Calculer la longueur des mots dans une chaîne en utilisant Python

Trouver la longueur de mots individuels dans une chaîne d'entrée donnée à l'aide de Python est un problème qui doit être résolu. Nous souhaitons compter le nombre de caractères de chaque mot dans une saisie de texte et afficher les résultats dans un style structuré tel qu'une liste. La tâche nécessite de diviser la chaîne d'entrée et de séparer chaque mot. Calculez ensuite la longueur de chaque mot en fonction du nombre de caractères qu'il contient. L'objectif fondamental est de créer une fonction ou une procédure capable de recevoir efficacement des entrées, de déterminer la longueur des mots et de produire des résultats en temps opportun. Il est essentiel de résoudre ce problème dans diverses applications, notamment le traitement de texte, le traitement du langage naturel et l'analyse de données, où les statistiques sur la longueur des mots peuvent fournir des informations pertinentes et permettre une analyse supplémentaire.

Méthode à utiliser

• Utilisez les boucles et la fonction split()

• Utilisez la fonction map() avec len et split()

• Utilisez la méthode re.split() dans le module re

• Utilisez le dictionnaire pour stocker la longueur des mots

Utilisez les boucles et la fonction split()

Une technique de traitement et d'analyse de texte Python basique et simple consiste à obtenir la longueur du mot à l'aide d'une boucle et de la fonction split(). En utilisant cette technique pour décomposer la chaîne d'entrée en mots qui la composent, nous pouvons déterminer la longueur de chaque mot en vérifiant à plusieurs reprises la liste des mots. Dans cette méthode, la fonction split() est cruciale car elle symbolise essentiellement le texte saisi en fonction de caractères d'espacement, séparant ainsi les mots les uns des autres. La liste de mots résultante sert de base au reste de nos calculs de longueur de mots. Cette technique constitue une partie importante de tout ensemble d’outils d’analyse de texte car elle est efficace et simple pour comprendre et extraire des informations importantes à partir de la saisie de texte.

Algorithme

• Définissez une fonction findWordLengths qui prend la chaîne d'entrée comme paramètre.

• Utilisez la fonction split() pour diviser la chaîne d'entrée en mots individuels, en utilisant des espaces comme séparateurs pour les séparer. Stockez les résultats dans une liste appelée mots.

• Initialisez une liste vide "wordLengths" pour stocker la longueur des mots.

• Pour chaque mot de la liste de mots, procédez comme suit :

a. Utilisez la fonction len() pour calculer la longueur du mot actuel.

b. Ajoutez la longueur du mot actuel à la liste "wordLengths".

• Renvoyer la liste "wordLengths".

Exemple

def findWordLengths(input_string):
   words = input_string.split()
   wordLengths = []
   for word in words:
      wordLengths.append(len(word))
   return wordLengths


input_string = "Today feels like a productive day"
result = findWordLengths(input_string)
print("The words lengths are as:", result)

Sortie

The words lengths are as: [5, 5, 4, 1, 10, 3]

Utilisez la fonction map() avec len et split()

La méthode de détermination de la longueur des mots en Python combine la fonction map() avec len et split() pour fournir une réponse élégante et efficace au problème du travail avec des données texte. Cette approche exploite la puissance des fonctions intégrées de Python, qui peuvent être combinées pour déterminer rapidement la longueur de mots individuels dans une chaîne d'entrée. La méthode split() utilise des espaces comme délimiteurs, divisant efficacement la chaîne d'entrée en mots séparés, et constitue la base de cette stratégie. Le résultat a été la création d’une liste de termes qui a servi de base à une enquête plus approfondie. En utilisant la méthode map(), nous changeons cette liste en une liste itérable contenant les longueurs de tous les mots en appliquant la fonction len() à chaque mot.

Algorithme

• Définissez une fonction findWordLengths qui prend la chaîne d'entrée comme argument. Ce paramètre contiendra notre chaîne d'entrée.

• Utilisez la fonction split() pour diviser la chaîne d'entrée en mots individuels, en utilisant des espaces comme délimiteurs. Stockez les résultats dans une liste appelée mots.

• Utilisez la fonction map() pour appliquer la fonction len() à chaque mot de la liste de mots, car la fonction len() calcule principalement la longueur. Cela produira une itération contenant une seule longueur de mot.

• Convertissez l'itérable obtenu à partir de map() en une liste pour obtenir la longueur d'un seul mot.

• Renvoie une liste de longueurs de mots.

Exemple

def findWordLengths(input_string):
   words = input_string.split()
   wordLengths = list(map(len, words))
   return wordLengths


input_string = "Hello my name is Rahul"
result = findWordLengths(input_string)
print("The words lengths are as:", result)

Sortie

The words lengths are as: [5, 2, 4, 2, 5]

Utilisez la méthode re.split() dans le module re

Les expressions régulières sont un outil efficace pour la modification de texte et la correspondance de modèles. En détectant intelligemment les caractères d'espacement comme séparateurs de mots, la fonction re.split() peut servir de technique fiable pour étiqueter des phrases en mots dans ce cas. Pour diviser les mots avec précision, le modèle d'expression régulière r's+' correspond à une ou plusieurs lettres d'espacement consécutives. Cette méthode fonctionne très bien lors de la gestion de différents formats de texte d'entrée, autorise différents modèles d'espaces et fournit des calculs précis de la longueur des mots. Son utilisation d'expressions régulières le rend efficace même lors du traitement de grandes quantités de données d'entrée. De plus, le manque d'autres bibliothèques simplifie la mise en œuvre.

Algorithme

• Entrez des phrases contenant des mots.

• Divisez les phrases en mots à l'aide de la méthode re.split() et de l'expression régulière r's+'.

• Initialisez une liste vide pour stocker la longueur des mots.

• Parcourez chaque mot de la liste de mots :

• a. Calculez la longueur du mot actuel.

• b. Ajoute la longueur du mot à la liste de longueurs de mots.

• Liste de longueur de mots de sortie.

示例

import re

def word_lengths(sentence):
   
   words = re.split(r'\s+', sentence)
   
   word_lengths = []
   
   for word in words:
      length = len(word)
      word_lengths.append(length)
   
   return word_lengths

sentence = "This is a sample sentence"
result = word_lengths(sentence)
print(result)

输出

[4, 2, 1, 6, 8]

使用字典存储单词长度

使用字典保存单词长度来确定字符串中单词长度的方法将 Python 内置数据结构的有效性与简单的算法相结合，以提供有效且适应性强的结果。该技术通过使用 len() 函数迭代计算字典中每个单词的长度，为字典中的每个单词生成键值对。给出单词的长度作为匹配值，并将单词设置为键。由于这个清晰简单的过程，字长的收集是精确和有效的。

生成的词典提供每个单词对应的单词长度，捕获文本的广泛视图。为了进一步处理或分析数据，这种格式可以轻松检索字长。

算法

• 输入包含单词的句子。

• 使用 split() 方法将句子拆分为单词，这将为我们的输入字符串创建单词列表。

• 初始化一个空字典来存储单词长度。

• 迭代单词列表中的每个单词，如下所示：

• a。计算当前单词的长度。

• b。向字典中添加一个条目，以单词为键，以单词长度为值。

• 输出包含单词长度的字典。

示例

def word_lengths(sentence):

   words = sentence.split()
   word_lengths_dict = {}
   
   for word in words:
      length = len(word)
      word_lengths_dict[word] = length
   
   return word_lengths_dict

sentence = "This is how the length of words is calculated"
result = word_lengths(sentence)
print(result)

输出

{'This': 4, 'is': 2, 'how': 3, 'the': 3, 'length': 6, 'of': 2, 'words': 5, 'is': 2, 'calculated': 10}

结论

总而言之，我们研究了四种不同的 Python 方法来计算字符串中的单词长度。对于简单的工作，前两种方法（使用循环和 split() 函数或带有 len 和 split() 的 map() 函数）提供了简单性和有效性。第三个选项利用 re 模块中的 re.split() 方法，展示了正则表达式的强大功能，适合在复杂的文本处理应用程序中使用。最后但并非最不重要的一点是，使用字典来跟踪单词长度提供了一种系统且实用的方法来检索和处理单词数据。每种方法都具有特定的优点，使程序员能够根据特定需求和编码偏好选择最佳选项。

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!