Python第十三天

1 lambda表达式

2 内置函数

3闭包

 

1、lambda表达式

匿名函数  一句话函数  比较简单的函数

            关键字　形参  返回值

func1=lambda a,b :a+b
print(func1(1,2))

func=lambda a : (a[0],a[2])
print(func('adfddf'))

func1=lambda i,j : i if i >j else j
print(func1(5,1))



2 内置函数
int（）
float（）
complex（A，B）
bin（）
print（bin（100））

Oct（）
print（Oct（10））

hex（）
print（hex（10））


divmod()
print(divmod(10,3))

round()保留浮点数的小数位数
print(round(3.1415926,2))

pow()求x**y幂  （三个参数为求x**y幂的结果对Z取余）

print(pow(2,3))
print(pow(2,3,3))


bytes()

s1='太白'
b=s1.encode('utf-8')
#print(b)
b=bytes(s1,encoding='utf-8')
print(b)

ord:输入字符找该字符编码的位置

Chr：输入位置数字找出其对应的字符

print(ord('a'))#97
print(chr(97))#a
print(chr(20013))#中


repr：返回一个对象的string形式（原形毕露）

s='太白'
# print(s)
# print(repr(s))
# 太白
# '太白'

s='太白'
msg='我叫%s'%(s)
msg='我叫%r'%(s)
print(msg)

all：可迭代对象中，全都是true才是true

l1=[1,2,'他毒霸',True,[1,2,3],]
print(all(l1))

any：可迭代对象中，有一个true就是true

l1=[0,'太多',False,[],'',()]
print(any(l1))

*****************************
以下是非常重要的

print（）1打印  2改参数

print(1,2,3,4,sep='&')
print(1,end='')
print(2)

int()
str（）
bool（）
set（）
list（）将一个可迭代对象转化成列表

l1=list('ssss')
print(l1)#['s', 's', 's', 's']

tuple()将一个可迭代对象转化成元组
dict（）通过相应的方式创建列表

dic=dict([(1,'one'),(2,'two')])
print(dic)
字典的创建方式：
直接创建
元组的解构
dic=dict（）
dic=dict(one=1,two=2)
fromkeys
update
字典的推导式


ABS（）  绝对值

print(abs(-6))

sum（）求和

l1=[i for i in range(10)]
print(sum(l1))

#l1=[i for i in range(10)]

#print(sum(l1))
#print(sum(l1,100))#前面先求和后加100   145
s1='12345'
l1=list(s1)
l2=[int(i) for i in l1]
print(sum(l2))

reversed  将一个序列翻转 返回翻转序列的迭代器

# l1=[i for i in range(10)]
# l1.reverse()#   对源列表进行翻转
# print(l1)

l1=[i for i in range(10)]
obj=reversed(l1)# 返回的是翻转后的迭代器
print(list(obj))

Zip（）拉链方法  非常重要

l1=[1,2,3,4,5]
tu1=['taid','bge','degang']
s1='sbddsr'

obj=zip(l1,tu1,s1)这形成的是迭代器
# for i in obj:
#     print(i)
# (1, 'taid', 's')
# (2, 'bge', 'b')
# (3, 'degang', 'd')

print(list(obj))
[(1, 'taid', 's'), (2, 'bge', 'b'), (3, 'degang', 'd')]

*******************最重要

min  max
min（）求最小值

#l1=[33,2,1,54,7,-1,-9]
# l2=[abs(i) for i in l1]#以绝对值方式取最小值
# print(min(l2))


#print(min(l1,key=abs))  这一行和上两行是等价的  注意key=

max（）求最大值

l1=[33,2,1,54,7,-1,-9]
# l2=[abs(i) for i in l1]#以绝对值方式取最小值
# print(max(l2))


print(max(l1,key=abs))  #这一行和上两行是等价的  注意key=

凡是可以加key的：他会自动的将可迭代对象中每个元素按照顺序传入keys对应的函数中
以返回值比较大小

dic={'a':3,'b':2,'c':1}

#求出值最小的键值对

def func(a):
    return dic[a]

print(min(dic ,key=func))
print(min(dic,key=lambda a:dic[a]))#上面这两行的代码是一样的结果

l2=[('tai',18),('al',73),('wu',35),('k',41)]
# print(min(l2,key=lambda i:i[-1]))
# ('tai', 18)

sorted （）  排序成新的列表

l1=[22,33,1,2,8,7,6,5]
l2=sorted(l1)

print(l2)
[1, 2, 5, 6, 7, 8, 22, 33]

l2=[('tai',18),('al',73),('wu',35),('k',41)]
print(sorted(l2,key=lambda x:x[1]))
print(sorted(l2,key=lambda x:x[1],reverse=True))

[('tai', 18), ('wu', 35), ('k', 41), ('al', 73)]
[('al', 73), ('k', 41), ('wu', 35), ('tai', 18)]


filter 过滤 或筛选  类似于列表推导式的筛选模式

l1=[2,3,4,1,5,6,7,8]

#print([i for i in l1 if i >3])#返回的是列表
print(list(filter(lambda x:x>3,l1)))#返回的是迭代器
#[4, 5, 6, 7, 8]

map  列表推导式的循环模式

l1=[1,4,9,16,25]
print([i**2 for i in range(1,6)])#返回的是列表
ret=map(lambda x:x**2,range(1,6))#返回的是迭代器
print(list(ret))


reduce  

from functools import reduce
def func(x,y):
    return  x+y
l=reduce(func,[1,2,3,4])
print(l)
10

3 闭包   封闭的东西  保证数据的安全

闭包只能存在嵌套的函数中

内层函数对外层函数非全局变量的引用   被引用的全局变量也称作自由变量  这个自由变量会与内层函数产生一个绑定关系  自由变量不会在内存中消失

例如：整个历史中的某个商品的平均收盘价。什么叫平局收盘价呢？就是从这个商品一出现开始，每天记录当天价格，然后计算他的平均值：平均值要考虑直至目前为止所有的价格。

比如大众推出了一款新车：小白轿车。

第一天价格为：100000元，平均收盘价：100000元

第二天价格为：110000元，平均收盘价：（100000 + 110000）/2 元

第三天价格为：120000元，平均收盘价：（100000 + 110000 + 120000）/3 元

 

# 方法一
#
# l1=[]
# def make_averager(new_value):
#     l1.append(new_value)
#     title=sum(l1)
#     return title/len(l1)
# print(make_averager(10000))
# print(make_averager(11000))
# print(make_averager(9000))


def make_averager():
    l1=[]#l1叫自由变量
    def averager(new_value):
        l1.append(new_value)
        title=sum(l1)
        return  title/len(l1)这段叫闭包
    return averager
avg=make_averager()
print(avg(10000))

如何判断一个嵌套函数是不是闭包

 

 

def wrapper():
    a=1
    def inner():
        print(a)
    return inner
ret=wrapper()

a=2
def wrapper():
    def inner():
        print(a)
    return inner
ret=wrapper()

def wrapper():
    def inner():
        print(a)
        print(b)
    return inner
a=2
b=3
ret=wrapper(a,b)

如何用代码判断闭包

def wrapper(a,b):
    def inner():
        print(a)
        print(b)
    return inner
a=2
b=3
ret=wrapper(a,b)
print(ret.__code__.co_freevars)#('a', 'b')#只要有自由变量就是闭包

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))#这个就是个空列表
#[0, 1, 2, 3]
#[]

生成器的取值是单向取值  光标只向下运行

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))
#[20, 21, 22, 23]

 

 

作业“
注意：循环一个列表，最好不要改变大小
　　　　循环一个列表 实际上是按照索引循环的

l1=[2,4,5,6,7]
for i in l1:
    if i %2==0:
        l1.remove(i)
print(l1)#【4，5，7】