Python基础_second

    from functools import wraps
    def wrapper(func):  #func = holiday
        @wraps(func)
        def inner(*args,**kwargs):
            print(‘在被装饰的函数执行之前做的事‘)
            ret = func(*args,**kwargs)
            print(‘在被装饰的函数执行之后做的事‘)
            return ret
        return inner

    @wrapper   #holiday = wrapper(holiday)
    def holiday(day):
        ‘‘‘这是一个放假通知‘‘‘
        print(‘全体放假%s天‘%day)
        return ‘好开心‘

    print(holiday.__name__)
    print(holiday.__doc__)
    ret = holiday(3)   #inner
    print(ret)

    @wrapper→@wrapper（argument）三层 嵌套函数    
    def outer(形参) :                                           
          def wrapper(func):                                        
                @wraps(func)                                         
                def inner(*args,**kwargs):                     
                      ‘‘‘被装饰函数之前的函数处理‘‘‘         
                      ret=func(*args,**kwargs) 
                      ‘‘‘被装饰函数之后的函数处理‘‘‘  
                      return ret                    
                 return inner                    
    @outer(实参)  

    #应用于多个函数时，可通过参数来指定哪些程序开放执行
    import time
    FLAGE = False
    def timmer_out(flag):
        def timmer(func):
            def inner(*args,**kwargs):
                if flag:
                    start = time.time()
                    ret = func(*args,**kwargs)
                    end = time.time()
                    print(end-start)
                    return ret
                else:
                    ret = func(*args, **kwargs)
                    return ret
            return inner
        return timmer
    # timmer = timmer_out(FLAGE)
    @timmer_out(FLAGE)    #wahaha = timmer(wahaha)
    def wahaha():
    time.sleep(0.1)
    print(‘wahahahahahaha‘)
    
    @timmer_out(FLAGE)
    def xiaoxiaozi():
        time.sleep(0.1)
        print(‘xiaoxiaozizizi‘)
    
    wahaha()
    xiaoxiaozi()

    @wrapper1
    @wrapper2 
    装饰器先执行wrapper 2 
    在装饰函数之前的语句：先执行wrapper1中的。
    在装饰函数之后的语句：先执行wrapper2中的。

    def wrapper1(func):
        def inner1():
            print(‘wrapper1 ,before func‘)
            ret = func()
            print(‘wrapper1 ,after func‘)
            return ret
        return inner1

    def wrapper2(func):
        def inner2():
            print(‘wrapper2 ,before func‘)
            ret = func()
            print(‘wrapper2 ,after func‘)
            return ret
        return inner2

    def wrapper3(func):
        def inner3():
            print(‘wrapper3 ,before func‘)
            ret = func()
            print(‘wrapper3 ,after func‘)
            return ret
        return inner3

    @wrapper3
    @wrapper2
    @wrapper1
    def f():
        print(‘in f‘)
        return ‘哈哈哈‘

    print(f()

    flag=False
    def wrapper(func):
        def inner(*args,**kwargs):
            global flag   #
            if flag:
                ret=func(*args,**kwargs)
                return ret
            else:
                while 1:
                    username=input("请输入用户名:")
                    password=input("请输入密码:")
                    li=[]
                    with open("zhmm.txt",mode="r+",encoding="utf-8") as f:
                        for line in f:
                            li.append(line)
                        if username==li[0].strip(‘\n‘) and     password==li[1].strip(‘\n‘):
                           print("登陆成功")
                           flag=True
                           ret=func(*args,**kwargs)
                           return ret
                           break
                        else:
                           print("密码错误,请重新登陆!")
        return inner

    @wrapper
    def f1():
        print("123")
    @wrapper
    def f2():
        print("456")

    f1()
    f2()

    def decor(func):
          def inner(*args,**kwargs):
                with open(‘log‘,‘a‘,encoding=‘utf-8‘) as f:
                    f.write(func.__name__+"\n")
                    func(*args,**kwargs)
          return inner
    @decor
    def f1():
        print("f1")
    @decor   
    def f2():
        print("f2")
    @decor    
    def f3():
        print("f3")
    f1()
    f2()
    f3()
    f2()

    def get_webContent(url):
          html_sourceCode=urlopen(url).read()
          return html_sourceCode

    ret=get_webContent(‘http://www.baidu.com‘)
    print(ret)

    import os
    from urllib.request import urlopen
    def cache(func):
        def inner(*args,**kwargs):
            if os.path.getsize(‘web_content‘):#文件大小不为0时
                with open(‘web_content‘,‘rb‘) as f:
                    return f.read()
            ret=func(*args,**kwargs)
            with open("web_content",‘wb‘) as f:
                f.write(b‘****‘+ret)     
            return ret
        return inner

　　@cache
　　def get_webContent(url):
　　    html_sourceCode=urlopen(url).read()
 　　   return html_sourceCode

　　ret=get_webContent(‘http://www.baidu.com‘)
　　print(ret)
　　ret=get_webContent(‘http://www.baidu.com‘)
　　print(ret)
　　ret=get_webContent(‘http://www.baidu.com‘)
　　print(ret)

    #只要是能被for循环的数据类型 就一定拥有__iter__方法
    print([].__iter__())
    #一个列表执行了__iter__()之后的返回值就是一个迭代器
    print(dir([]))
    print(dir([].__iter__()))
    print(set(dir([].__iter__())) - set(dir([])))#差分
    print([1,‘a‘,‘bbb‘].__iter__().__length_hint__())#元素个数

    l = [1,2,3]
    iterator = l.__iter__()
    print(iterator.__next__())
    print(iterator.__next__())
    print(iterator.__next__())
    print(iterator.__next__())    

    print(‘__iter__‘ in dir( [].__iter__()))
    print(‘__next__‘ in dir( [].__iter__()))
    from collections import Iterable
    from collections import Iterator
    print(isinstance([],Iterator))
    print(isinstance([],Iterable))

    class A:
        # def __iter__(self):pass
        def __next__(self):pass
    a = A()
    print(isinstance(a,Iterator))
    print(isinstance(a,Iterable))

    def generator():
        print(1)
        yield ‘a‘ 
    ret = generator()#返回一个生成器
    print(ret)
    print(ret.__next__())#执行到yield停止

    def generator():
        print(1)
        yield ‘a‘
        print(2)
        yield ‘b‘
        yield ‘c‘
    g = generator()
    for i in g:#for循环本身就是迭代输出
        print(i)
    ##ret = g.__next__()
    ##print(ret)
    ##ret = g.__next__()
    ##print(ret)
    ##ret = g.__next__()
    ##print(ret)

    def wahaha():
        for i in range(2000000):
            yield ‘娃哈哈%s‘%i
    g = wahaha()
    g1 = wahaha()
    print(g.__next__())
    print(g1.__next__())

    def wahaha():
        for i in range(2000000):
            yield ‘娃哈哈%s‘%i
    g = wahaha()
    count = 0
    for i in g:
        count +=1
        print(i)
        if count > 50:
            break
    print(‘*******‘,g.__next__())
    for i in g:
        count +=1
        print(i)
        if count > 100:
            break

    def generator():
        print(123)
        content = yield 1
        print(‘=======‘,content)
        print(456)
        arg = yield 2
        ‘‘‘‘‘‘
        yield
    g1 = generator()
    g2 = generator()
    g1.__next__()
    g2.__next__()#执行到yield之前
    print(‘***‘,generator().__next__())#执行到yield并将值1进行返回打印
    print(‘***‘,generator().__next__())
    g = generator()
    ret = g.__next__()#将返回值赋给ret,此时只执行到yield，但并未将返回值进行处理
    print(‘***‘,ret)#返回值进行处理:打印
    ret = g.send(‘hello‘)   #send的效果和next一样，执行send前必须先执行一次__next__()
    print(‘***‘,ret)#执行yield左边的内容，即进行赋值,然后执行yield 1与yield 2之间的部分,并将返回值打印。
    #最后一个yield是为了再执行send时，可以对传入的值进行操作，但并无返回值，仅是为了使程序停止。

    def init(func):   #装饰器
        def inner(*args,**kwargs):
            g = func(*args,**kwargs)    #g = average()
            g.__next__()
            return g
        return inner
    @init
    def average():
        sum = 0
        count = 0
        avg = 0
        while True:
            num = yield avg
            sum += num    # 10
            count += 1    # 1
            avg = sum/count
    avg_g = average()   #===> inner
    ret = avg_g.send(10)
    print(ret)
    ret = avg_g.send(20)
    print(ret)

    def generator():
        a = ‘abcde‘
        b = ‘12345‘
        for i in a:
            yield i
        for i in b:
            yield i
    ##同下面的表达
    ##    yield a[0]
    ##    yield a[1]
    ##    yield a[2]
    ##    yield a[3]
    ##    yield a[4]
    ##    yield b[0]
    ##    yield b[1]
    ##    yield b[2]
    ##    yield b[3]
    ##    yield b[4]
    def generator():
        a = ‘abcde‘
        b = ‘12345‘
        yield from a
        yield from b

    g = generator()
    for i in g:
        print(i)

    g = (i for i in range(10))
    print(g)
    #上下的执行结果相同
    for i in  g:
        print(i)

    def tail(filename):
        f = open(filename,encoding=‘utf-8‘)
        while True:
            line = f.readline()
            if line.strip():
                yield line.strip()

    g = tail(‘file‘)
    for i in g:
        if ‘python‘ in i:
            print(‘***‘,i)

    ##readline:行读取。
    ##read(10)：读取指定大小的内容。
    def generator():
    for i in range(20):
       yield ‘哇哈哈%s‘%i
    g = generator()  #调用生成器函数得到一个生成器
    print(list(g))
    ret = g.__next__()#每一次执行g.__next__就是从生成器中取值，预示着生成器函数中的代码继续执行
    print(ret)

    #num:10 20 30 10
    #avg:10 15 20 17.5
    def average():
        sum = 0
        count = 0
        avg = 0
        while True:
            num = yield avg
            sum += num    # 10
            count += 1    # 1
            avg = sum/count
    avg_g = average()
    avg_g.__next__()
    avg1 = avg_g.send(10)
    avg1 = avg_g.send(20)
    print(avg1)

    def check_file():
        with open("java.docx",encoding="utf-8") as f:
            for i in f:
                if "java" in i:
                    yield i
    g=check_file()
    for i in g:
        print(i.strip())

    1.
    def demo():
        for i in range(4):
            yield i

    g=demo()
    g1=(i for i in g)
    g2=(i for i in g1)
    print(list(g1))#执行完后g1取值完成，全部给了list,即列表有值，而g1空了
    print(list(g2))#当执行这句时g1没有值了，所以g2无法取到值

    2.
    def add(n,i):
        return n+i

    def test():
        for i in range(4):
            yield i
        
    g=test()

    for n in [1,10,5]:
        g=(add(n,i) for i in g)
    ##等价于：
    ##n=1时
    ##g=(add(n,i) for i in g)
    ##n=10
    ##g=(add(n,i) for i in g)
    ##n=5
    ##g=(add(n,i) for i in g)
    #g=(add(n,i) for i in (add(n,i) for i in add(n,i) for i in g))令n=5，g初始取[0,1,2,3]进行计算
    print(list(g))#所有最后输出为15,16,17,18    

    reversed()参数:序列,返回值:反序迭代器

    l = [1,2,3,4,5]
    l.reverse()
    print(l)
    l = [1,2,3,4,5]
    l2 = reversed(l)
    print(l2)# 保留原列表，返回一个反向的迭代器

    slice():切片

    l = (1,2,23,213,5612,342,43)
    sli = slice(1,5,2)
    print(l[sli])
    print(l[1:5:2])

    str
    format:格式化输出
    print(format(‘test‘, ‘<20‘))#开辟20个字节的空间,并将test左对齐显    示。
    print(format(‘test‘, ‘>40‘))#开辟40个字节的空间,并将test右对齐显示。
    print(format(‘test‘, ‘^40‘))#开辟40个字节的空间,并将test居中显示。
    bytes
    #转换成bytes类型
    # gbk编码→utf-8编码
    print(bytes(‘你好‘,encoding=‘GBK‘))     # unicode转换成GBK的        bytes
    print(bytes(‘你好‘,encoding=‘utf-8‘))   # unicode转换成utf-8的bytes
    bytearray
    #网络编程 只能传二进制
    #照片和视频也是以二进制存储
    #html网页爬取到的也是编码
    b_array = bytearray(‘你好‘,encoding=‘utf-8‘)
    print(b_array)
    切片 —— 字节类型  不占内存
    print(b_array[0])#可按字节进行修改
    ‘\xe4\xbd\xa0\xe5\xa5\xbd‘
    例如:修改字符串中的a,b
    s1 = ‘alexa‘
    s2 = ‘alexb‘

    字节 —— 字符串 占内存
    l = ‘ahfjskjlyhtgeoahwkvnadlnv‘
    l2 = l[:10]

    memoryview:memory(bytes(‘hello,eva‘,encoding="utf-8"))。

    ord:字符按照Unicode转数字
    print(ord(‘好‘))
    print(ord(‘1‘))

    chr:数字按照Unicode转字符
    print(chr(97))

    ascii:只要是ASCII码中的内容就打印，不是就转成\u
    print(ascii(‘好‘))
    print(ascii(‘1‘))
    name = ‘egg‘
    print(‘你好%r‘%name)

    repr:用于%r格式化输出
    print(repr(‘1‘))
    print(repr(1))        

    print(all([‘a‘,‘‘,123]))#一个为假整体为假
    print(all([‘a‘,123]))
    print(all([0,123]))

    print(any([‘‘,True,0,[]]))#一个为真整体为真

    l = [1,2,3,4,5]
    l2 = [‘a‘,‘b‘,‘c‘,‘d‘]
    l3 = (‘*‘,‘**‘,[1,2])
    d = {‘k1‘:1,‘k2‘:2}
    for i in zip(l,l2,l3,d):
        print(i)

    def is_odd(x):
        return x % 2 == 1
    def is_str(s):
        return s and str(s).strip()
    ret1 = filter(is_odd, [1,  6, 7, 12, 17])
    ret2 = filter(is_str, [1, ‘hello‘,‘‘,‘  ‘,None,[], 6, 7, ‘world‘, 12, 17])
    print(ret1)
    print(ret2)
    for i in ret1:
        print(i)
    for i in ret2:
        print(i)
    #[i for i in [1, 4, 6, 7, 9, 12, 17] if i % 2 == 1]

    #求出1-100之间开平方为整数的值
    from math import sqrt
    def func(num):
        res = sqrt(num)
        return res % 1 == 0
    ret = filter(func,range(1,101))
    for i in ret:
        print(i)

    ret = map(abs,[1,-4,6,-8])
    print(ret)
    for i in ret:
        print(i)

    l = [1,-4,6,5,-10]
    l.sort(key = abs)#在原列表的基础上进行排序
    print(l)
    print(sorted(l,key=abs,reverse=True))#生成了一个新列表,占内存,默认升序
    print(l)#原列表没变

    l = [‘   ‘,[1,2],‘hello world‘]
    new_l = sorted(l,key=len)
    print(new_l)

    def add(x,y):
        return x+y
    add = lambda x,y:x+y
    print(add(1,2))

    dic={‘k1‘:10,‘k2‘:100,‘k3‘:30}
    def func(key):
        return dic[key]
    print(max(dic,key=func))   #根据返回值判断最大值，返回值最大的那个参数是结果
    print(max(dic,key=lambda key:dic[key]))
    max([1,2,3,4,5,-6,-7],key=abs)

    ret = map(abs,[-1,2,-3,4])
    for i in ret:
        print(i)
    

    def func(x):
        return x**2
    ret = map(func,[-1,2,-3,4])
    for i in ret:
        print(i)
    ret = map(lambda x:x**2,[-1,2,-3,4])

    d = lambda p:p*2
    t = lambda p:p*3
    x = 2
    x = d(x) #x = 4
    x = t(x) #x = 12
    x = d(x) #x = 24
    print(x)

    name=[‘alex‘,‘wupeiqi‘,‘yuanhao‘,‘nezha‘]
    def func(item):
        return item+‘_sb‘
    ret = map(func,name)   #ret是迭代器
    for i in ret:
        print(i)
    print(list(ret))
    ret = map(lambda item:item+‘_sb‘,name)
    print(list(ret))

    num = [1,3,5,6,7,8]
    def func(x):
        if x%2 == 0:
            return True
    #由于在filter函数中,当传入参数使函数成立时，filter才返回真，即将这个值顺便保存。所以可以直接将判断条件作为返回值。
    def func(x):
        return x%2==0

    ret = filter(func,num)  #ret是迭代器
    print(list(ret))
    ret = filter(lambda x:x%2 == 0,num)
    ret = filter(lambda x:True if x%2 == 0 else False,num)
    print(list(ret))

    with open(‘file‘,encoding=‘utf-8‘) as f:
        l = f.readlines()
    page_num = int(input(‘请输入页码 ： ‘))
    pages,mod = divmod(len(l),5) #求有多少页，有没有剩余的行数
    if mod:           # 如果有剩余的行数，那么页数加一
        pages += 1    # 一共有多少页
    if page_num > pages or page_num <= 0:   #用户输入的页数大于总数或者小于等于0
        print(‘输入有误‘)
    elif page_num == pages and mod !=0:    #如果用户输入的页码是最后一页，且之前有过剩余行数
        for i in range(mod):
            print(l[(page_num-1)*5 +i].strip())  #只输出这一页上剩余的行
    else:
        for i in range(5):
            print(l[(page_num-1)*5 +i].strip())  #输出5行

    ret = map(lambda dic : {dic[‘name‘]:round(dic[‘shares‘]*dic[‘price‘],2)},portfolio)
    print(list(ret))

    ret = filter(lambda dic:True if dic[‘price‘] > 100 else False,portfolio)
    print(list(ret))
    ret = filter(lambda dic:dic[‘price‘] > 100,portfolio)
    print(list(ret))

    #考察:匿名函数 ==> 内置函数
    ret=zip(((‘a‘),(‘b‘)),((‘c‘),(‘d‘)))
    def func(tup):
        return {tup[0]:tup[1]}
    func=lambda tup:{tup[0]:tup[1]}
        res=map(func,ret)
    print(list(res))

    #RecursionError: maximum recursion depth exceeded while calling a Python object

    import sys
    sys.setrecursionlimit(1000000)
    n = 0
    def story():
        global n
        n += 1
        print(n)
        story()
    story()

    def age(n):
        if n == 4:
            return 40
        elif n >0 and n < 4:
            return age(n+1)+2
    print(age(1))

    l = [2,3,5,10,15,16,18,22,26,30,32,35,41,42,43,55,56,66,67,69,72,76,82,83,88]
    def find(l,aim,start = 0,end = None):
        end = len(l) if end is None else end
        mid_index = (end - start)//2 + start
        if start <= end:
            if l[mid_index] < aim:
                return find(l,aim,start =mid_index+1,end=end)
            elif l[mid_index] > aim:
                return find(l, aim, start=start, end=mid_index-1)
            else:
                return mid_index
        else:
            return ‘找不到这个值‘

    ret= find(l,44)
    print(ret)

    def fib(n):
        if n==1 or n==2:
            return 1
        else:
            return fib(n-1)+fib(n-2)
    print(fib(10))

    def jiecheng(n):
        if n==1:
            return 1
        return jiecheng(n-1)*n
    jiecheng=lambda n:1 if n==1 else jiecheng(n-1)*n
    ret=jiecheng(5)
    print(ret)
    #jiecheng(5)→5*jiecheng(4)→5*4*jiecheng(3)→5*4*3*jiecheng(2)→5*4*3*2*jiecheng(1)

    l = [2,3,5,10,15,16,18,22,26,30,32,35,41,42,43,55,56,66,67,69,72,76,82,83,88]
    def find(l,aim,start = 0,end = None):
        end = len(l) if end is None else end
        mid_index = (end - start)//2 + start
        if start <= end:
            if l[mid_index] < aim:
                return find(l,aim,start =mid_index+1,end=end)
            elif l[mid_index] > aim:
                return find(l, aim, start=start, end=mid_index-1)
            else:
                return mid_index
        else:
            return ‘找不到这个值‘

    ret= find(l,44)
    print(ret)