python第四天

一什么是名称空间？

#名称空间：存放名字的地方，三种名称空间，（之前遗留的问题x=1，1存放于内存中，那名字x存放在哪里呢？名称空间正是存放名字x与1绑定关系的地方）

二名称空间的加载顺序
#1、python解释器先启动，因而首先加载的是：内置名称空间

#2、执行test.py文件，然后以文件为基础，加载全局名称空间

#3、在执行文件的过程中如果调用函数，则临时产生局部名称空间
三名字的查找顺序

局部名称空间--->全局名称空间--->内置名称空间

#需要注意的是：在全局无法查看局部的，在局部可以查看全局的

四 作用域

#1、作用域即范围

       - 全局范围（内置名称空间与全局名称空间属于该范围）：全局存活，全局有效

　     - 局部范围（局部名称空间属于该范围）：临时存活，局部有效

#2、作用域关系是在函数定义阶段就已经固定的，与函数的调用位置无关

#3、查看作用域：globals(),locals()

LEGB 代表名字查找顺序: locals -> enclosing function -> globals -> __builtins__

locals 是函数内的名字空间，包括局部变量和形参

enclosing 外部嵌套函数的名字空间（闭包中常见）

globals 全局变量，函数定义所在模块的名字空间

builtins 内置模块的名字空间

一 什么是闭包？

#内部函数包含对外部作用域而非全局作用域的引用

#提示：之前我们都是通过参数将外部的值传给函数，闭包提供了另外一种思路

二 闭包的意义与应用

#闭包的意义：返回的函数对象，不仅仅是一个函数对象，在该函数外还包裹了一层作用域，这使得，该函数无论在何处调用，优先使用自己外层包裹的作用域

#应用领域：延迟计算（原来我们是传参，现在我们是包起来）

装饰器就是闭包函数的一种应用场景

一 为何要用装饰器

#开放封闭原则：对修改封闭，对扩展开放

二 什么是装饰器

装饰器他人的器具，本身可以是任意可调用对象，被装饰者也可以是任意可调用对象。

强调装饰器的原则：1 不修改被装饰对象的源代码 2 不修改被装饰对象的调用方式

装饰器的目标：在遵循1和2的前提下，为被装饰对象添加上新功能

三 装饰器的使用

被装饰函数的正上方，单独一行

        @deco1

        @deco2

        @deco3

        def foo():

            pass

        foo=deco1(deco2(deco3(foo)))

一 迭代的概念

#迭代是一个重复的过程，每次重复即一次迭代，并且每次迭代的结果都是下一次迭代的初始值

while True: #只是单纯地重复，因而不是迭代

    print('===>') 

l=[1,2,3]

count=0

while count < len(l): #迭代

    print(l[count])

count+=1

二 为何要有迭代器？什么是可迭代对象？什么是迭代器对象？

#1、为何要有迭代器？

对于序列类型：字符串、列表、元组，我们可以使用索引的方式迭代取出其包含的元素。但对于字典、集合、文件等类型是没有索引的，若还想取出其内部包含的元素，则必须找出一种不依赖于索引的迭代方式，这就是迭代器

#2、什么是可迭代对象？

可迭代对象指的是内置有__iter__方法的对象，即obj.__iter__，如下

'hello'.__iter__

open('a.txt').__iter__

#3、什么是迭代器对象？

可迭代对象执行obj.__iter__()得到的结果就是迭代器对象

而迭代器对象指的是即内置有__iter__又内置有__next__方法的对象

文件类型是迭代器对象

open('a.txt').__iter__()

open('a.txt').__next__()

#4、注意：

迭代器对象一定是可迭代对象，而可迭代对象不一定是迭代器对象

三 迭代器对象的使用

dic={'a':1,'b':2,'c':3}

iter_dic=dic.__iter__() #得到迭代器对象，迭代器对象即有__iter__又有__next__，但是：迭代器.__iter__()得到的仍然是迭代器本身

iter_dic.__iter__() is iter_dic #True

print(iter_dic.__next__()) #等同于next(iter_dic)

print(iter_dic.__next__()) #等同于next(iter_dic)

print(iter_dic.__next__()) #等同于next(iter_dic)

# print(iter_dic.__next__()) #抛出异常StopIteration，或者说结束标志

#有了迭代器，我们就可以不依赖索引迭代取值了

iter_dic=dic.__iter__()

while 1:

    try:

        k=next(iter_dic)

        print(dic[k])

    except StopIteration:

        break

#这么写太丑陋了，需要我们自己捕捉异常，控制next，python这么牛逼，能不能帮我解决呢？

能，请看for循环

四 for循环

#基于for循环，我们可以完全不再依赖索引去取值了

dic={'a':1,'b':2,'c':3}

for k in dic:

    print(dic[k])

#for循环的工作原理

#1：执行in后对象的dic.__iter__()方法，得到一个迭代器对象iter_dic

#2: 执行next(iter_dic),将得到的值赋值给k,然后执行循环体代码

#3: 重复过程2，直到捕捉到异常StopIteration,结束循环

五 迭代器的优缺点

#优点：

  - 提供一种统一的、不依赖于索引的迭代方式

  - 惰性计算，节省内存

#缺点：

  - 无法获取长度（只有在next完毕才知道到底有几个值）

  - 一次性的，只能往后走，不能往前退

 

 

 

一 什么是生成器，生成器就是迭代器

#只要函数内部包含有yield关键字，那么函数名()的到的结果就是生成器，并且不会执行函数内部代码

def func():

    print('====>first')

    yield 1

    print('====>second')

    yield 2

    print('====>third')

    yield 3

    print('====>end')

g=func()

print(g) #<generator object func at 0x0000000002184360>

二 协程函数

#yield关键字的另外一种使用形式：表达式形式的yield

def eater(name):

    print('%s 准备开始吃饭啦' %name)

    food_list=[]

    while True:

        food=yield food_list

        print('%s 吃了 %s' % (name,food))

        food_list.append(food)

g=eater('egon')

g.send(None) #对于表达式形式的yield，在使用时，第一次必须传None，g.send(None)等同于next(g)

g.send('蒸羊羔')

g.send('蒸鹿茸')

g.send('蒸熊掌')

g.close()

g.send('烧素鹅')

 yield总结

#1、把函数做成迭代器

#2、对比return，可以返回多次值，可以挂起/保存函数的运行状态

面向过程编程

#1、首先强调：面向过程编程绝对不是用函数编程这么简单，面向过程是一种编程思路、思想，而编程思路是不依赖于具体的语言或语法的。言外之意是即使我们不依赖于函数，也可以基于面向过程的思想编写程序

#2、定义

面向过程的核心是过程二字，过程指的是解决问题的步骤，即先干什么再干什么

基于面向过程设计程序就好比在设计一条流水线，是一种机械式的思维方式

#3、优点：复杂的问题流程化，进而简单化

#4、缺点：可扩展性差，修改流水线的任意一个阶段，都会牵一发而动全身

#5、应用：扩展性要求不高的场景，典型案例如linux内核，git，httpd

#6、举例

流水线1：

用户输入用户名、密码--->用户验证--->欢迎界面

流水线2：

用户输入sql--->sql解析--->执行功能

            

 

一 三元表达式

name=input('姓名>>: ')

res='SB' if name == 'alex' else 'NB'

print(res)

二 列表推导式

#1、示例

egg_list=[]

for i in range(10):

    egg_list.append('鸡蛋%s' %i)

egg_list=['鸡蛋%s' %i for i in range(10)]

#2、语法

[expression for item1 in iterable1 if condition1

for item2 in iterable2 if condition2

...

for itemN in iterableN if conditionN

]

类似于

res=[]

for item1 in iterable1:

    if condition1:

        for item2 in iterable2:

            if condition2

                ...

                for itemN in iterableN:

                    if conditionN:

                        res.append(expression)

#3、优点：方便，改变了编程习惯，可称之为声明式编程

三 生成器表达式

#1、把列表推导式的[]换成()就是生成器表达式

#2、示例：生一筐鸡蛋变成给你一只老母鸡，用的时候就下蛋，这也是生成器的特性

>>> chicken=('鸡蛋%s' %i for i in range(5))

>>> chicken

<generator object <genexpr> at 0x10143f200>

>>> next(chicken)

'鸡蛋0'

>>> list(chicken) #因chicken可迭代，因而可以转成列表

['鸡蛋1', '鸡蛋2', '鸡蛋3', '鸡蛋4',]

#3、优点：省内存，一次只产生一个值在内存中