01-函数作为变量
1.函数调用表达式
1）函数调用表达式 - 调用函数的语句
2）普通值能做的事情函数调用表达式都可以做
def func1(x):
return x**3
def func2(t):
print('====:', t)
return func1(2)
8
func1(2)
num = 8
num1 = func1(2)
print(num, num1)
num = 8 * 2
num1 = func1(2) * 2
print(num, num1)
list1 = [8, 10]
list2 = [func1(2), 10]
print(list1, list2)
func2(8)
func2(func1(2))
if 8 % 2 == 0:
print('偶数')
if func1(2) % 2 == 0:
print('偶数')
def func3(num1):
return str(num1)+'abc'
print(func3(100)[-1])
print(func3(213)[2:])
print(func3(123).upper())
2.函数作为变量
1）python中声明函数本质就是声明一个类型是function的变量，函数名就是变量名，变量能做的事情，函数都可以做
1.1)声明一个类型是function的变量， func4是变量
def func4(x):
print('函数:', x)
a = 10
print(type(a), type(func4))
1.2)一个变量可以给另外一个变量赋值
print('================给变量赋值===============')
b = a
print(b+20)
c = func4
print(c(100))
1.3)给变量重新赋值
a = 'abc'
print(a)
func4 = 321
print(func4*2)
# func4(3) # TypeError: 'int' object is not callable
1.4)变量作为容器的元素
a = 10
list1 = [a, 10]
print(list1[0]/2)
def func4(x):
print('函数:', x)
list1 = [func4, func4(20)]
print(list1[1])
print(list1[0](9)) # print(func4(9))
list1 = [
{'a': 10, 'f': func4},
100
]
print(list1[0]['f'](100)) # func4(100)
def func5():
return [1, 2, 3]
list1 = [
{'a': 10, 'f': func5},
100
]
print(list1[0]['f']()[1]) # [1, 2, 3][1]
1.5)变量可以作为函数的参数
a.一个函数可以作为另外一个函数的参数
b.如果一个函数的参数也是函数，那么这种函数叫实参高阶函数
def func61(a=0):
return a*2
# 参数x的类型必须是函数
def func6(x):
# x = func61
x() # x()是调用函数的语句; func61()
func6(func61)
def func7(x):
return x(10) + 100 # x是函数，并且能够接收一个参数，返回值是数字
3.实参高阶函数: 列表.sort()、sorted()、max(), min()
nums = [1, 78, 9, 78, 67, 100]
print(nums.sort())
print(nums)
nums = (1, 78, 9, 78, 67, 100)
print(sorted(nums))
print(nums)
3.1）sort和sorted
a.这两个函数是实参高阶函数，里面有个参数key要求传一个函数
b.key参数对应的函数是用来决定排序规则: 函数需要一个参数和一个返回值, 它的参数代表需要排序的序列的元素，返回值是比较对象
c.数字列表, 排序规则发生改变： 按照数字的个位数从小到大排序
nums = [21, 69, 367, 78, 478, 5100]
# key对应的函数1: 按照元素本身大小进行排序
# [21, 69, 367, 78, 478, 5100]
def func(item):
return item
# key对应的函数2: 按照 元素%10 的值的大小进行排序
def func1(item):
return item % 10
# key对应的函数3：按照元素的最高位的值进行从小到大排序
def func2(item):
return int(str(item)[0])
nums.sort(key=func2) # 按照元素本身大小进行排序
print(nums)
练习: 给一个数字列表，按照各位数的和的大小从下到大排序
nums = [12, 67, 18, 90, 890, 123, 99] # [3, 13, 9, 9, 17, 6, 18]
# nums = [12, 123, 18, 90, 67, 890, 99]
def func3(item):
sum1 = 0
for ch in str(item):
sum1 += int(ch)
return sum1
nums.sort(key=func3)
print(nums)
练习:
all_students = [
{'name': '小明1', 'age': 23, 'score': 89, 'id': 'stu001'},
{'name': '小明2', 'age': 30, 'score': 70, 'id': 'stu029'},
{'name': '小明3', 'age': 18, 'score': 99, 'id': 'stu010'},
{'name': '小明4', 'age': 21, 'score': 40, 'id': 'stu004'},
]
def func4(item):
return item['score']
all_students.sort(key=func4, reverse=True)
print(all_students)
nums = [12, 39, 56]
print(max(nums, key=lambda item: item % 10))
print(max(all_students, key=lambda item: item['score']))
print(max([1, 78, 9]))
print(max({90, 9, 100, 89}))
# print(max(all_students)) # TypeError: '>' not supported between instances of 'dict' and 'dict'
# print(max(all_students, key=10)) # TypeError: 'int' object is not callable
print(max(all_students, key=lambda x: x['score']))
实现原理(了解!)
def yt_max(seq, key=None):
seq = list(seq)
if not key:
max1 = seq[0]
for x in seq[1:]:
if x > max1:
max1 = x
return max1
# key存在
max1 = seq[0]
for x in seq[1:]:
if key(x) > key(max1):
max1 = x
return max1
print(yt_max([1, 78, 9]))
print(yt_max({90, 9, 100, 89}))
# print(yt_max(all_students)) # TypeError: '>' not supported between instances of 'dict' and 'dict'
# print(yt_max(all_students, key=10)) # TypeError: 'int' object is not callable
print(yt_max(all_students, key=lambda x: x['score']))
4.变量作为函数的返回值
4.1)一个函数的返回值如果也是一个函数，那么这个函数就是返回值高阶函数
# func1是返回值高阶函数，因为它的返回值是一个函数
def func1():
def func11():
return 10
return func11
f = func1()
print(f()) # print(func11()) print(10)
f()
def operation(symbol):
if symbol == '+':
def sum(*num):
sum1= 0
for x in num:
sum1 += x
return sum1
return sum
elif symbol == '-':
def differ(*num):
sum1 = num[0]
for x in num[1:]:
sum1 -= x
return sum1
return differ
print(operation('+')(1, 2, 3, 9))
print(operation('-')(1, 2, 4))
5.****装饰器！ = 实参高阶函数+返回值高阶函数+函数+糖语法
02-迭代器
1.什么是迭代器(iter)
a.迭代器是容器型数据类型(序列), 可变(不支持增删改),有序(不支持下标操作)
b.保存在迭代器中的元素,只能取,并且取出后迭代器中就不再保存,也不可以再往迭代器中添加元素
c.迭代器没有对应的格式的数据, 迭代器只能是通过将其他的序列转换成迭代器,或者是生成器
iter1 = iter([10, 20, 30])
print(iter1)
iter2 = iter('hello')
print(iter2)
2.获取迭代器中的元素
a.不管用什么样的方式去获取迭代器中的元素, 获取一个就会少一个
- 获取单个元素: next(迭代器) - 获取迭代器顶部的元素(最上层/第一个元素)
print(next(iter2)) # h
print(next(iter2)) # e
print(next(iter2)) # l
print(next(iter2)) # l
print(next(iter2)) # o
# print(next(iter2)) # 报错, StopIteration
- 遍历
iter2 = iter('abc123')
print(next(iter2)) # a
print(next(iter2)) # b
for x in iter2:
print('===:', x)
# print(next(iter2)) # StopIteration
03-生成器
1.什么是生成器
a.生成器就是迭代器 - 获取元素和迭代器一样(只能一个一个的取，取一个少一个)
b.调用函数体中有yield关键字的函数，就可以得到一个生成器
2.yield
a.yield只能出现在函数体中
b.调用有yield关键字的函数, 不会执行函数体，也不会获取返回值。而是得到一个生成器
def func1():
print('我是一个函数')
return 100
yield
print(func1())
3.生成器怎么产生数据
a.看一个生成器能够产生几个数据，看执行完生成器对应的函数会遇到几次yield；yield后面的值就是生成器能产生数据
def func2():
for x in range(10):
yield x
gen1 = func2()
print(gen1)
print(next(gen1))
print(next(gen1))
for x in gen1:
print('==:', x)
4.生成器生成数据的原理
a.生成器不会同时将所有的元素保存起来, 而是需要数据的时候临时产生数据。
b.获取生成器元素的时候，就去执行生成器对应的函数的函数体，从前往后执行，
直到遇到yield为止， 并且将yield后面的值作为结果，同时保存结束位置；
下次获取下一个元素的时候，接着上次结束的位置往后执行，直到遇到下一个yield;
以此类推...
如果执行到函数结束都没有遇到yield, next函数会报StopIteration错误
print('=================================')
def func3():
print('start')
print('======第一个数据=====')
yield 1
print('======第二个数据======')
yield 2
print('======第三个数据=====')
yield 3
print('end')
gen2 = func3()
print(next(gen2))
print('开始取第2个数据:')
print(next(gen2))
print('开始取第3个数据:')
print(next(gen2))
# print(next(gen2)) # StopIteration
def func2():
print('===============')
yield
print('+++++++++++++++')
yield
def func3():
print('1111111111111111')
yield
print('2222222222222222')
yield
gen3 = func2()
gen4 = func3()
next(gen3)
next(gen4)
next(gen3)
next(gen4)
写一个产生学号的生成器
def creat_id():
num = 1
while True:
yield 'stu'+str(num)
num += 1
nums = creat_id()
print(next(nums))
print(next(nums))
for _ in range(100):
print('===:', next(nums))
print(next(nums))
def func4():
yield 1
return 10
yield 2
yield 3
gen5 = func4()
print(next(gen5))
# print(next(gen5)) # StopIteration: 10
04-生成式
1.什么是生成式
a.生成式本质就是生成器
1）语法1
（表达式 for 变量 in 序列） - 创建一个生成器
展开成生成器：
def func1():
for 变量 in 序列：
yield 表达式
[表达式 for 变量 in 序列] - 将声称是对应的生生成器转换成列表
2）语法2
（表达式 for 变量 in 序列 if 条件语句） - 创建一个生成器
展开成生成器：
def func1():
for 变量 in 序列：
if 条件语句：
yield 表达式
gen1 = (x*2 for x in range(10))
print(next(gen1))
print(next(gen1))
list1 = list(gen1)
print(list1) #[4,6,8,10···18]
# print(next(gen1)) # StopIteration
def func():
for x in range(10):
yield x*2
gen1 = func()
list2 = [x*x for x in range(1,10)]
print(list2) # [1,4,9,16,25,36,49,64,81]
list3 = list((x*x) for x in range(1,10))
print(list3) # [1,4,9,16,25,36,49,64,81]
dict1 = dict((x,x*2)for x in range(5))
# (0,0),(1,2),(2,4),(3,6),(4,8)
print(dict1) # {(0,0),(1,2),(2,4),(3,6),(4,8)}
list4 = ["stu"+str(x) for x in range(10) if x % 2 ]
print(list4) #["stu1","stu3","stu5","stu7","stu9"]
list5 = ["%d*2=%d" % (x,x*2) for x in range(5)]
print(list5)
05-模块的使用
a.在实际开发的时候，一个项目会分为多个模块
1.什么是模块：一个py文件就是一个模块
2.多模块怎么协作： 导入模块
import 模块名 - 在当前模块中导入指定模块，导入后可以使用指定模块中所有的全局变量
以'模块名.变量'的方式去使用from 模块名 import 全局变量1,全局变量2,...
- 导入指定模块中指定的全局变量; 被导入的全局变量在当前模块中直接使用
3)重命名
import 模块名 as 新模块名 - 模块重命名,通过新模块名去使用模块
from 模块名 import 变量1 as 新变量1, 变量2 as 新变量2,...
变量重命名，通过新变量去使用变量
- 通配符
from 模块名 import * - 导入模块中所有的全局变量，使用的时候直接用
导入方式一：
import login
login.login()
print(login.num)
print(login.text)
print(login.x)
导入方式二：
from login import login, num
login()
print(num)
# # print(text) # NameError: name 'text' is not defined
# # print(login.text) # AttributeError: 'function' object has no attribute 'text'
模块重命名
import login as loginModule
login = True
# print(login.num) # AttributeError: 'bool' object has no attribute 'num'
print(loginModule.num)
# from login import login, num as lg_num
# num = 123
# print(num, lg_num) # 123 100
#
# login()
通配符
from login import *
print(num, x, text)
login()
3.导入模块的原理
a.当执行导入模块的代码的时候，实质会执行被导入的模块对应的py文件
print('06模块中的name:', __name__)
# import login
from login import num
print(num)