Python 解釋器內置(內建)了很多函數,這篇博文對它們進行逐一介紹,博主覺得有必要給出示例代碼的會給出示例代碼。
聲明:博主(昊虹圖像算法)寫這篇博文時,用的Python的版本號為3.9.10。
官方文檔:https://docs.python.org/zh-cn/3.9/library/functions.html#built-in-functions
說明:官方文檔裡列出了14*5-1=59個內置函數,但博主認為classmethod、staticmethod、property這三個更像是定義類的三個關鍵字,故沒在這篇博文中進行介紹,如果要看這三個的介紹,可參考我的另一篇博文,鏈接 https://blog.csdn.net/wenhao_ir/article/details/125383895
這篇博文中反復提到了可迭代對象的概論,那麼什麼是可迭代對象呢?
列表、元組、字典和集合就是典型的可迭代對象,這些對象都包含方法 __iter__() 或__next__()。可迭代對象的元素能夠通過其內部的方法 __iter__() 或 __next__()進行遍歷。
abs(x)
返回一個數的絕對值。 參數可以是整數、浮點數或任何實現了 __abs__() 的對象。 如果參數是一個復數,則返回它的模。
這個的示例代碼就不給了。
什麼叫可迭代對象?列表、元組、字典和集合就是典型的可迭代對象,這些對象都包含方法 __iter__() 和 __next__()。可迭代對象的元素能夠通過其內部的方法 __iter__() 和 __next__()進行遍歷。
那麼元素對象滿足什麼條件為True呢?可參考我的另一篇博文 https://blog.csdn.net/wenhao_ir/article/details/125439660
注意:按道理,空元組、空列表的布爾值為False,所以對於空元組、空列表,函數all()應該返回False才對,但事實並不是這樣,對於空元組、空列表函數all()的返回值也為True,這一點要特別注意。
示例代碼如下:
list1 = [1, 2, 3]
list2 = [-1, 2, 3]
list3 = [0, 2, 3]
list4 = []
bool1 = all(list1)
bool2 = all(list2)
bool3 = all(list3)
bool4 = all(list4)
運行結果如下:
什麼叫可迭代對象?列表、元組、字典和集合就是典型的可迭代對象,這些對象都包含方法 __iter__() 和 __next__()。
any() 函數用於判斷可迭代對象是否有一個以上元素為True,如果有一個為 True,則返回 True;如果全部為False,則返回 False。
那麼元素對象滿足什麼條件為True呢?可參考我的另一篇博文 https://blog.csdn.net/wenhao_ir/article/details/125439660
注意:對於函數any()而言,空元組、空列表返回值為False。
示例代碼如下:
list1 = [0, '', False, None]
list2 = [-1, 2, 3]
list3 = [0, 2, 3]
list4 = []
bool1 = any(list1)
bool2 = any(list2)
bool3 = any(list3)
bool4 = any(list4)
運行結果如下:
函數ascii()返回任何對象(字符串、元組、列表等)的可讀版本,有點類似於把對象強制轉換為ASCII碼字符串,它會將非ASCII字符替換為轉義字符。
上面這句話不太好理解,看一個示例代碼就知道了。
示例代碼如下:
x1 = ascii('My name is Ståle')
print(x1)
x2 = ascii([77, 88, 'swh'])
print(x2)
運行結果如下:
這裡要注意x1中的“\xe5”是怎麼回事?那是因為在ASCII碼中沒有字符å ,所以將其替換成了 \xe5
另外, 我們看到字符串的前後的引號也被轉換成了字符。
示例代碼如下:
x1 = bin(10)
print(x1)
運行結果如下:
關於函數bool(),請參見我的另一篇博文 https://blog.csdn.net/wenhao_ir/article/details/125439660
這個函數是3.7 版之後才有的,使用頻率也不高,暫時不做過多介紹。
函數bytearray()的語法如下:
bytearray([source[, encoding[, errors]]])
參數介紹:
如果 source 為整數,則返回一個長度為 source 的初始化數組;
如果 source 為字符串,則按照指定的 encoding 將字符串轉換為字節序列;
如果 source 為可迭代類型,因為每個元素的存儲空間只有一個字節,則元素必須為[0 ,255] 中的整數;
如果沒有輸入任何參數,默認就是初始化數組為0個元素。
示例代碼如下:
bytearray0 = bytearray()
bytearray1 = bytearray(5)
bytearray2 = bytearray('suwenhao', 'utf-8')
bytearray3 = bytearray([65, 66, 67])
運行結果如下:
從上面的運行結果我們可以看出:
①長度為 source 的初始化數組的元素的默認值為\x00
②顯示是以ASCII碼來顯示其值的,所以bytearray3的三個數被顯示為了大寫的字母ABC。
如果指定的對象是可調用的,則返回 True,否則返回 False。
注意:如果函數callable()返回True,object 仍然可能調用失敗;但如果返回 False,調用對象 object 絕對不會成功。
對於函數、方法、lambda 匿名函數、 類以及實現了 __call__ 方法的類實例, 它都會返回 True。
示例代碼如下:
def add(a_p, b_p):
return a_p + b_p
class A:
def method(self):
return 0
class B:
def __call__(self):
return 0
bool1 = callable(0) # 對象0不可被調用,所以應該返回False
bool2 = callable(add) # 函數add返回True
bool3 = callable(A) # 類A返回True
a = A()
bool4 = callable(a) # 類A的實例化對象a沒有實現__call__,所以應該返回False
bool5 = callable(B) # 類B返回True
b = B()
bool6 = callable(b) # 類B的實例化對象b實現了__call__,所以應該返回True
運行結果如下:
函數chr( i )返回 Unicode 碼位為整數 i 的字符的字符串格式。例如,chr(97) 返回字符串 ‘a’,chr(8364) 返回字符串 ‘€’。
i — 可以是 10 進制也可以是 16 進制的形式的數字,數字范圍為 0 到 1,114,111 (16 進制為0x10FFFF)。
示例代碼如下:
char1 = chr(97)
char2 = chr(8364)
運行結果如下:
另外,可用使用函數ord()返回字符的ASCII 數值或者Unicode數值,詳情見本文的第47個函數。
函數compile()的作用將字符串代碼編譯成可運行的代碼對象。
看了上面這句話通常還是不知道它干了啥。沒關系,看一下示例代碼就知道了。
示例代碼如下:
a1 = 188
x = compile('print(a1)', 'jhoij', 'eval')
eval(x)
運行結果如下:
從上面的示例代碼我們可以看出,當對語句 print(a1) 執行了形式為eval的compile操作後,得到了對象x,此時用eval()函數調用對象x,就相當於執行了語句print(a1)。
那這樣的操作有什麼意義呢?
網上查到一個觀點如下:
當執行字符串形式的代碼時,每次都必須對這些代碼進行字節編譯處理。compile()函數提供了一次性字節代碼預編譯,以後每次調用的時候,都不用編譯了。
但是博主(昊虹君)覺得這個說法有點問題,從上面的例子來看,每次運行這個腳本的時候還是會去執行一次compile()函數,那還是每次都去編譯了啊,除非它的結果被緩存在某個地方。
compile()函數語法如下:
compile(source, filename, mode[, flags[, dont_inherit,[ optimize]]])
參數意義如下:
復數是Python中數值類型的一種。可以用函數complex()通過指定復數的實部和虛部來得到復數。
示例代碼如下:
z1 = complex(7, 8)
print(z1)
運行結果如下:
語法如下:
delattr(object, name)
object – 對象。
name – 必須是對象的屬性。
示例代碼如下:
class Coordinate:
x = 10
y = -5
z = 0
point1 = Coordinate()
print('x = ', point1.x)
print('y = ', point1.y)
print('z = ', point1.z)
delattr(Coordinate, 'z')
print('--刪除 z 屬性後--')
print('x = ', point1.x)
print('y = ', point1.y)
# 觸發錯誤
print('z = ', point1.z)
運行結果如下:
函數dict()的詳情請參見博文 https://blog.csdn.net/wenhao_ir/article/details/125412774 的“01-附2”
函數dir()的詳情請參見博文 https://blog.csdn.net/wenhao_ir/article/details/125421060
示例代碼如下:
result_1 = divmod(5, 2)
運行結果如下:
關於函數enumerate()的詳細介紹,請參見我的另一篇博文:https://blog.csdn.net/wenhao_ir/article/details/125443427
詳見對函數compile()的介紹,具體來說是這篇博文中的第11個。
filter() 函數用於過濾序列,過濾掉不符合條件的元素,返回一個迭代器對象,如果要轉換為列表,可以使用 list() 來轉換。
該接收兩個參數,第一個為函數,第二個為序列,序列的每個元素作為參數傳遞給函數進行判斷,然後返回 True 或 False,最後將返回 True 的元素放到新列表中。
示例代碼如下:
def is_odd(n):
return n % 2 == 1
tmplist = filter(is_odd, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
newlist = list(tmplist)
print(newlist)
運行結果如下:
這個函數與列表(list)的方法sort()的第一個參數key的使用挺類似的,詳情見博文https://blog.csdn.net/wenhao_ir/article/details/125406092
什麼?字符串也可以轉換成浮點數,是的,你沒看錯,看下面的示例你就知道了。
int1 = 112
str1 = '123'
float_1 = float(int1)
float_2 = float(str1)
運行結果如下:
從上面的運行結果我們可以看出,字符串’123’被轉換成了浮點數123.0,這就是Python的靈活之處,同樣的功能,在C++中則需要使用類stringstream來實現,詳情見我的另一篇博文 https://blog.csdn.net/wenhao_ir/article/details/124508457
關於函數format(),我已在博文https://blog.csdn.net/wenhao_ir/article/details/125390532中詳細介紹過,這裡就不再重復介紹了。
函數frozenset()用於由原可迭代對象返回一個被凍結的可迭代對象,處於凍結狀態的可迭代對象不能添加或刪除任何元素。
示例代碼如下:
list1 = ['Google', 'CSDN', 'tencent', 1997, 1999, 1998]
list2 = frozenset(list1)
list2[0] = 'facebook'
運行結果如下:
示例代碼如下:
class A(object):
bar = 1
a1 = A()
b1 = getattr(a1, 'bar')
運行結果如下:
如果您想設置對象的屬性值,可以用函數setattr()來設置哦!函數setattr()見本篇博文第56個函數
globals() 函數會以字典類型返回當前位置的全部全局變量。
示例代碼如下:
str1 = 'suwenhao'
int1 = 1990
list1 = [1, 2, 3]
global_variable = globals()
運行結果如下:
函數hasattr()的示例代碼如下:
class Coordinate:
x = 10
y = -5
z = 0
point1 = Coordinate()
bool1 = hasattr(point1, 'x')
bool2 = hasattr(point1, 'y')
bool3 = hasattr(point1, 'z')
bool4 = hasattr(point1, 'no') # 沒有該屬性
運行結果如下:
示例代碼如下:
hash1 = hash('swh')
hash2 = hash(2487872782)
將上面的代碼運行兩次,結果分別如下:
第一次的運行結果:
第二次運行的結果:
從上面兩次的運行結果我們可以看出,一個字符串的hash值並不是唯一的,整數的hash值還是其本身。
示例代碼如下:
help('sys') # 查看sys模塊的幫助
help('str') # 查看str類的幫助
a = [1, 2, 3]
help(a) # 查看列表list的幫助
help(a.append) # 查看list的append方法的幫助
下面兩行代碼
a = [1, 2, 3]
help(a.append) # 查看list的append方法的幫助
的運行結果如下:
示例代碼如下:
hex1 = hex(10)
運行結果如下:
注意:函數hex()返回的是一個字符串對象。
示例代碼如下:
str1 = 'CSDN'
id1 = id(str1)
運行結果如下:
示例代碼如下:
str1 = input("input:")
運行結果如下:
第一次運行(輸入字符串):
第二次運行(輸入數字)
從第二次的運行結果我們可以看出,輸入的數字也被當成字符串處理了。不過不要緊,我們可以用函數float()或函數int()將字符串型數字轉化為float型和int型嘛。
語法如下:
int(x, base=10)
參數意義:
x – 字符串或數字。
base – 代表x為哪種進制的數,注意不是表示返回傎的進制
示例代碼如下:
int1 = int(3.6)
int2 = int('20')
int3 = int('12', 16) #16進制的12換算成10進制是18
int4 = int('0xa', 16)
運行結果如下:
從上面的運行結果可以看出,函數int()在將浮點數轉換為整數時,對於小數部分是直接捨棄處理的,而不是四捨五入。
示例代碼如下:
a = 2
bool1 = isinstance(a, int)
bool2 = isinstance(a, str)
bool3 = isinstance(a, (str, int, list)) # 只要是元組中的一個就返回True
運行結果如下:
語法如下:
issubclass(class1, class2)
如果 class1 是 class2 的子類返回 True,否則返回 False。
示例代碼如下:
class A:
pass
class B(A):
pass
class C:
pass
bool1 = issubclass(B, A)
bool2 = issubclass(B, C)
運行結果如下:
這個函數用於生成可迭代對象的迭代器對象。以list對象為例,如果我們想通過迭代器遍歷它,怎麼操作呢?方法之一就是先生成其迭代器對象,然後用內置函數next()進行遍歷操作。
內置函數next()的語法如下:
next(iterable[, default])
iterable – 可迭代對象
default – 可選,用於設置在沒有下一個元素時返回該默認值,如果不設置,又沒有下一個元素則會觸發 StopIteration 異常。
再看函數iter()的語法:
iter(object[, sentinel])
根據是否存在第二個實參,第一個實參的解釋是非常不同的。
如果沒有第二個實參,object 必須是支持迭代協議(有 __iter__() 方法)的集合對象(比如列表、元組、集合都是有 __iter__() 方法的,博文https://blog.csdn.net/wenhao_ir/article/details/125421060的第一個示例代碼的運行結果便證明了這一點),或必須支持序列協議(有 __getitem__() 方法,且數字參數從 0 開始)。如果它不支持這些協議,會觸發 TypeError。
如果有第二個實參 sentinel,那麼 object 必須是可調用的對象。這種情況下生成的迭代器,每次迭代調用它的 __next__() 方法時都會不帶實參地調用 object;如果返回的結果是 sentinel 則觸發 StopIteration,從而停止迭代,否則返回調用結果.。
適合 iter() 的第二種形式的應用之一是構建塊讀取器。 例如,從二進制數據庫文件中讀取固定寬度的塊,直至到達文件的末尾,這種情況下的示例如下:
from functools import partial
with open('mydata.db', 'rb') as f:
for block in iter(partial(f.read, 64), 'b'):
process_block(block)
上面的函數partial()會被不帶參數的迭代下去,直到其返回值為’b’才停止迭代。
再回頭來說第一種情況,使用函數iter()和函數next()對列表進行迭代的示例代碼如下:
x = iter(["apple", "banana", "cherry"])
print(next(x))
print(next(x))
print(next(x))
運行結果如下:
這個在前面關於字符串、列表、元組、字典、集合的介紹時已經介紹過了,詳情見下面的鏈接:
https://blog.csdn.net/wenhao_ir/article/details/125396412(這篇博文中的第14-3點中用到了len()測量字符串長度)
https://blog.csdn.net/wenhao_ir/article/details/125400072
https://blog.csdn.net/wenhao_ir/article/details/125407815
https://blog.csdn.net/wenhao_ir/article/details/125412774
https://blog.csdn.net/wenhao_ir/article/details/125424671
所以這裡就不再舉例了。
示例代碼如下:
tup1 = ('Google', 'Taobao', 'CSDN', 555)
list1 = list(tup1)
str1 = "Hello World"
list2 = list(str1)
運行結果如下:
相關函數:
62-函數tuple():把可迭代對象轉換為元組
locals() 函數會以字典類型返回當前位置的全部局部變量。
示例代碼如下:
def fun1(arg): # 兩個局部變量:arg、z
z = 1
print(locals())
fun1(6)
運行結果如下:
map() 函數會根據提供的函數對指定序列做映射。它的第一個參數和list的方法sort()、filter()函數的第一個參數使用類似。
sort()方法的詳細介紹見博文 https://blog.csdn.net/wenhao_ir/article/details/125406092
filter()函數上面已經介紹過了。
示例代碼一如下:
def square(x): # 計算平方數
return x ** 2
iter1 = map(square, [1, 2, 3, 4, 5])
list1 = list(iter1)
運行結果如下:
示例代碼二如下(匿名函數):
iter1 = map(lambda x: x ** 3, [1, 2, 3, 4, 5])
list1 = list(iter1)
運行結果如下:
這個函數在之前對字符串、列表、元組的介紹中均有提及,在字符串中它是作為字符類的方法出現的,不過它也可作用於字符串對象。
下面給一個綜合性的示例代碼。
str1 = 'abcdef'
max_str1 = max(str1)
list1 = [10, 11, 12, 13]
max_list1 = max(list1)
tup1 = (20, 21, 22, 25)
max_tupl1 = max(tup1)
set1 = {
50, 51, 52, 53}
max_set1 = max(set1)
運行結果如下:
所謂內存查看對象,是指對支持緩沖區協議的數據進行包裝,然後可以按字節進行查看。
示例代碼如下:
v = memoryview(bytearray("abcefg", 'utf-8'))
v_01 = v[1]
v_02 = v[2]
運行結果如下:
個人感覺在Pycharm-IDE中這個作用不是很大,因為我在IDE中可以很方便的查看對象的內存情況。
函數min()與第40個max()的使用一模一樣,只是它返回的是最小值,所以這裡就不再介紹,也不給示例代碼了。
函數next()在介紹35-函數iter()時已經介紹過了,這裡就不再介紹了。
object() 函數返回一個空對象。
您不能向這個對象添加新的屬性或方法,這個函數不接受任何實參。
這個對象是所有類的基礎,它擁有所有類默認的內置屬性和方法。
示例代碼如下:
x = object()
運行結果如下:
函數oct()將一個整數轉換成 8 進制字符串,8 進制以 0o 作為前綴表示。
示例代碼如下:
str1 = oct(10)
運行果如下:
open()函數用於打開一個文件,並返回文件對象,在對文件進行處理過程都需要使用到這個函數,如果該文件無法被打開,會拋出 OSError。
注意:文件對象使用完後,一定要調用close()函數關閉文件。
open()函數常用的形式是接收兩個參數:文件名(file)和模式(mode)。
open(file, mode='r')
完整的語法格式如下:
pen(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)
file—文件的路徑或名稱。
mode—文件打開模式,其具體內容如下:
補充說明:
mode 是一個可選字符串,用於指定打開文件的模式。
默認值是 ‘r’ ,與 ‘rt’ 同義,這意味著它以文本模式打開並讀取文件。
其他常見模式有:寫入 ‘w’ 、排它性創建 ‘x’ 、追加寫 ‘a’(在 一些 Unix 系統上,無論當前的文件指針在什麼位置,所有 寫入都會追加到文件末尾)。
接下來繼續介紹函數open()的其它參數。
在文本模式,如果 encoding 沒有指定,則根據平台來決定使用的編碼:使用 locale.getpreferredencoding(False) 來獲取本地編碼。
要讀取和寫入原始字節,請使用二進制模式並不要指定 encoding。
以二進制模式打開的文件(包括 mode 參數中的 ‘b’ )返回的內容為 bytes 對象,不進行任何解碼。在文本模式下(默認情況下,或者在 mode 參數中包含 ‘t’ )時,文件內容返回為 str ,首先使用指定的 encoding (如果給定)或者使用平台默認的的字節編碼解碼。
模式 ‘w+’ 與 ‘w+b’ 將打開文件並清空內容。
模式 ‘r+’ 與 ‘r+b’ 將打開文件並不清空內容。
buffering—這個參數用於設置緩沖。
encoding— encoding 是用於解碼或編碼文件的編碼的名稱,一般使用utf8。這應該只在文本模式下使用。默認編碼是依賴於平台的(而不管 locale.getpreferredencoding() 返回何值),但可以使用任何Python支持的 text encoding 。有關支持的編碼列表,請參閱Pythoncodecs 模塊。
errors–是一個可選的字符串參數,用於指定如何處理編碼和解碼錯誤 - 這不能在二進制模式下使用。可以使用各種標准錯誤處理程序(列在 錯誤處理方案 ),但是使用 codecs.register_error() 注冊的任何錯誤處理名稱也是有效的。標准名稱包括:
newline—控制文件的換行,即 universal newlines 模式如何生效(它僅適用於文本模式)。它可以是 None,‘’,‘\n’,‘\r’ 和 ‘\r\n’。它的工作原理如下:
從流中讀取輸入時,如果 newline 為 None,則啟用通用換行模式。輸入中的行可以以 ‘\n’,‘\r’ 或 ‘\r\n’ 結尾,這些行被翻譯成 ‘\n’ 在返回呼叫者之前。如果它是 ‘’,則啟用通用換行模式,但行結尾將返回給調用者未翻譯。如果它具有任何其他合法值,則輸入行僅由給定字符串終止,並且行結尾將返回給未調用的調用者。
將輸出寫入流時,如果 newline 為 None,則寫入的任何 ‘\n’ 字符都將轉換為系統默認行分隔符 os.linesep。如果 newline 是 ‘’ 或 ‘\n’,則不進行翻譯。如果 newline 是任何其他合法值,則寫入的任何 ‘\n’ 字符將被轉換為給定的字符串。
closefd—如果 closefd 是 False 並且給出了文件描述符而不是文件名,那麼當文件關閉時,底層文件描述符將保持打開狀態。如果給出文件名則 closefd 必須為 True (默認值),否則將引發錯誤。
opener—可以通過傳遞可調用的 opener 來使用自定義開啟器。然後通過使用參數( file,flags )調用 opener 獲得文件對象的基礎文件描述符。 opener 必須返回一個打開的文件描述符(使用 os.open as opener 時與傳遞 None 的效果相同)。
ord() 函數是chr() 函數對於 8 位的 ASCII 字符串)的配對函數[函數chr()見本文的第10個],它以一個字符串(Unicode 字符)作為參數,返回對應的 ASCII 數值,或者 Unicode 數值。
示例代碼如下:
int1 = ord('a')
char1 = chr(int1)
運行結果如下:
語法如下:
pow(x, y[, z])
計算x的y次方,如果z在存在,則再對結果進行取模,其結果等效於pow(x,y) %z
示例代碼如下:
int1 = pow(2, 3)
int2 = pow(2, 3, 6)
運行結果如下:
函數print()的詳細介紹見我的另一篇博文:https://blog.csdn.net/wenhao_ir/article/details/125390532
函數property()通常用於獲取、設置、刪除類的某個屬性。
函數property()的語法如下:
class property([fget[, fset[, fdel[, doc]]]])
參數:
fget – -獲取屬性值的函數(函數的功能並不一定是真正的去獲取屬性值,看了示例代碼就容易理解這一點)
fset —設置屬性值的函數(函數的功能並不一定是真正的去設置屬性值,看了示例代碼就容易理解這一點)
fdel — 刪除屬性值函數(函數的功能並不一定是真正的去刪除屬性,看了示例代碼就容易理解這一點)
doc — 屬性描述信息。
示例代碼如下:
class C(object):
def __init__(self):
self._x = None
def getx(self):
return self._x
def setx(self, value):
self._x = value
def delx(self):
del self._x
x = property(getx, setx, delx, "I'm the 'x' property.")
如果 c 是 C 的實例化, 則
c.x 將調用getx(),
c.x = value 將調用setx()
del c.x 將調用delx()
如果給定 doc 參數,其將成為這個屬性值的 docstring,否則 property 函數就會復制 fget 函數的 docstring(如果有的話)。
繼續完善示例代碼如下:
# 博主微信/QQ 2487872782
# 有問題可以聯系博主交流
class C(object):
def __init__(self):
self._x = 100
self._y = 200
def getx(self):
print('called getx and x={}'.format(self._x))
def setx(self, value):
self._x = value
print('called setx and x={}'.format(self._x))
def delx(self):
del self._x
print('called delx')
def gety(self):
print('called gety and y={}'.format(self._y))
def sety(self, value):
self._y = value
print('called sety and y={}'.format(self._y))
def dely(self):
del self._y
print('called dely')
x = property(getx, setx, delx, "I'm the 'x' property.")
y = property(gety, sety, dely, "I'm the 'y' property.")
c = C()
c.x
c.x = 12
del c.x
c.y
help(c)
運行結果如下:
上面的代碼中我定義了兩個與函數property()有關的屬性名,分別為x和y,並且我還為x和y設置了三個函數,以x為例,這三個函數分別通過
c.x
c.x = 12
del c.x
來調用。
注意:
Python3 range() 函數返回的是一個可迭代對象,而不是列表對象,可以用函數list()將其轉化為列表。
Python2 range() 函數返回的則是列表。
語法如下(有兩種形式):
range(stop)
range(start, stop[, step])
start—計數從 start 開始。默認是從 0 開始。例如range(5)等價於range(0, 5);
stop:—計數到 stop 結束,但不包括 stop。例如:range(0, 5是[0, 1, 2, 3, 4],注意沒有包括5。
step—步長,默認為1。例如:range(0, 5) 等價於 range(0, 5, 1)
示例代碼如下:
rang1 = range(5)
list1 = list(rang1)
for i in range(1, 4, 1):
print(i)
運行結果如下:
示例代碼如下:
dict1 = {
'name': 'suwenhao', 'likes': 'reading', 123: 456}
str1 = repr(dict1)
print(str1)
list1 = ['Google', 'CSDN', 1997, 1999]
str2 = repr(list1)
print(str2)
運行結果如下:
示例代碼如下:
內置函數str()和這個函數的功能差不多,函數str()的介紹見本博文第59點。
示例代碼如下:
str1 = 'abcdefg'
str1_reverse = reversed(str1)
str1_reverse_list = list(str1_reverse)
list1 = [1, 2, 3, 4, 5]
list1_reverse = reversed(list1)
list1_reverse_list = list(list1_reverse)
tup1 = ('A', 'B', 'C', 'D')
tup1_reverse = reversed(tup1)
tup1_reverse_list = list(tup1_reverse)
運行結果如下圖所示:
語法如下:
round( x [, n] )
參數意義:
x — 待處理的浮點數。
n — 表示需保留的小數位數,默認值為0,即不保留小數部分。
注意:它做的是五捨六入的近似運算,而不是四捨五入,大家看下面的示例代碼就知道了。
示例代碼如下:
print("round(70.3) : ", round(70.3))
print("round(70.4) : ", round(70.4))
print("round(70.5) : ", round(70.5))
print("round(70.6) : ", round(70.6))
print("round(70.7) : ", round(70.7))
print("round(80.23, 1) : ", round(80.23, 1))
print("round(80.24, 1) : ", round(80.24, 1))
print("round(80.25, 1) : ", round(80.25, 1))
print("round(80.26, 1) : ", round(80.26, 1))
print("round(80.27, 1) : ", round(80.27, 1))
運行結果如下:
函數set()在博文 https://blog.csdn.net/wenhao_ir/article/details/125424671 中已經介紹過了,這裡就不再重復介紹了。
函數setattr()對應函數getattr(),用於設置屬性值,該屬性不一定是存在的哦。
語法如下:
setattr(object, name, value)
參數意義如下:
object – 對象。
name – 字符串,對象屬性。
value – 屬性值
示例代碼如下:
class A(object):
bar = 1
a = A()
bar1 = getattr(a, 'bar') # 獲取屬性bar的值
setattr(a, 'bar', 5) # 設置對象a的屬性bar的值
bar2 = getattr(a, 'bar') # 再次獲取屬性bar的值
運行結果如下:
slice() 函數實現切片對象,主要用在切片操作函數裡的參數傳遞。
語法如下:
有兩種形式:
slice(stop)
slice(start, stop[, step])
參數意義:
start – 起始索引值
stop – 結束索引值
step – 索引間距
示例代碼如下:
list1 = [10, 20, 30, 40, 50, 60, 70, 80, 90, 100]
slice1 = slice(5)
list_sub1 = list1[slice1]
slice2 = slice(1, 8, 2)
list_sub2 = list1[slice2]
運行結果如下:
這裡分析下list_sub2是怎麼得到的?
索引區間為[1, 8) 注意是左閉右開區間。
索引步長為2,則有效索引值為1、1+2=3、3+2=5、5+2=7
索引值1、3、5、7對應的元素值分別為:10、40、60、80
所以list_sub2為[20, 40, 60, 80]
當然,我們一般都不用這個切片對象,而直接寫出切片表達式,
即我們通常把語句:
slice2 = slice(1, 8, 2)
list_sub2 = list1[slice2]
寫成:
list_sub2 = list1[1:8:2]
函數sorted()的用法和列表中的方法sort()的使用方法和功能是基本一樣的。
不同之處在於函數sorted()可以對所有的可迭代對象元素進行排序,並且它會返回一個新的列表。而列表中的方法sort()它只能針對列表,並且對原列表對象進行操作。
所以這裡就不再對函數sorted()進行介紹了,大家可參考我的另一篇博文https://blog.csdn.net/wenhao_ir/article/details/125400072中第16點對方法sort()的介紹。
內置函數repr()和這個函數的功能差不多,函數repr()的介紹見本博文第52點。
示例代碼如下:
dict1 = {
'name': 'suwenhao', 'likes': 'reading', 123: 456}
str1 = str(dict1)
print(str1)
list1 = ['Google', 'CSDN', 1997, 1999]
str2 = str(list1)
print(str2)
運行結果如下:
內置函數repr()和這個函數的功能差不多,函數repr()的介紹見本博文第52點。
語法如下:
sum(iterable, start)
參數意義如下:
iterable—必需。需求和的可迭代對象(序列)。
start—可選。添加到返回值的值。
示例代碼如下:
resutl1 = sum([0, 1, 2])
result2 = sum((2, 3, 4), 1) # 元組對象計算總和後再加1
result3 = sum([0, 1, 2, 3, 4], 2) # 列表計算總和後再加2
運行結果如下:
關於這個函數的詳細介紹,可以查看我的另一篇博文:https://blog.csdn.net/wenhao_ir/article/details/125472478
示例代碼如下:
list1 = ['Google', 'Taobao', 'Runoob', 'Baidu']
tuple1 = tuple(list1)
運行結果如下:
相關函數:
37-函數list():用於將元組或字符串轉換為列表
函數type()有兩種語法:
type(object)
type(name, bases, dict)
第一種語法返回對象的類型,第二種語法返回新的類型對象。
第一種語法是常用的,第二種語法很少用,所以下面的示例代碼只給第一種語法的示例代碼:
type1 = type(1)
type2 = type([1, 2, 'swh'])
type3 = type({
0: 'zero'})
x = 1
bool1 = type(x) == int # 判斷類型是否為int型
運行結果如下:
從上面的運行結果可以看出,函數type()返回的並不是字符串,而是type對象,type對象屬於“Special Variables”。
並通,還可以用關系運算符“==”對類型進行判斷哦。
示例代碼如下:
class Person:
name = "Bill"
age = 19
country = "USA"
x1 = dir(Person) # 返回類的所有屬性
x2 = vars(Person) # 返回類的__dic__屬性
運行結果如下:
資料上都說是返回對象的__dic__ 屬性,但是我實測卻返回不了,如下:
class Person:
name = "Bill"
age = 19
country = "USA"
object1 = Person()
x1 = vars(object1)
運行結果如下:
可能那些資料中的對象也把類認為是對象吧~在我的腦海裡,認為類的實例化才叫對象。
zip() 函數用於將可迭代的對象作為參數,將對象中對應的元素打包成一個個元組,然後返回由這些元組組成的對象,這樣做的好處是節約了不少的內存。
我們可以使用 list() 轉換來輸出列表。
如果各個迭代器的元素個數不一致,則返回列表長度與最短的對象相同,利用 * 號操作符,可以將元組解壓為列表。
示例代碼如下:
a = [1, 2, 3]
b = [4, 5, 6]
c = [11, 12, 13, 14, 15]
zip1 = zip(a, b)
list1 = list(zip1)
zip2 = zip(a, c)
list2 = list(zip2)
運行結果如下:
利用 * 號操作符,可以將元組解壓為列表,示例代碼如下:
tup1 = ((1, 4), (2, 5), (3, 6))
a1, b1 = zip(*tup1)
運行結果如下:
雖然關鍵詞import可以實現同樣的功能,但是通常我們在程序的開頭使用關鍵詞import進入導入操作,如果我們想在程序中部,可以使用內置函數__import__(),這樣會使程序看來順眼。
其語法如下:
__import__(name[, globals[, locals[, fromlist[, level]]]])
可選參數意義暫時不作探究。
示例代碼如下:
my_script.py中的代碼如下:
print('Successfully imported my_ script!')
print('my_script execution completed!')
001-32-內置函數.py中的代碼如下:
list1 = [1, 2, 3]
__import__('my_script')
list2 = [7, 8, 9]
運行結果如下:
參考資料:https://blog.csdn.net/wenhao_ir/article/details/125100220