Shulou(Shulou.com)06/02 Report--

This article mainly shows you "how to use Geopandas in python", the content is easy to understand, clear, hope to help you solve your doubts, the following let the editor lead you to study and learn "how to use Geopandas in python" this article.

Key words: Python Geopandas spatial data analysis

This paper describes the process of completing a spatial data analysis operation with the help of Python language and Geopandas toolkit.

As a programmer and part-time amateur spatial data analyst, the processing of spatial data has always been a lingering dark cloud. Although the visual interface and all-inclusive functions of GIS software have been able to solve almost all the problems in daily work, as a programmer, all the problems that can not be solved with 26 letters on the keyboard are unscientific ~ so all these years I have been devoting myself to thinking about a problem, how to realize the function of Arcgis in code.

I have learned that Geopandas is an excellent tool, and today we will take a case to take a peek at it.

▼

Data preparation & clear tasks

I have a map of Shanghai's streets and towns, a copy of Shanghai's housing data and a Shanghai restaurant data.

Today, we need to create a 1KM buffer for each house, calculate how many restaurants are in the buffer zone, and calculate how many restaurants are in each street and town in Shanghai, and then show them on the map.

This is a theoretically simple but tedious process, and some students may already know the operation of GIS:

Import map data-import two EXCEL-- and associate latitude and longitude-get point data-and save point data layer-then buffer the source point data-save buffer layer-use spatial association to join restaurant data to Shanghai street and source buffer layer-and save layer respectively.

All right, I can't talk anymore. Let's see how the code solves it.

▼

Import data

Import various packages first

Import pandas as pd

Import geopandas as gpd

From shapely import geos

From shapely.geometry import Point

Import fiona

Import matplotlib.pyplot as plt

From fiona.crs import from_epsg,from_string

Let's take a look at the name of the geographic processing toolkit used in python: Geopandas. As the name implies, this package allows us to deal with geographic data like pandas. You can imagine that the process must be as smooth as silk!

Geopandas is actually the aggregator of all kinds of geographic data analysis packages, including shapely,Fiona, etc., and, of course, the package numpy,pandas related to data analysis, so the functions in these packages can be mixed and switched without leaving a trace. It's imported here as well.

Import Map shp

Shanghai_map = gpd.GeoDataFrame.from_file ('. / Shanghai Street Town / Shanghai Street Town .shp') # read shapfile data in geodataframe format

Geopandas provides a data format called GeoDataFrame, which, to put it bluntly, means that DataFrame adds a column of data to express geographic information. The import function Geopandas calls the Fiona package at the bottom, so you can refer to the Fiona documentation for some basic parameters and data formats that can be imported.

View imported data

Just like DataFrame, but with an extra column of Geometry to store geographic information, take a look at the drawing:

Yeah! It looks like this!

Next, import housing and restaurant data

* these two data are in CSV format and imported into DataFrame. We found that the data contains latitude and longitude fields. According to these two fields, we can also convert the data into GeoDataFrame format.

Convert point data by latitude and longitude:

Def point_to_geo (df,lon,lat):

Df ['geometry'] = gpd.GeoSeries (list (zip (df [lon], df [lat])) .apply (Point) # identifies longitude and latitude and converts point data

Df = gpd.GeoDataFrame (df) # convert Geodataframe format

Df.crs = {'init':'epsg:4326'} # define coordinate system WGS84

Del df [lon]

Del df [lat]

Return df

House_data = point_to_geo (house_data,'lon_WGS','lat_WGS') # convert Geodataframe format

Restaurant_data = point_to_geo (restaurant_data,'lon_WGS','lat_WGS') # convert Geodataframe format

* for official documents, please see here:

Drawing to see whether it is successful or not-- taking Shanghai Street and Town as the base map, two pieces of point data are superimposed on the base map.

Base = shanghai_map.plot (color='lightyellow',edgecolor='black',figsize= (15,15)) # bottom drawing

Restaurant_data.plot (ax=base,marker='o', color='green', markersize=5) # overlays restaurant data on the base map

House_data.plot (ax=base,marker='o', color='red', markersize=5) # overlays housing source point data on the base map

Plt.gca () .xaxis.set_major_locator (plt.NullLocator ()) # remove the x-axis scale

Plt.gca () .yaxis.set_major_locator (plt.NullLocator ()) # remove the y-axis scale

Plt.savefig ('. / map.png',dpi=400) # Save the picture

* the basic parameters of the graph are set here, and the drawing function is based on matplotlib, so some of its writing methods and functions are universal.

Display OK, then go to the core link ~

▼

Analysis process

Before making the buffer and spatial association, you need to make a projection transformation of the graph, and here you still write a function:

Def wgs84_to_CGCS2000 (df,code):

Result = df.to_crs (from_epsg (code))

Return result

Shanghai_map_pcs = wgs84_to_CGCS2000 (shanghai_map,4549)

House_data_pcs = wgs84_to_CGCS2000 (house_data,4549)

Restaurant_data_pcs = wgs84_to_CGCS2000 (restaurant_data,4549)

* as long as you know the ESPG code of the projection coordinate system, you can convert it at will. We use the GSC2000 coordinate system.

Next, build the buffer layer, using the buffer () method, with the argument to the radius of the buffer.

House_data_buffer = house_data_pcs.buffer (1000) # establish an one kilometre buffer zone

Base = shanghai_map_pcs.plot (color='lightyellow',edgecolor='black',figsize= (15,15))

House_data_buffer.plot (ax=base,color='gray', markersize=5,alpha=0.5)

Plt.gca () .xaxis.set_major_locator (plt.NullLocator ()) # remove the x-axis scale

Plt.gca (). Yaxis.set_major_locator (plt.NullLocator ()) # Last year's y-axis scale

Plt.savefig ('. / map2.png',dpi=400) # Save the picture

After the construction is completed, it is also output as a map view effect:

With the increase of transparency, we can see that the housing density in the city center is relatively high. The generated data is GeoSeries, and the data is the geographic information of the buffer. Here you need to use any method to match the geographic information with other fields.

Buffer_temp = house_data_pcs [['name','geometry']]

Buffer_temp ['geometry'] = house_data_buffer

House_data_buffer = buffer_temp

Next, we use spatial association to connect restaurant data and get the number of restaurants.

Spacial_join_restaurant = gpd.sjoin (house_data_buffer,restaurant_data_pcs,how='left',op='contains') # Spatial connection

Spacial_join_restaurant = spacial_join_restaurant.groupby (['name']). Count () [' title']. To_frame (). Reset_index () # number of aggregate calculations

Spacial_join_restaurant.columns = ['name','restaurant_count'] # change the column name to facilitate operation

Buffer_result = pd.merge (house_data_pcs,spacial_join_restaurant,left_on='name',right_on='name',how='left') # field match

* the method is sjoin (), which has the same function as GIS, intersects, contains and is included. We use the include to connect and use the groupby () method of pandas to group the count.

In this way, we have completed the spatial association and calculation, and we can use the map display and add legends:

Base = shanghai_result.plot (column='restaurant_count', cmap='Oranges',scheme = 'fisher_jenks'

, legend=True,edgecolor='black',figsize= (15,15) # overlay the background color according to the number

Plt.gca () .xaxis.set_major_locator (plt.NullLocator ()) # remove the x-axis scale

Plt.gca (). Yaxis.set_major_locator (plt.NullLocator ()) # Last year's y-axis scale

Plt.savefig ('. / map3.png',dpi=400) # Save the picture

In this way, you can draw a point density map in terms of streets and towns:

Finally, we need to export and save the data. We can save it in shapfile format. It is recommended that you save it directly in csv format to facilitate sharing. It can also be converted to any format as needed.

Shanghai_result = wgs84_to_CGCS2000 (shanghai_result,4326) # converted to geographic coordinate system

Shanghai_result.columns = ['town','region','geometry','restaurant_count'] # change the column name to English because the data preservation does not support Chinese well

Buffer_result = wgs84_to_CGCS2000 (buffer_result,4326) # converted to geographic coordinate system

Shanghai_result.to_csv ('. / result/shanghai_result.csv') # Save as csv

Shanghai_result.to_file ('. / result/shanghai_result.shp') # Save as shapfile

Buffer_result.to_csv ('. / result/buffer_result.csv') # Save as csv

Buffer_result.to_file ('. / result/buffer_result.shp') # Save as shapfile

▼

Result check

We import the saved data into Arcgis, which can be used normally. Great!

The above is all the content of the article "how to use Geopandas in python". Thank you for reading! I believe we all have a certain understanding, hope to share the content to help you, if you want to learn more knowledge, welcome to follow the industry information channel!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.