数据类型

Python 中的变量不需要声明，每个变量在使用之前都必须赋值（使用 = 进行赋值操作），变量赋值以后该变量才会在内存中被创建。并且 Python 中的变量是没有类型的，通常所说的类型仅仅指的是变量所指的内存中对象的类型。

python

a = 10
print(a)  # 10

在 Python 中允许同时为多个变量赋值，例如：

python

a = b = c = 10
print(a, b, c)  # 10 10 10

Python 3 中常见的数据类型有：

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

其中，不可变数据（Number、String、Tuple）不允许变量的值发生变化，如果改变变量的值，相当于是新建了一个对象，而对于可变数据（List、Set、Dictionary）来说，变量指向的内存地址不会变，只是内存地址中的内容发生了变化。

Number（数字）

Python 支持的 Number 类型有：

int（有符号整型）
long（长整型）
float（浮点型，Python 2 支持）
complex（复数）

Python 中可以使用 type() 函数或者 isinstance() 函数来查看变量的类型。

type() 函数返回对象的类型（即类）。它通常用于获取对象的直接类型，而不考虑继承关系。

python

x = 10  
print(type(x))  # 输出: <class 'int'>  
  
y = [1, 2, 3]  
print(type(y))  # 输出: <class 'list'>  
  
class MyClass:  
    pass  
  
obj = MyClass()  
print(type(obj))  # 输出: <class '__main__.MyClass'>

isinstance() 函数检查一个对象是否是一个给定类的实例或该类的子类的实例，它考虑了继承关系，因此比 type() 更加灵活和强大。

python

x = 10  
print(isinstance(x, int))    # 输出: True  
print(isinstance(x, float))  # 输出: False  
  
y = [1, 2, 3]  
print(isinstance(y, list))   # 输出: True  
  
class MyClass:  
    pass  
  
class AnotherClass(MyClass):  
    pass  
  
obj = AnotherClass()  
print(isinstance(obj, MyClass))  # 输出: True  
print(isinstance(obj, AnotherClass))  # 输出: True

type() 和 isinstance() 的区别

直接类型 vs 继承关系：
- type() 返回对象的直接类型，不考虑继承关系。
- isinstance() 检查对象是否是给定类或其子类的实例，考虑继承关系。
返回值：
- type() 返回一个类型对象。
- isinstance() 返回一个布尔值（True 或 False）。
用途：
- type() 常用于需要确切知道对象类型的情况。
- isinstance() 常用于多态性和类型检查，尤其是在需要处理继承关系的场景中。

在下方的示例中，type() 只能检查 dog 是否是 Dog 类的实例，而 isinstance() 还能检查 dog 是否是 Animal 类的实例（因为 Dog 继承自 Animal）。

python

class Animal:  
    pass  
  
class Dog(Animal):  
    pass  
  
dog = Dog()  
  
# 使用 type()  
print(type(dog) == Dog)  # 输出: True  
print(type(dog) == Animal)  # 输出: False  
  
# 使用 isinstance()  
print(isinstance(dog, Dog))  # 输出: True  
print(isinstance(dog, Animal))  # 输出: True

Python 中的复数由实数部分和虚数部分构成，可以用 a + bj 或者 complex(a, b) 表示，复数的实部和虚部都是浮点型。

python

a = 1 + 2j
print(a)  # (1+2j)
print(type(a))  # <class 'complex'>

String（字符串）

Python 中的字符串是不可变的，可以使用单引号 '、双引号 " 或者三引号 """ 来表示字符串。

python

a = 'Hello, World!'
b = "Hello, World!"
c = """Hello, World!"""

字符串的索引值都是从 0 开始的，支持截取操作：

python

str = 'Hello,World!'  # 定义一个字符串变量

print(str)           # 打印整个字符串
print(str[0:-1])     # 打印字符串第一个到倒数第二个字符（不包含倒数第一个字符）
print(str[0])        # 打印字符串的第一个字符
print(str[2:5])      # 打印字符串第三到第四个字符（不包含第五个字符）
print(str[2:])       # 打印字符串从第三个字符开始到末尾
print(str * 2)       # 打印字符串两次
print(str + " Python")  # 打印字符串和" Python"拼接在一起

# 输出：
Hello,World!
Hello,World
H
llo
llo,World!
Hello,World!Hello,World!
Hello,World! Python

使用反斜杠 \ 可以转义特殊字符，如果不想让反斜杠发生转义，可以在字符串前面添加一个 r，表示原始字符串。

python

print('Hello\nWorld!')  # 使用反斜杠转义特殊字符
print(r'Hello\nWorld!')  # 在字符串前面添加一个 r，表示原始字符串

# 输出：
Hello
World!
Hello\nWorld!

另外反斜杠可以作为续行符，表示下一行是上一行的延续。也可以使用 """ 或 ''' 来表示多行字符串。

python

print('Hello, \
World!')

print("""Hello,
World!""")

Bool（布尔）

布尔（Bool）数据类型表示逻辑上的真（True）或假（False）。布尔数据类型主要用于条件判断和逻辑运算。

布尔值

Python 中的布尔值只有两种：

True：表示真
False：表示假

布尔运算

Python 提供了一些用于布尔运算的运算符，这些运算符通常用于条件判断和循环控制中。主要的布尔运算符包括：

逻辑与（AND）：使用 and 关键字。当且仅当两个操作数都为 True 时，结果才为 True。

python

True and True  # 结果是 True
True and False # 结果是 False
False and True # 结果是 False
False and False # 结果是 False

逻辑或（OR）：使用 or 关键字。只要有一个操作数为 True，结果就为 True。

python

True or True  # 结果是 True
True or False # 结果是 True
False or True # 结果是 True
False or False # 结果是 False

逻辑非（NOT）：使用 not 关键字。它将操作数的布尔值取反。

python

not True  # 结果是 False
not False # 结果是 True

布尔值在条件判断中的应用

布尔值在条件判断中非常重要。例如，使用 if 语句可以根据布尔值决定是否执行某个代码块。

python

x = 10

if x > 5:
    print("x is greater than 5")  # 输出：x is greater than 5
else:
    print("x is not greater than 5")

布尔类型转换

Python 允许将其他数据类型转换为布尔值。在布尔上下文中，以下值会被视为 False：

False
None
数值类型中的 0
空字符串 ''
空列表 []
空元组 ()
空字典 {}
空集合 set()
自定义对象（如果定义了 __bool__() 或 __len__() 方法并返回 False 或 0）

除了上述的举例外，其他所有值在布尔上下文中都被视为 True。

python

bool(0)        # 结果是 False
bool(1)        # 结果是 True
bool(-1)       # 结果是 True
bool([])       # 结果是 False
bool([1, 2, 3])# 结果是 True
bool("")       # 结果是 False
bool("Hello")  # 结果是 True
bool(None)     # 结果是 False

布尔类型的应用场景

布尔类型在编程中有很多应用场景，例如：

控制程序流程（如条件判断和循环）
验证输入数据的有效性
函数的返回值（例如，表示操作是否成功）

List（列表）

列表（List）是一种非常强大和灵活的数据结构，用于存储一系列有序的元素。这些元素可以是不同类型的，比如整数、字符串、浮点数，甚至是其他列表（即嵌套列表）。

创建列表

使用中括号：

python

my_list = [1, 2, 3, "hello", 3.14]

使用 list() 函数：

python

my_list = list((1, 2, 3))  # 从元组转换
my_list = list("hello")    # 从字符串转换，生成每个字符的列表

访问列表元素

通过索引访问（从 0 开始）：

python

print(my_list[0])  # 输出: 1
print(my_list[3])  # 输出: hello

索引可以是负数，表示从末尾开始计数：

python

print(my_list[-1])  # 输出: 3.14

列表操作

修改元素：

python

my_list[0] = 10
print(my_list)  # 输出: [10, 2, 3, 'hello', 3.14]

添加元素：

在末尾添加：

python

my_list.append(42)
print(my_list)  # 输出: [10, 2, 3, 'hello', 3.14, 42]

在指定位置插入：

python

my_list.insert(2, "inserted")
print(my_list)  # 输出: [10, 2, 'inserted', 3, 'hello', 3.14, 42]

删除元素：

通过值删除（移除第一个匹配的元素）：

python

my_list.remove("hello")
print(my_list)  # 输出: [10, 2, 'inserted', 3, 3.14, 42]

通过索引删除：

python

del my_list[2]
print(my_list)  # 输出: [10, 2, 3, 3.14, 42]

弹出最后一个元素：

python

last_element = my_list.pop()
print(last_element)  # 输出: 42
print(my_list)       # 输出: [10, 2, 3, 3.14]

获取列表长度：

python

length = len(my_list)
print(length)  # 输出: 4

遍历列表：

python

for item in my_list:
    print(item)

列表切片：

python

sub_list = my_list[1:3]
print(sub_list)  # 输出: [2, 3]

列表推导式：

python

squares = [x**2 for x in range(5)]
print(squares)  # 输出: [0, 1, 4, 9, 16]

列表方法

Python 的列表对象有许多内置方法，比如：

count(x)：返回列表中元素x出现的次数。
extend(iterable)：通过添加指定序列的元素来扩展列表。
index(x, start, end)：返回列表中第一个值为 x 的元素的索引，如果没有找到，则抛出 ValueError。
reverse()：将列表中的元素反向排列。
sort(key=None, reverse=False)：对列表进行排序。

嵌套列表

列表可以嵌套在其他列表中，形成一个多维数组：

python

matrix = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
]

列表解析

列表解析是一种简洁的构建列表的方法：

python

even_numbers = [x for x in range(10) if x % 2 == 0]
print(even_numbers)  # 输出: [0, 2, 4, 6, 8]

不可变性

与元组（Tuple）不同的是，列表是可变的，这意味着你可以在创建后修改其内容。

示例

综合示例：

python

# 创建一个列表
fruits = ['apple', 'banana', 'cherry']

# 添加元素
fruits.append('date')

# 插入元素
fruits.insert(1, 'blueberry')

# 删除元素
fruits.remove('banana')

# 遍历列表
for fruit in fruits:
    print(fruit)

# 列表切片
first_two_fruits = fruits[:2]
print(first_two_fruits)

# 列表排序
fruits.sort()
print(fruits)

Tuple（元组）

在 Python 中，元组（Tuple）是一种内置的数据类型，用于存储一系列不可变的项。元组与列表（List）类似，但主要区别在于元组是不可变的，即一旦创建，其内容就不能被修改。这使得元组在某些情况下比列表更加安全和高效。

创建元组

元组可以通过多种方式创建，最常见的是使用小括号 () 和逗号 , 来分隔元素。例如：

python

# 创建一个包含三个元素的元组
my_tuple = (1, 2, 3)

# 创建一个空元组
empty_tuple = ()

# 创建一个只有一个元素的元组（注意需要加上逗号）
single_element_tuple = (5,)

访问元组元素

元组中的元素可以通过索引来访问，索引从 0 开始。例如：

python

# 访问第一个元素
first_element = my_tuple[0]  # 输出: 1

# 访问第二个元素
second_element = my_tuple[1]  # 输出: 2

元组是不可变的

由于元组是不可变的，因此不能修改其元素。尝试修改元组会引发 TypeError。例如：

python

# 尝试修改元组中的元素
my_tuple[0] = 10  # 这会引发 TypeError

元组的方法

虽然元组是不可变的，但它们仍然有一些有用的方法。例如：

count(value): 返回元组中某个值出现的次数。
index(value): 返回元组中某个值第一次出现的索引。

python

# 使用 count 方法
count_of_two = my_tuple.count(2)  # 输出: 1

# 使用 index 方法
index_of_three = my_tuple.index(3)  # 输出: 2

元组的用途

由于元组是不可变的，它们通常用于以下场景：

作为字典的键：因为字典的键必须是不可变的，所以元组可以用作字典的键。
存储不可变的数据：当你希望数据在创建后不被修改时，可以使用元组。
函数返回多个值：函数可以返回一个元组来同时返回多个值。

示例：函数返回多个值

python

def get_person_info():
    return ("Alice", 30, "Engineer")

name, age, job = get_person_info()
print(name, age, job)  # 输出: Alice 30 Engineer

拆包（Unpacking）

元组还可以进行拆包操作，即将元组中的元素赋值给多个变量。例如：

python

# 拆包操作
a, b, c = (1, 2, 3)
print(a, b, c)  # 输出: 1 2 3

Set（集合）

Python 中的集合（Set）是一种基本的数据类型，用于存储不重复的元素。集合中的元素是无序的，且不允许有重复的值。集合提供了丰富的操作方法来处理集合之间的关系，如并集、交集、差集等。

创建集合

集合可以使用大括号 {} 或 set() 函数来创建。

python

# 使用大括号创建集合
my_set = {1, 2, 3, 4}

# 使用 set() 函数创建集合
my_set = set([1, 2, 3, 4])

注意：

如果使用列表或其他可迭代对象来创建集合，并且可迭代对象中包含重复元素，集合会自动去重。
创建空集合时，必须使用 set() 函数，而不能使用 {}，因为 {} 会创建一个空字典。

访问集合中的元素

集合中的元素是无序的，因此不能通过索引来访问集合中的元素。不过，可以使用循环来遍历集合中的元素。

python

my_set = {1, 2, 3, 4}
for item in my_set:
    print(item)

集合的常用操作

添加元素

python

my_set = {1, 2, 3}
my_set.add(4)  # 添加单个元素
my_set.update([5, 6])  # 添加多个元素

删除元素

python

my_set = {1, 2, 3, 4}
my_set.remove(3)  # 删除指定元素，如果元素不存在则抛出 KeyError
my_set.discard(4)  # 删除指定元素，如果元素不存在则不抛出异常
my_set.pop()  # 随机删除一个元素，并返回该元素

集合的运算

python

set1 = {1, 2, 3}
set2 = {3, 4, 5}

# 并集
union_set = set1 | set2  # 或 set1.union(set2)

# 交集
intersection_set = set1 & set2  # 或 set1.intersection(set2)

# 差集
difference_set = set1 - set2  # 或 set1.difference(set2)，表示只在 set1 中存在的元素

# 对称差集
symmetric_difference_set = set1 ^ set2  # 或 set1.symmetric_difference(set2)，表示只在一个集合中存在的元素，等价于 (set1 - set2) | (set2 - set1)


# 输出：
{1, 2, 3, 4, 5}
{3}
{1, 2}
{1, 2, 4, 5}

判断元素是否在集合中

python

my_set = {1, 2, 3}
print(2 in my_set)  # 输出: True
print(4 in my_set)  # 输出: False

集合的其他方法

python

my_set = {1, 2, 3, 4}

# 获取集合的长度
length = len(my_set)

# 清空集合
my_set.clear()

# 将集合转换为列表
my_list = list(my_set)

# 将集合转换为元组
my_tuple = tuple(my_set)

不可变性（Immutability）

集合本身是可变的，即可以添加或删除元素，但集合中的元素必须是不可变的。例如，集合中的元素不能是列表或字典等可变类型。

python

# 正确的用法
my_set = {1, 2, (3, 4)}  # 集合中的元素是整数和元组（元组是不可变的）

# 错误的用法
# my_set = {1, 2, [3, 4]}  # 列表是可变的，会引发 TypeError

Dictionary（字典）

Python 中的字典（Dictionary）是一种非常强大且灵活的数据类型，用于存储键值对（key-value pairs）。每个键（key）都映射到一个值（value），并且键必须是唯一的。字典提供了一种快速查找、插入和删除数据的方式。

创建字典

你可以使用大括号 {} 或 dict() 函数来创建一个字典。以下是一些示例：

python

# 使用大括号创建字典
my_dict = {'name': 'Alice', 'age': 25, 'city': 'New York'}

# 使用 dict() 函数创建字典
another_dict = dict(name='Bob', age=30, city='Los Angeles')

访问字典中的值

你可以通过键来访问字典中的值：

python

print(my_dict['name'])  # 输出: Alice
print(another_dict['age'])  # 输出: 30

添加或修改键值对

你可以通过指定键来添加新的键值对或修改已有的键值对：

python

my_dict['email'] = 'alice@example.com'  # 添加新的键值对
my_dict['age'] = 26  # 修改已有的键值对

删除键值对

你可以使用 del 语句或 pop() 方法来删除字典中的键值对：

python

del my_dict['city']  # 使用 del 语句删除键值对
email = my_dict.pop('email')  # 使用 pop() 方法删除键值对，并返回该值

检查键是否存在

你可以使用 in 关键字来检查某个键是否存在于字典中：

python

if 'name' in my_dict:
    print("Name exists in the dictionary.")
else:
    print("Name does not exist in the dictionary.")

遍历字典

你可以使用多种方式来遍历字典，包括遍历键、遍历值或遍历键值对：

python

# 遍历键
for key in my_dict:
    print(key)

# 遍历值
for value in my_dict.values():
    print(value)

# 遍历键值对
for key, value in my_dict.items():
    print(f"{key}: {value}")

字典的常用方法

keys(): 返回一个包含字典中所有键的视图对象。
values(): 返回一个包含字典中所有值的视图对象。
items(): 返回一个包含字典中所有键值对的视图对象。
get(key, default=None): 返回指定键的值，如果键不存在则返回默认值（默认为 None）。
update(other): 使用另一个字典中的键值对更新当前字典。
clear(): 清空字典中的所有键值对。

示例代码

以下是一个综合示例，展示了如何使用字典进行各种操作：

python

# 创建一个字典
person = {'name': 'Alice', 'age': 25, 'city': 'New York'}

# 访问值
print(person['name'])  # 输出: Alice

# 添加新的键值对
person['email'] = 'alice@example.com'

# 修改已有的键值对
person['age'] = 26

# 删除键值对
del person['city']
email = person.pop('email')

# 检查键是否存在
if 'name' in person:
    print("Name exists in the dictionary.")

# 遍历字典
for key, value in person.items():
    print(f"{key}: {value}")

# 使用 get 方法获取值
print(person.get('age', 'Age not found'))  # 输出: 26

# 更新字典
person.update({'city': 'San Francisco', 'job': 'Engineer'})

# 清空字典
person.clear()
print(person)  # 输出: {}

Byte 类型

在 Python 中，bytes 数据类型用于表示不可变的字节序列。它是二进制数据的一种表现形式，常用于处理文件、网络通信和底层数据操作。

字节（Bytes）和字节串（Byte Strings）

字节（Bytes）：bytes 类型的对象，表示一个不可变的字节序列。
字节串（Byte Strings）：以 b 或 B 前缀开头的字符串字面量，用于创建 bytes 对象。

创建 bytes 对象

字节串字面量

python

b_data = b"Hello, World!"

使用 bytes() 构造函数

从整数列表创建：

python

b_data = bytes([72, 101, 108, 108, 111])  # 对应 'Hello'

从字符串创建（需要指定编码，默认是 'utf-8'）：

python

s = "Hello, World!"
b_data = s.encode('utf-8')

从其他 bytes-like 对象创建（如 bytearray）：

python

ba = bytearray([72, 101, 108, 108, 111])
b_data = bytes(ba)

bytes 对象的方法

bytes 对象提供了一些常用的方法来操作字节数据：

索引和切片：

python

b_data = b"Hello, World!"
print(b_data[0])  # 输出: 72 (ASCII码 for 'H')
print(b_data[0:5])  # 输出: b'Hello'

decode()：将 bytes 对象解码为字符串。

python

b_data = b"Hello, World!"
s = b_data.decode('utf-8')
print(s)  # 输出: Hello, World!

hex()：返回 bytes 对象的十六进制表示。

python

b_data = b"Hello"
print(b_data.hex())  # 输出: 48656c6c6f

join()：连接字节序列。

python

b1 = b"Hello"
b2 = b"World"
b_joined = b" ".join([b1, b2])
print(b_joined)  # 输出: b'Hello World'

split()：根据指定的字节分割字节序列。

python

b_data = b"Hello World"
b_split = b_data.split(b" ")
print(b_split)  # 输出: [b'Hello', b'World']

注意事项

bytes 对象是不可变的，这意味着你不能修改它的内容。如果需要可变的字节序列，可以使用 bytearray 类型。
在处理二进制数据时，需要特别小心编码和解码问题，以避免数据损坏或安全漏洞。

示例代码

以下是一个综合示例，展示了如何创建和操作 bytes 对象：

python

# 创建 bytes 对象
b_data = b"Hello, World!"

# 索引和切片
print(b_data[0])  # 输出: 72
print(b_data[0:5])  # 输出: b'Hello'

# 解码为字符串
s = b_data.decode('utf-8')
print(s)  # 输出: Hello, World!

# 十六进制表示
print(b_data.hex())  # 输出: 48656c6c6f2c20576f726c6421

# 连接字节序列
b1 = b"Hello"
b2 = b"Python"
b_joined = b" ".join([b1, b2])
print(b_joined)  # 输出: b'Hello Python'

# 分割字节序列
b_split = b_joined.split(b" ")
print(b_split)  # 输出: [b'Hello', b'Python']

数据类型 ​

Number（数字） ​

String（字符串） ​

Bool（布尔） ​

布尔值 ​

布尔运算 ​

布尔值在条件判断中的应用 ​

布尔类型转换 ​

布尔类型的应用场景 ​

List（列表） ​

创建列表 ​

访问列表元素 ​

列表操作 ​

列表方法 ​

嵌套列表 ​

列表解析 ​

不可变性 ​

示例 ​

Tuple（元组） ​

创建元组 ​

访问元组元素 ​

元组是不可变的 ​

元组的方法 ​

元组的用途 ​

示例：函数返回多个值 ​

拆包（Unpacking） ​

Set（集合） ​

创建集合 ​

访问集合中的元素 ​

集合的常用操作 ​

不可变性（Immutability） ​

Dictionary（字典） ​

创建字典 ​

访问字典中的值 ​

添加或修改键值对 ​

删除键值对 ​

检查键是否存在 ​

遍历字典 ​

字典的常用方法 ​

示例代码 ​

Byte 类型 ​

字节（Bytes）和字节串（Byte Strings） ​

创建 bytes 对象 ​

bytes 对象的方法 ​

注意事项 ​

示例代码 ​

数据类型

Number（数字）

String（字符串）

Bool（布尔）

布尔值

布尔运算

布尔值在条件判断中的应用

布尔类型转换

布尔类型的应用场景

List（列表）

创建列表

访问列表元素

列表操作

列表方法

嵌套列表

列表解析

不可变性

示例

Tuple（元组）

创建元组

访问元组元素

元组是不可变的

元组的方法

元组的用途

示例：函数返回多个值

拆包（Unpacking）

Set（集合）

创建集合

访问集合中的元素

集合的常用操作

不可变性（Immutability）

Dictionary（字典）

创建字典

访问字典中的值

添加或修改键值对

删除键值对

检查键是否存在

遍历字典

字典的常用方法

示例代码

Byte 类型

字节（Bytes）和字节串（Byte Strings）

创建 bytes 对象

bytes 对象的方法

注意事项

示例代码