python 面向对象(初级篇)
面向对象和面向过程
知乎上有句回答 : 面向过程是编年体；面向对象是纪传体 # 不知道会不会被告侵权 侵删哈23333333
- 面向过程:用一对代码从开始到结束描述整个任务完成的过程.
- 比如你要写一个格斗游戏
- 首先描述擂台场景
- 描述一个角色出现,另一个角色出现
- 再描述两个角色的外形 , 比如体型服装性别特征等等
- 两个人摆好架势等待用户输入
- while 用户输入>>做一次判断>>角色执行对应的动作......
- 面向对象:把构成问题事务分解成各个对象，建立对象的目的不是为了完成一个步骤，而是为了描叙某个事物在整个解决问题的步骤中的行为
- 同样是格斗游戏
- 擂台对象,描述擂台场景的构成
- 角色对象,描述任务外形技能等
- 规则对象,对比赛进行判定
类和对象
创建类和对象
类就是一个模板,模板里包含一类事物的共同特征,同时包含多个函数,函数里实现一些功能
对象则是根据模板创建的实例,具化类的特征,通过实例对象可以执行类中的函数
# 创建类 class Foo: # 创建类中的函数 def func(self): pass # 根据类Foo创建对象obj obj = Foo()
- class 关键字 表示创建类
- Foo 类名
- 创建对象,类名后边加括号即可
- 注释 类中定义的函数一般叫方法,方法的第一个参数必须是 self 稍后会讲解
面向对象的三大特性
封装
""" 封装 是对具体对象的一种抽象，即将某些部分隐藏起来，在程序外部看不到，其含义是其他程序无法调用 封装可以被认为是一个保护屏障,防止该类的代码和数据被外部类定义的代码随机访问,要访问该类的代码和数据，必须通过严格的接口控制 封装最主要的功能在于我们能修改自己的实现代码，而不用修改那些调用我们代码的程序片段 适当的封装可以让程式码更容易理解与维护，也加强了程式码的安全性。 """ class Foo1: def __init__(self,name,age,face_value): """ 构造方法,根据类创建对象时自动执行 :param name: :param age: :param face_value: """ self.name = name self.age = age self.face_value = face_value def foo(self): # 类中的方法需要通过self间接调用被封装的内容 print(self.name) # 将 'nathaniel','19','Men of God' 封装到obj的 name,age,face_score 属性中 obj = Foo1('nathaniel','19','Men of God') # self是一个形式参数,默认等于根据类创建的对象 # obj0 = Foo1('nathaniel','19','Men of God') self等于obj0 # obj1 = Foo1('nathaniel','19','Men of God') self等于obj1 # 所以,内容其实是被封装在了对象当中,每个对象都具有创建它们的类的属性,并且可以有自己不同的值 # 以上就封装好了,接下来调用 print(obj.name) # 通过对象直接调用类中的属性 obj.foo() # 调用类中的方法 class Person: """ 小游戏 1、创建三个游戏人物，分别是： 苍井井，女，18，初始战斗力10000 泷泽萝沙，女，20，初始战斗力8000 波多多，女，22，初始战斗力8100 2、游戏场景，分别： 草丛大作战，消耗200战斗力 冥想修炼，增长100战斗力 苍穹对决，消耗500战斗力 """ def __init__(self,name,gender,age,fight): self.name = name self.gender = gender self.age = age self.fight = fight def grassland(self): """ 草丛大作战，消耗200战斗力 :return: """ self.fight = self.fight - 200 def meditation(self): """ 冥想修炼，增长100战斗力 :return: """ self.fight = self.fight + 100 def sky_duel(self): """ 苍穹对决，消耗500战斗力 :return: """ self.fight = self.fight - 500 def show(self): """ 展示游戏人物当前状态 :return: """ temp = "姓名:%s ; 性别:%s ; 年龄:%s ; 战斗力:%s" % (self.name, self.gender, self.age, self.fight) print(temp) cjk = Person('苍井井', '女', 18, 10000) # 创建苍井井角色 lzl = Person('泷泽萝沙', '女', 18, 8000) # 创建泷泽萝沙角色 bdd = Person('波多多', '女', 18, 8100) # 创建波多多角色 cjk.sky_duel() # 苍井井进行了一次苍穹对决 lzl.meditation() # 泷泽萝沙进行了一次冥想修炼 bdd.grassland() # 波多多进行了一次草丛大作战 # 展示游戏人物当前状态 cjk.show() lzl.show() bdd.show()
继承
""" 继承 子类可以继承父类,父类中的属性和方法,子类可以直接使用 举个栗子 狗:"汪汪"叫,吃喝拉撒 猫:"喵喵"叫,吃喝拉撒 他们都继承动物类的属性 """ class Animal: def __init__(self,weight): self.weight = weight def action(self): print('吃喝拉撒') class Dog(Animal): # Dog类继承Animal类 def __init__(self,name): self.name = name # 子类可以都自己的特色 def voice(self): print('汪汪汪') class Cat(Animal): # Cat类继承Animal类 def __init__(self,name): self.name = name # 子类可以都自己的特色 def voice(self): print('喵喵喵') dog = Dog('大黄') dog.voice() # 子类可以调用自己的方法 dog.action() # 也可以调用父类的方法 cat = Cat('小黑') cat.voice() # 子类可以调用自己的方法 cat.action() # 也可以调用父类的方法 print('233') # 那么问题来了,创建子类的对象,父类中的构造方法没有被执行,怎么办? class Pig(Animal): def __init__(self,name,weight): self.name = name # 通过super关键字执行父类中的构造方法 super(Pig,self).__init__(weight) # 也可以执行父类中的其他方法 super(Pig,self).action() # 子类可以都自己的特色 def voice(self): print('哼唧哼唧') pig = Pig('阿花',300) print('有趣的阿花%s多斤'% pig.weight)
ok,现在你学会了继承,再来看个变态的东西----多继承
类有新式类和经典类之分,从写法上区分，如果 当前类或者父类继承了object类，那么该类便是新式类，否则便是经典类
- 当类是经典类时，多继承情况下，会按照深度优先方式搜索
- 当类是新式类时，多继承情况下，会按照广度优先方式搜索
Python 2.x中默认都是经典类，只有显式继承了object才是新式类
Python 3.x中默认都是新式类，不必显式的继承objec
class S0: def func(self): print("This is from S0") class S(S0): def __init__(self): pass class S1(S): def __init__(self): pass class S2(S0): def __init__(self): pass def func(self): print("This is from S2") class S3(S1,S2): def __init__(self): pass obj = S3() obj.func()
执行上述代码
经典类的答案： This is from S0
新式类的答案： This is from S2
# 一个子类能否继承多个类 (爸爸妈妈爷爷奶奶叔叔伯伯 # 如果继承的多个类每个类中都定义了相同的函数，那么那一个会被使用呢 class S: def show(self): print('S') def show1(self): print('S') class S1(S): def show(self): print('S1') class S2: def show(self): print('S2') def show1(self): print('S2') class S22(S): def show(self): print('S22') def show1(self): print('S22') class S3(S1,S2): pass class S4(S1,S22): pass obj = S3() obj.show() # 广度优先 S4().show1() # 广度优先
多态
对于Java、C#来说 ,创建一个变量必须指定它的数据类型
public static void main(String[] args) {}; Java定义一个方法,指定了变量类型String类,如果赋值不是String类就会报错
public static void main(Foo[] args) {}; 也可以自己写一个类Foo类,Foo类有众多子类,那么赋值类型就可以是Foo类或其子类中的任意一个
而python则没有这种限制,因为python原生多态
def func(*args):pass
变量可以是任意类型
# 有兴趣的小伙伴可以研究下这段代码,emmmmmm print("******多继承使用类名.__init__ 发生的状态******") class Parent(object): def __init__(self, name): print('parent的init开始被调用1') self.name = name print('parent的init结束被调用2') class Son1(Parent): def __init__(self, name, age): print('Son1的init开始被调用3') self.age = age Parent.__init__(self, name) print('Son1的init结束被调用4') class Son2(Parent): def __init__(self, name, gender): print('Son2的init开始被调用5') self.gender = gender Parent.__init__(self, name) print('Son2的init结束被调用6') class Grandson(Son1, Son2): def __init__(self, name, age, gender): print('Grandson的init开始被调用7') Son1.__init__(self, name, age) # 单独调用父类的初始化方法 Son2.__init__(self, name, gender) print('Grandson的init结束被调用8') print(Grandson.__mro__) gs = Grandson('grandson', 12, '男') print('姓名：', gs.name) print('年龄：', gs.age) print('性别：', gs.gender) print("******多继承使用类名.__init__ 发生的状态******\n\n") # ---------------------------------------------------- print("******多继承使用super().__init__ 发生的状态******") class Parent(object): def __init__(self, name, *args, **kwargs): # 为避免多继承报错，使用不定长参数，接受参数 print('parent的init开始被调用1') self.name = name print('parent的init结束被调用2') class Son1(Parent): def __init__(self, name, age, *args, **kwargs): # 为避免多继承报错，使用不定长参数，接受参数 print('Son1的init开始被调用3') self.age = age super().__init__(name, *args, **kwargs) # 为避免多继承报错，使用不定长参数，接受参数 print('Son1的init结束被调用4') class Son2(Parent): def __init__(self, name, gender, *args, **kwargs): # 为避免多继承报错，使用不定长参数，接受参数 print('Son2的init开始被调用5') self.gender = gender super().__init__(name, *args, **kwargs) # 为避免多继承报错，使用不定长参数，接受参数 print('Son2的init结束被调用6') class Grandson(Son1, Son2): def __init__(self, name, age, gender): print('Grandson的init开始被调用7') # 多继承时，相对于使用类名.__init__方法，要把每个父类全部写一遍 # 而super只用一句话，执行了全部父类的方法，这也是为何多继承需要全部传参的一个原因 # super(Grandson, self).__init__(name, age, gender) super().__init__(name, age, gender) print('Grandson的init结束被调用8') print(Grandson.__mro__) gs = Grandson('grandson', 12, '男') print('姓名：', gs.name) print('年龄：', gs.age) print('性别：', gs.gender) print("******多继承使用super().__init__ 发生的状态******\n\n")
