前言：
python编写非常简洁
第一行注释是为了告诉Linux/OS X系统，这是一个Python可执行程序，Windows系统会忽略这个注释；
CPython用>>>作为提示符，而IPython用In [序号]:作为提示符。
print()函数也可以接受多个字符串，用逗号“,”隔开，就可以连成一串输出 输入：
/除法计算结果是浮点数，即使是两个整数恰好整除，结果也是浮点数，
还有一种除法是//，称为地板除，两个整数的除法仍然是整数
转义字符\可以转义很多字符，比如\n表示换行，\t表示制表符，字符\本身也要转义，所以\\表示的字符就是\，
统一成Unicode编码，乱码问题从此消失了，本着节约的精神，又出现了把Unicode编码转化为“可变长编码”的UTF-8编码。UTF-8编码把一个Unicode字符根据不同的数字大小编码成1-6个字节，常用的英文字母被编码成1个字节，汉字通常是3个字节，只有很生僻的字符才会被编码成4-6个字节。如果你要传输的文本包含大量英文字符，用UTF-8编码就能节省空间
字符 | ASCII | Unicode | UTF-8 |
A | 01000001 | 00000000 01000001 | 01000001 |
中 | x | 01001110 00101101 | 11100100 10111000 10101101 |
由于Python的字符串类型是str，在内存中以Unicode表示，一个字符对应若干个字节。如果要在网络上传输，或者保存到磁盘上，就需要把str变为以字节为单位的bytes。浮点数也就是小数
用\n写在一行里不好阅读，为了简化，Python允许用'''...'''的格式表示多行内容
因为tuple不可变，所以代码更安全。如果可能，能用tuple代替list就尽量用tuple。
Python提供一个range()函数，可以生成一个整数序列，再通过list()函数可以转换为list。比如range(5)生成的序列是从0开始小于5的整数
列表 list=['a','b','e'] 用len()函数可以获得list元素的个数
元祖 class=('a','b','e') 不能更改
input()返回的数据类型是str，str不能直接和整数比较，必须先把str转换成整数。Python提供了int()函数来完成这件事情
要特别注意，不要滥用break和continue语句。break和continue会造成代码执行逻辑分叉过多，容易出错。大多数循环并不需要用到break和continue语句，上面的两个例子，都可以通过改写循环条件或者修改循环逻辑，去掉break和continue语句。
list或tuple的部分元素是非常常见的操作 切片
给定一个list或tuple，我们可以通过for循环来遍历这个list或tuple，这种遍历我们称为迭代（Iteration）
我们创建了一个generator后，基本上永远不会调用next()，而是通过for循环来迭代它
生成器：generator
print [x * (x + 1) for x in range(1, 100, 2)][x * x for x in range(1, 11) if x % 2 == 0] 条件过滤>>> [m + n for m in 'ABC' for n in '123']
['A1', 'A2', 'A3', 'B1', 'B2', 'B3', 'C1', 'C2', 'C3']
凡是可作用于for循环的对象都是Iterable类型；
凡是可作用于next()函数的对象都是Iterator类型，它们表示一个惰性计算的序列；
集合数据类型如list、dict、str等是Iterable但不是Iterator，不过可以通过iter()函数获得一个Iterator对象。
Python的for循环本质上就是通过不断调用next()函数实现的
和list比较，dict有以下几个特点：
- 查找和插入的速度极快，不会随着key的增加而变慢；
- 需要占用大量的内存，内存浪费多。
所以，dict是用空间来换取时间的一种方法。
函数分为内置函数和自定义的函数（函数使用的原则：先定义，再调用）
默认参数可以简化函数的调用。设置默认参数时，有几点要注意：
一是必选参数在前，默认参数在后，否则Python的解释器会报错（思考一下为什么默认参数不能放在必选参数前面）；
二是如何设置默认参数。
我们可以把年龄和城市设为默认参数：
def enroll(name, gender, age=6, city='Chongqing'):
print('name:', name)
print('gender:', gender)
print('age:', age)
print('city:', city)
这样，大多数学生注册时不需要提供年龄和城市，只提供必须的两个参数：
Python函数在定义的时候，默认参数L的值就被计算出来了，即[]，因为默认参数L也是一个变量，它指向对象[]，每次调用该函数，如果改变了L的内容，则下次调用时，默认参数的内容就变了，不再是函数定义时的[]了。
定义默认参数要牢记一点：默认参数必须指向不变对象！
要修改上面的例子，我们可以用None这个不变对象来实现：
def add_end(L=None):
if L is None:
L = []
L.append('END')
return L现在，无论调用多少次，都不会有问题：
生成list [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]可以用list(range(1, 11))
[x * x for x in range(1, 11)]在Python中，这种一边循环一边计算的机制，称为生成器：generator。
g = (x * x for x in range(10))
一个最简单的高阶函数：
def add(x, y, f):
return f(x) + f(y)
print(add(-5, 6, abs))把函数作为参数传入，这样的函数称为高阶函数，函数式编程就是指这种高度抽象的编程范式。
Python内建了map()和reduce()函数。
>>> def f(x):
... return x * x
...
>>> r = map(f, [1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> list(r)
[1, 4, 9, 16, 25, 36, 49, 64, 81]
>>> list(map(str, [1, 2, 3, 4, 5, 6, 7, 8, 9]))
['1', '2', '3', '4', '5', '6', '7', '8', '9']Python内建的filter()函数用于过滤序列。
>>> sorted([36, 5, -12, 9, -21], key=abs)
[5, 9, -12, -21, 36]
>>> sorted(['bob', 'about', 'Zoo', 'Credit'], key=str.lower)
['about', 'bob', 'Credit', 'Zoo']
>>> sorted(['bob', 'about', 'Zoo', 'Credit'], key=str.lower, reverse=True)
['Zoo', 'Credit', 'bob', 'about']
>>> list(map(lambda x: x * x, [1, 2, 3, 4, 5, 6, 7, 8, 9]))
[1, 4, 9, 16, 25, 36, 49, 64, 81]函数对象有一个__name__属性，可以拿到函数的名字：
在函数调用前后自动打印日志，但又不希望修改now()函数的定义，这种在代码运行期间动态增加功能的方式，称之为“装饰器”（Decorator）。
>>> int('12345', base=8)
5349
>>> int('12345', 16)
74565
现在，假设我们的abc和xyz这两个模块名字与其他模块冲突了，于是我们可以通过包来组织模块，避免冲突。方法是选择一个顶层包名，比如mycompany，按照如下目录存放：
mycompany
├─ __init__.py
├─ abc.py
└─ xyz.py引入了包以后，只要顶层的包名不与别人冲突，那所有模块都不会与别人冲突。现在，abc.py模块的名字就变成了mycompany.abc，类似的，xyz.py的模块名变成了mycompany.xyz。
请注意，每一个包目录下面都会有一个__init__.py的文件，这个文件是必须存在的，否则，Python就把这个目录当成普通目录，而不是一个包。__init__.py可以是空文件，也可以有Python代码，因为__init__.py本身就是一个模块，而它的模块名就是mycompany。
创建自己的模块时，要注意：
- 模块名要遵循Python变量命名规范，不要使用中文、特殊字符；
- 模块名不要和系统模块名冲突，最好先查看系统是否已存在该模块，检查方法是在Python交互环境执行
import abc，若成功则说明系统存在此模块。
面向对象
一个例子来说明面向过程和面向对象在程序流程上的不同之处。
假设我们要处理学生的成绩表，为了表示一个学生的成绩，面向过程的程序可以用一个dict表示：
std1 = { 'name': 'Michael', 'score': 98 }
std2 = { 'name': 'Bob', 'score': 81 }而处理学生成绩可以通过函数实现，比如打印学生的成绩：
def print_score(std):
print('%s: %s' % (std['name'], std['score']))如果采用面向对象的程序设计思想，我们首选思考的不是程序的执行流程，而是Student这种数据类型应该被视为一个对象，这个对象拥有name和score这两个属性（Property）。如果要打印一个学生的成绩，首先必须创建出这个学生对应的对象，然后，给对象发一个print_score消息，让对象自己把自己的数据打印出来。
class Student(object):
def __init__(self, name, score):
self.name = name
self.score = score
def print_score(self):
print('%s: %s' % (self.name, self.score))给对象发消息实际上就是调用对象对应的关联函数，我们称之为对象的方法（Method）。面向对象的程序写出来就像这样：
bart = Student('Bart Simpson', 59)
lisa = Student('Lisa Simpson', 87)
bart.print_score()
lisa.print_score()所以，面向对象的设计思想是抽象出Class，根据Class创建Instance。
注意：特殊方法“__init__”前后分别有两个下划线！！！
我们来判断对象类型，使用type()函数：基本类型都可以用type()判断：
为了限制score的范围，可以通过一个set_score()方法来设置成绩，再通过一个get_score()来获取成绩，这样，在set_score()方法里，就可以检查参数：
错误处理:
try:
print('try...')
r = 10 / int('2')
print('result:', r)
except ValueError as e:
print('ValueError:', e)
except ZeroDivisionError as e:
print('ZeroDivisionError:', e)
else:
print('no error!')
finally:
print('finally...')
print('END')
SQLite是一种嵌入式数据库，它的数据库就是一个文件。由于SQLite本身是C写的，而且体积很小，所以，经常被集成到各种应用程序中，甚至在iOS和Android的App中都可以集成。
在处理一些不规范的第三方网页的时候。虽然Python提供了Unicode表示的str和bytes两种数据类型，并且可以通过encode()和decode()方法转换，但是，在不知道编码的情况下，对bytes做decode()不好做。
使用chardet检测编码非常容易，chardet支持检测中文、日文、韩文等多种语言。
virtualenv为应用提供了隔离的Python运行环境，解决了不同应用间多版本的冲突问题。
什么是闭包？
def foo():
m=3
n=5
def bar():
a=4
return m+n+a #引用外部变量
return bar
>>>bar = foo() #外部调用
>>>bar() #接着内部调用
12
---------------------------------------
说明：
bar在foo函数的代码块中定义。我们称bar是foo的内部函数。
在bar的局部作用域中可以直接访问foo局部作用域中定义的m、n变量。
简单的说，这种内部函数可以使用外部函数变量的行为，就叫闭包。装饰器
装饰器就是闭包函数的一种应用场景
1、为何要用装饰器
开放封闭原则：对修改封闭，对扩展开放
2、什么是装饰器
就是装饰其他函数。
强调装饰器的原则：
- 不修改被装饰对象的源代码
- 不修改被装饰对象的调用方式
装饰器的目标：在遵循1和2的前提下，为被装饰对象添加上新功能
4、装饰器语法
#被装饰函数的正上方，单独一行，就是先运行装饰器的，再运行自己的
@deco1
@deco2
@deco3
def foo():
pass
foo=deco1(deco2(deco3(foo)))
