>>> author = 'piglei'
>>> print('Hello, {}!'.format(author))
Hello, piglei!

>>> author, reader = 'piglei', 'raymond'
>>> author, reader = reader, author (1)
>>> author
'raymond'

def remove_invalid(items):
    """剔除 items 里面无效的元素"""
    ... ...

def remove_invalid(items):
    """剔除 items 里面无效的元素

    :param items: 待剔除对象
    :type items: 包含整数的列表，[int, ...]
    """

from typing import List

def remove_invalid(items: List[int]):
    """剔除 items 里面无效的元素"""
    ... ...

data1 = process(data)
if data1 > data2:
    data2 = process_new(data1)
    data3 = data2
return process_v2(data3)

# 用户输入可能会有空格，使用 strip 去掉空格
username = extract_username(input_string.strip())

# 使用 strip() 去掉空格的好处：
# 1. 数据库保存时占用空间更小
# 2. 不用因为用户多打了一个空格而要求用户重新输入
username = extract_username(input_string.strip())

class Person:
    """人

    :param name: 姓名
    :param age: 年龄
    :param favorite_color: 最喜欢的颜色
    """

    def __init__(self, name, age, favorite_color):
        self.name = name
        self.age = age
        self.favorite_color = favorite_color

请用 Python 语言实现冒泡排序算法，把较大的数字放在后面。注意：默认所有的偶数都比奇数更大。

>>> numbers = [23, 32, 1, 3, 4, 19, 20, 2, 4]
>>> magic_bubble_sort(numbers)
[1, 3, 19, 23, 2, 4, 4, 20, 32]

def magic_bubble_sort(numbers):
    j = len(numbers) - 1
    while j > 0:
        for i in range(j):
            if numbers[i] % 2 == 0 and numbers[i + 1] % 2 == 1:
                numbers[i], numbers[i + 1] = numbers[i + 1], numbers[i]
                continue
            elif (numbers[i + 1] % 2 == numbers[i] % 2) and numbers[i] > numbers[i + 1]:
                numbers[i], numbers[i + 1] = numbers[i + 1], numbers[i]
                continue
        j -= 1
    return numbers

def foo():
    # users 本身是一个 Dict
    users = {'data': ['piglei', 'raymond']}
    ...
    # users 这个名字真不错！尝试复用它，把它变成 List 类型
    users = []
    ...

def foo():
    users = {'data': ['piglei', 'raymond']}
    ...
    # 使用一个新名字
    user_list = []
    ...

def generate_trip_png(trip):
    """
    根据旅途数据，生成 PNG 图片
    """
    # 预先定义好所有的局部变量
    waypoints = []
    photo_markers, text_markers = [], []
    marker_count = 0

    # 开始初始化 waypoint 数据
    waypoints.append(...)
    ...
    # 经过好几行代码后，开始处理 photo_markers、text_markers
    photo_markers.append(...)
    ...
    # 经过更多代码后，开始计算 marker_count
    marker_count += ...

    # 拼接图片：已省略...

def generate_trip_png(trip):
    """
    根据旅途数据，生成 PNG 图片
    """
    # 开始初始化 waypoint 数据
    waypoints = []
    waypoints.append(...)
    ...

    # 开始处理 photo_markers、text_markers
    photo_markers, text_markers = [], []
    photo_markers.append(...)
    ...

    # 开始计算 marker_count
    marker_count = 0
    marker_count += ...

    # 拼接图片：已省略...

# 为所有性别为女性，或者级别大于 3 的活跃用户发放 10000 个金币
if user.is_active and (user.sex == 'female' or user.level > 3):
    user.add_coins(10000)
    return

# 为所有性别为女性，或者级别大于 3 的活跃用户发放 10000 个金币
user_is_eligible = user.is_active and (user.sex == 'female' or user.level > 3):

if user_is_eligible:
    user.add_coins(10000)
    return

def import_users_from_file(fp):
    """尝试从文件对象读取用户，然后导入到数据库中

    :param fp: 可读文件对象
    :return: 成功与失败数量
    """
    # 初始化变量：重复用户、黑名单用户、正常用户
    duplicated_users, banned_users, normal_users = [], [], []
    for line in fp:
        parsed_user = parse_user(line)
        # ... 进行判断处理，修改上面定义的 {X}_users 变量

    succeeded_count, failed_count = 0, 0
    # ... 读取 {X}_users 变量，写入数据库并修改成功失败数量
    return succeeded_count, failed_count

class ImportedSummary:
    """保存导入结果摘要的数据类"""

    def __init__(self):
        self.succeeded_count = 0
        self.failed_count = 0

class ImportingUserGroup:
    """用于暂存用户导入处理的数据类"""

    def __init__(self):
        self.duplicated = []
        self.banned = []
        self.normal = []

def import_users_from_file(fp):
    """尝试从文件对象读取用户，然后导入到数据库中

    :param fp: 可读文件对象
    :return: 成功与失败数量
    """
    importing_user_group = ImportingUserGroup()
    for line in fp:
        parsed_user = parse_user(line)
        # ... 进行判断处理，修改上面定义的 importing_user_group 变量

    summary = ImportedSummary()
    # ... 读取 importing_user_group，写入数据库并修改成功失败数量
    return summary.succeeded_count, summary.failed_count

def get_best_trip_by_user_id(user_id):
    # 心理活动：“嗯，这个值未来说不定会修改/二次使用”，让我们先把它定义成变量吧！
    user = get_user(user_id)
    trip = get_best_trip(user_id)
    result = {
        'user': user,
        'trip': trip
    }
    return result

def get_best_trip_by_user_id(user_id):
    return {
        'user': get_user(user_id),
        'trip': get_best_trip(user_id)
    }

def foo():
    name = 'piglei'
    bar = 1
    print(locals())

# 调用 foo() 将输出：
{'name': 'piglei', 'bar': 1}

def render_trip_page(request, user_id, trip_id):
    """渲染旅程页面"""
    user = User.objects.get(id=user_id)
    trip = get_object_or_404(Trip, pk=trip_id)
    is_suggested = check_if_suggested(user, trip)
    return render(request, 'trip.html', {
        'user': user,
        'trip': trip,
        'is_suggested': is_suggested
    })

def render_trip_page(request, user_id, trip_id):
    ...

    # 利用 locals() 把当前所有变量作为模板渲染参数返回
    # 节约了三行代码，我简直是个天才！
    return render(request, 'trip.html', locals())

    return render(request, 'trip.html', {
        'user': user,
        'trip': trip,
        'is_suggested': is_suggested
    })

def magic_bubble_sort(numbers: List[int]):
    stop_position = len(numbers) - 1
    while stop_position > 0:
        for i in range(stop_position):
            current, next_ = numbers[i], numbers[i + 1]
            current_is_even, next_is_even = current % 2 == 0, next_ % 2 == 0
            should_swap = False
            if current_is_even and not next_is_even:
                should_swap = True
            elif current_is_even == next_is_even and current > next_:
                should_swap = True
            if should_swap:
                numbers[i], numbers[i + 1] = numbers[i + 1], numbers[i]
        stop_position -= 1
    return numbers

def magic_bubble_sort(numbers: List[int]):
    stop_position = len(numbers) - 1
    while stop_position > 0:
        for i in range(stop_position):
            previous, latter = numbers[i], numbers[i + 1]
            previous_is_even, latter_is_even = previous % 2 == 0, latter % 2 == 0
            should_swap = False

            if previous_is_even and not latter_is_even:
                should_swap = True
            elif previous_is_even == latter_is_even and previous > latter:
                should_swap = True

            if should_swap:
                numbers[i], numbers[i + 1] = numbers[i + 1], numbers[i]
        stop_position -= 1
    return numbers