Jun 01, 2021 Article blog
How to learn programming the fastest, of course, is a variety of small projects in action, only their own brain to think, hands-on, impression is the most profound.
This article is 30 minimalist tasks that beginners can try to implement on their own, and it's also 30 pieces of code, and
Python
developers can see if there's an unexpected usage.
Python
is the most widely used programming language for machine learning, and its most important advantage is the ease of use of programming. I
f the reader already has some knowledge of the basic
Python
syntax, this article may give you some inspiration.
The author has a brief overview of 30 pieces of code, all of which are common and practical techniques that we can browse from start to finish in just a few minutes.
The following method checks whether there are duplicate elements in a given list, and it uses
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
Check that the constituent elements of the two strings are not the same.
from collections import Counter
def anagram(first, second):
return Counter(first) == Counter(second)
anagram("abcd3", "3acdb") # True
import sys
variable = 30
print(sys.getsizeof(variable)) # 24
The following block of code checks the number of bytes consumed by strings.
def byte_size(string):
return(len(string.encode('utf-8')))
byte_size('') # 4
byte_size('Hello World') # 11
The block of code does not require a circular statement to print the N-string.
n = 2
s ="Programming"
print(s * n)
# ProgrammingProgramming
The following block of code uses
title()
method to capitalate the first letter of each word in the string.
s = "programming is awesome"
print(s.title())
# Programming Is Awesome
Given the exact size, define a function to cut the list at 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]
This method removes the value of the Boolean type, for example (False, None, 0, ""), which uses
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 ]
The following snippets untangled the packaged pair list into two different tuples.
array = [['a', 'b'], ['c', 'd'], ['e', 'f']]
transposed = zip(*array)
print(transposed)
# [('a', 'c', 'e'), ('b', 'd', 'f')]
We can use different operators in a single line of code to compare multiple different elements.
a = 3
print( 2 < a < 8) # True
print(1 == a < 2) # False (Recommended tutorial: python tutorial)
The following code can connect lists to 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
The following method counts the number of vowels ('a', 'e', 'i', 'o', 'u') in a 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
The following method unites the first character of a given string into lowercase.
def decapitalize(string):
return str[:1].lower() + str[1:]
decapitalize('FooBar') # 'fooBar'
decapitalize('FooBar') # 'fooBar'
The method expands the nesting of the list into a single list by recursively.
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]
The method returns the element of the first list, which is not in the second list.
If you want to feed back elements unique to the second list at the same time, you need to add
set_b.difference(set_a)
def difference(a, b):
setset_a = set(a)
setset_b = set(b)
comparison = set_a.difference(set_b)
return list(comparison)
difference([1,2,3], [1,2,4]) # [3]
The following method first applies a given function, and then returns the list element with different results after the function is applied.
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 } ]
You can call multiple functions within a single 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
The following code checks to see if there are duplicates in both 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
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 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}
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}
We often use
For
loops to traverse a list, and we can also enumerate the indexes and values of a 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)
The following blocks of code can be used to calculate the time it takes 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)
We can also add an
else
clause when we use the
try/except
statement, which will be run if an error is not 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.
The following method takes the most common elements in the list based on the frequency of the elements.
def most_frequent(list):
return max(set(list), key = list.count)
list = [1,2,1,2,3,2,1,4,2]
most_frequent(list)
The following method checks whether a given string is a reply sequence, first converting all letters into lowercases and removing non-English letter symbols. Finally, it compares whether the string is equal to the reverse string, which is represented as a reply sequence.
def palindrome(string):
from re import sub
s = sub('[\W_]', '', string.lower())
return s == s[::-1]
palindrome('taco cat') # True
This piece of code can be implemented without the use of conditional statements, addition, subtraction, power operation, it is implemented through the dictionary as a data structure:
import operator
action = {
"+": operator.add,
"-": operator.sub,
"/": operator.truediv,
"*": operator.mul,
"**": pow
}
print(action['-'](50, 25)) # 25
The algorithm disrupts the order of list elements, and it sorts new lists primarily 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]
Expand all elements within 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]
You do not need additional action to exchange the values of the 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]
By taking the corresponding
Value
value from
Key
you can set the default value in the following ways.
If
get()
method does not set a default value,
None
is returned if a
Key
that does not exist is encountered.
d = {'a': 1, 'b': 2}
print(d.get('c', 3)) # 3 (Recommended micro-course: python3 basic micro-course)
Here's a look at
Python
practical tips and 30
Python
minimalist codes.