Soutenir Vision du Web dans son partage de logiciels et de ressources libres

Ce mineur crée de la monnaie numérique Monero pour soutenir Vision du web.
Merci de désactiver votre bloqueur de publicité.
Aucune publicité ne sera affichée.
Le mineur utilise les ressources de votre machine pour créer gratuitement de la monnaie numérique.
Le montant des donations pour Vision du web est de 0.073555149149003 Monero.

Utiliser python

De Wiki. Analyse, Communication, Développement, Hacking.
Aller à : navigation, rechercher
Naviguer sur le wiki : Accueil du wiki - Administrateur - Développeur - Intégrateur - Marketing - Multimédia - Objectifs - We make Hack
Naviguer sur le site : Accueil du site - Les annuaires - Les éditoriaux - Le forum - Les outils - Les projets
 
Consulter le sommaire de cette page en étant déconnecté du réseau : Télécharger le sommaire en PDF

Installer Python

Ok-ko.png Installer Python : https://www.digitalocean.com/community/tutorials/how-to-install-the-django-web-framework-on-ubuntu-14-04

Outil de développement pour Python

Pycharm, gratuit dans la version Community Edition : https://www.jetbrains.com/pycharm/
Pyscripter : https://sourceforge.net/projects/pyscripter/files/
Emacs : https://www.emacswiki.org/emacs/PythonProgrammingInEmacs

Utiliser Python

Ok-ko.png Apprendre à programmer avec python : https://python.developpez.com/cours/TutoSwinnen/?page=page_6
Ok-ko.png Démarrer un programme en tant que service - démon : http://www.commentcamarche.net/faq/6858-demarrer-un-programme-en-tant-que-service-demon

Challenge de Connexion Web avec Python

L'authentification est un aspect critique de la sécurité sur le web.
Se documenter sur l'authentification sur le web avec des sessions.
Se documenter sur les mots clés «hacking» «session» «cookie» «sniffer».
01001110011001010111011101100010011010010110010101100011011011110110111001110100011001010111001101110100 est un site de challenges et d'expérimentation.
Le challenge : https://www.01001110011001010111011101100010011010010110010101100011011011110110111001110100011001010111001101110100.org/index.php?page=epreuve&no=134

Le cookie de connexion

Cookie retourné depuis le navigateur

Cookie créé lors de la connexion depuis la page de connexion.
Sniffer les Cookies avec les outils suivants : Navigateurs_pour_GNU_Linux#Cookies
Host: www.01001110011001010111011101100010011010010110010101100011011011110110111001110100011001010111001101110100.org
User-Agent: Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:60.0) Gecko/20100101 Firefox/60.0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
Accept-Language: fr,fr-FR;q=0.8,en-US;q=0.5,en;q=0.3
Accept-Encoding: gzip, deflate, br
Referer: https://www.01001110011001010111011101100010011010010110010101100011011011110110111001110100011001010111001101110100.org/forums/index.php?action=login2
Content-Type: application/x-www-form-urlencoded
Content-Length: 93
Cookie: PHPSESSID=cfef87d4ff0...fb71703789cc; _pk_id.1.8804=b0b3b...43d84.1530436988.3.1530453775.1530453775.; _pk_ref.1.8804=%5B%22%2...53775%2C%22https%3A%2F%2Fwww.visionduweb.eu%2Fwiki%2Findex.php%3Ftitle%3DUtiliser_python%22%5D; _pk_ses.1.8804=*
Connection: keep-alive
Upgrade-Insecure-Requests: 1
user=...
POST: HTTP/1.1 200 OK
Date: Sun, 01 Jul 2018 14:03:05 GMT
Server: Apache
X-Powered-By: PHP/5.4.45-0+deb7u5
X-Frame-Options: SAMEORIGIN
X-XSS-Protection: 1; mode=block
X-Content-Type-Options: nosniff
Expires: Thu, 19 Nov 1981 08:52:00 GMT
Cache-Control: private
Pragma: no-cache
Set-Cookie: SMFCookie89=a%3A4%3A%7Bi%3A0%3Bs%3A5%3A%2276012%2...2099ebb12a50dbe93f95%22%3Bi%3A2%3Bi%3A1530457385%3Bi%3A3%3Bi%3A0%3B%7D; expires=Sun, 01-Jul-2018 15:03:05 GMT; path=/
PHPSESSID=c098b4c6845...47abf1d892a761; path=/
PHPSESSID=c098b4c6845...47abf1d892a761; expires=Sun, 01-Jul-2018 15:03:05 GMT; path=/
Location: https://www.01001110011001010111011101100010011010010110010101100011011011110110111001110100011001010111001101110100.org/forums/index.php?action=login2;sa=check;member=76012
Content-Encoding: gzip
Vary: Accept-Encoding
Content-Length: 20
Keep-Alive: timeout=15, max=99
Connection: Keep-Alive
Content-Type: text/html

Le script pour se connecter au site

En python

#!/usr/bin/python
# -*- coding: utf-8 -*-
import cookielib, urllib, urllib2

login = 'LE LOGIN'
password = 'LE MOT DE PASSE'

# On active le support des cookies pour urllib2
cookiejar = cookielib.CookieJar()
urlOpener = urllib2.build_opener(urllib2.HTTPCookieProcessor(cookiejar))

# On envoie le login et le password à la première page du site qui nous renvoie un cookie de session
values = {'user':login, 'passwrd':password}
data = urllib.urlencode(values)
request = urllib2.Request("https://www.01001110011001010111011101100010011010010110010101100011011011110110111001110100011001010111001101110100.org/forums/index.php?action=login2", data)
url = urlOpener.open(request)  # Notre cookiejar reçoit automatiquement les cookies
page = url.read(500000)

# Affecter les valeurs du cookie à une variable.
# CookieName = [cookie.name for cookie in cookiejar]
# CookieValue = [cookie.value for cookie in cookiejar]
# Afficher les valeurs des variables cookie pour voir si il existe.
# print CookieName
# print CookieValue

# On fait une nouvelle requête sur la deuxième page du site avec le cookie de session qui a été récupéré lors de l'écoute des cookies lors du passage de la première à la deuxième page depuis un navigateur web.
url = urlOpener.open('http://www.01001110011001010111011101100010011010010110010101100011011011110110111001110100011001010111001101110100.org/epreuves/prog/prog1.php')

# Renseigner le header avec la valeur du cookie observé pour SMFCookie89 pour pouvoir lire la deuxième page
headers = {'Cookie: SMFCookie89=a%3A4%3A%7Bi%3A0%3Bs%3A5%3A%2255733%22%3Bi...%22%3Bi%3A2%3Bi%3A1612301728%3Bi%3A3%3Bi%3A0%3B%7D'}
page = url.read(200000)
print page

# Parser la réponse obtenue sur la deuxième page
nombre = page.replace('Le nombre aléatoire pour valider ta réponse est : ',)

# Stocker la réponse pour être sur qu'on l'ait bien récupérée.
# fichier = open("data.txt", "a")
# fichier.write(nombre)
# fichier.close()

# Concaténer le nombre de la réponse à l'url suivante pour valider la réponse.
# https://www.01001110011001010111011101100010011010010110010101100011011011110110111001110100011001010111001101110100.org/epreuves/prog/verifpr1.php?solution=nombre
resolu = "https://www.01001110011001010111011101100010011010010110010101100011011011110110111001110100011001010111001101110100.org/epreuves/prog/verifpr1.php?solution="+str(nombre)
print resolu

## Consulter l'adresse URL pour valider la réponse.
validation = urlOpener.open(resolu)
validation = validation.read(100000)
print validation

Un message s'affiche à l'écran pour valider le challenge :
# ['838fa4cdea5d...3145a98f20df9ee', 'a%3A4%3A%7Bi%3A0%3Bs%3A5%3A%2255733%22%3Bi...%22%3Bi%3A2%3Bi%3A1612301728%3Bi%3A3%3Bi%3A0%3B%7D']
 # Le nombre aléatoire pour valider ta réponse est : 27....115
 # https://www.01001110011001010111011101100010011010010110010101100011011011110110111001110100011001010111001101110100.org/epreuves/prog/verifpr1.php?solution=27....115
 # <h3 align="center">Bravo, tu as réussi l'épreuve !</h3><br /><p>Pour valider l'épreuve, le mot de passe est : ******
# Utiliser un navigateur pour aller sur votre compte, dans la partie Challenge, pour valider l'épreuve Renvoi en saisissant le mot de passe reçu dans le terminal.

En python - Variante

Au lieu d'appeler directement la fonction, on lui créé un contexte d'exécution en définissant un cookie :
$context = stream_context_create(array("http" => array ("header" => "Cookie: nomcookie=valeurcookie\r\n"))) ;
echo file_get_contents("http://www.01001110011001010111011101100010011010010110010101100011011011110110111001110100011001010111001101110100.org/epreuves/prog/prog1.php", false, $context) ;
Mise en application :
$context = stream_context_create(array("http" => array ("header" => "Cookie: SMFCookie89=a%3A4%3A%7Bi%3A0%3Bs%3A5%3A%2255733%22%3Bi...c9d541%22%3Bi%3A2%3Bi%3A1612301728%3Bi%3A3%3Bi%3A0%3B%7D\r\n"))) ;
$retour = file_get_contents("http://www.01001110011001010111011101100010011010010110010101100011011011110110111001110100011001010111001101110100.org/epreuves/prog/prog1.php", false, $context) ;
$k = preg_split("/ /", $retour);
// var_dump($keywords[stri]);
echo file_get_contents('http://www.01001110011001010111011101100010011010010110010101100011011011110110111001110100011001010111001101110100.org/epreuves/prog/verifpr1.php?solution='.$k[9], false, $context);
Source : https://github.com/ZerooCool/01001110011001010111011101100010011010010110010101100011011011110110111001110100011001010111001101110100/blob/master/programmation/Renvoi/epRenvoi.php
Fork de https://github.com/floriancourgey/01001110011001010111011101100010011010010110010101100011011011110110111001110100011001010111001101110100

En PHP

# Exemple. Alternative en PHP mais il faut encore renvoyer le cookie en entier. Identifier le cookie avec un sniffer.
$url = 'http://www.01001110011001010111011101100010011010010110010101100011011011110110111001110100011001010111001101110100.org/epreuves/prog/prog1.php';
$agent = 'Mozilla/5.0 (Windows; U; Windows NT 5.1; fr; rv:1.8.1.6) Gecko/20070725 Firefox/2.0.0.6';
$id = 'PHPSESSID=bb2e5b0c1801158d33295**********; path=/';
$ch = curl_init();
curl_setopt($ch, CURLOPT_USERAGENT, $agent);
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_TIMEOUT, 4);   
curl_setopt($ch, CURLOPT_COOKIE, $id);

$ret = curl_exec($ch);
if (curl_errno($ch))
{
   print curl_error($ch);
   return false;
}
echo $ret;
print_r($_COOKIE);
curl_close($ch);
# Autre exemple avec PHP Lib cURL.
$c = curl_init("http://www.01001110011001010111011101100010011010010110010101100011011011110110111001110100011001010111001101110100.org/epreuves/prog/prog1.php") ;
curl_setopt($c, CURLOPT_COOKIE, "cookie=value") ;
echo curl_exec ($c) ;
curl_close($c) ;
# En Perl avec LWP.
#!/usr/bin/perl
# Create a user agent object
use LWP::UserAgent;
$ua = LWP::UserAgent->new;
$ua->agent("MyApp/0.1 ");
$h = HTTP::Headers->new;

$h->header('Cookie' => 'MonCookie=MaValeur;SecondCookie=myVal2');

# Create a request
my $req = HTTP::Request->new(GET => "http://www.techniques-ingenieur.fr/test.asp",$h);

# Pass request to the user agent and get a response back
my $res = $ua->request($req);

# Check the outcome of the response
if ($res->is_success) {
  print $res->content;
}

La discussion sur ce challenge

La page Modification SMF nous informe : Si vous recherchiez la solution de facilité, et passiez le PHPSESSID en GET dans l'URL, bah raté, ça marche plus.
Source : https://www.01001110011001010111011101100010011010010110010101100011011011110110111001110100011001010111001101110100.org/forums/index.php?topic=2359.0
Il faut recréer le même contexte qu'avec un navigateur. Comprendre comment un navigateur se connecte à un serveur et quelles sont les données techniques échangées.
Observer quelque chose qui fonctionne déjà comme la connexion avec son propre navigateur par exemple.
Reproduisant en observant le comportement de la connexion.
Source : https://www.01001110011001010111011101100010011010010110010101100011011011110110111001110100011001010111001101110100.org/forums/index.php?topic=20.150
Lecture complémentaires : Apprendre à créer un cookie. Savoir créer un entête user agent.
https://www.01001110011001010111011101100010011010010110010101100011011011110110111001110100011001010111001101110100.org/forums/index.php?topic=2354.0
Source : https://www.01001110011001010111011101100010011010010110010101100011011011110110111001110100011001010111001101110100.org/forums/index.php?topic=20.90

Introduction à pandas - Analyse de données en Python

Dans cet article, je vais continuer la série précédente où nous avons présenté NumPy. (http://www.discoversdk.com/blog/getting-started-with-numpy)
Nous allons maintenant examiner Pandas (http://pandas.pydata.org), le standard de facto pour le traitement des données avec Python.
Nous avons rencontré certaines limitations lors de l'utilisation de NumPy (http://www.discoversdk.com/products/numpy), par exemple, le chargement à partir d'un fichier CSV nécessitait que le contenu de chaque colonne soit constitué de chaînes s'il existait une colonne contenant une entrée sans numéro. Nous allons maintenant faire un pas de plus et voir comment Pandas aborde ce problème et ce que nous pouvons faire avec.

Quelques mots sur pandas

Pandas vise à intégrer les fonctionnalités de NumPy et de matplotlib (http://www.discoversdk.com/products/matplotlib) afin de vous fournir un outil pratique pour l'analyse et la visualisation de données.
À côté de l'intégration, l'expérience utilisateur est améliorée.
Pour installer Pandas sur Debian Stretch 9, exécuter simplement la commande suivante sur votre ligne de commande :
sudo apt install python3-pandas
Cela chargera et installera pandas avec toutes ses dépendances, comme NumPy.
Après cela, nous pouvons commencer notre exploration.
Les structures de données de pandas sont capables de contenir des éléments de tout type : Series, DataFrame et Panel.
Le facteur commun est que les structures de données sont étiquetées.
Nous utiliserons la plupart du temps des DataFrames dans cette série de tutoriels, mais voici une brève introduction à chacun d’entre eux :
Série: objet étiqueté de type tableau unidimensionnel capable de contenir n'importe quel type d'objet.
DataFrame - structure de données étiquetée en deux dimensions dans laquelle les colonnes peuvent être de types différents.
Panel - une structure de données en trois dimensions. Vous pouvez les considérer comme des dictionnaires de DataFrames.

Fonctionnalité de base

Commençons par explorer les fonctionnalités de base de pandas.
>>> import pandas as pd
>>> import numpy as np
>>> series = pd.Series([1,2,3,4,5, np.nan, "a string", 6])
>>> series
0           1
1           2
2           3
3           4
4           5
5         NaN
6    a string
7           6
dtype: object
Pour afficher la sortie dans le terminal, créer un fichier test.py
touch test.py
nano test.py
Ajouter les 4 premières lignes, sans les >>>
Modifier la 4ème ligne pour print(series)
Dans l'exemple ci-dessus, nous avons créé un objet Series contenant beaucoup de valeurs différentes.
Une chose intéressante à noter est que nous pouvons faire référence à des éléments non numériques en utilisant le symbole nan de NumPy qui nous indique que l'élément n'est pas un nombre mais qu'il peut être utilisé comme un type numérique indiquant qu'il ne s'agit pas d'un nombre.
Le type de la série est object qui fait référence à son contenu mélangé car nous avons une chaîne incluse.
Si nous utilisons uniquement des types numériques, nous obtenons le type de base NumPy, float pour notre série :
>>> series = pd.Series([1,2,np.nan, 4])
>>> series
0    1.0
1    2.0
2    NaN
3    4.0
dtype: float64
Peu importe que les données incluent un nan, la série sera traitée comme une série de chiffres.
Les séries ne sont pas ce qui nous intéresse, mais les DataFrames, car cela ressemble à un tableau 2D similaire à un fichier CSV ou à une table de base de données relationnelle :
>>> df = pd.DataFrame(np.array([1,2,3,4,5,6]).reshape(2,3))
>>> df
 0  1  2
0  1  2  3
1  4  5  6
>>> df.dtypes
0    int32
1    int32
2    int32
dtype: object
Le paramètre par défaut affiche l'index numérique des lignes et des colonnes, mais il peut être modifié pour donner plus de sens aux données :
>>> df = pd.DataFrame(np.array([1,2,3,4,5,6]).reshape(2,3), columns=list('ABC'), index=list('XY'))
>>> df
 A  B  C
X  1  2  3
Y  4  5  6
Comme vous pouvez le constater, l'argument d'index fournit la liste à utiliser pour les lignes, tandis que la liste fournie via l'argument de colonnes peut être utilisé pour modifier les index de colonne.
Si nous avons de plus grands ensembles de données, la méthode head peut également être utile.
Il affiche les n premières lignes fournies en tant qu'argument.
Si vous ne fournissez pas d'argument, la valeur par défaut de 5 sera utilisée :
>>> df2 = pd.DataFrame(np.arange(1, 7501).reshape(500,15))
>>> df2.head(2)
 0   1   2   3   4   5   6   7   8   9   10  11  12  13  14
0   1   2   3   4   5   6   7   8   9  10  11  12  13  14  15
1  16  17  18  19  20  21  22  23  24  25  26  27  28  29  30
>>> df2.head()
 0   1   2   3   4   5   6   7   8   9   10  11  12  13  14
0   1   2   3   4   5   6   7   8   9  10  11  12  13  14  15
1  16  17  18  19  20  21  22  23  24  25  26  27  28  29  30
2  31  32  33  34  35  36  37  38  39  40  41  42  43  44  45
3  46  47  48  49  50  51  52  53  54  55  56  57  58  59  60
4  61  62  63  64  65  66  67  68  69  70  71  72  73  74  75
Le contraire est la méthode tail. Elle montre les n dernières lignes du DataFrame. Si vous omettez l’argument, la valeur par défaut de 5 sera utilisée :
>>> df2.tail()
      0     1     2     3     4     5     6     7     8     9     10    11  \
495  7426  7427  7428  7429  7430  7431  7432  7433  7434  7435  7436  7437
496  7441  7442  7443  7444  7445  7446  7447  7448  7449  7450  7451  7452
497  7456  7457  7458  7459  7460  7461  7462  7463  7464  7465  7466  7467
498  7471  7472  7473  7474  7475  7476  7477  7478  7479  7480  7481  7482
499  7486  7487  7488  7489  7490  7491  7492  7493  7494  7495  7496  7497

      12    13    14
495  7438  7439  7440
496  7453  7454  7455
497  7468  7469  7470
498  7483  7484  7485
499  7498  7499  7500
>>> df2.tail(1)
      0     1     2     3     4     5     6     7     8     9     10    11  \
499  7486  7487  7488  7489  7490  7491  7492  7493  7494  7495  7496  7497

      12    13    14
499  7498  7499  7500
Comme vous pouvez le constater, les colonnes sont divisées en plusieurs lignes si elles sont trop larges, mais cela ne nous dérangera plus à l'avenir car nous n'imprimerons pas nos données sur la console, mais nous utiliserons des visualisations pour montrer ce que nous pouvons collecter.

Description des données

C'est une fonctionnalité que nous utiliserons très souvent si nous avons un nouvel ensemble de données à analyser :
>>> df3 = pd.DataFrame(np.arange(1, 100, 0.12).reshape(33,25))
>>> df3.describe()
            0          1          2          3          4          5   \
count  33.000000  33.000000  33.000000  33.000000  33.000000  33.000000
mean   49.000000  49.120000  49.240000  49.360000  49.480000  49.600000
std    29.008619  29.008619  29.008619  29.008619  29.008619  29.008619
min     1.000000   1.120000   1.240000   1.360000   1.480000   1.600000
25%    25.000000  25.120000  25.240000  25.360000  25.480000  25.600000
50%    49.000000  49.120000  49.240000  49.360000  49.480000  49.600000
75%    73.000000  73.120000  73.240000  73.360000  73.480000  73.600000
max    97.000000  97.120000  97.240000  97.360000  97.480000  97.600000

             6          7          8          9     ...             15  \
count  33.000000  33.000000  33.000000  33.000000    ...      33.000000
mean   49.720000  49.840000  49.960000  50.080000    ...      50.800000
std    29.008619  29.008619  29.008619  29.008619    ...      29.008619
min     1.720000   1.840000   1.960000   2.080000    ...       2.800000
25%    25.720000  25.840000  25.960000  26.080000    ...      26.800000
50%    49.720000  49.840000  49.960000  50.080000    ...      50.800000
75%    73.720000  73.840000  73.960000  74.080000    ...      74.800000
max    97.720000  97.840000  97.960000  98.080000    ...      98.800000

             16         17         18         19         20         21  \
count  33.000000  33.000000  33.000000  33.000000  33.000000  33.000000
mean   50.920000  51.040000  51.160000  51.280000  51.400000  51.520000
std    29.008619  29.008619  29.008619  29.008619  29.008619  29.008619
min     2.920000   3.040000   3.160000   3.280000   3.400000   3.520000
25%    26.920000  27.040000  27.160000  27.280000  27.400000  27.520000
50%    50.920000  51.040000  51.160000  51.280000  51.400000  51.520000
75%    74.920000  75.040000  75.160000  75.280000  75.400000  75.520000
max    98.920000  99.040000  99.160000  99.280000  99.400000  99.520000

             22         23         24
count  33.000000  33.000000  33.000000
mean   51.640000  51.760000  51.880000
std    29.008619  29.008619  29.008619
min     3.640000   3.760000   3.880000
25%    27.640000  27.760000  27.880000
50%    51.640000  51.760000  51.880000
75%    75.640000  75.760000  75.880000
max    99.640000  99.760000  99.880000
[8 lignes x 25 colonnes]
Comme vous pouvez le constater, l'appel de la méthode describe sur le DataFrame affiche un bref résumé sur chaque colonne de l'ensemble de données :
Le nombre d'éléments (nombre), leur moyenne, l'écart type (std), les valeurs minimale et maximale et certaines valeurs dans l'intervalle.

Indexation et découpage

Le découpage en tranches de données fonctionne avec l'attribut iloc :
>>> df3 = pd.DataFrame(np.arange(1, 100, 0.12).reshape(33,25))
>>> df3.iloc[:5,:10]
     0      1      2      3      4     5      6      7      8      9
0   1.0   1.12   1.24   1.36   1.48   1.6   1.72   1.84   1.96   2.08
1   4.0   4.12   4.24   4.36   4.48   4.6   4.72   4.84   4.96   5.08
2   7.0   7.12   7.24   7.36   7.48   7.6   7.72   7.84   7.96   8.08
3  10.0  10.12  10.24  10.36  10.48  10.6  10.72  10.84  10.96  11.08
4  13.0  13.12  13.24  13.36  13.48  13.6  13.72  13.84  13.96  14.08
Dans l'exemple ci-dessus, nous avons sélectionné les 5 premières lignes et les 10 premières colonnes.
Nous pouvons aussi implémenter les méthodes head () et tail () en utilisant le nombre de lignes par défaut de 5 avec iloc :
>>> df3.iloc[-5:] # df3.tail(5)
    0      1      2      3      4     5      6      7      8      9   ...    \
28  85.0  85.12  85.24  85.36  85.48  85.6  85.72  85.84  85.96  86.08  ...
29  88.0  88.12  88.24  88.36  88.48  88.6  88.72  88.84  88.96  89.08  ...
30  91.0  91.12  91.24  91.36  91.48  91.6  91.72  91.84  91.96  92.08  ...
31  94.0  94.12  94.24  94.36  94.48  94.6  94.72  94.84  94.96  95.08  ...
32  97.0  97.12  97.24  97.36  97.48  97.6  97.72  97.84  97.96  98.08  ...

     15     16     17     18     19    20     21     22     23     24
28  86.8  86.92  87.04  87.16  87.28  87.4  87.52  87.64  87.76  87.88
29  89.8  89.92  90.04  90.16  90.28  90.4  90.52  90.64  90.76  90.88
30  92.8  92.92  93.04  93.16  93.28  93.4  93.52  93.64  93.76  93.88
31  95.8  95.92  96.04  96.16  96.28  96.4  96.52  96.64  96.76  96.88
32  98.8  98.92  99.04  99.16  99.28  99.4  99.52  99.64  99.76  99.88
[5 rows x 25 columns]
>>> df3.iloc[:5] # df3.head(5)
    0      1      2      3      4     5      6      7      8      9   ...    \
0   1.0   1.12   1.24   1.36   1.48   1.6   1.72   1.84   1.96   2.08  ...
1   4.0   4.12   4.24   4.36   4.48   4.6   4.72   4.84   4.96   5.08  ...
2   7.0   7.12   7.24   7.36   7.48   7.6   7.72   7.84   7.96   8.08  ...
3  10.0  10.12  10.24  10.36  10.48  10.6  10.72  10.84  10.96  11.08  ...
4  13.0  13.12  13.24  13.36  13.48  13.6  13.72  13.84  13.96  14.08  ...

    15     16     17     18     19    20     21     22     23     24
0   2.8   2.92   3.04   3.16   3.28   3.4   3.52   3.64   3.76   3.88
1   5.8   5.92   6.04   6.16   6.28   6.4   6.52   6.64   6.76   6.88
2   8.8   8.92   9.04   9.16   9.28   9.4   9.52   9.64   9.76   9.88
3  11.8  11.92  12.04  12.16  12.28  12.4  12.52  12.64  12.76  12.88
4  14.8  14.92  15.04  15.16  15.28  15.4  15.52  15.64  15.76  15.88
[5 rows x 25 columns]
Mais pandas représente une étape supplémentaire et nous permet d’accéder aux données via des étiquettes dans les cadres de données.
Dans cet exemple, ce n’est pas très spectaculaire car les étiquettes de l’ensemble de données sont les mêmes que leur position.
Cependant, en utilisant la méthode de changement de nom, vous pouvez facilement renommer les colonnes du DataFrame et utiliser ces index pour accéder aux valeurs :
>>> df4 = df3.rename(columns=lambda c: chr(65+c))
>>> df4.loc[:5, 'A':'D']
     A      B      C      D
0   1.0   1.12   1.24   1.36
1   4.0   4.12   4.24   4.36
2   7.0   7.12   7.24   7.36
3  10.0  10.12  10.24  10.36
4  13.0  13.12  13.24  13.36
5  16.0  16.12  16.24  16.36
>>> df4.loc[:5, ('A','D')]
     A      D
0   1.0   1.36
1   4.0   4.36
2   7.0   7.36
3  10.0  10.36
4  13.0  13.36
5  16.0  16.36
La partie la plus intéressante est la fonction lambda fournie pour les noms des colonnes.
En effet, vous avez besoin d'un paramètre de type dictionnaire ou d'une fonction qui renomme les étiquettes.
Créer un dictionnaire serait un exemple, une fonction anonyme simple est donc idéale.
La fonction chr () renvoie la représentation sous forme de caractères du nombre fourni, chr (65) égale le caractère A.
Le paramètre c est l'en-tête actuel de l'axe (dans ce cas, les colonnes), qui est un nombre compris entre 0 et 24.
Ceci est quelque chose de cool pour une utilisation future où nous traitons des données à partir de fichiers CSV.

Lecture de fichiers CSV

Le moment est venu de donner des exemples concrets.
Nous utiliserons le même ensemble de données déjà connu dans le dernier article de NumPy.
Si vous ne l'avez pas lu ou si vous ne voulez simplement pas le consulter, voici le fichier à télécharger :
Noms de bébé les plus populaires selon le sexe et le groupe ethnique de la mère, New York. (https://catalog.data.gov/dataset/most-popular-baby-names-by-sex-and-mothers-ethnic-group-new-york-city-8c742)
Je l'ai enregistré sous le nom baby_names.csv.
Il contient des noms donnés aux bébés de la ville de New York, en fonction du sexe et de l’appartenance ethnique. Commençons par lire dans le fichier :
>>> import numpy as np
>>> import pandas as pd
>>> baby_names = pd.read_csv('baby_names.csv')
>>> baby_names.head()
  BRTH_YR    GNDR    ETHCTY         NM  CNT  RNK
0     2011  FEMALE  HISPANIC  GERALDINE   13   75
1     2011  FEMALE  HISPANIC        GIA   21   67
2     2011  FEMALE  HISPANIC     GIANNA   49   42
3     2011  FEMALE  HISPANIC    GISELLE   38   51
4     2011  FEMALE  HISPANIC      GRACE   36   53
>>> baby_names.tail()
      BRTH_YR  GNDR              ETHCTY       NM  CNT  RNK
13957     2014  MALE  WHITE NON HISPANIC   Yousef   18   94
13958     2014  MALE  WHITE NON HISPANIC  Youssef   24   88
13959     2014  MALE  WHITE NON HISPANIC    Yusuf   16   96
13960     2014  MALE  WHITE NON HISPANIC  Zachary   90   39
13961     2014  MALE  WHITE NON HISPANIC      Zev   49   65
Vous pouvez voir que la lecture d'un fichier CSV se produit avec la fonction read_csv.
Le résultat est un DataFrame - et contrairement à NumPy, nous n'avons pas eu à dire à Pandas de lire toutes les données sous forme de chaînes.
Cela signifie que nous avons des colonnes contenant des valeurs numériques sous forme de types numériques dans le DataFrame.
Nous pouvons le vérifier si nous regardons la description du DataFrame :
>>> baby_names.describe()
           BRTH_YR           CNT           RNK
count  13962.000000  13962.000000  13962.000000
mean    2011.880318     34.531657     56.944349
std        1.134940     40.176370     25.361691
min     2011.000000     10.000000      1.000000
25%     2011.000000     13.000000     38.000000
50%     2011.000000     20.000000     59.000000
75%     2013.000000     36.000000     78.000000
max     2014.000000    426.000000    102.000000
Vous pouvez voir que descrcibe () ne sélectionne que les colonnes contenant des données numériques.
Naturellement, certaines informations n’ont aucun sens, comme la colonne RNK (seul le compte est utile) ou la moyenne et la valeur standard dans BRTH_YR.
Vous avez peut-être remarqué que les colonnes du DataFrame ont des étiquettes identiques aux en-têtes du fichier CSV.
C'est une fonctionnalité intéressante dans Pandas qui devient utile lorsque vous n'avez pas besoin de connaître l'index de la colonne à laquelle vous souhaitez accéder.
Les DataFrames peuvent être triés le long de colonnes ou d'axes et la forme sera conservée après le tri.
Nous avons maintenant un véritable ensemble de données, alors essayons de trier.
Trouvons les cinq premiers noms avec le nombre le plus bas et le plus élevé dans toutes les données (rappelez-vous: nous avons des années de 2011 à 2014 - le tri comptera uniquement les valeurs min et max en fonction des données de chaque année et ne résumera pas les mêmes noms les années) :
>>> baby_names.head()
  BRTH_YR    GNDR    ETHCTY         NM  CNT  RNK
0     2011  FEMALE  HISPANIC  GERALDINE   13   75
1     2011  FEMALE  HISPANIC        GIA   21   67
2     2011  FEMALE  HISPANIC     GIANNA   49   42
3     2011  FEMALE  HISPANIC    GISELLE   38   51
4     2011  FEMALE  HISPANIC      GRACE   36   53
>>> baby_names.sort_values(by='CNT').head()
      BRTH_YR    GNDR                      ETHCTY          NM  CNT  RNK
8744      2012  FEMALE              WHITE NON HISP         MAE   10   83
6746      2011  FEMALE          WHITE NON HISPANIC       LEILA   10   81
2389      2011    MALE                    HISPANIC       ALLAN   10   94
11009     2013    MALE  ASIAN AND PACIFIC ISLANDER      Martin   10   57
11013     2013    MALE  ASIAN AND PACIFIC ISLANDER  Maximilian   10   57
>>> baby_names.sort_values(by='CNT', ascending=False).head()
     BRTH_YR  GNDR    ETHCTY      NM  CNT  RNK
1504     2011  MALE  HISPANIC  JAYDEN  426    1
5430     2011  MALE  HISPANIC  JAYDEN  426    1
7393     2011  MALE  HISPANIC  JAYDEN  426    1
3505     2011  MALE  HISPANIC  JAYDEN  426    1
9385     2012  MALE  HISPANIC  JAYDEN  364    1
Comme vous pouvez le constater, nous avons identifié un problème dans l'ensemble de données :
Nous avons des entrées qui ont le même contenu.
Cela rend nos données moins utilisables telles quelles et nous devons les ranger pour obtenir de véritables informations.
Mais c’est la bonne chose en science des données et nous examinerons une approche permettant de filtrer les doublons.

Conclusion

Nous avons vu que Pandas est la prochaine étape de l'analyse de données avec Python après NumPy, car il nous permet de mieux gérer les données.
Cependant, nous ne pouvons pas ignorer NumPy car Pandas s'appuie sur NumPy et matplotlib pour nous donner un point unique où vous pouvez analyser et visualiser vos données.
Les pandas tirent vraiment parti de cette fonctionnalité si nous importons des fichiers CSV avec un contenu mixte.
Vous n'avez pas à vous soucier des conversions.
Dans le prochain article, nous allons nettoyer nos données des doublons et procéder à quelques analyses pour visualiser notre ensemble de données avec matplotlib afin de fournir des informations à l’utilisateur.
Trouver et comparer des milliers d'outils de développement avec DiscoverSDK. (http://www.discoversdk.com)
Source : http://www.discoversdk.com/blog/introduction-to-pandas-data-analysis-in-python

Interface graphique en TCL/TK

Source : http://daniel.roche.free.fr/article_tcl/article.html
Source : https://www.developpez.net/forums/d1515474/dotnet/langages/interface-graphique-tcl-tk/
Source : http://sebsauvage.net/python/gui/index_fr.html
Source : https://docs.python.org/fr/3/library/tk.html

Autres types d'interface graphique

Source : https://python-guide-pt-br.readthedocs.io/fr/latest/scenarios/gui.html

Requête http asynchrone en Python

Source : https://terriblecode.com/blog/asynchronous-http-requests-in-python/

Tester aya

dpkg -i aya.deb

Django

Ok-ko.png Forum officiel : http://forum.django-fr.org
Ok-ko.png Apprendre Python - Django introduction : http://apprendre-python.com/page-django-introduction-python
Ok-ko.png Apprendre Python - Django : https://docs.djangoproject.com/en/1.10/intro/tutorial01/
Ok-ko.png Tutoriel Django : https://app.box.com/shared/pl4xlarirl
Ok-ko.png Tutoriel Django : https://python.developpez.com/tutoriels/reseau-web/apprendre-framework-django/

Compiler

Compiler avec python et cx freeze.

Simple DRY Tabs using Django 1.3

Django Snippets : https://djangosnippets.org/snippets/2421/

Bibliographie

Technical articles Django, Python, Linux, PHP, Web, Open Source par James Pic : http://blog.yourlabs.org
Apprendre la programmation Python : https://python.developpez.com/tutoriels/apprendre-programmation-python/les-bases/?page=ordinateur-et-programmation
Apprendre python 3.5 : https://inforef.be/swi/download/apprendre_python3_5.pdf
File handling : https://github.com/learnbyexample/Python_Basics/blob/master/File_handling.md
Text Processing : https://github.com/learnbyexample/Python_Basics/blob/master/Text_Processing.md

NAVIGATION

PARTICIPER ET PARTAGER

Vous êtes sur le wiki de Vision du Web.
Les pages présentées sur le wiki évoluent tous les jours.
Certaines recherches sont peu abouties et incluent des erreurs.
Pour participer sur le wiki, créer un compte utilisateur en haut à droite.
La recherche interne du wiki permet de trouver le contenu qui vous intéresse.
Identifiez-vous pour poser vos questions sur la page de discussion de VisionDuWeb.
Améliorer le contenu des pages en faisant des propositions depuis l'onglet discussion.
Pour écrire en Markdown : Éditeur - Générateur de tableau 1 - Générateur de tableau 2.
Les informations du wiki ne doivent pas servir à nuire à autrui ou à un système informatique.
De nombreux outils gratuits sont listés et disponibles dans la boîte à outils de Vision du web.
D'autres pages du wiki peuvent correspondre à vos attentes. La liste de toutes les pages du wiki.

VALORISER LE WIKI

Valoriser le contenu partagé sur le wiki avec un don en monnaie numérique :
AEON - Bitcoins (BTC) - Bitcoins Cash - Bitcoins Gold - Bitcore (BTX) - Blackcoins - Bytecoins - Clams - Dash - Monero - Dogecoins - Ethereum - Ethereum Classique - Litecoins - Potcoins - Solarcoins - Zcash

OBTENIR DE LA MONNAIE NUMERIQUE

Obtenir gratuitement de la monnaie numérique :
Gagner des Altcoins - Miner des Altcoins.
Miroir PlanetHoster du 1er Novembre 2018.