一、面向对象VS面向过程
1、面向过程
2、面向对象
二、类与对象
1、类和对象
（1）基本概念
类和对象的内存图如下：
2、实例成员
（1）实例变量
（2）实例方法：
3、类成员：
（1）类变量
（2）类方法
4、静态方法：
三、基本代码：
"""
面向对象：考虑问题，从对象的角度出发．
类：模板 抽象
对象：具体
""" class Wife:
"""
老婆
""" # 1.数据成员 姓名 年龄 性别 ．．．
def __init__(self, name, age, sex):
# self "自己"，调用当前方法的对象
print(id(self))
self.name = name
self.age = age
self.sex = sex # 2.方法成员 做饭 ．．．
def cooking(self):
print(id(self))
print(self.name + "做饭") # 创建对象(实例化)
# 调用 __init__(self,name,age,sex) 方法
w01 = Wife("丽丽", 21, "女")
print(id(w01))
# 调用对象的方法 w01 将自身传入方法
w01.cooking() w02 = Wife("芳芳", 22, "男")
w02.cooking()
print(id(w02)) # 在内存中，方法只有一份．而对象有多份．
"""
实例成员
""" # 创建实例成员，可以不在类中．（在实际项目中，仍然会在__init__方法中）
# class Wife01:
# pass
#
#
# w01 = Wife01()
# w01.name = "丽丽"
# print(w01.name)
# print(w01.__dict__)# 此时实例变量是：{'name': '莉莉'}
#
# w01 = Wife01()
# print(w01.__dict__) # 此时实例变量是：｛｝ class Wife02:
def __init__(self,name):
self.name = name w01 = Wife02("丽丽")
w01.name = "莉莉"
print(w01.__dict__)# 此时实例变量是：{'name': '莉莉'}
print(w01.name) w01 = Wife02("丽丽")
print(w01.__dict__)# 此时实例变量是：{'name': '丽丽'} # 创建实例成员，可以不在__init__中．（在实际项目中，仍然会在__init__方法中）
class Wife03:
def __init__(self,name):
self.name = name def fun01(self):
self.age = 10
print("fun01执行喽") w01 = Wife03("丽丽")
# 通过对象调用实例方法，会自动传递对象地址．
w01.fun01()
# 通过类名调用实例方法，
Wife03.fun01(w01)
print(w01.age)
"""
类成员
"""
class ICBC:
"""
工商银行
"""
# 类变量 相当于被大家共享的"饮水机",
moneys = 9999999 # 类方法
@classmethod
def print_total_moneys(cls):
# print(ICBC.moneys)
print("总行金额：",cls.moneys) # 实例方法
def __init__(self,name,money):
# 实例变量：相当于每个人的"杯子"
self.money = money
self.name = name
# 从总行中，扣除当前支行的现金
ICBC.moneys -= money i01 = ICBC("广渠门支行",100000)
# 调用类变量
# print("总行金额：",ICBC.moneys)
# 调用类方法，此时会自动传递类名进入方法
ICBC.print_total_moneys() i02 = ICBC("磁器口支行",100000)
# print("总行金额：",ICBC.moneys)
ICBC.print_total_moneys()
"""
静态方法引入
00 01 02 03
10 11 12 13
20 21 22 23 需求：在某个元素基础上，获取每个方向，指定数量的元素．
10 向右 ３ －－> 11 12 13
21 向上 ２ -->11 01
.....
""" class Vector2:
"""
向量
""" def __init__(self, x=0, y=0):
self.x = x
self.y = y # # 实例方法
# def fun01(self):
# pass
#
# # 类方法
# @classmethod
# def fun02(cls):
# pass
#
# # 静态方法：得不到对象地址／也得不到类名
# @staticmethod
# def fun03():
# pass # v01 = Vector2()
# v01.fun01()# 隐式传递对象地址
#
# Vector2.fun02()# 隐式传递类名
#
# Vector2.fun03() def right():
return Vector2(0,1) def up():
return Vector2(-1,0) # ... # 在某个元素基础上，获取每个方向，指定数量的元素．
def get_elements(list_target, v_pos, v_dir, count):
result = []
for i in range(count):
# 位置 ＋＝ 方向
# 1 0 0 1 －－＞ 1 1
# 1 1 0 1 1 2
# 1 2 0 1 1 3
v_pos.x += v_dir.x
v_pos.y += v_dir.y
result.append(list_target[v_pos.x][v_pos.y])
return result list01 = [
["", "", "", ""],
["", "", "", ""],
["", "", "", ""],
] # 10 向右 ３ －－> 11 12 13
# re01 = get_elements(list01,Vector2(1,0),Vector2(0,1),3)
# 21 向上 ２ -->11 01
# re02 = get_elements(list01,Vector2(2,1),Vector2(-1,0),2) # 10 向右 ３ －－> 11 12 13
re01 = get_elements(list01,Vector2(1,0),right(),3)
print(re01)
re02 = get_elements(list01,Vector2(2,1),up(),2)
print(re02)
五、实例：
练习1
"""
(1)学生student是一个类，具有姓名，年龄等数据；
具有学习study，工作work等行为。
对象：悟空同学，28岁。
八戒同学，29岁。 """
class Student:
"""
学生类
"""
def __init__(self,name,age):
self.name = name
self.age = age def study(self):
print(str(self.age) + "学习") def work(self):
print(self.name+"工作") # s01 悟空对象的地址
s01 = Student("悟空",28)
s02 = Student("八戒",29) # 通过对象地址，调用对象方法，会自动传递对象地址．
s01.study()
s02.work()
练习2：
# 1. 在控制台中输入３个敌人，存入列表．
# 2. 将敌人列表输出（调用print_self）到控制台 class Enemy:
"""
敌人类
"""
def __init__(self,name='',hp=0,atk=0,atk_speed=0):
"""
构造函数
:param name: 敌人姓名
:param hp: 血量
:param atk: 攻击力
:param atk_speed:攻击速度
"""
self.name = name
self.hp = hp
self.atk = atk
self.atk_speed = atk_speed def print_self(self):
"""
打印对象
:return:
"""
print(self.name,self.hp,self.atk,self.atk_speed,sep='--') def input_control(msg):
"""
控制输入数据
:param msg: 提示信息
:return: 返回正确的录入值
"""
while True:
try:
return int(input(msg))
except:
print('输入有误！') def get_enemy_list(n):
"""
获取敌人列表
:param n: 敌人个数
:return: 敌人列表
"""
result_list = []
for i in range(n):
enemy = Enemy()
enemy.name = input('请输入姓名：')
enemy.hp = input_control('请输入血量')
enemy.atk = input_control('请输入攻击力')
enemy.atk_speed = input_control('请输入攻击速度')
result_list.append(enemy)
return result_list def get_enemy_by_name(name_value):
lst = []
for item in enemy_list:
if item.name == name_value:
lst.append(item)
for i in lst:
i.print_self() enemy_list = get_enemy_list(3)
for item in enemy_list:
item.print_self() get_enemy_by_name('张三')
练习3：
"""
二维列表工具
""" class Vector2:
"""
向量
""" def __init__(self, x=0, y=0):
self.x = x
self.y = y # 将函数转移到类中，就是静态方法．
@staticmethod
def right():
return Vector2(0, 1) @staticmethod
def up():
return Vector2(-1, 0) @staticmethod
def left():
return Vector2(0, -1) @staticmethod
def down():
return Vector2(1, 0) @staticmethod
def right_up():
return Vector2(-1, 1) class DoubleListHelper:
"""
二维列表助手类
定义：在开发过程中，所有对二维列表的常用操作．
""" @staticmethod
def get_elements(list_target, v_pos, v_dir, count):
result = []
for i in range(count):
v_pos.x += v_dir.x
v_pos.y += v_dir.y
result.append(list_target[v_pos.x][v_pos.y])
return result # 测试．．．．．．．．．．．．．
list01 = [
["", "", "", ""],
["", "", "", ""],
["", "", "", ""],
] # 10 向右 ３ －－> 11 12 13
re01 = DoubleListHelper.get_elements(list01, Vector2(1, 0), Vector2.right(), 3)
print(re01) # 练习１：在二维列表中，获取23位置，向左，３个元素．
re02 = DoubleListHelper.get_elements(list01, Vector2(2, 3), Vector2.left(), 3)
# 练习２：在二维列表中，获取02位置，向下，２个元素．
re02 = DoubleListHelper.get_elements(list01, Vector2(0, 2), Vector2.down(), 2)
# 练习３：在二维列表中，获取20位置，右上，２个元素．
re02 = DoubleListHelper.get_elements(list01, Vector2(2, 0), Vector2.right_up(), 2)
print(re02)
练习4：
"""
练习： 对象计数器
创建老婆类(名字...)，随意实例化对象．
统计老婆数量（定义方法）
画出内存图
""" class Wife:
# 计数器
count = 0 @classmethod
def get_count(cls):
return Wife.count def __init__(self,name):
# 实例变量
self.name = name
# 统计
Wife.count += 1 w01 = Wife("王超")
w02 = Wife("马汉")
# 通过类名，访问类方法
print(Wife.get_count())
练习5：
"""
以面向对象的思想，描述下列场景.
提示：对象与对象数据不同，类与类行为不同．
张三 教 李四 学习python
李四 教 张三 玩游戏
张三 工作 挣了８０００元
李四 工作 挣了３０００元
""" class Person:
def __init__(self, name):
# 人的姓名
self.name = name
# 人会的所有技能
self.__skills = []
self.__total_money = 0 # 只读属性
@property
def skills(self):
# return self.__skills # 返回可变对象地址,意味着类外仍然可以操作可变对象
return self.__skills[:] # 返回新的可变对象地址,意味着类外仍然操作的是新可变对象,不影响原对象.
# 备注:每次通过切片返回新对象,都会另外开辟空间创建新对象,占用过多内存. # 只读属性
@property
def total_money(self):
return self.__total_money @property
def name(self):
return self.__name @name.setter
def name(self,value):
self.__name = value def teach(self, person_other, str_skill):
# person_other 的技能列表,增加str_skill
person_other.__skills.append(str_skill)
print(self.name, "教了", person_other.name, str_skill) def work(self, money):
self.__total_money += money
print(self.name, "工作挣了", money, "元") zs = Person("张三")
ls = Person("李四")
# 张三 教 李四 学习python
zs.teach(ls, "python")
# 李四 教 张三 玩游戏
ls.teach(zs, "游戏") zs.work(8000)
ls.work(4000) #************************
zs = Person("张三")
# zs.skills = [] # 不能改
# 如果skills属性,返回的是__skills,那么仍然可以操作私有列表
# __skills[:],那么操作的是新列表
zs.skills.append("python")
print(zs.skills)
练习6：
"""
创建技能类(技能名称，冷却时间，持续时间，攻击距离......)
要求：使用属性封装变量
创建技能列表(技能对象的列表)
-- 查找名称是"降龙十八掌"的技能对象
-- 查找名称是持续时间大于１０秒的的所有技能对象
-- 查找攻击距离最远的技能对象
-- 按照持续时间，对列表升序排列．
""" class SkillData:
def __init__(self, name, cd, time, distance):
self.name = name
self.cd = cd
self.time = time
self.atk_distance = distance @property
def name(self):
return self.__name @name.setter
def name(self, value):
self.__name = value @property
def cd(self):
return self.__cd @cd.setter
def cd(self, value):
self.__cd = value @property
def time(self):
return self.__time @time.setter
def time(self, value):
self.__time = value @property
def atk_distance(self):
return self.__atk_distance @atk_distance.setter
def atk_distance(self, value):
self.__atk_distance = value def print_self(self):
print(self.name, self.cd, self.time, self.atk_distance) list_skills = [
SkillData("降龙十八掌", 60, 10, 5),
SkillData("如来神掌", 50, 5, 15),
SkillData("六脉神剑", 80, 20, 8),
SkillData("一阳指", 20, 50, 15),
SkillData("冷酷追击", 15, 30, 9),
] # -- 查找名称是"降龙十八掌"的技能对象
for item in list_skills:
if item.name == "降龙十八掌":
item.print_self() # -- 查找名称是持续时间大于１０秒的的所有技能对象
result = []
for item in list_skills:
if item.time > 10:
result.append(item) # -- 查找攻击距离最远的技能对象
result = list_skills[0]
for i in range(1, len(list_skills)):
# 后面的技能对象
if result.atk_distance < list_skills[i].atk_distance:
result = list_skills[i]
# result.atk_distance = list_skills[i].atk_distance result.print_self() # -- 按照持续时间，对列表升序排列．
for r in range(len(list_skills) - 1):
for c in range(r + 1, len(list_skills)):
if list_skills[r].time > list_skills[c].time:
list_skills[r],list_skills[c] = list_skills[c],list_skills[r] # 请用调试,查看列表的取值.
print(list_skills)