VB.net 2010 视频教程 VB.net 2010 视频教程 python基础视频教程
SQL Server 2008 视频教程 c#入门经典教程 Visual Basic从门到精通视频教程
当前位置:
首页 > temp > 简明python教程 >

  • python基础(13):函数名的使用、第一类对象、闭包、迭代器

作者：@小灰灰
本文为作者原创，转载请注明出处：https://www.cnblogs.com/liuhui0308/p/11814324.html

回到顶部(go to top)

1. 函数名的运用

函数名是⼀个变量，但它是⼀个特殊的变量，与括号配合可以执⾏函数的变量。

1.1 函数名的内存地址


		
    
			
  1. 
				def func():
    2. 
			
  2. 
				　　print("呵呵")
    3. 
			
  3. 
				　　print(func)
    4. 
			
  4. 
				结果:
    5. 
			
  5. 
				<function func at 0x1101e4ea0>
    6. 
		

	

	

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





	

		

		
    
			
  1. 
				def func():
    2. 
			
  2. 
				　　print("呵呵")
    3. 
			
  3. 
				print(func)
    4. 
			
  4. 
				a = func # 把函数当成⼀个变量赋值给另⼀个变量
    5. 
			
  5. 
				a() # 函数调⽤ func()
    6. 
		

	

	

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





	

		

		
    
			
  1. 
				def func1():
    2. 
			
  2. 
				　　print("呵呵")
    3. 
			
  3. 
				def func2():
    4. 
			
  4. 
				　　print("呵呵")
    5. 
			
  5. 
				def func3():
    6. 
			
  6. 
				　　print("呵呵")
    7. 
			
  7. 
				def func4():
    8. 
			
  8. 
				　　print("呵呵")
    9. 
			
  9. 
				lst = [func1, func2, func3]
    10. 
			
  10. 
				for i in lst:
    11. 
			
  11. 
				　　i()
    12. 
		

	

	

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





	

		

		
    
			
  1. 
				def func():
    2. 
			
  2. 
				　　print("吃了么")
    3. 
			
  3. 
				def func2(fn):
    4. 
			
  4. 
				　　print("我是func2")
    5. 
			
  5. 
				　　fn() # 执⾏传递过来的fn
    6. 
			
  6. 
				　　print("我是func2")
    7. 
			
  7. 
				func2(func) # 把函数func当成参数传递给func2的参数fn.
    8. 
		

	

	

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





	

		

		
    
			
  1. 
				def func_1():
    2. 
			
  2. 
				　　print("这⾥是函数1")
    3. 
			
  3. 
				　　def func_2():
    4. 
			
  4. 
				　　　　print("这⾥是函数2")
    5. 
			
  5. 
				　　print("这⾥是函数1")
    6. 
			
  6. 
				　　return func_2
    7. 
			
  7. 
				fn = func_1() # 执⾏函数1. 函数1返回的是函数2, 这时fn指向的就是上⾯函数2
    8. 
			
  8. 
				fn() # 执⾏上⾯返回的函数
    9. 
		

	

	

		回到顶部(go to top)

	

		2. 闭包





	

		什么是闭包? 闭包就是内层函数，对外层函数(非全局)的变量的引⽤，叫闭包。





	

		

		
    
			
  1. 
				def func1():
    2. 
			
  2. 
				　　name = "alex"
    3. 
			
  3. 
				　　def func2():
    4. 
			
  4. 
				　　　　print(name) # 闭包
    5. 
			
  5. 
				　　func2()
    6. 
			
  6. 
				func1()
    7. 
			
  7. 
				结果:
    8. 
			
  8. 
				alex
    9. 
		

	

	

		我们可以使⽤__closure__来检测函数是否是闭包，使⽤函数名.__closure__返回cell就是闭包，返回None就不是闭包。





	

		

		
    
			
  1. 
				def func1():
    2. 
			
  2. 
				　　name = "alex"
    3. 
			
  3. 
				　　def func2():
    4. 
			
  4. 
				　　　　print(name) # 闭包
    5. 
			
  5. 
				　　func2()
    6. 
			
  6. 
				　　print(func2.__closure__) # (<cell at 0x10c2e20a8: str object at0x10c3fc650>,)
    7. 
			
  7. 
				func1()
    8. 
		

	

	

		问题，如何在函数外边调⽤内部函数呢?





	

		

		
    
			
  1. 
				def outer():
    2. 
			
  2. 
				　　name = "alex"
    3. 
			
  3. 
				　　# 内部函数
    4. 
			
  4. 
				　　def inner():
    5. 
			
  5. 
				　　　　print(name)
    6. 
			
  6. 
				　　return inner
    7. 
			
  7. 
				fn = outer() # 访问外部函数, 获取到内部函数的函数地址
    8. 
			
  8. 
				fn() # 访问内部函数
    9. 
		

	

	

		那如果多层嵌套呢? 很简单，只需要⼀层⼀层的往外层返回就⾏了。





	

		

		
    
			
  1. 
				def func1():
    2. 
			
  2. 
				　　def func2():
    3. 
			
  3. 
				　　　　def func3():
    4. 
			
  4. 
				　　　　　　print("嘿嘿")
    5. 
			
  5. 
				　　　　return func3
    6. 
			
  6. 
				　　return func2
    7. 
			
  7. 
				func1()()()
    8. 
		

	

	

		由它我们可以引出闭包的好处，由于我们在外界可以访问内部函数，那这个时候内部函

	

		数访问的时间和时机就不⼀定了。因为在外部，我可以选择在任意的时间去访问内部函数。这

	

		个时候，想⼀想，我们之前说过，如果⼀个函数执⾏完毕，则这个函数中的变量以及局部命名

	

		空间中的内容都将会被销毁。在闭包中，如果变量被销毁了，那内部函数将不能正常执⾏，所

	

		以，python规定，如果你在内部函数中访问了外层函数中的变量，那么这个变量将不会消亡，

	

		将会常驻在内存中。也就是说，使⽤闭包，可以保证外层函数中的变量在内存中常驻，这样做

	

		有什么好处呢? 非常⼤的好处，我们来看⼀个关于爬⾍的代码:





	

		

		
    
			
  1. 
				from urllib.request import urlopen
    2. 
			
  2. 
				def but():
    3. 
			
      



  

  
  

   
  

  
 
 

 
 
  
 
 
 
 






 






相关教程