Some common Python methods and tips

Some common Python methods and tips

This article mainly introduces some common Python methods and techniques, this article describes three methods to reverse the string, four methods to traverse the dictionary, three methods to traverse the list, and the method to sort the dictionary. For more information, see

1. Three Methods to reverse a string

1.1. Simulate the method in C ++ and define an empty string for implementation

Set an empty string, traverse the strings in the parameter from the back to the front, and merge them into new strings using the addition of strings.

The Code is as follows:

Def reverse (text ):

Str =''

Index = len (text)-1

While index> = 0:

Str + = text [index]

Index-= 1

Return str

1.2. Use Slicing

This is a feature in Python. The slice can take negative values. This uses the Slice Method and sets the step size to-1, so that reverse sorting is achieved.

The Code is as follows:

Def reverse_1 (text ):

Return text [:-1]

1.3. Usage list

The reverse Method of the List is used. First, the text is converted to the list, and then reversed by the reverse method. Then, the join method is used to join the list as a string.

The Code is as follows:

Def reverse_2 (text ):

Temp = list (text)

Temp. reverse ()

Return ''. join (temp)

2. Use reduce

Use anonymous functions and reduce ()

The Code is as follows:

Def reverse_3 (text ):

Return reduce (lambda x, y: y + x, text)

Print reverse_3 ("Hello ")

3. Four methods to traverse the dictionary

The Code is as follows:

Dict = {"a": "apple", "B": "banana", "o": "orange "}

Print "########## dict ######################"

For I in dict:

Print "dict [% s] =" % I, dict [I]

Print "########### items #####################"

For (k, v) in dict. items ():

Print "dict [% s] =" % k, v

Print "########## iteritems #################"

For k, v in dict. iteritems ():

Print "dict [% s] =" % k, v

Print "########## iterkeys, itervalues #######"

For k, v in zip (dict. iterkeys (), dict. itervalues ()):

Print "dict [% s] =" % k, v

4. Three Methods to traverse the list

The Code is as follows:

For key in lst:

Print key

For I in range (len (lst )):

Print lst [I]

For index, key in enumerate (lst ):

Print key // index is the index of the list

5. dictionary sorting method

The dictionary is sorted in the ascending order of values (from small to small by default ).

The Code is as follows:

Dic = {'A': 31, 'bc': 5, 'C': 3, 'asd ': 4, 'A': 74, 'D': 0}

Dict = sorted (dic. iteritems (), key = lambda d: d [1], reverse = True)

Print dict

// Output result:

[('A', 74), ('A', 31), ('bc', 5), ('asd ', 4), ('C ', 3), ('D', 0)]

Next we will break down the code

Print dic. iteritems () to obtain the [(Key, value)] list.

Then, use the sorted method and the key parameter to specify that the sorting is based on the value, that is, the value of the first element d [1. Reverse = True indicates that the system needs to be flipped. The default value is from small to large. If it is flipped, it is from large to small.

Sort dictionary keys:

The Code is as follows:

Dic = {'A': 31, 'bc': 5, 'C': 3, 'asd ': 4, 'A': 74, 'D': 0}

Dict = sorted (dic. iteritems (), key = lambda d: d [0]) # d [0] indicates the dictionary key

Print dict

# In sorted, the third optional parameter is reverse. True indicates sorting from large to small.

# Default reverse = False

6. subclass and parent class

The subclass constructor calls the initialization constructor of the parent class.

The Code is as follows:

Class A (object ):

Def _ init _ (self ):

Print "testA

Class B ():

Def _ init _ (self ):

A. _ init _ (self)

Subclass calls a function of the same name as the parent class

The Code is as follows:

Super (). fuleifunction ()

7. More flexible parameter transmission methods

The Code is as follows:

Func2 (a = 1, B = 2, c = 3) # default parameter

Func3 (* args) # accepts any number of parameters and transmits them in tuple mode.

Func4 (** kargs) # input the parameter in the form of a key-Value Pair dictionary

The asterisk prefix (*) is added to the variable. The called parameters are stored in a tuple () object and assigned to the parameter. When processing a parameter within a function, you only need to operate the tuple-type parameter (args here. Therefore, a function can handle any number of parameters without specifying the number of parameters.

The Code is as follows:

Def calcSum (* args ):

Sum = 0

For I in args:

Sum + = I

Print sum

# Call:

CalcSum (1, 2, 3)

CalcSum (1, 123,456)

CalcSum ()

# Output:

6

579

0

#################################

Def printAll (** kargs ):

For k in kargs:

Print k, ':', kargs [k]

PrintAll (a = 1, B = 2, c = 3)

PrintAll (x = 4, y = 5)

# Output:

A: 1

C: 3

B: 2

Y: 5

X: 4

Parameters in python can be combined in multiple forms. In mixed use, you must first pay attention to the function writing method, which must comply:

1. The parameter (arg =) with the default value must be after the parameter (arg) without the default value

2. The tuple parameter (* args) must be after the parameter (arg =) with the default value

3. The dictionary parameter (** kargs) must be after the tuples parameter (* args)

When a function is called, the parameter transmission process is as follows:

1. assign values to parameters without specified parameters in sequence

2. Assign the real parameter value of the specified parameter name (arg = v) to the corresponding form parameter.

3. Package redundant real parameters without specified parameters into a tuple and pass it to the tuples parameter (* args)

4. Package the redundant real parameters of the specified parameter name into a dict and pass them to the dictionary parameter (** kargs)

8. lambda expressions

Lambda expressions can be seen as an anonymous function.

Syntax format of lambda expressions:

Lambda parameter list: expression # There are no parentheses around the parameter list, no return keyword before the return value, and no function name

Copy the Code as follows:

Def fn (x ):

Return lambda y: x + y

# Call

A = fn (2)

Print a (3)

# Output

5

Analysis

: Fn (2) after the call, it is equivalent to a = lambda y: 2 + y, and then a (3) is called.

Equivalent to print lambda y: 2 + 3