1.函数作为变量
python中声明函数就是声明一个类型是function的变量，函数名就是变量名
普通变量能做的事情函数都可以做
1.声明函数就是声明变量，函数名就是变量名
def func1():
print('函数1')
return 100
# 函数名就是func1，函数的调用表达式func1()就是函数的返回值
print(type(func1)) # 类型为function
a = 100
print(type(a))
func2 = lambda x: x*2
"""
def func2(x):
return x*2
"""
print(type(func2))
2.普通变量能做的函数都可以做
- 1)一个变量可以给另外一个变量赋值
a = 100
b = a
print(b, b+10)
def func3():
print('函数3')
return 200
b2 = func3
print(type(b2), b2())
- 2)修改变量的值
a = 'abc'
print(a, a[1:])
func3 = [10, 20]
# func3() # TypeError: 'list' object is not callable
func3.append(100)
print(func3)
- 3)变量作为序列的元素
a = 10
list1 = [a, 100, 'abc']
print(list1)
def func4():
print('函数4')
return 400
list2 = [func4, func4(), 10]
print(list2)
print(list2[0]()) # func4()
- 4)变量作为函数的参数
def func5(x):
print('函数5:', x)
a = 100
func5(a)
func5(func4)
===================实参高阶函数==================
1.将函数作为函数的参数 - 实参高阶函数
def func4():
print('函数4')
return 400
def func6(x):
x = func4
y = x() # func4()
print('y:', y)
return y
# func6(a) # TypeError: 'int' object is not callable
re = func6(func4)
print(re)
2.系统的实参高阶函数
- 列表.sort()、sorted()、max()、min()都是实参高阶函数, 因为这四个函数中都有一个参数key，要求是一个函数
nums = [10, 89, 78, 7]
nums.sort(reverse=True)
print(nums)
1）排序方法: 参数key要求是一个函数，作用是用来定制排序的规则(默认按元素的大小从小到大或者从大到小排序)
参数key的要求:
a.key是一个函数
b.函数中有且只有一个参数, 这个参数指向的是序列中的每个元素
c.函数需要一个返回值，这个返回值就是排序的时候比较大小的对象
# 练习: 将nums中的元素按个位数从小到大排序
nums = [100, 39, 51, 62, 58]
# nums = [100, 51, 62, 58, 39]
# def func_key(item):
# return item % 10
# func_key = lambda item: item % 10
nums.sort(key=lambda item: item % 10)
print(nums)
# 练习2：将学生按成绩从大到小排序
students = [
{'name': '小明', 'age': 18, 'score': 90},
{'name': '小花', 'age': 23, 'score': 78},
{'name': '王五', 'age': 17, 'score': 65},
{'name': '李四', 'age': 30, 'score': 89}
]
# def func1(item):
# return item['score']
students.sort(reverse=True, key=lambda item: item['score'])
print(students)
# 练习3: 按学生年龄和分数的和从小到排序
students.sort(key=lambda item: item['age'] + item['score'])
print(students)
2) max、min默认是直接比较序列元素的大小求出最大值和最小值
nums = [17, 89, 100, 78, 23]
max1 = max(nums)
print(max1)
# 求nums中个位数最大的元素
max2 = max(nums, key=lambda item: item % 10)
print(max2)
students = [
{'name': '小明', 'age': 18, 'score': 90},
{'name': '小花', 'age': 23, 'score': 78},
{'name': '王五', 'age': 17, 'score': 65},
{'name': '李四', 'age': 30, 'score': 89}
]
print(max(students, key=lambda item: item['score']))
3)max函数的原理(了解)
def yt_max(seq, key=None):
t_seq = list(seq)
t_max = t_seq[0]
if not key:
for item in t_seq[1:]:
if item > t_max:
t_max = item
else:
for item in t_seq[1:]:
if key(item) > key(t_max):
t_max = item
return t_max
# max1 = max(nums)
# print(max1)
# max([nums], key=)
max1 = max((10, 9, 8, 67), key=lambda item: item % 10)
print(max1)
max2 = yt_max((10, 12, 8, 67, 29), key=lambda item: item % 10)
print(max2)
1.变量可以作为函数的返回值
def yt_sum(x, y):
# x=10, y=20
t = x+y # t = 10+20 = 30
return t # return 30
print(yt_sum(10, 20))
函数作为函数的返回值 - 返回值高阶函数
# func1就是一个返回值高阶函数
def func1():
def func2():
print('函数2')
return func2
print(func1())
func1()() # func2()
print('=============')
print(func1()()) # func2() -> None
2.闭包 - 函数1中声明了一个函数2，并且在函数2中使用了函数1的数据，那么这个函数1就是一个闭包
闭包的特点: 闭包函数中的数据不会因为函数调用结束而销毁
def func3():
a = 10
print(id(a))
def func4():
print(a)
print(id(a))
return func4
t = func3()
# 在这个时间点，func3函数就已经销毁了
t() # 而func4函数中依然能够找到a的值
# 面试题1：函数在声明时不会执行，只有被调用的时候才会执行
list1 = []
for i in range(5):
list1.append(lambda x: x*i)
# list1 = [lambda x: x*i, lambda x: x*i, lambda x: x*i, lambda x: x*i, lambda x: x*i]
# i = 4
print(list1[1](2), list1[2](2), list1[3](2))
# def func10():
# print(yyy + 100)
# 面试题2: 函数参数默认值，当函数的参数存在默认值的时候，设定的默认值可以理解为在堆区间里开辟了一个内存区域
def func2(seq=[]):
# seq = []
seq.append(10) # [10]
return seq
print(func2()) # [10]
print(func2()) # [10, 10]
# 练习: 写出打印结果
list3 = [1, 2]
def func3(seq=list3):
# seq=seq
seq.append(10)
return seq
func3()
# list3 = [100, 200]
list3.append(100)
print(func3()) # 1, 2, 10, 100, 10
import time
1.什么是装饰器
- 装饰器本质是一个函数 = 返回值高阶函数+实参高阶函数+糖语法
- 装饰器是python的三大神器之一: 装饰器、迭代器、生成器
- 作用: 给已经写好的函数添加新的功能
eg:
给函数添加一个功能: 统计函数的执行时间
==========方法一: 在每个需要添加功能的函数中加入相应代码=========
def yt_sum(x, y):
start = time.time() # 获取当前时间
sum1 = x + y
print(sum1)
end = time.time()
print('函数执行时间: %fs' % (end - start))
yt_sum(100, 200)
def factorial(n):
start = time.time()
sum1 = 1
for num in range(1, n+1):
sum1 *= num
print('%d的阶乘是:%d' % (n, sum1))
end = time.time()
print('函数执行时间: %fs' % (end - start))
factorial(5)
==============方法二:====================
# 注意: 这个add_time只能给没有参数的函数添加统计执行时间的功能
def add_time(fn):
# fn=func1
start = time.time()
fn() # func1()
end = time.time()
print('函数执行时间: %fs' % (end - start))
# 注意: 这个add_time可以给有参数的函数添加统计执行时间的功能
def add_time2(fn, *args, **kwargs):
start = time.time()
fn(*args, **kwargs)
end = time.time()
print('函数执行时间: %fs' % (end - start))
def func1():
print('=======')
print('+++++++')
def func2():
print('你好世界!')
print('你好python~')
def func3(x, y):
print('%d+%d=%d' % (x, y, x+y))
add_time(func1)
add_time(func2)
add_time2(func1)
# func3(10, 20)
add_time2(func3, 10, 20)
2.装饰器
========================装饰器================
无参装饰器的函数:
def 函数名1(参数1):
def 函数名2(*args, **kwargs):
result = 参数1(*args, **kwargs)
新功能对应的代码段
return result
return 函数名2
说明:
函数名1 - 装饰器的名字;一般根据需要添加的功能命名
参数1 - 需要添加功能的函数， 一般命名为fn
函数名2 - 随便命名, 可以用test
添加统计函数执行时间的装饰器对应的函数
def add_time3(fn):
def test(*args, **kwargs):
start = time.time()
re = fn(*args, **kwargs)
end = time.time()
print('函数执行时间: %fs' % (end - start))
return re
return test
@add_time3
def func5():
print('你好吗')
func5()
@add_time3
def sum3(x, y, z):
print(x+y+z)
sum3(1, 2, 3)
# 练习: 给所有返回值是整数的函数添加功能: 返回值以16进制形式的数据返回
def add_hex(fn):
def test(*args, **kwargs):
re = fn(*args, **kwargs)
# type(re) == int
# 判断re是否是整型
if isinstance(re, int):
return hex(re)
return re
return test
@add_hex
def yt_sum(x, y):
return x+y
print(yt_sum(10, 20))
@add_hex
def print_star():
print('******')
print(print_star())
1.解包: 在容器型数据类型前加*或者**可以容器进行解包
注意: **只能放在字典的前面
1)*将列表和元祖解包
list1 = [10, 20, 30]
print(*list1) # list1 == [10, 20, 30] -> *list1 == 10, 20, 30
print(10, 20, 30)
def func1(x, y, z):
print('x:{}, y:{}, z:{}'.format(x, y, z))
func1(10, 20, 30)
func1(*list1)
list1 = [10, 20, 30, 40]
# func1(*list1) # func1(10, 20, 30, 40)
# 练习: 写一个函数可以对多个数据进行不同的运算
def yt_sum(*nums):
# nums = ((9, 90, 89, 67, 8),)
# nums = (9, 90, 89, 67, 8)
sum1 = 0
for x in nums:
sum1 += x
return sum1
def yt_sub(*nums):
sum1 = nums[0]
for x in nums[1:]:
sum1 -= x
return sum1
yt_sub(10, 2, 3)
def operation(char, *nums):
# char='+', nums = (9, 90, 89, 67, 8)
if char == '+':
# yt_sum((9, 90, 89, 67, 8))
# return yt_sum(nums)
# yt_sum(9, 90, 89, 67, 8)
return yt_sum(*nums)
elif char == '-':
return yt_sub(*nums)
print(operation('-', 28, 90, 78))
# operation('-', 28, 90, 78, 10)
print(operation('+', 9, 90, 89, 67, 8))
# 2) **是将字典解包
dict1 = {'x': 100, 'y': 200}
print(dict1) # dict1 == {'x': 100, 'y': 200} **dict1 == x=100,y=200; *dict1==x,y
# print(**dict1) # print(x=100, y=200)
dict2 = {'end': '\n', 'sep': '+'}
print(10, 20, **dict2) # print(10, 20, end='=', sep='+')
def func2(x, y):
print(x, y)
func2(x=100, y=200)
func2(**dict1) # func2(x=100,y=200)
1.什么是迭代器(iter)
迭代器也是python提供的容器型数据类型
迭代器存储数据的特点: 一个迭代器可以存储多个数据，如果要获取元素必须将元素从迭代器中取出，而且取一个就少一个；
取出来的数据不能再添加到迭代器中
2.将数据存入迭代器中: 1)将别的序列转换成迭代器 2)创建生成器
list1 = [10, 20, 30, 40]
iter1 = iter(list1)
print(iter1) # <list_iterator object at 0x110190400>
# print(len(iter1)) # TypeError: object of type 'list_iterator' has no len()
iter2 = iter('hello')
print(iter2) # <str_iterator object at 0x109be0550>
3.获取迭代器中的元素
迭代器中的元素不同通过什么方式取出来了，那么这个元素在迭代器中就不存在了
1)获取单个元素:
next(迭代器) -> 取出迭代器中最前面的元素
print(next(iter1)) # 10
print(next(iter1)) # 20
print(next(iter1)) # 30
print(next(iter1)) # 40
# print(next(iter1)) # StopIteration
2)遍历 - 一个一个的取所有的元素
for x in iter2:
print('x:', x)
# print(next(iter2)) # StopIteration
print('=================')
iter3 = iter('python')
next(iter3)
next(iter3)
for y in iter3:
print('y:', y)
iter4 = iter('python')
list2 = list(iter4)
print(list2)
print(next(iter4)) # StopIteration
