Python 第十二天

复习

"""单例模式"""


class A1(object):
    def __new__(cls, *args, **kwargs):
        if not hasattr(cls, 'inst'):
            cls.inst = object.__new__(cls)
        return cls.inst

    def __init__(self, x, y):
        self.x = x
        self.y = y


a = A1(1, 2)
b = A1('a', 'b')
c = A1('*', '@')
print(a.x, a.y)

"""斐波那切数列"""


class A2():
    def __call__(self, x):
        a = 1
        b = 1
        lb = []
        if x == 1:
            lb.append(1)
        elif x == 2:
            lb.append(1)
            lb.append(1)
        else:
            n = 1
            while n <= x:
                lb.append(a)
                a, b = b, a + b
                n += 1
            return lb


t = A2()
print(t(8))

"""判断是否相同"""


class A3():
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def __hash__(self):
        pass
        return hash((self.name, self.age))

    def __eq__(self, other):
        if self.name == other.name and self.age == other.age:
            return True
        else:
            return False


a = A3('张三', 19)
b = A3('李四', 19)
c = A3('张三', 19)
print(hash(a))
print(hash(b))
print(hash(c))
print(a == b)
print(a == c)
print(b == c)
lb = []
if a not in lb:
    lb.append(a)
if b not in lb:
    lb.append(b)
if c not in lb:
    lb.append(c)
print(lb)

print(dir([].__iter__()))
print(dir({}.__iter__()))
print(dir(().__iter__()))
print(dir("".__iter__()))

for i in dir(()):
    b = i.strip('_')
    if b == 'netx':
        print(b)

for i in dir({}):
    print(i)

for i in dir(()):
    print(i)

for i in dir(""):
    print(i)

a = [1, 2, 3]

b = a.__iter__()
print(next(b))
print(b.__next__())
print(next(b))
# print(next(b))

a = 'qwert'
b = list(a)
print(b)
a = tuple(b)
print(a)

class Fib():
    def __init__(self, num):
        self.num = num
        self.current = 1
        self.a = 1
        self.b = 1

    def __iter__(self):
        return self

    def __next__(self):
        if self.current <= self.num:
            ret = self.a
            self.a, self.b = self.b, self.a + self.b
            self.current += 1
            return ret
        else:
            raise StopIteration


for i in Fib(13):
    print(i)

def aFun():
    i = 0
    while i < 10:
        yield i
        i += 1


a = aFun()
print('-------------------------------yield-------------------------------------------')
print(next(a))
print(next(a))


def bFun():
    i = 0
    while i < 10:
        return i
        i += 1


b = bFun()
print('--------------------------------return------------------------------------------')
print(b)


def cFun():
    for i in range(11):
        yield i


c = cFun()
print('--------------------------------------------------------------------------')
print(next(c))
print(next(c))
print(next(c))

def xx():
    yield 1
    yield 2


x = xx()
print(x)
print(next(x))
print(next(x))


def yy():
    return 1


y = yy()
print(y)


def zz():
    for x in range(10):
        yield '第%d个' % (x + 1)


z = zz()
for i in z:
    print(i)

def xx():
    a=0
    b=yield a
    print('a---------',a)
    print('b---------',b)
    yield 2
    yield 3

x=xx()
print(next(x))
y=x.send(999)
print(y)
print(next(x))

def xx():
    for i in 'qwer':
        yield i
    for j in range(5):
        yield j


x = xx()

for k in x:
    print(k)


def yy():
    lb = []
    for i in 'sdf':
        lb.append(i)
    for j in range(5):
        lb.append(j)
    return lb


y = yy()
for k in y:
    print(k)

def xx():
    yield from 'ab'
    yield from range(3)


x = xx()
for i in x:
    print(i)
print('--------------------------------------------------------------------------')
for j in xx():
    print(j)

print('--------------------------------------------------------------------------')
def yy():
    lb = []
    for i in 'sdf':
        lb.append(i)
    for j in range(5):
        lb.append(j)
    return lb


for y in yy():
    print(y)

"""列表推导式"""
a = [i for i in range(5)]
print(a)

"""集合推导式"""
b = {i for i in range(5)}
print(b)

"""生成器表达式"""
c = (i for i in range(5))
print(c)
print(next(c))
for i in c:
    print(i)

""""闭包函数"""


def x1(tax):
    def x2(a, b):
        c = (a + b) * tax
        return c

    return x2


z1 = x1(0.2)
y1 = z1(1, 2)
y2 = z1(3, 4)
print(y1, y2)

a1 = x1(0.3)
b1 = a1(3, 4)
b2 = a1(5, 6)
print(b1, b2)
print(z1(10, 0))

"""闭包检测"""


def a1(tax):
    def b_1(a, b):
        c = (a + b) * tax
        return c

    print(b_1.__closure__)
    return b_1


t = a1(1)
t(1, 2)


def a2(tax):
    def b_2(a, b):
        c = a + b
        return c

    print(b_2.__closure__)
    return b_2


t = a2(1)
t(1, 2)

import time

def hehe(f):
    def haha():
        a=time.time()
        print('start')
        f()
        b=time.time()
        print('over',b-a)
    return haha

@hehe
def hs():
    print('开始')
    he=0
    for i in range(13):
        he+=i
    print('结束')

hs()
@hehe
def hs1():
    print('1111111111111111111111')
    print('2222222222222222222222')

hs1()

def decor(f):
    def inner(*args, **kwargs):
        print('*********************************')
        f(*args, **kwargs)
        print('*********************************')

    return inner


@decor
def ych(*args, **kwargs):
    print(args)
    for i in args:
        print(i, end=' ')
    print()
    print(kwargs)
    for i, j in kwargs.items():
        print(i, j)


ych('周杰伦', '刘亦菲', age=22, address='广州')


def xx(z):
    def yy(a, b):
        print('-----------------------------------')
        z(a, b)
        print('-----------------------------------')

    return yy


@xx
def zz(name, age):
    print(name, age)


zz('史蒂夫', 19)

def aa(f):
    def inner(a, b):
        print('$$$$$$$$$$$$$$$$$$$$$$$$')
        r = f(a, b)
        print('$$$$$$$$$$$$$$$$$$$$$$$$')
        return r

    return inner


@aa
def bb(a, b):
    print(a, b)
    return 'bb的返回值'


x = bb('全微分', 19)
print('显示x',x)

from functools import wraps


def decor(f):
    @wraps(f)
    def inner(name, age):
        print('***********************************')
        r = f(name, age)
        print('***********************************')
        return r

    return inner


@decor
def hanshu(name, age):
    """
    :param name:
    :param age:
    :return:
    """
    print(name, age)
    return name + str(age)


x = hanshu('迪丽热巴', 23)
print(x)
print(hanshu.__doc__)
print(hanshu.__name__)

def aA(f):
    def inner(a,b):
        print('aA开始')
        c=f(a,b)
        print('aA结束')
        return c+1
    return inner

def bB(f):
    def inner(a,b):
        print('bB开始')
        c=f(a,b)
        print('bB结束')
        return c+1
    return inner

@aA
@bB
def cC(a,b):
    print('cC开始')
    print('cC结束')
    return a+b

print(cC(3,4))

class A():
    def __init__(self, name, age):
        self.name = name
        self._age = age

    @property #将函数当属性使用
    def shown(self):
        print('pppppppppppppppppp')
        return self._age

    @shown.setter
    def shown(self, x):
        print('11111111111111111')
        self._age = x


s = A('张三', 19)
s.shown = 29
print(s.shown)
# print(s.name)

""""属性不能与装饰器重名"""


class A():
    def __init__(self, name, age,shown):
        self.name = name
        self._age = age
        self.shown=shown
    @property #将函数当属性使用
    def shown(self):
        print('pppppppppppppppppp')
        return self.shown

    @shown.setter
    def shown(self, x):
        print('11111111111111111')
        self.shown=x


s = A('张三', 19,20)
s.shown = 29
print(s.shown)
# print(s.name)

class A():
    def __init__(self):
        pass

    @property
    def Year(self):
        return self.age

    @Year.setter
    def Year(self, x):
        if x > 65 or x < 18:
            self.age = 0
        else:
            self.age = x


a = A()
a.Year = 190
print(a.Year)


class A1():
    def __init__(self, age):
        self.__age = age

    @property
    def Year(self):
        return self.__age

    @Year.setter
    def Year(self, x):
        if x > 65 or x < 18:
            self.__age = 0
        else:
            self.__age = x


a1 = A1(19)
a1.Year = 190
print(a1.Year)

from math import pi


class A3():
    def __init__(self, r):
        self.r = r

    @property
    def perimeter(self):
        return (self.r + self.r) * pi

    @property
    def area(self):
        return pi * (self.r ** 2)


a2 = A3(4)
print(a2.area)
print(a2.perimeter)


class BMI():
    def __init__(self, Weight, Height):
        self.Weight = Weight
        self.Height = Height

    @property
    def EX(self):
        ex = self.Weight / (self.Height ** 2)
        if ex < 18.5:
            return '过轻'
        elif ex <= 23.9:
            return '正常'
        elif ex <= 27:
            return '过重'
        elif ex <= 32:
            return '肥胖'
        else:
            return '非常肥胖'


a3 = BMI(82, 1.76)
print(a3.EX)

"""实例方法等于对象方法"""
"""静态方法"""


class A():
    @staticmethod
    def xx():
        print('孤儿')

    def yy(self):
        print('对象')
    @classmethod
    def zz(cls):
        print('类')


a = A()
a.xx()
a.yy()
# A.yy()
A.yy(a)  # 不建议这么使用
A.zz()
a.zz()

class Fruits():
    def __init__(self, fruits_name, price):
        self.fruits_name = fruits_name
        self.price = price

    @classmethod
    def zhekou(cls, x):
        cls.x = x

    def Price(self):
        return self.price * Fruits.x


a = Fruits('苹果', 12)
print(a.price)
b = Fruits('香蕉', 15)
print(b.price)
Fruits.zhekou(0.9)
print(a.Price())
print(b.Price())


class Fruits1():
    def __init__(self, fruits_name, price):
        self.fruits_name = fruits_name
        self.price = price

    @classmethod
    def zhekou(self, x):
        self.x = x

    def Price(self):
        return self.price * Fruits.x


a = Fruits1('苹果', 12)
print(a.price)
b = Fruits1('香蕉', 15)
print(b.price)
Fruits.zhekou(0.9)
print(a.Price())
print(b.Price())

def xx():
    a = 0
    b = 1
    c = 0
    sum_1 = 0

    while True:
        a = yield c
        # print(c)
        sum_1 = sum_1 + a
        c = sum_1 / b
        b += 1


x = xx()
next(x)
print(x.send(10))
print(x.send(20))
print(x.send(30))

def aA(f):
    def inner():
        print('aA开始')
        f()
        print('aA结束')
    return inner

def bB(f):
    def inner():
        print('bB开始')
        f()
        print('bB结束')
    return inner

@aA
@bB
def cC():
    print('cC开始')
    print('cC结束')

cC()

def xx():
    for i in range(5):
        j = yield i
        print('123', j)
        print('循环体')
    print('结束')


c = xx()
# print(c)
print('第一次', next(c), '第一次')  # 当使用next时，next的机制是根据自身在程序中所针对的函数出现的次数输出yield对应次数的值
# 如果有多个next叠加使用，则下一个next会将上一个next到这个next之间的代码都执行一次
print('第二次', next(c), '第二次')
# print('第三次',next(c),'第三次')
a = c.send(100)  # 将100的值传递给j，并执行循环体以yield为分隔的后半部分的代码
d = xx()
print("d第一次", next(d))

作业

1.通过迭代器获取素数

class IsPrime():
    def __init__(self, Start, End):
        self.Start = Start
        self.End = End
        self.r = 0

    def __iter__(self):
        return self

    def __next__(self):
        if self.Start <= self.End:
            for i in range(2, self.Start):
                if self.Start % i == 0:
                    break
            else:
                self.r = self.Start
            self.Start += 1
            return self.r
        else:
            raise StopIteration


a = IsPrime(4, 23)
a = set(a)
for i in a:
    print(i, end=' ')

2.通过生成器写入文件

"""生成器"""


# Open document
# FileRead
# File Write
# File content
def file_write():
    fileContent = open('a.txt', 'w')
    for i in range(5):
        fileContent.write((yield i))
    fileContent.close()


a = file_write()
print(next(a))
c = a.send('10000')

3.通过生成器输出空心棱形

"""装饰器"""


def above(f):
    def xx(a):
        f(a)

    return xx


@above
def above_inner(a):
    for i in range(1, a):
        for j in range(a - i):
            print(" ", end='')
        for k in range(2 * i - 1):
            if i == 0 or k == 0 or k == 2 * i - 2:
                print('*', end='')
            else:
                print(' ', end='')
        print()


@above
def above_inner1(a):
    for i in range(a, -1, -1):
        for j in range(a - i):
            print(" ", end='')
        for k in range(2 * i - 1):
            if i == 0 or k == 0 or k == 2 * i - 2:
                print('*', end='')
            else:
                print(' ', end='')
        print()


above_inner(7)
above_inner1(7)