cookbook1-10章学习

1、python cookbook学习

原文：https://python3-cookbook.readthedocs.io/zh_CN/latest/

• 一、数据结构和算法

去除序列中出现的重复元素，保持剩下的元素顺序不变

def dedupe(items):
    seen = set()
    for item in items:
        if item not in seen:
            yield item
            seen.add(item)
input: a = [1, 5, 2, 1, 9, 1, 5, 10]
         print(list(dedupe(a)))
output:[1, 5, 2, 9, 10]

• 二、字符串和文本

通过正则表达式匹配文本
可用于爬虫

import re
text1 = 'Computer says "no." Phone says "yes."'
str_path = re.compile(r'\"(.*)\"')   #(不加？为贪婪算法)
str_path_2 = re.compile(r'\"(.*?)\"')
print(str_path.findall(text1))
print(str_path_2.findall(text1))
output: ['no." Phone says "yes.']
          ['no.', 'yes.']

• 三、时间、 日期和时间

随机选择

import random
values = [1, 2, 3, 4, 5, 6]
print(random.shuffle(values))   #打乱元素的顺序（洗牌）
output:[2, 4, 6, 5, 3, 1]  

• 四、迭代器和生成器

同时迭代多个序列

xpts = [1, 5, 4]
ypts = [101, 78, 37]
for x, y in zip(xpts, ypts):
      print(x, y)
output:
1 101
5 78
4 37

from itertools import chain
a = [1, 2, 3, 4]
b = ['x', 'y', 'z']
for x in chain(a, b):
	print(x)
output:
1
2
3
4
x
y
z

合并多个有序序列，再对整个有序序列进行迭代

import heapq
a = [1, 4, 7, 10]
b = [2, 5, 6, 11]
for i in heapq.merge(a, b):
	print(i)
output:
1
2
4
5
6
7
10
11

• 五、文件和I/O

对已不存在的文件执行写入操作

with open('somefile', 'xt') as f:
	f.write('Hello\n')  #该操作在已经存在somefile文件时不会进行覆盖，而是报错

对固定大小的记录进行迭代

 from functools import partial
 RECORD_SIZE = 32
 with open('somefile.data', 'rb') as f:
      records = iter(partial(f.read, RECORD_SIZE),b'')
      for r in records:
      	...

处理路径名

import os
path = '/Users/beazley/Data/data.csv'
print(os.path.basename(path))   #获取末端路径
print(os.path.dirname(path))    #获取所在文件夹路径
print(os.path.join('tmp', 'data', os.path.basename(path)))
print(os.path.splitext(path))
print(os.path.exists('/home'))


output:
data.csv
/Users/beazley/Data
/tmp/data/data.csv
('/Users/beazley/Data/data', '.csv')
True
  uesrname

获取目录内容的列表

print(os.listdir('/home'))      #获取目录中的文件列表
pyfiles = [name for name in os.listdir('dirname')
            if name.endswith('.py')]
#或者
import glob
pyfiles = glob.glob('dirname/*.py')
#或者
from fnmatch import fnmathc
pyfiles = [name for name in os.listdir('dirname')
            if fnmatch(name, '*.py')]

序列化python对象

import pickle
#若对象为字节串
#通过 pickle.load()和pickle.dump()进行读和写
#若对象为字符串
#通过 pickle.loads()和pickle.dumps()进行读和写
#同时
#pickle.dumps()可以将字节串转储为字符串

• 六、数据编码和处理

数据汇总和统计

#假设存在一个data.csv文件，存储了date、country、project三列数据
import pandas as pd
data = pd.read_csv('data.csv')
#筛选数据
China_data = data[data['country'] == 'China']
#获取China_data中各类project出现次数，并获得排名前十的数据
China_data['project'].value_counts()[:10]
#按照date对数据进行打包
dates = data.groupby('date')
date_counts = dates.size()
print(date_counts[0:10])

output:
date
01/03/2011  4
01/03/2012  125
01/03/2013  54
...

#对上述数据通过sort进行整理
date_counts.sort()

• 七、函数

编写只接受关键字参数的函数
将关键字参数放置在以打头的参数或者一个单独的之后，此特性很容易实现

  def recv(maxsize, *, block):
      pass
  recv(1024, True)            #TypeError
  recv(1024, block=True)      #ok

定义匿名或内联函数

  add = lambda x, y: x + y
  上述表达式等效为下列函数
  def add(x, y):
      return x + y
  另外lambda表达式可用在如下的上下文环境中，对数据进行排序或整理
  names = ['David Beazley', 'Brain Jones', 'Ray Het', 'Ned Bat']
  print(sorted(names, key=lambda name: name.split()[-1].lower()))
  output:
  ['Ned Bat', 'David Beazley', 'Ray Het', 'Brain Jones']

内联回调函数

def apply_async(func, args, *, callback):
  # Compute the result
  result = func(*args)
  # Invoke the callback with the result
  callback(result)
from queue import Queue
from functools import wraps
class Async:
    def __init__(self, func, args):
        self.func = func
        self.args = args
def inlined_async(func):
    @wraps(func)
    def wrapper(*args):
        f = func(*args)             # 定义f=test()
        result_queue = Queue()
        result_queue.put(None)
        while True:
            result = result_queue.get()
            try:
                a = f.send(result)	# 第一次调用时,a=Async(add,(2,3)),result=None
                apply_async(a.func, a.args, callback=result_queue.put)
            except StopIteration:
                break
    return wrapper

def add(x, y):
    return x + y

@inlined_async
def test():
    r = yield Async(add, (2, 3))    # 一开始r=result=None,在第二次f.send(result)时，r=5
    print(r)
    r = yield Async(add, ('hello', 'world'))
    print(r)
    for n in range(10):
        r = yield Async(add, (n, n))
        print(r)
    print('Goodbye')

test()

output:
5
helloworld
0
2
4
6
8
10
12
14
16
18
Goodbye

• 八、类与对象

调用父类的方法

# test.py
class A:
    def spam(self):
        print('A.spam')

class B(A):
    def spam(self):
        print('B.spam')
        super().spam()

if __name__ == '__main__':
    b = B()
    b.spam()
    
output:
B.spam
A.spam

• 九、元编程

定义一个可接受参数的装饰器函数

from functools import wraps
import logging

def logged(level, name=None, message=None):
    """
    Add logging to a function. level is the logging
    level, name is the logger name, and message is the
    log message. If name and message aren't specified,
    they default to the function's module and name.
    """
    print(level)
    def decorate(func):
        logname = name if name else func.__module__
        log = logging.getLogger(logname)
        logmsg = message if message else func.__name__

        @wraps(func)
        def wrapper(*args, **kwargs):
            log.log(level, logmsg)
            return func(*args, **kwargs)
        return wrapper
    return decorate

# Example use
@logged(logging.DEBUG)
def add(x, y):
    return x + y

@logged(logging.CRITICAL, 'example')
def spam():
    print('Spam!')
    
add(2,3)
spam()

###
@decorator(x, y, z)
def func(a, b):
    pass

上述与下面的操作等效
def func(a, b):
    pass
func = decorator(x, y, z)(func)
###

• 十、模块与包

让各个目录下的代码在统一的命名空间下导入
这个大家在服务器中同个模块中不同小部分的时候很有用

###
假设你有Python代码的两个不同的目录如下：
foo-package/
    spam/
        blah.py

bar-package/
    spam/
        grok.py
###

import sys
sys.path.extend(['foo-package', 'bar-package'])
import spam.blah
import spam.grok