Python_zajęcia_7

Wzór Fibriocci'ego + turtle

import turtle
import random

zolwik = turtle.Turtle() # stworz obiekt rysujacego zolwia pod zmienna zolwik
zolwik.speed(2) # ustaw szybkosc zolwia wbudowana metoda speed
zolwik.shape("turtle") # uzyj metody shape do ustawienia wygladu kursora / zolwia
zolwik.pensize(3)

kolory = [
    "CornflowerBlue",
    "DarkOrchid",
    "IndianRed",
    "DeepSkyBlue",
    "LightSeaGreen",
    "wheat",
    "SlateGray",
    "SeaGreen",
]

fibo = [0, 1]
suma_ostatnich = fibo[-1]+fibo[-2]

gorna_granica = 77

while suma_ostatnich <= gorna_granica:
    fibo.append(suma_ostatnich)
    suma_ostatnich = fibo[-1]+fibo[-2]

print(fibo)

# [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]

dl_boku = 20

for mnoznik in fibo[1:]:
    zolwik.fillcolor(random.choice(kolory))
    zolwik.begin_fill()
    for _ in range(5):
        zolwik.forward(dl_boku*mnoznik)
        zolwik.left(90)
    zolwik.end_fill()
    zolwik.forward(dl_boku*mnoznik)

turtle.exitonclick()

Szyfrowanie:

 jak moga dzialać funkcje szyforwania

# I kategoria szyfrowanie: symetryczne - asymetryczne 

# szyfrowanie symetryczne - dwie osoby chca wymieniac miedzy soba wiadomosc 
# wymyslaja hasło - klucz: ktora odszyfruje zaszyforwane haslo
# osoba 1 szyfryjue haslo kluczem - przesyla do osoby 2
# osoba 2 wpisuje klucz - wiadomosc odszyfrowana 

# szyfrowanie asymetryczne - dwie osoby chcac wymienic miedzy soba
# osoba 1 jak i 2 - tworza sobie pare kluczy 
# 1 klucz jest do szafrywonia 
# 2 klucz do odszyfrowania 
# osoba 1 wysyla klucz publiczny do osoby 2,i ppsiaja tylko polowe klucza
# osoba 1 wysyla wiadomosc zaszyfrowana kluczem publicznym osoby 2
# osoba 2 odszyfrowuje wiadomosc swoim kodem prywaatnym 
# nie ma możliwości przechwycenia klucza do odszyfrowania

# ssh - metoda łączenia sie  z zewn.serwerami 
# wymiana kluczy 
# taki klucz składa sie klucz wewn. prywatny i klucz publiczny

ZNAKI = [
    "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",
    "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",
    "Ą",
    "ą",
    "Ć",
    "ć",
    "Ę",
    "ę",
    "Ł",
    "ł",
    "Ń",
    "ń",
    "Ó",
    "ó",
    "Ś",
    "ś",
    "Ź",
    "ź",
    "Ż",
    "ż",
    " ",
    ".",
    "?",
    "!",
]

# powyższa lista znaków ułatwi stworzenie kodu odpowiedzialnego za szyfrowanie

# żeby przy bardzo dużym kluczu , lub przy zamianie znaku z końca listy nie wyjść za nią
# można skorzystać z operatora modulo (to ten od reszty z dzielenia)
# wg. schematu (indeksznaku + klucz) % len(ZNAKI)

# indeksznaku = ZNAKI.index("!")
# print(f"Indeks znaku to: {indeksznaku}")
# klucz = 3
# nowy_indeks = (indeksznaku + klucz) % len(ZNAKI)
# print(f"Po przesunieciu o {klucz} uzyskamy {nowy_indeks}")

# jeśli nie chcemy skorzystać z naszej własnej tablicy znaków,
# to można to też zrobic korzystajac z tablicy znaków Unicode.
# Przydadzą się wtedy funkcje:
# ord - zwraca nr unicode znaku
# chr - zwraca znak po podaniu nr unicode

# klucz = 3
# haslo = input("Podaj hasło: ")

for n in haslo:
    indeksznaku = ZNAKI.index(n)
    nowy_indeks = (indeksznaku + klucz) % len(ZNAKI)
    print(f"Po przesunieciu o {klucz} uzyskamy {nowy_indeks}")
    print(ZNAKI[nowy_indeks])
    print(nowy_indeks)

# tekst = input("Wpisz tekst do zaszyfrowania: ")
# klucz =  int(input("wpisz klucz: "))

# for znak in tekst:
#     indeksznaku = ZNAKI.index(znak)
#     print(f"Indeks znaku to: {indeksznaku}")
#     nowy_indeks = (indeksznaku + klucz) % len(ZNAKI)
#     print(f"Po przesunieciu o {klucz} uzyskamy {nowy_indeks}")

Książka kontaków:

kontakty = {
    "Alice" : "[email protected]",
    "Bob" : "[email protected]",
            }

ilosc_kontaktow = ""
imie = ""
mail = ""
nowe_kontakty = {imie: mail}

while True:
    print("Książka kontaktowa:")
    print("Wybierz operację:")
    print("1 - dodanie wpisu")
    print("2 - aktualizacja wpisu")
    print("3 - usunięcie wpisu")
    print("4 - wydruk wszystkich kontaktów")
    print("5 - wydruk konretntego kontaktu")
    print("6 - koniec programu")

    wybor = input("Podaj kod operacji: ")

    if wybor == "1":
        print("")
        ilosc_kontaktow = int(input("Podaj liczbe kontaktów do dodania: "))
        for _ in range(ilosc_kontaktow):
            input('Nacisnij ENTER aby kontynuować.')
            print('\033c', end='')
            imie = input("Podaj imię: ")
            mail = input("Podaj mail: ")
            if imie in kontakty: 
                print('')
                print("Kontakt istnieje.")
                print('')
                input('Nacisnij ENTER aby kontynuować.')
                print('\033c', end='') 
            else:
                kontakty[imie] = mail
                print('')
                print("Kontakt został dodany.")
                print('')
                input('Nacisnij ENTER aby kontynuować.')
                print('\033c', end='')

    elif wybor == "2":
        print('')
        imie = input("Podaj imię: ")
        if imie in kontakty:
            print('')
            mail = input("Podaj mail: ")
            kontakty[imie] = mail
            print('')
            print(kontakty)
            input('Nacisnij ENTER aby kontynuować.')
            print('\033c', end='') 
        else: 
            print("Brak wpisu na liście kontaktów")
            print("Dodaj nowy wpis, za pomocą klawisza 1")
            print('')
            print(kontakty)
            print('')
            input('Nacisnij ENTER aby kontynuować.')
            print('\033c', end='')

    elif wybor == "3":
        print('')
        imie = input("Podaj imię: ")
        kontakty.pop(imie, "brak kontaktu")
        print('')
        print(kontakty)
        print('')
        input('Nacisnij ENTER aby kontynuować.')
        print('\033c', end='')

    elif wybor == "4":
        print(kontakty)
        print('')
        input('Nacisnij ENTER aby kontynuować.')
        print('\033c', end='')

    elif wybor == "5":
        print('')
        imie = input("Podaj imię: ")
        print(kontakty.get(imie, "brak kontaktu"))
        input('Nacisnij ENTER aby kontynuować.')
        print('\033c', end='')

    elif wybor == "6":
        print("Koniec programu")
        print('\033c', end='')
        break
    else:
        print("Nie ma opcji o podanym kodzie.")
        print('\033c', end='')   

Powtórka ze struktur:

 
1. Lista(list) - uporządkowana, mutowalna, pozwala na duplikaty

list = [1, 2, 2, 3, 4] 
list.append(4) #dodanie elementu na koniec
list.extend #dodaje do listy elementy z innej listy
list.insert(i, x) #wstawia element x na **miejsce elementu** i
list[x] #dostęp do elementu po indexie
list.count(x) #zwraca liczbę wystąpień elementu x
list.count(2)
print(list.count(2)) -> (2)

list.remove(2) #usuwa pierwsze wystąpienie zduplikowanego elementu
list.pop([x]) #usuwa element o indexie i & go zwraca (domyślenie ostani)

list.sort(key=None, reverse=False) #sortuje liste "na miejscu" (modyfikuje oryginał)
list.reverse() #odwraca elementy listy /nie sortuje, tylko odwraca /

list.copy() #zwraca płytką kopie listy
    .copy() albo lista[:] → płytka kopia (nowa lista, ale elementy to referencje do tych samych obiektów).
    copy.deepcopy(lista) → głęboka kopia (tworzy całkowicie nowe obiekty, niezależne od oryginału).
    
m = list.copy()
m[4] = 99
print(list)
print(m)
wynik: list = [1, 2, 2, 3, 99]

list_2 = [[1, 2], [3, 4]]
kopia = lista.copy()     # płytka kopia

print(lista)  # [[1, 2], [3, 4]]
print(kopia)  # [[1, 2], [3, 4]]

# zmieniamy element w zagnieżdżonej liście
lista[0][0] = 99

print(list_2)  # [[99, 2], [3, 4]]
print(kopia)  # [[99, 2], [3, 4]]  <-- kopia też się zmieniła!

import copy

list_2 = [[1, 2], [3, 4]]
kopia = copy.deepcopy(lista)

lista[0][0] = 99

print(lista)  # [[99, 2], [3, 4]]
print(kopia)  # [[1, 2], [3, 4]]  <-- niezależna kopia

len(list) #zwraca ilość elementów w liście
print(len(list)) 
sum(list) #sumuje wszystkie elementy listy
print(sum(list))
max(list) #zwraca największy element listy
min(list) #zwraca najmniejszy element listy

2. Krotka (tuple) - uporządkowana, niemutowalna
Krotka ma tylko dwie metody: 
tuple = (1, 2, 2, 3, 4)
tuple.count(x) #zwraca liczbę wystąpień elementu x
tuple.count(2)
print(list.count(2)) -> (2)

index(x, [start], [stop]) #zwraca index pierwszego wystąpienia x
tuple = (1, 2, 3, 2, 4)
print(tuple.index(2)) #zwróci mi index pierwszego wystąpienia elementu (2) czyli 1. 
print(tuple.index(2, 2) #zwróci index drugiego wystąpienia elementu (2)

3. Zbiór (set) - nieuporządkowany, unikalne elementy(bez powtórzeń, jeśli chcemy szybko usunąć zduplikowane ****elementy -> zamieniamy set na list -> a następnie list na set. ****

set.add() #dodaje elementy zbioru
set.update() #dodaje elementu z innego zbioru iterowalnego
set.remove() # usuwa element, jeśli istnieje / jeśli nie KeyError
set.discard() #usuwa elementy, ale nie rzuca błędu jesli nie istnieje
set.pop() #usuwa i zwraca losowy element
set.clear() #usuwa wszystkie elementy

4. Słownik (dict) - para klucz:wartość
dict.keys #zwraca widok wszystkich kluczy
dict.values #zwraca widok wszystkich wartości
dict.items #zwraca widok wszystkich par

*#WAŻNE! GRAMATYKA W PYTHON JEST BARDZO WAŻNA. KAŻDY NAWIAS, KAŻDA PODŁOGA 
#MA ZNACZENIE. JESLI ZABRAKNIE KTOREGOS Z NAWIASÓW W W/W KOMNEDZIE PYTHON SIE WYSYPIE; 
#! WAŻNA II! rezultat metody .keys() jest to 'NIEZWYKŁA LISTA' po której można 'ITEROWAĆ'
#! Iteracja = przechodzenie element po elemencie w strukturze danych.
# dzięki temu możemy łatwo przetwarzać wszystkie elementy jednej kolekcji.
# przydaje się to w momencie kiedy musimy przeglądnąć liste w pętli; 
# w przypadku metody (list.(dict.keys())) otrzymjujemy zwykłą listę bez możliwośći ITERRACJI; 

# analogicznie jeśli chcemy uzyskać/wyciągnąć wartości /values/ używamy komendy: .values()
# lista wartości: list("nazwasłownika".values())*

dict.get(key, default=None) #zwraca wartość dla klucza, albo default jeśli klucza nie ma
dict.setdefault(key, default=None) #zwraca wartość pod klucz, jeśli klucza nie ma -> wstawia wartość default

dict.update({:}) #aktualizuje słownik na podstawie innego słownika lub par klucza:wartość
dict[key] = values #aktualizuje wartość już istniejącego elementu

#?Klamry {} – tworzą słownik, czyli pary klucz–wartość.
#?Nawiasy okrągłe () – oznaczają wywołanie metody update.
#?Wywołujesz funkcję update, która przyjmuje jeden argument – słownik z elementami do dodania.
Czyli:
#! [] → operator bezpośredni (przypisanie lub dostęp do pojedynczego klucza).
#! () + {} → wywołanie metody z argumentem w postaci słownika (dla wielu elementów).

#* Podsumowanie: 
#* Co robimy	Składnia	Działanie:
#todo Pojedynczy klucz–wartość	dictionary["history"] = 3	Przypisanie wartości do klucza
#TODO Dodanie wielu klucz–wartości	dictionary.update({"history":3,"biology":5})	
#* Wywołanie metody update z argumentem – słownikiem

dict.pop(key, [default]) #usuwa elementy o danym kluczu i zwraca jego wartość. 
( jeśli klucza brak i brak default ) = KeyError

dict.popitem() #usuwa ostatnio dodaną parę (klucz:wartość)
dict.clear #usuwa zawartość całego słownika

dict.copy() #zwraca płytką kopie słownika

## To oznacza, że nowy słownik będzie niezależnym obiektem, ale jeśli wartościami są obiekty mutowalne (np. listy), to nadal będą współdzielone.
## 

dict.fromkeys(old_dict, value=None) #tworzy nowy slownik z podanymi kluczami, przypisując im tą samą wartość 

old_dict = ["a", "b", "c"]
new_dict = dict.fromkeys(old_dict)
print(slownik)
# {'a': None, 'b': None, 'c': None}

old_dict = ["a", "b", "c"]
new_dict = dict.fromkeys(old_dict, 0)
print(slownik)
# {'a': 0, 'b': 0, 'c': 0}

funkcje wbudowane: 

dict.led() # liczba elementów słownika
dict.sorted() # posortowana liczba kluczy
dict.in #sprawdza czy klucz istnieje