【Python3】基本数据类型、数据类型转换

【Python3】基本数据类型、数据类型转换
一、标准数据类型
 二、Number（数字）
- isinstance 和 type 的区别在于：
- 数值运算
三、String（字符串）
四、bool（布尔类型）
五、List（列表）
六、Tuple（元组）
七、Set（集合）
八、Dictionary（字典）
九、字节数组类型(bytes)
十、Python数据类型转换
 十一、隐式类型转换、显式类型转换
- 隐式类型转换 - 自动完成
- 显式类型转换 - 需要使用类型函数来转换
Python3基本数据类型

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

在 Python 中，变量就是变量，它没有类型，我们所说的"类型"是变量所指的内存中对象的类型。

一、标准数据类型

Python3 中常见的数据类型有：
- Number（数字）
- String（字符串）
- bool（布尔类型）
- List（列表）
- Tuple（元组）
- Set（集合）
- Dictionary（字典）
Python3 的六个标准数据类型中：
- 不可变数据（3 个）：Number（数字）、String（字符串）、Tuple（元组）；
- 可变数据（3 个）：List（列表）、Dictionary（字典）、Set（集合）。
  此外还有一些高级的数据类型，如: 字节数组类型(bytes)。
二、Number（数字）

在Python中，数字是一种基本的数据类型，主要分为以下几种：
1. 整数（int）: 用于表示整数值。例如：1, 42, -10。
2. 浮点数（float）: 用于表示带有小数点的数值。例如：3.14, 2.0, -0.5。
3. 复数（complex）: 用于表示复数，形式为a + bj，其中a和b都是浮点数，j是虚数单位。例如：1 + 2j, 3.5 - 4j。
4. 布尔值（bool）: 用于表示逻辑值，只有两个值：True和False。
以下是一些示例：
```
# 整数
integer_number = 42
negative_integer = -10

# 浮点数
float_number = 3.14
negative_float = -0.5

# 复数
complex_number = 1 + 2j

# 布尔值
is_true = True
is_false = False
1
2
3
4
5
6
7
8
9
10
11
12
13
14
```
Python还提供了一些内置函数用于在不同类型之间进行转换，例如int(), float(), complex()等。例如：
```
# 转换为整数
float_to_int = int(3.14)

# 转换为浮点数
int_to_float = float(42)

# 转换为复数
int_to_complex = complex(5)
1
2
3
4
5
6
7
8
```
这些数字类型提供了丰富的数学操作和函数，使得在Python中进行数值计算变得非常方便。

isinstance 和 type 的区别在于：

type()不会认为子类是一种父类类型。
isinstance()会认为子类是一种父类类型。
isinstance 和 type 是 Python 中用于检查对象类型的两种不同的方法，它们之间的主要区别在于其处理继承关系的方式。
1. type:
  - type(obj) 返回对象 obj 的类型。
  - 不考虑继承关系，只会精确返回对象的实际类型。
  - 例如，对于继承关系中的子类，type 返回的是子类的类型。
```
class Animal:
    pass

class Dog(Animal):
    pass

my_dog = Dog()
print(type(my_dog))  # 输出 
1
2
3
4
5
6
7
8
```
2. isinstance:
  - isinstance(obj, classinfo) 用于检查对象 obj 是否是指定类型 classinfo 或其子类的实例。
  - 能够处理继承关系，返回 True 或 False。
  - 通常更灵活，适用于检查对象是否属于某个类或其子类。
```
class Animal:
    pass

class Dog(Animal):
    pass

my_dog = Dog()
print(isinstance(my_dog, Animal))  # 输出 True，因为 Dog 是 Animal 的子类
1
2
3
4
5
6
7
8
```
总的来说，如果你想检查对象是否是某个类或其子类的实例，推荐使用 isinstance。如果你需要获取准确的对象类型，而不考虑继承关系，可以使用 type。

数值运算
```
>>> 5 + 4  # 加法
9
>>> 4.3 - 2 # 减法
2.3
>>> 3 * 7  # 乘法
21
>>> 2 / 4  # 除法，得到一个浮点数
0.5
>>> 2 // 4 # 除法，得到一个整数
0
>>> 17 % 3 # 取余 
2
>>> 2 ** 5 # 乘方
32
1
2
3
4
5
6
7
8
9
10
11
12
13
14
```
注意：
1、Python可以同时为多个变量赋值，如a, b = 1, 2。
2、一个变量可以通过赋值指向不同类型的对象。
3、数值的除法包含两个运算符：/ 返回一个浮点数，// 返回一个整数。
4、在混合计算时，Python会把整型转换成为浮点数。

三、String（字符串）

在 Python 中，字符串是一种不可变的序列类型，用于存储文本数据。字符串是由字符组成的，可以包含字母、数字、标点符号等。在 Python 中，字符串可以用单引号（' '）或双引号（" "）括起来。

以下是关于 Python 字符串的一些基本操作和特性：
1. 创建字符串：
```
str1 = 'Hello, World!'
str2 = "Python is awesome."
1
2
```
2. 字符串拼接：
```
greeting = 'Hello'
name = 'Alice'
message = greeting + ', ' + name + '!'
1
2
3
```
  或者使用格式化字符串：
```
message = f'{greeting}, {name}!'
1
```
3. 字符串长度：
```
length = len(message)
1
```
4. 字符串索引和切片：
```
char = message[0]  # 获取索引为 0 的字符
substring = message[7:12]  # 切片，获取索引 7 到 11 的子字符串
1
2
```
5. 字符串方法：
  
  Python 提供了许多字符串方法，用于处理和操作字符串，例如：
```
upper_case = message.upper()  # 转换为大写
lower_case = message.lower()  # 转换为小写
count_a = message.count('a')  # 统计 'a' 的出现次数
1
2
3
```
6. 字符串格式化：
  
  Python 中有多种字符串格式化的方式，其中一种是使用 % 操作符：
```
age = 25
formatted_string = 'My age is %d' % age
1
2
```
  另一种是使用 format 方法：
```
formatted_string = 'My age is {}'.format(age)
1
```
  或者使用 f-string（Python 3.6 及以上版本）：
```
formatted_string = f'My age is {age}'
1
```
7. 原始字符串：
  
  如果字符串中包含转义字符，可以使用原始字符串（在字符串前加 r 或 R）来禁用转义：
```
path = r'C:\Users\Alice\Documents'
1
```
8. 字符串比较：
  
  字符串可以使用比较运算符进行比较，例如：
```
result = 'apple' == 'orange'  # 返回 False
1
```
以上是 Python 字符串的一些基本操作和特性。字符串是 Python 中非常重要的数据类型之一，广泛用于文本处理、格式化输出等场景。

四、bool（布尔类型）

在 Python 中，bool 是布尔类型，它用于表示真值（True）或假值（False）。布尔类型是 Python 的基本数据类型之一，通常用于条件判断和逻辑运算。

以下是关于 Python 布尔类型的一些基本操作和特性：
1. 创建布尔变量：
```
x = True
y = False
1
2
```
2. 布尔运算：
  
  Python 支持常见的布尔运算，包括逻辑与（and）、逻辑或（or）、逻辑非（not）等。
```
result_and = x and y  # 逻辑与
result_or = x or y    # 逻辑或
result_not = not x    # 逻辑非
1
2
3
```
3. 布尔比较：
  
  布尔类型可以与其他数据类型进行比较，例如：
```
num1 = 10
num2 = 20

greater_than = num1 > num2  # 大于
less_than = num1 < num2     # 小于
equal_to = num1 == num2     # 等于
1
2
3
4
5
6
```
4. 布尔类型转换：
  
  布尔类型可以被转换为其他数据类型，反之亦然。在 Python 中，bool() 函数可以用于将其他数据类型转换为布尔类型。
```
bool_from_int = bool(42)     # 非零整数转换为 True，0 转换为 False
bool_from_str = bool("Hello")  # 非空字符串转换为 True，空字符串转换为 False
1
2
```
5. 空值表示：
  
  在 Python 中，None 是一个特殊的空值对象，可以用于表示缺失或空值。在条件判断中，None 被视为 False。
```
empty_value = None
if empty_value:
    print("This won't be executed.")
1
2
3
```
6. 布尔运算的短路特性：
  
  在逻辑运算中，如果第一个操作数已经确定整个表达式的值，那么 Python 将不再计算第二个操作数。这被称为短路特性。
```
x = True
y = some_function()  # 假设 some_function 是一个函数
result = x and y     # 如果 x 为 False，则不会计算 y
1
2
3
```
以上是关于 Python 布尔类型的一些基本操作和特性。布尔类型在编写条件判断和进行逻辑运算时非常常用。

五、List（列表）

在 Python 中，列表（List）是一种有序的数据结构，用于存储一组元素。列表可以包含不同类型的元素，甚至可以包含其他列表。列表是可变（Mutable）的，这意味着可以通过添加、删除或修改元素来改变列表的内容。

以下是关于 Python 列表的一些基本操作和特性：
1. 创建列表：
  
  使用方括号 [] 可以创建一个列表，元素之间用逗号 , 分隔。
```
my_list = [1, 2, 3, 'apple', 'orange']
1
```
2. 访问元素：
  
  可以使用索引访问列表中的元素，索引从 0 开始。
```
first_element = my_list[0]      # 获取第一个元素
last_element = my_list[-1]      # 获取最后一个元素
1
2
```
3. 切片（Slicing）：
  
  使用切片可以获取列表的子集。
```
sublist = my_list[1:3]          # 获取索引 1 到 2 的元素（不包括索引 3）
1
```
4. 修改元素：
  
  列表是可变的，可以通过索引直接修改元素的值。
```
my_list[0] = 10                 # 修改第一个元素的值
1
```
5. 添加元素：
  
  使用 append() 方法可以在列表末尾添加元素。
```
my_list.append('banana')        # 在列表末尾添加元素
1
```
6. 删除元素：
  
  使用 del 关键字或 remove() 方法可以删除列表中的元素。
```
del my_list[1]                   # 删除索引 1 处的元素
my_list.remove('orange')        # 删除指定值的元素
1
2
```
7. 列表长度：
  
  使用 len() 函数可以获取列表的长度。
```
length = len(my_list)            # 获取列表长度
1
```
8. 列表拼接：
  
  使用 + 运算符可以将两个列表拼接在一起。
```
combined_list = my_list + [4, 5, 6]
1
```
9. 列表复制：
  
  使用 copy() 方法或切片 [:] 可以复制列表。
```
copied_list = my_list.copy()     # 复制列表
sliced_copy = my_list[:]         # 使用切片复制列表
1
2
```
10. 列表嵌套：
  
  列表可以包含其他列表，形成嵌套结构。
```
nested_list = [[1, 2, 3], ['a', 'b', 'c']]
1
```
以上是关于 Python 列表的一些基本操作和特性。列表是 Python 中常用的数据结构，灵活且易于使用。

六、Tuple（元组）

在 Python 中，元组（Tuple）是一种有序、不可变的数据结构。与列表不同，元组一旦创建，其内容就不能被修改，也不能添加或删除元素。元组使用圆括号 () 来表示，元素之间用逗号 , 分隔。

以下是关于 Python 元组的一些基本操作和特性：
1. 创建元组：
  
  使用圆括号 () 可以创建一个元组，元素之间用逗号 , 分隔。
```
my_tuple = (1, 2, 3, 'apple', 'orange')
1
```
2. 访问元素：
  
  可以使用索引访问元组中的元素，索引从 0 开始。
```
first_element = my_tuple[0]      # 获取第一个元素
last_element = my_tuple[-1]      # 获取最后一个元素
1
2
```
3. 切片（Slicing）：
  
  使用切片可以获取元组的子集，结果仍然是元组。
```
sublist = my_tuple[1:3]          # 获取索引 1 到 2 的元素（不包括索引 3）
1
```
4. 元组解包：
  
  可以使用元组解包将元组中的元素分配给多个变量。
```
a, b, *rest = my_tuple           # 解包元组
1
```
5. 不可变性：
  
  元组是不可变的，一旦创建，不能修改元素的值、添加或删除元素。
```
my_tuple[0] = 10                 # 会引发 TypeError
1
```
6. 元组长度：
  
  使用 len() 函数可以获取元组的长度。
```
length = len(my_tuple)           # 获取元组长度
1
```
7. 元组拼接：
  
  使用 + 运算符可以将两个元组拼接在一起。
```
combined_tuple = my_tuple + (4, 5, 6)
1
```
8. 元组复制：
  
  由于元组不可变，复制操作实际上是创建一个新的元组。
```
copied_tuple = my_tuple           # 这不是复制，而是引用
1
```
9. 元组嵌套：
  
  元组可以包含其他元组，形成嵌套结构。
```
nested_tuple = ((1, 2, 3), ('a', 'b', 'c'))
1
```
元组在某些场景下很有用，尤其是在需要确保数据不被修改的情况下。由于元组不可变，可以作为字典的键，而列表则不能。

七、Set（集合）

在 Python 中，集合（Set）是一种无序、可变的数据结构，用于存储不重复的元素。集合使用花括号 {} 表示，元素之间用逗号 , 分隔。

以下是关于 Python 集合的一些基本操作和特性：
1. 创建集合：
  
  使用花括号 {} 可以创建一个集合。
```
my_set = {1, 2, 3, 'apple', 'orange'}
1
```
  也可以使用 set() 构造函数创建集合。
```
another_set = set([4, 5, 6, 'banana'])
1
```
2. 添加元素：
  
  使用 add() 方法可以向集合中添加元素。
```
my_set.add(4)
1
```
3. 删除元素：
  
  使用 remove() 或 discard() 方法可以删除集合中的元素。区别在于，remove() 方法在元素不存在时会引发 KeyError，而 discard() 不会。
```
my_set.remove('apple')
1
```
4. 集合运算：
  - 并集（Union）：
    
    使用 union() 方法或 | 运算符可以获取两个集合的并集。
    
    union_set = my_set.union(another_set) # 或 union_set = my_set | another_set
    1
    2
    3
  - 交集（Intersection）：
    
    使用 intersection() 方法或 & 运算符可以获取两个集合的交集。
    
    intersection_set = my_set.intersection(another_set) # 或 intersection_set = my_set & another_set
    1
    2
    3
  - 差集（Difference）：
    
    使用 difference() 方法或 - 运算符可以获取两个集合的差集。
    
    difference_set = my_set.difference(another_set) # 或 difference_set = my_set - another_set
    1
    2
    3
  - 对称差集（Symmetric Difference）：
    
    使用 symmetric_difference() 方法或 ^ 运算符可以获取两个集合的对称差集，即包含在其中一个集合中但不同时包含在两个集合中的元素。
    
    symmetric_difference_set = my_set.symmetric_difference(another_set) # 或 symmetric_difference_set = my_set ^ another_set
    1
    2
    3
5. 子集和超集：
  
  使用 issubset() 方法可以检查一个集合是否是另一个集合的子集，使用 issuperset() 方法可以检查一个集合是否是另一个集合的超集。
```
is_subset = my_set.issubset(another_set)
is_superset = my_set.issuperset(another_set)
1
2
```
6. 集合长度：
  
  使用 len() 函数可以获取集合中元素的个数。
```
length = len(my_set)
1
```
7. 集合清空：
  
  使用 clear() 方法可以清空集合中的所有元素。
```
my_set.clear()
1
```
8. 集合复制：
  
  使用 copy() 方法可以复制一个集合。
```
copied_set = my_set.copy()
1
```
9. 集合推导式：
  
  类似于列表推导式，Python 还支持集合推导式的语法。
```
squares_set = {x**2 for x in range(10)}
1
```
集合是处理唯一元素的一种有效方式，因此在去重、检查成员资格等场景中很有用。请注意，集合是无序的，因此不能通过索引访问集合中的元素。

八、Dictionary（字典）

在 Python 中，字典（Dictionary）是一种无序的、可变的数据结构，用于存储键值对（key-value pairs）。字典使用花括号 {} 表示，每个键值对之间用逗号 , 分隔，键和值之间用冒号 : 分隔。

以下是关于 Python 字典的一些基本操作和特性：
1. 创建字典：
  
  使用花括号 {} 可以创建一个字典。
```
my_dict = {'name': 'Alice', 'age': 25, 'city': 'Wonderland'}
1
```
  也可以使用 dict() 构造函数创建字典。
```
another_dict = dict(name='Bob', age=30, city='Dreamland')
1
```
2. 访问字典元素：
  
  使用键来访问字典中的值。
```
print(my_dict['name'])  # 输出: Alice
1
```
  如果键不存在，会引发 KeyError。为了避免这种情况，可以使用 get() 方法。
```
print(my_dict.get('gender', 'Unknown'))  # 输出: Unknown
1
```
3. 修改字典：
  
  可以通过给已有的键赋新值或添加新的键值对来修改字典。
```
my_dict['age'] = 26
my_dict['gender'] = 'Female'
1
2
```
4. 删除字典元素：
  
  使用 del 关键字可以删除字典中的键值对。
```
del my_dict['city']
1
```
5. 遍历字典：
  
  可以使用 for 循环遍历字典的键值对。
```
for key, value in my_dict.items():
    print(key, value)
1
2
```
6. 字典方法：
  - keys(): 返回字典中所有的键。
  - values(): 返回字典中所有的值。
  - items(): 返回字典中所有的键值对（元组形式）。
```
keys_list = my_dict.keys()
values_list = my_dict.values()
items_list = my_dict.items()
1
2
3
```
7. 字典长度：
  
  使用 len() 函数可以获取字典中键值对的个数。
```
length = len(my_dict)
1
```
8. 清空字典：
  
  使用 clear() 方法可以清空字典中的所有键值对。
```
my_dict.clear()
1
```
9. 字典复制：
  
  使用 copy() 方法可以复制一个字典。
```
copied_dict = my_dict.copy()
1
```
10. 字典推导式：
  
  类似于列表推导式和集合推导式，Python 还支持字典推导式的语法。
```
squares_dict = {x: x**2 for x in range(10)}
1
```
字典是一种非常灵活和实用的数据结构，适用于需要通过键来查找、插入或删除元素的场景。由于字典是可变的，因此可以在运行时动态地修改和扩展。

九、字节数组类型(bytes)

在 Python 中，bytes 类型是一个不可变的序列，表示二进制数据。bytes 对象包含的是字节（8 位），而不是像字符串那样的字符。每个字节都用整数值表示，范围从 0 到 255。

bytes 对象的创建可以通过以下几种方式：
1. 字面常量表示法：
```
my_bytes = b'hello'
1
```
  这里 b 前缀表示这是一个字节字符串。
2. bytes() 构造函数：
```
my_bytes = bytes([104, 101, 108, 108, 111])
1
```
  这里传递一个整数列表，每个整数代表一个字节的值。
3. encode() 方法：
  
  可以使用字符串的 encode() 方法将字符串转换为字节。
```
my_bytes = 'hello'.encode('utf-8')
1
```
  这里 'utf-8' 是指定字符编码方式。
bytes 对象的一些常见操作和特性：
- 索引和切片：
  
  bytes 对象可以通过索引和切片进行访问。
```
print(my_bytes[0])          # 输出: 104
print(my_bytes[:3])         # 输出: b'hel'
1
2
```
- 不可变性：
  
  与字符串类似，bytes 对象是不可变的，不能修改其中的元素。
```
my_bytes[0] = 65  # 会引发 TypeError
1
```
- 长度：
  
  使用 len() 函数可以获取 bytes 对象的长度。
```
length = len(my_bytes)
1
```
- 转换为字符串：
  
  使用 decode() 方法可以将 bytes 对象转换为字符串。
```
my_string = my_bytes.decode('utf-8')
1
```
- 十六进制表示：
  
  使用 hex() 函数可以获取 bytes 对象的十六进制表示。
```
hex_representation = my_bytes.hex()
1
```
- 迭代：
  
  bytes 对象是可迭代的，可以用于 for 循环。
```
for byte in my_bytes:
    print(byte)
1
2
```
bytes 类型通常用于处理二进制数据，例如读取或写入文件、网络通信等场景。在处理文本时，更常用的是 str 类型，而在需要直接处理字节数据时，bytes 是一个常见的选择。

在 Python 中，字节数组类型 bytearray 与 bytes 类型相似，都表示二进制数据。主要区别在于，bytearray 是可变的，可以通过索引和切片进行修改，而 bytes 对象是不可变的。

以下是使用 bytearray 的一些基本操作：
1. 创建字节数组：
```
my_bytearray = bytearray(b'hello')
1
```
  这里通过字节字符串创建了一个字节数组。
2. 索引和切片：
```
print(my_bytearray[0])          # 输出: 104
print(my_bytearray[:3])         # 输出: bytearray(b'hel')
1
2
```
  与 bytes 类似，bytearray 对象可以通过索引和切片进行访问。
3. 修改元素：
```
my_bytearray[0] = 65
1
```
  与 bytes 不同，bytearray 是可变的，可以通过索引进行元素的修改。
4. 添加元素：
```
my_bytearray.append(100)
1
```
  使用 append() 方法可以向字节数组末尾添加一个字节。
5. 删除元素：
```
del my_bytearray[1]
1
```
  使用 del 关键字可以删除指定索引处的元素。
6. 插入元素：
```
my_bytearray.insert(2, 111)
1
```
  使用 insert() 方法可以在指定索引处插入一个字节。
7. 转换为字节数组：
```
byte_array_copy = bytearray(my_bytearray)
1
```
  可以通过传递另一个字节数组或 bytes 对象来创建一个新的字节数组。
8. 转换为字符串：
```
my_string = my_bytearray.decode('utf-8')
1
```
  使用 decode() 方法将字节数组转换为字符串。
bytearray 类型通常用于那些需要动态修改的场景，例如解析二进制数据、图像处理等。在需要不可变的字节序列时，bytes 类型更为适用。

十、Python数据类型转换

在 Python 中，可以使用内置的类型转换函数进行不同数据类型之间的转换。以下是一些常见的数据类型转换函数：
1. 整数转换：
  - int(x)：将 x 转换为整数。例如，int('123') 将字符串 '123' 转换为整数 123。
2. 浮点数转换：
  - float(x)：将 x 转换为浮点数。例如，float('3.14') 将字符串 '3.14' 转换为浮点数 3.14。
3. 字符串转换：
  - str(x)：将 x 转换为字符串。例如，str(123) 将整数 123 转换为字符串 '123'。
4. 列表转换：
  - list(x)：将可迭代对象 x 转换为列表。例如，list('hello') 将字符串 'hello' 转换为列表 ['h', 'e', 'l', 'l', 'o']。
5. 元组转换：
  - tuple(x)：将可迭代对象 x 转换为元组。例如，tuple([1, 2, 3]) 将列表 [1, 2, 3] 转换为元组 (1, 2, 3)。
6. 集合转换：
  - set(x)：将可迭代对象 x 转换为集合。例如，set([1, 2, 2, 3]) 将列表 [1, 2, 2, 3] 转换为集合 {1, 2, 3}。
7. 字典转换：
  - dict(x)：将可迭代对象 x 转换为字典。例如，dict([('a', 1), ('b', 2)]) 将包含键值对的列表转换为字典 {'a': 1, 'b': 2}。
8. 布尔值转换：
  - bool(x)：将 x 转换为布尔值。通常，非零数字、非空字符串、非空列表、非空元组等都会转换为 True，而 0、空字符串、空列表、空元组等会转换为 False。
9. 十六进制、八进制、二进制转换：
  - hex(x)：将整数 x 转换为十六进制字符串。
  - oct(x)：将整数 x 转换为八进制字符串。
  - bin(x)：将整数 x 转换为二进制字符串。
这些转换函数在处理不同数据类型之间的转换时非常有用，可以根据需要选择适当的函数进行转换。

十一、隐式类型转换、显式类型转换

有时候，我们需要对数据内置的类型进行转换，数据类型的转换，一般情况下你只需要将数据类型作为函数名即可。

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

隐式类型转换 - 自动完成

在编程语言中，隐式类型转换是指在一些表达式或操作中，编译器或解释器会自动地将一种数据类型转换为另一种，而无需程序员明确地进行转换操作。这种转换通常是为了满足操作符或函数对特定类型的要求。

举例来说，如果你有两个整数 a 和 b，而你试图执行 a + b 操作，编译器会隐式地将它们的值相加，而无需你显式地将其中一个转换为浮点数。这是因为 + 操作符在这种上下文中期望数值类型。

在隐式类型转换中，通常涉及到不同类型之间的转换，例如整数到浮点数、浮点数到整数、整数到字符串等。编程语言规定了这些转换的规则，以确保在进行操作时能够保持语义上的一致性。

以下是一些常见的隐式类型转换的例子：
1. 整数和浮点数：
```
a = 5
b = 2.0
result = a + b  # 隐式地将整数 a 转换为浮点数
1
2
3
```
2. 整数和字符串：
```
a = 10
b = "5"
result = a + int(b)  # 隐式地将字符串 b 转换为整数
1
2
3
```
3. 浮点数和字符串：
```
a = 3.14
b = "2.0"
result = a + float(b)  # 隐式地将字符串 b 转换为浮点数
1
2
3
```
4. 其他类型的隐式转换：
  
  在不同的编程语言中，还有许多其他类型的隐式转换，如布尔值和整数、字符和整数等。
需要注意的是，虽然隐式类型转换提供了方便，但有时也可能引发一些意外的问题。程序员应该了解编程语言中的隐式类型转换规则，并谨慎处理可能导致精度损失或不符合预期的情况。

显式类型转换 - 需要使用类型函数来转换

显式类型转换是指程序员明确地使用语言提供的转换操作符或函数将一个数据类型转换为另一个数据类型。与隐式类型转换不同，显式类型转换需要开发者明确地指定转换的目标类型，以确保在类型之间进行转换时不发生意外的情况。

在许多编程语言中，显式类型转换通常涉及使用转换函数或转换操作符。以下是一些常见编程语言中的显式类型转换的示例：

1. Python

在 Python 中，可以使用内置的转换函数进行显式类型转换，例如 int()、float()、str() 等：
```
a = 5
b = "10"
result = a + int(b)  # 显式将字符串 b 转换为整数
1
2
3
```
2. C++

在 C++ 中，可以使用类型转换操作符或类型转换函数进行显式类型转换：
```
double a = 3.14;
int b = static_cast<int>(a);  // 显式将浮点数 a 转换为整数，使用 static_cast
1
2
```
3. Java

在 Java 中，可以使用强制类型转换进行显式类型转换：
```
double a = 3.14;
int b = (int) a;  // 显式将浮点数 a 转换为整数，使用强制类型转换
1
2
```
4. JavaScript

在 JavaScript 中，可以使用一些构造函数或方法进行显式类型转换：
```
let a = "5";
let b = Number(a);  // 显式将字符串 a 转换为数字，使用 Number 构造函数
1
2
```
5. C#

在 C# 中，可以使用一些内置方法进行显式类型转换：
```
double a = 3.14;
int b = Convert.ToInt32(a);  // 显式将浮点数 a 转换为整数，使用 Convert.ToInt32 方法
1
2
```
显式类型转换提供了更多的控制权和明确性，使得程序员能够更精确地指定转换的方式和规则。但需要注意的是，不同语言的显式类型转换的语法和方法可能有所不同，因此在具体的编程语言中需要查阅相应的文档和规范。
相关阅读:
【数据结构 | 链表】leetcode 2. 两数相加
 Spark3.x入门到精通-阶段一(入门&yarn集群&java和scale双语开发)
用stream流将list转为map
从某达OA到Yii2框架的cookie反序列化漏洞研究
 香橙派orangepi ubuntu 安装安装redis
用大白话解释“什么是ERP？” 看完这篇就全明白了
 java IO流序列化流
 如何做好分布式任务调度——Scheduler 的一些探索
 Advances in Graph Neural Networks笔记2：Fundamental Graph Neural Networks
物联网组件
原文地址：https://blog.csdn.net/m0_62140641/article/details/134419338

一、标准数据类型

二、Number（数字）

isinstance 和 type 的区别在于：

数值运算

三、String（字符串）

四、bool（布尔类型）

五、List（列表）

六、Tuple（元组）

七、Set（集合）

八、Dictionary（字典）

九、字节数组类型(bytes)

十、Python数据类型转换

十一、隐式类型转换、显式类型转换

隐式类型转换 - 自动完成

显式类型转换 - 需要使用类型函数来转换

1. Python

2. C++

3. Java

4. JavaScript

5. C#