#!/usr/bin/env python
# -*- coding: utf-8 -*-
# Author: rex.cheny
# E-mail: rex.cheny@outlook.com# 类名后面写(object)这种写法表示是新式类，不写object是经典类，两种的区别是多继承的问题。
class OOP(object):# 定义类变量，类共享的，那么实例A修改以后实例B也会受到影响（修改不可比那对象感官上看不到修改，如果是可变类型比如列表，感官上就有影响了），# 所以类变量是定义共有的属性通常不能修改，虽然技术上也可以修改。不用实例化也可以访问类变量。var1 = "hello"  # 不可变对象list1 = []  # 可变对象def __call__(self, *args, **kwargs):"""这个函数不是析构函数也不是构造函数，对象或者实例可以像函数一样调用，就像执行普通函数一样。这个如果不需要也不用写。:param args::param kwargs::return:"""print("我是特殊函数 __call__")def __init__(self):"""构造函数，用于初始化类的实例，实例化对象的时候就会自动调用这个方法，比如把实例变量绑定到实例上。这里这个self其实有些特别，也就是实例化的时候会自动把实例对象传递进来，self就是实例对象。oop = OOP() 这里其实是 OOP(oop) 所以self就是实例oop，这个self也就是为了接受隐式传递进来的实例名称除了在 __init__ 方法中定义的东西属于实例自己之外也就是在内存中也是独立的，其他的内容包括类变量、类里面的方法在内存中都只有一份所有实例公用。        多说一句，其实实例化的时候先执行__new__方法，该方法调用__init__方法。"""# 在 __init__ 方法里定义的变量是实例变量，实例独享的。通过实例调用变量或者其他资源是先找实例本身，如果没有就找类的。# 比如类变量和实例变量同名，你通过实例访问这个变量时，它会给你返回实例变量的值。# 加 "_" 表示私有变量，不过使用 "_" 也可以通过某种方式直接访问，所以要想使用严格的私有变量要使用 "__" 双下划线。self._Var2 = ""print("我是构造函数 __init__")def __del__(self):"""析构函数，当实例对象删除时候调用，所以不需要设置参数，你也传递不了参数。它是在实例销毁的时候自动调用的。对于python解释器来说，它有垃圾回收机制，只要有实例存在解释器就认为这个类被使用。如果你del这个实例，其实你删除的是这个实例，也就意味着切断了实例和类的关系，当解释器发现某个类没有被引用了就可以在内存中删除了。实例保存的是指向类的指针，实例放在栈里，类放在堆里。基本数据类型放在栈里，非基本数据类型真实的数据都是在堆里，而这个变量名在栈里。这个方法你通常不用写。"""print("我是析构函数 __del__")def myMethod(self):"""为什么类里面的每一个方法都是有self呢？因为我们调用的时候虽然是通过实例名称来调用，但是实际上是OOP.myMethod(oop)这种形式，你发现它还是会自动把实例传进来，这个self就是用来接收这个实例的。所以你在自己的方法里面可以访问变量。实例 oop 本身没有 myMethod()方法，之所以可以调用成功就是 OOP.myMonth(oop) 完成的。对于实例来说类里面的方法都是公用的，你实例化多个对象其实这些对象是多个，但是它们所公用的类方法和类变量在内存中也只有一份，哪个个实例调用这个方法那么这个self就是哪个实例。记住一句话实例调用方法都是对实例自身进程操作的。再说详细点，2个针对于同一个类的实例，A实例操作一个方法会影响B实例么？显然不能，这就是self必须存在的原因，在JAVA中也是一样，只是它使用this。:return:"""print("自定义方法")# 设置成属性用于获取内部变量
    @propertydef Var(self):return self._Var2# 设置成属性形式赋值给内部变量，这个必须写在@property下面
    @Var.setterdef Var(self, value):self._Var2 = valuedef main():oop = OOP()oop1 = OOP()# 调用实例的 __call__函数
    oop()# 通过属性方式修改变量oop.Var = "world"print(oop.Var)# 判断是否有某种属性# print(hasattr(oop, "_var1"))# 修改不可变对象（类变量）print("通过实例oop查看类变量var1的值：", oop.var1)print("通过实例oop1查看类变量var1的值：", oop1.var1)print("通过实例oop修改类变量var1的值：改为100")oop.var1 = 100print("通过实例oop查看类变量var1的值：", oop.var1)print("通过实例oop1查看类变量var1的值：", oop1.var1)# 从值上看感觉类变量也属于实例，因为修改不影响，下面打印id你就看出来了# print("通过实例oop查看类变量var1的内存地址：", id(oop.var1))# print("通过实例oop1查看类变量var1的内存地址：", id(oop1.var1))# print("通过实例oop修改类变量var1的值：改为100")# oop.var1 = 100# print("通过实例oop查看类变量var1的内存地址：", id(oop.var1))# print("通过实例oop1查看类变量var1的内存地址：", id(oop1.var1))# 修改类变量可变类型变量print("oop实例向list1添加一个元素A")oop.list1.append("A")print("oop的 list1 内容为：", oop.list1)print("oop1的 list1 内容为：", oop1.list1)if __name__ == '__main__':main()

#!/usr/bin/env python
# -*- coding: utf-8 -*-class A:# 类变量a = 11def __init__(self, x, y):# 实例变量self.x = xself.y = ya1 = A(1, 2)
# 这里你以为是修改的类A里面的a吗？其实不是，为什么，看下面
a1.a = 100
"""
这样定义其实会让a1这个实例多一个bb属性出来（新建到a1这个实例中），
所以上面那个a1.a 其实并不是A类里面的类变量a，而是属于实例自己的
"""
a1.bb = 200
print(a1.x, a1.y, a1.a, a1.bb)  # 这也就是a1为什么会有bba2 = A(5, 6)
# 这里的a值还是11，a2这个实例本身没有a这个变量，但是它自己没有就会向上查找，它的上一级就是A这个类
print(a2.x, a2.y, a2.a)A.a = 500  # 这样才会修改类变量，修改之后实例化的对象(之前或者之后)理论上都受到影响
print(A.a)
a3 = A(8, 9)
print("实例a3的a: ", a3.a)print("实例a2的a: ", a2.a)
# a1之所以不受影响是因为之前 a1自己定义了一个a属性，这样它自己就有a属性，从而就不用去找类的a属性了
print("实例a1的a: ", a1.a)

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# Author: rex.cheny
# E-mail: rex.cheny@outlook.comclass TestObj(object):# 类变量var1 = 999def __init__(self, name, age):self.name = nameself.age = ageself.list1 = ['A', 'B']self.set1 = (1, 2)self.dic1 = {"a": "a", "b": "b"}def main():TO = TestObj(name="Tom", age=23)print(TO.__dict__)TO.name = "张三"print(TO.__dict__)if __name__ == '__main__':main()

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# Author: rex.cheny
# E-mail: rex.cheny@outlook.comclass TestObj(object):# 类变量var1 = 999def __init__(self, name, age):self.name = nameself.age = ageself.list1 = ['A', 'B']self.set1 = (1, 2)self.dic1 = {"a": "a", "b": "b"}def main():# TO = TestObj(name="Tom", age=23)# print(TO.__dict__)# TO.name = "张三"# print(TO.__dict__)# 通过类来调用print(TestObj.__dict__)if __name__ == '__main__':main()

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# Author: rex.cheny
# E-mail: rex.cheny@outlook.comclass TestObj(object):# 类变量var1 = 999def __init__(self, name, age):self.name = nameself.age = agedef main():TO = TestObj(name="Tom", age=23)# 打印实例print(TO)if __name__ == '__main__':main()

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# Author: rex.cheny
# E-mail: rex.cheny@outlook.comclass TestObj(object):# 类变量var1 = 999def __init__(self, name, age):self.name = nameself.age = age# 定义__str__方法def __str__(self):return "我是TestObj"def main():TO = TestObj(name="Tom", age=23)# 打印实例print(TO)if __name__ == '__main__':main()

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# Author: rex.cheny
# E-mail: rex.cheny@outlook.comclass TestObj(object):# 类变量var1 = 999def __init__(self, name, age):self.dic1 = {}def __getitem__(self, item):print("__getitem__", item)return self.dic1[item]def __setitem__(self, key, value):print("__setitem__", key, value)self.dic1[key] = valuedef __delitem__(self, key):print("__deleteitem__", key)def main():TO = TestObj(name="Tom", age=23)TO["name"] = "Lucy"TO["age"] = 23print(TO.dic1)print(TO["name"])del TO["name"]if __name__ == '__main__':main()

#!/usr/bin/env python
# -*- coding: utf-8 -*-class Company(object):def __init__(self, employee_list):self.employee = employee_listdef __getitem__(self, item):return self.employee[item]company = Company(["Tom", "Lucy", "Lily"])
print(company[:2])for item in company:print(item)

#!/usr/bin/env python
# -*- coding: utf-8 -*-"""
正常使用try语句我们是这样的
"""
def exe_try():dic1 = {"A": "2"}try:print(dic1["B"])except KeyError as e:# 抛出异常执行这里print("KeyError")else:# 不抛出异常执行这里print("没有异常")finally:# 无论是否抛出异常最后都执行这里print("finished")# exe_try()"""
你是否想过一个问题，打开文件会抛出异常，通常打开文件后也需要关闭文件流，为什么用 with open()语句可以不用手动关闭文件流呢？
这就是上下文管理器
"""class Sample:def __init__(self):# 首先执行这个方法print("__init__")def __enter__(self):# 然后会自动调用这个方法，可以理解为获取资源print("__enter__")return selfdef __exit__(self, exc_type, exc_val, exc_tb):# 这个函数会自动调用，当跳出with语句的时候，目的是为了释放资源print("__exit__")def toDo(self):print("to do something")# 这个用法是不是很像 with open()呢？
with Sample() as sample:sample.toDo()"""
__enter__和__exit__构成了上下文管理器
"""

#!/usr/bin/env python
# -*- coding: utf-8 -*-"""
如何把上下文管理器更加简化一下呢？
"""import contextlib@contextlib.contextmanager # 这个装饰器把下面的函数包装成上下文管理器，主要利用了yiele的特性
def myFun(arg1):print("begin", arg1)  # 相当于 __enter__ 里面的代码yield {}  # 这里必须有个生成器print("finished")  # 相当于 __exit__ 里面的代码with myFun("AAA") as my:print("BBB")

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# Author: rex.cheny
# E-mail: rex.cheny@outlook.com__metaclass__ = typeclass TestObj(object):def __init__(self, name, age):self.name = nameself.age = age# 定义__str__方法def __str__(self):return "我是TestObj"def main():TO = TestObj(name="Tom", age=23)print(type(TO))print(type(TestObj))if __name__ == '__main__':main()

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# Author: rex.cheny
# E-mail: rex.cheny@outlook.comdef __init__(self, name, age):self.name = nameself.age = age"""
TestObj 对象名称
type() 函数
"TestObj" 类名称
(object,) 继承自哪里，可以为空
{} 方法名称和方法，字典形式 方法就是上面定义的
"""
TestObj = type("TestObj", (object,), {"__init__": __init__})def main():TO = TestObj(name="Tom", age=23)print(type(TO))print(type(TestObj))if __name__ == '__main__':main()

a = 1
print(type(1), " 生成1")
print(type(int), " 生成int")
print(type(type), " 生成type")

# 基类
class MyClass:pass# object是所有类都要继承的类也就是最顶层的类，或者说所有类的父类，类的祖先print("MyClass的基类是：", MyClass.__bases__)
print("type的基类是：", type.__bases__)
print("object的type是：", type(object))
print("Object的基类是：", object.__bases__)

#!/usr/bin/env python
# -*- coding: utf-8 -*-class A:passclass B(A):def test(self):print("Test")b = B()print(isinstance(b, B))
print(isinstance(b, A))print(type(b) is A)

#!/usr/bin/env python
# -*- coding: utf-8 -*-class A:def __init__(self):print("A")class B(A):def __init__(self):print("B")# 调用父类方法，Python2写法# super(Son, self).__init__()# 调用父类方法，Python3简化写法super().__init__()  #class C(A):def __init__(self):print("C")super().__init__()  #class D(B, C):def __init__(self):print("D")super().__init__()  ## 打印D的MRO看一下
print(D.__mro__)d = D()

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# Author: rex.cheny
# E-mail: rex.cheny@outlook.comclass TestObj(object):def __init__(self, name, age):self.name = nameself.age = ageprint("__init__方法执行了")def __new__(cls, *args, **kwargs):"""该方法会在__init__之前调用.:return:"""print("__new__方法执行了")"""如果你的类里自己重写了 __new__ 方法那么下面的这个返回必须写，否则你定义的类将不会执行__init__方法。这个类是继承自object，那么你其实并不知__new__原本具体都做什么，出于某些原因你必须要重写__new__方法，当你的逻辑写完之后，就要通过 object.__new__(cls) 来调用父类的__new__方法，完成初始化。"""return object.__new__(cls)def main():TO = TestObj(name="Tom", age=23)print(TO.name)if __name__ == '__main__':main()