03-数字型
1. ipython 数字型规律引入
1.1 实例演示
In [1]: 1 + 1
Out[1]: 2
In [2]: 1 + 1.0
Out[2]: 2.0
In [3]: 2 - 1
Out[3]: 1
In [4]: 2 - 1.0
Out[4]: 1.0
In [5]: 2 * 2
Out[5]: 4
In [6]: 2 * 2.0
Out[6]: 4.0
In [7]: 9/3
Out[7]: 3.0
In [8]: 9/3.0
Out[8]: 3.0
In [9]: 9.0/3
Out[9]: 3.0
In [10]: 9.0/3.0
Out[10]: 3.0
In [11]: 3.0*3.0
Out[11]: 9.0
In [12]: 9.00/3
Out[12]: 3.0
In [13]: 9.00/3.00
Out[13]: 3.0
In [14]: 2 * 2.00
Out[14]: 4.0
In [15]: 2.00 * 2.00
Out[15]: 4.0
In [16]: 1.00 + 1
Out[16]: 2.0通过上述示例，我们能总结出两处结论：
非除法（整除和取余也是非除法）运算式如果其中含有一个浮点数，就会得到浮点数「优先级最高」，且结果的浮点数一定是只保留一位小数，若无浮点数则结果无小数
除法计算式中涉及精度问题，结果必为浮点数，在能除尽且小数不超过1位的情况下结果必定保留一位小数，在除不尽的情况下保留16位小数
1.2 ipython 数学计算较 pycharm的优势
ipython 较 pycharm 运算便捷的多
ipython 能很好的保存之前的输出记录
ipython 能有很好的对比性，方便找出规律
47f8c72d08e7e2b94c7470f07082975d
但 ipython 保存代码能力很弱，故需要代码参与时用pycharm
2. 算数运算符
用于计算
| 运算符 | 描述 | 例子 |
|---|---|---|
+ | 加法运算符 | 1 + 1 = 2 |
- | 减法运算符 | 2 - 1 = 1 |
* | 乘法运算符 | 2 * 3 = 6 |
/ | 除法运算符 | 9 / 3 = 3.0 |
** | 指数运算符(注意0**0被规定为1，数学规定)，2**3**2=512 | 2 ** 3 = 8 |
%(%) | 取余运算符，计算余数 | 9 % 2 = 1 |
// | 除法取整运算符，计算商并去除其小数部分（注意，整除的去除小数不是四舍五入，而是全部取小，5.5//2是2.0，5.5//-2就变成了-3.0了） | 9 // 2 = 4 |
我们可输入：
num = 92
a = num % 10
b = num // 10
Q1 = a + b
Q2 = a * 10 + b
print("Q1:",Q1)
print("Q2:",Q2)来使该规律对任意二位整数生效
注意：%的原理为：
a % b == a - (a // b) * b从数学角度考虑a - (a / b) * b。这始终等于零。现在，a // b与进行比较a / b。向下取整除的结果永远不会大于除法的结果。考虑a / b用替换a // b，这会使 项更小。如果b为正数，则。如果为负数，则。在这两种情况下，余数的符号都与除数 的符号相同。a - (a // b) * b ≥ 0``b``a - (a // b) * b ≤ 0``b
这也就导致了
In [12]: 42%5
Out[12]: 2
In [13]: 42%-5
Out[13]: -3
In [14]: -42%5
Out[14]: 3
In [15]: -42%-5
Out[15]: -2结果都不相同
4. 比较运算符：比较值的大小
对于比较运算符，你只需知道运行结果会得到布尔类型即可。(大小判断正确就会显示ture，错误就会显示false)
注意：布尔型可以破例与数字型比较，且True视为无穷大，False视为无穷小，其它情况只能同类型代码比较
| 运算符 | 描述 | 例子 |
|---|---|---|
> | 判断第一个运算对象是否大于第二个运算对象 | Print(1 > 2) |
< | 判断第一个运算对象是否小于第二个运算对象 | print(1 < 2) |
>= | 判断第一个运算对象是否大于或等于第二个运算对象 | print(3 >= 3) |
<= | 判断第一个运算对象是否小于或等于第二个运算对象 | print(3 <= 4) |
== | 判断两个运算对象是否相等 | print(2 == 2) |
!= | 判断两个运算对象是否不相同 | print(2 != 1) |
is, is not | 判断两个运算对象是否等效 | print(a is b) |
in,not in | 判断第一个运算对象是否属于第二个运算对象 | print("as" in ["as","ad"]) |
注意：字符串之间也可以比大小，其比大小的方式就是取字符串的第一个字符进行比较,具体比较规则如下：
字符串内第一个字符均为数字时，直接比较字符串的大小，第一个字符均为字母时，根据字母表顺序排列比较，
“a”<"d",特殊字符时中文字符比英文字符大，当不同字符型比较时，一定有 ： 数字<字母<特殊字符,对字母来说，大写字母自动比小写字母小一级，满足Z<a仅同类型的代码可以进行比较，不同类型比较会报错
a = [1,2,3]
b = [1,2,3]
print(a is not b)结果为：
/Users/yhy/Coder/.venv/bin/python /Users/yhy/Coder/experiment/03.py
True
Process finished with exit code 0这说明a和b虽然赋同一个值但来自不同的源，这就导致两者id发生一定区别
/Users/yhy/Coder/.venv/bin/python /Users/yhy/Coder/experiment/03.py
4370921664
4370762304
Process finished with exit code 0
注意只要符合条件范围，python不会在意数学错误
当使用 or 时，python会先判定第一个是不是对的，如果对就直接true，不对再看后续，and 与之相反
原因：or是并集的意思，对python来说只要第一个正确那么结果就一定可以存在第一个的情况，那么就是true，而and是交集，只要有一个元素不正确，那整体就不正确，所以只要第一个是 False 那就是 False
注意：比较运算符的计算优先级永远高于逻辑运算符（and ，or，not，其中优先度not>and>or)
重要
is 与 == 区别 ：
is 用于判断两个变量引用对象是否为同一个， == 用于判断引用变量的值是否相等。
a is b 相当于 id(a)==id(b)，id() 能够获取对象的内存地址。
如果 a=10;b=a; 则此时 a 和 b 的内存地址一样的;
但当 a=[1,2,3]; 另 b=a[:] 时，虽然 a 和 b 的值一样，但内存地址不一样。
如果此时定义 a=10、b=10, 然后再对比 a is b 会发现返回的结果是 True，这是因为在 Python 中会实现创建一个小型的整形池，范围为 [-5,256]，为这些整形开辟好内存空间，当代码中定义该范围内的整形时，不会再重新分配内存地址。而我在 Pycharm 中进行测试：
2 < abc > 5 == 5 <= 10 == abc != -10我们需要知道比较运算符可以重复使用，其本质就是：
(2 < abc) and (abc > 5) and (5 == 5) and (5 <= 10) and (10 == abc) and (abc != -10)abc可以知道：这就是直接拆分了每个部分，分为了2<abc, abc>5, 5 == 5 等多个部分，注意拆分处理
5. 赋值运算符
接下来是赋值运算符，表格如下：
| 运算符 | 描述 | 例子 |
|---|---|---|
= | 把右边的运算对象赋值给左边的运算对象 | a=1 |
+= | a += b等同于a = a + b | a += 10 |
-= | a -= b等同于a = a - b | a -= 10 |
*= | a *= b等同于a = a*b | a *= 10 |
/= | a /= b等同于a = a/b | a /= 10 |
**= | a **= b等同于a = a ** b | a **= 10 |
//= | a //= b等同于a = a // b | a //= 10 |
%= | a %= b等同于a = a % b | a %= 10 |
用途：在代码输入时能省大量时间：
a = 1
a = a+10
print(a)a = 1
a += 10
print(a)两者效果相同
利用了变量的覆盖特性
但注意，该方法不兼容一行多个赋值符号的运算方式
xx = 7.4
xx = xx *= 1 + 2 + 3 + 4这是会直接报错的
训练：
a = 1
a += 10
a -= 10
a *= 10
a /= 10
a **= 10
a //= 10
print(a)结果不是0，是0.0
因为第五步出现了除法运算，导致从此之后的运算都会出现浮点数，导致输出结果为0.0
另外：在python中 0.0 == -0.0
6. 为什么需要赋值运算符
- 基础运算符：通常不会直接修改操作数本身，而是返回一个新的结果
- 赋值运算符：将某个值赋予某个变量，分为普通赋值运算符(
=)和复合赋值运算符(+=,-=等)，它们结合了基础运算符和赋值的功能
赋值运算符的引入简化代码，提高代码的可读性和可维护性，能减少出错概率
总结：基础运算符用于数学计算，赋值运算符用于在执行运算过程中将结果赋值给变量
7. 小试牛刀
x = 4.5
y = 2
print(x // y)结果是：
2.0
x = 4
y = 2
print(x // y)结果是：
2
综上：优先级 算术运算符>比较运算符>逻辑运算符
8. Float,int 和 complex 函数
8.1 Float()
示例1: int 变float
a = 10
print(float(a))结果为：
/usr/local/bin/python3.14 /Users/yhy/Coder/experiment/07.py
10.0
进程已结束，退出代码为 0示例2: complex 变float
a = 10+1j
print(float(a))结果为：
/usr/local/bin/python3.14 /Users/yhy/Coder/experiment/07.py
Traceback (most recent call last):
File "/Users/yhy/Coder/experiment/07.py", line 2, in <module>
print(float(a))
~~~~~^^^
TypeError: float() argument must be a string or a real number, not 'complex'
进程已结束，退出代码为 1发现报错，这也就是说float函数和int函数都只能运行实数
注意：python中的浮点数都存在误差，这主要源于计算机内部使用二进制表示浮点数，导致许多十进制小数
在转换为二进制时会变成无限循环小数，而计算机只能通过舍入来存储有限的精度，从而引入误差。
这种误差会在多次运算后累积，导致结果不精确。
例：
In [10]: 0.1 +0.2 Out[10]: 0.30000000000000004也就意味着超过一个浮点数直接的相加一定会产生误差，导致0.1+ 0.2 != 0.3 的情况
同时，直接拿浮点数做乘法，如5.1*6也会产生误差
有趣的是分数在python中也会按浮点数处理
对于幂运算**(C)，如果指数为负整数，即使两个输入均为int，输出也为float
这是因为当指数为负整数时，幂运算实际上是取底数的倒数并进行正整数次幂运算，所以即使底数是整数，结果也通常是分数，因此会被转换为浮点数类型
比如2**-3python会将其先处理成
0.5**3再进行后续计算
float 类型分类：
1. 正常浮点数：0.5
2. 21. #小数点后无需任何数字
3. .42. #小数点前也无需任何数字
4. 123_456. #'_'可以添加到数字之间增加可读性，但注意_不能添加在数字的开头或结尾，也不能添加到小数点前和后,同时_不能连续存在多个(如1__2)，但可以分开多个存在，只能一个一个间隔
5. 0_0. #这就是0
6. 科学计数法 #python自动将科学计数法归纳为float，Python 使用 e 或 E 来表示科学计数法科学计数法：
{:.2e}是Python中用于格式化字符串的表示方法，它将数字格式化为科学计数法，并保留两位小数。 具体来说，“e”表示指数形式，“.”后面是小数点和数字2，这表示需要保留小数点后两位
其本质为：f'{number:.nf}'，其中 n 是要保留的小数位数与科学计数法的合并简化写法
8.2 int()
示例：float 变int
a = 10.9
print(int(a))结果为：
/usr/local/bin/python3.14 /Users/yhy/Coder/experiment/07.py
10
进程已结束，退出代码为 0观察发现：python化整不会进行四舍五入，而是直接输出其整数段
8.3 complex()
示例1: int变complex
a = 10
print(complex(a))结果为：
/usr/local/bin/python3.14 /Users/yhy/Coder/experiment/07.py
(10+0j)
进程已结束，退出代码为 0示例2: float变complex（小数点后为0）
a = 10.0
print(complex(a))结果为：
/usr/local/bin/python3.14 /Users/yhy/Coder/experiment/07.py
(10+0j)
进程已结束，退出代码为 0发现其实数段小数点后为0会直接变成整数
示例3: float变complex（小数点后不为0）
a = 10.9
print(complex(a))结果为：
/usr/local/bin/python3.14 /Users/yhy/Coder/experiment/07.py
(10.9+0j)
进程已结束，退出代码为 0发现实数段仍为float
9. 简单的逻辑演示-if-else
if - else statement
mark = int(input("输入你的成绩"))
if mark>= 80:
print("Good")
else:
print("bad")复杂一点：
mark = int(input("输入你的成绩"))
if mark>= 80:
print("Good")
elif mark >= 70:
print("normal")
else:
print("bad")注意：elif 是既有else 也就 if的一种简写，也就是说在此处的范围仅在70到80直接才会触发第二个
同时：我们可以利用不同级别的if 和else构造相同结果
也可以：
注意这里用的都是运算符号，千万不要用=赋值符号
另外：if-else还有一种表达方式：
n = 5
s = "hello" if n==5 else "Okay"
print(s)这种方式专门作用于赋值符号右侧的一次性表达
格式为：
s = 'content1' if 条件 else 'content2'这种表达一般不用elif
复杂表达可为：
n=100
s = 1 if n==1 else 2 if n==2 else 3
print(s)注意如果多个同级 if 同时存在，那么每个 if 都单独执行，不会因为上方已经执行而绕过下方代码
10. 判断的优化-match-case
示例：
match 表达式:
case 模式1:
# 执行代码块1
case 模式2 | 模式3: # 支持多个模式用 | 连接
# 执行代码块2
case 变量 as 别名: # 捕获变量
# 执行代码块3
case _: # 通配符模式，匹配任何值
# 执行默认代码块如：
status = 418
match status:
case 200:
print("OK")
case 404:
print("Not Found")
case _:
print("Other status")这里的__就是else的意思，只要是其它情况就会输出这个结果
本质上，这种语法是从上而下检索，而__实际上是任意结果都会匹配的符号，所以__一定要放最后一个case，不然会报错
11. 连续执行符：while（循环结构）
对比一下两个示例：
i = 1
if i<=10:
i += 1
print(i)结果为：
/Users/yhy/Coder/.venv/bin/python /Users/yhy/Coder/experiment/06.py
2
Process finished with exit code 0i = 1
while i<=10:
i += 1
print(i)结果为：
/Users/yhy/Coder/.venv/bin/python /Users/yhy/Coder/experiment/06.py
11
Process finished with exit code 0对比发现：if函数只会单次执行命令，而while函数则是只要执行命令后的i仍然符合条件(即 i<=10 ),重复执行命令直至i不再满足条件
非常有趣的是，如果循环永不停止，python不会输出任何结果，但输出界面不再无法修改，而是可以任意输入字符了
构造无限循环的万金油：while True:当条件为True时，即任意情况一定满足，就可以达到无限循环了
与 if 相同的是，while 也可以搭配 else 使用
a = 1 while a<=10: a+=1 else: print("a =",a)结果一定为：
/Users/yhy/Coder/.venv/bin/python /Users/yhy/Coder/experiment/06.py a = 11 Process finished with exit code 0只要 while 循环不是无限，就一定能输出else的结果
12. Range()
range函数表示范围
括号内按正常的区间格式填写：
注意：range区间内只包含整数,且默认左闭右开
print(list(range(0,5)))结果为：
/Users/yhy/Coder/.venv/bin/python /Users/yhy/Coder/experiment/06.py
[0, 1, 2, 3, 4]
Process finished with exit code 0
其中：步长默认为1，初始值默认为0
13. For-in 循环
for i in 'python':
print(i)执行以上代码：
/Users/yhy/Coder/.venv/bin/python /Users/yhy/Coder/experiment/06.py
p
y
t
h
o
n
Process finished with exit code 0我们发现：输出i时会依次输出in右侧的所有字符（除了决定性质的字符）
我们换一种代码形式试试：
for i in [1,2,3,4,5,6,7,8]:
print("输出:",i)结果为：
/Users/yhy/Coder/.venv/bin/python /Users/yhy/Coder/experiment/06.py
输出: 1
输出: 2
输出: 3
输出: 4
输出: 5
输出: 6
输出: 7
输出: 8
Process finished with exit code 0也就是说：
for 右侧的字符会自动被依次赋值为 in 右侧的代码字符，在输出结果时，就会出现这种依次输出的循环执行效果（此处的循环指的是不断重复相同的赋值过程）
注：这种循环用不了 True 来构造无限循环
r = range(3)
for i in r:
r = range(5)
print(i, end=' ')我们构造了一个内置的重新分配范围处理，看看会发生什么：
0 1 2在迭代期间重新分配范围变量不会影响当前循环。
为什么会发生这种情况：
- for 循环从初始值创建一个迭代器
range(3) r在循环内重新分配会创建一个新的范围对象- 迭代器继续执行原始序列
# Similar concept:
numbers = [1, 2, 3]
for num in numbers:
numbers = [4, 5, 6] # Doesn't affect current iteration
print(num) # Still prints 1, 2, 314. break函数
break函数能破坏一切循环的发生
for letter in 'Python': # 第一个实例
if letter == 'h':
break
print '当前字母 :', letter
var = 10 # 第二个实例
while var > 0:
print '当前变量值 :', var
var = var -1
if var == 5: # 当变量 var 等于 5 时退出循环
break
print "Good bye!"输出结果为：
当前字母 : P
当前字母 : y
当前字母 : t
当前变量值 : 10
当前变量值 : 9
当前变量值 : 8
当前变量值 : 7
当前变量值 : 6
Good bye!我们发现，当满足break触发条件时，会直接中断循环
但是：
for i in range(3):
for j in range(3):
if i == j == 1:
break
print(i, j)结果为：
0, 0
0, 1
0, 2
1, 0
2, 0
2, 1
2, 2出现了七串，这说明 break 只会破除它所在的最内层循环，而不影响外层循环
15. continue
与break在同一区域使用，表示继续循环，而不执行以下命令，一般用于在一定范围内圈出更小的范围不做执行下述命令
for i in range(5):
if i == 3:
continue
print(i,end=' ')结果就是：
/Users/yhy/Coder/.venv/bin/python /Users/yhy/Coder/experiment/07.py
0 1 2 4
Process finished with exit code 03不再执行以下命令
16 center居中
格式：.center(总长，填充符号)
17.sum 函数
用于存在多个元素的代码类型中数字型的加合，但只要存在非数字型元素，就会报错
18 max 和 min 函数
max和min用于提取一行代码中最大的值
注意：值的判定是与索引相关的，因此max和min函数可以作用于字符串，但不能作用于数字型
在列表类的代码中，当且仅当内部所有元素都为一类代码类型时才不会报错，如果内部的代码类型也是列表类的代码，那么会从元素中的第一个值进行比较，如果都相等，那就比第二个值，以此类推
a = [(1,2,4),(1,2,3,4,5)]
print(max(a))结果即为：
/Users/yhy/Coder/.venv/bin/python /Users/yhy/Coder/experiment/05.py
(1, 2, 4)
Process finished with exit code 0另：字符串中可以存在不同类型的字符，遵循特殊字符>字母>数字，字母按照字母表顺序比较大小（s>a)