【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()
print(asc)  #输出A

num = ord("A")
print(num) #输出65

实例随机生成四位验证码：

#实例生成四位的随机验证码
#-9的ASCII  -
#A-Z的ASCII  -
#a-z的ASCII  -
import random
emp = ""
for i in range(,):
    ran = random.randrange(,)
    if ran == :
        emp += str(random.randrange(,))
    elif ran == :
        emp += chr(random.randrange(,))
    else:
        emp += chr(random.randrange(, ))
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','','','','A','赵','钱','孙','李','','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'