Python3 基础语法

编码

默认情况下，Python 3 源码文件以 UTF-8 编码，所有字符串都是 unicode 字符串。 当然你也可以为源码文件指定不同的编码：

# -*- coding: cp-1252 -*-

上述定义允许在源文件中使用 Windows-1252 字符集中的字符编码，对应适合语言为保加利亚语、白罗斯语、马其顿语、俄语、塞尔维亚语。

标识符

• 第一个字符必须是字母表中字母或下划线 _ 。
• 标识符的其他的部分由字母、数字和下划线组成。
• 标识符对大小写敏感。

在 Python 3 中，可以用中文作为变量名，非 ASCII 标识符也是允许的了。

python保留字

保留字即关键字，我们不能把它们用作任何标识符名称。Python 的标准库提供了一个 keyword 模块，可以输出当前版本的所有关键字：

>>> import keyword
>>> keyword.kwlist
['False', 'None', 'True', 'and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']

注释

Python中单行注释以 # 开头，实例如下：

实例(Python 3.0+)

#!/usr/bin/python3# 第一个注释
print ("Hello, Python!") # 第二个注释

执行以上代码，输出结果为：

Hello, Python!

多行注释可以用多个 # 号，还有 ''' 和 """：

实例(Python 3.0+)

#!/usr/bin/python3# 第一个注释
# 第二个注释'''
第三注释
第四注释
'''"""
第五注释
第六注释
"""
print ("Hello, Python!")

执行以上代码，输出结果为：

Hello, Python!

行与缩进

python最具特色的就是使用缩进来表示代码块，不需要使用大括号 {} 。

缩进的空格数是可变的，但是同一个代码块的语句必须包含相同的缩进空格数。实例如下：

实例(Python 3.0+)

if True:print ("True")
else:print ("False")

以下代码最后一行语句缩进数的空格数不一致，会导致运行错误：

实例

if True:print ("Answer")print ("True")
else:print ("Answer")print ("False")    # 缩进不一致，会导致运行错误

以上程序由于缩进不一致，执行后会出现类似以下错误：

 File "test.py", line 6print ("False")    # 缩进不一致，会导致运行错误^
IndentationError: unindent does not match any outer indentation level

多行语句

Python 通常是一行写完一条语句，但如果语句很长，我们可以使用反斜杠 \ 来实现多行语句，例如：

total = ['item_one', 'item_two', 'item_three','item_four', 'item_five']

在 [], {}, 或 () 中的多行语句，不需要使用反斜杠 \，例如：

total = ['item_one', 'item_two', 'item_three','item_four', 'item_five']

数字(Number)类型

python中数字有四种类型：整数、布尔型、浮点数和复数。

• int (整数), 如 1, 只有一种整数类型 int，表示为长整型，没有 python2 中的 Long。
• bool (布尔), 如 True。
• float (浮点数), 如 1.23、3E-2
• complex (复数), 如 1 + 2j、 1.1 + 2.2j

字符串(String)

• python中单引号和双引号使用完全相同。
• 使用三引号(''' 或 """)可以指定一个多行字符串。
• 转义符 \
• 反斜杠可以用来转义，使用r可以让反斜杠不发生转义。。 如 r"this is a line with \n" 则\n会显示，并不是换行。
• 按字面意义级联字符串，如"this " "is " "string"会被自动转换为this is string。
• 字符串可以用 + 运算符连接在一起，用 * 运算符重复。
• Python 中的字符串有两种索引方式，从左往右以 0 开始，从右往左以 -1 开始。
• Python中的字符串不能改变。
• Python 没有单独的字符类型，一个字符就是长度为 1 的字符串。
• 字符串的截取的语法格式如下：变量[头下标:尾下标:步长]

word = '字符串'
sentence = "这是一个句子。"
paragraph = """这是一个段落，
可以由多行组成"""

实例(Python 3.0+)

#!/usr/bin/python3str='123456789'print(str)                 # 输出字符串
print(str[0:-1])           # 输出第一个到倒数第二个的所有字符
print(str[0])              # 输出字符串第一个字符
print(str[2:5])            # 输出从第三个开始到第五个的字符
print(str[2:])             # 输出从第三个开始后的所有字符
print(str[1:5:2])          # 输出从第二个开始到第五个且每隔一个的字符（步长为2）
print(str * 2)             # 输出字符串两次
print(str + '你好')         # 连接字符串print('------------------------------')print('hello\nrunoob')      # 使用反斜杠(\)+n转义特殊字符
print(r'hello\nrunoob')     # 在字符串前面添加一个 r，表示原始字符串，不会发生转义

这里的 r 指 raw，即 raw string，会自动将反斜杠转义，例如：

>>> print('\n')       # 输出空行>>> print(r'\n')      # 输出 \n
\n
>>>

以上实例输出结果：

123456789
12345678
1
345
3456789
24
123456789123456789
123456789你好
------------------------------
hello
runoob
hello\nrunoob

空行

函数之间或类的方法之间用空行分隔，表示一段新的代码的开始。类和函数入口之间也用一行空行分隔，以突出函数入口的开始。

空行与代码缩进不同，空行并不是Python语法的一部分。书写时不插入空行，Python解释器运行也不会出错。但是空行的作用在于分隔两段不同功能或含义的代码，便于日后代码的维护或重构。

记住：空行也是程序代码的一部分。

等待用户输入

执行下面的程序在按回车键后就会等待用户输入：

实例(Python 3.0+)

#!/usr/bin/python3input("\n\n按下 enter 键后退出。")

以上代码中 ，"\n\n"在结果输出前会输出两个新的空行。一旦用户按下 enter 键时，程序将退出。

同一行显示多条语句

Python 可以在同一行中使用多条语句，语句之间使用分号 ; 分割，以下是一个简单的实例：

实例(Python 3.0+)

#!/usr/bin/python3import sys; x = 'runoob'; sys.stdout.write(x + '\n')

使用脚本执行以上代码，输出结果为：

runoob

使用交互式命令行执行，输出结果为：

>>> import sys; x = 'runoob'; sys.stdout.write(x + '\n')
runoob
7

此处的 7 表示字符数。

多个语句构成代码组

缩进相同的一组语句构成一个代码块，我们称之代码组。

像if、while、def和class这样的复合语句，首行以关键字开始，以冒号( : )结束，该行之后的一行或多行代码构成代码组。

我们将首行及后面的代码组称为一个子句(clause)。

如下实例：

if expression : suite
elif expression : suite 
else : suite

print 输出

print 默认输出是换行的，如果要实现不换行需要在变量末尾加上 end=""：

实例(Python 3.0+)

#!/usr/bin/python3x="a"
y="b"
# 换行输出
print( x )
print( y )print('---------')
# 不换行输出
print( x, end=" " )
print( y, end=" " )
print()

以上实例执行结果为：

a
b
---------
a b

import 与 from...import

在 python 用 import 或者 from...import 来导入相应的模块。

将整个模块(somemodule)导入，格式为： import somemodule

从某个模块中导入某个函数,格式为： from somemodule import somefunction

从某个模块中导入多个函数,格式为： from somemodule import firstfunc, secondfunc, thirdfunc

将某个模块中的全部函数导入，格式为： from somemodule import *

导入 sys 模块

import sys
print('================Python import mode==========================')
print ('命令行参数为:')
for i in sys.argv:print (i)
print ('\n python 路径为',sys.path)

导入 sys 模块的 argv,path 成员

from sys import argv,path # 导入特定的成员 print('================python from import===================================') print('path:',path) # 因为已经导入path成员，所以此处引用时不需要加sys.path

命令行参数

很多程序可以执行一些操作来查看一些基本信息，Python可以使用-h参数查看各参数帮助信息：

$ python -h
usage: python [option] ... [-c cmd | -m mod | file | -] [arg] ...
Options and arguments (and corresponding environment variables):
-c cmd : program passed in as string (terminates option list)
-d     : debug output from parser (also PYTHONDEBUG=x)
-E     : ignore environment variables (such as PYTHONPATH)
-h     : print this help message and exit[ etc. ]

我们在使用脚本形式执行 Python 时，可以接收命令行输入的参数，具体使用可以参照 Python 3 命令行参数。

Python3 基本数据类型

Python 中的变量不需要声明。每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建。

在 Python 中，变量就是变量，它没有类型，我们所说的"类型"是变量所指的内存中对象的类型。

等号（=）用来给变量赋值。

等号（=）运算符左边是一个变量名,等号（=）运算符右边是存储在变量中的值。例如：

实例(Python 3.0+)

#!/usr/bin/python3counter = 100          # 整型变量
miles   = 1000.0       # 浮点型变量
name    = "runoob"     # 字符串print (counter)
print (miles)
print (name)

运行实例 »

执行以上程序会输出如下结果：

100
1000.0
runoob

多个变量赋值

Python允许你同时为多个变量赋值。例如：

a = b = c = 1

以上实例，创建一个整型对象，值为 1，从后向前赋值，三个变量被赋予相同的数值。

您也可以为多个对象指定多个变量。例如：

a, b, c = 1, 2, "runoob"

以上实例，两个整型对象 1 和 2 的分配给变量 a 和 b，字符串对象 "runoob" 分配给变量 c。

标准数据类型

Python3 中有六个标准的数据类型：

• Number（数字）
• String（字符串）
• List（列表）
• Tuple（元组）
• Set（集合）
• Dictionary（字典）

Python3 的六个标准数据类型中：

• 不可变数据（3 个）：Number（数字）、String（字符串）、Tuple（元组）；
• 可变数据（3 个）：List（列表）、Dictionary（字典）、Set（集合）。

Number（数字）

Python3 支持 int、float、bool、complex（复数）。

在Python 3里，只有一种整数类型 int，表示为长整型，没有 python2 中的 Long。

像大多数语言一样，数值类型的赋值和计算都是很直观的。

内置的 type() 函数可以用来查询变量所指的对象类型。

>>> a, b, c, d = 20, 5.5, True, 4+3j
>>> print(type(a), type(b), type(c), type(d))
<class 'int'> <class 'float'> <class 'bool'> <class 'complex'>

此外还可以用 isinstance 来判断：

实例

>>> a = 111
>>> isinstance(a, int)
True
>>>

isinstance 和 type 的区别在于：

• type()不会认为子类是一种父类类型。
• isinstance()会认为子类是一种父类类型。

>>> class A:
...     pass
... 
>>> class B(A):
...     pass
... 
>>> isinstance(A(), A)
True
>>> type(A()) == A 
True
>>> isinstance(B(), A)
True
>>> type(B()) == A
False

注意：Python3 中，bool 是 int 的子类，True 和 False 可以和数字相加 True==1，False==0 是会返回 Ture，但可以通过 is 来判断类型。

>>> issubclass(bool, int) 
True
>>> True==1
True
>>> False==0
True
>>> True+1
2
>>> False+1
1
>>> 1 is True
False
>>> 0 is False
False

在 Python2 中是没有布尔型的，它用数字 0 表示 False，用 1 表示 True。

当你指定一个值时，Number 对象就会被创建：

var1 = 1
var2 = 10

您也可以使用del语句删除一些对象引用。

del语句的语法是：

del var1[,var2[,var3[....,varN]]]

您可以通过使用del语句删除单个或多个对象。例如：

del var
del var_a, var_b

数值运算

实例

>>> 5 + 4  # 加法
9
>>> 4.3 - 2 # 减法
2.3
>>> 3 * 7  # 乘法
21
>>> 2 / 4  # 除法，得到一个浮点数
0.5
>>> 2 // 4 # 除法，得到一个整数
0
>>> 17 % 3 # 取余
2
>>> 2 ** 5 # 乘方
32

注意：

• 1、Python可以同时为多个变量赋值，如a, b = 1, 2。
• 2、一个变量可以通过赋值指向不同类型的对象。
• 3、数值的除法包含两个运算符：/ 返回一个浮点数，// 返回一个整数。
• 4、在混合计算时，Python会把整型转换成为浮点数。

数值类型实例

Python还支持复数，复数由实数部分和虚数部分构成，可以用a + bj,或者complex(a,b)表示， 复数的实部a和虚部b都是浮点型

String（字符串）

Python中的字符串用单引号 ' 或双引号 " 括起来，同时使用反斜杠 \ 转义特殊字符。

字符串的截取的语法格式如下：

变量[头下标:尾下标]

索引值以 0 为开始值，-1 为从末尾的开始位置。

加号 + 是字符串的连接符， 星号 * 表示复制当前字符串，与之结合的数字为复制的次数。实例如下：

实例

#!/usr/bin/python3str = 'Runoob'print (str)          # 输出字符串
print (str[0:-1])    # 输出第一个到倒数第二个的所有字符
print (str[0])       # 输出字符串第一个字符
print (str[2:5])     # 输出从第三个开始到第五个的字符
print (str[2:])      # 输出从第三个开始的后的所有字符
print (str * 2)      # 输出字符串两次，也可以写成 print (2 * str)
print (str + "TEST") # 连接字符串

执行以上程序会输出如下结果：

Runoob
Runoo
R
noo
noob
RunoobRunoob
RunoobTEST

Python 使用反斜杠 \ 转义特殊字符，如果你不想让反斜杠发生转义，可以在字符串前面添加一个 r，表示原始字符串：

实例

>>> print('Ru\noob')
Ru
oob
>>> print(r'Ru\noob')
Ru\noob
>>>

另外，反斜杠(\)可以作为续行符，表示下一行是上一行的延续。也可以使用 """...""" 或者 '''...''' 跨越多行。

注意，Python 没有单独的字符类型，一个字符就是长度为1的字符串。

实例

>>> word = 'Python'
>>> print(word[0], word[5])
P n
>>> print(word[-1], word[-6])
n P

与 C 字符串不同的是，Python 字符串不能被改变。向一个索引位置赋值，比如word[0] = 'm'会导致错误。

注意：

• 1、反斜杠可以用来转义，使用r可以让反斜杠不发生转义。
• 2、字符串可以用+运算符连接在一起，用*运算符重复。
• 3、Python中的字符串有两种索引方式，从左往右以0开始，从右往左以-1开始。
• 4、Python中的字符串不能改变。

List（列表）

List（列表） 是 Python 中使用最频繁的数据类型。

列表可以完成大多数集合类的数据结构实现。列表中元素的类型可以不相同，它支持数字，字符串甚至可以包含列表（所谓嵌套）。

列表是写在方括号 [] 之间、用逗号分隔开的元素列表。

和字符串一样，列表同样可以被索引和截取，列表被截取后返回一个包含所需元素的新列表。

列表截取的语法格式如下：

变量[头下标:尾下标]

索引值以 0 为开始值，-1 为从末尾的开始位置。

加号 + 是列表连接运算符，星号 * 是重复操作。如下实例：

实例

#!/usr/bin/python3list = [ 'abcd', 786 , 2.23, 'runoob', 70.2 ]
tinylist = [123, 'runoob']print (list)            # 输出完整列表
print (list[0])         # 输出列表第一个元素
print (list[1:3])       # 从第二个开始输出到第三个元素
print (list[2:])        # 输出从第三个元素开始的所有元素
print (tinylist * 2)    # 输出两次列表
print (list + tinylist) # 连接列表

以上实例输出结果：

['abcd', 786, 2.23, 'runoob', 70.2]
abcd
[786, 2.23]
[2.23, 'runoob', 70.2]
[123, 'runoob', 123, 'runoob']
['abcd', 786, 2.23, 'runoob', 70.2, 123, 'runoob']

与Python字符串不一样的是，列表中的元素是可以改变的：

实例

>>> a = [1, 2, 3, 4, 5, 6]
>>> a[0] = 9
>>> a[2:5] = [13, 14, 15]
>>> a
[9, 2, 13, 14, 15, 6]
>>> a[2:5] = []   # 将对应的元素值设置为 []
>>> a
[9, 2, 6]

List 内置了有很多方法，例如 append()、pop() 等等，这在后面会讲到。

注意：

• 1、List写在方括号之间，元素用逗号隔开。
• 2、和字符串一样，list可以被索引和切片。
• 3、List可以使用+操作符进行拼接。
• 4、List中的元素是可以改变的。

Python 列表截取可以接收第三个参数，参数作用是截取的步长，以下实例在索引 1 到索引 4 的位置并设置为步长为 2（间隔一个位置）来截取字符串：

如果第三个参数为负数表示逆向读取，以下实例用于翻转字符串：

实例

def reverseWords(input):# 通过空格将字符串分隔符，把各个单词分隔为列表inputWords = input.split(" ")# 翻转字符串# 假设列表 list = [1,2,3,4],  # list[0]=1, list[1]=2 ，而 -1 表示最后一个元素 list[-1]=4 ( 与 list[3]=4 一样)# inputWords[-1::-1] 有三个参数# 第一个参数 -1 表示最后一个元素# 第二个参数为空，表示移动到列表末尾# 第三个参数为步长，-1 表示逆向inputWords=inputWords[-1::-1]# 重新组合字符串output = ' '.join(inputWords)return outputif __name__ == "__main__":input = 'I like runoob'rw = reverseWords(input)print(rw)

输出结果为：

runoob like I

Tuple（元组）

元组（tuple）与列表类似，不同之处在于元组的元素不能修改。元组写在小括号 () 里，元素之间用逗号隔开。

元组中的元素类型也可以不相同：

实例

#!/usr/bin/python3tuple = ( 'abcd', 786 , 2.23, 'runoob', 70.2  )
tinytuple = (123, 'runoob')print (tuple)             # 输出完整元组
print (tuple[0])          # 输出元组的第一个元素
print (tuple[1:3])        # 输出从第二个元素开始到第三个元素
print (tuple[2:])         # 输出从第三个元素开始的所有元素
print (tinytuple * 2)     # 输出两次元组
print (tuple + tinytuple) # 连接元组

以上实例输出结果：

('abcd', 786, 2.23, 'runoob', 70.2)
abcd
(786, 2.23)
(2.23, 'runoob', 70.2)
(123, 'runoob', 123, 'runoob')
('abcd', 786, 2.23, 'runoob', 70.2, 123, 'runoob')

元组与字符串类似，可以被索引且下标索引从0开始，-1 为从末尾开始的位置。也可以进行截取（看上面，这里不再赘述）。

其实，可以把字符串看作一种特殊的元组。

实例

>>> tup = (1, 2, 3, 4, 5, 6)
>>> print(tup[0])
1
>>> print(tup[1:5])
(2, 3, 4, 5)
>>> tup[0] = 11  # 修改元组元素的操作是非法的
Traceback (most recent call last):File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment
>>>

虽然tuple的元素不可改变，但它可以包含可变的对象，比如list列表。

构造包含 0 个或 1 个元素的元组比较特殊，所以有一些额外的语法规则：

tup1 = ()    # 空元组
tup2 = (20,) # 一个元素，需要在元素后添加逗号

string、list 和 tuple 都属于 sequence（序列）。

注意：

• 1、与字符串一样，元组的元素不能修改。
• 2、元组也可以被索引和切片，方法一样。
• 3、注意构造包含 0 或 1 个元素的元组的特殊语法规则。
• 4、元组也可以使用+操作符进行拼接。

Set（集合）

集合（set）是由一个或数个形态各异的大小整体组成的，构成集合的事物或对象称作元素或是成员。

基本功能是进行成员关系测试和删除重复元素。

可以使用大括号 { } 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。

创建格式：

parame = {value01,value02,...}
或者
set(value)

实例

#!/usr/bin/python3sites = {'Google', 'Taobao', 'Runoob', 'Facebook', 'Zhihu', 'Baidu'}print(sites)   # 输出集合，重复的元素被自动去掉# 成员测试
if 'Runoob' in sites :print('Runoob 在集合中')
else :print('Runoob 不在集合中')# set可以进行集合运算
a = set('abracadabra')
b = set('alacazam')print(a)print(a - b)     # a 和 b 的差集print(a | b)     # a 和 b 的并集print(a & b)     # a 和 b 的交集print(a ^ b)     # a 和 b 中不同时存在的元素

以上实例输出结果：

{'Zhihu', 'Baidu', 'Taobao', 'Runoob', 'Google', 'Facebook'}
Runoob 在集合中
{'b', 'c', 'a', 'r', 'd'}
{'r', 'b', 'd'}
{'b', 'c', 'a', 'z', 'm', 'r', 'l', 'd'}
{'c', 'a'}
{'z', 'b', 'm', 'r', 'l', 'd'}

Dictionary（字典）

字典（dictionary）是Python中另一个非常有用的内置数据类型。

列表是有序的对象集合，字典是无序的对象集合。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。

字典是一种映射类型，字典用 { } 标识，它是一个无序的 键(key) : 值(value) 的集合。

键(key)必须使用不可变类型。

在同一个字典中，键(key)必须是唯一的。

实例

#!/usr/bin/python3dict = {}
dict['one'] = "1 - 菜鸟教程"
dict[2]     = "2 - 菜鸟工具"tinydict = {'name': 'runoob','code':1, 'site': 'www.runoob.com'}print (dict['one'])       # 输出键为 'one' 的值
print (dict[2])           # 输出键为 2 的值
print (tinydict)          # 输出完整的字典
print (tinydict.keys())   # 输出所有键
print (tinydict.values()) # 输出所有值

以上实例输出结果：

1 - 菜鸟教程
2 - 菜鸟工具
{'name': 'runoob', 'code': 1, 'site': 'www.runoob.com'}
dict_keys(['name', 'code', 'site'])
dict_values(['runoob', 1, 'www.runoob.com'])

构造函数 dict() 可以直接从键值对序列中构建字典如下：

实例

>>> dict([('Runoob', 1), ('Google', 2), ('Taobao', 3)])
{'Runoob': 1, 'Google': 2, 'Taobao': 3}
>>> {x: x**2 for x in (2, 4, 6)}
{2: 4, 4: 16, 6: 36}
>>> dict(Runoob=1, Google=2, Taobao=3)
{'Runoob': 1, 'Google': 2, 'Taobao': 3}
>>>

另外，字典类型也有一些内置的函数，例如clear()、keys()、values()等。

注意：

• 1、字典是一种映射类型，它的元素是键值对。
• 2、字典的关键字必须为不可变类型，且不能重复。
• 3、创建空字典使用 { }。

Python数据类型转换

有时候，我们需要对数据内置的类型进行转换，数据类型的转换，你只需要将数据类型作为函数名即可。

以下几个内置的函数可以执行数据类型之间的转换。这些函数返回一个新的对象，表示转换的值。

Python3 解释器

Linux/Unix的系统上，一般默认的 python 版本为 2.x，我们可以将 python3.x 安装在 /usr/local/python3 目录中。

安装完成后，我们可以将路径 /usr/local/python3/bin 添加到您的 Linux/Unix 操作系统的环境变量中，这样您就可以通过 shell 终端输入下面的命令来启动 Python3 。

$ PATH=$PATH:/usr/local/python3/bin/python3    # 设置环境变量
$ python3 --version
Python 3.4.0

在Window系统下你可以通过以下命令来设置Python的环境变量，假设你的Python安装在 C:\Python34 下:

set path=%path%;C:\python34

交互式编程

我们可以在命令提示符中输入"Python"命令来启动Python解释器：

$ python3

执行以上命令后，出现如下窗口信息：

$ python3
Python 3.4.0 (default, Apr 11 2014, 13:05:11) 
[GCC 4.8.2] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> 

在 python 提示符中输入以下语句，然后按回车键查看运行效果：

print ("Hello, Python!");

以上命令执行结果如下：

Hello, Python!

当键入一个多行结构时，续行是必须的。我们可以看下如下 if 语句：

>>> flag = True
>>> if flag :
...     print("flag 条件为 True!")
... 
flag 条件为 True!

脚本式编程

将如下代码拷贝至 hello.py文件中：

print ("Hello, Python!");

通过以下命令执行该脚本：

python3 hello.py

输出结果为：

Hello, Python!

在Linux/Unix系统中，你可以在脚本顶部添加以下命令让Python脚本可以像SHELL脚本一样可直接执行：

#! /usr/bin/env python3

然后修改脚本权限，使其有执行权限，命令如下：

$ chmod +x hello.py

执行以下命令：

./hello.py

输出结果为：

Hello, Python!

Python3 注释

确保对模块, 函数, 方法和行内注释使用正确的风格

Python中的注释有单行注释和多行注释：

Python中单行注释以 # 开头，例如：：

# 这是一个注释
print("Hello, World!")

多行注释用三个单引号 ''' 或者三个双引号 """ 将注释括起来，例如:

1、单引号（'''）

#!/usr/bin/python3 
'''
这是多行注释，用三个单引号
这是多行注释，用三个单引号 
这是多行注释，用三个单引号
'''
print("Hello, World!")

2、双引号（"""）

#!/usr/bin/python3 
"""
这是多行注释，用三个双引号
这是多行注释，用三个双引号 
这是多行注释，用三个双引号
"""
print("Hello, World!")

Python3 运算符

什么是运算符？

本章节主要说明 Python 的运算符。

举个简单的例子:

4 + 5 = 9

例子中，4 和 5 被称为操作数，+ 称为运算符。

Python 语言支持以下类型的运算符:

• 算术运算符
• 比较（关系）运算符
• 赋值运算符
• 逻辑运算符
• 位运算符
• 成员运算符
• 身份运算符
• 运算符优先级

接下来让我们一个个来学习Python的运算符。

Python算术运算符

以下假设变量 a=10，变量 b=21：

>>> 9//2
4
>>> -9//2
-5

以下实例演示了Python所有算术运算符的操作：

实例(Python 3.0+)

#!/usr/bin/python3a = 21
b = 10
c = 0c = a + b
print ("1 - c 的值为：", c)c = a - b
print ("2 - c 的值为：", c)c = a * b
print ("3 - c 的值为：", c)c = a / b
print ("4 - c 的值为：", c)c = a % b
print ("5 - c 的值为：", c)# 修改变量 a 、b 、c
a = 2
b = 3
c = a**b 
print ("6 - c 的值为：", c)a = 10
b = 5
c = a//b 
print ("7 - c 的值为：", c)

以上实例输出结果：

1 - c 的值为： 31
2 - c 的值为： 11
3 - c 的值为： 210
4 - c 的值为： 2.1
5 - c 的值为： 1
6 - c 的值为： 8
7 - c 的值为： 2

Python比较运算符

以下假设变量a为10，变量b为20：

以下实例演示了Python所有比较运算符的操作：

实例(Python 3.0+)

#!/usr/bin/python3a = 21
b = 10
c = 0if ( a == b ):print ("1 - a 等于 b")
else:print ("1 - a 不等于 b")if ( a != b ):print ("2 - a 不等于 b")
else:print ("2 - a 等于 b")if ( a < b ):print ("3 - a 小于 b")
else:print ("3 - a 大于等于 b")if ( a > b ):print ("4 - a 大于 b")
else:print ("4 - a 小于等于 b")# 修改变量 a 和 b 的值
a = 5
b = 20
if ( a <= b ):print ("5 - a 小于等于 b")
else:print ("5 - a 大于  b")if ( b >= a ):print ("6 - b 大于等于 a")
else:print ("6 - b 小于 a")

以上实例输出结果：

1 - a 不等于 b
2 - a 不等于 b
3 - a 大于等于 b
4 - a 大于 b
5 - a 小于等于 b
6 - b 大于等于 a

Python赋值运算符

以下假设变量a为10，变量b为20：

if (n := len(a)) > 10:print(f"List is too long ({n} elements, expected <= 10)")

以下实例演示了Python所有赋值运算符的操作：

实例(Python 3.0+)

#!/usr/bin/python3a = 21
b = 10
c = 0c = a + b
print ("1 - c 的值为：", c)c += a
print ("2 - c 的值为：", c)c *= a
print ("3 - c 的值为：", c)c /= a 
print ("4 - c 的值为：", c)c = 2
c %= a
print ("5 - c 的值为：", c)c **= a
print ("6 - c 的值为：", c)c //= a
print ("7 - c 的值为：", c)

以上实例输出结果：

1 - c 的值为： 31
2 - c 的值为： 52
3 - c 的值为： 1092
4 - c 的值为： 52.0
5 - c 的值为： 2
6 - c 的值为： 2097152
7 - c 的值为： 99864

Python位运算符

按位运算符是把数字看作二进制来进行计算的。Python中的按位运算法则如下：

下表中变量 a 为 60，b 为 13二进制格式如下：

a = 0011 1100b = 0000 1101-----------------a&b = 0000 1100a|b = 0011 1101a^b = 0011 0001~a  = 1100 0011

以下实例演示了Python所有位运算符的操作：

实例(Python 3.0+)

#!/usr/bin/python3a = 60            # 60 = 0011 1100 
b = 13            # 13 = 0000 1101 
c = 0c = a & b        # 12 = 0000 1100
print ("1 - c 的值为：", c)c = a | b        # 61 = 0011 1101 
print ("2 - c 的值为：", c)c = a ^ b        # 49 = 0011 0001
print ("3 - c 的值为：", c)c = ~a           # -61 = 1100 0011
print ("4 - c 的值为：", c)c = a << 2       # 240 = 1111 0000
print ("5 - c 的值为：", c)c = a >> 2       # 15 = 0000 1111
print ("6 - c 的值为：", c)

以上实例输出结果：

1 - c 的值为： 12
2 - c 的值为： 61
3 - c 的值为： 49
4 - c 的值为： -61
5 - c 的值为： 240
6 - c 的值为： 15

Python逻辑运算符

Python语言支持逻辑运算符，以下假设变量 a 为 10, b为 20:

以上实例输出结果：

实例(Python 3.0+)

#!/usr/bin/python3a = 10
b = 20if ( a and b ):print ("1 - 变量 a 和 b 都为 true")
else:print ("1 - 变量 a 和 b 有一个不为 true")if ( a or b ):print ("2 - 变量 a 和 b 都为 true，或其中一个变量为 true")
else:print ("2 - 变量 a 和 b 都不为 true")# 修改变量 a 的值
a = 0
if ( a and b ):print ("3 - 变量 a 和 b 都为 true")
else:print ("3 - 变量 a 和 b 有一个不为 true")if ( a or b ):print ("4 - 变量 a 和 b 都为 true，或其中一个变量为 true")
else:print ("4 - 变量 a 和 b 都不为 true")if not( a and b ):print ("5 - 变量 a 和 b 都为 false，或其中一个变量为 false")
else:print ("5 - 变量 a 和 b 都为 true")

以上实例输出结果：

1 - 变量 a 和 b 都为 true
2 - 变量 a 和 b 都为 true，或其中一个变量为 true
3 - 变量 a 和 b 有一个不为 true
4 - 变量 a 和 b 都为 true，或其中一个变量为 true
5 - 变量 a 和 b 都为 false，或其中一个变量为 false

Python成员运算符

除了以上的一些运算符之外，Python还支持成员运算符，测试实例中包含了一系列的成员，包括字符串，列表或元组。

以下实例演示了Python所有成员运算符的操作：

实例(Python 3.0+)

#!/usr/bin/python3a = 10
b = 20
list = [1, 2, 3, 4, 5 ]if ( a in list ):print ("1 - 变量 a 在给定的列表中 list 中")
else:print ("1 - 变量 a 不在给定的列表中 list 中")if ( b not in list ):print ("2 - 变量 b 不在给定的列表中 list 中")
else:print ("2 - 变量 b 在给定的列表中 list 中")# 修改变量 a 的值
a = 2
if ( a in list ):print ("3 - 变量 a 在给定的列表中 list 中")
else:print ("3 - 变量 a 不在给定的列表中 list 中")

以上实例输出结果：

1 - 变量 a 不在给定的列表中 list 中
2 - 变量 b 不在给定的列表中 list 中
3 - 变量 a 在给定的列表中 list 中

Python身份运算符

身份运算符用于比较两个对象的存储单元

注： id() 函数用于获取对象内存地址。

以下实例演示了Python所有身份运算符的操作：

实例(Python 3.0+)

#!/usr/bin/python3a = 20
b = 20if ( a is b ):print ("1 - a 和 b 有相同的标识")
else:print ("1 - a 和 b 没有相同的标识")if ( id(a) == id(b) ):print ("2 - a 和 b 有相同的标识")
else:print ("2 - a 和 b 没有相同的标识")# 修改变量 b 的值
b = 30
if ( a is b ):print ("3 - a 和 b 有相同的标识")
else:print ("3 - a 和 b 没有相同的标识")if ( a is not b ):print ("4 - a 和 b 没有相同的标识")
else:print ("4 - a 和 b 有相同的标识")

以上实例输出结果：

1 - a 和 b 有相同的标识
2 - a 和 b 有相同的标识
3 - a 和 b 没有相同的标识
4 - a 和 b 没有相同的标识

is 与 == 区别：

is 用于判断两个变量引用对象是否为同一个， == 用于判断引用变量的值是否相等。

>>>a = [1, 2, 3]
>>> b = a
>>> b is a 
True
>>> b == a
True
>>> b = a[:]
>>> b is a
False
>>> b == a
True

Python运算符优先级

以下表格列出了从最高到最低优先级的所有运算符：

以下实例演示了Python所有运算符优先级的操作：

实例(Python 3.0+)

#!/usr/bin/python3a = 20
b = 10
c = 15
d = 5
e = 0e = (a + b) * c / d       #( 30 * 15 ) / 5
print ("(a + b) * c / d 运算结果为：",  e)e = ((a + b) * c) / d     # (30 * 15 ) / 5
print ("((a + b) * c) / d 运算结果为：",  e)e = (a + b) * (c / d)    # (30) * (15/5)
print ("(a + b) * (c / d) 运算结果为：",  e)e = a + (b * c) / d      #  20 + (150/5)
print ("a + (b * c) / d 运算结果为：",  e)

以上实例输出结果：

(a + b) * c / d 运算结果为： 90.0
((a + b) * c) / d 运算结果为： 90.0
(a + b) * (c / d) 运算结果为： 90.0
a + (b * c) / d 运算结果为： 50.0

and 拥有更高优先级:

实例

x = True
y = False
z = Falseif x or y and z:print("yes")
else:print("no")

以上实例输出结果：

yes

注意：Pyhton3 已不支持 <> 运算符，可以使用 != 代替，如果你一定要使用这种比较运算符，可以使用以下的方式：

>>> from __future__ import barry_as_FLUFL
>>> 1 <> 2
True

Python3 数字(Number)

Python 数字数据类型用于存储数值。

数据类型是不允许改变的,这就意味着如果改变数字数据类型的值，将重新分配内存空间。

以下实例在变量赋值时 Number 对象将被创建：

var1 = 1
var2 = 10

您也可以使用del语句删除一些数字对象的引用。

del语句的语法是：

del var1[,var2[,var3[....,varN]]]

您可以通过使用del语句删除单个或多个对象的引用，例如：

del var
del var_a, var_b

Python 支持三种不同的数值类型：

• 整型(int) - 通常被称为是整型或整数，是正或负整数，不带小数点。Python3 整型是没有限制大小的，可以当作 Long 类型使用，所以 Python3 没有 Python2 的 Long 类型。布尔(bool)是整型的子类型。

• 浮点型(float) - 浮点型由整数部分与小数部分组成，浮点型也可以使用科学计数法表示（2.5e2 = 2.5 x 102 = 250）

• 复数( (complex)) - 复数由实数部分和虚数部分构成，可以用a + bj,或者complex(a,b)表示， 复数的实部a和虚部b都是浮点型。

我们可以使用十六进制和八进制来代表整数：

>>> number = 0xA0F # 十六进制
>>> number
2575>>> number=0o37 # 八进制
>>> number
31

• Python支持复数，复数由实数部分和虚数部分构成，可以用a + bj,或者complex(a,b)表示， 复数的实部a和虚部b都是浮点型。

Python 数字类型转换

有时候，我们需要对数据内置的类型进行转换，数据类型的转换，你只需要将数据类型作为函数名即可。

• int(x) 将x转换为一个整数。

• float(x) 将x转换到一个浮点数。

• complex(x) 将x转换到一个复数，实数部分为 x，虚数部分为 0。

• complex(x, y) 将 x 和 y 转换到一个复数，实数部分为 x，虚数部分为 y。x 和 y 是数字表达式。

以下实例将浮点数变量 a 转换为整数：

>>> a = 1.0
>>> int(a)
1

Python 数字运算

Python 解释器可以作为一个简单的计算器，您可以在解释器里输入一个表达式，它将输出表达式的值。

表达式的语法很直白： +, -, * 和 /, 和其它语言（如Pascal或C）里一样。例如：

>>> 2 + 2
4
>>> 50 - 5*6
20
>>> (50 - 5*6) / 4
5.0
>>> 8 / 5  # 总是返回一个浮点数
1.6

注意：在不同的机器上浮点运算的结果可能会不一样。

在整数除法中，除法 / 总是返回一个浮点数，如果只想得到整数的结果，丢弃可能的分数部分，可以使用运算符 // ：

>>> 17 / 3  # 整数除法返回浮点型
5.666666666666667
>>>
>>> 17 // 3  # 整数除法返回向下取整后的结果
5
>>> 17 % 3  # ％操作符返回除法的余数
2
>>> 5 * 3 + 2 
17

注意：// 得到的并不一定是整数类型的数，它与分母分子的数据类型有关系。

>>> 7//2
3
>>> 7.0//2
3.0
>>> 7//2.0
3.0
>>> 

等号 = 用于给变量赋值。赋值之后，除了下一个提示符，解释器不会显示任何结果。

>>> width = 20
>>> height = 5*9
>>> width * height
900

Python 可以使用 ** 操作来进行幂运算：

>>> 5 ** 2  # 5 的平方
25
>>> 2 ** 7  # 2的7次方
128

变量在使用前必须先"定义"（即赋予变量一个值），否则会出现错误：

>>> n   # 尝试访问一个未定义的变量
Traceback (most recent call last):File "<stdin>", line 1, in <module>
NameError: name 'n' is not defined

不同类型的数混合运算时会将整数转换为浮点数：

>>> 3 * 3.75 / 1.5
7.5
>>> 7.0 / 2
3.5

在交互模式中，最后被输出的表达式结果被赋值给变量 _ 。例如：

>>> tax = 12.5 / 100
>>> price = 100.50
>>> price * tax
12.5625
>>> price + _
113.0625
>>> round(_, 2)
113.06

此处， _ 变量应被用户视为只读变量。

数学函数

随机数函数

随机数可以用于数学，游戏，安全等领域中，还经常被嵌入到算法中，用以提高算法效率，并提高程序的安全性。

Python包含以下常用随机数函数：

三角函数

Python包括以下三角函数：

数学常量

Python3 字符串

字符串是 Python 中最常用的数据类型。我们可以使用引号( ' 或 " )来创建字符串。

创建字符串很简单，只要为变量分配一个值即可。例如：

var1 = 'Hello World!'
var2 = "Runoob"

Python 访问字符串中的值

Python 不支持单字符类型，单字符在 Python 中也是作为一个字符串使用。

Python 访问子字符串，可以使用方括号 [] 来截取字符串，字符串的截取的语法格式如下：

<span style="color:#333333"><span style="color:#666600">变量[头下标:尾下标]</span></span>

索引值以 0 为开始值，-1 为从末尾的开始位置。

如下实例：

#!/usr/bin/python3var1 = 'Hello World!'
var2 = "Runoob"print ("var1[0]: ", var1[0])
print ("var2[1:5]: ", var2[1:5])

以上实例执行结果：

var1[0]:  H
var2[1:5]:  unoo

Python 字符串更新

你可以截取字符串的一部分并与其他字段拼接，如下实例：

#!/usr/bin/python3var1 = 'Hello World!'print ("已更新字符串 : ", var1[:6] + 'Runoob!')

以上实例执行结果

已更新字符串 :  Hello Runoob!

Python转义字符

在需要在字符中使用特殊字符时，python 用反斜杠 \ 转义字符。如下表：

>>> print("line1 \
... line2 \
... line3")
line1 line2 line3
>>>  print("line1 \
... line2 \
... line3")
line1 line2 line3
>>> 

>>> print("\\")
\ print("\\")
\

>>> print('\'')
' print('\'')
'

>>> print("\"")
" print("\"")
"

>>> print("\a") print("\a")

>>> print("Hello \b World!")
Hello World! print("Hello \b World!")
Hello World!

>>> print("\000")>>>  print("\000")>>> 

>>> print("\n")>>> print("\n")>>>

>>> print("Hello \v World!")
Hello World!
>>> print("Hello \v World!")
Hello World!
>>>

>>> print("Hello \t World!")
Hello      World!
>>> print("Hello \t World!")
Hello      World!
>>>

>>> print("Hello\rWorld!")
World!
>>> print('google runoob taobao\r123456')
123456 runoob taobao print("Hello\rWorld!")
World!
>>> print('google runoob taobao\r123456')
123456 runoob taobao

>>> print("Hello \f World!")
Hello World!
>>>  print("Hello \f World!")
Hello World!
>>> 

>>> print("\110\145\154\154\157\40\127\157\162\154\144\41")
Hello World! print("\110\145\154\154\157\40\127\157\162\154\144\41")
Hello World!

>>> print("\x48\x65\x6c\x6c\x6f\x20\x57\x6f\x72\x6c\x64\x21")
Hello World! print("\x48\x65\x6c\x6c\x6f\x20\x57\x6f\x72\x6c\x64\x21")
Hello World!

Python字符串运算符

下表实例变量 a 值为字符串 "Hello"，b 变量值为 "Python"：

print( r'\n' )
print( R'\n' )( r'\n' )
print( R'\n' )

#!/usr/bin/python3a = "Hello"
b = "Python"print("a + b 输出结果：", a + b)
print("a * 2 输出结果：", a * 2)
print("a[1] 输出结果：", a[1])
print("a[1:4] 输出结果：", a[1:4])if( "H" in a) :print("H 在变量 a 中")
else :print("H 不在变量 a 中")if( "M" not in a) :print("M 不在变量 a 中")
else :print("M 在变量 a 中")print (r'\n')
print (R'\n')

以上实例输出结果为：

a + b 输出结果： HelloPython
a * 2 输出结果： HelloHello
a[1] 输出结果： e
a[1:4] 输出结果： ell
H 在变量 a 中
M 不在变量 a 中
\n
\n

Python 字符串格式化

Python 支持格式化字符串的输出 。尽管这样可能会用到非常复杂的表达式，但最基本的用法是将一个值插入到一个有字符串格式符 %s 的字符串中。

在 Python 中，字符串格式化使用与 C 中 sprintf 函数一样的语法。

#!/usr/bin/python3print ("我叫 %s 今年 %d 岁!" % ('小明', 10))

以上实例输出结果：

我叫 小明 今年 10 岁!

python字符串格式化符号:

格式化操作符辅助指令:

Python2.6 开始，新增了一种格式化字符串的函数 str.format()，它增强了字符串格式化的功能。

Python三引号

python三引号允许一个字符串跨多行，字符串中可以包含换行符、制表符以及其他特殊字符。实例如下

#!/usr/bin/python3para_str = """这是一个多行字符串的实例
多行字符串可以使用制表符
TAB ( \t )。
也可以使用换行符 [ \n ]。
"""
print (para_str)

以上实例执行结果为：

这是一个多行字符串的实例
多行字符串可以使用制表符
TAB (    )。
也可以使用换行符 [ ]。

三引号让程序员从引号和特殊字符串的泥潭里面解脱出来，自始至终保持一小块字符串的格式是所谓的WYSIWYG（所见即所得）格式的。

一个典型的用例是，当你需要一块HTML或者SQL时，这时用字符串组合，特殊字符串转义将会非常的繁琐。

errHTML = '''
<HTML><HEAD><TITLE>
Friends CGI Demo</TITLE></HEAD>
<BODY><H3>ERROR</H3>
<B>%s</B><P>
<FORM><INPUT TYPE=button VALUE=Back
ONCLICK="window.history.back()"></FORM>
</BODY></HTML>
'''
cursor.execute('''
CREATE TABLE users (  
login VARCHAR(8), 
uid INTEGER,
prid INTEGER)
''')

f-string

f-string 是 python3.6 之后版本添加的，称之为字面量格式化字符串，是新的格式化字符串的语法。

之前我们习惯用百分号 (%):

>>> name = 'Runoob'
>>> 'Hello %s' % name
'Hello Runoob'

f-string 格式化字符串以 f 开头，后面跟着字符串，字符串中的表达式用大括号 {} 包起来，它会将变量或表达式计算后的值替换进去，实例如下：

>>> name = 'Runoob'
>>> f'Hello {name}'  # 替换变量
'Hello Runoob'
>>> f'{1+2}'         # 使用表达式
'3'>>> w = {'name': 'Runoob', 'url': 'www.runoob.com'}
>>> f'{w["name"]}: {w["url"]}'
'Runoob: www.runoob.com'

用了这种方式明显更简单了，不用再去判断使用 %s，还是 %d。

在 Python 3.8 的版本中可以使用 = 符号来拼接运算表达式与结果：

>>> x = 1
>>> print(f'{x+1}')   # Python 3.6
2>>> x = 1
>>> print(f'{x+1=}')   # Python 3.8
x+1=2

Unicode 字符串

在Python2中，普通字符串是以8位ASCII码进行存储的，而Unicode字符串则存储为16位unicode字符串，这样能够表示更多的字符集。使用的语法是在字符串前面加上前缀 u。

在Python3中，所有的字符串都是Unicode字符串。

Python 的字符串内建函数

Python 的字符串常用内建函数如下：

Python3 列表

序列是 Python 中最基本的数据结构。

序列中的每个值都有对应的位置值，称之为索引，第一个索引是 0，第二个索引是 1，依此类推。

Python 有 6 个序列的内置类型，但最常见的是列表和元组。

列表都可以进行的操作包括索引，切片，加，乘，检查成员。

此外，Python 已经内置确定序列的长度以及确定最大和最小的元素的方法。

列表是最常用的 Python 数据类型，它可以作为一个方括号内的逗号分隔值出现。

列表的数据项不需要具有相同的类型

创建一个列表，只要把逗号分隔的不同的数据项使用方括号括起来即可。如下所示：

list1 = ['Google', 'Runoob', 1997, 2000]
list2 = [1, 2, 3, 4, 5 ]
list3 = ["a", "b", "c", "d"]
list4 = ['red', 'green', 'blue', 'yellow', 'white', 'black']

访问列表中的值

与字符串的索引一样，列表索引从 0 开始，第二个索引是 1，依此类推。

通过索引列表可以进行截取、组合等操作。

实例

#!/usr/bin/python3list = ['red', 'green', 'blue', 'yellow', 'white', 'black']
print( list[0] )
print( list[1] )
print( list[2] )

以上实例输出结果：

red
green
blue

索引也可以从尾部开始，最后一个元素的索引为 -1，往前一位为 -2，以此类推。

实例

#!/usr/bin/python3list = ['red', 'green', 'blue', 'yellow', 'white', 'black']
print( list[-1] )
print( list[-2] )
print( list[-3] )

以上实例输出结果：

black
white
yellow

使用下标索引来访问列表中的值，同样你也可以使用方括号 [] 的形式截取字符，如下所示：

实例

#!/usr/bin/python3nums = [10, 20, 30, 40, 50, 60, 70, 80, 90]
print(nums[0:4])

以上实例输出结果：

[10, 20, 30, 40]

使用负数索引值截取：

实例

#!/usr/bin/python3list = ['Google', 'Runoob', "Zhihu", "Taobao", "Wiki"]# 读取第二位
print ("list[1]: ", list[1])
# 从第二位开始（包含）截取到倒数第二位（不包含）
print ("list[1:-2]: ", list[1:-2])

以上实例输出结果：

list[1]:  Runoob
list[1:-2]:  ['Runoob', 'Zhihu']

更新列表

你可以对列表的数据项进行修改或更新，你也可以使用 append() 方法来添加列表项，如下所示：

实例(Python 3.0+)

#!/usr/bin/python3list = ['Google', 'Runoob', 1997, 2000]print ("第三个元素为 : ", list[2])
list[2] = 2001
print ("更新后的第三个元素为 : ", list[2])list1 = ['Google', 'Runoob', 'Taobao']
list1.append('Baidu')
print ("更新后的列表 : ", list1)

注意：我们会在接下来的章节讨论 append() 方法的使用。

以上实例输出结果：

第三个元素为 :  1997
更新后的第三个元素为 :  2001
更新后的列表 :  ['Google', 'Runoob', 'Taobao', 'Baidu']

删除列表元素

可以使用 del 语句来删除列表的的元素，如下实例：

实例(Python 3.0+)

#!/usr/bin/python3list = ['Google', 'Runoob', 1997, 2000]print ("原始列表 : ", list)
del list[2]
print ("删除第三个元素 : ", list)

以上实例输出结果：

原始列表 :  ['Google', 'Runoob', 1997, 2000]
删除第三个元素 :  ['Google', 'Runoob', 2000]

注意：我们会在接下来的章节讨论 remove() 方法的使用

Python列表脚本操作符

列表对 + 和 * 的操作符与字符串相似。+ 号用于组合列表，* 号用于重复列表。

如下所示：

Python列表截取与拼接

Python的列表截取与字符串操作类型，如下所示：

L=['Google', 'Runoob', 'Taobao']

操作：

>>>L=['Google', 'Runoob', 'Taobao']
>>> L[2]
'Taobao'
>>> L[-2]
'Runoob'
>>> L[1:]
['Runoob', 'Taobao']
>>>

列表还支持拼接操作：

>>>squares = [1, 4, 9, 16, 25]
>>> squares += [36, 49, 64, 81, 100]
>>> squares
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
>>>

嵌套列表

使用嵌套列表即在列表里创建其它列表，例如：

>>>a = ['a', 'b', 'c']
>>> n = [1, 2, 3]
>>> x = [a, n]
>>> x
[['a', 'b', 'c'], [1, 2, 3]]
>>> x[0]
['a', 'b', 'c']
>>> x[0][1]
'b'

Python列表函数&方法

Python包含以下函数:

Python包含以下方法:

Python3 元组

Python 的元组与列表类似，不同之处在于元组的元素不能修改。

元组使用小括号 ( )，列表使用方括号 [ ]。

元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可。

实例(Python 3.0+)

>>> tup1 = ('Google', 'Runoob', 1997, 2000)
>>> tup2 = (1, 2, 3, 4, 5 )
>>> tup3 = "a", "b", "c", "d"   #  不需要括号也可以
>>> type(tup3)
<class 'tuple'>

创建空元组

tup1 = ()

元组中只包含一个元素时，需要在元素后面添加逗号 , ，否则括号会被当作运算符使用：

实例(Python 3.0+)

>>> tup1 = (50)
>>> type(tup1)     # 不加逗号，类型为整型
<class 'int'>>>> tup1 = (50,)
>>> type(tup1)     # 加上逗号，类型为元组
<class 'tuple'>

元组与字符串类似，下标索引从 0 开始，可以进行截取，组合等。

访问元组

元组可以使用下标索引来访问元组中的值，如下实例:

实例(Python 3.0+)

#!/usr/bin/python3tup1 = ('Google', 'Runoob', 1997, 2000)
tup2 = (1, 2, 3, 4, 5, 6, 7 )print ("tup1[0]: ", tup1[0])
print ("tup2[1:5]: ", tup2[1:5])

以上实例输出结果：

tup1[0]:  Google
tup2[1:5]:  (2, 3, 4, 5)

修改元组

元组中的元素值是不允许修改的，但我们可以对元组进行连接组合，如下实例:

实例(Python 3.0+)

#!/usr/bin/python3tup1 = (12, 34.56)
tup2 = ('abc', 'xyz')# 以下修改元组元素操作是非法的。
# tup1[0] = 100# 创建一个新的元组
tup3 = tup1 + tup2
print (tup3)

以上实例输出结果：

(12, 34.56, 'abc', 'xyz')

删除元组

元组中的元素值是不允许删除的，但我们可以使用del语句来删除整个元组，如下实例:

实例(Python 3.0+)

#!/usr/bin/python3tup = ('Google', 'Runoob', 1997, 2000)print (tup)
del tup
print ("删除后的元组 tup : ")
print (tup)

以上实例元组被删除后，输出变量会有异常信息，输出如下所示：

删除后的元组 tup : 
Traceback (most recent call last):File "test.py", line 8, in <module>print (tup)
NameError: name 'tup' is not defined

元组运算符

与字符串一样，元组之间可以使用 + 号和 * 号进行运算。这就意味着他们可以组合和复制，运算后会生成一个新的元组。

元组索引，截取

因为元组也是一个序列，所以我们可以访问元组中的指定位置的元素，也可以截取索引中的一段元素，如下所示：

元组：

tup = ('Google', 'Runoob', 'Taobao', 'Wiki', 'Weibo','Weixin')

运行实例如下：

实例

>>> tup = ('Google', 'Runoob', 'Taobao', 'Wiki', 'Weibo','Weixin')
>>> tup[1]
'Runoob'
>>> tup[-2]
'Weibo'
>>> tup[1:]
('Runoob', 'Taobao', 'Wiki', 'Weibo', 'Weixin')
>>> tup[1:4]
('Runoob', 'Taobao', 'Wiki')
>>>

元组内置函数

Python元组包含了以下内置函数

>>> tuple1 = ('Google', 'Runoob', 'Taobao')
>>> len(tuple1)
3
>>> 

>>> tuple2 = ('5', '4', '8')
>>> max(tuple2)
'8'
>>> 

>>> tuple2 = ('5', '4', '8')
>>> min(tuple2)
'4'
>>> 

>>> list1= ['Google', 'Taobao', 'Runoob', 'Baidu']
>>> tuple1=tuple(list1)
>>> tuple1
('Google', 'Taobao', 'Runoob', 'Baidu')

关于元组是不可变的

所谓元组的不可变指的是元组所指向的内存中的内容不可变。

>>> tup = ('r', 'u', 'n', 'o', 'o', 'b')
>>> tup[0] = 'g'     # 不支持修改元素
Traceback (most recent call last):File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment
>>> id(tup)     # 查看内存地址
4440687904
>>> tup = (1,2,3)
>>> id(tup)
4441088800    # 内存地址不一样了

从以上实例可以看出，重新赋值的元组 tup，绑定到新的对象了，不是修改了原来的对象。

Python3 字典

字典是另一种可变容器模型，且可存储任意类型对象。

字典的每个键值 key=>value 对用冒号 : 分割，每个对之间用逗号(,)分割，整个字典包括在花括号 {} 中 ,格式如下所示：

d = {key1 : value1, key2 : value2, key3 : value3 }

键必须是唯一的，但值则不必。

值可以取任何数据类型，但键必须是不可变的，如字符串，数字。

一个简单的字典实例：

dict = {'name': 'runoob', 'likes': 123, 'url': 'www.runoob.com'}

也可如此创建字典：

dict1 = { 'abc': 456 }
dict2 = { 'abc': 123, 98.6: 37 }

访问字典里的值

把相应的键放入到方括号中，如下实例:

实例

#!/usr/bin/python3dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}print ("dict['Name']: ", dict['Name'])
print ("dict['Age']: ", dict['Age'])

以上实例输出结果：

dict['Name']:  Runoob
dict['Age']:  7

如果用字典里没有的键访问数据，会输出错误如下：

实例

#!/usr/bin/python3dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}print ("dict['Alice']: ", dict['Alice'])

以上实例输出结果：

Traceback (most recent call last):File "test.py", line 5, in <module>print ("dict['Alice']: ", dict['Alice'])
KeyError: 'Alice'

修改字典

向字典添加新内容的方法是增加新的键/值对，修改或删除已有键/值对如下实例:

实例

#!/usr/bin/python3dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}dict['Age'] = 8               # 更新 Age
dict['School'] = "菜鸟教程"  # 添加信息print ("dict['Age']: ", dict['Age'])
print ("dict['School']: ", dict['School'])

以上实例输出结果：

dict['Age']:  8
dict['School']:  菜鸟教程

删除字典元素

能删单一的元素也能清空字典，清空只需一项操作。

显示删除一个字典用del命令，如下实例：

实例

#!/usr/bin/python3dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}del dict['Name'] # 删除键 'Name'
dict.clear()     # 清空字典
del dict         # 删除字典print ("dict['Age']: ", dict['Age'])
print ("dict['School']: ", dict['School'])

但这会引发一个异常，因为用执行 del 操作后字典不再存在：

Traceback (most recent call last):File "test.py", line 9, in <module>print ("dict['Age']: ", dict['Age'])
TypeError: 'type' object is not subscriptable

注：del() 方法后面也会讨论。

字典键的特性

字典值可以是任何的 python 对象，既可以是标准的对象，也可以是用户定义的，但键不行。

两个重要的点需要记住：

1）不允许同一个键出现两次。创建时如果同一个键被赋值两次，后一个值会被记住，如下实例：

实例

#!/usr/bin/python3dict = {'Name': 'Runoob', 'Age': 7, 'Name': '小菜鸟'}print ("dict['Name']: ", dict['Name'])

以上实例输出结果：

dict['Name']:  小菜鸟

2）键必须不可变，所以可以用数字，字符串或元组充当，而用列表就不行，如下实例：

实例

#!/usr/bin/python3dict = {['Name']: 'Runoob', 'Age': 7}print ("dict['Name']: ", dict['Name'])

以上实例输出结果：

Traceback (most recent call last):File "test.py", line 3, in <module>dict = {['Name']: 'Runoob', 'Age': 7}
TypeError: unhashable type: 'list'

字典内置函数&方法

Python字典包含了以下内置函数：

>>> dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
>>> len(dict)
3

>>> dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
>>> str(dict)
"{'Name': 'Runoob', 'Class': 'First', 'Age': 7}"

>>> dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
>>> type(dict)
<class 'dict'>

Python字典包含了以下内置方法：

Python3 集合

集合（set）是一个无序的不重复元素序列。

可以使用大括号 { } 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。

创建格式：

parame = {value01,value02,...}
或者
set(value)

实例(Python 3.0+)

>>> basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}
>>> print(basket)                      # 这里演示的是去重功能
{'orange', 'banana', 'pear', 'apple'}
>>> 'orange' in basket                 # 快速判断元素是否在集合内
True
>>> 'crabgrass' in basket
False>>> # 下面展示两个集合间的运算.
...
>>> a = set('abracadabra')
>>> b = set('alacazam')
>>> a                                  
{'a', 'r', 'b', 'c', 'd'}
>>> a - b                              # 集合a中包含而集合b中不包含的元素
{'r', 'd', 'b'}
>>> a | b                              # 集合a或b中包含的所有元素
{'a', 'c', 'r', 'd', 'b', 'm', 'z', 'l'}
>>> a & b                              # 集合a和b中都包含了的元素
{'a', 'c'}
>>> a ^ b                              # 不同时包含于a和b的元素
{'r', 'd', 'b', 'm', 'z', 'l'}

类似列表推导式，同样集合支持集合推导式(Set comprehension):

实例(Python 3.0+)

>>> a = {x for x in 'abracadabra' if x not in 'abc'}
>>> a
{'r', 'd'}

集合的基本操作

1、添加元素

语法格式如下：

s.add( x )

将元素 x 添加到集合 s 中，如果元素已存在，则不进行任何操作。

实例(Python 3.0+)

>>> thisset = set(("Google", "Runoob", "Taobao"))
>>> thisset.add("Facebook")
>>> print(thisset)
{'Taobao', 'Facebook', 'Google', 'Runoob'}

还有一个方法，也可以添加元素，且参数可以是列表，元组，字典等，语法格式如下：

s.update( x )

x 可以有多个，用逗号分开。

实例(Python 3.0+)

>>> thisset = set(("Google", "Runoob", "Taobao"))
>>> thisset.update({1,3})
>>> print(thisset)
{1, 3, 'Google', 'Taobao', 'Runoob'}
>>> thisset.update([1,4],[5,6])  
>>> print(thisset)
{1, 3, 4, 5, 6, 'Google', 'Taobao', 'Runoob'}
>>>

2、移除元素

语法格式如下：

s.remove( x )

将元素 x 从集合 s 中移除，如果元素不存在，则会发生错误。

实例(Python 3.0+)

>>> thisset = set(("Google", "Runoob", "Taobao"))
>>> thisset.remove("Taobao")
>>> print(thisset)
{'Google', 'Runoob'}
>>> thisset.remove("Facebook")   # 不存在会发生错误
Traceback (most recent call last):File "<stdin>", line 1, in <module>
KeyError: 'Facebook'
>>>

此外还有一个方法也是移除集合中的元素，且如果元素不存在，不会发生错误。格式如下所示：

s.discard( x )

实例(Python 3.0+)

>>> thisset = set(("Google", "Runoob", "Taobao"))
>>> thisset.discard("Facebook")  # 不存在不会发生错误
>>> print(thisset)
{'Taobao', 'Google', 'Runoob'}

我们也可以设置随机删除集合中的一个元素，语法格式如下：

s.pop() 

脚本模式实例(Python 3.0+)

thisset = set(("Google", "Runoob", "Taobao", "Facebook"))
x = thisset.pop()print(x)

输出结果：

$ python3 test.py 
Runoob

多次执行测试结果都不一样。

set 集合的 pop 方法会对集合进行无序的排列，然后将这个无序排列集合的左面第一个元素进行删除。

3、计算集合元素个数

语法格式如下：

len(s)

计算集合 s 元素个数。

实例(Python 3.0+)

>>> thisset = set(("Google", "Runoob", "Taobao"))
>>> len(thisset)
3

4、清空集合

语法格式如下：

s.clear()

清空集合 s。

实例(Python 3.0+)

>>> thisset = set(("Google", "Runoob", "Taobao"))
>>> thisset.clear()
>>> print(thisset)
set()

5、判断元素是否在集合中存在

语法格式如下：

x in s

判断元素 x 是否在集合 s 中，存在返回 True，不存在返回 False。

实例(Python 3.0+)

>>> thisset = set(("Google", "Runoob", "Taobao"))
>>> "Runoob" in thisset
True
>>> "Facebook" in thisset
False
>>>

集合内置方法完整列表

Python3 编程第一步

在前面的教程中我们已经学习了一些 Python3 的基本语法知识，下面我们尝试来写一个斐波纳契数列。

实例(Python 3.0+)

#!/usr/bin/python3# Fibonacci series: 斐波纳契数列
# 两个元素的总和确定了下一个数
a, b = 0, 1
while b < 10:print(b)a, b = b, a+b

其中代码 a, b = b, a+b 的计算方式为先计算右边表达式，然后同时赋值给左边，等价于：

n=b
m=a+b
a=n
b=m

执行以上程序，输出结果为：

1
1
2
3
5
8

这个例子介绍了几个新特征。

第一行包含了一个复合赋值：变量 a 和 b 同时得到新值 0 和 1。最后一行再次使用了同样的方法，可以看到，右边的表达式会在赋值变动之前执行。右边表达式的执行顺序是从左往右的。

输出变量值:

>>> i = 256*256
>>> print('i 的值为：', i)
i 的值为： 65536

end 关键字

关键字end可以用于将结果输出到同一行，或者在输出的末尾添加不同的字符，实例如下：

实例(Python 3.0+)

#!/usr/bin/python3# Fibonacci series: 斐波纳契数列
# 两个元素的总和确定了下一个数
a, b = 0, 1
while b < 1000:print(b, end=',')a, b = b, a+b

执行以上程序，输出结果为：

1,1,2,3,5,8,13,21,34,55,89,144,233,377,610,987,

Python3 条件控制

Python 条件语句是通过一条或多条语句的执行结果（True 或者 False）来决定执行的代码块。

可以通过下图来简单了解条件语句的执行过程:

代码执行过程：

if 语句

Python中if语句的一般形式如下所示：

if condition_1:statement_block_1
elif condition_2:statement_block_2
else:statement_block_3

• 如果 "condition_1" 为 True 将执行 "statement_block_1" 块语句
• 如果 "condition_1" 为False，将判断 "condition_2"
• 如果"condition_2" 为 True 将执行 "statement_block_2" 块语句
• 如果 "condition_2" 为False，将执行"statement_block_3"块语句

Python 中用 elif 代替了 else if，所以if语句的关键字为：if – elif – else。

注意：

• 1、每个条件后面要使用冒号 :，表示接下来是满足条件后要执行的语句块。
• 2、使用缩进来划分语句块，相同缩进数的语句在一起组成一个语句块。
• 3、在Python中没有switch – case语句。

Gif 演示：

实例

以下是一个简单的 if 实例：

实例

#!/usr/bin/python3var1 = 100
if var1:print ("1 - if 表达式条件为 true")print (var1)var2 = 0
if var2:print ("2 - if 表达式条件为 true")print (var2)
print ("Good bye!")

执行以上代码，输出结果为：

1 - if 表达式条件为 true
100
Good bye!

从结果可以看到由于变量 var2 为 0，所以对应的 if 内的语句没有执行。

以下实例演示了狗的年龄计算判断：

实例

#!/usr/bin/python3age = int(input("请输入你家狗狗的年龄: "))
print("")
if age <= 0:print("你是在逗我吧!")
elif age == 1:print("相当于 14 岁的人。")
elif age == 2:print("相当于 22 岁的人。")
elif age > 2:human = 22 + (age -2)*5print("对应人类年龄: ", human)### 退出提示
input("点击 enter 键退出")

将以上脚本保存在dog.py文件中，并执行该脚本：

$ python3 dog.py 
请输入你家狗狗的年龄: 1相当于 14 岁的人。
点击 enter 键退出

以下为if中常用的操作运算符:

实例

#!/usr/bin/python3# 程序演示了 == 操作符
# 使用数字
print(5 == 6)
# 使用变量
x = 5
y = 8
print(x == y)

以上实例输出结果：

False
False

high_low.py文件演示了数字的比较运算：

实例

#!/usr/bin/python3 # 该实例演示了数字猜谜游戏
number = 7
guess = -1
print("数字猜谜游戏!")
while guess != number:guess = int(input("请输入你猜的数字："))if guess == number:print("恭喜，你猜对了！")elif guess < number:print("猜的数字小了...")elif guess > number:print("猜的数字大了...")

执行以上脚本，实例输出结果如下：

$ python3 high_low.py 
数字猜谜游戏!
请输入你猜的数字：1
猜的数字小了...
请输入你猜的数字：9
猜的数字大了...
请输入你猜的数字：7
恭喜，你猜对了！

if 嵌套

在嵌套 if 语句中，可以把 if...elif...else 结构放在另外一个 if...elif...else 结构中。

if 表达式1:语句if 表达式2:语句elif 表达式3:语句else:语句
elif 表达式4:语句
else:语句

实例

# !/usr/bin/python3num=int(input("输入一个数字："))
if num%2==0:if num%3==0:print ("你输入的数字可以整除 2 和 3")else:print ("你输入的数字可以整除 2，但不能整除 3")
else:if num%3==0:print ("你输入的数字可以整除 3，但不能整除 2")else:print  ("你输入的数字不能整除 2 和 3")

将以上程序保存到 test_if.py 文件中，执行后输出结果为：

$ python3 test.py 
输入一个数字：6
你输入的数字可以整除 2 和 3

Python3 循环语句

本章节将为大家介绍 Python 循环语句的使用。

Python 中的循环语句有 for 和 while。

Python 循环语句的控制结构图如下所示：

while 循环

Python 中 while 语句的一般形式：

while 判断条件(condition)：执行语句(statements)……

执行流程图如下：

执行 Gif 演示：

同样需要注意冒号和缩进。另外，在 Python 中没有 do..while 循环。

以下实例使用了 while 来计算 1 到 100 的总和：

实例

#!/usr/bin/env python3n = 100sum = 0
counter = 1
while counter <= n:sum = sum + countercounter += 1print("1 到 %d 之和为: %d" % (n,sum))

执行结果如下：

1 到 100 之和为: 5050

无限循环

我们可以通过设置条件表达式永远不为 false 来实现无限循环，实例如下：

实例

#!/usr/bin/python3var = 1
while var == 1 :  # 表达式永远为 truenum = int(input("输入一个数字  :"))print ("你输入的数字是: ", num)print ("Good bye!")

执行以上脚本，输出结果如下：

输入一个数字  :5
你输入的数字是:  5
输入一个数字  :

你可以使用 CTRL+C 来退出当前的无限循环。

无限循环在服务器上客户端的实时请求非常有用。

while 循环使用 else 语句

如果 while 后面的条件语句为 false 时，则执行 else 的语句块。

语法格式如下：

while <expr>:<statement(s)>
else:<additional_statement(s)>

expr 条件语句为 true 则执行 statement(s) 语句块，如果为 false，则执行 additional_statement(s)。

循环输出数字，并判断大小：

实例

#!/usr/bin/python3count = 0
while count < 5:print (count, " 小于 5")count = count + 1
else:print (count, " 大于或等于 5")

执行以上脚本，输出结果如下：

0  小于 5
1  小于 5
2  小于 5
3  小于 5
4  小于 5
5  大于或等于 5

简单语句组

类似if语句的语法，如果你的while循环体中只有一条语句，你可以将该语句与while写在同一行中， 如下所示：

实例

#!/usr/bin/pythonflag = 1while (flag): print ('欢迎访问菜鸟教程!')print ("Good bye!")

注意：以上的无限循环你可以使用 CTRL+C 来中断循环。

执行以上脚本，输出结果如下：

欢迎访问菜鸟教程!
欢迎访问菜鸟教程!
欢迎访问菜鸟教程!
欢迎访问菜鸟教程!
欢迎访问菜鸟教程!
……

for 语句

Python for 循环可以遍历任何可迭代对象，如一个列表或者一个字符串。

for循环的一般格式如下：

for <variable> in <sequence>: <statements> else: <statements>

流程图：

Python for 循环实例：

实例

>>>languages = ["C", "C++", "Perl", "Python"] 
>>> for x in languages:
...     print (x)
... 
C
C++
Perl
Python
>>>

以下 for 实例中使用了 break 语句，break 语句用于跳出当前循环体：

实例

#!/usr/bin/python3sites = ["Baidu", "Google","Runoob","Taobao"]
for site in sites:if site == "Runoob":print("菜鸟教程!")breakprint("循环数据 " + site)
else:print("没有循环数据!")
print("完成循环!")

执行脚本后，在循环到 "Runoob"时会跳出循环体：

循环数据 Baidu
循环数据 Google
菜鸟教程!
完成循环!

range()函数

如果你需要遍历数字序列，可以使用内置range()函数。它会生成数列，例如:

实例

>>>for i in range(5):
...     print(i)
...
0
1
2
3
4

你也可以使用range指定区间的值：

实例

>>>for i in range(5,9) :print(i)5
6
7
8
>>>

也可以使range以指定数字开始并指定不同的增量(甚至可以是负数，有时这也叫做'步长'):

实例

>>>for i in range(0, 10, 3) :print(i)0
3
6
9
>>>

负数：

实例

>>>for i in range(-10, -100, -30) :print(i)-10
-40
-70
>>>

您可以结合range()和len()函数以遍历一个序列的索引,如下所示:

实例

>>>a = ['Google', 'Baidu', 'Runoob', 'Taobao', 'QQ']
>>> for i in range(len(a)):
...     print(i, a[i])
... 
0 Google
1 Baidu
2 Runoob
3 Taobao
4 QQ
>>>

还可以使用range()函数来创建一个列表：

实例

>>>list(range(5))
[0, 1, 2, 3, 4]
>>>

break 和 continue 语句及循环中的 else 子句

break 执行流程图：

continue 执行流程图：

while 语句代码执行过程：

for 语句代码执行过程：

break 语句可以跳出 for 和 while 的循环体。如果你从 for 或 while 循环中终止，任何对应的循环 else 块将不执行。

continue 语句被用来告诉 Python 跳过当前循环块中的剩余语句，然后继续进行下一轮循环。

实例

while 中使用 break：

实例

n = 5
while n > 0:n -= 1if n == 2:breakprint(n)
print('循环结束。')

输出结果为：

4
3
循环结束。

while 中使用 continue：

实例

n = 5
while n > 0:n -= 1if n == 2:continueprint(n)
print('循环结束。')

输出结果为：

4
3
1
0
循环结束。

更多实例如下：

实例

#!/usr/bin/python3for letter in 'Runoob':     # 第一个实例if letter == 'b':breakprint ('当前字母为 :', letter)var = 10                    # 第二个实例
while var > 0:              print ('当期变量值为 :', var)var = var -1if var == 5:breakprint ("Good bye!")

执行以上脚本输出结果为：

当前字母为 : R
当前字母为 : u
当前字母为 : n
当前字母为 : o
当前字母为 : o
当期变量值为 : 10
当期变量值为 : 9
当期变量值为 : 8
当期变量值为 : 7
当期变量值为 : 6
Good bye!

以下实例循环字符串 Runoob，碰到字母 o 跳过输出：

实例

#!/usr/bin/python3for letter in 'Runoob':     # 第一个实例if letter == 'o':        # 字母为 o 时跳过输出continueprint ('当前字母 :', letter)var = 10                    # 第二个实例
while var > 0:              var = var -1if var == 5:             # 变量为 5 时跳过输出continueprint ('当前变量值 :', var)
print ("Good bye!")

执行以上脚本输出结果为：

当前字母 : R
当前字母 : u
当前字母 : n
当前字母 : b
当前变量值 : 9
当前变量值 : 8
当前变量值 : 7
当前变量值 : 6
当前变量值 : 4
当前变量值 : 3
当前变量值 : 2
当前变量值 : 1
当前变量值 : 0
Good bye!

循环语句可以有 else 子句，它在穷尽列表(以for循环)或条件变为 false (以while循环)导致循环终止时被执行，但循环被 break 终止时不执行。

如下实例用于查询质数的循环例子:

实例

#!/usr/bin/python3for n in range(2, 10):for x in range(2, n):if n % x == 0:print(n, '等于', x, '*', n//x)breakelse:# 循环中没有找到元素print(n, ' 是质数')

执行以上脚本输出结果为：

2  是质数
3  是质数
4 等于 2 * 2
5  是质数
6 等于 2 * 3
7  是质数
8 等于 2 * 4
9 等于 3 * 3

pass 语句

Python pass是空语句，是为了保持程序结构的完整性。

pass 不做任何事情，一般用做占位语句，如下实例

实例

>>>while True:
...     pass  # 等待键盘中断 (Ctrl+C)

最小的类:

实例

>>>class MyEmptyClass:
...     pass

以下实例在字母为 o 时 执行 pass 语句块:

实例

#!/usr/bin/python3for letter in 'Runoob': if letter == 'o':passprint ('执行 pass 块')print ('当前字母 :', letter)print ("Good bye!")

执行以上脚本输出结果为：

当前字母 : R
当前字母 : u
当前字母 : n
执行 pass 块
当前字母 : o
执行 pass 块
当前字母 : o
当前字母 : b
Good bye!

Python3 迭代器与生成器

迭代器

迭代是Python最强大的功能之一，是访问集合元素的一种方式。

迭代器是一个可以记住遍历的位置的对象。

迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完结束。迭代器只能往前不会后退。

迭代器有两个基本的方法：iter() 和 next()。

字符串，列表或元组对象都可用于创建迭代器：

实例(Python 3.0+)

>>> list=[1,2,3,4]
>>> it = iter(list)    # 创建迭代器对象
>>> print (next(it))   # 输出迭代器的下一个元素
1
>>> print (next(it))
2
>>>

迭代器对象可以使用常规for语句进行遍历：

实例(Python 3.0+)

#!/usr/bin/python3list=[1,2,3,4]
it = iter(list)    # 创建迭代器对象
for x in it:print (x, end=" ")

执行以上程序，输出结果如下：

1 2 3 4

也可以使用 next() 函数：

实例(Python 3.0+)

#!/usr/bin/python3import sys         # 引入 sys 模块list=[1,2,3,4]
it = iter(list)    # 创建迭代器对象while True:try:print (next(it))except StopIteration:sys.exit()

执行以上程序，输出结果如下：

1
2
3
4

创建一个迭代器

把一个类作为一个迭代器使用需要在类中实现两个方法 __iter__() 与 __next__() 。

如果你已经了解的面向对象编程，就知道类都有一个构造函数，Python 的构造函数为 __init__(), 它会在对象初始化的时候执行。

更多内容查阅：Python3 面向对象

__iter__() 方法返回一个特殊的迭代器对象， 这个迭代器对象实现了 __next__() 方法并通过 StopIteration 异常标识迭代的完成。

__next__() 方法（Python 2 里是 next()）会返回下一个迭代器对象。

创建一个返回数字的迭代器，初始值为 1，逐步递增 1：

实例(Python 3.0+)

class MyNumbers:def __iter__(self):self.a = 1return selfdef __next__(self):x = self.aself.a += 1return xmyclass = MyNumbers()
myiter = iter(myclass)print(next(myiter))
print(next(myiter))
print(next(myiter))
print(next(myiter))
print(next(myiter))

执行输出结果为：

1
2
3
4
5

StopIteration

StopIteration 异常用于标识迭代的完成，防止出现无限循环的情况，在 __next__() 方法中我们可以设置在完成指定循环次数后触发 StopIteration 异常来结束迭代。

在 20 次迭代后停止执行：

实例(Python 3.0+)

class MyNumbers:def __iter__(self):self.a = 1return selfdef __next__(self):if self.a <= 20:x = self.aself.a += 1return xelse:raise StopIterationmyclass = MyNumbers()
myiter = iter(myclass)for x in myiter:print(x)

执行输出结果为：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

生成器

在 Python 中，使用了 yield 的函数被称为生成器（generator）。

跟普通函数不同的是，生成器是一个返回迭代器的函数，只能用于迭代操作，更简单点理解生成器就是一个迭代器。

在调用生成器运行的过程中，每次遇到 yield 时函数会暂停并保存当前所有的运行信息，返回 yield 的值, 并在下一次执行 next() 方法时从当前位置继续运行。

调用一个生成器函数，返回的是一个迭代器对象。

以下实例使用 yield 实现斐波那契数列：

实例(Python 3.0+)

#!/usr/bin/python3import sysdef fibonacci(n): # 生成器函数 - 斐波那契a, b, counter = 0, 1, 0while True:if (counter > n): returnyield aa, b = b, a + bcounter += 1
f = fibonacci(10) # f 是一个迭代器，由生成器返回生成while True:try:print (next(f), end=" ")except StopIteration:sys.exit()

执行以上程序，输出结果如下：

0 1 1 2 3 5 8 13 21 34 55

Python3 函数

函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段。

函数能提高应用的模块性，和代码的重复利用率。你已经知道Python提供了许多内建函数，比如print()。但你也可以自己创建函数，这被叫做用户自定义函数。

定义一个函数

你可以定义一个由自己想要功能的函数，以下是简单的规则：

• 函数代码块以 def 关键词开头，后接函数标识符名称和圆括号 ()。
• 任何传入参数和自变量必须放在圆括号中间，圆括号之间可以用于定义参数。
• 函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
• 函数内容以冒号 : 起始，并且缩进。
• return [表达式] 结束函数，选择性地返回一个值给调用方，不带表达式的 return 相当于返回 None。

语法

Python 定义函数使用 def 关键字，一般格式如下：

def 函数名（参数列表）:函数体

默认情况下，参数值和参数名称是按函数声明中定义的顺序匹配起来的。

实例

让我们使用函数来输出"Hello World！"：

#!/usr/bin/python3def hello() :print("Hello World!")hello()

更复杂点的应用，函数中带上参数变量:

实例(Python 3.0+)

比较两个数，并返回较大的数:

#!/usr/bin/python3def max(a, b):if a > b:return aelse:return ba = 4
b = 5
print(max(a, b))

以上实例输出结果：

5

实例(Python 3.0+)

计算面积函数:

#!/usr/bin/python3# 计算面积函数
def area(width, height):return width * heightdef print_welcome(name):print("Welcome", name)print_welcome("Runoob")
w = 4
h = 5
print("width =", w, " height =", h, " area =", area(w, h))

以上实例输出结果：

Welcome Runoob
width = 4  height = 5  area = 20

函数调用

定义一个函数：给了函数一个名称，指定了函数里包含的参数，和代码块结构。

这个函数的基本结构完成以后，你可以通过另一个函数调用执行，也可以直接从 Python 命令提示符执行。

如下实例调用了 printme() 函数：

实例(Python 3.0+)

#!/usr/bin/python3# 定义函数
def printme( str ):# 打印任何传入的字符串print (str)return# 调用函数
printme("我要调用用户自定义函数!")
printme("再次调用同一函数")

以上实例输出结果：

我要调用用户自定义函数!
再次调用同一函数

参数传递

在 python 中，类型属于对象，变量是没有类型的：

a=[1,2,3]a="Runoob"

以上代码中，[1,2,3] 是 List 类型，"Runoob" 是 String 类型，而变量 a 是没有类型，她仅仅是一个对象的引用（一个指针），可以是指向 List 类型对象，也可以是指向 String 类型对象。

可更改(mutable)与不可更改(immutable)对象

在 python 中，strings, tuples, 和 numbers 是不可更改的对象，而 list,dict 等则是可以修改的对象。

• 不可变类型：变量赋值 a=5 后再赋值 a=10，这里实际是新生成一个 int 值对象 10，再让 a 指向它，而 5 被丢弃，不是改变 a 的值，相当于新生成了 a。

• 可变类型：变量赋值 la=[1,2,3,4] 后再赋值 la[2]=5 则是将 list la 的第三个元素值更改，本身la没有动，只是其内部的一部分值被修改了。

python 函数的参数传递：

• 不可变类型：类似 C++ 的值传递，如整数、字符串、元组。如 fun(a)，传递的只是 a 的值，没有影响 a 对象本身。如果在 fun(a) 内部修改 a 的值，则是新生成一个 a 的对象。

• 可变类型：类似 C++ 的引用传递，如 列表，字典。如 fun(la)，则是将 la 真正的传过去，修改后 fun 外部的 la 也会受影响

python 中一切都是对象，严格意义我们不能说值传递还是引用传递，我们应该说传不可变对象和传可变对象。

python 传不可变对象实例

通过 id() 函数来查看内存地址变化：

实例(Python 3.0+)

def change(a):print(id(a))   # 指向的是同一个对象a=10print(id(a))   # 一个新对象a=1
print(id(a))
change(a)

以上实例输出结果为：

4379369136
4379369136
4379369424

可以看见在调用函数前后，形参和实参指向的是同一个对象（对象 id 相同），在函数内部修改形参后，形参指向的是不同的 id。

传可变对象实例

可变对象在函数里修改了参数，那么在调用这个函数的函数里，原始的参数也被改变了。例如：

实例(Python 3.0+)

#!/usr/bin/python3# 可写函数说明
def changeme( mylist ):"修改传入的列表"mylist.append([1,2,3,4])print ("函数内取值: ", mylist)return# 调用changeme函数
mylist = [10,20,30]
changeme( mylist )
print ("函数外取值: ", mylist)

传入函数的和在末尾添加新内容的对象用的是同一个引用。故输出结果如下：

函数内取值:  [10, 20, 30, [1, 2, 3, 4]]
函数外取值:  [10, 20, 30, [1, 2, 3, 4]]

参数

以下是调用函数时可使用的正式参数类型：

• 必需参数
• 关键字参数
• 默认参数
• 不定长参数

必需参数

必需参数须以正确的顺序传入函数。调用时的数量必须和声明时的一样。

调用 printme() 函数，你必须传入一个参数，不然会出现语法错误：

实例(Python 3.0+)

#!/usr/bin/python3#可写函数说明
def printme( str ):"打印任何传入的字符串"print (str)return# 调用 printme 函数，不加参数会报错
printme()

以上实例输出结果：

Traceback (most recent call last):File "test.py", line 10, in <module>printme()
TypeError: printme() missing 1 required positional argument: 'str'

关键字参数

关键字参数和函数调用关系紧密，函数调用使用关键字参数来确定传入的参数值。

使用关键字参数允许函数调用时参数的顺序与声明时不一致，因为 Python 解释器能够用参数名匹配参数值。

以下实例在函数 printme() 调用时使用参数名：

实例(Python 3.0+)

#!/usr/bin/python3#可写函数说明
def printme( str ):"打印任何传入的字符串"print (str)return#调用printme函数
printme( str = "菜鸟教程")

以上实例输出结果：

菜鸟教程

以下实例中演示了函数参数的使用不需要使用指定顺序：

实例(Python 3.0+)

#!/usr/bin/python3#可写函数说明
def printinfo( name, age ):"打印任何传入的字符串"print ("名字: ", name)print ("年龄: ", age)return#调用printinfo函数
printinfo( age=50, name="runoob" )

以上实例输出结果：

名字:  runoob
年龄:  50

默认参数

调用函数时，如果没有传递参数，则会使用默认参数。以下实例中如果没有传入 age 参数，则使用默认值：

实例(Python 3.0+)

#!/usr/bin/python3#可写函数说明
def printinfo( name, age = 35 ):"打印任何传入的字符串"print ("名字: ", name)print ("年龄: ", age)return#调用printinfo函数
printinfo( age=50, name="runoob" )
print ("------------------------")
printinfo( name="runoob" )

以上实例输出结果：

名字:  runoob
年龄:  50
------------------------
名字:  runoob
年龄:  35

不定长参数

你可能需要一个函数能处理比当初声明时更多的参数。这些参数叫做不定长参数，和上述 2 种参数不同，声明时不会命名。基本语法如下：

def functionname([formal_args,] *var_args_tuple ):"函数_文档字符串"function_suitereturn [expression]

加了星号 * 的参数会以元组(tuple)的形式导入，存放所有未命名的变量参数。

实例(Python 3.0+)

#!/usr/bin/python3# 可写函数说明
def printinfo( arg1, *vartuple ):"打印任何传入的参数"print ("输出: ")print (arg1)print (vartuple)# 调用printinfo 函数
printinfo( 70, 60, 50 )

以上实例输出结果：

输出: 
70
(60, 50)

如果在函数调用时没有指定参数，它就是一个空元组。我们也可以不向函数传递未命名的变量。如下实例：

实例(Python 3.0+)

#!/usr/bin/python3# 可写函数说明
def printinfo( arg1, *vartuple ):"打印任何传入的参数"print ("输出: ")print (arg1)for var in vartuple:print (var)return# 调用printinfo 函数
printinfo( 10 )
printinfo( 70, 60, 50 )

以上实例输出结果：

输出:
10
输出:
70
60
50

还有一种就是参数带两个星号 **基本语法如下：

def functionname([formal_args,] **var_args_dict ):"函数_文档字符串"function_suitereturn [expression]

加了两个星号 ** 的参数会以字典的形式导入。

实例(Python 3.0+)

#!/usr/bin/python3# 可写函数说明
def printinfo( arg1, **vardict ):"打印任何传入的参数"print ("输出: ")print (arg1)print (vardict)# 调用printinfo 函数
printinfo(1, a=2,b=3)

以上实例输出结果：

输出: 
1
{'a': 2, 'b': 3}

声明函数时，参数中星号 * 可以单独出现，例如:

def f(a,b,*,c):return a+b+c

如果单独出现星号 * 后的参数必须用关键字传入。

>>> def f(a,b,*,c):
...     return a+b+c
... 
>>> f(1,2,3)   # 报错
Traceback (most recent call last):File "<stdin>", line 1, in <module>
TypeError: f() takes 2 positional arguments but 3 were given
>>> f(1,2,c=3) # 正常
6
>>>

匿名函数

python 使用 lambda 来创建匿名函数。

所谓匿名，意即不再使用 def 语句这样标准的形式定义一个函数。

• lambda 只是一个表达式，函数体比 def 简单很多。
• lambda的主体是一个表达式，而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去。
• lambda 函数拥有自己的命名空间，且不能访问自己参数列表之外或全局命名空间里的参数。
• 虽然lambda函数看起来只能写一行，却不等同于C或C++的内联函数，后者的目的是调用小函数时不占用栈内存从而增加运行效率。

语法

lambda 函数的语法只包含一个语句，如下：

lambda [arg1 [,arg2,.....argn]]:expression

如下实例：

实例(Python 3.0+)

#!/usr/bin/python3# 可写函数说明
sum = lambda arg1, arg2: arg1 + arg2# 调用sum函数
print ("相加后的值为 : ", sum( 10, 20 ))
print ("相加后的值为 : ", sum( 20, 20 ))

以上实例输出结果：

相加后的值为 :  30
相加后的值为 :  40

return语句

return [表达式] 语句用于退出函数，选择性地向调用方返回一个表达式。不带参数值的return语句返回None。之前的例子都没有示范如何返回数值，以下实例演示了 return 语句的用法：

实例(Python 3.0+)

#!/usr/bin/python3# 可写函数说明
def sum( arg1, arg2 ):# 返回2个参数的和."total = arg1 + arg2print ("函数内 : ", total)return total# 调用sum函数
total = sum( 10, 20 )
print ("函数外 : ", total)

以上实例输出结果：

函数内 :  30
函数外 :  30

强制位置参数

Python3.8 新增了一个函数形参语法 / 用来指明函数形参必须使用指定位置参数，不能使用关键字参数的形式。

在以下的例子中，形参 a 和 b 必须使用指定位置参数，c 或 d 可以是位置形参或关键字形参，而 e 和 f 要求为关键字形参:

def f(a, b, /, c, d, *, e, f):print(a, b, c, d, e, f)

以下使用方法是正确的:

f(10, 20, 30, d=40, e=50, f=60)

以下使用方法会发生错误:

f(10, b=20, c=30, d=40, e=50, f=60)   # b 不能使用关键字参数的形式
f(10, 20, 30, 40, 50, f=60)           # e 必须使用关键字参数的形式

Python3 数据结构

本章节我们主要结合前面所学的知识点来介绍Python数据结构。

列表

Python中列表是可变的，这是它区别于字符串和元组的最重要的特点，一句话概括即：列表可以修改，而字符串和元组不能。

以下是 Python 中列表的方法：

下面示例演示了列表的大部分方法：

实例

>>> a = [66.25, 333, 333, 1, 1234.5]
>>> print(a.count(333), a.count(66.25), a.count('x'))
2 1 0
>>> a.insert(2, -1)
>>> a.append(333)
>>> a
[66.25, 333, -1, 333, 1, 1234.5, 333]
>>> a.index(333)
1
>>> a.remove(333)
>>> a
[66.25, -1, 333, 1, 1234.5, 333]
>>> a.reverse()
>>> a
[333, 1234.5, 1, 333, -1, 66.25]
>>> a.sort()
>>> a
[-1, 1, 66.25, 333, 333, 1234.5]

注意：类似 insert, remove 或 sort 等修改列表的方法没有返回值。

将列表当做堆栈使用

列表方法使得列表可以很方便的作为一个堆栈来使用，堆栈作为特定的数据结构，最先进入的元素最后一个被释放（后进先出）。用 append() 方法可以把一个元素添加到堆栈顶。用不指定索引的 pop() 方法可以把一个元素从堆栈顶释放出来。例如：

实例

>>> stack = [3, 4, 5]
>>> stack.append(6)
>>> stack.append(7)
>>> stack
[3, 4, 5, 6, 7]
>>> stack.pop()
7
>>> stack
[3, 4, 5, 6]
>>> stack.pop()
6
>>> stack.pop()
5
>>> stack
[3, 4]

将列表当作队列使用

也可以把列表当做队列用，只是在队列里第一加入的元素，第一个取出来；但是拿列表用作这样的目的效率不高。在列表的最后添加或者弹出元素速度快，然而在列表里插入或者从头部弹出速度却不快（因为所有其他的元素都得一个一个地移动）。

实例

>>> from collections import deque
>>> queue = deque(["Eric", "John", "Michael"])
>>> queue.append("Terry")           # Terry arrives
>>> queue.append("Graham")          # Graham arrives
>>> queue.popleft()                 # The first to arrive now leaves
'Eric'
>>> queue.popleft()                 # The second to arrive now leaves
'John'
>>> queue                           # Remaining queue in order of arrival
deque(['Michael', 'Terry', 'Graham'])

列表推导式

列表推导式提供了从序列创建列表的简单途径。通常应用程序将一些操作应用于某个序列的每个元素，用其获得的结果作为生成新列表的元素，或者根据确定的判定条件创建子序列。

每个列表推导式都在 for 之后跟一个表达式，然后有零到多个 for 或 if 子句。返回结果是一个根据表达从其后的 for 和 if 上下文环境中生成出来的列表。如果希望表达式推导出一个元组，就必须使用括号。

这里我们将列表中每个数值乘三，获得一个新的列表：

>>> vec = [2, 4, 6]
>>> [3*x for x in vec]
[6, 12, 18]

现在我们玩一点小花样：

>>> [[x, x**2] for x in vec]
[[2, 4], [4, 16], [6, 36]]

这里我们对序列里每一个元素逐个调用某方法：

实例

>>> freshfruit = ['  banana', '  loganberry ', 'passion fruit  ']
>>> [weapon.strip() for weapon in freshfruit]
['banana', 'loganberry', 'passion fruit']

我们可以用 if 子句作为过滤器：

>>> [3*x for x in vec if x > 3]
[12, 18]
>>> [3*x for x in vec if x < 2]
[]

以下是一些关于循环和其它技巧的演示：

>>> vec1 = [2, 4, 6]
>>> vec2 = [4, 3, -9]
>>> [x*y for x in vec1 for y in vec2]
[8, 6, -18, 16, 12, -36, 24, 18, -54]
>>> [x+y for x in vec1 for y in vec2]
[6, 5, -7, 8, 7, -5, 10, 9, -3]
>>> [vec1[i]*vec2[i] for i in range(len(vec1))]
[8, 12, -54]

列表推导式可以使用复杂表达式或嵌套函数：

>>> [str(round(355/113, i)) for i in range(1, 6)]
['3.1', '3.14', '3.142', '3.1416', '3.14159']

嵌套列表解析

Python的列表还可以嵌套。

以下实例展示了3X4的矩阵列表：

>>> matrix = [
...     [1, 2, 3, 4],
...     [5, 6, 7, 8],
...     [9, 10, 11, 12],
... ]

以下实例将3X4的矩阵列表转换为4X3列表：

>>> [[row[i] for row in matrix] for i in range(4)]
[[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]

以下实例也可以使用以下方法来实现：

>>> transposed = []
>>> for i in range(4):
...     transposed.append([row[i] for row in matrix])
...
>>> transposed
[[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]

另外一种实现方法：

>>> transposed = []
>>> for i in range(4):
...     # the following 3 lines implement the nested listcomp
...     transposed_row = []
...     for row in matrix:
...         transposed_row.append(row[i])
...     transposed.append(transposed_row)
...
>>> transposed
[[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]

del 语句

使用 del 语句可以从一个列表中依索引而不是值来删除一个元素。这与使用 pop() 返回一个值不同。可以用 del 语句从列表中删除一个切割，或清空整个列表（我们以前介绍的方法是给该切割赋一个空列表）。例如：

>>> a = [-1, 1, 66.25, 333, 333, 1234.5]
>>> del a[0]
>>> a
[1, 66.25, 333, 333, 1234.5]
>>> del a[2:4]
>>> a
[1, 66.25, 1234.5]
>>> del a[:]
>>> a
[]

也可以用 del 删除实体变量：

>>> del a

元组和序列

元组由若干逗号分隔的值组成，例如：

>>> t = 12345, 54321, 'hello!'
>>> t[0]
12345
>>> t
(12345, 54321, 'hello!')
>>> # Tuples may be nested:
... u = t, (1, 2, 3, 4, 5)
>>> u
((12345, 54321, 'hello!'), (1, 2, 3, 4, 5))

如你所见，元组在输出时总是有括号的，以便于正确表达嵌套结构。在输入时可能有或没有括号， 不过括号通常是必须的（如果元组是更大的表达式的一部分）。

集合

集合是一个无序不重复元素的集。基本功能包括关系测试和消除重复元素。

可以用大括号({})创建集合。注意：如果要创建一个空集合，你必须用 set() 而不是 {} ；后者创建一个空的字典，下一节我们会介绍这个数据结构。

以下是一个简单的演示：

>>> basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}
>>> print(basket)                      # 删除重复的
{'orange', 'banana', 'pear', 'apple'}
>>> 'orange' in basket                 # 检测成员
True
>>> 'crabgrass' in basket
False>>> # 以下演示了两个集合的操作
...
>>> a = set('abracadabra')
>>> b = set('alacazam')
>>> a                                  # a 中唯一的字母
{'a', 'r', 'b', 'c', 'd'}
>>> a - b                              # 在 a 中的字母，但不在 b 中
{'r', 'd', 'b'}
>>> a | b                              # 在 a 或 b 中的字母
{'a', 'c', 'r', 'd', 'b', 'm', 'z', 'l'}
>>> a & b                              # 在 a 和 b 中都有的字母
{'a', 'c'}
>>> a ^ b                              # 在 a 或 b 中的字母，但不同时在 a 和 b 中
{'r', 'd', 'b', 'm', 'z', 'l'}

集合也支持推导式：

>>> a = {x for x in 'abracadabra' if x not in 'abc'}
>>> a
{'r', 'd'}

字典

另一个非常有用的 Python 内建数据类型是字典。

序列是以连续的整数为索引，与此不同的是，字典以关键字为索引，关键字可以是任意不可变类型，通常用字符串或数值。

理解字典的最佳方式是把它看做无序的键=>值对集合。在同一个字典之内，关键字必须是互不相同。

一对大括号创建一个空的字典：{}。

这是一个字典运用的简单例子：

>>> tel = {'jack': 4098, 'sape': 4139}
>>> tel['guido'] = 4127
>>> tel
{'sape': 4139, 'guido': 4127, 'jack': 4098}
>>> tel['jack']
4098
>>> del tel['sape']
>>> tel['irv'] = 4127
>>> tel
{'guido': 4127, 'irv': 4127, 'jack': 4098}
>>> list(tel.keys())
['irv', 'guido', 'jack']
>>> sorted(tel.keys())
['guido', 'irv', 'jack']
>>> 'guido' in tel
True
>>> 'jack' not in tel
False

构造函数 dict() 直接从键值对元组列表中构建字典。如果有固定的模式，列表推导式指定特定的键值对：

>>> dict([('sape', 4139), ('guido', 4127), ('jack', 4098)])
{'sape': 4139, 'jack': 4098, 'guido': 4127}

此外，字典推导可以用来创建任意键和值的表达式词典：

>>> {x: x**2 for x in (2, 4, 6)}
{2: 4, 4: 16, 6: 36}

如果关键字只是简单的字符串，使用关键字参数指定键值对有时候更方便：

>>> dict(sape=4139, guido=4127, jack=4098)
{'sape': 4139, 'jack': 4098, 'guido': 4127}

遍历技巧

在字典中遍历时，关键字和对应的值可以使用 items() 方法同时解读出来：

>>> knights = {'gallahad': 'the pure', 'robin': 'the brave'}
>>> for k, v in knights.items():
...     print(k, v)
...
gallahad the pure
robin the brave

在序列中遍历时，索引位置和对应值可以使用 enumerate() 函数同时得到：

>>> for i, v in enumerate(['tic', 'tac', 'toe']):
...     print(i, v)
...
0 tic
1 tac
2 toe

同时遍历两个或更多的序列，可以使用 zip() 组合：

>>> questions = ['name', 'quest', 'favorite color']
>>> answers = ['lancelot', 'the holy grail', 'blue']
>>> for q, a in zip(questions, answers):
...     print('What is your {0}?  It is {1}.'.format(q, a))
...
What is your name?  It is lancelot.
What is your quest?  It is the holy grail.
What is your favorite color?  It is blue.

要反向遍历一个序列，首先指定这个序列，然后调用 reversed() 函数：

>>> for i in reversed(range(1, 10, 2)):
...     print(i)
...
9
7
5
3
1

要按顺序遍历一个序列，使用 sorted() 函数返回一个已排序的序列，并不修改原值：

>>> basket = ['apple', 'orange', 'apple', 'pear', 'orange', 'banana']
>>> for f in sorted(set(basket)):
...     print(f)
...
apple
banana
orange
pear

Python3 模块

在前面的几个章节中我们基本上是用 python 解释器来编程，如果你从 Python 解释器退出再进入，那么你定义的所有的方法和变量就都消失了。

为此 Python 提供了一个办法，把这些定义存放在文件中，为一些脚本或者交互式的解释器实例使用，这个文件被称为模块。

模块是一个包含所有你定义的函数和变量的文件，其后缀名是.py。模块可以被别的程序引入，以使用该模块中的函数等功能。这也是使用 python 标准库的方法。

下面是一个使用 python 标准库中模块的例子。

实例(Python 3.0+)

#!/usr/bin/python3
# 文件名: using_sys.pyimport sysprint('命令行参数如下:')
for i in sys.argv:print(i)print('\n\nPython 路径为：', sys.path, '\n')

执行结果如下所示：

$ python using_sys.py 参数1 参数2
命令行参数如下:
using_sys.py
参数1
参数2Python 路径为： ['/root', '/usr/lib/python3.4', '/usr/lib/python3.4/plat-x86_64-linux-gnu', '/usr/lib/python3.4/lib-dynload', '/usr/local/lib/python3.4/dist-packages', '/usr/lib/python3/dist-packages'] 

• 1、import sys 引入 python 标准库中的 sys.py 模块；这是引入某一模块的方法。
• 2、sys.argv 是一个包含命令行参数的列表。
• 3、sys.path 包含了一个 Python 解释器自动查找所需模块的路径的列表。

import 语句

想使用 Python 源文件，只需在另一个源文件里执行 import 语句，语法如下：

import module1[, module2[,... moduleN]

当解释器遇到 import 语句，如果模块在当前的搜索路径就会被导入。

搜索路径是一个解释器会先进行搜索的所有目录的列表。如想要导入模块 support，需要把命令放在脚本的顶端：

support.py 文件代码

#!/usr/bin/python3
# Filename: support.pydef print_func( par ):print ("Hello : ", par)return

test.py 引入 support 模块：

test.py 文件代码

#!/usr/bin/python3
# Filename: test.py# 导入模块
import support# 现在可以调用模块里包含的函数了
support.print_func("Runoob")

以上实例输出结果：

$ python3 test.py 
Hello :  Runoob

一个模块只会被导入一次，不管你执行了多少次import。这样可以防止导入模块被一遍又一遍地执行。

当我们使用import语句的时候，Python解释器是怎样找到对应的文件的呢？

这就涉及到Python的搜索路径，搜索路径是由一系列目录名组成的，Python解释器就依次从这些目录中去寻找所引入的模块。

这看起来很像环境变量，事实上，也可以通过定义环境变量的方式来确定搜索路径。

搜索路径是在Python编译或安装的时候确定的，安装新的库应该也会修改。搜索路径被存储在sys模块中的path变量，做一个简单的实验，在交互式解释器中，输入以下代码：

>>> import sys
>>> sys.path
['', '/usr/lib/python3.4', '/usr/lib/python3.4/plat-x86_64-linux-gnu', '/usr/lib/python3.4/lib-dynload', '/usr/local/lib/python3.4/dist-packages', '/usr/lib/python3/dist-packages']
>>> 

sys.path 输出是一个列表，其中第一项是空串''，代表当前目录（若是从一个脚本中打印出来的话，可以更清楚地看出是哪个目录），亦即我们执行python解释器的目录（对于脚本的话就是运行的脚本所在的目录）。

因此若像我一样在当前目录下存在与要引入模块同名的文件，就会把要引入的模块屏蔽掉。

了解了搜索路径的概念，就可以在脚本中修改sys.path来引入一些不在搜索路径中的模块。

现在，在解释器的当前目录或者 sys.path 中的一个目录里面来创建一个fibo.py的文件，代码如下：

实例

# 斐波那契(fibonacci)数列模块def fib(n):    # 定义到 n 的斐波那契数列a, b = 0, 1while b < n:print(b, end=' ')a, b = b, a+bprint()def fib2(n): # 返回到 n 的斐波那契数列result = []a, b = 0, 1while b < n:result.append(b)a, b = b, a+breturn result

然后进入Python解释器，使用下面的命令导入这个模块：

>>> import fibo

这样做并没有把直接定义在fibo中的函数名称写入到当前符号表里，只是把模块fibo的名字写到了那里。

可以使用模块名称来访问函数：

实例

>>>fibo.fib(1000)
1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987
>>> fibo.fib2(100)
[1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]
>>> fibo.__name__
'fibo

如果你打算经常使用一个函数，你可以把它赋给一个本地的名称：

>>> fib = fibo.fib
>>> fib(500)
1 1 2 3 5 8 13 21 34 55 89 144 233 377

from … import 语句

Python 的 from 语句让你从模块中导入一个指定的部分到当前命名空间中，语法如下：

from modname import name1[, name2[, ... nameN]]

例如，要导入模块 fibo 的 fib 函数，使用如下语句：

>>> from fibo import fib, fib2
>>> fib(500)
1 1 2 3 5 8 13 21 34 55 89 144 233 377

这个声明不会把整个fibo模块导入到当前的命名空间中，它只会将fibo里的fib函数引入进来。

from … import * 语句

把一个模块的所有内容全都导入到当前的命名空间也是可行的，只需使用如下声明：

from modname import *

这提供了一个简单的方法来导入一个模块中的所有项目。然而这种声明不该被过多地使用。

深入模块

模块除了方法定义，还可以包括可执行的代码。这些代码一般用来初始化这个模块。这些代码只有在第一次被导入时才会被执行。

每个模块有各自独立的符号表，在模块内部为所有的函数当作全局符号表来使用。

所以，模块的作者可以放心大胆的在模块内部使用这些全局变量，而不用担心把其他用户的全局变量搞混。

从另一个方面，当你确实知道你在做什么的话，你也可以通过 modname.itemname 这样的表示法来访问模块内的函数。

模块是可以导入其他模块的。在一个模块（或者脚本，或者其他地方）的最前面使用 import 来导入一个模块，当然这只是一个惯例，而不是强制的。被导入的模块的名称将被放入当前操作的模块的符号表中。

还有一种导入的方法，可以使用 import 直接把模块内（函数，变量的）名称导入到当前操作模块。比如:

>>> from fibo import fib, fib2
>>> fib(500)
1 1 2 3 5 8 13 21 34 55 89 144 233 377

这种导入的方法不会把被导入的模块的名称放在当前的字符表中（所以在这个例子里面，fibo 这个名称是没有定义的）。

这还有一种方法，可以一次性的把模块中的所有（函数，变量）名称都导入到当前模块的字符表:

>>> from fibo import *
>>> fib(500)
1 1 2 3 5 8 13 21 34 55 89 144 233 377

这将把所有的名字都导入进来，但是那些由单一下划线（_）开头的名字不在此例。大多数情况， Python程序员不使用这种方法，因为引入的其它来源的命名，很可能覆盖了已有的定义。

__name__属性

一个模块被另一个程序第一次引入时，其主程序将运行。如果我们想在模块被引入时，模块中的某一程序块不执行，我们可以用__name__属性来使该程序块仅在该模块自身运行时执行。

#!/usr/bin/python3
# Filename: using_name.pyif __name__ == '__main__':print('程序自身在运行')
else:print('我来自另一模块')

运行输出如下：

$ python using_name.py
程序自身在运行

$ python
>>> import using_name
我来自另一模块
>>>

说明： 每个模块都有一个__name__属性，当其值是'__main__'时，表明该模块自身在运行，否则是被引入。

说明：__name__ 与 __main__ 底下是双下划线， _ _ 是这样去掉中间的那个空格。

dir() 函数

内置的函数 dir() 可以找到模块内定义的所有名称。以一个字符串列表的形式返回:

>>> import fibo, sys
>>> dir(fibo)
['__name__', 'fib', 'fib2']
>>> dir(sys)  
['__displayhook__', '__doc__', '__excepthook__', '__loader__', '__name__','__package__', '__stderr__', '__stdin__', '__stdout__','_clear_type_cache', '_current_frames', '_debugmallocstats', '_getframe','_home', '_mercurial', '_xoptions', 'abiflags', 'api_version', 'argv','base_exec_prefix', 'base_prefix', 'builtin_module_names', 'byteorder','call_tracing', 'callstats', 'copyright', 'displayhook','dont_write_bytecode', 'exc_info', 'excepthook', 'exec_prefix','executable', 'exit', 'flags', 'float_info', 'float_repr_style','getcheckinterval', 'getdefaultencoding', 'getdlopenflags','getfilesystemencoding', 'getobjects', 'getprofile', 'getrecursionlimit','getrefcount', 'getsizeof', 'getswitchinterval', 'gettotalrefcount','gettrace', 'hash_info', 'hexversion', 'implementation', 'int_info','intern', 'maxsize', 'maxunicode', 'meta_path', 'modules', 'path','path_hooks', 'path_importer_cache', 'platform', 'prefix', 'ps1','setcheckinterval', 'setdlopenflags', 'setprofile', 'setrecursionlimit','setswitchinterval', 'settrace', 'stderr', 'stdin', 'stdout','thread_info', 'version', 'version_info', 'warnoptions']

如果没有给定参数，那么 dir() 函数会罗列出当前定义的所有名称:

>>> a = [1, 2, 3, 4, 5]
>>> import fibo
>>> fib = fibo.fib
>>> dir() # 得到一个当前模块中定义的属性列表
['__builtins__', '__name__', 'a', 'fib', 'fibo', 'sys']
>>> a = 5 # 建立一个新的变量 'a'
>>> dir()
['__builtins__', '__doc__', '__name__', 'a', 'sys']
>>>
>>> del a # 删除变量名a
>>>
>>> dir()
['__builtins__', '__doc__', '__name__', 'sys']
>>>

标准模块

Python 本身带着一些标准的模块库，在 Python 库参考文档中将会介绍到（就是后面的"库参考文档"）。

有些模块直接被构建在解析器里，这些虽然不是一些语言内置的功能，但是他却能很高效的使用，甚至是系统级调用也没问题。

这些组件会根据不同的操作系统进行不同形式的配置，比如 winreg 这个模块就只会提供给 Windows 系统。

应该注意到这有一个特别的模块 sys ，它内置在每一个 Python 解析器中。变量 sys.ps1 和 sys.ps2 定义了主提示符和副提示符所对应的字符串:

>>> import sys
>>> sys.ps1
'>>> '
>>> sys.ps2
'... '
>>> sys.ps1 = 'C> '
C> print('Runoob!')
Runoob!
C> 

包

包是一种管理 Python 模块命名空间的形式，采用"点模块名称"。

比如一个模块的名称是 A.B， 那么他表示一个包 A中的子模块 B 。

就好像使用模块的时候，你不用担心不同模块之间的全局变量相互影响一样，采用点模块名称这种形式也不用担心不同库之间的模块重名的情况。

这样不同的作者都可以提供 NumPy 模块，或者是 Python 图形库。

不妨假设你想设计一套统一处理声音文件和数据的模块（或者称之为一个"包"）。

现存很多种不同的音频文件格式（基本上都是通过后缀名区分的，例如： .wav，:file:.aiff，:file:.au，），所以你需要有一组不断增加的模块，用来在不同的格式之间转换。

并且针对这些音频数据，还有很多不同的操作（比如混音，添加回声，增加均衡器功能，创建人造立体声效果），所以你还需要一组怎么也写不完的模块来处理这些操作。

这里给出了一种可能的包结构（在分层的文件系统中）:

sound/                          顶层包__init__.py               初始化 sound 包formats/                  文件格式转换子包__init__.pywavread.pywavwrite.pyaiffread.pyaiffwrite.pyauread.pyauwrite.py...effects/                  声音效果子包__init__.pyecho.pysurround.pyreverse.py...filters/                  filters 子包__init__.pyequalizer.pyvocoder.pykaraoke.py...

在导入一个包的时候，Python 会根据 sys.path 中的目录来寻找这个包中包含的子目录。

目录只有包含一个叫做 __init__.py 的文件才会被认作是一个包，主要是为了避免一些滥俗的名字（比如叫做 string）不小心的影响搜索路径中的有效模块。

最简单的情况，放一个空的 :file:__init__.py就可以了。当然这个文件中也可以包含一些初始化代码或者为（将在后面介绍的） __all__变量赋值。

用户可以每次只导入一个包里面的特定模块，比如:

import sound.effects.echo

这将会导入子模块:sound.effects.echo。 他必须使用全名去访问:

sound.effects.echo.echofilter(input, output, delay=0.7, atten=4)

还有一种导入子模块的方法是:

from sound.effects import echo

这同样会导入子模块: echo，并且他不需要那些冗长的前缀，所以他可以这样使用:

echo.echofilter(input, output, delay=0.7, atten=4)

还有一种变化就是直接导入一个函数或者变量:

from sound.effects.echo import echofilter

同样的，这种方法会导入子模块: echo，并且可以直接使用他的 echofilter() 函数:

echofilter(input, output, delay=0.7, atten=4)

注意当使用 from package import item 这种形式的时候，对应的 item 既可以是包里面的子模块（子包），或者包里面定义的其他名称，比如函数，类或者变量。

import 语法会首先把 item 当作一个包定义的名称，如果没找到，再试图按照一个模块去导入。如果还没找到，抛出一个 :exc:ImportError 异常。

反之，如果使用形如 import item.subitem.subsubitem 这种导入形式，除了最后一项，都必须是包，而最后一项则可以是模块或者是包，但是不可以是类，函数或者变量的名字。

从一个包中导入*

如果我们使用 from sound.effects import * 会发生什么呢？

Python 会进入文件系统，找到这个包里面所有的子模块，然后一个一个的把它们都导入进来。

但这个方法在 Windows 平台上工作的就不是非常好，因为 Windows 是一个不区分大小写的系统。

在 Windows 平台平台上，我们无法确定一个叫做 ECHO.py 的文件导入为模块是 echo 还是 Echo，或者是 ECHO。

为了解决这个问题，我们只需要提供一个精确包的索引。

导入语句遵循如下规则：如果包定义文件 __init__.py 存在一个叫做 __all__ 的列表变量，那么在使用 from package import * 的时候就把这个列表中的所有名字作为包内容导入。

作为包的作者，可别忘了在更新包之后保证 __all__ 也更新了啊。

以下实例在 file:sounds/effects/__init__.py 中包含如下代码:

__all__ = ["echo", "surround", "reverse"]

这表示当你使用from sound.effects import *这种用法时，你只会导入包里面这三个子模块。

如果 __all__ 真的没有定义，那么使用from sound.effects import *这种语法的时候，就不会导入包 sound.effects 里的任何子模块。他只是把包sound.effects和它里面定义的所有内容导入进来（可能运行__init__.py里定义的初始化代码）。

这会把 __init__.py 里面定义的所有名字导入进来。并且他不会破坏掉我们在这句话之前导入的所有明确指定的模块。看下这部分代码:

import sound.effects.echo
import sound.effects.surround
from sound.effects import *

这个例子中，在执行 from...import 前，包 sound.effects 中的 echo 和 surround 模块都被导入到当前的命名空间中了。（当然如果定义了 __all__ 就更没问题了）

通常我们并不主张使用 * 这种方法来导入模块，因为这种方法经常会导致代码的可读性降低。不过这样倒的确是可以省去不少敲键的功夫，而且一些模块都设计成了只能通过特定的方法导入。

记住，使用 from Package import specific_submodule 这种方法永远不会有错。事实上，这也是推荐的方法。除非是你要导入的子模块有可能和其他包的子模块重名。

如果在结构中包是一个子包（比如这个例子中对于包sound来说），而你又想导入兄弟包（同级别的包）你就得使用导入绝对的路径来导入。比如，如果模块sound.filters.vocoder 要使用包 sound.effects 中的模块 echo，你就要写成 from sound.effects import echo。

from . import echo
from .. import formats
from ..filters import equalizer

无论是隐式的还是显式的相对导入都是从当前模块开始的。主模块的名字永远是"__main__"，一个Python应用程序的主模块，应当总是使用绝对路径引用。

包还提供一个额外的属性__path__。这是一个目录列表，里面每一个包含的目录都有为这个包服务的__init__.py，你得在其他__init__.py被执行前定义哦。可以修改这个变量，用来影响包含在包里面的模块和子包。

这个功能并不常用，一般用来扩展包里面的模块。

Python3 输入和输出

在前面几个章节中，我们其实已经接触了 Python 的输入输出的功能。本章节我们将具体介绍 Python 的输入输出。

输出格式美化

Python两种输出值的方式: 表达式语句和 print() 函数。

第三种方式是使用文件对象的 write() 方法，标准输出文件可以用 sys.stdout 引用。

如果你希望输出的形式更加多样，可以使用 str.format() 函数来格式化输出值。

如果你希望将输出的值转成字符串，可以使用 repr() 或 str() 函数来实现。

• str()： 函数返回一个用户易读的表达形式。
• repr()： 产生一个解释器易读的表达形式。

例如

>>> s = 'Hello, Runoob'
>>> str(s)
'Hello, Runoob'
>>> repr(s)
"'Hello, Runoob'"
>>> str(1/7)
'0.14285714285714285'
>>> x = 10 * 3.25
>>> y = 200 * 200
>>> s = 'x 的值为： ' + repr(x) + ',  y 的值为：' + repr(y) + '...'
>>> print(s)
x 的值为： 32.5,  y 的值为：40000...
>>> #  repr() 函数可以转义字符串中的特殊字符
... hello = 'hello, runoob\n'
>>> hellos = repr(hello)
>>> print(hellos)
'hello, runoob\n'
>>> # repr() 的参数可以是 Python 的任何对象
... repr((x, y, ('Google', 'Runoob')))
"(32.5, 40000, ('Google', 'Runoob'))"

这里有两种方式输出一个平方与立方的表:

>>> for x in range(1, 11):
...     print(repr(x).rjust(2), repr(x*x).rjust(3), end=' ')
...     # 注意前一行 'end' 的使用
...     print(repr(x*x*x).rjust(4))
...1   1    12   4    83   9   274  16   645  25  1256  36  2167  49  3438  64  5129  81  729
10 100 1000>>> for x in range(1, 11):
...     print('{0:2d} {1:3d} {2:4d}'.format(x, x*x, x*x*x))
...1   1    12   4    83   9   274  16   645  25  1256  36  2167  49  3438  64  5129  81  729
10 100 1000

注意：在第一个例子中, 每列间的空格由 print() 添加。

这个例子展示了字符串对象的 rjust() 方法, 它可以将字符串靠右, 并在左边填充空格。

还有类似的方法, 如 ljust() 和 center()。 这些方法并不会写任何东西, 它们仅仅返回新的字符串。

另一个方法 zfill(), 它会在数字的左边填充 0，如下所示：

>>> '12'.zfill(5)
'00012'
>>> '-3.14'.zfill(7)
'-003.14'
>>> '3.14159265359'.zfill(5)
'3.14159265359'

str.format() 的基本使用如下:

>>> print('{}网址： "{}!"'.format('菜鸟教程', 'www.runoob.com'))
菜鸟教程网址： "www.runoob.com!"

括号及其里面的字符 (称作格式化字段) 将会被 format() 中的参数替换。

在括号中的数字用于指向传入对象在 format() 中的位置，如下所示：

>>> print('{0} 和 {1}'.format('Google', 'Runoob'))
Google 和 Runoob
>>> print('{1} 和 {0}'.format('Google', 'Runoob'))
Runoob 和 Google

如果在 format() 中使用了关键字参数, 那么它们的值会指向使用该名字的参数。

>>> print('{name}网址： {site}'.format(name='菜鸟教程', site='www.runoob.com'))
菜鸟教程网址： www.runoob.com

位置及关键字参数可以任意的结合:

>>> print('站点列表 {0}, {1}, 和 {other}。'.format('Google', 'Runoob', other='Taobao'))
站点列表 Google, Runoob, 和 Taobao。

!a (使用 ascii()), !s (使用 str()) 和 !r (使用 repr()) 可以用于在格式化某个值之前对其进行转化:

>>> import math
>>> print('常量 PI 的值近似为： {}。'.format(math.pi))
常量 PI 的值近似为： 3.141592653589793。
>>> print('常量 PI 的值近似为： {!r}。'.format(math.pi))
常量 PI 的值近似为： 3.141592653589793。

可选项 : 和格式标识符可以跟着字段名。 这就允许对值进行更好的格式化。 下面的例子将 Pi 保留到小数点后三位：

>>> import math
>>> print('常量 PI 的值近似为 {0:.3f}。'.format(math.pi))
常量 PI 的值近似为 3.142。

在 : 后传入一个整数, 可以保证该域至少有这么多的宽度。 用于美化表格时很有用。

>>> table = {'Google': 1, 'Runoob': 2, 'Taobao': 3}
>>> for name, number in table.items():
...     print('{0:10} ==> {1:10d}'.format(name, number))
...
Google     ==>          1
Runoob     ==>          2
Taobao     ==>          3

如果你有一个很长的格式化字符串, 而你不想将它们分开, 那么在格式化时通过变量名而非位置会是很好的事情。

最简单的就是传入一个字典, 然后使用方括号 [] 来访问键值 :

>>> table = {'Google': 1, 'Runoob': 2, 'Taobao': 3}
>>> print('Runoob: {0[Runoob]:d}; Google: {0[Google]:d}; Taobao: {0[Taobao]:d}'.format(table))
Runoob: 2; Google: 1; Taobao: 3

也可以通过在 table 变量前使用 ** 来实现相同的功能：

>>> table = {'Google': 1, 'Runoob': 2, 'Taobao': 3}
>>> print('Runoob: {Runoob:d}; Google: {Google:d}; Taobao: {Taobao:d}'.format(**table))
Runoob: 2; Google: 1; Taobao: 3

旧式字符串格式化

% 操作符也可以实现字符串格式化。 它将左边的参数作为类似 sprintf() 式的格式化字符串, 而将右边的代入, 然后返回格式化后的字符串. 例如:

>>> import math
>>> print('常量 PI 的值近似为：%5.3f。' % math.pi)
常量 PI 的值近似为：3.142。

因为 str.format() 是比较新的函数， 大多数的 Python 代码仍然使用 % 操作符。但是因为这种旧式的格式化最终会从该语言中移除, 应该更多的使用 str.format().

读取键盘输入

Python 提供了 input() 内置函数从标准输入读入一行文本，默认的标准输入是键盘。

实例

#!/usr/bin/python3str = input("请输入：");
print ("你输入的内容是: ", str)

这会产生如下的对应着输入的结果：

请输入：菜鸟教程
你输入的内容是:  菜鸟教程

读和写文件

open() 将会返回一个 file 对象，基本语法格式如下:

open(filename, mode)

• filename：包含了你要访问的文件名称的字符串值。
• mode：决定了打开文件的模式：只读，写入，追加等。所有可取值见如下的完全列表。这个参数是非强制的，默认文件访问模式为只读(r)。

不同模式打开文件的完全列表：

下图很好的总结了这几种模式：

以下实例将字符串写入到文件 foo.txt 中：

实例

#!/usr/bin/python3# 打开一个文件
f = open("/tmp/foo.txt", "w")f.write( "Python 是一个非常好的语言。\n是的，的确非常好!!\n" )# 关闭打开的文件
f.close()

• 第一个参数为要打开的文件名。
• 第二个参数描述文件如何使用的字符。 mode 可以是 'r' 如果文件只读, 'w' 只用于写 (如果存在同名文件则将被删除), 和 'a' 用于追加文件内容; 所写的任何数据都会被自动增加到末尾. 'r+' 同时用于读写。 mode 参数是可选的; 'r' 将是默认值。

此时打开文件 foo.txt,显示如下：

$ cat /tmp/foo.txt 
Python 是一个非常好的语言。
是的，的确非常好!!

文件对象的方法

本节中剩下的例子假设已经创建了一个称为 f 的文件对象。

f.read()

为了读取一个文件的内容，调用 f.read(size), 这将读取一定数目的数据, 然后作为字符串或字节对象返回。

size 是一个可选的数字类型的参数。 当 size 被忽略了或者为负, 那么该文件的所有内容都将被读取并且返回。

以下实例假定文件 foo.txt 已存在（上面实例中已创建）：

实例

#!/usr/bin/python3# 打开一个文件
f = open("/tmp/foo.txt", "r")str = f.read()
print(str)# 关闭打开的文件
f.close()

执行以上程序，输出结果为：

Python 是一个非常好的语言。
是的，的确非常好!!

f.readline()

f.readline() 会从文件中读取单独的一行。换行符为 '\n'。f.readline() 如果返回一个空字符串, 说明已经已经读取到最后一行。

实例

#!/usr/bin/python3# 打开一个文件
f = open("/tmp/foo.txt", "r")str = f.readline()
print(str)# 关闭打开的文件
f.close()

执行以上程序，输出结果为：

Python 是一个非常好的语言。

f.readlines()

f.readlines() 将返回该文件中包含的所有行。

如果设置可选参数 sizehint, 则读取指定长度的字节, 并且将这些字节按行分割。

实例

#!/usr/bin/python3# 打开一个文件
f = open("/tmp/foo.txt", "r")str = f.readlines()
print(str)# 关闭打开的文件
f.close()

执行以上程序，输出结果为：

['Python 是一个非常好的语言。\n', '是的，的确非常好!!\n']

另一种方式是迭代一个文件对象然后读取每行:

实例

#!/usr/bin/python3# 打开一个文件
f = open("/tmp/foo.txt", "r")for line in f:print(line, end='')# 关闭打开的文件
f.close()

执行以上程序，输出结果为：

Python 是一个非常好的语言。
是的，的确非常好!!

这个方法很简单, 但是并没有提供一个很好的控制。 因为两者的处理机制不同, 最好不要混用。

f.write()

f.write(string) 将 string 写入到文件中, 然后返回写入的字符数。

实例

#!/usr/bin/python3# 打开一个文件
f = open("/tmp/foo.txt", "w")num = f.write( "Python 是一个非常好的语言。\n是的，的确非常好!!\n" )
print(num)
# 关闭打开的文件
f.close()

执行以上程序，输出结果为：

29

如果要写入一些不是字符串的东西, 那么将需要先进行转换:

实例

#!/usr/bin/python3# 打开一个文件
f = open("/tmp/foo1.txt", "w")value = ('www.runoob.com', 14)
s = str(value)
f.write(s)# 关闭打开的文件
f.close()

执行以上程序，打开 foo1.txt 文件：

$ cat /tmp/foo1.txt 
('www.runoob.com', 14)

f.tell()

f.tell() 返回文件对象当前所处的位置, 它是从文件开头开始算起的字节数。

f.seek()

如果要改变文件当前的位置, 可以使用 f.seek(offset, from_what) 函数。

from_what 的值, 如果是 0 表示开头, 如果是 1 表示当前位置, 2 表示文件的结尾，例如：

• seek(x,0) ： 从起始位置即文件首行首字符开始移动 x 个字符
• seek(x,1) ： 表示从当前位置往后移动x个字符
• seek(-x,2)：表示从文件的结尾往前移动x个字符

from_what 值为默认为0，即文件开头。下面给出一个完整的例子：

>>> f = open('/tmp/foo.txt', 'rb+')
>>> f.write(b'0123456789abcdef')
16
>>> f.seek(5)     # 移动到文件的第六个字节
5
>>> f.read(1)
b'5'
>>> f.seek(-3, 2) # 移动到文件的倒数第三字节
13
>>> f.read(1)
b'd'

f.close()

在文本文件中 (那些打开文件的模式下没有 b 的), 只会相对于文件起始位置进行定位。

当你处理完一个文件后, 调用 f.close() 来关闭文件并释放系统的资源，如果尝试再调用该文件，则会抛出异常。

>>> f.close()
>>> f.read()
Traceback (most recent call last):File "<stdin>", line 1, in ?
ValueError: I/O operation on closed file

当处理一个文件对象时, 使用 with 关键字是非常好的方式。在结束后, 它会帮你正确的关闭文件。 而且写起来也比 try - finally 语句块要简短:

>>> with open('/tmp/foo.txt', 'r') as f:
...     read_data = f.read()
>>> f.closed
True

文件对象还有其他方法, 如 isatty() 和 trucate(), 但这些通常比较少用。

pickle 模块

python的pickle模块实现了基本的数据序列和反序列化。

通过pickle模块的序列化操作我们能够将程序中运行的对象信息保存到文件中去，永久存储。

通过pickle模块的反序列化操作，我们能够从文件中创建上一次程序保存的对象。

基本接口：

pickle.dump(obj, file, [,protocol])

有了 pickle 这个对象, 就能对 file 以读取的形式打开:

x = pickle.load(file)

注解：从 file 中读取一个字符串，并将它重构为原来的python对象。

file: 类文件对象，有read()和readline()接口。

实例 1

#!/usr/bin/python3
import pickle# 使用pickle模块将数据对象保存到文件
data1 = {'a': [1, 2.0, 3, 4+6j],'b': ('string', u'Unicode string'),'c': None}selfref_list = [1, 2, 3]
selfref_list.append(selfref_list)output = open('data.pkl', 'wb')# Pickle dictionary using protocol 0.
pickle.dump(data1, output)# Pickle the list using the highest protocol available.
pickle.dump(selfref_list, output, -1)output.close()

实例 2

#!/usr/bin/python3
import pprint, pickle#使用pickle模块从文件中重构python对象
pkl_file = open('data.pkl', 'rb')data1 = pickle.load(pkl_file)
pprint.pprint(data1)data2 = pickle.load(pkl_file)
pprint.pprint(data2)pkl_file.close()

Python3 File(文件) 方法

open() 方法

Python open() 方法用于打开一个文件，并返回文件对象，在对文件进行处理过程都需要使用到这个函数，如果该文件无法被打开，会抛出 OSError。

注意：使用 open() 方法一定要保证关闭文件对象，即调用 close() 方法。

open() 函数常用形式是接收两个参数：文件名(file)和模式(mode)。

open(file, mode='r')

完整的语法格式为：

open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)

参数说明:

• file: 必需，文件路径（相对或者绝对路径）。
• mode: 可选，文件打开模式
• buffering: 设置缓冲
• encoding: 一般使用utf8
• errors: 报错级别
• newline: 区分换行符
• closefd: 传入的file参数类型
• opener: 设置自定义开启器，开启器的返回值必须是一个打开的文件描述符。

mode 参数有：

默认为文本模式，如果要以二进制模式打开，加上 b 。

file 对象

file 对象使用 open 函数来创建，下表列出了 file 对象常用的函数：

Python3 OS 文件/目录方法

os 模块提供了非常丰富的方法用来处理文件和目录。常用的方法如下表所示：

Python3 错误和异常

作为 Python 初学者，在刚学习 Python 编程时，经常会看到一些报错信息，在前面我们没有提及，这章节我们会专门介绍。

Python 有两种错误很容易辨认：语法错误和异常。

Python assert（断言）用于判断一个表达式，在表达式条件为 false 的时候触发异常。

语法错误

Python 的语法错误或者称之为解析错，是初学者经常碰到的，如下实例

>>> while True print('Hello world')File "<stdin>", line 1, in ?while True print('Hello world')^
SyntaxError: invalid syntax

这个例子中，函数 print() 被检查到有错误，是它前面缺少了一个冒号 : 。

语法分析器指出了出错的一行，并且在最先找到的错误的位置标记了一个小小的箭头。

异常

即便 Python 程序的语法是正确的，在运行它的时候，也有可能发生错误。运行期检测到的错误被称为异常。

大多数的异常都不会被程序处理，都以错误信息的形式展现在这里:

实例

>>> 10 * (1/0)             # 0 不能作为除数，触发异常
Traceback (most recent call last):File "<stdin>", line 1, in ?
ZeroDivisionError: division by zero
>>> 4 + spam*3             # spam 未定义，触发异常
Traceback (most recent call last):File "<stdin>", line 1, in ?
NameError: name 'spam' is not defined
>>> '2' + 2               # int 不能与 str 相加，触发异常
Traceback (most recent call last):File "<stdin>", line 1, in <module>
TypeError: can only concatenate str (not "int") to str

异常以不同的类型出现，这些类型都作为信息的一部分打印出来: 例子中的类型有 ZeroDivisionError，NameError 和 TypeError。

错误信息的前面部分显示了异常发生的上下文，并以调用栈的形式显示具体信息。

异常处理

try/except

异常捕捉可以使用 try/except 语句。

以下例子中，让用户输入一个合法的整数，但是允许用户中断这个程序（使用 Control-C 或者操作系统提供的方法）。用户中断的信息会引发一个 KeyboardInterrupt 异常。

while True:try:x = int(input("请输入一个数字: "))breakexcept ValueError:print("您输入的不是数字，请再次尝试输入！")

try 语句按照如下方式工作；

• 首先，执行 try 子句（在关键字 try 和关键字 except 之间的语句）。

• 如果没有异常发生，忽略 except 子句，try 子句执行后结束。

• 如果在执行 try 子句的过程中发生了异常，那么 try 子句余下的部分将被忽略。如果异常的类型和 except 之后的名称相符，那么对应的 except 子句将被执行。

• 如果一个异常没有与任何的 except 匹配，那么这个异常将会传递给上层的 try 中。

一个 try 语句可能包含多个except子句，分别来处理不同的特定的异常。最多只有一个分支会被执行。

处理程序将只针对对应的 try 子句中的异常进行处理，而不是其他的 try 的处理程序中的异常。

一个except子句可以同时处理多个异常，这些异常将被放在一个括号里成为一个元组，例如:

except (RuntimeError, TypeError, NameError):pass

最后一个except子句可以忽略异常的名称，它将被当作通配符使用。你可以使用这种方法打印一个错误信息，然后再次把异常抛出。

import systry:f = open('myfile.txt')s = f.readline()i = int(s.strip())
except OSError as err:print("OS error: {0}".format(err))
except ValueError:print("Could not convert data to an integer.")
except:print("Unexpected error:", sys.exc_info()[0])raise

try/except...else

try/except 语句还有一个可选的 else 子句，如果使用这个子句，那么必须放在所有的 except 子句之后。

else 子句将在 try 子句没有发生任何异常的时候执行。

以下实例在 try 语句中判断文件是否可以打开，如果打开文件时正常的没有发生异常则执行 else 部分的语句，读取文件内容：

for arg in sys.argv[1:]:try:f = open(arg, 'r')except IOError:print('cannot open', arg)else:print(arg, 'has', len(f.readlines()), 'lines')f.close()

使用 else 子句比把所有的语句都放在 try 子句里面要好，这样可以避免一些意想不到，而 except 又无法捕获的异常。

异常处理并不仅仅处理那些直接发生在 try 子句中的异常，而且还能处理子句中调用的函数（甚至间接调用的函数）里抛出的异常。例如:

>>> def this_fails():x = 1/0>>> try:this_fails()except ZeroDivisionError as err:print('Handling run-time error:', err)Handling run-time error: int division or modulo by zero

try-finally 语句

try-finally 语句无论是否发生异常都将执行最后的代码。

以下实例中 finally 语句无论异常是否发生都会执行：

实例

try:runoob()
except AssertionError as error:print(error)
else:try:with open('file.log') as file:read_data = file.read()except FileNotFoundError as fnf_error:print(fnf_error)
finally:print('这句话，无论异常是否发生都会执行。')

抛出异常

Python 使用 raise 语句抛出一个指定的异常。

raise语法格式如下：

raise [Exception [, args [, traceback]]]

以下实例如果 x 大于 5 就触发异常:

x = 10
if x > 5:raise Exception('x 不能大于 5。x 的值为: {}'.format(x))

执行以上代码会触发异常：

Traceback (most recent call last):File "test.py", line 3, in <module>raise Exception('x 不能大于 5。x 的值为: {}'.format(x))
Exception: x 不能大于 5。x 的值为: 10

raise 唯一的一个参数指定了要被抛出的异常。它必须是一个异常的实例或者是异常的类（也就是 Exception 的子类）。

如果你只想知道这是否抛出了一个异常，并不想去处理它，那么一个简单的 raise 语句就可以再次把它抛出。

>>> try:raise NameError('HiThere')except NameError:print('An exception flew by!')raiseAn exception flew by!
Traceback (most recent call last):File "<stdin>", line 2, in ?
NameError: HiThere

用户自定义异常

你可以通过创建一个新的异常类来拥有自己的异常。异常类继承自 Exception 类，可以直接继承，或者间接继承，例如:

>>> class MyError(Exception):def __init__(self, value):self.value = valuedef __str__(self):return repr(self.value)>>> try:raise MyError(2*2)except MyError as e:print('My exception occurred, value:', e.value)My exception occurred, value: 4
>>> raise MyError('oops!')
Traceback (most recent call last):File "<stdin>", line 1, in ?
__main__.MyError: 'oops!'

在这个例子中，类 Exception 默认的 __init__() 被覆盖。

当创建一个模块有可能抛出多种不同的异常时，一种通常的做法是为这个包建立一个基础异常类，然后基于这个基础类为不同的错误情况创建不同的子类:

class Error(Exception):"""Base class for exceptions in this module."""passclass InputError(Error):"""Exception raised for errors in the input.Attributes:expression -- input expression in which the error occurredmessage -- explanation of the error"""def __init__(self, expression, message):self.expression = expressionself.message = messageclass TransitionError(Error):"""Raised when an operation attempts a state transition that's notallowed.Attributes:previous -- state at beginning of transitionnext -- attempted new statemessage -- explanation of why the specific transition is not allowed"""def __init__(self, previous, next, message):self.previous = previousself.next = nextself.message = message

大多数的异常的名字都以"Error"结尾，就跟标准的异常命名一样。

定义清理行为

try 语句还有另外一个可选的子句，它定义了无论在任何情况下都会执行的清理行为。 例如:

>>> try:
...     raise KeyboardInterrupt
... finally:
...     print('Goodbye, world!')
...
Goodbye, world!
Traceback (most recent call last):File "<stdin>", line 2, in <module>
KeyboardInterrupt

以上例子不管 try 子句里面有没有发生异常，finally 子句都会执行。

如果一个异常在 try 子句里（或者在 except 和 else 子句里）被抛出，而又没有任何的 except 把它截住，那么这个异常会在 finally 子句执行后被抛出。

下面是一个更加复杂的例子（在同一个 try 语句里包含 except 和 finally 子句）:

>>> def divide(x, y):try:result = x / yexcept ZeroDivisionError:print("division by zero!")else:print("result is", result)finally:print("executing finally clause")>>> divide(2, 1)
result is 2.0
executing finally clause
>>> divide(2, 0)
division by zero!
executing finally clause
>>> divide("2", "1")
executing finally clause
Traceback (most recent call last):File "<stdin>", line 1, in ?File "<stdin>", line 3, in divide
TypeError: unsupported operand type(s) for /: 'str' and 'str'

预定义的清理行为

一些对象定义了标准的清理行为，无论系统是否成功的使用了它，一旦不需要它了，那么这个标准的清理行为就会执行。

这面这个例子展示了尝试打开一个文件，然后把内容打印到屏幕上:

for line in open("myfile.txt"):print(line, end="")

以上这段代码的问题是，当执行完毕后，文件会保持打开状态，并没有被关闭。

关键词 with 语句就可以保证诸如文件之类的对象在使用完之后一定会正确的执行他的清理方法:

with open("myfile.txt") as f:for line in f:print(line, end="")

以上这段代码执行完毕后，就算在处理过程中出问题了，文件 f 总是会关闭。

Python3 面向对象

Python从设计之初就已经是一门面向对象的语言，正因为如此，在Python中创建一个类和对象是很容易的。本章节我们将详细介绍Python的面向对象编程。

如果你以前没有接触过面向对象的编程语言，那你可能需要先了解一些面向对象语言的一些基本特征，在头脑里头形成一个基本的面向对象的概念，这样有助于你更容易的学习Python的面向对象编程。

接下来我们先来简单的了解下面向对象的一些基本特征。

面向对象技术简介

• 类(Class): 用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。
• 方法：类中定义的函数。
• 类变量：类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。
• 数据成员：类变量或者实例变量用于处理类及其实例对象的相关的数据。
• 方法重写：如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖（override），也称为方法的重写。
• 局部变量：定义在方法中的变量，只作用于当前实例的类。
• 实例变量：在类的声明中，属性是用变量来表示的，这种变量就称为实例变量，实例变量就是一个用 self 修饰的变量。
• 继承：即一个派生类（derived class）继承基类（base class）的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。例如，有这样一个设计：一个Dog类型的对象派生自Animal类，这是模拟"是一个（is-a）"关系（例图，Dog是一个Animal）。
• 实例化：创建一个类的实例，类的具体对象。
• 对象：通过类定义的数据结构实例。对象包括两个数据成员（类变量和实例变量）和方法。

和其它编程语言相比，Python 在尽可能不增加新的语法和语义的情况下加入了类机制。

Python中的类提供了面向对象编程的所有基本功能：类的继承机制允许多个基类，派生类可以覆盖基类中的任何方法，方法中可以调用基类中的同名方法。

对象可以包含任意数量和类型的数据。

类定义

语法格式如下：

class ClassName:<statement-1>...<statement-N>

类实例化后，可以使用其属性，实际上，创建一个类之后，可以通过类名访问其属性。

类对象

类对象支持两种操作：属性引用和实例化。

属性引用使用和 Python 中所有的属性引用一样的标准语法：obj.name。

类对象创建后，类命名空间中所有的命名都是有效属性名。所以如果类定义是这样:

实例(Python 3.0+)

#!/usr/bin/python3class MyClass:"""一个简单的类实例"""i = 12345def f(self):return 'hello world'# 实例化类
x = MyClass()# 访问类的属性和方法
print("MyClass 类的属性 i 为：", x.i)
print("MyClass 类的方法 f 输出为：", x.f())

以上创建了一个新的类实例并将该对象赋给局部变量 x，x 为空的对象。

执行以上程序输出结果为：

MyClass 类的属性 i 为： 12345
MyClass 类的方法 f 输出为： hello world

类有一个名为 __init__() 的特殊方法（构造方法），该方法在类实例化时会自动调用，像下面这样：

def __init__(self):self.data = []

类定义了 __init__() 方法，类的实例化操作会自动调用 __init__() 方法。如下实例化类 MyClass，对应的 __init__() 方法就会被调用:

x = MyClass()

当然， __init__() 方法可以有参数，参数通过 __init__() 传递到类的实例化操作上。例如:

实例(Python 3.0+)

#!/usr/bin/python3class Complex:def __init__(self, realpart, imagpart):self.r = realpartself.i = imagpart
x = Complex(3.0, -4.5)
print(x.r, x.i)   # 输出结果：3.0 -4.5

self代表类的实例，而非类

类的方法与普通的函数只有一个特别的区别——它们必须有一个额外的第一个参数名称, 按照惯例它的名称是 self。

class Test:def prt(self):print(self)print(self.__class__)t = Test()
t.prt()

以上实例执行结果为：

<__main__.Test instance at 0x100771878>
__main__.Test

从执行结果可以很明显的看出，self 代表的是类的实例，代表当前对象的地址，而 self.class 则指向类。

self 不是 python 关键字，我们把他换成 runoob 也是可以正常执行的:

class Test:def prt(runoob):print(runoob)print(runoob.__class__)t = Test()
t.prt()

以上实例执行结果为：

<__main__.Test instance at 0x100771878>
__main__.Test

类的方法

在类的内部，使用 def 关键字来定义一个方法，与一般函数定义不同，类方法必须包含参数 self, 且为第一个参数，self 代表的是类的实例。

实例(Python 3.0+)

#!/usr/bin/python3#类定义
class people:#定义基本属性name = ''age = 0#定义私有属性,私有属性在类外部无法直接进行访问__weight = 0#定义构造方法def __init__(self,n,a,w):self.name = nself.age = aself.__weight = wdef speak(self):print("%s 说: 我 %d 岁。" %(self.name,self.age))# 实例化类
p = people('runoob',10,30)
p.speak()

执行以上程序输出结果为：

runoob 说: 我 10 岁。

继承

Python 同样支持类的继承，如果一种语言不支持继承，类就没有什么意义。派生类的定义如下所示:

class DerivedClassName(BaseClassName):<statement-1>...<statement-N>

子类（派生类 DerivedClassName）会继承父类（基类 BaseClassName）的属性和方法。

BaseClassName（实例中的基类名）必须与派生类定义在一个作用域内。除了类，还可以用表达式，基类定义在另一个模块中时这一点非常有用:

class DerivedClassName(modname.BaseClassName):

实例(Python 3.0+)

#!/usr/bin/python3#类定义
class people:#定义基本属性name = ''age = 0#定义私有属性,私有属性在类外部无法直接进行访问__weight = 0#定义构造方法def __init__(self,n,a,w):self.name = nself.age = aself.__weight = wdef speak(self):print("%s 说: 我 %d 岁。" %(self.name,self.age))#单继承示例
class student(people):grade = ''def __init__(self,n,a,w,g):#调用父类的构函people.__init__(self,n,a,w)self.grade = g#覆写父类的方法def speak(self):print("%s 说: 我 %d 岁了，我在读 %d 年级"%(self.name,self.age,self.grade))s = student('ken',10,60,3)
s.speak()

执行以上程序输出结果为：

ken 说: 我 10 岁了，我在读 3 年级

多继承

Python同样有限的支持多继承形式。多继承的类定义形如下例:

class DerivedClassName(Base1, Base2, Base3):<statement-1>...<statement-N>

需要注意圆括号中父类的顺序，若是父类中有相同的方法名，而在子类使用时未指定，python从左至右搜索 即方法在子类中未找到时，从左到右查找父类中是否包含方法。

实例(Python 3.0+)

#!/usr/bin/python3#类定义
class people:#定义基本属性name = ''age = 0#定义私有属性,私有属性在类外部无法直接进行访问__weight = 0#定义构造方法def __init__(self,n,a,w):self.name = nself.age = aself.__weight = wdef speak(self):print("%s 说: 我 %d 岁。" %(self.name,self.age))#单继承示例
class student(people):grade = ''def __init__(self,n,a,w,g):#调用父类的构函people.__init__(self,n,a,w)self.grade = g#覆写父类的方法def speak(self):print("%s 说: 我 %d 岁了，我在读 %d 年级"%(self.name,self.age,self.grade))#另一个类，多重继承之前的准备
class speaker():topic = ''name = ''def __init__(self,n,t):self.name = nself.topic = tdef speak(self):print("我叫 %s，我是一个演说家，我演讲的主题是 %s"%(self.name,self.topic))#多重继承
class sample(speaker,student):a =''def __init__(self,n,a,w,g,t):student.__init__(self,n,a,w,g)speaker.__init__(self,n,t)test = sample("Tim",25,80,4,"Python")
test.speak()   #方法名同，默认调用的是在括号中排前地父类的方法

执行以上程序输出结果为：

我叫 Tim，我是一个演说家，我演讲的主题是 Python

方法重写

如果你的父类方法的功能不能满足你的需求，你可以在子类重写你父类的方法，实例如下：

实例(Python 3.0+)

#!/usr/bin/python3class Parent:        # 定义父类def myMethod(self):print ('调用父类方法')class Child(Parent): # 定义子类def myMethod(self):print ('调用子类方法')c = Child()          # 子类实例
c.myMethod()         # 子类调用重写方法
super(Child,c).myMethod() #用子类对象调用父类已被覆盖的方法

super() 函数是用于调用父类(超类)的一个方法。

执行以上程序输出结果为：

调用子类方法
调用父类方法

更多文档：

Python 子类继承父类构造函数说明

类属性与方法

类的私有属性

__private_attrs：两个下划线开头，声明该属性为私有，不能在类的外部被使用或直接访问。在类内部的方法中使用时 self.__private_attrs。

类的方法

在类的内部，使用 def 关键字来定义一个方法，与一般函数定义不同，类方法必须包含参数 self，且为第一个参数，self 代表的是类的实例。

self 的名字并不是规定死的，也可以使用 this，但是最好还是按照约定使用 self。

类的私有方法

__private_method：两个下划线开头，声明该方法为私有方法，只能在类的内部调用 ，不能在类的外部调用。self.__private_methods。

实例

类的私有属性实例如下：

实例(Python 3.0+)

#!/usr/bin/python3class JustCounter:__secretCount = 0  # 私有变量publicCount = 0    # 公开变量def count(self):self.__secretCount += 1self.publicCount += 1print (self.__secretCount)counter = JustCounter()
counter.count()
counter.count()
print (counter.publicCount)
print (counter.__secretCount)  # 报错，实例不能访问私有变量

执行以上程序输出结果为：

1
2
2
Traceback (most recent call last):File "test.py", line 16, in <module>print (counter.__secretCount)  # 报错，实例不能访问私有变量
AttributeError: 'JustCounter' object has no attribute '__secretCount'

类的私有方法实例如下：

实例(Python 3.0+)

#!/usr/bin/python3class Site:def __init__(self, name, url):self.name = name       # publicself.__url = url   # privatedef who(self):print('name  : ', self.name)print('url : ', self.__url)def __foo(self):          # 私有方法print('这是私有方法')def foo(self):            # 公共方法print('这是公共方法')self.__foo()x = Site('菜鸟教程', 'www.runoob.com')
x.who()        # 正常输出
x.foo()        # 正常输出
x.__foo()      # 报错

以上实例执行结果：

类的专有方法：

• __init__ : 构造函数，在生成对象时调用
• __del__ : 析构函数，释放对象时使用
• __repr__ : 打印，转换
• __setitem__ : 按照索引赋值
• __getitem__: 按照索引获取值
• __len__: 获得长度
• __cmp__: 比较运算
• __call__: 函数调用
• __add__: 加运算
• __sub__: 减运算
• __mul__: 乘运算
• __truediv__: 除运算
• __mod__: 求余运算
• __pow__: 乘方

运算符重载

Python同样支持运算符重载，我们可以对类的专有方法进行重载，实例如下：

实例(Python 3.0+)

#!/usr/bin/python3class Vector:def __init__(self, a, b):self.a = aself.b = bdef __str__(self):return 'Vector (%d, %d)' % (self.a, self.b)def __add__(self,other):return Vector(self.a + other.a, self.b + other.b)v1 = Vector(2,10)
v2 = Vector(5,-2)
print (v1 + v2)

以上代码执行结果如下所示:

Vector(7,8)

Python3 命名空间和作用域

命名空间

先看看官方文档的一段话：

A namespace is a mapping from names to objects.Most namespaces are currently implemented as Python dictionaries。

命名空间(Namespace)是从名称到对象的映射，大部分的命名空间都是通过 Python 字典来实现的。

命名空间提供了在项目中避免名字冲突的一种方法。各个命名空间是独立的，没有任何关系的，所以一个命名空间中不能有重名，但不同的命名空间是可以重名而没有任何影响。

我们举一个计算机系统中的例子，一个文件夹(目录)中可以包含多个文件夹，每个文件夹中不能有相同的文件名，但不同文件夹中的文件可以重名。

一般有三种命名空间：

• 内置名称（built-in names）， Python 语言内置的名称，比如函数名 abs、char 和异常名称 BaseException、Exception 等等。
• 全局名称（global names），模块中定义的名称，记录了模块的变量，包括函数、类、其它导入的模块、模块级的变量和常量。
• 局部名称（local names），函数中定义的名称，记录了函数的变量，包括函数的参数和局部定义的变量。（类中定义的也是）

命名空间查找顺序:

假设我们要使用变量 runoob，则 Python 的查找顺序为：局部的命名空间去 -> 全局命名空间 -> 内置命名空间。

如果找不到变量 runoob，它将放弃查找并引发一个 NameError 异常:

NameError: name 'runoob' is not defined。

命名空间的生命周期：

命名空间的生命周期取决于对象的作用域，如果对象执行完成，则该命名空间的生命周期就结束。

因此，我们无法从外部命名空间访问内部命名空间的对象。

实例

# var1 是全局名称
var1 = 5
def some_func():# var2 是局部名称var2 = 6def some_inner_func():# var3 是内嵌的局部名称var3 = 7

如下图所示，相同的对象名称可以存在于多个命名空间中。

作用域

A scope is a textual region of a Python program where a namespace is directly accessible. "Directly accessible" here means that an unqualified reference to a name attempts to find the name in the namespace.

作用域就是一个 Python 程序可以直接访问命名空间的正文区域。

在一个 python 程序中，直接访问一个变量，会从内到外依次访问所有的作用域直到找到，否则会报未定义的错误。

Python 中，程序的变量并不是在哪个位置都可以访问的，访问权限决定于这个变量是在哪里赋值的。

变量的作用域决定了在哪一部分程序可以访问哪个特定的变量名称。Python 的作用域一共有4种，分别是：

有四种作用域：

• L（Local）：最内层，包含局部变量，比如一个函数/方法内部。
• E（Enclosing）：包含了非局部(non-local)也非全局(non-global)的变量。比如两个嵌套函数，一个函数（或类） A 里面又包含了一个函数 B ，那么对于 B 中的名称来说 A 中的作用域就为 nonlocal。
• G（Global）：当前脚本的最外层，比如当前模块的全局变量。
• B（Built-in）： 包含了内建的变量/关键字等，最后被搜索。

规则顺序： L –> E –> G –> B。

在局部找不到，便会去局部外的局部找（例如闭包），再找不到就会去全局找，再者去内置中找。

g_count = 0  # 全局作用域
def outer():o_count = 1  # 闭包函数外的函数中def inner():i_count = 2  # 局部作用域

内置作用域是通过一个名为 builtin 的标准模块来实现的，但是这个变量名自身并没有放入内置作用域内，所以必须导入这个文件才能够使用它。在Python3.0中，可以使用以下的代码来查看到底预定义了哪些变量:

>>> import builtins
>>> dir(builtins)

Python 中只有模块（module），类（class）以及函数（def、lambda）才会引入新的作用域，其它的代码块（如 if/elif/else/、try/except、for/while等）是不会引入新的作用域的，也就是说这些语句内定义的变量，外部也可以访问，如下代码：

>>> if True:
...  msg = 'I am from Runoob'
... 
>>> msg
'I am from Runoob'
>>> 

实例中 msg 变量定义在 if 语句块中，但外部还是可以访问的。

如果将 msg 定义在函数中，则它就是局部变量，外部不能访问：

>>> def test():
...     msg_inner = 'I am from Runoob'
... 
>>> msg_inner
Traceback (most recent call last):File "<stdin>", line 1, in <module>
NameError: name 'msg_inner' is not defined
>>> 

从报错的信息上看，说明了 msg_inner 未定义，无法使用，因为它是局部变量，只有在函数内可以使用。

全局变量和局部变量

定义在函数内部的变量拥有一个局部作用域，定义在函数外的拥有全局作用域。

局部变量只能在其被声明的函数内部访问，而全局变量可以在整个程序范围内访问。调用函数时，所有在函数内声明的变量名称都将被加入到作用域中。如下实例：

实例(Python 3.0+)

#!/usr/bin/python3total = 0 # 这是一个全局变量
# 可写函数说明
def sum( arg1, arg2 ):#返回2个参数的和."total = arg1 + arg2 # total在这里是局部变量.print ("函数内是局部变量 : ", total)return total#调用sum函数
sum( 10, 20 )
print ("函数外是全局变量 : ", total)

以上实例输出结果：

函数内是局部变量 :  30
函数外是全局变量 :  0

global 和 nonlocal关键字

当内部作用域想修改外部作用域的变量时，就要用到 global 和 nonlocal 关键字了。

以下实例修改全局变量 num：

实例(Python 3.0+)

#!/usr/bin/python3num = 1
def fun1():global num  # 需要使用 global 关键字声明print(num) num = 123print(num)
fun1()
print(num)

以上实例输出结果：

1
123
123

如果要修改嵌套作用域（enclosing 作用域，外层非全局作用域）中的变量则需要 nonlocal 关键字了，如下实例：

实例(Python 3.0+)

#!/usr/bin/python3def outer():num = 10def inner():nonlocal num   # nonlocal关键字声明num = 100print(num)inner()print(num)
outer()

以上实例输出结果：

100
100

另外有一种特殊情况，假设下面这段代码被运行：

实例(Python 3.0+)

#!/usr/bin/python3a = 10
def test():a = a + 1print(a)
test()

以上程序执行，报错信息如下：

Traceback (most recent call last):File "test.py", line 7, in <module>test()File "test.py", line 5, in testa = a + 1
UnboundLocalError: local variable 'a' referenced before assignment

错误信息为局部作用域引用错误，因为 test 函数中的 a 使用的是局部，未定义，无法修改。

修改 a 为全局变量：

实例

#!/usr/bin/python3a = 10
def test():global aa = a + 1print(a)
test()

执行输出结果为：

11

也可以通过函数参数传递：

实例(Python 3.0+)

#!/usr/bin/python3a = 10
def test(a):a = a + 1print(a)
test(a)

执行输出结果为：

11

Python3 标准库概览

操作系统接口

os模块提供了不少与操作系统相关联的函数。

>>> import os
>>> os.getcwd()      # 返回当前的工作目录
'C:\\Python34'
>>> os.chdir('/server/accesslogs')   # 修改当前的工作目录
>>> os.system('mkdir today')   # 执行系统命令 mkdir 
0

建议使用 "import os" 风格而非 "from os import *"。这样可以保证随操作系统不同而有所变化的 os.open() 不会覆盖内置函数 open()。

在使用 os 这样的大型模块时内置的 dir() 和 help() 函数非常有用:

>>> import os
>>> dir(os)
<returns a list of all module functions>
>>> help(os)
<returns an extensive manual page created from the module's docstrings>

针对日常的文件和目录管理任务，:mod:shutil 模块提供了一个易于使用的高级接口:

>>> import shutil
>>> shutil.copyfile('data.db', 'archive.db')
>>> shutil.move('/build/executables', 'installdir')

文件通配符

glob模块提供了一个函数用于从目录通配符搜索中生成文件列表:

>>> import glob
>>> glob.glob('*.py')
['primes.py', 'random.py', 'quote.py']

命令行参数

通用工具脚本经常调用命令行参数。这些命令行参数以链表形式存储于 sys 模块的 argv 变量。例如在命令行中执行 "python demo.py one two three" 后可以得到以下输出结果:

>>> import sys
>>> print(sys.argv)
['demo.py', 'one', 'two', 'three']

错误输出重定向和程序终止

sys 还有 stdin，stdout 和 stderr 属性，即使在 stdout 被重定向时，后者也可以用于显示警告和错误信息。

>>> sys.stderr.write('Warning, log file not found starting a new one\n')
Warning, log file not found starting a new one

大多脚本的定向终止都使用 "sys.exit()"。

字符串正则匹配

re模块为高级字符串处理提供了正则表达式工具。对于复杂的匹配和处理，正则表达式提供了简洁、优化的解决方案:

>>> import re
>>> re.findall(r'\bf[a-z]*', 'which foot or hand fell fastest')
['foot', 'fell', 'fastest']
>>> re.sub(r'(\b[a-z]+) \1', r'\1', 'cat in the the hat')
'cat in the hat'

如果只需要简单的功能，应该首先考虑字符串方法，因为它们非常简单，易于阅读和调试:

>>> 'tea for too'.replace('too', 'two')
'tea for two'

数学

math模块为浮点运算提供了对底层C函数库的访问:

>>> import math
>>> math.cos(math.pi / 4)
0.70710678118654757
>>> math.log(1024, 2)
10.0

random提供了生成随机数的工具。

>>> import random
>>> random.choice(['apple', 'pear', 'banana'])
'apple'
>>> random.sample(range(100), 10)   # sampling without replacement
[30, 83, 16, 4, 8, 81, 41, 50, 18, 33]
>>> random.random()    # random float
0.17970987693706186
>>> random.randrange(6)    # random integer chosen from range(6)
4

访问 互联网

有几个模块用于访问互联网以及处理网络通信协议。其中最简单的两个是用于处理从 urls 接收的数据的 urllib.request 以及用于发送电子邮件的 smtplib:

>>> from urllib.request import urlopen
>>> for line in urlopen('http://tycho.usno.navy.mil/cgi-bin/timer.pl'):
...     line = line.decode('utf-8')  # Decoding the binary data to text.
...     if 'EST' in line or 'EDT' in line:  # look for Eastern Time
...         print(line)<BR>Nov. 25, 09:43:32 PM EST>>> import smtplib
>>> server = smtplib.SMTP('localhost')
>>> server.sendmail('soothsayer@example.org', 'jcaesar@example.org',
... """To: jcaesar@example.org
... From: soothsayer@example.org
...
... Beware the Ides of March.
... """)
>>> server.quit()

注意第二个例子需要本地有一个在运行的邮件服务器。

日期和时间

datetime模块为日期和时间处理同时提供了简单和复杂的方法。

支持日期和时间算法的同时，实现的重点放在更有效的处理和格式化输出。

该模块还支持时区处理:

>>> # dates are easily constructed and formatted
>>> from datetime import date
>>> now = date.today()
>>> now
datetime.date(2003, 12, 2)
>>> now.strftime("%m-%d-%y. %d %b %Y is a %A on the %d day of %B.")
'12-02-03. 02 Dec 2003 is a Tuesday on the 02 day of December.'>>> # dates support calendar arithmetic
>>> birthday = date(1964, 7, 31)
>>> age = now - birthday
>>> age.days
14368

数据压缩

以下模块直接支持通用的数据打包和压缩格式：zlib，gzip，bz2，zipfile，以及 tarfile。

>>> import zlib
>>> s = b'witch which has which witches wrist watch'
>>> len(s)
41
>>> t = zlib.compress(s)
>>> len(t)
37
>>> zlib.decompress(t)
b'witch which has which witches wrist watch'
>>> zlib.crc32(s)
226805979

性能度量

有些用户对了解解决同一问题的不同方法之间的性能差异很感兴趣。Python 提供了一个度量工具，为这些问题提供了直接答案。

例如，使用元组封装和拆封来交换元素看起来要比使用传统的方法要诱人的多,timeit 证明了现代的方法更快一些。

>>> from timeit import Timer
>>> Timer('t=a; a=b; b=t', 'a=1; b=2').timeit()
0.57535828626024577
>>> Timer('a,b = b,a', 'a=1; b=2').timeit()
0.54962537085770791

相对于 timeit 的细粒度，:mod:profile 和 pstats 模块提供了针对更大代码块的时间度量工具。

测试模块

开发高质量软件的方法之一是为每一个函数开发测试代码，并且在开发过程中经常进行测试

doctest模块提供了一个工具，扫描模块并根据程序中内嵌的文档字符串执行测试。

测试构造如同简单的将它的输出结果剪切并粘贴到文档字符串中。

通过用户提供的例子，它强化了文档，允许 doctest 模块确认代码的结果是否与文档一致:

def average(values):"""Computes the arithmetic mean of a list of numbers.>>> print(average([20, 30, 70]))40.0"""return sum(values) / len(values)import doctest
doctest.testmod()   # 自动验证嵌入测试

unittest模块不像 doctest模块那么容易使用，不过它可以在一个独立的文件里提供一个更全面的测试集:

import unittestclass TestStatisticalFunctions(unittest.TestCase):def test_average(self):self.assertEqual(average([20, 30, 70]), 40.0)self.assertEqual(round(average([1, 5, 7]), 1), 4.3)self.assertRaises(ZeroDivisionError, average, [])self.assertRaises(TypeError, average, 20, 30, 70)unittest.main() # Calling from the command line invokes all tests

Python3 实例

以下实例在 Python3.4.3 版本下测试通过：

• Python Hello World 实例
• Python 数字求和
• Python 平方根
• Python 二次方程
• Python 计算三角形的面积
• Python 计算圆的面积
• Python 随机数生成
• Python 摄氏温度转华氏温度
• Python 交换变量
• Python if 语句
• Python 判断字符串是否为数字
• Python 判断奇数偶数
• Python 判断闰年
• Python 获取最大值函数
• Python 质数判断
• Python 输出指定范围内的素数
• Python 阶乘实例
• Python 九九乘法表
• Python 斐波那契数列
• Python 阿姆斯特朗数
• Python 十进制转二进制、八进制、十六进制
• Python ASCII码与字符相互转换
• Python 最大公约数算法
• Python 最小公倍数算法
• Python 简单计算器实现
• Python 生成日历
• Python 使用递归斐波那契数列
• Python 文件 IO
• Python 字符串判断
• Python 字符串大小写转换
• Python 计算每个月天数
• Python 获取昨天日期
• Python list 常用操作
• Python 约瑟夫生者死者小游戏
• Python 五人分鱼
• Python 实现秒表功能
• Python 计算 n 个自然数的立方和
• Python 计算数组元素之和
• Python 数组翻转指定个数的元素
• Python 将列表中的头尾两个元素对调
• Python 将列表中的指定位置的两个元素对调
• Python 翻转列表
• Python 判断元素是否在列表中存在
• Python 清空列表
• Python 复制列表
• Python 计算元素在列表中出现的次数
• Python 计算列表元素之和
• Python 计算列表元素之积
• Python 查找列表中最小元素
• Python 查找列表中最大元素
• Python 移除字符串中的指定位置字符
• Python 判断字符串是否存在子字符串
• Python 判断字符串长度
• Python 使用正则表达式提取字符串中的 URL
• Python 将字符串作为代码执行
• Python 字符串翻转
• Python 对字符串切片及翻转
• Python 按键(key)或值(value)对字典进行排序
• Python 计算字典值之和
• Python 移除字典点键值(key/value)对
• Python 合并字典
• Python 将字符串的时间转换为时间戳
• Python 获取几天前的时间
• Python 将时间戳转换为指定格式日期
• Python 打印自己设计的字体
• Python 二分查找
• Python 线性查找
• Python 插入排序
• Python 快速排序
• Python 选择排序
• Python 冒泡排序
• Python 归并排序
• Python 堆排序
• Python 计数排序
• Python 希尔排序
• Python 拓扑排序