Python学习历程之面对对象浅识

# ===============================封装====================================
# class Bar:
#     def __init__(self,name,age,content):
#         self.name = name
#         self.age = age
#         self.content = content
#     def foo(self):
#         print(self.name,self.age,self.content)
# b = Bar('Join','18','上大学')
# b.foo()

# ================================继承===================================
# -------------------单继承---------------------
# class fa():
#     def eat(self):
#         print("father is eating")
#     def sleep(self):
#         print("father is sleeping")
#     def sing(self):
#         print("father is singging")
#
# class so(fa):
#     def school(self):
#         print("son is going to school")
#     def eat(self):
#         print("son is eating")
#     def sing(self):
#         print("son is singging")
#     def sleep(self):
#         super(so,self).sleep()
#         print("son is sleeping")
# s = so()
# s.school()
# s.sleep()
# s.eat()
# s.sing()

# --------------------多继承 -----------------------
# class f1:
#     def a(self):
#         print("f1.a")
# class f2:
#     def a(self):
#         print("f2.a")
# class son(f2,f1):
#     def a(self):
#         super(son,self).a()
#         print("s.b")
# s = son()
# s.a()
# 多继承时：
#     左侧优先
#     一条道走到黑
#     同一个根时，最后再访问根
# class BaseRequest():
#     def __init__(self):
#         print("BaseRequest.init()")
# class RequestHandler(BaseRequest):
#     def __init__(self):
#         print("RequestHandler.init")
#         BaseRequest.__init__(self)
#     def server_forver(self):
#         print('RequestHandler.server_forever')
#         self.process_request()
#     def process_request(self):
#         print('RequestHandler.process_request')
# class Minx:
#     def __init__(self):
#         print("Minx.init")
#     def process_request(self):
#         print('minx.process_request')
# class Son(Minx,RequestHandler):
#     def __init__(self):
#         print("Son.init()")
#     pass
# obj = Son()
# obj.server_forver()

# class Bar():
#     con = 'son' # 类静态字段 直接类名就可以调用
#     def __init__(self,name):
#         self.name = name # 普通对象，需要对象调用
#     def p(self):
#         print(self.name)
#     @staticmethod  # 相当于模块对函数的封装
#     def stat():
#         print("Im starticmethod") # 保存在类中，直接可通过类名调用
#     @classmethod
#     def classmethod(cls):
#         #cls 是类名
#         print(cls)
#         print("classmethod")
#     @property
#     def per(self):
#         return 1
#     @per.setter
#     def per(self,val):
#         self.name = val
#     @per.getter
#     def per(self):
#         return self.name
#     @per.deleter
#     def per(self):
#         self.name = ''
# b = Bar('teacher')
# b.con = "father"
# print(b.con)
# print(b.name)
# Bar.stat()
# Bar.classmethod()
# print(b.name)
# b.per = 'sdfsfsdfj'
# print(b.per)
# del b.per
# print(b.name)

# 分页列表

# class Page:
#     def __init__(self,val):
#         try:
#             page = int(val)
#         except Exception as e:
#             page = 1
#         self.val = page
#     @property
#     def start(self):
#         start = (self.val-1) * 10
#         return start
#     @property
#     def end(self):
#         end = self.val * 10
#         return end
#
# li = []
# for i in range(1000):
#     li.append(i)
#
# while True:
#     ipt = input("请输入要查看的Page:")
#     page = Page(ipt)
#     print(li[page.start:page.end])

# ================  成员修饰符  ======================
# -------------共有成员 与 私有成员
# class foo:
#     def __init__(self):
#         self.__name = ''
#         self.name = ''
#     @property
#     def per(self):
#         print(self.name)
#     @per.setter
#     def per(self,name):
#         self.__name = name
#     @per.getter
#     def per(self):
#         return self.__name
#     @per.deleter
#     def per(self):
#         self.__name = ''
#     def pname(self):
#         print(self.__name)
#
# f = foo()
# f.per = '123'
# print(f.per)
# print(f.pname())
# del f.per
# print(f.pname())

# =======================特殊成员=========================
# __init__ 类()自动执行
# __call__ 对象() 类()() 自动执行
# __int__  int(对象)
# __str__  str(对象)
# __add__  + 返回值可以自定义
# __del__   析构函数 对象被销毁时自动执行
# __dict__   对对象的成员封装成字典返回
# __doc__  模块注释
# __getitem__ 过的列表的元素
# __setitem__ 设置值
# __delitem__ 删除值
# def __call__(self,*args,**kwargs):
# class foo:
#     def __init__(self):
#         print('Init')
#     def __call__(self, *args, **kwargs):
#         print('call')
# obj = foo()
# obj() # 自动触发__call__()方法
# foo()()

# class foo:
#     def __init__(self,n,a):
#         self.n = n
#         self.a = a
#     def __str__(self):
#         return '%s-%s' % (self.n,self.a)
# f = foo('alex','18')
# print(f)

# class foo:
#     def __init__(self,name,age):
#         self.name = name
#         self.age = age
#     def __add__(self, other):
#         return 'xxoo'
# obj1 = foo('alex',19)
# obj2 = foo('eirc',66)
# r = obj1+obj2
# # 俩对象相加时，自动执行第一个对象的 __add__方法，并且将第二个对象作为参数传入
# print(r,type(r))

# ================== MetaClass===============================
# 创建类的几种方法
# class foo(object):
#     def func(self):
#         print("第一种创建方式")
# obj  = foo()
# obj.func()
# foo1 = type('foo1',(object,),{'func': lambda x: '第二种创建方式'})
# obj = foo1()
# obj.func()

# class MyType(type):
#     def __init__(self,what,bases=None,dict=None):
#         print("1 =======> MyType Init")
#         super(MyType,self).__init__(what,bases,dict)
#     # def __new__(cls, *args, **kwargs):
#     #     print("MyType New")
#     def __call__(self, *args, **kwargs):
#         print("2 =======> MyType Call")
#         obj = self.__new__(self,*args, **kwargs)
#         self.__init__(obj)
#
# class Foo(object,metaclass=MyType):
#     def __init__(self):
#         print("4 =======> Foo Init")
#     def __new__(cls, *args, **kwargs):
#         print("3 =======> Foo New")
#         return object.__new__(cls, *args, **kwargs)
# # 第一阶段：解释器从上到下执行代码创建Foo类
# # 第二阶段：通过Foo类创建obj对象
# obj = Foo()

# ======================异常捕获=========================
# def Foo(num):
#     try:
#         li = [1,2,3]
#         print(li[num])
#         if num > len(li):
#             raise  IndexError('现在已经有错误了')
#     except IndexError as e:
#         print('IndexError:',e)
#     except ValueError as e:
#         print('ValueError:',e)
#     except Exception as e:
#         print('Error:',e)
#     else:
#         print(li[:])
#     finally:
#         print(li)
# Foo(10)

# ========================== 反射 ================================
# 通过字符串的形式操作对象成员
# class Foo:
#     def __init__(self,name,age):
#         self.name = name
#         self.age = age
#
#
# obj = Foo('alex','18')
# obj.name
# b = 'name'
# print(obj.__dict__[b])
# ---------------------------------------
# getattr() 去什么里面获取什么东西
# setattr() 设置字段
# hasattr() 判断是否有字段
# delattr() 删除字段
# -------------------------------------------
# setattr(obj,'k1','v1')
# print(getattr(obj,b))
# print(getattr(obj,'k1'))
# delattr(obj,'k1')
# print(getattr(obj,'k1'))

# ---------------------- 单例模式 ---------------------------
# class Foo:
#     def __init__(self,name,age):
#         self.name = name
#         self.age = age
#     def show(self):
#         print(self.name,self.age)
# v = None
# while True:
#     if v :
#         v.show()
#     else:
#         v = Foo('alex',123)
#         v.show()

# class  Foo:
#     __v = None
#     def __init__(self):
#         print('对象被创建了')
#     @classmethod
#     def get_instatnce(cls):
#         print('单例模式创建对象')
#         if cls.__v:
#             return cls.__v
#         else:
#             cls.__v = Foo()
#             return  cls.__v
# obj = Foo.get_instatnce()