跨境互联网 跨境互联网
首页
  • AI 工具

    • 绘图提示词工具 (opens new window)
    • ChatGPT 指令 (opens new window)
  • ChatGPT

    • ChatGP T介绍
    • ChatGPT API 中文开发手册
    • ChatGPT 中文调教指南
    • ChatGPT 开源项目
  • Midjourney

    • Midjourney 文档
  • Stable Diffusion

    • Stable Diffusion 文档
  • 其他

    • AIGC 热门文章
    • 账号合租 (opens new window)
    • 有趣的网站
  • Vue

    • Vue3前置
  • JAVA基础

    • Stream
    • Git
    • Maven
    • 常用第三方类库
    • 性能调优工具
    • UML系统建模
    • 领域驱动设计
    • 敏捷开发
    • Java 测试
    • 代码规范及工具
    • Groovy 编程
  • 并发编程&多线程

    • 并发编程
    • 高性能队列 Disruptor
    • 多线程并发在电商系统下的应用
  • 其他

    • 面试题
  • 消息中间中间件

    • Kafka
    • RabbitMQ
    • RocketMQ
  • 任务调度

    • Quartz
    • XXL-Job
    • Elastic-Job
  • 源码解析

    • Mybatis 高级使用
    • Mybatis 源码剖析
    • Mybatis-Plus
    • Spring Data JPA
    • Spring 高级使用
    • Spring 源码剖析
    • SpringBoot 高级使用
    • SpringBoot 源码剖析
    • Jdk 解析
    • Tomcat 架构设计&源码剖析
    • Tomcat Web应用服务器
    • Zookeeper 高级
    • Netty
  • 微服务框架

    • 分布式原理
    • 分布式集群架构场景化解决方案
    • Dubbo 高级使用
    • Dubbo 核心源码剖析
    • Spring Cloud Gateway
    • Nacos 实战应用
    • Sentinel 实战应用
    • Seata 分布式事务
  • 数据结构和算法的深入应用
  • 存储

    • 图和Neo4j
    • MongoDB
    • TiDB
    • MySQL 优化
    • MySQL 平滑扩容实战
    • MySQL 海量数据存储与优化
    • Elasticsearch
  • 缓存

    • Redis
    • Aerospike
    • Guava Cache
    • Tair
  • 文件存储

    • 阿里云 OSS 云存储
    • FastDF 文件存储
  • 基础

    • Linux 使用
    • Nginx 使用与配置
    • OpenResty 使用
    • LVS+Keepalived 高可用部署
    • Jekins
  • 容器技术

    • Docker
    • K8S
    • K8S
  • 01.全链路(APM)
  • 02.电商终极搜索解决方案
  • 03.电商亿级数据库设计
  • 04.大屏实时计算
  • 05.分库分表的深入实战
  • 06.多维系统下单点登录
  • 07.多服务之间分布式事务
  • 08.业务幂等性技术架构体系
  • 09.高并发下的12306优化
  • 10.每秒100W请求的秒杀架构体系
  • 11.集中化日志管理平台的应用
  • 12.数据中台配置中心
  • 13.每天千万级订单的生成背后痛点及技术突破
  • 14.红包雨的架构设计及源码实现
  • 人工智能

    • Python 笔记
    • Python 工具库
    • 人工智能(AI) 笔记
    • 人工智能(AI) 项目笔记
  • 大数据

    • Flink流处理框架
  • 加密区

    • 机器学习(ML) (opens new window)
    • 深度学习(DL) (opens new window)
    • 自然语言处理(NLP) (opens new window)
AI 导航 (opens new window)

Revin

首页
  • AI 工具

    • 绘图提示词工具 (opens new window)
    • ChatGPT 指令 (opens new window)
  • ChatGPT

    • ChatGP T介绍
    • ChatGPT API 中文开发手册
    • ChatGPT 中文调教指南
    • ChatGPT 开源项目
  • Midjourney

    • Midjourney 文档
  • Stable Diffusion

    • Stable Diffusion 文档
  • 其他

    • AIGC 热门文章
    • 账号合租 (opens new window)
    • 有趣的网站
  • Vue

    • Vue3前置
  • JAVA基础

    • Stream
    • Git
    • Maven
    • 常用第三方类库
    • 性能调优工具
    • UML系统建模
    • 领域驱动设计
    • 敏捷开发
    • Java 测试
    • 代码规范及工具
    • Groovy 编程
  • 并发编程&多线程

    • 并发编程
    • 高性能队列 Disruptor
    • 多线程并发在电商系统下的应用
  • 其他

    • 面试题
  • 消息中间中间件

    • Kafka
    • RabbitMQ
    • RocketMQ
  • 任务调度

    • Quartz
    • XXL-Job
    • Elastic-Job
  • 源码解析

    • Mybatis 高级使用
    • Mybatis 源码剖析
    • Mybatis-Plus
    • Spring Data JPA
    • Spring 高级使用
    • Spring 源码剖析
    • SpringBoot 高级使用
    • SpringBoot 源码剖析
    • Jdk 解析
    • Tomcat 架构设计&源码剖析
    • Tomcat Web应用服务器
    • Zookeeper 高级
    • Netty
  • 微服务框架

    • 分布式原理
    • 分布式集群架构场景化解决方案
    • Dubbo 高级使用
    • Dubbo 核心源码剖析
    • Spring Cloud Gateway
    • Nacos 实战应用
    • Sentinel 实战应用
    • Seata 分布式事务
  • 数据结构和算法的深入应用
  • 存储

    • 图和Neo4j
    • MongoDB
    • TiDB
    • MySQL 优化
    • MySQL 平滑扩容实战
    • MySQL 海量数据存储与优化
    • Elasticsearch
  • 缓存

    • Redis
    • Aerospike
    • Guava Cache
    • Tair
  • 文件存储

    • 阿里云 OSS 云存储
    • FastDF 文件存储
  • 基础

    • Linux 使用
    • Nginx 使用与配置
    • OpenResty 使用
    • LVS+Keepalived 高可用部署
    • Jekins
  • 容器技术

    • Docker
    • K8S
    • K8S
  • 01.全链路(APM)
  • 02.电商终极搜索解决方案
  • 03.电商亿级数据库设计
  • 04.大屏实时计算
  • 05.分库分表的深入实战
  • 06.多维系统下单点登录
  • 07.多服务之间分布式事务
  • 08.业务幂等性技术架构体系
  • 09.高并发下的12306优化
  • 10.每秒100W请求的秒杀架构体系
  • 11.集中化日志管理平台的应用
  • 12.数据中台配置中心
  • 13.每天千万级订单的生成背后痛点及技术突破
  • 14.红包雨的架构设计及源码实现
  • 人工智能

    • Python 笔记
    • Python 工具库
    • 人工智能(AI) 笔记
    • 人工智能(AI) 项目笔记
  • 大数据

    • Flink流处理框架
  • 加密区

    • 机器学习(ML) (opens new window)
    • 深度学习(DL) (opens new window)
    • 自然语言处理(NLP) (opens new window)
AI 导航 (opens new window)
  • Python介绍
  • 基础

    • Python变量与数据类型
    • Python标准输入、格式化输出
    • Python运算符与注解
    • Python选择判断结构(if)
    • Python循环结构(while与for)
    • Python数据序列(字符串、列表、元组)
      • 1. 了解字符串
        • 1.1 字符串的定义
        • 1.2 字符串输入
        • 1.3 字符串的输出
        • ☆ 普通输出
        • ☆ 格式化输出
        • 1.4 字符串在计算机底层的存储形式
        • 1.5 聊聊索引下标
      • 2. 字符串切片
        • 2.1 什么是字符串切片
        • 2.2 字符串切片基本语法
        • 2.3 字符串切片小口诀
        • 2.4 字符串切片的小栗子
      • 3. 字符串的操作方法(内置)
        • 3.1 字符串中的查找方法
        • ☆ find()方法
        • ☆ index()方法
        • 3.2 字符串的修改方法
        • ☆ replace()方法
        • ☆ split()方法
        • ☆ join()方法
        • ☆ upper()与lower() 方法
        • 3.3 字符串的判断方法
        • ☆ startswith()
        • ☆ endswith()
      • 4. 列表及其应用场景
        • 4.1 为什么需要列表
        • 4.2 列表的定义
        • 4.3 列表的相关操作
        • ☆ 查操作
        • ☆ 增操作
        • ☆ append()
        • ☆ extend()方法
        • ☆ insert()方法
        • ☆ 删操作
        • ☆ del删除指定的列表元素
        • ☆ pop()方法
        • ☆ remove()方法
        • ☆ clear()方法
        • ☆ 改操作
        • 4.4 列表的循环遍历
        • 4.5 列表的嵌套
      • 5. 元组的定义与使用
        • 5.1 为什么需要元组
        • 5.2 元组的定义
        • 5.3 元组的应用场景(这个技术在未来工作中的应用场景)
        • 5.4 元组的相关操作方法
    • Python数据序列(字典、集合)
    • Python函数基础
    • Python函数进阶
    • Python异常
  • 进阶

  • 其他

  • Python开源项目
  • Python
  • 基础
Revin
2023-04-16
目录

Python数据序列(字符串、列表、元组)

# 1. 了解字符串

# 1.1 字符串的定义

字符串是 Python 中最常用的数据类型。我们一般使用引号来创建字符串。创建字符串很简单,只要为变量分配一个值即可。

示例1:使用单引号或双引号定义字符串变量

str1 = 'abcdefg'
str2 = "hello world"

print(type(str1))  # <class 'str'>
print(type(str2))  # <class 'str'>
1
2
3
4
5

示例2:使用3个引号定义字符串变量

name1 = '''I am Tom, Nice to meet you!'''
print(name1)
print(type(name1))

print('-' * 20)

name2 = """I am Jennify,
           Nice to meet you!"""
print(name2)
print(type(name2))
1
2
3
4
5
6
7
8
9
10

注意:三引号形式的字符串支持换行操作

示例3:思考如何使用字符串定义"I'm Tom"

使用单引号情况

str1 = 'I'm Tom'
1

运行结果:

image-20230421123013447

出现以上问题的主要原因在于,以上字符串的定义代码出现了(syntax)语法错误。单引号在字符串定义中必须成对出现,而且Python解析器在解析代码时,会自动认为第一个单引号和最近的一个单引号是一对!

如果一定要在单引号中在放入一个单引号,必须使用反斜杠进行转义。

str1 = 'I\'am Tom'
1

使用双引号情况

str2 = "I'm Tom"
1

注:在Python中,如果存在多个引号,建议① 单引号放在双引号中 ② 双引号放在单引号中。

# 1.2 字符串输入

在Python代码中,我们可以使用input()方法来接收用户的输入信息。记住:在Python中,input()方法返回的结果是一个字符串类型的数据。

name = input('请输入您的姓名:')
age = input('请输入您的年龄:')
address = input('请输入您的住址:')

print(name, age, address)
1
2
3
4
5

① input()可以阻断当前正在执行的代码,让系统处于等待状态,直到用户输入完成

② input()方法接收到的所有数据,返回的数据类型都是字符串

# 1.3 字符串的输出

# ☆ 普通输出

print(变量名称)
print(变量名称1, 变量名称2, 变量名称3)
1
2

# ☆ 格式化输出

① 百分号(Python2和Python3)

name = input('请输入您的姓名:')
age = int(input('请输入您的年龄:'))
address = input('请输入您的住址:')

print('我的名字是%s,今年%d岁了,家里住在%s...' % (name, age, address))
1
2
3
4
5

② format方法(Python3)

name = input('请输入您的姓名:')
age = input('请输入您的年龄:')
address = input('请输入您的住址:')

print('我的名字是{},今年{}岁了,家里住在{}...'.format(name, age, address))
1
2
3
4
5

③ f形式(Python3)

name = input('请输入您的姓名:')
age = input('请输入您的年龄:')
address = input('请输入您的住址:')

print(f'我的名字是{name},今年{age}岁了,家里住在{address}...')
1
2
3
4
5

延伸:

name = input('请输入您购买商品的名称:')
price = float(input('请输入您购买商品的价格:'))  # 18.5

print(f'购买商品名称:{name},商品价格:{price:.2f}')
1
2
3
4

# 1.4 字符串在计算机底层的存储形式

在计算机中,Python中的字符串属于序列结构。所以其底层存储占用一段连续的内存空间。

str1 = 'itheima'
1

结构原理图:

索引的最大值 = len(字符串) - 1

7个字符,则索引下标的最大值为7-1 = 6

image-20230421123348990

注意:索引下标从0开始。

# 1.5 聊聊索引下标

索引下标,就是编号。比如火车座位号,座位号的作用:按照编号快速找到对应的座位。同理,下标的作用即是通过下标快速找到对应的数据。

image-20230421123425172

举个例子:

name = 'abcdef'
print(name[0])  # a
print(name[3])  # d
1
2
3

image-20230421123552455

# 2. 字符串切片

# 2.1 什么是字符串切片

所谓的切片是指对操作的对象截取其中一部分的操作。字符串、列表、元组都支持切片操作。

# 2.2 字符串切片基本语法

顾头不顾尾:

序列名称[开始位置下标:结束位置下标:步长(步阶)]

numstr = '0123456789'
numstr[0:3:1]  # 012 => range方法非常类似,步长:每次前进1步
numstr[0:3:2]  # 02 => 每次前进2步
步长可以为负数,正数代表从左向右截取,负数代表从右向左截取
1
2
3
4
5
6

① 不包含结束位置下标对应的数据, 正负整数均可;

② 步长是选取间隔,正负整数均可,正数从左向右,负数从右向左。默认步长为1。

还是有点陌生,没关系,给你举个栗子:

numstr = '0123456789'
1

如果想对numstr字符串进行切片,如下图所示:

image-20230421123628982

# 2.3 字符串切片小口诀

记口诀:切片其实很简单,只顾头来尾不管,步长为正正向移,步长为负则逆向移

如果还是有点不太清楚这个原理,建议大家对字符串进行画图

image-20230421123646630

# 2.4 字符串切片的小栗子

示例1:

numstr = '0123456789'
# 1、从2到5开始切片,步长为1
print(numstr[2:5:1])
print(numstr[2:5])
# 2、只有结尾的字符串切片:代表从索引为0开始,截取到索引为5的位置(不包含索引为5的数据)
print(numstr[:5])
# 3、只有开头的字符串切片:代表从起始位置开始,已知截取到字符串的结尾
print(numstr[1:])
# 4、获取或拷贝整个字符串
print(numstr[:])
# 5、调整步阶:类似求偶数
print(numstr[::2])
# 6、把步阶设置为负整数:类似字符串翻转
print(numstr[::-1])
# 7、起始位置与结束位置都是负数
print(numstr[-4:-1])
# 8、结束字符为负数,如截取012345678
print(numstr[:-1])
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

示例2:

image-20230421123731920

示例3:给定一个图片的名称为"avatar.png",使用Python方法获取这个图片的名称(avatar)以及这个图片的后缀(.png)。

分析:

① 建议先获取点号的位置(目前还未学习,只能一个一个数)

② 从开头切片到点号位置,得到的就是文件的名称

③ 从点号开始切片,一直到文件的结尾,则得到的就是文件的后缀

filename = 'avatar.png'
# 获取点号的索引下标
index = 6
# 使用切片截取文件的文件
name = filename[:index]
print(f'上传文件的名称:{name}')

# 使用切片截取文件的后缀
postfix = filename[index:]
print(f'上传文件的后缀:{postfix}')
1
2
3
4
5
6
7
8
9
10

# 3. 字符串的操作方法(内置)

# 3.1 字符串中的查找方法

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

基本语法:

字符串.find(要查找的字符或者子串)
1
编号 函数 作用
1 find() 检测某个子串是否包含在这个字符串中,如果在返回这个子串开始的位置下标,否则则返回-1。
2 index() 检测某个子串是否包含在这个字符串中,如果在返回这个子串开始的位置下标,否则则报异常。

# ☆ find()方法

作用:检测某个子串是否包含在这个字符串中,如果在返回这个子串开始的位置下标,否则则返回-1。

# 定义一个字符串
str1 = 'hello world hello linux hello python'
# 查找linux子串是否出现在字符串中
print(str1.find('linux'))
# 在str1中查找不存在的子串
print(str1.find('and'))
1
2
3
4
5
6

示例:使用input方法输入任意一个文件名称,求点号的索引下标

filename = input('请输入您要上传文件的名称:')
# 获取点号的索引下标
index = filename.find('.')
print(index)

# 求文件名称
print(filename[:index])

# 求文件后缀
print(filename[index:])
1
2
3
4
5
6
7
8
9
10

# ☆ index()方法

index()方法其功能与find()方法完全一致,唯一的区别在于当要查找的子串没有出现在字符串中时,find()方法返回-1,而index()方法则直接报错。

str1 = 'apple, banana, orange'
# 判断apple是否出现在字符串str1中
print(str1.index('apple'))
print(str1.index('pineapple'))
1
2
3
4

运行结果:

image-20230421124027723

# 3.2 字符串的修改方法

所谓修改字符串,指的就是通过函数(方法)的形式修改字符串中的数据。

编号 函数 作用
1 replace() 返回替换后的字符串
2 split() 返回切割后的列表序列
3 title() 所有单词首字母大写
4 upper()与lower() 返回全部大写或小写的字符串

# ☆ replace()方法

基本语法:

字符串.replace(要替换的内容, 替换后的内容, 替换的次数-可以省略)
1

示例:编写一个字符串,然后把字符串中的linux替换为python

str1 = 'hello linux and hello linux'
# 把字符串中所有linux字符替换为python
print(str1.replace('linux', 'python'))
# 把字符串中的第一个linux进行替换为python
print(str1.replace('linux', 'python', 1))
# 把and字符串替换为&&
print(str1.replace('and', '&&'))
1
2
3
4
5
6
7

目前在工作中,replace主要用于实现关键字替换或过滤功能。北京 ==> BJ,论坛关键字过滤

# ☆ split()方法

作用:对字符串进行切割操作,返回一个list()列表类型的数据

str1 = 'apple-banana-orange'
print(str1.split('-'))
1
2

# ☆ join()方法

作用:和split()方法正好相反,其主要功能是把序列拼接为字符串

字符串.join(数据序列)
1

示例:把水果列表['apple', 'banana', 'orange']拼接成'apple-banana-orange'

list1 = ['apple', 'banana', 'orange']
print('-'.join(list1))
1
2

# ☆ upper()与lower() 方法

upper():把字符串全部转换为大写形式

lower():把字符串全部转换为小写形式

# 用户名以及密码验证示例
username = input('请输入您的账号:')
password = input('请输入您的密码:')

# 把username和password全部转换为大写或小写
print(username.lower())
print(password.upper())
1
2
3
4
5
6
7

# 3.3 字符串的判断方法

所谓判断即是判断真假,返回的结果是布尔型数据类型:True 或 False。

编号 函数 作用
1 startswith() 检查字符串是否是以指定子串开头,是则返回 True,否则返回 False。如果设置开始和结束位置下标,则在指定范围内检查。
2 endswith() 检查字符串是否是以指定子串结尾,是则返回 True,否则返回 False。如果设置开始和结束位置下标,则在指定范围内检查。

# ☆ startswith()

作用:检查字符串是否是以指定子串开头,是则返回 True,否则返回 False。如果设置开始和结束位置下标,则在指定范围内检查。

str1 = 'python program'
print(str1.startswith('python'))
1
2

# ☆ endswith()

作用:检查字符串是否是以指定子串结尾,是则返回 True,否则返回 False。如果设置开始和结束位置下标,则在指定范围内检查。

str2 = 'avatar.png'
print(str2.endswith('.png'))

if str2.endswith('.png') or str2.endswith('.jpg') or str2.endswith('.gif'):
    print('是一张图片格式的图片')
else:
    print('您上传的文件格式异常')
1
2
3
4
5
6
7

# 4. 列表及其应用场景

# 4.1 为什么需要列表

思考:有一个人的姓名(TOM)怎么书写存储程序?

答:变量。

思考:如果一个班级100位学生,每个人的姓名都要存储,应该如何书写程序?声明100个变量吗?

答:No,我们使用列表就可以了, 列表一次可以存储多个数据。

在Python中,我们把这种数据类型称之为列表。但是在其他的编程语言中,如Java、PHP、Go等等中其被称之为数组。

# 4.2 列表的定义

列表序列名称 = [列表中的元素1, 列表中的元素2, 列表中的元素3, ...]
1

示例演示:定义一个列表,用于保存苹果、香蕉以及菠萝

list1 = ['apple', 'banana', 'pineapple']
# list列表类型支持直接打印
print(list1)
# 打印列表的数据类型
print(type(list1))  # <class 'list'>
1
2
3
4
5

注意:列表可以一次存储多个数据且可以为不同的数据类型

# 4.3 列表的相关操作

列表的作用是一次性存储多个数据,程序员可以对这些数据进行的操作有:

增、删、改、查。

# ☆ 查操作

列表在计算机中的底层存储形式,列表和字符串一样,在计算机内存中都占用一段连续的内存地址,我们向访问列表中的每个元素,都可以通过**"索引下标"**的方式进行获取。

image-20230421124233690

如果我们想获取列表中的某个元素,非常简单,直接使用索引下标:

list1 = ['apple', 'banana', 'pineapple']
# 获取列表中的banana
print(list1[1])
1
2
3

查操作的相关方法:

编号 函数 作用
1 index() 指定数据所在位置的下标
2 count() 统计指定数据在当前列表中出现的次数
3 in 判断指定数据在某个列表序列,如果在返回True,否则返回False
4 not in 判断指定数据不在某个列表序列,如果不在返回True,否则返回False

举个栗子:

# 1、查找某个元素在列表中出现的位置(索引下标)
list1 = ['apple', 'banana', 'pineapple']
print(list1.index('apple'))  # 0
# print(list1.index('peach'))  # 报错

# 2、count()方法:统计元素在列表中出现的次数
list2 = ['刘备', '关羽', '张飞', '关羽', '赵云']
# 统计一下关羽这个元素在列表中出现的次数
print(list2.count('关羽'))

# 3、in方法和not in方法(黑名单系统)
list3 = ['192.168.1.15', '10.1.1.100', '172.35.46.128']
if '10.1.1.100' in list3:
    print('黑名单IP,禁止访问')
else:
    print('正常IP,访问站点信息')
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

# ☆ 增操作

编号 函数 作用
1 append() 增加指定数据到列表中
2 extend() 列表结尾追加数据,如果数据是一个序列,则将这个序列的数据逐一添加到列表
3 insert() 指定位置新增数据
# ☆ append()

append() :在列表的尾部追加元素

names = ['孙悟空', '唐僧', '猪八戒']
# 在列表的尾部追加一个元素"沙僧"
names.append('沙僧')
# 打印列表
print(names)
1
2
3
4
5

注意:列表追加数据的时候,直接在原列表里面追加了指定数据,即修改了原列表,故列表为可变类型数据。

# ☆ extend()方法

列表结尾追加数据,如果数据是一个序列,则将这个序列的数据逐一添加到列表

示例:

list1 = ['Tom', 'Rose', 'Jack']
# 1、使用extend方法追加元素"Jennify"
# names.extend("Jennify")
# print(names)

# 2、建议:使用extend方法两个列表进行合并
list2 = ['Hack', 'Jennify']
list1.extend(list2)

print(list1)
1
2
3
4
5
6
7
8
9
10

总结:extend方法比较适合于两个列表进行元素的合并操作

# ☆ insert()方法

作用:在指定的位置增加元素

names = ['薛宝钗', '林黛玉']
# 在薛宝钗和林黛玉之间,插入一个新元素"贾宝玉"
names.insert(1, '贾宝玉')
print(names)
1
2
3
4

# ☆ 删操作

编号 函数 作用
1 del 列表[索引] 删除列表中的某个元素
2 pop() 删除指定下标的数据(默认为最后一个),并返回该数据
3 remove() 移除列表中某个数据的第一个匹配项。
4 clear() 清空列表,删除列表中的所有元素,返回空列表。
# ☆ del删除指定的列表元素

基本语法:

names = ['Tom', 'Rose', 'Jack', 'Jennify']
# 删除Rose
del names[1]
# 打印列表
print(names)
1
2
3
4
5
# ☆ pop()方法

作用:删除指定下标的元素,如果不填写下标,默认删除最后一个。其返回结果:就是删除的这个元素

names = ['貂蝉', '吕布', '董卓']
del_name = names.pop()
# 或
# del_name = names.pop(1)
print(del_name)
print(names)
1
2
3
4
5
6
# ☆ remove()方法

作用:删除匹配的元素

fruit = ['apple', 'banana', 'pineapple']
fruit.remove('banana')
print(fruit)
1
2
3
# ☆ clear()方法

清空列表

names = ['貂蝉', '吕布', '董卓']
# 随着故事的发展,人物都game over
names.clear()
# 打印列表
print(names)
1
2
3
4
5

# ☆ 改操作

编号 函数 作用
1 列表[索引] = 修改后的值 修改列表中的某个元素
2 reverse() 将数据序列进行倒叙排列
3 sort() 对列表序列进行排序
list1 = ['貂蝉', '大乔', '小乔', '八戒']
# 修改列表中的元素
list1[3] = '周瑜'
print(list1)

list2 = [1, 2, 3, 4, 5, 6]
list2.reverse()
print(list2)

list3 = [10, 50, 20, 30, 1]
list3.sort()  # 升序(从小到大)
# 或
# list3.sort(reverse=True)  # 降序(从大到小)
print(list3)
1
2
3
4
5
6
7
8
9
10
11
12
13
14

# 4.4 列表的循环遍历

什么是循环遍历?答:循环遍历就是使用while或for循环对列表中的每个数据进行打印输出

while循环:

list1 = ['貂蝉', '大乔', '小乔']

# 定义计数器
i = 0
# 编写循环条件
while i < len(list1):
    print(list1[i])
    # 更新计数器
    i += 1
1
2
3
4
5
6
7
8
9

for循环(个人比较推荐):

list1 = ['貂蝉', '大乔', '小乔']
for i in list1:
    print(i)
1
2
3

# 4.5 列表的嵌套

列表的嵌套:列表中又有一个列表,我们把这种情况就称之为列表嵌套

在其他编程语言中,称之为叫做二维数组或多维数组

应用场景:要存储班级一、二、三 => 三个班级学生姓名,且每个班级的学生姓名在一个列表。

classes = ['第一个班级','第二个班级','第三个班级']

一班:['张三', '李四']
二班:['王五', '赵六']
三班:['田七', '孙八']

把班级和学员信息合并在一起,组成一个嵌套列表
students = [['张三', '李四'],['王五', '赵六'],['田七', '孙八']]

students = [x,y,z]
students[0] == ['张三', '李四']
students[0][1]
1
2
3
4
5
6
7
8
9
10
11
12

问题:嵌套后的列表,我们应该如何访问呢?

# 访问李四
print(students[0][1])
# 嵌套列表进行遍历,获取每个班级的学员信息
for i in students:
    print(i)
1
2
3
4
5

# 5. 元组的定义与使用

# 5.1 为什么需要元组

思考:如果想要存储多个数据,但是这些数据是不能修改的数据,怎么做?

答:列表?列表可以一次性存储多个数据,但是列表中的数据允许更改。

num_list = [10, 20, 30]
num_list[0] = 100
1
2

那这种情况下,我们想要存储多个数据且数据不允许更改,应该怎么办呢?

答:使用元组,元组可以存储多个数据且元组内的数据是不能修改的。

# 5.2 元组的定义

元组特点:定义元组使用小括号,且使用逗号隔开各个数据,数据可以是不同的数据类型。

基本语法:

# 多个数据元组
tuple1 = (10, 20, 30)

# 单个数据元组
tuple2 = (10,)
1
2
3
4
5

注意:如果定义的元组只有一个数据,那么这个数据后面也要添加逗号,否则数据类型为唯一的这个数据的数据类型。

# 5.3 元组的应用场景(这个技术在未来工作中的应用场景)

  • 函数的参数和返回值,一个函数可以接受任意多个参数,或者依次返回多个数据(暂时了解)

  • 格式化字符串,百分号和format,格式化字符串后面的()本质上就是一个元组

    print('姓名:%s,年龄:%d,家庭住址:%s' % (name, age, address))

  • 让列表不可以修改,以保护数据安全

# 5.4 元组的相关操作方法

由于元组中的数据不允许直接修改,所以其操作方法大部分为查询方法。

编号 函数 作用
1 元组[索引] 根据索引下标查找元素
2 index() 查找某个数据,如果数据存在返回对应的下标,否则报错,语法和列表、字符串的index方法相同
3 count() 统计某个数据在当前元组出现的次数
4 len() 统计元组中数据的个数

示例1:访问元组中的某个元素

nums = (10, 20, 30)
print(nums[2])
1
2

示例2:查找某个元素在元组中出现的位置,存在则返回索引下标,不存在则直接报错

nums = (10, 20, 30)
print(nums.index(20))
1
2

示例3:统计某个元素在元组中出现的次数

nums = (10, 20, 30, 50, 30)
print(nums.count(30))
1
2

示例4:len()方法主要就是求数据序列的长度,字符串、列表、元组

nums = (10, 20, 30, 50, 30)
print(len(nums))
1
2
上次更新: 2025/04/03, 11:07:08
Python循环结构(while与for)
Python数据序列(字典、集合)

← Python循环结构(while与for) Python数据序列(字典、集合)→

最近更新
01
tailwindcss
03-26
02
PaddleSpeech
02-18
03
whisper
02-18
更多文章>
Theme by Vdoing | Copyright © 2019-2025 跨境互联网 | 豫ICP备14016603号-5 | 豫公网安备41090002410995号
  • 跟随系统
  • 浅色模式
  • 深色模式
  • 阅读模式