python面向编程：面向对象、init、绑定方法、案例练习

本文目录：

一、类的定义

二、面向对象概念

三、对象的使用

四、__init__函数的使用

五、绑定方法

六、面向对象联系

一、类的定义

1.什么叫做类？

　　　　类就是分类，类型的意思，一堆具备相同特征和行为的事物的抽象概念

2.类的作用？

　　　　用于描述该类的对象具备什么样的特征和行为

3.类的语法

　　　　调用import class
　　　　类名规范大写开头，驼峰命名法

class MyClass():

    def __init__(self):
        pass

    def func(self):
        pass

4.类定义阶段发生了两种情况

　　　　1.当包含该类的py文件被执行，就会创建类的名称空间
　　　　2.执行代码，将产生的名称放入名称空间

5.类的调用方式

class SHOldboyStudent:
    # 描述该类对象的特征
    school = "上海Oldboy"
    name = "矮根"
    age = 68
    gender = "unknown"
　　print("========================")

    # 描述该类对象的行为 通过函数
    def say_hi(abc):
        print(abc)
        print("hello oldBoy")

#使用类中的属性
print(SHOldboyStudent.__dict__)
print(SHOldboyStudent.__dict__["name"])
print(SHOldboyStudent.name)

# 使用类中的函数
print(SHOldboyStudent.__dict__["say_hi"])
print(SHOldboyStudent.say_hi)
# 使用类直接调用类中函数时 与普通函数没有任何区别  位self仅仅是一个置参数
SHOldboyStudent.say_hi(10)

　　

二、面向对象的概念

1.面向过程

　　　　是一种编程思想，就是将复杂项目具体步骤化，先干什么后干什么
　　　　优点：把复杂的问题流程化，简单化，降低开发难度
　　　　缺点：扩展性差，维护性差，当前情况下用户需求千变万化 对扩展性要求非常高
　　　　使用场景：不需要扩展，或者多扩展性要求不高，例如：linux内核，shell脚本

2.面向对象

2.1什么是面向对象编程

　　也是一种编程思想，核心是对象，什么是对象在现实生活中实际存在，具备特征和行为的事物，

2.2面向对象编程的作用

　　面向对象编程:我们关注的点是.使用什么样的对象可以完成我的任务
       例如:把大象装进冰箱,什么样的对象可以帮我完成这个任务,只要找到这个对象,命令它来做事情即可， 你从一个操作者 变成了指挥者, 例如:西游记中的如来,他要完成一             个传经,要把经书传到东土大唐取经，本来要自己去,但是太麻烦,所以找了唐僧师徒五个对象,来帮他完成这个任务

2.3面向对象编程优点和缺点

　　优点：1.对于 程序员来说，不需要在关心具体步骤
　　　　　2.扩展性，一个单独个体特征或者行为发生时，不会影响到别人

　　缺点：1.程序的复读变高，你需要设计这些对象，注意要避免过度设计的问题
　　　　　2.程序的执行结果可控性低

三、对象的使用

1.创建对象

　　class OldboyStudent:
　　#如果每个对象的属性都相同  才应该定义到类中，比如所有人的学校都上海oldboy
　　school = "上海oldboy"

2.语法调用

　　#创建对象，语法：在类后面加括号，与调用函数写法相同
　　stu = oldboyStudent（)

　　#访问对象的属性
　　print(stu.school)
　　print(OldboyStudent.school)

3.属性的修改、增删

　　#修改属性的值
　　stu.school = "北京oldboy“
　　print(stu.school)

　　#增加属性
　　stu.room_num ="1008"
　　print(stu.room_num)

　　#删除属性
　　del stu.room_num
　　print(stu.room_num)

4.对象与类的名称空间是独立的关系

　　stu.school ="深圳oldboy“ #为对象的属性赋予新的值
　　print(OldboyStudent.School)#类中的属性不会变化
　　stu.room_num = "1008" #为对象增加属性
　　print（OldboyStudent.room_num)#类中不会出现新的属性
　　print(stu.__dict__)
　　print(OldboyStudent.__dict__)

5.对象的属性是相同的，就放到类中，做为一个公共的数据

　　stu.school#大家都是上海校区

　　stu2 = OldboyStudent()
　　print(stu2.__dict__)

　　stu1 = OldboyStudent()
　　print(stu1.__dict__)
　　stu2 = OldboyStudent()
　　print(stu2.__dict__)

　　print(stu1.school)
　　stu1.school = "北京Oldboy"
　　print(stu1.__dict__)

 

6.对象的属性查找顺序

　　对象自己的名称空间--》类的名称空间
　　stu1 = OldboyStudent()
　　stu1.school = "newSchool"
　　print(stu1.school)
　　print(stu1)

四、__init__函数的使用

1.场景案例：

class Dog:
    # 作为一只狗 应该有 昵称  age color gender
    # 但是不能写到类中因为每个狗不一样
    # name = "二哈"

    # __init__称之为初始化函数  它会在创建对象的时候自动执行
    # 创建对象时
    # .创建一个空对象
    # .执行__init__函数 并且自动传入了这个对象

    # 该函数的作用,就是为对象的属性赋初始值
    def __init__(self,name,color,age,gender):
        print("狗__init__执行了")
        print(self)
        self.name = name
        self.age = age
        self.color = color
        self.gender = gender

# dog1 = Dog()
# print(dog1)
# dog1.name = "二黄"
# dog1.age = ""
# dog1.color = "黄色"
# dog1.gender = "female"
#
#
# dog2 = Dog()
# print(dog1)
# dog2.name = "二哈"
# dog2.age = ""
# dog2.color = "白色"
# dog2.gender = "female"

# 在创建对象时,传入参数
# print(Dog("大黄","黄色",,"female"))
dog1 = Dog("大黄","黄色",,"female")
# dog1 = Dog()
# dog1.__init__(dog1,"大黄","黄色",,"female")

print(dog1.__dict__)
dog2 = Dog("二哈","白色",,"female")
print(dog2.__dict__)

2.__init__函数使用的注意点

　　1.使用场景，需要为每个对象定制不同的属性
　　2.__init__在创建对象后自动执行
　　3.第一个self参数 只的是这个对象本身 不需要手动传值

五、绑定方法

1.绑定案例：

class Person:
    country = "China"

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

    def sleep(self):
        print("sleeping")
        print(self)

    def eat(self):
        print("eating")

# p1 = Person("矮根",68,"female")
# p2 = Person("成伟",18,"female")

# 类调用类中函数 与 对象调用的区别
# p1.sleep()
# p2.sleep()
# print(Person.sleep)
# print(p1.sleep)

# 类调用
# Person.sleep(10)
# 对象调用
# p1.sleep()

2.类与对象调用的区别

　　　　对于类而言，sleep就是一个普通的函数
　　　　对对象而言，sleep是一个绑定的方法

3.绑定方法是什么？

　　　　是对象与类中的某个函数的绑定关系，就像生活中我们都会吃放，我吃饭你不会 饱
　　　　那么吃饭就是我绑定的方法

4.为什么要把函数进行绑定？

　　　　因为对象的行为通常都需要访问这个对象的数据，或是修改这个对象的数据，如果没有对象，直接调用函数是没有意义的，在函数中访问不到对象的数据，所以将对象和函数进行绑定

5.绑定的特殊之处　

　　　　在使用绑定方法时 不需要关心self参数，会自动将这个对象本身传进来，对象调用绑定方法时，最后执行的还是类中的那个函数

六、面向对象练习

# 王者荣耀 对砍游戏
# 两个英雄可以对砍 如果血量小于0 就GG
# 所需要的对象
# 英雄对象
"""
    亚瑟
        属性
            类型
            血量
            名称
        技能
            Q 跳起来给你一刀  伤害50
            W 给你一脚           30
            E 大宝剑            100

    妲己
        属性
            类型
            血量
            名称
        技能
            Q 给你一颗小星星   伤害10
            W 给你一尾巴          30
            E 色诱               100
"""
class Hero:
    def __init__(self,hero_type,name,blood,q,w,e):
        self.hero_type = hero_type
        self.name = name
        self.blood = blood
        self.q = q
        self.e = e
        self.w = w

    def Q(self,enemy):
        print("%s 对 %s 释放 Q技能 造成%s伤害 对方血量剩余%s"%
              (self.name,enemy.name,self.q,enemy.blood - self.q))
        # 对方血量减少
        enemy.blood-= self.q
        if enemy.blood <=0:
            print("hero %s GG"% enemy.name)

    def W(self,enemy):
        print("%s 对 %s 释放 w技能 造成%s伤害 对方血量剩余%s"%
              (self.name,enemy.name,self.w,enemy.blood - self.w))
        # 对方血量减少
        enemy.blood-= self.w
        if enemy.blood <=0:
            print("hero %s GG"% enemy.name)

    def E(self,enemy):
        print("%s 对 %s 释放 e技能 造成%s伤害 对方血量剩余%s"%
              (self.name,enemy.name,self.e,enemy.blood-self.e))
        # 对方血量减少
        enemy.blood-= self.e
        if enemy.blood <=0:
            print("hero %s GG"% enemy.name)

# 请选择你的英雄
yase = Hero("战士","亚瑟",200,50,30,100)
daji = Hero("法师","妲己",150,10,30,100)

# 妲己在树林中发现了亚瑟

daji.E(yase)
yase.W(daji)
yase.E(daji)
yase.Q(daji)

王者荣耀