文件操作##

读取文件

  try:
    f = open("test.txt", "r")
    print f.read()
  finally:
    if f: f.close()

可以使用with块缩短代码

  with open("test.txt", "r") as f:
    print f.read()

分块读取

  f.read(size) 

按行读取：如果要一次性读取所有行，只需调用readlines()

  f.readline()  #  按行读取, 如果要一次性读取所有行，只需调用readlines()
  open("test.txt", "rb")  #  读取二进制文件

读取非ASC2编码的文件：两种方式
第一种方式：用二进制读取之后再转码
第二种方式：用第三个参数指定编码

 open("test.txt", "r", "utf8")

写文件：跟读文件一样

对象序列化##

python的原版对象不能进行序列化，必须转成Dict才可以。
cPickle和pickle：cPickle支持中文，能用就用

  d = { "name": "opower", "age": 18 }
  print pickle.dump(d)
  with open("test.txt", "r") as f:
    pickle.dump(d, f)
  print pickle.load(f)  #  反序列化

JSON：pickle是针对python的，通用的方法是转成JSON格式

  #  序列化和反序列化跟pickle是一样的（就是函数名后面多了个s）
  #  关键在于json的dump提供一个转化函数的参数，可以把一般对象转成Dict后再序列化
  def student2dict(std):
    return {
        'name': std.name,
        'age': std.age,
        'score': std.score
    }
  print(json.dumps(s, default=student2dict))

  #  因为通常class的实例都有一个__dict__属性，它就是一个dict，
  #  用来存储实例变量。也有少数例外，比如定义了__slots__的class。
  print(json.dumps(s, default=lambda obj: obj.__dict__))

  #  反序列一样也可以
  def dict2student(d):
    return Student(d['name'], d['age'], d['score'])

  json_str = '{"age": 20, "score": 88, "name": "Bob"}'
  print(json.loads(json_str, object_hook=dict2student))

多进程##

Linux和Unix的系统，有自带的fork系统函数可以生成进程

  #  getpid：获取当前进程的ID
  #  getppid：获取父进程的ID
  import os

  print 'Process (%s) start...' % os.getpid()
  pid = os.fork()
  if pid==0:
    print 'I am child process (%s) and my parent is %s.' % (os.getpid(), os.getppid())
  else:
    print 'I (%s) just created a child process (%s).' % (os.getpid(), pid)

如果是window平台，需要用multiprocessing模块的Process类

  #  如果是window平台，需要用multiprocessing模块的Process类
  from multiprocessing import Process
  import os

  #  子进程要执行的代码
  def run_proc(name):
    print 'Run child process %s (%s)...' % (name, os.getpid())

  if __name__=='__main__':
    print 'Parent process %s.' % os.getpid()
    p = Process(target=run_proc, args=('test',))
    print 'Process will start.'
    p.start()
    p.join()
    print 'Process end.'

• 可以看出Process接受两个参数，第一个是进程的入口函数；第二个是传入的参数
• join()函数意味着当前进程会停下来，等待子进程执行结束之后再执行
• Process实际上比fork好用，multiprocessing库封装了fork

进程池：可以从进程池批量管理进程池

from multiprocessing import Pool
import os

def printInfo(idx):
    print "Index is",idx,", pid is",os.getpid()

if __name__=='__main__':
    p = Pool()
    for i in range(5):
        p. apply_async(printInfo, args=(i,))
    p.close()
    p.join()

close - 表示进程池不再接受进程（我的理解是所有进程池的进程start，所以join函数得在close之后执行）

进程间通讯:Queue列队和Pipes通道，详细看例子吧

  from multiprocessing import Process, Queue
  import os, time, random

  # 写数据进程执行的代码:
  def write(q):
    for value in ['A', 'B', 'C']:
      print 'Put %s to queue...' % value
      q.put(value)
      time.sleep(random.random())

  # 读数据进程执行的代码:
  def read(q):
    while True:
      value = q.get(True)
      print 'Get %s from queue.' % value

  if __name__=='__main__':
    # 父进程创建Queue，并传给各个子进程：
    q = Queue()
    pw = Process(target=write, args=(q,))
    pr = Process(target=read, args=(q,))
    # 启动子进程pw，写入:
    pw.start()
    # 启动子进程pr，读取:
    pr.start()
    # 等待pw结束:
    pw.join()
    # pr进程里是死循环，无法等待其结束，只能强行终止:
    pr.terminate()

多线程##

利用线程的高级模块，创建线程和进程一样很简单

import threading, time, random

def printInfo():
    for i in range(5):
        time.sleep(random.random() * 3)
        print "Hello",i

if __name__=='__main__':
    thd = threading.Thread(target=printInfo)
    thd.start()
    thd.join()
    print "Sub thread ended"

线程锁：多线程和多进程最大的不同在于，多进程中，同一个变量，各自有一份拷贝存在于每个进程中，互不影响，而多线程中，所有变量都由所有线程共享，所以，任何一个变量都可以被任何一个线程修改，因此，线程之间共享数据最大的危险在于多个线程同时改一个变量，把内容给改乱了。（选自廖雪峰python教程）

import threading, time, random

store = 20
lock = threading.Lock()

def sell(name):
    global store
    while store > 0:
        lock.acquire()  #  加锁
        store -= 1
        print "use by",name,"current:",store
        lock.release()  #  解锁

if __name__=='__main__':
    thdSell1 = threading.Thread(target=sell, args=("sell1",))
    thdSell2 = threading.Thread(target=sell, args=("sell2",))
    thdSell1.start()
    thdSell2.start()
    thdSell1.join()
    thdSell2.join()
    print "Application ended"

• 可以尝试着把加锁/解锁代码注释掉，查看结果
• 如果最后看到负数输出，考虑是因为什么原因，怎么检查原因，最后应该怎么解决

线程局部变量：每个线程有自己需要维护的一组局部变量，如果线程有多个函数，要使用某个局部变量只能依靠参数传递，为了防止函数参数表爆表，py提供了Threading.local

import threading

local_child = threading.local()
lock = threading.Lock()

def giveFruit(fruit):
    lock.acquire()
    local_child.fruit = fruit
    print getInfo()
    lock.release()

def getInfo():
    return local_child.fruit

if __name__=='__main__':
    thdSell1 = threading.Thread(target=giveFruit, args=("apple",))
    thdSell2 = threading.Thread(target=giveFruit, args=("orange",))
    thdSell1.start()
    thdSell2.start()
    thdSell1.join()
    thdSell2.join()
    print "Application ended"

python属于语法相对简单的脚本语言，比起C等传统高级语言，优势在于开发迅捷。因此适用于性能要求不太高的场合，而这样的场合经常出现在普通IO操作上，因此，网络应用、大数据量的输入输入很适合py。但对计算效率要求高的应用（解码、加压解压、跑算法等），如果效果不佳，还是尝试用传统高级语言。

上面线程锁最后输出负数的例子，可以尝试在循环头部打印一下当前执行的线程是哪个

  ...
  while store > 0:
        print "This is",name
        lock.acquire()  #  加锁
  ...

我们会看下输出结果是：
This is sell1
use by sell2 current: 8
This is sell2
use by sell2 current: 7
This is sell2
use by sell2 current: 6
This is sell2
use by sell2 current: 5
This is sell2
use by sell2 current: 4
This is sell2
use by sell2 current: 3
This is sell2
use by sell2 current: 2
This is sell2
use by sell2 current: 1
This is sell2
use by sell1 current: 0
use by sell2 current: -1
可以看到，当库存还有9的时候，线程1进入循环，但紧接着被线程2打断。线程2一直执行到库存还有1的时候，也是进入循环之后被线程1打断，线程1用掉最后一个库存，但不要忘了，这个时候2已经进入循环了，于是它在0库存的基础上用了不存在的值。
修正的方法也很简单，做一个死循环，所有的逻辑都放在里面并被锁包住，跳出条件是库存小于等于0，便可以了。