Какво ще изведе този код?

foods = ['spam', 'eggs', 'ham']
things = foods
things[1] = 'chips'
print(foods[1])

А този?

a = ['spam', 'eggs', 'ham']
b = a
c = a[:]
print(a is b, a is c)
print(a == b, a == c)
b[1] = 'milk'
print(a is b, a is c)
print(a == b, a == c)

my_string = '1234567890'
>>my_string[10]

IndexError: string index out of range

my_data = set(range(10))

for x in my_data:
    print(x)
    break

Ще изпринти един от елементите, без гаранция кой

{}
set()
1
None
True
[1, 2, 3]
(1, 2, 3)
12.0
'абвг'
lambda x: x**0
print, 5, 6, 7, 8

Кои от тези са валидни ключове за dict?

1, None, True, (1, 2, 3), 12.0, 'абвг', lambda-та и (print, 5, 6, 7 ,8)

my_dict = dict('12 34 16'.split() + [(False, False)])
print(len(my_dict), my_dict[0])

3 False

Според нас не сте

Има регистрирани грубо около 150 човека, предадени са ~70 решения

Имате време до началото на следващата ни среща, откровено не ви съветваме да чакате последния момент.

Забелязахме някои подробности в това, което е предадено до момента, на които е важно да обърнем внимание, за да имате време да ги поправите преди края на срока на домашното

if thingie == 'zero':
    return 0
elif thingie == 'one':
    return 1

elif thingie == 'THE ANSWER':
    return 6*7
else:
    return 'You are confusing me! STAHP!'

Само ако в python имаше някакъв вграден тип структура, която може да асоциира един обект с друг… Може би нещо, което да можем да индексираме с 'THE ANSWER' и то да ни върне 42… Би било супер яко!

number_names = {
    0: 'zero',
    1: 'one',
    2: 'two',
    …
    42: 'THE ANSWER'
}

В древните програмистки книги се говори за митична структура от данни, която подрежда елементите си линейно в паметта и може да бъде индексирана с числата 0, 1, 2 и т.н., за да получаваме елемента на съответната позиция в нея. Някои смели душѝ дори твърдят, че има имплементация на такова нещо в python.

Казано е, че двете най-трудни неща в програмирането са

• Кръщаване на неща
• Адекватна инвалидация на кеш
• Off-by-one грешки

Ако една константна стойност се срещне повече от веднъж в кода ви, то тя задължително трябва да стане стойност на променлива или константа

Едно добро решение на това домашно спокойно може да се случи в рамките на 50-60 реда при просторно подреждане на нещата, така че да се четат лесно

Има добри решения и на по 20, но не искаме да се стремите към такива неща

НЕ ПРЕДАВАЙТЕ ФУНКЦИИ, КОИТО НЕ СЕ ПОЛЗВАТ! Така решенията ви стават по-тежки за четене и осмисляне, без това да допринася с нищо

Решението на тази задача се състои единствено от функции, които трябва да са „глобални“ във файла с решението. Можете да дефинирате всякакви спомагателни функции, променливи, класове и каквото си желаете(макар че други функции и класове по-скоро не са нужни), но функциите описани в условието трябва да са видими в глобалната област на файла с решението.

не

class solution:
    def interpret_western_sign(day, month):
        …

    def interpret_chinese_sign(year):
        …

да

def interpret_western_sign(day, month):
    …

def interpret_chinese_sign(year):
    …

1. Запазете вашето решение във файл с името `solution.py`.
2. Свалете `sample_test.py` в същата директория, в която е решението ви
3. През командния ред на операционната си система отидете във въпросната директория
4. Изпълнете `python3.4 sample_test.py`
5. Ако имате дълбока фундаментална грешка в решението си, това ще ви покаже каква е

PEP8! Това е конвенцията за стил на Python. Задължително спазване!

• Индентация с 4 интервала за всяко ниво на влагане
• Максимално 79 символа на ред!
• snake_case за имена на функции, методи, променливи, параметри
• имена на "константи" в SCREAMING_SNAKE_CASE
• _turn_around, __seriously_turn_around за "частни"("private")
• използване на запазени думи? 1 подчертавка след името: range_, но..
• по-добре използвайте друго име

PEP8! Това е конвенцията за стил на Python. Задължително спазване!

• интервал след "," при изброяване и ":" при конструиране на dict: [1, 2, 3] {1: 2, 2: 4, 13: 26}
• без интервали след (, [, { и след ), ], }: func(1, 2, 3), [5, 6, 7, 8]
• по един интервал около оператори: a == b; 3 > 4; "abra" + "-" + "kadabra"
• изключение: може да липсват около оператори с по-висок приоритет в подходящ контекст: 42 - 6*9
• без интервали, когато задаваме стойност по подразбиране: def my_func(a, b, option=True): ..
• и при подаване на именовани параметри при извикване my_func(option=False, b=13, a=666)
• без скоби около условията на while/for/if/elif/return: while True; return my_result ...

Още много от източника

Никой не е запомнил целия pep8 само с четене

Всеки редактор може да бъде конфигуриран, така че да използва pep8, за да проверява кода ви и да се кара, когато не правите нещо правилно

Научете се как да ползвате добре редактора, който сте си избрали, това е много важно

pip install pep8

По същество за колекции

Когато имаме данни, най-логично е да ги слагаме в колекции.

• list (a.k.a. array, масив) = подредена последователност от стойности
• tuple = непроменяема по състав подредена последователност от обекти (~списък, но не съвсем)
• set = стойности без повтаряне и без подредба (множество в математическия смисъл)
• dict = ключове/имена, зад които стоят стойности (без подредба)

• В Python всички колекции са итерируеми (iterable)
• Един итерируем обект може да бъде обхождан последователно (поне веднъж)
• Някои могат да бъдат обхождани многократно или непоследователно

nice_things = ['coffee', 'cheese', 'crackers', 'tea']
for thing in nice_things:
    print('I tend to like {}'.format(thing))

можем и просто да ги индексираме

print(nice_things[1]) # cheese
print(nice_things[-1]) # tea
print(nice_things[-3]) # cheese

Списъците съдържат "указатели" към елементи

coffee, cheese, crackers, tea = 'coffee', 'cheese', 'crackers', 'tea' # unpacking
things_i_like = [coffee, cheese, crackers]
things_you_like = [crackers, coffee, tea]

things_i_like[0] == things_you_like[1] # True
things_i_like[0] is things_you_like[1] # True

Това позволява някои интересни неща

cheeses = ['brie', 'bergkäse', 'kashkaval', 'leipäjuusto']
cheeses.append(cheeses)

cheeses[-1] is cheeses # True
print(cheeses) # ['brie', 'bergkäse', 'kashkaval', 'leipäjuusto', [...]]

• .index(element) - Индексът на първото срещане на element в списъка или гърми с ValueError
• .count(element) - Броят срещания на element в списъка
• .append(element) - Добавя element в края на списъка
• .extend(elements) - Добавя елементите на elements в списъка (като + ама по-бързо)
• .sort() - Сещате се
• ...

range връща итерируемо за интервал от числа

numbers = range(3)

for number in numbers:
    print('We can count to {}'.format(number))

range интервалът може да не започва от нула

numbers = range(10, 13)

for number in numbers:
    print('We can count to {}'.format(number))

последователност, n-торка(n-орка), тюпъл

като списък, но с постоянен състав

people = ('Niki', 'Kiro', 'Genata')
people[2] # Genata
people[1] # Kiro
people[0] # Niki

people[1] = 'бобър'

Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment

кортеж

последователността от елементи в кортежа не може да се променя, самите елементи може да изменят вътрешната си структура

change_me = ([1, 2, 3], [4, 5, 6], [7, 8, 9])
change_me[1][1] = 0
change_me[2][0] = 'c'

print(change_me) # ([1, 2, 3], [4, 0, 6], ['c', 8, 9])

алтернативен синтаксис за кортежи

people = 'Niki', 'Kiro', 'Genata'
people = 'Niki',

people = ('Niki') # най-вероятно не е каквото очаквате

Има методите `index` и `count` като на списъците

Ако имате n-торка, съдържаща само имена от лявата страна на присвояване, може да постигнете интересни ефекти:

(a, b) = 1, 2
print(a)  # 1

Всъщност скобите изобщо не са задължителни

a, b = 1, 2
print(a)  # 1

Или

numbers = (1, 2, 3)
a, b, c = numbers

Можем да правим и така:

a, *b, c = 1, 2, 3, 4, 5
a = 1
b = [2, 3, 4]
c = 5

Сравняват се лексикографски:

>>> (1, 2) < (1, 3)
True
>>> (1, 2) < (1, 2)
False
>>> (1, 2) < (1, 2, 3)
True
>>> [1, 2] < [1, 3]
True
>>> (1, 2) < [1, 3] # tuple vs. list
# поражда грешка:
#    TypeError: unorderable types: tuple() < list()

Опашка (queue, FIFO buffer) - можете да ползвате списък.

adjectives = []

def add_adjective(items):
    adjectives.append(items)

def get_adjective():
    return adjectives.pop(0)

add_adjective('Magic')
add_adjective('Woody Allen')
add_adjective('Zombie')
add_adjective('Superhero')

print(' '.join(adjectives) + ' Jesus!') # Magic Woody Allen Zombie Superhero Jesus!

Stack?

Множества(за всякакви практически цели, неразличими от математическата абстракция със същото име)

favourite_numbers = set()
favourite_numbers.add(13)
favourite_numbers.add(73)
favourite_numbers.add(32)
favourite_numbers.add(73)
favourite_numbers.add(1024)
favourite_numbers.add(73)

print(favourite_numbers) # {32, 73, 666, 13, 1024}

Множествата са итерируеми и НЕподредени

for num in favourite_numbers:
    print('I really like the number ' + str(num))

можем да проверяваме за принадлежност

73 in favourite_numbers # True

Има синтаксис за създаване на множества(както може би сте се досетили)

favourite_numbers = {32, 73, 666, 13, 1024}

{} не е празния set!

Индексите не винаги са достатъчно информативни

artist_names = {
    'Eddie': 'Vedder',
    'Maynard': 'Keenan',
    'Matthew': 'Bellamy',
    'James': 'LaBrie',
}

print('Eddie\'s last names is ' + artist_names['Eddie'])

{} е празен речник, по простата причина, речниците са доста по-често използвана структура от множествата

можем да добавяме нови стойности във вече създаден речник

names['Devin'] = 'Townsend'

print(names) # {'Devin': 'Townsend', 'Matthew': 'Bellamy', 'Eddie': 'Vedder', 'James': 'LaBrie', 'Maynard': 'Keenan'}

речникът също е неподреден

Чрез наименовани параметри към конструктора (не питайте):

>>> dict(france="Paris", italy="Rome")
{'italy': 'Rome', 'france': 'Paris'}

Чрез списък от двойки

>>> dict([('One', 'I'), ('Two', 'II')])
{'Two': 'II', 'One': 'I'}

Чрез списък от ключове и стойност по подразбиране

>>> dict.fromkeys([1, 2, 3], 'Unknown')
{1: 'Unknown', 2: 'Unknown', 3: 'Unknown'}

• Функция от вид: обект → число
• Не е нужно да е инективна
• Ако два обекта са еднакви по стойност, те имат еднакъв хеш
• Възможно е различни обекти да имат еднакъв хеш
• За да работят речниците и множествата, ключовете трябва да могат да се сравняват с ==
• Добре е това да става по смислен начин
• Желателно е ключовете да са immutable

• map(function, iterable) създава колекция от резултатите от прилагането на function върху всеки елемент от iterable
• filter(function, iterable) създава колекция само с елементите, за които function върне True
• reduce(function, iterable) вика function с елементите на колекцията, докато сведе всичко до една стойност (във functools виж тук)
• all(iterable) всички елементи се оценяват на истина
• any(iterable) поне един от елементите се оценява на истина

за любознателните: map и filter са мързеливи

• Изрази, които генерират колекции
• Елегантен заместител на map и/или filter
• Колекциите могат да са динамични

Един list comprehension може да се вложи в друг, защото връща нещо итерируемо

>>> [(x, y) for x in [1,2,3] for y in [3,1,4] if x != y]
[(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]

• Кръгли скоби вместо квадратни
• Като list comprehension, но се изпълнява динамично (lazy evaluation)
• На всяка стъпка итераторът оценява условието и израза за следващата стойност

• Като list comprehension, но с { }

>>> import math
>>> {int(math.sqrt(x)) for x in range(1,100)}
{1, 2, 3, 4, 5, 6, 7, 8, 9}

• deque - двупосочни опашки
• OrderedDict - речник, който помни реда
• defaultdict - речник със стойност по подразбиране
• Counter - set, който брои повтарящи се стойности

• Обърнахте ли внимание, че ползвахме cute_animals, а не cute_animal_list?
• Използвайте вградените литерали за да създавате колекции

• http://fmi.py-bg.net/
• fmi@py-bg.net
• @pyfmi