利用Python进行数据分析－数据结构准备（元组、列表、字典、集合、函数、推导式、柯里化、生成器、itertools模块以及文件读写）利用Python进行数据分析－数据

本文引用《利用Python进行数据分析·第2版》

元组tuple 元组是一个固定长度而且不可以改变的序列对象
定义元组的方法: (1) 最简单的方法:

In [23]: top = 1,2,3In [24]: topOut[24]: (1, 2, 3)

(2) 复杂元组的定义:

In [25]: top = (1,2,3),(4,5)In [26]: topOut[26]: ((1, 2, 3), (4, 5))

常用方法: tuple : 将任意序列或者迭代器转换成元组

In [27]: tuple([1,2,3])Out[27]: (1, 2, 3)In [28]: tuple("wt")Out[28]: ('w', 't')

count：统计频率

In [50]: a = 1,2,2,3In [51]: a.count(2)Out[51]: 2

访问 : 可以直接通过下标来访问

In [29]: top[0]Out[29]: (1, 2, 3)

修改:元组的对象一旦定义便不可以修改，除非其中存储的对象是可变对象，例如：

In [30]: top = 1, [1,2,3],'a'In [31]: top[1].append('wt')In [32]: topOut[32]: (1, [1, 2, 3, 'wt'], 'a')

备注: [1,2,3]　为列表，有序的集合，可以随时添加和删除其中的元素
串联：　可以使用加法运算符把元组串联起来

In [32]: topOut[32]: (1, [1, 2, 3, 'wt'], 'a')In [33]: top + (4,5,6)　＃第一种情况Out[33]: (1, [1, 2, 3, 'wt'], 'a', 4, 5, 6)In [45]: top * 2＃第二种情况Out[45]: (1, [1, 2, 3, 'wt'], 'a', 1, [1, 2, 3, 'wt'], 'a')

拆分：拆分有两种情况，一种是等量拆分，另一种是不等量拆分等量拆分：

In [34]: top = 1,2,3In [35]: a,b,c = topIn [36]: aOut[36]: 1

不等量拆分，ｐ可以分配不等长度的列表

In [42]: a,*p = topIn [43]: pOut[43]: [2, 3]

变量拆分常用来迭代元组或者列表序列

In [46]: seq = (1,2,3),(4,5,6)In [49]: for a,b,c in seq:...:print("a = {0}, b = {1}, c = {2}".format(a,b,c))...:a = 1, b = 2, c = 3a = 4, b = 5, c = 6* * *

列表list 与元组相比，列表的长度和内容都是可变的
定义的方法：１．直接定义

In [52]: a_list = [1,2,3,'wt']In [53]: a_listOut[53]: [1, 2, 3, 'wt']

２．使用list函数，list函数在数据处理中常用来实体化迭代器和生成器

In [58]: b_list = range(2,10)In [59]: list(b_list)Out[59]: [2, 3, 4, 5, 6, 7, 8, 9]

添加和删除元素：１．使用append在列表末尾添加元素

In [60]: a_list.append('wt')In [61]: a_listOut[61]: [1, 2, 3, 'wt', 'wt']

２．使用insert在指定位置上添加元素

In [63]: b_list = list(b_list)In [64]: b_list.insert(1,'wt')In [65]: b_listOut[65]: [2, 'wt', 3, 4, 5, 6, 7, 8, 9]

３．使用pop去除指定的元素

In [66]: b_list.pop(2)Out[66]: 3In [67]: b_listOut[67]: [2, 'wt', 4, 5, 6, 7, 8, 9]

４．使用remove去除某个匹配值，优先去除找到的第一个

In [69]: b_list = ['wt',1,2,'wt']In [70]: b_list.remove('wt')In [71]: b_listOut[71]: [1, 2, 'wt']

常用方法：１．使用in去检查列表里面是否含有某个值（not ni）

In [72]: 'wt' in b_listOut[72]: True

2.串联和组合列表 (1)　使用 + 号将两个列表串联起来

In [73]: [1,2,3] + [4,5,6]Out[73]: [1, 2, 3, 4, 5, 6]

(2)　使用extend方法追加多个元素（添加的新对象为列表类型，与append不同的是，append添加的是单个元素）

In [76]: b_list.extend(['wt','wt'])In [77]: b_listOut[77]: [1, 2, 'wt', 'wt', 'wt']

区别：使用 + 号串联对象的开销比较大，因为要新建一个列表，如果对象是一个大列表的时候，使用extend追加元素会比较可取
３．使用sort()函数进行原地排序（不创建新的对象）

In [80]: a = [3,2,1]In [81]: a.sort()In [82]: aOut[82]: [1, 2, 3]

４．切片

利用Python进行数据分析－数据结构准备（元组、列表、字典、集合、函数、推导式、柯里化、生成器、itertools模块以及文件读写）

文章图片
切片示例图切片的赋值：（注意要与Numpy的特点区分开来，Numpy切片下产生的是视图，而不是新的对象）

In [83]: a = [1,2,3,4,5,6,7,8,9]In [85]: a[2:3] = ['wt','wt']In [86]: aOut[86]: [1, 2, 'wt', 'wt', 4, 5, 6, 7, 8, 9]In [87]: b = a[2:3]＃产生一个新的对象In [88]: b = [1,1]＃赋值In [89]: bOut[89]: [1, 1]In [90]: aOut[90]: [1, 2, 'wt', 'wt', 4, 5, 6, 7, 8, 9]＃a的切片区域，数值没有被改变，说明产生的并非视图In [91]: a[::2]＃隔两个数取一个值，顺序Out[91]: [1, 'wt', 4, 6, 8]In [92]: a[::-1]＃隔一个数取一个值，倒叙Out[92]: [9, 8, 7, 6, 5, 4, 'wt', 'wt', 2, 1]

序列函数： enumerate函数，可以返回（i,value）元组序列

In [93]: for i,value in enumerate(a):　＃测试用例...:print(i,value)...:0 11 22 wt

sorted函数从任意序列中返回一个已经拍好序的列表（列表的元素需要为同一类型）：

In [96]: sorted(["dscdcsd fsdf"])#空格为分割符Out[96]: ['dscdcsd fsdf']

zip函数可以将多个列别，元组或者其它序列组合成一个新的列表

In [98]: seq1 = [1,2,3]In [99]: seq2 = ['wt','wt']In [100]: seq3 = zip(seq1,seq2)In [101]: seq3#注意，如需展示列表，需要收到转换list()Out[101]:报错信息In [102]: list(seq3)Out[102]: [(1, 'wt'), (2, 'wt')]In [104]: list(zip(seq1,seq2,seq4))#zip可以合并任意长度的列别，元素的个数取决于最短的序列Out[104]: [(1, 'wt', 4), (2, 'wt', 5)]In [107]: for i,j in zip(*(zip(seq1,seq2,seq4))):　＃zip还可以用来解压，注意需要在被解压对象之前添加一个＊号...:print(i,j)...:1 2wt wt4 5#### reversed函数可以对一个列表进行倒叙处理In [109]: list(reversed([1,2,3]))Out[109]: [3, 2, 1]* * *

字典dict 字典是Python重要的数据结构，被我们称之为哈希映射或者关联数组，键和值都是python对象, 其中，值可变但键不可变
创建方法：常用的创建方法是使用｛｝尖括号：

In [110]: dict = {"wt":10,"wt2":20}In [111]: dictOut[111]: {'wt': 10, 'wt2': 20}

访问、插入和设定：访问、插入和设定的方式可以像数组一样

In [2]: dict['wt3'] = 30#通过访问键的方式去插入In [3]: dictOut[3]: {'wt': 10, 'wt2': 20, 'wt3': 30}In [5]: dict['wt2']#通过键去访问值valueOut[5]: 20

删除值（同时也会删除键），使用del或者pop方法

In [7]: dictOut[7]: {'wt': 10, 'wt2': 20, 'wt3': 30}In [8]: del dict['wt3']#使用del方法去删除键为‘wt3’的值In [9]: dictOut[9]: {'wt': 10, 'wt2': 20}In [9]: dictOut[9]: {'wt': 10, 'wt2': 20}In [10]: value = https://www.it610.com/article/dict.pop('wt2')#使用pop方法去删除键为‘wt2’的值，并把删除的值赋值给valueIn [11]: valueOut[11]: 20In [12]: dictOut[12]: {'wt': 10}

常用方法：通过 in 去检查字典中是否含有指定的键

In [6]: 'wt2' in dictOut[6]: True

访问字典中所有的keys

In [13]: dict.keys()Out[13]: dict_keys(['wt'])

访问字典中所有的values

In [14]: dict.values()Out[14]: dict_values([10])

使用update融合字典

In [16]: dict.update({"wt2":20,"wt3":30})#使用update合并字典In [17]: dictOut[17]: {'wt': 10, 'wt2': 20, 'wt3': 30}

将两个序列组合成字典

In [18]: key_list = [1,2,3]In [19]: value_list = [4,5,6]In [20]: mapping = {} #组合的第一种方法 In [21]: for key,value in zip(key_list,value_list):...:mapping[key] = value...:In [22]: mapping Out[22]: {1: 4, 2: 5, 3: 6} #组合的第二种方法 In [23]: list = list(zip(key_list,value_list)) In [24]: list Out[24]: [(1, 4), (2, 5), (3, 6)]#此为二元列表，可以使用dict方法来转换成字典 In [31]: mapping2 = dict(list） In [32]: mapping2 Out[32]: {1: 4, 2: 5, 3: 6}

默认值 dict的方法get和pop可以取默认值，并返回

#此种代码逻辑十分常见 In [33]: if key in some_dict: ...:value = https://www.it610.com/article/some_dict[key] ...: else: ...:value = default_value ...:

常用的方法还有collections, defaultdict, setdefault
集合set 集合是无序而又没有重复元素的集合，可以看作只有键而没有值的字典
定义方法: 直接使用{}尖括号

In [34]: mySet = {1,2,3}In [35]: mySet Out[35]: {1, 2, 3}

使用方法set

In [36]: mySet = set([4,5,6])In [37]: mySet Out[37]: {4, 5, 6}

常用方法：合并，取两个集合不重复的元素，然后组合成一个新的集合，可以用union方法或者 | 运算符

In [38]: set1 = {1,2,3}In [39]: set2 = {2,3,4}In [40]: set1.union(set2)#第一种方法，使用union Out[40]: {1, 2, 3, 4}In [41]: set1 | set2#第二种方法，使用 | 运算符 Out[41]: {1, 2, 3, 4}

交集，取两个集合中重复的集合，然后组合成一个新的集合，可以用intersection 或者 & 运算符

In [42]: set1.intersection(set2)#第一种方法，使用intersection Out[42]: {2, 3}In [43]: set1 & set2# 第二种方法，使用 & 运算符 Out[43]: {2, 3}

文章图片
集合常用的方法
所有逻辑集合操作都有另外的原地实现方法，可以直接用结果替代集合的内容。对于大的集合，这么做效率更高。
列表，集合，字典推导式列表推导式：

[expr for val in collection if condition]

集合推导式

set_comp = {expr for value in collection if condition}

字典推导式

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

函数函数的应用十分广泛，其中，值得注意的是，函数的返回值的形式可以多种多样，例如，返回字典

def f(): a = 5 b = 6 c = 7 return {'a':a,'b':b,'c':c}

有时候，我们需要对同一个字符串做一系列的函数操作，此时，最简单的方法是，我们把所有的方法封装成一个列表，然后再遍历执行（多函数模式）

def remove_punctuation(value): return re.sub('[!#?]', '', value)clean_ops = [str.strip, remove_punctuation, str.title]#一系列的函数名def clean_strings(strings, ops): result = [] for value in strings: for function in ops:#遍历调用列表中的函数 value = https://www.it610.com/article/function(value) result.append(value) return result

等同于

def clean_strings(strings): result = [] for value in strings: value = https://www.it610.com/article/value.strip() value = re.sub('[!#?]', '', value) value = https://www.it610.com/article/value.title() result.append(value) return result

我们还可以将函数作为另一个函数的参数，例如内置的map函数，它的作用是在一组数据上应用一个函数：

In [10]: def change(value): return str(str(value) + "wt") ....: In [7]: list = [1,2,3]In [11]: for i in map(change,list):#将list的元素经过change()处理之后，再赋值给 i print(i) ....: 1wt 2wt 3wt

同时，我们还可以使用lambda匿名函数，这种用法要比完整的函数声明和定义要简洁得多

In [3]: def double(list,f): return [f(x) for x in list] ...: In [4]: print(double(my_list,lambda x:x*2)) [2, 4, 6]

柯里化，部分参数的应用柯里化是一个计算机科学术语，它的意思就是部分参数应用，由现有的函数组合成一个新的函数

In [5]: def add(x,y): ...:return x+y ...: In [6]: add_one = lambda x: add(x,1)#派生出一个新函数In [7]: print(add_one(2)) 3

等同于

In [9]: from functools import partial In [12]: add_one = partial(add,y=1)In [13]: print(add_one(2)) 3

生成器表达式

In [189]: gen = (x ** 2 for x in range(100))

itertools模块

文章图片
常用的函数读写文件 【利用Python进行数据分析－数据结构准备（元组、列表、字典、集合、函数、推导式、柯里化、生成器、itertools模块以及文件读写）】读写文件一般使用with语句，不仅方便读取数据，而且在退出代码块之后会自动清理文件

In [212]: with open(path , "r") as f:#读文件 .....:lines = [x.rstrip() for x in f]In [225]: with open('path'.txt', 'w') as handle:#写文件 .....:handle.writelines(x for x in open(path) if len(x) > 1)