day22 面向过程与面向对象的介绍 类的定义和使用 产生对象 类名称空间与对象名称空间以及属性查找 绑定方法的特殊之处 一切皆对象 小练习 对象交互之人狗大战 总结 今日做业

一、面向过程编程

核心过程二字，过程指的是解决问题的步骤，即先干什么，再干什么

基于该思想编写程序就比如在设计一条流水线，是一种机械的思惟方式。

　　优势:复杂的问题流程化，进而简单化

　　缺点:扩展性差

二、面向对象

核心"对象"二字，对象指的是特征与技能的结合体，基于该思想编写程序

就比如在创造一个世界，你就是这个世界的上帝，是一种上帝式的思惟方式

　　优势:可扩展性强

　　缺点:编程的复杂度高于面向过程

=================================================================

PS.面向对象仅仅是解决了可扩展性的问题,并无表明所有

 

一、类

对象是特征与技能的结合体，那类就是一系列对象相同的特征与技能的结合体

二、在现实生活中P:必定是先有对象，后来随着人类文明的发展总结出的类，对象是具体存在的，而类只是一种抽象概念

三、在程序中，务必保证:先定义类，后调用类来产生对象

现实生活中的对象：
    对象1：
        特征：
            school="Oldboy"
            name="马冬梅"
            age=18
            sex="female"
        技能：
            学习
            选课

    对象2：
        特征：
            school="Oldboy"
            name="甜蜜蜜"
            age=21
            sex="male"
        技能：
            学习
            选课

    对象3：
        特征：
            school="Oldboy"
            name="原石开"
            age=22
            sex="male"
        技能：
            学习
            选课

现实生活中的老男孩学生类：
     相同的特征
            school="Oldboy"
     相同的技能
            学习
            选课
'''
类名通常用驼峰体
#一、程序中的类
class OldboyStudent:
    # 用变量表示特征
    school="Oldboy"

    #  用函数表示技能
    def learn(self):
        print('is learning...')

    def choose(self):
        print('choose course...')

    # print('======>')

注意：在定义类的阶段会马上执行类体内的代码，而后将产生的名字存放于类名称空间中
print(OldboyStudent.__dict__)
print(OldboyStudent.__dict__['school'])
print(OldboyStudent.__dict__['learn'])
OldboyStudent.__dict__['learn'](123)

print(OldboyStudent.school) # OldboyStudent.__dict__['school']
print(OldboyStudent.learn) # OldboyStudent.__dict__['learn']
OldboyStudent.learn('xxx')
OldboyStudent.learn('xxx')

OldboyStudent.country='China'   #新增属性
OldboyStudent.school='偶的博爱' #改属性

del OldboyStudent.country
print(OldboyStudent.__dict__)

二、调用类，产生程序中的对象

产生对象

类名称空间与对象名称空间以及属性查找

# 一、程序中的类
class OldboyStudent:
    # 用变量表示特征
    school = "Oldboy"

    # stu1, "马冬梅", 18, 'female'
    def __init__(self, name, age, sex):  
        # self=stu1     name= "马冬梅"   age=18     sex="female"
        # print('==========init run=============>')
        self.name = name  # stu1.name = "马冬梅"
        self.age = age  # stu1.age = 18
        self.sex = sex  # stu1.sex = "female"

    #  用函数表示技能
    def learn(self):
        print('is learning...', self)

    def choose(self):
        print('choose course...')

在程序中：必须先定义类 - -----》调用类 - -----》对象

stu1=OldboyStudent()
stu1.NAME='马冬梅'
stu1.AGE=18
stu1.SEX="female"

stu2=OldboyStudent()
stu2.NAME='甜蜜蜜'
stu2.AGE=21
stu2.SEX="male"

stu3=OldboyStudent()
stu3.NAME='原石开'
stu3.AGE=22
stu3.SEX="male"

print(stu1.NAME,stu1.school)
print(stu2.NAME,stu2.school)
print(stu3.NAME,stu3.school)
上述产生的三个对象都同样了

调用类发生哪些事：
一、首先会产生一个空对象stu1
二、会自动触发类内部的__init__函数
三、而后将空对象stu1连同调用类时括号内的参数组成（stu1,"马冬梅",18,'female'）,
将这四个参数一块儿传给__init__函数

stu1=OldboyStudent("马冬梅",18,'female')
#OldboyStudent.__init__(stu1,"马冬梅",18,'female')
stu2=OldboyStudent("甜蜜蜜",21,'male')
#OldboyStudent.__init__(stu2,"甜蜜蜜",21,'male')
stu3=OldboyStudent("原石开",22,'male')

print(stu1.name,stu1.age,stu1.sex)
print(stu2.name,stu2.age,stu2.sex)
print(stu3.name,stu3.age,stu3.sex)

类名称空间与对象名称空间以及属性查找

school = 'xxxxxxxxxxxxxxxxxxxxxxxxxx'

class OldboyStudent:
    school = 'oldboy'

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

    # self=stu1
    def learn(self):
        print('%s is learning' % self.name)

    def choose(self, course):
        print('%s is choosing %s' % (self.name, course))


# 调用类---》产生类的对象，该对象也能够称为类的一个实例，
# 调用类的过程也称为类的实例化
stu1 = OldboyStudent('李三胖', 18, 'male')
# OldboyStudent.__init__(stu1,'李三胖',18,'male')

# OldboyStudent.country='CHINA'
# print(OldboyStudent.country)

# print(OldboyStudent.__dict__)
# print(stu1.__dict__)
# print(stu1.__dict__['name'])
# print(stu1.name)
# print(stu1.school)
# print(school)

stu2 = OldboyStudent('王大炮', 28, 'male')
# print(stu2.__dict__)

# 类内部定义的变量是给全部对象共享，全部对象指向的都是同一个内存地址
# print(id(stu1.school))
# print(id(stu2.school))
# print(id(OldboyStudent.school))

绑定方法的特殊之处

类内部定义的函数，类可使用，但类来用的时候就是一个普通函数，
普通函数有几个参就传几个参数
print(OldboyStudent.learn)
OldboyStudent.learn(123)

类内部定义的函数，实际上是给对象使用的，并且是绑定给对象用，
绑定给不一样的对象就是不一样的绑定方法
print(stu1.learn)
print(stu2.learn)
绑定方法的特殊之处在于，谁来调用，就会将谁看成第一个参数自动传入
stu1.learn()  # OldboyStudent.learn(stu1)
stu2.learn()  # OldboyStudent.learn(stu2)

stu1.choose('python')
stu2.choose('linux')

一切皆对象

class OldboyStudent:
    school='oldboy'

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

    #self=stu1
    def learn(self):
        print('%s is learning' %self.name)

    def choose(self,course):
        print('%s is choosing %s' %(self.name,course))

stu2=OldboyStudent('王大炮',28,'male')

# print(id(stu2))
# print(type(stu2)) # 类与类型是一个概念
# print(stu2)

l1=[1,2,3] #l1=list([1,2,3])
# print(type(l1))
# l1.append(4)
list.append(l1,4)
print(l1)

l2=['a','b','c']
l2.append('d')
# list.append('d')
print(l2)

print(int)
print(str)
print(dict)
print(tuple)
print(set)
print(OldboyStudent)

 小练习 (实例化三次)

# class Foo:
#     n=0
#     def __init__(self):
#         Foo.n+=1 # Foo.n=3
#
# obj1=Foo()
# obj2=Foo()
# obj3=Foo()
# print(obj1.__dict__)
# print(obj2.__dict__)
# print(obj3.__dict__)
#
# print(obj1.n)
# print(obj2.n)
# print(obj3.n)

对象交互之人狗大战

#对对象属性的增删改查
# class Bar:
#     n=1111111111
#     def __init__(self,x):
#         self.x=x
#
# obj=Bar(111)
#
# # print(obj.__dict__)
# # print(obj.n)
# obj.y=2
# obj.n=3
# print(obj.__dict__)
# print(obj.n)
#
# obj.x=123
# del obj.x
# print(obj.x)
'''
现实中的对象：
    人1
        特征：
            名字='刘晴政'
            攻击力=60
            生命值=100
        技能：
            咬

    人2
        特征：
            名字='王苗璐'
            攻击力=50
            生命值=100
        技能：
            咬

现实中的人类
    相同的特征
    相同的技能
        咬
'''

'''
现实中的对象：
    狗1
        特征：
            名字='武培其'
            品种="京巴"
            攻击力=80
            生命值=50
        技能：
            咬

    人2
        特征：
            名字='李杰'
            品种="藏獒"
            攻击力=200
            生命值=200
        技能：
            咬

现实中的狗类
    相同的特征
    相同的技能
        咬
'''
class People:
    def __init__(self, name, aggresivity, life_value=100):
        self.name = name
        self.aggresivity = aggresivity
        self.life_value = life_value

    def bite(self, enemy): #self=p1   enemy=d1
        enemy.life_value-=self.aggresivity
        print("""
        人[%s] 咬了一口狗 [%s]
        狗掉血[%s]
        狗还剩血量[%s]
        """ %(self.name,enemy.name,self.aggresivity,enemy.life_value)
        )

class Dog:
    def __init__(self, name, dog_type, aggresivity, life_value):
        self.name = name
        self.dog_type = dog_type
        self.aggresivity = aggresivity
        self.life_value = life_value

    def bite(self, enemy): #self = d1    enemy= p1
        enemy.life_value-=self.aggresivity
        print("""
        狗[%s] 咬了一口人 [%s]
        人掉血[%s]
        人还剩血量[%s]
        """ %(self.name,enemy.name,self.aggresivity,enemy.life_value)
        )
p1 = People('刘清政', 60)
d1=Dog('李杰',"藏獒",200,200)

p1.bite(d1)
d1.bite(p1)

绑定:谁调用他就表明谁

相关补充

在python3中定义类的时候默认定义继承object的类，方便python2识别
class OldboyPeople(object):

#python为类内置的特殊属性
类名.__name__# 类的名字(字符串)
类名.__doc__# 类的文档字符串
类名.__base__# 类的第一个父类(在讲继承时会讲)
类名.__bases__# 类全部父类构成的元组(在讲继承时会讲)
类名.__dict__# 类的字典属性
类名.__module__# 类定义所在的模块
类名.__class__# 实例对应的类(仅新式类中)

类的特殊属性(了解便可)

今日做业

面向对象做业
1.默写:面向对象与面向过程的优缺点对比,及使用场景
2.初始化函数的做用是什么,有什么特色

做用:
init 函数用于初始化对象,它会在建立对象时,自动执行,
并传入调用类时传递的参数,第一个参数表示要初始化的对象自己,

特色:
self(第一个)参数不须要手动传递
self表示对象本身 是一个形式参数,名字能够随便取,可是不建议修改

3.什么是绑定方法,有什么特色

绑定方法:把对象与函数进行绑定
特色:谁来调用，就会将谁看成第一个参数自动传入

4.对象与类的属性查找顺序什么怎么样的

当对象中不存在是会到类里面查找，若是对象中存在这个属性，优先访问对象中的属性
# 查找顺序为 对象 ->  类

5.什么是类?  什么是对象?

对象是特征与技能的结合体
类是一系列特征与技能的结合体

6.扩展题
设计王者荣耀中的英雄类,每一个英雄对象能够对其余英雄对象使用技能
具有如下属性
英雄名称,等级,血量
和Q_hurt,W_hurt,E_hurt 三个属性,表示各技能的伤害量
具有如下技能
Q W E
三个技能都须要一个敌方英雄做为参数,当敌方血量小于等于0时输出角色死亡

class Hero:

    def __init__(self,name,level,hp,Q_hurt,W_hurt,E_hurt):
        self.name = name
        self.level = level
        self.hp = hp
        self.Q_hurt = Q_hurt
        self.W_hurt = W_hurt
        self.E_hurt = E_hurt

    def Q(self,enemy):

        enemy.hp -= self.Q_hurt
        print("%s 对%s 释放了 %s 技能" % (self.name,enemy.name,"Q"))
        print("形成了%s点伤害,剩余血量%s" % (self.Q_hurt, enemy.hp))
        if enemy.hp <= 0:
            print("%s被%s弄死了" % (enemy.name,self.name))

    def W(self,enemy):
        enemy.hp -= self.W_hurt
        print("%s 对%s 释放了 %s 技能" % (self.name, enemy.name, "W"))
        print("形成了%s点伤害,剩余血量%s" % (self.W_hurt,enemy.hp))
        if enemy.hp <= 0:
            print("%s被%s弄死了" % (enemy.name, self.name))

    def E(self,enemy):
        enemy.hp -= self.E_hurt
        print("%s 对%s 释放了 %s 技能" % (self.name, enemy.name, "E"))
        print("形成了%s点伤害,剩余血量%s" % (self.E_hurt, enemy.hp))
        if enemy.hp <= 0:
            print("%s被%s弄死了" % (enemy.name, self.name))

# 建立两个英雄
hero1 = Hero("小妲己",15,2000,50,500,600)

hero2 = Hero("小鲁班",15,1500,50,500,600)

hero1.Q(hero2)
hero1.W(hero2)
hero1.E(hero2)
hero1.E(hero2)