Comprehensive summary of functions in Python (with examples)

This article brings you a comprehensive summary of functions in Python (with examples). It has certain reference value. Friends in need can refer to it. I hope it will be helpful to you.

1. Dynamic parameters of formal parameters: Dynamic parameters are used when the parameters are uncertain.
Format:

def fun (*args)
fun(args)

1. Dynamically receive positional parameters: Dynamic parameters must be after the positional parameters.
Example 1. If the parameters are uncertain, as shown below, everyone has different appetites and different types of food. At this time Use dynamic parameter transfer.

def fun(*food):  #*表示的是不定参数,可以传递任意个信息,参数名称还是food,且接收到的信息为元祖()
    print("我要吃",food)
fun("米饭")    #*表示位置参数的动态传参    结果为我要吃 ('米饭',)
fun("一锅米饭","一箱辣条","一桶方便面","可口可乐")#我要吃 ('一锅米饭', '一箱辣条', '一桶方便面', '可口可乐')
fun ("一碗米饭","辣条","雪碧")  #结果为我要吃 ('一碗米饭', '辣条', '雪碧')

Liezi 2.

def fun (*food,a,b):
    print("我要吃",food,a,b)
fun("苹果","梨子","香蕉")  #此时程序会报错,全被food接收了,a和b永远接收不到参数.
def fun (a,b,*food):
    print("我要吃",a,b,food)
fun("苹果","梨子","香蕉","橘子")  #我要吃 苹果 梨子 ('香蕉', '橘子')

2. When there are default value parameters: sequence: positional parameters, dynamic parameters*, default Value parameter

def chi(a, b, *food, c="娃哈哈"):
    print(a, b, food, c)
chi("香蕉", "菠萝") #香蕉 菠萝 () 娃哈哈 默认值生效
chi("香蕉", "菠萝", "葫芦娃") #香蕉 菠萝 ('葫芦娃',) 娃哈哈 默认值生效
chi("香蕉", "菠萝", "葫芦娃", "口罩") # 香蕉 菠萝 ('葫芦娃', '口罩') 娃哈哈 默认值生效
chi("香蕉", "菠萝", "葫芦娃", "口罩",c="苹果")#香蕉 菠萝 ('葫芦娃', '口罩') 苹果

At this time we found that all default values ​​​​are in effect. If you do not give keywords to pass parameters at this time, then your default values ​​​​will always be in effect.
3. Dynamically receive keyword parameters: Final order (*): Positional parameters> *args > Default value parameters> **kwargs
1. Dynamic positional parameters can be used in python , but * in this case can only receive positional parameters, not keyword parameters. Use ** in python to receive dynamic keyword parameters. (Formal parameters only have two types: positional parameters and default value parameters)
*args positional parameters receive the dynamic parameters of the tuple
**kwargs keyword, and receive the dictionary
for example

def func(**kwargs): # key word arguments
    print(kwargs)  #{'a': 10, 'b': 20, 'jay': '周杰伦', 'jj': '林俊杰'}
func(a=10, b=20, jay="周杰伦", jj="林俊杰")

2. Invincible mode, anything can be connected

def fun(*args, **kwargs):
    print(args, kwargs)
fun("3","2",a="hello")  #('3', '2') {'a': 'hello'}

4.* and ** The meaning of usage in actual parameters
1* in the actual parameter position means breaking up, What is broken up are iterable objects such as lists and strings. The formal parameters represent aggregation.
def func(*args): # Here. In fact, it is equivalent to doing the passed parameters once Aggregation, aggregate into a tuple
print(args)
lst = "Wahaha"
func(*lst) # * in the actual parameter position means breaking up, and the breaking up is an iterable object
2. In the actual parameter position**, the dictionary is broken up
def func(**kwargs): # ** Pack (aggregate) the received keyword parameters into a dictionary
print(kwargs) # It must be Dictionary
dic = {"Zhang Wuji": "leader of Mingjiao", "Xie Xun": "golden lion king", "Fan Yao": "right envoy of light"}
func(Zhang Wuji=dic['Zhang Wuji'] , Xie Xun=dic['Xie Xun'], Fan Yao=dic['Fan Yao'])
func(**dic) # The ** here is to break up the dictionary. The key of the dictionary is used as the name of the parameter, dictionary The value is passed to the formal parameter as the value of the parameter. Both results are the same as {'Zhang Wuji': 'The Leader of the Ming Cult', 'Xie Xun': 'The Golden Retriever Lion', 'Fan Yao': 'The Right Envoy of Light'}
2. Namespace:

def fun():
    a=10
fun()
print(a)   #a 此时不存在

We give the space that stores the relationship between names and values ​​a name: namespace. Our variables are stored here when they are stored. In the slice space.
1. Namespace classification:
1. Global namespace --> The variables we declare directly in the py file and outside the function belong to the global namespace
2. Local naming Space --> Variables declared in the function will be placed in the local namespace
3. Built-in namespace --> Stores the names provided by the python interpreter, list, tuple, str, int, these are built-in Namespace
2. Loading order:
1. Built-in namespace 2. Global namespace 3. Local namespace (when the function is executed)
3. Value order:
1. Local Namespace 2. Global namespace 3. Built-in namespace
3. Scope
is the scope, which is divided into global scope and local scope according to the effective scope
Global Scope: includes built-in namespace and global namespace. Can be used anywhere in the entire file (follow line by line execution from top to bottom).
Local scope: Can be used inside a function.
Scope Namespace:
1. Global scope: global namespace built-in namespace
2. Local scope: local namespace
We can view the global scope through the globals() function The content in the scope can also be viewed through locals() to view the variable and function information in the local scope. locals() views the content in the current scope

def fun():
    a=10
    print(locals())   #{'a': 10}
fun()
print(globals())   #显示的没有a的信息
print(locals()) #此时和globals一样,显示的没有a的信息,因为他显示的是当前作用域中的内容.

4. Nesting of functions
Mainly uses two functions, global and nonlocal

global: in Introducing global variables locally
nonlocal: In the local area, the variables of the layer closest to it are introduced. Global variables cannot be introduced in the first layer function.

You can understand the embedding by understanding the following figure. The meaning of set

Related recommendations:

Summary of functions commonly used in python network programming

String Functions in PHP Full Summary

The above is the detailed content of Comprehensive summary of functions in Python (with examples). For more information, please follow other related articles on the PHP Chinese website!