第一章
讲一讲Unicode编码
Unicode（统一码、万国码）是一种字符集，它定义了世界上几乎所有的字符，包括各种文字、标点符号、符号等。Unicode编码使用16位或32位的二进制数来表示一个字符，每个字符都有一个唯一的编码，不同的字符有不同的编码。
UTF-8 是 Unicode 的一种实现方式，它是一种变长的编码格式，可以表示 Unicode 中的任何字符，并且兼容 ASCII 码。UTF-8 使用1到4个字节来表示一个字符，其中 ASCII 码使用 1 个字节表示，汉字使用 3 个字节表示。
举个例子，“Hello，世界！” 这句话，其中的 ‘H’、‘e’、‘l’、‘o’、‘,’、’ ‘、’!’ 这些字符对应的 Unicode 编码均为 ASCII 码，因此在 UTF-8 编码中均使用 1 个字节表示。而中文字符 ‘世’ 和 ‘界’ 则对应的 Unicode 编码为 U+4E16 和 U+754C，需要使用 3 个字节的 UTF-8 编码表示。因此，“Hello，世界！” 这句话在 UTF-8 编码中共占用 13 个字节。
在 Python 中，字符串默认采用 Unicode 编码。如果要以 UTF-8 编码保存文本文件，可以通过在文件头加上相应的 BOM（Byte Order Mark）来指示文件的编码格式：
python
# 输出 UTF-8 编码的文件
with open('file.txt', 'w', encoding='utf-8-sig') as f:
f.write('Hello，世界！')
这个例子中，utf-8-sig 指示要在文件头加上 BOM，以便在读取文件时自动识别编码格式。
其实说白了，也就是一种包含了几乎所有编码，然后用于计算机的码而已
标识符，关键字
标识符和关键字的命名和普通语言基本一致，开头只能以下划线和字母开头不能用数字开头，由数字，字母和下划线组成
注释
Python中的注释符号是#，后面的东西都不进行编译，仅供理解，就是注释
多行注释
在 Python 中，多行注释使用三个单引号或三个双引号来定义，通常用于说明函数、模块或类等对象的功能和使用方法，也可以用于暂时屏蔽一些代码段。例如：
python
"""
这是一个求两个数之和的函数。
参数：
- x：第一个数
- y：第二个数
返回值：两个数的和
"""
def add(x, y):
return x + y
多行输入，一行输入多行
例如a=1;b=2;c=3这样就是一行输入多行；这里面的规则是和c语言不一样的
然后多行输入，在某些情况下为了代码的可阅读性，会把原来很长的一行分解为许多行这样可以用反斜杠符号来进行实现
输入函数
Python中的输入函数有两种，一种是最为常见的input(),另一种多存在于读取文件中使用在工作中比较常见
input()：该函数从标准输入中读取一行文本，并将其作为字符串返回。可以通过提示信息向用户询问输入内容。例如：
python
-
name = input('请输入您的名字：') print('您好，' + name + '！')执行这段代码时，程序会向用户提示“请输入您的名字：”，等待用户输入，然后将用户输入的内容存入变量
name中，并输出一句问候语。 -
sys.stdin.readline()：该函数从标准输入中读取一行文本，并将其作为字符串返回。不同于input()函数的是，该函数不含任何提示信息，需要自行手动输出提示信息。例如：python
-
import sys name = sys.stdin.readline().strip() # 去除读入字符串末尾的换行符 print('您好，' + name + '！')执行这段代码时，程序会等待用户输入一行文本（最后记得按下回车键），然后将用户输入的内容存入变量
name中，并输出一句问候语。
需要注意的是，input() 函数的返回值是字符串类型，如果需要将输入的字符串转换成其他类型，可以使用 Python 的数据类型转换函数，例如：
python
age_str = input('请输入您的年龄：')
age = int(age_str)
print('您的年龄是：', age)
在这个例子中，input() 函数返回的是一个字符串类型的年龄数值，我们将其使用 int() 函数转换为整型数据，并输出一句问候语。
第二章基本数据类型
以下是 Python 中常见的数据类型及其说明：
数据类型
说明
整型（int）
有符号整数，例如 123、-456 等
浮点型（float）
单精度浮点数，例如 3.14、-1.23e3 等
复数（complex）
由实部和虚部组成的数值，例如 1+2j、2-3j 等
布尔型（bool）
只有两个值 True 和 False，用于逻辑判断
字符串（str）
由单个或多个字符组成的不可变序列，例如 ‘hello’、“world” 等
列表（list）
由任意数量的对象组成的有序序列，可以动态地增加、删除元素，例如 [1, 2, ‘three’, True] 等
元组（tuple）
由任意数量的对象组成的有序序列，一旦创建就不可更改，例如 (1, 2, ‘three’, True) 等
集合（set）
由一组互不相同的对象组成的无序集合，可以进行交、并、差等运算，例如 {1, 2, 3} 等
字典（dict）
由若干键值对组成的无序序列，键必须是唯一的，可以动态地增加、删除元素，例如 {‘name’: ‘Alice’, ‘age’: 20} 等
字节（bytes）
由单个字节组成的不可变序列，例如 b’hello’、b"\x41\x42\x43" 等
字节数组（bytearray）
由单个字节组成的可变序列，可以动态地修改、增加、删除元素，例如 bytearray(b’hello’) 等
需要注意的是，Python 中的数据类型比其他编程语言要更加灵活，同一变量也可以根据需要自动进行类型转换。同时，在进行运算或比较时，也会自动进行类型转换和提升。
在实际编程中，了解不同数据类型的特点和使用场景，能够更好地为程序员提供开发、优化、调试的思路和方法。
运算符
以下是 Python 中常见的运算符及其说明：
运算符
说明
算术运算符：
+（加）、-（减）、*（乘）、/（除）、//（取整除）、%（取余）、**（幂）
比较运算符：
==（等于）、!=（不等于）、>（大于）、<（小于）、>=（大于等于）、<=（小于等于）
赋值运算符：
=（赋值）、+=（加后赋值）、-=（减后赋值）、*=（乘后赋值）、/=（除后赋值）、%=（取余后赋值）、//=（取整除后赋值）、**=（幂后赋值）
逻辑运算符：
and（与）、or（或）、not（非）
位运算符：
&（按位与）、|（按位或）、^（按位异或）、~（按位取反）、<<（左移）、>>（右移）
成员运算符：
in（在序列中）、not in（不在序列中）
身份运算符：
is（对象相同）、is not（对象不同）
条件运算符：
x if c else y （当 c 为 True 时返回 x，否则返回 y）
需要注意的是，Python 中的运算符优先级和其他编程语言类似，可以使用括号来调整优先级。同时，Python 也支持函数式编程的风格，可以通过 lambda 表达式和 map、filter 等高阶函数来实现类似于列表推导式的功能。
在实际编程中，充分利用各种运算符和语法，能够更加简洁地表达程序逻辑，提高编码效率和代码质量。
异或运算符
异或运算符是 Python 中的一种位运算符，用符号“^”表示。它的作用是将两个数的二进制对应位进行比较，如果相同，则该位返回 0，如果不同，则返回 1。
例如，对于二进制数 a = 0b1011 和 b = 0b0101，它们的异或运算结果 c = a ^ b = 0b1110。
异或运算符在计算机科学中常常被用于数据加密、数据校验等方面。另外，通过异或运算也可以实现简单加密解密的功能，例如将明文和密钥进行异或运算，得到的结果就是密文。再将密文和密钥进行异或运算，就可以恢复出原始的明文。
需要注意的是，Python 中的异或运算符也可以与其他运算符组合使用，例如按位取反运算符（~）可以和异或运算符（^）一起使用，实现按位取反的效果。同时，在 Python 中还提供了一些方便的库和函数，例如 bin() 和 int() 可以实现二进制和十进制之间的转换。
第三章
列表和元组的区别
Python 中，列表和元组都属于序列类型，它们的区别主要体现在以下几个方面：
-
可变性：列表是可变对象，元组是不可变对象。这意味着，当我们对一个列表进行操作时，它的内容可以改变，比如可以添加或删除元素；而对于元组来说，一旦被创建后就不能再修改，只能读取其中的元素。
-
语法：列表使用方括号
[]表示，元素之间以逗号,分隔，例如[1, 2, 3]；元组使用圆括号()表示，元素之间也以逗号,分隔，例如(1, 2, 3)。需要注意的是，当元组只包含一个元素时，必须在元素后面加上逗号，否则会被解释为一个表达式而不是元组。例如，(1,)是一个元素为 1 的元组，而(1)则是一个整数类型，等同于数学上的括号。 -
性能：由于元组不可变，其在内存中分配的空间通常比列表更小，因此在大规模数据处理时，元组可能会比列表更加高效。
总的来说，如果你需要存储的元素是不可变的，或者一旦创建后就不需要改变，那么可以选择使用元组；如果你需要存储的元素可以随意添加、删除或修改，那么就需要使用列表了。
1.今天把第五章字典总结一下
首先集合{}方括号，集合是一个序列，无序不重复的元素序列，可以动态添加和删除元素
然后有一个关于序列和集合互相转换的函数
例如
a=[1,2,3,4]
a=set(a)
这就是将列表转集合的函数set
后面就涉及到操作和访问，min,max,sum,add,remove等等函数
5.2字典，字典相对于集合来说，有键值对，键就是索引，然后对应着一个值
用dict()函数可以创建字典
例如
url=dict(baidu='www.baidu.com',sina='ww.sina.com')
基本的函数有，del删除某一具体条目,len,in,not in,keys返回全部键组成的序列,values同理
items,返回序列，每一项是元组，每个元组由键和它对应的值组成
然后就是嵌套结构，这就涉及到表格的建构和提取数据，通过这样可以去建构表格，而且这有个好处就是可以通过这样建立数据结构，通过键值对应，嵌套然后就可以实现类似于结构体的功能
2.函数第六章
今天弄完函数
函数返回值这里有几个重点，一个是无return的情况默认返回none，在作bool值时，与false二者几乎等价。
然后是seen ，seen是python里面的集合，即无重复的序列，所以当我们需要把一个序列进行排序并且删除重复值时可以用到下面的循环语句
lst1=[i for i in lst if not in seen and not seen.add(i)]
下一点就涉及到了c语言中的函数的嵌套，其实也就是有点像递归，函数的返回值仍然是函数
6.4，命名空间和作用域
这里要注意的地方就是，有点像C语言的外部变量，就是全局变量和局部变量
不过python里面的变量查找的规则是：先在局部里查找是否存在变量的值，如果有就结束查找，然后返回，如果没有再在全局变量里面查看是否有值，然后返回，global关键词声明全局变量
全局变量：定义在函数外，存在于全局命名空间，作用域是整个程序
6.5递归
这里又以斐波那契数列为例
就举个简单的Python代码例子即可毕竟之前学过基本的思维
def fib(n):
if n==0 or n==1:
return 1
else:
return fib(n-1)+fib(n-2)
print(fib(4))```
copy()函数，就是把旧的直接赋给新的，
add(a,b)函数实现加法
然后今天再回顾一下切片
[1:5]切片到1（索引）到4（索引）右边开区间属于
然后还有带三个参数的如[1:9:2]第三个参数就是指步长
然后带省略的有
[:5]指0到4索引，[0:]指从第一个到最后一个
然后还有一个比较重要的就是切片的逆序也就是负数
[2:-1]2，到-2，但是逆序不太好输出倒数第一个这个时候用省略比较好
### 6.6内置函数
sorted()函数：
排序函数，操作对象，字符串，列表，元组，字典，然后sorted返回的是一个新的列表而不是原来的列表
iterable，可迭代对象，如字符串，列表，元组等
key,用来进行比较的函数，函数的参数取自于可迭代对象中，指定可迭代对象中的元素进行排序
reverse，排序规则，reverse为True时降序，为False时为升序，一般默认为升序
例如一个多样的列表我要对其进行排序
```python
students=[('蒋欣',89,15),('方鹏',80,14),('陈可',85,14)]
print(sorted(students,key=lambda s:s[2]))
#这里呢就是通过Key指定了可迭代对象，然后就以年龄进行排序了，如果s[1]的话就变成了按成绩进行排序，当然还可以再加上reverse，进行逆序操作等等
这是对lambda表达式的补充
好的，lambda表达式是Python语言中一种匿名函数的实现方式，它可以快速定义一个简单的函数，而不需要显式地定义函数名称。
在Python中，使用 lambda 关键字来定义 lambda 表达式。通常情况下，lambda 表达式的语法格式如下：
lambda argument_list: expression
其中：
argument_list—— lambda 表达式的参数列表，多个参数用逗号,分隔。expression—— lambda 表达式的函数体，通常是一个单行的表达式。
例如，以下是一个使用 lambda 表达式计算两个数之和的示例：
python
sum = lambda a, b: a + b
print(sum(3, 5)) # 输出 8
上述代码将匿名函数 lambda a, b: a + b 赋值给变量 sum，然后调用这个变量所代表的函数，即可得到两个数字的和。
Lambda 表达式通常用于函数式编程场景中，特别是在需要将函数作为参数传递给其他函数时非常方便。它可以简化代码，提高开发效率。但需要注意的是，在复杂的函数场景中，建议还是使用显式地定义函数名的方式来编写代码，以提高代码的可读性和可维护性。
其实也就是快速的建立简单函数避免名称的使用，但不建议在大型项目中使用可读性比较差
### map()函数
map()函数的基本语法是map(function,iterable)
function指函数体，可用lambda表达式去构建简单的函数，iterable是可迭代对象，返回新的可迭代对象
举个简单例子
```python
print(list(map(lambda x:x**2,[1,2,4,5])))
#就会输出[1,4,16,25]
```
### zip()函数
有点像打包的意思，就是把两个或者多个元组按照最短的元组依次把同一索引的打包成一个元组里的元素例如
```python
a=[1,2,3]
b=[2,5,6]
zip(a,b)=[(1,2),(2,5),(3,6)]
```
应该没有什么大用
奥用zip函数创建字典比较方便
就是在原先的字典如果要把键值兑换的话就用dict(zip(d.values(),d.keys))即可
下一个函数
### eval(),exec()函数
这两个函数的话就是没啥大用，个人感觉
一个是用来返回计算表达式的值
例如eval('x+3*y-4')
exec()的话就是执行里面的代码内容，例如执行print，input等等虽然感觉没事用
### all()和any()函数
all()函数的话就是里面的可迭代对象全部都是ture才返回ture,any()就是只要有一个为ture就返回ture，记得是可迭代对象all([1 if n%k!=0 else 0 for k in range(2,n)])
### rstrip() strip() lstrip()
`rstrip()` 是 Python 字符串对象的一个方法，其作用是去除字符串末尾的空白字符，默认情况下包括空格、制表符（\t）和换行符（\n）。该方法并不改变原字符串，而是返回一个新的字符串。
语法格式如下：
```python
string.rstrip([chars])
```
其中：
- `chars`：可选参数，指定要去除的字符序列。默认情况下为 None，表示去除所有空白字符。
以下是一个简单的示例：
python
```python
s = 'hello world\t\n'
print(s) # 输出: hello world
s1 = s.rstrip()
print(s1) # 输出: hello world
```
在上面的例子中，初始化了一个字符串`s`，此时这个字符串的末尾包含了制表符和换行符。使用 `rstrip()` 方法去除这些空白字符，将去除结果赋值给`s1`，最终打印`s1`时可以发现这些空白字符已经被成功地去除了。
需要注意的是，与 `rstrip()` 相关的还有另外两个方法 `lstrip()` 和 `strip()`，它们分别用于去除字符串开头的空白字符和同时去除字符串两端的空白字符，用法类似。如果有需要，可以参考 Python 官方文档来了解更多关于字符串方法的内容。
### replace()函数
在 Python 中，`replace()` 方法是字符串（str）对象的一个方法。它接受两个参数：一个要被替换的子字符串和一个新的字符串。具体语法如下：
```
string.replace(old, new[, count])
```
其中：
- `old`：必选参数，表示要被替换的子字符串。
- `new`：必选参数，表示用于替换的新字符串。
- `count`：可选参数，表示替换次数，不指定则默认全部替换。
python
```
s = "John Smith, John Doe"
new_s = s.replace("John", "Tom")
print(new_s) # 输出："Tom Smith, Tom Doe"
```
在上面的例子中，初始化了一个字符串`s`，其中包含了两个子串"John"。使用 `replace()` 方法将其中的 "John" 全部替换成 "Tom"，得到新字符串 `new_s`，最终输出结果是 "Tom Smith, Tom Doe"。
总的来说，`replace()` 函数是一个常用的字符串操作函数，在日常编程中经常会用到。需要注意的是，它只会替换字符串中的某些部分，不会改变原始字符串本身。
### isalnum()函数
`isalnum()` 是 Python 和 C 语言中常用的函数之一，用于判断一个字符是否是字母或数字。具体来说，该方法检测字符串或字符变量中的所有字符是否都是字母或数字，如果所有字符都是字母或数字，则返回 True；否则返回 False。
在 Python 中，`isalnum()` 是字符串（str）对象的一个方法，使用方法如下：
```
string.isalnum()
```
其中，`string` 表示要进行判断的字符串对象。
Python 示例：
python
```
s1 = 'Hello123'
s2 = 'good boy!'
print(s1.isalnum()) # 返回 True，因为 s1 中只包含字母和数字
print(s2.isalnum()) # 返回 False，因为 s2 中包含空格等非字母或数字的字符
```
### round()函数以及格式化字符保留小数
`round()`是Python的一个内置函数，可以将浮点数四舍五入到指定的位数。其基本语法如下：
python
```
round(number[, ndigits])
```
其中，`number`是要被舍入的数字，`ndigits`是保留的小数位数，默认为0。
下面举例说明：
python
```
a = 3.1415926
b = round(a)
print(b) # 输出 3
c = round(a, 2)
print(c) # 输出 3.14
d = round(a, 4)
print(d) # 输出 3.1416
```
在这个例子中，第一个 `round()` 函数没有传入 `ndigits` 参数，因此默认保留 0 位小数，直接对原始数字进行取整操作，输出结果为 `3`。
第二个 `round()` 函数传入了 `ndigits=2`，表示要保留 2 位小数，因此结果为 `3.14`。
第三个 `round()` 函数传入了 `ndigits=4`，表示要保留 4 位小数，因此结果为 `3.1416`。
需要注意的是，`round()` 函数会将小数部分四舍五入，并返回一个整数或浮点数，但它并不会改变原始变量的值。如果你想要改变原始变量的值，需要将 `round()` 函数的结果赋值给原始变量，例如：
python
```
a = 3.1415926
a = round(a, 2)
print(a) # 输出 3.14
```
格式化的介绍
在 Python 中，你可以通过字符串的 `format()` 方法对字符串中的数据进行格式化输出。`format()` 方法可以接受一个或多个参数，并将这些参数按照指定的格式插入到字符串中。
最常见的格式化方式是使用占位符 `{}`，例如：
python
```
name = "Jack"
age = 18
print("My name is {}, I'm {} years old.".format(name, age))
```
在这个例子中，`{}` 是一个占位符，它代表一个要被替换的值。`format()` 方法接受两个参数 `name` 和 `age`，并将它们按照顺序依次替换掉占位符，输出结果为：
```
My name is Jack, I'm 18 years old.
```
你也可以在占位符中加上参数的索引号，来指定参数填充的位置。例如，以下代码中，第一个占位符的索引号为 `0`，第二个占位符的索引号为 `1`：
python
```
print("My name is {0}, I'm {1} years old.".format(name, age))
```
输出结果与上面的例子相同。
除了占位符 `{}`，还有一些其他的占位符，如 `%s` 表示字符串，`%d` 表示整数，`%f` 表示浮点数，等等。例如：
python
```
print("My name is %s, I'm %d years old." % (name, age))
```
这种方式的格式化方式类似于 C 语言中的 `printf()` 函数。在这个例子中，`%s` 代表要被替换的字符串，`%d` 代表要被替换的整数。注意，在这种方式中，你需要将所有的参数都写在一个元组中，然后传递给 `%` 运算符。
不管是哪种方式，字符串格式化都可以方便地对字符串进行定制化输出。
2023/5/13 10:47:13
用格式化去保留小数
2023/5/13 10:47:45
在 Python 中，你可以使用字符串格式化的方式来保留小数位数。以下是两种常见的方式：
1. 使用 `format()` 方法。你可以在占位符中加上格式化指令，例如 `{:f}` 表示浮点数，后面跟上 `.nf` 表示要保留的小数位数，其中 `n` 为数字。例如：
python
```
num = 3.1415926
print("pi is {:.2f}".format(num)) # 输出 pi is 3.14
```
在这个例子中，占位符为 `{:.2f}`，表示要输出一个浮点数，并保留 2 位小数。
2. 使用 `%` 运算符。在占位符中加上 `.nf` 表示要保留的小数位数。例如：
python
```
num = 3.1415926
print("pi is %.2f" % num) # 输出 pi is 3.14
```
在这个例子中，占位符为 `%.2f`，也表示要输出一个浮点数，并保留 2 位小数。
需要注意的是，无论是使用 `format()` 方法还是 `%` 运算符，都只是在字符串中进行了格式化操作，并不会改变变量本身的值，因此如果你想保留某个浮点数的小数位数，应该使用 Python 内置的 `round()` 函数，例如：
python
```
num = 3.1415926
rounded_num = round(num, 2)
print(rounded_num) # 输出 3.14
```
### 6.7程序结构
这里面主要就讲了一下import
import 语句
import 模块名 as 别名
from 模块名 import * 或者from 模块名 import 函数
讲讲常见的模块
math,triangle,pandas,
然后用什么函数去查看这个模块有哪些变量和函数呢
当然是dir()
del是用来删除模块名，节省内存
有一个没啥用的知识点，__name__==__main__
### 包
包是模块名的自然扩展，旨在应对大型的项目，模块会把相关的函数，类，变量组织到一个文件中，包则把相关的模块组织到一个目录中，包是一个目录，其中包含一组模块文件和一个__init__.py文件这个文件是用来初始化这个包的，每个包里面都必须要有
### sys模块
sys是python自带模块，主要用来自己检测自己的版本，系统平台，系统编码，和更好的输出
可以用dir(sys)去看里面自带的函数和变量
sys.path查看路径
也可以去作为非常规输入，如有兴趣和需要可自行查阅
sys.stdin 标准输入
sys.stdout 标准输出
sys.stderr 标准错误输出
一般输入用 Ctrl-C Ctrl-D Ctrl-Z作为输出结束
### 第七章 文件和异常
文件的读写有三步，打开，处理数据，关闭
首先打开用的是open()函数，open函数的格式是
open("文件名","rt",encoding=None)这样是只读外加以文本形式去读
如果rt换为rb就是换为二进制去读
然后文件打开模式有这些种
r:只读模式
w:覆盖写模式（如过不存在就新创建文件，存在就直接全部重新覆盖，也就是全部弄掉）
a:追加模式（不存在就新创建;存在就只追加内容就是在后面追加内容）
x:创建写模式（不存在就新创建，存在就报错）
+：这个是用来串联这几个模式的
t:文本类型
b:二进制类型
### 文件对象常用函数和方法
open()
read([size]):从文件读取指定的字节数，如果为给定或者为负就读取所有内容
readline():读取整行
readlines:读取所有行并返回列表
writes(s):把s写入文件，默认使用utf-8编码，windows默认汉字编码是GBK,要用encoding=GBK;
writelines(s):向文件写入一个元素为字符串的列表，如果需要换行就自己加入每行的换行符
seek(off,whence=0):设置文件读写当前的位置
tell():返回文件读写的当前位置
close():关闭文件释放内存
在书本里面讲到一个问题
就是在读取文件时，（读取表格时）会有多个换行我查了查chatgpt发现
这是由于 Windows 和 Unix/Linux 操作系统的换行符不同导致的。在 Windows 中，每行结尾使用了回车符（CR）和换行符（LF），即"\r\n"，而在 Unix/Linux 中，只使用了换行符，即"\n"。
当我们在 Windows 中打开并修改一个文本文件时，Windows 默认会将"\n"转换为"\r\n"来保存到文件中，这样就会在每行末尾多出一个回车符"\r"。这个回车符会被Python解释器读入，并解析为空行，因此在读取文件时每行之间会出现空行。
解决此问题的方法有多种，比如：
- 使用 Python 内置的 `strip()` 方法去掉每行字符串末尾的空白字符（包括换行符、回车符等）。
- 打开文件时指定文件模式为 `"rU"` 或者 `"r"`（二者区别详见[[1](https://stackoverflow.com/questions/2665866/difference-between-modes-a-a-w-w-and-r-in-built-in-open-function)])，这样会自动将所有换行符（无论是"\n"还是"\r\n"）转换为"\n"，从而避免读取时出现空行。
下面是使用 `strip()` 方法处理的示例代码：
python
```
with open('mydata.csv', 'r') as f:
for line in f:
fields = line.strip().split(',')
print(fields)
```
然后讲一个有用的知识点
sys.stdin 标准输入
sys.stdout 标准输出
sys.stderr 标准错误输出
用sys.stdin结合readlines()函数有这样的用处
```python
import sys
s=sys.stdin.readlines()
print(s)
#1 3 4 键盘输入
#67
#78 9
#ctrl-D 表示结束
#输出['1 3 4\n','67\n','78 9\n']
```
### 7.2异常处理
异常是在程序运行时导致程序非正常停止的一个错误
提前检查和事后处理是处理程序错误的两种方法
对于异常处理其实也就是判断异常的位置
例如
```python
short_list=[1,72,3]
position=6
try:
short_list=[position]
except:
print('索引应该在0和',len(short_list)-1,'之间，但却是',position)
```
这里面try里面的代码先会被执行，如果返回错误就执行print的代码，这样我们就可以知道代码的问题出现的位置在哪可以及时的对问题进行更改
当我们在 Python 编写程序时，经常需要处理一些异常情况，例如文件无法打开、网络连接失败等。为了避免程序崩溃，我们可以使用 try except 语句来捕获并处理这些异常。以下是几个 try except 的实例：
1. 处理除以零错误
python
```
try:
x = 1 / 0
except ZeroDivisionError:
print("除数不能为零")
```
2. 处理文件打开错误
python
```
try:
f = open('test.txt', 'r')
content = f.read()
f.close()
except IOError:
print("文件读取出错")
```
3. 处理键值不存在错误
python
```
my_dict = {'name': 'Tom', 'age': 18}
try:
print(my_dict['gender'])
except KeyError:
print("key 不存在")
```
4. 处理类型转换错误
python
```
try:
x = int('abc')
except ValueError:
print("无法将字符串转换成整数")
```
5. 自定义异常处理
python
```
class MyError(Exception):
pass
try:
raise MyError("自定义异常")
except MyError as e:
print(e)
```
以上几个实例展示了 try except 语句的多种用法，在日常编程工作中非常常用。需要注意的是，在处理异常时，应该根据实际情况选择合适的异常类型，并且尽可能提供详细的错误提示信息，以便于快速定位和解决问题。
然后可以使用多个except去看异常类型，然后输出语句块
例如：
python
```
try:
a = int(input("请输入一个整数: "))
b = 10 / a
print("结果为:", b)
except ValueError:
print("输入不合法，请输入一个整数")
except ZeroDivisionError:
print("除数不能为零")
except Exception as e:
print("发生了一个错误:", e)
```
在上面的例子中，我们使用了三个 except 块来处理可能出现的三种异常，分别是 ValueError、ZeroDivisionError 和通用的 Exception 异常。如果用户输入的不是一个整数，则触发 ValueError 异常；如果用户输入的是 0，则触发 ZeroDivisionError 异常；如果出现其他未知的异常，则在最后一个 except 块中输出异常信息。
需要注意的是，应该在最后一个才写通用的异常处理 Exception，因为 Exception 可以捕获所有的异常，如果放在前面，可能会屏蔽掉前面所有的异常处理。在编写代码时，应该根据实际情况选择适当的异常处理方式，尽可能提供详细的错误提示信息，以便于快速定位和解决问题。
### 常见的标准异常
以下是 Python 中常见的标准异常：
异常名称
描述
AssertionError
断言语句（assert）失败
ModuleNotFoundError
导入模块失败
KeyboardInterrupt
用户中断执行
NameError
尝试访问未定义的变量
TypeError
不同类型间的无效操作
ValueError
传递给函数的参数类型正确但值错误
ZeroDivisionError
除数为零
AttributeError
尝试访问未知的对象属性
EOFError
没有内建输入，达到EOF标记
FileExistsError
在创建文件或目录时，如果该文件或目录已存在，则会引发此异常
FileNotFoundError
文件不存在
ImportError
导入模块失败
IndentationError
缩进错误，代码没有正确对齐
IndexError
索引超出序列边界
KeyError
字典中不存在指定的键
MemoryError
内存不足
NotImplementedError
尚未实现的方法
OSError
操作系统产生的异常
OverflowError
计算结果太大，超出了数据类型所能表示的范围
RecursionError
递归调用超过最大递归深度
RuntimeError
运行时错误
StopAsyncIteration
async 迭代器没有更多的值
StopIteration
迭代器没有更多的值。
SystemError
一般是由于Python本身出现问题引起
TypeError
不同类型间的无效操作
UnicodeError
Unicode相关的错误，如包含非法字符
ValueError
传递给函数的参数类型正确但值错误
ZeroDivisionError
除数为零
### 什么时候我们应该使用异常处理
异常处理主要适用于以下情况：
1. 文件操作：当我们进行文件读写、关闭文件或者其他与文件相关的操作时，需要考虑到文件不存在、权限不足等可能导致文件操作失败的情况。在这种情况下，我们应该使用 try except 语句捕获异常，并及时处理。
2. 网络访问：在进行网络访问时，可能会出现连接失败、超时等问题。为了避免程序因网络异常而崩溃，我们需要使用 try except 语句捕获异常。
3. 类型转换：当我们通过某些方式将数据类型进行强制转换时，可能会出现转换错误的情况。例如将字符串转换为数字，如果字符串中有非数字的字符，则会触发 ValueError 异常。在这种情况下，我们可以使用 try except 语句捕获异常并进行处理。
4. 外部依赖：在使用某些第三方库或模块时，可能会出现依赖缺失、api 版本不兼容等问题。为了避免这些问题导致程序崩溃，我们需要使用 try except 语句捕获异常。
总之，在 Python 中，任何可能导致程序崩溃或者出错的地方，都应该考虑编写异常处理代码来保证程序的稳定性和可靠性。
### raise语句和assert语句
raise()函数的典型应用就是在函数定义里面检查参数，发现实际参数不符合要求时就报告错误
下面是一个 Python 中使用 raise 函数判断参数是否符合实际的实例代码：
```python
def divide(x, y):
if y == 0:
# 如果除数为 0，则手动抛出 ZeroDivisionError 异常
raise ZeroDivisionError("除数不能为零")
else:
return x / y
try:
result = divide(10, 0)
except ZeroDivisionError as e:
print(e)
else:
print(result)
```
在这个例子中，我们定义了一个 `divide` 函数，用于计算两个数字的商。如果除数 `y` 等于 0，则手动抛出一个 `ZeroDivisionError` 异常，并通过 `raise` 函数传递错误信息 `"除数不能为零"`。在主程序中，我们使用 `try except` 语句来捕获该异常，并打印出错误信息。如果没有异常发生，则会输出计算结果。
这个例子展示了如何使用 `raise` 函数手动抛出异常，并且在判断参数是否符合实际时给出了一个具体的应用场景。
讲讲assert语句
assert 表达式
在逻辑上等同于
if not 表达式：
raise AssertionError
### 7.3Pandas模块读写常见的格式文件
Pandas是一个基于Python的数据分析库。它提供了高性能、易用的数据结构和数据分析工具，能够大幅度提升数据处理效率和数据分析速度。Pandas的数据结构包括：
- Series：一维数组，可以存储任意类型的数据，同时每个元素都有自己的标签，类似于字典。
- DataFrame：二维表格型数据结构，每个列可以是不同的数据类型（如整数、浮点数、日期等），同时每个列和行都有自己的标签，类似于关系型数据库中的表格。
Pandas提供了各种数据分析、操作和处理工具，例如：
- 数据清洗：例如删除重复行、填补缺失值等。
- 数据筛选：例如使用条件语句选择特定行或列。
- 数据变换：例如合并、拆分、重塑、透视等操作。
- 数据分组：例如根据某一列的属性进行分组计算。
- 时间序列：例如时间序列的操作和处理。
Pandas还可以与其他数据分析和科学工具集成，例如NumPy、Matplotlib、Scikit-learn等。通过使用Pandas，数据分析人员可以快速高效地对数据进行分析
### Pandas与Plotly一起联用
DataFrame是Pandas的一种数据类型，称为数据框，与Excel电子表格和Mysql表格并无不同，它可由元组列表，字典，和另一个DataFrame构造出来
Plotly是一个动态绘图模块，默认绘图结果是HTML格式，很方便去分享给其它人，毕竟它是基于javascript的模块
然后使用plotly去构建表格的函数是creat_table()
下面是一个实例：
下面是一个使用plotly创建表格的简单示例代码：
这段代码中的`FF.create_table()`是`plotly.figure_factory`子模块中提供的函数，用于通过输入数据创建一个表格。
具体而言，该函数可以接受一个二维列表或一个Pandas数据帧（DataFrame）作为输入参数，并返回一个包含所输入数据的表格。例如：
python
```
from plotly.figure_factory import create_table
import pandas as pd
# 创建一个DataFrame对象
df = pd.DataFrame({
'Name': ['Alice', 'Bob', 'Charlie', 'David'],
'Age': [25, 30, 35, 40],
'Salary': [5000, 6000, 7000, 8000]
})
# 使用create_table()函数创建一个带有表头的表格
table = create_table(df)
# 显示表格
table.show()
```
以上代码会使用`create_table()`函数创建一个新的表格，并将其存储到`table`变量中，然后通过`show()`方法在交互式窗口中显示该表格。
以上代码使用Pandas创建了一个名为`df`的DataFrame对象，包含名字、年龄和薪水三列数据。然后，通过`go.Table`函数创建一个表格trace对象，设置表头和单元格内容，并将其封装到`data`列表中。最后，构建布局并通过`fig.show()`显示出来。
### plotly的五个子模块
以下是 Plotly 的五个子模块和它们的功能：
1. `plotly.graph_objs`: 包含所有的图形对象，例如布局、轴、图例和注释等，这些对象可以用来构建各种类型的图表。
2. `plotly.offline`: 包含了一系列可以在本地生成 Plotly 图表的函数，这些函数可以将 Plotly 图表保存为 HTML 文件或嵌入到 Jupyter Notebook 中。
3. `plotly.subplots`: 包含创建 Plotly subplot（小图）的各种函数，支持多行和多列划分，以及自定义大小和间距等。
4. `plotly.figure_factory`: 包含各种函数，可以轻松创建一些简单的 Plotly 图表，例如直方图、热力图、散点图矩阵等。
5. `plotly.express`: 提供了一种快速创建常见图表的高层次接口，例如散点图、折线图、条形图等，同时还支持自动进行数据聚合和分组。
express子模块使用比较方便，但不够灵活，graph_object就灵活很多
其中trace表示图形，和画的痕迹，用layout去表示图形布局
### 补充一下画折线图的函数，一个是单一折线图，另一个是折线图的多个子图
1. `Line` 函数：`Line` 函数用于创建线图。它可以接受多个参数，其中包括 `x` 和 `y` 参数，分别表示线条的横纵坐标值。`px.line` 函数可用于快速绘制一条或多条线，以展示数据随时间或其他连续变量的变化趋势。
2. 例如，下面这段代码可以创建一条从 (0,0) 到 (1,1) 的线段：
python
```
import plotly.graph_objs as go
fig = go.Figure()
fig.add_trace(go.Scatter(x=[0, 1], y=[0, 1], mode="lines"))
fig.show()
```
2. `figure` 函数：`figure` 函数用于创建画布对象。在 `plotly` 中，画布对象被称为图 (`Figure`) 对象。通过 `figure` 函数创建的图对象可以包含多个子图 (`Subplot`)，每个子图可以使用不同的坐标轴。例如，下面这段代码可以创建一个包含两个子图的图对象：
python
```
import plotly.graph_objs as go
x_data = [0, 1, 2, 3, 4]
y1_data = [4, 3, 2, 1, 0]
y2_data = [0, 1, 2, 3, 4]
fig = go.Figure()
fig.add_trace(go.Scatter(x=x_data, y=y1_data, name="Trace 1"))
fig.add_trace(go.Scatter(x=x_data, y=y2_data, name="Trace 2"))
fig.update_layout(title_text="Subplots")
fig.show()
```
### 然后再补充一个画柱状图的一个函数Bar()
这个函数是用来做柱状图的函数，然后它结合Layout()可以生成层叠式的柱状图
python
```
import plotly.graph_objs as go
# 准备数据
x = ['A', 'B', 'C', 'D', 'E']
y1 = [2, 3, 1, 4, 5]
y2 = [1, 4, 2, 3, 6]
# 设置柱状图参数
trace1 = go.Bar(x=x, y=y1, name='Trace 1')
trace2 = go.Bar(x=x, y=y2, name='Trace 2')
# 设置布局信息和绘图参数
layout = go.Layout(title='Stacked Bar Chart', barmode='stack')
fig = go.Figure(data=[trace1, trace2], layout=layout)
# 显示图形
fig.show()
```
其中，`x` 和 `y` 表示柱状图中的横轴和纵轴数据，`name` 表示该数据集的名称，在图例中显示。通过设置 `barmode` 参数为 `'stack'`，即可将两个数据集分别叠加在一起。另外，通过设置 `title` 参数可以设置图表的标题。
运行以上代码，即可在浏览器中看到生成的柱状图。
### 读取表格里面的数据
值得注意的是：如果使用的data是字典，那么键就是列的名称，字典的值就是列值
- 然后at()函数可以去取data（）里面的某一个值 例如：print(data.at[0,"学号"])
- 然后说到了读取表格那么就还有另一个读取表格的方式，这个是按行读取也就是iloc()函数，常见举例print(data.iloc[0]),这个代码也就是去了数据的第一行
### 添加表格的内容
```python
from plotly import figure_factory as FF
import pandas as pd
data=pd.DataFrame(....)#里面内容省略一下)
#然后直接在后面加点东西即可
data["总评成绩"]=data["笔试"]*0.5+data["平时"]*0.25+data["实验"]*0.25
fig=FF.create_table(data)
fig.show()
```
### 读取各种类型的文件
一共有三种文件，csv,excel,json
格式是read_csv,read_excel,read_json
编码统称为encode,解码统称为decode
read_csv("score.csv",encoding=GBK)
### python中常见的库
库名称
功能作用
NumPy
提供了高性能的多维数组对象和各种派生对象（如掩码数组和矩阵）的处理函数，可以用来进行科学计算和数据分析。
pandas
提供了一种专门用于数据分析的数据结构DataFrame和Series，并且具有强大的数据处理、清洗、重塑、切片和切块等功能，可以用来进行数据挖掘、数据预处理和数据可视化等任务。
Matplotlib
提供了用于创建各种类型的图形和可视化效果的函数和类，包括线形图、散点图、条形图、面积图等各种类型的图形，可以用来进行数据可视化和数据分析。
SciPy
建立在 NumPy 之上，提供了许多高级的数学算法和函数，包括线性代数、优化、插值、积分、统计、信号处理、图像处理、常微分方程等方面的算法和函数。
Scikit-learn
提供了一系列用于机器学习的算法和模型库，包括分类、聚类、回归、降维、模型选择、特征提取、数据预处理等方法，可以用于数据挖掘、自然语言处理、图像处理、金融风控等领域。
TensorFlow
由 Google 开发的开源机器学习框架，提供了强大的神经网络构建和训练工具，同时支持分布式计算和 GPU 加速，适用于各种深度学习任务。
PyTorch
提供了动态图计算的机制，可以灵活地构建和调试深度学习模型，并支持 GPU 计算加速，同时也具有许多用于自然语言处理、计算机视觉等应用场景的库和工具。
Flask
用 Python 编写的轻量级 Web 应用框架，提供了简单易用的路由、请求响应处理、模版渲染等功能，适合构建中小型的 Web 应用。
Django
用 Python 编写的高级 Web 应用框架，提供了完整的 MVC 模式、ORM 映射、模版引擎、自动化管理等功能，适合构建复杂的 Web 应用。
BeautifulSoup4
用来解析 HTML 和 XML 文档的 Python 库，提供了一些便捷的函数和类，可用于网站爬虫、数据挖掘、文本抽取等任务。
requests
用来进行 HTTP 请求的 Python 库，提供了简单易用的 API 接口，包括 GET、POST、PUT、DELETE 等 HTTP 方法，可用于爬取网站、访问 Web API 接口等任务。
Pillow
用来处理图像的 Python 库，提供了一些便捷的函数和类，包括读取、修改、保存图片、生成缩略图、执行各种图像处理操作等功能。
Pygame
用于编写 2D 游戏的 Python 库，提供了一些基本的游戏框架、渲染引擎、事件处理等功能，可以用来编写简单的游戏和交互式应用。
这个表格列举了 Python 常用的一些库以及它们的主要功能作用，其中：
- 数据处理和分析方面，NumPy、pandas 和 Matplotlib 是必不可少的库，提供了多维数组、数据框和图形可视化等方面的强大支持；
- 科学计算和数学算法方面，SciPy 提供了各种高级的数学算法和函数，可以满足科学家和工程师的需求；
- 机器学习和深度学习方面，Scikit-learn、TensorFlow 和 PyTorch 是常用的库，提供了各种用于机器学习和深度学习的算法和模型，适合进行数据挖掘、自然语言处理、计算机视觉等任务；
- Web 应用开发方面，Flask 和 Django 是常用的 Web 应用框架，提供了路由、请求响应处理、ORM 映射、模版引擎等功能，可以用来构建各种规模的 Web 应用；
- 网络爬虫和数据挖掘方面，BeautifulSoup4 和 requests 是常用的库，提供了便捷的 HTML/XML 解析和 HTTP 请求接口，可用于网站爬虫、数据挖掘等任务；
- 图像处理和游戏开发方面，Pillow 和 Pygame 是常用的库，提供了图像处理和游戏开发方面的支持。
xlrd
适应范围 文件读写，读取Excel数据
xlwd
适应范围 文件读写，写数据到Excel文件
### math库函数表格
函数名
说明
math.ceil(x)
返回大于等于 x 的最小整数
math.floor(x)
返回小于等于 x 的最大整数
math.trunc(x)
返回 x 的整数部分
math.sqrt(x)
返回 x 的平方根
math.pow(x, y)
返回 x 的 y 次方
math.exp(x)
返回 e 的 x 次方
math.log(x, base = math.e)
返回以 base 为底数的 x 的对数
math.degrees(x)
将角度 x 从弧度转换为角度
math.radians(x)
将角度 x 从角度转换为弧度
math.sin(x)
返回 x 弧度的正弦值
math.cos(x)
返回 x 弧度的余弦值
math.tan(x)
返回 x 弧度的正切值
math.asin(x)
返回 x 的反正弦值（弧度）
math.acos(x)
返回 x 的反余弦值（弧度）
math.atan(x)
返回 x 的反正切值（弧度）
math.atan2(y, x)
返回坐标点 (x, y) 所对应的极角
math.pi
圆周率（π）的常量
math.e
自然常数 e 的常量
### turtle库函数列表
函数名
说明
turtle.forward(distance)
向当前方向移动 distance 像素长度
turtle.backward(distance)
向相反方向移动 distance 像素长度
turtle.right(angle)
右转指定角度
turtle.left(angle)
左转指定角度
turtle.penup()
抬起画笔，不绘制
turtle.pendown()
落下画笔，开始绘制
turtle.pencolor(color)
设置画笔颜色
turtle.fillcolor(color)
设置填充颜色
turtle.begin_fill()
开始填充图形
turtle.end_fill()
结束填充图形
turtle.circle(radius, extent)
以当前点为圆心，radius 为半径绘制一个圆形
turtle.dot(size, color)
在当前位置绘制一个大小为 size，颜色为 color 的点
turtle.write(text, move=False, align="left", font=("Arial", 12, "normal"))
在当前位置写入文本
turtle.bgcolor(color)
设置画布的背景色
### 第八章类和对象
对于python来说，类是定义属性（变量，数据）和行为（方法）的模板，类是python语言的核心，包括内置int str等等都是类
定义类
用关键词Class关键词去定义类，然后定义后面跟一个名称
例如
```Python
class Student:
def __init__(self,name,number):
self.name=name
self.number=number
def getinfo(self)
print(self):
```
类中的函数统称为方法，前面学到的函数的一切都适用于方法，他们的主要的差别是调用方法的方式，__init__是一个特殊的方法，他们的主要差别在用每当student类创建新对象时，python都会自动运行它，这个方法的名称中，开头和结尾都会有下划线，为了区别默认方法和普通方法，这是一种约定；
方法内的参数传递都有self这样以self为前缀的变量都可供类中的方法使用，去通过形参name去传递参数值
创建对象
```python
s1=Student("Wang","31000010")
print("我的名字是"+s1.name+"我的学号是"+s1.number)
```
和普通的创建对象没有什么太大的区别
访问对象
就是s1.name这样即可没啥好说的
修改值和传值可以直接通过赋值语句进行处理
这种类的好处呢，就是当遇到一些具体实例，包含各种比较复杂的数据类型，什么体重呀，名字，学号等等都可以比较好的进行运算，编写代码
### 类和C结构体的区别
最开始在学习类的时候会产生点疑问，因为它和C语言的结构体有些相似之处，于是去看了看chatgpt对它的回答：
可以说类和C语言的结构体有些相似之处，因为它们都可以用来封装不同类型的数据，并提供了对这些数据进行操作的方法。但是类和结构体也有很多不同之处。
首先，类具有封装性、继承性、多态性等面向对象编程的特性，而结构体则只是一种数据类型，没有面向对象编程的特性。类可以使用面向对象的方式来组织代码和管理程序，而结构体在C语言中只能用于存储一些相关的数据，不能定义方法或函数。
其次，类与结构体在访问权限上也有差异。类可以包含私有属性（即只能在类内部访问）和公有属性（即类外部也可以访问），而结构体中的数据成员默认都是公共的，可以被其他代码直接访问。
此外，类还支持多重继承和虚函数等高级特性，这些特性在C语言结构体中是不存在的。
因此，尽管类和结构体都有封装、继承和多态等概念，但它们实现的方式和应用场景还是有很大的不同的。
### 封装
Python 中的封装是将对象的属性和方法放在一个抽象的包装中，使得外部无法直接访问和修改对象的内部数据，只能通过对象的公共接口来访问和修改数据。这种封装的机制可以提高代码的安全性，防止非法的访问和不当修改，同时也可以增强程序的可维护性和可扩展性。
具体来说，Python 中的封装可以通过以下方式实现：
1. 定义私有属性：在 Python 中，可以通过在属性前加上双下划线 `__` 来定义私有属性，这样外部代码就不能直接访问该属性。只能通过类中的公共方法来对其进行操作。
2. 定义私有方法：和私有属性一样，也可以通过在方法名前加 `__` 来定义私有方法，这样外部代码也无法直接调用该方法。
3. 访问器（getter）和设置器（setter）方法：为了让外部代码能够访问对象的内部数据，可以通过定义访问器和设置器方法来提供公共接口。访问器用于获取私有属性的值，而设置器用于修改私有属性的值。这样一来，对象的内部数据就不会被外部代码随意访问和修改，而只能通过使用公共接口来进行操作。
总之， Python 中的封装可以提高程序的安全性和可维护性，同时也可以隐藏对象的内部数据，防止外部代码对其进行不当访问和修改。这种机制在程序设计中非常常见，是一种非常重要的编程思想。
三种方法，实例方法，类方法，静态方法
（1）在类的方法中第一个参数如果为self，这种方法交做实例方法，就是可以通过显式地访问实例
（2）类方法，不能对特定实例来进行操作，不能访问实例变量，它通过装饰器
@classmethod来定义
（3）静态方法通常是一个独立的方法，不对类的方法和变量进行操作，通过装饰器
@staticmethod来定义
私有成员和公有成员
- 以一个下划线为前缀，格式如_xxx，这就是受保护成员
- 一两个下划线为前缀和两个下划线为后缀，就说明它是系统定义的特殊成员
- 只以两个下划线为前缀，就说明这个是私有成员，只有类内自己能够访问，不能通过编程实例进行访问到这个成员
### 继承
Python 中的继承是一种面向对象编程中非常重要的概念，它允许一个类从已有的一个或多个父类中继承属性和方法，并在此基础上添加、修改或删除自己独有的属性和方法。继承的主要作用包括以下几点：
1. 代码复用：继承允许我们将已有的代码复用到新的类中，从而减少了重复编写代码的工作量。如果多个类具有相同的属性和方法，那么我们可以将它们抽象出来，定义为一个父类，然后让这些类继承这个父类，这样我们就不必在每个类中都编写相同的代码。
2. 提高代码的可读性：继承可以使代码更加清晰和易于理解。通过继承，我们可以使用现有的类和方法来构建新的类，从而简化了代码的结构和组织方式，使其更加易于理解和管理。
3. 提高代码的可维护性和可扩展性：通过继承，我们可以将一个类的属性和方法封装在一个父类中，这样当需要修改这些属性或方法时，只需要在父类中进行修改，而不需要修改每一个子类。同时，我们也可以通过继承来扩展现有类的功能，使得程序具有更高的可扩展性和灵活性。
4. 实现多态：继承可以使得不同的子类对象可以被视为同一个父类对象，从而实现了多态。这样一来，我们就可以使用父类定义的方法和属性来操作不同的子类对象，使得程序更加灵活和通用。
总之，继承是面向对象编程中非常重要的概念，它可以提高代码的复用性、可读性、可维护性和可扩展性，同时也可以实现多态，使得程序更加灵活和通用。
### python PTA题目实战练习
第1章-1 从键盘输入两个数，求它们的和并输出
分数 30
作者 陈春晖
单位 浙江大学
本题目要求读入2个整数A和B，然后输出它们的和。
在一行中给出一个被加数
在另一行中给出一个加数
输出格式:
在一行中输出和值。
输入样例:
在这里给出一组输入。例如：
```in
18
-48
```
输出样例:
在这里给出相应的输出。例如：
```out
-30
```
代码解释
```python
a=input()
b=input()
a, b = int(a), int(b)
print(a+b)```
2.第二题笔记
第二题原理第一遍我的代码程序是这样的
```python
a,b,c=int(input().split())
print(b*b-4*a*c)
```
然后仔细查看这里涉及到几个地方
第一个知识点的补充：Int()函数只涉及到一个变量，它只能对一个变量进行返回整数，所以这里是有语法错误的，况且split()返回的是可迭代对象，也就是元组
第二点改进：看了chatgpt发现，这里呢可以用到map函数
用
a, b, c = map(int, input().split())
就可以实现这个功能
可以看到int并没有加括号，即它的语法规则是不加括号只用有关键词即可
3.第三题笔记
这里涉及到循环的使用，以及赋值语句
发现python中不能用逗号隔开进行赋值
例如不能这样
i=0,sum=0
还有也不能进行自加
i++这样也是错误的
我最开始的代码
m=int(input())
i=11
sum=0
while i<=m :
sum=sum+i
i=i+1
print("sum = "+sum)
但是发现，这个sum+字符串本身就是一个错误的运算应该在sum前面加个str函数
这个题也可以用for循环去写，不过注意的是,for循环一般都会和range()函数一起用，注意range()函数的范围即可
```
m = int(input())
sum = 0
for i in range(11, m+1):
sum += i
print("sum = " + str(sum))
```
第二章2-4题
```
a,n=map(int,input().split())
temp=a
sum=0
for i in range(1,n+1):
sum=int(a)+sum
a=str(a)+str(temp)
print("s = "+str(sum))
```
综合前面的知识用字符串，循环就可以了，没有什么比较大的困难
第二章2-5题
这里又学到了几个知识点
一个是input()函数输入的是字符串的值，不能直接参与整数运算，要想参与必须转置类型
```
n = int(input())
```
例如上面这个
然后这个题目毕竟恶心的地方在于精度的计算
因为题目平台的限制，以及算法所用的函数不一样，可能会导致精度有一点点的偏差
a=int(input())
sum=0
for i in range(1,a+1):
sum=sum+1/(2*i-1)
sum=round(sum,6)
print("sum = "+str(sum))
例如我这里用的是round()函数去求，并且保留六位有效数字，在提交的时候就会有部分错误
a=int(input())
sum=0
for i in range(1,a+1):
sum=sum+1/(2*i-1)
sum=round(sum,6)
print("sum = {:.6f}".format(sum))
但是换成这样之后就不一样了
第2章第七题
第2章-7 产生每位数字相同的n位数
分数 30
作者 陈春晖
单位 浙江大学
读入2个正整数A和B，1<=A<=9, 1<=B<=10,产生数字AA...A,一共B个A
a,b=map(int,input().split(','))
temp=a
for i in range(1,b):
a=str(a)+str(temp)
print(a)
没啥好说的，简简单单
第三章第一题开始有点样子了
a[i]=int(input().split())
sum=0
for j in range(0,i):
sum=sum+a[j]
average=sum/(i+1)
for j in range(0,i):
if a[j]>average:
print(a[j]+" ")
这是我最开始的代码
逐一纠正
第一个我在元组的概念肯定有些问题
第一条语句应该改为
t = tuple(int(x) for x in input("请输入三个元素，以逗号分隔：").split(","))
或者把tuple()换成[]，然后注意因为input()普遍输入是字符串所以要注意转类型
实际上它相当于下面的三行代码
```
s = input("请输入三个元素，以逗号分隔：") # 获取用户输入的字符串
lst = [int(x) for x in s.split(",")] # 将字符串切割、转换为整型，并组成列表
t = tuple(lst) # 将列表转换为元组
```
然后当插入了上面的代码后，又观察到了小错误一个，average=sum/i;
然后在最后面有一个地方print()函数这边每一个print结束之后都会默认的来一个换行
所有我们要修改这个默认值
改为print("str(a[j])"+"",end='')
最终代码是
a=[int(x) for x in input().split()]
sum=0
i=len(a)
for j in range(0,i):
sum=sum+a[j]
average=sum/i
for j in range(0,i):
if a[j]>average:
print(str(a[j])+" ",end='')
```
```
接下来的代码是在我尝试进行挖洞中遇到想弄的脚本
修改本地时间的脚本
```
3万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
