Ragazzi ho scritto questo programmino per cifrare stringhe con l'Hill.
in uno dei commenti del codice indico il problema e dopo il codice stesso vi spiego il problema:




# creare la matrice n * n
import numpy as np

ordine_matrice = int(input("inserisci l'ordine della matrice: "))
forma_chiave = (ordine_matrice, ordine_matrice)
mini_forma_chiave = (ordine_matrice - 1, ordine_matrice - 1)
print(forma_chiave)
chiave = np.ndarray(forma_chiave)

for i in range(ordine_matrice):
for j in range(ordine_matrice):

chiave[i,j] = int(input("Inserisci valore matrice nella posizione "
"[{},{}]".format(i,j)))

# converto gli elementi in interi

chiave = chiave.astype(np.int64)
print("Stampa chiave int:")
print(chiave)

# inserisco il testo

testo = str(input("Inserisci il testo da cryptare: \n"))
testo = testo.replace(" ","")
testo = testo.replace(",","")
testo = testo.replace(":","")
testo = testo.replace(";","")
testo = testo.replace(".","")
diff = ordine_matrice - (len(testo) % ordine_matrice)
if len(testo) % ordine_matrice != 0:
for o in range(diff):
testo = testo + 'x'

print(testo)
lettere = "abcdefghijklmnopqrstuvwxyz"


#fase di encryption

lista_testo = []
alfabeto = ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l",
"m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x",
"y", "z"]

for q in range(len(testo)):
lista_testo.append(testoq)

print("lista: ", lista_testo)

# converto gli elementi della lista con numeri ad essi corrispondenti

for k in range(len(lista_testo)):
for l in range(len(alfabeto)):
if lista_testok == alfabetol:
print("ciao")
lista_testok = l
else:
continue



print("nuova lista: ", lista_testo)

lista_testo = np.vstack(lista_testo)
print("lista testo", lista_testo)
len_lista_testo = int(len(lista_testo) / 2)






f2l = lista_testo[:2]

"""
print("tipo f2l: ", type(f2l))
chiphertext = np.dot(chiave, f2l)
print(chiphertext)
"""



# QUI C'E' IL PROBLEMA.

for i in range(len_lista_testo):
chiphertext = np.dot(chiave, f2l)
for x in range(2):
lista_testo = np.delete(lista_testox, x) # non mi elimina i primi 2
# elementi del vettore colonna
print(lista_testo)
continue

print(chiphertext)


il problema come vedete è nell'ultimo for.

Non capisco come eliminare i primi due elementi del vettore colonna. come faccio?

Grazie della risposta ho risolto!

Ragazzi ho risolto da solo! Per chi volesse saperlo avevo una funzione che veniva richiamata in una classe. All'interno della funzione gestivo un errore con try except ma, se l'errore si presentava e veniva gestito, la funzione continuava il suo corso, così nell' "except:"
ho aggiunto un "return". Ora se si presenta l'errore la funzione termina e torna al punto in cui viene richiamata.

Ciao ragazzi ho un problemino.
Ho una classe "mia_classe" in cui eseguo codice e richiamo una funzione "mia_funzione", il problema è che, in un caso particolare vorrei che nel mezzo della sua esecuzione, la funzione "mia_funzione" smetta di fare quello che dovrebbe continuare a fare e riportarmi, invece, alla classe "mia_classe" dove viene richiamata.

Ho provato con l' exit() importato da "sys", ma sapevo che non avrebbe funzionato, quella blocca il programma.




Consigli?

Grazie in anticipo delle risposte!

Ho risolto no problema alla fine bastava usare una variabile globale.
Grazie dell'aiutoo

non è questione di libri è solo che abbiamo una serie di file, di cui 3 sono di grandi dimensioni (700 - 900 righe di codice)
e parecchie funzioni. Il mio obiettivo è quello di creare una coda prioritaria che possa usare all'interno di ogni singola classe

ciao ragazzi, ho un main che fa partire 3 classi. Se provo anche solo a scrivere una print(), un input, o far partire una funzione prima di richiamare le suddette classi invece, in ogni caso prima mi fa partire prima le classi e poi le print o gli input o le funzioni.



Come faccio a richiamare una funzione quando dico io?

ho provato con le condizioni if - else ma niente.

Ciao ragazzi avrei una domanda.
Come faccio a passare l'elemento di una lista che creo in una funzione all'interno di un'altra funzione?




In pratica voglio creare una lista nella funzione A() e poi stamparne il valore nella funzione B().

Come faccio?




def A():
lista = []
lista.append("ciao")
print(lista0)


if __name__ == "__main__":

A()





















def B():

print(lista0)




--- Ultima modifica di giuseppe giarratana in data 2019-06-20 11:24:36 ---

Slave ragazzi! Ho un problema con il codice nel 'main'. Funziona perfettamente ma vorrei modificarlo per fare una cosa in particolare.

nel main istanzio un albero e lo chiamo 'T'. Poi creo una radice con elemento la stringa "Auto" tramite la riga: ' radice = T._add_root("Auto") '.

Dopo, creata la lista ' lista ', creo il nodo figlio della radice che contiene la lista 'lista', la quale ha 3 elementi (In pratica è un albero generico che può avere più figli, usando come contenitore di tali figli una struttura dati, in questo caso un lista).

Il mio obiettivo è creare un nuovo nodo (lista_opel, lista_citroen, lista_suzuki) che contenga una lista di elmenti, per ogni elemento della lista ' lista '

(in pratica questi nuovi nodi saranno i "nipoti" della radice).




Il problema è che la lista 'lista_opel', e allo stesso modo le altre, diventa un nodo figlio dell'intero lista ' lista ' e non un nodo figlio di uno solo degli elementi della lista 'lista'.




Vorrei creare qualcosa del genere:

ecco l'immagine (scusate se non sono riuscito a inserirla ma era in locale e non su internet)







https://drive.google.com/open?id=1qn1ZRBWmOaYEHzmktafmpRQGLJo6WJya







come vedete dall'immagine il primo nodo ha un genitore "parent", un elemento "element" (New York) e 4 figli "children". I figli sono contenuti all'interno di una struttura dati e ogni elemento della struttura dati ha un nodo figlio con uguali caratteristiche.

Ora, al posto di un nodo con un solo elemento, come quelli che contengono "Baltimore", "Chicago", "Providence", "Seattle", vorrei dei nodi che contengono delle liste.

credo che il procedimento sia lo stesso ma non so davvero come realizzarlo.

Ringrazio chiunque riesca ad aiutarmi lo apprezzerei davvero tanto.









albero.



albero_binario import Albero Binario

class Albero Binario Concatenato(Albero Binario):

class _Node:

__slots__ = '_element', '_parent', '_child'

def __init__(self, element, parent = None, child = None):

self._element = element
self._parent = parent
self._child = child

class Position(Albero Binario.Position):

def __init__(self, container, node):

self._container = container
self._node = node

def element(self):

return self._node._element

def __eq__(self, other):

return type(other) is type(self) and other._node is self._node


def _validate(self, p):

if not isinstance(p, self.Position):
raise TypeError('p deve essere di tipo position')

if p._container is not self:
raise ValueError('p non appartiene a questo contenitore')

if p._node._parent is p._node:
raise ValueError('p non è più valido')
return p._node

def _make_position(self, node):

return self.Position(self, node) if node is not None else None

def __init__(self):

self._root = None
self._size = 0

def __len__(self):

return self._size

def root(self):

return self._make_position(self._root)

def parent(self, p):

node = self._validate(p)
return self._make_position(node._parent)

def child(self, p):

node = self._validate(p)
return self._make_position(node._child)



def num_children(self, p):

node = self._validate(p)
count = 0
if node._left is not None:
count += 1
if node._right is not None:
count += 1
return count


def _add_root(self, e):

if self._root is not None: raise ValueError('la radice esiste')
self._size = 1
self._root = self._Node(e)
return self._make_position(self._root)



def _add_child(self, p, e):

node = self._validate(p)
if node._child is not None: raise ValueError('ha già dei figli. I\n'
'figli devono essere '
'contenuti in una '
'struttura dati.')
self._size += 1
node._child = self._Node(e, node)
return self._make_position(node._child)



def replace(self, p, e):

node = self._validate(p)
old = node._element
node._element = e
return old

def _delete(self, p):

node = self._validate(p)
if self.num_children(p) == 2: raise ValueError('p ha 2 figli')
child = node._left if node._left else node._right
if child is not None:
child._parent = node._parent
if node is self._root:
self._root = child
else:
parent = node._parent
if node is parent._left:
parent._left = child
else:
parent._right = child
self._size -= 1
node._parent = node
return node._element


def _attach(self, p, t1, t2):

node = self._validate(p)
if not self.is_leaf(p): raise ValueError('la posizione deve essere una foglia')
if not type(self) is type(t1) is type(t2):
raise TypeError('gli alberi devono essere dello stesso tipo')
self._size += len(t1) + len(t2)
if not t1.is_empty():
t1._root._parent = node
node._left = t1._root
t1._root = None
t1._size = 0
if not t2.is_empty():
t2._root._parent = node
node._right = t2._root
t2._root = None
t2._size = 0


if __name__ == '__main__':



print("\nALBERO GENERICO\n\n")
T = Albero Binario Concatenato()
if T.is_empty():
print("\nl'albero è vuoto\n")

radice = T._add_root("Auto")
print("l'elemento della radice è: ", radice.element())

lista = ["Opel", "Citroen", "Suzuki"]

marche = T._add_child(radice, lista)

print("figlio Auto: ", marche.element())

lista_opel = ["Astra", "Corsa", "Zafira", "Crossland X", "Agila"]
lista_Citroen = ["C3", "C4", "C1", "Berlingo", "Cactus", "C-Zero"]
lista_Suzuki = ["Jimny", "Swift", "Ignis", "Vitara", "Celerio", "Baleno"]


figli_opel = T._add_child(marche, lista_opel)

print("figlio di opel: ", figli_opel.element())

Grazie mille e scusa se ho tardato a rispondere