内置函数(***)
1.print() 屏幕输出.
''' 源码分析
def print(self, *args, sep='', end='\n', file=None): # known special case of print
""" print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False)
file: 默认是输出到屏幕, 如果设置为文件句柄, 输出到文件
sep: 打印多个值之间的分隔符, 默认为空格
end: 每一次打印的结尾, 默认为换行符
flush: 立即把内容输出到流文件, 不作缓存
- """'''
- print(111,222,333,sep='*') # 111*222*333
- print(111,end='')
- print(222) #两行的结果 111222
- f = open('log','w',encoding='utf-8')
- print('写入文件',fle=f,flush=True)
- 2.int, str,bool,set,list,tupie,dict
int(): 整型
str(): 字符串
bool(): 布尔
set(): 集合
list() 将一个可迭代对象转换成列表
tuple() 将一个可迭代对象转换成元组
dict() 通过相应的方式创建字典.
- list
- l1 = list('abcd')
- print(l1) # ['a', 'b', 'c', 'd']
- tu1 = tuple('abcd')
- print(tu1) # ('a', 'b', 'c', 'd')
3.abs() 返回绝对值
- i = -5
- print(abs(i)) # 5
4.sum() 求和
- print(sum([1,2,3]))
- print(sum((1,2,3),100))
5.min() 求最小值
- print(min([1,2,3])) # 返回此序列最小值
- ret = min([1,2,-5,],key=abs) # 按照绝对值的大小, 返回此序列最小值
- print(ret)
- # 加 key 是可以加函数名, min 自动会获取传入函数中的参数的每个元素, 然后通过你设定的返回值比较大小, 返回最小的传入的那个参数.
- print(min(1,2,-5,6,-3,key=lambda x:abs(x))) # 可以设置很多参数比较大小
- dic = {
- 'a':3,'b':2,'c':1
- }
- print(min(dic,key=lambda x:dic[x]))
- # x 为 dic 的 key,lambda 的返回值 (即 dic 的值进行比较) 返回最小的值对应的键
max() 最大值与最小值用法相同.
6.reversed()
将一个序列翻转, 返回翻转序列的迭代器 reversed 示例:
- l = reversed('你好') # l 获取到的是一个生成器
- print(list(l))
- ret = reversed([1, 4, 3, 7, 9])
- print(list(ret)) # [9, 7, 3, 4, 1]
7.bytes()转成字节
把字符串转换成 bytes 类型
- s = '你好太白'
- bs = s.encode('utf-8')
- print(bs)
结果: b'\xe4\xbd\xa0\xe5\xa5\xbd\xe6\xad\xa6\xe5\xa4\xa7'
- s1 = bs.decode('utf-8')
- print(s1)
结果: 你好太白
- s = '你好'
- bs = bytes(s,encoding='utf-8')
- print(bs)
- # 将字符串转换成字节
- bs1 = str(bs,encoding='utf-8')
- print(bs1)
- # 将字节转换成字符串
8.zip() 拉链方法
函数用于将可迭代的对象作为参数, 将对象中对应的元素打包成一个个元组,
然后返回由这些元祖组成的内容, 如果各个迭代器的元素个数不一致, 则按照长度最短的返回
- lst1 = [1,2,3]
- lst2 = ['a','b','c','d']
- lst3 = (11,12,13,14,15)
- for i in zip(lst1,lst2,lst3):
- print(i)
结果:
- (1, 'a', 11)
- (2, 'b', 12)
- (3, 'c', 13)
9.sorted 排序
排序函数
语法: sorted(iterable,key=None,reverse=False)
iterable : 可迭代对象
key: 排序规则(排序函数), 在 sorted 内部会将可迭代对象中的每一个元素传递给这个函数的参数. 根据函数运算的结果进行排序
reverse : 是否是倒叙, True 倒叙 False 正序
- lst = [1,3,2,5,4]
- lst2 = sorted(lst)
- print(lst) #原列表不会改变
- print(lst2) #返回的新列表是经过排序的
- lst3 = sorted(lst,reverse=True)
- print(lst3) #倒叙
结果:
- [1, 3, 2, 5, 4]
- [1, 2, 3, 4, 5]
- [5, 4, 3, 2, 1]
字典使用 sorted 排序
- dic = {
- 1:'a',3:'c',2:'b'
- }
- print(sorted(dic)) # 字典排序返回的就是排序后的 key
结果:
[1,2,3]
和函数组合使用
- # 定义一个列表, 然后根据一元素的长度排序
- lst = ['天龙八部','西游记','红楼梦','三国演义']
- # 计算字符串的长度
- def func(s):
- return len(s)
- print(sorted(lst,key=func))
- # 结果:
- # ['西游记', '红楼梦', '天龙八部', '三国演义']
和 lambda 组合使用
- lst = ['天龙八部','西游记','红楼梦','三国演义']
- print(sorted(lst,key=lambda s:len(s)))
结果:
- ['西游记', '红楼梦', '天龙八部', '三国演义']
- lst = [{'id':1,'name':'alex','age':18},
- {'id':2,'name':'wusir','age':17},
- {'id':3,'name':'taibai','age':16},]
- # 按照年龄对学生信息进行排序
- print(sorted(lst,key=lambda e:e['age']))
结果:
[{'id': 3, 'name': 'taibai', 'age': 16}, {'id': 2, 'name': 'wusir', 'age': 17}, {'id': 1, 'name': 'alex', 'age': 18}]
10.filter 筛选过滤
筛选过滤
语法: filter(function,iterable)
function: 用来筛选的函数, 在 filter 中会自动的把 iterable 中的元素传递给 function, 然后根据 function 返回的 True 或者 False 来判断是否保留此项数据
iterable: 可迭代对象
- lst = [{'id':1,'name':'alex','age':18},
- {'id':1,'name':'wusir','age':17},
- {'id':1,'name':'taibai','age':16},]
- ls = filter(lambda e:e['age']> 16,lst)
- print(list(ls))
结果:
- [{'id': 1, 'name': 'alex', 'age': 18},
- {'id': 1, 'name': 'wusir', 'age': 17}]
11.map 每个值进行映射
映射函数
语法: map(function,iterable) 可以对可迭代对象中的每一个元素进映射, 分别取执行 function
计算列表中每个元素的平方, 返回新列表
- lst = [1,2,3,4,5]
- def func(s):
- return s*s
- mp = map(func,lst)
- print(mp)
- print(list(mp))
改写成 lambda
- lst = [1,2,3,4,5]
- print(list(map(lambda s:s*s,lst)))
计算两个列表中相同位置的数据的和
- 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]
12.reduce 可用来阶乘
- from functools import reduce
- def func(x,y):
- return x + y
- # reduce 的使用方式:
- # reduce(函数名, 可迭代对象) # 这两个参数必须都要有, 缺一个不行
- ret = reduce(func,[3,4,5,6,7])
- print(ret) # 结果 25
reduce 的作用是先把列表中的前俩个元素取出计算出一个值然后临时保存着,
接下来用这个临时保存的值和列表中第三个元素进行计算, 求出一个新的值将最开始
临时保存的值覆盖掉, 然后在用这个新的临时值和列表中第四个元素计算. 依次类推
注意: 我们放进去的可迭代对象没有更改
以上这个例子我们使用 sum 就可以完全的实现了. 我现在有 [1,2,3,4] 想让列表中的数变成 1234, 就要用到 reduce 了.
普通函数版
- from functools import reduce
- def func(x,y):
- return x * 10 + y
- # 第一次的时候 x 是 1 y 是 2 x 乘以 10 就是 10, 然后加上 y 也就是 2 最终结果是 12 然后临时存储起来了
- # 第二次的时候 x 是临时存储的值 12 x 乘以 10 就是 120 然后加上 y 也就是 3 最终结果是 123 临时存储起来了
- # 第三次的时候 x 是临时存储的值 123 x 乘以 10 就是 1230 然后加上 y 也就是 4 最终结果是 1234 然后返回了
- l = reduce(func,[1,2,3,4])
- print(l)
匿名函数版
- l = reduce(lambda x,y:x*10+y,[1,2,3,4])
- print(l)
在 Python2.x 版本中 recude 是直接 import 就可以的, Python3.x 版本中需要从 functools 这个包中导入
龟叔本打算将 lambda 和 reduce 都从全局名字空间都移除, 舆论说龟叔不喜欢 lambda 和 reduce
最后 lambda 没删除是因为和一个人写信写了好多封, 进行交流然后把 lambda 保住了.
13.open()打开文件
open ( "文件名","模式","编码")
14.enumerate()枚举
15.range()生成类列表
16.dir()查看所有操作
如迭代器的__iter__,__next__等
内置函数(**)
1.eval:
执行字符串类型的代码, 并返回最终结果.
- eval('2 + 2') # 4
- n=81
- eval("n + 4") # 85
- eval('print(666)') # 666
- 2.exec:
执行字符串类型的代码.
- s = '''
- for i in [1,2,3]:
- print(i)
- '''
- exec(s)
- 3.hash:
获取一个对象 (可哈希对象: int,str,Bool,tuple) 的哈希值.
- print(hash(12322))
- print(hash('123'))
- print(hash('arg" ))
- print(hash('alex'))
- print(hash(True))
- print(hash(False))
- print(hash((1,2,3)))
- '''
- -2996001552409009098
- -4637515981888139739
- 1
- 2528502973977326415
- '''
- 4.help:
函数用于查看函数或模块用途的详细说明.
- print(help(list))
- print(help(str.split))
- 5.callable
: 函数用于检查一个对象是否是可调用的. 如果返回 True,object 仍然可能调用失败; 但如果返回 False, 调用对象 ojbect 绝对不会成功.
- name = 'alex'
- def func():
- pass
- print(callable(name)) # False
- print(callable(func)) # True
- 6.int:
函数用于将一个字符串或数字转换为整型.
- print(int()) # 0
- print(int('12')) # 12
- print(int(3.6)) # 3
- print(int('0100',base=2)) # 将 2 进制的 0100 转化成十进制. 结果为 4
- 7.float:
函数用于将整数和字符串转换成浮点数.
8.complex:
函数用于创建一个值为 real + imag * j 的复数或者转化一个字符串或数为复数. 如果第一个参数为字符串, 则不需要指定第二个参数..
- print(float(3)) # 3.0
- print(complex(1,2)) # (1+2j)
9.bin: 将十进制转换成二进制并返回.
10.oct: 将十进制转化成八进制字符串并返回.
11.hex: 将十进制转化成十六进制字符串并返回.
- print(bin(10),type(bin(10))) # 0b1010 <class 'str'>
- print(oct(10),type(oct(10))) # 0o12 <class 'str'>
- print(hex(10),type(hex(10))) # 0xa <class 'str'>
- 12.divmod:
计算除数与被除数的结果, 返回一个包含商和余数的元组(a // b, a % b).
13.round:
保留浮点数的小数位数, 默认保留整数.
14.pow:
求 x**y 次幂.(三个参数为 `**y 的结果对 z 取余)
- print(divmod(7,2)) # (3, 1)
- print(round(7/3,2)) # 2.33
- print(round(7/3)) # 2
- print(round(3.32567,3)) # 3.326
- print(pow(2,3)) # 两个参数为 2**3 次幂
- print(pow(2,3,3)) # 三个参数为 2**3 次幂, 对 3 取余.
- 15.bytes:
用于不同编码之间的转化.
- # s = '你好'
- # bs = s.encode('utf-8')
- # print(bs)
- # s1 = bs.decode('utf-8')
- # print(s1)
- # bs = bytes(s,encoding='utf-8')
- # print(bs)
- # b = '你好'.encode('gbk')
- # b1 = b.decode('gbk')
- # print(b1.encode('utf-8'))
16.ord: 输入字符找该字符编码的位置
17.chr: 输入位置数字找出其对应的字符
- # ord 输入字符找该字符编码的位置
- # print(ord('a'))
- # print(ord('中'))
- # chr 输入位置数字找出其对应的字符
- # print(chr(97))
- # print(chr(20013))
18.repr: 返回一个对象的 string 形式(原形毕露).
- # %r 原封不动的写出来
- # name = 'taibai'
- # print('我叫 %r'%name)
- # repr 原形毕露
- print(repr('{"name":"alex"}'))
- print('{"name":"alex"}')
19.all: 可迭代对象中, 全都是 True 才是 True
20.any: 可迭代对象中, 有一个 True 就是 True
- # all 可迭代对象中, 全都是 True 才是 True
- # any 可迭代对象中, 有一个 True 就是 True
- # print(all([1,2,True,0]))
- # print(any([1,'',0]))
来源: https://www.cnblogs.com/nieice/p/11106602.html