day11_函数提高

前言回顾

1.容器型数据类型：列表、元组、字典、集合

列表：

[元素1,元素2,...]
可变、有序
增删改查、+、*、>、<、>=、<=、==、!=、is(判断地址是否相等)、in、not in、len()、list()
多个数据的意义相同，并且需要支增删改操作

元组：

(元素1,元素2,...)、(元素1,)、元素1,，元素2,...
不可变、有序
查、+、*、>、<、>=、<=、==、!=、is(判断地址是否相等)、in、not in、len()、tuple()
一般选择容器存储数据的时候不用元组存储不可变数据的时候才用

字典

{键1:值1, 键2:值2,...} 键 - 不可变，唯一值 - 任何类型的数据
可变、无序
增删改查、==、!=、is、in、not in、len()、dict()
保存的多个数据需要区分(意义/性质不同)

集合

{元素1, 元素2,...} 元素 - 不可变、唯一
可变、无序
增删查、==、!=、is、in、not in、len()、set()、数学集合运算(|, &, -, ^, >=, <=)
注意：集合遍历的效率高
做数学集合运算操作、去重、提高程序效率

2.函数

声明

def 函数名(参数列表):
函数体
注意：函数声明的时候不会执行函数体！

调用

函数(函数列表)
注意：函数调用之前必须已经声明过
**调用过程：
回到函数声明的位置
传参(传参要保证每个参数都有值)
执行函数体
执行完函数体确定返回值
回到函数调用的位置(这个时候函数调用表达式的值就是返回值)

参数

位置参数、关键字参数 - 保证位置参数在关键字参数的前面
参数默认值 - 可以不用传参
类型说明
不定长参数 - args，*kwargs (面试题)

返回值

怎么确定返回值
怎么获取返回值：获取函数调用表达式的值

其他

lambda 参数列表：返回值

变量的作用域：

全局变量：声明在函数/类外部的变量是全局变量
局部变量：声明在函数里面的变量就是局部变量

global: 在函数中声明全局变量
nonlocal: 在局部的局部中去修改局部变量的值

nums = [12, 3, 89, 90, 8]
nums.sort(reverse=True)
print(nums)

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

print('=====')
func1 = lambda x: x*2
result = func1(10)
print(result)

list1 = [10, lambda x: x*x]
result = list1[1](10)
print(result)

print('how are you'.split(' '))

1.函数作为变量

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

def func1():
    print('这是一个函数')
    return 100

2.一个变量可以给另一个变量赋值

a = 10
b = a
print(b/2)
a = 'abc'
print(a)

# c = func1()  # 调用函数，获取函数返回值
c = func1  # 将函数名作为变量，给另一个变量赋值(获取函数变量)
print('===')
print(c())
print('===')
func1 = 12.5
print(func1)

3.一个变量可以作为容器的元素

print('=====')
a = 10
print(type(a))

#声明一个变量，类型是function
def func2():
    print('这是函数2')
    return 100

print(type(func2))
list1 = [a, func2, func2()]
print(list1)
print('0:', list1[0]//3)
print('1:', list1[1]())  # 有问题。。。

练习：

list2 = []
for i in range(5):
    def func(n):
        return i * 2
    list2.append(func)
# 请说出list2[0](3), list2[1](3), list[2](3)  分别的值

list2 = []
i = 0 ~ 4
i = 0: func, list2 = [func]
i = 1: func, list2 = [func, func]
i = 4: list2 = [func, func, func, func, func] # 每声明一次函数，函数名相同，但是都会开辟不同的存储空间
声明函数时，函数都不会执行
8 8 8

4.变量可以作为函数的参数

# 普通变量
def func4(n):
    return n*2
a = 10
# 将变量作为函数的参数
func4(a)

函数作为函数的参数(实参高阶函数)

def func1(fn, fn2):
    fn()  # func11()
    print(fn2(3) / 4)  # print(func12(3)/4)

def func11():
    print('这是一个函数')

def func12(n):
    return n**2

print(func1(func11, func12))  # print None

应用：sort函数

nums = [1, 34, 45, 9, 20]
nums.sort()
print(nums)

all_students = [
    {'name': '小明', 'age': 19, 'score': 89},
    {'name': '熊大', 'age': 20, 'score': 90},
    {'name': '熊二', 'age': 17, 'score': 70},
    {'name': '光头强', 'age': 21, 'score': 40}
]
# sort函数中有个参数key，这个参数要求传一个函数，并且函数有一个参数和一个返回值
# 参数就是序列中的元素，返回值就是排序比较的对象
# def compare(item):
#     return item['age']
# all_students.sort(key=compare)
all_students.sort(key=lambda item: item['age'])
print(all_students)

练习，将all_message中的元组按照第二个元素从大到小排序，然后按照学号的最后一位从小到大排序

all_message = [
    ('张三', 'python1902004'),
    ('李四', 'python1902049'),
    ('王五', 'python1902032')
]
all_message.sort(key=lambda item: item[1], reverse=True)
print(all_message)
all_message.sort(key=lambda item: item[1][-1])
print(all_message)

5.变量作为返回值

将一个函数作为函数的返回值(返回值高阶函数)

print('======返回值高阶函数======')
def func1():
    def temp(*nums):
        return sum(nums)
    return temp

print(func1()(1, 3, 5, 9))

迭代器

1.迭代器

迭代器是容器型数据类型(可以同时存储多个数据),但是想要获取/查看迭代器中元素的值，只能将元素取出来
取出来的元素在迭代器中就不存在了，取的时候只能从前往后一个一个的取，不能跳着取

2.迭代器的元素

迭代器的元素只能通过类型转换，将其他容器转换成迭代器；或者通过生成器取生成

转换 - 所有的序列都可以转换成迭代器迭代器的元素可以是任何类型的数据

iter1 = iter([1, 23, 45, [1, 3]])
print(iter1)

3.获取元素：迭代器获取元素，不管以什么样的方式获取，获取后，这个元素在迭代器中就不存在了

next(迭代器) - 获取迭代器顶部数据(最上面的数据)

iter2 = iter('hello')
print(next(iter2))
print(next(iter2))
print(next(iter2))
print(next(iter2))
print(next(iter2))
# print(next(iter2))  # StopIteration 元素取完之后会报错

遍历获取每个元素

iter2 = iter('hello')
next(iter2)
next(iter2)
for x in iter2:
    print('x:', x)
# print(next(iter2))  # StopIteration

生成器

1.什么是生成器

生成器本质就是迭代器，迭代器不一定是生成器
调用一个带有yield关键字的函数就能得到一个生成器(yeild只能出现在函数体中)

def func1():
    print('=====')
    return 100
    yield

gen1 = func1()
gen2 = func1()
print(gen1, gen2)

2.生成器的元素

生成器获取元素的方式和迭代器一样：next()和循环遍历(只能是for循环)

生成器元素的个数：看执行完生成器对应的函数会遇到几次yield
元素的值：看yield后表达式的值

def func2():
    print('函数体')
    for x in range(10):
        yield x

gen3 = func2()
print('next:', next(gen3))
print('next:', next(gen3))
for x in gen3:
    print('x:', x)

3) 生成器产生数据的原理

当获取生成器的元素的时候，会执行生成器对应的函数，从开始执行到yield为止，将yield后面的数据作为元素返回并且记录结束位置
下次获取元素的时候，从上次结束的位置接着往后执行，直到遇到yield，将yield后面的数据作为元素返回并且记录结束位置
依次类推
如果从开始执行到函数结束，没有遇到yield，那么就获取不到元素

print('======')
def func3():
    print('第一次')
    yield 1
    print('第二次')
    yield 2
    print('第三次')
    yield 3

gen4 = func3()
print('next1:', next(gen4))
for x in range(10):
    print('+++++')

print('next2:', next(gen4))
print('next3:', next(gen4))

nums = ['001', '002', '003', '004']
def func5():
    for x in range(1, 6):
        yield str(x).rjust(3, '0')
nums2 = func5()
print(next(nums2))
print(next(nums2))

能够产生无线数字的生成器

def func6():
    num = 0
    while True:
        yield num
        num += 1

gen5 = func6()

day11_函数提高