Python

Python — один из популярнейших языков, который активно используется в анализе данных и машинном обучении, при разработке ПО, в автоматизации и так далее. Такая популярность обусловлена простотой в использовании и лёгкостью в его освоении.

По этим же причинам не составит большого труда освоить 30 коротких фрагментов кодов, которые мы рассмотрим ниже. Попробуем сделать это за 30 секунд?

Строки

Анаграммы

Метод проверяет, являются ли анаграммами две строки. Анаграмма — это слово или набор символов, образованных перестановкой букв другого слова или набора символов. Причём каждая буква или символ используется только один раз.

from collections import Counterdef anagram(first, second):
    return Counter(first) == Counter(second)
anagram("abcd3", "3acdb") # True

Палиндром

Проверяет, является ли строка палиндромом:

def palindrome(a):
    return a == a[::-1]palindrome('mom') # Trueпамяти

Получение гласных строки

Получает гласные английского алфавита в строке:

def get_vowels(string):
    return [each for each in string if each in 'aeiou'] 
get_vowels('foobar') # ['o', 'o', 'a']
get_vowels('gym') # []

Капитализация слов строки

Используйте title(), чтобы сделать заглавными первые буквы всех слов строки:

s = "programming is awesome"print(s.title()) # Programming Is Awesome

Декапитализация

Делает первую букву данной строки строчной:

def decapitalize(string):
    return str[:1].lower() + str[1:]
  
  
decapitalize('FooBar') # 'fooBar'
decapitalize('FooBar') # 'fooBar'

Длина строки в байтах

А этот метод возвращает длину строки в байтах:

def byte_size(string):
    return(len(string.encode('utf-8')))
    
    
byte_size('😀') # 4
byte_size('Hello World') # 11

Склеивание n строк в одну

С помощью этого фрагмента можно записать строку n раз без использования циклов.

n = 2; 
s ="Programming"; print(s * n); # ProgrammingProgramming

Объединение строк через разделитель

Этот код преобразует список строк в одну строку, вставляя указанный разделитель.

hobbies = ["basketball", "football", "swimming"]print("My hobbies are:") # My hobbies are:
print(", ".join(hobbies)) # basketball, football, swimming

Списки

Наличие дублей

Проверяет, есть ли в списке повторяющиеся значения, пользуясь тем, что set()содержит только уникальные элементы:

def has_duplicates(lst):
    return len(lst) != len(set(lst))
    
    
x = [1,2,3,4,5,5]
y = [1,2,3,4,5]
has_duplicates(x) # True
has_duplicates(y) # False

Очистка списка

Удаляет значения False, None, 0, "" из списка с помощью filter().

def compact(lst):
    return list(filter(bool, lst))
  
  
compact([0, 1, False, 2, '', 3, 'a', 's', 34]) # [ 1, 2, 3, 'a', 's', 34 ]def all_unique(lst):
    return len(lst) == len(set(lst))


x = [1,1,2,2,3,2,3,4,5,6]
y = [1,2,3,4,5]
all_unique(x) # False
all_unique(y) # True

Разделение списка

Делит список на списки заданного размера.

def chunk(list, size):
    return [list[i:i+size] for i in range(0,len(list), size)]

Объединение списка

Объединяет список аналогично [].concat(…arr) в JavaScript:

def spread(arg):
    ret = []
    for i in arg:
        if isinstance(i, list):
            ret.extend(i)
        else:
            ret.append(i)
    return ret
spread([1,2,3,[4,5,6],[7],8,9]) # [1,2,3,4,5,6,7,8,9]

Упрощение списка

Выполняет сведение потенциально глубокого списка к списку проще с помощью рекурсии:

def spread(arg):
    ret = []
    for i in arg:
        if isinstance(i, list):
            ret.extend(i)
        else:
            ret.append(i)
    return ret

def deep_flatten(xs):
    flat_list = []
    [flat_list.extend(deep_flatten(x)) for x in xs] if isinstance(xs, list) else flat_list.append(xs)
    return flat_list


deep_flatten([1, [2], [[3], 4], 5]) # [1,2,3,4,5]

Перемешивание

Располагает элементы списка в произвольном порядке. Обратите внимание: shuffle работает в обычном порядке и возвращает None.

from random import shufflefoo = [1, 2, 3, 4]
shuffle(foo) 
print(foo) # [1, 4, 3, 2] , foo = [1, 2, 3, 4]

Перечисления и списки

В этом фрагменте кода можно использовать перечисление для получения значений и индексов списков.

list = ["a", "b", "c", "d"]
for index, element in enumerate(list): 
    print("Value", element, "Index ", index, )
# ('Value', 'a', 'Index ', 0)
# ('Value', 'b', 'Index ', 1)
#('Value', 'c', 'Index ', 2)
# ('Value', 'd', 'Index ', 3)

Самый повторяющийся элемент

Возвращает наиболее часто встречающийся элемент в списке:

def most_frequent(list):
    return max(set(list), key = list.count)numbers = [1,2,1,2,3,2,1,4,2]
most_frequent(numbers)

Сравнения

Разница между объектами

Находит разницу между двумя итерируемыми объектами, сохраняя значения первого.

def difference(a, b):
    set_a = set(a)
    set_b = set(b)
    comparison = set_a.difference(set_b)
    return list(comparison)


difference([1,2,3], [1,2,4]) # [3]

Разница между списками

Возвращает разницу между двумя списками после применения функции к каждому элементу обоих списков.

def difference_by(a, b, fn):
    b = set(map(fn, b))
    return [item for item in a if fn(item) not in b]


from math import floor
difference_by([2.1, 1.2], [2.3, 3.4],floor) # [1.2]
difference_by([{ 'x': 2 }, { 'x': 1 }], [{ 'x': 1 }], lambda v : v['x']) # [ { x: 2 } ]

Цепочка сравнений

В одной строчке можно производить сравнения со всеми типами операторов:

a = 3
print( 2 < a < 8) # True
print(1 == a < 2) # False

Словари

Объединение словарей

Объединяет два словаря:

def merge_two_dicts(a, b):
    c = a.copy()   
    # make a copy of a 
    c.update(b)    
    # modify keys and values of a with the ones from b
    return c


a = { 'x': 1, 'y': 2}
b = { 'y': 3, 'z': 4}
print(merge_two_dicts(a, b)) # {'y': 3, 'x': 1, 'z': 4}

В Python 3.5 и более поздних версий это выглядит так:

def merge_dictionaries(a, b)
   return {**a, **b}


a = { 'x': 1, 'y': 2}
b = { 'y': 3, 'z': 4}
print(merge_dictionaries(a, b)) # {'y': 3, 'x': 1, 'z': 4}

Преобразование списков в словарь

Преобразует два списка в словарь:

def to_dictionary(keys, values):
    return dict(zip(keys, values))
    

keys = ["a", "b", "c"]    
values = [2, 3, 4]
print(to_dictionary(keys, values)) # {'a': 2, 'c': 4, 'b': 3}

Значения по умолчанию для отсутствующих ключей

Получаем значение по умолчанию, если искомого ключа нет в словаре:

d = {'a': 1, 'b': 2}print(d.get('c', 3)) # 3

Трюки

Расчет времени выполнения

Выводит время выполнения кода:

import time

start_time = time.time()

a = 1
b = 2
c = a + b
print(c) #3

end_time = time.time()
total_time = end_time - start_time
print("Time: ", total_time)

# ('Time: ', 1.1205673217773438e-05)

Использование памяти

Этот фрагмент кода предназначен, чтобы узнать объём памяти, используемый объектом:

import sysvariable = 30 
print(sys.getsizeof(variable)) # 24

Цепочка функций

Предоставляет возможность вызвать несколько функций в одной строке:

def add(a, b):
    return a + bdef subtract(a, b):
    return a - ba, b = 4, 5
print((subtract if a > b else add)(a, b)) # 9

Try else

elseможно использовать как часть блокаtry/except. Ветка else выполнится, если при выполнении никаких исключений не выброшено:

try:
    2*3
except TypeError:
    print("An exception was raised")
else:
    print("Thank God, no exceptions were raised.")

#Thank God, no exceptions were raised.

Калькулятор без if-else

Вот так можно написать простой калькулятор, не прибегая к условиям if-else:

import operator
action = {
    "+": operator.add,
    "-": operator.sub,
    "/": operator.truediv,
    "*": operator.mul,
    "**": pow
}
print(action['-'](50, 25)) # 25

Обмен значений

Действительно быстрый способ обмена двух переменных без третьей:

def swap(a, b):
  return b, a

a, b = -1, 14
swap(a, b) # (14, -1)

Транспонирование массива

Используется для транспонирования (поворота) 2D-массива:

array = [['a', 'b'], ['c', 'd'], ['e', 'f']]
transposed = zip(*array)
print(transposed) # [('a', 'c', 'e'), ('b', 'd', 'f')]

Это был краткий список методов, которые могут пригодиться в повседневной работе. Основой для большинства из них послужил этот GitHub репозиторий, где хранится множество других полезных фрагментов кода как на Python, так и на других языках.

Читайте также:


Перевод статьи Fatos Morina30 Helpful Python Snippets That You Can Learn in 30 Seconds or Less