Python3 基本数据类型

Python 中的变量不需要声明,它没有类型,每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建

文章目录

一、数据类型介绍

1. 数值类型（Numeric Types）

Python 中有三种主要的数值类型：整数（int）、浮点数（float） 和 复数（complex）。

1.1 整数（int）
  • 描述：整数类型用于表示没有小数点的数字，可以是正整数、负整数或零。
  • 示例 
    1
    2
    3
    a = 42        # 正整数  
    b = -100      # 负整数  
    c = 0         # 零
  • 特点：
    • Python 3 中的整数可以表示任意大小，不会因为值过大而溢出（仅受系统内存限制）。
1.2 浮点数（float）
  • 描述：浮点数用于表示带有小数点的数字或科学计数法表示的数字。
  • 示例： 
    1
    2
    3
    a = 3.14      # 普通浮点数  
    b = -0.001    # 负浮点数  
    c = 1.23e4    # 科学计数法表示的浮点数（1.23 × 10^4）
  • 特点：
    • 浮点数在计算中可能会出现精度问题（例如 0.1 + 0.2 可能不等于 0.3）。
1.3 复数（complex）
  • 描述：复数用于表示形如 a + bj 的复数，其中 a 是实部，b 是虚部，j 是虚数单位。
  • 示例： 
    1
    2
    a = 2 + 3j   # 复数  
    b = -1 + 2j  # 负复数
  • 特点：
    • 复数可以使用内置函数 complex() 创建。
    • 复数可以进行加、减、乘、除等运算。

      注意

      1、Python可以同时为多个变量赋值，如a, b = 1, 2。

      2、一个变量可以通过赋值指向不同类型的对象。

      3、数值的除法包含两个运算符：**/** 返回一个浮点数，**//** 返回一个整数。

      4、在混合计算时，Python会把整型转换成为浮点数。

2. 字符串类型（String）

  • 描述：字符串是由字符组成的序列，可以用单引号 '、双引号 " 或三引号 '''、""" 包裹。

注意：另外，反斜杠()可以作为续行符，表示下一行是上一行的延续。也可以使用 “”“…”“” 或者 ‘’‘…’‘’ 跨越多行。Python 没有单独的字符类型，一个字符就是长度为1的字符串

  • 示例： 
    1
    2
    3
    4
    s1 = 'Hello'  
    s2 = "World"  
    s3 = """这是  
    多行字符串"""
  • 特点：
    • 字符串是不可变的，即一旦创建，字符串内容不能被修改。
    • 可以通过索引访问单个字符，或使用切片操作。
    • 反斜杠可以用来转义，使用r可以让反斜杠不发生转义，表示原始字符串
    • 支持常见的字符串操作，如拼接、分割、查找、替换等。
    • Python中的字符串有两种索引方式，从左往右以0开始，从右往左以-1开始。
    • 可以使用**+** 连接字符串， 星号n ***** 复制当前字符串，n表示复制次数

3. 布尔类型（Boolean）

  • 描述：布尔类型表示 True 或 False 的值，用于逻辑判断和条件表达式中。

    注：在 Python 中，True 和 False 都是关键字，表示布尔值

  • 示例： 
    1
    2
    a = True  
    b = False
  • 特点：
    • 布尔值可以参与数学运算，True 等于 1，False 等于 0。

4. 列表类型（List）

  • 描述：列表是一个有序的可变容器，可以包含不同类型的元素。列表是写在方括号 [] 之间、用逗号分隔开的元素列表。和字符串一样，列表同样可以被索引和截取，列表被截取后返回一个包含所需元素的新列表。

    注：列表中元素的类型可以不相同，支持列表嵌套。

  • 示例： 
    1
    lst = [1, 2, 3, 'hello', 3.14]
  • 特点：
    • 列表是有序的，元素可以通过索引访问。
    • 支持修改、删除、添加元素等操作。
    • 可以包含不同类型的数据。

5. 元组类型（Tuple）

  • 描述：元组与列表类似，但元组是不可变的。元组写在小括号 () 里，元素之间用逗号隔开。

    注：元组中的元素类型也可以不相同

  • 示例： 
    1
    tup = (1, 2, 3, 'hello')
  • 特点：
    • 元组是有序的，元素可以通过索引访问。
    • 元组不可变，无法修改、删除、添加元素。
    • 元组通常用于表示不需要修改的数据集。

6. 字典类型（Dictionary）

  • 描述：列表是有序的对象集合，字典是无序的对象集合。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。字典是一种映射类型，字典用 { } 标识，它是一个无序的 键(key) : 值(value) 的集合。键(key)必须使用不可变类型。在同一个字典中，键(key)必须是唯一的
  • 示例： 
    1
    d = {'name': 'Alice', 'age': 25}
  • 特点：
    • 字典中的元素是无序的，键是唯一的。
    • 通过键访问对应的值。
    • 键必须是不可变的类型（如字符串、元组），而值可以是任意类型。

7. 集合类型（Set）

  • 描述：集合是一个无序的、不重复的元素集合，用于进行数学集合操作。
    集合使用大括号 {} 表示，元素之间用逗号 , 分隔。另外，也可以使用 set() 函数创建集合。

    **注意：**创建一个空集合必须用 set() 而不是 **{ }**，因为 { } 是用来创建一个空字典。

  • 示例： 
    1
    s = {1, 2, 3, 4}
  • 特点：
    • 集合中的元素是唯一的，不允许重复。
    • 支持集合运算，如并集、交集、差集等。

8. None 类型

  • 描述：None 是 Python 中的特殊类型，表示“无值”或“空值”。
  • 示例： 
    1
    a = None
  • 特点：
    • None 经常用于表示函数没有返回值或某个变量为空。

二、可变数据与不可变数据

在 Python 中，数据类型可以分为 可变数据类型 和 不可变数据类型。这两者的主要区别在于对象在内存中的存储方式以及它们是否能够被修改。

可变数据类型

1. 定义
  • 可变数据类型是指对象的值在创建后可以改变。这意味着，当你修改一个可变对象时，它的内存地址不会改变，只会改变对象的内容。
2. 常见的可变数据类型
  • 列表（list）
  • 字典（dict）
  • 集合（set）
3. 特点
  • 可以修改内容：你可以对可变对象的内容进行修改，而不需要创建新的对象。
  • 内存地址不变：修改对象内容时，它的内存地址保持不变。
  • 效率较高：因为它们可以直接在原地修改，不需要创建新的对象，所以效率更高。
4. 案例
1
2
3
4
5
6
7
8
9
10
11
12
13
# 列表是可变的
lst = [1, 2, 3]
print(id(lst))  # 打印列表的内存地址
lst.append(4)   # 修改列表内容
print(lst)      # 输出：[1, 2, 3, 4]
print(id(lst))  # 打印列表的内存地址（不会改变）
# 字典是可变的
d = {'name': 'Alice', 'age': 25}
print(id(d))     # 打印字典的内存地址
d['age'] = 26    # 修改字典内容
print(d)         # 输出：{'name': 'Alice', 'age': 26}
print(id(d))     # 打印字典的内存地址（不会改变）

不可变数据类型

1. 定义
  • 不可变数据类型是指对象的值一旦创建后不能修改。如果你尝试修改不可变对象的内容，Python 会创建一个新的对象，并将修改后的值赋给新的对象。
2. 常见的不可变数据类型
  • 整数（int）
  • 浮点数（float）
  • 字符串（str）
  • 元组（tuple）
  • 布尔类型（bool）
  • frozenset（冻结集合）
3. 特点
  • 不可修改内容：一旦创建了不可变对象，它的值就不能改变。
  • 创建新对象：对不可变对象的修改操作会创建一个新的对象，而原对象保持不变。
  • 内存地址改变：当修改不可变对象时，它的内存地址会改变，因为 Python 会创建一个新的对象。
4. 案例
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
# 整数是不可变的
a = 10
print(id(a))  # 打印整数的内存地址
a += 1        # 修改整数，实际上是创建一个新的整数对象
print(a)      # 输出：11
print(id(a))  # 打印新的整数的内存地址（发生了变化）
# 字符串是不可变的
s = "hello"
print(id(s))  # 打印字符串的内存地址
s += " world" # 修改字符串，实际上是创建一个新的字符串对象
print(s)      # 输出："hello world"
print(id(s))  # 打印新的字符串的内存地址（发生了变化）
# 元组是不可变的
t = (1, 2, 3)
print(id(t))  # 打印元组的内存地址
t += (4,)     # 修改元组，实际上是创建一个新的元组对象
print(t)      # 输出：(1, 2, 3, 4)
print(id(t))  # 打印新的元组的内存地址（发生了变化）

可变和不可变的主要区别

特性 可变数据类型 不可变数据类型
修改内容 可以直接修改内容 不能修改内容，修改时会创建新对象
内存地址 修改时内存地址不变 修改时会创建新的对象，内存地址会改变
性能 修改操作效率高，因为是在原地修改 修改操作需要创建新对象，相对较慢
使用场景 适用于需要频繁修改内容的数据结构 适用于数据不需要修改或只读的数据结构
示例 列表、字典、集合 整数、浮点数、字符串、元组

可变与不可变的副作用

  • 不可变类型：由于不可变对象不能修改，因此它们的副作用较少，更易于理解和推理。例如，传递不可变对象作为函数参数时，函数内的操作不会影响外部的对象。
  • 可变类型：可变对象在多个地方引用时可能引发副作用。修改可变对象时，所有引用该对象的地方都会看到变化。这种行为有时会导致难以预料的错误，特别是在函数传参时。 
    1
    2
    3
    4
    5
    def modify_list(lst):  
        lst.append(4)  # 修改传入的列表  
    original_list = [1, 2, 3]  
    modify_list(original_list)  
    print(original_list)  # 输出：[1, 2, 3, 4]，原列表被修改

三、类型转换

Python 提供了内置函数用于类型转换，可以将一种数据类型转换为另一种数据类型：

函数 描述
int(x,base) 将x转换为一个整数
float(x) 将x转换到一个浮点数
complex(real,imag) 创建一个复数
str(x) 将对象 x 转换为字符串
repr(x) 将对象 x 转换为表达式字符串
eval(str) 用来计算在字符串中的有效Python表达式,并返回一个对象
tuple(s) 将序列 s 转换为一个元组
list(s) 将序列 s 转换为一个列表
set(s) 转换为可变集合
dict(d) 创建一个字典。d 必须是一个 (key, value)元组序列。
frozenset(s) 转换为不可变集合
chr(x) 将一个整数转换为一个字符
ord(x) 将一个字符转换为它的整数值
hex(x) 将一个整数转换为一个十六进制字符串
oct(x) 将一个整数转换为一个八进制字符串

这些函数返回一个新的对象，表示转换的值

类型检查

内置的 type() 函数可以用来查询变量所指的对象类型

1
2
3
4
print(type(42))        # <class 'int'>
print(type('hello'))   # <class 'str'>
print(type([1, 2, 3])) # <class 'list'>

本文是转载文章，点击查看原文。