From 64112fbc0ab99c28bc4e81a65ee4e31809709a5b Mon Sep 17 00:00:00 2001 From: Henrikki Tenkanen Date: Wed, 4 Oct 2023 16:44:03 +0300 Subject: [PATCH] Update the rest of introductory geopandas section --- source/part2/chapter-06/md/01-geodataframe.md | 86 +++--- .../part2/chapter-06/nb/01-geodataframe.ipynb | 269 +++++++++++------- 2 files changed, 213 insertions(+), 142 deletions(-) diff --git a/source/part2/chapter-06/md/01-geodataframe.md b/source/part2/chapter-06/md/01-geodataframe.md index 76b54619..33dcbdae 100644 --- a/source/part2/chapter-06/md/01-geodataframe.md +++ b/source/part2/chapter-06/md/01-geodataframe.md @@ -320,7 +320,7 @@ After this small adjustment, geopandas was able to read the KML file without a p -Lastly, we demonstrate how it is possible to read data directly from a Zipfile which can be quite useful especially if you are working with large datasets or a collection of multiple files stored into a single Zipfile. ZipFile is a data format where the data is compressed efficiently. For instance after "zipping" Shapefiles, the disk space needed to store the data in the given format will be significantly lower.To read the data from ZipFiles, we can use the built-in Python library called **zipfile** and its `ZipFile` object, which makes it possible to work with compressed ZipFiles. The following example shows how to read data from a ZipFile. Let's start by opening the ZipFile into a variable `z` and read the names of the files stored inside of it: +Lastly, we demonstrate how it is possible to read data directly from a Zipfile which can be quite useful especially if you are working with large datasets or a collection of multiple files stored into a single Zipfile. ZipFile is a data format where the data is compressed efficiently. For instance after "zipping" Shapefiles, the disk space needed to store the data in the given format will be significantly lower. To read the data from ZipFiles, we can use the built-in Python library called **zipfile** and its `ZipFile` object, which makes it possible to work with compressed ZipFiles. The following example shows how to read data from a ZipFile. Let's start by opening the ZipFile into a variable `z` and read the names of the files stored inside of it with the method `.namelist()`: ```python editable=true slideshow={"slide_type": ""} @@ -333,7 +333,7 @@ with ZipFile(fp) as z: ``` -As we can see, the given ZipFile contains only a single GeoPackage called `building_points_helsinki.gpkg`. The `with ZipFile(fp) as z` command here is a standard Python convention to open files in read-format from ZipFiles. To read the contents of the GeoPackage stored inside the ZipFile, we first need use the `.read()` function of the opened `ZipFile` object to read the contents of the file into bytes. After this step, we still need to pass these bytes into a `BytesIO` in-memory file buffer by using the built-in `io` library. This file buffer that can then be used to read the actual contents of the file into geopandas. This maybe sounds complicated, but it actually only requires a few lines of code: +As we can see, the given `ZipFile` contains only a single GeoPackage called `building_points_helsinki.gpkg`. The `with ZipFile(fp) as z:` command here is a standard Python convention to open files in read-format from ZipFiles. To read the contents of the GeoPackage stored inside the ZipFile, we first need use the `.read()` function of the opened `ZipFile` object to read the contents of the file into bytes. After this step, we still need to pass these bytes into a `BytesIO` in-memory file buffer by using the built-in `io` library. This file buffer that can then be used to read the actual contents of the file into geopandas. This maybe sounds complicated, but it actually only requires a few lines of code: ```python editable=true slideshow={"slide_type": ""} @@ -361,10 +361,10 @@ Ta-da! Now we have succesfully read the GeoPackage from the ZipFile into a varia ### Writing vector data -We can save spatial data to various vector data formats using the `.to_file()` function in `geopandas` which also relies on `fiona`. It is possible to specify the output file format using the `driver` parameter, however, for most file formats it is not needed as the tool is able to infer the driver from the file extension. +We can save spatial data to various vector data formats using the `.to_file()` function in geopandas which also relies on the fiona library. It is possible to specify the output file format using the `driver` parameter, however, for most file formats it is not needed as the tool is able to infer the driver from the file extension (similarly as when reading data): -```python +```python editable=true slideshow={"slide_type": ""} # Write to Shapefile (just make a copy) outfp = "data/Temp/austin_pop_2019.shp" data.to_file(outfp) @@ -383,17 +383,18 @@ data.to_file(outfp) # Write to KML (just make a copy) outfp = "data/Temp/austin_pop_2019.kml" -data.to_file(outfp, driver="KML") +data.to_file(outfp, driver="LIBKML") ``` + ## Creating a GeoDataFrame from scratch -It is possible to create spatial data from scratch by using `shapely`'s geometric objects and `geopandas`. This is useful as it makes it easy to convert, for example, a text file that contains coordinates into spatial data layers. Let's first try creating a simple `GeoDataFrame` based on coordinate information that represents the outlines of the [Senate square in Helsinki, Finland](https://fi.wikipedia.org/wiki/Senaatintori). Here are the coordinates based on which we can create a `Polygon` object using `shapely. +It is possible to create spatial data from scratch by using shapely's geometric objects and geopandas. This is useful as it makes it easy to convert, for example, a text file that contains coordinates into geospatial data layers. Let's first create a simple `GeoDataFrame` based on coordinate information that represents the outlines of the Senate square in Helsinki, Finland. The coordinates below demonstrates the corners of the Senate square, which we can use to create a `Polygon` object in a similar manner as we learned earlier in this chapter: + -```python +```python editable=true slideshow={"slide_type": ""} from shapely.geometry import Polygon -# Coordinates of the Helsinki Senate square in decimal degrees coordinates = [ (24.950899, 60.169158), (24.953492, 60.169158), @@ -401,80 +402,83 @@ coordinates = [ (24.950958, 60.169990), ] -# Create a Shapely polygon from the coordinate-tuple list poly = Polygon(coordinates) ``` -Now we can use this polygon and `geopandas` to create a `GeoDataFrame` from scratch. The data can be passed in as a list-like object. In our case we will only have one row and one column of data. We can pass the polygon inside a list, and name the column as `geometry` so that `geopandas` will use the contents of that column the geometry column. Additionally, we could define the coordinate reference system for the data, but we will skip this step for now. For details of the syntax, see documentation for the `DataFrame` constructor and `GeoDataFrame` constructor online. + +Now we can use this polygon and create a `GeoDataFrame` from scratch with geopandas. The data can be passed in as a list-like object. In our case, we will only have one row and one column of data. We can pass the polygon inside a list, and name the column as `geometry` so that geopandas will know to use the contents of that column as the source for geometries. Additionally, we could define the coordinate reference system for the data which we will learn in the next chapter. + -```python +```python editable=true slideshow={"slide_type": ""} newdata = gpd.GeoDataFrame(data=[poly], columns=["geometry"]) -``` - -```python newdata ``` -We can also add additional attribute information to a new column. - -```python jupyter={"outputs_hidden": false} -# Add a new column and insert data -newdata.at[0, "name"] = "Senate Square" + +In this way, we can easily create a `GeoDataFrame` without any attribute data. However, quite often you also want to attach attribute information along with your geometry. We can create a `GeoDataFrame` from scratch with multiple attributes by passing a Python `dictionary` into the `GeoDataFrame` object as follows: + -# Check the contents -newdata +```python editable=true slideshow={"slide_type": ""} +gdf_data = { + "geometry": [poly], + "name": "Senate Square", + "city": "Helsinki", + "year": 2023 +} +new_data_extended = gpd.GeoDataFrame(gdf_data) +new_data_extended ``` -There it is! Now we have two columns in our data; one representing the geometry and another with additional attribute information. From here, you could proceed into adding additional rows of data, or printing out the data to a file. - + +There it is! Now we have four columns in our data, one representing the geometry and other columns with additional attribute information. + + ## Creating a GeoDataFrame from a text file + + +A common case is to have coordinates in a delimited textfile that needs to be converted into geospatial data. In such a case, we can make use of the pandas, geopandas and shapely libraries for doing this. The example data below contains point coordinates of airports derived from [openflights.org](https://openflights.org/data.html) [^openflights]. Let's read a couple of useful columns from the data into pandas `DataFrame` for further processing: + -A common case is to have coordinates in a delimited textfile that needs to be converted into spatial data. We can make use of `pandas`, `geopandas` and `shapely` for doing this. - -The example data contains point coordinates of airports derived from [openflights.org](https://openflights.org/data.html) [^openflights]. Let's read in a couple of useful columns from the data for further processing. - -```python +```python editable=true slideshow={"slide_type": ""} import pandas as pd -``` -```python airports = pd.read_csv( "data/Airports/airports.txt", usecols=["Airport ID", "Name", "City", "Country", "Latitude", "Longitude"], ) -``` - -```python airports.head() ``` -```python +```python editable=true slideshow={"slide_type": ""} len(airports) ``` -There are over 7000 airports in the data and we can use the coordinate information available in the `Latitude` and `Longitude` columns for visualizing them on a map. The coordinates are stored as *{term}`Decimal degrees `*, meaning that the appropriate coordinate reference system for these data is WGS 84 (EPSG:4326). - -There is a handy tool in `geopandas` for generating an array of `Point`objects based on x and y coordinates called `.points_from_xy()`. The tool assumes that x coordinates represent longitude and that y coordinates represent latitude. + +There are over 7000 airports in the data and we can use the coordinate information available in the `Latitude` and `Longitude` columns for visualizing them on a map. The coordinates are stored as *{term}`Decimal degrees `*. There is a handy function in geopandas called `.points_from_xy()` for generating an array of `Point` objects based on x and y coordinates. This function assumes that x coordinates represent longitude and that y coordinates represent latitude. The following shows how we can create geometries for the airports: + -```python +```python editable=true slideshow={"slide_type": ""} airports["geometry"] = gpd.points_from_xy( - x=airports["Longitude"], y=airports["Latitude"], crs="EPSG:4326" + x=airports["Longitude"], y=airports["Latitude"] ) airports = gpd.GeoDataFrame(airports) airports.head() ``` + Now we have the point geometries as `shapely`objects in the geometry-column ready to be plotted on a map. + -```python +```python editable=true slideshow={"slide_type": ""} airports.plot(markersize=0.1) ``` + _**Figure 6.12**. A basic plot showing the airports from openflights.org._ - + ## Footnotes diff --git a/source/part2/chapter-06/nb/01-geodataframe.ipynb b/source/part2/chapter-06/nb/01-geodataframe.ipynb index 9764d41a..1e340a9b 100644 --- a/source/part2/chapter-06/nb/01-geodataframe.ipynb +++ b/source/part2/chapter-06/nb/01-geodataframe.ipynb @@ -1507,7 +1507,7 @@ "tags": [] }, "source": [ - "Lastly, we demonstrate how it is possible to read data directly from a Zipfile which can be quite useful especially if you are working with large datasets or a collection of multiple files stored into a single Zipfile. ZipFile is a data format where the data is compressed efficiently. For instance after \"zipping\" Shapefiles, the disk space needed to store the data in the given format will be significantly lower.To read the data from ZipFiles, we can use the built-in Python library called **zipfile** and its `ZipFile` object, which makes it possible to work with compressed ZipFiles. The following example shows how to read data from a ZipFile. Let's start by opening the ZipFile into a variable `z` and read the names of the files stored inside of it:" + "Lastly, we demonstrate how it is possible to read data directly from a Zipfile which can be quite useful especially if you are working with large datasets or a collection of multiple files stored into a single Zipfile. ZipFile is a data format where the data is compressed efficiently. For instance after \"zipping\" Shapefiles, the disk space needed to store the data in the given format will be significantly lower. To read the data from ZipFiles, we can use the built-in Python library called **zipfile** and its `ZipFile` object, which makes it possible to work with compressed ZipFiles. The following example shows how to read data from a ZipFile. Let's start by opening the ZipFile into a variable `z` and read the names of the files stored inside of it with the method `.namelist()`:" ] }, { @@ -1550,7 +1550,7 @@ "tags": [] }, "source": [ - "As we can see, the given ZipFile contains only a single GeoPackage called `building_points_helsinki.gpkg`. The `with ZipFile(fp) as z` command here is a standard Python convention to open files in read-format from ZipFiles. To read the contents of the GeoPackage stored inside the ZipFile, we first need use the `.read()` function of the opened `ZipFile` object to read the contents of the file into bytes. After this step, we still need to pass these bytes into a `BytesIO` in-memory file buffer by using the built-in `io` library. This file buffer that can then be used to read the actual contents of the file into geopandas. This maybe sounds complicated, but it actually only requires a few lines of code:" + "As we can see, the given `ZipFile` contains only a single GeoPackage called `building_points_helsinki.gpkg`. The `with ZipFile(fp) as z:` command here is a standard Python convention to open files in read-format from ZipFiles. To read the contents of the GeoPackage stored inside the ZipFile, we first need use the `.read()` function of the opened `ZipFile` object to read the contents of the file into bytes. After this step, we still need to pass these bytes into a `BytesIO` in-memory file buffer by using the built-in `io` library. This file buffer that can then be used to read the actual contents of the file into geopandas. This maybe sounds complicated, but it actually only requires a few lines of code:" ] }, { @@ -1691,14 +1691,20 @@ "source": [ "### Writing vector data\n", "\n", - "We can save spatial data to various vector data formats using the `.to_file()` function in `geopandas` which also relies on `fiona`. It is possible to specify the output file format using the `driver` parameter, however, for most file formats it is not needed as the tool is able to infer the driver from the file extension. " + "We can save spatial data to various vector data formats using the `.to_file()` function in geopandas which also relies on the fiona library. It is possible to specify the output file format using the `driver` parameter, however, for most file formats it is not needed as the tool is able to infer the driver from the file extension (similarly as when reading data):" ] }, { "cell_type": "code", - "execution_count": 50, + "execution_count": 45, "id": "1fadf9b2", - "metadata": {}, + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, "outputs": [], "source": [ "# Write to Shapefile (just make a copy)\n", @@ -1719,29 +1725,40 @@ "\n", "# Write to KML (just make a copy)\n", "outfp = \"data/Temp/austin_pop_2019.kml\"\n", - "data.to_file(outfp, driver=\"KML\")" + "data.to_file(outfp, driver=\"LIBKML\")" ] }, { "cell_type": "markdown", "id": "e451b126", - "metadata": {}, + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, "source": [ "## Creating a GeoDataFrame from scratch\n", "\n", - "It is possible to create spatial data from scratch by using `shapely`'s geometric objects and `geopandas`. This is useful as it makes it easy to convert, for example, a text file that contains coordinates into spatial data layers. Let's first try creating a simple `GeoDataFrame` based on coordinate information that represents the outlines of the [Senate square in Helsinki, Finland](https://fi.wikipedia.org/wiki/Senaatintori). Here are the coordinates based on which we can create a `Polygon` object using `shapely." + "It is possible to create spatial data from scratch by using shapely's geometric objects and geopandas. This is useful as it makes it easy to convert, for example, a text file that contains coordinates into geospatial data layers. Let's first create a simple `GeoDataFrame` based on coordinate information that represents the outlines of the Senate square in Helsinki, Finland. The coordinates below demonstrates the corners of the Senate square, which we can use to create a `Polygon` object in a similar manner as we learned earlier in this chapter:" ] }, { "cell_type": "code", - "execution_count": 29, + "execution_count": 47, "id": "e791f5fd", - "metadata": {}, + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, "outputs": [], "source": [ "from shapely.geometry import Polygon\n", "\n", - "# Coordinates of the Helsinki Senate square in decimal degrees\n", "coordinates = [\n", " (24.950899, 60.169158),\n", " (24.953492, 60.169158),\n", @@ -1749,33 +1766,34 @@ " (24.950958, 60.169990),\n", "]\n", "\n", - "# Create a Shapely polygon from the coordinate-tuple list\n", "poly = Polygon(coordinates)" ] }, { "cell_type": "markdown", "id": "1dac87d9", - "metadata": {}, + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, "source": [ - "Now we can use this polygon and `geopandas` to create a `GeoDataFrame` from scratch. The data can be passed in as a list-like object. In our case we will only have one row and one column of data. We can pass the polygon inside a list, and name the column as `geometry` so that `geopandas` will use the contents of that column the geometry column. Additionally, we could define the coordinate reference system for the data, but we will skip this step for now. For details of the syntax, see documentation for the `DataFrame` constructor and `GeoDataFrame` constructor online." + "Now we can use this polygon and create a `GeoDataFrame` from scratch with geopandas. The data can be passed in as a list-like object. In our case, we will only have one row and one column of data. We can pass the polygon inside a list, and name the column as `geometry` so that geopandas will know to use the contents of that column as the source for geometries. Additionally, we could define the coordinate reference system for the data which we will learn in the next chapter." ] }, { "cell_type": "code", - "execution_count": 30, + "execution_count": 59, "id": "712160ba", - "metadata": {}, - "outputs": [], - "source": [ - "newdata = gpd.GeoDataFrame(data=[poly], columns=[\"geometry\"])" - ] - }, - { - "cell_type": "code", - "execution_count": 31, - "id": "58ccd2df", - "metadata": {}, + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, "outputs": [ { "data": { @@ -1815,42 +1833,42 @@ "0 POLYGON ((24.95090 60.16916, 24.95349 60.16916..." ] }, - "execution_count": 31, + "execution_count": 59, "metadata": {}, "output_type": "execute_result" } ], "source": [ + "newdata = gpd.GeoDataFrame(data=[poly], columns=[\"geometry\"])\n", "newdata" ] }, { "cell_type": "markdown", "id": "0aaeb053", - "metadata": {}, + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, "source": [ - "We can also add additional attribute information to a new column. " + "In this way, we can easily create a `GeoDataFrame` without any attribute data. However, quite often you also want to attach attribute information along with your geometry. We can create a `GeoDataFrame` from scratch with multiple attributes by passing a Python `dictionary` into the `GeoDataFrame` object as follows: " ] }, { "cell_type": "code", - "execution_count": 32, - "id": "80bf703b", + "execution_count": 61, + "id": "36433916-c3ba-481d-bd52-d2a80d2378fb", "metadata": { - "collapsed": false, - "jupyter": { - "outputs_hidden": false - } + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] }, "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/tmp/ipykernel_125320/3241937378.py:2: FutureWarning: Setting an item of incompatible dtype is deprecated and will raise in a future error of pandas. Value 'Senate Square' has dtype incompatible with float64, please explicitly cast to a compatible dtype first.\n", - " newdata.at[0, \"name\"] = \"Senate Square\"\n" - ] - }, { "data": { "text/html": [ @@ -1874,6 +1892,8 @@ " \n", " geometry\n", " name\n", + " city\n", + " year\n", " \n", " \n", " \n", @@ -1881,41 +1901,61 @@ " 0\n", " POLYGON ((24.95090 60.16916, 24.95349 60.16916...\n", " Senate Square\n", + " Helsinki\n", + " 2023\n", " \n", " \n", "\n", "" ], "text/plain": [ - " geometry name\n", - "0 POLYGON ((24.95090 60.16916, 24.95349 60.16916... Senate Square" + " geometry name city \\\n", + "0 POLYGON ((24.95090 60.16916, 24.95349 60.16916... Senate Square Helsinki \n", + "\n", + " year \n", + "0 2023 " ] }, - "execution_count": 32, + "execution_count": 61, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "# Add a new column and insert data\n", - "newdata.at[0, \"name\"] = \"Senate Square\"\n", - "\n", - "# Check the contents\n", - "newdata" + "gdf_data = {\n", + " \"geometry\": [poly], \n", + " \"name\": \"Senate Square\",\n", + " \"city\": \"Helsinki\",\n", + " \"year\": 2023\n", + "}\n", + "new_data_extended = gpd.GeoDataFrame(gdf_data)\n", + "new_data_extended" ] }, { "cell_type": "markdown", "id": "59b0ac71", - "metadata": {}, + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, "source": [ - "There it is! Now we have two columns in our data; one representing the geometry and another with additional attribute information. From here, you could proceed into adding additional rows of data, or printing out the data to a file. " + "There it is! Now we have four columns in our data, one representing the geometry and other columns with additional attribute information. " ] }, { "cell_type": "markdown", "id": "a83b254b", - "metadata": {}, + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, "source": [ "## Creating a GeoDataFrame from a text file" ] @@ -1923,41 +1963,28 @@ { "cell_type": "markdown", "id": "06f16d87", - "metadata": {}, - "source": [ - "A common case is to have coordinates in a delimited textfile that needs to be converted into spatial data. We can make use of `pandas`, `geopandas` and `shapely` for doing this. \n", - "\n", - "The example data contains point coordinates of airports derived from [openflights.org](https://openflights.org/data.html) [^openflights]. Let's read in a couple of useful columns from the data for further processing." - ] - }, - { - "cell_type": "code", - "execution_count": 33, - "id": "83fc60f2", - "metadata": {}, - "outputs": [], + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, "source": [ - "import pandas as pd" + "A common case is to have coordinates in a delimited textfile that needs to be converted into geospatial data. In such a case, we can make use of the pandas, geopandas and shapely libraries for doing this. The example data below contains point coordinates of airports derived from [openflights.org](https://openflights.org/data.html) [^openflights]. Let's read a couple of useful columns from the data into pandas `DataFrame` for further processing:" ] }, { "cell_type": "code", - "execution_count": 34, + "execution_count": 65, "id": "7cbc25d6", - "metadata": {}, - "outputs": [], - "source": [ - "airports = pd.read_csv(\n", - " \"data/Airports/airports.txt\",\n", - " usecols=[\"Airport ID\", \"Name\", \"City\", \"Country\", \"Latitude\", \"Longitude\"],\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": 35, - "id": "b91be67b", - "metadata": {}, + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, "outputs": [ { "data": { @@ -2054,20 +2081,32 @@ "4 Papua New Guinea -9.443380 147.220001 " ] }, - "execution_count": 35, + "execution_count": 65, "metadata": {}, "output_type": "execute_result" } ], "source": [ + "import pandas as pd\n", + "\n", + "airports = pd.read_csv(\n", + " \"data/Airports/airports.txt\",\n", + " usecols=[\"Airport ID\", \"Name\", \"City\", \"Country\", \"Latitude\", \"Longitude\"],\n", + ")\n", "airports.head()" ] }, { "cell_type": "code", - "execution_count": 36, + "execution_count": 66, "id": "f1642d2f", - "metadata": {}, + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, "outputs": [ { "data": { @@ -2075,7 +2114,7 @@ "7698" ] }, - "execution_count": 36, + "execution_count": 66, "metadata": {}, "output_type": "execute_result" } @@ -2087,18 +2126,28 @@ { "cell_type": "markdown", "id": "8fc9c2df", - "metadata": {}, + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, "source": [ - "There are over 7000 airports in the data and we can use the coordinate information available in the `Latitude` and `Longitude` columns for visualizing them on a map. The coordinates are stored as *{term}`Decimal degrees `*, meaning that the appropriate coordinate reference system for these data is WGS 84 (EPSG:4326). \n", - "\n", - "There is a handy tool in `geopandas` for generating an array of `Point`objects based on x and y coordinates called `.points_from_xy()`. The tool assumes that x coordinates represent longitude and that y coordinates represent latitude. " + "There are over 7000 airports in the data and we can use the coordinate information available in the `Latitude` and `Longitude` columns for visualizing them on a map. The coordinates are stored as *{term}`Decimal degrees `*. There is a handy function in geopandas called `.points_from_xy()` for generating an array of `Point` objects based on x and y coordinates. This function assumes that x coordinates represent longitude and that y coordinates represent latitude. The following shows how we can create geometries for the airports:" ] }, { "cell_type": "code", - "execution_count": 37, + "execution_count": 67, "id": "69d12f09", - "metadata": {}, + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, "outputs": [ { "data": { @@ -2201,14 +2250,14 @@ "4 Papua New Guinea -9.443380 147.220001 POINT (147.22000 -9.44338) " ] }, - "execution_count": 37, + "execution_count": 67, "metadata": {}, "output_type": "execute_result" } ], "source": [ "airports[\"geometry\"] = gpd.points_from_xy(\n", - " x=airports[\"Longitude\"], y=airports[\"Latitude\"], crs=\"EPSG:4326\"\n", + " x=airports[\"Longitude\"], y=airports[\"Latitude\"]\n", ")\n", "\n", "airports = gpd.GeoDataFrame(airports)\n", @@ -2218,16 +2267,28 @@ { "cell_type": "markdown", "id": "f3980e1a", - "metadata": {}, + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, "source": [ "Now we have the point geometries as `shapely`objects in the geometry-column ready to be plotted on a map." ] }, { "cell_type": "code", - "execution_count": 38, + "execution_count": 69, "id": "b21b6edb", - "metadata": {}, + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, "outputs": [ { "data": { @@ -2235,13 +2296,13 @@ "" ] }, - "execution_count": 38, + "execution_count": 69, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -2257,7 +2318,13 @@ { "cell_type": "markdown", "id": "1dbb692c", - "metadata": {}, + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, "source": [ "_**Figure 6.12**. A basic plot showing the airports from openflights.org._" ]