利用Python進行數據分析之Python的數據結構

##元組
元組是一個固定長度，不可改變的Python序列對象。創建元組的最簡單方式，是用逗號分隔一列值

在這裏插入tup = 4,5,6#元組
tup

輸出：
(4, 5, 6)

nested_tup = (1,2,3),(4,5,6)
nested_tup

輸出：
((1, 2, 3), (4, 5, 6))

tuple([4,0,2])
tup = tuple('string')
tup[0]

輸出：
‘s’

tup = 4,5,6#將元組賦值給類似元組的變量Python會試圖拆分等號右邊的值。
a,b,c = tup
b

輸出：
5

tup = 4,5,(6,7)#即使含有元組的元組也會被拆分
a,b,(c,d) = tup#注意這裏要用括號元組啥樣它啥樣
c

輸出：
6

a,b = 1,2#python中可以着麼換
b,a = a,b

print(a)#2
print(b)#1

values = 1,2,3,4,5
a,b,*rest = values#常見寫法爲a,b,*_ = values
a,b
rest

輸出：
[3, 4, 5]

#tuple方法
a = (1,2,2,2,3,4,2)#用count統計某個值出現的頻率
a.count(2)#4

#列表，與元組相比列表的長度可變，內容可以被修改。可用方括號定義，或用list函數
#列表與元組的語義接近，在許多函數中可以交叉使用。
b_list = [2,3,7,None, ]#不是錯誤，逗號結尾沒報錯。。
print(b_list)
tup = ('zr','wp','wjw')
a_list = list(tup)
print(a_list)
a_list[1] = 'zt'
print(a_list)

輸出：
[2, 3, 7, None]
[‘zr’, ‘wp’, ‘wjw’]
[‘zr’, ‘zt’, ‘wjw’]

#list函數常用來在數據處理中實體化迭代器或生成器
gen = range(10)
print(gen)
print(list(gen))

輸出：
range(0, 10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

#用append在列尾添加元素
a_list.append('xy')
print(a_list)
#insert可在特定位置插入元素,插入的序號必須在0和列表長度之間
a_list.insert(1,'wp')
print(a_list)
#pop，移除並返回指定位置的元素
print(a_list.pop(2))
print(a_list)
#可用remove去除某個值，remove會先尋找第一個值併除去：
a_list.append('zr')
print(a_list)
a_list.remove('zr')
print(a_list)
#用in可以檢查列表是否包含某個值
print('zr' in a_list)
print('zr' not in a_list)
#zai列表中檢查是否存在某個值遠比字典和集合速度慢，因爲python是線性搜索列表中的值，但在字典和集合中，在同樣的時間內還可以檢查其他項（基於哈希表）

輸出：
[‘wp’, ‘wp’, ‘xy’, ‘xy’, ‘xy’, ‘zr’, ‘xy’, ‘zr’, ‘xy’]
[‘wp’, ‘wp’, ‘wp’, ‘xy’, ‘xy’, ‘xy’, ‘zr’, ‘xy’, ‘zr’, ‘xy’]
wp
[‘wp’, ‘wp’, ‘xy’, ‘xy’, ‘xy’, ‘zr’, ‘xy’, ‘zr’, ‘xy’]
[‘wp’, ‘wp’, ‘xy’, ‘xy’, ‘xy’, ‘zr’, ‘xy’, ‘zr’, ‘xy’, ‘zr’]
[‘wp’, ‘wp’, ‘xy’, ‘xy’, ‘xy’, ‘xy’, ‘zr’, ‘xy’, ‘zr’]
True
False

#串聯和組合列表
#可用加號將兩個列表串聯起來
[4,None,'zr'] + [7,8,(1,2)]

輸出：
[4, None, ‘zr’, 7, 8, (1, 2)]

#排序sort函數排序
a = [4,1,5,7,9]
a.sort()
print(a)
#二級排序key，按字符長度對字符串進行排序：
b = ['pthon','c++','c','verilog']
b.sort(key = len)
print(b)

輸出：
[1, 4, 5, 7, 9]
[‘c’, ‘c++’, ‘pthon’, ‘verilog’]

#二分搜索和維護已排序的列表
#bisect模塊支持二分查找，和向已排序的列表插入值。bisect.bisect可以找到插入值後仍保證排序的位置，bisect.insort是向這個位置插入值
import bisect
c = [1,2,3,3,3,3,4,5,7]
print(bisect.bisect(c,2))
print(bisect.bisect(c,3))
bisect.insort(c,6)
print(c)
#note:bisect module cannot examine the list sort,if examine it will cost many time.so if list not sort will not error but the result maybe not true.

輸出：
2
6
[1, 2, 3, 3, 3, 3, 4, 5, 6, 7]

#切片
zr = [2,4,56,1,6,1,6,8,9,4]
print(zr[1:6])
#qiepian fuzhi包括起始元素，不包括結束元素還有是賦值代替的意思不是增加
zr[7:8] = [0,7]
print(zr)
print(zr[:6])
print(zr[6:])
print(zr[-4:])
print(zr[-6:-2])
#在第二個冒號後面使用step，可以隔一個取一個
print(zr[::2])
#使用-1，可以使列表或元組顛倒過來
print(zr[::-1])

輸出：
[4, 56, 1, 6, 1]
[2, 4, 56, 1, 6, 1, 6, 0, 7, 9, 4]
[2, 4, 56, 1, 6, 1]
[6, 0, 7, 9, 4]
[0, 7, 9, 4]
[1, 6, 0, 7]
[2, 56, 6, 6, 7, 4]
[4, 9, 7, 0, 6, 1, 6, 1, 56, 4, 2]

#序列函數
#enumerate函數
#i = 0
#for value in collection:
    #do something with value
    #i+=1
#我就經常這麼做，但是enumerate可以這麼做
#for i ,value in enumerate(collection):
    #do something with value
some_list = ['zr','wp','wjw']
mapping = {}
for i,v in enumerate(some_list):
    mapping[v] = i
print(mapping)

輸出：
{‘zr’: 0, ‘wp’: 1, ‘wjw’: 2}

#sorted函數
#sorted函數可以從任意序列的元素返回一個新的排好序的列表
zr = sorted([7,0,3,6,2,7,1,6,8,6,9])
print(zr)
wp = sorted('hello world')
print(wp)

輸出：
[0, 1, 2, 3, 6, 6, 6, 7, 7, 8, 9]
[’ ', ‘d’, ‘e’, ‘h’, ‘l’, ‘l’, ‘l’, ‘o’, ‘o’, ‘r’, ‘w’]

#zip函數
#zip可以將多個列表、元組或其它序列成對組合成一個元組列表
a = ['zr','wp','wjw']
b = ['shijian','sudu','jiasu']
zipped = zip(a,b)
print(list(zipped))
#zip可以處理任意多的數列，元素的個數取決於最短的序列
c = ['f','t']
zuhe = zip(a,b,c)
print(list(zuhe))
#zip的常見用法之一是同時迭代多個序列，可能結合enumerate使用
for i,(a,b) in enumerate(zip(a,b)):
    print('{0}:{1},{2}'.format(i,a,b))
#給一個“被壓縮的”序列，zip可以被用來解壓序列。也可以當作把行的列表轉換爲列的列表。
zr = [('鄒','瑞'),('王','鵬'),('佳','文')]
first_name,last_name = zip(*zr)
print(first_name)
print(last_name)

輸出：
[(‘zr’, ‘shijian’), (‘wp’, ‘sudu’), (‘wjw’, ‘jiasu’)]
[(‘zr’, ‘shijian’, ‘f’), (‘wp’, ‘sudu’, ‘t’)]
0:zr,shijian
1:wp,sudu
2:wjw,jiasu
(‘鄒’, ‘王’, ‘佳’)
(‘瑞’, ‘鵬’, ‘文’)

#reversed函數
#reversed可以從後向前迭代一個序列
print(list(reversed(range(10))))

輸出：
[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

#字典很重要常見名是哈希映射或關聯數組。他是鍵值對的大小可變的集合，鍵和值都是python的對象。方法之一爲使用尖括號，用冒號分隔鍵和值
#empty_dict = {}
d1 = {'a':'some value','b':[1,2,3,4]}
print(d1)
d1[7] = 'zr'
print(d1)
print(d1['a'])
#可用del關鍵字或pop方法（返回值的同時刪除鍵）刪除值
d1[5] = 'some value'
print(d1)
d1['wp'] = 'son'
print(d1)
del d1[5]
print(d1)
print(list(d1.keys()))
print(list(d1.values()))
#用updae方法可以將一個字典與另一個融合
d1.update({'b':'foo','c':13})#update方法是原地改變字典，因此任何傳遞給update的鍵的舊值都會被捨棄
print(d1)

輸出：
{‘a’: ‘some value’, ‘b’: [1, 2, 3, 4]}
{‘a’: ‘some value’, ‘b’: [1, 2, 3, 4], 7: ‘zr’}
some value
{‘a’: ‘some value’, ‘b’: [1, 2, 3, 4], 7: ‘zr’, 5: ‘some value’}
{‘a’: ‘some value’, ‘b’: [1, 2, 3, 4], 7: ‘zr’, 5: ‘some value’, ‘wp’: ‘son’}
{‘a’: ‘some value’, ‘b’: [1, 2, 3, 4], 7: ‘zr’, ‘wp’: ‘son’}
[‘a’, ‘b’, 7, ‘wp’]
[‘some value’, [1, 2, 3, 4], ‘zr’, ‘son’]
{‘a’: ‘some value’, ‘b’: ‘foo’, 7: ‘zr’, ‘wp’: ‘son’, ‘c’: 13}

#用序列創建字典
#一種寫法
#mapping = {}
#for key,value in zip(key_list,value_list):
#    mapping[key] = value
#因爲字典本質上是2元元組的集合，dict可以接受2元元組的列表
mapping = dict(zip(range(5),reversed(range(5))))
print(mapping)

輸出：
{0: 4, 1: 3, 2: 2, 3: 1, 4: 0}

from collections import defaultdict
#默認值
#常見邏輯
#if key in some_dict:
#    value = some_dict[key]
#else:
#    value = default_value
#簡寫成
#value = some_dict.get(key,default_value)
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)
#print(by_letter)
for word in words:
    letter = word[0]
    by_letter.setdefault(letter,[]).append(word)
print(by_letter)

by_letter = defaultdict(list)
for word in words:
    by_letter[word[0]].append(word)
print(by_letter)

輸出：
{‘a’: [‘apple’, ‘atom’], ‘b’: [‘bat’, ‘bar’, ‘book’]}
defaultdict(<class ‘list’>, {‘a’: [‘apple’, ‘atom’], ‘b’: [‘bat’, ‘bar’, ‘book’]})

#有效的鍵類型
#字典的值可以是任意Python對象，而鍵值通常是不可變的標量類型（整數，浮點數，字符串）或元組（元組中的對象必須是不可變的）。這被稱爲“可哈希性”。
#可用hash函數檢測一個對象是否是可哈希的。（可被用作字典的鍵）
#列表不可哈希（不能當作鍵值），因此將列表轉爲元組。
d = {}
d[tuple([1,2,3])] = 5
print(d)

輸出：
{(1, 2, 3): 5}

#集合
#集合是無序的不可重複的元素的集合，可以當作字典，但只有鍵沒有值。可用兩種方式創建集合；通過set函數或使用尖括號set語句
a = set([2,2,2,1,3,3])
b = {2,2,2,1,3,3}
print(a)
print(b)
#集合支持合併、交集、差分、和對稱差等數學集合運算
a = {1,2,3,4,5}
b = {3,4,5,6,7,8}
print(a.union(b))#hebing
print(a | b)
#交集
print(a.intersection(b))
print(a & b)
#與字典相似，集合元素通常是不可變的，要獲得類似列表的元素，必須轉換成元組
#檢測一個集合是否是另一個集合的1子集或父集

輸出：
{1, 2, 3}
{1, 2, 3}
{1, 2, 3, 4, 5, 6, 7, 8}
{1, 2, 3, 4, 5, 6, 7, 8}
{3, 4, 5}
{3, 4, 5}

#列表、集合、和字典推導式
#列表推導式是Python最喜愛的特徵之一。它允許用戶方便的從一個集合過濾元素，形成列表，在傳遞參數的過程中還可以修改元素
#[expr for val in collection if condition]
strings = ['a','as','bat','car','dove','python']
[x.upper() for x in strings if len(x)>2]
#相似的還可以推導集合和字典
#dict_comp = {key-expr : value-expr for value in collection if condition}
#set_comp = {expr for value in collection if condition}
#map函數
a = set(map(len,strings))
print(a)
#字典（可以創建一個字符串的查找映射表以確定他在列表中的位置）
loc_mapping = {val : index for index,val in enumerate(strings)}
print(loc_mapping)

輸出：
{1, 2, 3, 4, 6}
{‘a’: 0, ‘as’: 1, ‘bat’: 2, ‘car’: 3, ‘dove’: 4, ‘python’: 5}
一天的學習筆記，自己的見解，如有什麼錯誤請指出，感激涕零。