python递归迭代_Python入门基础知识点(python迭代器和递归）

函数名的使用：

函数名是一个变量, 但它是一个特殊的变量, 与括号配合可以执行函数的变量

函数名的内存地址：

deffunc():pass

print(func) #函数的内存地址

结果：

函数名可以赋值给其他变量：

deffunc():print(1)

a=func

a()

func()#函数名可以当做值赋值给变量

结果：1

函数名可以当做容器类的元素：

deffunc():print(1)deffunc2():print(2)

li=[func,func2]print(li) #函数名可以当做元素放到容器里

结果：[, ](打印的是函数的内存地址，列表里的函数可以加括号，打印的是函数执行的结果，及列表的返回的None)deffunc():print(1)deffunc2():print(2)

li=[func(),func2()]print(li) #函数名可以当做元素放到容器里

结果：1

2[None, None]

函数名可以当做函数的参数:

deffunc():print("吃了么")deffunc2(fn):print("我是1")

fn()#执行传递过来的fn

print("我是2")

func2(func)#把函数func当成参数传递给func2的参数fn.

结果：我是1

吃了么

我是2

函数名可以作为函数的返回值

deffunc_1():print("这里是函数1")deffunc_2():print("这里是函数2")print("这里是函数3")returnfunc_2

fn=func_1()#执行函数1. 函数1返回的是函数2, 这时fn指向的就是上面函数2

fn() #执行func_2函数

结果：

这里是函数1

这里是函数3

这里是函数2

deffunc():defaa():print(2)returnNonereturn aa() #return None#func() # func() == None

print(func())

结果：2None

例题：

li =[]for i in range(3): #for循环三次，三次最终结果i=2

def func(x): #定义函数，形参为x

print(x*i) #打印形参与i(2)相乘的结果

li.append(func) #将func依此添加到li列表当中，循环三次，添加三个，

#此时，列表里的func虽然外表相同，定义的函数相同，但内存地址不一样，存在三个内存地址

for func in li: #将列表里的函数循环出来

func(2) #依此执行func函数，实参数为2

结果：4

4此时我要想将结果打印为0，2，4，只需定义一个数即可

li=[]for i in range(3): #for循环三次，循环为 i =(0，1，2)

def func(x,y=i): #定义函数，形参为x，y=循环的 i 值

print(x*y) #打印形参与y(0，1，2)相乘的结果

li.append(func) #将func依此添加到li列表当中，循环三次，添加三个，

#此时，列表里的func虽然外表相同，定义的函数相同，但内存地址不一样，存在三个内存地址

for func in li: #将列表里的函数循环出来

func(2) #依此执行func函数，实参数为2

闭包

什么是闭包? 闭包就是内层函数, 对外层函数(非全局)的变量的引用. 叫闭包

# 1.一个嵌套函数

# 2.在嵌套函数的内部函数使用外部(非全局的变量)

# 满足以上两条就是闭包

defwrapper():

a= 10

definner():print(a)print(inner.__closure__) #不是None 就是闭包

inner()

wrapper()

结果:

(,)10

将里边的函数名当做参数返回给调用者

defouter():

name= "alex"

#内部函数

definner():print(name)returninner

fn= outer() #访问外部函数, 获取到内部函数的函数地址

fn() #访问内部函数

结果：alex

例：

money = 10

#全局里存放会有污染和不安全的现象

defwrapper():

money= 10

definner(num):global money #从全局调用money

money +=numprint(money)returninner

wrapper()(100) #第二个括号是return的返回值inner的执行，实参为100

# python中闭包,会进行内存驻留, 普通函数执行完后就销毁了

# 全局里存放会有污染和不安全的现象

# 面试必问,装饰器 -- 装饰器的本质就是闭包

# 闭包有个弊端:会出现内存泄漏

迭代器

可迭代对象有哪些:str list tuple dic set

可迭代对象：可以被for的就是可迭代对象

# Python 协议

# 具有.__iter__方法的就是可迭代对象

# a = 对象.__iter__ # 创建一个迭代器

# 具有__iter__和__next__就是一个迭代器

可以for循环的就有__iter__方法,包括range

.这里的__iter__是帮助我们获取到对象的迭代器.我们使用迭代器中的__next__()来获取到一个迭代器的元素

li = [1,2,3]

a= li.__iter__()print(a.__next__())print(a.__next__()) #一个一个取

print(a.__next__())

结果：1

我们使用while循环和迭代器来模拟for循环: 必须要会：

lst = [6,5,4]

l= lst.__iter__()while 1:try:

i= l.__next__()print(i)except StopIteration #当遇到报错的时候，就break退出

break

# 迭代器特性:

# 惰性机制

# 不能从下向上走

# 一次性的,用完就没了

小总结：

Iterable: 可迭代对象. 内部包含__iter__()函数

Iterator: 迭代器. 内部包含__iter__() 同时包含__next__().

迭代器的特点:

1. 节省内存.

2. 惰性机制

3. 不能反复, 只能向下执行.

我们可以把要迭代的内容当成子弹. 然后呢. 获取到迭代器__iter__(), 就把子弹都装在弹夹中. 然后发射就是__next__()把每一个子弹(元素)打出来. 也就是说, for循环的时候.一开始的时候是__iter__()来获取迭代器. 后面每次获取元素都是通过__next__()来完成的. 当程序遇到 StopIteration将结束循环.

递归：

# 1. 自己玩自己 (自己调用自己本身)

# 2. 玩的有限制 (有明确结束条件)

count =0deffunc():globalcount

count+= 1

print(count)if count == 4: #当count=4时，返回

returnfunc()#产生递归现象

func()

打印1到100

deffunc(n):

n+=1

print(n)if n == 100:returnfunc(n)