关键词：
面向对象初识到进阶
# 面向对象结构：
# 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)js高级进阶javascript初识面向对象(代码片段)
...题挑战赛第2期参赛话题：面试宝典目录前言一，面向对象介绍二，创建生成实例三，继承四，super关键字写在最后前言本篇主要讲解了什么是面向对象，如何创建使用类，super关键字的使用以及注意事... 查看详情
python面向对象进阶(代码片段)
...好的使用面向对象编程思想进行程序开发，我们还需要对Python中的面向对象编程进行更为深入的了解。@property装饰器之前我们讨论过Python中属性和方法访问权限的问题，虽然我们不建议将属性设置为私有的，但是如果直接将属性... 查看详情
python面向对象编程进阶(代码片段)
前言上上篇我们讲解了Python面向对象编程的基础知识，《Python基础篇：面向对象怎样炼成的》这篇我们继续来讨论面向对象编程相关的内容。目录前言可见性和属性装饰器动态属性静态方法和类方法继承和多态总结可见... 查看详情
进阶学python：python面向对象基础！(代码片段)
什么是编程范式？在了解面向对象编程之前，我们需要了解三大编程范式以及其之间的区别和利弊即：面向过程编程、函数式编程、面向对象编程。编程：是程序员用特定的语法+数据结构+算法组成的代码来... 查看详情
python进阶—面向对象编程(代码片段)
...程面向对象编程的特性封装继承多态面向对象编程的优势Python的类属性与类方法Python类的实例化Python的对象属性与对象方法Python类的继承面向对象思想面向对象不仅是一种编程思想，更是解决问题和处理数据的方式，面... 查看详情
面向对象进阶(代码片段)
...的设计领域所采用,并在Lisp和面向对象方面取得了成绩。2python面向对象中的反射：通过字符串的形式操作对象相关的属性。python中的一切事物都是对象（都可 查看详情
面向对象进阶(代码片段)
...计领域所采用,并在Lisp和面向对象方面取得了成绩。 2python面向对象中的反射：通过字符串的形式操作对象相关的属性。python中的一切事物 查看详情
python面向对象编程进阶(代码片段)
python面向对象编程进阶 一.isinstance(obj,cls)和issubclass(sub,super)isinstance(obj,cls)检查是否obj是否是类cls的对象1classFoo(object):2pass34obj=Foo()56isinstance(obj,Foo)issubclass(sub,super)检查sub类是否是super类的派生类1class 查看详情
面向对象进阶(代码片段)
...中，类就是一组用来描述如何生成一个对象的代码段。在Python中这一点仍然成立：>>>classObjectCreator(object):…pass…>>>my_object=ObjectCreator()>>>printmy_object<__main__.ObjectCreatorobjectat0 查看详情
进阶学python：python面向对象系列之魔法方法！(代码片段)
本篇主要介绍面向对象编程中类的魔法属性，这些魔法属性均有其特殊的功能，即执行某些操作时，会自动触发这些魔法方法的执行，了解这些魔法方法可以更好的了解面向对象编程的实现原理；在学习魔法... 查看详情
面向对象初识(代码片段)
..._(self,*args):#初始化方法，调用类时触发方法，调用之前，python帮我们创建了一个空对象selfself.name=args[0]#给self的属性赋值self.age=args[1]defwalk(self,n):#方法，必须传self参数，且必须写在第一个，后面还可以有其 查看详情
进阶学python：python面向对象之属性方法(代码片段)
这次我们主要介绍类中定义的各种属性，例如类属性、实例属性、类的私有属性，以及各种方法，例如实例方法、类方法、静态方法以及property属性方法等相关知识。🚀看一段代码classTool(object):dog_type="Huskie&... 查看详情
python全栈--9.1--面向对象进阶-super类对象成员--类属性-私有属性查找源码类对象步骤类特殊成员isinstanceissubclass异常处理(代码片段)
...向对象三大特性：封装、继承和多态 本篇将详细介绍Python类的成员 查看详情
初识vue2.0：vuex进阶(代码片段)
...使用单一状态树，应用的所有状态会集中到一个比较大的对象，当应用变得非常复杂时，store对象就有可能变得相当臃肿。为了解决以上问题，Vuex允许我们将store分割成模块（module），每个模块拥有自己的state、mutation、action、get... 查看详情
python------面向对象进阶反射详解(重点）(代码片段)
一.反射 通过字符串映射或者修改程序运行时的状态，属性，或者方法。1.getattr(object,name,default=None)2.hasattr(object,name)3.setattr(x,y,v)4.delattr(x,y)1classDog(object):2def__init__(self,name):3self.name=name45defeat(sel 查看详情
面向对象进阶1(代码片段)
...父母的基因，遗产，所以子女会拥有父母的部分特征而在python中，子类继承父类就是子类完全拥有父类所具备的属性及技能为什 查看详情
面向对象(进阶)(代码片段)
类的成员可分三大类:字段,方法和属性注:所有成员中,只有普通字段的内容保存在对象中,即:根据此类创建了多少对象,在内存中就有多少个普通字段.而其他的成员,则都是保存在类中,即:无论对象的多少,在内存中只创建一份一.字... 查看详情
面向对象编程进阶(代码片段)
python内置函数isinstance(obj,class) 判断一个对象是否是已知的类型,类似type()isinstance语法:isinstance(object,classinfo)object是实例/对象classinfo可以是直接或间接类名,基本类型或者由他们组成的元组返回值如果对象的类型与classinfo相... 查看详情