深入理解python_基础语法

前言：

Python是一个高层次的结合了解释性、编译性、互动性和面向对象的脚本语言。
本博文主要涉及Python基础入门、流程控制（条件语句、循环语句）、数据序列等知识。
本博文若存在任何知识错误，请读者第一时间在评论区指出，方便我修正内容！
获取更多内容，请关注博主，在主页进行阅读，感谢您的支持！

文章目录

一、Python简介

1. 了解Python

Python是一种解释型（这意味着开发过程中没有了编译这个环节）、面向对象（支持面向对象的风格或代码封装在对象的编程技术）、动态数据类型的交互式（可在命令行中通过Python提示符及直接代码执行程序）高级程序设计语言。

2. Python介绍

Python是时下最流行、最火爆的编程语言，具体原因：

简单、易学，适应人群广泛
免费、开源
应用领域广泛

备注：以下知名框架均是Python语言开发。

Google开源机器学习框架：TensorFlow

开源社区主推学习框架：Scikit-learn

百度开源深度学习框架：Paddle

3. 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=aladdin

5. Python版本

Python 2.X
Python 3.X

二、Python解释器

1. 解释器的作用

Python解释器作用：运行文件
Python解释器种类
1. CPython，C语言开发的解释器[官方]，应用广泛的解释器。
2. IPython，基于CPython的一种交互式解释器。
3. 其他解释器
  - PyPy，基于Python语言开发的解释器。
  - Jython，运行在Java平台的解释器，直接把Python代码编译成Java字节码执行。
  - IronPython，运行在微软.Net平台上的Python解释器，可以直接把Python代码编译成.Net的字节码。

2. 解释器的安装

Python解释器的安装：深入浅出Python——Python基础语法全解

三、PyCharm安装与使用

1. PyCharm的作用

PyCharm是一种Python IDE（集成开发环境），带有一整套可以帮助用户在使用Python语言开发时提高其效率的工具，内部集成的功能如下：

Project管理
智能提示
语法高亮
代码跳转
调试代码
解释代码(解释器)
框架和库
…

2. PyCharm安装与使用

PyCharm的安装：深入浅出Python——Python基础语法全解

四、注释

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 = 23
print(myAge)

2.4 认识bug

所谓bug，就是程序中的错误。如果程序有错误，需要程序员排查问题，纠正错误。

2.5 Debug工具

Debug工具是PyCharm IDE中集成的用来调试程序的工具，在这里程序员可以查看程序的执行细节和流程或者调解bug。

Debug工具使用步骤：

打断点
Debug调试

六、数据类型

在 Python 里为了应对不同的业务需求，也把数据分为不同的类型。

检测数据类型的方法：type(变量名或者数值)

a = 1
print(type(a))  # <class 'int'> -- 整型

b = 1.1
print(type(b))  # <class 'float'> -- 浮点型

c = True
print(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 = 18
print(age)

# 需求：输出“今年我的年龄是18岁”

1. 格式化输出

格式符号	转换
%s	字符串
%d	有符号的十进制整数
%f	浮点数
%c	字符
%u	无符号十进制整数
%o	八进制整数
%x	十六进制整数（小写ox）
%X	十六进制整数（大写OX）
%e	科学计数法（小写’e’）
%E	科学计数法（大写’E’）
%g	%f和%e的简写
%G	%f和%E的简写

%06d，表示输出的整数显示位数，不足以0补全，超出当前位数则原样输出。

%.2f，表示小数点后显示的小数位数。

2. 内置函数format

format()用于字符串格式化，功能非常强大，格式是str.format()，format函数可以接受不限个参数，位置可以不按顺序。

3. f-格式化字符串

f-string是格式化字符串的一种很好的新方法。与其他格式化方式相比，它不仅更易读，更简洁，不易出错，而且速度更快！格式为：f'{表达式}'。

4. 体验格式化字符串

name = "张三"
age = 23
weight = 75.5
student_id = 1

# 我的名字是张三
print('我的名字是%s' % name)

# 我的学号是0001
print('我的学号是%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. 转换数据类型的函数

函数	说明
int(x [,base ])	将x转换为一个整数
float(x )	将x转换为一个浮点数
complex(real [,imag ])	创建一个复数，real为实部，imag为虚部
str(x )	将对象 x 转换为字符串
repr(x )	将对象 x 转换为表达式字符串
eval(str )	用来计算在字符串中的有效Python表达式,并返回一个对象
tuple(s )	将序列 s 转换为一个元组
list(s )	将序列 s 转换为一个列表
chr(x )	将一个整数转换为一个Unicode字符
ord(x )	将一个字符转换为它的ASCII整数值
hex(x )	将一个整数转换为一个十六进制字符串
oct(x )	将一个整数转换为一个八进制字符串
bin(x )	将一个整数转换为一个二进制字符串

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 = 1
print(float(num1))
print(type(float(num1)))

# 2. str() -- 转换成字符串类型
num2 = 10
print(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. 算数运算符

运算符	描述	实例
+	加	1 + 1 输出结果为 2
–	减	1-1 输出结果为 0
*	乘	2 * 2 输出结果为 4
/	除	10 / 2 输出结果为 5
//	整除	9 // 4 输出结果为2
%	取余	9 % 4 输出结果为 1
**	指数	2 ** 4 输出结果为 16，即 2 * 2 * 2 * 2
()	小括号	小括号用来提高运算优先级，即 (1 + 2) * 3 输出结果为 9

混合运算优先级顺序：()高于 ** 高于 * / // % 高于 + -

3. 赋值运算符

运算符	描述	实例
=	赋值	将`=`右侧的结果赋值给等号左侧的变量

单个变量赋值

num = 1
print(num)

多个变量赋值

num1, float1, str1 = 10, 0.5, 'hello world'
print(num1)
print(float1)
print(str1)

多变量赋相同值

a = b = 10
print(a)
print(b)

4. 复合赋值运算符

运算符	描述	实例
+=	加法赋值运算符	c += a 等价于 c = c + a
-=	减法赋值运算符	c -= a 等价于 c = c- a
*=	乘法赋值运算符	c = a 等价于 c = c a
/=	除法赋值运算符	c /= a 等价于 c = c / a
//=	整除赋值运算符	c //= a 等价于 c = c // a
%=	取余赋值运算符	c %= a 等价于 c = c % a
**=	幂赋值运算符	c = a 等价于 c = c a

a = 100
a += 1
# 输出101 a = a + 1,最终a = 100 + 1
print(a)

b = 2
b *= 3
# 输出6 b = b * 3,最终b = 2 * 3
print(b)

c = 10
c += 1 + 2
# 输出13, 先算运算符右侧1 + 2 = 3， c += 3 , 推导出c = 10 + 3
print(c)

5. 比较运算符

比较运算符也叫关系运算符，通常用来判断。

运算符	描述	实例
==	判断相等。如果两个操作数的结果相等，则条件结果为真(True)，否则条件结果为假(False)	如a=3,b=3，则（a == b) 为 True
!=	不等于。如果两个操作数的结果不相等，则条件为真(True)，否则条件结果为假(False)	如a=3,b=3，则（a == b) 为 True如a=1,b=3，则(a != b) 为 True
>	运算符左侧操作数结果是否大于右侧操作数结果，如果大于，则条件为真，否则为假	如a=7,b=3，则(a > b) 为 True
<	运算符左侧操作数结果是否小于右侧操作数结果，如果小于，则条件为真，否则为假	如a=7,b=3，则(a < b) 为 False
>=	运算符左侧操作数结果是否大于等于右侧操作数结果，如果大于，则条件为真，否则为假	如a=7,b=3，则(a < b) 为 False如a=3,b=3，则(a >= b) 为 True
<=	运算符左侧操作数结果是否小于等于右侧操作数结果，如果小于，则条件为真，否则为假	如a=3,b=3，则(a <= b) 为 True

a = 7
b = 5
print(a == b)  # False
print(a != b)  # True
print(a < b)   # False
print(a > b)   # True
print(a <= b)  # False
print(a >= b)  # True

6. 逻辑运算符

运算符	逻辑表达式	描述	实例
and	x and y	布尔”与”：如果 x 为 False，x and y 返回 False，否则它返回 y 的值。	True and False，返回 False。
or	x or y	布尔”或”：如果 x 是 True，它返回 True，否则它返回 y 的值。	False or True，返回 True。
not	not x	布尔”非”：如果 x 为 True，返回 False 。如果 x 为 False，它返回 True。	not True 返回 False, not False 返回 True

a = 1
b = 2
c = 3
print((a < b) and (b < c))  # True
print((a > b) and (b < c))  # False
print((a > b) or (b < c))   # True
print(not (a > b))          # True

7. 补充知识

数字之间的逻辑运算

a = 0
b = 1
c = 2

# and运算符，只要有一个值为0，则结果为0，否则结果为最后一个非0数字
print(a and b)  # 0
print(b and a)  # 0
print(a and c)  # 0
print(c and a)  # 0
print(b and c)  # 2
print(c and b)  # 1

# or运算符，只有所有值为0结果才为0，否则结果为第一个非0数字
print(a or b)  # 1
print(a or c)  # 2
print(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 = 20
if 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. 如果有钱，则可以上车 2. 上车后，如果有空座，可以坐下 上车后，如果没有空座，则站着等空座位 如果没钱，不能上车 """
# 假设用 money = 1 表示有钱, money = 0表示没有钱
money = 1
if money == 1:
    print('土豪，不差钱，顺利上车')
else:
    print('没钱，不能上车，追着公交车跑')

判断是否能坐下

""" 1. 如果有钱，则可以上车 2. 上车后，如果有空座，可以坐下 上车后，如果没有空座，则站着等空座位 如果没钱，不能上车 """
# 假设用 money = 1 表示有钱, money = 0表示没有钱; seat = 1 表示有空座，seat = 0 表示没有空座
money = 1
seat = 0
if money == 1:
    print('土豪，不差钱，顺利上车')
    if seat == 1:
        print('有空座，可以坐下')
    else:
        print('没有空座，站等')
else:
    print('没钱，不能上车，追着公交车跑')

5.2 if嵌套执行流程

6. 应用：猜拳游戏

需求分析：

参与游戏的角色
- 玩家
  - 手动出拳
- 电脑
  - 随机出拳
判断输赢
- 玩家获胜
玩家电脑

石头剪刀

剪刀布

布石头
- 平局
  - 玩家出拳和电脑出拳相同
- 电脑获胜

玩家	电脑
石头	剪刀
剪刀	布
布	石头

随机做法：

导出random模块

import 模块名

使用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:c0
if (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 random

import sys

print("-----欢迎来到人机对战小游戏-----")
name = input("请输入您的游戏名：")
while True:
    stats = input("欢迎“%s”来到本游戏，开始游戏输入Y，退出游戏输入N，请您输入：" % name)
    if stats == "Y" or stats == "y":
        print("游戏开始……")
        print("石头输入0、剪刀输入1、布输入2")
        break
    elif 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":
        return
    else:
        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 = 1
b = 2

c = a if a > b else b
print(c)

十二、循环简介

1. 循环的作用

让代码更高效的重复执行。

2. 循环的分类

在Python中，循环分为while和for两种，最终实现效果相同。

3. while的语法

while 条件:
    条件成立重复执行的代码1
    条件成立重复执行的代码2
    ......

4. while循环快速体验

需求：复现重复执行10次print('Hello World')。

分析：初始值是0次，终点是10次，重复做的事情输出“Hello World”。

# 循环的计数器
i = 0
while i < 10:
    print('Hello World')
    i += 1

print('任务结束')

5. while的应用

5.1 应用一：计算1-100累加和

分析：1-100的累加和，即1 + 2 + 3 + 4 +….，即前两个数字的相加结果 + 下一个数字( 前一个数字 + 1)。

i = 1
result = 0
while i <= 100:
    result += i
    i += 1

# 输出5050
print(result)

注意：为了验证程序的准确性，可以先改小数值，验证结果正确后，再改成1-100做累加。

5.2 应用二：计算1-100偶数累加和

分析：1-100的偶数和，即 2 + 4 + 6 + 8…，得到偶数的方法如下：

偶数即是和2取余结果为0的数字，可以加入条件语句判断是否为偶数，为偶数则累加
初始值为0 / 2 , 计数器每次累加2

方法一：条件判断和2取余数则累加

# 方法一：条件判断和2取余数为0则累加计算
i = 1
result = 0
while i <= 100:
    if i % 2 == 0:
        result += i
    i += 1

# 输出2550
print(result)

方法二：计数器控制

# 方法二：计数器控制增量为2
i = 0
result = 0
while i <= 100:
    result += i
    i += 2

# 输出2550
print(result)

6. break和continue

break和continue是循环中满足一定条件退出循环的两种不同方式。

6.1 理解

举例：一共吃5个苹果，吃完第一个，吃第二个…，这里”吃苹果”的动作是不是重复执行？

情况一：如果吃的过程中，吃完第三个吃饱了，则不需要再吃第4个和第五个苹果，即是吃苹果的动作停止，这里就是break控制循环流程，即终止此循环。

情况二：如果吃的过程中，吃到第三个吃出一个大虫子…,是不是这个苹果就不吃了，开始吃第四个苹果，这里就是continue控制循环流程，即退出当前一次循环继而执行下一次循环代码。

6.2 break实例

i = 1
while i <= 5:
    if i == 4:
        print(f'吃饱了不吃了')
        break
    print(f'吃了第{i}个苹果')
    i += 1

6.3 continue实例

i = 1
while i <= 5:
    if i == 3:
        print(f'大虫子，第{i}个不吃了')
        # 在continue之前一定要修改计数器，否则会陷入死循环
        i += 1
        continue
    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 = 0
while j <= 4:
    # 一行星星的打印
    i = 0
    while i <= 4:
        # 一行内的星星不能换行，取消print默认结束符\n
        print('*', end='')
        i += 1
    # 每行结束要换行，这里借助一个空的print，利用print默认结束符换行
    print()
    j += 1

应用二：打印星号（三角形）

# 重复打印5行星星
# j表示行号
j = 0
while j <= 4:
    # 一行星星的打印
    i = 0
    # i表示每行里面星星的个数，这个数字要和行号相等所以i要和j联动
    while i <= j:
        print('*', end='')
        i += 1
    print()
    j += 1

应用二：九九乘法表

# 重复打印9行表达式
j = 1
while j <= 9:
    # 打印一行里面的表达式 a * b = a*b
    i = 1
    while 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 break

str1 = 'Hello World'
for i in str1:
    if i == 'e':
        print('遇到e不打印')
        break
    print(i)

8.4 continue

str1 = 'Hello World'
for i in str1:
    if i == 'e':
        print('遇到e不打印')
        continue
    print(i)

十三、else

循环可以和else配合使用，else下方缩进的代码指的是当循环正常结束之后要执行的代码。

1. while…else

1.1 语法

while 条件:
    条件成立重复执行的代码
else:
    循环正常结束之后要执行的代码

1.2 示例

i = 1
while i <= 5:
    print('Hello World')
    i += 1
else:
    print('执行完毕')

1.3 退出循环的方式

break终止循环

i = 1
while i <= 5:
    if i == 3:
        print("提前结束")
        break
    print('Hello World')
    i += 1
else:
    print('执行完毕')

所谓else指的是循环正常结束之后要执行的代码，即如果是break终止循环的情况，else下方缩进的代码将不执行。

continue控制循环

i = 1
while i <= 5:
    if i == 3:
        print("打断一下")
        i += 1
        continue
    print('Hello World')
    i += 1
else:
    print('执行完毕')

因为continue是退出当前一次循环，继续下一次循环，所以该循环在continue控制下是可以正常结束的，当循环结束后，则执行了else缩进的代码。

2. for…else

2.1 语法

for 临时变量 in 序列:
    重复执行的代码
    ...
else:
    循环正常结束之后要执行的代码

所谓else指的是循环正常结束之后要执行的代码，即如果是break终止循环的情况，else下方缩进的代码将不执行。

2.2 示例

str1 = 'Hello World'
for i in str1:
    print(i)
else:
    print('循环正常结束之后执行的代码')

2.3 退出循环的方式

break终止循环

str1 = 'Hello World'
for i in str1:
    if i == 'e':
        print('遇到e不打印')
        break
    print(i)
else:
    print('循环正常结束之后执行的代码')

没有执行else缩进的代码。

continue控制循环

str1 = 'Hello World'
for i in str1:
    if i == 'e':
        print('遇到e不打印')
        continue
    print(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])  # cde
print(name[2:5])  # cde
print(name[:5])  # abcde
print(name[1:])  # bcdefg
print(name[:])  # abcdefg
print(name[::2])  # aceg
print(name[:-1])  # abcdef, 负1表示倒数第一个数据
print(name[-4:-1])  # def
print(name[::-1])  # gfedcba

7. 常用操作方法

字符串的常用操作方法有查找、修改和判断三大类。

7.1 查找

所谓字符串查找方法即是查找子串在字符串中的位置或出现的次数。

find()：检测某个子串是否包含在这个字符串中，如果在返回这个子串开始的位置下标，否则则返回-1。

语法

字符串序列.find(子串, 开始位置下标, 结束位置下标)

注意：开始和结束位置下标可以省略，表示在整个字符串序列中查找。

快速体验

mystr = "hello world and buran and list and Python"

print(mystr.find('and'))  # 12
print(mystr.find('and', 15, 30))  # 22
print(mystr.find('ands'))  # -1

index()：检测某个子串是否包含在这个字符串中，如果在返回这个子串开始的位置下标，否则则报异常。

语法

字符串序列.index(子串, 开始位置下标, 结束位置下标)

注意：开始和结束位置下标可以省略，表示在整个字符串序列中查找。

快速体验

mystr = "hello world and buran and list and Python"

print(mystr.index('and'))  # 12
print(mystr.index('and', 15, 30))  # 22
print(mystr.index('ands'))  # 报错

rfind()：和find()功能相同，但查找方向为右侧开始。
rindex()：和index()功能相同，但查找方向为右侧开始。
count()：返回某个子串在字符串中出现的次数。

语法

字符串序列.count(子串, 开始位置下标, 结束位置下标)

注意：开始和结束位置下标可以省略，表示在整个字符串序列中查找。

快速体验

mystr = "hello world and buran and list and Python"

print(mystr.count('and'))  # 3
print(mystr.count('ands'))  # 0
print(mystr.count('and', 0, 20))  # 1

7.2 修改

所谓修改字符串，指的就是通过函数的形式修改字符串中的数据。

replace()：替换字符串。

语法

字符串序列.replace(旧子串, 新子串, 替换次数)

注意：替换次数如果查出子串出现次数，则替换次数为该子串出现次数。

快速体验

mystr = "hello world and buran and list and Python"

print(mystr.replace('and', 'he'))
# 结果：hello world he buran he list he Python
print(mystr.replace('and', 'he', 10))
# 结果：hello world he buran he list he Python
print(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()：用一个字符或子串合并字符串，即是将多个字符串合并为一个新的字符串。

语法

字符或子串.join(多字符串组成的序列)

快速体验

list1 = ['hello', 'buran', 'list']
t1 = ('aa', 'b', 'cc', 'ddd')

print('_'.join(list1))
# hello_buran_list
print('...'.join(t1))
# 结果：aa...b...cc...ddd

capitalize()：将字符串第一个字符转换成大写。

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 Python

lower()：将字符串中大写转小写。

mystr = "hello world and buran and list and Python"

print(mystr.lower())
# 结果：hello world and buran and list and python

upper()：将字符串中小写转大写。

mystr = "hello world and buran and list and Python"

print(mystr.upper())
# 结果：HELLO WORLD AND BURAN AND LIST AND PYTHON

lstrip()：删除字符串左侧空白字符。
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'))
# 结果：True
print(mystr.startswith('hello', 5, 20))
# 结果：False

endswith()：：检查字符串是否是以指定子串结尾，是则返回 True，否则返回 False。如果设置开始和结束位置下标，则在指定范围内检查。

语法

字符串序列.endswith(子串, 开始位置下标, 结束位置下标)

快速体验

mystr = "hello world and buran and list and Python"

print(mystr.endswith('Python'))
# 结果：True
print(mystr.endswith('python'))
# 结果：False
print(mystr.endswith('Python', 2, 20))
# 结果：False

isalpha()：如果字符串至少有一个字符并且所有字符都是字母则返回 True, 否则返回 False。

mystr1 = 'hello'
mystr2 = 'hello12345'

print(mystr1.isalpha())
# 结果：True
print(mystr2.isalpha())
# 结果：False

isdigit()：如果字符串只包含数字则返回 True 否则返回 False。

mystr1 = 'aaa12345'
mystr2 = '12345'

print(mystr1.isdigit())
# 结果： False
print(mystr2.isdigit())
# 结果：False

isalnum()：如果字符串至少有一个字符并且所有字符都是字母或数字则返回 True,否则返回 False。

mystr1 = 'aaa12345'
mystr2 = '12345-'

print(mystr1.isalnum())
# 结果：True
print(mystr2.isalnum())
# 结果：False

isspace()：如果字符串中只包含空白，则返回 True，否则返回 False。

mystr1 = '1 2 3 4 5'
mystr2 = ' '

print(mystr1.isspace())
# 结果：False
print(mystr2.isspace())
# 结果：True

十五、列表

1. 列表的格式

[数据1, 数据2, 数据3, 数据4......]

列表可以一次性有序存储多个不同类型的数据。

2. 列表的常用操作

列表的作用是一次性存储多个数据，程序员可以对这些数据进行的操作有：增、删、改、查。

2.1 查找

下标

name_list = ['Tom', 'Lily', 'Rose']

print(name_list[0])  # Tom
print(name_list[1])  # Lily
print(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'))  # 1

len()：访问列表长度，即列表中数据的个数。

name_list = ['Tom', 'Lily', 'Rose']

print(len(name_list))  # 3

2.2 判断是否存在

in：判断指定数据在某个列表序列，如果在返回True，否则返回False。

name_list = ['Tom', 'Lily', 'Rose']

# 结果：True
print('Lily' in name_list)

# 结果：False
print('Lilys' in name_list)

not in：判断指定数据不在某个列表序列，如果不在返回True，否则返回False。

name_list = ['Tom', 'Lily', 'Rose']

# 结果：False
print('Lily' not in name_list)

# 结果：True
print('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 删除

del 目标
# del(目标)

删除列表：

name_list = ['Tom', 'Lily', 'Rose']

# 结果：报错提示：name 'name_list' is not defined
del name_list
print(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)

# 结果：Lily
print(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 while

name_list = ['Tom', 'Lily', 'Rose']

i = 0
while i < len(name_list):
    print(name_list[i])
    i += 1

3.2 for

name_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))  # tuple

t3 = (20)
print(type(t3))  # int

t4 = ('hello')
print(type(t4))  # str

2. 元组的常见操作

元组数据不支持修改，只支持查找，具体如下：

按下标查找数据

tuple1 = ('aa', 'bb', 'cc', 'bb')
print(tuple1[0])  # aa

index()：查找某个数据，如果数据存在返回对应的下标，否则报错，语法和列表、字符串的index方法相同。

tuple1 = ('aa', 'bb', 'cc', 'bb')
print(tuple1.index('aa'))  # 0

count()：统计某个数据在当前元组出现的次数。

tuple1 = ('aa', 'bb', 'cc', 'bb')
print(tuple1.count('bb'))  # 2

len()：统计元组中数据的个数。

tuple1 = ('aa', 'bb', 'cc', 'bb')
print(len(tuple1))  # 4

3. 元组的注意事项

元组内的直接数据如果修改则立即报错。

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'])  # Tom
print(dict1['id'])  # 报错

如果当前查找的key存在，则返回对应的值；否则则报错。

get()

字典序列.get(key, 默认值)

注意：如果当前查找的key不存在则返回第二个参数(默认值)，如果省略第二个参数，则返回None。

dict1 = { 
   'name': 'Tom', 'age': 20, 'gender': '男'}
print(dict1.get('name'))  # Tom
print(dict1.get('id', 110))  # 110
print(dict1.get('id'))  # None

keys()

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 遍历字典的key

dict1 = { 
   'name': 'Tom', 'age': 20, 'gender': '男'}
for key in dict1.keys():
    print(key)

3.2 遍历字典的value

dict1 = { 
   '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))  # set

s5 = { 
   }
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. 运算符

运算符	描述	支持的容器类型
+	合并	字符串、列表、元组
*	复制	字符串、列表、元组
in	元素是否存在	字符串、列表、元组、字典
not in	元素是否不存在	字符串、列表、元组、字典

1.1 +

# 1. 字符串 
str1 = 'aa'
str2 = 'bb'
str3 = str1 + str2
print(str3)  # aabb


# 2. 列表 
list1 = [1, 2]
list2 = [10, 20]
list3 = list1 + list2
print(list3)  # [1, 2, 10, 20]

# 3. 元组 
t1 = (1, 2)
t2 = (10, 20)
t3 = t1 + t2
print(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')  # True
print('a' not in 'abcd')  # False

# 2. 列表
list1 = ['a', 'b', 'c', 'd']
print('a' in list1)  # True
print('a' not in list1)  # False

# 3. 元组
t1 = ('a', 'b', 'c', 'd')
print('aa' in t1)  # False
print('aa' not in t1)  # True

2. 公共方法

函数	描述
len()	计算容器中元素个数
del 或 del()	删除
max()	返回容器中元素最大值
min()	返回容器中元素最小值
range(start, end, step)	生成从start到end的数字，步长为 step，供for循环使用
enumerate()	函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中。

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))  # 2

2.2 del()

# 1. 字符串
str1 = 'abcdefg'
del str1
print(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))  # 40

2.4 min()

# 1. 字符串
str1 = 'abcdefg'
print(min(str1))  # a

# 2. 列表
list1 = [10, 20, 30, 40]
print(min(list1))  # 10

2.5 range()

# 1 2 3 4 5 6 7 8 9
for i in range(1, 10, 1):
    print(i)

# 1 3 5 7 9
for i in range(1, 10, 2):
    print(i)

# 0 1 2 3 4 5 6 7 8 9
for 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 = 0
while i < 10:
    list1.append(i)
    i += 1

print(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)

方法二：if实现

list1 = [i for i in range(10) if i % 2 == 0]
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}

注意：集合有数据去重功能。

补充：接下来的Python高级语法：函数、文件操作、面向对象、模块、包、异常等知识，我将陆续更新在自己的博客之中。如果本博文的知识能帮助到您的Python学习，本博主实属荣幸。更多后续知识，请关注博主，方便您第一时间查看，谢谢！

今天的文章深入理解python_基础语法分享到此就结束了，感谢您的阅读。

版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容，请发送邮件至举报，一经查实，本站将立刻删除。
如需转载请保留出处：http://bianchenghao.cn/78368.html