面向对象基础

一、面向对象

1.什么是面向对象

面向对象是一种编程思想，核心是“对象”二字，对象指的是特征与技能的结合体，

基于该思想编写出程序，就好比在创造一个世界，是一种上帝思维方式。

强调：对象不是凭空产生的，而是需要我们自己设计的

2.面向对象优缺点

优点:

1.扩展型

2.灵活性

3.重用性

缺点:

1.程序的复杂度提高了

2.无法准确预知结果

二、类和对象

1.类

既类型，类别，是一种抽象概念，

是一系列具备相同特征与技能的结合体

2.对象

就是存在的某个事物，具备自己的特征和行为

3.类与对象的关系

类包含对象，对象属于某个类，

在现实世界中：一定是先有对象，后来随着人类文明的发展总结出的类

在程序中，务必保证：先定义类，后调用对象

三、创建类与对象

1.定义类的语法

在python中，定义类，通过class关键字来定义

class Student:  # class为类的名称
    pass
class 后面紧接是类名，即Student,遵循python编码规范，类名通常以大写开头，多个单词使用驼峰命名法

2.创建对象的语法

class Student:
    pass

#创建对象
p = person()

例子：

class Teacher():
    school = "oldboy"
#教师1
T1 = Teacher()
T1.name = 'jason'
T1.age = 18
#教师2
T2 = Teacher()
T2.name = 'egon'
T2.age = 20


#打印的值
print(T1.name,T1.age)  # jason 18
print(T1.age)  # 18

3.属性的写法：

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

也可以写在对象中
对象中的属性，是每个对象独特的

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

练习：描述一个老师，需要包含一个公共属性和一个独特属性

class Teacher:
    school = 'oldboy'  # 学校为公共属性
t1 = Teacher()
t1.name = 'jack'  # 姓名与年龄为独特属性
t1.age = 18

4.属性的增删查改

1.增加属性

对象变量名称.属性名称 = 属性值

2.删除属性

del 对象的变量名称.属性名称

3.修改属性

对象.属性 = 新的值

4.查看属性

访问的是对象的所有属性

print（对象.dict）

访问对象的类信息

print(对象.class)

四、初始化方法init

1.什么是初始化方法

用于为对象的属性设置初始值的函数

2.特点

1.当实例化对象时，会自动执行init方法

2.会自动将对象作为第一个参数传入，参数名称为self,它可以是别的名字，但是不建议修改

功能：用户给对象赋初始值

例子：

class Teacher:
    def __init__(self,name,age):
        self.name = name
        self.age = age

t1 = Teacher('jason',18)

print(t1.age,t1.name)  # 18 jason

3.练习

创建一个类具备几个属性，通过初始化方来给他设置属性

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

d1 = Dog("二哈","黑白",1) 
d1 = Dog("泰迪","棕色",2)


注意:该函数不能有任何返回值/.... 只能是None 规定如此..

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

1.对象的绑定方法

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

其特殊之处在于，当使用对象调用函数时会自动传入对象本身，作为第一个参数

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

练习:写一个学生类，具备一个打招呼的技能，要能输出自己的信息

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


    def say_hi(self):
        print('hello ,my name is %s,my age is %s,my gender is %s ' % (self.name,self.age,self.gender))


stu = Student('jack',18,'male')

stu.say_hi()  # hello ,my name is jack,my age is 18,my gender is male

2.类的绑定方法

类的绑定方法用@classmethod来装饰

特殊之处：无论用类还是对象调用，都会自动传入类本身，作为第一个参数

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

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

例子：

class OldBoyStudent:
    school = "oldboy"

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

    @classmethod
    def show_school(cls):

        print(cls)

    @staticmethod
    def print_hello():
        print("hello world")

stu = OldBoyStudent("jack")

OldBoyStudent.print_hello()
stu.print_hello()  # hello world

3.非绑定方法

俗称静态方法，就是既不需要访问类中的数据，也不需要访问对象的数据

语法:@staticmethod

不常用

练习:为学生类添加一个save方法一个get方法
save是将对象存储到文件中
get是从文件中获取对象

import os
import pickle
import time


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

    def say_hi(self):
        print("name:",self.name)

    def save(self):
        with open(self.name,"wb") as f:
            pickle.dump(self,f)

    @staticmethod
    def get(name):
        with open(name,"rb") as f:
            obj = pickle.load(f)
            return obj

七、对象之间交互练习

需求设计王者荣耀中的英雄类,每个英雄对象可以对其他英雄对象使用技能

具备以下属性

英雄名称,等级,血量

和Q_hurt,W_hurt,E_hurt 三个属性,表示各技能的伤害量

具备以技能

Q W E

三个技能都需要一个敌方英雄作为参数,当敌方血量小于等于0时角色死亡

代码实现:

import random
import time


class Hero:

    def __init__(self,name,level,blood,att,q_hurt,w_hurt,e_hurt):
        # 简便写法
        lcs = locals()
        lcs.pop("self")
        self.__dict__.update(lcs)

    def attack(self,enemy):
        enemy.blood -= self.att
        print("%s对%s释放了普通攻击 造成了%s的伤害 敌人剩余血量%s" % (self.name, enemy.name, self.att, enemy.blood))
        if enemy.blood <= 0:
            print("%s被%s使用普通攻击击杀了" % (enemy.name,self.name))


    def Q(self,enemy):
        enemy.blood -= self.q_hurt
        print("%s对%s释放了Q 造成了%s的伤害 敌人剩余血量%s" % (self.name, enemy.name, self.q_hurt, enemy.blood))
        if enemy.blood <= 0:
            print("%s被%s使用Q技能击杀了" % (enemy.name, self.name))

    def W(self,enemy):
        enemy.blood -= self.w_hurt
        print("%s对%s释放了W 造成了%s的伤害 敌人剩余血量%s" % (self.name, enemy.name, self.w_hurt, enemy.blood))
        if enemy.blood <= 0:
            print("%s被%s使用W技能击杀了" % (enemy.name, self.name))

    def E(self,enemy):
        enemy.blood -= self.e_hurt
        print("%s对%s释放了E 造成了%s的伤害 敌人剩余血量%s" % (self.name,enemy.name,self.e_hurt,enemy.blood))

        if enemy.blood <= 0:
            print("%s被%s使用E技能击杀了" % (enemy.name, self.name))


h1 = Hero("亚索",20,2000,100,600,0,1000)
h2 = Hero("妲己",20,2000,100,600,500,1000)
h3 = Hero("鲁班",20,1500,700,100,200,300)
h4 = Hero("蔡文姬",20,2000,10,0,0,10)



# h1.attack(h2)
# h2.Q(h1)
# h2.E(h1)
# h2.W(h1)


#从字典中随机拿出一个值

def  random_hero(heros):
    hero_index = random.randint(1, len(heros))
    return heros[hero_index]


while True:
    # # 把所有的攻击方法装到字典里  为了随机取出一个
    funcs = {1: Hero.Q, 2: Hero.W, 3: Hero.E, 4: Hero.attack}
    func_index = random.randint(1, 4)
    func = funcs[func_index]


    # 把所有的英雄方法装到字典里  为了随机取出一个
    heros = {1: h1, 2: h2, 3: h3, 4: h4}
    hero = random_hero(heros)

    # 剩余的英雄们
    other_heros = {}
    new_index = 1
    for k, v in heros.items():
        if v != hero:
            other_heros[new_index] = v
            new_index += 1

    # 从剩余的英雄中随机挑出一个英雄来挨打
    enemy = random_hero(other_heros)
    # 打他
    func(hero, enemy)
    if enemy.blood <= 0:
        break
    time.sleep(1)

英雄大乱斗