|--------------------------------------------------------------------------------|------------------------------------------------------------------------------|
| 作者简要描述 | |
| 算法篇 | Linux篇 |
| QT百日筑基篇 | 数据结构篇 |
| python篇 | |
先说明一下：我使用的环境是vscode+ubuntu
目录/索引：
目录
[扩展： IEEE54标准](#扩展： IEEE54标准)
[关系运算符： > < == >= <= !=](#关系运算符： > < == >= <= !=)
[逻辑运算符：and（并且， 两者都是真的那就为真） or（或者，两者有一个真的那就为真） not（逻辑取反）](#逻辑运算符：and（并且， 两者都是真的那就为真） or（或者，两者有一个真的那就为真） not（逻辑取反）)
[身份运算符（is，not is）](#身份运算符（is，not is）)
[成员运算符（in， not in）](#成员运算符（in， not in）)
[位运算（<< >> ~ & |)](#位运算（<< >> ~ & |))
在我们学习一种编程语言的时候是一定是要先学习一下他们的输入输出的，那现在也不例外。
python的输出：
函数print
作用：用于输出。
示例一：简单输出一个字符串
python
print("你好python")输出：
示例二：计算+-
python
print(1+2)
print(1.1+2.2)
print(1-2)输出：
这里我们发现了我们的浮点数计算是有一些差异的像我们这样的数后面的数可以进行忽略的他的遵循一个IEEE54标准。
扩展： IEEE54标准
关键字：在python中IEEE54如何影响浮点数的。
由文心一言进行生成：
浮点数在计算机中基于 IEEE 754 标准进行存储和运算，由于其采用有限的二进制位来近似表示实数，不可避免地会产生精度问题。这些精度问题会对计算结果的准确性、系统稳定性以及业务逻辑产生深远影响，主要体现在以下几个方面：
- 表示误差与舍入误差
无法精确表示十进制小数：许多常见的十进制小数（如 0.1、0.3）在二进制中是无限循环小数。由于存储空间有限（单精度 float 为 32 位，双精度 double 为 64 位），计算机只能存储其近似值。例如，0.1 + 0.2 的结果往往不是精确的 0.3，而是 0.30000000000000004。
舍入误差累积：在连续的浮点数运算中每次操作都可能引入微小的舍入误差。随着运算次数的增加，这些误差会逐渐累积，导致最终结果与理论值产生显著偏差。在迭代计算（如数值积分、级数求和）中，这种累积效应尤为明显。- "大数吃小数"现象（有效位丢失）
数量级差异导致的精度丧失浮点数由符号位、指数位和尾数位组成。当两个数量级差异巨大的浮点数相加时较小的数需要调整指数以对齐较大数的指数，这可能导致较小数的有效位右移超出尾数位的存储范围从而被直接丢弃。
实例影响：例如，一个值为 20,000,000 的单精度浮点数加上 1，结果可能仍然是 20,000,000。这是因为两者指数位差异过大，加数"1"的有效位在对其过程中完全丢失。这在处理大规模数据统计或科学模拟时，可能导致微小但重要的变化被忽略。- 对特定领域的严重影响
金融计算风险：在货币计算、利息结算高频交易等场景中，浮点数的微小误差可能导致金额不一致，引发财务纠纷或巨额经济损失。因此，金融领域通常严禁直接使用浮点数进行金额计算，而推荐使用定点数或高精度 decimal 类型。
科学工程计算失真：在物理学模拟、气候模型、分子动力学等需要长时程积分的科学计算中，单精度浮点数可能因误差累积过快导致结果完全失真甚至发散。双精度浮点数虽然精度更高（15-17 位有效数字），但在极端高精需求下仍需谨慎处理。
图形渲染异常：在计算机图形学和游戏开发中，浮点数精度不足可能导致物体坐标计算错误，出现画面抖动、纹理错位或碰撞检测失效等视觉瑕疵。- 逻辑判断与控制流错误
相等比较失效：由于精度误差，直接使用 == 判断两个浮点数是否相等通常是错误的。例如，经过一系列运算后得到的 0.3 可能与直接赋值的 0.3 在底层二进制表示上不完全一致。
程序逻辑崩溃：如果程序依赖浮点数的精确相等性来决定分支逻辑（如循环终止条件、状态切换），精度问题可能导致死循环、逻辑跳过或程序崩溃。正确的做法是使用一个极小的误差范围（epsilon）来判断两个数是否"足够接近"。- 特殊值的处理复杂性
NaN 与 Infinity：浮点数运算可能产生非数字（NaN）或无穷大（Infinity）。如果代码未对这些特殊值进行妥善处理，它们会在后续运算中传播，导致整个计算链条的结果无效，且难以排查根源。
应对策略简述为了减轻上述影响，通常采取以下措施：
使用高精度类型：如对精度要求极高的场景使用 decimal 模块（Python）或 BigDecimal（Java）。
整数化运算：在金融场景中，将金额转换为最小单位（如"分"）使用整数运算。
算法优化：使用 Kahan Summation 等算法减少累加误差，或调整运算顺序以减少大数吃小数现象。
容差比较：在比较浮点数时，使用 abs(a - b) < epsilon 而非直接相等判断。
变量的定义：
在变量的定义中我们不需要像C语言那样要进行写类型int double那样的类型。
我们的书写一般是 "变量=值" 的方式进行书写。
python
a=20
b='c'
c=1.1
print(a)
print(b)
print(c)
type函数，进行查看对应的变量的类型
python
a=20
b='c'
c=1.1
print(type(a))
print(type(b))
print(type(c))在我们py中我们的字符串用str(srtring)来进行表示，我们的浮点数用float来表示，在我们的c/c++中我们的float表示单精度的变量，我们的double表示双精度的变量，在我们的py中只有float并且他也是表示双精度的变量。
在python中他的数据范围是无穷的，当我们的范围太大时他会自主进行扩容的。
字符串的操作
我们想要在字符串里加字符串的，之用一个""是不行的
可以采用"和'混用的情况来进行
python
a='你好我正在学习"python"'
print(a)
但是如果我们的数据出现了"/'同时存在的情况我们可以使用"""或者'''来进行字符串的引用
cpp
a="""你好我正在'认真'学习"python"""
len的使用
作用：像c/c++中的strlen一样计算字符串的大小
python
a="abcd"
print(len(a))
+：连接字符串
cpp
a="hello"
b="word"
print(a+b)
布尔类型
当然在py中也支持bool类型，这里要注意的是我们的python中True的第一个字母是要进行大写的。False也是。
python
print(type(True))
print(type(False))
动态类型的使用
我们在python中我们的类型是能发生变化的，像我们下面的代码我们的a先是int然后是str最后是float，我们a的类型是能进行动态的变化的。
python
a=1
print(a)
a="a"
print(a)
a=1.1
print(a)
注释：
在python中注释有三种：
1. # 最常用
2. """ """ 一般写一下文档的介绍。
3.''' '''
python
"""
a=1
print(a)
a="a"
print(a)
a=1.1
print(a)
"""常用的快捷键：
ctrl+/ 大面积的注释。
ctrl+z 撤销
ctrl+y 取消撤销ctrl+f 查找
ctrl+D 复制当前行到下一行
print进阶：
我们有时候想要将前面带上一些字符串
这里前面的f代表格式化的意思。后面的{a+b}是计算变量a+b不是字符串的a+b
python
a=10
b=20
print(f"a+b的结果是{a+b}")
python中的输入
我们在python中使用input来进行输入，他的返回值是str类型的，有的时候想要使用别的类型的我们需要进一步的进行转化。
python
num = input()
print(num)
print(type(num))
转化：
变量=类型（变量）
python
num= input()
num =int(num)
print(num)
print(type(num))
python中的运算符：
算数运算符： + - * / %(取模) **(平方) //（除但是取整）
python
print(1+1)
print(2+1)
print(1*3)
print(4/2)
print(2**2)
print(2//2)
print(2%2)
关系运算符： > < == >= <= !=
python
print(3==1+2)
print(0.3 == 0.2+0.1)这里要注意的是0.2+0.3后面肯定有一个很小很小的小数让他们不相等，所以这里判断为不相等(IEEE54标准)。
像我们在c/c++中不支持 a<b<c 但在py中可以这样进行操作。
python
a=1
b=2
c=3
print(a<b<c)
逻辑运算符：and（并且， 两者都是真的那就为真） or（或者，两者有一个真的那就为真） not（逻辑取反）
python
a=1
b=2
c=3
print(a<b and b<c)
python
a=1
b=2
c=3
print(a<b and b<c)
print(a<b or c<b)
print(a>b or b>c)
print(not(a<b and b<c))
多元赋值
像我们的c/c++是不支持多元赋值的。
python
a,b =1,2
print(a)
print(b)这样是把1赋值给了a,把2给了b。
多元赋值一般会用作交换
python
a=1
b=2
print(f"交换前：a={a}b={b}")
c=a
a=b
b=c
print(f"交换后：a={a}b={b}")
e=1
f=2
print(f"交换前：e={e}f={f}")
e,f=f,e
print(f"交换后：e={e}f={f}")
身份运算符（is，not is）
在 Python 中，身份运算符（Identity Operators） 用于判断两个变量是否引用了同一个对象（即它们在内存中的地址是否相同），而不是判断它们的值是否相等。
Python 提供了两个身份运算符：
is：如果两个变量指向同一个对象，返回True；否则返回False。is not：如果两个变量指向不同的对象，返回True；否则返回False。
python
a = [1, 2, 3]
b = a # b 指向 a 所在的内存地址
c = [1, 2, 3] # c 创建了一个新的列表对象，内容相同但地址不同
print(a is b) # True (a 和 b 是同一个对象)
print(a is c) # False (a 和 c 是不同的对象，尽管值相等)
print(a == c) # True (它们的值相等)
print(a is not c) # True (a 和 c 不是同一个对象)
成员运算符（in， not in）
在 Python 中，成员运算符（Membership Operators）用于判断一个值是否存在于某个序列或集合中。Python 提供了两个成员运算符：in 和 not in。它们返回布尔值（True 或 False），是进行数据检查、过滤和条件判断时最常用的工具之一。
- 核心定义
in：如果指定的值存在于序列/集合中，返回 True；否则返回 False。
not in：如果指定的值不存在于序列/集合中，返回 True；否则返回 False。
python
text = "Hello, Python!"
print("Python" in text) # True
print("java" in text) # False
print("H" not in text) # False
位运算（<< >> ~ & |)
这里位运算就不过多的进行说明了。
下一篇条件语句和循环
