Python学习之基础篇

目录

[1. list 和 tuple](#1. list 和 tuple)

[2. 条件判断之match case](#2. 条件判断之match case)

[3. dict和set](#3. dict和set)

[4. 函数](#4. 函数)

[a. 函数调用](#a. 函数调用)

[b. 定义函数](#b. 定义函数)

[ⅰ. python交互环境：](#ⅰ. python交互环境：)

[ⅱ. 空函数：](#ⅱ. 空函数：)

[ⅲ. 函数返回值：](#ⅲ. 函数返回值：)

[ⅳ. 可变参数：](#ⅳ. 可变参数：)

[ⅴ. 关键字参数：](#ⅴ. 关键字参数：)

[ⅵ. 命名关键字参数：](#ⅵ. 命名关键字参数：)

[ⅶ. 参数组合：](#ⅶ. 参数组合：)

[c. 递归函数](#c. 递归函数)

1. list 和 tuple

|--------------|------------------------------|----------------------------|
| 特性 | List | Tuple |
| **可变性** | 可变 (Mutable) | 不可变 (Immutable) |
| **语法** | 方括号 `[]` | 圆括号 `()` |
| **性能** | 较慢，占用更多内存 | 较快，占用更少内存 |
| **适用场景** | 动态数据集合 | 静态数据集合 |
| **内置方法** | 丰富（如 `append`, `remove`） | 较少（如 `count`, `index`） |
| **安全性** | 较低，易被修改 | 较高，不可被修改 |

2. 条件判断之match case

match-case 是 Python 3.10 引入的结构化条件判断语法，用于替代复杂的 if-elif-else 结构，提升代码的简洁性和可读性。以下是其语法精炼总结：

1. 基本结构：

match 被匹配对象:
    case 条件1:
        执行代码块1
    case 条件2:
        执行代码块2
    ...
    case _:
        默认执行代码块

1. 主要特点：

• • 简洁性：减少冗长的条件判断。
  • 模式匹配：支持复杂结构如元组、列表、字典等。
  • 通配符 ：_ 用于匹配任何情况，通常作为默认处理。

1. 使用场景：

• • 处理枚举类型、状态机或解析数据结构时更高效。
  • 提供更直观的代码结构，特别是在处理多种条件时。

1. 示例：

value = 2
match value:
    case 1:
        print("One")
    case 2:
        print("Two")
    case _:
        print("Other")

point = (1, 2)
match point:
    case (0, 0):
        print("Origin")
    case (x, 0):
        print(f"On x-axis at {x}")
    case (0, y):
        print(f"On y-axis at {y}")
    case (x, y):
        print(f"At point ({x}, {y})")

通过 match-case，代码可以更清晰地表达条件逻辑，减少冗余，提升维护性和可读性。

3. dict和set

**dict 和 set 的特点**

1. **dict（字典）**

• 键值对存储，键必须是不可变类型且唯一，值可以重复。

• 无序（Python 3.7+ 中保持插入顺序）。

• 查找、插入、删除操作时间复杂度为 O(1)。

2. **set（集合）**

• 存储唯一元素，自动去重。

• 无序。

• 支持集合运算（交集、并集、差集等）。

• 查找、插入、删除操作时间复杂度为 O(1)。

---

### **总结**

• **dict 和 set**：基于哈希表实现，适合快速查找和去重，但不保证顺序。

• **list 和 tuple**：基于数组实现，支持顺序存储，但查找效率较低；list 可变，tuple 不可变。

|--------------|---------------|---------|-----------|-----------|
| 特性 | dict | set | list | tuple |
| **数据结构** | 键值对 | 唯一元素集合 | 元素序列 | 元素序列 |
| **是否有序** | 无序（3.7+ 插入有序） | 无序 | 有序 | 有序 |
| **是否可变** | 可变 | 可变 | 可变 | 不可变 |
| **查找效率** | O(1) | O(1) | O(n) | O(n) |
| **元素限制** | 键必须唯一且不可变 | 元素唯一 | 元素可重复 | 元素可重复 |
| **适用场景** | 快速查找、映射关系 | 去重、集合运算 | 数据存储、顺序操作 | 数据固定、安全传递 |

4. 函数

a. 函数调用

数据类型转换：

Python内置的常用函数还包括数据类型转换函数，比如int()函数可以把其他数据类型转换为整数；

函数名其实就是指向一个函数对象的引用，完全可以把函数名赋给一个变量，相当于给这个函数起了一个"别名"：

>>> a = abs # 变量a指向abs函数
>>> a(-1) # 所以也可以通过a调用abs函数
1

b. 定义函数

ⅰ. python交互环境：

ⅱ. 空函数：

如果想定义一个什么事也不做的空函数，可以用pass语句：

def nop():
    pass

pass语句什么都不做，那有什么用？实际上pass可以用来作为占位符，比如现在还没想好怎么写函数的代码，就可以先放一个pass，让代码能运行起来。

pass还可以用在其他语句里，比如：

if age >= 18:
    pass

缺少了pass，代码运行就会有语法错误。

ⅲ. 函数返回值：

函数可以返回多个值。对于多个返回值，其实是返回一个tuple，但是，在语法上，返回一个tuple可以省略括号，而多个变量可以同时接收一个tuple，按位置赋给对应的值，所以，Python的函数返回多值其实就是返回一个tuple，但写起来更方便。

import math

def move(x, y, step, angle=0):
    nx = x + step * math.cos(angle)
    ny = y - step * math.sin(angle)
    return nx, ny

>>> x, y = move(100, 100, 60, math.pi / 6)
>>> print(x, y)
151.96152422706632 70.0

>>> r = move(100, 100, 60, math.pi / 6)
>>> print(r)
(151.96152422706632, 70.0)

ⅳ. 可变参数：

python函数允许传入可变参数，也就是传入的参数个数是可变的：

• 可以利用list或者tuple传入

def calc(numbers):
    sum = 0
    for n in numbers:
        sum = sum + n * n
    return sum

但是调用的时候，需要先组装出一个list或tuple：

>>> calc([1, 2, 3])
14
>>> calc((1, 3, 5, 7))
84

• 也可以把参数变为可变参数（参数前面加*号）

def calc(*numbers):
    sum = 0
    for n in numbers:
        sum = sum + n * n
    return sum

如果利用可变参数，调用函数的方式可以简化成这样：

>>> calc(1, 2, 3)
14
>>> calc(1, 3, 5, 7)
84

如果已经有一个list或者tuple，要调用一个可变参数怎么办？可以这样做：

>>> nums = [1, 2, 3]
>>> calc(nums[0], nums[1], nums[2])
14

这种写法当然是可行的，问题是太繁琐，所以Python允许你在list或tuple前面加一个*号，把list或tuple的元素变成可变参数传进去：

>>> nums = [1, 2, 3]
>>> calc(*nums)
14

*nums表示把nums这个list的所有元素作为可变参数传进去。这种写法相当有用，而且很常见。

ⅴ. 关键字参数：

可变参数允许你传入0个或任意个参数，这些可变参数在函数调用时自动组装为一个tuple。而关键字参数允许你传入0个或任意个含参数名的参数，这些关键字参数在函数内部自动组装为一个dict

def person(name, age, **kw):
    print('name:', name, 'age:', age, 'other:', kw)

>>> person('Bob', 35, city='Beijing')
name: Bob age: 35 other: {'city': 'Beijing'}
>>> person('Adam', 45, gender='M', job='Engineer')
name: Adam age: 45 other: {'gender': 'M', 'job': 'Engineer'}

关键字参数有什么用？它可以扩展函数的功能。比如，在person函数里，我们保证能接收到name和age这两个参数，但是，如果调用者愿意提供更多的参数，我们也能收到。试想你正在做一个用户注册的功能，除了用户名和年龄是必填项外，其他都是可选项，利用关键字参数来定义这个函数就能满足注册的需求。

和可变参数类似，也可以先组装出一个dict，然后，把该dict转换为关键字参数传进去：

>>> extra = {'city': 'Beijing', 'job': 'Engineer'}
>>> person('Jack', 24, city=extra['city'], job=extra['job'])
name: Jack age: 24 other: {'city': 'Beijing', 'job': 'Engineer'}

当然，上面复杂的调用可以用简化的写法：

>>> extra = {'city': 'Beijing', 'job': 'Engineer'}
>>> person('Jack', 24, **extra)
name: Jack age: 24 other: {'city': 'Beijing', 'job': 'Engineer'}

**extra表示把extra这个dict的所有key-value用关键字参数传入到函数的**kw参数，kw将获得一个dict，注意kw获得的dict是extra的一份拷贝，对kw的改动不会影响到函数外的extra。

ⅵ. 命名关键字参数：

为了限制关键字参数的名字，使用命名关键字参数

例如，只接收city和job作为关键字参数。这种方式定义的函数如下：

def person(name, age, *, city, job):
    print(name, age, city, job)

和关键字参数**kw不同，命名关键字参数需要一个特殊分隔符*，*后面的参数被视为命名关键字参数。

调用方式如下：

>>> person('Jack', 24, city='Beijing', job='Engineer')
Jack 24 Beijing Engineer

如果函数定义中已经有了一个可变参数，后面跟着的命名关键字参数就不再需要一个特殊分隔符*了：

def person(name, age, *args, city, job):
    print(name, age, args, city, job)

命名关键字参数必须传入参数名，位置参数不需要

>>> person('Jack', 24, 'Beijing', 'Engineer')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: person() missing 2 required keyword-only arguments: 'city' and 'job'

由于调用时缺少参数名city和job，Python解释器把前两个参数视为位置参数，后两个参数传给*args，但缺少命名关键字参数导致报错。

命名关键字参数可以有缺省值，从而简化调用：

def person(name, age, *, city='Beijing', job):
    print(name, age, city, job)

由于命名关键字参数city具有默认值，调用时，可不传入city参数：

>>> person('Jack', 24, job='Engineer')
Jack 24 Beijing Engineer

使用命名关键字参数时，要特别注意，如果没有可变参数，就必须加一个*作为特殊分隔符。如果缺少*，Python解释器将无法识别位置参数和命名关键字参数：

def person(name, age, city, job):
    # 缺少 *，city和job被视为位置参数
    pass

ⅶ. 参数组合：

在Python中定义函数，可以用必选参数、默认参数、可变参数、关键字参数和命名关键字参数，这5种参数都可以组合使用。但是请注意，参数定义的顺序必须是：必选参数、默认参数、可变参数、命名关键字参数和关键字参数。

c. 递归函数

类似于C++等编程语言。函数调用自身