43.Python基础（一）

2301_787328492026-01-06 8:54

文章目录

第1章：Python介绍

Python模块

安装模块

刚才编写的Python程序只有极少的代码，实现的功能非常简单。随着程序复杂度的提高，代码量会同步 增长，这时若还是在一个文件中编写代码，代码的维护就会越来越困难。为了保证代码的可维护性，开 发人员通常将一些功能性代码放在其他文件中，这样用于存放功能性代码的文件就是模块。

作为一种强大且便捷的编程语言，Python自然支持以模块的形式组织代码。Python内置了一些标准模块 ，Python的使用者也贡献了丰富且强大的第三方模块；标准模块可以直接导入与使用，第三方模块则 需先行安装。

Python内置的pip工具（安装Python3.12时会自动安装该工具）可以非常方便地安装Python第三方模 块，该工具可在命令行中使用，语法格式如下：

python 复制代码 
pip install 模块名
python 复制代码 
pip install pygame

解决超时报错：

原因：国内镜像源未设置，需要配置pip.ini

pip镜像源设置

python 复制代码 
python -m pip install -i https://pypi.tuna.tsinghua.edu.cn/simple --upgrade pip
pip config set global.index-url https://pypi.tuna.tsinghua.edu.cn/simple

生成pip.ini文件后，再编辑添加镜像源

python 复制代码 
[global]
timeout=40
index-url=http://mirrors.aliyun.com/pypi/simple/
extra-index-url=
       https://pypi.tuna.tsinghua.edu.cn/simple/
       http://pypi.douban.com/simple/
       http://pypi.mirrors.ustc.edu.cn/simple/
[install]
trusted-host=
       pypi.tuna.tsinghua.edu.cn
       mirrors.aliyun.com
       pypi.douban.com
       pypi.mirrors.ustc.edu.cn

检查安装是否成功

python 复制代码 
pip list

样式展示

python 复制代码 
python -m pygame.examples.aliens

导入设置

python 复制代码 
import pygame
pygame.init()

注意：pip是在线工具，pip命令执行后，它需要联网获取模块资源，若没有网络或网络不佳，pip将无法 顺利安装第三方模块。

在使用模块中定义的内容之前，需先将模块导入到当前程序。Python使用import关键字导入模块，其语 法格式如下：

python 复制代码 
import 模块1,模块2,...

模块导入后，可通过点字符"."调用模块中的内容，其语法格式如下：

python 复制代码 
模块.函数
模块.变量

通过点字符调用模块中的内容可避免多个模块中存在同名函数时代码产生歧义，但若不存在同名函数， 可使用from...import...语句直接将模块的指定内容导入程序，并在程序中直接使用模块中的内容。

python 复制代码 
from pygame import init
init()

使用from...import...语句也可将指定模块的全部内容导入当前程序，此时可使用"*"指代模块中的全部内 容。

python 复制代码 
from pygame import *

建议：虽然from...import *可以方便地导入一个模块中的所有内容，但考虑到代码的可维护性，此种方 式不应被过多地使用。

模块（module）、包（package）和库（lib）是Python组织代码的三种方式。

  • 模块：最基础的代码组织方式，每个包含有组织的代码片段的.py文件都是一个模块，文件名就是模块 名。

  • 包：以类似目录的结构组织模块文件或子包，简单来说，一个包含init.py文件的目录就是一个包。包中 必有init.py文件，可以有多个模块或子包。

  • 库：一个抽象概念，它是指具有相关功能的模块的集合。

第2章：Python基础

2.1代码格式

可提升代码的可读性，与其他语言不同，Python代码的格式是Python语法的组成之一，不符合格式规范 的Python代码无法正常运行。

2.1.1：注释

1）单行注释

以"#"开头，用于说明当前行或之后代码的功能。单行注释既可以单独占一行，也可以位于标识的代码之 后，与标识的代码共占一行。

python 复制代码 
# 单行注释，打印Hello，Python
print("Hello,Python")

建议：为了确保注释的可读性，Python官方建议"#"后面先添加一个空格，再添加相应的说明文字；若 单行注释与代码共占一行，注释和代码之间至少应有两个空格。

2）多行注释

由三对双引号或单引号包裹的语句，主要用于说明函数或类的功能。因此多行注释也被称为说明文档。

python 复制代码 
'''
hello
你好
'''

2.1.2 ：缩进

Python代码的缩进可以通过Tab键控制，也可使用空格控制。空格是Python3首选的缩进方法，一般使 用4个空格表示一级缩进；Python3不允许混合使用Tab和空格。示例如下

python 复制代码 
if True:
    print('你好')
else:
     print('hello')

代码缩进量的不同会导致代码语义的改变，Python语言要求同一代码块的每行代码必须具有相同得缩进 量。程序中不允许出现无意义或者不规范的缩进，否则运行时会产生错误。示例如下

python 复制代码 
if True:
    print('你好')
else:
     print('hello')
   print('world')

上面最后一行代码的缩进量不符合规范，程序在运行后会出现错误，具体如下：

python 复制代码 
  File "D:\PycharmProjects\PythonProject\.venv\scr\基础\基础.py", line 5
    print('world')
                  ^
IndentationError: unindent does not match any outer indentation level

2.1.3： 语句换行

Python官方建议每行代码不超过79个字符，若代码过长应该换行。Python会将圆括号、中括号和大括 号中的行进行隐式连接，我们可以根据这个特点实现过长语句的换行显示。

python 复制代码 
string = ("Python是一种面向对象、解释型计算机程序设计语言，"
   "由Guido van Rossum于1989年底发明。"
   "第一个公开发行版发行于1991年，"
   "Python源代码同样遵循GPL(GNU General Public License)协议。")

# 运行结果不会换行

注意：原本由圆括号、中括号和大括号包裹的语句在换行时不需要另外添加圆括号

python 复制代码 
number = ["one","two",
    "three","four"]
print(number)

# 运行结果
['one', 'two', 'three', 'four']

2.2：标识符和关键字

在程序中表示一些事物，开发人员需要自定义一些符号和名称，这些符号和名称叫做标识符。 Python中的标识符需要遵守一定的规则。

命名规则：

1）标示符由字母、下划线和数字组成，且数字不能开头。

2）Python中的标识符是区分大小写的。例如，tom和Tom是不同的标识符。

3）Python中的标识符不能使用关键字 。

为了规范命名标识符，关于标识符的命名提以下建议：

1）见名知意。(姓名：name；年龄：age)

2）常量名使用大写的单个单词或由下画线连接的多个单词(ORDER_LIST_LIMIT)。

3）模块名、函数名使用小写的单个单词或由下画线连接的多个单词(low_with_under)。

4）类名使用大写字母开头的单个或多个单词。(Cat，Dog，Person)

关键字是Python已经使用的、不允许开发人员重复定义的标识符。Python3中一共有35个关键字，每个关键字都有不同的作用。

python 复制代码 
import keyword
print(keyword.kwlist)

['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']

获取命令字声明

python 复制代码 
import keyword
print(help('for'))

# 运行结果
The "for" statement
*******************

The "for" statement is used to iterate over the elements of a sequence
(such as a string, tuple or list) or other iterable object:

   for_stmt: "for" target_list "in" starred_expression_list ":" suite
             ["else" ":" suite]
......

2.3：变量和数据类型

2.3.1：变量

变量：用拉丁字母表示的，值不固定的数据。

程序在运行期间用到的数据会被保存在计算机的内存单元中，为了方便存取内存单元中的数据，Python 使用标识符来标识不同的内存单元，如此，标识符与数据建立了联系。

标识内存单元的标识符又称为变量名，Python通过赋值运算符"="将内存单元中存储的数值与变量名建立 联系，即定义变量，具体语法格式如下：变量 = 值

将内存单元中存储的数据100与变量名data建立联系,如下所示

python 复制代码 
date=100

2.3.2：数据类型

根据数据存储形式的不同，数据类型分为基础的数字类型和比较复杂的组合类型，其中数字类型又分为 整型、浮点型、布尔类型和复数类型；组合类型分为字符串、列表、元组、字典等。

1）数字类型

Python内置的数字类型有整型（int）、浮点型（float）、复数类型（complex）和布尔类型(bool)，其 中int、float和complex分别对应数学中的整数、小数和复数；bool类型比较特殊，它是int的子类，只有 True和False两种取值。

python 复制代码 
整型： 0     101     -239     False     True
浮点型： 3.1415     4.2E-10     -2.334E-9
复数类型： 3.12+1.2.3j     -1.23-93j
布尔类型： True     False

2）字符串

字符串是一个由单引号、双引号或者三引号包裹的、有序的字符集合。

python 复制代码 
使用单引号包含： 'Python123￥' 
使用双引号包含： "Python3*&%" 
使用三引号包含： '''Python s1 ~(())'''

3）列表

列表是多个元素的集合，它可以保存任意数量、任意类型的元素，且可以被修改。Python中使用"\[\]"创 建列表，列表中的元素以逗号分隔。

python 复制代码 
[1,2,'hello']

4）元组

元组与列表的作用相似，它可以保存任意数量与类型的元素，但不可以被修改。Python中使用"()"创建元 组，元组中的元素以逗号分隔

python 复制代码 
(1,2,'hello')

5）集合

集合与列表和元组类似，也可以保存任意数量、任意类型的元素，不同的是，集合使用"{}"创建，集合中 的元素无序且唯一。

注意：集合为空时，类型表示为字典

python 复制代码 
{1,2,'hello'}

6）字典

字典中的元素是"键（Key）：值（Value）"形式的键值对，键不能重复。Python中使用"{}"创建字典， 字典中的各元素以逗号分隔

python 复制代码 
{'name':'张三','age':22}

可以使用type()查看数据类型

python 复制代码 
info={'name':'张三','age':22}
print(type(info))

# 运行结果
<class 'dict'>

2.3.3：变量的输入和输出

程序要实现人机交互功能，需能从输入设备接收用户输入的数据，也需要向显示设备输出数据。

1）input函数

input()函数用于接收用户键盘输入的数据，返回一个字符串类型的数据，其语法格式如下所示：

python 复制代码 
input([prompt])

prompt表示函数的参数，用于设置接收用户输入时的提示信息。

python 复制代码 
num1=input('输入数字：')
print(type(num1))
# 类型转换
num2=int(input("输入整数："))
print(type(num2))


# 运行结果
输入数字：10
<class 'str'>
输入整数：10
<class 'int'>

2）print()函数

print()函数用于向控制台中输出数据，它可以输出任何类型的数据，其语法格式如下所示：

python 复制代码 
print(*objects, sep=' ', end='\n', file=sys.stdout)

objects：表示输出的对象。输出多个对象时，对象之间需要用分隔符隔。
sep：用于设定分隔符，默认使用空格作为分隔。
end：用于设定输出以什么结尾，默认值为换行符\n。
file：表示数据输出的文件对象。

代码示例

python 复制代码 
name1='张三'
score=87.2
age=20

# 单值输出
print(10+20)

# 多值输出
print(name1,score,age,sep="\n")

# %格式化
# %s（字符串）、%d（整数）、%f（浮点数
print("姓名:%s,年龄：%d,成绩：%f"%(name1,age,score))

#str.format()格式化
# 方式一 按位置索引匹配
print("姓名：{0}，年龄：{1}，再次显示姓名：{0}".format("李四",22))
# 方式二 关键字匹配, ".2f"四舍五入，保留两位小数
print("姓名：{name},成绩：{score:.2f}".format(name='王五',score=95.666))
# 方式三 直接传入变量

print("姓名：{}，年龄：{}".format(name1,score))
# f-string格式化
print(f"姓名是{name1},他的年龄是{age}")
python 复制代码 
30
张三
87.2
20
姓名:张三,年龄：20,成绩：87.200000
姓名：李四，年龄：22，再次显示姓名：李四
姓名：王五,成绩：95.67
姓名：张三，年龄：87.2
姓名是张三,他的年龄是20

2.4：课堂练习

2.4.1：打印购物票

购物小票又称购物收据，是指消费者购买商品时由商场或其它商业机构给用户留存的销售凭据。购物小票中一般会包含用户购买的商品名称、数量、单价以及总金额等信息。本实例要求编写代码，实现打印购物小票的功能。

2.4.2：蚂蚁森林

蚂蚁森林是支付宝客户端发起"碳账户"的一款公益活动：用户通过步行、地铁出行、在线消费等行为， 可在蚂蚁森林中获取能量，当能量到达一定数值后，用户可以在支付宝中申请一颗虚拟的树，申请成功 后会收到支付宝发放的一张植树证书。植树证书中包含申请日期、树苗编号等信息。本实例要求编写代 码，实现打印植树证书信息的功能。

2.5：数字类型

2.5.1：整型

整数类型（int）简称整型，它用于表示整数。整型常用的计数方式有4种，分别是二进制（以"0B"或"0b" 开头）、八进制（以数字"0o"或"0O"开头）、十进制和十六进制（以"0x"或"0X"开头）。

python 复制代码 
0b101 # 二进制
0o5 # 八进制
5 # 十进制
0x5 # 十六进制

为了方便使用各进制的数据，Python中内置了用于转换数据进制的函数：bin()、oct()、int()、hex()，关 于这些函数的功能说明如下。

代码示例

python 复制代码 
num=11
bin_num=0b1011
print("11的二进制：",bin(num))
print('11的八进制：',oct(num))
print("0b1011的十进制：",int(bin_num))
print("11的十六进制：",hex(num))

# 运行结果
11的二进制： 0b1011
11的八进制： 0o13
0b1011的十进制： 11
11的十六进制： 0xb

2.5.2：浮点类型

浮点型（float）用于表示实数，由整数和小数部分（可以是0）组成例如，3.14、0.9等。较大或较小的 浮点数可以使用科学计算法表示。

Python程序中使用字母e或E代表底数10

python 复制代码 
-3.14e2 # 即-314
3.14e-3 # 即0.00314

Python中的浮点型每个浮点型数据占8个字节（即64位），且遵守IEEE标准。Python中浮点型的取值范 围为-1.8e308~1.8e308，若超出这个范围，Python会将值视为无穷大（inf）或无穷小（-inf）。

2.5.3：复数类型

复数由实部和虚部构成，它的一般形式为：real+imagj，其中real为实部，imag为虚部，j为虚部单位。 示例如下：

python 复制代码 
complex_one = 1 + 2j # 实部为1，虚部为2
complex_two = 2j           # 实部为0，虚部为2

代码示例

python 复制代码 
complex_num=1+2j
print(complex_num.real)
print(complex_num.imag)

# 运行结果
1.0
2.0

2.5.4：布尔类型

布尔类型（bool）是一种特殊的整型，其值True对应整数1，False对应整数0。

python 复制代码 
None。
False。
任何数字类型的0，如0、0.0、0j。
任何空序列，如''''、()、[]。
空字典，如{}。

代码示例

python 复制代码 
print(bool(0))
print(bool(''))
print(bool([]))
print(bool(1))

# 运行结果
False
False
False
True

2.5.5：数字类型转换

Python内置了一系列可实现强制类型转换的函数，使用这些函数可以将目标数据转换为指定的类型。数 字类型间进行转换的函数有int()、float()、complex()。需要注意的是浮点型数据转换为整型数据后只保 留整数部分。

代码示例

python 复制代码 
num1=2
num2=3.6
print(int(num2))
print(float(num1))
print(complex(num1))

# 运行结果
3  # 只保留整数部分
2.0
(2+0j)

2.6：运算符

Python运算符是一种特殊的符号，主要用于实现数值之间的运算。根据操作数数量的不同，运算符可分 为单目运算符、双目运算符；根据运算符的功能，运算符可分为算术运算符、赋值运算符、比较运算 符、逻辑运算符和成员运算符。

2.6.1：算术运算符

Python中的算术运算符包括+、-、*、/、//、%和**。以操作数a = 2，b = 8为例对算术运算符进行使用 说明。

Python中的算术运算符既支持对相同类型的数值进行运算，也支持对不同类型的数值进行混合运算。在 混合运算时，Python会强制将数值的类型进行临时类型转换，这些转换遵循如下原则：

python 复制代码 
1:整型与浮点型进行混合运算时，将整型转化为浮点型。
2:其他类型与复数运算时，将其他类型转换为复数类型。

代码示例

python 复制代码 
print(10/2.0)
print(10-(3+8j))

# 运行结果
5.0
(7-8j)

2.6.2：赋值运算符

赋值运算符的作用是将一个表达式或对象赋值给一个左值。左值是指一个能位于赋值运算符左边的表达 式，它通常是一个可修改的变量，不能是一个常量。

赋值运算符允许同时为多个变量赋值

python 复制代码 
x = y = z = 1   # 变量x、y、z均赋值为1
a, b = 1, 2       # 变量a赋值为1，变量b赋值为2

Python中的算术运算符可以与赋值运算符组成复合赋值运算符，赋值运算符同时具备运算和赋值两项功 能。以变量num为例， Python复合赋值运算符的功能说明及示例如下表所示：

Python3.8中新增了一个赋值运算符------海象运算符":="，该运算符用于在表达式内部为变量赋值，因形 似海象的眼睛和长牙而得此命名。

python 复制代码 
num1=2
result=num1+(num2:=3)
print(result)

2.6.3：比较运算符

比较运算符也叫关系运算符，用于比较两个数值，判断它们之间的关系。Python中的比较运算符包括 ==、!=、>、<、>=、<=，它们通常用于布尔测试，测试的结果只能是True或False。以变量x=2，y=3为 例，具体如下：

2.6.4：逻辑运算符

Python中分别使用"or"，"and"，"not"这三个关键字作为逻辑运算符，其中or与and为双目运算符，not 为单目运算符。以x=10，y=20为例，具体如下：

2.6.5：成员运算符

成员运算符in和not in用于测试给定数据是否存在于序列（如列表、字符串）中，关于它们的介绍如下：

python 复制代码 
in：如果指定元素在序列中返回True，否则返回False。
not in：如果指定元素不在序列中返回True，否则返回False。

代码示例

python 复制代码 
x='Python'
y='t'
print(y in x)
print(y not in x)

# 运行结果
True
False

2.6.6：位运算符

位运算符用于按二进制位进行逻

按位左移(<<)是指将二进制形式操作数的所有位全部左移n位，高位丢弃，低位补0。以十进制9为例，9 转为二进制后是00001001，将转换后的二进制数左移4位。

按位右移(>>)是指将二进制形式操作数的所有位全部右移n位，低位丢弃，高位补0。以十进制8为例，8 转换为二进制后是00001000，将转换后的二进制数右移2位。

按位与(&)是指将参与运算的两个操作数对应的二进制位进行"与"操作。当对应的两个二进制位均为1时， 结果位就为1，否则为0。以十进制9和3为例，9和3转换为二进制后分别是00001001和00000011。

按位或(|)是指将参与运算的两个操作数对应的二进制位进行"或"操作。若对应的两个二进制位有一个为1 时，结果位就为1。若参与运算的数值为负数，参与运算的两个数均以补码出现。以十进制8和3为例，8 和3转换为二进制后分别是00001000和00000011。

按位异或(^)是指将参与运算的两个操作数对应的二进制位进行"异或"操作。当对应的两个二进制位中有 一个为1，另一个为0时，结果位为1，否则结果位为0。以十进制8和4为例，8和4转换为二进制后分别是 00001000和00000100。

按位取反(~)是指将二进制的每一位进行取反，0取反为1，1取反为0。按位取反操作首先会获取这个数的 补码，然后对补码进行取反，最后将取反结果转换为原码，例如，对9按位取反的计算过程如下：

2.6.7：运算符优先级

Python支持使用多个不同的运算符连接简单表达式，实现相对复杂的功能，为了避免含有多个运算符的 表达式出现歧义，Python为每种运算符都设定了优先级。Python中运算符的优先级从高到低如下：

说明：如果表达式中的运算符优先级相同，按从左向右的顺序执行；如果表达式中包含小括号，那么解 释器会先执行小括号中的子表达式

代码示例

python 复制代码 
a=20
b=2
c=6
result1=(a-b)+c
result2=a/b%c
result3=c**b*a
print(result1,result2,result3)

# 运行结果
24 4.0 720

第3章：流程控制

程序中的语句默认自上而下顺序执行，但通过一些特定的语句可以更改语句的执行顺序，使之产生跳 跃，回溯等，进而实现流程控制。Python中用于实现流程控制的特定语句分为条件语句，循环语句和跳 转语句。

3.1：条件语句

现实生活中，大家在12306网站购票时需要先验证身份，验证通过后可进入购票页面，验证失败则需重 新验证。在代码编写工作中，大家可以使用条件语句为程序增设条件，使程序产生分支，进而有选择地 执行不同的语句。

3.1.1：if语句

if语句由关键字if、判断条件和冒号组成，if语句和从属于该语句的代码段可组成选择结构。

python 复制代码 
if 条件表达式:
   代码块

执行if语句时，若if语句的判断条件成立（判断条件的布尔值为True），执行之后的代码段；若if语句的 判断条件不成立（判断条件的布尔值为False），跳出选择结构，继续向下执行。

某中学上周进行英语模拟考试，考试成绩不低于60分的学生为"合格"，假设小明的考试成绩为88分，输 出小明的成绩评估结果。

代码示例

python 复制代码 
score = 88
if score >= 60:
    print("考试及格")

# 运行结果
考试及格

3.1.2：if-else语句

一些场景不仅需要处理满足条件的情况，也需要对不满足条件的情况做特殊处理。因此，Python提供了 可以同时处理满足和不满足条件的if-else语句。

python 复制代码 
if 判断条件:
    代码块1
else:
    代码段2

执行if-else语句时，若判断条件成立，执行if语句之后的代码段1；若判断条件不成立，执行else语句之 后的代码段2。

代码示例

python 复制代码 
score = 50
if score >= 60:
    print("考试及格")
else:
    print("考试不及格")
    
# 运行结果 (可以修改成绩，两次进行结果比较)
考试不及格

3.1.3：if-elif-else语句

Python除了提供单分支和双分支条件语句外，还提供多分支条件语句if-elif-else。多分支条件语句用于 处理单分支和双分支无法处理的情况。

python 复制代码 
if 判断条件1:
    代码段1
elif 判断条件2:
    代码段2
elif 判断条件3:
    代码段3
...
else:
    代码段n

执行if-elif-else语句时，若if条件成立，执行if语句之后的代码段1；若if条件不成立，判断elif语句的判断 条件2：条件2成立则执行elif语句之后的代码段2，否则继续向下执行。以此类推，直至所有的判断条件 均不成立，执行else语句之后的代码段。

代码示例

python 复制代码 
score = 84
if score>=85:
    print("优秀")
elif 75 <= score <85:
    print("良好")
elif 60 <= score <75:
    print("合格")
else:
    print("不合格")
    
# 运行结果
良好

3.1.4：if嵌套

大家在某些火车站乘坐高铁出行时需要历经检票和安检两道程序：检票符合条件后方可进入安检程序， 安检符合条件后方可进站乘坐列车。这个场景中虽然涉及两个判断条件，但这两个条件并非选择关系， 而是嵌套关系：先判断外层条件，条件满足后才去判断内层条件；两层条件都满足时才执行内层的操 作。

Python中通过if嵌套可以实现程序中条件语句的嵌套逻辑。

python 复制代码 
if 判断条件1:               # 外层条件                    
       代码段1
       if 判断条件2:        # 内层条件
              代码段2
       ...

执行if嵌套时，若外层判断条件（判断条件1）的值为True，执行代码段1，并对内层判断条件（判断条 件2）进行判断：若判断条件2的值为True，则执行代码段2，否则跳出内层条件结构，顺序执行外层条 件结构中内层条件结构之后的代码；若外层判断条件的值为False，直接跳过条件语句，既不执行代码段 1，也不执行内层的条件结构。

案例：1年有12个月份，每个月的总天数具有一定的规律，1月，3月，5月，7月，8月，10月，12月有 31天，4月，6月，9月，11月有30天；2月的情况稍微复杂些，闰年的2月有29天，平年的2月有28天。 本示例要求根据年份和月份计算当月的天数。

代码示例

python 复制代码 
year=int(input("输入年份:"))
mouth=int(input("输入月份:"))
if mouth in [1,3,5,7,8,10,12]:
    print("%d月有31天" %mouth)
elif mouth in [4,6,9,11]:
    print("%d月有30天" %mouth)
elif mouth == 2:
    if year%4 ==0:
        print("%d年%d月有29天" %(year,mouth))
    else:
        print("%d年%d月有28天" %(year,mouth))
        
# 运行结果
输入年份:3542
输入月份:2
3542年2月有28天

扩展：isdigit()判断输入的字符串是否是数字，如果是返回True，否则为False

3.2：课堂练习

3.2.1：猜数字

猜数字由两个人参与，一个人设置一个数字，一个人猜数字，当猜数字的人说出一个数字，由出数字的 人告知是否猜中：若猜测的数字大于设置的数字，出数字的人提示"很遗憾，你猜大了"；若猜测的数字 小于设置的数字时，出数字的人提示"很遗憾，你猜小了"；若猜数字的人在规定的次数内猜中设置的数 字，出数字的人提示"恭喜，猜数成功"。 本实例要求编写代码，实现遵循上述规则的猜数字程序。

python 复制代码 
# 取10个1到100的随机数，1和100都能取到
import random
for i in range (10):
    print(random.randint(1,100))
python 复制代码 
# 猜数字
import random

num=random.randint(1,100)
count_num = 0
while True:
    guess_num = int(input("输入数字："))
    if guess_num==num:
       count_num=count_num+1
       print("猜对了，数字是：%d" %num)
       print("一共猜了%d次" %count_num)
       break
    elif guess_num > num:
        count_num=count_num+1
        print("猜大了")
    elif guess_num<num:
        count_num=count_num+1
        print("猜小了")

3.3：循环语句

现实生活中存在很多重复的事情，例如，地球一直围绕太阳不停地旋转；月球始终围绕地球旋转；每年 都会经历司机的更替；每天都是从白天到黑夜的过程，程序开发中同样可能出现代码的重复执行。 Python提供循环语句，使用该语句能以简洁的代码实现重复操作。

3.3.1 while语句

while语句一般用于实现条件循环，该语句由关键字while、循环条件和冒号组成，while语句和从属于该 语句的代码段组成循环结构。

python 复制代码 
while 条件表达式:
   代码块

案例：求和1+2+3...+10

代码示例

python 复制代码 
i=1
result=0
while i<=10:
    result+=i
    i+=1
print(result)

# 运行结果
55

无限循环(死循环)

python 复制代码 
while True:
    print("无限循环")

3.3.2：for语句

for语句一般用于实现遍历循环。遍历指逐一访问目标对象中的数据，例如逐个访问字符串中的字符；遍 历循环指在循环中完成对目标对象的遍历。

python 复制代码 
for 临时变量 in 目标对象:
    代码块

案例：使用循环遍历字符串"Python"的每个字符

代码示例

python 复制代码 
for word in "Python":
    print(word)
    
# 运行结果
P
y
t
h
o
n

for语句可以与range()函数搭配，range()函数可以生成一个由整数组成的可迭代对象

代码示例

python 复制代码 
#range(起始值，最终值，步长)，最终值取不到,起始值和步长可不写
for i in range(5):
    print(i)

# 运行结果
0
1
2
3
4

3.3.3：循环嵌套

循环之间可以互相嵌套，进而实现更为复杂的逻辑。循环嵌套按不同的循环语句可以划分为while循环嵌 套和for循环嵌套。

1）while循环嵌套

while循环嵌套是指while语句中嵌套了while或for语句。以while语句中嵌套while语句为例，while循环 嵌套的语法格式如下：

python 复制代码 
while 循环条件1：       # 外层循环
    代码段1
    while 循环条件2：   # 内层循环
        代码段2
       ......

执行while循环嵌套时，若外层循环条件1的值为True，则执行代码段1，并对内层循环的循环条件2进行 判断，若循环条件2的值为True则执行代码段2，若其值为False则结束内层循环。内层循环执行完毕后 继续判断外层循环的循环条件1，如此反复，直至循环条件1的值为False时结束外层循环。

案例：打印"*"组成的直角三角形

代码示例：

python 复制代码 
i=1
while i<6:
    j=0
    while j<i:
        print("*",end=' ')
        j+=1
    print()
    i+=1

2）for循环嵌套

for循环嵌套是指for语句中嵌套了while或for语句。以for语句中嵌套for语句为例，for循环嵌套的语法格 式如下：

python 复制代码 
for 临时变量 in 目标对象：       # 外层循环
    代码段1
    for 临时变量 in 目标对象：   # 内层循环
        代码段2
       ......

执行for循环嵌套时，程序首先会访问外层循环中目标对象的首个元素，执行代码段1，访问内层循环目 标对象的首个元素、执行代码段2，然后访问内层循环中的下一个元素，执行代码段2，如此往复，直至 访问完内层循环的目标对象后结束内层循环，转而继续访问外层循环中的下一个元素，访问完外层循环 的目标对象后结束外层循环。因此外层循环每执行一次，都会执行一轮内层循环。

案例：打印"*"组成的直角三角形

python 复制代码 
for j in range(5):   #外层循环控制行
    for i in range(j):   #内层循坏控制列
        print("*",end=' ')
    print()
    
# 运行结果
* 
* * 
* * * 
* * * *

倒直角三角

python 复制代码 
for j in range(5,0,-1):
    for i in range(j):
        print("*",end=' ')
    print()
    
# 运行结果
* * * * * 
* * * * 
* * * 
* * 
*

圣诞树

python 复制代码 
for j in range(5,0,-1):
    for i in range(j):
        print(" ",end=' ')
    for i in range(2*(6-j)-1):
        print("*",end=' ')
    print()
    
# 运行结果
          * 
        * * * 
      * * * * * 
    * * * * * * * 
  * * * * * * * * *

菱形

python 复制代码 
for j in range(5,0,-1):
     for i in range(j):
         print(" ",end=' ')
     for i in range(2*(6-j)-1):
         print("*",end=' ')
     print()
for j in range(0,6):
    for i in range(j):
        print(" ",end=' ')
    for i in range(2*(6-j)-1):
        print("*",end=' ')
    print()
    
# 运行结果
          * 
        * * * 
      * * * * * 
    * * * * * * * 
  * * * * * * * * * 
* * * * * * * * * * * 
  * * * * * * * * * 
    * * * * * * * 
      * * * * * 
        * * * 
          *

3.4：实训案例

3.4.1：逢7拍手游戏

逢7拍手游戏的规则是：从1开始顺序数数，数到有7或者包含7的倍数的时候拍手。本实例要求编写代

码，模拟实现逢七拍手游戏，实现输出100以内需要拍手的数字的程序。

python 复制代码 
 for i in range(101):
    if i%7==0 or '7' in str(i):
        print("*")
    else:
        print(i)
python 复制代码 
sum_money=0
clothes_sum_count=0
trousers_sum_count=0
hats_sum_count=0
shoes_sum_count=0
for i in range(1,6):
    print("是否进入第%d家店铺（yes/no）？" %i)
    answer1=input()
    if answer1 == "yes":
        print("是否购物（yes/no）？")
        answer2 = bool(input())
        if answer2 == "yes":
            while True:
                    print("1.衣服：￥200\n2.裤子：￥150\n3.帽子：￥20\n4.鞋子：￥180")
                    print("退出店铺请按0")
                    print("请输入你要选择的商品序号:")
                    goods = int(input())
                    print("请输入你要选择的商品数量:")
                    if goods==1:
                        clothes_count = int(input())
                        clothes_money=200*clothes_count
                        clothes_sum_count = clothes_count + clothes_sum_count
                        sum_money=clothes_money+sum_money
                    elif goods==2:
                         trousers_count = int(input())
                         trousers_money=150*trousers_count
                         trousers_sum_count = trousers_count + trousers_sum_count
                         sum_money = trousers_money + sum_money
                    elif goods==3:
                         hats_count = int(input())
                         hats_money=20*hats_count
                         hats_sum_count = hats_count + hats_sum_count
                         sum_money = hats_money + sum_money
                    elif goods==4:
                        shoes_count = int(input())
                        shoes_money=180*shoes_count
                        shoes_sum_count=shoes_count+shoes_sum_count
                        sum_money = shoes_money + sum_money
                    elif goods==0:
                        break
                    else:
                        print("序号无效，请重新输入")
        elif answer2=="no":
            break
        else:
            print("输入无效")
    elif answer1=="no":
        continue
print("消费总金额为%d\n衣服共买了%d\n裤子共买了%d\n帽子共买了%d\n鞋子共买了%d\n" %(sum_money,clothes_sum_count, trousers_sum_count, hats_sum_count, shoes_sum_count))

3.5：跳转语句

循环语句在条件满足的情况下会一直执行，但在某些情况下需要跳出循环，例如，实现音乐播放器循环 模式的切歌功能等。Python提供了控制循环的跳转语句：break和continue。

3.5.1：break语句

break语句用于结束循环，若循环中使用了break语句，程序执行到break语句时会结束循环；若循环嵌 套使用了break语句，程序执行到break语句时会结束本层循环。

案例：在使用for循环遍历字符串'Python'时，遍历到字符'o'就使用break语句结束循环。

示例代码

python 复制代码 
for i in 'Python':
    if i=='o':
        break
    print(i,end='')

# 运行结果
Pyth

3.5.2：continue语句

continue语句用于在满足条件的情况下跳出本次循环，该语句通常也与if语句配合使用。 案例：在使用for循环遍历字符串'Python'时，遍历到字符'o'就使用continue语句跳出本次循环。

示例代码

python 复制代码 
for i in 'Python':
    if i=='o':
        continue
    print(i,end='')
    
# 运行结果
Pythn

第4章：字符串

在使用浏览器登录网站时需要先输入账户和密码，之后浏览器将账号和密码传递给服务器，服务器把本

次输入的密码与之前保存的密码进行对比，两处密码相同则认为本次输入的密码正确，否则认为密码错

误，在以上场景中，用户的账号和密码都需要被存储，但用户的信息有字母、数字和字符组成，这些类

型就是字符串。

4.1：字符串介绍

字符串是由字母、符号或者数字组成的字符序列。

Python支持使用单引号、双引号和三引号定义字符串，其中单引号和双引号通常用于定义单行字符串，

三引号通常用于定义多行字符串。

代码示例

python 复制代码 
print('使用单引号在一行输出')
print("使用双引号在一行输出")
print("""使用三引号
进行多行输出""")

# 输出结果
使用单引号在一行输出
使用双引号在一行输出
使用三引号
进行多行输出

注意：当字符串中有相同类型引号出现，就需要变更外部的引号类型来避免语法错误

python 复制代码 
print("let's go ")
# 或
print("""let's go""")

除此以外，Python使用反斜杠"\"转义。例如，在字符串中的引号前添加"\"，此时Python解释器会将"\"之后的引号视为解释为一个普通字符，而非特殊符号。

python 复制代码 
print('let\'s go')
print('E:\\python\\code')


# 运行结果
let's go
E:\python\code

扩展：一些普通字符与反斜杠组合后将失去原有意义，产生新的含义。类似这样的由"\"和而成的、具有特殊意义的字符就是转义字符。转移字符通常用于表示一些无法显示的字符，例如空格、回车等。

代码示例

python 复制代码 
for j in range(1,10):
    for i in range(1,j+1):
        print(f"{i} x {j} = {i*j}",end='\t')
    print()
python 复制代码 
1 x 1 = 1	
1 x 2 = 2	2 x 2 = 4	
1 x 3 = 3	2 x 3 = 6	3 x 3 = 9	
1 x 4 = 4	2 x 4 = 8	3 x 4 = 12	4 x 4 = 16	
1 x 5 = 5	2 x 5 = 10	3 x 5 = 15	4 x 5 = 20	5 x 5 = 25	
1 x 6 = 6	2 x 6 = 12	3 x 6 = 18	4 x 6 = 24	5 x 6 = 30	6 x 6 = 36	
1 x 7 = 7	2 x 7 = 14	3 x 7 = 21	4 x 7 = 28	5 x 7 = 35	6 x 7 = 42	7 x 7 = 49	
1 x 8 = 8	2 x 8 = 16	3 x 8 = 24	4 x 8 = 32	5 x 8 = 40	6 x 8 = 48	7 x 8 = 56	8 x 8 = 64	
1 x 9 = 9	2 x 9 = 18	3 x 9 = 27	4 x 9 = 36	5 x 9 = 45	6 x 9 = 54	7 x 9 = 63	8 x 9 = 72	9 x 9 = 81

在一段字符串中如果包含多个转义字符，但又不希望转义字符产生作用，此时可以使用原始字符串。原 始字符串即在字符串开始的引号之前添加r或R，使它成为原始字符串。

python 复制代码 
print(r'转义字符：\n表示转行；\r表示回车；\b表示退格')

4.2：格式化字符串

格式化字符串是将制定的字符串转化为想要的格式。Python中有三种格式化字符串的方式：使用%格式 化、使用format()方法格式化和使用f-string格式化。

4.2.1：使用%格式化字符串

字符串具有一种特殊的内置操作，它可以使用%进行格式化。

python 复制代码 
format % values

format：表示一个字符串，该字符串中包含单个或多个为真实数据占位的格式符；

values：表示单个或多个真实数据；

%：代表执行格式化操作，即将format中的格式符替换为values。 不

同的格式符为不同类型的数据预留位置，常见的格式符如下所示。

下面使用%对字符串进行格式化

python 复制代码 
age=19
name='唐三'
info ='姓名是%s,今年%d岁'
print(info % (name,age)) #顺序不能变
python 复制代码 
姓名是唐三,今年19岁

注意：如果被替换的数据类型不符合格式符中制定的数据类型，那么程序会出现类型异常错误！

4.2.2：使用format()方法格式化字符串

虽然使用%可以对字符串进行格式化，但是这种方式并不是很直观，一旦开发人员遗漏了替换数据或选 择了不匹配的格式符，就会导致字符串格式化失败。为了能更直观、便捷地格式化字符串，Python为字 符串提供了一个格式化方法format()。

python 复制代码 
str.format(values)

str：表示需要被格式化的字符串，字符串中包含单个或多个为真实数据占位的符号{}；

values：表示单个或多个待替换的真实数据，多个数据之间以逗号分隔。

使用format{}方法格式化字 符串时，无须关注替换数据的类型。 字符串中可以包含多个{}符号，字符串被格式化时Python解释器默认会按从左到右的顺序将{}逐个替换 为真实的数据。

python 复制代码 
age=19
name='唐三'
info ='姓名是{},今年{}岁'
print(info.format(name,age)) #顺序不能变
python 复制代码 
姓名是唐三,今年19岁

字符串的{}中可以明确地指定编号，格式化字符串时解释器会按编号取values中相应位置的值替换{}， values中元素的索引从0开始。

python 复制代码 
age=19
name='唐三'
info ='姓名是{0},今年{1}岁'
print(info.format(name,age))

字符串的{}中可以指定名称，字符串在被格式化时Python解释器会按真实数据绑定的名称替换{}中的变量。

python 复制代码 
age=19
name='唐三'
info ='姓名是{a},今年{b}岁'
print(info.format(a=name,b=age))

字符串中的{}可以指定替换的浮点型数据的精度，浮点型数据在被格式化时会按指定的精度进行替换。

python 复制代码 
import math
r=5
pi=math.pi
s=r**2*pi
info='圆的半径是{a},π是{b:.3},圆面积是{c:.4}' # {b:.3}保留三位有效数字，b是参数
print(info.format(a=r,b=pi,c=s))

# 运行结果
圆的半径是5,π是3.14,圆面积是78.54

4.2.3：使用f-string格式化字符串

f-string提供了一种更为简洁的格式化字符串的方式，它在形式上以f或F引领字符串，在字符串中使用 "{变量名}"标明被替换的真实数据和其所在位置。

python 复制代码 
f('{变量名}') 或者 F('{变量名}')

代码示例

python 复制代码 
name='唐三'
age=18
print(f'姓名是{name},年龄是{age}岁')
python 复制代码 
姓名是唐三,年龄是18岁

4.3：实训案例

4.3.1：进制转换

十进制是实际应用中最常使用的计数方式，除此之外，还可以采用二进制、八进制或十六进制计数。 本实例要求编写代码，实现将用户输入的十进制整数转换为指定进制的功能。

4.4：字符串的常见操作

字符串的操作在实际应用中非常常见，Python内置了很多字符串方法，使用这些方法可以轻松实现字符 串的查找，替换，拼接，大小写转换等操作。但需要注意的是，字符串一但创建便不可修改；若对字符 串进行修改，就会生成新的字符串。

4.4.1：字符串的查找与替换

1）查找：Python中提供了实现字符串查找操作的find()方法，该方法可查找字符串中是否包含子串，若 包含则返回子串首次出现的位置，否则返回-1。

语法格式

python 复制代码 
str.find(sub[, start[, end]])

sub：指定要查找的子串。

start：开始索引，默认为0。

end：结束索引，默认为字符串的长度。

代码示例

python 复制代码 
strings='life is sort, i use python'
print(len(strings))
print(strings[2])
# find（）是显示匹配的第一个元素位置，如果为匹配则返回-1
print(strings.find('s'))

# 运行结果
26
f
6

2）替换：Python中提供了实现字符串替换操作的replace()方法，该方法可将当前字符串中的指定子串 替换成新的子串，并返回替换后的新字符串。

语法格式

python 复制代码 
str.replace(old, new[, count])

old：被替换的旧子串。

new：替换旧子串的新子串。

count：表示替换旧字符串的次数。

代码示例

python 复制代码 
# 替换 replace（）默认替换全文匹配，可以设置替换次数
word="""八百标兵奔北坡，北坡炮兵并排跑。炮兵怕把标兵碰，标兵怕碰炮兵炮。"""
new_string=word.replace("标兵","战士",count=2)
print(new_string)

# 运行结果
八百战士奔北坡，北坡炮兵并排跑。炮兵怕把战士碰，标兵怕碰炮兵炮。

4.4.2：字符串的分割与拼接

字符串的分割与拼接功能是处理文本数据时常用的功能。

1）字符串分割

split()方法可以按照指定分隔符对字符串进行分割，该方法会返回由分割后的子串组成的列表。

语法格式

python 复制代码 
str.split(sep=None, maxsplit=-1)

sep：分隔符，默认为空字符。

maxsplit：分割次数，默认值为-1，表示不限制分割次数。

代码示例

python 复制代码 
word="""八百标兵奔北坡，北坡炮兵并排跑。炮兵怕把标兵碰，标兵怕碰炮兵炮。"""
#以'兵'作为分隔符
print(word.split('兵'))
#以'兵'作为分隔符，并分割2次
result=word.split('兵',2)
print(result)

# 运行结果
['八百标兵奔北坡，北坡炮兵并排跑。炮兵怕把标兵碰，标兵怕碰炮兵炮。']
['八百标', '奔北坡，北坡炮', '并排跑。炮', '怕把标', '碰，标', '怕碰炮', '炮。']
['八百标', '奔北坡，北坡炮', '并排跑。炮兵怕把标兵碰，标兵怕碰炮兵炮。']

2）字符串拼接

join()方法使用指定的字符连接字符串并生成一个新的字符串。join()方法的语法格式如下。

语法格式

python 复制代码 
str.join(iterable)

iterable：表示连接字符串的字符。

使用'-'连接字符串Python中的各个字符，代码示例

python 复制代码 
symbol ='#'
word='python'
print(symbol.join(word))

# 运行结果
p#y#t#h#o#n

Python中还可以使用运算符'+'和'*'连接字符串，代码示例

python 复制代码 
start = 'Py'
end = 'thon'
print(start+end) #使用'+'连接
print(end*3) #使用'*'倍数连接

# 运行结果
Python
thonthonthon

4.4.3：删除字符串的指定字符

字符串中可能会包含一些无用的字符（如空格），在处理字符串之前往往需要先删除这些无用的字符。Python中的strip()、lstrip()和rstrip()方法可以删除字符串中的指定字符。

代码示例

python 复制代码 
words='*i use python*'
print(words)
new_words1=words.strip('*')
new_words2=words.lstrip('*')
new_words3=words.rstrip('*')
print(new_words1)
print(new_words2)
print(new_words3)

# 运行结果
*i use python*
i use python
i use python*
*i use python

4.4.4：字符串大小写转换

在特定情况下会对英文单词的大小写形式进行要求，表示特殊简称时全字母大写，如CBA；表示月份、 周日、节假日时每个单词首字母大写，如Monday。Python中支持字母大小写转换的方法有upper()、 lower()、capitalize()和title()。

示例代码

python 复制代码 
# 大小写转换
string='Life is short.I use Python'
print('大写：',string.upper())
print('小写：',string.lower())
print('语句首字母大写：',string.capitalize())
print('标题：',string.title())

# 运行结果
大写： LIFE IS SHORT.I USE PYTHON
小写： life is short.i use python
语句首字母大写： Life is short.i use python
标题： Life Is Short.I Use Python

4.4.5：字符串对齐

在使用Word处理文档时可能需要对文档的格式进行调整，如标题居中显示、左对齐、右对齐等。 Python提供了center()、ljust()、rjust()这3个方法来设置字符串的对齐方式。

python 复制代码 
# 对齐方式
words='hello world'
print(len(words))
print(words.center(15,'-'))
print(words.ljust(15,'-'))
print(words.rjust(15,'-'))

运行结果
11
--hello world--
hello world----
----hello world

第5章：组合数据类型

在大数据时代，程序中不仅要处理数字、字符串这些基础数据类型的数据，还需要处理混合数据。为 此，Python定义了可以表示混合数据的组合数据类型。使用组合数据类型定义和记录数据，不仅能使数 据表示得更为清晰，也能极大简化程序员的开发工作，提升开发效率。

5.1：认识组合数据类型

组合数据类型可将多个相同类型或不同类型的数据组织为一个整体，根据数据组织方式的不同，Python 的组合数据类型可分成三类：序列类型、集合类型和映射类型。

1）序列类型

Python中常用的序列类型有字符串（str）、列表（list）和元组（tuple）。

Python中的序列支持双向索引：正向递增索引和反向递减索引。正向递增索引从左向右依次递增，第一 个元素的索引为0，第二个元素的索引为1，以此类推；反向递减索引从右向左依次递减，从右数第一个 元素的索引为-1，第二个元素的索引为-2，以此类推。

2）集合类型

Python集合具备确定性、互异性 和无序性三个特性。

Python要求放入集合中的元素必须是不可变类型，Python中的整型、浮点型、字符串类型和元组属于不可变类型，列表、字典及集合本身都属于可变的数据类型。

  • 确定性：给定一个集合，那么任何一个元素是否在集合中就确定了。

  • 互异性：集合中的元素互不相同。

  • 无序性：集合中的元素没有顺序，顺序不同但元素相同的集合可视为同一集合。

3）映射类型

映射类型以键值对的形式存储元素，键值对中的键与值之间存在映射关系。

字典（dict）是Python唯一的内置映射类型，字典的键必须遵守以下两个原则：

  • 每个键只能对应一个值，不允许同一个键在字典中重复出现。

  • 字典中的键是不可变类型。

5.2：列表

Python利用内存中的一段连续空间存储列表。列表是Python中最灵活的序列类型，它没有长度限制，可以包含任意元素。开发人员可以自由的对列表中的元素进行各种操作包括访问、添加、排序、删除。

5.2.1：创建列表

Python列表的创建方式非常简单，既可以直接使用中括号"\[\]"创建，也可以使用内置的list()函数快速创建。

1）使用中括号"\[\]"可以创建列表，示例代码如下：

python 复制代码 
list_one = []

\[\]中包括的是列表元素，列表元素可以是整型、浮点型、字符串等基本类型，也可以是列表、元组、字 典等组合类型，还可以是其他自定义类型；列表元素的类型可以相同也可以不同；列表中的元素使 用"，"分隔。

python 复制代码 
list_two = ['p', 'y', 't', 'h', 'o', 'n']

2）使用list()函数创建列表

list()函数接收一个可迭代类型的数据，返回一个列表。

python 复制代码 
li_two = list() # 使用list()创建空列表
li_two = list('python')

扩展：

  • 在Python中，支持通过for...in...语句迭代获取数据的对象就是可迭代对象。
  • 我们学习过可迭代的类型有字符串和列表，后续学习的集合、字典、文件也是可迭代类型的对象。
  • 使用isinstance()函数可以判断目标是否为可迭代对象，返回True表示为可迭代对象。
python 复制代码 
import random
# 迭代对象判断
from collections.abc import Iterable
print(isinstance(True,Iterable))

# 运行结果
False

5.2.2：访问列表元素

列表中的元素可以通过索引或切片这两种方式进行访问，也可以在循环中依次访问。

1）以索引方式访问列表元素

索引就像图书中的目录，阅读时可以借助目录快速定位到书籍的制定内容，访问列表时则可以借助索引 快速定位到列表中的元素。

python 复制代码 
list_dev=['abc','c#','123','php']
print(list_dev[0])
print(list_dev[-2])

# 运行结果
abc
123

2）以切片方式访问列表元素

切片用于截取列表中的部分元素，获取一个新列表。

格式

python 复制代码 
list[起始索引,结束索引,步长]

代码示例

python 复制代码 
list_char=['p','y','t','h','o','n']
print(list_char[1:4:2])
print(list_char[3:])
print(list_char[:3])
print(list_char[:])
print(list_char[::2])

# 运行结果
['y', 'h']
['h', 'o', 'n']
['p', 'y', 't']
['p', 'y', 't', 'h', 'o', 'n']
['p', 't', 'o']

3）在循环中依次访问列表元素

列表是一个可迭代对象，在for...in...语句中逐个访问列表中的元素。

python 复制代码 
list_char=['p','y','t','h','o','n']
for i in list_char:
    print(i,end=' ')
    
# 运行结果
p y t h o n

扩展：Python的成员运算符in和not in 对列表同样适用，利用in可判断某个元素是否存在于列表，利用 not in可以判断某个元素是否不存在列表。

python 复制代码 
list_char=['p','y','t','h','o','n']
print('p' in list_char)
print('a' not in list_char)

# 运行结果
True
True

5.2.3：添加列表元素

向列表中添加元素是非常常见的一种列表操作，Python提供了append()、extend()和insert()这几个方法 向列表末尾、指定位置添加元素。

1）append()方法

在列表末尾添加新的元素

python 复制代码 
list_one=[10,20]
list_one.append(30)
print(list_one)

# 运行结果
[10, 20, 30]

2）extend()方法

在列表末尾一次性添加另一个列表中的所有元素，即使用新列表扩展原来的列表。

python 复制代码 
# 列表扩展，那个表调用了extend,那个列表结构发生变化
list_one=[10,20]
list_two=[30,40,50]
list_one.extend(list_two)
print(list_one)
print(list_two)

# 运行结果
[10, 20, 30, 40, 50]
[30, 40, 50]

3）insert()方法

按照索引将新元素插入列表的指定位置。

python 复制代码 
list_one=[10,20]
list_one.insert(1,15)
print(list_one)

# 运行结果
[10, 15, 20]

5.2.4：元素排序

列表的排序是将元素按照某种规定进行排列。列表中常用的排序方法有sort()、reverse()、sorted()。

1）sort()方法

按特定顺序对列表元素排序，语法如下

python 复制代码 
sort(key=None,reverse=False)

以上格式中参数key用于指定排序规则，该参数可以是列表支持的函数，默认值为None；参数reverse用 于控制列表元素排序的方式，该参数可以取值True或者False，取值为True表示降序排列，取值为 False（默认值）表示升序排列，使用sort()方法对列表元素排序后，有序的元素会覆盖原来的列表元 素，不产生新列表。

python 复制代码 
list_one=[23,45,43,65,74,34]
list_two=['world','abcd','php']
list_one.sort()
print(list_one)
list_two.sort()
print(list_two)
list_one.sort(reverse=True)   #降序排列列表中的元素
print(list_one)

# 运行结果
[23, 34, 43, 45, 65, 74]
['abcd', 'php', 'world']
[74, 65, 45, 43, 34, 23]

2）sorted()方法

按升序排列列表元素，该方法的返回值是升序排列后的新列表，排序操作不会对原列表产生影响。

python 复制代码 
list_one=[23,45,43,65,74,34]
list_two=sorted(list_one)
print(list_one)
print(list_two)

# 运行结果
[23, 45, 43, 65, 74, 34]
[23, 34, 43, 45, 65, 74]

3）reverse()方法

用于逆置列表，即把原列表中的元素从右至左依次排列存放。

python 复制代码 
list_one=[23,45,43,65,74,34]
list_one.reverse()
print(list_one)

# 运行结果
[34, 74, 65, 43, 45, 23]

5.2.5：删除列表元素

删除列表元素的常用方式有del语句、remove()方法、pop()方法和clear()方法。

1）del语句

用于删除列表中指定位置的元素。

python 复制代码 
list_one=[23,45,43,65,74,34]
del list_one[2]
print(list_one)

# 运行结果
[23, 45, 65, 74, 34]

del也可以删除整个列表

python 复制代码 
list_one=[23,45,43,65,74,34]
del list_one
print(list_one)

# 运行结果，出现错误信息
Traceback (most recent call last):
  File "D:\PycharmProjects\PythonProject\.venv\scr\组合数据类型\列表.py", line 80, in <module>
    print(list_one)
          ^^^^^^^^
NameError: name 'list_one' is not defined

2）remove()方法

用于移除列表中的某个元素，若列表中有多个匹配的元素，remove()只移除匹配到的第1个元素。

python 复制代码 
list_one=[23,45,43,65,74,45,34]
list_one.remove(45)
print(list_one)

# 运行结果
[23, 43, 65, 74, 45, 34]

3）pop()方法

用于移除列表中的某个元素，若未指定具体元素，则移除列表中的最后1个元素。

python 复制代码 
list_one=[23,45,43,65,74,34]
print("删除的元素是：",list_one.pop())
print("删除的元素是：",list_one.pop(1))
print(list_one)

# 运行结果
[23, 43, 65, 74]

4）clear()方法 用于清空列表。

python 复制代码 
list_one=[23,45,43,65,74,34]
list_one.clear()
print(list_one)

# 运行结果
[]

5.2.6：列表推导式

列表推导式是符合Python语法规则的复合表达式，它用于以简洁的方式根据已有的列表构建满足特定需 求的列表。

python 复制代码 
[exp for x in list]

以上格式由表达式exp和之后的for...in...语句组成。其中，for...in...用于遍历列表（或者其他可迭代对 象）；exp用于在每层循环中对列表中的元素进行运算。

使用上面的列表推导式可方便的修改列表中的每个元素。例如，将一个列表中每个元素都替换成它的平 方。

python 复制代码 
ls=[1,2,3,4,5]
ls=[date*date for date in ls]
print(ls)

# 运行结果
[1, 4, 9, 16, 25]

列表推导式还可以结合if判断语句或for循环嵌套，生成更灵活的列表。

1）带有if语句的列表推导式

在基本列表推导式的for语句之后添加一个if语句，就组成了带有if语句的列表推导式。

python 复制代码 
[exp for x in list if cond]

上面格式的功能是：遍历列表，若列表中的元素x符合条件cond，按表达式exp对其进行运算后将其添加 到新列表中。

例如上例结果列表中只保留大于4的元素。

python 复制代码 
ls=[1,2,3,4,5]
ls=[date*date for date in ls]
ls=[date for date in ls if date>4]
print(ls)

# 运行结果
[9, 16, 25]

2）嵌套for循环语句的列表推导式

在基本列表推导式的for语句之后添加一个for语句，就实现了列表推导式的循环嵌套。

python 复制代码 
[exp for x in list_1 for y in list_2]

以上格式中的for语句按从左至右的顺序分别是外层循环和内层循环。利用此格式可以根据2个列表快速 生成一个新的列表。例如，取列表1和列表2中元素的和作为列表3的元素。

python 复制代码 
ls_one=[1,2,3]
ls_two=[4,5,6]
ls_three=[x+y for x in ls_one for y in ls_two]
print(ls_three)

# 运行结果
[5, 6, 7, 6, 7, 8, 7, 8, 9]

3）带有if语句和嵌套for循环语句的列表推导式

列表推导式中嵌套的for循环可以有多个，每个循环也都可以与if语句连用（应用场景不多，了解即 可）。

python 复制代码 
[exp for x in list_1 [if cond]
    for y in list_2 [if cond]
   ...
    for n in list_n [if cond]]

5.3：元组

元组的表现形式为一组包含在圆括号"()"中、由逗号分隔的元素，元组中元素的个数、类型不受限制。 使用圆括号可以直接创建元组，还可以使用内置函数tuple()构建元组。

python 复制代码 
t1 = ()     #空元组
t2 = (1,)   #包含单个元素的元组
t3 = (1,2,3)    #包含多个元素的元组
t4 = (1,'h',('o',2))    #元组嵌套

当使用圆括号"()"创建元组时，如果元组中只包含一个元素，那么需要在该元素的后面添加逗号，从而保 证Python解释器能够识别其为元组类型。

使用内置函数tuple()也可以创建元组，当函数的参数列表为空时该函数常见空元组，当参数为可迭代对 象时该函数创建非空元组。

python 复制代码 
t1 = tuple()    #创建空元组
t2 = tuple([1,2,3])     #利用列表创建元组(1,2,3)
t3 = tuple('python')    #利用字符串创建元组('p','y','t','h','o','n')
t4 = tuple(range(5))    #利用可迭代对象创建元组(0,1,2,3,4)

与列表相同，Python支持通过索引和切片访问元组的元素，也支持在循环中遍历元组。

python 复制代码 
print(t2[1])    #以索引方式访问元组元素
print(t3[2:5])  #以切片方式访问元组元素
for data in t3: #在循环中遍历元组
    print(data,end='')
    
# 运行结果
2
('t', 'h', 'o')
python

注意：元组是不可变类型，元组中的元素不能修改，即它不支持添加元素，删除元素和排序操作。

python 复制代码 
tuple_one=(10,20,30)
result=list(tuple_one) #强转为list
result.append(100)
print(result)

# 运行结果
[10, 20, 30, 100]

注意：元组是不可变类型，元组中的元素不能修改，即它不支持添加元素，删除元素和排序操作。

5.4：实训案例

5.4.1：十大歌手

为丰富校园文化生活，学校拟组织一场歌手大赛，从参赛选手中选拔出十名相对突出的学生，授予"校园 十大歌手"称号。比赛之中设置有评委组，每名选手演唱完毕之后会由评委组的十名评委打分。为保证比 赛公平公正，防止作弊和恶意打分，计算得分时会先去掉最高分和最低分，再计算平均分。 本实例要求编写程序，实现根据需求计算平均分的功能。

5.5：集合

Python的集合（set）本身是可变类型，但Python要求放入集合中的元素必须是不可变类型。 集合类型与列表和元组的区别是：集合中的元素无序但必须唯一。

1）创建集合

集合的表现形式为一组包含在大括号"{}"中、由逗号","分隔的元素。使用"{}"可以直接创建集合，使用内 置函数set()也可以创建集合。

python 复制代码 
s1 = {1} #单元素集合
s2 = {1,'b',(2,5)} #多元素结合

使用内置函数set()也可以创建集合。该函数的参数列表可以为空，此时该函数创建一个空集合。

python 复制代码 
s=set()
print(type(s))

注意！使用{}不能创建空集合（不包含元素的{}创建的是字典变量），空集合只能利用set()函数创建。 若使用set()函数创建非空集合，需为该函数传入可迭代对象。

python 复制代码 
s1 = set([1,2,3])       #传入列表
s2 = set((2,3,4))       #传入元组
s3 = set('python')      #传入字符串
s4 = set(range(5))      #传入整数列表
print(s1)
print(s2)
print(s3)
print(s4
      
# 运行结果
{1, 2, 3}
{2, 3, 4}
{'h', 'p', 'n', 'o', 'y', 't'}
{0, 1, 2, 3, 4}

2）集合的常见操作

集合是可变的，集合中的元素可以动态增加或删除。Python提供了一些内置方法来操作集合，常见内置 方法如下：

代码示例

python 复制代码 
set_two={10,20,30,40}
# 增加元素
set_two.add(50)
print(set_two)

#删除元素
# 元素不存在 报错
      set_two.remove(0)
set_two.remove(10)
print('remove删除：',set_two)

# 元素不存在 不报错
       set_two.discard(60)
set_two.discard(20)
print('discard删除：',set_two)

#随机删一个
result=set_two.pop()
print(set_two,'随机删除的数是：',result)

# 清空集合，集合为空，报错
set_two.clear()

# 复制
set_three=set_two.copy()
print('set_three集合为：',set_three)

#判断集合set_three和set_two是否有相同元素
print(set_three.isdisjoint(set_two))


# 运行结果
{40, 10, 50, 20, 30}
remove删除： {40, 50, 20, 30}
discard删除： {40, 50, 30}
set_two集合为： {50, 30} 随机删除的数是： 40
set_three集合为： {50, 30}
False

扩展：pop() 是基于HashMap实现的，它总是「删除」集合中的「第一个元素」，由于集合是「无序」 的，所以它看起来就像是「随机」删除元素。当集合中的元素是「纯数字」时，集合会按照从小到大的 顺序排列元素，「最小」的数值会别排在第一个，所以pop()时，会删除最小的那个元素。

3）集合推导式 集合也可以利用推导式创建，集合推导式的格式与列表推导式相似，区别在于集合推导式外侧为大括号 "{}"。

python 复制代码 
{exp for x in set if cond}

以上格式中遍历的可以是集合或者其他可迭代对象。利用集合推导式在列表ls的基础上生成只包含偶数 元素的集合。

python 复制代码 
ls ={1,2,3,4}
s={data for data in ls if data%2==0}
print(s)

# 运行结果
{2, 4}

5.6：字典

提到字典这个词相信大家都不会陌生，学生时期碰到不认识的字时，大家都会使用字典的部首表查找对 应的汉字。Python中的字典数据与学生使用的字典有类似的功能，它以"键值对"的形式组织数据，利用 "键"快速查找"值"。通过"键"查找"值"的过程称为映射，Python中的字典是典型的映射类型。

5.6.1：创建字典

字典的表现形式为一组包含在大括号"{}"中的键值对，每个键值对为一个字典元素，每个元素通过逗号 "，"分隔，每对键值通过"："分隔。

python 复制代码 
{键1:值1, 键2:值2,...,键N:值N}

字典的值可以是任意类型，但键不能是列表或字典类型。字典像集合一样使用"{}"包裹元素，它也具备类 似集合的特点：字典元素无序，键值必须唯一。

使用"{}"可以直接创建字典。

python 复制代码 
dict_1 = {}         #创建空字典
dict_2={'name':'张三','age':19,'score':[70,80,80]}

还可以使用内置函数dict()创建字典。

python 复制代码 
d1=dict()
d2=dict({'name':'张三','age':19,'score':[70,80,80]})

5.6.2：字典的访问

字典的值可通过"键"或内置方法get()访问。

python 复制代码 
字典变量[键]
d.get(key[,default])
python 复制代码 
dict_one={'name':'张三','age':19,'score':[70,80,80]}
print(dict_one.get('age'))
print(dict_one['score'])

# 运行结果
19
[70, 80, 80]

字典涉及的数据分为键、值和元素（键值对），除了直接利用键访问值外，Python还提供了内置方法 keys()、values()和items()。

python 复制代码 
dict_one={'name':'张三','age':19,'score':[70,80,80]}
print(dict_one.keys())
print(dict_one.values())
print(dict_one.items())

# 运行结果
dict_keys(['name', 'age', 'score'])
dict_values(['张三', 19, [70, 80, 80]])
dict_items([('name', '张三'), ('age', 19), ('score', [70, 80, 80])])

内置方法keys()、values()、items()的返回值都是可迭代对象，利用循环可以遍历这些对象。

python 复制代码 
dict_one={'name':'张三','age':19,'score':[70,80,80]}
for k,v in dict_one.items():
    print(k,v)
    print("-"*50)

# 运行结果
name 张三
--------------------------------------------------
age 19
--------------------------------------------------
score [70, 80, 80]
--------------------------------------------------

5.6.3：字典元素的添加和修改

字典支持通过为指定的键赋值或使用update()方法添加或修改元素。

1）字典元素的添加

当字典中不存在某个键时，利用一下格式可在字典中新增一个元素。

2）字典元素的修改 修改字典元素的本质是通过键获取值，再重新对元素进行赋值。修改元素的操作与添加元素的操作相 同。

python 复制代码 
字典变量[键] = 值
python 复制代码 
dict_one={'name':'张三','age':19,'score':[70,80,80]}
# 添加和修改，键名存在，修改；不存在，添加
#方式一
dict_one['hobby']='sleep'
dict_one['age']=20    #通过指定键修改
print(dict_one)

# 方式二
dict_one.update(hobby='sleep')
dict_one.update(age=20)  #使用update()修改
print(dict_one)

# 运行结果
{'name': '张三', 'age': 20, 'score': [70, 80, 80], 'hobby': 'sleep'}

5.6.4：字典元素的删除

Python支持通过pop()、popitem()和clear()方法删除字典中的元素。

1）pop()方法

pop()：根据指定键值删除字典中的指定元素，若删除成功，返回目标元素的值。

python 复制代码 
dict_one={'name':'张三','age':19,'score':[70,80,80]}
result=dict_one.pop('age')
print(result)
print(dict_one)

# 运行结果
19
{'name': '张三', 'score': [70, 80, 80]}

2）popitem()方法

popitem()：随机删除字典中的元素。实际上popitem()之所以能随机删除元素，是因为字典元素本身无 序，没有第1个和最后1个之分。若删除成功，popitem()方法返回被删除的元素。

python 复制代码 
dict_one={'name':'张三','age':19,'score':[70,80,80]}
print(dict_one.popitem())
print(dict_one)

# 运行结果
('score', [70, 80, 80])
{'name': '张三', 'age': 19}

3）clear()方法

clear()：清空字典中的元素。

python 复制代码 
dict_one={'name':'张三','age':19,'score':[70,80,80]}
dict_one.clear()
print(dict_one)

# 运行结果
{}

5.6.5：字典推导式

字典推导式的格式、用法与列表推导式类似，区别在于字典推导式外侧为大括号"{}"，且内部需包含键和 值两部分。

python 复制代码 
{new_key:new_value for key,value in dict.items()}

利用字典推导式可快速交换字典中的键和值。

python 复制代码 
dict_one={'name':'张三','age':19,'score':88}
dict_two={value : key for key,value in dict_one.items()}
print(dict_two)

# 运行结果
{'张三': 'name', 19: 'age', 88: 'score'}

5.7：实训案例

5.7.1：青春有你

如今两年偶像选秀节目风头正盛，吸引了许多喜欢唱跳、有一颗明星梦想的少年少女参加，青春有你正 是节目之一。青春有你采用计票机制，选手获得的票数越多，排名就越靠前。 本实例要求编写程序，接收选手的姓名和票数，输出排序后的成绩。

5.8：组合数据类型应用运算符

Python中针对数字类型的运算符对组合数据类型同样适用，包括+、*、in、not in。

1）'+' 运算符

字符串、列表和元组使用" + "运算符，会对数据进行拼接。

只能同类型进行'+'运算

python 复制代码 
str_two='world'
print(str_one+str_two)
list_one=[1,2,3]
list_two=[4,5,6]
print(list_one+list_two)
tuple_one=(10,20,30)
tuple_two=(10,20,30)
print(tuple_one+tuple_two)

# 运行结果
helloworld
[1, 2, 3, 4, 5, 6]
(10, 20, 30, 10, 20, 30)

2）'*' 运算符 字符串、列表和元组使用" * "运算符，字符串、列表和元组会对数据进行整数倍拼接。

python 复制代码 
list_one=[1,2,3]
print(list_one*3)

# 运行结果
[1, 2, 3, 1, 2, 3, 1, 2, 3]

3）'in' 'not in' 运算符

"in""not in"运算符称为成员运算符，用于判断某个元素是否属于某个变量。python的字符串、列表、元 组、集合和字典都支持成员运算符。

python 复制代码 
list_one=[1,2,3]
print(1 in list_one)
print(1 not in list_one)

# 运行结果
True
False
相关推荐
笨鸟先飞，勤能补拙4 小时前
AI 赋能网络安全：技术全景、成熟度评估与实战案例
人工智能·python·安全·web安全·网络安全·sqlite·github
长和信泰光伏储能5 小时前
京津冀光伏发电：绿色能源的未来之路
python·能源
浦信仿真大讲堂5 小时前
从重复操作到自动化闭环：如何让 CST 与 Python 真正协同起来
python·自动化·cst·仿真软件·达索软件
Gu Gu Study6 小时前
ScoutLoop开放域深度研究引擎（agent的初步设计想法）
人工智能·python
卷无止境6 小时前
写代码这件事，到底该讲究点什么？
后端·python
卷无止境7 小时前
循环复杂度到底在算什么，Python 代码怎么才能写得让人一看就懂
后端·python
lpfasd1237 小时前
MediaCrawler 项目深度分析
chrome·python·chrome devtools
Dxy12393102167 小时前
Python项目打包成EXE完整教程（PyInstaller实战避坑）
开发语言·python
bamb008 小时前
一个项目带你入门AI应用开发01
python
0566468 小时前
Python康复训练——常用标准库
开发语言·python·学习
热门推荐
01如何新建文件夹？ 电脑新建文件夹的4种方法02GitHub 镜像站点03国内可直接用、免费额度/永久免费的大模型API清单（含 SiliconFlow、火山、阿里、智谱、百度、Kimi、DeepSeek、DMXAPI 等）042026年7月AI圈大地震：GPT-5.6被政府限制、Claude入驻Slack、Anthropic自研芯片05微信历史版本含下载地址（ Windows PC | 安卓 | MAC ）及设置微信不更新06AI 编程 IDE 全景解析 2026：Agent 全面接管开发链路072026 国产 AI 大模型横评：DeepSeek、通义千问、Kimi、文心一言、星火、豆包谁更能打？08AI科技热点日报 | 2026年07月01日09Agnes AI 免费 API 接入指南：文本、生图、生视频，一套接口全免费102026 年 AI 大模型 & AI 编程工具实战全总结