python基础知识之数据类型

Python确实有多种内置的数据类型，使用合适的数据类型可以使程序变得高效。本文介绍python中常用的基本数据类型和容器类型，并举例说明他们的常用用法。

基本数据类型

整数（int)

整型（int）是Python中的一种基本数据类型，用于表示整数。在Python中，整型对象是不可变的，这意味着一旦创建了整型对象，其值就不能被修改。

• 创建和表示， 可以直接使用数字（没有小数点）来创建整型。

a = 5
b = -3
c = int(6)

在Python 3中，int可以表示任意大小的整数，只要内存允许。

• 基本操作: 整型支持所有常规的数学运算：
  加法: a + b
  减法: a - b
  乘法: a * b
  除法（结果为浮点数）: a / b
  整除（取商）: a // b
  模（取余数）: a % b
  乘方: a ** b

浮点数(float)

浮点数（float）在Python中表示小数点的数字。它们通常用于需要更精确值的情况。在计算机中，浮点数通常使用IEEE 754标准来表示。在大多数现代计算机和编程语言（包括Python）中，通常使用两种主要的浮点表示方法：

（1） 单精度浮点数 (Float32): 这种表示使用32位存储浮点数，其中1位用于符号，8位用于指数，23位用于尾数（也称为分数）。
（2） 双精度浮点数 (Float64): 这种表示使用64位存储浮点数，其中1位用于符号，11位用于指数，52位用于尾数。
Python中的float类型通常使用双精度（Float64）表示，但这可能取决于底层C库和操作系统的实现。因此，Python的float通常有64位。但是，使用32位浮点数（通常称为float32或单精度浮点数）相对于64位浮点数（通常称为float64或双精度浮点数）确实可以节省内存。具体来说，float32使用的内存是float64的一半。

• 创建和表示: 可以通过在数字中包含小数点或使用科学记数法来创建浮点数。

a = 3.14
b = -0.01
c = 2.5e3  # 2.5 x 10^3 = 2500.0

• 精度和限制
  浮点数的精度是有限的，这可能会导致某些不精确的结果。例如，计算0.1 + 0.2可能不会正好得到0.3。由于这种内部表示的特性，通常不建议将浮点数用于需要完全精确的计算，如货币计算。在这种情况下，通常使用定点算法或特殊的库，如Python的decimal模块。

• NaN和Infinity, 浮点数两个特殊的值：
  float(‘nan’): 表示"Not a Number"，用于表示未定义的或不可表示的值。
  float(‘inf’) 和 float(‘-inf’): 分别表示正无穷和负无穷。

浮点数的计算与整数计算方法相同。

复数(complex)

在Python中，复数是内置的数据类型，用complex表示。Python使用j来表示虚数单位。

• 创建复数：

x = 3 + 4j
y = complex(5, -2)  # 也表示为 5 - 2j

• 访问复数的实部和虚部：

z = 3 - 5j
print(z.real)  # 输出: 3.0
print(z.imag)  # 输出: -5.0

• 复数的操作：复数支持加法、减法、乘法、除法和其他数学操作。例如：

a = 2 + 3j
b = 1 - 1j
result = a + b  # 结果是 3 + 2j

• 复共轭：复数的共轭是改变虚部符号的结果。例如，$(3+4j)$的共轭是$(3-4j)$
  在Python中，你可以使用conjugate()方法获取复数的共轭：

z = 3 + 4j
print(z.conjugate())  # 输出: (3-4j)

模（绝对值）：
复数的模（或绝对值）是其到原点的欧几里得距离，计算公式为：$\sqrt{(a^2+b^2)}$, 在Python中，你可以使用内置的abs()函数来获取复数的模：

z = 3 + 4j
print(abs(z))  # 输出: 5.0，因为 sqrt(3^2 + 4^2) = 5

布尔值(bool)

布尔值（Boolean）是计算机科学和数学中的一个基本概念，它只有两个可能的值：真（True）和假（False）。在Python中，布尔值是bool类型的实例。

• 创建和表示, 在Python中，布尔值可以直接使用True和False关键字表示（注意首字母大写）：

a = True
b = False

• 基于其他数据类型的布尔值
  几乎所有Python对象都可以在需要布尔上下文（例如条件语句或循环）时被解释为真或假。常见的“假值”有：
  • None
  • 数字零：0, 0.0, 0j
  • 空序列和集合：“”, [], (), {}, set()
  • 其他特定于类型的“空”值，如numpy.array([])等
  • 其他所有值通常都被解释为真。

使用内置的bool()函数，可以将其他类型的值转换为布尔值：

print(bool(0))      # 输出: False
print(bool(1))      # 输出: True
print(bool(""))     # 输出: False
print(bool("abc"))  # 输出: True
print(bool([]))     # 输出: False
print(bool([1, 2])) # 输出: True

• 逻辑操作, 布尔值常常与逻辑操作符一起使用：
  • and：如果两个操作数都为真，则结果为真。
  • or：如果至少有一个操作数为真，则结果为真。
  • not：返回操作数的反值。

x = True
y = False

print(x and y)  # 输出: False
print(x or y)   # 输出: True
print(not x)    # 输出: False

• 比较操作, 比较操作符（如==, !=, <, <=, >, >=）在Python中返回布尔值。例如：

print(5 == 5)  # 输出: True
print(5 < 3)   # 输出: False

• 布尔值的用途, 布尔值在许多编程场景中都非常有用，例如：
  • 控制流语句（如if, while）
  • 循环中的条件检查
  • 数据过滤

字符串(str)

字符串用于表示文本信息。在Python中，字符串是不可变的序列数据类型，通常用于存储和处理文本数据。

• 创建和表示
  你可以使用单引号（'）或双引号（"）来创建字符串。对于多行字符串，可以使用三个单引号或三个双引号。

s1 = 'Hello, world!'
s2 = "Hello, world!"

multi_line_string = '''
This is a multi-line
string in Python.
'''

• 访问字符, 使用方括号和索引可以访问字符串中的单个字符, 负索引可以从字符串的末尾开始访问。

s = "Python"
print(s[0])  # 输出: 'P'
print(s[-1])  # 输出: 'n' 

• 切片, 使用切片可以提取字符串的子字符串。切片也可以有一个可选的步长。

s = "Python"
print(s[1:4])  # 输出: 'yth'
print(s[0:6:2])  # 输出: 'Pto'

• 字符串操作
  • 连接：使用+连接两个字符串。
  • 重复：使用*重复字符串。
  • 转换：使用内置的str()函数将其他数据类型转换为字符串。

greeting = "Hello" + " " + "World"
repeated = "ha" * 3  # 'hahaha'
number = 123
str_num = str(number)  # '123'

• 常用方法
  • len(s): 返回字符串的长度。
  • s.upper(): 返回大写版本的字符串。
  • s.lower(): 返回小写版本的字符串。
  • s.split(delimiter): 根据指定的分隔符拆分字符串。
  • s.join(list): 使用字符串将列表中的元素连接起来。
  • s.replace(old, new): 替换字符串中的子串。
  • s.startswith(prefix): 检查字符串是否以指定前缀开头。
  • s.endswith(suffix): 检查字符串是否以指定后缀结尾。
  • s.strip(): 删除字符串两侧的空白字符。
  • …
• 转义字符
  在字符串中，有时需要表示特殊字符，如引号、换行符或制表符。这可以通过转义字符完成，它由反斜杠（\）开始。下面给出一些常用python转义字符：
  \\：反斜杠 ()
  \'：单引号 (')
  \"：双引号 (")
  \a：ASCII蜂鸣（响铃）字符
  \b：ASCII退格字符
  \f：ASCII换页符
  \n：换行符
  \r：回车符
  \t：水平制表符 (tab)
  \v：垂直制表符
  \ooo：以八进制形式表示的字符（ooo代表三个八进制数字）
  \xhh：以十六进制形式表示的字符（hh代表两个十六进制数字）
  \N{name}：对于指定名称的Unicode字符
  \uxxxx：对于16位的Unicode字符（xxxx代表四个十六进制数字）
  \Uxxxxxxxx：对于32位的Unicode字符（xxxxxxxx代表八个十六进制数字）
• 字符串格式化
  Python提供了多种方法来格式化字符串，其中最常见的是使用format()方法或f-string（在Python 3.6及更高版本中可用）。

# Using format()
"{} is a programming language.".format("Python")
# Python is a programming language.
# Using f-string
language = "Python"
f"{language} is a programming language."
# Python is a programming language.

容器类型

在编程中，容器是一种可以用来存储和组织多个数据项的数据结构。这些数据项可以是基本数据类型，如整数、浮点数和字符串，也可以是其他容器或复杂对象。容器通常提供一种方式来访问、修改和遍历其中的元素。

列表(list)

• 列表定义与创建: 列表是一个有序的元素集合，可以包含多种数据类型，如整数、浮点数、字符串、其他列表等。创建列表的方法：

list1 = [1, 2, 3, 4]
list2 = ["a", "b", "c"]
list3 = [1, "a", [2, 3], 4.5]

• 列表索引: 列表元素的索引从 0 开始。使用负数索引从列表的末尾开始计数。

list1 = [1, 2, 3, 4]
print(list1[0])  # 输出：1
print(list1[-1]) # 输出：4

• 列表切片

list1 = [1, 2, 3, 4, 5]
print(list1[1:4])  # 输出：[2, 3, 4]

• 修改列表， 通过索引修改元素的值。

  • 使用 append() 方法向列表添加元素。
  • 使用 insert() 方法在指定位置插入元素。
  • 使用remove(elemen)删除列表中第一个出现的指定值。
  • 使用 pop(index=-1) 方法删除指定位置的元素并返回它，如果不指定索引，则删除并返回最后一个元素。

• 列表操作

  • len(): 获取列表长度。
  • +: 合并两个列表。
  • *: 重复列表。

• 列表推导式: 列表推导式是创建列表的一种简洁方式：

squared = [x**2 for x in range(10)]

-其他常用方法

• list.sort(key=None, reverse=False): 对列表进行排序。
• list.reverse(): 反转列表。
• list.count(x): 计算 x 在列表中出现的次数。
• extend(list): 通过添加指定列表的所有元素来扩展列表。
• insert(index, element): 在指定位置插入一个元素。
• index(element, start=0, end=len(list)): 返回元素在列表中第一次出现的索引。
• count(element): 返回元素在列表中出现的次数。
• clear(): 清空列表。

更多方法，请查阅挂网列表的使用

元组(tuple)

元组（tuple）是 Python 中的一个基本的容器数据类型，与列表非常相似。但主要的区别在于元组是不可变的，这意味着一旦创建了元组，你就不能修改它的内容。这种不可变性为其提供了某些优点，如可以用作字典的键。

• 定义与创建: 创建元组的基本方法是使用圆括号 (), 一个元素的元组需要在元素后面加一个逗号，以区分数学中的括号。

tup1 = (1, 2, 3, 4)
tup2 = ("a", "b", "c")
tup3 = (1, "a", (2, 3), 4.5)
singleton = (1,)

• 访问元组: 与列表类似，可以使用索引来访问元组中的元素

tup1 = (1, 2, 3, 4)
print(tup1[0])  # 输出：1
print(tup1[-1]) # 输出：4

• 切片 可以使用切片来获取元组的子集：

tup1 = (1, 2, 3, 4, 5)
print(tup1[1:4])  # 输出：(2, 3, 4)

• 不可变性: 尝试修改元组的元素会引发错误：

tup1 = (1, 2, 3)
tup1[0] = 4  # 这将会引发 TypeError

• 元组操作
  • len(): 获取元组长度。
  • +: 合并两个元组。
  • *: 重复元组。
  • tuple.index(element): 返回元素在元组中首次出现的位置。
  • tuple.count(element): 返回元素在元组中出现的次数。

Note:

• 由于元组是不可变的，它们通常比列表更快。
• 元组可以用作字典的键，而列表不行。
• 如果有一个数据集合不应该被改变，使用元组而不是列表可以为你的代码提供一个保障。

集合(set)

集合（set）是 Python 中的一个数据结构，用于存储无序的元素集。集合中的元素是唯一的，这意味着一个集合中不能有重复的元素。集合是可变的，但是它存储的元素必须是不可变的数据类型（例如整数、浮点数、字符串、元组等）。

• 定义与创建: 创建集合使用大括号 {} 或 set() 函数,
  Note: 空大括号 {} 会创建一个空字典，而不是一个空集合。所以，创建空集合必须使用 set() 函数。

s1 = {1, 2, 3, 4}
s2 = set([1, 2, 2, 3, 4])  # 使用列表创建，并自动去除重复项

• 集合的特性

  • 无序性：集合中的元素是无序的，不能使用索引或键访问。
  • 唯一性：集合中的元素是唯一的，重复的元素会被自动去除。
  • 可变性：你可以添加和删除集合中的元素。

• 集合操作:

  • 添加元素：使用 add() 方法添加单个元素，使用 update() 方法添加多个元素。
  • 删除元素：使用 remove() 方法删除指定元素（如果元素不存在则引发 KeyError），使用 discard() 方法删除指定元素（如果元素不存在则不进行任何操作）。
  • 随机删除并返回元素：使用 pop() 方法。
  • 清空集合：使用 clear() 方法。
  • 求交集：intersection_update(): 更新一个集合，使其只包含同时存在于两个集合中的元素； difference_update(): 从一个集合中移除所有在另一集合中存在的元素，并更新原始集合。
  • 求并集： union(): 返回两个集合的并集，但不更新原始集合。isdisjoint(): 如果两个集合没有交集，则返回 True。
  • 求是否为子集： issubset() 和 issuperset(): 如前所述，这两个方法分别用于检查一个集合是否是另一个集合的子集或超集。

s = {1, 2}
s.add(3)  # {1, 2, 3}
s.update([3, 4, 5])  # {1, 2, 3, 4, 5}

s = {1, 2, 3}
s.remove(2)  # {1, 3}
s.discard(3)  # {1}
s.discard(4)  # {1}，没有变化，不会引发错误
item = s.pop()  # 随机删除并返回一个元素
s.clear()  # {}

a = {1, 2, 3, 4}
b = {3, 4, 5, 6}

# 并集
union_set = a | b  # {1, 2, 3, 4, 5, 6}
# 交集
intersection_set = a & b  # {3, 4}
# 差集
difference_set = a - b  # {1, 2}
# 对称差集（在 a 或 b 中，但不同时在 a 和 b 中）
symmetric_difference_set = a ^ b  # {1, 2, 5, 6}

a.difference_update(b)
# a 的内容变为 {1, 2}

a = {1, 2, 3, 4}
b = {3, 4, 5, 6}
a.intersection_update(b)

a = {1, 2, 3, 4}
b = {3, 4, 5, 6}
a.symmetric_difference_update(b)

a = {1, 2, 3}
b = {3, 4, 5}
c = a.union(b)
# c 的内容为 {1, 2, 3, 4, 5}

a = {1, 2, 3}
b = {4, 5, 6}
result = a.isdisjoint(b)  # True

字典(dict)

字典（Dictionary）是 Python 中的一个核心数据结构，用于存储键值对。字典中的键是唯一的，每个键对应一个值。字典是可变的，这意味着你可以添加、修改或删除键值对。

• 定义与创建：创建字典使用大括号 {} 或 dict() 函数

dict1 = {"name": "John", "age": 25, "city": "New York"}
dict2 = dict(name="Jane", age=30, city="Los Angeles")

• 访问字典: 通过键访问值

age = dict1["age"]  # 返回 25

如果键不存在，直接访问将引发 KeyError。为避免这种情况，可以使用 get() 方法，它允许你为不存在的键设置一个默认值。

age = dict1.get("salary", 0)  # 如果 "salary" 不存在，返回 0

• 修改字典:

• 添加或更新键值对

dict1["job"] = "Engineer"  # 添加新的键值对
dict1["age"] = 26         # 更新现有的键值对

• 删除键值对：使用 del 语句或 pop() 方法。

del dict1["city"]
age = dict1.pop("age")

• 清空字典：使用 clear() 方法。

dict1.clear()

• 字典的其他常用方法
  • keys(): 返回字典中的所有键。
  • values(): 返回字典中的所有值。
  • items(): 返回字典中的所有键值对。
  • copy(): 返回字典的浅拷贝。
  • update(other): 将另一个字典 other 的键值对合并到当前字典中。
  • popitem(): 随机删除并返回字典中的一个键值对（在 Python 3.7+，它删除并返回最后一个键值对）。
  • setdefault(key, default=None): 如果键在字典中，则返回其值。如果不在，插入该键及 default 值并返回 default。

d = {"a": 1, "b": 2}
d.clear()
# 结果：d = {}

keys = ["a", "b", "c"]
d = dict.fromkeys(keys, 0)
# 结果：d = {"a": 0, "b": 0, "c": 0}

d = {"a": 1, "b": 2}
val = d.get("c", 3)  # 由于 "c" 不在 d 中，所以返回 3

d = {"a": 1, "b": 2}
items = d.items()  # items = {("a", 1), ("b", 2)}

d = {"a": 1, "b": 2}
keys = d.keys()  # keys = {"a", "b"}

d = {"a": 1, "b": 2}
values = d.values()  # values = {1, 2}

d = {"a": 1, "b": 2}
val = d.pop("a")  # val = 1, d = {"b": 2}

d = {"a": 1, "b": 2}
item = d.popitem()  # item 可能是 ("a", 1) 或 ("b", 2)

d = {"a": 1, "b": 2}
d.update({"b": 3, "c": 4})  # d = {"a": 1, "b": 3, "c": 4}

• 遍历字典
  • 遍历所有键：

for key in dict1:
    print(key)

• 遍历所有值：

for value in dict1.values():
    print(value)

• 遍历所有键值对：

for key, value in dict1.items():
    print(key, value)

• 字典推导式
  与列表和集合的推导式类似，字典也有推导式，它是创建字典的一种简洁方式。

squared = {x: x**2 for x in (2, 3, 4)}
# 结果：{2: 4, 3: 9, 4: 16}