arcgis.features module¶
The arcgis.features module contains types and functions for working with features and feature layers in the GIS.
Entities located in space with a geometrical representation (such as points, lines or polygons) and a set of properties can be represented as features. The arcgis.features module is used for working with feature data, feature layers and collections of feature layers in the GIS. It also contains the spatial analysis functions which operate against feature data.
In the GIS, entities located in space with a set of properties can be represented as features. Features are stored as feature classes, which represent a set of features located using a single spatial type (point, line, polygon) and a common set of properties. This is the geographic extension of the classic tabular or relational representation for entities  a set of entities is modelled as rows in a table. Tables represent entity classes with uniform properties. In addition to working with entities with location as features, the system can also work with nonspatial entities as rows in tables. The system can also model relationships between entities using properties which act as primary and foreign keys. A collection of feature classes and tables, with the associated relationships among the entities, is a feature layer collection. FeatureLayerCollections are one of the dataset types contained in a Datastore. Finally, features are not simply entities in a dataset. Features have a visual representation and user experience  on a map, in a 3D scene, as entities with a property sheet or popups.
arcgis.features.Feature¶

class
arcgis.features.
Feature
(geometry=None, attributes=None)¶ Entities located in space with a set of properties can be represented as features.
# Obtain a feature from a feature layer: feat_set = feature_layer.query(where="OBJECTID=1") feat = feat_set[0]

property
as_dict
¶  Returns
the feature as a dictionary

property
as_row
¶  Returns
the feature as a tuple containing two lists:
List of:
Description
row values
the specific attribute values and geometry for this feature
field names
the name for each attribute field

property
attributes
¶  Returns
a dictionary of feature attribute values with field names as the key

property
fields
¶  Returns
attribute field names for the feature as a list of strings

classmethod
from_dict
(feature)¶  Returns
a feature from a dict

classmethod
from_json
(json_str)¶  Returns
a feature from a JSON string

property
geometry
¶  Returns
the feature geometry

property
geometry_type
¶  Returns
the geometry type of the feature as a string

get_value
(field_name)¶ Retrieves the value for a specified field name
Argument
Description
field name
Required String. The name of the field to get the value for.feature.fields
will return a list of all field names. Returns
value for the specified attribute field of the feature.

set_value
(field_name, value)¶ Sets an attribute value for a given field name
Argument
Description
field_name
Required String. The name of the field to update.
value
Required. Value to update the field with.
 Returns
boolean indicating whether field_name value was updated.

property
arcgis.features.FeatureLayer¶

class
arcgis.features.
FeatureLayer
(url, gis=None, container=None, dynamic_layer=None)¶ The feature layer is the primary concept for working with features in a GIS.
Users create, import, export, analyze, edit, and visualize features, i.e. entities in space as feature layers.
Feature layers can be added to and visualized using maps. They act as inputs to and outputs from feature analysis tools.
Feature layers are created by publishing feature data to a GIS, and are exposed as a broader resource (Item) in the GIS. Feature layer objects can be obtained through the layers attribute on feature layer Items in the GIS.

append
(item_id=None, upload_format='featureCollection', source_table_name=None, field_mappings=None, edits=None, source_info=None, upsert=True, skip_updates=False, use_globalids=False, update_geometry=True, append_fields=None, rollback=False, skip_inserts=None, upsert_matching_field=None)¶ Only available in ArcGIS Online
Update an existing hosted feature layer using append.
Argument
Description
source_table_name
optional string. Required only when the source data contains more than one tables, e.g., for file geodatabase. Example: source_table_name= “Building”
item_id
optional string. The ID for the Portal item that contains the source file. Used in conjunction with editsUploadFormat.
field_mappings
optional list. Used to map source data to a destination layer. Syntax: fieldMappings=[{“name” : <”targerName”>,
“sourceName” : < “sourceName”>}, …]
 Examples: fieldMappings=[{“name”“CountyID”,
“sourceName” : “GEOID10”}]
edits
optional string. Only feature collection json is supported. Append supports all format through the upload_id or item_id.
source_info
optional dictionary. This is only needed when appending data from excel or csv. The appendSourceInfo can be the publishing parameter returned from analyze the csv or excel file.
upsert
optional boolean. Optional parameter specifying whether the edits needs to be applied as updates if the feature already exists. Default is false.
skip_updates
Optional boolean. Parameter is used only when upsert is true.
use_globalids
Optional boolean. Specifying whether upsert needs to use GlobalId when matching features.
update_geometry
Optional boolean. The parameter is used only when upsert is true. Skip updating the geometry and update only the attributes for existing features if they match source features by objectId or globalId.(as specified by useGlobalIds parameter).
append_fields
Optional list. The list of destination fields to append to. This is supported when upsert=true or false. Values: [“fieldName1”, “fieldName2”,….]
upload_format
required string. The source append data format. The default is featureCollection format. Values: sqlite  shapefile  filegdb  featureCollection  geojson  csv  excel
rollback
Optional boolean. Optional parameter specifying whether the upsert edits needs to be rolled back in case of failure. Default is false.
skip_inserts
Used only when upsert is true. Used to skip inserts if the value is true. The default value is false.
upsert_matching_field
Optional string. The layer field to be used when matching features with upsert. ObjectId, GlobalId, and any other field that has a unique index can be used with upsert. This parameter overrides use_globalids; e.g., specifying upsert_matching_field will be used even if you specify use_globalids = True. Example: upsert_matching_field=”MyfieldWithUniqueIndex”
 Returns
boolean

calculate
(where, calc_expression, sql_format='standard', version=None, sessionid=None, return_edit_moment=None, future=False)¶ The calculate operation is performed on a feature layer resource. It updates the values of one or more fields in an existing feature service layer based on SQL expressions or scalar values. The calculate operation can only be used if the supportsCalculate property of the layer is true. Neither the Shape field nor system fields can be updated using calculate. System fields include ObjectId and GlobalId. See Calculate a field for more information on supported expressions
Inputs
Description
where
Required String. A where clause can be used to limit the updated records. Any legal SQL where clause operating on the fields in the layer is allowed.
calc_expression
Required List. The array of field/value info objects that contain the field or fields to update and their scalar values or SQL expression. Allowed types are dictionary and list. List must be a list of dictionary objects.
Calculation Format is as follows:
{“field” : “<field name>”, “value” : “<value>”}
sql_format
Optional String. The SQL format for the calc_expression. It can be either standard SQL92 (standard) or native SQL (native). The default is standard.
Values: standard, native
version
Optional String. The geodatabase version to apply the edits.
sessionid
Optional String. A parameter which is set by a client during long transaction editing on a branch version. The sessionid is a GUID value that clients establish at the beginning and use throughout the edit session. The sessonid ensures isolation during the edit session. This parameter applies only if the isDataBranchVersioned property of the layer is true.
return_edit_moment
Optional Boolean. This parameter specifies whether the response will report the time edits were applied. If true, the server will return the time edits were applied in the response’s edit moment key. This parameter applies only if the isDataBranchVersioned property of the layer is true.
future
Optional Boolean. If True, the result is returned as a future object and the results are obtained in an asynchronous fashion. False is the default.
This applies to 10.8+ only
# Usage Example 1: print(fl.calculate(where="OBJECTID < 2", calc_expression={"field": "ZONE", "value" : "R1"}))
# Usage Example 2: print(fl.calculate(where="OBJECTID < 2001", calc_expression={"field": "A", "sqlExpression" : "B*3"}))
Output: dictionary with format {‘updatedFeatureCount’: 1, ‘success’: True}

property
container
¶ The feature layer collection to which this layer belongs.

delete_features
(deletes=None, where=None, geometry_filter=None, gdb_version=None, rollback_on_failure=True, return_delete_results=True, future=False)¶ This operation deletes features in a feature layer or table
Argument
Description
deletes
Optional string. A comma seperated string of OIDs to remove from the service.
where
Optional string. A where clause for the query filter. Any legal SQL where clause operating on the fields in the layer is allowed. Features conforming to the specified where clause will be deleted.
geometry_filter
Optional SpatialFilter. A spatial filter from arcgis.geometry.filters module to filter results by a spatial relationship with another geometry.
gdb_version
Optional string. A Geodatabase version to apply the edits.
rollback_on_failure
Optional boolean. Optional parameter to specify if the edits should be applied only if all submitted edits succeed. If false, the server will apply the edits that succeed even if some of the submitted edits fail. If true, the server will apply the edits only if all edits succeed. The default value is true.
return_delete_results
Optional Boolean. Optional parameter that indicates whether a result is returned per deleted row when the deleteFeatures operation is run. The default is true.
future
Optional Boolean. If future=True, then the operation will occur asynchronously else the operation will occur synchronously. False is the default.
 Returns
Dict if future=False (default), else a concurrent.Future class.

edit_features
(adds=None, updates=None, deletes=None, gdb_version=None, use_global_ids=False, rollback_on_failure=True, return_edit_moment=False, attachments=None, true_curve_client=False, session_id=None, use_previous_moment=False, datum_transformation=None)¶ This operation adds, updates, and deletes features to the associated feature layer or table in a single call.
Inputs
Description
adds
Optional FeatureSet/List. The array of features to be added.
updates
Optional FeatureSet/List. The array of features to be updated.
deletes
Optional FeatureSet/List. string of OIDs to remove from service
use_global_ids
Optional boolean. Instead of referencing the default Object ID field, the service will look at a GUID field to track changes. This means the GUIDs will be passed instead of OIDs for delete, update or add features.
gdb_version
Optional boolean. Geodatabase version to apply the edits.
rollback_on_failure
Optional boolean. Optional parameter to specify if the edits should be applied only if all submitted edits succeed. If false, the server will apply the edits that succeed even if some of the submitted edits fail. If true, the server will apply the edits only if all edits succeed. The default value is true.
return_edit_moment
Optional boolean. Introduced at 10.5, only applicable with ArcGIS Server services only. Specifies whether the response will report the time edits were applied. If set to true, the server will return the time in the response’s editMoment key. The default value is false.
attachments
Optional Dict. This parameter adds, updates, or deletes attachments. It applies only when the use_global_ids parameter is set to true. For adds, the globalIds of the attachments provided by the client are preserved. When useGlobalIds is true, updates and deletes are identified by each feature or attachment globalId, rather than their objectId or attachmentId. This parameter requires the layer’s supportsApplyEditsWithGlobalIds property to be true.
Attachments to be added or updated can use either preuploaded data or base 64 encoded data.
Inputs
Inputs
Description
adds
List of attachments to add.
updates
List of attachements to update
deletes
List of attachments to delete
Additional attachment information here.
true_curve_client
Optional boolean. Introduced at 10.5. Indicates to the server whether the client is true curve capable. When set to true, this indicates to the server that true curve geometries should be downloaded and that geometries containing true curves should be consumed by the map service without densifying it. When set to false, this indicates to the server that the client is not true curves capable. The default value is false.
session_id
Optional String. Introduced at 10.6. The session_id is a GUID value that clients establish at the beginning and use throughout the edit session. The sessonID ensures isolation during the edit session. The session_id parameter is set by a client during long transaction editing on a branch version.
use_previous_moment
Optional Boolean. Introduced at 10.6. The use_previous_moment parameter is used to apply the edits with the same edit moment as the previous set of edits. This allows an editor to apply single block of edits partially, complete another task and then complete the block of edits. This parameter is set by a client during long transaction editing on a branch version.
When set to true, the edits are applied with the same edit moment as the previous set of edits. When set to false or not set (default) the edits are applied with a new edit moment.
datum_transformation
Optional Integer/Dictionary. This parameter applies a datum transformation while projecting geometries in the results when out_sr is different than the layer’s spatial reference. When specifying transformations, you need to think about which datum transformation best projects the layer (not the feature service) to the outSR and sourceSpatialReference property in the layer properties. For a list of valid datum transformation ID values ad wellknown text strings, see Coordinate systems and transformations. For more information on datum transformations, please see the transformation parameter in the Project operation.
Examples
Inputs
Description
WKID
Integer. Ex: datum_transformation=4326
WKT
Dict. Ex: datum_transformation={“wkt”: “<WKT>”}
Composite
Dict. Ex: datum_transformation=```{‘geoTransforms’:[{‘wkid’:<id>,’forward’:<truefalse>},{‘wkt’:’<WKT>’,’forward’:<TrueFalse>}]}```
Output: dictionary

export_attachments
(output_folder, label_field=None)¶ Exports attachments from the feature layer in Imagenet format using the output_label_field.
Argument
Description
output_folder
Required. Output folder where the attachments will be stored.
label_field
Optional. Field which contains the label/category of each feature. If None, a default folder is created.

classmethod
fromitem
(item, layer_id=0)¶ Creates a feature layer from a GIS Item. The type of item should be a ‘Feature Service’ that represents a FeatureLayerCollection. The layer_id is the id of the layer in feature layer collection (feature service).

generate_renderer
(definition, where=None)¶ This operation groups data using the supplied definition (classification definition) and an optional where clause. The result is a renderer object. Use baseSymbol and colorRamp to define the symbols assigned to each class. If the operation is performed on a table, the result is a renderer object containing the data classes and no symbols.
Argument
Description
definition
required dict. The definition using the renderer that is generated. Use either class breaks or unique value classification definitions. See: https://resources.arcgis.com/en/help/rest/apiref/ms_classification.html
where
optional string. A where clause for which the data needs to be classified. Any legal SQL where clause operating on the fields in the dynamic layer/table is allowed.
 Returns
dictionary

get_html_popup
(oid)¶ The htmlPopup resource provides details about the HTML popup authored by the user using ArcGIS for Desktop.
Argument
Description
oid
Optional string. Object id of the feature to get the HTML popup.
 Returns
string

get_unique_values
(attribute, query_string='1=1')¶ Return a list of unique values for a given attribute
Argument
Description
attribute
Required string. The feature layer attribute to query.
query_string
Optional string. SQL Query that will be used to filter attributes before unique values are returned. ex. “name_2 like ‘%K%’”

property
manager
¶ Helper object to manage the feature layer, update it’s definition, etc

property
metadata
¶ The metadata property allows for the setting and downloading of the Feature Layer’s metadata. If metadata is disabled on the GIS or the layer does not support metdata, None value will be returned.
Argument
Description
value
Required String. (SET) Path to the metadata file.
 Returns
String (GET)

property
properties
¶ The properties of this object

query
(where='1=1', out_fields='*', time_filter=None, geometry_filter=None, return_geometry=True, return_count_only=False, return_ids_only=False, return_distinct_values=False, return_extent_only=False, group_by_fields_for_statistics=None, statistic_filter=None, result_offset=None, result_record_count=None, object_ids=None, distance=None, units=None, max_allowable_offset=None, out_sr=None, geometry_precision=None, gdb_version=None, order_by_fields=None, out_statistics=None, return_z=False, return_m=False, multipatch_option=None, quantization_parameters=None, return_centroid=False, return_all_records=True, result_type=None, historic_moment=None, sql_format=None, return_true_curves=False, return_exceeded_limit_features=None, as_df=False, datum_transformation=None, **kwargs)¶ Queries a feature layer based on a sql statement
Argument
Description
where
Optional string. The default is 1=1. The selection sql statement.
out_fields
Optional List of field names to return. Field names can be specified either as a List of field names or as a comma separated string. The default is “*”, which returns all the fields.
object_ids
Optional string. The object IDs of this layer or table to be queried. The object ID values should be a commaseparated string.
distance
Optional integer. The buffer distance for the input geometries. The distance unit is specified by units. For example, if the distance is 100, the query geometry is a point, units is set to meters, and all points within 100 meters of the point are returned.
units
Optional string. The unit for calculating the buffer distance. If unit is not specified, the unit is derived from the geometry spatial reference. If the geometry spatial reference is not specified, the unit is derived from the feature service data spatial reference. This parameter only applies if supportsQueryWithDistance is true. Values: esriSRUnit_Meter  esriSRUnit_StatuteMile 
esriSRUnit_Foot  esriSRUnit_Kilometer  esriSRUnit_NauticalMile  esriSRUnit_USNauticalMile
time_filter
Optional list. The format is of [<startTime>, <endTime>] using datetime.date, datetime.datetime or timestamp in milliseconds. Syntax: time_filter=[<startTime>, <endTime>] ; specified as
datetime.date, datetime.datetime or timestamp in milliseconds
geometry_filter
Optional from arcgis.geometry.filter. Allows for the information to be filtered on spatial relationship with another geometry.
max_allowable_offset
Optional float. This option can be used to specify the max_allowable_offset to be used for generalizing geometries returned by the query operation. The max_allowable_offset is in the units of out_sr. If out_sr is not specified, max_allowable_offset is assumed to be in the unit of the spatial reference of the layer.
out_sr
Optional Integer. The WKID for the spatial reference of the returned geometry.
geometry_precision
Optional Integer. This option can be used to specify the number of decimal places in the response geometries returned by the query operation. This applies to X and Y values only (not m or zvalues).
gdb_version
Optional string. The geodatabase version to query. This parameter applies only if the isDataVersioned property of the layer is true. If this is not specified, the query will apply to the published map’s version.
return_geometry
Optional boolean. If true, geometry is returned with the query. Default is true.
return_distinct_values
Optional boolean. If true, it returns distinct values based on the fields specified in out_fields. This parameter applies only if the supportsAdvancedQueries property of the layer is true.
return_ids_only
Optional boolean. Default is False. If true, the response only includes an array of object IDs. Otherwise, the response is a feature set.
return_count_only
Optional boolean. If true, the response only includes the count (number of features/records) that would be returned by a query. Otherwise, the response is a feature set. The default is false. This option supersedes the returnIdsOnly parameter. If returnCountOnly = true, the response will return both the count and the extent.
return_extent_only
Optional boolean. If true, the response only includes the extent of the features that would be returned by the query. If returnCountOnly=true, the response will return both the count and the extent. The default is false. This parameter applies only if the supportsReturningQueryExtent property of the layer is true.
order_by_fields
Optional string. One or more field names on which the features/records need to be ordered. Use ASC or DESC for ascending or descending, respectively, following every field to control the ordering. example: STATE_NAME ASC, RACE DESC, GENDER
group_by_fields_for_statistics
Optional string. One or more field names on which the values need to be grouped for calculating the statistics. example: STATE_NAME, GENDER
out_statistics
Optional string. The definitions for one or more fieldbased statistics to be calculated.
Syntax:
 [
 {
“statisticType”: “<count  sum  min  max  avg  stddev  var>”, “onStatisticField”: “Field1”, “outStatisticFieldName”: “Out_Field_Name1”
}, {
“statisticType”: “<count  sum  min  max  avg  stddev  var>”, “onStatisticField”: “Field2”, “outStatisticFieldName”: “Out_Field_Name2”
}
]
return_z
Optional boolean. If true, Z values are included in the results if the features have Z values. Otherwise, Z values are not returned. The default is False.
return_m
Optional boolean. If true, M values are included in the results if the features have M values. Otherwise, M values are not returned. The default is false.
multipatch_option
Optional x/y footprint. This option dictates how the geometry of a multipatch feature will be returned.
result_offset
Optional integer. This option can be used for fetching query results by skipping the specified number of records and starting from the next record (that is, resultOffset + 1th). This option is ignored if return_all_records is True (i.e. by default).
result_record_count
Optional integer. This option can be used for fetching query results up to the result_record_count specified. When result_offset is specified but this parameter is not, the map service defaults it to max_record_count. The maximum value for this parameter is the value of the layer’s max_record_count property. This option is ignored if return_all_records is True (i.e. by default).
quantization_parameters
Optional dict. Used to project the geometry onto a virtual grid, likely representing pixels on the screen.
return_centroid
Optional boolean. Used to return the geometry centroid associated with each feature returned. If true, the result includes the geometry centroid. The default is false.
return_all_records
Optional boolean. When True, the query operation will call the service until all records that satisfy the where_clause are returned. Note: result_offset and result_record_count will be ignored if return_all_records is True. Also, if return_count_only, return_ids_only, or return_extent_only are True, this parameter will be ignored.
result_type
Optional string. The result_type parameter can be used to control the number of features returned by the query operation. Values: None  standard  tile
historic_moment
Optional integer. The historic moment to query. This parameter applies only if the layer is archiving enabled and the supportsQueryWithHistoricMoment property is set to true. This property is provided in the layer resource.
If historic_moment is not specified, the query will apply to the current features.
sql_format
Optional string. The sql_format parameter can be either standard SQL92 standard or it can use the native SQL of the underlying datastore native. The default is none which means the sql_format depends on useStandardizedQuery parameter. Values: none  standard  native
return_true_curves
Optional boolean. When set to true, returns true curves in output geometries. When set to false, curves are converted to densified polylines or polygons.
return_exceeded_limit_features
Optional boolean. Optional parameter which is true by default. When set to true, features are returned even when the results include ‘exceededTransferLimit’: True.
When set to false and querying with resultType = tile features are not returned when the results include ‘exceededTransferLimit’: True. This allows a client to find the resolution in which the transfer limit is no longer exceeded without making multiple calls.
as_df
Optional boolean. If True, the results are returned as a DataFrame instead of a FeatureSet.
datum_transformation
Optional Integer/Dictionary. This parameter applies a datum transformation while projecting geometries in the results when out_sr is different than the layer’s spatial reference. When specifying transformations, you need to think about which datum transformation best projects the layer (not the feature service) to the outSR and sourceSpatialReference property in the layer properties. For a list of valid datum transformation ID values ad wellknown text strings, see Coordinate systems and transformations. For more information on datum transformations, please see the transformation parameter in the Project operation.
Examples
Inputs
Description
WKID
Integer. Ex: datum_transformation=4326
WKT
Dict. Ex: datum_transformation={“wkt”: “<WKT>”}
Composite
Dict. Ex: datum_transformation=```{‘geoTransforms’:[{‘wkid’:<id>,’forward’:<truefalse>},{‘wkt’:’<WKT>’,’forward’:<TrueFalse>}]}```
kwargs
Optional dict. Optional parameters that can be passed to the Query function. This will allow users to pass additional parameters not explicitly implemented on the function. A complete list of functions available is documented on the Query REST API.
 Returns
A FeatureSet containing the features matching the query unless another return type is specified, such as count
The Query operation is performed on a feature service layer resource. The result of this operation are feature sets grouped by source layer/table object IDs. Each feature set contains Feature objects including the values for the fields requested by the user. For related layers, if you request geometry information, the geometry of each feature is also returned in the feature set. For related tables, the feature set does not include geometries.
Argument
Description
object_ids
Required string. The object IDs of the table/layer to be queried
relationship_id
Required string. The ID of the relationship to be queried.
out_fields
Required string. the list of fields from the related table/layer to be included in the returned feature set. This list is a comma delimited list of field names. If you specify the shape field in the list of return fields, it is ignored. To request geometry, set return_geometry to true. You can also specify the wildcard “*” as the value of this parameter. In this case, the results will include all the field values.
definition_expression
Optional string. The definition expression to be applied to the related table/layer. From the list of objectIds, only those records that conform to this expression are queried for related records.
return_geometry
Optional boolean. If true, the feature set includes the geometry associated with each feature. The default is true.
max_allowable_offset
Optional float. This option can be used to specify the max_allowable_offset to be used for generalizing geometries returned by the query operation. The max_allowable_offset is in the units of the outSR. If out_wkid is not specified, then max_allowable_offset is assumed to be in the unit of the spatial reference of the map.
geometry_precision
Optional integer. This option can be used to specify the number of decimal places in the response geometries.
out_wkid
Optional Integer. The spatial reference of the returned geometry.
gdb_version
Optional string. The geodatabase version to query. This parameter applies only if the isDataVersioned property of the layer queried is true.
return_z
Optional boolean. If true, Z values are included in the results if the features have Z values. Otherwise, Z values are not returned. The default is false.
return_m
Optional boolean. If true, M values are included in the results if the features have M values. Otherwise, M values are not returned. The default is false.
historic_moment
Optional Integer/datetime. The historic moment to query. This parameter applies only if the supportsQueryWithHistoricMoment property of the layers being queried is set to true. This setting is provided in the layer resource.
If historic_moment is not specified, the query will apply to the current features.
Syntax: historic_moment=<Epoch time in milliseconds>
return_true_curves
Optional boolean. Optional parameter that is false by default. When set to true, returns true curves in output geometries; otherwise, curves are converted to densified polylines or polygons.
 Returns
dict

query_top_features
(top_filter=None, where=None, objectids=None, start_time=None, end_time=None, geometry_filter=None, out_fields='*', return_geometry=True, return_centroid=False, max_allowable_offset=None, out_sr=None, geometry_precision=None, return_ids_only=False, return_extents_only=False, order_by_field=None, return_z=False, return_m=False, result_type=None, as_df=True)¶ The query_top_features is performed on a feature layer. This operation returns a feature set or spatially enabled dataframe based on the top features by order within a group. For example, when querying counties in the United States, you want to return the top five counties by population in each state. To do this, you can use query_top_feaures to group by state name, order by desc on the population and return the first five rows from each group (state).
The top_filter parameter is used to set the group by, order by, and count criteria used in generating the result. The operation also has many of the same parameters (for example, where and geometry) as the layer query operation. However, unlike the layer query operation, query_top_feaures does not support parameters such as outStatistics and its related parameters or return distinct values. Consult the advancedQueryCapabilities layer property for more details.
If the feature layer collection supports the query_top_feaures operation, it will include “supportsTopFeaturesQuery”: true, in the advancedQueryCapabilities layer property.
Argument
Description
top_filter
Required Dict. The top_filter define the aggregation of the data.
 groupByFields define the field or fields used to aggregate
your data.
 topCount defines the number of features returned from the top
features query and is a numeric value.
 orderByFields defines the order in which the top features will
be returned. orderByFields can be specified in either ascending (asc) or descending (desc) order, ascending being the default.
 Example: {“groupByFields”: “worker”, “topCount”: 1,
“orderByFields”: “employeeNumber”}
where
Optional String. A WHERE clause for the query filter. SQL ‘92 WHERE clause syntax on the fields in the layer is supported for most data sources.
objectids
Optional List. The object IDs of the layer or table to be queried.
start_time
Optional Datetime. The starting time to query for.
end_time
Optional Datetime. The end date to query for.
geometry_filter
Optional from arcgis.geometry.filter. Allows for the information to be filtered on spatial relationship with another geometry.
out_fields
Optional String. The list of fields to include in the return results.
return_geometry
Optional Boolean. If False, the query will not return geometries. The default is True.
return_centroid
Optional Boolean. If True, the centroid of the geometry will be added to the output.
max_allowable_offset
Optional float. This option can be used to specify the max_allowable_offset to be used for generalizing geometries returned by the query operation. The max_allowable_offset is in the units of out_sr. If out_sr is not specified, max_allowable_offset is assumed to be in the unit of the spatial reference of the layer.
out_sr
Optional Integer. The WKID for the spatial reference of the returned geometry.
geometry_precision
Optional Integer. This option can be used to specify the number of decimal places in the response geometries returned by the query operation. This applies to X and Y values only (not m or zvalues).
return_ids_only
Optional boolean. Default is False. If true, the response only includes an array of object IDs. Otherwise, the response is a feature set.
return_extent_only
Optional boolean. If true, the response only includes the extent of the features that would be returned by the query. If returnCountOnly=true, the response will return both the count and the extent. The default is false. This parameter applies only if the supportsReturningQueryExtent property of the layer is true.
order_by_field
Optional Str. Optional string. One or more field names on which the features/records need to be ordered. Use ASC or DESC for ascending or descending, respectively, following every field to control the ordering. example: STATE_NAME ASC, RACE DESC, GENDER
return_z
Optional boolean. If true, Z values are included in the results if the features have Z values. Otherwise, Z values are not returned. The default is False.
return_m
Optional boolean. If true, M values are included in the results if the features have M values. Otherwise, M values are not returned. The default is false.
result_type
Optional String. The result_type can be used to control the number of features returned by the query operation. Values: none  standard  tile
as_df
Optional Boolean. If False, the result is returned as a FeatureSet. If True (default) the result is returned as a spatially enabled dataframe.
 Returns
Default  pd.DataFrame, when as_df=False returns a FeatureSet. If return_count_only is True, the return type is Integer. If the return_ids_only is True, a list of value is returned.

update_metadata
(file_path)¶ Updates a Layer’s metadata from an xml file.
Argument
Description
file_path
Required String. The path to the .xml file that contains the metadata.
 Returns
boolean

validate_sql
(sql, sql_type='where')¶ The validate_sql operation validates an SQL92 expression or WHERE clause. The validate_sql operation ensures that an SQL92 expression, such as one written by a user through a user interface, is correct before performing another operation that uses the expression. For example, validateSQL can be used to validate information that is subsequently passed in as part of the where parameter of the calculate operation. validate_sql also prevents SQL injection. In addition, all table and field names used in the SQL expression or WHERE clause are validated to ensure they are valid tables and fields.
Argument
Description
sql
Required String. The SQL expression of WHERE clause to validate. Example: “Population > 300000”
sql_type
 Optional String. Three SQL types are supported in validate_sql
where (default)  Represents the custom WHERE clause the user can compose when querying a layer or using calculate.
expression  Represents an SQL92 expression. Currently, expression is used as a default value expression when adding a new field or using the calculate API.
statement  Represents the full SQL92 statement that can be passed directly to the database. No current ArcGIS REST API resource or operation supports using the full SQL92 SELECT statement directly. It has been added to the validateSQL for completeness. Values: where  expression  statement
 Returns
dict

arcgis.features.Table¶

class
arcgis.features.
Table
(url, gis=None, container=None, dynamic_layer=None)¶ Tables represent entity classes with uniform properties. In addition to working with “entities with location” as features, the GIS can also work with nonspatial entities as rows in tables.
Working with tables is similar to working with feature layers, except that the rows (Features) in a table do not have a geometry, and tables ignore any geometry related operation.

append
(item_id=None, upload_format='featureCollection', source_table_name=None, field_mappings=None, edits=None, source_info=None, upsert=True, skip_updates=False, use_globalids=False, update_geometry=True, append_fields=None, rollback=False, skip_inserts=None, upsert_matching_field=None)¶ Only available in ArcGIS Online
Update an existing hosted feature layer using append.
Argument
Description
source_table_name
optional string. Required only when the source data contains more than one tables, e.g., for file geodatabase. Example: source_table_name= “Building”
item_id
optional string. The ID for the Portal item that contains the source file. Used in conjunction with editsUploadFormat.
field_mappings
optional list. Used to map source data to a destination layer. Syntax: fieldMappings=[{“name” : <”targerName”>,
“sourceName” : < “sourceName”>}, …]
 Examples: fieldMappings=[{“name”“CountyID”,
“sourceName” : “GEOID10”}]
edits
optional string. Only feature collection json is supported. Append supports all format through the upload_id or item_id.
source_info
optional dictionary. This is only needed when appending data from excel or csv. The appendSourceInfo can be the publishing parameter returned from analyze the csv or excel file.
upsert
optional boolean. Optional parameter specifying whether the edits needs to be applied as updates if the feature already exists. Default is false.
skip_updates
Optional boolean. Parameter is used only when upsert is true.
use_globalids
Optional boolean. Specifying whether upsert needs to use GlobalId when matching features.
update_geometry
Optional boolean. The parameter is used only when upsert is true. Skip updating the geometry and update only the attributes for existing features if they match source features by objectId or globalId.(as specified by useGlobalIds parameter).
append_fields
Optional list. The list of destination fields to append to. This is supported when upsert=true or false. Values: [“fieldName1”, “fieldName2”,….]
upload_format
required string. The source append data format. The default is featureCollection format. Values: sqlite  shapefile  filegdb  featureCollection  geojson  csv  excel
rollback
Optional boolean. Optional parameter specifying whether the upsert edits needs to be rolled back in case of failure. Default is false.
skip_inserts
Used only when upsert is true. Used to skip inserts if the value is true. The default value is false.
upsert_matching_field
Optional string. The layer field to be used when matching features with upsert. ObjectId, GlobalId, and any other field that has a unique index can be used with upsert. This parameter overrides use_globalids; e.g., specifying upsert_matching_field will be used even if you specify use_globalids = True. Example: upsert_matching_field=”MyfieldWithUniqueIndex”
 Returns
boolean

calculate
(where, calc_expression, sql_format='standard', version=None, sessionid=None, return_edit_moment=None, future=False)¶ The calculate operation is performed on a feature layer resource. It updates the values of one or more fields in an existing feature service layer based on SQL expressions or scalar values. The calculate operation can only be used if the supportsCalculate property of the layer is true. Neither the Shape field nor system fields can be updated using calculate. System fields include ObjectId and GlobalId. See Calculate a field for more information on supported expressions
Inputs
Description
where
Required String. A where clause can be used to limit the updated records. Any legal SQL where clause operating on the fields in the layer is allowed.
calc_expression
Required List. The array of field/value info objects that contain the field or fields to update and their scalar values or SQL expression. Allowed types are dictionary and list. List must be a list of dictionary objects.
Calculation Format is as follows:
{“field” : “<field name>”, “value” : “<value>”}
sql_format
Optional String. The SQL format for the calc_expression. It can be either standard SQL92 (standard) or native SQL (native). The default is standard.
Values: standard, native
version
Optional String. The geodatabase version to apply the edits.
sessionid
Optional String. A parameter which is set by a client during long transaction editing on a branch version. The sessionid is a GUID value that clients establish at the beginning and use throughout the edit session. The sessonid ensures isolation during the edit session. This parameter applies only if the isDataBranchVersioned property of the layer is true.
return_edit_moment
Optional Boolean. This parameter specifies whether the response will report the time edits were applied. If true, the server will return the time edits were applied in the response’s edit moment key. This parameter applies only if the isDataBranchVersioned property of the layer is true.
future
Optional Boolean. If True, the result is returned as a future object and the results are obtained in an asynchronous fashion. False is the default.
This applies to 10.8+ only
# Usage Example 1: print(fl.calculate(where="OBJECTID < 2", calc_expression={"field": "ZONE", "value" : "R1"}))
# Usage Example 2: print(fl.calculate(where="OBJECTID < 2001", calc_expression={"field": "A", "sqlExpression" : "B*3"}))
Output: dictionary with format {‘updatedFeatureCount’: 1, ‘success’: True}

property
container
¶ The feature layer collection to which this layer belongs.

delete_features
(deletes=None, where=None, geometry_filter=None, gdb_version=None, rollback_on_failure=True, return_delete_results=True, future=False)¶ This operation deletes features in a feature layer or table
Argument
Description
deletes
Optional string. A comma seperated string of OIDs to remove from the service.
where
Optional string. A where clause for the query filter. Any legal SQL where clause operating on the fields in the layer is allowed. Features conforming to the specified where clause will be deleted.
geometry_filter
Optional SpatialFilter. A spatial filter from arcgis.geometry.filters module to filter results by a spatial relationship with another geometry.
gdb_version
Optional string. A Geodatabase version to apply the edits.
rollback_on_failure
Optional boolean. Optional parameter to specify if the edits should be applied only if all submitted edits succeed. If false, the server will apply the edits that succeed even if some of the submitted edits fail. If true, the server will apply the edits only if all edits succeed. The default value is true.
return_delete_results
Optional Boolean. Optional parameter that indicates whether a result is returned per deleted row when the deleteFeatures operation is run. The default is true.
future
Optional Boolean. If future=True, then the operation will occur asynchronously else the operation will occur synchronously. False is the default.
 Returns
Dict if future=False (default), else a concurrent.Future class.

edit_features
(adds=None, updates=None, deletes=None, gdb_version=None, use_global_ids=False, rollback_on_failure=True, return_edit_moment=False, attachments=None, true_curve_client=False, session_id=None, use_previous_moment=False, datum_transformation=None)¶ This operation adds, updates, and deletes features to the associated feature layer or table in a single call.
Inputs
Description
adds
Optional FeatureSet/List. The array of features to be added.
updates
Optional FeatureSet/List. The array of features to be updated.
deletes
Optional FeatureSet/List. string of OIDs to remove from service
use_global_ids
Optional boolean. Instead of referencing the default Object ID field, the service will look at a GUID field to track changes. This means the GUIDs will be passed instead of OIDs for delete, update or add features.
gdb_version
Optional boolean. Geodatabase version to apply the edits.
rollback_on_failure
Optional boolean. Optional parameter to specify if the edits should be applied only if all submitted edits succeed. If false, the server will apply the edits that succeed even if some of the submitted edits fail. If true, the server will apply the edits only if all edits succeed. The default value is true.
return_edit_moment
Optional boolean. Introduced at 10.5, only applicable with ArcGIS Server services only. Specifies whether the response will report the time edits were applied. If set to true, the server will return the time in the response’s editMoment key. The default value is false.
attachments
Optional Dict. This parameter adds, updates, or deletes attachments. It applies only when the use_global_ids parameter is set to true. For adds, the globalIds of the attachments provided by the client are preserved. When useGlobalIds is true, updates and deletes are identified by each feature or attachment globalId, rather than their objectId or attachmentId. This parameter requires the layer’s supportsApplyEditsWithGlobalIds property to be true.
Attachments to be added or updated can use either preuploaded data or base 64 encoded data.
Inputs
Inputs
Description
adds
List of attachments to add.
updates
List of attachements to update
deletes
List of attachments to delete
Additional attachment information here.
true_curve_client
Optional boolean. Introduced at 10.5. Indicates to the server whether the client is true curve capable. When set to true, this indicates to the server that true curve geometries should be downloaded and that geometries containing true curves should be consumed by the map service without densifying it. When set to false, this indicates to the server that the client is not true curves capable. The default value is false.
session_id
Optional String. Introduced at 10.6. The session_id is a GUID value that clients establish at the beginning and use throughout the edit session. The sessonID ensures isolation during the edit session. The session_id parameter is set by a client during long transaction editing on a branch version.
use_previous_moment
Optional Boolean. Introduced at 10.6. The use_previous_moment parameter is used to apply the edits with the same edit moment as the previous set of edits. This allows an editor to apply single block of edits partially, complete another task and then complete the block of edits. This parameter is set by a client during long transaction editing on a branch version.
When set to true, the edits are applied with the same edit moment as the previous set of edits. When set to false or not set (default) the edits are applied with a new edit moment.
datum_transformation
Optional Integer/Dictionary. This parameter applies a datum transformation while projecting geometries in the results when out_sr is different than the layer’s spatial reference. When specifying transformations, you need to think about which datum transformation best projects the layer (not the feature service) to the outSR and sourceSpatialReference property in the layer properties. For a list of valid datum transformation ID values ad wellknown text strings, see Coordinate systems and transformations. For more information on datum transformations, please see the transformation parameter in the Project operation.
Examples
Inputs
Description
WKID
Integer. Ex: datum_transformation=4326
WKT
Dict. Ex: datum_transformation={“wkt”: “<WKT>”}
Composite
Dict. Ex: datum_transformation=```{‘geoTransforms’:[{‘wkid’:<id>,’forward’:<truefalse>},{‘wkt’:’<WKT>’,’forward’:<TrueFalse>}]}```
Output: dictionary

export_attachments
(output_folder, label_field=None)¶ Exports attachments from the feature layer in Imagenet format using the output_label_field.
Argument
Description
output_folder
Required. Output folder where the attachments will be stored.
label_field
Optional. Field which contains the label/category of each feature. If None, a default folder is created.

classmethod
fromitem
(item, table_id=0)¶ Creates a Table from a GIS Item. The type of item should be a ‘Feature Service’ that represents a FeatureLayerCollection. The layer_id is the id of the layer in feature layer collection (feature service).

generate_renderer
(definition, where=None)¶ This operation groups data using the supplied definition (classification definition) and an optional where clause. The result is a renderer object. Use baseSymbol and colorRamp to define the symbols assigned to each class. If the operation is performed on a table, the result is a renderer object containing the data classes and no symbols.
Argument
Description
definition
required dict. The definition using the renderer that is generated. Use either class breaks or unique value classification definitions. See: https://resources.arcgis.com/en/help/rest/apiref/ms_classification.html
where
optional string. A where clause for which the data needs to be classified. Any legal SQL where clause operating on the fields in the dynamic layer/table is allowed.
 Returns
dictionary

get_html_popup
(oid)¶ The htmlPopup resource provides details about the HTML popup authored by the user using ArcGIS for Desktop.
Argument
Description
oid
Optional string. Object id of the feature to get the HTML popup.
 Returns
string

get_unique_values
(attribute, query_string='1=1')¶ Return a list of unique values for a given attribute
Argument
Description
attribute
Required string. The feature layer attribute to query.
query_string
Optional string. SQL Query that will be used to filter attributes before unique values are returned. ex. “name_2 like ‘%K%’”

property
manager
¶ Helper object to manage the feature layer, update it’s definition, etc

property
metadata
¶ The metadata property allows for the setting and downloading of the Feature Layer’s metadata. If metadata is disabled on the GIS or the layer does not support metdata, None value will be returned.
Argument
Description
value
Required String. (SET) Path to the metadata file.
 Returns
String (GET)

property
properties
¶ The properties of this object

query
(where='1=1', out_fields='*', time_filter=None, geometry_filter=None, return_geometry=True, return_count_only=False, return_ids_only=False, return_distinct_values=False, return_extent_only=False, group_by_fields_for_statistics=None, statistic_filter=None, result_offset=None, result_record_count=None, object_ids=None, distance=None, units=None, max_allowable_offset=None, out_sr=None, geometry_precision=None, gdb_version=None, order_by_fields=None, out_statistics=None, return_z=False, return_m=False, multipatch_option=None, quantization_parameters=None, return_centroid=False, return_all_records=True, result_type=None, historic_moment=None, sql_format=None, return_true_curves=False, return_exceeded_limit_features=None, as_df=False, datum_transformation=None, **kwargs)¶ Queries a feature layer based on a sql statement
Argument
Description
where
Optional string. The default is 1=1. The selection sql statement.
out_fields
Optional List of field names to return. Field names can be specified either as a List of field names or as a comma separated string. The default is “*”, which returns all the fields.
object_ids
Optional string. The object IDs of this layer or table to be queried. The object ID values should be a commaseparated string.
distance
Optional integer. The buffer distance for the input geometries. The distance unit is specified by units. For example, if the distance is 100, the query geometry is a point, units is set to meters, and all points within 100 meters of the point are returned.
units
Optional string. The unit for calculating the buffer distance. If unit is not specified, the unit is derived from the geometry spatial reference. If the geometry spatial reference is not specified, the unit is derived from the feature service data spatial reference. This parameter only applies if supportsQueryWithDistance is true. Values: esriSRUnit_Meter  esriSRUnit_StatuteMile 
esriSRUnit_Foot  esriSRUnit_Kilometer  esriSRUnit_NauticalMile  esriSRUnit_USNauticalMile
time_filter
Optional list. The format is of [<startTime>, <endTime>] using datetime.date, datetime.datetime or timestamp in milliseconds. Syntax: time_filter=[<startTime>, <endTime>] ; specified as
datetime.date, datetime.datetime or timestamp in milliseconds
geometry_filter
Optional from arcgis.geometry.filter. Allows for the information to be filtered on spatial relationship with another geometry.
max_allowable_offset
Optional float. This option can be used to specify the max_allowable_offset to be used for generalizing geometries returned by the query operation. The max_allowable_offset is in the units of out_sr. If out_sr is not specified, max_allowable_offset is assumed to be in the unit of the spatial reference of the layer.
out_sr
Optional Integer. The WKID for the spatial reference of the returned geometry.
geometry_precision
Optional Integer. This option can be used to specify the number of decimal places in the response geometries returned by the query operation. This applies to X and Y values only (not m or zvalues).
gdb_version
Optional string. The geodatabase version to query. This parameter applies only if the isDataVersioned property of the layer is true. If this is not specified, the query will apply to the published map’s version.
return_geometry
Optional boolean. If true, geometry is returned with the query. Default is true.
return_distinct_values
Optional boolean. If true, it returns distinct values based on the fields specified in out_fields. This parameter applies only if the supportsAdvancedQueries property of the layer is true.
return_ids_only
Optional boolean. Default is False. If true, the response only includes an array of object IDs. Otherwise, the response is a feature set.
return_count_only
Optional boolean. If true, the response only includes the count (number of features/records) that would be returned by a query. Otherwise, the response is a feature set. The default is false. This option supersedes the returnIdsOnly parameter. If returnCountOnly = true, the response will return both the count and the extent.
return_extent_only
Optional boolean. If true, the response only includes the extent of the features that would be returned by the query. If returnCountOnly=true, the response will return both the count and the extent. The default is false. This parameter applies only if the supportsReturningQueryExtent property of the layer is true.
order_by_fields
Optional string. One or more field names on which the features/records need to be ordered. Use ASC or DESC for ascending or descending, respectively, following every field to control the ordering. example: STATE_NAME ASC, RACE DESC, GENDER
group_by_fields_for_statistics
Optional string. One or more field names on which the values need to be grouped for calculating the statistics. example: STATE_NAME, GENDER
out_statistics
Optional string. The definitions for one or more fieldbased statistics to be calculated.
Syntax:
 [
 {
“statisticType”: “<count  sum  min  max  avg  stddev  var>”, “onStatisticField”: “Field1”, “outStatisticFieldName”: “Out_Field_Name1”
}, {
“statisticType”: “<count  sum  min  max  avg  stddev  var>”, “onStatisticField”: “Field2”, “outStatisticFieldName”: “Out_Field_Name2”
}
]
return_z
Optional boolean. If true, Z values are included in the results if the features have Z values. Otherwise, Z values are not returned. The default is False.
return_m
Optional boolean. If true, M values are included in the results if the features have M values. Otherwise, M values are not returned. The default is false.
multipatch_option
Optional x/y footprint. This option dictates how the geometry of a multipatch feature will be returned.
result_offset
Optional integer. This option can be used for fetching query results by skipping the specified number of records and starting from the next record (that is, resultOffset + 1th). This option is ignored if return_all_records is True (i.e. by default).
result_record_count
Optional integer. This option can be used for fetching query results up to the result_record_count specified. When result_offset is specified but this parameter is not, the map service defaults it to max_record_count. The maximum value for this parameter is the value of the layer’s max_record_count property. This option is ignored if return_all_records is True (i.e. by default).
quantization_parameters
Optional dict. Used to project the geometry onto a virtual grid, likely representing pixels on the screen.
return_centroid
Optional boolean. Used to return the geometry centroid associated with each feature returned. If true, the result includes the geometry centroid. The default is false.
return_all_records
Optional boolean. When True, the query operation will call the service until all records that satisfy the where_clause are returned. Note: result_offset and result_record_count will be ignored if return_all_records is True. Also, if return_count_only, return_ids_only, or return_extent_only are True, this parameter will be ignored.
result_type
Optional string. The result_type parameter can be used to control the number of features returned by the query operation. Values: None  standard  tile
historic_moment
Optional integer. The historic moment to query. This parameter applies only if the layer is archiving enabled and the supportsQueryWithHistoricMoment property is set to true. This property is provided in the layer resource.
If historic_moment is not specified, the query will apply to the current features.
sql_format
Optional string. The sql_format parameter can be either standard SQL92 standard or it can use the native SQL of the underlying datastore native. The default is none which means the sql_format depends on useStandardizedQuery parameter. Values: none  standard  native
return_true_curves
Optional boolean. When set to true, returns true curves in output geometries. When set to false, curves are converted to densified polylines or polygons.
return_exceeded_limit_features
Optional boolean. Optional parameter which is true by default. When set to true, features are returned even when the results include ‘exceededTransferLimit’: True.
When set to false and querying with resultType = tile features are not returned when the results include ‘exceededTransferLimit’: True. This allows a client to find the resolution in which the transfer limit is no longer exceeded without making multiple calls.
as_df
Optional boolean. If True, the results are returned as a DataFrame instead of a FeatureSet.
datum_transformation
Optional Integer/Dictionary. This parameter applies a datum transformation while projecting geometries in the results when out_sr is different than the layer’s spatial reference. When specifying transformations, you need to think about which datum transformation best projects the layer (not the feature service) to the outSR and sourceSpatialReference property in the layer properties. For a list of valid datum transformation ID values ad wellknown text strings, see Coordinate systems and transformations. For more information on datum transformations, please see the transformation parameter in the Project operation.
Examples
Inputs
Description
WKID
Integer. Ex: datum_transformation=4326
WKT
Dict. Ex: datum_transformation={“wkt”: “<WKT>”}
Composite
Dict. Ex: datum_transformation=```{‘geoTransforms’:[{‘wkid’:<id>,’forward’:<truefalse>},{‘wkt’:’<WKT>’,’forward’:<TrueFalse>}]}```
kwargs
Optional dict. Optional parameters that can be passed to the Query function. This will allow users to pass additional parameters not explicitly implemented on the function. A complete list of functions available is documented on the Query REST API.
 Returns
A FeatureSet containing the features matching the query unless another return type is specified, such as count
The Query operation is performed on a feature service layer resource. The result of this operation are feature sets grouped by source layer/table object IDs. Each feature set contains Feature objects including the values for the fields requested by the user. For related layers, if you request geometry information, the geometry of each feature is also returned in the feature set. For related tables, the feature set does not include geometries.
Argument
Description
object_ids
Required string. The object IDs of the table/layer to be queried
relationship_id
Required string. The ID of the relationship to be queried.
out_fields
Required string. the list of fields from the related table/layer to be included in the returned feature set. This list is a comma delimited list of field names. If you specify the shape field in the list of return fields, it is ignored. To request geometry, set return_geometry to true. You can also specify the wildcard “*” as the value of this parameter. In this case, the results will include all the field values.
definition_expression
Optional string. The definition expression to be applied to the related table/layer. From the list of objectIds, only those records that conform to this expression are queried for related records.
return_geometry
Optional boolean. If true, the feature set includes the geometry associated with each feature. The default is true.
max_allowable_offset
Optional float. This option can be used to specify the max_allowable_offset to be used for generalizing geometries returned by the query operation. The max_allowable_offset is in the units of the outSR. If out_wkid is not specified, then max_allowable_offset is assumed to be in the unit of the spatial reference of the map.
geometry_precision
Optional integer. This option can be used to specify the number of decimal places in the response geometries.
out_wkid
Optional Integer. The spatial reference of the returned geometry.
gdb_version
Optional string. The geodatabase version to query. This parameter applies only if the isDataVersioned property of the layer queried is true.
return_z
Optional boolean. If true, Z values are included in the results if the features have Z values. Otherwise, Z values are not returned. The default is false.
return_m
Optional boolean. If true, M values are included in the results if the features have M values. Otherwise, M values are not returned. The default is false.
historic_moment
Optional Integer/datetime. The historic moment to query. This parameter applies only if the supportsQueryWithHistoricMoment property of the layers being queried is set to true. This setting is provided in the layer resource.
If historic_moment is not specified, the query will apply to the current features.
Syntax: historic_moment=<Epoch time in milliseconds>
return_true_curves
Optional boolean. Optional parameter that is false by default. When set to true, returns true curves in output geometries; otherwise, curves are converted to densified polylines or polygons.
 Returns
dict

query_top_features
(top_filter=None, where=None, objectids=None, start_time=None, end_time=None, geometry_filter=None, out_fields='*', return_geometry=True, return_centroid=False, max_allowable_offset=None, out_sr=None, geometry_precision=None, return_ids_only=False, return_extents_only=False, order_by_field=None, return_z=False, return_m=False, result_type=None, as_df=True)¶ The query_top_features is performed on a feature layer. This operation returns a feature set or spatially enabled dataframe based on the top features by order within a group. For example, when querying counties in the United States, you want to return the top five counties by population in each state. To do this, you can use query_top_feaures to group by state name, order by desc on the population and return the first five rows from each group (state).
The top_filter parameter is used to set the group by, order by, and count criteria used in generating the result. The operation also has many of the same parameters (for example, where and geometry) as the layer query operation. However, unlike the layer query operation, query_top_feaures does not support parameters such as outStatistics and its related parameters or return distinct values. Consult the advancedQueryCapabilities layer property for more details.
If the feature layer collection supports the query_top_feaures operation, it will include “supportsTopFeaturesQuery”: true, in the advancedQueryCapabilities layer property.
Argument
Description
top_filter
Required Dict. The top_filter define the aggregation of the data.
 groupByFields define the field or fields used to aggregate
your data.
 topCount defines the number of features returned from the top
features query and is a numeric value.
 orderByFields defines the order in which the top features will
be returned. orderByFields can be specified in either ascending (asc) or descending (desc) order, ascending being the default.
 Example: {“groupByFields”: “worker”, “topCount”: 1,
“orderByFields”: “employeeNumber”}
where
Optional String. A WHERE clause for the query filter. SQL ‘92 WHERE clause syntax on the fields in the layer is supported for most data sources.
objectids
Optional List. The object IDs of the layer or table to be queried.
start_time
Optional Datetime. The starting time to query for.
end_time
Optional Datetime. The end date to query for.
geometry_filter
Optional from arcgis.geometry.filter. Allows for the information to be filtered on spatial relationship with another geometry.
out_fields
Optional String. The list of fields to include in the return results.
return_geometry
Optional Boolean. If False, the query will not return geometries. The default is True.
return_centroid
Optional Boolean. If True, the centroid of the geometry will be added to the output.
max_allowable_offset
Optional float. This option can be used to specify the max_allowable_offset to be used for generalizing geometries returned by the query operation. The max_allowable_offset is in the units of out_sr. If out_sr is not specified, max_allowable_offset is assumed to be in the unit of the spatial reference of the layer.
out_sr
Optional Integer. The WKID for the spatial reference of the returned geometry.
geometry_precision
Optional Integer. This option can be used to specify the number of decimal places in the response geometries returned by the query operation. This applies to X and Y values only (not m or zvalues).
return_ids_only
Optional boolean. Default is False. If true, the response only includes an array of object IDs. Otherwise, the response is a feature set.
return_extent_only
Optional boolean. If true, the response only includes the extent of the features that would be returned by the query. If returnCountOnly=true, the response will return both the count and the extent. The default is false. This parameter applies only if the supportsReturningQueryExtent property of the layer is true.
order_by_field
Optional Str. Optional string. One or more field names on which the features/records need to be ordered. Use ASC or DESC for ascending or descending, respectively, following every field to control the ordering. example: STATE_NAME ASC, RACE DESC, GENDER
return_z
Optional boolean. If true, Z values are included in the results if the features have Z values. Otherwise, Z values are not returned. The default is False.
return_m
Optional boolean. If true, M values are included in the results if the features have M values. Otherwise, M values are not returned. The default is false.
result_type
Optional String. The result_type can be used to control the number of features returned by the query operation. Values: none  standard  tile
as_df
Optional Boolean. If False, the result is returned as a FeatureSet. If True (default) the result is returned as a spatially enabled dataframe.
 Returns
Default  pd.DataFrame, when as_df=False returns a FeatureSet. If return_count_only is True, the return type is Integer. If the return_ids_only is True, a list of value is returned.

update_metadata
(file_path)¶ Updates a Layer’s metadata from an xml file.
Argument
Description
file_path
Required String. The path to the .xml file that contains the metadata.
 Returns
boolean

validate_sql
(sql, sql_type='where')¶ The validate_sql operation validates an SQL92 expression or WHERE clause. The validate_sql operation ensures that an SQL92 expression, such as one written by a user through a user interface, is correct before performing another operation that uses the expression. For example, validateSQL can be used to validate information that is subsequently passed in as part of the where parameter of the calculate operation. validate_sql also prevents SQL injection. In addition, all table and field names used in the SQL expression or WHERE clause are validated to ensure they are valid tables and fields.
Argument
Description
sql
Required String. The SQL expression of WHERE clause to validate. Example: “Population > 300000”
sql_type
 Optional String. Three SQL types are supported in validate_sql
where (default)  Represents the custom WHERE clause the user can compose when querying a layer or using calculate.
expression  Represents an SQL92 expression. Currently, expression is used as a default value expression when adding a new field or using the calculate API.
statement  Represents the full SQL92 statement that can be passed directly to the database. No current ArcGIS REST API resource or operation supports using the full SQL92 SELECT statement directly. It has been added to the validateSQL for completeness. Values: where  expression  statement
 Returns
dict

arcgis.features.FeatureLayerCollection¶

class
arcgis.features.
FeatureLayerCollection
(url, gis=None)¶ A FeatureLayerCollection is a collection of feature layers and tables, with the associated relationships among the entities.
In a web GIS, a feature layer collection is exposed as a feature service with multiple feature layers.
Instances of FeatureDatasets can be obtained from feature service Items in the GIS using FeatureLayerCollection.fromitem(item), from feature service endpoints using the constructor, or by accessing the dataset attribute of feature layer objects.
FeatureDatasets can be configured and managed using their manager helper object.
If the dataset supports the sync operation, the replicas helper object allows management and synchronization of replicas for disconnected editing of the feature layer collection.
Note: You can use the layers and tables property to get to the individual layers and tables in this feature layer collection.

extract_changes
(layers, servergen, queries=None, geometry=None, geometry_type=None, in_sr=None, version=None, return_inserts=False, return_updates=False, return_deletes=False, return_ids_only=False, return_extent_only=False, return_attachments=False, attachments_by_url=False, data_format='json', change_extent_grid_cell=None)¶ Feature service change tracking is an efficient change tracking mechanism for applications. Applications can use change tracking to query changes that have been made to the layers and tables in the service. For enterprise geodatabase based feature services published from ArcGIS Pro 2.2 or higher, the ChangeTracking capability requires all layers and tables to be either archive enabled or branch versioned and have globalid columns. Change tracking can also be enabled for ArcGIS Online hosted feature services. If all layers and tables in the service have the ChangeTracking capability, the extract_changes operation can be used to get changes.

classmethod
fromitem
(item)¶

property
manager
¶ helper object to manage the feature layer collection, update it’s definition, etc

property
properties
¶ The properties of this object

query
(layer_defs_filter=None, geometry_filter=None, time_filter=None, return_geometry=True, return_ids_only=False, return_count_only=False, return_z=False, return_m=False, out_sr=None)¶ queries the feature layer collection

query_domains
(layers)¶ The query_domains returns full domain information for the domains referenced by the layers in the feature layer collection. This operation is performed on a feature layer collection. The operation takes an array of layer IDs and returns the set of domains referenced by the layers.
Argument
Description
layers
Required List. An array of layers. The set of domains to return is based on the domains referenced by these layers. Example: [1,2,3,4]
 Returns
list of dictionaries
The Query operation is performed on a feature service layer resource. The result of this operation are feature sets grouped by source layer/table object IDs. Each feature set contains Feature objects including the values for the fields requested by the user. For related layers, if you request geometry information, the geometry of each feature is also returned in the feature set. For related tables, the feature set does not include geometries.
Argument
Description
object_ids
Optional string. the object IDs of the table/layer to be queried.
relationship_id
Optional string. The ID of the relationship to be queried.
out_fields
Optional string.the list of fields from the related table/layer to be included in the returned feature set. This list is a comma delimited list of field names. If you specify the shape field in the list of return fields, it is ignored. To request geometry, set return_geometry to true. You can also specify the wildcard “*” as the value of this parameter. In this case, the results will include all the field values.
definition_expression
Optional string. The definition expression to be applied to the related table/layer. From the list of objectIds, only those records that conform to this expression are queried for related records.
return_geometry
Optional boolean. If true, the feature set includes the geometry associated with each feature. The default is true.
max_allowable_offset
Optional float. This option can be used to specify the max_allowable_offset to be used for generalizing geometries returned by the query operation. The max_allowable_offset is in the units of the outSR. If outSR is not specified, then max_allowable_offset is assumed to be in the unit of the spatial reference of the map.
geometry_precision
Optional integer. This option can be used to specify the number of decimal places in the response geometries.
out_wkid
Optional integer. The spatial reference of the returned geometry.
gdb_version
Optional string. The geodatabase version to query. This parameter applies only if the isDataVersioned property of the layer queried is true.
return_z
Optional boolean. If true, Z values are included in the results if the features have Z values. Otherwise, Z values are not returned. The default is false.
return_m
Optional boolean. If true, M values are included in the results if the features have M values. Otherwise, M values are not returned. The default is false.
 Returns
dict

property
relationships
¶ The relationships property provides relationship information for the layers and tables in the feature layer collection.
The relationships resource includes information about relationship rules from the backend relationship classes, in addition to the relationship information already found in the individual layers and tables.
Feature layer collections that support the relationships resource will have the “supportsRelationshipsResource”: true property on their properties.
 Returns
List of Dictionaries

upload
(path, description=None)¶ Uploads a new item to the server. Once the operation is completed successfully, the JSON structure of the uploaded item is returned.
Argument
Description
path
Optional string. Filepath of the file to upload.
description
Optional string. Descriptive text for the uploaded item.
 Returns
boolean

property
versions
¶ Returns a VersionManager to create, update and use versions on a FeatureLayerCollection. If versioning is not enabled on the service, None is returned.

arcgis.features.FeatureSet¶

class
arcgis.features.
FeatureSet
(features, fields=None, has_z=False, has_m=False, geometry_type=None, spatial_reference=None, display_field_name=None, object_id_field_name=None, global_id_field_name=None)¶ A set of features with information about their fields, field aliases, geometry type, spatial reference etc.
FeatureSets are commonly used as input/output with several Geoprocessing Tools, and can be the obtained through the query() methods of feature layers. A FeatureSet can be combined with a layer definition to compose a FeatureCollection.
FeatureSet contains Feature objects, including the values for the fields requested by the user. For layers, if you request geometry information, the geometry of each feature is also returned in the FeatureSet. For tables, the FeatureSet does not include geometries.
If a Spatial Reference is not specified at the FeatureSet level, the FeatureSet will assume the SpatialReference of its first feature. If the SpatialReference of the first feature is also not specified, the spatial reference will be UnknownCoordinateSystem.

property
df
¶ deprecated in v1.5.0 please use `sdf`
converts the FeatureSet to a Pandas dataframe. Requires pandas

property
display_field_name
¶ gets/sets the displayFieldName

property
features
¶ gets the features in the FeatureSet

property
fields
¶ gets the fields in the FeatureSet

static
from_dataframe
(df)¶ returns a featureset from a Pandas’ Data or Spatial DataFrame

static
from_dict
(featureset_dict)¶ returns a featureset from a dict

static
from_geojson
(geojson)¶ Converts a GeoJSON Feature Collection into a FeatureSet

static
from_json
(json_str)¶ returns a featureset from a JSON string

property
geometry_type
¶ gets/sets the geometry Type

property
global_id_field_name
¶ gets/sets the globalIdFieldName

property
has_m
¶ gets/set the Mproperty

property
has_z
¶ gets/sets the Zproperty

property
object_id_field_name
¶ gets/sets the object id field

save
(save_location, out_name, encoding=None)¶ Saves a featureset object to a feature class
Argument
Description
save_location
Required string. Path to export the FeatureSet to.
out_name
Required string. Name of the saved table.
encoding
Optional string. character encoding is used to represent a repertoire of characters by some kind of encoding system. The default is None.
 Returns
string

property
sdf
¶ Converts the FeatureSet to a Spatially Enabled Pandas dataframe

property
spatial_reference
¶ gets the featureset’s spatial reference

to_dict
()¶ converts the object to Python dictionary

property
to_geojson
¶ converts the object to GeoJSON

property
to_json
¶ converts the object to JSON

property
value
¶ returns object as dictionary

property
arcgis.features.FeatureCollection¶

class
arcgis.features.
FeatureCollection
(dictdata)¶ FeatureCollection is an object with a layer definition and a feature set.
It is an inmemory collection of features with rendering information.
Feature Collections can be stored as Items in the GIS, added as layers to a map or scene, passed as inputs to feature analysis tools, and returned as results from feature analysis tools if an output name for a feature layer is not specified when calling the tool.

static
from_featureset
(fset, symbol=None, name=None)¶ Create a FeatureCollection object from a FeatureSet object.
 Returns
A FeatureCollection object.

query
()¶ Returns the data in this feature collection as a FeatureSet. Filtering by where clause is not supported for feature collections

static
arcgis.features.GeoAccessor¶

class
arcgis.features.
GeoAccessor
(obj)¶ The DataFrame Accessor is a namespace that performs dataset operations. This includes visualization, spatial indexing, IO and dataset level properties.

property
area
¶ Returns the total area of the dataframe
 Returns
float
>>> df.spatial.area 143.23427

property
bbox
¶ Returns the total length of the dataframe
 Returns
Polygon
>>> df.spatial.bbox {'rings' : [[[1,2], [2,3], [3,3],....]], 'spatialReference' {'wkid': 4326}}

property
centroid
¶ Returns the centroid of the dataframe
 Returns
Geometry
>>> df.spatial.centroid (14.23427, 39)

distance_matrix
(leaf_size=16, rebuild=False)¶ Creates a kd tree to calculate the nearestneighbor problem.
requires scipy
Argument
Description
leafsize
Optional Integer. The number of points at which the algorithm switches over to bruteforce. Default: 16.
rebuild
Optional Boolean. If True, the current KDTree is erased. If false, any KDTree that exists will be returned.
 Returns
scipy’s KDTree class

static
from_df
(df, address_column='address', geocoder=None, sr=None)¶ Returns a SpatialDataFrame from a dataframe with an address column.
Argument
Description
df
Required Pandas DataFrame. Source dataset
address_column
Optional String. The default is “address”. This is the name of a column in the specified dataframe that contains addresses (as strings). The addresses are batch geocoded using the GIS’s first configured geocoder and their locations used as the geometry of the spatial dataframe. Ignored if the ‘geometry’ parameter is also specified.
geocoder
Optional Geocoder. The geocoder to be used. If not specified, the active GIS’s first geocoder is used.
sr
Optional integer. The WKID of the spatial reference.
 Returns
DataFrame
NOTE: Credits will be consumed for batch_geocoding, from the GIS to which the geocoder belongs.

static
from_featureclass
(location, **kwargs)¶ Returns a Spatially enabled pandas.DataFrame from a feature class.
Argument
Description
location
Required string or pathlib.Path. Full path to the feature class
Optional parameters when ArcPy library is available in the current environment:
Optional Argument
Description
sql_clause
sql clause to parse data down. To learn more see ArcPy Search Cursor
where_clause
where statement. To learn more see ArcPy SQL reference
fields
list of strings specifying the field names.
spatial_filter
A Geometry object that will filter the results. This requires arcpy to work.
 Returns
pandas.core.frame.DataFrame

static
from_geodataframe
(geo_df, inplace=False, column_name='SHAPE')¶ Import Geopandas GeoDataFrame into an ArcGIS Spatially enabled DataFrame. Requires geopandas library be installed in current environment.
Argument
Description
geo_df
GeoDataFrame object, created using GeoPandas library
inplace
 Optional Bool. When True, the existing GeoDataFrame is spatially
enabled and returned. When False, a new Spatially Enabled DataFrame object is returned. Default is False.
column_name
 Optional String. Sets the name of the geometry column. Default
is SHAPE.
 Returns
ArcGIS Spatially Enabled DataFrame object.

static
from_layer
(layer)¶ Imports a FeatureLayer to a Spatially Enabled DataFrame
This operation converts a FeatureLayer or TableLayer to a Pandas’ DataFrame
Argument
Description
layer
Required FeatureLayer or TableLayer. The service to convert to a Spatially enabled DataFrame.
Usage:
>>> from arcgis.features import FeatureLayer >>> mylayer = FeatureLayer(("https://sampleserver6.arcgisonline.com/arcgis/rest" "/services/CommercialDamageAssessment/FeatureServer/0")) >>> df = from_layer(mylayer) >>> print(df.head())
 Returns
Pandas’ DataFrame

static
from_table
(filename, **kwargs)¶ Allows a user to read from a nonspatial table
Note: ArcPy is Required for this method
Argument
Description
filename
Required string or pathlib.Path. The path to the table.
Keyword Arguments
Argument
Description
fields
Optional List/Tuple. A list (or tuple) of field names. For a single field, you can use a string instead of a list of strings.
Use an asterisk (*) instead of a list of fields if you want to access all fields from the input table (raster and BLOB fields are excluded). However, for faster performance and reliable field order, it is recommended that the list of fields be narrowed to only those that are actually needed.
Geometry, raster, and BLOB fields are not supported.
where
Optional String. An optional expression that limits the records returned.
skip_nulls
Optional Boolean. This controls whether records using nulls are skipped.
null_value
Optional String/Integer/Float. Replaces null values from the input with a new value.
 Returns
pd.DataFrame

static
from_xy
(df, x_column, y_column, sr=4326)¶ Converts a Pandas DataFrame into a Spatial DataFrame by providing the X/Y columns.
Argument
Description
df
Required Pandas DataFrame. Source dataset
x_column
Required string. The name of the Xcoordinate series
y_column
Required string. The name of the Ycoordinate series
sr
Optional int. The wkid number of the spatial reference. 4326 is the default value.
 Returns
DataFrame

property
full_extent
¶ Returns the extent of the dataframe
 Returns
tuple
>>> df.spatial.full_extent (118, 32, 97, 33)

property
geometry_type
¶ Returns a list Geometry Types for the DataFrame

join
(right_df, how='inner', op='intersects', left_tag='left', right_tag='right')¶ Joins the current DataFrame to another spatially enabled dataframes based on spatial location based.
Note
requires the SEDF to be in the same coordinate system
Argument
Description
right_df
Required pd.DataFrame. Spatially enabled dataframe to join.
how
Required string. The type of join:
left  use keys from current dataframe and retains only current geometry column
right  use keys from right_df; retain only right_df geometry column
inner  use intersection of keys from both dfs and retain only current geometry column
op
Required string. The operation to use to perform the join. The default is intersects.
supported perations: intersects, within, and contains
left_tag
Optional String. If the same column is in the left and right dataframe, this will append that string value to the field.
right_tag
Optional String. If the same column is in the left and right dataframe, this will append that string value to the field.
 Returns
Spatially enabled Pandas’ DataFrame

property
length
¶ Returns the total length of the dataframe
 Returns
float
>>> df.spatial.length 1.23427

property
name
¶ returns the name of the geometry column

overlay
(sdf, op='union')¶ Performs spatial operation operations on two spatially enabled dataframes.
requires ArcPy or Shapely
Argument
Description
sdf
Required Spatially Enabled DataFrame. The geometry to perform the operation from.
op
Optional String. The spatial operation to perform. The allowed value are: union, erase, identity, intersection. union is the default operation.
 Returns
Spatially enabled DataFrame (pd.DataFrame)

plot
(map_widget=None, **kwargs)¶ Plot draws the data on a web map. The user can describe in simple terms how to renderer spatial data using symbol. To make the process simplier a pallette for which colors are drawn from can be used instead of explicit colors.
Explicit Argument
Description
map_widget
optional WebMap object. This is the map to display the data on.
palette
optional string/dict. Color mapping. For simple renderer, just provide a string. For more robust renderers like unique renderer, a dictionary can be given.
renderer_type
optional string. Determines the type of renderer to use for the provided dataset. The default is ‘s’ which is for simple renderers.
Allowed values:
‘s’  is a simple renderer that uses one symbol only.
 ‘u’  unique renderer symbolizes features based on one
or more matching string attributes.
 ‘c’  A class breaks renderer symbolizes based on the
value of some numeric attribute.
 ‘h’  heatmap renders point data into a raster
visualization that emphasizes areas of higher density or weighted values.
symbol_type
optional string. This is the type of symbol the user needs to create. Valid inputs are: simple, picture, text, or carto. The default is simple.
symbol_type
optional string. This is the symbology used by the geometry. For example ‘s’ for a Line geometry is a solid line. And ‘‘ is a dash line.
Allowed symbol types based on geometries:
Point Symbols
‘o’  Circle (default)
‘+’  Cross
‘D’  Diamond
‘s’  Square
‘x’  X
Polyline Symbols
‘s’  Solid (default)
‘‘  Dash
‘.’  Dash Dot
‘..’  Dash Dot Dot
‘.’  Dot
‘–’  Long Dash
‘–.’  Long Dash Dot
‘n’  Null
‘s‘  Short Dash
‘s.’  Short Dash Dot
‘s..’  Short Dash Dot Dot
‘s.’  Short Dot
Polygon Symbols
‘s’  Solid Fill (default)
‘’  Backward Diagonal
‘/’  Forward Diagonal
‘’  Vertical Bar
‘‘  Horizontal Bar
‘x’  Diagonal Cross
‘+’  Cross
col
optional string/list. Field or fields used for heatmap, class breaks, or unique renderers.
pallette
optional string. The color map to draw from in order to visualize the data. The default pallette is ‘jet’. To get a visual representation of the allowed color maps, use the display_colormaps method.
alpha
optional float. This is a value between 0 and 1 with 1 being the default value. The alpha sets the transparancy of the renderer when applicable.
** Render Syntax **
The render syntax allows for users to fully customize symbolizing the data.
** Simple Renderer**
A simple renderer is a renderer that uses one symbol only.
Optional Argument
Description
symbol_type
optional string. This is the type of symbol the user needs to create. Valid inputs are: simple, picture, text, or carto. The default is simple.
symbol_type
optional string. This is the symbology used by the geometry. For example ‘s’ for a Line geometry is a solid line. And ‘‘ is a dash line.
Point Symbols
‘o’  Circle (default)
‘+’  Cross
‘D’  Diamond
‘s’  Square
‘x’  X
Polyline Symbols
‘s’  Solid (default)
‘‘  Dash
‘.’  Dash Dot
‘..’  Dash Dot Dot
‘.’  Dot
‘–’  Long Dash
‘–.’  Long Dash Dot
‘n’  Null
‘s‘  Short Dash
‘s.’  Short Dash Dot
‘s..’  Short Dash Dot Dot
‘s.’  Short Dot
Polygon Symbols
‘s’  Solid Fill (default)
‘’  Backward Diagonal
‘/’  Forward Diagonal
‘’  Vertical Bar
‘‘  Horizontal Bar
‘x’  Diagonal Cross
‘+’  Cross
description
Description of the renderer.
rotation_expression
A constant value or an expression that derives the angle of rotation based on a feature attribute value. When an attribute name is specified, it’s enclosed in square brackets.
rotation_type
String value which controls the origin and direction of rotation on point features. If the rotationType is defined as arithmetic, the symbol is rotated from East in a counterclockwise direction where East is the 0 degree axis. If the rotationType is defined as geographic, the symbol is rotated from North in a clockwise direction where North is the 0 degree axis.
Must be one of the following values:
arithmetic
geographic
visual_variables
An array of objects used to set rendering properties.
Heatmap Renderer
The HeatmapRenderer renders point data into a raster visualization that emphasizes areas of higher density or weighted values.
Optional Argument
Description
blur_radius
The radius (in pixels) of the circle over which the majority of each point’s value is spread.
field
This is optional as this renderer can be created if no field is specified. Each feature gets the same value/importance/weight or with a field where each feature is weighted by the field’s value.
max_intensity
The pixel intensity value which is assigned the final color in the color ramp.
min_intensity
The pixel intensity value which is assigned the initial color in the color ramp.
ratio
A number between 01. Describes what portion along the gradient the colorStop is added.
Unique Renderer
This renderer symbolizes features based on one or more matching string attributes.
Optional Argument
Description
background_fill_symbol
A symbol used for polygon features as a background if the renderer uses point symbols, e.g. for bivariate types & size rendering. Only applicable to polygon layers. PictureFillSymbols can also be used outside of the Map Viewer for Size and Predominance and Size renderers.
default_label
Default label for the default symbol used to draw unspecified values.
default_symbol
Symbol used when a value cannot be matched.
field1, field2, field3
Attribute field renderer uses to match values.
field_delimiter
String inserted between the values if multiple attribute fields are specified.
rotation_expression
A constant value or an expression that derives the angle of rotation based on a feature attribute value. When an attribute name is specified, it’s enclosed in square brackets. Rotation is set using a visual variable of type rotation info with a specified field or value expression property.
rotation_type
String property which controls the origin and direction of rotation. If the rotation type is defined as arithmetic the symbol is rotated from East in a counterclockwise direction where East is the 0 degree axis. If the rotation type is defined as geographic, the symbol is rotated from North in a clockwise direction where North is the 0 degree axis. Must be one of the following values:
arithmetic
geographic
arcade_expression
An Arcade expression evaluating to either a string or a number.
arcade_title
The title identifying and describing the associated Arcade expression as defined in the valueExpression property.
visual_variables
An array of objects used to set rendering properties.
Class Breaks Renderer
A class breaks renderer symbolizes based on the value of some numeric attribute.
Optional Argument
Description
background_fill_symbol
A symbol used for polygon features as a background if the renderer uses point symbols, e.g. for bivariate types & size rendering. Only applicable to polygon layers. PictureFillSymbols can also be used outside of the Map Viewer for Size and Predominance and Size renderers.
default_label
Default label for the default symbol used to draw unspecified values.
default_symbol
Symbol used when a value cannot be matched.
method
Determines the classification method that was used to generate class breaks.
Must be one of the following values:
esriClassifyDefinedInterval
esriClassifyEqualInterval
esriClassifyGeometricalInterval
esriClassifyNaturalBreaks
esriClassifyQuantile
esriClassifyStandardDeviation
esriClassifyManual
field
Attribute field used for renderer.
min_value
The minimum numeric data value needed to begin class breaks.
normalization_field
Used when normalizationType is field. The string value indicating the attribute field by which the data value is normalized.
normalization_total
Used when normalizationType is percentoftotal, this number property contains the total of all data values.
normalization_type
Determine how the data was normalized.
Must be one of the following values:
esriNormalizeByField
esriNormalizeByLog
esriNormalizeByPercentOfTotal
rotation_expression
A constant value or an expression that derives the angle of rotation based on a feature attribute value. When an attribute name is specified, it’s enclosed in square brackets.
rotation_type
A string property which controls the origin and direction of rotation. If the rotation_type is defined as arithmetic, the symbol is rotated from East in a couterclockwise direction where East is the 0 degree axis. If the rotationType is defined as geographic, the symbol is rotated from North in a clockwise direction where North is the 0 degree axis.
Must be one of the following values:
arithmetic
geographic
arcade_expression
An Arcade expression evaluating to a number.
arcade_title
The title identifying and describing the associated Arcade expression as defined in the arcade_expression property.
visual_variables
An object used to set rendering options.
** Symbol Syntax **
Optional Argument
Description
symbol_type
optional string. This is the type of symbol the user needs to create. Valid inputs are: simple, picture, text, or carto. The default is simple.
symbol_type
optional string. This is the symbology used by the geometry. For example ‘s’ for a Line geometry is a solid line. And ‘‘ is a dash line.
Point Symbols
‘o’  Circle (default)
‘+’  Cross
‘D’  Diamond
‘s’  Square
‘x’  X
Polyline Symbols
‘s’  Solid (default)
‘‘  Dash
‘.’  Dash Dot
‘..’  Dash Dot Dot
‘.’  Dot
‘–’  Long Dash
‘–.’  Long Dash Dot
‘n’  Null
‘s‘  Short Dash
‘s.’  Short Dash Dot
‘s..’  Short Dash Dot Dot
‘s.’  Short Dot
Polygon Symbols
‘s’  Solid Fill (default)
‘’  Backward Diagonal
‘/’  Forward Diagonal
‘’  Vertical Bar
‘‘  Horizontal Bar
‘x’  Diagonal Cross
‘+’  Cross
cmap
optional string or list. This is the color scheme a user can provide if the exact color is not needed, or a user can provide a list with the color defined as: [red, green blue, alpha]. The values red, green, blue are from 0255 and alpha is a float value from 0  1. The default value is ‘jet’ color scheme.
cstep
optional integer. If provided, its the color location on the color scheme.
Simple Symbols
This is a list of optional parameters that can be given for point, line or polygon geometries.
Argument
Description
marker_size
optional float. Numeric size of the symbol given in points.
marker_angle
optional float. Numeric value used to rotate the symbol. The symbol is rotated counterclockwise. For example, The following, angle=30, in will create a symbol rotated 30 degrees counterclockwise; that is, 30 degrees clockwise.
marker_xoffset
Numeric value indicating the offset on the xaxis in points.
marker_yoffset
Numeric value indicating the offset on the yaxis in points.
line_width
optional float. Numeric value indicating the width of the line in points
outline_style
Optional string. For polygon point, and line geometries , a customized outline type can be provided.
Allowed Styles:
‘s’  Solid (default)
‘‘  Dash
‘.’  Dash Dot
‘..’  Dash Dot Dot
‘.’  Dot
‘–’  Long Dash
‘–.’  Long Dash Dot
‘n’  Null
‘s‘  Short Dash
‘s.’  Short Dash Dot
‘s..’  Short Dash Dot Dot
‘s.’  Short Dot
outline_color
optional string or list. This is the same color as the cmap property, but specifically applies to the outline_color.
Picture Symbol
This type of symbol only applies to Points, MultiPoints and Polygons.
Argument
Description
marker_angle
Numeric value that defines the number of degrees ranging from 0360, that a marker symbol is rotated. The rotation is from East in a counterclockwise direction where East is the 0 axis.
marker_xoffset
Numeric value indicating the offset on the xaxis in points.
marker_yoffset
Numeric value indicating the offset on the yaxis in points.
height
Numeric value used if needing to resize the symbol. Specify a value in points. If images are to be displayed in their original size, leave this blank.
width
Numeric value used if needing to resize the symbol. Specify a value in points. If images are to be displayed in their original size, leave this blank.
url
String value indicating the URL of the image. The URL should be relative if working with static layers. A full URL should be used for map service dynamic layers. A relative URL can be dereferenced by accessing the map layer image resource or the feature layer image resource.
image_data
String value indicating the base64 encoded data.
xscale
Numeric value indicating the scale factor in x direction.
yscale
Numeric value indicating the scale factor in y direction.
outline_color
optional string or list. This is the same color as the cmap property, but specifically applies to the outline_color.
outline_style
Optional string. For polygon point, and line geometries , a customized outline type can be provided.
Allowed Styles:
‘s’  Solid (default)
‘‘  Dash
‘.’  Dash Dot
‘..’  Dash Dot Dot
‘.’  Dot
‘–’  Long Dash
‘–.’  Long Dash Dot
‘n’  Null
‘s‘  Short Dash
‘s.’  Short Dash Dot
‘s..’  Short Dash Dot Dot
‘s.’  Short Dot
outline_color
optional string or list. This is the same color as the cmap property, but specifically applies to the outline_color.
line_width
optional float. Numeric value indicating the width of the line in points
Text Symbol
This type of symbol only applies to Points, MultiPoints and Polygons.
Argument
Description
font_decoration
The text decoration. Must be one of the following values:  linethrough  underline  none
font_family
Optional string. The font family.
font_size
Optional float. The font size in points.
font_style
Optional string. The text style.  italic  normal  oblique
font_weight
Optional string. The text weight. Must be one of the following values:  bold  bolder  lighter  normal
background_color
optional string/list. Background color is represented as a fourelement array or string of a color map.
halo_color
Optional string/list. Color of the halo around the text. The default is None.
halo_size
Optional integer/float. The point size of a halo around the text symbol.
horizontal_alignment
optional string. One of the following string values representing the horizontal alignment of the text. Must be one of the following values:  left  right  center  justify
kerning
optional boolean. Boolean value indicating whether to adjust the spacing between characters in the text string.
line_color
optional string/list. Outline color is represented as a fourelement array or string of a color map.
line_width
optional integer/float. Outline size.
marker_angle
optional int. A numeric value that defines the number of degrees (0 to 360) that a text symbol is rotated. The rotation is from East in a counterclockwise direction where East is the 0 axis.
marker_xoffset
optional int/float.Numeric value indicating the offset on the xaxis in points.
marker_yoffset
optional int/float.Numeric value indicating the offset on the xaxis in points.
right_to_left
optional boolean. Set to true if using Hebrew or Arabic fonts.
rotated
optional boolean. Boolean value indicating whether every character in the text string is rotated.
text
Required string. Text Value to display next to geometry.
vertical_alignment
Optional string. One of the following string values representing the vertical alignment of the text. Must be one of the following values:  top  bottom  middle  baseline
Cartographic Symbol
This type of symbol only applies to line geometries.
Argument
Description
line_width
optional float. Numeric value indicating the width of the line in points
cap
Optional string. The cap style.
join
Optional string. The join style.
miter_limit
Optional string. Size threshold for showing mitered line joins.
The kwargs parameter accepts all parameters of the create_symbol method and the create_renderer method.

project
(spatial_reference, transformation_name=None)¶ Reprojects the who dataset into a new spatial reference. This is an inplace operation meaning that it will update the defined geometry column from the set_geometry.
Argument
Description
spatial_reference
Required SpatialReference. The new spatial reference. This can be a SpatialReference object or the coordinate system name.
transformation_name
Optional String. The geotransformation name.
 Returns
boolean

relationship
(other, op, relation=None)¶ This method allows for dataframe to dataframe compairson using spatial relationships. The return is a pd.DataFrame that meet the operations’ requirements.
Argument
Description
sdf
Required Spatially Enabled DataFrame. The geometry to perform the operation from.
op
Optional String. The spatial operation to perform. The allowed value are: contains,crosses,disjoint,equals, overlaps,touches, or within.
contains  Indicates if the base geometry contains the comparison geometry.
crosses  Indicates if the two geometries intersect in a geometry of a lesser shape type.
disjoint  Indicates if the base and comparison geometries share no points in common.
equals  Indicates if the base and comparison geometries are of the same shape type and define the same set of points in the plane. This is a 2D comparison only; M and Z values are ignored.
overlaps  Indicates if the intersection of the two geometries has the same shape type as one of the input geometries and is not equivalent to either of the input geometries.
touches  Indicates if the boundaries of the geometries intersect.
within  Indicates if the base geometry is within the comparison geometry.
relation
Optional String. The spatial relationship type. The allowed values are: BOUNDARY, CLEMENTINI, and PROPER.
BOUNDARY  Relationship has no restrictions for interiors or boundaries.
CLEMENTINI  Interiors of geometries must intersect. This is the default.
PROPER  Boundaries of geometries must not intersect.
This only applies to contains,
 Returns
Spatially enabled DataFrame (pd.DataFrame)

select
(other)¶ This operation performs a dataset wide selection by geometric intersection. A geometry or another Spatially enabled DataFrame can be given and select will return all rows that intersect that input geometry. The select operation uses a spatial index to complete the task, so if it is not built before the first run, the function will build a quadtree index on the fly.
requires ArcPy or Shapely
 Returns
pd.DataFrame (spatially enabled)

set_geometry
(col, sr=None)¶ Assigns the Geometry Column by Name or by List

sindex
(stype='quadtree', reset=False, **kwargs)¶ Creates a spatial index for the given dataset.
By default the spatial index is a QuadTree spatial index.
If rtree indexes should be used for large datasets. This will allow users to create very large out of memory indexes. To use rtree indexes, the rtree library must be installed. To do so, install via conda using the following command: conda install c condaforge rtree

property
sr
¶ gets/sets the spatial reference of the dataframe

to_feature_collection
(name=None, drawing_info=None, extent=None, global_id_field=None)¶ Converts a spatially enabled pd.DataFrame to a Feature Collection
optional argument
Description
name
optional string. Name of the Feature Collection
drawing_info
Optional dictionary. This is the rendering information for a Feature Collection. Rendering information is a dictionary with the symbology, labelling and other properties defined. See: http://resources.arcgis.com/en/help/arcgisrestapi/index.html#/Renderer_objects/02r30000019t000000/
extent
Optional dictionary. If desired, a custom extent can be provided to set where the map starts up when showing the data. The default is the full extent of the dataset in the Spatial DataFrame.
global_id_field
Optional string. The Global ID field of the dataset.
 Returns
FeatureCollection object

to_featureclass
(location, overwrite=True)¶ exports a geo enabled dataframe to a feature class.

to_featurelayer
(title, gis=None, tags=None, folder=None)¶ publishes a spatial dataframe to a new feature layer
Argument
Description
title
Required string. The name of the service
gis
Optional GIS. The GIS connection object
tags
Optional list of strings. A comma seperated list of descriptive words for the service.
folder
Optional string. Name of the folder where the featurelayer item and imported data would be stored.
 Returns
FeatureLayer

to_featureset
()¶ Converts a spatial dataframe to a feature set object

to_table
(location, overwrite=True)¶ Exports a geo enabled dataframe to a table.
Argument
Description
location
Required string. The output of the table.
overwrite
Optional Boolean. If True and if the table exists, it will be deleted and overwritten. This is default. If False, the table and the table exists, and exception will be raised.
 Returns
String

property
true_centroid
¶ Returns the true centroid of the dataframe
 Returns
Geometry
>>> df.spatial.true_centroid (1.23427, 34)

validate
(strict=False)¶ Determines if the Geo Accessor is Valid with Geometries in all values

voronoi
()¶ Generates a voronoi diagram on the whole dataset. If the geometry is not a Point then the centroid is used for the geometry. The result is a polygon GeoArray Series that matches 1:1 to the original dataset.
requires scipy
 Returns
pd.Series

property
arcgis.features.GeoSeriesAccessor¶

class
arcgis.features.
GeoSeriesAccessor
(obj)¶ 
property
JSON
¶ Returns JSON string of Geometry
 Returns
Series of strings

property
WKB
¶ Returns the Geometry as WKB
 Returns
Series of Bytes

property
WKT
¶ Returns the Geometry as WKT
 Returns
Series of String

angle_distance_to
(second_geometry, method='GEODESIC')¶ Returns a tuple of angle and distance to another point using a measurement type.
Argument
Description
second_geometry
Required Geometry. A arcgis.Geometry object.
method
Optional String. PLANAR measurements reflect the projection of geographic data onto the 2D surface (in other words, they will not take into account the curvature of the earth). GEODESIC, GREAT_ELLIPTIC, LOXODROME, and PRESERVE_SHAPE measurement types may be chosen as an alternative, if desired.
 Returns
a tuple of angle and distance to another point using a measurement type.

property
area
¶ Returns the features area
 Returns
float in a series

property
as_arcpy
¶ Returns the features as ArcPy Geometry
 Returns
arcpy.Geometry in a series

property
as_shapely
¶ Returns the features as Shapely Geometry
 Returns
shapely.Geometry in a series

boundary
()¶ Constructs the boundary of the geometry.
 Returns
arcgis.geometry.Polyline

buffer
(distance)¶ Constructs a polygon at a specified distance from the geometry.
Argument
Description
distance
Required float. The buffer distance. The buffer distance is in the same units as the geometry that is being buffered. A negative distance can only be specified against a polygon geometry.
 Returns
arcgis.geometry.Polygon

property
centroid
¶ Returns the feature’s centroid
 Returns
tuple (x,y) in series

clip
(envelope)¶ Constructs the intersection of the geometry and the specified extent.
Argument
Description
envelope
required tuple. The tuple must have (XMin, YMin, XMax, YMax) each value represents the lower left bound and upper right bound of the extent.
 Returns
output geometry clipped to extent

contains
(second_geometry, relation=None)¶ Indicates if the base geometry contains the comparison geometry.
Argument
Description
second_geometry
Required arcgis.geometry.Geometry. A second geometry
relation
Optional string. The spatial relationship type.
BOUNDARY  Relationship has no restrictions for interiors or boundaries.
CLEMENTINI  Interiors of geometries must intersect. Specifying CLEMENTINI is equivalent to specifying None. This is the default.
PROPER  Boundaries of geometries must not intersect.
 Returns
boolean

convex_hull
()¶ Constructs the geometry that is the minimal bounding polygon such that all outer angles are convex.

crosses
(second_geometry)¶ Indicates if the two geometries intersect in a geometry of a lesser shape type.
Argument
Description
second_geometry
Required arcgis.geometry.Geometry. A second geometry
 Returns
boolean

cut
(cutter)¶ Splits this geometry into a part left of the cutting polyline, and a part right of it.
Argument
Description
cutter
Required Polyline. The cuttin polyline geometry
 Returns
a list of two geometries

densify
(method, distance, deviation)¶ Creates a new geometry with added vertices
Argument
Description
method
Required String. The type of densification, DISTANCE, ANGLE, or GEODESIC
distance
Required float. The maximum distance between vertices. The actual distance between vertices will usually be less than the maximum distance as new vertices will be evenly distributed along the original segment. If using a type of DISTANCE or ANGLE, the distance is measured in the units of the geometry’s spatial reference. If using a type of GEODESIC, the distance is measured in meters.
deviation
Required float. Densify uses straight lines to approximate curves. You use deviation to control the accuracy of this approximation. The deviation is the maximum distance between the new segment and the original curve. The smaller its value, the more segments will be required to approximate the curve.
 Returns
arcgis.geometry.Geometry

difference
(second_geometry)¶ Constructs the geometry that is composed only of the region unique to the base geometry but not part of the other geometry. The following illustration shows the results when the red polygon is the source geometry.
Argument
Description
second_geometry
Required arcgis.geometry.Geometry. A second geometry
 Returns
arcgis.geometry.Geometry

disjoint
(second_geometry)¶ Indicates if the base and comparison geometries share no points in common.
Argument
Description
second_geometry
Required arcgis.geometry.Geometry. A second geometry
 Returns
boolean

distance_to
(second_geometry)¶ Returns the minimum distance between two geometries. If the geometries intersect, the minimum distance is 0. Both geometries must have the same projection.
Argument
Description
second_geometry
Required arcgis.geometry.Geometry. A second geometry
 Returns
float

equals
(second_geometry)¶ Indicates if the base and comparison geometries are of the same shape type and define the same set of points in the plane. This is a 2D comparison only; M and Z values are ignored.
Argument
Description
second_geometry
Required arcgis.geometry.Geometry. A second geometry
 Returns
boolean

property
extent
¶ Returns the feature’s extent
 Returns
tuple (xmin,ymin,xmax,ymax) in series

property
first_point
¶ Returns the feature’s first point
 Returns
Geometry

generalize
(max_offset)¶ Creates a new simplified geometry using a specified maximum offset tolerance. This only works on Polylines and Polygons.
Argument
Description
max_offset
Required float. The maximum offset tolerance.
 Returns
arcgis.geometry.Geometry

property
geoextent
¶ A returns the geometry’s extents
 Returns
Series of Floats

property
geometry_type
¶ returns the geometry types
 Returns
Series of strings

get_area
(method, units=None)¶ Returns the area of the feature using a measurement type.
Argument
Description
method
Required String. PLANAR measurements reflect the projection of geographic data onto the 2D surface (in other words, they will not take into account the curvature of the earth). GEODESIC, GREAT_ELLIPTIC, LOXODROME, and PRESERVE_SHAPE measurement types may be chosen as an alternative, if desired.
units
Optional String. Areal unit of measure keywords: ACRES  ARES  HECTARES  SQUARECENTIMETERS  SQUAREDECIMETERS  SQUAREINCHES  SQUAREFEET  SQUAREKILOMETERS  SQUAREMETERS  SQUAREMILES  SQUAREMILLIMETERS  SQUAREYARDS
 Returns
float

get_length
(method, units)¶ Returns the length of the feature using a measurement type.
Argument
Description
method
Required String. PLANAR measurements reflect the projection of geographic data onto the 2D surface (in other words, they will not take into account the curvature of the earth). GEODESIC, GREAT_ELLIPTIC, LOXODROME, and PRESERVE_SHAPE measurement types may be chosen as an alternative, if desired.
units
Required String. Linear unit of measure keywords: CENTIMETERS  DECIMETERS  FEET  INCHES  KILOMETERS  METERS  MILES  MILLIMETERS  NAUTICALMILES  YARDS
 Returns
float

get_part
(index=None)¶ Returns an array of point objects for a particular part of geometry or an array containing a number of arrays, one for each part.
requires arcpy
Argument
Description
index
Required Integer. The index position of the geometry.
 Returns
arcpy.Array

property
hull_rectangle
¶ A spacedelimited string of the coordinate pairs of the convex hull
 Returns
Series of strings

intersect
(second_geometry, dimension=1)¶ Constructs a geometry that is the geometric intersection of the two input geometries. Different dimension values can be used to create different shape types. The intersection of two geometries of the same shape type is a geometry containing only the regions of overlap between the original geometries.
Argument
Description
second_geometry
Required arcgis.geometry.Geometry. A second geometry
dimension
Required Integer. The topological dimension (shape type) of the resulting geometry.
1 A zerodimensional geometry (point or multipoint).
2 A onedimensional geometry (polyline).
4 A twodimensional geometry (polygon).
 Returns
boolean

property
is_empty
¶ Returns True/False if feature is empty
 Returns
Series of Booleans

property
is_multipart
¶ Returns True/False if features has multiple parts
 Returns
Series of Booleans

property
is_valid
¶ Returns True/False if features geometry is valid
 Returns
Series of Booleans

property
label_point
¶ Returns the geometry point for the optimal label location
 Returns
Series of Geometries

property
last_point
¶ Returns the Geometry of the last point in a feature.
 Returns
Series of Geometry

property
length
¶ Returns the length of the features
 Returns
Series of float

property
length3D
¶ Returns the length of the features
 Returns
Series of float

measure_on_line
(second_geometry, as_percentage=False)¶ Returns a measure from the start point of this line to the in_point.
Argument
Description
second_geometry
Required arcgis.geometry.Geometry. A second geometry
as_percentage
Optional Boolean. If False, the measure will be returned as a distance; if True, the measure will be returned as a percentage.
 Returns
float

overlaps
(second_geometry)¶ Indicates if the intersection of the two geometries has the same shape type as one of the input geometries and is not equivalent to either of the input geometries.
Argument
Description
second_geometry
Required arcgis.geometry.Geometry. A second geometry
 Returns
boolean

property
part_count
¶ Returns the number of parts in a feature’s geometry
 Returns
Series of Integer

property
point_count
¶ Returns the number of points in a feature’s geometry
 Returns
Series of Integer

point_from_angle_and_distance
(angle, distance, method='GEODESCIC')¶ Returns a point at a given angle and distance in degrees and meters using the specified measurement type.
Argument
Description
angle
Required Float. The angle in degrees to the returned point.
distance
Required Float. The distance in meters to the returned point.
method
Optional String. PLANAR measurements reflect the projection of geographic data onto the 2D surface (in other words, they will not take into account the curvature of the earth). GEODESIC, GREAT_ELLIPTIC, LOXODROME, and PRESERVE_SHAPE measurement types may be chosen as an alternative, if desired.
 Returns
arcgis.geometry.Geometry

position_along_line
(value, use_percentage=False)¶ Returns a point on a line at a specified distance from the beginning of the line.
Argument
Description
value
Required Float. The distance along the line.
use_percentage
Optional Boolean. The distance may be specified as a fixed unit of measure or a ratio of the length of the line. If True, value is used as a percentage; if False, value is used as a distance. For percentages, the value should be expressed as a double from 0.0 (0%) to 1.0 (100%).
 Returns
Geometry

project_as
(spatial_reference, transformation_name=None)¶ Projects a geometry and optionally applies a geotransformation.
Argument
Description
spatial_reference
Required SpatialReference. The new spatial reference. This can be a SpatialReference object or the coordinate system name.
transformation_name
Required String. The geotransformation name.
 Returns
arcgis.geometry.Geometry

query_point_and_distance
(second_geometry, use_percentage=False)¶ Finds the point on the polyline nearest to the in_point and the distance between those points. Also returns information about the side of the line the in_point is on as well as the distance along the line where the nearest point occurs.
Argument
Description
second_geometry
Required arcgis.geometry.Geometry. A second geometry
as_percentage
Optional boolean  if False, the measure will be returned as distance, True, measure will be a percentage
 Returns
tuple

segment_along_line
(start_measure, end_measure, use_percentage=False)¶ Returns a Polyline between start and end measures. Similar to Polyline.positionAlongLine but will return a polyline segment between two points on the polyline instead of a single point.
Argument
Description
start_measure
Required Float. The starting distance from the beginning of the line.
end_measure
Required Float. The ending distance from the beginning of the line.
use_percentage
Optional Boolean. The start and end measures may be specified as fixed units or as a ratio. If True, start_measure and end_measure are used as a percentage; if False, start_measure and end_measure are used as a distance. For percentages, the measures should be expressed as a double from 0.0 (0 percent) to 1.0 (100 percent).
 Returns
Geometry

snap_to_line
(second_geometry)¶ Returns a new point based on in_point snapped to this geometry.
Argument
Description
second_geometry
Required arcgis.geometry.Geometry. A second geometry
 Returns
arcgis.gis.Geometry

property
spatial_reference
¶ Returns the Spatial Reference of the Geometry
 Returns
Series of SpatialReference

symmetric_difference
(second_geometry)¶ Constructs the geometry that is the union of two geometries minus the instersection of those geometries.
The two input geometries must be the same shape type.
Argument
Description
second_geometry
Required arcgis.geometry.Geometry. A second geometry
 Returns
arcgis.gis.Geometry

touches
(second_geometry)¶ Indicates if the boundaries of the geometries intersect.
Argument
Description
second_geometry
Required arcgis.geometry.Geometry. A second geometry
 Returns
boolean

property
true_centroid
¶ Returns the true centroid of the Geometry
 Returns
Series of Points

union
(second_geometry)¶ Constructs the geometry that is the settheoretic union of the input geometries.
Argument
Description
second_geometry
Required arcgis.geometry.Geometry. A second geometry
 Returns
arcgis.gis.Geometry

within
(second_geometry, relation=None)¶ Indicates if the base geometry is within the comparison geometry.
Argument
Description
second_geometry
Required arcgis.geometry.Geometry. A second geometry
relation
Optional String. The spatial relationship type.
BOUNDARY  Relationship has no restrictions for interiors or boundaries.
CLEMENTINI  Interiors of geometries must intersect. Specifying CLEMENTINI is equivalent to specifying None. This is the default.
PROPER  Boundaries of geometries must not intersect.
 Returns
boolean

property
arcgis.features.SpatialDataFrame¶

class
arcgis.features.
SpatialDataFrame
(*args, **kwargs)¶ A Spatial Dataframe is an object to manipulate, manage and translate data into new forms of information for users.
Functionality of the Spatial DataFrame is determined by the Geometry Engine available to the object at creation. It will first leverage the arcpy geometry engine, then shapely, then it will create the geometry objects without any engine.
Scenerios
Engine Type
Functionality
ArcPy
Users will have the full functionality provided by the API.
Shapely
Users get a subset of operations, and all properties.
 Valid Properties
JSON
WKT
WKB
area
centroid
extent
first_point
hull_rectangle
is_multipart
label_point
last_point
length
length3D
part_count
point_count
true_centroid
 Valid Functions
boundary
buffer
contains
convex_hull
crosses
difference
disjoint
distance_to
equals
generalize
intersect
overlaps
symmetric_difference
touches
union
within
Everything else will return None
No Engine
Values will return None by default
 Required Parameters:
None
 Optional:
 param data
panda’s dataframe containing attribute information
 param geometry
list/array/geoseries of arcgis.geometry objects
 param sr
spatial reference of the dataframe. This can be the factory code, WKT string, arcpy.SpatialReference object, or arcgis.SpatailReference object.
 param gis
passing a gis.GIS object set to Pro will ensure arcpy is installed and a full swatch of functionality is available to the end user.

property
JSON
¶ Returns an Esri JSON representation of the geometry as a string.

property
T
¶

property
WKB
¶ Returns the wellknown binary (WKB) representation for OGC geometry. It provides a portable representation of a geometry value as a contiguous stream of bytes.

property
WKT
¶ Returns the wellknown text (WKT) representation for OGC geometry. It provides a portable representation of a geometry value as a text string.

abs
() → FrameOrSeries¶ Return a Series/DataFrame with absolute numeric value of each element.
This function only applies to elements that are all numeric.
 abs
Series/DataFrame containing the absolute value of each element.
numpy.absolute : Calculate the absolute value elementwise.
For
complex
inputs,1.2 + 1j
, the absolute value is \(\sqrt{ a^2 + b^2 }\).Absolute numeric values in a Series.
>>> s = pd.Series([1.10, 2, 3.33, 4]) >>> s.abs() 0 1.10 1 2.00 2 3.33 3 4.00 dtype: float64
Absolute numeric values in a Series with complex numbers.
>>> s = pd.Series([1.2 + 1j]) >>> s.abs() 0 1.56205 dtype: float64
Absolute numeric values in a Series with a Timedelta element.
>>> s = pd.Series([pd.Timedelta('1 days')]) >>> s.abs() 0 1 days dtype: timedelta64[ns]
Select rows with data closest to certain value using argsort (from StackOverflow).
>>> df = pd.DataFrame({ ... 'a': [4, 5, 6, 7], ... 'b': [10, 20, 30, 40], ... 'c': [100, 50, 30, 50] ... }) >>> df a b c 0 4 10 100 1 5 20 50 2 6 30 30 3 7 40 50 >>> df.loc[(df.c  43).abs().argsort()] a b c 1 5 20 50 0 4 10 100 2 6 30 30 3 7 40 50

add
(other, axis='columns', level=None, fill_value=None)¶ Get Addition of dataframe and other, elementwise (binary operator add).
Equivalent to
dataframe + other
, but with support to substitute a fill_value for missing data in one of the inputs. With reverse version, radd.Among flexible wrappers (add, sub, mul, div, mod, pow) to arithmetic operators: +, , *, /, //, %, **.
 otherscalar, sequence, Series, or DataFrame
Any single or multiple element data structure, or listlike object.
 axis{0 or ‘index’, 1 or ‘columns’}
Whether to compare by the index (0 or ‘index’) or columns (1 or ‘columns’). For Series input, axis to match Series index on.
 levelint or label
Broadcast across a level, matching Index values on the passed MultiIndex level.
 fill_valuefloat or None, default None
Fill existing missing (NaN) values, and any new element needed for successful DataFrame alignment, with this value before computation. If data in both corresponding DataFrame locations is missing the result will be missing.
 DataFrame
Result of the arithmetic operation.
DataFrame.add : Add DataFrames. DataFrame.sub : Subtract DataFrames. DataFrame.mul : Multiply DataFrames. DataFrame.div : Divide DataFrames (float division). DataFrame.truediv : Divide DataFrames (float division). DataFrame.floordiv : Divide DataFrames (integer division). DataFrame.mod : Calculate modulo (remainder after division). DataFrame.pow : Calculate exponential power.
Mismatched indices will be unioned together.
>>> df = pd.DataFrame({'angles': [0, 3, 4], ... 'degrees': [360, 180, 360]}, ... index=['circle', 'triangle', 'rectangle']) >>> df angles degrees circle 0 360 triangle 3 180 rectangle 4 360
Add a scalar with operator version which return the same results.
>>> df + 1 angles degrees circle 1 361 triangle 4 181 rectangle 5 361
>>> df.add(1) angles degrees circle 1 361 triangle 4 181 rectangle 5 361
Divide by constant with reverse version.
>>> df.div(10) angles degrees circle 0.0 36.0 triangle 0.3 18.0 rectangle 0.4 36.0
>>> df.rdiv(10) angles degrees circle inf 0.027778 triangle 3.333333 0.055556 rectangle 2.500000 0.027778
Subtract a list and Series by axis with operator version.
>>> df  [1, 2] angles degrees circle 1 358 triangle 2 178 rectangle 3 358
>>> df.sub([1, 2], axis='columns') angles degrees circle 1 358 triangle 2 178 rectangle 3 358
>>> df.sub(pd.Series([1, 1, 1], index=['circle', 'triangle', 'rectangle']), ... axis='index') angles degrees circle 1 359 triangle 2 179 rectangle 3 359
Multiply a DataFrame of different shape with operator version.
>>> other = pd.DataFrame({'angles': [0, 3, 4]}, ... index=['circle', 'triangle', 'rectangle']) >>> other angles circle 0 triangle 3 rectangle 4
>>> df * other angles degrees circle 0 NaN triangle 9 NaN rectangle 16 NaN
>>> df.mul(other, fill_value=0) angles degrees circle 0 0.0 triangle 9 0.0 rectangle 16 0.0
Divide by a MultiIndex by level.
>>> df_multindex = pd.DataFrame({'angles': [0, 3, 4, 4, 5, 6], ... 'degrees': [360, 180, 360, 360, 540, 720]}, ... index=[['A', 'A', 'A', 'B', 'B', 'B'], ... ['circle', 'triangle', 'rectangle', ... 'square', 'pentagon', 'hexagon']]) >>> df_multindex angles degrees A circle 0 360 triangle 3 180 rectangle 4 360 B square 4 360 pentagon 5 540 hexagon 6 720
>>> df.div(df_multindex, level=1, fill_value=0) angles degrees A circle NaN 1.0 triangle 1.0 1.0 rectangle 1.0 1.0 B square 0.0 0.0 pentagon 0.0 0.0 hexagon 0.0 0.0

add_prefix
(prefix: str) → FrameOrSeries¶ Prefix labels with string prefix.
For Series, the row labels are prefixed. For DataFrame, the column labels are prefixed.
 prefixstr
The string to add before each label.
 Series or DataFrame
New Series or DataFrame with updated labels.
Series.add_suffix: Suffix row labels with string suffix. DataFrame.add_suffix: Suffix column labels with string suffix.
>>> s = pd.Series([1, 2, 3, 4]) >>> s 0 1 1 2 2 3 3 4 dtype: int64
>>> s.add_prefix('item_') item_0 1 item_1 2 item_2 3 item_3 4 dtype: int64
>>> df = pd.DataFrame({'A': [1, 2, 3, 4], 'B': [3, 4, 5, 6]}) >>> df A B 0 1 3 1 2 4 2 3 5 3 4 6
>>> df.add_prefix('col_') col_A col_B 0 1 3 1 2 4 2 3 5 3 4 6

add_suffix
(suffix: str) → FrameOrSeries¶ Suffix labels with string suffix.
For Series, the row labels are suffixed. For DataFrame, the column labels are suffixed.
 suffixstr
The string to add after each label.
 Series or DataFrame
New Series or DataFrame with updated labels.
Series.add_prefix: Prefix row labels with string prefix. DataFrame.add_prefix: Prefix column labels with string prefix.
>>> s = pd.Series([1, 2, 3, 4]) >>> s 0 1 1 2 2 3 3 4 dtype: int64
>>> s.add_suffix('_item') 0_item 1 1_item 2 2_item 3 3_item 4 dtype: int64
>>> df = pd.DataFrame({'A': [1, 2, 3, 4], 'B': [3, 4, 5, 6]}) >>> df A B 0 1 3 1 2 4 2 3 5 3 4 6
>>> df.add_suffix('_col') A_col B_col 0 1 3 1 2 4 2 3 5 3 4 6

agg
(func=None, axis=0, *args, **kwargs)¶ Aggregate using one or more operations over the specified axis.
New in version 0.20.0.
 funcfunction, str, list or dict
Function to use for aggregating the data. If a function, must either work when passed a DataFrame or when passed to DataFrame.apply.
Accepted combinations are:
function
string function name
list of functions and/or function names, e.g.
[np.sum, 'mean']
dict of axis labels > functions, function names or list of such.
 axis{0 or ‘index’, 1 or ‘columns’}, default 0
If 0 or ‘index’: apply function to each column. If 1 or ‘columns’: apply function to each row.
 *args
Positional arguments to pass to func.
 **kwargs
Keyword arguments to pass to func.
scalar, Series or DataFrame
The return can be:
scalar : when Series.agg is called with single function
Series : when DataFrame.agg is called with a single function
DataFrame : when DataFrame.agg is called with several functions
Return scalar, Series or DataFrame.
The aggregation operations are always performed over an axis, either the index (default) or the column axis. This behavior is different from numpy aggregation functions (mean, median, prod, sum, std, var), where the default is to compute the aggregation of the flattened array, e.g.,
numpy.mean(arr_2d)
as opposed tonumpy.mean(arr_2d, axis=0)
.agg is an alias for aggregate. Use the alias.
DataFrame.apply : Perform any type of operations. DataFrame.transform : Perform transformation type operations. core.groupby.GroupBy : Perform operations over groups. core.resample.Resampler : Perform operations over resampled bins. core.window.Rolling : Perform operations over rolling window. core.window.Expanding : Perform operations over expanding window. core.window.ExponentialMovingWindow : Perform operation over exponential weighted
window.
agg is an alias for aggregate. Use the alias.
A passed userdefinedfunction will be passed a Series for evaluation.
>>> df = pd.DataFrame([[1, 2, 3], ... [4, 5, 6], ... [7, 8, 9], ... [np.nan, np.nan, np.nan]], ... columns=['A', 'B', 'C'])
Aggregate these functions over the rows.
>>> df.agg(['sum', 'min']) A B C sum 12.0 15.0 18.0 min 1.0 2.0 3.0
Different aggregations per column.
>>> df.agg({'A' : ['sum', 'min'], 'B' : ['min', 'max']}) A B max NaN 8.0 min 1.0 2.0 sum 12.0 NaN
Aggregate over the columns.
>>> df.agg("mean", axis="columns") 0 2.0 1 5.0 2 8.0 3 NaN dtype: float64

aggregate
(func=None, axis=0, *args, **kwargs)¶ Aggregate using one or more operations over the specified axis.
New in version 0.20.0.
 funcfunction, str, list or dict
Function to use for aggregating the data. If a function, must either work when passed a DataFrame or when passed to DataFrame.apply.
Accepted combinations are:
function
string function name
list of functions and/or function names, e.g.
[np.sum, 'mean']
dict of axis labels > functions, function names or list of such.
 axis{0 or ‘index’, 1 or ‘columns’}, default 0
If 0 or ‘index’: apply function to each column. If 1 or ‘columns’: apply function to each row.
 *args
Positional arguments to pass to func.
 **kwargs
Keyword arguments to pass to func.
scalar, Series or DataFrame
The return can be:
scalar : when Series.agg is called with single function
Series : when DataFrame.agg is called with a single function
DataFrame : when DataFrame.agg is called with several functions
Return scalar, Series or DataFrame.
The aggregation operations are always performed over an axis, either the index (default) or the column axis. This behavior is different from numpy aggregation functions (mean, median, prod, sum, std, var), where the default is to compute the aggregation of the flattened array, e.g.,
numpy.mean(arr_2d)
as opposed tonumpy.mean(arr_2d, axis=0)
.agg is an alias for aggregate. Use the alias.
DataFrame.apply : Perform any type of operations. DataFrame.transform : Perform transformation type operations. core.groupby.GroupBy : Perform operations over groups. core.resample.Resampler : Perform operations over resampled bins. core.window.Rolling : Perform operations over rolling window. core.window.Expanding : Perform operations over expanding window. core.window.ExponentialMovingWindow : Perform operation over exponential weighted
window.
agg is an alias for aggregate. Use the alias.
A passed userdefinedfunction will be passed a Series for evaluation.
>>> df = pd.DataFrame([[1, 2, 3], ... [4, 5, 6], ... [7, 8, 9], ... [np.nan, np.nan, np.nan]], ... columns=['A', 'B', 'C'])
Aggregate these functions over the rows.
>>> df.agg(['sum', 'min']) A B C sum 12.0 15.0 18.0 min 1.0 2.0 3.0
Different aggregations per column.
>>> df.agg({'A' : ['sum', 'min'], 'B' : ['min', 'max']}) A B max NaN 8.0 min 1.0 2.0 sum 12.0 NaN
Aggregate over the columns.
>>> df.agg("mean", axis="columns") 0 2.0 1 5.0 2 8.0 3 NaN dtype: float64

align
(other, join='outer', axis=None, level=None, copy=True, fill_value=None, method=None, limit=None, fill_axis=0, broadcast_axis=None) → pandas.core.frame.DataFrame¶ Align two objects on their axes with the specified join method.
Join method is specified for each axis Index.
other : DataFrame or Series join : {‘outer’, ‘inner’, ‘left’, ‘right’}, default ‘outer’ axis : allowed axis of the other object, default None
Align on index (0), columns (1), or both (None).
 levelint or level name, default None
Broadcast across a level, matching Index values on the passed MultiIndex level.
 copybool, default True
Always returns new objects. If copy=False and no reindexing is required then original objects are returned.
 fill_valuescalar, default np.NaN
Value to use for missing values. Defaults to NaN, but can be any “compatible” value.
 method{‘backfill’, ‘bfill’, ‘pad’, ‘ffill’, None}, default None
Method to use for filling holes in reindexed Series:
pad / ffill: propagate last valid observation forward to next valid.
backfill / bfill: use NEXT valid observation to fill gap.
 limitint, default None
If method is specified, this is the maximum number of consecutive NaN values to forward/backward fill. In other words, if there is a gap with more than this number of consecutive NaNs, it will only be partially filled. If method is not specified, this is the maximum number of entries along the entire axis where NaNs will be filled. Must be greater than 0 if not None.
 fill_axis{0 or ‘index’, 1 or ‘columns’}, default 0
Filling axis, method and limit.
 broadcast_axis{0 or ‘index’, 1 or ‘columns’}, default None
Broadcast values along this axis, if aligning two objects of different dimensions.
 (left, right)(DataFrame, type of other)
Aligned objects.

all
(axis=0, bool_only=None, skipna=True, level=None, **kwargs)¶ Return whether all elements are True, potentially over an axis.
Returns True unless there at least one element within a series or along a Dataframe axis that is False or equivalent (e.g. zero or empty).
 axis{0 or ‘index’, 1 or ‘columns’, None}, default 0
Indicate which axis or axes should be reduced.
0 / ‘index’ : reduce the index, return a Series whose index is the original column labels.
1 / ‘columns’ : reduce the columns, return a Series whose index is the original index.
None : reduce all axes, return a scalar.
 bool_onlybool, default None
Include only boolean columns. If None, will attempt to use everything, then use only boolean data. Not implemented for Series.
 skipnabool, default True
Exclude NA/null values. If the entire row/column is NA and skipna is True, then the result will be True, as for an empty row/column. If skipna is False, then NA are treated as True, because these are not equal to zero.
 levelint or level name, default None
If the axis is a MultiIndex (hierarchical), count along a particular level, collapsing into a Series.
 **kwargsany, default None
Additional keywords have no effect but might be accepted for compatibility with NumPy.
 Series or DataFrame
If level is specified, then, DataFrame is returned; otherwise, Series is returned.
Series.all : Return True if all elements are True. DataFrame.any : Return True if one (or more) elements are True.
Series
>>> pd.Series([True, True]).all() True >>> pd.Series([True, False]).all() False >>> pd.Series([]).all() True >>> pd.Series([np.nan]).all() True >>> pd.Series([np.nan]).all(skipna=False) True
DataFrames
Create a dataframe from a dictionary.
>>> df = pd.DataFrame({'col1': [True, True], 'col2': [True, False]}) >>> df col1 col2 0 True True 1 True False
Default behaviour checks if columnwise values all return True.
>>> df.all() col1 True col2 False dtype: bool
Specify
axis='columns'
to check if rowwise values all return True.>>> df.all(axis='columns') 0 True 1 False dtype: bool
Or
axis=None
for whether every value is True.>>> df.all(axis=None) False

angle_distance_to
(second_geometry, method='GEODESIC')¶ Returns a tuple of angle and distance to another point using a measurement type.
 Paramters:
 second_geometry
a second geometry
 method
PLANAR measurements reflect the projection of geographic
data onto the 2D surface (in other words, they will not take into account the curvature of the earth). GEODESIC, GREAT_ELLIPTIC, LOXODROME, and PRESERVE_SHAPE measurement types may be chosen as an alternative, if desired.

any
(axis=0, bool_only=None, skipna=True, level=None, **kwargs)¶ Return whether any element is True, potentially over an axis.
Returns False unless there at least one element within a series or along a Dataframe axis that is True or equivalent (e.g. nonzero or nonempty).
 axis{0 or ‘index’, 1 or ‘columns’, None}, default 0
Indicate which axis or axes should be reduced.
0 / ‘index’ : reduce the index, return a Series whose index is the original column labels.
1 / ‘columns’ : reduce the columns, return a Series whose index is the original index.
None : reduce all axes, return a scalar.
 bool_onlybool, default None
Include only boolean columns. If None, will attempt to use everything, then use only boolean data. Not implemented for Series.
 skipnabool, default True
Exclude NA/null values. If the entire row/column is NA and skipna is True, then the result will be False, as for an empty row/column. If skipna is False, then NA are treated as True, because these are not equal to zero.
 levelint or level name, default None
If the axis is a MultiIndex (hierarchical), count along a particular level, collapsing into a Series.
 **kwargsany, default None
Additional keywords have no effect but might be accepted for compatibility with NumPy.
 Series or DataFrame
If level is specified, then, DataFrame is returned; otherwise, Series is returned.
numpy.any : Numpy version of this method. Series.any : Return whether any element is True. Series.all : Return whether all elements are True. DataFrame.any : Return whether any element is True over requested axis. DataFrame.all : Return whether all elements are True over requested axis.
Series
For Series input, the output is a scalar indicating whether any element is True.
>>> pd.Series([False, False]).any() False >>> pd.Series([True, False]).any() True >>> pd.Series([]).any() False >>> pd.Series([np.nan]).any() False >>> pd.Series([np.nan]).any(skipna=False) True
DataFrame
Whether each column contains at least one True element (the default).
>>> df = pd.DataFrame({"A": [1, 2], "B": [0, 2], "C": [0, 0]}) >>> df A B C 0 1 0 0 1 2 2 0
>>> df.any() A True B True C False dtype: bool
Aggregating over the columns.
>>> df = pd.DataFrame({"A": [True, False], "B": [1, 2]}) >>> df A B 0 True 1 1 False 2
>>> df.any(axis='columns') 0 True 1 True dtype: bool
>>> df = pd.DataFrame({"A": [True, False], "B": [1, 0]}) >>> df A B 0 True 1 1 False 0
>>> df.any(axis='columns') 0 True 1 False dtype: bool
Aggregating over the entire DataFrame with
axis=None
.>>> df.any(axis=None) True
any for an empty DataFrame is an empty Series.
>>> pd.DataFrame([]).any() Series([], dtype: bool)

append
(other, ignore_index=False, verify_integrity=False, sort=False) → pandas.core.frame.DataFrame¶ Append rows of other to the end of caller, returning a new object.
Columns in other that are not in the caller are added as new columns.
 otherDataFrame or Series/dictlike object, or list of these
The data to append.
 ignore_indexbool, default False
If True, the resulting axis will be labeled 0, 1, …, n  1.
 verify_integritybool, default False
If True, raise ValueError on creating index with duplicates.
 sortbool, default False
Sort columns if the columns of self and other are not aligned.
New in version 0.23.0.
Changed in version 1.0.0: Changed to not sort by default.
DataFrame
concat : General function to concatenate DataFrame or Series objects.
If a list of dict/series is passed and the keys are all contained in the DataFrame’s index, the order of the columns in the resulting DataFrame will be unchanged.
Iteratively appending rows to a DataFrame can be more computationally intensive than a single concatenate. A better solution is to append those rows to a list and then concatenate the list with the original DataFrame all at once.
>>> df = pd.DataFrame([[1, 2], [3, 4]], columns=list('AB')) >>> df A B 0 1 2 1 3 4 >>> df2 = pd.DataFrame([[5, 6], [7, 8]], columns=list('AB')) >>> df.append(df2) A B 0 1 2 1 3 4 0 5 6 1 7 8
With ignore_index set to True:
>>> df.append(df2, ignore_index=True) A B 0 1 2 1 3 4 2 5 6 3 7 8
The following, while not recommended methods for generating DataFrames, show two ways to generate a DataFrame from multiple data sources.
Less efficient:
>>> df = pd.DataFrame(columns=['A']) >>> for i in range(5): ... df = df.append({'A': i}, ignore_index=True) >>> df A 0 0 1 1 2 2 3 3 4 4
More efficient:
>>> pd.concat([pd.DataFrame([i], columns=['A']) for i in range(5)], ... ignore_index=True) A 0 0 1 1 2 2 3 3 4 4

apply
(func, axis=0, raw=False, result_type=None, args=(), **kwds)¶ Apply a function along an axis of the DataFrame.
Objects passed to the function are Series objects whose index is either the DataFrame’s index (
axis=0
) or the DataFrame’s columns (axis=1
). By default (result_type=None
), the final return type is inferred from the return type of the applied function. Otherwise, it depends on the result_type argument. funcfunction
Function to apply to each column or row.
 axis{0 or ‘index’, 1 or ‘columns’}, default 0
Axis along which the function is applied:
0 or ‘index’: apply function to each column.
1 or ‘columns’: apply function to each row.
 rawbool, default False
Determines if row or column is passed as a Series or ndarray object:
False
: passes each row or column as a Series to the function.True
: the passed function will receive ndarray objects instead. If you are just applying a NumPy reduction function this will achieve much better performance.
 result_type{‘expand’, ‘reduce’, ‘broadcast’, None}, default None
These only act when
axis=1
(columns):‘expand’ : listlike results will be turned into columns.
‘reduce’ : returns a Series if possible rather than expanding listlike results. This is the opposite of ‘expand’.
‘broadcast’ : results will be broadcast to the original shape of the DataFrame, the original index and columns will be retained.
The default behaviour (None) depends on the return value of the applied function: listlike results will be returned as a Series of those. However if the apply function returns a Series these are expanded to columns.
New in version 0.23.0.
 argstuple
Positional arguments to pass to func in addition to the array/series.
 **kwds
Additional keyword arguments to pass as keywords arguments to func.
 Series or DataFrame
Result of applying
func
along the given axis of the DataFrame.
DataFrame.applymap: For elementwise operations. DataFrame.aggregate: Only perform aggregating type operations. DataFrame.transform: Only perform transforming type operations.
>>> df = pd.DataFrame([[4, 9]] * 3, columns=['A', 'B']) >>> df A B 0 4 9 1 4 9 2 4 9
Using a numpy universal function (in this case the same as
np.sqrt(df)
):>>> df.apply(np.sqrt) A B 0 2.0 3.0 1 2.0 3.0 2 2.0 3.0
Using a reducing function on either axis
>>> df.apply(np.sum, axis=0) A 12 B 27 dtype: int64
>>> df.apply(np.sum, axis=1) 0 13 1 13 2 13 dtype: int64
Returning a listlike will result in a Series
>>> df.apply(lambda x: [1, 2], axis=1) 0 [1, 2] 1 [1, 2] 2 [1, 2] dtype: object
Passing
result_type='expand'
will expand listlike results to columns of a Dataframe>>> df.apply(lambda x: [1, 2], axis=1, result_type='expand') 0 1 0 1 2 1 1 2 2 1 2
Returning a Series inside the function is similar to passing
result_type='expand'
. The resulting column names will be the Series index.>>> df.apply(lambda x: pd.Series([1, 2], index=['foo', 'bar']), axis=1) foo bar 0 1 2 1 1 2 2 1 2
Passing
result_type='broadcast'
will ensure the same shape result, whether listlike or scalar is returned by the function, and broadcast it along the axis. The resulting column names will be the originals.>>> df.apply(lambda x: [1, 2], axis=1, result_type='broadcast') A B 0 1 2 1 1 2 2 1 2

applymap
(func) → pandas.core.frame.DataFrame¶ Apply a function to a Dataframe elementwise.
This method applies a function that accepts and returns a scalar to every element of a DataFrame.
 funccallable
Python function, returns a single value from a single value.
 DataFrame
Transformed DataFrame.
DataFrame.apply : Apply a function along input axis of DataFrame.
>>> df = pd.DataFrame([[1, 2.12], [3.356, 4.567]]) >>> df 0 1 0 1.000 2.120 1 3.356 4.567
>>> df.applymap(lambda x: len(str(x))) 0 1 0 3 4 1 5 5
Note that a vectorized version of func often exists, which will be much faster. You could square each number elementwise.
>>> df.applymap(lambda x: x**2) 0 1 0 1.000000 4.494400 1 11.262736 20.857489
But it’s better to avoid applymap in that case.
>>> df ** 2 0 1 0 1.000000 4.494400 1 11.262736 20.857489

property
area
¶ The area of a polygon feature. Empty for all other feature types.

property
as_arcpy
¶ Returns an Esri ArcPy geometry in a Series

property
as_shapely
¶ Returns a Shapely Geometry Objects in a Series

asfreq
(freq, method=None, how: Optional[str] = None, normalize: bool = False, fill_value=None) → FrameOrSeries¶ Convert TimeSeries to specified frequency.
Optionally provide filling method to pad/backfill missing values.
Returns the original data conformed to a new index with the specified frequency.
resample
is more appropriate if an operation, such as summarization, is necessary to represent the data at the new frequency. freqDateOffset or str
Frequency DateOffset or string.
 method{‘backfill’/’bfill’, ‘pad’/’ffill’}, default None
Method to use for filling holes in reindexed Series (note this does not fill NaNs that already were present):
‘pad’ / ‘ffill’: propagate last valid observation forward to next valid
‘backfill’ / ‘bfill’: use NEXT valid observation to fill.
 how{‘start’, ‘end’}, default end
For PeriodIndex only (see PeriodIndex.asfreq).
 normalizebool, default False
Whether to reset output index to midnight.
 fill_valuescalar, optional
Value to use for missing values, applied during upsampling (note this does not fill NaNs that already were present).
 Same type as caller
Object converted to the specified frequency.
reindex : Conform DataFrame to new index with optional filling logic.
To learn more about the frequency strings, please see this link.
Start by creating a series with 4 one minute timestamps.
>>> index = pd.date_range('1/1/2000', periods=4, freq='T') >>> series = pd.Series([0.0, None, 2.0, 3.0], index=index) >>> df = pd.DataFrame({'s':series}) >>> df s 20000101 00:00:00 0.0 20000101 00:01:00 NaN 20000101 00:02:00 2.0 20000101 00:03:00 3.0
Upsample the series into 30 second bins.
>>> df.asfreq(freq='30S') s 20000101 00:00:00 0.0 20000101 00:00:30 NaN 20000101 00:01:00 NaN 20000101 00:01:30 NaN 20000101 00:02:00 2.0 20000101 00:02:30 NaN 20000101 00:03:00 3.0
Upsample again, providing a
fill value
.>>> df.asfreq(freq='30S', fill_value=9.0) s 20000101 00:00:00 0.0 20000101 00:00:30 9.0 20000101 00:01:00 NaN 20000101 00:01:30 9.0 20000101 00:02:00 2.0 20000101 00:02:30 9.0 20000101 00:03:00 3.0
Upsample again, providing a
method
.>>> df.asfreq(freq='30S', method='bfill') s 20000101 00:00:00 0.0 20000101 00:00:30 NaN 20000101 00:01:00 NaN 20000101 00:01:30 2.0 20000101 00:02:00 2.0 20000101 00:02:30 3.0 20000101 00:03:00 3.0

asof
(where, subset=None)¶ Return the last row(s) without any NaNs before where.
The last row (for each element in where, if list) without any NaN is taken. In case of a
DataFrame
, the last row without NaN considering only the subset of columns (if not None)If there is no good value, NaN is returned for a Series or a Series of NaN values for a DataFrame
 wheredate or arraylike of dates
Date(s) before which the last row(s) are returned.
 subsetstr or arraylike of str, default None
For DataFrame, if not None, only use these columns to check for NaNs.
scalar, Series, or DataFrame
The return can be:
scalar : when self is a Series and where is a scalar
Series: when self is a Series and where is an arraylike, or when self is a DataFrame and where is a scalar
DataFrame : when self is a DataFrame and where is an arraylike
Return scalar, Series, or DataFrame.
merge_asof : Perform an asof merge. Similar to left join.
Dates are assumed to be sorted. Raises if this is not the case.
A Series and a scalar where.
>>> s = pd.Series([1, 2, np.nan, 4], index=[10, 20, 30, 40]) >>> s 10 1.0 20 2.0 30 NaN 40 4.0 dtype: float64
>>> s.asof(20) 2.0
For a sequence where, a Series is returned. The first value is NaN, because the first element of where is before the first index value.
>>> s.asof([5, 20]) 5 NaN 20 2.0 dtype: float64
Missing values are not considered. The following is
2.0
, not NaN, even though NaN is at the index location for30
.>>> s.asof(30) 2.0
Take all columns into consideration
>>> df = pd.DataFrame({'a': [10, 20, 30, 40, 50], ... 'b': [None, None, None, None, 500]}, ... index=pd.DatetimeIndex(['20180227 09:01:00', ... '20180227 09:02:00', ... '20180227 09:03:00', ... '20180227 09:04:00', ... '20180227 09:05:00'])) >>> df.asof(pd.DatetimeIndex(['20180227 09:03:30', ... '20180227 09:04:30'])) a b 20180227 09:03:30 NaN NaN 20180227 09:04:30 NaN NaN
Take a single column into consideration
>>> df.asof(pd.DatetimeIndex(['20180227 09:03:30', ... '20180227 09:04:30']), ... subset=['a']) a b 20180227 09:03:30 30.0 NaN 20180227 09:04:30 40.0 NaN

assign
(**kwargs) → pandas.core.frame.DataFrame¶ Assign new columns to a DataFrame.
Returns a new object with all original columns in addition to new ones. Existing columns that are reassigned will be overwritten.
 **kwargsdict of {str: callable or Series}
The column names are keywords. If the values are callable, they are computed on the DataFrame and assigned to the new columns. The callable must not change input DataFrame (though pandas doesn’t check it). If the values are not callable, (e.g. a Series, scalar, or array), they are simply assigned.
 DataFrame
A new DataFrame with the new columns in addition to all the existing columns.
Assigning multiple columns within the same
assign
is possible. Later items in ‘**kwargs’ may refer to newly created or modified columns in ‘df’; items are computed and assigned into ‘df’ in order.Changed in version 0.23.0: Keyword argument order is maintained.
>>> df = pd.DataFrame({'temp_c': [17.0, 25.0]}, ... index=['Portland', 'Berkeley']) >>> df temp_c Portland 17.0 Berkeley 25.0
Where the value is a callable, evaluated on df:
>>> df.assign(temp_f=lambda x: x.temp_c * 9 / 5 + 32) temp_c temp_f Portland 17.0 62.6 Berkeley 25.0 77.0
Alternatively, the same behavior can be achieved by directly referencing an existing Series or sequence:
>>> df.assign(temp_f=df['temp_c'] * 9 / 5 + 32) temp_c temp_f Portland 17.0 62.6 Berkeley 25.0 77.0
You can create multiple columns within the same assign where one of the columns depends on another one defined within the same assign:
>>> df.assign(temp_f=lambda x: x['temp_c'] * 9 / 5 + 32, ... temp_k=lambda x: (x['temp_f'] + 459.67) * 5 / 9) temp_c temp_f temp_k Portland 17.0 62.6 290.15 Berkeley 25.0 77.0 298.15

astype
(dtype, copy: bool = True, errors: str = 'raise') → FrameOrSeries¶ Cast a pandas object to a specified dtype
dtype
. dtypedata type, or dict of column name > data type
Use a numpy.dtype or Python type to cast entire pandas object to the same type. Alternatively, use {col: dtype, …}, where col is a column label and dtype is a numpy.dtype or Python type to cast one or more of the DataFrame’s columns to columnspecific types.
 copybool, default True
Return a copy when
copy=True
(be very careful settingcopy=False
as changes to values then may propagate to other pandas objects). errors{‘raise’, ‘ignore’}, default ‘raise’
Control raising of exceptions on invalid data for provided dtype.
raise
: allow exceptions to be raisedignore
: suppress exceptions. On error return original object.
casted : same type as caller
to_datetime : Convert argument to datetime. to_timedelta : Convert argument to timedelta. to_numeric : Convert argument to a numeric type. numpy.ndarray.astype : Cast a numpy array to a specified type.
Create a DataFrame:
>>> d = {'col1': [1, 2], 'col2': [3, 4]} >>> df = pd.DataFrame(data=d) >>> df.dtypes col1 int64 col2 int64 dtype: object
Cast all columns to int32:
>>> df.astype('int32').dtypes col1 int32 col2 int32 dtype: object
Cast col1 to int32 using a dictionary:
>>> df.astype({'col1': 'int32'}).dtypes col1 int32 col2 int64 dtype: object
Create a series:
>>> ser = pd.Series([1, 2], dtype='int32') >>> ser 0 1 1 2 dtype: int32 >>> ser.astype('int64') 0 1 1 2 dtype: int64
Convert to categorical type:
>>> ser.astype('category') 0 1 1 2 dtype: category Categories (2, int64): [1, 2]
Convert to ordered categorical type with custom ordering:
>>> cat_dtype = pd.api.types.CategoricalDtype( ... categories=[2, 1], ordered=True) >>> ser.astype(cat_dtype) 0 1 1 2 dtype: category Categories (2, int64): [2 < 1]
Note that using
copy=False
and changing data on a new pandas object may propagate changes:>>> s1 = pd.Series([1, 2]) >>> s2 = s1.astype('int64', copy=False) >>> s2[0] = 10 >>> s1 # note that s1[0] has changed too 0 10 1 2 dtype: int64
Create a series of dates:
>>> ser_date = pd.Series(pd.date_range('20200101', periods=3)) >>> ser_date 0 20200101 1 20200102 2 20200103 dtype: datetime64[ns]
Datetimes are localized to UTC first before converting to the specified timezone:
>>> ser_date.astype('datetime64[ns, US/Eastern]') 0 20191231 19:00:0005:00 1 20200101 19:00:0005:00 2 20200102 19:00:0005:00 dtype: datetime64[ns, US/Eastern]

property
at
¶ Access a single value for a row/column label pair.
Similar to
loc
, in that both provide labelbased lookups. Useat
if you only need to get or set a single value in a DataFrame or Series. KeyError
If ‘label’ does not exist in DataFrame.
 DataFrame.iatAccess a single value for a row/column pair by integer
position.
DataFrame.loc : Access a group of rows and columns by label(s). Series.at : Access a single value using a label.
>>> df = pd.DataFrame([[0, 2, 3], [0, 4, 1], [10, 20, 30]], ... index=[4, 5, 6], columns=['A', 'B', 'C']) >>> df A B C 4 0 2 3 5 0 4 1 6 10 20 30
Get value at specified row/column pair
>>> df.at[4, 'B'] 2
Set value at specified row/column pair
>>> df.at[4, 'B'] = 10 >>> df.at[4, 'B'] 10
Get value within a Series
>>> df.loc[5].at['B'] 4

at_time
(time, asof: bool = False, axis=None) → FrameOrSeries¶ Select values at particular time of day (e.g., 9:30AM).
time : datetime.time or str axis : {0 or ‘index’, 1 or ‘columns’}, default 0
New in version 0.24.0.
Series or DataFrame
 TypeError
If the index is not a
DatetimeIndex
between_time : Select values between particular times of the day. first : Select initial periods of time series based on a date offset. last : Select final periods of time series based on a date offset. DatetimeIndex.indexer_at_time : Get just the index locations for
values at particular time of the day.
>>> i = pd.date_range('20180409', periods=4, freq='12H') >>> ts = pd.DataFrame({'A': [1, 2, 3, 4]}, index=i) >>> ts A 20180409 00:00:00 1 20180409 12:00:00 2 20180410 00:00:00 3 20180410 12:00:00 4
>>> ts.at_time('12:00') A 20180409 12:00:00 2 20180410 12:00:00 4

property
attrs
¶ Dictionary of global attributes on this object.
Warning
attrs is experimental and may change without warning.

property
axes
¶ Return a list representing the axes of the DataFrame.
It has the row axis labels and column axis labels as the only members. They are returned in that order.
>>> df = pd.DataFrame({'col1': [1, 2], 'col2': [3, 4]}) >>> df.axes [RangeIndex(start=0, stop=2, step=1), Index(['col1', 'col2'], dtype='object')]

backfill
(axis=None, inplace: bool = False, limit=None, downcast=None) → Optional[FrameOrSeries]¶ Synonym for
DataFrame.fillna()
withmethod='bfill'
. {klass} or None
Object with missing values filled or None if
inplace=True
.

between_time
(start_time, end_time, include_start: bool = True, include_end: bool = True, axis=None) → FrameOrSeries¶ Select values between particular times of the day (e.g., 9:009:30 AM).
By setting
start_time
to be later thanend_time
, you can get the times that are not between the two times. start_timedatetime.time or str
Initial time as a time filter limit.
 end_timedatetime.time or str
End time as a time filter limit.
 include_startbool, default True
Whether the start time needs to be included in the result.
 include_endbool, default True
Whether the end time needs to be included in the result.
 axis{0 or ‘index’, 1 or ‘columns’}, default 0
Determine range time on index or columns value.
New in version 0.24.0.
 Series or DataFrame
Data from the original object filtered to the specified dates range.
 TypeError
If the index is not a
DatetimeIndex
at_time : Select values at a particular time of the day. first : Select initial periods of time series based on a date offset. last : Select final periods of time series based on a date offset. DatetimeIndex.indexer_between_time : Get just the index locations for
values between particular times of the day.
>>> i = pd.date_range('20180409', periods=4, freq='1D20min') >>> ts = pd.DataFrame({'A': [1, 2, 3, 4]}, index=i) >>> ts A 20180409 00:00:00 1 20180410 00:20:00 2 20180411 00:40:00 3 20180412 01:00:00 4
>>> ts.between_time('0:15', '0:45') A 20180410 00:20:00 2 20180411 00:40:00 3
You get the times that are not between two times by setting
start_time
later thanend_time
:>>> ts.between_time('0:45', '0:15') A 20180409 00:00:00 1 20180412 01:00:00 4

bfill
(axis=None, inplace: bool = False, limit=None, downcast=None) → Optional[FrameOrSeries]¶ Synonym for
DataFrame.fillna()
withmethod='bfill'
. {klass} or None
Object with missing values filled or None if
inplace=True
.

bool
()¶ Return the bool of a single element Series or DataFrame.
This must be a boolean scalar value, either True or False. It will raise a ValueError if the Series or DataFrame does not have exactly 1 element, or that element is not boolean (integer values 0 and 1 will also raise an exception).
 bool
The value in the Series or DataFrame.
Series.astype : Change the data type of a Series, including to boolean. DataFrame.astype : Change the data type of a DataFrame, including to boolean. numpy.bool_ : NumPy boolean data type, used by pandas for boolean values.
The method will only work for single element objects with a boolean value:
>>> pd.Series([True]).bool() True >>> pd.Series([False]).bool() False
>>> pd.DataFrame({'col': [True]}).bool() True >>> pd.DataFrame({'col': [False]}).bool() False

boundary
()¶ Constructs the boundary of the geometry.

property
bounds
¶ Return a DataFrame of minx, miny, maxx, maxy values of geometry objects

boxplot
(column=None, by=None, ax=None, fontsize=None, rot=0, grid=True, figsize=None, layout=None, return_type=None, backend=None, **kwargs)¶ Make a box plot from DataFrame columns.
Make a boxandwhisker plot from DataFrame columns, optionally grouped by some other columns. A box plot is a method for graphically depicting groups of numerical data through their quartiles. The box extends from the Q1 to Q3 quartile values of the data, with a line at the median (Q2). The whiskers extend from the edges of box to show the range of the data. By default, they extend no more than 1.5 * IQR (IQR = Q3  Q1) from the edges of the box, ending at the farthest data point within that interval. Outliers are plotted as separate dots.
For further details see Wikipedia’s entry for boxplot.
 columnstr or list of str, optional
Column name or list of names, or vector. Can be any valid input to
pandas.DataFrame.groupby()
. bystr or arraylike, optional
Column in the DataFrame to
pandas.DataFrame.groupby()
. One boxplot will be done per value of columns in by. axobject of class matplotlib.axes.Axes, optional
The matplotlib axes to be used by boxplot.
 fontsizefloat or str
Tick label font size in points or as a string (e.g., large).
 rotint or float, default 0
The rotation angle of labels (in degrees) with respect to the screen coordinate system.
 gridbool, default True
Setting this to True will show the grid.
 figsizeA tuple (width, height) in inches
The size of the figure to create in matplotlib.
 layouttuple (rows, columns), optional
For example, (3, 5) will display the subplots using 3 columns and 5 rows, starting from the topleft.
 return_type{‘axes’, ‘dict’, ‘both’} or None, default ‘axes’
The kind of object to return. The default is
axes
.‘axes’ returns the matplotlib axes the boxplot is drawn on.
‘dict’ returns a dictionary whose values are the matplotlib Lines of the boxplot.
‘both’ returns a namedtuple with the axes and dict.
when grouping with
by
, a Series mapping columns toreturn_type
is returned.If
return_type
is None, a NumPy array of axes with the same shape aslayout
is returned.
 backendstr, default None
Backend to use instead of the backend specified in the option
plotting.backend
. For instance, ‘matplotlib’. Alternatively, to specify theplotting.backend
for the whole session, setpd.options.plotting.backend
.New in version 1.0.0.
 **kwargs
All other plotting keyword arguments to be passed to
matplotlib.pyplot.boxplot()
.
 result
See Notes.
Series.plot.hist: Make a histogram. matplotlib.pyplot.boxplot : Matplotlib equivalent plot.
The return type depends on the return_type parameter:
‘axes’ : object of class matplotlib.axes.Axes
‘dict’ : dict of matplotlib.lines.Line2D objects
‘both’ : a namedtuple with structure (ax, lines)
For data grouped with
by
, return a Series of the above or a numpy array:Series
array
(forreturn_type = None
)
Use
return_type='dict'
when you want to tweak the appearance of the lines after plotting. In this case a dict containing the Lines making up the boxes, caps, fliers, medians, and whiskers is returned.Boxplots can be created for every column in the dataframe by
df.boxplot()
or indicating the columns to be used:Boxplots of variables distributions grouped by the values of a third variable can be created using the option
by
. For instance:A list of strings (i.e.
['X', 'Y']
) can be passed to boxplot in order to group the data by combination of the variables in the xaxis:The layout of boxplot can be adjusted giving a tuple to
layout
:Additional formatting can be done to the boxplot, like suppressing the grid (
grid=False
), rotating the labels in the xaxis (i.e.rot=45
) or changing the fontsize (i.e.fontsize=15
):The parameter
return_type
can be used to select the type of element returned by boxplot. Whenreturn_type='axes'
is selected, the matplotlib axes on which the boxplot is drawn are returned:>>> boxplot = df.boxplot(column=['Col1', 'Col2'], return_type='axes') >>> type(boxplot) <class 'matplotlib.axes._subplots.AxesSubplot'>
When grouping with
by
, a Series mapping columns toreturn_type
is returned:>>> boxplot = df.boxplot(column=['Col1', 'Col2'], by='X', ... return_type='axes') >>> type(boxplot) <class 'pandas.core.series.Series'>
If
return_type
is None, a NumPy array of axes with the same shape aslayout
is returned:>>> boxplot = df.boxplot(column=['Col1', 'Col2'], by='X', ... return_type=None) >>> type(boxplot) <class 'numpy.ndarray'>

buffer
(distance)¶ Constructs a polygon at a specified distance from the geometry.
 Parameters:
 distance
length in current projection. Only polygon accept
negative values.

property
centroid
¶ The true centroid if it is within or on the feature; otherwise, the label point is returned. Returns a point object.

clip
(envelope)¶ Constructs the intersection of the geometry and the specified extent.
 Parameters:
 envelope
arcpy.Extent object

columns
¶ The column labels of the DataFrame.

combine
(other: pandas.core.frame.DataFrame, func, fill_value=None, overwrite=True) → pandas.core.frame.DataFrame¶ Perform columnwise combine with another DataFrame.
Combines a DataFrame with other DataFrame using func to elementwise combine columns. The row and column indexes of the resulting DataFrame will be the union of the two.
 otherDataFrame
The DataFrame to merge columnwise.
 funcfunction
Function that takes two series as inputs and return a Series or a scalar. Used to merge the two dataframes column by columns.
 fill_valuescalar value, default None
The value to fill NaNs with prior to passing any column to the merge func.
 overwritebool, default True
If True, columns in self that do not exist in other will be overwritten with NaNs.
 DataFrame
Combination of the provided DataFrames.
 DataFrame.combine_firstCombine two DataFrame objects and default to
nonnull values in frame calling the method.
Combine using a simple function that chooses the smaller column.
>>> df1 = pd.DataFrame({'A': [0, 0], 'B': [4, 4]}) >>> df2 = pd.DataFrame({'A': [1, 1], 'B': [3, 3]}) >>> take_smaller = lambda s1, s2: s1 if s1.sum() < s2.sum() else s2 >>> df1.combine(df2, take_smaller) A B 0 0 3 1 0 3
Example using a true elementwise combine function.
>>> df1 = pd.DataFrame({'A': [5, 0], 'B': [2, 4]}) >>> df2 = pd.DataFrame({'A': [1, 1], 'B': [3, 3]}) >>> df1.combine(df2, np.minimum) A B 0 1 2 1 0 3
Using fill_value fills Nones prior to passing the column to the merge function.
>>> df1 = pd.DataFrame({'A': [0, 0], 'B': [None, 4]}) >>> df2 = pd.DataFrame({'A': [1, 1], 'B': [3, 3]}) >>> df1.combine(df2, take_smaller, fill_value=5) A B 0 0 5.0 1 0 4.0
However, if the same element in both dataframes is None, that None is preserved
>>> df1 = pd.DataFrame({'A': [0, 0], 'B': [None, 4]}) >>> df2 = pd.DataFrame({'A': [1, 1], 'B': [None, 3]}) >>> df1.combine(df2, take_smaller, fill_value=5) A B 0 0 5.0 1 0 3.0
Example that demonstrates the use of overwrite and behavior when the axis differ between the dataframes.
>>> df1 = pd.DataFrame({'A': [0, 0], 'B': [4, 4]}) >>> df2 = pd.DataFrame({'B': [3, 3], 'C': [10, 1], }, index=[1, 2]) >>> df1.combine(df2, take_smaller) A B C 0 NaN NaN NaN 1 NaN 3.0 10.0 2 NaN 3.0 1.0
>>> df1.combine(df2, take_smaller, overwrite=False) A B C 0 0.0 NaN NaN 1 0.0 3.0 10.0 2 NaN 3.0 1.0
Demonstrating the preference of the passed in dataframe.
>>> df2 = pd.DataFrame({'B': [3, 3], 'C': [1, 1], }, index=[1, 2]) >>> df2.combine(df1, take_smaller) A B C 0 0.0 NaN NaN 1 0.0 3.0 NaN 2 NaN 3.0 NaN
>>> df2.combine(df1, take_smaller, overwrite=False) A B C 0 0.0 NaN NaN 1 0.0 3.0 1.0 2 NaN 3.0 1.0

combine_first
(other: pandas.core.frame.DataFrame) → pandas.core.frame.DataFrame¶ Update null elements with value in the same location in other.
Combine two DataFrame objects by filling null values in one DataFrame with nonnull values from other DataFrame. The row and column indexes of the resulting DataFrame will be the union of the two.
 otherDataFrame
Provided DataFrame to use to fill null values.
DataFrame
 DataFrame.combinePerform serieswise operation on two DataFrames
using a given function.
>>> df1 = pd.DataFrame({'A': [None, 0], 'B': [None, 4]}) >>> df2 = pd.DataFrame({'A': [1, 1], 'B': [3, 3]}) >>> df1.combine_first(df2) A B 0 1.0 3.0 1 0.0 4.0
Null values still persist if the location of that null value does not exist in other
>>> df1 = pd.DataFrame({'A': [None, 0], 'B': [4, None]}) >>> df2 = pd.DataFrame({'B': [3, 3], 'C': [1, 1]}, index=[1, 2]) >>> df1.combine_first(df2) A B C 0 NaN 4.0 NaN 1 0.0 3.0 1.0 2 NaN 3.0 1.0

compare
(other: pandas.core.frame.DataFrame, align_axis: Union[str, int] = 1, keep_shape: bool = False, keep_equal: bool = False) → pandas.core.frame.DataFrame¶ Compare to another DataFrame and show the differences.
New in version 1.1.0.
 otherDataFrame
Object to compare with.
 align_axis{0 or ‘index’, 1 or ‘columns’}, default 1
Determine which axis to align the comparison on.
 0, or ‘index’Resulting differences are stacked vertically
with rows drawn alternately from self and other.
 1, or ‘columns’Resulting differences are aligned horizontally
with columns drawn alternately from self and other.
 keep_shapebool, default False
If true, all rows and columns are kept. Otherwise, only the ones with different values are kept.
 keep_equalbool, default False
If true, the result keeps values that are equal. Otherwise, equal values are shown as NaNs.
 DataFrame
DataFrame that shows the differences stacked side by side.
The resulting index will be a MultiIndex with ‘self’ and ‘other’ stacked alternately at the inner level.
Series.compare : Compare with another Series and show differences.
Matching NaNs will not appear as a difference.
>>> df = pd.DataFrame( ... { ... "col1": ["a", "a", "b", "b", "a"], ... "col2": [1.0, 2.0, 3.0, np.nan, 5.0], ... "col3": [1.0, 2.0, 3.0, 4.0, 5.0] ... }, ... columns=["col1", "col2", "col3"], ... ) >>> df col1 col2 col3 0 a 1.0 1.0 1 a 2.0 2.0 2 b 3.0 3.0 3 b NaN 4.0 4 a 5.0 5.0
>>> df2 = df.copy() >>> df2.loc[0, 'col1'] = 'c' >>> df2.loc[2, 'col3'] = 4.0 >>> df2 col1 col2 col3 0 c 1.0 1.0 1 a 2.0 2.0 2 b 3.0 4.0 3 b NaN 4.0 4 a 5.0 5.0
Align the differences on columns
>>> df.compare(df2) col1 col3 self other self other 0 a c NaN NaN 2 NaN NaN 3.0 4.0
Stack the differences on rows
>>> df.compare(df2, align_axis=0) col1 col3 0 self a NaN other c NaN 2 self NaN 3.0 other NaN 4.0
Keep the equal values
>>> df.compare(df2, keep_equal=True) col1 col3 self other self other 0 a c 1.0 1.0 2 b b 3.0 4.0
Keep all original rows and columns
>>> df.compare(df2, keep_shape=True) col1 col2 col3 self other self other self other 0 a c NaN NaN NaN NaN 1 NaN NaN NaN NaN NaN NaN 2 NaN NaN NaN NaN 3.0 4.0 3 NaN NaN NaN NaN NaN NaN 4 NaN NaN NaN NaN NaN NaN
Keep all original rows and columns and also all original values
>>> df.compare(df2, keep_shape=True, keep_equal=True) col1 col2 col3 self other self other self other 0 a c 1.0 1.0 1.0 1.0 1 a a 2.0 2.0 2.0 2.0 2 b b 3.0 3.0 3.0 4.0 3 b b NaN NaN 4.0 4.0 4 a a 5.0 5.0 5.0 5.0

contains
(second_geometry, relation=None)¶ Indicates if the base geometry contains the comparison geometry.
 Paramters:
 second_geometry
a second geometry

convert_dtypes
(infer_objects: bool = True, convert_string: bool = True, convert_integer: bool = True, convert_boolean: bool = True) → FrameOrSeries¶ Convert columns to best possible dtypes using dtypes supporting
pd.NA
.New in version 1.0.0.
 infer_objectsbool, default True
Whether object dtypes should be converted to the best possible types.
 convert_stringbool, default True
Whether object dtypes should be converted to
StringDtype()
. convert_integerbool, default True
Whether, if possible, conversion can be done to integer extension types.
 convert_booleanbool, defaults True
Whether object dtypes should be converted to
BooleanDtypes()
.
 Series or DataFrame
Copy of input object with new dtype.
infer_objects : Infer dtypes of objects. to_datetime : Convert argument to datetime. to_timedelta : Convert argument to timedelta. to_numeric : Convert argument to a numeric type.
By default,
convert_dtypes
will attempt to convert a Series (or each Series in a DataFrame) to dtypes that supportpd.NA
. By using the optionsconvert_string
,convert_integer
, andconvert_boolean
, it is possible to turn off individual conversions toStringDtype
, the integer extension types orBooleanDtype
, respectively.For objectdtyped columns, if
infer_objects
isTrue
, use the inference rules as during normal Series/DataFrame construction. Then, if possible, convert toStringDtype
,BooleanDtype
or an appropriate integer extension type, otherwise leave asobject
.If the dtype is integer, convert to an appropriate integer extension type.
If the dtype is numeric, and consists of all integers, convert to an appropriate integer extension type.
In the future, as new dtypes are added that support
pd.NA
, the results of this method will change to support those new dtypes.>>> df = pd.DataFrame( ... { ... "a": pd.Series([1, 2, 3], dtype=np.dtype("int32")), ... "b": pd.Series(["x", "y", "z"], dtype=np.dtype("O")), ... "c": pd.Series([True, False, np.nan], dtype=np.dtype("O")), ... "d": pd.Series(["h", "i", np.nan], dtype=np.dtype("O")), ... "e": pd.Series([10, np.nan, 20], dtype=np.dtype("float")), ... "f": pd.Series([np.nan, 100.5, 200], dtype=np.dtype("float")), ... } ... )
Start with a DataFrame with default dtypes.
>>> df a b c d e f 0 1 x True h 10.0 NaN 1 2 y False i NaN 100.5 2 3 z NaN NaN 20.0 200.0
>>> df.dtypes a int32 b object c object d object e float64 f float64 dtype: object
Convert the DataFrame to use best possible dtypes.
>>> dfn = df.convert_dtypes() >>> dfn a b c d e f 0 1 x True h 10 NaN 1 2 y False i <NA> 100.5 2 3 z <NA> <NA> 20 200.0
>>> dfn.dtypes a Int32 b string c boolean d string e Int64 f float64 dtype: object
Start with a Series of strings and missing data represented by
np.nan
.>>> s = pd.Series(["a", "b", np.nan]) >>> s 0 a 1 b 2 NaN dtype: object
Obtain a Series with dtype
StringDtype
.>>> s.convert_dtypes() 0 a 1 b 2 <NA> dtype: string

convex_hull
()¶ Constructs the geometry that is the minimal bounding polygon such that all outer angles are convex.

coordinates
()¶ returns the point coordinates of the geometry as a np.array object

copy
(deep=True)¶ Make a copy of this SpatialDataFrame object Parameters:
 Deep
boolean, default True Make a deep copy, i.e. also copy data
 Returns:
 copy
of SpatialDataFrame

corr
(method='pearson', min_periods=1) → pandas.core.frame.DataFrame¶ Compute pairwise correlation of columns, excluding NA/null values.
 method{‘pearson’, ‘kendall’, ‘spearman’} or callable
Method of correlation:
pearson : standard correlation coefficient
kendall : Kendall Tau correlation coefficient
spearman : Spearman rank correlation
 callable: callable with input two 1d ndarrays
and returning a float. Note that the returned matrix from corr will have 1 along the diagonals and will be symmetric regardless of the callable’s behavior.
New in version 0.24.0.
 min_periodsint, optional
Minimum number of observations required per pair of columns to have a valid result. Currently only available for Pearson and Spearman correlation.
 DataFrame
Correlation matrix.
 DataFrame.corrwithCompute pairwise correlation with another
DataFrame or Series.
Series.corr : Compute the correlation between two Series.
>>> def histogram_intersection(a, b): ... v = np.minimum(a, b).sum().round(decimals=1) ... return v >>> df = pd.DataFrame([(.2, .3), (.0, .6), (.6, .0), (.2, .1)], ... columns=['dogs', 'cats']) >>> df.corr(method=histogram_intersection) dogs cats dogs 1.0 0.3 cats 0.3 1.0

corrwith
(other, axis=0, drop=False, method='pearson') → pandas.core.series.Series¶ Compute pairwise correlation.
Pairwise correlation is computed between rows or columns of DataFrame with rows or columns of Series or DataFrame. DataFrames are first aligned along both axes before computing the correlations.
 otherDataFrame, Series
Object with which to compute correlations.
 axis{0 or ‘index’, 1 or ‘columns’}, default 0
The axis to use. 0 or ‘index’ to compute columnwise, 1 or ‘columns’ for rowwise.
 dropbool, default False
Drop missing indices from result.
 method{‘pearson’, ‘kendall’, ‘spearman’} or callable
Method of correlation:
pearson : standard correlation coefficient
kendall : Kendall Tau correlation coefficient
spearman : Spearman rank correlation
 callable: callable with input two 1d ndarrays
and returning a float.
New in version 0.24.0.
 Series
Pairwise correlations.
DataFrame.corr : Compute pairwise correlation of columns.

count
(axis=0, level=None, numeric_only=False)¶ Count nonNA cells for each column or row.
The values None, NaN, NaT, and optionally numpy.inf (depending on pandas.options.mode.use_inf_as_na) are considered NA.
 axis{0 or ‘index’, 1 or ‘columns’}, default 0
If 0 or ‘index’ counts are generated for each column. If 1 or ‘columns’ counts are generated for each row.
 levelint or str, optional
If the axis is a MultiIndex (hierarchical), count along a particular level, collapsing into a DataFrame. A str specifies the level name.
 numeric_onlybool, default False
Include only float, int or boolean data.
 Series or DataFrame
For each column/row the number of nonNA/null entries. If level is specified returns a DataFrame.
Series.count: Number of nonNA elements in a Series. DataFrame.shape: Number of DataFrame rows and columns (including NA
elements).
 DataFrame.isna: Boolean samesized DataFrame showing places of NA
elements.
Constructing DataFrame from a dictionary:
>>> df = pd.DataFrame({"Person": ... ["John", "Myla", "Lewis", "John", "Myla"], ... "Age": [24., np.nan, 21., 33, 26], ... "Single": [False, True, True, True, False]}) >>> df Person Age Single 0 John 24.0 False 1 Myla NaN True 2 Lewis 21.0 True 3 John 33.0 True 4 Myla 26.0 False
Notice the uncounted NA values:
>>> df.count() Person 5 Age 4 Single 5 dtype: int64
Counts for each row:
>>> df.count(axis='columns') 0 3 1 2 2 3 3 3 4 3 dtype: int64
Counts for one level of a MultiIndex:
>>> df.set_index(["Person", "Single"]).count(level="Person") Age Person John 2 Lewis 1 Myla 1

cov
(min_periods: Optional[int] = None, ddof: Optional[int] = 1) → pandas.core.frame.DataFrame¶ Compute pairwise covariance of columns, excluding NA/null values.
Compute the pairwise covariance among the series of a DataFrame. The returned data frame is the covariance matrix of the columns of the DataFrame.
Both NA and null values are automatically excluded from the calculation. (See the note below about bias from missing values.) A threshold can be set for the minimum number of observations for each value created. Comparisons with observations below this threshold will be returned as
NaN
.This method is generally used for the analysis of time series data to understand the relationship between different measures across time.
 min_periodsint, optional
Minimum number of observations required per pair of columns to have a valid result.
 ddofint, default 1
Delta degrees of freedom. The divisor used in calculations is
N  ddof
, whereN
represents the number of elements.New in version 1.1.0.
 DataFrame
The covariance matrix of the series of the DataFrame.
Series.cov : Compute covariance with another Series. core.window.ExponentialMovingWindow.cov: Exponential weighted sample covariance. core.window.Expanding.cov : Expanding sample covariance. core.window.Rolling.cov : Rolling sample covariance.
Returns the covariance matrix of the DataFrame’s time series. The covariance is normalized by Nddof.
For DataFrames that have Series that are missing data (assuming that data is missing at random) the returned covariance matrix will be an unbiased estimate of the variance and covariance between the member Series.
However, for many applications this estimate may not be acceptable because the estimate covariance matrix is not guaranteed to be positive semidefinite. This could lead to estimate correlations having absolute values which are greater than one, and/or a noninvertible covariance matrix. See Estimation of covariance matrices for more details.
>>> df = pd.DataFrame([(1, 2), (0, 3), (2, 0), (1, 1)], ... columns=['dogs', 'cats']) >>> df.cov() dogs cats dogs 0.666667 1.000000 cats 1.000000 1.666667
>>> np.random.seed(42) >>> df = pd.DataFrame(np.random.randn(1000, 5), ... columns=['a', 'b', 'c', 'd', 'e']) >>> df.cov() a b c d e a 0.998438 0.020161 0.059277 0.008943 0.014144 b 0.020161 1.059352 0.008543 0.024738 0.009826 c 0.059277 0.008543 1.010670 0.001486 0.000271 d 0.008943 0.024738 0.001486 0.921297 0.013692 e 0.014144 0.009826 0.000271 0.013692 0.977795
Minimum number of periods
This method also supports an optional
min_periods
keyword that specifies the required minimum number of nonNA observations for each column pair in order to have a valid result:>>> np.random.seed(42) >>> df = pd.DataFrame(np.random.randn(20, 3), ... columns=['a', 'b', 'c']) >>> df.loc[df.index[:5], 'a'] = np.nan >>> df.loc[df.index[5:10], 'b'] = np.nan >>> df.cov(min_periods=12) a b c a 0.316741 NaN 0.150812 b NaN 1.248003 0.191417 c 0.150812 0.191417 0.895202

crosses
(second_geometry)¶ Indicates if the two geometries intersect in a geometry of a lesser shape type.
 Paramters:
 second_geometry
a second geometry

cummax
(axis=None, skipna=True, *args, **kwargs)¶ Return cumulative maximum over a DataFrame or Series axis.
Returns a DataFrame or Series of the same size containing the cumulative maximum.
 axis{0 or ‘index’, 1 or ‘columns’}, default 0
The index or the name of the axis. 0 is equivalent to None or ‘index’.
 skipnabool, default True
Exclude NA/null values. If an entire row/column is NA, the result will be NA.
 *args, **kwargs
Additional keywords have no effect but might be accepted for compatibility with NumPy.
 Series or DataFrame
Return cumulative maximum of Series or DataFrame.
 core.window.Expanding.maxSimilar functionality
but ignores
NaN
values. DataFrame.maxReturn the maximum over
DataFrame axis.
DataFrame.cummax : Return cumulative maximum over DataFrame axis. DataFrame.cummin : Return cumulative minimum over DataFrame axis. DataFrame.cumsum : Return cumulative sum over DataFrame axis. DataFrame.cumprod : Return cumulative product over DataFrame axis.
Series
>>> s = pd.Series([2, np.nan, 5, 1, 0]) >>> s 0 2.0 1 NaN 2 5.0 3 1.0 4 0.0 dtype: float64
By default, NA values are ignored.
>>> s.cummax() 0 2.0 1 NaN 2 5.0 3 5.0 4 5.0 dtype: float64
To include NA values in the operation, use
skipna=False
>>> s.cummax(skipna=False) 0 2.0 1 NaN 2 NaN 3 NaN 4 NaN dtype: float64
DataFrame
>>> df = pd.DataFrame([[2.0, 1.0], ... [3.0, np.nan], ... [1.0, 0.0]], ... columns=list('AB')) >>> df A B 0 2.0 1.0 1 3.0 NaN 2 1.0 0.0
By default, iterates over rows and finds the maximum in each column. This is equivalent to
axis=None
oraxis='index'
.>>> df.cummax() A B 0 2.0 1.0 1 3.0 NaN 2 3.0 1.0
To iterate over columns and find the maximum in each row, use
axis=1
>>> df.cummax(axis=1) A B 0 2.0 2.0 1 3.0 NaN 2 1.0 1.0

cummin
(axis=None, skipna=True, *args, **kwargs)¶ Return cumulative minimum over a DataFrame or Series axis.
Returns a DataFrame or Series of the same size containing the cumulative minimum.
 axis{0 or ‘index’, 1 or ‘columns’}, default 0
The index or the name of the axis. 0 is equivalent to None or ‘index’.
 skipnabool, default True
Exclude NA/null values. If an entire row/column is NA, the result will be NA.
 *args, **kwargs
Additional keywords have no effect but might be accepted for compatibility with NumPy.
 Series or DataFrame
Return cumulative minimum of Series or DataFrame.
 core.window.Expanding.minSimilar functionality
but ignores
NaN
values. DataFrame.minReturn the minimum over
DataFrame axis.
DataFrame.cummax : Return cumulative maximum over DataFrame axis. DataFrame.cummin : Return cumulative minimum over DataFrame axis. DataFrame.cumsum : Return cumulative sum over DataFrame axis. DataFrame.cumprod : Return cumulative product over DataFrame axis.
Series
>>> s = pd.Series([2, np.nan, 5, 1, 0]) >>> s 0 2.0 1 NaN 2 5.0 3 1.0 4 0.0 dtype: float64
By default, NA values are ignored.
>>> s.cummin() 0 2.0 1 NaN 2 2.0 3 1.0 4 1.0 dtype: float64
To include NA values in the operation, use
skipna=False
>>> s.cummin(skipna=False) 0 2.0 1 NaN 2 NaN 3 NaN 4 NaN dtype: float64
DataFrame
>>> df = pd.DataFrame([[2.0, 1.0], ... [3.0, np.nan], ... [1.0, 0.0]], ... columns=list('AB')) >>> df A B 0 2.0 1.0 1 3.0 NaN 2 1.0 0.0
By default, iterates over rows and finds the minimum in each column. This is equivalent to
axis=None
oraxis='index'
.>>> df.cummin() A B 0 2.0 1.0 1 2.0 NaN 2 1.0 0.0
To iterate over columns and find the minimum in each row, use
axis=1
>>> df.cummin(axis=1) A B 0 2.0 1.0 1 3.0 NaN 2 1.0 0.0

cumprod
(axis=None, skipna=True, *args, **kwargs)¶ Return cumulative product over a DataFrame or Series axis.
Returns a DataFrame or Series of the same size containing the cumulative product.
 axis{0 or ‘index’, 1 or ‘columns’}, default 0
The index or the name of the axis. 0 is equivalent to None or ‘index’.
 skipnabool, default True
Exclude NA/null values. If an entire row/column is NA, the result will be NA.
 *args, **kwargs
Additional keywords have no effect but might be accepted for compatibility with NumPy.
 Series or DataFrame
Return cumulative product of Series or DataFrame.
 core.window.Expanding.prodSimilar functionality
but ignores
NaN
values. DataFrame.prodReturn the product over
DataFrame axis.
DataFrame.cummax : Return cumulative maximum over DataFrame axis. DataFrame.cummin : Return cumulative minimum over DataFrame axis. DataFrame.cumsum : Return cumulative sum over DataFrame axis. DataFrame.cumprod : Return cumulative product over DataFrame axis.
Series
>>> s = pd.Series([2, np.nan, 5, 1, 0]) >>> s 0 2.0 1 NaN 2 5.0 3 1.0 4 0.0 dtype: float64
By default, NA values are ignored.
>>> s.cumprod() 0 2.0 1 NaN 2 10.0 3 10.0 4 0.0 dtype: float64
To include NA values in the operation, use
skipna=False
>>> s.cumprod(skipna=False) 0 2.0 1 NaN 2 NaN 3 NaN 4 NaN dtype: float64
DataFrame
>>> df = pd.DataFrame([[2.0, 1.0], ... [3.0, np.nan], ... [1.0, 0.0]], ... columns=list('AB')) >>> df A B 0 2.0 1.0 1 3.0 NaN 2 1.0 0.0
By default, iterates over rows and finds the product in each column. This is equivalent to
axis=None
oraxis='index'
.>>> df.cumprod() A B 0 2.0 1.0 1 6.0 NaN 2 6.0 0.0
To iterate over columns and find the product in each row, use
axis=1
>>> df.cumprod(axis=1) A B 0 2.0 2.0 1 3.0 NaN 2 1.0 0.0

cumsum
(axis=None, skipna=True, *args, **kwargs)¶ Return cumulative sum over a DataFrame or Series axis.
Returns a DataFrame or Series of the same size containing the cumulative sum.
 axis{0 or ‘index’, 1 or ‘columns’}, default 0
The index or the name of the axis. 0 is equivalent to None or ‘index’.
 skipnabool, default True
Exclude NA/null values. If an entire row/column is NA, the result will be NA.
 *args, **kwargs
Additional keywords have no effect but might be accepted for compatibility with NumPy.
 Series or DataFrame
Return cumulative sum of Series or DataFrame.
 core.window.Expanding.sumSimilar functionality
but ignores
NaN
values. DataFrame.sumReturn the sum over
DataFrame axis.
DataFrame.cummax : Return cumulative maximum over DataFrame axis. DataFrame.cummin : Return cumulative minimum over DataFrame axis. DataFrame.cumsum : Return cumulative sum over DataFrame axis. DataFrame.cumprod : Return cumulative product over DataFrame axis.
Series
>>> s = pd.Series([2, np.nan, 5, 1, 0]) >>> s 0 2.0 1 NaN 2 5.0 3 1.0 4 0.0 dtype: float64
By default, NA values are ignored.
>>> s.cumsum() 0 2.0 1 NaN 2 7.0 3 6.0 4 6.0 dtype: float64
To include NA values in the operation, use
skipna=False
>>> s.cumsum(skipna=False) 0 2.0 1 NaN 2 NaN 3 NaN 4 NaN dtype: float64
DataFrame
>>> df = pd.DataFrame([[2.0, 1.0], ... [3.0, np.nan], ... [1.0, 0.0]], ... columns=list('AB')) >>> df A B 0 2.0 1.0 1 3.0 NaN 2 1.0 0.0
By default, iterates over rows and finds the sum in each column. This is equivalent to
axis=None
oraxis='index'
.>>> df.cumsum() A B 0 2.0 1.0 1 5.0 NaN 2 6.0 1.0
To iterate over columns and find the sum in each row, use
axis=1
>>> df.cumsum(axis=1) A B 0 2.0 3.0 1 3.0 NaN 2 1.0 1.0

cut
(cutter)¶ Splits this geometry into a part left of the cutting polyline, and a part right of it.
 Parameters:
 cutter
The cutting polyline geometry.

densify
(method, distance, deviation)¶ Creates a new geometry with added vertices
 Parameters:
 method
The type of densification, DISTANCE, ANGLE, or GEODESIC
 distance
The maximum distance between vertices. The actual
distance between vertices will usually be less than the maximum distance as new vertices will be evenly distributed along the original segment. If using a type of DISTANCE or ANGLE, the distance is measured in the units of the geometry’s spatial reference. If using a type of GEODESIC, the distance is measured in meters.
 deviation
Densify uses straight lines to approximate curves.
You use deviation to control the accuracy of this approximation. The deviation is the maximum distance between the new segment and the original curve. The smaller its value, the more segments will be required to approximate the curve.

describe
(percentiles=None, include=None, exclude=None, datetime_is_numeric=False) → FrameOrSeries¶ Generate descriptive statistics.
Descriptive statistics include those that summarize the central tendency, dispersion and shape of a dataset’s distribution, excluding
NaN
values.Analyzes both numeric and object series, as well as
DataFrame
column sets of mixed data types. The output will vary depending on what is provided. Refer to the notes below for more detail. percentileslistlike of numbers, optional
The percentiles to include in the output. All should fall between 0 and 1. The default is
[.25, .5, .75]
, which returns the 25th, 50th, and 75th percentiles. include‘all’, listlike of dtypes or None (default), optional
A white list of data types to include in the result. Ignored for
Series
. Here are the options:‘all’ : All columns of the input will be included in the output.
A listlike of dtypes : Limits the results to the provided data types. To limit the result to numeric types submit
numpy.number
. To limit it instead to object columns submit thenumpy.object
data type. Strings can also be used in the style ofselect_dtypes
(e.g.df.describe(include=['O'])
). To select pandas categorical columns, use'category'
None (default) : The result will include all numeric columns.
 excludelistlike of dtypes or None (default), optional,
A black list of data types to omit from the result. Ignored for
Series
. Here are the options:A listlike of dtypes : Excludes the provided data types from the result. To exclude numeric types submit
numpy.number
. To exclude object columns submit the data typenumpy.object
. Strings can also be used in the style ofselect_dtypes
(e.g.df.describe(include=['O'])
). To exclude pandas categorical columns, use'category'
None (default) : The result will exclude nothing.
 datetime_is_numericbool, default False
Whether to treat datetime dtypes as numeric. This affects statistics calculated for the column. For DataFrame input, this also controls whether datetime columns are included by default.
New in version 1.1.0.
 Series or DataFrame
Summary statistics of the Series or Dataframe provided.
DataFrame.count: Count number of nonNA/null observations. DataFrame.max: Maximum of the values in the object. DataFrame.min: Minimum of the values in the object. DataFrame.mean: Mean of the values. DataFrame.std: Standard deviation of the observations. DataFrame.select_dtypes: Subset of a DataFrame including/excluding
columns based on their dtype.
For numeric data, the result’s index will include
count
,mean
,std
,min
,max
as well as lower,50
and upper percentiles. By default the lower percentile is25
and the upper percentile is75
. The50
percentile is the same as the median.For object data (e.g. strings or timestamps), the result’s index will include
count
,unique
,top
, andfreq
. Thetop
is the most common value. Thefreq
is the most common value’s frequency. Timestamps also include thefirst
andlast
items.If multiple object values have the highest count, then the
count
andtop
results will be arbitrarily chosen from among those with the highest count.For mixed data types provided via a
DataFrame
, the default is to return only an analysis of numeric columns. If the dataframe consists only of object and categorical data without any numeric columns, the default is to return an analysis of both the object and categorical columns. Ifinclude='all'
is provided as an option, the result will include a union of attributes of each type.The include and exclude parameters can be used to limit which columns in a
DataFrame
are analyzed for the output. The parameters are ignored when analyzing aSeries
.Describing a numeric
Series
.>>> s = pd.Series([1, 2, 3]) >>> s.describe() count 3.0 mean 2.0 std 1.0 min 1.0 25% 1.5 50% 2.0 75% 2.5 max 3.0 dtype: float64
Describing a categorical
Series
.>>> s = pd.Series(['a', 'a', 'b', 'c']) >>> s.describe() count 4 unique 3 top a freq 2 dtype: object
Describing a timestamp
Series
.>>> s = pd.Series([ ... np.datetime64("20000101"), ... np.datetime64("20100101"), ... np.datetime64("20100101") ... ]) >>> s.describe(datetime_is_numeric=True) count 3 mean 20060901 08:00:00 min 20000101 00:00:00 25% 20041231 12:00:00 50% 20100101 00:00:00 75% 20100101 00:00:00 max 20100101 00:00:00 dtype: object
Describing a
DataFrame
. By default only numeric fields are returned.>>> df = pd.DataFrame({'categorical': pd.Categorical(['d','e','f']), ... 'numeric': [1, 2, 3], ... 'object': ['a', 'b', 'c'] ... }) >>> df.describe() numeric count 3.0 mean 2.0 std 1.0 min 1.0 25% 1.5 50% 2.0 75% 2.5 max 3.0
Describing all columns of a
DataFrame
regardless of data type.>>> df.describe(include='all') categorical numeric object count 3 3.0 3 unique 3 NaN 3 top f NaN a freq 1 NaN 1 mean NaN 2.0 NaN std NaN 1.0 NaN min NaN 1.0 NaN 25% NaN 1.5 NaN 50% NaN 2.0 NaN 75% NaN 2.5 NaN max NaN 3.0 NaN
Describing a column from a
DataFrame
by accessing it as an attribute.>>> df.numeric.describe() count 3.0 mean 2.0 std 1.0 min 1.0 25% 1.5 50% 2.0 75% 2.5 max 3.0 Name: numeric, dtype: float64
Including only numeric columns in a
DataFrame
description.>>> df.describe(include=[np.number]) numeric count 3.0 mean 2.0 std 1.0 min 1.0 25% 1.5 50% 2.0 75% 2.5 max 3.0
Including only string columns in a
DataFrame
description.>>> df.describe(include=[object]) object count 3 unique 3 top a freq 1
Including only categorical columns from a
DataFrame
description.>>> df.describe(include=['category']) categorical count 3 unique 3 top f freq 1
Excluding numeric columns from a
DataFrame
description.>>> df.describe(exclude=[np.number]) categorical object count 3 3 unique 3 3 top f a freq 1 1
Excluding object columns from a
DataFrame
description.>>> df.describe(exclude=[object]) categorical numeric count 3 3.0 unique 3 NaN top f NaN freq 1 NaN mean NaN 2.0 std NaN 1.0 min NaN 1.0 25% NaN 1.5 50% NaN 2.0 75% NaN 2.5 max NaN 3.0

diff
(periods: int = 1, axis: Union[str, int] = 0) → pandas.core.frame.DataFrame¶ First discrete difference of element.
Calculates the difference of a Dataframe element compared with another element in the Dataframe (default is element in previous row).
 periodsint, default 1
Periods to shift for calculating difference, accepts negative values.
 axis{0 or ‘index’, 1 or ‘columns’}, default 0
Take difference over rows (0) or columns (1).
 Dataframe
First differences of the Series.
Dataframe.pct_change: Percent change over given number of periods. Dataframe.shift: Shift index by desired number of periods with an
optional time freq.
Series.diff: First discrete difference of object.
For boolean dtypes, this uses
operator.xor()
rather thanoperator.sub()
. The result is calculated according to current dtype in Dataframe, however dtype of the result is always float64.Difference with previous row
>>> df = pd.DataFrame({'a': [1, 2, 3, 4, 5, 6], ... 'b': [1, 1, 2, 3, 5, 8], ... 'c': [1, 4, 9, 16, 25, 36]}) >>> df a b c 0 1 1 1 1 2 1 4 2 3 2 9 3 4 3 16 4 5 5 25 5 6 8 36
>>> df.diff() a b c 0 NaN NaN NaN 1 1.0 0.0 3.0 2 1.0 1.0 5.0 3 1.0 1.0 7.0 4 1.0 2.0 9.0 5 1.0 3.0 11.0
Difference with previous column
>>> df.diff(axis=1) a b c 0 NaN 0.0 0.0 1 NaN 1.0 3.0 2 NaN 1.0 7.0 3 NaN 1.0 13.0 4 NaN 0.0 20.0 5 NaN 2.0 28.0
Difference with 3rd previous row
>>> df.diff(periods=3) a b c 0 NaN NaN NaN 1 NaN NaN NaN 2 NaN NaN NaN 3 3.0 2.0 15.0 4 3.0 4.0 21.0 5 3.0 6.0 27.0
Difference with following row
>>> df.diff(periods=1) a b c 0 1.0 0.0 3.0 1 1.0 1.0 5.0 2 1.0 1.0 7.0 3 1.0 2.0 9.0 4 1.0 3.0 11.0 5 NaN NaN NaN
Overflow in input dtype
>>> df = pd.DataFrame({'a': [1, 0]}, dtype=np.uint8) >>> df.diff() a 0 NaN 1 255.0

difference
(second_geometry)¶ Constructs the geometry that is composed only of the region unique to the base geometry but not part of the other geometry. The following illustration shows the results when the red polygon is the source geometry.
 Paramters:
 second_geometry
a second geometry

disjoint
(second_geometry)¶ Indicates if the base and comparison geometries share no points in common.
 Paramters:
 second_geometry
a second geometry

distance_to
(second_geometry)¶ Returns the minimum distance between two geometries. If the geometries intersect, the minimum distance is 0. Both geometries must have the same projection.
 Paramters:
 second_geometry
a second geometry

div
(other, axis='columns', level=None, fill_value=None)¶ Get Floating division of dataframe and other, elementwise (binary operator truediv).
Equivalent to
dataframe / other
, but with support to substitute a fill_value for missing data in one of the inputs. With reverse version, rtruediv.Among flexible wrappers (add, sub, mul, div, mod, pow) to arithmetic operators: +, , *, /, //, %, **.
 otherscalar, sequence, Series, or DataFrame
Any single or multiple element data structure, or listlike object.
 axis{0 or ‘index’, 1 or ‘columns’}
Whether to compare by the index (0 or ‘index’) or columns (1 or ‘columns’). For Series input, axis to match Series index on.
 levelint or label
Broadcast across a level, matching Index values on the passed MultiIndex level.
 fill_valuefloat or None, default None
Fill existing missing (NaN) values, and any new element needed for successful DataFrame alignment, with this value before computation. If data in both corresponding DataFrame locations is missing the result will be missing.
 DataFrame
Result of the arithmetic operation.
DataFrame.add : Add DataFrames. DataFrame.sub : Subtract DataFrames. DataFrame.mul : Multiply DataFrames. DataFrame.div : Divide DataFrames (float division). DataFrame.truediv : Divide DataFrames (float division). DataFrame.floordiv : Divide DataFrames (integer division). DataFrame.mod : Calculate modulo (remainder after division). DataFrame.pow : Calculate exponential power.
Mismatched indices will be unioned together.
>>> df = pd.DataFrame({'angles': [0, 3, 4], ... 'degrees': [360, 180, 360]}, ... index=['circle', 'triangle', 'rectangle']) >>> df angles degrees circle 0 360 triangle 3 180 rectangle 4 360
Add a scalar with operator version which return the same results.
>>> df + 1 angles degrees circle 1 361 triangle 4 181 rectangle 5 361
>>> df.add(1) angles degrees circle 1 361 triangle 4 181 rectangle 5 361
Divide by constant with reverse version.
>>> df.div(10) angles degrees circle 0.0 36.0 triangle 0.3 18.0 rectangle 0.4 36.0
>>> df.rdiv(10) angles degrees circle inf 0.027778 triangle 3.333333 0.055556 rectangle 2.500000 0.027778
Subtract a list and Series by axis with operator version.
>>> df  [1, 2] angles degrees circle 1 358 triangle 2 178 rectangle 3 358
>>> df.sub([1, 2], axis='columns') angles degrees circle 1 358 triangle 2 178 rectangle 3 358
>>> df.sub(pd.Series([1, 1, 1], index=['circle', 'triangle', 'rectangle']), ... axis='index') angles degrees circle 1 359 triangle 2 179 rectangle 3 359
Multiply a DataFrame of different shape with operator version.
>>> other = pd.DataFrame({'angles': [0, 3, 4]}, ... index=['circle', 'triangle', 'rectangle']) >>> other angles circle 0 triangle 3 rectangle 4
>>> df * other angles degrees circle 0 NaN triangle 9 NaN rectangle 16 NaN
>>> df.mul(other, fill_value=0) angles degrees circle 0 0.0 triangle 9 0.0 rectangle 16 0.0
Divide by a MultiIndex by level.
>>> df_multindex = pd.DataFrame({'angles': [0, 3, 4, 4, 5, 6], ... 'degrees': [360, 180, 360, 360, 540, 720]}, ... index=[['A', 'A', 'A', 'B', 'B', 'B'], ... ['circle', 'triangle', 'rectangle', ... 'square', 'pentagon', 'hexagon']]) >>> df_multindex angles degrees A circle 0 360 triangle 3 180 rectangle 4 360 B square 4 360 pentagon 5 540 hexagon 6 720
>>> df.div(df_multindex, level=1, fill_value=0) angles degrees A circle NaN 1.0 triangle 1.0 1.0 rectangle 1.0 1.0 B square 0.0 0.0 pentagon 0.0 0.0 hexagon 0.0 0.0

divide
(other, axis='columns', level=None, fill_value=None)¶ Get Floating division of dataframe and other, elementwise (binary operator truediv).
Equivalent to
dataframe / other
, but with support to substitute a fill_value for missing data in one of the inputs. With reverse version, rtruediv.Among flexible wrappers (add, sub, mul, div, mod, pow) to arithmetic operators: +, , *, /, //, %, **.
 otherscalar, sequence, Series, or DataFrame
Any single or multiple element data structure, or listlike object.
 axis{0 or ‘index’, 1 or ‘columns’}
Whether to compare by the index (0 or ‘index’) or columns (1 or ‘columns’). For Series input, axis to match Series index on.
 levelint or label
Broadcast across a level, matching Index values on the passed MultiIndex level.
 fill_valuefloat or None, default None
Fill existing missing (NaN) values, and any new element needed for successful DataFrame alignment, with this value before computation. If data in both corresponding DataFrame locations is missing the result will be missing.
 DataFrame
Result of the arithmetic operation.
DataFrame.add : Add DataFrames. DataFrame.sub : Subtract DataFrames. DataFrame.mul : Multiply DataFrames. DataFrame.div : Divide DataFrames (float division). DataFrame.truediv : Divide DataFrames (float division). DataFrame.floordiv : Divide DataFrames (integer division). DataFrame.mod : Calculate modulo (remainder after division). DataFrame.pow : Calculate exponential power.
Mismatched indices will be unioned together.
>>> df = pd.DataFrame({'angles': [0, 3, 4], ... 'degrees': [360, 180, 360]}, ... index=['circle', 'triangle', 'rectangle']) >>> df angles degrees circle 0 360 triangle 3 180 rectangle 4 360
Add a scalar with operator version which return the same results.
>>> df + 1 angles degrees circle 1 361 triangle 4 181 rectangle 5 361
>>> df.add(1) angles degrees circle 1 361 triangle 4 181 rectangle 5 361
Divide by constant with reverse version.
>>> df.div(10) angles degrees circle 0.0 36.0 triangle 0.3 18.0 rectangle 0.4 36.0
>>> df.rdiv(10) angles degrees circle inf 0.027778 triangle 3.333333 0.055556 rectangle 2.500000 0.027778
Subtract a list and Series by axis with operator version.
>>> df  [1, 2] angles degrees circle 1 358 triangle 2 178 rectangle 3 358
>>> df.sub([1, 2], axis='columns') angles degrees circle 1 358 triangle 2 178 rectangle 3 358
>>> df.sub(pd.Series([1, 1, 1], index=['circle', 'triangle', 'rectangle']), ... axis='index') angles degrees circle 1 359 triangle 2 179 rectangle 3 359
Multiply a DataFrame of different shape with operator version.
>>> other = pd.DataFrame({'angles': [0, 3, 4]}, ... index=['circle', 'triangle', 'rectangle']) >>> other angles circle 0 triangle 3 rectangle 4
>>> df * other angles degrees circle 0 NaN triangle 9 NaN rectangle 16 NaN
>>> df.mul(other, fill_value=0) angles degrees circle 0 0.0 triangle 9 0.0 rectangle 16 0.0
Divide by a MultiIndex by level.
>>> df_multindex = pd.DataFrame({'angles': [0, 3, 4, 4, 5, 6], ... 'degrees': [360, 180, 360, 360, 540, 720]}, ... index=[['A', 'A', 'A', 'B', 'B', 'B'], ... ['circle', 'triangle', 'rectangle', ... 'square', 'pentagon', 'hexagon']]) >>> df_multindex angles degrees A circle 0 360 triangle 3 180 rectangle 4 360 B square 4 360 pentagon 5 540 hexagon 6 720
>>> df.div(df_multindex, level=1, fill_value=0) angles degrees A circle NaN 1.0 triangle 1.0 1.0 rectangle 1.0 1.0 B square 0.0 0.0 pentagon 0.0 0.0 hexagon 0.0 0.0

dot
(other)¶ Compute the matrix multiplication between the DataFrame and other.
This method computes the matrix product between the DataFrame and the values of an other Series, DataFrame or a numpy array.
It can also be called using
self @ other
in Python >= 3.5. otherSeries, DataFrame or arraylike
The other object to compute the matrix product with.
 Series or DataFrame
If other is a Series, return the matrix product between self and other as a Series. If other is a DataFrame or a numpy.array, return the matrix product of self and other in a DataFrame of a np.array.
Series.dot: Similar method for Series.
The dimensions of DataFrame and other must be compatible in order to compute the matrix multiplication. In addition, the column names of DataFrame and the index of other must contain the same values, as they will be aligned prior to the multiplication.
The dot method for Series computes the inner product, instead of the matrix product here.
Here we multiply a DataFrame with a Series.
>>> df = pd.DataFrame([[0, 1, 2, 1], [1, 1, 1, 1]]) >>> s = pd.Series([1, 1, 2, 1]) >>> df.dot(s) 0 4 1 5 dtype: int64
Here we multiply a DataFrame with another DataFrame.
>>> other = pd.DataFrame([[0, 1], [1, 2], [1, 1], [2, 0]]) >>> df.dot(other) 0 1 0 1 4 1 2 2
Note that the dot method give the same result as @
>>> df @ other 0 1 0 1 4 1 2 2
The dot method works also if other is an np.array.
>>> arr = np.array([[0, 1], [1, 2], [1, 1], [2, 0]]) >>> df.dot(arr) 0 1 0 1 4 1 2 2
Note how shuffling of the objects does not change the result.
>>> s2 = s.reindex([1, 0, 2, 3]) >>> df.dot(s2) 0 4 1 5 dtype: int64

drop
(labels=None, axis=0, index=None, columns=None, level=None, inplace=False, errors='raise')¶ Drop specified labels from rows or columns.
Remove rows or columns by specifying label names and corresponding axis, or by specifying directly index or column names. When using a multiindex, labels on different levels can be removed by specifying the level.
 labelssingle label or listlike
Index or column labels to drop.
 axis{0 or ‘index’, 1 or ‘columns’}, default 0
Whether to drop labels from the index (0 or ‘index’) or columns (1 or ‘columns’).
 indexsingle label or listlike
Alternative to specifying axis (
labels, axis=0
is equivalent toindex=labels
). columnssingle label or listlike
Alternative to specifying axis (
labels, axis=1
is equivalent tocolumns=labels
). levelint or level name, optional
For MultiIndex, level from which the labels will be removed.
 inplacebool, default False
If False, return a copy. Otherwise, do operation inplace and return None.
 errors{‘ignore’, ‘raise’}, default ‘raise’
If ‘ignore’, suppress error and only existing labels are dropped.
 DataFrame
DataFrame without the removed index or column labels.
 KeyError
If any of the labels is not found in the selected axis.
DataFrame.loc : Labellocation based indexer for selection by label. DataFrame.dropna : Return DataFrame with labels on given axis omitted
where (all or any) data are missing.
 DataFrame.drop_duplicatesReturn DataFrame with duplicate rows
removed, optionally only considering certain columns.
Series.drop : Return Series with specified index labels removed.
>>> df = pd.DataFrame(np.arange(12).reshape(3, 4), ... columns=['A', 'B', 'C', 'D']) >>> df A B C D 0 0 1 2 3 1 4 5 6 7 2 8 9 10 11
Drop columns
>>> df.drop(['B', 'C'], axis=1) A D 0 0 3 1 4 7 2 8 11
>>> df.drop(columns=['B', 'C']) A D 0 0 3 1 4 7 2 8 11
Drop a row by index
>>> df.drop([0, 1]) A B C D 2 8 9 10 11
Drop columns and/or rows of MultiIndex DataFrame
>>> midx = pd.MultiIndex(levels=[['lama', 'cow', 'falcon'], ... ['speed', 'weight', 'length']], ... codes=[[0, 0, 0, 1, 1, 1, 2, 2, 2], ... [0, 1, 2, 0, 1, 2, 0, 1, 2]]) >>> df = pd.DataFrame(index=midx, columns=['big', 'small'], ... data=[[45, 30], [200, 100], [1.5, 1], [30, 20], ... [250, 150], [1.5, 0.8], [320, 250], ... [1, 0.8], [0.3, 0.2]]) >>> df big small lama speed 45.0 30.0 weight 200.0 100.0 length 1.5 1.0 cow speed 30.0 20.0 weight 250.0 150.0 length 1.5 0.8 falcon speed 320.0 250.0 weight 1.0 0.8 length 0.3 0.2
>>> df.drop(index='cow', columns='small') big lama speed 45.0 weight 200.0 length 1.5 falcon speed 320.0 weight 1.0 length 0.3
>>> df.drop(index='length', level=1) big small lama speed 45.0 30.0 weight 200.0 100.0 cow speed 30.0 20.0 weight 250.0 150.0 falcon speed 320.0 250.0 weight 1.0 0.8

drop_duplicates
(subset: collections.abc.Hashable = None, keep: Union[str, bool] = 'first', inplace: bool = False, ignore_index: bool = False) → Optional[pandas.core.frame.DataFrame]¶ Return DataFrame with duplicate rows removed.
Considering certain columns is optional. Indexes, including time indexes are ignored.
 subsetcolumn label or sequence of labels, optional
Only consider certain columns for identifying duplicates, by default use all of the columns.
 keep{‘first’, ‘last’, False}, default ‘first’
Determines which duplicates (if any) to keep. 
first
: Drop duplicates except for the first occurrence. last
: Drop duplicates except for the last occurrence.  False : Drop all duplicates. inplacebool, default False
Whether to drop duplicates in place or to return a copy.
 ignore_indexbool, default False
If True, the resulting axis will be labeled 0, 1, …, n  1.
New in version 1.0.0.
 DataFrame
DataFrame with duplicates removed or None if
inplace=True
.
DataFrame.value_counts: Count unique combinations of columns.
Consider dataset containing ramen rating.
>>> df = pd.DataFrame({ ... 'brand': ['Yum Yum', 'Yum Yum', 'Indomie', 'Indomie', 'Indomie'], ... 'style': ['cup', 'cup', 'cup', 'pack', 'pack'], ... 'rating': [4, 4, 3.5, 15, 5] ... }) >>> df brand style rating 0 Yum Yum cup 4.0 1 Yum Yum cup 4.0 2 Indomie cup 3.5 3 Indomie pack 15.0 4 Indomie pack 5.0
By default, it removes duplicate rows based on all columns.
>>> df.drop_duplicates() brand style rating 0 Yum Yum cup 4.0 2 Indomie cup 3.5 3 Indomie pack 15.0 4 Indomie pack 5.0
To remove duplicates on specific column(s), use
subset
.>>> df.drop_duplicates(subset=['brand']) brand style rating 0 Yum Yum cup 4.0 2 Indomie cup 3.5
To remove duplicates and keep last occurences, use
keep
.>>> df.drop_duplicates(subset=['brand', 'style'], keep='last') brand style rating 1 Yum Yum cup 4.0 2 Indomie cup 3.5 4 Indomie pack 5.0

droplevel
(level, axis=0) → FrameOrSeries¶ Return DataFrame with requested index / column level(s) removed.
New in version 0.24.0.
 levelint, str, or listlike
If a string is given, must be the name of a level If listlike, elements must be names or positional indexes of levels.
 axis{0 or ‘index’, 1 or ‘columns’}, default 0
Axis along which the level(s) is removed:
0 or ‘index’: remove level(s) in column.
1 or ‘columns’: remove level(s) in row.
 DataFrame
DataFrame with requested index / column level(s) removed.
>>> df = pd.DataFrame([ ... [1, 2, 3, 4], ... [5, 6, 7, 8], ... [9, 10, 11, 12] ... ]).set_index([0, 1]).rename_axis(['a', 'b'])
>>> df.columns = pd.MultiIndex.from_tuples([ ... ('c', 'e'), ('d', 'f') ... ], names=['level_1', 'level_2'])
>>> df level_1 c d level_2 e f a b 1 2 3 4 5 6 7 8 9 10 11 12
>>> df.droplevel('a') level_1 c d level_2 e f b 2 3 4 6 7 8 10 11 12
>>> df.droplevel('level_2', axis=1) level_1 c d a b 1 2 3 4 5 6 7 8 9 10 11 12

dropna
(axis=0, how='any', thresh=None, subset=None, inplace=False)¶ Remove missing values.
See the User Guide for more on which values are considered missing, and how to work with missing data.
 axis{0 or ‘index’, 1 or ‘columns’}, default 0
Determine if rows or columns which contain missing values are removed.
0, or ‘index’ : Drop rows which contain missing values.
1, or ‘columns’ : Drop columns which contain missing value.
Changed in version 1.0.0: Pass tuple or list to drop on multiple axes. Only a single axis is allowed.
 how{‘any’, ‘all’}, default ‘any’
Determine if row or column is removed from DataFrame, when we have at least one NA or all NA.
‘any’ : If any NA values are present, drop that row or column.
‘all’ : If all values are NA, drop that row or column.
 threshint, optional
Require that many nonNA values.
 subsetarraylike, optional
Labels along other axis to consider, e.g. if you are dropping rows these would be a list of columns to include.
 inplacebool, default False
If True, do operation inplace and return None.
 DataFrame
DataFrame with NA entries dropped from it.
DataFrame.isna: Indicate missing values. DataFrame.notna : Indicate existing (nonmissing) values. DataFrame.fillna : Replace missing values. Series.dropna : Drop missing values. Index.dropna : Drop missing indices.
>>> df = pd.DataFrame({"name": ['Alfred', 'Batman', 'Catwoman'], ... "toy": [np.nan, 'Batmobile', 'Bullwhip'], ... "born": [pd.NaT, pd.Timestamp("19400425"), ... pd.NaT]}) >>> df name toy born 0 Alfred NaN NaT 1 Batman Batmobile 19400425 2 Catwoman Bullwhip NaT
Drop the rows where at least one element is missing.
>>> df.dropna() name toy born 1 Batman Batmobile 19400425
Drop the columns where at least one element is missing.
>>> df.dropna(axis='columns') name 0 Alfred 1 Batman 2 Catwoman
Drop the rows where all elements are missing.
>>> df.dropna(how='all') name toy born 0 Alfred NaN NaT 1 Batman Batmobile 19400425 2 Catwoman Bullwhip NaT
Keep only the rows with at least 2 nonNA values.
>>> df.dropna(thresh=2) name toy born 1 Batman Batmobile 19400425 2 Catwoman Bullwhip NaT
Define in which columns to look for missing values.
>>> df.dropna(subset=['name', 'born']) name toy born 1 Batman Batmobile 19400425
Keep the DataFrame with valid entries in the same variable.
>>> df.dropna(inplace=True) >>> df name toy born 1 Batman Batmobile 19400425

property
dtypes
¶ Return the dtypes in the DataFrame.
This returns a Series with the data type of each column. The result’s index is the original DataFrame’s columns. Columns with mixed types are stored with the
object
dtype. See the User Guide for more. pandas.Series
The data type of each column.
>>> df = pd.DataFrame({'float': [1.0], ... 'int': [1], ... 'datetime': [pd.Timestamp('20180310')], ... 'string': ['foo']}) >>> df.dtypes float float64 int int64 datetime datetime64[ns] string object dtype: object

duplicated
(subset: collections.abc.Hashable = None, keep: Union[str, bool] = 'first') → pandas.core.series.Series¶ Return boolean Series denoting duplicate rows.
Considering certain columns is optional.
 subsetcolumn label or sequence of labels, optional
Only consider certain columns for identifying duplicates, by default use all of the columns.
 keep{‘first’, ‘last’, False}, default ‘first’
Determines which duplicates (if any) to mark.
first
: Mark duplicates asTrue
except for the first occurrence.last
: Mark duplicates asTrue
except for the last occurrence.False : Mark all duplicates as
True
.
 Series
Boolean series for each duplicated rows.
Index.duplicated : Equivalent method on index. Series.duplicated : Equivalent method on Series. Series.drop_duplicates : Remove duplicate values from Series. DataFrame.drop_duplicates : Remove duplicate values from DataFrame.
Consider dataset containing ramen rating.
>>> df = pd.DataFrame({ ... 'brand': ['Yum Yum', 'Yum Yum', 'Indomie', 'Indomie', 'Indomie'], ... 'style': ['cup', 'cup', 'cup', 'pack', 'pack'], ... 'rating': [4, 4, 3.5, 15, 5] ... }) >>> df brand style rating 0 Yum Yum cup 4.0 1 Yum Yum cup 4.0 2 Indomie cup 3.5 3 Indomie pack 15.0 4 Indomie pack 5.0
By default, for each set of duplicated values, the first occurrence is set on False and all others on True.
>>> df.duplicated() 0 False 1 True 2 False 3 False 4 False dtype: bool
By using ‘last’, the last occurrence of each set of duplicated values is set on False and all others on True.
>>> df.duplicated(keep='last') 0 True 1 False 2 False 3 False 4 False dtype: bool
By setting
keep
on False, all duplicates are True.>>> df.duplicated(keep=False) 0 True 1 True 2 False 3 False 4 False dtype: bool
To find duplicates on specific column(s), use
subset
.>>> df.duplicated(subset=['brand']) 0 False 1 True 2 False 3 True 4 True dtype: bool

property
empty
¶ Indicator whether DataFrame is empty.
True if DataFrame is entirely empty (no items), meaning any of the axes are of length 0.
 bool
If DataFrame is empty, return True, if not return False.
Series.dropna : Return series without null values. DataFrame.dropna : Return DataFrame with labels on given axis omitted
where (all or any) data are missing.
If DataFrame contains only NaNs, it is still not considered empty. See the example below.
An example of an actual empty DataFrame. Notice the index is empty:
>>> df_empty = pd.DataFrame({'A' : []}) >>> df_empty Empty DataFrame Columns: [A] Index: [] >>> df_empty.empty True
If we only have NaNs in our DataFrame, it is not considered empty! We will need to drop the NaNs to make the DataFrame empty:
>>> df = pd.DataFrame({'A' : [np.nan]}) >>> df A 0 NaN >>> df.empty False >>> df.dropna().empty True

eq
(other, axis='columns', level=None)¶ Get Equal to of dataframe and other, elementwise (binary operator eq).
Among flexible wrappers (eq, ne, le, lt, ge, gt) to comparison operators.
Equivalent to ==, =!, <=, <, >=, > with support to choose axis (rows or columns) and level for comparison.
 otherscalar, sequence, Series, or DataFrame
Any single or multiple element data structure, or listlike object.
 axis{0 or ‘index’, 1 or ‘columns’}, default ‘columns’
Whether to compare by the index (0 or ‘index’) or columns (1 or ‘columns’).
 levelint or label
Broadcast across a level, matching Index values on the passed MultiIndex level.
 DataFrame of bool
Result of the comparison.
DataFrame.eq : Compare DataFrames for equality elementwise. DataFrame.ne : Compare DataFrames for inequality elementwise. DataFrame.le : Compare DataFrames for less than inequality
or equality elementwise.
 DataFrame.ltCompare DataFrames for strictly less than
inequality elementwise.
 DataFrame.geCompare DataFrames for greater than inequality
or equality elementwise.
 DataFrame.gtCompare DataFrames for strictly greater than
inequality elementwise.
Mismatched indices will be unioned together. NaN values are considered different (i.e. NaN != NaN).
>>> df = pd.DataFrame({'cost': [250, 150, 100], ... 'revenue': [100, 250, 300]}, ... index=['A', 'B', 'C']) >>> df cost revenue A 250 100 B 150 250 C 100 300
Comparison with a scalar, using either the operator or method:
>>> df == 100 cost revenue A False True B False False C True False
>>> df.eq(100) cost revenue A False True B False False C True False
When other is a
Series
, the columns of a DataFrame are aligned with the index of other and broadcast:>>> df != pd.Series([100, 250], index=["cost", "revenue"]) cost revenue A True True B True False C False True
Use the method to control the broadcast axis:
>>> df.ne(pd.Series([100, 300], index=["A", "D"]), axis='index') cost revenue A True False B True True C True True D True True
When comparing to an arbitrary sequence, the number of columns must match the number elements in other:
>>> df == [250, 100] cost revenue A True True B False False C False False
Use the method to control the axis:
>>> df.eq([250, 250, 100], axis='index') cost revenue A True False B False True C True False
Compare to a DataFrame of different shape.
>>> other = pd.DataFrame({'revenue': [300, 250, 100, 150]}, ... index=['A', 'B', 'C', 'D']) >>> other revenue A 300 B 250 C 100 D 150
>>> df.gt(other) cost revenue A False False B False False C False True D False False
Compare to a MultiIndex by level.
>>> df_multindex = pd.DataFrame({'cost': [250, 150, 100, 150, 300, 220], ... 'revenue': [100, 250, 300, 200, 175, 225]}, ... index=[['Q1', 'Q1', 'Q1', 'Q2', 'Q2', 'Q2'], ... ['A', 'B', 'C', 'A', 'B', 'C']]) >>> df_multindex cost revenue Q1 A 250 100 B 150 250 C 100 300 Q2 A 150 200 B 300 175 C 220 225
>>> df.le(df_multindex, level=1) cost revenue Q1 A True True B True True C True True Q2 A False True B True False C True False

equals
(second_geometry)¶ Indicates if the base and comparison geometries are of the same shape type and define the same set of points in the plane. This is a 2D comparison only; M and Z values are ignored. Paramters:
 second_geometry
a second geometry

erase
(other, inplace=False)¶ Erases
Argument
Description
other
Required Geometry. A geometry object to erase from other geometries.
inplace
Optional boolean. Default False. Modify the SpatialDataFrame in place (do not create a new object)
 Returns
SpatialDataFrame

eval
(expr, inplace=False, **kwargs)¶ Evaluate a string describing operations on DataFrame columns.
Operates on columns only, not specific rows or elements. This allows eval to run arbitrary code, which can make you vulnerable to code injection if you pass user input to this function.
 exprstr
The expression string to evaluate.
 inplacebool, default False
If the expression contains an assignment, whether to perform the operation inplace and mutate the existing DataFrame. Otherwise, a new DataFrame is returned.
 **kwargs
See the documentation for
eval()
for complete details on the keyword arguments accepted byquery()
.
 ndarray, scalar, or pandas object
The result of the evaluation.
 DataFrame.queryEvaluates a boolean expression to query the columns
of a frame.
 DataFrame.assignCan evaluate an expression or function to create new
values for a column.
 evalEvaluate a Python expression as a string using various
backends.
For more details see the API documentation for
eval()
. For detailed examples see enhancing performance with eval.>>> df = pd.DataFrame({'A': range(1, 6), 'B': range(10, 0, 2)}) >>> df A B 0 1 10 1 2 8 2 3 6 3 4 4 4 5 2 >>> df.eval('A + B') 0 11 1 10 2 9 3 8 4 7 dtype: int64
Assignment is allowed though by default the original DataFrame is not modified.
>>> df.eval('C = A + B') A B C 0 1 10 11 1 2 8 10 2 3 6 9 3 4 4 8 4 5 2 7 >>> df A B 0 1 10 1 2 8 2 3 6 3 4 4 4 5 2
Use
inplace=True
to modify the original DataFrame.>>> df.eval('C = A + B', inplace=True) >>> df A B C 0 1 10 11 1 2 8 10 2 3 6 9 3 4 4 8 4 5 2 7
Multiple columns can be assigned to using multiline expressions:
>>> df.eval( ... ''' ... C = A + B ... D = A  B ... ''' ... ) A B C D 0 1 10 11 9 1 2 8 10 6 2 3 6 9 3 3 4 4 8 0 4 5 2 7 3

ewm
(com=None, span=None, halflife=None, alpha=None, min_periods=0, adjust=True, ignore_na=False, axis=0, times=None)¶ Provide exponential weighted (EW) functions.
Available EW functions:
mean()
,var()
,std()
,corr()
,cov()
.Exactly one parameter:
com
,span
,halflife
, oralpha
must be provided. comfloat, optional
Specify decay in terms of center of mass, \(\alpha = 1 / (1 + com)\), for \(com \geq 0\).
 spanfloat, optional
Specify decay in terms of span, \(\alpha = 2 / (span + 1)\), for \(span \geq 1\).
 halflifefloat, str, timedelta, optional
Specify decay in terms of halflife, \(\alpha = 1  \exp\left(\ln(2) / halflife\right)\), for \(halflife > 0\).
If
times
is specified, the time unit (str or timedelta) over which an observation decays to half its value. Only applicable tomean()
and halflife value will not apply to the other functions.New in version 1.1.0.
 alphafloat, optional
Specify smoothing factor \(\alpha\) directly, \(0 < \alpha \leq 1\).
 min_periodsint, default 0
Minimum number of observations in window required to have a value (otherwise result is NA).
 adjustbool, default True
Divide by decaying adjustment factor in beginning periods to account for imbalance in relative weightings (viewing EWMA as a moving average).
When
adjust=True
(default), the EW function is calculated using weights \(w_i = (1  \alpha)^i\). For example, the EW moving average of the series [\(x_0, x_1, ..., x_t\)] would be:
\[y_t = \frac{x_t + (1  \alpha)x_{t1} + (1  \alpha)^2 x_{t2} + ... + (1  \alpha)^t x_0}{1 + (1  \alpha) + (1  \alpha)^2 + ... + (1  \alpha)^t}\]When
adjust=False
, the exponentially weighted function is calculated recursively:
\[\begin{split}\begin{split} y_0 &= x_0\\ y_t &= (1  \alpha) y_{t1} + \alpha x_t, \end{split}\end{split}\] ignore_nabool, default False
Ignore missing values when calculating weights; specify
True
to reproduce pre0.15.0 behavior.When
ignore_na=False
(default), weights are based on absolute positions. For example, the weights of \(x_0\) and \(x_2\) used in calculating the final weighted average of [\(x_0\), None, \(x_2\)] are \((1\alpha)^2\) and \(1\) ifadjust=True
, and \((1\alpha)^2\) and \(\alpha\) ifadjust=False
.When
ignore_na=True
(reproducing pre0.15.0 behavior), weights are based on relative positions. For example, the weights of \(x_0\) and \(x_2\) used in calculating the final weighted average of [\(x_0\), None, \(x_2\)] are \(1\alpha\) and \(1\) ifadjust=True
, and \(1\alpha\) and \(\alpha\) ifadjust=False
.
 axis{0, 1}, default 0
The axis to use. The value 0 identifies the rows, and 1 identifies the columns.
times : str, np.ndarray, Series, default None
New in version 1.1.0.
Times corresponding to the observations. Must be monotonically increasing and
datetime64[ns]
dtype.If str, the name of the column in the DataFrame representing the times.
If 1D array like, a sequence with the same shape as the observations.
Only applicable to
mean()
. DataFrame
A Window subclassed for the particular operation.
rolling : Provides rolling window calculations. expanding : Provides expanding transformations.
More details can be found at: Exponentially weighted windows.
>>> df = pd.DataFrame({'B': [0, 1, 2, np.nan, 4]}) >>> df B 0 0.0 1 1.0 2 2.0 3 NaN 4 4.0
>>> df.ewm(com=0.5).mean() B 0 0.000000 1 0.750000 2 1.615385 3 1.615385 4 3.670213
Specifying
times
with a timedeltahalflife
when computing mean.>>> times = ['20200101', '20200103', '20200110', '20200115', '20200117'] >>> df.ewm(halflife='4 days', times=pd.DatetimeIndex(times)).mean() B 0 0.000000 1 0.585786 2 1.523889 3 1.523889 4 3.233686

expanding
(min_periods=1, center=None, axis=0)¶ Provide expanding transformations.
 min_periodsint, default 1
Minimum number of observations in window required to have a value (otherwise result is NA).
 centerbool, default False
Set the labels at the center of the window.
axis : int or str, default 0
a Window subclassed for the particular operation
rolling : Provides rolling window calculations. ewm : Provides exponential weighted functions.
By default, the result is set to the right edge of the window. This can be changed to the center of the window by setting
center=True
.>>> df = pd.DataFrame({"B": [0, 1, 2, np.nan, 4]}) >>> df B 0 0.0 1 1.0 2 2.0 3 NaN 4 4.0
>>> df.expanding(2).sum() B 0 NaN 1 1.0 2 3.0 3 3.0 4 7.0

explode
(column: Union[str, Tuple], ignore_index: bool = False) → pandas.core.frame.DataFrame¶ Transform each element of a listlike to a row, replicating index values.
New in version 0.25.0.
 columnstr or tuple
Column to explode.
 ignore_indexbool, default False
If True, the resulting index will be labeled 0, 1, …, n  1.
New in version 1.1.0.
 DataFrame
Exploded lists to rows of the subset columns; index will be duplicated for these rows.
 ValueError :
if columns of the frame are not unique.
 DataFrame.unstackPivot a level of the (necessarily hierarchical)
index labels.
DataFrame.melt : Unpivot a DataFrame from wide format to long format. Series.explode : Explode a DataFrame from listlike columns to long format.
This routine will explode listlikes including lists, tuples, Series, and np.ndarray. The result dtype of the subset rows will be object. Scalars will be returned unchanged. Empty listlikes will result in a np.nan for that row.
>>> df = pd.DataFrame({'A': [[1, 2, 3], 'foo', [], [3, 4]], 'B': 1}) >>> df A B 0 [1, 2, 3] 1 1 foo 1 2 [] 1 3 [3, 4] 1
>>> df.explode('A') A B 0 1 1 0 2 1 0 3 1 1 foo 1 2 NaN 1 3 3 1 3 4 1

property
extent
¶ the extent of the geometry

ffill
(axis=None, inplace: bool = False, limit=None, downcast=None) → Optional[FrameOrSeries]¶ Synonym for
DataFrame.fillna()
withmethod='ffill'
. {klass} or None
Object with missing values filled or None if
inplace=True
.

fillna
(value=None, method=None, axis=None, inplace=False, limit=None, downcast=None) → Optional[pandas.core.frame.DataFrame]¶ Fill NA/NaN values using the specified method.
 valuescalar, dict, Series, or DataFrame
Value to use to fill holes (e.g. 0), alternately a dict/Series/DataFrame of values specifying which value to use for each index (for a Series) or column (for a DataFrame). Values not in the dict/Series/DataFrame will not be filled. This value cannot be a list.
 method{‘backfill’, ‘bfill’, ‘pad’, ‘ffill’, None}, default None
Method to use for filling holes in reindexed Series pad / ffill: propagate last valid observation forward to next valid backfill / bfill: use next valid observation to fill gap.
 axis{0 or ‘index’, 1 or ‘columns’}
Axis along which to fill missing values.
 inplacebool, default False
If True, fill inplace. Note: this will modify any other views on this object (e.g., a nocopy slice for a column in a DataFrame).
 limitint, default None
If method is specified, this is the maximum number of consecutive NaN values to forward/backward fill. In other words, if there is a gap with more than this number of consecutive NaNs, it will only be partially filled. If method is not specified, this is the maximum number of entries along the entire axis where NaNs will be filled. Must be greater than 0 if not None.
 downcastdict, default is None
A dict of item>dtype of what to downcast if possible, or the string ‘infer’ which will try to downcast to an appropriate equal type (e.g. float64 to int64 if possible).
 DataFrame or None
Object with missing values filled or None if
inplace=True
.
interpolate : Fill NaN values using interpolation. reindex : Conform object to new index. asfreq : Convert TimeSeries to specified frequency.
>>> df = pd.DataFrame([[np.nan, 2, np.nan, 0], ... [3, 4, np.nan, 1], ... [np.nan, np.nan, np.nan, 5], ... [np.nan, 3, np.nan, 4]], ... columns=list('ABCD')) >>> df A B C D 0 NaN 2.0 NaN 0 1 3.0 4.0 NaN 1 2 NaN NaN NaN 5 3 NaN 3.0 NaN 4
Replace all NaN elements with 0s.
>>> df.fillna(0) A B C D 0 0.0 2.0 0.0 0 1 3.0 4.0 0.0 1 2 0.0 0.0 0.0 5 3 0.0 3.0 0.0 4
We can also propagate nonnull values forward or backward.
>>> df.fillna(method='ffill') A B C D 0 NaN 2.0 NaN 0 1 3.0 4.0 NaN 1 2 3.0 4.0 NaN 5 3 3.0 3.0 NaN 4
Replace all NaN elements in column ‘A’, ‘B’, ‘C’, and ‘D’, with 0, 1, 2, and 3 respectively.
>>> values = {'A': 0, 'B': 1, 'C': 2, 'D': 3} >>> df.fillna(value=values) A B C D 0 0.0 2.0 2.0 0 1 3.0 4.0 2.0 1 2 0.0 1.0 2.0 5 3 0.0 3.0 2.0 4
Only replace the first NaN element.
>>> df.fillna(value=values, limit=1) A B C D 0 0.0 2.0 2.0 0 1 3.0 4.0 NaN 1 2 NaN 1.0 NaN 5 3 NaN 3.0 NaN 4

filter
(items=None, like: Optional[str] = None, regex: Optional[str] = None, axis=None) → FrameOrSeries¶ Subset the dataframe rows or columns according to the specified index labels.
Note that this routine does not filter a dataframe on its contents. The filter is applied to the labels of the index.
 itemslistlike
Keep labels from axis which are in items.
 likestr
Keep labels from axis for which “like in label == True”.
 regexstr (regular expression)
Keep labels from axis for which re.search(regex, label) == True.
 axis{0 or ‘index’, 1 or ‘columns’, None}, default None
The axis to filter on, expressed either as an index (int) or axis name (str). By default this is the info axis, ‘index’ for Series, ‘columns’ for DataFrame.
same type as input object
 DataFrame.locAccess a group of rows and columns
by label(s) or a boolean array.
The
items
,like
, andregex
parameters are enforced to be mutually exclusive.axis
defaults to the info axis that is used when indexing with[]
.>>> df = pd.DataFrame(np.array(([1, 2, 3], [4, 5, 6])), ... index=['mouse', 'rabbit'], ... columns=['one', 'two', 'three']) >>> df one two three mouse 1 2 3 rabbit 4 5 6
>>> # select columns by name >>> df.filter(items=['one', 'three']) one three mouse 1 3 rabbit 4 6
>>> # select columns by regular expression >>> df.filter(regex='e$', axis=1) one three mouse 1 3 rabbit 4 6
>>> # select rows containing 'bbi' >>> df.filter(like='bbi', axis=0) one two three rabbit 4 5 6

first
(offset) → FrameOrSeries¶ Select initial periods of time series data based on a date offset.
When having a DataFrame with dates as index, this function can select the first few rows based on a date offset.
 offsetstr, DateOffset or dateutil.relativedelta
The offset length of the data that will be selected. For instance, ‘1M’ will display all the rows having their index within the first month.
 Series or DataFrame
A subset of the caller.
 TypeError
If the index is not a
DatetimeIndex
last : Select final periods of time series based on a date offset. at_time : Select values at a particular time of the day. between_time : Select values between particular times of the day.
>>> i = pd.date_range('20180409', periods=4, freq='2D') >>> ts = pd.DataFrame({'A': [1, 2, 3, 4]}, index=i) >>> ts A 20180409 1 20180411 2 20180413 3 20180415 4
Get the rows for the first 3 days:
>>> ts.first('3D') A 20180409 1 20180411 2
Notice the data for 3 first calendar days were returned, not the first 3 days observed in the dataset, and therefore data for 20180413 was not returned.

property
first_point
¶ The first coordinate point of the geometry.

first_valid_index
()¶ Return index for first nonNA/null value.
scalar : type of index
If all elements are nonNA/null, returns None. Also returns None for empty Series/DataFrame.

floordiv
(other, axis='columns', level=None, fill_value=None)¶ Get Integer division of dataframe and other, elementwise (binary operator floordiv).
Equivalent to
dataframe // other
, but with support to substitute a fill_value for missing data in one of the inputs. With reverse version, rfloordiv.Among flexible wrappers (add, sub, mul, div, mod, pow) to arithmetic operators: +, , *, /, //, %, **.
 otherscalar, sequence, Series, or DataFrame
Any single or multiple element data structure, or listlike object.
 axis{0 or ‘index’, 1 or ‘columns’}
Whether to compare by the index (0 or ‘index’) or columns (1 or ‘columns’). For Series input, axis to match Series index on.
 levelint or label
Broadcast across a level, matching Index values on the passed MultiIndex level.
 fill_valuefloat or None, default None
Fill existing missing (NaN) values, and any new element needed for successful DataFrame alignment, with this value before computation. If data in both corresponding DataFrame locations is missing the result will be missing.
 DataFrame
Result of the arithmetic operation.
DataFrame.add : Add DataFrames. DataFrame.sub : Subtract DataFrames. DataFrame.mul : Multiply DataFrames. DataFrame.div : Divide DataFrames (float division). DataFrame.truediv : Divide DataFrames (float division). DataFrame.floordiv : Divide DataFrames (integer division). DataFrame.mod : Calculate modulo (remainder after division). DataFrame.pow : Calculate exponential power.
Mismatched indices will be unioned together.
>>> df = pd.DataFrame({'angles': [0, 3, 4], ... 'degrees': [360, 180, 360]}, ... index=['circle', 'triangle', 'rectangle']) >>> df angles degrees circle 0 360 triangle 3 180 rectangle 4 360
Add a scalar with operator version which return the same results.
>>> df + 1 angles degrees circle 1 361 triangle 4 181 rectangle 5 361
>>> df.add(1) angles degrees circle 1 361 triangle 4 181 rectangle 5 361
Divide by constant with reverse version.
>>> df.div(10) angles degrees circle 0.0 36.0 triangle 0.3 18.0 rectangle 0.4 36.0
>>> df.rdiv(10) angles degrees circle inf 0.027778 triangle 3.333333 0.055556 rectangle 2.500000 0.027778
Subtract a list and Series by axis with operator version.
>>> df  [1, 2] angles degrees circle 1 358 triangle 2 178 rectangle 3 358
>>> df.sub([1, 2], axis='columns') angles degrees circle 1 358 triangle 2 178 rectangle 3 358
>>> df.sub(pd.Series([1, 1, 1], index=['circle', 'triangle', 'rectangle']), ... axis='index') angles degrees circle 1 359 triangle 2 179 rectangle 3 359
Multiply a DataFrame of different shape with operator version.
>>> other = pd.DataFrame({'angles': [0, 3, 4]}, ... index=['circle', 'triangle', 'rectangle']) >>> other angles circle 0 triangle 3 rectangle 4
>>> df * other angles degrees circle 0 NaN triangle 9 NaN rectangle 16 NaN
>>> df.mul(other, fill_value=0) angles degrees circle 0 0.0 triangle 9 0.0 rectangle 16 0.0
Divide by a MultiIndex by level.
>>> df_multindex = pd.DataFrame({'angles': [0, 3, 4, 4, 5, 6], ... 'degrees': [360, 180, 360, 360, 540, 720]}, ... index=[['A', 'A', 'A', 'B', 'B', 'B'], ... ['circle', 'triangle', 'rectangle', ... 'square', 'pentagon', 'hexagon']]) >>> df_multindex angles degrees A circle 0 360 triangle 3 180 rectangle 4 360 B square 4 360 pentagon 5 540 hexagon 6 720
>>> df.div(df_multindex, level=1, fill_value=0) angles degrees A circle NaN 1.0 triangle 1.0 1.0 rectangle 1.0 1.0 B square 0.0 0.0 pentagon 0.0 0.0 hexagon 0.0 0.0

static
from_df
(df, address_column='address', geocoder=None)¶ Returns a SpatialDataFrame from a dataframe with an address column.
Argument
Description
df
Required Pandas DataFrame. Source dataset
address_column
Optional String. The default is “address”. This is the name of a column in the specified dataframe that contains addresses (as strings). The addresses are batch geocoded using the GIS’s first configured geocoder and their locations used as the geometry of the spatial dataframe. Ignored if the ‘geometry’ parameter is also specified.
geocoder
Optional Geocoder. The geocoder to be used. If not specified, the active GIS’s first geocoder is used.
 Returns
SpatialDataFrame
NOTE: Credits will be consumed for batch_geocoding, from the GIS to which the geocoder belongs.

classmethod
from_dict
(data, orient='columns', dtype=None, columns=None) → pandas.core.frame.DataFrame¶ Construct DataFrame from dict of arraylike or dicts.
Creates DataFrame object from dictionary by columns or by index allowing dtype specification.
 datadict
Of the form {field : arraylike} or {field : dict}.
 orient{‘columns’, ‘index’}, default ‘columns’
The “orientation” of the data. If the keys of the passed dict should be the columns of the resulting DataFrame, pass ‘columns’ (default). Otherwise if the keys should be rows, pass ‘index’.
 dtypedtype, default None
Data type to force, otherwise infer.
 columnslist, default None
Column labels to use when
orient='index'
. Raises a ValueError if used withorient='columns'
.New in version 0.23.0.
DataFrame
 DataFrame.from_recordsDataFrame from structured ndarray, sequence
of tuples or dicts, or DataFrame.
DataFrame : DataFrame object creation using constructor.
By default the keys of the dict become the DataFrame columns:
>>> data = {'col_1': [3, 2, 1, 0], 'col_2': ['a', 'b', 'c', 'd']} >>> pd.DataFrame.from_dict(data) col_1 col_2 0 3 a 1 2 b 2 1 c 3 0 d
Specify
orient='index'
to create the DataFrame using dictionary keys as rows:>>> data = {'row_1': [3, 2, 1, 0], 'row_2': ['a', 'b', 'c', 'd']} >>> pd.DataFrame.from_dict(data, orient='index') 0 1 2 3 row_1 3 2 1 0 row_2 a b c d
When using the ‘index’ orientation, the column names can be specified manually:
>>> pd.DataFrame.from_dict(data, orient='index', ... columns=['A', 'B', 'C', 'D']) A B C D row_1 3 2 1 0 row_2 a b c d

static
from_featureclass
(filename, **kwargs)¶ Returns a SpatialDataFrame from a feature class.
Argument
Description
filename
Required string. The full path to the feature class
sql_clause
Optional string. The sql clause to parse data down
where_clause
Optional string. A where statement
sr
Optional SpatialReference. A spatial reference object
 Returns
SpatialDataFrame

static
from_hdf
(path_or_buf, key=None, **kwargs)¶ read from the store, close it if we opened it
Retrieve pandas object stored in file, optionally based on where criteria
 path_or_bufpath (string), buffer, or path object (pathlib.Path or
py._path.local.LocalPath) to read from
New in version 0.19.0: support for pathlib, py.path.
 keygroup identifier in the store. Can be omitted if the HDF file
contains a single pandas object.
where : list of Term (or convertable) objects, optional start : optional, integer (defaults to None), row number to start
selection
 stopoptional, integer (defaults to None), row number to stop
selection
 columnsoptional, a list of columns that if not None, will limit the
return columns
iterator : optional, boolean, return an iterator, default False chunksize : optional, nrows to include in iteration, return an iterator
The selected object

static
from_layer
(layer, **kwargs)¶ Returns a SpatialDataFrame/Pandas’ Dataframe from a FeatureLayer or Table object.
Arguments
Description
layer
required FeatureLayer/Table. This is the service endpoint object.
 Returns
SpatialDataFrame for feature layers with geometry and Panda’s Dataframe for tables

classmethod
from_records
(data, index=None, exclude=None, columns=None, coerce_float=False, nrows=None) → pandas.core.frame.DataFrame¶ Convert structured or record ndarray to DataFrame.
Creates a DataFrame object from a structured ndarray, sequence of tuples or dicts, or DataFrame.
 datastructured ndarray, sequence of tuples or dicts, or DataFrame
Structured input data.
 indexstr, list of fields, arraylike
Field of array to use as the index, alternately a specific set of input labels to use.
 excludesequence, default None
Columns or fields to exclude.
 columnssequence, default None
Column names to use. If the passed data do not have names associated with them, this argument provides names for the columns. Otherwise this argument indicates the order of the columns in the result (any names not found in the data will become allNA columns).
 coerce_floatbool, default False
Attempt to convert values of nonstring, nonnumeric objects (like decimal.Decimal) to floating point, useful for SQL result sets.
 nrowsint, default None
Number of rows to read if data is an iterator.
DataFrame
DataFrame.from_dict : DataFrame from dict of arraylike or dicts. DataFrame : DataFrame object creation using constructor.
Data can be provided as a structured ndarray:
>>> data = np.array([(3, 'a'), (2, 'b'), (1, 'c'), (0, 'd')], ... dtype=[('col_1', 'i4'), ('col_2', 'U1')]) >>> pd.DataFrame.from_records(data) col_1 col_2 0 3 a 1 2 b 2 1 c 3 0 d
Data can be provided as a list of dicts:
>>> data = [{'col_1': 3, 'col_2': 'a'}, ... {'col_1': 2, 'col_2': 'b'}, ... {'col_1': 1, 'col_2': 'c'}, ... {'col_1': 0, 'col_2': 'd'}] >>> pd.DataFrame.from_records(data) col_1 col_2 0 3 a 1 2 b 2 1 c 3 0 d
Data can be provided as a list of tuples with corresponding columns:
>>> data = [(3, 'a'), (2, 'b'), (1, 'c'), (0, 'd')] >>> pd.DataFrame.from_records(data, columns=['col_1', 'col_2']) col_1 col_2 0 3 a 1 2 b 2 1 c 3 0 d

static
from_xy
(df, x_column, y_column, sr=4326)¶ Converts a Pandas DataFrame into a Spatial DataFrame by providing the X/Y columns.
Argument
Description
df
Required Pandas DataFrame. Source dataset
x_column
Required string. The name of the Xcoordinate series
y_column
Required string. The name of the Ycoordinate series
sr
Optional int. The wkid number of the spatial reference.
 Returns
SpatialDataFrame

ge
(other, axis='columns', level=None)¶ Get Greater than or equal to of dataframe and other, elementwise (binary operator ge).
Among flexible wrappers (eq, ne, le, lt, ge, gt) to comparison operators.
Equivalent to ==, =!, <=, <, >=, > with support to choose axis (rows or columns) and level for comparison.
 otherscalar, sequence, Series, or DataFrame
Any single or multiple element data structure, or listlike object.
 axis{0 or ‘index’, 1 or ‘columns’}, default ‘columns’
Whether to compare by the index (0 or ‘index’) or columns (1 or ‘columns’).
 levelint or label
Broadcast across a level, matching Index values on the passed MultiIndex level.
 DataFrame of bool
Result of the comparison.
DataFrame.eq : Compare DataFrames for equality elementwise. DataFrame.ne : Compare DataFrames for inequality elementwise. DataFrame.le : Compare DataFrames for less than inequality
or equality elementwise.
 DataFrame.ltCompare DataFrames for strictly less than
inequality elementwise.
 DataFrame.geCompare DataFrames for greater than inequality
or equality elementwise.
 DataFrame.gtCompare DataFrames for strictly greater than
inequality elementwise.
Mismatched indices will be unioned together. NaN values are considered different (i.e. NaN != NaN).
>>> df = pd.DataFrame({'cost': [250, 150, 100], ... 'revenue': [100, 250, 300]}, ... index=['A', 'B', 'C']) >>> df cost revenue A 250 100 B 150 250 C 100 300
Comparison with a scalar, using either the operator or method:
>>> df == 100 cost revenue A False True B False False C True False
>>> df.eq(100) cost revenue A False True B False False C True False
When other is a
Series
, the columns of a DataFrame are aligned with the index of other and broadcast:>>> df != pd.Series([100, 250], index=["cost", "revenue"]) cost revenue A True True B True False C False True
Use the method to control the broadcast axis:
>>> df.ne(pd.Series([100, 300], index=["A", "D"]), axis='index') cost revenue A True False B True True C True True D True True
When comparing to an arbitrary sequence, the number of columns must match the number elements in other:
>>> df == [250, 100] cost revenue A True True B False False C False False
Use the method to control the axis:
>>> df.eq([250, 250, 100], axis='index') cost revenue A True False B False True C True False
Compare to a DataFrame of different shape.
>>> other = pd.DataFrame({'revenue': [300, 250, 100, 150]}, ... index=['A', 'B', 'C', 'D']) >>> other revenue A 300 B 250 C 100 D 150
>>> df.gt(other) cost revenue A False False B False False C False True D False False
Compare to a MultiIndex by level.
>>> df_multindex = pd.DataFrame({'cost': [250, 150, 100, 150, 300, 220], ... 'revenue': [100, 250, 300, 200, 175, 225]}, ... index=[['Q1', 'Q1', 'Q1', 'Q2', 'Q2', 'Q2'], ... ['A', 'B', 'C', 'A', 'B', 'C']]) >>> df_multindex cost revenue Q1 A 250 100 B 150 250 C 100 300 Q2 A 150 200 B 300 175 C 220 225
>>> df.le(df_multindex, level=1) cost revenue Q1 A True True B True True C True True Q2 A False True B True False C True False

generalize
(max_offset)¶ Creates a new simplified geometry using a specified maximum offset tolerance.
 Parameters:
 max_offset
The maximum offset tolerance.

property
geoextent
¶ returns the extent of the spatial dataframe

property
geometry
¶ Get/Set the geometry data for SpatialDataFrame

property
geometry_type
¶ The geometry type: polygon, polyline, point, multipoint, multipatch, dimension, or annotation

get
(key, default=None)¶ Get item from object for given key (ex: DataFrame column).
Returns default value if not found.
key : object
value : same type as items contained in object

get_area
(method, units=None)¶ Returns the area of the feature using a measurement type.
 Parameters:
 method
PLANAR measurements reflect the projection of
geographic data onto the 2D surface (in other words, they will not take into account the curvature of the earth). GEODESIC, GREAT_ELLIPTIC, LOXODROME, and PRESERVE_SHAPE measurement types may be chosen as an alternative, if desired.
 units
Areal unit of measure keywords: ACRES  ARES  HECTARES
SQUARECENTIMETERS  SQUAREDECIMETERS  SQUAREINCHES  SQUAREFEETSQUAREKILOMETERS  SQUAREMETERS  SQUAREMILES SQUAREMILLIMETERS  SQUAREYARDS

get_length
(method, units)¶ Returns the length of the feature using a measurement type.
 Parameters:
 method
PLANAR measurements reflect the projection of
geographic data onto the 2D surface (in other words, they will not take into account the curvature of the earth). GEODESIC, GREAT_ELLIPTIC, LOXODROME, and PRESERVE_SHAPE measurement types may be chosen as an alternative, if desired.
 units
Linear unit of measure keywords: CENTIMETERS 
DECIMETERS  FEET  INCHES  KILOMETERS  METERS  MILES  MILLIMETERS  NAUTICALMILES  YARDS

get_part
(index=None)¶ Returns an array of point objects for a particular part of geometry or an array containing a number of arrays, one for each part.
 Parameters:
 index
The index position of the geometry.

groupby
(by=None, axis=0, level=None, as_index: bool = True, sort: bool = True, group_keys: bool = True, squeeze: bool = <object object>, observed: bool = False, dropna: bool = True) → DataFrameGroupBy¶ Group DataFrame using a mapper or by a Series of columns.
A groupby operation involves some combination of splitting the object, applying a function, and combining the results. This can be used to group large amounts of data and compute operations on these groups.
 bymapping, function, label, or list of labels
Used to determine the groups for the groupby. If
by
is a function, it’s called on each value of the object’s index. If a dict or Series is passed, the Series or dict VALUES will be used to determine the groups (the Series’ values are first aligned; see.align()
method). If an ndarray is passed, the values are used asis determine the groups. A label or list of labels may be passed to group by the columns inself
. Notice that a tuple is interpreted as a (single) key. axis{0 or ‘index’, 1 or ‘columns’}, default 0
Split along rows (0) or columns (1).
 levelint, level name, or sequence of such, default None
If the axis is a MultiIndex (hierarchical), group by a particular level or levels.
 as_indexbool, default True
For aggregated output, return object with group labels as the index. Only relevant for DataFrame input. as_index=False is effectively “SQLstyle” grouped output.
 sortbool, default True
Sort group keys. Get better performance by turning this off. Note this does not influence the order of observations within each group. Groupby preserves the order of rows within each group.
 group_keysbool, default True
When calling apply, add group keys to index to identify pieces.
 squeezebool, default False
Reduce the dimensionality of the return type if possible, otherwise return a consistent type.
Deprecated since version 1.1.0.
 observedbool, default False
This only applies if any of the groupers are Categoricals. If True: only show observed values for categorical groupers. If False: show all values for categorical groupers.
New in version 0.23.0.
 dropnabool, default True
If True, and if group keys contain NA values, NA values together with row/column will be dropped. If False, NA values will also be treated as the key in groups
New in version 1.1.0.
 DataFrameGroupBy
Returns a groupby object that contains information about the groups.
 resampleConvenience method for frequency conversion and resampling
of time series.
See the user guide for more.
>>> df = pd.DataFrame({'Animal': ['Falcon', 'Falcon', ... 'Parrot', 'Parrot'], ... 'Max Speed': [380., 370., 24., 26.]}) >>> df Animal Max Speed 0 Falcon 380.0 1 Falcon 370.0 2 Parrot 24.0 3 Parrot 26.0 >>> df.groupby(['Animal']).mean() Max Speed Animal Falcon 375.0 Parrot 25.0
Hierarchical Indexes
We can groupby different levels of a hierarchical index using the level parameter:
>>> arrays = [['Falcon', 'Falcon', 'Parrot', 'Parrot'], ... ['Captive', 'Wild', 'Captive', 'Wild']] >>> index = pd.MultiIndex.from_arrays(arrays, names=('Animal', 'Type')) >>> df = pd.DataFrame({'Max Speed': [390., 350., 30., 20.]}, ... index=index) >>> df Max Speed Animal Type Falcon Captive 390.0 Wild 350.0 Parrot Captive 30.0 Wild 20.0 >>> df.groupby(level=0).mean() Max Speed Animal Falcon 370.0 Parrot 25.0 >>> df.groupby(level="Type").mean() Max Speed Type Captive 210.0 Wild 185.0
We can also choose to include NA in group keys or not by setting dropna parameter, the default setting is True:
>>> l = [[1, 2, 3], [1, None, 4], [2, 1, 3], [1, 2, 2]] >>> df = pd.DataFrame(l, columns=["a", "b", "c"])
>>> df.groupby(by=["b"]).sum() a c b 1.0 2 3 2.0 2 5
>>> df.groupby(by=["b"], dropna=False).sum() a c b 1.0 2 3 2.0 2 5 NaN 1 4
>>> l = [["a", 12, 12], [None, 12.3, 33.], ["b", 12.3, 123], ["a", 1, 1]] >>> df = pd.DataFrame(l, columns=["a", "b", "c"])
>>> df.groupby(by="a").sum() b c a a 13.0 13.0 b 12.3 123.0
>>> df.groupby(by="a", dropna=False).sum() b c a a 13.0 13.0 b 12.3 123.0 NaN 12.3 33.0

gt
(other, axis='columns', level=None)¶ Get Greater than of dataframe and other, elementwise (binary operator gt).
Among flexible wrappers (eq, ne, le, lt, ge, gt) to comparison operators.
Equivalent to ==, =!, <=, <, >=, > with support to choose axis (rows or columns) and level for comparison.
 otherscalar, sequence, Series, or DataFrame
Any single or multiple element data structure, or listlike object.
 axis{0 or ‘index’, 1 or ‘columns’}, default ‘columns’
Whether to compare by the index (0 or ‘index’) or columns (1 or ‘columns’).
 levelint or label
Broadcast across a level, matching Index values on the passed MultiIndex level.
 DataFrame of bool
Result of the comparison.
DataFrame.eq : Compare DataFrames for equality elementwise. DataFrame.ne : Compare DataFrames for inequality elementwise. DataFrame.le : Compare DataFrames for less than inequality
or equality elementwise.
 DataFrame.ltCompare DataFrames for strictly less than
inequality elementwise.
 DataFrame.geCompare DataFrames for greater than inequality
or equality elementwise.
 DataFrame.gtCompare DataFrames for strictly greater than
inequality elementwise.
Mismatched indices will be unioned together. NaN values are considered different (i.e. NaN != NaN).
>>> df = pd.DataFrame({'cost': [250, 150, 100], ... 'revenue': [100, 250, 300]}, ... index=['A', 'B', 'C']) >>> df cost revenue A 250 100 B 150 250 C 100 300
Comparison with a scalar, using either the operator or method:
>>> df == 100 cost revenue A False True B False False C True False
>>> df.eq(100) cost revenue A False True B False False C True False
When other is a
Series
, the columns of a DataFrame are aligned with the index of other and broadcast:>>> df != pd.Series([100, 250], index=["cost", "revenue"]) cost revenue A True True B True False C False True
Use the method to control the broadcast axis:
>>> df.ne(pd.Series([100, 300], index=["A", "D"]), axis='index') cost revenue A True False B True True C True True D True True
When comparing to an arbitrary sequence, the number of columns must match the number elements in other:
>>> df == [250, 100] cost revenue A True True B False False C False False
Use the method to control the axis:
>>> df.eq([250, 250, 100], axis='index') cost revenue A True False B False True C True False
Compare to a DataFrame of different shape.
>>> other = pd.DataFrame({'revenue': [300, 250, 100, 150]}, ... index=['A', 'B', 'C', 'D']) >>> other revenue A 300 B 250 C 100 D 150
>>> df.gt(other) cost revenue A False False B False False C False True D False False
Compare to a MultiIndex by level.
>>> df_multindex = pd.DataFrame({'cost': [250, 150, 100, 150, 300, 220], ... 'revenue': [100, 250, 300, 200, 175, 225]}, ... index=[['Q1', 'Q1', 'Q1', 'Q2', 'Q2', 'Q2'], ... ['A', 'B', 'C', 'A', 'B', 'C']]) >>> df_multindex cost revenue Q1 A 250 100 B 150 250 C 100 300 Q2 A 150 200 B 300 175 C 220 225
>>> df.le(df_multindex, level=1) cost revenue Q1 A True True B True True C True True Q2 A False True B True False C True False

head
(n: int = 5) → FrameOrSeries¶ Return the first n rows.
This function returns the first n rows for the object based on position. It is useful for quickly testing if your object has the right type of data in it.
For negative values of n, this function returns all rows except the last n rows, equivalent to
df[:n]
. nint, default 5
Number of rows to select.
 same type as caller
The first n rows of the caller object.
DataFrame.tail: Returns the last n rows.
>>> df = pd.DataFrame({'animal': ['alligator', 'bee', 'falcon', 'lion', ... 'monkey', 'parrot', 'shark', 'whale', 'zebra']}) >>> df animal 0 alligator 1 bee 2 falcon 3 lion 4 monkey 5 parrot 6 shark 7 whale 8 zebra
Viewing the first 5 lines
>>> df.head() animal 0 alligator 1 bee 2 falcon 3 lion 4 monkey
Viewing the first n lines (three in this case)
>>> df.head(3) animal 0 alligator 1 bee 2 falcon
For negative values of n
>>> df.head(3) animal 0 alligator 1 bee 2 falcon 3 lion 4 monkey 5 parrot

hist
(column: collections.abc.Hashable = None, by=None, grid: bool = True, xlabelsize: Optional[int] = None, xrot: Optional[float] = None, ylabelsize: Optional[int] = None, yrot: Optional[float] = None, ax=None, sharex: bool = False, sharey: bool = False, figsize: Optional[Tuple[int, int]] = None, layout: Optional[Tuple[int, int]] = None, bins: Union[int, Sequence[int]] = 10, backend: Optional[str] = None, legend: bool = False, **kwargs)¶ Make a histogram of the DataFrame’s.
A histogram is a representation of the distribution of data. This function calls
matplotlib.pyplot.hist()
, on each series in the DataFrame, resulting in one histogram per column. dataDataFrame
The pandas object holding the data.
 columnstr or sequence
If passed, will be used to limit data to a subset of columns.
 byobject, optional
If passed, then used to form histograms for separate groups.
 gridbool, default True
Whether to show axis grid lines.
 xlabelsizeint, default None
If specified changes the xaxis label size.
 xrotfloat, default None
Rotation of x axis labels. For example, a value of 90 displays the x labels rotated 90 degrees clockwise.
 ylabelsizeint, default None
If specified changes the yaxis label size.
 yrotfloat, default None
Rotation of y axis labels. For example, a value of 90 displays the y labels rotated 90 degrees clockwise.
 axMatplotlib axes object, default None
The axes to plot the histogram on.
 sharexbool, default True if ax is None else False
In case subplots=True, share x axis and set some x axis labels to invisible; defaults to True if ax is None otherwise False if an ax is passed in. Note that passing in both an ax and sharex=True will alter all x axis labels for all subplots in a figure.
 shareybool, default False
In case subplots=True, share y axis and set some y axis labels to invisible.
 figsizetuple
The size in inches of the figure to create. Uses the value in matplotlib.rcParams by default.
 layouttuple, optional
Tuple of (rows, columns) for the layout of the histograms.
 binsint or sequence, default 10
Number of histogram bins to be used. If an integer is given, bins + 1 bin edges are calculated and returned. If bins is a sequence, gives bin edges, including left edge of first bin and right edge of last bin. In this case, bins is returned unmodified.
 backendstr, default None
Backend to use instead of the backend specified in the option
plotting.backend
. For instance, ‘matplotlib’. Alternatively, to specify theplotting.backend
for the whole session, setpd.options.plotting.backend
.New in version 1.0.0.
 legendbool, default False
Whether to show the legend.
New in version 1.1.0.
 **kwargs
All other plotting keyword arguments to be passed to
matplotlib.pyplot.hist()
.
matplotlib.AxesSubplot or numpy.ndarray of them
matplotlib.pyplot.hist : Plot a histogram using matplotlib.
This example draws a histogram based on the length and width of some animals, displayed in three bins

property
hull_rectangle
¶ A spacedelimited string of the coordinate pairs of the convex hull rectangle.

property
iat
¶ Access a single value for a row/column pair by integer position.
Similar to
iloc
, in that both provide integerbased lookups. Useiat
if you only need to get or set a single value in a DataFrame or Series. IndexError
When integer position is out of bounds.
DataFrame.at : Access a single value for a row/column label pair. DataFrame.loc : Access a group of rows and columns by label(s). DataFrame.iloc : Access a group of rows and columns by integer position(s).
>>> df = pd.DataFrame([[0, 2, 3], [0, 4, 1], [10, 20, 30]], ... columns=['A', 'B', 'C']) >>> df A B C 0 0 2 3 1 0 4 1 2 10 20 30
Get value at specified row/column pair
>>> df.iat[1, 2] 1
Set value at specified row/column pair
>>> df.iat[1, 2] = 10 >>> df.iat[1, 2] 10
Get value within a series
>>> df.loc[0].iat[1] 2

idxmax
(axis=0, skipna=True) → pandas.core.series.Series¶ Return index of first occurrence of maximum over requested axis.
NA/null values are excluded.
 axis{0 or ‘index’, 1 or ‘columns’}, default 0
The axis to use. 0 or ‘index’ for rowwise, 1 or ‘columns’ for columnwise.
 skipnabool, default True
Exclude NA/null values. If an entire row/column is NA, the result will be NA.
 Series
Indexes of maxima along the specified axis.
 ValueError
If the row/column is empty
Series.idxmax : Return index of the maximum element.
This method is the DataFrame version of
ndarray.argmax
.Consider a dataset containing food consumption in Argentina.
>>> df = pd.DataFrame({'consumption': [10.51, 103.11, 55.48], ... 'co2_emissions': [37.2, 19.66, 1712]}, ... index=['Pork', 'Wheat Products', 'Beef'])
>>> df consumption co2_emissions Pork 10.51 37.20 Wheat Products 103.11 19.66 Beef 55.48 1712.00
By default, it returns the index for the maximum value in each column.
>>> df.idxmax() consumption Wheat Products co2_emissions Beef dtype: object
To return the index for the maximum value in each row, use
axis="columns"
.>>> df.idxmax(axis="columns") Pork co2_emissions Wheat Products consumption Beef co2_emissions dtype: object

idxmin
(axis=0, skipna=True) → pandas.core.series.Series¶ Return index of first occurrence of minimum over requested axis.
NA/null values are excluded.
 axis{0 or ‘index’, 1 or ‘columns’}, default 0
The axis to use. 0 or ‘index’ for rowwise, 1 or ‘columns’ for columnwise.
 skipnabool, default True
Exclude NA/null values. If an entire row/column is NA, the result will be NA.
 Series
Indexes of minima along the specified axis.
 ValueError
If the row/column is empty
Series.idxmin : Return index of the minimum element.
This method is the DataFrame version of
ndarray.argmin
.Consider a dataset containing food consumption in Argentina.
>>> df = pd.DataFrame({'consumption': [10.51, 103.11, 55.48], ... 'co2_emissions': [37.2, 19.66, 1712]}, ... index=['Pork', 'Wheat Products', 'Beef'])
>>> df consumption co2_emissions Pork 10.51 37.20 Wheat Products 103.11 19.66 Beef 55.48 1712.00
By default, it returns the index for the minimum value in each column.
>>> df.idxmin() consumption Pork co2_emissions Wheat Products dtype: object
To return the index for the minimum value in each row, use
axis="columns"
.>>> df.idxmin(axis="columns") Pork consumption Wheat Products co2_emissions Beef consumption dtype: object

property
iloc
¶ Purely integerlocation based indexing for selection by position.
.iloc[]
is primarily integer position based (from0
tolength1
of the axis), but may also be used with a boolean array.Allowed inputs are:
An integer, e.g.
5
.A list or array of integers, e.g.
[4, 3, 0]
.A slice object with ints, e.g.
1:7
.A boolean array.
A
callable
function with one argument (the calling Series or DataFrame) and that returns valid output for indexing (one of the above). This is useful in method chains, when you don’t have a reference to the calling object, but would like to base your selection on some value.
.iloc
will raiseIndexError
if a requested indexer is outofbounds, except slice indexers which allow outofbounds indexing (this conforms with python/numpy slice semantics).See more at Selection by Position.
DataFrame.iat : Fast integer location scalar accessor. DataFrame.loc : Purely labellocation based indexer for selection by label. Series.iloc : Purely integerlocation based indexing for
selection by position.
>>> mydict = [{'a': 1, 'b': 2, 'c': 3, 'd': 4}, ... {'a': 100, 'b': 200, 'c': 300, 'd': 400}, ... {'a': 1000, 'b': 2000, 'c': 3000, 'd': 4000 }] >>> df = pd.DataFrame(mydict) >>> df a b c d 0 1 2 3 4 1 100 200 300 400 2 1000 2000 3000 4000
Indexing just the rows
With a scalar integer.
>>> type(df.iloc[0]) <class 'pandas.core.series.Series'> >>> df.iloc[0] a 1 b 2 c 3 d 4 Name: 0, dtype: int64
With a list of integers.
>>> df.iloc[[0]] a b c d 0 1 2 3 4 >>> type(df.iloc[[0]]) <class 'pandas.core.frame.DataFrame'>
>>> df.iloc[[0, 1]] a b c d 0 1 2 3 4 1 100 200 300 400
With a slice object.
>>> df.iloc[:3] a b c d 0 1 2 3 4 1 100 200 300 400 2 1000 2000 3000 4000
With a boolean mask the same length as the index.
>>> df.iloc[[True, False, True]] a b c d 0 1 2 3 4 2 1000 2000 3000 4000
With a callable, useful in method chains. The x passed to the
lambda
is the DataFrame being sliced. This selects the rows whose index label even.>>> df.iloc[lambda x: x.index % 2 == 0] a b c d 0 1 2 3 4 2 1000 2000 3000 4000
Indexing both axes
You can mix the indexer types for the index and columns. Use
:
to select the entire axis.With scalar integers.
>>> df.iloc[0, 1] 2
With lists of integers.
>>> df.iloc[[0, 2], [1, 3]] b d 0 2 4 2 2000 4000
With slice objects.
>>> df.iloc[1:3, 0:3] a b c 1 100 200 300 2 1000 2000 3000
With a boolean array whose length matches the columns.
>>> df.iloc[:, [True, False, True, False]] a c 0 1 3 1 100 300 2 1000 3000
With a callable function that expects the Series or DataFrame.
>>> df.iloc[:, lambda df: [0, 2]] a c 0 1 3 1 100 300 2 1000 3000

index
¶ The index (row labels) of the DataFrame.

infer_objects
() → FrameOrSeries¶ Attempt to infer better dtypes for object columns.
Attempts soft conversion of objectdtyped columns, leaving nonobject and unconvertible columns unchanged. The inference rules are the same as during normal Series/DataFrame construction.
converted : same type as input object
to_datetime : Convert argument to datetime. to_timedelta : Convert argument to timedelta. to_numeric : Convert argument to numeric type. convert_dtypes : Convert argument to best possible dtype.
>>> df = pd.DataFrame({"A": ["a", 1, 2, 3]}) >>> df = df.iloc[1:] >>> df A 1 1 2 2 3 3
>>> df.dtypes A object dtype: object
>>> df.infer_objects().dtypes A int64 dtype: object

info
(verbose=None, buf=None, max_cols=None, memory_usage=None, null_counts=None)¶ Concise summary of a DataFrame.
 verbose{None, True, False}, optional
Whether to print the full summary. None follows the display.max_info_columns setting. True or False overrides the display.max_info_columns setting.
buf : writable buffer, defaults to sys.stdout max_cols : int, default None
Determines whether full summary or short summary is printed. None follows the display.max_info_columns setting.
 memory_usageboolean/string, default None
Specifies whether total memory usage of the DataFrame elements (including index) should be displayed. None follows the display.memory_usage setting. True or False overrides the display.memory_usage setting. A value of ‘deep’ is equivalent of True, with deep introspection. Memory usage is shown in humanreadable units (base2 representation).
 null_countsboolean, default None
Whether to show the nonnull counts
If None, then only show if the frame is smaller than max_info_rows and max_info_columns.
If True, always show counts.
If False, never show counts.

insert
(loc, column, value, allow_duplicates=False) → None¶ Insert column into DataFrame at specified location.
Raises a ValueError if column is already contained in the DataFrame, unless allow_duplicates is set to True.
 locint
Insertion index. Must verify 0 <= loc <= len(columns).
 columnstr, number, or hashable object
Label of the inserted column.
value : int, Series, or arraylike allow_duplicates : bool, optional

interpolate
(method: str = 'linear', axis: Union[str, int] = 0, limit: Optional[int] = None, inplace: bool = False, limit_direction: Optional[str] = None, limit_area: Optional[str] = None, downcast: Optional[str] = None, **kwargs) → Optional[FrameOrSeries]¶ Please note that only
method='linear'
is supported for DataFrame/Series with a MultiIndex. methodstr, default ‘linear’
Interpolation technique to use. One of:
‘linear’: Ignore the index and treat the values as equally spaced. This is the only method supported on MultiIndexes.
‘time’: Works on daily and higher resolution data to interpolate given length of interval.
‘index’, ‘values’: use the actual numerical values of the index.
‘pad’: Fill in NaNs using existing values.
‘nearest’, ‘zero’, ‘slinear’, ‘quadratic’, ‘cubic’, ‘spline’, ‘barycentric’, ‘polynomial’: Passed to scipy.interpolate.interp1d. These methods use the numerical values of the index. Both ‘polynomial’ and ‘spline’ require that you also specify an order (int), e.g.
df.interpolate(method='polynomial', order=5)
.‘krogh’, ‘piecewise_polynomial’, ‘spline’, ‘pchip’, ‘akima’, ‘cubicspline’: Wrappers around the SciPy interpolation methods of similar names. See Notes.
‘from_derivatives’: Refers to scipy.interpolate.BPoly.from_derivatives which replaces ‘piecewise_polynomial’ interpolation method in scipy 0.18.
 axis{{0 or ‘index’, 1 or ‘columns’, None}}, default None
Axis to interpolate along.
 limitint, optional
Maximum number of consecutive NaNs to fill. Must be greater than 0.
 inplacebool, default False
Update the data in place if possible.
 limit_direction{{‘forward’, ‘backward’, ‘both’}}, Optional
Consecutive NaNs will be filled in this direction.
 If limit is specified:
If ‘method’ is ‘pad’ or ‘ffill’, ‘limit_direction’ must be ‘forward’.
If ‘method’ is ‘backfill’ or ‘bfill’, ‘limit_direction’ must be ‘backwards’.
 If ‘limit’ is not specified:
If ‘method’ is ‘backfill’ or ‘bfill’, the default is ‘backward’
else the default is ‘forward’
Changed in version 1.1.0: raises ValueError if limit_direction is ‘forward’ or ‘both’ and method is ‘backfill’ or ‘bfill’. raises ValueError if limit_direction is ‘backward’ or ‘both’ and method is ‘pad’ or ‘ffill’.
 limit_area{{None, ‘inside’, ‘outside’}}, default None
If limit is specified, consecutive NaNs will be filled with this restriction.
None
: No fill restriction.‘inside’: Only fill NaNs surrounded by valid values (interpolate).
‘outside’: Only fill NaNs outside valid values (extrapolate).
New in version 0.23.0.
 downcastoptional, ‘infer’ or None, defaults to None
Downcast dtypes if possible.
 **kwargs
Keyword arguments to pass on to the interpolating function.
 Series or DataFrame
Returns the same object type as the caller, interpolated at some or all
NaN
values.
fillna : Fill missing values using different methods. scipy.interpolate.Akima1DInterpolator : Piecewise cubic polynomials
(Akima interpolator).
 scipy.interpolate.BPoly.from_derivativesPiecewise polynomial in the
Bernstein basis.
scipy.interpolate.interp1d : Interpolate a 1D function. scipy.interpolate.KroghInterpolator : Interpolate polynomial (Krogh
interpolator).
 scipy.interpolate.PchipInterpolatorPCHIP 1d monotonic cubic
interpolation.
scipy.interpolate.CubicSpline : Cubic spline data interpolator.
The ‘krogh’, ‘piecewise_polynomial’, ‘spline’, ‘pchip’ and ‘akima’ methods are wrappers around the respective SciPy implementations of similar names. These use the actual numerical values of the index. For more information on their behavior, see the SciPy documentation and SciPy tutorial.
Filling in
NaN
in aSeries
via linear interpolation.>>> s = pd.Series([0, 1, np.nan, 3]) >>> s 0 0.0 1 1.0 2 NaN 3 3.0 dtype: float64 >>> s.interpolate() 0 0.0 1 1.0 2 2.0 3 3.0 dtype: float64
Filling in
NaN
in a Series by padding, but filling at most two consecutiveNaN
at a time.>>> s = pd.Series([np.nan, "single_one", np.nan, ... "fill_two_more", np.nan, np.nan, np.nan, ... 4.71, np.nan]) >>> s 0 NaN 1 single_one 2 NaN 3 fill_two_more 4 NaN 5 NaN 6 NaN 7 4.71 8 NaN dtype: object >>> s.interpolate(method='pad', limit=2) 0 NaN 1 single_one 2 single_one 3 fill_two_more 4 fill_two_more 5 fill_two_more 6 NaN 7 4.71 8 4.71 dtype: object
Filling in
NaN
in a Series via polynomial interpolation or splines: Both ‘polynomial’ and ‘spline’ methods require that you also specify anorder
(int).>>> s = pd.Series([0, 2, np.nan, 8]) >>> s.interpolate(method='polynomial', order=2) 0 0.000000 1 2.000000 2 4.666667 3 8.000000 dtype: float64
Fill the DataFrame forward (that is, going down) along each column using linear interpolation.
Note how the last entry in column ‘a’ is interpolated differently, because there is no entry after it to use for interpolation. Note how the first entry in column ‘b’ remains
NaN
, because there is no entry before it to use for interpolation.>>> df = pd.DataFrame([(0.0, np.nan, 1.0, 1.0), ... (np.nan, 2.0, np.nan, np.nan), ... (2.0, 3.0, np.nan, 9.0), ... (np.nan, 4.0, 4.0, 16.0)], ... columns=list('abcd')) >>> df a b c d 0 0.0 NaN 1.0 1.0 1 NaN 2.0 NaN NaN 2 2.0 3.0 NaN 9.0 3 NaN 4.0 4.0 16.0 >>> df.interpolate(method='linear', limit_direction='forward', axis=0) a b c d 0 0.0 NaN 1.0 1.0 1 1.0 2.0 2.0 5.0 2 2.0 3.0 3.0 9.0 3 2.0 4.0 4.0 16.0
Using polynomial interpolation.
>>> df['d'].interpolate(method='polynomial', order=2) 0 1.0 1 4.0 2 9.0 3 16.0 Name: d, dtype: float64

intersect
(second_geometry, dimension)¶ Constructs a geometry that is the geometric intersection of the two input geometries. Different dimension values can be used to create different shape types. The intersection of two geometries of the same shape type is a geometry containing only the regions of overlap between the original geometries.
 Paramters:
 second_geometry
a second geometry
 dimension
The topological dimension (shape type) of the
 resulting geometry.
1 A zerodimensional geometry (point or multipoint). 2 A onedimensional geometry (polyline). 4 A twodimensional geometry (polygon).

property
is_empty
¶ Return True for each empty geometry, False for nonempty

property
is_multipart
¶ True, if the number of parts for the geometry is more than 1

isin
(values) → pandas.core.frame.DataFrame¶ Whether each element in the DataFrame is contained in values.
 valuesiterable, Series, DataFrame or dict
The result will only be true at a location if all the labels match. If values is a Series, that’s the index. If values is a dict, the keys must be the column names, which must match. If values is a DataFrame, then both the index and column labels must match.
 DataFrame
DataFrame of booleans showing whether each element in the DataFrame is contained in values.
DataFrame.eq: Equality test for DataFrame. Series.isin: Equivalent method on Series. Series.str.contains: Test if pattern or regex is contained within a
string of a Series or Index.
>>> df = pd.DataFrame({'num_legs': [2, 4], 'num_wings': [2, 0]}, ... index=['falcon', 'dog']) >>> df num_legs num_wings falcon 2 2 dog 4 0
When
values
is a list check whether every value in the DataFrame is present in the list (which animals have 0 or 2 legs or wings)>>> df.isin([0, 2]) num_legs num_wings falcon True True dog False True
When
values
is a dict, we can pass values to check for each column separately:>>> df.isin({'num_wings': [0, 3]}) num_legs num_wings falcon False False dog False True
When
values
is a Series or DataFrame the index and column must match. Note that ‘falcon’ does not match based on the number of legs in df2.>>> other = pd.DataFrame({'num_legs': [8, 2], 'num_wings': [0, 2]}, ... index=['spider', 'falcon']) >>> df.isin(other) num_legs num_wings falcon True True dog False False

isna
() → pandas.core.frame.DataFrame¶ Detect missing values.
Return a boolean samesized object indicating if the values are NA. NA values, such as None or
numpy.NaN
, gets mapped to True values. Everything else gets mapped to False values. Characters such as empty strings''
ornumpy.inf
are not considered NA values (unless you setpandas.options.mode.use_inf_as_na = True
). DataFrame
Mask of bool values for each element in DataFrame that indicates whether an element is not an NA value.
DataFrame.isnull : Alias of isna. DataFrame.notna : Boolean inverse of isna. DataFrame.dropna : Omit axes labels with missing values. isna : Toplevel isna.
Show which entries in a DataFrame are NA.
>>> df = pd.DataFrame({'age': [5, 6, np.NaN], ... 'born': [pd.NaT, pd.Timestamp('19390527'), ... pd.Timestamp('19400425')], ... 'name': ['Alfred', 'Batman', ''], ... 'toy': [None, 'Batmobile', 'Joker']}) >>> df age born name toy 0 5.0 NaT Alfred None 1 6.0 19390527 Batman Batmobile 2 NaN 19400425 Joker
>>> df.isna() age born name toy 0 False True False True 1 False False False False 2 True False False False
Show which entries in a Series are NA.
>>> ser = pd.Series([5, 6, np.NaN]) >>> ser 0 5.0 1 6.0 2 NaN dtype: float64
>>> ser.isna() 0 False 1 False 2 True dtype: bool

isnull
() → pandas.core.frame.DataFrame¶ Detect missing values.
Return a boolean samesized object indicating if the values are NA. NA values, such as None or
numpy.NaN
, gets mapped to True values. Everything else gets mapped to False values. Characters such as empty strings''
ornumpy.inf
are not considered NA values (unless you setpandas.options.mode.use_inf_as_na = True
). DataFrame
Mask of bool values for each element in DataFrame that indicates whether an element is not an NA value.
DataFrame.isnull : Alias of isna. DataFrame.notna : Boolean inverse of isna. DataFrame.dropna : Omit axes labels with missing values. isna : Toplevel isna.
Show which entries in a DataFrame are NA.
>>> df = pd.DataFrame({'age': [5, 6, np.NaN], ... 'born': [pd.NaT, pd.Timestamp('19390527'), ... pd.Timestamp('19400425')], ... 'name': ['Alfred', 'Batman', ''], ... 'toy': [None, 'Batmobile', 'Joker']}) >>> df age born name toy 0 5.0 NaT Alfred None 1 6.0 19390527 Batman Batmobile 2 NaN 19400425 Joker
>>> df.isna() age born name toy 0 False True False True 1 False False False False 2 True False False False
Show which entries in a Series are NA.
>>> ser = pd.Series([5, 6, np.NaN]) >>> ser 0 5.0 1 6.0 2 NaN dtype: float64
>>> ser.isna() 0 False 1 False 2 True dtype: bool

items
() → Iterable[Tuple[collections.abc.Hashable, pandas.core.series.Series]]¶ Iterate over (column name, Series) pairs.
Iterates over the DataFrame columns, returning a tuple with the column name and the content as a Series.
 labelobject
The column names for the DataFrame being iterated over.
 contentSeries
The column entries belonging to each label, as a Series.
 DataFrame.iterrowsIterate over DataFrame rows as
(index, Series) pairs.
 DataFrame.itertuplesIterate over DataFrame rows as namedtuples
of the values.
>>> df = pd.DataFrame({'species': ['bear', 'bear', 'marsupial'], ... 'population': [1864, 22000, 80000]}, ... index=['panda', 'polar', 'koala']) >>> df species population panda bear 1864 polar bear 22000 koala marsupial 80000 >>> for label, content in df.items(): ... print(f'label: {label}') ... print(f'content: {content}', sep='\n') ... label: species content: panda bear polar bear koala marsupial Name: species, dtype: object label: population content: panda 1864 polar 22000 koala 80000 Name: population, dtype: int64

iteritems
() → Iterable[Tuple[collections.abc.Hashable, pandas.core.series.Series]]¶ Iterate over (column name, Series) pairs.
Iterates over the DataFrame columns, returning a tuple with the column name and the content as a Series.
 labelobject
The column names for the DataFrame being iterated over.
 contentSeries
The column entries belonging to each label, as a Series.
 DataFrame.iterrowsIterate over DataFrame rows as
(index, Series) pairs.
 DataFrame.itertuplesIterate over DataFrame rows as namedtuples
of the values.
>>> df = pd.DataFrame({'species': ['bear', 'bear', 'marsupial'], ... 'population': [1864, 22000, 80000]}, ... index=['panda', 'polar', 'koala']) >>> df species population panda bear 1864 polar bear 22000 koala marsupial 80000 >>> for label, content in df.items(): ... print(f'label: {label}') ... print(f'content: {content}', sep='\n') ... label: species content: panda bear polar bear koala marsupial Name: species, dtype: object label: population content: panda 1864 polar 22000 koala 80000 Name: population, dtype: int64

iterrows
() → Iterable[Tuple[collections.abc.Hashable, pandas.core.series.Series]]¶ Iterate over DataFrame rows as (index, Series) pairs.
 indexlabel or tuple of label
The index of the row. A tuple for a MultiIndex.
 dataSeries
The data of the row as a Series.
 itgenerator
A generator that iterates over the rows of the frame.
DataFrame.itertuples : Iterate over DataFrame rows as namedtuples of the values. DataFrame.items : Iterate over (column name, Series) pairs.
Because
iterrows
returns a Series for each row, it does not preserve dtypes across the rows (dtypes are preserved across columns for DataFrames). For example,>>> df = pd.DataFrame([[1, 1.5]], columns=['int', 'float']) >>> row = next(df.iterrows())[1] >>> row int 1.0 float 1.5 Name: 0, dtype: float64 >>> print(row['int'].dtype) float64 >>> print(df['int'].dtype) int64
To preserve dtypes while iterating over the rows, it is better to use
itertuples()
which returns namedtuples of the values and which is generally faster thaniterrows
.You should never modify something you are iterating over. This is not guaranteed to work in all cases. Depending on the data types, the iterator returns a copy and not a view, and writing to it will have no effect.

itertuples
(index=True, name='Pandas')¶ Iterate over DataFrame rows as namedtuples.
 indexbool, default True
If True, return the index as the first element of the tuple.
 namestr or None, default “Pandas”
The name of the returned namedtuples or None to return regular tuples.
 iterator
An object to iterate over namedtuples for each row in the DataFrame with the first field possibly being the index and following fields being the column values.
 DataFrame.iterrowsIterate over DataFrame rows as (index, Series)
pairs.
DataFrame.items : Iterate over (column name, Series) pairs.
The column names will be renamed to positional names if they are invalid Python identifiers, repeated, or start with an underscore. On python versions < 3.7 regular tuples are returned for DataFrames with a large number of columns (>254).
>>> df = pd.DataFrame({'num_legs': [4, 2], 'num_wings': [0, 2]}, ... index=['dog', 'hawk']) >>> df num_legs num_wings dog 4 0 hawk 2 2 >>> for row in df.itertuples(): ... print(row) ... Pandas(Index='dog', num_legs=4, num_wings=0) Pandas(Index='hawk', num_legs=2, num_wings=2)
By setting the index parameter to False we can remove the index as the first element of the tuple:
>>> for row in df.itertuples(index=False): ... print(row) ... Pandas(num_legs=4, num_wings=0) Pandas(num_legs=2, num_wings=2)
With the name parameter set we set a custom name for the yielded namedtuples:
>>> for row in df.itertuples(name='Animal'): ... print(row) ... Animal(Index='dog', num_legs=4, num_wings=0) Animal(Index='hawk', num_legs=2, num_wings=2)

join
(other, on=None, how='left', lsuffix='', rsuffix='', sort=False) → pandas.core.frame.DataFrame¶ Join columns of another DataFrame.
Join columns with other DataFrame either on index or on a key column. Efficiently join multiple DataFrame objects by index at once by passing a list.
 otherDataFrame, Series, or list of DataFrame
Index should be similar to one of the columns in this one. If a Series is passed, its name attribute must be set, and that will be used as the column name in the resulting joined DataFrame.
 onstr, list of str, or arraylike, optional
Column or index level name(s) in the caller to join on the index in other, otherwise joins indexonindex. If multiple values given, the other DataFrame must have a MultiIndex. Can pass an array as the join key if it is not already contained in the calling DataFrame. Like an Excel VLOOKUP operation.
 how{‘left’, ‘right’, ‘outer’, ‘inner’}, default ‘left’
How to handle the operation of the two objects.
left: use calling frame’s index (or column if on is specified)
right: use other’s index.
outer: form union of calling frame’s index (or column if on is specified) with other’s index, and sort it. lexicographically.
inner: form intersection of calling frame’s index (or column if on is specified) with other’s index, preserving the order of the calling’s one.
 lsuffixstr, default ‘’
Suffix to use from left frame’s overlapping columns.
 rsuffixstr, default ‘’
Suffix to use from right frame’s overlapping columns.
 sortbool, default False
Order result DataFrame lexicographically by the join key. If False, the order of the join key depends on the join type (how keyword).
 DataFrame
A dataframe containing columns from both the caller and other.
DataFrame.merge : For column(s)oncolumns(s) operations.
Parameters on, lsuffix, and rsuffix are not supported when passing a list of DataFrame objects.
Support for specifying index levels as the on parameter was added in version 0.23.0.
>>> df = pd.DataFrame({'key': ['K0', 'K1', 'K2', 'K3', 'K4', 'K5'], ... 'A': ['A0', 'A1', 'A2', 'A3', 'A4', 'A5']})
>>> df key A 0 K0 A0 1 K1 A1 2 K2 A2 3 K3 A3 4 K4 A4 5 K5 A5
>>> other = pd.DataFrame({'key': ['K0', 'K1', 'K2'], ... 'B': ['B0', 'B1', 'B2']})
>>> other key B 0 K0 B0 1 K1 B1 2 K2 B2
Join DataFrames using their indexes.
>>> df.join(other, lsuffix='_caller', rsuffix='_other') key_caller A key_other B 0 K0 A0 K0 B0 1 K1 A1 K1 B1 2 K2 A2 K2 B2 3 K3 A3 NaN NaN 4 K4 A4 NaN NaN 5 K5 A5 NaN NaN
If we want to join using the key columns, we need to set key to be the index in both df and other. The joined DataFrame will have key as its index.
>>> df.set_index('key').join(other.set_index('key')) A B key K0 A0 B0 K1 A1 B1 K2 A2 B2 K3 A3 NaN K4 A4 NaN K5 A5 NaN
Another option to join using the key columns is to use the on parameter. DataFrame.join always uses other’s index but we can use any column in df. This method preserves the original DataFrame’s index in the result.
>>> df.join(other.set_index('key'), on='key') key A B 0 K0 A0 B0 1 K1 A1 B1 2 K2 A2 B2 3 K3 A3 NaN 4 K4 A4 NaN 5 K5 A5 NaN

keys
()¶ Get the ‘info axis’ (see Indexing for more).
This is index for Series, columns for DataFrame.
 Index
Info axis.

kurt
(axis=None, skipna=None, level=None, numeric_only=None, **kwargs)¶ Return unbiased kurtosis over requested axis.
Kurtosis obtained using Fisher’s definition of kurtosis (kurtosis of normal == 0.0). Normalized by N1.
 axis{index (0), columns (1)}
Axis for the function to be applied on.
 skipnabool, default True
Exclude NA/null values when computing the result.
 levelint or level name, default None
If the axis is a MultiIndex (hierarchical), count along a particular level, collapsing into a Series.
 numeric_onlybool, default None
Include only float, int, boolean columns. If None, will attempt to use everything, then use only numeric data. Not implemented for Series.
 **kwargs
Additional keyword arguments to be passed to the function.
Series or DataFrame (if level specified)

kurtosis
(axis=None, skipna=None, level=None, numeric_only=None, **kwargs)¶ Return unbiased kurtosis over requested axis.
Kurtosis obtained using Fisher’s definition of kurtosis (kurtosis of normal == 0.0). Normalized by N1.
 axis{index (0), columns (1)}
Axis for the function to be applied on.
 skipnabool, default True
Exclude NA/null values when computing the result.
 levelint or level name, default None
If the axis is a MultiIndex (hierarchical), count along a particular level, collapsing into a Series.
 numeric_onlybool, default None
Include only float, int, boolean columns. If None, will attempt to use everything, then use only numeric data. Not implemented for Series.
 **kwargs
Additional keyword arguments to be passed to the function.
Series or DataFrame (if level specified)

property
label_point
¶ The point at which the label is located. The labelPoint is always located within or on a feature.

last
(offset) → FrameOrSeries¶ Select final periods of time series data based on a date offset.
When having a DataFrame with dates as index, this function can select the last few rows based on a date offset.
 offsetstr, DateOffset, dateutil.relativedelta
The offset length of the data that will be selected. For instance, ‘3D’ will display all the rows having their index within the last 3 days.
 Series or DataFrame
A subset of the caller.
 TypeError
If the index is not a
DatetimeIndex
first : Select initial periods of time series based on a date offset. at_time : Select values at a particular time of the day. between_time : Select values between particular times of the day.
>>> i = pd.date_range('20180409', periods=4, freq='2D') >>> ts = pd.DataFrame({'A': [1, 2, 3, 4]}, index=i) >>> ts A 20180409 1 20180411 2 20180413 3 20180415 4
Get the rows for the last 3 days:
>>> ts.last('3D') A 20180413 3 20180415 4
Notice the data for 3 last calendar days were returned, not the last 3 observed days in the dataset, and therefore data for 20180411 was not returned.

property
last_point
¶ The last coordinate of the feature.

last_valid_index
()¶ Return index for last nonNA/null value.
scalar : type of index
If all elements are nonNA/null, returns None. Also returns None for empty Series/DataFrame.

le
(other, axis='columns', level=None)¶ Get Less than or equal to of dataframe and other, elementwise (binary operator le).
Among flexible wrappers (eq, ne, le, lt, ge, gt) to comparison operators.
Equivalent to ==, =!, <=, <, >=, > with support to choose axis (rows or columns) and level for comparison.
 otherscalar, sequence, Series, or DataFrame
Any single or multiple element data structure, or listlike object.
 axis{0 or ‘index’, 1 or ‘columns’}, default ‘columns’
Whether to compare by the index (0 or ‘index’) or columns (1 or ‘columns’).
 levelint or label
Broadcast across a level, matching Index values on the passed MultiIndex level.
 DataFrame of bool
Result of the comparison.
DataFrame.eq : Compare DataFrames for equality elementwise. DataFrame.ne : Compare DataFrames for inequality elementwise. DataFrame.le : Compare DataFrames for less than inequality
or equality elementwise.
 DataFrame.ltCompare DataFrames for strictly less than
inequality elementwise.
 DataFrame.geCompare DataFrames for greater than inequality
or equality elementwise.
 DataFrame.gtCompare DataFrames for strictly greater than
inequality elementwise.
Mismatched indices will be unioned together. NaN values are considered different (i.e. NaN != NaN).
>>> df = pd.DataFrame({'cost': [250, 150, 100], ... 'revenue': [100, 250, 300]}, ... index=['A', 'B', 'C']) >>> df cost revenue A 250 100 B 150 250 C 100 300
Comparison with a scalar, using either the operator or method:
>>> df == 100 cost revenue A False True B False False C True False
>>> df.eq(100) cost revenue A False True B False False C True False
When other is a
Series
, the columns of a DataFrame are aligned with the index of other and broadcast:>>> df != pd.Series([100, 250], index=["cost", "revenue"]) cost revenue A True True B True False C False True
Use the method to control the broadcast axis:
>>> df.ne(pd.Series([100, 300], index=["A", "D"]), axis='index') cost revenue A True False B True True C True True D True True
When comparing to an arbitrary sequence, the number of columns must match the number elements in other:
>>> df == [250, 100] cost revenue A True True B False False C False False
Use the method to control the axis:
>>> df.eq([250, 250, 100], axis='index') cost revenue A True False B False True C True False
Compare to a DataFrame of different shape.
>>> other = pd.DataFrame({'revenue': [300, 250, 100, 150]}, ... index=['A', 'B', 'C', 'D']) >>> other revenue A 300 B 250 C 100 D 150
>>> df.gt(other) cost revenue A False False B False False C False True D False False
Compare to a MultiIndex by level.
>>> df_multindex = pd.DataFrame({'cost': [250, 150, 100, 150, 300, 220], ... 'revenue': [100, 250, 300, 200, 175, 225]}, ... index=[['Q1', 'Q1', 'Q1', 'Q2', 'Q2', 'Q2'], ... ['A', 'B', 'C', 'A', 'B', 'C']]) >>> df_multindex cost revenue Q1 A 250 100 B 150 250 C 100 300 Q2 A 150 200 B 300 175 C 220 225
>>> df.le(df_multindex, level=1) cost revenue Q1 A True True B True True C True True Q2 A False True B True False C True False

property
length
¶ The length of the linear feature. Zero for point and multipoint feature types.

property
length3D
¶ The 3D length of the linear feature. Zero for point and multipoint feature types.

property
loc
¶ Access a group of rows and columns by label(s) or a boolean array.
.loc[]
is primarily label based, but may also be used with a boolean array.Allowed inputs are:
A single label, e.g.
5
or'a'
, (note that5
is interpreted as a label of the index, and never as an integer position along the index).A list or array of labels, e.g.
['a', 'b', 'c']
.A slice object with labels, e.g.
'a':'f'
.Warning
Note that contrary to usual python slices, both the start and the stop are included
A boolean array of the same length as the axis being sliced, e.g.
[True, False, True]
.A
callable
function with one argument (the calling Series or DataFrame) and that returns valid output for indexing (one of the above)
See more at Selection by Label
 KeyError
If any items are not found.
DataFrame.at : Access a single value for a row/column label pair. DataFrame.iloc : Access group of rows and columns by integer position(s). DataFrame.xs : Returns a crosssection (row(s) or column(s)) from the
Series/DataFrame.
Series.loc : Access group of values using labels.
Getting values
>>> df = pd.DataFrame([[1, 2], [4, 5], [7, 8]], ... index=['cobra', 'viper', 'sidewinder'], ... columns=['max_speed', 'shield']) >>> df max_speed shield cobra 1 2 viper 4 5 sidewinder 7 8
Single label. Note this returns the row as a Series.
>>> df.loc['viper'] max_speed 4 shield 5 Name: viper, dtype: int64
List of labels. Note using
[[]]
returns a DataFrame.>>> df.loc[['viper', 'sidewinder']] max_speed shield viper 4 5 sidewinder 7 8
Single label for row and column
>>> df.loc['cobra', 'shield'] 2
Slice with labels for row and single label for column. As mentioned above, note that both the start and stop of the slice are included.
>>> df.loc['cobra':'viper', 'max_speed'] cobra 1 viper 4 Name: max_speed, dtype: int64
Boolean list with the same length as the row axis
>>> df.loc[[False, False, True]] max_speed shield sidewinder 7 8
Conditional that returns a boolean Series
>>> df.loc[df['shield'] > 6] max_speed shield sidewinder 7 8
Conditional that returns a boolean Series with column labels specified
>>> df.loc[df['shield'] > 6, ['max_speed']] max_speed sidewinder 7
Callable that returns a boolean Series
>>> df.loc[lambda df: df['shield'] == 8] max_speed shield sidewinder 7 8
Setting values
Set value for all items matching the list of labels
>>> df.loc[['viper', 'sidewinder'], ['shield']] = 50 >>> df max_speed shield cobra 1 2 viper 4 50 sidewinder 7 50
Set value for an entire row
>>> df.loc['cobra'] = 10 >>> df max_speed shield cobra 10 10 viper 4 50 sidewinder 7 50
Set value for an entire column
>>> df.loc[:, 'max_speed'] = 30 >>> df max_speed shield cobra 30 10 viper 30 50 sidewinder 30 50
Set value for rows matching callable condition
>>> df.loc[df['shield'] > 35] = 0 >>> df max_speed shield cobra 30 10 viper 0 0 sidewinder 0 0
Getting values on a DataFrame with an index that has integer labels
Another example using integers for the index
>>> df = pd.DataFrame([[1, 2], [4, 5], [7, 8]], ... index=[7, 8, 9], columns=['max_speed', 'shield']) >>> df max_speed shield 7 1 2 8 4 5 9 7 8
Slice with integer labels for rows. As mentioned above, note that both the start and stop of the slice are included.
>>> df.loc[7:9] max_speed shield 7 1 2 8 4 5 9 7 8
Getting values with a MultiIndex
A number of examples using a DataFrame with a MultiIndex
>>> tuples = [ ... ('cobra', 'mark i'), ('cobra', 'mark ii'), ... ('sidewinder', 'mark i'), ('sidewinder', 'mark ii'), ... ('viper', 'mark ii'), ('viper', 'mark iii') ... ] >>> index = pd.MultiIndex.from_tuples(tuples) >>> values = [[12, 2], [0, 4], [10, 20], ... [1, 4], [7, 1], [16, 36]] >>> df = pd.DataFrame(values, columns=['max_speed', 'shield'], index=index) >>> df max_speed shield cobra mark i 12 2 mark ii 0 4 sidewinder mark i 10 20 mark ii 1 4 viper mark ii 7 1 mark iii 16 36
Single label. Note this returns a DataFrame with a single index.
>>> df.loc['cobra'] max_speed shield mark i 12 2 mark ii 0 4
Single index tuple. Note this returns a Series.
>>> df.loc[('cobra', 'mark ii')] max_speed 0 shield 4 Name: (cobra, mark ii), dtype: int64
Single label for row and column. Similar to passing in a tuple, this returns a Series.
>>> df.loc['cobra', 'mark i'] max_speed 12 shield 2 Name: (cobra, mark i), dtype: int64
Single tuple. Note using
[[]]
returns a DataFrame.>>> df.loc[[('cobra', 'mark ii')]] max_speed shield cobra mark ii 0 4
Single tuple for the index with a single label for the column
>>> df.loc[('cobra', 'mark i'), 'shield'] 2
Slice from index tuple to single label
>>> df.loc[('cobra', 'mark i'):'viper'] max_speed shield cobra mark i 12 2 mark ii 0 4 sidewinder mark i 10 20 mark ii 1 4 viper mark ii 7 1 mark iii 16 36
Slice from index tuple to index tuple
>>> df.loc[('cobra', 'mark i'):('viper', 'mark ii')] max_speed shield cobra mark i 12 2 mark ii 0 4 sidewinder mark i 10 20 mark ii 1 4 viper mark ii 7 1

lookup
(row_labels, col_labels) → numpy.ndarray¶ Labelbased “fancy indexing” function for DataFrame.
Given equallength arrays of row and column labels, return an array of the values corresponding to each (row, col) pair.
 row_labelssequence
The row labels to use for lookup.
 col_labelssequence
The column labels to use for lookup.
 numpy.ndarray
The found values.

lt
(other, axis='columns', level=None)¶ Get Less than of dataframe and other, elementwise (binary operator lt).
Among flexible wrappers (eq, ne, le, lt, ge, gt) to comparison operators.
Equivalent to ==, =!, <=, <, >=, > with support to choose axis (rows or columns) and level for comparison.
 otherscalar, sequence, Series, or DataFrame
Any single or multiple element data structure, or listlike object.
 axis{0 or ‘index’, 1 or ‘columns’}, default ‘columns’
Whether to compare by the index (0 or ‘index’) or columns (1 or ‘columns’).
 levelint or label
Broadcast across a level, matching Index values on the passed MultiIndex level.
 DataFrame of bool
Result of the comparison.
DataFrame.eq : Compare DataFrames for equality elementwise. DataFrame.ne : Compare DataFrames for inequality elementwise. DataFrame.le : Compare DataFrames for less than inequality
or equality elementwise.
 DataFrame.ltCompare DataFrames for strictly less than
inequality elementwise.
 DataFrame.geCompare DataFrames for greater than inequality
or equality elementwise.
 DataFrame.gtCompare DataFrames for strictly greater than
inequality elementwise.
Mismatched indices will be unioned together. NaN values are considered different (i.e. NaN != NaN).
>>> df = pd.DataFrame({'cost': [250, 150, 100], ... 'revenue': [100, 250, 300]}, ... index=['A', 'B', 'C']) >>> df cost revenue A 250 100 B 150 250 C 100 300
Comparison with a scalar, using either the operator or method:
>>> df == 100 cost revenue A False True B False False C True False
>>> df.eq(100) cost revenue A False True B False False C True False
When other is a
Series
, the columns of a DataFrame are aligned with the index of other and broadcast:>>> df != pd.Series([100, 250], index=["cost", "revenue"]) cost revenue A True True B True False C False True
Use the method to control the broadcast axis:
>>> df.ne(pd.Series([100, 300], index=["A", "D"]), axis='index') cost revenue A True False B True True C True True D True True
When comparing to an arbitrary sequence, the number of columns must match the number elements in other:
>>> df == [250, 100] cost revenue A True True B False False C False False
Use the method to control the axis:
>>> df.eq([250, 250, 100], axis='index') cost revenue A True False B False True C True False
Compare to a DataFrame of different shape.
>>> other = pd.DataFrame({'revenue': [300, 250, 100, 150]}, ... index=['A', 'B', 'C', 'D']) >>> other revenue A 300 B 250 C 100 D 150
>>> df.gt(other) cost revenue A False False B False False C False True D False False
Compare to a MultiIndex by level.
>>> df_multindex = pd.DataFrame({'cost': [250, 150, 100, 150, 300, 220], ... 'revenue': [100, 250, 300, 200, 175, 225]}, ... index=[['Q1', 'Q1', 'Q1', 'Q2', 'Q2', 'Q2'], ... ['A', 'B', 'C', 'A', 'B', 'C']]) >>> df_multindex cost revenue Q1 A 250 100 B 150 250 C 100 300 Q2 A 150 200 B 300 175 C 220 225
>>> df.le(df_multindex, level=1) cost revenue Q1 A True True B True True C True True Q2 A False True B True False C True False

mad
(axis=None, skipna=None, level=None)¶ Return the mean absolute deviation of the values for the requested axis.
 axis{index (0), columns (1)}
Axis for the function to be applied on.
 skipnabool, default None
Exclude NA/null values when computing the result.
 levelint or level name, default None
If the axis is a MultiIndex (hierarchical), count along a particular level, collapsing into a Series.
Series or DataFrame (if level specified)

mask
(cond, other=nan, inplace=False, axis=None, level=None, errors='raise', try_cast=False)¶ Replace values where the condition is True.
 condbool Series/DataFrame, arraylike, or callable
Where cond is False, keep the original value. Where True, replace with corresponding value from other. If cond is callable, it is computed on the Series/DataFrame and should return boolean Series/DataFrame or array. The callable must not change input Series/DataFrame (though pandas doesn’t check it).
 otherscalar, Series/DataFrame, or callable
Entries where cond is True are replaced with corresponding value from other. If other is callable, it is computed on the Series/DataFrame and should return scalar or Series/DataFrame. The callable must not change input Series/DataFrame (though pandas doesn’t check it).
 inplacebool, default False
Whether to perform the operation in place on the data.
 axisint, default None
Alignment axis if needed.
 levelint, default None
Alignment level if needed.
 errorsstr, {‘raise’, ‘ignore’}, default ‘raise’
Note that currently this parameter won’t affect the results and will always coerce to a suitable dtype.
‘raise’ : allow exceptions to be raised.
‘ignore’ : suppress exceptions. On error return original object.
 try_castbool, default False
Try to cast the result back to the input type (if possible).
Same type as caller
DataFrame.where()
Return an object of same shape asself.
The mask method is an application of the ifthen idiom. For each element in the calling DataFrame, if
cond
isFalse
the element is used; otherwise the corresponding element from the DataFrameother
is used.The signature for
DataFrame.where()
differs fromnumpy.where()
. Roughlydf1.where(m, df2)
is equivalent tonp.where(m, df1, df2)
.For further details and examples see the
mask
documentation in indexing.>>> s = pd.Series(range(5)) >>> s.where(s > 0) 0 NaN 1 1.0 2 2.0 3 3.0 4 4.0 dtype: float64
>>> s.mask(s > 0) 0 0.0 1 NaN 2 NaN 3 NaN 4 NaN dtype: float64
>>> s.where(s > 1, 10) 0 10 1 10 2 2 3 3 4 4 dtype: int64
>>> df = pd.DataFrame(np.arange(10).reshape(1, 2), columns=['A', 'B']) >>> df A B 0 0 1 1 2 3 2 4 5 3 6 7 4 8 9 >>> m = df % 3 == 0 >>> df.where(m, df) A B 0 0 1 1 2 3 2 4 5 3 6 7 4 8 9 >>> df.where(m, df) == np.where(m, df, df) A B 0 True True 1 True True 2 True True 3 True True 4 True True >>> df.where(m, df) == df.mask(~m, df) A B 0 True True 1 True True 2 True True 3 True True 4 True True

max
(axis=None, skipna=None, level=None, numeric_only=None, **kwargs)¶ Return the maximum of the values for the requested axis.
If you want the index of the maximum, use
idxmax
. This isthe equivalent of thenumpy.ndarray
methodargmax
. axis{index (0), columns (1)}
Axis for the function to be applied on.
 skipnabool, default True
Exclude NA/null values when computing the result.
 levelint or level name, default None
If the axis is a MultiIndex (hierarchical), count along a particular level, collapsing into a Series.
 numeric_onlybool, default None
Include only float, int, boolean columns. If None, will attempt to use everything, then use only numeric data. Not implemented for Series.
 **kwargs
Additional keyword arguments to be passed to the function.
Series or DataFrame (if level specified)
Series.sum : Return the sum. Series.min : Return the minimum. Series.max : Return the maximum. Series.idxmin : Return the index of the minimum. Series.idxmax : Return the index of the maximum. DataFrame.sum : Return the sum over the requested axis. DataFrame.min : Return the minimum over the requested axis. DataFrame.max : Return the maximum over the requested axis. DataFrame.idxmin : Return the index of the minimum over the requested axis. DataFrame.idxmax : Return the index of the maximum over the requested axis.
>>> idx = pd.MultiIndex.from_arrays([ ... ['warm', 'warm', 'cold', 'cold'], ... ['dog', 'falcon', 'fish', 'spider']], ... names=['blooded', 'animal']) >>> s = pd.Series([4, 2, 0, 8], name='legs', index=idx) >>> s blooded animal warm dog 4 falcon 2 cold fish 0 spider 8 Name: legs, dtype: int64
>>> s.max() 8
Max using level names, as well as indices.
>>> s.max(level='blooded') blooded warm 4 cold 8 Name: legs, dtype: int64
>>> s.max(level=0) blooded warm 4 cold 8 Name: legs, dtype: int64

mean
(axis=None, skipna=None, level=None, numeric_only=None, **kwargs)¶ Return the mean of the values for the requested axis.
 axis{index (0), columns (1)}
Axis for the function to be applied on.
 skipnabool, default True
Exclude NA/null values when computing the result.
 levelint or level name, default None
If the axis is a MultiIndex (hierarchical), count along a particular level, collapsing into a Series.
 numeric_onlybool, default None
Include only float, int, boolean columns. If None, will attempt to use everything, then use only numeric data. Not implemented for Series.
 **kwargs
Additional keyword arguments to be passed to the function.
Series or DataFrame (if level specified)

measure_on_line
(second_geometry, as_percentage=False)¶ Returns a measure from the start point of this line to the in_point.
 Paramters:
 second_geometry
a second geometry
 as_percentage
If False, the measure will be returned as a
distance; if True, the measure will be returned as a percentage.

median
(axis=None, skipna=None, level=None, numeric_only=None, **kwargs)¶ Return the median of the values for the requested axis.
 axis{index (0), columns (1)}
Axis for the function to be applied on.
 skipnabool, default True
Exclude NA/null values when computing the result.
 levelint or level name, default None
If the axis is a MultiIndex (hierarchical), count along a particular level, collapsing into a Series.
 numeric_onlybool, default None
Include only float, int, boolean columns. If None, will attempt to use everything, then use only numeric data. Not implemented for Series.
 **kwargs
Additional keyword arguments to be passed to the function.
Series or DataFrame (if level specified)

melt
(id_vars=None, value_vars=None, var_name=None, value_name='value', col_level=None, ignore_index=True) → pandas.core.frame.DataFrame¶ Unpivot a DataFrame from wide to long format, optionally leaving identifiers set.
This function is useful to massage a DataFrame into a format where one or more columns are identifier variables (id_vars), while all other columns, considered measured variables (value_vars), are “unpivoted” to the row axis, leaving just two nonidentifier columns, ‘variable’ and ‘value’.
New in version 0.20.0.
 id_varstuple, list, or ndarray, optional
Column(s) to use as identifier variables.
 value_varstuple, list, or ndarray, optional
Column(s) to unpivot. If not specified, uses all columns that are not set as id_vars.
 var_namescalar
Name to use for the ‘variable’ column. If None it uses
frame.columns.name
or ‘variable’. value_namescalar, default ‘value’
Name to use for the ‘value’ column.
 col_levelint or str, optional
If columns are a MultiIndex then use this level to melt.
 ignore_indexbool, default True
If True, original index is ignored. If False, the original index is retained. Index labels will be repeated as necessary.
New in version 1.1.0.
 DataFrame
Unpivoted DataFrame.
melt : Identical method. pivot_table : Create a spreadsheetstyle pivot table as a DataFrame. DataFrame.pivot : Return reshaped DataFrame organized
by given index / column values.
 DataFrame.explodeExplode a DataFrame from listlike
columns to long format.
>>> df = pd.DataFrame({'A': {0: 'a', 1: 'b', 2: 'c'}, ... 'B': {0: 1, 1: 3, 2: 5}, ... 'C': {0: 2, 1: 4, 2: 6}}) >>> df A B C 0 a 1 2 1 b 3 4 2 c 5 6
>>> df.melt(id_vars=['A'], value_vars=['B']) A variable value 0 a B 1 1 b B 3 2 c B 5
>>> df.melt(id_vars=['A'], value_vars=['B', 'C']) A variable value 0 a B 1 1 b B 3 2 c B 5 3 a C 2 4 b C 4 5 c C 6
The names of ‘variable’ and ‘value’ columns can be customized:
>>> df.melt(id_vars=['A'], value_vars=['B'], ... var_name='myVarname', value_name='myValname') A myVarname myValname 0 a B 1 1 b B 3 2 c B 5
Original index values can be kept around:
>>> df.melt(id_vars=['A'], value_vars=['B', 'C'], ignore_index=False) A variable value 0 a B 1 1 b B 3 2 c B 5 0 a C 2 1 b C 4 2 c C 6
If you have multiindex columns:
>>> df.columns = [list('ABC'), list('DEF')] >>> df A B C D E F 0 a 1 2 1 b 3 4 2 c 5 6
>>> df.melt(col_level=0, id_vars=['A'], value_vars=['B']) A variable value 0 a B 1 1 b B 3 2 c B 5
>>> df.melt(id_vars=[('A', 'D')], value_vars=[('B', 'E')]) (A, D) variable_0 variable_1 value 0 a B E 1 1 b B E 3 2 c B E 5

memory_usage
(index=True, deep=False) → pandas.core.series.Series¶ Return the memory usage of each column in bytes.
The memory usage can optionally include the contribution of the index and elements of object dtype.
This value is displayed in DataFrame.info by default. This can be suppressed by setting
pandas.options.display.memory_usage
to False. indexbool, default True
Specifies whether to include the memory usage of the DataFrame’s index in returned Series. If
index=True
, the memory usage of the index is the first item in the output. deepbool, default False
If True, introspect the data deeply by interrogating object dtypes for systemlevel memory consumption, and include it in the returned values.
 Series
A Series whose index is the original column names and whose values is the memory usage of each column in bytes.
 numpy.ndarray.nbytesTotal bytes consumed by the elements of an
ndarray.
Series.memory_usage : Bytes consumed by a Series. Categorical : Memoryefficient array for string values with
many repeated values.
DataFrame.info : Concise summary of a DataFrame.
>>> dtypes = ['int64', 'float64', 'complex128', 'object', 'bool'] >>> data = dict([(t, np.ones(shape=5000).astype(t)) ... for t in dtypes]) >>> df = pd.DataFrame(data) >>> df.head() int64 float64 complex128 object bool 0 1 1.0 1.000000+0.000000j 1 True 1 1 1.0 1.000000+0.000000j 1 True 2 1 1.0 1.000000+0.000000j 1 True 3 1 1.0 1.000000+0.000000j 1 True 4 1 1.0 1.000000+0.000000j 1 True
>>> df.memory_usage() Index 128 int64 40000 float64 40000 complex128 80000 object 40000 bool 5000 dtype: int64
>>> df.memory_usage(index=False) int64 40000 float64 40000 complex128 80000 object 40000 bool 5000 dtype: int64
The memory footprint of object dtype columns is ignored by default:
>>> df.memory_usage(deep=True) Index 128 int64 40000 float64 40000 complex128 80000 object 160000 bool 5000 dtype: int64
Use a Categorical for efficient storage of an objectdtype column with many repeated values.
>>> df['object'].astype('category').memory_usage(deep=True) 5216

merge
(right, how='inner', on=None, left_on=None, right_on=None, left_index=False, right_index=False, sort=False, suffixes=('_x', '_y'), copy=True, indicator=False, validate=None) → pandas.core.frame.DataFrame¶ Merge DataFrame or named Series objects with a databasestyle join.
The join is done on columns or indexes. If joining columns on columns, the DataFrame indexes will be ignored. Otherwise if joining indexes on indexes or indexes on a column or columns, the index will be passed on.
 rightDataFrame or named Series
Object to merge with.
 how{‘left’, ‘right’, ‘outer’, ‘inner’}, default ‘inner’
Type of merge to be performed.
left: use only keys from left frame, similar to a SQL left outer join; preserve key order.
right: use only keys from right frame, similar to a SQL right outer join; preserve key order.
outer: use union of keys from both frames, similar to a SQL full outer join; sort keys lexicographically.
inner: use intersection of keys from both frames, similar to a SQL inner join; preserve the order of the left keys.
 onlabel or list
Column or index level names to join on. These must be found in both DataFrames. If on is None and not merging on indexes then this defaults to the intersection of the columns in both DataFrames.
 left_onlabel or list, or arraylike
Column or index level names to join on in the left DataFrame. Can also be an array or list of arrays of the length of the left DataFrame. These arrays are treated as if they are columns.
 right_onlabel or list, or arraylike
Column or index level names to join on in the right DataFrame. Can also be an array or list of arrays of the length of the right DataFrame. These arrays are treated as if they are columns.
 left_indexbool, default False
Use the index from the left DataFrame as the join key(s). If it is a MultiIndex, the number of keys in the other DataFrame (either the index or a number of columns) must match the number of levels.
 right_indexbool, default False
Use the index from the right DataFrame as the join key. Same caveats as left_index.
 sortbool, default False
Sort the join keys lexicographically in the result DataFrame. If False, the order of the join keys depends on the join type (how keyword).
 suffixeslistlike, default is (“_x”, “_y”)
A length2 sequence where each element is optionally a string indicating the suffix to add to overlapping column names in left and right respectively. Pass a value of None instead of a string to indicate that the column name from left or right should be left asis, with no suffix. At least one of the values must not be None.
 copybool, default True
If False, avoid copy if possible.
 indicatorbool or str, default False
If True, adds a column to the output DataFrame called “_merge” with information on the source of each row. The column can be given a different name by providing a string argument. The column will have a Categorical type with the value of “left_only” for observations whose merge key only appears in the left DataFrame, “right_only” for observations whose merge key only appears in the right DataFrame, and “both” if the observation’s merge key is found in both DataFrames.
 validatestr, optional
If specified, checks if merge is of specified type.
“one_to_one” or “1:1”: check if merge keys are unique in both left and right datasets.
“one_to_many” or “1:m”: check if merge keys are unique in left dataset.
“many_to_one” or “m:1”: check if merge keys are unique in right dataset.
“many_to_many” or “m:m”: allowed, but does not result in checks.
 DataFrame
A DataFrame of the two merged objects.
merge_ordered : Merge with optional filling/interpolation. merge_asof : Merge on nearest keys. DataFrame.join : Similar method using indices.
Support for specifying index levels as the on, left_on, and right_on parameters was added in version 0.23.0 Support for merging named Series objects was added in version 0.24.0
>>> df1 = pd.DataFrame({'lkey': ['foo', 'bar', 'baz', 'foo'], ... 'value': [1, 2, 3, 5]}) >>> df2 = pd.DataFrame({'rkey': ['foo', 'bar', 'baz', 'foo'], ... 'value': [5, 6, 7, 8]}) >>> df1 lkey value 0 foo 1 1 bar 2 2 baz 3 3 foo 5 >>> df2 rkey value 0 foo 5 1 bar 6 2 baz 7 3 foo 8
Merge df1 and df2 on the lkey and rkey columns. The value columns have the default suffixes, _x and _y, appended.
>>> df1.merge(df2, left_on='lkey', right_on='rkey') lkey value_x rkey value_y 0 foo 1 foo 5 1 foo 1 foo 8 2 foo 5 foo 5 3 foo 5 foo 8 4 bar 2 bar 6 5 baz 3 baz 7
Merge DataFrames df1 and df2 with specified left and right suffixes appended to any overlapping columns.
>>> df1.merge(df2, left_on='lkey', right_on='rkey', ... suffixes=('_left', '_right')) lkey value_left rkey value_right 0 foo 1 foo 5 1 foo 1 foo 8 2 foo 5 foo 5 3 foo 5 foo 8 4 bar 2 bar 6 5 baz 3 baz 7
Merge DataFrames df1 and df2, but raise an exception if the DataFrames have any overlapping columns.
>>> df1.merge(df2, left_on='lkey', right_on='rkey', suffixes=(False, False)) Traceback (most recent call last): ... ValueError: columns overlap but no suffix specified: Index(['value'], dtype='object')

merge_datasets
(other)¶ This operation combines two dataframes into one new DataFrame. If the operation is combining two SpatialDataFrames, the geometry_type must match.
Argument
Description
other
Required SpatialDataFrame. Another SpatialDataFrame to combine.
 Returns
SpatialDataFrame

min
(axis=None, skipna=None, level=None, numeric_only=None, **kwargs)¶ Return the minimum of the values for the requested axis.
If you want the index of the minimum, use
idxmin
. This isthe equivalent of thenumpy.ndarray
methodargmin
. axis{index (0), columns (1)}
Axis for the function to be applied on.
 skipnabool, default True
Exclude NA/null values when computing the result.
 levelint or level name, default None
If the axis is a MultiIndex (hierarchical), count along a particular level, collapsing into a Series.
 numeric_onlybool, default None
Include only float, int, boolean columns. If None, will attempt to use everything, then use only numeric data. Not implemented for Series.
 **kwargs
Additional keyword arguments to be passed to the function.
Series or DataFrame (if level specified)
Series.sum : Return the sum. Series.min : Return the minimum. Series.max : Return the maximum. Series.idxmin : Return the index of the minimum. Series.idxmax : Return the index of the maximum. DataFrame.sum : Return the sum over the requested axis. DataFrame.min : Return the minimum over the requested axis. DataFrame.max : Return the maximum over the requested axis. DataFrame.idxmin : Return the index of the minimum over the requested axis. DataFrame.idxmax : Return the index of the maximum over the requested axis.
>>> idx = pd.MultiIndex.from_arrays([ ... ['warm', 'warm', 'cold', 'cold'], ... ['dog', 'falcon', 'fish', 'spider']], ... names=['blooded', 'animal']) >>> s = pd.Series([4, 2, 0, 8], name='legs', index=idx) >>> s blooded animal warm dog 4 falcon 2 cold fish 0 spider 8 Name: legs, dtype: int64
>>> s.min() 0
Min using level names, as well as indices.
>>> s.min(level='blooded') blooded warm 2 cold 0 Name: legs, dtype: int64
>>> s.min(level=0) blooded warm 2 cold 0 Name: legs, dtype: int64

mod
(other, axis='columns', level=None, fill_value=None)¶ Get Modulo of dataframe and other, elementwise (binary operator mod).
Equivalent to
dataframe % other
, but with support to substitute a fill_value for missing data in one of the inputs. With reverse version, rmod.Among flexible wrappers (add, sub, mul, div, mod, pow) to arithmetic operators: +, , *, /, //, %, **.
 otherscalar, sequence, Series, or DataFrame
Any single or multiple element data structure, or listlike object.
 axis{0 or ‘index’, 1 or ‘columns’}
Whether to compare by the index (0 or ‘index’) or columns (1 or ‘columns’). For Series input, axis to match Series index on.
 levelint or label
Broadcast across a level, matching Index values on the passed MultiIndex level.
 fill_valuefloat or None, default None
Fill existing missing (NaN) values, and any new element needed for successful DataFrame alignment, with this value before computation. If data in both corresponding DataFrame locations is missing the result will be missing.
 DataFrame
Result of the arithmetic operation.
DataFrame.add : Add DataFrames. DataFrame.sub : Subtract DataFrames. DataFrame.mul : Multiply DataFrames. DataFrame.div : Divide DataFrames (float division). DataFrame.truediv : Divide DataFrames (float division). DataFrame.floordiv : Divide DataFrames (integer division). DataFrame.mod : Calculate modulo (remainder after division). DataFrame.pow : Calculate exponential power.
Mismatched indices will be unioned together.
>>> df = pd.DataFrame({'angles': [0, 3, 4], ... 'degrees': [360, 180, 360]}, ... index=['circle', 'triangle', 'rectangle']) >>> df angles degrees circle 0 360 triangle 3 180 rectangle 4 360
Add a scalar with operator version which return the same results.
>>> df + 1 angles degrees circle 1 361 triangle 4 181 rectangle 5 361
>>> df.add(1) angles degrees circle 1 361 triangle 4 181 rectangle 5 361
Divide by constant with reverse version.
>>> df.div(10) angles degrees circle 0.0 36.0 triangle 0.3 18.0 rectangle 0.4 36.0
>>> df.rdiv(10) angles degrees circle inf 0.027778 triangle 3.333333 0.055556 rectangle 2.500000 0.027778
Subtract a list and Series by axis with operator version.
>>> df  [1, 2] angles degrees circle 1 358 triangle 2 178 rectangle 3 358
>>> df.sub([1, 2], axis='columns') angles degrees circle 1 358 triangle 2 178 rectangle 3 358
>>> df.sub(pd.Series([1, 1, 1], index=['circle', 'triangle', 'rectangle']), ... axis='index') angles degrees circle 1 359 triangle 2 179 rectangle 3 359
Multiply a DataFrame of different shape with operator version.
>>> other = pd.DataFrame({'angles': [0, 3, 4]}, ... index=['circle', 'triangle', 'rectangle']) >>> other angles circle 0 triangle 3 rectangle 4
>>> df * other angles degrees circle 0 NaN triangle 9 NaN rectangle 16 NaN
>>> df.mul(other, fill_value=0) angles degrees circle 0 0.0 triangle 9 0.0 rectangle 16 0.0
Divide by a MultiIndex by level.
>>> df_multindex = pd.DataFrame({'angles': [0, 3, 4, 4, 5, 6], ... 'degrees': [360, 180, 360, 360, 540, 720]}, ... index=[['A', 'A', 'A', 'B', 'B', 'B'], ... ['circle', 'triangle', 'rectangle', ... 'square', 'pentagon', 'hexagon']]) >>> df_multindex angles degrees A circle 0 360 triangle 3 180 rectangle 4 360 B square 4 360 pentagon 5 540 hexagon 6 720
>>> df.div(df_multindex, level=1, fill_value=0) angles degrees A circle NaN 1.0 triangle 1.0 1.0 rectangle 1.0 1.0 B square 0.0 0.0 pentagon 0.0 0.0 hexagon 0.0 0.0

mode
(axis=0, numeric_only=False, dropna=True) → pandas.core.frame.DataFrame¶ Get the mode(s) of each element along the selected axis.
The mode of a set of values is the value that appears most often. It can be multiple values.
 axis{0 or ‘index’, 1 or ‘columns’}, default 0
The axis to iterate over while searching for the mode:
0 or ‘index’ : get mode of each column
1 or ‘columns’ : get mode of each row.
 numeric_onlybool, default False
If True, only apply to numeric columns.
 dropnabool, default True
Don’t consider counts of NaN/NaT.
New in version 0.24.0.
 DataFrame
The modes of each column or row.
Series.mode : Return the highest frequency value in a Series. Series.value_counts : Return the counts of values in a Series.
>>> df = pd.DataFrame([('bird', 2, 2), ... ('mammal', 4, np.nan), ... ('arthropod', 8, 0), ... ('bird', 2, np.nan)], ... index=('falcon', 'horse', 'spider', 'ostrich'), ... columns=('species', 'legs', 'wings')) >>> df species legs wings falcon bird 2 2.0 horse mammal 4 NaN spider arthropod 8 0.0 ostrich bird 2 NaN
By default, missing values are not considered, and the mode of wings are both 0 and 2. The second row of species and legs contains
NaN
, because they have only one mode, but the DataFrame has two rows.>>> df.mode() species legs wings 0 bird 2.0 0.0 1 NaN NaN 2.0
Setting
dropna=False
NaN
values are considered and they can be the mode (like for wings).>>> df.mode(dropna=False) species legs wings 0 bird 2 NaN
Setting
numeric_only=True
, only the mode of numeric columns is computed, and columns of other types are ignored.>>> df.mode(numeric_only=True) legs wings 0 2.0 0.0 1 NaN 2.0
To compute the mode over columns and not rows, use the axis parameter:
>>> df.mode(axis='columns', numeric_only=True) 0 1 falcon 2.0 NaN horse 4.0 NaN spider 0.0 8.0 ostrich 2.0 NaN

mul
(other, axis='columns', level=None, fill_value=None)¶ Get Multiplication of dataframe and other, elementwise (binary operator mul).
Equivalent to
dataframe * other
, but with support to substitute a fill_value for missing data in one of the inputs. With reverse version, rmul.Among flexible wrappers (add, sub, mul, div, mod, pow) to arithmetic operators: +, , *, /, //, %, **.
 otherscalar, sequence, Series, or DataFrame
Any single or multiple element data structure, or listlike object.
 axis{0 or ‘index’, 1 or ‘columns’}
Whether to compare by the index (0 or ‘index’) or columns (1 or ‘columns’). For Series input, axis to match Series index on.
 levelint or label
Broadcast across a level, matching Index values on the passed MultiIndex level.
 fill_valuefloat or None, default None
Fill existing missing (NaN) values, and any new element needed for successful DataFrame alignment, with this value before computation. If data in both corresponding DataFrame locations is missing the result will be missing.
 DataFrame
Result of the arithmetic operation.
DataFrame.add : Add DataFrames. DataFrame.sub : Subtract DataFrames. DataFrame.mul : Multiply DataFrames. DataFrame.div : Divide DataFrames (float division). DataFrame.truediv : Divide DataFrames (float division). DataFrame.floordiv : Divide DataFrames (integer division). DataFrame.mod : Calculate modulo (remainder after division). DataFrame.pow : Calculate exponential power.
Mismatched indices will be unioned together.
>>> df = pd.DataFrame({'angles': [0, 3, 4], ... 'degrees': [360, 180, 360]}, ... index=['circle', 'triangle', 'rectangle']) >>> df angles degrees circle 0 360 triangle 3 180 rectangle 4 360
Add a scalar with operator version which return the same results.
>>> df + 1 angles degrees circle 1 361 triangle 4 181 rectangle 5 361
>>> df.add(1) angles degrees circle 1 361 triangle 4 181 rectangle 5 361
Divide by constant with reverse version.
>>> df.div(10) angles degrees circle 0.0 36.0 triangle 0.3 18.0 rectangle 0.4 36.0
>>> df.rdiv(10) angles degrees circle inf 0.027778 triangle 3.333333 0.055556 rectangle 2.500000 0.027778
Subtract a list and Series by axis with operator version.
>>> df  [1, 2] angles degrees circle 1 358 triangle 2 178 rectangle 3 358
>>> df.sub([1, 2], axis='columns') angles degrees circle 1 358 triangle 2 178 rectangle 3 358
>>> df.sub(pd.Series([1, 1, 1], index=['circle', 'triangle', 'rectangle']), ... axis='index') angles degrees circle 1 359 triangle 2 179 rectangle 3 359
Multiply a DataFrame of different shape with operator version.
>>> other = pd.DataFrame({'angles': [0, 3, 4]}, ... index=['circle', 'triangle', 'rectangle']) >>> other angles circle 0 triangle 3 rectangle 4
>>> df * other angles degrees circle 0 NaN triangle 9 NaN rectangle 16 NaN
>>> df.mul(other, fill_value=0) angles degrees circle 0 0.0 triangle 9 0.0 rectangle 16 0.0
Divide by a MultiIndex by level.
>>> df_multindex = pd.DataFrame({'angles': [0, 3, 4, 4, 5, 6], ... 'degrees': [360, 180, 360, 360, 540, 720]}, ... index=[['A', 'A', 'A', 'B', 'B', 'B'], ... ['circle', 'triangle', 'rectangle', ... 'square', 'pentagon', 'hexagon']]) >>> df_multindex angles degrees A circle 0 360 triangle 3 180 rectangle 4 360 B square 4 360 pentagon 5 540 hexagon 6 720
>>> df.div(df_multindex, level=1, fill_value=0) angles degrees A circle NaN 1.0 triangle 1.0 1.0 rectangle 1.0 1.0 B square 0.0 0.0 pentagon 0.0 0.0 hexagon 0.0 0.0

multiply
(other, axis='columns', level=None, fill_value=None)¶ Get Multiplication of dataframe and other, elementwise (binary operator mul).
Equivalent to
dataframe * other
, but with support to substitute a fill_value for missing data in one of the inputs. With reverse version, rmul.Among flexible wrappers (add, sub, mul, div, mod, pow) to arithmetic operators: +, , *, /, //, %, **.
 otherscalar, sequence, Series, or DataFrame
Any single or multiple element data structure, or listlike object.
 axis{0 or ‘index’, 1 or ‘columns’}
Whether to compare by the index (0 or ‘index’) or columns (1 or ‘columns’). For Series input, axis to match Series index on.
 levelint or label
Broadcast across a level, matching Index values on the passed MultiIndex level.
 fill_valuefloat or None, default None
Fill existing missing (NaN) values, and any new element needed for successful DataFrame alignment, with this value before computation. If data in both corresponding DataFrame locations is missing the result will be missing.
 DataFrame
Result of the arithmetic operation.
DataFrame.add : Add DataFrames. DataFrame.sub : Subtract DataFrames. DataFrame.mul : Multiply DataFrames. DataFrame.div : Divide DataFrames (float division). DataFrame.truediv : Divide DataFrames (float division). DataFrame.floordiv : Divide DataFrames (integer division). DataFrame.mod : Calculate modulo (remainder after division). DataFrame.pow : Calculate exponential power.
Mismatched indices will be unioned together.
>>> df = pd.DataFrame({'angles': [0, 3, 4], ... 'degrees': [360, 180, 360]}, ... index=['circle', 'triangle', 'rectangle']) >>> df angles degrees circle 0 360 triangle 3 180 rectangle 4 360
Add a scalar with operator version which return the same results.
>>> df + 1 angles degrees circle 1 361 triangle 4 181 rectangle 5 361
>>> df.add(1) angles degrees circle 1 361 triangle 4 181 rectangle 5 361
Divide by constant with reverse version.
>>> df.div(10) angles degrees circle 0.0 36.0 triangle 0.3 18.0 rectangle 0.4 36.0
>>> df.rdiv(10) angles degrees circle inf 0.027778 triangle 3.333333 0.055556 rectangle 2.500000 0.027778
Subtract a list and Series by axis with operator version.
>>> df  [1, 2] angles degrees circle 1 358 triangle 2 178 rectangle 3 358
>>> df.sub([1, 2], axis='columns') angles degrees circle 1 358 triangle 2 178 rectangle 3 358
>>> df.sub(pd.Series([1, 1, 1], index=['circle', 'triangle', 'rectangle']), ... axis='index') angles degrees circle 1 359 triangle 2 179 rectangle 3 359
Multiply a DataFrame of different shape with operator version.
>>> other = pd.DataFrame({'angles': [0, 3, 4]}, ... index=['circle', 'triangle', 'rectangle']) >>> other angles circle 0 triangle 3 rectangle 4
>>> df * other angles degrees circle 0 NaN triangle 9 NaN rectangle 16 NaN
>>> df.mul(other, fill_value=0) angles degrees circle 0 0.0 triangle 9 0.0 rectangle 16 0.0
Divide by a MultiIndex by level.
>>> df_multindex = pd.DataFrame({'angles': [0, 3, 4, 4, 5, 6], ... 'degrees': [360, 180, 360, 360, 540, 720]}, ... index=[['A', 'A', 'A', 'B', 'B', 'B'], ... ['circle', 'triangle', 'rectangle', ... 'square', 'pentagon', 'hexagon']]) >>> df_multindex angles degrees A circle 0 360 triangle 3 180 rectangle 4 360 B square 4 360 pentagon 5 540 hexagon 6 720
>>> df.div(df_multindex, level=1, fill_value=0) angles degrees A circle NaN 1.0 triangle 1.0 1.0 rectangle 1.0 1.0 B square 0.0 0.0 pentagon 0.0 0.0 hexagon 0.0 0.0

property
ndim
¶ Return an int representing the number of axes / array dimensions.
Return 1 if Series. Otherwise return 2 if DataFrame.
ndarray.ndim : Number of array dimensions.
>>> s = pd.Series({'a': 1, 'b': 2, 'c': 3}) >>> s.ndim 1
>>> df = pd.DataFrame({'col1': [1, 2], 'col2': [3, 4]}) >>> df.ndim 2

ne
(other, axis='columns', level=None)¶ Get Not equal to of dataframe and other, elementwise (binary operator ne).
Among flexible wrappers (eq, ne, le, lt, ge, gt) to comparison operators.
Equivalent to ==, =!, <=, <, >=, > with support to choose axis (rows or columns) and level for comparison.
 otherscalar, sequence, Series, or DataFrame
Any single or multiple element data structure, or listlike object.
 axis{0 or ‘index’, 1 or ‘columns’}, default ‘columns’
Whether to compare by the index (0 or ‘index’) or columns (1 or ‘columns’).
 levelint or label
Broadcast across a level, matching Index values on the passed MultiIndex level.
 DataFrame of bool
Result of the comparison.
DataFrame.eq : Compare DataFrames for equality elementwise. DataFrame.ne : Compare DataFrames for inequality elementwise. DataFrame.le : Compare DataFrames for less than inequality
or equality elementwise.
 DataFrame.ltCompare DataFrames for strictly less than
inequality elementwise.
 DataFrame.geCompare DataFrames for greater than inequality
or equality elementwise.
 DataFrame.gtCompare DataFrames for strictly greater than
inequality elementwise.
Mismatched indices will be unioned together. NaN values are considered different (i.e. NaN != NaN).
>>> df = pd.DataFrame({'cost': [250, 150, 100], ... 'revenue': [100, 250, 300]}, ...