Visualización “En Contacto”: Dime ¿quién es tu amigo? ¿Qué muestra el gráfico social en VKontakte?

Una vez me encontré con una tarea interesante: dibujar de la forma más rápida y sencilla posible (con un mínimo de bibliotecas involucradas) un gráfico de la intersección de usuarios de diferentes grupos de VKontakte. Y hasta lo hice. Entonces pensé: ¿y si alguien más necesita hacer algo similar?

Por lo tanto, aquí le diré y le mostraré cómo hacer estas cosas:

1. Conéctese al sitio web de VKontakte usando Python 2.7 (siempre puede reescribirlo en 3.x, si corresponde)

2. Cree gráficos utilizando la biblioteca NetworkX (aquí consideraremos gráficos de intersecciones de audiencias del grupo VKontakte)

3. Visualice estos gráficos (aquí necesitamos un poco la biblioteca matplotlib)

Entonces, dado:

Ejercicio: dibuje un gráfico de intersecciones de usuarios de diferentes grupos de VKontakte

Herramientas básicas: Python 2.7, NetworkX, matplotlib, numpy

Conexión a la API

Si busca bien en la vasta red, puede encontrar recursos útiles que facilitarán mucho la conexión a la API de VKontakte.

Primero debe descargar una biblioteca contenedora especial: el contenedor API vk.com (también conocido como vkontakte.ru).

Entonces es muy recomendable descargar un módulo para simplificar la autorización de VKontakte (muchas gracias a la buena persona Alexkutsan por este script). Llamaremos al módulo vk_auth y lo importaremos de todas las formas posibles en el futuro, así que guárdelo en el mismo directorio donde se ubicarán los scripts principales. Si el enlace no funciona, puede quitarme vk_auth: escriba en los comentarios o envíeme una solicitud por correo electrónico.

Entonces, tenemos todo para conectarnos rápida y fácilmente a la API de VKontakte. Comprobemos que hemos hecho todo bien y el contacto ahora nos deja entrar en lo más profundo.

#!/usr/bin/env python2 # -*- codificación: utf-8 -*- import vk_auth import vkontakte def test(): #parámetros para vk_auth.auth - su inicio de sesión de VKontakte, su contraseña de VKontakte, identificación de la aplicación, #y zona de acceso, también conocida como alcance (token,user_id) = vk_auth.auth("your_login", "your_password", "2951857", "groups") vk = vkontakte.API(token=token) print "la hora del servidor vk es", vk .getServerTime() devuelve 0

En este script, debe indicar su nombre de usuario y contraseña de VKontakte (no se preocupe, esta información no se filtrará a ninguna parte, puede verificarla usando el código del script vk_auth), como ID de la aplicación debe indicar el número de identificación de su aplicación. , que primero debe crearse en VKontakte de esta manera, por ejemplo.

Si el video no es muy claro, entonces en la página. vk.com/developers.php Hay un botón oculto para "crear aplicación" en la esquina superior derecha. No llama la atención de inmediato: está ubicado justo debajo de los botones del menú "música" y "ayuda". Allí puede crear una aplicación y usar su client_id como identificación de la aplicación.

¡Pero! También puedes utilizar la identificación de otra persona. Por ejemplo, usé este: 2951857 , que fue publicado en este artículo sobre Habrahabr. Si de repente el autor tiene alguna queja sobre el uso de este identificador, estoy dispuesto a eliminarlo de aquí.

A continuación debe especificar el llamado alcance— zona de acceso para nuestro analizador. Dado que vamos a analizar más los grupos, vale la pena especificar "grupo". Puede leer más sobre lo que se puede especificar como alcance.

Todo lo demás se puede dejar como está. Si todo es correcto, al ejecutar el código que se muestra arriba, obtendremos la hora del servidor VKontakte.

Grupos parsim

¡Excelente! Todo salió bien (al menos debería haberlo hecho).

Ahora intentemos obtener los datos necesarios sobre los grupos de VKontakte: el número de participantes de cada grupo y una lista de estos mismos participantes en forma de lista de ID.

Es importante saber que La API de VKontakte muestra un máximo de 1000 usuarios del grupo– No podrás volver a interrogarlo. Sin embargo, para realizar un análisis aproximado de grupos, servirá. Si necesita más, deberá analizar las páginas del grupo directamente.

La siguiente función toma como entrada una lista de nombres de grupos de VKontakte y, en la salida, proporciona los datos que necesitamos para estos grupos.

#!/usr/bin/env python2 # -*- codificación: utf-8 -*- importar vk_auth importar vkontakte importar tiempo def get_groups_users(lista_grupos): groups_out = () (token,user_id) = vk_auth.auth("su_inicio de sesión" , "tu_contraseña", "2951857", "grupos") vk = vkontakte.API(token=token) para grupo en lista_grupos: #aquí especificamos recuento=10, lo que nos dará 10 usuarios del grupo #esto se hace para claridad. Se puede extraer un máximo de 1000 usuarios groups_out = vk.get("groups.getMembers", group_id=group, sort="id_asc", offset=100, count=10) time.sleep(1) return groups_out if __name__ = = "__main__" : group_list = ["oldlentach", "obrazovach", "superdiscoteka"] print get_groups_users(group_list) >>> ("oldlentach": (u"count": 740868, u"users": ), "obrazovach ": (u"cuenta": 217978, u"usuarios": ), "superdiscoteka": (u"cuenta": 150538, u"usuarios": ))

La estructura de los datos de salida es la siguiente: la clave es el nombre del grupo, el valor es un diccionario con dos claves: u'count' - el número de miembros del grupo y u'users' - la lista de ID de los integrantes de este grupo (máximo 1000, como recordamos)

El nombre del grupo se toma de su dirección VKontakte, por ejemplo, está el grupo Obrazovach, que se encuentra en http://vk.com/obrazovach y tomamos la última parte de la dirección, es decir "obrazovach" como nombre del grupo.

Construyendo un gráfico social

Ahora pasemos directamente a la construcción de un gráfico social.

Aquí usaremos la biblioteca NetworkX, que es excelente para compilar, analizar y visualizar gráficos.

Así es como puede crear un gráfico para grupos de VKontakte:

1. La entrada es un diccionario, donde la clave es el nombre del grupo VKontakte y el valor es el número de miembros de este grupo y una lista de un máximo de 1000 ID de miembros del grupo (cada ID es un ID de usuario de VKontakte)
2. Creamos un vértice en el gráfico para cada grupo, asignando como atributo a cada vértice un peso igual al número de participantes del grupo.
3. Luego, para cada par de vértices, si hay una intersección entre ellos según los ID de los participantes, se crea una arista, y como atributo asignamos a cada arista un peso igual al número de usuarios que están presentes en ambos. grupos.

Los atributos que se asignan a los vértices y aristas son necesarios para su posterior visualización. Cuanto mayor sea el peso de un vértice (el número de participantes en el grupo), mayor será el tamaño del vértice en el diagrama. Cuanto mayor sea el peso del borde (la intersección del número de participantes), más grueso será el borde en el diagrama.

Esta función construye el gráfico descrito anteriormente:

#!/usr/bin/env python2 # -*- codificación: utf-8 -*- importar networkx como nx def make_graph(groups_out): graph = nx.Graph() groups_out = groups_out.items() para i_group en xrange( len(groups_out)): graph.add_node(groups_out, size=groups_out["count"]) para k_group en xrange(i_group+2, len(groups_out)): intersección = set(groups_out["usuarios"]).intersección( set(groups_out["usuarios"])) si len(intersección) > 0: graph.add_edge(groups_out, groups_out, peso=len(intersección)) devolver gráfico

visualicemos

La visualización se realiza utilizando métodos NetworkX basados ​​en matplotlib. Puede leer más sobre cómo visualizar un gráfico. Y aquí hay un ejemplo de cómo se visualiza exactamente el gráfico que creamos arriba. Los parámetros de los métodos hablan por sí solos, por lo que creo que no se requiere ninguna explicación adicional :)

Así es como puedes visualizar el gráfico que creamos:

#!/usr/bin/env python2 # -*- codificación: utf-8 -*- importar networkx como nx importar matplotlib.pyplot como plt importar numpy def plot_graph(graph, ajustar_nodesize): pos=nx.spring_layout(graph, k =1) #normaliza el tamaño del vértice para la visualización. El valor óptimo del parámetro #adjust_nodesize es de 300 a 500 nodesize = ["size"]/adjust_nodesize para i en graph.nodes()] #normaliza el grosor del borde del gráfico. #La normalización por puntuación estándar funciona bien aquí edge_mean = numpy.mean([i]["weight"] for i in graph.edges()]) edge_std_dev = numpy.std([i]["weight"] for i in graph .edges()]) edgewidth = [((graph.edge[i][i]["weight"] - edge_mean)/edge_std_dev) para i en graph.edges()] #crea un gráfico para visualización nx.draw_networkx_nodes( gráfico, pos,node_size=nodesize, node_color="y", alpha=0.6) nx.draw_networkx_edges(graph,pos,width=edgewidth,edge_color="b") nx.draw_networkx_labels(graph,pos,fontsize=10) #save y muestra el gráfico visualizado plt.savefig("/path/to/save/figure") plt.show()

Por cierto, puedes simplificar enormemente la normalización de los bordes mediante la puntuación estándar (también conocida como puntuación Z) utilizando el método scipy.stats.mstats.zscore de la biblioteca scipy.

Es simple, ¿no?

Ahora, si lo pones todo junto,

If __name__ == "__main__": groups = ["oldlentach", "echomsk", "meduzaproject", "tvrain", "bbc", "1tv", "izvestia", "rt_russian", "lentaru", "ntv" , "habr", "postnauka", "cloudytech", "space_live", "popularmechanics", "inbest", "lovestime", "orealno", "devpoymut", "padik_adik"] groups_out = get_groups_users(grupos) graph = make_graph (grupos_out) plot_graph(gráfico, 500)

entonces puedes dibujar un gráfico como este (haz clic en la imagen para ampliarla):

No diré que sea lo más estético posible, pero se hace de forma sencilla y rápida y es bastante adecuado para investigaciones superficiales. Además, siempre puedes jugar con colores, tamaños, transparencias, etc. :)

Es interesante, por cierto, que entre los grupos Habrahabr, el canal de televisión Dozhd (tvrain), Eco de Moscú (echomsk), la revista Popular Mechanics (popularmechanics) y el proyecto de información Meduza (meduzaproject) (y un poco más public Postnauka (postnauka)) hay conexiones serias: la audiencia de los grupos se superpone bastante. Y el grupo padik_adik, que en la visualización aparece como un pico aislado, es el grupo “Boys Will Understand” con el contingente correspondiente, al que, como puedes ver, no le gusta mucho involucrarse con el resto del mundo.

Estaré muy agradecido si deja un comentario aquí, ya sea elogioso o abusivo.

¡Hola gente de Habra!

Estos son mis amigos. Cada punto es una persona, un mundo entero que tuve la suerte de conocer de una forma u otra. La línea entre los puntos representa la amistad. Desde esta red, sin embargo, se puede saber mucho sobre una persona.

¿Cómo construir una red de tus amigos?

1. Compruebe que el navegador sea compatible con WebGL: get.webgl.org; debería haber un cubo. Si no hay ningún cubo, pruebe con otro navegador. A menudo, Chrome/Lis está bloqueado por tarjetas de video con controladores obsoletos. Por desgracia, el cubo es la clave para una visualización exitosa :).

2. Vaya a www.yasiv.com/vk; esta es una visualización de sus amigos en VK.

¿Por qué cuadrados azules en lugar de avatares?

WebGL tiene restricciones muy estrictas sobre las imágenes utilizadas en las texturas. Si provienen de otro dominio, el servidor de imágenes debe permitir el uso entre dominios. Se puede solucionar agregando una imagen Access-Control-Allow-Origin:* al encabezado de respuesta, pero, lamentablemente, VKontakte aún no lo admite. Si usted, el lector, es empleado de VKontakte y tiene acceso al código, agregue un encabezado. Te lo agradeceré mucho y corregiré la visualización :).

¿Por qué WebGL?

Ni CSS, ni SVG, ni siquiera un simple lienzo 2D pueden igualar el rendimiento de WebGL. vivagraph.js admite SVG y CSS, pero en ambos casos el principal obstáculo visual es el código del navegador para representar los elementos. Sólo al usar WebGL el cuello de botella se traslada a mi algoritmo de apilamiento :).

Pequeño mundo

¿Recuerdas la historia de los seis apretones de manos? Un análisis reciente de toda la red de Facebook arrojó un número de 4,7. Por diversión, comencé a construir una red con un amigo que no conocía bien hacia lo desconocido, y esta imagen se observó muy a menudo:

¿Qué dices?

Sus comentarios y sugerencias son muy, muy importantes para mí. Es sólo mi hobby, pero lo amo mucho. Entiendo que todo está todavía tosco y que en gráficos enormes (más de 2000 nodos) todo funciona demasiado lento. Pero en lugar de intentar hacer todo bien la primera vez, me gustaría preguntarte qué recomendarías hacer mejor. Bueno, estaré muy feliz si te unes.

¡Hola gente de Habra!

Estos son mis amigos. Cada punto es una persona, un mundo entero que tuve la suerte de conocer de una forma u otra. La línea entre los puntos representa la amistad. Desde esta red, sin embargo, se puede saber mucho sobre una persona.

¿Cómo construir una red de tus amigos?

1. Compruebe que el navegador sea compatible con WebGL: get.webgl.org; debería haber un cubo. Si no hay ningún cubo, pruebe con otro navegador. A menudo, Chrome/Lis está bloqueado por tarjetas de video con controladores obsoletos. Por desgracia, el cubo es la clave para una visualización exitosa :).

2. Vaya a www.yasiv.com/vk; esta es una visualización de sus amigos en VK.

¿Por qué cuadrados azules en lugar de avatares?

WebGL tiene restricciones muy estrictas sobre las imágenes utilizadas en las texturas. Si provienen de otro dominio, el servidor de imágenes debe permitir el uso entre dominios. Se puede solucionar agregando una imagen Access-Control-Allow-Origin:* al encabezado de respuesta, pero, lamentablemente, VKontakte aún no lo admite. Si usted, el lector, es empleado de VKontakte y tiene acceso al código, agregue un encabezado. Te lo agradeceré mucho y corregiré la visualización :).

¿Por qué WebGL?

Ni CSS, ni SVG, ni siquiera un simple lienzo 2D pueden igualar el rendimiento de WebGL. vivagraph.js admite SVG y CSS, pero en ambos casos el principal obstáculo visual es el código del navegador para representar los elementos. Sólo al usar WebGL el cuello de botella se traslada a mi algoritmo de apilamiento :).

Pequeño mundo

¿Recuerdas la historia de los seis apretones de manos? Un análisis reciente de toda la red de Facebook arrojó un número de 4,7. Por diversión, comencé a construir una red con un amigo que no conocía bien hacia lo desconocido, y esta imagen se observó muy a menudo:

¿Qué dices?

Sus comentarios y sugerencias son muy, muy importantes para mí. Es sólo mi hobby, pero lo amo mucho. Entiendo que todo está todavía tosco y que en gráficos enormes (más de 2000 nodos) todo funciona demasiado lento. Pero en lugar de intentar hacer todo bien la primera vez, me gustaría preguntarte qué recomendarías hacer mejor. Bueno, estaré muy feliz si te unes.

Gráfico social VK 22 de junio de 2012

No hace mucho apareció en la conocida red social rusa una aplicación que permite construir un gráfico de las conexiones de tus propios amigos. Esto no supone ningún beneficio global, pero para la investigación personal es algo bastante interesante. El procedimiento es simple: instale la aplicación, ejecútela, espere, vea el resultado. Después de 10-15 minutos la aplicación terminó de procesar la información y recibí este interesante gráfico:

Para entender qué áreas se relacionan con qué, he resaltado las principales:

El grupo central y más numeroso es la Facultad de Matemáticas de la Universidad Estatal de Volgogrado, lo cual es lógico, ya que es nuestra facultad nativa. A su derecha se encuentra separada la Facultad de Física, lo que se debe a dos motivos:

• Una parte de mi primera facultad de tecnologías de la información pasó a formar parte del departamento de física (la otra, en consecuencia, pasó a formar parte del departamento de matemáticas), y la mayoría de las conexiones surgieron de allí;
• El departamento de física y yo teníamos un edificio académico separado y común.

Justo debajo destaqué el grupo de Informática Empresarial de VolSU, mi grupo habitual. Un dato interesante es que la mayoría de mis compañeros de clase apenas se conocieron en la nueva facultad y permanecieron al margen.

Aún más abajo hay un grupo que incluye a aquellas personas con las que estudié para ser traductor en la Facultad de Lingüística.

A la izquierda del departamento de matemáticas hay un grupo de estudiantes de Volgogrado ChGK. De hecho, los límites de los grupos aquí están definidos de manera muy aproximada, y el rectángulo rojo del ChGK también debería cubrir parte del departamento de matemáticas. En el grupo se cruzan los estudiantes de ChGK con todos los demás estudiantes de VolSU, principalmente con aquellos a quienes conocí en ChGK, siendo editor y en varios viajes universitarios.

Separadamente a la izquierda hay un grupo con conexiones escolares, la mayoría de ellas de mi antigua clase. Como puedes ver, el nivel de socialización allí es bastante bajo y se limita a un determinado círculo de personas.

El segundo grupo más grande después de VolSU es la Escuela Superior de Economía de la Universidad Nacional de Investigación, principalmente la Facultad de Informática Empresarial, resaltada en amarillo. Hay dos ramas que no destaqué: estas son conexiones en el trabajo (un número tan pequeño se debe al hecho de que la mayoría no usa VK, prefiriendo FB y LinkedIn). Dos sucursales son dos departamentos, en uno trabajé antes y en el otro trabajo ahora. Como puedes ver, en cada uno de ellos hay una o dos personas relacionadas con HSE de una forma u otra.

El último grupo son los trabajadores de ChGK de Moscú y Yaroslavl. Al principio pensé que el grupo estaría relacionado con la Escuela Superior de Economía, porque de allí venían todos mis conocidos. Pero resultó que los estudiantes académicos de Moscú conocen a muchos más expertos de Volgogrado que los estudiantes de la Facultad de Biología (lo cual probablemente sea lógico).

Los puntos restantes son personas que conocí por casualidad en la calle, en viajes individuales o en Internet. No hay muchos, alrededor del 6%.

En general, la Facultad de Matemáticas de VolSU (incluida la Informática Empresarial) y HSE representan cada una 1/3 de todas las conexiones, respectivamente. El último tercio de las conexiones recae en los 6 clusters y usuarios restantes, que no incluí en ninguna muestra.

Por supuesto, no se trata de todos los que conozco, sino sólo de aquellos que están en VK y que están entre mis "amigos". Entonces la muestra no es del todo exacta, pero sí muy, muy aproximada.

Si está interesado, puede crear uno usted mismo.

Más recientemente, Habré publicó información sobre cómo implementar conexiones amigables en VKontakte usando Wolfram Mathematica. Me gustó la idea y, naturalmente, quería hacer el mismo gráfico usando Python y . Esto es lo que salió de esto.

¡Atención! El artículo contendrá partes del código que describirán las acciones más importantes, pero tenga en cuenta que el proyecto sufrirá más de un cambio en su base de código. Los interesados ​​pueden encontrar la fuente en GitHub.

Dividamos la tarea en elementos:

• Creación y autorización de aplicaciones.
• Recepción de datos.
• Visualización de gráficos.

Qué necesitamos para esto:

• Pitón 3.4
• Mozilla FireFox, ya que en Chrome no puedes usar XMLHttpRequest para descargar archivos locales (nadie te molesta en hacerlo Python -m http.servidor 8000)

Creación y autorización de aplicaciones.

Para acceder a la API de VKontakte, necesitamos crear Aplicación independiente, después de lo cual podemos usar los métodos API que necesitamos, que se describirán a continuación. La aplicación se está creando - seleccione Aplicación independiente. Se nos pedirá que ingresemos un código de confirmación enviado a nuestro teléfono móvil, luego de lo cual se nos dirigirá a la página de administración de la aplicación. en la pestaña Ajustes nos será útil ID de aplicación recibir token_acceso.
A continuación, debemos autorizar nuestra aplicación. Este proceso consta de 3 etapas.

Autenticación de usuario en el sitio web de VKontakte

Para hacer esto, crearemos una URL como se muestra a continuación:

https://oauth.vk.com/authorize?client_id=ApplicationID&scope=friends,offline&redirect_uri=https://oauth.vk.com/blank.html&display=page&v=5.21&response_type=token
Citando vk.com/dev/auth_mobile :

APP_ID: su identificador de aplicación;
PERMISOS: derechos de acceso a la aplicación solicitados;
PANTALLA: apariencia de la ventana de autorización, compatible: página, ventana emergente y móvil.
REDIRECT_URI: la dirección a la que se enviará el token de acceso.
API_VERSION: la versión de API que estás utilizando.

En nuestro caso, PERMISOS es el acceso a amigos y a la API en cualquier momento desde un servidor de terceros (token perpetuo). Si la dirección está formada correctamente, se nos pedirá que ingresemos un nombre de usuario y contraseña.

Permitir el acceso a sus datos

A continuación, permitimos que la aplicación acceda a la información necesaria:

Obteniendo token de acceso

Una vez autorizada la aplicación, el cliente será redirigido a REDIRECT_URI. La información que necesitamos estará contenida en el enlace.

https://oauth.vk.com/blank.html#access_token=ACCESS_TOKEN&expires_in=0&user_id=USER_ID
Editando el archivo configuración.py, insertando allí el recibido token_acceso Y ID_usuario. Ahora podemos realizar solicitudes a la API de VKontakte.

Recibiendo datos

Primero, veamos los métodos que usaremos para este propósito.

Dado que necesitamos al menos alguna información sobre la identificación del usuario, según la cual se construirá el gráfico, nos será útil. usuarios.obtener . Acepta una identificación o varias, una lista de campos de los cuales necesitamos información, así como el caso en el que se rechazará el apellido y el nombre. mi metodo información_base() obtiene una lista de identificaciones y devuelve información sobre el usuario con una foto.

Def base_info(self, ids): """leer https://vk.com/dev/users.get""" r = request.get(self.request_url("users.get", "user_ids=%s&fields= photo" % (",".join(map(str, ids)))).json() si "error" en r.keys(): generar VkException("Mensaje de error: %s. Código de error: %s " % (r["error"]["error_msg"], r["error"]["error_code"])) r = r["response"] # Verifique si la identificación de settings.py no está desactivada si está "desactivada " en r.keys(): levanta VkException ("Usuario desactivado") devuelve r
Esto puede ser importante para aquellos que quieran enviar una identificación desde amigos.getMutual, generando así una enorme cantidad de solicitudes. Más sobre esto más adelante.
Ahora necesitamos obtener información sobre los amigos del usuario, que es en lo que nos ayudará el método. amigos.obtener . De todos sus parámetros enumerados en la documentación, utilizamos ID_usuario, que está en nuestro configuración.py Y campos. Los campos adicionales serán las identificaciones de los amigos, sus nombres y apellidos y fotografías. Después de todo, lo que quieres es que los nodos tengan miniaturas de sus fotografías.

Def amigos(self, id): """ leer https://vk.com/dev/friends.get Acepta ID de usuario """ r = request.get(self.request_url("friends.get", "user_id= %s&fields=uid,first_name,last_name,photo" % id)).json()["response"] #self.count_friends = r["count"] return (item["id"]: artículo por artículo en r[ "elementos"])
Luego viene la parte divertida.
El método devuelve la lista de identificadores de amigos mutuos entre dos usuarios. amigos.getMutual . Esto es bueno, porque solo obtenemos la identificación y ya tenemos información más avanzada, gracias a amigos.obtener. Pero nadie le prohíbe realizar cien o dos solicitudes adicionales utilizando usuarios.obtener. Los diagramas se encuentran un poco más abajo.
Ahora decidamos cómo usaremos amigos.getMutual. Si el usuario tiene N amigos, entonces debemos realizar N consultas para que para cada amigo obtengamos una lista de amigos en común. Además, necesitaremos realizar retrasos para tener un número aceptable de solicitudes por segundo.
Supongamos que la identificación que estamos escaneando tiene 25 amigos.

Sólo 52 solicitudes son demasiadas, así que recuerda que usuarios.obtener puede aceptar una lista de identificaciones:

25 amigos - 28 solicitudes, pero como dije anteriormente, ya tenemos la información, gracias. amigos.obtener.

Y aquí es donde lo necesitaremos. ejecutar , que le permitirá ejecutar una secuencia de métodos. Tiene un solo parámetro código, puede contener hasta 25 llamadas a métodos API.
Es decir, al final el código en VKscript será algo como esto:

Return ("id": API.friends.getMutual(("source_uid":source, "target_uid":target)), // * 25 ... );
Encuentre quienes escriban cómo acortar este código sin usarlo todo el tiempo. API.amigos.getMutual.
Ahora sólo necesitamos enviar las identificaciones de nuestros amigos en lotes de 25 cada uno. En nuestro ejemplo, el diagrama se verá así:

Pero podríamos, con la ayuda para enviar a todos los amigos a amigos.getMutual y luego obtenga información más detallada a través de usuarios.obtener.
A continuación, crearemos una estructura legible por humanos, donde en lugar de la identificación de un amigo y una lista de identificaciones de sus amigos en común, habrá información de amigos.obtener. Como resultado, obtenemos algo como:

[((Tu amigo), [(amigo en común), (otro amigo en común)]),((Tu novia), Ninguna)]
Los diccionarios contienen identificación, nombre, apellido, foto; las listas contienen diccionarios de amigos en común; si no hay amigos en común, entonces Ninguno. Todo esto está separado por tuplas.

Def common_friends(self): """ lee https://vk.com/dev/friends.getMutual y lee https://vk.com/dev/execute Devuelve tuplas en el diccionario con información sobre el objetivo y una lista de amigos comunes con información """ def parts(lst, n=25): """ divide la lista en partes - 25 en cada """ return for i in iter(range(0, len(lst), n)) ] resultado = for i in parts(list(self.all_friends.keys())): # Código de formulario (parámetro de ejecución) code = "return (" for id in i: code = "%s%s" % (code, ""%s ": API.friends.getMutual(("source_uid":%s, "target_uid":%s)),," % (id, self.my_id, id)) código = "%s%s" % (código, " );") para clave, val en request.get(self.request_url("ejecutar", "código=%s" % código)).json()["respuesta"].items(): if int(key) in list(self.all_friends.keys()): # toma información de una lista ya completa result.append((self.all_friends, for i in val] if val else Ninguno)) devuelve resultado
Entonces, si quieres ver tu lista de amigos y amigos en común con ellos, ejecuta:

Python principal.py

Visualización de gráficos

La elección recayó en Curved Links. Para ello es necesario generar json, que será algo como esto:

( "nodos": [ ("nombre":"Myriel","grupo":1, "foto": "ruta"), ("nombre":"Napoleón","grupo":1, "foto": " ruta"), ("nombre":"Mlle.Baptistine","grupo":1, "foto": "ruta") ], "enlaces":[ ("fuente":1,"destino":0," valor":1), ("fuente":2,"destino":0,"valor":8) ] )
Modificándolo un poco índice.html, las fotos de amigos se convierten en nodos.

Si desea visualizar inmediatamente el gráfico:

Python 2d3.py
El archivo aparecerá en la carpeta web. miserables.json. No olvides abrir índice.html en Mozilla FireFox o utilizar Python -m http.servidor 8000 y ábrelo en Chrome.

La visualización se ralentiza cuando hay muchos amigos, así que estoy pensando en usar WebGL en el futuro.

Así se ve el gráfico de amistad de uno de mis amigos. Las conexiones lo son todo.

Por supuesto, me preguntaba quién trabaja más rápido.

El que me inspiró dice:

A mis 333 amigos les tomó 119 segundos.

Al momento de escribir este artículo, Himura tenía 321 amigos en VKontakte. Me tomó 9 segundos (funcionó todo el programa, no solo uno). amigos.getMutual).

En conclusión

Toda la información necesaria sobre los métodos utilizados se puede encontrar en la generosa documentación de VKontakte, sin embargo, descubrí un par de errores: el código de error 15 no estaba descrito ( "error_msg": "Acceso denegado: usuario desactivado", "error_code": 15), puedes adivinar lo que significa, y fluido en lugar de ID_usuario en la documentación del método friends.get. Después de 2 días:
Como se mencionó al principio, el proyecto se puede encontrar en GitHub, me alegraré si a alguien más le gusta y recibo muchas solicitudes de extracción interesantes...

UPD (27/05/2014):
Al igual que WTFRU7, agregué la capacidad de utilizar procedimientos almacenados. Para hacer esto necesitas ir a