类，实例，类属性，实例属性，属性，方法，实例方法，类方法，静态方法，动态的添加类属性和实例属性，动态的添加实例方法类方法和静态方法，生成器，迭代器，可迭代，iter函数，闭包，装饰器，类装饰器

1. 类：使用class编写的代码模板
2. 实例（对象）：类的构造方法的返回值（实例的引用）
3. 类属性，实例属性：
4. 属性：类中的字段
5. 方法：操作属性的代码段
6. 实例方法：
7. 类方法：@classmethod
8. 静态方法：@staticmethod
9. 动态的添加类属性和实例属性：
10. 动态的添加实例方法类方法和静态方法：实例使用types模块
11. 生成器：（），函数+yield
12. 迭代器：可以用next（如：generator）
13. 可迭代：可以用for循环（如：list,tuple,set,dict,generator）
14. iter()函数：将可迭代的对象转换为迭代器
15. 闭包：在函数内部再定义一个函数，内部函数用到了外边函数的变量，并且外部函数将内部函数的引用返回，那么将这个函数以 及用到的一些变量称之为闭包
16. 装饰器：
17. 类装饰器：

对比：
1,类属性只和类相关（属于类）
2,实例属性通常定义在构造函数中
3,类可以访问类属性，不可访问实例属性
  实例可以访问类属性， 可以访问实例属性
 

实例属性  类属性（属于类的）
1声明一个类（需要内存 存储类的信息） 此时声明类属性占一份内存1
2声明一个实例A（需要内存 存储实例A信息） 可以访问类属性可以使用内存1  需要内存2来维护实例属性
3声明一个实例B（需要内存 存储实例B的信息） 可以访问类属性可以使用内存1 需要内存3来维护实例属性
为了节省内存（多使用类属性，少使用实例属性）

"实例可以访问类方法,类可以访问类方法"
"静态方法通过实例，类都可以访问"

实例属性  类属性（属于类的）
1声明一个类（需要内存 存储类的信息） 此时声明类属性占一份内存1
2声明一个实例A（需要内存 存储实例A信息） 可以访问类属性可以使用内存1  需要内存2来维护实例属性
3声明一个实例B（需要内存 存储实例B的信息） 可以访问类属性可以使用内存1 需要内存3来维护实例属性
为了节省内存（多使用类属性，少使用实例属性）

动态语言（解释性语言）：执行需要解释器，根据需要去解释代码，边解释边执行，效率低下
Python，JS，PHP，Go，R
编译性语言：需要预先编译成机器语言或者中间语言，效率高
C++，C，C#，Java
很多Python库库使用C语言来编写 import math
胶水语言（自己不实现，通过调用其他语言的实现）
Python如何动态的
     通过类名添加类属性
     通过实例名添加实例属性
     实例权限比较高

class Person(object):
    "表名只有name 和mp,hp属性可以被动态的添加"
    __slots__ = ("name", "mp", "hp")
    "类属性"
    isAlive = False
    def __init__(self,_hp):
        self.hp = _hp

"声明p的时候还没有类属性"
p = Person(100)
p1 = Person(100)
"通过类名动态的添加类属性"
Person.name = "zzy"
"实例可以获取类属性"
print(p.name,Person.name)
"通过实例动态的添加实例属性"
p.mp = 50
print(p.mp)
print(p1.name)
#wheelnum 没有通过 __slots__的审核所以不能被动态添加
p.wheelnum = 4
print(p.wheelnum)

给类或者实例动态添加方法

"方法:1,实例方法"
import types
class Person(object):
    """Person类可以动态的添加各种方法"""
    def __init__(self, _name):
        self.name = _name

"添加实例方法 getname  setname"
def setname(self, newname):
    self.name = newname
def getname(self):
    return self.name

"添加类方法getdesc"
@classmethod
def getdesc(cls):
    return cls.__doc__
" 动态添加类方法"
Person.getd = getdesc

"添加静态方法getinfo"
@staticmethod
def getinfo():
    return "helloworld"
"动态添加静态方法"
Person.geti = getinfo

p1 = Person("zzy")
p2 = Person("abc")

"需要获取角色的名字"
"1 通过实例名"
"2 添加一个可以设置实例名的方法"
"实例方法的添加需要使用types模块"
p1.setn = types.MethodType(setname, p1)
p1.getn = types.MethodType(getname, p1)
p2.getn = types.MethodType(getname, p2)

p1.setn("zzy1")
# print(p1.getn())
# print(p2.getn())
# print(Person.getd())
# print(p1.getd(),p2.getd())
print(Person.geti())
"动态语言 边执行边解释"

实例方法添加用types模块

类方法和静态方法添加用类名

 "生成器写法 对象多占内存跟元素个数无关"
"生成器不能使用下标,但是可以使用for循环和 next（生成器对象）"
"生成器后面数据根据前面数据推算出来"

函数的内部有yield 函数返回的为生成器
yield 向生成器内部放入对象
如果要获取函数的原始返回值，需要通过next访问所有对象（出错了，错误异常即函数原始返回值）

"""
1.生成器第一种实现:()
"列表生成式 很好用，但是有缺点，有多少个元素就需要开辟多的空间 "
# l1 = [x for x in range(100000)]
# print(l1[100])
""
# l2 = (x for x in range(100000))
# print(next(l2),next(l2),next(l2),next(l2))
# print(l1.__sizeof__())
# print(l2.__sizeof__())

# for r in l1:
#     print(r)
# for r in l2:
#     print(r)
"""
2.生成器第二种写法，常见一种函数写法通过函数 + yield
"""
# def fun():
#     yield 10
#     yield 20
#     yield 30
#     return "helloworld"
#
# result = fun()
# print(type(result))
# for r in result:
#     print(r)

# print(next(result))
# print(next(result))
# print(next(result))

# try:
#     print(next(result))
# except StopIteration as e:
#     print(e)
"""
裴波拉契算法  从第三项起每一项为前两项的和  
0 1 1 2 3 5 8 ...
"""
# a, b = 0, 1
# print(a, b)
# a, b = b, a+b
# print(a, b)
# a, b = b, a+b
# print(a, b)
# a, b = b, a+b
# print(a, b)

def fun(n):
    a, b = 0, 1
    yield a
    yield b
    count = 0
    while count<n:
        a, b = b, a + b
        yield b
        count += 1
    return "Finish"


result = fun(30)
# for r in result:
#     print(r)

while True:
    try:
        print(next(result))
    except StopIteration as e:
        print("next方法出现异常,原因",e)
        break

生成器：为了节省内存空间才是用可以生成 数列 类型为genertor
迭代器Iterator：可以使用next就是迭代器
可迭代Iterable：可以使用for循环
isinstance方法可以用来判断对象是否是某各类的实例 True代表是该类实例

生成器可迭代
可迭代不一定是迭代器
迭代器一定是可迭代的

Python有哪些数据类型
不可迭代:int bool float None 
可迭代类型:str list turple dict set  generator 
生成器 :generator

from collections.abc import Iterable,Iterator
"1 如何判断是否可以迭代"
# g = (x for x in range(10))
# print(type(g))
# for r in g:
#     print(r)
# print( isinstance("", Iterable)  )

"2 如何判断是否为迭代器"
l = [x for x in range(10)]
g = (x for x in range(10))
# print(next(g))
# print(isinstance({5,6}, Iterator))
g2 = iter(l)
print(next(g2))
print(type(g2))
print(isinstance(g2,Iterator))

闭包：
1，函数内部嵌套函数
2，内部函数访问外部函数局部变量
3，外部函数将内部函数返回
因为外部函数返回的为内部函数的引用
外部函数每执行一次都要返回内部函数的引用（该引用保存了外部函数的局部变量）

def fun1():
    a = 1
    def fun2(b):
        return a+b
    return fun2

# print(fun1, type(fun1))
# print(fun1(), type(fun1()))
# print(fun1()(2))

r1 = fun1()
print(r1(5))
print(r1(5))
print(r1(5))
r2 = fun1()
print(r1(6))