abs

取绝对值，数学上的绝对值

print(abs(-1))

all

接收一个可迭代参数。如果里面有一个False的元素，那么返回值就是False，否则返回True，类似逻辑“与”。如果可迭代参数本身为空，那么返回True。需要记住什么是False的元素，False本身、数字0、空字符串""、None是False的。

f = list()
f.append([1, 0, "mysql"])
f.append([1, "", "mysql"])
f.append([1, None, "mysql"])
f.append({0: "mysql", 1: "oralce"})
f.append("")
f.append([])
f.append({})for i in f:print(i, all(i))pass
# [1, 0, 'mysql'] False   
# [1, '', 'mysql'] False  
# [1, None, 'mysql'] False  
#  True   元素本身是空的，那么返回True
# [] True# [1, 0, 'mysql'] False 0是False
# [1, '', 'mysql'] False ''是False
# [1, None, 'mysql'] False None是False
# {0: 'mysql', 1: 'oralce'} False
#  True 元素本身是空的，那么返回True
# [] True 元素本身是空的，那么返回True
# {} True 元素本身是空的，那么返回True

any

接收一个可迭代参数。如果里面有一个True的元素，那么返回值就是True，所有元素都是False则返回False，类似逻辑“或”。如果可迭代参数本身为空，那么返回False。

f = list()
f.append([1, 0, "mysql"])
f.append([1, "", "mysql"])
f.append([1, None, "mysql"])
f.append({0: "mysql", 1: "oralce"})
f.append("")
f.append([])
f.append({})for i in f:print(i, any(i))pass# [1, 0, 'mysql'] True
# [1, '', 'mysql'] True
# [1, None, 'mysql'] True
# {0: 'mysql', 1: 'oralce'} True
#  False   元素本身是空的，那么返回False
# [] False 元素本身是空的，那么返回False
# {} False 元素本身是空的，那么返回False

bin、oct、hex

转换为二进制、八进制、十六进制

print(bin(17), oct(17), hex(17))
# 0b10001 0o21 0x11

bool

判断布尔类型。只需要记住什么是False，除此之外都是True。

False本身、数字0、各类空值（None、""、[]、{}）是False。

# 以下都是False
print(bool(False))
print(bool(0))
print(bool(None))
print(bool(""))
print(bool([]))
print(bool({}))

bytes

将字符串转换为字节，可以用于存储和网络传输。用什么编码，就用什么解码。

s1 = '你好'
# unicode编码每个字符3个字节 b'\xe4\xbd\xa0\xe5\xa5\xbd'
print(bytes(s1, encoding='utf-8'))
print(bytes(s1, encoding='utf-8').decode(encoding='utf-8'))
# gbk编码每个字符2个字节 b'\xc4\xe3\xba\xc3'
print(bytes(s1, encoding='gbk'))
print(bytes(s1, encoding='gbk').decode(encoding='gbk'))

chr、ord

chr传入数字，转换为对应的字符。ord与chr相反的操作，入参是字符，返回的是字符对应的数字。

# 0,A,a
print(chr(48), chr(65), chr(97), sep=',')
print(chr(0x30), chr(0x41), chr(0x61), sep=',')
# 48,65,97,36,27721
print(ord('0'), ord('A'), ord('a'), ord('$'), ord('汉'), sep=',')

dir

打印内置方法。

print(dir(all))
# ['__call__', '__class__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__name__', '__ne__', '__new__', '__qualname__', '__reduce__', '__reduce_ex__', '__repr__', '__self__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__text_signature__']

divmod

x, y = divmod(37, 5)
print(x, y)  # 商7 余2

enumerate

enumerate 接收一个可迭代的参数，返回一个迭代器，迭代器每个元素是索引位置和元素组成的元组。可以再多传入一个参数，指定索引位置的起始值。这样可以直接获取到迭代器元素的索引位置，这是推荐使用的办法

# enumerate 接收一个可迭代的参数，返回一个迭代器，每个元素是索引位置和元素
# 可以再多传入一个参数，指定索引位置的起始值
# 这样可以直接获取到迭代器元素的索引位置，这是推荐使用的办法
a = ['mysql', 'oracle', 'db2']
e = list(enumerate(a))
print(e)
# [(0, 'mysql'), (1, 'oracle'), (2, 'db2')]
for i, item in enumerate(a):print(i, item)pass
# 0 mysql
# 1 oracle
# 2 db2
for i, item in enumerate(a, 7):print(i, item)pass
# 7 mysql
# 8 oracle
# 9 db2

eval

eval的一大用处是提取字符串为某个数据类型。比如，将字符串提取成字典。

dic = {'os': 'linux', 'db': 'mysql'}
dic_str = str(dic)
d = eval(dic_str)

eval的另一个用处是直接计算字符串形式表达式的值。

express = '1+2*3-8/2'
print(eval(express))  # 3.0

hash

计算hash值。可hash的是不可变的数据类型。不可hash的是可变的数据类型。

s = 'mysql'
print(hash(s))  # -5554907091058110952
print(hash(s))  # -5554907091058110952
print(hash(s))  # -5554907091058110952
s = 'oracle'
print(hash(s))  # 6847068001075588286

help

打印方法的使用方法。我们打印all的使用发放看看。

print(help(all))
# Help on built-in function all in module builtins:
# 
# all(iterable, /)
#     Return True if bool(x) is True for all values x in the iterable.
#     
#     If the iterable is empty, return True.
# 
# None

globals、locals

globals打印全局变量。locals打印当前级别的局部变量。

os = 'linux'def test():db = 'mysql'print(globals())print(locals())passtest()
# {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x0000000000640940>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': 'D:/dev/basic/day16-built-in.py', '__cached__': None, 'os': 'linux', 'test': <function test at 0x00000000006251F0>}
# {'db': 'mysql'}

max、min、sorted

字面意思，最大值、最小值、排序。

max、min、sorted的高级用法。可以自己指定比较大小的规则。

首先，了解max和min的比较大小逻辑。遍历传入的可迭代参数，逐个比较大小，得到最值。

其次，了解比较大小逻辑。数字比较大小。可迭代的元素，逐个迭代比较大小，比如字符串按照字符串的编码规则比较大小，比如元组先比较第一个元素，比较不出大小再比较下一个位置的元素。

最后，max和min的可选参数key。key可以指定一个取数逻辑，也就是被比较的是什么，也就是这个key取出的数去比较大小。比如，我们可以指定长度大的字符串大。也可以指定个位数字大的数字大。也可以指定比较的是字典中的年龄age。等等……

排序函数sorted本质是比较大小，用法类似。

s = ['mysql', 'oracle', 'db2', 'database']
# 字符串比较大小，逐个比较字符的编码大小
# 最大的是oracle，最小的是database
# 排序按照字母序 ['database', 'db2', 'mysql', 'oracle']
print(max(s))
print(min(s))
print(sorted(s))
# 指定长度大的字符串大
# 最大的是database，最小的是db2
# 排序按照长度排序 ['db2', 'mysql', 'oracle', 'database']
print(max(s, key=lambda x: len(x)))
print(min(s, key=lambda x: len(x)))
print(sorted(s, key=lambda x: len(x)))# 元组类似，先比较第一个元素，相等再比较后面的元素
server = [('linux', 'mysql'),('linux', 'oracle'),('aix', 'oracle'),
]
print(max(server))n = [1213, 345, 232, 39]
# 数字最大1213，最小39，排序[39, 232, 345, 1213]
print(max(n))
print(min(n))
print(sorted(n))
# 个位数大的数字大，最大39，最小232，排序[232, 1213, 345, 39]
print(max(n, key=lambda x: x % 10))
print(min(n, key=lambda x: x % 10))
print(sorted(n, key=lambda x: x % 10))p = [{'name': 'Able', 'age': 18},{'name': 'Fox', 'age': 298},{'name': 'Easy', 'age': 17},{'name': 'Dog', 'age': 36},
]
# 找出年龄最大的人的名字# 先找出年龄最大的人的元素 {'name': 'Fox', 'age': 298}
# 先找出年龄最小的人的元素 {'name': 'Easy', 'age': 17}
print(max(p, key=lambda x: x['age']))
print(min(p, key=lambda x: x['age']))
# 再在年龄最大的人的元素里面取出名字，Fox
# 再在年龄最大的人的元素里面取出名字，Easy
print(max(p, key=lambda x: x['age'])['name'])
print(min(p, key=lambda x: x['age'])['name'])
# 按照年龄排序
# [
# {'name': 'Easy', 'age': 17},
# {'name': 'Able', 'age': 18},
# {'name': 'Dog', 'age': 36},
# {'name': 'Fox', 'age': 298}
# ]
print(sorted(p, key=lambda x: x['age']))
# 按照姓名排序
# [
# {'name': 'Able', 'age': 18},
# {'name': 'Dog', 'age': 36},
# {'name': 'Easy', 'age': 17},
# {'name': 'Fox', 'age': 298}
# ]
print(sorted(p, key=lambda x: x['name']))

 zip

拉链？zip接收多个可迭代的参数，返回一个迭代器。返回迭代器的每个元素是元组，第n个元组的元素是入参的迭代器的第那个元素组成的。好绕啊！！！看例子吧。

a = ['mysql', 'linux', 'oracle']
print(list(zip(*a)))
# [('m', 'l', 'o'), ('y', 'i', 'r'), ('s', 'n', 'a'), ('q', 'u', 'c'), ('l', 'x', 'l')]li = ['aa', 'bb']
tu = (11, 22, 33,)
print(list(zip(li, tu)))
# [('aa', 11), ('bb', 22)]p = {'name': 'Kevin','age': 29,'gender': None
}print(list(zip(p.keys(), p.values())))
# [('name', 'Kevin'), ('age', 29), ('gender', None)]

pow

pow，数学计算的乘方，可选参数可以取余数。

print(pow(2, 10))  # 2**10=1024
print(pow(3, 3))  # 3**3=27
print(pow(3, 3, 2))  # 3**3%2=1

reversed

字面意思，将序列入参反转。但是这个对字符串似乎不行，所以字符串反转，还是考虑使用切片方式，将切片的步长设置为-1。

x = ['mysql', 'oracle', 'db2']
# ['db2', 'oracle', 'mysql']
print(list(reversed(x)))s = 'Kevin'
# 没有搞懂为什么reversed不能直接将字符串反转
# #这个不能反转，得到的是 <reversed object at 0x0000000002423A00>
print(str(reversed(s)))
for i in reversed(s):print(i)pass
# 如果要字符串反转，考虑使用切片,步长为-1，得到niveK
sr = s[::-1]
print(sr)

round

round数学上的四舍五入，默认保留到整数，可选保留几位小数。

# 3 和 3.1416
print(round(3.1415926))
print(round(3.1415926, 4))

slice

字面意思，切片，可以定义切片的方式。

s = 'Oracle'
db = ['debian', 'ubuntu', 'centos', 'redhat', 'suse', 'kali']# 定义一个切片,取3到5的切片
sl = slice(3, 6)
# cle
print(s[sl])
# ['redhat', 'suse', 'kali']
print(db[sl])# 定义一个切片，从头到尾，步长为-1，实际上就是反转
s_reversed = slice(None, None, -1)
# elcarO
print(s[s_reversed])
# ['kali', 'suse', 'redhat', 'centos', 'ubuntu', 'debian']
print(db[s_reversed])

type

type函数返回一个变量的类型。对于int、str、tuple、list、dict、set等内置类型推荐使用type。获取的结果用is和类型名做判断。

对于对象，推荐使用isinstance，这个暂时还没有研究，isinstance考虑了子类继承的情况。

x = '256'if type(x) is str:n = int(x) + 1print(n)pass