本文列出一些要点，帮助已经学会C/C++，Java（或其他面向对象语言）的同学快速入门Python。这些要点是关于语言的，没有涉及开发环境。
Python程序的构成
1. 第一个Python程序——Hello World程序
下面的一行代码构成打印Hello World的Python程序。
print(“Hello World”)
上一行代码存为文件helloworld.py。在Windows终端上（注意，当前目录下须有helloworld.py），输入命令：
python helloworld.py
就运行了程序（实质是运行python解释器程序解释执行了helloworld.py。须事先安装python。），在终端上打印出: Hello World
2. Python程序文件的后缀名必须是”.py“
Python程序文件后缀必须是.py。这样，python解释器才视该文件为python代码文件。
3. 第二个Python程序——求两个数的和
程序功能：输入两个数，输出它们的和。
代码如下：
#程序功能：输入两个加数，输出它们的和
firstNumStr= input("输入被加数：") #从键盘输入一串数字，存入firstNumStr变量中。“输入被加数：”这一段文字会打印到屏幕上，用作输入提示。
firstSum = float(firstNumStr) #float函数把文字类型的数字(firstNumStr变量存储）转换为浮点数（firstSum变量存储）
secondNumStr = input("输入加数：")
secondNum = float(secondNumStr)
sum = firstSum + secondNum #求和：firstNum变量的值和secondNum变量的值相加，和存入sum变量
print("两个数之和：" + str(sum)) #str(sum)是把sum变量的整数值转换为字符串类型的数字。
上述代码有6条语句。其中，#号之后到行末的文字都是注释。
上述代码存为aplusb.py。在Windows终端上（注意，当前目录下须有helloworld.py），输入命令：
python aplusb.py
就运行了程序（实质是运行python解释器程序解释执行了aplusb.py。须事先安装python。），在终端上将输出以下文字：
输入被加数：
而后光标一闪一闪等待用户输入。用户输入完毕（敲回车表示完毕），输入的数字字符串赋给firstNumStr变量。接着，该数字被转换为浮点数。类似地，输入加数。最后，求得两个数的和，输出结果。
4. 概括起来讲
1) Python程序由一条或多条语句组成。
2) 一条语句独立占一行或多行。一行中不能写两条语句。无须用分号来表示语句结尾。
3) 程序的执行从第一条语句开始往后执行，直至最后一条语句或者遇到退出语句。无须有main函数。
变量
1. 变量是什么
Python中，变量是值的名字，也即变量是值的引用。变量v可以先引用整数值（即变量v是某个整数值的名字），接着引用字符串值，再接着引用浮点数值。以下写法在Python中是允许的，在C/C++, Java中是不允许的。
v = 1
v = “hello”
v = 6.8
变量的类型实际上是指值的类型。上面代码中，第一行代码使得变量v的类型是整型；第二行代码使得变量v的类型是字符串类型，第三行代码使得变量v的类型变成浮点数类型。
2. 变量的定义
Python中，第一次赋值就是定义变量。 如下面的写法定义了变量v：
v = 1
变量必须先定义后使用。使用的例子有参与运算、用作实参、赋值给其他变量等等。
字符串
1. 字符串的写法
- 用单引号或双引号括起来。如："Hello world!"，'hello' 。
- 同样有转义字符。'\n'是换行符。'\\'是反斜杠。'\t'是制表符。等等。
2. 字符
Python中没有单独设字符这种数据类型，而是把字符视为长度为1的字符串。下面是字符的3个例子：'a', '1', "$" 。
3. 字符串与整数、浮点数之间的转换
- 整数、浮点数转换为字符串，用str()函数。
- 数字字符串转换为整数，用int()函数。
- 数字字符串转换为浮点数，用float()函数。
- 字符串不能和整数进行拼接操作。你应当用str()函数把整数转换为字符串后再进行拼接。
4. 字符串对象和方法
Python中，任何值，无论是整数值、浮点数值还是字符串值，都存储为一个对象。对象由多个属性组成。一个属性有两个组成部分：属性名和属性值。属性分数据属性和方法属性。
字符串对象有以下方法：
- title() 把字符串内的各个单词首字母变成大写。
- upper() 把字符串的所有字母变成大写。
- lower() 把字符串的所有字母变成小写。
- rstrip() 去除字符串尾部空白。
- lstrip() 去除字符串头部空白。
- strip() 去除字符串两端空白。
- split() 分割字符串，得到单词列表。
- 还有很多方法，无法逐一列出。参阅python手册，或用搜索引擎进行检索。
5. 字符与ASCII码的转换
要把字符转换为ASCII码，用ord( )函数；要把ASCII码转换为字符，用chr( )函数。
6. 如何查阅各个函数或方法的用法
- 以ord函数为例，你可以在搜索引擎中输入“python ord”来查阅ord()函数的用法。
- 你也可以利用安装在你电脑上的python手册来查阅ord()函数的用法。windows 7系统中启动python手册的做法图1所示。
ord()函数的用法如图2所示。
图1 启动python手册
图2 python手册中查询ord()函数的用法
输入字符串、数字
1. input()函数输入的是字符串
下面的写法，输入的是字符串，用num_str变量引用存储输入的文字的字符串对象。
num_str = input("输入一句话：")
这里，"输入一句话："用作输入提示，就是打印到屏幕的文字，用来提示用户输入什么。
执行该语句时，终端上将输出以下文字：
输入一句话：
而后光标一闪一闪等待用户输入。用户输入完毕（敲回车表示完毕），输入的文字（字符串类型）将赋值给num_str变量。
2. 要输入数字，应该进行类型转换
下面两行代码中，第一行是输入字符串，第二行代码是把字符串转换为整数数字。
num_str = input( ) #这次没有输入提示
num = int(num_str)
上面，用int( )函数把数字字符串转换为整数。要把数字字符串转换为浮点数，需要用float( )函数，如下所示。
num_str = input( ) #这次没有输入提示
num = float(num_str)
对象和方法
概念上，Python对象与Java对象是相同的。Python对象与C语言的结构体也有类似之处。对象由一组属性组成。属性分数据属性和方法属性两类。每一个属性都有属性名和属性值两部分。
方法（即方法属性的值）实质上是函数，不过是能够访问对象内部的属性的函数。普通的函数是不能够访问对象内部的属性的。
调用普通函数func的形式如：
result = func(10， 7.6)
这里，10和7.6是实参，result变量接收函数的返回值。
调用方法method的形式如：
result = object.method( 99)
这里，object是一个对象，点号.是成员操作符，99是实参。method方法能够访问object对象内部的属性。
if语句
if语句有三种。与C/C++，Java相比，除了书写格式有差异外，if语句的用法本质上是类似的。下面给出了每种语句的用法示例，你应当把它与你熟悉的语言进行对比。通过对比，你肯定能快速掌握Python语言的if语句的用法。
第一种if语句
第一种if语句的写法是：
if 布尔表达式:
语句块
布尔表达式跟C/C++, Java中的布尔表达式是等同的，都用于检查某个条件是否成立。语句块是由一条或多条语句组成。
注意：(1) 布尔表达式后面有一个冒号。(2) 语句块中的所有语句都要缩进4个空格。
第一种if语句的示例代码如下。代码的功能是输入整数，输出它的绝对值。
numStr = input("输入一个整数：")
num = int(numStr)
if num < 0: #if语句，当num<0成立时，执行其后的语句块
num = -num #这里，语句块只有一条语句组成。
print("绝对值：" + str(num)) #这一条语句不属于if语句。
第二种if语句
第二种if语句的书写格式是：
if 布尔表达式:
语句块1else:
语句块2
布尔表达式跟C/C++, Java中的布尔表达式是等同的，都用于检查某个条件是否成立。语句块是由一条或多条语句组成。
注意：(1) 布尔表达式后面和else后面都有一个冒号。(2) 语句块中的所有语句都要缩进4个空格。
第二种if语句的示例代码如下。代码的功能是输入分数，输出及格与否的结论。
score = float(input("输入分数："))
if score >= 60:
print("及格")
else:
print("不及格")
第三种if语句
第三种if语句的书写格式是：
if 布尔表达式1:
语句块1elif 布尔表达式2:
语句块2
elif 布尔表达式3：
语句块3
else:
语句块4
以上写法中, elif分支可多可少；else分支可以没有。你能猜到elif是什么单词的缩写吗？答案是else if。
第三种if语句的示例代码如下。代码的功能是输入年龄，得出门票价格。计价规则是：4岁以下，免费； 4~18岁，5元；18岁以上，10元。
age = int(input("输入年龄："))
if age < 4:
price = 0
elif age < 18: #elif来自else if
price = 5
else:
price = 10
print("票价(元）：", price)
逻辑运算符
在C/C++, Java语言中，实现“而且”、“或者”、”非“的逻辑运算符是&&, ||, !。
Python语言中，实现“而且”、“或者”、”非“的逻辑运算符是and, or, not 。
下面的代码是逻辑运算符的示例。代码的功能是输入年份，输出该年份是闰年还是平年的结论。
year = int(input("输入年份："))
if (year % 4 == 0 and year % 100 != 0) or (year % 400 == 0):
print("闰年")
else:
print("平年")
布尔类型
布尔类型就是值为真或假的类型。Python语言中，用关键字True代表真，False代表假。注意第一个字母是大写。
在C/C++, Java语言中，用true代表真，false代表假。注意第一个字母是小写。
while语句
Python的while语句与C/C++，Java的while语句相比，除了书写格式有差异外，用法本质上是类同的。
Python的while语句的书写格式是：
while 布尔表达式:
语句块
以上格式中，语句块由一条或多条语句组成。语句块的每一条语句都要缩进4个空。要记得写布尔表达式后面的冒号。
下面的代码给出了while语句的示例。代码的功能是求1+2+3+4+5的和。
sum = 0
n = 1
while n <= 5:
sum += n #即：sum = sum + n
n += 1 #即：n = n + 1
print("1+2+...+5=", sum)
while语句内，你可以使用break语句和continue语句，用法与C/C++, Java一样。
函数
函数是由一组语句组成的。调用函数就是执行这一组语句。
函数的使用分定义函数和调用函数，用法与C/C++, Java差不多（以后会接触到调用函数时传入关键字参数，这是后两种语言没有的）。
定义函数和调用函数
Python中，定义函数的书写格式是：
def 函数名(形式参数):
语句块
上述格式中，def是define的缩写。上述写法构成一条Python语句。C/C++, Java中使用花括号括起函数体，Python中是用缩进的语句块代表函数体。要记得起始行末尾的冒号。强调一遍，语句块（函数体）要缩进。
要让函数返回值，需要使用return语句，这与C/C++, Java是一致的。
函数定义和调用举例1：
#实现f(x) = x**2 + 3x + 5
def f(x):
return x**2 + 3*x + 5print("f(x)=", f(2.0)) #这是调用函数。由于没有缩进，不构成函数体的一部分。
函数定义和调用举例2：
#求x, y的公因子
def gyz(x, y):
yz = x
while yz > 0:
if x % yz == 0 and y % yz == 0:
return yz
else:
yz -= 1
print("35和21的公因子是：", gyz(35, 21)) #这是调用函数。不是函数体的一部分，不能缩进。
print("24和18的公因子是：", gyz(24, 18))
作用域
1. 全局作用域和局部作用域
- 每一个Python文件拥有一个全局域。这一点与C/C++, Java类似。
- 每一个函数定义都生成该函数的局部域。该函数内定义的变量，在函数外无法使用。这一点与C/C++, Java类似。
- 与C/C++, Java不同，if语句，while语句，for语句的语句块不构成一个局部作用域。也就是说，它这些语句的语句块内定义的变量，在语句块外部也可以使用。
2. 示例：if语句，while语句，for语句的语句块不构成一个局部作用域
下面代码中的price变量在if语句的语句块内定义，在语句块外依旧可以使用。
age = int(input("输入年龄："))
if age < 4:
price = 0
elif age < 18: #elif来自else if
price = 5
else:
price = 10
print("票价(元）：", price)
3. 关于作用域更多的内容
Python语言对作用域有自己的若干约定。比如函数内部，修改全部变量的话，要事先用global语句声明该全局变量。
在入门阶段，不宜纠缠过多枝节，故这里不予介绍。那同学们会问，啥是主干啥是枝节呢？解题要用到的知识内容，就是主干；用不到的，就是枝节。
列表和for语句
C/C++、Java中的数组，在Python中对应的是列表。数组和列表都是由多个元素组成的。数组能干的事，列表都能干，而且列表能干更多事。
列表的用法
1. 定义列表
定义列表用的是方括号。下面定义了一份字符串为元素的列表，有courses变量引用它。
courses = ['Python程序设计', '计算机原理', '操作系统', '数据结构', '算法设计', '软件工程导论']
下面定义的列表的元素类型不同。这在Python中是允许的。C/C++、Java中，数组的元素的类型必须一致。
ns = ['python', 10000, 77.5, '加油']
下面定义了空列表。
blist = []
2. 访问列表元素
访问列表元素的做法与C/C++、Java的做法是一样的。下面的代码示范了这一点。
#下标i对应第i+1个元素
bicycles = ['trek', 'cannondale', 'redline', '捷安特', '凤凰', '永久' ]
print(bicycles[0])
print(bicycles[3])
#索引从0开始
print("索引从0开始：")
print(bicycles[1])
#print(bicycles[6])
#倒数的索引
print("倒数的索引：")
print(bicycles[-1]) #最后一个元素
print(bicycles[-2]) #倒数第二个元素
print(bicycles[-3]) #倒数第三个元素
Python可以用负数作为下标，比C/C++、Java的数组下标更灵活。
3. 修改、添加列表元素
修改、添加列表元素的示例代码如下。你可以复制这段代码，建立一份python程序文件，运行该文件看看效果。
#修改列表元素
motorcycles = ['honda', 'yamaha', 'suzuki', '宗申', '钱江']
print(motorcycles)
print("修改第一个元素：")
motorcycles[0] = '嘉陵' #修改元素
print(motorcycles)
#尾部添加列表元素
print("列表尾部添加元素：")
motorcycles.append('哈雷')
print(motorcycles)
#从空列表开始构造列表
print("从空列表开始：")
bicycles = []
bicycles.append('捷安特')
bicycles.append('永久')
bicycles.append('飞鸽')
print(bicycles)
#向列表中插入元素
print("向列表中插入元素：")
motorcycles = ['honda', 'yamaha', 'suzuki']
motorcycles.insert(0, '哈雷') #在第1个元素前插入元素
motorcycles.insert(2, '嘉陵') #在第3个元素前插入元素
print(motorcycles)
for循环遍历列表
1. for语句的写法
Python语言的for语句和C/C++、Java的for语句有较大差别。Python的for语句的书写格式是：
for 变量 in 列表:
语句块
示例程序如下。你可以复制这段代码，建立一份python程序文件，运行该文件看看效果。
magicians = ['alice', 'david', 'carolina']
#print(magicians)
print("遍历每一个元素：")
for magician in magicians:
print(magician)
print("元素之前冠以序号：")
index = 1
for magician in magicians:
print(str(index) + '.', magician)
index = index + 1
2. for语句的执行流程
for语句的执行流程描述如下。
依次对列表中的每个元素e，执行下面两个步骤：
1). 把当前元素e的值赋值给变量。
2). 执行语句块。
3. 用range()函数实现C语言风格的for循环
从1加到5，用循环来实现，在C/C++，Java中该怎么写，在Python中又该怎么写？
C/C++、Java中的写法是：
int sum = 0;
for (int i = 1; i < 6; i++) {
sum += i;
}
Python中的写法是：
sum = 0
for i in range(1, 6):
sum += i
上面代码中，range(1, 6)会生成[1, 2, ,3, 4, 5]这样一份列表。
4. range()函数
下面的代码示范了range()函数的用法。更多的说明，请参阅Python手册，或者通过搜索引擎搜索。
#range(2,11,2)参数说明：
# 第一个参数指定数字列表的第一项是多少。这里为2.
# 第二个参数指定数字列表的上下界（不含）是多少。这里为11.
# 第三个参数指定数字列表的相邻项之间的增量是多少。这里为2.
even_numbers = list(range(2, 11, 2)) #先执行range(),而后执行list()
print("even_numbers:", even_numbers)#只有1个参数的情形。这个参数用作上下界。
print("list(range(9)):", list(range(9))) #range(9)的列表第一项是0.
#递减的数字列表
print("list(range(9, 1))", list(range(9, 1, -1))) #增量为-1，即递减
上面的代码中，range( )函数生成range对象，list( )函数获得range对象内的列表。
一行中输入一组数的做法
下面的代码示范了如何让用户运行程序时，在一行中输入多个整数。
#输入一行字符串
line = input("输入多个整数，用空格隔开：") #line是一个字符串
print("line=", line)
#以空格为分隔符，分割字符串得到数字字符串列表
num_strs = line.split() #num_strs是数字字符串列表
print("num_strs=", num_strs)
#数字字符串列表转换为数字列表
nums = []
for s in num_strs:
nums.append(int(s))
print("nums=", nums)
关于上面的代码的说明：
1. line.split( )是调用字符串对象的split方法。它的作用是，以空格为分隔符，分割整行文本（即line变量的值）得到数字字符串列表。
2. 而后，遍历数字字符串列表，逐个地把数字字符串转换为整数，加入整数列表（或者说数组）中。
矩阵
Python中，矩阵是以每一行为元素的列表。而每一行自身是一份列表，因此矩阵是列表的列表。
下面的代码示范了定义矩阵和访问矩阵元素的做法。访问矩阵元素使用行下标和列下标。要记得，可以用负数作为下标，-1代表最后一个元素，-2代表倒数第二个，以此类推。
#定义2行3列的整数矩阵
imx = [
[1, 2, 3],
[4, 5, 6]
]
#用下标访问矩阵元素
print("整数矩阵中第1行第2列的元素：", imx[0][1])
print("整数矩阵中第2行第3列的元素：", imx[1][2])
print("整数矩阵中第1行：", imx[0]) #可见，矩阵是列表为元素的列表
print("整数矩阵中第2行：", imx[1])
#定义5行5列的字符矩阵
cmx = [
"1abcd", #实质上，一个字符串就是一个列表
"2efgh",
"3ijkl",
"4mnop",
"5qrst"
]
#用下标访问矩阵元素
print("字符矩阵中第2行第2列的元素：", cmx[1][1])
print("字符矩阵中第5行第3列的元素：", cmx[4][2])
print("字符矩阵中第2行：", cmx[1])
print("字符矩阵中第5行：", cmx[4])
下面的代码示范了如何用for循环遍历矩阵。代码的功能是累加各行的和，结果存入列表row_sum中。
mtx是4X4矩阵
mtx = [
[1, 2, 3, 4],
[5, 6, 7, 8],
[9, 10, 11, 12],
[13, 14, 15, 16]
]
#求每一行的和
row_sum = []
for r in range(4): #range(4)等同于range(0, 4)
sum = 0
for c in range(4):
sum += mtx[r][c]
row_sum.append(sum)
print("各行的和：", row_sum)
下面的代码示范了如何分两行输入2ｘ3的矩阵。注意，三引号括起来的是注释，也就是下面的第2~6行是注释。
# 下面用3个引号括起来的文本是注释。
'''
输入一个2X3的整数矩阵。输入示例如下：
1 2 3
4 5 6
'''
print("请输入2X3整数矩阵...")
imtx = [ ]
for r in range(2): #输入每一行
line = input()
ns = line.split() #得到当前行中的数字字符串列表
#把字符串列表转换为数字列表
n_line = []
for s in ns:
n = int(s)
n_line.append(n)
imtx.append(n_line)
print("输入的整数矩阵：", imtx)
列表切片
列表切片是指获得列表的一部分元素，组成子列表。在很多场合都会用到。
#切片的写法：列表[x:z]
players = ['charles', 'martina', 'michael', '马龙', '孙杨']
print("[0:3]:", players[0:3]) #[0:3]得到从下标0到下标3（不含下标3）之间的子列表
print("[1:4]:", players[1:4]) #1~第2个元素。4~第5个元素（不含）
#未指定起点或终点
print("[ :4]:", players[:4]) #起点未指定，视为从下标0开始
print("[1: ]:", players[1:]) #终点未指定，视为到列表末尾
print("[ : ]:", players[:]) #[:]是从下标0开始到列表末尾
#负数作为下标
#-1是最后一个，-2是倒数第二，-3是倒数第三，...
print("[-2:-1]:", players[-2:-1])
print("[-3: ]:", players[-3:]) #终点是列表末尾
注意：[1:4]是不含下标4的元素的。[-2:-1]是不含下标-1（也即最后一个）的元素的。
字典
在日常生活中，我们经常遇到“键-值对”类型的数据。比如，生词本用来记录英文单词及其中文释义。这里，英文单词是键，中文释义是值。又比如，电话簿记录了人名和电话号码。此中，人名是键，电话号码是值。使用这种类型的数据时，用‘键’查‘值’是最常发生的；用‘值’查‘键’的几率会少得多。
字典的查询
Python语言提供了字典来存储和操作上述“键-值对”类型的数据。下面的代码示范了字典的用法，是用来存储电话簿。
contacts = {
'马云': '13309283335',
'赵龙': '18989227822',
'张敏': '13382398921',
'乔治': '19833824743',
'乔丹': '18807317878',
'库里': '15093488129',
'韦德': '19282937665'
}
name = input("输入姓名：")
if name in contacts:
print(name, ":", contacts[name])
else:
print("没找到" + name)
对于上面代码，说明如下：
1. contacts是一份字典。定义字典使用花括号{ }。字典的条目是一个键值对，比如字符串'马云'是键，字符串'13309283335'是值。
2. name in contancts，是用来判断name作为键，有没有出现在字典中。
3. contacts[name]，是得到name键在字典中的值。加入name是'马云'，那么contacts[name]将得到'13309283335'。
4. 字典中键可以是整数类型、浮点数类型或字符串类型，还可以是其他类型。但列表不能用作键。
字典中插入键值对
下面的代码片段示范了如何在字典中插入键值对，以及如何修改键值对中值的部分。代码的功能是统计数字在列表中的出现次数。
num_dict = {} #定义一份空字典num_list = [1, 3, 5, 1, 8, 3, 1]
for n in num_list:
if n in num_dict: #n这个键有没有在字典中吗？
num_dict[n] = num_dict[n] + 1 #这里，修改键值对的值。功能是出现次数增1.
else:
num_dict[n] = 1 #这里，插入键值对。键为n，值为1.
关于字典的更多用法，在你需要用到某种操作时，再上网搜索。
模块
Python模块与Java包有些类似，也有不同。
每一个Python程序文件都构成一个模块。文件名就是模块名，比如newWordsFuncs.py程序文件的模块名是newWordsFuncs。
下面举例说明模块的导入。
假如你编写了newWordsFuncs.py程序文件，里头定义了read_command( )函数，append( )函数，delete( )函数和query( )函数。如何在另一个python程序文件main.py中使用newWordsFuncs.py内定义的函数呢？
下面讲解3种导入的方法。这3种方法本质是一样的，细节上有差异。
1. 导入模块
下面是第一种用法的main.py文件的代码。底色为橙色的文字与模块有关。导入模块的写法是：
import 模块名
调用模块内函数的写法是：
模块名.函数(实参）
import newWordsFuncs #导入模块newWordsFuncs
word_dict = {
'name': '名字',
'python': '蟒蛇',
'dictionary': '字典',
'list': '列表',
'variable': '变量',
'class': '类',
'object': '对象'
}
while True:
#步骤1. 输入命令
command = newWordsFuncs.read_command() #调用newWordsFuncs模块的read_command( )函数
#步骤2. 分析命令
operator = command[0]
#退出
if operator == "quit":
print("bye.")
break;
if operator == 'append':
result = newWordsFuncs.append(command, word_dict)
elif operator == 'del':
result = newWordsFuncs.delete(command, word_dict)
elif operator == 'query':
result = newWordsFuncs.query(command, word_dict)
else:
result = "Bad command: " + operator
#步骤3. 输出结果
print(result)
print(word_dict)
2. 导入模块并重命名
下面是第二种用法的main.py文件的代码。底色为橙色的文字与模块有关。导入模块并重命名的写法是：
import 模块名 as 新模块名
调用模块内函数的写法是：
新模块名.函数(实参）
import newWordsFuncs as nwf #新模块名是nwf
word_dict = {
'name': '名字',
'python': '蟒蛇',
'dictionary': '字典',
'list': '列表',
'variable': '变量',
'class': '类',
'object': '对象'
}
while True:
#步骤1. 输入命令
command = nwf.read_command() #调用模块内的函数。nwf是新模块名。
#步骤2. 分析命令
operator = command[0]
#退出
if operator == "quit":
print("bye.")
break;
if operator == 'append':
result = nwf.append(command, word_dict)
elif operator == 'del':
result = nwf.delete(command, word_dict)
elif operator == 'query':
result = nwf.query(command, word_dict)
else:
result = "Bad command: " + operator
#步骤3. 输出结果
print(result)
print(word_dict)
3. 直接导入模块内的函数
采用前面两种导入方法的话，调用函数时必须带上模块名。
下面是第三种用法的main.py程序文件的代码，它里头调用函数时，无须带上模块名。直接导入模块内的函数的写法是：
from 模块名 import 函数名1， 函数名2
如果要导入更多函数，在尾部追加函数名即可。下面的代码直接导入了4个函数。底色为橙色的文字与模块有关。
from newWordsFuncs import read_command, append, delete, query
word_dict = {
'name': '名字',
'python': '蟒蛇',
'dictionary': '字典',
'list': '列表',
'variable': '变量',
'class': '类',
'object': '对象'
}
while True:
#步骤1. 输入命令
command = read_command()
#步骤2. 分析命令
operator = command[0]
#退出
if operator == "quit":
print("bye.")
break;
if operator == 'append':
result = append(command, word_dict)
elif operator == 'del':
result = delete(command, word_dict)
elif operator == 'query':
result = query(command, word_dict)
else:
result = "Bad command: " + operator
#步骤3. 输出结果
print(result)
print(word_dict)
上面的代码的第一行换成：
from newWordsFuncs import *
将把newWordsFuncs模块内的全部函数直接导入进来（代价是消耗内存空间）。这里，星号*代表所有。接着，你可以向上述代码那样，不带模块名地调用函数。
文件操作
Python的文件操作，在写法上与C/C++或Java类似，同样遵循打开文件 –> 读写文件 –> 关闭文件的流程。
1. 读取整个文件的内容
下面是读取整个文件内容的示例程序。你可以自己准备一份10-1-data.txt文件，文件内容随意。然后复制以下内容，存为程序文件，最后运行程序看看效果。
with open('10-1-data.txt') as datafile:
lines = datafile.read()
print(lines)
print("lines[-1]:", lines[-1])
上面的代码使用了with语句。with语句的书写格式是：
with ... as ...:
with语句块
上面的示例代码中，with语句用在文件操作的场合。这是常见的使用场合，with语句还可以用在其他场合。
我们来分析一下上面的示例代码。
1). open(‘10-1-data.txt’)是打开了10-1-data.txt文件，返回文件对象。with语句把这个文件对象赋值给datafile变量。
2). datafile.read( ）是读入整个文件的内容。第二行用lines变量来引用内存中的文件内容（字符串对象）。
3). with语句的语句块都要缩进。
4). with语句结束的时候，会自动关闭文件。正因为这一点，建议使用with语句来包裹文件操作步骤。
2. 逐行读取文件
下面的代码示范了逐行读取文件的用法。with语句的说明参照上一种用法。with语句结束时会自动关闭文件。
with open("10-1-data.txt") as datafile:
for line in datafile: #逐行读取
print(line)
print("上面的输出，行与行之间有一行空白。"
"原因是除了最后一行，读入的各行结尾有换行符。加上print()本身会换行。")
print("下面的输出不隔开一行空白。")
with open("10-1-data.txt") as datafile:
for line in datafile:
print(line.rstrip()) #rstrip()删除尾部空白（含换行符、制表符和空格）
上面的代码中，for语句达成了逐行读取文件内容的效果。
3. 读入到列表
下面的代码示范了读取文件的内容并存入列表的做法。
filename = 'chap10-data/pi_digits.txt'
with open(filename) as file_object:
lines = file_object.readlines() #readlines()一次性地读入所有行。每一行作为一个元素存入列表中。
上面的代码中，file_object对象的readlines()方法的作用是读取文件内容并存入列表。文件的每一行构成列表的元素。
4. 读入有汉字的文件
要读入有汉字的文件，需要导入codecs模块。下面的示例代码示范了用法。橙色突显的文字值得特别关注，配合注释阅读，你应该能明白具体的用法。
#读/写有汉字的文件，要使用codecs模块。
import codecs
#下面的例子中,10-1-7-names.txt文件使用的是utf-8编码。
with codecs.open('chap10-data/10-1-7-names.txt', encoding='utf-8') as namesfile:
names = namesfile.read()
print(names)
#下面的例子中，10-1-7-txt文件格式.txt文件使用的是gbk编码。
with codecs.open('chap10-data/10-1-7-txt文件格式.txt', encoding='gbk') as txtfile:
contents = txtfile.read()
print(contents)
#utf-8编码和gbk编码都是能对汉字进行编号，但对同一个汉字，比如‘过’，两种编码给出的编号是不同的。
#能通过软件把utf-8编码文件转换为gbk编码文件，反之也行。
5. 写入文件
下面的示例程序示范了写入文件的用法。
with open("10-2-data.txt", "w") as mfile:
mfile.write("I love python.")
mfile.write("Python is easy.")
mfile.write("I love programming.")
#write()函数不会自动添加换行符。
print("写入完毕。")
print("把以上内容写成3行。")
with open("10-2-data.txt", "w") as sfile:
sfile.write("I love python.\n") #双引号内，两个字符\n一起表示换行符。
sfile.write("Python is easy.\n")
sfile.write("I love programming.\n")
print("分3行写入完毕。")
关于上面的代码，说明如下：
1). 写打开要带上"w"参数。w是write的第一个字母。
2). write()函数不会在输出内容尾部添加换行符。你要写成独立的一行，需要你自己添加换行符，如上面的第二段代码所示。
3). with语句结束，会自动关闭文件。
4). 写打开文件，如果文件不存在，会自动生成它；如果文件已经存在，则会清空文件。
5). 要写有汉字的内容，需要使用codecs模块。参照上一小节的说明。
897
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
