本文使用 Python 版本为 3.9.5

一、概述

Python3 中有六个标准的数据类型：

• Number（数字）
• String（字符串）
• List（列表）
• Tuple（元组）
• Set（集合）
• Dictionary（字典）

由于Python会自动进行隐式转换，所以我们在使用的过程中，无需事先声明变量名及其类型，直接赋值即可创建任意类型的对象变量。不仅变量的值是可以变化的，变量的类型可以随时变化。

a = True
type(a)		#结果：<class 'bool'>
a = 2
type(a)		#结果：<class 'int'>
a = "abc"
type(a)		#结果：<class 'str'>

Python 中的变量不直接存储值，而是存储了值的内存地址 / 引用
，我们可以使用函数 id(变量名 / 值)，来查看一个变量的地址。

id(变量名 / 值)

我们还可以使用 函数 type(变量名 / 值)，来查看一个变量的类型。

type(变量名 / 值)

虽然 Python 无需显式声明变量类型，但 Python 是一门强类型语言。

另外，切记变量必须以字母、数字、下划线命名，但不应与关键字冲突，且应在不确定的情况下，尽量避免下划线命名（下划线在 Python 中拥有特殊含义）

二、数字

1、整数型 (int)

整数类型，

#定义int类型的变量
a = -1
b = 2
c = 2
#打印这两个变量
print(a)		#结果：-1
print(b)		#结果：2
#进行简单运算，并打印结果
print(a + b)	#加法，结果：1
print(a - b)	#减法，结果：-3
print(a * b)	#乘法，结果：-2
print(a / b)	#除法，结果：-0.5
print(a % b)	#取模，结果：1
print(a ** b)	#幂乘，等同于内置函数Pow()，结果：1
#使用type()函数，查看数据类型
type(a)			#结果：<class 'int'>
#使用id()函数，查看数据地址
id(b)			#结果：139656112220496
id(c)			#结果：139656112220496

2、浮点型 (float)

浮点类型用以表示小数，

#定义float类型的变量
a = 1.1
b = -0.5
#打印这两个变量
print(a)		  #结果：1.1
print(b)		  #结果：-0.5
#实数相减，结果有所偏差
print(0.3 - 0.2)  #结果：0.09999999999999998
#所以应尽量避免直接比较实数大小
print(0.3 - 0.2 == 0.1)			#结果：False
#可以依据二者之差的绝对值是否足够小，判断两实数是否相等
print(abs(0.3 - 0.2 - 0.1) < 1e-6)	   #1e-6代表10^6，结果：True
#使用type()函数，查看数据类型
type(a)			  #结果：<class 'float'>
#可以使用'_'作为分隔符，提高数字的阅读性：
print(1_000_000_000)		#结果：1000000000
print(1_0000_0000_0000)		#结果：1000000000000

3、复数型 (complex)

python基本类型自带复数属性，

#定义complex类型的变量
a = 1 + 2j
b = -2 - 4j
#打印这两个变量
print(a)		#结果：(1+2j)
print(b)		#结果：(-2-4j)
#使用type()函数，查看数据类型
type(a)			#结果：<class 'complex'>

4、布尔型 (bool)

布尔逻辑值，拥有两种状态：True，False

#定义两个bool类型的变量
a = True
b = False
#打印这两个变量
print(a)			#结果：True
print(b)			#结果：False
print(1 + a)		#结果：2
print(a + b)		#结果：1
#使用type()函数，查看数据类型
type(True)			#结果：<class 'bool'>

可以看到，在 Python 中，布尔类型可以直接参与其他数字类型的运算，True 等同于 1，False则等同于 0。

三、字符串 (str)

Python 中的字符串声明有三种方法，分别是：单引号、双引号、三引号。

#定义两个str类型的变量
a = 'aa'
b = "bb"
c = '''cc'''
#打印这两个变量
print(a)			#结果：aa
print(b)			#结果：bb
print(c)			#结果：cc
#连接字符串
print(a + b)		#结果：aacc
#使用type()函数，查看数据类型
type(a)				#结果：<class 'str'>

四、字节串 (bytes)

对str类型的字符串，调用其 encode() 方法编码得到对应的 bytes 字节串，反之，调用 bytes 字节串的 decode() 方法，指定正确的编码格式，得到对应的 str 字符串，串前加 b 代表字节串。

#定义字符串
s = 'hello world'
#确定类型
type(s)			#<class 'str'>
# utf-8 编码
r = s.encode('utf-8')		#b'hello world'
#确定类型
type(r)			#<class 'bytes'>
# utf-8 解码
b'hello world'.decode('utf-8')	#'hello world'
# gbk 编码
x = '橘子'
x.encode('gbk')			#b'\xe9\xd9\xd7\xd3'
# gbk 解码
b'\xe9\xd9\xd7\xd3'.decode('gbk')	#'橘子'

五、容器（序列结构）

1、列表 (list)

• 定界符：方括号[ ]
• 元素有序、可变、可重复，下标为序号，对元素没有要求，可以存放任何类型的数据。
• 元素查找速度慢，尾部的增删速度快。

#创建列表
a = ['a','b','haha','banana','e']	#创建有值列表
a = []		#创建空列表
a = list()	#创建空列表
#元组  -->  列表
a = list((1,2,3,4,5))
#range对象  -->  列表
b = list(range(1,10,2))
#字符串  -->   列表
list('hello!')	#['h', 'e', 'l', 'l', 'o', '!']
#集合  -->   列表
list({3,7,5})
#字典“键”   -->  列表
list({'a':3,'b':9,'c':78})	#['a','b','c']
#字典“键:值”  -->   列表
a = list({'a':3,'b':9,'c':78}.items())	#[('b',9),('c',78),('a',73)]
#根据下标访问元素
a[0]	#('a', 3)

操作列表：

#创建列表
a = [1,2,3]
#追加元素	append(x):属于原地操作，即不影响列表对象内存
a.append(4)		#[1,2,3,4]
#索引插入	insert(index, x):属于原地操作
a.insert(2,0)	#[1,2,0,3,4]
#删除元素	remove(x):删除第一个值为x的元素，如果不存在x则抛出异常，属于原地操作
a.remove(0)		#[1,2,3,4]
#弹出元素	pop([index]):默认删除并返回列表尾元素，可传入索引，弹出列表中间元素，如若索引越界，则返回异常
a.pop()			#4  #[1,2,3]
a.pop(1)		#2  #[1,3]
#清空元素	clear():原地操作
a.clear()		#[]
#追加列表	exted(L):传入列表，属于原地操作
a.extend(['a','v','c','p'])		#['a','v','c','p']
#返回元素索引 index(x):返回列表中第一个x的索引，若不存在则抛出异常
a.index('c')	#2  #['a','v','c','p']
#翻转列表	reverse()：原地翻转
a.reverse()		#['p', 'c', 'v', 'a']
#列表排序	sort(Key=None,reverse=False),Key指定排序规则，reverse:Fals升序，True降序，原地排序
a.sort()		#['a', 'c', 'p', 'v']
a.sort(reverse = True)		#['v', 'p', 'c', 'a']

2、元组 (tuple)

• 定界符：( )
• 元素有序、不可变、可重复，下标为序号（元组支持双向索引），对元素没有要求，可以存放任何类型的数据。
• 元素查找速度慢，不允许对元素做增删操作。
• 仅有一个元素的元组的定义方式：(x,)，必须在其末尾加上逗号，否则会被视为普通的数字

#创建元组
t = (1,2,3,4)	//(1,2,3,4)
#根据下标访问访问元素，0为首元素索引
t[0]			//1
#逆向访问，-1为末尾元素索引，元组支持双向索引
t[-1]			//4
#创建空元组
x = ()
y = tuple()
#range对象  -->  元组
z = tuple(range(4))			#(0,1,2,3)
#列表   -->   元组
r = tuple(['a','b','c'])	#('a','b','c')

3、字典 (dict)

• 定界符：{ }
• 元素无序、可变、“键”不可重复、“值”可重复，键值对应。对元素没有要求，可以存放任何类型的数据，但“键”必须可哈希。
• 元素查找速度快，增删操作快。

#空字典
x = dict()
y = {}
#创建字典，Key为ID,Value为Name
d = {1:'C++',2:'Java',3:'Python',4:'C',5:'Rust'}
#按Key访问Value，若不存在该Key，则抛出异常
d[3]			#'Python'
#创建其他键类型字典
f = {'a':'apple','b':'banana','c':'carrot'}
#新增其他元素
d.setdefault(6,'PHP')	#{1:'C++',2:'Java',3:'Python',4:'C',5:'Rust',6:'PHP'}
d[7] = 'Ruby'	#{1: 'C++', 2: 'Java', 3: 'Python', 4: 'C', 5: 'Rust', 6: 'PHP', 7: 'Ruby'}
#修改元素
d[7] = 'JavaScript'		#{1: 'C++', 2: 'Java', 3: 'Python', 4: 'C', 5: 'Rust', 6: 'PHP', 7: 'JavaScript'}
#按字典更新
d.update({1:'A',2:'B'})		#{1: 'A', 2: 'B', 3: 'Python', 4: 'C', 5: 'Rust', 6: 'PHP', 7: 'JavaScript'}
#删除字典元素
del d[7]		#{1: 'A', 2: 'B', 3: 'Python', 4: 'C', 5: 'Rust', 6: 'PHP'}
#弹出并删除指定元素
d.popitem()		#(6, 'PHP')		#{1: 'A', 2: 'B', 3: 'Python', 4: 'C', 5: 'Rust'}
d.pop(2)		#'B'			#{1: 'A', 3: 'Python', 4: 'C', 5: 'Rust'}

4、集合 (set、frozenset)

• 定界符：{ }
• 元素无序、可变、不可重复，元素必须可哈希。
• 元素查找速度快，增删速度快

#创建集合，验证其不可重复性，集合会自动忽略创建时的重复元素
a = {1,2,2,2,3}		#集合a：{1,2,3}
#添加元素
a.add(4)			#{1,2,3,4}
#更新元素，自动忽略重复元素
a.add({4,5})		#{1, 2, 3, 4, 5}
#删除元素，不存在则忽略该操作
a.discard(9)		#忽略该操作：{1, 2, 3, 4, 5}
#删除元素，不存在则抛出异常
a.remove(4)			#{1,2,3,5}
#清空集合
a.clear()			#{}

集合运算

a = {1,2,3,4}
b = {2,4,7,8}
c = {2,4}
#并集
a | b			#{1, 2, 3, 4, 7, 8}
#交集
a & b			#{2,4}
{3} & {4}		#set()
#差集
a - b			#{1,3}
#对称差集
a ^ b			#{1, 3, 7, 8}
a.symmetric_difference(b)		#{1, 3, 7, 8}
#比较集合大小（包含关系）
a > b			#False
b > c			#True
#验证参数是否为调用者子集
c.issubset(b)	#True
#判断两集合交集是否为空，交集为空 返回True
a.isdisjoint(b)	#False