《Python数据分析》第二版.第三章.[学习笔记][Jupyter notebook]

第3章 Python的数据结构、函数和文件

1.元组是一个固定长度，不可改变的Python序列对象

tup = 4, 5, 6
nested_tup = (4, 5, 6), (7, 8) #复杂元组

2.tuple 可以将任意序列或迭代器转换成元组

In : tup = tuple('string')
In : tup
Out: ('s', 't', 'r', 'i', 'n', 'g')

3.元组中的对象不能修改，列表除外

4.+ 可以将元组串联起来

5.元组 * 一个整数，像列表一样，会将几个元组的复制串联起来

6.将元组赋值给类似元组的变量，Python会试图拆分等号右边的值

7.在Python中，替换可以这样做：b, a = a, b

In : seq = [(1, 2, 3), (4, 5, 6), (7, 8, 9)]
In : 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
a=7, b=8, c=9

8.*obj 抓取任意长度列表的位置参数, Python程序员会将不需要的变量使用下划线 a, b, *_ = values

In : values = 1, 2, 3, 4, 5
In : a, b, *rest = values
In : rest
Out: [3, 4, 5]

9.count 统计某值出现的频率

10.列表的长度可变、内容可以被修改。可以用 [ ] 定义或list()

11.append 在列表末尾添加元素

12.insert 在特定的位置插入元素

13.pop它移除并返回指定位置的元素

14.remove去除某个值，会先寻找第一个值并除去

15.in 可以检查列表是否包含某个值, not in 相反

16.extend 追加元素

17.sort 排序函数，obj.sort(key=len)按长度对字符串进行排序

18.bisect 模块支持二分查找，向已排序的列表插入值(需要 import)

In : import bisect
In : c = [1, 2, 2, 2, 3, 4, 7]
In : bisect.insort(c, 6)#插入某值，并保持排序
In : c
Out: [1, 2, 2, 2, 3, 4, 6, 7]
In : bisect.bisect(c, 6)#可以查询想要插入值，将要插入的位置
Out: 7

19.切片不包含结束元素，seq[1:5]，seq[:5]，seq[3:]，负数表示从后往前数，第多少个

20.seq[::step]，两个冒号后，使用step变量，可以间隔取数，seq[::-1]可以逆转列表或元组

21.enumerate函数

for i, value in enumerate(collection):# i 跟踪当前项的序号

In : some_list = ['foo', 'bar', 'baz'] #添加位置信息，整合成一个字典
In : mapping = {}
In : for i, v in enumerate(some_list):
   ....:     mapping[v] = i
In : mapping
Out: {'bar': 1, 'baz': 2, 'foo': 0}

22.sorted 函数可以从任意序列的元素返回一个新的排好序的列表

23.zip函数可以将多个列表、元组或其它序列，成对组合成一个元组列表，元素的个数取决于最短的序列

In : pitchers = [('Nolan', 'Ryan'), ('Roger', 'Clemens'),('Schilling', 'Curt')]
In : first_names, last_names = zip(*pitchers)#行的列表转换为列的列表
In : first_names
Out: ('Nolan', 'Roger', 'Schilling')
In : last_names
Out: ('Ryan', 'Clemens', 'Curt')

24.reversed函数从后向前迭代一个序列

25.字典

d1 = {} #空字典
d1 = {'a' : 'some value', 'b' : [1, 2, 3, 4]} #创建字典
In : d1[7] = 'an integer' #添加元素
In : 'b' in d1 #检查列表和元组是否包含某个值的方法
In : del d1[7] #删除某元素
ret = d1.pop('b')#删除键的同时返回键对应的值
list(d1.keys()) #将键取出
list(d1.values()) #将值取出
d1.update({'b' : 'foo', 'c' : 12}) #将一个字典与另一个融合，有相同键，则会覆盖

26.两个序列配对组合成字典

mapping = {} #方法一
for key, value in zip(key_list, value_list):
    mapping[key] = value
mapping = dict(zip(range(5), reversed(range(5)))) #方法二

27.dict的方法get和pop可以取默认值进行返回，value = some_dict.get(key, default_value)

28.setdefault 方法， 和collections模块的defaultdict

In : words = ['apple', 'bat', 'bar', 'atom', 'book']
In : by_letter = {}
In : for word in words:
   :     letter = word[0]
   :     if letter not in by_letter:
   :         by_letter[letter] = [word]
   :     else:
   :         by_letter[letter].append(word)
   :
In : by_letter
Out: {'a': ['apple', 'atom'], 'b': ['bat', 'bar', 'book']}

for word in words: #setdefault方法改进
    letter = word[0]
    by_letter.setdefault(letter, []).append(word)

from collections import defaultdict  #collections模块的defaultdict改进
by_letter = defaultdict(list)
for word in words:
    by_letter[word[0]].append(word)

29.字典的值可以是任意Python对象，而键通常是不可变的标量类型（整数、浮点型、字符串）或元组（元组中的对象必须是不可变的）。这被称为“可哈希性”。可以用hash函数检测一个对象是否是可哈希的（可被用作字典的键）

30.要用列表当做键，可以将列表转化为元组，只要内部元素可以被哈希，它也就可以被哈希，d[tuple([1, 2, 3])] = 5

31.集合，集合是无序的不可重复的元素的集合，set([2, 2, 2, 1, 3, 3]) 或{2, 2, 2, 1, 3, 3} 创建

32.常用的集合方法

33.与字典类似，集合元素通常都是不可变的。要获得类似列表的元素，必须转换成元组

34.a.issubset(b)  b.issuperset(a) 测一个集合是否是另一个集合的子集或父集

35. == 判断集合是否相等

36.推导式

In ：strings = ['a', 'as', 'bat', 'car', 'dove', 'python']
In : [x.upper() for x in strings if len(x) > 2]
Out: ['BAT', 'CAR', 'DOVE', 'PYTHON']
#字典的推导式
dict_comp = {key-expr : value-expr for value in collection if condition}
#集合的推导式
set_comp = {expr for value in collection if condition}

37.map函数

In : set(map(len, strings))
Out: {1, 2, 3, 4, 6}

38.