2.6 万字、38 张图，Python 基础语法全解！
作者：不染-何程龙https://luckylifes.blog.csdn.net/article/details/107044216排版排了一下午，文章很长，正文共：26651字 38图！大家可以先收藏，然后慢慢看，但是一定要记得先拉到底部点一个免费的赞，看看今天这篇文章能不能到100赞，哈哈~文章纯干货！没有一点水分！！！前言：Python是一个高层次的结合了解释性、编译性、互动性和面向对象的脚本语言。本博文主要涉及Python基础入门、流程控制（条件语句、循环语句）、数据序列等知识。本博文若存在任何知识错误，请读者第一时间在评论区指出，方便我修正内容！获取更多内容，请关注博主，在主页进行阅读，感谢您的支持！一、Python简介1. 了解PythonPython是一种解释型（这意味着开发过程中没有了编译这个环节）、面向对象（支持面向对象的风格或代码封装在对象的编程技术）、动态数据类型的交互式（可在命令行中通过Python提示符及直接代码执行程序）高级程序设计语言。
2. Python介绍Python是时下最流行、最火爆的编程语言，具体原因：简单、易学，适应人群广泛
免费、开源应用领域广泛
备注：以下知名框架均是Python语言开发。Google开源机器学习框架：TensorFlow开源社区主推学习框架：Scikit-learn百度开源深度学习框架：Paddle3. Python特点易于学习：Python有相对较少的关键字，结构简单，和一个明确定义的语法，学习起来更加简单。易于阅读：Python代码定义的更清晰。易于维护：Python的成功在于它的源代码是相当容易维护的。一个广泛的标准库：Python的最大的优势之一是丰富的库，跨平台的，在UNIX，Windows和Macintosh兼容很好。互动模式：互动模式的支持，您可以从终端输入执行代码并获得结果的语言，互动的测试和调试代码片断。可移植：基于其开放源代码的特性，Python已经被移植（也就是使其工作）到许多平台。可扩展：如果你需要一段运行很快的关键代码，或者是想要编写一些不愿开放的算法，你可以使用C或C++完成那部分程序，然后从你的Python程序中调用。数据库：Python提供所有主要的商业数据库的接口。GUI编程：Python支持GUI可以创建和移植到许多系统调用。可嵌入: 你可以将Python嵌入到C/C++程序，让你的程序的用户获得'脚本化'的能力。4. Python发展历史Python发展历史：https://baike.baidu.com/item/Python/407313?fr=aladdin5. Python版本Python 2.XPython 3.X二、Python解释器1. 解释器的作用Python解释器作用：运行文件Python解释器种类PyPy，基于Python语言开发的解释器。Jython，运行在Java平台的解释器，直接把Python代码编译成Java字节码执行。IronPython，运行在微软.Net平台上的Python解释器，可以直接把Python代码编译成.Net的字节码。CPython，C语言开发的解释器[官方]，应用广泛的解释器。IPython，基于CPython的一种交互式解释器。其他解释器2. 解释器的安装Python解释器的安装：https://blog.csdn.net/weixin_43495473/article/details/103559812三、PyCharm安装与使用1. PyCharm的作用PyCharm是一种Python IDE（集成开发环境），带有一整套可以帮助用户在使用Python语言开发时提高其效率的工具，内部集成的功能如下：Project管理智能提示语法高亮代码跳转调试代码解释代码(解释器)框架和库…2. PyCharm安装与使用PyCharm的安装：https://blog.csdn.net/weixin_43495473/article/details/103560198四、注释1. 注释的作用通过用自己熟悉的语言，在程序中对某些代码进行标注说明，这就是注释的作用，能够大大增强程序的可读性。2. 注释的分类及语法注释分为两类：单行注释 和 多行注释。单行注释只能注释一行内容，语法如下：# 注释内容多行注释可以注释多行内容，一般用在注释一段代码的情况， 语法如下：''' 第一行注释 第二行注释 第三行注释'''''' 注释1 注释2 注释3'''快捷键： ctrl + /注意：解释器不执行任何的注释内容。五、变量1. 变量的作用变量，简单来说，其实就是计算机内存中的一块储存空间，用来存储CPU需要使用的数据。而这个储存空间需要一个名字，这个名字的统称就叫变量。
作用：用来临时保存数据便于项目的后期升级维护节约内存2. 定义变量变量名 = 值变量名自定义，要满足标识符命名规则。2.1 标识符标识符命名规则是Python中定义各种名字的时候的统一规范，具体如下：由数字、字母、下划线组成不能数字开头不能使用内置关键字严格区分大小写
2.2 命名习惯见名知义。大驼峰：即每个单词首字母都大写，例如：MyName。小驼峰：第二个（含）以后的单词首字母大写，例如：myName。下划线：例如：my_name。2.3 使用变量my_name = '张三'print(my_name)myAge = 23print(myAge)2.4 认识bug所谓bug，就是程序中的错误。如果程序有错误，需要程序员排查问题，纠正错误。2.5 Debug工具Debug工具是PyCharm IDE中集成的用来调试程序的工具，在这里程序员可以查看程序的执行细节和流程或者调解bug。Debug工具使用步骤：打断点Debug调试六、数据类型在 Python 里为了应对不同的业务需求，也把数据分为不同的类型。
检测数据类型的方法：type(变量名或者数值)a = 1print(type(a)) # <class 'int'> -- 整型b = 1.1print(type(b)) # <class 'float'> -- 浮点型c = Trueprint(type(c)) # <class 'bool'> -- 布尔型d = '12345'print(type(d)) # <class 'str'> -- 字符串e = [10, 20, 30]print(type(e)) # <class 'list'> -- 列表f = (10, 20, 30)print(type(f)) # <class 'tuple'> -- 元组h = {10, 20, 30}print(type(h)) # <class 'set'> -- 集合g = {'name': '张三', 'age': 20}print(type(g)) # <class 'dict'> -- 字典思考：为什么Python会提出这么多种的数据类型?有限的内存, 无限的变量, 合理的使用内存Python中，程序员定义变量需要关心变量的类型吗?Python弱类型语言程序员不需要关心变量的类型, 只需要把数据书写正确即可，python会通过自动推到出您变量的类型。七、输出作用：程序输出内容给用户。print('hello Python')age = 18print(age)# 需求：输出“今年我的年龄是18岁”1. 格式化输出
%06d，表示输出的整数显示位数，不足以0补全，超出当前位数则原样输出。%.2f，表示小数点后显示的小数位数。2. 内置函数formatformat()用于字符串格式化，功能非常强大，格式是str.format()，format函数可以接受不限个参数，位置可以不按顺序。3. f-格式化字符串f-string是格式化字符串的一种很好的新方法。与其他格式化方式相比，它不仅更易读，更简洁，不易出错，而且速度更快！格式为：f'{表达式}'。4. 体验格式化字符串name = '张三'age = 23weight = 75.5student_id = 1# 我的名字是张三print('我的名字是%s' % name)# 我的学号是0001print('我的学号是%04d' % student_id)# 我的体重是75.50公斤print('我的体重是%.2f公斤' % weight)# 我的名字是张三，今年23岁了print('我的名字是%s，今年%d岁了' % (name, age))# 我的名字是张三，明年24岁了print('我的名字是%s，明年%d岁了' % (name, age + 1))# 我的名字是张三，明年24岁了print('我的名字是{0}, 明年{1}岁了'.format(name, age+1))# 我的名字是李思，今年18岁了print('我的名字是{0}, 今年{1}岁了'.format('李思', 18))# 我的名字是张三，明年24岁了print(f'我的名字是{name}, 明年{age + 1}岁了')
5. 补充知识字符串输出的本质其实就是拼接字符串，那么我们都用%s完全也是可以的。很多时候，我们不用区分整型、浮点型等，直接用%s输出就可以了。print('我的名字是%s，今年%s岁了，我的体重是%s公斤' % (name, age ,weight))
6. 转义字符\n：换行。\t：制表符，一个tab键（4个空格）的距离。7. 结束符# print会默认换行输出print('输出的内容', end='\n')在Python中，print()， 默认自带end='\n'这个换行结束符，所以导致每两个print直接会换行展示，用户可以按需求更改结束符。# 改变Python换行输出print('内容', end=' ')print('内容', end='···')八、输入在Python中，程序接收用户输入的数据的功能即是输入。
1. 输入的语法input('提示信息')2. 输入的特点当程序执行到input，等待用户输入，输入完成之后才继续向下执行。在Python中，input接收用户输入后，一般存储到变量，方便使用。在Python中，input会把接收到的任意用户输入的数据都当做字符串处理。password = input('请输入您的密码：')print(f'您输入的密码是{password}')# <class 'str'>print(type(password))
九、转换数据类型1. 转换数据类型的作用问：input()接收用户输入的数据都是字符串类型，如果用户输入1，想得到整型该如何操作？答：转换数据类型即可，即将字符串类型转换成整型。2. 转换数据类型的函数
3. 体验转换数据类型需求：input接收用户输入，用户输入“1”，将这个数据1转换成整型。# 1. 接收用户输入num = input('请输入您的幸运数字：')# 2. 打印结果print(f'您的幸运数字是{num}')# 3. 检测接收到的用户输入的数据类型 -- str类型print(type(num))# 4. 转换数据类型为整型 -- int类型print(type(int(num)))# 1. float() -- 转换成浮点型num1 = 1print(float(num1))print(type(float(num1)))# 2. str() -- 转换成字符串类型num2 = 10print(type(str(num2)))# 3. tuple() -- 将一个序列转换成元组list1 = [10, 20, 30]print(tuple(list1))print(type(tuple(list1)))# 4. list() -- 将一个序列转换成列表t1 = (100, 200, 300)print(list(t1))print(type(list(t1)))# 5. eval() -- 将字符串中的数据转换成Python表达式原本类型str1 = '10'str2 = '[1, 2, 3]'str3 = '(1000, 2000, 3000)'print(type(eval(str1)))print(type(eval(str2)))print(type(eval(str3)))十、运算符1. 运算符的分类算数运算符赋值运算符复合赋值运算符比较运算符逻辑运算符2. 算数运算符
混合运算优先级顺序：()高于 ** 高于 * / // % 高于 + -3. 赋值运算符
1.单个变量赋值num = 1print(num)2. 多个变量赋值num1, float1, str1 = 10, 0.5, 'hello world'print(num1)print(float1)print(str1)3. 多变量赋相同值a = b = 10print(a)print(b)4. 复合赋值运算符
a = 100a += 1# 输出101 a = a + 1,最终a = 100 + 1print(a)b = 2b *= 3# 输出6 b = b * 3,最终b = 2 * 3print(b)c = 10c += 1 + 2# 输出13, 先算运算符右侧1 + 2 = 3， c += 3 , 推导出c = 10 + 3print(c)5. 比较运算符比较运算符也叫关系运算符， 通常用来判断。
a = 7b = 5print(a == b) # Falseprint(a != b) # Trueprint(a < b) # Falseprint(a > b) # Trueprint(a <= b) # Falseprint(a >= b) # True6. 逻辑运算符
a = 1b = 2c = 3print((a < b) and (b < c)) # Trueprint((a > b) and (b < c)) # Falseprint((a > b) or (b < c)) # Trueprint(not (a > b)) # True7. 补充知识数字之间的逻辑运算a = 0b = 1c = 2# and运算符，只要有一个值为0，则结果为0，否则结果为最后一个非0数字print(a and b) # 0print(b and a) # 0print(a and c) # 0print(c and a) # 0print(b and c) # 2print(c and b) # 1# or运算符，只有所有值为0结果才为0，否则结果为第一个非0数字print(a or b) # 1print(a or c) # 2print(b or c) # 1十一、条件语句1. 了解条件语句Python条件语句是通过一条或多条语句的执行结果（True或者False）来决定执行的代码块。2. if语法if 条件: 条件成立执行的代码1 条件成立执行的代码2 ......2.1 体验if语句if True:print('条件成立执行的代码1')print('条件成立执行的代码2')# 下方的代码没有缩进到if语句块，所以和if条件无关print('我是无论条件是否成立都要执行的代码')
2.2 简单版：网吧上网需求分析：如果用户年龄大于等于18岁，即成年，输出'已经成年，可以上网'。age = 20if age >= 18:print('已经成年，可以上网')print('系统关闭')2.3 进阶版：网吧上网新增需求：用户可以输出自己的年龄，然后系统进行判断是否成年，成年则输出'您的年龄是’用户输入的年龄’，已经成年，可以上网'。# input接受用户输入的数据是字符串类型，条件是age和整型18做判断，所以这里要int转换数据类型age = int(input('请输入您的年龄：'))if age >= 18:print(f'您的年龄是{age},已经成年，可以上网')print('系统关闭')3. if…else…作用：条件成立执行if下方的代码; 条件不成立执行else下方的代码。if 条件: 条件成立执行的代码1 条件成立执行的代码2 ......else: 条件不成立执行的代码1 条件不成立执行的代码2 ......思考：网吧上网的实例，如果成年，允许上网，如果不成年呢？是不是应该回复用户不能上网？3.1 实用版：网吧上网age = int(input('请输入您的年龄：'))if age >= 18: print(f'您的年龄是{age},已经成年，可以上网')else: print(f'您的年龄是{age},未成年，请自行回家写作业')print('系统关闭')注意：如果条件成立执行了某些代码，那么其他的情况的代码将不会执行。4. 多重判断if 条件1: 条件1成立执行的代码1 条件1成立执行的代码2 ......elif 条件2： 条件2成立执行的代码1 条件2成立执行的代码2 ............else: 以上条件都不成立执行执行的代码多重判断也可以和else配合使用。一般else放在整个if语句的最后，表示以上条件都不成立的时候执行的代码。思考：中国合法工作年龄为18-60岁，即如果年龄小于18的情况为童工，不合法；如果年龄在18-60岁之间为合法工龄；大于60岁为法定退休年龄。4.1 实例：工龄判断age = int(input('请输入您的年龄：'))if age < 18: print(f'您的年龄是{age},童工一枚')elif (age >= 18) and (age <= 60): print(f'您的年龄是{age},合法工龄')elif age > 60: print(f'您的年龄是{age},可以退休')拓展：age >= 18 and age <= 60可以化简为18 <= age <= 60。5. if嵌套if 条件1： 条件1成立执行的代码 条件1成立执行的代码if 条件2： 条件2成立执行的代码 条件2成立执行的代码注意：条件2的if也是出于条件1的缩进关系内部。思考：坐公交：如果有钱可以上车，没钱不能上车；上车后如果有空座，则可以坐下；如果没空座，就要站着。怎么书写程序？5.1 实例：坐公交1.判断是否能上车''' 1. 如果有钱，则可以上车 2. 上车后，如果有空座，可以坐下 上车后，如果没有空座，则站着等空座位 如果没钱，不能上车'''# 假设用 money = 1 表示有钱, money = 0表示没有钱money = 1if money == 1: print('土豪，不差钱，顺利上车')else: print('没钱，不能上车，追着公交车跑')2. 判断是否能坐下''' 1. 如果有钱，则可以上车 2. 上车后，如果有空座，可以坐下 上车后，如果没有空座，则站着等空座位 如果没钱，不能上车'''# 假设用 money = 1 表示有钱, money = 0表示没有钱; seat = 1 表示有空座，seat = 0 表示没有空座money = 1seat = 0if money == 1: print('土豪，不差钱，顺利上车')if seat == 1: print('有空座，可以坐下')else: print('没有空座，站等')else: print('没钱，不能上车，追着公交车跑')5.2 if嵌套执行流程
6. 应用：猜拳游戏需求分析：参与游戏的角色随机出拳手动出拳玩家电脑判断输赢玩家电脑石头剪刀剪刀布布石头玩家出拳 和 电脑出拳相同平局电脑获胜玩家获胜随机做法：1.导出random模块import 模块名2. 使用random模块中的随机整数功能random.randint(开始,结束)6.1 初始版：猜拳游戏'''提示：0-石头，1-剪刀，2-布3. 出拳玩家输入出拳电脑随机出拳4. 判断输赢玩家获胜平局电脑获胜'''# 导入random模块import random# 计算电脑出拳的随机数字computer = random.randint(0, 2)print(computer)player = int(input('请出拳：0-石头，1-剪刀，2-布：'))# 玩家胜利 p0:c1 或 p1:c2 或 p2:c0if (player == 0 and computer == 1) or (player == 1 and computer == 2) or (player == 2 and computer == 0): print('玩家获胜')# 平局：玩家 == 电脑elif player == computer: print('平局')else: print('电脑获胜')6.2 进阶版：猜拳游戏'''石头剪刀布游戏玩家VS电脑站在玩家的角度，分析胜利、失败、平局0-石头，1-剪刀，2-布'''# 导入随机数模块import randomimport sysprint('-----欢迎来到人机对战小游戏-----')name = input('请输入您的游戏名：')while True: stats = input('欢迎“%s”来到本游戏，开始游戏输入Y，退出游戏输入N，请您输入：' % name)if stats == 'Y' or stats == 'y': print('游戏开始……') print('石头输入0、剪刀输入1、布输入2')breakelif stats == 'N' or stats == 'n': print('游戏结束……') sys.exit(0)else: print('请按照要求重新输入！')print('-------------加载中-------------')def Game(user, comp):if (user== 0 and comp== 1) or (user== 1 and comp== 2) or (user== 2 and comp== 0): print('机器输入%d，您赢了！' % comp)elif user == comp: print('机器输入%d，平局了！' % comp)else: print('机器输入%d，您输了！' % comp) res = input('重新游戏请输入X，退出游戏按任意键')if res == 'X' or res == 'x':returnelse: sys.exit(0)while True: user = int(input('请您出拳，输入相应数字！'))if user == 0 or user == 1 or user == 2: comp = random.randint(0, 2) Game(user, comp)else: print('输入数字有误，请确认后，重新输入！')7. 三目运算符三目运算符也叫三元运算符。语法如下：值1 if 条件 else 值2快速体验：a = 1b = 2c = a if a > b else bprint(c)十二、循环简介1. 循环的作用让代码更高效的重复执行。2. 循环的分类在Python中，循环分为while和for两种，最终实现效果相同。3. while的语法while 条件: 条件成立重复执行的代码1 条件成立重复执行的代码2 ......4. while循环快速体验需求：复现重复执行10次print('Hello World')。分析：初始值是0次，终点是10次，重复做的事情输出“Hello World”。# 循环的计数器i = 0while i < 10:print('Hello World') i += 1print('任务结束')5. while的应用5.1 应用一：计算1-100累加和分析：1-100的累加和，即1 + 2 + 3 + 4 +….，即前两个数字的相加结果 + 下一个数字( 前一个数字 + 1)。i = 1result = 0while i <= 100:result += ii += 1# 输出5050print(result)注意：为了验证程序的准确性，可以先改小数值，验证结果正确后，再改成1-100做累加。5.2 应用二：计算1-100偶数累加和分析：1-100的偶数和，即 2 + 4 + 6 + 8…，得到偶数的方法如下：偶数即是和2取余结果为0的数字，可以加入条件语句判断是否为偶数，为偶数则累加初始值为0 / 2 , 计数器每次累加2方法一：条件判断和2取余数则累加# 方法一：条件判断和2取余数为0则累加计算i = 1result = 0while i <= 100:if i % 2 == 0:result += ii += 1# 输出2550print(result)方法二：计数器控制# 方法二：计数器控制增量为2i = 0result = 0while i <= 100:result += ii += 2# 输出2550print(result)6. break和continuebreak和continue是循环中满足一定条件退出循环的两种不同方式。6.1 理解举例：一共吃5个苹果，吃完第一个，吃第二个…，这里'吃苹果'的动作是不是重复执行？情况一：如果吃的过程中，吃完第三个吃饱了，则不需要再吃第4个和第五个苹果，即是吃苹果的动作停止，这里就是break控制循环流程，即终止此循环。情况二：如果吃的过程中，吃到第三个吃出一个大虫子…,是不是这个苹果就不吃了，开始吃第四个苹果，这里就是continue控制循环流程，即退出当前一次循环继而执行下一次循环代码。6.2 break实例i = 1while i <= 5:if i == 4: print(f'吃饱了不吃了')break print(f'吃了第{i}个苹果') i += 1
6.3 continue实例i = 1while i <= 5:if i == 3: print(f'大虫子，第{i}个不吃了')# 在continue之前一定要修改计数器，否则会陷入死循环 i += 1continue print(f'吃了第{i}个苹果') i += 1
7. while循环嵌套7.1 语法while 条件1: 条件1成立执行的代码 ......while 条件2: 条件2成立执行的代码 ......总结：所谓while循环嵌套，就是一个while里面嵌套一个while的写法，每个while和之前的基础语法是相同的。7.2 执行过程当内部循环执行完成之后，再执行下一次外部循环的条件判断。
7.3 while循环嵌套应用应用一：打印星号（正方形）# 重复打印5行星星j = 0while j <= 4:# 一行星星的打印 i = 0while i <= 4:# 一行内的星星不能换行，取消print默认结束符\nprint('*', end='') i += 1# 每行结束要换行，这里借助一个空的print，利用print默认结束符换行print() j += 1
应用二：打印星号（三角形）# 重复打印5行星星# j表示行号j = 0while j <= 4:# 一行星星的打印 i = 0# i表示每行里面星星的个数，这个数字要和行号相等所以i要和j联动while i <= j:print('*', end='') i += 1print() j += 1
应用二：九九乘法表# 重复打印9行表达式j = 1while j <= 9:# 打印一行里面的表达式 a * b = a*b i = 1while i <= j: print(f'{i}*{j}={j*i}', end='\t') i += 1 print() j += 1
8. for循环8.1 语法for 临时变量 in 序列: 重复执行的代码1 重复执行的代码2 ......8.2 快速体验str1 = 'Hello World'for i in str1: print(i)
8.3 breakstr1 = 'Hello World'for i in str1:if i == 'e':print('遇到e不打印')break print(i)
8.4 continuestr1 = 'Hello World'for i in str1:if i == 'e':print('遇到e不打印')continue print(i)
十三、else循环可以和else配合使用，else下方缩进的代码指的是当循环正常结束之后要执行的代码。1. while…else1.1 语法while 条件: 条件成立重复执行的代码else: 循环正常结束之后要执行的代码1.2 示例i = 1while i <= 5:print('Hello World') i += 1else: print('执行完毕')
1.3 退出循环的方式1.break终止循环i = 1while i <= 5:if i == 3:print('提前结束')breakprint('Hello World') i += 1else: print('执行完毕')
所谓else指的是循环正常结束之后要执行的代码，即如果是break终止循环的情况，else下方缩进的代码将不执行。2.continue控制循环i = 1while i <= 5:if i == 3:print('打断一下') i += 1continueprint('Hello World') i += 1else: print('执行完毕')
因为continue是退出当前一次循环，继续下一次循环，所以该循环在continue控制下是可以正常结束的，当循环结束后，则执行了else缩进的代码。2. for…else2.1 语法for 临时变量 in 序列: 重复执行的代码 ...else: 循环正常结束之后要执行的代码所谓else指的是循环正常结束之后要执行的代码，即如果是break终止循环的情况，else下方缩进的代码将不执行。2.2 示例str1 = 'Hello World'for i in str1:print(i)else: print('循环正常结束之后执行的代码')
2.3 退出循环的方式1.break终止循环str1 = 'Hello World'for i in str1:if i == 'e':print('遇到e不打印')breakprint(i)else: print('循环正常结束之后执行的代码')
没有执行else缩进的代码。2.continue控制循环str1 = 'Hello World'for i in str1:if i == 'e':print('遇到e不打印')continueprint(i)else: print('循环正常结束之后执行的代码')
因为continue是退出当前一次循环，继续下一次循环，所以该循环在continue控制下是可以正常结束的，当循环结束后，则执行了else缩进的代码。十四、字符串1. 认识字符串字符串是 Python 中最常用的数据类型。我们一般使用引号来创建字符串。创建字符串很简单，只要为变量分配一个值即可。a = 'hello world'b = 'abcdefg'print(type(a))print(type(b))注意：控制台显示结果为<class 'str'>， 即数据类型为str(字符串)。2. 字符串特征一对引号字符串name1 = 'Tom'name2 = 'Rose'三引号字符串name3 = ''' Tom '''name4 = ''' Rose '''a = ''' i am Tom, nice to meet you! '''b = ''' i am Rose, nice to meet you! '''注意：三引号形式的字符串支持换行。思考：如果创建一个字符串I'm Tom?c = 'I'm Tom'd = 'I\'m Tom'3. 字符串输出print('hello world')name = 'Tom'print('我的名字是%s' % name)print(f'我的名字是{name}')4. 字符串输入在Python中，使用input()接收用户输入。name = input('请输入您的名字：')print(f'您输入的名字是{name}')print(type(name))password = input('请输入您的密码：')print(f'您输入的密码是{password}')print(type(password))
5. 下标5.1 概念“下标”又叫“索引”，就是编号。比如火车座位号，座位号的作用：按照编号快速找到对应的座位。同理，下标的作用即是通过下标快速找到对应的数据。5.2 快速体验需求：字符串name = 'abcdef'，取到不同下标对应的数据。代码name = 'abcdef'print(name[1])print(name[0])print(name[2])输出结果
注意：下标从0开始。
6. 切片切片是指对操作的对象截取其中一部分的操作。字符串、列表、元组都支持切片操作。6.1 语法序列[开始位置下标:结束位置下标:步长]注意：不包含结束位置下标对应的数据， 正负整数均可；步长是选取间隔，正负整数均可，默认步长为1。6.2 示例name = 'abcdefg'print(name[2:5:1]) # cdeprint(name[2:5]) # cdeprint(name[:5]) # abcdeprint(name[1:]) # bcdefgprint(name[:]) # abcdefgprint(name[::2]) # acegprint(name[:-1]) # abcdef, 负1表示倒数第一个数据print(name[-4:-1]) # defprint(name[::-1]) # gfedcba7. 常用操作方法字符串的常用操作方法有查找、修改和判断三大类。7.1 查找所谓字符串查找方法即是查找子串在字符串中的位置或出现的次数。find()：检测某个子串是否包含在这个字符串中，如果在返回这个子串开始的位置下标，否则则返回-1。语法字符串序列.find(子串, 开始位置下标, 结束位置下标)注意：开始和结束位置下标可以省略，表示在整个字符串序列中查找。快速体验mystr = 'hello world and buran and list and Python'print(mystr.find('and')) # 12print(mystr.find('and', 15, 30)) # 22print(mystr.find('ands')) # -1index()：检测某个子串是否包含在这个字符串中，如果在返回这个子串开始的位置下标，否则则报异常。语法字符串序列.index(子串, 开始位置下标, 结束位置下标)注意：开始和结束位置下标可以省略，表示在整个字符串序列中查找。快速体验mystr = 'hello world and buran and list and Python'print(mystr.index('and')) # 12print(mystr.index('and', 15, 30)) # 22print(mystr.index('ands')) # 报错rfind()：和find()功能相同，但查找方向为右侧开始。rindex()：和index()功能相同，但查找方向为右侧开始。count()：返回某个子串在字符串中出现的次数。语法字符串序列.count(子串, 开始位置下标, 结束位置下标)注意：开始和结束位置下标可以省略，表示在整个字符串序列中查找。快速体验mystr = 'hello world and buran and list and Python'print(mystr.count('and')) # 3print(mystr.count('ands')) # 0print(mystr.count('and', 0, 20)) # 17.2 修改所谓修改字符串，指的就是通过函数的形式修改字符串中的数据。replace()：替换字符串。语法字符串序列.replace(旧子串, 新子串, 替换次数)注意：替换次数如果查出子串出现次数，则替换次数为该子串出现次数。快速体验mystr = 'hello world and buran and list and Python'print(mystr.replace('and', 'he'))# 结果：hello world he buran he list he Pythonprint(mystr.replace('and', 'he', 10))# 结果：hello world he buran he list he Pythonprint(mystr)# 结果：hello world and buran and list and Python注意：数据按照是否能直接修改分为可变类型和不可变类型两种。字符串类型的数据修改的时候不能改变原有字符串，属于不能直接修改数据的类型即是不可变类型。split()：按照指定字符分割字符串。语法字符串序列.split(分割字符, num)注意：num表示的是分割字符出现的次数，即将来返回数据个数为num+1个。快速体验mystr = 'hello world and buran and list and Python'print(mystr.split('and'))# 结果：['hello world ', ' buran ', ' list ', ' Python']print(mystr.split('and', 2))# 结果：['hello world ', ' buran ', ' list and Python']print(mystr.split(' '))# 结果：['hello', 'world', 'and', 'buran', 'and', 'list', 'and', 'Python']print(mystr.split(' ', 2))# 结果：['hello', 'world', 'and buran and list and Python']注意：如果分割字符是原有字符串中的子串，分割后则丢失该子串。join()：用一个字符或子串合并字符串，即是将多个字符串合并为一个新的字符串。1.语法字符或子串.join(多字符串组成的序列)2. 快速体验list1 = ['hello', 'buran', 'list']t1 = ('aa', 'b', 'cc', 'ddd')print('_'.join(list1))# hello_buran_listprint('...'.join(t1))# 结果：aa...b...cc...dddcapitalize()：将字符串第一个字符转换成大写。mystr = 'hello world and buran and list and Python'print(mystr.capitalize())# 结果：Hello world and buran and list and python注意：capitalize()函数转换后，只字符串第一个字符大写，其他的字符全都小写。title()：将字符串每个单词首字母转换成大写。mystr = 'hello world and buran and list and Python'print(mystr.title())# 结果：Hello World And Buran And List And Pythonlower()：将字符串中大写转小写。mystr = 'hello world and buran and list and Python'print(mystr.lower())# 结果：hello world and buran and list and pythonupper()：将字符串中小写转大写。mystr = 'hello world and buran and list and Python'print(mystr.upper())# 结果：HELLO WORLD AND BURAN AND LIST AND PYTHONlstrip()：删除字符串左侧空白字符。rstrip()：删除字符串右侧空白字符。strip()：删除字符串两侧空白字符。ljust()：返回一个原字符串左对齐,并使用指定字符(默认空格)填充至对应长度 的新字符串。rjust()：返回一个原字符串右对齐,并使用指定字符(默认空格)填充至对应长度 的新字符串，语法和ljust()相同。center()：返回一个原字符串居中对齐,并使用指定字符(默认空格)填充至对应长度 的新字符串，语法和ljust()相同。7.3 判断所谓判断即是判断真假，返回的结果是布尔型数据类型：True 或 False。startswith()：检查字符串是否是以指定子串开头，是则返回 True，否则返回 False。如果设置开始和结束位置下标，则在指定范围内检查。语法字符串序列.startswith(子串, 开始位置下标, 结束位置下标)快速体验mystr = 'hello world and buran and list and Python'print(mystr.startswith('hello'))# 结果：Trueprint(mystr.startswith('hello', 5, 20))# 结果：Falseendswith()：：检查字符串是否是以指定子串结尾，是则返回 True，否则返回 False。如果设置开始和结束位置下标，则在指定范围内检查。语法字符串序列.endswith(子串, 开始位置下标, 结束位置下标)快速体验mystr = 'hello world and buran and list and Python'print(mystr.endswith('Python'))# 结果：Trueprint(mystr.endswith('python'))# 结果：Falseprint(mystr.endswith('Python', 2, 20))# 结果：Falseisalpha()：如果字符串至少有一个字符并且所有字符都是字母则返回 True, 否则返回 False。mystr1 = 'hello'mystr2 = 'hello12345'print(mystr1.isalpha())# 结果：Trueprint(mystr2.isalpha())# 结果：Falseisdigit()：如果字符串只包含数字则返回 True 否则返回 False。mystr1 = 'aaa12345'mystr2 = '12345'print(mystr1.isdigit())# 结果：Falseprint(mystr2.isdigit())# 结果：Falseisalnum()：如果字符串至少有一个字符并且所有字符都是字母或数字则返 回 True,否则返回 False。mystr1 = 'aaa12345'mystr2 = '12345-'print(mystr1.isalnum())# 结果：Trueprint(mystr2.isalnum())# 结果：Falseisspace()：如果字符串中只包含空白，则返回 True，否则返回 False。mystr1 = '1 2 3 4 5'mystr2 = ' 'print(mystr1.isspace())# 结果：Falseprint(mystr2.isspace())# 结果：True十五、列表1. 列表的格式[数据1, 数据2, 数据3, 数据4......]列表可以一次性有序存储多个不同类型的数据。2. 列表的常用操作列表的作用是一次性存储多个数据，程序员可以对这些数据进行的操作有：增、删、改、查。2.1 查找下标name_list = ['Tom', 'Lily', 'Rose']print(name_list[0]) # Tomprint(name_list[1]) # Lilyprint(name_list[2]) # Rose函数index()：返回指定数据所在位置的下标 。列表序列.index(数据, 开始位置下标, 结束位置下标)name_list = ['Tom', 'Lily', 'Rose']print(name_list.index('Lily', 0, 2)) # 1注意：如果查找的数据不存在则报错。count()：统计指定数据在当前列表中出现的次数。name_list = ['Tom', 'Lily', 'Rose']print(name_list.count('Lily')) # 1len()：访问列表长度，即列表中数据的个数。name_list = ['Tom', 'Lily', 'Rose']print(len(name_list)) # 32.2 判断是否存在in：判断指定数据在某个列表序列，如果在返回True，否则返回False。name_list = ['Tom', 'Lily', 'Rose']# 结果：Trueprint('Lily' in name_list)# 结果：Falseprint('Lilys' in name_list)not in：判断指定数据不在某个列表序列，如果不在返回True，否则返回False。name_list = ['Tom', 'Lily', 'Rose']# 结果：Falseprint('Lily' not in name_list)# 结果：Trueprint('Lilys' not in name_list)2.2 增加作用：增加指定数据到列表中。append()：列表结尾追加数据。列表序列.append(数据)name_list = ['Tom', 'Lily', 'Rose']name_list.append('xiaoming')# 结果：['Tom', 'Lily', 'Rose', 'xiaoming']print(name_list)列表追加数据的时候，直接在原列表里面追加了指定数据，即修改了原列表，故列表为可变类型数据。注意点：如果append()追加的数据是一个序列，则追加整个序列到列表。name_list = ['Tom', 'Lily', 'Rose']name_list.append(['xiaoming', 'xiaohong'])# 结果：['Tom', 'Lily', 'Rose', ['xiaoming', 'xiaohong']]print(name_list)extend()：列表结尾追加数据，如果数据是一个序列，则将这个序列的数据逐一添加到列表。列表序列.extend(数据)单个数据：name_list = ['Tom', 'Lily', 'Rose']name_list.extend('xiaoming')# 结果：['Tom', 'Lily', 'Rose', 'x', 'i', 'a', 'o', 'm', 'i', 'n', 'g']print(name_list)序列数据：name_list = ['Tom', 'Lily', 'Rose']name_list.extend(['xiaoming', 'xiaohong'])# 结果：['Tom', 'Lily', 'Rose', 'xiaoming', 'xiaohong']print(name_list)insert()：指定位置新增数据。列表序列.insert(位置下标, 数据)name_list = ['Tom', 'Lily', 'Rose']name_list.insert(1, 'xiaoming')# 结果：['Tom', 'xiaoming', 'Lily', 'Rose']print(name_list)2.3 删除deldel 目标# del(目标)删除列表：name_list = ['Tom', 'Lily', 'Rose']# 结果：报错提示：name 'name_list' is not defineddel name_listprint(name_list)删除指定数据：name_list = ['Tom', 'Lily', 'Rose']del name_list[0]# 结果：['Lily', 'Rose']print(name_list)pop()：删除指定下标的数据(默认为最后一个)，并返回该数据。列表序列.pop(下标)name_list = ['Tom', 'Lily', 'Rose']del_name = name_list.pop(1)# 结果：Lilyprint(del_name)# 结果：['Tom', 'Rose']print(name_list)remove()：移除列表中某个数据的第一个匹配项。列表序列.remove(数据)name_list = ['Tom', 'Lily', 'Rose']name_list.remove('Rose')# 结果：['Tom', 'Lily']print(name_list)clear()：清空列表name_list = ['Tom', 'Lily', 'Rose']name_list.clear()print(name_list) # 结果： []2.4 修改修改指定下标数据name_list = ['Tom', 'Lily', 'Rose']name_list[0] = 'aaa'# 结果：['aaa', 'Lily', 'Rose']print(name_list)逆置：reverse()num_list = [1, 5, 2, 3, 6, 8]num_list.reverse()# 结果：[8, 6, 3, 2, 5, 1]print(num_list)排序：sort()列表序列.sort( key=None, reverse=False)num_list = [1, 5, 2, 3, 6, 8]num_list.sort()# 结果：[1, 2, 3, 5, 6, 8]print(num_list)注意：reverse表示排序规则，reverse = True 降序， reverse = False 升序（默认）2.5 复制函数：copy()name_list = ['Tom', 'Lily', 'Rose']name_li2 = name_list.copy()# 结果：['Tom', 'Lily', 'Rose']print(name_li2)3. 列表的循环遍历需求：依次打印列表中的各个数据。3.1 whilename_list = ['Tom', 'Lily', 'Rose']i = 0while i < len(name_list):print(name_list[i]) i += 13.2 forname_list = ['Tom', 'Lily', 'Rose']for i in name_list: print(i)4. 列表嵌套所谓列表嵌套指的就是一个列表里面包含了其他的子列表。应用场景：要存储班级一、二、三三个班级学生姓名，且每个班级的学生姓名在一个列表。name_list = [['小明', '小红', '小绿'], ['Tom', 'Lily', 'Rose'], ['张三', '李四', '王五']]思考：如何查找到数据'李四'？# 第一步：按下标查找到李四所在的列表print(name_list[2])# 第二步：从李四所在的列表里面，再按下标找到数据李四print(name_list[2][1])十六、元组一个元组可以存储多个数据，元组内的数据是不能修改的。1. 定义元组元组特点：定义元组使用小括号，且逗号隔开各个数据，数据可以是不同的数据类型。# 多个数据元组t1 = (10, 20, 30)# 单个数据元组t2 = (10,)注意：如果定义的元组只有一个数据，那么这个数据后面也好添加逗号，否则数据类型为唯一的这个数据的数据类型。t2 = (10,)print(type(t2)) # tuplet3 = (20)print(type(t3)) # intt4 = ('hello')print(type(t4)) # str2. 元组的常见操作元组数据不支持修改，只支持查找，具体如下：按下标查找数据tuple1 = ('aa', 'bb', 'cc', 'bb')print(tuple1[0]) # aaindex()：查找某个数据，如果数据存在返回对应的下标，否则报错，语法和列表、字符串的index方法相同。tuple1 = ('aa', 'bb', 'cc', 'bb')print(tuple1.index('aa')) # 0count()：统计某个数据在当前元组出现的次数。tuple1 = ('aa', 'bb', 'cc', 'bb')print(tuple1.count('bb')) # 2len()：统计元组中数据的个数。tuple1 = ('aa', 'bb', 'cc', 'bb')print(len(tuple1)) # 43. 元组的注意事项元组内的直接数据如果修改则立即报错。tuple1 = ('aa', 'bb', 'cc', 'bb')tuple1[0] = 'aaa'但是如果元组里面有列表，修改列表里面的数据则是支持的，故自觉很重要。tuple2 = (10, 20, ['aa', 'bb', 'cc'], 50, 30)print(tuple2[2]) # 访问到列表# 结果：(10, 20, ['aaaaa', 'bb', 'cc'], 50, 30)tuple2[2][0] = 'aaaaa'print(tuple2)十七、字典字典里面的数据是以“键值对”形式出现，字典数据和数据顺序没有关系，即字典不支持下标，后期无论数据如何变化，只需要按照对应的键的名字查找数据即可。1. 创建字典的语法字典特点：符号为大括号数据为键值对形式出现各个键值对之间用逗号隔开# 有数据字典dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}# 空字典dict2 = {}dict3 = dict()注意：一般称冒号前面的为键(key)，简称k；冒号后面的为值(value)，简称v。2. 字典常见操作2.1 增写法：字典序列[key] = 值注意：如果key存在则修改这个key对应的值；如果key不存在则新增此键值对。dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}dict1['name'] = 'Rose'# 结果：{'name': 'Rose', 'age': 20, 'gender': '男'}print(dict1)dict1['id'] = 110# {'name': 'Rose', 'age': 20, 'gender': '男', 'id': 110}print(dict1)注意：字典为可变类型。2.2 删del() / del：删除字典或删除字典中指定键值对。dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}del dict1['gender']# 结果：{'name': 'Tom', 'age': 20}print(dict1)clear()：清空字典dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}dict1.clear()print(dict1) # {}2.3 改写法：字典序列[key] = 值注意：如果key存在则修改这个key对应的值 ；如果key不存在则新增此键值对。2.4 查key值查找dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}print(dict1['name']) # Tomprint(dict1['id']) # 报错如果当前查找的key存在，则返回对应的值；否则则报错。get()字典序列.get(key, 默认值)注意：如果当前查找的key不存在则返回第二个参数(默认值)，如果省略第二个参数，则返回None。dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}print(dict1.get('name')) # Tomprint(dict1.get('id', 110)) # 110print(dict1.get('id')) # Nonekeys()dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}print(dict1.keys()) # dict_keys(['name', 'age', 'gender'])values()dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}print(dict1.values()) # dict_values(['Tom', 20, '男'])items()dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}print(dict1.items()) # dict_items([('name', 'Tom'), ('age', 20), ('gender', '男')])3. 字典的循环遍历3.1 遍历字典的keydict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}for key in dict1.keys(): print(key)3.2 遍历字典的valuedict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}for value in dict1.values(): print(value)3.3 遍历字典的元素dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}for item in dict1.items(): print(item)3.4 遍历字典的键值对dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}for key, value in dict1.items(): print(f'{key} = {value}')十八、集合集合具有确定性，无序性和去重性。1. 创建集合创建集合使用{}或set()， 但是如果要创建空集合只能使用set()，因为{}用来创建空字典。s1 = {10, 20, 30, 40, 50}print(s1)s2 = {10, 30, 20, 10, 30, 40, 30, 50}print(s2)s3 = set('abcdefg')print(s3)s4 = set()print(type(s4)) # sets5 = {}print(type(s5)) # dict特点：集合可以去掉重复数据；集合数据是无序的，故不支持下标。2. 集合常见操作方法2.1 增加数据add()s1 = {10, 20}s1.add(100)s1.add(10)print(s1) # {100, 10, 20}因为集合有去重功能，所以，当向集合内追加的数据是当前集合已有数据的话，则不进行任何操作。update(), 追加的数据是序列。s1 = {10, 20}# s1.update(100) # 报错s1.update([100, 200])s1.update('abc')print(s1) # {'a', 100, 200, 10, 'b', 'c', 20}2.2 删除数据remove()，删除集合中的指定数据，如果数据不存在则报错。s1 = {10, 20}s1.remove(10)print(s1)s1.remove(10) # 报错print(s1)discard()，删除集合中的指定数据，如果数据不存在也不会报错。s1 = {10, 20}s1.discard(10)print(s1)s1.discard(10)print(s1)pop()，随机删除集合中的某个数据，并返回这个数据。s1 = {10, 20, 30, 40, 50}del_num = s1.pop()print(del_num)print(s1)2.3 查找数据in：判断数据在集合序列not in：判断数据不在集合序列s1 = {10, 20, 30, 40, 50}print(10 in s1)print(10 not in s1)十九、公共操作1. 运算符
1.1 +# 1. 字符串 str1 = 'aa'str2 = 'bb'str3 = str1 + str2print(str3) # aabb# 2. 列表 list1 = [1, 2]list2 = [10, 20]list3 = list1 + list2print(list3) # [1, 2, 10, 20]# 3. 元组 t1 = (1, 2)t2 = (10, 20)t3 = t1 + t2print(t3) # (10, 20, 100, 200)1.2 *# 1. 字符串print('-' * 10) # ----------# 2. 列表list1 = ['hello']print(list1 * 4) # ['hello', 'hello', 'hello', 'hello']# 3. 元组t1 = ('world',)print(t1 * 4) # ('world', 'world', 'world', 'world')1.3 in或not in# 1. 字符串print('a' in 'abcd') # Trueprint('a' not in 'abcd') # False# 2. 列表list1 = ['a', 'b', 'c', 'd']print('a' in list1) # Trueprint('a' not in list1) # False# 3. 元组t1 = ('a', 'b', 'c', 'd')print('aa' in t1) # Falseprint('aa' not in t1) # True2. 公共方法
2.1 len()# 1. 字符串str1 = 'abcdefg'print(len(str1)) # 7# 2. 列表list1 = [10, 20, 30, 40]print(len(list1)) # 4# 3. 元组t1 = (10, 20, 30, 40, 50)print(len(t1)) # 5# 4. 集合s1 = {10, 20, 30}print(len(s1)) # 3# 5. 字典dict1 = {'name': 'Rose', 'age': 18}print(len(dict1)) # 22.2 del()# 1. 字符串str1 = 'abcdefg'del str1print(str1)# 2. 列表list1 = [10, 20, 30, 40]del(list1[0])print(list1) # [20, 30, 40]2.3 max()# 1. 字符串str1 = 'abcdefg'print(max(str1)) # g# 2. 列表list1 = [10, 20, 30, 40]print(max(list1)) # 402.4 min()# 1. 字符串str1 = 'abcdefg'print(min(str1)) # a# 2. 列表list1 = [10, 20, 30, 40]print(min(list1)) # 102.5 range()# 1 2 3 4 5 6 7 8 9for i in range(1, 10, 1):print(i)# 1 3 5 7 9for i in range(1, 10, 2):print(i)# 0 1 2 3 4 5 6 7 8 9for i in range(10): print(i)注意：range()生成的序列不包含end数字。2.6 enumerate()enumerate(可遍历对象, start=0)注意：start参数用来设置遍历数据的下标的起始值，默认为0。list1 = ['a', 'b', 'c', 'd', 'e']for i in enumerate(list1): print(i)for index, char in enumerate(list1, start=1): print(f'下标是{index}, 对应的字符是{char}')
3. 容器类型转换3.1 tuple()作用：将某个序列转换成元组。list1 = [10, 20, 30, 40, 50, 20]s1 = {100, 200, 300, 400, 500}print(tuple(list1))print(tuple(s1))3.2 list()作用：将某个序列转换成列表。t1 = ('a', 'b', 'c', 'd', 'e')s1 = {100, 200, 300, 400, 500}print(list(t1))print(list(s1))3.3 set()作用：将某个序列转换成集合。list1 = [10, 20, 30, 40, 50, 20]t1 = ('a', 'b', 'c', 'd', 'e')print(set(list1))print(set(t1))注意：集合可以快速完成列表去重。集合不支持下标。二十、推导式1. 列表推导式作用：用一个表达式创建一个有规律的列表或控制一个有规律列表。列表推导式又叫列表生成式。1.1 快速体验需求：创建一个0-10的列表。while循环实现# 1. 准备一个空列表list1 = []# 2. 书写循环，依次追加数字到空列表list1中i = 0while i < 10: list1.append(i) i += 1print(list1)for循环实现list1 = []for i in range(10): list1.append(i)print(list1)列表推导式实现list1 = [i for i in range(10)]print(list1)1.2 带if的列表推导式需求：创建0-10的偶数列表方法一：range()步长实现list1 = [i for i in range(0, 10, 2)]print(list1)1.3 多个for循环实现列表推导式需求：创建列表如下：[(1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2)]代码如下：list1 = [(i, j) for i in range(1, 3) for j in range(3)]print(list1)2. 字典推导式字典推导式作用：快速合并列表为字典或提取字典中目标数据。2.1 快速体验创建一个字典：字典key是1-5数字，value是这个数字的2次方。dict1 = {i: i**2 for i in range(1, 5)}print(dict1) # {1: 1, 2: 4, 3: 9, 4: 16}将两个列表合并为一个字典list1 = ['name', 'age', 'gender']list2 = ['Tom', 20, 'man']dict1 = {list1[i]: list2[i] for i in range(len(list1))}print(dict1)提取字典中目标数据counts = {'MBP': 268, 'HP': 125, 'DELL': 201, 'Lenovo': 199, 'acer': 99}# 需求：提取上述电脑数量大于等于200的字典数据count1 = {key: value for key, value in counts.items() if value >= 200}print(count1) # {'MBP': 268, 'DELL': 201}3. 集合推导式需求：创建一个集合，数据为下方列表的2次方。list1 = [1, 1, 2]代码如下：list1 = [1, 1, 2]set1 = {i ** 2 for i in list1}print(set1) # {1, 4}注意：集合有数据去重功能。