第三章 Python的数据结构、函数和文件
数据结构
元组
用括号括着的数组；用tuple可以将任意的序列或迭代器转换成元组；
通过方括号访问元组中的元素；
元组中的元素类型可能是可变对象，但一旦创建了元组，元组中的对象就不能修改了。
x=4,5,6
#x
tuple([4,2,0])
tup=tuple('hallo world')
#tup
tup[2]
#tup[1]='m'
tu=tuple(['foo',[1,2,3],True])
如果元组中的某个元素是可变的，那就可以在元组中原位置进行相关的操作修改其值；
两个元组相连可直接通过加号运算；
元组乘数字n即为重复n遍。
tu[1].append(3)
tu
(21,2)+(1,) #好像必须在最后一个元组中元素后加一个逗号，不然加不成功
(3,'a')*4
拆分元组 直接用变量一一对应即可
a,b,c=(4,5,6)
a
a,b=([1,23],'false')
a
如果直接通过这样的拆分方法，当元素个数和变量个数不一样的时候就会拆分失败。此时可以通过*rest(rest名字可变） 方法，将剩下的元素都放到一个元组中。
#a,b=(1,2,3)
a,b,*rest=(1,2,3,4,5)
a
rest
元组中用count方法可以统计元组中某个值出现的频次
a=(1,2,2,2,5,5,5,5,5,8)
a.count(5)
列表
列表可变，包括长度可变，也包括内容可以被修改。一般采用方括号定义，或者用list函数定义
a=[1,2,3,4,'m']
tup=(1,2,3,'to')
b=list(tup)
b
# out: [1, 2, 3, 'to']
b[1]
# out: 2
列表可以用来在数据处理中实体化迭代器或生成器
g=range(10)
list(g)
# out: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
添加或者删除元素
list可以用append添加元素；
insert可以在特定位置添加元素；
pop是移除并返回指定位置的元素；
remove是去除某个值，当列表中有多个相同值是，remove会先寻找第一个值并除去。
in 可以检查某个元素是否在列表中，在in 前加not表示否定。
b.append('a')
b
# out: [1, 2, 3, 'to', 'a']
b.insert(1,'red')
b
# out:[1, 'red', 2, 3, 'to', 'a']
b.pop(1)
# out: 'red'
b.remove(2)
b
# out: [1, 3, 'to', 'a', 2]
串联和组合列表
两个列表可以用加号相连接。
可以用extend方法追加多个元素。
当连接的是大型列表的时候，使用extend方法追加元素速度更快。
[1,2,3,4]+[5,6,6]
# out: [1, 2, 3, 4, 5, 6, 6]
a=[1,2,3,4]
a.extend([5,6,7])
a
# out: [1, 2, 3, 4, 5, 6, 7]
#everything = []
#for chunk in list_of_lists:
# everything.extend(chunk)
#比
#everything = []
#for chunk in list_of_lists:
# everything = everything + chunk
#快
排序
sort方法进行从小到大排序，就改变原列表，不创建新的对象
sort方法还有一些选项，例如可以通过设定key，设定二级排序关键字，通过长度排序就为：key= len
a=[2,1,3,5,7,4,6,3,4]
a.sort()
a
# out: [1, 2, 3, 3, 4, 4, 5, 6, 7]
二分搜索和维护已排序的列表
bisect 模块支持二分查找，和向已排序的列表插入值。 bisect.bisect 可以找到插入值后仍保证排序的位置， bisect.insort 是向这个位置插入值。
注意：是已排序的列表。
import bisect
c=[1,2,2,4,5,7]
bisect.bisect(c,2)
c
# out: [1, 2, 2, 4, 5, 7]
bisect.bisect(c,6)
# out: 5
c
# out: [1, 2, 2, 4, 5, 7]
bisect.insort(c,6)
c
# out: [1, 2, 2, 4, 5, 6, 7]
切片
切片的基本形式是start：stop;也可以对切片结果进行赋值。
切片中包括起始位置，不包括结束位置元素。切片中包含的元素格式是stop-start。如果不写start或者stop，就是默认是序列的开头或结尾。
同样的切片中的参数可以为负数，-1表示倒数第一个，-3表示倒数第三个。
当出现两个冒号的时候，第二个冒号后的含义为step(步长），为2表示隔一个元素取值，当步长为-1时，表示将列表或者元组颠倒过来。
seq = [7, 2, 3, 7, 5, 6, 0, 1]
seq[2:5]
# out:[3, 7, 5]
seq[2:5]=[66,99,1]
seq
# out:[7, 2, 66, 99, 1, 6, 0, 1]
序列函数
enumerate函数
Python内建了enumerate 函数，可以返回 (i, value) 元组序列。当你索引数据时，使用 enumerate 的一个好⽅法是计算序列（唯一的） dict 映射到位置的值。
sorted函数
sorted函数可以从任意序列的元素返回一个新的排好序的列表。同时，sorted函数可以接受sort相同的参数。
zip函数
zip可以将多个列表、元组或其他序列成对组合成一个元素列表；zip可以处理任意多的序列，元素的个数取决于最短的序列。
zip的常见用法之一是同时迭代多个序列，可以与enumerate函数结合使用。
zip也可以被用来解压序列。
reversed函数
reversed函数可以从后向前迭代一个序列。
some=['dsf',12,'a',True]
m={}
for i,v in enumerate(some):
m[v]=i
m
# out: {'dsf': 0, 12: 1, 'a': 2, True: 3}
sorted([2,34,5,6,23,4])
# out: [2, 4, 5, 6, 23, 34]
sorted('hallo world')
# out: [' ', 'a', 'd', 'h', 'l', 'l', 'l', 'o', 'o', 'r', 'w']
seq1=[1,2,3]
seq2=['sd','hs','xx']
zipped=zip(seq1,seq2)
list(zipped)
# out: [(1, 'sd'), (2, 'hs'), (3, 'xx')]
for i,(a,b) in enumerate(zip(seq1,seq2)):
print('{0}:{1},{2}'.format(i,a,b))
'''# out:
0:1,sd
1:2,hs
2:3,xx'''
pic=[(1, 'asd'), (2, 'hss'), (3, 'xx')]
x,y=zip(*pic)
x
# out: (1, 2, 3)
y
# out: ('asd', 'hss', 'xx')
list(reversed(range(10)))
# out: [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
字典
创建字典的方法之一是使用尖括号，用冒号分隔键和值。
可以像访问列表或元组的元素一样，访问、插入或设定字典中的元素。
可以通过del或者pop方法删除值。
keys是字典的键，values是字典的值。
使用update可以和另一个字典融合。
通过序列创建字典。
默认值相关知识。
通过hash函数监测一个对象是否可哈希的（可被用作字典的键）。
d={'a':'asd','b':[1,3,4]}
d
# out: {'a': 'asd', 'b': [1, 3, 4]}
d[7]='hallo'
d
# out: {'a': 'asd', 'b': [1, 3, 4], 7: 'hallo'}
d[9]='23d'
d[5]='wd'
d
# out: {'a': 'asd', 'b': [1, 3, 4], 7: 'hallo', 9: '23d', 5: 'wd'}
del d[9]
d
# out: {'a': 'asd', 'b': [1, 3, 4], 7: 'hallo', 5: 'wd'}
ret=d.pop(5)
ret
# out: 'wd'
d
# out: {'a': 'asd', 'b': [1, 3, 4], 7: 'hallo'}
d.update({'m':'foo','w':123})
d
# out: {'a': 'asd', 'b': [1, 3, 4], 7: 'hallo', 'm': 'foo', 'w': 123}
#mapping = {}
#for key, value in zip(key_list, value_list):
# mapping[key] = value
#或者：
map=dict(zip(range(5),reversed(range(5))))
map
# out: {0: 4, 1: 3, 2: 2, 3: 1, 4: 0}
#value = some_dict.get(key, default_value)
#当字典中有key时，就返回key对应的value值，如果没有key就返回default_value。get默认会返回None
#setdefault方法可以提取单词首字母，并列举成一个字典。
#for word in words:
# letter = word[0]
# by_letter.setdefault(letter, []).append(word)
#collections 模块有一个很有的的类， defaultdict ，它可以进一步简化上面。传递类型或函数以生成每个位置的默认值：
#from collections import defaultdict
#by_letter = defaultdict(list)
#for word in words:
# by_letter[word[0]].append(word)
hash((1,23,2,'w'))
# out: -5452363187364022245
集合
集合是无序的不可重复的元素的集合。你可以把它当做字典，但是只有键没有值。可以用两种方式创建集合：通过set函数或使用尖括号set语句。
集合可以所交集、并集等运算。
12.png
set([2,3,4,5])
# out: {2, 3, 4, 5}
{21,3,4}
# out: {3, 4, 21}
a = {1, 2, 3, 4, 5}
b = {3, 4, 5, 6, 7, 8}
a.union(b)
# out: {1, 2, 3, 4, 5, 6, 7, 8}
a | b
# out: {1, 2, 3, 4, 5, 6, 7, 8}
a.intersection(b)
# out: {3, 4, 5}
a&b
# out: {3, 4, 5}
集中元素通常是不可变的，要获得类似列表的元素，就必须转换为元组。
a.ssubset(b)
监测a是不是b的子集；
b.issuperset(a)
监测b是不是a的父集
{1, 2, 3} == {3, 2, 1}#集合内容相同时，集合才相等。
# out: True
a_set = {1, 2, 3, 4, 5}
{1, 2, 3}.issubset(a_set)
# out: True
a_set.issuperset({1, 2, 3})
# out: True
列表、集合和字典推导式
它允许用户方便的从一个集合过滤元素，形成列表，在传递参数的过程中还可以修改元素。
列表推导式
形式如下：
[expr for val in collection if condition]
字典推导式
dict_comp = {key-expr : value-expr for value in collection if condition}
集合推导式
set_comp = {expr for value in collection if condition}
#等同于下面的for循环
#result = []
#for val in collection:
# if condition:
# result.append(expr)
strings = ['a', 'as', 'bat', 'car', 'dove', 'python']
[x.upper() for x in strings if len(x) >2]
#过滤出长度在2及以下的字符串，并将其转换成大写
# out: ['BAT', 'CAR', 'DOVE', 'PYTHON']
# 嵌套列表推导式
# 使用多个for语句
some_tuples = [(1, 2, 3), (4, 5, 6), (7, 8, 9)]
flattened = [x for tup in some_tuples for x in tup]
flattened
# out: [1, 2, 3, 4, 5, 6, 7, 8, 9]
#等价于
flattened = []
for tup in some_tuples:
for x in tup:
flattened.append(x)
flattened
# out: [1, 2, 3, 4, 5, 6, 7, 8, 9]
函数
用def声明函数名，用return返回关键字；
同时拥有多条return语句也是可以的。如果到达函数末尾时没有遇到任何一条return语句，则返回None。
命名空间、作用域和局部函数，我的理解是，在创建函数的时候，函数内的变量只是在函数内有效，当在函数外使用变量时，则没有效果。这个时候需要声明函数变量是全局变量。
Python中return可以返回多个值。
匿名（lambda）函数
匿名函数仅由但条语句组成，该语句的结果就是返回值。
柯里化：部分参数应用
将之前的函数部分再封装成另一个函数。
#匿名函数
def short_function(x):
return x+2
#等价于
equiv = lambda x:x+2
生成器
生成器（generator）是构造新的可迭代对象的⼀种简单⽅式。一般的函数执⾏之后只会返回单个值，而生成器则是以延迟的⽅式返回⼀个值序列，即每返回一个值之后暂停，直到下一个值被请求时再继续。要创建一个生成器，只需将函数中的return替换为yeild即可。
生成器表达式
使用生成器表达是，可以更简洁构造生成器。其创建方式为，把列表推导式两端的方括号改为圆括号。
def pf(n=10):
print('pingfang from 1 to {0}'.format(n**2))
for i in range(1,n+1):
yield i**2
gen=pf()
#调用该生成器时，没有任何代码会被立即执行
gen
#直到从该生成器中请求元素时，它才会开始执行其代码
# out: <generator object pf at 0x0000000005011678>
for x in gen:
print(x,end=' ')
# out: pingfang from 1 to 100
# out:1 4 9 16 25 36 49 64 81 100
#生成器表达式
gen=(x ** 2 for x in range(100))
#生成器表达式也可以取代列表推导式，作为函数参数：
sum(x ** 2 for x in range(100))
# out: 328350
dict((i,i**2) for i in range(5))
# out: {0: 0, 1: 1, 2: 4, 3: 9, 4: 16}
itertools模块
它根据函数的返回值对序列中的连续元素进行分组.常见的itertools函数有以下几种。
13.png
import itertools
f=lambda x:x[0]
names=['alan','adam','was','hallo','halen','bilibili']
for letter,name in itertools.groupby(names,f):
print(letter,list(name))
'''
a ['alan', 'adam']
w ['was']
h ['hallo', 'halen']
b ['bilibili']
'''
错误和异常处理
一般使用try语句。
一般为try ……except……语句。当try为异常或者错误的时候，执行except语句。
#一般格式为。
#try :
# xxx
#except :
# yyy
#else:
# zzz
#finally:
# mmm
# 上面语句表示执行try下面的语句，并判断是否有异常，当有异常或者错误的时候，执行except下的语句。
#当try部分成功的情况下，执行else部分语句。finally部分语句，是不管try部分语句是否成功，最后都会执行。
文件和操作系统
打开文件
使用内置函数open（）就可以打开一个相对或者绝对的文件路径,默认情况下，文件是以只读模式（'r'）打开的。然后，我们就可以像处理列表那样来处理这个文件句柄： f=oprn(path),for line in f:通过for语句就可以对文件的每一行进行处理。
从文件中取出的行都带有完整的⾏结束符（EOL），因此你常常会看到下面这样的代码（得到一组没有EOL的行）：
lines = [x.rstrip() for x in open(path)]；如果使用open创建文件对象，一定要用close关闭它。关闭文件可以返回操作系统资源。
使用with打开文件，可以更为容易。
打开文件的模式住以下几种：
14.png
#with oprn(path) as f:
# lines = [x.rstrip() for x in f]
#用with打开文件用，退出的时候会自动关闭文件。
#对于可读文件，一般常用的方法有read、seek和tell。read会从文件返回字符。
# 可以使用sys模块检查文件默认的编码。
#sys.getdefaultencoding()
向文件中写入
可以用write或者writelines方法。
with open('tmp.txt', 'w') as handle:
handle.writelines(x for x in open(path) if len(x) > 1)
常见的文件处理方法：
15.png
文件一般使用“文本模式”，一般Python处理的是字符串，需要对其进行编码和解码操作。否则就是二进制模式。
网友评论