Python解釋器可以自動識別用戶輸入的數據類型。創建對象的數據類型，可以通過type查看。需要注意的是：用戶通過input輸入的數據，其類型均為字符串

num1 = input("please input num1: ") num2 = input("please input num2: ") print("type of num1: ",type(num1),"type of num2: ",type(num2)) please input num1: test please input num2: 123 type of num1: <class 'str'> type of num2: <class 'str'>

整型

整型可分為整型（32位機器上整型的取值范圍為：-2* * 31~-2* *31）和長整型。Python2.7中會自動轉換數字為整型、長整型。但在Python3.6中，不再有整型長整型之分。
Python中提供了10進制轉換為其他進制的方法

• 十進制轉十六進制

>>> hex(10) '0xa'

• 十進制轉八進制

>>> oct(10) '0o12'

• 十進制轉二進制

>>> bin(10) '0b1010'

在浮點數中，Python默認的精度為17位，這個精度越到后面越不準確。當我們的計算需要使用更高精度的時候，可以使用“getcontext”和"Decimal"的方式來實現

>>> a = 3.141592653002154564564 >>> a 3.1415926530021547 >>> from decimal import * >>> getcontext() Context(prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999, capitals=1, clamp=0, flags=[], traps=[InvalidOperation, DivisionByZero, Overflow]) >>> getcontext().prec = 50 >>> a = Decimal(1)/Decimal(3) >>> a Decimal('0.33333333333333333333333333333333333333333333333333')

整型的常用方法

int：強制類型轉換

>>> a = "0xa" >>> print(int(a,base=16)) 10

bit_length：整數轉換成二進制后所占最少bit位數

>>> a = 10 >>> print(a.bit_length()) 4 >>> print(bin(a)) 0b1010

布爾型

包含True（非0）和False（0）。注意首字母大寫。以下內容均為False：

• None，空；
• ""，空字符串
• ()，空元祖；
• []，空列表；
• {}，空字典
• 數值0（整型、浮點型、復數）；

a = ("", (), [], {}, 0, 1, 1.1, 0.0, 0+0j,) for i in a :if i :print("it is True.",i)else :print("it is False.",i) it is False. it is False. () it is False. [] it is False. {} it is False. 0 it is True. 1 it is True. 1.1 it is False. 0.0 it is False. 0j

列表

• 列表的形式：使用中括號括起來

list #類，列表 li = [1,2,3,"li","liu"] #通過list類創建的對象

• 列表可以嵌套使用：

>>> li = ["test",223,"123",["12","ads"],{"name":"tuple"}] >>> print(li[4]["name"]) tuple

• 列表中的元素可以是：數字、字符串、列表、布爾值、字典（注意字典的無序特性）
• 對列表進行切片后，所得到的數據還是列表

>>> li = ["test",223,"123",["12","ads"],{"name":"tuple"}] >>> print(li[0:2],type(li[0:3])) ['test', 223] <class 'list'>

• 支持for、while循環提取所有子序列

li = ["test",223,"123",["12","ads"],{"name":"tuple"}] l = len(li) num = 0 for i in li :print(i) while num < l :print(li[num])num += 1

• 字符串在內存中的地址是連續的，所以字符串的數值一旦發生改變，就需要重新開辟新的內存空間。而列表不一樣，它的子序列的存儲地址是非連續的，元素的內容可以被修改，被修改后元素對應的內存地址不會發生改變。這是因為每個元素是采用鏈表的形式存儲的（即每個元素的內存空間中，不僅存放了元素的數值，而且還有下一個元素的內存地址）。列表的元素可以使用索引進行修改，也可以使用切片的方法進行修改

>>> li = ["test",223,"123",["12","ads"],{"name":"tuple"}] >>> li[1] = "liu" >>> li[2:4] = ["liu",234] >>> print(li) ['test', 'liu', 'liu', 234, {'name': 'tuple'}]

• 列表元素的刪除

>>> li = ["test",223,"123",["12","ads"],{"name":"tuple"}] >>> del li[0] >>> del li[0:2] >>> print(li) [['12', 'ads'], {'name': 'tuple'}]

• 如果列表的元素中存在列表或者字符串的話，可以對元素再進行索引或切片
• 如果將一個字符串轉換成list后，會將字符串中的每個元素轉換成列表。int類型的對象不能轉換成list

>>> string = "python" >>> print(list(string)) ['p', 'y', 't', 'h', 'o', 'n']

• 列表轉換成字符串的時候，需要自己寫for循環。當列表中的元素只有字符串時，可以直接使用join

li = ["test",223,"123",["12","ads"],{"name":"tuple"}] l = len(li) r = range(0,l) s = "" for i in r :s += str(li[i]) print(s) li02 = ["liu","hao","hai"] print("".join(li02)) test223123['12', 'ads']{'name': 'tuple'} liuhaohai

列表的常用方法

append：在列表元素的最后進行追加（不需要對append進行賦值操作）

>>> li = ["asd","fgh","liu"] >>> li.append("hai") >>> li.append(["lhh",123]) >>> print(li) ['asd', 'fgh', 'liu', 'hai', ['lhh', 123]]

clear：清空列表

>>> li = ["asd","fgh","liu"] >>> li.clear() >>> print(li) []

copy：（淺）拷貝

>>> li = ["asd","fgh","liu"] >>> v = li.copy() >>> print(v) ['asd', 'fgh', 'liu']

count：計算列表中元素出現的次數

>>> li = [11,22,33,22,11] >>> print(li.count(22)) 2

extend：將extend后參數中每一個元素迭代append到原列表中。注意和append的區別

>>> li = [11,22,33,22,11] >>> li.extend(["asd",44]) >>> print(li) [11, 22, 33, 22, 11, 'asd', 44] >>> li.append(["asd",44]) >>> print(li) [11, 22, 33, 22, 11, 'asd', 44, ['asd', 44]]

index：查看指定元素在列表中的下標

>>> li = [11,22,33,22,11] >>> print(li.index(22)) 1 >>> print(li.index(23)) Traceback (most recent call last):File "<stdin>", line 1, in <module> ValueError: 23 is not in list

insert：在列表中指定的下標前插入對象

>>> li = [11,22,33,22,11] >>> print(li.insert(1,["lhh",360])) None >>> li.insert(1,["lhh",360]) >>> print(li) [11, ['lhh', 360], ['lhh', 360], 22, 33, 22, 11]

pop：剔除指定下標的元素（默認剔除最后一個），并提取該元素的數值

>>> li = [11,22,33,22,11] >>> li.pop(2) 33 >>> print(li) [11, 22, 22, 11]

remove：從左開始刪除指定元素，當列表中同時存在多個相同的元素是，刪除第一個匹配的元素

>>> li = [11,22,33,22,11] >>> li.remove(22) >>> print(li) [11, 33, 22, 11]

reverse：將列表中的元素反轉顯示

>>> li = [1,2,3,4] >>> li.reverse() >>> print(li) [4, 3, 2, 1]

sort：將列表中的元素進行排序（默認為升序：reverse=False）

>>> li = [1,2,3,4,8,5] >>> li.sort() >>> print(li) [1, 2, 3, 4, 5, 8] >>> li = [1,2,3,4,8,5] >>> li.sort(reverse=True) >>> print(li) [8, 5, 4, 3, 2, 1]

元祖

• 表現形式：使用小括號括起來的。元祖中的低級元素不可被修改，不支持增加刪除

>>> tuple1 = (12,"dad",True,[12,23],(2,3,4),{"name":"lhh"}) >>> print(tuple1) (12, 'dad', True, [12, 23], (2, 3, 4), {'name': 'lhh'}) >>> tuple1[0] = "123" Traceback (most recent call last):File "<stdin>", line 1, in <module> TypeError: 'tuple' object does not support item assignment >>> tuple1[3][1] = "lhh" >>> print(tuple1) (12, 'dad', True, [12, 'lhh'], (2, 3, 4), {'name': 'lhh'})

• 元組中的元素可以是：字符串、數字、布爾值、列表、元組、字典
• 為了防止和類的方法混淆，一般元祖的最后，加上一個“，”，而元祖的長度不會發生變化
• 可以使用索引、切片查看元祖的元素，但是不能對元素增刪。可以被for/while循環

>>> tuple1 = (12,"dad",True,[12,23],(2,3,4),{"name":"lhh"}) >>> print(tuple1[0:3]) (12, 'dad', True) >>> for i in tuple1 : ... print(i) ... 12 dad True [12, 23] (2, 3, 4) {'name': 'lhh'}

• 字符串、列表都可以轉換為元祖

>>> string = "python" >>> li = ["lhh",360,True] >>> print(tuple(string),tuple(li),sep="\n") ('p', 'y', 't', 'h', 'o', 'n') ('lhh', 360, True)

• 元祖可以轉換成字符串、列表

>>> tu = (123,"asd",True) >>> print(list(tu)) [123, 'asd', True] tu = (123,"asd",True) s = "" for i in tu :s += str(i) print(s) 123asdTrue

元組的常用方法

count：統計元祖中指定元素出現的次數

>>> tu = (11,22,33,2,22,) >>> print(tu.count(22)) 2

index：統計指定元素在元組中的下標。出現多個相同元素時，從左開始取第一個匹配的下標

>>> tu = (11,22,33,2,22,) >>> print(tu.index(22)) 1

字典

• 形式：使用大括號括起來。字典的鍵值對（key:value）中，value的類型可以是任意數據類型

  info = { "k1":"string", "k2":123, "k3":False, "k4":(123,"sd","hda"), "k5":["sdf",23], "k6":{"kk1":"sdf","kk2":123 } } print(info) {'k1': 'string', 'k2': 123, 'k3': False, 'k4': (123, 'sd', 'hda'), 'k5': ['sdf', 23], 'k6': {'kk1': 'sdf', 'kk2': 123}}

• 列表、字典不能作為字典的key

  info = { 1:"string", False:123, (11,22):False, #[11,22]:123, #{"k1":"v1"}:123 } print(info) {1: 'string', False: 123, (11, 22): False}

• 字典是無序的，無法通過切片的方式讀取元素的值。可以通過Key值，使用索引讀取某一個元素

>>> info = {1: 'string', False: 123, (11, 22): False} >>> print(info[1]) string

• 可以使用for循環提取字典中的key、value、key和value

info = {1:"string",False:123,(11,22):False, } for i in info :print(i) for i in info.keys() :print(i) for i in info.values() :print(i) for i in info.items() :print(i) for i,j in info.items() :print(i,j) 1 False (11, 22) 1 False (11, 22) string 123 False (1, 'string') (False, 123) ((11, 22), False) 1 string False 123 (11, 22) False

• 字典元素的刪除

info = {"k1":"v1",1:True,("k3"):{"kk1":"lhh","kk2":123,"kk3":False,} } del info[("k3")]["kk3"] print(info) {'k1': 'v1', 1: True, 'k3': {'kk1': 'lhh', 'kk2': 123}}

字典的常用方法

clear ：清空字典中的所有元素

>>> info = {1: 'string', False: 123, (11, 22): False} >>> info.clear() >>> print(info) {}

copy：（淺）拷貝

>>> info = {1: 'string', False: 123, (11, 22): False} >>> info_bak = info.copy() >>> print(info_bak) {1: 'string', False: 123, (11, 22): False}

fromkeys：根據序列，創建字典，并為key指定統一的value。使用格式為dict.fromkyes()，而不是"dict類名稱.fromkey()"。fromkeys方法后最多只能只能有2個參數，分別對應key/value。當只有1個參數時，創建的字典的value為None

>>> dict.fromkeys(("asdf",123,False)) {'asdf': None, 123: None, False: None} >>> dict.fromkeys(("asdf",123,False),123) {'asdf': 123, 123: 123, False: 123}

get：根據key，獲取value的值。如果key不存在，返回指定的值

>>> info = {1: 'string', False: 123, (11, 22): False} >>> print(info.get(1)) string >>> print(info.get(True)) string >>> print(info.get("None")) None >>> print(info.get("None","space")) space

items：返回字典中的keys和values

>>> info = {1: 'string', False: 123, (11, 22): False} >>> info.items() dict_items([(1, 'string'), (False, 123), ((11, 22), False)])

keys：返回字典中的Keys

>>> info = {1: 'string', False: 123, (11, 22): False} >>> info.keys() dict_keys([1, False, (11, 22)])

pop：刪除字典中指定key對應的鍵值對。如果key在字典中不存在，則返回None或者指定的值

>>> info = {1: 'string', False: 123, (11, 22): False} >>> info.pop(False) 123 >>> print(info) {1: 'string', (11, 22): False} >>> info.pop("space","NONE") 'NONE' >>> print(info) {1: 'string', (11, 22): False}

popitem：刪除字典最后一個元素，返回值為該元素的key:value

>>> info = {1: 'string', False: 123, (11, 22): False,"k1":"v1","k2":"v2"} >>> info.popitem() ('k2', 'v2') >>> n,m = info.popitem() >>> print(n,m) k1 v1

setdefault：設置字典元素的value值。如果元素中有存在的Key，不做任何操作；如果元素中沒有對應的key，則在字典中的最后添加一個元素，元素對應的key:value，就是setdefault的2個參數

>>> info = {1: 'string', False: 123, (11, 22): False,"k1":"v1","k2":"v2"} >>> info = {1: 'string', False: 123, (11, 22): False} >>> info.setdefault(1,"STR") 'string' >>> print(info) {1: 'string', False: 123, (11, 22): False} >>> info.setdefault("k1","value") 'value' >>> print(info) {1: 'string', False: 123, (11, 22): False, 'k1': 'value'}

update：更新字典元素對應的value。如果key不存在的則直接添加這個key:value，如果存在，則修改這個key對應的value值

>>> info = {1: 'string', False: 123, (11, 22): False} >>> info.update({1:"new_str"}) >>> print(info) {1: 'new_str', False: 123, (11, 22): False}

values：獲取字典元素的value值

>>> info = {1: 'string', False: 123, (11, 22): False} >>> print(info.values()) dict_values(['string', 123, False])

可變數據類型和不可變數據類型

根據對象元素的數值是否可被修改，可以將數據類型分為可變數據類型和不可變數據類型。到目前為止，不可變數據類型有：整型、字符串、元祖。可變數據類型有：列表、字典。可變數據類型是能夠被hash的。如果一個對象不能被hash的話，那么這個對象一定為可變數據類型。

轉載于:https://www.cnblogs.com/hurst/p/10065134.html

總結

以上是生活随笔為你收集整理的Python数据类型——整型、布尔型、列表、元祖、字典的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。