网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。
一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！
- 点餐
- 结账
面向对象的业务逻辑
- 新建餐馆对象
- 餐馆对象.建立菜谱
- 餐馆对象.展示菜谱
- 新建客人c1
- 新建客人c2
- 客人c1.点餐青椒肉丝、皮蛋豆腐
- 客人c2.点餐皮蛋豆腐、新疆大盘鸡
- 餐馆对象.结算餐费(客人c1.结账)
- 餐馆对象.结算餐费(客人c2.结账)
业务逻辑和顺序结构类似，但是业务逻辑都分配到各个对象，封装性更强了。
面向对象编程可以核心思想为在面向过程编程的基础上将业务逻辑又抽象了一层，以业务逻辑的参与方进行划分，然后将参与方的特征和行为封装在一起。最终也会调用对象的属性和方法按照步骤实现业务需求。
- 面向过程编程适用于简单的应用场景，面向对象编程适用于复杂的业务场景
- 面向对象编程更加适应复杂的需求变化，因为对象相关的代码都封装在一起，在需求变更时也更容易快速迭代；而面向过程编程相关代码都分散在不同的位置，维护迭代时相对困难。
2. 类和对象
类是分类，是模板，对象是基于类创建的一个具体的实例。
例如人是一个类，人有五官、四肢、有智慧，会吃饭、睡觉、学习，张三是具体一个人，他有人这一个分类的所有特征和行为。
class Person:
pass
# p1和p2是基于同一个类创建的两个不同的实例
p1 = Person()
p2 = Person()
# 变量的地址是不一样的，指向2个不同的对象
print(id(p1), id(p2))
2225665760280 2225665760224
3. 类的定义
- 定义类的关键字为class
- class后跟的是类名
- 类名后小括号中的是父类，这是类的继承特性，可以继承父类的属性和方法，不继承时可不添加小括号
- 类中可定义对象的属性、类的属性、自定义方法、对象私有属性等
class [class_name](Object):
desc = "自定义类" # 类的属性，所有对象共有
def __init__(self, arg1, arg2, name):
self.arg1 = arg1 # 对象的属性
self.arg2 = arg2
self.__name = name # 对象的私有属性
# 自定义方法
def user_defined_func(self, ...):
pass
3.1 特殊方法：__init__函数
- 类的初始化函数，创建对象的时候就会被执行
- 必须存在，函数名不可更改，双下划线开始双下划线结束；
- 所有类方法的第一个参数必定为self；
- 目的是挂载类的属性，self.开始的属性是对象的属性，其它属性为类的属性，所有对象共有
class menu:
desc = "自定义类" # 类的属性，所有对象共有
def __init__(self, arg1, arg2): # 初始化方法，创建对象时调用
self.arg1 = arg1 # 对象的属性
self.arg2 = arg2
# 自定义方法
def user_defined_func():
pass
3.2 属性
3.2.1 实例属性
使用self定义的属性都是实例属性。
class dish:
def \_\_init\_\_(self, id, name, price):
self.id = id # 实例属性
self.name = name # 实例属性
self.price = price # 实例属性
d1 = dish(1, "青椒肉丝", 22.9)
d2 = dish(2, "新疆大盘鸡", 89.9)
menu = []
menu.append(d1)
menu.append(d2)
for dish_item in menu:
print(dish_item.id, dish_item.name, dish_item.price)
1 青椒肉丝 22.9
2 新疆大盘鸡 89.9
3.2.2 类属性
在类中定义的非self属性属于类的属性，它属于类，类创建的所有实例对象都拥有这个属性，且值一样
class dish:
desc = "菜品销售信息"
def \_\_init\_\_(self, id, name, price):
self.id = id # 实例属性
self.name = name # 实例属性
self.price = price # 实例属性
d1 = dish(1, "青椒肉丝", 22.9)
d2 = dish(2, "新疆大盘鸡", 89.9)
menu = []
menu.append(d1)
menu.append(d2)
print(dish.desc) # 类调用类属性
print(d1.desc) # 对象d1调用类属性
print(d2.desc) # 对象d2调用类属性
菜品销售信息
菜品销售信息
菜品销售信息
3.2.3 动态属性-实例属性
python支持类在创建实例对象动态扩展属性，该属性仅属于该对象，不属于类，其它对象也不存在
# 动态属性仅属于当前实例对象，其它实例对象无该属性
class dish:
desc = "菜品销售信息"
def \_\_init\_\_(self, id, name, price):
self.id = id # 实例属性
self.name = name # 实例属性
self.price = price # 实例属性
d1 = dish(1, "青椒肉丝", 22.9)
d2 = dish(2, "新疆大盘鸡", 89.9)
d1.star = 5 # 动态属性：客户评分，仅属于d1实例对象
d2.star # 之前创建的实例对象无star属性
---------------------------------------------------------------------------
AttributeError Traceback (most recent call last)
<ipython-input-12-2cf61b7d68db> in <module>()
12 d1.star = 5 # 动态属性：客户评分，仅属于d1实例对象
13
---> 14 d2.star
AttributeError: 'dish' object has no attribute 'star'
# 动态属性仅属于当前实例对象，类也无此属性，新创建的实例对象无此属性
class dish:
desc = "菜品销售信息"
def \_\_init\_\_(self, id, name, price):
self.id = id # 实例属性
self.name = name # 实例属性
self.price = price # 实例属性
d1 = dish(1, "青椒肉丝", 22.9)
d2 = dish(2, "新疆大盘鸡", 89.9)
d1.star = 5 # 动态属性：客户评分，仅属于d1实例对象
# 以类创建新的实例对象
d3 = dish(3, "皮蛋豆腐", 18.0)
d3.star # 新创建的对象没有star属性
---------------------------------------------------------------------------
AttributeError Traceback (most recent call last)
<ipython-input-13-a2911ace03c1> in <module>()
16 # 以类创建新的实例对象
17 d3 = dish(3, "皮蛋豆腐", 18.0)
---> 18 d3.star # 新创建的对象没有star属性
AttributeError: 'dish' object has no attribute 'star'
3.2.4 动态属性-类属性
python支持类动态扩展属性，该属性仅属于该类，该类之前和之后创建的对象均会拥有该类属性。该属性修改时会影响到该类的所有实例对象
# 动态属性仅属于当前实例对象，类也无此属性，新创建的实例对象无此属性
class dish:
desc = "菜品销售信息"
def \_\_init\_\_(self, id, name, price):
self.id = id # 实例属性
self.name = name # 实例属性
self.price = price # 实例属性
d1 = dish(1, "青椒肉丝", 22.9)
d2 = dish(2, "新疆大盘鸡", 89.9)
dish.restaurant_name = "秦王阁" # 动态类属性：属于类
# 之前创建的实例对象拥有该属性
print(f"d1:{d1.restaurant\_name}")
# 之后创建的实例对象拥有该属性
d3 = dish(3, "皮蛋豆腐", 18.0)
print(f"d3:{d3.restaurant\_name}")
# 修改动态类属性会影响该类的所有实例对象
dish.restaurant_name = "秦王阁总店"
print(f"d1:{d1.restaurant\_name}, d3:{d3.restaurant\_name}")
d1:秦王阁
d3:秦王阁
d1:秦王阁总店, d3:秦王阁总店
3.2.5 私有属性
在实际开发中，对象的某些属性或方法可能只希望在对象内部使用，而不希望在外部被访问到，将没有必要展示的属性隐藏到类的内部
私有属性就是对象不希望公开的属性
定义方法：双下划线+变量名
__[var_name]
如下代码中的__freshness就是私有属性，在类的外部无法访问该属性。python的实现原理是将属性改名以实现隐藏的目的,在下面的例程中__freshness被重命名为_dish__freshness。
# 动态属性仅属于当前实例对象，类也无此属性，新创建的实例对象无此属性
class dish:
desc = "菜品销售信息"
def \_\_init\_\_(self, id, name, price):
self.id = id # 实例属性
self.name = name # 实例属性
self.price = price # 实例属性
self.__freshness = 0 # 私有属性
d1 = dish(1, "青椒肉丝", 22.9)
d2 = dish(2, "新疆大盘鸡", 89.9)
d1.__freshness
---------------------------------------------------------------------------
AttributeError Traceback (most recent call last)
<ipython-input-2-bbebea90b95d> in <module>()
13 d2 = dish(2, "新疆大盘鸡", 89.9)
14
---> 15 d1.__freshness
AttributeError: 'dish' object has no attribute '__freshness'
# 查看\_\_freshness是否暴露出来，可以看到无\_\_freshness，属性改名为\_dish\_\_freshness
dir(d1)
['__class__',
'__delattr__',
'__dict__',
'__dir__',
'__doc__',
'__eq__',
'__format__',
'__ge__',
'__getattribute__',
'__gt__',
'__hash__',
'__init__',
'__init_subclass__',
'__le__',
'__lt__',
'__module__',
'__ne__',
'__new__',
'__reduce__',
'__reduce_ex__',
'__repr__',
'__setattr__',
'__sizeof__',
'__str__',
'__subclasshook__',
'__weakref__',
'_dish__freshness',
'desc',
'id',
'name',
'price']
3.3 方法
3.3.1 实例方法
类的方法用来描述对象的行为。
类的方法定义和普通函数稍微有点不一样，第一个参数必须为self，表示对象自身
class dish:
desc = "菜品销售信息"
def \_\_init\_\_(self, id, name, price):
self.id = id # 实例属性
self.name = name # 实例属性
self.price = price # 实例属性
# 实例方法的定义
def display\_dish(self): # 自定义函数
print(f"id:{self.id}\tname:{self.name}\tprice:{self.price}")
d1 = dish(1, "青椒肉丝", 22.9)
d2 = dish(2, "新疆大盘鸡", 89.9)
menu = []
menu.append(d1)
menu.append(d2)
for dish_item in menu: # 类的自定义方法
# 实例方法的调用
dish_item.display_dish()
id:1 name:青椒肉丝 price:22.9
id:2 name:新疆大盘鸡 price:89.9
3.3.1 动态实例方法
python支持类在创建实例对象动态扩展方法，该属性仅属于该对象，不属于类，其它对象也不存在
from types import MethodType # 动态方法需要引入模块
class dish:
desc = "菜品销售信息"
def \_\_init\_\_(self, id, name, price):
self.id = id # 实例属性
self.name = name # 实例属性
self.price = price # 实例属性
def display\_dish(self): # 自定义函数
print(f"id:{self.id}\tname:{self.name}\tprice:{self.price}")
d1 = dish(1, "青椒肉丝", 22.9)
d2 = dish(2, "新疆大盘鸡", 89.9)
def update\_price(self, price):
self.price = price
# 动态加载方法，需要MethodType配合使用
d1.update_price = MethodType(update_price, d1)
d1.update_price(36.9)
print(f"d1.price:{d1.price}")
# 其它实例对象无此方法
d2.update_price(69.9)
d1.price:36.9
---------------------------------------------------------------------------
AttributeError Traceback (most recent call last)
<ipython-input-22-46959ca8d4f0> in <module>()
25
26 # 其它实例对象无此方法
---> 27 d2.update_price(69.9)
AttributeError: 'dish' object has no attribute 'update_price'
3.3.2 私有方法
私有方法就是对象不希望公开的方法,只可以在类的内部使用，外部无法访问。下面代码中的__update_price就是私有方法，从dir的输出来看，__update_price也被python改名了，改为_dish__update_price了。
from types import MethodType # 动态方法需要引入模块
class dish:
desc = "菜品销售信息"
def \_\_init\_\_(self, id, name, price):
self.id = id # 实例属性
self.name = name # 实例属性
self.price = price # 实例属性
def display\_dish(self): # 自定义函数
print(f"id:{self.id}\tname:{self.name}\tprice:{self.price}")
def \_\_update\_price(self, price):
self.price = price
def update(self, price):
self.__update_price(price)
d1 = dish(1, "青椒肉丝", 22.9)
d2 = dish(2, "新疆大盘鸡", 89.9)
# 实例对象访问
print(dir(d1)) #
d1.____update_price(39.2)
['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_dish__update_price', 'desc', 'display_dish', 'id', 'name', 'price', 'update']
---------------------------------------------------------------------------
AttributeError Traceback (most recent call last)
<ipython-input-6-bf2ee1f232ce> in <module>()
24 print(dir(d1)) #
25
---> 26 d1.____update_price(39.2)
AttributeError: 'dish' object has no attribute '____update_price'
4. 类的继承和多态
面向对象三大特征：
- 封装:根据职责将属性和方法封装到一个抽象的类中
- 继承:实现代码的重用，相同的代码不需要重复的写
- 多态:以封装和继承为前提，不同的子类对象调用相同的方法，产生不同的执行结果
class Chinese:
def \_\_init\_\_(self, name, age):
self.name = name
self.age = age
def eat(self):
print(f"{self.name}喜欢吃中餐")
def sleep(self):
print(f"{self.name}正在睡觉")
class Southern(Chinese):
def \_\_init\_\_(self, name, age, height):# 子类Southern重载了\_\_init\_\_方法，和父类有差异，新增了height属性
self.name = name
self.age = age
self.height = height
def eat(self, favorate): # 子类Southern重载了eat方法，和父类的参数数量不一样
print(f"{self.name}喜欢吃米饭, 尤其喜欢{favorate}")
return True
class Northern(Chinese):
def eat(self): # 子类Northern重载了eat方法，参数数量和父类一样
print(f"{self.name}喜欢吃面食")
p1 = Chinese("张三", 18)
p1.eat()
s1 = Southern("李四", 20, 190)
s1.eat("黄焖鸡米饭")
s1.sleep()
n1 = Northern("王五", 22)
n1.eat()
**既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上大数据知识点，真正体系化！**
**由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新**
**[需要这份系统化资料的朋友，可以戳这里获取](https://bbs.csdn.net/forums/4f45ff00ff254613a03fab5e56a57acb)**
return True
class Northern(Chinese):
def eat(self): # 子类Northern重载了eat方法，参数数量和父类一样
print(f"{self.name}喜欢吃面食")
p1 = Chinese("张三", 18)
p1.eat()
s1 = Southern("李四", 20, 190)
s1.eat("黄焖鸡米饭")
s1.sleep()
n1 = Northern("王五", 22)
n1.eat()
[外链图片转存中...(img-KuFDbi3R-1715356152342)]
[外链图片转存中...(img-fQ4wSIJr-1715356152342)]
[外链图片转存中...(img-HXpFdOua-1715356152343)]
**既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上大数据知识点，真正体系化！**
**由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新**
**[需要这份系统化资料的朋友，可以戳这里获取](https://bbs.csdn.net/forums/4f45ff00ff254613a03fab5e56a57acb)**
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
