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

注：Python数据分析再学习

 
 

1. 数据结构和序列

1.1 元组

## 生成元组
tup1 = 4, 5, 6
tup2 = (4, 5, 6), (7, 8)

## 转换成元组
tuple([4, 0, 2])

## 访问元组
tup[0]

## 如果元组中的某个对象是可变的，则可以在原位进行修改
tup[1].append(3)

## 元组连接
(4, None, 'foo') + (6, 0) + ('bar')
('foo', 'bar') * 4

## 拆分元组
 tup = (4, 5, (6, 7))
 a, b, (c, d) = tup
 
 seq = [(1, 2, 3), (4, 5, 6), (7, 8, 9)]
 for a, b, c in seq:
     print('a = {0}, b = {1}, c = {2}'.format(a, b, c))

value = 1, 2, 3, 4, 5
a, b, *rest = values

## 统计频率
a = (1, 2, 2, 3, 4, 2, 5)
a.count(2)

1.2 列表

1.2.1 生成列表

tup = ('foo', 'bar', 'baz')
b_list = list(tup)
b_list[1] = 'peekaboo'

1.2.2 添加和删除元素

## 在末尾添加元素
b_list.append('dwarf')

## 在指定位置添加元素
b_list.insert(1, 'red')

## 在指定位置移除元素
b_list.pop(2)  ## insert逆运算

## 移除某个值
b_list.remove('foo')  ## remove逆运算

1.2.3 串联和组合列表

## 用+号串联
[4, None, 'foo'] + [7, 8, (2, 3)]

## 追加元素
x = [4, None, 'foo']
x.extend([7, 8, (2, 3)])

• 注意这里extend与append之间的区别，如果要在列表x末尾添加元素，用x.append(3)或者x.extend([3])，即extend括号内一定要是列表形式。
• 若s= [1, 2], s.append([3, 4])得到[1, 2, [3, 4]]; s.extend([3, 4])得到[1, 2, 3, 4]。

1.2.4 排序

a = [7, 2, 5, 1, 3]
a.sort()
b = ['saw', 'small', 'He', 'foxes', 'six']
b.sort(key = len)

1.2.5 切片

seq = [7, 2, 3, 7, 5, 6, 0, 1]

## 切片赋值
seq[3:4] = [6, 3]

## 省略开头或结尾
seq[:5]
seq[3:]

## 向前切片
seq[-4:]
seq[-6:-2]

## 隔元素取值
seq[::2]

## 将列表（元组）颠倒
seq[::-1]

• 切片包含起始元素，不包含结束元素。
• start和stop都可被省略。省略之后，分别默认序列的开头和结尾。
• 负数表明从后向前切片
• 在第二个冒号后面使用step，可以隔一个取一个元素
  

1.3 序列函数

1.3.1 enumerate函数

## 格式
for i, value in enumerate(collection):
    # do something with value

## 例子
l = ['foo', 'bar', 'baz']
mapping = {}
for i, v in enumerate(l):
mapping[v] = i

1.3.2 sorted函数

sorted([2, 1, 3])
sorted('horse race')

注：这里的sorted与之前的sort区别在于sorted(a)不会改变a，而a.sort()会改变a本身。

1.3.3 zip函数

1. zip可将多个列表、元组或其他序列成对组合成一个元组列表

seq1 = ['foo', 'bar', 'baz']
seq2 = ['one', 'two', 'three']
zipped = zip(seq1, seq2)
list(zipped)

2. zip可以处理任意多的序列，元素的个数取决于最短的序列

seq3 = [False, True]
list(zip(deq1, seq2, seq3))

3. 结合enumerate函数

for i, (a, b) in enumerate(zip(seq1, seq2)):
    print('{0}: {1}, {2}'.format(i, a, b))

4. 解压序列

a = [(1, 4, 3), ('foo', None, 2)]
first, middle, last= zip(*a)

1.3.4 reversed函数

list(reversed(range(10)))

1.4 字典

## 创建字典
empty_dict = {}
d1 = {'a': 'some_value', 'b': [1, 2, 3, 4]}

## 插入元素
d1[7] = 'an integer'

## 检查字典是否包含某个键
'b' in d1

## 删除元素（用del或pop）
del d1[7]
d1.pop('b')

## 字典的键和值
list(d1.keys())
list(d1.values())

## 融合
d1.update({'b': 'foo', 'c': 12})

1.4.1 用序列创建字典

## 方法1
mapping = {}
for key, value in zip(key_list, value_list):
    mapping[key] = value

## 方法2
mapping = dict(zip(range(5), reversed(range(5))))

1.4.2 默认值

## 格式
value = some_dict.get(key, default_value)

## 例子
### 方法1
words = ['apple', 'bat', 'bar', 'atom', 'bool']
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)
### 方法2
for word in words:
    letter = word[0]
    by_letter.setdefault(letter, []).append(word)
### 方法3
from collections import defaultdict
by_letter = defaultdict(list)
for word in words:
    by_letter[word[0]].append(word)

注：这里重点说一下setdefault与defaultdict函数

• setdefault函数的用法为dict.setdefault(key, default)，在例子中是寻找之前的字典中的键是否有letter。如果有就把对应的值取出来并且加上word；如果没有letter，就把这个letter做为新的键，并且把当前的word加到新的键对应的值当中。
• defaultdict函数的用法为defaultdict(list, dict)，其中list为当找不到原列表对应的键时，自动生成的当前键对应的值，dict为开始可以初始化的字典。

>>>by = defaultdict(list, {'a': 1})
>>>by
defaultdict(<class 'list'>, {'a': 1})
>>>by['a']
1
>>>by['b']
[]
>>>by
defaultdict(<class 'list'>, {'a': 1, 'b': []})

1.4.3 有效的键类型

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

1.5 集合

定义：集合是无序的不可重复的元素的集合。类似于字典，但是只有键没有值。

## 创建列表
### 方法1
set([1, 2, 3, 2])
### 方法2
{1, 2, 3, 2}

## 交集、并集、子集、父集
a.intersection(b)
a.union(b)
a.issubset(b)
a.issuperset(b)

函数	替代语法	说明
a.add(x)		将元素x添加到集合a
a.clear()		将集合清空
a.remove(x)		将元素x从集合a中除去
a.pop()		从集合a中除去任意元素
a.union(b)	a|b	集合a与b的并集
a.update(b)	a|=b	设定集合a中的元素为a与b的合并
a.intersection(b)	a&b	a与b的交集
a.intersection_update(b)	a&=b	设定集合a中的元素为a与b的交叉
a.difference(b)	a-b	存在与a但不存在于b中的元素
a.difference_update(b)	a-=b	设定集合a中的元素为a与b的差
a.symmetric_difference(b)	a^b	只在a中或只在b中的元素
a.symmetric_difference_update(b)	a^=b	集合a中的元素为只在a或只在b中的元素
a.issubset(b)
a.issuperset(b)
a.isdisjoint(b)

1.6 列表、集合、字典推导式

## 列表
strings = ['a', 'as', 'bat', 'car', 'dove']
[x.upper() for x in strings if len(x) > 2]

## 集合
### 方法1
unique_lengths = {len(x) for x in strings}
### 方法2
set(map(len, strings))

## 字典
loc_mapping = {val: index for index, val in enumerate(strings)}

## 嵌套列表
### 方法1
name_list = []
for name in all_data:
    enough_es = [name for names if name.count('e') >= 2]
    name_list.extend(enough_es)
### 方法2
result = [name for names in all_data for name in names if name.count('e') >= 2]

 
 

2. 函数

注：1.函数可以拥有多条return语句，也可以没有；2.关键字参数必须位于位置参数之后。

2.1 函数也是对象

## 转换字符串
import re
## 方法1
def clean_strings(strings):
    result = []
    for value in strings:
        value = value.strip()
        value = re.sub('[!#?]', '', value)
        value = value.title()
        result.append(value)
    return result

## 方法2
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

for x in map(remove_punctuation, states):
    print(x)

2.2 lambda函数

它仅由单条语句组成，该语句的结果即为返回值。它是通过lambda关键字定义的，这个关键字没有特别的含义，只是说我们正在声明的是一个匿名函数。

def apply_to_list(some_list, f):
    return [f(x) for x in some_list]

ints = [4, 0, 1]
apply_to_list(ints, lambda x: x^2)

strings = ['foo', 'card', 'bar', 'aaaa', 'abab']
strings.sort(key = lambda x: len(set(list(x))))

### 柯里化
def add_numbers(x, y):
    return x + y

add_five = lambda y: add_numbers(5, y)

from functools import partial
add_five = partial(add_numbers, 5)

2.3 生成器

sum(x ** 2 for x in range(100))

dict((i, i ** 2) for i in range(5))

2.4 itertools模块

import itertools
first_letter = lambda x: x[0]
names = ['Alan', 'Adam', 'Wes', 'Will', 'Steven']
for letter, name in itertools.groupby(names, first_letter):
    print(letter, list(name))

函数	说明
combinations(iterable, k)	生成一个由iterable中所有可能的k元元组组成的序列，不考虑顺序
permutations(iterable, k)	生成一个由iterable中所有可能的k元元组组成的序列，考虑顺序
groupby(iterable, keyfunc)	为每个唯一的键生成一个

2.5 错误和异常处理

## 例子1
def attempt_float(x):
    try:
        return float(x)
    except (TypeError, ValueError):
        return x

## 例子2
f = open(path, 'w')
try:
    write_to_file(f)
except:
    print('Failed')
else:
    print('Succeeded')
finally:
    f.close()

 
 

3. 文件和操作系统

with open(path) as f:
lines = [x.rstrip() for x in f]