编写一个Python自定义函数，用 对列表seq = [3,9,1,4,7,6,5,8,2]中的元素进行排序，观察形参和实参的变化情况。 双重循环

在Python中，我们可以创建一个自定义函数来对列表中的元素进行排序。这里我们使用双重循环结合冒泡排序算法来演示如何处理形参和实参的变化。假设我们的函数名为`bubble_sort_list`，接受一个列表作为参数：

def bubble_sort_list(seq):
    # 初始的形参值
    n = len(seq)
    for i in range(n):
        for j in range(0, n-i-1):  # 冒泡排序，内部循环从0到n-i-1，每次减少一个已排序部分
            if seq[j] > seq[j+1]:  # 如果当前元素大于下一个元素，则交换它们
                seq[j], seq[j+1] = seq[j+1], seq[j]
    
    return seq

# 实际调用并打印结果
seq = [3,9,1,4,7,6,5,8,2]
sorted_seq = bubble_sort_list(seq)
print("原始列表:", seq)
print("排序后的列表:", sorted_seq)

# 现在改变列表内容，再次调用函数观察结果
seq = [5, 2, 8, 1, 9, 3, 6, 7, 4]
sorted_seq = bubble_sort_list(seq)
print("\n更改后的列表:", seq)
print("排序后的列表 (更改后):", sorted_seq)

相关问题

编写程序，利用元组作为函数的返回值，求序列类型中的最大值，最小值和元素个数，并测试编写代码，s1=9，7，8，3，2，1，55，6，s2=apple,pear,melon,kiwi,s3=TheQuickBrownFox不使用max，min函数

当需要在Python中获取列表或其他序列类型的最值和元素个数时，我们可以自定义函数来完成这个任务。对于数值序列，可以使用内置的比较操作来找到最大值和最小值，而对于非数值序列，我们需要分别处理每个元素并记录结果。下面是一个例子，首先定义一个通用的`analyze_sequence`函数，然后分别处理三个不同的输入序列`s1`, `s2`, 和 `s3`。

def analyze_sequence(seq):
    # 获取元素个数
    element_count = len(seq)

    # 数值类型的序列寻找最值
    if all(isinstance(i, (int, float)) for i in seq):
        max_value = max(seq)
        min_value = min(seq)
    else:
        # 非数值类型的序列，遍历找到最大字符和最小字符（这里是字符串）
        max_value = max(seq, key=len) if isinstance(seq[0], str) else None
        min_value = min(seq, key=len) if isinstance(seq[0], str) else None

    return max_value, min_value, element_count


# 测试用例
s1 = [9, 7, 8, 3, 2, 1, 55, 6]
s2 = ['apple', 'pear', 'melon', 'kiwi']
s3 = "TheQuickBrownFox"

result_s1 = analyze_sequence(s1)
result_s2 = analyze_sequence(s2)
result_s3 = analyze_sequence(s3)

print(f"Sequence s1: Max={result_s1[0]}, Min={result_s1[1]}, Count={result_s1[2]}")
print(f"Sequence s2: Max={result_s2[0]}, Min={result_s2[1]}, Count={result_s2[2]}")
print(f"Sequence s3: Max={result_s3[0]}, Min={result_s3[1]}, Count={result_s3[2]}")

编写程序，实现一个自定义函数，计算两个序列中任意两点距离的最小值和最大值，以及距离最近和最远的两对点在点列中的序号。用自己的学号和学号反序的各位分别作为点的横坐标和纵坐标构造点列

好的，你可以使用以下代码来实现该自定义函数：

import math

def calculate_distances(seq1, seq2):
    points = [(int(str(seq1[i]) + str(seq1[::-1][i])), int(str(seq2[i]) + str(seq2[::-1][i]))) for i in range(len(seq1))]
    min_dist = math.inf
    max_dist = 0
    min_dist_points = ()
    max_dist_points = ()

    for i in range(len(points) - 1):
        for j in range(i + 1, len(points)):
            dist = math.sqrt((points[i][0] - points[j][0])**2 + (points[i][1] - points[j][1])**2)
            if dist < min_dist:
                min_dist = dist
                min_dist_points = (i, j)
            if dist > max_dist:
                max_dist = dist
                max_dist_points = (i, j)

    return min_dist, max_dist, min_dist_points, max_dist_points

这个函数接受两个序列 `seq1` 和 `seq2`，其中 `seq1` 是你的学号，`seq2` 是你学号反序的各位。它将构造一个点列，每个点的横坐标是 `seq1[i]` 和 `seq1[::-1][i]` 的组合，纵坐标是 `seq2[i]` 和 `seq2[::-1][i]` 的组合。然后，它会计算任意两点之间的距离，找到最小值和最大值，并返回距离最近和最远的两对点在点列中的序号。

你可以使用以下代码来测试该函数：

seq1 = [1, 2, 3]  # 你的学号
seq2 = [3, 2, 1]  # 你学号反序的各位

min_dist, max_dist, min_dist_points, max_dist_points = calculate_distances(seq1, seq2)
print("最小距离:", min_dist)
print("最大距离:", max_dist)
print("距离最近的两对点序号:", min_dist_points)
print("距离最远的两对点序号:", max_dist_points)

请将 `seq1` 和 `seq2` 替换为你的学号和学号反序的各位，然后运行代码即可得到最小距离、最大距离以及距离最近和最远的两对点在点列中的序号。