Python 基础知识
1. 认识 Python
1.1 Python 概述
1.1.1 基本概念
1.1.2 语言优势
2020 年 2 月的 TIOBE 的编程语言排行榜：
Python 也存在缺点：
1.1.3 典型应用
2020-02-25_20-19-
1.2 安装 Python 环境
1.2.1 下载 Python
https://www.python.org/downloads/
目前最新版是 3.8.
1.2.2 安装 Python
1.2.3 配置环境变量
Python 的安装路径，及其 Script 文件夹
1.2.4 下载并配置 Pycharm
https://www.jetbrains.com/pycharm/download/#section=windows
Python文件模板配置
字体设置
- *- codeing = utf- 8 - *-
@Time :${DATE} ${TIME}
@Author:Eric
@File : ${NAME}.py
@Software: ${PRODUCT_NAME}
课堂练习 ：
下载并安装 Python 环境（ 10 分钟）
1.3 编写第一个 Python 程序
1.4 注释
单行注释
以 #开头，# 右边的所有东西当做说明，而不是真正要执行的程序，起辅助说明作用
多行注释
python程序中，中文支持
如果直接在程序中用到了中文，比如
如果直接运行输出，程序会出错。
解决的办法为：在程序的开头写入如下代码，这就是中文注释
修改之后的程序:
运行结果:
注意：
在 python 的语法规范中推荐使用的方式：
课堂练习 ：
编写第一个 Python 程序，并配置好 Pycharm（ 10 分钟）
# 我是注释，可以在里写一些功能说明之类的哦
print('hello world')
'''
我是多行注释，
可以写很多很多行的功能说明
哈哈哈。。。
'''
print('hello world')
print('你好')
#coding=utf- 8
#coding=utf- 8
print('你好')
你好
# - *- coding:utf- 8 - *-
1.5 变量及类型
1.6 标识符和关键字
什么是关键字
python一些具有特殊功能的标示符，这就是所谓的关键字
关键字，是python已经使用的了，所以不允许开发者自己定义和关键字相同的名字的标示符
查看关键字:
1.7 输出
1.7.1 普通输出
python中普通的输出
1.7.2 格式化输出
>>> import keyword
>>> keyword.kwlist
and as assert break class continue def
del
elif else except exec finally for from
global
if in import is lambda not or
pass
print raise return try while with yield
# 打印提示
print('hello world')
1.7.2.1 格式化操作的目的
比如有以下代码:
想一想:
在输出年龄的时候，用了多次"我今年xx岁"，能否简化一下程序呢？？？
答:
字符串格式化
1.7.2.2 什么是格式化
看如下代码:
在程序中，看到了 % 这样的操作符，这就是 Python 中格式化输出。
1.7.2.3 常用的格式符号
下面是完整的，它可以与％符号使用列表:
pirnt("我今年 10 岁")
pirnt("我今年 11 岁")
pirnt("我今年 12 岁")
...
age = 10
print("我今年%d岁"%age)
age += 1
print("我今年%d岁"%age)
age += 1
print("我今年%d岁"%age)
...
age = 18
name = "xiaohua"
print("我的姓名是%s,年龄是%d"%(name,age))
格式符号 转换
%c 字符
%s 通过str() 字符串转换来格式化
%i 有符号十进制整数
%d 有符号十进制整数
%u 无符号十进制整数
%o 八进制整数
%x 十六进制整数（小写字母）
%X 十六进制整数（大写字母）
%e 索引符号（小写'e'）
%E 索引符号（大写“E”）
%f 浮点实数
%g ％f和％e 的简写
%G ％f和％E的简写
1.7.3 换行输出
在输出的时候，如果有 \n 那么，此时 \n 后的内容会在另外一行显示
1.8 输入
运行结果：
input()的小括号中放入的是，提示信息，用来在获取数据之前给用户的一个简单提示
input()在从键盘获取了数据以后，会存放到等号左边的变量中
print(" 1234567890 - ------") # 会在一行显示
print(" 1234567890 \n-------") # 一行显示 1234567890 ，另外一行显示-------
password = input("请输入密码:")
print('您刚刚输入的密码是:', password)
input()函数接受的输入必须是表达式
1.9 运算符和表达式
>>> a = input()
123
>>> a
123
>>> type(a)
<type 'int'>
>>> a = input()
abc
Traceback (most recent call last):
File "<stdin>", line 1 , in <module>
File "<string>", line 1 , in <module>
NameError: name 'abc' is not defined
>>> a = input()
"abc"
>>> a
'abc'
>>> type(a)
<type 'str'>
>>> a = input()
1 + 3
>>> a
4
>>> a = input()
"abc"+"def"
>>> a
'abcdef'
>>> value = 100
>>> a = input()
value
>>> a
100
（了解）
（了解）
（了解）
2. 判断语句和循环语句
2.1 条件判断语句
if语句是用来进行判断的，其使用格式如下：
demo:
运行结果:
2.1.1 if-else
代码的缩进为一个tab键，或者 4 个空格
if 要判断的条件:
条件成立时，要做的事情
age = 30
print "------if判断开始------"
if age>= 18 :
print "我已经成年了"
print "------if判断结束------"
- -----if 判断开始 ------ 我已经成年了
- -----if 判断结束 ------
if True: print ("Answer") print ("True") else: print ("Answer") print ("False") # 缩进不一致，会导致运行错误
2.1.2 elif
demo:
注意
可以和else一起使用
elif必须和if一起使用，否则出错
2.1.3 if 嵌套
2.1.3.1 if 嵌套的格式
说明
外层的if判断，也可以是if-else
内层的if判断，也可以是if-else
根据实际开发的情况，进行选择
2.1.3.2 if 嵌套的应用
demo：
score = 77
if score>= 90 and score<= 100 :
print('本次考试，等级为A')
elif score>= 80 and score< 90 :
print('本次考试，等级为B')
elif score>= 70 and score< 80 :
print('本次考试，等级为C')
elif score>= 60 and score< 70 :
print('本次考试，等级为D')
#elif score>= 0 and score< 60 :
else: #elif可以else一起使用
print('本次考试，等级为E')
if 条件 1 :
满足条件 1 做的事情 1
满足条件 1 做的事情 2
...(省略)...
if 条件 2 :
满足条件 2 做的事情 1
满足条件 2 做的事情 2
...(省略)...
2.1.3.2 import 与 from...import
在 python 用 import 或者 from...import 来导入相应的模块。
将整个模块 (somemodule) 导入，格式为： import somemodule
从某个模块中导入某个函数, 格式为： from somemodule import somefunction
从某个模块中导入多个函数, 格式为： from somemodule import firstfunc, secondfunc, thirdfunc
将某个模块中的全部函数导入，格式为： from somemodule import *
【生成随机数】
1. 第一行代码引入库：
2. 生成指定范围的随机数
课堂练习 ：
综合使用 if 语句的相关知识，实现石头剪子布游戏效果。显示下面提示信息：
用户输入数字 0-2 中的一个数字，与系统随机生成的数字比较后给出结果信息。
例如：输入 0 后，显示如下
xingBie = 1 # 用 1 代表男生， 0 代表女生
danShen = 1 # 用 1 代表单身， 0 代表有男/女朋友
if xingBie == 1 :
print("是男生")
if danShen == 1 :
print("我给你介绍一个吧？")
else:
print("你给我介绍一个呗？")
else:
print("你是女生")
print("......")
import random #引入随机库
computer = random.randint( 0 , 2 ) #随机生成 0 、 1 、 2 中的一个数字，赋值给变量computer
请输入：剪刀（ 0 ）、石头（ 1 ）、布（ 2 ）：_
提示：对于输入不正常的情况尽可能考虑全面，使程序能够正常运行。
建议用时 15~20 分钟。
2.2 循环语句
2.2.1 for 循环
for 循环的格式
demo：
你的输入为：剪刀（ 0 ）
随机生成数字为： 1
哈哈，你输了：）
for 临时变量 in 列表或者字符串等:
循环满足条件时执行的代码
name = 'chengdu'
for x in name:
print(x)
2.2.2 while 循环
demo
课堂练习 ：
1. 计算 1~100 的累积和（包含 1 和 100 ）
2. 计算 1~100 之间偶数的累积和（包含 1 和 100 ）
建议用时 20 分钟。
2.2.3 break 和 continue
i = 0
while i< 5 :
print("当前是第%d次执行循环"%(i+ 1 ))
print("i=%d"%i)
i+= 1
带有break的循环示例如下:
带有continue的循环示例如下:
作业：
i = 0
while i< 10 :
i = i+ 1
print('----')
if i== 5 :
break
print(i)
i = 0
while i< 10 :
i = i+ 1
print('----')
if i== 5 :
continue
print(i)
使用 for 循环和 while 循环，打印九九乘法表，显示效果如下图：
3. 字符串、列表、元组、字典
3.1 字符串
3.1.1 单引号和双引号如何选择？
1 、包含单引号的字符串
word = '字符串'
sentence = "这是一个句子。"
paragraph = """这是一个段落，
可以由多行组成"""
转义字符 描述
(在行尾时) 续行符
\ 反斜杠符号
\' 单引号
\" 双引号
\a 响铃
\b 退格(Backspace)
\000 空
\n 换行
\v 纵向制表符
\t 横向制表符
\r 回车
\f 换页
\oyy 八进制数， yy 代表的字符，例如： \o12 代表换行，其中 o 是字母，不是数字 0 。
\xyy 十六进制数，yy代表的字符，例如：\x0a代表换行
\other 其它的字符以普通格式输出
假如你想定义一个字符串 my_str，其值为： I'm a student，则可以采用如下方式，通过转义字符 \ 进 行定义。
也可以不使用转义字符，利用双引号直接进行定义。
2 、包含双引号的字符串
假如你想定义一个字符串 my_str，其值为： Jason said "I like you" ，则可以采用如下方式，通过转义 字符 \ 进行定义。
也可以不使用转义字符，利用单引号直接进行定义。
3.1.2 转义字符
my_str = 'I\'m a student'
my_str = "I'm a student"
my_str = "Jason said \"I like you\""
my_str = 'Jason said "I like you"'
序
号
方法及描述
1 capitalize() 将字符串的第一个字符转换为大写
2
center(width, fillchar) 返回一个指定的宽度 width 居中的字符串，fillchar 为填充的字符，
默认为空格。
3 count(str, beg= 0,end=len(string)) 返回 str 在 string 里面出现的次数，如果 beg 或者 end
指定则返回指定范围内 str 出现的次数
4
bytes.decode(encoding="utf-8", errors="strict") Python3 中没有 decode 方法，但我
们可以使用 bytes 对象的 decode() 方法来解码给定的 bytes 对象，这个 bytes 对象可以由
str.encode() 来编码返回。
5
encode(encoding='UTF-8',errors='strict') 以 encoding 指定的编码格式编码字符串，如
果出错默认报一个ValueError 的异常，除非 errors 指定的是'ignore'或者'replace'
6
endswith(suffix, beg=0, end=len(string)) 检查字符串是否以 obj 结束，如果beg 或者 end
指定则检查指定的范围内是否以 obj 结束，如果是，返回 True,否则返回 False.
7 expandtabs(tabsize=8) 把字符串 string 中的 tab 符号转为空格，tab 符号默认的空格数是
8 。
3.1.3 字符串的截取和连接
3.1.4 字符串的常见操作
str='chengdu'
print(str) # 输出字符串
print(str[ 0 :- 1 ]) # 输出第一个到倒数第二个的所有字符
print(str[ 0 ]) # 输出字符串第一个字符
print(str[ 2 : 5 ]) # 输出从第三个开始到第五个的字符
print(str[ 2 :]) # 输出从第三个开始后的所有字符
print(str * 2 ) # 输出字符串两次
print(str + '你好') # 连接字符串
print(str[: 5 ]) # 输出第五个字母前的所有字符
print(str[ 0 : 7 : 2 ]) # [起始：终止：步长]
print('------------------------------')
print('hello\nchengdu') # 使用反斜杠(\)+n转义特殊字符
print(r'hello\npython') # 在字符串前面添加一个 r，表示原始字符串，不会发生转义
序
号
方法及描述
8
find(str, beg=0, end=len(string)) 检测 str 是否包含在字符串中，如果指定范围 beg 和 end
，则检查是否包含在指定范围内，如果包含返回开始的索引值，否则返回-1
9
index(str, beg=0, end=len(string)) 跟find()方法一样，只不过如果str不在字符串中会报一
个异常.
10 isalnum()^ 如果字符串至少有一个字符并且所有字符都是字母或数字则返 ^ 回 True, 否则返回 False
11 isalpha() 如果字符串至少有一个字符并且所有字符都是字母则返回 True, 否则返回 False
12 isdigit() 如果字符串只包含数字则返回 True 否则返回 False..
13
islower() 如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符
都是小写，则返回 True，否则返回 False
14 isnumeric() 如果字符串中只包含数字字符，则返回 True，否则返回 False
15 isspace() 如果字符串中只包含空白，则返回 True，否则返回 False.
16 istitle() 如果字符串是标题化的 (见 title()) 则返回 True，否则返回 False
17
isupper() 如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字
符都是大写，则返回 True，否则返回 False
18
join(seq) 以指定字符串作为分隔符，将 seq 中所有的元素(的字符串表示)合并为一个新的
字符串
19 len(string) 返回字符串长度
20 [ljust(width, fillchar]) 返回一个原字符串左对齐, 并使用 fillchar 填充至长度 width 的新字符 串，fillchar 默认为空格。
21 lower() 转换字符串中所有大写字符为小写.
22 lstrip() 截掉字符串左边的空格或指定字符。
23 maketrans() 创建字符映射的转换表，对于接受两个参数的最简单的调用方式，第一个参数 是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标。
24 max(str) 返回字符串 str 中最大的字母。
25 min(str) 返回字符串 str 中最小的字母。
26
[replace(old, new , max]) 把 将字符串中的 str1 替换成 str2,如果 max 指定，则替换不超
过 max 次。
27 rfind(str, beg=0,end=len(string)) 类似于 find() 函数，不过是从右边开始查找.
28 rindex(str, beg=0, end=len(string)) 类似于 index()，不过是从右边开始.
29
[rjust(width,, fillchar]) 返回一个原字符串右对齐,并使用fillchar(默认空格）填充至长度
width 的新字符串
30 rstrip() 删除字符串字符串末尾的空格.
序
号
方法及描述
31
split(str="", num=string.count(str)) num=string.count(str)) 以 str 为分隔符截取字
符串，如果 num 有指定值，则仅截取 num+1 个子字符串
32
[splitlines(keepends]) 按照行('\r', '\r\n', \n')分隔，返回一个包含各行作为元素的列表，如
果参数 keepends 为 False，不包含换行符，如果为 True，则保留换行符。
33 startswith(substr, beg=0,end=len(string)) 检查字符串是否是以指定子字符串 substr 开
头，是则返回 True，否则返回 False。如果beg 和 end 指定值，则在指定范围内检查。
34 [strip(chars]) 在字符串上执行 lstrip()和 rstrip()
35 swapcase() 将字符串中大写转换为小写，小写转换为大写
36
title() 返回"标题化"的字符串,就是说所有单词都是以大写开始，其余字母均为小写(见
istitle())
37 translate(table, deletechars="") 根据 str 给出的表(包含^256 个字符)转换 string 的字符, 要
过滤掉的字符放到 deletechars 参数中
38 upper() 转换字符串中的小写字母为大写
39 zfill (width) 返回长度为 width 的字符串，原字符串右对齐，前面填充 0
40 isdecimal() 检查字符串是否只包含十进制字符，如果是返回 true，否则返回 false。
3.2 列表
3.2.1 列表的定义与访问
列表的格式
变量 A 的类型为列表
比 C 语言的数组强大的地方在于列表中的元素可以是不同类型的
打印列表
demo:
列表的循环遍历
为了更有效率的输出列表的每个数据，可以使用循环来完成
demo:
3.2.3 常用操作
namesList = ['xiaoWang','xiaoZhang','xiaoHua']
testList = [ 1 , 'a']
namesList = ['xiaoWang','xiaoZhang','xiaoHua']
print(namesList[ 0 ])
print(namesList[ 1 ])
print(namesList[ 2 ])
namesList = ['xiaoWang','xiaoZhang','xiaoHua']
for name in namesList:
print(name)
------------- 操作名称 -------
-------------------------------- 操作方法 举例
访问列表中的元素 通过下标直接访问 print(list1[0])
列表的切片 使用 [: :] list1[2:5:2]
遍历列表 通过 for 循环 for i in list1: print(i)
【增】新增数据到列表 尾部 使用 append list1.append(5)
【增】列表的追加 使用 extend 方法 list1.extend(list2)
【增】列表数据插入 insert 方法 list1.insert(1, 3)
【删】列表的删除
del ：我们通过索引删除指定位置的元
素。
remove：移除列表中指定值的第一个匹
配值。如果没找到的话，会抛异常。
del list1[0]
list1.remove(1) 注意两
种方法的区别
【删】弹出列表尾部元
素 使用 pop list1.pop()
【改】更新列表中的数 据 通过下标原地修改 list1[0] = 8
【查】列表成员关系 in 、not in 2 in list1
列表的加法操作 + list3 = list1 + list2
【排】列表的排序 sort 方法 list1.sort()
【排】列表的反转 reverse list1.reverse()
操作名称 操作方法 举例
获取列表长度 len（）
获取列表元素最大值 max（）
获取列表元素最小值 min（）
其它类型对象转换成列表 list（）
3.2.4 列表的嵌套
列表嵌套
类似while循环的嵌套，列表也是支持嵌套的
一个列表中的元素又是一个列表，那么这就是列表的嵌套
应用
一个学校，有 3 个办公室，现在有 8 位老师等待工位的分配，请编写程序，完成随机的分配
schoolNames = [['北京大学','清华大学'],
['南开大学','天津大学','天津师范大学'],
['山东大学','中国海洋大学']]
#encoding=utf- 8
import random
# 定义一个列表用来保存 3 个办公室
offices = [[],[],[]]
# 定义一个列表用来存储 8 位老师的名字
names = ['A','B','C','D','E','F','G','H']
i = 0
for name in names:
index = random.randint( 0 , 2 )
offices[index].append(name)
i = 1
for tempNames in offices:
print('办公室%d的人数为:%d'%(i,len(tempNames)))
i+= 1
for name in tempNames:
print("%s"%name,end='')
print("\n")
print("-"* 20 )
作业 ：
现有商品列表如下：
1. products = [["iphone",6888],["MacPro",14800],["小米6",2499],["Coffee",31],["Book",60],
["Nike",699]]，需打印出以下格式：
- 根据上面的 products 列表写一个循环，不断询问用户想买什么，用户选择一个商品编号，就把对应 的商品添加到购物车里，最终用户输入 q 退出时，打印购买的商品列表。
3.3 元组
3.3.1 元组的定义与访问
创建空元组
- ----- 商品列表 - -----
0 iphone 6888
1 MacPro 14800
2 小米 6 2499
3 Coffee 31
4 Book 60
5 Nike 699
tup 1 = ()
操作名称 操作方法 举例
访问元组中的元素 通过下标直接访问 print(tuple1[0])
遍历元组 通过for循环 for i in tuple1: print(i)
元组的切片 使用[: :] tuple1[2:5:2]
元组的定义
元组的访问
元组中的元素值是不允许修改的，但我们可以对元组进行连接组合，如下实例:
删除元组后，再次访问会报错
3.3.2 常用操作：
tup 1 = ( 50 ) # 不加逗号，类型为整型
print(type(tup 1 )) #输出<class 'int'>
tup 1 = ( 50 ,) # 加逗号，类型为元组
print(type(tup 1 )) #输出<class 'tuple'>
tup 1 = ('Google', 'baidu', 2000 , 2020 )
tup 2 = ( 1 , 2 , 3 , 4 , 5 , 6 , 7 )
print ("tup 1 [ 0 ]: ", tup 1 [ 0 ])
print ("tup 2 [ 1 : 5 ]: ", tup 2 [ 1 : 5 ])
tup 1 = ( 12 , 34. 56 )
tup 2 = ('abc', 'xyz')
# 以下修改元组元素操作是非法的。
# tup 1 [ 0 ] = 100
# 创建一个新的元组
tup 3 = tup 1 + tup 2
print (tup 3 )
tup = ('Google', 'baidu', 2000 , 2020 )
print (tup)
del tup
print ("删除后的元组 tup : ")
print (tup)
操作名称 元组的加法操作 操作方法 + 举例 tuple3 = tuple1 + tuple2
操作名称 操作方法 举例
元组成员关系 in 2 in list1
得到重复元素数量 count tuple1.count(1)
操作名称 操作方法 举例
获取元组长度 len（）
获取元组元素最大值 max（）
获取元组元素最小值 min（）
其它类型对象转换成元组 tuple（）
3.4 字典
3.4.1 字典的定义
变量 info 为字典类型：
说明：
字典和列表一样，也能够存储多个数据
列表中找某个元素时，是根据下标进行的
字典中找某个元素时，是根据 '名字'（就是冒号: 前面的那个值，例如上面代码中
的'name'、'id'、'sex'）
字典的每个元素由 2 部分组成，键:值。例如 'name':'班长' ,'name'为键，'班长'为值
3.4.2 根据键访问值
若访问不存在的键，则会报错：
在我们不确定字典中是否存在某个键而又想获取其值时，可以使用 get 方法，还可以设置默认值：
3.4.3 常用操作：
info = {'name':'班长', 'id': 100 , 'sex':'f', 'address':'地球亚洲中国北京'}
info = {'name':'吴彦祖','age': 18 }
print(info['age']) # 获取年龄
# print(info['sex']) # 获取不存在的key，会发生异常
print(info.get('sex')) # 获取不存在的key，获取到空的内容，不会出现异常
info['sex']
Traceback (most recent call last):
File "<stdin>", line 1 , in <module>
KeyError: 'sex'
>>> age = info.get('age')
>>> age #'age'键不存在，所以age为None
>>> type(age)
<type 'NoneType'>
>>> age = info.get('age', 18 ) # 若info中不存在'age'这个键，就返回默认值 18
>>> age
18
------------- 操作名称 -----
------------
操作方法 举例
访问字典中的元素
（ 1 ）
通过key访问，key不存在会抛出
异常
print(dict1[“小明”])
访问字典中的元素
（ 2 ）
通过get方法，不存在返回None,
不抛出异常 print(dict1.get(“”小明))
遍历字典（ 1 ） 通过 for 循环，只能获取 key
for key in dict1:
print(key, dict1[key])
遍历字典（ 2 ） 配合 items 方法，获取 key 和 val for key, val in dict1.items(): print(key, val)
直接获取所有 key 和 value
使用keys和values方法 print(dict1.values())
print(dict1.keys())
修改 val 直接通过 key 修改 dict1[' 小明'] = 2003
新增键值对 直接新增 dict1[‘小李'] = 2005
操作名称 操作方法 举例
字典元素的删除 通过 key 删除 del dict1[' 小李']
字典元素的弹出 通过 pop 方法 dict1.pop(" 小李")
判断 key 是否存在 in “key” in dict1
合并字典 update dict1.update(dict2)
把两个列表转为字典 dict+zip 方法 dict(zip(list1,list2))
把一个嵌套列表转为字典 dict 方法 dict2 = dict([['key1','value1']])
清除字典内的元素 clear 方法 dict1.clear()
操作名称 操作方法 举例
获取字典长度 len（）
获取最大的key max（）
获取最小的key min（）
其它类型对象转换成字典 dict（） dict([(1, 2), (2, 3)])
操作名称 操作方法 举例
遍历集合 通过for循环 for i in set1: print(i)
更新集合 update方法 set1.update(set2)
向集合添加新元素 add方法 set1.add(5)
移除集合中的元素 remove方法 set1.remove(5)
弹出元素 pop方法 val = set1.pop()
清除元素 clear方法 set1.clear()
删除集合 del del set1
操作名称 操作方法 举例
获取集合长度 len（）
获取最大的元素 max（）
获取最小的元素 min（）
其它类型对象转换成集合 set（）
3.5 集合
常用操作：
是否有序 是否可变类型
列表 [ ] 有序 可变类型
元组 ( ) 有序 不可变类型
字典{ } 无序 key不可变 val可变
集合{ } 无序 可变类型（不重复）
3.6 小结
4. 函数
4.1 函数的概念
如果在开发程序时，需要某块代码多次，但是为了提高编写的效率以及代码的重用，所以把具有独
立功能的代码块组织为一个小模块，这就是函数。
4.2 函数定义和调用
4.2.1 定义函数
定义函数的格式如下：
demo:
def 函数名():
代码
4.2.2 调用函数
定义了函数之后，就相当于有了一个具有某些功能的代码，想要让这些代码能够执行，需要调用它
调用函数很简单的，通过 函数名 () 即可完成调用
demo:
4.3 函数参数
4.3.1 定义带有参数的函数
示例如下：
4.3.2 调用带有参数的函数
以调用上面的 add2num(a, b) 函数为例:
# 定义一个函数，能够完成打印信息的功能
def printInfo():
print '------------------------------------'
print ' 人生苦短，我用Python'
print '------------------------------------'
# 定义完函数后，函数是不会自动执行的，需要调用它才可以
printInfo()
def add 2 num(a, b):
c = a+b
print c
def add 2 num(a, b):
c = a+b
print c
add 2 num( 11 , 22 ) #调用带有参数的函数时，需要在小括号中，传递数据
调用带有参数函数的运行过程：
4.4 函数返回值
4.4.1 带有返回值的函数
想要在函数中把结果返回给调用者，需要在函数中使用 return
如下示例:
或者
4.4.2 保存函数的返回值
在本小节刚开始的时候，说过的 “买烟” 的例子中，最后儿子给你烟时，你一定是从儿子手中接过来 对
么，程序也是如此，如果一个函数返回了一个数据，那么想要用这个数据，那么就需要保存
保存函数的返回值示例如下:
def add 2 num(a, b):
c = a+b
return c
def add 2 num(a, b):
return a+b
4.4.3 在 python 中我们可不可以返回多个值？ (了解)
本质是利用了元组
课堂练习 ：
1. 写一个打印一条横线的函数。（提示：横线是若干个 “-” 组成）
2. 写一个函数，可以通过输入的参数，打印出自定义行数的横线。（提示：调用上面的函数）
3. 写一个函数求三个数的和
4. 写一个函数求三个数的平均值（提示：调用上面的函数）
【建议每题 5 分钟以内】
#定义函数
def add 2 num(a, b):
return a+b
#调用函数，顺便保存函数的返回值
result = add 2 num( 100 , 98 )
#因为result已经保存了add 2 num的返回值，所以接下来就可以使用了
print result
>>> def divid(a, b):
... shang = a//b
... yushu = a%b
... return shang, yushu
...
>>> sh, yu = divid( 5 , 2 )
>>> sh
5
>>> yu
1
参考代码 1-2 ：
参考代码 3-4 ：
4.5 局部变量和全局变量
4.5.1 局部变量
什么是局部变量
如下图所示:
# 打印一条横线
def printOneLine():
print("-"* 30 )
# 打印多条横线
def printNumLine(num):
i= 0
# 因为printOneLine函数已经完成了打印横线的功能，
# 只需要多次调用此函数即可
while i<num:
printOneLine()
i+= 1
printNumLine( 3 )
# 求 3 个数的和
def sum 3 Number(a,b,c):
return a+b+c # return 的后面可以是数值，也可是一个表达式
# 完成对 3 个数求平均值
def average 3 Number(a,b,c):
# 因为sum 3 Number函数已经完成了 3 个数的就和，所以只需调用即可
# 即把接收到的 3 个数，当做实参传递即可
sumResult = sum 3 Number(a,b,c)
aveResult = sumResult/ 3. 0
return aveResult
# 调用函数，完成对 3 个数求平均值
result = average 3 Number( 11 , 2 , 55 )
print("average is %d"%result)
小总结
局部变量，就是在函数内部定义的变量
不同的函数，可以定义相同的名字的局部变量，但是各用个的不会产生影响
局部变量的作用，为了临时保存数据需要在函数中定义变量来进行存储，这就是它的作用
4.5.2 全局变量
什么是全局变量
如果一个变量，既能在一个函数中使用，也能在其他的函数中使用，这样的变量就是全局变量
demo 如下:
全局变量和局部变量名字相同问题
看如下代码:
# 定义全局变量
a = 100
def test 1 ():
print(a)
def test 2 ():
print(a)
# 调用函数
test 1 ()
test 2 ()
修改全局变量
既然全局变量，就是能够在所以的函数中进行使用，那么可否进行修改呢？
代码如下:
总结:
在函数外边定义的变量叫做全局变量
全局变量能够在所有的函数中进行访问
如果在函数中修改全局变量，那么就需要使用global进行声明，否则出错
如果全局变量的名字和局部变量的名字相同，那么使用的是局部变量的，小技巧强龙不压地头蛇
4.6 函数使用注意事项
1. 自定义函数
<1> 无参数、无返回值
<2> 无参数、有返回值
注意:
一个函数到底有没有返回值，就看有没有return，因为只有return才可以返回数据
在开发中往往根据需求来设计函数需不需要返回值
函数中，可以有多个return语句，但是只要执行到一个return语句，那么就意味着这个函数的调用
完成
<3> 有参数、无返回值
注意：
在调用函数时，如果需要把一些数据一起传递过去，被调用函数就需要用参数来接收
参数列表中变量的个数根据实际传递的数据的多少来确定
<4> 有参数、有返回值
<5> 函数名不能重复
2. 调用函数
<1> 调用的方式为：
<2> 调用时，到底写不写 实参
如果调用的函数 在定义时有形参，那么在调用的时候就应该传递参数
<3> 调用时，实参的个数和先后顺序应该和定义函数中要求的一致
<4> 如果调用的函数有返回值，那么就可以用一个变量来进行保存这个值
3. 作用域
<1> 在一个函数中定义的变量，只能在本函数中用 (局部变量)
<2> 在函数外定义的变量，可以在所有的函数中使用 (全局变量)
def 函数名():
语句
def 函数名():
语句
return 需要返回的数值
def 函数名(形参列表):
语句
def 函数名(形参列表):
语句
return 需要返回的数值
函数名 ([实参列表])
5. 文件操作
文件，就是把一些数据存放起来，可以让程序下一次执行的时候直接使用，而不必重新制作一份，省
时省力。
5.1 文件打开与关闭
5.1.1 打开文件
在 python，使用 open 函数，可以打开一个已经存在的文件，或者创建一个新文件
open(文件名，访问模式)
示例如下：
说明:
f = open('test.txt', 'w')
访问
模式
说明
r 以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。
w
打开一个文件只用于写入。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文
件。
a 打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，
新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
rb 以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。这是默认模式。
wb
以二进制格式打开一个文件只用于写入。如果该文件已存在则将其覆盖。如果该文件不存
在，创建新文件。
ab
以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结
尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进
行写入。
r+ 打开一个文件用于读写。文件指针将会放在文件的开头。
w+ 打开一个文件用于读写。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文
件。
a+
打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。文件打开时
会是追加模式。如果该文件不存在，创建新文件用于读写。
rb+ 以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。
wb+
以二进制格式打开一个文件用于读写。如果该文件已存在则将其覆盖。如果该文件不存
在，创建新文件。
ab+ 以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结
尾。如果该文件不存在，创建新文件用于读写。
5.1.2 关闭文件
close( )
示例如下：
5.2 文件读写
5.2.1 写数据 (write)
使用 write() 可以完成向文件写入数据
demo:
# 新建一个文件，文件名为:test.txt
f = open('test.txt', 'w')
# 关闭这个文件
f.close()
注意：
如果文件不存在那么创建，如果存在那么就先清空，然后写入数据
5.2.2 读数据 (read)
使用 read(num) 可以从文件中读取数据，num 表示要从文件中读取的数据的长度（单位是字节），如果 没有传入 num，那么就表示读取文件中所有的数据
demo:
注意：
如果open是打开一个文件，那么可以不用写打开的模式，即只写 open('test.txt')
如果使用读了多次，那么后面读取的数据是从上次读完后的位置开始的
5.2.3 读数据（readlines）
就像 read 没有参数时一样，readlines 可以按照行的方式把整个文件中的内容进行一次性读取，并且返 回的是一个列表，其中每一行的数据为一个元素
f = open('test.txt', 'w')
f.write('hello world, i am here!')
f.close()
f = open('test.txt', 'r')
content = f.read( 5 )
print(content)
print("-"* 30 )
content = f.read()
print(content)
f.close()
#coding=utf- 8
f = open('test.txt', 'r')
content = f.readlines()
print(type(content))
i= 1
for temp in content:
print("%d:%s"%(i, temp))
i+= 1
5.2.4 读数据（readline）
5.3 文件的相关操作
有些时候，需要对文件进行重命名、删除等一些操作，python 的 os 模块中都有这么功能
5.3.1 文件重命名
os 模块中的 rename() 可以完成对文件的重命名操作
rename(需要修改的文件名, 新的文件名)
5.3.2 删除文件
os 模块中的 remove() 可以完成对文件的删除操作
remove(待删除的文件名)
5.3.3 创建文件夹
5.3.4 获取当前目录
f.close()
#coding=utf- 8
f = open('test.txt', 'r')
content = f.readline()
print(" 1 :%s"%content)
content = f.readline()
print(" 2 :%s"%content)
f.close()
import os
os.rename("毕业论文.txt", "毕业论文-最终版.txt")
import os
os.remove("毕业论文.txt")
import os
os.mkdir("张三")
5.3.5 改变默认目录
5.3.6 获取目录列表
5.3.7 删除文件夹
6. 错误与异常
6.1 异常简介
看如下示例:
运行结果:
说明:
打开一个不存在的文件123.txt，当找不到123.txt 文件时，就会抛出给我们一个IOError类型的错
误，No such file or directory：123.txt （没有123.txt这样的文件或目录）
import os
os.getcwd()
import os
os.chdir("../")
import os
os.listdir("./")
import os
os.rmdir("张三")
print '-----test-- 1 - --'
open(' 123 .txt','r')
print '-----test-- 2 - --'
异常:
当Python检测到一个错误时，解释器就无法继续执行了，反而出现了一些错误的提示，这就是所
谓的"异常"
6.2 捕获异常 try...except...
看如下示例:
说明:
此程序看不到任何错误，因为用except 捕获到了IOError异常，并添加了处理的方法
pass 表示实现了相应的实现，但什么也不做；如果把pass改为print语句，那么就会输出其他信息
小总结:
把可能出现问题的代码，放在try中
把处理异常的代码，放在except中
6.3 except 捕获多个异常
看如下示例:
想一想:
上例程序，已经使用except来捕获异常了，为什么还会看到错误的信息提示？
答:
except捕获的错误类型是IOError，而此时程序产生的异常为 NameError ，所以except没有生效
try:
print('-----test-- 1 - --')
open(' 123 .txt','r')
print('-----test-- 2 - --')
except IOError:
pass
try:
print num
except IOError:
print('产生错误了')
修改后的代码为:
实际开发中，捕获多个异常的方式，如下：
注意：**
当捕获多个异常时，可以把要捕获的异常的名字，放到except 后，并使用元组的方式仅进行存储
6.4 获取异常的信息描述
6.5 捕获所有异常
try:
print num
except NameError:
print('产生错误了')
#coding=utf- 8
try:
print('-----test-- 1 - --')
open(' 123 .txt','r') # 如果 123 .txt文件不存在，那么会产生 IOError 异常
print('-----test-- 2 - --')
print(num)# 如果num变量没有定义，那么会产生 NameError 异常
except (IOError,NameError):
#如果想通过一次except捕获到多个异常可以用一个元组的方式
6.6 try...finally...
try...finally... 语句用来表达这样的情况：
在程序中，如果一个段代码必须要执行，即无论异常是否产生都要执行，那么此时就需要使用
finally。 比如文件关闭，释放锁，把数据库连接返还给连接池等
demo:
说明:
test.txt文件中每一行数据打印，但是我有意在每打印一行之前用time.sleep方法暂停 2 秒钟。这样
做的原因是让程序运行得慢一些。在程序运行的时候，按Ctrl+c中断（取消）程序。
我们可以观察到KeyboardInterrupt异常被触发，程序退出。但是在程序退出之前，finally从句仍
然被执行，把文件关闭。
import time
try:
f = open('test.txt')
try:
while True:
content = f.readline()
if len(content) == 0 :
break
time.sleep( 2 )
print(content)
except:
#如果在读取文件的过程中，产生了异常，那么就会捕获到
#比如 按下了 ctrl+c
pass
finally:
f.close()
print('关闭文件')
except:
print("没有这个文件")
作业：
1. 应用文件操作的相关知识，通过Python新建一个文件gushi.txt，选择一首古诗写入文件中
2. 另外写一个函数，读取指定文件gushi.txt，将内容复制到copy.txt中，并在控制台输出“复制完
毕”。
3. 提示：分别定义两个函数，完成读文件和写文件的操作
尽可能完善代码，添加异常处理。
