Jeskson文档-微服务分布式系统架构

第4天-Python基础

2023/6/15

# 第4天-Python基础

Python的语法比较简单，采用缩进方式

# print absolute value of an integer:
a = 100
if a >= 0:
    print(a)
else:
    print(-a)

# Python 数据类型和变量

# 1. 数据类型（Data Types）

在 Python 中，数据类型指的是我们存储和操作的数据的类别。不同的数据类型决定了我们可以对数据执行什么样的操作。

Python 支持多种常用的数据类型，主要分为以下几类：

# 1.1 数字类型（Numeric Types）

  • 整数（int）：表示没有小数点的数字。
  • 浮点数（float）：表示带有小数点的数字。

示例：

# 整数类型
x = 10  # 这是一个整数
y = -5  # 负数也是整数

# 浮点数类型
a = 3.14  # 这是一个浮点数
b = -0.001  # 负数浮点数

# 1.2 字符串类型（String）

  • 字符串是由字符组成的序列，通常用引号括起来（单引号 ' 或双引号 " 都可以）。

示例：

# 字符串类型
name = "Alice"  # 使用双引号定义字符串
greeting = 'Hello, World!'  # 使用单引号定义字符串

# 1.3 布尔类型（Boolean）

  • 布尔值有两个取值：True 和 False，用于表示真或假，常用于条件判断。

示例：

is_student = True  # True 表示"是学生"
has_completed_homework = False  # False 表示"没有完成作业"

# 1.4 列表类型（List）

  • 列表是一个有序的元素集合，可以包含不同类型的元素，列表用方括号 [] 表示。

示例：

# 列表类型
fruits = ["apple", "banana", "cherry"]  # 包含字符串的列表
numbers = [1, 2, 3, 4, 5]  # 包含整数的列表
mixed_list = [1, "apple", 3.14, True]  # 混合数据类型的列表

# 1.5 元组类型（Tuple）

  • 元组和列表类似，不同之处在于元组是不可更改的，也就是说，元组中的元素一旦定义就不能被修改。元组用圆括号 () 表示。

示例：

# 元组类型
coordinates = (10, 20)  # 二维坐标的元组
person = ("Alice", 25, "Engineer")  # 包含多个信息的元组

# 1.6 字典类型（Dictionary）

  • 字典是一种无序的数据结构，由键（key）和值（value）对组成，键和值通过冒号 : 分隔，整个字典用大括号 {} 包裹。

示例：

# 字典类型
student = {"name": "Alice", "age": 20, "major": "Physics"}  # 存储学生信息

# 1.7 集合类型（Set）

  • 集合是一种无序的、不重复的元素集合，用大括号 {} 表示。

示例：

# 集合类型
colors = {"red", "green", "blue"}  # 不允许重复元素

# 2. 变量（Variable）

变量是一个用来存储数据的容器，可以将数据赋值给变量并使用它。变量可以保存不同类型的数据。Python 中不需要显式声明变量的类型，Python 会根据赋值自动推断类型。

# 2.1 变量定义

变量的定义非常简单，只需要通过 = 赋值操作符来定义和赋值。

示例：

# 定义一个整数变量
age = 25  # age 是变量，25 是它的值

# 定义一个字符串变量
name = "Alice"  # name 是变量，"Alice" 是它的值

# 定义一个列表变量
fruits = ["apple", "banana", "cherry"]  # fruits 是变量，它的值是一个列表

# 2.2 变量的类型

变量的类型是由它存储的数据类型决定的。例如，age = 25 中，age 是一个整数类型的变量。

# 2.3 变量的作用域

变量的作用域是指变量的可访问范围。在 Python 中，变量有局部作用域和全局作用域：

  • 局部变量：在函数内部定义，只能在函数内部访问。
  • 全局变量：在函数外部定义，可以在整个程序中访问。

示例：

# 全局变量
global_var = "I am global"  # 在函数外定义，整个程序可以访问

def test():
    # 局部变量
    local_var = "I am local"  # 在函数内部定义，只能在这个函数内访问
    print(local_var)  # 输出局部变量

test()
print(global_var)  # 输出全局变量

# 3. 总结

  • 数字类型（int 和 float）用于表示数值。
  • 字符串类型（str）用于表示文字或字符序列。
  • 布尔类型（bool）表示真或假，常用于条件判断。
  • 列表、元组、字典和集合是容器类型，分别用于存储多个元素。
  • 变量是存储数据的“容器”，可以动态赋值并在程序中使用。

通过这些基本的数据类型和变量，你可以在 Python 中轻松地存储、操作和传递数据。

# Python 字符串和编码

# 1. 字符串（String）

在 Python 中，字符串（String） 是由字符组成的序列。这些字符可以是字母、数字、符号等，字符串用单引号 '' 或双引号 "" 来定义。

  • 字符串是不可变的，也就是说一旦创建，就不能改变其中的字符。

# 1.1 创建字符串

我们可以通过简单的引号（单引号或双引号）来创建字符串。

示例：

# 使用单引号创建字符串
name = 'Alice'

# 使用双引号创建字符串
greeting = "Hello, World!"

# 1.2 字符串操作

  • 拼接字符串：可以使用 + 号来拼接两个或多个字符串。
  • 重复字符串：可以使用 * 号来重复字符串。
  • 索引和切片：可以通过索引访问字符串中的字符，索引从 0 开始，负数表示从字符串的末尾开始。

示例：

# 拼接字符串
full_name = 'Alice' + ' ' + 'Smith'
print(full_name)  # 输出 "Alice Smith"

# 重复字符串
repeat_string = 'Hello ' * 3
print(repeat_string)  # 输出 "Hello Hello Hello "

# 索引
first_char = 'Hello'[0]  # 获取第一个字符
print(first_char)  # 输出 "H"

# 切片
substring = 'Hello'[:3]  # 获取前3个字符
print(substring)  # 输出 "Hel"

# 1.3 字符串方法

Python 中有很多内置的字符串方法，常用的有：

  • lower()：将字符串转换为小写。
  • upper()：将字符串转换为大写。
  • replace(old, new)：替换字符串中的某些字符。
  • strip()：去除字符串两端的空格。
  • split()：将字符串分割成列表。

示例：

text = "  Hello, World!  "

# 去除前后的空格
clean_text = text.strip()
print(clean_text)  # 输出 "Hello, World!"

# 字符串转为小写
lowercase_text = "Hello".lower()
print(lowercase_text)  # 输出 "hello"

# 替换字符
new_text = "Hello World".replace("World", "Alice")
print(new_text)  # 输出 "Hello Alice"

# 2. 编码（Encoding）

编码（Encoding） 是将字符转换成计算机可以处理的二进制数据（字节）的过程。不同的编码方式会用不同的规则将字符转换为字节。

# 2.1 字符编码示例：
  • ASCII：美国标准信息交换代码（ASCII）只使用 128 个字符（例如字母、数字、符号）。每个字符占用 1 字节。
  • Unicode：Unicode 是一种全球通用的字符编码方式，支持所有的语言字符（包括中文、日文等）。它可以使用不同的字节数来表示字符（如 UTF-8、UTF-16 等）。
# 2.2 Python 中的编码与解码

Python 默认使用 Unicode 字符编码，这意味着可以直接处理大部分语言的字符（比如中文、日文等）。当你从文件或网络获取数据时，可能需要将字节数据转换为字符串，或者将字符串转换为字节数据。

  • 编码：将字符串转换为字节。
  • 解码：将字节转换为字符串。

示例：

# 字符串编码为字节
text = "Hello, 世界!"
encoded_text = text.encode('utf-8')  # 使用 UTF-8 编码
print(encoded_text)  # 输出 b'Hello, \xe4\xb8\x96\xe7\x95\x8c!'

# 字节解码为字符串
decoded_text = encoded_text.decode('utf-8')
print(decoded_text)  # 输出 "Hello, 世界!"

# 2.3 常见编码格式

  • UTF-8：一种变长的 Unicode 编码方式，最常用，兼容 ASCII。
  • GB2312、GBK：中文字符编码，GBK 包含了更多的汉字。
  • ISO-8859-1：西欧语言常用的编码方式。

# 3. 编码相关的常见问题

# 3.1 UnicodeError 错误

如果你尝试使用不正确的编码格式来解码字节数据，可能会引发 UnicodeError。

示例：

# 假设我们有一些字节数据，尝试用错误的编码解码
byte_data = b'\xe4\xb8\x96\xe7\x95\x8c'  # 这是 "世界" 的 UTF-8 编码

# 错误解码（如果用其他编码解码，会报错）
try:
    decoded_text = byte_data.decode('ascii')
except UnicodeDecodeError as e:
    print(f"解码错误: {e}")

# 3.2 文件读取与写入的编码问题

在读取和写入文件时，通常需要指定编码格式，特别是处理包含非 ASCII 字符的文件时。

示例：

# 写入文件时指定编码
with open('sample.txt', 'w', encoding='utf-8') as file:
    file.write("Hello, 世界!")

# 读取文件时指定编码
with open('sample.txt', 'r', encoding='utf-8') as file:
    content = file.read()
    print(content)  # 输出 "Hello, 世界!"

# 4. 总结

  • 字符串（String） 是由字符组成的序列，可以进行拼接、切片、替换等操作。
  • 编码（Encoding） 是将字符转换为计算机可以理解的字节数据的过程。Python 默认使用 Unicode 编码（UTF-8）。
  • 常见编码格式：UTF-8、ASCII、GBK 等。
  • 常见操作：将字符串编码为字节或将字节解码为字符串。

通过了解字符串和编码，你能更好地处理文本数据，尤其是涉及多语言和文件操作时。

# Python 中的 list 和 tuple - 通俗易懂的解释

在 Python 中，list 和 tuple 都是用来存储多个元素的数据结构，它们有很多相似之处，但也有一些关键的区别。

# 1. List（列表）

  • 定义：list（列表）是一个可变的、有序的容器，用来存储多个元素。

  • 特点：

    • 可变：可以修改、添加和删除元素。
    • 有序：列表中的元素有固定的顺序，可以通过索引访问。
    • 可以包含不同类型的数据：可以存储整数、字符串、甚至其他列表。

# 示例：创建和操作 list

# 创建一个列表
fruits = ["apple", "banana", "cherry"]

# 访问列表中的元素
print(fruits[0])  # 输出 "apple"（索引从0开始）

# 修改列表中的元素
fruits[1] = "orange"  # 将 "banana" 改为 "orange"
print(fruits)  # 输出 ["apple", "orange", "cherry"]

# 向列表中添加元素
fruits.append("grape")  # 添加 "grape" 到列表的末尾
print(fruits)  # 输出 ["apple", "orange", "cherry", "grape"]

# 删除列表中的元素
fruits.remove("cherry")  # 删除 "cherry"
print(fruits)  # 输出 ["apple", "orange", "grape"]

# 常用的 list 方法：

  • append()：向列表添加一个元素。
  • remove()：删除列表中的某个元素。
  • pop()：删除并返回指定索引的元素。
  • sort()：对列表进行排序。

# 2. Tuple（元组）

  • 定义：tuple（元组）也是一个有序的容器，用来存储多个元素，但与 list 不同的是，元组是不可变的。

  • 特点：

    • 不可变：创建后不能修改，不能增加或删除元素。
    • 有序：和列表一样，元素有固定顺序，可以通过索引访问。
    • 可以包含不同类型的数据：元组也可以存储不同类型的元素。

# 示例：创建和操作 tuple

# 创建一个元组
coordinates = (10, 20, 30)

# 访问元组中的元素
print(coordinates[0])  # 输出 10（索引从0开始）

# 元组是不可变的，不能修改
# coordinates[1] = 50  # 这会引发错误，因为元组不能修改

# 可以创建单元素元组（注意要加逗号）
single_element_tuple = (5,)
print(single_element_tuple)  # 输出 (5,)

# 元组的常用方法：

  • count()：返回指定元素在元组中出现的次数。
  • index()：返回指定元素在元组中的索引。

# 3. list 和 tuple 的区别

特性 List（列表） Tuple（元组）
可变性 可变（可以修改、添加和删除元素） 不可变（创建后不能修改、添加或删除元素）
语法 使用方括号 [] 使用圆括号 ()
存储方式 存储在内存中，占用更多内存（因为它是可变的） 存储在内存中，占用更少的内存（因为它是不可变的）
用途 适合需要修改元素或动态变化的数据结构 适合存储不需要修改的数据，通常用于保护数据不被改变

# 4. 何时使用 list，何时使用 tuple

  • 使用 list：

    • 当你需要一个可以随时添加、修改、删除元素的容器时，使用 list。
    • 例如：你需要存储一个购物清单，可以随时添加或删除商品。

  • 使用 tuple：

    • 当你需要一个不可变的容器，确保数据不被修改时，使用 tuple。
    • 例如：你需要存储一个坐标点（经度、纬度），这些值在计算过程中不会改变。

# 5. 总结

  • List（列表）：可以修改、添加、删除元素；适用于需要频繁修改数据的场景。
  • Tuple（元组）：一旦创建就无法修改；适用于需要保护数据不被更改的场景。

这两种数据类型各有其优缺点，根据需求选择合适的类型可以让你的程序更加高效且安全。

# Python 条件判断

在程序中，我们常常需要根据不同的情况执行不同的操作，比如：

如果今天下雨，就带伞；否则就不带。

这就是“条件判断”，也叫“分支语句”。

# 一、基本语法结构

Python 使用 if、elif 和 else 来进行条件判断：

if 条件1:
    代码块1
elif 条件2:
    代码块2
else:
    代码块3
  • if：如果条件为 True，执行它下面的代码。
  • elif（else if）：如果上面的条件不满足，检查这个条件。
  • else：其他情况都不满足时执行。

# 二、简单示例

# 示例1：判断天气

weather = "rain"

if weather == "sunny":
    print("出去玩")
elif weather == "rain":
    print("带伞")
else:
    print("待在家里")

输出：

带伞

# 示例2：判断数字正负

num = -10

if num > 0:
    print("正数")
elif num == 0:
    print("零")
else:
    print("负数")

输出：

负数

# 三、条件表达式支持的运算符

运算符 含义 示例
== 等于 x == 10
!= 不等于 x != 5
> 大于 x > 0
< 小于 x < 100
>= 大于等于 x >= 18
<= 小于等于 x <= 60
and 与（同时满足） x > 0 and x < 10
or 或（满足一个） x < 0 or x > 100
not 非（取反） not x == 0

# 示例3：判断年龄是否在合法范围内（18~60）

age = 25

if age >= 18 and age <= 60:
    print("合法年龄")
else:
    print("不合法")

# 四、嵌套判断（if 里面再套 if）

score = 85

if score >= 60:
    if score >= 90:
        print("优秀")
    else:
        print("及格")
else:
    print("不及格")

# 五、简洁写法（三元运算）

x = 10
result = "正数" if x > 0 else "负数或零"
print(result)

在 Python 中，模式匹配（Pattern Matching） 是一种类似于“结构解构 + 条件判断”的语法，它让我们可以更简洁、清晰地处理复杂数据结构，尤其适合处理字典、列表、元组等嵌套结构。

Python 从 3.10 版本开始，引入了官方的结构化模式匹配语法 —— match ... case，非常类似于其他语言中的 switch。

# 一、语法结构：match ... case

match 变量:
    case 模式1:
        执行代码1
    case 模式2:
        执行代码2
    case _:
        默认处理（相当于 else）

# 二、通俗示例

# 示例1：匹配字符串值（类似 switch）

command = "start"

match command:
    case "start":
        print("启动程序")
    case "stop":
        print("停止程序")
    case "pause":
        print("暂停程序")
    case _:
        print("未知命令")

输出：

启动程序

# 示例2：匹配元组（结构解包）

point = (0, 5)

match point:
    case (0, 0):
        print("原点")
    case (x, 0):
        print(f"在 X 轴上, x = {x}")
    case (0, y):
        print(f"在 Y 轴上, y = {y}")
    case (x, y):
        print(f"在平面上，x={x}, y={y}")

输出：

在 Y 轴上, y = 5

# 示例3：匹配字典结构

user = {"type": "admin", "name": "Alice"}

match user:
    case {"type": "admin", "name": name}:
        print(f"管理员：{name}")
    case {"type": "guest", "name": name}:
        print(f"访客：{name}")
    case _:
        print("未知用户")

输出：

管理员：Alice

# 三、常见匹配模式

模式类型 示例 描述
常量匹配 case "ok" 匹配特定值
变量绑定 case x: 将值绑定到变量
元组结构匹配 case (x, y) 拆解元组
列表匹配 case [x, y, z] 拆解固定长度的列表
字典匹配 case {"type": "admin", "id": id} 匹配并提取字典中的字段
通配符 _ case _: 匹配所有剩余情况（默认分支）

# 四、注意事项

  • 需要 Python 3.10 及以上版本。
  • match-case 区分大小写。
  • case 分支必须是静态模式，不能使用逻辑表达式（如 case x > 5: 会报错）。
  • 若想使用表达式判断，需在 case 后加守卫条件（if）

# 示例4：使用守卫条件 if

x = 8

match x:
    case x if x > 10:
        print("大于10")
    case x if x > 5:
        print("大于5")
    case _:
        print("5或以下")

输出：

大于5

# 总结

特性 优点
解构数据结构 支持元组、列表、字典、类
多分支结构清晰 替代复杂的 if-elif
默认分支 _ 简洁处理未匹配情况
支持守卫语句 配合 if 做条件限制

在 Python 中，循环（loop） 是一种重复执行代码块的结构，直到满足某个条件为止。常用于遍历列表、字典、范围，或重复某些操作。

# 一句话理解循环

就是：“做这件事一直重复，直到不需要为止”

# 一、两种常用的循环方式

循环类型 适用场景 关键字
for 循环 知道要循环几次或遍历东西时 for ... in ...
while 循环 不知道要循环几次，只知道条件 while 条件:

# 二、for 循环（最常用）

用于遍历序列类型（如 list、tuple、str、dict、range）

# 示例1：遍历列表

fruits = ["apple", "banana", "cherry"]

for fruit in fruits:
    print(fruit)

输出：

apple
banana
cherry

# 示例2：遍历字符串

for letter in "hello":
    print(letter)

输出：

h
e
l
l
o

# 示例3：使用 range() 遍历数字

for i in range(5):  # 0 ~ 4（不包括5）
    print(i)

# 🔁 三、while 循环（基于条件）

只要条件为 True，就不断执行

# 示例4：用 while 数到 5

i = 1
while i <= 5:
    print(i)
    i += 1

输出：

1
2
3
4
5

# 🛑 四、控制循环的语句

语句 作用
break 立即退出循环
continue 跳过当前这次循环，继续下一次
else（可选） 循环正常结束后执行（非中断）

# 示例5：break 用法

for i in range(1, 10):
    if i == 5:
        break
    print(i)

输出：

1
2
3
4

# 示例6：continue 用法

for i in range(1, 6):
    if i == 3:
        continue  # 跳过3
    print(i)

输出：

1
2
4
5

# 🎁 五、循环的综合例子：猜数字游戏

secret = 7
guess = 0

while guess != secret:
    guess = int(input("猜一个 1~10 的数字: "))
    if guess < secret:
        print("猜小了")
    elif guess > secret:
        print("猜大了")
    else:
        print("猜对了！")

# ✅ 总结

循环类型 用途 示例
for 遍历列表、字符串、数字序列等 for x in ...
while 基于条件重复执行 while 条件:
break 提前终止循环 if 条件: break
continue 跳过当前轮，继续下一轮 if 条件: continue

# 1. 九九乘法表（嵌套 for 循环）

# 打印九九乘法表
for i in range(1, 10):  # 外层控制行数（1 到 9）
    for j in range(1, i + 1):  # 内层控制每行的列数
        print(f"{j}×{i}={i*j}", end="\t")
    print()  # 换行

输出（部分）：

1×1=1
1×2=2	2×2=4
1×3=3	2×3=6	3×3=9
...

# 二、字典（dict）—— 键值对存储

# 概念：

dict 就像一个“电话号码本”或“小型数据库”，通过“键”快速找到对应的“值”。

# 语法：

字典名 = {键1: 值1, 键2: 值2, ...}

# 示例1：基本操作

# 创建字典
student = {
    "name": "Alice",
    "age": 20,
    "major": "Computer Science"
}

# 访问值
print(student["name"])  # 输出：Alice

# 添加新键值对
student["grade"] = "A"

# 修改已有值
student["age"] = 21

# 删除键值对
del student["major"]

# 遍历字典
for key, value in student.items():
    print(key, "->", value)

# 常用方法：

方法 作用
dict.get(key, 默认值) 获取值，不存在时返回默认
dict.keys() 返回所有键
dict.values() 返回所有值
dict.items() 返回键值对元组
in 判断键是否存在

# 示例2：get() 和判断键

score = {"Tom": 90, "Bob": 85}

print(score.get("Tom"))         # 输出：90
print(score.get("Alice", 0))    # Alice 不在字典里，输出：0

if "Bob" in score:
    print("Bob 在成绩单里")

# 二、集合（set）—— 不重复、无序的元素集合

# 概念：

set 是一个无重复、无序的数据容器，适合去重、集合运算（并集、交集、差集等）。

# 语法：

集合名 = {元素1, 元素2, ...}

# 示例3：基本操作

# 创建集合
colors = {"red", "green", "blue"}

# 添加元素
colors.add("yellow")

# 删除元素
colors.remove("red")

# 遍历集合
for color in colors:
    print(color)

# 常用集合运算：

a = {1, 2, 3}
b = {3, 4, 5}

print(a | b)  # 并集：{1, 2, 3, 4, 5}
print(a & b)  # 交集：{3}
print(a - b)  # 差集：{1, 2}
print(a ^ b)  # 对称差集（不重复的）：{1, 2, 4, 5}

# 示例4：列表去重

nums = [1, 2, 2, 3, 4, 4, 5]
unique_nums = list(set(nums))
print(unique_nums)  # 输出：[1, 2, 3, 4, 5]（顺序可能变）

# 总结对比

特性 dict set
结构 键值对（key: value） 单个元素（value）
是否唯一 键必须唯一 所有元素唯一
是否有顺序 Python 3.7+ 中保持插入顺序 无序
常见用途 快速查找、存储映射关系 去重、集合运算

第5天-函数