python类和对象

概述python类和对象Python和java一样，是面向对象的编程语言，也有类和对象，且概念是一样的。Python中所有的类型都是一个类，所有的变量也都是对象的引用在类中的函数叫方法，而独立的函数就叫函数，本质上没有区别创建类创建一个类的语法如下class类名: 类的成员类名开头字母要 python类和对象

Python和java一样，是面向对象的编程语言，也有类和对象，且概念是一样的。

Python中所有的类型都是一个类，所有的变量也都是对象的引用

在类中的函数叫方法，而独立的函数就叫函数，本质上没有区别

---

创建类

创建一个类的语法如下

class 类名:	类的成员

类名开头字母要大写，这虽然不是语法要求，但这是程序员间约定俗成的，注意冒号与缩进

---

创建对象

创建一个对象类似于函数的调用，如下

class A:    def fun(self):        print('我真帅')x = A()x.fun()

其实这种方式相当于调用了A类的构造方法

---

self

Python中的self和java的this指针很相似，都是指代当前的对象

通常情况下，类里面的方法第一个参数必须是self，但在通过对象使用方法时，Python会自动为self赋值，因此我们不用亲自为self赋值

其实在类的方法中，第一个参数就是指代当前类的实例对象，并不一定要使
用self，使用self是程序员约定俗成的做法

---

构造方法__init__

Python的构造函数叫__init__，同样第一个参数为self，在实例化类生成对象时会自动调用，没有也不能有返回值

默认的构造函数里只有一个self参数，里面什么也没有

在生成对象时，类名后面的括号里就是构造函数的参数，语法如下

对象名 = 类名(构造函数的参数)

举个例子

class A:    x = '123'    def __init__(self,s):        self.x = sa = A('456')print(a.x)# 456

---

私有成员

与java不同，Python中并没有private，public这两个关键字，但这不意味着它所有成员都是公有的

定义一个私有成员，只需要在其名字前面加上两个下划线__即可，这样，就无法从外部来直接访问这个成员了

注意：Python的私有其实是一种伪私有，本质上只是自动把成员的名字改成了_类名__成员名，因此我们完全可以通过改变后的名字来访问成员，举个例子

class A:    __x = '123'    a = A()try:    print(a.__x)except AttributeError:    print('没有找到__x')try:    print(a._A__x)except AttributeError:    print('没有找到_A__x')# output: # 没有找到__x# 123

---

类，类对象和实例对象

类，类对象和实例对象其实都是不同的东西，我们一个个解释

类：类是一个抽象的概念类对象：当定义完类后，由于在Python中所有的东西都是对象，所以类也是一个对象，对象名就是类名实例对象：用类对象的构造方法来生成的对象就叫实例对象

---

绑定

当生成实例对象后，他会自动绑定类对象所拥有的方法和变量，但这些并不会作为实例对象的成员

当我们通过实例对象来调用绑定的方法时，这个对象会自动作为第一个参数，也就是self

当我们通过类对象来调用方法（非绑定调用）时，那他就跟调用函数一样，有几个参数就要传入几个参数，例如

当这个类对象被删除时，它的成员方法并不会被删除，也就是说它的实例对象依然可以使用成员方法和变量

class A:    email = '@.com'    def __init__(self,a):        self.name = '我是'+a    def fun1():        print('我是类A的方法')    def fun2(self):        print('我通过'+self.name+'调用fun2')        a = A('帅')A.fun1()A.fun2(a)del Aa.fun2()print(a.email)# output:# 我是类A的方法# 我通过我是帅调用fun2# 我通过我是帅调用fun2# @.com

---

继承

与java的继承一样，可以继承父类所有的成员，其语法如下

class 子类名(父类名):	类成员

如果子类中定义了与父类同名的方法或属性，则会自动覆盖掉父类对应的方法或属性，举个例子

class Parent:    name = '我是父类的属性'    def act1(self):        print('正在调用父类的方法')    def act2(self):        print('我是父类的方法')        class Child(Parent):    def act2(self):        print('我是子类的方法')p = Parent()c = Child()print(c.name)c.act1()p.act2()c.act2()# output:# 我是父类的属性# 正在调用父类的方法# 我是父类的方法# 我是子类的方法

Python也支持多重继承，一个子类可以拥有多个父类，其语法如下

class 子类名(父类名1,父类名2,父类名3,...)

使用多重继承时，如果两个父类有重名的方法，则继承时类名靠前的会覆盖掉类名靠后的

注意：当在父类里写了构造方法，而在子类中又写了一个构造方法，那么父类的构造方法将会被覆盖，不会执行

解决这个问题有如下两种方法

使用类对象来调用类的方法，其语法规则如下

类对象.方法名(对象)

例如

class Parent1:    name = '我是父类1'    def __init__(self):        print('父类1的构造方法')class Parent2:    name = '我是父类2'    def __init__(self):        print('父类2的构造方法')        class Child(Parent1,Parent2):    name = '我是子类'    def __init__(self):        Parent1.__init__(self)        Parent2.__init__(self)        print('子类的构造方法')    def act(self):        print(self.name)c = Child()p1 = Parent1()Child.act(p1)# output:# 父类1的构造方法# 父类2的构造方法# 子类的构造方法# 父类1的构造方法# 我是父类1

从这个例子可以看出，类方法的self参数并不关心你是不是这个类的实例对象，或者说Python中所有的函数形参都不关心类型，所以p1也可以作为Child中的act方法的实参

使用super()函数，super()函数可以调用父类的一个方法，其语法规则如下

super().父类的方法名(参数)

例如

class Parent1:    name = '我是父类1'    def __init__(self):        print('父类1的构造方法')class Parent2:    name = '我是父类2'    def __init__(self):        print('父类2的构造方法')    def act(self):        print(self.name)        class Child(Parent1,Parent2):        def __init__(self):        super().__init__()        print('子类的构造方法')        super().act()c = Child()# output:# 父类1的构造方法# 子类的构造方法# 我是父类1

从这个例子可以看出，多重继承的机制似乎是前面的继承后面的，也就是Parent1继承Parent2，Child再继承Parent1。而super().act()就是调用Parent1的act()，也就是说super()可以调用第一个继承的类的方法

从这两个例子可以很明显的看出这两种方法的优缺点

第一种优点：使用起来比较灵活，想调用哪个父类的方法就调用哪个父类的方法第一种缺点：我们在写的时候需要使用到父类名，当我们该表父类名的时候，子类的代码也需要改变，比较麻烦第二种优点：写起来方便，改起来也方便，当父类名改变时，子类的代码不需要变第二种缺点：当多个父类有重名方法时，由于靠后继承的会被靠前的覆盖，所以super只会执行靠前的父类的方法

---

有关类的内置函数

issubclass(class, classinfo)：class和classinfo是类对象，如果class是classinfo的一个子类，返回True，否则，返回False，有以下几个注意点。

一个类被认为是自身的子类classinfo可以是一个由类对象组成的元组，则会从前往后找class的父类，只要找到，就会停止查找，并返回True，若classinfo查找的时候遇到不是类对象的元素，则会报TypeError

class A:    pass#pass是一个占位符，什么都不做，只是美观class B(A):    passclass C:    passa = A()print(issubclass(B,A))try:    print(issubclass(B,(C,A,a)))#遇到a之前就找到了父类，停止了查找，所以没报错    print(issubclass(B,(C,a,A)))except TypeError:    print('classinfo中存在非类对象元素')# output# True# True# classinfo中存在非类对象元素

isinstance(object, classinfo)：判断实例对象object是不是类对象classinfo的的实例对象，若是，则返回True，否则，返回False，有以下几个注意点

如果object是一个类对象，则永远返回False类似于issubclass，classinfo也可以是一个由类对象组成的元组，判断的机制也相似，不再赘述子类的实例对象也属于父类的实例对象，但反过来不成立

class A:    passclass B(A):    passclass C:    passa = A()b = B()print(isinstance(a,A))print(isinstance(a,(C,A,b)))print(isinstance(a,B))print(isinstance(b,A))# output# True# True# False# True

hasattr(object, name)：判断实例对象object中是否存在name属性，如果有，则返回True，否则，返回False，例如

class C:    x = "我是C"    def y(self):        passc = C()print(hasattr(c, 'x'))print(hasattr(c, 'y'))print(hasattr(c, 'z'))# output:# True# True# False

getattr(object, name[, default])：如果实例对象object中存在name属性，则返回其值，否则，如果有参数default，则返回default，如果没有，就会报AttributeError，例如

class C:    x = "我是C"    def y(self):        passc = C()print(getattr(c, 'x'))print(getattr(c, 'y'))print(getattr(c, 'z','z不存在'))# output:# 我是C# <bound method C.y of <__main__.C object at 0x0000028DCDD63248>># z不存在

setattr(object, name, value)，将value对象赋值给实例对象object里的name属性，如果没有name属性，则会创建该属性，该函数没有返回值，例如

class A:    passclass C:    x = "我是C"    def y(self):        passc = C()a = A()setattr(c,'x','哈哈哈')setattr(c,'y','嘻嘻嘻')print(getattr(c, 'x'))print(getattr(c, 'y'))if(not hasattr(c,'z')):    setattr(c, 'z', a)    print(getattr(c, 'z'))else:    print(getattr(c, 'z'))# output:# 哈哈哈# 嘻嘻嘻# <__main__.A object at 0x0000015B48F53348>

delattr(object, name)：删除object对象中的name属性，若不存在，则报AttributeError，注意，这里不会把绑定的属性算在内，因为绑定的属性无法通过实例对象来删除，该函数没有返回值，例如

class C:    x = "我是C"    def __init__(self):        self.z = 'zzz'    def y(self):        passc = C()try:    delattr(c, 'x')except:    print('无法删除x')print(getattr(c, 'x', 'x不存在'))delattr(c, 'z')print(getattr(c,'z','z不存在'))# output:# 无法删除x# 我是C# z不存在

property(fget=None, fset=None, fdel=None,doc=None)：这个函数很特殊，它的返回值是一个对象，而fget，fset，fdel，doc都是一些方法，我们可以通过对返回的这个对象进行特定的 *** 作来调用这些方法，例如

class A:    def __init__(self):        self.name = '王'    def getname(self):        return self.name    def setname(self, name):        self.name = name    def delname(self):        del self.name    x = property(getname,setname,delname)a = A()print(a.x)a.x = '李'print(a.x)del a.xtry:    print(a.name)except AttributeError:    print('a.name不存在')a.x = '张'print(a.x)print(a.name)# output:# 王# 李# a.name不存在# 张# 张

我们可以看出，这种方式类似于 *** 作符重载，对 *** 作符进行了重新定义，所以当我们使用=时，会调用setname这个方法，当我们使用del时，会调用delname这个方法，使用property可以让你的程序更加简洁美观规范，同时维护更加方便

---

析构方法__del__

当一个对象没有引用指向它时，Python的垃圾回收机制会自动调用对象的析构方法，同时释放掉该对象所占用的空间，没有返回值，例如

>>> class A:    def __init__(self):        print('我是__init__')    def __del__(self):        print('我是__del__')>>> a1 = A()我是__init__>>> a2 = a1>>> a3 = a1>>> del a2>>> del a3>>> del a1我是__del__

---

创建对象方法__new__

在Python中，当你创建一个实例对象时，第一个调用的方法不是构造方法__init__，而是__new__，这个方法的语法如下

__new__(cls[, ...])

其中，cls是类对象，其返回值是一个对象，返回值默认是cls的实例对象

这个方法我们通常不用重写，只有当我们继承了一个系统内置的类时，且我们需要对其进行修改时，我们可以考虑重写它来实现需求，例如

class A(str):    def __new__(cls,string):        string = string.upper()        return str.__new__(cls,string)a = A('i love China')print(a)# I lovE CHINA

---

其他细枝末节

函数和方法的本质相同，但有一些区别

不同点是：方法是在类中定义的，函数是在类外面定义的，要使用必须通过一个对象去调用，方法的第一个参数必须是self，如果通过实例对象调用，则Python会自动为self赋值，如果通过类对象调用，则你必须自己给self赋值，且函数和方法的类型是不同的，方法可以访问一个对象里的私有成员，函数不行。相同点的是：他们执行的机制是相同的，包括参数传递机制，语法也类似，函数和方法的名字都是引用，类似于变量，指向了代码段，当我们在名字后加()时，他们会跑去代码段执行，并返回结果，例如

class A:    def fun(self):        print('ko no 方法 da')def fun():    print('ko no 函数 da')x = A()print(type(x.fun))print(type(fun))print(type(A.fun(x)))print(type(fun()))# output:# <class 'method'># <class 'function'># ko no 方法 da# <class 'nonetype'># ko no 函数 da# <class 'nonetype'>

总结

以上是内存溢出为你收集整理的python类和对象全部内容，希望文章能够帮你解决python类和对象所遇到的程序开发问题。

如果觉得内存溢出网站内容还不错，欢迎将内存溢出网站推荐给程序员好友。