[PYTHON] Convention de code, table de correspondance des méthodes

#python

--sql

[]( "Commande à afficher sur cette page" python pandas numpy matplotlib Autre sql R )

[]( Comment écrire cette page

# # # # Grand en-tête: Exemple "Convention de code", "Table de correspondance des méthodes"

# # En-têtes: "Extraire les colonnes", "Extraire certains enregistrements"

‘‘‘ python code commentaire ・ Écrivez tous les commentaires ici, pas dans le texte )

Code conventions_rules pour chaque langue

python

convention de code python

#python
df_used_method1_used_method2\
    = df.copy()\
        .used_method1()\
        .used_method2()\

Comment écrire .py

1.Description de la fonction elle-même
"""Écrivez une description ici"""

2.Import de bibliothèque
import pandas as pd

3.Spécification des variables
START_DATE = 20200527

4.main()Définition de la fonction utilisée dans
def func1(parameter1:str) -> pd.DataFrame:

5.main()Définition de
def main()

6.
if __name__ == "main":
    main()

Comment écrire une fonction

def func1(parameter_path:str, parameter_date:int, parameter_df:pd.DataFrame) -> pd.DataFrame:
    """
Ecrire une docstring
    """

Comment écrire argparse

#main()Cela semble nécessaire lors de la prise d'un argument dans

Comment écrire la journalisation

SQL

--sql
select
    datamart1.column1
    , datamart1.column2
    , datamart2.column3
from
    datamart1
        left join
    datamart2
        on = column2
where
    datamart1.column1 > 10
;

select
    column1
    , column2
    , sum(column3)
    , avg(column4)
from
    datamart1
group by
    column1
    , column2
;

Règles SQL

• Tout, minuscules
• Le retrait est comme ci-dessus

Méthode de correspondance table_data liée à l'analyse

Compréhension des données / préparation des données des données de table

Vérification de l'unicité de la clé

#python

--sql

Vérification des enregistrements en double

#python

--sql

Extraction de colonne

#python

#Extrait au format série
df.loc[:,'column']

df['column']

df.column

#Extrait au format de trame de données
df.loc[:,['column1','column2']]

df[['column1','column2']]

--sql
select
    column1
from
    datamart
;

select
    *
from
    datamart
;

Extraire quelques enregistrements

#python
df.head(10)

--sql
select top(10)
    column1
from
    datamart
;

select
    column1
from
    datamart
limit
    10
;

Extraire les colonnes sans duplication

#python
df.drop_duplicates()

--sql
select unique
    *
from
    datamart
;

Ajouter une colonne

#python
df_assign\
    = df.copy()\
        .assign(column = 10)

df['column'] = 10

--sql
select
    10 as column1
from
    dataframe
;

Extraire les enregistrements qui correspondent aux conditions

#python
df_query_loc\
    = df.copy()\
        .query('column1 == 10')\
        .loc[:,['column1','column2']]

df[df.column1 == 10, ['column1','column2']]

--sql
select
    column1
from
    datamart1
where
    column1 == 10
;

select
    column1
    , count(column1)
from
    datamart1
group by
    column1
having
    count(column1) == 10
;

Changer le nom de la colonne

#python
df.rename(columns = {'column1':'new_column1','column2':'new_column2'})

pd.DataFrame(df.values, columns = ['new_column1','new_column2'])

df.columns = ['new_column1','new_column2']

df.columns = 'new_' + df.columns

--sql
select
    column1 as new_column1
from
    datamart1
;

Combiner df

#python
pd.merge(
    df1,
    df2,
    on = ['column1','column2'],
    how = 'left')

pd.merge(
    df1,
    df2,
    left_on  = ['column1','column2'],
    right_on = ['column3','column4'],
    how = 'left')

df1.merge(
    df2,
    on = 'column1',
    how = 'left')

--sql
select
    datamart1.column1
    , datamart1.column2
    , datamart2.column3
from
    datamart1
        left join
    datamart2
        on = column2

Concat qui combine plusieurs données en une seule donnée

#python_pandas
#Verticale
pd.concat([df1,df2],axis=0)

df1.append(df2)

#côté
pd.concat([df1,df2],axis=1)

#python_numpy
#Verticale
np.concatenate([nparray1,nparray2], axis=0)

#côté
np.concatenate([nparray1,nparray2], axis=1)

--sql
select
    column1
from
    datamart1
union -- union all / intersect / except
select
    column2
from
    datamart2

Nombre de lignes

#python
len(df)

--sql
select
    count(*)
from
    datamart1
;

Vérifiez la nature des données

#python
#Contrôle de forme
np.array().shape

Tri

#python
df.sort_values()

--sql
select
    *
from
    datamart1
order by
    column1

Traitement des fonctions de fenêtre

#python

--sql

Générer des données

#python
#Générer nparray avec toutes les mêmes valeurs
#Exemple, 3D
np.tile(Nombres, (n, n, n))

Notation d'inclusion de liste

[i for i in range(100)]

#Lors de l'utilisation de l'instruction if
[i for i in range(100) if i > 50]

Agrégation

#python
df\
    .groupby(['column1','column2'])\
    .agg({'column3':'sum',
          'column4':'mean'})\
    .reset_index()

-- sql
select
    column1
    , column2
    , sum(column3)
    , avg(column4)
from
    datamart1
group by
    column1
    , column2
;

Ne comptez que des éléments spécifiques lors de l'agrégation

df_tmp\
    .groupby('column1')\
    .agg({'column2':'nunique'})

Effectuer plusieurs opérations sur une seule colonne lors de l'agrégation

df_tmp\
    .groupby('column1')\
    .agg({'column2':['sum', 'min', 'max']})

Faites le calcul

#python
#moyenne
np.average(nparray, axis = n)
#Pour les données de deux dimensions ou plus, le résultat dépend de la dimension moyenne.

np.array().mean()

#division
np.array(nparray1, nparray2)

Diviser une chaîne avec des symboles spécifiques

#Obtenir au format liste
str_data.split('Chaîne spécifique')

Extraire les n derniers caractères de la chaîne

str_data[-n]

Supprimer les n derniers caractères de la chaîne

str_data[:-n]

Vérifiez si les données de texte contiennent une chaîne de caractères spécifique

str_data.find('Chaîne de caractères à rechercher')
#Si la chaîne est incluse"1"Si non inclus"-1"

Traitement des données d'image

Lecture des données d'image

#python
import cv2
cv2.imread('filename.png')

#python
import PIL
PIL.image.open('filename.png')

Affichage des données d'image

#python
cv2.imshow("image_name", cv2.imread('filename.png'))
#"image_name"Est éventuellement défini

#python
PIL.image.open('filename.png').show()

Conversion de données d'image

#python
#Conversion de données d'image np
image = PIL.image.open('filename.png')
np.array(image)

Extraire une partie de l'image

#python
np.array(image)[Pixel supérieur:Pixel inférieur,Pixel gauche:Pixel droit]

Ajouter à l'image

#python

#Ajouter un carré
plt.figure()
plt.grid(false)
cv2.rectangle(np.array(image), (Pixel droit,Pixel supérieur), (Pixel gauche,Pixel inférieur), (255, 255, 255), 4)
plt.imshow(np.array(image),cmap='gray',vmin=0,vmax=65555)

Conversion d'image

signal.convolve2D

Prise en charge du format TIF

#Changer le nombre d'images à extraire avec le dernier numéro
Image.open('~.tif').seek(0)

Processus de visualisation

Taille d'image à afficher

#python
plt.figure(figsize = (6,4))

Spécifier la plage du graphique à afficher

#python
plt.x_lim([droite,la gauche])
plt.y_lim([Vers le haut,en dessous de])

Rendre l'image à afficher carrée

#python
aspect = (ax.get_x_lim()[1] - ax.get_xlim()[1]) / (ax.get_y_lim()[1] - ax.get_y_lim()[0])
ax.set_aspect(aspect)

Rendre l'arrière-plan transparent

#python
fig.patch.set_alpha(0)
#Seule la figue est prise en charge

Correspondance des lignes de quadrillage

#python

#Ne pas afficher les lignes de quadrillage

Affichage de plusieurs images

#python

#Utiliser 1, sous-tracé
plt.subplot(Verticale,côté,1)
plt.plot(~)
plt.subplot(Verticale,côté,2)
plt.plot(~)
↓
plt.subplot(Verticale,côté,Verticale×côté)
plt.show(~)

#2、add_Utilisez le sous-tracé,
ax1 = plt.figure().add_subplot(Verticale,côté,1)
ax1 = plot(~)
↓
plt.show()

#Utiliser 3, sous-parcelles
fig, axes = plt.subplots(~, figsize=(6,4)) #fig, n'est pas utilisé
axes[1].plot

Afficher le japonais

#python
#Processus à l'aide de la bibliothèque

la modélisation

Correspondance de méthode table_coding general

Traitement des données de temps

Calcul du temps de traitement

#python
import time
#Début du traitement
time_start = time.time()
#Fin de traitement
time_end   = time.time()
print(time_end-time_start)

Convertir les données de date et d'heure du type de caractère au type d'heure

import datetime
from dateutil.relativedelta import relativedelta

date_datetime = datetime.datetime.strptime('2020-05-24', '%Y-%m-%d')

Convertir les données de date et d'heure du type de caractère au type d'heure

import datetime
from dateutil.relativedelta import relativedelta

datetime.datetime.strftime(date_datetime, '%Y-%m-%d')

Différence de données de date et d'heure

date_datetime + datetime.timedelta(days=7)
date_datetime + relativedelta(weeks = 1)

Obtenez des informations sur le jour à partir des données de date et d'heure

datetime.weekday(date_datetime)

Traitement des chemins

Chargement des fonctions à partir du fichier py

#python
#annuaire"src"Lisez la fonction dans le fichier suivant
import sys
sys.path.append('src/')
from filename.py import func_name

Lire les données sur le serveur Windows

#python
import pathlib
filepath = r'chemin_nom de fichier.csv'
read_file = pathlib.WindowPath()

Extraire des fichiers dans un répertoire spécifique

import glob
glob.glob('path/*')

Créer un chemin s'il n'y a pas de chemin

import os

if os.path.exists(path_name) == False
    os.makedirs(path_name)

Charger et enregistrer des fichiers

Lire le fichier

#python_pandas

#Lire df
pd.DataFrame(data,columns=[column1,column2])

pd.read_csv('filename')

#python_numpy

#Chargement de npz
np.load(filename)

Enregistrer le fichier

#python_pandas

#Lire df
pd.DataFrame().to_csv('filename', index=False)

#python_numpy

#Enregistrer npz
np.savez(pathname, filename1 = np.array('1'), filename2 = np.array('2'))

#python_matplotlib
#Enregistrer l'image
plt.savefig('filename')

#python_sklearn
#Enregistrer le modèle
import sklearn
import pickle
reg = sklearn.LinearRegression().fit(x,y)
with open('filename.pickle', mode = 'wb', as f
    pickle.dump(reg, f)

Traitement des itérations

Itération multi-éléments

#zip
for i_column1, i_column2 in zip(df_tmp.column1, df_tmp.column2):

#itertools
for i,j in 
    permutations(i,j):permutation
    combinations(i,j):combinaison
    products(i,j):Produit direct

Entrez le numéro de l'itération

for i in enumerate(df_tmp.column):

À propos des fonctions / classes

une fonction

#def, utiliser
def_func_name(parameter1, parameter2):
En traitement
return Valeur de retour

#Utilisez lambda,
lambda parameter:Formule de retour(parameter)

#Utilisez lambda,_Exprimé en une ligne
(lambda parameter:Formule de retour(parameter))(parameter_instance)

classe