学习python入门基础——类和对象

本文主要是介绍学习python入门基础——类和对象，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

一、概念
　　1.1、类
　　　　拥有相同属性和功能的对象的集合，一类事物的抽象
　　　　命名：用大驼峰（例如：Test01）
　　1.2、对象/类实例
　　　　类的实体(类的具体)
　　1.3、封装
　　　　隐藏了对象的属性和实现细节，只是对外提供接口或者入口
二、类的创建
　　　　class 类名称:
　　　　class 类名称():

class Dog:

三、属性
　　3.1、类属性
　　　　1、概念：定义在类里面，在方法（函数）外面的属性
　　　　2、类属性访问
　　　　　　1）类.类属性名称
　　　　　　2）实例.类属性名称

　　3.2、实例属性
　　　　1、概念：定义在__init__（初始化方法）中，self.xxxx
　　　　2、实例属性访问
　　　　　　1）在类里面访问：self.实例方法
　　　　　　2）在类外面访问：类().实例方法
　　　　　　3）类不能访问实例属性
　　3.3、私有属性
　　　　1、概念：不能被外部访问的属性或者不想让子类继承的属性，通过双下划线命名
　　　　2、类的私有属性：__类属性名称　　　　　　
　　　　3、实例私有属性：self.__实例属性名称

class Dog:
    name='小黑'            #类属性，属性可全局使用
    __dog_color='白色'     #类私有属性

    def __init__(self):      #初始化方法，会自动调用，属性可全局使用
        self.color='黑色'       #实例属性
        self.__kind='中华田园犬'     #实例私有属性
        print('初始化方法')
    #实例方法
    def eating(self):
        print(Dog.name,'正在吃骨头。。。')      #类属性访问：类.类属性名称
        print('狗颜色',self.color)
        self.sleep()              #在类里面用实例（self）调用实例方法（self.实例方法）
    def sleep(self):
        print('类私有属性',Dog.__dog_color)       #类私有属性访问
        print('类实例私有属性',self.__kind)        #类实例私有属性访问
if __name__=='__main__':              #函数入口，被其他调用时，这个下面的是不会访问的
    a=Dog()              #实例化
    print(a.name)        #类属性访问：类实例.类属性名称
    print(a.eating())          #在类外面用类实例调用实例方法（类().实例方法）
    print(a.sleep())        #类实例私有属性不能在外访问，只能通过调用类实例方法　　　　　　

四、方法
　　4.1、初始化方法：__init__(self)
　　　　1、用于创建实例属性，在类实例化后自动调用，执行完后才会执行调用函数
　　　　2、self：类实例本身，是个占位符，可写任意，习惯写法写self
　　4.2、实例方法
　　　　1、概念：定义在类中，第一个参数【实例对象】，习惯用self来表示类实例
　　　　2、调用：实例.方法()

class Test:
    color='白色'                #类属性
    def __init__(self):        #初始化方法，用于创建实例属性，在实例化后自动执行
        self.color='heise'     #实例属性
        self.name='2021'       #实例属性
        print(self.name,self.color)     #self.实例方法
    def test01(self):           #实例方法
        print('test01方法')
        return 0
    def test02(self):       #实例方法
        self.test01()      #函数调用（类里面）
if __name__ == '__main__':
    a=Test()        #实例化
    a.test02()       #函数调用（类外面）

　　4.3、类方法
　　　　1、概念：定义在类中，通过@classmethod修饰之后的方法，第一个参数是类本身，习惯用cls占位，cls类本身
　　　　2、调用
　　　　　　1）类.类方法
　　　　　　2）类实例.类方法

　　　　3、与实例方法的区别

　　　　　　1）类方法可以用类或类实例调用，实例方法只能实例化调用

　　　　　　2）类方法可以用类属性，但不能用实例属性

　　　　　　3）类方法通常用cls占位，实例方法通常用self占位，要区分开

class Test01:
    name='大黄'
    def test01(self):　　　　　　　　　#实例方法，self实例本身
        self.color='黄色'
        return self.color

    @classmethod          　　　　　　#定义在类中，通过@classmethod修饰之后的方法，叫类方法
    def test02(cls):         　　　　#类方法，cls类本身
        print('test02')

if __name__ == '__main__':
    print(Test01.name)　　　　　#可以直接调用类属性
    Test01.test02()            #可以直接同类调用类方法（类.类方法）
    Test01().test02()          #也可以用类实例调用类方法（类实例.类方法）

　　4.4、静态方法
　　　　1、概念：定义在类中，通过@staticmethod修饰后的方法，没有参，没有self，cls（类和类实例）
　　　　2、调用
　　　　　　1）类.静态方法
　　　　　　2）类实例.静态方法
　　　　3、与类方法的区别
　　　　　　1）相同点
　　　　　　　　都是在类里，可以通过类直接调用
　　　　　　　　都可以被实例调用
　　　　　　2）不同点
　　　　　　　　类方法可以使用类的属性和静态方法
　　　　　　　　静态方法不可以使用类的属性和方法
　　　　　　3）使用场景：当类不能重复初始化时，可以使用类方法和静态方法

class Test01:
    name='大黄'
    def test01(self):
        self.color='黄色'
        return self.color

    @classmethod          #定义在类中，通过@classmethod修饰之后的方法，叫类方法
    def test02(cls):         #cls是类本身，无法使用实例方法，实例属性
        print('test02')
        cls.test03()          #使用静态方法
        return cls.name         #使用类属性

    @staticmethod          #定义在类中，通过@staticmethod修饰后的方法，叫静态方法，可以不传参，没有类，实例
    def test03():           #无法使用类属性、类方法、实例方法
        print('test03')

if __name__ == '__main__':
    print(Test01().test02())     #用类或类实例调用类方法（类/类实例.类方法）
    print(Test01().test01())           #只能类实例化后调用实例方法（类实例.实例方法）
    Test01.test03()            # 可以直接同类调用静态方法（类.静态方法）
    Test01().test03()          # 也可以用类实例调用静态方法（类实例.静态方法）

　　4.5、私有方法
　　　　1、概念：不想让子类继承的方法，通过双下划线命名
　　　　2、私有方法：__私有方法(self)

__sleep(self):

五、使用场景
　　5.1、类属性/方法：不需要实例化，不能重复初始化，直接访问类的属性和方法
　　　　
　　5.2、实例属性/方法：全局使用属性，类里面的方法相互调用，使用实例属性和方法
　　　　
　　5.3、私有属性/方法：封装过程中避免类内部的方法被外部错误使用
　　　　
六、类的特性
　　6.1、继承
　　　　6.1.1、单继承
　　　　　　1、概念：子类只继承一个父类后，就可用父类的属性和方法（私有属性和私有方法不能被继承）
　　　　　　2、语法：class 函数2(函数1):
　　　　　　　　　　  函数2是子类，函数1是父类，函数2继承函数1

class Test02(Test01):           #Test02继承Test01

　　　　　　3、子类调用父类方法
　　　　　　　　1）在子类里面调用：self.属性/方法
　　　　　　　　　  如果子类和父类有相同名称的属性或方法，优先使用子类自己的属性或方法
　　　　　　　　2）在子类外面调用：类实例.方法
　　　　　　　　3）super().属性/方法
　　　　　　　　　  直接从父类寻找对应的方法和属性
　　　　　　4、如果不写继承的类，则默认继承python的基类（object）

例1：
class Test01:
    def __init__(self):
        self.name='静静的'
        print(self.name)
    def test01(self):
        print('吃饭')
    def test02(self):
        print('睡觉')

class Test02(Test01):           #Test02继承Test01
    def __init__(self):
        super().__init__()     #从子类里面调用，直接去父类调用方法
        self.test02()         #从子类里面调用，先在子类方法里调用，没有再去父类
if __name__ == '__main__':
    b=Test02 ()
    b.test01()                  #从子类外面调用

例2：
class Test01:
    def __init__(self):
        print('Test01>>>初始化')
    def test01(self):
        print('Test01>>>test01')
    def __test02(self):
        print('Test01>>>__test02')
class Test02(Test01):                     #Test02继承Test01
    def __init__(self):
        print('Test02>>>初始化')
    def test01(self):
        print('Test02>>>test01')
    def test03(self):
        print('Test02>>>test03')
        self.test01()                     #self.方法时，若子类本身有该方法就用自己的，没有则用父类的
        super().__init__()                #super().__init__()用来直接调用父类的初始化方法
        super().test01()                  #super().方法，直接调用父类的方法
if __name__ == '__main__':
    a=Test02()
    a.test01()
    a.test03()

　　　　6.1.2、多继承
　　　　　　1、概念：子类继承多个父类，就会继承父类的所有属性和方法（私有属性和私有方法不能被继承）
　　　　　　2、语法：class 函数3(函数1,函数2):
　　　　　　　　函数3是子类，函数1和函数2都是父类

class Test03(Test02,Test01):                #Test03继承Test02和Test01

　　　　　　3、根据继承顺序调用

class Test01:
    def test01(self):
        print('Test01>>>test01')
    def test02(self):
        print('Test01>>>test02')
class Test02():　　　　　　　　　　　　　　　　　　#不写继承的类，则默认继承python的基类（object），即class Test02()与class Test02(object)一致
    def test01(self):
        print('Test02>>>test01')
    def test03(self):
        print('Test02>>>test03')
class Test03(Test02,Test01):                #根据继承的顺序来优先调用，即Test02在前，调用时优先调用Test02的方法
    def test04(self):
        print('Test02>>>test04')
if __name__ == '__main__':
    a=Test03()
    a.test01()

　　6.2、封装
　　　　1、概念：实现细节不会暴露出来，只告诉你一个接口，使用这个接口就能实现操作
　　　　2、调用接口就是封装
　　6.3、多态
　　　　1、概念：同名方法在不同类中，调用时只需要传递对应的类实例，就能实现调用不同的方法
　　　　2、一个方法多种实现
七、动态设置属性
　　7.1、获取对象所有属性
　　　　1、可以获取类和类实例的属性：类/类实例.__dict__

class Test01:
    color='黑色'
    def __init__(self,name,age):
        self.name=name
        self.age=age
if __name__ == '__main__':
    cl=Test01('老王',20)
    print(cl.__dict__)                     #获取类实例的所有属性
    print(Test01.__dict__)                 #获取类的所有属性

　　7.2、设置属性
　　　　1、设置属性：setattr(x, y, v)
　　　　　　1）第一个参数：对象（类、类实例）
　　　　　　2）第二个参数：属性名称
　　　　　　3）第三个参数：属性的值，若属性名称存在，则修改属性的值，若不存在，则添加

class Test01:
    color='黑色'
    def __init__(self,name,age):
        self.name=name
        self.age=age
if __name__ == '__main__':
    cl=Test01('老王',20)
    setattr(cl,'name','男')                   #设置实例属性，若属性存在则修改，若不存在则添加属性
    print(cl.__dict__)
    setattr(Test01,'sex','男')                  #设置类属性，若属性存在则修改，若不存在则添加属性
    print(Test01.__dict__)

　　　　2、获取属性：getattr(x, y, v)
　　　　　　1）第一个参数：对象（类、类实例）
　　　　　　2）第二个参数：属性名称
　　　　　　3）第三个参数：默认值，若属性存在，则返回属性的值，若属性不存在，会返回默认值，不会新增

class Test01:
    color='黑色'
    def __init__(self,name,age):
        self.name=name
        self.age=age
if __name__ == '__main__':
    cl=Test01('老王',20)
    print(getattr(cl,'name123','no attribute'))    #获取实例属性，若属性存在，则返回属性的值，若属性不存在，则返回no attribute，可以随便填
    print(getattr(cl,'name','男'))
    print(getattr(Test01, 'color', '男'))            #获取类属性，若属性存在，则返回属性的值，若属性不存在，则返回默认值

　　　　3、判断属性：hasattr(x,y)
　　　　　　1）第一个参数：对象（类、类实例）
　　　　　　2）第二个参数：属性名称
　　　　　　3）返回：属性存在，则返回True，属性不存在，则返回False

class Test01:
    color='黑色'
    def __init__(self,name,age):
        self.name=name
        self.age=age
if __name__ == '__main__':
    cl=Test01('老王',20)
    print(hasattr(cl,'test'))               #判断实例属性是否存在，若存在返回True，若不存在，返回False
    print(hasattr(Test01, 'color'))         #判断类属性是否存在，若存在返回True，若不存在，返回False

　　　　4、删除属性：delattr(x,y)
　　　　　　1）第一个参数：对象（类、类实例）
　　　　　　2）第二个参数：需要删除的属性名称

class Test01:
    color='黑色'
    def __init__(self,name,age):
        self.name=name
        self.age=age
if __name__ == '__main__':
    cl=Test01('老王',20)
    delattr(cl,'name')                    #删除实例属性
    print(cl.__dict__)
    delattr(Test01, 'color')              #删除类属性
    print(Test01.__dict__)

这篇关于学习python入门基础——类和对象的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！