本文目錄一覽：
python內置函數有哪些
python常見的內置函數有：
1. abs()函數返回數字的絕對值。
2. all() 函數用於判斷給定的參數中的所有元素是否都為 TRUE，如果是返回 True，否則返回 False。元素除了是 0、空、None、False 外都算 True；空元組、空列表返回值為True。
3. any() 函數用於判斷給定的參數是否全部為False，是則返回False，如果有一個為True，則返回True。 元素除了是 0、空、False外都算 TRUE。
4. bin()函數返回一個整數int或者長整數long int的二進制表示。
5. bool() 函數用於將給定參數轉換為布爾類型，如果參數不為空或不為0，返回True；參數為0或沒有參數，返回False。
6. bytearray()方法返回一個新字節數組。這個數組裡的元素是可變的，並且每個元素的值範圍: 0 = x 256（即0-255）。即bytearray()是可修改的二進制字節格式。
7. callable()函數用於檢查一個對象是否可調用的。對於函數、方法、lambda函式、類以及實現了 __call__ 方法的類實例, 它都返回 True。（可以加括號的都可以調用）
8. chr()函數用一個範圍在range(256)內（即0～255）的整數作參數，返回一個對應的ASCII數值。
9. dict()函數用來將元組/列錶轉換為字典格式。
10. dir()函數不帶參數時，返回當前範圍內的變量、方法和定義的類型列表；帶參數時，返回參數的屬性、方法列表。
擴展資料：
如何查看python3.6的內置函數？
1、首先先打開python自帶的集成開發環境IDLE；
2、然後我們直接輸入”dir(__builtins__)”,需要注意的是builtins左右的下劃線都是兩個；
3、回車之後我們就可以看到python所有的內置函數；
4、接下來我們學習第二種查看python內置函數的方法，我們直接在IDLE中輸入”import builtins”,然後輸入”dir(builtins)”；
5、然後回車，同樣的這個方法也可以得到所有的python內置的函數；
6、這裡我們可以使用python內置函數len（）來查看python內置函數的個數，這裡我們直接輸入”len(dir(builtins))”；
7、回車之後我們可以看到系統返回值153，說明我們現在這個版本中有153個內置函數；
8、最後我們介紹一個比較有用的內置函數”help”，python內置函數有一百多個，我們當然不能記住所有的函數，這裡python提供了一個”help”函數，我們來看一個例子一起來體會一下help函數的用法，這裡我們直接輸入”help(len)”,然後回車，會看到系統給我們對於內置函數”len”的解釋，當然對於其他函數可能會有更加詳細的解釋以及用法提示。
享學課堂淺談Python序列內建函數都有哪些
1、Python類型操作符和內建函數總結
表4.5列出了所有操作符和內建函數，其中操作符順序是按優先級從高到低排列的。同一種灰度的操作符擁有同樣的優先級。注意在operator模塊中有這些（和絕大多數Python)操作符相應的同功能的函數可供使用。
表4.5 標準類型操作符和內建函數
操作符/函數
描 述
結 果a
字符串表示
“
對象的字符串表示
str
內建函數
cmp(obj1, obj2)
比較兩個對象
int
repr(obj)
對象的字符串表示
str
str(obj)
對象的字符串表示
str
type(obj)
檢測對象的類型
type
值比較
小於
bool
大於
bool
=
小於或等於
bool
=
大於或等於
bool
==
等於
bool
!=
不等於
bool
不等於
bool
對象比較
is
是
bool
is not
不是
bool
布爾操作符
not
邏輯反
bool
and
邏輯與
bool
or
邏輯或
bool
2、Python數值類型操作符和內建函數
一、工廠函數
數值工廠函數總結類（工廠函數） 操作
bool(obj) b 返回obj對象的布爾值，也就是 obj.__nonzero__()方法的返回值。
int(obj, base=10) 返回一個字符串或數值對象的整數表 示， 類似string.atoi();
從Python 1.6起， 引入了可選的進制參數。
long(obj, base=10) 返回一個字符或數據對象的長整數表 示，類似string.atol(),
從Python1.6起， 引入了可選的進制參數 float(obj) ，
返回一個字符串或數據對象的浮點數 表示，類似string.atof()。
complex(str) or返回一個字符串的複數表示，或 者根據給定的實數，
complex(real, imag=0.0) （及一個可選 的虛數部分）生成一個複數對象。
二、內建函數
1、分類
Python 有五個運算內建函數用於數值運算：
abs(num), coerce(num1,num2), divmod(num1,num2), pow(num1,num2,mod=1)和 round(flt,ndig=0)
其中abs()返回給定參數的絕對值。如果參數是一個複數， 那麼就返回math.sqrt(num.real2 + num.imag2).
coerce()是一個數據類型轉換函數，不過它的行為更像一個運算符.數coerce（）為程序員提供了不依賴Python 解釋器，而是自定義兩個數值類型轉換的方法。對一種新創建的數值類型來說， 這個特性非常有用.函數coerce()僅返回一個包含類型轉換完畢的兩個數值元素的元組.
divmod()內建函數把除法和取余運算結合起來, 返回一個包含商和餘數的元組.對整數來說，它的返回值就是地板除和取余操作的結果.對浮點數來說，返回的商部分是math.floor(num1/num2)，對複數來說，商部分是ath.floor((num1/num2).real).
pow()它和雙星號 （**）運算符都可以進行指數運算.不過二者的區別並不僅僅在於一個是運算符，一個是內建函數.在Python 1.5 之前，並沒有 ** 運算符,內建函數pow()還接受第三個可選的參數，一個餘數參數.如果有這個參數的， pow() 先進行指數運算，然後將運算結果和第三個參數進行取余運算.這個特性主要用於密碼運算，並且比 pow(x,y) % z 性能更好， 這是因為這個函數的實現類似於C 函數pow(x,y,z).
round()用於對浮點數進行四捨五入運算。它有一個可選的小數位數參數.如果不提供小數位參數， 它返回與第一個參數最接近的整數（但仍然是浮點類型）.第二個參數告訴round 函數將結果精確到小數點後指定位數.
2、函數int()/round()/math.floor()它們之間的不同之處：
函數 int()直接截去小數部分.（返回值為整數）
函數 floor() 得到最接近原數但小於原數的整數.（返回值為浮點數）
函數 round() 得到最接近原數的整數.（返回值為浮點數）
3、進制轉換函數:
返回字符串表示的8 進制和16 進制整數,它們分別是內建函數：
oct()和 hex(). oct(255)=’0377’/hex(255)=’0xff’
函數chr()接受一個單字節整數值(0到255)，返回一個字符串(ASCII)，其值為對應的字符.chr(97)=’a’
函數ord()則相反，它接受一個字符(ASCII 或 Unicode)，返回其對應的整數值.ord(‘A’)=65
3、Python字符串函數
(一)標準類型操作符和標準內建函數
1)、標準類型操作符
,,=,=,==,!=,對象值得比較
註：做比較時字符串是按ASCII值的大小來比較的
is 對象身份比較
and,or,not 布爾類型
2）標準內建函數
type(obj)
cmp(obj1,obj2)
str(obj)和repr(obj) 或反引號運算符(“) 可以方便的以字符串的方式獲取對象的
內容、類型、數值屬性等信息。str()函數得到的字符串可讀性好， 而repr()函數得到的字符
串通常可以用來重新獲得該對象, 通常情況下 obj == eval(repr(obj)) 這個等式是成立的
isinstance(obj,type) 判斷對象的類型
(二)序列操作
1、序列操作
字符串屬於序列對象，可以使用所有序列的操作和函數
切片 [] [:] [::]
簡單總結：
*索引（S[i])獲取特定偏移的元素。
——第一個元素偏移為0
——（S[0])獲取第一個元素。
——負偏移索引意味着從最後或右邊反向進行計數
——（S[-2])獲取倒數第二個元素（就像S[len(s)-2]一樣
*分片[S[i:j]提取對應的部分作為一個序列
——右邊界不包含在內
——分片的邊界默認為0和序列的長度，如果沒有給出的話S[:]
——（S[1:3])獲取了從偏移為1，直到但不包括偏移為3的元素
——（S[1:])獲取從偏移為1到末尾之間的元素
——（S[:3])獲取從偏移為0直到但不包括偏移為3的元素
——（S[:-1])獲取從偏移為0直到但不包括最後一個元素之間的元素
——（S[:])獲取從偏移為0到末尾之間的元素,這有效地實現了頂層S拷貝
拷貝了一個相同值，但是是不同內存區域的對象。對象字符串這樣不可變的對象不是很有用，但是對於可以實地修改的對象來說很有用。
比如列表。
擴展分片：第三個限制值 【步進】
完整形式：X[I:J:K]:這標識索引X對象的元素，從偏移為I直到J-1，每隔K元素索引一次。第三個限制值，K，默認為1
實例
Python Code
1
2
3
4
5
S=’abcdefghijk’
S[1:10]
‘bcdefghij’
S[1:10:2]
‘bdfhj
也可以使用負數作為步進。
分片表達式
Python Code
1
2
“hello”[::-1]
‘olleh’
通過負數步進，兩個邊界的意義實際上進行了反轉。
3、成員操作符 in ，not in
返回布爾值True 或False
可以使用string模塊來判斷輸入字符的合法性，可見成品中的idcheck.py
4、字符串連接
+ 連接字符串 ‘name’+’ ‘+’jin’
字符串格式化 ‘%s %s’ % (‘name’,’jin’)
join()方法 ‘ ‘.join((‘name’,’jin’)) ‘ ‘.join([‘name’,’jin’])
5、刪除清空字符串
del aString
aString=”
(三)、序列函數
序列類型函數
len(str) 返回字串的長度
enumerate(iter):接受一個可迭代對象作為參數，返回一個enumerate
max(str)/min(str):max()和min()函數對其他的序列類型可能更有用,但對於string類型它們能很好地運行,返回最大或者最小的字符(按照ASCII 碼值排列),
zip([it0, it1,… itN]) 返回一個列表，其第一個元素是it0,it1,…這些元素的第一個元素組成的一個元組，第二個…,類推.
reversed(seq)c 接受一個序列作為參數,返回一個以逆序訪問的迭代器(PEP 322)
sorted(iter,func=None,key=None,reverse=False) 接受一個可迭代對象作為參數，返回一個有序的列表;可選參數func,key 和reverse 的含義跟list.sort()內建函數的參數含義一樣.
注意：
sorted等需要在原處修改的函數無法用在字符串對象，但可以產生新的對象
sum處理的對象是數字，不能用在字符串
sorted(s)
[‘a’, ‘e’, ‘e’, ‘g’, ‘g’, ‘g’, ‘o’]
(四)只適合於字符串類型的函數
1)raw_input()函數
內建的raw_input()函數使用給定字符串提示用戶輸入並將這個輸入返回，下面是一個使
用raw_input()的例子:
user_input = raw_input(“Enter your name: “)
prin user_input
2)str() and unicode()
str()和unicode()函數都是工廠函數，就是說產生所對應的類型的對象.它們接受一個任
意類型的對象，然後創建該對象的可打印的或者Unicode 的字符串表示. 它們和basestring 都
可以作為參數傳給isinstance()函數來判斷一個對象的類型
3)chr(), unichr(), and ord()
chr()函數用一個範圍在range(256)內的(就是0 到255)整數做參數,返回一個對應的字符.unichr()跟它一樣，只不過返回的是Unicode 字符
ord()函數是chr()函數(對於8 位的ASCII 字符串)或unichr()函數(對於Unicode 對象)
的配對函數,它以一個字符(長度為1 的字符串)作為參數,返回對應的ASCII 數值，或者Unicode
數值，如果所給的Unicode 字符超出了你的Python 定義範圍,則會引發一個TypeError 的異常
(五)、只適用於字符串的操作符
1、格式化操作符 %
字符串格式化符號
格式化字符 轉換方式
%c 轉換成字符(ASCII 碼值，或者長度為一的字符串)
%ra 優先用repr()函數進行字符串轉換
%s 優先用str()函數進行字符串轉換
%d / %i 轉成有符號十進制數
%ub 轉成無符號十進制數
%ob 轉成無符號八進制數
%xb/%Xb (Unsigned)轉成無符號十六進制數(x/X 代表轉換後的十六進制字符的大
小寫)
%e/%E 轉成科學計數法(e/E 控制輸出e/E)
%f/%F 轉成浮點數(小數部分自然截斷)
%g/%G %e 和%f/%E 和%F 的簡寫
%% 輸出%
格式化操作符輔助指令
符號 作用
* 定義寬度或者小數點精度
– 用做左對齊
+ 在正數前面顯示加號( + )
sp 在正數前面顯示空格
# 在八進制數前面顯示零(‘0’)，在十六進制前面顯示’0x’或者’0X'(取決於
用的是’x’還是’X’)
0 顯示的數字前面填充‘0’而不是默認的空格
% ‘%%’輸出一個單一的’%’
(var) 映射變量(字典參數)
m.n m 是顯示的最小總寬度,n 是小數點後的位數(如果可用的話)
2、字符串模板: 更簡單的替代品
由於新式的字符串Template 對象的引進使得string 模塊又重新活了過來，Template 對象
有兩個方法,substitute()和safe_substitute().前者更為嚴謹,在key 缺少的情況下它會報一
個KeyError 的異常出來，而後者在缺少key 時，直接原封不動的把字符串顯示出
3、原始字符串操作符( r/R )
字符串抑制轉義r’帶特殊符號的字串’
myfile=open(r’C:\new\text.data’,’w’)
4、Unicode 字符串操作符( u/U )
u’abc’ U+0061 U+0062 U+0063
u’\u1234′ U+1234
u’abc\u1234\n’ U+0061 U+0062 U+0063 U+1234 U+0012
(六)字符串對象的方法：
1、刪減
T2.lstrip() 移除字符串前面字符（默認空格），返回字符串
T2.rstrip() 移除字符串後面字符（默認空格），返回字符串
T2.strip() 移除字符串前後面空格，返回字符串 默認空格，可以其他字符 S.strip(‘”‘)
2、切割
partition(sep),
rpartition(sep),
splitlines([keepends]),#把S按照行分割符分為一個list，keepends是一個bool值，如果為真每行後而會保留行分割符
split([sep [,maxsplit]]),#以sep為分隔符，把S分成一個list。maxsplit表示分割的次數。默認的分割符為空白字符
rsplit([sep[,maxsplit]]) #從右到左切割
備註：
partition()函數族是2.5版本新增的方法。它接受一個字符串參數，並返回一個3個元素的 tuple 對象。
如果sep沒出現在母串中，返回值是 (sep, ‘’, ‘’)；
否則，返回值的第一個元素是 sep 左端的部分，第二個元素是 sep 自身，第三個元素是 sep 右端的部分。
S.partition(‘;’)
(”, ‘;’, ‘ generated by /sbin/dhclient-script\nnameserver 172.16.10.171\nnameserver 8.8.8.8\nnameserver 172.16.0.2\nnameserver 178.79.131.110\nnameserver 202.96.199.133\n’)
參數 maxsplit 是分切的次數，即最大的分切次數，所以返回值最多有 maxsplit+1 個元素。
s.split() 和 s.split(‘ ‘)的返回值不盡相同
‘ hello world!’.split()
[‘hello’, ‘world!’]
‘ hello world!’.split(‘ ‘)
[”, ”, ‘hello’, ”, ”, ‘world!’]
S.split(‘\n’,3)
[‘; generated by /sbin/dhclient-script’, ‘nameserver 172.16.10.171’, ‘nameserver 8.8.8.8’, ‘nameserver 172.16.0.2\nnameserver 178.79.131.110\nnameserver 202.96.199.133\n’]
超過最大切割個數後面的全部為一個元素
按行切割
S
‘; generated by /sbin/dhclient-script\nnameserver 172.16.10.171\nnameserver 8.8.8.8\nnameserver 172.16.0.2\nnameserver 178.79.131.110\nnameserver 202.96.199.133\n’
S.splitlines()
[‘; generated by /sbin/dhclient-script’, ‘nameserver 172.16.10.171’, ‘nameserver 8.8.8.8’, ‘nameserver 172.16.0.2’, ‘nameserver 178.79.131.110’, ‘nameserver 202.96.199.133’]
產生差異的原因在於當忽略 sep 參數或sep參數為 None 時與明確給 sep 賦予字符串值時 split() 採用兩種不同的算法。
對於前者，split() 先去除字符串兩端的空白符，然後以任意長度的空白符串作為界定符分切字符串
即連續的空白符串被當作單一的空白符看待；
對於後者則認為兩個連續的 sep 之間存在一個空字符串。因此對於空字符串（或空白符串），它們的返回值也是不同的：
”.split()
[]
”.split(‘ ‘)
[”]
3、變形
lower(),#全部小寫
upper(),#全部小寫
capitalize(),#首字母大寫
swapcase(),#大小寫交換
title()#每個單詞第一個大寫,其他小寫
備註
因為title() 函數並不去除字符串兩端的空白符也不會把連續的空白符替換為一個空格，
所以建議使用string 模塊中的capwords(s)函數，它能夠去除兩端的空白符，再將連續的空白符用一個空格代替。
Python Code
1
2
3
4
‘ hello world!’.title()
‘ Hello World!’
string.capwords(‘ hello world!’)
‘Hello World!’
4、連接
join(seq)
join() 函數的高效率（相對於循環相加而言），使它成為最值得關注的字符串方法之一。
它的功用是將可迭代的字符串序列連接成一條長字符串，如：
conf = {‘host’:’127.0.0.1′,
… ‘db’:’spam’,
… ‘user’:’sa’,
… ‘passwd’:’eggs’}
‘;’.join(“%s=%s”%(k, v) for k, v in conf.iteritems())
‘passswd=eggs;db=spam;user=sa;host=127.0.0.1’
S=”.join(T) #使用空字符串分割把字符列錶轉換為字符串
5、查找
count( sub[, start[, end]]),#計算substr在S中出現的次數
find( sub[, start[, end]]),#返回S中出現sub的第一個字母的標號，如果S中沒有sub則返回-1。start和end作用就相當於在S[start:end]中搜索
index( substr[, start[, end]]),#與find()相同，只是在S中沒有substr時，會返回一個運行時錯誤
rfind( sub[, start[,end]]),#返回S中最後出現的substr的第一個字母的標號，如果S中沒有substr則返回-1，也就是說從右邊算起的第一次出現的substr的首字母標號
rindex( sub[, start[, end]])
T2.find(‘ie’) 字符串方法調用：搜索
find()—-找到的第一個符合字符的index
rfind()—–找到最後一個符合的字符的index
備註：
find()函數族找不到時返回-1，index()函數族則拋出ValueError異常。
另，也可以用 in 和 not in 操作符來判斷字符串中是否存在某個模板
6、替換
replace(old, new[,count]),#把S中的oldstar替換為newstr，count為替換次數。這是替換的通用形式，還有一些函數進行特殊字符的替換
translate(table[,deletechars]) #使用上面的函數產後的翻譯表，把S進行翻譯，並把deletechars中有的字符刪掉
備註：
replace()函數的 count 參數用以指定最大替換次數
translate() 的參數 table 可以由 string.maketrans(frm, to) 生成
translate() 對 unicode 對象的支持並不完備，建議不要使用
7、判定
isalnum(),#是否全是字母和數字，並至少有一個字符
isalpha(),是否全是字母，並至少有一個字符
isdigit(),是否全是數字，並至少有一個字符 ，如果是全數字返回True,否則返回False
islower(),#S中的字母是否全是小寫
isupper(),#S中的字母是否是大寫
isspace(),#是否全是空白字符，並至少有一個字符
istitle(),S是否是首字母大寫的
startswith(prefix[, start[, end]]), #是否以prefix開頭
endswith(suffix[,start[, end]]),#以suffix結尾
備註：
這些函數都比較簡單，顧名知義。需要注意的是*with()函數族可以接受可選的 start, end 參數，善加利用，可以優化性能。
另，自 Py2.5 版本起，*with() 函數族的 prefix 參數可以接受 tuple 類型的實參，當實參中的某人元素能夠匹配，即返回 True。
8、填充
字符串在輸出時的對齊：
center(width[, fillchar]), 字符串中間對齊
ljust(width[, fillchar]), 字符串左對齊，不足部分用fillchar填充，默認的為空格
rjust(width[, fillchar]), 字符串右對齊，不足部分用fillchar填充，默認的為空格
zfill(width), 把字符串變成width長，並在右對齊，不足部分用0補足
expandtabs([tabsize])把字符串中的製表符（tab）轉換為適當數量的空格。
fillchar 參數指定了用以填充的字符，默認為空格
zfill的z為zero的縮寫,顧名思義,是以字符0進行填充，用於數值輸出
expandtabs()的tabsize 參數默認為8。它的功能是把字符串中的製表符（tab）轉換為適當數量的空格。
9、編碼
encode([encoding[,errors]]),
decode([encoding[,errors]])
這是一對互逆操作的方法，用以編碼和解碼字符串。因為str是平台相關的，它使用的內碼依賴於操作系統環境，
而unicode是平台無關的，是Python內部的字符串存儲
python常用函數
1、complex()
返回一個形如 a+bj 的複數，傳入參數分為三種情況：
參數為空時，返回0j；參數為字符串時，將字符串表達式解釋為複數形式並返回；參數為兩個整數(a,b)時，返回 a+bj；參數只有一個整數 a 時，虛部 b 默認為0，函數返回 a+0j。
2、dir()
不提供參數時，返回當前本地範圍內的名稱列表；提供一個參數時，返回該對象包含的全部屬性。
3、divmod(a,b)
a — 代表被除數，整數或浮點數；b — 代表除數，整數或浮點數；根據 除法運算 計算 a,b 之間的商和餘數，函數返回一個元組(p,q) ，p 代表商 a//b ，q 代表餘數 a%b。
4、enumerate(iterable,start=0)
iterable — 一個可迭代對象，列表、元組序列等；start — 計數索引值，默認初始為0‘該函數返回枚舉對象是個迭代器，利用 next() 方法依次返回元素值，每個元素以元組形式存在，包含一個計數元素(起始為 start )和 iterable 中對應的元素值。
Python中字典的內建函數用法是什麼？
點擊上方 “Python人工智能技術” 關注，星標或者置頂
22點24分準時推送，第一時間送達
後台回復“大禮包”，送你特別福利
編輯：樂樂 | 來自：pypypypy
上一篇：
正文
大家好，我是Pythn人工智能技術。
內置函數就是Python給你提供的，拿來直接用的函數，比如print.，input等。
截止到python版本3.6.2 ，python一共提供了68個內置函數，具體如下
abs() dict() help() min() setattr()
all() dir() hex() next() slice()
any() divmod() id() object() sorted()
ascii() enumerate() input() oct() staticmethod()
bin() eval() int() open() str()
bool() exec() isinstance() ord() sum()
bytearray() filter() issubclass() pow() super()
bytes() float() iter() print() tuple()
callable() format() len() property() type()
chr() frozenset() list() range() vars()
classmethod() getattr() locals() repr() zip()
compile() globals() map() reversed() __import__()
complex() hasattr() max() round()
delattr() hash() memoryview() set()
本文將這68個內置函數綜合整理為12大類，正在學習Python基礎的讀者一定不要錯過，建議收藏學習！
和數字相關 1. 數據類型
bool : 布爾型(True,False)
int : 整型(整數)
float : 浮點型(小數)
complex : 複數
2. 進制轉換
bin() 將給的參數轉換成二進制
otc() 將給的參數轉換成八進制
hex() 將給的參數轉換成十六進制
print(bin(10)) # 二進制:0b1010
print(hex(10)) # 十六進制:0xa
print(oct(10)) # 八進制:0o12
3. 數學運算
abs() 返回絕對值
divmode() 返回商和餘數
round() 四捨五入
pow(a, b) 求a的b次冪, 如果有三個參數. 則求完次冪後對第三個數取余
sum() 求和
min() 求最小值
max() 求最大值
print(abs(-2)) # 絕對值:2
print(divmod(20,3)) # 求商和餘數:(6,2)
print(round(4.50)) # 五舍六入:4
print(round(4.51)) #5
print(pow(10,2,3)) # 如果給了第三個參數. 表示最後取余:1
print(sum([1,2,3,4,5,6,7,8,9,10])) # 求和:55
print(min(5,3,9,12,7,2)) #求最小值:2
print(max(7,3,15,9,4,13)) #求最大值:15
和數據結構相關 1. 序列
（1）列表和元組
list() 將一個可迭代對象轉換成列表
tuple() 將一個可迭代對象轉換成元組
print(list((1,2,3,4,5,6))) #[1, 2, 3, 4, 5, 6]
print(tuple([1,2,3,4,5,6])) #(1, 2, 3, 4, 5, 6)
（2）相關內置函數
reversed() 將一個序列翻轉, 返回翻轉序列的迭代器
slice() 列表的切片
lst = “你好啊”
it = reversed(lst) # 不會改變原列表. 返回一個迭代器, 設計上的一個規則
print(list(it)) #[‘啊’, ‘好’, ‘你’]
lst = [1, 2, 3, 4, 5, 6, 7]
print(lst[1:3:1]) #[2,3]
s = slice(1, 3, 1) # 切片用的
print(lst[s]) #[2,3]
（3）字符串
str() 將數據轉化成字符串
print(str(123)+’456′) #123456
format() 與具體數據相關, 用於計算各種小數, 精算等.
s = “hello world!”
print(format(s, “^20”)) #劇中
print(format(s, “20”)) #左對齊
print(format(s, “20”)) #右對齊
# hello world!
# hello world!
# hello world!
print(format(3, ‘b’ )) # 二進制:11
print(format(97, ‘c’ )) # 轉換成unicode字符:a
print(format(11, ‘d’ )) # ⼗進制:11
print(format(11, ‘o’ )) # 八進制:13
print(format(11, ‘x’ )) # 十六進制(⼩寫字母):b
print(format(11, ‘X’ )) # 十六進制(大寫字母):B
print(format(11, ‘n’ )) # 和d⼀樣:11
print(format(11)) # 和d⼀樣:11
print(format(123456789, ‘e’ )) # 科學計數法. 默認保留6位小數:1.234568e+08
print(format(123456789, ‘0.2e’ )) # 科學計數法. 保留2位小數(小寫):1.23e+08
print(format(123456789, ‘0.2E’ )) # 科學計數法. 保留2位小數(大寫):1.23E+08
print(format(1.23456789, ‘f’ )) # 小數點計數法. 保留6位小數:1.234568
print(format(1.23456789, ‘0.2f’ )) # 小數點計數法. 保留2位小數:1.23
print(format(1.23456789, ‘0.10f’)) # 小數點計數法. 保留10位小數:1.2345678900
print(format(1.23456789e+3, ‘F’)) # 小數點計數法. 很大的時候輸出INF:1234.567890
bytes() 把字符串轉化成bytes類型
bs = bytes(“今天吃飯了嗎”, encoding=”utf-8″)
print(bs) #b’\xe4\xbb\x8a\xe5\xa4\xa9\xe5\x90\x83\xe9\xa5\xad\xe4\xba\x86\xe5\x90\x97′
bytearray() 返回一個新字節數組. 這個數字的元素是可變的, 並且每個元素的值得範圍是[0,256)
ret = bytearray(“alex” ,encoding =’utf-8′)
print(ret[0]) #97
print(ret) #bytearray(b’alex’)
ret[0] = 65 #把65的位置A賦值給ret[0]
print(str(ret)) #bytearray(b’Alex’)
ord() 輸入字符找帶字符編碼的位置
chr() 輸入位置數字找出對應的字符
ascii() 是ascii碼中的返回該值 不是就返回u
print(ord(‘a’)) # 字母a在編碼表中的碼位:97
print(ord(‘中’)) # ‘中’字在編碼表中的位置:20013
print(chr(65)) # 已知碼位,求字符是什麼:A
print(chr(19999)) #丟
for i in range(65536): #打印出0到65535的字符
print(chr(i), end=” “)
print(ascii(“@”)) #’@’
repr() 返回一個對象的string形式
s = “今天\n吃了%s頓\t飯” % 3
print(s)#今天# 吃了3頓 飯
print(repr(s)) # 原樣輸出,過濾掉轉義字符 \n \t \r 不管百分號%
#’今天\n吃了3頓\t飯’
2. 數據集合
字典：dict 創建一個字典
集合：set 創建一個集合
frozenset() 創建一個凍結的集合，凍結的集合不能進行添加和刪除操作。
3. 相關內置函數
len() 返回一個對象中的元素的個數
sorted() 對可迭代對象進行排序操作 (lamda)
語法：sorted(Iterable, key=函數(排序規則), reverse=False)
Iterable: 可迭代對象
key: 排序規則(排序函數), 在sorted內部會將可迭代對象中的每一個元素傳遞給這個函數的參數. 根據函數運算的結果進行排序
reverse: 是否是倒敘. True: 倒敘, False: 正序
lst = [5,7,6,12,1,13,9,18,5]
lst.sort() # sort是list裡面的一個方法
print(lst) #[1, 5, 5, 6, 7, 9, 12, 13, 18]
ll = sorted(lst) # 內置函數. 返回給你一個新列表 新列表是被排序的
print(ll) #[1, 5, 5, 6, 7, 9, 12, 13, 18]
l2 = sorted(lst,reverse=True) #倒序
print(l2) #[18, 13, 12, 9, 7, 6, 5, 5, 1]
#根據字符串長度給列表排序
lst = [‘one’, ‘two’, ‘three’, ‘four’, ‘five’, ‘six’]
def f(s):
return len(s)
l1 = sorted(lst, key=f, )
print(l1) #[‘one’, ‘two’, ‘six’, ‘four’, ‘five’, ‘three’]
enumerate() 獲取集合的枚舉對象
lst = [‘one’,’two’,’three’,’four’,’five’]
for index, el in enumerate(lst,1): # 把索引和元素一起獲取,索引默認從0開始. 可以更改
print(index)
print(el)
# 1
# one
# 2
# two
# 3
# three
# 4
# four
# 5
# five
all() 可迭代對象中全部是True, 結果才是True
any() 可迭代對象中有一個是True, 結果就是True
print(all([1,’hello’,True,9])) #True
print(any([0,0,0,False,1,’good’])) #True
zip() 函數用於將可迭代的對象作為參數, 將對象中對應的元素打包成一個元組, 然後返回由這些元組組成的列表. 如果各個迭代器的元素個數不一致, 則返回列表長度與最短的對象相同
lst1 = [1, 2, 3, 4, 5, 6]
lst2 = [‘醉鄉民謠’, ‘驢得水’, ‘放牛班的春天’, ‘美麗人生’, ‘辯護人’, ‘被嫌棄的松子的一生’]
lst3 = [‘美國’, ‘中國’, ‘法國’, ‘意大利’, ‘韓國’, ‘日本’]
print(zip(lst1, lst1, lst3)) #
for el in zip(lst1, lst2, lst3):
print(el)
# (1, ‘醉鄉民謠’, ‘美國’)
# (2, ‘驢得水’, ‘中國’)
# (3, ‘放牛班的春天’, ‘法國’)
# (4, ‘美麗人生’, ‘意大利’)
# (5, ‘辯護人’, ‘韓國’)
# (6, ‘被嫌棄的松子的一生’, ‘日本’)
fiter() 過濾 (lamda)
語法：fiter(function. Iterable)
function: 用來篩選的函數. 在filter中會自動的把iterable中的元素傳遞給function. 然後根據function返回的True或者False來判斷是否保留留此項數據 , Iterable: 可迭代對象
搜索公眾號頂級架構師後台回復“面試”，送你一份驚喜禮包。
def func(i): # 判斷奇數
return i % 2 == 1
lst = [1,2,3,4,5,6,7,8,9]
l1 = filter(func, lst) #l1是迭代器
print(l1) #
print(list(l1)) #[1, 3, 5, 7, 9]
map() 會根據提供的函數對指定序列列做映射(lamda)
語法 : map(function, iterable)
可以對可迭代對象中的每一個元素進行映射. 分別去執行 function
def f(i): return i
lst = [1,2,3,4,5,6,7,]
it = map(f, lst) # 把可迭代對象中的每一個元素傳遞給前面的函數進行處理. 處理的結果會返回成迭代器print(list(it)) #[1, 2, 3, 4, 5, 6, 7]
和作用域相關
locals() 返回當前作用域中的名字
globals() 返回全局作用域中的名字
def func():
a = 10
print(locals()) # 當前作用域中的內容
print(globals()) # 全局作用域中的內容
print(“今天內容很多”)
func()
# {‘a’: 10}
# {‘__name__’: ‘__main__’, ‘__doc__’: None, ‘__package__’: None, ‘__loader__’:
# _frozen_importlib_external.SourceFileLoader object at 0x0000026F8D566080,
# ‘__spec__’: None, ‘__annotations__’: {}, ‘__builtins__’:
# (built-in), ‘__file__’: ‘D:/pycharm/練習/week03/new14.py’, ‘__cached__’: None,
# ‘func’: }
# 今天內容很多
和迭代器生成器相關
range() 生成數據
next() 迭代器向下執行一次, 內部實際使⽤用了__ next__()⽅方法返回迭代器的下一個項目
iter() 獲取迭代器, 內部實際使用的是__ iter__()⽅方法來獲取迭代器
for i in range(15,-1,-5):
print(i)
# 15
# 10
# 5
# 0
lst = [1,2,3,4,5]
it = iter(lst) # __iter__()獲得迭代器
print(it.__next__()) #1
print(next(it)) #2 __next__()
print(next(it)) #3
print(next(it)) #4
字符串類型代碼的執行
eval() 執行字符串類型的代碼. 並返回最終結果
exec() 執行字符串類型的代碼
compile() 將字符串類型的代碼編碼. 代碼對象能夠通過exec語句來執行或者eval()進行求值
s1 = input(“請輸入a+b:”) #輸入:8+9
print(eval(s1)) # 17 可以動態的執行代碼. 代碼必須有返回值
s2 = “for i in range(5): print(i)”
a = exec(s2) # exec 執行代碼不返回任何內容
# 0
# 1
# 2
# 3
# 4
print(a) #None
# 動態執行代碼
exec(“””
def func():
print(” 我是周杰倫”)
“”” )
func() #我是周杰倫
code1 = “for i in range(3): print(i)”
com = compile(code1, “”, mode=”exec”) # compile並不會執行你的代碼.只是編譯
exec(com) # 執行編譯的結果
# 0
# 1
# 2
code2 = “5+6+7”
com2 = compile(code2, “”, mode=”eval”)
print(eval(com2)) # 18
code3 = “name = input(‘請輸入你的名字:’)” #輸入:hello
com3 = compile(code3, “”, mode=”single”)
exec(com3)
print(name) #hello
輸入輸出
print() : 打印輸出
input() : 獲取用戶輸出的內容
print(“hello”, “world”, sep=”*”, end=”@”) # sep:打印出的內容用什麼連接,end:以什麼為結尾
#hello*world@
內存相關
hash() : 獲取到對象的哈希值(int, str, bool, tuple). hash算法:(1) 目的是唯一性 (2) dict 查找效率非常高, hash表.用空間換的時間 比較耗費內存
s = ‘alex’print(hash(s)) #-168324845050430382lst = [1, 2, 3, 4, 5]print(hash(lst)) #報錯,列表是不可哈希的 id() : 獲取到對象的內存地址s = ‘alex’print(id(s)) #2278345368944
文件操作相關
open() : 用於打開一個文件, 創建一個文件句柄
f = open(‘file’,mode=’r’,encoding=’utf-8′)
f.read()
f.close()
模塊相關
__ import__() : 用於動態加載類和函數
# 讓用戶輸入一個要導入的模塊
import os
name = input(“請輸入你要導入的模塊:”)
__import__(name) # 可以動態導入模塊
幫 助
help() : 函數用於查看函數或模塊用途的詳細說明
print(help(str)) #查看字符串的用途
調用相關
callable() : 用於檢查一個對象是否是可調用的. 如果返回True, object有可能調用失敗, 但如果返回False. 那調用絕對不會成功
a = 10
print(callable(a)) #False 變量a不能被調用
def f():
print(“hello”)
print(callable(f)) # True 函數是可以被調用的
查看內置屬性
dir() : 查看對象的內置屬性, 訪問的是對象中的__dir__()方法
print(dir(tuple)) #查看元組的方法
你還有什麼想要補充的嗎？
免責聲明：本文內容來源於網絡，文章版權歸原作者所有，意在傳播相關技術知識行業趨勢，供大家學習交流，若涉及作品版權問題，請聯繫刪除或授權事宜。
技術君個人微信
添加技術君個人微信即送一份驚喜大禮包
→ 技術資料共享
→ 技術交流社群
–END–
往日熱文：
Python程序員深度學習的“四大名著”：
這四本書着實很不錯！我們都知道現在機器學習、深度學習的資料太多了，面對海量資源，往往陷入到“無從下手”的困惑出境。而且並非所有的書籍都是優質資源，浪費大量的時間是得不償失的。給大家推薦這幾本好書並做簡單介紹。
獲得方式：
2.後台回復關鍵詞：名著
太全了！Python3常用內置函數總結
數學相關
abs(a) : 求取絕對值。abs(-1)
max(list) : 求取list最大值。max([1,2,3])
min(list) : 求取list最小值。min([1,2,3])
sum(list) : 求取list元素的和。 sum([1,2,3]) 6
sorted(list) : 排序，返回排序後的list。
len(list) : list長度,len([1,2,3])
divmod(a,b): 獲取商和餘數。 divmod(5,2) (2,1)
pow(a,b) : 獲取乘方數。pow(2,3) 8
round(a,b) : 獲取指定位數的小數。a代表浮點數，b代表要保留的位數。round(3.1415926,2) 3.14
range(a[,b]) : 生成一個a到b的數組,左閉右開。range(1,10) [1,2,3,4,5,6,7,8,9]
類型轉換
int(str) : 轉換為int型。int(‘1’) 1
float(int/str) : 將int型或字符型轉換為浮點型。float(‘1’) 1.0
str(int) : 轉換為字符型。str(1) ‘1’
bool(int) : 轉換為布爾類型。 str(0) False str(None) False
bytes(str,code) : 接收一個字符串，與所要編碼的格式，返回一個字節流類型。bytes(‘abc’, ‘utf-8′) b’abc’ bytes(u’爬蟲’, ‘utf-8′) b’xe7x88xacxe8x99xab’
list(iterable) : 轉換為list。 list((1,2,3)) [1,2,3]
iter(iterable)： 返回一個可迭代的對象。 iter([1,2,3]) list_iterator object at 0x0000000003813B00
dict(iterable) : 轉換為dict。 dict([(‘a’, 1), (‘b’, 2), (‘c’, 3)]) {‘a’:1, ‘b’:2, ‘c’:3}
enumerate(iterable) : 返回一個枚舉對象。
tuple(iterable) : 轉換為tuple。 tuple([1,2,3]) (1,2,3)
set(iterable) : 轉換為set。 set([1,4,2,4,3,5]) {1,2,3,4,5} set({1:’a’,2:’b’,3:’c’}) {1,2,3}
hex(int) : 轉換為16進制。hex(1024) ‘0x400’
oct(int) : 轉換為8進制。 oct(1024) ‘0o2000’
bin(int) : 轉換為2進制。 bin(1024) ‘0b10000000000’
chr(int) : 轉換數字為相應ASCI碼字符。 chr(65) ‘A’
ord(str) : 轉換ASCI字符為相應的數字。 ord(‘A’) 65
相關操作
eval****() : 執行一個表達式，或字符串作為運算。 eval(‘1+1’) 2
exec() : 執行python語句。 exec(‘print(“Python”)’) Python
filter(func, iterable) : 通過判斷函數fun，篩選符合條件的元素。 filter(lambda x: x3, [1,2,3,4,5,6]) filter object at 0x0000000003813828
map(func, *iterable) : 將func用於每個iterable對象。 map(lambda a,b: a+b, [1,2,3,4], [5,6,7]) [6,8,10]
zip(*iterable) : 將iterable分組合併。返回一個zip對象。 list(zip([1,2,3],[4,5,6])) [(1, 4), (2, 5), (3, 6)]
type()：返回一個對象的類型。
id()： 返回一個對象的唯一標識值。
hash(object)：返回一個對象的hash值，具有相同值的object具有相同的hash值。 hash(‘python’) 7070808359261009780
help()：調用系統內置的幫助系統。
isinstance()：判斷一個對象是否為該類的一個實例。
issubclass()：判斷一個類是否為另一個類的子類。
globals() : 返回當前全局變量的字典。
next(iterator[, default]) : 接收一個迭代器，返回迭代器中的數值，如果設置了default，則當迭代器中的元素遍歷後，輸出default內容。
reversed(sequence) ： 生成一個反轉序列的迭代器。 reversed(‘abc’) [‘c’,’b’,’a’]
原創文章，作者：小藍，如若轉載，請註明出處：https://www.506064.com/zh-hant/n/282831.html
微信掃一掃 
支付寶掃一掃 