内置函数1

查看有哪些内置函数：

import builtins
for i in dir(builtins):
    print(i)

　　

1、abs(number):  取数字的绝对值

print(abs(-3))   #取绝对值   3

2、all(iterable)  ：只能是一个可迭代对象，判断这个可迭代对象的所有元素为非空，则为True，任一元素为空，则为False

print(all(([],[],)))   #False
print(all([[],'abc',123,()]))  #False
print(all([[123,'dfdf'],('dfdf')]))   #True

3、any(iterable) ;   通all，判断该可迭代对象是否包含非空元素，元素全部为空则为False，任一元素非空，则为True

print(any({}))  # False
print(any(['abc',(),123]))  #True

4、bin（number）、hex、oct  分别将十进制数字转换为对应的二进制、十六进制、八进制

print(bin(3))   # 0b11    将10进制数字转换为二进制
print(hex(17))   #0x11    将10进制数字转换为16进制
print(oct(9))    #0o11    将10进制数字转换为8进制

5、bool()  :判断一个元素的boolean值：  0、None、空 --》False    其它为True

#print(bool(None))  #False

6、callable(o)    #判断一个元素是否可以被调用，是为True，不能为False

x =10
def foo(x):
    return x
print(callable(foo))    #True  注意。这里是函数名，如果是foo()则是对函数的返回结果的判断，如下为False
print(callable(foo(x)))   #False
print(callable(x))   #False

7、chr(code)、ord(c)  将ASCII转换为10进制数字，或者转换过来

print(chr(67))   #C
print(ord('C'))   #67

8、complex(复数)    可以打印出一个复数的实数和虚数部分

res = complex(1+2j)
print(res.real)   #1.0
print(res.imag)   #2.0

9、工厂函数：int、str、list、set、dict、puple、

list1 = []  #  ==list2 = list([])

10、dir(object)  查看一个对象下面的属性

l = []
print(dir(l))

11、help(o)    对象的帮助文档，包括对其属性的使用示例

l = []
print(help(l))

12、divmod(a,b)   返回a/b的商和余数并放在元组中

print(divmod(100,3))   #(33, 1)

13、　range()   enumerate(可迭代对象），在python3中都是迭代到时才存在内存中。

for i in range(1,10):   #不写名起始位置，则从0开始，指明起始位置则，打印出左边界-右边界-1
    print(i)

for x in enumerate(range(10),1):   #(1,0)  (2,1)  (3,2) ... (10,9)   enumerate(可迭代对象，起始值）
    print(x)

14、　eval（)   将字符串格式的字典，转换为字典格式。通常用在将input获得的变量转换为字典格式，方便后面操作

cmd = "{1:'a',2:'b'}"
print(type(cmd))  #str
print(eval(cmd))  #{1: 'a', 2: 'b'}
print(type(eval(cmd)))  #dict

15、frozenset({})  定义一个不可变得集合  。set:可变集合

s = set({1,2})
s.add(3)
print(s)   #{1,2,3}
s1 = frozenset({1,2})
s1.add(3)  #frozenset()没有add 方法   'frozenset' object has no attribute 'add'

16、hash(o)   :得到对象的hash值

　　　　#只要校验的内容一致，则hash得到的结果永远一致

　　　　#不可逆

　　　　#只要采用的hash算法一致，则不管校验的内容多长，hash得到的结果长度一样

print(hash('adfdfdfd'))  #-7566950498571372601
print(hash('adfdfdfd'))  #-7566950498571372601

17、id(o) 返回对象的身份证号。可以用id判断两个对象的身份证号是否相同，是否指向一个内存地址。  ==是判断值是否相等

x = 10
y = 10
print(id(x))  #1639501840
print(id(y))  #1639501840
print(x is y)   #True

18、max(iterator)   返回一个可迭代对象中的最大值

print(max([1,4,3]))   #4

19、pow(x,y) 返回x的y次方    pow(x,y,z)  返回x的y次方再除以z的余数

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

20、reversed()   返回倒叙

l = [1,2,3,4]
for i in reversed(l):
    print(i)
print(l)
v = reversed(l)
print(list(v))  #[4, 3, 2, 1]

21、round(number,ndigits)   保留n位小数，最后一位是四舍五入的结果

print(round(3.1415926,4))    #3.1416

22、slice()  ：预先设置好切片策略，用到时直接调用list[s]

l = ['a','b','c','d','e']
print(l[1:4:2])   #['b', 'd']
s =slice(1,4,2)
print(l[s])

23、__import__('time')   以字符串的形式导入模块

m = __import__('time')
m.sleep(3)

 24、seek(offset[,whence])   :

　　offset:需要移动偏移的字节数      # 注意：这里是字节

　　whence:可选参数，表示从哪里开始偏移，默认是0。0：文件起始位置；1：从当前位置；2：从文件末尾

with open('a.txt','r',encoding='utf-8') as f:
      f.seek(0)         #从开头开始
    f.seek(0,2)      #从文件末尾开始
    f.readlines()

25、匿名函数：节省内存，因为该函数没有名字，所以应用场景比较简单，在用完后内存即得到释放

f = lambda x,y : x+y
#      参数    返回的结果：相当于返回x+y的和
print(f(1,2))   #3

26、max、min、sorted函数实现打印出工资最高的人名

#实现：打印出工资最高的人名
salaries = {'agen':3000,'alex':1000000,'wupeiqi':10000,'yuanhao':2000}
print(max(salaries))   #yuanhao   因为默认比较的是key，key比较的话是按字母大小排序
print(max(salaries.values()))   #1000000只打印了工资
res=zip(salaries.values(),salaries.keys())
#print(max(res))   #(1000000, 'alex')
print(list(res))  #[(3000, 'agen'), (10000, 'wupeiqi'), (1000000, 'alex'), (2000, 'yuanhao')]
#注意：res是一个解释器，迭代完一次之后就是个空的列表，若先print(max(res))得到的就是【】

#max(salaries,key)  max按照key值得大小比较，并返回结果
def func(f):
    return salaries[f]

print(max(salaries,key=func))     #直接返回alex
#max每一次迭代都是取salaries的key值传给函数func，并将结果返回传递给key，max函数以key值大小排序
#可以用匿名函数简写为
print(max(salaries,key=lambda k:salaries[k]))   #  alex

27、min的用法

print(min(salaries,key=lambda k:salaries[k]))   #yuanhao

28、sorted排序的用法

print(sorted(salaries))  #按字母排序，默认是从小到到 ['agen', 'alex', 'wupeiqi', 'yuanhao']
print(sorted(salaries,key=lambda k:salaries[k]))   #['yuanhao', 'agen', 'wupeiqi', 'alex']
print(sorted(salaries,key=lambda k:salaries[k],reverse = True))
#sorted参数reverse 反转，由大道小排列  ['alex', 'wupeiqi', 'agen', 'yuanhao']

29、global关键字

#global关键字，在函数内部对外部作用域做出修改
x = 1000
def foo():
    global x   #有global，则后面调用玩foo()函数后，打印x得到的结果是0，没有global结果就是1000.
    x = 0
foo()
print(x)

30、map(函数，可迭代对象）：每次迭代都是取可迭代对象的一个值传递给函数的参数，将返回结果放入迭代器返回

l = ['alex','agen','yuanhao']
res = map(lambda k:k+'_SB',l)
print(list(res))   #['alex_SB', 'agen_SB', 'yuanhao_SB']
nums = (2,4,9,10)  #得到每个值的平方
res1 = map(lambda x:x**2,nums)
print(list(res1))  #[4, 16, 81, 100]
print(nums)  #(2, 4, 9, 10) 对原参数没有改变

31、reduce

from functools import reduce   #reduce现在是放在functools模块中，用到需要导入
l = [1,2,3,4,5]
print(reduce(lambda x,y:x+y,l))  #15
print(reduce(lambda x,y:x+y,l,10)) #25
# reduce：如果没有初始值则首先弹出第一个参数，第二次迭代时在弹出一个参数传递给函数，后面就是两个参数的和跟第三个参数传递
#每次都是第一次的结果跟下一次迭代的值作为参数传递给函数的参数
#如果有初始值则不需要弹出第一个参数，直接第一个参数跟初始值传递给函数

32、filter:过滤函数，其中的函数不用if判断，用endswith判断，返回boolean值，如果True则返回元素。

l = ['alex_sb','wupid_sb','agen']
res=filter(lambda x:x.endswith('sb'),l) 
print(list(res))   #['alex_sb', 'wupid_sb']