Skip to content

Instantly share code, notes, and snippets.

@vilterp

vilterp/geopandas.ipynb

Created July 29, 2014 19:54
Show Gist options
  • Save vilterp/6586a61f183947ca1885 to your computer and use it in GitHub Desktop.
Save vilterp/6586a61f183947ca1885 to your computer and use it in GitHub Desktop.
Download ZIP
Display the source blob
Display the rendered blob
Raw
geopandas.ipynb
{
"metadata": {
"name": "",
"signature": "sha256:d4e27f35f71f18c08f9880a87176e7929c0c935ad3f48a72dac4cdb2e41cf2d4"
},
"nbformat": 3,
"nbformat_minor": 0,
"worksheets": [
{
"cells": [
{
"cell_type": "code",
"collapsed": false,
"input": [
"import shapely"
],
"language": "python",
"metadata": {},
"outputs": [],
"prompt_number": 1
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"import pandas as pd"
],
"language": "python",
"metadata": {},
"outputs": [],
"prompt_number": 2
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"import fiona"
],
"language": "python",
"metadata": {},
"outputs": [],
"prompt_number": 3
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"import geopandas as gpd"
],
"language": "python",
"metadata": {},
"outputs": [],
"prompt_number": 4
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"help(gpd)"
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"Help on package geopandas:\n",
"\n",
"NAME\n",
" geopandas\n",
"\n",
"FILE\n",
" /usr/local/lib/python2.7/site-packages/geopandas/__init__.py\n",
"\n",
"PACKAGE CONTENTS\n",
" base\n",
" geocode\n",
" geodataframe\n",
" geoseries\n",
" io (package)\n",
" plotting\n",
" tools\n",
" version\n",
"\n",
"DATA\n",
" __version__ = '0.1.0'\n",
"\n",
"VERSION\n",
" 0.1.0\n",
"\n",
"\n"
]
}
],
"prompt_number": 5
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"help(gpd.base)"
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"Help on module geopandas.base in geopandas:\n",
"\n",
"NAME\n",
" geopandas.base\n",
"\n",
"FILE\n",
" /usr/local/lib/python2.7/site-packages/geopandas/base.py\n",
"\n",
"CLASSES\n",
" __builtin__.object\n",
" GeoPandasBase\n",
" \n",
" class GeoPandasBase(__builtin__.object)\n",
" | Methods defined here:\n",
" | \n",
" | buffer(self, distance, resolution=16)\n",
" | \n",
" | contains(self, other)\n",
" | Return True for all geometries that contain *other*, else False\n",
" | \n",
" | crosses(self, other)\n",
" | Return True for all geometries that cross *other*, else False\n",
" | \n",
" | difference(self, other)\n",
" | Return the set-theoretic difference of each geometry with *other*\n",
" | \n",
" | disjoint(self, other)\n",
" | Return True for all geometries that are disjoint with *other*, else False\n",
" | \n",
" | distance(self, other)\n",
" | Return distance of each geometry to *other*\n",
" | \n",
" | geom_almost_equals(self, other, decimal=6)\n",
" | Return True for all geometries that is approximately equal to *other*, else False\n",
" | \n",
" | geom_equals(self, other)\n",
" | Return True for all geometries that equal *other*, else False\n",
" | \n",
" | geom_equals_exact(self, other, tolerance)\n",
" | Return True for all geometries that equal *other* to a given tolerance, else False\n",
" | \n",
" | interpolate(self, distance, normalized=False)\n",
" | Return a point at the specified distance along each geometry\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | distance : float or Series of floats\n",
" | Distance(s) along the geometries at which a point should be returned\n",
" | normalized : boolean\n",
" | If normalized is True, distance will be interpreted as a fraction \n",
" | of the geometric object's length.\n",
" | \n",
" | intersection(self, other)\n",
" | Return the set-theoretic intersection of each geometry with *other*\n",
" | \n",
" | intersects(self, other)\n",
" | Return True for all geometries that intersect *other*, else False\n",
" | \n",
" | overlaps(self, other)\n",
" | Return True for all geometries that overlap *other*, else False\n",
" | \n",
" | project(self, other, normalized=False)\n",
" | Return the distance along each geometry nearest to *other*\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | other : BaseGeometry or GeoSeries\n",
" | The *other* geometry to computed projected point from.\n",
" | normalized : boolean\n",
" | If normalized is True, return the distance normalized to\n",
" | the length of the object.\n",
" | \n",
" | The project method is the inverse of interpolate.\n",
" | \n",
" | relate(self, other)\n",
" | \n",
" | representative_point(self)\n",
" | Return a GeoSeries of points guaranteed to be in each geometry\n",
" | \n",
" | rotate(self, angle, origin='center', use_radians=False)\n",
" | Rotate the coordinates of the GeoSeries.\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | angle : float\n",
" | The angle of rotation can be specified in either degrees (default) \n",
" | or radians by setting use_radians=True. Positive angles are \n",
" | counter-clockwise and negative are clockwise rotations.\n",
" | origin : string, Point, or tuple (x, y)\n",
" | The point of origin can be a keyword 'center' for the bounding box \n",
" | center (default), 'centroid' for the geometry's centroid, a Point \n",
" | object or a coordinate tuple (x, y).\n",
" | use_radians : boolean\n",
" | Whether to interpret the angle of rotation as degrees or radians\n",
" | \n",
" | See shapely manual for more information:\n",
" | http://toblerity.org/shapely/manual.html#affine-transformations\n",
" | \n",
" | scale(self, xfact=1.0, yfact=1.0, zfact=1.0, origin='center')\n",
" | Scale the geometries of the GeoSeries along each (x, y, z) dimension.\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | xfact, yfact, zfact : float, float, float\n",
" | Scaling factors for the x, y, and z dimensions respectively.\n",
" | origin : string, Point, or tuple\n",
" | The point of origin can be a keyword 'center' for the 2D bounding \n",
" | box center (default), 'centroid' for the geometry's 2D centroid, a \n",
" | Point object or a coordinate tuple (x, y, z).\n",
" | \n",
" | Note: Negative scale factors will mirror or reflect coordinates.\n",
" | \n",
" | See shapely manual for more information:\n",
" | http://toblerity.org/shapely/manual.html#affine-transformations\n",
" | \n",
" | simplify(self, *args, **kwargs)\n",
" | \n",
" | skew(self, xs=0.0, ys=0.0, origin='center', use_radians=False)\n",
" | Shear/Skew the geometries of the GeoSeries by angles along x and y dimensions.\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | xs, ys : float, float\n",
" | The shear angle(s) for the x and y axes respectively. These can be \n",
" | specified in either degrees (default) or radians by setting \n",
" | use_radians=True.\n",
" | origin : string, Point, or tuple (x, y)\n",
" | The point of origin can be a keyword 'center' for the bounding box \n",
" | center (default), 'centroid' for the geometry's centroid, a Point \n",
" | object or a coordinate tuple (x, y).\n",
" | use_radians : boolean\n",
" | Whether to interpret the shear angle(s) as degrees or radians\n",
" | \n",
" | See shapely manual for more information:\n",
" | http://toblerity.org/shapely/manual.html#affine-transformations\n",
" | \n",
" | symmetric_difference(self, other)\n",
" | Return the symmetric difference of each geometry with *other*\n",
" | \n",
" | touches(self, other)\n",
" | Return True for all geometries that touch *other*, else False\n",
" | \n",
" | translate(self, xoff=0.0, yoff=0.0, zoff=0.0)\n",
" | Shift the coordinates of the GeoSeries.\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | xoff, yoff, zoff : float, float, float\n",
" | Amount of offset along each dimension.\n",
" | xoff, yoff, and zoff for translation along the x, y, and z \n",
" | dimensions respectively.\n",
" | \n",
" | See shapely manual for more information:\n",
" | http://toblerity.org/shapely/manual.html#affine-transformations\n",
" | \n",
" | union(self, other)\n",
" | Return the set-theoretic union of each geometry with *other*\n",
" | \n",
" | within(self, other)\n",
" | Return True for all geometries that are within *other*, else False\n",
" | \n",
" | ----------------------------------------------------------------------\n",
" | Data descriptors defined here:\n",
" | \n",
" | __dict__\n",
" | dictionary for instance variables (if defined)\n",
" | \n",
" | __weakref__\n",
" | list of weak references to the object (if defined)\n",
" | \n",
" | area\n",
" | Return the area of each geometry in the GeoSeries\n",
" | \n",
" | boundary\n",
" | Return the bounding geometry for each geometry\n",
" | \n",
" | bounds\n",
" | Return a DataFrame of minx, miny, maxx, maxy values of geometry objects\n",
" | \n",
" | cascaded_union\n",
" | Deprecated: Return the unary_union of all geometries\n",
" | \n",
" | centroid\n",
" | Return the centroid of each geometry in the GeoSeries\n",
" | \n",
" | convex_hull\n",
" | Return the convex hull of each geometry\n",
" | \n",
" | envelope\n",
" | Return a bounding rectangle for each geometry\n",
" | \n",
" | exterior\n",
" | Return the outer boundary of each polygon\n",
" | \n",
" | geom_type\n",
" | Return the geometry type of each geometry in the GeoSeries\n",
" | \n",
" | interiors\n",
" | Return the interior rings of each polygon\n",
" | \n",
" | is_empty\n",
" | Return True for each empty geometry, False for non-empty\n",
" | \n",
" | is_ring\n",
" | Return True for each geometry that is a closed ring, else False\n",
" | \n",
" | is_simple\n",
" | Return True for each simple geometry, else False\n",
" | \n",
" | is_valid\n",
" | Return True for each valid geometry, else False\n",
" | \n",
" | length\n",
" | Return the length of each geometry in the GeoSeries\n",
" | \n",
" | total_bounds\n",
" | Return a single bounding box (minx, miny, maxx, maxy) for all geometries\n",
" | \n",
" | This is a shortcut for calculating the min/max x and y bounds individually.\n",
" | \n",
" | type\n",
" | Return the geometry type of each geometry in the GeoSeries\n",
" | \n",
" | unary_union\n",
" | Return the union of all geometries\n",
"\n",
"FUNCTIONS\n",
" warn(...)\n",
" Issue a warning, or maybe ignore it or raise an exception.\n",
"\n",
"\n"
]
}
],
"prompt_number": 6
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"help(gpd.geodataframe)"
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"Help on module geopandas.geodataframe in geopandas:\n",
"\n",
"NAME\n",
" geopandas.geodataframe\n",
"\n",
"FILE\n",
" /usr/local/lib/python2.7/site-packages/geopandas/geodataframe.py\n",
"\n",
"CLASSES\n",
" geopandas.base.GeoPandasBase(__builtin__.object)\n",
" GeoDataFrame(geopandas.base.GeoPandasBase, pandas.core.frame.DataFrame)\n",
" pandas.core.frame.DataFrame(pandas.core.generic.NDFrame)\n",
" GeoDataFrame(geopandas.base.GeoPandasBase, pandas.core.frame.DataFrame)\n",
" \n",
" class GeoDataFrame(geopandas.base.GeoPandasBase, pandas.core.frame.DataFrame)\n",
" | A GeoDataFrame object is a pandas.DataFrame that has a column\n",
" | with geometry. In addition to the standard DataFrame constructor arguments,\n",
" | GeoDataFrame also accepts the following keyword arguments:\n",
" | \n",
" | Keyword Arguments\n",
" | -----------------\n",
" | crs : str (optional)\n",
" | Coordinate system\n",
" | geometry : str or array (optional)\n",
" | If str, column to use as geometry. If array, will be set as 'geometry'\n",
" | column on GeoDataFrame.\n",
" | \n",
" | Method resolution order:\n",
" | GeoDataFrame\n",
" | geopandas.base.GeoPandasBase\n",
" | pandas.core.frame.DataFrame\n",
" | pandas.core.generic.NDFrame\n",
" | pandas.core.generic.PandasContainer\n",
" | pandas.core.base.PandasObject\n",
" | pandas.core.base.StringMixin\n",
" | __builtin__.object\n",
" | \n",
" | Methods defined here:\n",
" | \n",
" | __finalize__(self, other, method=None, **kwargs)\n",
" | propagate metadata from other to self\n",
" | \n",
" | __getitem__(self, key)\n",
" | If the result is a column containing only 'geometry', return a\n",
" | GeoSeries. If it's a DataFrame with a 'geometry' column, return a\n",
" | GeoDataFrame.\n",
" | \n",
" | __init__(self, *args, **kwargs)\n",
" | \n",
" | __setattr__(self, attr, val)\n",
" | \n",
" | copy(self, deep=True)\n",
" | Make a copy of this GeoDataFrame object\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | deep : boolean, default True\n",
" | Make a deep copy, i.e. also copy data\n",
" | \n",
" | Returns\n",
" | -------\n",
" | copy : GeoDataFrame\n",
" | \n",
" | plot(self, *args, **kwargs)\n",
" | \n",
" | set_geometry(self, col, drop=False, inplace=False, crs=None)\n",
" | Set the GeoDataFrame geometry using either an existing column or\n",
" | the specified input. By default yields a new object.\n",
" | \n",
" | The original geometry column is replaced with the input.\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | keys : column label or array\n",
" | drop : boolean, default True\n",
" | Delete column to be used as the new geometry\n",
" | inplace : boolean, default False\n",
" | Modify the GeoDataFrame in place (do not create a new object)\n",
" | crs : str/result of fion.get_crs (optional)\n",
" | Coordinate system to use. If passed, overrides both DataFrame and\n",
" | col's crs. Otherwise, tries to get crs from passed col values or\n",
" | DataFrame.\n",
" | \n",
" | Examples\n",
" | --------\n",
" | >>> df1 = df.set_geometry([Point(0,0), Point(1,1), Point(2,2)])\n",
" | >>> df2 = df.set_geometry('geom1')\n",
" | \n",
" | Returns\n",
" | -------\n",
" | geodataframe : GeoDataFrame\n",
" | \n",
" | to_crs(self, crs=None, epsg=None, inplace=False)\n",
" | Transform geometries to a new coordinate reference system\n",
" | \n",
" | This method will transform all points in all objects. It has\n",
" | no notion or projecting entire geometries. All segments\n",
" | joining points are assumed to be lines in the current\n",
" | projection, not geodesics. Objects crossing the dateline (or\n",
" | other projection boundary) will have undesirable behavior.\n",
" | \n",
" | to_file(self, filename, driver='ESRI Shapefile', **kwargs)\n",
" | Write this GeoDataFrame to an OGR data source\n",
" | \n",
" | A dictionary of supported OGR providers is available via:\n",
" | >>> import fiona\n",
" | >>> fiona.supported_drivers\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | filename : string \n",
" | File path or file handle to write to.\n",
" | driver : string, default 'ESRI Shapefile'\n",
" | The OGR format driver used to write the vector file.\n",
" | \n",
" | The *kwargs* are passed to fiona.open and can be used to write \n",
" | to multi-layer data, store data within archives (zip files), etc.\n",
" | \n",
" | to_json(self, na='null', **kwargs)\n",
" | Returns a GeoJSON representation of the GeoDataFrame.\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | na : {'null', 'drop', 'keep'}, default 'null'\n",
" | Indicates how to output missing (NaN) values in the GeoDataFrame\n",
" | * null: ouput the missing entries as JSON null\n",
" | * drop: remove the property from the feature. This applies to\n",
" | each feature individually so that features may have\n",
" | different properties\n",
" | * keep: output the missing entries as NaN\n",
" | \n",
" | The remaining *kwargs* are passed to json.dumps().\n",
" | \n",
" | ----------------------------------------------------------------------\n",
" | Class methods defined here:\n",
" | \n",
" | from_features(cls, features, crs=None) from __builtin__.type\n",
" | Alternate constructor to create GeoDataFrame from an iterable of\n",
" | features. Each element must be a feature dictionary or implement\n",
" | the __geo_interface__.\n",
" | See: https://gist.github.com/sgillies/2217756\n",
" | \n",
" | from_file(cls, filename, **kwargs) from __builtin__.type\n",
" | Alternate constructor to create a GeoDataFrame from a file.\n",
" | \n",
" | Example:\n",
" | df = geopandas.GeoDataFrame.from_file('nybb.shp')\n",
" | \n",
" | Wraps geopandas.read_file(). For additional help, see read_file()\n",
" | \n",
" | from_postgis(cls, sql, con, geom_col='geom', crs=None, index_col=None, coerce_float=True, params=None) from __builtin__.type\n",
" | Alternate constructor to create a GeoDataFrame from a sql query\n",
" | containing a geometry column.\n",
" | \n",
" | Example:\n",
" | df = geopandas.GeoDataFrame.from_postgis(con,\n",
" | \"SELECT geom, highway FROM roads;\")\n",
" | \n",
" | Wraps geopandas.read_postgis(). For additional help, see read_postgis()\n",
" | \n",
" | ----------------------------------------------------------------------\n",
" | Data descriptors defined here:\n",
" | \n",
" | geometry\n",
" | Geometry data for GeoDataFrame\n",
" | \n",
" | ----------------------------------------------------------------------\n",
" | Methods inherited from geopandas.base.GeoPandasBase:\n",
" | \n",
" | buffer(self, distance, resolution=16)\n",
" | \n",
" | contains(self, other)\n",
" | Return True for all geometries that contain *other*, else False\n",
" | \n",
" | crosses(self, other)\n",
" | Return True for all geometries that cross *other*, else False\n",
" | \n",
" | difference(self, other)\n",
" | Return the set-theoretic difference of each geometry with *other*\n",
" | \n",
" | disjoint(self, other)\n",
" | Return True for all geometries that are disjoint with *other*, else False\n",
" | \n",
" | distance(self, other)\n",
" | Return distance of each geometry to *other*\n",
" | \n",
" | geom_almost_equals(self, other, decimal=6)\n",
" | Return True for all geometries that is approximately equal to *other*, else False\n",
" | \n",
" | geom_equals(self, other)\n",
" | Return True for all geometries that equal *other*, else False\n",
" | \n",
" | geom_equals_exact(self, other, tolerance)\n",
" | Return True for all geometries that equal *other* to a given tolerance, else False\n",
" | \n",
" | interpolate(self, distance, normalized=False)\n",
" | Return a point at the specified distance along each geometry\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | distance : float or Series of floats\n",
" | Distance(s) along the geometries at which a point should be returned\n",
" | normalized : boolean\n",
" | If normalized is True, distance will be interpreted as a fraction \n",
" | of the geometric object's length.\n",
" | \n",
" | intersection(self, other)\n",
" | Return the set-theoretic intersection of each geometry with *other*\n",
" | \n",
" | intersects(self, other)\n",
" | Return True for all geometries that intersect *other*, else False\n",
" | \n",
" | overlaps(self, other)\n",
" | Return True for all geometries that overlap *other*, else False\n",
" | \n",
" | project(self, other, normalized=False)\n",
" | Return the distance along each geometry nearest to *other*\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | other : BaseGeometry or GeoSeries\n",
" | The *other* geometry to computed projected point from.\n",
" | normalized : boolean\n",
" | If normalized is True, return the distance normalized to\n",
" | the length of the object.\n",
" | \n",
" | The project method is the inverse of interpolate.\n",
" | \n",
" | relate(self, other)\n",
" | \n",
" | representative_point(self)\n",
" | Return a GeoSeries of points guaranteed to be in each geometry\n",
" | \n",
" | rotate(self, angle, origin='center', use_radians=False)\n",
" | Rotate the coordinates of the GeoSeries.\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | angle : float\n",
" | The angle of rotation can be specified in either degrees (default) \n",
" | or radians by setting use_radians=True. Positive angles are \n",
" | counter-clockwise and negative are clockwise rotations.\n",
" | origin : string, Point, or tuple (x, y)\n",
" | The point of origin can be a keyword 'center' for the bounding box \n",
" | center (default), 'centroid' for the geometry's centroid, a Point \n",
" | object or a coordinate tuple (x, y).\n",
" | use_radians : boolean\n",
" | Whether to interpret the angle of rotation as degrees or radians\n",
" | \n",
" | See shapely manual for more information:\n",
" | http://toblerity.org/shapely/manual.html#affine-transformations\n",
" | \n",
" | scale(self, xfact=1.0, yfact=1.0, zfact=1.0, origin='center')\n",
" | Scale the geometries of the GeoSeries along each (x, y, z) dimension.\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | xfact, yfact, zfact : float, float, float\n",
" | Scaling factors for the x, y, and z dimensions respectively.\n",
" | origin : string, Point, or tuple\n",
" | The point of origin can be a keyword 'center' for the 2D bounding \n",
" | box center (default), 'centroid' for the geometry's 2D centroid, a \n",
" | Point object or a coordinate tuple (x, y, z).\n",
" | \n",
" | Note: Negative scale factors will mirror or reflect coordinates.\n",
" | \n",
" | See shapely manual for more information:\n",
" | http://toblerity.org/shapely/manual.html#affine-transformations\n",
" | \n",
" | simplify(self, *args, **kwargs)\n",
" | \n",
" | skew(self, xs=0.0, ys=0.0, origin='center', use_radians=False)\n",
" | Shear/Skew the geometries of the GeoSeries by angles along x and y dimensions.\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | xs, ys : float, float\n",
" | The shear angle(s) for the x and y axes respectively. These can be \n",
" | specified in either degrees (default) or radians by setting \n",
" | use_radians=True.\n",
" | origin : string, Point, or tuple (x, y)\n",
" | The point of origin can be a keyword 'center' for the bounding box \n",
" | center (default), 'centroid' for the geometry's centroid, a Point \n",
" | object or a coordinate tuple (x, y).\n",
" | use_radians : boolean\n",
" | Whether to interpret the shear angle(s) as degrees or radians\n",
" | \n",
" | See shapely manual for more information:\n",
" | http://toblerity.org/shapely/manual.html#affine-transformations\n",
" | \n",
" | symmetric_difference(self, other)\n",
" | Return the symmetric difference of each geometry with *other*\n",
" | \n",
" | touches(self, other)\n",
" | Return True for all geometries that touch *other*, else False\n",
" | \n",
" | translate(self, xoff=0.0, yoff=0.0, zoff=0.0)\n",
" | Shift the coordinates of the GeoSeries.\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | xoff, yoff, zoff : float, float, float\n",
" | Amount of offset along each dimension.\n",
" | xoff, yoff, and zoff for translation along the x, y, and z \n",
" | dimensions respectively.\n",
" | \n",
" | See shapely manual for more information:\n",
" | http://toblerity.org/shapely/manual.html#affine-transformations\n",
" | \n",
" | union(self, other)\n",
" | Return the set-theoretic union of each geometry with *other*\n",
" | \n",
" | within(self, other)\n",
" | Return True for all geometries that are within *other*, else False\n",
" | \n",
" | ----------------------------------------------------------------------\n",
" | Data descriptors inherited from geopandas.base.GeoPandasBase:\n",
" | \n",
" | __dict__\n",
" | dictionary for instance variables (if defined)\n",
" | \n",
" | __weakref__\n",
" | list of weak references to the object (if defined)\n",
" | \n",
" | area\n",
" | Return the area of each geometry in the GeoSeries\n",
" | \n",
" | boundary\n",
" | Return the bounding geometry for each geometry\n",
" | \n",
" | bounds\n",
" | Return a DataFrame of minx, miny, maxx, maxy values of geometry objects\n",
" | \n",
" | cascaded_union\n",
" | Deprecated: Return the unary_union of all geometries\n",
" | \n",
" | centroid\n",
" | Return the centroid of each geometry in the GeoSeries\n",
" | \n",
" | convex_hull\n",
" | Return the convex hull of each geometry\n",
" | \n",
" | envelope\n",
" | Return a bounding rectangle for each geometry\n",
" | \n",
" | exterior\n",
" | Return the outer boundary of each polygon\n",
" | \n",
" | geom_type\n",
" | Return the geometry type of each geometry in the GeoSeries\n",
" | \n",
" | interiors\n",
" | Return the interior rings of each polygon\n",
" | \n",
" | is_empty\n",
" | Return True for each empty geometry, False for non-empty\n",
" | \n",
" | is_ring\n",
" | Return True for each geometry that is a closed ring, else False\n",
" | \n",
" | is_simple\n",
" | Return True for each simple geometry, else False\n",
" | \n",
" | is_valid\n",
" | Return True for each valid geometry, else False\n",
" | \n",
" | length\n",
" | Return the length of each geometry in the GeoSeries\n",
" | \n",
" | total_bounds\n",
" | Return a single bounding box (minx, miny, maxx, maxy) for all geometries\n",
" | \n",
" | This is a shortcut for calculating the min/max x and y bounds individually.\n",
" | \n",
" | type\n",
" | Return the geometry type of each geometry in the GeoSeries\n",
" | \n",
" | unary_union\n",
" | Return the union of all geometries\n",
" | \n",
" | ----------------------------------------------------------------------\n",
" | Methods inherited from pandas.core.frame.DataFrame:\n",
" | \n",
" | __add__(self, other, axis=None, level=None, fill_value=None)\n",
" | Binary operator __add__ with support to substitute a fill_value for missing data in\n",
" | one of the inputs\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | other : Series, DataFrame, or constant\n",
" | axis : {0, 1, 'index', 'columns'}\n",
" | For Series input, axis to match Series index on\n",
" | fill_value : None or float value, default None\n",
" | Fill missing (NaN) values with this value. If both DataFrame locations are\n",
" | missing, the result will be missing\n",
" | level : int or name\n",
" | Broadcast across a level, matching Index values on the\n",
" | passed MultiIndex level\n",
" | \n",
" | Notes\n",
" | -----\n",
" | Mismatched indices will be unioned together\n",
" | \n",
" | Returns\n",
" | -------\n",
" | result : DataFrame\n",
" | \n",
" | __and__(self, other, axis='columns', level=None, fill_value=None)\n",
" | Binary operator __and__ with support to substitute a fill_value for missing data in\n",
" | one of the inputs\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | other : Series, DataFrame, or constant\n",
" | axis : {0, 1, 'index', 'columns'}\n",
" | For Series input, axis to match Series index on\n",
" | fill_value : None or float value, default None\n",
" | Fill missing (NaN) values with this value. If both DataFrame locations are\n",
" | missing, the result will be missing\n",
" | level : int or name\n",
" | Broadcast across a level, matching Index values on the\n",
" | passed MultiIndex level\n",
" | \n",
" | Notes\n",
" | -----\n",
" | Mismatched indices will be unioned together\n",
" | \n",
" | Returns\n",
" | -------\n",
" | result : DataFrame\n",
" | \n",
" | __array__(self, dtype=None)\n",
" | \n",
" | __array_wrap__(self, result)\n",
" | \n",
" | __contains__(self, key)\n",
" | True if DataFrame has this column\n",
" | \n",
" | __div__(self, other, axis=None, level=None, fill_value=None)\n",
" | Binary operator __div__ with support to substitute a fill_value for missing data in\n",
" | one of the inputs\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | other : Series, DataFrame, or constant\n",
" | axis : {0, 1, 'index', 'columns'}\n",
" | For Series input, axis to match Series index on\n",
" | fill_value : None or float value, default None\n",
" | Fill missing (NaN) values with this value. If both DataFrame locations are\n",
" | missing, the result will be missing\n",
" | level : int or name\n",
" | Broadcast across a level, matching Index values on the\n",
" | passed MultiIndex level\n",
" | \n",
" | Notes\n",
" | -----\n",
" | Mismatched indices will be unioned together\n",
" | \n",
" | Returns\n",
" | -------\n",
" | result : DataFrame\n",
" | \n",
" | __eq__(self, other)\n",
" | Wrapper for comparison method __eq__\n",
" | \n",
" | __floordiv__(self, other, axis=None, level=None, fill_value=None)\n",
" | Binary operator __floordiv__ with support to substitute a fill_value for missing data in\n",
" | one of the inputs\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | other : Series, DataFrame, or constant\n",
" | axis : {0, 1, 'index', 'columns'}\n",
" | For Series input, axis to match Series index on\n",
" | fill_value : None or float value, default None\n",
" | Fill missing (NaN) values with this value. If both DataFrame locations are\n",
" | missing, the result will be missing\n",
" | level : int or name\n",
" | Broadcast across a level, matching Index values on the\n",
" | passed MultiIndex level\n",
" | \n",
" | Notes\n",
" | -----\n",
" | Mismatched indices will be unioned together\n",
" | \n",
" | Returns\n",
" | -------\n",
" | result : DataFrame\n",
" | \n",
" | __ge__(self, other)\n",
" | Wrapper for comparison method __ge__\n",
" | \n",
" | __getattr__(self, name)\n",
" | After regular attribute access, try looking up the name of a column.\n",
" | This allows simpler access to columns for interactive use.\n",
" | \n",
" | __getstate__(self)\n",
" | \n",
" | __gt__(self, other)\n",
" | Wrapper for comparison method __gt__\n",
" | \n",
" | __invert__(self)\n",
" | \n",
" | __iter__(self)\n",
" | Iterate over columns of the frame.\n",
" | \n",
" | __le__(self, other)\n",
" | Wrapper for comparison method __le__\n",
" | \n",
" | __len__(self)\n",
" | Returns length of index\n",
" | \n",
" | __lt__(self, other)\n",
" | Wrapper for comparison method __lt__\n",
" | \n",
" | __mod__(self, other, axis=None, level=None, fill_value=None)\n",
" | Binary operator __mod__ with support to substitute a fill_value for missing data in\n",
" | one of the inputs\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | other : Series, DataFrame, or constant\n",
" | axis : {0, 1, 'index', 'columns'}\n",
" | For Series input, axis to match Series index on\n",
" | fill_value : None or float value, default None\n",
" | Fill missing (NaN) values with this value. If both DataFrame locations are\n",
" | missing, the result will be missing\n",
" | level : int or name\n",
" | Broadcast across a level, matching Index values on the\n",
" | passed MultiIndex level\n",
" | \n",
" | Notes\n",
" | -----\n",
" | Mismatched indices will be unioned together\n",
" | \n",
" | Returns\n",
" | -------\n",
" | result : DataFrame\n",
" | \n",
" | __mul__(self, other, axis=None, level=None, fill_value=None)\n",
" | Binary operator __mul__ with support to substitute a fill_value for missing data in\n",
" | one of the inputs\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | other : Series, DataFrame, or constant\n",
" | axis : {0, 1, 'index', 'columns'}\n",
" | For Series input, axis to match Series index on\n",
" | fill_value : None or float value, default None\n",
" | Fill missing (NaN) values with this value. If both DataFrame locations are\n",
" | missing, the result will be missing\n",
" | level : int or name\n",
" | Broadcast across a level, matching Index values on the\n",
" | passed MultiIndex level\n",
" | \n",
" | Notes\n",
" | -----\n",
" | Mismatched indices will be unioned together\n",
" | \n",
" | Returns\n",
" | -------\n",
" | result : DataFrame\n",
" | \n",
" | __ne__(self, other)\n",
" | Wrapper for comparison method __ne__\n",
" | \n",
" | __neg__(self)\n",
" | \n",
" | __or__(self, other, axis='columns', level=None, fill_value=None)\n",
" | Binary operator __or__ with support to substitute a fill_value for missing data in\n",
" | one of the inputs\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | other : Series, DataFrame, or constant\n",
" | axis : {0, 1, 'index', 'columns'}\n",
" | For Series input, axis to match Series index on\n",
" | fill_value : None or float value, default None\n",
" | Fill missing (NaN) values with this value. If both DataFrame locations are\n",
" | missing, the result will be missing\n",
" | level : int or name\n",
" | Broadcast across a level, matching Index values on the\n",
" | passed MultiIndex level\n",
" | \n",
" | Notes\n",
" | -----\n",
" | Mismatched indices will be unioned together\n",
" | \n",
" | Returns\n",
" | -------\n",
" | result : DataFrame\n",
" | \n",
" | __pow__(self, other, axis=None, level=None, fill_value=None)\n",
" | Binary operator __pow__ with support to substitute a fill_value for missing data in\n",
" | one of the inputs\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | other : Series, DataFrame, or constant\n",
" | axis : {0, 1, 'index', 'columns'}\n",
" | For Series input, axis to match Series index on\n",
" | fill_value : None or float value, default None\n",
" | Fill missing (NaN) values with this value. If both DataFrame locations are\n",
" | missing, the result will be missing\n",
" | level : int or name\n",
" | Broadcast across a level, matching Index values on the\n",
" | passed MultiIndex level\n",
" | \n",
" | Notes\n",
" | -----\n",
" | Mismatched indices will be unioned together\n",
" | \n",
" | Returns\n",
" | -------\n",
" | result : DataFrame\n",
" | \n",
" | __radd__(self, other, axis=None, level=None, fill_value=None)\n",
" | Binary operator __radd__ with support to substitute a fill_value for missing data in\n",
" | one of the inputs\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | other : Series, DataFrame, or constant\n",
" | axis : {0, 1, 'index', 'columns'}\n",
" | For Series input, axis to match Series index on\n",
" | fill_value : None or float value, default None\n",
" | Fill missing (NaN) values with this value. If both DataFrame locations are\n",
" | missing, the result will be missing\n",
" | level : int or name\n",
" | Broadcast across a level, matching Index values on the\n",
" | passed MultiIndex level\n",
" | \n",
" | Notes\n",
" | -----\n",
" | Mismatched indices will be unioned together\n",
" | \n",
" | Returns\n",
" | -------\n",
" | result : DataFrame\n",
" | \n",
" | __rdiv__(self, other, axis=None, level=None, fill_value=None)\n",
" | Binary operator __rdiv__ with support to substitute a fill_value for missing data in\n",
" | one of the inputs\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | other : Series, DataFrame, or constant\n",
" | axis : {0, 1, 'index', 'columns'}\n",
" | For Series input, axis to match Series index on\n",
" | fill_value : None or float value, default None\n",
" | Fill missing (NaN) values with this value. If both DataFrame locations are\n",
" | missing, the result will be missing\n",
" | level : int or name\n",
" | Broadcast across a level, matching Index values on the\n",
" | passed MultiIndex level\n",
" | \n",
" | Notes\n",
" | -----\n",
" | Mismatched indices will be unioned together\n",
" | \n",
" | Returns\n",
" | -------\n",
" | result : DataFrame\n",
" | \n",
" | __rfloordiv__(self, other, axis=None, level=None, fill_value=None)\n",
" | Binary operator __rfloordiv__ with support to substitute a fill_value for missing data in\n",
" | one of the inputs\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | other : Series, DataFrame, or constant\n",
" | axis : {0, 1, 'index', 'columns'}\n",
" | For Series input, axis to match Series index on\n",
" | fill_value : None or float value, default None\n",
" | Fill missing (NaN) values with this value. If both DataFrame locations are\n",
" | missing, the result will be missing\n",
" | level : int or name\n",
" | Broadcast across a level, matching Index values on the\n",
" | passed MultiIndex level\n",
" | \n",
" | Notes\n",
" | -----\n",
" | Mismatched indices will be unioned together\n",
" | \n",
" | Returns\n",
" | -------\n",
" | result : DataFrame\n",
" | \n",
" | __rmod__(self, other, axis=None, level=None, fill_value=None)\n",
" | Binary operator __rmod__ with support to substitute a fill_value for missing data in\n",
" | one of the inputs\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | other : Series, DataFrame, or constant\n",
" | axis : {0, 1, 'index', 'columns'}\n",
" | For Series input, axis to match Series index on\n",
" | fill_value : None or float value, default None\n",
" | Fill missing (NaN) values with this value. If both DataFrame locations are\n",
" | missing, the result will be missing\n",
" | level : int or name\n",
" | Broadcast across a level, matching Index values on the\n",
" | passed MultiIndex level\n",
" | \n",
" | Notes\n",
" | -----\n",
" | Mismatched indices will be unioned together\n",
" | \n",
" | Returns\n",
" | -------\n",
" | result : DataFrame\n",
" | \n",
" | __rmul__(self, other, axis=None, level=None, fill_value=None)\n",
" | Binary operator __rmul__ with support to substitute a fill_value for missing data in\n",
" | one of the inputs\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | other : Series, DataFrame, or constant\n",
" | axis : {0, 1, 'index', 'columns'}\n",
" | For Series input, axis to match Series index on\n",
" | fill_value : None or float value, default None\n",
" | Fill missing (NaN) values with this value. If both DataFrame locations are\n",
" | missing, the result will be missing\n",
" | level : int or name\n",
" | Broadcast across a level, matching Index values on the\n",
" | passed MultiIndex level\n",
" | \n",
" | Notes\n",
" | -----\n",
" | Mismatched indices will be unioned together\n",
" | \n",
" | Returns\n",
" | -------\n",
" | result : DataFrame\n",
" | \n",
" | __rpow__(self, other, axis=None, level=None, fill_value=None)\n",
" | Binary operator __rpow__ with support to substitute a fill_value for missing data in\n",
" | one of the inputs\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | other : Series, DataFrame, or constant\n",
" | axis : {0, 1, 'index', 'columns'}\n",
" | For Series input, axis to match Series index on\n",
" | fill_value : None or float value, default None\n",
" | Fill missing (NaN) values with this value. If both DataFrame locations are\n",
" | missing, the result will be missing\n",
" | level : int or name\n",
" | Broadcast across a level, matching Index values on the\n",
" | passed MultiIndex level\n",
" | \n",
" | Notes\n",
" | -----\n",
" | Mismatched indices will be unioned together\n",
" | \n",
" | Returns\n",
" | -------\n",
" | result : DataFrame\n",
" | \n",
" | __rsub__(self, other, axis=None, level=None, fill_value=None)\n",
" | Binary operator __rsub__ with support to substitute a fill_value for missing data in\n",
" | one of the inputs\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | other : Series, DataFrame, or constant\n",
" | axis : {0, 1, 'index', 'columns'}\n",
" | For Series input, axis to match Series index on\n",
" | fill_value : None or float value, default None\n",
" | Fill missing (NaN) values with this value. If both DataFrame locations are\n",
" | missing, the result will be missing\n",
" | level : int or name\n",
" | Broadcast across a level, matching Index values on the\n",
" | passed MultiIndex level\n",
" | \n",
" | Notes\n",
" | -----\n",
" | Mismatched indices will be unioned together\n",
" | \n",
" | Returns\n",
" | -------\n",
" | result : DataFrame\n",
" | \n",
" | __rtruediv__(self, other, axis=None, level=None, fill_value=None)\n",
" | Binary operator __rtruediv__ with support to substitute a fill_value for missing data in\n",
" | one of the inputs\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | other : Series, DataFrame, or constant\n",
" | axis : {0, 1, 'index', 'columns'}\n",
" | For Series input, axis to match Series index on\n",
" | fill_value : None or float value, default None\n",
" | Fill missing (NaN) values with this value. If both DataFrame locations are\n",
" | missing, the result will be missing\n",
" | level : int or name\n",
" | Broadcast across a level, matching Index values on the\n",
" | passed MultiIndex level\n",
" | \n",
" | Notes\n",
" | -----\n",
" | Mismatched indices will be unioned together\n",
" | \n",
" | Returns\n",
" | -------\n",
" | result : DataFrame\n",
" | \n",
" | __setitem__(self, key, value)\n",
" | \n",
" | __setstate__(self, state)\n",
" | \n",
" | __sub__(self, other, axis=None, level=None, fill_value=None)\n",
" | Binary operator __sub__ with support to substitute a fill_value for missing data in\n",
" | one of the inputs\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | other : Series, DataFrame, or constant\n",
" | axis : {0, 1, 'index', 'columns'}\n",
" | For Series input, axis to match Series index on\n",
" | fill_value : None or float value, default None\n",
" | Fill missing (NaN) values with this value. If both DataFrame locations are\n",
" | missing, the result will be missing\n",
" | level : int or name\n",
" | Broadcast across a level, matching Index values on the\n",
" | passed MultiIndex level\n",
" | \n",
" | Notes\n",
" | -----\n",
" | Mismatched indices will be unioned together\n",
" | \n",
" | Returns\n",
" | -------\n",
" | result : DataFrame\n",
" | \n",
" | __truediv__(self, other, axis=None, level=None, fill_value=None)\n",
" | Binary operator __truediv__ with support to substitute a fill_value for missing data in\n",
" | one of the inputs\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | other : Series, DataFrame, or constant\n",
" | axis : {0, 1, 'index', 'columns'}\n",
" | For Series input, axis to match Series index on\n",
" | fill_value : None or float value, default None\n",
" | Fill missing (NaN) values with this value. If both DataFrame locations are\n",
" | missing, the result will be missing\n",
" | level : int or name\n",
" | Broadcast across a level, matching Index values on the\n",
" | passed MultiIndex level\n",
" | \n",
" | Notes\n",
" | -----\n",
" | Mismatched indices will be unioned together\n",
" | \n",
" | Returns\n",
" | -------\n",
" | result : DataFrame\n",
" | \n",
" | __unicode__(self)\n",
" | Return a string representation for a particular DataFrame\n",
" | \n",
" | Invoked by unicode(df) in py2 only. Yields a Unicode String in both\n",
" | py2/py3.\n",
" | \n",
" | __xor__(self, other, axis='columns', level=None, fill_value=None)\n",
" | Binary operator __xor__ with support to substitute a fill_value for missing data in\n",
" | one of the inputs\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | other : Series, DataFrame, or constant\n",
" | axis : {0, 1, 'index', 'columns'}\n",
" | For Series input, axis to match Series index on\n",
" | fill_value : None or float value, default None\n",
" | Fill missing (NaN) values with this value. If both DataFrame locations are\n",
" | missing, the result will be missing\n",
" | level : int or name\n",
" | Broadcast across a level, matching Index values on the\n",
" | passed MultiIndex level\n",
" | \n",
" | Notes\n",
" | -----\n",
" | Mismatched indices will be unioned together\n",
" | \n",
" | Returns\n",
" | -------\n",
" | result : DataFrame\n",
" | \n",
" | add(self, other, axis='columns', level=None, fill_value=None)\n",
" | Binary operator add with support to substitute a fill_value for missing data in\n",
" | one of the inputs\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | other : Series, DataFrame, or constant\n",
" | axis : {0, 1, 'index', 'columns'}\n",
" | For Series input, axis to match Series index on\n",
" | fill_value : None or float value, default None\n",
" | Fill missing (NaN) values with this value. If both DataFrame locations are\n",
" | missing, the result will be missing\n",
" | level : int or name\n",
" | Broadcast across a level, matching Index values on the\n",
" | passed MultiIndex level\n",
" | \n",
" | Notes\n",
" | -----\n",
" | Mismatched indices will be unioned together\n",
" | \n",
" | Returns\n",
" | -------\n",
" | result : DataFrame\n",
" | \n",
" | align(self, other, join='outer', axis=None, level=None, copy=True, fill_value=nan, method=None, limit=None, fill_axis=0)\n",
" | Align two DataFrame object on their index and columns with the\n",
" | specified join method for each axis Index\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | other : DataFrame or Series\n",
" | join : {'outer', 'inner', 'left', 'right'}, default 'outer'\n",
" | axis : {0, 1, None}, default None\n",
" | Align on index (0), columns (1), or both (None)\n",
" | level : int or name\n",
" | Broadcast across a level, matching Index values on the\n",
" | passed MultiIndex level\n",
" | copy : boolean, default True\n",
" | Always returns new objects. If copy=False and no reindexing is\n",
" | required then original objects are returned.\n",
" | fill_value : scalar, default np.NaN\n",
" | Value to use for missing values. Defaults to NaN, but can be any\n",
" | \"compatible\" value\n",
" | method : str, default None\n",
" | limit : int, default None\n",
" | fill_axis : {0, 1}, default 0\n",
" | Filling axis, method and limit\n",
" | \n",
" | Returns\n",
" | -------\n",
" | (left, right) : (DataFrame, type of other)\n",
" | Aligned objects\n",
" | \n",
" | all(self, axis=0, bool_only=None, skipna=True, level=None)\n",
" | Return whether all elements are True over requested axis.\n",
" | %(na_action)s\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | axis : {0, 1}\n",
" | 0 for row-wise, 1 for column-wise\n",
" | skipna : boolean, default True\n",
" | Exclude NA/null values. If an entire row/column is NA, the result\n",
" | will be NA\n",
" | level : int, default None\n",
" | If the axis is a MultiIndex (hierarchical), count along a\n",
" | particular level, collapsing into a DataFrame\n",
" | bool_only : boolean, default None\n",
" | Only include boolean data.\n",
" | \n",
" | Returns\n",
" | -------\n",
" | any : Series (or DataFrame if level specified)\n",
" | \n",
" | any(self, axis=0, bool_only=None, skipna=True, level=None)\n",
" | Return whether any element is True over requested axis.\n",
" | %(na_action)s\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | axis : {0, 1}\n",
" | 0 for row-wise, 1 for column-wise\n",
" | skipna : boolean, default True\n",
" | Exclude NA/null values. If an entire row/column is NA, the result\n",
" | will be NA\n",
" | level : int, default None\n",
" | If the axis is a MultiIndex (hierarchical), count along a\n",
" | particular level, collapsing into a DataFrame\n",
" | bool_only : boolean, default None\n",
" | Only include boolean data.\n",
" | \n",
" | Returns\n",
" | -------\n",
" | any : Series (or DataFrame if level specified)\n",
" | \n",
" | append(self, other, ignore_index=False, verify_integrity=False)\n",
" | Append columns of other to end of this frame's columns and index,\n",
" | returning a new object. Columns not in this frame are added as new\n",
" | columns.\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | other : DataFrame or list of Series/dict-like objects\n",
" | ignore_index : boolean, default False\n",
" | If True do not use the index labels. Useful for gluing together\n",
" | record arrays\n",
" | verify_integrity : boolean, default False\n",
" | If True, raise Exception on creating index with duplicates\n",
" | \n",
" | Notes\n",
" | -----\n",
" | If a list of dict is passed and the keys are all contained in the\n",
" | DataFrame's index, the order of the columns in the resulting DataFrame\n",
" | will be unchanged\n",
" | \n",
" | Returns\n",
" | -------\n",
" | appended : DataFrame\n",
" | \n",
" | apply(self, func, axis=0, broadcast=False, raw=False, args=(), **kwds)\n",
" | Applies function along input axis of DataFrame. Objects passed to\n",
" | functions are Series objects having index either the DataFrame's index\n",
" | (axis=0) or the columns (axis=1). Return type depends on whether passed\n",
" | function aggregates\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | func : function\n",
" | Function to apply to each column\n",
" | axis : {0, 1}\n",
" | 0 : apply function to each column\n",
" | 1 : apply function to each row\n",
" | broadcast : bool, default False\n",
" | For aggregation functions, return object of same size with values\n",
" | propagated\n",
" | raw : boolean, default False\n",
" | If False, convert each row or column into a Series. If raw=True the\n",
" | passed function will receive ndarray objects instead. If you are\n",
" | just applying a NumPy reduction function this will achieve much\n",
" | better performance\n",
" | args : tuple\n",
" | Positional arguments to pass to function in addition to the\n",
" | array/series\n",
" | Additional keyword arguments will be passed as keywords to the function\n",
" | \n",
" | Examples\n",
" | --------\n",
" | >>> df.apply(numpy.sqrt) # returns DataFrame\n",
" | >>> df.apply(numpy.sum, axis=0) # equiv to df.sum(0)\n",
" | >>> df.apply(numpy.sum, axis=1) # equiv to df.sum(1)\n",
" | \n",
" | See also\n",
" | --------\n",
" | DataFrame.applymap: For elementwise operations\n",
" | \n",
" | Returns\n",
" | -------\n",
" | applied : Series or DataFrame\n",
" | \n",
" | applymap(self, func)\n",
" | Apply a function to a DataFrame that is intended to operate\n",
" | elementwise, i.e. like doing map(func, series) for each series in the\n",
" | DataFrame\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | func : function\n",
" | Python function, returns a single value from a single value\n",
" | \n",
" | Returns\n",
" | -------\n",
" | applied : DataFrame\n",
" | \n",
" | as_blocks(self, columns=None)\n",
" | Convert the frame to a dict of dtype -> DataFrames that each has a homogeneous dtype.\n",
" | are presented in sorted order unless a specific list of columns is\n",
" | provided.\n",
" | \n",
" | NOTE: the dtypes of the blocks WILL BE PRESERVED HERE (unlike in as_matrix)\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | columns : array-like\n",
" | Specific column order\n",
" | \n",
" | Returns\n",
" | -------\n",
" | values : a list of DataFrames\n",
" | \n",
" | as_matrix(self, columns=None)\n",
" | Convert the frame to its Numpy-array matrix representation. Columns\n",
" | are presented in sorted order unless a specific list of columns is\n",
" | provided.\n",
" | \n",
" | NOTE: the dtype will be a lower-common-denominator dtype (implicit upcasting)\n",
" | that is to say if the dtypes (even of numeric types) are mixed, the one that accomodates all will be chosen\n",
" | use this with care if you are not dealing with the blocks\n",
" | \n",
" | e.g. if the dtypes are float16,float32 -> float32\n",
" | float16,float32,float64 -> float64\n",
" | int32,uint8 -> int32\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | columns : array-like\n",
" | Specific column order\n",
" | \n",
" | Returns\n",
" | -------\n",
" | values : ndarray\n",
" | If the DataFrame is heterogeneous and contains booleans or objects,\n",
" | the result will be of dtype=object\n",
" | \n",
" | bfill(self, axis=0, inplace=False, limit=None)\n",
" | \n",
" | boxplot(self, column=None, by=None, ax=None, fontsize=None, rot=0, grid=True, **kwds)\n",
" | Make a box plot from DataFrame column/columns optionally grouped\n",
" | (stratified) by one or more columns\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | data : DataFrame\n",
" | column : column names or list of names, or vector\n",
" | Can be any valid input to groupby\n",
" | by : string or sequence\n",
" | Column in the DataFrame to group by\n",
" | ax : matplotlib axis object, default None\n",
" | fontsize : int or string\n",
" | rot : int, default None\n",
" | Rotation for ticks\n",
" | grid : boolean, default None (matlab style default)\n",
" | Axis grid lines\n",
" | \n",
" | Returns\n",
" | -------\n",
" | ax : matplotlib.axes.AxesSubplot\n",
" | \n",
" | clip(self, lower=None, upper=None)\n",
" | Trim values at input threshold(s)\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | lower : float, default None\n",
" | upper : float, default None\n",
" | \n",
" | Returns\n",
" | -------\n",
" | clipped : DataFrame\n",
" | \n",
" | clip_lower(self, threshold)\n",
" | Trim values below threshold\n",
" | \n",
" | Returns\n",
" | -------\n",
" | clipped : DataFrame\n",
" | \n",
" | clip_upper(self, threshold)\n",
" | Trim values above threshold\n",
" | \n",
" | Returns\n",
" | -------\n",
" | clipped : DataFrame\n",
" | \n",
" | combine(self, other, func, fill_value=None, overwrite=True)\n",
" | Add two DataFrame objects and do not propagate NaN values, so if for a\n",
" | (column, time) one frame is missing a value, it will default to the\n",
" | other frame's value (which might be NaN as well)\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | other : DataFrame\n",
" | func : function\n",
" | fill_value : scalar value\n",
" | overwrite : boolean, default True\n",
" | If True then overwrite values for common keys in the calling frame\n",
" | \n",
" | Returns\n",
" | -------\n",
" | result : DataFrame\n",
" | \n",
" | combineAdd(self, other)\n",
" | Add two DataFrame objects and do not propagate\n",
" | NaN values, so if for a (column, time) one frame is missing a\n",
" | value, it will default to the other frame's value (which might\n",
" | be NaN as well)\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | other : DataFrame\n",
" | \n",
" | Returns\n",
" | -------\n",
" | DataFrame\n",
" | \n",
" | combineMult(self, other)\n",
" | Multiply two DataFrame objects and do not propagate NaN values, so if\n",
" | for a (column, time) one frame is missing a value, it will default to\n",
" | the other frame's value (which might be NaN as well)\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | other : DataFrame\n",
" | \n",
" | Returns\n",
" | -------\n",
" | DataFrame\n",
" | \n",
" | combine_first(self, other)\n",
" | Combine two DataFrame objects and default to non-null values in frame\n",
" | calling the method. Result index columns will be the union of the\n",
" | respective indexes and columns\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | other : DataFrame\n",
" | \n",
" | Examples\n",
" | --------\n",
" | >>> a.combine_first(b)\n",
" | a's values prioritized, use values from b to fill holes\n",
" | \n",
" | Returns\n",
" | -------\n",
" | combined : DataFrame\n",
" | \n",
" | convert_objects(self, convert_dates=True, convert_numeric=False, copy=True)\n",
" | Attempt to infer better dtype for object columns\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | convert_dates : if True, attempt to soft convert_dates, if 'coerce', force conversion (and non-convertibles get NaT)\n",
" | convert_numeric : if True attempt to coerce to numerbers (including strings), non-convertibles get NaN\n",
" | copy : boolean, return a copy if True (True by default)\n",
" | \n",
" | Returns\n",
" | -------\n",
" | converted : DataFrame\n",
" | \n",
" | corr(self, method='pearson', min_periods=1)\n",
" | Compute pairwise correlation of columns, excluding NA/null values\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | method : {'pearson', 'kendall', 'spearman'}\n",
" | pearson : standard correlation coefficient\n",
" | kendall : Kendall Tau correlation coefficient\n",
" | spearman : Spearman rank correlation\n",
" | min_periods : int, optional\n",
" | Minimum number of observations required per pair of columns\n",
" | to have a valid result. Currently only available for pearson\n",
" | and spearman correlation\n",
" | \n",
" | Returns\n",
" | -------\n",
" | y : DataFrame\n",
" | \n",
" | corrwith(self, other, axis=0, drop=False)\n",
" | Compute pairwise correlation between rows or columns of two DataFrame\n",
" | objects.\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | other : DataFrame\n",
" | axis : {0, 1}\n",
" | 0 to compute column-wise, 1 for row-wise\n",
" | drop : boolean, default False\n",
" | Drop missing indices from result, default returns union of all\n",
" | \n",
" | Returns\n",
" | -------\n",
" | correls : Series\n",
" | \n",
" | count(self, axis=0, level=None, numeric_only=False)\n",
" | Return Series with number of non-NA/null observations over requested\n",
" | axis. Works with non-floating point data as well (detects NaN and None)\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | axis : {0, 1}\n",
" | 0 for row-wise, 1 for column-wise\n",
" | level : int, default None\n",
" | If the axis is a MultiIndex (hierarchical), count along a\n",
" | particular level, collapsing into a DataFrame\n",
" | numeric_only : boolean, default False\n",
" | Include only float, int, boolean data\n",
" | \n",
" | Returns\n",
" | -------\n",
" | count : Series (or DataFrame if level specified)\n",
" | \n",
" | cov(self, min_periods=None)\n",
" | Compute pairwise covariance of columns, excluding NA/null values\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | min_periods : int, optional\n",
" | Minimum number of observations required per pair of columns\n",
" | to have a valid result.\n",
" | \n",
" | Returns\n",
" | -------\n",
" | y : DataFrame\n",
" | \n",
" | y contains the covariance matrix of the DataFrame's time series.\n",
" | The covariance is normalized by N-1 (unbiased estimator).\n",
" | \n",
" | delevel = wrapper(*args, **kwargs)\n",
" | \n",
" | describe(self, percentile_width=50)\n",
" | Generate various summary statistics of each column, excluding\n",
" | NaN values. These include: count, mean, std, min, max, and\n",
" | lower%/50%/upper% percentiles\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | percentile_width : float, optional\n",
" | width of the desired uncertainty interval, default is 50,\n",
" | which corresponds to lower=25, upper=75\n",
" | \n",
" | Returns\n",
" | -------\n",
" | DataFrame of summary statistics\n",
" | \n",
" | diff(self, periods=1)\n",
" | 1st discrete difference of object\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | periods : int, default 1\n",
" | Periods to shift for forming difference\n",
" | \n",
" | Returns\n",
" | -------\n",
" | diffed : DataFrame\n",
" | \n",
" | div = divide(self, other, axis='columns', level=None, fill_value=None)\n",
" | Binary operator divide with support to substitute a fill_value for missing data in\n",
" | one of the inputs\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | other : Series, DataFrame, or constant\n",
" | axis : {0, 1, 'index', 'columns'}\n",
" | For Series input, axis to match Series index on\n",
" | fill_value : None or float value, default None\n",
" | Fill missing (NaN) values with this value. If both DataFrame locations are\n",
" | missing, the result will be missing\n",
" | level : int or name\n",
" | Broadcast across a level, matching Index values on the\n",
" | passed MultiIndex level\n",
" | \n",
" | Notes\n",
" | -----\n",
" | Mismatched indices will be unioned together\n",
" | \n",
" | Returns\n",
" | -------\n",
" | result : DataFrame\n",
" | \n",
" | divide(self, other, axis='columns', level=None, fill_value=None)\n",
" | Binary operator divide with support to substitute a fill_value for missing data in\n",
" | one of the inputs\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | other : Series, DataFrame, or constant\n",
" | axis : {0, 1, 'index', 'columns'}\n",
" | For Series input, axis to match Series index on\n",
" | fill_value : None or float value, default None\n",
" | Fill missing (NaN) values with this value. If both DataFrame locations are\n",
" | missing, the result will be missing\n",
" | level : int or name\n",
" | Broadcast across a level, matching Index values on the\n",
" | passed MultiIndex level\n",
" | \n",
" | Notes\n",
" | -----\n",
" | Mismatched indices will be unioned together\n",
" | \n",
" | Returns\n",
" | -------\n",
" | result : DataFrame\n",
" | \n",
" | dot(self, other)\n",
" | Matrix multiplication with DataFrame or Series objects\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | other : DataFrame or Series\n",
" | \n",
" | Returns\n",
" | -------\n",
" | dot_product : DataFrame or Series\n",
" | \n",
" | drop_duplicates(self, cols=None, take_last=False, inplace=False)\n",
" | Return DataFrame with duplicate rows removed, optionally only\n",
" | considering certain columns\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | cols : column label or sequence of labels, optional\n",
" | Only consider certain columns for identifying duplicates, by\n",
" | default use all of the columns\n",
" | take_last : boolean, default False\n",
" | Take the last observed row in a row. Defaults to the first row\n",
" | inplace : boolean, default False\n",
" | Whether to drop duplicates in place or to return a copy\n",
" | \n",
" | Returns\n",
" | -------\n",
" | deduplicated : DataFrame\n",
" | \n",
" | dropna(self, axis=0, how='any', thresh=None, subset=None)\n",
" | Return object with labels on given axis omitted where alternately any\n",
" | or all of the data are missing\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | axis : {0, 1}, or tuple/list thereof\n",
" | Pass tuple or list to drop on multiple axes\n",
" | how : {'any', 'all'}\n",
" | any : if any NA values are present, drop that label\n",
" | all : if all values are NA, drop that label\n",
" | thresh : int, default None\n",
" | int value : require that many non-NA values\n",
" | subset : array-like\n",
" | Labels along other axis to consider, e.g. if you are dropping rows\n",
" | these would be a list of columns to include\n",
" | \n",
" | Returns\n",
" | -------\n",
" | dropped : DataFrame\n",
" | \n",
" | duplicated(self, cols=None, take_last=False)\n",
" | Return boolean Series denoting duplicate rows, optionally only\n",
" | considering certain columns\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | cols : column label or sequence of labels, optional\n",
" | Only consider certain columns for identifying duplicates, by\n",
" | default use all of the columns\n",
" | take_last : boolean, default False\n",
" | Take the last observed row in a row. Defaults to the first row\n",
" | \n",
" | Returns\n",
" | -------\n",
" | duplicated : Series\n",
" | \n",
" | eq(self, other, axis='columns', level=None)\n",
" | Wrapper for flexible comparison methods eq\n",
" | \n",
" | ffill(self, axis=0, inplace=False, limit=None)\n",
" | \n",
" | fillna(self, value=None, method=None, axis=0, inplace=False, limit=None, downcast=None)\n",
" | Fill NA/NaN values using the specified method\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | method : {'backfill', 'bfill', 'pad', 'ffill', None}, default None\n",
" | Method to use for filling holes in reindexed Series\n",
" | pad / ffill: propagate last valid observation forward to next valid\n",
" | backfill / bfill: use NEXT valid observation to fill gap\n",
" | value : scalar or dict\n",
" | Value to use to fill holes (e.g. 0), alternately a dict of values\n",
" | specifying which value to use for each column (columns not in the\n",
" | dict will not be filled). This value cannot be a list.\n",
" | axis : {0, 1}, default 0\n",
" | 0: fill column-by-column\n",
" | 1: fill row-by-row\n",
" | inplace : boolean, default False\n",
" | If True, fill the DataFrame in place. Note: this will modify any\n",
" | other views on this DataFrame, like if you took a no-copy slice of\n",
" | an existing DataFrame, for example a column in a DataFrame. Returns\n",
" | a reference to the filled object, which is self if inplace=True\n",
" | limit : int, default None\n",
" | Maximum size gap to forward or backward fill\n",
" | downcast : dict, default is None, a dict of item->dtype of what to\n",
" | downcast if possible\n",
" | \n",
" | See also\n",
" | --------\n",
" | reindex, asfreq\n",
" | \n",
" | Returns\n",
" | -------\n",
" | filled : DataFrame\n",
" | \n",
" | filter(self, items=None, like=None, regex=None)\n",
" | Restrict frame's columns to set of items or wildcard\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | items : list-like\n",
" | List of columns to restrict to (must not all be present)\n",
" | like : string\n",
" | Keep columns where \"arg in col == True\"\n",
" | regex : string (regular expression)\n",
" | Keep columns with re.search(regex, col) == True\n",
" | \n",
" | Notes\n",
" | -----\n",
" | Arguments are mutually exclusive, but this is not checked for\n",
" | \n",
" | Returns\n",
" | -------\n",
" | DataFrame with filtered columns\n",
" | \n",
" | first_valid_index(self)\n",
" | Return label for first non-NA/null value\n",
" | \n",
" | ge(self, other, axis='columns', level=None)\n",
" | Wrapper for flexible comparison methods ge\n",
" | \n",
" | get_value(self, index, col)\n",
" | Quickly retrieve single value at passed column and index\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | index : row label\n",
" | col : column label\n",
" | \n",
" | Returns\n",
" | -------\n",
" | value : scalar value\n",
" | \n",
" | gt(self, other, axis='columns', level=None)\n",
" | Wrapper for flexible comparison methods gt\n",
" | \n",
" | head(self, n=5)\n",
" | Returns first n rows of DataFrame\n",
" | \n",
" | hist = hist_frame(data, column=None, by=None, grid=True, xlabelsize=None, xrot=None, ylabelsize=None, yrot=None, ax=None, sharex=False, sharey=False, figsize=None, layout=None, **kwds)\n",
" | Draw Histogram the DataFrame's series using matplotlib / pylab.\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | data : DataFrame\n",
" | column : string or sequence\n",
" | If passed, will be used to limit data to a subset of columns\n",
" | by : object, optional\n",
" | If passed, then used to form histograms for separate groups\n",
" | grid : boolean, default True\n",
" | Whether to show axis grid lines\n",
" | xlabelsize : int, default None\n",
" | If specified changes the x-axis label size\n",
" | xrot : float, default None\n",
" | rotation of x axis labels\n",
" | ylabelsize : int, default None\n",
" | If specified changes the y-axis label size\n",
" | yrot : float, default None\n",
" | rotation of y axis labels\n",
" | ax : matplotlib axes object, default None\n",
" | sharex : bool, if True, the X axis will be shared amongst all subplots.\n",
" | sharey : bool, if True, the Y axis will be shared amongst all subplots.\n",
" | figsize : tuple\n",
" | The size of the figure to create in inches by default\n",
" | layout: (optional) a tuple (rows, columns) for the layout of the histograms\n",
" | kwds : other plotting keyword arguments\n",
" | To be passed to hist function\n",
" | \n",
" | icol(self, i)\n",
" | \n",
" | idxmax(self, axis=0, skipna=True)\n",
" | Return index of first occurrence of maximum over requested axis.\n",
" | NA/null values are excluded.\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | axis : {0, 1}\n",
" | 0 for row-wise, 1 for column-wise\n",
" | skipna : boolean, default True\n",
" | Exclude NA/null values. If an entire row/column is NA, the result\n",
" | will be first index.\n",
" | \n",
" | Returns\n",
" | -------\n",
" | idxmax : Series\n",
" | \n",
" | Notes\n",
" | -----\n",
" | This method is the DataFrame version of ``ndarray.argmax``.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | Series.idxmax\n",
" | \n",
" | idxmin(self, axis=0, skipna=True)\n",
" | Return index of first occurrence of minimum over requested axis.\n",
" | NA/null values are excluded.\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | axis : {0, 1}\n",
" | 0 for row-wise, 1 for column-wise\n",
" | skipna : boolean, default True\n",
" | Exclude NA/null values. If an entire row/column is NA, the result\n",
" | will be NA\n",
" | \n",
" | Returns\n",
" | -------\n",
" | idxmin : Series\n",
" | \n",
" | Notes\n",
" | -----\n",
" | This method is the DataFrame version of ``ndarray.argmin``.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | Series.idxmin\n",
" | \n",
" | iget_value(self, i, j)\n",
" | \n",
" | info(self, verbose=True, buf=None, max_cols=None)\n",
" | Concise summary of a DataFrame, used in __repr__ when very large.\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | verbose : boolean, default True\n",
" | If False, don't print column count summary\n",
" | buf : writable buffer, defaults to sys.stdout\n",
" | max_cols : int, default None\n",
" | Determines whether full summary or short summary is printed\n",
" | \n",
" | insert(self, loc, column, value, allow_duplicates=False)\n",
" | Insert column into DataFrame at specified location.\n",
" | if allow_duplicates is False, Raises Exception if column is already contained in the DataFrame\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | loc : int\n",
" | Must have 0 <= loc <= len(columns)\n",
" | column : object\n",
" | value : int, Series, or array-like\n",
" | \n",
" | irow(self, i, copy=False)\n",
" | \n",
" | iteritems(self)\n",
" | Iterator over (column, series) pairs\n",
" | \n",
" | iterkv = iteritems(self)\n",
" | Iterator over (column, series) pairs\n",
" | \n",
" | iterrows(self)\n",
" | Iterate over rows of DataFrame as (index, Series) pairs.\n",
" | \n",
" | Notes\n",
" | -----\n",
" | \n",
" | * ``iterrows`` does **not** preserve dtypes across the rows (dtypes\n",
" | are preserved across columns for DataFrames). For example,\n",
" | \n",
" | >>> df = DataFrame([[1, 1.0]], columns=['x', 'y'])\n",
" | >>> row = next(df.iterrows())[1]\n",
" | >>> print row['x'].dtype\n",
" | float64\n",
" | >>> print df['x'].dtype\n",
" | int64\n",
" | \n",
" | Returns\n",
" | -------\n",
" | it : generator\n",
" | A generator that iterates over the rows of the frame.\n",
" | \n",
" | itertuples(self, index=True)\n",
" | Iterate over rows of DataFrame as tuples, with index value\n",
" | as first element of the tuple\n",
" | \n",
" | join(self, other, on=None, how='left', lsuffix='', rsuffix='', sort=False)\n",
" | Join columns with other DataFrame either on index or on a key\n",
" | column. Efficiently Join multiple DataFrame objects by index at once by\n",
" | passing a list.\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | other : DataFrame, Series with name field set, or list of DataFrame\n",
" | Index should be similar to one of the columns in this one. If a\n",
" | Series is passed, its name attribute must be set, and that will be\n",
" | used as the column name in the resulting joined DataFrame\n",
" | on : column name, tuple/list of column names, or array-like\n",
" | Column(s) to use for joining, otherwise join on index. If multiples\n",
" | columns given, the passed DataFrame must have a MultiIndex. Can\n",
" | pass an array as the join key if not already contained in the\n",
" | calling DataFrame. Like an Excel VLOOKUP operation\n",
" | how : {'left', 'right', 'outer', 'inner'}\n",
" | How to handle indexes of the two objects. Default: 'left'\n",
" | for joining on index, None otherwise\n",
" | * left: use calling frame's index\n",
" | * right: use input frame's index\n",
" | * outer: form union of indexes\n",
" | * inner: use intersection of indexes\n",
" | lsuffix : string\n",
" | Suffix to use from left frame's overlapping columns\n",
" | rsuffix : string\n",
" | Suffix to use from right frame's overlapping columns\n",
" | sort : boolean, default False\n",
" | Order result DataFrame lexicographically by the join key. If False,\n",
" | preserves the index order of the calling (left) DataFrame\n",
" | \n",
" | Notes\n",
" | -----\n",
" | on, lsuffix, and rsuffix options are not supported when passing a list\n",
" | of DataFrame objects\n",
" | \n",
" | Returns\n",
" | -------\n",
" | joined : DataFrame\n",
" | \n",
" | keys(self)\n",
" | \n",
" | kurt(self, axis=0, skipna=True, level=None)\n",
" | Return unbiased kurtosis over requested axis.\n",
" | NA/null values are excluded\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | axis : {0, 1}\n",
" | 0 for row-wise, 1 for column-wise\n",
" | skipna : boolean, default True\n",
" | Exclude NA/null values. If an entire row/column is NA, the result\n",
" | will be NA\n",
" | level : int, default None\n",
" | If the axis is a MultiIndex (hierarchical), count along a\n",
" | particular level, collapsing into a DataFrame\n",
" | \n",
" | Returns\n",
" | -------\n",
" | kurt : Series (or DataFrame if level specified)\n",
" | \n",
" | last_valid_index(self)\n",
" | Return label for last non-NA/null value\n",
" | \n",
" | le(self, other, axis='columns', level=None)\n",
" | Wrapper for flexible comparison methods le\n",
" | \n",
" | lookup(self, row_labels, col_labels)\n",
" | Label-based \"fancy indexing\" function for DataFrame. Given\n",
" | equal-length arrays of row and column labels, return an array of the\n",
" | values corresponding to each (row, col) pair.\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | row_labels : sequence\n",
" | The row labels to use for lookup\n",
" | col_labels : sequence\n",
" | The column labels to use for lookup\n",
" | \n",
" | Notes\n",
" | -----\n",
" | Akin to\n",
" | \n",
" | .. code-block:: python\n",
" | \n",
" | result = []\n",
" | for row, col in zip(row_labels, col_labels):\n",
" | result.append(df.get_value(row, col))\n",
" | \n",
" | Examples\n",
" | --------\n",
" | values : ndarray\n",
" | The found values\n",
" | \n",
" | lt(self, other, axis='columns', level=None)\n",
" | Wrapper for flexible comparison methods lt\n",
" | \n",
" | mad(self, axis=0, skipna=True, level=None)\n",
" | Return mean absolute deviation over requested axis.\n",
" | NA/null values are excluded\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | axis : {0, 1}\n",
" | 0 for row-wise, 1 for column-wise\n",
" | skipna : boolean, default True\n",
" | Exclude NA/null values. If an entire row/column is NA, the result\n",
" | will be NA\n",
" | level : int, default None\n",
" | If the axis is a MultiIndex (hierarchical), count along a\n",
" | particular level, collapsing into a DataFrame\n",
" | \n",
" | Returns\n",
" | -------\n",
" | mad : Series (or DataFrame if level specified)\n",
" | \n",
" | mask(self, cond)\n",
" | Returns copy of self whose values are replaced with nan if the\n",
" | inverted condition is True\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | cond: boolean DataFrame or array\n",
" | \n",
" | Returns\n",
" | -------\n",
" | wh: DataFrame\n",
" | \n",
" | max(self, axis=0, skipna=True, level=None)\n",
" | Notes\n",
" | -----\n",
" | This method returns the maximum of the values in the DataFrame. If you\n",
" | want the *index* of the maximum, use ``DataFrame.idxmax``. This is the\n",
" | equivalent of the ``numpy.ndarray`` method ``argmax``.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | DataFrame.idxmax\n",
" | Series.idxmax\n",
" | \n",
" | Return maximum over requested axis.\n",
" | NA/null values are excluded\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | axis : {0, 1}\n",
" | 0 for row-wise, 1 for column-wise\n",
" | skipna : boolean, default True\n",
" | Exclude NA/null values. If an entire row/column is NA, the result\n",
" | will be NA\n",
" | level : int, default None\n",
" | If the axis is a MultiIndex (hierarchical), count along a\n",
" | particular level, collapsing into a DataFrame\n",
" | \n",
" | Returns\n",
" | -------\n",
" | max : Series (or DataFrame if level specified)\n",
" | \n",
" | mean(self, axis=0, skipna=True, level=None)\n",
" | Return mean over requested axis.\n",
" | NA/null values are excluded\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | axis : {0, 1}\n",
" | 0 for row-wise, 1 for column-wise\n",
" | skipna : boolean, default True\n",
" | Exclude NA/null values. If an entire row/column is NA, the result\n",
" | will be NA\n",
" | level : int, default None\n",
" | If the axis is a MultiIndex (hierarchical), count along a\n",
" | particular level, collapsing into a DataFrame\n",
" | \n",
" | Returns\n",
" | -------\n",
" | mean : Series (or DataFrame if level specified)\n",
" | \n",
" | median(self, axis=0, skipna=True, level=None)\n",
" | Return median over requested axis.\n",
" | NA/null values are excluded\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | axis : {0, 1}\n",
" | 0 for row-wise, 1 for column-wise\n",
" | skipna : boolean, default True\n",
" | Exclude NA/null values. If an entire row/column is NA, the result\n",
" | will be NA\n",
" | level : int, default None\n",
" | If the axis is a MultiIndex (hierarchical), count along a\n",
" | particular level, collapsing into a DataFrame\n",
" | \n",
" | Returns\n",
" | -------\n",
" | median : Series (or DataFrame if level specified)\n",
" | \n",
" | merge(self, right, how='inner', on=None, left_on=None, right_on=None, left_index=False, right_index=False, sort=False, suffixes=('_x', '_y'), copy=True)\n",
" | Merge DataFrame objects by performing a database-style join operation by\n",
" | columns or indexes.\n",
" | \n",
" | If joining columns on columns, the DataFrame indexes *will be\n",
" | ignored*. Otherwise if joining indexes on indexes or indexes on a column or\n",
" | columns, the index will be passed on.\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | right : DataFrame\n",
" | how : {'left', 'right', 'outer', 'inner'}, default 'inner'\n",
" | * left: use only keys from left frame (SQL: left outer join)\n",
" | * right: use only keys from right frame (SQL: right outer join)\n",
" | * outer: use union of keys from both frames (SQL: full outer join)\n",
" | * inner: use intersection of keys from both frames (SQL: inner join)\n",
" | on : label or list\n",
" | Field names to join on. Must be found in both DataFrames. If on is\n",
" | None and not merging on indexes, then it merges on the intersection of\n",
" | the columns by default.\n",
" | left_on : label or list, or array-like\n",
" | Field names to join on in left DataFrame. Can be a vector or list of\n",
" | vectors of the length of the DataFrame to use a particular vector as\n",
" | the join key instead of columns\n",
" | right_on : label or list, or array-like\n",
" | Field names to join on in right DataFrame or vector/list of vectors per\n",
" | left_on docs\n",
" | left_index : boolean, default False\n",
" | Use the index from the left DataFrame as the join key(s). If it is a\n",
" | MultiIndex, the number of keys in the other DataFrame (either the index\n",
" | or a number of columns) must match the number of levels\n",
" | right_index : boolean, default False\n",
" | Use the index from the right DataFrame as the join key. Same caveats as\n",
" | left_index\n",
" | sort : boolean, default False\n",
" | Sort the join keys lexicographically in the result DataFrame\n",
" | suffixes : 2-length sequence (tuple, list, ...)\n",
" | Suffix to apply to overlapping column names in the left and right\n",
" | side, respectively\n",
" | copy : boolean, default True\n",
" | If False, do not copy data unnecessarily\n",
" | \n",
" | Examples\n",
" | --------\n",
" | \n",
" | >>> A >>> B\n",
" | lkey value rkey value\n",
" | 0 foo 1 0 foo 5\n",
" | 1 bar 2 1 bar 6\n",
" | 2 baz 3 2 qux 7\n",
" | 3 foo 4 3 bar 8\n",
" | \n",
" | >>> merge(A, B, left_on='lkey', right_on='rkey', how='outer')\n",
" | lkey value_x rkey value_y\n",
" | 0 bar 2 bar 6\n",
" | 1 bar 2 bar 8\n",
" | 2 baz 3 NaN NaN\n",
" | 3 foo 1 foo 5\n",
" | 4 foo 4 foo 5\n",
" | 5 NaN NaN qux 7\n",
" | \n",
" | Returns\n",
" | -------\n",
" | merged : DataFrame\n",
" | \n",
" | min(self, axis=0, skipna=True, level=None)\n",
" | Notes\n",
" | -----\n",
" | This method returns the minimum of the values in the DataFrame. If you\n",
" | want the *index* of the minimum, use ``DataFrame.idxmin``. This is the\n",
" | equivalent of the ``numpy.ndarray`` method ``argmin``.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | DataFrame.idxmin\n",
" | Series.idxmin\n",
" | \n",
" | Return minimum over requested axis.\n",
" | NA/null values are excluded\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | axis : {0, 1}\n",
" | 0 for row-wise, 1 for column-wise\n",
" | skipna : boolean, default True\n",
" | Exclude NA/null values. If an entire row/column is NA, the result\n",
" | will be NA\n",
" | level : int, default None\n",
" | If the axis is a MultiIndex (hierarchical), count along a\n",
" | particular level, collapsing into a DataFrame\n",
" | \n",
" | Returns\n",
" | -------\n",
" | min : Series (or DataFrame if level specified)\n",
" | \n",
" | mod(self, other, axis='columns', level=None, fill_value=None)\n",
" | Binary operator mod with support to substitute a fill_value for missing data in\n",
" | one of the inputs\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | other : Series, DataFrame, or constant\n",
" | axis : {0, 1, 'index', 'columns'}\n",
" | For Series input, axis to match Series index on\n",
" | fill_value : None or float value, default None\n",
" | Fill missing (NaN) values with this value. If both DataFrame locations are\n",
" | missing, the result will be missing\n",
" | level : int or name\n",
" | Broadcast across a level, matching Index values on the\n",
" | passed MultiIndex level\n",
" | \n",
" | Notes\n",
" | -----\n",
" | Mismatched indices will be unioned together\n",
" | \n",
" | Returns\n",
" | -------\n",
" | result : DataFrame\n",
" | \n",
" | mul = multiply(self, other, axis='columns', level=None, fill_value=None)\n",
" | Binary operator multiply with support to substitute a fill_value for missing data in\n",
" | one of the inputs\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | other : Series, DataFrame, or constant\n",
" | axis : {0, 1, 'index', 'columns'}\n",
" | For Series input, axis to match Series index on\n",
" | fill_value : None or float value, default None\n",
" | Fill missing (NaN) values with this value. If both DataFrame locations are\n",
" | missing, the result will be missing\n",
" | level : int or name\n",
" | Broadcast across a level, matching Index values on the\n",
" | passed MultiIndex level\n",
" | \n",
" | Notes\n",
" | -----\n",
" | Mismatched indices will be unioned together\n",
" | \n",
" | Returns\n",
" | -------\n",
" | result : DataFrame\n",
" | \n",
" | ne(self, other, axis='columns', level=None)\n",
" | Wrapper for flexible comparison methods ne\n",
" | \n",
" | pivot(self, index=None, columns=None, values=None)\n",
" | Reshape data (produce a \"pivot\" table) based on column values. Uses\n",
" | unique values from index / columns to form axes and return either\n",
" | DataFrame or Panel, depending on whether you request a single value\n",
" | column (DataFrame) or all columns (Panel)\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | index : string or object\n",
" | Column name to use to make new frame's index\n",
" | columns : string or object\n",
" | Column name to use to make new frame's columns\n",
" | values : string or object, optional\n",
" | Column name to use for populating new frame's values\n",
" | \n",
" | Notes\n",
" | -----\n",
" | For finer-tuned control, see hierarchical indexing documentation along\n",
" | with the related stack/unstack methods\n",
" | \n",
" | Examples\n",
" | --------\n",
" | >>> df\n",
" | foo bar baz\n",
" | 0 one A 1.\n",
" | 1 one B 2.\n",
" | 2 one C 3.\n",
" | 3 two A 4.\n",
" | 4 two B 5.\n",
" | 5 two C 6.\n",
" | \n",
" | >>> df.pivot('foo', 'bar', 'baz')\n",
" | A B C\n",
" | one 1 2 3\n",
" | two 4 5 6\n",
" | \n",
" | >>> df.pivot('foo', 'bar')['baz']\n",
" | A B C\n",
" | one 1 2 3\n",
" | two 4 5 6\n",
" | \n",
" | Returns\n",
" | -------\n",
" | pivoted : DataFrame\n",
" | If no values column specified, will have hierarchically indexed\n",
" | columns\n",
" | \n",
" | pivot_table(data, values=None, rows=None, cols=None, aggfunc='mean', fill_value=None, margins=False, dropna=True)\n",
" | Create a spreadsheet-style pivot table as a DataFrame. The levels in the\n",
" | pivot table will be stored in MultiIndex objects (hierarchical indexes) on\n",
" | the index and columns of the result DataFrame\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | data : DataFrame\n",
" | values : column to aggregate, optional\n",
" | rows : list of column names or arrays to group on\n",
" | Keys to group on the x-axis of the pivot table\n",
" | cols : list of column names or arrays to group on\n",
" | Keys to group on the y-axis of the pivot table\n",
" | aggfunc : function, default numpy.mean, or list of functions\n",
" | If list of functions passed, the resulting pivot table will have\n",
" | hierarchical columns whose top level are the function names (inferred\n",
" | from the function objects themselves)\n",
" | fill_value : scalar, default None\n",
" | Value to replace missing values with\n",
" | margins : boolean, default False\n",
" | Add all row / columns (e.g. for subtotal / grand totals)\n",
" | dropna : boolean, default True\n",
" | Do not include columns whose entries are all NaN\n",
" | \n",
" | Examples\n",
" | --------\n",
" | >>> df\n",
" | A B C D\n",
" | 0 foo one small 1\n",
" | 1 foo one large 2\n",
" | 2 foo one large 2\n",
" | 3 foo two small 3\n",
" | 4 foo two small 3\n",
" | 5 bar one large 4\n",
" | 6 bar one small 5\n",
" | 7 bar two small 6\n",
" | 8 bar two large 7\n",
" | \n",
" | >>> table = pivot_table(df, values='D', rows=['A', 'B'],\n",
" | ... cols=['C'], aggfunc=np.sum)\n",
" | >>> table\n",
" | small large\n",
" | foo one 1 4\n",
" | two 6 NaN\n",
" | bar one 5 4\n",
" | two 6 7\n",
" | \n",
" | Returns\n",
" | -------\n",
" | table : DataFrame\n",
" | \n",
" | pop(self, item)\n",
" | Return column and drop from frame. Raise KeyError if not found.\n",
" | \n",
" | Returns\n",
" | -------\n",
" | column : Series\n",
" | \n",
" | pow(self, other, axis='columns', level=None, fill_value=None)\n",
" | Binary operator pow with support to substitute a fill_value for missing data in\n",
" | one of the inputs\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | other : Series, DataFrame, or constant\n",
" | axis : {0, 1, 'index', 'columns'}\n",
" | For Series input, axis to match Series index on\n",
" | fill_value : None or float value, default None\n",
" | Fill missing (NaN) values with this value. If both DataFrame locations are\n",
" | missing, the result will be missing\n",
" | level : int or name\n",
" | Broadcast across a level, matching Index values on the\n",
" | passed MultiIndex level\n",
" | \n",
" | Notes\n",
" | -----\n",
" | Mismatched indices will be unioned together\n",
" | \n",
" | Returns\n",
" | -------\n",
" | result : DataFrame\n",
" | \n",
" | prod(self, axis=0, skipna=True, level=None)\n",
" | Return product over requested axis.\n",
" | NA/null values are treated as 1\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | axis : {0, 1}\n",
" | 0 for row-wise, 1 for column-wise\n",
" | skipna : boolean, default True\n",
" | Exclude NA/null values. If an entire row/column is NA, the result\n",
" | will be NA\n",
" | level : int, default None\n",
" | If the axis is a MultiIndex (hierarchical), count along a\n",
" | particular level, collapsing into a DataFrame\n",
" | \n",
" | Returns\n",
" | -------\n",
" | product : Series (or DataFrame if level specified)\n",
" | \n",
" | product = prod(self, axis=0, skipna=True, level=None)\n",
" | Return product over requested axis.\n",
" | NA/null values are treated as 1\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | axis : {0, 1}\n",
" | 0 for row-wise, 1 for column-wise\n",
" | skipna : boolean, default True\n",
" | Exclude NA/null values. If an entire row/column is NA, the result\n",
" | will be NA\n",
" | level : int, default None\n",
" | If the axis is a MultiIndex (hierarchical), count along a\n",
" | particular level, collapsing into a DataFrame\n",
" | \n",
" | Returns\n",
" | -------\n",
" | product : Series (or DataFrame if level specified)\n",
" | \n",
" | quantile(self, q=0.5, axis=0, numeric_only=True)\n",
" | Return values at the given quantile over requested axis, a la\n",
" | scoreatpercentile in scipy.stats\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | q : quantile, default 0.5 (50% quantile)\n",
" | 0 <= q <= 1\n",
" | axis : {0, 1}\n",
" | 0 for row-wise, 1 for column-wise\n",
" | \n",
" | Returns\n",
" | -------\n",
" | quantiles : Series\n",
" | \n",
" | radd(self, other, axis='columns', level=None, fill_value=None)\n",
" | Binary operator radd with support to substitute a fill_value for missing data in\n",
" | one of the inputs\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | other : Series, DataFrame, or constant\n",
" | axis : {0, 1, 'index', 'columns'}\n",
" | For Series input, axis to match Series index on\n",
" | fill_value : None or float value, default None\n",
" | Fill missing (NaN) values with this value. If both DataFrame locations are\n",
" | missing, the result will be missing\n",
" | level : int or name\n",
" | Broadcast across a level, matching Index values on the\n",
" | passed MultiIndex level\n",
" | \n",
" | Notes\n",
" | -----\n",
" | Mismatched indices will be unioned together\n",
" | \n",
" | Returns\n",
" | -------\n",
" | result : DataFrame\n",
" | \n",
" | rank(self, axis=0, numeric_only=None, method='average', na_option='keep', ascending=True)\n",
" | Compute numerical data ranks (1 through n) along axis. Equal values are\n",
" | assigned a rank that is the average of the ranks of those values\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | axis : {0, 1}, default 0\n",
" | Ranks over columns (0) or rows (1)\n",
" | numeric_only : boolean, default None\n",
" | Include only float, int, boolean data\n",
" | method : {'average', 'min', 'max', 'first'}\n",
" | average: average rank of group\n",
" | min: lowest rank in group\n",
" | max: highest rank in group\n",
" | first: ranks assigned in order they appear in the array\n",
" | na_option : {'keep', 'top', 'bottom'}\n",
" | keep: leave NA values where they are\n",
" | top: smallest rank if ascending\n",
" | bottom: smallest rank if descending\n",
" | ascending : boolean, default True\n",
" | False for ranks by high (1) to low (N)\n",
" | \n",
" | Returns\n",
" | -------\n",
" | ranks : DataFrame\n",
" | \n",
" | rdiv = rdivide(self, other, axis='columns', level=None, fill_value=None)\n",
" | Binary operator rdivide with support to substitute a fill_value for missing data in\n",
" | one of the inputs\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | other : Series, DataFrame, or constant\n",
" | axis : {0, 1, 'index', 'columns'}\n",
" | For Series input, axis to match Series index on\n",
" | fill_value : None or float value, default None\n",
" | Fill missing (NaN) values with this value. If both DataFrame locations are\n",
" | missing, the result will be missing\n",
" | level : int or name\n",
" | Broadcast across a level, matching Index values on the\n",
" | passed MultiIndex level\n",
" | \n",
" | Notes\n",
" | -----\n",
" | Mismatched indices will be unioned together\n",
" | \n",
" | Returns\n",
" | -------\n",
" | result : DataFrame\n",
" | \n",
" | reindex(self, index=None, columns=None, method=None, level=None, fill_value=nan, limit=None, copy=True, takeable=False)\n",
" | Conform DataFrame to new index with optional filling logic, placing\n",
" | NA/NaN in locations having no value in the previous index. A new object\n",
" | is produced unless the new index is equivalent to the current one and\n",
" | copy=False\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | index : array-like, optional\n",
" | New labels / index to conform to. Preferably an Index object to\n",
" | avoid duplicating data\n",
" | columns : array-like, optional\n",
" | Same usage as index argument\n",
" | method : {'backfill', 'bfill', 'pad', 'ffill', None}, default None\n",
" | Method to use for filling holes in reindexed DataFrame\n",
" | pad / ffill: propagate last valid observation forward to next valid\n",
" | backfill / bfill: use NEXT valid observation to fill gap\n",
" | copy : boolean, default True\n",
" | Return a new object, even if the passed indexes are the same\n",
" | level : int or name\n",
" | Broadcast across a level, matching Index values on the\n",
" | passed MultiIndex level\n",
" | fill_value : scalar, default np.NaN\n",
" | Value to use for missing values. Defaults to NaN, but can be any\n",
" | \"compatible\" value\n",
" | limit : int, default None\n",
" | Maximum size gap to forward or backward fill\n",
" | takeable : the labels are locations (and not labels)\n",
" | \n",
" | Examples\n",
" | --------\n",
" | >>> df.reindex(index=[date1, date2, date3], columns=['A', 'B', 'C'])\n",
" | \n",
" | Returns\n",
" | -------\n",
" | reindexed : same type as calling instance\n",
" | \n",
" | reindex_axis(self, labels, axis=0, method=None, level=None, copy=True, limit=None, fill_value=nan)\n",
" | Conform DataFrame to new index with optional filling logic, placing\n",
" | NA/NaN in locations having no value in the previous index. A new object\n",
" | is produced unless the new index is equivalent to the current one and\n",
" | copy=False\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | index : array-like, optional\n",
" | New labels / index to conform to. Preferably an Index object to\n",
" | avoid duplicating data\n",
" | axis : {0, 1}\n",
" | 0 -> index (rows)\n",
" | 1 -> columns\n",
" | method : {'backfill', 'bfill', 'pad', 'ffill', None}, default None\n",
" | Method to use for filling holes in reindexed DataFrame\n",
" | pad / ffill: propagate last valid observation forward to next valid\n",
" | backfill / bfill: use NEXT valid observation to fill gap\n",
" | copy : boolean, default True\n",
" | Return a new object, even if the passed indexes are the same\n",
" | level : int or name\n",
" | Broadcast across a level, matching Index values on the\n",
" | passed MultiIndex level\n",
" | limit : int, default None\n",
" | Maximum size gap to forward or backward fill\n",
" | \n",
" | Examples\n",
" | --------\n",
" | >>> df.reindex_axis(['A', 'B', 'C'], axis=1)\n",
" | \n",
" | See also\n",
" | --------\n",
" | DataFrame.reindex, DataFrame.reindex_like\n",
" | \n",
" | Returns\n",
" | -------\n",
" | reindexed : same type as calling instance\n",
" | \n",
" | reindex_like(self, other, method=None, copy=True, limit=None, fill_value=nan)\n",
" | Reindex DataFrame to match indices of another DataFrame, optionally\n",
" | with filling logic\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | other : DataFrame\n",
" | method : string or None\n",
" | copy : boolean, default True\n",
" | limit : int, default None\n",
" | Maximum size gap to forward or backward fill\n",
" | \n",
" | Notes\n",
" | -----\n",
" | Like calling s.reindex(index=other.index, columns=other.columns,\n",
" | method=...)\n",
" | \n",
" | Returns\n",
" | -------\n",
" | reindexed : DataFrame\n",
" | \n",
" | rename(self, index=None, columns=None, copy=True, inplace=False)\n",
" | Alter index and / or columns using input function or\n",
" | functions. Function / dict values must be unique (1-to-1). Labels not\n",
" | contained in a dict / Series will be left as-is.\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | index : dict-like or function, optional\n",
" | Transformation to apply to index values\n",
" | columns : dict-like or function, optional\n",
" | Transformation to apply to column values\n",
" | copy : boolean, default True\n",
" | Also copy underlying data\n",
" | inplace : boolean, default False\n",
" | Whether to return a new DataFrame. If True then value of copy is\n",
" | ignored.\n",
" | \n",
" | See also\n",
" | --------\n",
" | Series.rename\n",
" | \n",
" | Returns\n",
" | -------\n",
" | renamed : DataFrame (new object)\n",
" | \n",
" | reorder_levels(self, order, axis=0)\n",
" | Rearrange index levels using input order.\n",
" | May not drop or duplicate levels\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | order: list of int representing new level order.\n",
" | (reference level by number not by key)\n",
" | axis: where to reorder levels\n",
" | \n",
" | Returns\n",
" | -------\n",
" | type of caller (new object)\n",
" | \n",
" | replace(self, to_replace=None, value=None, inplace=False, limit=None, regex=False, method=None, axis=None)\n",
" | Replace values given in 'to_replace' with 'value'.\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | to_replace : str, regex, list, dict, Series, numeric, or None\n",
" | \n",
" | * str or regex:\n",
" | \n",
" | - str: string exactly matching `to_replace` will be replaced\n",
" | with `value`\n",
" | - regex: regexs matching `to_replace` will be replaced with\n",
" | `value`\n",
" | \n",
" | * list of str, regex, or numeric:\n",
" | \n",
" | - First, if `to_replace` and `value` are both lists, they\n",
" | **must** be the same length.\n",
" | - Second, if ``regex=True`` then all of the strings in **both**\n",
" | lists will be interpreted as regexs otherwise they will match\n",
" | directly. This doesn't matter much for `value` since there\n",
" | are only a few possible substitution regexes you can use.\n",
" | - str and regex rules apply as above.\n",
" | \n",
" | * dict:\n",
" | \n",
" | - Nested dictionaries, e.g., {'a': {'b': nan}}, are read as\n",
" | follows: look in column 'a' for the value 'b' and replace it\n",
" | with nan. You can nest regular expressions as well. Note that\n",
" | column names (the top-level dictionary keys in a nested\n",
" | dictionary) **cannot** be regular expressions.\n",
" | - Keys map to column names and values map to substitution\n",
" | values. You can treat this as a special case of passing two\n",
" | lists except that you are specifying the column to search in.\n",
" | \n",
" | * None:\n",
" | \n",
" | - This means that the ``regex`` argument must be a string,\n",
" | compiled regular expression, or list, dict, ndarray or Series\n",
" | of such elements. If `value` is also ``None`` then this\n",
" | **must** be a nested dictionary or ``Series``.\n",
" | \n",
" | See the examples section for examples of each of these.\n",
" | value : scalar, dict, list, str, regex, default None\n",
" | Value to use to fill holes (e.g. 0), alternately a dict of values\n",
" | specifying which value to use for each column (columns not in the\n",
" | dict will not be filled). Regular expressions, strings and lists or\n",
" | dicts of such objects are also allowed.\n",
" | inplace : boolean, default False\n",
" | If True, fill the DataFrame in place. Note: this will modify any\n",
" | other views on this DataFrame, like if you took a no-copy slice of\n",
" | an existing DataFrame, for example a column in a DataFrame. Returns\n",
" | a reference to the filled object, which is self if inplace=True\n",
" | limit : int, default None\n",
" | Maximum size gap to forward or backward fill\n",
" | regex : bool or same types as `to_replace`, default False\n",
" | Whether to interpret `to_replace` and/or `value` as regular\n",
" | expressions. If this is ``True`` then `to_replace` *must* be a\n",
" | string. Otherwise, `to_replace` must be ``None`` because this\n",
" | parameter will be interpreted as a regular expression or a list,\n",
" | dict, or array of regular expressions.\n",
" | \n",
" | See also\n",
" | --------\n",
" | reindex, asfreq, fillna\n",
" | \n",
" | Returns\n",
" | -------\n",
" | filled : DataFrame\n",
" | \n",
" | Raises\n",
" | ------\n",
" | AssertionError\n",
" | * If `regex` is not a ``bool`` and `to_replace` is not ``None``.\n",
" | TypeError\n",
" | * If `to_replace` is a ``dict`` and `value` is not a ``list``,\n",
" | ``dict``, ``ndarray``, or ``Series``\n",
" | * If `to_replace` is ``None`` and `regex` is not compilable into a\n",
" | regular expression or is a list, dict, ndarray, or Series.\n",
" | ValueError\n",
" | * If `to_replace` and `value` are ``list`` s or ``ndarray`` s, but\n",
" | they are not the same length.\n",
" | \n",
" | Notes\n",
" | -----\n",
" | * Regex substitution is performed under the hood with ``re.sub``. The\n",
" | rules for substitution for ``re.sub`` are the same.\n",
" | * Regular expressions will only substitute on strings, meaning you\n",
" | cannot provide, for example, a regular expression matching floating\n",
" | point numbers and expect the columns in your frame that have a\n",
" | numeric dtype to be matched. However, if those floating point numbers\n",
" | *are* strings, then you can do this.\n",
" | * This method has *a lot* of options. You are encouraged to experiment\n",
" | and play with this method to gain intuition about how it works.\n",
" | \n",
" | reset_index(self, level=None, drop=False, inplace=False, col_level=0, col_fill='')\n",
" | For DataFrame with multi-level index, return new DataFrame with\n",
" | labeling information in the columns under the index names, defaulting\n",
" | to 'level_0', 'level_1', etc. if any are None. For a standard index,\n",
" | the index name will be used (if set), otherwise a default 'index' or\n",
" | 'level_0' (if 'index' is already taken) will be used.\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | level : int, str, tuple, or list, default None\n",
" | Only remove the given levels from the index. Removes all levels by\n",
" | default\n",
" | drop : boolean, default False\n",
" | Do not try to insert index into dataframe columns. This resets\n",
" | the index to the default integer index.\n",
" | inplace : boolean, default False\n",
" | Modify the DataFrame in place (do not create a new object)\n",
" | col_level : int or str, default 0\n",
" | If the columns have multiple levels, determines which level the\n",
" | labels are inserted into. By default it is inserted into the first\n",
" | level.\n",
" | col_fill : object, default ''\n",
" | If the columns have multiple levels, determines how the other\n",
" | levels are named. If None then the index name is repeated.\n",
" | \n",
" | Returns\n",
" | -------\n",
" | resetted : DataFrame\n",
" | \n",
" | rmod(self, other, axis='columns', level=None, fill_value=None)\n",
" | Binary operator rmod with support to substitute a fill_value for missing data in\n",
" | one of the inputs\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | other : Series, DataFrame, or constant\n",
" | axis : {0, 1, 'index', 'columns'}\n",
" | For Series input, axis to match Series index on\n",
" | fill_value : None or float value, default None\n",
" | Fill missing (NaN) values with this value. If both DataFrame locations are\n",
" | missing, the result will be missing\n",
" | level : int or name\n",
" | Broadcast across a level, matching Index values on the\n",
" | passed MultiIndex level\n",
" | \n",
" | Notes\n",
" | -----\n",
" | Mismatched indices will be unioned together\n",
" | \n",
" | Returns\n",
" | -------\n",
" | result : DataFrame\n",
" | \n",
" | rmul = rmultiply(self, other, axis='columns', level=None, fill_value=None)\n",
" | Binary operator rmultiply with support to substitute a fill_value for missing data in\n",
" | one of the inputs\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | other : Series, DataFrame, or constant\n",
" | axis : {0, 1, 'index', 'columns'}\n",
" | For Series input, axis to match Series index on\n",
" | fill_value : None or float value, default None\n",
" | Fill missing (NaN) values with this value. If both DataFrame locations are\n",
" | missing, the result will be missing\n",
" | level : int or name\n",
" | Broadcast across a level, matching Index values on the\n",
" | passed MultiIndex level\n",
" | \n",
" | Notes\n",
" | -----\n",
" | Mismatched indices will be unioned together\n",
" | \n",
" | Returns\n",
" | -------\n",
" | result : DataFrame\n",
" | \n",
" | rpow(self, other, axis='columns', level=None, fill_value=None)\n",
" | Binary operator rpow with support to substitute a fill_value for missing data in\n",
" | one of the inputs\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | other : Series, DataFrame, or constant\n",
" | axis : {0, 1, 'index', 'columns'}\n",
" | For Series input, axis to match Series index on\n",
" | fill_value : None or float value, default None\n",
" | Fill missing (NaN) values with this value. If both DataFrame locations are\n",
" | missing, the result will be missing\n",
" | level : int or name\n",
" | Broadcast across a level, matching Index values on the\n",
" | passed MultiIndex level\n",
" | \n",
" | Notes\n",
" | -----\n",
" | Mismatched indices will be unioned together\n",
" | \n",
" | Returns\n",
" | -------\n",
" | result : DataFrame\n",
" | \n",
" | rsub = rsubtract(self, other, axis='columns', level=None, fill_value=None)\n",
" | Binary operator rsubtract with support to substitute a fill_value for missing data in\n",
" | one of the inputs\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | other : Series, DataFrame, or constant\n",
" | axis : {0, 1, 'index', 'columns'}\n",
" | For Series input, axis to match Series index on\n",
" | fill_value : None or float value, default None\n",
" | Fill missing (NaN) values with this value. If both DataFrame locations are\n",
" | missing, the result will be missing\n",
" | level : int or name\n",
" | Broadcast across a level, matching Index values on the\n",
" | passed MultiIndex level\n",
" | \n",
" | Notes\n",
" | -----\n",
" | Mismatched indices will be unioned together\n",
" | \n",
" | Returns\n",
" | -------\n",
" | result : DataFrame\n",
" | \n",
" | set_index(self, keys, drop=True, append=False, inplace=False, verify_integrity=False)\n",
" | Set the DataFrame index (row labels) using one or more existing\n",
" | columns. By default yields a new object.\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | keys : column label or list of column labels / arrays\n",
" | drop : boolean, default True\n",
" | Delete columns to be used as the new index\n",
" | append : boolean, default False\n",
" | Whether to append columns to existing index\n",
" | inplace : boolean, default False\n",
" | Modify the DataFrame in place (do not create a new object)\n",
" | verify_integrity : boolean, default False\n",
" | Check the new index for duplicates. Otherwise defer the check until\n",
" | necessary. Setting to False will improve the performance of this\n",
" | method\n",
" | \n",
" | Examples\n",
" | --------\n",
" | >>> indexed_df = df.set_index(['A', 'B'])\n",
" | >>> indexed_df2 = df.set_index(['A', [0, 1, 2, 0, 1, 2]])\n",
" | >>> indexed_df3 = df.set_index([[0, 1, 2, 0, 1, 2]])\n",
" | \n",
" | Returns\n",
" | -------\n",
" | dataframe : DataFrame\n",
" | \n",
" | set_value(self, index, col, value)\n",
" | Put single value at passed column and index\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | index : row label\n",
" | col : column label\n",
" | value : scalar value\n",
" | \n",
" | Returns\n",
" | -------\n",
" | frame : DataFrame\n",
" | If label pair is contained, will be reference to calling DataFrame,\n",
" | otherwise a new object\n",
" | \n",
" | shift(self, periods=1, freq=None, **kwds)\n",
" | Shift the index of the DataFrame by desired number of periods with an\n",
" | optional time freq\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | periods : int\n",
" | Number of periods to move, can be positive or negative\n",
" | freq : DateOffset, timedelta, or time rule string, optional\n",
" | Increment to use from datetools module or time rule (e.g. 'EOM')\n",
" | \n",
" | Notes\n",
" | -----\n",
" | If freq is specified then the index values are shifted but the data\n",
" | if not realigned\n",
" | \n",
" | Returns\n",
" | -------\n",
" | shifted : DataFrame\n",
" | \n",
" | sort(self, columns=None, column=None, axis=0, ascending=True, inplace=False)\n",
" | Sort DataFrame either by labels (along either axis) or by the values in\n",
" | column(s)\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | columns : object\n",
" | Column name(s) in frame. Accepts a column name or a list or tuple\n",
" | for a nested sort.\n",
" | ascending : boolean or list, default True\n",
" | Sort ascending vs. descending. Specify list for multiple sort\n",
" | orders\n",
" | axis : {0, 1}\n",
" | Sort index/rows versus columns\n",
" | inplace : boolean, default False\n",
" | Sort the DataFrame without creating a new instance\n",
" | \n",
" | Examples\n",
" | --------\n",
" | >>> result = df.sort(['A', 'B'], ascending=[1, 0])\n",
" | \n",
" | Returns\n",
" | -------\n",
" | sorted : DataFrame\n",
" | \n",
" | sort_index(self, axis=0, by=None, ascending=True, inplace=False, kind='quicksort')\n",
" | Sort DataFrame either by labels (along either axis) or by the values in\n",
" | a column\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | axis : {0, 1}\n",
" | Sort index/rows versus columns\n",
" | by : object\n",
" | Column name(s) in frame. Accepts a column name or a list or tuple\n",
" | for a nested sort.\n",
" | ascending : boolean or list, default True\n",
" | Sort ascending vs. descending. Specify list for multiple sort\n",
" | orders\n",
" | inplace : boolean, default False\n",
" | Sort the DataFrame without creating a new instance\n",
" | \n",
" | Examples\n",
" | --------\n",
" | >>> result = df.sort_index(by=['A', 'B'], ascending=[1, 0])\n",
" | \n",
" | Returns\n",
" | -------\n",
" | sorted : DataFrame\n",
" | \n",
" | sortlevel(self, level=0, axis=0, ascending=True, inplace=False)\n",
" | Sort multilevel index by chosen axis and primary level. Data will be\n",
" | lexicographically sorted by the chosen level followed by the other\n",
" | levels (in order)\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | level : int\n",
" | axis : {0, 1}\n",
" | ascending : bool, default True\n",
" | inplace : boolean, default False\n",
" | Sort the DataFrame without creating a new instance\n",
" | \n",
" | Returns\n",
" | -------\n",
" | sorted : DataFrame\n",
" | \n",
" | stack(self, level=-1, dropna=True)\n",
" | Pivot a level of the (possibly hierarchical) column labels, returning a\n",
" | DataFrame (or Series in the case of an object with a single level of\n",
" | column labels) having a hierarchical index with a new inner-most level\n",
" | of row labels.\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | level : int, string, or list of these, default last level\n",
" | Level(s) to stack, can pass level name\n",
" | dropna : boolean, default True\n",
" | Whether to drop rows in the resulting Frame/Series with no valid\n",
" | values\n",
" | \n",
" | Examples\n",
" | ----------\n",
" | >>> s\n",
" | a b\n",
" | one 1. 2.\n",
" | two 3. 4.\n",
" | \n",
" | >>> s.stack()\n",
" | one a 1\n",
" | b 2\n",
" | two a 3\n",
" | b 4\n",
" | \n",
" | Returns\n",
" | -------\n",
" | stacked : DataFrame or Series\n",
" | \n",
" | std(self, axis=0, skipna=True, level=None, ddof=1)\n",
" | Return standard deviation over requested axis.\n",
" | NA/null values are excluded\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | axis : {0, 1}\n",
" | 0 for row-wise, 1 for column-wise\n",
" | skipna : boolean, default True\n",
" | Exclude NA/null values. If an entire row/column is NA, the result\n",
" | will be NA\n",
" | level : int, default None\n",
" | If the axis is a MultiIndex (hierarchical), count along a\n",
" | particular level, collapsing into a DataFrame\n",
" | \n",
" | Returns\n",
" | -------\n",
" | std : Series (or DataFrame if level specified)\n",
" | \n",
" | Normalized by N-1 (unbiased estimator).\n",
" | \n",
" | sub = subtract(self, other, axis='columns', level=None, fill_value=None)\n",
" | Binary operator subtract with support to substitute a fill_value for missing data in\n",
" | one of the inputs\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | other : Series, DataFrame, or constant\n",
" | axis : {0, 1, 'index', 'columns'}\n",
" | For Series input, axis to match Series index on\n",
" | fill_value : None or float value, default None\n",
" | Fill missing (NaN) values with this value. If both DataFrame locations are\n",
" | missing, the result will be missing\n",
" | level : int or name\n",
" | Broadcast across a level, matching Index values on the\n",
" | passed MultiIndex level\n",
" | \n",
" | Notes\n",
" | -----\n",
" | Mismatched indices will be unioned together\n",
" | \n",
" | Returns\n",
" | -------\n",
" | result : DataFrame\n",
" | \n",
" | sum(self, axis=0, numeric_only=None, skipna=True, level=None)\n",
" | Return sum over requested axis.\n",
" | NA/null values are excluded\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | axis : {0, 1}\n",
" | 0 for row-wise, 1 for column-wise\n",
" | skipna : boolean, default True\n",
" | Exclude NA/null values. If an entire row/column is NA, the result\n",
" | will be NA\n",
" | level : int, default None\n",
" | If the axis is a MultiIndex (hierarchical), count along a\n",
" | particular level, collapsing into a DataFrame\n",
" | numeric_only : boolean, default None\n",
" | Include only float, int, boolean data. If None, will attempt to use\n",
" | everything, then use only numeric data\n",
" | \n",
" | Returns\n",
" | -------\n",
" | sum : Series (or DataFrame if level specified)\n",
" | \n",
" | swapaxes(self, i, j)\n",
" | Like ndarray.swapaxes, equivalent to transpose\n",
" | \n",
" | Returns\n",
" | -------\n",
" | swapped : DataFrame\n",
" | View on original data (no copy)\n",
" | \n",
" | swaplevel(self, i, j, axis=0)\n",
" | Swap levels i and j in a MultiIndex on a particular axis\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | i, j : int, string (can be mixed)\n",
" | Level of index to be swapped. Can pass level name as string.\n",
" | \n",
" | Returns\n",
" | -------\n",
" | swapped : type of caller (new object)\n",
" | \n",
" | tail(self, n=5)\n",
" | Returns last n rows of DataFrame\n",
" | \n",
" | take(self, indices, axis=0, convert=True)\n",
" | Analogous to ndarray.take, return DataFrame corresponding to requested\n",
" | indices along an axis\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | indices : list / array of ints\n",
" | axis : {0, 1}\n",
" | convert : convert indices for negative values, check bounds, default True\n",
" | mainly useful for an user routine calling\n",
" | \n",
" | Returns\n",
" | -------\n",
" | taken : DataFrame\n",
" | \n",
" | to_csv(self, path_or_buf, sep=',', na_rep='', float_format=None, cols=None, header=True, index=True, index_label=None, mode='w', nanRep=None, encoding=None, quoting=None, line_terminator='\\n', chunksize=None, tupleize_cols=True, **kwds)\n",
" | Write DataFrame to a comma-separated values (csv) file\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | path_or_buf : string or file handle / StringIO\n",
" | File path\n",
" | sep : character, default \",\"\n",
" | Field delimiter for the output file.\n",
" | na_rep : string, default ''\n",
" | Missing data representation\n",
" | float_format : string, default None\n",
" | Format string for floating point numbers\n",
" | cols : sequence, optional\n",
" | Columns to write\n",
" | header : boolean or list of string, default True\n",
" | Write out column names. If a list of string is given it is assumed\n",
" | to be aliases for the column names\n",
" | index : boolean, default True\n",
" | Write row names (index)\n",
" | index_label : string or sequence, or False, default None\n",
" | Column label for index column(s) if desired. If None is given, and\n",
" | `header` and `index` are True, then the index names are used. A\n",
" | sequence should be given if the DataFrame uses MultiIndex. If\n",
" | False do not print fields for index names. Use index_label=False\n",
" | for easier importing in R\n",
" | nanRep : None\n",
" | deprecated, use na_rep\n",
" | mode : str\n",
" | Python write mode, default 'w'\n",
" | encoding : string, optional\n",
" | a string representing the encoding to use if the contents are\n",
" | non-ascii, for python versions prior to 3\n",
" | line_terminator : string, default '\\\\n'\n",
" | The newline character or character sequence to use in the output\n",
" | file\n",
" | quoting : optional constant from csv module\n",
" | defaults to csv.QUOTE_MINIMAL\n",
" | chunksize : int or None\n",
" | rows to write at a time\n",
" | tupleize_cols : boolean, default True\n",
" | write multi_index columns as a list of tuples (if True)\n",
" | or new (expanded format) if False)\n",
" | \n",
" | to_dict(self, outtype='dict')\n",
" | Convert DataFrame to dictionary.\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | outtype : str {'dict', 'list', 'series'}\n",
" | Determines the type of the values of the dictionary. The\n",
" | default `dict` is a nested dictionary {column -> {index -> value}}.\n",
" | `list` returns {column -> list(values)}. `series` returns\n",
" | {column -> Series(values)}.\n",
" | Abbreviations are allowed.\n",
" | \n",
" | \n",
" | Returns\n",
" | -------\n",
" | result : dict like {column -> {index -> value}}\n",
" | \n",
" | to_excel(self, excel_writer, sheet_name='sheet1', na_rep='', float_format=None, cols=None, header=True, index=True, index_label=None, startrow=0, startcol=0)\n",
" | Write DataFrame to a excel sheet\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | excel_writer : string or ExcelWriter object\n",
" | File path or existing ExcelWriter\n",
" | sheet_name : string, default 'sheet1'\n",
" | Name of sheet which will contain DataFrame\n",
" | na_rep : string, default ''\n",
" | Missing data representation\n",
" | float_format : string, default None\n",
" | Format string for floating point numbers\n",
" | cols : sequence, optional\n",
" | Columns to write\n",
" | header : boolean or list of string, default True\n",
" | Write out column names. If a list of string is given it is\n",
" | assumed to be aliases for the column names\n",
" | index : boolean, default True\n",
" | Write row names (index)\n",
" | index_label : string or sequence, default None\n",
" | Column label for index column(s) if desired. If None is given, and\n",
" | `header` and `index` are True, then the index names are used. A\n",
" | sequence should be given if the DataFrame uses MultiIndex.\n",
" | startow : upper left cell row to dump data frame\n",
" | startcol : upper left cell column to dump data frame\n",
" | \n",
" | \n",
" | Notes\n",
" | -----\n",
" | If passing an existing ExcelWriter object, then the sheet will be added\n",
" | to the existing workbook. This can be used to save different\n",
" | DataFrames to one workbook\n",
" | >>> writer = ExcelWriter('output.xlsx')\n",
" | >>> df1.to_excel(writer,'sheet1')\n",
" | >>> df2.to_excel(writer,'sheet2')\n",
" | >>> writer.save()\n",
" | \n",
" | to_html(self, buf=None, columns=None, col_space=None, colSpace=None, header=True, index=True, na_rep='NaN', formatters=None, float_format=None, sparsify=None, index_names=True, justify=None, force_unicode=None, bold_rows=True, classes=None, escape=True)\n",
" | to_html-specific options\n",
" | \n",
" | bold_rows : boolean, default True\n",
" | Make the row labels bold in the output\n",
" | classes : str or list or tuple, default None\n",
" | CSS class(es) to apply to the resulting html table\n",
" | escape : boolean, default True\n",
" | Convert the characters <, >, and & to HTML-safe sequences.\n",
" | \n",
" | Render a DataFrame as an HTML table.\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | frame : DataFrame\n",
" | object to render\n",
" | buf : StringIO-like, optional\n",
" | buffer to write to\n",
" | columns : sequence, optional\n",
" | the subset of columns to write; default None writes all columns\n",
" | col_space : int, optional\n",
" | the minimum width of each column\n",
" | header : bool, optional\n",
" | whether to print column labels, default True\n",
" | index : bool, optional\n",
" | whether to print index (row) labels, default True\n",
" | na_rep : string, optional\n",
" | string representation of NAN to use, default 'NaN'\n",
" | formatters : list or dict of one-parameter functions, optional\n",
" | formatter functions to apply to columns' elements by position or name,\n",
" | default None, if the result is a string , it must be a unicode\n",
" | string. List must be of length equal to the number of columns.\n",
" | float_format : one-parameter function, optional\n",
" | formatter function to apply to columns' elements if they are floats\n",
" | default None\n",
" | sparsify : bool, optional\n",
" | Set to False for a DataFrame with a hierarchical index to print every\n",
" | multiindex key at each row, default True\n",
" | justify : {'left', 'right'}, default None\n",
" | Left or right-justify the column labels. If None uses the option from\n",
" | the print configuration (controlled by set_printoptions), 'right' out\n",
" | of the box.\n",
" | index_names : bool, optional\n",
" | Prints the names of the indexes, default True\n",
" | force_unicode : bool, default False\n",
" | Always return a unicode result. Deprecated in v0.10.0 as string\n",
" | formatting is now rendered to unicode by default.\n",
" | \n",
" | Returns\n",
" | -------\n",
" | formatted : string (or unicode, depending on data and options)\n",
" | \n",
" | to_latex(self, buf=None, columns=None, col_space=None, colSpace=None, header=True, index=True, na_rep='NaN', formatters=None, float_format=None, sparsify=None, index_names=True, bold_rows=True, force_unicode=None)\n",
" | to_latex-specific options\n",
" | bold_rows : boolean, default True\n",
" | Make the row labels bold in the output\n",
" | \n",
" | Render a DataFrame to a tabular environment table.\n",
" | You can splice this into a LaTeX document.\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | frame : DataFrame\n",
" | object to render\n",
" | buf : StringIO-like, optional\n",
" | buffer to write to\n",
" | columns : sequence, optional\n",
" | the subset of columns to write; default None writes all columns\n",
" | col_space : int, optional\n",
" | the minimum width of each column\n",
" | header : bool, optional\n",
" | whether to print column labels, default True\n",
" | index : bool, optional\n",
" | whether to print index (row) labels, default True\n",
" | na_rep : string, optional\n",
" | string representation of NAN to use, default 'NaN'\n",
" | formatters : list or dict of one-parameter functions, optional\n",
" | formatter functions to apply to columns' elements by position or name,\n",
" | default None, if the result is a string , it must be a unicode\n",
" | string. List must be of length equal to the number of columns.\n",
" | float_format : one-parameter function, optional\n",
" | formatter function to apply to columns' elements if they are floats\n",
" | default None\n",
" | sparsify : bool, optional\n",
" | Set to False for a DataFrame with a hierarchical index to print every\n",
" | multiindex key at each row, default True\n",
" | justify : {'left', 'right'}, default None\n",
" | Left or right-justify the column labels. If None uses the option from\n",
" | the print configuration (controlled by set_printoptions), 'right' out\n",
" | of the box.\n",
" | index_names : bool, optional\n",
" | Prints the names of the indexes, default True\n",
" | force_unicode : bool, default False\n",
" | Always return a unicode result. Deprecated in v0.10.0 as string\n",
" | formatting is now rendered to unicode by default.\n",
" | \n",
" | Returns\n",
" | -------\n",
" | formatted : string (or unicode, depending on data and options)\n",
" | \n",
" | to_panel(self)\n",
" | Transform long (stacked) format (DataFrame) into wide (3D, Panel)\n",
" | format.\n",
" | \n",
" | Currently the index of the DataFrame must be a 2-level MultiIndex. This\n",
" | may be generalized later\n",
" | \n",
" | Returns\n",
" | -------\n",
" | panel : Panel\n",
" | \n",
" | to_period(self, freq=None, axis=0, copy=True)\n",
" | Convert DataFrame from DatetimeIndex to PeriodIndex with desired\n",
" | frequency (inferred from index if not passed)\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | freq : string, default\n",
" | axis : {0, 1}, default 0\n",
" | The axis to convert (the index by default)\n",
" | copy : boolean, default True\n",
" | If False then underlying input data is not copied\n",
" | \n",
" | Returns\n",
" | -------\n",
" | ts : TimeSeries with PeriodIndex\n",
" | \n",
" | to_records(self, index=True, convert_datetime64=True)\n",
" | Convert DataFrame to record array. Index will be put in the\n",
" | 'index' field of the record array if requested\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | index : boolean, default True\n",
" | Include index in resulting record array, stored in 'index' field\n",
" | convert_datetime64 : boolean, default True\n",
" | Whether to convert the index to datetime.datetime if it is a\n",
" | DatetimeIndex\n",
" | \n",
" | Returns\n",
" | -------\n",
" | y : recarray\n",
" | \n",
" | to_sparse(self, fill_value=None, kind='block')\n",
" | Convert to SparseDataFrame\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | fill_value : float, default NaN\n",
" | kind : {'block', 'integer'}\n",
" | \n",
" | Returns\n",
" | -------\n",
" | y : SparseDataFrame\n",
" | \n",
" | to_sql(self, name, con, flavor='sqlite', if_exists='fail', **kwargs)\n",
" | Write records stored in a DataFrame to a SQL database.\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | name: name of SQL table\n",
" | conn: an open SQL database connection object\n",
" | flavor: {'sqlite', 'mysql', 'oracle'}, default 'sqlite'\n",
" | if_exists: {'fail', 'replace', 'append'}, default 'fail'\n",
" | fail: If table exists, do nothing.\n",
" | replace: If table exists, drop it, recreate it, and insert data.\n",
" | append: If table exists, insert data. Create if does not exist.\n",
" | \n",
" | to_stata(self, fname, convert_dates=None, write_index=True, encoding='latin-1', byteorder=None)\n",
" | A class for writing Stata binary dta files from array-like objects\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | fname : file path or buffer\n",
" | Where to save the dta file.\n",
" | convert_dates : dict\n",
" | Dictionary mapping column of datetime types to the stata internal\n",
" | format that you want to use for the dates. Options are\n",
" | 'tc', 'td', 'tm', 'tw', 'th', 'tq', 'ty'. Column can be either a\n",
" | number or a name.\n",
" | encoding : str\n",
" | Default is latin-1. Note that Stata does not support unicode.\n",
" | byteorder : str\n",
" | Can be \">\", \"<\", \"little\", or \"big\". The default is None which uses\n",
" | `sys.byteorder`\n",
" | \n",
" | Examples\n",
" | --------\n",
" | >>> writer = StataWriter('./data_file.dta', data)\n",
" | >>> writer.write_file()\n",
" | \n",
" | Or with dates\n",
" | \n",
" | >>> writer = StataWriter('./date_data_file.dta', data, {2 : 'tw'})\n",
" | >>> writer.write_file()\n",
" | \n",
" | to_string(self, buf=None, columns=None, col_space=None, colSpace=None, header=True, index=True, na_rep='NaN', formatters=None, float_format=None, sparsify=None, nanRep=None, index_names=True, justify=None, force_unicode=None, line_width=None)\n",
" | Render a DataFrame to a console-friendly tabular output.\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | frame : DataFrame\n",
" | object to render\n",
" | buf : StringIO-like, optional\n",
" | buffer to write to\n",
" | columns : sequence, optional\n",
" | the subset of columns to write; default None writes all columns\n",
" | col_space : int, optional\n",
" | the minimum width of each column\n",
" | header : bool, optional\n",
" | whether to print column labels, default True\n",
" | index : bool, optional\n",
" | whether to print index (row) labels, default True\n",
" | na_rep : string, optional\n",
" | string representation of NAN to use, default 'NaN'\n",
" | formatters : list or dict of one-parameter functions, optional\n",
" | formatter functions to apply to columns' elements by position or name,\n",
" | default None, if the result is a string , it must be a unicode\n",
" | string. List must be of length equal to the number of columns.\n",
" | float_format : one-parameter function, optional\n",
" | formatter function to apply to columns' elements if they are floats\n",
" | default None\n",
" | sparsify : bool, optional\n",
" | Set to False for a DataFrame with a hierarchical index to print every\n",
" | multiindex key at each row, default True\n",
" | justify : {'left', 'right'}, default None\n",
" | Left or right-justify the column labels. If None uses the option from\n",
" | the print configuration (controlled by set_printoptions), 'right' out\n",
" | of the box.\n",
" | index_names : bool, optional\n",
" | Prints the names of the indexes, default True\n",
" | force_unicode : bool, default False\n",
" | Always return a unicode result. Deprecated in v0.10.0 as string\n",
" | formatting is now rendered to unicode by default.\n",
" | \n",
" | Returns\n",
" | -------\n",
" | formatted : string (or unicode, depending on data and options)\n",
" | \n",
" | to_timestamp(self, freq=None, how='start', axis=0, copy=True)\n",
" | Cast to DatetimeIndex of timestamps, at *beginning* of period\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | freq : string, default frequency of PeriodIndex\n",
" | Desired frequency\n",
" | how : {'s', 'e', 'start', 'end'}\n",
" | Convention for converting period to timestamp; start of period\n",
" | vs. end\n",
" | axis : {0, 1} default 0\n",
" | The axis to convert (the index by default)\n",
" | copy : boolean, default True\n",
" | If false then underlying input data is not copied\n",
" | \n",
" | Returns\n",
" | -------\n",
" | df : DataFrame with DatetimeIndex\n",
" | \n",
" | to_wide = wrapper(*args, **kwargs)\n",
" | \n",
" | transpose(self)\n",
" | Returns a DataFrame with the rows/columns switched. If the DataFrame is\n",
" | homogeneously-typed, the data is not copied\n",
" | \n",
" | truncate(self, before=None, after=None, copy=True)\n",
" | Function truncate a sorted DataFrame / Series before and/or after\n",
" | some particular dates.\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | before : date\n",
" | Truncate before date\n",
" | after : date\n",
" | Truncate after date\n",
" | copy : boolean, default True\n",
" | \n",
" | Returns\n",
" | -------\n",
" | truncated : type of caller\n",
" | \n",
" | unstack(self, level=-1)\n",
" | Pivot a level of the (necessarily hierarchical) index labels, returning\n",
" | a DataFrame having a new level of column labels whose inner-most level\n",
" | consists of the pivoted index labels. If the index is not a MultiIndex,\n",
" | the output will be a Series (the analogue of stack when the columns are\n",
" | not a MultiIndex)\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | level : int, string, or list of these, default last level\n",
" | Level(s) of index to unstack, can pass level name\n",
" | \n",
" | Examples\n",
" | --------\n",
" | >>> s\n",
" | one a 1.\n",
" | one b 2.\n",
" | two a 3.\n",
" | two b 4.\n",
" | \n",
" | >>> s.unstack(level=-1)\n",
" | a b\n",
" | one 1. 2.\n",
" | two 3. 4.\n",
" | \n",
" | >>> df = s.unstack(level=0)\n",
" | >>> df\n",
" | one two\n",
" | a 1. 2.\n",
" | b 3. 4.\n",
" | \n",
" | >>> df.unstack()\n",
" | one a 1.\n",
" | b 3.\n",
" | two a 2.\n",
" | b 4.\n",
" | \n",
" | Returns\n",
" | -------\n",
" | unstacked : DataFrame or Series\n",
" | \n",
" | update(self, other, join='left', overwrite=True, filter_func=None, raise_conflict=False)\n",
" | Modify DataFrame in place using non-NA values from passed\n",
" | DataFrame. Aligns on indices\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | other : DataFrame, or object coercible into a DataFrame\n",
" | join : {'left', 'right', 'outer', 'inner'}, default 'left'\n",
" | overwrite : boolean, default True\n",
" | If True then overwrite values for common keys in the calling frame\n",
" | filter_func : callable(1d-array) -> 1d-array<boolean>, default None\n",
" | Can choose to replace values other than NA. Return True for values\n",
" | that should be updated\n",
" | raise_conflict : bool\n",
" | If True, will raise an error if the DataFrame and other both\n",
" | contain data in the same place.\n",
" | \n",
" | var(self, axis=0, skipna=True, level=None, ddof=1)\n",
" | Return variance over requested axis.\n",
" | NA/null values are excluded\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | axis : {0, 1}\n",
" | 0 for row-wise, 1 for column-wise\n",
" | skipna : boolean, default True\n",
" | Exclude NA/null values. If an entire row/column is NA, the result\n",
" | will be NA\n",
" | level : int, default None\n",
" | If the axis is a MultiIndex (hierarchical), count along a\n",
" | particular level, collapsing into a DataFrame\n",
" | \n",
" | Returns\n",
" | -------\n",
" | var : Series (or DataFrame if level specified)\n",
" | \n",
" | Normalized by N-1 (unbiased estimator).\n",
" | \n",
" | where(self, cond, other=nan, inplace=False, try_cast=False, raise_on_error=True)\n",
" | Return a DataFrame with the same shape as self and whose corresponding\n",
" | entries are from self where cond is True and otherwise are from other.\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | cond : boolean DataFrame or array\n",
" | other : scalar or DataFrame\n",
" | inplace : boolean, default False\n",
" | Whether to perform the operation in place on the data\n",
" | try_cast : boolean, default False\n",
" | try to cast the result back to the input type (if possible),\n",
" | raise_on_error : boolean, default True\n",
" | Whether to raise on invalid data types (e.g. trying to where on\n",
" | strings)\n",
" | \n",
" | Returns\n",
" | -------\n",
" | wh : DataFrame\n",
" | \n",
" | xs(self, key, axis=0, level=None, copy=True)\n",
" | Returns a cross-section (row(s) or column(s)) from the DataFrame.\n",
" | Defaults to cross-section on the rows (axis=0).\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | key : object\n",
" | Some label contained in the index, or partially in a MultiIndex\n",
" | axis : int, default 0\n",
" | Axis to retrieve cross-section on\n",
" | level : object, defaults to first n levels (n=1 or len(key))\n",
" | In case of a key partially contained in a MultiIndex, indicate\n",
" | which levels are used. Levels can be referred by label or position.\n",
" | copy : boolean, default True\n",
" | Whether to make a copy of the data\n",
" | \n",
" | Examples\n",
" | --------\n",
" | >>> df\n",
" | A B C\n",
" | a 4 5 2\n",
" | b 4 0 9\n",
" | c 9 7 3\n",
" | >>> df.xs('a')\n",
" | A 4\n",
" | B 5\n",
" | C 2\n",
" | Name: a\n",
" | >>> df.xs('C', axis=1)\n",
" | a 2\n",
" | b 9\n",
" | c 3\n",
" | Name: C\n",
" | >>> s = df.xs('a', copy=False)\n",
" | >>> s['A'] = 100\n",
" | >>> df\n",
" | A B C\n",
" | a 100 5 2\n",
" | b 4 0 9\n",
" | c 9 7 3\n",
" | \n",
" | \n",
" | >>> df\n",
" | A B C D\n",
" | first second third\n",
" | bar one 1 4 1 8 9\n",
" | two 1 7 5 5 0\n",
" | baz one 1 6 6 8 0\n",
" | three 2 5 3 5 3\n",
" | >>> df.xs(('baz', 'three'))\n",
" | A B C D\n",
" | third\n",
" | 2 5 3 5 3\n",
" | >>> df.xs('one', level=1)\n",
" | A B C D\n",
" | first third\n",
" | bar 1 4 1 8 9\n",
" | baz 1 6 6 8 0\n",
" | >>> df.xs(('baz', 2), level=[0, 'third'])\n",
" | A B C D\n",
" | second\n",
" | three 5 3 5 3\n",
" | \n",
" | Returns\n",
" | -------\n",
" | xs : Series or DataFrame\n",
" | \n",
" | ----------------------------------------------------------------------\n",
" | Class methods inherited from pandas.core.frame.DataFrame:\n",
" | \n",
" | from_csv(cls, path, header=0, sep=',', index_col=0, parse_dates=True, encoding=None, tupleize_cols=False) from __builtin__.type\n",
" | Read delimited file into DataFrame\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | path : string file path or file handle / StringIO\n",
" | header : int, default 0\n",
" | Row to use at header (skip prior rows)\n",
" | sep : string, default ','\n",
" | Field delimiter\n",
" | index_col : int or sequence, default 0\n",
" | Column to use for index. If a sequence is given, a MultiIndex\n",
" | is used. Different default from read_table\n",
" | parse_dates : boolean, default True\n",
" | Parse dates. Different default from read_table\n",
" | tupleize_cols : boolean, default True\n",
" | write multi_index columns as a list of tuples (if True)\n",
" | or new (expanded format) if False)\n",
" | \n",
" | Notes\n",
" | -----\n",
" | Preferable to use read_table for most general purposes but from_csv\n",
" | makes for an easy roundtrip to and from file, especially with a\n",
" | DataFrame of time series data\n",
" | \n",
" | Returns\n",
" | -------\n",
" | y : DataFrame\n",
" | \n",
" | from_dict(cls, data, orient='columns', dtype=None) from __builtin__.type\n",
" | Construct DataFrame from dict of array-like or dicts\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | data : dict\n",
" | {field : array-like} or {field : dict}\n",
" | orient : {'columns', 'index'}, default 'columns'\n",
" | The \"orientation\" of the data. If the keys of the passed dict\n",
" | should be the columns of the resulting DataFrame, pass 'columns'\n",
" | (default). Otherwise if the keys should be rows, pass 'index'.\n",
" | \n",
" | Returns\n",
" | -------\n",
" | DataFrame\n",
" | \n",
" | from_items(cls, items, columns=None, orient='columns') from __builtin__.type\n",
" | Convert (key, value) pairs to DataFrame. The keys will be the axis\n",
" | index (usually the columns, but depends on the specified\n",
" | orientation). The values should be arrays or Series.\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | items : sequence of (key, value) pairs\n",
" | Values should be arrays or Series.\n",
" | columns : sequence of column labels, optional\n",
" | Must be passed if orient='index'.\n",
" | orient : {'columns', 'index'}, default 'columns'\n",
" | The \"orientation\" of the data. If the keys of the\n",
" | input correspond to column labels, pass 'columns'\n",
" | (default). Otherwise if the keys correspond to the index,\n",
" | pass 'index'.\n",
" | \n",
" | Returns\n",
" | -------\n",
" | frame : DataFrame\n",
" | \n",
" | from_records(cls, data, index=None, exclude=None, columns=None, coerce_float=False, nrows=None) from __builtin__.type\n",
" | Convert structured or record ndarray to DataFrame\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | data : ndarray (structured dtype), list of tuples, dict, or DataFrame\n",
" | index : string, list of fields, array-like\n",
" | Field of array to use as the index, alternately a specific set of\n",
" | input labels to use\n",
" | exclude: sequence, default None\n",
" | Columns or fields to exclude\n",
" | columns : sequence, default None\n",
" | Column names to use. If the passed data do not have named\n",
" | associated with them, this argument provides names for the\n",
" | columns. Otherwise this argument indicates the order of the columns\n",
" | in the result (any names not found in the data will become all-NA\n",
" | columns)\n",
" | coerce_float : boolean, default False\n",
" | Attempt to convert values to non-string, non-numeric objects (like\n",
" | decimal.Decimal) to floating point, useful for SQL result sets\n",
" | \n",
" | Returns\n",
" | -------\n",
" | df : DataFrame\n",
" | \n",
" | ----------------------------------------------------------------------\n",
" | Data descriptors inherited from pandas.core.frame.DataFrame:\n",
" | \n",
" | T\n",
" | Returns a DataFrame with the rows/columns switched. If the DataFrame is\n",
" | homogeneously-typed, the data is not copied\n",
" | \n",
" | axes\n",
" | \n",
" | blocks\n",
" | Convert the frame to a dict of dtype -> DataFrames that each has a homogeneous dtype.\n",
" | are presented in sorted order unless a specific list of columns is\n",
" | provided.\n",
" | \n",
" | NOTE: the dtypes of the blocks WILL BE PRESERVED HERE (unlike in as_matrix)\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | columns : array-like\n",
" | Specific column order\n",
" | \n",
" | Returns\n",
" | -------\n",
" | values : a list of DataFrames\n",
" | \n",
" | columns\n",
" | \n",
" | dtypes\n",
" | \n",
" | index\n",
" | \n",
" | shape\n",
" | \n",
" | values\n",
" | Convert the frame to its Numpy-array matrix representation. Columns\n",
" | are presented in sorted order unless a specific list of columns is\n",
" | provided.\n",
" | \n",
" | NOTE: the dtype will be a lower-common-denominator dtype (implicit upcasting)\n",
" | that is to say if the dtypes (even of numeric types) are mixed, the one that accomodates all will be chosen\n",
" | use this with care if you are not dealing with the blocks\n",
" | \n",
" | e.g. if the dtypes are float16,float32 -> float32\n",
" | float16,float32,float64 -> float64\n",
" | int32,uint8 -> int32\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | columns : array-like\n",
" | Specific column order\n",
" | \n",
" | Returns\n",
" | -------\n",
" | values : ndarray\n",
" | If the DataFrame is heterogeneous and contains booleans or objects,\n",
" | the result will be of dtype=object\n",
" | \n",
" | ----------------------------------------------------------------------\n",
" | Methods inherited from pandas.core.generic.NDFrame:\n",
" | \n",
" | __delitem__(self, key)\n",
" | Delete item\n",
" | \n",
" | __nonzero__(self)\n",
" | \n",
" | add_prefix(self, prefix)\n",
" | Concatenate prefix string with panel items names.\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | prefix : string\n",
" | \n",
" | Returns\n",
" | -------\n",
" | with_prefix : type of caller\n",
" | \n",
" | add_suffix(self, suffix)\n",
" | Concatenate suffix string with panel items names\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | suffix : string\n",
" | \n",
" | Returns\n",
" | -------\n",
" | with_suffix : type of caller\n",
" | \n",
" | astype(self, dtype, copy=True, raise_on_error=True)\n",
" | Cast object to input numpy.dtype\n",
" | Return a copy when copy = True (be really careful with this!)\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | dtype : numpy.dtype or Python type\n",
" | raise_on_error : raise on invalid input\n",
" | \n",
" | Returns\n",
" | -------\n",
" | casted : type of caller\n",
" | \n",
" | consolidate(self, inplace=False)\n",
" | Compute NDFrame with \"consolidated\" internals (data of each dtype\n",
" | grouped together in a single ndarray). Mainly an internal API function,\n",
" | but available here to the savvy user\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | inplace : boolean, default False\n",
" | If False return new object, otherwise modify existing object\n",
" | \n",
" | Returns\n",
" | -------\n",
" | consolidated : type of caller\n",
" | \n",
" | cummax(self, axis=None, skipna=True)\n",
" | Return DataFrame of cumulative max over requested axis.\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | axis : {0, 1}\n",
" | 0 for row-wise, 1 for column-wise\n",
" | skipna : boolean, default True\n",
" | Exclude NA/null values. If an entire row/column is NA, the result\n",
" | will be NA\n",
" | \n",
" | Returns\n",
" | -------\n",
" | y : DataFrame\n",
" | \n",
" | cummin(self, axis=None, skipna=True)\n",
" | Return DataFrame of cumulative min over requested axis.\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | axis : {0, 1}\n",
" | 0 for row-wise, 1 for column-wise\n",
" | skipna : boolean, default True\n",
" | Exclude NA/null values. If an entire row/column is NA, the result\n",
" | will be NA\n",
" | \n",
" | Returns\n",
" | -------\n",
" | y : DataFrame\n",
" | \n",
" | cumprod(self, axis=None, skipna=True)\n",
" | Return cumulative product over requested axis as DataFrame\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | axis : {0, 1}\n",
" | 0 for row-wise, 1 for column-wise\n",
" | skipna : boolean, default True\n",
" | Exclude NA/null values. If an entire row/column is NA, the result\n",
" | will be NA\n",
" | \n",
" | Returns\n",
" | -------\n",
" | y : DataFrame\n",
" | \n",
" | cumsum(self, axis=None, skipna=True)\n",
" | Return DataFrame of cumulative sums over requested axis.\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | axis : {0, 1}\n",
" | 0 for row-wise, 1 for column-wise\n",
" | skipna : boolean, default True\n",
" | Exclude NA/null values. If an entire row/column is NA, the result\n",
" | will be NA\n",
" | \n",
" | Returns\n",
" | -------\n",
" | y : DataFrame\n",
" | \n",
" | get_dtype_counts(self)\n",
" | return the counts of dtypes in this frame\n",
" | \n",
" | rename_axis(self, mapper, axis=0, copy=True)\n",
" | Alter index and / or columns using input function or functions.\n",
" | Function / dict values must be unique (1-to-1). Labels not contained in\n",
" | a dict / Series will be left as-is.\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | mapper : dict-like or function, optional\n",
" | axis : int, default 0\n",
" | copy : boolean, default True\n",
" | Also copy underlying data\n",
" | \n",
" | See also\n",
" | --------\n",
" | DataFrame.rename\n",
" | \n",
" | Returns\n",
" | -------\n",
" | renamed : type of caller\n",
" | \n",
" | squeeze(self)\n",
" | squeeze length 1 dimensions\n",
" | \n",
" | tz_convert(self, tz, axis=0, copy=True)\n",
" | Convert TimeSeries to target time zone. If it is time zone naive, it\n",
" | will be localized to the passed time zone.\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | tz : string or pytz.timezone object\n",
" | copy : boolean, default True\n",
" | Also make a copy of the underlying data\n",
" | \n",
" | Returns\n",
" | -------\n",
" | \n",
" | tz_localize(self, tz, axis=0, copy=True)\n",
" | Localize tz-naive TimeSeries to target time zone\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | tz : string or pytz.timezone object\n",
" | copy : boolean, default True\n",
" | Also make a copy of the underlying data\n",
" | \n",
" | Returns\n",
" | -------\n",
" | \n",
" | ----------------------------------------------------------------------\n",
" | Data descriptors inherited from pandas.core.generic.NDFrame:\n",
" | \n",
" | empty\n",
" | \n",
" | ndim\n",
" | \n",
" | ----------------------------------------------------------------------\n",
" | Methods inherited from pandas.core.generic.PandasContainer:\n",
" | \n",
" | __hash__(self)\n",
" | \n",
" | abs(self)\n",
" | Return an object with absolute value taken. Only applicable to objects\n",
" | that are all numeric\n",
" | \n",
" | Returns\n",
" | -------\n",
" | abs: type of caller\n",
" | \n",
" | asfreq(self, freq, method=None, how=None, normalize=False)\n",
" | Convert all TimeSeries inside to specified frequency using DateOffset\n",
" | objects. Optionally provide fill method to pad/backfill missing values.\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | freq : DateOffset object, or string\n",
" | method : {'backfill', 'bfill', 'pad', 'ffill', None}\n",
" | Method to use for filling holes in reindexed Series\n",
" | pad / ffill: propagate last valid observation forward to next valid\n",
" | backfill / bfill: use NEXT valid observation to fill methdo\n",
" | how : {'start', 'end'}, default end\n",
" | For PeriodIndex only, see PeriodIndex.asfreq\n",
" | normalize : bool, default False\n",
" | Whether to reset output index to midnight\n",
" | \n",
" | Returns\n",
" | -------\n",
" | converted : type of caller\n",
" | \n",
" | at_time(self, time, asof=False)\n",
" | Select values at particular time of day (e.g. 9:30AM)\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | time : datetime.time or string\n",
" | \n",
" | Returns\n",
" | -------\n",
" | values_at_time : type of caller\n",
" | \n",
" | between_time(self, start_time, end_time, include_start=True, include_end=True)\n",
" | Select values between particular times of the day (e.g., 9:00-9:30 AM)\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | start_time : datetime.time or string\n",
" | end_time : datetime.time or string\n",
" | include_start : boolean, default True\n",
" | include_end : boolean, default True\n",
" | \n",
" | Returns\n",
" | -------\n",
" | values_between_time : type of caller\n",
" | \n",
" | drop(self, labels, axis=0, level=None)\n",
" | Return new object with labels in requested axis removed\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | labels : array-like\n",
" | axis : int\n",
" | level : int or name, default None\n",
" | For MultiIndex\n",
" | \n",
" | Returns\n",
" | -------\n",
" | dropped : type of caller\n",
" | \n",
" | first(self, offset)\n",
" | Convenience method for subsetting initial periods of time series data\n",
" | based on a date offset\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | offset : string, DateOffset, dateutil.relativedelta\n",
" | \n",
" | Examples\n",
" | --------\n",
" | ts.last('10D') -> First 10 days\n",
" | \n",
" | Returns\n",
" | -------\n",
" | subset : type of caller\n",
" | \n",
" | get(self, key, default=None)\n",
" | Get item from object for given key (DataFrame column, Panel slice,\n",
" | etc.). Returns default value if not found\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | key : object\n",
" | \n",
" | Returns\n",
" | -------\n",
" | value : type of items contained in object\n",
" | \n",
" | groupby(self, by=None, axis=0, level=None, as_index=True, sort=True, group_keys=True, squeeze=False)\n",
" | Group series using mapper (dict or key function, apply given function\n",
" | to group, return result as series) or by a series of columns\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | by : mapping function / list of functions, dict, Series, or tuple /\n",
" | list of column names.\n",
" | Called on each element of the object index to determine the groups.\n",
" | If a dict or Series is passed, the Series or dict VALUES will be\n",
" | used to determine the groups\n",
" | axis : int, default 0\n",
" | level : int, level name, or sequence of such, default None\n",
" | If the axis is a MultiIndex (hierarchical), group by a particular\n",
" | level or levels\n",
" | as_index : boolean, default True\n",
" | For aggregated output, return object with group labels as the\n",
" | index. Only relevant for DataFrame input. as_index=False is\n",
" | effectively \"SQL-style\" grouped output\n",
" | sort : boolean, default True\n",
" | Sort group keys. Get better performance by turning this off\n",
" | group_keys : boolean, default True\n",
" | When calling apply, add group keys to index to identify pieces\n",
" | squeeze : boolean, default False\n",
" | reduce the dimensionaility of the return type if possible, otherwise\n",
" | return a consistent type\n",
" | \n",
" | Examples\n",
" | --------\n",
" | # DataFrame result\n",
" | >>> data.groupby(func, axis=0).mean()\n",
" | \n",
" | # DataFrame result\n",
" | >>> data.groupby(['col1', 'col2'])['col3'].mean()\n",
" | \n",
" | # DataFrame with hierarchical index\n",
" | >>> data.groupby(['col1', 'col2']).mean()\n",
" | \n",
" | Returns\n",
" | -------\n",
" | GroupBy object\n",
" | \n",
" | last(self, offset)\n",
" | Convenience method for subsetting final periods of time series data\n",
" | based on a date offset\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | offset : string, DateOffset, dateutil.relativedelta\n",
" | \n",
" | Examples\n",
" | --------\n",
" | ts.last('5M') -> Last 5 months\n",
" | \n",
" | Returns\n",
" | -------\n",
" | subset : type of caller\n",
" | \n",
" | load(self, path)\n",
" | \n",
" | pct_change(self, periods=1, fill_method='pad', limit=None, freq=None, **kwds)\n",
" | Percent change over given number of periods\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | periods : int, default 1\n",
" | Periods to shift for forming percent change\n",
" | fill_method : str, default 'pad'\n",
" | How to handle NAs before computing percent changes\n",
" | limit : int, default None\n",
" | The number of consecutive NAs to fill before stopping\n",
" | freq : DateOffset, timedelta, or offset alias string, optional\n",
" | Increment to use from time series API (e.g. 'M' or BDay())\n",
" | \n",
" | Returns\n",
" | -------\n",
" | chg : Series or DataFrame\n",
" | \n",
" | resample(self, rule, how=None, axis=0, fill_method=None, closed=None, label=None, convention='start', kind=None, loffset=None, limit=None, base=0)\n",
" | Convenience method for frequency conversion and resampling of regular\n",
" | time-series data.\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | rule : the offset string or object representing target conversion\n",
" | how : string, method for down- or re-sampling, default to 'mean' for\n",
" | downsampling\n",
" | axis : int, optional, default 0\n",
" | fill_method : string, fill_method for upsampling, default None\n",
" | closed : {'right', 'left'}\n",
" | Which side of bin interval is closed\n",
" | label : {'right', 'left'}\n",
" | Which bin edge label to label bucket with\n",
" | convention : {'start', 'end', 's', 'e'}\n",
" | kind: \"period\"/\"timestamp\"\n",
" | loffset: timedelta\n",
" | Adjust the resampled time labels\n",
" | limit: int, default None\n",
" | Maximum size gap to when reindexing with fill_method\n",
" | base : int, default 0\n",
" | For frequencies that evenly subdivide 1 day, the \"origin\" of the\n",
" | aggregated intervals. For example, for '5min' frequency, base could\n",
" | range from 0 through 4. Defaults to 0\n",
" | \n",
" | save(self, path)\n",
" | \n",
" | select(self, crit, axis=0)\n",
" | Return data corresponding to axis labels matching criteria\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | crit : function\n",
" | To be called on each index (label). Should return True or False\n",
" | axis : int\n",
" | \n",
" | Returns\n",
" | -------\n",
" | selection : type of caller\n",
" | \n",
" | to_clipboard(self)\n",
" | Attempt to write text representation of object to the system clipboard\n",
" | \n",
" | Notes\n",
" | -----\n",
" | Requirements for your platform\n",
" | - Linux: xclip, or xsel (with gtk or PyQt4 modules)\n",
" | - Windows:\n",
" | - OS X:\n",
" | \n",
" | to_hdf(self, path_or_buf, key, **kwargs)\n",
" | activate the HDFStore\n",
" | \n",
" | to_pickle(self, path)\n",
" | Pickle (serialize) object to input file path\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | path : string\n",
" | File path\n",
" | \n",
" | tshift(self, periods=1, freq=None, **kwds)\n",
" | Shift the time index, using the index's frequency if available\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | periods : int\n",
" | Number of periods to move, can be positive or negative\n",
" | freq : DateOffset, timedelta, or time rule string, default None\n",
" | Increment to use from datetools module or time rule (e.g. 'EOM')\n",
" | \n",
" | Notes\n",
" | -----\n",
" | If freq is not specified then tries to use the freq or inferred_freq\n",
" | attributes of the index. If neither of those attributes exist, a\n",
" | ValueError is thrown\n",
" | \n",
" | Returns\n",
" | -------\n",
" | shifted : Series\n",
" | \n",
" | ----------------------------------------------------------------------\n",
" | Data descriptors inherited from pandas.core.generic.PandasContainer:\n",
" | \n",
" | at\n",
" | \n",
" | iat\n",
" | \n",
" | iloc\n",
" | \n",
" | ix\n",
" | \n",
" | loc\n",
" | \n",
" | ----------------------------------------------------------------------\n",
" | Methods inherited from pandas.core.base.StringMixin:\n",
" | \n",
" | __bytes__(self)\n",
" | Return a string representation for a particular object.\n",
" | \n",
" | Invoked by bytes(obj) in py3 only.\n",
" | Yields a bytestring in both py2/py3.\n",
" | \n",
" | __repr__(self)\n",
" | Return a string representation for a particular object.\n",
" | \n",
" | Yields Bytestring in Py2, Unicode String in py3.\n",
" | \n",
" | __str__(self)\n",
" | Return a string representation for a particular object.\n",
" | \n",
" | Invoked by str(obj) in both py2/py3.\n",
" | Yields Bytestring in Py2, Unicode String in py3.\n",
"\n",
"DATA\n",
" DEFAULT_GEO_COLUMN_NAME = 'geometry'\n",
" PY3 = False\n",
" string_types = (<type 'basestring'>,)\n",
"\n",
"\n"
]
}
],
"prompt_number": 8
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"cas = gpd.geodataframe.GeoDataFrame.from_file('CommAreas.shp')\n",
"cas"
],
"language": "python",
"metadata": {},
"outputs": [
{
"html": [
"<pre>\n",
"&lt;class 'geopandas.geodataframe.GeoDataFrame'&gt;\n",
"Int64Index: 77 entries, 0 to 76\n",
"Data columns (total 10 columns):\n",
"AREA 77 non-null values\n",
"AREA_NUMBE 77 non-null values\n",
"AREA_NUM_1 77 non-null values\n",
"COMAREA_ 77 non-null values\n",
"COMAREA_ID 77 non-null values\n",
"COMMUNITY 77 non-null values\n",
"PERIMETER 77 non-null values\n",
"SHAPE_AREA 77 non-null values\n",
"SHAPE_LEN 77 non-null values\n",
"geometry 77 non-null values\n",
"dtypes: float64(4), int64(2), object(4)\n",
"</pre>"
],
"metadata": {},
"output_type": "pyout",
"prompt_number": 13,
"text": [
"<class 'geopandas.geodataframe.GeoDataFrame'>\n",
"Int64Index: 77 entries, 0 to 76\n",
"Data columns (total 10 columns):\n",
"AREA 77 non-null values\n",
"AREA_NUMBE 77 non-null values\n",
"AREA_NUM_1 77 non-null values\n",
"COMAREA_ 77 non-null values\n",
"COMAREA_ID 77 non-null values\n",
"COMMUNITY 77 non-null values\n",
"PERIMETER 77 non-null values\n",
"SHAPE_AREA 77 non-null values\n",
"SHAPE_LEN 77 non-null values\n",
"geometry 77 non-null values\n",
"dtypes: float64(4), int64(2), object(4)"
]
}
],
"prompt_number": 13
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"cas.head(10)"
],
"language": "python",
"metadata": {},
"outputs": [
{
"html": [
"<div style=\"max-height:1000px;max-width:1500px;overflow:auto;\">\n",
"<table border=\"1\" class=\"dataframe\">\n",
" <thead>\n",
" <tr style=\"text-align: right;\">\n",
" <th></th>\n",
" <th>AREA</th>\n",
" <th>AREA_NUMBE</th>\n",
" <th>AREA_NUM_1</th>\n",
" <th>COMAREA_</th>\n",
" <th>COMAREA_ID</th>\n",
" <th>COMMUNITY</th>\n",
" <th>PERIMETER</th>\n",
" <th>SHAPE_AREA</th>\n",
" <th>SHAPE_LEN</th>\n",
" <th>geometry</th>\n",
" </tr>\n",
" </thead>\n",
" <tbody>\n",
" <tr>\n",
" <th>0</th>\n",
" <td> 0</td>\n",
" <td> 35</td>\n",
" <td> 35</td>\n",
" <td> 0</td>\n",
" <td> 0</td>\n",
" <td> DOUGLAS</td>\n",
" <td> 0</td>\n",
" <td> 46004621.1581</td>\n",
" <td> 31027.054510</td>\n",
" <td> POLYGON ((1181573.2498000003397465 1886828.039...</td>\n",
" </tr>\n",
" <tr>\n",
" <th>1</th>\n",
" <td> 0</td>\n",
" <td> 36</td>\n",
" <td> 36</td>\n",
" <td> 0</td>\n",
" <td> 0</td>\n",
" <td> OAKLAND</td>\n",
" <td> 0</td>\n",
" <td> 16913961.0408</td>\n",
" <td> 19565.506153</td>\n",
" <td> POLYGON ((1186289.3555999994277954 1876750.733...</td>\n",
" </tr>\n",
" <tr>\n",
" <th>2</th>\n",
" <td> 0</td>\n",
" <td> 37</td>\n",
" <td> 37</td>\n",
" <td> 0</td>\n",
" <td> 0</td>\n",
" <td> FULLER PARK</td>\n",
" <td> 0</td>\n",
" <td> 19916704.8692</td>\n",
" <td> 25339.089750</td>\n",
" <td> POLYGON ((1176344.9979999996721745 1871187.545...</td>\n",
" </tr>\n",
" <tr>\n",
" <th>3</th>\n",
" <td> 0</td>\n",
" <td> 38</td>\n",
" <td> 38</td>\n",
" <td> 0</td>\n",
" <td> 0</td>\n",
" <td> GRAND BOULEVARD</td>\n",
" <td> 0</td>\n",
" <td> 48492503.1554</td>\n",
" <td> 28196.837157</td>\n",
" <td> POLYGON ((1182322.0428999997675419 1876674.730...</td>\n",
" </tr>\n",
" <tr>\n",
" <th>4</th>\n",
" <td> 0</td>\n",
" <td> 39</td>\n",
" <td> 39</td>\n",
" <td> 0</td>\n",
" <td> 0</td>\n",
" <td> KENWOOD</td>\n",
" <td> 0</td>\n",
" <td> 29071741.9283</td>\n",
" <td> 23325.167906</td>\n",
" <td> POLYGON ((1186289.3555999994277954 1876750.733...</td>\n",
" </tr>\n",
" <tr>\n",
" <th>5</th>\n",
" <td> 0</td>\n",
" <td> 4</td>\n",
" <td> 4</td>\n",
" <td> 0</td>\n",
" <td> 0</td>\n",
" <td> LINCOLN SQUARE</td>\n",
" <td> 0</td>\n",
" <td> 71352328.2399</td>\n",
" <td> 36624.603085</td>\n",
" <td> POLYGON ((1163421.8401000015437603 1934571.070...</td>\n",
" </tr>\n",
" <tr>\n",
" <th>6</th>\n",
" <td> 0</td>\n",
" <td> 40</td>\n",
" <td> 40</td>\n",
" <td> 0</td>\n",
" <td> 0</td>\n",
" <td> WASHINGTON PARK</td>\n",
" <td> 0</td>\n",
" <td> 42373881.4842</td>\n",
" <td> 28175.316087</td>\n",
" <td> POLYGON ((1182600.2496999986469746 1865402.018...</td>\n",
" </tr>\n",
" <tr>\n",
" <th>7</th>\n",
" <td> 0</td>\n",
" <td> 41</td>\n",
" <td> 41</td>\n",
" <td> 0</td>\n",
" <td> 0</td>\n",
" <td> HYDE PARK</td>\n",
" <td> 0</td>\n",
" <td> 45105380.1732</td>\n",
" <td> 29746.708202</td>\n",
" <td> POLYGON ((1189545.4585999995470047 1871529.775...</td>\n",
" </tr>\n",
" <tr>\n",
" <th>8</th>\n",
" <td> 0</td>\n",
" <td> 42</td>\n",
" <td> 42</td>\n",
" <td> 0</td>\n",
" <td> 0</td>\n",
" <td> WOODLAWN</td>\n",
" <td> 0</td>\n",
" <td> 57815179.5120</td>\n",
" <td> 46936.959244</td>\n",
" <td> POLYGON ((1190479.1906000003218651 1865569.238...</td>\n",
" </tr>\n",
" <tr>\n",
" <th>9</th>\n",
" <td> 0</td>\n",
" <td> 1</td>\n",
" <td> 1</td>\n",
" <td> 0</td>\n",
" <td> 0</td>\n",
" <td> ROGERS PARK</td>\n",
" <td> 0</td>\n",
" <td> 51259902.4506</td>\n",
" <td> 34052.397576</td>\n",
" <td> POLYGON ((1168756.1147000007331371 1942653.008...</td>\n",
" </tr>\n",
" </tbody>\n",
"</table>\n",
"</div>"
],
"metadata": {},
"output_type": "pyout",
"prompt_number": 12,
"text": [
" AREA AREA_NUMBE AREA_NUM_1 COMAREA_ COMAREA_ID COMMUNITY \\\n",
"0 0 35 35 0 0 DOUGLAS \n",
"1 0 36 36 0 0 OAKLAND \n",
"2 0 37 37 0 0 FULLER PARK \n",
"3 0 38 38 0 0 GRAND BOULEVARD \n",
"4 0 39 39 0 0 KENWOOD \n",
"5 0 4 4 0 0 LINCOLN SQUARE \n",
"6 0 40 40 0 0 WASHINGTON PARK \n",
"7 0 41 41 0 0 HYDE PARK \n",
"8 0 42 42 0 0 WOODLAWN \n",
"9 0 1 1 0 0 ROGERS PARK \n",
"\n",
" PERIMETER SHAPE_AREA SHAPE_LEN \\\n",
"0 0 46004621.1581 31027.054510 \n",
"1 0 16913961.0408 19565.506153 \n",
"2 0 19916704.8692 25339.089750 \n",
"3 0 48492503.1554 28196.837157 \n",
"4 0 29071741.9283 23325.167906 \n",
"5 0 71352328.2399 36624.603085 \n",
"6 0 42373881.4842 28175.316087 \n",
"7 0 45105380.1732 29746.708202 \n",
"8 0 57815179.5120 46936.959244 \n",
"9 0 51259902.4506 34052.397576 \n",
"\n",
" geometry \n",
"0 POLYGON ((1181573.2498000003397465 1886828.039... \n",
"1 POLYGON ((1186289.3555999994277954 1876750.733... \n",
"2 POLYGON ((1176344.9979999996721745 1871187.545... \n",
"3 POLYGON ((1182322.0428999997675419 1876674.730... \n",
"4 POLYGON ((1186289.3555999994277954 1876750.733... \n",
"5 POLYGON ((1163421.8401000015437603 1934571.070... \n",
"6 POLYGON ((1182600.2496999986469746 1865402.018... \n",
"7 POLYGON ((1189545.4585999995470047 1871529.775... \n",
"8 POLYGON ((1190479.1906000003218651 1865569.238... \n",
"9 POLYGON ((1168756.1147000007331371 1942653.008... "
]
}
],
"prompt_number": 12
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"cas.plot()"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 14,
"text": [
"<matplotlib.axes.AxesSubplot at 0x1056a30d0>"
]
},
{
"metadata": {},
"output_type": "display_data",
"png": "iVBORw0KGgoAAAANSUhEUgAAARUAAAEACAYAAACd9eLKAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nEsnhyf8D0r7YoQnMfsMAAAAASUVORK5CYII=\n",
"text": [
"<matplotlib.figure.Figure at 0x105696b50>"
]
}
],
"prompt_number": 14
},
{
"cell_type": "code",
"collapsed": false,
"input": [],
"language": "python",
"metadata": {},
"outputs": []
}
],
"metadata": {}
}
]
}
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment