首页 > 代码库 > 函数嵌套 ,名称空间与作用域 ,闭包函数 ,装饰器 ,迭代器, 生成器 三元表达式，列表解析，生成器表达式 递归与二分法, 内置函数
函数嵌套 ,名称空间与作用域 ,闭包函数 ,装饰器 ,迭代器, 生成器 三元表达式，列表解析，生成器表达式 递归与二分法, 内置函数
函数嵌套
名称空间与作用域
闭包函数
装饰器
迭代器
生成器
三元表达式，列表解析，生成器表达式
递归与二分法
内置函数
--------------------------------------------
函数的嵌套调用：在调用一个函数的过程中，又调用了其他函数
函数的嵌套定义：在一个函数的内部，又定义另外一个函数
def max(x,y):
if x>y:
return x
else:
return y
def max1(a,b,c,d):
res=max(a,b)
res2=max(res,c)
res3=max(res2,d)
return res3
print(max1(4,5,6,7))
效果：7
--------------------------------------------------
名称空间：存放名字的地方，准确的说名称空间是存放名字与变量值绑定关系的地方
内置名称空间：在python解释器启动时产生，存放一些python内置的名字(存在始终)
全局名称空间：在执行文件时，存放文件级别定义的名字(不用缩进)
局部名称空间：在执行文件的过程中，如果调用了函数，则会产生该函数的局部名称空间
用来存放该函数内定义的名字，该名字在函数调用时生效，在函数调用结束后失效
加载顺序：内置--》全局--》局部
****名字的查找顺序：局部-全局-内置
------------------------------------------------
作用域：作用的范围
全局作用域：全局存活，全局有效globals()
局部作用域：临时存活，局部有效locals()
（global 值）设置为全局
（nonlocal 值）设置为局部
*作用域关系，在行数定义时就已经固定，于调用位置无关，在调用函数时，必须回到函数原来定义的位置去找作用域关系
============================================================================
闭包函数：定义在函数内部的函数，包含对外部作用域名字的引用，而不是对全局作用域名字的引用
闭包函数的应用：惰性计算
import requests #pip3 install requests
def index(url):
# url=‘https://www.python.org‘
def get():
return requests.get(url).text
return get
python_web=index(‘https://www.python.org‘)
baiduweb=index(‘https://www,baidu.com‘)
python_web()
baiduweb()
-----------------------------------------------------------------------------
装饰器：
1 开放封闭原则：对扩展是开放的，对修改是封闭
2 装饰器：装饰他人的工具，装饰器目的是为其他人添加新功能
装饰器本身可以是任意可调用对象，被装饰的对象本身也可以是任意可调用对象
2.1 装饰器的遵循的原则：1不修改被装饰对象的源代码
2不修改被调用对象的调用方式
2.2 装饰器的目的是：在遵循1和2的前提下，为其他函数添加新功能
import time
def timmer(func):
def wrapper(*args,**kwargs):
start=time.time()
res=func(*args,**kwargs)
stop=time.time()
print(‘run time is %s‘ %(stop-start))
return res
return wrapper
@timmer #index=timmer(index)
def index():
time.sleep(3)
print("welcome to index")
return 1234
@timmer #home=timmer(home)
def home(name):
time.sleep(2)
print("dddddd%s" %name)
index()
home(666)
------------------------------------------------------------
迭代：是一个重复的过程，每一次重复，都是基于上一次的结果而来
迭代器：
可迭代的对象：凡是对象下有_iter_方法：对象._iter_,该对象就是可迭代对象
s=‘hello‘
l=[‘a‘,‘b‘,‘c‘,‘d‘]
t=(‘a‘,‘b‘,‘c‘,‘d‘)
dic={‘name‘:‘elroy‘,‘sex‘:‘m‘}
set1={1,2,3}
f=open(‘db.txt‘)
----------------------------------
s.__iter__()
l.__iter__()
t.__iter__()
dic.__iter__()
set1.__iter__()
f.__iter__()
dic={‘name‘:‘elroy‘,‘sex‘:‘m‘}
i=dic.__iter__()
print(i) #iterator迭代器
--------------------------------------------
l=[‘a‘,‘b‘,‘c‘,‘d‘]
dic={‘name‘:‘elroy‘,‘sex‘:‘m‘}
i=iter(l)
iter_dic=iter(dic)
while True:
try:
print(next(i))
k=next(iter_dic)
print(k,dic[k])
except StopIteration:检查报错语句并退出
break
=============================================
什么是迭代器对象：
1 有__iter_，执行得到仍然是迭代本身
2 有__next__
迭代器对象有点：
1 提供了一种统一的（不依赖于索引的）迭代方式
2 迭代器本身，比起其他数据类型更省内存
迭代器对象缺点：
1 一次性，只能往后走，不能回退，不如索引取值灵活
2 无法预知什么时候取值结束，即无法预支长度
*for循环遵循迭代器协议
文件本身就是迭代器对象
判断可迭代对象与迭代器对象
from collections import Iterable,Iterator
s=‘hello‘
l=[‘a‘,‘b‘,‘c‘,‘d‘]
t=(‘a‘,‘b‘,‘c‘,‘d‘)
dic={‘name‘:‘elroy‘,‘sex‘:‘m‘}
set1={1,2,3}
f=open(‘db.txt‘)
print(isinstance(s,Iterable))
print(isinstance(l,Iterable))
print(isinstance(t,Iterable))
print(isinstance(dic,Iterable))
print(isinstance(set1,Iterable))
print(isinstance(f,Iterable))
*文件是迭代器对象 print(isinstance(f,Iterator))
效果：
True
True
True
True
True
True
Ture
-------------------------------------------------
生成器：在函数颞部包含yield关键，那么该函数执行的结果是生成器
生成器就是迭代器
yield的功能： 1 把函数的结果做成迭代器（以一种优雅的方式封装好__iter__,__next__）
2 函数暂停与再继续运行的状态是由yield
无穷尽的值：
def elroy(n):
print("开始")
while True:
yield n
n+=1
g=elroy(0)
for i in g:
print(i)
效果：
开始
450579
450580
450581
450582
450583
450584
450585
450586
450587
450588
450589
450590
450591
450592
450593
450594
450595
450596
---------------------------------------
def my_range(start,stop):
while True:
if start == stop:
* raise StopIteration #终止迭代器异常
yield start
start+=1
for i in my_range(1,3):
print(i)
****for循环自动出来StopIeration退出循环
---------------------------------------------
yield与return的比较？
相同：都有返回值的功能
不同：return只能返回一次值，而yield可以返回多次值
=============================================================
三元表达式，列表解析，生成器表达式
if判断的另外一种表现形式
x=10
def foo():
if x > 3:
return ‘OK‘
else:
return ‘NO‘
print(foo())
x=10
res=‘OK‘ if x>3 else ‘NO‘
print(res)
----------------------------------------
列表解析，生成器表达式（不允许else：）为了多行代码浓缩成少行
l=[]
for i in range(10):
l.append("egg%s" %i)
print(l)
*l=[‘egg%s‘ %i for i in range(10)]
*print(l)
------------
l=[]
for i in range(10):
if i >=5:
l.append("egg%s" %i)
print(l)
l=[‘egg%s‘ %i for i in range(10) if i >=5]
print(l)
效果：
[‘egg5‘, ‘egg6‘, ‘egg7‘, ‘egg8‘, ‘egg9‘]
[‘egg5‘, ‘egg6‘, ‘egg7‘, ‘egg8‘, ‘egg9‘]
-----------------------------------------------
生成器表达式：(占内存大的时候用)
with open(‘a.txt‘,encoding=‘utf-8‘) as f:
res=max((len(line) for line in f))
print(res)
效果：
44
-----------------------------------------------
声明式编程：
文件内容：
asdfaf 11111 1
asdfa 1111112 2
asdf 1111114 3
asd 1111113 4
---------------------
with open(‘d.txt‘,encoding=‘utf-8‘)as f:
l=[]
for line in f:
goods=line.split()
price=float(goods[1])
connt=int(goods[2])
const=price*connt
l.append(const)
print(sum(l))
-------------------------------------------------
简化版本：with open(‘d.txt‘,encoding=‘utf-8‘)as f:
l=[float(line.split()[1])*int(line.split()[2])for line in f]
print(sum(l))
http://www.cnblogs.com/linhaifeng/articles/6883726.html
函数嵌套
名称空间与作用域
闭包函数
装饰器
迭代器
生成器
三元表达式，列表解析，生成器表达式
递归与二分法
内置函数
--------------------------------------------
函数的嵌套调用：在调用一个函数的过程中，又调用了其他函数
函数的嵌套定义：在一个函数的内部，又定义另外一个函数
def max(x,y):
if x>y:
return x
else:
return y
def max1(a,b,c,d):
res=max(a,b)
res2=max(res,c)
res3=max(res2,d)
return res3
print(max1(4,5,6,7))
效果：7
--------------------------------------------------
名称空间：存放名字的地方，准确的说名称空间是存放名字与变量值绑定关系的地方
内置名称空间：在python解释器启动时产生，存放一些python内置的名字(存在始终)
全局名称空间：在执行文件时，存放文件级别定义的名字(不用缩进)
局部名称空间：在执行文件的过程中，如果调用了函数，则会产生该函数的局部名称空间
用来存放该函数内定义的名字，该名字在函数调用时生效，在函数调用结束后失效
加载顺序：内置--》全局--》局部
****名字的查找顺序：局部-全局-内置
------------------------------------------------
作用域：作用的范围
全局作用域：全局存活，全局有效globals()
局部作用域：临时存活，局部有效locals()
（global 值）设置为全局
（nonlocal 值）设置为局部
*作用域关系，在行数定义时就已经固定，于调用位置无关，在调用函数时，必须回到函数原来定义的位置去找作用域关系
============================================================================
闭包函数：定义在函数内部的函数，包含对外部作用域名字的引用，而不是对全局作用域名字的引用
闭包函数的应用：惰性计算
import requests #pip3 install requests
def index(url):
# url=‘https://www.python.org‘
def get():
return requests.get(url).text
return get
python_web=index(‘https://www.python.org‘)
baiduweb=index(‘https://www,baidu.com‘)
python_web()
baiduweb()
-----------------------------------------------------------------------------
装饰器：
1 开放封闭原则：对扩展是开放的，对修改是封闭
2 装饰器：装饰他人的工具，装饰器目的是为其他人添加新功能
装饰器本身可以是任意可调用对象，被装饰的对象本身也可以是任意可调用对象
2.1 装饰器的遵循的原则：1不修改被装饰对象的源代码
2不修改被调用对象的调用方式
2.2 装饰器的目的是：在遵循1和2的前提下，为其他函数添加新功能
import time
def timmer(func):
def wrapper(*args,**kwargs):
start=time.time()
res=func(*args,**kwargs)
stop=time.time()
print(‘run time is %s‘ %(stop-start))
return res
return wrapper
@timmer #index=timmer(index)
def index():
time.sleep(3)
print("welcome to index")
return 1234
@timmer #home=timmer(home)
def home(name):
time.sleep(2)
print("dddddd%s" %name)
index()
home(666)
------------------------------------------------------------
迭代：是一个重复的过程，每一次重复，都是基于上一次的结果而来
迭代器：
可迭代的对象：凡是对象下有_iter_方法：对象._iter_,该对象就是可迭代对象
s=‘hello‘
l=[‘a‘,‘b‘,‘c‘,‘d‘]
t=(‘a‘,‘b‘,‘c‘,‘d‘)
dic={‘name‘:‘elroy‘,‘sex‘:‘m‘}
set1={1,2,3}
f=open(‘db.txt‘)
----------------------------------
s.__iter__()
l.__iter__()
t.__iter__()
dic.__iter__()
set1.__iter__()
f.__iter__()
dic={‘name‘:‘elroy‘,‘sex‘:‘m‘}
i=dic.__iter__()
print(i) #iterator迭代器
--------------------------------------------
l=[‘a‘,‘b‘,‘c‘,‘d‘]
dic={‘name‘:‘elroy‘,‘sex‘:‘m‘}
i=iter(l)
iter_dic=iter(dic)
while True:
try:
print(next(i))
k=next(iter_dic)
print(k,dic[k])
except StopIteration:检查报错语句并退出
break
=============================================
什么是迭代器对象：
1 有__iter_，执行得到仍然是迭代本身
2 有__next__
迭代器对象有点：
1 提供了一种统一的（不依赖于索引的）迭代方式
2 迭代器本身，比起其他数据类型更省内存
迭代器对象缺点：
1 一次性，只能往后走，不能回退，不如索引取值灵活
2 无法预知什么时候取值结束，即无法预支长度
*for循环遵循迭代器协议
文件本身就是迭代器对象
判断可迭代对象与迭代器对象
from collections import Iterable,Iterator
s=‘hello‘
l=[‘a‘,‘b‘,‘c‘,‘d‘]
t=(‘a‘,‘b‘,‘c‘,‘d‘)
dic={‘name‘:‘elroy‘,‘sex‘:‘m‘}
set1={1,2,3}
f=open(‘db.txt‘)
print(isinstance(s,Iterable))
print(isinstance(l,Iterable))
print(isinstance(t,Iterable))
print(isinstance(dic,Iterable))
print(isinstance(set1,Iterable))
print(isinstance(f,Iterable))
*文件是迭代器对象 print(isinstance(f,Iterator))
效果：
True
True
True
True
True
True
Ture
-------------------------------------------------
生成器：在函数颞部包含yield关键，那么该函数执行的结果是生成器
生成器就是迭代器
yield的功能： 1 把函数的结果做成迭代器（以一种优雅的方式封装好__iter__,__next__）
2 函数暂停与再继续运行的状态是由yield
无穷尽的值：
def elroy(n):
print("开始")
while True:
yield n
n+=1
g=elroy(0)
for i in g:
print(i)
效果：
开始
450579
450580
450581
450582
450583
450584
450585
450586
450587
450588
450589
450590
450591
450592
450593
450594
450595
450596
---------------------------------------
def my_range(start,stop):
while True:
if start == stop:
* raise StopIteration #终止迭代器异常
yield start
start+=1
for i in my_range(1,3):
print(i)
****for循环自动出来StopIeration退出循环
---------------------------------------------
yield与return的比较？
相同：都有返回值的功能
不同：return只能返回一次值，而yield可以返回多次值
=============================================================
三元表达式，列表解析，生成器表达式
if判断的另外一种表现形式
x=10
def foo():
if x > 3:
return ‘OK‘
else:
return ‘NO‘
print(foo())
x=10
res=‘OK‘ if x>3 else ‘NO‘
print(res)
----------------------------------------
列表解析，生成器表达式（不允许else：）为了多行代码浓缩成少行
l=[]
for i in range(10):
l.append("egg%s" %i)
print(l)
*l=[‘egg%s‘ %i for i in range(10)]
*print(l)
------------
l=[]
for i in range(10):
if i >=5:
l.append("egg%s" %i)
print(l)
l=[‘egg%s‘ %i for i in range(10) if i >=5]
print(l)
效果：
[‘egg5‘, ‘egg6‘, ‘egg7‘, ‘egg8‘, ‘egg9‘]
[‘egg5‘, ‘egg6‘, ‘egg7‘, ‘egg8‘, ‘egg9‘]
-----------------------------------------------
生成器表达式：(占内存大的时候用)
with open(‘a.txt‘,encoding=‘utf-8‘) as f:
res=max((len(line) for line in f))
print(res)
效果：
44
-----------------------------------------------
声明式编程：
文件内容：
asdfaf 11111 1
asdfa 1111112 2
asdf 1111114 3
asd 1111113 4
---------------------
with open(‘d.txt‘,encoding=‘utf-8‘)as f:
l=[]
for line in f:
goods=line.split()
price=float(goods[1])
connt=int(goods[2])
const=price*connt
l.append(const)
print(sum(l))
-------------------------------------------------
简化版本：with open(‘d.txt‘,encoding=‘utf-8‘)as f:
l=[float(line.split()[1])*int(line.split()[2])for line in f]
print(sum(l))
函数嵌套 ,名称空间与作用域 ,闭包函数 ,装饰器 ,迭代器, 生成器 三元表达式，列表解析，生成器表达式 递归与二分法, 内置函数