游乐游手机版
首页/AI教程/文章详情

人工智能学习Python基础进阶指南

时间：2026-06-18 17:13
先分享几个核心判断：在Python基础进阶阶段，数据结构和算法是绝对的重点，大厂笔试面试几乎都会涉及，尤其是算法思想中的背包问题，考查频率极高。面试环节除了数据结构和算法，操作系统的进程管理、计算机网络的三次握手与客户端服务器交互、MySQL索引优化与调优、Redis——这些在Java开发领域都是重

先分享几个核心判断：在Python基础进阶阶段，数据结构和算法是绝对的重点，大厂笔试面试几乎都会涉及，尤其是算法思想中的背包问题，考查频率极高。面试环节除了数据结构和算法，操作系统的进程管理、计算机网络的三次握手与客户端服务器交互、MySQL索引优化与调优、Redis——这些在Java开发领域都是重中之重，值得投入时间深入研究。而人工智能的学习路径确实充满挑战，数学是基础，目前算力和GPU仍是瓶颈，但相信未来会逐步突破。各类算法必须熟练掌握，特别是基础算法。后续将更新机器学习和深度学习的内容，届时会详细展开。再往后，AI大模型知识和实战项目也会陆续补充。同时，Java的常用框架也会抽时间更新。一起进步吧！

人工智能学习之python基础进阶

一.面向对象

面向对象编程让开发更贴近现实世界——每个对象都被赋予属性和方法，使编程更加直观。它的核心理念是模拟真实世界，在现实生活中，一切事物都可以看作对象。当我们解决问题时，通常会将所需步骤列出，然后按步骤编写代码逐一实现——这种基于步骤的叙事思维，就是面向过程思想。当视角转向操作对象而非步骤时，对象可以是冰箱、手机、电脑等各种现实实体。

举个例子：

# 1.1 定义类，语法：class 类名
class Car:
    # 1.2 定义类方法
    def run(self):
        print('能跑起来...')
        pass

# 2 创建对象，语法：对象名 = 类名()
car01 = Car()
car01.run()

# 3 创建对象，语法：对象名 = 类名()
car02 = Car()
car02.run()

面向对象三大特性：

封装：简单来说，就是将属性和方法封装为一个整体，仅对外提供访问接口。其优点在于简化编程，提升代码安全性。

继承：子类能够复用父类的属性和方法，实现代码重用，降低冗余。

多态：同一个函数（消息）在不同上下文中呈现不同行为，有助于解耦合和扩展。

封装：在面向对象中，封装就是隐藏对象的属性和实现细节，仅对外公开接口，控制程序中属性的读取和修改的访问级别。把抽象得到的数据和行为（或功能）结合成一个有机整体，也就是将数据与操作数据的源代码结合，形成“类”，其中数据和函数都是类的成员。

继承：现实生活中，继承通常指子女继承父辈的财产（如“子承父业”）；在面向对象中，继承是基本特征之一，子类继承父类的属性和方法，使得子类对象具有父类的特征和行为。

多态：多态指不同类的对象对同一消息做出响应，同一消息根据发送对象的不同而采用多种不同的行为方式。简单说，同一个函数在不同场景下表现出不同形态（功能）。

再看个例子：

# 1.1 定义类语法: class 类名:
# 1.2 定义类方法
# 2 创建对象语法: 对象名 = 类名()
# 3 调用方法语法: 对象名.方法名()
# 4 命名
# 大驼峰命名法 MyClassName, 类名多采用大驼峰命名法
# 小驼峰命名法 myClaseName, 变量名对象名多采用小驼峰命名法
# 匈牙利命名法 变量名=属性+类型+对象描述。m_strName 变量名对象名多采用匈牙利命名法

# 1.1 定义类
class Car:
    # 1.1 定义类方法
    def run(self):
        print('能跑起来')
# 2 实例化对象1
car01 = Car()
car01.run()
print('car01:', car01)
# 3 实例化对象2
car02 = Car()
car02.run()
print('car02:', car02)

2.self关键字

# 1 为什么需要self:
# 从Python解释器角度思考: 解决类和对象 1:多 关系
# 对run(self)方法, 哪个对象调用run方法self就是谁
# 2 self作用: 在类的内部调用类的属性和方法, 采用self
# 3 区分类的内部和类的外部
# 小结: 在类外部调用方法用 对象.方法() ；在类的内部调用属性和方法用 self.run

class Car:
    # self: 谁调用类中的run函数, self就代表谁
    def run(self):
        print(f'跑起来, self:{self}')
    # 在类的内部调用类的属性和方法, 采用self
    def work(self):
        self.run()
        pass

mycar01 = Car()
print('mycar01-->', mycar01)
mycar01.run()  # 相当于Car.run(mycar01)
print('-'*55)
mycar02 = Car()
print('mycar02-->', mycar02)
mycar02.run()  # 相当于Car.run(mycar02)
print('-'*55)
mycar03 = Car()
mycar03.work()

3.类内外部添加和获得属性

# 类外部添加属性: 对象.属性名 = 属性值
# 类外部获取属性: 对象.属性名

# 1 定义类
class Car:
    def run(self):
        print('能跑起来...')

# 2 在类的外部 添加属性
car = Car()
car.color = '红色'
car.number = 4
# 3 在类的外部 使用属性
print(f'车的颜色:{car.color}')
print(f'车的轮胎数:{car.number}')

# 注意1
# car2 = Car()
# print(f'车的颜色:{car2.color}')
# print(f'车的轮胎数:{car2.number}')

# 类外部添加属性: 对象.属性名 = 属性值
# 类外部获取属性: 对象.属性名
# 类内部获取属性: self.属性名

# 1 定义类
class Car:
    def run(self):
        print('能跑起来...')
    def show(self):  # 3 类内部获取属性
        print(f'车的颜色:{self.color}')
        print(f'车的轮胎数:{self.number}')

# 2 设置类属性
car = Car()
car.color = '红色'
car.number = 4
# 4 调用show方法
car.show()
# 注意1
# car2 = Car()
# print(f'车的颜色:{car2.color}')
# print(f'车的轮胎数:{car2.number}')

4.有无参init方法

# 魔法方法: 满足规则, 会被python解释器自动调用
# init魔法方法: 新创建对象时，会自动触发__init__()魔法方法

#无参
# 1 定义类
class Car:
    # 定义魔法方法init
    def __init__(self):
        self.color = '红色'
        self.number = 4
    # 定义run方法
    def run(self):
        print('跑起来...')
    # 定义show方法
    def show(self):
        print(f"车的颜色:{self.color}")
        print(f"车的轮胎数:{self.number}")

# 2 实例化对象
mycar = Car()
# 通过show方法访问属性
mycar.show()
# 通过 对象名.属性名 访问属性
print(mycar.color)
print(mycar.number)

# init魔法方法: 创建对象时被python解释器自动调用

#有参
# 1 定义类
class Car:
    # 定义魔法方法init
    def __init__(self, color, number):
        self.color = color
        self.number = number
    # 定义run方法
    def run(self):
        print('跑起来...')
    # 定义show方法
    def show(self):
        print(f"车的颜色:{self.color}")
        print(f"车的轮胎数:{self.number}")

# 2 实例化对象
mycar = Car('红色', 8)
# 通过show方法访问属性
mycar.show()
# 通过 对象名.属性名 访问属性
print(mycar.color)
print(mycar.number)

5.str魔法方法

# str魔法方法:打印print对象时, 被python解释器自动调用, 返回该方法的结果
# 如果不重写str魔法方法: 默认打印对象的内存地址

# 1 定义类
class Car:
    # 定义魔法方法init
    def __init__(self, color, number):
        self.color = color
        self.number = number
    # 定义run方法
    def run(self):
        print('跑起来...')
    # 定义show方法
    def show(self):
        print(f"车的颜色:{self.color}")
        print(f"车的轮胎数:{self.number}")
    def __str__(self):
        # 注意 需要返回str
        # print (f'车的颜色{self.color}, 车的轮胎数{self.number}')
        return (f'车的颜色{self.color}, 车的轮胎数{self.number}')

# 2 实例化对象
mycar = Car('红色', 8)
# 通过show方法访问属性
print('mycar:', mycar)

6.del魔法方法

# del 魔法方法:调用del删除对象或文件执行结束后, python解释器会自动调用该方法

# 1 定义类
class Car:
    # 定义魔法方法init
    def __init__(self, color, number):
        self.color = color
        self.number = number
    # 定义run方法
    def run(self):
        print('跑起来...')
    # 定义show方法
    def show(self):
        print(f"车的颜色:{self.color}")
        print(f"车的轮胎数:{self.number}")
    def __str__(self):
        # 注意 需要返回str
        # print (f'车的颜色{self.color}, 车的轮胎数{self.number}')
        return (f'车的颜色{self.color}, 车的轮胎数{self.number}')
    def __del__(self):
        print('del自动调用了该方法 清理资源')
        pass

def dm01_auto_car():
    # 2 实例化对象
    mycar = Car('红色', 8)
    # 通过show方法访问属性
    print('mycar:', mycar)
    pass
    # 删除对象
    del mycar
    # 对象删除后不能再被使用
    # mycar.run()

if __name__ == '__main__':
    print('dm01_auto_car 111111111')
    dm01_auto_car()
    print('dm01_auto_car 22222222222')

一个综合案例：烤地瓜

# 1 实例化类 SweetPotato
# init 函数 cook_time cook_state condiments
# cook 地瓜被烤函数
# add_condiments 添加调料
# str魔法方法
# 2 用类实例化对象
# 不断的烤地瓜/添加调料, 打印对象状态

# 1 定义类
class SweetPotato():
    # 1.1 初始化属性
    def __init__(self):
        self.cook_time = 0  # 被烤时间
        self.cook_state = '生的'  # 烤的状态
        self.condiments = []  # 调料列表
        pass
    # 1.2 地瓜被烤
    def cook(self, time):
        # 计算总时间
        self.cook_time += time
        # 根据总时间显示地瓜状态
        if 0<= self.cook_time < 3:
            self.cook_state = '生的'
        elif 3<= self.cook_time < 7:
            self.cook_state = '半生不熟'
        elif 7 <= self.cook_time < 12:
            self.cook_state = '熟的'
        elif self.cook_time >= 12:
            self.cook_state = '糊了'
    # 1.3 添加调料
    def add_condiments(self, condiments):
        self.condiments.append(condiments)
    # 1.4 魔法方法str
    def __str__(self):
        return f'这个地瓜被烤的时间:{self.cook_time}, 状态是:{self.cook_state}, 调料是:{self.condiments}'
        pass

if __name__ == '__main__':
    mypotato = SweetPotato()
    print(mypotato)
    mypotato.cook(2)
    mypotato.add_condiments("酱油")
    print(mypotato)
    mypotato.cook(2)
    mypotato.add_condiments("辣椒面")
    print(mypotato)
    mypotato.cook(2)
    print(mypotato)
    mypotato.cook(20)
    print(mypotato)

二.1.类定义的三种方法

# 1 定义类的三种方法
# 2 python中object类是所有类的老祖宗
# 3 万物皆对象

# 定义类 方法1 旧的方式
class Teacher1:
    pass
# 定义类 方法2旧的方式
class Teacher2():
    pass
# 定义类 方法3 后续都用此方法
class Teacher3(object):
    pass

if __name__ == '__main__':
    myt1 = Teacher1()
    myt2 = Teacher2()
    myt3 = Teacher3()
    print(myt1, myt2, myt3)

2.继承的语法

# 1 继承概念: 类B从类A中继承父类的属性和方法
# 2 父类: 基类 子类: 派生类
# 3 继承作用: 提高代码的复用率

# 1 定义父类 属性和方法 room sex work
# 2 定义子类 继承父类
# 3 实例化子类对象, 可使用继承的属性和方法

# 1 定义父类 属性和方法
class Father(object):
    def __init__(self):
        self.room = 4
        self.sex = '男'
    def work(self):
        print('喜欢散步...')
        pass

# 2 定义子类, 继承父类
class Son(Father):
    pass

# 3 实例化子类对象 使用父类的属性和方法
myson = Son()
print(myson.room)
print(myson.work())

if __name__ == '__main__':
    pass

3.单继承和多继承

# 1 定义师父类 Master
# 1.1 定义init初始化 kongfu
# 1.2 定义 make_cake
# 2 定义徒弟类 Prentice 继承师父类
# 3 实例化徒弟类, 调用属性/调用方法

#单继承
# 1 定义师父类 Master
# 1.1 定义init初始化 kongfu
# 1.2 定义 make_cake
class Master(object):
    def __init__(self):
        self.kongfu = '[传统方法]'
    def make_cake(self):
        print(f'使用{self.kongfu}摊煎饼')

# 2 定义徒弟类 Prentice 继承师父类
class Prentice(Master):
    pass

# 3 实例化徒弟类Prentice , 调用属性/调用方法
prentice = Prentice()
print(prentice.kongfu)
prentice.make_cake()

# 如果一个类继承多个父类，优先继承第一个父类的同名属性和方法
# 通过子类的mro()方法 __mro__属性 查看父类的先后顺序
# MRO(Method Resolution Order)：方法解析顺序

# 1 定义师父类 Master
# 1.1 定义init初始化 kongfu
# 1.2 定义 make_cake
# 2 定义HeimaSchool类 /kongfu /make_cake
# 3 定义徒弟类 继承Master HeimaSchool
# 4 实例化徒弟类 Prentice, 调用属性/调用方法
# 5 通过子类的mro()方法 __mro__属性 查看父类的先后顺序

class Master(object):
    def __init__(self):
        self.kongfu = '[传统方法]'
    def make_cake(self):
        print(f'使用{self.kongfu}摊煎饼')

# 2 定义HeimaSchool类 /kongfu /make_cake
class HeimaSchool(object):
    def __init__(self):
        self.kongfu = '[黑马配方]'
    def make_cake(self):
        print(f'使用{self.kongfu}摊煎饼')

# 2 定义徒弟类 继承Master HeimaSchool
class Prentice(Master, HeimaSchool):
    # class Prentice(HeimaSchool, Master):
    pass

# 3 实例化徒弟类, 调用属性/调用方法
xiaoming = Prentice()
# 注: 实例化类对象,不要忘()
print(xiaoming.kongfu)
xiaoming.make_cake()

# 4 通过子类的mro()方法 __mro__属性 查看父类的先后顺序
# Return a type's method resolution order查看源代码
# print(Prentice.mro())
# print(Prentice.__mro__)
# [,
#  ,
#  ,
#  ]
print(Prentice.mro())
print(Prentice.__mro__)

4.多层继承

# 1 定义master类 init方法 make_cake方法
class Master(object):
    def __init__(self):
        self.kongfu = '[传统方法]'
        pass
    def make_cake(self):
        print(f'使用{self.kongfu}摊煎饼')
        pass

# 2 定义HeimaSchool类 /kongfu /make_cake
class HeimaSchool(object):
    def __init__(self):
        self.kongfu = '[黑马配方]'
        pass
    def make_cake(self):
        print(f'使用{self.kongfu}摊煎饼')
        pass

# 3 定义徒弟类 继承Master HeimaSchool
class Prentice(Master, HeimaSchool):
    def __init__(self):
        self.kongfu = '[独创摊煎饼技术]'
        pass
    def make_cake(self):
        print(f'使用{self.kongfu}摊煎饼')
        pass
    # 通过父类名.方法名(self)来调用父类的方法
    def make_master_cake(self):
        Master.__init__(self)
        Master.make_cake(self)
        pass
    def make_school_cake(self):
        HeimaSchool.__init__(self)
        HeimaSchool.make_cake(self)
        pass

# 4 徒孙类 继承徒弟类
class Tusun(Prentice):
    pass

if __name__ == '__main__':
    # 1 实例化 徒孙类对象
    mytusun01 = Tusun()
    # 2 调用各种煎饼果子方法
    mytusun01.make_cake()
    mytusun01.make_master_cake()
    mytusun01.make_school_cake()
    print('多层继承 End')

5.私有属性和方法

# 1 设置私有属性和方法语法: 双下划线开头 eg: self.__money def __make_cake()
# 2 私有属性和方法只能在类的内部使用, 不能被继承
# 3 私有属性通过set_xxx get_xxx方法 获取和修改
# 4 私有方法, 再设置一个公共接口来访问
# 5 总之: 私有属性和私有方法,只能在类的内部使用,不能在类的外部使用. 如果想用则通过公共接口使用

# 1 定义ma
来源：https://blog.csdn.net/2301_79454275/article/details/146765831
学习
上一篇人工智能课程资源哪里找？推荐这几个AI学习平台 下一篇秒懂AI提问，让人工智能成为你的效率神器
本站内容用于信息整理与展示，如有侵权或内容问题请及时联系处理。

相关推荐

补充同频道和同主题内容，方便继续浏览更多相关内容。

从零学Agent三条主线系统掌握大模型应用少走弯路 年实战AI大模型从入门到精通快速入职阿里 普通开发者如何入局AI的大模型入门建议 深度学习神经网络详解人工智能大数据开发UI基础教程 专业AI工具导航与学习平台 连接现在与AI未来 AI系统学习全路径指南从入门到进阶少走弯路 AI产品经理修炼：从产业链到能力提升的大模型资源

同类最新

继续查看同栏目最近更新的文章。

更多
微软Copilot插件安装全流程：浏览器与扩展市场配置
AI教程 · 2026-07-01

微软Copilot插件安装全流程：浏览器与扩展市场配置

围绕MicrosoftCopilot在浏览器、编辑器和扩展市场中的安装与配置，梳理账号准备、安装步骤、权限检查、常见故障及安全使用边界，适合新手快速完成AI办公工具部署。

 Microsoft Copilot Docker 一键部署指南：镜像拉取、端口映射与数据目录配置
AI教程 · 2026-07-01

Microsoft Copilot Docker 一键部署指南：镜像拉取、端口映射与数据目录配置

围绕Copilot类AI办公工具的Docker部署流程，说明镜像选择、拉取校验、端口映射、数据目录挂载、环境变量配置、更新回滚与常见故障处理。

 微软Copilot API密钥注册获取与国内网络配置
AI教程 · 2026-07-01

微软Copilot API密钥注册获取与国内网络配置

围绕MicrosoftCopilot相关接口接入流程，梳理账号准备、Azure资源创建、密钥获取、环境变量配置、国内网络连通性优化、常见报错处理与安全管理要点。

 微软Copilot Linux部署：环境准备到后台运行全流程
AI教程 · 2026-07-01

微软Copilot Linux部署：环境准备到后台运行全流程

MicrosoftCopilot不适合按本地模型方式安装，Linux服务器更常见的是部署企业入口或集成服务。流程需完成账号授权、运行环境、服务配置、反向代理、进程守护与日志监控，并注意数据权限、访问控制和合规边界。

 Microsoft Copilot macOS安装教程：Apple Silicon与Intel配置步骤
AI教程 · 2026-07-01

Microsoft Copilot macOS安装教程：Apple Silicon与Intel配置步骤

MicrosoftCopilot在Mac上可通过网页应用、Edge侧边栏或Microsoft365组件使用，AppleSilicon与Intel机型重点在系统版本、浏览器、账号授权和隐私设置。