1. 简介
   1. 发音:[ 'paiθ(ə)n; (US) 'paiθɔn ]
   2. 解释型
   3. 交互性
   4. 动态类型
   5. 强类型
   6. 面向对象
      1. 便于复用、设计
2. python基础
   1. 万物皆对象@python
      1. 程序有模块构成
      2. 模块有语句组成
      3. 语句有表达式构成
      4. 表达式是用来创建处理对象的
   2. python 对象
      1. 标准类型
         1. 数字
            1. int
            2. oct()
            3. hex()
            4. chr()
            5. ord()
            6. long
            7. boolean
            8. complex
            9. real
            10. imag
            11. conjugate()
            12. float
            13. 功能函数
            14. abs
            15. coerce
            16. divmod
            17. pow
            18. round
            19. random module
         2. string
         3. list
            1. stack
            2. append()
            3. pop()
            4. queues
            5. deque
            6. collections
            7. append()
            8. popleft()
         4. tuple
         5. dict
      2. 其他内建类型
         1. type
         2. None
         3. file
         4. set/frozen set
         5. function/method
         6. module
         7. class
      3. 内部类型
         1. 代码
         2. 帧
         3. 跟踪记录
         4. 切边
         5. 省略
         6. Xrange
      4. 标准的内建函数
         1. cmp
         2. type
         3. repr
         4. str
         5. dir
         6. id
      5. 工厂方法/函数
         1. int
         2. long
         3. float
         4. complex
         5. str
         6. unicode
         7. list
         8. tuple
         9. dict
         10. set
         11. bool
         12. set
         13. frozenset
         14. ------------------
         15. super
         16. property
         17. file
         18. object
         19. classmethod
         20. staticmethod
   3. 与序列有关的BIF
      1. sorted
      2. reversed
         1. 返回的是个反向序列迭代器
      3. enumerate
      4. zip
   4. 迭代器
      1. iter()
      2. obj.next()
      3. 支持迭代协议
         1. __iter__()
         2. next()
      4. iterable的对象
         1. list
         2. tuple
         3. generator
         4. list comprehension
         5. 支持迭代协议对象
            1. file object / like file object
      5. 特性
         1. 单向性
         2. 不可复制性
      6. 一个迭代实例只会迭代一次
         1. 单向性决定的犹如时间
         2. 如过要反复用到某个集个反复实例迭代对象
         3. 直接用序列 等类型
   5. 生成器
      1. 生成器表达式
         1. （e for e in data）
      2. yield 语句
      3. 使用场合
         1. 迭代巨大的数据集合
         2. 从A处获取数据处理后存入B处（允许A=B）
      4. 优点
         1. 动态的生成一个对象
         2. 提高内存性能
      5. 高级扩展
         1. send()
         2. close()
      6. 根据相应的逻辑动态生成
   6. 列表解析
      1. 左延伸
         1. [[y for y in range(10)] for x in range(10)]
      2. 右延伸
         1. [(x, y) for x in range(10) for y in range(10) ]
   7. 文件对象
      1. 打开
         1. open
         2. file
      2. 输入
         1. read
         2. readline
         3. readlines
            1. read them all from file to list
      3. 输出
         1. write
         2. writelines
            1. write all in list to file
      4. 文件内的移动
         1. seek
            1. 0
            2. default set
            3. 1
            4. current
            5. 2
            6. end
         2. tell
         3. text
      5. 杂项操作
         1. flush
         2. fileno
      6. 关闭
         1. close
      7. 文件属性
         1. closed
         2. encoding
         3. mode
         4. newlines
      8. 其他
         1. os
            1. linesep
            2. sep
            3. pathsep
            4. curdir
            5. pardir
         2. sys
            1. stderr
            2. stdin
            3. stdout
            4. argv
      9. 序列化
         1. pickle/cPickle
         2. json
   8. 异常
      1. 异常的类型
         1. BaseException
         2. Exception
         3. StopIteration
         4. ImportError
         5. ValueError
         6. TypeError
         7. AttributeError
         8. IndexError
         9. KeyError
         10. NameError
      2. 异常的处理
      3. with语句
         1. 应用场合
            1. 文件
            2. 线程资源
            3. 简单同步
            4. 数据库
         2. 仅对支持上下文协议
      4. 异常的抛出
         1. raise
      5. 断言
         1. assert
   9. 函数
      1. 形式参数
         1. 位置参数
         2. 默认参数
         3. 可变长参数
            1. 非关键字
            2. 关键字
      2. 函数式编程(FP)
         1. filter
         2. reduce
         3. map
         4. lambda
      3. 偏函数(PFA)
         1. from functools import partial
         2. partial
            1. functools
            2. 功能
            3. 类的部分实例化
            4. 函数部分形实结合
            5. func
            6. args....
      4. 装饰器
         1. 加入日记
         2. 加入事务处理
   10. 模块
       1. 名称空间
          1. 内建空间
             1. __builtins__
          2. 全局空间
             1. globals()检查
          3. 局部空间
             1. locals()检查
             2. 函数
             3. 类
             4. 实例
   11. OOP
       1. 类
          1. 类属性
             1. 特殊
             2. __name__
             3. __doc__
             4. __bases__
             5. __dict__
             6. __module__
             7. __class__
       2. 实例
          1. 实例属性
             1. 特殊
             2. __class__
             3. __dict__
       3. 绑定
       4. 类方法
          1. classmethod()
          2. cls
       5. 静态方法
          1. staticmethod()
       6. 组合
       7. 派生
          1. super(C, self)
          2. 从标准类派生
             1. 不可变
             2. 可变
       8. 内建函数
          1. issubclass
             1. issubclass与isinstance的第二个参数都可以是个元组
          2. isinstance
          3. -------------------
          4. hasattr
          5. getattr
          6. setattr
          7. delattr
          8. -------------------
          9. super
          10. dir
          11. vars
          12. id
       9. 用特殊方法来定制类
       10. 描述符／特性对象
           1. property
              1. fget
              2. fset
              3. fdel
              4. doc
           2. discriptor
              1. __get__
              2. self
              3. obj
              4. type(cls)
              5. __set__
              6. self
              7. obj
              8. value
              9. __delete__
              10. self
              11. obj
       11. 元类
           1. __metaclass__
       12. 类／实例属性的方法特性
           1. __getattr__
              1. 在名字字典中没有才会去执行
           2. __setattr__
              1. 小心死循环
              2. object.__setattr__
           3. __delattr__
           4. __slots__
              1. 确保你只能访问那些属性
           5. 描述符
           6. property
   12. 执行环境
       1. 可调用对象(callable)
          1. 函数
             1. 内建函数(BIF)
             2. 用户自定义函数(UDF)
             3. lambda
          2. 方法
             1. 内建方法(BIM)
             2. 用户自定义方法(UDM)
          3. 类
          4. 部分实例
             1. 定义类时实现了__call__方法
       2. 代码对象
          1. 组成
             1. 语句
             2. 赋值
             3. 表达式
             4. 其他可调用对象
          2. 函数对象仅是代码对象的包装
          3. 方法是对函数对象的包装
       3. 可执行对象(executable)
          1. 内建函数和语句
             1. callable()
             2. complile()
             3. eval()
             4. exec
       4. 执行外部程序
          1. subprocess
             1. call()
             2. Popen
             3. PIPE
   13. ORM
       1. storm
       2. django ORM
       3. SQLAlchemy
3. Python Module
   1. re
      1. regex object
         1. compile()
         2. Flag
            1. S
            2. I
            3. L
            4. M
            5. X
            6. U
      2. match object
         1. match()
         2. search()
         3. findall()
         4. finditer()
         5. ==========
         6. sub()
         7. subn()
         8. split()
         9. =========
         10. group()
         11. groups()
         12. start()
         13. end()
         14. span()
   2. os
      1. linesep
         1. 行结束标记(新行符)
      2. sep
         1. 路径中各级目录的分隔符
      3. pathsep
         1. 路径与路径的分隔符
      4. curdir
         1. 一般是"."
      5. pardir
         1. 一般是“..”
      6. getcwd()
         1. 获得当前工作目录
      7. path
         1. basename()
         2. dirname()
         3. abspath()
         4. join()
   3. sys
      1. stderr
      2. stdin
      3. stdout
      4. argv
      5. exit()
   4. datetime
   5. subprocess
      1. call
         1. ['ls', '-a', '/tmp']
            1. Win32 加上shell=True
         2. "ls -a /tmp"
            1. shell=True
         3. 返回状态码
      2. check_call
         1. 状态非0则抛出CalledProcessError
      3. Popen
         1. poll()
            1. Check if child process has terminated. Set and return returncode attribute.
         2. wait()
            1. Wait for child process to terminate. Set and return returncode attribute
         3. communicate()
            1. input=None
            2. send data to stdin.PS:stdin=PIPE
            3. returns a tuple (stdoutdata, stderrdata)
            4. read data from stdout and stderr.PS:stderr=PIPE, stdout=PIPE
         4. send_signal()
            1. signal
         5. terminate()
         6. kill()
         7. 属性
            1. stdin
            2. stdout
            3. stderr
            4. pid
            5. returncode
      4. PIPE
         1. stdin
         2. stdout
         3. stderr
      5. STDOUT
         1. stderr
      6. 异常
         1. CalledProcessError
         2. ValueError
         3. OSError
      7. 辅助的模块
         1. shlex
            1. split()
   6. cStringIO/StringIO
      1. StringIO
         1. 无初始值
         2. 有初始值
      2. getvalue
      3. close
      4. like file object
   7. unittest
   8. PIL
      1. Image
   9. BIF/M/FM
      1. unicode
         1. string
         2. encoding
         3. errors
            1. "strict"
            2. "replace"
            3. "ignore"
      2. unichr
4. FP
   1. 基本的概念
      1. 函数是第一类（对象）
      2. 将递归用作主要的控制结构
      3. “纯”函数语言能够避免副作用
      4. FP 不鼓励或根本不允许出现 语句，取而代之是使用表达式求值
      5. FP 关心的是计算什么而不是如何计算
      6. 许多 FP 利用了“更高等级”函数
   2. 柯里化(currying)
      1. lambda闭包实现
   3. lambda演算(lambda caculus)
   4. 怎样整出“纯”函数
      1. 通过闭包封装状态
   5. 一个函数被认为是捕获模式的机制
5. 经验总结
   1. 性能
      1. 正则匹配
         1. 先编译后使用
            1. 当不止使用一到两次时
         2. 切勿重复编译
            1. 放入全局空间
            2. 放入cell空间并实例出一个闭包实例
      2. 学会用生成器
   2. 句法
      1. “短路”实现分支语句时的歧义
         1. 请使用()
            1. 同时也方便看代码
      2. 不要使用from module import *除非非常适合的情况下
      3. try语句块中不要return
      4. None与空值对象'', [], set(), {}, ()差异
         1. None是NoneType无类型即除了对象的特殊方法无任何方法
         2. 空值对象有类型且具有相应下的方法和属性
   3. FP相关
      1. 如何处理FP或列表解析过长
         1. 分行处理
            1. 字典：每个键值对一行
      2. 如何处理FP中过多使用lambda实现常规运算
         1. 使用operator模块
      3. 如何处理一复杂表达式在一句中多次不引用
         1. (lambda x, y: do_something_expression with x, y)(make_x_expression, make_y_expression)
            1. 结果就是lambda执行后的结果
            2. make_x/y_expression都是较复杂的表达式
   4. 风格
6. 问题归纳
   1. 不可变性
      1. 元组的不可变性的理解
         1. 破坏不可变性
         2. 元素的增加和减少
         3. 元素次序的改变
         4. 直接引用的改变
      2. 自由变量不可变性
         1. 可能是描述器实现
         2. 描述器设置为只读
         3. 类似于名字不可变
   2. 闭包
      1. 对象是附带过程的数据，闭包是附带数据的过程。
      2. 闭包是由函数和与其相关的引用环境组合而成的实体
      3. 闭包类似于类的实例
      4. 类和实例---闭包源和闭包
      5. 闭包是函数
      6. 闭包封装的状态可以是个函数
      7. 条件
         1. 函数是first class
         2. 函数可以嵌套定义
         3. 可捕获引用环境
      8. 应用
         1. 模拟面向对象
         2. GUI回调函数
         3. 事件驱动编程
         4. 获取数据库行和处理数据
      9. func_closure
         1. 追踪自由变量
      10. python中自由变量的不可变性
          1. 可能描述器实现
   3. 可调用实例
      1. 实现__call__
      2. 与不可变实例的比较
         1. “人工”的调用方法
         2. 有__call__统一“自动”调用
            1. 类似于框架模式中的框架类
   4. 序列、迭代与生成器
      1. 序列
         1. 人工取货的仓库
         2. 处理生存这样的序列
            1. 来至内存模型
            2. 文件系统
            3. 数据库
            4. 网络
         3. 内存存在着这样的序列(list, tuple, str)
         4. 下标的方式随机访问
         5. 可变对象(list)的修改
      2. 迭代器
         1. 自动化的仓库
         2. 通过iter序列或其他方式实例化出可迭代对象
         3. 单向的次序访问
         4. 只可访问
      3. 生成器
         1. 无仓库
         2. 动态的生成对象
            1. 来至内存模型
            2. 文件系统
            3. 数据库
            4. 网络
         3. 单向的访问一次性使用
      4. 对迭代器和生成器使用in操作，会迭代查找
         1. 要查找的元素不在其中，将会迭代完全部元素（无限迭代）
         2. 要查找的元素在其中，则迭代到对应的第一个元素
   5. PFA与currying
      1. currying通过闭包实现的
         1. 使用funcwant = fucname(arg1)(arg2,arg3)()
         2. 一层调用用掉全部参数（默认值参数可当已有值）
      2. PFA是用parital(不知如何实现)
         1. 更泛化
         2. 部分的实例化
         3. 部分的形实结合
   6. 一般函数与lambda
      1. 一般函数
         1. 函数是对一个代码对象的包装
         2. 函数是把代码块包装成可调用对象
         3. 自身是个函数定义语句
         4. 返回值
            1. return 语句指定
            2. 默认是None
         5. 定义/包装过程
            1. 通过def func():语句
            2. 在堆中生成一个函数对象
            3. 将引用给名字func
      2. lambda
         1. lambda是对表达式的包装
         2. lambda是把表达式包装成可调用对象
         3. 自身是个表达式
         4. “返回”值
            1. 就是执行了表达式后的结果
            2. 默认是表达式结果
            3. 没有也不可能有return这玩意
         5. 定义/装过程
            1. lambda关键字
            2. 在堆中生成一个lambda可调用对象
            3. 无名字（当然可人工指定）
7. 学习难度
   1. 简单易学
   2. 易学难精
8. 为什么使用
   1. 软件质量
   2. 开发者效率
   3. 程序的可移植性
   4. 标准库的支持
   5. 组建集成
   6. happy
9. 能做什么
   1. 网络
      1. twisted
         1. framework
      2. web
         1. zope/plone
            1. framework
         2. django
         3. web.py
         4. 其它
      3. smtp
      4. ftp
      5. RPC
         1. XML-RPC
         2. REST
         3. SOAP
   2. 游戏
   3. 快速原型
   4. 系统编程
   5. 科学计算
   6. 人工智能
   7. GUI
   8. 数据库编程
   9. 其它
10. 谁在使用
    1. Google
    2. YouTube
    3. NASA、JPL
       1. zope
    4. IronPort
    5. IRobot
    6. Pxiar
11. 优点
    1. 简洁
    2. 一致性
    3. 易学、易读
       1. 便于维护
    4. 广泛强大的库支持
       1. unitTest
          1. TDD佳品
       2. ……
       3. pygame