python基础系列教程（1）——python基础语法全解

---

1.逻辑运算

---

1.1 算数运算符

运算符	描述	实例
+，-，*，/	加，减，乘，除	不做补充
//	取整数	返回除法的整数部分 9//2=4
%	取余数	9%2=1
**	幂	2**3=8

---

1.2 比较运算符

比较符	描述
== , !=	检查两边的变量是否相等，是就返回1，否就返回0
>, <	左边是否大于，小于右边，是就返回1，否就返回0
>=,<=	左边是否大于等于，小于等于右边，是就返回1，否就返回0

输入

print(2==2)
print(2==1)
print('A'=='a')
print(2!=2)
print(2!=1)
print('A'!='a')

输出

True
False
False
False
True
True

---

1.3 逻辑运算

• and 与/且

格式：

条件1 and 条件2

情况	结果
两个同时满足	返回True
有一个不满足	返回False
都不满足	返回False

• or 或

格式：

条件1 or 条件2

情况	结果
两个同时满足	返回True
有一个不满足	返回True
都不满足	返回False

• not 非
  格式：

not 条件

情况	结果
条件成立	返回False
条件不成立	返回True

逻辑运算演练：

# 输入数学和语文成绩，要求只要有一门成绩 > 60 分就算合格
yuwen_score = int(input('输入语文成绩：'))
math_score = int(input('输入数学成绩：'))

if yuwen_score > 60 or math_score > 60:
    print("考试通过")
else:
    print("再接再厉！")

---

1.4 赋值运算

运算符	描述
+=，-=，*=，、=	c += a 等效于 c = c + a
//=	c //= a 等效于 c = c // a
**=	c ** = a 等效于 c = c ** a

---

1.5. 随机数处理

先导入随机数模块

import random

• 导入模块后，可以直接在 模块名称 后面敲一个 . 然后按 Tab 键，会提示该模块中包含的所有函数

举例：

random.randint(12, 20)  # 生成的随机数n: 12 <= n <= 20   
random.randint(20, 20)  # 结果永远是 20   
random.randint(20, 10)  # 该语句是错误的，下限必须小于上限

---

2.条件语句

---

2.1 if、elif、else 判断语句

格式：

if 要判断的条件：
	成立的话要执行的语句
elif 要判断的条件：
	成立的话要执行的语句
else ：
	不满足以上条件时要执行的语句

输入：

age = int(input('请输入您的年龄：'))
if age>18:
    print('大于18岁，成年，可以进网吧')
elif age==18:
    print('等于18岁，成年，可以进网吧')
else:
    print('不准进网吧')

输出：

请输入您的年龄：1
不准进网吧

• if 嵌套练习

'''1.定义布尔型变量  has_ticket  表示是否有车票
2.定义整型变量  knife_length  表示刀的长度，单位：厘米
3.首先检查是否有车票，如果有，才允许进行 安检
4.安检时，需要检查刀的长度，判断是否超过 20 厘米◦如果超过 20 厘米，提示刀的长度，不允许上车
◦如果不超过 20 厘米，安检通过
5.如果没有车票，不允许进门'''

has_ticket =int(input('是否有车票？有填1没有填0：'))
if has_ticket== 1 :
    print('有车票，允许通行')
    knife_lenth = int(input('刀长度，单位：cm：'))
    if knife_lenth >= 20:
        print('刀长为 %d 不允许携带' % knife_lenth)
    else :
        print('安全通过')

else:
    print('没票不允许通行')

---

2.2.while 循环语句

用法：

while 条件（判断 变量是否满足条件）：
	条件1满足，做事情1
	条件2满足，做事情2
	......

输入：

i=1
while i<=5:
    print('这是第 %d 次输出' % i)
    i+=1

输出：

这是第 1 次输出
这是第 2 次输出
这是第 3 次输出
这是第 4 次输出
这是第 5 次输出

• while循环练习

'''
输出
*
**
***
****
*****
'''
i=1
while i<=5:
    print('*'*i)
    i+=1

'''
输出
*
**
***
****
*****
假设  Python  没有提供 字符串的  *  操作 拼接字符串
'''
i=1
while i<=5:
    j=1
    while j<=i:
        print('*',end='')
        j+=1
    print()
    i+=1

---

2.3 break,continue退出循环

• break 某一条件满足时，不再执行循环体中后续重复的代码，并退出循环
• continue 某一条件满足时，不再执行本次循环体中后续重复的代码，但进入下一次循环判断

输入

#break
i=1
sum=0
while i<=100:
    sum=i+sum
    i+=1
    if i == 50:
        break
print(sum)
#输出结果为1225

#continue
i=1
sum=0
while i<=100:
    sum=i+sum
    if i == 50:
        i += 1
        print(i)
        continue
    i+=1
print(sum)
#结果是 51 5050

---

2.4 for循环

for 变量 in 条件：
	如果为真就进行的操作

for i in range(1,5):
    print(i,end='')
    i+=1

输出：
1234

'''
一个学校，有3个办公室，现在有7位老师等待工位的分配，请编写程序，完成随机的分配，假设每个教室可以容纳任意数量的教师
'''
import random

list1=[[],[],[]]
teacher=['a','b','c','d','e','f','g']

for i in teacher:
    index=random.randint(0,2)
    list1[index].append(i)

print(list1)

输出：
[['e'], ['a', 'b', 'd'], ['c', 'f', 'g']]

---

3. 变量类型

---

3.1 列表

3.1.1列表定义

列表（list） 是 Python 中使用 最频繁 的数据类型，在其他语言中通常叫做 数组

• 列表专门用于存储 一串 信息
• 列表用 [] 定义，数据 之间使用 , 分隔
• 列表的索引从0开始
  • 索引 就是数据在 列表 中的位置编号，索引 又可以被称为 下标

list=[1,2,3,'haha']
print(list)
print(list[2])
print(type(list))

输出：
[1, 2, 3, 'haha']
3
<class 'list'>

3.1.2 列表常见操作-增加

a.增加元素

• 列表.insert(索引, 数据)：在指定位置插入一个值

list=[1,2,3,'haha']
print(list)
list.insert(0,'zz')
print(list)

输出：
[1, 2, 3, 'haha']
['zz', 1, 2, 3, 'haha']

• 列表.append(数据)：在末尾追加一个值，这个最常用

list=[1,2,3,'haha']
print(list)
list.append('zz')
print(list)

输出：
[1, 2, 3, 'haha']
[1, 2, 3, 'haha', 'zz']

• 列表.extend(Iterable)：将另一个列表（也可以）的全部内容追加到末尾

list1=[1,2,3,'haha']
list2=[4,5,6,'zz']
print(list1)
list1.extend(list2)
print(list1)

输出：
[1, 2, 3, 'haha']
[1, 2, 3, 'haha', 4, 5, 6, 'zz']

• append 和extend的差别
  使用 append 追加的是将后面的列表作为一个整体追加到最后了，而使用 extend 追加的是将里面的元素依次追加到最后。

list1=[1,2,3,'haha']
list2=[4,5,6,'zz']
print(list1)
list1.extend(list2)
print(list1)
list1.append(list2)
print(list1)

输出：
[1, 2, 3, 'haha']
[1, 2, 3, 'haha', 4, 5, 6, 'zz']
[1, 2, 3, 'haha', 4, 5, 6, 'zz', [4, 5, 6, 'zz']]

3.1.3 列表常见操作-删除

• del 列表[索引]：删除指定索引元素

list1=[1,2,3,'haha']
del list1[0]
print(list1)

输出：
[2, 3, 'haha']

• 列表.remove(数据)：直接删除列表里面的值，不需要知道位置。如果有多个值，只删除第一个

list1=[1,2,3,'haha',1]
list1.remove(1)
print(list1)

输出：
[2, 3, 'haha', 1]

• 列表.pop()：可指定索引删除，不指定会删除最后一个

list1=[1,2,3,'haha',1]
list1.pop(1)
print(list1)

输出：
[1, 3, 'haha', 1]

• 列表.clear：清空列表

list1=[1,2,3,'haha',1]
list1.clear()
print(list1)

输出：
[]

3.1.4 列表常见操作-修改

• 直接指定索引赋值，就是修改元素内容

list1=[1,2,3,'haha',1]
list1[1]='zz'
print(list1)

输出：
[1, 'zz', 3, 'haha', 1]

3.1.5 列表常见操作-查询

• 列表[索引]：根据索引获取（查询）值

list1=[1,2,3,'haha',1]
print(list1[0])

输出：
1

• 列表.index(数据)：查询给定值的索引，即想要知道元素的位置，如果查询元素有多个相同值只会返回第一个值出现的记录

list1=[1,2,3,'haha',1]
print(list1.index(1))

输出：
0

• 列表.count(数据)：查询值出现的次数

list1=[1,2,3,'haha',1]
print(list1.count(1))

输出：
2

• len(列表)：有多少个元素

list1=[1,2,3,'haha',1]
print(len(list1))

输出：
5

• if 数据 in 列表：判断元素是否在列表中，用作条件语句中

list1=[1,2,3,'haha',1]
if 1 in list1:
    print('包含1')
else:
    print('不包含1')

输出：
包含1

3.1.6 列表元素的排序

注意数字和字符串不能一起排序，会报错
sort（）升序
sort(reverse=True)降序

list1=[1,2,3,2,1]
list1.sort()
print(list1)
list1.sort(reverse=True)
print(list1)

输出：
[1, 1, 2, 2, 3]
[3, 2, 2, 1, 1]

• sort 方法还有一个参数，key，这个参数是传递函数方法名的，可以传入自定义的函数名或者是匿名函数

list=[5,7,9,0,4,'8']
#这里是使用 int 函数，意思是将里面可以转换为数字的字符串转换成数字来排序，如果转换不成功会报错，如‘8d’ 显示是不能转换为数字类型的
list.sort(key=int,reverse=True)
print(list)

输出：
[9, '8', 7, 5, 4, 0]

---

3.2 元祖

3.2.1元祖的定义

• Tuple（元组）与列表类似一个用 [] 一个用 () 定义，不同之处在于元组的元素不能修改
• 元组的索引从0开始

info_tuple = ("zhangsan", 18, 1.75)

3.2.1元祖的常见操作-查询

• 因为元组具有的不可修改的特性，所以没有 增加、删除、修改 的方法，只有查询功能

tuple=(1,2,'a',3)
print(tuple[2])

输出：
a

• 但是，如果元组中的元素如果为列表/字典时，则可以修改列表/字典中的元素的值

a = [1, 2]
b = (a, 3)
print(b)
a.append(3)
print(b)

输出：
([1, 2], 3) 
([1, 2, 3], 3)

• 元组中 只包含一个元素 时，需要 在元素后面添加逗号，不加就不是元组了

info_tuple = (50, )
print(type(info_tuple))

输出：
<class 'tuple'>

• count(),index(),len均可以在元祖中使用

3.2.1元祖和列表的转换

• 使用 list 函数可以把元组转换成列表

list(元组)

• 使用 tuple 函数可以把列表转换成元组

tuple(列表)

---

3.3字典

3.3.1字典的定义

• 字典用 {key:value，…} 定义
• 字典使用键值对(key、value对)存储数据，键值对之间使用,分隔◦键 key 是索引：注意索引不再是 0，1，2… 了，虽然可以用数字，但是一般使用字符串
• 值 value 是数据
• 键 和 值 之间使用 : 分隔
• 键必须是唯一的：如果有多个，后者会覆盖前者
• 值 可以取任何数据类型，但 键 只能使用 字符串、数字或 元组

xiaoming = {"name": "小明",
            "age": 18,
            "gender": True,
            "height": 1.75}

3.3.2字典的常见操作-增加

dict={'name':'zz','age':18}
print(dict)
#这里 weight 的键值对不存在就是新增，如果存在就是修改（后面有）
dict['weight']=100
print(dict)

输出：
{'name': 'zz', 'age': 18} {'name': 'frog', 'age': 18, 'weight': 100}

3.3.3 字典的常见操作-删除

• del 字典[键]

dict={
    'name':'zz',
    'age':18
}
print(dict)
#如果要删除的键不存在，会报错 KeyError: 'age1'
del dict['age']
print(dict)

输出
{'name': 'zz', 'age': 18}
{'name': 'zz'}

• 字典.pop(键)

dict={
    'name':'zz',
    'age':18
}
print(dict)
# 如果要删除的键不存在，会报错 KeyError: 'age1'
# 注意：pop 删除成功了会返回被删除的值
dict.pop('age')
print(dict)

输出：
{'name': 'zz', 'age': 18}
{'name': 'zz'}

• 字典.clear 删除整个字典里的值

dict={
    'name':'zz',
    'age':18
}
print(dict)
dict.clear()
print(dict)

输出：
{'name': 'zz', 'age': 18}
{}

3.3.4 字典的常见操作-修改

• 字典[键] = 数据

dict={
    'name':'zz',
    'age':18
}
print(dict)
dict['age']=20.1
print(dict)

输出：
{'name': 'zz', 'age': 18}
{'name': 'zz', 'age': 20.1}

• 字典.setdefault(键，数据)

dict={
    'name':'zz',
    'age':18
}
print(dict)
#如果存在就不做处理
dict.setdefault('sex','girl')
print(dict)

输出：
{'name': 'zz', 'age': 18}
{'name': 'zz', 'age': 18, 'sex': 'girl'}

• 字典.update(字典2)

dict={
    'name':'zz',
    'age':18
}
print(dict)
dict.update({'weight':100,'age':20.1})
print(dict)

输出：
{'name': 'zz', 'age': 18}
{'name': 'zz', 'age': 20.1, 'weight': 100}

3.3.5 字典的常见操作-查询

• 字典[键]：注意不能根据值来查询键

dict={
    'name':'zz',
    'age':18,
    'weight':100
}
print(dict['weight'])

输出：
100

• 字典.get(键)

dict={
    'name':'zz',
    'age':18,
    'weight':100
}
print(dict.get('name'))
# 键不存在不会报错，而是会返回 None
print(dict.get('nname'))
# 键不存在会返回后面设置的 默认值，可以根据返回的值来判断有没有获取成功
print(dict.get('nname','无'))
输出：
zz
None
无

3.3.6 字典的常见操作-遍历

• 字典.keys() 得到字典的 键
• 字典.values() 得到字典的 值
• 字典.items() 得到键值对，返回为元组

dict={
    'name':'zz',
    'age':18,
    'weight':100
}
print(dict.keys())
print(dict.values())
print(dict.items())
#注意上面三个都是视图对象的类型，可以使用 for 遍历，也可以转换为 list ，当然我们一般只需要遍历即可
print(list(dict.items()))

输出：
dict_keys(['name', 'age', 'weight'])
dict_values(['zz', 18, 100])
dict_items([('name', 'zz'), ('age', 18), ('weight', 100)])
[('name', 'zz'), ('age', 18), ('weight', 100)]

for i in dict.keys():
    print(i,end=' ')
print('遍历键')
for j in dict.values():
    print(j,end=' ')
print('遍历值')
# 对返回的元组遍历，然后解包获得 key、value
for i,j in dict.items():
    print(i)
    print(j)

输出：
name age weight 遍历键
zz 18 100 遍历值
name
zz
age
18
weight
100

---

3.4 字符串

3.4.1 字符串的定义

• 字符串 就是 一串字符，是编程语言中表示文本的数据类型
• 在 Python 中可以使用一对双引号"或者一对单引号’定义一个字符串
  ◾可以在前面加r,代表后面的不做转义字符输出
  ◾ 可以使用\"或者\'做字符串的转义
  ◾如果字符串内部需要使用 " ，可以使用 ’ 定义字符串
  ◾如果字符串内部需要使用 ’ ，可以使用 " 定义字符串
• 使用 索引 获取一个字符串中 指定位置的字符，索引计数从 0 开始
• 可以使用 for 循环遍历 字符串中每一个字符

string = "zzz"
for c in string:
    print(c)
输出：
z
z
z

3.4.2 字符串的常用操作-查询和替换

string = "hellozzz"
#根据索引查询值
print(string[0])
#根据值查询索引
print(string.index('z'))
#根据值查出现次数
print(string.count('z'))
#查询值的元素数量
print(len(string))

输出
h
5
3
8

方法	说明
string.find(str, start=0, end=len(string))	检测 str 是否包含在 string 中，如果 start 和 end 指定范围，则检查是否包含在指定范围内，如果是返回开始的索引值，否则返回 -1
string.rfind(str, start=0, end=len(string))	类似于 find()，不过是从右边开始查找
string.index(str, start=0, end=len(string))	跟 find() 方法类似，不过如果 str 不在 string 会报错
string.rindex(str, start=0, end=len(string))	类似于 index()，不过是从右边开始
string.replace(old_str, new_str, num=string.count(old))	返回一个新字符串，把 string 中的 old_str 替换成 new_str，如果 num 指定，则替换不超过 num 次

3.4.3 字符串的常用操作-判断

方法	说明
string.isalpha()	如果 string 至少有一个字符并且所有字符都是字母则返回 True
string.isdecimal()	如果 string 只包含数字则返回 True
string.islower()	如果 string 中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True
string.isupper()	如果 string 中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回 True
string.startswith(str)	检查字符串是否是以 str 开头，是则返回 True
string.startswith(str)	检查字符串是否是以 str 开头，是则返回 True
string.endswith(str)	检查字符串是否是以 str 结束，是则返回 True

3.4.4 字符串的常用操作-拆分连接

方法	说明
string.partition(str)	返回元组，把字符串 string 分成一个 3 元素的元组 (str前面, str, str后面)
string.rpartition(str)	类似于 partition() 方法，不过是从右边开始查找
string.split(str="", num)	返回列表，以 str 为分隔符拆分 string，如果 num 有指定值，则仅分隔 num + 1 个子字符串，str 默认包含 ‘\r’, ‘\t’, ‘\n’ 和空格
string.splitlines()	返回列表，按照行(’\r’, ‘\n’, ‘\r\n’)分隔
string1 + string2	拼接两个字符串
string.join(seq)	返回字符串，以 string 作为分隔符，将 seq 中所有的元素（的字符串表示）合并为一个新的字符串

3.4.5 字符串的常用操作-大小写转换

方法	说明
string.lower()	返回新字符串，转换 string 中所有大写字符为小写
string.upper()	返回新字符串，转换 string 中的小写字母为大写

3.4.6 字符串的常用操作-文本对齐

方法	说明
string.ljust(width)	返回新字符串，基于原字符串左对齐，并使用空格填充至长度 width
string.rjust(width)	返回新字符串，基于原字符串右对齐，并使用空格填充至长度 width
string.center(width)	返回新字符串，基于原字符串居中，并使用空格填充至长度 width

3.4.7 字符串的常用操作-去除空白符

方法	说明
string.lstrip()	返回新字符串，截掉 string 左边（开始）的空白字符
string.rstrip()	返回新字符串，截掉 string 右边（末尾）的空白字符
string.strip()	返回新字符串，截掉 string 左右两边的空白字符

3.4.8字符串的切片

• 切片 译自英文单词 slice ，翻译成另一个解释更好理解: 一部分
• 切片 使用 索引值 来限定范围，根据 步长 从原序列中 取出一部分 元素组成新序列
• 切片 方法适用于 字符串、列表、元组

字符串[开始索引:结束索引:步长]

num_str = "0123456789"

# 1. 截取从 2 ~ 5 位置 的字符串
print(num_str[2:6])

# 2. 截取从 2 ~ `末尾` 的字符串
print(num_str[2:])

# 3. 截取从 `开始` ~ 5 位置 的字符串
print(num_str[:6])

# 4. 截取完整的字符串
print(num_str[:])

# 5. 从开始位置，每隔一个字符截取字符串
print(num_str[::2])

# 6. 从索引 1 开始，每隔一个取一个
print(num_str[1::2])

# 倒序切片
# -1 表示倒数第一个字符
print(num_str[-1])

# 7. 截取从 2 ~ `末尾 - 1` 的字符串
print(num_str[2:-1])

# 8. 截取字符串末尾两个字符
print(num_str[-2:])

# 9. 字符串的逆序（面试题）
print(num_str[::-1])

---

4.函数

---

4.1 函数基本使用

4.1.1 函数定义

def 函数名():

    函数封装的代码
    ……

• 函数，就是把 具有独立功能的代码块 组织为一个整体，在需要的时候 调用

• 函数的使用包含两个步骤：
  1.定义函数 —— 在函数中编写代码，实现功能
  2.调用函数 —— 执行编写的代码

• 函数的作用，在开发程序时，使用函数可以提高编写的效率以及代码的 重用

4.1.2 函数的调用

通过 函数名() 即可完成对函数的调用

4.1.3 第一个函数演练

name = input('输入名字：')
def say_haha():
    print(name+'hhhh1')
    print(name + 'hhhh2')
    print(name + 'hhhh3')
say_haha()

输出：
输入名字：zz
zzhhhh1
zzhhhh2
zzhhhh3

---

4.2函数的参数

• 在函数名的后面的小括号内部填写 参数
• 多个参数之间使用 , 分隔

4.2.1参数作用

• 函数的参数，增加函数的通用性，针对相同的数据处理逻辑，能够适应更多的数据
  1.在函数 内部，把参数当做 变量 使用，进行需要的数据处理
  2.函数调用时，按照函数定义的参数顺序，把 希望在函数内部处理的数据，通过参数 传递

4.2.2 形参实参

• 形参：定义 函数时，小括号中的参数，是给真实数据占位用的，在函数内部 作为变量使用
• 实参：调用 函数时，小括号中的参数，是传递到 函数内部 的 真实数据

形参作用域

a = 5  

def test1(a): 
    # 这里 a 是形参，是在函数内部定义的，作用域只在函数内部
    a += 1
    print("%d" % a)

test1(2)  
# 这里因为形参的作用域不到这里，所以这个 a 是外面的 a
print("%d" % a)

• 形参的作用域(起作用的范围) 只在定义函数的代码块 中，一旦超出该范围就不存在了，如果强行使用该形参名，则使用的是 同名的自定义变量，如果此时外面没有a 就报错了
• 因为形参的作用域只在本函数的内部，所以不同函数的形参可以是同名
• 编程中应该尽量避免 函数的形参 和 同文件的变量名 同名

4.2.3 默认参数

• 形参设定默认值 称为 默认参数
• 调用函数时，如果没有传入默认参数对应的实参，则实参使用默认值。
• 默认参数一定要位于参数列表的最后面

def func(name,age=18):
    print('name is %s' % name ,end=' ,')
    print('age is %s' % age)
func("zz")
func('zz',20)

输出：
name is zz ,age is 18
name is zz ,age is 20

4.2.4 关键字参数

• 调用函数时，实参可以指定对应的形参，称为 关键字参数
• 一旦给实参设置了关键字参数，则所有实参都要设置为关键字参数

def func(name,age):
    print('name is %s' % name ,end=' ,')
    print('age is %s' % age)
func(age=18,name="zz")
输出：
name is zz ,age is 18

4.2.5 元祖可变参数 args

• 函数可以定义 可变参数，用于接收任意数量的参数
• 可变参数的前边需要添加，用于提示python解释器该参数为可变参数*
• 使用可变参数直接用args即可（不需要加*）
• 可变参数的本质是 将传递的参数包装成了元组

def func(i,j,*args):
    sum=i+j
    for a in args:
        sum+=a
    print('和为 %s' % sum)
    
func(1,2,3,4,5)

输出：
和为15

4.2.6 字典可变参数 kwargs

• 可以接收不存在的关键字参数
• 定义参数时需要在变量名前添加两个*
• 这种可变参数会将 不存在的关键字参数包装成字典
• 字典可变参数必须放在形参最后面

def func(i,j,*args,**kwargs):
    sum=i+j
    for a in args:
        sum+=a
    print('和为 %s' % sum)
    print(kwargs)
func(1,2,3,4,5,a='你好',b=6)
输出：
{'a': '你好', 'b': 6}

---

4.3 函数的变量

4.3.1局部变量

• 局部变量，就是在 函数内部定义的变量
• 不同函数，可以定义相同的名字的局部变量，但是各用个的不会产生影响
• 局部变量的作用域只在函数内部
• 局部变量的目的是 存储需要临时保存的数据
  以下两个函数都有a变量，因为是局部变量所以不互相影响

def test1():
    a = 10
    print("%d" % a)


def test2():
    a = 5
    print("%d" % a)

test1()
test2()
输出：
10
5

4.3.2 全局变量

• 在函数外边定义的变量叫做 全局变量
• 全局变量能够在所有的函数中进行访问

a = 100

def test1():
    print(a)

def test2():
    print(a)


# 调用函数
test1()
test2()

输出：
5
5

4.3.3函数内修改全局变量

• 函数内赋值变量 时，默认为定义并赋值局部变量，赋值后获取的也是局部变量的值
• 如果在函数中修改全局变量，那么就需要使用 global 进行声明，否则出错

a = 10

def test():
    global a
    a = 5  # 修改全局变量
    print("函数内a：%d" %a)

test()
print("函数外a：%d" %a)

输出：
函数内a：5
函数外a：5

---

4.4 函数的返回值

4.4.1 返回值

• 在程序开发中，有时候，会希望 一个函数执行结束后，告诉调用者一个结果，以便调用者针对具体的结果做后续的处理
• 返回值 是函数 完成工作后，最后 给调用者的 一个结果
• 在函数中使用 return 关键字可以返回结果
• 调用函数一方，可以 使用变量 来 接收 函数的返回结果，也可以不接收只调用。注意没有返回值，也有返回值，是 None

def sum_2_num(num1, num2):
    """对两个数字的求和"""

    return num1 + num2

# 调用函数，并使用 result 变量接收计算结果
result = sum_2_num(10, 20)

print("计算结果是 %d" % result)

4.4.2 多个返回值

def func2():
return 1, 1.5

a = func2()
print(a)

a, b = func2()
print(a)
print(b)

输出：
(1, 1.5)
1
1.5

4.4.3 return

• return 后面可以不跟值

def func_sum():
    """求和 1+2"""
    sum_num = 1 + 2
    print(sum_num)
    return

• 函数中代码执行到 return 时，会终止函数的执行，返回到函数调用的代码处。所以可以利用 return 结束程序

def func_sum():
    """求和 1+2"""
    sum_num = 1 + 2
    print(sum_num)

    return
    # 这行代码不会执行了
    print('不会执行这行代码')

res=func_sum()
print(res)

4.4.4 多个return

def is_even_num(num):
    """判断奇偶数"""
    if num % 2 == 0:
        return True
    else:
        return False

• 一个函数中可以有多个return语句，但是只要有一个return语句被执行，那么这个函数就会结束

---

4.5 匿名函数lambda

4.5.1 定义

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

简单应用：

a= lambda i,j:i+j
print(a(1,2))
输出：
3

• Lambda函数能接收任何数量的参数但只能返回一个表达式的值

• 匿名函数不能直接调用print，因为lambda需要一个表达式

4.5.2使用场景

使用参数的匿名函数

• 定义一个函数

def fun(a, b, opt):
     print("a = %s" % a)
     print("b = %s" % b)
     print("result =%s" % opt(a, b))

# 调用函数
fun(1, 2, lambda x,y:x+y)
输出：
a = 1 b = 2 result = 3

• 将字典按照指定数据排序

stus = [
    {"name": "zhangsan", "age": 18}, 
    {"name": "lisi", "age": 19}, 
    {"name": "wangwu", "age": 17}
]
#按照name排序
stus.sort(key = lambda x: x['name'])
print(stus)
输出：
[{'age': 19, 'name': 'lisi'}, {'age': 17, 'name': 'wangwu'}, {'age': 18, 'name': 'zhangsan'}]

• 快速构造列表

list2 =(lambda n:[i**2 for i in range(1,n+1)])(2)
print(list2)
输出
[1, 4]

---

5.模块使用

---

5.1 模块定义

• 模块 就好比是 工具包，要想使用这个工具包中的工具，就需要 导入 import 这个模块
• 每一个以扩展名 py 结尾的 Python 源代码文件都是一个 模块
• 在模块中定义的 全局变量 、 函数 都是模块能够提供给外界直接使用的工具

1.新建 info.py，代码如下

name = "datafrog"
def func():
    print('info_func')

2.再新建 get_info.py 文件，并且编写以下代码：

import info
print(info.name)
info.func()

第一步是新建一个自定义的模块
第二步实现了模块的调用

5.2 自定义模块名称规范

• 可以由 字母、下划线 和 数字 组成
• 不能以数字开头
• 不能与关键字重名

---

6.列表推导式

---

6.1基本方法

格式：

[计算式 for 循环]

输出固定步长的整数

a=[x for x in range(4)]
b=[x for x in range(1,7)]
c=[x for x in range(1,7,2)]

print(a)
print(b)
print(c)

输出：
[0, 1, 2, 3]
[1, 2, 3, 4, 5, 6]
[1, 3, 5]

6.2 for+if的使用

a=[x for x in range(1,7) if x%2==0]
b=[x for x in range(1,7) if x%2!=0]
c=[x for x in range(1,7,2)]

print(a)
print(b)
print(c)
输出：
[2, 4, 6] [1, 3, 5] [1, 3, 5]

6.3 生成二维列表

a=[(x,y) for x in range(1,4) for y in range(3,6)]
print(a)
输出
[(1, 3), (1, 4), (1, 5), (2, 3), (2, 4), (2, 5), (3, 3), (3, 4), (3, 5)]