第一章
Python要素
1 数据类型
int str tuple list dict class。
字符串用单引号或双引号封装。Strl类型与int类型都是固定类型
方括号存取法适用于任何序列类型包括字符串，str可以通过[]取字符但不能设置新的字符。Python的索引位置总是从0开始。
类型转换datetype(item)。 如int(‘123’),头尾处可以带空格。 str(456)，str几乎支持所有的转化。
type()函数返回数据项的类型
所有python对象都知道自身的数据类型，不需要明确指明数据类型。
#后面的为注释。
2 对象引用
在python中“=”是将对象引用与内存中的某对象进行绑定。
标识符由字母下划线和数字组成，没有长度限制。字母指的是unicode编码定义的字符。
Pythin使用动态类型机制，每个对象引用都可以重新引用不同类型的对象
3 组合数据类型
元组是固定的列表是可变的。
如果某个元组只有一个数据项有需要使用圆括号，则必须使用逗号。如(1，)
元组与列表并不真正存放数据而是存放数据对象的引用
len(item )返回某个对象的长度.
list类型的对象有一个append()方法添加单个数据项，extend()添加一个列表。 insert(),remove()方法在给定索引(从0开始)处插入删除数据项
a.append('item')和list.append(a,'item')等效。
4 逻辑操作符
is询问对象引用是否指向相同的对象而不仅是值相同。 a is b返回True或False
a is None, is not None 判断是否是空对象
>,<,==,!=,>=,<=,对对象的值进行比较。0<=2<=10会返回True, 不需要&&操作符
‘3’<4 会出错，应该进行类型转换
对于序列或集合类型，in 用来测试成员关系
逻辑运算符and, or,返回决定结果的操作数，而不是布尔值，除非表达式本身出现在布尔上下文中，如if语句中。 not 总是返回布尔值True或者False
5 流程控制
.py文件中每条语句都是顺序执行的，从第一条语句开始。函数，方法条用或者控制结构都可以使控制流转向。
预定义为False的布尔表达式，特殊对象None,空序列或集合(如空字符串,元组，列表),值为0的数据项，布尔结果都为False
python提供了关键字pass，实际上就是一条空语句
顺序，分支If/else，循环for/while
if 表达式1:
表达式为真需要执行的语句段
elif 表达式2:
表达式1为假，表达式2为真执行的语句段
else:
全部为假
注: elif和else都可省略，elif可有多个，作用等同于C/C++中的switch
思考题:如何解决多个cases的判断问题，一个解决方案是使用for 循环。
while进行循环控制，它对表达式进行测试，如果为真，则循环执行循环体。
while EXPRESSION:
STATEMENT
else:
STATEMENT
如果测试为假，则会执行else块。如果循环被中断(break)，则else块不会执行。
使用import random 和random.randint(1,100)可获得1-100的随机数
在程序首行加入#encoding=utf-8可使用汉字（gbk,gb2312也可)
for循环可遍历对象，并可进行迭代操作。
for TARGET in OBJECTS：
STATEMENT
else:
STATEMENT
在循环正常退出时，会执行else块。
循环索引的方式
以元素进行索引
s=’hello world‘
for a in s:
print a
以下标进行索引
s=‘hello world’
for i in range(len(s)):
print s[i],i
同时使用下标和元素
for i,a in enumerate(s):
print i,a,
print
break ：break语句会立即退出当前循环，不会执行else块的内容。
continue语句会忽略后面的语句，强制进入下一次循环。
pass不做任何事情
6 异常处理
7 算术操作符
int类型是固定的，一旦赋值不能修改，a=a+8实际上创建一个新对象存储结果然后重新绑定
a operator=b与a=a operator b实际上不一样，前者只查询一次a的值
python重载了+与+=，分别用于字符串和列表。+表示连接，+=表示追加字符串或扩展列表
8 输入输出
9 函数的创建于调用
def functionname(arg)
编码风格
以“#”号开头的内容为注释，python解释器会忽略该行内容。
在Python中是以缩进(indent)来区分程序功能块的，缩进的长度不受限制，但就一个功能块来讲，最好保持一致的缩进量。
可以使用空格、Tab键等，但是最好保持一致
如果一行中有多条语句，语句间要以分号（;）分隔。
在Python中，每行程序以换行符代表结束，如果一行程序太长的话，可以用“\”符号扩展到下一行。
在python中以三引号(“”“)括起来的字符串
列表，元组和字典都能跨行使用。并且以小括号(...)、中括号[...]和大括号{...}包围的代码不用加“\”符也可扩展到多行。
标示符
python中的标识符是区分大小写的。
标示符以字母或下划线开头，可包括字母，下划线和数字。
以下划线开头的标识符是有特殊意义的。
以单下划线开头（_foo）的代表不能直接访问的类属性，需通过类提供的接口进行访问，不能用“from xxx import *”而导入；
以双下划线开头的（__foo）代表类的私有成员；
以双下划线开头和结尾的（__foo__）代表python里特殊方法专用的标识，如__init__（）代表类的构造函数。
在交互模式下运行python时，一个下划线字符(_)是特殊标识符，它保留了表达式的最后一个计算结果。
关键字
共31个(版本不同变化)
逻辑运算—3个
and/or/not
流程控制—12个
if/elif/while/for/else
break/continue/pass
return/yield
with/as
异常处理—5个
try/except/finally
raise/assert
定义等—6个
class
global
def/lambda
import/from
判断—2个
is
in
其他—3个
del/print
exec
help()
help>关键字
运算符1/2
第二章数据类型
dir()函数返回对象属性列表，不带参数时返回内置属性列表
整数大小只受机器内存限制
对象的创建可以直接给变量赋字面意义的值，或者将数据类型作为函数进行调用。
使用对象类型创建对象时有3中用例：
1.不用参数，对象会被赋默认值。 x=int()h会创建一个值为0的整数。
2.使用一个参数调用数据类型。如果给定的参数是同样的数据类型，就创建一个新对象，新对象是原始对象的一个浅拷贝。如果不是同样的类型就尝试进行转换转换失败会产生ValueError或TypeError异常。
3.给定两个或者多个参数。
第三章 组合类型
python列表和元组中存放的仅仅是对象引用，通过list(tuple)创建列表，列表中存放的仅仅对象的浅拷贝。
元组是固定的是指它存放的对象引用是固定的，但引用本身的内容并不是固定的。类似于C++中的指针。
1. 元组tuple
元组支持字符串一样的分片与步距。tuple()作为函数调用可以无参数或者有一个参数。可以将函数参数一元组形式传递。function((1,2,3)).
元组只提供了两种方法:t.count(x)返回x出现的次数, t.index(x)返回x第一次出现的位置，不存在时产生ValueError异常。
元组可以使用+连接，*复制，[]分片，也可以只用in/not in测试成员关系。使用+=和*=赋值时实际上创建了新元组。
比较操作符进行逐项比较递归处理，>,<,==....
当元组出现在操作符左边或unary语句右边时不需要使用圆括号。a,b=(1,2),return x,x**2,for x,y in ((1,1),(2,3)),
赋值操作右边是序列左边是元组的情况下称右边被拆分，序列拆分可用于交换值:a,b=(b,a)。
2. 命名的元组:collectins.namedtuple
collectins.namedtuple()返回一个自定义的类用于创建命名元组
Sale=collectins.namedtuple('Sale','pid cid date price').
sales=[];
sales.append(Sale(432,921,'2014-02-24',7.9)); sales.append(Sale(514,852,'2014-02-24',10.0));
命名元组有几个私有方法，其中一个namedtuple._asdict()，返回键值对的映射。键是元组元素的名称，值是对应的值。可以使用映射拆分**dict将映射转换为str.format()的键值参数。
3. 列表list
列表和元组一样，是包含对象引用的有序序列。但是可以对列表中的项或者分片进行插入，替换，删除。
对于列表可以用内置的len(li)获得列表长度,del语句删除项。
列表方法:l.append(x),l.extend(li)/l+=li,l.index(x,start,end)不存在产生ValueError异常，l.insert(i,x),l,pop()返回并移除最右边的项,l.pop(i)。
l.remove(x)移除最左边的项，l.reverse()对列表进行翻转。l.sort()对列表进行排序，接受可选的key和reverse参数，内置的sorted(li)不改变列表本身的顺序返回排好序的副本。
任意可迭代的数据类型都可以使用序列拆分符*进行操作。用于=左边的两个或多个变量时，其中的一个使用*引导，则剩下的数据项将赋值给该变量。
first,*rest=[1,2,3,4] first=1,rest=[2,3,4].
不管右边是什么类型，rest总是列表类型的。
*dir,executable='/usr/local/bin/vim'.split('/') dir=['','usr','local','bin'],exectuable='vim'
del语句可以删除数据项，也可以取消对象引用到数据项的绑定并删除对象引用。对象引用被删除后如果引用的数据项没有被其他对象引用所引用那么该数据项将进入垃圾收集流程。
内置的range()函数返回一个迭代子，给定一个整数n，range()函数将生成并返回0,1,...n-1.
words[2:2]=['pine'] 与words.insert(2,'pine')等效。
可以对列表的单个数据项或者分片进行替换。words[2]='me' words[1:3]=[iterabe].分片与iterable的长度并不一定要等长，因此列表的长度可能变短也可能变长。
del words[2:4]与words[2:4]=[]等效。
使用步距:x[1::2]=[0]*len(x[1::2])可以将x的奇数位上的项置为0.
可以使用内置的reversed()与sorted()函数,效果与list.reverse()和list.sort()函数一样。后者可以接受与sorted()函数一样的可选参数。如words.sort(key=str.lower),key用于指定一个函数作用于每一项。
列表内涵
[expressin for item in iterable if condiction]
括号中的解析语法可以用啦创建生成器： g=(item for item in iterable );next(g),next(g)
列表，集合，字典都可以用解析来创建
集合类型set
集合类型支持成员关系操作符in，len(),也是iterable的,并至少提供一个set.isdisjoint()方法，支持比较，也支持逻辑操作符(用于集合的联合，交叉)。
python提供了两中集合类型，可变的set,固定的frozenset,进行迭代时数据项的顺序不定。
只有可哈希对象才可以添加到集合中，可哈希对象包含一个__hash__()方法，其返回值在整个生命周期内是相同的，并可以使用__eq__()特殊方法进行相等性比较。
所有的内置固定类型都是可哈希的(如int,str,float,tuple,frozenset),内置的可变数据类型(如dict,list,set)都是不可哈希的，其哈希值会随着数据项数的变化而变化。
集合类型可使用标准的比较操作符进行逐项，递归比较。除==,!=外，其他的比较符进行子集或超集比较。
因集合是无序的所以没有索引位置的概念，不能分片。
空集合必须使用set()函数创建，包含一个或多个数据项的集合可使用逗号分隔的序列(包含在圆括号中)创建。
set('apple'),set('aple'),{'e','p','l','e'}产生的集合是一样的
集合内涵
{expressin for item in iterable if condiction}
固定集合frozenset
由于固定集合不可变，所以其支持的方法与操作符所产生的结果不能影响固定集合本省。
如果将二元操作符作用于集合与固定集合，那么所产生的结果类型与左边的操作数一致。
由于固定集合是固定不变的，满足集合项的可哈希运算标准，因而集合和固定集合都可以包含固定集合。
映射类型
python3.0有两种无序的映射类型:内置的dict与标准库中的collections.defaultdict,
python3.1中引入了一种新的dict类型:collextions.OrderedDict类型，其与dict类型有相同的属性的方法，也即相同的API。其在存储数据项时以插入顺序存储。
只有可哈希对象才能作为字典的键，因此固定的数据类型(如float,int,str,tuple,frozenset),可变的类型(如dict,list,set)不能作为键。
每个键关联的值实际是对象引用，因此可以是任意类型，如数字，字符串，列表，集合，字典，函数等。
由于字典是无序的，索引位置对字典无意义，因而不能进行分片。
字典可用空的花括号创建{}，dict([dict]),也可使用关键字参数创建，还可使用序列创建，但序列中的每一项必须包含两个对象。
d[x]=59;使用d[x]或del d[x]时如果不存在会产生KeyError异常，字典支持len()函数和in/not in成员关系测试。
当向字典中添加一个键值对时，如果键已经存在，则会用新值覆盖原来的值。
可以根据项，键，值对字典进行迭代。
for item in d.items(): print(item[0],item[1])
for key, value in d.items:print(key,value)
for value in d.values():print(value)
for key in d:print(key)/d[key]+=1
for key in d.keys():print(key)
d.keys(),d.values(),d.items()返回字典视图，可将视图简单看做iterables,但是如果视图引用的字典发生变化，视图将反映该变化;
此外，键视图v与set或字典视图x支持的操作包括:v&x v|x v-x v^x
sorted(d)返回的是d的键经过排序后的列表。
使用映射拆分符**可以将字典的键值对转换为str.format()的键值参数。
greens=dict(green='#00800',love='#808000'),print('{green}{love}'.format(**greens)).
**与.format(green=greens.green,love=greens.love)效果完全一致。
字典内涵
{keyExpression:valueExpression for key, value in iterable if condition}
file_sizes={name:os.path.getsize() for name in os.listdir('.') if os.path.isfile(name)}
默认字典
默认字典的不同之处在于它可以对遗失的键进行处理。对于字典x=d[m]当键m不存在时会产生KeyError异常，单的、但对于默认字典则会创建一个新项，值为默认值，并返回默认值。
函数名实际上是对函数的对象引用，因此在需要将函数作为参数进行传递时我们只传递函数名，使用圆括号是python会调用函数。
words=collections.defaultdict(int). words[word]+=1,不会产生异常，不存在时调用int()将其赋值为0.
有序字典
collections.OrderedDict,以数据项的插入顺序进行存储，当接收无需字典，关键字参数或使用update()方法时，数据项的顺序是任意的。
在创建有序字典时以二元组列表形式传递参数，则参数的顺序得意保留。collections.OrderedDict([(k,v),(k1,v1),(k2,v2)])
list(d.keys()),返回键的掺入顺序，当插入并覆盖原有值时，键的顺序不会改变 。
popitem()删除并返回最后一个键值数据项，popitem(last=False),删除并返回第一个键值数据项。
一个稍专业的用途是生成排序字典:d=collections.OrderedDict(sorted(d.items())).但如果之后要插入额外的键则插在末尾，为保持排序必须重新创建该字典。
通常只有在期望对字典进行多次迭代并且一旦创建后不需要进行任何插入操作时，生成有序字典才是有意义的。
组合类型的迭代与复制
任意包含__iter__()方法的对象或任意序列都是一个iterable，并可以提供一个迭代子。
迭代子是一个对象，该对象可以提供一个__next()方法，该方法每依次返回相继的数据项，并在没有数据项时产生StopIteration异常。
可用于iterables的操作符与函数:
s+t,s*n,x in i,all(i)每一项为True返回True,any(i)任意一项为True返回True.
enumerate(i,start)通常用于for...in...循环中，并提供一个(index,item)序列,索引起始值为0或start.
len(x)返回长度，x为字符串时返回字符数。max(i,keyFun)/min(i,keyFun)返回最大/最小项，如果提供keyFun函数就返回keyFun(item)值得最大/最小项。
range(start,stop,step)返回start到stop-1的迭代子。
reversed(i)以反序返回迭代子i中的项。sorted(i,key,reverse),以排序后的顺序返回i中的项，key用于排序，reverse为True时则返回逆序。
sum(i,start)返回i中项的和，start默认为0，i中可以包含字符串。zip(i1,i2,...,in).返回元组的迭代子。i1中存放的是每个元组的第一项，in存放每个元组的第n项,只要有一个iterable中的元素用完就终止。
内置的iter(i)返回一个迭代子，并可以提供一个函数，该函数在每次迭代时都会调用.
获取迭代子下一项的方法是使用内置的next(i)函数，并在没有数据项时产生StopIteration异常。
product=1
i=iter([2,4,6,8]) for i in [2,4,6,8]
while true: product*=i;
try:
product*=next(i)
except StopIteration:
break
print(product)
range()函数最常用于两个目的，创建列表或元组，提供for...in...循环中的计数。
for x in range(len(i)) 等价于 x=0,while(i<len(i))
使用*操作符可以对iterable或range()函数返回的迭代子进行拆分。如函数f(1,2,3,4)需要4个参数，则可以用t=(1,2,3,4),f(*t)或者f(*range(1,5)).
random.choice(i)从i中随机选择一项，random.sample(i,limit),从i中随机返回至多limit项。
与其他任何对象一样，python中的函数也是对象，可以作为参数进行传递，也可以在组合类型中存放，函数名只是对函数的对象引用，只有在函数名后面跟括号时才会被视为函数调用。
python的排序算法是一种自适应的稳定的混合排序算法。在对整数，字符串，其他组合类型排序时使用的是其小于操作符'<'，可以进行任意深度的递归。
组合类型复制
由于python使用了对象引用，因此在使用赋值操作符=时并没有进行复制操作，只是将左边的操作数设置为一个对象引用，并且与右边的操作数指向相同的对象。
这种机制以为着我们可以将列表或者其他可变的组合类型作为函数参数传递并在函数中对数据进行修改，在函数调用完成后可以对修改后的组合类型进行存取。
对于序列，在提取分片(如s[:2])时,数据片总是取自某个数据项的一个单独副本，但仍然是浅拷贝。如果需要整个序列的副本，可以这样用c=s[:]
对于字典与集合而言这种复制可以通过dict.copy(),set.copy()实现，此外copy模块提供了copy.copy()方法返回给定对象的一个副本。
对内置组合类型复制的另外一种方法是是哦用类型名作为函数:dict(d),list(l),set(s),但这些都是浅拷贝，复制的只是对象引用，对于固定类型这就是复制的效果，但对于可变类型则意味着某个相关对象会同时被原来的和复制得到的对象引用所引用。
如果我们确实需要一个独立的副本或任意的嵌套组合可以进行深拷贝:copy.deepcopy()。x=[5,6,['a','b','c']],y=copy.deepcopy(x),则x与y是独立的。
在创建组合数据类型时，在for...in...循环与内涵中都需要频繁使用range()与zip()函数。
第四章 控制结构与函数
分支 if:...elif:...elif:...else:
有时if..else..语句可以转换为单一的条件表达式: expression1 if boolean_expression else expression2. offset=20 if ... else 10
循环while expr:... else:... 如果循环正常终止else部分就总会执行但由于break, 返回语句, 异常等原因导致跳出循环，则else分支不会执行。
else分支的这些特点对while,for...in...,try...except块都是一样的。
for...in...循环表达式中创建的变量在循环终止后仍然存在，与所有局部变量类似，他们也将在闭合范围结尾处终止存在。
异常处理
try:...
except except1 as variable1:..
...
except exceptn as variablen:..
else: ...
finally: ...
至少要包含一个except,else和finally都是可选的try块正常执行时会执行else块，但如果发生异常就不会执行，fianlly块总会执行。
except块可以是单独的异常也可以是异常元组。对于每个异常元组， as variable是可选的，如果使用，变量就会包含发生的异常，并可以在异常块中使用。
如果异常产生但没有匹配的except块,那么会先执行finally块，之后将该异常在调用栈中回溯。
产生异常
我们可以使用内置的异常或者自定义的异常产生异常的方法:
raise exception(args) raise exception(args) from orignal_exception
raise
使用第一种语法时，指定的异常应该是内置的异常或者是继承自Exception的自定义异常，如果给定一些文本作为参数，那么打印该异常时，这些文本应该为输出信息。
使用第二种语法也就是没指定异常时，raise将重新产生当前活跃的异常，如果当前没有就产生一个TypeError。
函数
def func(arg1,arg2,...):....
每个函数都有一个返回值，尽管也可以忽略。函数返回类型没有限制，可在任意位置使用return语句，如果return不带参数或者没有return语句，函数将返回None
含有默认值参数的函数，默认参数必须排在右边。在传递参数时可以不按照参数定义的顺序—，即使用关键字参数，以name=value的形式传递参数。
关键字参数必须在非关键子参数(即位置参数)的右边，顺序不定。
在给定默认值时，实际上是在执行def语句的时候创建的。对于固定类型的变量，这没什么影响，但对于可变参数这就有一个陷阱。
比如若给定一个默认列表参数ls=[],那么如果不指定该参数，默认的列表将都是函数创建时指定的那个列表，不会每次都创建一个默认空列表。
可以将ls默认值指定为None，在函数中这样写:if ls is None: ls=[]或者ls=[] if ls is None else ls.
使用docstring可以为函数添加文档信息，docstring可以是简单的添加在def行之后，函数代码开始前的字符串。
可以使用序列拆分操作符*来提供位置参数，如f(s[0],s[1],s[2])可以用f(*s).如果列表或其他序列包含比函数参数更多的项，我们可以使用分片提取出合适的参数。
在创建参数数量可变的函数时，也可以使用拆分符。def product(*args):for i in args...。
*意味着在函数内部args可以是一个元组，其项数也岁参数个数的变化而变化。 product(2,3,5,7), product(11)都是可以的。
也可以使用映射拆分**d，在定义时和调用时都可以使用。作为参数调用时，函数必须是关键字参数,d中的键不能超出函数定义时的关键字参数的范围，只能少，不能多。
定义时使用意味可以传递任意数量的关键字参数，并且*与**可以同时用在函数定义中。f(*arg,**dict):...
print函数可以接受任意数量的位置参数，还有3个关键字参数:sep,end,file.sep指定参数之间的分隔符，end默认为'\n',也就是在末尾会打印一个换行，file的默认参数为sys.stdout标准输出,通常为控制台。
不带end时print()打印一个换行。file可以指定为文件对象。
Lambda函数
lambda parameters:expressions
parameters是可选的如果提供通常是逗号分隔的变量名形式，expressions不能包含分支或循环，也不能包含return(或yield语句)，lambda表达式的结果是一个匿名函数。
返回的结果是对表达式计算产生的结果，如果expressions是一个元组就应该用圆括号将其包含起来。
f=lambda x:if x==1 else 's'。 s(count)。
对于内置的sorted()和list.sort()函数，lambda函数通常用作键值函数
调用函数时的参数顺序：(位置参数value, 关键字参数name=value和序列拆分*seq的组合, 映射拆分**dict)
定义函数时的参数顺序：(一般参数name, 默认参数name=value, *name或*, name或name=value keyword-only参数, **dict)
keyword-only参数——必须按照关键字参数传递。带有默认值的keyword-only参数是可选的，没有默认值的必须以关键字参数形式给出。
在函数定义即函数头部，keyword-only参数必须在**dict之前，*args之后。出现在*args之前的参数可能是默认位置参数，但不是keyword-only参数。
在调用函数时，keyword-only参数必须出现在**dict之前，但是可以在*args之前或之后。也可以包含在**dict之中。
当在调用函数时使用关键字参数时,参数的排列顺序并没有关系Python通过变量名进行匹配。
name=value的形式在定义函数时代表默认参数，在调用时代表关键字参数。
*/** 在定义时意味着收集任意数量的参数，在调用时意味着解包任意数量的参数。
oop和类
在通常请况下，类是由class语句填充的，而实例的属性则是通过在方法函数内对self属性进行赋值运算而创建。
不过重点在于并不是必须如此。Python中的oop其实就是在已连接命名空间对象内寻找属性而已。
python的属性继承搜索:object.attribute, 找出attribute首次出现的地方，先搜索object,然后该对象之上的所有类，由下而上，由左至右。
换句话说，取出属性只是简单的搜索”树“而已。
同一个类的实例不一定具有相同的属性名，实例实际上具有不同的名称空间，因此，每个实例都有一个不同的属性字典，尽管它们通常由类方法一致的填充。
可以通过类名修改类属性，或者通过实例或类引用它。通常情况下，继承搜索只会在属性引用时发生，而不是在赋值运算时发生。
对实例属性进行赋值会在该实例内创建或修改变两个名。
属性赋值运算只会影响属性赋值所在对象，通过实例属性赋值改变类属性也只会影响该实例本身的属性值，不会改变其他实例的属性值。
对对象属性进行赋值总会修改该对象，除此之外没有其他影响。
记住：如下的调用方法instance.method(args,...)，Python会自动将其转换为如下等同形式:class.method(instance,args,...)
class语句是复合语句，所以任何种类的语句都可以位于其主体内：print, = , if, def等。class语句运行时(不是创建实例时)会从头到尾执行其所有语句。
使用==比较两个对象时使用的是__eq__()方法，使用is比较时是用的是内置的id()函数来确定两个对象引用是否指向相同对象。
id()函数通常返回对象在内存中的地址。
默认情况下，自定义类型的对象都是可hash的，如果重写了__eq__()方法，则变为不可hash的，必须重新实现__hash__()方法，且其返回值不能改变。
类方法的第一个参数是由python指定的，通常是方法所属的类。 如__new__(class,args)
实例方法的第一个参数也是有python指定的，是调用该方法的实例。 如__init__(self,args)
静态方法则没有python指定的第一个参数,就像模块中的全局函数。
__setitem__(),__getitem__(),__delitem()__,__contains__(),__iter__(),__reversed__(),__len__(),
zip,map,reduce,filter,enumerate,sorted,range,
zip,map,filter和range不同，它们都是自己的迭代器，在遍历一次后它们就用尽了。它们不支持相同结果上的多个迭代器。
模块
就像def一样，import和from 都是可执行语句，而不是编译期间的声明，而且他们可以嵌套在if语句中，出现在def之中，直到执行时才会进行解析，和def一样，import和from都是隐性的赋值语句
。以from复制的变量名会变成对共享变量的引用，就像函数的参数一样，对已取出的变量名进行重新赋值，修改可变对象时会影响模块内的对象。
from语句会在导入者中创建新变量，而那些变量初始化时引用了导入文件中的同名那个对象。
在python3中在一个包中导入默认是绝对的，导入忽略了包含包本身并在CWD和sys.path搜索路径中查找。 可以使用from ./.. 来实现相对导入。
导入对象：变量，函数，数据类型，模块
import importable1 [,importable2,...,importableN]
import importable as another_name
from importable import object as another_name
from importable import object1 [,object2,...,objectN] //超过一行用括号括起来
from importable import * // *代表导入一切非私有对象，如果有全局__all__变量，就导入__all__中的名称列表。
包就是一个目录，其中包含一组模块和一个__init.py__文件。
使用from importable import * 时，__init.py__文件中如果有全局__all__变量，就导入__all__中的指定名称列表。
相对导入： from ..importable import object...
一个raw字符串不能以奇数个反斜杠'\结尾'，也就是说r'...\'不是一个有效的字符串，如果需要单个反斜杠结束的字符串，可以用两个反斜杠，并分片掉第二个。
r'1\n\tc\\'[:-1],或者手动添加:r'1\n\tc'+'\\',或者使用常规字符串，双斜杠转义:'1\\n\\tc\\'
2101
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
