Python 面向对象概念 类和对象 对象初始化__init__ 绑定与非绑定

面向对象 （Object Oriented Programming，简称OOP）

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

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

3.面向对象优缺点：

    优点：拓展性  灵活性 重用性

    缺点： 程序的复杂度提高了   无法准确的预知程序的执行结果

4.应用场景：对拓展性要求高的程序，一般是直接面向用户的如：qq 微信

 

 

面向过程

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

2.面向过程的优缺点：

  优点：逻辑清晰  复杂问题简单化，流程化

  缺点：拓展性差  可维护性差

3.应用场景：对拓展性要求低的程序如：系统内核

注意：程序是选择面向对象还是面向程序，主要是根据具体需求来选择

类和对象初识

1.类：是一种抽象的概念，是具备相同特征和相同行为对象的集合体。如人类，鱼类等。

2.对象：是具体存在的事物，具备自己的特征和行为。对象就是特征和技能的结合体。

注意：现实生活中先有对象后有类        程序中是先有类后有对象。

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

python中的类和对象

1.定义类的语法：

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

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

2.创建对象语法

class Person:
    pass

#创建对象 
p = Person()

3.类中和对象中属性的区别

属性可以写在类中 
类中的属性,是所有对象公共的 

也可以写在对象中 
对象中的属性,是每个对象独特的(不一样的)


如果类中和对象中存在同样的属性,先访问对象 如果没有在访问类 


练习: 描述一个老师类 需要包含 一个公共属性和 一个独特的属性 

class Teacher:
    school = "oldboy"
    
t1 = Teacher()
t1.name = "jack"
t1.age = 28

4.对象属性的 增 删 改 查

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

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

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

4.查看属性  访问的是对象的所有属性（只能访问到实行的名称空间和类无关） 
# print(对象.__dict__)
class Teacher:
    school = "oldboy"
    
t1 = Teacher()
t1.name = "jack"
t1.age = 28
print(t1.__dict__) # {'name': 'jack', 'age': 28}

访问对象的类信息
# print(对象.__class__)  
print(t1.__class__) # <class '__main__.Teacher'>

 

python中的初始化__init__

1.什么是初始化方法：用于为对象的属性设置初始值的函数

2.__init__ 事例和特点

class Dog:
    def __init__(self,kind,color,age):
        self.kind = kind
        self.color = color
        self.age = age

print(d1.kind) # 二哈
print(d2.kind) # 泰迪

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

类和对象的属性查找顺序

属性查找顺序:对象->类->父类

绑定与非绑定

对象的精髓就是将数据和处理数据的函数整合到一起 ,这样一来拿到一个对象就同时拿到了需要处理的数据以及处理数据的函数

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

# 练习:写一个学生类,具备一个打招呼的技能 要能输出自己的名字信息
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

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

# 其特殊之处在于,

当使用对象调用该函数时会自动传入对象本身,作为第一个参数  

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

2.类绑定（将类与方法进行绑定）

class OldBoyStudent:
    school = "oldboy"

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

    @classmethod
    def show_school(cls):
        print(cls.school)
        print(cls)

    @staticmethod
    def print_hello():
        print("hello world")
# 类调用
OldBoyStudent.show_school() # oldboy  <class '__main__.OldBoyStudent'>

# 对象调用
stu = OldBoyStudent("jack")
stu.show_school() # # oldboy  <class '__main__.OldBoyStudent'>

类绑定方法用@classmethod来装饰 

特殊之处:不管用类还是对象调用,都会自动传入类本身,作为第一个参数 



什么时候绑定给对象:当函数逻辑需要访问对象中的数据时

什么时候绑定给类:当函数逻辑需要访问类中的数据时

3.静态绑定（非绑定）

class OldBoyStudent:
    school = "oldboy"

    def __init__(self,name):
        self.name = name
     @staticmethod
    def print_hello():
        print("hello world")
# 对象调用
tu = OldBoyStudent("jack")
stu.print_hello(18) # 年龄 18

# 类调用
OldBoyStudent.print_hello(18) # 年龄 18

也叫做静态方法,就是即不需访问类的数据,.也不需要访问对象的数据 

语法:@staticmethod 

不常用：无论是类调用还是对象调用有几个参数就传几个参数

4.练习

"""
需求设计王者荣耀中的英雄类,每个英雄对象可以对其他英雄对象使用技能
具备以下属性
英雄名称,等级,血量
和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)

5.补充：

 __doc__:注释
对象.__class__:访问对象类信息
类名.__name__:查看类名