第五节，python基本语法

1、类（Class）

Python中的类的概念与其它语言类似，比较特殊的是protected和private在python中没有明确的限制，通常的惯例是用单下划线_表示protected，用双下划线开头__的表示private。

class A:
    '''Class A'''
    def __init__(self,x,y,name):
        self.x=x
        self.y=y
        self.name=name
    def introduce(self):
        print(self.name)
    def greeting(self):
        print("what's up!")
    def __12norm(self):
        return self.x**2+self.y**2
    def cla_12norm(self):
        return self.__12norm()
a=A(11,11,'Lenaa')
print(A.__doc__)                  #打印类解释信息“Class A"
a.introduce()
a.greeting()
print(a.name)
print(a.cla_12norm())
print(a._A__12norm())      #仍然可以访问，只是名字不一样
print(a.__12norm())          #报错，是私有成员

类的初始化使用的是__init__(self,)，所有成员变量都是self的，所以以self.开头。

双下划线开头的变量触发了Python中一种叫做name mangling的机制，其实只是名字变了，仍然可以通过前面加上”_类名“的方式访问

print(a._A__12norm())      #仍然可以访问，只是名字不一样。

Python中的继承非常简单，最基本的继承方式就是定义类的时候把父类放入括号里即可。

class B(A):
    """Class B inheritenced from A"""
    def greeting(self):
        print("how's going!")
b=B(12,12,'Flauree')
b.introduce()
b.greeting()      # how's going!进行了方法覆盖
print(b.name)     # 输出新的name___Flauree

2、map、reduce和filter

map 可以用于可遍历结构的每个元素执行同样的操作，批量操作：

y =map(lambda  x:x**2,[1,2,3,4])   #[1,4,9,16]
for i in y:
    print(i)
map(lambda  x,y:x+y,[1,2,3],[5,6,7]) #[6,8,10]

reduce则是对可遍历结构的元素按顺序进行两个输入参数的操作，并且每次的结果保存作为下次操作的第一个输入参数，还没有遍历的元素作为第二个输入参数：

reduce(lambda x,y:x+y,[1,2,3,4])     #((1+2)+3)+4=10

filter根据条件课对遍历结构进行筛选：

filter(lambda x:x%2,[1,2,3,4,5])   #筛选奇数，[1,3,5]

对于filter和map，在python2中返回结果是列表，在Python3中返回的是生成器。

zip()函数：可以把多个列表关联起来，可以按顺序同时输出两个列表对应位置的元素对。

zip()函数不会自动帮助判断两个列表是否长度一样，所以最终结果会以短的列表为准，想要以长的列表为准，可以考虑itertools模块中的izip_longest()函数。

for x in zip([1,2,3],[4,5,6]):
    print(sum(x))             # 5，7，9

3、文件操作和pickle

在python中，推荐用上下文管理器（with-as）来打开文件，IO资源的管理更加安全，不用记着给文件执行close()函数，假设有个文件name_age.txt，里面存储着名字和年龄，格式如下：

Tom,8

Jerry,7

Tyke,3

....

# 读取文件内容并全部显示
with open('name_age.txt','r') as f:
    lines=f.readlines()
    for line in lines:
        name,age=line.rstrip().split(',')
        print('{} is {} years old.'.format(name,age))
# Tom is 8 years old.
# Jerry is 7 years old.
# Tyke is 3 years old.

open()函数的第一个参数是文件名，第二个参数是模式，文件的模式一般有4种：读取（r)、写入（w）、追加（a）、和读写（r+）。

有时候进行文件操作时希望把对象进行序列化，可以考虑用pickle模块。

import pickle
lines=[
    "I'm like a dog chasing cars.",
    "I wouldn't know what to do if ..",
    "I'd just do things."
]
with open('lines.pkl','wb') as f:   #序列化并保存成文件
    pickle.dump(lines,f)
with open('lines.pkl','rb')as f:    #从文件读取反序列化
    lines_back=pickle.load(f)
print(lines_back)                   #和lines一样

注意：序列化的时候就要使用b模式了。Python2中有个效率更高的pickle脚cPickle，用法和pickle一样，在Python3中就只有一个pickle。

4、异常操作

在深度学习中，尤其是数据准备阶段，常常遇到IO操作，遇到异常的可能性很高，采用异常处理可以保证数据处理的过程中不被中断，并对有异常的情况进行记录。

for filepath in filelist:   #filelist是文件路径的列表
    try:
        with open(filepath,'r') as f:
            #执行数据处理的相关工作
        print('{} is processed!'.format(filepath))
    except IOError:
        print('{} with IOError!'.format(filepath))
        # 异常的相应处理

5、多进程（multiprocessing)

深度学习中对数据高效处理常常会需要并行，这时多进程就派上了用场。假设在数据准备阶段，有很多文件需要运行一定的预处理，正好有多台核服务器，我们希望把这些文件分成32份，并行处理：

from multiprocessing import Process
def process_data(filelist):
    for filepath in filelist:
        print('Processing {}...'.format(filepath))
        #处理数据
if __name__=='__main__':
    #如果是在windows下，需要加上freeze_support()函数
    freeze_support()
    # full_list包含了要处理的全部文件列表
    n_total=len(full_list)  #一个远大于32的数
    n_processes=32
    # 每段子列表的平均长度
    length=float(n_total)/float(n_processes)
    # 计算下标，尽可能均匀地划分输入文件列表
    indices=[int(round(i*length)) for i in range(n_processes+1)]
    # 生成每个进程要处理的子文件列表
    sublists=[full_list[indices[i]:indices[i+1]]for i in range(n_processes)]
    # 生成进程
    processes=[Process(target=process_data(),args=(x,))for x in sublists]
    # 并行处理
    for p in processes:
        p.start()
    for p in processes:
        p.join()