1、安装python编译器 版本：Python2.7比较普遍，Python不是向下兼容的软件，因此Python3.x有些东西不好找资料
|
1
2
3
|
total
=
item_one
+
\
item_two
+
\
item_three
|
|
1
2
|
days
=
[
'Monday'
,
'Tuesday'
,
'Wednesday'
,
'Thursday'
,
'Friday'
]
|
|
1
2
3
4
|
word
=
'word'
sentence
=
"This is a sentence."
paragraph
=
"""This is a paragraph. It is
made up of multiple lines and sentences."""
|
1、在DOS中运行python： python test.py
2、输入：
>>> name = raw_input()
Michaelname = raw_input('please enter your name: ')
print 'hello,', name3、输出：print会依次打印每个字符串，遇到逗号“,”会输出一个空格：
>>> print 'The quick brown fox', 'jumps over', 'the lazy dog'
The quick brown fox jumps over the lazy dog
4、变量赋值用：=
多个变量赋值:
|
1
|
a, b, c
=
1
,
2
,
"john"
|
5、Python有五个标准的数据类型：
5.1.Numbers（数字）：不可改变的数据类型，这意味着改变数字数据类型会分配一个新的对象。
|
1
2
|
var1
=
1
var2
=
10
|
|
1
2
|
del
var
del
var_a, var_b
|
5.2.String（字符串）
#!/usr/bin/python
str
=
"Hello World!"
print
str
# 输出完整字符串
print
str
[
0
]
# 输出字符串中的第一个字符
print
str
[
2
:
5
]
# 输出字符串中第三个至第五个之间的字符串
print
str
[
2
:]
# 输出从第三个字符开始的字符串
print
str
*
2
# 输出字符串两次
print
str
+
"TEST"
# 输出连接的字符串
|
以上实例输出结果：
|
1
2
3
4
5
6
|
Hello World!
H
llo
llo World!
Hello World!Hello World!
Hello World!TEST
|
5.3.List（列表）
加号（+）是列表连接运算符，星号（*）是重复操作。如下实例：
|
1
2
3
4
5
6
7
8
9
10
11
|
#!/usr/bin/python
List
=
[
"abcd"
,
786
,
2.23
,
"john"
,
70.2
]
tinylist
=
[
123
,
"john"
]
print
List
# 输出完整列表
print
List
[
0
]
# 输出列表的第一个元素
print
List
[
1
:
3
]
# 输出第二个至第三个的元素
print
List
[
2
:]
# 输出从第三个开始至列表末尾的所有元素
print
tinylist
*
2
# 输出列表两次
print
List
+
tinylist
# 打印组合的列表
|
以上实例输出结果：
|
1
2
3
4
5
6
|
[
"abcd"
,
786
,
2.23
,
"john"
,
70.200000000000003
]
abcd
[
786
,
2.23
]
[
2.23
,
"john"
,
70.200000000000003
]
[
123
,
"john"
,
123
,
"john"
]
[
"abcd"
,
786
,
2.23
,
"john"
,
70.200000000000003
,
123
,
"john"
]
|
5.4.Tuple（元组）
以下是元组无效的，因为元组是不允许更新的。而列表是允许更新的：
|
1
2
3
4
5
6
|
#!/usr/bin/python
Tuple
=
(
"abcd"
,
786
,
2.23
,
"john"
,
70.2
)
List
=
[
"abcd"
,
786
,
2.23
,
"john"
,
70.2
]
Tuple
[
2
]
=
1000
# 错误！元组中是非法应用
List
[
2
]
=
1000
# 正确！列表中是合法应用
|
5.5.Dictionary（字典）
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
#!/usr/bin/python
dict
=
{}
dict
[
"one"
]
=
"This is one"
dict
[
2
]
=
"This is two"
tinydict
=
{
"name"
:
"john"
,
"code"
:
6734
,
"dept"
:
"sales"
}
print
dict
[
"one"
]
# 输出键为"one" 的值
print
dict
[
2
]
# 输出键为 2 的值
print
tinydict
# 输出完整的字典
print
tinydict.keys()
# 输出所有键
print
tinydict.values()
# 输出所有值
|
输出结果为：
|
1
|
This
is
one
This
is
two
{
"dept"
:
"sales"
,
"code"
:
6734
,
"name"
:
"john"
}
[
"dept"
,
"code"
,
"name"
]
[
"sales"
,
6734
,
"john"
]
|
6、数据类型转换
| 函数 | 描述 |
|---|---|
| int(x [,base]) |
将x转换为一个整数 |
| long(x [,base] ) |
将x转换为一个长整数 |
| float(x) |
将x转换到一个浮点数 |
| complex(real [,imag]) |
创建一个复数 |
| str(x) |
将对象 x 转换为字符串 |
| repr(x) |
将对象 x 转换为表达式字符串 |
| eval(str) |
用来计算在字符串中的有效Python表达式,并返回一个对象 |
| tuple(s) |
将序列 s 转换为一个元组 |
| list(s) |
将序列 s 转换为一个列表 |
| set(s) |
转换为可变集合 |
| dict(d) |
创建一个字典。d 必须是一个序列 (key,value)元组。 |
| frozenset(s) |
转换为不可变集合 |
| chr(x) |
将一个整数转换为一个字符 |
| unichr(x) |
将一个整数转换为Unicode字符 |
| ord(x) |
将一个字符转换为它的整数值 |
| hex(x) |
将一个整数转换为一个十六进制字符串 |
| oct(x) |
将一个整数转换为一个八进制字符串 |
7、运算符
7.1.Python算术运算符
| 运算符 | 描述 | 实例 |
|---|---|---|
| + | 加 - 两个对象相加 | a + b 输出结果 30 |
| - | 减 - 得到负数或是一个数减去另一个数 | a - b 输出结果 -10 |
| * | 乘 - 两个数相乘或是返回一个被重复若干次的字符串 | a * b 输出结果 200 |
| / | 除 - x除以y | b / a 输出结果 2 |
| % | 取模 - 返回除法的余数 | b % a 输出结果 0 |
| ** | 幂 - 返回x的y次幂 | a**b 输出结果 20 |
| // | 取整除 - 返回商的整数部分 | 9//2 输出结果 4 , 9.0//2.0 输出结果 4.0 |
7.2.比较运算符
以下假设变量a为10，变量b为20：
| 运算符 | 描述 | 实例 |
|---|---|---|
| == | 等于 - 比较对象是否相等 | (a == b) 返回 False。 |
| != | 不等于 - 比较两个对象是否不相等 | (a != b) 返回 true. |
| <> | 不等于 - 比较两个对象是否不相等 | (a <> b) 返回 true。这个运算符类似 != 。 |
| > | 大于 - 返回x是否大于y | (a > b) 返回 False。 |
| < | 小于 - 返回x是否小于y。所有比较运算符返回1表示真，返回0表示假。这分别与特殊的变量True和False等价。注意，这些变量名的大写。 | (a < b) 返回 true。 |
| >= | 大于等于 - 返回x是否大于等于y。 | (a >= b) 返回 False。 |
| <= | 小于等于 - 返回x是否小于等于y。 | (a <= b) 返回 true。 |
7.3.Python赋值运算符
| 运算符 | 描述 | 实例 |
|---|---|---|
| = | 简单的赋值运算符 | c = a + b 将 a + b 的运算结果赋值为 c |
| += | 加法赋值运算符 | c += a 等效于 c = c + a |
| -= | 减法赋值运算符 | c -= a 等效于 c = c - a |
| *= | 乘法赋值运算符 | c *= a 等效于 c = c * a |
| /= | 除法赋值运算符 | c /= a 等效于 c = c / a |
| %= | 取模赋值运算符 | c %= a 等效于 c = c % a |
| **= | 幂赋值运算符 | c **= a 等效于 c = c ** a |
| //= | 取整除赋值运算符 | c //= a 等效于 c = c // a |
7.4.Python位运算符
| 运算符 | 描述 | 实例 |
|---|---|---|
| & | 按位与运算符 | (a & b) 输出结果 12 ，二进制解释： 0000 1100 |
| | | 按位或运算符 | (a | b) 输出结果 61 ，二进制解释： 0011 1101 |
| ^ | 按位异或运算符 | (a ^ b) 输出结果 49 ，二进制解释： 0011 0001 |
| ~ | 按位取反运算符 | (~a ) 输出结果 -61 ，二进制解释： 1100 0011， 在一个有符号二进制数的补码形式。 |
| << | 左移动运算符 | a << 2 输出结果 240 ，二进制解释： 1111 0000 |
| >> | 右移动运算符 | a >> 2 输出结果 15 ，二进制解释： 0000 1111 |
7.5.Python逻辑运算符
| 运算符 | 描述 | 实例 |
|---|---|---|
| and | 布尔"与" - 如果x为False，x and y返回False，否则它返回y的计算值。 | (a and b) 返回 true。 |
| or | 布尔"或" - 如果x是True，它返回True，否则它返回y的计算值。 | (a or b) 返回 true。 |
| not | 布尔"非" - 如果x为True，返回False。如果x为False，它返回True。 | not(a and b) 返回 false。 |
7.6.Python成员运算符
| 运算符 | 描述 | 实例 |
|---|---|---|
| in | 如果在指定的序列中找到值返回True，否则返回False。 | x 在 y序列中 , 如果x在y序列中返回True。 |
| not in | 如果在指定的序列中没有找到值返回True，否则返回False。 | x 不在 y序列中 , 如果x不在y序列中返回True。 |
7.7.Python身份运算符
| 运算符 | 描述 | 实例 |
|---|---|---|
| is | is是判断两个标识符是不是引用自一个对象 | x is y, 如果 id(x) 等于 id(y) , is 返回结果 1 |
| is not | is not是判断两个标识符是不是引用自不同对象 | x is not y, 如果 id(x) 不等于 id(y). is not 返回结果 1 |
7.8.Python运算符优先级
| 运算符 | 描述 |
|---|---|
| ** | 指数 (最高优先级) |
| ~ + - | 按位翻转, 一元加号和减号 (最后两个的方法名为 +@ 和 -@) |
| * / % // | 乘，除，取模和取整除 |
| + - | 加法减法 |
| >> << | 右移，左移运算符 |
| & | 位 'AND' |
| ^ | | 位运算符 |
| <= < > >= | 比较运算符 |
| <> == != | 等于运算符 |
| = %= /= //= -= += *= **= | 赋值运算符 |
| is is not | 身份运算符 |
| in not in | 成员运算符 |
| not or and | 逻辑运算符 |
8、语句
8.1.条件语句
- Python 编程中 if 语句用于控制程序的执行，基本形式为：
|
1
2
3
4
|
if
判断条件：
执行语句……
else
：
执行语句……
|
其中"判断条件"成立时（非零），则执行后面的语句，而执行内容可以多行，以缩进来区分表示同一范围。
- 当判断条件为多个值是，可以使用以下形式：
|
1
2
3
4
5
6
7
8
|
if
判断条件
1
:
执行语句
1
……
elif
判断条件
2
:
执行语句
2
……
elif
判断条件
3
:
执行语句
3
……
else
:
执行语句
4
……
|
- python 并不支持 switch 语句，所以多个条件判断，只能用 elif 来实现，如果判断需要多个条件需同时判断时，可以使用 or （或），表示两个条件有一个成立时判断条件成功；使用 and （与）时，表示只有两个条件同时成立的情况下，判断条件才成功。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
|
# 例3：if语句多个条件
num
=
9
if
num >
=
0
and
num <
=
10
:
# 判断值是否在0~10之间
print
'hello'
>>> hello
# 输出结果
num
=
10
if
num <
0
or
num >
10
:
# 判断值是否在小于0或大于10
print
'hello'
else
:
print
'undefine'
>>> undefine
# 输出结果
num
=
8
# 判断值是否在0~5或者10~15之间
if
(num >
=
0
and
num <
=
5
)
or
(num >
=
10
and
num <
=
15
):
print
'hello'
else
:
print
'undefine'
>>> undefine
# 输出结果
|
当if有多个条件时可使用括号来区分判断的先后顺序，括号中的判断优先执行，此外 and 和 or 的优先级低于>（大于）、<（小于）等判断符号，即大于和小于在没有括号的情况下会比与或要优先判断。
8.2 循环语句
Python提供了for循环和while循环（在Python中没有do..while循环）:
| 循环类型 | 描述 |
|---|---|
| 在给定的判断条件为 true 时执行循环体，否则退出循环体。 | |
| for 循环 | 重复执行语句 |
- while 语句用于循环执行程序，即在某条件下，循环执行某段程序，以处理需要重复处理的相同任务。其基本形式为：
|
1
2
|
while
判断条件：
执行语句……
|
执行语句可以是单个语句或语句块。判断条件可以是任何表达式，任何非零、或非空（null）的值均为true。
当判断条件假false时，循环结束。
- for循环的语法格式如下：
|
1
2
|
for
iterating_var
in
sequence:
statements(s)
|
实例：
|
1
2
3
4
5
6
7
8
9
10
|
#!/usr/bin/python
for
letter
in
'Python'
:
# First Example
print
'Current Letter :'
, letter
fruits
=
[
'banana'
,
'apple'
,
'mango'
]
for
fruit
in
fruits:
# Second Example
print
'Current fruit :'
, fruit
print
"Good bye!"
|
以上实例输出结果:
|
1
2
3
4
5
6
7
8
9
10
|
Current Letter : P
Current Letter : y
Current Letter : t
Current Letter : h
Current Letter : o
Current Letter : n
Current fruit : banana
Current fruit : apple
Current fruit : mango
Good bye!
|
另外一种执行循环的遍历方式是通过索引。
- 循环使用 else 语句
在 python 中，for … else 表示这样的意思，for 中的语句和普通的没有区别，else 中的语句会在循环正常执行完（即 for 不是通过 break 跳出而中断的）的情况下执行，while … else 也是一样。
|
1
2
3
4
5
6
7
8
|
#!/usr/bin/python
count
=
0
while
count <
5
:
print
count,
" is less than 5"
count
=
count
+
1
else
:
print
count,
" is not less than 5"
|
以上实例输出结果为：
|
1
2
3
4
5
6
|
0
is
less than
5
1
is
less than
5
2
is
less than
5
3
is
less than
5
4
is
less than
5
5
is
not
less than
5
|
- 循环控制语句
循环控制语句可以更改语句执行的顺序。Python支持以下循环控制语句：
| 控制语句 | 描述 |
|---|---|
| break 语句 | 在语句块执行过程中终止循环，并且跳出整个循环 |
| continue 语句 | 在语句块执行过程中终止当前循环，跳出该次循环，执行下一次循环。 |
| pass 语句 | pass是空语句，是为了保持程序结构的完整性。 |
Python 语言 pass 语句语法格式如下：
|
1
|
pass
|
实例：
|
1
2
3
4
5
6
7
8
9
|
#!/usr/bin/python
for
letter
in
'Python'
:
if
letter
=
=
'h'
:
pass
print
'This is pass block'
print
'Current Letter :'
, letter
print
"Good bye!"
|
以上实例执行结果：
|
1
2
3
4
5
6
7
8
|
Current Letter : P
Current Letter : y
Current Letter : t
This is pass block
Current Letter : h
Current Letter : o
Current Letter : n
Good bye!
|
9、用户自定义函数
9.1函数定义
你可以定义一个由自己想要功能的函数，以下是简单的规则：
-
函数代码块以def关键词开头，后接函数标识符名称和圆括号()。
-
任何传入参数和自变量必须放在圆括号中间。圆括号之间可以用于定义参数。
-
函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
-
函数内容以冒号起始，并且缩进。
-
Return[expression]结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回 None。
|
1
2
3
4
|
def
functionname( parameters ):
"函数_文档字符串"
function_suite
return
[expression]
|
默认情况下，参数值和参数名称是按函数声明中定义的的顺序匹配起来的。
以下为一个简单的Python函数，它将一个字符串作为传入参数，再打印到标准显示设备上。
|
1
2
3
|
def
printme( string ):
"打印传入的字符串到标准显示设备上"
print
string
|
9.2函数调用
定义一个函数只给了函数一个名称，指定了函数里包含的参数，和代码块结构。
这个函数的基本结构完成以后，你可以通过另一个函数调用执行，也可以直接从Python提示符执行。
如下实例调用了printme（）函数：
|
1
2
3
4
5
6
7
8
9
10
|
#!/usr/bin/python
# Function definition is here
def
printme( string ):
"打印任何传入的字符串"
print
string
# Now you can call printme function
printme(
"我要调用用户自定义函数!"
);
printme(
"再次调用同一函数"
);
|
以上实例输出结果：
|
1
2
|
我要调用用户自定义函数!
再次调用同一函数
|
所有参数（自变量）在Python里都是按引用传递。如果你在函数里修改了参数，那么在调用这个函数的函数里，原始的参数也被改变了。例如：
|
1
2
3
4
5
6
7
8
9
10
11
12
|
#!/usr/bin/python
# 可写函数说明
def
changeme( mylist ):
"修改传入的列表"
mylist.append([
1
,
2
,
3
,
4
])
print
"函数内取值: "
, mylist
# 调用changeme函数
mylist
=
[
10
,
20
,
30
];
changeme( mylist );
print
"函数外取值: "
, mylist
|
传入函数的和在末尾添加新内容的对象用的是同一个引用。故输出结果如下：
|
1
2
|
函数内取值: [
10
,
20
,
30
, [
1
,
2
,
3
,
4
]]
函数外取值: [
10
,
20
,
30
, [
1
,
2
,
3
,
4
]]
|
9.3参数
以下是调用函数时可使用的正式参数类型：
-
必备参数
-
命名参数
-
缺省参数
-
不定长参数
- 不定长参数
你可能需要一个函数能处理比当初声明时更多的参数。这些参数叫做不定长参数，这种参数声明时不会命名。基本语法如下：
|
1
2
3
4
|
def
functionname([formal_args,]
*
var_args_tuple ):
"函数_文档字符串"
function_suite
return
[expression]
|
加了星号（*）的变量名会存放所有未命名的变量参数。选择不多传参数也可。如下实例：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
#!/usr/bin/python
# 可写函数说明
def
printinfo( arg1,
*
vartuple ):
"打印任何传入的参数"
print
"输出: "
print
arg1
for
var
in
vartuple:
print
var
# 调用printinfo 函数
printinfo(
10
)
printinfo(
70
,
60
,
50
)
|
以上实例输出结果：
|
1
2
3
4
5
6
|
输出:
10
输出:
70
60
50
|
9.4匿名函数
用lambda关键词能创建小型匿名函数。这种函数得名于省略了用def声明函数的标准步骤。
-
Lambda函数能接收任何数量的参数但只能返回一个表达式的值，同时不能包含命令或多个表达式。
-
匿名函数不能直接调用print，因为lambda需要一个表达式。
-
lambda函数拥有自己的名字空间，且不能访问自有参数列表之外或全局名字空间里的参数。
-
虽然lambda函数看起来只能写一行，却不等同于C或C++的内联函数，后者的目的是调用小函数时不占用栈内存从而增加运行效率。
语法
lambda函数的语法只包含一个语句，如下：
|
1
|
lambda
[arg1 [,arg2,.....argn]]:expression
|
如下实例：
|
1
2
3
4
5
6
7
8
|
#!/usr/bin/python
#可写函数说明
sum
=
lambda
arg1, arg2: arg1
+
arg2
#调用sum函数
print
"Value of total : "
,
sum
(
10
,
20
)
print
"Value of total : "
,
sum
(
20
,
20
)
|
以上实例输出结果：
|
1
2
|
Value of total :
30
Value of total :
40
|
9.5return语句
return语句[表达式]退出函数，选择性地向调用方返回一个表达式。不带参数值的return语句返回None。之前的例子都没有示范如何返回数值，下例便告诉你怎么做：
|
1
2
3
4
5
6
7
8
9
10
11
12
|
#!/usr/bin/python
# 可写函数说明
def
sum
( arg1, arg2 ):
# 返回2个参数的和."
total
=
arg1
+
arg2
print
"Inside the function : "
, total
return
total
# 调用sum函数
total
=
sum
(
10
,
20
);
print
"Outside the function : "
, total
|
以上实例输出结果：
|
1
2
|
Inside the function :
30
Outside the function :
30
|
9.6变量作用域
一个程序的所有的变量并不是在哪个位置都可以访问的。访问权限决定于这个变量是在哪里赋值的。
变量的作用域决定了在哪一部分程序你可以访问哪个特定的变量名称。两种最基本的变量作用域如下：
-
全局变量
-
局部变量
变量和局部变量
定义在函数内部的变量拥有一个局部作用域，定义在函数外的拥有全局作用域。
局部变量只能在其被声明的函数内部访问，而全局变量可以在整个程序范围内访问。调用函数时，所有在函数内声明的变量名称都将被加入到作用域中。如下实例：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
#!/usr/bin/python
total
=
0
;
# This is global variable.
# 可写函数说明
def
sum
( arg1, arg2 ):
#返回2个参数的和."
total
=
arg1
+
arg2;
# total在这里是局部变量.
print
"Inside the function local total : "
, total
return
total;
#调用sum函数
sum
(
10
,
20
);
print
"Outside the function global total : "
, total
|
以上实例输出结果：
|
1
2
|
Inside the function local total :
30
Outside the function
global
total :
0
|
10 Python模块
例子
一个叫做aname的模块里的Python代码一般都能在一个叫aname.py的文件中找到。下例是个简单的模块support.py。
|
1
2
|
def
print_func( par ):
print
"Hello : "
, par
|
10.1 import 语句
想使用Python源文件，只需在另一个源文件里执行import语句，语法如下：
|
1
|
import
module1[, module2[,... moduleN]
|
当解释器遇到import语句，如果模块在当前的搜索路径就会被导入。
搜索路径是一个解释器会先进行搜索的所有目录的列表。如想要导入模块hello.py，需要把命令放在脚本的顶端：
|
1
2
3
4
5
6
7
|
#!/usr/bin/python
# 导入模块
import
support
# 现在可以调用模块里包含的函数了
support.print_func(
"Zara"
)
|
以上实例输出结果：
|
1
|
Hello : Zara
|
一个模块只会被导入一次，不管你执行了多少次import。这样可以防止导入模块被一遍又一遍地执行。
- From…import 语句
Python的from语句让你从模块中导入一个指定的部分到当前命名空间中。语法如下：
|
1
|
from
modname
import
name1[, name2[, ... nameN]]
|
例如，要导入模块fib的fibonacci函数，使用如下语句：
|
1
|
from
fib
import
fibonacci
|
这个声明不会把整个fib模块导入到当前的命名空间中，它只会将fib里的fibonacci单个引入到执行这个声明的模块的全局符号表。
- From…import * 语句
把一个模块的所有内容全都导入到当前的命名空间也是可行的，只需使用如下声明：
|
1
|
from
mod_name
import
*
|
这提供了一个简单的方法来导入一个模块中的所有项目。然而这种声明不该被过多地使用。
- reload()函数
当一个模块被导入到一个脚本，模块顶层部分的代码只会被执行一次。
因此，如果你想重新执行模块里顶层部分的代码，可以用reload()函数。该函数会重新导入之前导入过的模块。语法如下：
|
1
|
reload
(module_name)
|
在这里，module_name要直接放模块的名字，而不是一个字符串形式。比如想重载hello模块，如下：
|
1
|
reload
(hello)
|
10.2 定位模块
当你导入一个模块，Python解析器对模块位置的搜索顺序是：
-
当前目录
-
如果不在当前目录，Python则搜索在shell变量PYTHONPATH下的每个目录。
-
如果都找不到，Python会察看默认路径。UNIX下，默认路径一般为/usr/local/lib/python/
模块搜索路径存储在system模块的sys.path变量中。变量里包含当前目录，PYTHONPATH和由安装过程决定的默认目录。
- PYTHONPATH变量
作为环境变量，PYTHONPATH由装在一个列表里的许多目录组成。PYTHONPATH的语法和shell变量PATH的一样。
在Windows系统，典型的PYTHONPATH如下：
|
1
|
set
PYTHONPATH
=
c:\python20\lib;
|
在UNIX系统，典型的PYTHONPATH如下：
|
1
|
set
PYTHONPATH
=
/
usr
/
local
/
lib
/
python
|
10.3 命名空间和作用域
一个Python表达式可以访问局部命名空间和全局命名空间里的变量。如果一个局部变量和一个全局变量重名，则局部变量会覆盖全局变量。因此，如果要给全局变量在一个函数里赋值，必须使用global语句。
global VarName的表达式会告诉Python， VarName是一个全局变量，这样Python就不会在局部命名空间里寻找这个变量了。
例如，我们在全局命名空间里定义一个变量money。我们再在函数内给变量money赋值，然后Python会假定money是一个局部变量。然而，我们并没有在访问前声明一个局部变量money，结果就是会出现一个UnboundLocalError的错误。取消global语句的注释就能解决这个问题。
|
1
2
3
4
5
6
7
8
9
10
11
|
#!/usr/bin/python
Money
=
2000
def
AddMoney():
# 想改正代码就取消以下注释:
# global Money
Money
=
Money
+
1
print
Money
AddMoney()
print
Money
|
- globals()和locals()函数
根据调用地方的不同，globals()和locals()函数可被用来返回全局和局部命名空间里的名字。
如果在函数内部调用locals()，返回的是所有能在该函数里访问的命名。如果在函数内部调用globals()，返回的是所有在该函数里能访问的全局名字。两个函数的返回类型都是字典。所以名字们能用keys()函数摘取。
- dir()函数
dir()函数一个排好序的字符串列表，内容是一个模块里定义过的名字。
返回的列表容纳了在一个模块里定义的所有模块，变量和函数。如下一个简单的实例：
|
1
2
3
4
5
6
7
8
|
#!/usr/bin/python
# 导入内置math模块
import
math
content
=
dir
(math)
print
content;
|
以上实例输出结果：
|
1
2
3
4
5
|
[
'__doc__'
,
'__file__'
,
'__name__'
,
'acos'
,
'asin'
,
'atan'
,
'atan2'
,
'ceil'
,
'cos'
,
'cosh'
,
'degrees'
,
'e'
,
'exp'
,
'fabs'
,
'floor'
,
'fmod'
,
'frexp'
,
'hypot'
,
'ldexp'
,
'log'
,
'log10'
,
'modf'
,
'pi'
,
'pow'
,
'radians'
,
'sin'
,
'sinh'
,
'sqrt'
,
'tan'
,
'tanh'
]
|
在这里，特殊字符串变量__name__指向模块的名字，__file__指向该模块的导入文件名。
10.4 Python中的包
包是一个分层次的文件目录结构，它定义了一个由模块及子包，和子包下的子包等组成的Python的应用环境。
考虑一个在Phone目录下的pots.py文件。这个文件有如下源代码：
|
1
2
3
4
|
#!/usr/bin/python
def
Pots():
print
"I'm Pots Phone"
|
同样地，我们有另外两个保存了不同函数的文件：
-
Phone/Isdn.py 含有函数Isdn()
-
Phone/G3.py 含有函数G3()
现在，在Phone目录下创建file: __init__.py：
-
Phone/__init__.py
当你导入Phone时，为了能够使用所有函数，你需要在__init__.py里使用显式的导入语句，如下：
|
1
2
3
|
from
Pots
import
Pots
from
Isdn
import
Isdn
from
G3
import
G3
|
当你把这些代码添加到__init__.py之后，导入Phone包的时候这些类就全都是可用的了。
|
1
2
3
4
5
6
7
8
|
#!/usr/bin/python
# Now import your Phone Package.
import
Phone
Phone.Pots()
Phone.Isdn()
Phone.G3()
|
以上实例输出结果：
|
1
2
3
|
I'm Pots Phone
I'm 3G Phone
I'm ISDN Phone
|
如上，为了举例，我们只在每个文件里放置了一个函数，但其实你可以放置许多函数。你也可以在这些文件里定义Python的类，然后为这些类建一个包。
11 Python 文件I/O
11.1 print打印到屏幕
11.2 读取键盘输入
- raw_input函数
raw_input([prompt]) 函数从标准输入读取一个行，并返回一个字符串（去掉结尾的换行符）：
|
1
2
3
4
|
#!/usr/bin/python
str
=
raw_input
(
"Enter your input: "
);
print
"Received input is : "
,
str
|
这将提示你输入任意字符串，然后在屏幕上显示相同的字符串。当我输入"Hello Python！"，它的输出如下：
|
1
2
|
Enter your
input
: Hello Python
Received
input
is
: Hello Python
|
- input函数
input([prompt]) 函数和raw_input([prompt]) 函数基本可以互换，但是input会假设你的输入是一个有效的Python表达式，并返回运算结果。
|
1
2
3
4
|
#!/usr/bin/python
str
=
input
(
"Enter your input: "
);
print
"Received input is : "
,
str
|
这会产生如下的对应着输入的结果：
|
1
2
|
Enter your
input
: [x
*
5
for
x
in
range
(
2
,
10
,
2
)]
Recieved
input
is
: [
10
,
20
,
30
,
40
]
|
11.3打开和关闭文件
- open函数
你必须先用Python内置的open()函数打开一个文件，创建一个file对象，相关的辅助方法才可以调用它进行读写。
语法：
|
1
|
file
object
=
open
(file_name [, access_mode][, buffering])
|
各个参数的细节如下：
- file_name：file_name变量是一个包含了你要访问的文件名称的字符串值。
- access_mode：access_mode决定了打开文件的模式：只读，写入，追加等。所有可取值见如下的完全列表。这个参数是非强制的，默认文件访问模式为只读(r)。
- buffering:如果buffering的值被设为0，就不会有寄存。如果buffering的值取1，访问文件时会寄存行。如果将buffering的值设为大于1的整数，表明了这就是的寄存区的缓冲大小。如果取负值，寄存区的缓冲大小则为系统默认。
不同模式打开文件的完全列表：
| 模式 | 描述 |
|---|---|
| r | 以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。 |
| rb | 以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。这是默认模式。 |
| r+ | 打开一个文件用于读写。文件指针将会放在文件的开头。 |
| rb+ | 以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。 |
| w | 打开一个文件只用于写入。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。 |
| wb | 以二进制格式打开一个文件只用于写入。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。 |
| w+ | 打开一个文件用于读写。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。 |
| wb+ | 以二进制格式打开一个文件用于读写。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。 |
| a | 打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。 |
| ab | 以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。 |
| a+ | 打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在，创建新文件用于读写。 |
| ab+ | 以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。如果该文件不存在，创建新文件用于读写。 |
- File对象的属性
一个文件被打开后，你有一个file对象，你可以得到有关该文件的各种信息。
以下是和file对象相关的所有属性的列表：
| 属性 | 描述 |
|---|---|
| file.closed | 返回true如果文件已被关闭，否则返回false。 |
| file.mode | 返回被打开文件的访问模式。 |
| file.name | 返回文件的名称。 |
| file.softspace | 如果用print输出后，必须跟一个空格符，则返回false。否则返回true。 |
如下实例：
|
1
2
3
4
5
6
7
8
|
#!/usr/bin/python
# 打开一个文件
fo
=
open
(
"foo.txt"
,
"wb"
)
print
"Name of the file: "
, fo.name
print
"Closed or not : "
, fo.closed
print
"Opening mode : "
, fo.mode
print
"Softspace flag : "
, fo.softspace
|
以上实例输出结果：
|
1
2
3
4
|
Name of the
file
: foo.txt
Closed
or
not
:
False
Opening mode : wb
Softspace flag :
0
|
- Close()方法
File对象的close（）方法刷新缓冲区里任何还没写入的信息，并关闭该文件，这之后便不能再进行写入。
当一个文件对象的引用被重新指定给另一个文件时，Python会关闭之前的文件。用close（）方法关闭文件是一个很好的习惯。
语法：
|
1
|
fileObject.close();
|
例子：
|
1
2
3
4
5
6
7
8
|
#!/usr/bin/python
# 打开一个文件
fo
=
open
(
"foo.txt"
,
"wb"
)
print
"Name of the file: "
, fo.name
# 关闭打开的文件
fo.close()
|
以上实例输出结果：
|
1
|
Name of the
file
: foo.txt
|
11.4 读写文件
file对象提供了一系列方法，能让我们的文件访问更轻松。来看看如何使用read()和write()方法来读取和写入文件。
- Write()方法
Write()方法可将任何字符串写入一个打开的文件。需要重点注意的是，Python字符串可以是二进制数据，而不是仅仅是文字。
Write()方法不在字符串的结尾不添加换行符('\n')：
语法：
|
1
|
fileObject.write(string);
|
在这里，被传递的参数是要写入到已打开文件的内容。
例子：
|
1
2
3
4
5
6
7
8
|
#!/usr/bin/python
# 打开一个文件
fo
=
open
(
"/tmp/foo.txt"
,
"wb"
)
fo.write(
"Python is a great language.\nYeah its great!!\n"
);
# 关闭打开的文件
fo.close()
|
上述方法会创建foo.txt文件，并将收到的内容写入该文件，并最终关闭文件。如果你打开这个文件，将看到以下内容:
|
1
2
|
Python
is
a great language.
Yeah its great!!
|
- read()方法
read（）方法从一个打开的文件中读取一个字符串。需要重点注意的是，Python字符串可以是二进制数据，而不是仅仅是文字。
语法：
|
1
|
fileObject.read([count]);
|
在这里，被传递的参数是要从已打开文件中读取的字节计数。该方法从文件的开头开始读入，如果没有传入count，它会尝试尽可能多地读取更多的内容，很可能是直到文件的末尾。
例子：
就用我们上面创建的文件foo.txt。
|
1
2
3
4
5
6
7
8
|
#!/usr/bin/python
# 打开一个文件
fo
=
open
(
"/tmp/foo.txt"
,
"r+"
)
str
=
fo.read(
10
);
print
"Read String is : "
,
str
# 关闭打开的文件
fo.close()
|
以上实例输出结果：
|
1
|
Read String
is
: Python
is
|
- 文件位置
Tell()方法告诉你文件内的当前位置；换句话说，下一次的读写会发生在文件开头这么多字节之后：
seek（offset [,from]）方法改变当前文件的位置。Offset变量表示要移动的字节数。From变量指定开始移动字节的参考位置。
如果from被设为0，这意味着将文件的开头作为移动字节的参考位置。如果设为1，则使用当前的位置作为参考位置。如果它被设为2，那么该文件的末尾将作为参考位置。
例子：
就用我们上面创建的文件foo.txt。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
#!/usr/bin/python
# 打开一个文件
fo
=
open
(
"/tmp/foo.txt"
,
"r+"
)
str
=
fo.read(
10
);
print
"Read String is : "
,
str
# 查找当前位置
position
=
fo.tell();
print
"Current file position : "
, position
# 把指针再次重新定位到文件开头
position
=
fo.seek(
0
,
0
);
str
=
fo.read(
10
);
print
"Again read String is : "
,
str
# 关闭打开的文件
fo.close()
|
以上实例输出结果：
|
1
2
3
|
Read String
is
: Python
is
Current
file
position :
10
Again read String
is
: Python
is
|
11.5 重命名和删除文件
Python的os模块提供了帮你执行文件处理操作的方法，比如重命名和删除文件。要使用这个模块，你必须先导入它，然后可以调用相关的各种功能。
- rename()方法
rename()方法需要两个参数，当前的文件名和新文件名。
语法：
|
1
|
os.rename(current_file_name, new_file_name)
|
例子：
下例将重命名一个已经存在的文件test1.txt。
|
1
2
3
4
5
|
#!/usr/bin/python
import
os
# 重命名文件test1.txt到test2.txt。
os.rename(
"test1.txt"
,
"test2.txt"
)
|
- remove()方法
你可以用remove()方法删除文件，需要提供要删除的文件名作为参数。
语法：
|
1
|
os.remove(file_name)
|
例子：
下例将删除一个已经存在的文件test2.txt。
|
1
2
3
4
5
|
#!/usr/bin/python
import
os
# 删除一个已经存在的文件test2.txt
os.remove(
"text2.txt"
)
|
11.6 Python里的目录
- 文件、目录相关的方法
三个重要的方法来源能对Windows和Unix操作系统上的文件及目录进行一个广泛且实用的处理及操控，如下：
- File 对象方法: file对象提供了操作文件的一系列方法。
- OS 对象方法: 提供了处理文件及目录的一系列方法。
所有文件都包含在各个不同的目录下，不过Python也能轻松处理。os模块有许多方法能帮你创建，删除和更改目录。
- mkdir()方法——创建新目录
可以使用os模块的mkdir()方法在当前目录下创建新的目录们。你需要提供一个包含了要创建的目录名称的参数。
语法：
|
1
|
os.mkdir(
"newdir"
)
|
例子：
下例将在当前目录下创建一个新目录test。
|
1
2
3
4
5
|
#!/usr/bin/python
import
os
# 创建目录test
os.mkdir(
"test"
)
|
- chdir()方法
可以用chdir()方法来改变当前的目录。chdir()方法需要的一个参数是你想设成当前目录的目录名称。
语法：
|
1
|
os.chdir(
"newdir"
)
|
例子：
下例将进入"/home/newdir"目录。
|
1
2
3
4
5
|
#!/usr/bin/python
import
os
# 将当前目录改为"/home/newdir"
os.chdir(
"/home/newdir"
)
|
- getcwd()方法
getcwd()方法显示当前的工作目录。
语法：
|
1
|
os.getcwd()
|
例子：
下例给出当前目录：
|
1
2
3
4
5
|
#!/usr/bin/python
import
os
# 给出当前的目录
os.getcwd()
|
- rmdir()方法
rmdir()方法删除目录，目录名称以参数传递。
在删除这个目录之前，它的所有内容应该先被清除。
语法：
|
1
|
os.rmdir(
'dirname'
)
|
例子：
以下是删除" /tmp/test"目录的例子。目录的完全合规的名称必须被给出，否则会在当前目录下搜索该目录。
|
1
2
3
4
5
|
#!/usr/bin/python
import
os
# 删除”/tmp/test”目录
os.rmdir(
"/tmp/test"
)
|
12 python 常用库
12.1GUI 图形界面
1.wxpython
Python下的GUI编程框架，与MFC的架构相似
下载地址：http://wxpython.org/download.php
2. PyQt
用于Python的QT开发库
下载地址：http://www.riverbankcomputing.com/software/pyqt/download
12.2 Web框架
1. Django
开源web开发框架，它鼓励快速开发,并遵循MVC设计
下载地址： http://www.djangoproject.com/
2. web2py
一个小巧灵活的Web框架，虽然简单但是功能强大
下载地址：http://web2py.com/
12.3 科学计算
1. Matplotlib
用Python实现的类matlab的第三方库，用以绘制一些高质量的数学二维图形
下载地址：http://sourceforge.net/projects/matplotlib/files/matplotlib/matplotlib-1.1.0/
2. SciPy
基于Python的matlab实现，旨在实现matlab的所有功能
下载地址：http://pypi.python.org/pypi/scipy/
3. NumPy
基于Python的科学计算第三方库，提供了矩阵，线性代数，傅立叶变换等等的解决方案
下载地址：http://pypi.python.org/pypi/numpy/
12.4 网页处理
1. BeautifulSoup，强大的容错功能
网页处理非常强大的包：http://www.crummy.com/software/BeautifulSoup/
2. PyQuery，在Python中如网页的 jQuery一样处理文档
下载：https://pypi.python.org/pypi/pyquery
文档：https://pythonhosted.org/pyquery/
12.5 其他
1. MySQLdb
用于连接MySQL数据库
下载地址：http://pypi.python.org/pypi/MySQL-python/
2. PIL
基于Python的图像处理库，功能强大，对图形文件的格式支持广泛
下载地址：http://effbot.org/zone/pil-index.htm
3. PyGame
基于Python的多媒体开发和游戏软件开发模块
下载地址：http://www.pygame.org/download.shtml
4 sh 系统管理
sh 可以让你像执行函数一样执行shell终端命令
下载地址：https://pypi.python.org/pypi/sh
5. pickle (cPickle)
6. json7. random
8. datetime
12.6 特别介绍
1. cx_Freeze
方便简洁的打包工具，可跨平台！
下载地址：http://cx-freeze.sourceforge.net/
2. psyco
脚本的执行效率多少有点差强人意，虽然优化起来并不是难事，但如果有简单的方法，近乎不用修改源代码，那当然值得去关注一下。psyco 的神奇在于它只需要在代码的入口处调用短短两行代码，性能就能提升 40% 或更多，真可谓是立竿见影！
如果你的客户觉得你的程序有点慢，敬请不要急着去优化代码，psyco 或许能让他立即改变看法。psyco 堪称 Python 的 jit，有许多潜力可以挖掘，如果剩下来给你优化性能的时间已经不多，请马上去阅读它的手册，有许多招儿轻松优化性能。
以上都是一些常用的第三方库，更多请点击：http://pypi.python.org/pypi