Python组合数据类型

Visual code AlCv

已于 2023-09-30 16:32:08 修改

阅读量763

点赞数 2

分类专栏： python学习文章标签： python 开发语言

于 2023-09-05 20:41:21 首次发布

本文链接：https://blog.csdn.net/m0_65995252/article/details/132668204

版权

python学习专栏收录该内容

23 篇文章 1 订阅

订阅专栏

1.基本数据类型

数字类型（Number）：包括整型（int）、浮点型（float）、复数型（complex）等

字符串类型（String）：由单引号或双引号包含的文本数据

布尔类型（Boolean）：包含正确（True）和错误（false）两种

2.组合数据类型

在python中组合数据类型是指将多个数据组合在一起形成的数据结构。包括序列类型、集合类型、映射类型。

其中，字符串类型也属于序列类型，因为字符串是由单个字符组成的有序序列，每个字符都可以通过索引访问。

2.1 序列类型

2.1.1列表(list)

2.1.1.1列表定义&创建

定义：

列表是有序的可变序列，可以包含任意类型的元素。
列表的元素可以通过索引访问，索引从0开始。
列表使用方括号 [] 定义，元素之间用逗号分隔。
列表的常用操作包括添加、删除、修改和排序等。

创建：

#空列表
a = []

#手动创建
a = [元素1，元素2，元素3 ......]

#为外部输入的一行数据创建列表
a = list(map(int, input().split())

列表中的元素可以为基本数据类型，也可以为组合数据类型且可以重复。

2.1.1.2列表操作

常用方法解释

append(): 在列表末尾添加一个元素。
insert(): 在指定位置插入一个元素。
extend(): 将另一个列表的元素添加到当前列表末尾
remove(): 删除列表中第一个匹配的元素。
pop(): 删除指定索引位置的元素，并返回该元素的值。
count(): 返回列表中指定元素的出现次数。
sort(): 对列表进行排序。
reverse(): 将列表中的元素反转。

切片

new_list = list[start:end:step]

start：切片的起始位置（包含），默认为0。
end：切片的结束位置（不包含），默认为列表的长度。
step：切片的步长，表示每隔多少个元素取一个值，默认为1。

加法和乘法

加法操作使用加号（+）完成，表示把加号两端的列表变量连接形成一个新列表；
乘法操作使用星号（*）完成，表示对当前列表对象进行复制并连接，并形成一个新列表。

修改和删除

通过索引值对相应元素进行修改或删除。
删除整个列表或列表中的部分元素，使用del命令。删除整个列表后，不可再次引用。

建立一个水果列表并演示作为示例：

删

fruits = ["apple", "banana", "cherry", "date"]

# 使用索引删除元素
del fruits[2]
print(fruits)  # 输出: ['apple', 'banana', 'date']

# 使用remove()方法删除指定元素
fruits.remove("banana")
print(fruits)  # 输出: ['apple', 'date']

# 使用pop()方法删除指定索引位置的元素，并返回该元素的值
popped_fruit = fruits.pop(0)
print(popped_fruit)  # 输出: 'apple'
print(fruits)  # 输出: ['date']

# 清空列表
fruits.clear()
print(fruits)  # 输出: []

改

fruits = ["apple", "banana", "cherry", "date"]

# 在列表末尾添加元素
fruits.append("elderberry")
print(fruits)  # 输出: ['apple', 'banana', 'cherry', 'date', 'elderberry']

# 在指定位置插入元素
fruits.insert(2, "fig")
print(fruits)  # 输出: ['apple', 'banana', 'fig', 'cherry', 'date', 'elderberry']

# 扩展列表，将另一个列表的元素添加到当前列表末尾
additional_fruits = ["grape", "kiwi"]
fruits.extend(additional_fruits)
print(fruits)  # 输出: ['apple', 'banana', 'fig', 'cherry', 'date', 'elderberry', 'grape', 'kiwi']

追加插入和拓展

append：在当前列表对象尾部追加元素；
insert：在当前列表的指定索引位置插入元素；
extend：对当前列表元素进行批量增加。

2.1.1.3多维列表

列表的元素为可迭代对象，自然可以将列表作为自己的元素

创建多维列表

演示生成二维列表[[1, 2, 3 ......,11][1, 2, 3 ......,11]]

# 方法1
a = [1, 2, 3 ......,11]
b = [1, 2, 3 ......,11]
c = [a,b]

# 方法2
a =[[1, 2, 3 ......,11], [1, 2, 3 ......,11]]

#方法3
[a for a in range(1, 11)]

2.1.2元组(tuple)

元组与列表最大的不同在于元组内部的元素是不可以修改的，其他的性质基本一致。

2.1.2.1创建元组

# 创建空元组
a = ()

# 手动创建元组
a =(元素1, 元素2, 元素3,元素4, ....)

# 将输入的一行数建立为元组
a = tuple(map(函数, input().split())

注：当元组中只包含一个元素时，需要在元素后面添加逗号，否则括号会被当作运算符使用

2.1.2.2基本操作

1. 访问
使用下标索引来访问相应的元素值。也可采用正向索引和反向索引两种方式，并支持切片操作。

my_tuple = (1, 2, 3)
print(my_tuple[0])  # 访问第一个元素

2. 修改
元组中的元素若是像列表这样元素可以修改的，则元组中元素的元素可以修改。

def_tuple = ("kele", "tea")
def_tuple[0] = "xuebi"

# 试图修改元组中的元素会报错
Traceback (most recent call last):
  File "<input>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment

# 元组第二个元素是一个列表，可直接通过索引修改
def_tuple = ("kele", ["tea", "kele"])
def_tuple[1][1] = "xuebi"
def_tuple
('kele', ['tea', 'xuebi'])

元组是不可变的，无法直接修改元素。如果需要修改元组，可以先将元组转换为列表，修改列表中的元素，然后再将列表转换回元组。

my_tuple = (1, 2, 3)
my_list = list(my_tuple)  # 将元组转换为列表
my_list[0] = 4  # 修改列表中的元素
my_tuple = tuple(my_list)  # 将列表转换回元组

3. 删除
元素值不允许删除的，但可使用del语句删除整个元组。
需要注意的是，删除后的元组对象不可再次引用。

my_tuple = (1, 2, 3)
del my_tuple  # 删除整个元组

4. 统计
通过内置的count方法统计某个元素出现的次数。

my_tuple = (1, 2, 2, 3, 4, 2)
count = my_tuple.count(2)  # 统计元素2的出现次数

5. 查找
通过内置的index方法查找某个元素首次出现的索引位置。

my_tuple = (1, 2, 3, 4, 5)
index = my_tuple.index(3)  # 查找元素3的索引位置

6.切片操作：

my_tuple = (1, 2, 3, 4, 5)
print(my_tuple[1:4])  # 输出：(2, 3, 4)

7.连接元组：

tuple1 = (1, 2, 3)
tuple2 = (4, 5, 6)
new_tuple = tuple1 + tuple2
print(new_tuple)  # 输出：(1, 2, 3, 4, 5, 6)

2.1.3字符串（string）

2.1.3.1 特殊字符串

块字符串

在Python中，块字符串是指跨越多行的字符串，可以使用三个引号（ ''' 或 """ ）来定义。块字符串可以包含换行符和其他特殊字符，而不需要使用转义字符。这使得块字符串非常适合用于多行文本或包含大量特殊字符的字符串。

转义字符

转义字符是用来表示一些特殊字符的字符序列。转义字符以反斜杠（\）开头，后面跟着一个或多个字符。下面是一些常用的转义字符：

\n : 换行符
\t : 制表符
\" : 双引号
\' : 单引号
\\ : 反斜杠

raw字符串

raw字符串的格式是r’…’。

在raw字符串中，所有的字符都是直接按照字面意思来解释，没有转义字符或者不能打印的字符。

原始字符串非常有用，特别是在处理正则表达式、文件路径和正斜杠等需要使用转义字符的情况下。

示例：

path = r'C:\Users\username\Documents'
print(path)

2.1.3.2 字符串操作

Python语言中包含字符串的以下几个基本操作：

字符串的索引
字符串的切片
字符串的合并
修改字符串
其他操作

索引

在Python语言中，字符串是一个有序字符的集合

在一个字符串被创建之后，其中字符的相对位置就固定了。

第一个字符的索引编号定义为0，第二个字符索引编号为1，以此类推。在Python语言中，对字符串可以进行正向索引和反向索引。

例：

str = 'abcde'

字符串中的字符和其索引编号的对应关系
0	1	2	3	4	正向索引
a	b	c	d	e	对应字符
-5	-4	-3	-2	-1	负向索引

切片

Python字符串的切片操作是指从一个字符串中选取一部分子字符串。切片操作使用方括号 [] 来表示，并且可以有两个索引值，中间用冒号 : 隔开。

可以通过以下方式进行切片操作：

str[start:end]：从索引 start 开始到索引 end-1 结束，返回一个新的字符串。
str[start:]：从索引 start 开始到字符串的末尾结束，返回一个新的字符串。
str[:end]：从字符串的开头开始到索引 end-1 结束，返回一个新的字符串。
str[:]：返回整个字符串的一个副本。
str[::-1]：反向输出字符串
str[::a]：从下标0开始，每隔a-1个字符截取元素

合并

字符串的连接就是把两个或多个字符串连接成一个字符串。
在连接字符串时，Python语言会为每个连接的字符串及新产生的字符串分配内存，增大不必要的内存开销。

操作符(“+”) 方法：

a = str1
b = str2
c = a + b

a为字符串str1，b为字符串str2 ，c通过（“+”）连接 a 和 b 两个字符串

2.Python语言使用符串格式化操作符(%)和join()方法这两种方式连接字符串。

操作符(%) 方法：

'%s%s%s'%('py','th','on')
#输出 python

join()方法：

words = ['Hello', 'world']
result = ' '.join(words)
print(result)

#输出 Hello world

修改

字符串在Python中属于不可变类型，不能直接修改或删除原字符串中的字符，但是可以通过合并或者切片后再合并进行修改。

然而replace函数却可以直接修改字符串的内容。当调用replace()函数时，它会创建一个新的字符串，该字符串是原始字符串的副本，并对副本进行修改。这样做的好处是，原始字符串仍然保持不变，不会被修改。

str1 = " ABCD "
new_str = str1.replace("AB", "EF")
# 输出"EFCD"

其他（字符串格式化）

字符串格式化有两种，分别为 “%”和format。

格式化符号“%”

字符串格式化符号
格式化符号	含义
%x / %X	转为无符号十六进制数
%e / %E	转为科学计数法
%f / %F	转为浮点数
%o / %O	转为无符号八进制数
%d / %D	转为无符号十进制数
%%	输出“%”

format()方法

对字符串进行格式化操作，format()方法常用的匹配方法有三种：

不带编号，即“{}”；
带数字编号，可调换顺序，如“{0}”、“{1}”等；

带关键字，如“{name}”、“{age}”等。

print("a={},b={}".format(2, 4))
print("a={0},b={1}".format(2, 4))
print("a={1},b={0}".format(2, 4))
print("a={num2},b={num3}".format(num2=2, num3=4))
print("a={num3},b={num2}".format(num2=2, num3=4))

# 输出结果
a=2,b=4
a=2,b=4
a=4,b=2
a=2,b=4
a=4,b=2

2.2 集合类型（set）

在Python中，集合是一种无序、不重复的数据集。集合是使用大括号{}或者使用set()函数来创建的。下面是一些常见的集合操作和方法：

2.2.1 创建集合

set1 = {1, 2, 3}  # 使用大括号创建集合
set2 = set()  # 使用set()函数创建空集合

2.2.2 添加元素到集合

set1.add(4)  # 添加单个元素
set1.update([5, 6])  # 添加多个元素

2.2.3 移除集合中的元素

set1.remove(3)  # 移除指定元素，如果元素不存在会抛出KeyError异常
set1.discard(3)  # 移除指定元素，如果元素不存在不会抛出异常
set1.pop()  # 随机移除一个元素
set1.clear()  # 清空集合中的所有元素

2.2.4 集合操作

set1.union(set2)  # 返回个集合的并集
set1.intersection(set2)  # 返回两个集合的交集
set1.difference(set2)  # 返回两个集合的差集
set1.symmetric_difference(set2)  # 返回两个集合的对称差集

2.2.5 集合方法

set1.copy()  # 复制集合
len(set1)  # 返回集合中元素的个数
x in set1  # 判断元素x是否在集合中   set1.issubset(set2)  # 判断set1是否为set2的子集
set1.issuperset(set2)  # 判断set1是否为set2的超集
set1.isdisjoint(set2)  # 判断set1和set2是否没有交集

2.3 映射类型（字典dict）

Python的字典是一种无序的、可变的数据类型，用于存储键值对。字典中的每个元素由一个键和一个值组成，键和值之间用冒号分隔，键值对之间用逗号分隔，整个字典用花括号{}括起来。

2.3.1 创建字典

my_dict = {}
my_dict = dict()
my_dict = {'key1': 'value1', 'key2': 'value2'......}

字典的元素是可变的，可以是列表、元组、字典等任意数据类型，但键(key)值必须使用不可变类型。
在同一个字典变量中，键(key) 值必须是唯一的。
字典中的键必须是唯一的，但值可以重复。可以使用方括号[]来访问字典中的值

2.3.2 访问字典中的值

value = my_dict['key']
value = my_dict.get('key')

2.3.3 修改字典中的值

my_dict['key'] = 'new_value'

2.3.4 添加新的键值对到字典中

my_dict['new_key'] = 'new_value'

2.3.5 删除字典中的键值对

del my_dict['key']
my_dict.pop('key')

2.3.6 检查字典中是否存在某个键或值

if 'key' in my_dict:
    # do something
if 'value' in my_dict.values():
    # do something

2.3.7 遍历字典

for key in my_dict:
    value = my_dict[key]
    # do something with key and value

for key, value in my_dict.items():
    # do something with key and value

2.3.8 获取字典的键、值或键值对

keys = my_dict.keys()
values = my_dict.values()
items = my_dict.items()

2.3.9 清空字典

my_dict.clear()

2.3.10 字典方法

一些常用的字典方法：

clear(): 清空字典中的所有元素。
copy(): 复制字典，返回一个新的字典副本。
get(key, default): 获取指定键的值，如果键不存在则返回默认值。
items(): 返回一个包含字典所有键值对的元组列表。
keys():一个包含字典所有键的列表。
values(): 返回一个包含字典所有值的列表。
(key, default): 删除指定键，并返回对应的值，如果键不存在则返回默认值。
popitem(): 随机删除字典中的一个键值对，并返回被删除的键值对。
. update(dict2): 将另一个字典的键值对添加到当前字典中。
setdefault(key, default): 获取指定键的值，如果键不存在则设置默认值并返回。
keys(seq, value): 创建一个新字典，使用定的序列作为键，指定的值作为所有键的默认值。
len(): 返回字典中键值对的数量。