Великденски Яйца

Програмиране с Python

Курс във Факултета по Математика и Информатика към СУ

Решение на Пет малки функции от Георги Павлов

Обратно към всички решения

Към профила на Георги Павлов

Резултати

  • 10 точки от тестове
  • 0 бонус точки
  • 10 точки общо
  • 19 успешни тест(а)
  • 0 неуспешни тест(а)

Код

def extract_type(symbols, symbol_type):
text = ""
for symbol in symbols:
if type(symbol[0]) is symbol_type:
for _ in range(symbol[1]):
text += (str(symbol[0]))
return text
def reversed_dict(normal):
return {value: key for key, value in normal.items()}
def flatten(key, value):
if isinstance(value, dict):
return [(key + '.' + k, v) for k, v in flatten_dict(value).items()]
return [(key, value)]
def flatten_dict(unflattened):
return {pair[0]: pair[1] for key, value in unflattened.items()
for pair in flatten(key, value)}
def make_nested_dict(keys, value, unflattened):
nested = unflattened
for key in keys[:-1]:
if key not in nested:
nested[key] = {}
nested = nested[key]
nested[keys[-1]] = value
def unflatten_dict(flat):
unflattened = {}
for key, value in flat.items():
keys = key.split('.')
make_nested_dict(keys, value, unflattened)
return unflattened
def reps(sequence):
return tuple([x for x in sequence if sequence.count(x) > 1])

Лог от изпълнението

...................
----------------------------------------------------------------------
Ran 19 tests in 0.162s

OK

История (3 версии и 2 коментара)

Георги обнови решението на 22.03.2015 17:36 (преди над 9 години)

+def extract_type(symbols, symbol_type):
+ text = ""
+ for symbol in symbols:
+ if type(symbol[0]) is symbol_type:
+ for _ in range(symbol[1]):
+ text += (str(symbol[0]))
+ return text
+
+
+def reversed_dict(normal):
+ return {value: key for key, value in normal.items()}
+
+
+def flatten(key, value):
+ if isinstance(value, dict):
+ return [(key + '.' + k, v) for k, v in flatten_dict(value).items()]
+ return [(key, value)]
+
+
+def flatten_dict(unflattened):
+ return {pair[0]: pair[1] for key, value in unflattened.items()
+ for pair in flatten(key, value)}
+
+
+def make_nested_dict(keys, value, unflattened):
+ nested = unflattened
+ for key in keys[:-1]:
+ if key not in nested:
+ nested[key] = {}
+ nested = nested[key]
+ nested[keys[-1]] = value
+
+
+def unflatten_dict(flat):
+ unflattened = {}
+ for key, value in flat.items():
+ keys = key.split('.')
+ make_nested_dict(keys, value, unflattened)
+ return unflattened
+
+
+def reps(sequence):
+ return tuple([x for x in sequence if sequence.count(x) > 1])

Георги обнови решението на 22.03.2015 17:45 (преди над 9 години)

def extract_type(symbols, symbol_type):
text = ""
for symbol in symbols:
- if type(symbol[0]) is symbol_type:
+ if isinstance(symbol[0], symbol_type):
for _ in range(symbol[1]):
text += (str(symbol[0]))
return text
def reversed_dict(normal):
return {value: key for key, value in normal.items()}
def flatten(key, value):
if isinstance(value, dict):
return [(key + '.' + k, v) for k, v in flatten_dict(value).items()]
return [(key, value)]
def flatten_dict(unflattened):
return {pair[0]: pair[1] for key, value in unflattened.items()
for pair in flatten(key, value)}
def make_nested_dict(keys, value, unflattened):
nested = unflattened
for key in keys[:-1]:
if key not in nested:
nested[key] = {}
nested = nested[key]
nested[keys[-1]] = value
def unflatten_dict(flat):
unflattened = {}
for key, value in flat.items():
keys = key.split('.')
make_nested_dict(keys, value, unflattened)
return unflattened
def reps(sequence):
return tuple([x for x in sequence if sequence.count(x) > 1])

Георги обнови решението на 23.03.2015 12:29 (преди над 9 години)

def extract_type(symbols, symbol_type):
text = ""
for symbol in symbols:
- if isinstance(symbol[0], symbol_type):
+ if type(symbol[0]) is symbol_type:
for _ in range(symbol[1]):
text += (str(symbol[0]))
return text
def reversed_dict(normal):
return {value: key for key, value in normal.items()}
def flatten(key, value):
if isinstance(value, dict):
return [(key + '.' + k, v) for k, v in flatten_dict(value).items()]
return [(key, value)]
def flatten_dict(unflattened):
return {pair[0]: pair[1] for key, value in unflattened.items()
for pair in flatten(key, value)}
def make_nested_dict(keys, value, unflattened):
nested = unflattened
for key in keys[:-1]:
if key not in nested:
nested[key] = {}
nested = nested[key]
nested[keys[-1]] = value
def unflatten_dict(flat):
unflattened = {}
for key, value in flat.items():
keys = key.split('.')
make_nested_dict(keys, value, unflattened)
return unflattened
def reps(sequence):
return tuple([x for x in sequence if sequence.count(x) > 1])

Имам въпрос относно сравнението на типове с isinstance() и type(). В pep8 пише, че трябва да се ползва isinstance(), за да се сравняват типове, но когато промених решението си и днес пуснах едни от допълнителните тестове във форума, се оказа, че isinstance() приравнява bool към int. Това означава ли, че в определени случай трябва да се използва type() и да се пренебрегне style guide-а?

По-добра идея е да се използваш isinstance, тъй като той би върнал истина, че инстанции на collections.defaultdict и collections.OrderedDict са инстанции на dict, тъй като първите наследяват от dict.

Когато ви дадохме домашното все още не ви бяхме показали isinstance и на последната ни лекция споменахме, че няма да сме критични по тази тема. Т.е. в реда на нещата е да използвате type, конкретно за тази задача.

Причината isinstance(True, int) да връща истина е, че в питон bool наследява от int:

>>> True.__class__.__mro__
<<< (bool, int, object)

Гледай на това като на имплементационен детайл, който поради една или друга причина прави това възможно:

>>> True + True
<<< 2

>>> 8 * (True + True)
<<< 16

>>> True + True - False
<<< 2

>>> 8 * False
<<< 0