【聪明办法学 Python】Chapter 2 数据类型和操作-CSDN博客

本文链接：https://blog.csdn.net/2301_81558576/article/details/137938639

Task03：数据类型和操作 Data Types and Operators

作业链接：https://hydro.ac/d/datawhale_p2s/user/48176

· 常用内置类型

· def→是define（定义的缩写）

· 整数和离散

机器学习的两个大任务：分类与回归

回归：例如给人工智能一堆数据，让其回答买一台电脑多少钱。人工智能会回复一个数字范围，是连续的（整数）

分类：例如问人工智能7000块可以买什么东西，给出许多不同回答，其是离散的（离散）

· 布尔值只有两种，真或者假

· 类型Type是用来判断其他数据的类型，而type本身也是一种类型

↑判断为整数

Python的底层语言是C语言，C语言中有两种浮点类型：单精度和双精度。Python中的浮点型默认对应C语言中的双精度浮点型。

首先，Python是一种高级编程语言，它允许程序员用相对简单和直观的方式来编写代码。但是，Python代码最终需要转换成计算机能够理解的机器语言才能运行。这个转换过程通常是由编译器或解释器来完成的。

Python的底层语言是C语言，这意味着Python的很多底层操作和数据结构都是用C语言实现的。C语言是一种低级语言，它更接近计算机硬件，执行效率很高。

在C语言中，浮点类型是用来表示小数的。C语言提供了两种主要的浮点类型：

单精度(float)：这种类型可以存储较小范围的浮点数，但计算速度更快。它通常用于需要快速计算但不需要特别高精度的场景。

双精度(double)：这种类型可以存储更大范围和更高精度的浮点数。它适用于需要高精度计算的场景，但计算速度可能稍慢。

Python中的浮点型默认对应C语言中的双精度(float)浮点型。这意味着当你在Python中使用浮点数时，Python解释器实际上是在背后使用C语言的双精度类型来存储和计算这些浮点数。选择双精度作为默认类型，是因为Python设计者认为在大多数情况下，程序员更关心数值的精度而不是计算速度。

简单来说，就像你用一支高级的笔来写字，这支笔的内部构造和工作原理可能很复杂，但你只需要关注如何使用它来写出漂亮的字。Python就是这支高级的笔，而C语言就像是笔的内部构造，确保了Python能够高效地运行。当你在Python中写入一个浮点数时，Python会用它内部的C语言机制来处理这个数，确保你得到准确的计算结果。

复制再试一次分享

· @在Python中表示矩阵乘法

·**表示多少次方 eg. 3**2=9

· % 模运算，即余数是多少5%2=1

· ↑Python中的相等是==，一个=是赋值

· 不同类型之间的运算会影响运算方式

结合率：加减乘除是从左往右，次方是从右往左算

浮点数误差出现的原因是：计算机使用二进制，人正常使用的是十进制

在Python中，当你执行这样的计算 `0.1 + 0.1 + 0.1 - 0.3`，实际上你可能会得到一个非常接近于0，但不是精确0的结果。这是因为计算机中浮点数的表示和运算存在精度限制，导致所谓的“浮点误差”。

浮点数在计算机中是如何表示的呢？它们通常遵循IEEE 754标准，使用二进制浮点数表示法。这个表示法涉及到一个符号位、指数部分和尾数部分。问题在于，并不是所有的十进制小数都能精确地转换为二进制小数。有些小数在二进制中是无限循环的，而计算机只能存储有限的小数位数，因此必须进行舍入。

例如，十进制中的 `0.1` 转换成二进制是一个无限循环的小数，计算机会存储最接近的二进制近似值。当你执行 `0.1 + 0.1 + 0.1` 时，计算机实际上是在加三个这样的近似值，结果也是一个近似值。当你从这个近似值中减去 `0.3`（它本身也是一个近似值）时，最终结果会非常接近于0，但由于舍入误差，它不会精确等于0。

为了更好地理解这个问题，你可以在Python中打印出每一步的计算结果：

```python
print(0.1) # 输出0.1的近似值
print(0.1 + 0.1) # 输出0.1 + 0.1的近似值
print(0.1 + 0.1 + 0.1) # 输出0.1 + 0.1 + 0.1的近似值
print(0.1 + 0.1 + 0.1 - 0.3) # 输出最终结果
```

你会发现每一步的结果都与预期的数学结果有微小的差异。

要解决这个问题，你可以使用Python的 `decimal` 模块，它提供了更高精度的十进制数运算：

```python
from decimal import Decimal, getcontext

# 设置decimal模块的精度
getcontext().prec = 6

# 使用Decimal进行精确计算
result = Decimal('0.1') + Decimal('0.1') + Decimal('0.1') - Decimal('0.3')
print(result) # 这将输出0
```

使用 `decimal` 模块可以避免浮点数的舍入误差，因为它允许你以任意精度进行十进制数的运算。

好的，让我们一步步来解释为什么十进制中的 `0.1` 在二进制中是一个无限循环的小数。

首先，我们需要理解十进制和二进制之间的转换。十进制是基于10的数制，而二进制是基于2的数制。在十进制中，每一位的值是10的幂次方，而在二进制中，每一位的值是2的幂次方。

### 十进制转二进制的简单例子：
- 十进制的 `1`（1*10^0）在二进制中表示为 `1`。
- 十进制的 `2`（2*10^0）在二进制中表示为 `10`。

### 十进制小数转二进制小数：
- 十进制 `0.5` 转换为二进制是 `0.1`（因为 0.5 * 2 = 1，所以小数点后第一位是1，第二位是0，即0.5）。

### 为什么 `0.1` 是无限循环的？
当我们尝试将十进制的 `0.1` 转换为二进制时，我们实际上是在寻找一个分数，它乘以2的某个幂次方后结果是一个整数。但 `0.1` 并不符合这个条件。

让我们尝试将 `0.1` 转换为二进制：
1. 将 `0.1` 乘以2，得到 `0.2`（不是整数，继续）。
2. 将 `0.2` 乘以2，得到 `0.4`（不是整数，继续）。
3. 这个过程会无限进行下去，因为 `0.1` 乘以任何2的幂次方都不会得到一个整数。

实际上，如果我们尝试找到一个近似值，我们会发现 `0.1` 可以表示为一个无限循环的二进制小数：
- `0.1` 约等于二进制的 `0.0001100110011...` 并且这个模式会无限重复下去。

### 为什么计算机中 `0.1` 不能精确表示？
计算机在存储浮点数时，只能使用有限的位数来表示这个数。由于 `0.1` 的二进制表示是无限循环的，计算机只能存储这个循环序列的一部分。因此，计算机中的 `0.1` 是一个近似值，不是精确值。

当你在Python中输入 `0.1` 时，实际上Python内部存储的是一个最接近 `0.1` 的二进制近似值，这会导致后续的计算出现浮点误差。这就是为什么当你计算 `0.1 + 0.1 + 0.1 - 0.3` 时，最终结果不会精确等于 `0` 的原因。

↓短路运算至少要算第一个：

and：如果X为false，就无需判断Y，直接输出false；如果X为Ture，则需继续判断Y是否为True。

↑使用type判断整数和浮点数不能覆盖所有数字，因为不包含复数

type() 严格检查对象的类型，不考虑继承关系。
isinstance() 检查对象是否是某个类的实例，包括该类的所有子类实例。

使用场景：

当你需要知道对象的确切类型时，使用 type()。
当你需要检查对象是否是某个类的实例，或者是否是某个类的派生类的实例时，使用 isinstance()。

在判断类型时推荐使用isinstance来判断

print() 函数没有显式地进行布尔运算，它也会隐式地将布尔值转换为它们的字符串表示形式，以便输出。这个转换过程是自动的，你不需要手动进行布尔到字符串的转换。

如果你想要更明确地展示布尔值的逻辑真值或假值，你可以在 print() 中直接打印布尔值，例如：
print(isNumber(1)) # 输出: True 或 False print(bool(isNumber(1))) # 显式地将结果转换为布尔值

在这个例子中，bool(isNumber(1)) 是一个显式的布尔运算，它会返回 True 或 False 的逻辑值，但通常这是不必要的，因为 print() 已经足够智能，能够处理布尔值并正确地输出它们的字符串表示。

· 用户输入的一定是字符串

作业：

当你调用 isNumber 函数并传入一个参数时，比如 isNumber(10)，函数会执行 isinstance(10, numbers.Number)，检查数字 10 是否是一个数字类型，并返回结果 True 或 False。

简单来说，def isNumber(x): 定义了函数的名称和它接收的输入，而 return isinstance(x, numbers.Number) 是这个函数的“大脑”，它告诉函数如何根据输入来判断并返回结果。