文章收集于網(wǎng)絡(luò)，如有版權(quán)，請聯(lián)系作者

一、引子

1 什么是數(shù)據(jù)？

x=10，10是我們要存儲的數(shù)據(jù)

2 為何數(shù)據(jù)要分不同的類型

數(shù)據(jù)是用來表示狀態(tài)的，不同的狀態(tài)就應(yīng)該用不同的類型的數(shù)據(jù)去表示

3 數(shù)據(jù)類型

數(shù)字、字符串、列表、元組、字典、集合

二、基礎(chǔ)數(shù)據(jù)類型

2.1 數(shù)字 int

數(shù)字主要是用于計算用的，使用方法并不是很多，就記住一種就可以：
int() 可以把其他類型轉(zhuǎn)化為數(shù)字類型，并自動除去空格，但是前提是轉(zhuǎn)化的數(shù)字

# bit_length() 當(dāng)十進制用二進制表示時，最少使用的位數(shù) v = 11 data = v.bit_length() print(data)

2.2 布爾值bool

布爾值就兩種：True，False

真 ? 1 ? True 假 ? 0 ? Falseint:0?? list:[]?? tuple:{}?? str:'' 轉(zhuǎn)化為布爾值是False，其他的都是True

2.3 字符串str

2.3.1?字符串的索引與切片。

索引即下標，就是字符串組成的元素從第一個開始，初始索引為0，以此類推。

a = 'ABCDEFGHIJK' print(a[0]) # A print(a[3]) # D print(a[-1]) # K

切片就是通過索引（索引：索引：步長）截取字符串的一段，形成新的字符串（原則就是顧頭不顧腚）。

a = 'ABCDEFGHIJK' print(a[0:3]) print(a[2:5]) print(a[0:]) # 默認到最后 ABCDEFGHIJK print(a[0:-1]) # -1 是列表中最后一個元素的索引，但是要滿足顧頭不顧腚的原則，所以取不到K元素 print(a[0:5:2]) # 加步長 ACE print(a[5:0:-2]) # 反向加步長 FDB

2.3.2、字符串常用方法。

# 大小寫轉(zhuǎn)化 captalize,swapcase,title name = 'flp' print(name.capitalize()) # 首字母大寫 print(name.swapcase()) # 大小寫翻轉(zhuǎn) msg='i love china' print(msg.title()) # 每個單詞的首字母大寫# 內(nèi)容居中 center a1 = 'abcdefgabcd' ret2 = a1.center(20,"*") # 內(nèi)容居中（總長度，空白處填充） print(ret2)# 統(tǒng)計字符串出現(xiàn)元素個數(shù) count ret3 = a1.count("a",0,4) # 字符串中的元素出現(xiàn)的個數(shù)，可切片(元素，開始位置，結(jié)束位置) print(ret3)# \t補全 a2 = "hqw\t" ret4 = a2.expandtabs() # 默認將一個tab鍵變成8個空格，如果tab前面的字符長度不足8個，則補全8個，如果tab鍵前面的字符長度超過8個不足16個則補全16個，以此類推每次補全8個 print(ret4)# 判斷字符串開頭結(jié)尾 可切片startswith，endswith a4 = "dkfjdkfasf54" ret4 = a4.startswith('jdk',3,6) # 判斷是否以...開頭，顧頭不顧腚，返回的是布爾值 print(ret4) ret5 = a4.endswith("kfj",1,4) # 判斷是否以...結(jié)尾，顧頭不顧腚，返回的是布爾值 print(ret5)# 判斷字符串中的元素是否存在 可切片find index ret6 = a4.find("fjdk",1,6) # 返回的找到的元素的索引，如果找不到返回-1 print(ret6) ret61 = a4.index("fjdk",4,6) # 返回的找到的元素的索引，找不到報錯 print(ret61) # 注：在用find判斷字符不存在時，用下列的方式，因為不存在返回值是-1。 # if a4.find("fjdk",1,6) == -1# split 分割，最終形成一個列表此列表不含有這個分割的元素。 a5 = 'title,Tilte,atre,' ret9 = a5.split('t') print(ret9) # 結(jié)果['', 'i', 'le,Til', 'e,a', 're,'] ret91 = a5.rsplit('t',1) print(ret91) # 結(jié)果['title,Tilte,a', 're,'] ret92 = a5.rsplit('t',2) print(ret92) # 結(jié)果['title,Til', 'e,a', 're,']# format的三種玩法 格式化輸出 res='{} {} {}'.format('egon',18,'male') # 結(jié)果 egon,18,male res='{1} {0} {1}'.format('egon',18,'male') # 結(jié)果 18,egon,18 res='{name} {age} {sex}'.format(sex='male',name='egon',age=18)# strip切除字符串開頭或結(jié)尾的字符 name='*egon**' print(name.strip('*')) # 切除字符串開頭和結(jié)尾包含的* print(name.lstrip('*')) # 切除字符串開頭包含的* print(name.rstrip('*')) # 切除字符串結(jié)尾包含的*# replace字符串替換 name='flp China name is flp' print(name.replace('flp','shuai',1)) #（要替換的字符串，替換成的字符串，替換的個數(shù)）# is系列 name='flp123' print(name.isalnum()) # 字符串由字母或數(shù)字組成，返回布爾值 print(name.isalpha()) # 字符串只由字母組成，返回布爾值 print(name.isdigit()) # 字符串只由數(shù)字組成，返回布爾值# 判斷字符串是否為空 s=' ' if s.strip()=='':print('s is null') # 或者 if not s.strip():print('s is null')

?2.4 元祖tuple

元組被稱為只讀列表，即數(shù)據(jù)可以被查詢，但不能被修改，所以，字符串的切片操作同樣適用于元組。例：（1，2，3）（"a","b","c"）

?2.5 列表list

列表是python中的基礎(chǔ)數(shù)據(jù)類型之一，其他語言中也有類似于列表的數(shù)據(jù)類型，比如js中叫數(shù)組，他是以[]括起來，每個元素以逗號隔開，而且他里面可以存放各種數(shù)據(jù)類型比如：

li = [123,Ture,(1,2,3,’abc’),[1,2,3,’小明’,],{‘name’:’abc’}]

列表相比于字符串，不僅可以儲存不同的數(shù)據(jù)類型，而且可以儲存大量數(shù)據(jù)，32位python的限制是 536870912 個元素,64位python的限制是 1152921504606846975 個元素。而且列表是有序的，有索引值，可切片，方便取值。

2.5.1、增

li = [1,'a','b',2,3,'a'] li.insert(0,55) # 按照索引去增加 print(li) # [55, 1, 'a', 'b', 2, 3, 'a']li.append('aaa') # 增加到最后 li.append([1,2,3]) print(li) # [55, 1, 'a', 'b', 2, 3, 'a', 'aaa', [1, 2, 3]]li.extend(['q,a,w']) # 迭代的去增 li.extend(['q,a,w','aaa']) li.extend('a') li.extend('abc') li.extend('a,b,c') print(li) # [55, 1, 'a', 'b', 2, 3, 'a', 'aaa', [1, 2, 3], 'q,a,w', 'q,a,w', 'aaa', 'a', 'a', 'b', 'c', 'a', ',', 'b', ',', 'c']

2.5.2、刪

li = [1,'a','b',2,3,'a'] l1 = li.pop(1) # 按照位置去刪除，有返回值，返回被刪除的元素 print(l1,li) # a [1, 'b', 2, 3, 'a']del li[1:3] # 按照位置去刪除，也可切片刪除沒有返回值。 print(li) # [1, 3, 'a']li.remove('a') # 按照元素去刪除 print(li) # [1, 3]li.clear() # 清空列表

2.5.3、改

li = [1,'a','b',2,3,'a'] li[1] = 'dfasdfas' print(li) # [1, 'dfasdfas', 'b', 2, 3, 'a']li[1:3] = ['a','b'] print(li) # [1, 'a', 'b', 2, 3, 'a']

2.5.4、查

切片去查，或者循環(huán)去查。

2.5.5、其他操作

# count 統(tǒng)計某個元素在列表中出現(xiàn)的次數(shù) a = ["q","w","q","r","t","y"] print(a.count("q")) # index 用于從列表中找出某個值第一個匹配項的索引位置 a = ["q","w","r","t","y"] print(a.index("r")) # sort 用于在原位置對列表進行排序，沒有返回值 a = [2,1,3,4,5] a.sort() # 他沒有返回值，所以只能打印排序后的a print(a)# reverse 將列表中的元素反向存放，也沒有返回值 a.reverse() # 他也沒有返回值，所以只能打印排序后的a print(a)

?2.6字典dict

字典是python中唯一的映射類型，采用鍵值對（key-value）的形式存儲數(shù)據(jù)。python對key進行哈希函數(shù)運算，根據(jù)計算的結(jié)果決定value的存儲地址，所以字典是無序存儲的，且key必須是可哈希的?？晒１硎緆ey必須是不可變類型，如：數(shù)字、字符串、元組。

字典(dictionary)是除列表外，python之中最靈活的內(nèi)置數(shù)據(jù)結(jié)構(gòu)類型。列表是有序的對象結(jié)合，字典是無序的對象集合。兩者之間的區(qū)別在于：字典當(dāng)中的元素是通過鍵來存取的，而不是通過偏移存取。

2.6.1、增

dic = {} dic['li'] = ["a","b","c"] print(dic) # {'li': ['a', 'b', 'c']} # setdefault 在字典中添加鍵值對，如果鍵對應(yīng)的值是none,則添加；如果值不為空，則不會更改覆蓋。 dic.setdefault('k','v') print(dic) # {'age': 18, 'name': 'jin', 'sex': 'male', 'k': 'v'} dic.setdefault('k','v1') print(dic) # {'age': 18, 'name': 'jin', 'sex': 'male', 'k': 'v'}

2.6.2、刪

dic_pop = dic.pop("a",'無key默認返回值') # pop根據(jù)key刪除鍵值對，并返回對應(yīng)的值，如果沒有key則返回默認返回值 print(dic_pop)del dic["name"] # 沒有返回值。 print(dic)dic_pop1 = dic.popitem() # 隨機刪除字典中的某個鍵值對，將刪除的鍵值對以元祖的形式返回 print(dic_pop1) dic_clear = dic.clear() # 清空字典 print(dic,dic_clear) # {} None

注：在循環(huán)字典本身的時候，不能刪除字典的鍵值對

2.6.3、改

dic = {"name":"jin","age":18,"sex":"male"} dic2 = {"name":"alex","weight":75} dic2.update(dic) # 將dic所有的鍵值對覆蓋添加（相同的覆蓋，沒有的添加）到dic2中 print(dic2) # {'name': 'jin', 'weight': 75, 'age': 18, 'sex': 'male'}

2.6.4、查

value1 = dic["name"] # 沒有會報錯 print(value1)value2 = dic.get("djffdsafg","默認返回值") # 沒有可以返回設(shè)定的返回值 print(value2)

2.6.5、其他操作

item = dic.items() print(item,type(item)) # dict_items([('age', '18'), ('sex', 'male')) <class 'dict_items'>這個類型就是dict_items類型，可迭代的keys = dic.keys() print(keys,type(keys)) # dic的所有kvalues = dic.values() print(values,type(values)) # dic的所有值# 字典的循環(huán)。 dic = {"age":18,"sex":"male"} for key in dic:print(key) for item in dic.items():print(item) for key,value in dic.items():print(key,value)# 判斷值是否在字典中 if 'age' in dic.keys: if 'age' in dic:# fromkeys(seq[, value]) 函數(shù)用于創(chuàng)建一個新字典，以序列 seq 中元素做字典的鍵，value 為字典所有鍵對應(yīng)的初始值。 dict.fromkeys(seq[, value])seq -- 字典鍵值列表。value -- 可選參數(shù), 設(shè)置鍵序列（seq）的值。seq = ('Google', 'Runoob', 'Taobao') dict = dict.fromkeys(seq) print "新字典為 : %s" % str(dict) # 新字典為 : {'Google': None, 'Taobao': None, 'Runoob': None}dict = dict.fromkeys(seq, 10) print "新字典為 : %s" % str(dict) # 新字典為 : {'Google': 10, 'Taobao': 10, 'Runoob': 10}

?2.7?集合set

集合：可變的數(shù)據(jù)類型，他里面的元素必須是不可變(可哈希)的數(shù)據(jù)類型，無序，不重復(fù)

去重：把一個列表變成集合會自動去重

關(guān)系測試是，測試兩組數(shù)據(jù)之前的交集，差集，并集等關(guān)系

創(chuàng)建

set1 = set(1,2,abc)

增

set1.add('dong') set1.update([1,2,3])

刪

set1.remove('a') # 刪除一個元素 set1.pop('b') # 隨機刪除一個，有返回值，返回值為刪除的元素 set1.clear() # 清除set del set1 # 刪除set1

查

for i in set1 :print(i)

關(guān)系測試

set1 = {1,2,3,4,'a'} set2 = {'a','b','c','d',1} print(set1 & set2) print(set1.intersection(set2)) # 交集{1, 'a'}print(set1 | set2) print(set2.union(set1)) # 并集{1, 2, 3, 4, 'd', 'b', 'c', 'a'}print(set1 - set2) print(set1.symmetric_difference(set2)) # 差集，set1獨有的{2, 3, 4}print(set1 ^ set2) print(set1.difference(set2)) # 反交集{2, 3, 4, 'c', 'd', 'b'}print(set1 > set2) print(set1.issubset(set2)) # 這兩個相同，都是說明set1是set2子集。print(set2 < set2) print(set2.issuperset(set1)) # 這兩個相同，都是說明set2是set1超集。

三丶基礎(chǔ)數(shù)據(jù)類型的總結(jié)

按存儲空間的占用分（從低到高）

數(shù)字

字符串

集合：無序，即無序存索引相關(guān)信息

元組：有序，需要存索引相關(guān)信息，不可變

列表：有序，需要存索引相關(guān)信息，可變，需要處理數(shù)據(jù)的增刪改

字典：無序，需要存key與value映射的相關(guān)信息，可變，需要處理數(shù)據(jù)的增刪改

按存值個數(shù)區(qū)分

標量／原子類型	數(shù)字，字符串
容器類型	列表，元組，字典

按可變不可變區(qū)分

可變	列表，字典
不可變	數(shù)字，字符串，元組，布爾值

按訪問順序區(qū)分

直接訪問	數(shù)字
順序訪問（序列類型）	字符串，列表，元組
key值訪問（映射類型）	字典

四丶其他（for，enumerate，range）

for循環(huán)：用戶按照順序循環(huán)可迭代對象的內(nèi)容。

msg = 'Lepeng最帥' for item in msg:print(item)li = ['趙','錢','孫','李'] for i in li:print(i)dic = {'name':'Lepeng','age':18,'sex':'man'} for k,v in dic.items():print(k,v)

enumerate：枚舉，對于一個可迭代的（iterable）/可遍歷的對象（如列表、字符串），enumerate將其組成一個索引序列，利用它可以同時獲得索引和值。

li = ['趙','錢','孫','李'] for i in enumerate(li):print(i) for index, name in enumerate(li, 100): # 起始位置默認是0，可更改print(index, name) # 100 趙 # 101 錢 # 102 孫 # 103 李

range：指定范圍，生成指定數(shù)字。

for i in range(1,10):print(i)for i in range(1,10,2): # 步長print(i)

join：用于將序列中的元素以指定的字符連接生成一個新的字符串。

語法：? 'sep'.join(seq)

參數(shù)說明

sep：分隔符，可以為空

seq：要連接的元素序列、字符串、元組、字典

上面的語法即：以sep作為分隔符，將seq所有的元素合并成一個新的字符串,然后返回

示例 s1 = "-" s2 = "" seq = ("r", "u", "n", "o", "o", "b") # 字符串序列 print (s1.join( seq )) # r-u-n-o-o-b print (s2.join( seq )) # runoob

五，判斷是否是字符串，字典等（isinstance）

在實際寫程序中，經(jīng)常要對變量類型進行判斷，除了用type(變量)這種方法外，還可以用isinstance方法判斷：

#!/usr/bin/env python a = 1 b = [1,2,3,4] c = (1,2,3,4) d = {'a':1,'b':2,'c':3} e = "abc" if isinstance(a,int):print "a is int" else:print "a is not int" if isinstance(b,list):print "b is list" else:print "b is not list" if isinstance(c,tuple):print "c is tuple" else:print "c is not tuple" if isinstance(d,dict):print "d is dict" else:print "d is not dict" if isinstance(e,str):print "d is str" else:print "d is not str"

六丶相互轉(zhuǎn)化

# 1、字典 dict1 = {'name': 'Zara', 'age': 7, 'class': 'First'} # 字典轉(zhuǎn)為字符串，返回：<type 'str'> {'age': 7, 'name': 'Zara', 'class': 'First'} print(type(str(dict1)), str(dict1)) # 字典可以轉(zhuǎn)為元組，返回：('age', 'name', 'class') print(tuple(dict1)) # 字典可以轉(zhuǎn)為元組，返回：(7, 'Zara', 'First') print(tuple(dict1.values())) # 字典轉(zhuǎn)為列表，返回：['age', 'name', 'class'] print(list(dict1)) # 字典轉(zhuǎn)為列表，返回：['Zara', 7, 'First'] print(list(dict1.values()))# 2、元組 tup=(1, 2, 3, 4, 5) # 元組轉(zhuǎn)為字符串，返回：(1, 2, 3, 4, 5) print(tup.__str__()) # 元組轉(zhuǎn)為列表，返回：[1, 2, 3, 4, 5] print(list(tup)) # 元組不可以轉(zhuǎn)為字典# 3、列表 nums=[1, 3, 5, 7, 8, 13, 20]; # 列表轉(zhuǎn)為字符串，返回：[1, 3, 5, 7, 8, 13, 20] print(str(nums)) # 列表轉(zhuǎn)為元組，返回：(1, 3, 5, 7, 8, 13, 20) print(tuple(nums)) # 列表不可以轉(zhuǎn)為字典# 4.1、字符串之eval函數(shù)，此函數(shù)有風(fēng)險，需慎用，此函數(shù)的參數(shù)可以是系統(tǒng)命令，所以會存在風(fēng)險 # 字符串轉(zhuǎn)為元組，前提是字符串像元組,返回：(1, 2, 3) print(eval("(1,2,3)")) # 字符串轉(zhuǎn)為列表，前提是字符串像列表,返回：[1, 2, 3] print(eval("[1,2,3]")) # 字符串轉(zhuǎn)為字典，前提是字符串像字典,返回：{'name': 'ljq', 'age': 24} print(eval("{'name':'ljq', 'age':24}"))# 4.2、字符串轉(zhuǎn)換其他方式 # 字符串轉(zhuǎn)為列表，結(jié)果['', 'i', 'le,Til', 'e,a', 're,'] a5 = 'title,Tilte,atre,' print(a5.split('t'))# 字符串轉(zhuǎn)為字典 s = "Name1=Value1;Name2=Value2;Name3=Value3" d = dict(item.split("=") for item in s.split(";")) print(d) # 結(jié)果為dict = { "Name1": "Value1", "Name2": "Value2", "Name3": "Value3" }， # 注意s結(jié)尾不能是;如果是，用s.rstrip(';')

七，注意事項

如果元組只有一個元素，如果不加逗號，此元素是什么類型，則就是什么類型，如果元組只用（）表示，也不存在此情況；list，字典不存在此情況

tu1 = ()? ? ? ? ? ? ?# <class ''tuple'> tu2 = (1)? ? ? ? ? ? # <class 'int'> tu3 = (1,)? ? ? ? ? ?# <class 'tuple'>list1 = ['a']? ? ? ??#?<class 'list'> list2 = []? ? ? ? ? ?#?<class 'list'>

八丶深淺copy

1，先看賦值運算

l1 = [1,2,3,['AB','ab']] l2 = l1l1[0] = 111 print(l1) # [111, 2, 3, ['AB', 'ab']] print(l2) # [111, 2, 3, ['AB, 'ab']]l1[3][0] = 'EEE' print(l1) # [111, 2, 3, ['EEE', 'ab']] print(l2) # [111, 2, 3, ['EEE', 'ab']]

對于賦值運算來說，l1與l2指向的是同一個內(nèi)存地址，所以他們是完全一樣的。

2，淺拷貝copy

# 同一代碼塊下： l1 = [1, 'abc', True, (1,2,3), [22, 33]] l2 = l1.copy() print(id(l1), id(l2)) # 2713214468360 2713214524680 不同 print(id(l1[-2]), id(l2[-2])) # 2547618888008 2547618888008 相同 print(id(l1[-1]),id(l2[-1])) # 2547620322952 2547620322952 相同# 不同代碼塊下： l1 = [1, 'abc', True, (1, 2, 3), [22, 33]] l2 = l1.copy() print(id(l1), id(l2)) # 1477183162120 1477183162696 不同 print(id(l1[-2]), id(l2[-2])) # 1477181814032 1477181814032 相同 print(id(l1[-1]), id(l2[-1])) # 1477183162504 1477183162504 相同

對于淺copy來說，只是在內(nèi)存中重新創(chuàng)建了開辟了一個空間存放一個新列表，但是新列表中的元素與原列表中的元素是公用的。

3，深拷貝deepcopy。

# 同一代碼塊下 import copy l1 = [1, 'abc', True, (1,2,3), [22, 33]] l2 = copy.deepcopy(l1) print(id(l1), id(l2)) # 2788324482440 2788324483016 不同 print(id(l1[0]),id(l2[0])) # 1470562768 1470562768 相同 print(id(l1[-1]),id(l2[-1])) # 2788324482632 2788324482696 不同 print(id(l1[-2]),id(l2[-2])) # 2788323047752 2788323047752 相同# 不同代碼塊下 import copy l1 = [1, 'abc', True, (1, 2, 3), [22, 33]] l2 = copy.deepcopy(l1) print(id(l1), id(l2)) # 1477183162824 1477183162632 不同 print(id(0), id(0)) # 1470562736 1470562736 相同 print(id(-2), id(-2)) # 1470562672 1470562672 相同 print(id(l1[-1]), id(l2[-1])) # 1477183162120 1477183162312 不同

對于深copy來說，列表是在內(nèi)存中重新創(chuàng)建的，列表中可變的數(shù)據(jù)類型是重新創(chuàng)建的，列表中的不可變的數(shù)據(jù)類型是公用的。

八、小數(shù)據(jù)池

小數(shù)據(jù)池。 一種數(shù)據(jù)緩存機制. 也被稱為駐留機制. 各大編程語?中都有類似的東西.

小數(shù)據(jù)池只針對: 整數(shù), 字符串, 布爾值. 其他的數(shù)據(jù)類型不存在，如列表，元祖等，即使里面只有一個值，賦值時內(nèi)存地址不一樣

在python中對-5到256之間的整數(shù)會被駐留留在內(nèi)存中. 將一定規(guī)則的字符串緩存. 在使用的時候, 內(nèi)存中只會創(chuàng)建一個該數(shù)據(jù)的對象. 保存在小數(shù)據(jù)池中. 當(dāng)使用的時候直接從小數(shù)據(jù)池中獲取對象的內(nèi)存引用. 而不需要創(chuàng)建一個新的數(shù)據(jù). 這樣會節(jié)省更多的內(nèi)存區(qū)域.

優(yōu)點: 能夠提?一些字符串, 整數(shù)的處理速度. 省略創(chuàng)建對象的過程.
缺點: 在’池’中創(chuàng)建或者插入新的內(nèi)容會花費更多的時間.

對于數(shù)字:

?-5~256是會被加到小數(shù)據(jù)池中的. 每次使用都是同一個對象. 例如：

a,b=100,100

print(a is b)? ? ?#True

對于字符串:

如果字符串的長度是0或者1, 都會默認進行緩存

字符串長度大于1, 但是字符串中只包含字母, 數(shù)字, 下劃線時才會緩存，無論字符串長度大小

用乘法得到的字符串.

??????? ①. 乘數(shù)等于1, 僅包含數(shù)字, 字母, 下劃線時會被緩存. 如果包含其他字符, 而長度<=1 也會被駐存,

??????? ②. 乘數(shù)大于1, 僅包含數(shù)字, 字母, 下劃線時會被緩存. 但字符串長度不能大于20 ，大于20不會緩存

指定駐留. 我們可以通過sys模塊中的intern()函數(shù)來指定要駐留留的內(nèi)容.

到目前為止. 我們已經(jīng)了解了了python的小數(shù)據(jù)池的一些基本情況了. 但是!!!! 還有最后一 個問題. 小數(shù)據(jù)池和最開始的代碼塊有什么關(guān)系呢? 同樣的一段代碼在命令行窗口和在py文件中. 出現(xiàn)的效果是完全不一樣的。在代碼塊內(nèi)的緩存機制是不一樣的.

在執(zhí)行同一個代碼塊的初始化對象的命令時, 會檢查其值是否已經(jīng)存在, 如果存在, 會將其重用. 換句話說: 執(zhí)行同一個代碼塊時, 遇到初始化對象的命令時，他會將初始化的這個變量與值存儲在一個字典中, 在遇到新的變量時, 會先在字典中查詢記錄, 如果有同樣的記錄那么它會重復(fù)使用這個字典中的之前的這個值. 所以在文件執(zhí)行時(同一個代碼塊) 會把a, b兩個變量量指向同?一個對象.

如果是不同的代碼塊, 他就會看這個兩個變量是否滿足小數(shù)據(jù)池的數(shù)據(jù), 如果是滿足小數(shù)據(jù)池的數(shù)據(jù)則會指向同一個地址. a, b的賦值語句分別被當(dāng)作兩個代碼塊執(zhí)行, 但是他們不滿足小數(shù)據(jù)池的數(shù)據(jù)所以會得到兩個不同的對象, 因而is判斷返回False.

= 為賦值，賦予的是內(nèi)存地址
is：比較的是內(nèi)存地址。
id：比較的id是否相同。
==：比較兩個值是否相等。

總結(jié)

以上是生活随笔為你收集整理的Python 之数据类型的全部內(nèi)容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網(wǎng)站內(nèi)容還不錯，歡迎將生活随笔推薦給好友。