用python做數據分析，python高斯求和_利用Python進行數據分析(3)- 列表、元組、字典、集合

本文主要是對Python的數據結構進行了一個總結，常見的數據結構包含：列表list、元組tuple、字典dict和集合set。

image

索引

左邊0開始，右邊-1開始

通過index()函數查看索引編號

lang = ['python', 'java', 'html']

lang.index('python')

0 # 索引從0開始

lang.index('html')

2

切片

索引左邊從0開始，右邊-1開始

含頭不含尾

步長可正可負

lst = [1, 2, 3, 4, 5, 6]

print(lst[:]) # 相當于是復制 lst

[1, 2, 3, 4, 5, 6]

print(lst[::2]) # 步長是2 [開始:結束:步長]

[1, 3, 5]

print(lst[-3:-1])

lst = [1,2,3,4,5,6]

print(lst[1:5:2]) # 常規用法

print(lst[-5:-2:2]) # 標號-5代表的是元素2，標號-2代表的是5，步長為2

print(lst[-5:4:2])

print(lst[1:-2:2])

[2,4]

list列表[]

特點

長度可變的

內容是可以修改的

創建

直接通過[]

通過list()函數

list(range(10))

list(1,2,3,4)

操作

列表和字符串一樣，都是序列，里面的元素是有序的，也有索引和切片。索引index左邊從0開始，右邊從-1開始，index()函數可以查看某個元素的索引編號。

追加

append：末尾追加，單個追加

insert(location, obj)：指定位置追加元素

extend：整體的擴編

刪除

pop(2)：刪除指定索引為2的元素，有返回值即刪除的元素值

remove(obj)：刪除指定元素，沒有返回值；如果存在多個，則刪除第一個元素

排序

sort：obj.sort(key=len)

sorted：sorted(obj)；默認是從小到大排序

bisect模塊：import bisect

bisect.bisect(obj,col)：返回插入的位置

bisect.insort(obj,col)：直接插入元素

反轉

通過步長-1進行反轉，[::-1]

通過reversed()進行反轉，得到的是可迭代對象，并且將迭代對象轉為為列表顯示

# 反轉1

print(lst[::-1]) # 通過步長為-1進行反轉

print(lst) # 不影響原來對象

[6, 5, 4, 3, 2, 1]

[1, 2, 3, 4, 5, 6]

# 反轉2

print(list(reversed(lst))) # 通過reversed函數進行反轉

[6,5,4,3,2,1]

print(list(reversed('abcde'))) # 對字符串進行反轉，列表顯示

['e', 'd', 'c', 'b', 'a']

元組tuple()

特點

固定長度、不可變

元組中的元素可以是任意類型

如果內部存在列表等可變的元素，則內部元素能夠進行修改

元組中的元素能夠通過索引進行訪問

創建

使用小括號，元素之間用逗號隔開；若只有元素，末尾也必須加上逗號：(5,)

通過tuple函數進行創建

tup = () # 創建空元組

print(tup)

tup1 = ('python', ) # 創建單個元組，必須在最后帶上逗號

print(tup1)

tup2 = (1, 2, (3, ), ["python", "java", "php"]) # 創建多重元組

元組和列表之間是互通的，通過list()和tuple()能夠實現列表和元組之間的轉化。通過dir(tuple)能夠查看元組對象的方法

操作

統計

統計元素出現的個數count()

嵌套拆包

tup = 4,5,(6,7)

a,b,(c,d) = tup # 嵌套拆包

遍歷序列

seq = [(1,2,3), (4,5,6), (7,8,9)]

for a, b, c in seq:

print('a={0}, b={1}, c={2}'.format(a,b,c))

# 結果

a=1, b=2, c=3

a=4, b=5, c=6

a=7, b=8, c=9

image

高級功能

特殊語法*rest

values = 1,2,3,4,5

a,b,*rest = values

rest

[3,4,5]

如果想丟棄某些元素，將rest換成下劃線_

a,b,*_ = values

用途

元組表列表操作速度快；

在進行遍歷操作的時候，請用元組代替列表

如果對不需要修改的數據進行“寫保護”，即改數據是常量，也要使用元組；如果需要改變這些值，轉換為列表進行修改

元組在字典中可以當做key來使用，但是列表不可以

字典dict{}

特點

常用的名字是哈希表或者關聯數組

由鍵值對組成，鍵是不可變的(哈希的)，值是可變的

創建

通過dict函數

直接通過{}中括號創建，中間用逗號隔開

操作

刪除

del：del dict[k1]，內存中也沒有了

clear：D.clear()變成了空字典，但內存中仍存在

pop：D.pop(k[,d])，以字典的鍵為參數，刪除鍵值對

更新

update：更新字典，沒有返回值

獲取鍵、值

關于鍵值對、鍵、值的獲取主要用到的是items()、keys()、values()三種方法，三種方法得到的結果都能夠用for進行遍歷，獲取單個元素：

函數

作用

items

獲取鍵值對

keys

獲取所有的鍵

values

獲取所有的值

默認值相關

get

獲取某個鍵key的值value：dict.get(k, [,d])鍵不存在返回指定的值d

setdefault

類似get方法，如果鍵不存在，返回指定的值，并在字典中增加這個鍵值對；如果不指定返回值，默認是None

看一個具體的例子

ab = {'language': 'python', 'city': 'shenzhen', 'code': '101'}

print(ab.get("language"))

print(ab['language']) # 當鍵存在時，二者作用相同

print(ab.get('number')) # 返回的是None，但是原來的字典不變

# print(ab['number']) 報錯

print(ab.get('number', '1234')) # 返回值是1234，但是原來的字典不變

print(ab.setdefault('number', '1234')) # 返回值是1234，并且原來的字典添加了鍵值對'number':'1234'

# 執行setdefault()后的結果

{'language': 'python', 'city': 'shenzhen', 'code': '101', 'number': '1234'}

栗子

根據首字母分類為包含列表的字典

words = ['apple', 'bat', 'bar', 'atom', 'book']

by_letter = {}

for word in words:

letter = word[0] # 取出每個單詞的首字母

if letter not in by_letter:

by_letter[letter] = [word] # 首字母第一次不存在則創建

else:

by_letter[letter].append(word) # 當首字母之后，直接進行追加

使用setdefault來解決

words = ['apple', 'bat', 'bar', 'atom', 'book']

by_letter = {}

for word in words:

letter = word[0]

by_letter.setdefault(letter, []).append(word) # 創建letter為首字母的鍵，值為word組成的列表的鍵值對

使用內建模塊defaultdict來解決，defaultdict(function_factory)構建的是一個類似dictionary的對象

keys的值，自行確定賦值；values的類型，是function_factory的類實例，而且具有默認值。

比如default(int)則創建一個類似dictionary對象，里面任何的values都是int的實例，而且就算是一個不存在的key, d[key] 也有一個默認值，這個默認值是int()的默認值0

from collections import defaultdict

by_letter = defaultdict(list) # 創建一個類似dict的對象，values都是list類型

for word in words:

by_letter[word[0]].append(word)

集合set{}

特點

無序的，沒有索引，不屬于序列

元素唯一，不重復

元素不可變，可哈希

空集合只能通過set()創建

創建

set方法

通過{}直接創建，還帶去重功能

方法

常見的集合方法及其作用

方法

作用

add()

給一個集合增加元素，參數只能有一個：增加的元素

update

用原有集合自身和其他東西構成的新集合，來更新原來的集合

pop

隨機刪除一個元素，返回元素本身；不能指定參數，不能指定刪除某個元素

remove(obj)

obj必須是集合set中的元素，否則報錯；沒有返回值

discard(obj)

obj如果在集合中就執行刪除，否則不進行任何操作，與remove不同

clear()

刪除所有元素，bool(set)為False

操作

常見的操作

并集：union、|

交集：intersection、&

子集(包含于)：issubset()

超集(包含)：issuperset()

image

內建函數

enumerate

遍歷序列的同事跟蹤其索引，使用enumerate()，返回的是(i, value)

lst = ["foo", "bat", "bar"]

mapping = {}

for i,v in enumerate(lst):

mapping[v] = i # 鍵是lst中的元素，值是該元素的索引

sorted

sorted函數返回的是排序好的一個列表，默認是從小到大

sorted([1,3,4,2,6,5])

[1,2,3,4,5,6]

zip

配對

將列表、元組或者其他序列中的元素進行配對組合，新建一個元組構成的列表

image-20200407172659855

生成的長度由最短的序列決定。有時和enumerate()連用：

for i, (a,b) in enumerate(zip(seq1, seq2)):

print('{0}:{1},{2}'.format(i,a,b))

拆分

將已經配對的序列用zip進行拆分，注意*的使用

first_name, last_name = zip(*pitchers)

image

利用zip實現矩陣轉置

list2 = [[1, 2], [3, 4], [5, 6]]

list(zip(*list2))

[(1,3,5), (2,4,6)]

map

方法中有兩個參數，一個是函數，另一個是待運行的序列，基本樣式：map(func, seq)

func是一個函數對象，seq是序列對象

執行：可迭代序列對象seq中的元素，依次取出來放入函數func對象進行執行，相當于是for循環。

返回值被放入一個列表

items = list(range(10))

def square(x):

return x*2

list(map(square, items)) # 函數+序列

list1 = range(1, 6)

list2 = range(6, 11)

list(map(lambda x, y: x + y, list1, list2)) # 將兩個list中的對象一次相加

求出兩個列表中對應位置的較大值

a = [1, 2, 3, 4, 5]

b = [2, 3, 2, 4, 8]

list(map(lambda x: max(x), zip(a,b)))

reduce

在Python3中reduce已經被轉移到functools模塊里面了，使用的時候需要進行導入：

from functools import reduce

兩個參數 reduce(function, seq)

執行：從左到右根據函數一次執行

返回值是一個value

image

高斯求和利用reduce函數實現

lst = range(1, 101)

reduce(lambda x, y: x+y, lst)

filter

filter翻譯成中文就是過濾器的意思，在Python起到了過濾的作用，將滿足條件的對象進行輸出:

兩個參數：函數+可迭代對象

滿足條件的對象進行輸出

numbers = range(-5, 5)

list(filter(lambda x: x < 0, numbers)) # 選出小于0的數，返回列表list

推導式

列表推導式

[x.upper() for x in strings if len(x) > 2]

image

字典推導式

dict_comp = {key-expr: value-expr for value in collections if condition}

創建一個字符串與其位置相匹配的字典

loc_mapping = {val: index for index, val in enumerate(strings)}

集合推導式

set-comp = {expr for value in collection if condition}

unique_len = {len(x) for x in strings}

上述功能使用map函數

set(map(len, strings))

嵌套推導式

some_tuples = [(1,2,3),(4,5,6),(7,8,9)]

# 方法1

flattened = [x for tup in some_tuples for x in tup]

# 方法2：列表推導式中的列表推導式

[[x for x in tup] for tup in some_tuples]

# 方法3:for循環

flattened = []

for tup in some_tuples:

for x in tup:

flattened.append(x) # 不斷地追加到末尾