Python基礎12-常用的內置函數

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())
    pass


test()
# {'__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) + 1
    print(n)
    pass