【python之路18】内置函数，补充请看【python之路46】
1、abs(number)表示某个数字的绝对值
print(abs(-123)) #打印出123
2、all(iterable) 表示可迭代的参数全部为True那么返回True，否则返回False
re = all([True,True]) #参数为可迭代的，当参数全部为True时才返回True，否则返回False print(re) #True
python中False的情况：False,0,None,'',[],(),{},set()，其他情况则为True，可以用bool转换进行验证，例如：
bol = bool(set()) print(bol) #打印False
re = all(['aa',(11,22),{}]) print(re) #因为上面参数中有一个{}所以其中有一个为False，则结果打印出False
3、any(iterable) 表示可迭代的参数只要有一个为True那么返回True，否则返回False
re = any(['',(),[],{}]) print(re) #因为参数中全部为False类型，所以结果打印出False
4、ascii(对象) #表示在对象的类中找到__repr__，执行__repr__并将返回的结果返回给ascii，然后由ascii返回回来
class Foo: def __repr__(self): return 'hello world!' fo = Foo() #类的实例化 print(ascii(fo)) #输出'hollo world!'
5、关于进制转换的函数
bin() 二进制
oct() 八进制
int() 十进制
hex() 十六进制
1）十进制转化为其他进制
re = bin(20) #将十进制20转化为二进制 re = oct(20) #将十进制20转化为八进制 re = int(20) #将十进制20转化为十进制 re = hex(20) #将十进制20转化为十六进制
2）将其他进制转化为十进制
re = int('0b10',base=2) #将二进制转化为十进制 re = int('0o71',base=8) #将八进制转化为十进制 re = int('0xAB',base=16) #将十六进制转化为十进制
re1 = int(0b10) #将二进制转化为十进制 re2 = int(0o71) #将八进制转化为十进制 re3 = int(0xAB) #将十六进制转化为十进制 re1 = int('0b10',0) #将二进制转化为十进制 re2 = int('0o71',0) #将八进制转化为十进制 re3 = int('0xAB',0) #将十六进制转化为十进制
6、bool()判断真假
可以将任何值转化为布尔类型,如：False,0,None,'',[],(),{},set()转化为False
7、bytes()和bytearray()
byt = bytes('xxxx',encoding='utf-8') #将字符串转化为字节
8、chr() ord() ASCII码字符和数字转换
asc = chr(65) print(asc) #输出A
num = ord("A") print(num) #输出65
实例随机生成四位验证码：
#实例生成四位的随机验证码 #0-9的ASCII 48-57 #A-Z的ASCII 65-90 #a-z的ASCII 97-122 import random emp = "" for i in range(1,5): ran = random.randrange(1,4) if ran == 1: emp += str(random.randrange(0,9)) elif ran == 2: emp += chr(random.randrange(65,90)) else: emp += chr(random.randrange(97, 122)) print(emp)
9、callable()判断对象是不是可执行的
def f1() print("hello word") callable(f1) #如果f1后面加括号，可以被执行，那么返回True,否则返回False
10、compile()编译，将字符串类型的代码编译为可执行的代码
#!usr/bin/env python # -*- coding:utf-8 -*- code = "for i in range(10):print(i)" cmpcode = compile(code,'','exec') exec(cmpcode) #结果将打印0-9的数字
#!usr/bin/env python # -*- coding:utf-8 -*- str = '3 * 4 + 5' a = compile(str,'','eval') print(eval(a)) #打印出17
11、dir(类名) 列出某个类的功能
print(dir(list))
会打印出：['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']
12、divmod(除数,被除数) 返回一个元组（商,余数）
print(divmod(10,3)) #会打印(3, 1)
13、enumeric(可迭代的,起始位置） 可以在循环时加入序号
#!usr/bin/env python # -*- coding:utf-8 -*- li = [11,22,33,44,55] for i,j in enumerate(li,1): print(i,j)
输出结果：
1 11
2 22
3 33
4 44
5 55
14、eval('1 + 2') 执行表达式， 可以计算字符串的四则运算
#!usr/bin/env python # -*- coding:utf-8 -*- re = eval('1+3*2') print(re) #打印输出7
#!usr/bin/env python # -*- coding:utf-8 -*- re = eval('a+99',{'a':100}) print(re) #打印输出199
15、exec（字符串） 可以将字符串转化为代码执行
#!usr/bin/env python # -*- coding:utf-8 -*- st = "print('hello worl!')" exec(st) #输出：hello worl!
16、filter(函数，可迭代的对象) 将可迭代的对象的每一个元素作为参数，循环调用函数，如果函数返回True,则加入filter返回数据的迭代对象
#!usr/bin/env python # -*- coding:utf-8 -*- def f1(num): if num > 30: return True else: return False re = filter(f1,[11,22,33,44,55,66]) print(list(re)) #打印输出[33, 44, 55, 66]
函数可以用lambda表示
re = filter(lambda num:num > 30,[11,22,33,44,55,66] ) print(list(re)) #打印输出[33, 44, 55, 66]
17、map(函数,可迭代的对象）将可迭代的对象的每一个元素作为参数，循环调用函数，将函数返回的值,则加入filter的迭代对象
例如：列表 li = [11,22,33,44,55],将函数的每个元素加100
li = [11, 22, 33, 44, 55] def f1(num): return num + 100 re = map(f1,li) print(list(re))
可以用lambda表达式：
li = [11, 22, 33, 44, 55] re = map(lambda num:num + 100,li) print(list(re))
上面的例子，条件改为如果列表中是寄数则加100，否则原值返回：（可以加入三元运算符）
#!usr/bin/env python # -*- coding:utf-8 -*- li = [11, 22, 33, 44, 55] re = map(lambda num:num + 100 if num % 2 == 1 else num,li) print(list(re)) #打印输出[111, 22, 133, 44, 155]
18、globals()获取当前所有的全局变量
print(globals()) #返回：{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__':
<_frozen_importlib_external.SourceFileLoader object at 0x000001ECB4E1B1D0>, '__spec__':
None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__':
'E:/python_code/2/seven day/built-in_function.py', '__cached__': None}
19、locals() 获取当前的所有局部变量
#!usr/bin/env python # -*- coding:utf-8 -*- def f1(): name = 123 print(locals()) print(globals()) #返回：{'name': 123} print(f1())
20、frozenset() 冻结的结合
21、hash() 转化为哈希值，一般用在字典的key上，节省内存，并且能增加索引
哈希算法将任意长度的二进制值映射为固定长度的较小二进制值，这个小的二进制值称为哈希值。哈希值是一段数据唯一且极其紧凑的数值表示形式。如果散列一段明文而且哪怕只更改该段落的一个字母，随后的哈希都将产生不同的值。要找到散列为同一个值的两个不同的输入，在计算上来说基本上是不可能的。
#!usr/bin/env python # -*- coding:utf-8 -*- dic = {'aafafafafasdsffdappoipewejkn':1} re = hash('aafafafafasdsffdappoipewejkn') print(re) #输出：4700510488390097995
22、help() 查某个对象的帮助，一般配合dir() 使用
help(list)
上面代码会将list类的详细帮助信息打印出来
23、id() 显示某个值的内存地址
24、input(“提示内容”) 等待用户输入内容，并返回用户输入的内容。2.x系列，返回字符串要用raw_input()
25、isinstance(类的对象,类名) 判断第一个参数是否是第2个参数的对象，如果是返回True,否则返回False
#!usr/bin/env python # -*- coding:utf-8 -*- li = [11,22,33] bol = isinstance(li,list) print(bol) #返回True
26、iter(可迭代的对象) 生成一个可迭代的对象，并不显示所有的值，当循环的时候才去取值
#!usr/bin/env python # -*- coding:utf-8 -*- li = [11,22,33,44] ob = iter(li) print(ob) #打印输出迭代对象：<list_iterator object at 0x000002216D01A080> r1 = next(ob) print(r1) #打印输出：11 r2 = next(ob) print(r2) #打印输出：22 r3 = next(ob) print(r3) #打印输出：33 r4 = next(ob) print(r4) #打印输出：44
27、max() min() 最大值，最小值
#!usr/bin/env python # -*- coding:utf-8 -*- li = [11,22,33,44,55] re1 = max(li) re2 = min(li) print(re1) #返回打印：55 print(re2) #返回打印：11
28、memoryview() 判断对象的内存地址
#!usr/bin/env python # -*- coding:utf-8 -*- name = 'sunshuhai' by = bytes(name,encoding='utf-8') addr = memoryview(by) #参数必须是字节类型 print(by) #打印输出：<memory at 0x00000294F56D5F48>
29、pow(2,10) 指的是2的10次方
re = pow(2,10) print(re) #打印输出：1024
30、print
31、range
32、repr(对象) #表示在对象的类中找到__repr__，执行__repr__并将返回的结果返回给repr，然后由repr返回回来
与ascii()函数用法基本相同，区别为：ascii如果是中文，ascii会进行转义
#!usr/bin/env python # -*- coding:utf-8 -*- class Foo: def __repr__(self): return "hello world!!" fo = Foo() print(repr(fo)) #打印输出：hello world!!
33、reversed(可迭代的对象) 把可迭代的有顺序索引的每个元素反转
#!usr/bin/env python # -*- coding:utf-8 -*- li = [11,22,33,44,55] new_li = reversed(li) print(new_li) #打印输出迭代对象：<list_reverseiterator object at 0x0000023AB8F3A240> print(list(new_li)) #打印输出反转后的列表：[55, 44, 33, 22, 11]
34、round() 四舍五入
#!usr/bin/env python # -*- coding:utf-8 -*- num = 3.1415 new_num = round(num,2) #四舍五入保留2位小数 print(new_num) #打印输出：3.14
35、slience() 切片，当调用函数或切片时，实际内部调用的是：__slienceitem__()
36、sum(可迭代的对象)求和
#!usr/bin/env python # -*- coding:utf-8 -*- li = [11,22,33,44] re = sum(li) print(re) #结果打印：110
37、vars(对象) 查看当前对象中有多少个变量
#!usr/bin/env python # -*- coding:utf-8 -*- re = vars(int) print(re)
38、zip(可迭代的对象1，可迭代的对象2) ，返回合并的可迭代的对象
#!usr/bin/env python # -*- coding:utf-8 -*- li1 = [11,22,33,44] li2 = ['a','b','c','d'] re = zip(li1,li2) print(re) #打印迭代对象：<zip object at 0x00000145C83B2048> print(list(re)) #打印迭代后的对象：[(11, 'a'), (22, 'b'), (33, 'c'), (44, 'd')]
39、__import__() 可以代替import
#!usr/bin/env python # -*- coding:utf-8 -*- import random i = random.randrange(0,11) #产生一个0-10的随机数 print(i)
可以用下面的代码代替：
#!usr/bin/env python # -*- coding:utf-8 -*- r = __import__('random') i = r.randrange(0,11) print(i)
40、sorted() 排序
列表本来就有方法可以进行排序，例如：
#!usr/bin/env python # -*- coding:utf-8 -*- li = [22,11,55,77,44,66] li.sort() print(li) #结果打印输出：[11, 22, 44, 55, 66, 77]
#!usr/bin/env python # -*- coding:utf-8 -*- li = [22,11,55,77,44,66] new_li = sorted(li) print(new_li) #打印输出：[11, 22, 44, 55, 66, 77]
注意：sorted()进行排序时，必须保证可迭代对象中的元素是同一中类型，如果是数字类型则按照大小进行排序，如果是字符串类型，则按照数字在前面，字母在中间，汉字在后面进行排序。其中每一类按照第一位的大小，第一位不能判断时再判断第二位
#!usr/bin/env python # -*- coding:utf-8 -*- li = ['a','22','256','211','A','赵','钱','孙','李','1','ab'] new_li = sorted(li) print(new_li) #打印输出：['1', '211', '22', '256', 'A', 'a', 'ab', '孙', '李', '赵', '钱'] #输出列表字节 for i in li: print(bytes(i,encoding='utf-8'))
b'a'
b'22'
b'256'
b'211'
b'A'
b'\xe8\xb5\xb5'
b'\xe9\x92\xb1'
b'\xe5\xad\x99'
b'\xe6\x9d\x8e'
b'1'
b'ab'
