【Python】入门到放弃之第三章《数据类型》

花凝雨

于 2024-08-10 15:12:23 发布

阅读量687

点赞数 18

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

本文链接：https://blog.csdn.net/MP13537560060/article/details/141089238

版权

Python 专栏收录该内容

5 篇文章 0 订阅

订阅专栏

上一篇：【Python】入门到放弃之第二章《变量》
下一篇：【Python】入门到放弃之第四章《数据类型转换》

前言

这是本系列的第三章节内容，《数据类型》。

一、何为数据类型

数据类型（Data Type）是编程中用于指定数据项（如变量、数组等）存储何种类型的数据的标记或分类。不同的数据类型允许程序以不同的方式存储和操作数据。数据类型对于编程语言来说至关重要，因为它们决定了数据如何被解释以及可以在数据上执行哪些操作。

本章将其分为数字类型、布尔类型、字符串类型、列表类型、元组类型、字典类型、集合类型、其他数据类型等进行讲解。

二、数字类型（Number Types）

整型（Integer）：用于表示整数，可以是正整数、负整数或零。Python 3中不再区分整型（int）和长整型（long），统一使用int类型。
浮点型（Float）：用于表示带有小数点的实数，可以是正数、负数或零。
复数型（Complex）：由实部和虚部组成，表示形式为a + bj，其中a是实部，b是虚部，j（或J）是虚数单位。

# 下面是整型
x = 10            # 正整数
y = -5            # 负整数
z = 0             # 零

# 下面是浮点型
a = 3.14          # 浮点数
b = -0.01         # 负浮点数
c = 0.0           # 零的浮点数表示

# 下面是复数型
c1 = 1 + 2j       # 复数
c2 = 7.7 - 8.10j  # 带有浮点数的复数

三、布尔类型（Boolean Type）

布尔类型只有两个值：True和False，用于表示逻辑上的真和假。常用于条件判断和控制流语句中。

# 布尔值在数值上下文中的表现
print(True + 1)   # 输出 2
print(False * 3)  # 输出 0

2
0

四、字符串类型（String Type）

1.字符串的使用

字符串是由零个或多个字符组成的有限序列，用于表示文本数据。Python中的字符串是不可变的，即一旦创建就不能更改其内容。字符串可以用单引号（‘）、双引号（"）或三引号（’''或"“”）来定义。

# 使用单引号定义字符串  
s1 = 'Hello, world!'  
  
# 使用双引号定义字符串  
s2 = "Hello, world!"  
  
# 使用三引号定义多行字符串  
s3 = """这是一个多行字符串。  
它可以包含多个字符，  
甚至换行符。"""  
  
# 包含引号字符的字符串  
s4 = 'He said, "Hello, world!"'  
s5 = "She said, 'Hello, world!'"  
  
# 使用转义字符来定义包含引号的字符串（非必需，仅作演示）  
s6 = 'He said, \"Hello, world!\"'  
s7 = "She said, \'Hello, world!\'"

需要注意的是，字符串是不可变的，任何看起来像是修改字符串的操作实际上都是创建了一个新的字符串。

s = 'Hello'  
s = s + ', world!'  # 这里并没有修改s，而是创建了一个新的字符串并赋值给s

2.字符串的常用操作

Python提供了丰富的字符串操作方法，包括拼接、切片、索引、查找、替换、分割、格式化等。

拼接：使用+操作符可以拼接两个或多个字符串。
切片：使用切片语法可以获取字符串的子串。
索引：使用索引可以访问字符串中的单个字符。
查找：使用find()、index()等方法可以在字符串中查找子串的位置。
替换：使用replace()方法可以在字符串中替换子串。
分割：使用split()方法可以根据指定的分隔符将字符串分割成列表。
格式化：可以使用%操作符、str.format()方法或f-strings（Python 3.6+）来格式化字符串。

3.字符串的编码

在Python中，字符串是以Unicode编码的形式存储的。Unicode是一种为了将世界上所有的系统、语言和字符编码都纳入其中的编码标准。这意呀着Python的字符串可以包含来自任何语言的字符。
当需要将字符串以特定编码形式（如UTF-8）保存到文件或通过网络传输时，可以使用encode()方法将字符串编码为字节序列，使用decode()方法将字节序列解码为字符串。但请注意，这两个操作通常是在处理字节序列（bytes类型）时使用的，而不是直接在字符串上进行。

五、列表类型（List Type）

列表是Python中最常用的复合数据类型之一，它是一个有序的数据集合，可以包含不同类型的元素（如整数、浮点数、字符串等），且元素之间用逗号分隔，整个列表用方括号[]括起来。列表是可变的，即可以添加、删除或修改其中的元素。
注意，本小节下面1-6的代码应为连续。

1.创建列表

列表由方括号[]定义，里面的元素由逗号,分隔。

# 创建一个空列表  
my_list = []  
  
# 创建一个包含不同类型元素的列表  
my_list = [1, 'Hello', 3.14, [1, 2, 3]]

2.访问列表元素

列表中的元素可以通过索引进行访问，索引从0开始。

# 访问列表的第一个元素  
first_element = my_list[0]  
  
# 访问列表的最后一个元素（注意，这不是索引-1的简写）  
last_element = my_list[-1]

3.修改列表

由于列表是可变的，可以通过索引来修改列表中的元素。

# 修改第一个元素  
my_list[0] = 'New Element'  
  
# 列表的嵌套修改  
my_list[-1][0] = 0  # 将子列表的第一个元素修改为0

4.添加元素

添加元素：可以使用append()方法在列表末尾添加元素，或者使用insert()方法在指定位置插入元素。

# 在列表末尾添加元素  
my_list.append('Another Element')  
  
# 在索引1的位置插入元素  
my_list.insert(1, 'Inserted Element')

5.删除元素

删除元素：可以使用remove()方法根据值删除元素，或者使用pop()方法根据索引删除元素（并返回被删除的元素）。

# 删除值为'Inserted Element'的元素  
my_list.remove('Inserted Element')  
  
# 删除索引为1的元素（注意，这会改变列表中元素的索引）  
popped_element = my_list.pop(1)

6.列表切片

列表支持切片操作，允许获取列表的一部分。

# 获取列表的前三个元素  
first_three = my_list[:3]  
  
# 获取列表的第二个到第四个元素（不包括第四个）  
middle_slice = my_list[1:4]  
  
# 逆序获取列表的元素  
reversed_list = my_list[::-1]

7.列表的常用方法

Python的列表类型提供了许多其他有用的方法，比如count()（计数）、index()（查找索引）、sort()（排序）、reverse()（逆序）等。
注意sort()时，对象列表的元素类型须保持一致，否则报错。

# 创建一个空列表
my_testlist = []

# 创建一个包含相同类型元素的列表
my_testlist = ['Hello', 'World', '!']

# 计数
print(my_testlist.count('Hello'))

# 查找索引
print(my_testlist.index('Hello'))

# 排序（注意，这会就地修改列表）
my_testlist.sort()

# 逆序（注意，这也会就地修改列表）
my_testlist.reverse()

1
0

8.列表推导式

列表推导式提供了一种简洁的方式来创建列表。

# 创建一个包含1到10的平方的列表
squares = [x ** 2 for x in range(1, 11)]

# 创建一个包含列表中偶数元素的列表
even_numbers = [x for x in squares if isinstance(x, int) and x % 2 == 0]

print(squares)

print(even_numbers)

[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
[4, 16, 36, 64, 100]

六、元组类型（Tuple Type）

元组与列表类似，也是一个有序的数据集合，但它与列表的主要区别在于元组是不可变的。一旦创建了元组，就不能修改其元素（尽管可以替换整个元组）。元组用圆括号()定义，如果元组中只有一个元素，则需要在该元素后面加上逗号,，以区分于普通的圆括号表达式。

1.创建元组

元组可以包含不同类型的元素，如整数、浮点数、字符串、列表等，甚至其他元组（即元组可以嵌套）。

# 创建一个空元组  
empty_tuple = ()  
  
# 创建一个包含不同类型元素的元组  
mixed_tuple = (1, 'hello', 3.14)  
  
# 创建一个嵌套元组  
nested_tuple = (1, (2, 3), 4)  
  
# 创建只有一个元素的元组时，需要在元素后面加上逗号  
single_element_tuple = (1,)

2.访问元组元素

与列表相似，可以使用索引来访问元组中的元素。元组的索引从0开始。

tuple_example = (1, 'hello', 3.14)  
print(tuple_example[0])  # 输出: 1  
print(tuple_example[1])  # 输出: hello  
print(tuple_example[2])  # 输出: 3.14

1
hello
3.14

3.元组的切片

元组也支持切片操作，这意味着可以获取元组的一部分。

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

(2, 3)

4.元组的不可变性

由于元组是不可变的，你不能像列表那样使用如 append(), pop(), remove() 等方法来修改元组。如果你需要修改元组中的元素，你需要先将元组转换成列表，进行修改，然后再转换回元组（如果必要的话）。

# 错误的尝试修改元组  
tuple_example = (1, 2, 3)  
# tuple_example[1] = 4  # 这会抛出TypeError  
  
# 正确的修改方式  
list_example = list(tuple_example)  
list_example[1] = 4  
tuple_example = tuple(list_example)  
print(tuple_example)  # 输出: (1, 4, 3)

(1, 4, 3)

5.元组的应用场景

删除元素：可以使用remove()方法根据值删除元素，或者使用pop()方法根据索引删除元素（并返回被删除的元素）。
1. 当数据项不需要改变时，使用元组可以提高效率，因为元组是不可变的，Python解释器可以对其进行优化。
2. 作为字典的键（key）使用，因为字典的键必须是不可变的。
3. 打包多个值，作为函数返回多个值时的容器（虽然Python支持函数返回多个值，但实际上返回的是一个元组）。
4. 在需要元组语义（如使用 in 和 not in 进行成员测试）的场合。

七、字典类型（Dictionary Type）

字典是Python中另一种常用的复合数据类型，它是一个无序的数据集合，用于存储键值对（key-value pairs）。每个键值对将键映射到其关联的值，键必须是唯一的，而值则可以是任何数据类型。字典用大括号{}定义，键值对之间用逗号,分隔。
注意，本小节1-5代码为连续。

1.创建字典

可以通过大括号 {} 来创建一个字典，并使用冒号 : 来分隔键和值，用逗号 , 来分隔不同的键值对。

# 创建一个空字典  
empty_dict = {}  
  
# 创建一个包含一些键值对的字典  
person = {'name': 'HuaNingyu', 'age': 30, 'city': 'Mao Ming'}

2.访问字典的值

可以通过键来访问字典中的值。如果键存在，则返回对应的值；如果不存在，则会引发一个 KeyError，除非使用 .get() 方法，它才会返回 None 或者你指定的默认值。

# 访问存在的键  
print(person['name'])  # 输出: HuaNingyu
  
# 访问不存在的键（会引发KeyError）  
# print(person['job'])  
  
# 使用.get()访问不存在的键，返回None或指定默认值  
print(person.get('job'))  # 输出: None  
print(person.get('job', 'Unknown'))  # 输出: Unknown

HuaNingyu
None
Unknown

3.修改字典

可以通过为键赋值来修改字典中的值。如果键不存在，则会自动添加这个键值对。

# 修改已存在的键的值
person['age'] = 31

# 添加新的键值对
person['job'] = 'Bricklayer'

print(person)

{'name': 'HuaNingyu', 'age': 31, 'city': 'Mao Ming', 'job': 'Bricklayer'}

4.删除字典中的元素

可以使用 del 语句或字典的 .pop() 方法来删除键值对。.popitem() 方法会移除并返回字典中的最后一对键值对（Python 3.7+ 中保证按插入顺序）。

# 使用del删除键值对  
del person['city']  
  
# 使用.pop()删除键值对，并返回被删除的值  
job = person.pop('job')  
print(job)  # 输出: Bricklayer
  
# 如果尝试删除的键不存在，.pop() 会引发KeyError，但你可以提供一个默认值  
# print(person.pop('job', 'Not found'))  
  
# 使用.popitem()删除并返回字典中的最后一对键值对  
# 注意：这个方法在空字典上调用会抛出KeyError  
last_item = person.popitem()  
print(last_item)  # 输出类似: ('name', 'HuaNingyu')

Bricklayer
('age', 31)

5.字典的遍历

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

# 添加新的键值对
person['date'] = '2024.8.10'  # 此时 person = {'name': 'HuaNingyu', 'date': '2024.8.10'}

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

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

# 遍历键值对
for key, value in person.items():
    print(key, value)

name
date
HuaNingyu
2024.8.10
name HuaNingyu
date 2024.8.10

八、集合类型（Set Type）

集合是一个无序的、不包含重复元素的数据集合。它主要用于数学上的集合运算，如并集、交集、差集和对称差集等。集合用大括号{}或set()函数定义，但需要注意的是，空集合不能用{}表示（因为它会被解释为空字典），而应该使用set()。
注意，本小节1-2代码为连续。

1.创建集合

使用 set() 函数。

# 创建集合
my_set = set([1, 2, 3, 4, 5])
print(my_set)     # 输出：{1, 2, 3, 4, 5}

empty_set = set()
print(empty_set)  # 输出：set()

使用花括号 {} 创建集合（注意，仅当集合非空时）

# 创建集合
my_set = {1, 2, 3, 4, 5}
print(my_set)  # 输出：{1, 2, 3, 4, 5}

2.集合的基本操作

添加元素：使用 .add() 方法。

my_set.add(6)
print(my_set)  # 输出：{1, 2, 3, 4, 5, 6}

删除元素：使用 .remove() 方法（如果元素不存在则抛出异常），或使用 .discard() 方法（如果元素不存在则不抛出异常）。

my_set.remove(2)  # 如果2在集合中，则删除

# my_set.remove(7)  # 这会抛出KeyError

my_set.discard(7)  # 如果7不在集合中，则不会抛出异常

清空集合：使用 .clear() 方法。

my_set.clear()  
print(my_set)  # 输出：set()

集合的并集：使用 | 运算符或 .union() 方法。

set1 = {1, 2, 3}  
set2 = {3, 4, 5}  
print(set1 | set2)  # 输出：{1, 2, 3, 4, 5}  
print(set1.union(set2))  # 输出：{1, 2, 3, 4, 5}

集合的交集：使用 & 运算符或 .intersection() 方法。

print(set1 & set2)  # 输出：{3}  
print(set1.intersection(set2))  # 输出：{3}

集合的差集：使用 - 运算符或 .difference() 方法。

print(set1 - set2)  # 输出：{1, 2}  # 表示在set1中但不在set2中的元素  
print(set1.difference(set2))  # 输出：{1, 2}

集合的对称差集：使用 ^ 运算符或 .symmetric_difference() 方法。

print(set1 ^ set2)  # 输出：{1, 2, 4, 5}  # 表示在set1或set2中，但不同时在两者中的元素  
print(set1.symmetric_difference(set2))  # 输出：{1, 2, 4, 5}

九、其他数据类型

除了上述主要的数据类型外，Python还提供了一些其他的数据类型，如：
1. NoneType：表示空值或空对象，只有一个值None。
2. 文件类型：用于表示打开的文件对象，支持文件的读写操作。
3. 字节类型（Bytes）：用于表示不可变的字节序列，常用于处理二进制数据。
4. 日期和时间类型：如datetime模块提供的date、time、datetime等类型，用于表示和处理日期和时间。

以下提供NoneType 实例：

# 检查一个变量是否是None  
x = None
if x is None:
    print("x 是 None") 

# 检查一个变量是否是NoneType  
if type(x) is type(None):
    print("x 的类型是 NoneType")  

# 简写形式，直接和None比较  
if x is None:
    print("这是检查None的常用方式")  

# 尝试访问None的属性或方法会引发TypeError  
try:
    print(x.some_attribute)
except AttributeError:
    print("尝试访问None的属性或方法会失败") 


# None常用于函数的返回值，表示没有有效的返回值
def get_value(condition):
    if condition:
        return "Some value"
    else:
        return None


result = get_value(False)
if result is None:
    print("没有获取到值")

x 是 None
x 的类型是 NoneType
这是检查None的常用方式
尝试访问None的属性或方法会失败
没有获取到值

总结

以上，就是Python中数据类型的全部内容。本想着简单写点就午睡的，不知不觉写了这么长，好累好困，就这样吧，从入门到放弃。

花凝雨

关注

18
点赞
踩
7

收藏

觉得还不错? 一键收藏
0
评论
【Python】入门到放弃之第三章《数据类型》

这是本系列的第三章节内容，《数据类型》。以上，就是Python中数据类型的全部内容。本想着简单写点就午睡的，不知不觉写了这么长，好累好困，就这样吧，从入门到放弃。
复制链接

扫一扫

专栏目录