利用Python进行数据分析（二）

前文（一）

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

数据结构

元组

用括号括着的数组；用tuple可以将任意的序列或迭代器转换成元组；
通过方括号访问元组中的元素；
元组中的元素类型可能是可变对象，但一旦创建了元组，元组中的对象就不能修改了。

x=4,5,6

x

(4, 5, 6)

tuple([4,2,0])

(4, 2, 0)

tup=tuple('hallo world')
tup

('h', 'a', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd')

tup[2]

'l'

#tup[1]='m'

tu=tuple(['foo',[1,2,3],True])

如果元组中的某个元素是可变的，那就可以在元组中原位置进行相关的操作修改其值；
两个元组相连可直接通过加号运算；
元组乘数字n即为重复n遍

tu[1].append(3)
tu

('foo', [1, 2, 3, 3], True)

(21,2)+(1,)  #好像必须在最后一个元组中元素后加一个逗号，不然加不成功

(21, 2, 1)

(3,'a')*4

(3, 'a', 3, 'a', 3, 'a', 3, 'a')

拆分元组 直接用变量一一对应即可

a,b,c=(4,5,6)

a

4

a,b=([1,23],'false')

a

[1, 23]

如果直接通过这样的拆分方法，当元素个数和变量个数不一样的时候就会拆分失败。此时可以通过*rest(rest名字可变） 方法，将剩下的元素都放到一个元组中。

#a,b=(1,2,3)

a,b,*rest=(1,2,3,4,5)

a

1

rest

[3, 4, 5]

元组中用count方法可以统计元组中某个值出现的频次

a=(1,2,2,2,5,5,5,5,5,8)
a.count(5)

5

列表

列表可变，包括长度可变，也包括内容可以被修改。一般采用方括号定义，或者用list函数定义

a=[1,2,3,4,'m']

tup=(1,2,3,'to')

b=list(tup)

b

[1, 2, 3, 'to']

b[1]

2

列表可以用来在数据处理中实体化迭代器或生成器

g=range(10)
list(g)

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

添加或者删除元素

list可以用append添加元素；
insert可以在特定位置添加元素；
pop是移除并返回指定位置的元素；
remove是去除某个值，当列表中有多个相同值是，remove会先寻找第一个值并除去。
in 可以检查某个元素是否在列表中，在in 前加not表示否定。

b.append('a')
b

[1, 2, 3, 'to', 'a']

b.insert(1,'red')
b

[1, 'red', 2, 3, 'to', 'a']

b.pop(1)

'red'

b

[1, 2, 3, 'to', 'a']

b.append(2)

b

[1, 2, 3, 'to', 'a', 2]

b.remove(2)
b

[1, 3, 'to', 'a', 2]

1 in b

True

1 not in b

False

串联和组合列表

两个列表可以用加号相连接。
可以用extend方法追加多个元素。
当连接的是大型列表的时候，使用extend方法追加元素速度更快。

[1,2,3,4]+[5,6,6]

[1, 2, 3, 4, 5, 6, 6]

a=[1,2,3,4]
a.extend([5,6,7])
a

[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

[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

[1, 2, 2, 4, 5, 7]

bisect.bisect(c,6)

5

c

[1, 2, 2, 4, 5, 7]

bisect.insort(c,6)

c

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

[3, 7, 5]

seq[2:5]=[66,99,1]

seq

[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

{'dsf': 0, 12: 1, 'a': 2, True: 3}

sorted([2,34,5,6,23,4])

[2, 4, 5, 6, 23, 34]

sorted('hallo world')

[' ', 'a', 'd', 'h', 'l', 'l', 'l', 'o', 'o', 'r', 'w']

seq1=[1,2,3]
seq2=['sd','hs','xx']
zipped=zip(seq1,seq2)
list(zipped)

[(1, 'sd'), (2, 'hs'), (3, 'xx')]

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

0:1,sd
1:2,hs
2:3,xx

pic=[(1, 'asd'), (2, 'hss'), (3, 'xx')]
x,y=zip(*pic)

x

(1, 2, 3)

y

('asd', 'hss', 'xx')

list(reversed(range(10)))

[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

字典

创建字典的方法之一是使用尖括号，用冒号分隔键和值。
可以像访问列表或元组的元素一样，访问、插入或设定字典中的元素。
可以通过del或者pop方法删除值。
keys是字典的键，values是字典的值。
使用update可以和另一个字典融合。
通过序列创建字典。
默认值相关知识。
通过hash函数监测一个对象是否可哈希的（可被用作字典的键）。

d={'a':'asd','b':[1,3,4]}
d

{'a': 'asd', 'b': [1, 3, 4]}

d[7]='hallo'

d

{'a': 'asd', 'b': [1, 3, 4], 7: 'hallo'}

d[9]='23d'
d[5]='wd'

d

{'a': 'asd', 'b': [1, 3, 4], 7: 'hallo', 9: '23d', 5: 'wd'}

del d[9]

d

{'a': 'asd', 'b': [1, 3, 4], 7: 'hallo', 5: 'wd'}

ret=d.pop(5)

ret

'wd'

d

{'a': 'asd', 'b': [1, 3, 4], 7: 'hallo'}

d.update({'m':'foo','w':123})

d

{'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

{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'))

-5452363187364022245

集合

集合是无序的不可重复的元素的集合。你可以把它当做字典，但是只有键没有值。可以用两种方式创建集合：通过set函数或使用尖括号set语句。
集合可以所交集、并集等运算。

set([2,3,4,5])

{2, 3, 4, 5}

{21,3,4}

{3, 4, 21}

a = {1, 2, 3, 4, 5}
b = {3, 4, 5, 6, 7, 8}
a.union(b)

{1, 2, 3, 4, 5, 6, 7, 8}

a | b

{1, 2, 3, 4, 5, 6, 7, 8}

a.intersection(b)

{3, 4, 5}

a&b

{3, 4, 5}

集中元素通常是不可变的，要获得类似列表的元素，就必须转换为元组。
a.ssubset(b)
监测a是不是b的子集；
b.issuperset(a)
监测b是不是a的父集

{1, 2, 3} == {3, 2, 1}#集合内容相同时，集合才相等。

True

a_set = {1, 2, 3, 4, 5}

{1, 2, 3}.issubset(a_set)

True

a_set.issuperset({1, 2, 3})

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及以下的字符串，并将其转换成大写

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

[1, 2, 3, 4, 5, 6, 7, 8, 9]

#等价于
flattened = []
for tup in some_tuples:
    for x in tup:
        flattened.append(x)

flattened

[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
#直到从该生成器中请求元素时，它才会开始执行其代码

<generator object pf at 0x0000000005011678>

for x in gen:
    print(x,end=' ')

pingfang from 1 to 100
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))

328350

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

{0: 0, 1: 1, 2: 4, 3: 9, 4: 16}

itertools模块

它根据函数的返回值对序列中的连续元素进行分组.常见的itertools函数有以下几种。

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打开文件，可以更为容易。
打开文件的模式住以下几种：

#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)

常见的文件处理方法：

文件一般使用“文本模式”，一般Python处理的是字符串，需要对其进行编码和解码操作。否则就是二进制模式。