Analysis of part of the function in python

The content of this article is about the analysis of some functions in python. It has certain reference value. Friends in need can refer to it. I hope it will be helpful to you.

In python, a variable has no type, it is a reference to an object, and the type belongs to the object
A variable is essentially a placeholder! Variables are usually named with lowercase letters.

1: Syntax

def Function name (parameter list):
Function body
(Function names generally use combinations of lowercase letters, single underlines, numbers, etc.)

2: Types of commonly used functions

(1) Functions with parameters: parameters must be passed into the function in the correct order

(2) Default parameter function: If no parameters are passed, it will be used Default parameters, if the default parameters are not at the end, an error will be reported!

(3) Keyword parameters: Function calls use keyword parameters to determine the passed parameter values

(4) Indefinite-length parameters: The function can handle more parameters than when originally declared ,

①All variables in *args will be packed into a tuple to store all unnamed variables
②All variables in **args will be packed into a dictionary

（ 5) When declaring a function, the asterisk * in the parameter can appear alone, and the parameters after * must be passed in with keywords

(6) Anonymous functions, use lambda functions to create anonymous functions

①lambda is just an expression, and the function body is much simpler than def
②The main body of lambda is an expression, not a code block
③The function has its own namespace and cannot access outside its own parameter list Or parameters in the global namespace.

Three: Parameter passing of python function:

Immutable type:

C-like value passing, such as int, string, tuple.
Such as fun(a), only the value of a is passed and does not affect the a object itself.
For example, modifying the value of a inside fun (a) only modifies another copied object and will not affect a itself.

Variable type:

Similar to c reference transfer , such as lists and dictionaries. For example, fun (la), la is actually passed to it. After modification, la outside fun will also be affected. It should be said that passing immutable objects and passing mutable objects

Four: Variable scope

There are generally four types of scopes in python:

L (Local) local scope Domain

E (Enclosing) In the function outside the closure function

G (Global) Global scope
B (Built-in) Built-in scope

The search rule is L-> ;E->G->B

In Python, only modules, classes and functions (def, lambda) will introduce new scopes. Other code blocks (such as if/ elif/else/, try/except, for/while, etc.) will not introduce new scopes, which means that the variables defined in these statements can also be accessed from the outside.

5: Global variables and local variables

Variables defined inside the function have a local scope, and variables defined outside the function have a global scope.

When the inner scope wants to modify the variables of the outer scope, the global and nonlocal keywords are used.

(1) global is used to modify the value of global variables

(2) nonlocal is required to modify variables in the nested scope (enclosing scope, outer non-global scope) The nonlocal keyword is

6: Tips in function calling (important)

Function name.__doc__Get the help document of the function

The function name can be used as the reference of another function Formal parameters

Multiple return values ​​are returned in the form of tuples

Internal functions, global variables can be accessed without modifying them! !

Internal function, if you modify the global variable with the same name, python will think it is a local variable! !

Seven: About naming

(1) File name: all lowercase, you can use underscores

(2) Function name: lowercase, small camel case principle

(3) Variable name: all lowercase, connected by underscores

For detailed naming rules, please refer to PEP8

8: Several special functions

map

reduce
filter

# --------------------------------------------------------------------------#
# 函数的语法及调用
# --------------------------------------------------------------------------#


def func(func_name, number):        # 函数的定义
    """打印输入的任何字符串"""
    print(func_name, number)
    return 'Done'


func('func_1', 'faith')             # 函数的调用

# --------------------------------------------------------------------------#
# 不定长参数函数，封装成元组
# --------------------------------------------------------------------------#


def func_1(func_name, *number):
    """
    打印输入的任何字符串
    """
    print(type(number))
    print(func_name, number)
    return 'Done'


func_1('func_1', 1, 2, 2, 3)


def func_2(func_name, number):   #
    print(type(number))
    print(func_name, number)
    return 'Done'


func_2('func_2', (1, 2, 2, 3))


def func_3(func_name, *number):
    print(func_name)
    print(number[3])            # 根据元组index中一部分变量
    print(number[4])
    return 'Done'


func_3('func_3', 1, 2, 2, 3, 'aaa', 'abc')


# get out question: the number of index isn't known in most case!
# --------------------------------------------------------------------------#
# 不定长参数函数，封装成字典
# --------------------------------------------------------------------------#


def func_4(func_name, **number):  # 可变参数必须在函数参数的最后
    # print(type(number))
    print(func_name, number)
    return 'Done'


func_4('func_4', name='faith')

# --------------------------------------------------------------------------#
# 命名关键字函数
# --------------------------------------------------------------------------#


def func_5(a, x, c, *, china, uk):
    print('func_5:', china, uk)
    print(a, x, c)


func_5(1, 2, 3, china='bJ', uk='rs')    # 调用时必须加上关键字
# func_5(1, 2, 3, 'bJ', 'rs')

# --------------------------------------------------------------------------#
# 函数应用之-递归
# --------------------------------------------------------------------------#


def my_sum(i):
    if i < 0:
        raise ValueError    # 抛出错误
    elif i <= 1:
        return i
    else:
        return i + my_sum(i - 1)


print(my_sum(1.4))

# --------------------------------------------------------------------------#
# 传递不可变对象实例
# --------------------------------------------------------------------------#


def change_int(a):
    a = 10


b = 2
change_int(b)
print(b)         # 结果是2
# --------------------------------------------------------------------------#
# 传递可变对象实例
# --------------------------------------------------------------------------#


def change_me(mylist):
    mylist.append([1, 2, 3, 4])
    print("函数内取值: ", mylist)
    return


myList = [10, 20, 30]
change_me(myList)
print("函数外取值: ", myList)

# --------------------------------------------------------------------------#
# 函数内修改全局变量的值
# --------------------------------------------------------------------------#

money = 200  # 模块里面的全局变量


def add_money():
    global money
    money = money + 1
    return money


print("修改后的值money = ", add_money())


# --------------------------------------------------------------------------#
# 匿名函数
# --------------------------------------------------------------------------#
sum_1 = lambda arg1, arg2: arg1 + arg2

# 调用sum函数
print("相加后的值为 : ", sum_1(10, 20))
print("相加后的值为 : ", sum_1(20, 20))

# 单独编译一个文件时候输出结果
if __name__ == "__main__":
    pass

The above is the detailed content of Analysis of part of the function in python. For more information, please follow other related articles on the PHP Chinese website!