10.1 构造和析构

1._init_(self[……])

该方法之前已经运用过了，在类中用于创建对象时初始化数据，给全局变量进行快速赋值的优点。

# 定义一个矩形类，长和宽作为全局变量，计算周长和面积
class Rectangle:
    # 构造方法，用于创建对象的时候，初始化长和宽的值
    def __init__(self,x,y):
        self.x=x
        self.y=y
    #     用于计算长方形的周长
    def getPeri(self):
        return (self.x+self.y)*2

    # 用于计算长方形的面积
    def getArea(self):
        return self.x * self.y

    # 运行
rect=Rectangle(10,20)
print("长方形的周长为:",rect.getPeri())#长方形的周长为: 60
print("长方形的面积为:",rect.getArea())#长方形的面积为: 200

这里需要注意构造方法是没有返回值的，它的返回值一定是None，所以一般在需要进行初始化的时候才重写该方法，但在python中这个方法并不是创建对象的时候第一个被调用的魔法方法。

2._new_(cls[……])

该方法才是创建一个对象的时候第一个被执行的方法，它和其他方法不一样，它的第一个参数不再是self，而是cls，该方法是一定需要有返回值，返回值为一个对象。一般情况下该方法很少会被重写，但当继承一个不可变的类型的时候，就需要该方法来完成功能。

# 定义一个类继承至字符串类，作为改变字符串字母为大写的功能
class Capstr(str):
    def __new__(cls, string):
        # 将该字符串转换为大写
        string=string.upper()
        # 将转换后的字符串提交给字符串类
        return str.__new__(cls,string)

# 执行代码
a=Capstr("how do you do?")
print(a)#HOW DO YOU DO?

3._del_(self)

该方法是在对象被销毁的时候，自动调用执行。

class C:
    def __init__(self):
        print("我是构造方法,我用于初始化数据")
    def __del__(self):
        print("我是销毁的方法，当该类的对象被销毁时执行")

# 运行
c=C()#我是构造方法,我用于初始化数据
c1=C()#我是构造方法,我用于初始化数据
del c#我是销毁的方法，当该类的对象被销毁时执行
del c1#我是销毁的方法，当该类的对象被销毁时执行

10.2 算术运算

# 算术运算
#查看以下几个是内建函数还是类
print(type(len))
# 
print(type(int))
# 
print(type(dir))
# 
print(type(list))
# 

通过上面的输出可以发现len和dir是内建函数，而int和list其实是类，那么说明之前说讲的类型之间的转换其实是创建了一个这个类的对象，并把值传入给构造方法，例如:

# 类型转换
# 创建了一个int类的对象，把字符串120作为参数传入给init构造方法，得到对象a
a=int("120")
# # 创建了一个int类的对象，把浮点数3.14作为参数传入给init构造方法，得到对象b
b=int(3.14)
# 将两个对象做加法运算，得到结果为123
print(a+b)

讲到这里你会发现其实python中对象无处不在。int(),float(),str(),list(),tuple(),dict()等等都是表示创建对象。

以下为算术运算相关的魔法方法

举例，定义一个int的子类，将加法变减法，减法变加法

# 加减互换
class New_int(int):
    # 在该类对象做加法的时候执行该方法，其内部实际做的是减法
    def __add__(self, other):
        return int.__sub__(self,other)
    # 在该类对象做减法的时候执行该方法，其内部实际做的是加法
    def __sub__(self, other):
        return int.__add__(self,other)

# 运行
# 将字符串3转换成整型
x=New_int("3")
#将字符串5转换成整型
y=New_int("5")
# 对象x调用加法魔法方法把y作为参数传入
print(x + y)# 可理解为x.__add__(y) 因此 3.add(5)实际是 3-5=-2
print(x - y)# 可理解为x.__sub__(y) 因此 3.sub(5)实际是 3+5=8
print(y + x)# 可理解为y.__add__(x) 因此 5.add(3)实际是 5-3=2
print(y - x)# 可理解为y.__sub__(x) 因此 5.sub(3)实际是 5+3=8

课堂练习:大家可以练习一下乘法，除法互换，练一练。

以下为反运算的常用魔法方法

那什么是反运算，我们在做a+b运算的时候，实际是a对象调用add方法去和b对象做运算，那么如果前者不是对象是纯数字，例如3+b,这种情况，前者不是对象，也就不存在add方法，而后者是有add方法的，那么python就会调用后者的radd方法进行执行运算，这种称为反运算，可以理解为后项驱动运算。

# 反运算
class Nint(int):
    def __radd__(self, other):
        return int.__sub__(self,other)
# 运行
z=Nint(10)
print(4+z)#前者不是对象，不具备add方法，则后者调用radd方法执行
# 结果应该是 10-4=6

Python还支持一元操作符的魔方方法:__neg__()表示正号行为，__pos__()表示负号行为，__abs__()表示绝对值行为，__invert__()表示按位取反行为。

10.3 属性访问

在上一章中，我们讲过一些内置函数操作对象的全局变量

class A:
    def __init__(self):
        self.x="XXX"
# 运行
a=A()
print(a.x)
print(getattr(a,"x"))
print(getattr(a,"y","不存在该变量"))
# 动态创建全局变量
setattr(a,"y","YYY")
print(getattr(a,"y","不存在该变量"))
delattr(a,"y")

以上这些方法也对应着魔法方法的触发

class E:
    def __init__(self):
        self.x=100
    def __getattribute__(self, item):
        print("该类的属性正在被访问……")
        return super().__getattribute__(item)
    def __getattr__(self, item):
        print("该类的属性正在被要求获取输出数据")
    def __setattr__(self, key, value):
        print("正在给该类的属性进行赋值")
        return super().__setattr__(key,value)
    def __delattr__(self, item):
        print("正在删除该类的属性变量")
        return super().__delattr__(item)
e=E()#创建对象时，会执行init方法，该方法中给x变量赋值，这时候会触发setattr这个魔法方法
print(e.x)#通过对象调用x这个全局变量，触发getattribute这个魔法方法，变量被访问
#运行结果
	#正在给该类的属性进行赋值
	#该类的属性正在被访问……
	#100
print(getattr(e,"x"))#通过getattr方法获得值，触发getattribute这个魔法方法
	#该类的属性正在被访问……
	#100
print(getattr(e,"y","不存在"))#通过getattr方法获得不存在的变量的值，
	#该类的属性正在被访问……
	#该类的属性正在被要求获取输出数据
	#不存在
setattr(e,"y",200)
	#正在给该类的属性进行赋值
print(getattr(e,"y","不存在"))
	#该类的属性正在被访问……
	#200
delattr(e,"y")
	#正在删除该类的属性变量

10.4 描述符(property的原理)

python提供了一下三个魔法方法，用来监听get，set，del方法的调用。

class My:
    def __get__(self, instance, owner):
        print("getting……")
    def __set__(self, instance, value):
        print("setting……")
    def __delete__(self, instance):
        print("deling……")

class Test:
    #将My类的对象作为测试类的全局变量
    x=My()
# 运行测试
t=Test()
#给My类进行赋值，被set魔法方法监听触发执行
t.x="test" #setting……
print(t.x)#获得my类的值，被get魔法方法监听触发执行
del t.x#删除my类对象，被delete魔法方法监听触发执行

 接下来我们自定义Property函数:

# 自定义Property函数
class MyProperty:
    def __init__(self,fget=None,fset=None,fdel=None):
        #将getX方法赋予fget变量
        self.fget=fget
        #将setX方法赋予fset变量
        self.fset=fset
        #将delX方法赋予fdel变量
        self.fdel=fdel
    #也就是说这里的三个全局变量其实是三个方法
    #那么当把该类对象当做属性来操作时，就会触发以下三个方法，则在方法中调用C类的三个方法，间接操作C类的私有变量
    def __get__(self, instance, owner):
        return self.fget(instance)
    def __set__(self, instance, value):
        self.fset(instance,value)
    def __delete__(self, instance):
        self.fdel(instance)
class C:
    # 定义构造方法
    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
    # 将以上三个方法作为参数传入MyProperty类中作为参数
    x=MyProperty(getX,setX,delX)
# 运行测试
c=C()
# x变量就是MyProperty类的对象
# 把hello赋值给x，也就是赋值给MyProperty类，则会触发set方法，则set方法中把接收到的hello又赋值给了C类中的私有变量_x
c.x="hello"
# 获得x变量，其实是获得MyProperty类的对象，则会触发get魔法方法，即调用getX方法，把_x的值输出
print(c.x)
#删除x变量，其实是删除MyProperty类的对象，则会触发delete魔法方法，即调用delX方法，把_x的变量删除
del c.x
# 测试x是否还存在
print(c.x)
# 通过输出结果可以看出，确实是把_x这个私有变量删除了
# AttributeError: 'C' object has no attribute '_x'

10.5 自定义序列容器

在python中，序列类型(类表，元组，字符串)或者映射类型(字典)都是属于容器，本节我们来自定义容器。

以下是自定义容器的相关魔法方法

案例:编写一个自定义列表，要求记录列表中每个元素被访问的次数

# 自定义列表，要求记录列表中每个元素被访问的次数
class CountList:
    # 定义构造方法，将元组数据进行保存至列表格式
    def __init__(self,*args):
        # 将传入进来的元组做循环获得里面的每一个元素存储至列表中
        self.value=[x for x in args]
        # 根据value列表的长度个数来填充初始化一个字典，每一个元素都用0填充
        self.count={}.fromkeys(range(len(self.value)),0)
    # 重写获得长度的魔法方法，将列表的长度进行返回
    def __len__(self):
        return len(self.value)
    #重写通过索引值获得某个元素时，触发该魔法方法
    def __getitem__(self, item):
        # 根据当前索引值得知哪个元素被访问，则把该元素对应在count字典中的元素中加一，记录该元素被访问了一次
        self.count[item]+=1
        # 并根据索引值从列表中将对应的元素返回
        return self.value[item]
# 运行测试
cl1=CountList(1,3,5,7,9)
cl2=CountList(2,4,6,8,10)
# 输出索引值为1的元素，同时记录被访问次数
print(cl1[1])#3
print(cl2[3])#8
print(cl1[1]+cl2[3])#11
# 以上cl1列表索引值为1的元素被访问了两次，一次输出，一次加法
# 以上cl2列表索引值为3的元素被访问了两次，一次输出，一次加法
print("输出列表中各元素的被访问次数:",cl1.count)
#输出列表中各元素的被访问次数: {0: 0, 1: 2, 2: 0, 3: 0, 4: 0}
print("输出列表中各元素的被访问次数:",cl2.count)
#输出列表中各元素的被访问次数: {0: 0, 1: 0, 2: 0, 3: 2, 4: 0}

10.6 迭代器

迭代的意思类似于循环，每一次重复的过程被称为一次迭代的过程，而每一次爹地啊得到的结果会被用来作为下一次迭代的初始值。例如:

for i in range(10):
    print(i,end=" ")
#运行结果:0 1 2 3 4 5 6 7 8 9

列表，元组，字符串，字典和集合都是带有迭代器的

links={"百度":"www.baidu.com","京东":"www.jd.com","淘宝":"www.taobao,com"}
for key in links:
    print("%s -> %s" % (key,links[key]))
#运行结果:
百度 -> www.baidu.com
京东 -> www.jd.com
淘宝 -> www.taobao,com

接下来介绍两个内建函数:iter()和next()

iter():任何容器对象调用它可以获得迭代对象

next():被调用时获得下一个元素值

当元素不存在的时候，会产生StopIteration异常

例如:

numbers=(1,11,12,23,24,34,45,56)
it=iter(numbers)
print(next(it))#1
print(next(it))#11
print(next(it))#12
print(next(it))#23
print(next(it))#24

因此，以上案例可以简化一下

numbers=(1,11,12,23,24,34,45,56)
it=iter(numbers)
while True:
    try:
        n=next(it)
    except StopIteration:
        break
    print(n)

以上代码中，建立while循环执行next方法获得元组中的迭代元素，直到产生StopIteration异常，表示迭代结束，则通过捕获异常来停止while循环，并每一次循环都输出迭代的元素。

那么以上两个内建函数有两个对应的魔法方法:

__iter()__和__next__()

例如:

class Filb:
    def __init__(self):
        self.x=0
        self.y=1
    def __iter__(self):
        return self
    def __next__(self):
        #每一次执行该方法，将x和y进行运算，最后返回x变量的值
        self.x,self.y=self.y,self.x+self.y
        return self.x
# 运行
# 调用执行构造方法，初始化x和y变量
f=Filb()
# 循环Filb类，则自动会调用iter魔法方法，返回当前类对象
for i in f:
    # 输出i，其实等价于执行了next()内建函数，因此每一次循环都会触发next魔法方法
    # 将计算后的x变量的值赋值给i，再判断i是否小于20，计算结果超过20则停止迭代循环
    if i<20:
        print(i,end="")
    else:
        break
运行结果:
    1 1 2 3 5 8 13 

如果想让运行测试的代码更简便，我们将封装的类进行升级一下，什么时候停止循环的判断和判断条件封装起来

class Filb:
    def __init__(self,total):
        self.total=total
        self.x=0
        self.y=1
    def __iter__(self):
        return self
    def __next__(self):
        # 如果不超出则进行计算，并返回x的值
        self.x, self.y = self.y, self.x + self.y
        #判断每一次迭代后，x的值是否会超出上线值
        # 如果超出上线，则抛出异常
        if self.x > self.total:
           raise StopIteration
        return self.x

# 运行
f=Filb(20)
for i in f:
    print(i,end=" ")

10.7 生成器

生成器是迭代器的一个特殊的用法，比迭代器更简洁，运用更方便。需要使用yield关键字

# 生成器的运用
def myGen():
    print("生成器被执行!!!")
    yield 1
    yield 2
# 该方法就是迭代对象
m=myGen()
# 直接使用next方法获得迭代对象中的元素
print(next(m))
print(next(m))

# 使用循环执行迭代器
for i in myGen():
    print(i)

使用生成器完成斐波那契数列的实现

def fbnq():
    a=0
    b=1
    while True:
        a,b=b,a+b
        yield a

# 执行该方法
for x in fbnq():
    if x>100:
        break
    print(x)

使用类来封装以上方法，进行简化测试的过程

# 定义斐波那契数列类
class FbnqC:
    def __init__(self,sum):
        self.sum=sum
    # 生成器迭代
    def fbnq(self):
        a = 0
        b = 1
        while True:
            a, b = b, a + b
            yield a
    #运行测试
    def test(self):
        for x in fbnq():
            if x > self.sum:
                break
            print(x)
f=FbnqC(1000)
f.test()

1.列表推导式:求出100以内能被2整除，但不能被3整除的所有数:

# 求出100以内能被2整除，但不能被3整除的所有数
a=[ i for i in range(100) if i % 2==0 and i %3!=0]
print(a)

简化一下

# 求出100以内能被2整除，但不能被3整除的所有数
a=[ i for i in range(100) if not(i % 2) and i %3]
print(a)

2.字典推导式:输出10以内，偶数输出True，奇数输出False

# 输出10以内，偶数输出True，奇数输出False
b={i:i%2==0 for i in range(10) }
print(b)

3.集合推导式:去除重复

c={ i for i in [1,1,2,3,3,4,5,5,5,6,6,7,7,8] }
print(c)