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 non-spatial 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. FeatureLayerCollection are one of the dataset types contained in a Datastore.

Note

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

The as_dict property retrieves the feature layer as a dictionary. :returns: the feature as a dictionary

property as_row

The as_row property retrieves 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

Returns

A tuple

property attributes
Returns

a dictionary of feature attribute values with field names as the key

property fields

The fields property retrieves the attribute field names for the feature as a list of strings

Returns

A list of strings

classmethod from_dict(feature, sr=None)

The from_dict method creates a Feature object from a dictionary.

Returns

A class:~arcgis.features.feature.Feature from a dictionary

classmethod from_json(json_str)

The from_dict method creates a Feature object from a JSON string.

Returns

A Feature from a JSON string

property geometry
Returns

the feature geometry

property geometry_type

The geometry_type property retrieves the geometry type of the Feature as a string.

Returns

The geometry type of the Feature as a string

get_value(field_name)

The get_value method retrieves the value for a specified field name.

Returns

The value for the specified attribute field of the Feature

set_value(field_name, value)

The set_value method 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.

# UsageExample

>>> feat_set = feature_layer.query(where="OBJECTID=1")
>>> feat = feat_set[0]
>>> feat.set_value(field_name = "field_name",
>>>               value = "new_value")
True
Returns

A boolean indicating whether field_name value was updated (True), or not updated (False).

arcgis.features.FeatureLayer

class arcgis.features.FeatureLayer(url, gis=None, container=None, dynamic_layer=None)

The FeatureLayer class is the primary concept for working with Feature objects in a GIS.

User objects 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, upload_id=None, *, return_messages=None, future=False)

The append method is used to update an existing hosted FeatureLayer object. See the Append (Feature Service/Layer) page in the ArcGIS REST API documentation for more informatin.

Note

The append method is only available in ArcGIS Online and ArcGIS Enterprise 10.8.1+

Argument

Description

item_id

optional string. The ID for the Portal item that contains the source file. Used in conjunction with editsUploadFormat.

upload_format

required string. The source append data format. The default is featureCollection. Values: sqlite | shapefile | filegdb | featureCollection | geojson | csv | excel

source_table_name

required string. Required even when the source data contains only one table, e.g., for file geodatabase.

# Example usage:
source_table_name=  "Building"

field_mappings

optional list. Used to map source data to a destination layer. Syntax: fieldMappings=[{“name” : <”targetName”>,

“sourceName” : < “sourceName”>}, …]

# Example usage:
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 true.

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",....]

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”

upload_id

Optional string. The itemID field from an upload() response, corresponding with the appendUploadId REST API argument. This argument should not be used along side the item_id argument.

return_messages

Optional Boolean. When set to True, the messages returned from the append will be returned. If False, the response messages will not be returned. This alters the output to be a tuple consisting of a (Boolean, Dictionary).

future

Optional Boolean. When true, the response is returned as a Future object.

# Usage Example

>>> feature_layer.append(source_table_name= "Building",
                        field_Mappings=[{"name" : "CountyID",
                                        "sourceName" : "GEOID10"}],
                        upsert = True,
                        append_fields = ["fieldName1", "fieldName2",...., fieldname22],
                        return_messages = False)
<True>
Returns

A boolean indicating success (True), or failure (False). When return_messages is True, the response messages will be return in addition to the boolean as a tuple. If future = True, then the result is a Future object. Call result() to get the response.

calculate(where, calc_expression, sql_format='standard', version=None, sessionid=None, return_edit_moment=None, future=False)

The calculate operation is performed on a FeatureLayer resource. calculate 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.

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"}))
Returns

A dictionary with the following format:

{ ‘updatedFeatureCount’: 1, ‘success’: True }

property container

The container property gets and sets the FeatureLayerCollection 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)

The delete_features deletes features in a FeatureLayer or Table

Argument

Description

deletes

Optional string. A comma separated 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.

# Usage Example with only a "where" sql statement

>>> from arcgis.features import FeatureLayer

>>> gis = GIS("pro")
>>> buck = gis.content.search("owner:"+ gis.users.me.username)
>>> buck_1 =buck[1]
>>> lay = buck_1.layers[0]

>>> la_df = lay.delete_features(where = "OBJECTID > 15")
>>> la_df
{'deleteResults': [
{'objectId': 1, 'uniqueId': 5, 'globalId': None, 'success': True},
{'objectId': 2, 'uniqueId': 5, 'globalId': None, 'success': True},
{'objectId': 3, 'uniqueId': 5, 'globalId': None, 'success': True},
{'objectId': 4, 'uniqueId': 5, 'globalId': None, 'success': True},
{'objectId': 5, 'uniqueId': 5, 'globalId': None, 'success': True},
{'objectId': 6, 'uniqueId': 6, 'globalId': None, 'success': True},
{'objectId': 7, 'uniqueId': 7, 'globalId': None, 'success': True},
{'objectId': 8, 'uniqueId': 8, 'globalId': None, 'success': True},
{'objectId': 9, 'uniqueId': 9, 'globalId': None, 'success': True},
{'objectId': 10, 'uniqueId': 10, 'globalId': None, 'success': True},
{'objectId': 11, 'uniqueId': 11, 'globalId': None, 'success': True},
{'objectId': 12, 'uniqueId': 12, 'globalId': None, 'success': True},
{'objectId': 13, 'uniqueId': 13, 'globalId': None, 'success': True},
{'objectId': 14, 'uniqueId': 14, 'globalId': None, 'success': True},
{'objectId': 15, 'uniqueId': 15, 'globalId': None, 'success': True}]}
Returns

A dictionary if future=False (default), else a Future object.

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)

The edit_features operation adds, updates, and deletes features to the associated FeatureLayer or Table in a single call.

Note

When making large number (250+ records at once) of edits, append should be used over edit_features to improve performance and ensure service stability.

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 pre-uploaded 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

See the Apply Edits to a Feature Service layer in the ArcGIS REST API for more information.

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 well-known 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’:<true|false>},{‘wkt’:’<WKT>’,’forward’:<True|False>}]}```

Returns

A dictionary

export_attachments(output_folder, label_field=None)

The exports_attachments exports attachments from the FeatureLayer 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)

The fromitem method creates a FeatureLayer from a Item object.

Argument

Description

item

Required Item object. The type of item should be a Feature Service that represents a FeatureLayerCollection

layer_id

Required Integer. the id of the layer in feature layer collection (feature service). The default for layer_id is 0.

# Usage Example

>>> from arcgis.features import FeatureLayer

>>> gis = GIS("pro")
>>> buck = gis.content.search("owner:"+ gis.users.me.username)
>>> buck_1 =buck[1]
>>> buck_1.type
'Feature Service'
>>> new_layer= FeatureLayer.fromitem(item = buck_1)
>>> type(new_layer)
<class 'arcgis.features.layer.FeatureLayer'>
Returns

A FeatureSet object

generate_renderer(definition, where=None)

The generate_renderer operation groups data using the supplied definition (classification definition) and an optional where clause. The result is a renderer object.

Note

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 Classification Objects for additional details.

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

A dictionary

get_html_popup(oid)

The get_html_popup method provides details about the HTML pop-up authored by the User using ArcGIS Pro or ArcGIS Desktop.

Argument

Description

oid

Optional string. Object id of the feature to get the HTML popup.

Returns

A string

get_unique_values(attribute, query_string='1=1')

The get_unique_values method retrieves a list of unique values for a given attribute in the FeatureLayer.

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%’”

# Usage Example with only a "where" sql statement

>>> from arcgis.features import FeatureLayer

>>> gis = GIS("pro")
>>> buck = gis.content.search("owner:"+ gis.users.me.username)
>>> buck_1 =buck[1]
>>> lay = buck_1.layers[0]
>>> layer = lay.get_unique_values(attribute = "COUNTY")
>>> layer
['PITKIN', 'PLATTE', 'TWIN FALLS']
Returns

A List

property manager

The manager property is a helper object to manage the FeatureLayer, such as updating its definition.

property metadata

The metadata property allows for the setting and downloading of the Feature Layer’s metadata.

Note

If metadata is disabled on the GIS or the layer does not support metadata, None will be returned.

Argument

Description

value

Required String. (SET) Path to the metadata file.

Returns

String (GET)

property properties

The properties method retrieves and set 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)

The query method queries a FeatureLayer 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 comma-separated 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 z-values).

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 field-based 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 well-known 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’:<true|false>},{‘wkt’:’<WKT>’,’forward’:<True|False>}]}```

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.

# Usage Example with only a "where" sql statement

>>> feat_set = feature_layer.query(where = "OBJECTID= 1")
>>> type(feat_set)
<arcgis.Features.FeatureSet>
>>> feat_set[0]
<Feature 1>
# Usage Example of an advanced query returning the object IDs instead of Features

>>> id_set = feature_layer.query(where = "OBJECTID1",
                                   out_fields = ["FieldName1, FieldName2"],
                                   distance = 100,
                                   units = 'esriSRUnit_Meter',
                                   return_ids_only = True)

>>> type(id_set)
<Array>
>>> id_set[0]
<"Item_id1">
# Usage Example of an advanced query returning the number of features in the query

>>> search_count = feature_layer.query(where = "OBJECTID1",
                                   out_fields = ["FieldName1, FieldName2"],
                                   distance = 100,
                                   units = 'esriSRUnit_Meter',
                                   return_count_only = True)

>>> type(search_count)
<Integer>
>>> search_count
<149>
Returns

A FeatureSet containing the features matching the query unless another return type is specified, such as count

query_analytics(out_analytics, where='1=1', out_fields='*', analytic_where=None, geometry_filter=None, out_sr=None, return_geometry=True, order_by=None, result_type=None, cache_hint=None, result_offset=None, result_record_count=None, quantization_param=None, sql_format=None, future=True, **kwargs)

The query_analytics exposes the standard SQL windows functions that compute aggregate and ranking values based on a group of rows called window partition. The window function is applied to the rows after the partitioning and ordering of the rows. query_analytics defines a window or user-specified set of rows within a query result set. query_analytics can be used to compute aggregated values such as moving averages, cumulative aggregates, or running totals.

Note

See the query method for a similar function.

SQL Windows Function

A window function performs a calculation across a set of rows (SQL partition or window) that are related to the current row. Unlike regular aggregate functions, use of a window function does not return single output row. The rows retain their separate identities with each calculation appended to the rows as a new field value. The window function can access more than just the current row of the query result.

query_analytics currently supports the following windows functions:
  • Aggregate functions

  • Analytic functions

  • Ranking functions

Aggregate Functions

Aggregate functions are deterministic function that perform a calculation on a set of values and return a single value. They are used in the select list with optional HAVING clause. GROUP BY clause can also be used to calculate the aggregation on categories of rows. query_analytics can be used to calculate the aggregation on a specific range of value. Supported aggregate functions are:

  • Min

  • Max

  • Sum

  • Count

  • AVG

  • STDDEV

  • VAR

Analytic Functions

Several analytic functions available now in all SQL vendors to compute an aggregate value based on a group of rows or windows partition. Unlike aggregation functions, analytic functions can return single or multiple rows for each group.

  • CUM_DIST

  • FIRST_VALUE

  • LAST_VALUE

  • LEAD

  • LAG

  • PERCENTILE_DISC

  • PERCENTILE_CONT

  • PERCENT_RANK

Ranking Functions

Ranking functions return a ranking value for each row in a partition. Depending on the function that is used, some rows might receive the same value as other rows.

  • RANK

  • NTILE

  • DENSE_RANK

  • ROW_NUMBER

Partitioning

Partitions are extremely useful when you need to calculate the same metric over different group of rows. It is very powerful and has many potential usages. For example, you can add partition by to your window specification to look at different groups of rows individually.

partitionBy clause divides the query result set into partitions and the sql window function is applied to each partition. The ‘partitionBy’ clause normally refers to the column by which the result is partitioned. ‘partitionBy’ can also be a value expression (column expression or function) that references any of the selected columns (not aliases).

Argument

Description

out_analytics

Required List. A set of analytics to calculate on the Feature Layer.

The definitions for one or more field-based or expression analytics to be computed. This parameter is supported only on layers/tables that indicate supportsAnalytics is true. Note: If outAnalyticFieldName is empty or missing, the server assigns a field name to the returned analytic field.

Syntax: An array of analytic definitions. An analytic definition specifies the type of analytic, the field or expression on which it is to be computed, and the resulting output field name. Syntax [

{

“analyticType”: “<COUNT | SUM | MIN | MAX | AVG | STDDEV | VAR | FIRST_VALUE, LAST_VALUE, LAG, LEAD, PERCENTILE_CONT, PERCENTILE_DISC, PERCENT_RANK, RANK, NTILE, DENSE_RANK, EXPRESSION>”, “onAnalyticField”: “Field1”, “outAnalyticFieldName”: “Out_Field_Name1”,

“analyticParameters”: {

“orderBy”: “<orderBy expression”, “value”: <double value>,// percentile value “partitionBy”: “<field name or expression>”, “offset”: <integer>, // used by LAG/LEAD “windowFrame”: {

“type”: “ROWS” | “RANGE”, “extent”: {

“extentType”: “PRECEDING” | “BOUNDARY”, “PRECEDING”: {

“type”: <”UNBOUNDED” |
“NUMERIC_CONSTANT” |

“CURRENT_ROW”>

“value”: <numeric constant value>

} “BOUNDARY”: {

“start”: “UNBOUNDED_PRECEDING”,
“NUMERIC_PRECEDING”,

“CURRENT_ROW”,

“startValue”: <numeric constant value>, “end”: <”UNBOUNDED_FOLLOWING” |

“NUMERIC_FOLLOWING” | “CURRENT_ROW”,

“endValue”: <numeric constant value>

}

}

}

}

}

}

]

Example: [{

“analyticType”: “FIRST_VALUE”, “onAnalyticField”: “POP1990”, “analyticParameters”: {

“orderBy”: “POP1990”, “partitionBy”: “state_name”

}, “outAnalyticFieldName”: “FirstValue”

}

]

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.

analytic_where

Optional String. A where clause for the query filter that applies to the result set of applying the source where clause and all other params.

geometry_filter

Optional from arcgis.geometry.filter. Allows for the information to be filtered on spatial relationship with another geometry.

out_sr

Optional Integer. The WKID for the spatial reference of the returned geometry.

out_sr

Optional Integer. The output spatial reference wkid.

return_geometry

Optional boolean. If true, geometry is returned with the query. Default is true.

order_by

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

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

cache_hint

Optional Boolean. If you are performing the same query multiple times, a user can ask the server to cache the call to obtain the results quicker. The default is False.

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).

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.

quantization_parameters

Optional dict. Used to project the geometry onto a virtual grid, likely representing pixels on the screen.

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

future

Optional Boolean. This determines if a Future object is returned (True) the method returns the results directly (False).

Returns

A Pandas DataFrame (pd.DataFrame)

The query_related_records operation is performed on a FeatureLayer 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.

Note

See the query method for a similar function.

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 Polyline or Polygon objects.

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 FeatureLayer. 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_features 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.

Note

See the query method for a similar function.

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 z-values).

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.

property renderer

Get/Set the Renderer of the Feature Layer. This overrides the default symbology when displaying it on a webmap.

Returns

InsensitiveDict

property time_filter

The time_filter method is used to set a time filter instead of querying time-enabled map service layers or time-enabled feature service layers, a time filter can be specified. Time can be filtered as a single instant or by separating the two ends of a time extent with a comma.

Note

The time_filter method is supported starting at Enterprise 10.7.1+.

Input

Description

value

Required Datetime/List Datetime. This is a single or list of start/stop date.

Returns

A string of datetime values as milliseconds from epoch

update_metadata(file_path)

The update_metadata updates a FeatureLayer metadata from an xml file.

Argument

Description

file_path

Required String. The path to the .xml file that contains the metadata.

Returns

A boolean indicating success (True), or failure (False)

validate_sql(sql, sql_type='where')

The validate_sql operation validates an SQL-92 expression or WHERE clause. The validate_sql operation ensures that an SQL-92 expression, such as one written by a user through a user interface, is correct before performing another operation that uses the expression.

Note

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 SQL-92 expression. Currently, expression is used as a default value expression when adding a new field or using the calculate API.

  • statement - Represents the full SQL-92 statement that can be passed directly to the database. No current ArcGIS REST API resource or operation supports using the full SQL-92 SELECT statement directly. It has been added to the validateSQL for completeness. Values: where | expression | statement

Returns

A dictionary

arcgis.features.Table

class arcgis.features.Table(url, gis=None, container=None, dynamic_layer=None)

Table objects represent entity classes with uniform properties. In addition to working with “entities with location” as Feature objects, the GIS can also work with non-spatial entities as rows in tables.

Note

Working with tables is similar to working with :class:`~arcgis.features.FeatureLayer`objects, 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, upload_id=None, *, return_messages=None, future=False)

The append method is used to update an existing hosted FeatureLayer object. See the Append (Feature Service/Layer) page in the ArcGIS REST API documentation for more informatin.

Note

The append method is only available in ArcGIS Online and ArcGIS Enterprise 10.8.1+

Argument

Description

item_id

optional string. The ID for the Portal item that contains the source file. Used in conjunction with editsUploadFormat.

upload_format

required string. The source append data format. The default is featureCollection. Values: sqlite | shapefile | filegdb | featureCollection | geojson | csv | excel

source_table_name

required string. Required even when the source data contains only one table, e.g., for file geodatabase.

# Example usage:
source_table_name=  "Building"

field_mappings

optional list. Used to map source data to a destination layer. Syntax: fieldMappings=[{“name” : <”targetName”>,

“sourceName” : < “sourceName”>}, …]

# Example usage:
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 true.

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",....]

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”

upload_id

Optional string. The itemID field from an upload() response, corresponding with the appendUploadId REST API argument. This argument should not be used along side the item_id argument.

return_messages

Optional Boolean. When set to True, the messages returned from the append will be returned. If False, the response messages will not be returned. This alters the output to be a tuple consisting of a (Boolean, Dictionary).

future

Optional Boolean. When true, the response is returned as a Future object.

# Usage Example

>>> feature_layer.append(source_table_name= "Building",
                        field_Mappings=[{"name" : "CountyID",
                                        "sourceName" : "GEOID10"}],
                        upsert = True,
                        append_fields = ["fieldName1", "fieldName2",...., fieldname22],
                        return_messages = False)
<True>
Returns

A boolean indicating success (True), or failure (False). When return_messages is True, the response messages will be return in addition to the boolean as a tuple. If future = True, then the result is a Future object. Call result() to get the response.

calculate(where, calc_expression, sql_format='standard', version=None, sessionid=None, return_edit_moment=None, future=False)

The calculate operation is performed on a FeatureLayer resource. calculate 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.

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"}))
Returns

A dictionary with the following format:

{ ‘updatedFeatureCount’: 1, ‘success’: True }

property container

The container property gets and sets the FeatureLayerCollection 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)

The delete_features deletes features in a FeatureLayer or Table

Argument

Description

deletes

Optional string. A comma separated 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.

# Usage Example with only a "where" sql statement

>>> from arcgis.features import FeatureLayer

>>> gis = GIS("pro")
>>> buck = gis.content.search("owner:"+ gis.users.me.username)
>>> buck_1 =buck[1]
>>> lay = buck_1.layers[0]

>>> la_df = lay.delete_features(where = "OBJECTID > 15")
>>> la_df
{'deleteResults': [
{'objectId': 1, 'uniqueId': 5, 'globalId': None, 'success': True},
{'objectId': 2, 'uniqueId': 5, 'globalId': None, 'success': True},
{'objectId': 3, 'uniqueId': 5, 'globalId': None, 'success': True},
{'objectId': 4, 'uniqueId': 5, 'globalId': None, 'success': True},
{'objectId': 5, 'uniqueId': 5, 'globalId': None, 'success': True},
{'objectId': 6, 'uniqueId': 6, 'globalId': None, 'success': True},
{'objectId': 7, 'uniqueId': 7, 'globalId': None, 'success': True},
{'objectId': 8, 'uniqueId': 8, 'globalId': None, 'success': True},
{'objectId': 9, 'uniqueId': 9, 'globalId': None, 'success': True},
{'objectId': 10, 'uniqueId': 10, 'globalId': None, 'success': True},
{'objectId': 11, 'uniqueId': 11, 'globalId': None, 'success': True},
{'objectId': 12, 'uniqueId': 12, 'globalId': None, 'success': True},
{'objectId': 13, 'uniqueId': 13, 'globalId': None, 'success': True},
{'objectId': 14, 'uniqueId': 14, 'globalId': None, 'success': True},
{'objectId': 15, 'uniqueId': 15, 'globalId': None, 'success': True}]}
Returns

A dictionary if future=False (default), else a Future object.

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)

The edit_features operation adds, updates, and deletes features to the associated FeatureLayer or Table in a single call.

Note

When making large number (250+ records at once) of edits, append should be used over edit_features to improve performance and ensure service stability.

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 pre-uploaded 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

See the Apply Edits to a Feature Service layer in the ArcGIS REST API for more information.

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 well-known 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’:<true|false>},{‘wkt’:’<WKT>’,’forward’:<True|False>}]}```

Returns

A dictionary

export_attachments(output_folder, label_field=None)

The exports_attachments exports attachments from the FeatureLayer 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)

The fromitem method creates a Table from a Item object. The layer_id is the id of the layer in feature layer collection (feature service).

Argument

Description

item

Required Item object. The type of item should be a Feature Service that represents a FeatureLayerCollection

layer_id

Required Integer. the id of the layer in feature layer collection (feature service). The default for layer_id is 0.

Returns

A Table object

generate_renderer(definition, where=None)

The generate_renderer operation groups data using the supplied definition (classification definition) and an optional where clause. The result is a renderer object.

Note

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 Classification Objects for additional details.

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

A dictionary

get_html_popup(oid)

The get_html_popup method provides details about the HTML pop-up authored by the User using ArcGIS Pro or ArcGIS Desktop.

Argument

Description

oid

Optional string. Object id of the feature to get the HTML popup.

Returns

A string

get_unique_values(attribute, query_string='1=1')

The get_unique_values method retrieves a list of unique values for a given attribute in the FeatureLayer.

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%’”

# Usage Example with only a "where" sql statement

>>> from arcgis.features import FeatureLayer

>>> gis = GIS("pro")
>>> buck = gis.content.search("owner:"+ gis.users.me.username)
>>> buck_1 =buck[1]
>>> lay = buck_1.layers[0]
>>> layer = lay.get_unique_values(attribute = "COUNTY")
>>> layer
['PITKIN', 'PLATTE', 'TWIN FALLS']
Returns

A List

property manager

The manager property is a helper object to manage the FeatureLayer, such as updating its definition.

property metadata

The metadata property allows for the setting and downloading of the Feature Layer’s metadata.

Note

If metadata is disabled on the GIS or the layer does not support metadata, None will be returned.

Argument

Description

value

Required String. (SET) Path to the metadata file.

Returns

String (GET)

property properties

The properties method retrieves and set properties of this object.

query(where='1=1', out_fields='*', time_filter=None, return_count_only=False, return_ids_only=False, return_distinct_values=False, group_by_fields_for_statistics=None, statistic_filter=None, result_offset=None, result_record_count=None, object_ids=None, gdb_version=None, order_by_fields=None, out_statistics=None, return_all_records=True, historic_moment=None, sql_format=None, return_exceeded_limit_features=None, as_df=False, having=None, **kwargs)

The query method queries a Table Layer based on a set of criteria.

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 comma-separated string.

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

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.

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 field-based 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”

}

]

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).

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.

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_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.

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.

# Usage Example with only a "where" sql statement

>>> feat_set = feature_layer.query(where = "OBJECTID1")
>>> type(feat_set)
<arcgis.Features.FeatureSet>
>>> feat_set[0]
<Feature 1>
# Usage Example of an advanced query returning the object IDs instead of Features

>>> id_set = feature_layer.query(where = "OBJECTID1",
                                   out_fields = ["FieldName1, FieldName2"],
                                   distance = 100,
                                   units = 'esriSRUnit_Meter',
                                   return_ids_only = True)

>>> type(id_set)
<Array>
>>> id_set[0]
<"Item_id1">
# Usage Example of an advanced query returning the number of features in the query

>>> search_count = feature_layer.query(where = "OBJECTID1",
                                   out_fields = ["FieldName1, FieldName2"],
                                   distance = 100,
                                   units = 'esriSRUnit_Meter',
                                   return_count_only = True)

>>> type(search_count)
<Integer>
>>> search_count
<149>
Returns

A FeatureSet object or Panda’s DataFrame containing the features matching the query unless another return type is specified, such as count

query_analytics(out_analytics, where='1=1', out_fields='*', analytic_where=None, geometry_filter=None, out_sr=None, return_geometry=True, order_by=None, result_type=None, cache_hint=None, result_offset=None, result_record_count=None, quantization_param=None, sql_format=None, future=True, **kwargs)

The query_analytics exposes the standard SQL windows functions that compute aggregate and ranking values based on a group of rows called window partition. The window function is applied to the rows after the partitioning and ordering of the rows. query_analytics defines a window or user-specified set of rows within a query result set. query_analytics can be used to compute aggregated values such as moving averages, cumulative aggregates, or running totals.

Note

See the query method for a similar function.

SQL Windows Function

A window function performs a calculation across a set of rows (SQL partition or window) that are related to the current row. Unlike regular aggregate functions, use of a window function does not return single output row. The rows retain their separate identities with each calculation appended to the rows as a new field value. The window function can access more than just the current row of the query result.

query_analytics currently supports the following windows functions:
  • Aggregate functions

  • Analytic functions

  • Ranking functions

Aggregate Functions

Aggregate functions are deterministic function that perform a calculation on a set of values and return a single value. They are used in the select list with optional HAVING clause. GROUP BY clause can also be used to calculate the aggregation on categories of rows. query_analytics can be used to calculate the aggregation on a specific range of value. Supported aggregate functions are:

  • Min

  • Max

  • Sum

  • Count

  • AVG

  • STDDEV

  • VAR

Analytic Functions

Several analytic functions available now in all SQL vendors to compute an aggregate value based on a group of rows or windows partition. Unlike aggregation functions, analytic functions can return single or multiple rows for each group.

  • CUM_DIST

  • FIRST_VALUE

  • LAST_VALUE

  • LEAD

  • LAG

  • PERCENTILE_DISC

  • PERCENTILE_CONT

  • PERCENT_RANK

Ranking Functions

Ranking functions return a ranking value for each row in a partition. Depending on the function that is used, some rows might receive the same value as other rows.

  • RANK

  • NTILE

  • DENSE_RANK

  • ROW_NUMBER

Partitioning

Partitions are extremely useful when you need to calculate the same metric over different group of rows. It is very powerful and has many potential usages. For example, you can add partition by to your window specification to look at different groups of rows individually.

partitionBy clause divides the query result set into partitions and the sql window function is applied to each partition. The ‘partitionBy’ clause normally refers to the column by which the result is partitioned. ‘partitionBy’ can also be a value expression (column expression or function) that references any of the selected columns (not aliases).

Argument

Description

out_analytics

Required List. A set of analytics to calculate on the Feature Layer.

The definitions for one or more field-based or expression analytics to be computed. This parameter is supported only on layers/tables that indicate supportsAnalytics is true. Note: If outAnalyticFieldName is empty or missing, the server assigns a field name to the returned analytic field.

Syntax: An array of analytic definitions. An analytic definition specifies the type of analytic, the field or expression on which it is to be computed, and the resulting output field name. Syntax [

{

“analyticType”: “<COUNT | SUM | MIN | MAX | AVG | STDDEV | VAR | FIRST_VALUE, LAST_VALUE, LAG, LEAD, PERCENTILE_CONT, PERCENTILE_DISC, PERCENT_RANK, RANK, NTILE, DENSE_RANK, EXPRESSION>”, “onAnalyticField”: “Field1”, “outAnalyticFieldName”: “Out_Field_Name1”,

“analyticParameters”: {

“orderBy”: “<orderBy expression”, “value”: <double value>,// percentile value “partitionBy”: “<field name or expression>”, “offset”: <integer>, // used by LAG/LEAD “windowFrame”: {

“type”: “ROWS” | “RANGE”, “extent”: {

“extentType”: “PRECEDING” | “BOUNDARY”, “PRECEDING”: {

“type”: <”UNBOUNDED” |
“NUMERIC_CONSTANT” |

“CURRENT_ROW”>

“value”: <numeric constant value>

} “BOUNDARY”: {

“start”: “UNBOUNDED_PRECEDING”,
“NUMERIC_PRECEDING”,

“CURRENT_ROW”,

“startValue”: <numeric constant value>, “end”: <”UNBOUNDED_FOLLOWING” |

“NUMERIC_FOLLOWING” | “CURRENT_ROW”,

“endValue”: <numeric constant value>

}

}

}

}

}

}

]

Example: [{

“analyticType”: “FIRST_VALUE”, “onAnalyticField”: “POP1990”, “analyticParameters”: {

“orderBy”: “POP1990”, “partitionBy”: “state_name”

}, “outAnalyticFieldName”: “FirstValue”

}

]

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.

analytic_where

Optional String. A where clause for the query filter that applies to the result set of applying the source where clause and all other params.

geometry_filter

Optional from arcgis.geometry.filter. Allows for the information to be filtered on spatial relationship with another geometry.

out_sr

Optional Integer. The WKID for the spatial reference of the returned geometry.

out_sr

Optional Integer. The output spatial reference wkid.

return_geometry

Optional boolean. If true, geometry is returned with the query. Default is true.

order_by

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

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

cache_hint

Optional Boolean. If you are performing the same query multiple times, a user can ask the server to cache the call to obtain the results quicker. The default is False.

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).

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.

quantization_parameters

Optional dict. Used to project the geometry onto a virtual grid, likely representing pixels on the screen.

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

future

Optional Boolean. This determines if a Future object is returned (True) the method returns the results directly (False).

Returns

A Pandas DataFrame (pd.DataFrame)

The query_related_records operation is performed on a FeatureLayer 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.

Note

See the query method for a similar function.

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 Polyline or Polygon objects.

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 FeatureLayer. 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_features 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.

Note

See the query method for a similar function.

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 z-values).

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.

property renderer

Get/Set the Renderer of the Feature Layer. This overrides the default symbology when displaying it on a webmap.

Returns

InsensitiveDict

property time_filter

The time_filter method is used to set a time filter instead of querying time-enabled map service layers or time-enabled feature service layers, a time filter can be specified. Time can be filtered as a single instant or by separating the two ends of a time extent with a comma.

Note

The time_filter method is supported starting at Enterprise 10.7.1+.

Input

Description

value

Required Datetime/List Datetime. This is a single or list of start/stop date.

Returns

A string of datetime values as milliseconds from epoch

update_metadata(file_path)

The update_metadata updates a FeatureLayer metadata from an xml file.

Argument

Description

file_path

Required String. The path to the .xml file that contains the metadata.

Returns

A boolean indicating success (True), or failure (False)

validate_sql(sql, sql_type='where')

The validate_sql operation validates an SQL-92 expression or WHERE clause. The validate_sql operation ensures that an SQL-92 expression, such as one written by a user through a user interface, is correct before performing another operation that uses the expression.

Note

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 SQL-92 expression. Currently, expression is used as a default value expression when adding a new field or using the calculate API.

  • statement - Represents the full SQL-92 statement that can be passed directly to the database. No current ArcGIS REST API resource or operation supports using the full SQL-92 SELECT statement directly. It has been added to the validateSQL for completeness. Values: where | expression | statement

Returns

A dictionary

arcgis.features.FeatureLayerCollection

class arcgis.features.FeatureLayerCollection(url, gis=None)

A FeatureLayerCollection is a collection of FeatureLayer and Table, 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 fromitem, from feature service endpoints using the constructor, or by accessing the dataset attribute of FeatureLayer 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, return_geometry_updates=None)

The extract_changes is an efficient change tracking mechanism for applications. Applications can use extract_changes to query changes that have been made to the layers and tables in the service.

Note

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.

Argument

Description

layers

Required List. The list of layers (by index value) and tables to include in the output.

servergen

Required List. The servergen numbers allow a client to specify the last layer generation numbers (a Unix epoch time value in milliseconds) for the changes received from the server. All changes made after this value will be returned.

  • minServerGen: It is the min generation of the server data changes. Clients with layerServerGens that is less than minServerGen cannot extract changes and would need to make a full server/layers query instead of extracting changes.

  • serverGen: It is the current server generation number of the changes. Every changed feature has a version or a generation number that is changed every time the feature is updated.

Syntax:

servergen= [{“id”: <layerId1>, “serverGen”: <genNum1>}, {“id”: <layerId2>, “serverGen”: <genNum2>}]

The id value for the layer is the index of the layer from the layers attribute on the FeatureLayerCollection. The serverGen value is a Unix epoch timestamp value in milliseconds.

# Usage Example:

servergen= [{"id": 0, "serverGen": 10500},
            {"id": 1, "serverGen": 1100},
            {"id": 2, "serverGen": 1200}]

queries

Optional Dictionary. In addition to the layers and geometry parameters, the queries parameter can be used to further define what changes to return. This parameter allows you to set query properties on a per-layer or per-table basis. If a layer’s ID is present in the layers parameter and missing from layer queries, it’s changed features that intersect with the filter geometry are returned.

The properties include the following:

  • where - Defines an attribute query for a layer or table. The default is no where clause.

  • useGeometry - Determines whether or not to apply the geometry for the layer. The default is true. If set to false, features from the layer that intersect the geometry are not added.

  • includeRelated - Determines whether or not to add related rows. The default is true. The value true is honored only for queryOption=none. This is only applicable if your data has relationship classes. Relationships are only processed in a forward direction from origin to destination.

  • queryOption - Defines whether or how filters will be applied to a layer. The queryOption was added in 10.2. See the Compatibility notes topic for more information. Valid values are None, useFilter, or all. See also the layerQueries column in the Request Parameters table in the Extract Changes (Feature Service) help for details and code samples.

  • When the value is none, no feature are returned based on where and filter geometry.

  • If includeRelated is false, no features are returned.

  • If includeRelated is true, features in this layer (that are related to the features in other layers in the replica) are returned.

  • When the value is useFilter, features that satisfy filtering based on geometry and where are returned. The value of includeRelated is ignored.

# Usage Example:

queries={Layer_or_tableID1:{"where":"attribute query",
                            "useGeometry": true | false,
                            "includeRelated": true | false},
         Layer_or_tableID2: {.}}

geometry

Optional Geometry/Extent. The geometry to apply as the spatial filter for the changes. All the changed features in layers intersecting this geometry will be returned. The structure of the geometry is the same as the structure of the JSON geometry objects returned by the ArcGIS REST API. In addition to the JSON structures, for envelopes and points you can specify the geometry with a simpler comma-separated syntax.

geometry_type

Optional String. The type of geometry specified by the geometry parameter. The geometry type can be an envelope, point, line or polygon. The default geometry type is an envelope.

Values: esriGeometryPoint, esriGeometryMultipoint, esriGeometryPolyline, esriGeometryPolygon, esriGeometryEnvelope

in_sr

Optional Integer. The spatial reference of the input geometry.

out_sr

Optional Integer/String. The output spatial reference of the returned changes.

version

Optional String. If branch versioning is enabled, a user can specify the branch version name to extract changes from.

return_inserts

Optional Boolean. If true, newly inserted features will be returned. The default is false.

return_updates

Optional Boolean. If true, updated features will be returned. The default is false.

return_deletes

Optional Boolean. If true, deleted features will be returned. The default is false.

return_ids_only

Optional Boolean. If true, the response includes an array of object IDs only. The default is false.

return_attachments

Optional Boolean. If true, attachments changes are returned in the response. Otherwise, attachments are not included. The default is false. This parameter is only applicable if the feature service has attachments.

attachments_by_url

Optional Boolean. If true, a reference to a URL will be provided for each attachment returned. Otherwise, attachments are embedded in the response. The default is true.

data_format

Optional String. The format of the changes returned in the response. The default is json. Values: sqllite or json

change_extent_grid_cell

Optional String. To optimize localizing changes extent, the value medium is an 8x8 grid that bound the changes extent. Used only when return_extent_only is true. The default is none. Values: None, large, medium, or small

return_geometry_updates

Optional Boolean. If true, the response includes a ‘hasGeometryUpdates’ property set as true for each layer with updates that have geometry changes. The default is false.

If a layer’s edits include only inserts, deletes, or updates to fields other than geometry, hasGeometryUpdates is not set or is returned as false. When a layer has multiple rows with updates, only one needs to include a geometry changes for hasGeometryUpdates to be set as true.

#Usage Example for extracting all changes to a feaature layer in a particular version since the time the Feature Layer was created.

from arcgis.gis import GIS
from arcgis.features import FeatureLayerCollection

>>> gis = GIS(<url>, <username>, <password>)

# Search for the Feature Service item
>>> fl_item = gis.content.search('title:"my_feature_layer" type:"Feature Layer"')[0]
>>> created_time = fl_item.created

# Get the Feature Service url
>>> fs=gis.content.search('title:"my_feature_layer" type:"Feature"')[0].url

# Instantiate the a FeatureLayerCollection from the url
>>> flc=FeatureLayerCollection(fs, gis)

# Extract the changes for the version
>>> extracted_changes=flc.extract_changes(layers=[0],
                           servergen=[{"id": 0, "serverGen": created_time}],
                           version="<version_owner>.<version_name>",
                           return_ids_only=True,
                           return_inserts=True,
                           return_updates=True,
                           return_deletes=True,
                           data_format="json")

>>> extracted_changes

{'layerServerGens': [{'id': 0, 'serverGen': 1600713614620}],
 'edits': [{'id': 0,
   'objectIds': {'adds': [], 'updates': [194], 'deletes': []}}]}
Returns

A dictionary containing the layerServerGens and an array of edits

classmethod fromitem(item)

The fromitem method is used to create a FeatureLayerCollection from a Item class.

Argument

Description

item

A required Item object. The item needed to convert to a FeatureLayerCollection object.

Returns

A FeatureLayerCollection object.

property manager

The manager property is a helper object to manage the FeatureLayerCollection, for example updating its definition.

property properties

The properties method retrieves and set 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)

The query method queries the current FeatureLayerCollection based on sql statement.

Argument

Description

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.

layer_defs_filter

Optional Layer Definition Filter.

return_geometry

Optional boolean. If true, geometry is returned with the query. Default 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_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.

out_sr

Optional Integer. The WKID for the spatial reference of the returned geometry.

query_domains(layers)

The query_domains returns full domain information for the domains referenced by the layers in the FeatureLayerCollection. 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.

Note

See the query method for a similar function.

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_related_records operation is performed on a FeatureLayerCollection resource. The result of this operation are feature sets grouped by source FeatureLayer/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.

Note

See the query method for a similar function.

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 FeatureLayerCollection object.

The relationships resource includes information about relationship rules from the back-end relationship classes, in addition to the relationship information already found in the individual FeatureLayer and Table.

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)

The uploads method uploads a new item to the server.

Note

Once the operation is completed successfully, the following is returned as a 2 element tuple: the success Boolean, and the JSON structure of the uploaded item

Argument

Description

path

Optional string. Filepath of the file to upload.

description

Optional string. Descriptive text for the uploaded item.

Returns

A tuple of (Boolean, dict)

property versions

The version property creates a VersionManager to create, update and use versions on a FeatureLayerCollection.

Note

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 FeatureSet is a set of features with information about their fields, field aliases, geometry type, spatial reference, and more.

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 Spatial Reference of the first feature is also not specified, the spatial reference will be UnknownCoordinateSystem.

property df

Warning

deprecated in v1.5.0 please use sdf

converts the FeatureSet to a Pandas dataframe. Requires pandas

property display_field_name

The display_field_name gets and sets the display field for the FeatureSet object.

Returns

A String

property features

The features method gets the Feature objects in the FeatureSet object.

Returns

A list of Feature objects

property fields

The fields method sets and gets the fields in the FeatureSet

static from_dataframe(df)

The from_dataframe method creates a FeatureSet objects from a Pandas’ DataFrame or SpatialDataFrame

Returns

A FeatureSet object

static from_dict(featureset_dict)

The from_dict method creates a FeatureSet objects from a dictionary.

Returns

A FeatureSet object

static from_geojson(geojson)

The from_geoJSON method creates a FeatureSet objects from a GEO JSON FeatureCollection object

Returns

A FeatureSet object

static from_json(json_str)

The from_json method creates a FeatureSet objects from a JSON string.

Returns

A FeatureSet object

property geometry_type

The geometry_type method sets or gets the Type of the FeatureSet object, such as Polygon, Polyline, or Point.

Returns

A string representing the geometry type of the FeatureSet object

property global_id_field_name

The global_id_field_name gets and sets the global ID field for the FeatureSet object.

Returns

A string

property has_m

The has_m method gets and sets the M-property of the FeatureSet object

Returns

The M-value of the FeatureSet object

property has_z

The has_z method gets and sets the Z-property of the FeatureSet object

Returns

The Z-value of the FeatureSet object

property object_id_field_name

The object_id_field_name gets and sets the object id field of the FeatureSet object

Returns

A string representing the object id field name

save(save_location, out_name, encoding=None)

The save method saves a FeatureSet object to a Feature class on disk.

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.

# Obtain a feature from a feature layer:

>>> feat_set = feature_layer.save(save_location = "C:\ArcGISProjects"
>>>                               out_name = "Power_Plant_Data")
"C:\ArcGISProjects\Power_Plant_Data"
Returns

A string

property sdf

The sdf method converts the FeatureSet to a Spatially Enabled Pandas dataframe

Returns

A Spatially Enabled Pandas Dataframe object

property spatial_reference

gets the featureset’s spatial reference

to_dict()

The to_dict method converts the FeatureSet object to a Python dictionary.

Returns

A Python dictionary

property to_geojson

The to_geojson method converts the FeatureSet object to a GeoJSON.

Returns

A GeoJSON object.

property to_json

The to_json method converts the FeatureSet object to a JSON string.

Returns

A JSON string

property value

The value method retrieves the FeatureSet object as a dictionary.

Returns

A dictionary

arcgis.features.FeatureCollection

class arcgis.features.FeatureCollection(dictdata)

FeatureCollection is an object with a layer definition and a FeatureSet.

It is an in-memory collection of Feature objects with rendering information.

Note

Feature Collections can be stored as Item objects 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)

The from_featureset method creates a FeatureCollection object from a FeatureSet object.

Argument

Description

fset

Required FeatureSet object.

symbol

Optional dict. Specify your symbol as a dictionary. Symbols for points can be picked from the Esri Symbol Page

If not specified, a default symbol will be created.

name

Optional String. The name of the feature collection. This is used when feature collections are being persisted on a WebMap. If None is provided, then a random name is generated. (New at 1.6.1)

# Usage Example

>>> feat_set = feature_layer.query(where="OBJECTID=1")
>>> feat_collect = FeatureCollection.from_featureset(feat_set)
>>> type(feat_collect)
"acrgis.features.FeatureCollection"
Returns

A FeatureCollection object.

query()

The query method retrieves the data in this feature collection as a FeatureSet.

Warning

Filtering by where clause is not supported for feature collections.

Returns

A FeatureSet object

arcgis.features.GeoAccessor

class arcgis.features.GeoAccessor(obj)

The GeoAccessor class adds a spatial namespace that performs spatial operations on the given Pandas DataFrame. The GeoAccessor class includes visualization, spatial indexing, IO and dataset level properties.

property area

The area method retrieves the total area of the GeoAccessor dataframe.

Returns

A float

>>> df.spatial.area
143.23427
property bbox

The bbox property retrieves the total length of the dataframe

Returns

Polygon

>>> df.spatial.bbox
{'rings' : [[[1,2], [2,3], [3,3],....]], 'spatialReference' {'wkid': 4326}}
property centroid

The centroid method retrieves the centroid of the dataframe

Returns

Geometry

>>> df.spatial.centroid
(-14.23427, 39)
distance_matrix(leaf_size=16, rebuild=False)

The distance_matrix creates a k-d tree to calculate the nearest-neighbor problem.

Note

The distance_matrix method requires SciPy

Argument

Description

leafsize

Optional Integer. The number of points at which the algorithm switches over to brute-force. Default: 16.

rebuild

Optional Boolean. If True, the current KDTree is erased. If false, any KD-Tree that exists will be returned.

Returns

scipy’s KDTree class

static from_df(df, address_column='address', geocoder=None, sr=None, geometry_column=None)

The from_df creates a Spatially Enabled DataFrame 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_column’ is 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.

geometry_column

Optional String. The name of the geometry column to convert to the arcgis.Geometry Objects (new at version 1.8.1)

Returns

Spatially Enabled DataFrame

NOTE: Credits will be consumed for batch_geocoding, from the GIS to which the geocoder belongs.

static from_feather(path, spatial_column='SHAPE', columns=None, use_threads=True)

The from-feather method loads a feather-format object from the file path.

Argument

Description

path

String. Path object or file-like object. Any valid string path is acceptable. The string could be a URL. Valid URL schemes include http, ftp, s3, and file. For file URLs, a host is expected. A local file could be:

file://localhost/path/to/table.feather.

If you want to pass in a path object, pandas accepts any os.PathLike.

By file-like object, we refer to objects with a read() method, such as a file handler (e.g. via builtin open function) or StringIO.

spatial_column

Optional String. The default is SHAPE. Specifies the column containing the geo-spatial information.

columns

Sequence/List/Array. The default is None. If not provided, all columns are read.

use_threads

Boolean. The default is True. Whether to parallelize reading using multiple threads.

Returns

A Pandas DataFrame (pd.DataFrame)

static from_featureclass(location, **kwargs)

The from_featureclass creates a Spatially enabled pandas.DataFrame from a Features class.

Argument

Description

location

Required string or pathlib.Path. Full path to the feature class or URL (shapefile only).

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.

Optional Parameters are not supported for URL based resources

Returns

A pandas.core.frame.DataFrame object

static from_geodataframe(geo_df, inplace=False, column_name='SHAPE')

The from_geodataframe loads a Geopandas GeoDataFrame into an ArcGIS Spatially Enabled DataFrame.

Note

The from_geodataframe method 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

A Spatially Enabled DataFrame.

static from_layer(layer)

The from_layer method imports a FeatureLayer to a Spatially Enabled DataFrame

Note

This operation converts a FeatureLayer or Table 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

A Pandas’ DataFrame

static from_table(filename, **kwargs)

The from_table method allows a User to read from a non-spatial table

Note

The from_table method requires ArcPy

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

A Pandas DataFrame (pd.DataFrame)

static from_xy(df, x_column, y_column, sr=4326)

The from_xy method converts a Pandas DataFrame into a Spatially Enabled DataFrame by providing the X/Y columns.

Argument

Description

df

Required Pandas DataFrame. Source dataset

x_column

Required string. The name of the X-coordinate series

y_column

Required string. The name of the Y-coordinate series

sr

Optional int. The wkid number of the spatial reference. 4326 is the default value.

Returns

DataFrame

property full_extent

The full_extent method retrieves the extent of the DataFrame.

Returns

A tuple

>>> df.spatial.full_extent
(-118, 32, -97, 33)
property geometry_type

The geometry_type property retrieves a list of Geometry Types for the DataFrame.

Returns

A List

property has_m

The has_m property determines if the datasets have M values

Returns

A boolean indicating M values (True), or not (False)

property has_z

The has_z property determines if the datasets have Z values

Returns

A boolean indicating Z values (True), or not (False)

join(right_df, how='inner', op='intersects', left_tag='left', right_tag='right')

The join method joins the current DataFrame to another Spatially-Enabled DataFrame based on spatial location based.

Note

The join method requires the Spatially-Enabled DataFrame 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

The length method retrieves the total length of the DataFrame

Returns

A float

>>> df.spatial.length
1.23427
property name

The name method retrieves the name of the geometry column.

Returns

A string

overlay(sdf, op='union')

The overlay performs spatial operation operations on two spatially enabled dataframes.

Note

The overlay method 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

A Spatially enabled DataFrame (pd.DataFrame)

plot(map_widget=None, **kwargs)

The plot draws the data on a web map. The user can describe in simple terms how to renderer spatial data using symbol.

Note

To make the process simpler, a palette for which colors are drawn from can be used instead of explicit colors.

** 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 counter-clockwise 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 0-1. 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 counter-clockwise 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 percent-of-total, 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 couter-clockwise 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 0-255 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 counter-clockwise. For example, The following, angle=-30, in will create a symbol rotated -30 degrees counter-clockwise; that is, 30 degrees clockwise.

marker_xoffset

Numeric value indicating the offset on the x-axis in points.

marker_yoffset

Numeric value indicating the offset on the y-axis 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 0-360, that a marker symbol is rotated. The rotation is from East in a counter-clockwise direction where East is the 0 axis.

marker_xoffset

Numeric value indicating the offset on the x-axis in points.

marker_yoffset

Numeric value indicating the offset on the y-axis 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: - line-through - 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 four-element 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 four-element 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 counter-clockwise direction where East is the 0 axis.

marker_xoffset

optional int/float.Numeric value indicating the offset on the x-axis in points.

marker_yoffset

optional int/float.Numeric value indicating the offset on the x-axis 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.

Returns

A MapView object with new drawings

project(spatial_reference, transformation_name=None)

The project method reprojects the who dataset into a new SpatialReference. This is an inplace operation meaning that it will update the defined geometry column from the set_geometry.

Note

The project method requires ArcPy or pyproj v4

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

A boolean indicating success (True), or failure (False)

relationship(other, op, relation=None)

The relationship method allows for dataframe to dataframe comparison using spatial relationships.

Note

The return is a Pandas DataFrame (pd.DataFrame) that meet the operations’ requirements.

Argument

Description

other

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.

  • intersect - Intdicates if the base geometry has an intersection of the other 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)

property renderer

The renderer property defines the renderer for the Spatially-enabled DataFrame.

Note

If none is given, then the value is reset.

Returns

InsensitiveDict

sanitize_column_names(convert_to_string=True, remove_special_char=True, inplace=False, use_snake_case=True)

The sanitize_column_names cleans column names by converting them to string, removing special characters, renaming columns without column names to noname, renaming duplicates with integer suffixes and switching spaces or Pascal or camel cases to Python’s favored snake_case style.

Snake_casing gives you consistent column names, no matter what the flavor of your backend database is when you publish the DataFrame as a Feature Layer in your web GIS.

Argument

Description

convert_to_string

Optional Boolean. Default is True. Converts column names to string

remove_special_char

Optional Boolean. Default is True. Removes any characters in column names that are not numeric or underscores. This also ensures column names begin with alphabets by removing numeral prefixes.

inplace

Optional Boolean. Default is False. If True, edits the DataFrame in place and returns Nothing. If False, returns a new DataFrame object.

use_snake_case

Optional Boolean. Default is True. Makes column names lower case, and replaces spaces between words with underscores. If column names are in PascalCase or camelCase, it replaces them to snake_case.

Returns

pd.DataFrame object if inplace= False . Else None .

select(other)

The select 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.

Note

The select method requires ArcPy or Shapely

Returns

A Pandas DataFrame (pd.DataFrame, spatially enabled)

set_geometry(col, sr=None, inplace=True)

The set_geometry method assigns the geometry column by name or by list.

Argument

Description

col

Required string, Pandas Series, GeoArray, list or tuple. If a string, this is the name of the column containing the geometry. If a Pandas Series GeoArray, list or tuple, it is an iterable of Geometry objects.

sr

Optional integer or spatial reference of the geometries described in the first parameter. If the geometry objects already have the spatial reference defined, this is not necessary. If the spatial reference for the geometry objects is NOT define, it will default to WGS84 (wkid 4326).

inplace

Optional bool. Whether or not to modify the dataframe in place, or return a new dataframe. If True, nothing is returned and the dataframe is modified in place. If False, a new dataframe is returned with the geometry set. Defaults to True.

Returns

Spatially Enabled DataFrame or None

sindex(stype='quadtree', reset=False, **kwargs)

The sindex creates a spatial index for the given dataset.

Note

By default, the spatial index is a QuadTree spatial index.

r-tree indexes should be used for large datasets. This will allow users to create very large out of memory indexes. To use r-tree indexes, the r-tree library must be installed. To do so, install via conda using the following command: conda install -c conda-forge rtree

Returns

A spatial index for the given dataset.

property sr

The sr property gets and sets the SpatialReference of the dataframe

to_feature_collection(name=None, drawing_info=None, extent=None, global_id_field=None)

The to_feature_collection converts a spatially enabled a Pandas DataFrame to a FeatureCollection .

optional argument

Description

name

optional string. Name of the FeatureCollection

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 the Renderer Objects page in the ArcGIS REST API for more information.

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

A FeatureCollection object

to_featureclass(location, overwrite=True, has_z=None, has_m=None, sanitize_columns=True)

The to_featureclass exports a spatially enabled dataframe to a feature class.

Argument

Description

location

Required string. The output of the table.

overwrite

Optional Boolean. If True and if the feature class exists, it will be deleted and overwritten. This is default. If False, the feature class and the feature class exists, and exception will be raised.

has_z

Optional Boolean. If True, the dataset will be forced to have Z based geometries. If a geometry is missing a Z value when true, a RuntimeError will be raised. When False, the API will not use the Z value.

has_m

Optional Boolean. If True, the dataset will be forced to have M based geometries. If a geometry is missing a M value when true, a RuntimeError will be raised. When False, the API will not use the M value.

sanitize_columns

Optional Boolean. If True, column names will be converted to string, invalid characters removed and other checks will be performed. The default is True.

Returns

A String

to_featurelayer(title, gis=None, tags=None, folder=None)

The to_featurelayer method publishes a spatial dataframe to a new FeatureLayer object.

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

A FeatureLayer object.

to_featureset()

The to_featureset method converts a Spatially Enabled DataFrame object. to a FeatureSet object.

Returns

A FeatureSet object

to_table(location, overwrite=True)

The to_table method exports a geo enabled dataframe to a Table object.

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

The true_centroid property retrieves the true centroid of the DataFrame

Returns

A Geometry object

>>> df.spatial.true_centroid
(1.23427, 34)
validate(strict=False)

The validate method determines if the GeoAccessor is Valid with Geometry objects in all values

Returns

A boolean indicating Success (True), or Failure (False)

voronoi()

The voronoi method generates a voronoi diagram on the whole dataset.

Note

If the Geometry object is not a :class:`~arcgis.geometry.Point then the centroid is used for the geometry. The result is a Polygon GeoArray Series that matches 1:1 to the original dataset.

Note

The voronoi method requires SciPy

Returns

A Pandas Series (pd.Series)

arcgis.features.GeoSeriesAccessor

class arcgis.features.GeoSeriesAccessor(obj)
property JSON

The JSON method creates a JSON string out of the Geometry object.

Returns

Series of strings

property WKB

The WKB method retrieves the Geometry object as a WKB

Returns

A Series of Bytes

property WKT

The WKT method retrieves the Geometry object’s WKT

Returns

Series of String

angle_distance_to(second_geometry, method='GEODESIC')

The angle_distance_to method retrieves a tuple of angle and distance to another point using a measurement method.

Argument

Description

second_geometry

Required Geometry. A 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 Series where each element is a tuple of angle and distance to another point using a measurement type.

property area

The area method retrieves the Feature object’s area.

returns

A float in a series

property as_arcpy

The as_arcpy method retrieves the features as an ArcPy geometry object.

Returns

An arcpy.geometry as a series

property as_shapely

The as_shapely method retrieves the features as Shapely`Geometry <https://shapely.readthedocs.io/en/stable/manual.html#geometric-objects>`_

Returns

shapely.Geometry objects in a series

boundary()

The boundary method constructs the boundary of the Geometry object.

Returns

A Pandas Series of Polyline objects

buffer(distance)

The buffer method constructs a Polygon at a specified distance from the Geometry object.

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

A Pandas Series of Polygon objects

property centroid

Returns the feature’s centroid

Returns

tuple (x,y) in series

clip(envelope)

The clip method constructs the intersection of the Geometry object 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

A Pandas Series of Geometry objects

contains(second_geometry, relation=None)

The contains method indicates if the base Geometry contains the comparison Geometry.

Argument

Description

second_geometry

Required 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

A Pandas Series of booleans indicating success (True), or failure (False)

convex_hull()

The convex_hull method constructs the Geometry that is the minimal bounding Polygon such that all outer angles are convex.

Returns

A Pandas Series of Geometry objects

crosses(second_geometry)

The crosses method indicates if the two Geometry objects intersect in a geometry of a lesser shape type.

Argument

Description

second_geometry

Required Geometry. A second geometry

Returns

A Pandas Series of booleans indicating success (True), or failure (False)

cut(cutter)

The cut method splits this Geometry into a part to the left of the cutting Polyline and a part to the right of it.

Argument

Description

cutter

Required Polyline. The cutting polyline geometry

Returns

A Pandas Series where each element is a list of two Geometry objects

densify(method, distance, deviation)

The densify method 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

A Pandas Series of Geometry objects

difference(second_geometry)

The difference method constructs the Geometry that is composed only of the region unique to the base geometry but not part of the other geometry.

Argument

Description

second_geometry

Required Geometry. A second geometry

Returns

A Pandas Series of Geometry objects

disjoint(second_geometry)

The disjoint method indicates if the base and comparison Geometry objects share no Point objects in common.

Argument

Description

second_geometry

Required Geometry. A second geometry

Returns

A Pandas Series of booleans indicating success (True), or failure (False)

distance_to(second_geometry)

The distance_to method retrieves the minimum distance between two Geometry. If the geometries intersect, the minimum distance is 0.

Note

Both geometries must have the same projection.

Argument

Description

second_geometry

Required Geometry. A second geometry

Returns

A Pandas Series of floats

equals(second_geometry)

The equals method indicates if the base and comparison Geometry objects are of the same shape type and define the same set of Point objects in the plane.

Note

This is a 2D comparison only; M and Z values are ignored.

Argument

Description

second_geometry

Required Geometry. A second geometry

Returns

A Pandas Series of booleans indicating success (True), or failure (False)

property extent

The extent method retrieves the feature’s extent

Returns

A tuple (xmin,ymin,xmax,ymax) in series

property first_point

The first_point property retrieves the feature’s first Point object

Returns

A Point object

generalize(max_offset)

The generalize method creates a new simplified Geometry using a specified maximum offset tolerance.

Note

This only works on Polyline and Polygon objects.

Argument

Description

max_offset

Required float. The maximum offset tolerance.

Returns

A Pandas Series of Geometry objects

property geoextent

The geoextent method retrieves the Geometry object’s extents

Returns

A Series of Floats

property geometry_type

The geometry_type property retrieves the Geometry object’s type.

Returns

A Series of strings

get_area(method, units=None)

The get_area method retreives the area of the feature using a measurement type.

Returns

A Pandas Series of floats

get_length(method, units)

The get_length method retrieves 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

A A Pandas Series of floats

get_part(index=None)

The get_part method retrieves 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

AnA Pandas Series of arcpy.Arrays

property has_m

The has_m method determines if the Geometry objects has an M value

Returns

A Series of Booleans

property has_z

The has_z method determines if the Geometry object has a Z value

Returns

A Series of Booleans

property hull_rectangle

The hull_rectangle retrieves a space-delimited string of the coordinate pairs of the convex hull

Returns

A Series of strings

intersect(second_geometry, dimension=1)

The intersect method constructs a Geometry that is the geometric intersection of the two input geometries. Different dimension values can be used to create different shape types.

Note

The intersection of two Geometry objects of the same shape type is a geometry containing only the regions of overlap between the original geometries.

Argument

Description

second_geometry

Required Geometry. A second geometry

dimension

Required Integer. The topological dimension (shape type) of the resulting geometry.

  • 1 -A zero-dimensional geometry (point or multipoint).

  • 2 -A one-dimensional geometry (polyline).

  • 4 -A two-dimensional geometry (polygon).

Returns

A Pandas Series of Geometry objects

property is_empty

The is_empty method determines if the Geometry object is empty.

Returns

A Series of Booleans

property is_multipart

The is_multipart method determines if features has multiple parts.

Returns

A Series of Booleans

property is_valid

The is_valid method determines if the features Geometry is valid

Returns

A Series of Booleans

property label_point

The label_point method determines the Point for the optimal label location.

Returns

A Series of Geometry object

property last_point

The last_point method retrieves the Geometry of the last point in a feature.

Returns

A Series of Geometry objects

property length

The length method retrieves the length of the features.

Returns

A Series of floats

property length3D

The length3D method retrieves the length of the features

Returns

A Series of floats

measure_on_line(second_geometry, as_percentage=False)

The measure_on_line method retrieves the measure from the start Point of this line to the in_point.

Argument

Description

second_geometry

Required 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

A Pandas Series of floats

overlaps(second_geometry)

The overlaps method indicates if the intersection of the two Geometry objects 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 Geometry. A second geometry

Returns

A Pandas Series of booleans indicating success (True), or failure (False)

property part_count

The part_count method retrieves the number of parts in a feature’s Geometry

Returns

A Series of Integers

property point_count

The point_count method retrieves the number of Point objects in a feature’s Geometry.

Returns

A Series of Integers

point_from_angle_and_distance(angle, distance, method='GEODESCIC')

The point_from_angle_and_distance retrieves 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

A Pandas Series of Geometry objects

position_along_line(value, use_percentage=False)

The position_along_line method retrieves 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

A Pandas Series of Geometry objects.

project_as(spatial_reference, transformation_name=None)

The project_as method 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

A Pandas Series of Geometry objects

query_point_and_distance(second_geometry, use_percentage=False)

The query_point_and_distance finds the Point on the Polyline nearest to the in_point and the distance between those points.

Note

query_point_and_distance 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 Geometry. A second geometry

as_percentage

Optional boolean - if False, the measure will be returned as distance, True, measure will be a percentage

Returns

A Pandas Series of tuples

segment_along_line(start_measure, end_measure, use_percentage=False)

The segment_along_line method retrieves a Polyline between start and end measures. Similar to 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

A Pandas Series of Geometry objects

snap_to_line(second_geometry)

The snap_to_line method creates a new Point based on in_point snapped to this Geometry object.

Argument

Description

second_geometry

Required Geometry. A second geometry

Returns

A Pandas Series of Geometry objects

property spatial_reference

The spatial_reference method retrieves the SpatialReference of the Geometry

Returns

A Series of SpatialReference objects.

symmetric_difference(second_geometry)

The symmetric_difference method constructs the Geometry that is the union of two geometries minus the intersection of those geometries.

Note

The two input Geometry must be the same shape type.

Argument

Description

second_geometry

Required Geometry. A second geometry

Returns

A Pandas Series of Geometry objects

touches(second_geometry)

The touches method indicates if the boundaries of the Geometry intersect.

Argument

Description

second_geometry

Required Geometry. A second geometry

Returns

A Pandas Series of booleans indicating touching (True), or not touching (False)

property true_centroid

The true_centroid method retrieves the true centroid of the Geometry object.

Returns

A Series of Point objects

union(second_geometry)

The union method constructs the Geometry object that is the set-theoretic union of the input geometries.

Argument

Description

second_geometry

Required Geometry. A second geometry

Returns

A Pandas Series of Geometry objects

within(second_geometry, relation=None)

The within method indicates if the base Geometry is within the comparison Geometry.

Argument

Description

second_geometry

Required 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

A Pandas Series of booleans indicating within (True), or not within (False)

arcgis.features.SpatialDataFrame

class arcgis.features.SpatialDataFrame(*args, **kwargs)

Warning

The SpatialDataFrame class is deprecated in favor of the GeoAccessor and the GeoSeriesAccessor pattern. Please see those classes for more details.

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 sub-set 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 well-known 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 well-known 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 element-wise.

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, element-wise (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 list-like 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 to numpy.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 user-defined-function 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 to numpy.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 user-defined-function 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 column-wise values all return True.

>>> df.all()
col1     True
col2    False
dtype: bool

Specify axis='columns' to check if row-wise 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. non-zero or non-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 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/dict-like 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’ : list-like results will be turned into columns.

  • ‘reduce’ : returns a Series if possible rather than expanding list-like 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: list-like 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 list-like 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 list-like 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 list-like 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
2000-01-01 00:00:00    0.0
2000-01-01 00:01:00    NaN
2000-01-01 00:02:00    2.0
2000-01-01 00:03:00    3.0

Upsample the series into 30 second bins.

>>> df.asfreq(freq='30S')
                       s
2000-01-01 00:00:00    0.0
2000-01-01 00:00:30    NaN
2000-01-01 00:01:00    NaN
2000-01-01 00:01:30    NaN
2000-01-01 00:02:00    2.0
2000-01-01 00:02:30    NaN
2000-01-01 00:03:00    3.0

Upsample again, providing a fill value.

>>> df.asfreq(freq='30S', fill_value=9.0)
                       s
2000-01-01 00:00:00    0.0
2000-01-01 00:00:30    9.0
2000-01-01 00:01:00    NaN
2000-01-01 00:01:30    9.0
2000-01-01 00:02:00    2.0
2000-01-01 00:02:30    9.0
2000-01-01 00:03:00    3.0

Upsample again, providing a method.

>>> df.asfreq(freq='30S', method='bfill')
                       s
2000-01-01 00:00:00    0.0
2000-01-01 00:00:30    NaN
2000-01-01 00:01:00    NaN
2000-01-01 00:01:30    2.0
2000-01-01 00:02:00    2.0
2000-01-01 00:02:30    3.0
2000-01-01 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 array-like of dates

Date(s) before which the last row(s) are returned.

subsetstr or array-like 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 array-like, or when self is a DataFrame and where is a scalar

  • DataFrame : when self is a DataFrame and where is an array-like

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 for 30.

>>> 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(['2018-02-27 09:01:00',
...                                           '2018-02-27 09:02:00',
...                                           '2018-02-27 09:03:00',
...                                           '2018-02-27 09:04:00',
...                                           '2018-02-27 09:05:00']))
>>> df.asof(pd.DatetimeIndex(['2018-02-27 09:03:30',
...                           '2018-02-27 09:04:30']))
                      a   b
2018-02-27 09:03:30 NaN NaN
2018-02-27 09:04:30 NaN NaN

Take a single column into consideration

>>> df.asof(pd.DatetimeIndex(['2018-02-27 09:03:30',
...                           '2018-02-27 09:04:30']),
...         subset=['a'])
                         a   b
2018-02-27 09:03:30   30.0 NaN
2018-02-27 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 re-assigned 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 column-specific types.

copybool, default True

Return a copy when copy=True (be very careful setting copy=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 raised

  • ignore : 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   2020-01-01
1   2020-01-02
2   2020-01-03
dtype: datetime64[ns]

Datetimes are localized to UTC first before converting to the specified timezone:

>>> ser_date.astype('datetime64[ns, US/Eastern]')
0   2019-12-31 19:00:00-05:00
1   2020-01-01 19:00:00-05:00
2   2020-01-02 19:00:00-05: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 label-based lookups. Use at 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('2018-04-09', periods=4, freq='12H')
>>> ts = pd.DataFrame({'A': [1, 2, 3, 4]}, index=i)
>>> ts
                     A
2018-04-09 00:00:00  1
2018-04-09 12:00:00  2
2018-04-10 00:00:00  3
2018-04-10 12:00:00  4
>>> ts.at_time('12:00')
                     A
2018-04-09 12:00:00  2
2018-04-10 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() with method='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:00-9:30 AM).

By setting start_time to be later than end_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('2018-04-09', periods=4, freq='1D20min')
>>> ts = pd.DataFrame({'A': [1, 2, 3, 4]}, index=i)
>>> ts
                     A
2018-04-09 00:00:00  1
2018-04-10 00:20:00  2
2018-04-11 00:40:00  3
2018-04-12 01:00:00  4
>>> ts.between_time('0:15', '0:45')
                     A
2018-04-10 00:20:00  2
2018-04-11 00:40:00  3

You get the times that are not between two times by setting start_time later than end_time:

>>> ts.between_time('0:45', '0:15')
                     A
2018-04-09 00:00:00  1
2018-04-12 01:00:00  4
bfill(axis=None, inplace: bool = False, limit=None, downcast=None) → Optional[FrameOrSeries]

Synonym for DataFrame.fillna() with method='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 box-and-whisker 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 array-like, optional

Column in the DataFrame to pandas.DataFrame.groupby(). One box-plot 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 top-left.

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 to return_type is returned.

    If return_type is None, a NumPy array of axes with the same shape as layout is returned.

backendstr, default None

Backend to use instead of the backend specified in the option plotting.backend. For instance, ‘matplotlib’. Alternatively, to specify the plotting.backend for the whole session, set pd.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 (for return_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 x-axis:

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 x-axis (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. When return_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 to return_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 as layout 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: pandas.core.indexes.base.Index

The column labels of the DataFrame.

combine(other: pandas.core.frame.DataFrame, func, fill_value=None, overwrite=True) → pandas.core.frame.DataFrame

Perform column-wise combine with another DataFrame.

Combines a DataFrame with other DataFrame using func to element-wise combine columns. The row and column indexes of the resulting DataFrame will be the union of the two.

otherDataFrame

The DataFrame to merge column-wise.

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

non-null 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 element-wise 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 non-null 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 series-wise 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 support pd.NA. By using the options convert_string, convert_integer, and convert_boolean, it is possible to turn off individual conversions to StringDtype, the integer extension types or BooleanDtype, respectively.

For object-dtyped columns, if infer_objects is True, use the inference rules as during normal Series/DataFrame construction. Then, if possible, convert to StringDtype, BooleanDtype or an appropriate integer extension type, otherwise leave as object.

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 column-wise, 1 or ‘columns’ for row-wise.

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 non-NA 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 non-NA/null entries. If level is specified returns a DataFrame.

Series.count: Number of non-NA elements in a Series. DataFrame.shape: Number of DataFrame rows and columns (including NA

elements).

DataFrame.isna: Boolean same-sized 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, where N 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 N-ddof.

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 semi-definite. This could lead to estimate correlations having absolute values which are greater than one, and/or a non-invertible 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 non-NA 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 or axis='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 or axis='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 or axis='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 or axis='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.

percentileslist-like 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’, list-like 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 list-like 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 the numpy.object data type. Strings can also be used in the style of select_dtypes (e.g. df.describe(include=['O'])). To select pandas categorical columns, use 'category'

  • None (default) : The result will include all numeric columns.

excludelist-like 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 list-like of dtypes : Excludes the provided data types from the result. To exclude numeric types submit numpy.number. To exclude object columns submit the data type numpy.object. Strings can also be used in the style of select_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 non-NA/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 is 25 and the upper percentile is 75. The 50 percentile is the same as the median.

For object data (e.g. strings or timestamps), the result’s index will include count, unique, top, and freq. The top is the most common value. The freq is the most common value’s frequency. Timestamps also include the first and last items.

If multiple object values have the highest count, then the count and top 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. If include='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 a Series.

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("2000-01-01"),
...   np.datetime64("2010-01-01"),
...   np.datetime64("2010-01-01")
... ])
>>> s.describe(datetime_is_numeric=True)
count                      3
mean     2006-09-01 08:00:00
min      2000-01-01 00:00:00
25%      2004-12-31 12:00:00
50%      2010-01-01 00:00:00
75%      2010-01-01 00:00:00
max      2010-01-01 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 than operator.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, element-wise (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 list-like 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, element-wise (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 list-like 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 array-like

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 multi-index, labels on different levels can be removed by specifying the level.

labelssingle label or list-like

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 list-like

Alternative to specifying axis (labels, axis=0 is equivalent to index=labels).

columnssingle label or list-like

Alternative to specifying axis (labels, axis=1 is equivalent to columns=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 : Label-location 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: Optional[Union[Hashable, Sequence[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 list-like

If a string is given, must be the name of a level If list-like, 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 non-NA values.

subsetarray-like, 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 (non-missing) 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("1940-04-25"),
...                             pd.NaT]})
>>> df
       name        toy       born
0    Alfred        NaN        NaT
1    Batman  Batmobile 1940-04-25
2  Catwoman   Bullwhip        NaT

Drop the rows where at least one element is missing.

>>> df.dropna()
     name        toy       born
1  Batman  Batmobile 1940-04-25

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 1940-04-25
2  Catwoman   Bullwhip        NaT

Keep only the rows with at least 2 non-NA values.

>>> df.dropna(thresh=2)
       name        toy       born
1    Batman  Batmobile 1940-04-25
2  Catwoman   Bullwhip        NaT

Define in which columns to look for missing values.

>>> df.dropna(subset=['name', 'born'])
       name        toy       born
1    Batman  Batmobile 1940-04-25

Keep the DataFrame with valid entries in the same variable.

>>> df.dropna(inplace=True)
>>> df
     name        toy       born
1  Batman  Batmobile 1940-04-25
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: Optional[Union[Hashable, Sequence[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 as True except for the first occurrence.

  • last : Mark duplicates as True 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, element-wise (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 list-like 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 by query().

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 multi-line 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, or alpha 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 half-life, \(\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 to mean() 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_{t-1} + (1 - \alpha)^2 x_{t-2} + ... + (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_{t-1} + \alpha x_t, \end{split}\end{split}\]
ignore_nabool, default False

Ignore missing values when calculating weights; specify True to reproduce pre-0.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\) if adjust=True, and \((1-\alpha)^2\) and \(\alpha\) if adjust=False.

  • When ignore_na=True (reproducing pre-0.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\) if adjust=True, and \(1-\alpha\) and \(\alpha\) if adjust=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 1-D array like, a sequence with the same shape as the observations.

Only applicable to mean().

DataFrame

A Window sub-classed 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 timedelta halflife when computing mean.

>>> times = ['2020-01-01', '2020-01-03', '2020-01-10', '2020-01-15', '2020-01-17']
>>> 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 sub-classed 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 list-like 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 list-like columns to long format.

This routine will explode list-likes including lists, tuples, Series, and np.ndarray. The result dtype of the subset rows will be object. Scalars will be returned unchanged. Empty list-likes 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() with method='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 in-place. Note: this will modify any other views on this object (e.g., a no-copy 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 non-null 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.

itemslist-like

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, and regex 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('2018-04-09', periods=4, freq='2D')
>>> ts = pd.DataFrame({'A': [1, 2, 3, 4]}, index=i)
>>> ts
            A
2018-04-09  1
2018-04-11  2
2018-04-13  3
2018-04-15  4

Get the rows for the first 3 days:

>>> ts.first('3D')
            A
2018-04-09  1
2018-04-11  2

Notice the data for 3 first calendar days were returned, not the first 3 days observed in the dataset, and therefore data for 2018-04-13 was not returned.

property first_point

The first coordinate point of the geometry.

first_valid_index()

Return index for first non-NA/null value.

scalar : type of index

If all elements are non-NA/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, element-wise (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 list-like 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 array-like or dicts.

Creates DataFrame object from dictionary by columns or by index allowing dtype specification.

datadict

Of the form {field : array-like} 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 with orient='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, array-like

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 all-NA columns).

coerce_floatbool, default False

Attempt to convert values of non-string, non-numeric 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 array-like 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 X-coordinate series

y_column

Required string. The name of the Y-coordinate 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, element-wise (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 list-like 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 | SQUAREFEET
SQUAREKILOMETERS | 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 as-is determine the groups. A label or list of labels may be passed to group by the columns in self. 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 “SQL-style” 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, element-wise (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 list-like 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: Union[Hashable, None, Sequence[Optional[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 x-axis 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 y-axis 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 the plotting.backend for the whole session, set pd.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 space-delimited 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 integer-based lookups. Use iat 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 row-wise, 1 or ‘columns’ for column-wise.

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 row-wise, 1 or ‘columns’ for column-wise.

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 integer-location based indexing for selection by position.

.iloc[] is primarily integer position based (from 0 to length-1 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 raise IndexError if a requested indexer is out-of-bounds, except slice indexers which allow out-of-bounds indexing (this conforms with python/numpy slice semantics).

See more at Selection by Position.

DataFrame.iat : Fast integer location scalar accessor. DataFrame.loc : Purely label-location based indexer for selection by label. Series.iloc : Purely integer-location 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: pandas.core.indexes.base.Index

The index (row labels) of the DataFrame.

infer_objects() → FrameOrSeries

Attempt to infer better dtypes for object columns.

Attempts soft conversion of object-dtyped columns, leaving non-object 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 human-readable units (base-2 representation).

null_countsboolean, default None

Whether to show the non-null 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 t