Python基礎(chǔ)數(shù)據(jù)類型(一)

一.什么是數(shù)據(jù)類型？

什么是數(shù)據(jù)類型？

我們?nèi)祟惪梢院苋菀椎姆智鍞?shù)字與字符的區(qū)別，但是計算機并不能呀，計算機雖然很強大，但從某種角度上看又很傻，除非你明確的告訴它，1是數(shù)字，“漢”是文字，否則它是分不清1和‘漢’的區(qū)別的，因此，在每個編程語言里都會有一個叫數(shù)據(jù)類型的東東，其實就是對常用的各種數(shù)據(jù)類型進行了明確的劃分，你想讓計算機進行數(shù)值運算，你就傳數(shù)字給它，你想讓他處理文字，就傳字符串類型給他。Python中常用的數(shù)據(jù)類型有多種，如下：

整數(shù)(int) ,字符串(str),布爾值(bool),列表(list),元組(tuple),字典(dict),集合(set).

int。數(shù)字：主要用于運算。1 ，2,3...

bool。判斷真假：True, False.

str。簡單少量的儲存數(shù)據(jù)，并進行相應的操作。name = 'alex',

tuple。只讀，不能更改。(1,'alex')

list：大量有序數(shù)據(jù)，[1,'ses',True,[1,2,3],{'name':'jinxin'}]

dict：大量數(shù)據(jù)，且是關(guān)聯(lián)性比較強的數(shù)據(jù)? {'name':'jinxin','age':18,'name_list':['張三'，'李四']}

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

nt，就是咱們常見的數(shù)據(jù)類型，主要是用于葛總運算，加減乘數(shù)等這里就不給你舉例說明了。

首先要給大家講下是十進制與二進制之間的轉(zhuǎn)換。

2.1.1 十進制二進制轉(zhuǎn)換

十進制整數(shù)轉(zhuǎn)換為二進制整數(shù)采用"除2取余，逆序排列"法。具體做法是：用2整除十進制整數(shù)，可以得到一個商和余數(shù)；再用2去除商，又會得到一個商和余數(shù)，如此進行，直到商為小于1時為止，然后把先得到的余數(shù)作為二進制數(shù)的低位有效位，后得到的余數(shù)作為二進制數(shù)的高位有效位，依次排列起來。

十進制小數(shù)轉(zhuǎn)換成二進制小數(shù)采用"乘2取整，順序排列"法。具體做法是：用2乘十進制小數(shù)，可以得到積，將積的整數(shù)部分取出，再用2乘余下的小數(shù)部分，又得到一個積，再將積的整數(shù)部分取出，如此進行，直到積中的小數(shù)部分為零，此時0或1為二進制的最后一位。或者達到所要求的精度為止。

二進制轉(zhuǎn)化成十進制:

要從右到左用二進制的每個數(shù)去乘以2的相應次方,小數(shù)點后則是從左往右

例如：二進制數(shù)1101.01轉(zhuǎn)化成十進制

1101.01（2）=1*20+0*21+1*22+1*23?+0*2-1+1*2-2=1+0+4+8+0+0.25=13.25（10）

所以總結(jié)起來通用公式為：

abcd.efg(2)=d*20+c*21+b*22+a*23+e*2-1+f*2-2+g*2-3（10）

或者是：

把二進制數(shù)首先寫成加權(quán)系數(shù)展開式，然后按十進制加法規(guī)則求和。這種做法稱為"按權(quán)相加"法。

此時，1101=8+4+0+1=13

再比如：二進制數(shù)100011轉(zhuǎn)成十進制數(shù)可以看作這樣：

數(shù)字***有三個1 即第一位一個，第五位一個，第六位一個，然后對應十進制數(shù)即2的0次方+2的1次方+2的5次方， 即

100011=32+0+0+0+2+1=35

2.2.2 int操作方法

因為數(shù)字主要是用于計算，所以針對于數(shù)字可以使用的方法除了那些運算之外，沒有什么經(jīng)常會用的方法，python給咱們提供了一種方法：bit_length()就是幫助你快速的計算整數(shù)在內(nèi)存中占用的二進制碼的長度.

num?=?10print(num.bit_length())??#?當十進制用二進制表示時，最少使用的位數(shù) #?運行結(jié)果:?4

布爾值就兩種：True，F(xiàn)alse。就是反應條件的正確與否。

真 ? 1 ? True。

假 ? 0 ? False。

這里補充一下int str bool 三者數(shù)據(jù)類型之間的轉(zhuǎn)換。

#?int?--->?bool i?=?100 print(bool(i))??#?True??#?非零即True i1?=?0 print(bool(i1))??#?False?零即False #?bool?--->?int t?=?True print(int(t))??#?1??True?-->?1 t?=?False print(int(t))??#?0??False?-->?0 #?int?--->?str i1?=?100 print(str(i1))??#?'100' #?str?--->?int??#?全部由數(shù)字組成的字符串才可以轉(zhuǎn)化成數(shù)字 s1?=?'90' print(int(s1))??#?90 #?str?--->?bool s1?=?'太白' s2?=?'' print(bool(s1))??#?True?非空即True print(bool(s2))??#?False #?bool?--->?str t1?=?True print(str(True))??#?'True'

Python中凡是用引號引起來的數(shù)據(jù)可以稱為字符串類型，組成字符串的每個元素稱之為字符，將這些字符一個一個連接起來，然后在用引號起來就是字符串。

s1?=?'太白nb'#?對于s1這個字符串來說，它由四個字符組成：太,?白,?n,?b。

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

組成字符串的字符從左至右，依次排列，他們都是有順序的，就好比是部隊的隊列，從左至右依次報號(從零開始) ：0,1,2,3....

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

a?=?'ABCDEFGHIJK' print(a[0]) print(a[3]) print(a[5]) print(a[7])

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

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

2.3.2、字符串常用方法。

字符串除了可以用切片（步長）之外，還有一些其他的操作方法。

#數(shù)字符串中的元素出現(xiàn)的個數(shù)。 #?ret3?=?a1.count("a",0,4)?#?可切片 #?print(ret3) a4?=?"dkfjdkfasf54" #startswith?判斷是否以...開頭 #endswith?判斷是否以...結(jié)尾 #?ret4?=?a4.endswith('jdk',3,6)??#?顧頭不顧腚 #?print(ret4)??#?返回的是布爾值 #?ret5?=?a4.startswith("kfj",1,4) #?print(ret5) #split?以什么分割，最終形成一個列表此列表不含有這個分割的元素。 #?ret9?=?'title,Tilte,atre,'.split('t') #?print(ret9) #?ret91?=?'title,Tilte,atre,'.rsplit('t',1) #?print(ret91) #format的三種玩法?格式化輸出 res='{}?{}?{}'.format('egon',18,'male') res='{1}?{0}?{1}'.format('egon',18,'male') res='{name}?{age}?{sex}'.format(sex='male',name='egon',age=18) #strip name='*barry**' print(name.strip('*')) print(name.lstrip('*')) print(name.rstrip('*')) #replace name='alex?say?:i?have?one?tesla,my?name?is?alex' print(name.replace('alex','SB',1)) #####is系列 name='taibai123' print(name.isalnum())?#字符串由字母或數(shù)字組成 print(name.isalpha())?#字符串只由字母組成 print(name.isdecimal())?#字符串只由十進制組成 #############下面這些方法在數(shù)據(jù)類型補充時會講到，現(xiàn)在不講#################### #尋找字符串中的元素是否存在 #?ret6?=?a4.find("fjdk",1,6) #?print(ret6)??#?返回的找到的元素的索引，如果找不到返回-1 #?ret61?=?a4.index("fjdk",4,6) #?print(ret61)?#?返回的找到的元素的索引，找不到報錯。 #captalize,swapcase,title print(name.capitalize())?#首字母大寫 print(name.swapcase())?#大小寫翻轉(zhuǎn) msg='taibai?say?hi' print(msg.title())?#每個單詞的首字母大寫 #?內(nèi)同居中，總長度，空白處填充 ret2?=?a1.center(20,"*") print(ret2)

Why:?我們現(xiàn)在已經(jīng)學過的數(shù)據(jù)類型有：數(shù)字，布爾值，字符串，大家都知道數(shù)字主要用于計算，bool值主要是條件判斷，只有字符串可以用于數(shù)據(jù)的存儲，這些數(shù)據(jù)類型夠用么？對于一門語言來說，肯定是不夠用的。就說字符串：

1，字符串只能存儲少量的數(shù)據(jù)，對于大量的數(shù)據(jù)用字符串操作不方便也不易存儲。

2，字符串存儲的數(shù)據(jù)類型太單一，只能是字符串類型。

例如：‘1 True alex’ 像這樣的字符串，我如果通過切片或者其他方法將1 True alex 取出來，他也只能是字符串，但是我想要得到數(shù)字的1，布爾值的True，必須還要轉(zhuǎn)化，是不是很麻煩。

所以python給咱們也提供了一類數(shù)據(jù)類型，他能承載多種數(shù)據(jù)類型，這類數(shù)據(jù)類型被稱作容器類數(shù)據(jù)類型可以存儲大量的數(shù)據(jù)。列表就屬于容器類的數(shù)據(jù)類型。

What:這個數(shù)據(jù)類型就是list列表。

列表是python的基礎(chǔ)數(shù)據(jù)類型之一 ,其他編程語言也有類似的數(shù)據(jù)類型.比如JS中的數(shù) 組, java中的數(shù)組等等. 它是以[ ]括起來, 每個元素用' , '隔開而且可以存放各種數(shù)據(jù)類型:?列表是python中的基礎(chǔ)數(shù)據(jù)類型之一，其他語言中也有類似于列表的數(shù)據(jù)類

型，比如js中叫數(shù)組，他是以[]括起來，每個元素以逗號隔開，而且他里面可以存放各種數(shù)據(jù)類型比如：

li = [‘a(chǎn)lex’,123,Ture,(1,2,3,’wusir’),[1,2,3,’小明’,],{‘name’:’alex’}]

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

How：那么這個列表如何使用呢？咱們從這幾方面去深入研究這個列表。

2.4.1?列表的創(chuàng)建

#?創(chuàng)建一個列表有三種方式： #?方式一：（常用） l1?=?[1,?2,?'太白'] #?方式二：（不常用） l1?=?list()??#?空列表 #?l1?=?list(iterable)??#?可迭代對象 l1?=?list('123') print(l1)??#?['1',?'2',?'3'] #?方式三：列表推導式（后面的課程會講到） l1?=?[i?for?i?in?range(1,5)] print(l1)??#?[1,?2,?3,?4]

2.4.2?列表的索引切片

l1?=?['a',?'b',?'太白',?3,?666] print(l1[0])??#?'a' print(l1[-1])??#?666 print(l1[1:3])??#?['b',?'太白'] print(l1[:-1])??#?['a',?'b',?'太白',?3] print(l1[::2])??#?['a',?'太白',?666] print(l1[::-1])??#?[666,?3,?'太白',?'b',?'a']

li?=?[1,?3,?2,?"a",?4,?"b",?5,"c"] 通過對li列表的切片形成新的列表l1,l1?=?[1,3,2] 通過對li列表的切片形成新的列表l2,l2?=?["a",4,"b"] 通過對li列表的切片形成新的列表l4,l4?=?[3,"a","b"] 通過對li列表的切片形成新的列表l6,l6?=?["b","a",3]

2.4.3.?增

#?append?追加，給列表的最后面追加一個元素 l?=?[1,?2,?'a'] l.append(666) print(l)?#?[1,?2,?'a',?666] #?insert??插入在列表的任意位置插入元素 l?=?[1,?2,?'a'] l.insert(1,'太白') print(l)?#?[1,?'太白',?2,?'a'] #?extend??迭代著追加，在列表的最后面迭代著追加一組數(shù)據(jù) l?=?[1,?2,?'a'] l.extend('太白a') print(l) 列表的增

2.4.4.?刪

#?pop??通過索引刪除列表中對應的元素，該方法有返回值，返回值為刪除的元素 l?=?['太白',?'alex',?'WuSir',?'女神'] ret?=?l.pop(1) print(ret,l)?#?alex?['太白',?'WuSir',?'女神'] #?remove??通過元素刪除列表中該元素 l?=?['太白',?'alex',?'WuSir',?'女神'] l.remove('alex') print(l)?#?['太白',?'WuSir',?'女神'] #?clear?清空列表 l?=?['太白',?'alex',?'WuSir',?'女神'] l.clear() print(l)?#?[]?? #?del #按照索引刪除該元素 l?=?['太白',?'alex',?'WuSir',?'女神'] del?l[2] print(l)?#?['太白',?'alex',?'女神'] #?切片刪除該元素 l?=?['太白',?'alex',?'WuSir',?'女神'] del?l[1:] print(l)?#?['太白'] #?切片(步長)刪除該元素 l?=?['太白',?'alex',?'WuSir',?'女神'] del?l[::2] print(l)?#?['alex',?'女神'] 列表的刪

2.4.5.?改

#?按照索引改值 l?=?['太白',?'alex',?'WuSir',?'女神'] l[0]?=?'男神' print(l)?#?['男神',?'alex',?'WuSir',?'女神'] #?按照切片改值(迭代著增加) l?=?['太白',?'alex',?'WuSir',?'女神'] l[1:3]?=?'abcdefg' print(l)?#?['太白',?'a',?'b',?'c',?'d',?'e',?'f',?'g',?'女神']? #?按照切片(步長)改值(必須一一對應) l?=?['太白',?'alex',?'WuSir',?'女神'] l[::2]?=?'對應' print(l)?#?['對',?'alex',?'應',?'女神'] 列表的改

2.4.6.?查

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

2.4.5 其他操作這些方法會在數(shù)據(jù)類型的補充時再給大家講~

2.4.5、其他操作

count（數(shù)）（方法統(tǒng)計某個元素在列表中出現(xiàn)的次數(shù)）。

1?a?=?["q","w","q","r","t","y"] 2?print(a.count("q"))

index（方法用于從列表中找出某個值第一個匹配項的索引位置）

1?a?=?["q","w","r","t","y"] 2?print(a.index("r"))

sort （方法用于在原位置對列表進行排序）。

reverse （方法將列表中的元素反向存放）。

1?a?=?[2,1,3,4,5] 2?a.sort()#?他沒有返回值，所以只能打印a 3?print(a) 4?a.reverse()#他也沒有返回值，所以只能打印a 5?print(a)

列表也可以相加與整數(shù)相乘

l1?=?[1,?2,?3] l2?=?[4,?5,?6]#?print(l1+l2)??#?[1,?2,?3,?4,?5,?6]print(l1*3)??#?[1,?2,?3,?1,?2,?3,?1,?2,?3]

li?=?["alex",?"WuSir",?"ritian",?"barry",?"wenzhou"] 計算列表的長度并輸出 列表中追加元素"seven",并輸出添加后的列表 請在列表的第1個位置插入元素"Tony",并輸出添加后的列表 請修改列表第2個位置的元素為"Kelly",并輸出修改后的列表 請將列表l2=[1,"a",3,4,"heart"]的每一個元素添加到列表li中，一行代碼實現(xiàn)，不允許循環(huán)添加。 請將字符串s?=?"qwert"的每一個元素添加到列表li中，一行代碼實現(xiàn)，不允許循環(huán)添加。 請刪除列表中的元素"ritian",并輸出添加后的列表 請刪除列表中的第2個元素，并輸出刪除的元素和刪除元素后的列表 請刪除列表中的第2至4個元素，并輸出刪除元素后的列表 相應練習題

2.4.6 列表的嵌套

l1?=?[1,?2,?'taibai',?[1,?'WuSir',?3,]] 1,?將l1中的'taibai'變成大寫并放回原處。 2，給小列表[1,'alex',3,]追加一個元素,'老男孩教育'。 3，將列表中的'alex'通過字符串拼接的方式在列表中變成'alexsb'

lis?=?[2,?3,?"k",?["qwe",?20,?["k1",?["tt",?3,?"1"]],?89],?"ab",?"adv"] 將列表lis中的"tt"變成大寫（用兩種方式）。 將列表中的數(shù)字3變成字符串"100"（用兩種方式）。 將列表中的字符串"1"變成數(shù)字101（用兩種方式）。

Where:(這個知識點用在什么地方)：

你需要存儲大量的數(shù)據(jù)，且需要這些數(shù)據(jù)有序的時候。

制定一些特殊的數(shù)據(jù)群體：按順序，按規(guī)則，自定制設(shè)計數(shù)據(jù)。

Why:對于容器型數(shù)據(jù)類型list，無論誰都可以對其增刪改查，那么有一些重要的數(shù)據(jù)放在list中是不安全的，所以需要一種容器類的數(shù)據(jù)類型存放重要的數(shù)據(jù)，創(chuàng)建之初只能查看而不能增刪改，這種數(shù)據(jù)類型就是元組。

what:這個容器型數(shù)據(jù)類型就是元組。

元組:俗稱不可變的列表,又被成為只讀列表,元祖也是python的基本數(shù)據(jù)類型之一,用小括號括起來,里面可以放任何數(shù)據(jù)類型的數(shù)據(jù),查詢可以,循環(huán)也可以,切片也可以.但就是不能改.

2.5.1?元組的索引切片

tu1?=?('a',?'b',?'太白',?3,?666) print(tu1[0])??#?'a' print(tu1[-1])??#?666 print(tu1[1:3])??#?('b',?'太白') print(tu1[:-1])??#?('a',?'b',?'太白',?3) print(tu1[::2])??#?('a',?'太白',?666) print(tu1[::-1])??#?(666,?3,?'太白',?'b',?'a') 元組的索引切片

2.5.2 其他操作這些方法會在數(shù)據(jù)類型的補充時再給大家講~

2.5.2?元組其他操作方法

因為元組的特性，直接從屬于元組的元素不能更改，所以元組只能查看。

#?可以利用for循環(huán)查詢tu1?=?('a',?'b',?'太白',?3,?666)for?i?in?tu1:????print(i)

index：通過元素找索引（可切片），找到第一個元素就返回，找不到該元素即報錯。

tu?=?('太白',?[1,?2,?3,?],?'WuSir',?'女神')print(tu.index('太白'))?#?0

count:?獲取某元素在列表中出現(xiàn)的次數(shù)

tu?=?('太白',?'太白',?'WuSir',?'吳超')print(tu.count('太白'))?#?2

2.5.3 len

tu1?=?(1,2,3,4,84,5,2,8,2,11,88,2)print(len(tu1)) 結(jié)果:12

Where:

1，就是將一些非常重要的不可讓人改動的數(shù)據(jù)放在元組中，只供查看。

2，常用于元組的拆包（數(shù)據(jù)類型補充的時候會給大家講到）。

2.6.1 字典的初識

Why:咱們目前已經(jīng)學習到的容器型數(shù)據(jù)類型只有l(wèi)ist，那么list夠用？他有什么缺點呢？

1. 列表可以存儲大量的數(shù)據(jù)類型，但是如果數(shù)據(jù)量大的話，他的查詢速度比較慢。

2. 列表只能按照順序存儲，數(shù)據(jù)與數(shù)據(jù)之間關(guān)聯(lián)性不強。

所以針對于上的缺點，說咱們需要引入另一種容器型的數(shù)據(jù)類型，解決上面的問題，這就需要dict字典。

what：

數(shù)據(jù)類型可以按照多種角度進行分類，就跟咱們?nèi)艘粯樱税凑盏赜蚩梢詣澐址譃閬喼奕耍瑲W洲人，美洲人等，但是按照膚色又可以分為白種人，黃種人，黑種人，等等，數(shù)據(jù)類型可以按照不同的角度進行分類，先給大家按照可變與不可變的數(shù)據(jù)類型的分類：

不可變（可哈希）的數(shù)據(jù)類型：int，str，bool，tuple。

可變（不可哈希）的數(shù)據(jù)類型：list，dict，set。

字典是Python語言中的映射類型，他是以{}括起來，里面的內(nèi)容是以鍵值對的形式儲存的：

Key: 不可變（可哈希）的數(shù)據(jù)類型.并且鍵是唯一的，不重復的。

Value:任意數(shù)據(jù)(int，str，bool，tuple，list，dict，set)，包括后面要學的實例對象等。

在Python3.5版本（包括此版本）之前，字典是無序的。

在Python3.6版本之后，字典會按照初建字典時的順序排列(即第一次插入數(shù)據(jù)的順序排序)。

當然，字典也有缺點：他的缺點就是內(nèi)存消耗巨大。

字典查詢之所以快的解釋：（了解）

字典的查詢速度非常快，簡單解釋一下原因：字典的鍵值對會存在一個散列表（稀疏數(shù)組）這樣的空間中，每一個單位稱作一個表元，表元里面記錄著key：value,如果你想要找到這個key對應的值，先要對這個key進行hash獲取一串數(shù)字咱們簡稱為門牌號（非內(nèi)存地址），然后通過門牌號，確定表元，對比查詢的key與被鎖定的key是否相同，如果相同，將值返回，如果不同，報錯。（這里只是簡單的說一下過程，其實還是比較復雜的。），下面我已圖形舉例：

#?此段解釋來源于《流暢的python》. 這一節(jié)籠統(tǒng)地描述了?Python?如何用散列表來實現(xiàn)?dict?類型，有些細節(jié)只是一筆帶過，像 CPython?里的一些優(yōu)化技巧?就沒有提到。但是總體來說描述是準確的。 Python?源碼?dictobject.c?模塊（http://hg.python.org/cpython/file/tip/Objects/dictobject.c）里有豐富的注釋，另外延伸閱 讀中有對《代碼之美》一書的引用。 為了簡單起見，這里先集中討論?dict?的內(nèi)部結(jié)構(gòu)，然后再延伸到集合上面。 散列表其實是一個稀疏數(shù)組（總是有空白元素的數(shù)組稱為稀疏數(shù)組）。在一般的數(shù)據(jù)結(jié)構(gòu) 教材中，散列表里的單元通常叫作表元（bucket）。在?dict?的散列表當中，每個鍵值對 都占用一個表元，每個表元都有兩個部分，一個是對鍵的引用，另一個是對值的引用。因 為所有表元的大小一致，所以可以通過偏移量來讀取某個表元。 因為?Python?會設(shè)法保證大概還有三分之一的表元是空的，所以在快要達到這個閾值的時 候，原有的散列表會被復制到一個更大的空間里面。 如果要把一個對象放入散列表，那么首先要計算這個元素鍵的散列值。Python?中可以用 hash()?方法來做這件事情，接下來會介紹這一點。 01.?散列值和相等性 內(nèi)置的?hash()?方法可以用于所有的內(nèi)置類型對象。如果是自定義對象調(diào)用?hash() 的話，實際上運行的是自定義的?__hash__。如果兩個對象在比較的時候是相等的， 那它們的散列值必須相等，否則散列表就不能正常運行了。例如，如果?1?==?1.0?為 8 真，那么?hash(1)?==?hash(1.0)?也必須為真，但其實這兩個數(shù)字（整型和浮點） 的內(nèi)部結(jié)構(gòu)是完全不一樣的。 為了讓散列值能夠勝任散列表索引這一角色，它們必須在索引空間中盡量分散開來。 這意味著在最理想的狀況下，越是相似但不相等的對象，它們散列值的差別應該越 大。示例?3-16?是一段代碼輸出，這段代碼被用來比較散列值的二進制表達的不同。 注意其中?1?和?1.0?的散列值是相同的，而?1.0001、1.0002?和?1.0003?的散列值則非常不 同。 示例?3-16?在32?位的?Python?中，1、1.0001、1.0002?和?1.0003?這幾個數(shù)的散列 值的二進制表達對比（上下兩個二進制間不同的位被?!?高亮出來，表格的最右 列顯示了有多少位不相同） 32-bit?Python?build 00000000000000000000000000000001 !=?0 1.0?00000000000000000000000000000001 ------------------------------------------------ 1.0?00000000000000000000000000000001 !?!!!?!?!!?!?!?!?!?!!?!!!?!=?16 1.0001?00101110101101010000101011011101 ------------------------------------------------ 1.0001?00101110101101010000101011011101 !!!?!!!!?!!!!!?!!!!!?!!?!?!=?20 1.0002?01011101011010100001010110111001 ------------------------------------------------ 1.0002?01011101011010100001010110111001 !?!?!?!!!?!?!?!!?!?!?!?!!!!?!=?17 1.0003?00001100000111110010000010010110 ------------------------------------------------ 用來計算示例?3-16?的程序見于附錄?A。盡管程序里大部分代碼都是用來整理輸出格 式的，考慮到完整性，我還是把全部的代碼放在示例?A-3?中了。 從?Python?3.3?開始，str、bytes?和?datetime?對象的散列值計算過程中多 了隨機的“加鹽”這一步。所加鹽值是?Python?進程內(nèi)的一個常量，但是每次啟動 Python?解釋器都會生成一個不同的鹽值。隨機鹽值的加入是為了防止?DOS?攻擊 而采取的一種安全措施。在?__hash__?特殊方法的文檔 （https://docs.python.org/3/reference/datamodel.html#object.__hash__)?里有相關(guān)的詳 細信息。 了解對象散列值相關(guān)的基本概念之后，我們可以深入到散列表工作原理背后的算法 了。 02.?散列表算法 為了獲取?my_dict[search_key]?背后的值，Python?首先會調(diào)用?hash(search_key)來計算?search_key?的散列值，把這個值最低的幾位數(shù)字當作偏移量，在散列表里查找表元（具體取幾位，得看當前散列表的大小）。若找到的表元是空的，則拋出KeyError?異常。若不是空的，則表元里會有一對?found_key:found_value。這時候?Python?會檢驗?search_key?==?found_key?是否為真，如果它們相等的話，就會返回?found_value。如果?search_key?和?found_key?不匹配的話，這種情況稱為散列沖突。發(fā)生這種情況是因為，散列表所做的其實是把隨機的元素映射到只有幾位的數(shù)字上，而散列表本身的索引又只依賴于這個數(shù)字的一部分。為了解決散列沖突，算法會在散列值中另外再取幾位，然后用特殊的方法處理一下，把新得到的數(shù)字再當作索引來尋找表元。若這次找到的表元是空的，則同樣拋出?KeyError；若非空，或者鍵匹配，則返回這個值；或者又發(fā)現(xiàn)了散列沖突，則重復以上的步驟。圖?3-3?展示了這個算法的示意 圖。圖?3-3：從字典中取值的算法流程圖；給定一個鍵，這個算法要么返回一個值，要么拋出?KeyError?異常添加新元素和更新現(xiàn)有鍵值的操作幾乎跟上面一樣。只不過對于前者，在發(fā)現(xiàn)空表元的時候會放入一個新元素；對于后者，在找到相對應的表元后，原表里的值對象會被替換成新值。 另外在插入新值時，Python?可能會按照散列表的擁擠程度來決定是否要重新分配內(nèi)存為它擴容。如果增加了散列表的大小，那散列值所占的位數(shù)和用作索引的位數(shù)都會隨之增加，這樣做的目的是為了減少發(fā)生散列沖突的概率。表面上看，這個算法似乎很費事，而實際上就算?dict?里有數(shù)百萬個元素，多數(shù)的搜索過程中并不會有沖突發(fā)生，平均下來每次搜索可能會有一到兩次沖突。在正常情況下，就算是最不走運的鍵所遇到的沖突的次數(shù)用一只手也能數(shù)過來。了解?dict?的工作原理能讓我們知道它的所長和所短，以及從它衍生而來的數(shù)據(jù)類型 詳細解釋

由于字典使用了散列表，而散列表又必須是稀疏的，這導致它在空間上的效率低下。舉例而言，如果你需要存放數(shù)量巨大的記錄，那么放在由元組或是具名元組構(gòu)成的列表中會是比較好的選擇；最好不要根據(jù)?JSON?的風格，用由字典組成的列表來存放這些記錄。用元組取代字典就能節(jié)省空間的原因有兩個：其一是避免了散列表所耗費的空間，其二是無需把記錄中字段的名字在每個元素里都存一遍。記住我們現(xiàn)在討論的是空間優(yōu)化。如果你手頭有幾百萬個對象，而你的機器有幾個GB?的內(nèi)存，那么空間的優(yōu)化工作可以等到真正需要的時候再開始計劃，因為優(yōu)化往往是可維護性的對立面。

2.6.2 創(chuàng)建字典的幾種方式：

#?創(chuàng)建字典的幾種方式： #?方式1: dic?=?dict((('one',?1),('two',?2),('three',?3))) #?dic?=?dict([('one',?1),('two',?2),('three',?3)]) print(dic)??#?{'one':?1,?'two':?2,?'three':?3} #?方式2: dic?=?dict(one=1,two=2,three=3) print(dic)??#?{'one':?1,?'two':?2,?'three':?3} #?方式3: dic?=?dict({'one':?1,?'two':?2,?'three':?3}) print(dic)??#?{'one':?1,?'two':?2,?'three':?3} #?方式5:?后面會講到先了解 dic?=?dict(zip(['one',?'two',?'three'],[1,?2,?3])) print(dic) #?方式6:?字典推導式?后面會講到 #?dic?=?{?k:?v?for?k,v?in?[('one',?1),('two',?2),('three',?3)]} #?print(dic) #?方式7:利用fromkey后面會講到。 #?dic?=?dict.fromkeys('abcd','太白') #?print(dic)??#?{'a':?'太白',?'b':?'太白',?'c':?'太白',?'d':?'太白'}

2.6.3 驗證字典的合法性

#?合法 dic?=?{123:?456,?True:?999,?"id":?1,?"name":?'sylar',?"age":?18,?"stu":?['帥 哥',?'美?'],?(1,?2,?3):?'麻花藤'} print(dic[123]) print(dic[True]) print(dic['id']) print(dic['stu']) print(dic[(1,?2,?3)]) #?不合法 #?dic?=?{[1,?2,?3]:?'周杰倫'}?#?list是可變的.?不能作為key #?dic?=?{{1:?2}:?"哈哈哈"}?#?dict是可變的.?不能作為key dic?=?{{1,?2,?3}:?'呵呵呵'}?#?set是可變的,?不能作為key

2.6.4 字典的常用操作方法

接下來咱們就進入字典的學習環(huán)節(jié)，字典對于咱們小白來說可能相對于列表是不好理解的，因為列表是有序的一個一個排列的，但是字典的鍵值對對于大家來說是比較陌生的，所以咱們可以把字典比喻成一個公寓，公寓里面有N多個房間，房間號就是鍵，房間里面具體的東西就值：比如房間001號：對應的房間住著兩個人，也就是2person，簡稱2P，房間99號：3P， 房間78號：有人還有小動物....... 這樣，咱們就能通過房間號（也就是鍵）找到對應的房間，查看里面的內(nèi)容，也就是值。

那么首先先從字典的增刪改查開始學習。

增

#?通過鍵值對直接增加 dic?=?{'name':?'太白',?'age':?18} dic['weight']?=?75?#?沒有weight這個鍵，就增加鍵值對 print(dic)?#?{'name':?'太白',?'age':?18,?'weight':?75} dic['name']?=?'barry'?#?有name這個鍵，就成了字典的改值 print(dic)?#?{'name':?'barry',?'age':?18,?'weight':?75} #?setdefault dic?=?{'name':?'太白',?'age':?18} dic.setdefault('height',175)?#?沒有height此鍵，則添加 print(dic)?#?{'name':?'太白',?'age':?18,?'height':?175} dic.setdefault('name','barry')?#?有此鍵則不變 print(dic)?#?{'name':?'太白',?'age':?18,?'height':?175} #它有返回值 dic?=?{'name':?'太白',?'age':?18} ret?=?dic.setdefault('name') print(ret)??#?太白 字典的增

刪

#?pop?通過key刪除字典的鍵值對，有返回值，可設(shè)置返回值。 dic?=?{'name':?'太白',?'age':?18} #?ret?=?dic.pop('name') #?print(ret,dic)?#?太白?{'age':?18} ret1?=?dic.pop('n',None) print(ret1,dic)?#?None?{'name':?'太白',?'age':?18} #popitem?3.5版本之前，popitem為隨機刪除，3.6之后為刪除最后一個，有返回值 dic?=?{'name':?'太白',?'age':?18} ret?=?dic.popitem() print(ret,dic)?#?('age',?18)?{'name':?'太白'} #clear?清空字典 dic?=?{'name':?'太白',?'age':?18} dic.clear() print(dic)?#?{} #?del #?通過鍵刪除鍵值對 dic?=?{'name':?'太白',?'age':?18} del?dic['name'] print(dic)?#?{'age':?18} #刪除整個字典 del?dic 字典的刪

改

#?通過鍵值對直接改 dic?=?{'name':?'太白',?'age':?18} dic['name']?=?'barry' print(dic)?#?{'name':?'barry',?'age':?18} #?update dic?=?{'name':?'太白',?'age':?18} dic.update(sex='男',?height=175) print(dic)?#?{'name':?'太白',?'age':?18,?'sex':?'男',?'height':?175} dic?=?{'name':?'太白',?'age':?18} dic.update([(1,?'a'),(2,?'b'),(3,?'c'),(4,?'d')]) print(dic)?#?{'name':?'太白',?'age':?18,?1:?'a',?2:?'b',?3:?'c',?4:?'d'} dic1?=?{"name":"jin","age":18,"sex":"male"} dic2?=?{"name":"alex","weight":75} dic1.update(dic2) print(dic1)?#?{'name':?'alex',?'age':?18,?'sex':?'male',?'weight':?75} print(dic2)?#?{'name':?'alex',?'weight':?75}? 字典的改

查

#?通過鍵查詢 #?直接dic[key](沒有此鍵會報錯) dic?=?{'name':?'太白',?'age':?18} print(dic['name'])?#?太白 #?get dic?=?{'name':?'太白',?'age':?18} v?=?dic.get('name') print(v)?#?'太白' v?=?dic.get('name1') print(v)?#?None v?=?dic.get('name2','沒有此鍵') print(v)?#?沒有此鍵? keys() dic?=?{'name':?'太白',?'age':?18} print(dic.keys())?#?dict_keys(['name',?'age'])? values() dic?=?{'name':?'太白',?'age':?18} print(dic.values())?#?dict_values(['太白',?18]) items() dic?=?{'name':?'太白',?'age':?18} print(dic.items())?#?dict_items([('name',?'太白'),?('age',?18)]) 字典的查

dic?=?{'k1':?"v1",?"k2":?"v2",?"k3":?[11,22,33]} 請在字典中添加一個鍵值對，"k4":?"v4"，輸出添加后的字典 請在修改字典中?"k1"?對應的值為?"alex"，輸出修改后的字典 請在k3對應的值中追加一個元素?44，輸出修改后的字典 請在k3對應的值的第?1?個位置插入個元素?18，輸出修改后的字典

fromkeys? 數(shù)據(jù)類型的補充時會給大家講到~

dic?=?dict.fromkeys('abcd','太白')print(dic)?#?{'a':?'太白',?'b':?'太白',?'c':?'太白',?'d':?'太白'}dic?=?dict.fromkeys([1,?2,?3],'太白')print(dic)?#?{1:?'太白',?2:?'太白',?3:?'太白'}

其他操作

key_list?=?dic.keys()???? print(key_list) 結(jié)果: dict_keys(['劍圣',?'哈啥給',?'大寶劍']) #?一個高仿列表,存放的都是字典中的key #?并且這個高仿的列表可以轉(zhuǎn)化成列表 print(list(key_list)) #?它還可以循環(huán)打印 dic?=?{'劍圣':'易','哈啥給':'劍豪','大寶劍':'蓋倫'} for?i?in?dic: ????print(i) value_list?=?dic.values() print(value_list) 結(jié)果: dict_values(['易',?'劍豪',?'蓋倫']) #一個高仿列表,存放都是字典中的value #?并且這個高仿的列表可以轉(zhuǎn)化成列表 print(list(value_list)) #?它還可以循環(huán)打印 for?i?in?dic.values():??? ????print(i) key_value_list?=?dic.items() print(key_value_list) 結(jié)果: dict_items([('劍圣',?'易'),?('哈啥給',?'劍豪'),?('大寶劍',?'蓋倫')]) #?一個高仿列表,存放是多個元祖,元祖中第一個是字典中的鍵,第二個是字典中的值　　 #?并且這個高仿的列表可以轉(zhuǎn)化成列表 print(list(key_value_list?)) #?它還可以循環(huán)打印 dic?=?{'劍圣':'易','哈啥給':'劍豪','大寶劍':'蓋倫'} for?i?in?dic.items(): ????print(i) 結(jié)果： ('劍圣',?'易') ('哈啥給',?'劍豪') ('大寶劍',?'蓋倫')

這里補充一個知識點：分別賦值，也叫拆包。

a,b?=?1,2 print(a,b) 結(jié)果: 2 a,b?=?('你好','世界')??#?這個用專業(yè)名詞就叫做元組的拆包 print(a,b) 結(jié)果: 你好?世界 a,b?=?['你好','大飛哥'] print(a,b) 結(jié)果: 你好?世界 a,b?=?{'汪峰':'北京北京','王菲':'天后'} print(a,b) 結(jié)果: 汪峰?王菲

所以利用上面剛學的拆包的概念，我們循環(huán)字典時還可以這樣獲取字典的鍵，以及值：

for?k,v?in?dic.items(): ????print('這是鍵',k) ????print('這是值',v) 結(jié)果: 這是鍵?劍圣 這是值?易 這是鍵?哈啥給 這是值?劍豪 這是鍵?大寶劍 這是值?蓋倫

4.1.5字典的嵌套

字典的嵌套是非常重要的知識點，這個必須要建立在熟練使用字典的增刪改查的基礎(chǔ)上，而且字典的嵌套才是咱們在工作中經(jīng)常會遇到的字典，工作中遇到的字典不是簡簡單單一層，而就像是蔥頭一樣，一層接一層，但一般都是很有規(guī)律的嵌套，那么接下來我們就學習一下字典的嵌套：

現(xiàn)在有如下字典，完成一下需求：

dic?=?{ ????'name':'汪峰', ????'age':48, ????'wife':[{'name':'國際章','age':38}], ????'children':{'girl_first':'小蘋果','girl_second':'小怡','girl_three':'頂頂'} } 1.?獲取汪峰的名字。 2.獲取這個字典：{'name':'國際章','age':38}。 3.?獲取汪峰妻子的名字。 4.?獲取汪峰的第三個孩子名字。

解題思路：

1.獲取汪峰的名字。:?這個比較簡單，汪峰就是dic的一個鍵對應的值，我們通過這個key就可以獲取到汪峰這個值。

name?=?dic['name']print(name)

2.?獲取這個字典{'name':'國際章','age':38}:?想要獲取這個字典，先要看字典從屬于誰？這個字典從屬于一個列表，而這個列表是字典wife對應的鍵，所以咱們應該先通過wife獲取到對應的這個列表，然后通過這個列表按照所以取值取到對應的這個字典。

l1?=?dic['wife']??#?先獲取到這個列表 di?=?l1[0]??#?列表按照索引取值，這個字典是列表的第一個元素，所以通過索引獲取到這個字典 print(di) #?當然上面是分布獲取的，我們還可以合并去寫： di?=?dic['wife'][0] print(di)

3. 獲取汪峰的妻子名字:?還是按照上一題的思路：想要獲取汪峰妻子的名字：國際章，那么他是一個字典的鍵對應的值，所以我們通過'name'這個鍵就可以獲取到對應的值，這個題的難點是獲取到這個小字典，而上一個題我們已經(jīng)獲取了這個小字典，所以在上面的基礎(chǔ)上再執(zhí)行就可以了。

di?=?dic['wife'][0]??#?這個是上一次題獲取的小字典的代碼 wife_name=?di['name']??#?通過小字典然后再通過鍵就能獲取到對應的值 print(wife_name) #?當然咱們可以簡化： wife_name?=?dic['wife'][0]['name] print(wife_name)

4.?獲取汪峰的第三個孩子名字:?汪峰的孩子們是在一個字典中的，你要想獲取汪峰的第三個孩子，你應該先獲取到它從屬于的這個字典，然后再通過這個字典獲取第三個孩子的名字。

dic2?=?dic['children']??#?先獲取這個字典 name?=?dic2['girl_three']??#?在通過這個字典獲取第三個孩子的名字 print(name) #?當然你可以簡化： name?=?dic['children']['girl_three'] print(name)

dic1?=?{ ?'name':['alex',2,3,5], ?'job':'teacher', ?'oldboy':{'alex':['python1','python2',100]} ?} 1，將name對應的列表追加?個元素’wusir’。 2，將name對應的列表中的alex?字??寫。 3，oldboy對應的字典加?個鍵值對’?男孩’,’linux’。 4，將oldboy對應的字典中的alex對應的列表中的python2刪除 相關(guān)練習題

人工智能 python 軟件開發(fā)云 云計算

版權(quán)聲明：本文內(nèi)容由網(wǎng)絡用戶投稿，版權(quán)歸原作者所有，本站不擁有其著作權(quán)，亦不承擔相應法律責任。如果您發(fā)現(xiàn)本站中有涉嫌抄襲或描述失實的內(nèi)容，請聯(lián)系我們jiasou666@gmail.com 處理，核實后本網(wǎng)站將在24小時內(nèi)刪除侵權(quán)內(nèi)容。