Comment étendre l'affichage de sortie pour voir plus de colonnes d'un DataFrame pandas?

624

Existe-t-il un moyen d'élargir l'affichage de la sortie en mode interactif ou en exécution de script?

Plus précisément, j'utilise la describe()fonction sur un pandas DataFrame. Lorsque la DataFramelargeur est de 5 colonnes (étiquettes), j'obtiens les statistiques descriptives que je veux. Cependant, si le DataFramea plus de colonnes, les statistiques sont supprimées et quelque chose comme ceci est retourné:

>> Index: 8 entries, count to max  
>> Data columns:  
>> x1          8  non-null values  
>> x2          8  non-null values  
>> x3          8  non-null values  
>> x4          8  non-null values  
>> x5          8  non-null values  
>> x6          8  non-null values  
>> x7          8  non-null values  

La valeur "8" est indiquée s'il y a 6 ou 7 colonnes. À quoi fait référence le «8»?

J'ai déjà essayé de faire glisser la fenêtre IDLE plus grande, ainsi que d'augmenter les options de largeur "Configurer IDLE", en vain.

Mon but en utilisant des pandas et describe()est d'éviter d'utiliser un deuxième programme comme Stata pour faire des manipulations et des enquêtes de base sur les données.

betteraves
la source

Réponses:

890

Mise à jour: Pandas 0.23.4 en avant

Ce n'est pas nécessaire, pandas détecte automatiquement la taille de la fenêtre de votre terminal si vous la définissez pd.options.display.width = 0. (Pour les anciennes versions, voir en bas.)

pandas.set_printoptions(...)est obsolète. Au lieu de cela, utilisez pandas.set_option(optname, val)ou de manière équivalente pd.options.<opt.hierarchical.name> = val. Comme:

import pandas as pd
pd.set_option('display.max_rows', 500)
pd.set_option('display.max_columns', 500)
pd.set_option('display.width', 1000)

Voici l' aide pourset_option :

set_option (pat, value) - Définit la valeur de l'option spécifiée

Options disponibles:
affichage. [chop_threshold, colheader_justify, column_space, date_dayfirst,
         date_yearfirst, encodage, expand_frame_repr, float_format, height,
         line_width, max_columns, max_colwidth, max_info_columns, max_info_rows,
         max_rows, max_seq_items, mpl_style, multi_sparse, notebook_repr_html,
         pprint_nest_depth, précision, largeur]
mode. [sim_interactive, use_inf_as_null]

Paramètres
----------
pat - str / regexp qui doit correspondre à une seule option.

Remarque: les correspondances partielles sont prises en charge pour plus de commodité, mais à moins que vous n'utilisiez le
nom complet de l'option (egxyzoption_name), votre code risque de se casser à l'avenir
versions si de nouvelles options avec des noms similaires sont introduites.

valeur - nouvelle valeur d'option.

Retour
-------
Aucun

Augmente
------
KeyError si aucune telle option n'existe

display.chop_threshold: [par défaut: aucun] [actuellement: aucun]
: float ou None
        s'il est défini sur une valeur flottante, toutes les valeurs flottantes sont plus petites que le seuil donné
        sera affiché comme exactement 0 par repr et amis.
display.colheader_justify: [par défaut: droite] [actuellement: droite]
: 'gauche droite'
        Contrôle la justification des en-têtes de colonne. utilisé par DataFrameFormatter.
display.column_space: [par défaut: 12] [actuellement: 12] Aucune description disponible.

display.date_dayfirst: [par défaut: False] [actuellement: False]
: booléen
        Lorsque la valeur est True, imprime et analyse les dates avec le premier jour, par exemple 20/01/2005
display.date_yearfirst: [par défaut: False] [actuellement: False]
: booléen
        Lorsque la valeur est True, imprime et analyse les dates avec l'année en premier, par exemple 2005/01/20
display.encoding: [par défaut: UTF-8] [actuellement: UTF-8]
: str / unicode
        Par défaut, le codage détecté de la console.
        Spécifie l'encodage à utiliser pour les chaînes renvoyées par to_string,
        ce sont généralement des chaînes destinées à être affichées sur la console.
display.expand_frame_repr: [par défaut: True] [actuellement: True]
: booléen
        Que ce soit pour imprimer la reproduction complète de DataFrame pour de larges DataFrames
        sur plusieurs lignes, `max_columns` est toujours respecté, mais la sortie
        boucler sur plusieurs "pages" si sa largeur dépasse "display.width".
display.float_format: [par défaut: aucun] [actuellement: aucun]
: appelable
        L'appelable doit accepter un nombre à virgule flottante et retourner
        une chaîne avec le format souhaité du nombre. Ceci est utilisé
        dans certains endroits comme SeriesFormatter.
        Voir core.format.EngFormatter pour un exemple.
display.height: [par défaut: 60] [actuellement: 1000]
: int
        Obsolète.
        (Obsolète, utilisez plutôt `display.height`.)

display.line_width: [par défaut: 80] [actuellement: 1000]
: int
        Obsolète.
        (Obsolète, utilisez plutôt `display.width`.)

display.max_columns: [par défaut: 20] [actuellement: 500]
: int
        max_rows et max_columns sont utilisés dans les méthodes __repr __ () pour décider si
        to_string () ou info () est utilisé pour restituer un objet à une chaîne. Au cas où
        python / IPython s'exécute dans un terminal, cela peut être défini sur 0 et pandas
        détectera correctement la largeur du terminal et passera à un plus petit
        format au cas où toutes les colonnes ne tiendraient pas verticalement. Le bloc-notes IPython,
        IPython qtconsole ou IDLE ne s'exécutent pas dans un terminal et, par conséquent, il n'est pas
        possible de faire une auto-détection correcte.
        La valeur «Aucun» signifie illimité.
display.max_colwidth: [par défaut: 50] [actuellement: 50]
: int
        La largeur maximale en caractères d'une colonne dans la représentation de
        une structure de données pandas. Lorsque la colonne déborde, un "..."
        l'espace réservé est incorporé dans la sortie.
display.max_info_columns: [par défaut: 100] [actuellement: 100]
: int
        max_info_columns est utilisé dans la méthode DataFrame.info pour décider si
        les informations par colonne seront imprimées.
display.max_info_rows: [par défaut: 1690785] [actuellement: 1690785]
: int ou Aucun
        max_info_rows est le nombre maximum de lignes pour lesquelles un cadre sera
        effectuer une vérification nulle sur ses colonnes lors de la représentation vers une console.
        La valeur par défaut est 1 000 000 de lignes. Donc, si un DataFrame a plus
        1 000 000 de lignes, aucune vérification nulle ne sera effectuée
        colonnes et donc la représentation prendra beaucoup moins de temps pour
        afficher dans une session interactive. Une valeur de None signifie toujours
        effectuer une vérification nulle lors de la réimpression.
display.max_rows: [par défaut: 60] [actuellement: 500]
: int
        Ceci définit le nombre maximum de lignes que les pandas doivent produire lors de l'impression
        sur diverses sorties. Par exemple, cette valeur détermine si le repr ()
        pour une trame de données imprime entièrement ou simplement un résumé.
        La valeur «Aucun» signifie illimité.
display.max_seq_items: [par défaut: aucun] [actuellement: aucun]
: int ou Aucun

        lors de l'impression d'une longue séquence, pas plus que `max_seq_items`
        sera imprimé. Si des articles sont omis, ils seront signalés par l'addition
        de "..." à la chaîne résultante.

        S'il est défini sur Aucun, le nombre d'éléments à imprimer est illimité.
display.mpl_style: [par défaut: aucun] [actuellement: aucun]
: bool

        La définition de cette valeur par défaut modifiera les rcParams utilisés par matplotlib
        pour donner aux tracés un style visuel plus agréable par défaut.
        La définition de None / False restaure les valeurs à leur valeur initiale.
display.multi_sparse: [par défaut: True] [actuellement: True]
: booléen
        Affichage MultiIndex "sparsify" (ne pas afficher répété
        éléments dans les niveaux externes au sein des groupes)
display.notebook_repr_html: [par défaut: True] [actuellement: True]
: booléen
        Lorsque True, le bloc-notes IPython utilisera une représentation html pour
        objets pandas (si disponibles).
display.pprint_nest_depth: [par défaut: 3] [actuellement: 3]
: int
        Contrôle le nombre de niveaux imbriqués à traiter lors d'une jolie impression
display.precision: [par défaut: 7] [actuellement: 7]
: int
        Précision de sortie en virgule flottante (nombre de chiffres significatifs). C'est
        seulement une suggestion
display.width: [par défaut: 80] [actuellement: 1000]
: int
        Largeur de l'affichage en caractères. Dans le cas où python / IPython s'exécute dans
        un terminal, celui-ci peut être réglé sur Aucun et les pandas détecteront correctement
        largeur.
        Notez que le bloc-notes IPython, IPython qtconsole ou IDLE ne s'exécutent pas dans un
        terminal et il n'est donc pas possible de détecter correctement la largeur.
mode.sim_interactive: [par défaut: False] [actuellement: False]
: booléen
        S'il faut simuler le mode interactif à des fins de test
mode.use_inf_as_null: [par défaut: False] [actuellement: False]
: booléen
        True signifie traiter None, NaN, INF, -INF comme null (ancienne méthode),
        Faux signifie aucun et NaN sont nuls, mais INF, -INF ne sont pas nuls
        (nouvelle façon).
Appelez def: pd.set_option (self, * args, ** kwds)

EDIT: informations sur les anciennes versions, une grande partie de ces informations a été dépréciée.

Comme @bmu l'a mentionné , pandas détecte automatiquement (par défaut) la taille de la zone d'affichage, une vue récapitulative sera utilisée lorsqu'un objet représenté ne tient pas sur l'écran. Vous avez mentionné le redimensionnement de la fenêtre IDLE, sans effet. Si vous le faites, print df.describe().to_string()cela tient-il dans la fenêtre IDLE?

La taille du terminal est déterminée par pandas.util.terminal.get_terminal_size()(obsolète et supprimée), ce qui renvoie un tuple contenant (width, height)l'affichage. La sortie correspond-elle à la taille de votre fenêtre IDLE? Il pourrait y avoir un problème (il y en avait un avant lors de l'exécution d'un terminal dans emacs).

Notez qu'il est possible de contourner la détection automatique, pandas.set_printoptions(max_rows=200, max_columns=10)ne basculera jamais en vue récapitulative si le nombre de lignes, les colonnes ne dépassent pas les limites données.


L'option 'max_colwidth' aide à voir la forme non tronquée de chaque colonne.

TruncatedColumnDisplay

Wouter Overmeire
la source
4
display.height: obsolète, utilisez display.heightplutôt ... Je suis en boucle morte.
Frozen Flame
5
De nos jours, les options peuvent également être définies comme des affectations aux attributs depd.options , par exemplepd.options.display.max_rows = 999
unutbu
2
La propriété 'display.height' est obsolète.
Greg M. Krsak
2
N'a pas fonctionné pour moi dans Pandas 0.23.2.
devinbost
6
Vous voudrez peut-être utiliser l' option_context pour que les changements d'options soient locaux par rapport à la chose avec laquelle vous travaillez. Cela évite d'imprimer accidentellement 400 pages de courrier indésirable lors de votre prochain appel .head()ou autre.
Mike Williamson
195

Essaye ça:

pd.set_option('display.expand_frame_repr', False)

De la documentation:

display.expand_frame_repr: booléen

Que ce soit pour imprimer la représentation complète de DataFrame pour des DataFrames larges sur plusieurs lignes, max_columns est toujours respecté, mais la sortie sera bouclée sur plusieurs «pages» si sa largeur dépasse display.width. [par défaut: True] [actuellement: True]

Voir: http://pandas.pydata.org/pandas-docs/stable/generated/pandas.set_option.html

Robert Rose
la source
6
Celui-ci fonctionne pour moi. Il semble que pandas calcule mal la largeur de sortie pour une raison quelconque et casse les colonnes inutilement.
zbyszek
5
Je dois littéralement le faire tous les jours ... Y a-t-il un moyen de régler cela quelque part à l'échelle mondiale?
citynorman
1
@citynorman voir pandas\core\config_init.pypour le définir définitivement.
Jarad
106

Si vous souhaitez définir temporairement des options pour afficher un grand DataFrame, vous pouvez utiliser option_context :

with pd.option_context('display.max_rows', None, 'display.max_columns', None):
    print (df)

Les valeurs des options sont restaurées automatiquement lorsque vous quittez le withbloc.

jezrael
la source
3
Afin de ne fixer aucune limite, Nonepeut être utilisé (au lieu de 999, etc.).
Eric O Lebigot
5
with pd.option_context('display.max_rows', None, 'display.max_columns', None): print(energy)n'a pas fonctionné. Cela n'a pas changé le nombre de colonnes que je voulais voir. Cependant, la solution de Wouter Overmeiere a fonctionné.
Aziz Javed
Mais il y a une différence, il faut un certain nombre comme -1ou 500non.
jezrael
2
Utiliser -1 plante et 500 n'a rien fait non plus
Aziz Javed
1
+1 pour suggérer un gestionnaire de contexte, mais -1 pour la max_rowsvaleur;). La définition 'display.max_rows'de -1 semble perturber complètement le formatage (pour mes données, pas de plantage, mais il imprime certaines lignes plusieurs fois maintenant).
bluenote10
88

Seule l'utilisation de ces 3 lignes a fonctionné pour moi:

pd.set_option('display.max_columns', None)  
pd.set_option('display.expand_frame_repr', False)
pd.set_option('max_colwidth', -1)

Anaconda / Python 3.6.5 / pandas: 0.23.0 / Visual Studio Code 1.26

arispen
la source
54

Définissez la largeur maximale de la colonne à l'aide de:

pd.set_option('max_colwidth', 800)

Cette instruction particulière définit la largeur maximale à 800 px, par colonne.

pX0r
la source
2
En faisant défiler vers le bas dans l'ordre de vote décroissant, c'est la première réponse qui a fonctionné pour moi afin que les pandas ne tronquent pas la sortie en texte brut des DataFrames. (pandas 0.22, iTerm2 3.0.13, OS X 10.12).
Peter Leimbigler
2
C'est le seul qui a fonctionné pour moi pour Pandas 0.23.2.
devinbost
1
Comment se fait-il que vous n'ayez pas à le spécifier display.max_colwidth? Voilà comment il est répertorié dans la documentation. Je suis d'accord que cela ne max_colwidthfonctionne que et est plus court à écrire, mais j'ai été surpris.
cmo
26

Vous pouvez utiliser print df.describe().to_string()pour le forcer à afficher la table entière. (Vous pouvez utiliser to_string()comme ceci pour n'importe quel DataFrame. Le résultat dedescribe est juste un DataFrame lui-même.)

Le 8 est le nombre de lignes dans le DataFrame contenant la "description" (car describecalcule 8 statistiques, min, max, moyenne, etc.).

BrenBarn
la source
26

Vous pouvez ajuster les options d'impression des pandas avec set_printoptions.

In [3]: df.describe()
Out[3]: 
<class 'pandas.core.frame.DataFrame'>
Index: 8 entries, count to max
Data columns:
x1    8  non-null values
x2    8  non-null values
x3    8  non-null values
x4    8  non-null values
x5    8  non-null values
x6    8  non-null values
x7    8  non-null values
dtypes: float64(7)

In [4]: pd.set_printoptions(precision=2)

In [5]: df.describe()
Out[5]: 
            x1       x2       x3       x4       x5       x6       x7
count      8.0      8.0      8.0      8.0      8.0      8.0      8.0
mean   69024.5  69025.5  69026.5  69027.5  69028.5  69029.5  69030.5
std       17.1     17.1     17.1     17.1     17.1     17.1     17.1
min    69000.0  69001.0  69002.0  69003.0  69004.0  69005.0  69006.0
25%    69012.2  69013.2  69014.2  69015.2  69016.2  69017.2  69018.2
50%    69024.5  69025.5  69026.5  69027.5  69028.5  69029.5  69030.5
75%    69036.8  69037.8  69038.8  69039.8  69040.8  69041.8  69042.8
max    69049.0  69050.0  69051.0  69052.0  69053.0  69054.0  69055.0

Cependant, cela ne fonctionnera pas dans tous les cas car pandas détecte la largeur de votre console et ne l'utilisera que to_stringsi la sortie tient dans la console (voir la docstring de set_printoptions). Dans ce cas, vous pouvez explicitement appeler to_stringcomme répondu par BrenBarn .

Mise à jour

Avec la version 0.10, la façon dont les cadres de données larges sont imprimés a changé :

In [3]: df.describe()
Out[3]: 
                 x1            x2            x3            x4            x5  \
count      8.000000      8.000000      8.000000      8.000000      8.000000   
mean   59832.361578  27356.711336  49317.281222  51214.837838  51254.839690   
std    22600.723536  26867.192716  28071.737509  21012.422793  33831.515761   
min    31906.695474   1648.359160     56.378115  16278.322271     43.745574   
25%    45264.625201  12799.540572  41429.628749  40374.273582  29789.643875   
50%    56340.214856  18666.456293  51995.661512  54894.562656  47667.684422   
75%    75587.003417  31375.610322  61069.190523  67811.893435  76014.884048   
max    98136.474782  84544.484627  91743.983895  75154.587156  99012.695717   

                 x6            x7  
count      8.000000      8.000000  
mean   41863.000717  33950.235126  
std    38709.468281  29075.745673  
min     3590.990740   1833.464154  
25%    15145.759625   6879.523949  
50%    22139.243042  33706.029946  
75%    72038.983496  51449.893980  
max    98601.190488  83309.051963  

De plus, l'API pour définir les options de pandas a changé:

In [4]: pd.set_option('display.precision', 2)

In [5]: df.describe()
Out[5]: 
            x1       x2       x3       x4       x5       x6       x7
count      8.0      8.0      8.0      8.0      8.0      8.0      8.0
mean   59832.4  27356.7  49317.3  51214.8  51254.8  41863.0  33950.2
std    22600.7  26867.2  28071.7  21012.4  33831.5  38709.5  29075.7
min    31906.7   1648.4     56.4  16278.3     43.7   3591.0   1833.5
25%    45264.6  12799.5  41429.6  40374.3  29789.6  15145.8   6879.5
50%    56340.2  18666.5  51995.7  54894.6  47667.7  22139.2  33706.0
75%    75587.0  31375.6  61069.2  67811.9  76014.9  72039.0  51449.9
max    98136.5  84544.5  91744.0  75154.6  99012.7  98601.2  83309.1
bmu
la source
Je préfère utiliser la méthode max_columns mentionnée par lodagro, mais je suis content que vous ayez mentionné le mot-clé de précision car cela aidera à nettoyer les statistiques affichées. Merci!
betteraves
22

Vous pouvez régler l'affichage de sortie pour qu'il corresponde à la largeur actuelle de votre terminal:

pd.set_option('display.width', pd.util.terminal.get_terminal_size()[0])
Wilfred Hughes
la source
6
@ wouter-overmeire dit que les pandas le font automatiquement , mais cela ne semble pas être le cas, du moins pas avec la 0.18.0. Cependant, si vous utilisez pd.set_option('display.width', None)dans un terminal, "les pandas détecteront correctement la largeur" .
Matthias Fripp
Exactement! Il ne le fait pas par défaut. Si vous le définissez sur None, cela ignore simplement la largeur. Peut-être que c'est un bug dans Pandas ou peut-être cela a à voir avec le terminal gnome ..? Merci Wilfred Hughes!
danger89
3
AttributeError: le module 'pandas.util' n'a pas d'attribut 'terminal'
Bhishan Poudel
1
@BhishanPoudel Vous pouvez le faire à la place:pd.options.display.width = None
SebMa
1
@BhishanPoudel Cette réponse date de quelques années et j'ai rencontré le même problème que vous. Au moment d'écrire ces lignes, en utilisant la version 0.23.1 de pandas, le module est maintenantpd.io.formats.terminal.get_terminal_size()
Ajay
13

Selon la documentation de la v0.18.0 , si vous utilisez un terminal (c'est-à-dire pas un ordinateur portable iPython, qtconsole ou IDLE), il s'agit d'une doublure pour que les Pandas détectent automatiquement la largeur de votre écran et s'adaptent à la volée avec combien de colonnes, il montre:

pd.set_option('display.large_repr', 'truncate')
pd.set_option('display.max_columns', 0)
hamx0r
la source
1
Cela a fonctionné pour moi, merci! J'utilise Pandas 0.22.0 (au plus tard le 8 février 2018) à l'aide de l'application Terminal intégrée sur OS X 10.11.6
Greg Sadetsky
8

Il semble que toutes les réponses ci-dessus résolvent le problème. Encore un point: au lieu de pd.set_option('option_name'), vous pouvez utiliser le (auto-complete-able)

pd.options.display.width = None

Voir le document Pandas: Options et paramètres:

Les options ont un nom complet «style pointillé», insensible à la casse (par exemple display.max_rows). Vous pouvez obtenir / définir des options directement en tant qu'attributs de l'attribut de niveau supérieur options:

In [1]: import pandas as pd

In [2]: pd.options.display.max_rows
Out[2]: 15

In [3]: pd.options.display.max_rows = 999

In [4]: pd.options.display.max_rows
Out[4]: 999

[...]

pour les max_...params:

max_rowset max_columnssont utilisés dans les __repr__()méthodes pour décider si to_string()ou info()est utilisé pour restituer un objet à une chaîne. Dans le cas où python / IPython s'exécute dans un terminal, cela peut être défini sur 0 et les pandas détecteront correctement la largeur du terminal et passeront à un format plus petit au cas où toutes les colonnes ne tiendraient pas verticalement. Le bloc-notes IPython, IPython qtconsole ou IDLE ne s'exécutent pas dans un terminal et il n'est donc pas possible d'effectuer une détection automatique correcte. ' None' valeur signifie illimité. [non souligné dans l'original]

pour le width param:

Largeur de l'affichage en caractères. Dans le cas où python / IPython s'exécute dans un terminal, cela peut être défini sur Noneet pandas détectera correctement automatiquement la largeur. Notez que le bloc-notes IPython, IPython qtconsole ou IDLE ne s'exécutent pas dans un terminal et qu'il n'est donc pas possible de détecter correctement la largeur.

serv-inc
la source
5
import pandas as pd
pd.set_option('display.max_columns', 100)
pd.set_option('display.width', 1000)

SentenceA = "William likes Piano and Piano likes William"
SentenceB = "Sara likes Guitar"
SentenceC = "Mamoosh likes Piano"
SentenceD = "William is a CS Student"
SentenceE = "Sara is kind"
SentenceF = "Mamoosh is kind"


bowA = SentenceA.split(" ")
bowB = SentenceB.split(" ")
bowC = SentenceC.split(" ")
bowD = SentenceD.split(" ")
bowE = SentenceE.split(" ")
bowF = SentenceF.split(" ")

# Creating a set consisted of all words

wordSet = set(bowA).union(set(bowB)).union(set(bowC)).union(set(bowD)).union(set(bowE)).union(set(bowF))
print("Set of all words is: ", wordSet)

# Initiating dictionary with 0 value for all BOWs

wordDictA = dict.fromkeys(wordSet, 0)
wordDictB = dict.fromkeys(wordSet, 0)
wordDictC = dict.fromkeys(wordSet, 0)
wordDictD = dict.fromkeys(wordSet, 0)
wordDictE = dict.fromkeys(wordSet, 0)
wordDictF = dict.fromkeys(wordSet, 0)

for word in bowA:
    wordDictA[word] += 1
for word in bowB:
    wordDictB[word] += 1
for word in bowC:
    wordDictC[word] += 1
for word in bowD:
    wordDictD[word] += 1
for word in bowE:
    wordDictE[word] += 1
for word in bowF:
    wordDictF[word] += 1

# Printing Term frequency

print("SentenceA TF: ", wordDictA)
print("SentenceB TF: ", wordDictB)
print("SentenceC TF: ", wordDictC)
print("SentenceD TF: ", wordDictD)
print("SentenceE TF: ", wordDictE)
print("SentenceF TF: ", wordDictF)

print(pd.DataFrame([wordDictA, wordDictB, wordDictB, wordDictC, wordDictD, wordDictE, wordDictF]))

Production:

   CS  Guitar  Mamoosh  Piano  Sara  Student  William  a  and  is  kind  likes
0   0       0        0      2     0        0        2  0    1   0     0      2
1   0       1        0      0     1        0        0  0    0   0     0      1
2   0       1        0      0     1        0        0  0    0   0     0      1
3   0       0        1      1     0        0        0  0    0   0     0      1
4   1       0        0      0     0        1        1  1    0   1     0      0
5   0       0        0      0     1        0        0  0    0   1     1      0
6   0       0        1      0     0        0        0  0    0   1     1      0
William Pourmajidi
la source
Vous avez juste besoin des deux: (Vérifiez l'exemple ci-dessus) importez des pandas en tant que pd pd.set_option ('display.max_columns', 100) pd.set_option ('display.width', 1000)
William Pourmajidi
4

J'ai utilisé ces paramètres lorsque l'échelle des données est élevée.

# environment settings: 
pd.set_option('display.max_column',None)
pd.set_option('display.max_rows',None)
pd.set_option('display.max_seq_items',None)
pd.set_option('display.max_colwidth', 500)
pd.set_option('expand_frame_repr', True)

Vous pouvez consulter la documentation ici

debaonline4u
la source
4

La ligne ci-dessous est suffisante pour afficher toutes les colonnes de la trame de données. pd.set_option('display.max_columns', None)

zeeshan
la source
1
Bienvenue chez SO! Lorsque vous postez une nouvelle réponse à une question et qu'il y a d'autres réponses, essayez de montrer aux Pros. Il y a encore une réponse pd.set_option('display.max_columns', 0)Quels sont les avantages de la vôtre?
David García Bodego
3

Si vous ne voulez pas jouer avec vos options d'affichage et que vous voulez juste voir cette liste particulière de colonnes sans développer chaque trame de données que vous affichez, vous pouvez essayer:

df.columns.values
Sont trop
la source
2

Vous pouvez également essayer en boucle:

for col in df.columns: 
    print(col) 
la vie est belle
la source
2

Vous pouvez simplement effectuer les étapes suivantes,

  • Vous pouvez modifier les options de la fonction pandas max_columns comme suit

    import pandas as pd
    pd.options.display.max_columns = 10

    (cela permet d'afficher 10 colonnes, vous pouvez modifier cela selon vos besoins)

  • De cette façon, vous pouvez modifier le nombre de lignes que vous devez afficher comme suit (si vous devez également modifier le nombre maximal de lignes)

    pd.options.display.max_rows = 999

    (cela permet d'imprimer 999 lignes à la fois)

Veuillez vous référer avec bonté le doc pour changer les différentes options / paramètres pour les pandas

Amila Viraj
la source