第四篇：python基础_4
本篇内容
- 名称空间与作用域
- 闭包函数
- 装饰器
- 迭代器
- 生成器
- 三元表达式
- 列表解析
- 生成器表达式
一、 名称空间与作用域
1.名称空间
存放名字的地方，准确的说名称空间是存放名字与变量值绑定关系的地方。名称空间有分为三类，分别为内置名称空间、全局名称空间、局部名称空间。
加载顺序：内置名称空间 ------> 全局名称空间 ------> 局部名称空间
名字查找顺序：局部名称空间 ------> 全局名称空间 ------> 内置名称空间
#!/usr/bin/env pyhon
#encoding: utf-8
#auth: yanglei
max = 1
def foo():
max = 2
print(max)
foo()
#!/usr/bin/env pyhon
#encoding: utf-8
#auth: yanglei
max = 1
def foo():
#max = 2
print(max)
foo()
#!/usr/bin/env pyhon
#encoding: utf-8
#auth: yanglei
#max = 1
def foo():
max = 2
print(max)
foo()
（1）内置名称空间
在python解释器启动时产生，存放一些python内置的名字。
max() len() int() str() float()
（2）全局名称空间
在执行文件时产生，存放文件级别定义的名字。
x = 1
def func():
y =2
def f1():
pass
print x
class foo:
pass
if x == 1:
z = 3
（3）局部名称空间
在执行文件的过程中，如果调用了函数，则会产生该函数的局部名称空间。用来存放该函数内定义的名字，该名字在函数调用时生效，在函数调用结束后失效。
#!/usr/bin/env pyhon
#encoding: utf-8
#auth: yanglei
def foo():
x = 2
print(x)
foo()
2.作用域
作用域，即作用的范围。
（1）全局作用域
全局作用域：全局存活，全局有效
#!/usr/bin/env pyhon
#encoding: utf-8
#auth: yanglei
x = 1
def test():
def test1():
def test2():
print(x)
test2()
test1()
test()
（2）局部作用域
局部作用域：临时存活，局部有限
#!/usr/bin/env pyhon
#encoding: utf-8
#auth: yanglei
x = 1
def test():
def test1():
def test2():
x = 2
print(x)
test2()
test1()
print(x)
test()
（3）作用域关系
在函数定义时就已经固定，与调用关系无关，在函数调用时，必须回到函数原来定义的位置去找作用域关系。
#!/usr/bin/env pyhon
#encoding: utf-8
#auth: yanglei
x = 1
def f1():
x = 1000
def f2():
x = 2000
print(x)
return f2
def foo(func):
func()
foo(f1())
二、闭包函数
定义在函数内部的函数，包含对外部作用域名字的引用，而不是对全局作用域名字的引用，那么该内部函数就称为闭包函数。
#!/usr/bin/env pyhon
#encoding: utf-8
#auth: yanglei
x = 1
def test():
x = 11111
def test_1():
print(x)
return test_1
func = test()
func()
闭包函数的应用
#!/usr/bin/env pyhon
#encoding: utf-8
#auth: yanglei
import requests
def f1(url):
def f2():
print(requests.get(url).text)
return f2
python_web = f1("https://www.python.org")
baidu_web = f1("https://www.baidu.com")
python_web()
baidu_web()
三、装饰器
更改线上代码要遵守开放封闭原则，即对扩展是开放的，对修改是封闭的。
装饰器，装饰它人的工具，装饰器本身可以是任意可调用对象，被装饰的对象本身也可以是任意可调用对象。
装饰器的遵循的原则：1.不修改被装饰对象的源代码2.不修改被调用对象的调用方式。
装饰器的目的是：在遵循1和2原则的前提，为其他新功能函数添加。
#!/usr/bin/env pyhon
#encoding: utf-8
#auth: yanglei
import time
def timeer(func):
def wapper():
start_time = time.time()
func()
stop_time = time.time()
print("run time is %s" %(stop_time - start_time))
return wapper
@timeer
def foo():
print("the is foo")
time.sleep(2)
return 123
@timeer
def bar():
print("the is bar")
time.sleep(3)
foo()
bar()
有参装饰器
#!/usr/bin/env pyhon
#encoding: utf-8
#auth: yanglei
if_name = {"users":None}
def login(func):
def wapper(*args,**kwargs):
if if_name["users"]:
return func(*args,**kwargs)
user = input("username:").strip()
passwd = input("password:").strip()
with open("db.txt",encoding="utf-8") as file:
data = eval(file.read())
print(data)
if user in data and passwd == data[user]:
res = func(*args,**kwargs)
if_name["users"] = user
return res
else:
print("login is error")
return wapper
@login
def index():
print("the is index,welcome~")
index()
@login
def home(name):
print("the is home,%s welcome~" % name)
home("yanglei")
四、迭代器
迭代：是一个重复的过程，每一次重复，都是基于上一次的结果而来。
迭代器对象的优点：
1：提供了一种统一的（不依赖于索引的）迭代方式
2：迭代器本身，比起其他数据类型更省内存
迭代器对象的缺点：
1:一次性，只能往后走，不能回退，不如索引取值灵活
2：无法预知什么时候取值结束，即无法预知长度
#!/usr/bin/env pyhon
#encoding: utf-8
#auth: yanglei
while True: #单纯的重复
print('你瞅啥')
l=['a','b','c','d']
count=0
while count < len(l):
print(l[count])
count+=1
迭代器：
可迭代对象iterable：凡是对象下有__iter__方法：对象.__iter__，该对象就是可迭代对象
#!/usr/bin/env pyhon
#encoding: utf-8
#auth: yanglei
s='hello'
l=['a','b','c','d']
t=('a','b','c','d')
dic={'name':'yanglei','sex':'m',"age":18}
set1={1,2,3}
f=open('db.txt')
s.__iter__()
l.__iter__()
t.__iter__()
dic.__iter__()
set1.__iter__()
f.__iter__()
迭代器对象：可迭代对象执行内置的__iter__方法，得到的结果就是迭代器对象
#!/usr/bin/env pyhon
#encoding: utf-8
#auth: yanglei
dic={'name':'yanglei','sex':'m',"age":18}
i=dic.__iter__()
print(i) #iterator迭代器
i.__next__() #next(i)
print(next(i))
print(next(i))
print(next(i))
print(next(i)) #StopIteration
l=['a','b','c','d']
i=l.__iter__()
print(next(i))
print(next(i))
print(next(i))
print(next(i))
print(next(i)) #StopIteration
五、生成器
生成器：在函数内部包含yield关键，那么该函数执行的结果是生成器
生成器就是迭代器
yield的功能：
1 把函数的结果做生迭代器（以一种优雅的方式封装好__iter__,__next__）
2 函数暂停与再继续运行的状态是由yield
#!/usr/bin/env pyhon
#encoding: utf-8
#auth: yanglei
def func():
print('first')
yield 11111111
print('second')
yield 2222222
print('third')
yield 33333333
print('fourth')
g=func()
print(g)
from collections import Iterator
print(isinstance(g,Iterator))
print(next(g))
print('======>')
print(next(g))
print('======>')
print(next(g))
print('======>')
print(next(g))
for i in g: #i=iter(g)
print(i)
六、三元表达式
#!/usr/bin/env pyhon
#encoding: utf-8
#auth: yanglei
def foo(x):
if x > 3:
return 'ok'
else:
return 'no'
x=10
res=x if x > 3 else 'no'
print(res)
七、列表解析
#!/usr/bin/env pyhon #encoding: utf-8 #auth: yanglei nums=[1,2,3,4,5,6] nums_new=[item**2 for item in nums if item > 3] print(nums_new)
八、生成器表达式
#!/usr/bin/env pyhon
#encoding: utf-8
#auth: yanglei
# [{'name': 'apple', 'price': 333, 'count': 3}, ]
with open('db.txt',encoding='utf-8') as f:
info=[{'name':line.split()[0],
'price':float(line.split()[1]),
'count':int(line.split()[2])} for line in f if float(line.split()[1]) >= 30000]
print(info)