标签：__ 入门 python self name 对象 实例 Test01 属性

一、概念
　　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,self,name,对象,实例,Test01,属性
来源： https://www.cnblogs.com/mango-93/p/16370827.html

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。