TI/Zadania powtórzeniowe

Zadania

pętle for i while

• Rozpisz działanie programów podobnie jak w poniższym przykładzie

1. i = 0
2. while i < 3: 
3.     print i
4.     i += 1

Wykonanie programu:

1. i = 0

2. i = 0 (i<3 = True)
3. i = 0
4. i = 1

2. i = 1 (i<3 = True)
3. i = 1
4. i = 2

2. i = 2 (i < 3 = True)
3. i = 2
4. i = 3 

2. i = 3 (i < 3 = False)

Koniec.

1. l = ['a', 'b', 'c']
2. for x in l:
3. 	print x

1. l = ['a', 'b', 'c']

2. x = 'a', l = ['a', 'b', 'c']
3. x = 'a', l = ['a', 'b', 'c']

2. x = 'b', l = ['a', 'b', 'c']
3. x = 'b', l = ['a', 'b', 'c'] 

2. x = 'c', l = ['a', 'b', 'c']
3. x = 'c', l = ['a', 'b', 'c']

koniec

• Przepisze następującą funkcję z pętlą while na funkcję z pętlą for, robiącą to samo:

def fun_while(n):
	while i < n:
		print i
		i += 1

odp:

def fun_for(n):
	for i in range(n):
		print i

• Dana jest funkcja:

def wypisz(l):
	for el in l:
		print l

Wywołaj tę funkcję dla listy

lista = [1,2,3,4,5]

i przypisz wynik wywołania na zmienną x.

# odp
x = wypisz(lista)

1. Co ta funkcja ZWRACA?

Odp: None -- jeśli nie ma instrukcji return, zwracającej coś, co chcemy zwrócić, funkcja przez nas zdefiniowana i tak będzie coś zwracać -- konkretnie None.

Gdyby funkcja wyglądała np. tak:

def wypisz(l):
	for el in l:
		print l
	return len(l)

to odpowiedzią byłoby, że zwraca długość listy l.

2. Co ta funkcja ROBI?

Odp: Wypisuje elementy listy l

3. Przepisze tę funkcję tak, aby odwoływać się do jej elementów poprzez ich indeks, tzn, żeby instrukcja wypisania wyglądała tak:

print lista[i]

Odp:

def wypisz(l):
	for i in xrange(len(l)):
		print l[i]

4. Przepisz funkcję tak, aby wypisuwała tylko elementy o parzystym indeksie

Odp:

def wypisz(l):
	for i in xrange(len(l)):
		if i%2 == 0:
			print l[i]

5. Napisz funkcję, która znajduje największy element na liście liczb "lista" i zwraca jego index.

Odp:

lista = [1,2,3,4,5,6,7,8]

def max(l):
	m = l[0]
	idx = 0
	for i in range(1,len(l)):
		if l[i] > m:
			idx = i
			m = l[i]
	
mx = max(l)

• Przepisz daną pętlę for na while. Pamiętaj, żeby nie dopuścić do wyjścia poza zakres tablicy.

n = 100
l = ...
w = [0 for i in range(n)]

for i in xrange(n):
	for j in xrange(i, n):
		if l[i] < l[j]:
			w[i] += 1

• Podaj dane, dla których następujący fragment kodu zakończy się błędem

szukany = 10
i = 0
a = [1,2,3,4,5, 6,7,8,9,10,11,12]
while a[i] < szukany:
	i += 1

• Przepisz powyższą pętlę while na pętlę for.

• Napisz petle, która dla listy liczby zwróci listę wieksze t. ze wieksze[i] to ilosc liczb z listy liczby poprzedzajacych liczbe liczby[i] i wiekszych od niej.

Przykladowe dane: liczba = [1,1,1,4,4,5,2,3,4]

Przykladowa odpowiedz: wieksze = [0,0,0,0,0,0,3,3,1]

listy: wycinki i inne operacje

• Masz danę listę l. Napisz wyrażenie, które poda:
  • jej ostatni element
  • 4 ostatnie elementy
  • co czwarty element
  • pierwsze 4 elementy
  • odwroconą listę
  • listę l bez jej 4 ostatnich elementów

• Utwórz listę N pustych list. Napisz funkcję
  • multi_push(stos, element, indeks), która na listę nr "indeks" z listy "stos" dodaje element "element".
  • multi_pop(stos, indeks), która z listy nr "indeks" z listy "stos" usuwa ostatni element.

Przetestuj działanie napisanych funkcji.

• co się stanie po wykonaniu operacji:

a = 2 * [[]]
a[0].append(1)
a[1].append(2)

słowniki, krotki i inne

• Utwórz słownik o kluczach: "k1", …, "kn" i wartościach 1,…,n

• Napisz wyrażenie, które
  • zwróci klucze słownika
  • zwróci wartości słownika
  • wypisze dla każdej pozycji ze słownika parę klucz, wartość

• Sprawdz, czy kluczami w słowniku mogą być:
  • napis
  • liczba
  • krotka
  • lista

Krótka ściąga ze słowników:

>>> dict = {}
>>> dict["Klucz"] = 0
>>> dict
{'Klucz': 0}
>>> dict["klucz"] = 1
>>> dict
{'Klucz': 0, 'klucz': 1}
>>> dict[("krotka","napisow")] = ("inna","krotka")
>>> dict
{'Klucz': 0, 'klucz': 1, ('krotka', 'napisow'): ('inna', 'krotka')}
>>> dict[("krotka","napisow")]
('inna', 'krotka')
>>> del dict["Klucz"]
>>> dict
{'klucz': 1, ('krotka', 'napisow'): ('inna', 'krotka')}
>>> dict.clear()
>>> dict
{}

• Czym się różni krotka od listy? Kiedy używamy krotek, a kiedy list i dlaczego?

zapis / odczyt pliku binarnego / tekstowego: struckt.pack, read, write, open, numpy.fromfile, numpy loadtxt

• Zapisz do pliku liczby z listy 5 * range(10) jako typ double w systemie little endian. Następnie wczytaj plik, żeby skontrolować poprawność zapisu.

Funkcje

• Opisz jakie wartości w których momentach wykonania poniższego fragmentu kodu będą się znajdowały na zmiennej x.

x = 6
def fun(x):
    def fun1():
        global x
        x += 1
        return x
    def fun2():
        global x
        x -= 1
        return x
    y = fun2()
    x = 0
    return x
x = 7
print fun(x)
print x

Obiekty mutable i immutable

• Jaki będzie wynik działania poniższego fragmentu kodu:

l1 = range(10)
def modify(l1, l2, l3, l4):
	l1.append(5)
	l2[0] += 3
	l3 = []
	l4 = [2*x for x in l4]
	print l4

modify(l1,l1,l1,l1)
print l1

 

przekazywanie argumentów przez * i przez **

• Uzupełnij definicję funkcji:

def onestar(*a):

tak, aby wypisywała otrzymane argumenty i zwracała ich liczbę. Napisz przykładowe wywołanie.

• Uzupełnij definicję funkcji:

def twostar(**a):

tak, aby wypisywała otrzymane argumenty i zwracała ich liczbę. Napisz przykładowe wywołanie.

operacje macierzowe

• Mając dane wektory x i y oblicz wartość wyrażenia:

[math] \sum_{i=1}^N \left( y_i-x_i\right)^2[/math]

korzystając z operacji maceirzowych -- nie używając pętli.

reshape / x::n

• Korzystając z "wycinków" / numpy.reshape przekształć następującą macierz:

a = np.array([5 * range(10)])

tak, aby:
wynik[i] == [i,i,i,...]

broadcasting

• Mając daną macierz a, t.że a.shape = (3,) oraz b, t.że b.shape = (5,) wygeneruj macierz c t.że c[i,j] = a[i]*b[j]

• Na podstawie następującego kawałka kodu:

a = np.array([np.arange(5) + i for i in range(3)])
bbb = np.arange(30)
bbb = np.reshape(bbb,(3,-1,5))
aa = np.reshape(a, (3,1,5))
ccc = aa + bbb

Naszkicuj na kartce jak będą wyglądały kolejne powstające macierze.