python 高级编程技巧学习笔记

第二章 数据结构相关话题

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', 'aa@aa.com')  # 赋值就跟创建一个对象类似
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<year>\d{4})-(?P<month>\d{2})-(?P<day>\d{2})',r'\g<month>/\g<day>/\g<year>', 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')