函数
位置参数和关键字参数
1、位置参数和关键字参数 - 根据函数调用时候的实参的传递方式分类
1）位置参数 – 让实参和形参在位置上一 一对应
2) 关键字参数 — 调用的时候在实参前加‘形参名=’的结构
3)位置参数和关键字参数可以混用: 位置参数在关键字参数的前面
def func1(a,b,c):
print(f'a:{a},b:{b},c:{c}')
# 位置参数
func1(10,20,30) # a:10,b:20,c:30
func1(20,10,30) # a:20,b:10,c:30
# 关键字参数
func1(a=100,b=200,c=300) # a:20,b:10,c:30
func1(b=200,c=300,a=100) # a:100,b:200,c:300
def func9(a=10,b=20,c=30):
print(f'a:{a},b:{b},c:{c}')
func9(c=330) # 10 20 330
func1(100,c=300,b=200) # a:100,b:200,c:300
# func1(a=300,b=100,300) 报错
# func1(100,a=200,c=300) # 传参必须保证每个参数都有值
2、参数默认值 - 形参
定义函数的时候可以给形参赋值，这样的参数就是有默认值的参数。
在调用有默认值参数的函数的时候，有默认值的参数可以不用传参
注意：有的参数有默认值，有的参数没有默认值，那么没有默认值的必须在有默认值的参数
def func2(a=1,b=2,c=3):
print(f'a:{a},b:{b},c:{c}')
func2(10,20,30) # a:10,b:20,c:30
func2(10,20) # a:10,b:20,c:3
func2(10) # a:10,b:2,c:3
print() # a:1,b:2,c:3
def func3(a,b,c=3):
print(f'a:{a},b:{b},c:{c}')
func3(100,200) # a:100,b:200,c:3
func3(100,200,300) # a:100,b:200,c:300
3、参数类型说明
方法一：在没有默认值的参数后面加：’：类型名’
方法二：形参默认值的类型就是对应的参数类型
def func4(a:list,b:int,c):
print(f'a:{a},b:{b},c:{c}')
def func4(a:list,b:int,c=''):
print(f'a:{a},b:{b},c:{c}')
4、不定长参数 — 参数个数不确定
1）带的不定长参数 - 在形参前加，那么形参就是一个不定长参数，可以同时接受多个参数
不定长*参数本质是元组
注意：
a、不定长的参数对应的形参调用的时候必须用位置参数赋值
2）带**的不定长参数 - 在形参前加 ，那么形参就是一个不定长参数，可以同时接受多个参数
不定长参数本质是字典
注意：必须是关键字传参
定义一个函数求多个数:sum1
def sum1(*nums):
print(nums)
sum1() # ()
sum1(1) # (1,)
sum1(10,20) # (10, 20)
sum1(1,23,3) # (1, 23, 3)
sum1(1,2,3,4) # (1, 2, 3, 4)
特殊情况1：定长在前，*的不定长在后，调用的时候必须是位置参数
def student_info(name,*score):
print(name,score)
student_info('小明',200) # 小明 (200,)py
student_info('小花',20,30,40) # 小花 (20, 30, 40)
特别情况:2：*的不定长在前，定长在后，调用的时候定长必须使用关键字参数，不定长必须是位置参数
def student_info2(*score,name):
print(name,score)
student_info2(2,3,40,name='小花')
特别情况3：*后面的其他参数，必须使用关键字参数
def func5(a,*,b):
pass
def func6(**x):
print(x)
func6() # {}
func6(a=10) # {'a': 10}
返回值
1、返回值 - 将函数内部的数据传到函数外部
什么时候需要返回值：如果实现函数功能产生新的数据，那么新的数据需要返回
def sum1(num1:int,num2:int):
s=num1+num2
# print('函数：',s)
sum1(10,20)
# print(s)
2、怎么返回数据
1）return关键字后面的值就是函数返回值 - 怎么确定函数返回值
2）函数调用表达式的值就是函数的返回值 - 怎么在函数外面获得函数返回值
def sum1(num1:int,num2:int):
s=num1+num2
# print('函数：',s)
return s
result=sum1(10,20)
print('result:',result)
# print(s)
def func9(a=10,b=20,c=30):
print(a,b,c)
3、return关键字
1）return只能在函数体中使用
2）return用来将数据从函数内部传递到函数外部，return后面的值就是函数返回值
如果没有return（没有遇到return），函数返回值是默认值None
3）return可以直接结束函数 - 在执行函数体的时候，如果遇到return函数直接结束
def func2():
return 100
result=func2()
print(result) # 100
def func3():
print(100)
result=func3()
print('返回值',result) # 返回值 None 没有return
def func4():
print('start')
return
print('hello')
print('end')
func4() # start
print(func4()) # None return后面没表达式
4、返回值的使用
使用函数调用表达式的值就是使用函数的返回值
def func5():
return 100
# 1)可以直接打印函数调用表达式
print(100)
print(func5())
# 2)可以使用函数表达式给变量赋值
a=100
b=func5()
print(a,b)
# 3)
print(100+200)
print(func5()+200)
# 4)
list1=[100,200]
list2=[func5(),200]
print(list1,list2) # [100, 200] [100, 200]
def func6(string:str):
return [x for x in string]
print(func6('hello')[-1]) # o
全局变量和局部变量
根据变量作用域的不同，将变量分为全局变量和局部变量
1、全局变量
没有定义在函数和类中的变量都是全局变量，全局变量从定义开始到整个程序结束的任何地方都可以用去全局变量
a是全局变量
a=100
print('外部a',a)
for x in range(3):
print('循环里a:',a)
def func1():
print('函数里面：',a)
func1()
b和c都是全局
for b in range(3):
c=100
print('循环里：',b,c)
print('循环外：',b,c)
2、局部变量
Python中定义在函数中的变量就是局部变量，局部变量的作用域是从定义开始到函数结束
def func3():
m=10
n='abc'
print(f'函数中m、n:{m},{n}')
func3()
# print(f'函数中m、n:{m},{n}') name 'm' is not defined
形参也是局部变量
def func4(x,y):
print('函数外面xy:',x,y)
func4(1,2)
# print('函数外面xy:',x,y) NameError: name 'y' is not defined
总结：当调用函数的时候新系统会自动为被调用的函数开辟一个临时的栈区间，用来保存函数中定义的变量
当函数调用结束之后，这个函数对应的栈区间会自动释放，里面的数据全部销毁，销毁之前先将返回值返回
3.global
作用：
1）在函数里面去修改全局变量的值
2)直接在函数中定义全局变量
age=10
name='小明'
def update():
global name
age=20 # 不会修改全局变量的值，而是定义一个新的局部变量age
print(f'函数里面的年龄：{age}') # 函数里面的年龄：20
name='小花'
print('里面：',name) # 里面： 小花
global sex
sex='男'
print('里面：',sex) # 里面： 男
update()
print(f'外面的年龄：{age}') # 外面的年龄：10
print('外面：',name) # 外面： 小花
print('外面：',sex) # 外面： 男
1、什么是匿名函数
匿名函数的本质是函数（只能用来定义功能用一句代码实现的函数）
语法：
函数名 = lambda 形参列表：返回值
相当于：
def 函数名（形参列表）：
return 返回值
写匿名函数求两个数的和
sum1 = lambda num1, num2:num2+num1
print(sum1(1,2))
print(sum1(num1=100,num2=3))
写一个匿名函数，判断指定年是否是闰年，结果是Ture或False
is_leap_year = lambda year:year % 4 ==0 and year % 100 != 0 or year % 400 ==0
print(is_leap_year(2020)) # True
print(is_leap_year(2021)) # False
-
写一个匿名函数，判断指定的年是否是闰年
is_leap_year = lambda year: year % 4 == 0 and year % 100 != 0 or year % 400 == 0 print(is_leap_year(2021)) # False -
写一个函数将一个指定的列表中的元素逆序( 如[1, 2, 3] -> [3, 2, 1])(注意:不要使用列表自带的逆序函数)
def inverted_sequence(list1): new_list=[] for x in range(len(list1)): new_list.append(list1[len(list1)-1]-x) print(new_list) inverted_sequence([1,2,3,4]) -
写一个函数，获取指定列表中指定元素的下标(如果指定元素有多个，将每个元素的下标都返回)
例如: 列表是：[1, 3, 4, 1] ,元素是1, 返回:0,3def index1(list1,element ): for x in range(len(list1)): if element == list1[x]: print(x,end=' ') index1([1,2,3,4,1],1) -
编写一个函数，计算一个整数的各位数的平方和
例如: sum1(12) -> 5（1的平方加上2的平方） sum1(123) -> 14
def sum_these_numbers(string):
sum1=0
for x in string:
sum1+=int(x)**2
print(sum1)
sum_these_numbers('1235')
- 求列表 nums 中绝对值最大的元素
例如：nums = [-23, 100, 89, -56, -234, 123], 最大值是：-234
def abs_element(list1):
result=[x if x >0 else -x for x in list1]
index1=result.index(max(result))
print(list1[index1])
abs_element([-23, 100, 89, -56, -234, 123])
-
已经列表points中保存的是每个点的坐标(坐标是用元组表示的，第一个值是x坐标，第二个值是y坐标)
points = [ (10, 20), (0, 100), (20, 30), (-10, 20), (30, -100) ]1）获取列表中y坐标最大的点
for x in range(len(points)): max1=points[0][1] if max1 < points[x][1]: max1=points[x][1] max2=points[x] print('y最大坐标',max2)2）获取列表中x坐标最小的点
for x in range(len(points)): min1=points[0][1] if min1 > points[x][0]: min1=points[x][0] min2=points[x] print('x最小坐标',min2)3）获取列表中距离原点最远的点
for x in range(len(points)): max1=points[0][0]**2+points[0][1]**2 if max1 < points[x][0]**2+points[x][1]**2: max1=points[x][0]**2+points[x][1]**2 points1=points[x] print(points1)4）将点按照点到x轴的距离大小从大到小排序
new_points=sorted(points,reverse=True)
result=new_points.pop(3)
new_points.append(result)
print(new_points)
扫一扫
572
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
