day12 函数名的应用 闭包 迭代器
sum()函数
print(sum((5,6,7))) #求和, 参数是可迭代的
reture 和 print()函数
a = print('bajie') #print打印bajie, 但是不返回任何东西
print(a) #所以 a 是None
max() min()函数
print(max(3,4,5))
print(min(3,4,5))
求阶乘 如(7*6*5*4*3*2*1)
def func(num):
sumn = 1
for i in range(num, 0, -1):
sumn *= i
return sumn
print(func(7))
笛卡尔积 (两个for嵌套)
def func():
hua = ['hong','hei','hua','pian']
dian = [2,3,4,5,6,7,8,9,10,'J','Q','K','A']
rst = []
for h in hua:
for d in dian:
rst.append((h, d))
return rst
print(func())
默认值参数: 当参数的数据类型是可变的时候
def func(var, lst=[]): #当默认值参数是可变的类型, 下次用默认值时,使用的是旧的内存空间, 不会分配新的内存空间
lst.append(var)
return lst
print(func(10))
print(func(123, []))
print(func('abc'))
99乘法表
def func(num=9):
for i in range(1, num+1):
for j in range(1, i+1):
print('%sx%s=%s' % (i, j, i*j), end=' ')
print()
func()
一.函数名的应用(是第一类对象)
函数名的命名规范和变量是一样的
函数名其实就是变量名
def func():
print('i am function')
print(func) #是函数本身, 是一个内存地址
a = func #变量可赋值, 函数名也可以
a()
func = 6 #函数名就是变量
print(func)
a = 10
b = 20
c = 30
lst = [a, b, c] #变量可以作为元素加到列表里
print(lst)
def func1():
print('in func1')
def func2():
print('in func2')
def func3():
print('in func3')
lst = [func1, func2, func3] #函数名和变量一样也可以放到列表里, 说明函数是变量名
print(lst)
for el in lst:
el()
函数名可以作为参数传递给函数
def eat():
print('eat some thing')
def func(fn):
fn()
func(eat)
可以作为返回值
def func():
print('in func')
a = 10
def inner():
print('in inner')
return inner #和变量一样可作为返回值, 返回函数名(即函数的内存地址)
rst = func()
rst() #或写为 func()()
二.闭包
特点: 在内层函数中访问外层函数的变量
作用: 1. 可以保护你的变量不受侵害(因为全局变量不安全, 因为谁的函数的global都可以改)
def outer():
a = 10 #作用1.变量安全,只有函数 outer 里面可以改, 对外界的函数不开放
def inner():
print(a)
inner()
outer()
作用: 2. 可以让一个变量常驻内存
def outer():
a = 10 #作用: 2.常驻内存, 为了inner执行的时候有值
def inner():
print(a)
return inner
inner = outer()
inner() #作用: 2.因为inner是在outer函数外面执行的, 什么时间执行不确定, 所以要求a要常驻内存
超简易爬虫: 利用闭包把爬取到的内容常驻内存
from urllib.request import urlopen
def outer():
s = urlopen('https://pythonav.com/index/').read() #后端爬虫, (还有一种前端爬虫)
def inner():
print(s)
return inner
rst = outer()
rst() #第一次耗时
rst() #第二次直接从内存取
#outer()()
#outer()()
#outer()() #这样写每次都要进行 url 的请求, 是毛用都没有的
__closure__ 判断一个函数是否是闭包
def func():
a = 10
def inner():
print(a)
print(inner.__closure__) #如果不是闭包None; 如果是闭包会有一坨东西(closure: 关闭)
func()
三.迭代器
是通用的遍历对象的方式
1.节省内存
2.惰性机制
3.不能重复, 只能向下执行
4.for循环的内部就是迭代器
dir() 查看对象里面有什么方法, 什么函数(打印出来, 先是带__的, 后是不带的)
print(dir(str))
print(dir(list))
__iter__() 获取当前对象的迭代器: 可以用for循环, 可迭代对象
s = 'bajieai'
it = s.__iter__() #获取迭代器
print(it)
>>>str_iterator object at 0x0000019B2E778EF0
print(dir(it)) #迭代器里面有 __iter__ 和 __next__
print(it.__next__()) #1. 只能向前
print(it.__next__()) #2. 几乎不占内存(明天生成器讲原因)
print(it.__next__()) #3. for循环
print(it.__next__())
print(it.__next__()) #当取完,数据, 会抛出异常StopIteration
用迭代器模拟for循环
lst = ['bajie','wukong','datang','xiyu']
for el in lst: #底层用的是迭代器
print(el)
lst = ['bajie','wukong','datang','xiyu']
it = lst.__iter__() #先拿到迭代器
while True:
try:
el = it.__next__() #获取下一个元素
print(el)
except StopIteration:
break
用dir(), 判断数据是否是可迭代的, 是否是迭代器(野路子)
lst = ['bajie', 'wukong', 'datang']
print('__iter__' in dir(lst)) #True
print('__next__' in dir(lst)) #False lst是可迭代的
it = lst.__iter__()
print('__iter__' in dir(it)) #True
print('__next__' in dir(it)) #True it是迭代器
isinstance(), 判断一个对象是不是Iterator或Iterable类的实例: 判断数据是否是可迭代的, 是否是迭代器(正规的)
from collections import Iterable
from collections import Iterator
lst = ['bajie', 'wukong', 'datang']
it = lst.__iter__()
print(isinstance(lst, Iterable)) #True
print(isinstance(lst, Iterator)) #False
print(isinstance(it, Iterable)) #True
print(isinstance(it, Iterator)) #True