How to learn Python the fastest, of course, is the actual combat of various small projects, only to think and write, to remember the rules. This article is 30 minimalist tasks, beginners can try to achieve their own; this article is also 30 pieces of code, Python developers can also see if there is unexpected use.

Python is the most widely used programming language in machine learning. Its most important advantage is the ease of use of programming. If the reader already has some knowledge of the basic Python grammar, this article may give you some inspiration. The author gives a brief overview of 30 pieces of code. They are all very practical techniques. It takes us only a few minutes to go through them from beginning to end.

1. Determination of repetitive elements

The following method checks for duplicate elements in a given list, which uses the set() function to remove all duplicate elements.

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. Character Element Composition Decision

Check that the elements of two strings are the same.

from collections import Counter

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


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

3. Memory occupancy

The following code block checks the memory occupied by variable.

import sys 

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

4. Byte occupation

The following code block checks the number of bytes occupied by the string.

def byte_size(string):
    return(len(string.encode('utf-8')))


byte_size('😀') # 4
byte_size('Hello World') # 11   

5. Print N-th string

This block of code can print N strings without looping statements.

n = 2; 
s ="Programming"; 

print(s * n);
# ProgrammingProgramming  

6. Capitalize the first letter

The following code block uses the title() method to begin each word in the uppercase string.

s = "programming is awesome"

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

7. blocks

Given the specific size, define a function to cut the list according to that size.

from math import ceil

def chunk(lst, size):
    return list(
        map(lambda x: lst[x * size:x * size + size],
            list(range(0, ceil(len(lst) / size)))))

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

8. compression

This method can remove Boolean values, such as (False, None, 0, ""), which use the filter() function.

def compact(lst):
    return list(filter(bool, lst))


compact([0, 1, False, 2, '', 3, 'a', 's', 34])
# [ 1, 2, 3, 'a', 's', 34 ]

9. unpack

The following code snippet can decompose packaged paired lists into two different groups of tuples.

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

10. Chain Contrast

We can use different operators to compare multiple different elements in a single line of code.

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

11. Comma Connection

The following code can join lists into a single string, and the separation between each element is set to a comma.

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

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

12. Vowel Statistics

The following method counts the number of vowels in a string ('a','e','i','o','u'), which is done through regular expressions.

import re

def count_vowels(str):
    return len(len(re.findall(r'[aeiou]', str, re.IGNORECASE)))

count_vowels('foobar') # 3
count_vowels('gym') # 0

13. Capital lowercase

The following method unifies the first character of a given string into lowercase.

def decapitalize(string):
    return str[:1].lower() + str[1:]


decapitalize('FooBar') # 'fooBar'
decapitalize('FooBar') # 'fooBar'

14. Expansion list

This method expands the nesting of lists into a single list by recursion.

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

def deep_flatten(lst):
    result = []
    result.extend(
        spread(list(map(lambda x: deep_flatten(x) if type(x) == list else x, lst))))
    return result


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

15. Differences in Lists

This method returns the elements of the first list, which are not in the second list. If you want to feed back the unique elements of the second list at the same time, you need to add a set_b.difference(set_a).

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. Deviation by function

The following method first applies a given function, and then returns the list elements with different results after applying the function.

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. Chain function call

You can call multiple functions in one line of code.

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. Check duplicates

The following code checks whether the two lists have duplicates.

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

19. Merge two dictionaries

The following method will be used to merge the two dictionaries.

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}

In Python 3.5 or later, we can also merge dictionaries in the following ways:

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}

20. Convert two lists into Dictionaries

The following method converts two lists into a single dictionary.

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}

21. Use enumerations

We often use the For loop to traverse a list, and we can also enumerate the index and value of the 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)    

22. Execution time

The following code blocks can be used to calculate the time taken to execute a particular code.

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)  

23.Try else

We can also add an else clause when using try/except statements, which will be run if no error is triggered.

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

#Thank God, no exceptions were raised.

24. Elemental Frequency

The following method picks the most common elements in the list based on their frequency.

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


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

25. Palindrome Sequence

The following method checks whether a given string is a palindrome sequence. It first converts all letters into lowercase and moves them unless they are English alphabetic symbols. Finally, it compares whether a string is equal to a reverse string, and equality is represented as a palindrome sequence.

def palindrome(string):
    from re import sub
    s = sub('[\W_]', '', string.lower())
    return s == s[::-1]


palindrome('taco cat') # True

26. Do not use if-else calculators

This code can add, subtract, multiply, divide and power operation without using conditional statement. It is realized by the data structure of dictionary.

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

27.Shuffle

This algorithm will disrupt the order of the list elements. It will sort the new list mainly through Fisher-Yates algorithm:

from copy import deepcopy
from random import randint

def shuffle(lst):
    temp_lst = deepcopy(lst)
    m = len(temp_lst)
    while (m):
        m -= 1
        i = randint(0, m)
        temp_lst[m], temp_lst[i] = temp_lst[i], temp_lst[m]
    return temp_lst


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

28. Expansion list

All elements in the list, including sublists, are expanded into a list.

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]

29. Exchange Value

The value of two variables can be exchanged without additional operations.

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

a, b = -1, 14
swap(a, b) # (14, -1)
spread([1,2,3,[4,5,6],[7],8,9]) # [1,2,3,4,5,6,7,8,9]

30. Dictionary defaults

By taking the corresponding Value value through Key, the default value can be set in the following way. If the get() method does not set the default value, it returns None if it encounters a key that does not exist.

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

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

Reference link: https://towardsdatascience.com/30-helpful-python-snippets-that-you-can-learn-in-30-seconds-or-less-69bb49204172