python-类

创建类

class Foo:              #class是关键字 foo是类名

x=1

#创建类中函数

def bar(self):       #self特殊参数(必填)

pass

根据类Foo创建对象obj

obj=foo

class Dog():

def __init__(self, name, age):

self.name = name

self.age = age

def sit(self):

print(self.name+‘我蹲下‘)

def roll_over(self):

print(self.name+‘打滚‘)

def __init__(self,*args):方法:

是【初始化方法】方法，每当你根据Dog 类创建新实例时，Python都会自动运行它

self.name=args[0]   self.name是变量，以self 为前缀的变量都可供类中的所有方法使用【类变量】【self就是对象的引用，在类内部调用属性和方法通过self来调用，就是存储属性的字典】，我们还可以通过类的任何实例来访问这些变量。像这样可通过实例访问的变量称为属性

类中的每个属性都必须有初始值

在这个方法中定义的参数，就是创建对象要输入的参数

属性可以是另一个类的对象

def __del__(self):方法    析构函数

是对象销毁前执行的方法

def __str__(self):方法   修改输出对象时的输出信息

tom=Cat(‘Tom‘)    print(tom)    输出某对象时：

<__main__.Cat object at 0x02EDCA50>

默认输出信息：类名   地址

要修改输出信息就在这个方法中修改：必须返回一个字符串

例：

def __str__(self):

        return ‘我是%s‘%self.name

def __repr__(self):   是__str__(self)的备胎

在调用__str__(self)函数时，如果__str__(self)不存在，就先找本类的__repr__(self):，再找父类的__str__(self)，再找父类的__repr__(self)  依次类推

必须返回一个字符串

__new__         给对象分配空间，返回对象的引用

创建对象时，会自动执行

重写时一定要返回对象的地址

例子

    def __new__(cls, *args, **kwargs):

        print(‘创建对象，分配空间‘)

        instance=super().__new__(cls)     # 给对象分配空间,instance是用来保存对象地址的

        return instance                   #返回对象地址

alex.__dict__    保存对象的属性

用来存储对象属性的一个字典，其键为属性名，值为属性的值

用这个字典可以查看属性，修改属性

person. __dict__   保存类的属性

用来存储类属性的一个字典，其键为属性名，值为属性的值

用这个字典可以查看属性，不能修改属性

s=isinstance(a,A)   判断a是不是类A的对象

是  返回true，不是返回false

isinstance() 与 type() 区别：

type() 不会认为子类是一种父类类型，不考虑继承关系。

isinstance() 会认为子类是一种父类类型，考虑继承关系。

如果要判断两个类型是否相同推荐使用 isinstance()

例子

>>>a = 2

>>> isinstance (a,int)

True

>>> isinstance (a,str)

False

>>> isinstance (a,(str,int,list))    # 是元组中的一个返回 True

True

issubclass(class, classinfo)     判断参数 class 是否是classinfo 的子类

如果 class 是 classinfo 的子类返回 True，否则返回 False。

方法的定义和调用

class person:

    country=‘中国‘      #类属性  也叫静态属性

    def __init__(self,*args):

        self.name=args[0]    #对象属性

        self.hp=args[1]

        self.aggr=args[2]

        self.sex=args[3]

    def walk(self,n):                   #【对象方法：属于对象】

        print(‘%s走走,走了%s‘%(self.name,n))

        return ‘aa‘alex=person(‘狗剩儿‘,100,1,‘不祥‘)

s=person.walk(alex,n10)     #类名.方法名(对象名)

s=alex.walk(10)  等价于s=person.walk(alex)       #对象名.方法名()

print(s)

说明：self属性属于对象属性，用 对象名.属性名 来调用

类属性属于类   用 类名.属性名 来调用，[也可以用 对象名.属性名 来调用,但是不建议]

类方法

@classmethod   #表示下方的方法是类方法

def 方法名(cls):      #第一个参数必须是cls

pass

一般用来访问修改类属性的

调用方法：类名.方法名()

静态方法：不需要实例化就能运行

 @staticmethod    #表示下方的方法是静态方法

def 方法名():

pass

参数可有可无

调用：类名.方法名()

例子

class login:

    @staticmethod    #下面的方法是静态方法，不需要实例化就能运行

    def get(name,pwd):

        print(name,pwd)

login.get(‘lm‘,123456)  #调用：类名.方法名()

私有属性和方法   __xxx

在属性名称和方法名称前面增加两个下划线

其实这种私有是伪私有  在私有属性前面加上 _类名  就可以在外部访问了

例  

xiaofang是对象    Women是类  __age是私有属性

私有属性和方法只能在类内使用，不能被继承，子类不能访问父类的私有属性和方法

_xxx      "单下划线 "   保护变量

只有类对象（即类实例）和子类对象自己能访问到这些变量，需通过类提供的接口进行访问；不能用‘from module import *‘导入

del 对象名         删除一个对象

在对象外部给对象增加属性【不推荐】

tom.name=‘Tom‘

给对象tom增加属性name

继承

格式：   class 子类名(父类名):

pass

多继承

   class 子类名(父类名,父类名2):

pass

父类之间尽量避免同名的属性和方法，如果有同名的，以前面的类为准

B.__bases__   返回父类    <class ‘__main__.A‘>,

属性的派生   方法的重写

父类中没有的属性，子类中有的属性叫派生属性

父类中没有的方法，子类中有的方法叫派生方法

注意：先在本地找，本地没有再往上找

例子

class A:

    def __init__(self,name,age,id):

        self.name=name

        self.age=age

        self.id=id

    def y(self):

        print(‘父函数‘)

class B(A):

    def __init__(self,name,age,id,gongzi):  #参数要包含父类参数和派生参数

        #A.__init__(self,name,age,id)    #启用父类属性，要加上self参数

        super().__init__(name,age,id)    #启用父类属性，不要加上self参数

        self.gongzi=gongzi              #派生属性

    def y(self):                     #函数的重写

        print(‘子函数‘)

        #A.y(self)                      #调用父函数，要加上self参数

        super().y()                   #调用父函数，不要加上self参数

d=B(‘李明‘,50,120107196801041510,8000)

d.y()

print(d.name)

说明：

多继承时super()的指向：广度优先

super()在类内使用不需要参数；在类外使用需要类和对象两个参数

super(B,d).y()   表示执行B类的对象d的函数y()

C.mro()    返回C类的继承顺序

C可是是类名 也可以是对象名

多继承

接口类

说明：Payment的子类必须拥有@abstractmethod下的同名函数

抽象类

从一堆类中抽取相同的内容的类，内容包括数据属性和函数属性

抽象类是一个特殊的类，它的特殊之处在于只能被继承，不能被实例化

从实现角度来看，抽象类与普通类的不同之处在于：抽象类中有抽象方法，该类不能被实例化，只能被继承，且子类必须实现抽象方法

例子

import abc  #利用abc模块实现抽象类

class cxl(metaclass=abc.ABCMeta):

    all_type=‘file‘

    @abc.abstractmethod #定义抽象方法，无需实现功能

    def read(self):   #子类必须拥有的函数

        pass

    @abc.abstractmethod  # 定义抽象方法，无需实现功能

    def write(self):    #子类必须拥有的函数

        pass

class Txt(cxl):  #子类继承抽象类，但是必须定义read和write方法

    def read(self):

        print(‘文本数据的读取方法‘)

    def write(self):

        print(‘文本数据的写入方法‘)

class Sata(All_file): #子类继承抽象类，但是必须定义read和write方法

    def read(self):

        print(‘硬盘数据的读取方法‘)

    def write(self):

        print(‘硬盘数据的写入方法‘)

class Process(All_file): #子类继承抽象类，但是必须定义read和write方法

    def read(self):

        print(‘进程数据的读取方法‘)

    def write(self):

        print(‘进程数据的写入方法‘)

python-类

原文：https://www.cnblogs.com/liming19680104/p/10649110.html