1.函数作为变量

"""
python中声明函数就是声明一个类型是function的变量，函数名就是变量名
普通函数能做的事情函数都可以做
"""

1. 声明函数就是声明变量，函数名就是变量名

def func1():
print('函数1')
return 100

print(type(func1)) # class 'function'

2.普通变量能做的函数都可以做

1)一个变量可以给另一个变量赋值

a = func1
print(type(a))
print(type(a), a())

2)修改变量的值

a = 'abc'
print(a, a[1:])
func1 = [10, 20]
print(func1)

3)变量作为序列元素

a = 10
list1 = [a, 100, 'abc']

def func2():
print('函数2')
return 200

list2 = [func2, func2(), 10]
print(list2) # [<function func2 at 0x00000000021A5F78>, 200, 10]
print(list20) # 200

4)变量作为函数的参数

def func3(x):
print('函数3', x)

a = 100
func3(a)
func3(func2)

将函数作为函数的参数 - 实参高阶函数

def func2():
print('函数2')
return 200

def func4(x):
x()

func4(func2)

2.系统的实参高阶函数

列表.sort()、sorted()、max()、min()都是实参高阶函数，因为这4个函数中都有一个参数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]

[100,51,62,58,39]

def func_key(item):

return item % 10

nums.sort(key=func_key)

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}
]

students.sort(reverse=True, key=lambda item: item['score'])
print(students)

练习3：按学生年龄和分数的和从小到大排序

students.sort(key=lambda item: item['score'] + item['age'])
print(students)

max、min默认是直接比较序列元素的大小求出最大值和最小值

nums = [17, 89, 100, 78, 23]
max1 = max(nums)
print(max1)

求nums中个位数最大的元素

max2 = max(nums, key=lambda item: item % 10)
print(max2)

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

max2 = yt_max((10, 9, 8, 67), key=lambda item: item % 10)
print(max2)

1.变量可以作为函数的返回值

def yt_sum(x, y):
t = x + y
return t

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

def func4():
    print(a)

return func4

t = func3()
t()

练习：

list1 = []
for i in range(5):
list1.append(lambda x: x * i)

print(list11, list12, list13) # 8 8 8

练习2：

def func2(seq=[]):
seq.append(10)
return seq

print(func2()) # [10]
print(func2()) # [10, 10]

import time

1.什么是装饰器

"""
装饰器本质是一个函数 = 返回值高阶函数+实参高阶函数+糖语法
装饰器是python的三大神器之一：装饰器、迭代器、生成器
作用：给已经写好的函数添加新的功能
"""

给函数添加一个功能：统计函数的执行时间

def yt_sum(x, y):
start = time.time()
sum1 = x + y
end = time.time()
print(sum1)
print('函数执行时间:%fs' % (end - start))

yt_sum(100, 200)

注意：这个add_time只能给没有参数的函数添加统计执行时间的功能

def add_time(fn):
start = time.time()
fn()
end = time.time()
print('函数执行时间:%fs' % (end - start))

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')

add_time(func1)

def func3(x, y):
print('%d + %d + %d' % (x, y, x + y))

add_time2(func3, 10, 20)

print('===================================================')

2.装饰器

"""
无参装饰器：
def 函数名1(参数1):
def 函数名2(*args, **kwargs):
参数1()
新功能对应的代码段
return 函数名2

说明：
函数名1 - 装饰器的名字；一般根据需要添加的功能命名
参数1 - 需要添加功能的函数，一般为fn
函数名2 - 随便命名，可以用test
"""

def add_time3(fn):

def test(*args, **kwargs):
    start = time.time()
    fn(*args, **kwargs)
    end = time.time()
    print('函数执行时间:%fs' % (end - start))

return test

@add_time3
def func5():
print('你好吗')

func5()

@add_time3
def sum3(x, y, z):
print(x+y+z)

sum3(1, 2, 3)

print('===================================')

练习：给所有返回值是整数的函数添加功能：返回值以16进制形式的数据返回

def add_hex(fn):

def test(*args, **kwargs):
    re = fn(*args, **kwargs)
    if type(re) == int:
        return hex(re)
    return re
return test

@add_hex
def yt_sum(x, y):
return x+y

print(yt_sum(10, 20))

1.解包：在容器型数据类型前加或者*可以对容器进行解包

注意：**只能放在字典的前面

1)*将列表和元组解包

list1 = [10, 20, 30]
print(*list1)

def func1(x, y, z):
print('x:{},y:{},z:{}'.format(x, y, z))

func1(10, 20, 30)
func1(*list1)

练习：写一个函数可以对多个数据进行不同的运算

def yt_sum(*nums):
sum1 = 0
for x in nums:
sum1 += x
return sum1

def yt_sub(*nums):
sub1 = nums[0]
for x in nums[1:]:
sub1 -= x
return sub1

def operation(operation1, nums):
if operation1 == '-':
return yt_sub(nums)
elif operation1 == '+':
return yt_sum(*nums)

a = operation('-', 28, 90, 78)
b = operation('+', 9, 90, 89, 67, 8)
print(a, b)

2)**是将字典解包

dict1 = {'x': 100, 'y': 200}

print(**dict1)

dict2 = {'end': '=', 'sep': '+'}
print(10, 20, **dict2)
print()

def func2(x, y):
print(x, y)

func2(x=100, y=200)
func2(**dict1)

1.什么是迭代器(iter)

"""
迭代器也是python提供的容器型数据类型

迭代器存储数据的特点：一个迭代器可以存储多个数据，如果要获取元素必须将元素从迭代器中取出，而且取一个少一个；
取出来的数据不能再添加到迭代器中

"""

2.将数据存入迭代器中：1)将别的序列转换成迭代器 2)创建生成器

list1 = [10, 20, 30, 40]
iter1 = iter(list1) # <list_iterator object at 0x000000000063C508>
print(iter1)

iter2 = iter('hello')
print(iter2) # <str_iterator object at 0x000000000217CA48>

3.获取迭代器中的元素

"""
迭代器中的元素不管通过什么方式取出来了，那么这个元素在迭代器中就不存在了

1)获取单个元素：
next(迭代器) - 取出迭代器中最前面的元素
"""
print(next(iter1)) # 10
print(next(iter1)) # 20
print(next(iter1)) # 30
print(next(iter1)) # 40

day11-python三大神器