XMind

feeling-python

1. 简介

   1. 发音:[ 'paiθ(ə)n; (US) 'paiθɔn ]

   2. 解释型

   3. 交互性

   4. 动态类型

   5. 强类型

   6. 面向对象

      1. 便于复用、设计

   7. 学习难度

      1. 简单易学

      2. 易学难精

   8. 为什么使用

      1. 软件质量

         Python 注重可读性、一致性、软件质量，毕竟写程序是为了以后修改的，当你写下代码时你就应该想到几个月后就有人来修改，也许那个人就是你。

      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

2. python基础

   1. 万物皆对象@python

      1. 程序有模块构成

      2. 模块有语句组成

      3. 语句有表达式构成

      4. 表达式是用来创建处理对象的

   2. python 对象

      1. 标准类型

         1. 数字

            1. int

               1. oct()

               2. hex()

               3. chr()

               4. ord()

            2. long

            3. boolean

            4. complex

               1. real

               2. imag

               3. conjugate()

            5. float

            6. 功能函数

               1. abs

               2. coerce

               3. divmod

               4. pow

               5. round

            7. random module

         2. string

         3. list

            1. stack

               1. append()

               2. pop()

            2. queues

               1. deque

                  1. append()

                  2. popleft()

                  1. collections

         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. 高级扩展

         def counter(start_at=0):
         
         count = start_at
         
         while True:
         
         val = (yield count)
         
         if val is not None:
         
         count = val
         
         else:
         
         count += 1
         
         
         
         >>> count = counter(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

               1. default set

            2. 1

               1. current

            3. 2

               1. 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. 异常的类型

         异常名称 描述
         
         BaseExceptiona 所有异常的基类
         
         SystemExitb python 解释器请求退出
         
         KeyboardInterruptc 用户中断执行(通常是输入^C)
         
         Exceptiond 常规错误的基类
         
         StopIteratione 迭代器没有更多的值
         
         GeneratorExita 生成器(generator)发生异常来通知退出
         
         SystemExith Python 解释器请求退出
         
         StandardErrorg 所有的内建标准异常的基类
         
         ArithmeticErrord 所有数值计算错误的基类...

         1. BaseException

         2. Exception

         3. StopIteration

         4. ImportError

         5. ValueError

         6. TypeError

         7. AttributeError

         8. IndexError

         9. KeyError

         10. NameError

      2. 异常的处理

         try:
         
         try_suite
         
         except Exception1:
         
         suite_for_Exception1
         
         except (Exception2, Exception3,Exception4):
         
         suite_for_Exceptions_2_3_and_4
         
         except Exception5, Argument5:
         
         suite_for_Exception5_plus_argument
         
         except (Exception6, Exception7), Argument67:
         
         suite_for_Exceptions6_and_7_plus_argument...

      3. with语句

         with open('/etc/passwd', 'r') as f:
         
         for eachLine in f:
         
         # ...do stuff with eachLine or f...

         1. 应用场合

            1. 文件

            2. 线程资源

            3. 简单同步

            4. 数据库

         2. 仅对支持上下文协议

      4. 异常的抛出

         1. raise

            raise [exclass[,args]]

      5. 断言

         1. assert

            assert expression[,args]

   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. 功能

               1. 类的部分实例化

               2. 函数部分形实结合

            2. func

            3. args....

            1. functools

      4. 装饰器

         无参装饰器
         
         def deco(func):
         
         def wrapper():
         
         do_some_before
         
         func()
         
         do_some_after
         
         return wrapper
         
         @deco
         
         def foo():
         
         do_something...

         1. 加入日记

         2. 加入事务处理

   10. 模块

       1. 名称空间

          1. 内建空间

             1. __builtins__

          2. 全局空间

             1. globals()检查

          3. 局部空间

             1. locals()检查

             2. 函数

             3. 类

             4. 实例

   11. OOP

       1. 类

          1. 类属性

             1. 特殊

                1. __name__

                2. __doc__

                3. __bases__

                4. __dict__

                5. __module__

                6. __class__

       2. 实例

          1. 实例属性

             1. 特殊

                1. __class__

                2. __dict__

       3. 绑定

       4. 类方法

          1. classmethod()

          2. cls

       5. 静态方法

          1. staticmethod()

       6. 组合

       7. 派生

          1. super(C, self)

          2. 从标准类派生

             1. 不可变

                class RoundFloat(float):
                
                def __new__(cls, val):
                
                return super(RoundFloat, cls).__new__(cls, round(val, 2))

             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__

                 1. self

                 2. obj

                 3. type(cls)

              2. __set__

                 1. self

                 2. obj

                 3. value

              3. __delete__

                 1. self

                 2. 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

               1. send data to stdin.PS:stdin=PIPE

            2. returns a tuple (stdoutdata, stderrdata)

               1. 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. 直接引用的改变

         1. 破坏不可变性

      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. 处理生存这样的序列

            1. 来至内存模型

            2. 文件系统

            3. 数据库

            4. 网络

         2. 内存存在着这样的序列(list, tuple, str)

         3. 下标的方式随机访问

         4. 可变对象(list)的修改

         1. 人工取货的仓库

      2. 迭代器

         1. 通过iter序列或其他方式实例化出可迭代对象

         2. 单向的次序访问

         3. 只可访问

         1. 自动化的仓库

      3. 生成器

         1. 动态的生成对象

            1. 来至内存模型

            2. 文件系统

            3. 数据库

            4. 网络

         2. 单向的访问一次性使用

         1. 无仓库

      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. cloudcry@gmail.com 记录Py 学习体验

   2. 版本:

      1. 110117 ZQ转换成XMind

   3. 作者:Zoom.Quiet

   4. 工具:xMind 3.2.1