Nasza strona używa cookies. Korzystając ze strony, wyrażasz zgodę na używanie cookies, zgodnie z aktualnymi ustawieniami przeglądarki. Rozumiem

Snippety Pythona, których nauczysz się w mniej niż minutę

Fatos Morina Machine Learning Engineer / Mozaix LLC
Poznaj snippety Pythona, które możesz zrozumieć i przyswoić w mniej niż minutę, a które znacznie ułatwią Ci pracę.
Snippety Pythona, których nauczysz się w mniej niż minutę

Python jest jednym z najpopularniejszych języków wykorzystywanych w data science, uczeniu maszynowym, tworzeniu stron internetowych, różnego rodzaju skryptach, automatyzacji itp. Jednym z powodów jego popularności jest fakt, że Python jest prosty i łatwo się go nauczyć. Jeśli to czytasz, to albo już używasz Pythona, albo chcesz się go nauczyć. W tym artykule pokrótce omówimy 30 krótkich fragmentów kodu, które możesz zrozumieć i przyswoić w mniej niż minutę.


1. Brak duplikatów

Poniższa metoda sprawdza, czy dana lista zawiera zduplikowane elementy. Wykorzystuje ona to, że set(), usuwa zduplikowane elementy z listy.

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


2. Anagramy

Tej metody można użyć do sprawdzenia, czy dwa ciągi znaków są anagramami. Anagram jest słowem lub frazą utworzoną przez zmianę układu liter innego słowa, lub frazy, zwykle używając wszystkich oryginalnych liter dokładnie raz.

from collections import Counter

def anagram(first, second):
    return Counter(first) == Counter(second)


anagram("abcd3", "3acdb") # True


3. Pamięć

Ten snippet można wykorzystać do sprawdzenia zużycia pamięci obiektu.

import sys 

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


4. Rozmiar w bajtach

Metoda ta zwraca długość łańcucha w bajtach.

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


5. Wydrukuj ciąg n razy

Tego fragmentu można użyć do wydrukowania ciągu n razy bez konieczności używania do tego pętli.

n = 2
s ="Programming"

print(s * n) # ProgrammingProgramming


6. Pierwsze litery jako wielkie

Ten snippet używa metody title(), aby pierwsze litery każdego słowa były wielkie.

s = "programming is awesome"

print(s.title()) # Programming Is Awesome


7. Rozdrabnianie listy

Ta metoda dzieli listę na małe części o określonym rozmiarze.

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


8. Compact

Metoda ta usuwa z listy wartości falsy (takie jak, False, None, 0 oraz "") za pomocą filter().

def compact(lst):
    return list(filter(None, lst))
  
  
compact([0, 1, False, 2, '', 3, 'a', 's', 34]) # [ 1, 2, 3, 'a', 's', 34 ]


9. Transpozycja

Tego fragmentu można użyć do transpozycji tablicy 2D.

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


10. Wiele porównań w jednej linijce

Możesz tutaj wykonać wiele porównań ze wszystkimi rodzajami operatorów w jednej linijce kodu.

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


11. Rozdzielanie przecinkiem

Ten snippet można wykorzystać do przekształcenia listy łańcuchów w pojedynczy ciąg znaków, a każdy element z listy oddzielony będzie przecinkami.

hobbies = ["basketball", "football", "swimming"]

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


12. Wyszukiwanie samogłosek

Ta metoda wyszukuje w ciągu znaków samogłoski.

def get_vowels(string):
    return [each for each in string if each in 'aeiou'] 


get_vowels('foobar') # ['o', 'o', 'a']
get_vowels('gym') # []


13. Małe litery

Tej metody można użyć do zamiany pierwszej dużej litery danego ciągu znaków na małą.

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


14. Spłaszczenie listy

Poniższe metody spłaszczają potencjalnie głęboką listę przy użyciu rekurencji.

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]


15. Różnica

Ta metoda znajduje różnicę między dwoma obiektami iterowalnymi, zachowując tylko te różniące się wartości, które są w pierwszym z nich.

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]


16. Zwracanie różnicy

Poniższa metoda zwraca różnicę między dwiema listami po zastosowaniu danej funkcji do każdego elementu obu list.

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 } ]


17. Łańcuchowe wywołanie funkcji

Dzięki tej metodzie możesz wywołać wiele funkcji w obrębie jednej linijki kodu.

def add(a, b):
    return a + b

def subtract(a, b):
    return a - b

a, b = 4, 5
print((subtract if a > b else add)(a, b)) # 9


18. Fuzja dwóch słowników

Poniższej metody można użyć do scalenia dwóch słowników.

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}


W wersji Pythona 3.5 i nowszych możesz to zrobić w następujący sposób:

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}


19. Przekonwertuj dwie listy na słownik

Poniższej metody można użyć do przekonwertowania dwóch list na słownik.

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}


20. Używanie enumerate 

Ten snippet udowadnia, że można użyć enumerate, aby uzyskać zarówno wartości, jak i indeksy różnych list.

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)    


21. Spędzony czas

Ten snippet można wykorzystać do obliczenia czasu potrzebnego do wykonania określonego kodu.

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)


22. Try else

Klauzula else może wystąpić jako część bloku try/except, który jest wykonywany, jeśli nie zostanie zgłoszony żaden wyjątek.

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

#Thank God, no exceptions were raised.


23. Zwracanie najczęstszych elementów

Ta metoda zwraca najczęstszy element, który pojawia się na liście.

def most_frequent(list):
    return max(set(list), key = list.count)
  

numbers = [1,2,1,2,3,2,1,4,2]
most_frequent(numbers)  


24. Palindrom

Metoda ta sprawdza, czy dany ciąg znaków jest palindromem.

def palindrome(a):
    return a == a[::-1]


palindrome('mom') # True


25. Kalkulator bez if-else

Poniższy snippet pokazuje, jak napisać prosty kalkulator bez konieczności używania warunków if-else.

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


26. Wymieszanie elementów

Ten snippet można wykorzystać do losowego uporządkowania elementów na liście. Pamiętaj, że shuffle działa w miejscu i zwraca None.

from random import shuffle

foo = [1, 2, 3, 4]
shuffle(foo) 
print(foo) # [1, 4, 3, 2] , foo = [1, 2, 3, 4]


27. Spread

Metoda ta spłaszcza listę podobnie jak [].concat (… arr) w 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]


28. Zmiana wartości

Naprawdę szybki sposób na zamianę dwóch zmiennych bez konieczności używania dodatkowej.

a, b = -1, 14
a, b = b, a

print(a) # 14
print(b) # -1


29. Otrzymywanie domyślnej wartości dla brakujących kluczy

Ten snippet pokazuje, jak uzyskać wartość domyślną w przypadku, gdy poszukiwany klucz nie znajduje się w słowniku.

d = {'a': 1, 'b': 2}

print(d.get('c', 3)) # 3


Oto lista fragmentów kodu, które mogą się naprawdę przydać w codziennej pracy. Została ona w dużej mierze oparta na tym repozytorium, w którym znajduje się jeszcze wiele przydatnych rzeczy, zarówno w Pythonie, jak i w innych językach.



Oryginał tekstu w języku angielskim przeczytasz tutaj.

Rozpocznij dyskusję

Lubisz dzielić się wiedzą i chcesz zostać autorem?

Podziel się wiedzą z 160 tysiącami naszych czytelników

Dowiedz się więcej