主页 / 问题 / 701775
Accepted
Narnik Gamarnik
Asked:2020-08-04 13:01:49 +0000 UTC2020-08-04 13:01:49 +0000 UTC

如何制作字典生成器？

  • 772

任务是生成一个城市字典，这种类型：

{city: {'distance': '443 mi', 'duration': '9 hours 0 mins'}}

这是模型：

@python_2_unicode_compatible
class Route(Base):

    cities = models.ManyToManyField(City)

    @cached_property
    def cities_arrival_time(self, *args, **kwargs):
        r = lambda: x, y: requests.get(
            'https://maps.googleapis.com/maps/api/distancematrix/json?units=metric&mode=driving&origins={}&destinations={}&key={}'.format(
                x.name,
                y.name,     
                settings.GEOPOSITION_GOOGLE_MAPS_API_KEY
                )
            )

之后，您需要以duration这样的方式进行转换，以获得datetime

问题是发送我不明白如何编写一个将迭代QuerySet排除最后一个元素的生成器。

python

1 个回答

  1. Best Answer

    我做的完全不同。

    import json
import urllib
import os
import copy
import ast
import operator
import requests


DISTANCE_MATRIX_URL = "http://maps.googleapis.com/maps/api/distancematrix/"


class DM(object):

    def __init__(self, api_key=None, url=DISTANCE_MATRIX_URL):

        self.api_key = api_key
        self.url = url
        self.response = ''
        self.dict_response = {'distance': {'value': {}, 'text': {}, },
                              'duration': {'value': {}, 'text': {}, },
                              }

        self.origins = ''
        self.destinations = ''

    def make_request(self, origins, destinations, mode='driving'):
        data = {}
        self.origins = [origins] if type(origins) == str else origins
        self.destinations = [destinations] if type(destinations) == str else destinations
        data['origins'] = origins if type(origins) == str else '|'.join(origins)
        data['destinations'] = destinations if type(destinations) == str else '|'.join(destinations)
        data['mode'] = mode

        url_values = urllib.parse.urlencode(data)
        output_format = 'json'
        url = os.path.join(self.url, output_format)

        self.response = ast.literal_eval((urllib.request.urlopen(url + '?' + url_values).read()).decode("utf-8"))['rows']
        self.dict_response = {'distance': {'value': {}, 'text': {}, },  # Reset temporary dict
                              'duration': {'value': {}, 'text': {}, },
                              }


    def __get_response_element_data(self, key1, key2):
        if not self.dict_response[key1][key2]:
            l = self.response
            for i, orig in enumerate(self.origins):
                self.dict_response[key1][key2][orig] = {}
                for j, dest in enumerate(self.destinations):
                    if l[i]['elements'][j]['status'] == 'OK':
                        self.dict_response[key1][key2][orig][dest] = l[i]['elements'][j][key1][key2]
                    else:
                        self.dict_response[key1][key2][orig][dest] = l[i]['elements'][j]['status']

        return self.dict_response[key1][key2]

    def get_distance_values(self):
        return self.__get_response_element_data('distance', 'value')

    def get_distance_texts(self):
        return self.__get_response_element_data('distance', 'text')

    def get_time_values(self):
        return self.__get_response_element_data('duration', 'value')

    def get_time_texts(self):
        return self.__get_response_element_data('duration', 'text')

    def get_closest_points(self, max_distance=None, num=10, origin_index=0, origin_raw=None):
        if not self.dict_response['distance']['value']:
            self.get_distance_values()

        if origin_raw:
            origin = copy.deepcopy(self.dict_response['distance']['value'][origin_raw])
        else:
            origin = copy.deepcopy(self.dict_response['distance']['value'][self.origins[origin_index]])

        tmp_origin = copy.deepcopy(origin)
        if max_distance:
            for k, v in tmp_origin.iteritems():
                if v > max_distance:
                    del(origin[k])

        if origin:
            return sorted(origin.iteritems(), key=operator.itemgetter(1))[:num]

    它是这样工作的：

    a = DM()

a.make_request(['Minsk'], ['Moscow'])

    # 归还一个origin（我们计算的点）和一个destination（目的地）。

    如果我们想得到文本格式的结果（它不太准确），那么我们这样做：

    a.get_distance_texts()

    并得到结果：

    {'Minsk': {'Moscow': '717 km'}}

    但是，如果您需要计算 oneorigin和几个之间的距离destination，那么我们这样做：

    a.make_request(['Minsk'], ['Moscow', 'Sankt-Peterburg'])
a.get_distance_texts()
{'Minsk': {'Moscow': '717 km', 'Sankt-Peterburg': '795 km'}}

    实际上，距离是不同的。但是莫斯科和圣彼得堡之间的区别或多或少是准确的。

    这就是我们以米为单位获取数据的方式：

    a.get_distance_values()
{'Minsk': {'Moscow': 717038, 'Sankt-Peterburg': 795481}}

    所以，我们得到duration

    a.get_time_values()
{'Minsk': {'Moscow': 28751, 'Sankt-Peterburg': 36415}}

    同样，使用文本显示：

    a.get_time_texts()
{'Minsk': {'Moscow': '7 hours 59 mins', 'Sankt-Peterburg': '10 hours 7 mins'}}

    如果你需要找出几个origins和之间的距离destinations，那么像这样：

    a.make_request(['Minsk', 'Moscow'], ['Moscow', 'Varshava'])
a.get_distance_texts()
{'Minsk': {'Moscow': '717 km', 'Varshava': '554 km'}, 'Moscow': {'Moscow': '1 m', 'Varshava': '1,264 km'}}

    但是像这样：

    a.get_closest_points()

    我们得到一个元组列表，其中第一个元素是目的地，第二个是到第一个元素的距离origin

    [('Varshava', 553521), ('Moscow', 717038)]
    • 2

相关问题