python 类class学习总结（程序验证，超详细，包括多继承、循环、super（）.xxx等）

最新推荐文章于 2024-08-16 20:23:56 发布

鸡丝米线

最新推荐文章于 2024-08-16 20:23:56 发布

阅读量1.2k

点赞数 4

分类专栏： python 文章标签： python

本文链接：https://blog.csdn.net/qq_43659401/article/details/121379869

版权

python 专栏收录该内容

7 篇文章 0 订阅

订阅专栏

python类class学习总结（程序验证，超详细，包括多继承、循环、super（）.xxx等） ps：作者是很用心写的，如果觉得不错，请给作者一点鼓励噢！（点赞收藏评论噢）

1 类
2 类变量和实例变量
3 继承
- 3.1多继承
4 循环

ps：作者是很用心写的，如果觉得不错，请给作者一点鼓励噢！（点赞收藏评论噢）

1 类

类的定义：用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。
通俗来说，假设我们定义一个person类，这个类可以包括姓名、学号、爱好等这些称之为属性，这个类还可以包括比如通过学号判断打印入学年份，这个称之为方法。

类的语法格式如下

	class ClassName:
		语句1
		...
		语句n

(1)一个对象的特征称为"属性"
(2)一个对象的行为称为"方法"
(3)属性在代码层面上来看就是变量，方法实际就是函数，通过调用这些函数来完成某些工作
(4)语句n可能是内部变量(数据、属性)的定义和赋值语句，也可能是内部方法(函数)的定义语句

示例：
随便写了一段程序，尝试了各种用法

class Person(object):
    #class 是关键字（表示要开始创建类了），Cc是新建的类名称，object为类的继承，没有合适的继承类用object类，这是所有类最终会继承的类
    country='China'#类变量，所有实例共有
    def __init__(self, name, age):#__init__ 用于初始化对象。第一个参数是self，实例化时不用实际传参，self在__init__里面代表实例的本身，后面的参数正常传递
        #它是一个实例被创建时最先被调用的函数，并且每次创建实例，它的__init__都会被调用，而且它的第一个参数永远是 self，指向创建的实例本身。
        self.name = name#实例变量，每个实例特有
        self.age=age
        self.province='Shaanxi'
    def greet(self):
        print("Hi, my name is %s. I come from %s,%s. And I am %d" %(self.name,self.province,self.country,self.age))
    def hobby(self,hobby):
        self.hobby=hobby
        print("I feel like %s"%self.hobby)
    def repeat(self):
        print("Hi, my name is %s. I come from %s,%s. I am %d. And I feel like %s"%(self.name,self.province,self.country,self.age,self.hobby))
        #调用self.hobby可以在其他方法中使用，但是如果是hobby就只在该方法作用域内起作用
if __name__=='__main__':
    a=Person('Lisa',20)#类的实例化
    a.greet()#类的引用
    a.hobby('runing')
    a.repeat()

输出：
Hi, my name is Lisa. I come from Shaanxi,China. And I am 20
I feel like runing
Hi, my name is Lisa. I come from Shaanxi,China. I am 20. And I feel like runing

self.name = name表示：将外部传来的变量name的值赋值给当前实例对象的name属性(两个name之间无任何关系，只是变量名一致)
    ⑴name：只是一个形参，用来接收外部传入的实参值
    ⑵self.name：表示当前实例对象的实例属性(当前是哪个实例对象，就表示哪个实例对象的实例属性)

2 类变量和实例变量

例如上述例子country是类变量，所有实例共有。name是实例变量，个体特有。在调用一个类中的属性时，Python会先在当前实例中找，然后再到类中找。
示例：


class C:
    count = 0
a = C()
b = C()
c = C()
print(a.count,b.count,c.count)   #output:0,0,0
 
a.count += 10   #实例对象调用类属性
print(a.count,b.count,c.count)   #output:10,0,0
 
C.count += 100  #类对象调用类属性
print(a.count,b.count,c.count)   #output:10 100 100

对实例对象的count属性进行赋值后，就相当于覆盖了类对象C的count属性，如果没有赋值覆盖，那么引用的就是类对象的count属性
⑴通过"实例对象名.属性名"来覆盖类属性，只会影响到当前实例对象，不会影响到其他实例对象中的类属性
⑵通过"类名.属性名"来覆盖类属性，会影响到所有实例的类属性
⑶因此在类外调用类变量时，最好使用"实例对象名.属性名"，避免在重新赋值时影响到其他实例

类变量和实例变量的区别在于：类变量是所有对象共有，其中一个对象将它值改变，其他对象得到的就是改变后的结果；而实例变量则属对象私有，某一个对象将其值改变，不影响其他对象

该部分参照博客：https://blog.csdn.net/qq_39314932/article/details/80716295

3 继承

当我们已经创建了一个类，而又想再创建一个与之相似的类，比如添加几个方法，或者修改原来的方法，这时我们不必从头开始，可以从原来的类派生出一个新的类，我们把原来的类称为父类（基类 BaseClassName），而派生出的类称为子类（派生类 DerivedClassName），子类继承了父类的所有数据和方法（初始化和其他函数）。

示例：
我们前面已经定义了一个Person类，现在定义一个Person的子类Student

class Person(object):
    #class 是关键字（表示要开始创建类了），Cc是新建的类名称，object为类的继承，没有合适的继承类用object类，这是所有类最终会继承的类
    country='China'
    def __init__(self, name, age):#__init__ 用于初始化对象。第一个参数是self，实例化时不用实际传参，self在__init__里面代表实例的本身，后面的参数正常传递
        #它是一个实例被创建时最先被调用的函数，并且每次创建实例，它的__init__都会被调用，而且它的第一个参数永远是 self，指向创建的实例本身。
        self.name = name
        self.age=age
        self.province='Shaanxi'
    def greet(self):
        print("Hi, my name is %s. I come from %s,%s. And I am %d" %(self.name,self.province,self.country,self.age))
    def hobby(self,hobby):
        self.hobby=hobby
        print("I feel like %s"%self.hobby)
    def repeat(self):
        print("Hi, my name is %s. I come from %s,%s. I am %d. And I feel like %s"%(self.name,self.province,self.country,self.age,self.hobby))

class Student(Person):
    def id(self,school,number):
        self.number=number
        self.school=school
        print("My name is %s. I am a student of %s. And my student id is %s"%(self.name,self.school,self.number))
    
if __name__=='__main__':
    a=Person('Lisa',20)
    a.greet()
    a.hobby('runing')
    a.repeat()
    b=Student('Tom',18)
    b.id('Xidian University',18392389)
    b.greet()#子类继承了父类的所有方法，函数
    print(b.country)#子类继承了父类的所有方法,包括一开始的赋值
    print(b.name)#子类继承了父类的所有方法，初始化方法

输出：
Hi, my name is Lisa. I come from Shaanxi,China. And I am 20
I feel like runing
Hi, my name is Lisa. I come from Shaanxi,China. I am 20. And I feel like runing
My name is Tom. I am a student of Xidian University. And my student id is 18392389
Hi, my name is Tom. I come from Shaanxi,China. And I am 18
China

但是，如果我们在子类里面重新定义了初始化 def init（）函数（）（如果初始化的逻辑与父类的不同），那么子类就不再会继承父类 def init（）里面的内容，也就是说python在查找方法时，会先子类里面查找，如果子类有这个函数就用子类的，如果子类没有，再去查找父类里面的这个函数。
例如下面这个例子：

class Root(object):
    def __init__(self):
        self.x= '这是属性'
    def fun(self):
    	#print(self.x)
        print('这是方法')
class A(Root):
    def __init__(self):
        #super().__init__()
        #super().fun()
        print('实例化时执行')
test = A()	#实例化类
test.fun()	#调用方法
print(test.x)

输出：
实例化时执行
这是方法
Traceback (most recent call last):
  File "F:/shiyan.py", line 14, in <module>
    print(test.x)
AttributeError: 'A' object has no attribute 'x'

**分析：**出现报错，为什么A里面没有x这个属性呢？因为我们在写程序的时候子类里面重新初始化代替父类里面的初始化了，而我们重新定义的初始化函数里面没有x属性，所以程序报错。
那么如果在子类里面重新初始化了，但是我们还想用到父类里面的初始化内容，怎么办呢？
在子类初始化函数里面加上super(Class, self).init()
ps：Python 3 可以使用直接使用 super().xxx 代替 super(Class, self).xxx
示例：

class Root(object):
    def __init__(self):
        self.x= '这是属性'
    def fun(self):
    	#print(self.x)
        print('这是方法')
class A(Root):
    def __init__(self):
        super().__init__()#相比上一个程序，新添加的一行代码
        #super().fun()
        print('实例化时执行')
test = A()	#实例化类
test.fun()	#调用方法
print(test.x)

输出：
实例化时执行
这是方法
这是属性

完美解决报错！
注意，super().xxx里面xxx，对于上一段代码可以是_init_（）,可以是fun（），但是不能是_init_里面的内容x
示例：

class Root(object):
    def __init__(self):
        self.x= '这是属性'
    def fun(self):
    	#print(self.x)
        print('这是方法')
        def hello(self):
            print("hello")
class A(Root):
    def __init__(self):
        super().__init__()
        super().fun()
        print('实例化时执行')
        #print(self.x)
test = A()	#实例化类
test.fun()	#调用方法
print(test.x)

输出：
这是方法
实例化时执行
这是方法
这是属性

3.1多继承

看下面这个例子：

class A:
    def __init__(self):
        self.n = 2

    def add(self, m):
        print('self is {0} @A.add'.format(self))
        self.n += m


class B(A):
    def __init__(self):
        self.n = 3

    def add(self, m):
        print('self is {0} @B.add'.format(self))
        super().add(m)
        self.n += 3

输出：
self is <__main__.D object at 0x00000271287D3FA0> @D.add
self is <__main__.D object at 0x00000271287D3FA0> @B.add
self is <__main__.D object at 0x00000271287D3FA0> @C.add
self is <__main__.D object at 0x00000271287D3FA0> @E.add
self is <__main__.D object at 0x00000271287D3FA0> @A.add
21

分析：
在这里插入图片描述

4 循环

如果于for…in循环，这时我们需要在类中定义__iter__和__next__方法。其中，__iter()__方法返回迭代器对象本身__next()__方法返回容器的下一个元素
示例：斐波那契数列

class Fib():
    def __init__(self):
        self.a, self.b = 0, 1
    def __iter__(self):
        return self
    def __next__(self):
        self.a, self.b = self.b, self.a + self.b
        return self.a

fib = Fib()
for i in fib:
    if i > 3: 
         break
    print(i)