本文引用《利用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

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

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）

In [72]: 'wt' in b_list

Out[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_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函数从任意序列中返回一个已经拍好序的列表（列表的元素需要为同一类型）：

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 去检查字典中是否含有指定的键

In [6]: 'wt2' in dict

Out[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]: 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}

集合常用的方法

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

列表，集合，字典推导式

列表推导式：

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

生成器表达式

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重要的文件方法