python数据类型——超详细：字符串、列表、字典.........

python基础语法

1、python基础

1.1 编码

默认情况下，Python 3 源码文件以 UTF-8 编码，所有字符串都是 unicode 字符串。 当然你也可以为源码文件指定不同的编码

1.2标识符

标识符就是我们编程的时候使用的“名字“ , 给类、接口、方法、变量、常量名，包名等起名字的字符序列

  • 第一个字符必须是字母表中字母或下划线 _ 。
  • 标识符的其他的部分由字母、数字和下划线组成。
  • 标识符对大小写敏感。
  • 在 Python 3 中，可以用中文作为变量名，非 ASCII 标识符也是允许的了。

1.3注释

1.3.1注释

单行注释，单行注释以#开头

# print ("Hello, Python!")
print ("Hello, Python!") # 第二个注释

输出

Hello, Python!

多行注释

'''
print ("Hello, Python!")
print ("Hello, Python!")
'''
 
"""
print ("Hello, Python!")
print ("Hello, Python!")
"""
print ("Hello, Python!")

输出

Hello, Python!

1.4行与缩进

python最具特色的就是使用缩进来表示代码块，不需要使用大括号 {} 。在python中代码利用缩进来形成代码层，缩进的空格数是可变的，但是同一个代码块的语句必须包含相同的缩进空格数。

if True:
    print ("True")
else:
    print ("False")

当缩进不一样的时候会导致代码错误

1.5 多行语句

Python 通常是一行写完一条语句，但如果语句很长，我们可以使用反斜杠 \ 来实现多行语句，例如：

total = item_one + \
        item_two + \
        item_three

1.6变量

  • 变量代表一个有名字的、具有特定属性的一个存储单元；
  • 变量用来存放数据，也就是存放变量的值；
  • 变量的值可以改变；
  • 变量有特定的类型，类型决定了存储单元的大小和变量值的范围，运算符可应用于变量上。

变量常被描述为可⽤于存储值的盒⼦。在你刚接触变量时，这种定义很有帮助，但它并没有准确地描述 Python 内部表⽰变量的⽅式。⼀种好得多的定义是，变量是可以被赋值的标签，也可以说变量指向特定的值。

1.6.1变量的命名和使⽤

  1. 变量名只能包含字⺟、数字和下划线1。变量名能以字⺟或下划线打头，但不能以数字打头。

    例如，可将变量命名为 message_1，但不能将其命名为 1_message。

  2. 变量名不能包含空格，但能使⽤下划线来分隔其中的单词。

    例如，变量名 greeting_message 可⾏，但变量名 greeting message 会引发错误。

  3. 不要将 Python 关键字和函数名⽤作变量名。

    例如，不要将 print ⽤作变量名，因为它被 Python 留作特殊⽤途。

  4. 变量名应既简短⼜具有描述性。

    例如，name ⽐ n 好，student_name ⽐ s_n 好，name_length ⽐length_of_persons_name 好。

  5. 慎⽤⼩写字⺟ l 和⼤写字⺟ O，因为它们可能被⼈错看成数字 1 和0。

  6. 在 Python 3 中，变量名还可以包含其他 Unicode 字符。例如，中⽂字符也是⽀持的，但是不推荐。

1.6.1同时给多个变量赋值

可在⼀⾏代码中给多个变量赋值，这有助于缩短程序并提⾼其可读性。这种做法最常⽤于将⼀系列数赋给⼀组变量。例如，下⾯演⽰了如何将变量 x、y 和 z 都初始化为零：

x, y, z = 0, 0, 0

在这样做时，需要⽤逗号将变量名分开；对于要赋给变量的值，也需要做同样的处理。Python 将按顺序将每个值赋给对应的变量。只要变量数和值的个数相同，Python 就能正确地将变量和值关联起来。

1.7空行

函数之间或类的方法之间用空行分隔，表示一段新的代码的开始。类和函数入口之间也用一行空行分隔，以突出函数入口的开始。

空行与代码缩进不同，空行并不是 Python 语法的一部分。书写时不插入空行，Python 解释器运行也不会出错。但是空行的作用在于分隔两段不同功能或含义的代码，便于日后代码的维护或重构。

记住：空行也是程序代码的一部分。

1.8 输入输出

执行下面的程序在按回车键后就会等待用户输入：

#!/usr/bin/python3  
input("\n\n按下 enter 键后退出。")

以上代码中 ，\n\n 在结果输出前会输出两个新的空行。一旦用户按下 enter 键时，程序将退出。

执行下面的程序在按回车键后就会输出：

print("hello word!")

1.9 python常量

常量（constant）是在程序的整个⽣命周期内都保持不变的变量。Python 没有内置的常量类型，但 Python 程序员会使⽤全⼤写字⺟来指出应将某个变量视为常量，其值应始终不变：

MAX_CONNECTIONS = 5000

在代码中，要指出应将特定的变量视为常量，可以将其变量名全⼤写（也可以不大写）

2、基础语法

2.1数据类型

Python 中的变量不需要声明。每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建。

在 Python 中，变量就是变量，它没有类型，我们所说的"类型"是变量所指的内存中对象的类型。

等号（=）用来给变量赋值。

等号（=）运算符左边是一个变量名,等号（=）运算符右边是存储在变量中的值。例如：

#!/usr/bin/python3

counter = 100      # 整型变量
miles  = 1000.0    # 浮点型变量
name   = "runoob"   # 字符串

print (counter)
print (miles)
print (name)

执行以上程序会输出如下结果：

100
1000.0
runoob

2.1.1 标准数据类型

Python3 中常见的数据类型有：

  • Number（数字）
  • String（字符串）
  • bool（布尔类型）
  • List（列表）
  • Tuple（元组）
  • Set（集合）
  • Dictionary（字典）

Python3 的六个标准数据类型中：

  • 不可变数据（3 个）：Number（数字）、String（字符串）、Tuple（元组）；
  • 可变数据（3 个）：List（列表）、Dictionary（字典）、Set（集合）。

此外还有一些高级的数据类型，如: 字节数组类型(bytes)。

2.1.2数字(Number)类型

内置的 type() 函数可以用来查询变量所指的对象类型。

python中数字有四种类型：整数、布尔型、浮点数和复数。

  • int (整数), 如 1, 只有一种整数类型 int，表示为长整型，没有 python2 中的 Long。
  • bool (布尔), 如 True。
  • float (浮点数), 如 1.23、3E-2
  • complex (复数) - 复数由实部和虚部组成，形式为 a + bj，其中 a 是实部，b 是虚部，j 表示虚数单位。如 1 + 2j、 1.1 + 2.2i

在python中可直接对整数（integer）执⾏加（+）减（-）乘（*）除（/）运算。

2.1.2.1 赋值运算
  • 1、Python可以同时为多个变量赋值，如a, b = 1, 2。
  • 2、一个变量可以通过赋值指向不同类型的对象。
  • 3、数值的除法包含两个运算符：/ 返回一个浮点数，// 返回一个整数。
  • 4、在混合计算时，Python会把整型转换成为浮点数。
2.1.2.2 浮点数

在编程语言中，小数通常以浮点数的形式存储。浮点数和定点数是相对的：小数在存储过程中如果小数点发生移动，就称为浮点数；如果小数点不动，就称为定点数。书写小数时必须包含一个小数点，否则会被 Python 当作整数处理。

a = float(input("输入一个小数"))
b = float(input("输入一个小数"))
c = a * b
print(type(c))		#打印出来数据类型
print(f'a*b的值为{c:.2f}')


输入一个小数1.33
输入一个小数1.44
<class 'float'>
a*b的值为1.92

进程已结束，退出代码为 0
2.1.2.3 布尔类型

布尔数据类型可以是两个值之一，即True（真）或False（假）。在编程中，我们使用布尔值进行比较，并确定给定程序的控制流程。

布尔值表示与数学逻辑分支相关的真值，这影响计算机科学中的算法。在Python中，值True和False也始终使用大写的T和F，因为它们在Python中是特殊值。
布尔比较运算符:

运算符 含义
== 等于
!= 不等于
< 小于
> 大于
<= 小于或者等于
>= 大于或者等于 
x = 5
y = 8

print("x == y:", x == y)
print("x != y:", x != y)
print("x < y:", x < y)
print("x > y:", x > y)
print("x <= y:", x <= y)
print("x >= y:", x >= y)

x == y: False
x != y: True
x < y: True
x > y: False
x <= y: True
x >= y: False
2.1.2.4 数字类型转换

有时候，我们需要对数据内置的类型进行转换，数据类型的转换，你只需要将数据类型作为函数名即可。

int(x) 将x转换为一个整数。

float(x) 将x转换到一个浮点数。

complex(x) 将x转换到一个复数，实数部分为 x，虚数部分为 0。

complex(x, y) 将 x 和 y 转换到一个复数，实数部分为 x，虚数部分为 y。x 和 y 是数字表达式。

2.1.2.5 列题
你正在帮助一个小型超市管理他们的库存系统。为了简化操作，你需要编写一些Python代码来处理商品的价格和数量。在这个练习中，我们将专注于使用Python的数字类型（如整数int、浮点数float）进行计算。

题目：超市购物折扣计算

题目描述
编写一个 Python 程序，计算顾客购买商品的最终应付金额。具体要求如下：

  1. 输入商品的单价（浮点数）和购买数量（整数）。
  2. 计算总价（单价 × 数量）。
  3. 如果总价 大于或等于 100 元，则享受 9 折 优惠。
  4. 输出最终应付金额，保留两位小数（例如：应付金额：135.00元）。

题解

知识点

  1. 输入类型转换（float() 和 int()）。
  2. 条件判断（if 语句）。
  3. 浮点数运算和格式化输出。

实现思路

  1. 读取输入：将用户输入的单价转换为浮点数，数量转换为整数。
  2. 计算总价：用单价乘以数量得到初始总价。
  3. 判断折扣：如果总价大于等于 100 元，则打 9 折。
  4. 格式化输出：保留两位小数，确保货币金额的规范显示。

代码示例

# 输入单价和数量
price = float(input("请输入商品单价："))
quantity = int(input("请输入购买数量："))

# 计算总价
total = price * quantity

# 判断是否满足折扣条件
if total >= 100:
    total *= 0.9  # 打9折

# 格式化输出结果（保留两位小数）
print(f"应付金额：{total:.2f}元")

示例输入与输出

  1. 输入：

    请输入商品单价：50.0  
请输入购买数量：3

    输出：

    应付金额：135.00元

  2. 输入：

    请输入商品单价：25.5  
请输入购买数量：4

    输出：

    应付金额：91.80元

  3. 输入：

    请输入商品单价：10.0  
请输入购买数量：5

    输出：

    应付金额：50.00元

最终答案

price = float(input("请输入商品单价："))
quantity = int(input("请输入购买数量："))
total = price * quantity
if total >= 100:
    total *= 0.9
print(f"应付金额：{total:.2f}元")

题目：时间转换器

题目描述
编写一个 Python 程序，将用户输入的总秒数转换为“小时、分钟、秒”的表示形式。例如，输入 3661 秒，程序应输出 1小时1分1秒。程序需满足以下要求：

  1. 输入为一个非负整数。
  2. 输出格式为 X小时Y分Z秒，其中 X、Y、Z 分别为计算得到的小时、分钟和秒。
  3. 即使某一部分为 0，也需完整显示（例如输入 3600 秒，输出 1小时0分0秒）。

题解

知识点

  1. 整数除法（//）和取余运算（%）。
  2. 输入输出操作。
  3. 字符串格式化。

实现思路

  1. 计算小时：总秒数整除 3600（1小时=3600秒），得到小时数。
  2. 计算剩余秒数：总秒数对 3600 取余，得到扣除小时部分后的剩余秒数。
  3. 计算分钟：剩余秒数整除 60（1分钟=60秒），得到分钟数。
  4. 计算秒：剩余秒数对 60 取余，得到最终的秒数。
  5. 格式化输出：将小时、分钟、秒按固定格式拼接为字符串。

代码示例

# 读取输入
total_seconds = int(input("请输入总秒数："))

# 计算小时、分钟、秒
hours = total_seconds // 3600
remaining_seconds = total_seconds % 3600
minutes = remaining_seconds // 60
seconds = remaining_seconds % 60

# 格式化输出
print(f"{hours}小时{minutes}分{seconds}秒")

示例输入与输出

  1. 输入：

    3661

    输出：

    1小时1分1秒

  2. 输入：

    7200

    输出：

    2小时0分0秒

  3. 输入：

    65

    输出：

    0小时1分5秒

最终答案

total_seconds = int(input("请输入总秒数："))
hours = total_seconds // 3600
remaining = total_seconds % 3600
minutes = remaining // 60
seconds = remaining % 60
print(f"{hours}小时{minutes}分{seconds}秒")

2.1.3 运算符

Python 语言支持以下类型的运算符:

  • 算术运算符
  • 比较（关系）运算符
  • 赋值运算符
  • 逻辑运算符
  • 位运算符
  • 成员运算符
  • 身份运算符
  • 运算符优先级
2.1.3.1 python 算数运算符

image-20250226161811507

2.1.3.2Python 比较运算符

image-20250226161908480

2.1.3.3Python赋值运算符

image-20250226162000548

2.1.3.4Python位运算符

按位运算符是把数字看作二进制来进行计算的。Python中的按位运算法则如下：

下表中变量 a 为 60，b 为 13二进制格式如下：

a = 0011 1100

b = 0000 1101

-----------------

a&b = 0000 1100

a|b = 0011 1101

a^b = 0011 0001

~a  = 1100 0011

image-20250226162205407

a = 60            # 60 = 0011 1100 
b = 13            # 13 = 0000 1101 
c = 0
 
c = a & b        # 12 = 0000 1100
print ("1 - c 的值为：", c)
 
c = a | b        # 61 = 0011 1101 
print ("2 - c 的值为：", c)
 
c = a ^ b        # 49 = 0011 0001
print ("3 - c 的值为：", c)
 
c = ~a           # -61 = 1100 0011
print ("4 - c 的值为：", c)
 
c = a << 2       # 240 = 1111 0000
print ("5 - c 的值为：", c)
 
c = a >> 2       # 15 = 0000 1111
print ("6 - c 的值为：", c)

1 - c 的值为： 12
2 - c 的值为： 61
3 - c 的值为： 49
4 - c 的值为： -61
5 - c 的值为： 240
6 - c 的值为： 15
2.1.3.5Python逻辑运算符

Python语言支持逻辑运算符，以下假设变量 a 为 10, b为 20:

image-20250226162326478

2.1.3.6Python成员运算符

除了以上的一些运算符之外，Python还支持成员运算符，测试实例中包含了一系列的成员，包括字符串，列表或元组。

image-20250226162423655

a = 10
b = 20
list = [1, 2, 3, 4, 5 ]
 
if ( a in list ):
   print ("1 - 变量 a 在给定的列表中 list 中")
else:
   print ("1 - 变量 a 不在给定的列表中 list 中")
 
if ( b not in list ):
   print ("2 - 变量 b 不在给定的列表中 list 中")
else:
   print ("2 - 变量 b 在给定的列表中 list 中")
 
# 修改变量 a 的值
a = 2
if ( a in list ):
   print ("3 - 变量 a 在给定的列表中 list 中")
else:
   print ("3 - 变量 a 不在给定的列表中 list 中")

1 - 变量 a 不在给定的列表中 list 中
2 - 变量 b 不在给定的列表中 list 中
3 - 变量 a 在给定的列表中 list 中
2.1.3.7Python身份运算符

身份运算符用于比较两个对象的存储单元

image-20250226162522069

2.1.3.8Python运算符优先级

以下表格列出了从最高到最低优先级的所有运算符， 相同单元格内的运算符具有相同优先级。 运算符均指二元运算，除非特别指出。 相同单元格内的运算符从左至右分组（除了幂运算是从右至左分组）：

image-20250226162714493

2.1.3.9 列题

题目1：矩形面积与周长计算器

题目描述
编写一个 Python 程序，输入矩形的长度和宽度（均为正数），计算并输出其面积和周长。要求：

  1. 输入为两个浮点数，分别表示长度和宽度。
  2. 输出格式为 面积：X，周长：Y，其中 X 和 Y 保留两位小数。

**题解 **

知识点

  1. 算术运算符（* 和 +）。
  2. 输入类型转换与浮点数运算。
  3. 字符串格式化保留小数位。

实现思路

  1. 通过 input 读取长度和宽度，并转换为浮点数。
  2. 面积公式：面积 = 长 × 宽。
  3. 周长公式：周长 = 2 × (长 + 宽)。
  4. 使用 f-string 格式化输出结果，保留两位小数。

代码示例

length = float(input("请输入矩形的长度："))
width = float(input("请输入矩形的宽度："))

area = length * width
perimeter = 2 * (length + width)

print(f"面积：{area:.2f}，周长：{perimeter:.2f}")

示例输入与输出

  1. 输入：

    请输入矩形的长度：5.0  
请输入矩形的宽度：3.0

    输出：

    面积：15.00，周长：16.00

  2. 输入：

    请输入矩形的长度：4.5  
请输入矩形的宽度：2.5

    输出：

    面积：11.25，周长：14.00

最终答案

length = float(input("请输入矩形的长度："))
width = float(input("请输入矩形的宽度："))
print(f"面积：{length * width:.2f}，周长：{2 * (length + width):.2f}")

题目2：数字整除性判断器

题目描述
编写一个 Python 程序，判断用户输入的整数是否能 同时被3和5整除。要求：

  1. 输入为一个正整数。
  2. 输出结果为 是 或 否。

**题解 **

知识点

  1. 取余运算符（%）。
  2. 逻辑运算符（and）。
  3. 条件判断（if-else）。

实现思路

  1. 读取输入并转换为整数。
  2. 判断条件：数 % 3 == 0 且 数 % 5 == 0。
  3. 若条件满足输出“是”，否则输出“否”。

代码示例

num = int(input("请输入一个正整数："))

if num % 3 == 0 and num % 5 == 0:
    print("是")
else:
    print("否")

示例输入与输出

输入：

15

输出：

是

最终答案

num = int(input("请输入一个正整数："))
print("是" if num % 3 == 0 and num % 5 == 0 else "否")

2.2 String（字符串）

2.2.1 访问字符串中的值

Python中的字符串用单引号 ' 或双引号 " 括起来，同时使用反斜杠 ** 转义特殊字符。

Python 不支持单字符类型，单字符在 Python 中也是作为一个字符串使用。

字符串的截取的语法格式如下：

变量[头下标:尾下标]

索引值以 0 为开始值，-1 为从末尾的开始位置。

image-20250225194601235

加号 + 是字符串的连接符， 星号 ***** 表示复制当前字符串，与之结合的数字为复制的次数。

#!/usr/bin/python3

str = 'Runoob'  # 定义一个字符串变量
print(str)           # 打印整个字符串
print(str[0:-1])     # 打印字符串第一个到倒数第二个字符（不包含倒数第一个字符）
print(str[0])        # 打印字符串的第一个字符
print(str[2:5])      # 打印字符串第三到第五个字符（包含第五个字符）
print(str[2:])       # 打印字符串从第三个字符开始到末尾
print(str * 2)       # 打印字符串两次
print(str + "TEST")  # 打印字符串和"TEST"拼接在一起

运行结果

Runoob
Runoo
R
noo
noob
RunoobRunoob
RunoobTEST

Python 使用反斜杠 \转义特殊字符，如果你不想让反斜杠发生转义，可以在字符串前面添加一个 r，表示原始字符串：

  • 1、反斜杠可以用来转义，使用r可以让反斜杠不发生转义。
  • 2、字符串可以用+运算符连接在一起，用*运算符重复。
  • 3、Python中的字符串有两种索引方式，从左往右以0开始，从右往左以-1开始。
  • 4、Python中的字符串不能改变。
>>> print('Ru\noob')
Ru
oob
>>> print(r'Ru\noob')
Ru\noob
>>>

2.2.1字符串操作

title()函数：首字母输出大写

upper()函数：输出全部大写

lower()函数：输出全部小写

name = "Ada Lovelace"
name_1 = "ada aovelace"
print(name.upper())
print(name.lower())
print(name_1.title())

这些代码的输出如下：

ADA LOVELACE
ada lovelac
Ada Lovelacee

2.2.2 f 字符串

f字符串是一种格式化字符串的方法，它允许你在字符串中直接嵌入表达式。这种方法从Python 3.6版本开始引入，被称为格式化字符串字面量或f-string。使用f-string时，你可以将变量或表达式放在花括号{}中，并在字符串前加上f或F来创建一个f-string，在f字符串的使用中当有小数点时在{}中需要写清楚小数点的位数：f‘<内容>{<变量>:.<小数位数>f}<内容>’

price = 49.99
a= "开局一根肠"
info = (
f'商品名称: {a}\n'
f'价格: {price:.3f}元'
)
print(info)

商品名称: 开局一根肠
价格: 49.990元

2.2.3 字符串运算

image-20250227224047005

#!/usr/bin/python3
 
a = "Hello"
b = "Python"
 
print("a + b 输出结果：", a + b)
print("a * 2 输出结果：", a * 2)
print("a[1] 输出结果：", a[1])
print("a[1:4] 输出结果：", a[1:4])
 
if( "H" in a) :
    print("H 在变量 a 中")
else :
    print("H 不在变量 a 中")
 
if( "M" not in a) :
    print("M 不在变量 a 中")
else :
    print("M 在变量 a 中")
 
print (r'\n')
print (R'\n')

a + b 输出结果： HelloPython
a * 2 输出结果： HelloHello
a[1] 输出结果： e
a[1:4] 输出结果： ell
H 在变量 a 中
M 不在变量 a 中
\n
\n

进程已结束，退出代码为 0

2.3.4 如何在使⽤字符串时避免语法错误

语法错误是⼀种你会不时遇到的错误。当程序包含⾮法的 Python 代码时，就会导致语法错误。

  1. 正确使用引号：确保你的字符串用一对匹配的单引号('')或双引号("")括起来。不要混用不同类型的引号作为开始和结束符号。例如，'Hello, world!' 或 "Hello, world!" 都是正确的，但 'Hello, world!" 会产生语法错误。

  2. 转义字符：如果你需要在字符串中包含引号（即与包围字符串的引号类型相同），可以使用反斜杠()进行转义。例如，'He said, "Hello, world!"' 或 "It\'s a wonderful day."。如果你想包含一个实际的反斜杠，则需要使用两个反斜杠(\\)。

  3. 多行字符串：如果需要编写多行文本，可以使用三重引号(''' 或 """)来定义多行字符串。例如：

    text = '''这是一个多行
字符串示例'''

    或者

    text = """这也是一个
多行字符串示例"""

  4. 拼接字符串：当需要将多个字符串组合在一起时，可以使用加号(+)来拼接它们。例如："Hello, " + "world!" 结果为 "Hello, world!"。

  5. 格式化字符串：使用格式化字符串（如Python中的f-string、str.format()方法）可以更方便地插入变量值到字符串中。例如，在Python中使用f-string:

    name = "Alice"
greeting = f"Hello, {name}"

    这样可以减少因为手动拼接字符串而产生的错误。

  6. 检查字符串边界：确保对字符串的操作不会超出其边界。例如，访问或修改字符串中的某个字符时，确认索引值在有效范围内。

2.3.5 列题

题目1：字符串反转与长度计算

题目描述
编写一个 Python 程序，输入一个字符串，输出该字符串的反转形式及其长度。要求：

  1. 输入为一个字符串。
  2. 输出格式为 反转字符串：X，长度：Y，其中 X 是反转后的字符串，Y 是字符串的长度。

**题解 **

知识点

  1. 字符串切片（[::-1]）。
  2. 字符串长度计算（len()）。
  3. 字符串格式化输出。

实现思路

  1. 使用 input 读取字符串。
  2. 通过切片 [::-1] 反转字符串。
  3. 使用 len() 计算字符串长度。
  4. 格式化输出结果。

代码示例

s = input("请输入一个字符串：")
reversed_s = s[::-1]
length = len(s)

print(f"反转字符串：{reversed_s}，长度：{length}")

示例输入与输出

  1. 输入：

    hello

    输出：

    反转字符串：olleh，长度：5

  2. 输入：

    Python

    输出：

    反转字符串：nohtyP，长度：6

最终答案

s = input("请输入一个字符串：")
print(f"反转字符串：{s[::-1]}，长度：{len(s)}")

题目2：单词首字母大写

题目描述
编写一个 Python 程序，输入一个由多个单词组成的字符串（单词之间用空格分隔），将每个单词的首字母大写，并输出结果。要求：

  1. 输入为一个字符串。
  2. 输出格式为 转换后的字符串：X，其中 X 是每个单词首字母大写后的字符串。

**题解 **

知识点

  1. 字符串方法（split() 和 join()）。
  2. 字符串方法（capitalize() 或 title()）。
  3. 字符串格式化输出。

实现思路

  1. 使用 input 读取字符串。
  2. 使用 split() 将字符串按空格分割为单词列表。
  3. 使用 capitalize() 或 title() 将每个单词的首字母大写。
  4. 使用 join() 将单词列表重新组合为字符串。
  5. 格式化输出结果。

代码示例

s = input("请输入一个字符串：")
words = s.split()
capitalized_words = [word.capitalize() for word in words]
result = " ".join(capitalized_words)

print(f"转换后的字符串：{result}")

示例输入与输出

  1. 输入：

    hello world

    输出：

    转换后的字符串：Hello World

  2. 输入：

    python programming is fun

    输出：

    转换后的字符串：Python Programming Is Fun

最终答案

s = input("请输入一个字符串：")
print(f"转换后的字符串：{s.title()}")

注意：

  • title() 方法可以直接将每个单词的首字母大写，但会将其余字母转为小写。
  • 如果需要保留单词中其他字母的大小写，可以使用 capitalize() 方法逐个处理单词。

2.3列表

  • List（列表） 是 Python 中使用最频繁的数据类型。由⼀系列按特定顺序排列的元素组成。你不仅可以创建包含字⺟表中所有字⺟、数字 0〜9 或所有家庭成员姓名的列表，还可以将任何东⻄加⼊列表，其中的元素之间可以没有任何关系。

  • 列表可以完成大多数集合类的数据结构实现。列表中元素的类型可以不相同，它支持数字，字符串甚至可以包含列表（所谓嵌套）。

  • 列表是写在方括号 [] 之间、用逗号分隔开的元素列表。

  • 和字符串一样，列表同样可以被索引和截取，列表被截取后返回一个包含所需元素的新列表。

  • 列表截取的语法格式如下：

变量[头下标:尾下标]

注意：

  1. 列表写在方括号之间，元素用逗号隔开。
  2. 和字符串一样，列表可以被索引和切片。
  3. 列表可以使用 + 操作符进行拼接。
  4. 列表中的元素是可以改变的。

2.3.1 访问列表元素

在 Python 中，第⼀个列表元素的索引为 0，⽽不是 1。⼤多数编程语⾔是如此规定的，这与列表操作的底层实现有关。如果结果出乎意料，问问⾃⼰是否犯了简单⽽常⻅的差⼀错误。第⼆个列表元素的索引为 1。根据这种简单的计数⽅式，要访问列表的任何元素，都可将其位置减 1，并将结果作为索引。

列表是有序集合，因此要访问列表的任何元素，只需将该元素的位置（索引）告诉 Python 即可。要访问列表元素，可指出列表的名称，再指出元素的索引，并将后者放在⽅括号内。

索引从 0 ⽽不是 1 开始，-1 为从末尾的开始位置。

加号 + 是列表连接运算符，星号 * 是重复操作。

#!/usr/bin/python3

list = [ 'abcd', 786 , 2.23, 'runoob', 70.2 ]  # 定义一个列表
tinylist = [123, 'runoob']

print (list)            # 打印整个列表
print (list[0])         # 打印列表的第一个元素
print (list[1:3])       # 打印列表第二到第四个元素（不包含第四个元素）
print (list[2:])        # 打印列表从第三个元素开始到末尾
print (tinylist * 2)    # 打印tinylist列表两次
print (list + tinylist)  # 打印两个列表拼接在一起的结果

['abcd', 786, 2.23, 'runoob', 70.2]
abcd
[786, 2.23]
[2.23, 'runoob', 70.2]
[123, 'runoob', 123, 'runoob']
['abcd', 786, 2.23, 'runoob', 70.2, 123, 'runoob']

ython 列表截取可以接收第三个参数，参数作用是截取的步长，以下实例在索引 1 到索引 4 的位置并设置为步长为 2（间隔一个位置）来截取字符串：

image-20250226160701727

list_1 = ['abcd', 786, 2.23, 'runoob', 70.2]
list_2 = ['a', 'b', 'c', 'd']

print(list_1[1:4:2])
print(list_1[1:4:2] + list_2)
print(list_2[1:4:2])
print(list_1 + list_2[1:4:2])

[786, 'runoob']
[786, 'runoob', 'a', 'b', 'c', 'd']
['b', 'd']
['abcd', 786, 2.23, 'runoob', 70.2, 'b', 'd']

2.3.2 修改、添加和删除元素

2.3.2.1 更新列表，添加列表元素

可以直接对列表的数据项进行修改或更新，也可以使用 append() 方法来添加列表元素，使用 append() 方法来添加列表项（将元素追加（append）到列表末尾），

#!/usr/bin/python3

list = ['Google', 'Runoob', 1997, 2000]
print ("第三个元素为 : ", list[2])
list[2] = 2001
print ("更新后的第三个元素为 : ", list[2])

list_1 = ['Google', 'Runoob', 'Taobao']
list_1.append('Baidu')
print ("更新后的列表 : ", list_1)

第三个元素为 :  1997
更新后的第三个元素为 :  2001
更新后的列表 :  ['Google', 'Runoob', 'Taobao', 'Baidu']

使⽤ insert() ⽅法可在列表的任意位置添加新元素。为此，需要指定新元素的索引和值：

m = ['honda', 'yamaha', 'suzuki']
m.insert(0, 'ducati')
print(m)

在这个⽰例中，值 'ducati' 被插⼊到了列表开头。insert() ⽅法,在索引 0 处添加空间，并将值 'ducati' 存储到这个地⽅：

['ducati', 'honda', 'yamaha', 'suzuki']
2.3.2.2 从列表中删除元素

  • 如果知道要删除的元素在列表中的位置，可使⽤ del 语句：

    m = ['honda', 'yamaha', 'suzuki']
print(m)
del m[0]
print(m)

    这⾥使⽤ del 语句删除了列表 m 中的第⼀个元素'honda'：

    ['honda', 'yamaha', 'suzuki']
['yamaha', 'suzuki']

    使⽤ del 可删除任意位置的列表元素，只需要知道其位置即可。例如，下⾯演⽰了如何删除列表 m中的第⼆个元素'yamaha'：

    m = ['honda', 'yamaha', 'suzuki']
print(m)
del m[1]
print(m)

    下⾯的输出表明，已经将第⼆款摩托⻋从列表中删除了：

    ['honda', 'yamaha', 'suzuki']
['honda', 'suzuki']

  • 使⽤ pop() ⽅法删除元素

    pop() 方法是 列表(List)对象的一个内置方法，用于移除并返回列表中的元素。根据是否传入索引参数，pop() 的行为会有所不同：

    基本用法

    1. 不带参数调用：如果不向 pop() 方法传递任何参数，默认会移除并返回列表的最后一个元素。这是最常用的场景。

      # 初始化一个列表m，包含三个字符串元素：'honda', 'yamaha', 'suzuki'
m = ['honda', 'yamaha', 'suzuki']

# 打印列表m的当前状态，此时列表包含所有三个初始元素
print(m)

# 调用pop()方法，不指定参数，默认移除并返回列表m的最后一个元素
# 这里将移除'suzuki'，因为它在列表的末尾
popped_m = m.pop()

# 打印执行pop()方法之后的列表m
# 注意，现在列表只包含前两个元素：'honda', 'yamaha'
print(m)

# 打印被移除的元素，即最后一次调用pop()方法时从列表中移除的元素
# 在这个例子中，它将是'suzuki'
print(popped_m)

      ['honda', 'yamaha', 'suzuki']
['honda', 'yamaha']
suzuki

    2. 带索引参数调用：可以向 pop() 方法传递一个整数参数，指定要移除和返回的元素在列表中的位置（索引）。列表的索引是从0开始的，因此第一个元素的索引是0，第二个元素的索引是1，以此类推。如果指定了一个负数索引，它将从列表的末尾开始计数（例如，-1表示最后一个元素）。

      # 初始化一个列表m，包含三个字符串元素：'honda', 'yamaha', 'suzuki'
m = ['honda', 'yamaha', 'suzuki']

# 使用pop(0)方法移除并返回列表m中的第一个元素（索引为0的元素）
# 这里将移除'honda'，因为它是列表中的第一个元素
first_item = m.pop(0)

# 打印被移除的第一个元素，即从列表中移除的元素，在这个例子中是'honda'
print(first_item)  # 输出: honda

# 打印执行pop(0)方法之后的列表m
# 注意，现在列表m只包含剩下的两个元素：'yamaha', 'suzuki'
print(m)  # 输出: ['yamaha', 'suzuki']

      honda
['yamaha', 'suzuki']

    注意事项

    • 如果尝试对空列表调用 pop() 方法，或者提供的索引超出了列表的范围（无论是正数还是负数索引），Python 将抛出 IndexError 异常。

      m = []
item = m.pop()  # 这里将会抛出 IndexError: pop from empty list

    • 使用 pop() 方法可以从列表中按位置删除元素，并且该方法还会返回被删除的元素，这使得它非常适合用来实现栈(stack)数据结构，其中你可以使用 append() 方法添加元素到列表末尾，并使用 pop() 方法从列表末尾移除元素。

  • 删除列表中任意位置的元素和根据值删除元素

    使用 pop() 删除任意位置的元素

    使用 pop() 方法可以从列表中删除任意位置的元素，并返回这个元素。只需在括号内指定元素的索引即可。

    #示例：删除并打印列表中的第一个摩托车

m = ['honda', 'yamaha', 'suzuki']
first_owned = m.pop(0)
print(f"The first motorcycle I owned was a {first_owned.title()}.")

    注意：使用 pop() 后，该元素将从列表中移除。

    提示：如果要删除元素且不再使用它，用 del 语句；如果需要在删除后继续使用该元素，则使用 pop() 方法。

  • 根据值删除元素

    当你知道要删除的元素值但不知道其索引时，可以使用 remove() 方法。

    # 定义一个包含四个元素的列表m
m = ['honda', 'yamaha', 'suzuki', 'ducati']
print("原始列表:", m)

# 使用remove()方法删除列表中的'ducati'
m.remove('ducati')  # 删除'ducati'
print("移除'ducati'后的列表:", m)

# 如果需要引用被删除的元素，可以先将其赋值给一个变量
too_expensive = 'ducati'

# 假设我们再次尝试从列表中移除'ducati'（注意：此行在当前上下文中不是必需的，因为'ducati'已经被移除了）
# 这里只是为了演示如果'ducati'依然存在于列表中时的操作
if too_expensive in m:
    m.remove(too_expensive)
    print(f"再次尝试移除'{too_expensive}'后的列表:", m)
else:
    print(f"\nA {too_expensive.title()} 已经不在列表中了，所以对我来说太贵了。")

    原始列表: ['honda', 'yamaha', 'suzuki', 'ducati']
移除'ducati'后的列表: ['honda', 'yamaha', 'suzuki']

A Ducati 已经不在列表中了，所以对我来说太贵了。

  • 注意：remove() 只删除首次出现的指定值。若同一值出现多次，需结合循环使用以确保全部删除。

2.3.3 列表管理

2.3.3.1 使用 sort() 方法对列表进行永久排序

sort() 方法可以对列表进行永久性排序，这意味着排序后列表的顺序将被改变。

# 定义一个列表
cars = ['bmw', 'audi', 'toyota', 'subaru']
# 使用sort()方法按字母顺序对列表进行永久排序
cars.sort()
print("永久排序后的列表:", cars)

永久排序后的列表: ['audi', 'bmw', 'subaru', 'toyota']

注意：sort() 方法默认按升序（从小到大）排序。如果需要降序排序，可以传递参数 reverse=True。

cars.sort(reverse=True)
print("永久降序排序后的列表:", cars)

永久降序排序后的列表: ['toyota', 'subaru', 'bmw', 'audi']
2.3.3.2 使用 sorted() 函数对列表进行临时排序

如果你想保持列表原来的顺序，但又想以特定顺序显示出来，可以使用 sorted() 函数。这不会影响列表的实际顺序。

cars = ['bmw', 'audi', 'toyota', 'subaru']
print("原始列表:", cars)
print("临时排序后的列表:", sorted(cars))
print("再次打印原始列表验证顺序未变:", cars)

原始列表: ['bmw', 'audi', 'toyota', 'subaru']
临时排序后的列表: ['audi', 'bmw', 'subaru', 'toyota']
再次打印原始列表验证顺序未变: ['bmw', 'audi', 'toyota', 'subaru']

同样地，sorted() 函数也支持通过传递 reverse=True 实现降序排序。

2.3.3.3反向打印列表

使用 reverse() 方法可以反转列表中的元素顺序。这个操作也是永久性的，但你可以随时再次调用 reverse() 来恢复原顺序。

cars = ['bmw', 'audi', 'toyota', 'subaru']
cars.reverse()
print("反向打印列表:", cars)

反向打印列表: ['subaru', 'toyota', 'audi', 'bmw']
2.3.3.4 确定列表的长度

使用 len() 函数可以快速获取列表中元素的数量。

cars = ['bmw', 'audi', 'toyota', 'subaru']
length = len(cars)
print("列表的长度是:", length)

列表的长度是: 4

这些方法和函数为处理列表提供了极大的灵活性，无论是对列表进行排序、反转还是查询其长度，都非常直观易懂。

2.3.4嵌套列表及其列表截取拼接

列表可以包含其他列表作为其元素，这种结构称为嵌套列表。此外，我们还可以通过列表的切片（截取）和拼接操作来处理这些列表。

2.3.4.1嵌套列表

下面是一个简单的例子，展示了如何创建一个嵌套列表，并访问其中的元素：

# 创建一个嵌套列表
nested_list = [['apple', 'banana'], ['carrot', 'potato'], ['milk', 'cheese']]

# 访问嵌套列表中的元素
print("第一个子列表:", nested_list[0])  # 输出: ['apple', 'banana']
print("第二个子列表的第一个元素:", nested_list[1][0])  # 输出: carrot

第一个子列表: ['apple', 'banana']
第二个子列表的第一个元素: carrot
2.3.4.2列表截取

列表的切片操作允许我们获取列表的一部分。下面是如何对列表进行切片操作的例子：

# 定义一个列表
fruits = ['apple', 'banana', 'cherry', 'date', 'elderberry']

# 获取从索引1到3的元素（不包括索引3）
slice_of_fruits = fruits[1:3]
print("切片后的列表:", slice_of_fruits)  # 输出: ['banana', 'cherry']

切片后的列表: ['banana', 'cherry']
2.3.4.3列表拼接

列表可以通过加法运算符 + 来拼接在一起，形成一个新的列表：

# 定义两个列表
list_one = ['a', 'b', 'c']
list_two = ['d', 'e', 'f']

# 拼接列表
concatenated_list = list_one + list_two
print("拼接后的列表:", concatenated_list)  # 输出: ['a', 'b', 'c', 'd', 'e', 'f']

拼接后的列表: ['a', 'b', 'c', 'd', 'e', 'f']
2.3.4.4综合示例：嵌套列表的截取与拼接

假设我们有一个更复杂的嵌套列表，并希望对其进行一些操作：

# 创建一个更复杂的嵌套列表
complex_nested_list = [['red', 'blue'], ['green', 'yellow'], ['black', 'white']]

# 截取并打印第二个子列表
second_sublist = complex_nested_list[1]
print("第二个子列表:", second_sublist)  # 输出: ['green', 'yellow']

# 对第二个子列表进行切片操作
slice_second_sublist = second_sublist[0:1]  # 取出'green'
print("第二个子列表的切片:", slice_second_sublist)  # 输出: ['green']

# 拼接两个子列表
concatenated_sublists = complex_nested_list[0] + complex_nested_list[2]
print("拼接后的子列表:", concatenated_sublists)  # 输出: ['red', 'blue', 'black', 'white']

第二个子列表: ['green', 'yellow']
第二个子列表的切片: ['green']
拼接后的子列表: ['red', 'blue', 'black', 'white']

2.3.5列表函数&方法

image-20250302210118029

image-20250302210149752

image-20250302210341232

2.3.6 列题

2.3.6.1题目1：创建和访问列表

描述: 创建一个名为 colors 的列表，包含以下颜色名称："red", "blue", "green", "yellow"。然后打印出该列表的第二个元素。

题解:

colors = ["red", "blue", "green", "yellow"]
print(colors[1])  # 注意索引从0开始，所以[1]是第二个元素

答案:

blue
2.3.6.2题目2：列表切片与拼接

描述: 给定两个列表 list1 = ['a', 'b', 'c'] 和 list2 = ['d', 'e', 'f']。请完成以下任务：

  1. 从 list1 中截取从第一个元素到第三个元素（不包括第三个）。
  2. 将 list1 和 list2 拼接成一个新的列表，并打印出来。

题解:

list1 = ['a', 'b', 'c']
list2 = ['d', 'e', 'f']

# 截取部分
slice_of_list1 = list1[0:2]  # 取出'a', 'b'
print("截取后的列表:", slice_of_list1)

# 拼接列表
concatenated_list = list1 + list2
print("拼接后的列表:", concatenated_list)

答案:

截取后的列表: ['a', 'b']
拼接后的列表: ['a', 'b', 'c', 'd', 'e', 'f']
2.3.6.3题目3：嵌套列表与访问特定元素

描述: 创建一个嵌套列表 nested_list = [['apple', 'banana'], ['carrot', 'potato'], ['milk', 'cheese']]。请执行以下操作：

  1. 打印整个嵌套列表。
  2. 访问并打印第二个子列表中的第一个元素。

题解:

nested_list = [['apple', 'banana'], ['carrot', 'potato'], ['milk', 'cheese']]

# 打印整个嵌套列表
print("嵌套列表:", nested_list)

# 访问并打印第二个子列表的第一个元素
second_sublist_first_element = nested_list[1][0]
print("第二个子列表的第一个元素:", second_sublist_first_element)

答案:

嵌套列表: [['apple', 'banana'], ['carrot', 'potato'], ['milk', 'cheese']]
第二个子列表的第一个元素: carrot

2.4 元组

元组（Tuple）它与列表非常相似，但有一个重要的区别：元组是不可变的（immutable），这意味着一旦创建后，就不能修改其内容。以下是一些关于元组的基础知识：

2.4.1创建元组

元组可以用圆括号 () 来创建，元素之间用逗号分隔。

# 创建一个简单的元组
simple_tuple = (1, 2, 3)

# 元组也可以不使用括号来定义
another_tuple = 4, 5, 6

# 包含不同类型元素的元组
mixed_tuple = ('apple', 10, True)

注意：即使只有一个元素，也需要在元素后面加上逗号，以表明这是一个元组而不是单个值。

single_element_tuple = ('only',)

2.4.2访问元组中的元素

可以通过索引来访问元组中的元素，索引从0开始。

my_tuple = ('a', 'b', 'c', 'd')
print(my_tuple[0])  # 输出: a
print(my_tuple[2])  # 输出: c

你也可以使用负数索引来从末尾访问元素。

print(my_tuple[-1])  # 输出: d

2.4.3元组切片

可以像列表一样对元组进行切片操作，获取子集。

my_tuple = ('a', 'b', 'c', 'd', 'e')
sub_tuple = my_tuple[1:4]  # 结果: ('b', 'c', 'd')
print(sub_tuple)

2.4.4遍历元组

可以使用for循环遍历元组中的所有元素。

my_tuple = ('apple', 'banana', 'cherry')
for item in my_tuple:
    print(item)

apple
banana
cherry

2.4.5不可变性

由于元组是不可变的，不能对其进行修改、添加或删除操作。

my_tuple = (1, 2, 3)
# 下面的操作会抛出TypeError
# my_tuple[0] = 4  # 错误
# del my_tuple[1]  # 错误

但是，如果你的元组包含的是可变对象（如列表），这些可变对象本身是可以修改的。

tuple_with_list = ([1, 2], [3, 4])
tuple_with_list[0].append(3)  # 这是允许的
print(tuple_with_list)  # 输出: ([1, 2, 3], [3, 4])

([1, 2, 3], [3, 4])

2.4.6元组方法

元组支持的方法较少，因为它们是不可变的。常见的方法包括：

  • count(x)：返回元组中出现x的次数。
  • index(x)：返回元组中第一次出现x的索引位置。
my_tuple = (1, 2, 3, 2, 4)
print(my_tuple.count(2))  # 输出: 2
print(my_tuple.index(3))  # 输出: 2

2
2

2.4.7元组的应用场景

由于其不可变性，元组适用于那些不需要更改的数据集合。例如，用于存储固定的信息，如日期、坐标等，或者作为字典的键（因为字典的键必须是不可变类型）。

2.5 字典

2.5.1字典（Dictionary）详细基础知识

字典是Python中的一种内置数据结构，它允许你存储键值对（key-value pairs）。每个键都是唯一的，并且通过键可以快速访问对应的值。字典是可变的，支持动态添加、修改和删除元素。

2.5.2.创建字典

字典可以通过花括号 {} 来创建，键和值之间用冒号 : 分隔，键值对之间用逗号 , 分隔。也可以使用 dict() 构造函数来创建字典。

# 使用花括号创建字典
person = {'name': 'Alice', 'age': 25, 'city': 'New York'}

# 使用dict()构造函数创建字典
person = dict(name='Alice', age=25, city='New York')

# 创建空字典
empty_dict = {}

2.5.3.访问字典中的值

通过键可以直接访问字典中的值。如果试图访问不存在的键，会抛出 KeyError 异常。为了避免这种情况，可以使用 get() 方法，它会在键不存在时返回 None 或者指定的默认值。

print(person['name'])  # 输出: Alice

# 使用get()方法避免KeyError
print(person.get('country'))  # 输出: None
print(person.get('country', 'Unknown'))  # 输出: Unknown

2.5.4修改字典

字典是可变的，这意味着你可以随时向字典中添加新的键值对，或者修改已有的键对应的值。

# 添加新的键值对
person['email'] = 'alice@example.com'
print(person)  # 输出: {'name': 'Alice', 'age': 25, 'city': 'New York', 'email': 'alice@example.com'}

# 修改已有的键对应的值
person['age'] = 26
print(person)  # 输出: {'name': 'Alice', 'age': 26, 'city': 'New York', 'email': 'alice@example.com'}

2.5.6.删除键值对

可以使用 del 关键字删除字典中的键值对，或者使用 pop() 方法删除并返回该键对应的值。

# 使用del关键字删除键值对
del person['city']
print(person)  # 输出: {'name': 'Alice', 'age': 26, 'email': 'alice@example.com'}

# 使用pop()方法删除并返回键对应的值
age = person.pop('age')
print(person)  # 输出: {'name': 'Alice', 'email': 'alice@example.com'}
print(age)  # 输出: 26

2.5.7遍历字典

可以遍历字典的所有键、所有值或所有键值对。

# 遍历所有键
for key in person:
    print(key)

# 遍历所有值
for value in person.values():
    print(value)

# 遍历所有键值对
for key, value in person.items():
    print(f"{key}: {value}")

2.5.8字典方法

字典提供了许多有用的方法：

  • keys()：返回字典中所有的键。

    for key in person.keys():
    print(key)

  • values()：返回字典中所有的值。

    for value in person.values():
    print(value)

  • items()：返回字典中所有的键值对（作为元组的形式）。

    for key, value in person.items():
    print(f"{key}: {value}")

  • update()：将另一个字典的键值对更新到当前字典中。

    new_info = {'age': 27, 'gender': 'female'}
person.update(new_info)
print(person)  # 输出: {'name': 'Alice', 'email': 'alice@example.com', 'age': 27, 'gender': 'female'}

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

    person.clear()
print(person)  # 输出: {}

  • copy()：创建字典的一个浅拷贝。

    person_copy = person.copy()

  • setdefault()：获取指定键的值；如果键不存在，则插入指定的键值对并返回其值。

    age = person.setdefault('age', 30)
print(age)  # 如果'age'键存在则返回其值，否则设置为30并返回30

这些详细的说明涵盖了如何创建、访问、修改、删除和遍历字典，以及一些常用的方法。字典因其高效性和灵活性，在处理复杂数据结构时非常有用。掌握字典的基本操作对于编写高效的Python代码至关重要。

部分数据来源于菜鸟教程、python从入门到实践

posted @ 2025-03-08 15:23  有一大盒  阅读(147)  评论(0)    收藏  举报