python_day25__02__iter()方法和type方法去自己创建类

#Author:'haijing'
#date:2018/10/27

#----------对迭代器的回顾----------#
#列表、字典等都是可迭代对象
# i = iter([11,22,33])  #i就是迭代器 加上iter()方法
# print(i.next())
# print(i.next())  #注意 i.next是在python2中才有的,而目前用的是python3，所以会出错的
# print(next(i))  #这样才会正确的打印11 in python3
# print(next(i))  #打印22

# for r in i:  #如果i是可迭代对象,那么先对i进行__iter__()方法,获取迭代器之后再进行for循环；如果i本身就是迭代器了,那么就直接执行for循环
#     print(r)  #这样也可以打印11 22 33 代替next()方法

#----------自己用__iter__()定义迭代器----------#
#如果类中有__iter()__方法，创建的对象就是可迭代对象，
# 对象.__iter()__的返回值就是迭代器
#for循环遇到迭代器直接就执行next方法了
# class Foo:
#     def __init__(self,name,age):
#         self.name = name
#         self.age = age
#         self.a = '123'
#     def __iter__(self):
#         return iter([11,22,33])
#
# li = Foo('haijing',18)
# for i in li:
#     print(i)  #打印11 22 33
# #执行这个for循环，获取li对象的类Foo中的特殊的__iter__()方法，并获取其返回值
# #第二步循环上一步中返回的对象

#----------自己用type去定义类----------#
# 在python中一切事物都是对象，类都是type类的对象(以下见解析)
# class Foo:  #在编译器编译的时候也会把Foo当作一个对象
#     pass
# obj = Foo()
# obj是一个对象 obj是Foo类的对象
# 在python中一切事物都是对象,按照这个说法,Foo也是一个对象，Foo是type类的对象,是有type创建

# lambda 函数的应用 传参数用的  穿插的一个小知识点
# a = lambda x,y,z:x+y+z
# print(a(1,2,3))  #打印6

# class Foo:
#     def func(self):
#         print('123')
# obj = Foo() #创建对象obj
# #以上三句可用以下三句代替
# def function(self):
#     print('123')
# Foo = tyoe('Foo',(object,),{'func':lambda x:123})  #用type声明一个类,所以这里可以说Foo也是一个对象
# # 其中object为Foo继承的类,实际没有继承那么就默认为object
# #func为Foo类中的一个方法,方法中的内容为 x=123
# obj = Foo() #创建对象obj

#----------类之新理解----------#
class Foo:
    def func(self):
        print('123')
#python编译器执行以上三句的时候首先执行
#1、type中的init()方法
#2、

#----------回顾__call()__方法 ----------#
# class Foo:
#     def __init__(self):
#         pass
#     def __call__(self, *args, **kwargs):
#         pass
# obj = Foo() #默认去执行__init__(self)方法
# obj()   #默认去执行__call__(self, *args, **kwargs)方法,一个对象后面加括号,默认去执行Foo中的__call__()方法

#----------定义自己的type类型,用metclass= ----------#  *****
#回顾 (*)会把接收到的参数形成一个元组，而（**）则会把接收到的参数存入一个字典,区别就是传参数时**必须有名字
# class mytype(type):   #自己创建了mytype类,并继承了python编译器中的type类
#     def __init__(self,*a,**b):  #这里的__init__()方法必须有参数,*a,**b就代表了所有参数,可以有参数也可以没有
#         print('123')
# class Foo(object,metaclass=mytype):  #告诉Foo以后不用由type去创建了,由mytype去创建
#     def func(self):
#         print('hello world!')
# #由于执行 class Foo():的时候会默认去执行type
# #而这里自己定义了mytype，所以在执行class Foo(object,metaclass=mytype)的时候会去执行类mytype(type)中的__init__()方法
# #所以这里会打印123
# obj = Foo()

#----------自己定义的类中使用__call__()方法 ----------#
# class mytype(type):   #自己创建了mytype类,并继承了python编译器中的type类
#     def __init__(self,*a,**b):  #这里的__init__()方法必须有参数,*a,**b就代表了所有参数,可以有参数也可以没有
#         print('123')
#     def __call__(self, *args, **kwargs):
#         print('456')
# class Foo(object,metaclass=mytype):  #告诉Foo以后不用由type去创建了,由mytype去创建
#     def func(self):
#         print('hello world!')
# #当编译器遇到上边三句的时候，会默认执行mytype中的__init()__方法 打印123
#
# obj = Foo() #Foo是类mytype的对象，而对象加括号会去执行类中的__call__()方法
# #所以上边这一句会默认执行mytype中的__call__()方法，打印456
# #原因：Foo是类mytype的对象,一个对象后面加括号,默认去执行类mytype中的__call__()方法

#----------自己定义的类中的call方法 && 去执行类Foo中的方法----------#
class mytype(type):   #自己创建了mytype类,并继承了python编译器中的type类
    def __init__(self,*a,**b):  #这里的__init__()方法必须有参数,*a,**b就代表了所有参数,可以有参数也可以没有
        #self = Foo类
        print('123')
    def __call__(self, *args, **kwargs):
        #self = Foo类
        ret = self.__new__()  #相当于Foo类去调用__new__()方法,而如果__new__()中有返回值,那么就会拿到这里来
            self.__init__(obj)  #去执行Foo中的__init__()方法
class Foo(object,metaclass=mytype):  #告诉Foo以后不用由type去创建了,由mytype去创建
    def func(self):
        print('hello world!')
    def __new__(cls, *args, **kwargs):  #在这里边真正的创建了obj
        return '对象'
下面插图具体来说明执行的步骤：


haijing iN HZ  我在杭州的江干区，想着你
2018.10.27 晚