# 30 pieces of Python code are extremely simple, allowing you to learn a practical trick in 30 seconds

Posted by Jamez on Fri, 18 Feb 2022 18:19:23 +0100

Life is short, learn Python!

How to learn Python is the fastest. Of course, it is a variety of small projects in actual combat. Only when you think and write, can you remember the rules. Today I share with you 30 minimalist tasks, which beginners can try to achieve by themselves; This article is also 30 pieces of code. Python developers can also see if there are unexpected usages.

Python is the most widely used programming language for machine learning. Its most important advantage is the ease of programming. If the reader already knows something about the basic Python syntax, this article may give you some inspiration. The author gives a brief overview of 30 pieces of code. They are usually very practical skills. We can browse them from beginning to end in a few minutes.

### 1. Determination of repeated elements

The following method can check whether there are duplicate elements in a given list. It will use 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. Determination of character element composition

Check whether the constituent 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 occupation

The following code block can check the memory occupied by the variable variable.

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

### 4. Byte occupation

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

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

### 5. Print the string N times

The code block can print the string N times without circular statements.

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

### 6. First capital letter

The following code block uses the title() method to capitalize the first letter of each word in the string.

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

### 7. Block

Given a specific size, define a function to cut the list according to this 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 the Boolean value, for example (False, None, 0, ""), and it uses 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. Unpacking

The following code snippet can unpack the packed paired list 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 comparison

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

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

### 11. Comma connection

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

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

### 12. Vowel statistics

The following method will count the number of vowels ('a ',' e ',' i ',' o ',' u ') in the string, 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. Initial lowercase

The following method will unify 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. Expand the list

This method will recursively expand the nesting of the list into a single list.

```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. List difference

This method returns the element of the first list, which is 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 sentence 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. Take difference by function

The following method will first apply a given function, and then return 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. Chained 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 for duplicates

The following code will check whether there are duplicates in the two lists.

```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 two dictionaries.

```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 will convert the 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 enumeration

We often use the For loop to traverse a list. Similarly, we can enumerate the indexes and values 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 block can be used to calculate the time spent executing specific 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 the try/except statement. If there is no trigger error, this clause will be run.

```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. Element frequency

The following method will take the most common elements in the list according to the element 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 to lowercase and removes non English alphabetic symbols. Finally, it compares whether the string is equal to the reverse string, which is expressed 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 the calculator of if else

This code can realize the operations of addition, subtraction, multiplication, division and exponentiation without using conditional statements. It is realized through the data structure of Dictionary:

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

### 27.Shuffle

This algorithm will disrupt the order of list elements. It mainly sorts the new list 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. Expand list

Expand all elements in the list, including sub lists, into a list.

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

### 29. Exchange value

The values 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)
```d = {'a': 1, 'b': 2}