初始面向对象

一、面向对象编程介绍

　　1、面向过程编程

　　面向过程的程序设计的核心是过程（流水线式思维），过程即解决问题的步骤，面向过程的设计就好比精心设计好一条流水线，考虑周全什么时候处理什么东西。优点是：极大的降低了写程序的复杂度，只需要顺着要执行的步骤，堆叠代码即可。缺点是：一套流水线或者流程就是用来解决一个问题，代码牵一发而动全身

　　2、面向对象编程

　　面向对象的程序设计的

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

　　缺点：可控性差，无法向面向过程的程序设计流水线式的可以很精准的预测问题的处理流程与结果，面向对象的程序一旦开始就由对象之间的交互解决问题，例如游戏新出的英雄都比较逆天

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

相关概念：类、对象、实例、实例化

类：具有相同特征的一类事物(人、狗、老虎)，

对象／实例：具体的某一个事物（如人属性的张三、李四等），python中一切皆对象

类名（）：类名加括号就是实例化一个类，相当于调用一个__init__方法

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

查看对象的属性，直接有对象名，属性名

调用类中的方法，直接用对象名.对象方法名（）

对象名 = 类名(1,2)  #对象就是实例，代表一个具体的东西
                  #类名() : 类名+括号就是实例化一个类，相当于调用了__init__方法
                  #括号里传参数，参数不需要传self，其他与init中的形参一一对应
                  #结果返回一个对象
对象名.对象的属性1   #查看对象的属性，直接用 对象名.属性名 即可
对象名.方法名()     #调用类中的方法，直接用 对象名.方法名() 即可

二、类名的作用

1、属性引用

class Person:  #类名有两个作用
    country = '中国'   #静态属性、数据属性（可以定义多个，或不定义）
    def walk(self):    #动态属性、函数属性、方法
        print('walk')

1.属性引用
print(Person.country) #静态属性的查看
print(Person.walk)  # <function Person.walk at 0x00000000024D88C8>

Person.role = '人'  #添加一个新静态属性
print(Person.role)

Person.country = '印度'  #修改一个新静态属性

del Person.role #删除一个静态属性
print(Person.__dict__)

print(Person.walk())  #报错 少self参数

Person.__dict__['country'] = '印度'  #报错 不能改变，只能查看
print(Person.__dict__['country'])  #静态属性的查看
print(Person.country)  #静态属性的查看  （推荐这种方式）

#类能完成的第二个功能：实例化对象
#实例化：从一个类中创造一个具体的对象的过程
            p = Person()  
            print(p)  #Person的对象

class Person: 
    country = '中国'   #静态属性、数据属性
    def __init__(self,life_value,aggr,name,job): #初始化方法
        #self = {'lv':life_value}
        self.lv = life_value     #属性，对象属性  self相等于p
        self.aggr = aggr
        self.name = name
        self.job = job

    def walk(self):    #动态属性、函数属性、方法
        print('%s is walking'%self.name)

# p = Person()  #如何让对象拥有具体的属性
p = Person(1000,2,'金老板','boss')  #如何让对象拥有具体的属性
p.walk()  # Person.walk(p)
print(p.lv)  #Person的对象
print(p.aggr)  #Person的对象
print(p.name)  #Person的对象
print(p.job)  #Person的对象
p.sex = 'lady_boy'  #添加一个属性
print(p.sex)
p.sex = 'girl'  #属性的修改
print(p.sex)    #属性的删除
del p.sex

面向对象之间的交互

低配版
#交互
#人
# life_value,aggr,name,job  属性
# attack  方法
class Person:
    def __init__(self,life_value,aggr,name,job): 初始化
        self.life = life_value
        self.aggressive = aggr
        self.name = name
        self.job = job

    def attack(self,dog_obj):  # 方法
        print('%s 攻击了 %s'%(self.name,dog_obj.name))
        dog_obj.life = dog_obj.life - self.aggressive
# dog
# 属性：life_value,aggr,name,kind
# 方法：bite
class Dog:
    def __init__(self, life_value, aggr, name, kind):
        self.life = life_value
        self.aggressive = aggr
        self.name = name
        self.kind = kind

    def bite(self,person_obj):  # 方法
        print('%s 咬了 %s'%(self.name,person_obj.name))
        person_obj.life -= self.aggressive
        # person_obj.life = self.aggressive  - person_obj.life

tiedan = Dog(1000,100,'铁蛋','土狗')   # 实例化  dog 对象名（随意）
boss_gold = Person(1000,200,'太黑','old_driver')     # 实例化人

boss_gold.attack(tiedan)  # 人攻击狗
print(tiedan.life)

tiedan.bite(boss_gold)  # 狗反击
print(boss_gold.life)

 练习

练习一：在终端输出如下信息
小明，10岁，男，上山去砍柴
小明，10岁，男，开车去东北
小明，10岁，男，最爱大保健
老李，90岁，男，上山去砍柴
老李，90岁，男，开车去东北
老李，90岁，男，最爱大保健
老张…
class Person:
    def __init__(self,name,age,sex):
        self.name = name
        self.age = age
        self.sex = sex

    def cutfirewood(self):  #功能的解耦
        print('%s,%s岁,%s,上山去砍柴'%(self.name,self.age,self.sex))

    def drivetoDB(self):
        print('%s,%s岁,%s,开车去东北' % (self.name, self.age, self.sex))

    def loveDBJ(self):
        print('%s,%s岁,%s,最爱大保健' % (self.name, self.age, self.sex))

ming = Person('小明',10,'男')
ming.cutfirewood()  #Person.cutfirewood(ming)
ming.drivetoDB()
ming.loveDBJ()
alex = Person('老李',90,'男')
alex.cutfirewood()
alex.drivetoDB()
alex.loveDBJ()

练习2、
#创造一个圆形类，属性：半径，两个方法：求周长，求面积
from math import pi
class Circle:
    def __init__(self,r):
        self.radius = r

    def perimeter(self):
        return 2*pi*self.radius

    def area(self):
        return pi*(self.radius**2)

c1 = Circle(10)
print(c1.perimeter())
print(c1.area())

 模式

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   #查看对象的属性，直接用 对象名.属性名 即可
对象名.方法名()     #调用类中的方法，直接用 对象名.方法名() 即可

小结