├── # 3 le regole fondamentali OOP.py ├── .github └── workflows │ └── main.yml ├── 1 welcome.md ├── CreazioneObj.py ├── ImportShelveITA.py ├── Lambda.py ├── POLIMORFIMO.py ├── Padre.py ├── astrazioni.py ├── json.py ├── jsonpy.py ├── numPy.py ├── pandastry.py ├── pickletest.py ├── pickletest2.py ├── primalezione.py ├── secondoscript.py └── trycatcheor.py /# 3 le regole fondamentali OOP.py: -------------------------------------------------------------------------------- 1 | # 3 le regole fondamentali OOP 2 | 3 | # Ereditarierà Polimorfismo Incapsulamento ASTRAZIONE 4 | 5 | # Pyt. è un linguaggio debolmenete tipizzato. Definizione non tecnica: Non tipizzato 6 | 7 | # Python sfrutta il Polimorfismo per inclusione 8 | 9 | 10 | # Variabili 11 | 12 | from copyreg import pickle 13 | from msilib.schema import Class 14 | 15 | 16 | 17 | 18 | 19 | numero = 10 # non interessa a python che tipo di valore contega 20 | numero = 0 # quando un valore è null o indefinito o 0 l'unico valore che ha è False 21 | 22 | # UN LIVELLO DI ASTRAZIONE DEL POLIMORFISMO 23 | # ogni oggetto in python che può avere un valore, accetta controlli booleani, 24 | # avendo una tipizzazione debole non importa se è o non è un booleano python 25 | # si può comunque andare andare a controllarlo tramite il suo valore reale 26 | 27 | numero != True 28 | 29 | stringa = "Python" # questa variabile la uso in metodo X 30 | numero = "mirko" 31 | 32 | nomelista = [1, 2, 3, stringa, "mirko", True, numero ] 33 | 34 | print( "mirko" , nomelista ) 35 | print(nomelista) 36 | 37 | 38 | 39 | 40 | # input : parametro in ingresso richiesto al utente 41 | # funzione di basso livello ma e comunque una delle più costose 42 | # tiene in run time i valori delle azioni 43 | 44 | #Scelta = input('dimmi il tuo nome') # = assegnazione 45 | 46 | #print(Scelta == "mirko") # == controllo, uguaglianza fa si che stampi true 47 | #print(Scelta != "mirko") # Diverso da, falso rispetto a, uguaglianza fa si che stampi false 48 | 49 | Scelta = 1 50 | 51 | if Scelta == 3: 52 | Scelta2 = input('fai la tua scelta digita o yes o no\n') 53 | 54 | 55 | 56 | # IF è il Blocco basilare di condizione la sintassi che si usa è [ if condizione : /n blocco di codice ] 57 | # Else quindi e l'alternativa alla condizione if iniziale nel caso non sia verificata 58 | 59 | 60 | # Ereditarierà - Classi 61 | 62 | # Una classe è un modello di riferimento per la creazione di un oggetto 63 | 64 | class primaclasse (): 65 | 66 | x = 0 67 | y= "mirko" 68 | m= "nonna" 69 | b= True 70 | 71 | 72 | print(primaclasse().x) 73 | valoredelloggetto = primaclasse() 74 | print(valoredelloggetto.y) 75 | 76 | 77 | # l'oggeto è insieme i valori e metodi datagli dalla classe di riferimento 78 | # e il valore e solo l'elemento che compone la veridicità della variabile 79 | 80 | i = 0 81 | 82 | o = primaclasse() 83 | 84 | 85 | class primaEredità (): 86 | 87 | def __init__(self, name, age): 88 | self.y1 = name 89 | self.m1 = age 90 | 91 | x1 = 0 92 | y1= "mirko" 93 | m1= "nonna" 94 | b1= True 95 | 96 | def sommatore (): 97 | # METODI SONO LE AZIONI PRATICHE CHE PUò COMPIERE IL NOSTRO CODICE O IL NOSTRO OGGETTO 98 | x1 +=100 99 | print(x1) 100 | 101 | class secondEredità (primaEredità): 102 | x1 = 100 103 | 104 | primaEredità.sommatore 105 | 106 | 107 | 108 | # __init__ definisce l'insieme delle caraterische che danno corpo, valore, e in caso anche metodi, i me e costituiscono l'oggetto 109 | # self 110 | 111 | # Incapsulamento: è la capacità del codice di nascedersi e nascodere pezzi di se stesso alla sua comprensione 112 | 113 | class Person: 114 | 115 | età = 10 116 | 117 | def __init__(self, name, age): 118 | self.name = name 119 | self.age = age 120 | 121 | def mirko (self): 122 | print(self.name, self.age) 123 | 124 | class Studente (Person): 125 | 126 | 127 | def __init__(self, name, age, anno ): 128 | super().__init__(name, age) 129 | scuola = "quinto alberti" 130 | self.scuola = scuola 131 | self.anno = anno 132 | def welcome (self): 133 | print("Ciao", self.name, " all'età di ", self.age, " sei il bevenuto alla ", self.scuola) 134 | 135 | class AiutoBidello (Person): 136 | 137 | 138 | def __init__(self, name, age): 139 | Studente() 140 | super().__init__(name, age) 141 | self.stipendio = 100 142 | self.scuola = "mirko" 143 | 144 | 145 | p1 = Person("John", 36) 146 | 147 | p3 = Studente("carlo", 22, 1995 ) 148 | 149 | p3.welcome 150 | 151 | 152 | del p1.age # è il commando per eliminare un'attributo 153 | 154 | p1.age = 20 # il comando per dare un valore a quel elemento 155 | 156 | del p1 # è il commando per eliminare l'oggeto 157 | 158 | class Person2: 159 | pass # è un comando per evitare che una classe venga eseguita facendo passare la lettura di codice oltre 160 | 161 | Person2() 162 | 163 | 164 | class creadict: 165 | car = { 166 | "brand": "Ford", 167 | "model": "Mustang", 168 | "year": 1964 169 | } 170 | 171 | 172 | 173 | 174 | pickle 175 | 176 | 177 | 178 | -------------------------------------------------------------------------------- /.github/workflows/main.yml: -------------------------------------------------------------------------------- 1 | # This is a basic workflow to help you get started with Actions 2 | 3 | name: CI 4 | 5 | # Controls when the workflow will run 6 | on: 7 | # Triggers the workflow on push or pull request events but only for the main branch 8 | push: 9 | branches: [ main ] 10 | pull_request: 11 | branches: [ main ] 12 | 13 | # Allows you to run this workflow manually from the Actions tab 14 | workflow_dispatch: 15 | 16 | # A workflow run is made up of one or more jobs that can run sequentially or in parallel 17 | jobs: 18 | # This workflow contains a single job called "build" 19 | build: 20 | # The type of runner that the job will run on 21 | runs-on: ubuntu-latest 22 | 23 | # Steps represent a sequence of tasks that will be executed as part of the job 24 | steps: 25 | # Checks-out your repository under $GITHUB_WORKSPACE, so your job can access it 26 | - uses: actions/checkout@v3 27 | 28 | # Runs a single command using the runners shell 29 | - name: Run a one-line script 30 | run: echo Hello, world! 31 | 32 | # Runs a set of commands using the runners shell 33 | - name: Run a multi-line script 34 | run: | 35 | echo Add other actions to build, 36 | echo test, and deploy your project. 37 | -------------------------------------------------------------------------------- /1 welcome.md: -------------------------------------------------------------------------------- 1 | # PythonForU 2 | Una serie di script utili in python. 3 | 4 | Metto le mani avanti: 5 | 6 | - Sono pezzi di codice utile a orientarsi e non sempre pronti all'uso sopratutto la dove si tratta di sistemi complessi 7 | 8 | 9 | - ho preso spunto anch'io a mia volta da codici pre esistenti modificandoli di mio pugno 10 | 11 | 12 | - I titoli sono un riferimento generico al contenuto degli script 13 | -------------------------------------------------------------------------------- /CreazioneObj.py: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | class MyClass: 5 | x = 5 6 | y= "antonio" 7 | 8 | def mirko(): 9 | print("6") 10 | 11 | variabile = "" 12 | 13 | print(MyClass.x) 14 | 15 | print(variabile) 16 | 17 | variabile = MyClass() 18 | print(variabile.x is MyClass.x) 19 | print(variabile.y) 20 | print(variabile.mirko) 21 | 22 | 23 | print(variabile is MyClass()) -------------------------------------------------------------------------------- /ImportShelveITA.py: -------------------------------------------------------------------------------- 1 | import shelve 2 | 3 | M = shelve.open( Esempio txt) # open -- file può ottenere suffisso da low level 4 | # library 5 | 6 | M[key] = data # memorizza i dati nella chiave (sovrascrive i vecchi dati se 7 | # utilizza una chiave esistente) 8 | data = M[key] # recupera una copia dei dati nella chiave (Va in KeyError 9 | # se la chiave non ha valore o non esiste) 10 | del M[key] # Cancella i dati salvati nella chiave (Va in KeyError 11 | # se la chiave non ha valore o non esiste) 12 | 13 | flag = key in M # true quando la chiave esiste 14 | klist = list(M.keys()) # Una lista di tutte le chiavi esistenti(slow!) 15 | 16 | # as M was opened WITHOUT writeback=True, beware: 17 | M['xx'] = [0, 1, 2] # this works as expected, but... 18 | M['xx'].append(3) # *this doesn't!* -- M['xx'] is STILL [0, 1, 2]! 19 | 20 | 21 | # M è stato aperto SENZA Writeback=Vero, attenzione: 22 | M['xx'] = [0, 1, 2] # questo funziona come previsto, ma... 23 | M['xx']. append(3) # *questo non è ! * -- M['xx'] è ANCORA [0, 1, 2]! 24 | 25 | 26 | # Dopo aver aperto M senza Writeback=True, è necessario pensare attentamente ai passaggi seguenti: 27 | temp = M['xx'] # estrae la copia 28 | temp.append(5) # muta la copia 29 | M['xx'] = temp # memorizza la copia, per persistere 30 | 31 | # oppure, M=shelve.open(filename, Writeback=True) ti permette da codice 32 | # M['xx']. append(5) di farlo funzionare come previsto, MA sarebbe anche 33 | # consumata più memoria rendono cosi l'operazione M.close() più lenta. 34 | 35 | M.close() 36 | -------------------------------------------------------------------------------- /Lambda.py: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | # LAMBDA è UN MODO PER ANONIMIZARE e Snellire gli formule matematiche pure 14 | 15 | 16 | # lambda arguments : expression 17 | 18 | 19 | 20 | c = lambda a : a + 10 # il lato destro è il cosa fa 21 | print(c(5)) 22 | 23 | y = lambda a, b, c : a + b + c 24 | print(y(5, 6, 2)) 25 | 26 | x = lambda a, b : a * b 27 | print(x(5, 6)) 28 | 29 | def myfunc(n): 30 | c = lambda a : a * n 31 | 32 | 33 | print(c(11)) 34 | 35 | 36 | 37 | 38 | 39 | 40 | 41 | class MANAGER: 42 | 43 | lista = () 44 | 45 | def __init__(self): 46 | self.__stipendio = 1230 47 | self.__VALORE = " mirko " 48 | 49 | def Paga(self): 50 | print("La MANAGER è pagato {}".format(self.__stipendio)) 51 | 52 | def impostastipendio(self, variante): 53 | self.__stipendio = variante 54 | 55 | def impostavqalore ( self, variante2 ): 56 | self.__VALORE = variante2 57 | 58 | def ValorePrint(self): 59 | print( "IL tuo valore è {}".format(self.__VALORE) ) 60 | 61 | def creafilio(self, variabile): 62 | self.variabile = Figlio() 63 | 64 | 65 | class Figlio (MANAGER): 66 | 67 | def __init__(self): 68 | super().__init__() 69 | 70 | # istanza di classe 71 | x = MANAGER() 72 | x1 = MANAGER() 73 | 74 | print(x) 75 | print(x1) 76 | 77 | y = input() 78 | # funzione setter 79 | x.impostastipendio(y) 80 | x.impostavqalore("MirkoSuper") 81 | x.ValorePrint() 82 | 83 | x.__stipendio = 100 # non ha alcune valore per x e per manager 84 | x.Paga() 85 | x1.Paga() 86 | -------------------------------------------------------------------------------- /POLIMORFIMO.py: -------------------------------------------------------------------------------- 1 | DIZIO = { 2 | "Marca": "Nike", 3 | "Modello": "air jordan", 4 | "Anno": 1999 5 | } 6 | 7 | print(DIZIO) 8 | 9 | 10 | # Incapsulamento in Python 11 | class Facciata: 12 | 13 | def __init__(self): 14 | self.__colore = "verde" 15 | 16 | def colora(self): 17 | print("La facciata è di colore {}".format(self.__colore)) 18 | 19 | def impostaColore(self, variante): 20 | self.__colore = variante 21 | 22 | # istanza di classe 23 | x = Facciata() 24 | x.colora() 25 | 26 | # modifica del colore 27 | x.__colore = "rosso" 28 | x.colora() 29 | 30 | # funzione setter 31 | x.impostaColore("rosso") 32 | x.colora() -------------------------------------------------------------------------------- /Padre.py: -------------------------------------------------------------------------------- 1 | 2 | 3 | class creadict: 4 | car = { 5 | "brand": "Ford", 6 | "model": "Mustang", 7 | "year": 1964 8 | } 9 | 10 | 11 | -------------------------------------------------------------------------------- /astrazioni.py: -------------------------------------------------------------------------------- 1 | # Python program showing 2 | # abstract base class work 3 | 4 | from abc import ABC, abstractmethod 5 | 6 | class Polygon(ABC): 7 | 8 | @abstractmethod 9 | def noofsides(self): 10 | pass 11 | 12 | class Triangle(Polygon): 13 | 14 | # overriding abstract method 15 | def noofsides(self): 16 | print("I have 3 sides") 17 | 18 | class Pentagon(Polygon): 19 | 20 | # overriding abstract method 21 | def noofsides(self): 22 | print("I have 5 sides") 23 | 24 | class Hexagon(Polygon): 25 | 26 | # overriding abstract method 27 | def noofsides(self): 28 | print("I have 6 sides") 29 | 30 | class Quadrilateral(Polygon): 31 | 32 | # overriding abstract method 33 | def noofsides(self): 34 | print("I have 4 sides") 35 | 36 | # Driver code 37 | R = Triangle() 38 | R.noofsides() 39 | 40 | K = Quadrilateral() 41 | K.noofsides() 42 | 43 | R = Pentagon() 44 | R.noofsides() 45 | 46 | K = Hexagon() 47 | K.noofsides() 48 | 49 | 50 | 51 | 52 | 53 | 54 | 55 | 56 | 57 | # Python program showing 58 | # abstract base class work 59 | 60 | from abc import ABC, abstractmethod 61 | class Animal(ABC): 62 | 63 | def move(self): 64 | pass 65 | 66 | class Human(Animal): 67 | 68 | def move(self): 69 | print("I can walk and run") 70 | 71 | class Snake(Animal): 72 | 73 | def move(self): 74 | print("I can crawl") 75 | 76 | class Dog(Animal): 77 | 78 | def move(self): 79 | print("I can bark") 80 | 81 | class Lion(Animal): 82 | 83 | def move(self): 84 | print("I can roar") 85 | 86 | # Driver code 87 | R = Human() 88 | R.move() 89 | 90 | K = Snake() 91 | K.move() 92 | 93 | R = Dog() 94 | R.move() 95 | 96 | K = Lion() 97 | K.move() -------------------------------------------------------------------------------- /json.py: -------------------------------------------------------------------------------- 1 | import json 2 | 3 | x = { 4 | 5 | "name": "John", 6 | "age": 30, 7 | "married": True, 8 | "divorced": False, 9 | "children": ("Ann","Billy"), 10 | "pets": None, 11 | "cars": [ 12 | {"model": "BMW 230", "mpg": 27.5}, 13 | {"model": "Ford Edge", "mpg": 24.1} 14 | ] 15 | } 16 | 17 | # print (json.dumps( x, indent=4, separators=(". ", " = ") )) 18 | 19 | 20 | from ilmiomodulo import greetingpass 21 | 22 | 23 | antonio = chr.person1["name"] 24 | print(antonio) 25 | 26 | if(greetingpass == True): 27 | 28 | import platform 29 | 30 | x = platform.system() 31 | print(x) 32 | 33 | x = dir(chr) 34 | print(x) -------------------------------------------------------------------------------- /jsonpy.py: -------------------------------------------------------------------------------- 1 | import json # IMPORTIAMO LA LIBRERIA JSON ALTRIMENTI NON ANDRà NULLA 2 | 3 | 4 | # RICEVERE UN JSON: 5 | x = '{ "Nome":"Mirko", "Età":36, "Città":"Old York"}' 6 | 7 | # caricare l'elemento x: 8 | y = json.loads(x) 9 | 10 | #il risultato sarà un Python dictionary: 11 | print(y["Età"]) 12 | 13 | 14 | 15 | #inviare e creare un json 16 | # ora abbiamo l'oggetto (dict): 17 | x1 = { 18 | "Nome": "Micheal", 19 | "Valore": 28, 20 | "Stile": "old london" 21 | } 22 | 23 | # convertire in JSON: 24 | y1 = json.dumps(x1) 25 | 26 | # il risultato sarà un JSON in string: 27 | print(y1) 28 | 29 | 30 | # Ecco i tipi convertibili 31 | 32 | # # dict 33 | # # list 34 | # # tupla 35 | # # int 36 | # # float 37 | # # Vero 38 | # # Falso 39 | # # none 40 | 41 | 42 | # # Utilizzare il indent parametro per definire il numero di rientri: 43 | 44 | json.dumps(x, indent=4) 45 | 46 | # # Utilizzo del separatore per modificare il separatore predefinito: 47 | 48 | u = { 49 | "name": "John", 50 | "age": 30, 51 | "married": True, 52 | "divorced": False, 53 | "children": ("Ann","Billy"), 54 | "pets": None, 55 | "cars": [ 56 | {"model": "BMW 230", "mpg": 27.5}, 57 | {"model": "Ford Edge", "mpg": 24.1} 58 | ] 59 | } 60 | 61 | # facilità la lettura: 62 | print(json.dumps(u, indent=6)) 63 | 64 | 65 | json.dumps(u, indent=4, sort_keys=True) # Sort_Key può ordinare automaticamente un elemento quando scrivimo o leggiamo un dato 66 | print(u) -------------------------------------------------------------------------------- /numPy.py: -------------------------------------------------------------------------------- 1 | import numpy as np 2 | 3 | 4 | #tupla 5 | arr = np.array([1, 2, 3, 4, 5]) 6 | # elenco 7 | arr2 = np.array((1, 2, 3, 4, 5)) 8 | 9 | print(arr) 10 | 11 | 12 | 13 | 14 | # matrice 0-d zero dimensioni 15 | arr3 = np.array(42) 16 | 17 | print(arr3) 18 | 19 | # matrice 1-d zero dimensioni 20 | arr4 = np.array([1, 2, 3, 4, 5]) 21 | 22 | print(arr4) 23 | 24 | # matrice 2-d zero dimensioni 25 | arr5 = np.array([[1, 2, 3], [4, 5, 6]]) 26 | 27 | print(arr5) 28 | 29 | 30 | # matrice 3-d zero dimensioni 31 | arr6 = np.array([[[1, 2, 3], [4, 5, 6]], [[1, 2, 3], [4, 5, 6]]]) 32 | 33 | print(arr6) 34 | print(arr6.ndim) # per sapere quante dimensioni ha un insieme 35 | 36 | 37 | # quella sarà la dimenzione massima del nostro insieme 38 | arr7 = np.array([1, 2, 3, 4, 5], ndmin=1) 39 | 40 | print(arr7) 41 | print('number of dimensions :', arr7.ndim) 42 | print(arr7[0]) 43 | 44 | print(arr7[2] + arr7[3]) 45 | 46 | 47 | arr8 = np.array([[1,2,3,4,5], [6,7,8,9,10]]) 48 | print('2nd element on 1st row: ', arr8[0, 1]) 49 | 50 | 51 | 52 | arr9 = np.array([[[1, 2, 3], [4, 5, 6]], [[7, 8, 9], [10, 11, 12]]]) 53 | print(arr9[0, 1, 2]) 54 | print(arr9[1, 1, 1 ]) 55 | 56 | 57 | from numpy import random 58 | 59 | x = random.randint(100) 60 | 61 | print(x) 62 | 63 | # crea un array 1-D con 5 posizioni riempite con numeri random da 1 a 100 64 | x2 =random.randint(100, size=(5)) 65 | print(x2) 66 | 67 | x3 = random.randint(100, size=(3, 5)) 68 | print(x3) 69 | 70 | # 71 | 72 | x = random.rand(5) 73 | 74 | print(x) 75 | 76 | 77 | x = [1, 2, 3, 4] 78 | y = [4, 5, 6, 7] 79 | z = [] 80 | 81 | for i, j in zip(x, y): 82 | z.append(i + j) 83 | print(z) 84 | 85 | 86 | x = [1, 2, 3, 4] 87 | y = [4, 5, 6, 7] 88 | z = np.add(x, y) 89 | 90 | print(z) 91 | 92 | 93 | print(type(np.add)) 94 | -------------------------------------------------------------------------------- /pandastry.py: -------------------------------------------------------------------------------- 1 | 2 | # ALIAS DEL NOME NON C'è DIFFERENZA 3 | 4 | import pandas as pd 5 | 6 | mydataset = { 7 | 'cars': ["BMW", "Volvo", "Ford"], 8 | 'passings': [3, 7, 2] 9 | } 10 | 11 | myvar = pd.DataFrame(mydataset) 12 | 13 | print(myvar) 14 | print(myvar.loc[0 , 1]) 15 | # per poter localizare un elemento in un dataframe abbiamo bisogno di .loc e delle [] 16 | 17 | df = pd.DataFrame(mydataset, index = ["mia macchina"," macchina mamma"]) 18 | 19 | print(df) 20 | 21 | ##print(pd.__version__) 22 | 23 | 24 | a = [1, 7, 2] 25 | 26 | myvar = pd.Series(a, index = ["x", "y", "z"]) 27 | 28 | print(myvar) 29 | 30 | print(myvar["z"]) 31 | 32 | 33 | 34 | calories = {"day1": 420, "day2": 380, "day3": 390} 35 | 36 | myvar2 = pd.Series(calories, index = ["day1" ,"day2" ]) 37 | 38 | print(myvar2) 39 | 40 | 41 | 42 | # può essere letto e inserito all'interno di un dataframe 43 | df = pd.read_csv("x.csv") #nomex 44 | print(df.to_string()) # con il to_string possiamo stampare l'intero dataframe 45 | 46 | 47 | df = pd.read_json('data.json') #nomex 48 | print(df.to_string()) -------------------------------------------------------------------------------- /pickletest.py: -------------------------------------------------------------------------------- 1 | import pickle 2 | import re 3 | 4 | 5 | x= [ 3, 2, 4] 6 | 7 | pickle 8 | 9 | re.search 10 | 11 | 12 | pickle.DEFAULT_PROTOCOL 13 | 14 | pickle.HIGHEST_PROTOCOL 15 | 16 | pickle.Pickler(pickle.DEFAULT_PROTOCOL) 17 | 18 | pickle.Pickler 19 | 20 | 21 | pickle.Unpickler 22 | 23 | 24 | 25 | 26 | 27 | 28 | 29 | 30 | 31 | 32 | 33 | 34 | 35 | 36 | 37 | 38 | 39 | 40 | 41 | 42 | 43 | def carica_dati(): 44 | try: 45 | #infile = open('dati.txt','r') 46 | namefile = input('Inserire il nome del file e la sua estensione: ') 47 | infile = open(namefile,'r') 48 | dati = infile.readlines() 49 | infile.close() 50 | except Exception as err: 51 | dati = list() 52 | print("File non esistente") 53 | return dati 54 | else: 55 | return dati 56 | 57 | def carica_liste(dati): 58 | nominativi = list() 59 | ore= list() 60 | for i in range(0,len(dati),2): 61 | nominativi.append(dati[i].rstrip('\n')) 62 | ore.append(float(dati[i+1].rstrip('\n'))) 63 | return nominativi, ore 64 | 65 | def carica_dizionario(n, o): 66 | d = dict() 67 | for i in range(0,len(n)): 68 | d[n[i]] = o[i] 69 | return d 70 | 71 | def salva_dizionario(d): 72 | file = open('log.dat','wb') 73 | pickle.dump(d, file) 74 | file.close() 75 | 76 | def visualizza_info(d, paga_oraria): 77 | for key in d: 78 | totale = d[key]*paga_oraria 79 | print("Nominativo dipendente: "+key+"\t"+ str(d[key]) + " ore lavorate\t Costo orario: "+str(paga_oraria)+ "€\t Paga lorda € "+str(totale)) 80 | 81 | 82 | def main(): 83 | dati = carica_dati() 84 | if (len(dati)>0): 85 | 86 | try: 87 | 88 | nominativi, ore = carica_liste(dati) 89 | 90 | monte_ore_lav = carica_dizionario(nominativi, ore) 91 | 92 | paga_oraria = float(input('Inserire la paga oraria in Euro: ')) 93 | 94 | salva_dizionario(monte_ore_lav) 95 | visualizza_info(monte_ore_lav, paga_oraria) 96 | 97 | except Exception as err: 98 | print(err) 99 | 100 | main() -------------------------------------------------------------------------------- /pickletest2.py: -------------------------------------------------------------------------------- 1 | import pickle 2 | import re 3 | 4 | 5 | 6 | 7 | 8 | import mysql.connector 9 | 10 | import prova1 11 | 12 | mydb = mysql.connector.connect( 13 | host="localhost", 14 | user="yourusername", 15 | password="yourpassword" 16 | ) 17 | 18 | mydb = x 19 | mydb is x 20 | 21 | 22 | # Il modulo PICKlE che il cPIckle implementano un algoritmo di serializzazione degli oggetti 23 | # Può essere conservato è trasmesso e in secondo tempo ricostruito per riottenere le sue caratteristiche 24 | # cPickle quindi è lo stesso elemento di serializzazione ma in formato nativo C 25 | 26 | x= [ 3, 2, 4] 27 | 28 | pickle 29 | 30 | re.search 31 | 32 | 33 | pickle.DEFAULT_PROTOCOL 34 | 35 | pickle.HIGHEST_PROTOCOL 36 | 37 | pickle.Pickler(pickle.DEFAULT_PROTOCOL) 38 | 39 | pickle.Pickler.dump(x) 40 | 41 | # il controllo 42 | 43 | pickle.Pickler.clear_memo() 44 | 45 | 46 | # dump e dumps 47 | 48 | # load e loads 49 | 50 | 51 | # exception PickleError exception PicklingError exception UnpicklingError 52 | 53 | pickle.Unpickler 54 | 55 | 56 | try: 57 | import cPickle as pickle 58 | except: 59 | import pickle 60 | import pprint 61 | 62 | data = [ pickletest ] 63 | print ('DATI:') 64 | pprint.pprint(data) 65 | 66 | data_string = mydb.dump(data) 67 | print ('PICKLE:') 68 | data_string 69 | 70 | # alcuni tipi non serializzabili: None, True e False Interi, interi long, numeri in virgola mobile, numeri complessi stringhe normali ed Unicodetuple, liste, insiemi e dizionari contenenti solamente oggetti serializzabilifunzioni definite nella parte iniziale di un modulofunzioni built-in definite nella parte iniziale di un modulo 71 | 72 | # sui può cercare di limitare questa problematica utilizzando exception Pickling Error 73 | 74 | f = open("demofile.txt") 75 | 76 | #"r"- Lettura - Valore predefinito. Apre un file per la lettura, errore se il file non esiste 77 | 78 | #"a"- Aggiungi - Apre un file per l'accodamento, crea il file se non esiste 79 | 80 | #"w"- Scrivi - Apre un file per la scrittura, crea il file se non esiste 81 | 82 | #"x"- Crea - Crea il file specificato, restituisce un errore se il file esiste 83 | 84 | import marshal 85 | import pickle 86 | import json 87 | 88 | y = open("D:\\myfiles\welcome3.txt", "w") 89 | 90 | f = open("D:\\myfiles\welcome.txt", "r") 91 | print(f.read()) 92 | 93 | f = open("demofile2.txt", "r") 94 | print(f.readline()) 95 | 96 | f = open("demofile2.txt", "a") 97 | f.write("Now the file has more content!") 98 | f.close() 99 | 100 | #open and read the file after the appending: 101 | f = open("demofile2.txt", "r") 102 | print(f.read()) 103 | 104 | fletto= f.read 105 | 106 | f = json.dumps(y, indent=5) 107 | 108 | h = json.loads(fletto) 109 | print(h) 110 | 111 | # Creare un sistema che dopo aver accetato un imput lo scriva su in file e ripeta 112 | # , alla fine lo convertirà in json 113 | 114 | # some JSON: 115 | x = '{ "name":"John", "age":30, "city":"New York"}' 116 | 117 | # parse x: 118 | y = json.loads(x) 119 | 120 | # the result is a Python dictionary: 121 | print(y["age"]) 122 | 123 | 124 | x = { 125 | "name": "John", 126 | "age": 30, 127 | "married": True, 128 | "divorced": False, 129 | "children": ("Ann","Billy"), 130 | "pets": None, 131 | "cars": [ 132 | {"model": "BMW 230", "mpg": 27.5}, 133 | {"model": "Ford Edge", "mpg": 24.1} 134 | ] 135 | } 136 | 137 | print(json.dumps(x)) 138 | 139 | 140 | 141 | 142 | 143 | 144 | 145 | 146 | import shelve 147 | 148 | d = shelve.open(filename) # open -- file che può prendere un suffisso 149 | # aggiunto da una libreria di basso-livello 150 | 151 | d[key] = data # immagazzina i dati della chiave (sovrascrive i 152 | # vecchi dati se sta usando una chiave esistente) 153 | data = d[key] # recupera una COPIA dei dati dalla chiave 154 | # (solleva KeyError se la chiave non corrisponde) 155 | del d[key] # cancella i dati immagazzinati nella chiave 156 | # (solleva KeyError se la chiave non corrisponde) 157 | flag = d.has_key(key) # vero se la chiave esiste 158 | list = d.keys() # una lista di tutte le chiavi esistenti (lento!) 159 | 160 | # visto che d è stata aperta SENZA writeback=True, si faccia attenzione che: 161 | d['xx'] = range(4) # questa lavora come sperato, ma ... 162 | d['xx'].append(5) # *questa no!* -- d['xx'] è ANCORA range(4)!!! 163 | # avendo aperto d senza writeback=True, avete bisogno di scrivere accuratamente: 164 | temp = d['xx'] # estrae la copia 165 | temp.append(5) # modifica la copia 166 | d['xx'] = temp # memorizza la copia, per renderla persistente 167 | # oppure, d=shelve.open(nomefile,writeback=True) potrebbe lasciarvi 168 | # scrivere d['xx'].append(5) e farla funzionare come deisderato, MA 169 | # potrebbe anche consumare una maggiore quantità di memoria, e rendere 170 | # l'operazione d.close() più lenta. 171 | 172 | 173 | d.close() # chiude d 174 | 175 | 176 | 177 | 178 | 179 | 180 | 181 | def carica_dati(): 182 | try: 183 | #infile = open('dati.txt','r') 184 | namefile = input('Inserire il nome del file e la sua estensione: ') 185 | infile = open(namefile,'r') 186 | dati = infile.readlines() 187 | infile.close() 188 | except Exception as err: 189 | dati = list() 190 | print("File non esistente") 191 | return dati 192 | else: 193 | return dati 194 | 195 | def carica_liste(dati): 196 | nominativi = list() 197 | ore= list() 198 | for i in range(0,len(dati),2): 199 | nominativi.append(dati[i].rstrip('\n')) 200 | ore.append(float(dati[i+1].rstrip('\n'))) 201 | return nominativi, ore 202 | 203 | def carica_dizionari(n, o): 204 | d = dict() 205 | for i in range(0,len(n)): 206 | d[n[i]] = o[i] 207 | return d 208 | 209 | def salva_dizionario(d): 210 | file = open('log.dat','wb') 211 | pickle.dump(d, file) 212 | file.close() 213 | 214 | def visualizza_info(d, paga_oraria): 215 | for key in d: 216 | totale = d[key]*paga_oraria 217 | print("Nominativo dipendente: "+key+"\t"+ str(d[key]) + " ore lavorate\t Costo orario: "+str(paga_oraria)+ "€\t Paga lorda € "+str(totale)) 218 | 219 | 220 | def main(): 221 | dati = carica_dati() 222 | if (len(dati)>0): 223 | 224 | try: 225 | 226 | nominativi, ore = carica_liste(dati) 227 | 228 | monte_ore_lav = carica_dizionario(nominativi, ore) 229 | 230 | paga_oraria = float(input('Inserire la paga oraria in Euro: ')) 231 | 232 | salva_dizionario(monte_ore_lav) 233 | visualizza_info(monte_ore_lav, paga_oraria) 234 | 235 | except Exception as err: 236 | print(err) 237 | 238 | main() -------------------------------------------------------------------------------- /primalezione.py: -------------------------------------------------------------------------------- 1 | # Con cui si commenta 2 | 3 | # Ereditarietà, Polimorfismo, Incapsulamento. 4 | 5 | from asyncio.windows_events import NULL 6 | 7 | 8 | x = 10 # valorizzazione esplicità 9 | 10 | y = x # valorizzazione implicità 11 | 12 | x +=1 # addizione implicità 13 | 14 | x + 1 # addizione esplcità 15 | 16 | # TIPIZZAZIONE E ASTRAZIONE 17 | 18 | y = 1 19 | 20 | z = 1 21 | 22 | y = NULL 23 | 24 | # Math ( Int, Float ) String ( " QUALSIASI " ) Bool ( True, False ) 25 | 26 | #Metodo: Azione pratica che può compiere una classe 27 | #Classe: è il modello per la creazione degli oggeti 28 | #Attributi: Insieme dei valori e delle proprietà della classe 29 | 30 | 31 | print (x) 32 | print (" Ciao sono il trenino tom ") 33 | 34 | # print (v) se il valore non esiste stamperà false o andrà in errore 35 | 36 | # print metodo per stampare in console gli elemeti 37 | 38 | print (x == 10) 39 | print (x == 11) 40 | 41 | 42 | # blocco di condizione: è un delimitatore di parti di codice 43 | 44 | if (x != 5): 45 | x=12 46 | y = "riuscito" 47 | else: 48 | x=13 49 | 50 | 51 | if ( x == False or x == 11): 52 | x = 13 53 | else: 54 | x = 13 55 | 56 | # input system: un elmento che consente al'utente di inserire dati 57 | 58 | nome = input('qualè il tuo nome') 59 | print(nome) 60 | 61 | # Loop (11) 62 | 63 | 64 | # Creare un sistema di input che controlli detetrminate parole per riscattere dei ticket 65 | # mirko_campari@libero.it -------------------------------------------------------------------------------- /secondoscript.py: -------------------------------------------------------------------------------- 1 | 2 | # Benvenuti alla seconda lezione 3 | 4 | from asyncio.windows_events import NULL 5 | from cgi import print_arguments 6 | from ftplib import parse227 7 | 8 | 9 | def mirko (): 10 | print("qui non c'è") 11 | def mirkocè (): 12 | print(x + " grazie di aver usato la nostra app ") 13 | 14 | 15 | # Iniziamo a parlare ora di LOOP e/o ITERATORI 16 | 17 | # Sono uno degli elementi più complessi da inserire senza trouble shotting 18 | # Un motivo di persistere una ending condition 19 | 20 | # While ripete ed Esegue un insieme di condizioni purchè la condizione sia vera 21 | 22 | thisdict = { 23 | "brand" : "mirko", 24 | "model" : "Mustang", 25 | "year": 1969, 26 | "years": 1900 27 | } 28 | 29 | i = input( "che operazione vuoi fare? aggiungi / stampa /esci " ) 30 | i2 = 0 31 | 32 | while i2 >= 1: 33 | 34 | #While i != NULL: 35 | 36 | while i != "esci": 37 | 38 | # Menu uno 39 | 40 | if i == "stampa": 41 | print(thisdict) 42 | i = input( "che operazione vuoi fare? aggiungi / stampa /esci " ) 43 | 44 | if i == "aggiungi": 45 | thisdict["color"] = "red" # aggiungere dovremmo dare la scelta in input 46 | i = input( "che operazione vuoi fare? aggiungi / stampa /esci " ) 47 | 48 | if i == "esci": 49 | break 50 | else: 51 | i = input( "sei sicuro? yes/no" ) 52 | if i == "si": 53 | i2 +=1 54 | if i == "no": 55 | i = input( "che operazione vuoi fare? aggiungi / stampa /esci " ) 56 | 57 | print("grazie mille") 58 | 59 | 60 | # INFINITI 61 | 62 | 63 | 64 | 65 | 66 | 67 | 68 | 69 | 70 | 71 | # For il primo loop che andiamo a vedere 72 | 73 | Frutto = input("inseristi il frutto che cerchi") # input tipo frutto da cercare 74 | 75 | # mai il raw input se non è strettamente neccesario 76 | 77 | listo = [ mirko, x2 ] 78 | listo1 = 1 79 | 80 | fruits = ["apple", "mirko", "banana", "cherry", 5, "ciliegia", Frutto, listo] # iniziano a esssere numerati partendo da 0 81 | 82 | for x in fruits: 83 | print(x) 84 | if x == Frutto: 85 | # va tutto bene 86 | break 87 | if x != Frutto: 88 | mirko() 89 | 90 | print(Frutto) 91 | 92 | m= "" # False 93 | m= 0 # False 94 | m= NULL # False 95 | m= False # false 96 | 97 | # Valori booleani in py sonos empre veri e controllabili su qualsiasi elemento 98 | # A due condizioni che il valore non sia 0 o che la variabile non abbia valore 99 | 100 | exp = 0 101 | mikk = 0 102 | 103 | print(exp + " hai questa exp ") # non ci interessa del tipo 104 | 105 | 106 | 107 | 108 | 109 | 110 | 111 | 112 | 113 | # Set è uno dei 4 tipi di dati integrati in Python utilizzati per archiviare raccolte di dati, 114 | # gli altri 3 sono List , Tuple e Dictionary , tutti con qualità e utilizzo diversi. 115 | 116 | 117 | thisset = {"apple", "banana", "cherry"} 118 | print(thisset) 119 | 120 | 121 | thislist = ["apple", "banana", "cherry", "banana"] 122 | print(len(thislist)) 123 | 124 | 125 | thistuple = ("apple", "banana", "cherry") 126 | print(thistuple) 127 | 128 | 129 | 130 | thisdict = { 131 | 1 : thislist, 132 | "model" : "Mustang", 133 | "year": 1969, 134 | "years": 1900 135 | } 136 | 137 | print(thisdict) 138 | print(thisdict["model"]) 139 | print(len(thisdict)) 140 | print(type(thisdict)) 141 | 142 | thisdict["color"] = "red" # aggiungere 143 | thisdict["year"] = 2028 # modifica diretta 144 | thisdict.update({"color": "red"}) # modifica indiretta 145 | del thisdict["model"] # cancellazione totale 146 | thisdict.pop("model") # rimozione dell'elemento chiave valore 147 | thisdict.clear() # svuota l'elemento dict 148 | 149 | x = thisdict.items() # stampa lista chiavi e valore 150 | 151 | if "model" in thisdict: # controllo di esistenza delle chiavi 152 | print("Yes, 'model' esiste") 153 | 154 | for x , y in thisdict.items: # cicla e stampa le chiavi su variabili separate richiamabili 155 | print(x, y) 156 | 157 | 158 | import Padre 159 | 160 | 161 | p = 0 162 | 163 | p2 = 0 164 | 165 | Padre.creadict(p) 166 | 167 | Padre.creadict.car.update({"color": "red"}) 168 | 169 | 170 | Padre.creadict(p2) 171 | 172 | 173 | thisdict["anthoer dict"] = p # modifica diretta 174 | 175 | 176 | -------------------------------------------------------------------------------- /trycatcheor.py: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | # TRY E Execpt SySTEM e comando or e and e is 5 | 6 | # Il try catch e un blocco di codice che si occupa di gestire le eccezioni 7 | # Ricordate non esiste un modo di conprovare l'assenza totale di errori am solo di evidenziarne uno conosciuto 8 | 9 | 10 | 11 | 12 | try: 13 | print(x) 14 | except: 15 | print("OPS WE HAVE A PROBLEM") 16 | 17 | 18 | 19 | try: 20 | print(x) 21 | except NameError: 22 | print("VariabIle ANndrea VUOTA ") 23 | except TypeError: 24 | print("OPS WTF") 25 | except: 26 | print(" wtf ") 27 | else: # viene eseguito quando non abbiamo errori 28 | print("non ci sono eroi") 29 | finally: # viene stampato comunque sempre 30 | print("ok 2") 31 | 32 | 33 | x1 = "pippo" 34 | 35 | try: 36 | print(x1) 37 | except: 38 | print("Non funziona pippo") 39 | finally: # il finaly verrà sempre eseguito indipendetemente dal risultato del blocco try catch 40 | print("The 'try except' is finished") 41 | 42 | 43 | 44 | x2= 2 45 | 46 | #IS, is not, not , AND E OR sono i tre operatori logici complessi più utilizati 47 | 48 | if not( x2 <=0 ): # situazioni matematiche 49 | print("pippo") 50 | 51 | 52 | if x1 is "pippo": 53 | print("w mikk") 54 | 55 | if x1 is not "pippo": 56 | print("w mikk4") 57 | 58 | 59 | if x1 is "pippo" or x2 == 1 or x2 == "mirko": # OR CI DICE CHE BASTA CHE UNA DELLE DUE O PIù CONDIZIONI SIANO VERE 60 | print("w mikk2") 61 | 62 | if x1 is "pippo" and x2 == 1: # AND CI DICE CHE SERVIRANNO ENTRAMBE LE CONDIZIONI VERE 63 | print("w mikk3") 64 | 65 | 66 | # la differenza fra == è l'IS E CHE SI PUò USARE ANCHE SUGLI OGGETTI --------------------------------------------------------------------------------