09-11-周四_16-52-32

project02/02.Python基础语法.md

@@ -0,0 +1,700 @@
+# 注释
+
+单行注释：
+
+```python
+# 这是一条注释信息
+```
+
+多行注释：
+
+```python
+'''
+这是多行注释
+'''
+```
+
+```python
+"""
+这是多行注释
+"""
+```
+
+# 变量
+
+什么是变量？
+
+变量就是把某些值或者运行的结果临时保存在内存中，以便后续调用
+
+## 强类型与弱类型
+
+### 强类型（Strongly Typed）
+
+- **定义**：在强类型语言中，类型检查在编译时或运行时都很严格，变量的类型在定义时明确，且不允许隐式转换。
+- 特征：
+  - 不同类型之间的操作会导致错误。
+  - 类型安全，高度限制了类型不兼容的操作。
+- **示例语言**：Java、C++、Python、Rust
+
+**示例：python**
+
+```python
+a = 10
+b = "10"
+print(a+b)
+print(a == b)
+
+# Output:
+TypeError: unsupported operand type(s) for +: 'int' and 'str'
+......
+```
+
+### 弱类型（Weakly Typed）
+
+- **定义**：在弱类型语言中，变量的数据类型可以在运行时发生变化，允许隐式转换。
+- 特征：
+  - 不同类型之间的操作可能会被自动转换。
+  - 灵活性高，但可能导致运行时错误或意外结果。
+- **示例语言**：JavaScript、PHP、Ruby
+
+**示例：JavaScript**
+
+```python
+let a = "5";
+let b = 10;
+let result = a + b; // result 为 "510"（字符串拼接）
+```
+
+## 动态类型与静态类型
+
+### 动态类型（Dynamically Typed）
+
+- **定义**：动态类型语言在运行时确定变量的类型，变量可以在程序执行过程中改变其类型。
+- 特征：
+  - 变量不需要在声明时指定类型。
+  - 类型检查在运行时进行。
+  - 允许在同一变量中存储不同类型的数据。
+- **示例语言**：JavaScript、Python、Ruby、PHP。
+
+**示例：python**
+
+```python
+a = 10      # 整数类型
+print(a)    # 输出: 10
+
+a = "Hello" # 现在是字符串类型
+print(a)    # 输出: Hello
+```
+
+### 静态类型（Statically Typed）
+
+- **定义**：静态类型语言在编译时确定变量的类型，变量的类型在声明时明确且在整个生命周期内保持不变。
+- 特征：
+  - 变量必须在声明时指定类型。
+  - 类型检查在编译时进行。
+  - 不允许在同一变量中存储不同类型的数据。
+- **示例语言**：Java、C、C++、Go、Rust。
+
+**示例：C语言**
+
+```c
+#include <stdio.h>
+
+int main() {
+    int a = 10;           // 整数类型
+    float b = 5.5;       // 浮点类型
+    char c = 'A';        // 字符类型
+
+    printf("a = %d\n", a);
+    printf("b = %.2f\n", b);
+    printf("c = %c\n", c);
+
+    return 0;
+}
+```
+
+### 对比
+
+| 特性     | 强类型               | 弱类型               |
+| :------- | :------------------- | :------------------- |
+| 类型检查 | 严格                 | 灵活                 |
+| 隐式转换 | 不允许               | 允许                 |
+| 错误检测 | 通常在编译时或运行时 | 可能在运行时发现错误 |
+| 类型安全 | 高                   | 低                   |
+
+## 声明变量
+
+```python
+a = "Hello World!"
+print(a)
+```
+
+## 变量命名约定
+
+### Python变量命名规则
+
+- 变量名只能由字母、数字和下划线组成
+- 变量名只能以字母或下划线开头，不能以数字开头
+- 变量名不区分大小写，但为了提高可读性，推荐使用小写字母命名，并用下划线分隔多个单词
+- 变量名不能使用Python的关键字，如下：
+  - **['and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'exec', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'not', 'or', 'pass', 'print', 'raise', 'return', 'try', 'while', 'with', 'yield']**
+- 变量名应该具有描述性，以便能够清晰地表达变量的含义
+
+### 常见的命名方式
+
+1. 大驼峰命名法（Camel case）
+   驼峰命名法是将多个单词连接在一起，每个单词首字母大写，这种命名方式常用于类、函数和对象的命名。
+
+```python
+FirstName = '牛'
+LastName = '老师'
+
+print("你的名字是:",FirstName + LastName)
+```
+
+2. 下划线命名法（Snake case）
+   下划线命名法是将多个单词连接在一起，使用下划线（_）分隔每个单词，所有字母小写。这种命名方式常用于变量和模块名的命名。
+
+```python
+first_str = 'Hello'
+second_str = 'Python'
+
+print(first_str + " " + second_str)
+```
+
+3. 全大写命名法（Pascal case / UPPERCASE）
+   全大写命名法是将多个单词连接在一起，每个单词所有字母大写，可以加上适当的分隔符如下划线。这种命名方式常用于常量或全局变量的命名。
+
+```python
+FIRST_STR = 'Hello'
+SECOND_STR = 'Python'
+
+print( FIRST_STR+ " " + SECOND_STR)
+```
+
+## 变量的赋值
+
+将某个数据赋值给某个变量存储
+
+```python
+a = "变量1"
+b = "变量2"
+```
+
+ ![img](./02.Python基础语法/1140672815.png) 
+
+```python
+a = "变量1"
+b = a
+```
+
+ ![img](./02.Python基础语法/4238420988.png) 
+
+## 常量
+
+常量是指在程序运行过程中其值不应被改变的变量。虽然 Python 本身并没有内置的常量类型，但有一些约定和方法可以用于定义常量。
+
+### **定义常量：**
+
+常量通常是通过使用大写字母命名的变量来表示。这是一种约定，表明该变量不应被修改。例如：
+
+```python
+PI = 3.14159
+MAX_CONNECTIONS = 100
+```
+
+Python 没有内置的常量机制，但通过命名约定和模块结构，可以有效地使用常量来提高代码的可读性和可维护性。在设计大型程序时，合理使用常量是一个良好的编程习惯。
+
+# 用户交互
+
+## INPUT(输入)
+
+**基本用法：**
+
+```python
+name = input('请输出你的姓名:')
+print(name)
+```
+
+解释器在执行该代码的时候，如果遇到input就会出现阻塞，程序暂停，等待用户输入。当用户回车以后，程序才会继续向下执行
+
+**注意：**通过**input函数**输入进来的内容一律会被当成字符串处理
+
+```python
+a = input('请输入一个数字:')
+print(type(a))
+print(a > 0)
+
+# Output:
+请输入一个数字:10
+<class 'str'>
+Traceback (most recent call last):
+  File "D:\Code\Code\Python\PythonProject\测试\deom1.py", line 3, in <module>
+    print(a > 0)
+TypeError: '>' not supported between instances of 'str' and 'int'
+```
+
+如果想要规定**input**输入的类型，需要做类型转换，如下所示：
+
+```python
+a = int(input('请输入一个数字:'))
+print(type(a))
+print(a > 0)
+
+# Output:
+请输入一个数字:10
+<class 'int'>
+True
+```
+
+**其他用法：**
+
+既然我们了解了input函数的特性，那么我们可以借助input函数来实现我们常见到的"按任意键结束......."
+
+示例：
+
+```python
+import time
+a = 12345
+b = 54321
+print("开始计算a的b次方")
+a1 = a**b
+print("开始计算b的a次方")
+b1 = b**a
+print("开始比较大小")
+time.sleep(5)
+print(a1 > b1)
+input("比较结束，请按任意键回车结束.....")
+```
+
+## OUTPUT(输出)
+
+**基本用法：**
+
+```python
+a = "Hello world"
+print(a)
+```
+
+### 格式化输出
+
+```python
+name = input("姓名：")
+age = input("年龄：")
+job = input("工作：")
+info = '''
+----------- info of %s -----------
+姓名：%s
+年龄：%s
+工作：%s
+''' % (name,name,age,job)
+print(info)
+```
+
+运行结果：
+
+```python
+姓名：牛老师
+年龄：18
+工作：teacher
+
+----------- info of 牛老师 -----------
+姓名：牛老师
+年龄：18
+工作：teacher
+```
+
+### 字符串格式化标志(占位符)
+
+以下是 Python 中字符串格式化的常见格式化标志及其说明：
+
+- **`s`**：获取传入对象的 `__str__` 方法的返回值，并将其格式化到指定位置。
+
+- **`r`**：获取传入对象的 `__repr__` 方法的返回值，并将其格式化到指定位置。
+
+- **`c`**：
+  - 整数：将数字转换成其 Unicode 对应的值（范围：0 <= i <= 1114111）。
+  - 字符：将字符添加到指定位置。
+
+- **`o`**：将整数转换成八进制表示，并将其格式化到指定位置。
+
+- **`x`**：将整数转换成十六进制表示，并将其格式化到指定位置。
+
+- **`d`**：将整数、浮点数转换成十进制表示，并将其格式化到指定位置。
+
+- **`e`**：将整数、浮点数转换成科学计数法（小写 e），并将其格式化到指定位置。
+
+- **`E`**：将整数、浮点数转换成科学计数法（大写 E），并将其格式化到指定位置。
+
+- **`f`**：将整数、浮点数转换成浮点数表示，并将其格式化到指定位置（默认保留小数点后 6 位）。
+
+- **`F`**：同上。
+
+- **`g`**：自动调整，将整数、浮点数转换成浮点型或科学计数法表示（超过 6 位数用科学计数法），并将其格式化到指定位置（如果是科学计数则是 e）。
+
+- **`G`**：自动调整，将整数、浮点数转换成浮点型或科学计数法表示（超过 6 位数用科学计数法），并将其格式化到指定位置（如果是科学计数则是 E）。
+
+- **`%`**：当字符串中存在格式化标志时，需要用 `%%` 表示一个百分号。
+
+**示例：**
+
+```python
+# s：获取对象的 __str__ 方法返回值
+name = "Alice"
+print("Hello, %s!" % name)  # 输出: Hello, Alice!
+
+# r：获取对象的 __repr__ 方法返回值
+print("Name: %r" % name)  # 输出: Name: 'Alice'
+
+# c：整数转换为其 Unicode 字符（0-1114111）
+print("Unicode character: %c" % 65)  # 输出: Unicode character: A
+
+# o：将整数转换为八进制表示
+num = 10
+print("Octal: %o" % num)  # 输出: Octal: 12
+
+# x：将整数转换为十六进制表示
+num = 255
+print("Hexadecimal: %x" % num)  # 输出: Hexadecimal: ff
+
+# d：将整数或浮点数转换为十进制表示
+num = 42
+print("Decimal: %d" % num)  # 输出: Decimal: 42
+
+# e：将整数或浮点数转换为科学计数法（小写 e）
+num = 123456789
+print("Scientific: %e" % num)  # 输出: Scientific: 1.234568e+08
+
+# E：将整数或浮点数转换为科学计数法（大写 E）
+print("Scientific: %E" % num)  # 输出: Scientific: 1.234568E+08
+
+# f：将整数或浮点数转换为浮点数表示，默认保留小数点后 6 位
+num = 3.14159
+print("Float: %f" % num)  # 输出: Float: 3.141590
+
+# F：同上
+print("Float: %F" % num)  # 输出: Float: 3.141590
+
+# g：自动调整为浮点型或科学计数法，超出 6 位数使用科学计数法
+num = 1234567.89
+print("Auto: %g" % num)  # 输出: Auto: 1234567.89
+
+# G：同上，但科学计数法用大写 E
+print("Auto: %G" % num)  # 输出: Auto: 1234567.89
+
+# %：表示一个百分号
+percentage = 0.75
+print("Percentage: %.2f%%" % (percentage * 100))  # 输出: Percentage: 75.00%
+```
+
+# 基本数据类型
+
+## 整数(int)
+
+- **描述：**表示没有小数部分的数字，可以是正数、负数或零。
+- **特性：**
+  - Python 3 中的 `int` 类型是无限大小的。这意味着你可以创建非常大的整数，而不必担心溢出（overflow）的问题。
+  - Python 会根据整数的大小自动调整内存使用，因此可以存储任意大小的整数，只要计算机的内存允许。
+  - 支持基本的算术运算，如加、减、乘、除等。
+
+**示例：**
+
+```python
+a = 10
+b = -5
+c = 0
+print(a + b)
+# Output: 5
+```
+
+可以使用type()内置函数来查看某个变量或值的数据类型
+
+```python
+a = 2**64
+print(type(a))    # type()是查看数据类型的方法
+b = 2**60
+print(type(b))
+
+# Output:
+<class 'int'>
+<class 'int'>
+```
+
+## 字符串(str)
+
+- **描述：**字符串是字符的序列，可以通过单引号或双引号定义。
+- **特性：**
+  - 字符串是不可变的（immutable），不能更改其内容。
+  - 支持切片、连接、重复等操作。
+  - 可以使用转义字符处理特殊字符。
+
+在 Python 中, 加了引号的字符都被认为是字符串！
+
+**示例：**
+
+```python
+Greeting = "Welcome to 英格科技"
+Name = "牛老师"
+print(Greeting + " " + Name)	# 字符串可以通过+号进行拼接
+
+# Output:
+Welcome to 英格科技 牛老师
+```
+
+### 字符串的索引与切片
+
+**字符串的索引：**
+
+索引：每个字符在字符串中都有一个唯一的索引，索引从 `0` 开始。
+
+负索引：可以使用负数索引从字符串的末尾开始访问字符，`-1` 表示最后一个字符，`-2` 表示倒数第二个字符，以此类推。
+
+**示例：**
+
+```bash
+s = "Hello, World!"
+
+# 正索引
+print(s[0])  # 输出: H
+print(s[7])  # 输出: W
+
+# 负索引
+print(s[-1])  # 输出: !
+print(s[-5])  # 输出: o
+```
+
+**字符串的切片：**
+
+切片：可以通过指定起始索引和结束索引来提取字符串的子串。切片的语法为 `s[start:end]`，包含起始索引的字符，但不包含结束索引的字符。
+
+步长：可以指定步长来控制切片的间隔，语法为 `s[start:end:step]`。如果不指定步长，默认为 `1`。
+
+**示例：**
+
+```python
+s = "Hello, World!"
+
+# 基本切片
+print(s[0:5])  # 输出: Hello
+print(s[7:12])  # 输出: World
+
+# 省略起始或结束索引
+print(s[:5])  # 输出: Hello (从开始到索引 4)
+print(s[7:])  # 输出: World! (从索引 7 到结束)
+
+# 使用负索引切片
+print(s[-6:-1])  # 输出: World
+
+# 步长切片
+print(s[::2])  # 输出: Hlo ol! (每隔一个字符)
+print(s[::-1])  # 输出: !dlroW ,olleH (反转字符串)
+```
+
+### 字符串常用方法
+
+```bash
+# 字符串操作示例
+
+words = "beautiful is better than ugly."
+
+# 字符串的基本操作
+print(words.capitalize())   # 首字母大写
+print(words.swapcase())     # 大小写翻转
+print(words.title())        # 每个单词的首字母大写
+
+# 内容居中，总长度，空白处填充
+a = "test"
+ret = a.center(20, "*")
+print(ret)
+
+# 统计字符串中的元素出现的个数
+ret = words.count("e", 0, 30)
+print(ret)
+
+# startswith 和 endswith 判断
+print(a.startswith("a"))             # 判断是否以 'a' 开头
+print(a.endswith("j"))               # 判断是否以 'j' 结尾
+print(a.startswith('sdj', 2, 5))     # 判断子串是否在指定范围内
+print(a.endswith('ado', 7, 10))      # 判断子串是否在指定范围内
+
+# 寻找字符串中的元素是否存在
+print(a.find('sdj', 1, 10))          # 返回索引，找不到返回 -1
+print(a.index('sdj', 1, 10))         # 返回索引，找不到抛出异常
+
+# split 以指定字符分割，形成列表
+ret = words.split(' ')
+print(ret)
+ret = words.rsplit(' ', 2)           # 指定分割次数
+print(ret)
+
+# format 的三种用法
+print('{} {} {}'.format('aaron', 18, 'teacher'))
+print('{1} {0} {1}'.format('aaron', 18, 'teacher'))
+print('{name} {age} {job}'.format(job='teacher', name='aaron', age=18))
+
+# strip 操作
+a = '****asdasdasd********'
+print(a.strip('*'))   # 去除两端指定字符
+print(a.lstrip('*'))  # 去除左侧指定字符
+print(a.rstrip('*'))  # 去除右侧指定字符
+
+# replace 操作
+print(words.replace('e', 'a', 2))  # 替换 'e' 为 'a'，替换两次
+
+# 字符串类型检查
+print(words.isalnum())  # 判断字符串是否只由字母或数字组成
+print(words.isalpha())   # 判断字符串是否只由字母组成
+print(words.isdigit())   # 判断字符串是否只由数字组成
+```
+
+## 布尔类型(bool)
+
+- **描述：**布尔类型只有两个值：`True` 和 `False`。
+- **特性：**
+  - 通常用于条件判断和逻辑运算。
+  - 布尔值在逻辑表达式中可以进行运算。
+
+布尔类型很简单，就两个值 ，一个 True(真)，一个 False(假), 主要用记逻辑判断
+
+示例：
+
+```python
+a = 3
+b = 5
+print(a < b, a > b , a != b)
+
+# Output:
+True False True
+```
+
+# 基本运算符
+
+## 算数运算符
+
+用于执行基本的数学运算
+
+| 运算符 | 描述                                               | 示例            |
+| :----- | :------------------------------------------------- | :-------------- |
+| `+`    | 加法，返回两个数的和                               | `3 + 5` → `8`   |
+| `-`    | 减法，返回第一个数减去第二个数的结果               | `10 - 4` → `6`  |
+| `*`    | 乘法，返回两个数的乘积                             | `2 * 3` → `6`   |
+| `/`    | 除法，返回第一个数除以第二个数的结果，结果为浮点数 | `7 / 2` → `3.5` |
+| `//`   | 地板除法，返回两个数相除的整数部分                 | `7 // 2` → `3`  |
+| `%`    | 取模，返回第一个数除以第二个数的余数               | `7 % 2` → `1`   |
+| `**`   | 幂运算，返回第一个数的第二个数次幂                 | `2 ** 3` → `8`  |
+
+## 关系运算符
+
+用于比较两个值的关系
+
+| 运算符 | 描述                                     | 示例              |
+| :----- | :--------------------------------------- | :---------------- |
+| `==`   | 等于，判断两个值是否相等                 | `5 == 5` → `True` |
+| `!=`   | 不等于，判断两个值是否不相等             | `5 != 3` → `True` |
+| `>`    | 大于，判断左侧值是否大于右侧值           | `5 > 3` → `True`  |
+| `<`    | 小于，判断左侧值是否小于右侧值           | `5 < 3` → `False` |
+| `>=`   | 大于等于，判断左侧值是否大于或等于右侧值 | `5 >= 5` → `True` |
+| `<=`   | 小于等于，判断左侧值是否小于或等于右侧值 | `3 <= 5` → `True` |
+
+## 逻辑运算符
+
+用于进行布尔逻辑运算
+
+| 运算符 | 描述                                            | 示例                       |
+| :----- | :---------------------------------------------- | :------------------------- |
+| `and`  | 逻辑与，当且仅当两个表达式都为 True 时返回 True | `True and False` → `False` |
+| `or`   | 逻辑或，只要有一个表达式为 True 即返回 True     | `True or False` → `True`   |
+| `not`  | 逻辑非，返回布尔值的反转                        | `not True` → `False`       |
+
+## 赋值运算符
+
+用于给变量赋值
+
+| 运算符 | 描述                              | 示例      |
+| :----- | :-------------------------------- | :-------- |
+| `=`    | 赋值，将右侧的值赋给左侧的变量    | `x = 5`   |
+| `+=`   | 加法赋值，等同于 `x = x + 5`      | `x += 3`  |
+| `-=`   | 减法赋值，等同于 `x = x - 5`      | `x -= 2`  |
+| `*=`   | 乘法赋值，等同于 `x = x * 5`      | `x *= 4`  |
+| `/=`   | 除法赋值，等同于 `x = x / 5`      | `x /= 2`  |
+| `//=`  | 地板除法赋值，等同于 `x = x // 5` | `x //= 3` |
+| `%=`   | 取模赋值，等同于 `x = x % 5`      | `x %= 2`  |
+| `**=`  | 幂赋值，等同于 `x = x ** 5`       | `x **= 3` |
+
+## 位运算符
+
+用于对整数的二进制位进行操作
+
+| 运算符 | 描述                                  | 示例            |
+| :----- | :------------------------------------ | :-------------- |
+| `&`    | 按位与，两个比特位都为 1 时结果为 1   | `5 & 3` → `1`   |
+| ` | `  | 按位或，只要有一个比特位为 1 结果为 1 |                 |
+| `^`    | 按位异或，当比特位不同结果为 1        | `5 ^ 3` → `6`   |
+| `~`    | 按位取反，反转所有比特位              | `~5` → `-6`     |
+| `<<`   | 左移运算，向左移动指定的比特位数      | `5 << 1` → `10` |
+| `>>`   | 右移运算，向右移动指定的比特位数      | `5 >> 1` → `2`  |
+
+## 身份运算符
+
+用于比较两个对象的内存地址
+
+| 运算符   | 描述                         | 示例         |
+| :------- | :--------------------------- | :----------- |
+| `is`     | 判断两个对象是否为同一对象   | `x is y`     |
+| `is not` | 判断两个对象是否不是同一对象 | `x is not y` |
+
+## 成员运算符
+
+用于检查值是否在序列中
+
+| 运算符   | 描述                   | 示例                          |
+| :------- | :--------------------- | :---------------------------- |
+| `in`     | 判断元素是否在序列中   | `3 in [1, 2, 3]` → `True`     |
+| `not in` | 判断元素是否不在序列中 | `4 not in [1, 2, 3]` → `True` |
+
+## 运算符优先级
+
+以下表格列出了从最高到最低优先级的所有运算符：
+
+| 优先级 | 运算符                                     | 描述                       |
+| :----- | :----------------------------------------- | :------------------------- |
+| 1      | `()`                                       | 括号，改变运算顺序         |
+| 2      | `**`                                       | 幂运算                     |
+| 3      | `+`, `-`                                   | 正负号（正负运算）         |
+| 4      | `*`, `/`, `//`, `%`                        | 乘法、除法、地板除法、取模 |
+| 5      | `+`, `-`                                   | 加法、减法                 |
+| 6      | `<<`, `>>`                                 | 位移运算                   |
+| 7      | `&`                                        | 按位与                     |
+| 8      | `^`                                        | 按位异或                   |
+| 9      | ` | `                                      |                            |
+| 10     | `==`, `!=`, `>`, `<`, `>=`, `<=`           | 比较运算                   |
+| 11     | `is`, `is not`, `in`, `not in`             | 身份和成员运算             |
+| 12     | `not`                                      | 逻辑非                     |
+| 13     | `and`                                      | 逻辑与                     |
+| 14     | `or`                                       | 逻辑或                     |
+| 15     | `=`                                        | 赋值                       |
+| 16     | `+=`, `-=`, `*=`, `/=`, `//=`, `%=`, `**=` | 赋值运算                   |
+
+### 注意事项
+
+1. **括号优先**：使用括号可以改变运算顺序，任何在括号内的运算会优先计算。
+2. **运算符结合性**：
+   - 大多数运算符是从左到右结合的，例如加法和减法。
+   - 幂运算 `**` 是从右到左结合，即 `2 ** 3 ** 2` 等于 `2 ** (3 ** 2)`。
+3. **比较运算符**：比较运算符的优先级在逻辑运算符之前。
+4. **赋值运算符**：赋值运算符的优先级最低。
+
+**示例：**
+
+```python
+# 示例 1
+result = 2 + 3 * 4  # 结果为 14，因为乘法优先于加法
+
+# 示例 2
+result = (2 + 3) * 4  # 结果为 20，因为括号改变了优先顺序
+
+# 示例 3
+result = 2 ** 3 ** 2  # 结果为 512，因为幂运算是右结合的
+```
+
+了解运算符优先级有助于在编写和阅读代码时清晰地理解表达式的计算顺序。

project02/02.[任务书]数据类型练习.md

@@ -0,0 +1,113 @@
+# 计算器
+
+## 需求
+
+- 编写一个简单的计算器，在数组中存入算式字符串，然后在新的数组中计算得到答案
+  - 例如，有个数组是`["5 + 3", "6 * 2", "12 / 3", "100 - 55"]`
+  - 得到的输出是`[8, 12, 4, 45]`
+
+## 参考代码
+
+```python
+# 示例输入
+expressions = ["5 + 3", "6 * 2", "12 / 3", "100 - 55"]
+
+# 创建一个新的数组，用来存储计算结果
+results = []
+
+# 遍历数组
+for i in expressions:
+    # 将算式的两个数字取出
+    a = int(i.split(" ")[0])
+    b = int(i.split(" ")[-1])
+    # 判断需要使用什么运算
+    if i.count("+"):
+        results.append(a + b)
+    elif i.count("-"):
+        results.append(a - b)
+    elif i.count("*"):
+        results.append(a * b)
+    elif i.count("/"):
+        results.append(a / b)
+        
+print(results)
+```
+
+## 扩展学习
+
+- 貌似下面的代码更加合适，想办法去搞懂吧
+
+```python
+# 示例输入
+expressions = ["5 + 3", "6 * 2", "12 / 3", "100 - 55"]
+
+# 创建一个新的数组，用来存储计算结果
+results = []
+
+# 遍历算式数组，使用 eval() 计算每个算式的结果
+for expr in expressions:
+    result = eval(expr)  # 计算表达式的值
+    results.append(result)  # 将结果添加到结果数组中
+
+print(results)
+```
+
+
+
+> <span style="color: red; background: yellow; padding: 2px 5px; font-size: 22px;">作业2.1提交的内容</span>
+>
+> - 程序运行成功的截图，单独发送给组长
+
+
+
+# 词频统计
+
+## 需求
+
+- 编写一个词频统计程序，给定一个英文字符串，然后统计每个单词出现次数，并且存入一个字典中(暂不要求排序和截取)
+  - 例如：`Python is a powerful programming language. Python is widely used for web development,  data analysis, artificial intelligence, and scientific computing. Python is simple yet versatile.`
+  - 输出：`{'python': 3, 'is': 3, 'a': 1, 'powerful': 1, 'programming': 1}`
+
+## 参考代码
+
+```python
+# 示例字符串
+text = """
+Python is a powerful programming language. Python is widely used for web development, 
+data analysis, artificial intelligence, and scientific computing. Python is simple yet versatile.
+"""
+
+# 将字符串转换为小写，去掉标点符号，并按空格分割成单词
+words = text.lower()
+
+# 按照空格将单词分开
+word1 = words.split(" ")
+
+# 将单词前后的空格和换行符去除存入l2
+word2 = []
+for i in word1:
+    i = i.strip(".")
+    i = i.strip(",")
+    i = i.strip()
+    word2.append(i)
+
+# 手动统计单词频率
+word_count = {}
+for word in word2:
+    if word in word_count:
+        word_count[word] += 1
+    else:
+        word_count[word] = 1
+
+print(word_count)
+```
+
+## 扩展学习
+
+- 如果想要取排名前5的应该如何，需要大家提前预习后续的知识，发挥一下学习能力吧
+
+
+
+> <span style="color: red; background: yellow; padding: 2px 5px; font-size: 22px;">作业2.2提交的内容</span>
+>
+> - 程序运行成功的截图，单独发送给组长

project02/03.python数据类型.md

@@ -0,0 +1,493 @@
+# Python基本数据结构
+
+# 列表(List)
+
+列表是一个有序的可变集合，可以存储不同类型的元素。列表相比于字符串，不仅可以储存不同的数据类型，而且可以储存大量数据。而且列表是有序的，有索引值，可切片，方便取值。
+
+## 定义列表
+
+```python
+fruits = ["apple", "banana", "cherry"]
+print(fruits)
+
+# Output:
+['apple', 'banana', 'cherry']
+```
+
+## 增加元素
+
+```python
+# 1. 按照索引的位置去增加
+fruits.insert(1, "kiwi")
+
+# 2. 在最末尾添加
+fruits.append("orange")
+
+# 3. 用迭代的方式去添加
+fruits.extend(['a','b','c'])		
+# 可以立即为再传递一个List进去，然后依次添加到末尾,而append会把括号里的当成一个整体添加到末尾
+
+# Output:
+['apple', 'kiwi', 'banana', 'cherry', 'orange', 'a', 'b', 'c']
+```
+
+## 删除元素
+
+```python
+# 1. 删除制定的具体元素
+fruits.remove("cherry")
+
+# 2. 按照索引位置去删除
+fruits.pop()		# 默认是删除最后一个，可以加上索引。并且有返回值，返回值为删除的元素
+fruits.pop(1)
+
+# 3. 使用切片范围删除
+del fruits[1:3]		# 没有返回值
+
+# 4. 清空列表
+fruits.clear()
+
+# 5. 删除列表
+del fruits
+
+# clear是清空列表的内容，变成一个空列表，而del是删除列表本身，后续无法再次调用...
+
+# Output:
+['apple', 'banana', 'cherry']
+['apple', 'kiwi', 'banana', 'cherry', 'orange', 'a', 'b', 'c']
+[]
+```
+
+## 修改元素
+
+```python
+# 1. 按照索引修改某个元素的值
+fruits = ["apple", "banana", "cherry"]
+fruits[1] = "orange"
+print(fruits)
+
+# Output:
+['apple', 'orange', 'cherry']
+
+# 2. 按照切片范围修改
+fruits[0:2] = ['kiwi','orange']
+print(fruits)
+
+# Output:
+['kiwi', 'orange', 'cherry']
+```
+
+## 查找元素
+
+```python
+# 1. index(element)：返回元素的索引
+fruits = ["apple", "banana", "cherry"]
+index_of_apple = fruits.index("apple")
+print(index_of_apple)
+
+# Output:
+0
+
+# 2. count(element)：返回元素出现的次数
+count_of_cherry = fruits.count("cherry")
+print(count_of_cherry)
+
+# Output:
+1
+```
+
+## 列表的切片
+
+切片是按照一定的索引规律分割列表从而组成一个新的列表，类似与我们字符串中讲到的切片
+
+```python
+li = [1,2,4,5,4,2,4]
+sub_li = li[2:5]
+print(sub_li)
+
+# Output:
+[4, 5, 4]
+```
+
+## 其他操作
+
+```python
+li = [1,2,4,5,4,2,4]
+# 1. 统计某个元素出现的次数
+print (li.count(4))
+
+# 2. 从列表中找出某个值第一个匹配项的索引位置
+print (li.index(2))
+
+# 3. 对列表进行排序
+li.sort()
+print(li)
+
+# 4. 将列表中的元素反向存放
+li.reverse()
+print (li)
+
+# Output:
+3
+1
+[1, 2, 2, 4, 4, 4, 5]
+[5, 4, 4, 4, 2, 2, 1]
+```
+
+# 元组(Tuple)
+
+有序的不可变集合，也被被称为只读列表，即数据可以被查询，但不能被修改。
+
+## 定义元组
+
+```python
+tuple = (1,2,3,'a','b','c')
+print(tuple)
+print(tuple[1])
+
+# 可以删除元素吗?
+tuple.pop()
+
+# Output:
+AttributeError: 'tuple' object has no attribute 'pop'
+```
+
+## 可变元组
+
+tuple其实不可变的是地址空间，如果地址空间里存的是可变的数据类型的话，比如列表就是可变的
+
+```python
+tuple = (1, 2, 3, [1, 4, 7])
+print(tuple)
+tuple[3][2] = 100
+print(tuple)
+
+# Output:
+(1, 2, 3, [1, 4, 7])
+(1, 2, 3, [1, 4, 100])
+```
+
+在元组tuple中，包含一个list类型的数据，由于list是可以变的，所以我们可以更改元组里list的值，但是元组本身的地址空间是不变的。
+
+<img src="./03.python更多数据类型/image-20240904095734746.png" alt="image-20240904095734746" style="zoom:80%;" />
+
+# 字典(Dict)
+
+字典是python中唯一的映射类型，采用键值对（key-value）的形式存储数据。python对key进行哈希函数运算，根据计算的结果决定value的存储地址，所以字典是无序存储的，且key必须是可哈希的。可哈希表示key必须是不可变类型，如：数字、字符串、元组。
+
+不过在Python 3.6版本以后，字典会保留插入顺序，变成有序数据结构。
+
+而且键是具有唯一性的，每个键只能出现一次，但是值没有限制，在一个字典中可以出现多个相同的值。
+
+## 定义字典
+
+```python
+dic = {'name':'nls','age':18,'job':'teacher'}
+print(dic)
+print(dic['name'])
+print(dic['age'])
+print(dic['job'])
+
+# Output:
+{'name': 'nls', 'age': 18, 'job': 'teacher'}
+nls
+18
+teacher
+```
+
+## 增加键值
+
+```python
+dic = {'name':'nls','age':18,'job':'teacher'}
+
+# 1. 直接通过键值对来增加
+dic['hobby'] = 'study'		# 如果键已经存在，那么就会替换原来的值
+
+print(dic)
+# Output: {'name': 'nls', 'age': 18, 'job': 'teacher', 'hobby': 'study'}
+
+# 2. 在字典中添加键值对时，如果指定的键已经存在则不做任何操作,如果原字典中不存在指定的键值对，则会添加。
+dic.setdefault('name','牛老师')
+dic.setdefault('gender','男')
+print(dic)
+
+# Output:
+{'name': 'nls', 'age': 18, 'job': 'teacher', 'hobby': 'study', 'gender': '男'}
+```
+
+## 删除键值
+
+```python
+dic = {'name':'nls','age':18,'job':'teacher'}
+
+# 1. 删除指定的键,并且返回对应的值
+name = dic.pop('job')
+hobby = dic.pop('hobby','查无此项')		# 可以在后面加上一个异常处理，如果key不存在，就输出后面的内容
+print(dic)
+print(name)
+print(hobby)
+
+# Output:
+{'name': 'nls', 'age': 18}
+teacher
+查无此项
+
+# 2. 使用del关键字删除指定的键值对
+del dic['name']
+
+# 3. 删除最后插入的键值对
+dic_pop = dic.popitem()
+print(dic_pop)
+
+# 4. 清空字典
+dic.clear()
+print(dic)
+
+# Output: {}
+```
+
+## 修改键值
+
+```python
+dic = {'name':'nls','age':18,'job':'teacher'}
+dic['age'] = 25
+
+print(dic)
+
+# Output:
+{'name': 'nls', 'age': 25, 'job': 'teacher'}
+```
+
+## 查找键值
+
+```python
+dic = {'name':'nls','age':18,'job':'teacher'}
+# 1. 直接通过键名获取，如果不存在会报错
+value = dic['name']
+print(value)
+
+# 2. 使用get方法获取键值,若不存在则返回 None，可以自定义异常返回值
+value = dic.get('job','查无此项')
+print(value)
+
+# Output:
+nls
+teacher
+
+# 3. IN关键字，存在返回True，反之False
+exists = "name" in dic
+print(exists)
+
+# Output:
+True
+```
+
+## 其他操作
+
+```python
+dic = {'name':'nls','age':18,"phone":['1888888888','0511-10101010']}
+# 字典里面的value也可以是容器类型的数据，比如列表，字典等等...但是key必须是不可变的
+print(dic)
+
+# 1. 对键和值进行迭代操作
+for i in dic.items():
+	# 将键和值作为元祖列出
+    print(i)
+
+for i in dic:
+	# 只迭代键
+    print(i)
+    
+# Output:
+('name', 'nls')
+('age', 18)
+('phone', ['1888888888', '0511-10101010'])
+name
+age
+phone
+
+# 2. 使用keys()和values()方法获取键值
+keys = dic.keys()
+print(keys,type(keys))
+
+value = dic.values()
+print(value,type(value))
+
+# Output:
+dict_keys(['name', 'age', 'phone']) <class 'dict_keys'>
+dict_values(['nls', 18, ['1888888888', '0511-10101010']]) <class 'dict_values'>
+```
+
+# 集合(Set)
+
+集合是**无序**的，**不重复**，**确定性**的数据集合，它里面的元素是可哈希的(不可变类型)，但是集合本身是不可哈希（所以集合做不了字典的键）的。以下是集合最重要的两点：
+
+- 去重，把一个列表变成集合，就自动去重了。
+- 关系测试，测试两组数据之前的交集、差集、并集等关系。
+
+## 定义集合
+
+```python
+set1 = {1,2,3,'a','b','c'}		# 推荐方法
+set2 = set({1,2,3})
+
+print(set1, set2)
+
+# Output:
+{1, 2, 3, 'b', 'c', 'a'} {1, 2, 3}
+```
+
+## 增加元素
+
+```python
+set1 = {1,2,3,'a','b','c'}
+# 1. 使用add()方法为集合增加元素
+set1.add('d')
+print(set1)
+
+# Output:
+{'a', 1, 2, 3, 'c', 'd', 'b'}
+
+# 2. 使用update()方法迭代的去增加
+set1.update('e','f')
+# update接收的参数应该是可迭代的数据类型，比如字符串、元组、列表、集合、字典。这些都可以向集合中添加元素，但是整型、浮点型不可以
+set1.update([4,5,6])
+print(set1)
+
+# Output:
+{1, 2, 3, 4, 5, 6, 'a', 'd', 'b', 'c', 'f', 'e'}
+```
+
+## 删除元素
+
+```python
+set1 = {1,2,3,'a','b','c'}
+# 1. 使用remove()方法删除元素
+set1.remove('a')
+
+print(set1)
+
+# 2. 随机删除某个元素
+set1.pop()
+print(set1)
+
+# Output:
+{1, 2, 3, 'c', 'b'}
+{2, 3, 'c', 'b'}
+
+# 3. 删除集合本身
+del set1
+```
+
+## 查找元素
+
+```python
+set1 = {1,2,3,'a','b','c'}
+exists = "a" in set1  # True
+print(exists)
+```
+
+## 关系测试
+
+### 交集(& 或者 intersection)
+
+取出两个集合共有的元素
+
+```python
+set1 = {1,2,3,4,5}
+set2 = {3,4,5,6,7}
+
+print(set1 & set2)
+print(set1.intersection(set2))
+
+# Output:
+{3, 4, 5}
+{3, 4, 5}
+```
+
+### 反交集(^ 或者 symmetric_difference)
+
+```python
+set1 = {1,2,3,4,5}
+set2 = {3,4,5,6,7}
+
+print(set1 ^ set2)
+print(set1.symmetric_difference(set2))
+
+# Output:
+{1, 2, 6, 7}
+{1, 2, 6, 7}
+```
+
+### 并集(| 或者 union)
+
+合并两个集合的所有元素
+
+```python
+set1 = {1,2,3,4,5}
+set2 = {3,4,5,6,7}
+
+print(set1 | set2)
+print(set2.union(set1))
+
+# Output:
+{1, 2, 3, 4, 5, 6, 7}
+{1, 2, 3, 4, 5, 6, 7}
+```
+
+### 差集(- 或者 difference)
+
+第一个集合去除二者共有的元素
+
+```python
+set1 = {1,2,3,4,5}
+set2 = {3,4,5,6,7}
+
+print(set1 - set2)
+print(set1.difference(set2))
+
+# Output:
+{1, 2}
+{1, 2}
+```
+
+### 子集与超集
+
+当一个集合的所有元素都在另一个集合里，则称这个集合是另一个集合的子集，另一个集合是这个集合的超集
+
+```python
+set1 = {1,2,3}
+set2 = {1,2,3,4,5,6}
+
+print(set1 < set2)
+print(set1.issubset(set2))  # 这两个相同，都是说明set1是set2子集。
+
+print(set2 > set1)
+print(set2.issuperset(set1))  # 这两个相同，都是说明set2是set1超集
+```
+
+## 不可变集合
+
+```python
+set1 = {1,2,3,4,5,6}
+
+set2 = frozenset(set1)
+print(set2,type(set2))
+
+set2.add(7) # 不可以修改,会报错
+
+# Output:
+AttributeError: 'frozenset' object has no attribute 'add'
+```
+
+# 数据结构的总结
+
+| 数据结构              | 描述             | 特性                   | 常见操作               | 适用场景                                 | 优点                        | 缺点                                  |
+| :-------------------- | :--------------- | :--------------------- | :--------------------- | :--------------------------------------- | :-------------------------- | :------------------------------------ |
+| **列表 (List)**       | 有序的可变集合   | 有序、可变、支持重复   | 添加、删除、修改、查找 | 需要维护元素顺序的场景，如队列、栈的实现 | 灵活性高，支持多种操作      | 查询复杂度为 O(n)，插入和删除性能较差 |
+| **元组 (Tuple)**      | 有序的不可变集合 | 有序、不可变、支持重复 | 查找                   | 元素不需要修改的场景，如函数参数、字典键 | 更节省内存，速度较快        | 不支持修改                            |
+| **集合 (Set)**        | 无序的可变集合   | 无序、可变、不支持重复 | 添加、删除、查找       | 需要去重和快速查找的场景，如集合运算     | 快速查找和去重              | 不支持索引，元素无序                  |
+| **字典 (Dictionary)** | 有序的键值对集合 | 有序、可变、键唯一     | 添加、删除、修改、查找 | 需要快速查找和存储键值对的场景，如缓存   | 快速查找（O(1) 平均复杂度） | 键必须是不可变类型，内存开销较大      |
+| **字符串 (String)**   | 字符的序列       | 不可变                 | 查找、切片、替换       | 文本处理                                 | 易于使用，内置丰富的方法    | 不可修改，性能较低                    |
+
+#