python编程思想的进阶
- 面向对象编程思想的前戏(以游戏为参照物)
- 面向过程编程与面向对象编程
- 类与对象的概念
- 代码编写类
- 代码产生对象
- 类与对象的具体操作
面向对象编程思想的前戏
游戏:猫和老鼠 回合制游戏
1.'''需要将游戏的双方的对象分别装进相关的字典'''
cat = {
'name':'tom',
'type':'蓝猫',
'attack_val': 50,
'hp': 100
}
mouses = {
'name':'jerry',
'type':'mouse',
'attack_val':20,
'hp': 100
}
2.封装成函数 减少代码量
def cat(name,age,type,attack_val,hp):
data_dict = {
'name':name,
'age':age,
'type':type,
'attack_val':attack_val,
'hp':hp
}
return data_dict
def mouse(name,age,type,attack_val,hp):
data_dict = {
'name':name,
'age':age,
'type':type,
'attack_val':attack_val,
'hp':hp
}
return data_dict
res1 = cat('tom',18,'blue_cat',8,100)
res2 = mouse('jerry',18,'super_mouse',5,100)
print(res1)
print(res2)
def attack(cat1,mouse1):
print('当前血量:%s'%cat1.get('hp'))
mouse1['hp'] -= cat1.get('attack_val')
print("""cat:%s 攻击了mouse:%s一次 mouse掉血:%s 剩余hp:%s"""%(cat1.get('name'),mouse1.get('name'),cat1.get('attack_val'),mouse1['hp']))
attack(res1,res2)
print(res2)
当然这种做法会产生调用数据混乱的现象需要改进推荐下面的方法
将各自的数据对应到相对应的数据
def cat_again(name,age,type,attack_val,hp):
def cat_attack(cat_res,mouse_res):
print('当前血量为%s'%mouse.get('hp'))
mouse['hp'] -= cat.get('hp')
print("""cat:%s 攻击mouse:%s一次 cat_hp:%s mouse_hp:%s"""%(cat.get('name'),mouse.get('name'),cat['hp'],mouse['hp']))
data_cat = {
'name':'tom',
'type':'type',
'attack_val': 10,
'hp': 100
'cat_attack':cat_attack
}
return data_cat
同理只要稍加修改函数作为mouse的攻击数据就可以了
原理是将函数的数据和相对应的功能绑定
数据相对应后只能由相关数据对应的函数功能所调用数据不会出现jerry调用tom的数据情况编程思想的转变
1. 面向过程的编程
将程序的执行流程化 即分步操作 分布操作过程中解决问题类似递归函数下一伦使用的函数要比上一论简便甚至能够直接解决问题 以atm——购物车为例：
注册：获取用户名其次对比数据
登录： 将注册数据取出 与之登录数据进行比照
添加购物车数据:将用户添加数据输入进购物车 可以取消和再次添加
结算：获取购物车数据调用计算模块将数据校检
类似工厂里的流水数据
2. 面向对象编程
我们在编写代码的面对对象是什么 ：对象是一个容器将数据和功能集合在一起 类似函数体里面夹带数据 上文的猫和老鼠就是函数功能里面添加了功能数据
只要符合数据和功能在相对应的代码里面就是对象
面向过程与面向对象两者没有优劣之分 具体要结合实际情况
甚至很多时候两者是混合在一起的!!! 思想占据的比例不同而已类与对象的概念
对象：数据和功能的载体
类：即类别、种类 相当于所运用函数的共同特征(可以理解为数学中的最大公约数)
80 60 最大公约数是20 相当于 20 就是类
当然 20 和 30 有着最大公约数10 也就是说类本身也可以作为相对于其他类的数据
所以类其实也算对象
python中名言:一切皆对象类与对象的创建
类是对象的爹 这句话说的没错
先定义类 后产生对象 # 类似于生物学的里面的 类 纲 科
学生类
class Student: # class定义函数的类
school = '家里蹲大学' # 类体代码
def choosd_course(self):
print('学生选课功能')
语法结构
'class 类名：
类体代码'
'1. class 是定义 类 的关键字
2. 类名类似于函数体当中的def 最好首字母大写 做到见名知意
类体代码就是存放对象公共数据和公共功能的地方
数据：变量名 = 变量值
功能：函数'
当我们需要查看数据的时候可以用:__dict__来查看
print(Student.__dict__) # 查看数据值 返回一个字典
print(Student.school) # 简便查看类体代码的公共数据
print(Student.__dict__['school']) # 查看类体代码的公共数据
print(Student.__dict__['choose_course'])# 获取类别的属性
print(Student.choose_course) # 简便类别的属性
class Student:
school ='家里蹲大学'
def choose_course(self):
print('学生选课功能')
print(Student.__dict__)
print(Student.school)
print(Student.__dict__['school'])
print(Student.__dict__['choose_course'])
print(Student.choose_course)
res = Student()
res2 = Student()
print(res.__dict__,res2.__dict__)
print(res.school)
print(res2.school)
print(res.choose_course)
print(res2.choose_course)
修改类中的公共数据
Student.school = '北京大学'
print(res.school)
res = Student()
Student.school = '南京大学'
print(res.school)对象的实例比
class Student:
def __init__(self,name,age,hobby):
self.name = name
self.age = age
self.hobby = hobby
# self.__dict__['name'] = name
# self.__dict__['age'] = age
# self.__dict__['hpbby'] = hobby
school = '北京大学'
def choose_course(self):
print('学生选课功能')
res = Student()
res.__dict__['name'] = 'jack'
res.__dict__['age'] = 18
res.__dict__['hobby'] = 'football'
print(res.name)
在添加对象键值对的情况下可以将多余的代码用函数封装的方法减少我们的代码量
class Student:
def init(res,name,age,gender):
res.name = name
res.age = age
res.gender = gender
init('res1','oscar',21,'basketball')
print(res1.name)
简单的封装成函数没有提现出面向对象整合的精髓 所以我们将函数写进类里面
class Student:
def init(obj,name,age):
obj.name = name
obj.age = age
school = '北京大学'
def chooes_course(self):
print('学生选课')
res = Student()
res2 = Student()
Student.init(res,'jim',18)
print(res.name)
类中针对给对象创建独有数据的函数名 专门定义了一个固定的方法
class Student:
def __init__(res,name,age,gender):
res.name= name
res.age = age
res.gender = gender
res1 = Student('jack',18,'football')
print(res1.name)
类中的__init__方法会在类产生对象的时候自动执行
类产生对象的具体步骤
1.先创建一个没有独有数据的空对象 {}
2.将空对象和类括号内传入的数据一并交给__init__执行
__init__的第一个参数就是对象本身
__init__(obj,name,age,gender)
3.将创建好的对象自动返回
给你提供这种方式能够减少代码的编写
绑定方法
在类中定义的函数默认都是绑定给对象使用的
即对象来调 会自动将对象当做第一个参数传入
class Student:
school = '清华大学'
# __init__方法不要自己去调用
def __init__(self, name, age):
self.name = name
self.age = age
def course(self):
print(self)
def choose_course(self):
print('姓名%s'%self.name)
def chooes(self):
print('年龄%s'%self.age)
res = Student('jack',18)
# 需要调用几个函数 有几个参数就需要传几个参数
# 对象调用类中函数 会将当前调用的对象当做第一个参数自动传入
Student.course(10086)
res.choose_course()
res.chooes()本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
