# [introduction to Python] 30 commonly used Python minimalist codes, ready to use

What is the fastest way to learn Python?

1. Repeated element determination
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. Character element composition determination
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 usage

The following code block checks the number of bytes the string occupies.

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

4. Byte occupancy
The following code block checks the number of bytes the string occupies.

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

5. Print string N times
This code block can print a string N times without a loop statement.

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

6. Capital first 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 blocks
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 Boolean values, 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. Unpack
The following code snippet can unpack the packed paired list into two different sets 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 concatenation
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 a string. It 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 unifies the first character of a given string to lowercase.

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

14. Expand 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, , [, 4], 5]) # [1,2,3,4,5]
```

15. List difference

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 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]) # 
```

16. 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_two_dicts(a, b):
c = a.copy() # make a copy of a
c.update(b) # modify keys and values of a with the once 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 to 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 blocks 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 no error is triggered, 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 will check whether the given string is a palindrome sequence. It will first convert all letters to lowercase and remove 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. The calculator without if else

This code can realize 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 disturb 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)
```

30. Dictionary default

Get the corresponding Value through the Key. You can set the default Value in the following ways. If the get() method does not set a default Value, if a nonexistent Key is encountered, None will be returned.

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

Here we have sorted out Python learning materials for you, including basic installation packages and learning tutorials, as well as some items suitable for beginners to practice. You can scan the code to get them if necessary, which may help you learn Python! Posted by nepton on Wed, 01 Jun 2022 20:01:07 +0530