Python学习思维导图模板_ProcessOn思维导图、流程图

序列

定义

序列类型有着相同的访问模式:它的每一个元素可以通过指定一个偏移量的方式得到。

多个元素可以通过切片操作的方式一次得到

偏移量是从 0 开始到总元素数-1 结束

成员关系操作符

in

not in

连接操作符( + )

把一个序列和另一个相同类型的序列做连接

字符串join()方法更高效节约内存

对列表来说，用列表类型的 extend()方法来把两个或者多个列表对象合并

重复操作符 ( * )

一个序列的多份拷贝

切片操作符

[]方括号加一个下标的方式访问它的每一个元素

在方括号中用冒号把开始下标和结束下标分开的方式来访问一组连续的元素[star:end]不包含第end个元素

扩展切片操作，它多出来的第三个索引值被用做步长参数[::]

s[::-1] # 可以视作"翻转"操作

s[::2] # 隔一个取一个的操作

字符串

字符串是不可变的,所以你不能仅仅删除一个字符串里的某个字符,你能做的是清空一个空字符串，或者是把剔除了不需要的部分后的字符串组合起来形成一个新串。

性能

一般来说，从性能的的角度来考虑，把重复操作作为参数放到循环里面进行是非常低效的一般来说，从性能的的角度来考虑，把重复操作作为参数放到循环里面进行是非常低效的.
while i < len(myString):
print 'character %d is:', myString[i]
上面的循环操作把大把的时间都浪费到了重复计算字符串 myString 的长度上了.每次循环
迭代都要运行一次这个函数.如果把这个值做一次保存，我们就可以用更为高效的方式重写我们的循环操作.
length = len(myString)
while i < length:
print 'character %d is:', myString[i]

格式化输出

%

string.format()

原始字符串符号(引号前面的字母"r"，大小写随意，唯一要求：在第一个引号前面)

在打开文件时可以使用

列表

能保留任意数目的 Python 对象的灵活的容器

列表是可变的

操作符和字符串操作符基本一致

用列表构建其他数据结构

堆栈

堆栈是一个后进先出(LIFO)的数据结构

队列

队列是一种先进先出(FIFO)的数据类型

元组

元组和列表看起来不同的一点是元组用的是圆括号而列表用的是方括号。

不可变

元组对象本身不可变，但是它包含的可变对象是可变的

操作符和字符串的基本一致

所有的多对象的，逗号分隔的，没有明确用符号定义的，比如说像用方括号表示列表，这些集合默认的类型都是元组

单元素元组：第一个元素后添加逗号

浅拷贝和深拷贝

浅拷贝

对一个对象进行浅拷贝其实是新创建了一个类型跟原对象一样,其内容是原来对象元素的引用,换句话说,这个拷贝的对象本身是新的,但是它的内容不是.序列类型对象的浅拷贝是默认类型拷贝,并可以以下几种方式实施:(1)完全切片操作[:],(2) 利用工厂函数,比如 list(),dict()等,(3)使用 copy 模块的 copy 函数.

深拷贝

copy.deepcopy()

警告

第一,非容器类型(比如数字,字符串和其他"原子"类型的对象,像代码,类型和 xrange 对象等)没有被拷贝一说,浅拷贝是用完全切片操作来完成的.

第二, 如果元组变量只包含原子类型对象,对它的深拷贝将不会进行.如果我们把账户信息改成元组类型,那么即便按我们的要求使用深拷贝操作也只能得到一个浅拷贝:

映射和集合类型

映射类型

映射类型对象里哈希值(键) 和指向的对象(值)是一对多的关系。

一个字典条目的语法格式是键:值。而且，多条字典条目被包含在{ }里

>>> fdict = dict((['x', 1], ['y', 2])) >>> fdict {'y': 2, 'x': 1}

>>> ddict = {}.fromkeys(('x', 'y'), -1) >>> ddict {'y': -1, 'x': -1} >>> >>> edict = {}.fromkeys(('foo', 'bar')) >>> edict {'foo': None, 'bar': None}

想访问该字典中的一个数据元素，而它在这个字典中没有对应的键，将会产生一个错误

可以使用in或not in操作符检查键是否存在

字典中的键必须是可哈希的，所以数字和字符串可以作为字典中的键，但是列表和其他字典不行。

用字典参数可以简化 print 语句，因为这样做你只须用到一次该字典的名字，而不用在每个元素出现的时候都用元组参数表示

更新字典

字典中该键已经存在，则字典中该键对应的值将被新值替代

也可以用内建方法 update()将整个字典的内容添加到另一个字典

标准类型操作符

字典的键查找操作符（[ ]）

(键)成员关系操作( in ,not in)

首先是字典的大小，然后是键，最后是值

可以用一个很方便的内建方法 fromkeys() 来创建一个"默认"字典, 字典中元素具有相同的值 (如果没有给出，默认为 None)

用字典参数可以简化 print 语句

>>> dict2['name'] = 'venus' # 更新已有条目 >>> >>> print 'host %(name)s is running on port %(port)d' %dict2 host venus is running on port 6969

dict()创建字典

参数是可以迭代的（一个序列，或是一个迭代器，或是一个支持迭代的对象），那每个可迭代的元素必须成对出现。在每个值对中，第一个元素是字典的键、第二个元素是字典中的值。

如果输入参数是(另)一个映射对象，比如，一个字典对象，对其调用 dict()会从存在的字典里复制内容来生成新的字典。新生成的字典是原来字典对象的浅复制版本，它与用字典的内建方法copy() 生成的字典对象是一样的。但是从已存在的字典生成新的字典速度比用 copy()方法慢，我们推荐使用 copy()。

对字典调用 len()，它会返回所有元素(键-值对)的数目

hash() 检查对象是否可哈希

update()方法可以用来将一个字典的内容添加到另外一个字典中。字典中原有的键如果与新添加的键重复，那么重复键所对应的原有条目的值将被新键所对应的值所覆盖。原来不存在的条目则被添加到字典中。

get()方法和键查找(key-lookup)操作符( [ ] )相似

不同的是它允许你为不存在的键提供默认值。如果该键不存在，也未给出它的默认值，则返回 None

setdefault()

它实现了常用的语法: 检查字典中是否含有某键。如果字典中这个键存在，你可以取到它的值。如果所找的键在字典中不存在，你可以给这个键赋默认值并返回此值

字典的键

每个键只能对应一个项。也就是说，一键对应多个值是不允许的。当有键发生冲突(即，字典键重复赋值)，取最后(最近)的赋值。

必须是可哈希的

集合

集合对象是一组无序排列的值

支持用 in 和 not in 操作符检查成员

由 len() 内建函数得到集合的基数(大小)

用 for 循环迭代集合的成员

可变集合sets

可添加或删除元素

不可哈希

不可变集合frozensets

不可添加或删除元素

可哈希

集合操作符和关系符号

in 是。。。的成员

not in 不是。。。的成员

== 等于

!= 不等于

< 是。。。的（严格）子集

<= 是。。。的子集（包括非严格子集）

> 是。。。的（严格）超集

>= 是。。。的超集（包括非严格超集）

& 交集

两个集合的交集是一个新集合，该集合中的每个元素同时是两个集合中的成员，即，属于两个集合的成员。交集符号有一个等价的方法，intersection()

| 合集

属于两个集合其中之一的成员。联合符号有一个等价的方法，union()

- 差补或相对补集

两个集合(s 和 t)的差补或相对补集是指一个集合 C，该集合中的元素，只属于集合 s，而不属于集合 t。差符号有一个等价的方法，difference()

^ 对称差分

对称差分是集合的 XOR(又称”异或“)另外一个集合 C,该集合中的元素，只能是属于集合 s 或者集合 t的成员，不能同时属于两个集合。对称差分有一个等价的方法，symmetric_difference()

如果左右两个操作数的类型相同，既都是可变集合或不可变集合, 则所产生的结果类型是相同的，但如果左右两个操作数的类型不相同(左操作数是 set，右操作数是 frozenset，或相反情况)，则所产生的结果类型与左操作数的类型相同，

创建集合的方法

Python2仅能用集合的工厂方法set()或frozenset()

python3可以使用{}

条件和循环

if-else

if-elif

三元操作符

smaller = x if x < y else y

>>> if x < y: ... smaller = x ... else: ... smaller = y

while

for-in

直接迭代序列要比通过索引迭代快

两全其美的办法是使用内建的 enumerate() 函数

可迭代对象有next（）方法

range()

range(start, end, step =1)

返回一个包含所有 k 的列表, 这里 start <= k < end , 从 start 到 end , k 每次递增step，step不可以为0

range(end)

start 默认为 0 , step 默认为 1 , 然后 range()返回从 0 到 end 的数列

range(start, end)

step默认为1

xrange()

有一个很大的范围列表时, xrange() 可能更为适合，Python3版本range()可能就像xrange()一样了

break

跳出当前循环，注意缩进

continue

当遇到 continue 语句时, 程序会终止当前循环,并忽略剩余的语句, 然后回到循环的顶端. 在开始下一次迭代前,如果是条件循环, 我们将验证条件表达式.如果是迭代循环,我们将验证是否还有元素可以迭代. 只有在验证成功的情况下, 我们才会开始下一次迭代.

pass

无操作

else

当for或while正常执行结束之后, 会再次执行一次else里面的内容.

for i in range(5): print i else: print "这里是else输出:", i+1 输出结果: 0 1 2 3 4 这里是else输出: 5

当循环语句中的else遇到break时将不会生效.

for i in range(5): print i if i == 3:break else: print "这里是else输出:", i+1 输出结果: 0 1 2 3

迭代器，iter()

可以迭代不是序列但表现出序列行为的对象, 例如字典的 key , 一个文件的行, 等等

根本上说, 迭代器就是有一个 next() 方法的对象, 而不是通过索引来计数.

当你或是一个循环机制(例如 for 语句)需要下一个项时, 调用迭代器的 next() 方法就可以获得它. 条目全部取出后, 会引发一个 StopIteration 异常, 这并不表示错误发生, 只是告诉外部调用者, 迭代完成.

代器也有一些限制. 例如你不能向后移动, 不能回到开始, 也不能复制一个迭代器.如果你要再次(或者是同时)迭代同个对象, 你只能去创建另一个迭代器对象.

reversed() 内建函数将返回一个反序访问的迭代器.

enumerate() 内建函数同样也返回迭代器

any() 和 all() , 在 Python 2.5 中新增, 如果迭代器中某个/所有条目的值都为布尔真时，则它们返回值为真.

itertools 模块, 它包含各种有用的迭代器

序列使用

推荐使用for循环

字典使用

字典的迭代器会遍历它的键(keys).语句 for eachKey in myDict.keys() 可以缩写为 for eachKey in myDict

myDict.iterkeys() (通过 keys 迭代), myDict.itervalues() (通过 values 迭代), 以及 myDicit.iteritems() (通过 key/value 对来迭代). 注意, in 操作符也可以用于检查字典的 key 是否存在 , 之前的布尔表达式myDict.has_key(anyKey) 可以被简写为 anyKey in myDict

文件使用

文件对象生成的迭代器会自动调用 readline() 方法. 这样, 循环就可以访问文本文件的所有行 . 程序员可以使用更简单的 for eachLine in myFile 替换 for eachLine in myFile.readlines() :

可变对象

不要在在迭代可变对象的时候修改它们

创建迭代器

对一个对象调用iter()

使用可迭代对象的__iter__()方法

列表解析

来自函数式编程语言 Haskell，用来动态地创建列表

函数式编程

map() 对所有的列表成员应用一个操作,

filter() 基于一个条件表达式过滤列表成员.

lambda 允许你快速地创建只有一行的函数对象.

语法

[expr for iter_var in iterable]

语句的核心是 for 循环, 它迭代 iterable 对象的所有条目. 前边的 expr 应用于序列的每个成员, 最后的结果值是该表达式产生的列表.

结合 if语句，列表解析还提供了一个扩展版本的语法:

[expr for iter_var in iterable if cond_expr]

这个语法在迭代时会过滤/捕获满足条件表达式 cond_expr 的序列成员

举例

>>> map(lambda x: x ** 2, range(6)) [0, 1, 4, 9, 16, 25]

>>> [x ** 2 for x in range(6)] [0, 1, 4, 9, 16, 25]

>>> seq = [11, 10, 9, 9, 10, 10, 9, 8, 23, 9, 7, 18, 12, 11, 12] >>> filter(lambda x: x % 2, seq) [11, 9, 9, 9, 23, 9, 7, 11]

>>> [x for x in seq if x % 2] [11, 9, 9, 9, 23, 9, 7, 11]

列表解析支持多重嵌套for 循环以及多个 if 子句.

>>> [(x, y) for x in [1,2,3] for y in [3,1,4] if x != y] [(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]

>>> combs = [] >>> for x in [1,2,3]: ... for y in [3,1,4]: ... if x != y: ... combs.append((x, y)) ... >>> combs [(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]

生成器表达式

语法

(expr for iter_var in iterable if cond_expr)

与列表解析非常相似，而且它们的基本语法基本相同; 不过它并不真正创建数字列表, 而是返回一个生成器，这个生成器在每次计算出一个条目后，把这个条目“产生”(yield)出来. 生成器表达式使用了"延迟计算"(lazy evaluation), 所以它在使用内存上更有效.

文件

open()和file()

基本语法

file_object = open(file_name, access_mode='r', buffering=-1)

file_name 是包含要打开的文件名字的字符串, 它可以是相对路径或者绝对路径

access_mode 也是一个字符串, 代表文件打开的模式. 通常, 文件使用模式 'r', 'w', 或是 'a'模式来打开, 分别代表读取, 写入和追加. 还有个 'U' 模式, 代表通用换行符支持， '+' 代表可读可写, 'b'代表二进制模式访问.

使用 'r' 或 'U' 模式打开的文件必须是已经存在的. 使用 'w' 模式打开的文件若存在则首先清空, 然后(重新)创建. 以 'a' 模式打开的文件是为追加数据作准备的, 所有写入的数据都将追加到文件的末尾. 即使你 seek 到了其它的地方. 如果文件不存在, 将被自动创建

如果没有给定 access_mode , 它将自动采用默认值 'r'

buffering 用于指示访问文件所采用的缓冲方式. 其中 0 表示不缓冲, 1表示只缓冲一行数据, 任何其它大于 1 的值代表使用给定值作为缓冲区大小. 不提供该参数或者给定负值代表使用系统默认缓冲机制

通用换行符支持

不同平台用来表示行结束的符号是不同的

默认打开

如果你不需要这个特性, 在运行 configure 脚本时，你可以使用 --without-universal-newlines 开关关闭它

只用于读取文本文件. 没有对应的处理文件输出的方法

内建方法

输入

read()

直接读取字节到字符串中, 最多读取给定数目个字节. 如果没有给定 size参数(默认值为 -1)或者 size 值为负, 文件将被读取直至末尾

readline()

读取打开文件的一行(读取下个行结束符之前的所有字节). 然后整行，包括行结束符，作为字符串返回. 和 read() 相同, 它也有一个可选的 size 参数, 默认为 -1, 代表读至行结束符. 如果提供了该参数, 那么在超过 size 个字节后会返回不完整的行

readlines()

readlines() 方法并不像其它两个输入方法一样返回一个字符串. 它会读取所有(剩余的)行然后把它们作为一个字符串列表返回. 它的可选参数 sizhint 代表返回的最大字节大小. 如果它大于 0 , 那么返回的所有行应该大约有 sizhint 字节(可能稍微大于这个数字, 因为需要凑齐缓冲区大小).

输出

write()

功能与 read() 和 readline() 相反

writelines()

接受一个字符串列表作为参数, 将它们写入文件. 行结束符并不会被自动加入, 所以如果需要的话, 你必须在调用 writelines()前给每行结尾加上行结束符

文件内移动

seek()

在文件中移动文件指针到不同的位置

offset字节代表相对于某个位置偏移量. 位置的默认值为 0 , 代表从文件开头算起(即绝对偏移量), 1 代表从当前位置算起, 2 代表从文件末尾算起

tell()

返回光标当前在文件中的位置

其他

close()

关闭访问文件

fileno()

返回打开文件的描述

flush()

把内部缓冲区中的数据立刻写入文件

os模块

os 模块属性描述 linesep 用于在文件中分隔行的字符串 sep 用来分隔文件路径名的字符串 pathsep 用于分隔文件路径的字符串 curdir 当前工作目录的字符串名称 pardir 当前工作目录的)父目录字符串名称

函数描述文件处理 mkfifo()/mknod() 创建命名管道/创建文件系统节点 remove()/unlink() Delete file 删除文件 rename()/renames() 重命名文件 *statc () 返回文件信息 symlink() 创建符号链接 utime() 更新时间戳 tmpfile() 创建并打开('w+b')一个新的临时文件 walk() 生成一个目录树下的所有文件名目录/文件夹 chdir()/fchdir() 改变当前工作目录/通过一个文件描述符改变当前工作目录 chroot() 改变当前进程的根目录 listdir() 列出指定目录的文件 getcwd()/getcwdu() 返回当前工作目录/功能相同, 但返回一个 Unicode 对象 mkdir()/makedirs() 创建目录/创建多层目录 rmdir()/removedirs() 删除目录/删除多层目录访问/权限 access() 检验权限模式 chmod() 改变权限模式 chown()/lchown() 改变 owner 和 group ID/功能相同, 但不会跟踪链接 umask() 设置默认权限模式文件描述符操作 open() 底层的操作系统 open (对于文件, 使用标准的内建 open() 函数) read()/write() 根据文件描述符读取/写入数据 dup()/dup2() 复制文件描述符号/功能相同, 但是是复制到另一个文件描述符设备号 makedev() 从 major 和 minor 设备号创建一个原始设备号 major() /minor() 从原始设备号获得 major/minor 设备号表 9.6 os.path 模块中的路径名访问函数函数描述分隔 basename() 去掉目录路径, 返回文件名 dirname() 去掉文件名, 返回目录路径 join() 将分离的各部分组合成一个路径名 split() 返回 (dirname(), basename()) 元组 splitdrive() 返回 (drivename, pathname) 元组 splitext() 返回 (filename, extension) 元组信息 getatime() 返回最近访问时间 getctime() 返回文件创建时间 getmtime() 返回最近文件修改时间 getsize() 返回文件大小(以字节为单位) 查询 exists() 指定路径(文件或目录)是否存在 isabs() 指定路径是否为绝对路径 isdir() 指定路径是否存在且为一个目录 isfile() 指定路径是否存在且为一个文件 islink() 指定路径是否存在且为一个符号链接 ismount() 指定路径是否存在且为一个挂载点 samefile() 两个路径名是否指向同个文件

永久存储模块

把用户的数据归档保存起来供以后使用, 这样你就可以避免每次输入同样的信息. 在简单的磁盘文件已经不能满足你的需要, 而使用完整的关系数据库管理系统(relational database management systems 即 RDBMS) 又有些大材小用时, 简单的永久性储存就可以发挥它的作用. 大部分永久性储存模块是用来储存字符串数据的, 但是也有方法来归档 Python 对象.

marshal

只能处理简单的 Python 对象(数字, 序列, 映射, 以及代码对象)

pickle

还可以处理递归对象, 被不同地方多次引用的对象, 以及用户定义的类和实例

一个增强的版本叫 cPickle , 使用 C 实现了相关的功能

shelve

使用 anydbm 模块寻找合适的 DBM 模块, 然后使用 cPickle 来完成对储存转换过程

错误和异常

异常

当 Python 检测到一个错误时, 解释器就会指出当前流已经无法继续执行下去. 这时候就出现了异常.

错误

语法错误

语法错误指示软件的结构上有错误, 导致不能被解释器解释或编译器无法编译.

逻辑错误

由于不完整或是不合法的输入所致; 在其他情况下, 还可能是逻辑无法生成, 计算, 或是输出结果需要的过程无法执行

检测和处理异常

try-except

try: try_suite # watch for exceptions here 监控这里的异常 except Exception[, reason]: except_suite # exception-handling code 异常处理代码

可以把多个 except 语句连接在一起, 处理一个 try 块中可能发生的多种异常

可以在一个 except 子句里处理多个异常. except 语句在处理多个异常时要求异常被放在一个元组里

接受所有异常

except Exception, e

使用裸 except 子句 except:

try-finally

不是用来捕捉异常的.作为替代,它常常用来维持一致的行为

try-except-else-finally

异常参数

reason

包含来自导致异常的代码的诊断信息的类实例

else子句

在 try 范围中没有异常被检测到时,执行 else 子句.

finally 子句

无论异常是否发生,是否捕捉都会执行的一段代码

上下文管理

with 语句

with 语句也是用来简化代码的,这与用 try-except 和 try-finally 所想达到的目的前后呼应.try-except 和 try-finally 的一种特定的配合用法是保证共享的资源的唯一分配,并在任务结束的时候释放它.比如文件(数据,日志,数据库等等),线程资源,简单同步,数据库连接,等等. with 语句的目标就是应用在这种场景

字符串异常

已废弃

抛出异常

raise

raise [SomeException [, args [, traceback]]] 第一个参数,SomeExcpetion,是触发异常的名字.如果有,它必须是一个字符串,类或实例(详见下文).如果有其他参数(arg 或 traceback),就必须提供 SomeExcpetion. 第二个符号为可选的 args(比如参数,值),来传给异常.这可以是一个单独的对象也可以是一个对象的元组.当异常发生时,异常的参数总是作为一个元组传入.如果 args 原本就是元组,那么就将其传给异常去处理;如果 args 是一个单独的对象,就生成只有一个元素的元组(就是单元素元组).大多数情况下,单一的字符串用来指示错误的原因.如果传的是元组,通常的组成是一个错误字符串,一个错误编号,可能还有一个错误的地址,比如文件,等等. 最后一项参数,traceback,同样是可选的(实际上很少用它),如果有的话,则是当异常触发时新生成的一个用于异常-正常化(exception—normally)的追踪(traceback)对象.当你想重新引发异常时,第三个参数很有用(可以用来区分先前和当前的位置).如果没有这个参数,就填写 None。 raise Exception'参数错误'，Exception可以替换为其他已有的错误类型

断言

assert

断言成功不采取任何措施(类似语句),否则触发 AssertionError(断言错误)的异常.

标准异常

所有的标准/内建异常都是从根异常派生的.目前,有 3 个直接从 BaseException 派生的异常子类:SystemExit,KeyboardInterrupt 和 Exception.其他的所有的内建异常都是 Exception 的子类

创建异常

异常和sys模块

通过 sys 模块中 exc_info()函数. 此功能提供了一个 3 元组 (3-tuple)的信息, 多于我们单纯用异常参数所能获得

函数和函数式编程

内部/内嵌函数

在函数体内创建另外一个函数(对象)

简介

高级：有高级的数据结构（例如：列表，字典），不需要开发框架（C需要）

面向对象：数据和逻辑分离

可升级：项目可增加功能且易于维护

可拓展：使用别的语言开发性能更高的代码

可移植：运行在任何带有ANSIC编译器的平台

运行Python的三种路径

1.命令行交互式解释器

2.命令行运行Python脚本

3.GUI集成开发环境

Python起步

输出语句

print

print后添加逗号,就不会换行了

print >>重定向输出

logfile = open('/tmp/mylog.txt', 'a')

print >> logfile, 'Fatal error: invalid input!'

logfile.close()

输入

raw_input

只能用于文本输入

注释

从#开始到一行结束

‘注释内容’

“注释内容”

‘’‘注释内容’‘’

运算符

+

-

*

/

底板除，取比商小的最大整数

//

浮点除法，精度更高

**

乘方

<

>

<=

>=

==

!=

and

or

not

变量和赋值

变量名区分大小写

只能以字母或下划线_开头

等号赋值

增量赋值

n = n + 1等同于n += 1

-/*以此类推

数字

整数

int

long

布尔

bool

0为false

1为true

浮点

float

复数

i² = -1

十进制浮点数

decimal

字符串

索引运算符[ ]

第一个字符的索引是0

最后一个字符的索引是-1

切片运算符[ : ]

+拼接字符串

*n 字符串重复n次

列表

[ ]

元素个数可以改变

元素的值可以改变

也可切片运算

元组

( )

不可以更改

也可切片运算，结果也是元组

字典

{key : value }

key不可变的类型，list类型对象不能做key

value任意类型

缩进对齐表达代码逻辑

if语句

while循环

for循环

range()函数

接受数值，生成一个列表

>>> for eachNum in range(3):

... print eachNum

...

0

1

2

enumerate()函数

同时循环索引和元素

>>> for i, ch in enumerate(foo):

... print ch, '(%d)' % i

...

a (0)

b (1)

c (2)

列表解析

在一行中使用一个 for 循环将所有值放到一个列表当中

squared = [x ** 2 for x in range(4)]

>>> for i in squared:

... print i

0

1

4

9

挑选出符合要求的值放入列表

sqdEvens = [x ** 2 for x in range(8) if not x % 2]

>>>

>>> for i in sqdEvens:

... print i

0

4

16

36

文件

open()

access_mode

r读

w写

a添加

+读写

b二进制访问

未提供默认为r

返回一个文件对象句柄

可以访问一些方法如readlines()，close()

实例

fobj = open(filename, 'r')

for eachLine in fobj:

print eachLine,

fobj.close()

file()

类似于open()

错误和异常

try-except

try之后的代码组，就是你打算管理的代码

except 之后的代码组，则是你处理错误的代码

raise

raise 语句故意引发一个异常

函数

定义

def 关键字及紧随其后的函数名再加上该函数需要的几个参数组成，由一个冒号(:)结束

def addMe2Me(x):

'apply + operation to argument'

return (x + x)

调用

使用小括号( )调用

在调用之前必须先定义

没有 return 语句，就会自动返回 None 对象

函数内对参数的改变会影响到原始对象

只有可变对象会受此影响，对不可变对象来说，它的行为类似按值调用

调用实例

>>> addMe2Me(4.25)

8.5

类

class 关键字定义类。可以提供一个可选的父类或者说基类; 如果没有合适的基类，那就使用 object 作为基类。class 行之后是可选的文档字符串，静态成员定义，及方法定义。

模块

模块是一种组织形式，它将彼此有关系的 Python 代码组织到一个个独立文件当中。

模块可以包含可执行代码，函数和类或者这些东西的组合。

你可以从另一个模块中使用 import 语句导入这个模块来使用。

常使用的内建函数

dir([obj]) 显示对象的属性，如果没有提供参数，则显示全局变量的名字

help([obj]) 以一种整齐美观的形式显示对象的文档字符串，如果没有提供任何参数，则会进入交互式帮助。

int(obj) 将一个对象转换为整数

len(obj) 返回对象的长度

open(fn, mode) 以 mode('r' = 读， 'w'= 写)方式打开一个文件名为 fn 的文件

range([[ start ,] stop [, step ]) 返回一个整数列表。起始值为 start, 结束值为 stop - 1; start默认值为 0， step默认值为1

raw_input(str) 等待用户输入一个字符串，可以提供一个可选的参数 str 用作提示信息。

str(obj) 将一个对象转换为字符串

type(obj) 返回对象的类型（返回值本身是一个 type 对象！）

Python基础

语句和语法

注释#

换行继续\

if (weather_is_hot == 1) and \

(shark_warnings == 0):

send_goto_beach_mesg_to_pager()

分号; 允许你将多个语句写在同一行上

等号(=)是主要的赋值运算符

y = (x = x + 1)非法

y = x = x + 1合法

x, y, z = 1, 2, 'a string' 多元赋值

标识符

第一个字符必须是字母或下划线（_）

剩下的字符可以是字母和数字或下划线

大小写敏感

非关键字

关键字

and、as、if、with、None等

内建

分支主题

下划线标识符

_xxx 不用'from module import *'导入

__xxx__系统定义名字

__xxx 类中的私有变量名

避免用下划线作为变量名的开始

模块结构和布局

# (1) 起始行(Unix)

# (2) 模块文档

# (3) 模块导入

# (4) 变量定义

# (5) 类定义

# (6) 函数定义

# (7) 主程序

主程序调用 main()函数

__name__ 系统变量

如果模块是被导入， __name__ 的值为模块名字

如果模块是被直接执行， __name__ 的值为 '__main__'

内存管理

变量在第一次被赋值时自动声明。和其他大多数语言一样，变量只有被创建和赋值后才能被使用。

也无需类型声明

变量名会被“回收”

del 语句能够直接释放资源

Python程序技巧

使用局部变量替换模块变量

类似 os.linesep 这样的名字需要解释器做两次查询：（1）查找 os 以确认它是一个模块，

（2）在这个模块中查找 linesep 变量。因为模块也是全局变量，我们多消耗了系统资源。如果你在一个函数中类似这样频繁使用一个属性，我们建议你为该属性取一个本地变量别名。变量查找速度将会快很多－－在查找全局变量之前，总是先查找本地变量。这也是一个让你的程序跑的更快的技巧：将经常用到的模块属性替换为一个本地引用。代码跑得更快，而也不用老是敲那么长的变量名了。

Python对象

对象

Python 使用对象模型来存储数据。构造任何类型的值都是一个对象。

所有的 Python 对像都拥有三个特性：身份，类型和值

每一个对象都有一个唯一的身份标识自己，任何对象的身份可以使用内建函数 id()来得到。这个值可以被认为是该对象的内存地址。您极少会用到这个值，也不用太关心它究竟是什么。

对象的类型决定了该对象可以保存什么类型的值，可以进行什么样的操作，以及遵循什么样的规则。您可以用内建函数 type()查看 Python 对象的类型。因为在 Python 中类型也是对象（还记得我们提到 Python 是面向对象的这句话吗?)，所以 type()返回的是对象而不是简单的字符串

对象表示的数据项

三个特性在对象创建的时候就被赋值，除了值之外，其它两个特性都是只读的。对于新风格的类型和类, 对象的类型也是可以改变的，不过对于初学者并不推荐这样做。

标准类型

数字（分为几个子类型，其中有三个是整型）整型布尔型长整型浮点型复数型字符串列表元组字典

布尔类型

所有标准对象均可用于布尔测试，同类型的对象之间可以比较大小。每个对象天生具有布尔 True 或 False 值。空对象、值为零的任何数字或者 Null 对象 None 的布尔值都是 False。

and， or 和 not 都是 Python 关键字，这些运算符的优先级按从高到低的顺序列于表 4.3. not 运算符拥有最高优先级，只比所有比较运算符低一级

Python 提供了 is 和 is not 运算符来测试两个变量是否指向同一个对象

整数对象和字符串对象是不可变对象，所以Python会很高效的缓存它们。这会造成我们认为Python应该创建新对象时，它却没有创建新对象的假象。

>>> a = 1 >>> id(a) 8402824 >>> b = 1 >>> id(b) 8402824 >>> >>> c = 1.0 >>> id(c) 8651220 >>> d = 1.0 >>> id(d) 8651204

标准类型内建函数

type() 接受一个对象做为参数，并返回它的类型。它的返回值是一个类型对象。

cmp()用于比较两个对象 obj1 和 obj2，如果 obj1 小于 obj2, 则返回一个负整数，如果 obj1 大于 obj2 则返回一个正整数，如果 obj1 等于 obj2，则返回 0

str() 和 repr() 或反引号运算符(``) 可以方便的以字符串的方式获取对象的内容、类型、数值属性等信息。str()函数得到的字符串可读性好，而 repr()函数得到的字符串通常可以用来重新获得该对象

>>> str(4.53-2j) '(4.53-2j)' >>> >>> str(1) '1' >>> >>> str(2e10) '20000000000.0' >>> >>> str([0, 5, 9, 9]) '[0, 5, 9, 9]' >>> >>> repr([0, 5, 9, 9]) '[0, 5, 9, 9]' >>> >>> `[0, 5, 9, 9]` '[0, 5, 9, 9]'

repr() 输出对 Python 比较友好，而 str()的输出对人比较友好。虽然如此，很多情况下这三者的输出仍然都是完全一样的。

Python 不支持方法或函数重载，因此你必须自己保证调用的就是你想要的函数或对象。

存储类型

标量/原子类型：数值(所有的数值类型)，字符串(全部是文字)

容器类型：列表、元组、字典

访问模型

直接存取

非容器类型可以直接访问

所有数值类型

顺序

容器内的元素按从 0 开始的索引顺序访问

字符串，列表和元组

映射

容纳的是哈希键-值对的集合

字典

不支持的类型

char、bit

指针

更新模型

可变类型：列表，字典

不可变类型：数字、字符串、元组

数字

提供了标量贮存和直接访问

不可更改类型，也就是说变更数字的值会生成新的对象

无法真正删除一个数值对象，你仅仅是不再使用它而已。如果你实际上想删除一个数值对象的引用，使用 del 语句

整型

布尔类型

只有两个值的整型

常规整型

浮点数

复数

一个实数和一个虚数的组合构成一个复数。一个复数是一对有序浮点数(x, y)。表示为 x + yj，其中 x 是实数部分，y 是虚数部分。

分支主题