Python 快速入门学习

• 1. python的基本语法
• 1.1 变量
• 1.12 如何定义变量
• 1.13 输出一个变量
• 1.14 变量的数据类型
• 1.15 变量的运算
• 1.16 变量的输入
• 1.17 变量的类型转换
• 1.18 变量的格式化输出
• 2. 逻辑判断（分支结构）
• 2.1 单个分支结构
• 2.2 多个分支结构
• 2.3 逻辑运算符
• 2.31 and 用法
• 2.32 or 用法
• 2.33 not 用法
• 2.4 逻辑嵌套
• 3. 循环
• 3.1 循环的定义
• 3.2 while 循环的语法
• 3.21 while 循环实现累加
• 3.22 while 里面的 break 用法
• 3.23 while 里面的 continue 用法
• 3.3 循环嵌套
• 4. 容器
• 4.1 字符串
• 4.11 字符串的概念
• 4.12 字符串通过下标访问对应的元素
• 4.13 字符串的遍历
• 4.14 字符串的常用API
• 4.141 字符串的替换
• 4.142 字符串的查找
• 4.143 字符串的切片
• 扩展 判断字符串是否是数字
• 扩展 判断字符串是否为字母
• 4.2 列表
• 4.21 列表和数组的区别
• 4.22 列表添加元素
• 4.23 列表删除元素
• 4.24 列表查找元素的下标
• 4.25 列表修改元素
• 4.26 列表的排序
• 5. 元组
• 5.11 元组的定义
• 5.12 元组的应用
• 5.13 元组不支持 增，删，改
• 5.14 元组的遍历
• 5.15 元组的查询
• 6. 字典
• 6.1 字典的概念
• 6.2 字典的定义
• 6.3 字典添加元素
• 6.4 字典的元素修改
• 6.5 字典的查询
• 6.6 字典的遍历
• 6.61 取所有的键和值
• 6.62 取所有的键
• 6.63 取所有的值
• 6.64 嵌套字典
• 7. 函数
• 7.1 函数的概念
• 7.2 函数的作用
• 7.4 函数的定义
• 7.5 函数的调用
• 7.6 函数的参数
• 7.61 单个参数
• 7.62 多个参数
• 7.63 参数的总结
• 7.7 函数的返回值 return
• 7.71 单个返回值
• 7.72 多个返回值
• 扩展 函数与返回值的应用场景
• 7.8 函数中的默认参数
• 7.9 函数的关键字参数
• 7.10 函数的可变参数
• 7.11 成员变量和局部变量
• 7.12 成员变量（全局变量）
• 7.13 局部变量
• 7.14 申明成员变量（全局变量）

1. python的基本语法

1.1 变量

变量：内存中存储空间的一个表示

1.12 如何定义变量

例如：
a = 5
b = “你好”

1.13 输出一个变量

print(a)
print(b)

\t表示缩进，相当于按Tab的效果（4个空格）,\n表示换行

1.14 变量的数据类型

整数 int 
浮点型 float 
字符串 str 字符串可以使用单引号，双引号，3个双引号定义 
布尔 bool

=表示赋值，==表示判断是否相等
例如：

a = 5       #整形
b = "你好"       #字符串
c = 5.20          #浮点型
d = True         #布尔类型

print("a的数据类型是：",type(a))
print("b的数据类型是：",type(b))
print("c的数据类型是：",type(c)) 
print("d的数据类型是：",type(d))

1.15 变量的运算

1，字符串可以和字符串做加法运算

s1 = "12" 
s2 = "3"
s = s1 + s2
print("结果是：",s)
#结果是：123

2，字符串可以和整形做乘法运算

s = "好好学习\t" 
n = 10 
jieguo = s * n 
print("结果是："jieguo)
#结果是：好好学习	好好学习	好好学习	好好学习	好好学习	好好学习	好好学习	好好学习	好好学习	好好学习

3，数值型可以和数值型做所有的算数运算

n1 = 7 
n2 = 3 
j1 = n1 + n2 
j2 = n1 - n2 
j3 = n1 * n2 
j4 = n1 / n2 
j5 = n1 % n2
j6 = n1 // n2 
j7 = n1 ** n2 
print("n1和n2相加的结果为：",j1) 
print("n1和n2相减的结果为：",j2) 
print("n1和n2相乘的结果为：",j3) 
print("n1和n2相除的结果为：",j4) 
print("n1和n2求余数的结果为：",j5)
print("n1和n2取整结果为：",j6) 
print("n1和n2求幂的结果为：",j7)

#结果：
n1和n2相加的结果为： 10
n1和n2相减的结果为： 4
n1和n2相乘的结果为： 21
n1和n2相除的结果为： 2.3333333333333335
n1和n2求余数的结果为： 1
n1和n2取整结果为： 2
n1和n2求幂的结果为： 343

1.16 变量的输入

s = input("请在控制台输入一个东西：") 

print(type(s))      #不管输入的什么类型，默认都是字符串类型 

print("输入的这个变量是：",s)

1.17 变量的类型转换

n = int(str) #将字符串类型转换为整数类型 
f = float(str) #将字符串类型转换为小数类型

 # 实现一个2个数的加法计算器 
 n1 = input("请输入第一个数：")
 n2 = input("请输入第二个数：") 
 print('n1的类型是：',type(n1)) 
 num1 = int(n1)    #将n1转换为整形
 num2 = int(n2) 
 print('num1的类型是：',type(num1)) 
 result = num1 + num2 print("相加的结果为：",result)

例如：

小明去超市购物： 价格如下：口罩：3.5一个 荔枝：12元一斤 猪肉 ：26元一斤 小明购买了3个口罩，2斤荔枝，半斤猪肉。
结账的时候，老板宣布所有商品全部打8折。请编写程序计算最终 的应付款 :

kouzhao = 3.5 #定义一个口罩，单价是3.5一个 
lizhi = 12 #定义荔枝，12元一斤 
zhurou = 26 #定义猪肉，26一斤 
money = kouzhao * 3 + lizhi * 2 + zhurou * 0.5 
print("应付金额为：",money) 
shiji = money * 0.8 print("实际应付金额为：",shiji)

1.18 变量的格式化输出

%s 表示字符串
%d表示整形
%f 表示小数

%s格式化输出
s = “我的名字叫%s,今天：%d岁，身高%.2f” % (name,age,height)

例如：# 1,定义姓名，年龄，身高这3个变量，采用格式化输出 这样一句话“我的名字叫xx，今年xx岁，有xx米高” 
# xx为变量值

#%s格式化输出 
s = "我的名字叫%s,今天：%d岁，身高%.2f" % (name,age,height)

#format格式化输出
s = “我的名字叫{},今天：{}岁，身高{:.1f}”.format(name,age,height)

#format格式化输出 
s = "我的名字叫{},今天：{}岁，身高{:.1f}".format(name,age,height)

2. 逻辑判断（分支结构）

2.1 单个分支结构

if 表示如果
else 表示否则

例如：如果分数超过60分，那么就及格了，如果分数低于60分，那么就不及格
score = int(input("请输入你的成绩：")) 
if score >= 60: 
	print("及格") 
else:
	print("不及格")

2.2 多个分支结构

elif 表示不满足if里面的条件的前提下判断是否满足当前这个条件

例如：如果分数超过60分，那么就及格了，如果分数低于60分，如果分数超过80分，输出优秀，那么就不及
格
score = int(input("请输入你的成绩：")) 
if score >= 80: 
	print("优秀") 
elif score >= 60:     #只有当分数低于80分的时候，程序才会判断这个条件 
	print("及格") 
else:
	print("不及格")

2.3 逻辑运算符

and 表示并且 
or 表示或者 
not/！ 表示取反

2.31 and 用法

例如：如果语法成绩和数学成绩全部大于60分，输出批准毕业，如果有一门低于60分，都输出不能毕业
yuwen = int(input("请输入语文成绩：")) 
shuxue = int(input("请输入数学成绩：")) 
if yuwen >= 60 and shuxue >= 60: 
	print("可以毕业") 
else:
	print("不能毕业")

2.32 or 用法

例如：如果语文和数学有一门是满分，就可以毕业，否则就不能毕业
yuwen = int(input("请输入语文成绩：")) 
shuxue = int(input("请输入数学成绩：")) 
if yuwen == 100 or shuxue == 100: 
	print("可以毕业") 
else:
	print("不能毕业")

2.33 not 用法

例如：如果语文成绩不低于60分或者数学成绩不低于60分就可以毕业
yuwen = int(input("请输入语文成绩：")) 
shuxue = int(input("请输入数学成绩：")) 
if not(yuwen < 60) or not(shuxue < 60): 
	print("可以毕业") 
else:
	print("不能毕业")

2.4 逻辑嵌套

在if的里面或者在else的里面继续判断

例如：
username = input("请输入用户名：") 
password = input("请输入密码：") 
if username == "admin":#表示用户名输入正确 
		if password == "123": 
				print("登录成功") 
		else:
				print("密码错误") 
else:#表示用户名输入错误 
		if password == "123": 
				print("用户名错误，密码正确") 
		else:
				print("用户名和密码都错误")

例2：逻辑判断练习题：
小明去超市购物：
价格如下：口罩：3.5一个 荔枝：12元一斤 猪肉 ：26元一斤
小明购买了x个口罩，y斤荔枝，z斤猪肉。结账的时候，老板说有会员的用户如果商品金额大于200元打
六折，金额不足200元也可以打8折。没有会员的用户，金额大于200块，打9折，不足200块，不打折原
价支付。
程序：
输入：是否是会员，购买金额
输出：最终的实际支付金额

n1 = int(input("口罩要几个：")) 
n2 = float(input("荔枝来几斤：")) 
n3 = float(input("猪肉来几斤：")) 

kouzhao = 3.5 #定义一个口罩，单价是3.5一个 
lizhi = 12 #定义荔枝，12元一斤 
zhurou = 26 #定义猪肉，26一斤 

money = kouzhao * n1 + lizhi * n2 + zhurou * n3 
print("购物金额是：{}元".format(money)) 

vip = input("请问是会员吗？（Y/N）") 
if vip == "Y": #是会员 
		if money >= 200: 
				m = money * 0.6   #是会员并且购买金额超过200  打6折
		else:
				m = money * 0.8   #是会员并且购买金额不超过200  打8折
else: #不是会员 
		if money >= 200: 
				m = money * 0.9 
			
print("实际付款{}元".format(m))

3. 循环

3.1 循环的定义

重复的去执行一行或者多行代码

3.2 while 循环的语法

i = 1
while i < 5:
	 print("好好学习") 
	 i = i+1 #加法的运算优先级高于=号，所以i = i + 1，先将i+1的值赋值给i本身 
print("结束了")

#结果：
好好学习
好好学习
好好学习
好好学习
结束了

3.21 while 循环实现累加

在while循环的里面放多行代码 
i = 6 
#再定义一个变量，这个变量的作用就是存钱罐（容器） 
sum = 0 
while i <= 13: 
		sum = sum + i 
		i += 1 
print("整数之和为：{}".format(sum))

#结果：
整数之和为：76

例2：
 假设黄金的日涨幅为0.8%（只涨不跌），现在买了1万块的黄金，问经过多少天，本金可以变成10万。
day = 0 
money = 10000  
while money <= 100000: 
		money = money * 0.008 + money 
		day += 1 
print("需要{}天，达到10万".format(day)) 

#结果：
需要289天，达到10万

3.22 while 里面的 break 用法

break 表示跳出循环，不管是否满足循环条件，只要碰到break循环就会终止

i = 1 
while i <= 10:
		 if i == 3: 
		 break 
		 print("好好学习") 
		 i += 1 
print("循环结束了") 

#输出结果为：2次好好学习

# 练习题：
循环输入整数，按q退出。循环结束后可以将所有整数相乘并输出结果
result = 1 
while True: 
		n = int(input("请输入整数：")) 
		result *= n 
		s = input("按任意键继续（q退出）：")
		if s == "q": 
		 		print("循环结束！") 
		 		break 
print("乘积为：{}".format(result))

3.23 while 里面的 continue 用法

continue 表示跳过当前这次循环，来到下一次循环

#实现1到5之间的所有整数之和 
i = 1 sum = 0 
while i <= 5:
	 if i == 3: 
	 	i += 1 
	 	continue #3不会累加 
	 else:
	 	sum += i 
	 	i += 1 
print("1到5之间的所有整数之和为：{}".format(sum))

3.3 循环嵌套

在循环的里面嵌套一个循环

#九九乘法表就是一个很好的嵌套循环例子
i = 1
while i <= 9:
    j = 1
    while j <= i:
        print("{}x{}={}".format(j,i,i*j), end=" \t")
        j +=1
    print()
    i +=1

#结果：
1x1=1 	
1x2=2 	2x2=4 	
1x3=3 	2x3=6 	3x3=9 	
1x4=4 	2x4=8 	3x4=12 	4x4=16 	
1x5=5 	2x5=10 	3x5=15 	4x5=20 	5x5=25 	
1x6=6 	2x6=12 	3x6=18 	4x6=24 	5x6=30 	6x6=36 	
1x7=7 	2x7=14 	3x7=21 	4x7=28 	5x7=35 	6x7=42 	7x7=49 	
1x8=8 	2x8=16 	3x8=24 	4x8=32 	5x8=40 	6x8=48 	7x8=56 	8x8=64 	
1x9=9 	2x9=18 	3x9=27 	4x9=36 	5x9=45 	6x9=54 	7x9=63 	8x9=72 	9x9=81 

4. 容器

字符串的之类是str，列表的类型是list，元组的类型是tuple，字典的类型是dict，set集合的类型是set

4.1 字符串

4.11 字符串的概念

字符串可以由单引号，双引号，3个双引号定义。字符串是一个序列化容器。
序列化指的是元素连续排列，有 下标，支持索引和切片。
非序列化没有下标，不支持索引和切片

4.12 字符串通过下标访问对应的元素

下标都是从0开始！！！

s = "好好学习" 
s1 = s[0] #如果下标不存在，会报索引越界异常 
s2 = s[1] 
print(s1) 
print(s2)

4.13 字符串的遍历

c = len(s) 
print("字符串的长度为：{}".format(c)) 
str = "好好学习,拒当备胎" 
print("while循环遍历的结果为:") 
i = 0 
while i < 9: 
		print(str[i],end=" ") 
		i += 1 

##for循环遍历
print("\nfor循环遍历的结果为：") 
for s in str:
	 print(s,end=" ")

输入一个字符串：明天会更好。逆序输出，输出的是好更会天明
str = input("请输入一句话：") 
i= len(str)-1             #利用while循环 算出总长度 再倒序输出
while i >= 0: 
	print(str[i],end=" ")
	i -= 1

4.14 字符串的常用API

4.141 字符串的替换

str = "一存光阴一存金，存金难买存光阴"
str2 = str.replace("存","寸",2) #有3个参数，第一个参数是旧元素，第二个参数是新元素，第三个 参数是替换的数量 
print(str2)

4.142 字符串的查找

str = "一存光阴一存金，存金难买存光阴" 
index = str.find("光") #当要查找的元素不存在的时候，不会报错，只是会返回-1 

index2 = str.rfind("光")              #rfind逆序查找
print("最左边的光的下标为：",index) 
print("最右边的光的下标为：",index2)

4.143 字符串的切片

str = "www.7k7k.com" 
s1 = str[:3] #字符串切片，包头不包尾,切出www 
s2 = str[4:8] #切出7k7k 
s3 = str[9:] #切出com 

str = "www.7k7k12345678987654321.com" 
#切出com 
s = str[-3:] #从右往左 
print(s)

例如：编写一个文件检测的脚本：规定后缀名为py或者是java的文件可以通过检测。
其他后缀名的文件不能通过检测。满足条件输出检测通过，不满足条件就输出未通过检测

while True: 
	text = input("请输入文件名：") 
	index = text.rfind(".") #查找文件名中最后一个小数点的下标
	if index != -1 and index > 0:
		 houzhui = text[index+1:] 
		 print("后缀名是：",houzhui) 
		 if houzhui == "py" or houzhui == "java":
		 	 print("通过检测") 
		 else:
		 	 print("未通过检测") 
	 else:
	 	 print("没有后缀或者文件名为空，请重新输入!")

扩展 判断字符串是否是数字

str = "12o3" 
b = str.isnumeric() #如果字符串中所有的字符都为阿拉伯数字，返回True 
print(b)

扩展 判断字符串是否为字母

str = "Aabc" 
b = str.isalpha() #当字符串中只有纯字母的时候返回True 
print(b)

运用：
用户名格式校验：要求用户名不能全部是字母，用户名不能全部是数字，用户名不能含有除字母和数字
以外的符号，也就是说用户名必须是字母和数字的组合（要用所学过的方法编码）
用户名符合条件即输出注册成功，否则输出用户名不符合格式要求

while True:
username = input("请输入用户名：") 
 
zm = 0        #定义一个统计字母个数的变量
sz = 0       #定义一个统计字母个数的变量

for u in username:
	 if u.isalpha() == True: #说明该字符是字母 
		 zm += 1 
	 elif u.isnumeric() == True:#说明该字符是数字 
	 	sz += 1 
	 	
	if zm + sz == len(username) and username.isalpha() == False and username.isnumeric() == False:
	 	 print("用户名符合格式要求") 
	else:
	  	 print("不符合")
 

4.2 列表

4.21 列表和数组的区别

python中的列表跟java里面的数组非常类似，但是也有区别：
1，python中的列表长度可以变的
2，python的中的列表可以存放不同数据类型的数据

list = [3,"你好",9,"张三"] #可以存放不同的数据类型 
print(list)

4.22 列表添加元素

list = [3,"你好",9,"张三"] 
list.append(6) #列表的长度可以变，可以直接向列表中添加元素 
print(list)

4.23 列表删除元素

list = [3,"你好",9,"张三"] 
list.remove("你好") #remove表示根据元素去删除 
print(list)

list = [3,"你好",9,"张三"] 
list.pop(3) #pop表示根据下标去删除 
print(list)

4.24 列表查找元素的下标

list = [3,6,1,9] 
xiabiao = list.index(6) 
print("6的下标是：{}",xiabiao)

4.25 列表修改元素

list = [3,6,1,9] 
xiabiao = list.index(6) 
print("6的下标是：{}",xiabiao) 

#将列表中的6替换为66 
list[xiabiao] = 66 #根据下标去修改元素 
print("修改后的列表为：",list)

4.26 列表的排序

list = [3,6,1,9,5,7] 
list.sort() #列表中排序的方法,默认是从小到大 
print("排序后：",list)

#结果是
1，3，5，6，7，9

list = [3,6,1,9,5,7] 
list.sort(reverse=True) #列表中排序的方法，从大到小 
print("排序后：",list)

#结果是
9，7，6，5，3，1

5. 元组

列表支持增删改查所有操作，元组只支持查询操作，不支持修改，删除，添加
元组的好处：1，防止误操作而引起的数据变动。2，节省内存空间。
元组是一个序列化容器，支持索引和切片

5.11 元组的定义

names = ("张三","李四","王五")
 如果元组只有一个元素，那么末尾一定要加逗号。如果没有加逗号，那么数据类型就是str。 
 names = ("张三",) 
 print(type(names)) 

如果内元组只有一个元素，那么也要加上逗号 
nums = ((5,),) 
print(type(nums)) 

## for 嵌套循环遍历元组
for num in nums: 
	for n in num: 
		print(n,end=" ")

5.12 元组的应用

1，连接mysql数据库，查询数据的结果是元组类型
2，可变参数是通过元组存储参数的
3，多个返回值返回的结果是元组类型

5.13 元组不支持 增，删，改

元组是 没有增加，删除，更改的API  ！！！

5.14 元组的遍历

names = ("张三","李四","王五") 
for name in names: 
	 print(name,end=" ") 
	 
nums = ((3,5),(9,4),(6,1,2),7) #嵌套元组的遍历 
for num in nums: 
	if type(num) == tuple: 
		for n in num: 
			print(n,end=" ")
	else:
		print(num,end=" ")`

5.15 元组的查询

names = ("张三","李四","王五") 
n = names[1] #根据下标去查询指定的元素 
print(n) 

xiabiao = names.index("王五") #根据元素去查找对应的下标 
print(xiabiao)

6. 字典

6.1 字典的概念

字典是一个非序列化容器，不支持索引和切片。元素与元素通过逗号相隔，
把一个元素拆分成键和值。不是通 过下标去查询元素，而是通过键去查询值

6.2 字典的定义

student = {"姓名":"张三","性别":"女","年龄":19} #直接定义了一个带有3个元素的字典 
student2 = {}    #定义一个空字典

6.3 字典添加元素

stu = {} 
stu["name"] = "张三"       #向字典中添加了一个键值为 name  的 张三元素
print(stu)

6.4 字典的元素修改

student = {"姓名":"张三","性别":"女","年龄":19} 
student["年龄"] = 20 
print(student) 

student.update(年龄=30) #通过关键字修改

当一个键不存在的时候，就是添加。存在的时候值会覆盖上一次的值

6.5 字典的查询

#查询学生的姓名
name=student.get("姓名2") 
#根据键去查询值,当键不存在的时候，返回None 
print(name) 

#查询学生的姓名 
name = student["姓名2"] #根据键去查询值,当键不存在的时候，会报错 
print(name)

6.6 字典的遍历

6.61 取所有的键和值

phone = {"Logo":"华为","type":"P30","price":3999,"neicun":"8G"} 

for k,v in phone.items():    #字典的遍历方法
	print("{}:{}".format(k,v))

6.62 取所有的键

例如：
k = phone.keys() 
for kk in k: 
	print(kk)

6.63 取所有的值

例如：
v = phone.values() 
	for vv in v: 
		print(vv)

6.64 嵌套字典

dict = {“键1”:{“键1”:“值”，”键2"：“值2”}，“键2"：{“键1”:“值1”,“键2”:“值2”}}

嵌套字典的遍历

dict = {"键1":{"键1":"值1","键2":"值2"},"键2":{"键1":"值1","键2":"值2"}} 

for k,v in dict.items(): 
	print(k) 
	for kk,vv in v.items(): 
		print(kk,vv)

7. 函数

7.1 函数的概念

可以完成某个功能的一段代码，函数不调用不执行

7.2 函数的作用

1，提高代码的复用性
2，减少了项目的维护成本
3，多人开发，提高了开发效率

7.4 函数的定义

#函数名符合变量的命名规范 
#1，字母和数字和下划线,$的组合 
#2,变量的开头不能是数字 
#3，变量不能是关键字

例如：打印三角形的函数
def print_star():            #def关键字定义函数
	 """ 
	 打印三角形的函数 
 	入参：xx 
 	:return:null 
 	"""
 	 i = 1 
 	 while i <= 5: 
 	 	print("#" * i, end=" ") 
 	 	print() 
 	 	i += 1 

#调用函数 
print_star()

7.5 函数的调用

在当前文件中调用直接用函数名调用 
在其他文件中需要导包后调用 
from py_day02.人机猜拳 import * 
print_star

7.6 函数的参数

7.61 单个参数

#编写一个榨汁机的函数，这个函数可以榨果汁
def zzj():#函数没有参数意味着只能榨一种果汁 
	print("榨好了一杯西瓜汁") 
zzj() 


def zzj2(shuiguo):         #有参数后意味想喝什么果汁都可以 
	print("榨好了一杯{}汁".format(shuiguo)) 
	
while True:
	 sg = input("请问你想喝啥？") 
	 zzj2(sg)

7.62 多个参数

例如：
#完成2个任意之和 
def add2(num1,num2):
	 sum = num1 + num2 
	 print("结果是：{}".format(sum)) 

add2(3,4)

7.63 参数的总结

形参：在编写函数时定义的参数称之为是形参
实参：在调用函数的时候传入进去的参数称之为实参

形参和实参的关系：
1，形参和实参的个数必须要一样
2，形参和实参的数据类型必须要一样
3，形参和实参的位置顺序必须要一样

例如：
# 定义一个函数，要求：计算x到y之间所有的偶数之和。 

def sumOu(x,y): 
	sum = 0 
	i = x 
	while i <= y: 
		if i % 2 == 0: 
			sum += i 
		i += 1 
	print("偶数之和为：",sum) 

sumOu(2,7)   #调用函数并传入参数

7.7 函数的返回值 return

概念

后端工程师 -->编写接口，接口返回数据（JSON/xml） 
前端工程师 -->得到json数据解析，展示在网页上 一些常见的有返回值的函数：
比如 str = input("请输入：")#这里的str就是函数的返回值 

没有返回值的函数，有print语句的：只能打印在控制台，无法在其他地方使用函数加工后的成品 

有返回值的函数：调用函数的时候，可以得到该函数加工后的成品，至于我是打印还是传递到其他地方

7.71 单个返回值

例如：
# 实现2个数的相加函数 
def add(n1, n2): 
	sum = n1 + n2 
	return sum                     #返回sum的结果

result = add(3,7) 
print(result)

7.72 多个返回值

多个返回值需要用逗号隔开，调用多个返回值的函数会得到一个元组，
该元组中存储的就是函数的那多个返回值，遍历即可使用里面的返回值了

def computer(n1,n2):
	 sum = n1 + n2 
	 jian = n1 - n2 
	 return sum,jian     #返回sum跟jian的结果

j1 = computer(7,3) 
print(type(j1))      #多个返回值 是一个元组来存储
print(j1) 
for j in j1:      #利用for遍历出来
	print(j)

扩展 函数与返回值的应用场景

# 生成指定长度的验证码（由数字和大小写英文字母构成的随机字符串） 
# 就是说如果用户输入4，那么就生成一个4位数的随机验证码。 
# 用户输入5，就生成一个5位数的随机验证码... 
# 要求：编写函数完成。(返回验证码) 
import time 
def makeGode(length): 
	str = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz" 
	import random 
	i = 1 
	code = "" 
	while i <= length: 
		r = random.randint(0,len(str)-1)     #利用随机数生成下标并获取对应的下标的字符串内容
		code += str[r]                                  #获取对应下标的字符串内容
		i += 1 
	return code 

while True: 
	yanzhengma = makeGode(5) 
	print("得到的这个验证码是：{}".format(yanzhengma)) time.sleep(0.3)

7.8 函数中的默认参数

定义函数的时候，给参数一个默认值，那么调用函数不传入参数默认就是默认值
传了参数以我传入的参数为准。

def add(n1=100,n2=200):      #赋予形参默认参数数值 如果调用时不传入参数 则会使用默认参数数值
	sum = n1 + n2 
	return sum 

num = add(5,7) 
print(num)

7.9 函数的关键字参数

如果没有指定关键字参数，那么默认就是位置参数。位置参数要求参数的顺序一一对应
需要注意的一点：关键字参数只能在位置参数的后面

def add(n1,n2): 
	sum = n1 - n2 
	return sum 

num = add(n2=5,n1=7) #关键字参数。 
print(num)

7.10 函数的可变参数

调用函数的时候参数的个数可以变化，那么就要求在定义函数的时候，形参的个数不能写死。
要用*args来定义。args可以用其他名字命名。按规范最好使用args命名。args的数据类型是元组
案例：

# 实现所有参数的求和 
def func(*args):    #可变参数   可以传入多个参数 按照情况 需要传入几个就可以传入几个
	print(type(args)) 
	sum = 0 
	for a in args: 
		sum += a 
		return sum 

jieguo = func(6,7,3,4) 
print(jieguo)

7.11 成员变量和局部变量

7.12 成员变量（全局变量）

定义在函数或者方法的外面的变量称之为成员变量，可以在当前脚本中所有的函数或者方法中被使用

例如：
money = 500 #成员变量
 #可以从函数里面去修改成员变量的值，需要去引入一个关键字global去申明成员变量 
 
 def getMoney(): 
 	print("获得了{}元".format(money)) 

def setMoney(): 
	m = money - 200 
	return m 

getMoney() 
qian = setMoney() 
print("钱变成了{}元".format(qian))

7.13 局部变量

定义在函数或者方法的里面的变量称之为局部变量，只能在当前函数或者方法中被使用.参数也是当前函数的 局部变量

def getMoney(): 
	money = 500
	print("获得了{}元".format(money)) 

def setMoney(): 
	m = money - 200 #money报错，无法使用  因为money是函数getMoney中定义的局部变量此函数无法调用
	return m 

getMoney() 
qian = setMoney() 
print("钱变成了{}元".format(qian))

7.14 申明成员变量（全局变量）

想在函数的里面去使用这个成员变量，并且修改这个成员变量。
需要去引入一个关键字 global 去申明成员变量

例如：
money = 500 # 成员变量 
def getMoney(): 
	global money       #只有申明了  函数内部对money进行的操作才会同步更新到全局变量
	money -= 100         #money会减少
	print("函数里面的money:",money) 

getMoney() 
print("成员变量的money",money)