Python語法速查： 1. 數據類型與內置函數
返回目錄html
（1）經常使用內置數據類型
| 分類 | 類型名稱 | 描述 |
|---|---|---|
| 數字 | int | 整數 |
| float | 浮點數 | |
| complex | 複數 | |
| bool | 布爾值 | |
| 序列 | str | 字符串（不可變序列） |
| list | 列表 | |
| tuple | 元組（不可變序列） | |
| range | 整數範圍（不可變序列） | |
| bytes | 字節數組（不可變序列） | |
| bytearray | 可變字節數組 | |
| 映射 | dict | 字典 |
| 集合 | set | 可變集合 |
| frozenset | 不可變集合 | |
| None | NoneType | 空對象，它沒有任何屬性 |
（2）類型檢查經常使用方法
| 用法 | 類型 | 描述 | 舉例 |
|---|---|---|---|
| id(實例) | 內置函數 | 返回一個對象的身份（整數） | id(a)express |
| type(實例) | 內置函數 | 返回一個對象實例的類型 | type(a) |
| is | 運算符 | 比較2個對象是否同一身份 | a is b數組 type(a) is str框架 type(a) is type(b) # a與b是否同一類型函數 |
| isinstance(實例, 類名) | 內置函數 | 入參對象是不是入參類的實例 | isinstance(s, list) # s是否爲列表ui isinstance(f, Foo) # f是否爲Foo類的實例編碼 |
（3）經常使用內置函數
| 名稱 | 簡述 | 用法 | 舉例或說明 |
|---|---|---|---|
| 數學運算 | |||
| abs() | 返回一個數的絕對值 | abs(x) | abs(a) |
| pow() | x的y次方運算，將結果對z取模 | pow(x, y[,z]) | pow(2,3,3) # 結果爲2spa |
| round() | 將x按10的負n次取四捨五入 | round(x[, n=0]) | 舍入規則見下詳述 |
| divmod() | 將a除以b的商和餘數做爲元組返回 | divmod(a, b) | divmod(10,3) # 結果爲(3,1)代理 |
| 內置數據類型實例生成 | |||
| int() | 根據入參數字或字符串，生成整數實例 | int(x[, base=10]) | base默認爲10， 詳見下例 |
| float() | 根據入參數字或字符串，生成浮點數實例 | float(x) | float(3) # 結果爲3.0調試 |
| complex() | 生成複數實例 | complex(r[, i]) | 較少用到 |
| bool() | 生成布爾值實例 | bool([x]) | 不帶入參時默認返回False |
| list() | 生成列表實例 | list([iter]) | iter須是可迭代對象 |
| dict() | 生成字典實例 | dict([m]) | 詳見下述 |
| tuple() | 生成元組實例 | tuple([iter]) | iter須是可迭代對象 |
| str() | 生成字符串實例 | str([object]) | 入參object的__str__方法 |
| range() | 建立range實例 | range(stop) range(start, stop [,step]) |
range對象能夠用迭代、也可用切片訪問 |
| set() | 生成集合實例 | set([iter]) | iter須是可迭代對象 |
| frozenset() | 生成不可變集合實例 | frozenset([iter]) | iter須是可迭代對象 |
| slice() | 生成切片對象 | slice(stop) slice(start, stop [,step]) |
較少直接使用 |
| bytes() | 生成不可變字節數組實例 | bytes([source [,encoding [,errors]]]) | 詳見下述 |
| bytearray() | 生成可變字節數組實例 | bytearray([source [,encoding [,errors]]]) | 用法同上，內容可變 |
| memoryview() | 生成memoryview實例 | memoryview(obj) | 較少用到 |
| object() | 生成一個基類實例 | object() | 較少用到 |
| 編碼與解碼 | |||
| hex() | 將數值x用16進制字符串表示 | hex(x) | hex(16) # 結果爲'0x10' |
| oct() | 將數值x用8進制字符串表示 | oct(x) | oct(16) # 結果爲'0o20' |
| bin() | 將數值x用2進制字符串表示 | bin(x) | bin(8) # 結果爲'0b1000' |
| ord() | 將單字符轉換成utf-8數值 | ord(c) | ord('a') # 結果爲97 ord('數') # 結果爲25968 |
| chr() | 將數值x轉換成單字符字符串 | chr(x) | chr(97) # 結果爲'a' chr(25968) # 結果爲'數' |
| ascii() | 像repr()那樣顯示對象，非ASCII字符顯示爲轉義序列 | ascii(object) | 較少用到 |
| 序列操做 | |||
| len() | 返回s中包含的項數 | len(s) | s能夠是：列表、元組、字符串、集合、字典 |
| min() | 若是隻有1個參數s，返回s中各項的最小值。若是有多個參數，返回各個參數中的最小值。 | min(s[, args, ...]) | s能夠是可迭代對象 min([1,3,5]) # 結果爲1 min(1,3,5,7) # 結果爲1 |
| max() | 若是隻有1個參數s，返回s中各項的最大值。若是有多個參數，返回各個參數中的最大值。 | max(s[, args, ...]) | s能夠是可迭代對象 min([1,3,5]) # 結果爲5 min(1,3,5,7) # 結果爲7 |
| sum() | 計算可迭代對象iter中全部項的和，initial爲累加初始值，默認爲0。只能用於數值計算。 | sum(iter[ ,initial]) | sum([1,2,3]) # 結果爲6 sum([1,2,3], 10) # 結果爲16 |
| 迭代操做 | |||
| all() | 若可迭代對象iterable中的全部值都爲True，則返回True。 | all(iter) | all([0,1,2,3]) # 結果爲False |
| any() | 若可迭代對象iterable中的任意值爲True，則返回True。 | any(iter) | any([0,1,2,3]) # 結果爲True |
| enumerate() | 根據入參迭代器，產生一個新迭代器，其中每一個元素爲一個元組：內含一個計數值和原迭代出的值。 | enumerate(iter[ ,start=0]) | for i,x in enumerate(['a','b']) pass # 結果迭代出(0,'a'), (1,'b') |
| zip() | 產生一個新迭代器，第n個元素爲一個(s1[n], s2[n], ...)的元組，其長度爲最短的一個迭代器長度。 | zip([s1 [, s2 [, ...]]]) | a = [1,2,3] b = ['x','y'] for t in zip(a, b) pass # 迭代結果爲(1,'x'), (2,'y') |
| sorted() | 根據入參迭代器的內容排序，建立有序列表 | sorted(iter, *, key=None, reverse=False) | 詳見下述 |
| reversed() | 產生一個迭代器，將入參序列的全部元素位置顛倒（注意：跟sorted()徹底不一樣） | reversed(seq) | for x in reversed([1,2,'a']): pass # 迭代結果爲 'a', 2, 1 |
| filter() | 產生一個迭代器，其內容是對入參iter中的每一個元素使用func函數進行過濾，只有func返回True的才被加入新迭代器。 | filter(func, iter) | a = [1,2,3,4,5,6,7,8] filter(lambda x:x%2==1, a) # 迭代器中內容爲 1,3,5,7 |
| map() | 產生一個迭代器，其每一項是將函數func應用到iter中的每一項返回的結果。若入參有多個iter迭代器，則相應的函數func應有多個入參。 | map(func, iter, ...) | map(lambda x:x*2, [1,3,5,7]) # 迭代器中內容爲 2,6,10,14 |
| iter() | 返回一個可生成object中各項的迭代器。 | iter(object[ ,sentinel]) | 較少直接使用 |
| next() | 返回迭代器iter中的下一項。 | next(iter[ ,default]) | 較少直接使用 |
| 對象實例操做 | |||
| id() | 返回object的惟一整數標識符（這是一個內存位置）。 | id(object) | 結果爲一個整數，較少直接使用 |
| type() | 當單參數調用時，返回入參object的類型。當三參數調用時，建立一個新type對象（通常用於元類）。 | type(object) type(name, bases, dict) |
type(1) # 結果爲<class 'int'> type('a') # 結果爲<class 'str'> |
| isinstance() | 若是object是clsinfo類的一個實例，則返回True。clsinfo能夠是一個含多個類的元組。 | isinstance(object, clsinfo) | # 設有一個名爲Foo的自定義類 f = Foo() isinstance(f, Foo) # True isinstance(f, (Foo,list)) # True isinstance([1,2], (Foo,list)) # True isinstance(f, (list,tuple) # False |
| repr() | 返回object的字符串表示形式。 | repr(object) | 通常在類內部的__repr__()方法會定義本對象的字符串表示形式。 |
| dir() | 返回object對象的屬性名（含方法名）列表，若object是一個模塊，則返回其內部定義的符號列表。 | dir(object) | 若是類內部定義了__dir__屬性，則返回此值。 |
| hasattr() | 若name是object的屬性名，則返回True | hasattr(object, name) | 入參name是一個字符串 |
| getattr() | 返回對象的name屬性的值，若無此屬性，則default是可選的返回值，不然引發AttributeError。 | getattr(object, name [,default]) | a = getattr(obj, 'p1') # 效果同 a = obj.p1 |
| setattr() | 設置對象的屬性 | setattr(object, name, value) | setattr(obj, 'p1', a) # 效果同 obj.p1 = a |
| delattr() | 刪除對象的屬性 | delattr(object, name) | delattr(obj, 'p1') # 效果同 del obj.p1 |
| hash() | 返回對象的整數散列值。通常可變對象不會定義散列值，除非類內部定義了__hash__()方法。 | hash() | hash('abc') # 結果爲526986374 hash(3.14) # 結果爲1846836513 |
| callable() | 檢查一個對象是不是可調用的。但有時即使返回 True，object 仍然可能調用失敗。 | callable(object) | 對於函數、方法、lamdba表達式、類、實現了__call__()方法的類實例，它都返回True。 |
| 類操做 | |||
| staticmethod() | 建立在類中使用的靜態方法。 | staticmethod(func) | 通常經過@staticmethod裝飾器隱式調用該函數 |
| classmethod() | 建立在類方法。 | classmethod(func) | 通常經過@classmethod裝飾器隱式調用該函數 |
| issubclass() | 若是class是clsinfo的子類，或class是基於抽象基類clsinfo註冊的，則返回True。clsinfo能夠是一個含多個類的元組。 | issubclass(class, clsinfo) | issubclass(Foo, BaseFoo) # 結果爲 True issubclass(Foo, (BaseFoo,list) # 結果爲 True |
| super() | 返回一個代理對象，提供能夠調用基類中的方法的手段。type是當前子類名，object通常是self。 在Python3中，在子類方法中能夠省略type和object參數，直接簡寫成：super() |
super(type [,object]) | class B(A): def foo(self): # 調用基類A的foo方法 super(B,self).foo() # 在Python3中可簡寫成： # super().foo() |
| property() | 建立一個虛擬屬性。fget, fset, fdel分別爲自定義的屬性讀取、設置、刪除方法，doc爲文檔字符串。 | property(fget=None, fset=None, fdel=None, doc=None) | class C: def __init__(self): self._x = 'c' def gx(self): return self._x x=property(fget=gx, doc='a') # 定義了一個只讀的屬性x |
| 域操做 | |||
| globals() | 返回表明當前全局做用域的全部符號的字典。 | globals() | globals() |
| locals() | 返回表明當前局部做用域的全部符號的字典。 | locals() | locals() |
| vars() | 返回object的全部屬性和屬性值的字典對象，若是沒有入參，則至關於調用locals() | vars([object]) | vars(obj) |
| 輸入輸出與文件操做 | |||
| input() | 顯示prompt提示信息，並讀取一行輸入，將讀入內容不做任何修改做爲字符串返回。（Python3中取消了原raw_input()函數） | input([prompt]) | >>> input('pls ipt:') pls ipt:123 # 返回結果爲：'123'
|
| print() | 打印一系列值到屏幕上。入參中可設置：多個顯示對象之間的分隔符、換行符、輸出設備、強制刷新等，通常不用修改。 | print(*objects, sep=' ', end='\n', file=sys.stdout, flush=False) | 通常用於調試用 |
| open() | 打開文件並返回一個新文件對象。 | open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None) | 在文件操做章節詳細描述 |
| 雜項 | |||
| eval() | 計算入參表達式的值並返回結果。expr是一個字符串或代碼對象。globals和locals參數可指定操做時的全局和局部命名空間映射對象。 | eval(expr, globals=None, locals=None) | x = 1 y = eval('x+1') # 結果爲2 更詳細說明 |
| exec() | 執行Python語句，入參code能夠是字符串、文件或代碼對象。globals和locals參數可指定操做時的全局和局部命名空間映射對象。 | exec(code[, globals[, locals]]) | x = 1 code = """s = x + 1 print(s)""" exec(code) # 結果爲2 exec(code, {'x':10}) # 結果爲11 更詳細說明 |
| format() | 按照format_spec中的格式將value轉換爲有格式的字符串，該操做調用value.__format__()方法。 | format(value[, format_spec]) | 通常在格式化字符串時被隱式調用 |
| help() | 調用內置的幫助系統。object能夠是字符串（表示模塊名、類名、函數名、方法名、關鍵字、文檔主題名稱），若是是其餘類型的對象，則會出現與該對象有關的幫助界面。 | help([object]) | help('math') |
| compile() | 將source對象編譯爲代碼對象，結果可被用於eval()和exec()函數。 | compile(source, filename, mode, flags=0, dont_inherit=False, optimize=-1) | 若不是開發框架的話，通常用不到 |
| breakpoint() | Python3.7中新增的內置函數，用來設置程序運行時的斷點，程序運行到該函數時自動進入調試器。這是個方便函數，可讓你很方便地進入Pdb調試器（不用再顯式導入調試模塊等）。 | breakpoint(*args, **kwargs) | 在須要設置斷點的地方直接調用breakpoint()便可 |
● round(x[, n])
說明：
在Python3中，當被舍入數字爲5且爲第1位小數時，舍入規則以下：若被舍入數字的前一個數爲偶數，則朝0方向進行四捨五入；不然遠離0，正負數都遵循這個規則。其它位的四捨五入不適用此規則，依舊按照普通數學規則進行。
舉例：
>>> round(2.5) # 結果爲2 >>> round(-2.5) # 結果爲2 >>> round(3.5) # 結果爲4 >>> round(-3.5) # 結果爲4
● int(x[, base])
說明：
x能夠是數字或字符串，base是入參的轉換進制基數，能夠是二、八、1六、16等，轉換結果老是10進制整數。
舉例：
>>> int('100') # 結果爲100
>>> int('100', 10) # 結果爲100
>>> int('100', 16) # 結果爲256
>>> int('100', 2) # 結果爲4
● dict([m])
說明：
入參m如果字典，則dict(m)就建立一個m淺複製。若m不是字典，則必須可以產生(key, value)形式的迭代值。也可用關鍵字建立字典，見下例。
舉例：
>>> dict('a'=1, 'b'=2) # 結果爲{'a':1, 'b':2}
>>> dict() # 結果爲空字典{}
● bytes([source [,encoding [,errors]]])
說明：
生成不變字節數組，入參source爲原始輸入字符串，入參encoding指定要使用的字符編碼方式。
舉例：
>>> x = bytes() # 結果爲空字節數組 b'' >>> x = b'' # 結果同上 >>> x = bytes('abc') # 結果爲 b'abc' >>> x = bytes('ab數字', 'utf-8') # 結果爲 b'ab\xe6\x95\xb0\xe5\xad\x97'
● sorted(iter, *, key=None, reverse=False)
說明：
根據iter迭代器中的各項值的內容進行排序（從小到大），建立有序列表，通常只能對數字或字符串進行排序。key是個單參數函數，能夠對元素在被排序前進行預處理，將一些常規來講不能排序的元素預處理成可排序的數字或字符串。reverse是個標誌位，用以指出是否逆序（從大到小）排序。（注意：Python3最新版本中已廢除了cmp參數）
舉例：
>>> sorted([1,7,3,5]) # 結果爲[1,3,5,7] >>> sorted([1,7,3,5], reverse=True) # 結果爲[7,5,3,1] >>> sorted(['c','b','a']) # 結果爲['a','b','c'] >>> sorted([('b',2),('a',1)], key=lambda x:x[1]) # 結果爲[('a',1),('b',2)] >>> # 上例說明：入參列表中的元素爲元組，通常不能排序。但這裏用lambda生成了一個匿名函數，對元素進行預處理，取出每一個元素元組中的數字，而後用這個數字做爲排序依據，給sorted()函數進行排序
● 舊版raw_input()用法
說明：
在Python3中的input()函數至關於Python2中的raw_input()函數。而在Python2中的input()函數中，用戶在輸入字符串內容時必須帶上引號，不然會報錯（非字符串類型則不須要引號）。因此在Python2中，通常儘可能使用raw_input()函數。
舉例：
x = input('x:') # 用戶必須輸入帶引號的字符串：'abc'，不然會報錯
x = raw_input('x:') # 用戶能夠直接輸入：abc，系統會自動將其轉換爲字符串
● eval(expr, globals=None, locals=None)
說明：
eval()計算字符串形式的表達式或代碼對象expr，並返回計算結果。其中globals和locals參數可指定操做時的全局和局部命名空間，若是省略，就使用當前實際的全局和局部命名空間中的值。
舉例：
# 例1：
x = eval(input('Enter an expression:')) # 用戶若輸入：1+2*3，返回值爲7
# 例2：
scope = {'x':2, 'y':3}
eval('x+y', scope) # 至關於在scope命名空間中運行eval()，結果爲5
● exec(code[, globals[, locals]])
說明：
exec在Python2中是一個語句，exec()在Python3中是內置函數，exec()最有用的地方在於能夠動態地建立代碼字符串。其中globals和locals參數可指定操做時的全局和局部命名空間，若是省略，就使用當前實際的全局和局部命名空間中的值。
因爲每次執行exec()或eval()時，Python都要編譯一次入參字符串，這個比較耗資源。若是某個代碼字符串要反覆執行屢次，最好是先編譯代碼，而後在後續的調用中使用編譯過的code對象。詳見後面的例子。
舉例：
# 例1：
x = 1
scope = {}
exec('x=2', scope) # 在命名空間scope中運行賦值語句，因此x僅在scope範圍爲2，在實際的全局空間中仍爲1
# 例2：
s = 'for i in range(100): print(i)'
code = compile(s, '', 'exec') # 將要執行的字符串代碼先進行編譯
exec(code) # 執行剛纔已編譯過的代碼
（4）程序結構的數據類型
在Python中，函數、類、方法、模塊等等均可以看成數據操做的對象，下表爲表示程序自己各類元素的類型。
| 分類 | 類型名稱 | 描述 |
|---|---|---|
| 可調用 | types.BuiltinFunctionType | 內置函數或方法 |
| types.FunctionType | 用於定義的函數（包括lambda匿名函數） | |
| types.MethodType | 類中定義的方法 | |
| type | 由於類自己也是能夠被調用的，因此這裏也列一下。 | |
| object | 由於類自己也是能夠被調用的，因此這裏也列一下。 | |
| 模塊 | types.ModuleType | 模塊 |
| 類型 | type | 內置數據類型和類的類型 |
| 根類 | object | 全部類型和類的祖先 |
- 1. Python-數據類型內置方法(1)
- 2. Python-數據類型內置方法(2)
- 3. Python 內置函數速查表
- 4. Python語法速查： 7. 函數基礎
- 5. Go語言內置類型和函數
- 6. JS數據類型(1)：數據類型與內存空間
- 7. hive查詢語法-數據類型-函數-綜合（twenty-four day）
- 8. Python基礎語法 - 第1關 數據類型與轉換
- 9. Python 內置函數1
- 10. 1三、大數據之Hive參數配置與內置函數
- 更多相關文章...
- • Rust 數據類型 - RUST 教程
- • R 數據類型 - R 語言教程
- • Flink 數據傳輸及反壓詳解
- • Kotlin學習（二）基本類型
-
每一个你不满意的现在，都有一个你没有努力的曾经。