Day04

Posted 2020-11-02 rainbow91

2018-04-22

复习回顾
# 作业 博客登录

# 文件操作
    # 打开文件
        # f = open(‘文件路径‘) 默认的打开方式 r，默认的打开编码是操作系统的默认编码
        # r w a (r+ w+ a+ 避免用) 以上6种加b，如果打开模式+b，就不需要指定编码了
        #编码 UTF-8 gbk
    # 操作文件
        # 读
            # read 不穿参数 意味着读所有
                # 传参，如果是r方式打开的，参数指的是读多少个字符
                # 传参，如果是rb方式打开的，参数指的是读多少个字节（视频，图片，网络传输）
            # readline
                # 一行一行读 每次只读一样，不会自动停止，继续读的话返回空
            # for循环的方式
                # 一行一行读 从第一行开始，每次读一行，读到没有之后就停止
        # 写
            # write 写一行内容 需要自己添加\\n换行
    # 关闭文件
        #f.close()
    # with open() as f:
    # 修改文件：
        # import os
        # os.remove
        # os.rename
# 函数
    # 定义
        # 关键字 def 函数名(形参):
        # 参数：1、位置参数 2、*args动态传参 3、关键字参数/默认参数 4、**kwargs 动态传参
            # 位置参数
            # *args 动态传参：接收在调用的时候传过来的多余的所有按位置传的参数
            # 关键字参数 默认参数，如果不传回有一个默认的值，如果传了会覆盖默认的值
            # **kwargs 动态传参：接收在调用的时候传过来的多余的所有按关键字传的参数
        # 返回值
            # 关键字 return 停止一个程序的运行 返回参数
                # 没有返回值 默认返回None
                # 有一个返回值
                # 返回多个值
    # 调用
        # 调用的关键字 函数名(实参) 调用运算符
        # 传参数：
            # 按照位置传
            # 按照关键字传
        # 接收返回值
            # 没有返回值 不接受
            # 有一个返回值 用一个变量接收
            # 有多个返回值
                # 用一个变量接收 所有返回值都会被组织成一个元组
                # 用多个变量接收 有多少个返回值 就必须用多少个变量接收
# 函数是第一类对象的概念
    # 函数名 --> 函数的内存地址
    # 函数名可以作为 容器类型的元素 函数的参数、返回值 还能进行赋值  --> 变量

# 闭包和装饰器
    # 闭包的定义：内部函数引用外部函数的变量
    # 闭包的应用：装饰器

装饰器
# 在原有的函数前后增加功能，且不改变原函数的调用方式

# 计算一个函数的运行之间

import time

def timer(f):
    def inner(*args,**kwargs):
        start_time = time.time()
        ret = f(*args,**kwargs)
        end_time = time.time()
        print(end_time - start_time)
        return ret
    return inner

@timer
def func(a,b):
    print(‘begin func‘,a)
    time.sleep(0.1)
    print(‘end func‘,b)

func(1,2)  # --> inner()

‘‘‘
最小化装饰器
def timer(f):
    def inner(*args,**kwargs):
        ‘‘‘执行函数之前的操作‘‘‘
        ret = f(*args,**kwargs)
        ‘‘‘执行函数之后的操作‘‘‘
        return  ret
    return inner

@timer
func():
    pass

func()
‘‘‘

# 进阶需求
# 第一种情况
#   500个函数
#   你可以涉及你的装饰器 来确认是否
import time

def timer(f):
    def inner(*args,**kwargs):
        start_time = time.time()
        ret = f(*args,**kwargs)
        end_time = time.time()
        print(end_time - start_time)
        return ret
    return inner

@timer
def func(a,b):
    print(‘begin func‘,a)
    time.sleep(0.1)
    print(‘end func‘,b)

func(1,2)  # --> inner()

# 第二种情况
# 装饰器 登录 记录日志
login_info = {‘alex‘:False}



‘‘‘ 装饰器嵌套执行流程
def wrapper1(func):   #f
    def inner1():
        print(‘wrapper1 ,before func‘)
        func()   # f
        print(‘wrapper1 ,after func‘)
    return inner1

def wrapper2(func):  # inner1
    def inner2():
        print(‘wrapper2 ,before func‘)
        func()   # inner1
        print(‘wrapper2 ,after func‘)
    return inner2

@wrapper2
@wrapper1
def f():
    print(‘in f‘)

f()

# 

 

‘‘‘

#http://www.cnblogs.com/Eva-J/articles/7213953.html

迭代器 生成器
# 如何从列表、字典中取值的
    # index索引，key
    # for循环
# 凡是可以使用for循环取值的都是可迭代的
#可迭代协议：内部含有__iter__方法的都是可迭代的

#迭代器协议：内部含有__iter__方法和__next__方法的都是迭代器

print(dir([1,2,3]))
print(dir([1,2,3].__iter__()))
lst_iter = [1,2,3].__iter__()
print(lst_iter.__next__())
print(lst_iter.__next__())
print(lst_iter.__next__())
# 等同于for循环
for i in [1,2,3]:   # 1、[1,2,3].__iter__() 2、把__next__()值赋给i
    print(i)

l = [1,2,3]
lst_iter = iter(l)  # l.__iter__()
while True:
    try:
        print(next(lst_iter))   # lst_iter.__next__()
    except StopIteration:
        break

# 什么事可迭代的   有iter方法的
# 什么事迭代器     迭代器 = iter(可迭代的)，自带一个__next__方法
# 可迭代 最大的优势 节省内存

from collections import  Iterable,Iterator
print(range(1000000))
print(isinstance(range(1000000),Iterable))
print(isinstance(range(1000000),Iterator))
# py2 range 不管range多少，会生成一个列表，这个列表将用来存储所有的值
# py3 range 不管range多少，都不会实际的生成任何一个值
# 迭代器的优势：
    # 节省内存
    # 快
# 迭代器的特性：惰性运算

# 可迭代的：
# 列表 字典 元组 字符串 集合 range 文件句柄 enumerate

# 生成器 Generator
# 自己写的迭代器 就是一个生成器
# 两种自己写生成器（迭代器）的机制：生成器函数 生成器表达式

# 生成器函数
‘‘‘
坏例子
def cloth(num):
    for i in range(num):
        ret.append(‘cloth%s‘%i)
    return ret
‘‘‘
‘‘‘
生成器函数
def cloth_g(num):
    for i in range(num):
        yield ‘cloth%s‘%i

g = cloth_g(1000)
print(next(g))
print(next(g))
print(next(g))
‘‘‘
# 凡是带有yield的函数就是一个生成器函数

def func():
    print(‘****‘)
    yield 1
    print(‘^^^^‘)
    yield 2     # 记录当前所在的位置，等待下一次next来触发函数的状态

g = func()
print(‘--‘,next(g))
print(‘--‘,next(g))

# 生成器函数的调用不会触发代码的执行，而是会返回一个生成器（迭代器）
# 使用next的时候才执行

# 例子
# 使用生成器监听文件输入
# import time
# def listen_file():
#     with open (‘userinfo‘) as f:
#         while True:
#             line = f.readline()
#             if line.strip():
#                 yield line.strip()
#             time.sleep(0.1)
#
# g = listen_file()
# for line in g:
#     print(line)


# send
def func():
    print(11111)
    ret1 = yield 1
    print(22222,ret1)
    ret2 = yield 2
    print(33333,ret2)
    yield 3

g = func()
ret = next(g) #这里必须用next
print(ret)
print(g.send(‘alex‘))  # 在执行next的过程中 传递一个参数 给生成器函数的内部
print(g.send(‘金老板‘))
#图2

 

#向生成器传递值，有一个激活的过程：第一次必须要用next触发生成器

# 例子
# 计算移动平均值
# 12 13 15 18

# 2、月度 的 天平均收入
# 图3

 

def average():
    sum_money = 0
    day = 0
    avg = 0
    while True:
        money = yield avg
        sum_money += money
        day += 1
        avg = sum_money/day

g = average()
print(next(g))  # 预激活
print(g.send(200))
print(g.send(300))
print(g.send(600))

# 预激生成器
def init(func):
    def inner(*args,**kwargs):
        ret = func(*args,**kwargs)
        next(ret)
        return ret
    return inner

@init
def average():
    sum_money = 0
    day = 0
    avg = 0
    while True:
        money = yield avg
        sum_money += money
        day += 1
        avg = sum_money/day

g = average()
print(g.send(200))
print(g.send(300))
print(g.send(600))

# yield from
# yield from之前
def generator_func():
    for i in range(5):
        yield i
    for j in ‘hello‘:
        yield j
g = generator_func()
# yield from之后
def generator_func():
    yield from range(5)
    yield from ‘hello‘
g = generator_func()


# 如何从生成器中取值
# 第一种 next
print(next(g))
print(next(g))
# 第二种 for循环 从头到尾遍历一次 不遇到break return
for i in g:
    print(i)
# 第三种：list tuple
print(g)
print(list(g))

# 生成器函数 是我们python程序员实现迭代器的一种手段
# 主要特征是 在函数中 含有yield
# 调用一个生成器函数 不会执行这儿函数中的代码 只是会获取一个生成器（迭代器）
# 只有从生成器中取值的时候，才会执行函数内部的代码，且每获取一个数据才能执行得到这个数据的代码
# 获取数据的方式包括 next send 循环 数据类型的强制转化
# yield 返回值得渐变方法，如果本身就是循环一个可迭代的，且要把可迭代数据中的每一个元素都返回 可以用yield from
# 使用send的时候，在生成器创造出来之后需要进行预激，这一步可以使用装饰器完成
# 生成器的特点：  节省内存 惰性运算
# 图4

# 图5

 

# 生成器用来解决 内存问题 和 程序功能之间的解耦


# 生成器表达式
# 列表推导式 http://www.cnblogs.com/Eva-J/articles/7276796.html
# 之前
new_lst = []
for i in range(10):
    new_lst.append(i**2)
print(new_lst)
# 之后
print(‘列表推导式:‘)
print([i**2 for i in range(10)])

li = [1,2,3,-5,6,20,-7]
# 取2余数
print(‘取2余数:‘)
print([i%2 for i in li])
# 取奇数
print(‘取奇数:‘)
print([i for i in li if i%2 == 1])

# 例一：30以内所有能被3整除的数
print(‘30以内所有能被3整除的数:‘)
print([i for i in range(30) if i%3 == 0])
# 例二：30以内所有能被3整除的数的平方
print(‘30以内所有能被3整除的数的平方:‘)
print([num**2 for num in range(30) if num%3 == 0])
#例三:找到嵌套列表中名字含有两个‘e’的所有名字
names = [[‘Tom‘, ‘Billy‘, ‘Jefferson‘, ‘Andrew‘, ‘Wesley‘, ‘Steven‘, ‘Joe‘],
         [‘Alice‘, ‘Jill‘, ‘Ana‘, ‘Wendy‘, ‘Jennifer‘, ‘Sherry‘, ‘Eva‘]]
print(‘找到嵌套列表中名字含有两个‘e’的所有名字:‘)
print([name for name_lst in names for name in name_lst if name.count(‘e‘) == 2])

# 生成器表达式 和 列表推导式写法一模一样
l = [i for i in range(30) if i%3 == 0]  # 列表推导式 排序的时候
g = (i for i in range(30) if i%3 == 0)  # 生成器表达式
print(l)
print(g)
for i in g:print(i)

‘‘‘
列表推导式和生成器表达式
#老男孩由于峰哥的强势加盟很快走上了上市之路,alex思来想去决定下几个鸡蛋来报答峰哥

egg_list=[‘鸡蛋%s‘ %i for i in range(10)] #列表解析

#峰哥瞅着alex下的一筐鸡蛋,捂住了鼻子,说了句:哥,你还是给我只母鸡吧,我自己回家下

laomuji=(‘鸡蛋%s‘ %i for i in range(10))#生成器表达式
print(laomuji)
print(next(laomuji)) #next本质就是调用__next__
print(laomuji.__next__())
print(next(laomuji))
‘‘‘
# 面试题
# 面试题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))
print(list(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]:
    g=(add(n,i) for i in g)

print(list(g))
# 生成器在不找它要值的时候始终不执行，当它执行的时候，要以执行时候的所有变量值为准

内置函数

# 自定义函数
# 内置函数 https://www.processon.com/view/link/5adc6062e4b04721d63171eb?pw=3218
    # print
    # len
    # max min
    #
    # print()   也是写文件
        # print(1,2,3,4,5,sep = ‘;‘,end=)
        # python 操作文件 ————需要发起系统调用 才能操作文件
# 99乘法表
for i in range(1,10):
    for j in range(1,i+1):
        print(‘%s * %s = %2s‘%(i,j,i*j),end=‘ ‘)
    print()
# 进度条

    # hash 哈希
        # 对可hash的数据类型进行hash之后会得到一个数字
        # 在一次程序的执行过程中 对相同的可哈希变量 哈希之后的结果永远相同的
        # 在一次程序的执行过程中 对不相同的可哈希变量 哈希之后的结果总是不相同的
        # hash 字典底层的存储 和set集合的去重机制 都相关
    # id() 查看一个变量的内存地址
    # import ----> __import__
    # help([1,23])  帮助
    # callable  可调用
def func():pass
a = 1
print(callable(func))   # 可调用
print(callable(a))      # 不可调用

    # dir  查看一个变量拥有的所有名字
print(dir(‘1‘))

    # 进制转换 二进制、八进制、十进制
print(bin(10))  # 0b开头 二进制
print(oct(10))  # 0o开头 八进制
print(hex(10))  # 0x开头 十六进制

    # abs() 计算绝对值
print(abs(4))
print(abs(-4))

    # divmod # 商余函数 返回一个元组
print(divmod(10,2))
print(divmod(7,3))
print(divmod(9,7))

    # round 小数精确 会四舍五入 默认取整
print(round(3.1415926,4))

    # pow 取平方
print(pow(2,3))
print(pow(3,2))
print(pow(2,3,5))   #(2**3)%5
print(pow(3,2,2))

    # sum 取和
print(sum([1,2,3,4,5]))
print(sum(range(1,6)))

    # min 最小值
print(min([1,2,3,4,5]))
print(min(1,2,3,4))
print(min(1,-2,3,-4))
print(min(1,-2,3,-4,key=abs))   # 1 按绝对值后最小值
print(min(-2,3,-4,key=abs))     # -2 返回值是原值

def func(num):
    return num%2
print(min(-2,3,-4,key=func))    # key可自定义函数
    # max 与 min()相同

    # reversed()
ret = [1,2,3,4,5]
ret1 = reversed(ret)
ret2 = reversed((1,2,3,4,5))

# 字符串
    # format
print(format(‘test‘,‘<20‘))
print(format(‘test‘,‘>20‘))
print(format(‘test‘,‘^20‘))
    # ord chr 字符串与
print(ord(‘a‘))     # 小写的 a-z 97+26 大写的 A-Z 65+26
print(chr(97))
    # repr 数据类型原形显示
print(repr(1))
print(repr(‘1‘))
    # enumerate()   枚举函数 enumerate(容器类型,序号的起始值默认0)
l = [1,2,3,4,5,6,7]
ret = enumerate(l)
print(ret)
for item in ret:
    print(item)

l = [‘苹果‘,‘香蕉‘]
for num,item in enumerate(l,1):
    print(num,item)

    # all 在所有的容器类型里，全为真才为真
print(all([1,2,3,4,5]))
print(all([0,1,2,3,4,5]))
print(all([‘‘,1,2,3,4,5]))
print(any([0,None,False]))
    # any 在所有的容器类型里，有一个真即为True，全False返回False

    # zip 拉链方法  返回可迭代 按最少个数变量拉齐
ret = zip([1,2,3,4,5],(‘a‘,‘b‘,‘c‘,‘d‘),(4,5))
print(ret)
for i in ret:
    print(i)

    # filter和map
# 例子：用filter删选所有偶数 把lst内的值全传给func，然后判断是否留在lst内
lst = [1,4,6,7,9,12,17]
def func(num):
    if num % 2 == 0:return True
for i in filter(func,lst):
    print(i)

# 例子：用filter删除列表内的None和空字符
l = [‘test‘, None, ‘‘, ‘str‘, ‘  ‘, ‘END‘]
def func(item):
    if item and item.strip():return True
for i in filter(func,l):
    print(i)

# 例子：利用filter()过滤出1~100中平方根是整数的数
import math
def is_sqr(x):
    return

# 例子：用map()
def func(num):
    return num ** 2
for i in map(func,range(10)):print(i)

    # sorted 排序功能 sorted
l = [1,-4,-2,3,-5,6,5]
l.sort(key = abs)
print(l)

l = [1,-4,-2,3,-5,6,5]
new_l = sorted(l,key = abs)   # 根据abs返回值排序
print(new_l)

l = [1,-4,-2,3,-5,6,5]
new_l = sorted(l,key = abs,reverse = True)   # 根据abs返回值排序
print(new_l)

l = [[1,2],[3,4,5,6],(7,),‘123‘]
print(sorted(l,key = len))

    # eval() 以字符串形式执行，有返回值 慎用，代码必须确认为安全的，不能有外部输入
eval(‘print(123)‘)
print(eval(‘1+2-3*20/(2+3)‘))
    # exec() 以字符串形式执行，没有返回值 慎用，代码必须确认为安全的，不能有外部输入
exec(‘print(123)‘)
print(exec(‘1+2-3*20/(2+3)‘))

# min max sorted filter map 明星函数

匿名函数

# lambda 表达式
# lambda 是关键字
#

def add(a,b):
    return a+b
print(add(1,2))
# 等同于
add = lambda a,b: a+b
print(add(1,2))

def func(num):
    return num ** 2
for i in map(func,range(10)):print(i)
# 等同于
for i in map(lambda num : num ** 2,range(10)):print(i)

print(min(-2,3,-4,key=lambda num:num%2))

d = lambda p:p*2
t = lambda p:p*3
x = 2
x = d(x)
x = t(x)
x = d(x)
print(x)

# 现有两元组((‘a‘),(‘b‘)),((‘c‘),(‘d‘)),请使用python中匿名函数生成列表[{‘a‘:‘c‘},{‘b‘:‘d‘}]
def func(t):
    return {t[0]:t[1]}
ret = map(func,zip(((‘a‘),(‘b‘)),((‘c‘),(‘d‘))))
print(list(ret))
#等同于
ret = map(lambda t:{t[0]:t[1]},a)


递归

# def func():
#     print(1)
#     func()
# func()

# RecursionError: maximum recursion depth exceeded while calling a Python object
# 超出递归最大深度 997/ 998
# 如果你的递归次数大余998，不适合用递归

import  sys
sys.setrecursionlimit(1000000) # 修改递归上限

# 6!
# 阶乘 6*5*4*3*2*1
print(6*5*4*3*2*1)
def fn(n):
    if n == 1:return 1
    return n*fn(n-1)
print(fn(6))

‘‘‘
def fn(6):
    return  6*fn(5)
def fn(6):
    return  5*fn(4)
def fn(6):
    return  4*fn(3)
def fn(6):
    return  3*fn(2)
def fn(6):
    return  2*fn(1)
def fn(6):
    if n == 1:return 1
‘‘‘
# 图8

# 递归文档 http://www.cnblogs.com/Eva-J/articles/7205734.html