函数嵌套 ,名称空间与作用域 ,闭包函数 ,装饰器 ,迭代器, 生成器 三元表达式,列表解析,生成器表达式 递归与二分法, 内置函数
函数嵌套
名称空间与作用域
闭包函数
装饰器
迭代器
生成器
三元表达式,列表解析,生成器表达式
递归与二分法
内置函数
--------------------------------------------
函数的嵌套调用:在调用一个函数的过程中,又调用了其他函数
函数的嵌套定义:在一个函数的内部,又定义另外一个函数
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))