Preface
The text and pictures in this article are from the Internet and are for learning and communication purposes only. They do not have any commercial use. If you have any questions, please contact us for processing.
PS: If you need Python learning materials, you can click on the link below to get it yourself
Python free learning materials and group communication answers Click to join
How to learn Python is the fastest, of course, is to fight various small projects. Only when you think and write yourself can you remember the rules. This article is 30 minimal tasks, beginners can try to achieve it by themselves; this article is also 30 pieces of code, Python developers can also see if there are unexpected usages.
1. Duplicate element determination
- The following method can check if 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 composition of character elements
- Check if the elements of the 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
import sys
variable = 30
print(sys.getsizeof(variable)) # 24
4. Bytes occupied
- The following code block can check the number of bytes occupied by a string.
def byte_size(string):
return(len(string.encode('utf-8')))
byte_size('') # 4
byte_size('Hello World') # 11
5. Print the string N times
- This code block can print the string N times without loop statements.
n = 2
s ="Programming"
print(s * n)
# ProgrammingProgramming
6.Capitalize the 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. Blocking
- 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, such as (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 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 a line of code.
a = 3
print( 2 < a < 8) # True
print(1 == a < 2) # False
11.Comma connection
- The following code can concatenate the list into a single string, and set the separation between each element 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 will count the number of vowels ('a','e','i','o','u') in a string, and 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. Lower case initials
- The following method will unify 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 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. The difference of the list
- This method will return 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. Take difference 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. 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 if 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 higher, 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 will convert 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 enum
- We often use 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 block can be used to calculate the time it takes to execute a 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 executed.
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 based on 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 letter symbols. Finally, it compares whether the string is equal to the reversed string, which 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. Calculator without if-else
- This piece of code can implement addition, subtraction, multiplication, division, and exponentiation operations without using conditional statements. It is implemented through the dictionary data structure:
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 mainly sort the new list through the 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 the 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
spread([1,2,3,[4,5,6],[7],8,9]) # [1,2,3,4,5,6,7,8,9]
29. Exchange value
- No additional operations are required to exchange the values of two variables.
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 default values
- Take the corresponding Value value through Key, and set the default value in the following ways. If the get() method does not set a default value, it will return None if it encounters a non-existent Key.
d = {'a': 1, 'b': 2}
print(d.get('c', 3)) # 3