面向对象初识到进阶
# 面向对象结构：
# 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)