python函数闭包_python内置函数与闭包

1.内置函数

内置函数I。

内置函数：内置的函数，python中的内置函数68种。13种是在面向对象之后讲解，还有一些不讲的。

# eval exce 去掉字符串两边的引号,还原本身(慎用)

s1 = "{1: 'alex'}"

s2 = '1 3'

# eval 剥去字符串的外衣，返回里面的本质

ret = eval(s1)

print(ret,type(ret)) # {1: 'alex'}

print(eval(s2)) # 4

# exec 代码流，过程。

s3 = '''

for i in range(3):

print(i)

'''

exec(s3) # 1 2 3

s3 = input('>>>')

print(eval(s3))

# hash() 获取对象的哈希值

print(hash(123214134))

print(hash('fkljdsaklgjdfs'))

print(hash('gjdfs'))

# help() 使用说明书

print(help(str.count))

# callable ** 判断对象是否可以调用

def a():

pass

b = 3433

a()

b()

print(callable(a)) # True

print(callable(b)) # False

# int ** 取整 将字符串转换成整数

print(int(3.14)) # 3

print(int('123')) # 123

# float 将整数和字符串转换成浮点数

print(float(100)) # 100.0

# complex：函数用于创建一个值为 real imag * j 的复数或者转化一个字符串或数为复数。如果第一个参数为字符串，则不需要指定第二个参数。

print(complex(1,2)) # (1 2j)

# 将十进制转化成二进制。 **

print(bin(100)) # 0b1100100

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

print(oct(10)) # 0o12

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

print(hex(17)) # 0x11

print(hex(15)) # 0xf

# divmod: 计算除数与被除数的结果，返回一个包含商和余数的元组(a // b, a % b)分页用到 **

print(divmod(10, 3)) # (3, 1)

# round: 保留小数的有效位置

print(round(3.1485926,2)) # 3.15

# pow：求x**y次幂。(三个参数为x**y的结果对z取余)

print(pow(3, 3)) # 27

print(pow(3, 3, 2)) # 1

# ord: 输入字符寻找其在unicode的位置。

print(ord('a')) # 97

print(ord('中')) # 20013

# chr: 输入位置数字找出其对应的字符 **

print(chr(98)) # b

print(chr(20104)) # 予

# repr 原形毕露 **

print('太白') # 太白

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

# all any **

l1 = [1, 'fgdsa', [], {1: 2}]

l2 = [0, '', [], {}]

print(all(l1)) # 判断可迭代对象元素全部都为True，返回True

print(any(l2)) # 判断可迭代对象元素只要有一个True返回True

内置函数II.(重要记住)

print(self, *args, sep=' ', end='\n', file=None)

# sep 设定分割符。

# end 默认是换行 可以打印到一行

print(1, 2, 3, sep='|') # 1|2|3

print(1, 2, end=' ')

print(3, 4) # 1 2 3 4

f = open('log','w',encoding='utf-8')

f.write('写入文件')

print('写入文件', file=f)

# list 构建列表

l1 = list('fdsafd')

print(l1) # ['f', 'd', 's', 'a', 'f', 'd']

# dict

# 创建字典的几种方式

dic = {1: 2}

# 字典推导式

print({i: 1 for i in range(3)})

# dict()

dic = dict(one=1, two=2, three=3)

print(dic) # {'one': 1, 'two': 2, 'three': 3}

# fromkeys()

# abs() 获取绝对值

print(abs(-10)) # 10

# sum() 数字相加求和

# sum(iterable,)

print(sum([1,2,3,4])) # 10

print(sum([1, 2, 3, 4], 100)) # 110 100代表起始数是100

# 非常非常非常重要的

# min 可以加功能

print(min([22, 11, 45, 2])) # 2

l1 = [('alex', 73, 170), ('太白', 18, 185), ('武大', 35, 159),]

# l1 = [(73, 'alex'), (35, '武大'), (18, '太白')]

# 找年龄最小的元组

# print(min(l1))

# 通过设置key去使用min

# key = 函数名

def func(x): # x = ('alex', 73)

return x[1]

# 返回值是什么就按照什么比较最小的。

# min 会自动的将可迭代对象的每一个元素作为实参传给x，

'''

第一次，x = ('alex', 73) 73

第二次，x = ('武大', 35) 35

第三次，x = ('太白', 18) 18

'''

# 将遍历的那个元素即是 ('太白', 18) 返回

print(min(l1,key=func)) # ('太白', 18)

print(min(l1,key=lambda x: x[1])) # ('太白', 18)

# 练习：

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

# 将dic值最小的键返回。

print(min(dic,key= lambda x:dic[x])) # c

# 将dic值最小的值返回。

print(dic[min(dic,key= lambda x:dic[x])]) # 1

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

# 将成绩最低的从属于的那个列表返回。

print(dic[min(dic,key=lambda x:dic[x][1])]) # ['李业', 67]

# 将成绩最低的分数返回。

print(dic[min(dic,key=lambda x:dic[x][1])][1]) # 67

# max() 与min 相同。

# reversed() 对一个可迭代对象进行翻转，返回一个迭代器

s1 = 'alex'

print(reversed(s1)) #

for i in reversed(s1):

print(i)

# 内置函数：bytes()

s1 = '太白'

# 方法一：

print(s1.encode('utf-8'))

# 方法二：

print(bytes(s1,encoding='utf-8'))

# 解码：

b1 = b'\xe5\xa4\xaa\xe7\x99\xbd'

# 方法一：

print(b1.decode('utf-8'))

# 方法二：

print(str(b1, encoding='utf-8'))

# zip 拉链方法 返回一个迭代器

l1 = [1, 2, 3, 4]

tu = ('a', 'b', 'c')

s = 'python23'

print(zip(l1,tu,s)) #

print(list(zip(l1,tu,s))) # [(1, 'a', 'p'), (2, 'b', 'y'), (3, 'c', 't')] 将每个可迭代对象的相同索引位置的元素组成一个元组 以最短的为准

# 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]

list1 = [{'name': 'alex', 'age': 73},

{'name': 'wusir', 'age': 35},

{'name': '太白', 'age': 25},]

# 加key

print(sorted(list1, key=lambda x:x['age']))

# [{'name': '太白', 'age': 25}, {'name': 'wusir', 'age': 35}, {'name': 'alex', 'age': 73}]

print(sorted(list1, key=lambda x:x['age'],reverse=True))

# [{'name': 'alex', 'age': 73}, {'name': 'wusir', 'age': 35}, {'name': '太白', 'age': 25}]

l1 = [('张一东',80), ('张耳洞',75), ('怼怼哥',7), ('李业',59)]

print(sorted(l1,key=lambda x:x[1]))

# [('怼怼哥',7), ('李业',59), ('张耳洞',75), ('张一东',80)]

print(sorted(l1,key=lambda x:x[1],reverse=True))

# [('张一东',80), ('张耳洞',75), ('李业',59), ('怼怼哥',7)]

# 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)))

# [{'id': 1, 'name': 'wusir', 'age': 17}, {'id': 1, 'name': 'taibai', 'age': 16}]

# 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]

# reduce python3x 从内置函数剔除了。

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])) # 15

print(reduce(lambda x,y: 2*x y, [1,2,3])) # 11

print(reduce(lambda x,y: x y, ['alex','s','b'])) # alexsb 可以用字符串拼接

2.闭包

闭包的定义：

1. 闭包是嵌套在函数中的函数。

2. 闭包必须是内层函数对外层函数的变量(非全局变量)的引用。

闭包的作用：保存局部信息不被销毁，保证数据的安全性。

闭包的应用：

1，保证数据的安全。

2，装饰器的本质。

# 为了保证数据的安全，闭包

def make_average():

l1 = []

def average(price):

l1.append(price)

total = sum(l1)

return total/len(l1)

return average

avg = make_average()

# print(avg)

print(avg(100000))

print(avg(110000))

print(avg(120000))

# 判断一个函数是不是闭包 == 闭包函数有没有自由变量

print(ret.__code__.co_freevars) # 查看函数的自由变量

# 了解

print(ret.__code__.co_varnames) # 查看函数中的局部变量

来源：https://www.icode9.com/content-1-255901.html