# 注释

单行注释：

```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，因为幂运算是右结合的
```

了解运算符优先级有助于在编写和阅读代码时清晰地理解表达式的计算顺序。