Python基础代码学习

（1）输入任意大的自然数，输出各位数字之和。

代码：

def sum_of_digits(n):         定义一个求各位数字之和的函数
    return sum(map(int, str(n)))    运用map函数将字符串中的每个字符转换为整数
# 从用户那里获取输入
n = input("请输入一个数字：")
print(sum_of_digits(int(n)))

示例：

请输入一个数字： 88

16

（2）输入两个集合setA和setB，分别输出它们的交集、并集和差集setA-setB。

代码：

A_set = []        此时A_set和B_set是列表
B_set = []
print("请输入A的数据，输入'结束'来结束输入：")
while True:    这个是个无限循环语句只用遇到break才会停止
    user_input = input()
    if user_input == '结束':   如果用户输入'结束'，则停止输入
        break
    A_set.append(user_input)   将用户输入的数据添加到列表中

print("请输入B的数据，输入'结束'来结束输入：")
while True:
    user_input = input()
    if user_input == '结束':  
        break
    B_set.append(user_input)  

将列表转换为集合才能用下面的运算符
setA = set(A_set)
setB = set(B_set)

# 计算交集
intersection = setA & setB
# 计算并集
union = setA | setB
# 计算差集
difference = setA - setB
print("交集:", intersection)
print("并集:", union)
print("差集 setA - setB:", difference)

示例：

请输入A的数据，输入'结束'来结束输入：

 5
 2
 3
 结束

请输入B的数据，输入'结束'来结束输入：

 5
 9
 1
 结束

交集: {'5'}
并集: {'1', '3', '9', '2', '5'}
差集 setA - setB: {'2', '3'}

（3）输入一个自然数，输出它的二进制、八进制、十六进制表示形式。

代码： 

number = int(input("请输入一个自然数："))

# 输出二进制表示
print(f"{number}的二进制表示为：{bin(number)[2:]}")      

bin(number)是把number转化为二进制，[2:]是切片操作，可以把二进制的前缀“0b”删除，以下代码同理

# 输出八进制表示
print(f"{number}的八进制表示为：{oct(number)[2:]}")

# 输出十六进制表示
print(f"{number}的十六进制表示为：{hex(number)[2:].upper()}")

其中f可以格式化字符串，可以在大括号 {} 中放入变量或表达式，它们会被自动转换为字符串并替换。

示例：

请输入一个自然数： 66

66的二进制表示为：1000010
66的八进制表示为：102
66的十六进制表示为：42

（4）输入一个包含若干整数的列表，输出一个新列表，要求新列表中只包含原列表中的偶数。

代码：

list_A=[]       建立原列表
list_B=[]       建立偶数列表
while True:
    user_input = input()
    if user_input == '结束':    如果用户输入'结束'，则停止输入
        break
    list_A.append(user_input) 
for i in list_A:    对A列表中的元素进行遍历，如果能被2整除就把它添加进B列表
    if int(i)%2==0:     其中int(i)的目的是为了保整i 是一个整数
     list_B.append(i)  
print("偶数列表", list_B)

示例：

 2
 3
 4
 5
 结束

偶数列表 ['2', '4']

（5）输入两个分别包含若干整数的列表lstA和lstB，输出一个字典，要求使用列表lstA中的元素作为键，列表lstB中的元素作为值，并且最终字典中的元素数量取决于lstA和lstB中元素最少的列表的数量。

代码：

lstA = []
lstB = []
while True:
    user_input = input("请输入列表A的一个元素（输入'结束'来结束输入）：")
    if user_input == '结束':  
        break
    lstA.append(user_input)

while True:
    user_input = input("请输入列表B的一个元素（输入'结束'来结束输入）：")
    if user_input == '结束':  
        break
    lstB.append(user_input)
result_dict = dict(zip(lstA, lstB))   

使用zip函数将两个列表合并，并转换为字典。字典dict为用zip函数配对的数据
print(result_dict)

示例：

请输入列表A的一个元素（输入'结束'来结束输入）： a
请输入列表A的一个元素（输入'结束'来结束输入）： b
请输入列表A的一个元素（输入'结束'来结束输入）： c
请输入列表A的一个元素（输入'结束'来结束输入）： 结束
请输入列表B的一个元素（输入'结束'来结束输入）： 1
请输入列表B的一个元素（输入'结束'来结束输入）： 2
请输入列表B的一个元素（输入'结束'来结束输入）： 3
请输入列表B的一个元素（输入'结束'来结束输入）： 结束

{'a': '1', 'b': '2', 'c': '3'}

（6）输入一个包含若干整数的列表，输出新列表，要求新列表中的所有元素来自于输入的列表，并且降序排列。

代码：

lstA = []
while True:
    user_input = input("请输入列表A的一个元素（输入'结束'来结束输入）：")
    if user_input == '结束':  
        break
    lstA.append(user_input)

print(sorted(lst, reverse=True))     

 sorted() 函数会返回一个新的列表，该列表包含原列表 lst 的所有元素，但是已经按照指定的顺序（这里是降序）排序。

注释：reverse=True 是一个布尔参数，通常用于列表（list）的 sort() 方法或内置函数 sorted() 中。这个参数的作用是指定排序的顺序：

当 reverse=True 时，列表的元素会被按照降序（从大到小）进行排序。

当 reverse=False 或省略此参数时（默认值），列表的元素会被按照升序（从小到大）进行排序。

示例：

请输入列表A的一个元素（输入'结束'来结束输入）： 1
请输入列表A的一个元素（输入'结束'来结束输入）： 2
请输入列表A的一个元素（输入'结束'来结束输入）： 3
请输入列表A的一个元素（输入'结束'来结束输入）： 4
请输入列表A的一个元素（输入'结束'来结束输入）： 结束

['4', '3', '2', '1']

（7）编写程序，输入一个包含若干整数的列表，输出列表中所有整数连乘的结果。

代码：

lstA = []
while True:
    user_input = input("请输入列表A的一个元素（输入'结束'来结束输入）：")
    if user_input == '结束':
        break
    lstA.append(int(user_input))    使用int()将lstA中的字符串变成整型以便后面的累乘运算
cj=1
for i in lstA:
   cj*=i
print(cj)

示例：

请输入列表A的一个元素（输入'结束'来结束输入）： 1
请输入列表A的一个元素（输入'结束'来结束输入）： 2
请输入列表A的一个元素（输入'结束'来结束输入）： 3
请输入列表A的一个元素（输入'结束'来结束输入）： 4
请输入列表A的一个元素（输入'结束'来结束输入）： 结束

24

（8）编写程序，输入两个各包含2个整数的列表，分别表示城市中两个地点的坐标，输出两点之间的曼哈顿距离。

对于二维空间中的两点(x1​,y1​)和(x2​,y2​)，曼哈顿距离D可以用以下公式计算：

                                       D=∣x1​−x2​∣+∣y1​−y2​∣

代码：

def manhattan_distance(coord1, coord2):
    return abs(coord1[0] - coord2[0]) + abs(coord1[1] - coord2[1])     

定义了一个求曼哈顿距离的函数

# 获取用户输入并转换为整数列表
location1 = list(map(int, input("请输入第一个地点的坐标（格式为'x y'）：").split())) 

 使用split()函数规定列表输入元素的分隔符是空格
location2 = list(map(int, input("请输入第二个地点的坐标（格式为'x y'）：").split()))

# 计算曼哈顿距离
distance = manhattan_distance(location1, location2)

# 输出结果
print(f"两个地点之间的曼哈顿距离是：{distance}")
示例：

请输入第一个地点的坐标（格式为'x y'）： 2 3
请输入第二个地点的坐标（格式为'x y'）： 8 1

两个地点之间的曼哈顿距离是：8

（9）编写程序，输入包含若干集合的列表，输出这些集合的并集。要求使用reduce()函数和lambda表达式完成

from functools import reduce       

从Python标准库中的functools模块中导入名为reduce的函数
sets_input = input("请输入包含若干集合的列表（例如：{{1, 2, 3}, {4, 5}, {6}}）：")      

提示用户输入集合列表形式
sets_list = eval(sets_input)   

 将输入的字符串转换为集合列表 使用eval函数可以安全地执行字符串形式的Python表达式
union_of_sets = reduce(lambda x, y: x | y, sets_list)   

使用reduce和lambda表达式来计算并集 reduce函数对序列中的元素从左到右进行累积操作。lambda表达式它接受两个参数 x 和 y，并返回它们的并集。reduce 函数将这个 lambda 函数应用于集合列表中的元素，从而实现累加效果。
print("输入的集合的并集是：", union_of_sets)

示例：

请输入包含若干集合的列表（例如：{{1, 2, 3}, {4, 5}, {6}}）： {2,3,4},{5,2},{5,4}

输入的集合的并集是： {2, 3, 4, 5}

（10）编写程序，输入等比数列的首项、公比（不等于1且小于36的正整数）和一个自然数n，输出这个数列前n项的和。关键步骤要求使用内置函数int()。

a1 = int(input('请输入等比数列首项：'))     int()将某个值变成整数
q = int(input('请输入等比数列公比（不等于1且小于36的正整数）：'))
n = int(input('请输入一个自然数：'))

# 验证公比是否符合要求
if q == 1 or q >= 36:
    print("公比不符合要求，请输入一个不等于1且小于36的正整数。")
else:
    # 使用正确的公式计算等比数列的前n项和
    result = a1 * (1 - q ** n) // (1 - q)
    print(f"等比数列的前{n}项和为：{result}")
示例：

请输入等比数列首项： 1
请输入等比数列公比（不等于1且小于36的正整数）： 2
请输入一个自然数： 5

等比数列的前5项和为：31

（11）编写程序，输入一个字符串，输出其中出现次数最多的字符及其出现的次数。要求使用字典。

data = input('请输入一个字符串：')
char_count = {}       初始化一个空字典 ，用于存储每个字符及其出现的次数。

for ch in data:
    char_count[ch] = char_count.get(ch, 0) + 1    

遍历输入的字符串 data，对于每个字符 ch，使用字典的 get 方法来获取该字符当前的计数（将 ch 键对应的值（如果存在的话）加 1，如果 ch 键不存在，则将 0 加 1。)

most_common_char, frequency = max(char_count.items(), key=lambda item: item[1])
print(f"出现次数最多的字符是：'{most_common_char}'，出现了 {frequency} 次。")

示例：

请输入一个字符串： jxdxsysybdx

出现次数最多的字符是：'x'，出现了 3 次。