import random
x = [random.randint(0,100) for _ in range(10)]
print("排序前的列表：", x)

even_x = x[::2]
even_x.sort()
x[::2] = even_x

print("排序后的列表：", x)

import random

• 作用：导入 Python 的随机数工具包

random.randint(0,100)：生成一个 0 到 100 之间的随机整数

for _ in range(10)：循环 10 次，生成 10 个随机数

• 把这 10 个数打包成一个列表，赋值给变量x

even_x = x[::2] （核心！）

• 作用：从列表x里，提取所有「偶数索引」的元素，存到even_x里

列表的索引是从0开始数的：x[0], x[1], x[2], x[3], ..., x[9]

0, 2, 4, 6, 8（0 是第一个数，2 是第三个数，以此类推）

even_x.sort()

• 作用：对even_x里的偶数索引元素，原地升序排序

sort()是列表的内置方法，直接修改原列表，不生成新列表，符合题目 “原地排序” 的要求

x[::2] = even_x

刚才提取了偶数索引的元素，排序后，再把它们按顺序放回原列表的偶数索引位置

• 比如原列表[12, 45, 3, 99, 67, 23, 88, 1, 55, 77]
• 排序后even_x = [3, 12, 55, 67, 88]

写回后，原列表变成：[3, 45, 12, 99, 55, 23, 67, 1, 88, 77]

---

nums = [2,7,11,15,1,8,3,6,4,0,2]
result = []  # 用来存答案的列表

# 双重循环：i 是第一个元素的下标，j 是第二个元素的下标
# range(len(nums)) 表示遍历所有下标
for i in range(len(nums)):
    for j in range(len(nums)):
        # 条件1：两数相加等于9
        # 条件2：i < j (保证只找一次，比如(0,9)和(9,0)算同一个，只存一次)
        if nums[i] + nums[j] == 9 and i < j:
            result.append((i, j))  # 把找到的组合做成元组，加进结果里

print(result)

for i in range(len(nums)):：外层循环，i 代表第一个元素的索引（从 0 数到 10）。

for j in range(len(nums)):：内层循环，j 代表第二个元素的索引

if nums[i] + nums[j] == 9 and i < j:：这是核心判断。i < j：非常重要！防止重复记录。比如 i=0, j=9 和 i=9, j=0 是同样的两个数，只记录一次

---

result.append((i, j))：如果满足条件，把 (i, j) 做成一个元组，添加到结果列表里。

# 1. 创建初始字典
info = {'Name': 'Rose', 'Age': 18, 'English': 97}

# (1) 输出所有的键
print("所有的键：", info.keys())

# (2) 添加元素 "Physics":98
info['Physics'] = 98
print("添加Physics后的字典：", info)

# (3) 删除键 'Age'
del info['Age']
print("删除Age后的字典：", info)

info 的字典，里面存了 3 个数据

keys() 是字典的一个功能，专门用来取出所有的 “键”。

info['Physics'] = 98

这是添加键值对的固定格式：字典名['新键'] = 新值。

del 是删除的意思，后面跟上 字典名['要删的键'] 就能删掉对应的键值对。

---

n = input("请输入一个自然数：")
is_palindrome = True

# 双指针法：从首尾同时遍历，对比对应位置的字符
for i in range(len(n) // 2):
    if n[i] != n[-(i+1)]:  # 对比第i个和倒数第i+1个字符
        is_palindrome = False
        break

print("是回文数" if is_palindrome else "不是回文数")

• 用两个 “指针”，一个从开头往后数，一个从末尾往前数
• 依次对比对应位置的字符，只要有一对不相等，就不是回文数
• 效率更高，只需要遍历一半的字符

我造了一个工具，叫 is_even，你给它一个数，它就能判断是不是偶数

 def  is_even(num)
    return num%1==0
print(is_even(2))
print(is_even(3))
print(is_even(0))

返回结果

True → 2 是偶数

False → 3 不是偶数

True → 0 是偶数

---

编写一个函数factorial（n）

该函数接受一个非整数n作为参数 返回该函数的阶乘如果输入为负数返回none

我要做一个算阶乘的工具，你给我一个数 n，我给你算它的阶乘。

def fractorial(n):
    if n < 0:    #r如果n<0负数没有阶乘返回None
        return None
    elif n == 0:   #如果n=0返回1因为0的阶乘为1
        return 1
    else:
        result = 1
        for i in range(1, n+1):   #否则如果是正常整数 就初始值=1 开始累乘
#每个结果都放到result里并且每次都会用result再去乘现在的数并刷新
#先准备一个初始1 再遍历，从1~n，range（1，n+1）
            result *= i
        return result  #把算好的阶乘返回
print(fractorial(5))  # 120
print(fractorial(3))  # 6
print(fractorial(0))  # 1
print(fractorial(-2)) # None

• 5 的阶乘 = 5×4×3×2×1 = 120
• 3 的阶乘 = 3×2×1 = 6
• 0 的阶乘 = 1（数学规定）

  ---

  ---

编写一个函数接收任意数量的数字作为参数 返回这些数字的和

# 定义函数：*numbers 表示可以接收任意多个数字
def add_numbers(*numbers):
    total = 0  # 先定义一个总和，初始是0
    
    # 循环遍历所有传进来的数字
    for num in numbers:
        total += num  # 把每个数字加到总和里
    
    return total  # 返回最终的和

 `*` 号 = **接收任意数量的参数** 

可以传 **1个、2个、10个、0个** 数字都行 

所有数字会被打包成一个**元组**

Python 自带 sum() 函数，代码能更短：
 

def add_numbers(*numbers):

          return sum(numbers)

---

---

---

写一个函数remove_spaces(s)该函数接收一个字符串s去除其中所有空格如果字符串中没有空格返回None

def remove_spaces(s):  # 1. 这里必须加冒号
    if ' ' not in s:   # 空格规范写法
        return None
    
    # 如果有空格
    new_s = s.replace(' ', '')  # 2. 修正拼写 replace
    return new_s

print(remove_spaces("hello world"))  # 输出：helloworld
print(remove_spaces("a b  c   d"))   # 输出：abcd
print(remove_spaces("python"))       # 输出：None

if ' ' not in s:判断：字符串里没有空格

s.replace(' ', '')把字符串里所有空格替换成空（也就是删掉）

---

自定义一个函数，求两个函数的最大值

def max_num(a, b):
    return a if a > b else b

---

自定义函数用lambda函数求两个数最小值

min_value = lambda x, y: x if x < y else y

print(min_value(5, 3))   # 3
print(min_value(2, 8))   # 2

定义阶乘函数计算n的阶乘

def jc(n):
    s=1
    for i in range(1,n+1):
        s*=i
    return s
print(jc(10))

s 是累乘结果

return s是把s结果返回给调用函数

如果不写return s 函数就执行完了 print（jc（10））会打印None

---