Python prend en charge les boucles et sa syntaxe est légèrement différente des autres langages (comme JavaScript ou Java). Le bloc de code suivant montre comment utiliser une boucle for en Python pour parcourir les éléments d'une liste :
L'extrait de code ci-dessus imprime trois lettres sur des lignes séparées. Vous pouvez limiter la sortie à la même ligne en ajoutant une virgule "," après l'instruction print (s'il y a plusieurs caractères spécifiés à imprimer, ils seront "retour à la ligne"), le code est le suivant :
Quand vous le souhaitez La forme de code ci-dessus peut être utilisée lors de l'affichage du contenu du texte sur une seule ligne au lieu de plusieurs lignes. Python fournit également la fonction intégrée reverse(), qui peut inverser le sens de la boucle, par exemple :
Notez que cela ne peut être inversé que lorsque la taille de l'objet est déterminée ou que l'objet implémente la méthode _reversed_(). Seule la fonction de parcours directionnel est valide.
StringToNums.py dans le listing 1 illustre comment additionner un ensemble d'entiers convertis à partir de chaînes.
<ol><pre class="brush:sql;toolbar:false;">line = '1 2 3 4 10e abc'
sum = 0
invalidStr = ""
print('String of numbers:',line)
for str in line.split(" "):
try:
sum = sum + eval(str)
except:
invalidStr = invalidStr + str + ' '
print('sum:', sum)
if(invalidStr != ""):
print('Invalid strings:',invalidStr)
else:
print('All substrings are valid numbers')
Listing 1 initialise d'abord les variables line, sum et invalidStr, puis affiche le contenu de la ligne. Ensuite, le contenu de la ligne est divisé en mots, puis les valeurs des mots sont accumulées une par une dans la somme variable via le bloc de code try. Si une exception se produit, le contenu de la chaîne actuelle est ajouté à la variable invalidStr.
Lorsque l'exécution de la boucle se termine, le listing 1 imprime la somme des mots numériques et affiche les mots non numériques après. Sa sortie ressemble à ceci :
Nth_exponet.py dans le listing 2 illustre comment calculer la puissance d'un ensemble d'entiers.
<ol ><pre class="brush:sql;toolbar:false;">maxPower = 4
maxCount = 4
def pwr(num):
prod = 1
for n in range(1,maxPower+1):
prod = prod*num
print(num,'to the power',n, 'equals',prod)
print('-----------')
for num in range(1,maxCount+1):
pwr(num)
Listing 2 a une fonction pwr() dont le paramètre est une valeur numérique. La boucle de cette fonction peut imprimer le paramètre élevé à la puissance 1 à n. La valeur de n va de 1 à maxCount+1.
La deuxième partie du code appelle la fonction pwr() de 1 à maxCount+1 via une boucle for. Sa sortie ressemble à ceci :
La liste 3 de Triangular1.py illustre comment imprimer une ligne d'entiers consécutifs (en commençant à 1) où chaque ligne est plus longue que la ligne 1 précédente.
<ol ><pre class="brush:sql;toolbar:false;">max = 8
for x in range(1,max+1):
for y in range(1,x+1):
print(y,'', end='')
print()
Listing 3 initialise d'abord la variable max à 8, puis exécute une boucle à travers la variable x de 1 à max+1. La boucle interne a une variable de boucle y avec une valeur de 1 à x+1 et imprime la valeur de y. Son résultat est le suivant :
Python prend en charge une variété de fonctions pratiques liées aux opérations sur les chaînes, y compris la fonction split() et la fonction join(). La fonction split() est utile lorsque vous devez tokeniser (c'est-à-dire « diviser ») une ligne de texte en mots, puis utiliser une boucle for pour parcourir les mots.
La fonction join() est à l'opposé de la fonction split(), elle "joint" deux mots ou plus en une seule ligne. Vous pouvez facilement supprimer les espaces supplémentaires dans une phrase en utilisant la fonction split(), puis en appelant la fonction join() afin qu'il n'y ait qu'un seul espace entre chaque mot dans la ligne de texte.
Compare2.py dans le listing 4 illustre comment comparer chaque mot d'une chaîne de texte avec un autre mot via la fonction split().
<ol ><pre class="brush:sql;toolbar:false;">x = 'This is a string that contains abc and Abc'
y = 'abc'
identical = 0
casematch = 0
for w in x.split():
if(w == y):
identical = identical + 1
elif (w.lower() == y.lower()):
casematch = casematch + 1
if(identical > 0):
print('found identical matches:', identical)
if(casematch > 0):
print('found case matches:', casematch)
if(casematch == 0 and identical == 0):
print('no matches found')
Listing 4 Comparez chaque mot de la chaîne x avec le mot abc via la fonction split(). Si les mots correspondent exactement, la variable identique est incrémentée de 1 ; sinon, une comparaison insensible à la casse est tentée, et s'il y a une correspondance, la variable casematch est incrémentée.
Le résultat du listing 4 ressemble à ceci :
清单5 的FixedColumnCount1.py 说明了如何打印一组设定固定宽度的字符串。
<ol ><pre class="brush:sql;toolbar:false;">import string
wordCount = 0
str1 = 'this is a string with a set of words in it'
print('Left-justified strings:')
print('-----------------------')
for w in str1.split():
print('%-10s' % w)
wordCount = wordCount + 1
if(wordCount % 2 == 0):
print("")
print("n")
print('Right-justified strings:')
print('------------------------')
wordCount = 0
for w in str1.split():
print('%10s' % w)
wordCount = wordCount + 1
if(wordCount % 2 == 0):
print()
清单5 首先初始化变量wordCount和str1，然后执行两个for循环。第一个for循环对str1的每个单词进行左对齐打印，第二个for循环对str1的每个单词进行右对齐打印。在每个循环中当wordCount是偶数的时候就输出一次换行，这样每打印两个连续的单词之后就换行。清单5的输出如下所示：
清单6 的FixedColumnWidth1.py说明了如何打印固定宽度的文本。
<ol ><pre class="brush:sql;toolbar:false;">import string
left = 0
right = 0
columnWidth = 8
str1 = 'this is a string with a set of words in it and it will be split into a fixed column width'
strLen = len(str1)
print('Left-justified column:')
print('----------------------')
rowCount = int(strLen/columnWidth)
for i in range(0,rowCount):
left = i*columnWidth
right = (i+1)*columnWidth-1
word = str1[left:right]
print("%-10s" % word)
# check for a 'partial row'
if(rowCount*columnWidth < strLen):
left = rowCount*columnWidth-1;
right = strLen
word = str1[left:right]
print("%-10s" % word)
清单6初始化整型变量columnWidth和字符串类型变量str1。变量strLen是str1的长度，变量rowCount是strLen除以columnWidth的值。之后通过循环打印rowCount行，每行包含columnWidth个字符。代码的最后部分输出所有“剩余”的字符。清单6的输出如下所示：
清单7 的CompareStrings1.py说明了如何判断一个文本字符串中的单词是否出现在另一个文本字符串中。
<ol ><pre class="brush:sql;toolbar:false;">text1 = 'a b c d'
text2 = 'a b c e d'
if(text2.find(text1) >= 0):
print('text1 is a substring of text2')
else:
print('text1 is not a substring of text2')
subStr = True
for w in text1.split():
if(text2.find(w) == -1):
subStr = False
break
if(subStr == True):
print('Every word in text1 is a word in text2')
else:
print('Not every word in text1 is a word in text2')
清单7 首先初始化两个字符串变量text1和text2，然后通过条件逻辑判断字符串text2是否包含了text1(并输出相应打印信息)。
清单7的后半部分通过一个循环遍历字符串text1中的每个单词，并判断其是否出现在text2中。如果发现有匹配失败的情况，就设置变量subStr为False，并通过break语句跳出循环，提前终止for循环的执行。最后根据变量subStr的值打印对应的信息。清单7的输出如下所示：
清单8 的StringChars1.py说明了如何打印一个文本字符串中的字符。
<ol ><pre class="brush:sql;toolbar:false;">text = 'abcdef'
for ch in text:
print('char:',ch,'ord value:',ord(ch))
print
清单8 的代码简单直接地通过一个for循环遍历字符串text并打印它的每个字符以及字符的ord值(ASCII 码)。清单8 的输出如下所示：
另一个去掉多余空格的方法是使用join()函数，代码示例如下所示：
split()函数将一个文本字符串“分割”为一系列的单词，同时去掉多余的空格。接下来join()函数使用一个空格作为分隔符将字符串text1中的单词连接在一起。上述代码的最后部分使用字符串XYZ替换空格作为分隔符，执行相同的连接操作。上述代码的输出如下：
关于作者：奥斯瓦尔德·坎佩萨托(OswaldCampesato)，专门研究深度学习、Java、Android和TensorFlow。他是25本书的作者/合著者。
本文摘编自《机器学习入门：Python语言实现》，经出版方授权发布。(ISBN：9787111695240)
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!
![[Web front-end] Démarrage rapide de Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
