Chapter 6 functions and modules

Posted by ashebrian on Mon, 03 Jan 2022 17:30:43 +0100

6.1 functions

When implementing large projects, the code that needs to be reused is often extracted and defined as a function. Thus, the programming workload is simplified and the program structure is simplified

6.1. 1 define function

  • def statements are used to define functions

    def Function name(Parameter table): 
    	Function statement
    	return Return value
    The return value and parameters can be omitted

6.1. 2 call function

  • Basic format of calling function

    Function name(Parameter table)
  • example

    # Define function
    def add(a, b):
        return a + b
    # Call function
    t = add(10, 20)
    print(t)  # The output is 30

6.1. 3 parameters of function

The parameters in the parameter table of the function definition are called formal parameters, which are called formal parameters for short. When calling a function, the parameters provided in the parameter table are called actual parameters, which are referred to as actual parameters for short. Arguments can be constants, expressions, or variables. When the argument is a constant or expression, the calculation result of the constant or expression is directly passed to the formal parameter.

  • Parameter polymorphism: different results can be obtained when the types of arguments passed by the same function are different

    # Define function
    def add(a, b):
        return a + b
    add(1,2) # Perform digital addition
    add('abc','def') # Perform string connection
    add((1,2),(3,4)) # Perform tuple merge
    add([1,2],[3,4]) # Perform list merge
  • Parameter assignment and passing: Python allows you to pass an argument to a specified formal parameter in the way of formal parameter assignment

    def add(a, b):
        return a + b
    add(a='ab',b='cd') # Pass the parameter by assignment, and the result is' abcd '
    add(b='ab',a='cd') # Pass the parameter by assignment and the result is' cdab '
  • Pass reference of variable object: when the argument references a variable object, if the formal parameter is modified in the function, the argument also obtains the modified object

    • In python, strings, tuples, and numbers are immutable objects, while list,dict, and so on are modifiable objects
    def f(a):
        a[0] = 'abc'
    x = [1,2]
    f(x) # Call the function to pass a reference to the list object
    print(x) #The output result is ['abc',2]
  • Indefinite length parameter

    • Add a * in front of the formal parameter, which becomes an indefinite length tuple formal parameter and can receive all position arguments. The type is tuple
    • Add two * * before the formal parameter. The formal parameter becomes an indefinite length dictionary formal parameter, which can receive all keyword real graphs. The type is dictionary

6.1. 4 function nesting definition

  • Python allows you to define functions inside functions, that is, internal functions
  • Internal functions can only be used inside functions

6.1.5 lambda function

  • lambda functions, also known as expression functions, are used to define anonymous functions

  • lambda is just an expression, and the function body is much simpler than def

  • The body of a lambda is an expression, not a code block. Only limited logic can be encapsulated in lambda expressions

  • lambda functions have their own namespace and cannot access parameters outside their own parameter list or in the global namespace

  • Although lambda functions can only write one line, they are not equivalent to C or C + + inline functions. The purpose of the latter is to call small functions without occupying stack memory, so as to increase operation efficiency

  • Basic format

    lambda Parameter table:expression
  • example

    add = lambda a,b:a+b
    add(1,2) # The result is 3

6.1. 6 recursive function

  • Recursive function refers to calling the function itself in the function body

    def fac(n):
        if n==0: #Termination condition of recursive call
            return 1
            return n*fac(n-1) # Call the function itself recursively

6.1. 7 function list

  • Because a function is an object, you can use it as a list element and then call the function through the list index

    d = [lambda a,b:a+b,lambda a,b:a*b]
    d[0](1,3) # Call the first function and the result is 4
    d[1](1,3) # Call the second function and the result is 3

6.2 scope of variable

The scope of a variable is the usable range of the variable, also known as the namespace of the variable. When assigning a value to a variable for the first time, Python creates a variable, and the location of the created variable determines the scope of the variable

  • Scope classification
    • Local scope: when there is no internal function, the function body is used as the local scope. The variables and function parameters created by assignment in the function belong to the local scope
    • Function nested scope: when an internal function is included, the function body is a function nested scope
    • global scope
      • File scope: the internal of program files (also known as module files) is the file scope
      • Built in scope: the environment of Python runtime is built-in scope, which contains various predefined variables and functions of Python

6.3 modules

A module is a program file that contains variables, functions, or classes. Modules can also contain various other Python statements

6.3. 1 import module

  • Import statement: the import statement is used to import the whole module. You can use as to specify a new name for the imported module

    #Method 1 import module name
    #Use: module name Function name
    import my_ module1
    print(my_ module1. num) # Use my_ Variable num in module1
    my_ _module1. func() # Call my_ func function in module1
    dog = my_ _module1.Dog() #Call my__ Create objects from classes in module1
    dpg. show_ _info( )
  • From statement: the from statement is used to import the specified objects in the module. The imported objects can be used directly

    #Method 2: from module name, import function name 1, function name 2,
    #Usage: function name
    #Note: if there is a ten thousand Dharma name with the same name, it will be covered
    ) from my_ _module2 import func´╝î num
    from my_ _module1 import num
    print( num)
    #Method 3 from Module name import * #Import all functions in the module
    #Usage: function name
    from my_ module2 import *
    print( num)
    func( )
    dog = Dog()
    dog. show_ _info()
    #as alias You can alias modules and functions
    #Note: if you use the as alias, you can no longer use the original name
    import my_ module1 as mm1
    from my_ module1 import func as m1_ func
    from my_ _module2 import func as m2_ func
    mm1. func()
    m1_ _func()
    m2_ func()

6.4 package

Modules with similar or similar functions are placed in a directory, and one is defined in the directory__ file, this directory is the package