python代码笔记02

import random
from functools import reduce

1、输入一个整数，以列表的形式输出每一位，并输出列表的和。

 number = int(input("请输入一个整数: "))
 numberList = list(map(int, str(number)))
 print("每一位组成的列表:", numberList)
 listSum = sum(numberList)
 print("列表的和:", listSum)

请输入一个整数: 233
每一位组成的列表: [2, 3, 3]
列表的和: 8

2、输入一个整数，输出对应的二进制、八进制、十六进制。

 scale = int(input("输入一个整数: "))
 print("转二进制：", bin(scale))
 print("转八进制:", oct(scale))
 print("转十六进制：", hex(scale))

请输入一个整数: 234
转二进制为： 0b11101010
转八进制为: 0o352
转十六进制为： 0xea

3、输入一些整数，以逗号分隔，计算并输出这些数的平均值。

 averageStr = input("请输入一些整数，以逗号分隔：")
 averageList = list(map(int, averageStr.split(',')))
 print("平均值为：", sum(averageList)/len(averageList))

请输入一些整数，以逗号分隔：12,12,34
平均值为： 19.333333333333332

4、以列表的形式输入一些整数，计算并输出这些数的平均值、最大值、最小值。

 from statistics import mean
 listStr = input("请输入列表[xOne,xTow,...]：")
 listNumber = eval(listStr)  eval像什么转什么，字符串转列表
 print("平均值", mean(listNumber))
 print("最大值", max(listNumber))
 print("最小值", min(listNumber))

请输入列表[xOne,xTow,…]：[11,22,33]
平均值 22
最大值 33
最小值 11

5、以列表的形式输入一些整数，降序输出。

 listStr = input("请输入列表[xOne,xTow,...]：")
 listNumber = eval(listStr)  eval像什么转什么，字符串转列表
 print(sorted(listNumber, reverse=True))
# reverse：一个布尔值，表示排序是降序还是升序。
# 默认为 False，表示升序排序；
# 如果为 True，则进行降序排序。

请输入列表[xOne,xTow,…]：[11,22,33,44,12,45,90,67] [90, 67, 45, 44,
33, 22, 12, 11]

6、编写程序，输入两个各包含2个实数的列表，分别表示点的坐标，计算两点间的欧式距离和曼哈顿距离。

 point1 =list(map(float, input("请输入第一个逗号分割的点坐标：").split(',')))
 point2 =list(map(float, input("请输入第二个逗号分割的点坐标：").split(',')))
 import math
 def euclidean_distance(point1, point2):   计算欧式距离
     xOne, y1 = point1
     xTow, y2 = point2
     return math.sqrt((xTow - xOne) ** 2 + (y2 - y1) ** 2)
 def manhattan_distance(point1, point2):  计算曼哈顿距离
     xOne, y1 = point1
     xTow, y2 = point2
     return abs(xTow - xOne) + abs(y2 - y1)
 euc_dist = euclidean_distance(point1, point2)
 man_dist = manhattan_distance(point1, point2)
 print(f"两点间的欧式距离为: {euc_dist:.2f}")
 print(f"两点间的曼哈顿距离为: {man_dist:.2f}")  注意格式化有大括号和f

请输入第一个逗号分割的点坐标：2,3
请输入第二个逗号分割的点坐标：4,5
两点间的欧式距离为: 2.83
两点间的曼哈顿距离为: 4.00

7、输入一个列表，如果列表全为真，输出True，否则输出False

 listStr = input("请输入列表[xOne,xTow,...]：")
 print(all(eval(listStr)))  eval像什么转什么，字符串转列表

请输入列表[xOne,xTow,…]：[1,2,3,4,5]
True

8、输入一个列表，如果列表中有一个为真，输出True,否则输出False

 listStr = input("请输入列表[xOne,xTow,...]：")
 print(any(eval(listStr)))  eval像什么转什么，字符串转列表

请输入列表[xOne,xTow,…]：[1,2,3,4,5,6]
True

9、输入一个整数，输出整数分离后的和。例如输入1234，输出10

 number = int(input("请输入一个整数: "))
 print("列表的和:", sum(list(map(int, str(number)))))

请输入一个整数: 234567
列表的和: 27

10、输入一个整数，输出分离后的整数，以逗号分隔。例如输入1234，输出：1,2,3,4

 number = int(input("请输入一个整数: "))
 print(','.join(str(number)))

请输入一个整数: 2023
2,0,2,3

11、编写一个函数，测试字符串是否包含列表中某个元素作为子串

 def text(s, lst):
     for element in lst:
         if element in s:
             return True
     return False
 s = "Hello, world!"   s里包含Hello
 lst = ["python", "Hello"]
 print(text(s, lst))

True

12、生成一个1到1e20的随机整数，对这个数进行分离，依次输出每位数，用逗号分隔。

 def randomFun():
     number = random.randint(0,9)
     return number
 number = randomFun()
 while number==0:
     number = randomFun()
 print(number)
 #-----------------以上为确保第一位不为0------------
 listOne =[random.randint(0, 9) for _ in range(19)]  #使用列表生成式生成19个0到9的随机整数
 print(listOne)
 print([number]+listOne) # []是让数值变为列表类型

1
[9, 7, 1, 2, 3, 6, 8, 9, 2, 5, 1, 8, 4, 5, 7, 5, 2, 1, 9]
[1, 9, 7, 1, 2, 3, 6, 8, 9, 2, 5, 1, 8, 4, 5, 7, 5, 2, 1, 9]

13、用列表生成式，随机生成20个0到100的整数，分别计算平均值、最大值、最小值。

 random_number = [random.randint(0, 100) for _ in range(20)]  使用列表生成式生成20个0到100的随机整数
 print("平均值:", sum(random_number) / len(random_number))
 print("最大值:", max(random_number))
 print("最小值:", min(random_number))

平均值: 45.7
最大值: 94
最小值: 1

14、用列表生成式，随机生成4x5的列表，即该列表有5个元素，每个元素是一个列表，列表含有4个元素。分别求最大的列表，和求和最大的列表，并输出。

 import random
 # 随机生成4x5的列表，每个子列表包含4个随机整数
 matrix = [[random.randint(0, 100) for _ in range(4)] for _ in range(5)]
 # 分别用于存储包含最大元素的子列表和元素和最大的子列表
 maxList = None
 maxSumList = None
  #用于存储最大元素值和最大元素和
 max_element_value = float('-inf')
 max_sum_value = float('-inf')
 for sublist in matrix:
      #计算当前子列表的元素和
     current_sum = sum(sublist)
     # 检查当前子列表是否包含最大元素
     if max(sublist) > max_element_value:
         max_element_value = max(sublist)
         maxList = sublist
         # 检查当前子列表的元素和是否最大
     if current_sum > max_sum_value:
         max_sum_value = current_sum
         maxSumList = sublist
 print("包含最大元素的子列表:", maxList)
 print("元素和最大的子列表:", maxSumList)

包含最大元素的子列表: [58, 97, 59, 77]
元素和最大的子列表: [58, 97, 59, 77]

15、任意输入3个英文单词，以空格分隔分隔，输出字符串长度最大的。

 words = input("请输入3个英文单词，以空格分隔：").split()
 if len(words) != 3:
     print("请输入3个单词！")
 else:
     maxLen = 0
     max_word = ""
     for word in words:
         if len(word) > maxLen:
             maxLen = len(word)
             max_word = word
     print("字符串长度最大的单词是：", max_word)

请输入3个英文单词，以空格分隔：hello world youzezhang
字符串长度最大的单词是： youzezhang

16、随机生成10个整数，分别按字符的字典顺序、按长度、转换为整数比较大小。 Key

 integers = [random.randint(1, 100) for _ in range(10)]
 strings = [str(i) for i in integers]
 print("按字符的字典顺序排序:", sorted(strings))
 print("按长度排序:", sorted(strings, key=len))
 print("按整数大小排序:", sorted(integers))

按字符的字典顺序排序: [‘30’, ‘36’, ‘46’, ‘47’, ‘52’, ‘63’, ‘64’, ‘64’, ‘74’, ‘84’]
按长度排序: [‘30’, ‘46’, ‘74’, ‘36’, ‘64’, ‘63’, ‘47’, ‘84’, ‘64’, ‘52’]
按整数大小排序: [30, 36, 46, 47, 52, 63, 64, 64, 74, 84]

17、随机生成两个长度为10列表，将两个列表对应位置的数相加；将两个列表对应位置的数相乘；
将两个列表对应位置的数相乘后得到的列表求和（向量内积）。

 integers1 = [random.randint(1, 10) for _ in range(10)]
 integers2 = [random.randint(1, 10) for _ in range(10)]
 print("列表1：", integers1)
 print("列表2：", integers2)
 listSun = [a + b for a, b in zip(integers1, integers2)]
 print("相加后的列表:", listSun)
 productLIst = [a * b for a, b in zip(integers1, integers2)]
 print("相乘后的列表:", productLIst)
 print("列表求和:", sum(productLIst))

列表1： [1, 9, 2, 4, 4, 3, 9, 10, 8, 4]
列表2： [5, 5, 7, 5, 10, 1, 1, 8, 6, 10]
相加后的列表: [6, 14, 9, 9, 14, 4, 10, 18, 14, 14]
相乘后的列表: [5, 45, 14, 20, 40, 3, 9, 80, 48, 40]
列表求和: 304

18、用range函数生成首项为1，公差为3，小于50的等差数列。用reduce函数求该数列的和。

 from functools import reduce
 numberList = range(1, 50, 3)
 numberSum = reduce(lambda x, y: x + y, numberList)
 print("等差数列:", list(numberList))
 print("数列和:", numberSum)

等差数列: [1, 4, 7, 10, 13, 16, 19, 22, 25, 28, 31, 34, 37, 40, 43, 46, 49]
数列和: 425

19、用range函数生成1到10的数字，计算这些数字的乘积。随机生成三个小于10的整数，计算这些数字的乘积。

 numberList = range(1, 11, 1)
 numberListTow = random.choices((range(1, 11, 1)), k=3)
 print("1到10的数字:", list(numberList))
 print("1-10的3个数字:", list(numberListTow))
 numberSum = reduce(lambda x, y: x * y, numberList)
 numberSumTow = reduce(lambda x, y: x * y, numberListTow)
 print("数字乘积:", numberSum)
 print("1-10的3个数字乘积:", numberSumTow)

1到10的数字: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
1-10的3个数字: [10, 6, 1]
数字乘积: 3628800
1-10的3个数字乘积: 60

20、随机生成200个在[0到100]的整数，并把奇数放到一个列表中，偶数放到另一个列表中，计算奇数和偶数的个数。

integers1 = [random.randint(1, 101) for _ in range(200)]
 odd_number = []
 even_number = []
 for number in integers1:
     if number % 2 == 0:
         even_number.append(number)
     else:
         odd_number.append(number)
 print("200个随机数：", integers1)
 print("奇数列表：", odd_number)
 print("偶数列表：", even_number)
 print("奇数个数：", len(odd_number))
 print("偶数个数：", len(even_number))
 
  #200个随机数： [42, 37, 100, 4, 13, 87, 46, 89, 61, 20, 7, 22, 84, 86, 9, 31, 20, 94, 40, 65, 93, 23, 22, 24, 71, 49, 67, 43, 48, 14, 72, 53, 31, 82, 17, 43, 7, 67, 15, 66, 45, 41, 6, 73, 9, 92, 80, 27, 39, 53, 10, 64, 11, 67, 67, 26, 60, 99, 72, 100, 86, 37, 99, 55, 45, 79, 32, 100, 97, 56, 47, 39, 29, 88, 14, 94, 32, 84, 52, 59, 86, 17, 41, 66, 61, 53, 45, 16, 35, 80, 10, 38, 67, 16, 72, 99, 85, 36, 70, 65, 23, 67, 101, 63, 33, 39, 77, 95, 61, 35, 38, 85, 71, 1, 29, 12, 96, 49, 29, 34, 53, 71, 8, 25, 80, 54, 87, 14, 2, 27, 63, 51, 36, 79, 5, 93, 43, 9, 57, 17, 15, 38, 22, 60, 88, 27, 92, 1, 52, 18, 85, 52, 93, 99, 75, 32, 15, 62, 30, 79, 53, 38, 45, 63, 1, 1, 96, 1, 13, 46, 81, 49, 82, 41, 95, 37, 2, 73, 13, 5, 65, 13, 73, 22, 39, 31, 41, 51, 90, 5, 30, 3, 93, 66, 69, 92, 22, 48, 65, 68]
  #奇数列表： [37, 13, 87, 89, 61, 7, 9, 31, 65, 93, 23, 71, 49, 67, 43, 53, 31, 17, 43, 7, 67, 15, 45, 41, 73, 9, 27, 39, 53, 11, 67, 67, 99, 37, 99, 55, 45, 79, 97, 47, 39, 29, 59, 17, 41, 61, 53, 45, 35, 67, 99, 85, 65, 23, 67, 101, 63, 33, 39, 77, 95, 61, 35, 85, 71, 1, 29, 49, 29, 53, 71, 25, 87, 27, 63, 51, 79, 5, 93, 43, 9, 57, 17, 15, 27, 1, 85, 93, 99, 75, 15, 79, 53, 45, 63, 1, 1, 1, 13, 81, 49, 41, 95, 37, 73, 13, 5, 65, 13, 73, 39, 31, 41, 51, 5, 3, 93, 69, 65]
  #偶数列表： [42, 100, 4, 46, 20, 22, 84, 86, 20, 94, 40, 22, 24, 48, 14, 72, 82, 66, 6, 92, 80, 10, 64, 26, 60, 72, 100, 86, 32, 100, 56, 88, 14, 94, 32, 84, 52, 86, 66, 16, 80, 10, 38, 16, 72, 36, 70, 38, 12, 96, 34, 8, 80, 54, 14, 2, 36, 38, 22, 60, 88, 92, 52, 18, 52, 32, 62, 30, 38, 96, 46, 82, 2, 22, 90, 30, 66, 92, 22, 48, 68]
  #奇数个数： 119
  #偶数个数： 81

21、随机生成两个长度为10列表，用zip函数把两个列表压缩。

 integers1 = [random.randint(1, 100) for _ in range(10)]
 print(list(integers1))
 integers2 = [random.randint(1, 100) for _ in range(10)]
 print(list(integers2))
 zip1 = zip(integers1, integers2)
 print(list(zip1))

[19, 49, 99, 62, 71, 41, 43, 4, 58, 85]
[49, 96, 38, 94, 42, 65, 61, 16, 36, 2]
[(19, 49), (49, 96), (99, 38), (62, 94), (71, 42), (41, 65), (43, 61), (4, 16), (58, 36), (85, 2)]

23、编写程序，输入一个正整数，然后输出各位数字之和。

 number = int(input("请输入一个正整数: "))
 if number > 0:
     print("列表的和:", sum(list(map(int, str(number)))))
 else:
     print("输入的不是正整数")

24、编写程序，输入一个字符串，输出翻转（首尾交换）后的字符串，要求使用内置函数来实现。例如，12345，输出54321

  s = input("请输入一个字符串: ")
  print("翻转后的字符串是: ", s[::-1])

请输入一个字符串: dwjefkelf
翻转后的字符串是: flekfejwd

25、编写程序，输入一个包含若干整数的列表，输出列表中，最大值。

number = input("请输入列表空格分隔: ").split( )
 max_number = max(list(map(int, number)))
 print(max_number)

26、编写程序，输入一个包含若干整数的列表，把列表中所有整数转换为字符串，然后输出包含这些字符串的列表。

listStr = eval(input("请输入列表[xOne,xTow,...]："))
print(list(map(str,listStr)))

27、编写程序，输入一个包含若干任意数据的列表，输出该列表中等价于True的元素组成的列表。例如，输入[1,2,0,[]]，输出[1,2]

 number = input("请输入任意数据类型的列表空格分隔: ").split( )
 listOne = [eval(number) for number in number]
 print(listOne)
 listTow = [item for item in listOne if item]  item被放入列表值  if item 求布尔
 print(listTow)

请输入任意数据类型的列表空格分隔: [] 0 8 9 90 6 8
[[], 0, 8, 9, 90, 6, 8]
[8, 9, 90, 6, 8]

28、编写程序，输入一个包含若干整数的列表，输出一个只包含奇数的新列表。

import math
 number = input("请输入列表空格分隔: ").split()
 number = list(map(int, number))
 oddNumber = [item for item in number if item % 2 == 1]
 print(oddNumber)

请输入列表空格分隔: 1 2 3 4 5 6
[1, 3, 5]

29、编写程序，输入一个包含若干整数的列表，输出一个只包含偶数的新列表。

 number = input("请输入列表空格分隔: ").split()
 number = list(map(int, number))
 evenNomber = [item for item in number if item % 2 == 0]
 print(evenNomber)

请输入列表空格分隔: 1 2 3 4 5 6
[2, 4, 6]

30、编写程序，输入一个包含若干整数的列表，输出一个一个新列表，列表中奇数在前前偶数在后，并且奇数之间的相对顺序不变，偶数之间的相对顺序也不变。

 number = input("请输入列表空格分隔: ").split()
 number = list(map(int, number))
 oddNumber = [item for item in number if item % 2 == 1]
 ouhsu = [item for item in number if item % 2 == 0]
 heb = oddNumber + ouhsu
 print(heb)

请输入列表空格分隔: 1 2 3 4 5 6 7 8 9
[1, 3, 5, 7, 9, 2, 4, 6, 8]

31、输入一个包含若干自然数的列表，输出这些自然数的平均值，结果保留3小数。

 number = input("请输入列表空格分隔: ").split()
 number = list(map(int, number))
 avg = round(sum(number)/len(number),3)
 print(avg)

请输入列表空格分隔: 1 2 3 4 5 4 3 2 1
2.778

32、输入一个包含若干自然数的列表，输出这些自然数降序排列后的新列表。

 number = input("请输入列表空格分隔: ").split()
 number = list(map(int, number))
 sort = sorted(number,reverse=True)
 print(sort)

请输入列表空格分隔: 54675678 33 21312 6786
[54675678, 21312, 6786, 33]

33、输入一个包含若干自然数的列表，输出一个新列表，新列表中每个元素为原列表中每个自然数的位数。

 number = input("请输入列表空格分隔: ").split()
 len_list = [len(item) for item in number]
 print(len_list)

请输入列表空格分隔: 23234 34 56 7 88 987
[5, 2, 2, 1, 2, 3]

34、输入一个包含若干数字的列表，输出其中绝对值最小的数字。

 number = input("请输入列表空格分隔: ").split()
 number = list(map(int, number))
 abs_list = [abs(item) for item in number]
 min_number = min(abs_list)
 print(min_number)

请输入列表空格分隔: 11 -11 2 3 -1 34
1

35、输入一个包含若干整数的列表，输出这些整数的乘积。

 number = input("请输入列表空格分隔: ").split()
 number = list(map(int, number))
 chen =1
 for number in number:
     chen *=number
 print(chen)

请输入列表空格分隔: 4 5 5
100

36、输入两个包含若干整数的等长列表，把这两个列表看作两个向量，输出这两个向量的内积。

 numberOne = list(map(int, (input("请输入列表空格分隔: ").split())))
 numberTow = list(map(int, (input("请输入列表空格分隔: ").split())))
 if len(numberOne) == len(numberTow):
     sum = sum(a * b for a, b in zip(numberOne, numberTow))
     print(sum)
 else:
     print("不等长")

请输入列表空格分隔: 1 2 3 4 5 6
请输入列表空格分隔: 6 5 4 3 2 1
56