Chapter 3: Built-in Data Structures, Functions, and Files
声明一下这里直接导入了Jupter notebooks的markdown笔记,不是很方便阅读
3.1 数据结构与序列
3.1.1 元组
元组可以通过括号[]来获取
tup = tuple([4,0,2])
tup[1]
0
元组乘以整数,则会和列表一样,生成含有多个拷贝的数组,这些元组的地址是相同的.
tup = ('foo','bar')
id(tup)
id(tup*4)
1950453912624
id(tup*4)
1950453912624
tup*4
('foo', 'bar', 'foo', 'bar', 'foo', 'bar', 'foo', 'bar')
3.1.1.1 元组拆包
Python会对元组进行拆包,也就是如果一个元组有N个元素,将元组赋值给N个变量,每个变量按位置从元组取值
a,b,c = (4,5,6)
print(f"a是{a},b是{b},c是{c}")
a是4,b是5,c是6
拆包应用于循环十分方便,参考如下代码
seq = [(1,2,3),(5,2,1),(121,41,11),(3,0,13)]
for a,b,c in seq:
print(f"a是{a},b是{b},c是{c}")
a是1,b是2,c是3
a是5,b是2,c是1
a是121,b是41,c是11
a是3,b是0,c是13
由于元组拆包功能,我们可以应用它来丢弃会存储某些数据,这些数据会存储在列表
a,b,*rest=(1,2,3,4)
print(a)
print(b)
print(rest)
1
2
[3, 4]
3.1.1.2 元组方法
元组的实例方法少,有一个count用于计数元组有多少个元素
tup = (1,2,31,3,1,1,1,1,5,3)
print(tup.count(1))
5
3.1.2 列表
3.1.2.1 增加和移除元素
使用append()方法可以增加列表元素,也可以使用insert()方法指定插入位置,但是insert()方法开销比较大.如果我们在双端插入元素比较多,可以考虑使用collection.deuqe.它是一个双端队列,类似C++的deque.
pop()可以删除指定位置的元素,remove(str)会删除列表中第一个str元素
in和not in 用于检查列表中是否有某元素
3.1.2.2 连接和联结列表
与元组类似,列表可以使用+连接
[4,5,None]+[7,8,(1,2,3),{1:'foo',2:'str'}]
[4, 5, None, 7, 8, (1, 2, 3), {1: 'foo', 2: 'str'}]
+效率较低,用extend效率更高
a = [4,5,None]
a.extend([7,8,(1,2,3),{1:'foo',2:'str'}])
a
[4, 5, None, 7, 8, (1, 2, 3), {1: 'foo', 2: 'str'}]
3.1.2.3 排序
sort()可以对列表内部进行排序(永久改变列表),sort有一个参数key,向key传参可以改变列表排序的方式
a = ['aaa','12','dwdawdawd','wdadawdawdwwadawdwadwad','r']
a.sort(key=len)
print(a)
['r', '12', 'aaa', 'dwdawdawd', 'wdadawdawdwwadawdwadwad']
3.1.2.4 二分搜索和已排序列表的维护
内建的bisect模块实现了二分搜索和已排序序列的插值.bisect.bisect会找到元素应该插入的位置,并保持序列排序.而bisect.insort将元素插入到相应位置
import bisect
c = [1,2,2,3,4,7]
bisect.bisect(c,2)
3
bisect.insort(c,2)
c
[1, 2, 2, 2, 3, 4, 7]
bisect.insort(c,10)
c
[1, 2, 2, 2, 3, 4, 7, 10]
3.1.3 内建序列函数
Python中有很多有用的序列函数
3.1.3.1 enumerate
enumerate函数用于返回一个元素是(索引,对应列表元素)的新列表对象,但是返回值不是真正的列表,而是一个enumerate object,只是因为它允许迭代才可以这样做.
some_list = ['foo','bar','baz']
for k,v in enumerate(some_list):
print(f"{k}的值是{v}")
0的值是foo
1的值是bar
2的值是baz
enumerate?
3.1.3.2 sorted
sorted可以接受的参数与sort一致
3.1.3.3 zip
zip可以将多个列表、元组或其它序列成对组合成一个元组列表,但是返回值是zip对象,是允许迭代的,可以转化为list列表
seq1 = ['foo','bar','baz']
seq2 = ['one','two','three']
zipped = zip(seq1,seq2)
zipped
<zip at 0x1c6212d0ac0>
list(zipped)
[('foo', 'one'), ('bar', 'two'), ('baz', 'three')]
zip可以处理任意多的序列，元素的个数取决于最短的序列:
seq3 = [False,True]
list(zip(seq1,seq2,seq3))
[('foo', 'one', False), ('bar', 'two', True)]
zip的常见用法之一是同时迭代多个序列，可能结合enumerate使用：
从下面来看,拆包元组还是需要一一对应,如果元组中还有元组
for i in enumerate(zip(seq1,seq2)):
print(i)
(0, ('foo', 'one'))
(1, ('bar', 'two'))
(2, ('baz', 'three'))
for i,(a,b) in enumerate(zip(seq1,seq2)):
print(f"{i}:({a},{b})")
print(f"a是{a},b是{b}")
0:(foo,one)
a是foo,b是one
1:(bar,two)
a是bar,b是two
2:(baz,three)
a是baz,b是three
给出一个"被压缩的"序列,zip可以被用来解压序列.也可以当作把行的列表转换为列的列表.这个方法看起来有点神奇:(行列是书上原话,没理解什么意思)
pitchers = [('Nolan', 'Ryan'), ('Roger', 'Clemens'),('Schilling', 'Curt')]
first_names,last_names = zip(*pitchers)
print(first_names)
print(last_names)
('Nolan', 'Roger', 'Schilling')
('Ryan', 'Clemens', 'Curt')
3.1.3.4 reversed
reversed函数将序列的元素倒序排序,reversed函数是一个生成器,它只能返回一个迭代器,只有实体化（即列表或for循环）之后才能创建翻转的序列
list(reversed(range(10)))
[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
3.1.4 字典
字典可能是Python最为重要的数据结构。它更为常见的名字是哈希映射或关联数组。它是键值对的大小可变集合，键和值都是Python对象。创建字典的方法之一是使用尖括号，用冒号分隔键和值.
我们可以用del或者pop从字典中删除值,其中pop可以获得返回值
dict_1 = {'1001':'张三','1002':'李四','1003':'王五'}
name = dict_1.pop('1002')
name
'李四'
dict_1
{'1001': '张三', '1003': '王五'}
update方法可以将字典合并,从实验来看没有改变字典的位置
dict_1 = {'1001':'张三','1002':'李四','1003':'王五'}
print(f"第一次{id(dict_1)}")
dict_1.update({'1004':'赵六','1005':'李白'})
id(dict_1)
print(f"第二次{id(dict_1)}")
第一次1950473138304
第二次1950473138304
3.1.4.1 从序列生成字典
因为字典本质上是2元元组的集合，dict可以接受2元元组的列表:
而后有字典推导式,也能创建字典
mapping = dict(zip(range(5),reversed(range(5))))
mapping
{0: 4, 1: 3, 2: 2, 3: 1, 4: 0}
3.1.4.2 默认值
Python 字典 setdefault() 函数和 get()方法 类似, 如果键不存在于字典中，将会添加键并将值设为默认值.
- key -- 查找的键值.
- default -- 键不存在时，设置的默认键值.
返回值:如果字典中包含有给定键，则返回该键对应的值，否则返回为该键设置的值。
words = ['apple','bat','bar','atom','book']
#by_letter针对首字母存储字典
by_letter = {}
for word in words:
letter = word[0]
if letter in by_letter:
by_letter[letter].append(letter)
else:
by_letter[letter] = [word]
print(by_letter)
{'a': ['apple', 'a'], 'b': ['bat', 'b', 'b']}
上述代码与下面等效
by_letter2 = {}
for word in words:
letter = word[0]
by_letter2.setdefault(letter,[]).append(word)
print(by_letter2)
{'a': ['apple', 'atom'], 'b': ['bat', 'bar', 'book']}
但是还有更方便的,collections模块有一个很有用的类defaultdict,它可以进一步简化上面.如果不存在key,它会使用默认值,但是我们在创建defaultdict时,必须指定一个可以创建默认值的函数,参考如下代码
from collections import defaultdict
by_letter3 = defaultdict(list)
for word in words:
by_letter3[word[0]].append(word)
print(by_letter3)
defaultdict(<class 'list'>, {'a': ['apple', 'atom'], 'b': ['bat', 'bar', 'book']})
3.1.4.3 有效的字典键类型
字典的值可以是任意Python对象，而键通常是不可变的标量类型（整数、浮点型、字符串）或元组（元组中的对象必须是不可变的）。这被称为“可哈希性”。可以用hash函数检测一个对象是否是可哈希的（可被用作字典的键）.
print(hash("123"))
print(hash((1,3,4)))
7841519930062954612
-1070212610609621906
hash((1,3,[1,3]))
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
<ipython-input-57-df3578781556> in <module>
----> 1 hash((1,3,[1,3]))
TypeError: unhashable type: 'list'
3.1.5 集合
集合是无序的不可重复的元素的集合。你可以把它当做字典，但是只有键没有值。可以用两种方式创建集合：通过set函数或使用尖括号set语句
s1 = {1,2,3,4}
s2 = set([1,3,3,4])
print(type(s1))
print(type(s2))
<class 'set'>
<class 'set'>
集合支持合并、交集、差分和对称差等数学集合运算。考虑两个示例集合:
a = {1, 2, 3, 4, 5}
b = {3, 4, 5, 6, 7, 8}
合并是取两个集合中不重复的元素。可以用union方法，或者|运算符;
交集的元素包含在两个集合中。可以用intersection或&运算符;
print(a.intersection(b))
print(a & b)
print(a.union(b))
print(a | b)
{3, 4, 5}
{3, 4, 5}
{1, 2, 3, 4, 5, 6, 7, 8}
{1, 2, 3, 4, 5, 6, 7, 8}
下表给出常见的集合操作:
与字典类似，集合元素通常都是不可变的。要获得类似列表的元素，必须转换成元组：
my_set = {tuple([1,2,3,45])}
print(my_set)
{(1, 2, 3, 45)}
my_set = {[1,2,3,4]}
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
<ipython-input-63-9f5b1d870c7b> in <module>
----> 1 my_set = {[1,2,3,4]}
TypeError: unhashable type: 'list'
3.1.6 列表、集合和字典推导式
列表推导式是Python最受喜爱的特性之一。它允许用户方便的从一个集合过滤元素，形成列表，在传递参数的过程中还可以修改元素。形式如下:
# [expr for val in collection if condition]
# 它等同于下面的for循环:
# result = []
# for val in collection:
# if condition:
# result.append(expr)
用相似的方法，还可以推导集合和字典。字典的推导式如下所示:
dict_comp = {key-expr : value-expr for value in collection if condition}
集合的推导式与列表很像，只不过用的是尖括号:
set_comp = {expr for value in collection if condition}
假如我们只想要字符串的长度，用集合推导式的方法非常方便:
strings = ['a', 'as', 'bat', 'car', 'dove', 'python']
unique_lengths = {len(x) for x in strings}
unique_lengths
{1, 2, 3, 4, 6}
map函数可以进一步简化:
map() 会根据提供的函数对指定序列做映射.
第一个参数 function 以参数序列中的每一个元素调用 function 函数，返回包含每次 function 函数返回值的新列表.
map(function, iterable, ...)
- function -- 函数
- iterable -- 一个或多个序列
返回值:
Python 3.x 返回迭代器
set(map(len, strings))
{1, 2, 3, 4, 6}
3.1.6.1 嵌套列表推导式
假设我们有一个包含列表的列表，包含了一些英文名和西班牙名:
all_data = [['John', 'Emily', 'Michael', 'Mary', 'Steven'],['Maria', 'Juan', 'Javier', 'Natalia', 'Pilar']]
你可能是从一些文件得到的这些名字，然后想按照语言进行分类。现在假设我们想用一个列表包含所有的名字，这些名字中包含两个或更多的e。可以用for循环来做:
names_of_interest = []
for names in all_data:
enough_es = [name for name in names if name.count('e') >= 2]
names_of_interest.extend(enough_es)
print(names_of_interest)
['Steven']
可以用嵌套列表推导式的方法,将这些写在一起，如下所示:
names_of_interest = [name for names in all_data for name in names if name.count('e') >= 2]
print(names_of_interest)
['Steven']
嵌套列表推导式看起来有些复杂。列表推导式的for部分是根据嵌套的顺序，过滤条件还是放在最后
记住，for表达式的顺序是与嵌套for循环的顺序一样(而不是列表推导式的顺序):
你可以有任意多级别的嵌套，但是如果你有两三个以上的嵌套，你就应该考虑下代码可读性的问题了。分辨列表推导式的列表推导式中的语法也是很重要的:
some_tuples = [(1,2,3),(4,5,6),(7,8,9)]
[[x for x in tup] for tup in some_tuples]
[[1, 2, 3], [4, 5, 6], [7, 8, 9]]
这段代码产生了一个列表的列表，而不是扁平化的只包含元素的列表.一定要区分列表推导式中的列表推导式和嵌套列表推导式
3.2 函数
函数是Python中最主要也是最重要的代码组织和复用手段.作为最重要的原则,如果你要重复使用相同或非常类似的代码,就需要写一个函数.通过给函数起一个名字，还可以提高代码的可读性.
3.2.1 命名空间、作用域和本地函数
函数可以访问两种不同作用域中的变量：全局(global)和局部(local).Python有一种更科学的用于描述变量作用域的名称，即命名空间（namespace）。任何在函数中赋值的变量默认都是被分配到局部命名空间（local namespace）中的。局部命名空间是在函数被调用时创建的，函数参数会立即填入该命名空间。在函数执行完毕之后，局部命名空间就会被销毁（会有一些例外的情况，具体请参见后面介绍闭包的那一节）.
但是这样会造成一些问题,比如在C语言中,由于变量一定是先声明,后使用,所以我们可以清楚的知道,现在使用的变量是全局还是局部.比如:
int a = 5;
void test(void)
{
a = 1; // 没有先声明，所以用的是全局的变量a
}
void test1(void)
{
int a;
a = 2; // 前面声明了，所以用的是局部变量a，对其所做的修改不会影响全局变量a
}
但是在python中,变量不需要先声明，直接使用即可，那我们怎么知道用的是局部变量还是全局变量呢？
首先：python使用的变量，在默认情况下一定是用局部变量.
其次：python如果想使用作用域之外的全局变量，则需要加global前缀.
#不使用global的情况
a = 5
def test():
a = 1
print(f'In test func: a = {a}')
test()
print(f'Global a = {a}')
In test func: a = 1
Global a = 5
#使用global的情况
a = 5
def test():
global a
#此处声明，告诉执行引擎：我要用全局变量a，不要整成局部的了！
a = 1
print(f'In test func: a = {a}')
test()
print(f'Global a = {a}')
In test func: a = 1
Global a = 1
3.2.2 返回多个值
在数据分析和其他科学计算应用中，你会发现自己常需要返回多个值。但函数其实只返回了一个对象，也就是一个元组，最后该元组会被拆包到各个结果变量中.
def f():
a = 5
b = 6
c = 7
return a, b, c
a, b, c = f()
print(a,b,c)
5 6 7
此外，还有一种非常具有吸引力的多值返回方式——返回字典,取决于工作内容，第二种方法可能很有用.
def f():
a = 5
b = 6
c = 7
return {'a' : a, 'b' : b, 'c' : c}
print(f())
{'a': 5, 'b': 6, 'c': 7}
3.2.3 函数是对象
由于Python函数都是对象，因此，在其他语言中较难表达的一些设计思想在Python中就要简单很多了。假设我们有下面这样一个字符串数组，希望对其进行一些数据清理工作并执行一堆转换:
states = [' Alabama ', 'Georgia!', 'Georgia', 'georgia', 'FlOrIda','south carolina##', 'West virginia?']
不管是谁，只要处理过由用户提交的调查数据，就能明白这种乱七八糟的数据是怎么一回事。为了得到一组能用于分析工作的格式统一的字符串，需要做很多事情：去除空白符、删除各种标点符号、正确的大写格式等。做法之一是使用内建的字符串方法和正则表达式re模块.
之前看到Python基础书并没有介绍Re,这里写一些定义,也可以直接参考链接:
3.2.3.1 re
Re库是Python的标准库，主要用于字符串匹配，调用方法"import re"
(1) 正则表达式的类型
Re库采用raw string(原生字符串类型)表达正则表达式,表示为r'text',raw string是不包含转义符的字符串
如 r'[1-9]\d{5}'、r'\d{3}-\d{8}|\d{4}-\d{7}'
如果直接用String表示,还需要转义符:
'[1-9]\d{5}'、'\d{3}-\d{8}|\d{4}-\d{7}'
(2) \(re\)库的主要函数
- re.sub(pattern,repl,string,count = 0,flags = 0)
在一个字符串中替换所有匹配正则表达式的子串，返回替换后的字符串
① pattern:正则表达式的字符串或原生字符串表示
② repl:替换匹配字符串的字符串
③ string:待匹配字符串
④ count:匹配的最大替换次数
⑤ flags:正则表达式使用时的控制标记
import re
re.sub(r'[1-9]\d{5}','zipcode','BIT100081 TSU100084')
#'BITzipcode TSUzipcode'
'BITzipcode TSUzipcode'
这里只介绍要用的,详细上面的链接
现在来看如何清洗数据
def clean_strings(strings):
result = []
for value in strings:
value = value.strip()
value = re.sub('[!#?]','',value)
value = value.title()
result.append(value)
return result
clean_strings(states)
['Alabama',
'Georgia',
'Georgia',
'Georgia',
'Florida',
'South Carolina',
'West Virginia']
其实还有另外一种不错的办法：将需要在一组给定字符串上执行的所有运算做成一个列表:
states = [' Alabama ', 'Georgia!', 'Georgia', 'georgia', 'FlOrIda','south carolina##', 'West virginia?']
def remove_punctuation(value):
return re.sub('[!#?]','',value)
clean_ops = [str.strip,remove_punctuation,str.title]
def clean_strings(strings,ops):
result = []
for string in strings:
for fun in ops:
string = fun(string)
result.append(string)
return result
clean_strings(states,clean_ops)
['Alabama',
'Georgia',
'Georgia',
'Georgia',
'Florida',
'South Carolina',
'West Virginia']
这种多函数模式使你能在很高的层次上轻松修改字符串的转换方式。此时的clean_strings也更具可复用性!
还可以将函数用作其他函数的参数，比如内置的map函数，它用于在一组数据上应用一个函数:
states = [' Alabama ', 'Georgia!', 'Georgia', 'georgia', 'FlOrIda','south carolina##', 'West virginia?']
for x in map(remove_punctuation, states):
print(x)
Alabama
Georgia
Georgia
georgia
FlOrIda
south carolina
West virginia
3.2.4 匿名函数
Python支持一种被称为匿名的、或lambda函数。它仅由单条语句组成，该语句的结果就是返回值。它是通过lambda关键字定义的，这个关键字没有别的含义，仅仅是说"我们正在声明的是一个匿名函数"。
下面是lambda的语法格式
name = lambda [参数list] : 表达式
举一个例子,如果设计一个求 2 个数之和的函数，使用普通函数的方式，定义如下:
def add(x, y):
return x+y
print(add(3,4))
7
但如果我们使用lambda函数,可以将代码缩减为1行:
add = lambda x,y : x+y
add(3,4)
7
Lambda函数可以具有任意数量的参数，但只能有一个表达式.表达式被求值并返回.Lambda函数可在需要函数对象的任何地方使用.等式左边返回的是函数对象.
在Python中，我们通常将其用作高阶函数的参数,Lambda函数可以与filter(),map()等内置函数一起使用.
#按字符串字母数量种类排序
strings = ['foo', 'card', 'bar', 'aaaa', 'abab']
#set()只接受list和tuple或其他可迭代对象作为参数,因为它只存储不可变的数据类型,为什么允许接受list:是将List的元素划为自己的元素
#但如果list存在可变的类型,那么也会报错
strings.sort(key = lambda x : len(set(list(x))))
strings
['aaaa', 'foo', 'abab', 'bar', 'card']
3.2.5 柯里化:部分参数应用
柯里化（currying）是一个有趣的计算机科学术语，它指的是通过“部分参数应用”（partial argument application）从现有函数派生出新函数的技术.详情看这个,更详细
3.2.6 生成器
能以一种一致的方式对序列进行迭代（比如列表中的对象或文件中的行）是Python的一个重要特点.这是通过一种叫做迭代器协议(iterator protocol,它是一种使对象可迭代的通用方式)的方式实现的,一个原生的使对象可迭代的方法。比如说，对字典进行迭代可以得到其所有的键：
some_dict = {'a': 1, 'b': 2, 'c': 3}
for key in some_dict:
print(key)
a
b
c
当你编写for key in some_dict时，Python解释器首先会尝试从some_dict创建一个迭代器:
dict_iterator = iter(some_dict)
dict_iterator
<dict_keyiterator at 0x1c621ac7ea0>
迭代器与生成器的解释看这个
顾名思义，迭代器就是用于迭代操作(for)的对象,它像列表一样可以迭代获取其中的每一个元素,任何实现了 next 方法 （python2 是 next）的对象都可以称为迭代器.
它与列表的区别在于,构建迭代器的时候,不像列表把所有元素一次性加载到内存,而是以一种延迟计算（lazy evaluation）方式返回元素,这正是它的优点.比如列表含有中一千万个整数,需要占超过400M的内存,而迭代器只需要几十个字节的空间.因为它并没有把所有元素装载到内存中,而是等到调用next方法时候才返回该元素(按需调用 call by need 的方式，本质上 for 循环就是不断地调用迭代器的next方法).
大部分能接受列表之类的对象的方法也都可以接受任何可迭代对象。比如min、max、sum等内置方法以及list、tuple等类型构造器:
list(dict_iterator)
['a', 'b', 'c']
- 生成器
这方面还是继续看知乎比较好.
知道迭代器之后，就可以正式进入生成器的话题了。普通函数用return返回一个值，和 Java 等其他语言是一样的,然而在Python中还有一种函数，用关键字yield来返回值，这种函数叫生成器函数，函数被调用时会返回一个生成器对象，生成器本质上还是一个迭代器,也是用在迭代操作中，因此它有和迭代器一样的特性,唯一的区别在于实现方式上不一样,后者更加简洁.
一般的函数执行之后只会返回单个值，而生成器则是以延迟的方式返回一个值序列，即每返回一个值之后暂停，直到下一个值被请求时再继续。要创建一个生成器，只需将函数中的return替换为yeild即可:
def squares(n=10):
print('Generating squares from 1 to {0}'.format(n ** 2))
for i in range(1, n + 1):
yield i ** 2
调用该生成器时，没有任何代码会被立即执行:
gen = squares()
gen
<generator object squares at 0x000001C621336970>
直到你从该生成器中请求元素时，它才会开始执行其代码:
这里感觉延迟执行,每返回一个值就暂停,可能这就是在for循环里返回值的原因
for x in gen:
print(x,end=' ')
Generating squares from 1 to 100
1 4 9 16 25 36 49 64 81 100
3.2.6.1 生成器表达式
另一种更简洁的构造生成器的方法是使用生成器表达式（generator expression）。这是一种类似于列表、字典、集合推导式的生成器。其创建方式为，把列表推导式两端的方括号改成圆括号:
gen = (x**2 for x in range(100))
gen
<generator object <genexpr> at 0x000001C6233476D0>
它跟下面这个冗长得多的生成器是完全等价的:
def _make_gen():
for x in range(100):
yield x ** 2
gen = _make_gen()
gen
<generator object _make_gen at 0x000001C6233479E0>
生成器表达式也可以取代列表推导式，作为函数参数:
dict(((i,i**2) for i in range(6)))#实际包裹生成器表达式的括号不需要
{0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25}
3.2.6.2 itertools 模块
课本上的解释不是很白话,然后参考了几个博客,概况如下:
Python的内建模块itertools提供了非常有用的用于操作迭代对象的函数,其主要分为三类:分别是无限迭代器，有限迭代器，组合迭代器.
(1) 无限迭代器
这些函数可以生成无限的迭代器,我们主要学习以下三个函数的用法
- count([start=0, step=1])
接收两个可选整形参数,第一个指定了迭代开始的值,第二个指定了迭代的步长.此外，start参数默认为0，step参数默认为1，可以根据需要来把这两个指定为其它值，或者使用默认参数.
下面的代码,如果没有break,会一直迭代下去
import itertools
for i in itertools.count(10,2):
print(i)
if i>20:
break
10
12
14
16
18
20
22
- cycle(iterable)
是用一个可迭代对象中的元素来创建一个迭代器,并且复制自己的值,一直无限的重复下去。
for i in itertools.cycle("abc"):
print(i)
break
a
- repeat(elem [,n])
是将一个元素重复n遍或者无穷多遍，并返回一个迭代器
for i in itertools.repeat("abcd",5):
print(i)
abcd
abcd
abcd
abcd
abcd
(2) 组合迭代器
组合操作包括排列,笛卡儿积,或者一些离散元素的选择,组合迭代器就是产生这样序列的迭代器。我们来看看这几个函数的用法.
- product(iterables, repeat=1)
得到的是可迭代对象的笛卡儿积,iterables参数表示需要多个可迭代对象.这些可迭代对象之间的笛卡儿积,也可以使用for循环来实现,例如product(A,B)与((x,y) for x in A for y in B)就实现一样的功能
for i in itertools.product([1,2,3],[4,5,6]):
print(i)
(1, 4)
(1, 5)
(1, 6)
(2, 4)
(2, 5)
(2, 6)
(3, 4)
(3, 5)
(3, 6)
而repeat参数则表示这些可迭代序列重复的次数.例如 product(A, repeat=4)与 product(A,A,A,A)实现的功能一样.
- permutations(iterable,r=None)
返回的是可迭代元素中的一个排列组合,并且是按顺序返回的,且不包含重复的结果.
for i in itertools.permutations('abc'):
print(i)
('a', 'b', 'c')
('a', 'c', 'b')
('b', 'a', 'c')
('b', 'c', 'a')
('c', 'a', 'b')
('c', 'b', 'a')
当然,第2个参数默认为None,它表示的是返回元组（tuple) 的长度,我们来尝试一下传入第二个参数:
for i in itertools.permutations('abc',2):
print(i)
('a', 'b')
('a', 'c')
('b', 'a')
('b', 'c')
('c', 'a')
('c', 'b')
- combinations(iterable,r)
返回的是可迭代对象所有的长度为 r 的子序列，注意这与前一个函数 permutation 不同，permutation 返回的是排列，而 combinations 返回的是组合
for i in itertools.combinations('1234',2):
print(i)
('1', '2')
('1', '3')
('1', '4')
('2', '3')
('2', '4')
('3', '4')
- combinations_with_replacement(iterable, r)
返回一个可与自身重复的元素组合,用法类似于 combinations
for i in itertools.combinations_with_replacement('1234',2):
print(i)
('1', '1')
('1', '2')
('1', '3')
('1', '4')
('2', '2')
('2', '3')
('2', '4')
('3', '3')
('3', '4')
('4', '4')
(3) 有限迭代器
这里的函数有十来个,主要介绍其中几个常用的函数:
- chain(*iterables)
可以把多个可迭代对象组合起来，形成一个更大的迭代器
print(itertools.chain([1,2,3],[4,5]))
<itertools.chain object at 0x000001C621D85F10>
for i in itertools.chain([1,3],[4,5]):
print(i)
1
3
4
5
- groupby(iterable,key=None)
可以把相邻元素按照key函数分组,并返回相应的key和groupby,如果key函数为None,则只有相同的元素才能放在一组
names = ['Alan', 'Adam', 'Wes', 'Will', 'Albert', 'Steven']
for letter, names in itertools.groupby(names, lambda x:x[0]):
print(letter, list(names)) # names is a generator
A ['Alan', 'Adam']
W ['Wes', 'Will']
A ['Albert']
S ['Steven']
- accumulate(iterable [,func])
可以计算出一个迭代器，这个迭代器是由特定的二元函数的累计结果生成的，如果不指定的话，默认函数为求和函数
for i in itertools.accumulate([0,1,0,1,1,2,3,5]):
print(i)
0
1
1
2
3
5
8
13
3.2.7 错误和异常
使用try-catch-else-finally处理异常或错误
path = 'D:/Python_Code/IPython/Chapter_3/1.txt'
f = open(path,'w')
try:
write_to_file(f)
except (TypeError,ValueError,NameError,PermissionError):
#except多个异常以元组形式
print('Failed')
else:
print('Succeeded')
finally:
f.close()
Failed
3.3 文件和操作系统
本书的代码示例大多使用诸如pandas.read_csv之类的高级工具将磁盘上的数据文件读入Python数据结构。但我们还是需要了解一些有关Python文件处理方面的基础知识。好在它本来就很简单，这也是Python在文本和文件处理方面的如此流行的原因之一。
为了打开一个文件以便读写，可以使用内置的open函数以及一个相对或绝对的文件路径：
path = 'examples/segismundo.txt'
f = open(path)
默认情况下，文件是以只读模式（'r'）打开的。然后，我们就可以像处理列表那样来处理这个文件句柄f了，比如对行进行迭代:
for line in f:
print(line)
Sue帽a el rico en su riqueza,
que m谩s cuidados le ofrece;
sue帽a el pobre que padece
su miseria y su pobreza;
sue帽a el que a medrar empieza,
sue帽a el que afana y pretende,
sue帽a el que agravia y ofende,
y en el mundo, en conclusi贸n,
todos sue帽an lo que son,
aunque ninguno lo entiende.
从文件中取出的行都带有完整的行结束符（EOL），因此你常常会看到下面这样的代码（得到一组没有EOL的行）:
lines = [x.rstrip() for x in open(path)]
lines
['Sue帽a el rico en su riqueza,',
'que m谩s cuidados le ofrece;',
'',
'sue帽a el pobre que padece',
'su miseria y su pobreza;',
'',
'sue帽a el que a medrar empieza,',
'sue帽a el que afana y pretende,',
'sue帽a el que agravia y ofende,',
'',
'y en el mundo, en conclusi贸n,',
'todos sue帽an lo que son,',
'aunque ninguno lo entiende.',
'']
如果使用open创建文件对象，一定要用close关闭它。关闭文件可以返回操作系统资源：
f.close()
用with语句可以可以更容易地清理打开的文件：
with open(path) as f:
lines = [x.rstrip() for x in f]
lines
['Sue帽a el rico en su riqueza,',
'que m谩s cuidados le ofrece;',
'',
'sue帽a el pobre que padece',
'su miseria y su pobreza;',
'',
'sue帽a el que a medrar empieza,',
'sue帽a el que afana y pretende,',
'sue帽a el que agravia y ofende,',
'',
'y en el mundo, en conclusi贸n,',
'todos sue帽an lo que son,',
'aunque ninguno lo entiende.',
'']
这样可以在退出代码块时，自动关闭文件。
如果输入f =open(path,'w')，就会有一个新文件被创建在examples/segismundo.txt，并覆盖掉该位置原来的任何数据。另外有一个x文件模式，它可以创建可写的文件，但是如果文件路径存在，就无法创建。表3-3列出了所有的读/写模式。
我们可以用sys查看默认编码:
import sys
sys.getdefaultencoding()
'utf-8'
对于可读文件，一些常用的方法是read、seek和tell。read会从文件返回字符。字符的内容是由文件的编码决定的（如UTF-8），如果是二进制模式打开的就是原始字节:
f = open(path)
f.read(10)
'Sue帽a el r'
f2 = open(path, 'rb') # Binary mode
f2.read(10)
b'Sue\xc3\xb1a el '
read模式会将文件句柄的位置提前，提前的数量是读取的字节数。tell可以给出当前的位置：
print(f.tell(),f2.tell())
11 10
尽管我们从文件读取了10个字符，位置却是11，这是因为用默认的编码用了这么多字节才解码了这10个字符。你可以用sys模块检查默认的编码.
seek将文件位置更改为文件中的指定字节:
f.seek(3)
3
f.read(1)
'帽'
f.close()
f2.close()
向文件写入，可以使用文件的write或writelines方法。例如，我们可以创建一个无空行版的prof_mod.py:
with open('tmp.txt', 'w') as handle:
handle.writelines(x for x in open(path) if len(x) > 1)
with open('tmp.txt') as f:
lines = f.readlines()
lines
['Sue帽a el rico en su riqueza,\n',
'que m谩s cuidados le ofrece;\n',
'sue帽a el pobre que padece\n',
'su miseria y su pobreza;\n',
'sue帽a el que a medrar empieza,\n',
'sue帽a el que afana y pretende,\n',
'sue帽a el que agravia y ofende,\n',
'y en el mundo, en conclusi贸n,\n',
'todos sue帽an lo que son,\n',
'aunque ninguno lo entiende.\n']
表3-4列出了一些最常用的文件方法: