第二章 数据结构相关话题
2.1、筛选数据
两种方式
filter函数：filter(lambda x: x>0, data)
注意：python3 需要把filter的结果转为list ，也就是list(filter(lambda x: x>0, data))
加条件的遍历: [ x for x in data if x > 0 ]
如果想转成集合，就把[]改成{}
2.2、如何为元组的每个元素命名
使用元组的好处：减少存储开销
缺点：使用索引访问元素，降低程序可读性
解决方案：
1、定义一系列数值常量
NAME, AGE, SEX, EMAIL = range(4)
2、使用标准库中的collections.namedtuple替代内置tuple
from collections import namedtuple
Student = namedtuple('Student', ['name','age','sex','email']) # 定义类
s = Student('jim',16, 'male', '[email protected]') # 赋值就跟创建一个对象类似
s.name # 获取元素
isinstance(s, tuple) # 元组类型
2.3、如何统计序列中出现的频度
解决方案：使用collections.Counter对象
将序列传入Counter的构造器，得到Counter对象是元素频度的字典
Counter.most_common(n)方法得到频度最高的n个元素的字典
2.4、如何根据字典中值的大小，对字典进行排序
解决方案：使用内置函数sorted
# 1、利用Zip将字典数据转为元组
s ={ x: randint(60,100) for x in 'xyzabc'}
z = list(zip(s.values(), s.keys()))
sorted(z)
# 2、传递sorted函数的key参数
sorted(s.items(), key=lambda x: x[1])
s.items() # 是把字典转为元组的序列
x[1] # 获取元组的第二个元素
2.5、如何快速找到多个字典的公共键
案例：统计每轮比赛都有进球的球员
解决方案：利用集合的交集操作
1、使用字典的viewkeys()方法，得到一个字典keys的集合
2、使用map函数，得到所有字典的keys的集合
3、使用reduce函数，取所有字典的keys的集合的交集
reduce(lambda a,b: a & b, map(dict.viewkeys, [s1,s2,s3]))
2.6、如何让字典保持有序，也就是遍历的时候按插入顺序打印
解决方案：使用collections.OrderedDict
以OrderedDict代替内置字典dict，依次将数据存入OrderedDict
2.7、如何实现用户的历史记录功能（最多n条）
解决方案：使用容量为n的队列容量存储历史记录
使用标准库collections中的deque,它是一个双端循环队列
程序退出前，可以使用pickle将队列存入文件，再次运行时将其导入。
第三章 迭代器
3.1、如何实现可迭代对象和迭代器对象
可迭代对象需要有iter方法，这个方法返回迭代器对象。
而迭代器对象则要有next()
class WeatherIterator(Iterator):
def __init__(self, cities):
self.cities = cities
self.index = 0
def getWeather(self, city):
r = requests.get(u'http://wthrcdn.etouch.cn/weather_mini?city=' + city)
data = r.json()['data']['forecast'][0]
return '%s: %s, %s' % (city, data['low'], data['high'])
def next(self):
if self.index == len(self.cities):
raise StopIteration
city = self.cities[self.index]
self.index += 1
return self.getWeather(city)
class WeatherIterable(Iterable):
def __init__(self, cities):
self.cities = cities
def __iter__(self):
return WeatherIterator(self.cities)
3.2、如何使用生成器函数实现可迭代对象
yield关键字
yield 是一个类似 return 的关键字，只是这个函数返回的是个生成器
当你调用这个函数的时候，函数内部的代码并不立马执行 ，这个函数只是返回一个生成器对象
当你使用for进行迭代的时候，函数中的代码才会执行
class PrimeNumbers:
def __init__(self, start, end):
self.start = start
self.end = end
def isPrimeNum(self, k):
if k < 2:
return False
for i in xrange(2, k):
if k % i == 0:
return False
return True
def __iter__(self):
for k in xrange(self.start, self.end + 1):
if self.isPrimeNum(k):
yield k
for x in PrimeNumbers(1, 200):
print x
3.3、 如何进行反向迭代以及如何实现反向迭代
解决方案：
1、使用内置函数reversed()方法
2、实现反向迭代协议的 __reverse 方法，它返回一个反向迭代器
class FloatRange:
def __init__(self, start, end, step=0.1):
self.start = start
self.end = end
self.step = step
def __reversed__(self):
t = self.end
while t>= self.start:
yield t
t -= self.step
for x in reversed(FloatRange(1.0, 3.0, 0.4)):
print x
3.5、 如何对迭代器做切片操作
解决方案：使用标准库中的itertools.islice,它能返回一个迭代对象切片的生成器
from itertools import islice
f = open('a.txt')
t = islice(f, 4, 6)
for x in t:
print x,
print '--------'
//注：会从上面的位置继续迭代下去
for x in f:
print x,
3.6、如何在一个for语句中迭代多个可迭代对象
解决方案：
并行：使用内置函数zip,它能将多个可迭代对象合并，每次迭代返回一个元组
串行：使用标准库中的itertools.chain,它能将多个可迭代对象连接
from random import randint
from itertools import chain
chinese = [randint(60, 100) for _ in xrange(40)]
english = [randint(60, 100) for _ in xrange(40)]
math = [randint(60, 100) for _ in xrange(40)]
totals = []
for c, e, m in zip(chinese, english, math):
totals.append(c + m + e)
for x in totals:
print x
e1 = [randint(60, 100) for _ in xrange(40)]
e2 = [randint(60, 100) for _ in xrange(42)]
e3 = [randint(60, 100) for _ in xrange(42)]
e4 = [randint(60, 100) for _ in xrange(46)]
count = 0
for s in chain(e1, e2, e3, e4):
if s >= 90:
count += 1
print count
第四章 字符串处理
4.1、如何拆分含有多种分隔符的字符串
解决方案：
1、连续使用str.split()方法，每次处理一种分隔符
2、使用正则表达式的re.split()方法，一次性拆分字符串
import re
def mySplit(s, ds):
res = [s]
for d in ds:
t = []
map(lambda x: t.extend(x.split(d)), res)
res = t
return [x for x in res if x]
s = 'ab;cd|edfs\tsdf,llksjd|sdfsd'
print mySplit(s, ';,|\t')
print re.split(r'[,;|\t]+', s)
4.2、如何判断一个字符串是以b开头或结尾
解决方案：
使用字符串的str.startswith()和endswith()方法。注意：多个匹配时参数使用元组。
import os, stat
list = os.listdir('.')
namelist = [name for name in list if name.endswith(('.py', '.sh'))]
for name in namelist:
os.chmod(name, os.stat(name).st_mode | stat.S_IXUR)
4.3、如何调整字符串中文本的格式
解决方案：
使用正则表达式re.sub()方法做字符串替换，利用正则表达式的捕获组，捕获每个部分内容，在替换字符串中调整各个捕获组的顺序
import re
s = '2016-06-23 10:32:00'
print re.sub('(\d{4})-(\d{2})-(\d{2})',r'\2/\3/\1', s)
print re.sub('(?P\d{4})-(?P\d{2})-(?P\d{2})',r'\g/\g/\g', s)
4.4、如何将多个小字符串拼接成一个大字符串
解决方案：
方法一：迭代列表，使用‘+’连接字符串
方法二：使用str.join()方法，更加快速的拼接列表的字符串
l = ['abc', 45, 123, 'xyc']
l2 = ['abc', '45', '123', 'xyc']
s = ''.join(str(x) for x in l) #当数组中有些元素不是字符串时，可以用生成器格式化元素
s2 = ''.join(l)
print s
4.5、如何对字符串进行左中右对齐
解决方案：
1、使用字符串的str.ljust(), str.rjust(), str.center()进行左中右对齐
2、使用format()方法，传递类似‘<20’, '^20', '>20'参数
s = 'abc'
print s.ljust(20, '=')
print s.rjust(20, '=')
print s.center(20, '=')
print format(s, '<20')
print format(s, '^20')
print format(s, '>20')
4.6、如何去掉字符串中不需要的字符
解决方案：
1、字符串strip(), lstrip(), rstrip()去掉字符串两端字符
2、删除单个固定位置的字符，可以使用切片 + 拼接的方式
3、字符串的replace方法或正则表达式re.sub()删除任意位置字符
4、字符串translate()方法，可以同时shanchu删除多种不同字符
import re
import string
s = 'abc:123'
print s[:3] + s[4:] #使用切片 + 拼接
s = '\t123\t123\txyz'
print s.replace('\t', '') #字符串的replace方法
s = '\t123\n123\r123'
print re.sub('[\t\r\n]', '', s) #正则表达式re.sub()
s = 'abc123xyz'
print s.translate(string.maketrans('abcxyz','xyzabc')) #字符串translate()方法
s = '\t123\n123\r123'
print s.translate(None, '\t\n\r')
第五章 文件处理
5.1、如何读写文本文件（py2和py3区别）
字符串的语义发生变化
py2 py3
str ---> bytes
unicode ----> str
解决方案：
py2 写入文件前对unicode编码，读入文件后对二进制解码
py3 open函数指定‘t’的文本模式，encoding指定编码格式
# py2
f = open('test.txt', 'w')
s = u'你好,我爱你'
f.write(s.encode('utf8'))
f.close()
f = open('test.txt', 'r')
t = f.read()
print t.decode('utf8')
# py3
f = open('test.txt', 'wt', encoding='utf8')
f.write('你好，我爱编程')
f.close()
f = open('test.txt', 'rt', encoding='utf8')
s = f.read()
print(s)
5.2、如何处理二进制文件
解决方案：
open函数以二进制模式打开文件，指定mode为‘b’
二进制文件可以用readinto，读入到提前分配好的buffer中，便于数据处理
解析二进制文件可以用标准库中的struct模块的unpack方法
import struct
import array
f = open('demo.wav', 'rb')
info = f.read(44)
struct.unpack('h', info[22:24])
struct.unpack('i', info[24:28])
f.seek(0, 2) # 将文件的指针移到末尾
f.tell() # 报告文件的指针
n = (f.tell() - 44) / 2 # 数组的长度
buf = array.array('h', (0 for _ in xrange(n)))
f.seek(44)
f.readinto(buf)
for i in xrange(n): buf[i] /= 8
f2 = open('demo2.wav', 'wb')
f2.write(info)
buf.tofile(f2)
f2.close()
5.3、如何设置文件的缓冲
解决方案：设置open函数的buffering参数
1、全缓冲，buffering设置为大于1的整数n，n为缓冲区大小
2、行缓冲，buffering设置为1，遇到换行符\n就停止缓冲
3、无缓冲，buffering设置为0
f = open('demo.txt', 'w', buffering=n) # n为缓冲区大小
tail -f demo.txt # 可以检测是否写入到磁盘
5.4、如何将文件映射到内存
解决方案：使用标准库mmap模块中的mmap()函数，它需要一个打开的文件描述符作为参数
f = open('demo.bin', 'r+b')
f.fileno() # 文件描述符
m = mmap.mmap(f.fileno(), 0, access=mmap.ACCESS_WRITE)
5.5、如何访问文件的状态
解决方案：
1、系统调用，标准库中os模块下的三个系统调用stat, fstat, lstat获取文件状态
2、快捷调用，标准库中os.path下一些函数，使用起来更加简洁（没有文件 访问权限的函数）
5.6、如何使用临时文件？
解决方案：使用标准库中tempfile下的TemporaryFile, namedTemporaryFile
第六章 数据处理
6.1、如何读写CSV数据
解决方案：使用标准库中的CSV模块，可以使用其中reader和writer完成CSV读写
import csv
with open('pingan.csv', 'rb') as rf:
reader = csv.reader(rf)
with open('pingan2.csv', 'wb') as wf:
writer = csv.writer(wf)
headers = reader.next()
writer.writerow(headers)
for row in reader:
if row[0] < '2016-01-01':
break;
if int(row[5]) > 5000000:
writer.writerow(row)
print('end')
6.2、如何读写json数据
解决方案：使用标准库中的json模块，其中loads，dumps函数可以完成json数据的读写
# -*- coding: utf-8 -*
import json
l = [1, 2, 'abc', {'name': 'bob', 'age': 19}]
s = json.dumps(l) # 把对象转成json字符串
# s = json.dumps(l, separators=[',', ':']) # 去掉空格
l2 = json.loads(s) # 把json字符串转成对象
print s
print l2
with open('demo.json', 'wb') as f:
json.dump(l, f) # 写入文件
6.3、如何读写Excel文件
解决方案：使用第三方库xlrd和xlwt，这两个库分别用于Excel读和写
#coding:utf8
import xlrd
import xlwt
rbook = xlrd.open_workbook('demo.xlsx')
rsheet = rbook.sheet_by_index(0)
nc = rsheet.ncols
rsheet.put_cell(0, nc, xlrd.XL_CELL_TEXT, u'总分', None)
for row in xrange(1, rsheet.nrows):
t = sum(rsheet.row_values(row, 1))
print t
rsheet.put_cell(row, nc, xlrd.XL_CELL_NUMBER, t, None)
print rsheet.name
wbook = xlwt.Workbook()
wsheet = wbook.add_sheet(rsheet.name)
style = xlwt.easyxf('align: vertical center, horizontal center')
for r in xrange(rsheet.nrows):
for c in xrange(rsheet.ncols):
wsheet.write(r, c, rsheet.cell_value(r, c), style)
wbook.save('output.xls')