python杂记2.0

1. python的生成器和推导式

def myScq():
    print("生成器执行")
    yield  1
    yield  2
my1=myScq()
"""普通函数加上一个yield语句就变成生成器类，就可以实例化成生成器对象，生成器对象也是迭代器"""

"""生成器就是为了把一个空或者非空的函数加上若干有上下顺序的yield语句，变成一个生成器类，
可以实例化成生成器对象，就是实例化成一个可迭代的迭代器，所以就是通过函数和yield语句快速产生指定迭代器，
并且这个迭代器可以在一次next之后暂停挂起"""
print(sum(my1))#输出每次迭代出的结果的和
# print(next(my1))
# print(next(my1))
for i in myScq(): print(i)
for i in my1: print(i)
"""这俩for的底层next是不一样的，会重新开始
但是如果前面只是next，for循环会接着遍历输出"""

print("-------__---------------------------")
def libs():
    a=0
    b=1
    while True:
        a,b=b,a+b
        yield a
for each in libs():

    """for循环虽然底层有捕获StopIteration机制，但是在for循环表面手动抛出的不会捕获要自己再加一个try和except"""
    try:
        if each>1000:
            raise StopIteration
        else:
            print(each)
    except StopIteration as e:
        print(e.__str__())
        break
















a=[i for i in range(100) if  not i%2 and i%3]

"""这个就是看列表推导式if后面的真值，i%2为0时并且i%3不是0时 就是真，其他情况都是假，为真也就是满足条件的i的本身返回值才能存入a列表
不论是神魔推导式，都是存入方式（返回值）+遍历+条件限制"""
print(a)

b={i:i%2==0 for i in range(10)}
"""字典推导式"""
"""这里i%2==0的返回值就是存入的值，i就是存入的键，后面时遍历"""
print(b)


c={i for i in [1,2,3,1,2,3,4,5,6,6,6,6,6,6,6,6]}
"""集合推导式"""
"""集合推导式可以用于列表去重"""
print(c)

# d="i for i in [1,2,3,4,5,7]"
# print(d)没有字符串推导式。。。

d=(i for i in [1,2,3,4,5,7,9,9])
"""这个不是元组推导式，而是生成器推导式，说白了还是生成一个迭代器"""
print(d)
print(next(d))
print(next(d))
print(next(d))
print(next(d))
print(next(d))
print(next(d))
print(next(d))
print(next(d))

for each in d:
    """in后面可迭代对象和迭代器一样放"""
    """这里接着前面next输出就没有输出了"""
    print(each,end=" ")
print(sum(i for i in [1,2,3,4,5,7]))#22
print(sum((i for i in [1,2,3,4,5,7])))#22
"""生成器推导式做参数时可以不要外层括号"""

python列表推导式、字典推导式、集合推导式-CSDN博客

【技能树共建】Python 三元表达式_python三元表达式-CSDN博客

【精选】【技能树共建】Python 列表推导式_列表推导式重复生成一个值-CSDN博客

2.python中property的底层逻辑分析

class MyProperty:
    def __init__(self,fget=None,fset=None,fdel=None):
        self.fget = fget
        self.fset = fset
        self.fdel=fdel
    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
    x=MyProperty(getX,setX,delX)
c1=C()
print(c1.x)
c1.x=260
print(c1.x)
del c1.x

"""上述代码展示了py中property的底层逻辑，就是一个property类实例化，
按照上面代码具体过程：
实例化C类成c1对象时,会创建x这个属性，也就时实例化这个属性，会把C类中其他三个方法名当成属性一样传进去，（内置的bif方法也可以这样操作，就是方法的传递赋值）这时property类创建三个自己的动态方法名来接收，就是x自己的方法了(就是x可以调用，其他都一样）

当c1调用x属性对象的时候，就会触发x对象的__get__方法，self就是x对象的引用，instance就是c1对象的引用，owner就是C类的引用，然后__get__方法返回的fget也就是getX方法中:self就是原来的instance也就是c1
所以就可以对c1的原生属性进行操作了，即使私有属性也可以操作，其他两个行为的触发机制都一样


内置bif方法可以调用正常调用机制方法
方法名有时候可以当属性名用，可以把一个方法赋给另一个方法"""

 3.Python的私有不是绝对的

class  Person:
    __b=0
    def __init__(self,b):
        self.__b=b
        print("Person构造函数调用")
        self.__fun()
    def get__B(self):
        print(self.__b)
    def __fun(self):
        print("fun函数调用")
    def ooo():
        print("ooo")
    def cao(self):
        self.__fun()
       # ooo()
        print(self.__b)

p1=Person(10)
p1.get__B()
#print(p1.__b)
print("--------------------------------")
print(p1._Person__b)
print(p1._Person__fun())
"""py中的私有属性和方法只不过是对类外加了一个  _类名  还是可以直接调用"""
print("--------------------------------")
p1.cao()

4.python魔法方法讨论

class CapStr(str):
    def __new__(cls,string):
        string = string.upper()
        return str.__new__(cls,string)
a=CapStr("I love FishC.com!")
"""三种重写内置bif达到不同效果的方法：
1。改变传进去的参数，2步
2.返回不同的父类内置调用  3步
3.子类实例引用向上转型成父类引用   4步"""
print(a)

# class New_int(int):
#     def __add__(self,other):
#         return int.__sub__(self, other)
#     def __sub__(self, other):
#         return int.__add__(self, other)
# b=New_int("250")
# c=New_int("38")
# print(b+c)
# print(b-c)




# class Try_int(int):
#     def __add__(self,other):
#         return self+other
#     def __sub__(self, other):
#         return self-other
# b=Try_int("250")
# c=Try_int("30")
# print(b+c)


# class Try_int(int):
#     def __add__(self,other):
#         return int(self)-int(other)
#     def __sub__(self, other):
#         return int(self)+int(other)
# b=Try_int("250")
# c=Try_int("30")
# print(b+c)
# print(b-c)


class int(int):
    def __add__(self,other):
        return int.__sub__(self,other)
    def __radd__(self,other):
        return  int.__sub__(self,other)

# b=3
# c=4
# pint(b-c)
"""如果子父类相同名字，优先用父类地"""
b=int("250")
c=int("1000")
print(b+c)
print(2000+c+b+c)
"""加了r的这些内置bif就是从左到右第一个是实例化变量时就开始操作为self(就是左边的参数，可以更改位置),并且一个操作符操作一次
"""