Python 數據類型之list

1.1數值型

int(x) 返回一個整數
float(x) 返回一個浮點數
complex(x)、complex(x,y) 返回一個複數
bool(x) 返回布爾值，前面講過False等價的對象

1.2對象函數的處理

round(),總結：四捨六入，5取偶（最近的偶數）

print(round(2.5)) #2
print(round(2.5001)) #3
print(round(2.6)) #3

print(round(-2.5)) #-2
print(round(-2.5001)) #-3
print(round(-2.6)) #-3

int(),總結只取整數部分

print(int(3.5)) #3
print(int(3.4)) #3
print(int(3.6)) #3

//整除，總結整除而且向下取整

print(7//2, 7//-2, -7//2, -(7//2)) #3 -4 -4 -3
print(2//3, -2//3, -1//3) #0 -1 -1　　

math模塊總結 floor()向下取整 ,ceil()向上取整

print(math.floor(2.5), math.floor(-2.5)) #2 -3
print(math.ceil(2.5), math.ceil(-2.5))#3 -2

1.3數字處理函數

max(...)
    max(iterable, *[, default=obj, key=func]) -> value
    max(arg1, arg2, *args, *[, key=func]) -> value

min(...)
    min(iterable, *[, default=obj, key=func]) -> value
    min(arg1, arg2, *args, *[, key=func]) -> value

pow(x, y, z=None, /)
    Equivalent to x**y (with two arguments) or x**y % z (with three arguments)
    文檔上說使用三個參數時更高效

math.sqrt()
sqrt(...)
    sqrt(x)   
    Return the square root of x.

1.4類型判斷

type:返回類型，而不是字符串 

type(object_or_name, bases, dict)
type(object) -> the object's type
type(name, bases, dict) -> a new type

type隱式轉換
type(1+True)  #返回int

　　

isinstance:相比於type能夠判斷子類

isinstance(obj, class_or_tuple, /)
    Return whether an object is an instance of a class or of a subclass thereof.
    
    A tuple, as in ``isinstance(x, (A, B, ...))``, may be given as the target to
    check against. This is equivalent to ``isinstance(x, A) or isinstance(x, B)
    or ...`` etc.
i.e:
isinstance(6, (str, bool, int))

 

1.5列表

1.5.1列表特性

一個隊列，一個排列整齊的隊伍 
列表內的個體稱做元素，由若干元素組成列表 
元素能夠是任意對象（數字、字符串、對象、列表等） 
列表內元素有順序，可使用索引 
線性的數據結構 
使用 [ ] 表示
列表是可變的

1.5.2列表定義

list() -> new empty list 
list(iterable) -> new list initialized from iterable's items #迭代器也是可迭代對象，因此也能放迭代器
lst = list()
lst = [] 
lst = [2, 6, 9, 'ab'] 
lst = list(range(5))

1.5.3列表索引訪問

lst = [1,3,5,7,9,'a','b','c','d']

索引，也叫下標
正索引：從左至右，從0開始，爲列表中每個元素編號 
負索引：從右至左，從-1開始 
正負索引不能夠超界，不然引起異常IndexError 
爲了理解方便，能夠認爲列表是從左至右排列的，左邊是頭部，右邊是尾部，左邊是下界，右邊是 上界

訪問方式：
list[index] ，index就是索引，使用中括號訪問
lst[-1] #'d'
lst[1]   #3
lst[0:4] #[1, 3, 5, 7]
lst[-4:] #['a', 'b', 'c', 'd']

1.5.4列表查詢

lst = [1,3,5,7,9,'a','b','c','d']

index(value,[start,[stop]]) --->return first index of value.
1.經過值value，從指定區間查找列表內的元素是否匹配
2.匹配第一個就當即返回索引
3.匹配不到，拋出異常ValueError 

lst.index('a',1,6)　　#output 5
lst.index('a',-9,-3)  #output 5
總結index按照從左到右的順序查找，因此負數的時候也要按照次順序查找

count(value) -> integer -- return number of occurrences of value
返回列表中匹配value的次數 

時間複雜度 
1.index和count方法都是O(n) 
2.隨着列表數據規模的增大，而效率降低 


如何返回列表元素的個數？如何遍歷？如何設計高效？ 
len()  --->Return the number of items in a container；相似於計數器

1.5.5列表元素修改

索引訪問修改
list[index] = value  #經過下表對值從新賦值
lst[5]="aaaa"          #索引不要超界

1.5.6列表增長插入元素

append(object) -> None -- append object to end
1.列表尾部追加元素，返回None 
2.返回None就意味着沒有新的列表產生，就地修改 
3.時間複雜度是O(1) 
lst.append('e')


insert(index, object) -- insert object before index
1.在指定的索引index處插入元素object 
2.返回None就意味着沒有新的列表產生，就地修改
3.時間複雜度是O(n) p 
4.索引能超上下界嗎？
    1.超越上界，尾部追加
    2.超越下界，頭部追加

1.5.6列表增長插入元素

extend(...) method of builtins.list instance
    L.extend(iterable) -> None -- extend list by appending elements from the iterable
1.將可迭代對象的元素追加進來，返回None 
2. 就地修改 
ie:
lst.extend(range(10,20,2))


+ -> list
1.鏈接操做，將兩個列表鏈接起來 
2.產生新的列表，原列表不變 
3.本質上調用的是__add__()方法 
ie:
lst5=[1,2,3,4]
lst6=['a',['b','c']]
lst7=lst4+lst5     #output[1, 2, 3, 4, 'a', 'b']

lst7[0]=100
lst7               #output[100, 2, 3, 4, 1, 2, 3, 4]
lst4               #output[1, 2, 3, 4]

 * -> list 
1.重複操做，將本列表元素重複n次，返回新的列表
ie:
lst2 = ['a','c',[1,2]]*2 #output['a', 'c', [1, 2], 'a', 'c', [1, 2]]
lst2[0]='aaaaa'          #output['aaaaa', 'c', [1, 2], 'a', 'c', [1, 2]]
lst2[2][0]=11111       #output['aaaaa', 'c', [11111, 2], 'a', 'c', [11111, 2]]

總結簡單的object，list重複n次的時候，重複項已經獨立出來了，更改一個 ，不會所有變
        複雜的object，list中嵌套list，重複項未獨立出來，更改嵌套的list中一個值，所有變化

1.5.7列表刪除元素

remove(...) method of builtins.list instance
    L.remove(value) -> None -- remove first occurrence of value.
    Raises ValueError if the value is not present
1.從左至右查找第一個匹配value的值，移除該元素，返回None 
2. 就地修改 
3.效率是O(n)

pop(...) method of builtins.list instance
    L.pop([index]) -> item -- remove and return item at index (default last).
    Raises IndexError if list is empty or index is out of range.
1.不指定索引index，就從列表尾部彈出一個元素
2.指定索引index，就從索引處彈出一個元素，索引超界拋出IndexError錯誤 
3.效率，制定索引O(n),不指定索引O(1)

clear(...) method of builtins.list instance
    L.clear() -> None -- remove all items from L
1.清除列表全部元素，剩下一個空列表
2.頻繁clear會形成內存gc，當list太大是會影響性能

1.5.8列表的其餘操做

reverse(...) method of builtins.list instance
    L.reverse() -- reverse *IN PLACE*
1. 將列表元素反轉，返回None 
2.就地修改 


class reversed(object)
    reversed(sequence) -> reverse iterator over values of the sequence
    Return a reverse iterator
ie:
tmp = reversed(lst)
tmp    #output <list_reverseiterator at 0x7fdef40fc4e0>
for i in tmp:
    print(i)

總結
在查詢幫助文檔的時候會顯示function，method 再此以reverse()和reversed()作(i，e)
reverse是method；與類和實例有綁定關係的function都屬於方法（method）定義的lst是一個類的實例，因此能夠調用lst.reverse()
reversed()是function，與類和實例無綁定關係的function都屬於函數（function），函數通常須要傳遞一個參數，因此能夠調用reversed(lst)

reversed 返回一個iterator,all of iterator is iterable，list函數傳遞一個iterable，因此能夠傳遞迭代器iterator做爲參數，能夠打印reversed的值了

1.5.9列表排序操做

sort(...) method of builtins.list instance
    L.sort(key=None, reverse=False) -> None -- stable sort *IN PLACE*
    true 1 false 0
1.對列表元素進行排序，就地修改，默認升序 
2.reverse爲True，反轉，降序 
3.key一個函數，指定key如何排序 
    lst.sort(key=functionname)

1.5.10 in

in 成員運算符
1 in [1,2,3,4,5,[2,3]]
返回True

[2,3] in [1,2,3,4,5,[2,3]]
返回True

 1.5.11深淺copy

#淺copy的引用類型，引用的內存地址相同
lst3 = [1,[2,3],4,5]
lst4 = lst3.copy()
id(lst3[1])==id(lst4[1])