python23__面向对象编程（day31）
2021/7/12 20:36:08
本文主要是介绍python23__面向对象编程（day31），对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！
今日内容概要
- 面向过程概念
- 面向对象概念
- 类的定义和对象的产生
- 属性或者方法的查找
- 练习
面向过程
面向过程：
不是一门技术，是一种编程思想
核心是过程两个字 过程就是先干什么，在干什么，最后干什么， 机械师思维
"""
案例：
把大象关进冰箱
1.打开冰箱
2.把大象放进去
3.关闭冰箱门
案例2：
优点：
复杂的问题简单化，流程化
缺点：
扩展性差，可维护性差
应用场景: 对扩展性要求不高的
问题：
实现用户注册：
1.输入用户名密码
2.验证参数
3.注册
"""
# 1 与用户交互
def interactive():
username = input("请输入用户名：")
password = input("请输入密码：")
email = input("请输入email：")
return {
'username': username,
'password': password,
'email': email,
}
# 2. 验证参数
def check_info(userinfo):
is_valid = True
if len(userinfo['username']) == 0:
print("用户名不能为空")
is_valid = False
if len(userinfo['password']) == 0:
print("密码不能为空")
is_valid = False
if len(userinfo['email']) == 0:
print("email不能为空")
is_valid = False
return {
'is_valid': is_valid,
'userinfo': userinfo
}
# 3. 注册
import json
def register(param):
if param['is_valid']:
with open('userinfo', 'w', encoding='utf-8') as f:
json.dump(param['userinfo'], f)
def main():
userinfo = interactive()
checkinfo = check_info(userinfo)
register(checkinfo)
if __name__ == '__main__':
main()
类的对象
类即类别/种类，是面向对象分析和设计的基石，如果多个对象有相似的数据与功能，那么该多个对象就属于同一种类。有了类的好处是：我们可以把同一类对象相同的数据与功能存放到类里，而无需每个对象都重复存一份，这样每个对象里只需存自己独有的数据即可，极大地节省了空间。所以，如果说对象是用来存放数据与功能的容器，那么类则是用来存放多个对象相同的数据与功能的容器。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-sk5nQFW4-1626092358780)(%E4%BB%8A%E6%97%A5%E7%AC%94%E8%AE%B0.assets/image-20210712201511382.png)]
综上所述，虽然我们是先介绍对象后介绍类，但是需要强调的是：在程序中，必须要事先定义类，然后再调用类产生对象（调用类拿到的返回值就是对象）。产生对象的类与对象之间存在关联，这种关联指的是：对象可以访问到类中共有的数据与功能，所以类中的内容仍然是属于对象的，类只不过是一种节省空间、减少代码冗余的机制，面向对象编程最终的核心仍然是去使用对象。
在了解了类与对象这两大核心概念之后，我们就可以来介绍一下面向对象编程啦。
面向对象编程
类的定义与实例化
我们以开发一个清华大学的选课系统为例，来简单介绍基于面向对象的思想如何编写程序
面向对象的基本思路就是把程序中要用到的、相关联的数据与功能整合到对象里，然后再去使用，但程序中要用到的数据以及功能那么多，如何找到相关连的呢？我需要先提取选课系统里的角色：学生、老师、课程等，然后显而易见的是：学生有学生相关的数据于功能，老师有老师相关的数据与功能，我们单以学生为例，
"""
面向对象：
核心是对象二字，
1.程序里面
对象就是盛放数据属性和功能的容器，
2. 现实中
对象就是特征与技能的结合体
Linux：一切皆文件
优点：扩展性强
缺点：编程复杂度高
应用场景：对扩展性要求较高的场景，比如：qq， 微信
案例：
西天取经
学生选课系统
"""
# 版本1：
# stu1_name = 'egon'
# stu2_name = 'tom'
# stu1_age = 18
# stu2_age = 20
# stu1_gender = 'male'
# stu2_gender = 'male'
# stu1_courses = []
# stu2_courses = []
#
# def choose_course(stu_name, stu_courses,course):
# stu_courses.append(course)
# print("%s 选课成功 %s" % (stu_name, stu_courses))
#
# choose_course(stu1_name ,stu1_courses, 'python全站开发')
# choose_course(stu2_name ,stu2_courses, 'linux全站开发')
# # 版本2
#
# stu1 = {
# 'name':'egon',
# 'age' : 18,
# 'gender' : 'male',
# 'courses': []
# }
#
# stu2 = {
# 'name':'tom',
# 'age' : 18,
# 'gender' : 'male',
# 'courses': []
# }
#
#
# def choose_course(stu_dic,course):
# stu_dic['courses'].append(course)
# print("%s 选课成功 %s" % (stu_dic['name'], stu_dic['courses']))
#
# choose_course(stu1, 'python全站开发')
# choose_course(stu2, 'linux全站开发')
# 版本3
def choose_course(stu_dic,course):
stu_dic['courses'].append(course)
print("%s 选课成功 %s" % (stu_dic['name'], stu_dic['courses']))
stu1 = {
'name':'egon',
'age' : 18,
'gender' : 'male',
'courses': [],
'choose_course':choose_course
}
stu2 = {
'name':'tom',
'age' : 18,
'gender' : 'male',
'courses': [],
'choose_course':choose_course
}
stu1['choose_course'](stu2, 'python开发')
stu2['choose_course'](stu2, 'linux开发')
类的概念
"""
对象：特征和节能的结合体
类：一系列对象相似的特征和相似的技能的结合体
强调：站在不同的角度，划分的分类是不一样的
问题：先有类还是先有对象？
1.现实中：
必须先有对象，在有类
2. 程序中:
必须先定义类，在调用类产生对象
"""
# 定义类
"""
class 类名():
pass
def 函数名():
pass
类名： 一般是首字母大写
"""
class Student():
school = 'SH'
def choose_course(stu_dic, course):
stu_dic['courses'].append(course)
print("%s 选课成功 %s" % (stu_dic['name'], stu_dic['courses']))
# 类的名称空间
print(Student.__dict__)
print(Student.__dict__)
#
#
# # 造对象，调用类，产生对象
stu1 = Student() # 调用类 产生空对象
# stu2 = Student()
#
print(stu1.__dict__)
调用类的过程就是实例化， 得到的对象就是一个实例
定制对象自己独有的属性
# 版本3
"""
产生对象发生了几件事？
1. 产生一个空对象，并且把该空对象当成第一个参数传递
"""
class Student():
school = 'SH'
# 初始化方法
def __init__(stu_obj, name, age, gender, courses=[]):
stu_obj.name = name # stu1.__dict__['name'] = 'egon'
stu_obj.age = age # stu1.__dict__['age'] = 20
stu_obj.gender = gender # stu1.__dict__['gender'] = 'male'
stu_obj.courses = courses # stu1.__dict__['courses'] = []
def choose_course(stu_dic, course):
stu_dic['courses'].append(course)
print("%s 选课成功 %s" % (stu_dic['name'], stu_dic['courses']))
# print(123)
# 类的名称空间
# print(Student.__dict__)
stu1 = Student('egon', 18 ,'male')
print(stu1.__dict__)
# stu2 = Student()
# stu1.name = 'egon' # stu1.__dict__['name'] = 'egon'
# stu1.age = 18 # stu1.__dict__['age'] = 20
# stu1.gender = 'male' # stu1.__dict__['gender'] = 'male'
# stu1.courses = [] # stu1.__dict__['courses'] = []
#
#
# stu2.name = 'tom' # stu2.__dict__['name'] = 'egon'
# stu2.age = 18 # stu2.__dict__['age'] = 20
# stu2.gender = 'male' # stu2.__dict__['gender'] = 'male'
# stu2.courses = [] # stu2.__dict__['courses'] = []
#
# init(stu1, 'egon', 18, 'male')
# init(stu2, 'tom', 18, 'male')
#
#
# print(stu1.__dict__)
# print(stu2.__dict__)
属性查找
class Student():
school = 'SH'
# 初始化方法
def __init__(stu_obj, name, age, gender, courses=[]):
stu_obj.name = name # stu1.__dict__['name'] = 'egon'
stu_obj.age = age # stu1.__dict__['age'] = 20
stu_obj.gender = gender # stu1.__dict__['gender'] = 'male'
stu_obj.courses = courses # stu1.__dict__['courses'] = []
def choose_course(self, course):
self.courses.append(course)
print("%s 选课成功 %s" % (self.name, self.courses))
# print(123)
# 类的名称空间
# print(Student.__dict__)
stu1 = Student('egon', 18 ,'male')
stu2 = Student('tom', 18 ,'male')
# print(stu1.__dict__)
# 1 类的属性查找
# print(Student.__dict__['school'])
# # Student.__dict__['xxx'] = 'xxx'
# del Student.__dict__['xxx']
# Student.xxx = 'xxx'
#
# del Student.xxx
# Student.school = 'MMM'
# print(Student.school)
# print(Student.choose_course)
# Student.choose_course(stu1, 'python')
# 对象操作属性 点语法取值，先从自己对象中取，如果没有，在取类中取值
# print(stu1.school)
#
# stu1.xxx = 'x'
# del stu1.xxx
# stu1.school = 'y'
# Student.school = 'x'
# print(stu1.school)
# 类中的属性是共享给所有对象的，但是，类中的方法是给对象用的, 并且，把对象自己当成第一个参数传递
# stu1.school = 'y'
# print(stu1.school)
#
# print(stu2.school)
stu1.choose_course('python')
小练习
"""
定义个学生类，产生一堆对象
要求：
增加一个计数器，记录产生了多少个对象？
"""
class Student():
school = 'SH'
# 初始化方法
count = 0
def __init__(self, name, age, gender, courses=[]):
self.name = name
self.age = age
self.gender = gender
self.courses = courses
Student.count += 1
def choose_course(self, course):
self.courses.append(course)
print('%s选课成功 %s' % (self.name, self.courses))
stu1 = Student('egon', 18, 'male')
stu2 = Student('eva', 21, 'male')
print(Student.count)
print(stu1.count)
print(stu2.count)
print(stu1.__dict__)
print(Student.__dict__
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-DNsx3na4-1626092358782)(%E4%BB%8A%E6%97%A5%E7%AC%94%E8%AE%B0.assets/image-20210712164245792.png)]
"""
定义两个英雄类，
要求：
1. 英雄要有昵称，生命值， 攻击力
2. 产生两个对象
3. 互相攻击，生命值小于0，判定为死亡
"""
class Hero:
def __init__(self, name, level, attack):
self.name = name
self.level = level
self.attack = attack
def action(self, people):
if people.name == self.name:
print("自己对自己无法进行攻击")
return
people.level -= self.attack
if people.level <= 0:
print('%s已经被%s打死了' % (people.name, self.name))
return
print("%s攻击了%s，%s还剩%s的生命值" % (self.name,people.name, people.name,people.level))
hero1 = Hero('eva', 100, 50)
hero2 = Hero('wyz', 80, 20)
hero2.action(hero1)
hero1.action(hero2)
hero1.action(hero2)
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-JeNhWu1x-1626092358784)(%E4%BB%8A%E6%97%A5%E7%AC%94%E8%AE%B0.assets/image-20210712164610733.png)]
这篇关于python23__面向对象编程（day31）的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！
- 2024-11-12Python编程基础指南
- 2024-11-12Python基础编程教程
- 2024-11-08Python编程基础与实践示例
- 2024-11-07Python编程基础指南
- 2024-11-06Python编程基础入门指南
- 2024-11-06怎么使用python 计算两个GPS的距离功能-icode9专业技术文章分享
- 2024-11-06Python 基础编程入门教程
- 2024-11-05Python编程基础：变量与类型
- 2024-11-05Python编程基础：变量与类型
- 2024-11-04Python编程基础：变量与类型
