2019.04.21 python核心特征

本阶段我们将了解Python是如何管理内存的，学习内存管理让我们掌握python的运行机制；

并且在python中有许多函数式编程的特性，比如闭包，装饰器和生成器，这些都是一些比较难掌握的概念，但面试会经常遇到。

1.生成器与列表的对照使用

　　

在Python中， 一边循环一边计算的机制， 称为生成器： generator
创建生成器: G = ( x*2 for x in range(5))
可以通过 next(生成器) 函数获得生成器的下一个返回值
没有更多的元素时， 抛出 StopIteration 的异常
生成器也可以使for 循环，因为生成器也是可迭代对象

这不就是元祖那个推导式吗

需要新的数字，就生成一个新的，不同于列表，需要一下子全出来，
更占用内存

time.clock

%d  是字节吗？

sys.getsizeof()

生成器：generator

老母鸡下蛋比喻法：列表是直接杀了了取卵，生成器通过next让它下蛋

但我还是不知道拿来干嘛呀，只是为了减少内存吗？性能优化吧

生成器和列表推到就只是差括号 和中括号而已　　

next（g）  g.__next__（）底层原理是一样的

g.send(None )

2.生成器的其他生成方式以及元素的遍历方式

　　生成器就是你要多少我就给你多少，我不会直接的存储所有

　　生成器与列表比较

"""

生成器：
什么是生成器？
    genterator
    记录一个算法，可以一遍循环，一遍计算的一种机制
生成器的作用？
    存储1-10000中所有的偶数
    1.list
        列表推导公式
        更加耗时
        更加开销系统内存
    2.生成器
        存储数据(存数的算法)

使用生成器的好处？
    1.时间
    2.内存开销

使用生成器？
    创建生成器： 1. g =( x for x in range(10))

"""

生成器的其他生成方式：
    1.g = (x for x in range(5))
    2. 包含yield关键的函数，为生成器
        yield
        用在函数中

生成器可以生成的元素的访问以及注意事项：
    1.next(g)
    2.for循环变量
    3.g.__next__()
    4.g.send()
        使用send()访问的时候，首个元素必须给None参数,后续元素，可以给任意参数

    超出生成器生成数据的范围：StopIteration

"""

3.迭代器的使用

可以被next()函数调⽤并不断返回下⼀个值的对象称为迭代器
可以使用isinstance(对象,Iterator)判断对象是否为迭代器

迭代器（Iterator）

如何判断对象是可迭代对象（Iterable）

print(isinstance(list1,Iterable))

4.闭包的定义和使用

　　

"""
闭包：
    什么是闭包？
        函数

    如何创建闭包？
        1.嵌套函数定义(外部函数，内部函数)
        2.内部函数使用外部函数中定义的变量
        3.外部函数一定要有返回值，返回内部函数名

    如何使用闭包？
        funcIn = funcOut(a)
        result = funcIn(b)
        print(result)

5使用闭包完成求两点之间的距离
　　math.sqrt   开方
　　%d 是整数的   %g是浮点数
6.使用闭包添加日志功能的引入
　　

"""
闭包的特殊用途：
    1.可以在不修改现有功能源码的前提下，增加新的功能
    日志功能（统计访问事件，访问功能，写到日志文件中），权限验证（下载之前，验证当前账户是否为会员）

    开闭原则：
        开放： 添加功能
        关闭： 修改源代码

"""

import time
#定义一个记录日志的函数:将访问事件以及访问的函数名写入到文件中(log.txt)
def writeLog(func):
    try:
        file = open('log.txt', 'a', encoding='utf-8')
        #写入相关数据信息(访问的函数名，访问的时间)
        file.write(func.__name__)
        file.write('\t')
        #写入访问时间
        file.write(time.asctime())
        file.write('\n')
    except Exception as e:
        print(e.args)
    finally:
        #关闭文件
        file.close()
#闭包
def funcOut(func):
    def funcIn():
        #新增功能
        writeLog(func)
        func()
    return funcIn

def func1():
    print("我是功能1")
def func2():
    print("我是功能2")

#闭包的调用
func1 = funcOut(func1)
func2 = funcOut(func2)

func1()
func2()

　　

开闭原则：是指当别人写好了代码，但是我要新增功能怎么办呢？我又不能修改人家的代码
　　　　　添加功能一般在不修改被人的代码情况下

7.使用闭包实现不修改源码添加功能
　　与闭包关联紧密，很多时候，二者结合是用
加了装饰器之后就不用写使用闭包的第一句话了  其实他们实行的效果是一样的
要执行的函数  = 外部函数（要执行的函数）  返回内部函数名
对呀，装饰器只是让我们调用闭包更简洁更方便
@外部函数名

概括的讲，装饰器的作用就是为已经存在的对象添加额外的功能

装饰器就是装饰原函数的吗？源代码的基础上添加一些东西

def func(fn):
    # 需要有参数，*args,**kwargs
    def func_in(*args,**kwargs):
        print("记录日志")
        print('访问方法:'+fn.__name__)
        # 需要有参数，*args,**kwargs
        xx = fn(*args,**kwargs)
        # 需要有返回值
        return xx
    return func_in

# 待装饰函数：无参数，无返回值
@func
def test1():
    print("test1")
test1()
@func
def test2():
    return "Hello"
print(test2())
@func
def test3(a):
    print('a=%d'%a)
test3(1)

　　

12.Python动态添加属性（对象属性，类属性）

　　setattr（p1,'gender','男’）

　　对象是可以调用类属性的

对象属性是属于该对象的属性

而类属性不一样

13.Python动态添加方法（对象方法，静态方法）

　　如何让一个函数称成为类的实例方法、

　　实例方法也是一样的，属于该对象

import types

p1.study types.MethodTye(study.p1)

静态方法是都可以使用的  静态方法不用上面那个步骤了  直接加@staticmethod

直接将函数变成类的方法

类方法的第一个参数是cls  @classmethod

给的是函数名？？？？

"""
Python
动态语言    ：
    可以在运行时，改变类的结构
        添加属性:
            添加对象属性：
                对象名.属性名 = 值
                setattr(对象,属性,值)
            添加类属性
                类名.属性名

        添加方法
            添加对象方法(实例方法，成员方法)
                import types
                p1.study types.MethodType(study,p1)

                注意：添加后的方法，只能p1调用，其他对象不可以
            添加静态方法
                @staticmethod

                类名.静态方法名 = 定义的函数名

            添加类方法
                @classmethod
                类名.类方法名 = 定义的函数名

            注意：
                类名.类方法名 = 定义的函数名()
                后边为定义的函数名  而不是  定义的函数名()
强类型语言   ：
        变量的类型，运行时决定
        变量的类型在运行之后，可以任意变量，不需要强制转换
"""

14.__alots__的对动态添加属性及方法的限制作用

函数式式编程：指的是内建 函数吗？？

range（10,-1，-1） 步长为负一的是每次增加数（-1）

偏函数partial  对函数进行深加工 就比如从新定义int（）函数，直接可以写进制数的转换

functools之wraps的使用：原函数对象的指定属性复制给包装对象

打印名字：__name__

打印文档：__doc__

如何解决闭包函数中我想需要的是原来的真正的函数名呢？？？

在内部函数上加@wraps（func原函数）就可以了现在的内部函数就是原函数了

这个内建函数之map的使用  还是上次看到过  但是没用过

意思表示映射   就是说在地图上的每一个地址都对应现实中的真实位置，这种关系就是映射

map（func，*iterabale）---》map object  返回的应该是一个迭代器

匿名函数处理吗？？lambda x：x*2

functools 之reduce函数的使用：我感觉和map差不多  只是返回值前者是迭代器而后者是求和的总数  他们的参数是一样的

内建函数值filter的使用  卧槽是过滤器

it1 = filter（lambda x:x！=0，list1）

for i in it1:

print(i)        这些什么functools 的函数都是针对函数来使用的吧

内建函数之sorted（）的使用

list2 = sorted（list，key = lamdba x：（x<0,abs(x)））

这个key=后面要跟函数吗

列表中自定义对象的排序；

　　

有介绍了几个函数的使用吧

"""
元类：
    什么是元类？
        动态创建类
        元类->类

        类->对象

    用途？
        可以动态创建类
    如何使用？
    type()
        1.查看目标对象的数据类型
        2.可以使用type，动态创建类
        语法:
            类 = type(类名,(父类...),{属性，方法})

"""

通过type动态创建的类是没有初始化__init__的  所以可能调用属性的时候是父类的
为什么要跟我讲这个元--使用type动态创建类

类装饰器的作用：会调用__init__ __call__  所以把要写的东西放在__call__中

什么是对象池呢？就是python中的的对象都在这个对象池中存
数字和字符串类型来处理   超过这个【-5,256】范围的都是放在大整数池的

intern机制
　　每个单词（字符串），不夹杂空格或者其他符号，默认开启intern机制，共享内存考引用计数决定是否
销毁    这是内存优化机制的

内存管理这个东西很奇妙啊  内存泄露是指不能及时的释放内存，内存占满了，系统运行就会变慢

python中采用了计数机制为主和隔代回收辅助