04python入门—面向对象初识

面向过程和面向对象

面向过程

核心是过程 流水线思维
优点是：极大的降低了写程序的复杂度，只需要顺着要执行的步骤，堆叠代码即可。
缺点是：一套流水线或者流程就是用来解决一个问题，代码牵一发而动全身。
应用场景：一旦完成基本很少改变的场景，著名的例子有Linux內核，git。

面向对象

面向对象的程序设计的核心是对象，只要结果，不管你是如何运行的
优点是：解决了程序的扩展性。对某一个对象单独修改，会立刻反映到整个体系中，如对游戏中一个人物参数的特征和技能修改都很容易。
缺点：可控性差，无法向面向过程的程序设计流水线式的可以很精准的预测问题的处理流程与结果，存在不同改写、继承，有事对子对象的改写会影响全局

类与对象

class 类名:
    def __init__(self,参数1,参数2):
        self.对象的属性1 = 参数1
        self.对象的属性2 = 参数2

    def 方法名(self):pass

    def 方法名2(self):pass

实例对象 = 类名(1,2)  #对象的实例化

静态属性、动态属性、初始化

静态属性就是直接在类中定义的变量
动态属性就是定义在类中的方法
def  __init__(self):   这句话可以写也可以不写，只要有参数参进来的时候就必须得写；
self：在实例化时自动将对象/实例本身传给__init__的第一个参数

初始属性

print(Person.__name__,type(Person.__name__)) #查看类的名字(这里的类名是字符串类型的)
print(Person.__dict__) #查出的是一个字典，key为属性名，value为属性值
print(Person.__doc__)# 就是把注释显示出来
print(dir(Person)) #查看类的方法，以列表的形式显示出来
print(Person.__module__) #类定义所在的模块
print(Person.__class__)
print(isinstance(hy,Person))#判断对象 是否是类的实例

组合

组合：组合指的是，在一个类中以另外一个类的对象（也就是实例）作为数据属性，称为类的组合

class Jinneng:
    def change(self, obj):  # 功能是变身
        obj.height += 1000  # 变高1000

class Person:  # 定义一个人类
    role = 'person'  # 人的角色属性都是人

    def __init__(self, name):
        self.name = name
        # 能变身
        self.weapon = Weapon()
        
me= Person('egon')
me.weapon.change() 
# me组合技能变身了

classmethod类方法

classmethod 修饰符对应的函数不需要实例化，不需要 self 参数，但第一个参数需要是表示自身类的 cls 参数，可以来调用类的属性，类的方法，实例化对象等。

class A(object):
    bar = 1
    def func1(self):  
        print ('foo') 
    @classmethod
    def func2(cls):
        print ('func2')
        print (cls.bar)
        cls().func1()   # 调用 foo 方法
 
A.func2()               # 不需要实例化就能调用

staticmethod静态方法

class C(object):
    @staticmethod
    def f():
        print('runoob');
 
C.f();          # 静态方法无需实例化
cobj = C()
cobj.f()        # 也可以实例化后调用

对象、子类判断

isinstance(obj,cls)：检查obj是不是cls的对象（传两个参数，一个是对象，一个是类）
issubclass(sub,super)：检查sub是不是super的子类（传两个参数，一个是子类，一个是父类）

反射

hasattr：hasattr（object,name）判断一个对象是否有name属性或者name方法。有就返回True，没有就返回False
getattr：获取对象的属性或者方法，如果存在则打印出来。hasattr和getattr配套使用
　　　　需要注意的是，如果返回的是对象的方法，返回出来的是对象的内存地址，如果需要运行这个方法，可以在后面添加一对（）
setattr：给对象的属性赋值，若属性不存在，先创建后赋值
delattr：删除该对象指定的一个属性

对象应用反射

class Foo:
    def __init__(self):
        self.name = 'egon'
        self.age = 51
    def func(self):
        print('hello')
egg = Foo()
print(hasattr(egg,'name'))  #先判断name在egg里面存在不存在
print(getattr(egg,'name')) #如果为True它才去得到
print(hasattr(egg,'func'))
print(getattr(egg,'func'))  #得到的是地址
# getattr(egg,'func')()  #在这里加括号才能得到，因为func是方法
if hasattr(egg,'func'):
    getattr(egg,'func')()
else:
    print('没找到')

类应用反射

class Foo:
    f = 123
    @classmethod
    def class_method_dome(cls):
        print('class_method_dome')

    @staticmethod
    def static_method_dome():
        print('static_method_dome')
print(hasattr(Foo,'class_method_dome'))
method = getattr(Foo,'class_method_dome')
method()
print('------------')
print(hasattr(Foo,'static_method_dome'))
method1 = getattr(Foo,'static_method_dome')
method1()