Python 内置函数

函数就是以功能为导向，一个函数封装一个功能，那么Python将一些常用的功能（比如len）给我们封装成了一个一个的函数，供我们使用，他们不仅效率高（底层都是用C语言写的），而且是拿来即用，避免重复早轮子，那么这些函数就称为内置函数，到目前为止python给我们提供的内置函数一共是68个

all() any() bytes() callable() chr() complex() divmod() eval() exec() format() frozenset() globals() hash() help() id() input() int() iter() locals() next() oct() ord() pow() repr() round()
abs() enumerate() filter() map() max() min() open() range() print() len() list() dict() str() float() reversed() set() sorted() sum() tuple() type() zip() dir()
classmethod() delattr() getattr() hasattr() issubclass() isinstance() object() property() setattr() staticmethod() super()

参考资料:
https://www.processon.com/view/link/5b4ee15be4b0edb750de96ac

eval：执行字符串类型的代码，并返回最终结果。

print(eval('6+6')) # 12
n = 66
print(eval('n+4')) # 70
eval('print(666)')  # 666

exec:执行字符串类型的代码。

msg = '''
for i in [5,6,7]:
    print(i)
'''
exec(msg)
# result
5
6
7

hash：获取一个对象（可哈希对象：int，str，Bool，tuple）的哈希值。

print(hash(111))    # 111
print(hash('111'))  # -4507215569658252874
print(hash('abc'))  # -1843215514848640984
print(hash(True))   # 1
print(hash(False))  # 0
print(hash((1,2,3)))  # 2528502973977326415

help：函数用于查看函数或模块用途的详细说明。

print(help(list))
print(help(str.strip))

callable：函数用于检查一个对象是否是可调用的。如果返回True，object仍然可能调用失败；但如果返回False，调用对象ojbect绝对不会成功。

name = 'Python'
def func():
    pass
print(callable(name)) # False
print(callable(func)) # True

int：函数用于将一个字符串或数字转换为整型。

print(int())      # 0
print(int('66'))  # 66
print(int(5.78))  # 5
print(int('1111',base=2)) # 15  将2进制的 1111 转化成十进制。结果为 15

float：函数用于将整数和字符串转换成浮点数。

complex：函数用于创建一个值为 real + imag * j 的复数或者转化一个字符串或数为复数。如果第一个参数为字符串，则不需要指定第二个参数。

print(float(6))   # 6.0
print(complex(1,2)) # (1+2j)

bin：将十进制转换成二进制并返回。

oct：将十进制转化成八进制字符串并返回。

hex：将十进制转化成十六进制字符串并返回。

print(bin(15),type(bin(15))) # 0b1111 <class 'str'>
print(oct(15),type(oct(15))) # 0o17 <class 'str'>
print(hex(15),type(hex(15))) # 0xf <class 'str'>

divmod：计算除数与被除数的结果，返回一个包含商和余数的元组(a // b, a % b)。

round：保留浮点数的小数位数，默认保留整数。

pow：求x**y次幂。（三个参数为x**y的结果对z取余）

print(divmod(10,3))  # (3, 1)
print(round(10/3))   # 3
print(round(10/3,2)) # 3.33
print(pow(2,3))      # 8
print(pow(2,3,3))    # 2

bytes：用于不同编码之间的转化。

msg = '山药'
bmsg = msg.encode('utf-8')
print(bmsg) # b'\xe5\xb1\xb1\xe8\x8d\xaf'
msg2 = bmsg.decode('utf-8')
print(msg2) # 山药

msg3 = '山药'.encode('gbk') #
msg4 = msg3.decode('gbk')  #
print(msg4.encode('utf-8')) #b'\xe5\xb1\xb1\xe8\x8d\xaf'

str1 = '山药'
bs = bytes(str1,encoding='utf-8')
print(bs) # b'\xe5\xb1\xb1\xe8\x8d\xaf'

bs1 = str(bs,encoding='utf-8')
print(bs1) # 山药

ord:输入字符找该字符编码的位置

chr:输入位置数字找出其对应的字符

print(ord('A'))  # 65
print(ord('山'))  # 23665
print(chr(97))   # a
print(chr(30000)) # 田

repr:返回一个对象的string形式（原形毕露）。

name = '山药.'
# %r  原封不动的写出来
print('My name is %s' % name) # My name is 山药.
print('My name is %r' % name) # My name is '山药.'

print(repr('{"name":"山药"}')) # '{"name":"山药"}'
print('{"name":"山药"}') # {"name":"山药"}

all：可迭代对象中，全都是True才是True

any：可迭代对象中，有一个True 就是True

print(all([1,2,True,0])) # False
print(any([1,'',0])) # True

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)

    Prints the values to a stream, or to sys.stdout by default.
    Optional keyword arguments:
    file:  a file-like object (stream); defaults to the current sys.stdout.
            默认是输出到屏幕，如果设置为文件句柄，输出到文件
    sep:   string inserted between values, default a space.
            打印多个值之间的分隔符，默认为空格
    end:   string appended after the last value, default a newline.
            每一次打印的结尾，默认为换行符
    flush: whether to forcibly flush the stream.
            立即把内容输出到流文件，不作缓存
    """
    pass
'''
print(111,222,333,sep='<') # 111<222<333
print(111,end='\t')
print(222) # 两行的结果 111222
f = open('zzz','w',encoding='utf-8')
print('写入文件',f,flush=True) # 写入文件 <_io.TextIOWrapper name='zzz' mode='w' encoding='utf-8'>

int():pass

str():pass

bool():pass

set(): pass

list() 将一个可迭代对象转换成列表

tuple() 将一个可迭代对象转换成元组

dict() 通过相应的方式创建字典。

list1 = list('1234')
print(list1) # ['1', '2', '3', '4']
tuple1 = tuple('abcd')
print(tuple1) # ('a', 'b', 'c', 'd')

abs() 返回绝对值

n = -666
print(abs(n)) # 666

sum() 求和

print(sum([1,2,3,4])) # 10
print(sum([1,2,3,4],10)) # 20

min() 求最小值

print(min([1,2,3]))  # 1  返回此序列最小值
ret = min([1,2,-6],key=abs)  # 按照绝对值的大小，返回此序列最小值
print(ret) # 1
# 加key是可以加函数名，min自动会获取传入函数中的参数的每个元素，然后通过你设定的返回值比较大小，返回最小的传入的那个参数。
print(min(2,-3,6,-7,key=lambda x: abs(x))) # 2 可以设置很多参数比较大小
dic = {'a':3,'b':2,'c':1}
print(min(dic,key=lambda x: dic[x])) # c 
# x为dic的key，lambda的返回值（即dic的值进行比较）返回最小的值对应的键

max() 最大值与最小值用法相同。

reversed() 将一个序列翻转, 返回翻转序列的迭代器 reversed 示例:

str1 = reversed('山药')
print(list(str1)) # ['药', '山']  获取到的是一个生成器
ret = reversed([1,4,6,8,9])
print(list(ret)) # [9, 8, 6, 4, 1]

**zip() 拉链方法。**函数用于将可迭代的对象作为参数,将对象中对应的元素打包成一个个元组,

然后返回由这些元祖组成的内容,如果各个迭代器的元素个数不一致,则按照长度最短的返回

list1 = [2,3,4]
list2 = ['a','b','c','d','e']
tup1 = (66,77,88,22,33,55)
for i in zip(list1,list2,tup1):
    print(i)
# result
(2, 'a', 66)
(3, 'b', 77)
(4, 'c', 88)

sorted排序函数

语法:sorted(iterable,key=None,reverse=False)
iterable : 可迭代对象
key: 排序规则(排序函数),在sorted内部会将可迭代对象中的每一个元素传递给这个函数的参数.根据函数运算的结果进行排序
reverse :是否是倒叙,True 倒叙 False 正序
    
list1 = [5,7,4,2,8]
list2 = sorted(list1)
print(list1) # [5, 7, 4, 2, 8] 原列表不会改变
print(list2) # [2, 4, 5, 7, 8] 返回的新列表是经过排序的
list3 = sorted(list1,reverse=True)
print(list3) # [8, 7, 5, 4, 2] 倒叙

# 字典使用sorted排序
dic = {5:'a',7:'c',6:'b'}
print(sorted(dic)) # [5, 6, 7]  字典排序返回的就是排序后的key

# 和函数组合使用
# 定义一个列表,然后根据一元素的长度排序
list1 = ['Linux','Python','Java','OpenStack']
# 计算字符串的长度
def func(s):
    return len(s)
print(sorted(list1,key=func)) # ['Java', 'Linux', 'Python', 'OpenStack']

# 和lambda组合使用
list1 = ['Linux','Python','Java','OpenStack']
print(sorted(list1,key=lambda s: len(s))) # ['Java', 'Linux', 'Python', 'OpenStack']

list1 = [{'id':1,'name':'山药','age':18},
         {'id':2,'name':'枸杞','age':20},
         {'id':3,'name':'韭菜','age':19}]
# 按照年龄对学生信息进行排序
print(sorted(list1,key=lambda e:e['age']))
# result
[{'id': 1, 'name': '山药', 'age': 18}, {'id': 3, 'name': '韭菜', 'age': 19}, {'id': 2, 'name': '枸杞', 'age': 20}]

filter筛选过滤

语法: filter(function,iterable)
function: 用来筛选的函数,在filter中会自动的把iterable中的元素传递给function,然后根据function返回的True或者False来判断是否保留此项数据
iterable:可迭代对象
    
list1 = [{'id':1,'name':'山药','age':18},
         {'id':2,'name':'枸杞','age':20},
         {'id':3,'name':'韭菜','age':19}]
list2 = filter(lambda e:e['age'] >18,list1)
print(list(list2))
[{'id': 2, 'name': '枸杞', 'age': 20}, {'id': 3, 'name': '韭菜', 'age': 19}]

map

映射函数
语法: map(function,iterable) 可以对可迭代对象中的每一个元素进映射,分别取执行function

计算列表中每个元素的平方,返回新列表
list1 = [2,3,4,5,6]
def func(s):
    return s*s
mp = map(func,list1)
print(mp) # <map object at 0x00000271DF168470>
print(list(mp)) # [4, 9, 16, 25, 36]
# 改写成lambda
list1 = [2,3,4,5,6]
print(list(map(lambda s: s*s,list1))) #[4, 9, 16, 25, 36]
# 计算两个列表中相同位置的数据的和
list1 = [2,3,4,5,6]
list2 = [1,3,7,9,4]
print(list(map(lambda x,y: x+y,list1,list2))) # [3, 6, 11, 14, 10]

reduce

from functools import reduce
def func(x,y):
    return x+y
# reduce 的使用方式:
# reduce(函数名,可迭代对象)  # 这两个参数必须都要有,缺一个不行
ret = reduce(func,[2,3,4,5,6,7])
print(ret) # 27
'''
reduce的作用是先把列表中的前俩个元素取出计算出一个值然后临时保存着,
接下来用这个临时保存的值和列表中第三个元素进行计算,求出一个新的值将最开始
临时保存的值覆盖掉,然后在用这个新的临时值和列表中第四个元素计算.依次类推

注意:我们放进去的可迭代对象没有更改
以上这个例子我们使用sum就可以完全的实现了.我现在有[1,2,3,4]想让列表中的数变成1234,就要用到reduce了.
'''
# 普通函数版
from functools import reduce
def func(x,y):
    return x*10+y
list1 = reduce(func,[1,2,3,4])
print(list1) # 1234
# 匿名函数版
list2 = reduce(lambda x,y: x*10+y,[1,2,3,4])
print(list2) # 1234
'''
在Python2.x版本中recude是直接 import就可以的, Python3.x版本中需要从functools这个包中导入
龟叔本打算将 lambda 和 reduce 都从全局名字空间都移除, 舆论说龟叔不喜欢lambda 和 reduce
最后lambda没删除是因为和一个人写信写了好多封,进行交流然后把lambda保住了.
'''