利用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}
一天的学习笔记，自己的见解，如有什么错误请指出，感激涕零。