python面向对象创建类

*概述*

*面向过程*

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

例如：婚礼筹办

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

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

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

1. 公式：程序 = 算法 + 数据结构

2. 优点：所有环节、细节自己掌控。

3. 缺点：考虑所有细节，工作量大。

*面向对象*

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

例如：婚礼筹办

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

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

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

1. 公式：程序 = 对象 + 交互

2. 优点

(1) 思想层面：

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

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

​ (2) 技术层面：

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

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

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

*类和对象*

1. 类：一个抽象的概念，即生活中的”类别”。

2. 对象：类的具体实例，即归属于某个类别的”个体”。

3. 类是创建对象的”模板”。

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

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

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

*语法*

*定义类*

1. 代码

class 类名:

​ “””文档说明”””

​ &＃8220;def init(self,参数列表):`

​ self.实例变量 = 参数

方法成员

1. 说明

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

– _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. 语法

(1) 定义：

@staticmethod

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

​ 方法体

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

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

1. 说明

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

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

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

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()