.. info:
pygmt.info
==========
.. code::
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
-------
.. code ::
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()