Python：六大数据类型理论与示例

在这篇文章中，我们深入探讨了Python中的六大基本数据类型：数字（Number）、字符串（String）、列表（List）、元组（Tuple）、集合（Set）、字典（Dictionary）。每种数据类型都有其特定用途和操作方法，了解它们对于编写高效的Python代码至关重要。

数字类型（Number）

Python支持四种不同的数字类型：整型、布尔型、浮点型和复数。这篇文章详细介绍了数字类型的基本操作和转换方法。例如，int(x)用于将x转换为整数，float(x)将x转换为浮点数，complex(x)将x转换为复数。此外，还探讨了Python中的数字运算，如加减乘除和幂运算。

字符串（String）

字符串是Python中最常用的数据类型之一。在Python中，可以使用单引号或双引号创建字符串。文章中讨论了字符串的基本操作，例如访问子字符串、字符串更新和拆分。特别指出的是，Python支持负索引访问字符串中的值。

列表（List）

列表是Python中非常灵活的数据结构类型。它可以包含不同类型的数据，并且支持增删改查和其他多种操作。文章中深入解释了如何创建和操作列表，包括索引、切片、添加和删除元素。

元组（Tuple）

元组类似于列表，但它是不可变的。这意味着一旦创建了元组，就不能更改其内容。文章中介绍了如何创建和访问元组，以及它们与列表的主要区别。

集合（Set）

集合是一个无序且不重复的元素集。它非常适合用于进行成员关系测试和消除重复元素。文中详细介绍了如何创建集合、添加和删除元素，以及执行常见的集合操作（如并集、交集、差集）。

字典（Dictionary）

字典是Python中一个非常重要的数据结构。它基于键值对，其中每个键都是唯一的。文章中展示了如何创建和访问字典，如何添加、删除和修改字典中的元素。

示例展示

1.1 Python的基础知识

本节的主要目的是介绍一些Python的基础知识。

1.1.1 注释

注释的作用是通过使用自己熟悉的语言，在程序中对某些代码进行标注说明，它能够大大增强程序的可读性。主要的注释方式有三种：单行注释、多行注释和中文注释。 单行注释：以#开头，#右边的所有东西当作说明，而不是真正要执行的程序，起辅助说明作用，代码如下：

# 这是注释，一般写一些下面代码块的功能说明      
print('hello world')  

hello world

多行注释：以```开头和结尾，中间部分是注释内容，一般在内容较多，一行写不下的情况下进行标注说明，代码如下：

'''
这是多行注释，可以写很多很多行的功能说明哦 
哈哈 
哈 
哈哈哈哈哈哈哈哈…
'''
print("多行注释")

多行注释

1.1.2 六大数据类型

1. 变量

在程序中，如果需要对2个数据进行求和，那么该怎样做呢？ 类比一下现实生活中，如果去超市买两个商品，我们往往需要一个购物袋来存储商品，所有的商品都购买完成后，在收银台进行结账即可。 在程序中，如果需要对2个数据进行求和的话，也需要把这些数据先存储起来，然后把它们累加起来即可。 在Python中，存储一个数据，就需要一个变量，代码如下：

num1 = 7 #num1就是一个变量，就像一个购物袋    
num2 = 9  #num2也是一个变量    
#把num1和num2这两个"购物袋"中的数据进行累加，然后放到 result变量中    
result = num1 + num2
print(result)

16

所谓变量，可以理解为购物袋，如果需要存储多个数据，最简单的方式是用多个变量。想一想：我们应该让变量占用多大的空间，保存什么样的数据呢？ 这就是下面要介绍的六大数据类型。

2. 变量的类型

对于购物袋来说，一般也是有很多种类的，比如小袋子、中袋子和大袋子。每个类型经常装的物品也会有区别。

那么对于变量来说也是一样的，Python里面有六大基础的数据类型，可以更充分地利用内存空间以及更有效率地管理内存。六大数据类型分别为：Numbers（数字）、String（字符串）、List（列表）、Tuple（元组）、Dictionary（字典）和Set（集合）。

1) Numbers数字

数字数据类型下有三个子类型：

a= 1     # Int类型数据赋值    
print(type(a))    
b= 1.0   # Float类型数据赋值    
print(type(b))    
c= 3e+26J # Complex类型数据赋值    
print(type(c))  

<class 'int'>
<class 'float'>
<class 'complex'>

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

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

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

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

④：将x和y转换到一个复数，实数部分为x，虚数部分为y。x和y是数字表达式。

将浮点数变量a转换为整数，代码如下：

a = 1.0    
int(a)

1

(2)数字数据类型的运算：

Python 解释器可以作为一个简单的计算器，在解释器里输入一个表达式，它将输出表达式的值。 表达式的语法很直白，“+”、“-”、“*”、“/”和其他语言（如Pascal或C）里一样。但是有几个值得注意的地方：

①在不同的机器上浮点运算的结果可能会不一样。

②在整数除法中，除法“/” 总是返回一个浮点数，如果只想得到整数的结果，丢弃可能的分数部分，可以使用运算符“//”。

③ “//”得到的并不一定是整数类型的数，它与分母分子的数据类型有关系（例如，7//2.0>>>3.0）。

④Python 可以使用“**”操作来进行幂运算。

⑤变量在使用前必须先“定义”（即赋予变量一个值），否则会出现错误。

⑥不同类型的数混合运算时会将整数转换为浮点数。

Python内置的数字类型数学函数见下表。

(3)Python内置的数字类型随机数函数：

随机函数可以用于数学、游戏、安全等领域中，还经常被嵌入到算法中，用以提高算法效率，并提高程序的安全性，随机函数说明见下表

2) String字符串

字符串是Python中最常用的数据类型。读者可以使用引号（' 或 "）来创建字符串。 创建字符串很简单，只要为变量分配一个值即可，代码如下：

var1 = 'Hello World!'    
var2 = "VenusAI"

(1)Python访问字符串中的值：

Python访问子字符串，可以使用方括号“[]”来截取字符串，字符串的截取的语法格式为：变量名[头下标: 尾下标: 步长]，左闭右开，代码如下：

var1 = 'Hello World!'    
var2 = "VenusAI"    
print ("var1[-1]: ", var1[-2])    
print ("var2[::2]: ", var2[::2]) 

var1[-1]:  d
var2[::2]:  VnsI

注意：Python访问字符串中的值也支持下标负索引。

(2) Python字符串更新：

可以截取字符串的一部分并与其他字段拼接，代码如下：

var1 = 'Hello World!'     
print ("已更新字符串 : ", var1[:6] + 'VenusAI!')  

已更新字符串 :  Hello VenusAI!

(3) Python字符串拆分：

可以按照某个元素对字符串进行切分，方法语法：字符串.split(str=" ")，代码如下：

value = 'Hello_World!'     
print ("已更新字符串 : ", value.split('_')) 

已更新字符串 :  ['Hello', 'World!']

以“_”为分隔符切片字符串value，返回一个列表来存储分割后的字符串。

(4) Python转义字符：

在计算机中，有些字符是有特殊含义的，例如换行符、制表符、引号等等。如果我们想要表示这些字符本身，而不是它们的特殊含义，就需要使用转义字符来进行表示。Python用反斜杠“\”转义字符，常见的如下：
①(在行尾时) 表示续行符。
②\n：表示换行符，将光标移动到下一行开头。
③\t：表示制表符，将光标移动到下一个制表符位置。
④\r：表示回车符，将光标移动到本行开头。
⑤\b：表示退格符，将光标退回到前一个位置。
⑥\f：表示换页符，将光标移动到下一页开头。
⑦\'：表示单引号本身。
⑧\"：表示双引号本身。
代码如下：

# \\ 表示反斜杠符号    
print("\\")     
# \n' 表示换行    
print("\\n")     
# \" 表示双引号    
print("\"")    
# "

\
\n
"

(5) Python字符串运算符，代码如下：

a = 'hello'    
b = 'Python'    
# + 字符串连接    
print(a + b)  
# helloPython
# * 重复输出字符串    
print(a*2)     
# hellohello

helloPython
hellohello

(6) Python字符串格式化：

Python支持格式化字符串的输出。尽管这样可能会用到非常复杂的表达式，但最基本的用法是将一个值插入到一个有字符串格式符%s的字符串中。 在Python中，字符串格式化使用与C语言中sprintf函数一样的语法，代码如下：

print ("我叫 %s 今年 %d 岁!" % ('小明', 10))

我叫 小明 今年 10 岁!

Python常用的字符串格式化符号见下表。 

3)List序列

序列是Python中最基本的数据结构。
序列中的每个值都有对应的位置值，称之为索引，第一个索引是0，第二个索引是1，依此类推，List也有负索引。

Python 有6个序列的内置类型，但最常见的是列表类型。

列表可以进行的操作包括索引、切片、加、乘和检查元素。

此外，Python 已经内置函数来确定序列的长度以及确定最大和最小的元素的方法。

列表的数据项不需要具有相同的类型，可以接受任何变量类型。

创建一个列表，只要把逗号分隔的不同的数据项使用方括号括起来即可。代码如下：

list1 = ['Python2.0', 'Guido', 2000]    
list2 = [1, 2, 3, 4, 5 ]    
list3 = ["a", "b", "c", "d"]

(1)访问列表中的值：

与字符串的索引一样，列表索引从0开始，第二个索引是 1，依此类推。 通过索引列表可以进行截取、组合等操作，代码如下：

list = ["a", "b", "c", "d"]    
print( list[0] ) # a    
print( list[1] )  # b    
print( list[-2] ) # c    
print( list[-3] ) # b

a
b
c
b

除了使用下标索引来访问列表中的值，也同样可以使用方括号 [头下标: 尾下标]，左闭右开的形式截取字符，代码如下：

nums = [10, 20, 30, 40, 50, 60, 70, 80, 90]    
print(nums[0:4]) # 10 20 30 40    
print(nums[2:-3]) # 30 40 50 60

[10, 20, 30, 40]
[30, 40, 50, 60]

(2)更新列表：

可以对列表的数据项进行修改或更新，也可以使用append()方法来添加列表项，代码如下：

list = ['Python2.0', 'VenusAI', 2000]    
print ("第2个元素为 : ", list[1])    
list[1] = 'Community'    
print ("更新后的第2个元素为 : ", list[1])
'''
第2个元素为：Guido  
更新后的第2个元素为：Community  
''' 
list = ['Alibaba', 'Tencent']    
list.append('Baidu')    
print ("更新后的列表 : ", list)

第2个元素为 : VenusAI
更新后的第2个元素为 : Community
更新后的列表 : ['Alibaba', 'Tencent', 'Baidu']

(3)删除列表元素：

可以使用del语句来删除列表中的元素，代码如下：

list = ['Python2.0', 'VenusAI', 2000]  
print ("原始列表 : ", list)  
del list[2]  
print ("删除第3个元素 : ", list)  

原始列表 :  ['Python2.0', 'VenusAI', 2000]
删除第3个元素 :  ['Python2.0', 'VenusAI']

(4)嵌套列表及索引：

使用嵌套列表即在列表里创建其他列表，代码如下：

a = [1, 2, 3]    
b = ['a', 'b']    
x = [a, b]    
print(x) 
# [[1, 2, 3], ['a', 'b']]

[[1, 2, 3], ['a', 'b']]

(5)列表比较：

列表比较则需要引入Operator模块的eq()方法，代码如下：

# 导入 operator 模块    
import operator    
a = [1, 2]    
b = [2, 3]    
c = [2, 3]    
print("operator.eq(a,b): ", operator.eq(a,b))    
print("operator.eq(c,b): ", operator.eq(c,b))  

operator.eq(a,b):  False
operator.eq(c,b):  True

(6)列表插入：

insert()函数用于将指定对象插入列表的指定位置。代码如下： list.insert(index, obj)

参数： ①index：对象obj需要插入的索引位置。 ②obj：要插入列表中的对象。 该方法没有返回值，但会在列表指定位置插入对象。insert()函数的使用代码如下：

list = ['Alibaba', 'Tencent']    
list.insert(1, 'Baidu')    
print ('列表插入元素后为 : ', list)  

列表插入元素后为 :  ['Alibaba', 'Baidu', 'Tencent']

(7)列表统计：

count()方法用于统计某个元素在列表中出现的次数。代码如下：list.count(obj)

参数obj表示要统计的列表对象，返回元素在列表中出现的次数。count()函数的使用代码如下：

list = [1, 2, 1, 1, 2, 3, 4]    
print("3的元素个数: ", list.count(3))    
# 1的元素个数: 3

3的元素个数:  1

(8)列表的排序：

sort()函数用于对原列表进行排序，如果指定参数，则使用比较函数指定的比较函数。代码如下：

list.sort( key=None, reverse=False)

①参数key：主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。例如，如果你有一个包含字符串的列表，你可以使用 key 参数来指定按字符串长度排序。 ②参数reverse：排序规则，reverse = True，降序；reverse = False，升序（默认）。 该方法没有返回值，但是会对列表的对象进行排序。sort()函数的使用代码如下：

list = ["VenusAI", "www.aideeplearning.cn", "aideeplearning"]    
list.sort(key=len)    
print("排序后的list: ", list)     

排序后的list:  ['VenusAI', 'aideeplearning', 'www.aideeplearning.cn']

4)Tuple元组

Python 的元组与列表类似，不同之处在于元组的元素不能修改。 元组使用小括号“( )”，列表使用方括号“[ ]”。 元组创建很简单，只需要在括号中添加元素，并使用逗号“,”隔开即可。

(1)创建空元组，代码如下：

tuple = ()

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

tup1 = (50)    
print(type(tup1)) # 不加逗号，类型为整型    
tup2 = (50,)    
print(type(tup2)) # 加上逗号，类型为元组

<class 'int'>
<class 'tuple'>

(2)元组的增删改查：

增：元组与字符串、列表类似，且可以进行截取、组合等，代码如下：

tup1 = (1, 2)    
tup2 = (3, 4)    
# 创建一个新的元组    
tup3 = tup1 + tup2    
print(tup3*2)    
# (1, 2, 3, 4)

(1, 2, 3, 4, 1, 2, 3, 4)

删：元组中的元素值是不允许删除的，但可以使用del语句来删除整个元组，代码如下：

tup = (1, 2, 3, 4)    
print(tup)    
del tup    
print("删除后的元组tup:", tup)

(1, 2, 3, 4)

---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
Cell In[50], line 4
      2 print(tup)    
      3 del tup    
----> 4 print("删除后的元组tup:", tup)

NameError: name 'tup' is not defined

改：元组中的元素值是不允许修改的，代码如下：

tup = (3,.14)    
# 以下操作是非法的    
tup[0] = 4    

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[51], line 4
      2 tup = (3,.14)    
      3 # 以下操作是非法的    
----> 4 tup[0] = 4

TypeError: 'tuple' object does not support item assignment

查：元组与字符串类似，元组的访问从下标索引从0开始，当然，也可以使用负索引，代码如下：

tup1 = (1, 2, 3, 4, 5)    
tup2 = ('a', 'b', 'c', 'd', 'e')    
print("tup1[0]: ", tup1[0])    
print("tup2[1:4]: ", tup2[1:4])   

tup1[0]:  1
tup2[1:4]:  ('b', 'c', 'd')

(3)元组运算符：

元组之间可以使用加号“+”和乘号“*”进行运算。这就意味着它们可以组合和复制，运算后会生成一个新的元组。

(4)元组是不可变的：

所谓元组的不可变指的是元组所指向的内存中的内容不可变，代码如下：

tup = (1, 2, 3, 4, 5, 6)     
print(tup)
print(id(tup)) # 查看内存地址     

tup = (1,)    
print(tup)
print(id(tup))  

(1, 2, 3, 4, 5, 6)
2410126556800
(1,)
2410127458800

从以上实例可以看出，重新赋值的元组（tup），绑定到新的对象了，不是修改了原来的对象。

5)Dictionary字典

字典是另一种可变容器模型，且可存储任意类型对象。 字典的存储单元是成对出现的key: value，用冒号“:”分割；每个对之间用逗号“,”分割，整个字典包括在花括号“{}”中，代码如下：d = {key1: val1, key2: val2}

# 创建空字典使用大括号{}创建    
emptyDict = {}    
# 也可以使用函数dict()构建    
emptyDict = dict()

字典中，键必须是唯一的，但值可以不唯一。且值可以取任何数据类型，但是键必须是不可变的数据类型，如字符串、数字。代码如下：

tinydict = {'name': 'VenusAI', 'likes': 123, 'url': 'www.aideeplearning.cn'}

函数dict.keys()或dict.values()可以返回字典的键值对，代码如下：

d = {"name":"VenusAI", "age":7}    
print(d.items() )       
print(d.keys()  )    
print(d.values()  )   

dict_items([('name', 'VenusAI'), ('age', 7)])
dict_keys(['name', 'age'])
dict_values(['VenusAI', 7])

(1)字典的增删改查：

增：向字典添加新内容的方法是增加新的键/值对，修改或删除已有键/值对，代码如下：

tinydict = {'Name': 'VenusAI', 'Age': 7, 'Class': 'First'}    
tinydict['Age'] = 9 # 更新Age    
tinydict['Web'] = "www.aideeplearning.cn"  # 添加信息    
print ("tinydict['Age']: ", tinydict['Age'])     
print ("tinydict['Web']: ", tinydict['Web'])  
print(tinydict)

tinydict['Age']:  9
tinydict['Web']:  www.aideeplearning.cn
{'Name': 'VenusAI', 'Age': 9, 'Class': 'First', 'Web': 'www.aideeplearning.cn'}

删：能删单一的元素，也能清空字典，清空只需一项操作。显式删除一个字典用del命令，代码如下：

tinydict = {'Name': 'VenusAI', 'Age': 7, 'Web': 'www.aideeplearning.cn'}    
print(tinydict)
del tinydict['Name'] # 删除键 'Name'  
print(tinydict)
tinydict.clear()     # 清空字典
print(tinydict)
del tinydict         # 删除字典
print(tinydict)

{'Name': 'VenusAI', 'Age': 7, 'Web': 'www.aideeplearning.cn'}
{'Age': 7, 'Web': 'www.aideeplearning.cn'}
{}

---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
Cell In[58], line 8
      6 print(tinydict)
      7 del tinydict         # 删除字典
----> 8 print(tinydict)

NameError: name 'tinydict' is not defined

改：通过索引关键字赋值的方式修改键值，代码如下：

tinydict = {'Name': 'VenusAI', 'Age': 7, 'Web': 'www.aideeplearning.cn'}    
tinydict['Name'] = 'Venus'    
print(tinydict)

{'Name': 'Venus', 'Age': 7, 'Web': 'www.aideeplearning.cn'}

查：通过索引关键字的方法查询键值，注意：如果用字典里没有的键访问数据，会输出错误，代码如下：

tinydict =  {'Name': 'VenusAI', 'Age': 7, 'Web': 'www.aideeplearning.cn'}    
print ("tinydict['Web']: ", tinydict['Web']) 

tinydict['Web']:  www.aideeplearning.cn

(2)关于字典的两个重要点：

第一，不允许同一个键出现两次。创建时如果同一个键被赋值两次，后一个值会被记住，代码如下：

tinydict = {'Name': 'Venus', 'Age': 7, 'Name': 'VenusAI'}    
print ("tinydict['Name']: ", tinydict['Name']) 

tinydict['Name']:  VenusAI

第二，键必须不可变，所以可以用数字、字符串或元组充当，而用列表就不行，使用列表作为键时输出将会报错，代码如下：

tinydict = {['Name']: 'VenusAI', 'Age': 7}

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[62], line 1
----> 1 tinydict = {['Name']: 'VenusAI', 'Age': 7}

TypeError: unhashable type: 'list'

6)Set集合

集合是一个无序的不重复元素序列。可以使用大括号“{}”或者set()函数创建集合，注意：创建一个空集合必须用set()而不是set{}，因为“{}”是用来创建一个空字典。代码如下：

param = {value01,value02,...}

param = set(value)

由于集合的性质之一是存放不重复的元素，因此可以用于去重功能，代码如下：

basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}    
print(basket) 

{'banana', 'apple', 'pear', 'orange'}

(1)两个集合间的运算，代码如下：

a = set('abracadabra')    
b = set('alacazam')    
           
# 集合a中包含而集合b中不包含的元素    
print(a - b )       
# 集合a或b中包含的所有元素    
print(a | b)        
# 集合a和b中都包含了的元素    
print(a & b)        
# 不同时包含于a和b的元素
print(a ^ b)      

{'b', 'r', 'd'}
{'l', 'r', 'm', 'b', 'z', 'd', 'c', 'a'}
{'c', 'a'}
{'b', 'z', 'l', 'd', 'r', 'm'}

(2)集合的增删改查：

增：将元素x添加到集合s中，如果元素已存在，则不进行任何操作，代码如下：

tinyset = set(("Google", "Baidu", "VenusAI"))    
tinyset.add("Facebook")    
print(tinyset) 

{'VenusAI', 'Google', 'Facebook', 'Baidu'}

还有一个方法，也可以添加元素，且参数可以是列表、元组、字典等，语法格式s.update(x)，其中，x可以有多个，用逗号分开，代码如下：

tinyset = set(("Google", "Amazon", "Taobao"))    
tinyset.update({1,3})    
print(tinyset)  

{1, 'Google', 3, 'Amazon', 'Taobao'}

删：将元素x从集合s中移除，如果元素不存在，则会发生错误。语法格式s.remove(x)，代码如下：

tinyset = set(("Google",  "Baidu", "Amazon"))    
tinyset.clear()    
print(tinyset)   

set()

此外还有一个方法也是移除集合中的元素，并且如果元素不存在，不会发生错误。格式为s.discard(x)。

清空集合的语法格式为s.clear()。

改：集合不支持索引，因此修改元素时一般把集合数据类型转换成列表数据类型。

查：判断元素是否在集合中存在，代码如下：

tinyset = set(("Google", "Baidu", "Amazon"))    
print( "Amazon" in tinyset)      
print( "FaceBook" in tinyset)      

tup=(1,23)
tup=(2,)

True
False

3. 小结

（1）可变数据类型：列表、字典、集合。总结这三种数据类型的增删改查方法。

（2）不可变数据类型：元组、数字、字符串。注意，一些初学者可能认为他们可变的原因实际上是这些变量名可以被重新赋值，造成了可变的假象。但是索引这些变量名中的元素是不可被重新赋值的。

（3）下标索引：所谓“下标”，就是编号，就好比超市中的存储柜的编号，通过这个编号就能找到相应的存储空间。下标分为正索引和负索引。字符串、列表、元组都支持下标索引，字典则是关键字索引。

（4）切片：切片是指对操作的对象截取其中一部分的操作。字符串、列表、元组都支持切片操作。切片的语法：[起始:结束:步长]。

注意：选取的区间属于左闭右开型，即从“起始”位开始，到“结束”位的前一位结束（不包含结束位本身），以字符串为例讲解。 如果取出一部分，且间隔取样，则可以在中括号“[]”中，代码如下：

s = "abcdefghi"     
print(s[1:7:2])
# bdf

bdf

（5）公共方法，Python包含的内置函数见下表。