Python 数据类型及数据类型转换

Python 数据类型及数据类型转换

数据类型

基本数据类型

区别于 C 语言，Python 中的变量没有类型，这里说的类型是变量所指的内存中对象的类型。同时，Python 中的变量不需要声明，每个变量只有在赋值以后才会被创建。

与 C 语言类似，Python 中的=用于给变量赋值。等号左侧是变量名，右侧则是需要存储在变量中的值。

counter = 100
miles = 1000.0
name = "John"print(counter)
print(miles)
print(name)

输出结果：

100
1000.0
John

多个变量赋值

Python 允许同时为多个变量赋值，有如下两种形式：

a = b = c = 1

创建一个整型对象，其值为1，并从后往前赋值，三个变量都有相同的值。

a, b, c = 1, 2, "John"

以上是将 1、2、“John” 分别赋值给变量 a、b、c。

a, b, c = 1, 2, "John"
print(a)
print(b)
print(c)

输出结果：

1
2
John

我们可以通过type()函数来查看变量的类型。

a = 1
b = 2.0
c = "John"print(type(a))
print(type(b))
print(type(c))

输出结果：

<class 'int'>
<class 'float'>
<class 'str'>

标准数据类型

Python 3 中常见的标准数据类型有以下几种：

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

其中：

• 不可变数据类型：数字（Number）、字符串（String）、元组（Tuple）
• 可变数据类型：列表（List）、集合（Set）、字典（Dictionary）

这里的不可变数据类型指的是，一旦创建了一个不可变对象，就不能对其进行修改。而可变数据类型则可以在创建后进行修改。

不能修改指的是不能改变变量所指的对象。当你试图对变量进行修改时，其实是重新创建一个新的变量。因此在你修改一个变量时，其实是销毁该变量并重新创建一个同名变量，举例如下：

a = 1
b = a
a = 2
print(a)
print(b)

输出结果：

2
1

可以看到，变量 a 的值改变了，但是变量 b 的值没有改变。这是因为起初变量 a 指向的是一个整型对象（这里我们设为x），而变量 b 指向的同样是此时变量 a 指向的对象x。当变量 a 指向的对象改变时，变量 b 指向的对象仍然是起初的对象x，不会改变。

Number 数字

Python 中的数字类型包括整型（int）、浮点型（float）、复数（complex）等。

整型是 Python 中最常用的数字类型，用于表示整数。在 Python 3 中，整型没有大小限制，可以表示任意大的整数。因此 Python 3 只有一种整型类型，即 int。

a = 100
b = 1000
print(a)
print(b)

输出结果：

100
1000

另外，在Python 3 中，bool 是整型的子类型，用于表示布尔值（True 或 False）。

Python 还支持复数类型，复数由实部和虚部组成，例如：

a = 1 + 2j
print(a)

输出结果：

(1+2j)

其中，复数的实部和虚部都是浮点数。

String 字符串

Python 中字符串支持单引号、双引号和三引号。

a = 'hello'
b = "world"
c = '''hello world'''
d = """hello world"""
print(a)
print(b)
print(c)
print(d)

输出结果：

hello
world
hello world
hello world

单引号和双引号的字符串是等价的，而三引号的字符串可以跨越多行，例如：

a = '''hello
world'''
print(a)

输出结果：

hello
world

如果不想转义特殊字符，可以在字符串前添加一个r，即可使用原始字符串，例如：

a = r"hello\nworld"
print(a)

输出结果：

hello\nworld

字符串索引

字符串有两种索引方式，从左往右以 0 开始，从右往左以 -1 开始。

a = "hello world"
print(a[0])
print(a[1])
print(a[-1])
print(a[-2])

输出结果：

h
e
d
l

字符串切片

字符串切片是指从字符串中取出一个子字符串。切片的语法为：

a[start:end:step]

其中，start 表示切片的起始位置（包含），end 表示切片的结束位置（不包含），step 表示切片的步长。

如果不指定 start，则默认从 0 开始；如果不指定 end，则默认到字符串的结束；如果不指定 step，则默认步长为 1。若步长为负数，则表示从右往左切片。

a = "hello world"
print(a[0:5])
print(a[0:5:2])
print(a[::-1])

输出结果：

hello
hlo
dlrow olleh

这里注意区分索引和切片，索引是指获取字符串中的一个字符，而切片是指获取字符串中的一个子字符串。

他们对于字符串的操作不同，索引只能获取一个字符，而切片可以获取多个字符。

他们对于字符串的标号是相同的，都是从左往右时：从 0 开始，到字符串长度减 1 结束；从右往左时：从 -1 开始，到 -字符串长度 结束。

但是切片的范围是左闭右开的，即包含起始位置，不包含结束位置。

• 以上例子中我们可以清晰的看到，当执行print(a[0:5])时，输出的是从索引 0 到索引 4 的字符，即hello。

• 当执行print(a[0:5:2])时，输出的是从索引 0 到索引 4 的字符，步长为 2，即hlo。

因此，当我们需要切片到字符串的末尾时，不能将结束位置设置为-1，因为-1表示的是字符串的最后一个字符，而不是字符串的末尾。

正确的做法是将结束位置设置为字符串的长度或者不指定结束位置，例如：

• 不指定结束位置：

a = "hello world"
print(a[0:])

输出结果：

hello world

• 指定结束位置为字符串长度：

a = "hello world"
print(a[0:len(a)])

输出结果：

hello world

同样，String 是不能修改的，即不能改变字符串中的某个字符。如果需要修改字符串，只能创建一个新的字符串。

bool 布尔值

Python 中的布尔值只有两个：True 和 False。

布尔值可以用于条件判断、循环等场景。

a = True
b = False
print(a)
print(b)

输出结果：

True
False

前面我们提到，Python 中的数字类型包括整型（int）、浮点型（float）、复数（complex）等。

而布尔值是整型的子类型，因此布尔值可以进行数字类型的运算和比较。

• 布尔值可以进行数字类型的运算。

• 布尔值可以进行比较运算。

• 布尔类型可以和逻辑运算符一起使用，包括 and、or 和 not。

• True 等价于 1，False 等价于 0。

例如：

a = True
b = False
print(a + 1)
print(b + 1)

输出结果：

2
1

另外，布尔类型和其他数据类型可以互相转换：

• 布尔类型转换为其他类型时：
  • True 转换为 1
  • False 转换为 0
• 其他类型转换为布尔类型时：

  • None、零（包括 0、0.0、0j）、False、空字符串、空列表、空元组、空字典、空集合、空映射等转换为 False

  • 其他值转换为 True

例如：

a = 1
b = 0
c = ''
d = []
e = ()
f = {}
g = set()
h = 100
print(bool(a))    # True
print(bool(b))    # False
print(bool(c))    # False
print(bool(d))    # False
print(bool(e))    # False
print(bool(f))    # False
print(bool(g))    # False
print(bool(h))    # True

List 列表

List （列表）是 Python 中使用最频繁的数据类型。

列表是写在方括号 [] 中的，列表中的元素用逗号 , 隔开。

与字符串类似，列表也支持索引和切片。索引和切片的语法与字符串相同。

列表中的元素类型可以不相同，它甚至可以包含列表实现嵌套，例如：

a = [1, 2, 3, 'hello', 'world', [1, 2, 3]]
print(a)

输出结果：

[1, 2, 3, 'hello', 'world', [1, 2, 3]]

列表中的元素是可以改变的：

a = [1, 2, 3, 'hello', 'world', [1, 2, 3]]
a[0] = 100
print(a)

输出结果：

[100, 2, 3, 'hello', 'world', [1, 2, 3]]

Tuple 元组

Tuple（元组）与列表类似，区别在于元组中的元素不能修改。

元组是写在圆括号 () 中的，元组中的元素用逗号 , 隔开。

元组中的元素类型可以不相同，它同样可以包含元组实现嵌套，例如：

a = (1, 2, 3, 'hello', 'world', (1, 2, 3))
print(a)

输出结果：

(1, 2, 3, 'hello', 'world', (1, 2, 3))

元组的索引和切片与列表、字符串相同，在此不再赘述。

从另一个角度来说，字符串是字符的元组，因此也可以将字符串视作特殊的元组。

当你要创建一个只有 0 个或者 1 个元素的元组时，需要在元素后面添加一个逗号，否则 Python 会认为这只是一个数学运算中的符号，例如：

a = (1,)
b = ()
print(a)
print(b)

输出结果：

(1,)
()

Set 集合

Set（集合）是 Python 中一种无序、可变的数据类型，用于存储唯一的元素。

集合中的元素不会重复。

集合有两种创建方式：

• 直接创建
• 使用 set() 函数创建

直接创建集合时，需要在元素之间用逗号 , 隔开，元素可以是任意类型，例如：

a = {1, 2, 3, 'hello', 'world',1,2,3}
print(a)

输出结果：

{1, 2, 3, 'hello', 'world'} #重复元素会被自动去掉

当你需要创建一个空集合时，不能使用 {} 来创建，因为 {} 会被解释为一个空字典。

正确的做法是使用 set() 函数来创建一个空集合，例如：

a = set()
b = set('hello world')
print(a)
print(b)
print(type(a))
print(type(b))

输出结果：

set()
{'h', 'd', 'l', 'o', 'w', 'r', 'e'} #集合中的元素是无序的
<class 'set'>
<class 'set'>

集合可以进行并、交、差、补等运算。

例如：

a = {1, 2, 3, 4, 5}
b = {3, 4, 5, 6, 7}
print(a | b)  # 并集
print(a & b)  # 交集
print(a - b)  # 差集
print(a ^ b)  # 补集（a 和 b中不同时存在的元素）

输出结果：

{1, 2, 3, 4, 5, 6, 7}
{3, 4, 5}
{1, 2}
{1, 2, 6, 7}

Dictionary 字典

Dictionary（字典）是 Python 中一种无序、可变的数据类型，用于存储键值对。

字典中的每个元素都由一个键和一个值组成，它是一个无序的键（key）：值（value） 对，元素之间用逗号 , 隔开。

字典的键必须是不可变的类型，例如：字符串、数字、元组等，而值可以是任意类型。

字典有两种创建方式：

• 直接创建
• 使用 dict() 函数创建

#!/usr/bin/python3dict = {}   #先创建一个空字典
dict['one'] = "exm" #可以直接在空字典中添加键值对
dict[2]     = "zem"tinydict = {'first-name': 'exm','last-name': 'zem', 'code':1}print(dict)
print (dict['one'])       # 输出键为 'one' 的值
print (dict[2])           # 输出键为 2 的值
print (tinydict)          # 输出完整的字典
print (tinydict.keys())   # 输出所有键
print (tinydict.values()) # 输出所有值

输出结果：

{'one': 'exm', 2: 'zem'}
exm
zem
{'first-name': 'exm', 'last-name': 'zem', 'code': 1}
dict_keys(['first-name', 'last-name', 'code'])
dict_values(['exm', 'zem', 1])

构造函数 dict() 可以直接从键值对序列中构建字典如下：

dict = dict([('one', 1), ('two', 2), ('three', 3)])
print(dict)

输出结果：

{'one': 1, 'two': 2, 'three': 3}

还可以使用关键字参数来创建字典，例如：

dict = dict(one=1, two=2, three=3)
print(dict)

输出结果：

{'one': 1, 'two': 2, 'three': 3}

此外，还可以通过字典推导式来创建字典，例如：

dict = {x: x**2 for x in (2, 4, 6)}
print(dict)

输出结果：

{2: 4, 4: 16, 6: 36}

bytes 类型

bytes 类型是 Python 中一种不可变的序列类型，用于存储二进制数据。

bytes 类型的对象可以通过在字符串前添加 b 或 B 前缀来创建，例如：

a = b'hello world'
b = B'hello world'
print(a)
print(b)

输出结果：

b'hello world'
b'hello world'

bytes 类型中的元素是整数，范围从 0 到 255，而不是 Unicode 字符。

例如：

a = b'hello world'
print(a[0])

输出结果：

104

可以使用切片来访问 bytes 类型中的元素，例如：

a = b'hello world'
print(a[0:5])

输出结果：

b'hello'

bytes 类型通常用于处理二进制数据，比如图像文件、音频文件、视频文件等等。在网络编程中，也经常使用 bytes 类型来传输二进制数据。

数据类型转换

有时候我们需要将一个数据类型转换为另一个数据类型，比如将字符串转换为整数，将整数转换为字符串等等。一般情况下，我们只需要将数据类型作为函数名即可。

Python 数据类型转换分为两种：

• 隐式类型转换
• 显式类型转换

隐式类型转换

隐式类型转换指的是 Python 自动将一种数据类型转换为另一种数据类型，不需要我们手动干预。

例如：

a = 10
b = 20.0
c = a + b
print(c)
print(type(c))

输出结果：

30.0
<class 'float'>

可以看到，当我们将一个整数和一个浮点数相加时，Python 自动将整数转换为浮点数，然后进行相加。

当我们将整型变量和字符串变量相加时：

num_int = 123
num_str = "456"print("num_int 数据类型为:",type(num_int))
print("num_str 数据类型为:",type(num_str))print(num_int+num_str)

输出结果：

num_int 数据类型为: <class 'int'>
num_str 数据类型为: <class 'str'>
Traceback (most recent call last):File "C:\Users\22608\Desktop\CODE\Python\Python数据类型及数据类型转换.py", line 12, in <module>print(num_int+num_str)
TypeError: unsupported operand type(s) for +: 'int' and 'str'

可以看到，当我们将一个整数和一个字符串相加时，Python 抛出了一个类型错误异常。这是因为整数和字符串是不同的数据类型，不能直接相加。

这时候，我们就需要用到显式类型转换了。

显式类型转换

显式类型转换指的是 Python 手动将一种数据类型转换为另一种数据类型，需要我们手动干预。

实现方法就是利用int()、float()、str()等函数进行类型转换。

例如：

x_int = int(1)      #x_int 结果为 1
y_int = int(2.8)   #y_int 结果为 2
z_int = int("3")    #z_int 结果为 3
x_float = float(1)  #x_float 结果为 1.0
y_float = float(2.8)#y_float 结果为 2.8
z_float = float("3.2")#z_float 结果为 3.2
x_str = str(1)      #x_str 结果为 "1"
y_str = str(2.8)    #y_str 结果为 "2.8"
z_str = str("3")    #z_str 结果为 "3"

实际运算中，我们可以将不同类型的变量进行转换，然后进行运算。

x_int = 123
y_str = "456print("x_int 数据类型为",type(x_int))
print("转换前y_str 数据类型为",type(y_str))y_int = int(y_str)
print("转换后y_str 数据类型为",type(y_int))sum = x_int + y_int
print("sum 结果为",sum)
print("sum 数据类型为",type(sum))

输出结果：

x_int 数据类型为 <class 'int'>
转换前y_str 数据类型为 <class 'str'>
转换后y_str 数据类型为 <class 'int'>
sum 结果为 579
sum 数据类型为 <class 'int'>