python内置函数及匿名函数

locals  本地作用域/局部作用域 会随着位置的改变而改变
globals 全局作用域           永远不变 永远是全局

 1 a = 1
 2 b = 2
 3 print(locals())
 4 print(globals())
 5 def func():
 6     c = 3
 7     d = 4
 8     print(locals())
 9 def func2():
10     l1 = []
11     d1 = {}
12     print(locals())     #无论在哪里打印 得到的都是全局作用域中的名字
13 func()
14 func2()
15 结果
16 {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x000001CE3C83A470>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': 'E:/PyPractise/day11.py', '__cached__': None, 'a': 1, 'b': 2}
17 {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x000001CE3C83A470>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': 'E:/PyPractise/day11.py', '__cached__': None, 'a': 1, 'b': 2}
18 {'d': 4, 'c': 3}
19 {'d1': {}, 'l1': []}

range(起始位置,终止位置,步长)
range(终止位置)
range(起始,终止位置)

1 range(5)        #0,1,2,3,4
2 range(5,0,-1)   #5,4,3,2,1
3 range(1,10,2)   #1,3,5,7,9

iter  创建迭代器和__iter__一样

1 迭代器 = 可迭代的.__iter__()
2 迭代器 = iter(可迭代的)

next    执行迭代器和__next__一样

1 print(net(迭代器))
2 带双下划线的魔术方法一般情况下不直接用
3 带双下划线的所有的方法都可能和内置的函数有千丝万缕的联系

print(要打印的内容1,要打印的内容2,sep = '分隔符',end = '结束符',file=file.txt, flush=False)
file:  默认是输出到屏幕,如果设置为文件句柄,输出到文件
sep:   打印多个值之间的分隔符,默认为空格
end:   每一次打印的结尾,默认为换行符
flush: 立即把内容输出到流文件,不作缓存(默认缓存)
#print的本质,就是写文件,这个文件是pycharm的屏幕

 1 print(123,'abc',sep='|',end='@')
 2 print('www')
 3 结果：
 4 123|abc@www
 5 
 6 事例二
 7 f = open('file','w')
 8 print(123,'abc',file=f,flush=True)
 9 f.close()
10 
11 案例:打印进度条
12 import time   #导入别人写好的代码
13 def func():
14     for i in range(0,101,2):
15         time.sleep(0.1)     #每一次在这个地方阻塞0.1s
16         char_num = i//2     #控制输出长度
17         if i == 100:
18             per_str = '\r%s%% : %s\n' % (i, '*' * char_num)     # %% 转义%，\n换行符
19         else:
20             per_str = '\r%s%% : %s' % (i, '*' * char_num)
21         print(per_str,end = '')     #per_str,end = ''格式化输出去除print末尾的默认换行符\n,不换行打印
22 func()
23 print('下载完成')

input('字符串数据类型的参数,提醒用户你要输入的内容')

1 python2
2     input() 还原你输入的值的数据类型
3     raw_input = py3.input
4 python3
5     input() 输入的所有内容都是字符串类型
6     阻塞: 等待某件事情发生,如果不发生一直等着
7 input的返回值就是用户输入的内容
8     输入的内容 = input('提示')

hash函数

 1 哈希: 可哈希(不可变数据类型),不可哈希(可变数据类型)
 2 哈希是一个算法,导致了字典的快速寻址
 3 所有的数据要想得到不变的hash值,必须是一个不可变的数据类型
 4 字符串通过hash复杂的算法,得到一个数字
 5 数字算出来就是数字本身
 6 print(id('呵呵'))
 7 print(hash(12345))
 8 结果：
 9 2655670439144
10 12345

id函数
获取到的是内存地址

1 print(id('呵呵'))
2 结果
3 2076687142120

open('文件名')打开一个文件,返回一个文件操作符(文件句柄)

1 操作文件的模式有r,w,a,r+,w+,a+ 共6种
2 每一种方式都可以用二进制的形式操作(rb,wb,ab,rb+,wb+,ab+)
3 encoding指定编码：默认是操作系统的默认编码

dir函数: 特殊的需求/研究或者了解一个新的数据类型/面向对象之后会介绍新的数据类型

1 print(dir(list)) #查看列表内置方法
2 print(dir(123))

help() 帮助你了解python的

1 方式一
2 输入help() 进入帮助页面,输入数据类型,帮助我们打印具体的帮助信息
3 输入q退出帮助
4 
5 方式二
6 print(help(str))
7 print(help('abc'))

callable() 判断某一个变量是否可调用(True/False)

 1 def call(arg):
 2     if callable(arg):
 3         arg()
 4     else:
 5         print('参数不符合规定')
 6 def func():
 7     print('in func')
 8     return 1
 9 func2 = 1234
10 call(func)
11 call(func2)
12 print(callable(func))
13 print(callable(func2))
14 结果
15 in func
16 参数不符合规定
17 True
18 False

bool
int
float
complex 复数

 1 实数 (有理数和无理数) :世界上存在的数
 2 虚数 : j
 3 某一个数的平方是-1 ,那么这个数就是一个虚数的基础单位 j
 4 复数 = 实数+虚数 = a+bj
 5 选择题 :(对你的数学有要求的公司都会考)
 6     复数不能比较大小
 7     共轭复数 : a+bj 和 a-bj是一对共轭复数
 8     a+bj 和 a+bJ都是复数
 9 c = 1+2J
10 print(type(c))
11 结果
12 <class 'complex'>

bin二进制没有2, oct八进制没8, hex十六进制没有16

1 逢二进一是二进制
2 逢八进一是十进制
3 逢十六进一是十六进制
4 0 1 2 3 4 5 6 7 8 9 A B C D E F
5 
6 a=256
7 print(bin(a))     # 0b100000000 0b代表二进制,100000000 = 256
8 print(oct(a))     # 0o400 0o代表八进制,400 = 256
9 print(hex(a))     # 0x100 十六进制

abs 求绝对值,正数的绝对值是正数,负数的绝对值也是正数

1 print(abs(5))
2 print(abs(-5))

sum(可迭代的数字集,start),start从哪个数开始加

 1 print(sum(range(10)))       #1+2+3+……9+10
 2 print(sum((i**2 for i in range(5))))    #1+4+9+16
 3 print(sum((1,2,3,4)))       #1+2+3+4
 4 print(sum([1,2,3,4]))
 5 print(sum((1,2,3,4)))
 6 print(sum((1,2,3,4),10))    #1+2+3+4+10
 7 print(sum((1,2,3,4),30))
 8 结果
 9 45
10 30
11 10
12 10
13 10
14 20
15 40

min/max(iterable/*args,key)
key是一个函数的内存地址,key做的事情就是根据你对每一项数据大小的需求来排序

 1 print(min(1,2,3))
 2 print(min((1,2,3)))
 3 print(min((1,2,3),(4,5,6)))
 4 print(min((7,2,3),(7,5,6)))
 5 结果
 6 1
 7 1
 8 (1, 2, 3)
 9 (7, 2, 3)
10 
11 事例1
12 def func(n):    # n = 2,3,4,7
13     return n%6  # 2,3,4,1
14 ret = min(2,3,4,7,key = func)
15 print(ret)
16 结果
17 7
18 
19 事例2
20 根据每一个元组的和来计算max或者min
21 l = [(7,2,3),(4,5,6),(-1,20,5)]
22 print(max(l,key = sum))   # sum((7,2,3))
23 结果：
24 (-1, 20, 5)
25 
26 案例
27 max函数 找到股价最高的那个字典
28 l中的每一项都会作为参数传给func
29 max和min的求值会根据func的返回值来排序
30 l = [{'name1':10},{'name2':500}]
31 def max(iter,key = None):            # 内置的max   iter = [{'name1':10},{'name2':500}] , key = func
32     ret = 0                          # ret = 0
33     max_value = 0                    # max_value = 0
34     if key:                          # key = func
35         for i in iter:               # iter = [{'name1':10},{'name2':500}]
36             print(key(i),max_value)  # i = {'name1':500}  key(i) = func({'name1':500}) = 500,max_value = 10
37             if key(i) > max_value:   # 500>10
38                 max_value = key(i)   # max_value = 500
39                 ret = i              # ret ={'name1':500}
40     return ret
41 
42 def func(dic):             #  {'name1':10}
43     for k in dic:
44         return dic[k]      # 10
45 print(max(l,key = func))
46 print(min(l,key = func))
47 结果：
48 10 0
49 500 10
50 {'name2': 500}
51 {'name1': 10}

divmod 商余函数(计算商和余数)

1 主要应用: 翻页功能
2 print(divmod(10,3))
3 print(divmod(7,4))
4 print(divmod(8,3))
5 结果
6 (3, 1)
7 (1, 3)
8 (2, 2)

round(小数,保留几位小数)  小数精确
整数是奇数 -> 正常四舍五入
整数是偶数 -> 五舍六入

 1 2.x(完全的四舍五入)和3.x(更精准的计算方式)不同
 2 print(round(2.3258358))
 3 print(round(2.3253358,2))
 4 print(round(2.3254358,3))
 5 print(round(1.5))
 6 print(round(2.5))
 7 print(round(2.6))
 8 结果
 9 2
10 2.33
11 2.325
12 2
13 2
14 3

pow(x,y,z=1) 幂运算/幂余运算 x的y次方%z

 1 print(pow(2,3))
 2 print(pow(3,2))
 3 print(pow(5,3,2))
 4 print(pow(4,2,2))
 5 print(pow(4,3,2))
 6 结果
 7 8
 8 9
 9 1
10 0
11 0

list
tuple

reversed  返回一个迭代器,节省内存
reversed 不修改原基础: 不直接返回列表而返回迭代器,为了不占用更多的内存
reverse 是在原基础上修改: 2000项的列表,不会产生额外的内存占用

 1 l = [1,2]
 2 l.reverse()
 3 print(l)
 4 结果：
 5 [2, 1]
 6 
 7 ret = reversed([1,2,3])  # iterator可迭代的
 8 print(ret)
 9 print(list(ret))
10 结果：
11 <list_reverseiterator object at 0x0000024B9ECEEC88>
12 [3, 2, 1]
13 
14 lst = ["河南", "四川", "东北", "山东", "上海"]
15 r = reversed(lst)
16 print(list(r))
17 结果
18 ['上海', '山东', '东北', '四川', '河南']
19 
20 s= "不是上海自来水来自海上"
21 print(s[::-1])
22 it = reversed(s)
23 s2 = ''
24 for i in it:
25     s2 += i
26 print(s2)
27 结果：
28 上海自来水来自海上是不
29 上海自来水来自海上是不

slice  切片

1 l = [1,2,3,4,5,]
2 ret = slice(1,4)   # [1:4]
3 print(l[ret])
4 等于
5 print(l[1:4])
6 结果：
7 [2, 3, 4]
8 [2, 3, 4]

format(填充)

 1 print(format('test', '<20'),'alex')
 2 print(format('test', '>20'),'alex')
 3 print(format('test', '^20'),'alex')
 4 结果：
 5 test                 alex
 6                 test alex
 7         test         alex
 8 
 9 进制转换
10 print(format(3, 'b'))   # 转换成二进制  binary  0b11
11 print(format(65, 'c'))  # 转换成unicode字符  ascii
12 print(format(11, 'o'))  # 转换成八进制  0o    13
13 print(format(11, 'x'))  # 转换成十六进制(小写字母)
14 print(format(11, 'X'))  # 转换成十六进制(大写字母)
15 print(format(11, 'd'))  # 转换成十进制
16 print(format(11, 'n'))  # 和d一样
17 print(format(11))       # 和d一样
18 结果
19 11
20 A
21 13
22 b
23 B
24 11
25 11
26 11
27 
28 科学计数法
29 print(format(123456789, 'e'))   # 科学计数法,默认保留6位小数,表示大的数据
30 print(format(123456789, '.2e')) # 科学计数法,保留2位小数(小写)
31 print(format(123456789, '0.2E'))# 科学计数法,保留2位小数(大写)
32 结果
33 1.234568e+08
34 1.23e+08
35 1.23E+08
36 
37 浮点计数法
38 print(format(1.23456789, 'f'))    # 浮点数计数法,保留6位小数
39 print(format(1.23456789, '0.2f')) # 小浮点数计数法,保留2位小数
40 print(format(1, '0.10f'))         # 小浮点数计数法,保留10位小数
41 print(format(1.23456789e+10000, 'F')) # 小浮点数计数法
42 结果
43 1.234568
44 1.23
45 1.0000000000
46 INF        #无穷大

bytes 字节
网络上传输的数据: bytes
文件的存储: wb 写字节 rb 读字节 图片视频都是字节
网络 + 文件: wb / rb

 1 str --> bytes
 2     print('abc'.encode('utf-8'))
 3     print('你好'.encode('utf-8'))
 4 bytes --> str
 5     b = b'\xe4\xbd\xa0\xe5\xa5\xbd'
 6     print(b.decode('utf-8'))
 7 结果：
 8 b'abc'
 9 b'\xe4\xbd\xa0\xe5\xa5\xbd'
10 你好

bytearray
把一个字符串编程一个字节数组,较长的字符串的修改节省内存,修改行为必须依靠编码

1 ret = bytearray('abc'*30,encoding='utf-8')  # 字节数组
2 print(ret)
3 ret[0] = 102   # assice码  65A 97a bcdef 你好 您好
4 print(ret)

memoryview 忘记吧

1 print(memoryview(bytes('hello,eva',encoding='utf-8')))
2 结果：
3 <memory at 0x0000026B858B8048>

ord/chr  字符和编码之间的转换

1 print(ord('中'))
2 print(chr(20013))
3 结果
4 20013
5 中
6 
7 查看计算机中所有的字符
8 for i in range(65536):
9     print(chr(i), end= " ")

repr() 还原字符串最官方的效果

 1 转义字符
 2 \n 换行
 3 \t tab 制表符
 4 \r 回车
 5 \"   双引号
 6 \'  单引号
 7 \\    \
 8 print('hello\\n world')
 9 结果
10 hello\n world
11 
12 还原字符串最官方的效果
13 print(repr('hello\\n world'))
14 结果
15 'hello\\n world'
16 
17 原封不动的显示字符串
18 print(r'hello\\n wo\trld')
19 结果
20 hello\\n wo\trld

len 计算长度

1 print(len('abc'))
2 结果
3 3

enumerate 枚举函数

 1 lst = ['姓名','年龄','职业']
 2 for i in range(len(lst)):
 3     print(i,lst[i])
 4 等于
 5 for k,v in enumerate(lst):
 6     print(k,v)
 7 结果
 8 0 姓名
 9 1 年龄
10 2 职业
11 
12 for i in enumerate(['a','b','c'],9):    #可以指定索引起始位置
13     print(i)
14 结果：
15 (9, 'a')
16 (10, 'b')
17 (11, 'c')
18 
19 案例
20 goods_lst= [
21     {'name':'电脑','price':1999},
22     {'name':'鼠标','price':20},
23     {'name':'美女','price':20},
24 ]
25 
26 for good in goods_lst:
27     print(goods_lst.index(good)+1,good['name'],good['price'])
28 同等
29 for good in enumerate(goods_lst,1):
30     # print(good)
31     index = good[0]
32     dic = good[1]
33     name = dic['name']
34     price = dic['price']
35     print(index,name,price)
36 同等
37 #index,dic = (1, {'name': '电脑', 'price': 1999})  # 解构
38 for index,dic in enumerate(goods_lst,1):
39     print(index,dic['name'],dic['price'])
40 结果：
41 1 电脑 1999
42 2 鼠标 20
43 3 美女 20

all就是bool值(and),参数iterable,只要有一个为假返回False

1 print(all((1,2,3,True)))
2 print(all((1,2,3,0,True)))
3 print(all((1,2,3,True,[])))
4 print(all((1,2,3,True,'')))
5 结果
6 True
7 False
8 False
9 False

any就是bool值(or),参数iterable,只要有一个为真返回True

1 print(any((1,2,3,True)))
2 print(any((1,2,3,0,True)))
3 print(any((1,2,3,True,[])))
4 print(any(({},False,0,[],'')))
5 结果
6 True
7 True
8 True
9 False

zip 拉链函数,返回迭代器-节省内存,水桶效应

 1 a = (1,2,3,4)
 2 b = ('a','b','c')
 3 c = ['111','222']
 4 d = {'k1':'v1','k2':'v2'}
 5 ret = zip(a,b,c,d)
 6 print(ret)
 7 
 8 for i in ret:
 9     print(i)
10 结果：
11 <zip object at 0x0000023ECB077108>
12 (1, 'a', '111', 'k1')
13 (2, 'b', '222', 'k2')

匿名函数
定义
匿名函数的内存地址 = lambda 参数1,参数2 : 返回值/返回值的表达式
调用
接收返回值 = 匿名函数的内存地址(参数)

 1 def定义的函数: 都是有名字的,def后面写的就是函数名
 2 def qqxing():
 3     print('qqxing')
 4 func = qqxing
 5 func2 = qqxing
 6 print(qqxing.__name__)
 7 print(func.__name__)    #内置属性,通过执行的函数名返回定义的函数名
 8 print(func2.__name__)
 9 结果
10 qqxing
11 qqxing
12 qqxing
13 
14 事例2
15 def exe(func):
16     func()
17     print('执行%s函数了'%func.__name__)
18 def qqxing():
19     print('qqxing')
20 def wahaha():
21     print('wahaha')
22 exe(wahaha)
23 exe(qqxing)
24 结果
25 wahaha
26 执行wahaha函数了
27 qqxing
28 执行qqxing函数了
29 
30 
31 匿名函数没有名字,统一的名字是:<lambda>,别称: lambda表达式
32 定义一个很简单的函数,复杂的函数不要用lambda
33 def func(a,b):
34     return a + b
35 ret = func(1,2)
36 print(ret)
37 
38 fn = lambda a,b:a + b
39 ret = fn(5,6)
40 print(ret)
41 print(fn)
42 结果
43 3
44 11
45 <function <lambda> at 0x0000027766AD98C8>
46 使用场景: 配合着sorted,map,filter一起使用
47 
48 事例2
49 qqxing = lambda n:n**2
50 print(qqxing.__name__)
51 ret = qqxing(8)
52 print(ret)
53 结果
54 <lambda>
55 64
56 
57 事例3
58 f = lambda *args:sum(args)
59 ret = f(1,2,3)
60 print(ret)
61 执行结果
62 6
63 
64 事例4
65 dic = {'k1':10,'k2':100,'k3':30}
66 m = max(dic,key=lambda k:dic[k])
67 print(m)
68 同等
69 def func(k):
70     return dic[k]
71 m = max(dic,key=func)
72 print(m)
73 结果
74 k2
75 
76 接收两个参数,返回较大值(不用max内置函数)
77 f1 = lambda a,b : max(a,b)
78 f2 = lambda a,b : a if a>b else b

sorted() 排序,根据key对应的函数的返回值的大小来排序的
由于必须要知道后面的值是谁,才能排出顺序,所以结果就是排序后的结果而不是可迭代的
按照字符串长度排序
执行流程: 把可迭代对象中的每一项拿出来, 作为参数传递给后面key函数,函数返回数字,根据数字进行排序

 1 lst = ['关谷神奇','吕小布','诺兰','山口美惠子','易']
 2 def func(s):
 3     return len(s)
 4 ret = sorted(lst,key=func)
 5 print(ret)
 6 同等
 7 print(sorted(lst,key=lambda s:len(s)))
 8 结果：
 9 ['易', '诺兰', '吕小布', '关谷神奇', '山口美惠子']
10 
11 事例2
12 lst = [
13     {"name":"bob", "shengao":150, "tizhong":250},
14     {"name":"jary", "shengao":158, "tizhong":150},
15     {"name":"jack", "shengao":177, "tizhong":130},
16     {"name":"pique", "shengao":165, "tizhong":130},
17     {"name":"alice", "shengao":160, "tizhong":120},
18     {"name":"athena", "shengao":183, "tizhong":190}
19 ]
20 按照体重进行排序
21 按照身高进行排序
22 print(sorted(lst,key=lambda dic:dic['tizhong']))
23 print(sorted(lst,key=lambda dic:dic['shengao']))
24 
25 
26 事例3
27 l = [-3,1,2]
28 l.sort()
29 print(l)
30 def func(n):
31     return abs(n)
32 l.sort(key = func)
33 print(l)
34 结果
35 [-3, 1, 2]
36 [1, 2, -3]
37 
38 事例4
39 l = [1,-3,2]
40 new_l = sorted(l)   #在不改变原列表的情况下 生成一个新列表
41 print(l)
42 print(new_l)
43 def func(n):
44     return abs(n)
45 ret = sorted(l,key = func)
46 print(ret)
47 结果
48 [1, -3, 2]
49 [-3, 1, 2]
50 [1, 2, -3]
51 
52 事例5
53 按照每一个字典中商品的价格从高到低排列
54 l = [{'name':'电脑','price':1999},{'name':'鼠标',

转载于:https://www.cnblogs.com/selina1997/p/10140126.html