pygmt.info¶

pygmt.info(data, \*, per_column=None, spacing=None,
nearest_multiple=None, verbose=None, aspatial=None,
coltypes=None, incols=None, registration=None, \**kwargs)

Obtenir des informations sur les tables de données.

Lit les fichiers et trouve les valeurs extrêmes dans chacune des colonnes signalées sous forme de paires min/max. Il reconnaît les NaN et affichera des avertissements si le nombre de colonnes varie d’un enregistrement à l’autre. En option, il trouvera l’étendue des deux premières colonnes arrondie au multiple supérieur et inférieur le plus proche des incréments fournis donnés par spacing. Cette sortie sera sous une forme numpy.ndarray [ w , e , s , n ], qui peut être utilisée directement comme le paramètre region pour d’autres modules (par conséquent, seuls dx et dy sont nécessaires). Si le per_column paramètre est combiné avec spacing, alors la sortie numpy.ndarray sera arrondie vers le haut/vers le bas pour autant de colonnes qu’il y a d’incréments fournis dans spacing. Un paramètre similaire nearest_multiple fournira un numpy.ndarray sous la forme de [ zmin , zmax , dz ] pour makecpt.

Paramètre¶

data ( str ou numpy.ndarray ou pandas.DataFrame ou xarray.Dataset ou geopandas.GeoDataFrame ) – Transmettez soit un nom de fichier à une table de données ASCII, un 1-D/2-D numpy.ndarray, un pandas.DataFrame, un xarray.Dataset composé de 1- D xarray.DataArray variables de données, ou a geopandas.GeoDataFrame contenant les données tabulaires.
per_column ( bool ) – Rapporte les valeurs min/max par colonne dans des colonnes séparées.
spacing ( str ) – [ b | p | f | s ] dx [/ dy [/ dz …]]. Calculez les valeurs min/max des n premières colonnes au multiple le plus proche des incréments fournis [la valeur par défaut est 2 colonnes]. Par défaut, les résultats de sortie sont sous la forme , sauf si est défini, auquel cas nous publions chaque valeur min et max dans des colonnes de sortie séparées. [w, e, s, n] per_column
nearest_multiple ( str ) – dz [ +c col ]. Indiquez le min/max de la première (0’ème) colonne au multiple de dz le plus proche et affichez-le sous la forme .[zmin, zmax, dz]
verbose ( bool ou str ) – Sélectionnez le niveau de verbosité [la valeur par défaut est w ], qui module les messages écrits sur stderr. Choisissez parmi 7 niveaux de verbosité :
- q - Des messages d’erreur silencieux, même fatals, ne sont pas générés
- e - Messages d’erreur uniquement
- w - Avertissements [par défaut]
- t - Timings (temps d’exécution des rapports pour les algorithmes chronophages)
- i - Messages d’information (comme verbose=True)
- c - Avertissements de compatibilité
- d - Messages de débogage
aspatial ( bool ou str ) – [ col =] nom [,…]. Contrôlez la manière dont les données aspatiales sont gérées lors de l’entrée et de la sortie.
incols ( str ou tableau 1-D ) – Spécifiez les colonnes de données pour l’entrée principale dans un ordre arbitraire. Les colonnes peuvent être répétées et les colonnes non répertoriées seront ignorées [par défaut, toutes les colonnes sont lues dans l’ordre, en commençant par la première (c’est-à-dire la colonne 0)].
- Pour un tableau 1-D : spécifiez les colonnes individuelles dans l’ordre d’entrée (par exemple, incols=[1,0] pour la 2ème colonne suivie de la 1ère colonne).
- Pour str: spécifiez des colonnes individuelles ou des plages de colonnes au format start [: inc ]: stop , où inc prend par défaut la valeur 1 s’il n’est pas spécifié, avec des colonnes et/ou des plages de colonnes séparées par des virgules (par exemple, incols= »0:2,4+l » pour saisir les trois premières colonnes suivies du 5e colonne transformée en log). Pour lire à partir d’une colonne donnée jusqu’à la fin de l’enregistrement, laissez off stop lors de la spécification de la plage de colonnes. Pour lire le texte de fin, ajoutez la colonne t . Ajoutez le numéro de mot à t pour ingérer un seul mot du texte de fin. Au lieu de spécifier des colonnes, utilisez incols= »n » pour lire simplement l’entrée numérique et ignorer le texte de fin. Ajoutez éventuellement l’un des modificateurs suivants à n’importe quelle colonne ou plage de colonnes pour transformer les colonnes d’entrée :
  
  +l pour prendre le log10 des valeurs d’entrée.
  
  +d pour diviser les valeurs d’entrée par le facteur diviseur [la valeur par défaut est 1].
  
  +s pour multiplier les valeurs d’entrée par l” échelle des facteurs [la valeur par défaut est 1].
  
  +o pour ajouter le décalage donné aux valeurs d’entrée [la valeur par défaut est 0].
coltypes ( str ) – [ i | o ] colinfo . Spécifiez les types de données des colonnes d’entrée et/ou de sortie (données temporelles ou géographiques).
inscription ( str ) – g | p . Forcer l’enregistrement du nœud quadrillage ( g ) ou pixel ( p ) [la valeur par défaut est g (ridline)].

Retour¶

output ( np.ndarray ou str ) – Le type de retour dépend si l’un des paramètres per_column , spacing ou nearest_multiple est défini.

numpy.ndarray si l’un des paramètres ci-dessus est utilisé.
str si aucun des paramètres ci-dessus n’est utilisé.

Exemple¶

import pandas as pd
import pygmt

# Load sample penguins data
df = pd.read_csv("https://github.com/mwaskom/seaborn-data/raw/master/penguins.csv")
# Convert 'species' column to categorical dtype
# By default, pandas sorts the individual categories in an alphabetical order.
# For a non-alphabetical order, you have to manually adjust the list of
# categories. For handling and manipulating categorical data in pandas,
# have a look at:
# https://pandas.pydata.org/docs/user_guide/categorical.html
df.species = df.species.astype(dtype="category")
# Make a list of the individual categories of the 'species' column
# ['Adelie', 'Chinstrap', 'Gentoo']
# They are (corresponding to the categorical number code) by default in
# alphabetical order and later used for the colorbar annotations
cb_annots = list(df.species.cat.categories)

# Use pygmt.info to get region bounds (xmin, xmax, ymin, ymax)
# The below example will return a numpy array like [30.0, 60.0, 12.0, 22.0]
region = pygmt.info(
    data=df[["bill_length_mm", "bill_depth_mm"]],  # x and y columns
    per_column=True,  # report the min/max values per column as a numpy array
    # round the min/max values of the first two columns to the nearest multiple
    # of 3 and 2, respectively
    spacing=(3, 2),
)

# Make a 2-D categorical scatter plot, coloring each of the 3 species
# differently
fig = pygmt.Figure()

# Generate a basemap of 10 cm x 10 cm size
fig.basemap(
    region=region,
    projection="X10c/10c",
    frame=[
        "xafg+lBill length (mm)",
        "yafg+lBill depth (mm)",
        "WSen+tPenguin size at Palmer Station",
    ],
)

# Define a colormap to be used for three categories, define the range of the
# new discrete CPT using series=(lowest_value, highest_value, interval),
# use color_model="+cAdelie,Chinstrap,Gentoo" to write the discrete color
# palette "inferno" in categorical format and add the species names as
# annotations for the colorbar
pygmt.makecpt(
    cmap="inferno",
    # Use the minimum and maximum of the categorical number code
    # to set the lowest_value and the highest_value of the CPT
    series=(df.species.cat.codes.min(), df.species.cat.codes.max(), 1),
    # convert ['Adelie', 'Chinstrap', 'Gentoo'] to 'Adelie,Chinstrap,Gentoo'
    color_model="+c" + ",".join(cb_annots),
)

fig.plot(
    # Use bill length and bill depth as x and y data input, respectively
    x=df.bill_length_mm,
    y=df.bill_depth_mm,
    # Vary each symbol size according to another feature (body mass,
    # scaled by 7.5*10e-5)
    size=df.body_mass_g * 7.5e-5,
    # Points colored by categorical number code
    fill=df.species.cat.codes.astype(int),
    # Use colormap created by makecpt
    cmap=True,
    # Do not clip symbols that fall close to the map bounds
    no_clip=True,
    # Use circles as symbols (the first "c") with diameter in
    # centimeters (the second "c")
    style="cc",
    # Set transparency level for all symbols to deal with overplotting
    transparency=40,
)

# Add colorbar legend
fig.colorbar()

fig.show()