3內(nèi)置數(shù)據(jù)結(jié)構(gòu)_數(shù)值_列表

內(nèi)置數(shù)據(jù)結(jié)構(gòu)

?

幫助：

手冊(cè)中找關(guān)鍵字；

help(keyword)，keyword可以是變量、對(duì)象、類名、函數(shù)名、方法名；

?

分類：

數(shù)值型：int,float,complex,bool；

sequence序列對(duì)象：str,list,tuple；

鍵值對(duì)：set集合（約定set為集，collection為集合類型），dict字典；

?

?

?

數(shù)值型：

int,float,complex,book都是class，1,5,0,2+3j都是對(duì)象（即實(shí)例）；

int，python3的int就是長整型，且沒有大小限制（沒有上限，指進(jìn)程尋址的最大內(nèi)存區(qū)域），受制于內(nèi)存區(qū)域的大小；

float，由整數(shù)部分和小數(shù)部分組成，支持十進(jìn)制和科學(xué)計(jì)數(shù)法表示，只有雙精度型，通常浮點(diǎn)數(shù)比較時(shí)用<,>，不能用==（注：浮點(diǎn)數(shù)并不能完全準(zhǔn)確的表達(dá)我們指定的小數(shù)，只能說近似表達(dá)）；

complex，復(fù)數(shù)，由實(shí)數(shù)部分和虛數(shù)部分組成，實(shí)數(shù)部分和虛數(shù)部分都是浮點(diǎn)數(shù)，如3+4.2j；

bool，int的子類（類似哺乳類下的人類），僅有2個(gè)實(shí)例True（對(duì)應(yīng)1），False（對(duì)應(yīng)0），可以和整數(shù)直接運(yùn)算；

?

類型轉(zhuǎn)換：

int(x)，返回一個(gè)整數(shù)；

float(x)，返回一個(gè)浮點(diǎn)數(shù)；

complex(x)，complex(x,y)，返回一個(gè)復(fù)數(shù)；

bool(x)，返回布爾值；

?

數(shù)字的處理函數(shù)：

round()，不是四舍五入，是四舍六入五取偶，銀行家算法，其它語言的round()也一樣；

math.floor()，地板，向下取整；

math.ceil()，天花板，向上取整；?? #django.core.paginator.Paginator中Paginator.num_pages用到

int()，取整數(shù)部分，和//整除一樣；

min()；

max()；

pow()，等于x**6；

math.sqrt()，開平方；

bin()，進(jìn)制函數(shù)，返回值是字符串；

oct()，進(jìn)制函數(shù)，返回值是字符串；

hex()，進(jìn)制函數(shù)，返回值是字符串；

math.pi，取PI；

math.e，自如常數(shù)；

?

例：

In [1]: round(1.4)

Out[1]: 1

In [2]: round(1.5)

Out[2]: 2

In [3]: round(1.6)

Out[3]: 2

In [4]: round(2.6)

Out[4]: 3

In [5]: round(2.5)?? #四舍六入五取偶

Out[5]: 2

In [6]: import math

In [7]: math.floor(2.5)

Out[7]: 2

In [8]: math.ceil(2.5)

Out[8]: 3

?

類型判斷：

type(obj)，返回類型，而不是字符串；

isinstance(obj,class_or_tuple)，返回布爾值；

?

例：

In [9]: a=1

In [10]: type(a)

Out[10]: int

In [11]: type(type(a))

Out[11]: type

In [12]: type(a)==int

Out[12]: True

In [13]: isinstance(a,int)?? #類繼承時(shí)使用

Out[13]: True

In [14]: type(1+True)

Out[14]: int

In [15]: type(1+True+2.0)?? #有隱式轉(zhuǎn)換，int和float都是數(shù)值型，可理解為這倆是表親；

Out[15]: float

?

?

?

list：

一個(gè)隊(duì)列，一個(gè)排列整齊的隊(duì)伍（有序）；

列表內(nèi)的個(gè)體稱作元素（item或element），由若干元素組成列表；

元素可以是任意對(duì)象（數(shù)字、字符串、對(duì)象、列表）；

列表內(nèi)元素有順序，可以使用索引；

線性的數(shù)據(jù)結(jié)構(gòu)；

使用[]表示；

列表是可變的；

?

list列表、鏈表、queue隊(duì)列、stack棧的差異：

list，有序的整齊排列；

鏈表（元素手拉手在一起，不是網(wǎng)狀，在內(nèi)存中零散的存放，不能用索引）；

queue（先進(jìn)先出或后進(jìn)先出，可用list模擬queue）；

stack（壓棧，后進(jìn)先出，撂盤子）；

?

注：

賦值即定義（動(dòng)態(tài)語言與靜態(tài)語言的差別）；

?

list定義，初始化：

list()，new empty list；

list(iterable)，new list initialized from iterable's item，如lst=list(5)不可以，必須是可迭代對(duì)象，list()里要么放可迭代對(duì)象，要么什么都不放；

列表不能一開始就定義大??；

?

例：

In [16]: lst=list()?? #工廠方法定義

In [17]: lst=[]

In [18]: lst=[2,6,9,'ab',None]?? #通常用此種，定義和初始化一起搞

In [19]: lst=list(range(5))

In [21]: lst

Out[21]: [0, 1, 2, 3, 4]

In [22]: _?? #僅在ipython中使用此變量，返回上一次輸出

Out[22]: [0, 1, 2, 3, 4]

?

list索引訪問：

索引也叫下標(biāo)，列表通過索引訪問，list[index]，使用[]訪問；

正索引，從左至右，從0開始，為列表中的第一個(gè)元素編號(hào)；

負(fù)索引，從右至左，從-1開始；

正負(fù)索引不可以超界，否則引發(fā)異常IndexError；

為理解方便，可認(rèn)為列表是從左至右排列的，左邊是頭部，右邊是尾部，左邊是下界，右邊是上界；

?

list查詢：

index(value,[start,[stop]])，通過value，從指定區(qū)間查找列表內(nèi)的元素是否匹配；匹配第一個(gè)就立即返回索引；從左至右，從右至左，返回的索引值是不一樣的，通常從右至左找更快更便利，如在給定路徑中找文件名；匹配不到，拋出異常ValueError；

count(value)，返回列表中匹配value的次數(shù)；

?

時(shí)間復(fù)雜度：

O(1)，性能最好；

O(n),O(n**2)，隨著列表數(shù)據(jù)規(guī)模的增大而效率下降；

index()和count()都是O(n)；

如何返回列表元素的個(gè)數(shù)？如何遍歷？如何設(shè)計(jì)高效？len(lst)，len()是公共內(nèi)置函數(shù)，O(1)，增刪list元素時(shí)記錄著該list的類似元數(shù)據(jù)信息；

?

空間復(fù)雜度：生產(chǎn)中，尤其是vm中要考慮；

?

list元素修改：

lst[index]=value，索引訪問修改，索引不要超界；

?

list增加插入元素：

append(object)-->None，列表尾部追加元素，返回None；返回None就意味著沒有新的list產(chǎn)生，就地修改；時(shí)間復(fù)雜度O(1)；

insert(index,object)-->None，在指定的index處插入元素object；返回None，就地修改；時(shí)間復(fù)雜度O(1)，該方法少用，若在頭部或中間插入，整個(gè)內(nèi)存中的元素需移動(dòng)；

索引能超上下界嗎？超越上界，尾部追加，超越下界，頭部追加；

extend(iterable)-->None，將可迭代的元素追加進(jìn)來，返回None，就地修改；

+-->list，連接操作，將兩個(gè)list連接起來，產(chǎn)生新的list，原list不變；本質(zhì)上調(diào)用的是__add__()方法；

*-->list，重復(fù)操作，將本list元素重復(fù)n次，返回新的list；

?

注：

返回若不是None，將有特殊的編程方式；

list不適用insert元素，頭或中間插入時(shí)需要挪動(dòng)，鏈表適合insert；

?

list刪除元素：

remove(value)-->None，從左至右查找第一個(gè)匹配value的值，移除該元素返回None，就地修改；效率？不高；

pop([index])-->item，若不指定index就從list尾部彈出一個(gè)元素；指定index，就從索引處彈出指定元素；索引超界，拋出IndexError；效率？移除尾部元素效率高，不是尾部不要用；指定索引的時(shí)間復(fù)雜度？不指定索引的時(shí)間復(fù)雜度？

clear()-->None，清除列表的元素，剩下一個(gè)空列表；元素量大時(shí)會(huì)引起GC；

?

list其它操作：

reverse()-->None，將列表元素反轉(zhuǎn)，返回None，就地修改，少用；

sort(key=None,reverse=False)-->None，對(duì)列表元素進(jìn)行排序，就地修改，默認(rèn)升序，少用；reverse為True，反轉(zhuǎn)，降序；key（高階函數(shù)）指定一個(gè)函數(shù)，用于自定義排序；

in，not in，返回bool型；

?

例：

In [23]: lst=[1,2,3,4]

In [24]: lst.sort(reverse=True)?? #注意關(guān)鍵字參數(shù)，就地修改

In [25]: lst

Out[25]: [4, 3, 2, 1]

In [26]: lst.append('a')

In [27]: lst.sort(key=str)?? #把每個(gè)元素都轉(zhuǎn)為str，按ASCII碼排序

In [28]: lst

Out[28]: [1, 2, 3, 4, 'a']

In [29]: lst.sort(key=str,reverse=True)

In [30]: lst

Out[30]: ['a', 4, 3, 2, 1]

?

列表復(fù)制（深淺拷貝）：

在構(gòu)造嵌套結(jié)構(gòu)的列表時(shí)要注意；

==是值比較，內(nèi)容是否相同；

is是比較內(nèi)存地址，相當(dāng)于先取id()再比較；

?

copy()-->list，shadow copy，影子拷貝，淺拷貝，返回一個(gè)新列表，遇到引用類型，只是復(fù)制了一個(gè)引用，列表如果有嵌套則拷貝的是嵌套列表的內(nèi)存地址，內(nèi)層相當(dāng)于在引用；

?

深拷貝，copy模塊提供了deepcopy()，copy.deepcopy()；

?

?

例：

In [35]: lst0=list(range(4))

In [36]: lst1=list(range(4))

In [37]: lst0==lst1?? #但lst[0] is lst[1]結(jié)果為False

Out[37]: True

In [38]: lst2=lst0

In [39]: lst2[2]=10

In [42]: lst2==lst1

Out[42]: False

In [44]: lst0

Out[44]: [0, 1, 10, 3]

In [45]: lst1

Out[45]: [0, 1, 2, 3]

In [46]: lst2

Out[46]: [0, 1, 10, 3]

In [47]: id(lst0)?? #lst2引用lst0，這倆指向同一個(gè)內(nèi)存地址

Out[47]: 139655179771656

In [48]: id(lst2)

Out[48]: 139655179771656

?

例：

In [50]: lst3=list(range(4))

In [51]: lst4=lst3.copy()

In [52]: lst3==lst4

Out[52]: True

In [53]: lst3 is lst4

Out[53]: False

In [54]: lst3[2]=10

In [55]: lst3==lst4

Out[55]: False

?

例：

In [71]: lst5=[1,[2,3,4],5]

In [72]: lst6=lst5.copy()

In [73]: lst5==lst6

Out[73]: True

In [74]: lst5[1][1]=8

In [75]: lst5==lst6?? #注意，返回True，lst6是lst5的拷貝，對(duì)于嵌套結(jié)構(gòu)只copy()了引用

Out[75]: True

In [76]: lst5 is lst6

Out[76]: False

In [77]: lst5

Out[77]: [1, [2, 8, 4], 5]

In [78]: lst6

Out[78]: [1, [2, 8, 4], 5]

?

例：

In [1]: import copy

In [2]: lst0=[1,[2,3,4],5]

In [3]: lst1=copy.deepcopy(lst0)

In [4]: lst1[1][1]=8

In [5]: lst0==lst1

Out[5]: False

In [6]: lst0 is lst1

Out[6]: False

?

?

?

隨機(jī)數(shù)：

random模塊；

random.randint(a,b)，返回[a,b]之間的整數(shù)，兩邊都是閉區(qū)間（不同于range(a,b)，[a,b)前包后不包）；

random.choice(seq)，從非空序列的元素中隨機(jī)挑選一個(gè)元素，如random.choice(range(10))，從0-9中挑選一個(gè)整數(shù)，random.choice([1,3,5,7])；

random.randrange([start,]stop[,step])，同range()，從指定范圍內(nèi)，按指定基數(shù)遞增的集合中獲取一個(gè)隨機(jī)數(shù)，基數(shù)缺省值為1，如random.randrange(1,7,2)，返回1,3,5中的一個(gè)；

random.shuffle(list)-->None，就地打亂列表元素；

?

?

?

測(cè)試效率：

#作性能測(cè)試時(shí)把print()語句注釋掉，否則影響較大；

import datetime

start = datetime.datetime.now()

code segment

stop = datetime.datetime.now()

delta =(stop-start).total_seconds()

print(delta)