内置函数 闭包

内置函数 闭包

内置函数

匿名函数 lambda

构建格式 (一句话函数)

• 适用于简单的函数

func = lambda a,b : a if a > b else b
# lambda == def  a,b是形参 返回值用 ":"隔开  ":" 是返回值(可以加判断条件)
 print(func(5,2))

func = lambda lis : (lis[0],lis[2])  # 返回值多个元素用元组表达
print(func("sadas"))

func = lambda : 3
print(func()) # 3 (返回值)

注意事项(格式化输出F/f'strings' )

# 所以使用lambda 表达式会出现一些问题。
# 解决方式：可将lambda嵌套在圆括号里面解决此问题。
x = 5
print(f'{(lambda x: x*2) (x)}')  # 10

内置函数Ⅰ

eval 执行字符串类型的代码，并返回最终结果 有返回值 (谨慎使用)

print(eval("1+2")) # 脱掉str的外套, 进行int运算  # 打印结果 3

exec 执行字符串类型的代码 代码流 过程 没有返回值 (谨慎使用)

s ='''
for i in [1,2,3]:
    print(i)
'''  # 与eval相似 但没有返回值
exec(s) # 1 2 3  
print(exec(s)) # None

hash 获取一个对象（可哈希对象：int，str，Bool，tuple）的哈希值。

print(hash(12322))
print(hash('alex'))
print(hash(True))
'''
12322
4259238228040858354
1''' # 打印结果

help 函数用于查看函数或模块用途的详细说明。

print(help(list))  # 就是按着ctrl 看函数内部解释运行原理
print(help(str.split))

callable() (对象是否可调用)

• 函数用于检查一个对象是否是可调用的。如果返回True，object仍然可能调用失败；但如果返回False，调用对象ojbect绝对不会成功。

name = 'alex'
def func():
    pass
print(callable(name))  # False
print(callable(func))  # True

int () ( "12" → 12 / 12.2 → 12 )

• 函数用于将一个字符串或数字转换为整型。 将浮点型转化为整型

print(int())  # 0
print(int('12'))  # 12
print(int(3.6))  # 3
print(type(bin(3.6)))  # class"int" 

float () ( 3→3.0 )

• 函数用于将整数和字符串转换成浮点数。

print(float(1)) # 1.0

bin () ( 10 → 2 进制 )

• 将十进制整数转换成二进制并返回。

print(bin(100)) # 将十进制转化成二进制 0b1100100
print(type(bin(3)))  # class"str" 

oct () ( 10 → 8 进制 )

• 将十进制转化成八进制字符串并返回。

print(oct(10),type(oct(10)))  # 0o12 <class 'str'>

hex () ( 10 → 16 进制 )

• 将十进制转化成十六进制字符串并返回。

print(hex(10),type(hex(10)))  #16进制 0xa <class 'str'> 10,11,12,13,14,15 分别用a,b,c,d,e,f表示

divmod () (a // b , a % b ) 分页用

• 计算除数与被除数的结果，返回一个包含商和余数的元组(a // b, a % b)。

print(divmod(7,2))  # (3, 1)
print(divmod(2,2))  # (1, 0)

round () （保留有效位数）

• 保留小数的有效位数

print(round(7/3,2))  # 2.33
print(round(7/3))  # 2
print(round(3.32567,3))  # 3.326

pow () （x**y）

• 求xy次幂。（三个参数为x**y的结果对z取余）

print(pow(2,3))  # 8  （两个参数为2**3次幂）
print(pow(2,3,3)) # 2（三个参数为2**3次幂，对3取余）

ord () (查unicode中编码位置)

• 输入字符找该字符在unicode中编码的位置

# ord 输入字符找该字符编码的位置
print(ord('a')) # 97
print(ord('中')) # 20013

chr () (查unicode中对应位置)

• 输入位置数字找出其unicode中对应的字符

# chr 输入位置数字找出其对应的字符
print(chr(97)) # a
print(chr(20013)) # 中

repr () (%r 原形毕露)

• 返回一个对象的string形式（原形毕露）。

mag ="我叫%r" %(太白)
print(mag)  # 我叫"太白"
# %r  原封不动的写出来
# name = 'taibai'
# print('我叫%r'%name)

# repr 原形毕露
print(repr('{"name":"alex"}'))
print('{"name":"alex"}')

all () ( 判断可迭代对象 )

• 判断可迭代对象中，全都是True才是True

any () ( 判断可迭代对象 )

• 判断可迭代对象中，有一个True 就是True

# all  可迭代对象中，全都是True才是True
# any  可迭代对象中，有一个True 就是True
print(all([1,2,True,0]))
print(any([1,'',0]))

内置函数Ⅱ

print() 屏幕输出

# sep:   打印多个值之间的分隔符，默认为空格
# end:   每一次打印的结尾，默认为换行符 

# file:  默认是输出到屏幕，如果设置为文件句柄，输出到文件
print(1, 2, 3, sep='|') # 1|2|3

print(1, 2, end=' ') # 1 2 3 4
print(3, 4) # 两句话一起打印在一行

f = open('log','w',encoding='utf-8')
f.write('写入文件') == print('写入文件', file=f) 

int():pass

str():pass

bool():pass

set(): pass

list()

• 将一个可迭代对象转换成列表

l1 = list('abcd')
print(l1)  # ['a', 'b', 'c', 'd']
print(list("abcd"))

tuple()

• 将一个可迭代对象转换成元组

tu1 = tuple('abcd')
print(tu1)  # ('a', 'b', 'c', 'd')

dict()

• 通过相应的方式创建字典

# 创建字典的几种方式
dic = {1: 2}
# 字典推导式
print({i: 1 for i in range(3)})
dic = dict(one=1, two=2, three=3)
# 从键
dic = dict.fromkeys()

abs() 返回绝对值

print(abs(-10)) # 10

sum(Iterable object) 求和

print(sum([1,2,3])) # 6 
print(sum((1,2,3),100)) # 106

max / min() 求最值

print(min([22, 11, 45, 2])) # 2
# min / max 可加功能
dic = {'a':3,'b':2,'c':1}
# 将dic值最小的键返回。
print(min(dic,key=lambda x : dic[x]))

# 将dic值最小的值返回。
print(dic[min(dic,key=lambda x : dic[x])])

dic = {'a':['李业',67],'b':['怼哥', 95],'c':['方垚', 85]}

# 将成绩最低的从属于的那个列表返回。
print(dic[min(dic,key=lambda x : dic[x][1])])

# 将成绩最低的分数返回。
print(dic[min(dic,key=lambda x : dic[x][1])][1])

reversed() 镜像

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

print(reversed([1,2,3,4]))  # 返回值是一个迭代器(生成器)
print(list(reversed([1,2,3,4]))) # [4,3,2,1]

bytes()

• 把字符串转换成bytes类型

s1 = '太白'
方法一：
print(s1.encode('utf-8'))
方法二：
print(bytes(s1,encoding='utf-8'))

解码：
b1 = b'xe5xa4xaaxe7x99xbd'
# 方法一：
# print(b1.decode('utf-8'))
# 方法二：
print(str(b1, encoding='utf-8'))

zip() 拉链方法

• 函数用于将可迭代的对象作为参数,将对象中对应的元素打包成一个个元组,然后返回由这些元祖组成的内容,如果各个迭代器的元素个数不一致,则按照长度最短的参数索引返回

lst1 = [1,2,3]
lst2 = ['a','b','c','d']
lst3 = (11,12,13,14,15)
print(zip(lst1)) # 结果是一个迭代器
for i in zip(lst1,lst2,lst3):
    print(i)
# 结果:
(1, 'a', 11)
(2, 'b', 12)
(3, 'c', 13)　

sorted排序函数 (默认从小到大)

l1 = [2, 6, 4, 1, 3]
#  列表原有的方法
l1.sort()
print(l1)  # [1, 2, 3, 4, 6]

#  形成新列表
print(sorted(l1)) # [1, 2, 3, 4, 6]
print(l1) # [2, 6, 4, 1, 3]

#  reverse : 是否是倒叙 ,True 倒叙  ; False 正序

# 结合lambda 使用  (字典返回的是key)
l1 = [('张一东', 80), ('张耳洞', 75), ('怼怼哥', 7), ('李业', 59)]
print(sorted(l1,key=lambda x:x[1])) # 或者
print(sorted(l1,key=lambda x:x[1],reverse=False))
print(sorted(l1,key=lambda x:x[1],reverse=True))

filter() 筛选过滤

# 生成器表达式的筛选模式
l1 = [56, 67, 12, 34, 78, 90,]
print([i for i in l1 if i > 60]) # [67, 78, 90]
# 返回值为True的留下来
print(filter(lambda x: x>60,l1))  # 返回一个迭代器 / 生成器
print(list(filter(lambda x: x>60,l1))) # [67, 78, 90]

lst = [{'id':1,'name':'alex','age':50},
        {'id':1,'name':'wusir','age':17},
        {'id':1,'name':'taibai','age':16},]

print(list(filter(lambda x:x['age']<30,lst))) 

map() 统计可迭代类

l1 = [56, 67, 12, 34, 78, 90,] 
print([i**2 for i in l1])  # [3136, 4489, 144, 1156, 6084, 8100]
print(map(lambda x:x**2,l1))  # 返回一个生成器
print(list(map(lambda x:x**2,l1))) # [3136, 4489, 144, 1156, 6084, 8100]
#  计算两个列表中相同位置的数据的和
lst1 = [1, 2, 3, 4, 5]
lst2 = [2, 4, 6, 8, 10]
print(list(map(lambda x, y: x+y, lst1, lst2)) # [3, 6, 9, 12, 15]

reduce() 统计类

from functools import reduce # 先得调用
''' 
第一次：x,y 1,2 求和 3 记录到内存
第二次：x,y 3,3 求和 6 记录到内存
第三次：x,y 6，4 .........'''
print(reduce(lambda x,y: x+y,[1,2,3,4,5])) # 1+2+3+4+5 
print(reduce(lambda x,y: 2*x+y, [1,2,3]))
print(reduce(lambda x,y: x+y, ['alex','s','b']))  # 可以用字符串拼接  alexsb

enumerate() 枚举

解包和枚举
s = "wtf"
d = {}
for i, d[i] in enumerate(s):
    pass
print(d)# 打印结果: {0:"w",1:"t",2:"f"}

闭包

• 闭包就是内层函数中, 对外层函数(非全局)变量的调用(引用 / 改变). 叫闭包
• 可以让一个局部变量(自由变量)常驻内存

作用

• 应用于装饰器
• 最终的目的是保证了数据的安全
• 可以保证外层函数中的变量在内存中常驻,供后面的程序使用

闭包的形成条件

• 闭包存在于嵌套函数中
• 内层函数对外层函数非全局变量引用(改变)
• 参考 : 函数名逐层返回直至返回到最外层

特性

• 闭包函数的空间不会随着函数函数的结束而消失
• 被内层函数引用的(非全局)变量不会消失(常驻内存)

自由变量

• 外层函数被内层函数引用的变量被称为

判断是不是闭包 == 是不是有自由变量

print(外部函数名()._ code _.co_freevars 查看函数的自由变量)

print(外部函数名()._ code _.co_varnames 查看函数的局部变量)

def make_averager():
    series = []
    def averager(new_value):
        series.append(new_value)
        total = sum(series)
        return total/len(series)
    return averager
avg = make_averager()

# 函数名.__code__.co_freevars 查看函数的自由变量
print(avg.__code__.co_freevars)  # ('series',)
当然还有一些参数，仅供了解：

# 函数名.__code__.co_freevars 查看函数的自由变量
print(avg.__code__.co_freevars)  # ('series',)
# 函数名.__code__.co_varnames 查看函数的局部变量
print(avg.__code__.co_varnames)  # ('new_value', 'total')