先自我介绍一下，小编浙江大学毕业，去过华为、字节跳动等大厂，目前阿里P7
深知大多数程序员，想要提升技能，往往是自己摸索成长，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！
因此收集整理了一份《2024年最新Python全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友。
既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上Python知识点，真正体系化！
由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新
如果你需要这些资料，可以添加V获取：vip1024c （备注Python）
正文
首先，创建一个抽象公共工厂类，并定义一个生产对象的方法
import abc
from factory.fruit import *
class AbstractFactory(object):
“”“抽象工厂”“”
metaclass = abc.ABCMeta
@abc.abstractmethod
def get_fruit(self):
pass
接着，创建抽象工厂类的 3 个子类，并重写方法，创建一个实例对象并返回
class AppleFactory(AbstractFactory):
“”“生产苹果”“”
def get_fruit(self):
return Apple()
class BananaFactory(AbstractFactory):
“”“生产香蕉”“”
def get_fruit(self):
return Banana()
class OrangeFactory(AbstractFactory):
“”“生产橘子”“”
def get_fruit(self):
return Orange()
最后的使用方式如下：
if name == ‘main’:
每个工厂负责生产自己的产品也避免了我们在新增产品时需要修改工厂的代码，而只要增加相应的工厂即可
instance_apple = AppleFactory().get_fruit()
instance_banana = BananaFactory().get_fruit()
instance_orange = OrangeFactory().get_fruit()
print(instance_apple)
print(instance_banana)
print(instance_orange)
第 3 种，抽象工厂
如果一个工厂要生产多个产品，使用工厂方法的话，就需要编写很多工厂类，不太实用，使用抽象工厂就可以很好的解决这个问题
以川菜馆和湘菜馆炒两个菜，毛血旺和小炒肉为例
首先，创建川菜毛血旺、川菜小炒肉、湘菜毛血旺、湘菜小炒肉 4 个类
class MaoXW_CC(object):
“”“川菜-毛血旺”“”
def str(self):
return “川菜-毛血旺”
class XiaoCR_CC(object):
“”“川菜-小炒肉”“”
def str(self):
return “川菜-小炒肉”
class MaoXW_XC(object):
“”“湘菜-毛血旺”“”
def str(self):
return “湘菜-毛血旺”
class XiaoCR_XC(object):
“”“湘菜-小炒肉”“”
def str(self):
return “湘菜-小炒肉”
然后，定义一个抽象工厂类，内部定义两个方法，可以生成毛血旺和小炒肉
class AbstractFactory(object):
“”"
抽象工厂
既可以生产毛血旺，也可以生成小炒肉
“”"
metaclass = abc.ABCMeta
@abc.abstractmethod
def product_maoxw(self):
pass
@abc.abstractmethod
def product_xiaocr(self):
pass
接着，创建抽象工厂类的两个子类，川菜工厂和湘菜工厂，重写方法，然后创建对应的实例对象返回
class CCFactory(AbstractFactory):
“”“川菜馆”“”
def product_maoxw(self):
return MaoXW_CC()
def product_xiaocr(self):
return XiaoCR_CC()
class XCFactory(AbstractFactory):
“”“湘菜馆”“”
def product_maoxw(self):
return MaoXW_XC()
def product_xiaocr(self):
return XiaoCR_XC()
最后，使用川菜工厂和湘菜工厂分别炒两个菜
if name == ‘main’:
川菜炒两个菜，分别是：毛血旺和小炒肉
maoxw_cc = CCFactory().product_maoxw()
xiaocr_cc = CCFactory().product_xiaocr()
print(maoxw_cc, xiaocr_cc)
maoxw_xc = XCFactory().product_maoxw()
xiaocr_xc = XCFactory().product_xiaocr()
print(maoxw_xc, xiaocr_xc)
3. 构建者模式
构建者模式，是将一个复杂对象的构造与表现进行分离，利用多个步骤进行创建，同一个构建过程可用于创建多个不同的表现
简单来说，就是将一个复杂对象实例化的过程，按照自己的想法，一步步设置参数，定制一个我们需要的对象
构建者模式一般由 Director（指挥官）和 Builder（建设者）构成
其中：
Builder 用于定义目标对象部件的方法和参数
Director 用于构造一个 Builder 的接口，由 Director 去指导 Builder 生成一个复杂的对象
以购买一辆车（ 包含：准备钱、看车、试驾、购买 4 个步骤）为例
首先，定义一个车的实体，并定义属性变量
class Car(object):
def init(self):
准备的钱
self.money = None
去哪里看车
self.address = None
试驾什么车
self.car_name = None
购买时间是
self.buy_time = None
def str(self):
return “准备了：%s,去%s看车，试驾了%s,下单了，购买时间是：%s” % (self.money, self.address, self.car_name, self.buy_time
然后，创建一个 Builder，实例化一个 Car 对象；针对上面 4 个步骤，通过定义 4 个方法
分别是：准备多少钱、去哪里看车、试驾什么车、下单购买的时间
创建者
class CarBuilder(object):
def init(self):
self.car = Car()
def ready_money(self, money):
“”"
准备的金额
:param money:
:return:
“”"
self.car.money = money
sleep(0.5)
return self
def see_car(self, address):
“”"
去哪里看车
:param address:
:return:
“”"
self.car.address = address
sleep(0.5)
return self
def test_drive(self, car_name):
“”"
试驾了什么车
:param car_name:
:return:
“”"
self.car.car_name = car_name
sleep(0.5)
return self
def buy_car(self, buy_time):
“”"
下单时间
:param buy_time:
:return:
“”"
self.car.buy_time = buy_time
sleep(0.5)
return self
接着，创建 Director，创建 build 方法，使用 Builder 一步步构建一个车对象并返回
class Director(object):
def init(self):
self.builder = None
def build(self, builder):
self.builder = builder
self.builder. \
ready_money(“100万”). \
see_car(“4S店”). \
test_drive(“奥迪Q7”). \
buy_car(“2020年8月1日”)
返回构建的对象
return self.builder.car
最后使用的时候，只需要实例化一个 Builder 对象和 Director 对象，然后通过 Director 对象构建一个车对象即可
if name == ‘main’:
实例化一个构建者对象
car_builder = CarBuilder()
实例化一个负责人
director = Director()
构建的对象
car = director.build(car_builder)
print(car)
4. 代理模式
代理模式，会引入一个代理对象以代替真实的对象，解耦调用方和被调用方之间的联系
Python 中的实现方式也简单易懂
首先，我们定义一个真实对象实体类，并定义一个方法
class RealObject(object):
“”"
实际对象
“”"
def init(self, arg):
self.arg = arg
def foo(self):
print(‘参数值为:’, self.arg)
然后，创建一个代理对象，在初始化函数 __init__ 中拿到真实对象的实例，定义一个相同的方法，并调用真实对象的方法
class ProxyObject(object):
“”"
代理对象
“”"
def init(self, real_object):
self.real_object = real_object
def foo(self):
实际对象调用
self.real_object.foo()
最后的使用方式如下：
if name == ‘main’:
实例化代理对象
proxy_object = ProxyObject(RealObject(‘AirPython’))
调用方法
proxy_object.foo()
如此，就实现了代理替换真实对象的目的
5. 观察者模式
观察者模式在 Python 中很常见，会定义了对象之间的一对多依赖关系，当被观察者（也称为主体对象）改变状态时，其他所有观察者都会收到事件并处理预定的事情
首先，我们创建一个观察者，在初始化函数中注册到被观察对象上，并且自定义一个更新函数
观察者
class Observer(object):
def init(self, subject):
初始化观察者，并注册
subject.register(self)
def update(self, arg1):
“”“获取通知”“”
print(‘观察者收到监听消息，参数为：’, arg1)
然后，新建一个被观察对象，创建注册观察者、注销观察者方法
class Subject(object):
def init(self):
所有的观察者
self.observers = []
self.foo = None
def register(self, observer):
“”“添加观察者”“”
if observer not in self.observers:
self.observers.append(observer)
else:
print(‘已经存在，添加失败！’)
def unregister(self, observer):
“”“注销观察者”“”
try:
self.observers.remove(observer)
except ValueError:
print(‘注销观察者失败’
感谢每一个认真阅读我文章的人，看着粉丝一路的上涨和关注，礼尚往来总是要有的：
① 2000多本Python电子书（主流和经典的书籍应该都有了）
② Python标准库资料（最全中文版）
③ 项目源码（四五十个有趣且经典的练手项目及源码）
④ Python基础入门、爬虫、web开发、大数据分析方面的视频（适合小白学习）
⑤ Python学习路线图（告别不入流的学习）
网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。
需要这份系统化的资料的朋友，可以添加V获取：vip1024c （备注python）
一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！
ry:
self.observers.remove(observer)
except ValueError:
print(‘注销观察者失败’
感谢每一个认真阅读我文章的人，看着粉丝一路的上涨和关注，礼尚往来总是要有的：
① 2000多本Python电子书（主流和经典的书籍应该都有了）
② Python标准库资料（最全中文版）
③ 项目源码（四五十个有趣且经典的练手项目及源码）
④ Python基础入门、爬虫、web开发、大数据分析方面的视频（适合小白学习）
⑤ Python学习路线图（告别不入流的学习）
网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。
需要这份系统化的资料的朋友，可以添加V获取：vip1024c （备注python）
[外链图片转存中…(img-bzvB6V8q-1713055727628)]
一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！
534
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
