科学偷懒之豆包写教材:Python零基础入门学习教材

把python的几个关键词喂给豆包，让豆包来编辑教材，科学偷懒。

本教材对应思维导图结构，每一个知识点都包含详细概念解释 + 逐行可验证的演示代码 + 核心知识点总结，方便学习和复习。

1. 语言介绍

1.1 什么是 Python？

Python 是一种高级、解释型、面向对象的编程语言，由 Guido van Rossum 于 1991 年发布。

• 高级语言
  ：语法接近自然语言，无需关注底层硬件细节，开发效率极高
• 解释型语言
  ：代码无需提前编译，由 Python 解释器逐行执行，跨平台性强（Windows/Linux/macOS 一套代码通用）
• 面向对象
  ：支持面向对象编程，同时兼容面向过程编程，灵活度高
• 开源免费
  ：开源协议允许自由使用、修改和分发，拥有全球最大的开源社区和第三方库生态

1.2 Python 的核心特点

对于网络工程师 / 运维人员，Python 是自动化运维的核心工具：

• 可以批量配置网络设备（Cisco/Huawei 等）、自动化巡检、故障告警
• 结合 Ansible/SaltStack 等工具，实现大规模服务器 / 网络设备的自动化管理
• 语法简单，零基础也能快速上手，1-2 周即可写出实用的自动化脚本

2. 开发环境安装

2.1 环境选择说明

Python 的开发环境分为解释器和IDE / 编辑器两部分：

• 解释器
  ：Python 代码的运行核心，必须安装
• 编辑器 / IDE
  ：编写代码的工具，推荐新手用 VS Code（轻量、免费、插件丰富），专业开发用 PyCharm

2.2 详细安装步骤（Windows 为例，Linux/macOS 通用逻辑）

步骤 1：下载 Python 解释器

1. 访问 Python 官网：https://www.python.org/downloads/
2. 选择稳定版（推荐 3.10+，如 3.12.x），下载对应系统的安装包
3. 关键注意
   ：安装时必须勾选Add Python.exe to PATH（自动配置环境变量），否则需要手动配置

步骤 2：验证安装成功

打开命令提示符（CMD）/ 终端，输入以下命令：

# 检查Python版本python --version# 或python3 --version# 检查pip（Python包管理器）版本pip --version

如果正常输出版本号，说明安装成功。

步骤 3：安装代码编辑器（VS Code）

1. 下载 VS Code：https://code.visualstudio.com/
2. 安装后，在扩展商店搜索Python，安装微软官方的 Python 插件
3. 配置 Python 解释器：打开 VS Code，按Ctrl+Shift+P，输入Python: Select Interpreter，选择刚才安装的 Python 版本

步骤 4：第一个 Python 程序（验证环境）

在 VS Code 中新建hello.py文件，输入代码：

# 第一个Python程序：打印Hello Worldprint("Hello, Python!")

右键选择「运行 Python 文件」，终端输出Hello, Python!，说明环境完全可用。

3. Python 内置类型

Python 的内置类型是语言的基础数据结构，无需额外导入即可直接使用。

3.1 数字（Number）

3.1.1 概念解释

Python 的数字类型分为 3 种：

• 整数（int）
  ：没有小数部分的数，如10、-5、0，Python 的整数长度无限制（不会溢出）
• 浮点数（float）
  ：带小数部分的数，如3.14、-0.5、1.0
• 复数（complex）
  ：形如a+bj的数，如1+2j，运维场景极少使用，仅作了解

3.1.2 数字的基本运算

# 1. 整数运算a =10# 定义整数变量ab =3# 定义整数变量bprint("a + b =", a + b)# 加法：13print("a - b =", a - b)# 减法：7print("a * b =", a * b)# 乘法：30print("a / b =", a / b)# 除法：3.333...（Python3中/永远返回浮点数）print("a // b =", a // b)# 整除：3（向下取整）print("a % b =", a % b)# 取余：1print("a ** b =", a ** b)# 幂运算：10^3=1000# 2. 浮点数运算c =3.14d =2.0print("c * d =", c * d)# 6.28print("c + d =", c + d)# 5.14# 3. 类型转换num_str ="123"num_int =int(num_str)# 字符串转整数num_float =float(num_str)# 字符串转浮点数print("字符串转整数：", num_int,type(num_int))print("字符串转浮点数：", num_float,type(num_float))

3.1.3 核心知识点总结

• 整数运算/返回浮点数，//是整除，%是取余
• 浮点数存在精度问题（如0.1+0.2=0.30000000000000004），金融计算需用decimal模块
• type()
  函数可以查看变量的数据类型

3.2 字符串与正则表达式

3.2.1 字符串（String）

概念解释

字符串是字符的有序序列，用单引号' '、双引号" "或三引号''' '''/""""""包裹，是 Python 中最常用的数据类型之一。

字符串的基本操作

# 1. 定义字符串s1 ='Hello's2 ="Python"s3 ='''多行字符串可以换行无需转义'''print(s1, s2, s3)# 2. 字符串拼接s4 = s1 +" "+ s2  # 用+拼接字符串print("拼接结果：", s4)# Hello Python# 3. 字符串索引与切片（Python索引从0开始）s ="abcdef"print("索引0的字符：", s[0])# aprint("索引-1的字符：", s[-1])# f（倒数第一个）print("切片s[1:4]：", s[1:4])# bcd（左闭右开，包含1，不包含4）print("切片s[::-1]：", s[::-1])# fedcba（反转字符串）# 4. 字符串常用方法s ="  Hello Python  "print("去除首尾空格：", s.strip())# Hello Pythonprint("转大写：", s.upper())#   HELLO PYTHON  print("转小写：", s.lower())#   hello python  print("替换字符：", s.replace("Python","World"))#   Hello World  print("分割字符串：","a,b,c".split(","))# ['a', 'b', 'c']print("判断是否以Hello开头：", s.startswith("Hello"))# False（因为有空格）print("判断是否包含Python：","Python"in s)# True# 5. 格式化字符串（3种常用方式）name ="工程师"age =40# 方式1：f-string（Python3.6+推荐，最简洁）print(f"我是{name}，今年{age}岁")# 方式2：format()print("我是{}，今年{}岁".format(name, age))# 方式3：%格式化（兼容旧版本）print("我是%s，今年%d岁"%(name, age))

核心知识点总结

• 字符串是不可变类型：修改字符串会生成新的字符串，原字符串不会改变
• 索引从 0 开始，负数索引表示从末尾倒数
• 切片语法：s[起始:结束:步长]，左闭右开，省略起始默认 0，省略结束默认末尾，省略步长默认 1
• f-string 是 Python3.6 + 推荐的格式化方式，语法简洁、性能高

3.2.2 正则表达式（Regular Expression）

概念解释

正则表达式是匹配字符串的规则，用于快速查找、替换、提取符合特定格式的字符串，是网络运维中处理日志、配置文件的核心工具。Python 中通过内置的re模块使用正则表达式。

常用正则元字符

表格正则表达式演示代码

# 导入re模块import re# 1. 匹配：re.match() 从开头匹配，re.search() 全局匹配text ="我的手机号是13800138000，邮箱是test@example.com"# 匹配手机号（11位数字，以1开头）phone_pattern =r"1[3-9]\d{9}"phone = re.search(phone_pattern, text)if phone:print("匹配到的手机号：", phone.group())# 13800138000# 2. 提取：用分组()提取内容ip_text ="服务器IP地址：192.168.1.100，网关：192.168.1.1"# 匹配IP地址，分组提取4段数字ip_pattern =r"(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})"ip_match = re.search(ip_pattern, ip_text)if ip_match:print("完整IP：", ip_match.group(0))# 192.168.1.100print("IP第一段：", ip_match.group(1))# 192print("IP第二段：", ip_match.group(2))# 168# 3. 替换：re.sub() 替换匹配到的内容log ="用户admin登录失败，IP：192.168.1.100"# 替换IP地址为***.***.***.***new_log = re.sub(ip_pattern,"***.***.***.***", log)print("替换后的日志：", new_log)# 用户admin登录失败，IP：***.***.***.***# 4. 分割：re.split() 按正则规则分割字符串text ="a1b2c3d"# 按数字分割split_result = re.split(r"\d", text)print("分割结果：", split_result)# ['a', 'b', 'c', 'd', '']

核心知识点总结

• 正则表达式用 ** 原始字符串r""** 定义，避免转义字符冲突
• re.match()
  仅从字符串开头匹配，re.search()全局匹配，运维场景优先用re.search()
• group(0)
  是完整匹配内容，group(1)、group(2)对应分组提取的内容
• 正则是处理日志、配置文件、网络数据的核心工具，网络工程师必须掌握

3.3 列表（List）

3.3.1 概念解释

列表是可变的有序序列，用方括号[]包裹，元素可以是任意数据类型（数字、字符串、列表等），是 Python 中最灵活的内置类型。

3.3.2 列表的基本操作

# 1. 定义列表list1 =[1,2,3,4,5]# 整数列表list2 =["a","b","c"]# 字符串列表list3 =[1,"hello",[2,3]]# 混合类型列表（包含子列表）print(list1, list2, list3)# 2. 列表索引与切片（和字符串一致）print("list1[0]：", list1[0])# 1print("list1[-1]：", list1[-1])# 5print("list1[1:3]：", list1[1:3])# [2, 3]# 3. 列表修改（可变类型，可直接修改元素）list1[0]=100# 修改第一个元素print("修改后的list1：", list1)# [100, 2, 3, 4, 5]# 4. 列表常用方法list1 =[1,2,3]# 追加元素list1.append(4)print("append后：", list1)# [1, 2, 3, 4]# 插入元素（在索引1的位置插入100）list1.insert(1,100)print("insert后：", list1)# [1, 100, 2, 3, 4]# 删除元素（按值删除）list1.remove(100)print("remove后：", list1)# [1, 2, 3, 4]# 弹出元素（按索引删除，默认最后一个）last = list1.pop()print("pop后：", list1,"弹出的元素：", last)# [1, 2, 3] 4# 列表长度print("列表长度：",len(list1))# 3# 列表排序list4 =[3,1,4,2]list4.sort()# 升序排序（原地修改）print("排序后：", list4)# [1, 2, 3, 4]# 列表反转list4.reverse()print("反转后：", list4)# [4, 3, 2, 1]# 5. 列表拼接与遍历list_a =[1,2]list_b =[3,4]list_c = list_a + list_b  # 拼接列表print("拼接结果：", list_c)# [1, 2, 3, 4]# 遍历列表（for循环，后续会详细讲）for item in list_c:print("列表元素：", item)

3.3.3 核心知识点总结

• 列表是可变类型：可直接修改元素、添加 / 删除元素，原列表会改变
• 列表元素可以是任意数据类型，支持嵌套（多维列表）
• 常用方法：append()追加、insert()插入、remove()按值删除、pop()按索引删除、sort()排序
• len()
  函数可以获取列表长度，for循环是遍历列表的标准方式

3.4 字典（Dictionary）

3.4.1 概念解释

字典是键值对（key-value）的无序集合（Python3.7 + 后为有序），用大括号{}包裹，key必须是不可变类型（字符串、数字、元组），value可以是任意类型。字典是 Python 中最常用的映射型数据结构，用于存储结构化数据（如设备信息、用户信息）。

3.4.2 字典的基本操作

# 1. 定义字典# 存储网络设备信息device ={"name":"核心交换机","ip":"192.168.1.1","vendor":"Cisco","port":22,"status":"online"}print("设备字典：", device)# 2. 访问字典元素（通过key访问）print("设备名称：", device["name"])# 核心交换机print("设备IP：", device["ip"])# 192.168.1.1# 安全访问：get()方法，key不存在时返回默认值，不会报错print("不存在的key：", device.get("model","未知"))# 未知# 3. 修改/添加元素device["port"]=2222# 修改已有key的valuedevice["model"]="C9300"# 添加新的key-valueprint("修改后的字典：", device)# 4. 删除元素del device["status"]# 按key删除print("del后：", device)# pop()方法：按key删除，返回valuevendor = device.pop("vendor")print("pop后：", device,"弹出的value：", vendor)# {'name': '核心交换机', 'ip': '192.168.1.1', 'port': 2222, 'model': 'C9300'} Cisco# 5. 字典常用方法print("所有key：", device.keys())# dict_keys(['name', 'ip', 'port', 'model'])print("所有value：", device.values())# dict_values(['核心交换机', '192.168.1.1', 2222, 'C9300'])print("所有键值对：", device.items())# dict_items([('name', '核心交换机'), ('ip', '192.168.1.1'), ('port', 2222), ('model', 'C9300')])# 6. 遍历字典# 遍历keyfor key in device:print("key：", key)# 遍历key-valuefor key, value in device.items():print(f"{key}: {value}")

3.4.3 核心知识点总结

• 字典的key必须唯一、不可变，value可以重复、任意类型
• 访问元素优先用get()方法，避免 key 不存在时程序崩溃
• 常用方法：keys()获取所有 key、values()获取所有 value、items()获取所有键值对
• 字典是存储结构化数据的首选，运维中常用于存储设备信息、配置参数等

3.5 元组（Tuple）

3.5.1 概念解释

元组是不可变的有序序列，用小括号()包裹，元素可以是任意数据类型。元组和列表的核心区别：元组不可修改，因此更安全、性能更高，常用于存储固定不变的数据。

3.5.2 元组的基本操作

# 1. 定义元组t1 =(1,2,3,4)# 整数元组t2 =("a","b","c")# 字符串元组t3 =(1,"hello",[2,3])# 混合类型元组# 单元素元组必须加逗号，否则会被识别为普通变量t4 =(10,)print("单元素元组：", t4,type(t4))# 2. 元组索引与切片（和列表一致）print("t1[0]：", t1[0])# 1print("t1[1:3]：", t1[1:3])# (2, 3)# 3. 元组不可修改（尝试修改会报错）# t1[0] = 100  # 报错：TypeError: 'tuple' object does not support item assignment# 4. 元组常用方法print("元组长度：",len(t1))# 4print("元素2的索引：", t1.index(2))# 1print("元素1的出现次数：", t1.count(1))# 1# 5. 元组与列表的转换list1 =[1,2,3]t =tuple(list1)# 列表转元组print("列表转元组：", t,type(t))l =list(t)# 元组转列表print("元组转列表：", l,type(l))# 6. 元组的应用场景：函数返回多个值defget_device_info():return"C9300","192.168.1.1","online"model, ip, status = get_device_info()# 元组解包print(f"型号：{model}，IP：{ip}，状态：{status}")

3.5.3 核心知识点总结

• 元组是不可变类型：定义后无法修改元素，因此线程安全、性能更高
• 单元素元组必须加逗号(10,)，否则会被识别为普通变量
• 元组常用于存储固定不变的数据（如 IP 地址、端口号、函数返回值）
• 元组支持解包操作，是函数返回多个值的标准方式

3.6 文件（File）

3.6.1 概念解释

Python 的文件操作是读写本地文件的核心功能，通过内置的open()函数打开文件，支持文本文件、二进制文件的读写，是运维中处理日志、配置文件的基础。

3.6.2 文件操作模式

3.6.3 文件操作演示代码

# 1. 写文件（w模式：覆盖写入）# 方式1：传统open/close（不推荐，容易忘记关闭）f =open("test.txt","w", encoding="utf-8")f.write("第一行内容\n")f.write("第二行内容\n")f.close()# 方式2：with语句（推荐，自动关闭文件，避免资源泄漏）withopen("test.txt","w", encoding="utf-8")as f:    f.write("用with语句写入的第一行\n")    f.write("用with语句写入的第二行\n")# 2. 读文件（r模式）withopen("test.txt","r", encoding="utf-8")as f:# 方式1：read() 一次性读取全部内容    content = f.read()print("全部内容：\n", content)# 逐行读取（适合大文件，避免内存溢出）withopen("test.txt","r", encoding="utf-8")as f:print("逐行读取：")for line in f:# strip() 去除换行符print(line.strip())# 3. 追加文件（a模式：在末尾追加）withopen("test.txt","a", encoding="utf-8")as f:    f.write("追加的第三行内容\n")# 4. 读取追加后的文件withopen("test.txt","r", encoding="utf-8")as f:print("追加后的内容：\n", f.read())# 5. 二进制文件操作（如图片）# 读取图片withopen("test.jpg","rb")as f:    img_data = f.read()# 写入图片（复制）withopen("test_copy.jpg","wb")as f:    f.write(img_data)print("图片复制完成")

3.6.4 核心知识点总结

• 必须用with语句操作文件
  ：自动关闭文件，避免资源泄漏
• 文本文件必须指定encoding="utf-8"，避免中文乱码
• 大文件优先用for line in f逐行读取，避免一次性读取导致内存溢出
• w
  模式会覆盖原文件，a模式是追加，使用时需注意区分

4. 语句与语法

Python 的语句是代码的执行单元，语法简洁，强制缩进（4 个空格）是 Python 的核心语法规则。

4.1 赋值语句

4.1.1 概念解释

赋值语句是给变量分配内存、绑定值的语句，是 Python 中最基础的语句，语法为变量名 = 值。Python 是动态类型语言：变量无需提前声明类型，赋值时自动确定类型。

4.1.2 赋值语句演示代码

# 1. 基本赋值a =10# 整数赋值b ="hello"# 字符串赋值c =[1,2,3]# 列表赋值print(a, b, c)# 2. 多变量赋值a, b, c =1,2,3# 同时给多个变量赋值print(a, b, c)# 交换变量（Python特有，无需临时变量）a, b = b, aprint("交换后：a =", a,"b =", b)# a=2, b=1# 3. 链式赋值a = b = c =100# 多个变量绑定同一个值print(a, b, c)# 4. 增量赋值（复合赋值）a =10a +=5# 等价于 a = a + 5 → 15a -=3# 等价于 a = a - 3 → 12a *=2# 等价于 a = a * 2 → 24a /=4# 等价于 a = a / 4 → 6.0print("增量赋值后a：", a)# 5. 解包赋值（元组/列表/字典解包）# 列表解包list1 =[1,2,3]a, b, c = list1print("列表解包：", a, b, c)# 字典解包（默认解包key）dict1 ={"name":"张三","age":20}a, b = dict1print("字典解包key：", a, b)# 解包valuea, b = dict1.values()print("字典解包value：", a, b)

4.1.3 核心知识点总结

• Python 是动态类型语言，变量无需声明类型，赋值时自动确定
• 交换变量无需临时变量，a, b = b, a是 Python 的语法糖
• 增量赋值+=、-=、*=、/=是常用的简写方式
• 解包赋值是 Python 的特色，常用于函数返回值、遍历等场景

4.2 打印语句

4.2.1 概念解释

打印语句print()是 Python 中输出内容到控制台的内置函数，是调试代码、输出结果的核心工具。

4.2.2 打印语句演示代码

# 1. 基本打印print("Hello World")print(100)print([1,2,3])# 2. 打印多个内容（用逗号分隔，自动加空格）name ="工程师"age =40print("姓名：", name,"年龄：", age)# 姓名： 工程师 年龄： 40# 3. 自定义分隔符（sep参数）print("a","b","c", sep="-")# a-b-c# 4. 自定义结束符（end参数，默认换行\n）print("第一行", end=" ")print("第二行")# 第一行 第二行（不换行）# 5. 格式化打印（结合f-string）name ="工程师"age =40print(f"我是{name}，今年{age}岁")# 格式化数字（保留2位小数）pi =3.1415926print(f"π的值：{pi:.2f}")# π的值：3.14# 6. 打印到文件withopen("print_log.txt","w", encoding="utf-8")as f:print("这是打印到文件的内容",file=f)

4.2.3 核心知识点总结

• print()
  是内置函数，语法为print(*objects, sep=' ', end='\n', file=sys.stdout)
• sep
  参数自定义多个内容的分隔符，end参数自定义结束符
• 结合 f-string 可以实现灵活的格式化输出，是调试代码的核心工具
• 可以通过file参数将内容打印到文件，用于日志记录

4.3 IF 条件语句

4.3.1 概念解释

IF 条件语句是根据条件判断执行不同代码块的语句，是 Python 中流程控制的核心，语法为：

if 条件1:    条件1成立时执行的代码elif 条件2:    条件2成立时执行的代码else:    所有条件都不成立时执行的代码

Python 强制缩进：代码块必须缩进 4 个空格（或 1 个 Tab），缩进是语法的一部分，不是可选的。

4.3.2 IF 条件语句演示代码

# 1. 基本IF语句age =20if age >=18:print("成年")else:print("未成年")# 2. 多条件判断（elif）score =85if score >=90:print("优秀")elif score >=80:print("良好")elif score >=60:print("及格")else:print("不及格")# 3. 多条件组合（and/or/not）# and：两个条件都成立age =25has_id =Trueif age >=18and has_id:print("可以进入网吧")else:print("禁止进入")# or：任意一个条件成立weekday ="周六"if weekday =="周六"or weekday =="周日":print("周末休息")else:print("工作日上班")# not：取反is_login =Falseifnot is_login:print("请先登录")# 4. 嵌套IF语句score =85if score >=60:print("及格")if score >=80:print("良好")else:print("不及格")# 5. 三元表达式（简化IF-ELSE）age =20result ="成年"if age >=18else"未成年"print("三元表达式结果：", result)

4.3.3 核心知识点总结

• Python 强制缩进，代码块必须缩进 4 个空格，缩进错误会导致语法错误
• 条件判断用==（等于）、!=（不等于）、>、<、>=、<=
• 多条件组合用and（与）、or（或）、not（非）
• 三元表达式是if-else的简写，适合简单的条件判断

4.4 While 循环语句

4.4.1 概念解释

While 循环是根据条件循环执行代码块的语句，只要条件为真，就会一直执行，语法为：

while 条件:    循环体代码

常用于未知循环次数的场景（如用户输入验证、日志逐行读取）。

4.4.2 While 循环语句演示代码

# 1. 基本While循环（计算1-10的和）sum=0i =1while i <=10:sum+= i    i +=1# 必须有终止条件，否则会无限循环print("1-10的和：",sum)# 55# 2. 无限循环（while True）+ break终止# 用户输入验证whileTrue:    pwd =input("请输入密码：")if pwd =="123456":print("密码正确")break# 终止循环else:print("密码错误，请重新输入")# 3. continue跳过本次循环# 打印1-10中的偶数i =1while i <=10:if i %2!=0:        i +=1continue# 跳过奇数，进入下一次循环print(i)    i +=1# 4. While-ELSE语句（循环正常结束时执行，break终止时不执行）sum=0i =1while i <=5:sum+= i    i +=1else:print("循环正常结束，和为：",sum)# 15# 循环被break终止，else不执行i =1while i <=5:if i ==3:breakprint(i)    i +=1else:print("循环正常结束")# 不会执行

4.4.3 核心知识点总结

• While 循环必须有终止条件，否则会无限循环（死循环）
• break
  ：终止整个循环，跳出循环体
• continue
  ：跳过本次循环，进入下一次循环
• while-else
  ：循环正常结束时执行 else 代码块，被 break 终止时不执行
• 适合未知循环次数的场景，已知循环次数优先用 For 循环

4.5 For 循环语句

4.5.1 概念解释

For 循环是 ** 遍历可迭代对象（列表、元组、字符串、字典等）** 的循环语句，语法为：

for 变量 in 可迭代对象:    循环体代码

常用于已知循环次数的场景，是 Python 中最常用的循环语句。

4.5.2 For 循环语句演示代码

# 1. 遍历列表list1 =[1,2,3,4,5]for item in list1:print("列表元素：", item)# 2. 遍历字符串s ="Python"for char in s:print("字符串字符：", char)# 3. 遍历字典device ={"name":"交换机","ip":"192.168.1.1","vendor":"Cisco"}# 遍历keyfor key in device:print("字典key：", key)# 遍历key-valuefor key, value in device.items():print(f"{key}: {value}")# 4. range()函数（生成数字序列，常用For循环计数）# 打印1-10for i inrange(1,11):# range(起始, 结束)，左闭右开，结束不包含print(i)# 打印0-9，步长2for i inrange(0,10,2):print(i)# 0,2,4,6,8# 5. break/continue在For循环中的使用# break：终止循环for i inrange(1,11):if i ==5:breakprint(i)# 1,2,3,4# continue：跳过本次循环for i inrange(1,11):if i %2==0:continueprint(i)# 1,3,5,7,9（打印奇数）# 6. For-ELSE语句（和While-ELSE一致）for i inrange(1,6):print(i)else:print("循环正常结束")# 会执行# 被break终止，else不执行for i inrange(1,6):if i ==3:breakprint(i)else:print("循环正常结束")# 不会执行# 7. 嵌套For循环（打印九九乘法表）for i inrange(1,10):for j inrange(1, i+1):print(f"{j}*{i}={i*j}", end="\t")print()# 换行

4.5.3 核心知识点总结

• For 循环用于遍历可迭代对象，是 Python 中最常用的循环
• range()
  函数是 For 循环计数的核心工具，语法range(起始, 结束, 步长)，左闭右开
• break
  终止循环，continue跳过本次循环
• for-else
  ：循环正常结束时执行 else，被 break 终止时不执行
• 嵌套 For 循环用于处理多维数据（如二维列表、九九乘法表）

5. Python 函数

5.1 概念解释

函数是封装可重复使用的代码块，用于实现特定功能，提高代码的复用性、可维护性。Python 的函数分为内置函数（如print()、len()）和自定义函数。

5.2 函数的定义与调用

# 1. 定义函数：def 函数名(参数1, 参数2, ...):#    函数体代码#    return 返回值# 定义加法函数defadd(a, b):"""    计算两个数的和    :param a: 第一个数    :param b: 第二个数    :return: 两数之和    """return a + b# 2. 调用函数result = add(1,2)print("1+2的和：", result)# 3# 3. 无返回值函数defprint_hello(name):print(f"Hello, {name}!")print_hello("工程师")# Hello, 工程师!# 4. 默认参数defgreet(name, msg="你好"):print(f"{msg}, {name}!")greet("工程师")# 你好, 工程师!（使用默认msg）greet("工程师","早上好")# 早上好, 工程师!（自定义msg）# 5. 可变参数（*args：位置可变参数，**kwargs：关键字可变参数）# *args：接收任意多个位置参数，打包为元组defsum_all(*args):    total =0for num in args:        total += numreturn totalprint("sum_all(1,2,3,4)：", sum_all(1,2,3,4))# 10# **kwargs：接收任意多个关键字参数，打包为字典defprint_info(**kwargs):for key, value in kwargs.items():print(f"{key}: {value}")print_info(name="工程师", age=40, job="网络工程师")# 6. 匿名函数（lambda函数，适合简单函数）add_lambda =lambda a, b: a + bprint("lambda加法：", add_lambda(1,2))# 3# 7. 递归函数（函数调用自身，如阶乘）deffactorial(n):if n ==1:return1return n * factorial(n-1)print("5的阶乘：", factorial(5))# 120

5.3 核心知识点总结

• 函数定义用def关键字，必须有冒号，函数体缩进 4 个空格
• return
  语句用于返回值，无 return 时默认返回None
• 默认参数必须放在位置参数后面，避免语法错误
• *args
  接收任意多个位置参数（元组），**kwargs接收任意多个关键字参数（字典）
• lambda 函数是匿名函数，适合简单的一次性函数
• 递归函数必须有终止条件，否则会无限递归导致栈溢出

6. Python 模块

6.1 概念解释

模块是封装了函数、类、变量的 Python 文件（后缀.py），用于将代码拆分到多个文件，提高代码的可维护性、复用性。Python 的模块分为内置模块（如re、os、sys）、第三方模块（如paramiko、requests）和自定义模块。

6.2 模块的导入与使用

# 1. 导入内置模块# 导入整个模块import osprint("当前工作目录：", os.getcwd())# 导入模块中的特定函数/类from os import getcwdprint("当前工作目录：", getcwd())# 导入模块并起别名import os as operating_systemprint("当前工作目录：", operating_system.getcwd())# 2. 自定义模块（示例：创建my_module.py，内容如下）# my_module.py# def say_hello(name):#     print(f"Hello, {name}!")# # PI = 3.14159# 导入自定义模块import my_modulemy_module.say_hello("工程师")print("PI的值：", my_module.PI)# 3. 包的概念：多个模块组成的文件夹，必须包含__init__.py文件# 示例：创建package文件夹，包含module1.py、module2.py、__init__.py# 导入包中的模块from package import module1module1.func1()# 4. 常用内置模块演示# os模块：操作系统相关操作import osprint("当前目录文件：", os.listdir("."))# 列出当前目录文件os.mkdir("test_dir")# 创建文件夹print("创建文件夹成功")# sys模块：Python解释器相关操作import sysprint("Python版本：", sys.version)print("命令行参数：", sys.argv)# datetime模块：日期时间操作from datetime import datetimenow = datetime.now()print("当前时间：", now.strftime("%Y-%m-%d %H:%M:%S"))# 5. 第三方模块安装与使用（以requests为例）# 安装：pip install requestsimport requestsresponse = requests.get("https://www.baidu.com")print("百度响应状态码：", response.status_code)# 200（成功）

6.3 核心知识点总结

• 模块是.py文件，包是包含__init__.py的文件夹
• 导入方式：import 模块、from 模块 import 函数、import 模块 as 别名
• 内置模块无需安装，直接导入使用；第三方模块用pip install 模块名安装
• 常用内置模块：os（操作系统）、sys（解释器）、re（正则）、datetime（时间）、json（JSON 处理）
• 网络运维常用第三方模块：paramiko（SSH 连接）、netmiko（网络设备连接）、ansible（自动化）、requests（HTTP 请求）

7. Python 类

7.1 概念解释

类是面向对象编程的核心，是对象的模板，用于封装属性（变量）和方法（函数）。对象是类的实例，通过类创建对象，实现代码的复用、封装、继承、多态。

7.2 类的定义与使用

# 1. 定义类：class 类名:#    初始化方法__init__：创建对象时自动调用，用于初始化属性#    方法：类中的函数，第一个参数必须是self（代表对象本身）# 定义网络设备类classDevice:# 类属性（所有对象共享）    vendor ="Cisco"# 初始化方法（构造函数）def__init__(self, name, ip, model):# 实例属性（每个对象独有）        self.name = name        self.ip = ip        self.model = model        self.status ="offline"# 实例方法（操作对象属性）defconnect(self):        self.status ="online"print(f"{self.name}({self.ip}) 连接成功，状态：{self.status}")defdisconnect(self):        self.status ="offline"print(f"{self.name}({self.ip}) 断开连接，状态：{self.status}")defget_info(self):returnf"设备名称：{self.name}，IP：{self.ip}，型号：{self.model}，厂商：{self.vendor}，状态：{self.status}"# 2. 创建对象（类的实例化）switch = Device("核心交换机","192.168.1.1","C9300")router = Device("出口路由器","192.168.1.254","ISR4331")# 3. 访问对象属性和方法print(switch.get_info())switch.connect()print(switch.get_info())switch.disconnect()print(router.get_info())router.connect()# 4. 类的继承（子类继承父类的属性和方法，可重写方法）# 定义交换机子类，继承Device类classSwitch(Device):def__init__(self, name, ip, model, port_count):# 调用父类的初始化方法super().__init__(name, ip, model)# 子类新增属性        self.port_count = port_count# 重写父类方法defget_info(self):# 调用父类方法        info =super().get_info()returnf"{info}，端口数：{self.port_count}"# 创建交换机子类对象access_switch = Switch("接入交换机","192.168.1.2","C2960",48)print(access_switch.get_info())access_switch.connect()# 5. 多态（不同类的对象调用相同方法，执行不同逻辑）classRouter(Device):defconnect(self):        self.status ="online"print(f"路由器{self.name}({self.ip}) 连接成功")router = Router("出口路由器","192.168.1.254","ISR4331")switch = Switch("核心交换机","192.168.1.1","C9300",48)# 多态：相同的connect方法，不同的执行逻辑defconnect_device(device):    device.connect()connect_device(router)connect_device(switch)

7.3 核心知识点总结

• 类是对象的模板，对象是类的实例
• __init__
  方法是类的构造函数，创建对象时自动调用，第一个参数必须是self
• 类属性是所有对象共享的，实例属性是每个对象独有的
• 继承：子类继承父类的属性和方法，可重写父类方法，用super()调用父类方法
• 封装：将属性和方法封装在类中，隐藏实现细节，对外提供接口
• 多态：不同类的对象调用相同方法，执行不同逻辑，提高代码的灵活性

学习与复习建议

1. 逐行运行代码
   ：每一个知识点的代码都要自己手动输入、运行，理解每一行的作用
2. 修改代码验证
   ：修改代码中的参数、逻辑，观察运行结果，加深理解
3. 结合运维场景练习
   ：用学到的知识写实用脚本，如批量读取设备 IP、日志分析、自动化巡检
4. 定期复习
   ：每周复习一次思维导图对应的知识点，巩固记忆
5. 循序渐进
   ：从基础到进阶，先掌握内置类型、语句语法，再学习函数、模块、类

后续学习方向（网络运维方向）

学完本教材后，你可以继续学习：

• 网络自动化
  ：paramiko/netmiko（SSH 连接网络设备）、Ansible（自动化配置）
• 数据处理
  ：pandas（日志分析、数据统计）、matplotlib（数据可视化）
• Web 开发
  ：Flask/Django（开发运维平台）
• AI 运维
  ：结合大模型开发智能运维 Agent
• 并发编程
  ：多线程、多进程、异步编程（提高脚本效率）