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)
posted @ 2019-06-09 00:11  爱文飞翔  阅读(373)  评论(0编辑  收藏  举报