Python 的数据类型有哪些？（融合面试基础知识）

本篇博文在回答这个问题的基础上融合了一些python面试时的基础知识，总结过程中参考了以下几篇文章：

Python中的数类型有哪些？用通俗易懂的一篇文章，带你全面了解python中的数据类型！很适合新手小白查阅！ - 知乎

Python基础-元组_print(tuple1)和printtype(tuple1)-CSDN博客

Python--列表_python列表可以放不同类型-CSDN博客

python的可变数据类型和不可变数据类型_世界的LXL的博客-CSDN博客

1、简单类型：int、float、str、bool、空值None、复数complex

• class 一般称之为 类 或是 对象。在python中，一切都是对象。即不仅是具体的事物称为对象，字符串、函数等也都是对象。
• 空值None是python中的一个特殊的值，表示空（没有），也是 类型 NoneType的唯一值。None 并不等同于 0 或者是 空的字符串，也或者不等同于 空列表，空字典等容器类数据。None 仅仅是python定义的一个特殊的值。在定义函数时，返回值中，很容易遇到 空值None。
• 数据类型可变和数据类型不可变主要是指当该数据类型的值发生改变时，地址有没有随之改变，如果存储地址改变了，则是不可变的数据类型，如果地址没有改变则是可变的数据类型。结论是：int (整型),str（字符串） ,tuple（元组） 是不可变的数据类型，dict（字典）,set（集合）,list（列表）是可变的数据类型。

# python 的复数表示（两种）
a = 3 + 4j
print(a ** 2)  # (-7+24j)
 
b = complex(3, 4)
print(b ** 2)  # (-7+24j)
 
# 字符转数字
print(ord('5'))  # 53
print(ord('5') - ord('0'))  # 5
 
# str 没有 reverse 函数，list有
string = '12345'
str_list = list(string)
str_list.reverse()
print(str_list)  # ['5', '4', '3', '2', '1']
 
# str 反转
string[::-1]
 
# id求地址，type求类型
a = 1
print(type(1), id(a))  # <class 'int'> 1538554816816
a = 2
print(type(a), id(a))  # <class 'int'> 1538554816848

2、容器类型：列表list、元祖tuple、字典dict、集合set

• 同一个列表中元素的数据类型可以各不相同,可以同时包含整数、实数、字符串等基本类型的元素,也可以包含列表、元组、集合、函数以及其他任意对象。
• 元组里的元素，设置后，就不能更改里面的元素了。元组里的元素类型，不限于 数字，字符串，也可以是列表，元组，字典，集合，例如：(123, 'abc', '你好！', ['hello!', '333'], ('hello!', '333') , {'hello!': '333'}, {'hello!', '333'})
• 元组的应用场景：如果想要存储多个数据，但这些数据不能修改，这个时候就用元组。而元组与列表的区别就在于，元组里的元素不能修改，列表里的元素可以修改。
• 字典里【元素的键】是不可变的，比如： 字符串，数字，元组，都是不可变动的对象，一旦设置了，就是固定的值，可以作为 【元素的键】；不可哈希类型不能作为字典里元素的键，（当你用列表list 作为 字典里元素的键时，你会遇到这样的报错，“TypeError: unhashable type: 'list'”，通俗来说，不能变动的唯一的对象才能被哈希函数哈希）。列表，字典，集合不能作为字典里元素的键。
• 字典中【元素的值】不用是唯一的，可以重复出现在不同的 【元素的键】的值中，可以是任何数据类型，比如：数字，字符串，列表，元组，字典，集合。
• 集合里的元素类型，是 数字，字符串 ，元组类型，不可哈希类型不能作为集合的元素。

# 空的初始化
lst = list()  or  lst = []
tup = tuple() or  tup = ()
dic = dict()  or  dic = {}
st = set()
 
# 非空初始化
lst = [1, 2, 3, 4]
tup = (1, 2, 3, 4)
dic = {'key1': 1, 'key2': 2}
st = {1, 2, 3, 3, 4, 4}  or  st = set([1, 2, 3, 3, 4, 4])
 
 
# 判断是否相等
list1 = [1, 2, 3, 4]
list2 = [1, 2, 3, 4]
print(list1 == list2)  # True
tup1 = (1, 2, 3, 4)
tup2 = (1, 2, 3, 4)
print(tup1 == tup2)  # True
set1 = {1, 2, 3, 4}
set2 = {1, 2, 3, 3, 4, 4}
print(set1 == set2)  # True
dic1 = {'key1': 1, 'key2': 2}
dic2 = {'key1': 1, 'key2': 2}
print(dic1 == dic2)  # True
 
 
# 集合{1, 2, 3, 4}和{1, 2, 3, 3, 4, 4}属于重复元素
set1 = {1, 2, 3, 4}
set2 = {1, 2, 3, 3, 4, 4}
set3 = set()
set3.add(tuple(set1))
set3.add(tuple(set2))
print(set3)  # {(1, 2, 3, 4)}
 
set1 = {1, 2, 3, 4}
set2 = {1, 2, 3, 3, 4, 4, 5, 5, 5}
set3 = set()
set3.add(tuple(set1))
set3.add(tuple(set2))
print(set3)  # {(1, 2, 3, 4), (1, 2, 3, 4, 5)}
 
 
 
# 列表的初始化
a = list()  # []
b = list(range(5))  # [0, 1, 2, 3, 4]
c = list('cat')  # ['c', 'a', 't']
d = [x**2 for x in range(5)]  # [0,1,4,9,16]
e = [x for x in range(10) if x % 2 == 1]  # [1,3,5,7,9]
f = [x for x in 'alice' if x in 'aeiou']  # ['a','i','e']
lit = ['hello!', 333, [1, 2], (1, 2, 3)]
for i in range(len(lit)):
    print(type(lit[i]))
# <class 'str'>
# <class 'int'>
# <class 'list'>
# <class 'tuple'>
 
 
# 连接两个数组 （两种基本方法）
arr1 = [1, 2, 3]
arr2 = [4, 5, 6]
result = arr1 + arr2
print(result)  # [1, 2, 3, 4, 5, 6]
 
arr1 = [1, 2, 3]
arr2 = [4, 5, 6]
arr1.extend(arr2)
print(arr1)  # [1, 2, 3, 4, 5, 6]
 
 
 
# 元组
tuple1 = (0, 1, 2, 3, 4)
print(type(tuple1))  # <class 'tuple'>
# 定义元组，当元组只有一个数据的时候，这个数据后面最好也添加逗号，
# 否则数据类型为唯一的这个数据的类型
t2 = (1,)
print(type(t2))  # <class 'tuple'>
t3 = (2)
print(type(t3))  # <class 'int'>
t4 = ('hello')
print(type(t4))  # <class 'str'>
# 元组内如果嵌套了一个列表，可以修改列表里面的数据
t1 = ('aa', 'bb', ['test1', 'test2', 'test3'])
t1[2][0] = 'ffffff'
print(t1)  # ('aa', 'bb', ['ffffff', 'test2', 'test3'])
# 元祖的三个常用方法
t1 = (1, 2, 3, 4, 5, 2)
print(t1.index(5))  # 4
print(t1.count(2))  # 2
print(len(t1))  # 6
 
 
 
# set 是可迭代的
st = {1, 2, 4, 3, 4}
for i in st:
    print(i)
 
 
 
# 合并两个字典（两种基本方法）
dict1 = {'a': 10, 'b': 8}
dict2 = {'d': 6, 'c': 4}
dict2.update(dict1)
print(dict2)  # {'d': 6, 'c': 4, 'a': 10, 'b': 8}
 
dict1 = {'a': 10, 'b': 8}
dict2 = {'d': 6, 'c': 4}
res = {**dict1, **dict2}
print(res)  # {'a': 10, 'b': 8, 'd': 6, 'c': 4}
res2 = dict1 | dict2
print(res2)  # {'a': 10, 'b': 8, 'd': 6, 'c': 4}
 
# update方法：重复的键默认替换
dict1 = {'a': 10, 'b': 8}
dict2 = {'a': 6, 'c': 4}
dict2.update(dict1)
print(dict2)  # {'a': 10, 'c': 4, 'b': 8}
 
# ** 方法和 python3.9 中的 | 方法都默认替换掉前面的重复键的键值
dict1 = {'a': 10, 'b': 8}
dict2 = {'a': 6, 'c': 4}
dict3 = {'e': 1, 'c': 2}
res = {**dict1, **dict2, **dict3}
print(res)  # {'a': 6, 'b': 8, 'c': 2, 'e': 1}
res2 = dict1 | dict2 | dict3
print(res2)  # {'a': 6, 'b': 8, 'c': 2, 'e': 1}

3、类类型