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

元组tuple

元组是一个固定长度而且不可以改变的序列对象

定义元组的方法:

(1) 最简单的方法:

In [23]: top = 1,2,3

In [24]: top

Out[24]: (1, 2, 3)

(2) 复杂元组的定义:


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

In [26]: top

Out[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,3

In [51]: a.count(2)

Out[51]: 2

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

1
2
3

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]: top

Out[32]: (1, [1, 2, 3, 'wt'], 'a')

备注: [1,2,3]　为列表，有序的集合，可以随时添加和删除其中的元素

串联：　可以使用加法运算符把元组串联起来

In [32]: top

Out[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,3

In [35]: a,b,c = top

In [36]: a

Out[36]: 1

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

In [42]: a,*p = top

In [43]: p

Out[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 = 3

a = 4, b = 5, c = 6

* * *

列表list

与元组相比，列表的长度和内容都是可变的

定义的方法：

１．直接定义

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

In [53]: a_list

Out[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_list

Out[61]: [1, 2, 3, 'wt', 'wt']

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

In [63]: b_list = list(b_list)

In [64]: b_list.insert(1,'wt')

In [65]: b_list

Out[65]: [2, 'wt', 3, 4, 5, 6, 7, 8, 9]

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

In [66]: b_list.pop(2)

Out[66]: 3

In [67]: b_list

Out[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_list

Out[71]: [1, 2, 'wt']

常用方法：

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

1
2
3

In [72]: 'wt' in b_list

Out[72]: True

2.串联和组合列表

(1)　使用 + 号将两个列表串联起来

1
2
3

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_list

Out[77]: [1, 2, 'wt', 'wt', 'wt']

区别：使用 + 号串联对象的开销比较大，因为要新建一个列表，如果对象是一个大列表的时候，使用extend追加元素会比较可取

３．使用sort()函数进行原地排序（不创建新的对象）

In [80]: a = [3,2,1]

In [81]: a.sort()

In [82]: a

Out[82]: [1, 2, 3]

４．切片

切片示例图

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

In [83]: a = [1,2,3,4,5,6,7,8,9]

In [85]: a[2:3] = ['wt','wt']

In [86]: a

Out[86]: [1, 2, 'wt', 'wt', 4, 5, 6, 7, 8, 9]

In [87]: b = a[2:3]　　＃产生一个新的对象

In [88]: b = [1,1]　　＃赋值

In [89]: b

Out[89]: [1, 1]

In [90]: a

Out[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 1

1 2

2 wt

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

1
2
3

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 2

wt wt

4 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]: dict

Out[111]: {'wt': 10, 'wt2': 20}

访问、插入和设定：

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

In [2]: dict['wt3'] = 30   #通过访问键的方式去插入

In [3]: dict

Out[3]: {'wt': 10, 'wt2': 20, 'wt3': 30}

In [5]: dict['wt2']   #通过键去访问值value

Out[5]: 20

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

In [7]: dict

Out[7]: {'wt': 10, 'wt2': 20, 'wt3': 30}

In [8]: del dict['wt3']                                    #使用del方法去删除键为‘wt3’的值

In [9]: dict

Out[9]: {'wt': 10, 'wt2': 20}

In [9]: dict

Out[9]: {'wt': 10, 'wt2': 20}

In [10]: value = dict.pop('wt2')                   #使用pop方法去删除键为‘wt2’的值，并把删除的值赋值给value

In [11]: value

Out[11]: 20

In [12]: dict

Out[12]: {'wt': 10}

常用方法：

通过 in 去检查字典中是否含有指定的键

1
2
3

In [6]: 'wt2' in dict

Out[6]: True

访问字典中所有的keys

1
2
3

In [13]: dict.keys()

Out[13]: dict_keys(['wt'])

访问字典中所有的values

1
2
3

In [14]: dict.values()

Out[14]: dict_values([10])

使用update融合字典

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

In [17]: dict

Out[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 = 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}

集合常用的方法
所有逻辑集合操作都有另外的原地实现方法，可以直接用结果替代集合的内容。对于大的集合，这么做效率更高。

列表，集合，字典推导式

列表推导式：

1	[expr for val in collection if condition]

集合推导式

1	set_comp = {expr for value in collection if condition}

字典推导式

1	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 = function(value)
        result.append(value)
    return result

等同于

def clean_strings(strings):
    result = []
    for value in strings:
        value = value.strip()
        value = re.sub('[!#?]', '', value)
        value = 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

生成器表达式

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

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)

Python的文件模式
Python重要的文件方法

元组tuple

定义元组的方法:

(1) 最简单的方法:

(2) 复杂元组的定义:

常用方法:

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

count：统计频率

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

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

串联： 可以使用加法运算符把元组串联起来

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

等量拆分：

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

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

列表list

定义的方法：

１．直接定义

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

添加和删除元素：

１．使用append在列表末尾添加元素

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

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

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

常用方法：

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

2.串联和组合列表

３．使用sort()函数进行原地排序（不创建新的对象）

４．切片

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

序列函数：

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

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

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

字典dict

创建方法：

访问、插入和设定：

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

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

常用方法：

通过 in 去检查字典中是否含有指定的键

访问字典中所有的keys

访问字典中所有的values

使用update融合字典

将两个序列组合成字典

默认值

集合set

定义方法:

直接使用{}尖括号

使用方法set

常用方法：

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

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

列表，集合，字典推导式

列表推导式：

集合推导式

字典推导式

函数

柯里化，部分参数的应用

生成器表达式

itertools模块

读写文件

串联：　可以使用加法运算符把元组串联起来