python学习总结web

目录

1.两种python执行方式（Linux, Mac OS下） (3)

2.创建并执行脚本文件（windows下学习看本节最后的备注即可） (3)

3.python中的缩进 (4)

4.字符串的使用 (4)

5.说明几个运算符： (4)

6.数据结构--简介 (5)

7.数据结构--"列表（list）" (6)

8.数据结构--"元组（tuple）" (8)

9.数据结构--"字符串（str和unicode）" (9)

10.数据结构--"字典（dict）" (9)

11.数据结构--"集合（set）" (11)

12.数据类型之间的转换 (11)

13.选择语句、循环语句 (12)

14.关于模块 (13)

15.定义一个函数 (14)

16.关于python的类 (16)

17.命令行参数 (16)

18.引用和复制一个对象 (17)

19.常用内建函数 (17)

20.常用模块功能： (19)

a.os 模块 (19)

b.sys 模块 (19)

c.time模块 (20)

d.cPickle模块 (20)

e.ctypes模块 (20)

f.复制和移动文件 (20)

g.其它重要模块：datetime, json, sqlite3,等，自学 (20)

21.正则表达式(初学者了解) (21)

22.Python 异常处理 (23)

23.with语句 (24)

24.文档字符串 (24)

25.绝对路径与相对路径 (24)

26.其它应了解的 (25)

27.继续学习什么 (26)

28.如何自学 (26)

关于编程的一些建议(要养成的好习惯) (27)

本书收集历时一年多时间，此电子书可以免费使用，如果您觉得此电子书对您有帮助，可以小额赞助，以便我后期更好地完善此书。

也可以加入到QQ群（118140582），有问题可以互相交流，备注请写：Python基础教程。

说明:本书基于《byte of python》电子书及网络材料,结合自身测试,旨在抛砖引玉

python与脚本语言

首先我们知道，脚本与脚本解释器这两个概念是统一的、密不可分的。

脚本本质上就是文本文件（如用ASCII码所写的），这种文本文件用文本编辑器打开与普通的文本文件没有区别，只不过扩展名不是".txt"，python脚本的扩展名通常是".py"。计算机仅有脚本还是不能工作（它只是文本文件），我们需要一种工具软件，用来把脚本中的代码解释成计算机指令，同时让计算机立即执行这些指令，这种工具就是脚本解释器。很显然，使用不同语法规则编写的脚本应使用不同的解释器来解释执行，因为每种脚本实际上是专为其解释器而写的，是按照解释器能识别的语法规则而写的。python是众多"脚本解释器+语法规则"的一种，类似还有bash、perl、javascript等等。

Python是高层次的面向对象的编程语言。优点是代码简洁、简单易学，缺点是运行速度较慢。我们可以在python代码中调用C编译生成的动态链接库来提升程序运行速度。很多发布的linux系统都自带了python解释器，因此python在linux平台上应用广泛，很适合GUI（图形界面）、测试程序等各类软件的开发。建议学习时把书上提供的示例代码上机操作一遍，动手写python代码可以迅速掌握python。

学习摘要

1.两种python执行方式（Linux, Mac OS下）

a.进入python的shell下逐行执行：

在终端（Terminal）下键入"python"按回车（解释器被启动），进入python的shell，

此时可以输入python语句，按回车执行。按"左侧ctrl + D"退出python的shell。

b.在终端下直接调用python脚本执行：

在终端命令行进入相应目录，运行"python hello.py"；或者可以在脚本文件首行指定

解释器，终端命令行只需输入"./hello.py"调用，此方式见下文"创建并执行脚本文件"。

【超级终端实际就是一种shell，linux默认指定为bash。】

2.创建并执行脚本文件（windows下学习看本节最后的备注即可）

a.创建一个名为"hello.py"的脚本文件(黄色背景表示脚本的内容):

[root@Linux ~] #vi hello.py

#! /usr/bin/python

print "hello, world"

b.赋予脚本文件可执行权限:

[root@Linux ~] #chmod a+x hello.py

c.执行脚本文件:

[root@Linux ~] #./hello.py

【超级终端下会显示："hello, world"】

d.步骤说明

在文件开头写"#!/usr/bin/python"，这是指定该脚本使用的解释器所在的目录。因为python的

默认安装目录是"/usr/bin/python"，所以这里如此指定，真实情况要按照python的实际安装目录

来指定。也可以不在文件开始处指出解释器，这种情况下应在终端命令行中指定解释器，如下：

[root@Linux ~] #python ./hello.py 或python hello.py

备注：在winxp,win7,win8下也是一样的，

先安装python, 在[开始] -> [所有程序] 下找python2.7, IDLE

点击File, new window可以像文本一样编写程序, 按F5运行

3.python中的缩进

缩进是语法规则相关的，它决定语句的层次（类似C, Java等语言中用"{}"来表示层次一

样）。同一层次语句必须有相同缩进，否则解释器会报错。Python函数没有明确的开始

（begin）或者结束（end），也没有用大括号来标记函数从哪里开始从哪里停止。唯一

的定界符就是一个冒号(:)和代码自身缩进。例如：

def function_name():

I = 3

print "number is", i

4.字符串的使用

1.单引号与双引号在python中等效使用

a.三引号（'''或"""）可用来写跨行的字符串，在其中，单、双引号均可使用。

b.Python中字符串"what's this"表示方式

方式1：'what \'s this'. 这里用到了转义符'\'

方式2："what's this"

c.行末的单独一个反斜杠表示字符串在下一行继续，而不是开始一个新的行：

"This is the first sentence.\

This is the second sentence."

等价于"This is the first sentence. This is the second sentence."

d.用r或R指定自然字符串

r"Happy\n", 一般’\n’代表回车，因为用'r'指定为自然字符串，因此'\n'不会被解释器理解

为回车换行符，而是'\'和'n'这两个字符，因此打印时会打印出"Happy\n"这7个字符。在

正则表达式中常用到。

e.用u或U指定使用unicode编码. 如：u"Happy"

f.连写的两个字符串会被解释器理解为一个连续的字符串

"what's"" your name"会被理解为"what's your name"

g. 字符串strip(), find(), replace(), join(),split() 方法的掌握，后面有讲到。

5.说明几个运算符：

"not、and、or"：（布尔）非、（布尔）与、（布尔）或

"**"表示"幂"。如：3**4 = 81 (3的4次幂) 也可以用pow(3,4)

"//"表示"取整除"。如：4//3.0 = 1.0

/ 取整除或取商（浮点数），7/3.0=2.333... 4/3=1 8/3=2 9/float(4)=2.25

备注：在Python3.x中/ 是真正除，Python2.x可以在代码开头加一句from __future__ import division这样去改变除法的行为，使得其和Python3.x一致。

% 取余数8%2=0 4%3=1 5%2=1 7%4=3

思考：如何判断整除？即一个整数能不能被另一个整数整除，如何判断？(余数是0就是整除)

答: if x%m == 0:print "yes"或if not a%b:print "yes"或者if a==(a/b *b):print "yes"

6.数据结构--简介

python中每种数据类型都被当作对象。虽然Python中的每个值都有一种数据类型，但我们不需要声明变量的数据类型，因为python 会根据每个变量的初始赋值情况分析其类型，并在内部对其进行跟踪，当然这种"i = long(12)"带类型来定义变量的方式也是支持的。Python 有多种内置数据类型，各类型关键字可用于类型强制转化、定义变量等,如用a=list()定义一个数组，用help(set)学习集合。以下是比较重要的一些：

a.布尔型: 关键字bool，值为True或False，逻辑上的真、假。用于循环或判断

b.整数: 关键字int，如3, -1，也叫整型。

c.浮点数: 关键字float，如3.2，7.92, 也叫浮点型。

d.字符串型: 关键字str，如"hello python"；关键字unicode, 如u"hello"。

e.列表: 关键字list，是值的有序序列，如[3, 2, 5]，值可以是任何类型。

f.元组: 关键字tuple，类似于列表，但值不可变的序列，如(1,3,5)，(1,)。

g.集合，关键字set，是装满无序值的包。三大特性：无序性，确定性，互异性。

h.字典，关键字dict，是键值对的无序包。

(了解)【要使用C语言类型的数据，需要导入ctypes模块，以便使用c_int、c_long等类型。可以在python的shell先"import ctypes"然后"help(ctypes)"查看具体规定】

用关键字可以创建一个列表,元组,集合和字典,如my_dict = dict() 这样就创建了一个名称为my_dict的字典。

list1 = list() 或list2 = [] 创建一个空的列表

tuple1= tuple() 或tuple2 = () 创建一个空的元组

a = (1) 或a = ('a') # a 是tuple类型吗？不是，后文有解释

set_a = set() 创建一个集合，新版也可以用set_a = {1,2,3} 来创建一个集合

字符串为什么有两种？

由于历史原因，Python开始是不支持unicode的(Python 诞生时还没有unicode)，后来加入了unicode的支持。也就是说如果用到中文我们就会用到unicode

7.数据结构--"列表（list）"

list是一组有顺序的数据，它的元素（对象）个数是变的（后面要说的元组则是固定的）。

a.各种内建方法

>>>list_a = [1, 2] # 定义list_a含有1,2两个对象

>>>list_a.append(2) # 添加一个对象到末尾

>>>list_a # 查看list_a中内容

[1, 2, 2] # shell中显示

>>>list_a.count(2) # 返回list_a中对象是2的个数

2 # shell中显示有2个值为2的对象

>>>list_b = [3, 4] # 定义list_b含有3，4两个对象

>>>list_a.extend(list_b) # 在list_a末尾添加添加list_b

>>>list_a # 查看list_a中内容

[1, 2, 2, 3, 4] # shell中显示

>>>list_a.index(3) # 返回第1个匹配的指定值在list中的位置，list中第1个

对象的位置是0，第2个对象位置是1，以此类推

3 # shell中显示

>>>list_a.insert(2，'ok') # 在list_2位置是2的对象前添加对象'ok',返回None

>>>list_a # 查看list_a中内容

[1, 2, 'ok', 2, 3, 4]

>>>list_a.pop() # 删除并返回list中最后一个对象

>>>list_a.remove(2) # 删除第1次出现的匹配指定值的对象,没有指定值的话ValueError

如何删除所有的2呢？while 2 in list_a: list_a.remove(2) >>>list_a # 查看list_a中内容可以想想如何删除所有的2

[1, 'ok', 2, 3, 4]

>>>list_a.reverse() # 将list_a中的所有对象的位置反转

>>>list_a # 查看list_a中内容

[4, 3, 2, 'ok', 1]

>>> List=[1,5,7,1111,2,1.5]

>>> sorted(List) # 有返回值，List本身不变

[1, 1.5, 2, 5, 7, 1111]

>>> List

[1, 5, 7, 1111, 2, 1.5]

>>> List.sort() # 就地操作，无返回值，结果保存到List 本身

>>> List

[1, 1.5, 2, 5, 7, 1111]

list_a.sort(cmp=None, key=None, reverse=False)：对list_a排序

key：指定"取值函数"。取值函数带1个参数。sort方法从list_a中取出元素，作为实参传递给取值函数，取值函数做些处理，再将处理后的返回值传递给比较

函数。

cmp：指定"比较函数"。比较函数带2个参数。比较函数接收取值函数传送过来的2个参数，经过某种比较，返回比较结果（-1, 0, 1）。在写具体比较函数时，

往往会用到python内建函数"cmp()"

reverse: 指定为True时，将排序后序列顺序转置，否则无动作。

【list_a.sort()不指定任何参数时，对list_a按小从到大排序,返回值为None, sorted(list_a)排序时list_a不变，而是返回一个list】

b.列表使用：下标方式，结合切片操作符':'

>>> list_a[2] = 'ok'# 给列表中某一项赋值

>>> list_b = list_a[2:] # 将list_a[2]起到最后一个元素，把值赋给list_b

>>> list_b = list_a[:3] # 相当于list_a[0:3]赋给list_b，不包括list_a[3]

>>> list_b = list_a[1:4] # 将list_a[1]至list_a[3]赋给list_b，不包括list_a[4]

>>> list_b = list_a[1:-1] # 将list_a[1]到list_a中最后一项(不包括最后一项)赋给

list_b。-1表示最后一项，-2表示倒数第2项，以此类推

c.遍历list中数据

for value in list_a:

print value # 在循环中对value 进行操作

【临时变量value遍历list_a，循环取值，直到遍历完整个列表】

d.用列表解析(list comprehension) 定义列表

>>>my_list = [2*i for i in range(0, 5) if i>2] # 形式为[表达式，变量范围，条件]

(1)表达式：2*i，i是变量

(2)变量范围：for i in range(0,5)

(3)条件：if i>2

再举一例：

>>>list_a = [2, 3, 4, 5, 6]

>>>list_b = [3*i for i in list_a if i%2==0]

>>>print list_b # 终端显示[6, 12, 18]

e.列表相关其它函数（初学者了解，但都非常有用！）

(1) any(List) List中任何一个元素都有逻辑真，则返回True，全为假返回False

all(List) List中所有元素都为真时返回True,否则返回False

(2) max(List) min(List) 返回列表中的最大值或最小值

(3) enumerate() 在列表中同时循环索引和元素，如：

List=["MaoZedong", "DengXiaoping", "JiangZemin", "HuJintao", "XiJinping"]

for index, entry in enumerate(List):

print index, entry

(4) 求和函数：sum，如sum([1,2,3,4]) 可求1+2+3+4

sum(range(101)) 可求1+2+3+4+...+100 的和

(5) 过滤函数：filter(func,list)对list进行过滤，保留满足条件的，返回一个新的list,

function的返回值只能是True或False

>>> def f(x): return x % 2 != 0 and x % 3 != 0 #函数中只有一句可写成一行，但不建议，读起来费劲>>> filter(f, range(2, 25))

[5, 7, 11, 13, 17, 19, 23]

>>> def f(x): return x != 'a'

>>> filter(f, "abcdef")

'bcdef'

例子：找出1到10之间的奇数

filter(lambda x:x%2!=0, range(1,11))

(6) map(func,list)把list中每一个元素操作，返回一个新的list

>>> def cube(x): return x* *3 # x**3 equals to x*x*x

>>> map(cube, range(1, 11))

[1, 8, 27, 64, 125, 216, 343, 512, 729, 1000]

>>> def cube(x) : return x + x

...

>>> map(cube , "abcde")

['aa', 'bb', 'cc', 'dd', 'ee']

另外map也支持多个sequence，这就要求function也支持相应数量的参数输入：

>>> def add(x, y): return x+y

>>> map(add, range(8), range(8))

[0, 2, 4, 6, 8, 10, 12, 14]

(7) reduce(func,list[,init])如果给init的话用init和list[0]用func函数处理，得到

的结果再与list[1]经过func处理，依此类推，直到结束，如果不给init，第一次直

接从list中取出两个(即list[0]和list[1])

>>> def add(x,y): return x + y

>>> reduce(add, range(1, 11))

55 （注：1+2+3+4+5+6+7+8+9+10）

>>> reduce(add, range(1, 11), 20)

75 （注：20+1+2+3+4+5+6+7+8+9+10）

利用reduce求阶乘方法

def f(n): return reduce(lambda x,y:x*y ,xrange(1,n+1))

8.数据结构--"元组（tuple）"

tuple是一组有序且不可改变的数据（数组是可以改变的），它的元素（对象）个数是固定的。我们有时候会强制转换my_tuple = tuple(list_a)，由list_a得到一个元组my_tuple；

或者list_a = list(my_tuple) 由一个元组得到一个列表。关于使用方法，也是下标方式，与列表一样。记住，它的值不能改变，因此不能赋值。

特殊地：（元组也不是那么不可变）

1. 元组中的列表可以被改变，如：t=([2],3,7); t[0][0]=100 运行后看看t变成什么了

2. t=("first","second"); t=t+("third","fourth") 看看t现在变成了什么

思考: 1中t[0]能被改变吗?如果想改变的话应该怎么做?

注意：一个元素的元组一定要小心，要在后面加上逗号

Tuple_a = ("Weizhong Tu",) # 注意后面的逗号，少了就成了string 类型了

Tuple_b = (999,) # 999后面的逗号少了的话就成了整型数字

9.数据结构--"字符串（str和unicode）"

字符串同列表，元组一样，都是序列。序列的特点是可能使用"索引"和"切片"，即我们

可以取得序列中的某一项，或者某一部分。

1. 索引: a="student"a[2]是a中第三个字母'u' (从0算起，2就是第三个)

2. 切片: "string"[start:end:[step=1]]中start,end必须有一个,和列表切片相同,step不给时默认为1

"s tude nts"[1:5]是取第二个字母到第五个，不包括第六个(口诀：要前不要后)

常见操作：

>>> my_str ='Jason'# 定义字符串my_str

>>> my_str.starts with('Jas') # 若my_str以'Jas'开头，返回True, 否则返回False

>>> my_str.ends with('son') # 若my_str以'son'结尾，返回True, 否则返回False

备注：.startswith(), .endswith() 均可以tuple为参数，满足其中之一即返回True

String.startswith(('a','b')) # 当String 以a或b开头均返回True

>>> my_str.count(‘a’) # my_str 中有几个‘a’

>>> if 'a' in my_str：# 判断my_str中是否含有字符'a'，有返回True, 否则返回False >>> my_str.find('a') # 返回'a'在my_str中的位置, 找不到则返回-1 (不是0,因为0是第一个，是

找到了的意思) -1在逻辑上是真，0在逻辑上是假，所以查找字符串是否包含更推荐用in 方法。

>>> my_str.index('a')与my_str.find('a')功能相同，但找不到时发生ValueError

>>> ss = '***'# 定义字符串ss

>>> my_list = ['a', 'b', 'c'] # 定义列表my_list

>>> mylist_to_string = ss.join(my_list) # 使用ss来连接my_list中各元素，返回组成的字

符串给list_a。有返回值，ss与my_list均未改变。

mylist_to_string 值为'a***b***c'

>>> list_a = my_str.replace('a', 'b') # my_str中的'a'替换成'b'形成的字符串赋给list_a。

my_str实际未变

>>> a = u'中国' # 定义unicode字符串，如果在文件中在文件开头加上#coding=utf-8

总结：unicode('Learn python') 转化为unicode 字符串str(u'learn django') 转化为str 字符串。一般不这样转化，在处理中文地用到unicode, 建议用utf-8 编码的unicode

在Python2.7中，处理含有中文等unicode的字符时，读入时要data.decode(‘utf-8’) 变

成unicode 字符，输出f.write(data.encode(‘utf-8’))，即处理过程多用decode，使得字

符串尽量都是unicode这样可以简化操作。也可以在文档开头引入from __future__ import unicode_literals 使得不带u’’的字符串也是unicode 类型。

python3.x中统一为unicode了，不再区分，所有问题变得更简单，但是由于一些包并

不兼容Python 3.x ，所以Python 2.x 也还被广泛使用。

关于字符串的处理还有一个强大的工具就是正则表达式，见后文。

10.数据结构--"字典（dict）"

字典就是"键名/数值"对（简称'键值对'）无序的合集。键名是唯一的，不可变的，键值是可以改变的。{key1:value1, key2:value2}

>>>my_dict = {'Jason':2011, 'Anson':2012} # 定义字典，包含2个键值对

>>>my_dict["Wuhan"]=120 # 增加一个新的,返回{'Jason':2011, 'Anson':2012,"Wuhan":120}

>>>my_dict["Wuhan"]=2013 # 改变值,返回{'Jason':2011, 'Anson':2012,"Wuhan":2013}

>>>my_dict["Wuhan"] #得到2013，也就是取值，找不到时KeyError,除此和del之外相当于my_dict.get('Wuhan')

>>>my_dict.items() # 返回一个列表:列表元素是元组（每个键值

对组成一个二维元组）

【for item in my_dict.items() 可用来在my_dict中遍历，类似列表中介绍的遍历方法】

>>>'Jason'in my_dict # 判断my_dict中是否有键名'Jason'，有返回True，否则返回

False,相当于my_dict.has_key('Jason') >>>del my_dict['Jason'] # 删除键名为'Jason'的键值对

>>>dict_a = my_dict.copy() # 将my_dict复制给新建字典dict_a

>>>data = my_dict.get('Jason') # 从键名为'Jason'的对中取出值，赋给data，

dict.get(key,default=None), default默认为None 所以，找不到时返回None 2011 # 屏幕显示内容

>>>my_dict.setdefault('k','d') # 如果'k'存在，返回对应的值，如果不存在，赋值为'd'

>>>my_dict.keys() # 返回所有键名组成的列表

>>>my_dict.values() # 返回所有键值组成的列表

>>>my_dict.pop('Jason') # 删除键名为'Jason'的键值对，返回该对的值，key不存在时报错，用pop(key,None)

>>>my_dict.popitem() # 随时删除一个键值对，返回二维元组(key, value)

>>>my_dict.clear() # 清除所键值对

>>>my_dict.update(dict_a, **dict_b) # 在my_dict中添加dict_a, dict_b中各键值。可以

只用第一个参数，即一次只添加一个字典>>>for key in my_dict: # 直接在my_dict.keys()遍历

print key,my_dict[key]

>>>my_dict.setdefault(key,value) 当存在key时获取它，没有时赋值为value，并返回值

字典排序：sorted(my_dict) 相当于sorted(mydict.keys()), 没有my_dict.sort()

【更快的迭代方法：(python 3.x 中取消了这些方法)

.iter items() .iter keys() .iter values() 和items() .keys() .values()功能相当，但只用于迭代】有顺序的字典：

from collections import OrderDict

Dict1 = OrderDict() # Dict1 就是一个有顺序的字典

字典默认值：一般字典中key不存在时使用DICT[key] 时会引发KeyError, 如果希望key不存在时返回一个默认值，除了了DICT.get(key,default_value) 之外，还可以用

from collections import defaultdict

Dict1 = defaultdict(lambda: 'No') # 这样，当访问一个不存在的值时就返回'No'

11.数据结构--"集合（set）"

我所理解的，集合的概念就是数学上所称的集合的概念。

集合具有互异性，确定性，无序性。

>>> set_a = {1, 2} # 定义集合，或用set_a=set()定义空集合

>>>set_a.add(4) # 向set_a中添加元素4

>>>set_a.remove(2) # 从集合set_a中删除2，没有的话KeyError

>>>set_a.discard(2) # 删除集合set_a中的元素2,remove的友好版本

>>> set_a.pop() # 从集合set_a中随机删除一个值，并返回该值。从空集合中pop

会引发KeyError，.pop() 无参数，不同于字典。

>>> set_a.clear() # 清空集合

>>> set_b = set_a.copy() # 将set_a内容复制给set_b（浅拷贝）。

【"set_b = set_a"表示"引用"关系，并非是复制,也可用set_b=set_a[:] 来复制】

>>> set_a.update([5,9,2]) # 将5，9，2（可以是任意多个值）加入集合，根据数字中

集合的概念，相同的值不会重复加入。

>>> set_c = set_a | set_b # 并集set_c为set_a和set_b的并集

>>> set_c = set_a & set_b # 交集set_c为set_a和set_b的交集

>>> set_c = set_a - set_b # 差集set_c为set_a去掉其与set_b公共的部分

>>> set_c = set_b ^ set_a # 异或set_c为set_b并set_a，再去掉二者公共部分

s |= t 并，s与t并集，存到s中,相当于s=s.union(t) 或s.update(t)

s &= t 交，s与t交集，存到s中,相当于s=s.intersection(t) 或s.intersection_update(t)

s -= t 差，s与t差集，存到s中,相当于s=s.difference(t) 或s.difference_update(t)

s ^= t 异或，s与t不同的部分并到一起(s并t，再去掉s交t) ，存到s中,相当于s=s.symmetric_difference(t) 或s.symmetric_difference_update(t)

>>> if 3 in set_a: # 判断set_a中是否有元素3

>>> set_a <= set_b # 判断set_a是否为set_b的子集，返回True 或False,相当于set_a.issubset(set_b) >>> set_a >= set_b # 判断set_a是否为set_b的超集，返回True 或False,相当于set_a.issupset(set_b)【if 语句中，空集合为False，任何非空集合为真值】

思考：字典和集合都是用{},那么如何定义一个空的集合？

>>> a={} #这样是定义一个空字典，也可用a=dict()

>>> type(a) #

>>> a=set() #定义一个空集合

>>> type(a) #

12.数据类型之间的转换

利用关键字可以很容易地实现：比如int, str, list, tuple, set等

1.利用集合的互异性对列表去重：list_a = list(set(list_a)) 把list_a变成集合，再变成列表

2.字典-->列表dict_a.items() dict_a.keys() dict_a.values()，用list(dict_a)相当于.keys()

3.字符串与数字转换：变成数字int("2013") 变成字符串str(120)

4.数字类型之间转化：整形变浮点型float(2) 得到5除以2的准确值可以用5/float(2)

5.元组，列表，集合变字符串，用“”.join(sequence) 字符串变list用string.split()

备注：print 函数会对输出对象调用str()，所以print "I am", 23, "years old."这样写也不报错，但是用"I am" + 23 + "years old"就会报错，这时就得转换一下str(23)

13.选择语句、循环语句

选择语句( if-elif-else)：

循环语句( for, while )：

14.关于模块

从功能上讲，每个用python编码的合理的脚本应是一个功能模块，用".py"作扩展名。

Python也能够调用由c/c++编译生成的动态链接库，这种能力大大提升了整个程序的运

行速度【如内建模块，系统中并没有它们的源代码】。

a.import语句

import语句用来导入其它模块，主要有两种用法：

用法1："import A"表示导入整个模块A

用法2："from A import B"表示导入模块A下的对象B（B可以是任何对象，

python中一切皆为对象，如类，变量等）。

【假设模块A中有子模块B，而B中有个函数C，我们要调用这个函数C。如果"import

A"，就要"A.B.C()"，用"from A import B"，只要"B.C()"，就是说可以从导入的具体对

象开始引用, 用"from A.B import C"，只要"C()"】

默认导入路径在sys.path变量中定义。可以使用sys.path.append("目录")来添加导

入路径。例如：

import sys

sys.path.append("/usr/test") # 将/usr/test目录添加到sys.path变量中

import MyModule # 导入在/usr/test中的MyModule模块

b.直接使用python编码的模块的情况。例如我用们os模块创建文件夹：

import os # 导入os模块

os.mkdir("/tmp/folder") # 调用os模块的mkdir()函数

【使用import导入模块时，模块的主代码块（即函数与类之外的部分）会被立即执

行，可以使用下述方法来控制是否在被导入时执行(独立运行时模块的__name__为

"__main__", 当被导入时不是"__main__",是文件名)：

if __name__ == "__main__":

# 主代码块放在这里】

c.(了解)通过内建的ctypes模块，加载由c/c++编译得到的动态链接库的情况。具体请

看下文中，"常用模块功能"中的"ctypes模块"。

d.(了解)使用cython工具，将类似python风格的代码编译成c代码，然后再用上例中

介绍的方法编译成动态链接库，以供加载调用。例如：

cython some.pyx # 调用cython 命令将cython文件some.pyx编译成some.c

gcc some.c –fPIC –shared –I /usr/include –o some.so

【cython算是另一种类python语言，混合了python与c的编程风格，有自己独立

的"编译器+语法规则"。用途是使用较简洁的类python代码，编译生成c语言源码，

最终目的是生成动态链接库供python代码加载调用（当然由c源码编译为动态链接

库的过程不是cython编译器的工作），以提高python程序的运行速度。使用cython

还可以快速应用python2代码到python3中。cython官网下载https://www.wendangku.net/doc/0115140610.html,/】

15.定义一个函数

a.def my_func(arg1, arg2):

# 函数执行代码块

【使用"def"关键字表达开始定义一个函数，函数名后接参数（不需指定类型），参

数个数不限。然后要加一个冒号。函数执行代码块是在同一长度缩进之下。】

b.def add(A=1,B=2): # 缺省变量（默认参数）

print "A:",A,"B:",B

调用时执行add()时A=1,B=2, 执行add(A=3) B默认为2, 执行add(2,3)时A=2,B=3, 执

行add(B=5) A为默认值1,用起来比较灵活

【NOTE：默认参数放最后较好！】def add(x=3,y):print x+y 这样y不指定会出错！改为add(y,x=3)

c.def my_func(arg, *args):

print arg, args

【*前缀表示从第2个参数起所有参数都会作为一个元组存在于args中，调用上面

这个函数就可以看到实现情况了。】例子见d

【*args后还可以有参数吗? 用fun(arg, *args, other_arg=default)】

d.def my_func(**args):

【**前缀表示从第1个参数起所有参数都会作为字典键值对存在于args中】

https://www.wendangku.net/doc/0115140610.html,mbda语句：用于创建新的函数对象，并在运行中返回它们，例如：

>>>twice = lambda s:s*2【参数：s，表达式：s*2，函数对象：twice】

>>>print twice(7)

14

可用lambda语句来定义函数，使它能够创建符合某种规则的函数，例如：

>>>def create_multiple_func(n): # 定义一个用来创建函数对象的函数

…return lambda s:s*n

>>>multiple_2 = create_multiple_func(2) # 创建"乘2"函数

>>>multiple_3 = create_multiple_func(3) # 创建"乘3"函数

>>>print multiple_2(7) # 调用"乘2"函数

14

>>>print multiple_3(7) # 调用"乘3"函数

21

【lambda语句只能用单个表达式来创建函数对象】

f.递归函数：(函数可以调用自己本身)

def factorial(n): # 一个求阶乘的函数

if (n==0 or n==1): return 1

else: return n*factorial(n-1)

print factorial(5) # 得到5! =5*4*3*2*1的值

g.函数返回值，关于return

h.

函数运行时，先找局部变量，再找全局变量，都找不到就报错！函数运行后，函数内的非全局变量变会被释放！如果函数内变量要用在函数外，用global声明！

16.关于python的类

a.定义类用关键字"class"，域和方法列在一个缩进块中。类中的方法都要有一个表示

自己的参数，通常定义为"self",如：

class Jason(继承的父类):

def __init__(self, name, age=29): # age=29是指定默认参数值

# 函数代码。实例化一个对象时，自动调用该函数，相当于构造函数【在不使用任何域的时候，可以不定义__init__，但通常都会定义】

def show(self, some): #参数中必须有self，代表类或实例本身

# 函数代码

obj = Jason('chiweixi', 28); # 参数传递给Jason类中__init__函数中除self之外的2

个参数，它们是用于实例化时接收的

b.类与对象的域

class People:

number = 0 # 定义类的域（类的属性），所有类的实例会共用！

def __init__(self, name):

https://www.wendangku.net/doc/0115140610.html, = name # 定义实例属性，可以在类中的任何函数中定义Jason = People('chiweixi') # 实例化（number和name都是实例属性，属性也叫成员变量）

类的域（类属性）可以这样引用：People.number，即通过类名就可以使用，即使没

有实例化任何对象；实例属性必须在将类实例化为对象之后，通过实例来引用，如

https://www.wendangku.net/doc/0115140610.html,。

c.类以"__"为前缀的，python认为它是私有的，外部调用会引发AttributeError，其它

情况均为公共。有个惯例，"_"为前缀标志只希望在类或对象中使用，但语法上仍是

公共。

d.关于继承（自己学）

e.模仿一个文件读写的例子（by tuweizhong）

一般我们用open(path).read()来读取一个文件，模拟一下

class open: # 也可以用class open(object):

def __init__(self,filePath):

self.filePath=filePath

print "I am working"

def read(self):# 读取文本

# 读内容的代码写这里

print "Finished!"

def write(self): #写文本

print "write something!"

在调用的时候就是open(path).read() # 发现了没，open的括号里面的参数写在__init__里面了, 当调用函数时，__init__会先执行，初始化一些操作。更多知识请搜索

17.命令行参数

import sys

print sys.argv # a list

首先进入脚本所在目录，然后运行python 脚本名称参数

例如把上面存为try.py 进入try.py脚本所在目录,运行python try.py 123 会得到

["try.py","123"] 这样我们就可以捕捉命令行传入的参数，进行处理

运行python try.py have a try 会得到

["try.py","have","a","try"]

18.引用和复制一个对象

python中，"a = b"表示的是对象a引用对象b，对象a本身没有单独分配内存空间(重要：不是复制！)，它指向计算机中存储对象b的内存。因此，要想将一个对象复制为另一个对象，不能简单地用等号操作，要使用其它的方法。如序列类的对象是（列表、元组）要使用切片操作符（即':'）来做复制："a = b[:]"。[建议学习相关模块: copy]

问题：字符串不是引用: a="tuweizhong";b=a 试试改变b的值看看a变不变，数组呢？

(字符串不是可变对象在改变时会重新申请内存, id(b)会发生变化)

b = a 其实b和a是指向同一个内存地址，可以用id(a)和id(b)来看是否相同。

c = a[:]是对a进行了浅拷贝(与c = copy.copy(a) 相当)，所以改变c时发现a没有受到影

响, 我们用同样的方式对d进行了浅拷贝，发现e改变的时候影响到了a，也就是说浅拷贝不会拷贝引用中的引用，如果想完全拷贝一份，应该用深拷贝：

import copy

e = copy.deepcopy(d) # 再尝试去改变e看看a和c会不会受到影响（答案是不会）

19.常用内建函数

print函数：

print 'name: {0}, age: {1}' .format (name, age) # 用format进行格式化

print('name:%s, age:%s' %(name,age)) # 用%s 进行格式化

raw_input()：# 还有input() , 它们有什么区别呢?试试看

A=raw_input("Please input string A")，获得的输入的字符串，并存在A中help()：

用于获取帮助或者自学！在python代码中，或者在python的shell中，如果已经

定义了某个函数"some_func()",那么只要输入"help(some_func)"就会进入help界面

下显示some_func的文档字符串。此时，按"q"键退出help界面。

range(a, b): # range([start=0,]end[,step=1]) # 中括号的意思是这个参数可以省,当有两个参数时意思是range(start,end)，step默认为1，自己指定step必须是三个参数！

>>>list_a = range(2, 5) # 初始化list_a, 相当于list_a=[2, 3, 4]

>>>list_a # 查看list_a内容

[2, 3, 4]

range(5)和range(0,5)和range(0,5,1)一样得到[0,1,2,3,4]没有5！(要前要不后，和切片操作一样，5是取不到的), range(1,15,4)就是[1,5,9,13], range(2,4)就是[2,3]，记住没有4

dir(模块名)：

列出模块定义的标识符，不指定模块名时列出当前模块的标识符。

len(): 返回对象中元素的个数。可被用于字符串、列表、元组，字典、集合等。

cmp (a, b): 比较a, b的值

当a>b, 返回1；a=b, 返回0，a

exec():

执行字符串行式的python命令，单词：execute:执行(一段代码)

>>>command = "print 'ok'"

>>>exec command

ok

eval():

提取字符串中内容，单词：evaluate:求值例如：

>>>print eval("3*2") # 试试eval("range(11)"),看看能得到什么

6

repr():

和str()类似，将对象转换为字符串形式返回，例如：

>>>v = ['a', 'b'] # 变量v初始化为列表['a', 'b']

>>>s = repr(v) # 将v转化为字符串"['a', 'b']"

>>>print s # 打印字符串

['a', 'b']

str对人友好，repr对python友好，也就是说，str是给人看的，repr是给编译器看的体会一下: eval(repr(object)) == object

zip(list_a, list_b):

用两个list生成一个对象是元组的list.举例说明，list_a=[1, 3, 5, 7]，list_b=[2, 4]，list_c=zip(a, b)。List_c实际为[(1, 2), (3, 4)]。zip()返回的list中对象的个数是两个参数list中对象个数少的那个，本例中2只有两个元素。

pow():

pow(a,b):返回a的b次幂，同a**b

pow(a,b,c)：返回(a的b次幂)除以c的余数，即(a**b) % c

file操作：

my_file = open('file.txt', 'w') # 在当前目录中创建文件名为"file.txt"的文件

my_file.write('something') # 向文件中写入数据

my_file.close() # 关闭文件

my_file = open('filename', 'r') # 只读方式打开

my_file.readline() # 从文件中读出一行

my_file.close() # 关闭文件

一行一行地操作一个文件

f=open("D:/test.txt") # 默认是"r",即读

for line in f: # 这里的f 不用写成f.readlines() f本身就可以迭代，更省内存print line # 一行一行地操作

f.close() # 处理完后关闭文件

20.常用模块功能：

【首先import导入所需模块，比如import os】

a.os 模块

os.system("终端命令1")：在python中执行"终端命令1"，如同在终端中执行

os.mkdir("/mnt/share"):创建目录"/mnt/share"

os.makedirs(r"C:/a/b/c") 是super-mkdir,创建所有子目录和可选权限, makedirs(name, mode=511)

os.sep :目录分隔符，使用它会提高代码可移植性。例："scripts"+os.sep+"hello.py"

https://www.wendangku.net/doc/0115140610.html,:正在使用的os平台字符串。window平台显示'nt'，linux/unix平台显示'posix'

os.getcwd():返回当前工作目录

os.getenv('PATH')：读取环境变量'PATH'的值

os.putenv(键，值)：设置环境变量。

os.listdir('/root')：列出指定目录下所有文件和目录名(不会递归显示子目录)

os.walk('/root') 一种遍历目录的方法,例如:( 不建议用os.path.walk, python 3.x中删掉了)

import os

def VisitDir(path):

# root为当前遍历目录,dirs为当前目录下的目录列表,files为当前目录下的文件列表

for root,dirs,files in os.walk(path):

for filename in files:

print os.path.join(root,filename)

os.remove('/root/hello.py')：删除指定文件

os.rename("a.txt","b.txt") 重命名

os.linesep：当前平台使用的行终止符。windows平台下'\r\n'，linux下'\n'，Mac下'\r'

os.path.split('/root/test/hello.py'):

将完整路径分开为目录名和文件名，返回一个2维元组，(目录字符串, 文件名字符串)，本例中返回('/root/test', 'hello.py')

os.path.isfile(路径)：判断所给路径是否为文件，返回True or False

os.path.isdir(路径)：判断所给路径是否为目录，返回True or False

os.path.exists("/mnt/share"):判断目录是否存在，返回True或False

os.path.getctime(path) 获取创建时间os.path.getsize(path) 获取文件大小,单位b

os.path.abspath(__file__): 在文件中运行，获取当前文件的绝对路径

os.path.dirname(path): 取得文件或目录路径的上一级

b.sys 模块

sys.exit(status):

相当于raise SystemExit(status)，用于退出正在运行的程序，即退出interpreter

【可用help(sys.exit)、help(SystemExit)查看详情】

sys.version:python版本信息，如"2.7.6……"

sys.stdin: 标准输入流

>>>my_str = sys.stdin.readline()

>>>print my_str

sys.stdout: 标准输出流

>>>sys.stdout.write('ok') # 终端会显示"ok"

sys.stderr: 标准错误流

>>>sys.stderr.write('ok) # 因为默认标准错误输出是终端，因此效果同上sys.path.append('/usr/test'):

代码执行时动态添加import搜索目录。仅当程序执行至该句时，目录'/usr/test'才会被加入sys.path变量中，程序退出后sys.path中不保存'/usr/test'目录。

sys.path.insert(index, '/usr/test'):

向sys.path变量中插入目录。将'/usr/test'目录插入到第index个目录之前，比如index

为0，sys.path.insert(0, '/usr/test')是将'/usr/test'插入到sys.path变量中作为第一个目

录，这样就可替换某个软件的系统自带版本。如将python3.3替换python2.7.6等。

c.time模块

time.sleep(2):系统延迟2秒，即暂停2秒

time.time(): 当前时间的秒数

time.ctime(): 当前时间字符串

time.strftime('%Y-%m-%d %H:%M:%S') 获取当前年月日时分秒

d.cPickle模块

用于存储对象至文件，及从中恢复。

>>>import cPickle

>>>cPickle.dump(object, file) # 将对象object 存储到文件file中

>>>my_obj = cPicke.load(file) # 从文件file中取出对象给my_obj

【可以"import cPickle as p"，这样代码中用p来代替cPickle，好处是只要将cPicke改成pickle，就切换了两个模块的使用】

【pickle是python脚本，cPickle是c代码生成的动态链接库，速度是pickle模块的1000倍】e.ctypes模块

ctypes模块用于在python中创建和操作c语言数据类型。我们通常会使用该模块加载动态链接库的功能，使用范例如下：

步骤1：编译动态链接库(some.c-->some.so)

gcc some.c –fPIC –shared –I /usr/include –o some.so

【参数说明】

-fPIC: 编译为位置独立的代码，不用此项则编译的代码是位置相关的

-shared: 指定生成动态链接库

-I：some.c中"#include"要链接非默认目录的话，指定该目录。本例为：/usr/include 步骤2：使用编译好的动态链接库some.so

from ctypes import cdll # linux系统下,导入cdll子模块，window下用导入windll

my_libc = cdll.LoadLibrary("./some.so") # 加载当前文件夹下的"some.so"动态链接库

my_libc.hello() # 调用some.so的hello()函数

【在windows系统中，将"cdll"替换成"windll"就可以了。当然加载的文件扩展名应是".dll"】

f.复制和移动文件

import shutil

shutil.copyfile("a.txt","b.txt") # 将a.txt复制一份，名称为b.txt

shutil.move(path,newpath) # 移动文件夹或文件

g.其它重要模块：datetime, json, sqlite3,等，自学