pense-bête de bruno sanchiz

python en virtuel

bruno — 2023-07-11T13:37:34Z

Pour permettre l'utilisatio nde python dans toutes les situations, il a été décidé de metrte en avant la virtualisation :

https://peps.python.org/pep-0668/

et donc on utilise comme ça :
python3 -m venv /tmp/venv ; source /tmp/venv/bin/activate ; pip install --upgrade pip ; pip3 install matplotlib numpy opencv-python opencv-contrib-python tensorflow

erreurs : Could not build wheels for dlib, erreur apparue pour installer face-recognition

, d'après https://learnopencv.com/install-dlib-on-ubuntu/
installation de face_recognition

sudo apt-get install cmake build-essential libopenblas-dev liblapack-dev pkg-config libx11-dev libatlas-base-dev libgtk-3-dev libboost-python-dev python3-dev python3-pip virtualenv virtualenvwrapper

source /usr/share/virtualenvwrapper/virtualenvwrapper.sh mkvirtualenv facecourse-py3 -p python3 workon facecourse-py3 pip install numpy scipy matplotlib scikit-image scikit-learn ipython wheel numpy scipy matplotlib scikit-image scikit-learn ipython pip3 install numpy virtualenv virtualenvwrapper # now install python libraries within this virtual environment pip install numpy scipy matplotlib scikit-image scikit-learn ipython # quit virtual environment deactivate

opencv

bruno — 2023-03-18T23:17:17Z

imports

import cv2 import numpy as np import matplotlib.pyplot as plt import matplotlib

image

img = cv2.imread('a.jpg')
cv2.imshow("kk",img)
cv2.waitKey(0)
print(image.shape) #hauteur,largeur,canaux

dessiner une ligne :
img = cv2.line(img, pt1, pt2, color[, thickness[, lineType[, shift]]])
plt.imshow(image_line[ :, :, : :-1])
dessiner un cercle
img = cv2.circle(img, center, radius, color[, thickness[, lineType[, shift]]])
dessiner un rectangle
img = cv2.rectangle(img, pt1, pt2, color[, thickness[, lineType[, shift]]])
insérer un texte
img = cv2.putText(img, text, org, fontFace, fontScale, color[, thickness[, lineType[, bottomLeftOrigin]]])

functions sur images :

ajouter : cv2.add(im1,im2)
soustraire : cv2.substract(im1,im2)

RVB <-> BVR

B,V,R =img[x,y]
R,V,B=img[ :, :, : :-1] [x,y]

crop

cropped_region = img[y1:y2,x1:x2]

changement de taille, resize

cv2.resize(img, None, fx = 2, fy = 2)
cv2.resize(img, dsize = (200,400), interpolation = cv2.INTER_AREA)

flip

<-> : cv2.flip(img_eagle, 1)
vert : cv2.flip(img_eagle, 0)
rot 180 : cv2.flip(img_eagle, -1)

aruco detecteurs

for i in range(1000): dictionary = cv2.aruco.getPredefinedDictionary(cv2.aruco.DICT_6X6_1000) parameters = cv2.aruco.DetectorParameters() img=cv2.aruco.generateImageMarker(dictionary,i,200) cv2.imwrite("/tmp/aa/f"+str(i)+".jpg",img)

décorateur décorator

bruno — 2022-11-25T01:56:50Z

Un décorateur agit sur la sortie d'une fonction , sans la remplacer directement.
Quand la fonction est appelée, c'est le décorateur qui est appelé.

Par exemple avec une fonction

def decorateur(f): def g(a,b): print( "le résultat est {}".format(f(a,b))) return g @decorateur def ajoute(a,b): return a+b @decorateur def mult(a,b): return a*b

ajoute(5,3) affichera le résultat est 8
au lieu de retourner 8
mult(2,4) affichera le résultat est 8
Attention : le simple fait d'utiliser la fonction provoque l'affichage :
c=ajoute(5,6) affiche le résultat est 11

succession de décorateurs :

def decorateur2(f): def h(a,b): print( "Dans l'ensemble des réels, {}".format(f(a,b))) return h def decorateur(f): def g(a,b): return "le résultat est {}".format(f(a,b)) return g @decorateur2 @decorateur def div(a,b): return a/b div (5,4)

Dans l'ensemble des réels, le résultat est 1.25

On peut généraliser le décorateur :

def decorateur(f): def g(*args,**kargs): print( "le résultat est {}".format(f(*args,**kargs))) return g

decorateur debug :
def decorateur_debug(f) :
def g(*args,**kargs) :
if debug==True :
print(f.__name__+" :"+f.__doc__)
return f(*args,**kargs)
return g

https://zestedesavoir.com/tutoriels/954/notions-de-python-avancees/2-functions/3-decorators/#fn-approximation_decorateur

flask

bruno — 2022-11-14T14:26:47Z

installation
espace virtuel
premier programme
documentations

Installation

# sudo apt-get install python3-pip python3-venv

Création d'un espace virtuel

mkdir -p microblog && cd microblog python3 -m venv venv virtualenv venv source venv/bin/activate

premier programme

(venv) $ pip install flask gunicorn (venv) $ mkdir -p app

app/__init__.py

from flask import Flask app = Flask(__name__) from app import routes

app/routes.py

from app import app @app.route('/') @app.route('/index') def index(): return "Hello, World!"

microblog.py
from app import app

microblog/ venv/ microblog.py app/ __init__.py routes.py

démarrage du serveur

Méthode 1

(venv) $ export FLASK_APP=microblog.py (venv) $ flask run

* Serving Flask app "microblog" * Running on http://127.0.0.1:5000/ (Press CTRL+C to quit)

Méthode 2
gunicorn -b localhost:8000 -w 4 microblog:app

livres

Flask Web Development, 2-nd edition.pdf
Python for DevOps - Grig Gheorghiu & Alfredo Deza & Kennedy Behrman & Noah Gift.pdf
the-new-and-improved-flask-mega-tutorial.pdf

utilisation de python3-plotly - Python 3...

bruno — 2020-05-08T00:02:24Z

utilisation de python3-plotly - Python 3 plotting library for publication-quality graphs
https://plotly.com/python/
d'après : http://gael-varoquaux.info/slides_etalab_2020

exemples

import json with open('geojson-counties-fips.json',"r") as response: JSON = json.load(response) #JSON : dict et list #JSON["features"][0 à N-1] sont les N surfaces #JSON["features"][0]['id'] === CSV['fips'] #JSON["features"][0]['geometry']['type']='Polygon' #JSON["features"][0]['geometry']['coordinates']=[[[-86.496774, 32.344437], [-86.717897, 32.402814], [-86.814912, 32.340803], [-86.890581, 32.502974], [-86.917595, 32.664169], [-86.71339, 32.661732], [-86.714219, 32.705694], [-86.413116, 32.707386], [-86.411172, 32.409937], [-86.496774, 32.344437]]]

import pandas CSV = pandas.read_csv("fips-unemp-16.csv",dtype={"fips": str}) #CSV['fips'] et CSV['unemp']

Une carte des USA où la couleur des surfaces identifiées par JSON["features"][0]['id'] === CSV['fips'] est donnée par la valeur de CSV['unemp'] en allant de 0 à12.

import plotly.express as px fig = px.choropleth(CSV, geojson=JSON, locations='fips', color='unemp', color_continuous_scale="Viridis", range_color=(0, 12), scope="usa", labels={'unemp':'PRG3:unemployment rate'}) fig.update_layout(margin={"r":0,"t":0,"l":0,"b":0}) fig.show()

On obtient :

Attention, il y a de nombreux appels externes : creativecommons.org , openstreetmap.org , mapbox.cn , mapbox.com , carto.com , cartodb-basemaps-c.global.ssl.fastly.net , cdn.plot.ly , get.webgl.org , github.com , plotly.com , stamen-tiles.a.ssl.fastly.net , stamen.com , www.w3.org ,

exemples avec le coronavirus : voir coronavirus

module : subprocess

bruno — 2018-01-30T14:14:49Z

https://docs.python.org/2/library/subprocess.html#replacing-shell-pipeline

subprocess.call(["ls", "-l"])

HelloWorld=subprocess.check_output(["echo", "Hello World!"])

tokenization correcte :

import shlex, subprocess args = shlex.split("blender -b file.blend -o //file -F JPEG -x 1 -f 1") print (args) On obtient : ['blender', '-b', 'file.blend', '-o', '//file', '-F', 'JPEG', '-x', '1', '-f', '1'] Ensuite : p1 = Popen(['blender', '-b', 'file.blend', '-o', '//file', '-F', 'JPEG', '-x', '1', '-f', '1'], stdout=PIPE) res=p1.communicate()[0]

pipeline avec le symbole | , par exemple : dmesg | grep hda

p1 = Popen(["dmesg"], stdout=PIPE) p2 = Popen(["grep", "hda"], stdin=p1.stdout, stdout=PIPE) p1.stdout.close() # Allow p1 to receive a SIGPIPE if p2 exits. output = p2.communicate()[0]

os.system()
status = os.system("mycmd" + " myarg")
devient
status = subprocess.call("mycmd" + " myarg", shell=True)
ou

try: retcode = call("mycmd" + " myarg", shell=True) if retcode < 0: print >>sys.stderr, "Child was terminated by signal", -retcode else: print >>sys.stderr, "Child returned", retcode except OSError as e: print >>sys.stderr, "Execution failed:", e

Classes Python

bruno — 2017-10-26T01:35:19Z

Une classe est un objet qui a déjà des valeurs, des propriétés. Une classe est un programme qui sait déjà faire des choses évoluées et spécifiques.

On écrit import scipy,re pour importe les classes scipy et re. On peut alors utiliser l'objet fftpack contenu dans scipy en écrivant scipy.fftpack
On écrit from scipy import fftpack pour importer l'objet scipy.fftpack. On peut alors utiliser l'objet fftpack contenu dans scipy en écrivant fftpack

différentes classes utiles :

classe wave :
https://docs.python.org/2/library/w...

classe re :
https://docs.python.org/2/library/r...

classe scipy # apt-get install python3-scipy
https://docs.scipy.org/doc/scipy/re...

from scipy import fftpack
https://docs.scipy.org/doc/scipy/re...

classe matplotlib apt-get install python-matplotlib python3-matplotlib
http://matplotlib.org/api/pyplot_ap...
import matplotlib.pyplot as plt

classe pylexique https://pylexique.readthedocs.io/fr...
python3 -m venv /tmp/ytdlp-poub&& source /tmp/ytdlp-poub/bin/activate && pip install pylexique

print(pylexique.Lexique383().lexique["manger"][1].phon) = "m@Ze"

https://sekoudiaonlp.github.io/pylexique/fr_FR/readme.html

"ortho": "manger", "phon": "m@Ze", "lemme": "manger", "cgram": "NOM", "genre": "m", "nombre": "s", "freqlemfilms2": 5.62, "freqlemlivres": 4.05, "freqfilms2": 5.62, "freqlivres": 4.05, "infover": "", "nbhomogr": 2, "nbhomoph": 7, "islem": True, "nblettres": 6, "nbphons": 4, "cvcv": "CVCCVC", "p_cvcv": "CVCV", "voisorth": 9, "voisphon": 12, "puorth": 6, "puphon": 4, "syll": "m@-Ze", "nbsyll": 2, "cv_cv": "CV-CV", "orthrenv": "regnam", "phonrenv": "eZ@m", "orthosyll": "man-ger", "cgramortho": "NOM,VER", "deflem": "100", "defobs": "33", "old20": 1.35, "pld20": 1.25, "morphoder": "manger", "nbmorph": "1"

créer sa classe perso :

CFR.py :

class CFichiersRepertoires(object): g=9.81#Ici Une Variable Commune A Tous Les CFichiersRepertoires() def __init__(self,vit=0.0): self.vitesse=vit self.vitesse=10.5#Ici Une Variable Différente pour chaque élément

importer sa classe perso depuis un dossier :

dossier="PROGRAMMATION/PYTHON/DOC/CLASSES" if dossier not in sys.path: sys.path.append(dossier) import CFR from CFR import CFichiersRepertoires

les classes prédéfinies : https://www.python-course.eu/python3_magic_methods.php

Binary Operators
Operator Method

+ object.__add__(self, other) - object.__sub__(self, other) * object.__mul__(self, other) // object.__floordiv__(self, other) / object.__truediv__(self, other) % object.__mod__(self, other) ** object.__pow__(self, other[, modulo]) << object.__lshift__(self, other) >> object.__rshift__(self, other) & object.__and__(self, other) ^ object.__xor__(self, other) | object.__or__(self, other)

Extended Assignments
Operator Method

+= object.__iadd__(self, other) -= object.__isub__(self, other) *= object.__imul__(self, other) /= object.__idiv__(self, other) //= object.__ifloordiv__(self, other) %= object.__imod__(self, other) **= object.__ipow__(self, other[, modulo]) <<= object.__ilshift__(self, other) >>= object.__irshift__(self, other) &= object.__iand__(self, other) ^= object.__ixor__(self, other) |= object.__ior__(self, other)

Unary Operators
Operator Method

- object.__neg__(self) + object.__pos__(self) abs() object.__abs__(self) ~ object.__invert__(self) complex() object.__complex__(self) int() object.__int__(self) long() object.__long__(self) float() object.__float__(self) oct() object.__oct__(self) hex() object.__hex__(self

Comparison Operators
Operator Method

< object.__lt__(self, other) <= object.__le__(self, other) == object.__eq__(self, other) != object.__ne__(self, other) >= object.__ge__(self, other) > object.__gt__(self, other)

module re : match et find divers

bruno — 2017-10-26T00:53:29Z

import re

Etude de

<tr class='row_odd odd'><td>anciennes commandes net-tools</td><td>commandes iproute2 de remplacement</td></tr> <tr class='row_even even'><td>arp</td><td>ip n (ip neighbor)</td></tr> <tr class='row_odd odd'><td>ifconfig</td><td>ip a (ip addr), ip link, ip -s (ip -stats)</td></tr> <tr class='row_even even'><td>iptunnel</td><td>ip tunnel</td></tr> <tr class='row_odd odd'><td>nameif</td><td>ip link</td></tr> <tr class='row_even even'><td>netstat</td><td>ss, ip route (pour netstat -r), ip -s link (pour netstat -i), ip maddr (pour netstat -g)</td></tr> <tr class='row_odd odd'><td>route</td><td>ip r (ip route)</td></tr>

Etude de tmp='ID_VIDEO_WIDTH=300 ID_VIDEO_HEIGHT=200'

m=re.match(r".*WIDTH=([0-9]*).*HEIGHT=([0-9]*)[^0-9]*",str(tmp)) W,H=m.groups() print(W,H) 300 200

documentation pour python

bruno — 2017-10-26T00:53:18Z

fonction internes :
https://docs.python.org/3/library/functions.html

NON vérifiés :

http://python.developpez.com/cours/apprendre-python3/
http://greenteapress.com/wp/think-python/

python pour android :
http://kivy.org/docs/guide/basic.html
https://code.google.com/p/android-scripting/
kivy
https://github.com/kivy/python-for-android
qpython , jython
http://www.openbookproject.net/thinkCSpy
http://greenteapress.com/wp/think-python/
http://lanyrd.com/2012/europython/srzmt/
http://thp.io/2012/europython/

import androidhelper
droid = android.Android()
droid.makeToast('hello')
[/code]
Bottle exemple :
[code]
from bottle import route, run, template, request
@route('/')
@route('/index')
def index() :
return template('''Hello World''')

frameworks

bruno — 2017-05-26T23:30:15Z

Page générale des webframeworks : https://wiki.python.org/moin/WebFrameworks/

django
- The Web framework for perfectionists (with deadlines). Django makes it easier to build better Web apps more quickly and with less code. Django is a high-level Python Web framework that encourages rapid development and clean, pragmatic design. It lets you build high-performing, elegant Web applications quickly. Django focuses on automating as much as possible and adhering to the DRY (Don't Repeat Yourself) principle. See Django
web2py
- Python 2.6 to 2.7, Python 3.x friendly (compile but not tested no support yet) * All in one package with no further dependencies. Development, deployment, debugging, testing, database administration and maintenance of applications can be done via the provided web interface, but not required. * web2py has no configuration files, requires no installation, can be run off a USB drive. * web2py uses Python for the Model, View and the Controller * Built-in ticketing system to manage errors * Internationalization engine and pluralisation, caching system * Flexible authentication system (LDAP, MySQL, janrain etc) * NIX(Linux, BSD), Windows, Mac OSX, tested on EC2, Webfaction * works with MySQL, PostgreSQL, SQLite , Firebird, Oracle, MSSQL and the Google App Engine via an ORM abstraction layer. * Includes libraries to handle HTML/XML, RSS, ATOM, CSV, RTF, JSON, AJAX, XMLRPC, WIKI markup. * Production ready, capable of upload/download of very large files * Emphasis on backward compatibility.
Flask
- flask (0.12.1 Released 2017-03-31) is “a microframework for Python based on Werkzeug, Jinja 2 and good intentions.” Includes a built-in development server, unit tesing support, and is fully Unicode-enabled with RESTful request dispatching and WSGI compliance.

kivy
- python-kivy - Kivy - Multimedia / Multitouch framework in Python (Python 2) python-kivy-examples - Kivy - Multimedia / Multitouch framework in Python (examples) python3-kivy - Kivy - Multimedia / Multitouch framework in Python (Python 3)

différentes réflexions sur les frameworks

django, flask, pyramid : https://web.archive.org/web/20171008162318/https://www.airpair.com/python/posts/django-flask-pyramid
CubicWeb, Django, Pyramid, Web.py, Web2py, and Zope 2 : http://www.infoworld.com/article/2622836/application-development/pillars-of-python--six-python-web-frameworks-compared.html
- zope2 : 15 années de de développement
- web2py : python embeddable language
- django : an object-relational mapper so that you don't have to write your own RDBMS interface code, a template system so that you don't have to wrestle with marrying active Python content to static HTML content on a Web page, an administrative interface so that you can easily access your site's back-end data (as well as easily manage website users and permissions), and so on. You should expect to spend a stretch learning Django's API, but the time you put into Django is well worth it. It's a rich environment with much to recommend it.
- cubicweb : constructing a CubicWeb application entails lashing together modules (called cubes) into a final structure :
```
 echo "deb http://download.logilab.org/production/ jessie/">>/etc/apt/sources.list && wget -O/etc/apt/trusted.gpg.d/logilab.gpg https://www.logilab.fr/logilab-debian-keyring.gpg && apt-get update && apt-get install cubicweb cubicweb-dev cubicweb-mysql-support
```