Python3学习（七）

最新推荐文章于 2024-09-07 19:20:40 发布

linux顿悟吧

最新推荐文章于 2024-09-07 19:20:40 发布

阅读量273

点赞数

本文链接：https://blog.youkuaiyun.com/qq_36781842/article/details/107311026

版权

Python 专栏收录该内容

8 篇文章

订阅专栏

文章目录

类中的私有属性
类中的私有方法
__del__方法
测试对象的引用计数
继承

类中的私有属性

私有属性的定义，是以"__value"格式定义，只允许在类中的方法使用，不允许直接通过对象获取。

上栗子：


class Animal:
    def __init__(self,new_age):
        self.age = new_age #公有属性的定义，即允许在类中的方法使用，也允许直接通过对象获取
        self.__name = "小黑" #私有属性的定义，只允许在类中的方法使用，不允许直接通过对象获取

    def get_age(self):
        return self.age

    def get_name(self):
        return self.__name

dog = Animal(16)
print(dog.get_age())
print(dog.age)

print(dog.get_name())
#print(dog.__name)

#结果：
ubuntu@ubuntu16:/work/python/8-day$ python3 1-私有属性.py 
16
16
小黑

如上述栗子，如果使用print(dog.__name)直接获取__name这个私有属性，将会报如下错误。

ubuntu@ubuntu16:/work/python/8-day$ python3 1-私有属性.py 
16
16
Traceback (most recent call last):
  File "1-私有属性.py", line 23, in <module>
    print(dog.__name)
AttributeError: 'Animal' object has no attribute '__name'

认为Animal类中没有__name这个属性。

类中的私有方法

私有方法的定义，“def __func(self):”只允许在类中的方法使用，不允许直接通过对象获取

举个栗子：

class Animal:
    
    def __init__(self,new_age):
        self.age = new_age #公有属性的定义，即允许在类中的方法使用，也允许直接通过对象获取
        self.__name = "小黑" #私有属性的定义，只允许在类中的方法使用，不允许直接通过对象获取


    def get_age(self):
        return self.age

    def get_name(self):
        return self.__name

    def __color(self): #私有方法的定义，只允许在类中的方法使用，不允许直接通过对象获取
        print("-----红色------")

    def get_color(self):
        self.__color()

dog = Animal(18)

print(dog.get_age())
dog.get_color()
#dog.__color()

ubuntu@ubuntu16:/work/python/8-day$ python3 2-私有方法.py 
18
-----红色------

如果使用dog.__color()调用私有方法__color(),将会报如下错误。

ubuntu@ubuntu16:/work/python/8-day$ python3 2-私有方法.py 
18
Traceback (most recent call last):
  File "2-私有函数.py", line 24, in <module>
    dog.__color()
AttributeError: 'Animal' object has no attribute '__color'

认为Animal类中没有__color这个属性。

del方法

当我们通过类创建一个或多个对象之后，创建对象的时候，即会在内存中创建一片内存空间，当我们del 对象或者程序运行结束，类中默认会调用__del__方法，该方法有一定的实用效果，比如打游戏的时候，人物死掉的特效音效或动作，都可以在__del__方法中实现。

举个栗子：

class A:
    def __del__(self):
        print("----del-----")
a = A()
print("---------")

#结果：
ubuntu@ubuntu16:/work/python/8-day$ python3 3-__del__.py 
---------
----del-----

在程序运行结束，将调用__del__方法。

那么如果我提前删除掉对象a，我们来看看会是什么效果。

class A:
    def __del__(self):
        print("----del-----")

a = A()
del a
print("---------")

# 结果：
ubuntu@ubuntu16:/work/python/8-day$ python3 3-__del__.py 
----del-----
---------

使用del删除对象之后，即会调用__del__方法。

class A:
    def __del__(self):
        print("----del-----")

a = A()
b = a #创建对象b，并指向a所指向的位置
del a
print("---------")

#结果：
ubuntu@ubuntu16:/work/python/8-day$ python3 3-__del__.py 
---------
----del-----

我们可以看到创建对象b之后，del a删除，结果调用__del__方法在打印---------之后，这是为什么？

在内存中，b = a之后会将对象的引用计数加一，只有引用计数为0的时候才会调用类中的__del__方法。删除对象a之后，b对象仍然存在，所以不会调用__del__，等到程序运行结束之后，才会调用__del__方法。

在这里插入图片描述

测试对象的引用计数

模块sys下的方法getrefcount(对象)，去测试同一个类下的对象的引用计数

In [2]: import sys

In [3]: sys.getrefcount
Out[3]: <function sys.getrefcount>

In [4]: class A: #创建类A
   ...:     pass
   ...: 

In [5]: a = A() #创建对象a

In [6]: sys.getrefcount(a) #getrefcount(a)方法本身会增加一个引用计数
Out[6]: 2 #所以得出的结果为2

In [7]: b = a #创建对象b

In [8]: sys.getrefcount(a)
Out[8]: 3

In [9]: del b

In [10]: sys.getrefcount(a)
Out[10]: 2

In [11]: del a

In [12]: sys.getrefcount(a) #一旦引用计数为0,那么说明该类下没有对象创建，再去测试引用计数，则报错
---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
<ipython-input-12-fb616ef7f1f4> in <module>()
----> 1 sys.getrefcount(a)

NameError: name 'a' is not defined

继承

继承的概念：子类拥有父类的所有方法和属性
在这里插入图片描述
继承的格式：

class 类名(父类名):
    pass
class Child(Father):
    pass

1.子类继承自父类，可以直接享受 父类中已经封装好的方法，不需要再次开发

2.子类中应该根据职责，封装子类特有的属性和方法

专业术语

Dog 类是 Animal 类的子类，Animal 类是 Dog 类的父类，Dog 类从 Animal 类继承

Dog 类是 Animal 类的派生类，Animal 类是 Dog 类的基类，Dog 类从 Animal 类派生

class Animal:
	def eat(self):
		print("---animal eat---")
	def run(self):
		print("---animal run---")
	def sleep(self):
		print("---animal sleep---")


class cat(Animal):
	def catch(self):
		print("---cat catch---")
	
class dog(Animal):
	def bark(self):
		print("---dog bark---")

class XiaoTianquan(dog):
	def fly(self):
		print("---xiaotianquan fly---")


xtq = XiaoTianquan()
xtq.fly()
xtq.bark()
xtq.sleep()
xtq.eat()

#结果：
ubuntu@ubuntu16:/work/python/8-day$ python3 4-继承.py 
---xiaotianquan fly---
---dog bark---
---animal sleep---
---animal eat---

继承的传递性

C 类从 B 类继承，B 类又从 A 类继承，那么 C 类就具有 B 类和 A 类的所有属性和方法，子类拥有父类以及父类的父类中封装的所有属性和方法

提问：

哮天犬能够调用 Cat 类中定义的 catch 方法吗？

答案：

不能，因为哮天犬和 Cat 之间没有继承关系

#上述代码后添加
...
xtq.catch()

#执行结果：
ubuntu@ubuntu16:/work/python/8-day$ python3 4-继承.py 
---xiaotianquan fly---
---dog bark---
---animal sleep---
---animal eat---
Traceback (most recent call last):
  File "4-继承.py", line 29, in <module>
    xtq.catch()
AttributeError: 'XiaoTianquan' object has no attribute 'catch'

方法的重写

子类拥有父类的所有方法和属性
子类继承自父类，可以直接享受父类中已经封装好的方法，不需要再次开发。

应用场景
当父类的方法实现不能满足子类需求时，可以对方法进行重写(override)

class Animal:
	def eat(self):
		print("---animal eat---")
	def run(self):
		print("---animal run---")
	def sleep(self):
		print("---animal sleep---")


class cat(Animal):
	def catch(self):
		print("---cat catch---")
	
class dog(Animal):
	def bark(self):
		print("---dog bark---")

class XiaoTianquan(dog):
	def fly(self):
		print("---xiaotianquan fly---")
	
	def bark(self):
		print("---xiaotianquan 狂叫---")

xtq = XiaoTianquan()
xtq.fly()
xtq.bark()

# 执行结果：
ubuntu@ubuntu16:/work/python/8-day$ python3 5-重写.py 
---xiaotianquan fly---
---xiaotianquan 狂叫---

重写父类方法有两种情况：
1.覆盖父类的方法
2.对父类方法进行扩展

class Animal:
	def eat(self):
		print("---animal eat---")
	def run(self):
		print("---animal run---")
	def sleep(self):
		print("---animal sleep---")

class dog(Animal):
	def bark(self):
		print("---dog 汪汪叫---")

class XiaoTianquan(dog):
	def fly(self):
		print("---xiaotianquan fly---")
	
	def bark(self):
		print("---xiaotianquan 狂叫---")
		#第一种调用被重写的父类的方法
		#dog.bark(self)
		#第二种方法
		super().bark()

xtq = XiaoTianquan()
xtq.fly()
xtq.bark()

#执行结果：
ubuntu@ubuntu16:/work/python/8-day$ python3 6-调用被重写的方法.py 
---xiaotianquan fly---
---xiaotianquan 狂叫---
---dog 汪汪叫---

父类的私有属性和私有方法

子类对象 不能在自己的方法内部，直接访问父类的 私有属性或私有方法

子类对象 可以通过 父类的公有方法 间接访问到 私有属性或私有方法

私有属性、方法 是对象的隐私，不对外公开，外界以及 子类都不能直接访问
私有属性、方法通常用于做一些内部的事情

class A:
	def __init__(self):
		self.num1 = 100
		self.__num2 = 200

	def test1(self):
		print("--test1--")
		self.__test2() #在该类中可以使用私有方法和私有属性
		print(self.__num2)
	
	def __test2(self):
		print("--test2--")


class B(A):
	def demo(self):
		pass

b = B()
b.test1()
#b.__test2() #私有方法不继承,并且不能直接调用私有方法
print(b.num1)
#print(b.__num2)#私有属性不继承,并且不能直接调用私有属性

B 的对象不能直接访问 __num2 属性
B 的对象不能在 demo 方法内访问 __num2 属性
B 的对象可以在 demo 方法内，调用父类的 test 方法
父类的 test 方法内部，能够访问 __num2 属性和 __test2 方法

多继承

概念：子类可以拥有 多个父类，并且具有 所有父类的属性和方法。
例如：孩子会继承自己父亲和母亲的特性

语法：

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

在这里插入图片描述
问题：如果不同的父类中存在同名的方法，子类对象在调用方法时，会调用哪一个父类中的方法呢？

提示：开发时，应该尽量避免这种容易产生混淆的情况！ —— 如果父类之间存在同名的属性或者方法，应该尽量避免使用多继承

在这里插入图片描述
Python 中的 MRO —— 方法搜索顺序
Python 中针对类提供了一个内置属性 __mro__可以查看方法搜索顺序
MRO 是 method resolution order，主要用于 在多继承时判断方法、属性的调用路径

print(C.__mro__)

输出结果: 
(<class '__main__.C'>, <class '__main__.A'>, <class '__main__.B'>, <class 'object'>)

1.在搜索方法时，是按照 mro 的输出结果从左至右的顺序查找的
2.如果在当前类中找到方法，就直接执行，不再搜索
3.如果没有找到，就查找下一个类中是否有对应的方法，如果找到，就直接执行，不再搜索
4.如果找到最后一个类，还没有找到方法，程序报错

新式类与旧式（经典）类

object 是 Python 为所有对象提供的基类，提供有一些内置的属性和方法，可以使用 dir 函数查看

新式类：以 object 为基类的类，推荐使用

经典类：不以 object 为基类的类，不推荐使用

在 Python 3.x 中定义类时，如果没有指定父类，会默认使用 object 作为该类的基类 —— Python 3.x 中定义的类都是新式类

在 Python 2.x 中定义类时，如果没有指定父类，则不会以 object 作为基类

新式类和经典类在多继承时 —— 会影响到方法的搜索顺序

为了保证编写的代码能够同时在 Python 2.x 和 Python 3.x 运行！

今后在定义类时，如果没有父类，建议统一继承自 object

class 类名(object):
    pass