Python ~ 面向对象 - 基础
本章内容是面向对象编程的基础语法篇
以下是章节和目录
一、面向过程概念
二、面向对象概念
三、类的定义和对象的产生
四、定制对象自己独有的属性
五、属性的查找顺序
文章目录
一、面向过程概念
1、python中的两大范式：
1.面向过程
2.面向对象
他们两个都不是新的技术，而是一种做事的思维方式
2、面向过程
面向过程核心是过程二字，即先干什么，在干什么，最后干什么，也就是机械式的思维方式
3、举例
生活中得例子：把大象放冰箱分几步?
1. 打开冰箱门
2. 把大象放进冰箱
3. 关上冰箱门
4、面向过程优缺点：
优点：把复杂的问题简单化，进而流程化
缺点：扩展性差
使用场景：对扩展性要求不高的地方
面向过程就是一种做事情的思维方式
二、面向对象概念
1. 在程序中：
就是盛放数据属性和功能的集合体/容器
2. 在生活中：
特征与技能的结合体
3. 面向对象的优缺点：
优点：扩展性强
缺点：学习难度大
使用场景：对扩展性要求不高的地方
**面向对象核心是对象二字
在python中，一切皆对象**
三、类的定义和对象的产生
1、类的介绍
- 对象：'特征’与’技能’的结合体
“”" 站在不同的角度，分的种类不一样 “”"
- 类：一系列相似特征与相似技能的结合体
"""
问题来了？到底是先有类还是先有对象？
1. 程序中
# 一定是先定义类，调用类产生对象(****************)
2. 生活中
# 先有对象，在有类
"""
2、类的定义
"""
专业语法来定义类
class 类名():
pass
def index():
pass
"""
##################################
"""
语法格式：
class 类名():
pass
def 方法名（）:
pass
1. 类名的命名遵循变量的命名规范
2. 类名的首字母一般大写
3. 如果类名存在多个单词，一般是大驼峰格式
"""
3、类在定义过程中发生了什么
"""
定义类发生的几件事情？
1. 定义类，会立马执行类体代码
2. 产生类的名称空间，并且把类中的属性和方法名字丢在类的名称空间中，其实就是丢在大字典里
3. 把类的名称空间绑定给__dict__，类名.__dict__
"""
3、如何产生对象？及 对象如何调用方法和属性
class Student():
# 定义一个特征
school = 'SH' # 属性
country = 'China'
# 函数写到类里面叫方法
def choose_course(self, name, courses):
print('%s选课成功%s' % (name, courses))
# 如何查看类的名称空间？
# print(Student.__dict__) # {'school':'SH','choose_course':函数的内存地址}
# 如何产生对象？
stu1 = Student() # 类名()
# stu2 = Student() # 类名()
'''调用类产生对象，得到的额对象就是一个空对象，空字典'''
# print(stu1.__dict__) # {} # 对象有名称空间吗
# print(stu2.__dict__) # {} # 对象有名称空间吗
print(stu1.school)
stu1.choose_course('kevin', "python")
# print(stu1.choose_course('kevin', "python"))
stu1 = Student() # 类名() 这个步骤就是实例化一个对象
print(stu1.school) # 对象调用类的属性
总结：
stu1 = Student()
# 就是 ：实例化类并得到一个对象，通过对象去调用并执行方法。
# 调用类的过程也叫实例化的过程，得到的结果就是一个实例
stu1.choose_course(‘kevin’, “python”)
# 就是：对象去调用并执行方法
print(stu1.school)
# 就是：对象调用类的属性
函数写到类里面叫方法
四、定制对象自己独有的属性
方式一：
__dict__ 如下： 对象产生自己的属性，就是对象自己使用 点 __dict__ 方法添加:(变量 赋值符号 变量值)
class Student():
# 定义一个特征
school = 'SH' # 属性
country = 'China'
# 函数写到类里面叫方法
def choose_course(self, name, courses):
print('%s选课成功%s' % (name, courses))
stu = Student() # 实例化产生的一个对象
print(stu.__dict__) # 查看对象的名称空间
stu.__dict__["name"] = "kevin" # 这个添加属性的方法就是给对象定制自己的属性
print(stu.__dict__) # {'name': 'kevin'}
print(Student.__dict__) # 查看类的属性空间，全局名称空间
# 给对象添加属性其实就是给对象属性的字典添加值
方式二：
点语法（对象属性 加点） 如下： 对象点dict 赋值符号 变量值
class Student():
# 定义一个特征
school = 'SH' # 属性
country = 'China'
# 函数写到类里面叫方法
def choose_course(self, name, courses):
print('%s选课成功%s' % (name, courses))
stu = Student() # 实例化产生的一个对象
print(stu.__dict__) # 查看对象的名称空间
print(Student.__dict__) # 查看类的属性空间，全局名称空间
# stu.__dict__["name"] = "kevin" # 这个添加属性的方法就是给对象定制自己的属性
# print(stu.__dict__) # {'name': 'kevin'}
stu.name = "jack" # 和stu.__dict__["name"] = "kevin" 是一个意思，给对象属性定制自己的属性
print(stu.__dict__)
stu.gae = 20
print(stu.__dict__)
方式三：
初始化方法（ __init__ 和 init ）如下：
init 方法：
__init__ 方法：
# class Student():
# # 定义一个特征
# school = 'SH' # 属性
# country = 'China'
#
# # 函数写到类里面叫方法
# def choose_course(self, name, courses):
# print('%s选课成功%s' % (name, courses))
#
# stu = Student()
# stu2 = Student()
# stu3 = Student()
#
# def init(stu_dict, name, gae, gender):
# stu_dict.name = name
# stu_dict.gae = gae
# stu_dict.gender = gender
# stu_dict.courses = []
# init(stu, "kevin", 20, "male")
# init(stu2, "kevin2", 21, "male")
# init(stu3, "kevin3", 22, "male")
# print(stu.__dict__)
# print(stu2.__dict__)
# print(stu3.__dict__)
class Student():
# 定义一个特征
school = 'SH' # 属性
country = 'China'
# 初始化方法，当类被加括号调用的时候，会自动触发这个函数的执行
def __init__(stu_dict, name, gae, gender):
stu_dict.name = name
stu_dict.gae = gae
stu_dict.gender = gender
stu_dict.courses = []
# 函数写到类里面叫方法
def choose_course(self, name, courses):
print('%s选课成功%s' % (name, courses))
'''类被调用的时候，类里面传的第一个参数是这个类产生的对象'''
# 初始化方法，当类被加括号调用的时候，会自动触发这个函数的执行
stu = Student('kevin', 20, 'male') # # 相当于 stu = Student(stu, 'kevin', 20, 'male')
print(stu.__dict__)
总结：
1、函数写到类里面叫方法
2、初始化方法，当类被加括号调用的时候，会自动触发这个函数的执行
3、类被调用的时候，类里面传的第一个参数是这个类产生的对象
4、调用类的过程就是实例化的过程，得到的结果就是一个实例
五、属性的查找顺序
属性分两种：1. 类属性 2 对象属性
1. 类属性
类属性的查找 如下：
class Student():
# 定义一个特征
school = 'SH' # 属性
country = 'China'
# 函数写到类里面叫方法
def choose_course(self, name, courses):
print('%s选课成功%s' % (name, courses))
# 1. 类属性的查找
print(Student.school)
print(Student.country)
# print(Student.country1) # 查找没有的属性会报错
# 类增加属性
Student.aaa = 'xxx'
print(Student.__dict__)
# 修改
Student.school = 'beijing'
print(Student.__dict__)
# 删除
del Student.school
print(Student.__dict__)
2 对象属性
对象属性的查找 如下：
#########################对象属性
class Student():
# 定义一个特征
school = 'SH' # 属性
country = 'China'
# # 初始化方法，当类被加括号调用的时候，会自动触发这个函数的执行
def __init__(self, name, age, gender, course=[]):
# stu_dict => stu
# stu_dict => stu1
self.name = name # stu.__dict__['name'] = 'kevin'
self.age = age # stu.__dict__['age'] = 20
self.gender = gender # stu.__dict__['gender'] = 'male'
self.courses = course # stu.__dict__['courses'] = []
# 函数写到类里面叫方法
def choose_course(stu_dict, course):
stu_dict['courses'].append(course)
print('%s选课成功%s' % (stu_dict['name'], stu_dict['courses']))
stu = Student('kevin', 20, 'male')
# print(stu.__dict__) # 对象属性，对象调用
# 查看
# print(stu.__dict__['name1'])
# print(stu.name) # 查看不存在的属性 报错
# print(stu.age) # 20
# print(stu.gender) # male
print(stu.school)
# print(stu.__dict__['school']) # 只能从对象自己的属性里面去查找，没有则直接报错
stu.school = 'aaaaa'
print(stu.school)
'''对象的属性查找，先从自己对象属性里面去找，如果找到了，直接返回，如果找不到，在去产生这个对象的类中取查找'''
print(stu.school)
# 增加
stu.aaa = 'xxx'
print(stu.__dict__)
# 修改
stu.name = 'xxxx'
print(stu.__dict__)
# 删除
del stu.name
print(stu.__dict__)
总结：
1、属性分两种：1. 类属性 2 对象属性
2、类属性的查找， 类调用 ， 查找没有的属性会报错。
3、类属性：有查找属性，增加属性，修改属性，删除属性
4、对象属性，对象调用，查看不存在的属性会报错。
5、只能从对象自己的属性里面去查找，没有则直接报错
6、对象的属性查找，先从自己对象属性里面去找，如果找到了，直接返回，如果找不到，在去产生这个对象的类中取查找
7、对象属性：有查找属性，增加属性，修改属性，删除属性
总结
以上就是今天要讲的内容，本文仅仅简单介绍了python~面向对象的基本使用。
1534
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
