Python之路Python内置函数、zip()、max()、min()

一、python内置函数

abs()

求绝对值

例子

print(abs（-2）)

all()

把序列中每一个元素做布尔运算，如果全部都是true，就返回true,

但是如果是空字符串、空列表也返回true

例子

print(all([1,2,'','']))

输出结果

False

例子2

print(all(''))

输出结果

True

any（）

把序列中每一个元素做布尔运算，如果有一个为true就返回true,

但是有两个false还是false

例子

print(any([0,'']))
print(any([0,'',1]))

输出结果

False
True

bin()

把十进制转换为二进制

例子

print(bin(3))

输出结果

0b11

分析：其中“0b"代表二进制

bool()

判断布尔类型的，返回True或者False

bytes()

以一个字节的形式输出数据，这里的bytes是不可变数据类型

如果是整数，就输出长度为该整数长度的字节组

例子

print(bytes(0))
print(bytes(2))
print(bytes(5))

输出结果

b''b'\x00\x00'b'\x00\x00\x00\x00\x00'

如果是字符串，则必须制定编码方式进行编码

例子

name='你好'
print(bytes(name,encoding='utf-8'))
print(bytes(name,encoding='utf-8').decode('utf-8'))

输出结果

b'\xe4\xbd\xa0\xe5\xa5\xbd'<br>你好

分析：这里的第一行输出就是以utf-8的方式对“你好”进行编码，是二进制模式下的十六进制编码，这里是十六进制的形式，utf-8中三个字节代表一个汉字，所以前3个字节代表的是“你”

第二行输出的是对十六进制的字节进行解码，用“utf-8”的形式重新解码，所以这里被还原成“你好”

例子

name='你好'
print(bytes(name,encoding='gbk'))
print(bytes(name,encoding='gbk').decode('gbk'))

输出结果

b'\xc4\xe3\xba\xc3'
你好

分析：第一行输出是用"gbk"方式对“你好”进行编码，由于gbk是2个字符代表一个汉字，所以这里可以看到，前2个代表一个汉字，后2个代表一个汉字，

同样的这里也可以被解码重新还原为原字符串

bytearray()

以一个字节组的形式输出数据

用法与bytes()类似，但这里这个数组里的元素是可变的，bytes是不可变数据类型，而bytearray像名称一样可使用append等方法；

chr()

参数是（0~255）整数，返回的其实是ASCII码对应的字符

dict()

创建字典的函数

例子

print(dict( a = "",b = "" ))

输出结果

{'a': '', 'b': ''}

分析：这种创建字典的方式key只能是字符串，不能是数字、布尔值等，创建出的字典key是写入等式的前面，等式后面写的是value

例子2

print(dict([("a",1),(2,3)]))

输出结果

{'a': 1, 2: 3}

分析：这里是用可迭代对象创造字典，即通过二元组列表创建

dir()

打印某一个对象下面都有哪些方法

例子

print(dir(str))

输出结果

['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'capitalize', 'casefold', 'center', 'count', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'format_map', 'index', 'isalnum', 'isalpha', 'isdecimal', 'isdigit', 'isidentifier', 'islower', 'isnumeric', 'isprintable', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'maketrans', 'partition', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']

divmod()

实现a除以b，然后返回商与余数的元组。如果两个参数a,b都是整数，那么会采用整数除法，结果相当于（a//b, a % b)。如果a或b是浮点数，相当于（math.floor(a/b), a%b)。

例子

print(divmod(10,3))

输出结果

(3, 1)

enumerate()

将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中。

语法

  enumerate(seq, [start=0])

seq--一个序列或者可迭代对象，start 下标的开始位置

例子

li = ["nicholas","jack","pony"]
for i in enumerate(li,1):
    print(i)

输出结果

(1, 'nicholas')
(2, 'jack')
(3, 'pony')

eval()

将字符串str当成有效的表达式来求值并返回计算结果。

例子

#字符串转换成字典
print(eval('{"nick":1,"jack":2}'))

输出结果

{'nick': 1, 'jack': 2}

计算字符串里的表达式的值

例子

x,y = 1,2
print(eval('x + y'))

输出结果

hash()

用来做哈希运算的，只要可hash就是不可变数据类型

不可hash的就是可变数据类型

哈希是一种算法，把文件内容进行一个运算，最终得出一个值

得出的结果长度是固定的，不能根据结果反推原来的内容

本函数返回对象的哈希值。返回的哈希值是使用一个整数表示，通常使用软件校验。

例子

name = "nick"
print(hash(name))
name = "nicholas"
print(hash(name))

输出结果

5166927391536352230

分析：对name进行哈希运算返回一个值，如果中途被修改，哈希值也会变化

help()

查看帮助，查看某个函数怎么用

例子

print(help(dir))

查看dir的用法

hex()、oct()、bin()

bin()将十进制转换为二进制

hex()将十进制转换为十六进制

oct()将十进制转换为八进制

isinstance()

函数来判断一个对象是否是一个已知的类型，类似 type()。

例子

print(isinstance(1,int))
print(isinstance("a",str))

输出

True
 
True

分析：判断1是不是int类型，判断“a”是不是字符串类型

locals()、globals()

这两个函数主要提供，基于字典的访问局部和全局变量的方式。

globals打印全局变量，还有一些系统提供的全局变量

locals打印局部变量

例子

{'b': 'nick '}
----------------
{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x002EA550>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': 'D:/06python/exercise/test2.py', '__cached__': None, 'a': 2, 'test': <function test at 0x02116CD8>}

分析：这里print(locals())打印的是{'b': 'nick '}，获取的是局部变量，

print(globals())在输出的最后获取了'a': 2，其他都是系统提供的全局变量

ord()

ord() 函数是 chr() 函数（对于8位的ASCII字符串）或 unichr() 函数（对于Unicode对象）的配对函数，它以一个字符（长度为1的字符串）作为参数，返回对应的 ASCII 数值

pow（）

pow(x,y)方法返回 xy（x的y次方）的值。

pow(x,y,z)方法是x的y次方得到一个值，之后再用这个值对z进行取余

例子

print(pow(2,5,3))
print(pow(2,5))

输出结果

reversed()

reversed函数返回一个反转的迭代器。即取反，取反的对象可以是列表、字符串、元组，或者range

例子

print(reversed([1,2,3,4]))
print(list(reversed([1,2,3,4])))

输出结果

<list_reverseiterator object at 0x002EA570>[4, 3, 2, 1]

分析：第一行输出，直接打印reversed输出的是一个反转的迭代器，要用list方法可以进行显示列表。

round()

返回浮点数x的四舍五入值。

set()

创建一个集合

slice()

切片对象，主要用在切片操作函数里的参数传递。

语法

slice(start, stop[, step])

例子

l = "hello world !"
s1 = slice(0,4)
print(l[s1])

输出结果

hell

例子2

l = "aeiou world !"
s2 = slice(0,4,2)
print(l[s2])

输出结果

分析：这里加了步长。

sorted()

对所有可迭代的对象进行排序操作。内建函数 sorted 方法返回的是一个新的 list，而不是在原来的基础上进行的操作。

list 的 sort 方法返回的是对已经存在的列表进行操作

sorted 方法不能针对不同类型进行排序

例子

l = [2,1,3,5,8]
print(sorted(l))

输出结果

[1, 2, 3, 5, 8]

sorted()语法

  sorted(iterable, key=None, reverse=False)

iterable -- 可迭代对象。key -- 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中

reverse -- 排序规则，reverse = True 降序， reverse = False 升序（默认）。

例子

people=[
      {'name':'nicholas','age':18},
      {'name':'jack','age':53},
      {'name':'pony','age':46},
      {'name':'richard','age':44},
  ]
print(sorted(people,key = lambda  dic:dic["age"]))

输出结果

[{'name': 'nicholas', 'age': 18}, {'name': 'richard', 'age': 44}, {'name': 'pony', 'age': 46}, {'name': 'jack', 'age': 53}]

str()

将任意类型转换为字符串

sum()

对系列进行求和计算。

语法

  sum(iterable[, start])

例子

li = [1,2,3,4,5]
print(sum(li))
print(sum(li,2))

输出结果

15
17

分析：第二行输出是先对列表求和，再加上参数2再次求和。

type()

查看某一对象的数据类型

例子

msg = ""
if type(msg) is str :
    msg = int(msg)
    res = msg + 5
    print(res)

vars()

对象object的属性和属性值的字典对象。

查看对象的属性和值，如果没有参数和locals功能一样。

如果有就显示该对象的所有方法名

print(vars(int))

二、zip()

用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表或者字典。

zip()可以传2个参数，只要是序列就可以(列表、元组、字符串)

例子

print(zip(("a","b","c"),(1,2,3)))
print(list(zip(("a","b","c"),(1,2,3))))
print(list(zip(("a","b","c"),(1,2,3,4))))
print(list(zip(("a","b","c","d"),(1,2,3))))

输出结果

<zip object at 0x0216EB98>
 
[('a', 1), ('b', 2), ('c', 3)]
 
[('a', 1), ('b', 2), ('c', 3)]
 
[('a', 1), ('b', 2), ('c', 3)]

分析：第一行输出的是zip的对象，要转换为列表用list的方法

zip的左右两个参数序列是一一对应的关系，如果有多的自动忽略

例子2

p={'name':'nicholas','age':18,'gender':'man'}
print(list(zip(p.keys(),p.values())))

输出结果

[('name', 'nicholas'), ('age', 18), ('gender', 'man')]

分析：这样就可以把字典中的元素提取出来

例子

print(dict(zip(("a","b","c"),(1,2,3))))

输出结果

{'a': 1, 'b': 2, 'c': 3}

分析：这里可以直接将zip对象转为字典。

三、max（）、min()

max()求最大的值

例子

dic = {"age1":18,"age4":25,"age2":19,"age3":28}
print(max(dic))
print(max(dic.values()))
print(max(zip(dic.values(),dic.keys())))

输出结果

age4
28
(28, 'age3')

分析：print(max(dic))语句默认比较的是字典的key，进行字符串的比较，一个字符一个字符的比较，根据字符的ASCII码进行比较

第二行输出print(max(dic.values()))，比较的是字典的value，直接输出最大的value

第三行输出是首先将字典用zip方法将字典的value和key组成一个一一对应的元组，然后直接比较这个元组的大小

具体

dic = {"age1":18,"age4":25,"age2":19,"age3":28}
v = zip(dic.values(),dic.keys())
#这里也是一个可迭代对象
for i in v:
    print(i)

输出结果

(18, 'age1')
(25, 'age4')
(19, 'age2')
(28, 'age3')

这里通过for循环可以看出zip(dic.values(),dic.keys())是一个元组

例子2

l = [(5,"a"),(3,"b"),(2,"c")]
print(max(l))

输出结果

(5, 'a')

分析：这里是从第一个值进行比较，5、3、2进行比较，如果有结果，后面的就不用比较了

例子3

l = ["a18","b21","c5"]
print(max(l))

输出结果

分析：这里也是一个字符一个字符的比较。

max()的高级用法

max(iterable,key = func)

iterable--可迭代对象，func--对对象的元素处理逻辑

例子

people=[
    {'name':'pony','age':1000},
    {'name':'jack','age':10000},
    {'name':'richard','age':9000},
    {'name':'nick','age':18},
]
print(max(people,key = lambda x:x["age"]))

输出结果

{'name': 'jack', 'age': 10000}

分析：这里是对列表中每个元素进行for循环，即字典进行取出“age”对应的value进行比较，同时输出value最大值的元素，与map函数进行for循环类似。

x["age"]是对列表的每个元素进行索引，而非对列表进行索引，因为这个max()函数对要处理的可迭代对象进行了类似for循环处理。