欢迎使用Geopy文档！

GeoPy徽标
文档:

https://geopy.readthedocs.io/

源代码:

https://github.com/geopy/geopy

堆栈溢出:

https://stackoverflow.com/questions/tagged/geopy

地理信息系统堆栈交换:

https://gis.stackexchange.com/questions/tagged/geopy

讨论:

https://github.com/geopy/geopy/discussions

问题跟踪器:

https://github.com/geopy/geopy/issues

PyPI:

https://pypi.org/project/geopy/

geopy是几个流行的地理编码web服务的Python客户机。

geopy使python开发人员能够使用第三方地理编码程序和其他数据源轻松定位全球各地的地址、城市、国家和地标的坐标。

Geopy针对CPython(3.7、3.8、3.9、3.10、3.11、3.12版)和Py3进行了测试。Geopy 1.x行还支持CPython2.7、3.4和PyPy2。

安装

pip install geopy

地理编码器

您可能使用的每个地理定位服务（如Google地图、Bing地图或Nomingim）都在 geopy.geocoders 中有自己的类 ，用于抽象服务的API。每个地理编码程序至少定义一个 geocode 方法，用于从字符串中解析位置，并且可以定义 reverse 方法，它将一对坐标解析为一个地址。每个地理编码程序在初始化期间接受与其服务交互所需的任何凭证或设置，例如API密钥或区域设置。

要将查询定位到地址和坐标，请执行以下操作：

>>> from geopy.geocoders import Nominatim
>>> geolocator = Nominatim(user_agent="specify_your_app_name_here")
>>> location = geolocator.geocode("175 5th Avenue NYC")
>>> print(location.address)
Flatiron Building, 175, 5th Avenue, Flatiron, New York, NYC, New York, ...
>>> print((location.latitude, location.longitude))
(40.7410861, -73.9896297241625)
>>> print(location.raw)
{'place_id': '9167009604', 'type': 'attraction', ...}

要查找与一组坐标对应的地址：

>>> from geopy.geocoders import Nominatim
>>> geolocator = Nominatim(user_agent="specify_your_app_name_here")
>>> location = geolocator.reverse("52.509669, 13.376294")
>>> print(location.address)
Potsdamer Platz, Mitte, Berlin, 10117, Deutschland, European Union
>>> print((location.latitude, location.longitude))
(52.5094982, 13.3765983)
>>> print(location.raw)
{'place_id': '654513', 'osm_type': 'node', ...}

定位器 geocode 和 reverse 方法需要参数 query 至少接受这个参数 exactly_one ，这就是 True 默认情况下。地理编码可能具有其他属性，例如，必应接受 user_location ，其作用是偏向该位置附近的结果。 geocode 和 reverse 方法可以返回三种类型的值：

  • 当没有找到结果时，返回 None .

  • 当方法 exactly_one 参数是 True 并且至少找到一个结果，返回 geopy.location.Location 对象，可以迭代为：

    (address<String>, (latitude<Float>, longitude<Float>))

    或者可以访问为 location.address ， location.latitude ， location.longitude ， location.altitude 和 location.raw . 最后一个包含对这个结果的完整地理编码响应。

  • 当 exactly_one 是 False ，并且至少有一个结果，返回 geopy.location.Location 对象，如上所述：

    [location, [...]]

如果服务不可用，或者返回非OK响应，或者在分配的超时时间内未收到响应，您将收到 Exceptions 详见下文。

指定一次参数

地理编码方法接受许多不同的参数，您可能希望只指定其中一些参数一次，而不关心它们。

这很容易用Python实现 functools.partial() ：：

>>> from functools import partial
>>> from geopy.geocoders import Nominatim

>>> geolocator = Nominatim(user_agent="specify_your_app_name_here")

>>> geocode = partial(geolocator.geocode, language="es")
>>> print(geocode("london"))
Londres, Greater London, Inglaterra, SW1A 2DX, Gran Bretaña
>>> print(geocode("paris"))
París, Isla de Francia, Francia metropolitana, Francia
>>> print(geocode("paris", language="en"))
Paris, Ile-de-France, Metropolitan France, France

>>> reverse = partial(geolocator.reverse, language="es")
>>> print(reverse("52.509669, 13.376294"))
Steinecke, Potsdamer Platz, Tiergarten, Mitte, 10785, Alemania

如果需要修改查询，还可以使用lambda的一行程序。例如，如果您只需要对 Cleveland, Ohio 你可以这样做：

>>> geocode = lambda query: geolocator.geocode("%s, Cleveland OH" % query)
>>> print(geocode("11111 Euclid Ave"))
Thwing Center, Euclid Avenue, Magnolia-Wade Park Historic District,
University Circle, Cleveland, Cuyahoga County, Ohio, 44106, United States
of America

lambda不接受夸格斯。如果你需要的话，你可以：

>>> _geocode = partial(geolocator.geocode, language="es")
>>> geocode = lambda query, **kw: _geocode("%s, Cleveland OH" % query, **kw)
>>> print(geocode("11111 Euclid Ave"))
Thwing Center, Euclid Avenue, Magnolia-Wade Park Historic District,
University Circle, Cleveland, Cuyahoga County, Ohio, 44106, Estados Unidos
>>> print(geocode("11111 Euclid Ave", language="en"))
Thwing Center, Euclid Avenue, Magnolia-Wade Park Historic District,
University Circle, Cleveland, Cuyahoga County, Ohio, 44106, United States
of America

地理游戏不是一种服务

地理编码由许多不同的服务提供，这些服务与geopy没有任何关系。这些服务提供了任何人都可以实现的api，geopy只是一个在单个包中为许多不同服务提供这些实现的库。

_images/geopy_and_geocoding_services.svg

因此：

  1. 不同的服务有不同的使用条款、配额、定价、地理数据库等等。例如， Nominatim 是免费的，但提供低请求限制。如果您需要进行更多的查询，可以考虑使用其他（可能是付费的）服务，例如 OpenMapQuest 或 PickPoint （这两个是提名的商业提供者，因此它们应该具有相同的数据和API）。或者，如果你准备好等待，你可以尝试 geopy.extra.rate_limiter .

  2. geopy不负责地理编码服务的数据库。如果您对服务无法完成的某些查询有问题，应该将其定向到该服务的支持团队。

  3. geopy不对您的计算机和地理编码服务之间的任何网络问题负责。

如果您与当前的地理编码服务提供商有任何问题，您可以随时尝试另一个。

异步模式

默认情况下，geopy地理编码器是同步的（即他们使用基于 BaseSyncAdapter ）

通过简单地切换到基于 BaseAsyncAdapter （像 AioHTTPAdapter ）

例子：：

from geopy.adapters import AioHTTPAdapter
from geopy.geocoders import Nominatim

async with Nominatim(
    user_agent="specify_your_app_name_here",
    adapter_factory=AioHTTPAdapter,
) as geolocator:
    location = await geolocator.geocode("175 5th Avenue NYC")
    print(location.address)

基本上，用法与同步模式中的用法相同，只是所有geocoder调用都应与一起使用 await ，并且geocoder实例应该由 async with . 上下文管理器是可选的，但是强烈建议使用它来避免资源泄漏。

访问地理编码器

检索geocoder类的典型方法是从 geopy.geocoders 包裹：：

from geopy.geocoders import Nominatim
geopy.geocoders.get_geocoder_for_service(service)

对于提供的服务，请尝试返回地理编码程序类。

>>> from geopy.geocoders import get_geocoder_for_service
>>> get_geocoder_for_service("nominatim")
geopy.geocoders.nominatim.Nominatim

如果无法识别给定的字符串，则 geopy.exc.GeocoderNotFound 引发异常。

鉴于几乎所有的地理编码器都提供 geocode 方法它可用于完全基于用户输入进行基本查询：

from geopy.geocoders import get_geocoder_for_service

def geocode(geocoder, config, query):
    cls = get_geocoder_for_service(geocoder)
    geolocator = cls(**config)
    location = geolocator.geocode(query)
    return location.address

>>> geocode("nominatim", dict(user_agent="specify_your_app_name_here"), "london")
'London, Greater London, England, SW1A 2DX, United Kingdom'
>>> geocode("photon", dict(), "london")
'London, SW1A 2DX, London, England, United Kingdom'

默认选项对象

class geopy.geocoders.options

这个 options 对象包含地理编码程序的默认配置值，例如 timeout 和 User-Agent. 您可以覆盖此对象中的默认值，而不是单独向每个地理编码程序传递自定义值。

请注意，并不是所有的地理代码都使用这个对象的所有属性。例如，一些地理编码器不遵守 default_scheme 属性。请参阅特定地理编码程序的初始值设定项文档，以获取地理编码程序接受的参数列表。

覆盖默认值的示例 timeout 和 user_agent ：：

>>> import geopy.geocoders
>>> from geopy.geocoders import Nominatim
>>> geopy.geocoders.options.default_user_agent = 'my_app/1'
>>> geopy.geocoders.options.default_timeout = 7
>>> geolocator = Nominatim()
>>> print(geolocator.headers)
{'User-Agent': 'my_app/1'}
>>> print(geolocator.timeout)
7
属性：
default_adapter_factory

一个返回 geopy.adapters.BaseAdapter 实例。适配器是HTTP客户机的不同实现。看到了吗 geopy.adapters 更多信息。

此callable接受两个关键字参数： proxies 和 ssl_context . 也可以将类指定为此可调用类。

例子：：

import geopy.geocoders
geopy.geocoders.options.default_adapter_factory = geopy.adapters.URLLibAdapter

geopy.geocoders.options.default_adapter_factory = (
    lambda proxies, ssl_context: MyAdapter(
        proxies=proxies, ssl_context=ssl_context, my_custom_arg=42
    )
)

如果 requests 软件包已安装，默认适配器为 geopy.adapters.RequestsAdapter . 否则就是了 geopy.adapters.URLLibAdapter .

在 2.0 版本加入.

default_proxies

通过HTTP代理对请求进行隧道处理。

默认情况下，系统代理是受尊重的（例如 HTTP_PROXY 和 HTTPS_PROXY env vars或平台特定的代理设置，如macos或windows本机首选项--请参见 urllib.request.getproxies() 了解更多详细信息）。这个 proxies 使用系统代理的值为 None .

要直接禁用系统代理并发出请求，请显式传递空dict作为的值 proxies: {{}} .

要使用自定义HTTP代理位置，请传递一个字符串。有效的例子有：

  • "192.0.2.0:8080"

  • "john:passw0rd@192.0.2.0:8080"

  • "http://john:passw0rd@192.0.2.0:8080"

请注意：

  • 方案部分（ http:// ）将忽略代理的。

  • 仅支持 http 代理。即使代理方案是 https, 它将被忽略，并且客户端和代理之间的连接仍然是未加密的。然而， 仍然支持通过 https 代理的 http 请求（通过 HTTP CONNECT 方法）。

可能会提供原始 urllib-style proxies 可以提供dict而不是字符串：

  • {{"https": "192.0.2.0:8080"}} --意味着HTTP代理将仅用于具有 https 方案请求。字符串 proxies 值自动用于这两个方案，并作为urlib样式 proxies 的简写提供。

有关详细信息，请参阅文档 urllib.request.getproxies() .

default_scheme

使用 'https' 或 'http' 作为API URL的方案。

default_ssl_context

安 ssl.SSLContext 具有自定义TLS验证设置的实例。通过 None 默认使用CA的证书。

使用 requests 类库：

import ssl
import certifi
import geopy.geocoders
ctx = ssl.create_default_context(cafile=certifi.where())
geopy.geocoders.options.default_ssl_context = ctx

要完全禁用TLS证书验证，请执行以下操作：

import ssl
import geopy.geocoders
ctx = ssl.create_default_context()
ctx.check_hostname = False
ctx.verify_mode = ssl.CERT_NONE
geopy.geocoders.options.default_ssl_context = ctx

请参阅文档 ssl.SSLContext 类以获取更多示例。

default_timeout

等待地理编码服务响应的时间（秒），然后引发 geopy.exc.GeocoderTimedOut 例外。通过 None 禁用超时。

default_user_agent

要与请求一起发送到geocoder api的用户代理头。

default_adapter_factory

RequestsAdapter 的别名

default_proxies = None
default_scheme = 'https'
default_ssl_context = None
default_timeout = 1
default_user_agent = 'geopy/2.4.1'

与 Pandas 一起使用

可以用geopy对pandas数据帧进行地理编码，但是必须考虑速率限制。

大量的 DataFrame 行可能会对地理编码服务产生大量的地理编码请求，这些请求可能会受到服务的限制（例如，通过返回 Too Many Requests 429 HTTP错误或超时）。

geopy.extra.rate_limiter 类提供了一个方便的包装器，可用于在地理编码调用之间自动添加延迟，以减少地理编码服务的负载。此外，它还可以重试失败的请求，并吞下单个行的错误。

如果你有 Too Many Requests 错误，您可以尝试以下操作：

  • 使用 geopy.extra.rate_limiter 非零 min_delay_seconds .

  • 尝试不同的地理编码服务（请先咨询他们的TOS，因为有些服务禁止批量地理编码）。

  • 对所选的地理编码服务采取付费计划，这将提供更高的配额。

  • 提供您自己的地理编码服务的本地副本（如nomingim）。

速率限制器

RateLimiter 和 AsyncRateLimiter 允许执行批量操作，同时优雅地处理错误响应并在需要时添加延迟。

在下面的示例中，每对 geolocator.geocode 之间会加一个1秒的延迟（ min_delay_seconds=1 ）；全部 geopy.exc.GeocoderServiceError 异常将被重试（直到 max_retries 次）：：

import pandas as pd
df = pd.DataFrame({'name': ['paris', 'berlin', 'london']})

from geopy.geocoders import Nominatim
geolocator = Nominatim(user_agent="specify_your_app_name_here")

from geopy.extra.rate_limiter import RateLimiter
geocode = RateLimiter(geolocator.geocode, min_delay_seconds=1)
df['location'] = df['name'].apply(geocode)

df['point'] = df['location'].apply(lambda loc: tuple(loc.point) if loc else None)

这将生成以下DataFrame:

>>> df
     name                                           location  \
0   paris  (Paris, Île-de-France, France métropolitaine, ...
1  berlin  (Berlin, 10117, Deutschland, (52.5170365, 13.3...
2  london  (London, Greater London, England, SW1A 2DU, UK...

                           point
0   (48.8566101, 2.3514992, 0.0)
1  (52.5170365, 13.3888599, 0.0)
2  (51.5073219, -0.1276474, 0.0)

将额外选项传递给 geocode 调用：

from functools import partial
df['location'] = df['name'].apply(partial(geocode, language='de'))

要查看进度条，请执行以下操作：

from tqdm import tqdm
tqdm.pandas()
df['location'] = df['name'].progress_apply(geocode)

在使用速率限制类之前，请咨询地理编码服务ToS，该服务可能会明确地认为批量请求（甚至被限制）是一种违规行为。

class geopy.extra.rate_limiter.RateLimiter(func, *, min_delay_seconds=0.0, max_retries=2, error_wait_seconds=5.0, swallow_exceptions=True, return_value_on_exception=None)

这是同步函数的速率限制器实现（比如默认的geocoders geopy.adapters.BaseSyncAdapter ）

实例：

from geopy.extra.rate_limiter import RateLimiter
from geopy.geocoders import Nominatim

geolocator = Nominatim(user_agent="specify_your_app_name_here")

search = ["moscow", "paris", "berlin", "tokyo", "beijing"]
geocode = RateLimiter(geolocator.geocode, min_delay_seconds=1)
locations = [geocode(s) for s in search]

search = [
    (55.47, 37.32), (48.85, 2.35), (52.51, 13.38),
    (34.69, 139.40), (39.90, 116.39)
]
reverse = RateLimiter(geolocator.reverse, min_delay_seconds=1)
locations = [reverse(s) for s in search]

RateLimitor类是线程安全的。如果地理编码服务的响应慢于 min_delay_seconds ，那么您可以从并行工作中获益：

import concurrent.futures

geolocator = OpenMapQuest(api_key="...")
geocode = RateLimiter(geolocator.geocode, min_delay_seconds=1/20)

with concurrent.futures.ThreadPoolExecutor() as e:
    locations = list(e.map(geocode, search))

在 2.0 版本发生变更: 增加了线程安全支持。

__init__(func, *, min_delay_seconds=0.0, max_retries=2, error_wait_seconds=5.0, swallow_exceptions=True, return_value_on_exception=None)
参数:

  • func (callable) -- 由速率限制器包装的函数。

  • min_delay_seconds (float) -- 包装之间的最小延迟（秒） func 电话。转换 RPS 费率到 min_delay_seconds 你需要把1除以RPS。例如，如果需要将速率保持在20 RPS，可以使用 min_delay_seconds=1/20 .

  • max_retries (int) -- 异常重试次数。只有 geopy.exc.GeocoderServiceError 异常被重试——其他的总是被重新引发。 max_retries + 1 请求将以每个查询的最大值执行。设置 max_retries=0 禁用重试。

  • error_wait_seconds (float) -- 出错后两次重试之间的等待时间。必须大于或等于 min_delay_seconds .

  • swallow_exceptions (bool) -- 是否应在重试后接受异常？否则，将重新提升。如果是， return_value_on_exception 将被退回。

  • return_value_on_exception -- 当 swallow_exceptions=True 失败时返回的值.

class geopy.extra.rate_limiter.AsyncRateLimiter(func, *, min_delay_seconds=0.0, max_retries=2, error_wait_seconds=5.0, swallow_exceptions=True, return_value_on_exception=None)

这是异步函数的速率限制器实现（例如 geopy.adapters.BaseAsyncAdapter ）

实例：

from geopy.adapters import AioHTTPAdapter
from geopy.extra.rate_limiter import AsyncRateLimiter
from geopy.geocoders import Nominatim

async with Nominatim(
    user_agent="specify_your_app_name_here",
    adapter_factory=AioHTTPAdapter,
) as geolocator:

    search = ["moscow", "paris", "berlin", "tokyo", "beijing"]
    geocode = AsyncRateLimiter(geolocator.geocode, min_delay_seconds=1)
    locations = [await geocode(s) for s in search]

    search = [
        (55.47, 37.32), (48.85, 2.35), (52.51, 13.38),
        (34.69, 139.40), (39.90, 116.39)
    ]
    reverse = AsyncRateLimiter(geolocator.reverse, min_delay_seconds=1)
    locations = [await reverse(s) for s in search]

AsyncRateLimitor类可以安全地跨多个并发任务使用。如果地理编码服务的响应慢于 min_delay_seconds ，那么您可以从并行工作中获益：

import asyncio

async with OpenMapQuest(
    api_key="...", adapter_factory=AioHTTPAdapter
) as geolocator:

    geocode = AsyncRateLimiter(geolocator.geocode, min_delay_seconds=1/20)
    locations = await asyncio.gather(*(geocode(s) for s in search))

在 2.0 版本加入.

__init__(func, *, min_delay_seconds=0.0, max_retries=2, error_wait_seconds=5.0, swallow_exceptions=True, return_value_on_exception=None)
参数:

  • func (callable) -- 由速率限制器包装的函数。

  • min_delay_seconds (float) -- 包装之间的最小延迟（秒） func 电话。转换 RPS 费率到 min_delay_seconds 你需要把1除以RPS。例如，如果需要将速率保持在20 RPS，可以使用 min_delay_seconds=1/20 .

  • max_retries (int) -- 异常重试次数。只有 geopy.exc.GeocoderServiceError 异常被重试——其他的总是被重新引发。 max_retries + 1 请求将以每个查询的最大值执行。设置 max_retries=0 禁用重试。

  • error_wait_seconds (float) -- 出错后两次重试之间的等待时间。必须大于或等于 min_delay_seconds .

  • swallow_exceptions (bool) -- 是否应在重试后接受异常？否则，将重新提升。如果是， return_value_on_exception 将被退回。

  • return_value_on_exception -- 当 swallow_exceptions=True 失败时返回的值.

ArcGIS

class geopy.geocoders.ArcGIS(username=None, password=None, *, referer=None, token_lifetime=60, scheme=None, timeout=DEFAULT_SENTINEL, proxies=DEFAULT_SENTINEL, user_agent=None, ssl_context=DEFAULT_SENTINEL, adapter_factory=None, auth_domain='www.arcgis.com', domain='geocode.arcgis.com')

使用rsi arcgis API的地理编码。

文件地址：

https://developers.arcgis.com/rest/geocode/api-reference/overview-world-geocoding-service.htm

__init__(username=None, password=None, *, referer=None, token_lifetime=60, scheme=None, timeout=DEFAULT_SENTINEL, proxies=DEFAULT_SENTINEL, user_agent=None, ssl_context=DEFAULT_SENTINEL, adapter_factory=None, auth_domain='www.arcgis.com', domain='geocode.arcgis.com')
参数:
geocode(query, *, exactly_one=True, timeout=DEFAULT_SENTINEL, out_fields=None)

按地址返回位置点。

参数:

  • query (str) -- 要对其进行地理编码的地址或查询。

  • exactly_one (bool) -- 如果可用，返回一个结果或结果列表。

  • timeout (int) -- 等待地理编码服务响应的时间（秒），然后引发 geopy.exc.GeocoderTimedOut 例外。仅当您希望在这个调用上覆盖在地理编码程序初始化期间设置的值时，才设置这个值。

  • out_fields (str or iterable) -- 要在原始数据的属性字段中返回的输出字段列表。这可以是字段的python列表/元组，也可以是逗号分隔的字符串。有关支持的输出字段列表，请参阅https://developers.arcgis.com/rest/geocode/api-reference/geocoding-service-output.htm。如果要返回所有支持的输出字段，请设置 out_fields="*" .

返回类型:

None ， geopy.location.Location 或者他们的列表，如果 exactly_one=False .

reverse(query, *, exactly_one=True, timeout=DEFAULT_SENTINEL, distance=None)

按地点返回地址。

参数:

  • query (geopy.point.Point, list or tuple of (latitude, longitude), or string as "%(latitude)s, %(longitude)s".) -- 您希望获得最接近人类可读地址的坐标。

  • exactly_one (bool) -- 如果可用，返回一个结果或结果列表。

  • timeout (int) -- 等待地理编码服务响应的时间（秒），然后引发 geopy.exc.GeocoderTimedOut 例外。仅当您希望在这个调用上覆盖在地理编码程序初始化期间设置的值时，才设置这个值。

  • distance (int) -- 距离搜索的查询位置的距离（以米为单位）。如果未指定，Arcgis的默认值为100米。

返回类型:

None ， geopy.location.Location 或者他们的列表，如果 exactly_one=False .

AzureMaps

class geopy.geocoders.AzureMaps(subscription_key, *, scheme=None, timeout=DEFAULT_SENTINEL, proxies=DEFAULT_SENTINEL, user_agent=None, ssl_context=DEFAULT_SENTINEL, adapter_factory=None, domain='atlas.microsoft.com')

基类：TomTom

基于TomTom的azuremaps地理编码器。

文件地址：

https://docs.microsoft.com/en-us/azure/azure-maps/index

__init__(subscription_key, *, scheme=None, timeout=DEFAULT_SENTINEL, proxies=DEFAULT_SENTINEL, user_agent=None, ssl_context=DEFAULT_SENTINEL, adapter_factory=None, domain='atlas.microsoft.com')
参数:
geocode(query, *, exactly_one=True, timeout=DEFAULT_SENTINEL, limit=None, typeahead=False, language=None)

按地址返回位置点。

参数:

  • query (str) -- 要对其进行地理编码的地址或查询。

  • exactly_one (bool) -- 如果可用，返回一个结果或结果列表。

  • timeout (int) -- 等待地理编码服务响应的时间（秒），然后引发 geopy.exc.GeocoderTimedOut 例外。仅当您希望在这个调用上覆盖在地理编码程序初始化期间设置的值时，才设置这个值。

  • limit (int) -- 要从服务返回的最大结果量。除非exact_one设置为False，否则限制将始终为1。

  • typeahead (bool) -- 如果设置了“typeahead”标志，查询将被解释为部分输入，搜索将进入预测模式。

  • language (str) -- 应返回搜索结果的语言。 如果指定语言的数据不适用于特定字段，则使用默认语言。 支持的语言列表（不区分大小写）:https://developer.tomtom.com/online-search/online-search-documentation/supported-languages

返回类型:

None ， geopy.location.Location 或者他们的列表，如果 exactly_one=False .

reverse(query, *, exactly_one=True, timeout=DEFAULT_SENTINEL, language=None)

按地点返回地址。

参数:

  • query (geopy.point.Point, list or tuple of (latitude, longitude), or string as "%(latitude)s, %(longitude)s".) -- 您希望获得最接近人类可读地址的坐标。

  • exactly_one (bool) -- 如果可用，返回一个结果或结果列表。

  • timeout (int) -- 等待地理编码服务响应的时间（秒），然后引发 geopy.exc.GeocoderTimedOut 例外。仅当您希望在这个调用上覆盖在地理编码程序初始化期间设置的值时，才设置这个值。

  • language (str) -- 应返回搜索结果的语言。 如果指定语言的数据不适用于特定字段，则使用默认语言。 支持的语言列表（不区分大小写）:https://developer.tomtom.com/online-search/online-search-documentation/supported-languages

返回类型:

None ， geopy.location.Location 或者他们的列表，如果 exactly_one=False .

百度

class geopy.geocoders.Baidu(api_key, *, scheme=None, timeout=DEFAULT_SENTINEL, proxies=DEFAULT_SENTINEL, user_agent=None, ssl_context=DEFAULT_SENTINEL, adapter_factory=None, security_key=None)

使用百度地图v2 API的地理编码。

文件地址：

http://lbsyun.baidu.com/index.php?title=webapi/guide/webservice-geocoding

注意

新注册的API密钥不能与v2 API一起使用，请使用 BaiduV3 相反。

__init__(api_key, *, scheme=None, timeout=DEFAULT_SENTINEL, proxies=DEFAULT_SENTINEL, user_agent=None, ssl_context=DEFAULT_SENTINEL, adapter_factory=None, security_key=None)
参数:
geocode(query, *, exactly_one=True, timeout=DEFAULT_SENTINEL)

按地址返回位置点。

参数:

  • query (str) -- 要对其进行地理编码的地址或查询。

  • exactly_one (bool) -- 如果可用，返回一个结果或结果列表。

  • timeout (int) -- 等待地理编码服务响应的时间（秒），然后引发 geopy.exc.GeocoderTimedOut 例外。仅当您希望在这个调用上覆盖在地理编码程序初始化期间设置的值时，才设置这个值。

返回类型:

None ， geopy.location.Location 或者他们的列表，如果 exactly_one=False .

reverse(query, *, exactly_one=True, timeout=DEFAULT_SENTINEL)

按地点返回地址。

参数:

  • query (geopy.point.Point, list or tuple of (latitude, longitude), or string as "%(latitude)s, %(longitude)s".) -- 您希望获得最接近人类可读地址的坐标。

  • exactly_one (bool) -- 如果可用，返回一个结果或结果列表。百度的API最多只能返回一个结果。

  • timeout (int) -- 等待地理编码服务响应的时间（秒），然后引发 geopy.exc.GeocoderTimedOut 例外。仅当您希望在这个调用上覆盖在地理编码程序初始化期间设置的值时，才设置这个值。

返回类型:

None ， geopy.location.Location 或者他们的列表，如果 exactly_one=False .

百渡v3

class geopy.geocoders.BaiduV3(api_key, *, scheme=None, timeout=DEFAULT_SENTINEL, proxies=DEFAULT_SENTINEL, user_agent=None, ssl_context=DEFAULT_SENTINEL, adapter_factory=None, security_key=None)

基类：Baidu

地理编码器使用百度地图v3api。

文件地址：

http://lbsyun.baidu.com/index.php?title=webapi/guide/webservice-geocoding

__init__(api_key, *, scheme=None, timeout=DEFAULT_SENTINEL, proxies=DEFAULT_SENTINEL, user_agent=None, ssl_context=DEFAULT_SENTINEL, adapter_factory=None, security_key=None)
参数:
geocode(query, *, exactly_one=True, timeout=DEFAULT_SENTINEL)

按地址返回位置点。

参数:

  • query (str) -- 要对其进行地理编码的地址或查询。

  • exactly_one (bool) -- 如果可用，返回一个结果或结果列表。

  • timeout (int) -- 等待地理编码服务响应的时间（秒），然后引发 geopy.exc.GeocoderTimedOut 例外。仅当您希望在这个调用上覆盖在地理编码程序初始化期间设置的值时，才设置这个值。

返回类型:

None ， geopy.location.Location 或者他们的列表，如果 exactly_one=False .

reverse(query, *, exactly_one=True, timeout=DEFAULT_SENTINEL)

按地点返回地址。

参数:

  • query (geopy.point.Point, list or tuple of (latitude, longitude), or string as "%(latitude)s, %(longitude)s".) -- 您希望获得最接近人类可读地址的坐标。

  • exactly_one (bool) -- 如果可用，返回一个结果或结果列表。百度的API最多只能返回一个结果。

  • timeout (int) -- 等待地理编码服务响应的时间（秒），然后引发 geopy.exc.GeocoderTimedOut 例外。仅当您希望在这个调用上覆盖在地理编码程序初始化期间设置的值时，才设置这个值。

返回类型:

None ， geopy.location.Location 或者他们的列表，如果 exactly_one=False .

BANFrance

class geopy.geocoders.BANFrance(*, domain='api-adresse.data.gouv.fr', scheme=None, timeout=DEFAULT_SENTINEL, proxies=DEFAULT_SENTINEL, user_agent=None, ssl_context=DEFAULT_SENTINEL, adapter_factory=None)

使用基础地址的地理编码国家法国API。

文件地址：

https://adresse.data.gouv.fr/api

__init__(*, domain='api-adresse.data.gouv.fr', scheme=None, timeout=DEFAULT_SENTINEL, proxies=DEFAULT_SENTINEL, user_agent=None, ssl_context=DEFAULT_SENTINEL, adapter_factory=None)
参数:
geocode(query, *, limit=None, exactly_one=True, timeout=DEFAULT_SENTINEL)

按地址返回位置点。

参数:

  • query (str) -- 要对其进行地理编码的地址或查询。

  • limit (int) -- 定义响应结构中的最大项数。如果没有提供，并且有多个结果，BAN API将默认返回5个结果。如果 exactly_one 是True，则将重置为1。

  • exactly_one (bool) -- 如果可用，返回一个结果或结果列表。

  • timeout (int) -- 等待地理编码服务响应的时间（秒），然后引发 geopy.exc.GeocoderTimedOut 例外。仅当您希望在这个调用上覆盖在地理编码程序初始化期间设置的值时，才设置这个值。

返回类型:

None ， geopy.location.Location 或者他们的列表，如果 exactly_one=False .

reverse(query, *, exactly_one=True, timeout=DEFAULT_SENTINEL)

按地点返回地址。

参数:

  • query (geopy.point.Point, list or tuple of (latitude, longitude), or string as "%(latitude)s, %(longitude)s".) -- 您希望获得最接近人类可读地址的坐标。

  • exactly_one (bool) -- 如果可用，返回一个结果或结果列表。

  • timeout (int) -- 等待地理编码服务响应的时间（秒），然后引发 geopy.exc.GeocoderTimedOut 例外。仅当您希望在这个调用上覆盖在地理编码程序初始化期间设置的值时，才设置这个值。

返回类型:

None ， geopy.location.Location 或者他们的列表，如果 exactly_one=False .

Bing

class geopy.geocoders.Bing(api_key, *, scheme=None, timeout=DEFAULT_SENTINEL, proxies=DEFAULT_SENTINEL, user_agent=None, ssl_context=DEFAULT_SENTINEL, adapter_factory=None, domain='dev.virtualearth.net')

使用Bing地图位置API进行地理编码。

文件地址：

https://msdn.microsoft.com/en-us/library/ff701715.aspx

__init__(api_key, *, scheme=None, timeout=DEFAULT_SENTINEL, proxies=DEFAULT_SENTINEL, user_agent=None, ssl_context=DEFAULT_SENTINEL, adapter_factory=None, domain='dev.virtualearth.net')
参数:
geocode(query, *, exactly_one=True, user_location=None, timeout=DEFAULT_SENTINEL, culture=None, include_neighborhood=None, include_country_code=False)

按地址返回位置点。

参数:

  • query (str or dict) -- 要对其进行地理编码的地址或查询。对于结构化查询，请提供其关键字为以下各项之一的字典： addressLine ， locality (城市)， adminDistrict (述明)， countryRegion ，或 postalCode 。

  • exactly_one (bool) -- 如果可用，返回一个结果或结果列表。

  • user_location (geopy.point.Point) -- 确定靠近此位置的结果的优先级。

  • timeout (int) -- 等待地理编码服务响应的时间（秒），然后引发 geopy.exc.GeocoderTimedOut 例外。仅当您希望在这个调用上覆盖在地理编码程序初始化期间设置的值时，才设置这个值。

  • culture (str) -- 影响响应的语言，必须是两个字母的国家/地区代码。

  • include_neighborhood (bool) -- 设置是否在响应中包含邻域字段。

  • include_country_code (bool) -- 设置是否在响应中包含国家/地区的两个字母的ISO代码（字段名“countryRegioniso2”）。

返回类型:

None ， geopy.location.Location 或者他们的列表，如果 exactly_one=False .

reverse(query, *, exactly_one=True, timeout=DEFAULT_SENTINEL, culture=None, include_country_code=False)

按地点返回地址。

参数:

  • query (geopy.point.Point, list or tuple of (latitude, longitude), or string as "%(latitude)s, %(longitude)s".) -- 您希望获得最接近人类可读地址的坐标。

  • exactly_one (bool) -- 如果可用，返回一个结果或结果列表。

  • timeout (int) -- 等待地理编码服务响应的时间（秒），然后引发 geopy.exc.GeocoderTimedOut 例外。仅当您希望在这个调用上覆盖在地理编码程序初始化期间设置的值时，才设置这个值。

  • culture (str) -- 影响响应的语言，必须是两个字母的国家/地区代码。

  • include_country_code (bool) -- 设置是否在响应中包含国家/地区的两个字母的ISO代码（字段名“countryRegioniso2”）。

返回类型:

None ， geopy.location.Location 或者他们的列表，如果 exactly_one=False .

数据库

class geopy.geocoders.DataBC(*, scheme=None, timeout=DEFAULT_SENTINEL, proxies=DEFAULT_SENTINEL, user_agent=None, ssl_context=DEFAULT_SENTINEL, adapter_factory=None, domain='geocoder.api.gov.bc.ca')

使用来自databc的物理地址地理码器的地理码器。

文件地址：

https://github.com/bcgov/ols-geocoder/blob/gh-pages/geocoder-developer-guide.md

__init__(*, scheme=None, timeout=DEFAULT_SENTINEL, proxies=DEFAULT_SENTINEL, user_agent=None, ssl_context=DEFAULT_SENTINEL, adapter_factory=None, domain='geocoder.api.gov.bc.ca')
参数:
geocode(query, *, max_results=25, set_back=0, location_descriptor='any', exactly_one=True, timeout=DEFAULT_SENTINEL)

按地址返回位置点。

参数:

  • query (str) -- 要对其进行地理编码的地址或查询。

  • max_results (int) -- 要请求的最大结果数。

  • set_back (float) -- 将接入点从路缘（以米为单位）移动到地块内部的距离。位置描述符必须设置为访问点才能使设置返回生效。

  • location_descriptor (str) -- 请求的点类型。它可以是任何，入口点，前门点，停车点，屋顶点和路线点。

  • exactly_one (bool) -- 如果可用，返回一个结果或结果列表。

  • timeout (int) -- 等待地理编码服务响应的时间（秒），然后引发 geopy.exc.GeocoderTimedOut 例外。仅当您希望在这个调用上覆盖在地理编码程序初始化期间设置的值时，才设置这个值。

返回类型:

None ， geopy.location.Location 或者他们的列表，如果 exactly_one=False .

GeocodeEarth

class geopy.geocoders.GeocodeEarth(api_key, *, domain='api.geocode.earth', timeout=DEFAULT_SENTINEL, proxies=DEFAULT_SENTINEL, user_agent=None, scheme=None, ssl_context=DEFAULT_SENTINEL, adapter_factory=None)

基类：Pelias

Geocode Earth，这是一个由Pelias本身的开发者提供的基于Pelias的服务。

文件地址：

https://geocode.earth/docs

定价详情：

Https://geocode.earth/#pricing

__init__(api_key, *, domain='api.geocode.earth', timeout=DEFAULT_SENTINEL, proxies=DEFAULT_SENTINEL, user_agent=None, scheme=None, ssl_context=DEFAULT_SENTINEL, adapter_factory=None)
参数:
geocode(query, *, exactly_one=True, timeout=DEFAULT_SENTINEL, boundary_rect=None, countries=None, country_bias=None, language=None)

按地址返回位置点。

参数:

  • query (str) -- 要对其进行地理编码的地址或查询。

  • exactly_one (bool) -- 如果可用，返回一个结果或结果列表。

  • timeout (int) -- 等待地理编码服务响应的时间（秒），然后引发 geopy.exc.GeocoderTimedOut 例外。仅当您希望在这个调用上覆盖在地理编码程序初始化期间设置的值时，才设置这个值。

  • boundary_rect (list or tuple of 2 items of geopy.point.Point or (latitude, longitude) or "%(latitude)s, %(longitude)s".) -- 限制搜索的坐标。例如： [Point(22, 180), Point(-22, -180)] .

  • countries (list) -- 中指定的国家/地区代码列表 ISO 3166-1 alpha-2 or alpha-3 格式，例如 ['USA', 'CAN'] 。这是一个硬过滤器。。。添加的版本：：2.3

  • country_bias (str) -- 将结果偏向这个国家(ISO Alpha-3)。。。不推荐使用：：2.3 countries 取而代之的是。该选项的作用相同，也就是说，它不是顾名思义的软过滤器。此参数计划在Geopy 3.0中删除。

  • language (str) -- 返回结果的首选语言。两者都使用标准 RFC2616 接受语言字符串或简单的以逗号分隔的语言代码列表。

返回类型:

None ， geopy.location.Location 或者他们的列表，如果 exactly_one=False .

reverse(query, *, exactly_one=True, timeout=DEFAULT_SENTINEL, language=None)

按地点返回地址。

参数:

  • query (geopy.point.Point, list or tuple of (latitude, longitude), or string as "%(latitude)s, %(longitude)s".) -- 您希望获得最接近人类可读地址的坐标。

  • exactly_one (bool) -- 如果可用，返回一个结果或结果列表。

  • timeout (int) -- 等待地理编码服务响应的时间（秒），然后引发 geopy.exc.GeocoderTimedOut 例外。仅当您希望在这个调用上覆盖在地理编码程序初始化期间设置的值时，才设置这个值。

  • language (str) -- 返回结果的首选语言。两者都使用标准 RFC2616 接受语言字符串或简单的以逗号分隔的语言代码列表。

返回类型:

None ， geopy.location.Location 或者他们的列表，如果 exactly_one=False .

GeocodeFarm

在 2.2 版本发生变更: 由于服务太不可靠，此类已被删除。看见 #445 。

Geocodio

class geopy.geocoders.Geocodio(api_key, *, scheme=None, timeout=DEFAULT_SENTINEL, proxies=DEFAULT_SENTINEL, user_agent=None, ssl_context=DEFAULT_SENTINEL, adapter_factory=None, domain=None)

使用Geocod.io API的地理编码器。

文件地址：

https://www.geocod.io/docs/

定价详情：

https://www.geocod.io/pricing/

在 2.2 版本加入.

__init__(api_key, *, scheme=None, timeout=DEFAULT_SENTINEL, proxies=DEFAULT_SENTINEL, user_agent=None, ssl_context=DEFAULT_SENTINEL, adapter_factory=None, domain=None)
参数:
geocode(query, *, limit=None, exactly_one=True, timeout=DEFAULT_SENTINEL)

按地址返回位置点。

参数:

  • query (dict or str) -- 要对其进行地理编码的地址、查询或结构化查询。对于结构化查询，请提供其关键字为以下各项之一的字典： street ， city ， state ， postal_code 或 country 。

  • limit (int) -- 要返回的最大匹配数。如果满足以下条件，则该值将重置为1 exactly_one 是 True 。

  • exactly_one (bool) -- 如果可用，返回一个结果或结果列表。

  • timeout (int) -- 等待地理编码服务响应的时间（秒），然后引发 geopy.exc.GeocoderTimedOut 例外。仅当您希望在这个调用上覆盖在地理编码程序初始化期间设置的值时，才设置这个值。

返回类型:

None ， geopy.location.Location 或者他们的列表，如果 exactly_one=False .

reverse(query, *, exactly_one=True, timeout=DEFAULT_SENTINEL, limit=None)

按地点返回地址。

参数:

  • query (str) -- 要获取最接近的人类可读地址的坐标

  • exactly_one (bool) -- 如果可用，返回一个结果或结果列表。

  • timeout (int) -- 等待地理编码服务响应的时间（秒），然后引发 geopy.exc.GeocoderTimedOut 例外。仅当您希望在这个调用上覆盖在地理编码程序初始化期间设置的值时，才设置这个值。

  • limit (int) -- 要返回的最大匹配数。如果满足以下条件，则该值将重置为1 exactly_one 是 True 。

返回类型:

None ， geopy.location.Location 或者他们的列表，如果 exactly_one=False .

地理湖

class geopy.geocoders.Geokeo(api_key, *, domain='geokeo.com', scheme=None, timeout=DEFAULT_SENTINEL, proxies=DEFAULT_SENTINEL, user_agent=None, ssl_context=DEFAULT_SENTINEL, adapter_factory=None)

使用Geokeo API的地理编码器。

文件地址：

https://geokeo.com/documentation.php

在 2.4 版本加入.

__init__(api_key, *, domain='geokeo.com', scheme=None, timeout=DEFAULT_SENTINEL, proxies=DEFAULT_SENTINEL, user_agent=None, ssl_context=DEFAULT_SENTINEL, adapter_factory=None)
参数:
geocode(query, *, country=None, exactly_one=True, timeout=DEFAULT_SENTINEL)

按地址返回位置点。

参数:

  • query (str) -- 要对其进行地理编码的地址或查询。

  • country (str) -- 将结果限制为指定的国家/地区。国家代码是由ISO 3166-1 Alpha 2标准定义的2个字符的代码(例如 us )。

  • exactly_one (bool) -- 如果可用，返回一个结果或结果列表。

  • timeout (int) -- 等待地理编码服务响应的时间（秒），然后引发 geopy.exc.GeocoderTimedOut 例外。仅当您希望在这个调用上覆盖在地理编码程序初始化期间设置的值时，才设置这个值。

返回类型:

None ， geopy.location.Location 或者他们的列表，如果 exactly_one=False .

reverse(query, *, exactly_one=True, timeout=DEFAULT_SENTINEL)

按地点返回地址。

参数:

  • query (geopy.point.Point, list or tuple of (latitude, longitude), or string as "%(latitude)s, %(longitude)s".) -- 您希望获得最接近人类可读地址的坐标。

  • exactly_one (bool) -- 如果可用，返回一个结果或结果列表。

  • timeout (int) -- 等待地理编码服务响应的时间（秒），然后引发 geopy.exc.GeocoderTimedOut 例外。仅当您希望在这个调用上覆盖在地理编码程序初始化期间设置的值时，才设置这个值。

返回类型:

None ， geopy.location.Location 或者他们的列表，如果 exactly_one=False .

Geolake

class geopy.geocoders.Geolake(api_key, *, domain='api.geolake.com', scheme=None, timeout=DEFAULT_SENTINEL, proxies=DEFAULT_SENTINEL, user_agent=None, ssl_context=DEFAULT_SENTINEL, adapter_factory=None)

使用geolike api的地理编码。

文件地址：

https://geolake.com/docs/api

服务条款：

https://geolake.com/terms-of-use

__init__(api_key, *, domain='api.geolake.com', scheme=None, timeout=DEFAULT_SENTINEL, proxies=DEFAULT_SENTINEL, user_agent=None, ssl_context=DEFAULT_SENTINEL, adapter_factory=None)
参数:
geocode(query, *, country_codes=None, exactly_one=True, timeout=DEFAULT_SENTINEL)

按地址返回位置点。

参数:

  • query (str or dict) -- 要对其进行地理编码的地址或查询。对于结构化查询，提供其键为以下之一的字典： country ， state ， city ， zipcode ， street ， address ， houseNumber 或 subNumber .

  • country_codes (str or list) -- 为地理编码程序提供查询可能驻留的国家/地区代码列表。该值将把地理编码限制在所提供的国家。国家代码是由ISO-3166-1α-2标准（例如 FR ）可以使用python列表指定多个国家/地区。

  • exactly_one (bool) -- 返回一个结果或一个结果的列表。

  • timeout (int) -- 等待地理编码服务响应的时间（秒），然后引发 geopy.exc.GeocoderTimedOut 例外。仅当您希望在这个调用上覆盖在地理编码程序初始化期间设置的值时，才设置这个值。

返回类型:

None ， geopy.location.Location 或者他们的列表，如果 exactly_one=False .

GeoNames

class geopy.geocoders.GeoNames(username, *, timeout=DEFAULT_SENTINEL, proxies=DEFAULT_SENTINEL, user_agent=None, ssl_context=DEFAULT_SENTINEL, adapter_factory=None, scheme='http', domain='api.geonames.org')

GeoNames 地理编码器。

文件地址：

http://www.geonames.org/export/geonames-search.html

反向地理编码文件：

http://www.geonames.org/export/web-services.html#findNearbyPlaceName

__init__(username, *, timeout=DEFAULT_SENTINEL, proxies=DEFAULT_SENTINEL, user_agent=None, ssl_context=DEFAULT_SENTINEL, adapter_factory=None, scheme='http', domain='api.geonames.org')
参数:
geocode(query, *, exactly_one=True, timeout=DEFAULT_SENTINEL, country=None, country_bias=None)

按地址返回位置点。

参数:

  • query (str) -- 要对其进行地理编码的地址或查询。

  • exactly_one (bool) -- 如果可用，返回一个结果或结果列表。

  • timeout (int) -- 等待地理编码服务响应的时间（秒），然后引发 geopy.exc.GeocoderTimedOut 例外。仅当您希望在这个调用上覆盖在地理编码程序初始化期间设置的值时，才设置这个值。

  • country (str or list) -- 将记录限制到指定的国家。两个字母的国家代码ISO-3166（例如 FR ）可能是单个字符串或字符串列表。

  • country_bias (str) -- 首先列出来自国家/地区偏差的记录。两个字母的国家代码ISO-3166。

返回类型:

None ， geopy.location.Location 或者他们的列表，如果 exactly_one=False .

reverse(query, *, exactly_one=True, timeout=DEFAULT_SENTINEL, feature_code=None, lang=None, find_nearby_type='findNearbyPlaceName')

按地点返回地址。

参数:

  • query (geopy.point.Point, list or tuple of (latitude, longitude), or string as "%(latitude)s, %(longitude)s".) -- 您希望获得最接近人类可读地址的坐标。

  • exactly_one (bool) -- 如果可用，返回一个结果或结果列表。

  • timeout (int) -- 等待地理编码服务响应的时间（秒），然后引发 geopy.exc.GeocoderTimedOut 例外。仅当您希望在这个调用上覆盖在地理编码程序初始化期间设置的值时，才设置这个值。

  • feature_code (str) -- GeoNames功能代码

  • lang (str) -- 返回的语言 name 元素（伪语言代码“local”将以本地语言返回）支持语言的完整列表可在以下位置找到：https://www.geonames.org/countries/

  • find_nearby_type (str) -- 用于在不同GeoNames API端点之间切换的标志。默认值为 findNearbyPlaceName 返回最近的居民点。另一个当前实现的选项是 findNearby 返回lat/lng查询的最近地名。

返回类型:

None ， geopy.location.Location 或者他们的列表，如果 exactly_one=False .

reverse_timezone(query, *, timeout=DEFAULT_SENTINEL)

在 `query`找到一个点的时区 .

GeoNames 总是返回时区：如果查询的点没有分配的olson时区ID，则 pytz.FixedOffset 时区用于生成 :类:`geopy.timezone.Timezone` .

参数:

  • query (geopy.point.Point, list or tuple of (latitude, longitude), or string as "%(latitude)s, %(longitude)s") -- 需要时区的坐标。

  • timeout (int) -- 等待地理编码服务响应的时间（秒），然后引发 geopy.exc.GeocoderTimedOut 例外。仅当您希望在这个调用上覆盖在地理编码程序初始化期间设置的值时，才设置这个值。

返回类型:

geopy.timezone.Timezone 。

GoGuLv3

class geopy.geocoders.GoogleV3(api_key=None, *, domain='maps.googleapis.com', scheme=None, client_id=None, secret_key=None, timeout=DEFAULT_SENTINEL, proxies=DEFAULT_SENTINEL, user_agent=None, ssl_context=DEFAULT_SENTINEL, adapter_factory=None, channel='')

使用谷歌地图v3 api的地理编码。

文件地址：

https://developers.google.com/maps/documentation/geocoding/

定价详情：

https://developers.google.com/maps/documentation/geocoding/usage-and-billing

__init__(api_key=None, *, domain='maps.googleapis.com', scheme=None, client_id=None, secret_key=None, timeout=DEFAULT_SENTINEL, proxies=DEFAULT_SENTINEL, user_agent=None, ssl_context=DEFAULT_SENTINEL, adapter_factory=None, channel='')
参数:
geocode(query=None, *, exactly_one=True, timeout=DEFAULT_SENTINEL, bounds=None, region=None, components=None, place_id=None, language=None, sensor=False)

按地址返回位置点。

参数:

  • query (str) -- 要对其进行地理编码的地址或查询。可选，如果 components 设置参数：：>g.Geocode(Components={“CITY”：“PARIS”，“COUNTRY”：“FR”})位置(法国，(46.227638，2.213749，0.0))

  • exactly_one (bool) -- 如果可用，返回一个结果或结果列表。

  • timeout (int) -- 等待地理编码服务响应的时间（秒），然后引发 geopy.exc.GeocoderTimedOut 例外。仅当您希望在这个调用上覆盖在地理编码程序初始化期间设置的值时，才设置这个值。

  • bounds (list or tuple of 2 items of geopy.point.Point or (latitude, longitude) or "%(latitude)s, %(longitude)s".) -- 视区的边界框，在其中偏向地理编码的结果更突出。例子： [Point(22, 180), Point(-22, -180)] .

  • region (str) -- 区域代码，指定为cctld（“顶级域”）的两个字符值。

  • components (dict or list) -- 仅限于某个区域。可以使用以下任意组合： route ， locality ， administrative_area ， postal_code ， country . 如果要指定同一类型的多个组件，请传递元组列表，例如：>>> [('administrative_area', 'VA'), ('administrative_area', 'Arlington')]

  • place_id (str) -- 使用地点ID检索位置。不能与一起使用 query 或 bounds 参数。>>>g.geocode（place_id='ChIJOcfP0Iq2j4ARDrXUa7ZWs34'）

  • language (str) -- 返回结果的语言。

  • sensor (bool) -- 地理编码请求是否来自带有位置传感器的设备。

返回类型:

None ， geopy.location.Location 或者他们的列表，如果 exactly_one=False .

reverse(query, *, exactly_one=True, timeout=DEFAULT_SENTINEL, language=None, sensor=False)

按地点返回地址。

参数:

  • query (geopy.point.Point, list or tuple of (latitude, longitude), or string as "%(latitude)s, %(longitude)s".) -- 您希望获得最接近人类可读地址的坐标。

  • exactly_one (bool) -- 如果可用，返回一个结果或结果列表。

  • timeout (int) -- 等待地理编码服务响应的时间（秒），然后引发 geopy.exc.GeocoderTimedOut 例外。仅当您希望在这个调用上覆盖在地理编码程序初始化期间设置的值时，才设置这个值。

  • language (str) -- 返回结果的语言。

  • sensor (bool) -- 地理编码请求是否来自带有位置传感器的设备。

返回类型:

None ， geopy.location.Location 或者他们的列表，如果 exactly_one=False .

reverse_timezone(query, *, at_time=None, timeout=DEFAULT_SENTINEL)

在 query 中找到指定的 `at_time`时区.

None 对于没有指定奥尔森时区id的点，将返回（例如，对于南极洲）。

参数:

  • query (geopy.point.Point, list or tuple of (latitude, longitude), or string as "%(latitude)s, %(longitude)s") -- 需要时区的坐标。

  • at_time (datetime.datetime or None) -- 您希望此位置的时区的时间。这是可选的，默认为以UTC格式调用函数的时间。时区感知的日期时间被正确处理，原始日期时间被静默地视为UTC。

  • timeout (int) -- 等待地理编码服务响应的时间（秒），然后引发 geopy.exc.GeocoderTimedOut 例外。仅当您希望在这个调用上覆盖在地理编码程序初始化期间设置的值时，才设置这个值。

返回类型:

None 或 geopy.timezone.Timezone 。

HERE

class geopy.geocoders.Here(*, app_id=None, app_code=None, apikey=None, scheme=None, timeout=DEFAULT_SENTINEL, proxies=DEFAULT_SENTINEL, user_agent=None, ssl_context=DEFAULT_SENTINEL, adapter_factory=None)

Geocoder使用HERE Geocoder API。

文件地址：

https://developer.here.com/documentation/geocoder/

注意

该类使用处于维护模式的V6API。考虑使用较新的 HereV7 班级。

__init__(*, app_id=None, app_code=None, apikey=None, scheme=None, timeout=DEFAULT_SENTINEL, proxies=DEFAULT_SENTINEL, user_agent=None, ssl_context=DEFAULT_SENTINEL, adapter_factory=None)
参数:
geocode(query, *, bbox=None, mapview=None, exactly_one=True, maxresults=None, pageinformation=None, language=None, additional_data=False, timeout=DEFAULT_SENTINEL)

按地址返回位置点。

这个实现仅支持所有可用参数的子集。 此处提供了纯REST API的所有参数列表：https：//developer.here.com/documentation/geocoder/topics/resource-geocode.html

参数:

  • query (str or dict) -- 要对其进行地理编码的地址或查询。对于结构化查询，提供其键为以下之一的字典： city, county, district, country, state, street, housenumber, 或 postalcode.

  • bbox (list or tuple of 2 items of geopy.point.Point or (latitude, longitude) or "%(latitude)s, %(longitude)s".) -- 一种空间过滤器，限制对请求中任何其他属性的搜索。由两对坐标（lat/lon）指定--框的角。 The bbox search is currently similar to mapview but it is not extended （引自 REST API文档）。还将返回相关的全局结果。例如： [Point(22, 180), Point(-22, -180)] .

  • mapview (list or tuple of 2 items of geopy.point.Point or (latitude, longitude) or "%(latitude)s, %(longitude)s".) -- 应用程序的视区，作为两个坐标对给出，由两个lat/lon对指定——分别是边界框的角。从集合地图视图加上扩展区域中的匹配项排名最高。还将返回相关的全局结果。例如： [Point(22, 180), Point(-22, -180)] .

  • exactly_one (bool) -- 如果可用，返回一个结果或结果列表。

  • maxresults (int) -- 定义响应结构中的最大项数。如果没有提供，并且有多个结果， HERE API将默认返回10个结果。如果 exactly_one 是True，则将重置为1。

  • pageinformation (int) -- 当响应被分成多个页时，标识要返回的页的键。仅在提供“maxresults”时才有用。

  • language (str) -- 影响响应的语言，必须是RFC 4647语言代码，例如“en-US”。

  • additional_data (str) -- 具有键值对的字符串，如https://developer.here.com/documentation/geocoder/topics/resource-params-additional.html中所述。 这些将作为一个查询参数添加到URL。

  • timeout (int) -- 等待地理编码服务响应的时间（秒），然后引发 geopy.exc.GeocoderTimedOut 例外。仅当您希望在这个调用上覆盖在地理编码程序初始化期间设置的值时，才设置这个值。

返回类型:

None ， geopy.location.Location 或者他们的列表，如果 exactly_one=False .

reverse(query, *, radius=None, exactly_one=True, maxresults=None, pageinformation=None, language=None, mode='retrieveAddresses', timeout=DEFAULT_SENTINEL)

按地点返回地址。

此实现仅支持所有可用参数的子集。 此处提供了纯REST API的所有参数列表：https：//developer.here.com/documentation/geocoder/topics/resource-reverse-geocode.html

参数:

  • query (geopy.point.Point, list or tuple of (latitude, longitude), or string as "%(latitude)s, %(longitude)s".) -- 您希望获得最接近人类可读地址的坐标。

  • radius (float) -- 接近半径（米）。

  • exactly_one (bool) -- 如果可用，返回一个结果或结果列表。

  • maxresults (int) -- 定义响应结构中的最大项数。如果没有提供，并且有多个结果， HERE API将默认返回10个结果。如果 exactly_one 是True，则将重置为1。

  • pageinformation (int) -- 当响应被分成多个页时，标识要返回的页的键。仅在提供“maxresults”时才有用。

  • language (str) -- 影响响应的语言，必须是RFC 4647语言代码，例如“en-US”。

  • mode (str) -- 影响返回的响应项的类型，必须是“retrieveAddresses”（默认）、“retrieveAreas”、“retrieveLandmarks”、“retrieveAll”或“trackPosition”之一。有关详细信息，请参阅联机文档。

  • timeout (int) -- 等待地理编码服务响应的时间（秒），然后引发 geopy.exc.GeocoderTimedOut 例外。仅当您希望在这个调用上覆盖在地理编码程序初始化期间设置的值时，才设置这个值。

返回类型:

None ， geopy.location.Location 或者他们的列表，如果 exactly_one=False .

HEREv7

class geopy.geocoders.HereV7(apikey, *, scheme=None, timeout=DEFAULT_SENTINEL, proxies=DEFAULT_SENTINEL, user_agent=None, ssl_context=DEFAULT_SENTINEL, adapter_factory=None, domain='search.hereapi.com')

使用此处地理编码和搜索v7 API的地理编码器。

文件地址：

https://developer.here.com/documentation/geocoding-search-api/

服务条款：

https://legal.here.com/en-gb/terms

在 2.2 版本加入.

__init__(apikey, *, scheme=None, timeout=DEFAULT_SENTINEL, proxies=DEFAULT_SENTINEL, user_agent=None, ssl_context=DEFAULT_SENTINEL, adapter_factory=None, domain='search.hereapi.com')
参数:
geocode(query=None, *, components=None, at=None, countries=None, language=None, limit=None, exactly_one=True, timeout=DEFAULT_SENTINEL)

按地址返回位置点。

参数:

  • query (str) -- 要对其进行地理编码的地址或查询。可选，如果 components 参数已设置。

  • components (dict) -- 结构化查询。可以与自由文本一起使用 query 。应该是关键字为以下之一的字典： country ， state ， county ， city ， district ， street ， houseNumber ， postalCode 。

  • at (geopy.point.Point, list or tuple of (latitude, longitude), or string as "%(latitude)s, %(longitude)s".) -- 搜索上下文的中心。

  • countries (list) -- 中指定的国家/地区代码列表 ISO 3166-1 alpha-3 格式，例如 ['USA', 'CAN'] 。这是硬过滤。

  • language (str) -- 影响响应的语言，必须是符合BCP 47的语言代码，例如 en-US 。

  • limit (int) -- 定义响应结构中的最大项目数。如果没有提供并且有多个结果，则HERE API将默认返回20个结果。如果满足以下条件，则该值将重置为1 exactly_one 是真的。

  • exactly_one (bool) -- 如果可用，返回一个结果或结果列表。

  • timeout (int) -- 等待地理编码服务响应的时间（秒），然后引发 geopy.exc.GeocoderTimedOut 例外。仅当您希望在这个调用上覆盖在地理编码程序初始化期间设置的值时，才设置这个值。

返回类型:

None ， geopy.location.Location 或者他们的列表，如果 exactly_one=False .

reverse(query, *, language=None, limit=None, exactly_one=True, timeout=DEFAULT_SENTINEL)

按地点返回地址。

参数:

  • query (geopy.point.Point, list or tuple of (latitude, longitude), or string as "%(latitude)s, %(longitude)s".) -- 您希望获得最接近人类可读地址的坐标。

  • language (str) -- 影响响应的语言，必须是符合BCP 47的语言代码，例如 en-US 。

  • limit (int) -- 要返回的最大结果数。如果满足以下条件，则该值将重置为1 exactly_one 是真的。

  • exactly_one (bool) -- 如果可用，返回一个结果或结果列表。

  • timeout (int) -- 等待地理编码服务响应的时间（秒），然后引发 geopy.exc.GeocoderTimedOut 例外。仅当您希望在这个调用上覆盖在地理编码程序初始化期间设置的值时，才设置这个值。

返回类型:

None ， geopy.location.Location 或者他们的列表，如果 exactly_one=False .

IGNFrance

class geopy.geocoders.IGNFrance(api_key=None, *, username=None, password=None, referer=None, domain='wxs.ign.fr', scheme=None, timeout=DEFAULT_SENTINEL, proxies=DEFAULT_SENTINEL, user_agent=None, ssl_context=DEFAULT_SENTINEL, adapter_factory=None)

使用ign france geocoder opens api的geocoder。

文件地址：

https://geoservices.ign.fr/services-web-essentiels

__init__(api_key=None, *, username=None, password=None, referer=None, domain='wxs.ign.fr', scheme=None, timeout=DEFAULT_SENTINEL, proxies=DEFAULT_SENTINEL, user_agent=None, ssl_context=DEFAULT_SENTINEL, adapter_factory=None)
参数:
geocode(query, *, query_type='StreetAddress', maximum_responses=25, is_freeform=False, filtering=None, exactly_one=True, timeout=DEFAULT_SENTINEL)

按地址返回位置点。

参数:

  • query (str) -- 要地理编码的查询字符串。

  • query_type (str) -- 提供地理编码的类型。它可以 PositionOfInterest, StreetAddress 或 CadastralParcel. StreetAddress 如果未提供，则为默认选项。

  • maximum_responses (int) -- 查询正文中请求API的最大响应数。

  • is_freeform (str) -- 设置返回是使用自由形式结构还是更结构化的返回。默认情况下，值为假。

  • filtering (str) -- 提供有助于设置地理编码过滤器的字符串。它包含一个XML字符串。参见文档中的示例和目录测试中的ignfrance.py文件。

  • exactly_one (bool) -- 如果可用，返回一个结果或结果列表。

  • timeout (int) -- 等待地理编码服务响应的时间（秒），然后引发 geopy.exc.GeocoderTimedOut 例外。仅当您希望在这个调用上覆盖在地理编码程序初始化期间设置的值时，才设置这个值。

返回类型:

None ， geopy.location.Location 或者他们的列表，如果 exactly_one=False .

reverse(query, *, reverse_geocode_preference=('StreetAddress',), maximum_responses=25, filtering='', exactly_one=True, timeout=DEFAULT_SENTINEL)

按地点返回地址。

参数:

  • query (geopy.point.Point, list or tuple of (latitude, longitude), or string as "%(latitude)s, %(longitude)s".) -- 您希望获得最接近人类可读地址的坐标。

  • reverse_geocode_preference (list) -- 启用以设置预期的结果类型。它可以 StreetAddress 或 PositionOfInterest. 默认设置为 StreetAddress.

  • maximum_responses (int) -- 查询正文中请求API的最大响应数。

  • filtering (str) -- 提供有助于设置地理编码过滤器的字符串。它包含一个XML字符串。参见文档中的示例和目录测试中的ignfrance.py文件。

  • exactly_one (bool) -- 如果可用，返回一个结果或结果列表。

  • timeout (int) -- 等待地理编码服务响应的时间（秒），然后引发 geopy.exc.GeocoderTimedOut 例外。仅当您希望在这个调用上覆盖在地理编码程序初始化期间设置的值时，才设置这个值。

返回类型:

None ， geopy.location.Location 或者他们的列表，如果 exactly_one=False .

MapBox

class geopy.geocoders.MapBox(api_key, *, scheme=None, timeout=DEFAULT_SENTINEL, proxies=DEFAULT_SENTINEL, user_agent=None, ssl_context=DEFAULT_SENTINEL, adapter_factory=None, domain='api.mapbox.com', referer=None)

使用mapbox api的地理编码。

文件地址：

https://www.mapbox.com/api-documentation/

__init__(api_key, *, scheme=None, timeout=DEFAULT_SENTINEL, proxies=DEFAULT_SENTINEL, user_agent=None, ssl_context=DEFAULT_SENTINEL, adapter_factory=None, domain='api.mapbox.com', referer=None)
参数:
geocode(query, *, exactly_one=True, timeout=DEFAULT_SENTINEL, proximity=None, country=None, language=None, bbox=None)

按地址返回位置点。

参数:

  • query (str) -- 要对其进行地理编码的地址或查询。

  • exactly_one (bool) -- 如果可用，返回一个结果或结果列表。

  • timeout (int) -- 等待地理编码服务响应的时间（秒），然后引发 geopy.exc.GeocoderTimedOut 例外。仅当您希望在这个调用上覆盖在地理编码程序初始化期间设置的值时，才设置这个值。

  • proximity (geopy.point.Point, list or tuple of (latitude, longitude), or string as "%(latitude)s, %(longitude)s".) -- 根据提供的位置偏移局部结果的坐标。

  • country (str or list) -- 以ISO 3166-1α-2国家代码的形式筛选结果的国家（例如 FR ）可能是字符串的python列表。

  • language (str) -- 此参数控制响应中提供的文本的语言，并影响结果评分，与用户的查询匹配的结果以请求的语言优先于以另一种语言匹配的结果。您可以传递两个字母的国家代码(ISO 639-1)。。。添加的版本：：2.3

  • bbox (list or tuple of 2 items of geopy.point.Point or (latitude, longitude) or "%(latitude)s, %(longitude)s".) -- 视区的边界框，在其中偏向地理编码的结果更突出。例子： [Point(22, 180), Point(-22, -180)] .

返回类型:

None ， geopy.location.Location 或者他们的列表，如果 exactly_one=False .

reverse(query, *, exactly_one=True, timeout=DEFAULT_SENTINEL)

按地点返回地址。

参数:

  • query (geopy.point.Point, list or tuple of (latitude, longitude), or string as "%(latitude)s, %(longitude)s".) -- 您希望获得最接近人类可读地址的坐标。

  • exactly_one (bool) -- 如果可用，返回一个结果或结果列表。

  • timeout (int) -- 等待地理编码服务响应的时间（秒），然后引发 geopy.exc.GeocoderTimedOut 例外。仅当您希望在这个调用上覆盖在地理编码程序初始化期间设置的值时，才设置这个值。

返回类型:

None ， geopy.location.Location 或者他们的列表，如果 exactly_one=False .

MapQuest

class geopy.geocoders.MapQuest(api_key, *, scheme=None, timeout=DEFAULT_SENTINEL, proxies=DEFAULT_SENTINEL, user_agent=None, ssl_context=DEFAULT_SENTINEL, adapter_factory=None, domain='www.mapquestapi.com')

Geocoder使用基于许可数据的MapQuest API。

文件地址：

https://developer.mapquest.com/documentation/geocoding-api/

MapQuest提供了两个地理编码API：

__init__(api_key, *, scheme=None, timeout=DEFAULT_SENTINEL, proxies=DEFAULT_SENTINEL, user_agent=None, ssl_context=DEFAULT_SENTINEL, adapter_factory=None, domain='www.mapquestapi.com')
参数:
geocode(query, *, exactly_one=True, timeout=DEFAULT_SENTINEL, limit=None, bounds=None)

按地址返回位置点。

参数:

  • query (str) -- 要对其进行地理编码的地址或查询。

  • exactly_one (bool) -- 如果可用，返回一个结果或结果列表。

  • timeout (int) -- 等待地理编码服务响应的时间（秒），然后引发 geopy.exc.GeocoderTimedOut 例外。仅当您希望在这个调用上覆盖在地理编码程序初始化期间设置的值时，才设置这个值。

  • limit (int) -- 限制响应中的最大项数。如果出现以下情况，将重置为1 exactly_one 是True。

  • bounds (list or tuple of 2 items of geopy.point.Point or (latitude, longitude) or "%(latitude)s, %(longitude)s".) -- 视区的边界框，在其中偏向地理编码的结果更突出。例子： [Point(22, 180), Point(-22, -180)] .

返回类型:

None ， geopy.location.Location 或者他们的列表，如果 exactly_one=False .

reverse(query, *, exactly_one=True, timeout=DEFAULT_SENTINEL)

按地点返回地址。

参数:

  • query (geopy.point.Point, list or tuple of (latitude, longitude), or string as "%(latitude)s, %(longitude)s".) -- 您希望获得最接近人类可读地址的坐标。

  • exactly_one (bool) -- 如果可用，返回一个结果或结果列表。

  • timeout (int) -- 等待地理编码服务响应的时间（秒），然后引发 geopy.exc.GeocoderTimedOut 例外。仅当您希望在这个调用上覆盖在地理编码程序初始化期间设置的值时，才设置这个值。

返回类型:

None ， geopy.location.Location 或者他们的列表，如果 exactly_one=False .

MapTiler

class geopy.geocoders.MapTiler(api_key, *, scheme=None, timeout=DEFAULT_SENTINEL, proxies=DEFAULT_SENTINEL, user_agent=None, ssl_context=DEFAULT_SENTINEL, adapter_factory=None, domain='api.maptiler.com')

使用MapTiler API的Geocoder。

文件地址：

https://cloud.maptiler.com/geocoding/ (requires sign-up)

__init__(api_key, *, scheme=None, timeout=DEFAULT_SENTINEL, proxies=DEFAULT_SENTINEL, user_agent=None, ssl_context=DEFAULT_SENTINEL, adapter_factory=None, domain='api.maptiler.com')
参数:
geocode(query, *, exactly_one=True, timeout=DEFAULT_SENTINEL, proximity=None, language=None, bbox=None)

按地址返回位置点。

参数:

  • query (str) -- 要对其进行地理编码的地址或查询。

  • exactly_one (bool) -- 如果可用，返回一个结果或结果列表。

  • timeout (int) -- 等待地理编码服务响应的时间（秒），然后引发 geopy.exc.GeocoderTimedOut 例外。仅当您希望在这个调用上覆盖在地理编码程序初始化期间设置的值时，才设置这个值。

  • proximity (geopy.point.Point, list or tuple of (latitude, longitude), or string as "%(latitude)s, %(longitude)s".) -- 根据提供的位置偏移局部结果的坐标。

  • language (str or list) -- 更喜欢特定语言的结果。接受单个字符串，例如 "en" 或者是一份清单 ["de", "en"] .

  • bbox (list or tuple of 2 items of geopy.point.Point or (latitude, longitude) or "%(latitude)s, %(longitude)s".) -- 视区的边界框，在其中偏向地理编码的结果更突出。例子： [Point(22, 180), Point(-22, -180)] .

返回类型:

None ， geopy.location.Location 或者他们的列表，如果 exactly_one=False .

reverse(query, *, exactly_one=True, timeout=DEFAULT_SENTINEL, language=None)

按地点返回地址。

参数:

  • query (geopy.point.Point, list or tuple of (latitude, longitude), or string as "%(latitude)s, %(longitude)s".) -- 您希望获得最接近人类可读地址的坐标。

  • exactly_one (bool) -- 如果可用，返回一个结果或结果列表。

  • timeout (int) -- 等待地理编码服务响应的时间（秒），然后引发 geopy.exc.GeocoderTimedOut 例外。仅当您希望在这个调用上覆盖在地理编码程序初始化期间设置的值时，才设置这个值。

  • language (str or list) -- 更喜欢特定语言的结果。接受单个字符串，例如 "en" 或者是一份清单 ["de", "en"] .

返回类型:

None ， geopy.location.Location 或者他们的列表，如果 exactly_one=False .

OpenCage

class geopy.geocoders.OpenCage(api_key, *, domain='api.opencagedata.com', scheme=None, timeout=DEFAULT_SENTINEL, proxies=DEFAULT_SENTINEL, user_agent=None, ssl_context=DEFAULT_SENTINEL, adapter_factory=None)

使用OpenCageData API的地理编码。

文件地址：

https://opencagedata.com/api

在 2.2 版本发生变更: 通过使用默认错误映射改进了错误处理(例如引发 exc.GeocoderQuotaExceeded 而不是 exc.GeocoderQueryError 对于HTTP 402错误)

__init__(api_key, *, domain='api.opencagedata.com', scheme=None, timeout=DEFAULT_SENTINEL, proxies=DEFAULT_SENTINEL, user_agent=None, ssl_context=DEFAULT_SENTINEL, adapter_factory=None)
参数:
geocode(query, *, bounds=None, country=None, language=None, annotations=True, exactly_one=True, timeout=DEFAULT_SENTINEL)

按地址返回位置点。

参数:

  • query (str) -- 要对其进行地理编码的地址或查询。

  • bounds (list or tuple of 2 items of geopy.point.Point or (latitude, longitude) or "%(latitude)s, %(longitude)s".) -- 向地理编码程序提供查询所在区域的提示。该值将有助于地理编码，但不会将可能的结果限制到所提供的区域。边界参数应指定为2个坐标点——边界框的角。例如： [Point(22, 180), Point(-22, -180)] .

  • country (str or list) -- 将结果限制在指定的一个或多个国家。国家代码是由ISO 3166-1α2标准（例如 fr ）可能是字符串的python列表。

  • language (str) -- iETF格式语言代码（例如 es 西班牙语或巴西葡萄牙语的pt-br）；如果省略了 en （英语）将由远程服务承担。

  • annotations (bool) -- 启用 annotations 数据，可通过以下方式访问 Location.raw 。如果您不需要它来获得一点性能优势，则设置为false。。。添加的版本：：2.2

  • exactly_one (bool) -- 如果可用，返回一个结果或结果列表。

  • timeout (int) -- 等待地理编码服务响应的时间（秒），然后引发 geopy.exc.GeocoderTimedOut 例外。仅当您希望在这个调用上覆盖在地理编码程序初始化期间设置的值时，才设置这个值。

返回类型:

None ， geopy.location.Location 或者他们的列表，如果 exactly_one=False .

reverse(query, *, language=None, exactly_one=True, timeout=DEFAULT_SENTINEL)

按地点返回地址。

参数:

  • query (geopy.point.Point, list or tuple of (latitude, longitude), or string as "%(latitude)s, %(longitude)s".) -- 您希望获得最接近人类可读地址的坐标。

  • language (str) -- 返回结果的语言。

  • exactly_one (bool) -- 如果可用，返回一个结果或结果列表。

  • timeout (int) -- 等待地理编码服务响应的时间（秒），然后引发 geopy.exc.GeocoderTimedOut 例外。仅当您希望在这个调用上覆盖在地理编码程序初始化期间设置的值时，才设置这个值。

返回类型:

None ， geopy.location.Location 或者他们的列表，如果 exactly_one=False .

OpenMapQuest

class geopy.geocoders.OpenMapQuest(api_key, *, timeout=DEFAULT_SENTINEL, proxies=DEFAULT_SENTINEL, domain='open.mapquestapi.com', scheme=None, user_agent=None, ssl_context=DEFAULT_SENTINEL, adapter_factory=None)

基类：Nominatim

使用MapQuest开放平台Web服务的地理编码。

文件地址：

https://developer.mapquest.com/documentation/open/

MapQuest提供了两个地理编码API：

__init__(api_key, *, timeout=DEFAULT_SENTINEL, proxies=DEFAULT_SENTINEL, domain='open.mapquestapi.com', scheme=None, user_agent=None, ssl_context=DEFAULT_SENTINEL, adapter_factory=None)
参数:
geocode(query, *, exactly_one=True, timeout=DEFAULT_SENTINEL, limit=None, addressdetails=False, language=False, geometry=None, extratags=False, country_codes=None, viewbox=None, bounded=False, featuretype=None, namedetails=False)

按地址返回位置点。

参数:

  • query (dict or str) -- 您希望地理编码的地址、查询或结构化查询。其中一个键是结构化的字典，它提供以下一个查询： street ， city ， county ， state ， country 或 postalcode . 有关更多信息，请参阅Nomingim的文档 structured requests : https://nomintim.org/release-docs/develop/api/Search

  • exactly_one (bool) -- 如果可用，返回一个结果或结果列表。

  • timeout (int) -- 等待地理编码服务响应的时间（秒），然后引发 geopy.exc.GeocoderTimedOut 例外。仅当您希望在这个调用上覆盖在地理编码程序初始化期间设置的值时，才设置这个值。

  • limit (int) -- 从Nominatim返回的最大结果量。非 exact_one设置为 假，否则限制将始终为1。

  • addressdetails (bool) -- 如果你想加入的话 Location.raw 要包括地址详细信息，如HOUSE_NUMBER、CITY_SEARD、邮政编码等(以结构化形式)，请将其设置为True

  • language (str) -- 返回结果的首选语言。两者都使用标准 RFC2616 接受语言字符串或简单的以逗号分隔的语言代码列表。

  • geometry (str) -- 如果存在，指定地理编码服务是否应在 wkt, svg, kml, 或 geojson 格式。这是通过 raw 返回的属性 geopy.location.Location 对象获得。

  • extratags (bool) -- 如果可用，在结果中包括其他信息，例如维基百科链接、开放时间。

  • country_codes (str or list) -- 将搜索结果限制到特定国家（或国家列表）。国家/地区代码应为ISO 3166-1alpha2代码，例如 gb 对于联合王国， de 对于德国等

  • viewbox (list or tuple of 2 items of geopy.point.Point or (latitude, longitude) or "%(latitude)s, %(longitude)s".) -- 我更喜欢这个区域来查找搜索结果。默认情况下，这被视为提示，如果要将结果限制在此区域，请指定 bounded=True 也是。示例： [Point(22, 180), Point(-22, -180)] 。

  • bounded (bool) -- 将结果限制为仅包含在边界内的项目 viewbox 。

  • featuretype (str) -- 如果存在，请将结果限制为特定类型的特征。允许值： country ， state ， city ， settlement .

  • namedetails (bool) -- 如果你想要 Location.raw 若要包含namedetails，请将其设置为True。这将是一个备选名称的列表，包括语言变体等。

返回类型:

None ， geopy.location.Location 或者他们的列表，如果 exactly_one=False .

reverse(query, *, exactly_one=True, timeout=DEFAULT_SENTINEL, language=False, addressdetails=True, zoom=None, namedetails=False)

按地点返回地址。

参数:

  • query (geopy.point.Point, list or tuple of (latitude, longitude), or string as "%(latitude)s, %(longitude)s".) -- 您希望获得最接近人类可读地址的坐标。

  • exactly_one (bool) -- 如果可用，返回一个结果或结果列表。

  • timeout (int) -- 等待地理编码服务响应的时间（秒），然后引发 geopy.exc.GeocoderTimedOut 例外。仅当您希望在这个调用上覆盖在地理编码程序初始化期间设置的值时，才设置这个值。

  • language (str) -- 返回结果的首选语言。两者都使用标准 RFC2616 接受语言字符串或简单的以逗号分隔的语言代码列表。

  • addressdetails (bool) -- 是否在* Location.raw 中包含地址详细信息，例如城市，县，州等

  • zoom (int) -- 地址所需的详细程度，整数范围为0（国家/地区级别）到18（建筑级别），默认值为18。

  • namedetails (bool) -- 如果你想加入的话 Location.raw 要包括名称详细信息，请将其设置为True。这将是可选名称的列表，包括语言变体等。添加的版本：：2.3

返回类型:

None ， geopy.location.Location 或者他们的列表，如果 exactly_one=False .

Nominatim

class geopy.geocoders.Nominatim(*, timeout=DEFAULT_SENTINEL, proxies=DEFAULT_SENTINEL, domain='nominatim.openstreetmap.org', scheme=None, user_agent=None, ssl_context=DEFAULT_SENTINEL, adapter_factory=None)

为openstreetmap数据指定地理编码。

文件地址：

https://nominatim.org/release-docs/develop/api/Overview/

注意

在默认情况下使用提名 user_agent 强烈建议不要这样做，因为它违反了nomingim的使用策略http s://operations.osmfoundation.org/policies/nomingim/，可能导致403和429 HTTP错误。请确保指定自定义 user_agent 具有 Nominatim(user_agent="my-application") 或者通过覆盖默认值 user_agent ： geopy.geocoders.options.default_user_agent = "my-application" . 如果自定义 user_agent 未指定。

__init__(*, timeout=DEFAULT_SENTINEL, proxies=DEFAULT_SENTINEL, domain='nominatim.openstreetmap.org', scheme=None, user_agent=None, ssl_context=DEFAULT_SENTINEL, adapter_factory=None)
参数:
geocode(query, *, exactly_one=True, timeout=DEFAULT_SENTINEL, limit=None, addressdetails=False, language=False, geometry=None, extratags=False, country_codes=None, viewbox=None, bounded=False, featuretype=None, namedetails=False)

按地址返回位置点。

参数:

  • query (dict or str) -- 您希望地理编码的地址、查询或结构化查询。其中一个键是结构化的字典，它提供以下一个查询： street ， city ， county ， state ， country 或 postalcode . 有关更多信息，请参阅Nomingim的文档 structured requests : https://nomintim.org/release-docs/develop/api/Search

  • exactly_one (bool) -- 如果可用，返回一个结果或结果列表。

  • timeout (int) -- 等待地理编码服务响应的时间（秒），然后引发 geopy.exc.GeocoderTimedOut 例外。仅当您希望在这个调用上覆盖在地理编码程序初始化期间设置的值时，才设置这个值。

  • limit (int) -- 从Nominatim返回的最大结果量。非 exact_one设置为 假，否则限制将始终为1。

  • addressdetails (bool) -- 如果你想加入的话 Location.raw 要包括地址详细信息，如HOUSE_NUMBER、CITY_SEARD、邮政编码等(以结构化形式)，请将其设置为True

  • language (str) -- 返回结果的首选语言。两者都使用标准 RFC2616 接受语言字符串或简单的以逗号分隔的语言代码列表。

  • geometry (str) -- 如果存在，指定地理编码服务是否应在 wkt, svg, kml, 或 geojson 格式。这是通过 raw 返回的属性 geopy.location.Location 对象获得。

  • extratags (bool) -- 如果可用，在结果中包括其他信息，例如维基百科链接、开放时间。

  • country_codes (str or list) -- 将搜索结果限制到特定国家（或国家列表）。国家/地区代码应为ISO 3166-1alpha2代码，例如 gb 对于联合王国， de 对于德国等

  • viewbox (list or tuple of 2 items of geopy.point.Point or (latitude, longitude) or "%(latitude)s, %(longitude)s".) -- 我更喜欢这个区域来查找搜索结果。默认情况下，这被视为提示，如果要将结果限制在此区域，请指定 bounded=True 也是。示例： [Point(22, 180), Point(-22, -180)] 。

  • bounded (bool) -- 将结果限制为仅包含在边界内的项目 viewbox 。

  • featuretype (str) -- 如果存在，请将结果限制为特定类型的特征。允许值： country ， state ， city ， settlement .

  • namedetails (bool) -- 如果你想要 Location.raw 若要包含namedetails，请将其设置为True。这将是一个备选名称的列表，包括语言变体等。

返回类型:

None ， geopy.location.Location 或者他们的列表，如果 exactly_one=False .

reverse(query, *, exactly_one=True, timeout=DEFAULT_SENTINEL, language=False, addressdetails=True, zoom=None, namedetails=False)

按地点返回地址。

参数:

  • query (geopy.point.Point, list or tuple of (latitude, longitude), or string as "%(latitude)s, %(longitude)s".) -- 您希望获得最接近人类可读地址的坐标。

  • exactly_one (bool) -- 如果可用，返回一个结果或结果列表。

  • timeout (int) -- 等待地理编码服务响应的时间（秒），然后引发 geopy.exc.GeocoderTimedOut 例外。仅当您希望在这个调用上覆盖在地理编码程序初始化期间设置的值时，才设置这个值。

  • language (str) -- 返回结果的首选语言。两者都使用标准 RFC2616 接受语言字符串或简单的以逗号分隔的语言代码列表。

  • addressdetails (bool) -- 是否在* Location.raw 中包含地址详细信息，例如城市，县，州等

  • zoom (int) -- 地址所需的详细程度，整数范围为0（国家/地区级别）到18（建筑级别），默认值为18。

  • namedetails (bool) -- 如果你想加入的话 Location.raw 要包括名称详细信息，请将其设置为True。这将是可选名称的列表，包括语言变体等。添加的版本：：2.3

返回类型:

None ， geopy.location.Location 或者他们的列表，如果 exactly_one=False .

Pelias

class geopy.geocoders.Pelias(domain, api_key=None, *, timeout=DEFAULT_SENTINEL, proxies=DEFAULT_SENTINEL, user_agent=None, scheme=None, ssl_context=DEFAULT_SENTINEL, adapter_factory=None)

Pelias 地理编码器.

文件地址：

https://github.com/pelias/documentation

另见 geopy.geocoders.GeocodeEarth 这是一个基于Pelias的服务，由Pelias本身的开发人员提供。

__init__(domain, api_key=None, *, timeout=DEFAULT_SENTINEL, proxies=DEFAULT_SENTINEL, user_agent=None, scheme=None, ssl_context=DEFAULT_SENTINEL, adapter_factory=None)
参数:
geocode(query, *, exactly_one=True, timeout=DEFAULT_SENTINEL, boundary_rect=None, countries=None, country_bias=None, language=None)

按地址返回位置点。

参数:

  • query (str) -- 要对其进行地理编码的地址或查询。

  • exactly_one (bool) -- 如果可用，返回一个结果或结果列表。

  • timeout (int) -- 等待地理编码服务响应的时间（秒），然后引发 geopy.exc.GeocoderTimedOut 例外。仅当您希望在这个调用上覆盖在地理编码程序初始化期间设置的值时，才设置这个值。

  • boundary_rect (list or tuple of 2 items of geopy.point.Point or (latitude, longitude) or "%(latitude)s, %(longitude)s".) -- 限制搜索的坐标。例如： [Point(22, 180), Point(-22, -180)] .

  • countries (list) -- 中指定的国家/地区代码列表 ISO 3166-1 alpha-2 or alpha-3 格式，例如 ['USA', 'CAN'] 。这是一个硬过滤器。。。添加的版本：：2.3

  • country_bias (str) -- 将结果偏向这个国家(ISO Alpha-3)。。。不推荐使用：：2.3 countries 取而代之的是。该选项的作用相同，也就是说，它不是顾名思义的软过滤器。此参数计划在Geopy 3.0中删除。

  • language (str) -- 返回结果的首选语言。两者都使用标准 RFC2616 接受语言字符串或简单的以逗号分隔的语言代码列表。

返回类型:

None ， geopy.location.Location 或者他们的列表，如果 exactly_one=False .

reverse(query, *, exactly_one=True, timeout=DEFAULT_SENTINEL, language=None)

按地点返回地址。

参数:

  • query (geopy.point.Point, list or tuple of (latitude, longitude), or string as "%(latitude)s, %(longitude)s".) -- 您希望获得最接近人类可读地址的坐标。

  • exactly_one (bool) -- 如果可用，返回一个结果或结果列表。

  • timeout (int) -- 等待地理编码服务响应的时间（秒），然后引发 geopy.exc.GeocoderTimedOut 例外。仅当您希望在这个调用上覆盖在地理编码程序初始化期间设置的值时，才设置这个值。

  • language (str) -- 返回结果的首选语言。两者都使用标准 RFC2616 接受语言字符串或简单的以逗号分隔的语言代码列表。

返回类型:

None ， geopy.location.Location 或者他们的列表，如果 exactly_one=False .

Photon

class geopy.geocoders.Photon(*, scheme=None, timeout=DEFAULT_SENTINEL, proxies=DEFAULT_SENTINEL, domain='photon.komoot.io', user_agent=None, ssl_context=DEFAULT_SENTINEL, adapter_factory=None)

使用光子地理编码服务的地理编码器(基于开放式StreetMap的数据和由https://photon.komoot.io).上的komoot提供的服务

文件地址：

https://github.com/komoot/photon

Photon / Komoot地理编码器旨在让您在使用OpenStreetMap进行搜索时进行搜索。 此平台不需要API密钥。

在 2.2 版本发生变更: 将默认域从 photon.komoot.de 至 photon.komoot.io 。

__init__(*, scheme=None, timeout=DEFAULT_SENTINEL, proxies=DEFAULT_SENTINEL, domain='photon.komoot.io', user_agent=None, ssl_context=DEFAULT_SENTINEL, adapter_factory=None)
参数:
geocode(query, *, exactly_one=True, timeout=DEFAULT_SENTINEL, location_bias=None, language=False, limit=None, osm_tag=None, bbox=None)

按地址返回位置点。

参数:

  • query (str) -- 要对其进行地理编码的地址或查询。

  • exactly_one (bool) -- 如果可用，返回一个结果或结果列表。

  • timeout (int) -- 等待地理编码服务响应的时间（秒），然后引发 geopy.exc.GeocoderTimedOut 例外。仅当您希望在这个调用上覆盖在地理编码程序初始化期间设置的值时，才设置这个值。

  • location_bias (geopy.point.Point, list or tuple of (latitude, longitude), or string as "%(latitude)s, %(longitude)s".) -- 用作位置偏移的坐标。

  • language (str) -- 返回结果的首选语言。

  • limit (int) -- 限制返回结果的数量，默认为无限制。

  • osm_tag (str or list or set) -- 按键和/或值筛选（包括/排除）的表达式，str为 'key:value' 如果需要多个过滤器，则列出/设置str ['key:!val', '!key', ':!value'] .

  • bbox (list or tuple of 2 items of geopy.point.Point or (latitude, longitude) or "%(latitude)s, %(longitude)s".) -- 要在其中进行偏移地理编码的视口边界框的结果更加突出。示例： [Point(22, 180), Point(-22, -180)] 。。。添加的版本：：2.2

返回类型:

None ， geopy.location.Location 或者他们的列表，如果 exactly_one=False .

reverse(query, *, exactly_one=True, timeout=DEFAULT_SENTINEL, language=False, limit=None)

按地点返回地址。

参数:

  • query (geopy.point.Point, list or tuple of (latitude, longitude), or string as "%(latitude)s, %(longitude)s".) -- 您希望获得最接近人类可读地址的坐标。

  • exactly_one (bool) -- 如果可用，返回一个结果或结果列表。

  • timeout (int) -- 等待地理编码服务响应的时间（秒），然后引发 geopy.exc.GeocoderTimedOut 例外。仅当您希望在这个调用上覆盖在地理编码程序初始化期间设置的值时，才设置这个值。

  • language (str) -- 返回结果的首选语言。

  • limit (int) -- 限制返回结果的数量，默认为无限制。

返回类型:

None ， geopy.location.Location 或者他们的列表，如果 exactly_one=False .

PickPoint

class geopy.geocoders.PickPoint(api_key, *, timeout=DEFAULT_SENTINEL, proxies=DEFAULT_SENTINEL, domain='api.pickpoint.io', scheme=None, user_agent=None, ssl_context=DEFAULT_SENTINEL, adapter_factory=None)

基类：Nominatim

Pickpoint geocoder是商业版的nominim。

文件地址：

https://pickpoint.io/api-reference

__init__(api_key, *, timeout=DEFAULT_SENTINEL, proxies=DEFAULT_SENTINEL, domain='api.pickpoint.io', scheme=None, user_agent=None, ssl_context=DEFAULT_SENTINEL, adapter_factory=None)
参数:
geocode(query, *, exactly_one=True, timeout=DEFAULT_SENTINEL, limit=None, addressdetails=False, language=False, geometry=None, extratags=False, country_codes=None, viewbox=None, bounded=False, featuretype=None, namedetails=False)

按地址返回位置点。

参数:

  • query (dict or str) -- 您希望地理编码的地址、查询或结构化查询。其中一个键是结构化的字典，它提供以下一个查询： street ， city ， county ， state ， country 或 postalcode . 有关更多信息，请参阅Nomingim的文档 structured requests : https://nomintim.org/release-docs/develop/api/Search

  • exactly_one (bool) -- 如果可用，返回一个结果或结果列表。

  • timeout (int) -- 等待地理编码服务响应的时间（秒），然后引发 geopy.exc.GeocoderTimedOut 例外。仅当您希望在这个调用上覆盖在地理编码程序初始化期间设置的值时，才设置这个值。

  • limit (int) -- 从Nominatim返回的最大结果量。非 exact_one设置为 假，否则限制将始终为1。

  • addressdetails (bool) -- 如果你想加入的话 Location.raw 要包括地址详细信息，如HOUSE_NUMBER、CITY_SEARD、邮政编码等(以结构化形式)，请将其设置为True

  • language (str) -- 返回结果的首选语言。两者都使用标准 RFC2616 接受语言字符串或简单的以逗号分隔的语言代码列表。

  • geometry (str) -- 如果存在，指定地理编码服务是否应在 wkt, svg, kml, 或 geojson 格式。这是通过 raw 返回的属性 geopy.location.Location 对象获得。

  • extratags (bool) -- 如果可用，在结果中包括其他信息，例如维基百科链接、开放时间。

  • country_codes (str or list) -- 将搜索结果限制到特定国家（或国家列表）。国家/地区代码应为ISO 3166-1alpha2代码，例如 gb 对于联合王国， de 对于德国等

  • viewbox (list or tuple of 2 items of geopy.point.Point or (latitude, longitude) or "%(latitude)s, %(longitude)s".) -- 我更喜欢这个区域来查找搜索结果。默认情况下，这被视为提示，如果要将结果限制在此区域，请指定 bounded=True 也是。示例： [Point(22, 180), Point(-22, -180)] 。

  • bounded (bool) -- 将结果限制为仅包含在边界内的项目 viewbox 。

  • featuretype (str) -- 如果存在，请将结果限制为特定类型的特征。允许值： country ， state ， city ， settlement .

  • namedetails (bool) -- 如果你想要 Location.raw 若要包含namedetails，请将其设置为True。这将是一个备选名称的列表，包括语言变体等。

返回类型:

None ， geopy.location.Location 或者他们的列表，如果 exactly_one=False .

reverse(query, *, exactly_one=True, timeout=DEFAULT_SENTINEL, language=False, addressdetails=True, zoom=None, namedetails=False)

按地点返回地址。

参数:

  • query (geopy.point.Point, list or tuple of (latitude, longitude), or string as "%(latitude)s, %(longitude)s".) -- 您希望获得最接近人类可读地址的坐标。

  • exactly_one (bool) -- 如果可用，返回一个结果或结果列表。

  • timeout (int) -- 等待地理编码服务响应的时间（秒），然后引发 geopy.exc.GeocoderTimedOut 例外。仅当您希望在这个调用上覆盖在地理编码程序初始化期间设置的值时，才设置这个值。

  • language (str) -- 返回结果的首选语言。两者都使用标准 RFC2616 接受语言字符串或简单的以逗号分隔的语言代码列表。

  • addressdetails (bool) -- 是否在* Location.raw 中包含地址详细信息，例如城市，县，州等

  • zoom (int) -- 地址所需的详细程度，整数范围为0（国家/地区级别）到18（建筑级别），默认值为18。

  • namedetails (bool) -- 如果你想加入的话 Location.raw 要包括名称详细信息，请将其设置为True。这将是可选名称的列表，包括语言变体等。添加的版本：：2.3

返回类型:

None ， geopy.location.Location 或者他们的列表，如果 exactly_one=False .

LiveAddress

class geopy.geocoders.LiveAddress(auth_id, auth_token, *, timeout=DEFAULT_SENTINEL, proxies=DEFAULT_SENTINEL, user_agent=None, ssl_context=DEFAULT_SENTINEL, adapter_factory=None)

使用SmartSystems提供的LiveAddress API进行地理编码。

文件地址：

https://smartystreets.com/docs/cloud/us-street-api

__init__(auth_id, auth_token, *, timeout=DEFAULT_SENTINEL, proxies=DEFAULT_SENTINEL, user_agent=None, ssl_context=DEFAULT_SENTINEL, adapter_factory=None)
参数:
geocode(query, *, exactly_one=True, timeout=DEFAULT_SENTINEL, candidates=1)

按地址返回位置点。

参数:

  • query (str) -- 要对其进行地理编码的地址或查询。

  • exactly_one (bool) -- 如果可用，返回一个结果或结果列表。

  • timeout (int) -- 等待地理编码服务响应的时间（秒），然后引发 geopy.exc.GeocoderTimedOut 例外。仅当您希望在这个调用上覆盖在地理编码程序初始化期间设置的值时，才设置这个值。

  • candidates (int) -- 一个介于1和10之间的整数，表示如果找到有效地址，将返回的候选地址的最大数目。

返回类型:

None ， geopy.location.Location 或者他们的列表，如果 exactly_one=False .

TomTom

class geopy.geocoders.TomTom(api_key, *, scheme=None, timeout=DEFAULT_SENTINEL, proxies=DEFAULT_SENTINEL, user_agent=None, ssl_context=DEFAULT_SENTINEL, adapter_factory=None, domain='api.tomtom.com')

TomTom地理编码。

文件地址：

https://developer.tomtom.com/search-api/search-api-documentation

__init__(api_key, *, scheme=None, timeout=DEFAULT_SENTINEL, proxies=DEFAULT_SENTINEL, user_agent=None, ssl_context=DEFAULT_SENTINEL, adapter_factory=None, domain='api.tomtom.com')
参数:
geocode(query, *, exactly_one=True, timeout=DEFAULT_SENTINEL, limit=None, typeahead=False, language=None)

按地址返回位置点。

参数:

  • query (str) -- 要对其进行地理编码的地址或查询。

  • exactly_one (bool) -- 如果可用，返回一个结果或结果列表。

  • timeout (int) -- 等待地理编码服务响应的时间（秒），然后引发 geopy.exc.GeocoderTimedOut 例外。仅当您希望在这个调用上覆盖在地理编码程序初始化期间设置的值时，才设置这个值。

  • limit (int) -- 要从服务返回的最大结果量。除非exact_one设置为False，否则限制将始终为1。

  • typeahead (bool) -- 如果设置了“typeahead”标志，查询将被解释为部分输入，搜索将进入预测模式。

  • language (str) -- 应返回搜索结果的语言。 如果指定语言的数据不适用于特定字段，则使用默认语言。 支持的语言列表（不区分大小写）:https://developer.tomtom.com/online-search/online-search-documentation/supported-languages

返回类型:

None ， geopy.location.Location 或者他们的列表，如果 exactly_one=False .

reverse(query, *, exactly_one=True, timeout=DEFAULT_SENTINEL, language=None)

按地点返回地址。

参数:

  • query (geopy.point.Point, list or tuple of (latitude, longitude), or string as "%(latitude)s, %(longitude)s".) -- 您希望获得最接近人类可读地址的坐标。

  • exactly_one (bool) -- 如果可用，返回一个结果或结果列表。

  • timeout (int) -- 等待地理编码服务响应的时间（秒），然后引发 geopy.exc.GeocoderTimedOut 例外。仅当您希望在这个调用上覆盖在地理编码程序初始化期间设置的值时，才设置这个值。

  • language (str) -- 应返回搜索结果的语言。 如果指定语言的数据不适用于特定字段，则使用默认语言。 支持的语言列表（不区分大小写）:https://developer.tomtom.com/online-search/online-search-documentation/supported-languages

返回类型:

None ， geopy.location.Location 或者他们的列表，如果 exactly_one=False .

What3Words

class geopy.geocoders.What3Words(api_key, *, timeout=DEFAULT_SENTINEL, proxies=DEFAULT_SENTINEL, user_agent=None, ssl_context=DEFAULT_SENTINEL, adapter_factory=None, domain='api.what3words.com')

What3word使用遗留的V2API的地理编码器。

文件地址：

https://docs.what3words.com/api/v2/

注意

考虑使用 What3WordsV3 取而代之的是。

__init__(api_key, *, timeout=DEFAULT_SENTINEL, proxies=DEFAULT_SENTINEL, user_agent=None, ssl_context=DEFAULT_SENTINEL, adapter_factory=None, domain='api.what3words.com')
参数:
geocode(query, *, lang='en', exactly_one=True, timeout=DEFAULT_SENTINEL)

返回 3 words 查询。如果 3 words 地址不存在，a geopy.exc.GeocoderQueryError 将引发异常。

参数:

  • query (str) -- 您希望地理编码的3字地址。

  • lang (str) -- 接口支持的双字符语言代码(https://docs.what3words.com/api/v2/#lang).

  • exactly_one (bool) -- 如果可用，返回一个结果或结果列表。由于地址方案的原因，每个结果始终只有一个 3 words 地址，所以这个参数对于这个地理编码程序是相当无用的。

  • timeout (int) -- 等待地理编码服务响应的时间（秒），然后引发 geopy.exc.GeocoderTimedOut 例外。仅当您希望在这个调用上覆盖在地理编码程序初始化期间设置的值时，才设置这个值。

返回类型:

如果 exactly_one=False geopy.location.Location 或者他们的清单 .

reverse(query, *, lang='en', exactly_one=True, timeout=DEFAULT_SENTINEL)

按位置点返回 3 words 地址。表面上的每个点都有一个 3 words 地址，所以总是有一个非空的响应。

参数:

  • query (geopy.point.Point, list or tuple of (latitude, longitude), or string as "%(latitude)s, %(longitude)s".) -- 要获得3个字地址的坐标。

  • lang (str) -- 接口支持的双字符语言代码(https://docs.what3words.com/api/v2/#lang).

  • exactly_one (bool) -- 如果可用，返回一个结果或结果列表。由于地址方案的原因，每个结果始终只有一个 3 words 地址，所以这个参数对于这个地理编码程序是相当无用的。

  • timeout (int) -- 等待地理编码服务响应的时间（秒），然后引发 geopy.exc.GeocoderTimedOut 例外。仅当您希望在这个调用上覆盖在地理编码程序初始化期间设置的值时，才设置这个值。

返回类型:

如果 exactly_one=False geopy.location.Location 或者他们的清单 .

What 3WordsV3

class geopy.geocoders.What3WordsV3(api_key, *, timeout=DEFAULT_SENTINEL, proxies=DEFAULT_SENTINEL, user_agent=None, ssl_context=DEFAULT_SENTINEL, adapter_factory=None, domain='api.what3words.com')

What3word使用V3API的地理编码器。

文件地址：

https://developer.what3words.com/public-api/docs

在 2.2 版本加入.

__init__(api_key, *, timeout=DEFAULT_SENTINEL, proxies=DEFAULT_SENTINEL, user_agent=None, ssl_context=DEFAULT_SENTINEL, adapter_factory=None, domain='api.what3words.com')
参数:
geocode(query, *, exactly_one=True, timeout=DEFAULT_SENTINEL)

返回 3 words 查询。如果 3 words 地址不存在，a geopy.exc.GeocoderQueryError 将引发异常。

参数:

  • query (str) -- 您希望地理编码的3字地址。

  • exactly_one (bool) -- 如果可用，返回一个结果或结果列表。由于地址方案的原因，每个结果始终只有一个 3 words 地址，所以这个参数对于这个地理编码程序是相当无用的。

  • timeout (int) -- 等待地理编码服务响应的时间（秒），然后引发 geopy.exc.GeocoderTimedOut 例外。仅当您希望在这个调用上覆盖在地理编码程序初始化期间设置的值时，才设置这个值。

返回类型:

如果 exactly_one=False geopy.location.Location 或者他们的清单 .

reverse(query, *, lang='en', exactly_one=True, timeout=DEFAULT_SENTINEL)

按位置点返回 3 words 地址。表面上的每个点都有一个 3 words 地址，所以总是有一个非空的响应。

参数:

  • query (geopy.point.Point, list or tuple of (latitude, longitude), or string as "%(latitude)s, %(longitude)s".) -- 要获得3个字地址的坐标。

  • lang (str) -- (https://developer.what3words.com/public-api/docs#available-languages).接口支持的双字符语言代码

  • exactly_one (bool) -- 如果可用，返回一个结果或结果列表。由于地址方案的原因，每个结果始终只有一个 3 words 地址，所以这个参数对于这个地理编码程序是相当无用的。

  • timeout (int) -- 等待地理编码服务响应的时间（秒），然后引发 geopy.exc.GeocoderTimedOut 例外。仅当您希望在这个调用上覆盖在地理编码程序初始化期间设置的值时，才设置这个值。

返回类型:

如果 exactly_one=False geopy.location.Location 或者他们的清单 .

Woosmap

class geopy.geocoders.Woosmap(api_key, *, domain='api.woosmap.com', scheme=None, timeout=DEFAULT_SENTINEL, proxies=DEFAULT_SENTINEL, user_agent=None, ssl_context=DEFAULT_SENTINEL, adapter_factory=None)

使用Woosmap地址API的地理编码器。

文件地址：

https://developers.woosmap.com/products/address-api/geocode/

在 2.4 版本加入.

__init__(api_key, *, domain='api.woosmap.com', scheme=None, timeout=DEFAULT_SENTINEL, proxies=DEFAULT_SENTINEL, user_agent=None, ssl_context=DEFAULT_SENTINEL, adapter_factory=None)
参数:
geocode(query, *, limit=None, exactly_one=True, timeout=DEFAULT_SENTINEL, location=None, components=None, language=None, country_code_format=None)

按地址返回位置点。

参数:

  • query (str) -- 要对其进行地理编码的地址。

  • limit (int) -- 要返回的最大结果数。如果满足以下条件，则该值将重置为1 exactly_one 是真的。

  • exactly_one (bool) -- 如果可用，返回一个结果或结果列表。

  • timeout (int) -- 等待地理编码服务响应的时间（秒），然后引发 geopy.exc.GeocoderTimedOut 例外。仅当您希望在这个调用上覆盖在地理编码程序初始化期间设置的值时，才设置这个值。

  • location (geopy.point.Point, list or tuple of (latitude, longitude), or string as "%(latitude)s, %(longitude)s".) -- 中心延迟以偏向搜索上下文。

  • components (dict or list) -- 您希望将结果限制在哪些地理位置。目前，您可以使用组件过滤国家/地区。国家/地区由两个字符ISO 3166-1 Alpha-2或三个字符ISO 3166-1 Alpha-3兼容的国家/地区代码标识。如果要指定同一类型的多个组件，则传递一个元组列表，例如：> [('country', 'FRA'), ('country', 'DE')]

  • language (str) -- 返回结果所使用的语言。必须是ISO 639-1语言代码。

  • country_code_format (str) -- 回复中的默认国家/地区代码格式为Alpha3。但是，可以通过在alpha2中指定组件来更改响应中的格式。可用格式： alpha2 ， alpha3 。

返回类型:

None ， geopy.location.Location 或者他们的列表，如果 exactly_one=False .

reverse(query, *, limit=None, exactly_one=True, timeout=DEFAULT_SENTINEL, language=None, country_code_format=None)

按地点返回地址。

参数:

  • query (geopy.point.Point, list or tuple of (latitude, longitude), or string as "%(latitude)s, %(longitude)s".) -- 您希望获得最接近人类可读地址的坐标。

  • limit (int) -- 要返回的最大结果数。如果满足以下条件，则该值将重置为1 exactly_one 是真的。

  • exactly_one (bool) -- 如果可用，返回一个结果或结果列表。

  • timeout (int) -- 等待地理编码服务响应的时间（秒），然后引发 geopy.exc.GeocoderTimedOut 例外。仅当您希望在这个调用上覆盖在地理编码程序初始化期间设置的值时，才设置这个值。

  • language (str) -- 返回结果的语言。

  • country_code_format (str) -- 回复中的默认国家/地区代码格式为Alpha3。但是，可以通过在alpha2中指定组件来更改响应中的格式。可用格式： alpha2 ， alpha3 。

返回类型:

None ， geopy.location.Location 或者他们的列表，如果 exactly_one=False .

Yandex

class geopy.geocoders.Yandex(api_key, *, timeout=DEFAULT_SENTINEL, proxies=DEFAULT_SENTINEL, user_agent=None, scheme=None, ssl_context=DEFAULT_SENTINEL, adapter_factory=None, domain='geocode-maps.yandex.ru')

Yandex地理编码。

文件地址：

https://tech.yandex.com/maps/doc/geocoder/desc/concepts/input_params-docpage/

__init__(api_key, *, timeout=DEFAULT_SENTINEL, proxies=DEFAULT_SENTINEL, user_agent=None, scheme=None, ssl_context=DEFAULT_SENTINEL, adapter_factory=None, domain='geocode-maps.yandex.ru')
参数:
geocode(query, *, exactly_one=True, timeout=DEFAULT_SENTINEL, lang=None)

按地址返回位置点。

参数:

  • query (str) -- 要对其进行地理编码的地址或查询。

  • exactly_one (bool) -- 如果可用，返回一个结果或结果列表。

  • timeout (int) -- 等待地理编码服务响应的时间（秒），然后引发 geopy.exc.GeocoderTimedOut 例外。仅当您希望在这个调用上覆盖在地理编码程序初始化期间设置的值时，才设置这个值。

  • lang (str) -- 响应的语言和地图的区域设置。支持值列表：- tr_TR --土耳其语（仅适用于土耳其地图）- en_RU --英语、俄语地图特点- en_US --英语、美式地图特点- ru_RU --俄语（默认）- uk_UA --乌克兰语- be_BY --白俄罗斯人。

返回类型:

None ， geopy.location.Location 或者他们的列表，如果 exactly_one=False .

reverse(query, *, exactly_one=True, timeout=DEFAULT_SENTINEL, kind=None, lang=None)

按地点返回地址。

参数:

  • query (geopy.point.Point, list or tuple of (latitude, longitude), or string as "%(latitude)s, %(longitude)s".) -- 您希望获得最接近人类可读地址的坐标。

  • exactly_one (bool) -- 如果可用，返回一个结果或结果列表。

  • timeout (int) -- 等待地理编码服务响应的时间（秒），然后引发 geopy.exc.GeocoderTimedOut 例外。仅当您希望在这个调用上覆盖在地理编码程序初始化期间设置的值时，才设置这个值。

  • kind (str) -- 地名类型。允许值： house, street, metro, district, locality.

  • lang (str) -- 响应的语言和地图的区域设置。支持值列表：- tr_TR --土耳其语（仅适用于土耳其地图）- en_RU --英语、俄语地图特点- en_US --英语、美式地图特点- ru_RU --俄语（默认）- uk_UA --乌克兰语- be_BY --白俄罗斯人。

返回类型:

None ， geopy.location.Location 或者他们的列表，如果 exactly_one=False .

计算距离

Geopy可以用 geodesic distance 或 great-circle distance ，默认测地线距离作为函数 geopy.distance.distance .

大圆距离（ great_circle ）使用地球的球形模型，使用国际大地测量学和地球物理学联合会定义的平均地球半径，（2）a + b) /3=6371.0087714150598公里，约6371.009公里（WGS-84），误差高达0.5%。半径值存储在 distance.EARTH_RADIUS ，因此可以对其进行自定义（但是，它应该始终以公里为单位）。

The geodesic distance is the shortest distance on the surface of an ellipsoidal model of the earth. The default algorithm uses the method is given by Karney (2013) (geodesic); this is accurate to round-off and always converges.

geopy.distance.distance 目前使用 geodesic .

有许多流行的椭球体模型，哪一个模型最精确取决于你的点在地球上的位置。默认值是WGS-84椭球体，它是全局最精确的。geopy还包括 distance.ELLIPSOIDS 字典：

              model             major (km)   minor (km)     flattening
ELLIPSOIDS = {'WGS-84':        (6378.137,    6356.7523142,  1 / 298.257223563),
              'GRS-80':        (6378.137,    6356.7523141,  1 / 298.257222101),
              'Airy (1830)':   (6377.563396, 6356.256909,   1 / 299.3249646),
              'Intl 1924':     (6378.388,    6356.911946,   1 / 297.0),
              'Clarke (1880)': (6378.249145, 6356.51486955, 1 / 293.465),
              'GRS-67':        (6378.1600,   6356.774719,   1 / 298.25),
              }

以下是以下示例 distance.distance 用法，取对 (lat, lon) 元组：：

>>> from geopy import distance
>>> newport_ri = (41.49008, -71.312796)
>>> cleveland_oh = (41.499498, -81.695391)
>>> print(distance.distance(newport_ri, cleveland_oh).miles)
538.39044536

>>> wellington = (-41.32, 174.81)
>>> salamanca = (40.96, -5.50)
>>> print(distance.distance(wellington, salamanca).km)
19959.6792674

使用 great_circle 距离：

>>> print(distance.great_circle(newport_ri, cleveland_oh).miles)
536.997990696

您可以更改测地公式使用的椭球体模型，如下所示：

>>> ne, cl = newport_ri, cleveland_oh
>>> print(distance.geodesic(ne, cl, ellipsoid='GRS-80').miles)

上述型号名称将自动从 distance.ELLIPSOIDS 字典。或者，可以直接指定模型值：

>>> distance.geodesic(ne, cl, ellipsoid=(6377., 6356., 1 / 297.)).miles

距离支持简单的算法，使计算路径长度等操作变得容易：

>>> from geopy import Nominatim
>>> d = distance.distance
>>> g = Nominatim(user_agent="specify_your_app_name_here")
>>> _, wa = g.geocode('Washington, DC')
>>> _, pa = g.geocode('Palo Alto, CA')
>>> print((d(ne, cl) + d(cl, wa) + d(wa, pa)).miles)
3277.30439191

目前所有的算法都假设点的高度要么为零（如上面的例子中所示）要么相等，并且相对较小。因此，海拔高度不会影响结果距离：

>>> from geopy import distance
>>> newport_ri = (41.49008, -71.312796)
>>> cleveland_oh = (41.499498, -81.695391)
>>> print(distance.distance(newport_ri, cleveland_oh).km)
866.4554329098687
>>> newport_ri = (41.49008, -71.312796, 100)
>>> cleveland_oh = (41.499498, -81.695391, 100)
>>> print(distance.distance(newport_ri, cleveland_oh).km)
866.4554329098687

如果需要使用高程计算距离，则对于短距离 Euclidean distance 公式可以给出一个合适的近似值：

>>> import math
>>> from geopy import distance
>>> p1 = (43.668613, 40.258916, 0.976)
>>> p2 = (43.658852, 40.250839, 1.475)
>>> flat_distance = distance.distance(p1[:2], p2[:2]).km
>>> print(flat_distance)
1.265133525952866
>>> euclidian_distance = math.sqrt(flat_distance**2 + (p2[2] - p1[2])**2)
>>> print(euclidian_distance)
1.359986705262199

尝试计算具有不同高度的点之间的距离将导致 ValueError 例外情况。

geopy.distance.lonlat(x, y, z=0)

geopy.distance.distance 接受坐标 (y, x) / (lat, lon) 顺序，而其他一些库和系统可能会使用 (x, y) / (lon, lat) .

此函数提供了一种方便的方法来转换 (x, y) / (lon, lat) 格式转换为 geopy.point.Point 实例。

例子：：

>>> from geopy.distance import lonlat, distance
>>> newport_ri_xy = (-71.312796, 41.49008)
>>> cleveland_oh_xy = (-81.695391, 41.499498)
>>> print(distance(lonlat(*newport_ri_xy), lonlat(*cleveland_oh_xy)).miles)
538.3904453677203
参数:

  • x -- 经度

  • y -- 纬度

  • z -- （可选）高度

返回:

点（纬度、经度、海拔）

class geopy.distance.Distance(*args, **kwargs)

其他距离算法的基类。表示距离。

可用于单位转换：：

>>> from geopy.distance import Distance
>>> Distance(miles=10).km
16.09344

距离实例具有全部 距离 来自以下位置的特性 geopy.units ，例如： km ， m ， meters ， miles 诸若此类。

距离实例是不可变的。

它们支持比较：

>>> from geopy.distance import Distance
>>> Distance(kilometers=2) == Distance(meters=2000)
True
>>> Distance(kilometers=2) > Distance(miles=1)
True

字符串表示形式：：

>>> from geopy.distance import Distance
>>> repr(Distance(kilometers=2))
'Distance(2.0)'
>>> str(Distance(kilometers=2))
'2.0 km'
>>> repr(Distance(miles=2))
'Distance(3.218688)'
>>> str(Distance(miles=2))
'3.218688 km'

算术：：

>>> from geopy.distance import Distance
>>> -Distance(miles=2)
Distance(-3.218688)
>>> Distance(miles=2) + Distance(kilometers=1)
Distance(4.218688)
>>> Distance(miles=2) - Distance(kilometers=1)
Distance(2.218688)
>>> Distance(kilometers=6) * 5
Distance(30.0)
>>> Distance(kilometers=6) / 5
Distance(1.2)
__init__(*args, **kwargs)

有3种方法可以创建距离：

  • 出发地公里：：

    >>> from geopy.distance import Distance
>>> Distance(1.42)
Distance(1.42)

  • 自单位：

    >>> from geopy.distance import Distance
>>> Distance(kilometers=1.42)
Distance(1.42)
>>> Distance(miles=1)
Distance(1.609344)

  • 起点(仅适用于非抽象距离)，计算为所有点之间的距离之和：

    >>> from geopy.distance import geodesic
>>> geodesic((40, 160), (40.1, 160.1))
Distance(14.003702498106215)
>>> geodesic((40, 160), (40.1, 160.1), (40.2, 160.2))
Distance(27.999954644813478)
destination(point, bearing, distance=None)

使用起点、方向角和距离计算目标点。此方法仅适用于非抽象距离。

例子：以东10英里处的一个点 (34, 148) ：：

>>> import geopy.distance
>>> geopy.distance.distance(miles=10).destination((34, 148), bearing=90)
Point(33.99987666492774, 148.17419994321995, 0.0)
参数:

  • point (geopy.point.Point, list or tuple of (latitude, longitude), or string as "%(latitude)s, %(longitude)s".) -- 起点。

  • bearing (float) -- 方位角(度)：0--北，90--东，180--南，270或-90--西。

  • distance (Distance) -- 距离，可用于覆盖此实例：：>距地理副本。距离导入距离，距离>距离(英里=10)。目的地((34,149.08238904409637)，方位角=90，距离=距离(33.995238229104764))

返回类型:

geopy.point.Point

class geopy.distance.geodesic(*args, **kwargs)

基类：Distance

计算点之间的测地线距离。

通过指定 ellipsoid 关键字参数。默认值是“WGS-84”，它是最全局精确的模型。如果 ellipsoid 是一个字符串，它在 ELLIPSOIDS 字典获得大、小半轴和展平。否则，它应该是具有这些值的元组。请参见上面的注释 ELLIPSOIDS 字典了解更多信息。

例子：：

>>> from geopy.distance import geodesic
>>> newport_ri = (41.49008, -71.312796)
>>> cleveland_oh = (41.499498, -81.695391)
>>> print(geodesic(newport_ri, cleveland_oh).miles)
538.390445368
class geopy.distance.great_circle(*args, **kwargs)

基类：Distance

使用球面几何图形计算点之间的曲面距离。

通过指定 radius 关键字参数来设置要使用的地球半径。必须以公里为单位。默认值是使用模块常量 EARTH_RADIUS, 它使用平均大圆半径。

例子：：

>>> from geopy.distance import great_circle
>>> newport_ri = (41.49008, -71.312796)
>>> cleveland_oh = (41.499498, -81.695391)
>>> print(great_circle(newport_ri, cleveland_oh).miles)
536.997990696

数据

class geopy.location.Location(address, point, raw)

包含已分析的地理编码程序响应。可以迭代为 (location<String>, (latitude<float>, longitude<Float)) . 或者可以访问属性 address ， latitude ， longitude 或 raw . 最后是一个关于该项目的地理编码响应的字典。

property address

地理编码程序返回的格式化字符串或由Geopy构造的位置，具体取决于服务。

返回类型:

str

property altitude

位置的高度。

备注

地理编码服务通常在请求和响应中都不考虑海拔高度，所以这个属性的值几乎总是为零。

返回类型:

float

property latitude

位置的纬度。

返回类型:

float

property longitude

位置的经度。

返回类型:

float

property point

geopy.point.Point 表示位置的纬度、经度和高度的实例。

返回类型:

geopy.point.Point

property raw

位置的原始、未分析的地理编码响应。有关详细信息，请参阅服务的文档。

返回类型:

dict

class geopy.point.Point(latitude=None, longitude=None, altitude=None)

具有纬度、经度和高度的大地测量点。

纬度和经度是以度为单位的浮点值。高度是以公里为单位的浮点值。参考水平从未被考虑过，因此依赖于应用程序，所以要一致！所有值的默认值为0。

可以通过多种方式创建点…

纬度、经度和高度：

>>> p1 = Point(41.5, -81, 0)
>>> p2 = Point(latitude=41.5, longitude=-81)

以2到3个值（纬度、经度、海拔）为顺序：

>>> p1 = Point([41.5, -81, 0])
>>> p2 = Point((41.5, -81))

复制另一个`Point`实例:

>>> p2 = Point(p1)
>>> p2 == p1
True
>>> p2 is p1
False

给出至少包含纬度和经度的字符串：

>>> p = Point('41.5,-81.0')
>>> p = Point('+41.5 -81.0')
>>> p = Point('41.5 N -81.0 W')
>>> p = Point('-41.5 S, 81.0 E, 2.5km')
>>> p = Point('23 26m 22s N 23 27m 30s E 21.0mi')
>>> p = Point('''3 26' 22" N 23 27' 30" E''')

点值可以通过名称或索引访问：

>>> p = Point(41.5, -81.0, 0)
>>> p.latitude == p[0]
True
>>> p.longitude == p[1]
True
>>> p.altitude == p[2]
True

解包（或迭代）时，返回一个 (latitude, longitude, altitude) 元组：：

>>> latitude, longitude, altitude = p

文本表示：

>>> p = Point(41.5, -81.0, 12.3)
>>> str(p)  # same as `p.format()`
'41 30m 0s N, 81 0m 0s W, 12.3km'
>>> p.format_unicode()
'41° 30′ 0″ N, 81° 0′ 0″ W, 12.3km'
>>> repr(p)
'Point(41.5, -81.0, 12.3)'
>>> repr(tuple(p))
'(41.5, -81.0, 12.3)'
static __new__(cls, latitude=None, longitude=None, altitude=None)
参数:

  • latitude (float) -- 点的纬度。

  • longitude (float) -- 点的经度。

  • altitude (float) -- 点的高度。

format(altitude=None, deg_char='', min_char='m', sec_char='s')

将十进制度数（DD）格式设置为度分秒（DMS）：：

>>> p = Point(41.5, -81.0, 12.3)
>>> p.format()
'41 30m 0s N, 81 0m 0s W, 12.3km'
>>> p = Point(41.5, 0, 0)
>>> p.format()
'41 30m 0s N, 0 0m 0s E'

也见 format_unicode() .

参数:

altitude (bool) -- 是否包括 altitude 价值观。默认情况下，如果非零值，则自动包含该值。

format_altitude(unit='km')

高度单位格式：

>>> p = Point(41.5, -81.0, 12.3)
>>> p.format_altitude()
'12.3km'
>>> p = Point(41.5, -81.0, 0)
>>> p.format_altitude()
'0.0km'
参数:

unit (str) -- 生成的高度单位。支持的单位 from_string() 博士。

format_decimal(altitude=None)

设置带高度的十进制度数格式：

>>> p = Point(41.5, -81.0, 12.3)
>>> p.format_decimal()
'41.5, -81.0, 12.3km'
>>> p = Point(41.5, 0, 0)
>>> p.format_decimal()
'41.5, 0.0'
参数:

altitude (bool) -- 是否包括 altitude 价值观。默认情况下，如果非零值，则自动包含该值。

format_unicode(altitude=None)

format() 用漂亮的unicode字符表示度、分和秒：

>>> p = Point(41.5, -81.0, 12.3)
>>> p.format_unicode()
'41° 30′ 0″ N, 81° 0′ 0″ W, 12.3km'
参数:

altitude (bool) -- 是否包括 altitude 价值观。默认情况下，如果非零值，则自动包含该值。

classmethod from_point(point)

创建并返回新的 Point 从另一个实例 Point 实例。

classmethod from_sequence(seq)

创建并返回新的 Point 从任何包含2到3个元素的iterable实例。元素（如果存在）必须分别是纬度、经度和海拔。

classmethod from_string(string)

从包含纬度和经度以及可选高度的字符串中引用创建并返回 Point 。

纬度和经度必须以度为单位，可以是十进制形式，也可以表示弧分和弧秒（用Unicode Prime和Double Prime、ASCII Quote和Double Quote或'M'和'S'标记）。度数符号是可选的，可以在小数点后（以十进制形式）和arcminutes和arseconds之前包含。从南部和西部给出的坐标（用S和W后缀表示）将通过转换其符号转换为北和东。如果没有给出（或部分）基本方向，则假定方向为北和东。纬度和经度必须至少用空格、逗号或分号分隔（每个空格周围都有可选的空格）。

高度，如果提供，必须是带给定单位的十进制数字。支持以下单元缩写（不区分大小写）：

  • km （公里）

  • m （米）

  • mi （英里）

  • ft （脚）

  • nm ， nmi （海里）

一些可用的示例字符串包括：

  • 41.5;-81.0

  • 41.5,-81.0

  • 41.5 -81.0

  • 41.5 N -81.0 W

  • -41.5 S;81.0 E

  • 23 26m 22s N 23 27m 30s E

  • 23 26' 22" N 23 27' 30" E

  • UT: N 39°20' 0'' / W 74°35' 0''

classmethod parse_altitude(distance, unit)

解析高度管理单位转换：

>>> Point.parse_altitude(712, 'm')
0.712
>>> Point.parse_altitude(712, 'km')
712.0
>>> Point.parse_altitude(712, 'mi')
1145.852928
参数:

  • distance (float) -- 高度的数值。

  • unit (str) -- distance 单位。支持的单位 from_string() 博士。

classmethod parse_degrees(degrees, arcminutes, arcseconds, direction=None)

将度、分、秒和方向（N、S、E、W）转换为单个度数。

返回类型:

float

class geopy.timezone.Timezone(pytz_timezone, raw)

包含时区请求的解析响应，该响应在提供此类查找的少数地理代码中实现。

property pytz_timezone

pytz时区实例。

返回类型:

pytz.tzinfo.BaseTzInfo

property raw

时区的原始、未分析的地理编码响应。有关详细信息，请参阅服务的文档。

返回类型:

dict

单位换算

geopy.units 模块提供用于执行角度和距离单位转换的实用功能。

为了方便起见，我们提供了一些简短的别名（例如。 km() 是一个别名 kilometers() ）

geopy.units.arcmin(degrees=0, radians=0, arcseconds=0)

将角度转换为弧分。

geopy.units.arcminutes(degrees=0, radians=0, arcseconds=0)

将角度转换为弧分。

geopy.units.arcsec(degrees=0, radians=0, arcminutes=0)

将角度转换为弧秒。

geopy.units.arcseconds(degrees=0, radians=0, arcminutes=0)

将角度转换为弧秒。

geopy.units.degrees(radians=0, arcminutes=0, arcseconds=0)

将角度转换为度。

geopy.units.feet(kilometers=0, meters=0, miles=0, nautical=0)

将距离转换为英尺。

geopy.units.ft(kilometers=0, meters=0, miles=0, nautical=0)

将距离转换为英尺。

geopy.units.kilometers(meters=0, miles=0, feet=0, nautical=0)

将距离转换为公里。

geopy.units.km(meters=0, miles=0, feet=0, nautical=0)

将距离转换为公里。

geopy.units.m(kilometers=0, miles=0, feet=0, nautical=0)

将距离转换为米。

geopy.units.meters(kilometers=0, miles=0, feet=0, nautical=0)

将距离转换为米。

geopy.units.mi(kilometers=0, meters=0, feet=0, nautical=0)

将距离转换为英里。

geopy.units.miles(kilometers=0, meters=0, feet=0, nautical=0)

将距离转换为英里。

geopy.units.nautical(kilometers=0, meters=0, miles=0, feet=0)

把距离换算成海里。

geopy.units.nm(kilometers=0, meters=0, miles=0, feet=0)

把距离换算成海里。

geopy.units.rad(degrees=0, arcminutes=0, arcseconds=0)

将角度转换为弧度。

geopy.units.radians(degrees=0, arcminutes=0, arcseconds=0)

将角度转换为弧度。

例外情况

class geopy.exc.GeopyError

基类：Exception

特定于Geopy的异常都是从GeopyError继承而来的。

class geopy.exc.ConfigurationError

基类：GeopyError, ValueError

在实例化地理编码程序时，给出的参数无效。请参阅每个地理编码器的文档 __init__ 了解更多详细信息。

class geopy.exc.GeocoderServiceError

基类：GeopyError

调用远程地理编码服务时发生异常，地理信息不能再引发更具体的异常。调用geocoder的 geocode 或 reverse 方法时，这是可以引发的最通用的异常，任何非geopy异常都将被捕获并转换为该异常。异常的消息将是原始异常的消息。

class geopy.exc.GeocoderQueryError

基类：GeocoderServiceError, ValueError

Geopy检测到可能导致请求失败的输入，或者发出了请求，远程地理编码服务响应该请求是错误的。

class geopy.exc.GeocoderQuotaExceeded

基类：GeocoderServiceError

远程地理编码服务拒绝完成请求，因为客户端已使用其配额。

class geopy.exc.GeocoderRateLimited(message, *, retry_after=None)

基类：GeocoderQuotaExceeded, OSError

远程地理编码服务对该请求进行了速率限制。稍后重试可能会有所帮助。

此类型的异常具有 retry_after 属性，该属性包含服务要求等待的时间量(以秒为单位)。可能是 None 如果没有这样的数据作为回应。

在 2.2 版本加入.

class geopy.exc.GeocoderAuthenticationFailure

基类：GeocoderServiceError

远程地理编码服务拒绝使用此地理编码程序实例化的API密钥或帐户凭据。

class geopy.exc.GeocoderInsufficientPrivileges

基类：GeocoderServiceError

远程地理编码服务拒绝使用给定的帐户凭据完成请求。

class geopy.exc.GeocoderTimedOut

基类：GeocoderServiceError, TimeoutError

对地理编码服务的调用已中止，因为在 timeout geocoding类或方法调用（如果指定）的参数。有些服务的速度一直很慢，使用它们可能需要更高的超时。

class geopy.exc.GeocoderUnavailable

基类：GeocoderServiceError, OSError

要么是无法建立到远程地理编码服务的连接，要么是服务响应了一个指示它不可用的代码。

class geopy.exc.GeocoderParseError

基类：GeocoderServiceError

Geopy无法分析服务的响应。这可能是由于地地形的一个错误造成的。

class geopy.exc.GeocoderNotFound

基类：GeopyError, ValueError

调用者请求与字符串匹配的地理编码程序，例如， "google" > GoogleV3 ，但找不到地理编码。

适配器

适配器是geocoders使用的HTTP客户端实现。

一些适配器的持久性和响应可能会保持一致，所以会支持压缩请求。

适配器应该被视为实现细节。大多数情况下，除非您想优化HTTP客户端设置，否则您不需要知道它们的存在。

在 2.0 版本加入: 适配器当前提供在 provisional basis .

支持的适配器

class geopy.adapters.RequestsAdapter(*, proxies, ssl_context, pool_connections=10, pool_maxsize=10, max_retries=2, pool_block=False)

基类：BaseSyncAdapter

使用的适配器 requests 类库。

requests 支持保持有效、重试、持久Cookies、允许响应压缩和使用HTTP/1.1 [目前] .

requests 必须安装包才能使用此适配器。

这些请求的 trust_env 值设置为False，这意味着环境不会影响请求的配置。这个 ssl_context 和 proxies 可以使用设置进行配置。

在 2.4 版本发生变更: 此适配器过去使用 certifi CA捆绑包默认情况下，如果 ssl_context 没有明确提供。默认情况下，它已更改为使用系统CA存储。

class geopy.adapters.URLLibAdapter(*, proxies, ssl_context)

基类：BaseSyncAdapter

使用Python标准库中的urllib的回退适配器，请参阅 urllib.request.urlopen() .

urllib不支持保持有效、请求重试、不持久化Cookies，并且仅支持HTTP/1.1。

urllib是geopy1.x中发出请求的唯一可用选项，因此这个适配器在HTTP请求方面的行为与geopy1.x相同。

class geopy.adapters.AioHTTPAdapter(*, proxies, ssl_context)

基类：BaseAsyncAdapter

使用的适配器 aiohttp 类库。

aiohttp 支持保持有效性、持久Cookies、允许响应压缩和使用HTTP/1.1 [目前] .

aiohttp 必须安装包才能使用此适配器。

基类

class geopy.adapters.AdapterHTTPError(message, *, status_code, headers, text)

基类：OSError

当接收到状态代码不成功的HTTP响应时，适配器必须引发的异常。

基Geocoder类将此异常转换为 geopy.exc.GeocoderServiceError .

__init__(message, *, status_code, headers, text)
参数:

  • message (str) -- 标准异常消息。

  • status_code (int) -- HTTP状态代码。

  • headers (dict) -- HTTP响应读取器。具有小写或不区分大小写的键的映射对象。。。添加的版本：：2.2

  • text (str) -- HTTP正文文本。

class geopy.adapters.BaseAdapter(*, proxies, ssl_context)

适配器的基类。

适配器有两种类型：

具体的适配器实现必须扩展上面两个基本适配器中的一个。

见 geopy.geocoders.options.default_adapter_factory 有关如何指定地理编码器使用的适配器的详细信息。

__init__(*, proxies, ssl_context)

初始化适配器。

参数:
abstract get_json(url, *, timeout, headers)

等同于 get_text 但响应应该是有效的JSON。返回的值是解析后的JSON。

geopy.exc.GeocoderParseError 如果无法分析响应，则必须引发。

参数:
abstract get_text(url, *, timeout, headers)

发出GET请求并以字符串形式返回响应。

此方法不应引发除以下情况外的任何异常：

参数:
class geopy.adapters.BaseSyncAdapter(*, proxies, ssl_context)

基类：BaseAdapter

同步适配器的基类。

class geopy.adapters.BaseAsyncAdapter(*, proxies, ssl_context)

基类：BaseAdapter

异步适配器的基类。

另请参阅： Async Mode 。

登录

geopy将使用记录器名称记录geocoding url geopy 在水平 DEBUG, 对于某些地理编码程序，这些URL将包含身份验证信息。

带有不成功状态代码的响应的HTTP主体记录为 INFO 水平。

默认日志记录级别为 NOTSET, 它将消息处理委托给根记录器。查看文档 logging.Logger.setLevel() 更多信息。

Semver

geopy尝试遵循语义版本控制，但是一些突破性的更改仍在小版本中进行，例如：

  • 未记录API的向后不兼容更改。这不应该影响任何人，除非他们扩展了geocoder类或使用了未记录的特性或monkey-patch任何东西。如果您认为geopy中缺少一些东西，请考虑打开一个问题或提供一个补丁/PR，而不是在geopy周围进行黑客攻击。

  • 地理编码服务有时会引入新的API并贬低以前的API。我们试图在不破坏地理编码程序API接口的情况下进行升级，但是 geopy.location.Location.raw 值可能以向后不兼容的方式更改。

  • 无效输入和特殊边缘情况的行为可能会改变。例如, geopy.point.Point 实例以前确实进行了坐标值标准化，尽管没有文档记录，而且它完全不适用于 [-90; 90] 射程。因此，不是为纬度使用不正确的规格化值，而是使用 ValueError 异常现已引发 (#294 )。

被逐步淘汰的特性和用法被废弃了 warnings 如果可能的话。确保使用 -Wd 切换以查看代码是否发出警告。

为了减少升级的痛苦，请在升级之前阅读变更日志。

Changelog

Changelog for 2.x.x series .

Changelog for 1.x.x series .

Changelog for 0.9x series .