#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 晚
