Classes de début Impression d'une chaîne sur plusieurs lignes

Question

en python

Je prends des cours edx à la maison pour élargir mes compétences en programmation. Une des missions que j'ai rencontrées m'a bloqué. Le but est de pouvoir insérer un nombre entier et d'avoir une table de temps imprimée pour cela.

Cette table doit être divisée en colonnes et rangées. Je peux assembler les valeurs dont j'ai besoin dans une chaîne de caractères pour tous les nombres les uns par rapport aux autres en fonction de l'entrée variable. J'ai ajouté les onglets qui sont appelés entre les entiers.

Maintenant, cela est dans une chaîne et je ne peux pas l'obtenir à se rompre dans différents chutes de taille et imprimer en fonction de différentes valeurs entrées initialement.

J'ai essayé l'habillage de texte, mais j'ai eu des erreurs, peu importe comment je l'ai mis sur la base de différents exemples.

S'il vous plaît aidez-moi à trouver une solution et expliquer pourquoi cela fonctionne. J'essaie d'apprendre ceci ne pas avoir une ligne spoonfed de code qui résoudra le problème mais me laisse toujours ignorant. Aucun des indices trouvés dans le slack de cette classe ne contenait des termes ou des commandes listés dans le cours jusqu'à présent. Les lots qui n'étaient pas répertoriés cependant.

Voici ce que j'ai et s'il vous plaît ignorer les suppléments laissés par l'essai de différentes solutions.

mystery_int = 5 

#You may modify the lines of code above, but don't move them! 
#When you Submit your code, we'll change these lines to 
#assign different values to the variables. 

#This is a tough one! Stick with it, you can do it! 
# 
#Write a program that will print the times table for the 
#value given by mystery_int. The times table should print a 
#two-column table of the products of every combination of 
#two numbers from 1 through mystery_int. Separate consecutive 
#numbers with either spaces or tabs, whichever you prefer. 
# 
#For example, if mystery_int is 5, this could print: 
# 
#1 2 3 4 5 
#2 4 6 8 10 
#3 6 9 12 15 
#4 8 12 16 20 
#5 10 15 20 25 
# 
#To do this, you'll want to use two nested for loops; the 
#first one will print rows, and the second will print columns 
#within each row. 
# 
#Hint: How can you print the numbers across the row without 
#starting a new line each time? With what you know now, you 
#could build the string for the row, but only print it once 
#you've finished the row. There are other ways, but that's 
#how to do it using only what we've covered so far. 
# 
#Hint 2: To insert a tab into a string, use the character 
#sequence "\t". For example, "1\t2" will print as "1 2". 
# 
#Hint 3: Need to just start a new line without printing 
#anything else? Just call print() with no arguments in the 
#parentheses. 
# 
#Hint 4: If you're stuck, try first just printing out all 
#the products in one flat list, each on its own line. Once 
#that's working, then worry about how to organize it into 
#a table. 


#Add your code here! 
import textwrap 
a = mystery_int 
b = 1 
c = 0 
d = 1 
e = "" 
f = "" 
g = "" 
h = "\t" 
j = 1 
k = a*2 

for b in range(1,a + 1): 
    for c in range(1,a+1): 
     d = b * c 
     e +=str(d)+"," 
     f = str(e) 

g = str.replace(f,"," ,"\t") 

#textwrap.wrap(g,10) 
#print(g[0:int(k)]) 
print(g[:k]) 

Answer 1

Vous êtes, il vous suffit presque là pour recueillir les valeurs de chaque ligne dans une liste, puis les valeurs de ligne d'impression après chaque itération de la boucle interne. Étant donné que vous avez déjà une solution complète, à part quelques petits bugs, je vais vous fournir une explication complète de la solution.

Notation: Nous allons utiliser mystery_int au lieu de a, et nous allons changer b (incrément de boucle externe) à i et c (incrément de boucle interne) à j, conformément à la convention:

mystery_int = 5 

for i in range(1, mystery_int+1): 
    row = [str(i)] 
    for j in range(2, mystery_int+1): 
     row = row + [str(i*j)] 
    print('\t'.join(row)) 

sortie:

1 2 3 4 5 
2 4 6 8 10 
3 6 9 12 15 
4 8 12 16 20 
5 10 15 20 25 

les itère boucle externe (i) sur les rangées, et la boucle intérieure (j) sur des colonnes.
A chaque nouvelle ligne, nous voulons une nouvelle liste, row, qui commence avec un seul élément. Ce premier élément est le nombre dont nous allons faire des multiples (donc le premier élément de la ligne 1 est 1, le premier élément de la ligne 2 est 2, et ainsi de suite).

Notez que nous convertissons tous nos entiers en chaînes (i ->str(i)), car nous voulons éventuellement imprimer chaque ligne comme une séquence séparée par des espaces.

• Chaque fois que vous imprimez avec des espaces, même si le contenu que vous souhaitez imprimer est composé de chiffres, vous devez convertir ce contenu en une représentation sous forme de chaîne. (Vous l'avez déjà fait dans votre code, mais il vaut la peine de le réitérer, car c'est un point d'achoppement commun.)

Or, dans la boucle intérieure (j), calculer le produit de chaque colonne après la première (i*2, i*3, ..., i*mystery_int). Pour chaque passage sur la boucle interne, ajoutez le nouveau produit à row. Au moment où nous finissons la boucle interne, nous aurons une liste complète des séries de multiplication pour la ligne commençant par le nombre entier i.

A ce stade, avant de passer à la ligne suivante, imprimez la ligne en cours. La méthode join() est un moyen courant de connecter des éléments dans une liste, en utilisant le séparateur spécifié avant le ..

• Par exemple, ' '.join(row) va créer une chaîne de valeurs séparées par l'espace monopasse:

  ' '.join(["1","2","3","4","5"]) 
  # '1 2 3 4 5' 
  

• J'ai choisi d'utiliser des chaînes séparées par des tabulations, comme la sortie imprimée est plus agréable formatage. (Étant donné que certaines lignes ont des nombres à deux chiffres et d'autres ont seulement des nombres à un seul chiffre, un séparateur unique espace rend les colonnes apparaissent mal alignées.)

Notes:

• D'un point de vue pédagogique , il semble plus intuitif d'initialiser chaque nouveau row avec l'entier "base" i: row = [str(i)]. Cela fournit un ancrage visuel pour le reste des calculs de lignes qui suivent, à l'intérieur de la boucle interne. Cependant, il est également valide (et peut-être un peu plus « propre ») pour initialiser simplement une liste vide, row = [], puis commencer la boucle intérieure avec j = 1:

  for i in range(1, mystery_int+1): 
      row = [] 
      for j in range(1, mystery_int+1): 
       row = row + [str(i*j)] 
      print('\t'.join(row)) 
  

• Avec des modules supplémentaires, il est possible d'atteindre le même objectifs avec un code plus simple et souvent plus rapide. Il semble que vous travaillez avec la bibliothèque standard de Python, c'est pourquoi j'ai gardé les bases de la solution principale. Mais étant donné que d'une table de multiplication est vraiment le produit externe de deux vecteurs identiques, on peut également utiliser le module Numpy, qui fournit beaucoup d'opérations mathématiques rapides:

  import numpy as np 
  print(np.array2string(np.outer(np.arange(1, mystery_int+1), 
             np.arange(1, mystery_int+1)), 
           separator='\t')) 
  

Point étant, comme vous commencez à utiliser Python plus pour accomplir une tâche donnée, plutôt que d'apprendre simplement les bases de la programmation, il est raisonnable de supposer qu'il existe un module adapté à vos besoins, qui peut être un véritable gain de temps. Il y a un module Python pour just about everything!