Python-7-类、对象与魔法方法

最新推荐文章于 2023-07-23 22:08:43 发布

lyliu瑜

最新推荐文章于 2023-07-23 22:08:43 发布

阅读量183

点赞数

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

本文链接：https://blog.csdn.net/lyliu_19/article/details/107733700

版权

Python 专栏收录该内容

8 篇文章 0 订阅

订阅专栏

类与对象

对象 = 属性 + 方法
对象是类的实例，类主要定义对象的结构，然后以类为模板创建对象；类不但包含方法定义，还包含所有实例共享的数据

封装：
将抽象得到的数据和行为（或功能）相结合，形成一个有机的整体（即类）；封装的目的是增强安全性和简化编程，使用者不必了解具体的实现细节，而只是要通过外部接口，以特定的访问权限来使用类的成员。
使用关键词 class 定义类，类名约定以大写字母开头
继承：子类自动共享父类之间数据和方法的机制
多态：不同对象对同一方法响应不同的行动

self

类的方法与普通的函数的区别在于它们必须有一个额外的第一个参数名称（对应于该实例，即该对象本身），按照惯例它的名称是 self；
在调用方法时，无需明确提供与参数 self 对应的参数

共有和私有

在 Python 中定义私有变量或方法只需要在变量名或函数名前加上两个下划线 “__” ，那么这个函数或变量就会为私有的了
python的私有变量和私有方法是伪私有，只供类对象使用，即使是子类对象也不能访问
python的伪私有是指python使用一种 name mangling 技术，将私有变量或私有方法的名字 __name 转换成 _classname__name，使得其不能直接访问，但仍可能通过 实例._类__变量名/方法名() 的方式访问

class JustCounter:
    __secretCount = 0  	# 私有变量
    publicCount = 0  	# 公开变量

    def count(self):
        self.__secretCount += 1
        self.publicCount += 1
        print(self.__secretCount)


counter = JustCounter()
counter.count()  # 1
counter.count()  # 2
print(counter.publicCount)  # 2

print(counter.__secretCount)  
# AttributeError: 'JustCounter' object has no attribute '__secretCount'
print(counter._JustCounter__secretCount)  
# 2 Python的私有为伪私有

继承

子类中出现与父类相同的属性或方法时，父类中对应的属性或方法会被覆盖
注意在定义子类的__init__时，由于与父类中对应的方法同名，若不想覆盖父类的__init__的方法，则需要在子类的该方法中添加父类名.__init__(self) 或super().__init__()
python支持多继承形式，父类中方法的调用顺序从左向右查找

类、类对象和实例对象
关系图

类对象：创建一个类，其实也是一个对象也在内存开辟了一块空间，称为类对象，类对象只有一个；
实例对象：就是通过实例化类创建的对象，称为实例对象，实例对象可以有多个；
类属性：类里面方法外面定义的变量称为类属性。类属性所属于类对象并且多个实例对象之间共享同一个类属性，说白了就是类属性所有的通过该类实例化的对象都能共享；
实例属性：实例属性和具体的某个实例对象有关系，并且一个实例对象和另外一个实例对象是不共享属性的，说白了实例属性只能在自己的对象里面使用，其他的对象不能直接使用，因为self是谁调用，它的值就属于该对象

类属性和实例属性区别

类属性：类外面，可以通过实例对象.类属性和类名.类属性进行调用。类里面，通过self.类属性和类名.类属性进行调用；
实例属性：类外面，可以通过实例对象.实例属性调用。类里面，通过self.实例属性调用；
实例属性就相当于局部变量，出了这个类或者这个类的实例对象，就没有作用了；
类属性就相当于类里面的全局变量，可以和这个类的所有实例对象共享。

属性与方法同名时，属性会覆盖方法

绑定

绑定是指python严格要求方法需要有实例才能被调用
Python 对象的数据属性通常存储在名为.__ dict__的字典中，可以直接访问__dict__，也可以利用内置函数vars()获取

相关的内置函数

issubclass(class, classinfo)
用于判断 class 是否是类型 classinfo 的子类

a. 一个类是其自身的子类
b. classinfo 可以是类对象的元组，只要 class 是其中任何一个候选类的子类，则返回 True
isinstance(object, classinfo)
用于判断一个对象是否是一个已知的类型，类似type()；type()不会认为子类是一种父类类型，不考虑继承关系；isinstance()会认为子类是一种父类类型，考虑继承关系

a. 如果第一个参数不是对象，则永远返回False。
b. 如果第二个参数不是类或者由类对象组成的元组，则会抛出一个TypeError异常。
hasattr(object, name)
用于判断对象是否包含对应的属性
getattr(object, name[, default])
用于返回一个对象属性值

	class A(object):
    	def set(self, a, b):
        	x = a
        	a = b
        	b = x
        	print(a, b)

	a = A()
	c = getattr(a, 'set')
	c(a='1', b='2')  # 2 1

setattr(object, name, value)
对应函数 getattr()，用于设置属性值，该属性不一定是存在的

	class A(object):
    	bar = 1

	a = A()
	print(getattr(a, 'bar'))  # 1
	setattr(a, 'bar', 5)
	print(a.bar)  # 5
	setattr(a, "age", 28)
	print(a.age)  # 28

delattr(object, name)
用于删除属性
class property([fget[, fset[, fdel[, doc]]]])
用于在新式类中返回属性值；
fget – 获取属性值的函数，fset – 设置属性值的函数，fdel – 删除属性值函数， doc – 属性描述信息

	class C(object):
    	def __init__(self):
        	self.__x = None

    	def getx(self):
        	return self.__x

    	def setx(self, value):
        	self.__x = value

	    def delx(self):
    	    del self.__x

    	x = property(getx, setx, delx, "I'm the 'x' property.")


	cc = C()
	cc.x = 2
	print(cc.x)  # 2

	del cc.x
	print(cc.x)
	# AttributeError: 'C' object has no attribute '_C__x'

练习题

1、怎么定义私有方法？
在方法前面加两个下划线 __

2、尝试执行以下代码，并解释错误原因：

class C:
    def myFun():
        print('Hello!')
    c = C()
    c.myFun()

错误1. NameError: name 'C' is not defined
实例化类对象时应该在类外部

错误2. TypeError: myFun() takes 0 positional arguments but 1 was given
类方法在定义时，至少需要一个参数，一般为self

3、按照以下要求定义一个游乐园门票的类，并尝试计算2个成人+1个小孩平日票价

要求:
平日票价100元
周末票价为平日的120%
儿童票半价

class Ticket:

    def __init__(self, num_adult, num_children):
        self.value = 100
        self.adult = num_adult
        self.children = num_children

    def compute(self, weekday):
        value = self.value * self.adult + self.value * self.children * 0.5
        if weekday:
            return value
        else:
            return 1.2*value
		

ticket = Ticket(2, 1)
value = ticket.compute(0)
print(value)

魔法方法

魔法方法总是被双下划线包围，如 __init__
魔法方法的“魔力”体现在它们总能够在适当的时候被自动调用
魔法方法的第一个参数应为 cls(类名称) 或 self(实例对象的名称)

基本的魔法方法

__init__(self[, ...])
构造器，当一个实例被创建的时候调用的初始化方法
__new__(cls[, ...])
在一个对象实例化的时候所调用的第一个方法
- 至少要有一个参数cls，代表要实例化的类，此参数在实例化时由 Python 解释器自动提供，后面的参数直接传递给__init__；
- 对当前类进行了实例化，并将实例返回，传给__init__的self，但是，执行了__new__，并不一定会进入__init__，只有__new__返回了，当前类cls的实例，当前类的__init__才会进入
- 若__new__没有正确返回当前类cls的实例，那__init__是不会被调用的，即使是父类的实例也不行，将没有__init__被调用
- __new__方法主要是当你继承一些不可变的 class 时（比如int, str, tuple），提供给你一个自定义这些类的实例化过程的途径
__del__(self)
析构器，当一个对象将要被系统回收之时调用的方法

Python 采用自动引用计数（ARC）方式来回收对象所占用的空间，当程序中有一个变量引用该 Python 对象时，Python 会自动保证该对象引用计数增加 1；如果一个对象的引用计数变成了 0，则说明程序中不再有变量引用该对象，表明程序不再需要该对象，Python 会回收该对象。

大部分时候，Python 的 ARC 都能准确、高效地回收系统中的每个对象。但如果系统中出现循环引用的情况，此时 Python 的垃圾回收器就可能没那么快，要等专门的循环垃圾回收器来检测并回收这种引用循环。
__str__(self) & __repr__(self)

打印一个对象时，或使用%s格式化时，或str强转数据类型时，触发__str__(self)；

__repr__是__str__的备用方法，没有__str__时，执行__repr__方法；

repr(obj)内置函数对应的结果是__repr__的返回值；
当使用%r格式化时，触发__repr__

__str__(self) 的返回结果可读性强；__repr__(self) 的返回结果应更准确，__repr__ 存在的目的在于调试，便于开发者使用

算术运算符

__add__(self, other) # 加 +
__sub__(self, other) #减 -
__mul__(self, other) #乘 *
__truediv__(self, other) # 除 /
__floordiv__(self, other) # 整除 //
__mod__(self, other) # 取模/余 %
__divmod__(self, other) # 使用 divmod 方法时被调用，返回一个包含商和余数的元组
__pow__(self, other[, module]) #乘幂 power()/**
__lshift__(self, other) # 左移 <<
__rshift__(self, other) # 右移 >>
__and__(self, other) # 按位与 &
__xor__(self, other) # 按位异或 ^
__or__(self, other) # 按位或 |

反算术运算符
反运算魔方方法与算术运算符保持一一对应，不同之处在于反运算的魔法方法多了一个“r”；当文件左操作不支持相应的操作时被调用

__radd__(self, other) # 加 +
__rsub__(self, other) #减 -
__rmul__(self, other) #乘 *
__rtruediv__(self, other) # 除 /
__rfloordiv__(self, other) # 整除 //
__rmod__(self, other) # 取模/余 %
__rdivmod__(self, other) # 使用 divmod 方法时被调用，返回一个包含商和余数的元组
__rpow__(self, other[, module]) #乘幂 power()/**
__rlshift__(self, other) # 左移 <<
__rrshift__(self, other) # 右移 >>
__rand__(self, other) # 按位与 &
__rxor__(self, other) # 按位异或 ^
__ror__(self, other) # 按位或 |

增量赋值运算符

__iadd__(self, other) # 赋值加 +=
__isub__(self, other) # 赋值减 -=
__imul__(self, other) # 赋值乘 *=
__itruediv__(self, other) # 赋值除 /=
__ifloordiv__(self, other) # 赋值整除 //=
__imod__(self, other) # 赋值取模/余 %=
__ipow__(self, other[, module]) # 赋值乘幂 **=
__ilshift__(self, other) # 赋值左移 <<=
__irshift__(self, other) # 赋值右移 >>=
__iand__(self, other) # 赋值按位与 &=
__ixor__(self, other) # 赋值按位异或 ^=
__ior__(self, other) # 赋值按位或 |=

一元运算符

__neg__(self) # 正号
__pos__(self) # 负号
__abs__(self) # 取绝对值abs()
__invert__(self) # 按位取反

属性访问

__getattr__(self, name)
定义当用户试图获取一个不存在的属性时的行为
__getattribute__(self, name)
定义当该类的属性被访问时的行为（先调用该方法，查看是否存在该属性，若不存在，接着去调用__getattr__）
__setattr__(self, name, value)
定义当一个属性被设置时的行为
__delattr__(self, name)
定义当一个属性被删除时的行为

描述符

描述符就是将某种特殊类型的类的实例指派给另一个类的属性

__get__(self, instance, owner)
用于访问属性，返回属性的值
__set__(self, instance, value)
将在属性分配操作中调用，不返回任何内容
__del__(self, instance)
控制删除操作，不返回任何内容

定制序列

协议与接口类似，规定了必须要定义的方法，Python中协议并没有这么正式，更像是一种指南

如果希望定义一种容器，则容器类型的协议要求：
如果希望容器是不可变的，则只需要定义 __len__() 和 __getitem__() 两种方法；
如果希望容器是可变的，则除上述两种方法外，还要定义 __setitem__() 和 __delitem__() 两种方法

迭代器

迭代器是访问集合元素的一种方式，迭代器对象从集合的第一个元素开始访问，直到所有元素被访问完结束，不能后退；列表、元组和字符串都可用于创建迭代器

迭代器有两个基本方法：iter() 和 next()

iter(object) 用于生成迭代器，
next(iterator[, default]) 用于返回迭代器的下一个项目
iterator 是可迭代对象
default 用于设置在没有下一个元素时返回该默认值，如果不设置，又没有下一个元素则会触发 StopIteration 异常

	links = {'B': '百度', 'A': '阿里', 'T': '腾讯'}
	it = iter(links)
	print(next(it))  # B
	print(next(it))  # A
	print(next(it))  # T
	print(next(it))  # StopIteration

	it = iter(links)
	while True:
    	try:
        	each = next(it)
    	except StopIteration:
        	break
    	print(each)

	# B
	# A
	# T

把一个类作为一个迭代器使用需要在类中实现两个魔法方法 __iter__() 与 __next__()

__iter__(self) 定义迭代容器中元素的行为，返回一个特殊的迭代器对象，这个迭代器对象实现了 __next__() 方法并通过 StopIteration 异常标识迭代的完成。
__next__() 返回下一个迭代器对象。
StopIteration 异常用于标识迭代的完成，防止出现无限循环的情况，在 __next__() 方法中我们可以设置在完成指定循环次数后触发 StopIteration 异常来结束迭代。

	class Fibs:
    	def __init__(self, n=10):
        	self.a = 0
        	self.b = 1
        	self.n = n

    	def __iter__(self):
        	return self

	    def __next__(self):
    	    self.a, self.b = self.b, self.a + self.b
        	if self.a > self.n:
            	raise StopIteration
        	return self.a


	fibs = Fibs(100)
	for each in fibs:
	    print(each, end=' ')

	# 1 1 2 3 5 8 13 21 34 55 89

生成器

python 中使用 yield 的函数被称为生成器
与普通函数不同，生成器是一个返回迭代器的函数，只能用于迭代操作，生成器可理解成就是一个迭代器
在调用生成器运行的过程中，每次遇到 yield 时函数会暂停并保存当前所有的运行信息，返回 yield 的值, 并在下一次执行 next() 方法时从当前位置继续运行

	# 用生成器实现斐波那契数列
	def libs(n):
    	a = 0
    	b = 1
    	while True:
        	a, b = b, a + b
        	if a > n:
            	return
        	yield a

	for each in libs(100):
    	print(each, end=' ')
	# 1 1 2 3 5 8 13 21 34 55 89

lyliu瑜

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Python-7-类、对象与魔法方法

类与对象对象 = 属性 + 方法对象是类的实例，类主要定义对象的结构，然后以类为模板创建对象；类不但包含方法定义，还包含所有实例共享的数据封装：继承：多态：self魔法方法共有和私有继承组合类、类对象和实例对象绑定相关的内置函数练习题2、怎么定义私有⽅法？3、尝试执行以下代码，并解释错误原因：class C: def myFun(): print('Hello!') c = C() c.myFun()4、按照以下要求定义一个游乐园
复制链接

扫一扫