Teach: Learn a Python trick every 30 seconds

Many friends who study Python video tutorial will encounter many problems in function implementation during the actual project. Some problems are not difficult, or they already exist. Great way to solve it. Of course, what makes perfect is that when we become proficient in coding, we will naturally be able to summarize some useful techniques, but it may not be so easy for those students who are just getting familiar with Python.

Recommendation (free): Python video tutorial

This time I recommend one for everyone to learn these skills A very good resource"30-seconds-of-python", all skills and methods can be obtained in just 30 seconds, and you can use your business time to accumulate them. Take a quick look below.

https://github.com/30-seconds...

Content directory

The following is the entire directory of learning Python in 30 seconds, divided into several major sections: List, Math, Object, String, Utility, the following is the organized thinking map.

I have selected 10 practical and interesting methods to share with you. The rest can be learned by yourself if you are interested.

1. List: all_equal
Function implementation: Check whether all elements in a list are the same.
Interpretation: Use [1:] and [:-1] to compare all elements of the given list.

def all_equal(lst):
return lst[1:] == lst[:-1]

Example:

all_equal([1, 2, 3, 4, 5, 6]) # False
all_equal([1, 1, 1, 1]) # True

2. List: all_unique
Function implementation: If all values ​​in the list are unique, return True, otherwise False
Interpretation: Use set set() to remove duplicates on the given list and compare its length with the original list.

def all_unique(lst):
return len(lst) == len(set(lst))

Example:

x = [1,2,3,4,5,6]
y = [1,2,2,3,4,5]
all_unique(x) # True
all_unique(y) # False

3. List: bifurcate
Function implementation: Group list values. If the element in filter is True, then the corresponding element belongs to the first group; otherwise, it belongs to the second group.
Interpretation: Use list comprehension and enumerate() to each group based on filter elements.

def bifurcate(lst, filter):
    return [
    [x for i,x in enumerate(lst) if filter[i] == True],
    [x for i,x in enumerate(lst) if filter[i] == False]
  ]

Example:

bifurcate(['beep', 'boop', 'foo', 'bar'], [True, True, False, True])

# [ ['beep', 'boop', 'bar'], ['foo'] ]

4. List: difference
Function implementation: Return the difference between two iterables.
Interpretation: Create a set of b, and use the list comprehension of a to retain elements that are not in _b.

def difference(a, b):
  _b = set(b)
return [item for item in a if item not in _b]

Example:

difference([1, 2, 3], [1, 2, 4]) # [3]

5. List: flatten
Function implementation: one-time integrated list.
Interpretation: Use nested lists to extract each value of the sublist.

def flatten(lst):
return [x for y in lst for x in y]

Example:

flatten([[1,2,3,4],[5,6,7,8]]) # [1, 2, 3, 4, 5, 6, 7, 8]

6. Math: digitize
Function implementation: Decompose a number and convert it into single digits.
Interpretation: After characterizing n, use the map() function combined with int to complete the conversion

def digitize(n):
return list(map(int, str(n)))

Example:

digitize(123) # [1, 2, 3]

7. List: shuffle
Function implementation: Randomly shuffle the order of list elements.
Interpretation: Use the Fisher-Yates algorithm to reorder the list elements.

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

Example:

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

8. Math: clamp_number
Function implementation: Clamp the number num at the boundary value of a and b within the specified range.
Interpretation: If num falls within the range, return num; otherwise, return the closest number within the range.

def clamp_number(num,a,b):
return max(min(num, max(a,b)),min(a,b))

Example:

clamp_number(2, 3, 5) # 3
clamp_number(1, -1, -5) # -1

9. String: byte_size
Function implementation: Return the number of bytes in the string.
Interpretation: Use string.encode('utf-8')Decode the given string and return the length.

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

Example:

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

10. Math: gcd
Function implementation: Calculate the greatest common factor of several numbers.
Interpretation: Use reduce() and math.gcd to implement on the given list.

from functools import reduce
import math

def gcd(numbers):
    return reduce(math.gcd, numbers)

Example:

gcd([8,36,28]) # 4

The above are various tips for learning python in 30 seconds. How about it? Have you gained some new inspiration for some common operations? In addition, there are many other techniques that you can slowly learn. I hope it will be helpful to all readers.

The above is the detailed content of Teach: Learn a Python trick every 30 seconds. For more information, please follow other related articles on the PHP Chinese website!