python面向对象---创建类

最新推荐文章于 2023-11-13 21:51:29 发布

甲乙zzu

最新推荐文章于 2023-11-13 21:51:29 发布

阅读量363

点赞数

分类专栏： Python 文章标签： python 算法

本文链接：https://blog.youkuaiyun.com/qq_52023825/article/details/120047898

版权

Python 专栏收录该内容

12 篇文章

订阅专栏

面向对象Object Oriented\

概述

面向过程

分析出解决问题的步骤，然后逐步实现。

例如：婚礼筹办

– 发请柬（选照片、措词、制作）

– 宴席（场地、找厨师、准备桌椅餐具、计划菜品、购买食材）

– 婚礼仪式（定婚礼仪式流程、请主持人）

公式：程序 = 算法 + 数据结构
优点：所有环节、细节自己掌控。
缺点：考虑所有细节，工作量大。

面向对象

找出解决问题的人，然后分配职责。

例如：婚礼筹办

– 发请柬：找摄影公司（拍照片、制作请柬）

– 宴席：找酒店（告诉对方标准、数量、挑选菜品）

– 婚礼仪式：找婚庆公司（对方提供司仪、制定流程、提供设备、帮助执行）

公式：程序 = 对象 + 交互
优点

(1) 思想层面：

– 可模拟现实情景，更接近于人类思维。

– 有利于梳理归纳、分析解决问题。

(2) 技术层面：

– 高复用：对重复的代码进行封装，提高开发效率。

– 高扩展：增加新的功能，不修改以前的代码。

– 高维护：代码可读性好，逻辑清晰，结构规整。

类和对象

类：一个抽象的概念，即生活中的”类别”。
对象：类的具体实例，即归属于某个类别的”个体”。
类是创建对象的”模板”。

– 数据成员：名词类型的状态。

– 方法成员：动词类型的行为。

类与类行为不同，对象与对象数据不同。

语法

定义类

代码

class 类名:

“””文档说明”””

``def init(self,参数列表):`

self.实例变量 = 参数

方法成员

说明

– 类名所有单词首字母大写.

– _init_ 也叫构造函数，创建对象时被调用，也可以省略。

– self 变量绑定的是被创建的对象，名称可以随意。

#创建类
class 类名：#类名首字母大写

	def __init__(self，参数)
		#数据成员
    	self.数据1=参数
    #行为成员
    def 方法名称():
        方法体

#创建对象
变量名=类名(参数)

实例变量

实例变量：实例化对象时，每个对象都会有自己的实例变量，各实例变量之间不影响

在构造函数中定义
实例变量由实例对象修改，类修改实例变量没意义
每个实例对象有一份实例变量
实例变量也可以在创建对象后，用对象名.变量名创建或修改实例变量，但不建议这样做

实例方法

在类中定义的函数

def 方法名(self,参数列表)

类成员

类变量

1.语法：

——定义：在类中，方法外定义的变量

——调用：类名.变量名不建议通过对象访问类变量

2.说明

——存储在类中，方法区

——只有一份，类变量会被所有对象所共享

3.作用：描述所有对象的共有数据

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-3rbksoub-1630498312070)(C:\Users\13664\AppData\Roaming\Typora\typora-user-images\image-20210829211735894.png)]

类方法

1.语法

——1）定义：

@classmethod

def 方法名称（cls,参数列表）

方法体

——2)调用：类名.方法名（参数列表）不建议通过对象访问类方法

2.说明：

——至少有一个形参，第一个形参用于绑定类，一般命名为‘cls’

——使用@classmethod修饰的目的是调用类方法时可以（自动）隐式传递类

——类方法中没有对象地址，因此类方法中不能访问类成员，但实例方法中可以访问类成员

3.作用：操作类变量

实例

class ICBC:
    """
    工商银行
    """
    total_money=100000
    #创建类方法
    @classmethod
    def add_money(cls):
        cls.total_money+=100000
    @classmethod
    def print_total_money(cls):
        print(f"总行还剩{ICBC.total_money}元")
        print(f"总行还剩{cls.total_money}元")

    def __init__(self,name,money):
        self.name=name
        self.money=money
        #表示从总行中扣除当前支行使用的金额
        ICBC.total_money-=money

#创建实例对象
i01=ICBC("a支行",10000)
i02=ICBC("b支行",20000)
print(f"总行还剩{ICBC.total_money}元")#总行还剩70000元
#调用类方法
ICBC.add_money()
ICBC.print_total_money()
#总行还剩170000元
#总行还剩170000元

静态方法

将函数移到方法中就是静态方法

语法

(1) 定义：

@staticmethod

def 方法名称(参数列表):

方法体

(2) 调用：类名.方法名(参数列表)

不建议通过对象访问静态方法

说明

– 使用@ staticmethod修饰的目的是该方法不需要隐式传参数。

– 静态方法不能访问实例成员和类成员

作用：定义常用的工具函数。

class Vetor2:
    """
    二维向量
    """
    def __init__(self,x,y):
        self.x=x
        self.y=y
    #将函数移到方法中就是静态方法
    @staticmethod
    def left():
        return  Vetor2(0,-1)

    @staticmethod
    def right():
        return  Vetor2(0,1)

p0=Vetor2(1,2)#c创建一个坐标为1,2的二维向量
l01=Vetor2.left()#向左移动一个单位
#进行移动
p0.x+=l01.x
p0.y+=l01.y
print(p0.x,p0.y)#1 1


class Double_list_helper:
    @staticmethod
    def get_elements(target,vect_pos,vect_dir,count):
        """
        在二维列表中获取指定位置，指定方向，指定数量的元素
        :param target: 二维列表
        :param vect_pos: 指定位置
        :param vect_dir: 指定方向
        :param count: 数量
        :return: 列表
        """
        list_result=[]
        for i in range(count):
            vect_pos.x+=vect_dir.x
            vect_pos.y+=vect_dir.y
            elemnts=target[vect_pos.x][vect_pos.y]
            list_result.append(elemnts)
        return list_result
    
re=Double_list_helper.get_elements(list01,Vetor2(1,0),Vetor2.right(),3)

print(re)#['11', '12', '13']

总结

成员：

实例：对象的数据（变量），对象的行为（方法）

类：类的数据（变量），类的行为（方法）

方法：

实例方法操作实例变量，表示“个体“行为

类方法操作类变量，表示“大家”行为

静态方法不能操作实例变量，或者类方法，但开发过程中以面向对象为基础，所以需要把面向过程的函数变成静态方法写在类中

例子

"""
定义敌人类
数据：姓名，血量，基础攻击力，防御力
行为：打印个人信息
找到名字为乐芙兰的对象
找到血量为0的对象
计算所有敌人的平均攻击力
删除防御力小于30的敌人
"""
class Enemy:
    def __init__(self, name, HP, base_damage, defense):
        self.name=name
        self.HP=HP
        self.base_damage=base_damage
        self.defense=defense
    def print_info(self):#行为：打印个人信息
        print(f"姓名：{self.name}  血量：{self.HP}  "
              f"基础攻击力：{self.base_damage}  防御力：{self.defense}")

    @staticmethod
    def find_enemy(list_e):#找到名字为乐芙兰的对象
        for item in list_e:
            if item.name == "乐芙兰":
                return item

    @staticmethod
    def find_death(list_e):#找到血量为0的对象
        list_d=[]
        for item in list_e:
            if item.HP==0:
                list_d.append(item.name)
        return list_d

    @classmethod#计算所有敌人的平均攻击力
    def average_damage(cls,list_e):
        sum=0
        for item in list_e:
            sum+=item.base_damage
        return sum//len(list_e)
    @classmethod#删除防御力小于30的敌人
    def delete(cls,list_e):
        for i in range(len(list_e)-1,-1,-1):
            """
            倒序删除，因为如果删除对象大于一个，
            正序删除的话每删除一个会让列表索引向前减一，
            这样步长会变成2，
            加入两个要删除的对象在一起，这样只能删除一个
            而倒序没有这样的bug
            """
            if list_e[i].defense<30:
                del list_e[i]

e1=Enemy("墨菲特",660,65,47)
e2=Enemy("卡兹克",643,72,34)
e3=Enemy("乐芙兰",515,65,24)
e4=Enemy("厄斐琉斯",0,65,34)
e5=Enemy("锤石",549,61,30)
list_enemy=[e1,e2,e3,e4,e5]

Enemy.find_enemy(list_enemy).print_info()
print(Enemy.find_death(list_enemy))
print(Enemy.average_damage(list_enemy))

Enemy.delete(list_enemy)

#打印处理后的所有敌人
for item in list_enemy:
    item.print_info()