python——函数（2）

1、函数的返回值

1.1函数返回值概述

（1）一个函数，不管是否有return，他都是有返回值的，如果没有return，它的返回值是None。

（2）如果有return，函数的返回值是return后面的内容，切记：return后面的代码是不能够执行的。

（3）函数返回值的价值是：把函数与函数能够建立一层关联关系。

（4）用代码来处理动态参数可以用函数的返回值。

1.2函数返回值实例

#用函数返回值可以实现用代码解决动态参数问题。如以登录为例，可以结合接口测试的session流程来理解。
#定义一个登录的函数，返回其sessionId.
def login(username="qy",password="123456"):
	if username=="qy" and password=="123456":
		return "adefcade123"
	else:
		return "用户名或密码错误！"
#定义一个查看个人主页的函数，调用登录返回的sessionId。
def profile(sessionId):
	if sessionId=="adefcade123":
		print("欢迎访问主页！")
	else:
		print("请登录")

profile(sessionId=login())

2、内部函数

2.1定义

内部函数就是内部已经实现的函数，我们直接调用即可。

2.2常用内部函数

2.2.1数字与字母转换

2.2.1.1数字转字母：chr

# #数字转字母：chr,必须转97以上的，因为a就是97。
print(chr(98))

2.2.1.2字母转数字：ord

# #字母转数字:ord
 print(ord("c"))

 

2.2.2输出某个范围数字：range

#结合循环输出某个范围内的数字，包含开始不包含结尾：range（start， end， scan):,scan就是步长，默认为1.
for a in range(1,9):
	print(a)

for b in range(1,9,2):   #步长为2
	c=(str(b))   #把输出的数据转换为字符串
	print(list(c))   #把字符串转换为列表

2.2.3输出某个范围内的随机数字：random

2.2.3.1实例1

# 输出某个范围的随机数字：random.randint(a,b)，随机输出a到b范围内的数字，包含a但不包含b
import random
print(random.randint(1,100))

2.2.3.2验证码的实现

（1）随机4为字母的验证码

#随机输出一个4位数验证码
import random
list1=[]
for a in range(4):  #仅仅是为了实现循环4次。
	r=random.randint(97,120)  #循环4次，每次取97到120范围内的某个数字。
	list1.append(chr(r))  #将每次循环得到的数字转换为字母，添加到列表中。
print("".join(list1))  #将列表转换为字符串输出。

（2）随机6位数字的验证码

#随机输出一个6位数数字验证码
import random
list1=[]
for a in range(6):
	r=random.randint(1,7)
	list1.append(r)
#由于，这里输出的列表中的元素数据类型不是字符串，因此我们需要把元素类型转换为字符串。
b=map(str,list1)  #通过借用map(函数名称，可以被循环的对象）将列表中的元素类型转化为字符串类型,其中str为字符串函数，list1为可以被循环的对象。
c="".join(b)  #将列表转换为字符串
print(c)

2.2.4把字符串转化为表达式：eval

#把字符串转化为表达式：eval
a="5+5"
print(eval(a))

2.2.5匿名函数：lambda

#匿名函数指的是他是一个函数，但是这个函数的名称是可以自定义的：lambda。也就是相当于把函数写为一行了。
a=lambda x,y:x/y  #:左边是函数的形式参数，右边是函数的表达式。
print(a(6,2))

2.2.6过滤出想要的内容

2.2.6.1通过循环实现（for）

#过滤出列表中想要的内容，如过滤出列表1中大于2的内容
list1=[1,9,3,4,7,6,5,8,2]
#通过循环实现
list2=[]
for a in list1:
	if a>2:
		list2.append(a)
print(list2)

2.2.6.2通过函数实现：filter

#过滤出列表中想要的内容，如过滤出列表1中大于2的内容
list1 = [1, 9, 3, 4, 7, 6, 5, 8, 2]
#通过过滤函数实现：filter，其参数：（1）函数对象，但是没有()；（2）可迭代的对象（可以被循环的对象）
#第一种方法,常规函数
def func(a):
	if a>2:
		return True
print(list(filter(func,list1)))  #用list强制把输出的内容转换为列表形式
#第二种方法，借助lambda函数
print(list(filter(lambda x:x>2,list1)))

2.2.7针对所有对象做同一个操作

2.2.7.1通过循环实现（for）

#针对所有对象做同一个操作，如对列表1中的每个对象+10
#通过循环的方式实现
#第一种方式：生成一个新列表
list1=[1,2,3,4,5,6,7,8,9,10]
list2=[]
def func():
	for a in list1:
		list2.append(a+10)
	print(list2)
func()
#第二种方式：常规函数，借助循环和索引修改列表中的内容
def func1():
	for index,b in enumerate(list1):
		list1[index]=b+10
	print(list1)
func1()
#第三种方式，常规函数，借助列表解析式和循环
list3=[1,2,3,4,5,6,7,8,9,10]
def func2():
	list4=[i+10 for i in list3]
	print(list4)
func2()

2.2.7.2通过内部函数实现：map

list1=[1,2,3,4,5,6,7,8,9,10]
#通过函数实现，针对所有对象做同样的操作：map,其参数：（1）函数对象，但是没有()；（2）可迭代的对象（可以被循环的对象）
#第一种方式，借助lambda函数和map函数
print(list(map(lambda a:a+10,list1)))

3、全局变量与局部变量

3.1概述

（1）全局变量：在一个python文件中定义的变量；

（2）局部变量：在一个函数中定义的变量。

（3）优先级

A、在函数内部调用变量，局部变量优先级是高于全局变量的；

B、在python文件中调用变量，全局变量的优先级是高于局部变量的。如果在函数内部想引用全局变量，那么使用关键字global。

3.2实例

#全局变量：在一个python文件中定义的变量；局部变量：在一个函数中定义的变量。
# 优先级：在函数内部调用变量，局部变量优先级是高于全局变量的；在python文件中调用变量，全局变量的优先级是高于局部变量的。
#如果在函数内部想引用全局变量，那么使用关键字global.
name="柒夜"
def func():
	name="qy"
	print(name)
func()
print(name)
#在函数内部引用全局变量：global
def func():
	global name
	print(name)
func()

4、函数异常逻辑处理

4.1异常逻辑概述

异常的父类是BaseException，他执行的逻辑如下：

（1）try:

（2）except:

（3）else:

（4）finally:

异常逻辑执行的顺序：

1、正常逻辑：try——>else——>finally，即先执行try，正常逻辑情况下try可执行，接下来执行else，最后执行finally。其中try必须填写，else和finally可以填写也可以不填写。

2、异常逻辑：try—— >except——>finally，即先执行try,异常逻辑try不可执行，就跳过try，直接执行except捕获异常原因，最后执行finally。其中try和except必须填写，finally可以填写也可以不填写。

4.2异常逻辑处理实例

4.2.1实例1：分母不能为0异常处理

#异常逻辑：分母不能为0.
def func(a,b):
	try:
		print(a/b)
	except Exception as e:  #捕获异常，Exception是所有异常的基类，可以捕获所有异常。
		print(e.args[0])  #输出捕获到的异常信息,e.args[0]是固定格式。
	else:
		print("我是try，先执行try在执行我！")
	finally:
		print("不管是否正常，我都执行")
func(1,1)
#正常逻辑：try——>else——>finally,即先执行try，正常逻辑情况下try可执行，接下来执行else，最后执行finally。
# 其中try必须填写，else和finally可以填写也可以不填写。
func(1,0)
#异常逻辑：try—— >except——>finally，即先执行try,异常逻辑try不可执行，就跳过try，直接执行except捕获异常原因，最后执行finally。
#其中try和except必须填写，finally可以填写也可以不填写。

 4.2.2实例2：学生成绩判断循环异常处理

#改造学生成绩判断的循环，使其可以输出任意字符串不出错，异常情况下继续执行。
while True:
	try:
		studentScore = int(input("请输入学生成绩\n"))
		if studentScore >= 0 and studentScore < 60:
			print("继续努力")
		elif studentScore >= 60 and studentScore < 80:
			print("还可以更进一步")
		elif studentScore >= 80 and studentScore <= 90:
			print("优秀，但还有进步空间")
		elif studentScore > 90 and studentScore <= 100:
			print("非常棒，继续努力")
		elif studentScore == 120:
			continue
		elif studentScore == 150:
			break
		else:
			break
	except Exception as e:continue

4.2.3实例3：根据索引查询列表的内容的异常处理

#根据索引查找列表中的元素，当索引不存在时，使其不报错,并输出错误原因。
yl=[1,2,3,"a","b","c"]
for a,b in enumerate(yl):
	def func(a):
		try:
			print(yl[a])
		except Exception as e:
			print(e.args[0])
		else:
			print("我是try，先执行try在执行我！")
		finally:
			print("不管是否正常，我都执行")
#正常逻辑:先执行try,再执行else，最后执行finally。
func(3)
#异常逻辑：先执行try,执行异常，然后执行except，最后执行finally。
func(8)

5、模块和包

5.1概述

1、模块：在python中，每一个python文件都是一个模块(module)。

2、包（package)：在一个包里面会有很多模块。

3、包与文件夹的区别：包里面有_init _.py文件；文件夹里没有。

4、如何创建包和文件夹：

（1）创建包，如下图，包的中间有一个小孔。

（2）创建文件夹，如下图，文件夹中间没有小孔。

5.2模块间的调用

一个模块调用另一个模块中的所有的内容，前提是另一个模块是一个包中的，用的是from (包的位置）.package.module import *(*代表所有内容）。

#一个模块调用另一个模块中的所有的内容，前提是另一个模块是一个包中的，用的是from (包的位置）.package.module import *(*代表所有内容）
#如调用基础学习文件下的login包中的f1.py模块中的内容
from 基础学习文件.login.f1 import *
print(name)
func()