TI/Zadania powtórzeniowe

Z Brain-wiki

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.