#!/usr/bin/env/ python								- Maj : 18/02/2025 -

====== LIBRAIRIES - Import
from librairie_exemple import *
from math import sqrt
import math


====== VARIABLES

typage dynamique : 
x=2
chaine="la chaine"
y=3.1415

Binaire :
Utilisation du prefixe 0b. Attention, le type d'une variable prefixee 0b est : entier (represente un nombre en base 10)
>>> type(0b10011)
<class 'int'>

==== Casting / Transtypage :

x = int(2.5)    # x will be 2
y = float(2.8)   # y will be 2.8
z = float("3")   # z will be 3.0
z = str(3.0)  # z will be '3.0' 
t = int(0b00111000) # t will be 56

b = 56; bnew = b.to_bytes(2, 'big')    # bnew will be b'\x008'
# 2: longueur du tableau en octets    'big': byteorder, "little" si MSB se trouve a la fin - pour 'big', c'est l'inverse.

n=10; print(format(n, '08b'))
# ====> resultat : 00001010     codage sur 8 bits de l'entier.

===== BOOLEENS
True, False (attention a la majuscule !)
(9==1)
(9>1)

Operateur logiques booleens --> and, or, not    #(equivalents python pour &&, ||, ! dans d'autres langages, comme le C)
Operateurs booleens arithmetiques (on fait des calculs) --> & (et) , | (ou) , not (non),  ^ (xor)

len(variable_chaîne) # longueur de la chaîne 
id(var) # adresse memoire de var
type(var) # donne le type

====== Conditionnel

if (condition):
    instruction
elif
    instruction2
else:
    instruction3
    
Ne pas oublier les ":" apres if et else

====== Instructions repetitives / boucles

while (a<7):
    a=a+1
    print(a)
    
nom="cleopatre"
for car in nom:
    print(car+'*', end=' ')

liste = ['chien', 'chat']
    for animal in liste:
        print("Longueur chaine ",animal," = ",len(animal))

for i in range(5):
    print(i, end=", ") # prints: 0, 1, 2, 3, 4, 
    
# Example with two arguments
for i in range(-1, 5):
    print(i, end=", ") # prints: -1, 0, 1, 2, 3, 4, 

# Comprehension de liste Vs Boucle classique :
# Comprehension de liste
list =[ 3.1, 1.8, 9.2, 3.3 ] liste_arrondis = [math.floor(i) for i in list]
#Boucle classique
list =[ 3.1, 1.8, 9.2, 3.3]
liste_arrondis = [ ]
for i in list :
    x = floor(i)
    list_arrondis.append(x)

==== Afficher / Lire

print("Ceci est un texte", sep=" ", end="")
print('We are the {} who say "{}!"'.format('knights', 'Ni'))

for x in range(1, 11):
    print('{0:2d} {1:3d} {2:4d}'.format(x, x*x, x*x*x))

>>>coord = (3, 5)
>>>'X: {0[0]};  Y: {0[1]}'.format(coord)
Resultat : 'X: 3;  Y: 5'

>>>"int: {0:d};  hex: {0:x};  oct: {0:o};  bin: {0:b}".format(42)
Resultat : 'int: 42;  hex: 2a;  oct: 52;  bin: 101010'
# with 0x, 0o, or 0b as prefix:
>>>"int: {0:d};  hex: {0:#x};  oct: {0:#o};  bin: {0:#b}".format(42)
Resultat : 'int: 42;  hex: 0x2a;  oct: 0o52;  bin: 0b101010'

Utilisation des f-Strings :
print(f"val a : {a} et val b : {b}") # les accolades permettent la saisie des variables directement dans la zone de texte entre guillemets  

# ******* ENTREE UTILISATEUR

x = int(input("Entrez un entier : "))       #la saisie est reçue par x et castee (String>int)
x, y = int(input("Entrez 2 entiers : ")), int(input())      # pour 2 var.



===== TABLEAUX

Listes :

>>> jour = ['lundi', 'mardi', 1800, 'Jeudi']
>>> print(jour[1])

Remplacement d'1 element :
>>> jour[1] = 'Mercredi'

nombre d'elements de la liste :
>>> print(len(jour))
suppression d'un element :
>>> del(jour[0])
Ajout d'un element :
>>> jour.append('samedi')

Slicing / sous-chaînes :
jour[1:3] designe le sous-ensemble ['mardi',1800, 'Jeudi']

===== Try / Except :

try:
  print(varX)
except NameError:
  print("varX n'est pas definie ")
except:
  print("une autre erreur est apparue.")

# ***** AVEC AFFICHAGE DE L'ERREUR / DETAILS :
try:
    print(varX)
except Exception as e:
    print(type(e))
    print (e.args)
    print (e)

===== FONCTIONS

def maFonction(parametres):
      bloc d'instructions

def compteur(limite, increment):
    i = 0
    while i < limite:
        print(i)
        i = i + increment
======
# Fonction join()

myTuple = ("John", "Peter", "Vicky")
x = "#".join(myTuple)
print(x)
# ====> Resultat : John#Peter#Vicky

# Fonction strip() (supprimer les espaces)

# basique :
s = '  ceci est une chaine  '
s = s.strip()
# sortie  ====> 'ceci est une chaine'
# avec un caractere en parametre :
s = 'uuu urlu ceci est une chaine uu'
s = s.strip("u")
# sortie  ====> 'urlu ceci est une chaine'
# supression des espaces a gauche et a droite :
s = s.lstrip()
s = s.rstrip()


**************************************************
Instruction with (gestion de ressources : manipulation de fichiers,...)
Interet : simplification de la gestion des ressources, pas besoin de fermer un fichier apres utilisation, etc...

with open('mon_fichier.txt', 'r') as fichier:
    contenu = fichier.read()

Autre exemple :
---------------

 import base64
# read image, encode in base64 format :
 with open("my_image.png", "rb") as f:
    png_data = f.read()
    png_encoded = base64.b64encode(png_data)

#Then, you encode base64 string into base2 string:
encoded_b2 = "".join([format(n, '08b') for n in png_encoded])
print(encoded_b2)

# Ici, base64 est un module standard de Python qui fournit des fonctions pour encoder/ decode en utilisant l'encodage Base64.
# png_encoded => les donnees binaires sont encodees en Base64 pour obtenir une representation textuelle.
# f est un objet de type fichier, ouvert en mode binaire ("rb")

# Convertir les bytes encodes en une chaîne de caracteres (optionnel) :
png_encoded_str = png_encoded.decode('utf-8')

# Although, you may decode base2 string into png file:
decoded_b64 = b"".join([bytes(chr(int(encoded_b2[i:i + 8], 2)), "utf-8") for i in range(0, len(encoded_b2), 8)])
with open('/dir_exemple/out_fic_decoded.png', 'wb') as f:
    f.write(base64.b64decode(decoded_b64))




**************************************************
# Methode pour executer des commandes (process) sur l'hôte :
import subprocess
subprocess.Popen(['/usr/bin/ls', '-lh'])

***************************************************
#
# GESTION DE FICHIERS
#

fichier = open('fichier.txt', 'r')
contenu = fichier.read()
print(contenu)
fichier.close()

with open('fichier.txt', 'mode') as fichier:    # mode peut etre : r, w, a, r+, w+, w+, rb, wb, ab, rb+, wb+, ab+
    contenu = fichier.read()                    # r : lecture - w : ecriture - a : ajout - r+ : lecture+ecriture - a+ : lecture et ajout - ...
    print (contenu)


with open("mon_fichier.txt", "w") as fichier:
    fichier.write("exemple de texte : nouveau contenu.\n")

with open('exemple.txt', 'a') as fichier:
    fichier.write('\nAjout d\'une nouvelle ligne.')


Methodes

read()
#Lit l integralite du fichier.

readline()
#Lit le fichier ligne par ligne.

readlines()
#Lit chaque ligne du fichier et retourne une liste de chaines de caracteres.

read(n)
#Lit un nombre specifique de caracteres du fichier. Si n n’est pas specifie, lit le reste du fichier a partir de la position actuelle.

******************
# 2 variantes pour afficher les lignes d'un fichier :

fichier = "/directoy/thatFile.txt"

with open(fichier, 'r') as f:
    contenu = f.readlines()

for i in range (0, len(contenu), 1):
    print(contenu[i].encode(encoding='utf-8', errors='replace'))

for ligne in contenu:
    print(ligne.encode(encoding='ascii', errors='replace'))

***********************