30 questions pratiques sur Python qui valent la peine d'être collectées (avec des explications détaillées)

1. Étant donné qu'une chaîne est "hello_world_yoyo", comment obtenir une file d'attente ["hello","world","yoyo"] ?

Utilisez la fonction split pour diviser la chaîne et convertir les données en un type de liste :

test = 'hello_world_yoyo'
print(test.split("_"))
12

Résultat :

['hello', 'world', 'yoyo']

2 Il existe une liste ["hello", "world", "yoyo"], comment convertir. la concaténer les chaînes pour obtenir la chaîne "hello_world_yoyo" ?

Utilisez la fonction join pour convertir les données en chaîne :

test = ["hello", "world", "yoyo"]
print("_".join(test))

Résultat :

hello_world_yoyo

Si vous ne comptez pas sur la méthode de jointure fournie par python, vous pouvez également utiliser une boucle for puis épisser les chaînes, mais utilisez "+" pour connecter les chaînes Lors de l'utilisation de join, le résultat générera un nouvel objet. Lors de l'utilisation de join, le résultat concatène simplement les éléments de la liste d'origine, donc join est plus efficace.

La boucle for est épissée comme suit :

test = ["hello", "world", "yoyo"]
# 定义一个空字符串
j = ''
# 通过 for 循环打印出列表中的数据
for i in test:
 j = j + "_" + i
# 因为通过上面的字符串拼接，得到的数据是“_hello_world_yoyo”，前面会多一个下划线_，所以把这个下划线去掉
print(j.lstrip("_"))

3. Remplacez chaque espace de la chaîne s par "%20", entrée : s = "Nous sommes heureux.", sortie : "Nous%20are%20happy. ".

Utilisez la fonction de remplacement et remplacez les caractères :

s = 'We are happy.'
print(s.replace(' ', '%20'))
12

Résultat :

We%20are%20happy.

4 Comment imprimer la table de multiplication 99 en Python ?

pour l'impression en boucle :

for i in range(1, 10):
 for j in range(1, i+1):
 print('{}x{}={}t'.format(j, i, i*j), end='')
 print()

while implémentation de la boucle :

i = 1
while i <= 9:
 j = 1
 while j <= i:
 print("%d*%d=%-2d"%(i,j,i*j),end = ' ')# %d： 整数的占位符，'-2'代表靠左对齐，两个占位符
 j += 1
 print()
 i += 1

résultat :

1x1=1
1x2=2 2x2=4
1x3=3 2x3=6 3x3=9
1x4=4 2x4=8 3x4=12 4x4=16
1x5=5 2x5=10 3x5=15 4x5=20 5x5=25
1x6=6 2x6=12 3x6=18 4x6=24 5x6=30 6x6=36
1x7=7 2x7=14 3x7=21 4x7=28 5x7=35 6x7=42 7x7=49
1x8=8 2x8=16 3x8=24 4x8=32 5x8=40 6x8=48 7x8=56 8x8=64
1x9=9 2x9=18 3x9=27 4x9=36 5x9=45 6x9=54 7x9=63 8x9=72 9x9=81

5. Commencez l'indexation à partir de l'indice 0 et recherchez l'occurrence du mot "bienvenue" dans la chaîne "Bonjour, bienvenue dans mon monde". Si l'emplacement n'est pas trouvé, -1 est renvoyé.

def test():
 message = 'Hello, welcome to my world.'
 world = 'welcome'
 if world in message:
 return message.find(world)
 else:
 return -1
print(test())

Résultat :

7

6. Comptez le nombre de fois où la lettre w apparaît dans la chaîne "Bonjour, bienvenue dans mon monde".

def test():
 message = 'Hello, welcome to my world.'
 # 计数
 num = 0
 # for 循环 message
 for i in message:
 # 判断如果 ‘w’ 字符串在 message 中，则 num +1
 if 'w' in i:
 num += 1
 return num
print(test())
# 结果
2

7. Saisissez une chaîne str et affichez le m-ème caractère qui n'apparaît que n fois. Par exemple, dans la chaîne gbgkkdehh, recherchez le deuxième caractère qui n'apparaît qu'une seule fois et affichez le résultat : d

def test(str_test, num, counts):
 """
 :param str_test: 字符串
 :param num: 字符串出现的次数
 :param count: 字符串第几次出现的次数
 :return:
 """
 # 定义一个空数组，存放逻辑处理后的数据
 list = []
 # for循环字符串的数据
 for i in str_test:
 # 使用 count 函数，统计出所有字符串出现的次数
 count = str_test.count(i, 0, len(str_test))
 # 判断字符串出现的次数与设置的counts的次数相同，则将数据存放在list数组中
 if count == num:
 list.append(i)
 # 返回第n次出现的字符串
 return list[counts-1]
print(test('gbgkkdehh', 1, 2))
结果：
d

8 . si la chaîne a = "bienvenue dans mon monde" contient le mot b = "monde", si c'est le cas, elle renverra True, si ce n'est pas le cas, elle renverra False.

def test():
 message = 'welcome to my world'
 world = 'world'
 if world in message:
 return True
 return False
print(test())
结果：
True

9. Commencez à compter à partir de 0 et affichez la chaîne spécifiée

def test():
 message = 'hi how are you hello world, hello yoyo!'
 world = 'hello'
 return message.find(world)
print(test())
结果：
15

10. Commencez à compter à partir de 0 et affichez la chaîne spécifiée A = « bonjour » dans la chaîne B = « salut, comment vas-tu, bonjour tout le monde, bonjour yoyo ! » dernière position d'occurrence dans B, si B ne contient pas A, alors -1 est émis.

def test(string, str):
 # 定义 last_position 初始值为 -1
 last_position = -1
 while True:
 position = string.find(str, last_position+1)
 if position == -1:
 return last_position
 last_position = position
print(test('hi how are you hello world, hello yoyo!', 'hello'))
结果：
28

11. Étant donné un nombre a, déterminez si un nombre est un nombre impair ou pair.

while True:
 try:
 # 判断输入是否为整数
 num = int(input('输入一个整数：'))
 # 不是纯数字需要重新输入
except ValueError:
 print("输入的不是整数！")
 continue
 if num % 2 == 0:
 print('偶数')
 else:
 print('奇数')
 break
结果：
输入一个整数：100
偶数

12. Entrez un nom pour déterminer si le nom de famille est Wang.

def test():
 user_input = input("请输入您的姓名：")
 if user_input[0] == '王':
 return "用户姓王"
 return "用户不姓王"
print(test())
结果：
请输入您的姓名：王总
用户姓王

13. Comment déterminer si une chaîne est composée de nombres purs ?

Utilisez la conversion de type fournie par Python pour convertir les données saisies par l'utilisateur en un type de nombre à virgule flottante. Si la conversion génère une exception, il est jugé que le nombre n'est pas composé de nombres purs.

def test(num):
 try:
 return float(num)
 except ValueError:
 return "请输入数字"
print(test('133w3'))

14. Convertissez la chaîne a = « Ceci est un exemple de chaîne… .wow ! » en majuscules et convertissez la chaîne b = « Bienvenue dans mon monde » en minuscules.

a = 'This is string example….wow!'
b = 'Welcome To My World'
print(a.upper())
print(b.lower())

15. Supprimez les espaces de début et de fin de la chaîne a = "bienvenue dans mon monde"

Python fournit la méthode strip() pour supprimer les espaces de début et de fin, rstrip() supprime les espaces de fin, lstrip() supprime les espaces de début, replace( " ", "") supprime tous les espaces.

a = 'welcome to my world '
print(a.strip())

peut également être implémenté de manière récursive :

def trim(s):
 flag = 0
 if s[:1]==' ':
 s = s[1:]
 flag = 1
 if s[-1:] == ' ':
 s = s[:-1]
 flag = 1
 if flag==1:
 returntrim(s)
 else:
 return s
print(trim('Hello world!'))

implémenté via une boucle while :

def trim(s):
 while(True):
 flag = 0
 if s[:1]==' ':
 s = s[1:]
 flag = 1
 if s[-1:] == ' ':
 s = s[:-1]
 flag = 1
 if flag==0:
 break
 return s
print(trim('Hello world!'))

16. Convertissez la chaîne s = "ajldjlajfdljfddd", supprimez les doublons et triez de petit à grand pour afficher "adfjl".

def test():
 s = 'ajldjlajfdljfddd'
 # 定义一个数组存放数据
 str_list = []
 # for循环s字符串中的数据，然后将数据加入数组中
 for i in s:
 # 判断如果数组中已经存在这个字符串，则将字符串移除，加入新的字符串
 if i in str_list:
 str_list.remove(i)
 str_list.append(i)
 # 使用 sorted 方法，对字母进行排序
 a = sorted(str_list)
 # sorted方法返回的是一个列表，这边将列表数据转换成字符串
 return "".join(a)
print(test())
结果：
adfjl

17. Imprimez le motif suivant (losange) :

def test():
 n = 8
 for i in range(-int(n/2), int(n/2) + 1):
 print(" "*abs(i), "*"*abs(n-abs(i)*2))
print(test())
结果：
 **
****
 ******
********
 ******
****
 **

18 Étant donné un entier positif ne comportant pas plus de 5 chiffres (comme a = 12346), découvrez combien de chiffres il contient et imprimez-le. les chiffres dans l'ordre inverse.

class Test:
 # 计算数字的位数
 def test_num(self, num):
 try:
 # 定义一个 length 的变量，来计算数字的长度
 length = 0
 while num != 0:
 # 判断当 num 不为 0 的时候，则每次都除以10取整
 length += 1
 num = int(num) // 10
 if length > 5:
 return "请输入正确的数字"
 return length
 except ValueError:
 return "请输入正确的数字"
 # 逆序打印出个位数
 def test_sorted(self, num):
 if self.test_num(num) != "请输入正确的数字":
 # 逆序打印出数字
 sorted_num = num[::-1]
 # 返回逆序的个位数
 return sorted_num[-1]
print(Test().test_sorted('12346'))
结果：
1

19. Si un nombre à 3 chiffres est égal à la somme des cubes de ses chiffres, on l'appelle un nombre narcisse. Par exemple : 153 = 13 + 53 + 33, donc 153 est un nombre jonquille. Alors comment trouver le nombre de jonquilles dans la limite de 1000 (3 chiffres).

def test():
 for num in range(100, 1000):
 i = num // 100
 j = num // 10 % 10
 k = num % 10
 if i ** 3 + j ** 3 + k ** 3 == num:
 print(str(num) + "是水仙花数")
test()

20. Trouvez la somme de 1+2+3…+100.

i = 1
for j in range(101):
 i = j + i
print(i)
结果：
5051

21. Calculez la valeur de 1-2+3-4+5-…-100.

def test(sum_to):
 # 定义一个初始值
 sum_all = 0
 # 循环想要计算的数据
 for i in range(1, sum_to + 1):
 sum_all += i * (-1) ** (1 + i)
 return sum_all
if __name__ == '__main__':
 result = test(sum_to=100)
 print(result)
-50

22. La formule de calcul existante est 13 + 23 + 33 + 43 + …….+ n3 Comment l'implémenter : lorsque l'entrée n = 5, la sortie est 225 (formule correspondante : 13 + 23 + 33 + 43. + 53 = 225).

def test(n):
 sum = 0
 for i in range(1, n+1):
 sum += i*10+i
 return sum
print(test(5))
结果：
225

23. On sait que la valeur de a est "bonjour" et la valeur de b est "monde". Comment échanger les valeurs de a et b pour obtenir que la valeur de a soit "monde". " et la valeur de b est "bonjour" ?

a = 'hello'
b = 'world'
c = a
a = b
b = c
print(a, b)

24. Comment déterminer si un tableau est un tableau symétrique ?

Par exemple, [1, 2, 0, 2, 1], [1, 2, 3, 3, 2, 1], ces tableaux sont tous des tableaux symétriques. Utilisez Python pour juger s'il s'agit d'un tableau symétrique qui imprime True et non False.

def test():
 x = [1, 'a', 0, '2', 0, 'a', 1]
 # 通过下标的形式，将字符串逆序进行比对
 if x == x[::-1]:
 return True
 return False
print(test())
结果：
True

25. S'il existe une liste a = [1,3,5,7,11], alors comment l'inverser en [11,7,5,3,1] et obtenir le nombre impair de chiffres [1 ,5,11]?

def test():
 a = [1, 3, 5, 7, 11]
 # 逆序打印数组中的数据
 print(a[::-1])
 # 定义一个计数的变量
 count = 0
 for i in a:
 # 判断每循环列表中的一个数据，则计数器中会 +1
 count += 1
 # 如果计数器为奇数，则打印出来
 if count % 2 != 0:
 print(i)
test()
结果：
[11, 7, 5, 3, 1]
1
5
11

26. Triez les nombres de la liste a = [1, 6, 8, 11, 9, 1, 8, 6, 8, 7, 8] du petit au grand.

a = [1, 6, 8, 11, 9, 1, 8, 6, 8, 7, 8]
print(sorted(a))
结果：
[1, 1, 6, 6, 7, 8, 8, 8, 8, 9, 11]

27. Trouvez la valeur maximale et minimale dans la liste L1 = [1, 2, 3, 11, 2, 5, 3, 2, 5, 33, 88].

L1 = [1, 2, 3, 11, 2, 5, 3, 2, 5, 33, 88]
print(max(L1))
print(min(L1))
结果：
88
1

Ce qui précède est implémenté via les fonctions fournies avec Python, comme suit, vous pouvez écrire vous-même un programme de calcul :

class Test(object):
 def __init__(self):
 # 测试的列表数据
 self.L1 = [1, 2, 3, 11, 2, 5, 3, 2, 5, 33, 88]
 # 从列表中取第一个值，对于数据大小比对
 self.num = self.L1[0]
 def test_small_num(self, count):
 """
 :param count: count为 1，则表示计算最大值，为 2 时，表示最小值
 :return:
 """
 # for 循环查询列表中的数据
 for i in self.L1:
 if count == 1:
 # 循环判断当数组中的数据比初始值小，则将初始值替换
 if i > self.num:
 self.num = i
 elif count == 2:
 if i < self.num:
 self.num = i
 elif count != 1 or count != 2:
 return "请输入正确的数据"
 return self.num
print(Test().test_small_num(1))
print(Test().test_small_num(2))
结果：
88
1

28. 找出列表 a = [“hello”, “world”, “yoyo”, “congratulations”] 中单词最长的一个。

def test():
 a = ["hello", "world", "yoyo", "congratulations"]

 # 统计数组中第一个值的长度
 length = len(a[0])
 for i in a:
 # 循环数组中的数据，当数组中的数据比初始值length中的值长，则替换掉length的默认值
 if len(i) > length:
 length = i
 return length
print(test())
结果：
congratulations

29. 取出列表 L1 = [1, 2, 3, 11, 2, 5, 3, 2, 5, 33, 88] 中最大的三个值。

def test():
 L1 = [1, 2, 3, 11, 2, 5, 3, 2, 5, 33, 88]
 return sorted(L1)[:3]
print(test())
结果：
[1, 2, 2]

30. 把列表 a = [1, -6, 2, -5, 9, 4, 20, -3] 中的数字绝对值。

def test():
 a = [1, -6, 2, -5, 9, 4, 20, -3]
 # 定义一个数组，存放处理后的绝对值数据
 lists = []
 for i in a:
# 使用 abs() 方法处理绝对值
 lists.append(abs(i))
 return lists
print(test())
结果：
[1, 6, 2, 5, 9, 4, 20, 3]

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!