面向对象初识

函数总结:

https://www.processon.com/view/link/5b718274e4b0555b39e1055f

面向过程的程序设计的核心是过程（流水线式思维），过程即解决问题的步骤，面向过程的设计就好比精心设计好一条流水线，考虑周全什么时候处理什么东西。

优点是：极大的降低了写程序的复杂度，只需要顺着要执行的步骤，堆叠代码即可。

缺点是：一套流水线或者流程就是用来解决一个问题，代码牵一发而动全身。

应用场景：一旦完成基本很少改变的场景，著名的例子有Linux內核，git，以及Apache HTTP Server等。

面向对象的程序设计的核心是对象（上帝式思维），要理解对象为何物，必须把自己当成上帝，上帝眼里世间存在的万物皆为对象，不存在的也可以创造出来。面向对象的程序设计好比如来设计西游记，如来要解决的问题是把经书传给东土大唐，如来想了想解决这个问题需要四个人：唐僧，沙和尚，猪八戒，孙悟空，每个人都有各自的特征和技能（这就是对象的概念，特征和技能分别对应对象的属性和方法），然而这并不好玩，于是如来又安排了一群妖魔鬼怪，为了防止师徒四人在取经路上被搞死，又安排了一群神仙保驾护航，这些都是对象。然后取经开始，师徒四人与妖魔鬼怪神仙互相缠斗着直到最后取得真经。如来根本不会管师徒四人按照什么流程去取。

面向对象的程序设计的

优点是：解决了程序的扩展性。对某一个对象单独修改，会立刻反映到整个体系中，如对游戏中一个人物参数的特征和技能修改都很容易。

缺点：可控性差，无法向面向过程的程序设计流水线式的可以很精准的预测问题的处理流程与结果，面向对象的程序一旦开始就由对象之间的交互解决问题，即便是上帝也无法预测最终结果。于是我们经常看到一个游戏人某一参数的修改极有可能导致阴霸的技能出现，一刀砍死3个人，这个游戏就失去平衡。

应用场景：需求经常变化的软件，一般需求的变化都集中在用户层，互联网应用，企业内部软件，游戏等都是面向对象的程序设计大显身手的好地方。

在python 中面向对象的程序设计并不是全部。

面向对象编程可以使程序的维护和扩展变得更简单，并且可以大大提高程序开发效率 ，另外，基于面向对象的程序可以使它人更加容易理解你的代码逻辑，从而使团队开发变得更从容。

了解一些名词：类、对象、实例、实例化

 类:具有相同属性和技能的一类事物.
人类:
对象: 具体的类的表现,具体的实实在在的一个实例
人是一类,某个人是一个对象.
狗是一类,我家养的旺财是一个对象.

实例化：类——>对象的过程

 1 class Person:
 2     '''类体:两部分:变量部分,方法(函数)部分'''
 3     mind = '有思想'  # 变量,静态变量,静态字段
 4     animal = '高级动物'
 5     faith = '有信仰'
 6     def __init__(self):
 7         print(self)
 8         print(666)
 9     def work(self):  # 方法,函数,动态变量
10         print(self)
11         print('人类都会工作...')
12     def shop(self):
13         print('人类可以消费....')
14 
15 # 类名的角度
16     # 操作类中的静态变量
17         # 1, Person.__dict__ 查询类中的所有的内容 (不能进行增删改操作)
18 print(Person.__dict__)
19 print(Person.__dict__['faith'])
20 Person.__dict__['mind'] = '无脑'
21 print(Person.__dict__['mind'])
22         # 2, 万能的  .  对类中的单个的变量进行增删改查,用 万能的 点
23 print(Person.mind)
24 print(Person.animal)  # 查
25 Person.money = '运用货币'  # 增
26 Person.mind = '无脑的' # 改
27 del Person.mind
28 print(Person.__dict__)
29 
30     #操作类中的方法  (工作中基本不用类名去操作)
31 Person.work(111)
32 
33 # 对象的角度
34 ret = Person()  # 类名+()的这个过程:实例化的过程(创建一个对象的过程),
35           # Person() 实例化对象,实例,对象.
36 print(ret)
37 #1,只要类名+() 产生一个对象,自动执行类中的__init__方法.

1,完成下列功能:
  1.1创建一个人类Person,再类中创建3个静态变量(静态字段)
    animal = '高级动物'
    soul = '有灵魂'
    language = '语言'
  1.2在类中定义三个方法,吃饭,睡觉,工作.
  1.3在此类中的__init__方法中,给对象封装5个属性:国家,姓名,性别,年龄,身高.
  1.4实例化四个人类对象:
    第一个人类对象p1属性为:中国,alex,未知,42,175.
    第二个人类对象p2属性为:美国,武大,男,35,160.
    第三个人类对象p3属性为:你自己定义.
    第四个人类对象p4属性为:p1的国籍,p2的名字,p3的性别,p2的年龄,p3  的身高.
  1.5 通过p1对象执行吃饭方法,方法里面打印:alex在吃饭.
  1.6 通过p2对象执行吃饭方法,方法里面打印:武大在吃饭.
  1.7 通过p3对象执行睡觉方法,方法里面打印:(p3对象自己的名字)在吃饭.
  1.8 通过p1对象找到Person的静态变量 animal
  1.9 通过p2对象找到Person的静态变量 soup
  2.0 通过p3对象找到Person的静态变量 language

 1 class Person:
 2     animal = '高级动物'
 3     soul = '有灵魂'
 4     language = '语言'
 5 
 6     def __init__(self, country, name, sex, age, height):
 7         self.country = country
 8         self.name = name
 9         self.sex = sex
10         self.age = age
11         self.height = height
12 
13     def eat(self):
14         return "%s在吃饭" % self.name
15 
16     def sleep(self):
17         return '%s在睡觉' % self.name
18 
19     def work(self):
20         return '%s在工作' % self.name
21 
22 
23 p1 = Person("中国", 'alex', '未知', 42, 175)
24 p2 = Person("美国", '武大', '男', 35, 160)
25 p3 = Person('中国', 'corn', '男', 21, 178)
26 p4 = Person(p1.country, p2.name, p3.sex, p2.age, p3.height)
27 
28 print(p1.eat())
29 print(p2.eat())
30 print(p3.eat())
31 
32 print(p1.animal)
33 print(p2.soul)
34 print(p3.language)

2,通过自己创建类,实例化对象
  在终端输出如下信息
  小明，10岁，男，上山去砍柴
  小明，10岁，男，开车去东北
  小明，10岁，男，最爱大保健
  老李，90岁，男，上山去砍柴
  老李，90岁，男，开车去东北
  老李，90岁，男，最爱大保健
  老张…

1 class Hobby:
 2 
 3     def __init__(self,name,age,sex):
 4         self.name = name
 5         self.age = age
 6         self.sex = sex
 7     def hobby1(self):
 8         return('%s,%s岁,%s,上山去砍柴' % (self.name,self.age,self.sex))
 9     def hobby2(self):
10         return('%s,%s岁,%s,开车去东北' % (self.name,self.age,self.sex))
11     def hobby3(self):
12         return('%s,%s岁,%s,最爱大保健' % (self.name,self.age,self.sex))
13 
14 p1 = Hobby("小明",10,'男')
15 p2 = Hobby('老李',90,'男')
16 
17 print(p1.hobby1())
18 print(p1.hobby2())
19 print(p1.hobby3())
20 print(p2.hobby1())
21 print(p2.hobby2())
22 print(p2.hobby3())

3,模拟英雄联盟写一个游戏人物的类（升级题）.
  要求:
  (1)创建一个 Game_role的类.
  (2) 构造方法中给对象封装name,ad(攻击力),hp(血量).三个属性.
  (3) 创建一个attack方法,此方法是实例化两个对象,互相攻击的功能:
      例: 实例化一个对象 盖伦,ad为10, hp为100
      实例化另个一个对象 剑豪 ad为20, hp为80
      盖伦通过attack方法攻击剑豪,此方法要完成 '谁攻击谁,谁掉了多少血,  还剩多少血'的提示功能.

 1 class Game_role:
 2 
 3     def __init__(self,name,ad,hp):
 4         self.name = name
 5         self.ad = ad
 6         self.hp = hp
 7     def attack(self,vicitm):
 8         vicitm.hp = vicitm.hp - self.ad
 9         print( "%s攻击%s,%s掉了%s血,还剩%s血" % (self.name, vicitm.name, vicitm.name, self.ad, vicitm.hp))
10 p1 = Game_role("盖伦",10,100)
11 p2 = Game_role('剑豪',20,80)
12 
13 p1.attack(p2)
14 print(p2.hp)

今日主要内容:

• 1.类空间,对象空间,查询顺序.
• 2.组合.

1.类空间,对象空间,查询顺序.

class Person:
    animal = '高级动物'
    soul = '有灵魂'
    language = '语言'

    def __init__(self, country, name, sex, age, hight):
        self.country = country
        self.name = name
        self.sex = sex
        self.age = age
        self.hight = hight

    def eat(self):
        print('%s吃饭' % self.name)

    def sleep(self):
        print('睡觉')

    def work(self):
        print('工作')


Person.__dict__['sleep'](111)

p1 = Person('菲律宾','alex','未知',42,175)
p2 = Person('菲律宾','alex','未知',42,175)
p3 = Person('菲律宾','alex','未知',42,175)
p1.animal = '禽兽'
print(p1.animal)

print(Person.name)
p2 = Person('美国','武大','男',35,160)

查询顺序:
  对象.属性 : 先从对象空间找,如果找不到,再从类空间找,再找不到,再从父类找....
  类名.属性 : 先从本类空间找,如果找不到,再从父类找....

对象与对象之间是互相独立的.

2.组合
组合: 给一个类的对象封装一个属性,这个属性是另一个类的对象.

**模拟英雄联盟写一个游戏人物的类（升级题）.(见昨日作业)
要求:
(1)创建一个 Game_role的类.
(2) 构造方法中给对象封装name,ad(攻击力),hp(血量).三个属性.
(3) 创建一个attack方法,此方法是实例化两个对象,互相攻击的功能:
例: 实例化一个对象 盖伦,ad为10, hp为100
实例化另个一个对象 剑豪 ad为20, hp为80
盖伦通过attack方法攻击剑豪,此方法要完成 '谁攻击谁,谁掉了多少血, 还剩多少血'的提示功能.

版本一：添加武器：斧子，刀，枪，棍，棒...,

class GameRole:
    def __init__(self, name, ad, hp):
        self.name = name
        self.ad = ad
        self.hp = hp

    def attack(self,p):
        p.hp = p.hp - self.ad
        print('%s 攻击 %s,%s 掉了%s血,还剩%s血' %(self.name,p.name,p.name,self.ad,p.hp))

class Weapon:
    def __init__(self,name,ad):
        self.name = name
        self.ad = ad
    def fight(self,p1,p2):
        p2.hp = p2.hp - self.ad
        print('%s 用%s打了%s,%s 掉了%s血,还剩%s血'
              % (p1.name,self.name,p2.name,p2.name,self.ad,p2.hp))

p1 = GameRole('张三',20,500)
p2 = GameRole('李四',50,200)
axe = Weapon('三板斧',60)
broadsword = Weapon('屠龙宝刀',100)

axe.fight(p1,p2)
broadsword.fight(p2,p1)

p1.attack(p2)

代码不合理: 人物利用武器攻击别人,你的动作发起者是人,而不是武器.

版本二:

class GameRole:
    def __init__(self, name, ad, hp):
        self.name = name
        self.ad = ad
        self.hp = hp

    def attack(self,p):
        p.hp = p.hp - self.ad
        print('%s 攻击 %s,%s 掉了%s血,还剩%s血' %(self.name,p.name,p.name,self.ad,p.hp))

    def armament_weapon(self,wea):
        self.wea = wea


class Weapon:
    def __init__(self,name,ad):
        self.name = name
        self.ad = ad
    def fight(self,p1,p2):
        p2.hp = p2.hp - self.ad
        print('%s 用%s打了%s,%s 掉了%s血,还剩%s血'
              % (p1.name,self.name,p2.name,p2.name,self.ad,p2.hp))

p1 = GameRole('张三',20,500)
p2 = GameRole('李四',50,200)
axe = Weapon('三板斧',60)
broadsword = Weapon('屠龙宝刀',100)
# print(axe)
p1.armament_weapon(axe)  # 给张三 装备了三板斧这个对象.
# print(p1.wea)
# print(p1.wea.name)
# print(p1.wea.ad)
p1.wea.fight(p1,p2)