一文带你深入理解python数据类型

Python是一门广泛应用于科学计算、机器学习、数据分析等领域的编程语言。在Python中，内置了多种数据类型，包括数字、字符串、列表、元组、集合和字典等。这些数据类型具有不同的特点和用途。

数字类型是表示数字的数据类型，通常分为整数和浮点数两种类型。整数是没有小数点的数字，可以表示正数、负数或零，而浮点数则是带有小数点的数字。数字类型可以进行数学计算、逻辑运算和表示数据等场景。

字符串类型是由字符序列组成的不可变序列，可以用单引号、双引号或三引号来表示。字符串类型用于表示文本和字符数据，可以进行拼接、切片、查找和替换等操作。

列表类型是由任意类型的有序元素组成的序列，可以用方括号来表示。列表类型用于表示一组有序数据，可以进行增删改查等操作。

元组类型与列表类似，但是元组是不可变的，一旦创建后就无法修改。元组通常用于保护数据，以确保数据的不可更改性和安全性。

集合类型是由一组唯一元素组成的无序集合，可以用大括号来表示。集合类型用于去重、求交集、并集、差集等操作。

字典类型是由一组键值对组成的无序集合，可以用大括号来表示。字典类型用于表示一组键值对映射的数据，可以进行增删改查等操作。

文章目录

数字类型

Python中的数字数据类型包括整数、浮点数和复数。整数可以是正数、负数或零，浮点数是带有小数点的数字，而复数包含实部和虚部。数字类型可以用于数学计算、逻辑运算和表示数据等场景。

以下是数字类型的一些基本操作：

数字类型是 Python 内置的一种基本数据类型，用于表示数值，包括整数、浮点数和复数。数字类型支持基本的算术操作，如加、减、乘、除和取模，以及高级操作，如幂运算和三角函数等。下面我们将对数字类型进行详细介绍。

整数类型

整数是不带小数点的数字，可以是正数、负数或零。Python 中的整数没有限制大小，可以表示任意大小的整数。整数类型可以通过直接赋值或使用 int() 函数来创建。

例如：
a = 123  # 直接赋值
b = int('456')  # 使用 int() 函数创建

整数类型支持基本的算术操作，例如加、减、乘、除和取模。例如：
a = 6
b = 4
print(a + b)  # 10
print(a - b)  # 2
print(a * b)  # 24
print(a / b)  # 1.5
print(a % b)  # 2

整数类型也支持高级操作，例如幂运算。例如：
a = 2
b = 3
print(a ** b)  # 8

浮点数类型

浮点数是带有小数点的数字。Python 中的浮点数类型可以使用直接赋值或使用 float() 函数来创建。

例如：
a = 1.23  # 直接赋值
b = float('4.56')  # 使用 float() 函数创建

浮点数类型支持基本的算术操作，例如加、减、乘和除。例如：
a = 1.5
b = 0.5
print(a + b)  # 2.0
print(a - b)  # 1.0
print(a * b)  # 0.75
print(a / b)  # 3.0

浮点数类型也支持高级操作，例如幂运算。例如：
a = 2.0
b = 3.0
print(a ** b)  # 8.0

复数类型

复数是包含实部和虚部的数字，用 a + bj 的形式表示，其中 a 和 b 都是浮点数或整数。Python 中的复数类型可以使用直接赋值或使用 complex() 函数来创建。

例如：
a = 3 + 4j  # 直接赋值
b = complex(2, 5)  # 使用 complex() 函数创建

复数类型支持基本的算术操作，例如加、减、乘和除。例如：
a = 2 + 3j
b = 1 + 2j
print(a + b)  # (3+5j)
print(a - b)  # (1+1j)
print(a * b)  # (-4+7j)
print(a / b)  # (1.6-0

数字类型的优点包括：

数字类型的数据运算速度快，对于需要频繁进行数字计算的场景，使用数字类型可以获得更高的效率。
数字类型的数据在进行计算时，可以保留精度，不会出现舍入误差的问题。
数字类型可以进行比较操作，方便进行大小关系的判断。
数字类型支持各种数值计算函数，如求绝对值、求幂、求平方根等。
数字类型支持随机数生成，方便进行随机数相关的操作，如生成随机密码、生成随机数等。
在 Python 中，数字类型的数据可以与其他类型的数据进行运算，如字符串、列表、元组等，这种特性为开发者提供了更多的编程灵活性。

字符串类型

字符串是一种表示文本和字符数据的数据类型。它是由一系列字符组成的不可变序列，可以使用单引号、双引号或三引号来表示。

字符串类型在编程中广泛用于文本处理、文件操作和网络通信等方面。Python中的字符串类型是不可变的，这意味着一旦创建了字符串，就无法更改它的值。因此，任何修改字符串的操作都将返回一个新的字符串对象。

字符串类型提供了许多内置方法和操作符，可以方便地对字符串进行操作。下面是一些常用的字符串操作：

以下是字符串类型的一些基本操作：

定义字符串
可以使用单引号、双引号或三引号来定义字符串。例如：


s1 = 'hello'
s2 = "world"
s3 = '''hello world'''

字符串拼接
可以使用加号（+）运算符将两个字符串拼接在一起，例如：
s1 = 'hello'
s2 = 'world'
s3 = s1 + s2
print(s3)  # 输出'hello world'

字符串切片
可以使用中括号和索引来访问字符串中的单个字符或一段字符子串，例如：
s = 'hello world'
print(s[0])  # 输出'h'
print(s[1:5])  # 输出'ello'
print(s[:5])  # 输出'hello'
print(s[6:])  # 输出'world'

字符串长度
可以使用内置函数len()来获取字符串的长度，例如：
s = 'hello world'
print(len(s))  # 输出11

字符串查找
可以使用内置方法find()来查找字符串中是否包含指定的子串，例如：
s = 'hello world'
print(s.find('world'))  # 输出6

字符串替换
可以使用内置方法replace()来替换字符串中的指定子串，例如：
s = 'hello world'
new_s = s.replace('world', 'python')
print(new_s)  # 输出'hello python'

字符串分割
可以使用内置方法split()将字符串按照指定的分隔符分割成多个子串，例如：
s = 'hello,world'
new_s = s.split(',')
print(new_s)  # 输出['hello', 'world']

字符串格式化
可以使用字符串格式化操作符（%）或字符串格式化函数（format()）来将变量插入到字符串中，例如：
name = 'John'
age = 20
print('My name is %s and I am %d years old' % (name, age))
# 输出'My name is John and I am 20 years old'

print('My name is {} and I am {} years old'.format(name, age))
# 输出'My name is John and I am 20 years old'

字符串类型具有以下优点：

不可变性：字符串类型是不可变的，即字符串对象一旦创建，其值就不可被修改。这使得字符串对象在处理数据时更加安全，可以保证数据不被意外地修改。
易于处理文本数据：字符串类型是专门用于处理文本数据的数据类型。Python内置了大量的字符串操作方法，包括字符串的拼接、替换、查找、截取等操作，使得字符串处理变得十分方便。
可以直接使用操作符：与数字类型类似，字符串类型也可以直接使用加号（+）和乘号（*）操作符进行字符串拼接和复制。
支持多种编码方式：字符串类型支持多种编码方式，包括ASCII、UTF-8、GB2312等，可以满足不同语言、不同平台之间的文本数据交互需求。
可以作为字典的键：由于字符串类型的不可变性，它可以被用作字典的键，而列表等可变类型则不能作为字典的键。这使得字符串类型在字典操作中具有很大的灵活性和方便性。

列表类型

列表（List）是Python中最常用的数据类型之一，它是一个有序的集合，其中的元素可以是任意类型的数据，包括数字、字符串、布尔值、列表、元组、字典等。列表使用方括号 [ ] 表示，各个元素之间使用逗号分隔。

列表是一种可变的数据类型，可以进行增加、删除、修改等操作。它的长度和元素类型都可以改变，所以非常灵活。以下是列表类型的一些基本操作：

定义列表
列表可以通过 [] 或 list() 函数来定义，其中 [] 表示创建一个空列表，list() 函数可以将其他类型的数据转换成列表。
# 定义一个空列表
empty_list = []
# 定义一个包含数字和字符串的列表
my_list = [1, 2, 3, 'a', 'b', 'c']
# 使用 list() 函数将字符串转换成列表
str_list = list('hello')


索引和切片
列表中的元素可以通过索引来访问，索引从 0 开始，也可以使用负数索引从后往前访问。还可以使用切片来访问多个元素，切片的语法是 [start:end:step]，其中 start 表示起始位置（默认为 0），end 表示结束位置（默认为列表长度），step 表示步长（默认为 1）。
my_list = [1, 2, 3, 'a', 'b', 'c']
# 访问单个元素
print(my_list[0]) # 输出 1
print(my_list[-1]) # 输出 'c'
# 访问多个元素
print(my_list[1:4]) # 输出 [2, 3, 'a']
print(my_list[::2]) # 输出 [1, 3, 'b']


增加元素
列表中的元素可以通过 append() 方法在末尾增加一个元素，也可以使用 insert() 方法在指定位置插入一个元素，还可以使用 extend() 方法将一个列表添加到另一个列表的末尾。
my_list = [1, 2, 3, 'a', 'b', 'c']
# 在末尾增加一个元素
my_list.append('d')
print(my_list) # 输出 [1, 2, 3, 'a', 'b', 'c', 'd']
# 在指定位置插入一个元素
my_list.insert(2, 'x')
print(my_list) # 输出 [1, 2, 'x', 3, 'a', 'b', 'c', 'd']
# 将一个列表添加到另一个列表的末尾
my_list.extend([4, 5, 6])
print(my_list) # 输出 [1, 2, 'x', 3, 'a', 'b', 'c', 'd', 4, 5, 6]

删除元素
列表中的元素可以通过 remove() 方法删除指定元素，也可以使用 del 语句删除指定位置的元素，还可以使用 pop() 方法弹出列表中的最后一个元素。

下面是一个例子：
my_list = [1, 2, 3, 4, 5, 6, 3]
my_list.remove(3)  # 删除第一个匹配的 3
print(my_list)  # 输出 [1, 2, 4, 5, 6, 3]
my_list.remove(3)  # 再次删除匹配的 3
print(my_list)  # 输出 [1, 2, 4, 5, 6]
如果列表中不存在要删除的元素，则会抛出 ValueError 异常。

另一种删除元素的方法是使用 del 语句。del 语句可以删除指定位置的元素，也可以删除整个列表。

删除指定位置的元素：
my_list = [1, 2, 3, 4, 5, 6]
del my_list[2]  # 删除索引为 2 的元素（值为 3）
print(my_list)  # 输出 [1, 2, 4, 5, 6]

删除整个列表：
my_list = [1, 2, 3, 4, 5, 6]
del my_list  # 删除整个列表
print(my_list)  # 抛出 NameError 异常，因为 my_list 已经被删除了

列表类型的有点：
列表是Python中最常用的数据类型之一

动态性：列表的长度可以动态增长或缩小，可以随时添加、删除或修改元素，非常灵活。
多样性：列表中的元素可以是任何数据类型，包括数字、字符串、元组、列表等，非常适合存储和处理各种类型的数据。
索引和切片：可以通过索引和切片操作来访问和修改列表中的元素，非常方便。
支持多种操作：除了增加和删除元素之外，列表还支持排序、反转、查找元素、计算列表长度等多种常用操作，非常方便。
可以作为参数传递：由于列表可以存储不同类型的数据，所以它可以作为函数参数进行传递，非常方便。
可以嵌套：列表中的元素也可以是列表，因此可以进行嵌套，可以实现更复杂的数据结构。

元组类型

元组（tuple）是Python中另一种重要的数据类型，类似于列表，但是元组是不可变的（immutable）。这意味着元组一旦被创建，就不能对其中的元素进行修改，添加或删除，但可以访问其中的元素。

定义元组
使用小括号 () 定义元组，并用逗号 , 分隔其中的元素。
my_tuple = (1, 2, 3, 'a', 'b', 'c')

访问元素
元组中的元素可以通过索引来访问，索引从 0 开始，用 [] 操作符表示。
print(my_tuple[0])  # 输出 1
print(my_tuple[3])  # 输出 'a'

切片元组
与列表一样，可以通过切片操作符 : 来获取元组的子集。
print(my_tuple[1:4])  # 输出 (2, 3, 'a')

元组的不可变性
元组的一大特点是不可变性，这意味着一旦创建，就不能对其中的元素进行修改、添加或删除。
my_tuple = (1, 2, 3)
my_tuple[1] = 4  # TypeError: 'tuple' object does not support item assignment

由于元组是不可变的，因此在创建元组时必须确保其中的元素是正确的。如果需要修改元组中的元素，可以使用元组的拼接或复制操作来创建新的元组。
my_tuple = (1, 2, 3)
new_tuple = my_tuple + (4, 5)
print(new_tuple)  # 输出 (1, 2, 3, 4, 5)

元组的优点
与列表相比，元组有以下优点：

元组是不可变的，因此比列表更安全，更适合用于存储常量数据。
元组比列表更轻量级，更适合用于存储大量的数据。
元组可以作为字典的键，而列表不能。
元组可以作为函数的参数或返回值，而列表不能。

集合类型

集合（set）是一种无序且不重复的数据类型，它是由一组互不相同的元素组成的。在 Python 中，集合类型用大括号 {} 表示，或者使用 set() 函数创建。

下面是一个创建集合的例子：

# 创建集合
set1 = {1, 2, 3, 4, 5}
set2 = set([4, 5, 6, 7, 8])
集合和列表和元组不同，它是无序的，这意味着元素没有固定的顺序。这也意味着我们不能使用索引来访问集合中的元素。另外，集合中的元素是唯一的，即集合中不允许出现重复的元素。如果尝试将重复元素添加到集合中，集合会自动将重复元素去重，只保留一个元素。

下面是一些集合常用操作：

添加元素：使用 add() 方法添加单个元素，使用 update() 方法添加多个元素。
# 创建集合
set1 = {1, 2, 3}

# 添加单个元素
set1.add(4)
print(set1) # 输出 {1, 2, 3, 4}

# 添加多个元素
set1.update([4, 5, 6])
print(set1) # 输出 {1, 2, 3, 4, 5, 6}


删除元素：使用 remove() 或 discard() 方法删除指定元素。如果指定的元素不存在，remove() 方法会抛出异常，而 discard() 方法则不会抛出异常。还可以使用 pop() 方法随机删除一个元素。
# 创建集合
set1 = {1, 2, 3, 4, 5}

# 删除指定元素
set1.remove(3)
print(set1) # 输出 {1, 2, 4, 5}

# 随机删除一个元素
set1.pop()
print(set1) # 输出 {2, 4, 5}

# 删除不存在的元素
set1.discard(6)
print(set1) # 输出 {2, 4, 5}

# 删除不存在的元素并抛出异常
set1.remove(6) # 抛出 KeyError 异常

集合运算：包括交集、并集、差集和对称差集等。
# 创建集合
set1 = {1, 2, 3}
set2 = {3, 4, 5}

# 交集
print(set1 & set2) # 输出 {3}

# 并集
print(set1 | set2) # 输出 {1, 2, 3, 4, 5}

# 差集
print(set1 - set2) # 输出 {1, 2}

# 对称差集
print(set1 ^ set2) # 输出 {1, 2, 4, 5}

集合类型的主要优点如下：

去重功能：集合中的元素是唯一的，可以方便地对一组数据进行去重操作。
支持集合运算：集合类型支持交、并、差等基本集合运算，可以方便地对数据进行集合运算。
可变性：集合类型是可变的，可以通过 add()、remove() 等方法对集合进行增删改操作。
效率高：集合类型内部使用了哈希表，因此可以快速进行查找和判断元素是否存在。
无序性：集合类型是无序的，可以根据需要自由排序，也可以使用 sorted() 方法进行排序。

字典类型

字典类型（dict）是Python中常用的一种数据类型，它是一种可变容器模型，可以存储任意类型对象，例如数字、字符串、列表等，它以键值对（key-value pair）的形式存储数据。每个键值对之间用逗号隔开，整个字典用花括号 {} 括起来。字典中的键必须是不可变类型，如字符串、数字或元组，而值可以是任意类型的对象。

下面是一个简单的字典例子：

my_dict = {'name': 'Alice', 'age': 20, 'gender': 'female'}
这个字典中包含三个键值对，分别是 'name': 'Alice'、'age': 20 和 'gender': 'female'。其中，键 'name' 的值为字符串 'Alice'，键 'age' 的值为整数 20，键 'gender' 的值为字符串 'female'。

字典中的键值对是没有顺序的，因此无法使用索引访问字典中的元素。要访问字典中的某个值，可以使用对应的键，例如：
print(my_dict['name'])  # 输出 'Alice'

如果字典中不存在指定的键，会抛出 KeyError 异常。要避免这种情况，可以使用 get() 方法：
print(my_dict.get('age'))  # 输出 20
print(my_dict.get('phone'))  # 输出 None

get() 方法返回指定键的值，如果字典中不存在该键，则返回 None。也可以指定一个默认值，在键不存在时返回默认值：

print(my_dict.get('phone', 'N/A'))  # 输出 'N/A'


字典是可变的，可以使用赋值语句来修改字典中的值或添加新的键值对：
my_dict['name'] = 'Bob'  # 修改值
my_dict['phone'] = '123456789'  # 添加新键值对
print(my_dict)  # 输出 {'name': 'Bob', 'age': 20, 'gender': 'female', 'phone': '123456789'}

可以使用 del 语句来删除字典中的键值对：
del my_dict['age']  # 删除键 'age'
print(my_dict)  # 输出 {'name': 'Bob', 'gender': 'female', 'phone': '123456789'}

字典类型的优点如下：