先自我介绍一下,小编浙江大学毕业,去过华为、字节跳动等大厂,目前阿里P7
深知大多数程序员,想要提升技能,往往是自己摸索成长,但自己不成体系的自学效果低效又漫长,而且极易碰到天花板技术停滞不前!
因此收集整理了一份《2024年最新Python全套学习资料》,初衷也很简单,就是希望能够帮助到想自学提升又不知道该从何学起的朋友。
既有适合小白学习的零基础资料,也有适合3年以上经验的小伙伴深入学习提升的进阶课程,涵盖了95%以上Python知识点,真正体系化!
由于文件比较多,这里只是将部分目录截图出来,全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频,并且后续会持续更新
如果你需要这些资料,可以添加V获取:vip1024c (备注Python)
正文
1. class Animal ( object ):
2. def __init__ ( self , name ):
3. self . name = name
4. def greet ( self ):
5. print ‘Hello, I am %s.’ % self . name
现在,我们想创建一个 Dog 类,比如:
1. class Dog ( object ):
2. def __init__ ( self , name ):
3. self . name = name
4. def greet ( self ):
5. print 'WangWang…, I am %s. ’ % self . name
可以看到, Dog 类和 Animal 类几乎是一样的,只是 greet 方法不一样,我们完全没必要创建
一个新的类,而是从 Animal 类派生出一个新的类:
1. class Dog ( Animal ):
2. def greet ( self ):
3. print 'WangWang…, I am %s. ’ % self . name
Dog 类是从 Animal 类继承而来的, Dog 类自动获得了 Animal 类的所有数据和方法,而且还可以
对父类的方法进行修改,我们看看使用:
1. >>> animal = Animal ( ‘animal’ ) # 创建 animal 实例
2. >>> animal . greet ()
3. Hello , I am animal .
4. >>>
5. >>> dog = Dog ( ‘dog’ ) # 创建 dog 实例
6. >>> dog . greet ()
7. WangWang …, I am dog .
我们还可以对 Dog 类添加新的方法:
1. class Dog ( Animal ):
2. def greet ( self ):
3. print 'WangWang…, I am %s. ’ % self . name
4. def run ( self ):
5. print ‘I am running.I am running’
使用:
1. >>> dog = Dog ( ‘dog’ )
2. >>> dog . greet ()
3. WangWang …, I am dog .
4. >>> dog . run ()
5. I am running
3.2 多态
多态的概念其实不难理解,它是指对不同类型的变量进行相同的操作,它会根据对象(或类)类型的不同而表现出不同的行为。
事实上,我们经常用到多态的性质,比如:
1. >>> 1 + 2
2. 3
3. >>> ‘a’ + ‘b’
4. ‘ab’
可以看到,我们对两个整数进行 + 操作,会返回它们的和,对两个字符进行相同的 + 操作,
会返回拼接后的字符串。也就是说,不同类型的对象对同一消息会作出不同的响应。
再看看类的例子:
1. class Animal ( object ):
2. def __init__ ( self , name ):
3. self . name = name
4. def greet ( self ):
5. print ‘Hello, I am %s.’ % self . name
7. class Dog ( Animal ):
8. def greet ( self ):
9. print ‘WangWang…, I am %s.’ % self . name
11. class Cat ( Animal ):
12. def greet ( self ):
13. print ‘MiaoMiao…, I am %s’ % self . name
15. def hello ( animal ):
16. animal . greet ()
看看多态的使用:
1. >>> dog = Dog ( ‘dog’ )
2. >>> hello ( dog )
3. WangWang …, I am dog .
4. >>>
5. >>> cat = Cat ( ‘cat’ )
6. >>> hello ( cat )
7. MiaoMiao …, I am cat
可以看到, cat 和 dog 是两个不同的对象,对它们调用 greet 方法,它们会自动调用实
际类型的 greet 方法,作出不同的响应。这就是多态的魅力。
4 类方法和静态方法
在讲类方法和静态方法之前,先来看一个简单的例子:
1. class A ( object ):
2. def foo ( self ):
3. print 'Hello ’ , self
5. >>> a = A ()
6. >>> a . foo ()
7. Hello , < __main__ . A object at 0x10c37a450 >
在上面,我们定义了一个类 A ,它有一个方法 foo ,然后我们创建了一个对象 a ,并调用方法 foo 。
4.1 类方法
如果我们想通过类来调用方法,而不是通过实例,那应该怎么办呢?
Python 提供了 classmethod 装饰器让我们实现上述功能,看下面的例子:
1. class A ( object ):
2. bar = 1
3. @classmethod
4. def class_foo ( cls ):
5. print 'Hello, ’ , cls
6. print cls . bar
8. >>> A . class_foo () # 直接通过类来调用方法
9. Hello , < class ‘__main__.A’ >
10. 1
在上面,我们使用了 classmethod 装饰方法 class_foo ,它就变成了一个类方
法, class_foo 的参数是 cls ,代表类本身,当我们使用 A.class_foo() 时, cls 就会接
收 A 作为参数。另外,被 classmethod 装饰的方法由于持有 cls 参数,因此我们可以在方法
里面调用类的属性、方法,比如 cls.bar 。
4.2 静态方法
在类中往往有一些方法跟类有关系,但是又不会改变类和实例状态的方法,这种方法是静态方法,我们 使用 staticmethod 来装饰,比如下面的例子:
1. class A ( object ):
2. bar = 1
3. @staticmethod
4. def static_foo ():
5. print 'Hello, ’ , A . bar
7. >>> a = A ()
8. >>> a . static_foo ()
9. Hello , 1
10. >>> A . static_foo ()
11. Hello , 1
可以看到,静态方法没有 self 和 cls 参数,可以把它看成是一个普通的函数,我们当然可以把它
写到类外面,但这是不推荐的,因为这不利于代码的组织和命名空间的整洁。
5 定制类和魔法方法
在 Python 中,我们可以经常看到以双下划线 __ 包裹起来的方法,比如最常见的
__init__ ,这些方法被称为魔法方法( magic method )或特殊方法( special method )。简
单地说,这些方法可以给 Python 的类提供特殊功能,方便我们定制一个类,比如 __init__ 方
法可以对实例属性进行初始化。
完整的特殊方法列表可在 这里 查看,本文介绍部分常用的特殊方法:
__new__
__str__ , __repr__
__iter__
__getitem__ , __setitem__ , __delitem__
__getattr__ , __setattr__ , __delattr__
__call__
5.1 new
在 Python 中,当我们创建一个类的实例时,类会先调用 __new__(cls[, …]) 来创建实例,
然后 __init__ 方法再对该实例( self )进行初始化。
关于 __new__ 和 __init__ 有几点需要注意:
__new__ 是在 __init__ 之前被调用的;
__new__ 是类方法, __init__ 是实例方法;
重载 __new__ 方法,需要返回类的实例;
一般情况下,我们不需要重载 __new__ 方法。但在某些情况下,我们想控制实例的创建过程,这
时可以通过重载 __new_ 方法来实现。
让我们看一个例子:
1. class A ( object ):
2. _dict = dict ()
4. def __new__ ( cls ):
5. if ‘key’ in A . _dict :
6. print “EXISTS”
7. return A . _dict [ ‘key’ ]
8. else :
9. print “NEW”
10. return object . __new__ ( cls )
12. def __init__ ( self ):
13. print “INIT”
14. A . _dict [ ‘key’ ] = self
在上面,我们定义了一个类 A ,并重载了 __new__ 方法:当 key 在 A._dict 中
时,直接返回 A._dict[‘key’] ,否则创建实例。
执行情况:
1. >>> a1 = A ()
2. NEW
3. INIT
4. >>> a2 = A ()
5. EXISTS
6. INIT
7. >>> a3 = A ()
8. EXISTS
9. INIT
5.2 str & repr
先看一个简单的例子:
1. class Foo ( object ):
2. def __init__ ( self , name ):
3. self . name = name
5. >>> print Foo ( ‘ethan’ )
6. < __main__ . Foo object at 0x10c37aa50 >
在上面,我们使用 print 打印一个实例对象,但如果我们想打印更多信息呢,比如把 name 也打印
出来,这时,我们可以在类中加入 __str__ 方法,如下:
1. class Foo ( object ):
2. def __init__ ( self , name ):
3. self . name = name
4. def __str__ ( self ):
5. return ‘Foo object (name: %s)’ % self . name
7. >>> print Foo(‘ethan’) # 使用 print
8. Foo object ( name : ethan )
9. >>>
10. >>> str ( Foo ( ‘ethan’ )) # 使用 str
11. ‘Foo object (name: ethan)’
12. >>>
13. >>> Foo ( ‘ethan’ ) # 直接显示
14. < __main__ . Foo at 0x10c37a490 >
可以看到,使用 print 和 str 输出的是 __str__ 方法返回的内容,但如果直接显示则不是,
那能不能修改它的输出呢?当然可以,我们只需在类中加入 __repr__ 方法,比如:
1. class Foo ( object ):
2. def __init__ ( self , name ):
3. self . name = name
4. def __str__ ( self ):
5. return ‘Foo object (name: %s)’ % self . name
6. def __repr__ ( self ):
7. return ‘Foo object (name: %s)’ % self . name
9. >>> Foo ( ‘ethan’ )
10. ‘Foo object (name: ethan)’
可以看到,现在直接使用 Foo(‘ethan’) 也可以显示我们想要的结果了,然而,我们发现上面的代
码中, __str__ 和 __repr__ 方法的代码是一样的,能不能精简一点呢,当然可以,如下:
1. class Foo ( object ):
2. def __init__ ( self , name ):
3. self . name = name
4. def __str__ ( self ):
5. return ‘Foo object (name: %s)’ % self . name
6. __repr__ = __str__
5.3 iter
在某些情况下,我们希望实例对象可被用于 for…in 循环,这时我们需要在类中定义
__iter__ 和 next (在 Python3 中是 __next__ )方法,其中, __iter__ 返回一
个迭代对象, next 返回容器的下一个元素,在没有后续元素时抛出 StopIteration 异常。
看一个斐波那契数列的例子:
1. class Fib ( object ):
2. def __init__ ( self ):
3. self . a , self . b = 0 , 1
5. def __iter__ ( self ): # 返回迭代器对象本身
6. return self
8. def next ( self ): # 返回容器下一个元素
9. self . a , self . b = self . b , self . a + self . b
10. return self . a
12. >>> fib = Fib ()
13. >>> for i in fib :
14. … if i > 10 :
15. … break
16. … print i
17. …
18. 1
19. 1
20. 2
21. 3
22. 5
23. 8
5.4 getitem
有时,我们希望可以使用 obj[n] 这种方式对实例对象进行取值,比如对斐波那契数列,我们希望
可以取出其中的某一项,这时我们需要在类中实现 __getitem__ 方法,比如下面的例子:
1. class Fib ( object ):
2. def __getitem__ ( self , n ):
3. a , b = 1 , 1
4. for x in xrange ( n ):
5. a , b = b , a + b
6. return a
8. >>> fib = Fib ()
9. >>> fib [ 0 ], fib [ 1 ], fib [ 2 ], fib [ 3 ], fib [ 4 ], fib [ 5 ]
10. ( 1 , 1 , 2 , 3 , 5 , 8 )
我们还想更进一步,希望支持 obj[1:3] 这种切片方法来取值,这时 __getitem__ 方法传入的参数可能是一个整数,也可能是一个切片对象 slice ,因此,我们需要对传入的参数进行判断,可
以使用 isinstance 进行判断,改后的代码如下:
1. class Fib ( object ):
2. def __getitem__ ( self , n ):
3. if isinstance ( n , slice ): # 如果 n 是 slice 对象
4. a , b = 1 , 1
5. start , stop = n . start , n . stop
6. L = []
7. for i in xrange ( stop ):
8. if i >= start :
9. L . append ( a )
10. a , b = b , a + b
11. return L
12. if isinstance ( n , int ): # 如果 n 是 int 型
13. a , b = 1 , 1
14. for i in xrange ( n ):
15. a , b = b , a + b
16. return a
现在,我们试试用切片方法:
1. >>> fib = Fib ()
2. >>> fib [ 0 : 3 ]
3. [ 1 , 1 , 2 ]
4. >>> fib [ 2 : 6 ]
5. [ 2 , 3 , 5 , 8 ]
上面,我们只是简单地演示了 getitem 的操作,但是它还很不完善,比如没有对负数处理,不支持带
step 参数的切片操作 obj[1:2:5] 等等,读者有兴趣的话可以自己实现看看。
__geitem__ 用于获取值,类似地, __setitem__ 用于设置值, __delitem__ 用于删除
值,让我们看下面一个例子:
1. class Point ( object ):
2. def __init__ ( self ):
3. self . coordinate = {}
5. def __str__ ( self ):
6. return “point(%s)” % self . coordinate
8. def __getitem__ ( self , key ):
9. return self . coordinate . get ( key )
11. def __setitem__ ( self , key , value ):
12. self . coordinate [ key ] = value
14. def __delitem__ ( self , key ):
15. del self . coordinate [ key ]
16. print ‘delete %s’ % key
18. def __len__ ( self ):
19. return len ( self . coordinate )
21. __repr__ = __str__
在上面,我们定义了一个 Point 类,它有一个属性 coordinate (坐标),是一个字典,让我们看
看使用:
1. >>> p = Point ()
2. >>> p [ ‘x’ ] = 2 # 对应于 p.__setitem__(‘x’, 2)
3. >>> p [ ‘y’ ] = 5 # 对应于 p.__setitem__(‘y’, 5)
4. >>> p # 对应于 __repr__
5. point ({ ‘y’ : 5 , ‘x’ : 2 })
6. >>> len ( p ) # 对应于 p.__len__
7. 2
8. >>> p [ ‘x’ ] # 对应于 p.__getitem__(‘x’)
9. 2
10. >>> p [ ‘y’ ] # 对应于 p.__getitem__(‘y’)
11. 5
12. >>> del p [ ‘x’ ] # 对应于 p.__delitem__(‘x’)
13. delete x
14. >>> p
15. point ({ ‘y’ : 5 })
16. >>> len ( p )
17. 1
5.5 getattr
当我们获取对象的某个属性,如果该属性不存在,会抛出 AttributeError 异常,比如:
1. class Point ( object ):
2. def __init__ ( self , x = 0 , y = 0 ):
3. self . x = x
4. self . y = y
6. >>> p = Point ( 3 , 4 )
7. >>> p . x , p . y
8. ( 3 , 4 )
9. >>> p . z
10. ---------------------------------------------------------------------------
11. AttributeError Traceback ( most recent call last )
12. < ipython - input - 547 - 6dce4e43e15c > in < module >()
13. ----> 1 p . z
15. AttributeError : ‘Point’ object has no attribute ‘z’
那有没有办法不让它抛出异常呢?当然有,只需在类的定义中加入 __getattr__ 方法,比如:
1. class Point ( object ):
2. def __init__ ( self , x = 0 , y = 0 ):
3. self . x = x
4. self . y = y
5. def __getattr__ ( self , attr ):
6. if attr == ‘z’ :
7. return 0
9. >>> p = Point ( 3 , 4 )
10. >>> p . z
11. 0
现在,当我们调用不存在的属性(比如 z )时,解释器就会试图调用 __getattr__(self, ‘z’)
来获取值,但是,上面的实现还有一个问题,当我们调用其他属性,比如 w ,会返回 None ,因为
__getattr__ 默认返回就是 None ,只有当 attr 等于 ‘z’ 时才返回 0 ,如果我们想让
__getattr__ 只响应几个特定的属性,可以加入异常处理,修改 __getattr__ 方法,如下:
1. def __getattr__ ( self , attr ):
2. if attr == ‘z’ :
3. return 0
4. raise AttributeError ( “Point object has no attribute %s” % attr )
这里再强调一点, __getattr__ 只有在属性不存在的情况下才会被调用,对已存在的属性不会调用
__getattr__ 。
与 __getattr__ 一起使用的还有 __setattr__ , __delattr__ ,类似 obj.attr =value , del obj.attr ,看下面一个例子:
1. class Point ( object ):
2. def __init__ ( self , x = 0 , y = 0 ):
3. self . x = x
4. self . y = y
6. def __getattr__ ( self , attr ):
7. if attr == ‘z’ :
8. return 0
9. raise AttributeError ( “Point object has no attribute %s” % attr )
11. def __setattr__ ( self , * args , ** kwargs ):
12. print ‘call func set attr (%s, %s)’ % ( args , kwargs )
13. return object . __setattr__ ( self , * args , ** kwargs )
15. def __delattr__ ( self , * args , ** kwargs ):
16. print ‘call func del attr (%s, %s)’ % ( args , kwargs )
17. return object . __delattr__ ( self , * args , ** kwargs )
19. >>> p = Point ( 3 , 4 )
20. call func set attr (( ‘x’ , 3 ), {})
21. call func set attr (( ‘y’ , 4 ), {})
22. >>> p . z
23. 0
24. >>> p . z = 7
25. call func set attr (( ‘z’ , 7 ), {})
26. >>> p . z
27. 7
28. >>> p . w
29. Traceback ( most recent call last ):
30. File “” , line 1 , in < module >
31. File “” , line 8 , in __getattr__
32. AttributeError : Point object has no attribute w
33. >>> p . w = 8
34. call func set attr (( ‘w’ , 8 ), {})
35. >>> p . w
36. 8
37. >>> del p . w
38. call func del attr (( ‘w’ ,), {})
39. >>> p . __dict__
40. { ‘y’ : 4 , ‘x’ : 3 , ‘z’ : 7 }
5.6 call
我们一般使用 obj.method() 来调用对象的方法,那能不能直接在实例本身上调用呢?在
Python 中,只要我们在类中定义 __call__ 方法,就可以对实例进行调用,比如下面的例子:
1. class Point ( object ):
2. def __init__ ( self , x , y ):
3. self . x , self . y = x , y
4. def __call__ ( self , z ):
5. return self . x + self . y + z
使用如下:
1. >>> p = Point ( 3 , 4 )
2. >>> callable ( p ) # 使用 callable 判断对象是否能被调用
3. True
4. >>> p ( 6 ) # 传入参数,对实例进行调用,对应 p.__call__(6)
5. 13 # 3+4+6
可以看到,对实例进行调用就好像对函数调用一样。
__new__ 在 __init__ 之前被调用,用来创建实例。
__str__ 是用 print 和 str 显示的结果, __repr__ 是直接显示的结果。
__getitem__ 用类似 obj[key] 的方式对对象进行取值
__getattr__ 用于获取不存在的属性 obj.attr
__call__ 使得可以对实例进行调用
5.7 小结
__new__ 在 __init__ 之前被调用,用来创建实例。
__str__ 是用 print 和 str 显示的结果, __repr__ 是直接显示的结果。
__getitem__ 用类似 obj[key] 的方式对对象进行取值
__getattr__ 用于获取不存在的属性 obj.attr
__call__ 使得可以对实例进行调用
6 slots 魔法
在 Python 中,我们在定义类的时候可以定义属性和方法。当我们创建了一个类的实例后,我们还可以给该实例绑定任意新的属性和方法。
看下面一个简单的例子:
1. class Point ( object ):
2. def __init__ ( self , x = 0 , y = 0 ):
3. self . x = x
4. self . y = y
6. >>> p = Point ( 3 , 4 )
7. >>> p . z = 5 # 绑定了一个新的属性
8. >>> p . z
9. 5
10. >>> p . __dict__
11. { ‘x’ : 3 , ‘y’ : 4 , ‘z’ : 5 }
在上面,我们创建了实例 p 之后,给它绑定了一个新的属性 z ,这种动态绑定的功能虽然很有用,但它的代价是消耗了更多的内存。
因此,为了不浪费内存,可以使用 __slots__ 来告诉 Python 只给一个固定集合的属性分配空
间,对上面的代码做一点改进,如下:
1. class Point ( object ):
2. __slots__ = ( ‘x’ , ‘y’ ) # 只允许使用 x 和 y
4. def __init__ ( self , x = 0 , y = 0 ):
5. self . x = x
6. self . y = y
上面,我们给 __slots__ 设置了一个元组,来限制类能添加的属性。现在,如果我们想绑定一个
新的属性,比如 z ,就会出错了,如下:
1. >>> p = Point ( 3 , 4 )
2. >>> p . z = 5
3. ---------------------------------------------------------------------------
4. AttributeError Traceback ( most recent call last )
5. < ipython - input - 648 - 625ed954d865 > in < module >()
6. ----> 1 p . z = 5
8. AttributeError : ‘Point’ object has no attribute ‘z’
使用 __slots__ 有一点需要注意的是, __slots__ 设置的属性仅对当前类有效,对继承的子
类不起效,除非子类也定义了 __slots__ ,这样,子类允许定义的属性就是自身的 slots 加上父
类的 slots 。
7 使用 @property
在使用 @property 之前,让我们先来看一个简单的例子:
1. class Exam ( object ):
2. def __init__ ( self , score ):
3. self . _score = score
5. def get_score ( self ):
6. return self . _score
8. def set_score ( self , val ):
9. if val < 0 :
10. self . _score = 0
11. elif val > 100 :
12. self . _score = 100
13. else :
14. self . _score = val
16. >>> e = Exam ( 60 )
17. >>> e . get_score ()
18. 60
19. >>> e . set_score ( 70 )
20. >>> e . get_score ()
21. 70
在上面,我们定义了一个 Exam 类,为了避免直接对 _score 属性操作,我们提供了
get_score 和 set_score 方法,这样起到了封装的作用,把一些不想对外公开的属性隐蔽起来,
而只是提供方法给用户操作,在方法里面,我们可以检查参数的合理性等。
这样做没什么问题,但是我们有更简单的方式来做这件事, Python 提供了 property 装饰器,被
装饰的方法,我们可以将其『当作』属性来用,看下面的例子:
1. class Exam ( object ):
2. def __init__ ( self , score ):
3. self . _score = score
5. @property
6. def score ( self ):
7. return self . _score
9. @score . setter
10. def score ( self , val ):
11. if val < 0 :
12. self . _score = 0
13. elif val > 100 :
14. self . _score = 100
15. else :
16. self . _score = val
18. >>> e = Exam ( 60 )
19. >>> e . score
20. 60
21. >>> e . score = 90
22. >>> e . score
23. 90
24. >>> e . score = 200
25. >>> e . score
26. 100
在上面,我们给方法 score 加上了 @property ,于是我们可以把 score 当成一个属性来用,
此时,又会创建一个新的装饰器 score.setter ,它可以把被装饰的方法变成属性来赋值。
另外,我们也不一定要使用 score.setter 这个装饰器,这时 score 就变成一个只读属性了:
1. class Exam ( object ):
2. def __init__ ( self , score ):
3. self . _score = score
5. @property
6. def score ( self ):
7. return self . _score
9. >>> e = Exam ( 60 )
10. >>> e . score
11. 60
12. >>> e . score = 200 # score 是只读属性,不能设置值
13. ---------------------------------------------------------------------------
14. AttributeError Traceback ( most recent call last )
15. < ipython - input - 676 - b0515304f6e0 > in < module >()
16. ----> 1 e . score = 200
18. AttributeError : can 't set attribute
@property 把方法『变成』了属性 。
8 你不知道的 super
在类的继承中,如果重定义某个方法,该方法会覆盖父类的同名方法,但有时,我们希望能同时实现父类的功能,这时,我们就需要调用父类的方法了,可通过使用 super 来实现,比如:
1. class Animal ( object ):
2. def __init__ ( self , name ):
3. self . name = name
4. def greet ( self ):
5. print ‘Hello, I am %s.’ % self . name
7. class Dog ( Animal ):
8. def greet ( self ):
9. super ( Dog , self ). greet () # Python3 可使用 super().greet()
10. print ‘WangWang…’
在上面, Animal 是父类, Dog 是子类,我们在 Dog 类重定义了 greet 方法,为了能同时实现
父类的功能,我们又调用了父类的方法,看下面的使用:
1. >>> dog = Dog ( ‘dog’ )
2. >>> dog . greet ()
3. Hello , I am dog .
4. WangWang …
super 的一个最常见用法可以说是在子类中调用父类的初始化方法了,比如:
1. class Base ( object ):
2. def __init__ ( self , a , b ):
3. self . a = a
4. self . b = b
6. class A ( Base ):
7. def __init__ ( self , a , b , c ):
8.
super ( A , self ). __init__ ( a , b ) # Python3 可使用 super().__init__(a, b)
9. self . c = c
8.1 深入 super()
看了上面的使用,你可能会觉得 super 的使用很简单,无非就是获取了父类,并调用父类的方 法。其实,在上面的情况下, super 获得的类刚好是父类,但在其他情况就不一定了, super 其实和
父类没有实质性的关联。
让我们看一个稍微复杂的例子,涉及到多重继承,代码如下:
1. class Base ( object ):
2. def __init__ ( self ):
3. print “enter Base”
4. print “leave Base”
6. class A ( Base ):
7. def __init__ ( self ):
8. print “enter A”
9. super ( A , self ). __init__ ()
10. print “leave A”
12. class B ( Base ):
13. def __init__ ( self ):
14. print “enter B”
15. super ( B , self ). __init__ ()
16. print “leave B”
18. class C ( A , B ):
19. def __init__ ( self ):
20. print “enter C”
21. super ( C , self ). __init__ ()
22. print “leave C”
其中, Base 是父类, A, B 继承自 Base, C 继承自 A, B ,它们的继承关系是一个典型的『菱形继
承』,如下:
1. Base
2. / \
3. / \
4. A B
5. \ /
6. \ /
7. C
现在,让我们看一下使用:
1. >>> c = C ()
2. enter C
3. enter A
4. enter B
5. enter Base
6. leave Base
7. leave B
8. leave A
9. leave C
如果你认为 super 代表『调用父类的方法』,那你很可能会疑惑为什么 enter A 的下一句不是
enter Base 而是 enter B 。原因是, super 和父类没有实质性的关联,现在让我们搞清
super 是怎么运作的。
8.2 MRO 列表
事实上,对于你定义的每一个类, Python 会计算出一个方法解析顺序( Method Resolution
Order, MRO )列表,它代表了类继承的顺序,我们可以使用下面的方式获得某个类的 MRO 列表:
1. >>> C . mro () # or C.__mro__ or C().__class__.mro()
2. [ __main__ . C , __main__ . A , __main__ . B , __main__ . Base , object ]
那这个 MRO 列表的顺序是怎么定的呢,它是通过一个 C3 线性化算法 来实现的,这里我们就不去深究
这个算法了,感兴趣的读者可以自己去了解一下,总的来说,一个类的 MRO 列表就是合并所有父类的
MRO 列表,并遵循以下三条原则:
子类永远在父类前面
如果有多个父类,会根据它们在列表中的顺序被检查
如果对下一个类存在两个合法的选择,选择第一个父类
8.3 super 原理
super 的工作原理如下:
1. def super ( cls , inst ):
2. mro = inst . __class__ . mro ()
3. return mro [ mro . index ( cls ) + 1 ]
其中, cls 代表类, inst 代表实例,上面的代码做了两件事:
获取 inst 的 MRO 列表
查找 cls 在当前 MRO 列表中的 index, 并返回它的下一个类,即 mro[index + 1]
当你使用 super(cls, inst) 时, Python 会在 inst 的 MRO 列表上搜索 cls 的下一个类。
现在,让我们回到前面的例子。
首先看类 C 的 __init__ 方法:
1. super ( C , self ). __init__ ()
文末有福利领取哦~
👉一、Python所有方向的学习路线
Python所有方向的技术点做的整理,形成各个领域的知识点汇总,它的用处就在于,你可以按照上面的知识点去找对应的学习资源,保证自己学得较为全面。
👉二、Python必备开发工具
👉三、Python视频合集
观看零基础学习视频,看视频学习是最快捷也是最有效果的方式,跟着视频中老师的思路,从基础到深入,还是很容易入门的。
👉 四、实战案例
光学理论是没用的,要学会跟着一起敲,要动手实操,才能将自己的所学运用到实际当中去,这时候可以搞点实战案例来学习。(文末领读者福利)
👉五、Python练习题
检查学习结果。
👉六、面试资料
我们学习Python必然是为了找到高薪的工作,下面这些面试题是来自阿里、腾讯、字节等一线互联网大厂最新的面试资料,并且有阿里大佬给出了权威的解答,刷完这一套面试资料相信大家都能找到满意的工作。
👉因篇幅有限,仅展示部分资料,这份完整版的Python全套学习资料已经上传
网上学习资料一大堆,但如果学到的知识不成体系,遇到问题时只是浅尝辄止,不再深入研究,那么很难做到真正的技术提升。
需要这份系统化的资料的朋友,可以添加V获取:vip1024c (备注python)
一个人可以走的很快,但一群人才能走的更远!不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人,都欢迎加入我们的的圈子(技术交流、学习资源、职场吐槽、大厂内推、面试辅导),让我们一起学习成长!
or C.__mro__ or C().__class__.mro()
2. [ __main__ . C , __main__ . A , __main__ . B , __main__ . Base , object ]
那这个 MRO 列表的顺序是怎么定的呢,它是通过一个 C3 线性化算法 来实现的,这里我们就不去深究
这个算法了,感兴趣的读者可以自己去了解一下,总的来说,一个类的 MRO 列表就是合并所有父类的
MRO 列表,并遵循以下三条原则:
子类永远在父类前面
如果有多个父类,会根据它们在列表中的顺序被检查
如果对下一个类存在两个合法的选择,选择第一个父类
8.3 super 原理
super 的工作原理如下:
1. def super ( cls , inst ):
2. mro = inst . __class__ . mro ()
3. return mro [ mro . index ( cls ) + 1 ]
其中, cls 代表类, inst 代表实例,上面的代码做了两件事:
获取 inst 的 MRO 列表
查找 cls 在当前 MRO 列表中的 index, 并返回它的下一个类,即 mro[index + 1]
当你使用 super(cls, inst) 时, Python 会在 inst 的 MRO 列表上搜索 cls 的下一个类。
现在,让我们回到前面的例子。
首先看类 C 的 __init__ 方法:
1. super ( C , self ). __init__ ()
文末有福利领取哦~
👉一、Python所有方向的学习路线
Python所有方向的技术点做的整理,形成各个领域的知识点汇总,它的用处就在于,你可以按照上面的知识点去找对应的学习资源,保证自己学得较为全面。
👉二、Python必备开发工具
👉三、Python视频合集
观看零基础学习视频,看视频学习是最快捷也是最有效果的方式,跟着视频中老师的思路,从基础到深入,还是很容易入门的。
👉 四、实战案例
光学理论是没用的,要学会跟着一起敲,要动手实操,才能将自己的所学运用到实际当中去,这时候可以搞点实战案例来学习。(文末领读者福利)
👉五、Python练习题
检查学习结果。
👉六、面试资料
我们学习Python必然是为了找到高薪的工作,下面这些面试题是来自阿里、腾讯、字节等一线互联网大厂最新的面试资料,并且有阿里大佬给出了权威的解答,刷完这一套面试资料相信大家都能找到满意的工作。
👉因篇幅有限,仅展示部分资料,这份完整版的Python全套学习资料已经上传
网上学习资料一大堆,但如果学到的知识不成体系,遇到问题时只是浅尝辄止,不再深入研究,那么很难做到真正的技术提升。
需要这份系统化的资料的朋友,可以添加V获取:vip1024c (备注python)
[外链图片转存中…(img-zXH9jmj4-1713347167088)]
一个人可以走的很快,但一群人才能走的更远!不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人,都欢迎加入我们的的圈子(技术交流、学习资源、职场吐槽、大厂内推、面试辅导),让我们一起学习成长!