Shulou(Shulou.com)06/02 Report--

This article introduces the relevant knowledge of "how to use Python functions and modules". In the operation of actual cases, many people will encounter such a dilemma, so let the editor lead you to learn how to deal with these situations. I hope you can read it carefully and be able to achieve something!

Before we explain the content of this chapter, let's study a math problem. Please tell us how many positive integer solutions there are in the following equation.

As you may have thought, this question is actually equivalent to dividing eight apples into four groups and how many solutions are there for at least one apple in each group. So the question can be further equivalent to inserting three partitions between the seven gaps separating eight apples to divide the apples into four groups, that is, selecting the combination of three gaps from the seven gaps to put into the partition, so the answer is

The formula for calculating the number of combinations is as follows:

According to what we have learned before, we can calculate the factorial by doing cyclic multiplication, so we can calculate the number of combinations through the following Python code

The code is as follows

"

Enter M and N to calculate C (Mpene N)

Version: 0.1

Author: Luo Hao

"

M = int (input ('m ='))

N = int (input ('n ='))

# calculate the factorial of m

Fm = 1

For num in range (1, m + 1):

Fm * = num

# calculate the factorial of n

Fn = 1

For num in range (1, n + 1):

Fn * = num

# calculate the factorial of mmurn

Fm_n = 1

For num in range (1, m-n + 1):

Fm_n * = num

# calculate the value of C (MPern)

The function of print (fm / / fn / / fm_n) function

I wonder if you have noticed that we have done three factorials in the above code. Although the values of m, n and m-n are different, there is no substantial difference between the three pieces of code, which belongs to repetitive code. Mr. Martin Fowler, a world-class programmer, once said: "there are many bad smells of code, and repetition is the worst one!" . The first thing to solve in order to write high-quality code is the problem of repetitive code. For the above code, we can encapsulate the function of calculating factorial into a code block called "function". Where we need to calculate factorial, we just need to "call function".

Define function

In Python, you can use the def keyword to define functions, and like variables, each function should have a beautiful name, and the naming rules are consistent with the naming rules of variables. The parameters passed to the function can be placed in parentheses after the function name, which is the independent variable of the function we just mentioned, and after the function is executed, we will return the execution result of the function through the return keyword, which is the dependent variable of the function we just mentioned. The block of code to be executed by a function (what is to be done) is also represented by indentation, the same as the block of code in the previous branch and loop structure. Let's not forget that there is a colon at the end of the def line: as I warned you before, it is a colon entered in the English input method.

We can ReFactor the above code through the function. The so-called refactoring is to adjust the structure of the code without affecting the execution result of the code. The code after refactoring is as follows.

"

Enter M and N to calculate C (Mpene N)

Version: 0.1

Author: Luo Hao

"" # define the function: def is the keyword that defines the function, fac is the function name, and num is the parameter (independent variable)

Def fac (num):

"factorial"

Result = 1

For n in range (1, num + 1):

Result * = n

# returns the factorial of num (dependent variable)

Return resultm = int (input ('m ='))

N = int (input ('n ='))

# when you need to calculate the factorial, you don't have to write repeated code, but call the function fac directly.

# the syntax for calling a function is to follow the function name with parentheses and pass in parameters

Default values for parameter parameters of the print (fac (m) / / fac (n) / / fac (m-n)) function

If there is no return statement in the function, the function returns a None representing a null value by default. In addition, when defining a function, the function can also have no arguments, but the parentheses after the function name must be present. Python also allows the parameters of the function to have default values, and we can encapsulate the function of shaking the sieve to get points in the previous lesson of "CRAPSdubo Game" into a function, as shown below.

"

Default value of parameter 1

Version: 0.1

Author: Luo Hao

"

From random import randint# defines the function of shaking sieves. N represents the number of sieves. The default value is 2.

Def roll_dice (nasty 2):

"" Shake the sieve to return the total number of points ""

Total = 0

For _ in range (n):

Total + = randint (1,6)

If return total# does not specify a parameter, then n uses the default value of 2, which means shake two sieves

Print (roll_dice ())

# pass in parameter 3, and the variable n is assigned to 3, which means shaking three sieves to get points

Print (roll_dice (3))

Let's look at a simpler example.

"

Default value of parameter 2

Version: 0.1

Author: Luo Hao

"" def add (axi0, boun0, cym0):

"" the sum of three numbers ""

Return a + b + c # calls the add function with no arguments, then a, b, and c all use the default value of 0

Print (add ()) # 0

# call the add function and pass in a parameter, then the parameter is assigned to the variable a, and the variables b and c use the default value of 0

Print (add (1)) # 1

# call the add function, passing in two parameters, 1 and 2 are assigned to variables an and b, respectively, and variable c uses the default value of 0

Print (add (1,2)) # 3

# call the add function, pass in three parameters, and assign values to variables a, b and c, respectively

Print (add (1,2,3)) # 6

# parameters can be passed out of the set order, but in the form of "parameter name = parameter value"

Print (add (50, 100, 200)) # 350

Note: parameters with default values must be placed after parameters without default values, otherwise an SyntaxError error will be generated. The error message is: non-default argument follows default argument, which means "parameters without default values are placed after parameters with default values".

Variable parameter

Next, we can also implement an add function that sums any number of numbers, because functions in the Python language can support variable parameters through asterisk expression syntax. The so-called variable parameter means that 0 or any number of parameters can be passed to the function when the function is called. In the future, when we develop commercial projects as a team, we are likely to design a function for others to use, but sometimes we don't know how many parameters the caller of the function will pass to the function. at this time, variable parameters can come in handy. The following code demonstrates an add function that uses variable arguments to sum any number of numbers.

"

Variable parameter

Version: 0.1

Author: Luo Hao

"" # uses an asterisk expression to indicate that args can receive 0 or any number of parameters

Def add (* args):

Total = 0

# variable parameters can be placed in the for loop to fetch the value of each parameter

For val in args:

Total + = val

Return total# can pass in 0 or any number of parameters when calling the add function

Print (add ())

Print (add (1))

Print (add (1,2))

Print (add (1,2,3))

Print (add (1,3,5,7,9)) uses module management functions

No matter what programming language you use to write code, naming variables and functions is a headache, because we will encounter the awkward situation of naming conflicts. The simplest scenario is to define two functions with the same name in the same .py file, as shown below.

Def foo ():

Print ('hello, worldview') def foo ():

Print ('goodbye, worldview') foo () # guess what will be output if you call the foo function

Of course, we can easily avoid the above situation, but if the project is developed by multiple people in a team, there may be multiple programmers on the team who define a function called foo. How to resolve naming conflicts in this case? The answer is actually very simple, each file in Python represents a module (module), we can have a function with the same name in different modules, when using the function, we import the specified module through the import keyword and then use the fully qualified name call method to distinguish which module is to use the foo function, the code is shown below.

Module1.py

Def foo ():

Print ('hello, Worldwide')

Module2.py

Def foo ():

Print ('goodbye, Worldwide')

Test.py

Import module1

Import module2

# call the function by means of "module name. Function name" (fully qualified name)

Module1.foo () # hello, world!

Module2.foo () # goodbye, world!

When you import a module, you can also alias the module using the as keyword so that we can use a shorter, fully qualified name.

Test.py

Import module1 as m1

Import module2 as m2

M1.foo () # hello, world!

M2.foo () # goodbye, world!

In the above code, we import the module that defines the function, or we can use from...import... The syntax imports the functions you need to use directly from the module, as shown below.

Test.py

From module1 import foo

Foo () # hello, world!

From module2 import foo

Foo () # goodbye, world!

However, if we import a function with the same name from two different modules, the later imported function will overwrite the previous import, as in the following code, calling foo will output hello, Worldwide, because we first imported module2's foo, and then imported module1's foo. If two from...import... Writing it the other way around is a different story.

Test.py

From module2 import foo

From module1 import foo

Foo () # hello, world!

If you want to use the foo function from both modules in the above code, you may have guessed that you should alias the imported function with the as keyword, as shown below.

Test.py

From module1 import foo as f1

From module2 import foo as f2

F1 () # hello, world!

F2 () # goodbye, world! Modules and functions in the standard library

The Python standard library provides a large number of modules and functions to simplify our development work. The random module we have used before provides us with functions for generating random numbers and random sampling, while the time module provides functions related to time operations. The above factorial function already exists in the math module of the Python standard library, and we do not need to write it ourselves in the actual development, and the math module also includes a series of mathematical functions such as calculating sine, cosine, index, logarithm and so on. As we learn more about Python programming, we will use more modules and functions.

There is also a class of functions in the Python standard library that can be used directly without import. We call them built-in functions. These built-in functions are very useful and most commonly used. The following table lists some of the built-in functions.

This is the end of "how to use Python functions and modules". Thank you for reading. If you want to know more about the industry, you can follow the website, the editor will output more high-quality practical articles for you!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.