初识面向对象

一、面向对象与面向过程

1.1 什么是面向对象

面向对象编程是一种思想，它指导程序员如何编写出更好的程序。它的核心是对象，此时程序员从操作者变成了指挥者。

1.2 为什么要有面向对象

当今时代背景下,通常应用程序对扩展性和维护性要求都是非常高的,为什么?想想qq,微信,是不是不断的在添加新功能?,也就是说一款应用程序诞生后,都需要不断的更新维护。

1.3 什么是面向过程

也是一种编程思维，他的核心是过程就是一步步的执行步骤（先干什么，在干什么），面向过程的设计就好比精心设计好一条流水线，是一种机械式的思维方式。

1.4 面向对象与面向过程的优缺点

1. 面向对象优缺点：
　　优点：拓展性 灵活性 重用性
　　缺点： 程序的复杂度提高了 无法准确的预知程序的执行结果
　　应用场景：对拓展性要求高的程序，一般是直接面向用户的如：qq 微信

2. 面向过程的优缺点：
　　优点：逻辑清晰 复杂问题简单化，流程化
　　缺点：拓展性差 可维护性差
　　应用场景：对拓展性要求低的程序如：系统内核

二、类与对象

1.类：是一种抽象的概念，是具备相同特征和相同行为对象的集合体。如人类，鱼类等。
2.对象：是具体存在的事物，具备自己的特征和行为。对象就是特征和技能的结合体。

在使用面向对象编程时,第一步就是思考需要什么样的对象,对象具备什么样的特征和行为,从而根据 这些信息总结出需要的类型

三、如何定义一个类

class 类的名称:
    # 类中的内容 描述属性和技能 
    #描述属性用变量
    #描述行为用函数 

# 类名称 书写规范  首先是见名知意 名称是大驼峰命名法  
# 驼峰就是单词首字母大写 , 大驼峰是第一个字母大写,小驼峰是第一个字母小写


# 类的定义
class Student:
    # 描述特征使用变量（属性）
    name = "wangyong"
    # 描述技能使用函数（方法）
    def say_hi(self):
        print("say hi")
    # class中的代码仅在第一次加载时执行
    print("running...")  # 类体代码会在类定义阶段立即执行
print(Student.name)    # wangyong
print(Student.say_hi)    # <function Student.say_hi at 0x0000024F1056A9D8>
Student.say_hi(123)      # say hi

四、对象的使用

4.1 对象的增删改查

1.增加属性
对象变量名称.属性名称 = 属性值

2.删除属性
del 对象的变量名称.属性名称

3.修改
对象.属性 = 新的值

4.查看属性 访问的是对象的所有属性（只能访问到实行的名称空间和类无关）
print(对象.__dict__)

# 对象的使用
class Person:
    country = "China"
    def eat(self):
        print("eatting")
p1 = Person()
print(p1.country)

# 为对象增加属性
p1.name = "张三"    # China
print(p1.name)      # 张三

# 对p1对象单独添加country
p1.country = "USA"

# 在访问时优先访问自己名称空间的内容，如果找不到，会自动找到类中的属性
print(p1.country)        # USA
print(Person.country)    # China

# 每个对象都会存储自己类的地址，可以使用__class__来访问
print(p1.__class__)     # <class '__main__.Person'>
print(type(p1))         # <class '__main__.Person'>

# 查找名称空间的内容，类与对象的名称空间是对立的
print(p1.__dict__)       # {'name': '张三', 'country': 'USA'}
print(Person.__dict__)   # {'__module__': '__main__', 'country': 'China', 'eat': <function Pers...

4.2 类属性补充

一：我们定义的类的属性到底存到哪里了？有两种方式查看
dir(类名)：查出的是一个名字列表
类名.__dict__:查出的是一个字典，key为属性名，value为属性值

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

五、__init__函数

5.1 创建对象时发生什么

1. 产生一个空对象（名称空间）
2. 自动调用__init__方法，并且把这个对象以及额外的参数传入

5.2 __init__示例与特点

class Person:
def __init__(self,name,age):
print("=====>>>>>")
self.name = name
self.age = age

p = Person("wangyong","25")
print(p) # <__main__.Dog object at 0x000001FC97BE8A20>
print(p.age) # 25
print(p.name) # wangyong

# 【注意】:
# 1. 当实例化 对象时,会自动执行init方法（注意与元类中__init__区分开来）
# 2. 会自动将对象作为第一个参数传入,参数名称位self ,self可以是别的名字,但不建议改
# 3. 该函数不能有任何返回值/.... 只能是None 规定如此..
# 4. 有了`__init__`方法，在创建实例的时候，就不能传入空的参数了，必须传入与 `__init__`方法匹配的参数，但`self`不需要传，Python解释器自己会把实例变量传进去：

六、绑定方法与非绑定方法

6.1 绑定方法与函数的区别

当使用类调用时,就是一个普通函数 有几个参数就得传几个参数

当用对象来调用时,是一个绑定方法了,会自动将对象作为第一个参数传入

6.2 对象绑定（将对象与方法进行绑定）

# 练习:写一个学生类,具备一个打招呼的技能 要能输出自己的名字信息
class Student:
    def __init__(self,name):
        self.name = name
     
    def say_hi(self):
        print("hello my name is %s" % self.name)
s1 = Student('jack')
# 对象调用
s1.say_hi() # hello my name is jack
# 类调用
Student.say_hi(s1) # hello my name is jack

# 默认情况下类中的方法都是对象绑定方法 

6.3 类绑定 （将类与方法进行绑定）

class Person:
    name = "wangyuong"

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

    @classmethod
    def show_name(cls):
        print(cls.name)
        print(cls)

    @staticmethod
    def print_hello():
        print("hello world")
# 类调用
Person.show_name() # wangyong  <class '__main__.Person'>
# 对象调用
stu = Person("jack")
stu.show_name() # # wangyuong  <class '__main__.Person'>

# 1. 类绑定方法用@classmethod来装饰 
# 2. 特殊之处:不管用类还是对象调用,都会自动传入类本身,作为第一个参数 
# 3. 什么时候绑定给对象:当函数逻辑需要访问对象中的数据时
# 4. 什么时候绑定给类:当函数逻辑需要访问类中的数据时

6.4 静态绑定（非绑定）

class Student:
    school = "Tinghua"

    def __init__(self,name):
        self.name = name
     @staticmethod
    def print_hello():
        print("hello world")
# 对象调用
stu = Student("wangyong")
stu.print_hello() # hello world

# 类调用
Student.print_hello() # hello world

# 1. 静态方法,就是即不需访问类的数据,.也不需要访问对象的数据 
# 2. 法:@staticmethod 
# 3. 不常用：无论是类调用还是对象调用有几个参数就传几个参数

6.5 练习

"""
需求设计王者荣耀中的英雄类,每个英雄对象可以对其他英雄对象使用技能
具备以下属性
英雄名称,等级,血量
和Q_hurt,W_hurt,E_hurt 三个属性,表示各技能的伤害量
具备以下技能
Q W E
三个技能都需要一个敌方英雄作为参数,当敌方血量小于等于0时角色死亡


涉及到英雄对象
    属性:
    名字 等级 血量
    行为:
    Q  W  E
需要一个英雄类


"""
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):
        print("%s 对 %s 释放了 Q技能 造成了%s伤害" % (self.name,enemy.name,self.Q_hurt))
        self.attack(enemy, self.Q_hurt)

    def W(self,enemy):
        print("%s 对 %s 释放了 W技能 造成了%s伤害" % (self.name, enemy.name, self.W_hurt))
        self.attack(enemy, self.W_hurt)

    def E(self,enemy):
        print("%s 对 %s 释放了 E技能 造成了%s伤害" % (self.name, enemy.name, self.E_hurt))
        self.attack(enemy,self.E_hurt)

    def attack(self,enemy,hurt):
        enemy.HP -= hurt
        if enemy.HP <= 0:
            print("%s 已被%s击杀" % (enemy.name, self.name))


 # 创建两个英雄对象
arso = Hero("亚瑟","15",1000,30,500,200)

dj = Hero("妲己","15",800,300,10,800)

#
# dj.W(arso)
# dj.Q(arso)
# dj.E(arso)

arso.Q(dj)
arso.W(dj)
arso.E(dj)

dj.W(arso)
dj.Q(arso)
dj.E(arso)