plain = list(input("请输入需要加密的明文（只支持英文字母）："))
key = int(input("请输入移动的位数："))
base_A = ord('A')
base_a = ord('a')
cipher = []
for each in plain:
if each == ' ':
cipher.append(' ')
else:
if each.isupper():
base = base_A
else:
base = base_a
cipher.append(chr((ord(each) - base + key) % 26 + base))
print(''.join(cipher))
plain = list(input("请输入需要加密的明文（只支持英文字母）："))
key = int(input("请输入移动的位数："))
base_A = ord('A')
base_a = ord('a')
cipher = []
for each in plain:
if each == ' ':
cipher.append(' ')
else:
if each.isupper():
base = base_A
else:
base = base_a
cipher.append(chr((ord(each) - base + key) % 26 + base))
print(''.join(cipher))
【对关键步骤详细的解析】
在第7步之后的逻辑主要处理的是如何通过凯撒加密对字母进行位移，并且确保字母仍然保持在字母表内（即 'A'-'Z' 或 'a'-'z' 之间）。这部分的逻辑相对关键，涉及到字符的转换和加密。
### 第7步及之后的代码：
```python
else:
if each.isupper():
base = base_A
```
- 如果字符不是空格，首先判断它是大写字母还是小写字母。通过 `each.isupper()` 判断。
- 如果是大写字母（如 'A', 'B', 'C' 等），`base` 被设置为 `base_A`，即 `'A'` 的 ASCII 值（65）。
- 如果是小写字母，`base` 被设置为 `base_a`，即 `'a'` 的 ASCII 值（97）。
```python
else:
base = base_a
```
- 如果是小写字母（如 'a', 'b', 'c' 等），则 `base` 被设置为小写字母 'a' 的 ASCII 值。
### 8. 字母加密的核心代码：
```python
cipher.append(chr((ord(each) - base + key) % 26 + base))
```
这行代码执行了加密操作。下面分步解释它的功能：
1. **获取当前字母的 ASCII 值：**
`ord(each)` 取出当前字符 `each` 的 ASCII 值。假设 `each = 'A'`，那么 `ord('A') = 65`。
2. **计算相对于字母表起始的偏移量：**
`ord(each) - base` 计算当前字母相对于字母表起始位置（'A' 或 'a'）的偏移量。假设当前字符是 `'A'`（并且 `base = base_A = 65`），则：
- `ord('A') - 65 = 0`（因为 'A' 在字母表中的位置是 0）。
如果当前字符是 `'B'`，则：
- `ord('B') - 65 = 1`，表示 'B' 在字母表中的位置是 1。
3. **进行位移并确保结果在字母表范围内：**
`(ord(each) - base + key) % 26` 这一部分对计算得到的偏移量进行加密。加上 `key` 后，通过 `% 26` 保证偏移量不会超出 0 到 25 的范围。这里的 `26` 是字母表的长度（26 个字母）。
- 比如 `key = 3`，并且当前字母是 `'A'`，那么：
- 偏移量 `ord('A') - 65 = 0`
- `(0 + 3) % 26 = 3`，结果是 3，表示字母表中的第 3 个字母（'D'）。
4. **将偏移后的结果转换回字母：**
`chr(... + base)` 将计算得到的新偏移量转回字母，并加上基准值 `base`。这个 `base` 是对应大写字母或小写字母的起始 ASCII 值，确保加密后的字母仍然在正确的字母表范围内。
- 比如，如果计算的结果是 3（对于大写字母 'A'），那么 `chr(3 + 65) = 'D'`，即加密后的字符是 `'D'`。
- 如果当前字母是 `'a'`，且 `key = 3`，计算过程类似，结果是 `'d'`。
### 示例说明：
#### 例子 1：大写字母加密
- 明文：`A B C D`
- 偏移量：`key = 3`
按照加密过程，我们逐个字符进行加密：
- 对于 `'A'`：
1. `ord('A') = 65`
2. `65 - 65 = 0`（偏移量）
3. `(0 + 3) % 26 = 3`
4. `chr(3 + 65) = 'D'`
5. 所以 `'A'` 被加密为 `'D'`。
- 对于 `'B'`：
1. `ord('B') = 66`
2. `66 - 65 = 1`（偏移量）
3. `(1 + 3) % 26 = 4`
4. `chr(4 + 65) = 'E'`
5. 所以 `'B'` 被加密为 `'E'`。
- 对于 `'C'`：
1. `ord('C') = 67`
2. `67 - 65 = 2`（偏移量）
3. `(2 + 3) % 26 = 5`
4. `chr(5 + 65) = 'F'`
5. 所以 `'C'` 被加密为 `'F'`。
- 对于 `'D'`：
1. `ord('D') = 68`
2. `68 - 65 = 3`（偏移量）
3. `(3 + 3) % 26 = 6`
4. `chr(6 + 65) = 'G'`
5. 所以 `'D'` 被加密为 `'G'`。
最终，加密后的密文是：`D E F G`
#### 例子 2：小写字母加密
- 明文：`a b c d`
- 偏移量：`key = 2`
逐个字符加密：
- 对于 `'a'`：
1. `ord('a') = 97`
2. `97 - 97 = 0`（偏移量）
3. `(0 + 2) % 26 = 2`
4. `chr(2 + 97) = 'c'`
5. 所以 `'a'` 被加密为 `'c'`。
- 对于 `'b'`：
1. `ord('b') = 98`
2. `98 - 97 = 1`（偏移量）
3. `(1 + 2) % 26 = 3`
4. `chr(3 + 97) = 'd'`
5. 所以 `'b'` 被加密为 `'d'`。
- 对于 `'c'`：
1. `ord('c') = 99`
2. `99 - 97 = 2`（偏移量）
3. `(2 + 2) % 26 = 4`
4. `chr(4 + 97) = 'e'`
5. 所以 `'c'` 被加密为 `'e'`。
- 对于 `'d'`：
1. `ord('d') = 100`
2. `100 - 97 = 3`（偏移量）
3. `(3 + 2) % 26 = 5`
4. `chr(5 + 97) = 'f'`
5. 所以 `'d'` 被加密为 `'f'`。
最终，加密后的密文是：`c d e f`
### 总结
1. **偏移量计算：** 每个字母的偏移量通过 `ord(each) - base` 计算，得到相对字母表的偏移。
2. **加密过程：** 通过 `(ord(each) - base + key) % 26` 保证加密后的字母仍然在字母表范围内。
3. **转换为字符：** 计算出新的偏移量后，再通过 `chr(... + base)` 将其转换为加密后的字符。
这种方法确保了大写字母和小写字母分别独立加密，同时保证字母表的循环性（例如 'Z' 加密后是 'A'，'z' 加密后是 'a'）。
