python內置函式

1. 數學運算

1. abs()

回傳數字的絕對值，引數可以是整數、浮點數或任何實作了 abs() 的物件，如果引數是一個復數，則回傳它的模，

# 引數可以是整數
print(f'{ abs(123) = }')
print(f'{ abs(-123) = }')
print(f'{ abs(0) = }')
# 引數可以是浮點數
print(f'{ abs(1.23) = }')
print(f'{ abs(-1.23) = }')
print(f'{ abs(0.0) = }')
# 引數可以任何實作了 __abs__() 的物件，
class TestClass:
    def __abs__(self):
        return 123
print(f'{ abs(TestClass()) = }')
# 如果引數是一個復數，則回傳它的模
# 復數是實數+虛數
# 注意點：復數的絕對值回傳值一定是浮點數
print(f'{ abs(3+4j) = }')
print(f'{ abs(-3-4j) = }')

2. pow()

格式：pow(base, exp[, mod])
回傳值：int

回傳 base 的 exp 次冪；如果 mod 存在，則回傳 base 的 exp 次冪對 mod 取余（比 pow(base, exp) % mod 更高效），兩引數形式 pow(base, exp) 等價于乘方運算子: base**exp

# 回傳 base 的 exp 次冪；
print(f'{ pow(2, 3) = }')
print(f'{ pow(10, 2) = }')
# 兩引數形式 pow(base, exp) 等價于乘方運算子: base**exp，
print(f'{ 2**3 = }')
print(f'{ 10**2 = }')
# 如果 mod 存在，則回傳 base 的 exp 次冪對 mod 取余（比 pow(base, exp) % mod 更高效）

# 引數必須具有數值型別， 對于混用的運算元型別，則將應用雙目算術運算子的型別強制轉換規則， 對于 int 運算元，結果具有與運算元相同的型別（強制轉換后），除非第二個引數為負值；在這種情況下，所有引數將被轉換為浮點數并輸出浮點數結果， 例如，10**2 回傳 100，但 10**-2 回傳 0.01，

# 引數必須具有數值型別
# print(f'{ pow(2, "3") = }')
# 對于混用的運算元型別，則將應用雙目算術運算子的型別強制轉換規則，
print(f'{ pow(2.0, 3) = }')
# 對于 int 運算元，結果具有與運算元相同的型別（強制轉換后），除非第二個引數為負值；在這種情況下，所有引數將被轉換為浮點數并輸出浮點數結果，
print(f'{ pow(2, 3) = }')
print(f'{ pow(2, -3) = }')

# 對于 int 運算元 base 和 exp，如果給出 mod，則 mod 必須為整數型別并且 mod 必須不為零， 
# 如果給出 mod 并且 exp 為負值，則 base 必須相對于 mod 不可整除， 在這種情況下，將會回傳 pow(inv_base, -exp, mod)，其中 inv_base 為 base 的倒數對 mod 取余，

# print(f'{ pow(2, 3, 0) = }')

# 下面的例子是 38 的倒數對 97 取余:
# >>> pow(38, -1, mod=97)
# 23
# >>> 23 * 38 % 97 == 1
# True

3. divmod()

格式：divmod(a, b)
回傳值：一個包含商和余數的元組

它將兩個（非復數）數字作為實參，并在執行整數除法時回傳一對商和余數，對于混合運算元型別，適用雙目算術運算子的規則，對于整數，結果和 (a // b, a % b) 一致，對于浮點數，結果是 (q, a % b) ，q 通常是 math.floor(a / b) 但可能會比 1 小，在任何情況下， q * b + a % b 和 a 基本相等；如果 a % b 非零，它的符號和 b 一樣，并且 0 <= abs(a % b) < abs(b) ，

# 對于整數，結果和 (a // b, a % b) 一致，
a = 20  # 被除數
b = 3   # 除數
print(f'{ divmod(a, b) = }')#(6,2)
print(f'{ (a//b, a%b) = }')
# 對于浮點數，結果是 (q, a % b) ，q 通常是 math.floor(a / b)
import math
a = 2.0  # 被除數
b = 0.3  # 除數
q = math.floor(a/b)
print(f'{ divmod(a, b) = }')
print(f'{ (q, a%b) = }')
# 在任何情況下， q * b + a % b 和 a 基本相等

4. max()

格式：max(iterable, *[, key, default])
max(arg1, arg2, *args[, key])
回傳值：可迭代物件中最大的元素，或者回傳兩個及以上實參中最大的序列，

如果只提供了一個位置引數，它必須是非空 iterable（單序列），回傳可迭代物件中最大的元素；如果提供了兩個及以上的位置引數（多序列），則回傳最大的位置引數（序列），
單序列入參，回傳序列中最大的一個數值，多序列入參, 按索引順序，逐一對比各序列的當前索引位的 “值”，直到遇見最大值立即停止對比，并回傳最大值所在的序列（也就是說，多序列入參，回傳值依舊是一個序列，而不是數值）

>>> max([1,2,3])
3
>>> max(1,2,4)
4
>>> max(-1, -0.5, 0)
0
>>> max((1,2,3))
3
>>> max([2,4], [3,6])
[3, 6]
>>> max([2,4], [1,5])
[2, 4]
>>> max([2,4], [1,5], [3,1], [2,5],[0,7])
[3, 1]
>>> max((1,2,3), (3,3,0))
(3, 3, 0)
>>> max((1,-1,0), (True,False,0)) #布爾喔
(True, False, 0)
>>> max((1,-1,0), (True,False,2,0),(1, 0, 0, 2))
(True, False, 2, 0)
>>> max((1,-1,0), (True,),(1,))
(1, -1, 0)
>>> max((-1,-1,0), (True,),(1,))
(True,)
>>> max([1,3,2],3,4) #非法入參
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: '>' not supported between instances of 'int' and 'list'
>>> max((1,2,3), [2,4,1]) #非法入參

有兩個可選只能用關鍵字的實參，key 實參指定排序函式用的引數，如傳給 list.sort() 的，default 實參是當可迭代物件為空時回傳的值，如果可迭代物件為空，并且沒有給 default ，則會觸發 ValueError，
如果有多個最大元素，則此函式將回傳第一個找到的，

print(max([],default=False)) #空表觸發value error，設定default則不會，

# 給key傳參
print(f'{ max([3, 9, -20, 15], key=abs) = }')
# 自定義函式作為key
import math
def fun1(x):
    return math.sin(x)
print(max([1,2,3,4,5,6],key=fun1))
'''
2
'''
# 如果有多個最大元素，則此函式將回傳第一個找到的
print(f'{ max([3, 9, -20, 15, 20], key=abs) = }')

5. min()

格式：min(iterable, *[, key, default])
min(arg1, arg2, *args[, key])
回傳值：理同max()

6. round()

格式：round(number[, ndigits])
回傳值：回傳 number 舍入到小數點后 ndigits 位精度的值，如果 ndigits 被省略或為 None，則回傳最接近輸入值的整數，

round()內置函式不是使用四舍五入的規則，而是根據距離遠近的規則來取近似值，
即如果小于等于4則舍去，如果大于等于6則進入，如果5后面還有有效數字，則進1，如果5后面沒有有效數字，則選擇偶數，

numbers = [-0.5, 0.5, 1.5, 2.5, 3.5]
for num in numbers:
    print(f'{ num = } { round(num) = }')
print(f'{ round(0.125, 2) = }')
print(f'{ round(0.51) = }')
print(f'{ round(0.1251, 2) = }')

'''
 num = -0.5  round(num) = 0
 num = 0.5  round(num) = 0
 num = 1.5  round(num) = 2
 num = 2.5  round(num) = 2
 num = 3.5  round(num) = 4
 round(0.115, 2) = 0.12
 round(0.51) = 1
 round(0.1251, 2) = 0.13
'''

任何整數值都可作為有效的 ndigits (正數、零或負數)，

print(f'{ round(123.456, 2) = }')
print(f'{ round(123.456, 0) = }')
print(f'{ round(123.456, -2) = }')
print(f'{ round(163.456, -2) = }')

'''
 round(123.456, 2) = 123.46
 round(123.456, 0) = 123.0
 round(123.456, -2) = 100.0
 round(163.456, -2) = 200.0
'''

對浮點數執行 round() 的行為可能會令人驚訝：例如，round(2.675, 2) 將給出 2.67 而不是期望的 2.68，這不算是程式錯誤：這一結果是由于大多數十進制小數實際上都不能以浮點數精確地表示，

7. sum()

格式：sum(iterable, /, start=0)
回傳值：從 start 開始自左向右對 iterable 的項求和并回傳總計值， iterable 的項通常為數字，而 start 值則不允許為字串，

print(sum([1,2,3],start=10)) #計算總和后再加10
#16

8. sorted()

格式： sorted(iterable, *, key=None, reverse=False)
回傳值：根據 iterable 中的項回傳一個新的已排序串列，

具有兩個可選引數，它們都必須指定為關鍵字引數，reverse=False reverse 次序顛倒在這里表示，是否倒序排序，默認為False，表示默認升序排序.

print(f'{ sorted(["b", "c", "a"]) = }')
print(f'{ sorted((2, 3, 1)) = }')
print(f'{ sorted("bca") = }')
'''
sorted(["b", "c", "a"]) = ['a', 'b', 'c']
sorted((2, 3, 1)) = [1, 2, 3]
sorted("bca") = ['a', 'b', 'c']
'''

key 指定帶有單個引數的函式，用于從 iterable 的每個元素中提取用于比較的鍵 (例如 key=str.lower)，默認值為 None (直接比較元素)，

student_scores = [('A', 99), ('B', 114), ('C', 86)]
def get_key(elem):
    return elem[1]
print(f'{ sorted(student_scores, key=get_key) = }')
print(f'{ sorted(student_scores, key=lambda elem: elem[1]) = }')
# [('C', 86), ('A', 99), ('B', 114)]
# [('C', 86), ('A', 99), ('B', 114)]

2. 輸入輸出

9. input()

格式： input([prompt])
回傳值： str

如果存在 prompt 實參，則將其寫入標準輸出，末尾不帶換行符，該函式從輸入中讀取一行，將其轉換為字串（除了末尾的換行符）并回傳，

prompt = '請輸入內容:'
line = input(prompt)
print(f'{ line=  } { type(line) = }')

# 請輸入內容:today
#  line=  'today'  type(line) = <class 'str'>

input() 函式的引數只能為單個字串，常用int()將輸入的字串轉為整數型別，

10. print()

格式： print(*objects, sep=' ', end='\n', file=sys.stdout, flush=False)
回傳值：None

引數說明：

引數	型別	說明
objects	str等	可以一次輸出多個物件，輸出多個物件時，需要用 , 分隔，
sep	str	用來間隔多個物件，默認值是一個空格，
end	str	用來設定以什么結尾，默認值是換行符 \n，可以換成其他字串，
file		要寫入的檔案物件，
flush	bool	輸出是否被快取通常決定于 file，但如果 flush 關鍵字引數為 True，流會被強制重繪，

x1=[x**2 for x in range(0,6)]
for x in x1:
    print(x,end="+")

# 0+1+4+9+16+25+

3. 檔案操作

11.open()

格式： open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)
回傳值： file object,如果無法打開會會拋出 OSError，

open() 函式用于打開一個檔案，并回傳檔案物件，在對檔案進行處理程序都需要使用到這個函式，

引數說明：

引數	型別	說明
file	str	必需，檔案路徑（相對或者絕對路徑）
mode	str	可選，指定檔案打開模式
buffering	int	可選，設定緩沖
encoding	str	檔案編碼方式，一般使用utf-8
errors	str	可選，指定如何處理錯誤
newline		區分換行符
closefd		傳入的file引數型別
opener

mode可選引數：

引數	描述
t	文本模式（默認）
x	寫模式，新建一個檔案，如果該檔案已存在則會報錯，
b	二進制模式
a	追加寫，若檔案已存在，檔案指標將會放在檔案的結尾；新的內容將會被寫入到已有內容之后，若檔案不存在，創建新檔案寫入，
r	打開并讀取文本，檔案的指標將會放在檔案的開頭，（默認）與rt同義
w	打開檔案只用于寫入（原有內容會被洗掉），若檔案不存在則創建新檔案，
+	打開一個檔案進行更新(可讀可寫)，

s=open(r"C:\Users\zzy\Desktop\test.txt",
       "r",
       encoding="utf-8")

def fun1():#這個函式用來統計文本中的高頻詞，回傳一個“詞-頻”對的字典
    counts={}
    x = jieba.lcut(s.read())
    for word in x:
        if len(word)==1:
            pass
        else:
            counts[word]=counts.get(word,0)+1
    items=list(counts.items())
    items.sort(key=lambda x:x[1],reverse=True)
    return dict(items)

4. 進制轉換

12. bin()

格式：
回傳值： str

將一個整數轉變為一個前綴為“0b”的二進制字串，

13. hex()

格式：
回傳值： str

將整數轉換為以“0x”為前綴的小寫十六進制字串，

14. oct()

格式：
回傳值： str

將一個整數轉變為一個前綴為“0o”的八進制字串，

5. unicode字符

15. chr()

格式：
回傳值：

回傳 Unicode 碼位為整數 i 的字符的字串格式，

print(chr(36530)) #躲

16. ord()

格式： ord(c)
回傳值：

對表示單個 Unicode 字符的字串，回傳代表它 Unicode 碼點的整數，

print(ord("躲")) #36530

6. 型別轉換

17. bool()

格式： class bool([x])
回傳值：回傳一個布林值，True 或者 False，

x 使用標準的真值測驗程序來轉換，如果 x 是假的或者被省略，回傳 False；其他情況回傳 True，bool 類是 int 的子類（參見數字型別---int, float, complex），其他類不能繼承自它，它只有 False 和 True 兩個實體（參見布林值），

print(f'{ bool() = }')
print(f'{ bool(None) = }')
print(f'{ bool(False) = }')

from decimal import Decimal
from fractions import Fraction
print(f'{ bool(0) = }')
print(f'{ bool(0.0) = }')
print(f'{ bool(0j) = }')
print(f'{ bool(Decimal(0)) = }')
print(f'{ bool(Fraction(0, 1)) = }')
print('-'*20)
print(f'{ bool("") = }')
print(f'{ bool(()) = }')
print(f'{ bool([]) = }')
print(f'{ bool({}) = }')
print(f'{ bool(set()) = }')
print(f'{ bool(range(0)) = }')
# 如果 x 是假的或者被省略，回傳 False；其他情況回傳 True，
print(f'{ bool(123) = }')
print(f'{ bool(1.23) = }')
print(f'{ bool("test") = }')

# bool() = False
# bool(None) = False
# bool(False) = False
# bool(0) = False
# bool(0.0) = False
# bool(0j) = False
# bool(Decimal(0)) = False
# bool(Fraction(0, 1)) = False
# --------------------
# bool("") = False
# bool(()) = False
# bool([]) = False
# bool({}) = False
# bool(set()) = False
# bool(range(0)) = False
# bool(123) = True
# bool(1.23) = True
# bool("test") = True

18. int()

格式： int(*x*,base=10)
回傳值：回傳一個基于數字或字串x構造的整數int物件，或者在未給出引數時回傳 0，對浮點數向下取整，

這個函式按照base進制對數x進行解釋，回傳一個使用數字或字串生成的整數int物件，無實參回傳0，
其中x為數字或字串，base為進制，取值范圍為[2，36]和0，
一個進制為n的整數包含0到n-1的整數，其中a-z(A-Z)表示10到35，
進制為0將會按照代碼字面的前綴進行解釋，結果是2、8、10、16中的一個，

要清楚的一點是，在python中帶有前綴的數字，例如0xa，0o12，0b1010它們的型別(type)都是int整數型別，
如果想知道它們十進制數值，可以直接print，或print(int(x))，也可以int(str(x),base=0)（？）.

對這個函式的使用，主要分為三種情況：

x為int型別：無論帶不帶前綴，這個數的進制已經清楚，該函式無法對一個進制清楚的非字串型別進行轉換（啟用base關鍵字），
x為str字串型別：
- 帶前綴：表明這個數的進制已經清楚，base只能等于其前綴或0，
- 不帶前綴：根據用法自由發揮，注意沒有前綴且令base=0的話應注意x其形式，比如int("010",base=0)是非法的，因為解釋器認為x是十進制數，但x形式是錯誤的，
x為byte型別：暫時空缺，

x=int(156,base=2) #報錯
x=int(0x156,base=0) #報錯

x1="0101" #字串
y1=int(x1,base=2) # 結果為整數5
y2=int(x1,base=8) # 結果為整數65
y3=int(x1,base=16) # 結果為整數257
y4=int(x1,base=35) # 結果為整數1226

x2="0xa5f1"
y5=int(x,base=16) # 結果為整數42481
y6=int(x,base=0) # 結果為整數42481

19. float()

格式： class float([x])
回傳值：回傳從數字或字串 x 生成的浮點數，

如果實參是字串，則它必須是包含十進制數字的字串，字串前面可以有符號，之前也可以有空格，可選的符號有 '+' 和 '-' ； '+' 對創建的值沒有影響，

print(f'{ float("1.23") = }')
print(f'{ float("+1.23") = }')
print(f'{ float("-1.23") = }')
print(f'{ float("    -1.23") = }')

'''
float("1.23") = 1.23
float("+1.23") = 1.23
float("-1.23") = -1.23
float("    -1.23") = -1.23
'''

如果實參是整數或浮點數，則回傳具有相同值（在 Python 浮點精度范圍內）的浮點數，如果實參在 Python 浮點精度范圍外，則會觸發 OverflowError，
如果沒有實參，則回傳 0.0

# >>> float('+1.23')
# 1.23
# >>> float('   -12345\n')
# -12345.0
# >>> float('1e-003')
# 0.001
# >>> float('+1E6')
# 1000000.0
# >>> float('-Infinity')
# -inf

20. range()

格式：

  class range(stop)
  class range(start, stop[, step])

回傳值：range 型別

range 構造器的引數必須為整數，如果省略 step 引數，其默認值為 1，如果省略 start 引數，其默認值為 0，如果 step 為零則會引發 ValueError，

如果 step 為正值，確定 range 內容的公式為 r[i] = start + step * i 其中 i >= 0 且 r[i] < stop，

如果 step 為負值，確定 range 內容的公式仍然為 r[i] = start + step * i，但限制條件改為 i >= 0 且 r[i] > stop.

如果 r[0] 不符合值的限制條件，則該 range 物件為空， range 物件確實支持負索引，但是會將其解讀為從正索引所確定的序列的末尾開始索引，

>>> list(range(10))
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> list(range(1, 11))
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> list(range(0, 30, 5))
[0, 5, 10, 15, 20, 25]
>>> list(range(0, 10, 3))
[0, 3, 6, 9]
>>> list(range(0, -10, -1))
[0, -1, -2, -3, -4, -5, -6, -7, -8, -9]
>>> list(range(0))
[]
>>> list(range(1, 0))
[]

21. list()

格式：
```
  class list([iterable])
```
回傳值：構造器將構造一個串列，其中的項與 iterable 中的項具有相同的的值與順序， iterable 可以是序列、支持迭代的容器或其它可迭代物件，

::: tip 創建串列的幾種方式

方括號直接賦值：

 x=[]
 y=[1,"one",("jack")]

串列推導式:

[x**2 for x in range(0,10,2)]

型別構造器list()函式：

x=list("abcdefg")
x1=list((1,2,3))

:::
如果沒有給出引數，構造器將創建一個空串列 []，

22. dict()

格式：

  class dict(**kwarg)
  class dict(mapping, **kwarg)
  class dict(iterable, **kwarg)

引數說明：
- **kwargs -- 關鍵字，
- mapping -- 元素的容器，映射型別（Mapping Types）是一種關聯式的容器型別，它存盤了物件與物件之間的映射關系，
- iterable -- 可迭代物件，
回傳值：回傳一個新的字典，基于可選的位置引數和可能為空的關鍵字引數集來初始化，
::: tip 創建字典的幾種方式

大括號直接賦值：

dict1 = {}
dict1['chinese'] = 100
dict1['math'] = 80

dict1 = {'firstname':'ma', 'lastname':'yun'}

字典推導式:

def fun(x):
 return x**3
y={x:fun(x) for x in range(0,6)}
# {0: 0, 1: 1, 2: 8, 3: 27, 4: 64, 5: 125}

型別構造器dict()函式：

x=dict({"one": 1, "two": 2, "three": 3})
print(x)

:::

如果給出一個位置引數并且其屬于映射物件，將創建一個具有與映射物件相同鍵值對的字典，

print(f'{ dict({"one": 1, "two": 2, "three": 3}) = }')

否則的話，位置引數必須為一個 iterable 物件，
該可迭代物件中的每一項本身必須為一個剛好包含兩個元素的可迭代物件，
每一項中的第一個物件將成為新字典的一個鍵，第二個物件將成為其對應的值，

x=dict([("one",1),("two",2)])
y=dict((["one",1],["two",2]))

如果一個鍵出現一次以上，該鍵的最后一個值將成為其在新字典中對應的值，
如果給出了關鍵字引數，則關鍵字引數及其值會被加入到基于位置引數創建的字典，
如果要加入的鍵已存在，來自關鍵字引數的值將替代來自位置引數的值，

print(f'{ dict(one=1, two=2, three=3) = }')
print(f'{ dict({"two": 2, "three": 3}, one=1) = }')
print(f'{ dict({"one": 11, "two": 2, "three": 3}, one=1) = }')

23. tuple()

格式： class tuple([iterable])
回傳值：構造器將構造一個元組，其中的項與 iterable 中的項具有相同的值與順序，
::: tip 構造元組的幾種方式

圓括號直接賦值：

x=(1,)#使用一個后綴的逗號來表示單元組
x=(1,2,3)#使用以逗號分隔的多個項

tuple()函式

print(f'{ tuple(["a", "b", "c"]) = }')
print(f'{ tuple(("a", "b", "c")) = }')
print(f'{ tuple(range(3)) = }')
print(f'{ tuple("abc") = }')

# tuple(["a", "b", "c"]) = ('a', 'b', 'c')
# tuple(("a", "b", "c")) = ('a', 'b', 'c')
# tuple(range(3)) = (0, 1, 2)
# tuple("abc") = ('a', 'b', 'c')

:::
注意決定生成元組的其實是逗號而不是圓括號，圓括號只是可選的，生成空元組或需要避免語法歧義的情況除外，例如，f(a, b, c) 是在呼叫函式時附帶三個引數，而 f((a, b, c)) 則是在呼叫函式時傳參三元組，

24. set()

格式： class set([iterable])
回傳值：回傳一個新的 set 或 frozenset 物件，其元素來自于 iterable，集合的元素必須為 hashable，要表示由集合物件構成的集合，所有的內層集合必須為 frozenset 物件，如果未指定 iterable，則將回傳一個新的空集合，

print(f'{ set(["a", "b", "c"]) = }')
print(f'{ set(["a", "b", "c", "a"]) = }')
print(f'{ set(("a", "b", "c")) = }')
print(f'{ set(range(3)) = }')
print(f'{ set("abc") = }')

# set(["a", "b", "c"]) = {'b', 'c', 'a'}
# set(["a", "b", "c", "a"]) = {'b', 'c', 'a'}
# set(("a", "b", "c")) = {'b', 'c', 'a'}
# set(range(3)) = {0, 1, 2}
# set("abc") = {'b', 'c', 'a'}

25. str()

格式：

  class str(object='')
  class str(object=b'', encoding='utf-8', errors='strict')

回傳值：回傳 object的字串版本，如果未提供 object 則回傳空字串，

如果 encoding 或 errors 均未給出，str(object) 回傳 object.str()，這是 object 的“非正式”或格式良好的字串表示，對于字串物件，這是該字串本身，如果 object 沒有 str() 方法，則 str() 將回退為回傳 repr(object)，

print(f'{ str(123) = }')
print(f'{ str([1, 2, 3]) = }')
print(f'{ str(range(3)) = }')
print(f'{ str("test") = }')

# str(123) = '123'
# str([1, 2, 3]) = '[1, 2, 3]'
# str(range(3)) = 'range(0, 3)'
# str("test") = 'test'

26. complex()

格式：class complex([real[, imag]])
回傳值：回傳值為real + imag*1j的復數，或將字串或數字轉換為復數，

如果第一個形參是字串，則它被解釋為一個復數，并且函式呼叫時必須沒有第二個形參，第二個形參不能是字串，

print(f'{ complex("1+2j") = }')
# complex("1+2j") = (1+2j)

每個實參都可以是任意的數值型別（包括復數），如果省略了 imag，則默認值為零，建構式會像 int 和 float 一樣進行數值轉換，如果兩個實參都省略，則回傳 0j，

print(f'{ complex(1, 2) = }')
print(f'{ complex(1, -2) = }')
print(f'{ complex(1.2, 3.4) = }')
print(f'{ complex(1+2j, 1) = }')
print(f'{ complex(1+2j, 1+2j) = }')

'''
complex(1, 2) = (1+2j)
complex(1, -2) = (1-2j)
complex(1.2, 3.4) = (1.2+3.4j)
complex(1+2j, 1) = (1+3j)
 complex(1+2j, 1+2j) = (-1+3j)
'''

27. bytearray()

class bytearray([source[, encoding[, errors]]])
回傳一個新的 bytes 陣列， bytearray 類是一個可變序列，包含范圍為 0 <= x < 256 的整數，它有可變序列大部分常見的方法，見可變序列型別的描述；同時有 bytes 型別的大部分方法，參見 bytes 和 bytearray 操作，

回傳一個新的 bytes 陣列，
可選形參 source 可以用不同的方式來初始化陣列：

如果是一個 string，您必須提供 encoding 引數（errors 引數仍是可選的）；bytearray() 會使用 str.encode() 方法來將 string 轉變成 bytes，
print(f'{ bytearray("test", "utf-8") = }')
print(f'{ type(bytearray("test", "utf-8")) = }')
print(f'{ "test".encode("utf-8") = }')
print(f'{ type("test".encode("utf-8")) = }')
print('-------------')
print(f'{ bytearray("test", "utf-8", "strict") = }')
print(f'{ "test".encode("utf-8", "strict") = }')

如果是一個 integer，會初始化大小為該數字的陣列，并使用 null 位元組填充，
print('--------------')
print(f'{ bytearray(3) = }')

如果是一個遵循緩沖區介面的物件，該物件的只讀緩沖區將被用來初始化位元組陣列，
print('------------')
bytes_object = "test".encode("utf-8")
print(f'{ bytearray(bytes_object) = }')

如果是一個 iterable 可迭代物件，它的元素的范圍必須是 0 <= x < 256 的整數，它會被用作陣列的初始內容，
print('--------------')
print(f'{ bytearray([10, 65, 97, 98, 99]) = }')
print(f'{ bytearray([256, 257]) = }')

如果沒有實參，則創建大小為 0 的陣列，
print('-----------------')
print(f'{ bytearray() = }')

另見二進制序列型別 --- bytes, bytearray, memoryview 和 bytearray 物件

28. bytes()

class bytes([source[, encoding[, errors]]])
回傳一個新的“bytes”物件，是一個不可變序列，包含范圍為 0 <= x < 256 的整數，bytes 是 bytearray 的不可變版本 - 它有其中不改變序列的方法和相同的索引、切片操作，

因此，建構式的實參和 bytearray() 相同，

回傳一個新的“bytes”物件，
建構式的實參和 bytearray() 相同，
如果source引數是一個字串，必須提供encoding引數
print(f'{ bytes("test", "utf-8") = }')
print(f'{ type(bytes("test", "utf-8")) = }')
如果source是一個整型，會初始化大小為該數字的陣列，并使用null位元組填充
print('--------')
print(f'{ bytes(3) = }')
如果source是一個遵循緩沖區介面的物件，該物件的只讀快取區將被用來初始化位元組陣列
print('----------')
bytearray_object = bytearray('test', 'utf-8')
print(f'{ bytes(bytearray_object) = }')

如果source引數是一個iterable可迭代物件，它會被用作陣列的初始化內容
print('------')
print(f'{ bytes([65, 66, 67]) = }')
如果沒有實參，則創建大小為0的陣列
print('------')
print(f'{ bytes() = }')
位元組物件還可以用字面值創建，參見字串和位元組串字面值，

位元組物件還可以用字面值創建
print('---------')
print(f'{ bytes("test", "utf-8") = }')
print(f'{ b"test" = }')
print(f'{ type(b"test") = }')

另見二進制序列型別 --- bytes, bytearray, memoryview，bytes 物件和 bytes 和 bytearray 操作，

29. frozenset()

class set([iterable])
class frozenset([iterable])
回傳一個新的 set 或 frozenset 物件，其元素來自于 iterable，集合的元素必須為 hashable，要表示由集合物件構成的集合，所有的內層集合必須為 frozenset 物件，如果未指定 iterable，則將回傳一個新的空集合，

回傳一個新的 frozenset 物件，其元素來自于 iterable，
print(f'{ frozenset(["a", "b", "c"]) = }')
print(f'{ frozenset(["a", "b", "c", "a"]) = }')
print(f'{ frozenset(("a", "b", "c")) = }')
print(f'{ frozenset(range(3)) = }')
print(f'{ frozenset("abc") = }')
如果未指定 iterable，則將回傳一個新的空集合，
print('--------')
print(f'{ frozenset() = }')

集合可用多種方式來創建:

使用花括號內以逗號分隔元素的方式:

使用集合推導式:

使用型別構造器: set(), set('foobar'), set(['a', 'b', 'foo'])

30. memoryview()

class memoryview(obj)
創建一個參考 obj 的 memoryview， obj 必須支持緩沖區協議，支持緩沖區協議的內置物件包括 bytes 和 bytearray，

print(f'{ memoryview(b"abcdef") = }')
print(f'{ memoryview(bytes("abcdef", "utf-8")) = }')
print(f'{ memoryview(bytearray("abcdef", "utf-8")) = }')
print('-------')
print(f'{ hasattr(memoryview, "len") = }')
print(f'{ hasattr(memoryview, "getitem") = }')
print('-----------')
print(f'{ memoryview(b"abcdef")[0] = }')
print(f'{ memoryview(b"abcdef")[1] = }')
print('-----------')
print(f'{ memoryview(b"abcdef")[0:3] = }')
print(f'{ bytes(memoryview(b"abcdef")[0:3]) = }')
memoryview 具有元素的概念，即由原始物件 obj 所處理的基本記憶體單元，對于許多簡單型別例如 bytes 和 bytearray 來說，一個元素就是一個位元組，但是其他的型別例如 array.array 可能有更大的元素，

len(view) 與 tolist 的長度相等，如果 view.ndim = 0，則其長度為 1，如果 view.ndim = 1，則其長度等于 view 中元素的數量，對于更高的維度，其長度等于表示 view 的嵌套串列的長度， itemsize 屬性可向你給出單個元素所占的位元組數，

memoryview 支持通過切片和索引訪問其元素，一維切片的結果將是一個子視圖:

v = memoryview(b'abcefg')
v[1]
98
v[-1]
103
v[1:4]
<memory at 0x7f3ddc9f4350>
bytes(v[1:4])
b'bce'
如果 format 是一個來自于 struct 模塊的原生格式說明符，則也支持使用整數或由整數構成的元組進行索引，并回傳具有正確型別的單個元素，一維記憶體視圖可以使用一個整數或由一個整數構成的元組進行索引，多維記憶體視圖可以使用由恰好 ndim 個整數構成的元素進行索引，ndim 即其維度，零維記憶體視圖可以使用空元組進行索引，

這里是一個使用非位元組格式的例子:

import array
a = array.array('l', [-11111111, 22222222, -33333333, 44444444])
m = memoryview(a)
m[0]
-11111111
m[-1]
44444444
m[::2].tolist()
[-11111111, -33333333]
如果下層物件是可寫的，則記憶體視圖支持一維切片賦值，改變大小則不被允許:

data = https://www.cnblogs.com/zeroy610/p/bytearray(b'abcefg')
v = memoryview(data)
v.readonly
False
v[0] = ord(b'z')
data
bytearray(b'zbcefg')
v[1:4] = b'123'
data
bytearray(b'z123fg')
v[2:3] = b'spam'
Traceback (most recent call last):
File "", line 1, in
ValueError: memoryview assignment: lvalue and rvalue have different structures
v[2:6] = b'spam'
data
bytearray(b'z1spam')
由帶有格式符號 'B', 'b' 或 'c' 的可哈希（只讀）型別構成的一維記憶體視圖同樣是可哈希的，哈希定義為 hash(m) == hash(m.tobytes()):

v = memoryview(b'abcefg')
hash(v) == hash(b'abcefg')
True
hash(v[2:4]) == hash(b'ce')
True
hash(v[::-2]) == hash(b'abcefg'[::-2])
True
在 3.3 版更改: 一維記憶體視圖現在可以被切片，帶有格式符號 'B', 'b' 或 'c' 的一維記憶體視圖現在是可哈希的，

在 3.4 版更改: 記憶體視圖現在會自動注冊為 collections.abc.Sequence

在 3.5 版更改: 記憶體視圖現在可使用整數元組進行索引，

7. 格式化輸出

31. format

格式：format(value[, format_spec])
回傳值：將 value 轉換為 format_spec 控制的“格式化”表示，回傳字串，

format_spec 的解釋取決于 value 實參的型別，但是大多數內置型別使用標準格式化語法：格式規格迷你語言，

# format(value[, format_spec])
# 將 value 轉換為 format_spec 控制的“格式化”表示，format_spec 的解釋取決于 value 實參的型別，但是大多數內置型別使用標準格式化語法：格式規格迷你語言，
print(f'{ format("test", "<10") = }')
print(f'{ format("test", "^10") = }')
print(f'{ format("test", ">10") = }')
print('--------')
print(f'{ format(10, "b") = }')
print(f'{ format(10, "o") = }')
print(f'{ format(10, "d") = }')
print(f'{ format(10, "x") = }')
print('--------')
print(f'{ format(10, "#x") = }')
print(f'{ format(10, "#X") = }')
print('-------------')
print(f'{ format(1, "0>4") = }')
print(f'{ format(12, "0>4") = }')
print(f'{ format(123, "0>4") = }')
print(f'{ format(1234, "0>4") = }')
print('----------')
print(f'{ format(3.1415926, ".2f") = }')
print(f'{ format(0.967, ".2%") = }')

# format("test", "<10") = 'test      '
# format("test", "^10") = '   test   '
# format("test", ">10") = '      test'
# --------
# format(10, "b") = '1010'
# format(10, "o") = '12'
# format(10, "d") = '10'
# format(10, "x") = 'a'
# --------
# format(10, "#x") = '0xa'
# format(10, "#X") = '0XA'
# -------------
# format(1, "0>4") = '0001'
# format(12, "0>4") = '0012'
# format(123, "0>4") = '0123'
# format(1234, "0>4") = '1234'
# ----------
# format(3.1415926, ".2f") = '3.14'
# format(0.967, ".2%") = '96.70%'

格式控制符和字串的format方法詳見字串格式化輸出，

8. 可迭代物件、迭代器

32. all()

all(iterable)
如果 iterable 的所有元素均為真值（或可迭代物件為空）則回傳 True ，等價于:

def all(iterable):
for element in iterable:
if not element:
return False
return True
如果 iterable 的所有元素均為真值（或可迭代物件為空）則回傳 True ，
from decimal import Decimal
from fractions import Fraction
print(f'{ all([True, 123, 1.23, "test"]) = }')
print(f'{ all([(1, 2), [1, 2], {"name": "小明"}, {"a", "b"}, range(3)]) = }')
print(f'{ all([1+2j, Decimal("1.23"), Fraction(1, 2)]) = }')
print(f'{ all([]) = }')
print(f'{ all(()) = }')
如果可迭代物件不為空，只要有一個元素為假值，則回傳False
print(f'{ all([True, 123, 1.23, ""]) = }')
print(f'{ all([(), [1, 2], {"name": "小明"}, {"a", "b"}, range(3)]) = }')
print(f'{ all([1+2j, Decimal("0.0"), Fraction(1, 2)]) = }')

33. any()

any(iterable)
如果 iterable 的任一元素為真值則回傳 True，如果可迭代物件為空，回傳 False，等價于:

def any(iterable):
for element in iterable:
if element:
return True
return False
from decimal import Decimal
from fractions import Fraction
如果 iterable 的任一元素為真值則回傳 True，
iterable = [None, False, 0, 0.0, 0j, Decimal("0.0"), Fraction(0, 1), "test", (), [], {}, set(), range(0)]
print(f'{ any(iterable) = }')
如果可迭代物件為空，回傳 False，
print(f'{ any([]) = }')
print(f'{ any(()) = }')
如果可迭代物件不為空，并且iterable的所有元素都為假值，則回傳False
iterable = [None, False, 0, 0.0, 0j, Decimal("0.0"), Fraction(0, 1), "", (), [], {}, set(), range(0)]
print(f'{ any(iterable) = }')

34. enumerate()

enumerate(iterable, start=0)
列舉
enumerate
回傳一個列舉物件，iterable 必須是一個序列，或 iterator，或其他支持迭代的物件， enumerate() 回傳的迭代器的 next() 方法回傳一個元組，里面包含一個計數值（從 start 開始，默認為 0）和通過迭代 iterable 獲得的值，

回傳一個列舉物件，iterable 必須是一個序列，或 iterator，或其他支持迭代的物件，
print(f'{ enumerate("abc") = }')
print(f'{ enumerate(iter("abc")) = }')
print(f'{ enumerate(["a", "b", "c"]) = }')
enumerate() 回傳的迭代器的 next() 方法回傳一個元組，里面包含一個計數值（從 start 開始，默認為 0）和通過迭代 iterable 獲得的值，
print('--------------')
iterable = ["a", "b", "c"]
enum = enumerate(iterable, start=0)
print(f'{ enum = }')
print(f'{ enum.next() = }')
print(f'{ enum.next() = }')
print(f'{ enum.next() = }')
print('------------')
print(f'{ list(enumerate(["a", "b", "c"], start=0)) = }')
print(f'{ list(enumerate(["a", "b", "c"], start=3)) = }')
print(f'{ list(enumerate(["a", "b", "c"], start=100)) = }')
print('--------------')
students = ['小明', '小紅', '小灰']
需求：輸出第幾個學生是某某某
i = 0
for student in students:
print(f'第{i+1}個學生是{student}')
i += 1
print('--------------')
for i, student in enumerate(students, start=0):
print(f'第{i+1}個學生是{student}')
print('--------------')
for i, student in enumerate(students, start=1):
print(f'第{i}個學生是{student}')

seasons = ['Spring', 'Summer', 'Fall', 'Winter']
list(enumerate(seasons))
[(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]
list(enumerate(seasons, start=1))
[(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')]
等價于:

def enumerate(sequence, start=0):
n = start
for elem in sequence:
yield n, elem
n += 1

35. map()

格式： map(function, iterable, ...)

回傳值：回傳一個將 function 應用于 iterable 中每一項并輸出其結果的迭代器，

如果傳入了額外的 iterable 引數，function 必須接受相同個數的實參并被應用于從所有可迭代物件中并行獲取的項，
當有多個可迭代物件時，最短的可迭代物件耗盡則整個迭代就將結束，對于函式的輸入已經是引數元組的情況，請參閱 itertools.starmap()，
#回傳一個將 function 應用于 iterable 中每一項并輸出其結果的迭代器，
def func(elem):
    return elem**2
print(f'{ map(func, [1, 2, 3]) = }')
print(f'{ list(map(func, [1, 2, 3])) = }')
print(f'{ tuple(map(func, [1, 2, 3])) = }')
print(f'{ set(map(func, [1, 2, 3])) = }')
for elem in map(func, [1, 2, 3]):
    print(elem)
#如果傳入了額外的 iterable 引數，function 必須接受相同個數的實參并被應用于從所有可迭代物件中并行獲取的項，
def func(iterable1_elem, iterable2_elem):
    return iterable1_elem + iterable2_elem
print(f'{ map(func, [1, 2, 3], [4, 5, 6]) = }')
print(f'{ list(map(func, [1, 2, 3], [4, 5, 6])) = }')
#當有多個可迭代物件時，最短的可迭代物件耗盡則整個迭代就將結束，
def func(iterable1_elem, iterable2_elem, iterable3_elem):
    return iterable1_elem + iterable2_elem + iterable3_elem
print(f'{ map(func, ["a", "b", "c"], ["a", "b"], ["a"]) = }')
print(f'{ list(map(func, ["a", "b", "c"], ["a", "b"], ["a"])) = }')
36. filter()

格式：filter(function, iterable)

用 iterable 中函式 function 回傳真的那些元素，構建一個新的迭代器，iterable 可以是一個序列，一個支持迭代的容器，或一個迭代器，如果 function 是 None ，則會假設它是一個身份函式，即 iterable 中所有回傳假的元素會被移除，
def func(elem):
    return elem in ['a', 'b', 'c', 'd', 'e']
print(f'{ filter(func, "apple") = }')
print(f'{ type(filter(func, "apple")) = }')
print(f'{ list(filter(func, "apple")) = }')
print(f'{ tuple(filter(func, "apple")) = }')
print(f'{ set(filter(func, "apple")) = }')
for elem in filter(func, "apple"):
    print(elem)
# iterable 可以是一個序列，一個支持迭代的容器，或一個迭代器，
def func(elem):
    return elem % 2 == 0
print(f'{ filter(func, [0, 1, 2, 3, 4, 5]) = }')
print(f'{ list(filter(func, [0, 1, 2, 3, 4, 5])) = }')
# iterable 可以是一個序列，一個支持迭代的容器，或一個迭代器，
def func(elem):
    return elem % 2 == 0
iterator = iter([0, 1, 2, 3, 4, 5])
print(f'{ filter(func, iterator) = }')
print(f'{ list(filter(func, iterator)) = }')
# 如果 function 是 None ，則會假設它是一個身份函式，即 iterable 中所有回傳假的元素會被移除，
print(f'{ list(filter(None, [None, False, 0, 0.0, 1, "test", ""])) = }')

請注意， filter(function, iterable) 相當于一個生成器運算式，當 function 不是 None 的時候為 (item for item in iterable if function(item))；function 是 None 的時候為 (item for item in iterable if item) ，
請參閱 itertools.filterfalse() 了解，只有 function 回傳 false 時才選取 iterable 中元素的補充函式

37. zip()

格式： zip(*iterables)

回傳值： class 'zip',回傳一個元組的迭代器，其中的第 i 個元組包含來自每個引數序列或可迭代物件的第 i 個元素，

創建一個聚合了來自每個可迭代物件中的元素的迭代器，
x=[1,2,3]
y=(4,5,6)
z="789"
zipped=zip(x,y,z)
print(list(zipped))

'''
[(1, 4, '7'), (2, 5, '8'), (3, 6, '9')]
'''
print(f'{ zip([1, 2, 3], ("a", "b", "c"), range(3)) = }')
print(f'{ list(zip([1, 2, 3], ("a", "b", "c"), range(3))) = }')
'''
zip([1, 2, 3], ("a", "b", "c"), range(3)) = <zip object at 0x000001FEB14B5480>
list(zip([1, 2, 3], ("a", "b", "c"), range(3))) = [(1, 'a', 0), (2, 'b', 1), (3, 'c', 2)]
'''
當所輸入可迭代物件中最短的一個被耗盡時，迭代器將停止迭代，
print(f'{ list(zip([1, 2, 3], ("a", "b", "c", "d"))) = }')
#[(1, 'a'), (2, 'b'), (3, 'c')]
zip() 與 * 運算子相結合可以用來拆解一個串列
x = [1, 2, 3]
y = [4, 5, 6]
zipped = zip(x, y) #打包
print(list(zipped))#轉為串列
print(*zip(x,y))   #解包可迭代物件
print(list(zip(*zip(x, y))))#解包后再次按元素序號打包
x2, y2 = zip(*zip(x, y))
print(x == list(x2) and y == list(y2))

# [(1, 4), (2, 5), (3, 6)]
# (1, 4) (2, 5) (3, 6)
# [(1, 2, 3), (4, 5, 6)]
# True
38. next()

格式： next(iterator[, default])

回傳值：通過呼叫 iterator 的 next() 方法獲取下一個元素，如果迭代器耗盡，則回傳給定的 default，如果沒有默認值則觸發 StopIteration，
class Iterator:
    def __init__(self):
        self.items = [1, 2, 3]
    def __iter__(self):
        return self
    def __next__(self):
        print('呼叫了__next__')
        if not self.items:
            raise StopIteration
        return self.items.pop(0)
iterator = Iterator()
print(f'{ next(iterator) = }')
print(f'{ next(iterator) = }')
print(f'{ next(iterator) = }')
# print(f'{ next(iterator) = }')
print(f'{ next(iterator, None) = }')
print(f'{ next(iterator, None) = }')

# 呼叫了__next__
#  next(iterator) = 1
# 呼叫了__next__
#  next(iterator) = 2
# 呼叫了__next__
#  next(iterator) = 3
# 呼叫了__next__
#  next(iterator, None) = None
# 呼叫了__next__
#  next(iterator, None) = None
39. iter()

格式： iter(object[, sentinel])

回傳值：根據是否存在第二個實參，第一個實參的解釋是非常不同的，如果沒有第二個實參，object 必須是支持迭代協議（有 iter() 方法）的集合物件，或必須支持序列協議（有 getitem() 方法，且數字引數從 0 開始），

40. reversed()

格式： reversed(seq)

回傳值：回傳一個反向的 iterator， seq 必須是一個具有 reversed() 方法的物件或者是支持該序列協議（具有從 0 開始的整數型別引數的 len() 方法和 getitem() 方法），
print(f'{ hasattr(list, "__reversed__") = }')
print(f'{ reversed(["a", "b", "c"]) = }')
print(f'{ list(reversed(["a", "b", "c"])) = }')
print('----------------')
print(f'{ hasattr(tuple, "__reversed__") = }')
print(f'{ hasattr(tuple, "__len__") = }')
print(f'{ hasattr(tuple, "__getitem__") = }')
print(f'{ reversed(("a", "b", "c")) = }')
print(f'{ tuple(reversed(("a", "b", "c"))) = }')
print('------------------')
print(f'{ hasattr(range, "__reversed__") = }')
print(f'{ reversed(range(3)) = }')
print(f'{ list(reversed(range(3))) = }')
print('----------------')
print(f'{ hasattr(str, "__reversed__") = }')
print(f'{ hasattr(str, "__len__") = }')
print(f'{ hasattr(str, "__getitem__") = }')
print(f'{ reversed("abc") = }')
print(f'{ list(reversed("abc")) = }')

'''
hasattr(list, "__reversed__") = True
reversed(["a", "b", "c"]) = <list_reverseiterator object at 0x000001349DB81C70>
list(reversed(["a", "b", "c"])) = ['c', 'b', 'a']
----------------
hasattr(tuple, "__reversed__") = False
hasattr(tuple, "__len__") = True
hasattr(tuple, "__getitem__") = True
reversed(("a", "b", "c")) = <reversed object at 0x000001349DB08400>
tuple(reversed(("a", "b", "c"))) = ('c', 'b', 'a')
------------------
hasattr(range, "__reversed__") = True
reversed(range(3)) = <range_iterator object at 0x00000134A012CDD0>
list(reversed(range(3))) = [2, 1, 0]
----------------
hasattr(str, "__reversed__") = False
hasattr(str, "__len__") = True
hasattr(str, "__getitem__") = True
reversed("abc") = <reversed object at 0x000001349DB08400>
list(reversed("abc")) = ['c', 'b', 'a']

'''
41. slice()

格式： class slice(start, stop[, step])

回傳值：回傳一個表示由 range(start, stop, step) 所指定索引集的 slice 物件，切片物件具有僅會回傳對應引數值（或其默認值）的只讀資料屬性 start, stop 和 step，

其中 start 和 step 引數默認為 None，切片物件具有僅會回傳對應引數值（或其默認值）的只讀資料屬性 start, stop 和 step，它們沒有其他的顯式功能；不過它們會被 NumPy 以及其他第三方擴展所使用，切片物件也會在使用擴展索引語法時被生成，例如: a[start:stop:step] 或 a[start:stop, i]，
s=slice(3,10,2)
s1=slice(10)
x=np.arange(100)
print(x[3:10:2])
print(x[s])
print(x[s1])
# [3 5 7 9]
# [3 5 7 9]
# [0 1 2 3 4 5 6 7 8 9]

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/545177.html

標籤：Python

上一篇：Python批量繪制遙感影像資料的直方圖

下一篇：Python 錯誤：ModuleNotFoundError: No module named 'conf'

python內置函式1