Python中面向对象初识到进阶

面向对象初识到进阶

# 面向对象结构：
# class 类名:
#     def __init__(self,参数1,参数2):
#         self.对象的属性1 = 参数1
#         self.对象的属性2 = 参数2
#
#     def 方法名(self):pass
#
#     def 方法名2(self):pass
#
# 对象名 = 类名(1,2)  #对象就是实例，代表一个具体的东西
#                   #类名() : 类名+括号就是实例化一个类，相当于调用了__init__方法
#                   #括号里传参数，参数不需要传self，其他与init中的形参一一对应
#                   #结果返回一个对象
# 对象名.对象的属性1   #查看对象的属性，直接用 对象名.属性名 即可
# 对象名.方法名()     #调用类中的方法，直接用 对象名.方法名() 即可

# 类（抽象的 一个模子  大范围的）  是具有相同属性和相似功能的一类事物，可以清楚的知道这一类事物有什么属性，有什么动作，
# 但是不能知道这些属性的具体的值
#
# 对象（具体的）===实例
# 给类中所有的属性天上具体的值就是一个对象或者实例
# 只有一个类但是可以有多个对象都是这个类的对象

# 实例化
# 实例=类名()
# 首先开辟空间，调用__init__方法  吧开辟的空间传递个self参数
# init 方法中一般完成 ：把属性的值存储在self的空间里   =====对象的初始化
# self这个地址会作为返回值  返回给实例

# 方法 :定义在类里的函数  并且还带有self参数

# 实例化所经历的步骤：*****
# 1、类名() 之后的第一件事：开辟一块内存空间
# 2、调用__init__方法把空间的内存地址作为self参数传递到函数内部
# 3、所有的这个对象需要使用的属性都需要和self关联起来
# 4、执行完__init__中的逻辑之后  self 变量会自动的被返回到调用处(发生实例化的地方)

例子
# 定义一个圆形类  半径是这个圆形的属性  实例化一个半径为5的圆形  一个半径为10的圆形
# 面积 周长
from cmath import pi
class Yuan():
   def __init__(self,r):
      self.r=r
   def mianji(self,):
      return pi*self.r*self.r

one=Yuan(5)
one.mianji(one)

# 类和对象的关系？
# 类 是一个大范围 是一个模子  它约束了事物有哪些属性  但是不能约束具体的值
# 对象 是一个具体的内容 是模子的产物 它遵循了类的约束  同事给属性赋上了具体的值

# 类中的变量是静态变量  对象的变量只属于对象本身
# 每个对象调用每一个属性的时候会优先在自己的空间中找
# 找不到就会引用类中的，
# 对于类来说  所有的对象都是可以读取的  并且读取的是同一个

组合：

# 组合就是一个类的对象是另外一个类对象的属性
# 对象变成了一个属性

# 组合 一个类的对象是另一个类对象的属性
# 两个类之间有 什么有什么的关系 ：班级有学生 学生有班级 班级有课程 学生有成绩

例子：

# class Student():
#  def __init__(self,name,sex,age,number,clas,phone):
#     self.name=name
#     self.sex=sex
#     self.age=age
#     self.number=number
#     self.clas=clas
#     self.phone=phone
# class Clas():
#  def __init__(self,cname,begint,teacher):
#     self.cname=cname
#     self.begint=begint
#     self.teacher=teacher
# 查看的是a的开班日期是多少
# 查看的是b的班级开班日期是多少
# py22=Clas('python22','2019-4-26','小白')
# py23=Clas('python23','2019-5-28','大白')
# a=Student('a','man',20,19,'py2',18818883537)
# b=Student('b','man',21,23,'py2566',12345253)
# a.clas=py23
# b.name=py23
# print(b.name.teacher)
# print(a.clas.begint)

继承:# 调用了父类的初始化，去完成一些通用属性的初始化

# 单继承   
# 调子类的 子类自己有的时候
# 调父类的 子类自己没有的时候
# 调子类和父类：子类和父类都有

# 多继承
# 一个类有多个父类 ，在调用父类方法的时候谁里的近就调谁

# 单继承
# class D:
#  def func(self):
#     print("in D")
# class C(D):pass
# class A(C):
#  def func(self):
#     print("in A")
# class B(A):pass
# B().func()

# 多继承 多个父类
# class A:
#  def func(self):
#     print("in A")
#
#
# class B:
#  def func(self):
#     print("in B")
#
#
# class C(A, B): pass  # in A


# class C(B,A):pass       #in B
# C().func()

怎么继承
# class A:
#  def func(self):print('A')
# class B(A):
#  def func(self): print('B')
# b=B()
# b.func()
# 写代码的时候，是先有的父类还是先有的子类？
# 1、在加载代码的时候  需要先加载父类  所以父类写在前面
# 2、从思考的角度出发总是先把子类都写完，发现重复的代码，再把重复的代码放在父类中

# 类
# class 类名:
#  静态变量='值'
#  def 函数(self):
#     '函数体内容'
#     pass
# 所有的变量和函数的地址都存储在类的命名空间里


# 对象
   # 对象=类名()
# 怎么用
   # 类能做什么用？：
   # 1、可以实例化对象
   # 2、可以操作静态变量
# 什么时候是对类中的变量赋值或者去使用类中的变量
   # 类名.变量名='值'
   # print(类名.变量名) 查看
   # print(对象名.变量名) 如果对象本身没有这个名字
# 什么时候对对象中的变量赋值
   # 对象.变量名
   # self.变量名

#
# class A:  #写在一个类中的变量还是函数名都是存储在这个类中
#  role = []
#
#  def __init__(self): #实例化的时候总是先开空间在调用init，
#     #调用init的时候总是把新开的空间作为参数传递给self
#     self.l = []
#
#  def append(self, obj):
#     self.l.append(obj)
#
#  def pop(self, index=-1):
#     self.l.pop(index)
# print(A.role)
# a=A()
# s='asdffas234'
# a.append(s)#对象.方法名

#
# class B:
#  def append(self):print('bbbb')
# class C:
#  def append(self):print('cccc')
# b=B()
# d=C()
# b.obj=[]
# b=B()
# b.append()
# d=C()
# d.append()
# 所有的对象调用方法 就看这个对象是那一个类的对象
# 不要担心所有的类的方法都是一样的名字，并不影响的

多态：

# 多态：一个类型表现出来的多种状态
# 支付表现出的 微信支付和苹果支付这两种状态
# 多态:一个类表现出的多种形态，实际上是通过继承来完成的
# 如果狗类继承动物类，猫也继承动物类，那么我们就说猫对象也是动物类型的
# 狗的对象也是动物类型的，在这个例子里，动物这个类型表现出了猫和狗的形态

# Python中处处是多态
# Java中
# def eat(猫或狗的对象,str 食物):
# 	print('动物类型保证了猫和狗的对象都可以被传递进来')

鸭子类型：

# 鸭子类型：
# 子类继承父类，我们说子类也是父类这个类型的
# 在Python中一个类是不是属于某一个类型
# 不仅仅可以通过继承来完成
# 还可以是不继承，但是如果这个类满足了某些类型的特征条件
# 我们就说他长得像这个类型，那么他就是这个类型的鸭子类型

# ***在Python中一个类可以是多个类的鸭子类型

# tuple元组类：是可哈希的，又不依靠继承哈希类来判定是不是可哈希类型
# 元组类是可哈希类型的鸭子类型
# tuple是迭代器，不是依靠继承迭代类来判定是不是迭代类型
# tuple是可迭代的，看他长得像（内部实现了__iter__)


# 所有的类都必须继承object类
# 见到抽象类的写法，一定要知道要在子类中实现同名方法

经典类和新式类：

# 新式类和经典类
# 新式类：继承object，Python3中都是新式类,Python2主动继承object才是新式类
# 经典类:只在Python2中，不继承object默认是经典类

# 继承顺序：
# 1、深度优先-经典类
# 2、广度优先-新式类
   #查看广度优先的顺序，类名.mro()
   #遵循的算法C3

抽象类：

# 抽象类
# 为什么要用抽象类?
#为了规范子类必须实现和父类的同名方法

# 抽象类用到的格式
   # 1、不需要模块的
# class 父类：
#  def 子类必须实现的方法名(self,参数们):pass
#  raise NotImplementedError('提示信息')
# class 子类（父类）:
#  def 父类的要求实现的方法（self,参数）
#     print("code")
   # 2、需要模块的
# from abc import ABCMeta,abstractmethod
# class Foo(metaclass=ABCMeta):
#  def 子类必须实现的方法名(self,参数们):pass
# class 子类(父类)：
#  def 父类的要求实现的方法（self,参数）
#     print("code")



# 归一化设计:
# class A:
#  def 同名功能(self):pass
# class B:
#  def 同名功能(self):pass
# def 函数名(obj):
#  obj.同名功能

反射：

# 反射：用字符串类型的名字来操作这个名字对应的函数、实例变量、绑定方法、各种方法
# 反射相关：hasattr,getattr
# 字符串类型的变量名，采用getattr(对象，字符串变量名)就可以获取变量值

# 有些时候明明知道一个变量的字符串数据类型的名字，
# 想直接调用但是调用不到，那么就得使用反射了

# 1、反射对象的实例变量/绑定方法
# 2、反射类的静态变量、其他方法
# 3、反射模块中的所有变量
   #被导入的模块
   #当前执行的py文件-脚本
# class Person:
#  def __init__(self,name,age):
#     self.name=name
#     self.age=age
# w=Person('anwen',20)
# d=Person('wudi',21)
# ret=getattr(w,'name')
# print(ret)
# print(w.name)
# print(w.age)



import sys
w='anwen'
print(getattr(sys.modules['__main__'],'w'))

# 1、反射对象的 实例变量、绑定方法
# 2、反射类的 静态变量、其他方法
# 3、模块中的 所有变量：被导入的模块和当前执行的py文件

# class A:
#  Role='anwen'
#  def __init__(self):
#     self.name='yage'
#     self.age=18
#  def func(self):
#     print('wahaha')
#     return 555
# a=A()
# print(getattr(a,'name'))    #反射对象的实力变量
# print(getattr(a,'func')())  #反射对象的绑定方法
# print(getattr(A,'Role'))    #反射类的静态变量

# import a      #引入模块中的任意变量
# print(getattr(a,'sww'),a.sww)
# getattr(a,'sww')()
# print(getattr(a,'lst'),a.lst)
# print(getattr(a,'dic'),a.dic)
# print(getattr(a,'we'),a.we)


import sys
cat='maomao'
dog='gougou'
def pig():
   print('zhuzhu')
print(getattr(sys.modules['__main__'],'cat'))
print(getattr(sys.modules['__main__'],'dog'))
getattr(sys.modules['__main__'],'pig')()

反射例子
class A:
   Role='安文'
   def __init__(self):
      self.name='anwen'
      # self.age=23
   def func(self):
      print('wahaha')
      return 555
a=A()
# print(hasattr(a,'sex'))
# print(hasattr(a,'name'))
# print(hasattr(a,'age'))
# print(hasattr(a,'func'))
# if hasattr(a,'func'):
#  if callable(getattr(a,'func')):
#     getattr(a,'func')()
if hasattr(a,'name'):
   if callable(getattr(a,'name')):
      getattr(a,'name')
# callable:检测对象是否可被调用，可被调用指的是对象能否使用()括号的方法调用

封装：

# 封装：就是把属性或者方法装起来
#
# 广义：把属性和方法装起来，外面不能直接调用了，要通过类的名字来调用
# 狭义：把属性和方法藏起来，外面不能调用了，只能在内部偷偷调用

# 封装：
# 广义上的：装起来
# 狭义上的：藏起来，__名字
# 方法名私有化，实例变量私有化，静态变量私有化
# 私有化特点：只能在类的内部使用不能再类的外部使用
# 私有的各种静态变量和方法不能被子类继承

# 给一个名字加上‘__’双下划线的时候,这个名字就变成了一个私有的
# 所有私有的内容或者名字在类的内部能调用，在类的外部不能调用

# 所有的私有化都是为了让用户不在外部调用类中的某个名字
# 如果完成私有化，那么这个类的封装度就更高了
# 封装度越高各种属性和方法的安全性也越高 但是代码越复杂

# class User:
#  def __init__(self,name,passwd):
#     self.name=name
#     self.__pwd=passwd   #私有的实例变量、私有的对象属性#给一个名字加上‘__’双下划线的时候
#  def get_pwd(self):          #不能改只能看,私有+某个get方法实现的
#     return self.__pwd
#  def change_pwd(self):pass   #表示必须调用自定的修改方式来进行变量的修改，私有+change方法实现
# alex=User('anwen','1234')
# print(alex.pwd) #报错
# print(alex.__pwd) #报错
# print(alex.get_pwd())


# 加了双下划线的名字为什么不能从外部调用了？
# class User:
# 	__Country='china'
# 	__Role='安文'
# 	def func(self):
# 		print(self.__Country)
# 在类的内部使用的时候，自动的把当前这句话所在的类的名字
# 拼在私有变量前完成变形
# print(User._User__Country)
# print(User._User__Role)
# __Country --> _User__Country
# __Role  -->_User__Role

# 私有的内容能不能被子类使用或继承？不能
# class Foo(object):
#  def __init__(self):
#     self.func()
#  def func(self):
#     print('in Foo')
# class Son(Foo):
#  def func(self):
#     print('in Son')
# Son() #in Son

# class Foo(object):
#  def __init__(self):
#     self.__func()   #在哪一个类执行__func，就把当前类名拼在__func里-->self._Foo__func()
#  def __func(self):
#     print('in Foo')
# class Son(Foo):
#  def __func(self):
#     print('in Son')
# Son()     #in Foo

# class Foo(object):
#  def __func(self):
#     print('in Foo')
# class Son(Foo):
#  def __init__(self):
#     self.__func()
# Son()   #报错


# 在其他语言中数据的级别都有哪些，在Python有哪些
# public共有的类内类外都能用，父类子类都能用  Python支持
# protect 保护的，类内能用，父类子类都能用，类外不能用    Python不支持
# private 私有的，本类的内部能用，其他地方都不能用  Python支持

单例模式：

# class Baby:
#  __instance=None
#  def __new__(cls, *args, **kwargs):
#     if cls.__instance is None:
#        cls.__instance=super().__new__(cls)
#     return cls.__instance
#  def __init__(self,cloth,pants):
#     self.cloth=cloth
#     self.pants=pants
# b1=Baby('毛衣','裤子')
# print(b1.cloth)
# b2=Baby('衬衫','黑裤')
# print(b1.cloth)
# print(b2.cloth)