210202课堂整理
返回值
从函数内部传递到函数外部的数据就是函数返回值
1,判断返回值的使用时间
如果实现函数的功能产生了新的数据,
那么这个函数就需要通过返回值把新产生的数据返回
2,操作方法
1) return 后面的值为返回值,没有return默认返回值为None
2)函数调用表达式的值就是函数返回值,只能在函数体里面使用
def sum1(a, b):
return a+b # a+b的结果就是返回的数据
s = sum1(10, 20) # sum1(10, 20)也是函数返回值,就是30
print(s)
# 如果一个函数中没有遇到return, 返回值None
def print_star():
print('*************')
s1 = print_star()
print(s1)
3,函数返回值的使用
返回值能做的,函数调用表达式都可以做
def func1():
return 'abc'
print('abc')
print(func1())
a = 'abc'
print(a)
b = func1()
print(b)
print('abc'[-1])
print(func1()[-1]) # print('abc'[-1])
list1 = ['abc', 100]
list2 = [func1(), 100]
print(list2) # ['abc', 100]
print(func1().join('123')) # print('abc'.join('123'))
dic1 = {func1(): 123}
print(dic1) # {'abc': 123}
def func2(string: str):
return list(string)
print(func2('abc'))
re = func2('abc')
re.append(100)
print(re) # ['a', 'b', 'c', 100]
4,return的使用
1)需要将函数中产生的数据返回的时候使用return:
return 需要返回的数据
2)提前结束函数(执行函数体的时候如果遇到return,函数直接结束
def func3():
print('=====')
print('-----')
print('******')
return 100
result = func3()
print(result)
# 练习:写一个函数,给一个整数,如果这个数是偶数就计算这个数的阶乘,否则计算这个数的立方值。
def operation(num: int):
if num & 1:
return num ** 3
else:
s3 = 1
for x in range(1, num+1):
s3 *= x
return s3
result = operation(3)
print(result)
全局变量和局部变量
根据变量作用域(适用范围)的不同将变量分为:全局变量和局部变量
1,全局变量:没有定义在函数或类里面的变量都是全局变量
全局变量的作用域是从定义开始到程序结束
a = 10 # a是全局变量
if True:
print(f'if语句中:{a}')
for _ in range(3):
print(f'循环中:{a}')
def func1():
print(f'函数中:{a}')
func1()
# b和x都是全局变量
for x in range(3):
b = 100
print(f'函数外面b:{b},{x}')
def func2():
print(f'函数里面b:{b},{x}')
func2()
2,局部变量:定义在函数里面的变量就是局部变量
局部变量的作用域是从定义开始到函数结束(形参属于函数变量)
def func3(m, n):
# m = 10, n = 20
s = m + n
d = 100
print(m, n, d)
func3(10, 20)
# print(m, n)
# print(d)
3,global 只能在函数体中使用
1)在函数内部修改全局变量的值
在函数内部不能直接修改全局变量,要在变量前加global
2)在函数内部定义一个全局变量
age = 18
def func4():
global age
age = 20
print(f'函数内部的年龄:{age}')
global name
name = '小明'
func4()
print(f'函数外部的年龄:{age}, {name}')
匿名函数
1,匿名函数
**功能:**对函数体只有一条的普通函数进行简写
语法:
函数名 = lambda 参数列表:返回值
不需要return
相当于:
def 函数名(形参列表):
return 返回值
匿名函数适用于高阶函数
func1 = lambda x: x*2
# def func1(x):
# return x*2
print(func1(10))
print(func1(x=100))
func2 = lambda x, y=10: x+y
# def func2(x, y=10):
# return x+y
print(func2(2))
print(func2(100, 200))
# 练习:写一个匿名函数判断指定的年是否是闰年
is_leap_year = lambda year: year % 4 == 0 and year % 100 != 0 or year % 400 == 0
print(is_leap_year(2001))
函数就是变量
1.python中定义函数其实就是定义一个类型是function的变量,函数名就是变量名。
a = 10
b = 'abc'
c = [10, 20]
d = {'a': 10, 'b': 20}
# e = lambda x: x*2
def e(x):
return x*2
# 2.普通变量能做的,函数都可以做
x = [10, 20, 30]
def func1():
print('函数1')
# 打印变量
print(x)
print(func1)
# 查看变量类型
print(type(x)) # <class 'list'>
print(type(func1)) # <class 'function'>
# 查看变量的id
print(id(x)) # 4302411904
print(id(func1)) # 4302849360
# 用一个变量给另外一个变量赋值
y = x
y.append(100)
z = func1
z()
# x = 'abc'
# func1 = 200
x = 200
list2 = [x, 100]
def func2():
return 100
list3 = [func2, func2(), 100]
print(list3[0]()) # print(func2()) -> print(100)
# 2.高阶函数(认识就行)
# 1)实参高阶函数 - 如果一个函数的某个参数是函数,那么这样的函数就是实参高阶函数
# 2)返回值高阶函数 - 如果一个函数的返回值是函数,那么这个函数就是返回值高阶函数
# func3就是实参高阶函数
def func3(x):
print(x() + 10)
def f1(a=10, b=20):
return 12.4
func3(f1)
func3(lambda a=10, b=20: 12.4)
# 3.系统实参高阶函数
# max、min、sorted、map、reduce
# print(max([10, 23, '78', 67, '234']))
# print(max([19, 780, 67, 23]))
# students = [
# {'name': 'stu1', 'age': 23, 'score': 89},
# {'name': 'stu2', 'age': 18, 'score': 98},
# {'name': 'stu3', 'age': 24, 'score': 100},
# {'name': 'stu4', 'age': 30, 'score': 27},
# {'name': 'stu5', 'age': 10, 'score': 78}
# ]
# max(students)
实参高阶函数
1, max最大值 min最小值 sorted排序
参数key要求传一个函数,可以通过这个函数来确定比较大小的时候的比较标准
key的要求:
是一个函数
这个函数必须有且只有一个参数(这个参数相当于序列中每个元素)
这个函数需要一个返回值(返回值决定了比较的标准)
nums = [78, 67, 55, 18, 29]
# 求元素值最大的元素
result = max(nums, key=lambda item: item)
print(result) # 78
# 求nums中个位数最大元素
result = max(nums, key=lambda item: item % 10)
print(result) # 29
nums = [128, 88, 90, 71]
# 求各个位上的数字和最大的元素: 11, 16, 9, 8
def f(item):
s = 0
for x in str(item):
s += int(x)
print(f'item:{item}')
return s
result = max(nums, key=f)
print(result) # 88
nums = [123, '78', 89, '345']
# 获取nums数值最大的元素
result = max(nums, key=lambda item: int(item))
print(result)
nums = [78, 67, 55, 18, 29]
# 对nums按照个位数的大小从到大排序:[55, 67, 78, 18, 29] / [55, 67, 18, 78, 29]
new_nums = sorted(nums, key=lambda item: item % 10)
print(new_nums) # [55, 67, 78, 18, 29]
students = [
{'name': 'stu1', 'age': 23, 'score': 89},
{'name': 'stu2', 'age': 18, 'score': 98},
{'name': 'stu3', 'age': 24, 'score': 100},
{'name': 'stu4', 'age': 30, 'score': 27},
{'name': 'stu5', 'age': 10, 'score': 78}
]
# 1)获取students年龄最小的学生(用min)
result = min(students, key=lambda item: item['age'])
print(result)
# 2)按照分数对students从大到小排序
students.sort(key=lambda item: item['score'], reverse=True)
print(students)
# 原理:
# def sort(seq, *, key=None):
# if not key:
# length = len(seq)
# for i in range(0, length-1):
# for j in range(i+1, length):
# if seq[j] < seq[i]:
# seq[i], seq[j] = seq[j], seq[i]
# return seq
# else:
# length = len(seq)
# for i in range(0, length - 1):
# for j in range(i + 1, length):
# if key(seq[j]) < key(seq[i]):
# seq[i], seq[j] = seq[j], seq[i]
# return seq
#
# nums = [88, 39, 51, 17]
# sort(nums, key=lambda item: item % 10)
# print(nums)