Carte des informations de location sur une carte avec python

J'ai obtenu les informations de location de suumo dans Article précédent. Je voudrais cartographier les informations acquises sur une carte afin que je puisse voir la corrélation entre l'emplacement et le loyer.

Résultat d'exécution

Le résultat de l'exécution précédente est affiché. Vous pouvez obtenir la sortie suivante. Ce chiffre est une cartographie par code couleur des emplacements des appartements dans les 23 quartiers de Tokyo par prix. Plus la couleur est claire, moins elle est chère, et plus elle est sombre, plus elle est chère. Les couleurs sont divisées en 4 niveaux, dont chacun est répertorié dans la gamme suivante. 25%: ~ 85 900 yens 50%: 8,59 ~ 106 200 yens 75%: 10,62 ~ 136 300 yens 100%: 13,63 ~ 1,9 million de yens Le premier quadrant, le deuxième quadrant, le troisième quadrant et le quatrième quadrant sont calculés respectivement. Les couleurs peuvent être codées par couleur jusqu'à 12 niveaux ainsi que 4 niveaux.

Dans l'ensemble, vous pouvez voir que le loyer est moins cher du centre-ville au sud-ouest. En outre, l'est et le nord sont relativement moins chers que d'autres endroits. C'est peut-être évident pour les personnes vivant à Tokyo, mais c'était une découverte surprenante car je ne savais rien de Tokyo. En cartographiant de cette manière, vous pouvez comprendre visuellement l'emplacement et les informations de location. Si vous étendez la plage d'acquisition d'informations, vous pourrez voir la corrélation dans une plage plus large.

Environnement d'exécution

Vous devez convertir l'adresse en longitude / latitude pour la cartographie. Puisque je veux dessiner le résultat du mappage immédiatement et le voir, j'ai effectué une conversion de coordonnées et un mappage dans différents environnements.

Transformation de coordonnées

• python3(3.7.0)
• requests（2.24.0）
• beautifulsoup4（4.9.1）
• lxml(4.5.1)

cartographie

• python3(3.7.4)(anaconda3-2019.10)
• folium(0.11.0)
• pandas(0.25.1)

Pour être honnête, je ne pense pas que ce soit un problème d'aller tous ensemble dans le même environnement.

Transformation de coordonnées

Afin d'effectuer la cartographie, il est d'abord nécessaire de changer l'adresse acquise en coordonnées (longitudinale / latitude). L'obtention des coordonnées du lieu à partir de l'adresse ou du nom de cette manière s'appelle "géocodage". Il semble que le géocodage puisse également être effectué à l'aide d'API telles que Google et Yahoo, mais j'ai arrêté car l'enregistrement semble être gênant. J'ai entendu dire qu'il existe une API qui peut être géocodée gratuitement lorsque je recherche diverses choses, alors je l'ai utilisée. L'API utilisée est geocoding.jp. Quand je l'ai recherché, il y avait divers exemples d'implémentation, j'ai donc créé le code en référence à eux.

Code d'implémentation

Le code que j'ai créé est ci-dessous.

get_zahyo.py

import requests
from bs4 import BeautifulSoup
import time
import csv

def get_lat_lon_from_address(address):
    url = 'http://www.geocoding.jp/api/'
    latlons = []
    payload = {'q': address}
    r = requests.get(url, params=payload)
    ret = BeautifulSoup(r.content,'lxml')
    if ret.find('error'):
        raise ValueError("Invalid address submitted. {address}")
    else:
        x = ret.find('lat').string
        y = ret.find('lng').string
        time.sleep(10)
    return x, y

input_path = 'input.csv'
output_path = 'output.csv'

f1 = open(input_path)
reader = csv.reader(f1)

f2 = open(output_path, 'a')
writer = csv.writer(f2)

zahyo_d = {}
for row in reader:
    address = row[1]
    if address in zahyo_d:
        print('skip')
        x = zahyo_d[address][0]
        y = zahyo_d[address][1]
    else:
        print('get zahyo...')
        x, y = get_lat_lon_from_address(address)
        zahyo_d[address] = [x, y]
    row.append(x)
    row.append(y)
    writer.writerow(row)

Entrez le nom de fichier csv obtenu dans Article précédent dans input_path, et entrez le nom de fichier que vous aimez dans output_path.

Afin de réduire le nombre d'accès, l'adresse et les coordonnées une fois obtenues sont enregistrées dans un dictionnaire, et lorsque la même adresse que l'adresse précédemment recherchée arrive, elle est extraite du dictionnaire enregistré. Même ainsi, le nombre d'accès augmentera, il est donc nécessaire de définir un intervalle entre les temps d'accès avec time.sleep (10) afin de ne pas surcharger l'autre serveur.

Vous trouverez ci-dessous des exemples de input.csv et output.csv.

input.csv(partie)

La Tour Kagurazaka,Nishigokencho, Shinjuku-ku, Tokyo,18 ans,2 sous-sol 24 étages hors-sol,430 000 yens,2LDK,79.7m2,16e étage
La Tour Kagurazaka,Nishigokencho, Shinjuku-ku, Tokyo,18 ans,2 sous-sol 24 étages hors-sol,57.80 000 yens,3LDK,103.4m2,16e étage
Perle Hakusan,4 Hakusan, Bunkyo-ku, Tokyo,36 ans,8 étages,8.30 000 yens,3K,42m2,8ème étage
River City 21 East Towers II,Tsukuda 2, Chuo-ku, Tokyo,20 ans,2 souterrains de 43 étages hors sol,13.90 000 yens,1LDK,44.2m2,9ème étage

output.csv(partie)

La Tour Kagurazaka,Nishigokencho, Shinjuku-ku, Tokyo,18 ans,2 sous-sol 24 étages hors-sol,430 000 yens,2LDK,79.7m2,16e étage,35.706903,139.737421
La Tour Kagurazaka,Nishigokencho, Shinjuku-ku, Tokyo,18 ans,2 sous-sol 24 étages hors-sol,57.80 000 yens,3LDK,103.4m2,16e étage,35.706903,139.737421
Perle Hakusan,4 Hakusan, Bunkyo-ku, Tokyo,36 ans,8 étages,8.30 000 yens,3K,42m2,8ème étage,35.721231,139.746682
River City 21 East Towers II,Tsukuda 2, Chuo-ku, Tokyo,20 ans,2 souterrains de 43 étages hors sol,13.90 000 yens,1LDK,44.2m2,9ème étage,35.668253,139.786297

Ce n'est pas grave si la longitude et la latitude sont ajoutées.

Mise en garde

Même si vous recherchez des coordonnées à partir d'une adresse, il existe des adresses pour lesquelles les coordonnées ne peuvent pas être obtenues et une erreur se produit. Puisque j'ai noté l'adresse à laquelle l'erreur s'est produite, il est recommandé d'omettre la ligne avec ces adresses. Il peut être judicieux de sauvegarder un dictionnaire d'adresses et de coordonnées en cas d'erreur, ce qui n'alourdit pas l'autre serveur et raccourcit le temps d'exécution.

Adresse où l'erreur s'est produite

Centre-ville
1 Kandasuda-cho, Chiyoda-ku, Tokyo
2 Iwamotocho, Chiyoda-ku, Tokyo
1 Kanda Ogawamachi, Chiyoda-ku, Tokyo
3 Kanda Surugadai, Chiyoda-ku, Tokyo

23e arrondissement est
3 Kameari, Katsushika-ku, Tokyo
Flower Teahouse 2 à Katsushika-ku, Tokyo

West 23 quartiers
3 Numabukuro, Nakano-ku, Tokyo
Nokata 3 Nakano-ku, Tokyo

cartographie

Puisque nous avons pu convertir l'adresse en coordonnées, nous la mapperons sur la carte en fonction des informations de coordonnées. J'ai utilisé le folium comme bibliothèque de cartographie.

Structure du répertoire

Avant d'expliquer le code d'implémentation, j'expliquerai la structure du répertoire lorsque la conversion des coordonnées sera terminée. Afin de diviser par gamme, je divise les fichiers pour chaque partie des 23 quartiers de Tokyo comme suit. La partie "# acquisition de données" du code d'implémentation est implémentée en supposant que cette structure de répertoires est utilisée. Veuillez modifier la partie "# Acquisition de données" en fonction de votre structure de fichiers.

%ls
mapping.ipynb  output_center.csv  output_east.csv  output_north.csv  output_south.csv  output_west.csv

Code d'implémentation

Le code que j'ai créé est ci-dessous.

mapping.py

import folium
import pandas as pd

#Cartographie des stations sur la ligne Yamate
def mapping_stations(_map):
    locations_station = [[35.681382, 139.76608399999998],
[35.675069, 139.763328],
[35.665498, 139.75964],
[35.655646, 139.756749],
[35.645736, 139.74757499999998],
[35.630152, 139.74044000000004],
[35.6197, 139.72855300000003],
[35.626446, 139.72344399999997],
[35.633998, 139.715828],
[35.64669, 139.710106],
[35.658517, 139.70133399999997],
[35.670168, 139.70268699999997],
[35.683061, 139.702042],
[35.690921, 139.70025799999996],
[35.701306, 139.70004399999993],
[35.712285, 139.70378200000005],
[35.721204, 139.706587],
[35.728926, 139.71038],
[35.731401, 139.72866199999999],
[35.733492, 139.73934499999996],
[35.736489, 139.74687500000005],
[35.738062, 139.76085999999998],
[35.732135, 139.76678700000002],
[35.727772, 139.770987],
[35.720495, 139.77883700000007],
[35.713768, 139.77725399999997],
[35.707438, 139.774632],
[35.698683, 139.77421900000002],
[35.69169, 139.77088300000003]]
    for l in locations_station:
        folium.Circle(radius=10, location=l, color='blue').add_to(_map)
    return _map

#Obtenez des données
names = ['center', 'east', 'south', 'west', 'north']
df_list = []
for n in names:
    path = 'output_{}.csv'.format(n)
    df_list.append(pd.read_csv(path, names=['name', 'address', 'age', 'height', 'rent', 'kinds', 'area', 'floor', 'x', 'y']))
df = pd.concat(df_list)

#Convertir le loyer en nombres
df['rent'] = df['rent'].str.strip('Dix mille yens').astype(float)

#Traitement de la même adresse
address = df['address'].unique()
new_df = []
for adr in address:
    df_adr = df.loc[df['address']==adr]
    value = df_adr['rent'].mean()
    new_df.append([value, df_adr.iloc[0, 8], df_adr.iloc[0, 9]])
df = pd.DataFrame(new_df, columns=['rent', 'x', 'y'])

#décision de couleur
#colors = ['#fff4f4', '#ffeaea', '#ffd5d5', '#ffaaaa', '#ff8080', '#ff5555', '#ff2b2b', '#ff0000', '#d50000', '#aa0000', '#800000', '#550000']
#colors = ['#fff4f4', '#ffd5d5', '#ff8080', '#ff2b2b', '#d50000', '#800000']
colors = ['#ffd5d5', '#ff5555', '#d50000', '#550000']
num_color = len(colors)
df.loc[df['rent']<df['rent'].quantile(1/num_color), 'color'] = colors[0]
for i in range(1, num_color-1):
    df.loc[(df['rent'].quantile(i/num_color) <= df['rent']) & (df['rent'] < df['rent'].quantile((i+1)/num_color)), 'color'] = colors[i]
df.loc[df['rent']>=df['rent'].quantile((num_color-1)/num_color), 'color'] = colors[-1]

#cartographie
location = [df['x'].mean(), df['y'].mean()]
_map = folium.Map(location=location, zoom_start=12, tiles="Stamen Toner")
for i in range(len(df)):
    folium.Circle(radius=150, location=[df.loc[i, 'x'], df.loc[i, 'y']], color=df.loc[i, 'color'], fill_color=df.loc[i, 'color'], fill=True,).add_to(_map)
#_map = mapping_stations(_map)

#Plage de valeurs d'impression
print('{}% : - {:.2f}'.format(int((1)/num_color*100), df['rent'].quantile((1)/num_color)))
for i in range(1, num_color):
    print('{}% : {:.2f} - {:.2f}'.format(int((i+1)/num_color*100), df['rent'].quantile((i)/num_color), df['rent'].quantile((i+1)/num_color)))

#Pour anaconda
_map

#Pour python ordinaire
#_map.save('map.html')

Comme décrit dans la partie "Structure de répertoire", la partie "# Acquisition de données" est basée sur la structure de répertoire ci-dessus, veuillez donc la modifier. S'il n'y a qu'un seul fichier de sortie

#L'acquisition des données
path = [path to file]
df = pd.read_csv(path, names=['name', 'address', 'age', 'height', 'rent', 'kinds', 'area', 'floor', 'x', 'y'])

Je pense que ça va.

Vous pouvez modifier le nombre de couleurs en sélectionnant celle que vous aimez.

_map = mapping_stations (_map) est une fonction qui cartographie les informations de la station sur la ligne Yamate à Tokyo. Vous pouvez sortir en supprimant le commentaire. (Exemple de sortie ci-dessous)

Dans le cas d'anaconda, il peut être affiché en ligne, donc il peut être affiché avec _map. Si vous l'exécutez normalement avec python, il ne peut pas être affiché en ligne, vous pouvez donc l'afficher en l'enregistrant une fois avec _map.save ('map.html').

Résumé

J'ai essayé de cartographier les informations de l'appartement sur la carte. La cartographie est très pratique car elle vous permet de capturer visuellement des informations. Vous pouvez voir une corrélation plus globale en grattant davantage et en élargissant la plage de mappage. De plus, diverses informations telles que la taille de la pièce et la hiérarchie sont acquises par grattage, alors j'aimerais également essayer l'analyse des données avec les pandas.