标签：stu1 name course stu dict 内容 print 今日
今日内容详细
面向过程的概念
面向过程核心是过程二字，解决问题的流程， 即先干什么，在干什么，最后干什么
# 举例：
1. 洗衣服
2. 把大象放冰箱中需要几步？
'''
1. 把冰箱门打开
2. 把大象放进去
3. 关上冰箱门
'''
3. 流水线生产饮料
优点：复杂的问题流程化，进而简单化
缺点：牵一发而动全身，扩展性差，可维护性差
应用场景：对扩展性要求不高的地方， eg：安装包的使用
# 注册的功能
'''
1. 用户输入用户名和密码
2. 验证参数
3. 写入文件，注册成功
'''
面向对象
面向对象核心是对象二字
什么是对象?
1. 程序中：
函数:盛放数据的容器
对象：盛放数据和函数的容器
2. 现实生活中：
一切皆对象
对象：特征与技能的结合体
eg：
优点:扩展性强，可维护性强
缺点：编程复杂度高
应用场景：对扩展性要求较高的地方。 eg:微信，qq
# 举例：
以学生选课系统为例
# 版本1：
stu_name = 'jason'
stu_age = 18
stu_gender = 'male'
stu_courses = []
stu1_name = 'ly'
stu1_age = 18
stu1_gender = 'male'
stu1_courses = []
def choose_course(stu_name, stu_courses, course):
stu_courses.append(course)
print('%s选课成功 %s' % (stu_name,stu_courses))
choose_course(stu_name, stu_courses, 'python')
choose_course(stu1_name, stu1_courses, 'linux')
# 版本2：
stu1 = {
'name': 'jason',
'age': 18,
'gender': 'male',
'course': [],
}
stu2 = {
'name': 'ly',
'age': 18,
'gender': 'male',
'course': []
}
def score():
pass
def register():
pass
def choose_course(stu_dict, course):
stu_dict['course'].append(course)
print('%s选课成功 %s' % (stu_dict['name'], stu_dict['course']))
choose_course(stu1, 'python')
choose_course(stu2, 'linux')
# 版本3：
def choose_course(stu_dict, course):
stu_dict['course'].append(course)
print('%s选课成功 %s' % (stu_dict['name'], stu_dict['course']))
stu1 = {
'name': 'jason',
'age': 18,
'gender': 'male',
'course': [],
'choose_course': choose_course
}
stu2 = {
'name': 'ly',
'age': 18,
'gender': 'male',
'course': [],
'choose_course': choose_course
}
stu1['choose_course'](stu1, 'python')
stu2['choose_course'](stu2, 'python')
类的定义和对象的产生
对象: 特征与技能的结合体
类：一系列对象相似的特征与相似的技能的结合体
强调：站在不同的分类，划分的分类不一定一样
# 问题来了：
到底是先有类还是先有对象？
1. 程序中：
必须先定义类，然后调用类产生对象
2. 现实生活中：
先有对象，在有人类
'''
使用专业的语法定义类：
1. 定义函数
def 函数名():
pass
2. 定义类：
class 类名():
pass
'''
# 定义类:
'''
发生了什么事？
1. 立即执行类体代码
2. 产生一个类的名称空间，把类体里面执行的名字都扔到名称空间中(大字典)
3. 把类的名称空间绑定给__dict__, 类名.__dict__
'''
# 类名一般情况首字母大写
class Student():
# 定义一个属性
school = 'SH'
# 定义一个技能(函数)
def choose_course(stu_dict, course):
stu_dict['course'].append(course)
print('%s选课成功 %s' % (stu_dict['name'], stu_dict['course']))
print('>>>>>>')
# 查看类的名称空间
print(Student.__dict__)
# 产生对象
# 调用类产生对象，默认产生的就是一个空对象{}
stu1 = Student()
stu2 = Student()
stu3 = Student()
print(stu1.__dict__)
print(stu2.__dict__)
print(stu3.__dict__)
给对象定制自己独有的属性
# 版本3：
class Student():
# 定义一个属性
school = 'SH'
# 初始化方法
# 调用类自动触发的函数
# 该方法不是一定要定义，需要用到就定义，不需要刻意不定义
def __init__(stu_obj, name, age, gender):
# 空对象.name = name
# 空对象.age = age
# 空对象.gender = gender
stu_obj.name = name # stu1.__dict__['name'] = 'jason'
stu_obj.age = age # stu1.__dict__['age'] = 18
stu_obj.gender = gender # stu1.__dict__['gender'] = 'male'、
# return None # 在这个方法中不能有返回值，
# 定义一个技能(函数)
def choose_course(stu_dict, course):
stu_dict['course'].append(course)
print('%s选课成功 %s' % (stu_dict['name'], stu_dict['course']))
# 调用类发生了几件事？
'''
1. 得到一个空对象
2. 调用了Student.__dict__(空对象,'ly', 18, 'male'),
3. 得到一个初始化的结果。
'''
stu1 = Student('ly', 18, 'male')
stu2 = Student('jason', 18, 'male')
# stu1 = Student()
# print(stu1.__dict__)
# print(stu2.__dict__)
# print(stu1.name)
# print(stu2.name)
# 属性的查找：先从自己的对象中查找，然后在去产生对象的类中取找
stu1.school = 'aaaa'
print(stu1.school)
属性的查找顺序
# 版本3：
class Student():
# 定义一个属性
school = 'SH'
def __init__(self, name, age, gender, course=None):
if course is None:
course = []
self.name = name # stu1.__dict__['name'] = 'jason'
self.age = age # stu1.__dict__['age'] = 18
self.gender = gender # stu1.__dict__['gender'] = 'male'
self.course = course
def choose_course(self, course):
# stu_dict => stu
self.course.append(course)
print('%s选课成功 %s' % (self.name, self.course))
def func(self, name, age):
pass
# 属性的查找：
# 1. 类属性: 在类中写的属性就称为类属性
# 2. 对象属性：在对象自己的名称空间中的属性就是对象属性
# 类属性的查找
# 1. 查
# print(Student.school)
# 2. 增加
# Student.country = 'China'
# 3. 改
# Student.school = 'BJ'
# 4. 删除
# del Student.school
# print(Student.__dict__)
# {}
stu = Student('ly', 18, 'male') # 实例化对象， stu就是一个实例
# 对象属性
# 1. 查
# print(stu.name)
# print(stu.age)
# print(stu.gender)
# 2. 增
# stu.aaa = 'aaa'
#
# # 3. 改
# stu.name = 'bbb'
# 4. 删除
# del stu.name
# print(stu.__dict__)
# 类中的方法，类可以调用，对象也可以调用
# 类调用方法
# Student.choose_course(stu, 'python') # 类来调用，函数的参数有几个就要传几个
# print(Student.choose_course)
# 对象调用方法
# 类中的方法，类可以调用，对象也可以调用, 但是，推荐对象来调用，因为对象来调用，会把自己当成第一个参数传递给函数
stu.choose_course('python') # stu.choose_course(stu， 'python')
class Teacher():
pass
print(isinstance(123, int))
print(isinstance(stu, Teacher))
标签：stu1,name,course,stu,dict,内容,print,今日 来源： https://www.cnblogs.com/gzj6/p/15634838.html
本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享； 2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关； 3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关； 4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除； 5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。