# *Parameter transfer*

## *Parameter transfer mechanism*

"""

The function parameter passing mechanism is the same as the assignment mechanism. Its essence is to pass the memory address, which is reference passing

When a passes in, it passes in the memory address

If you really don't understand, you can think it's x= a

"""

```def isid(x):

print(id(x))

a = 10

print(id(a)) #140731588047408

#A becomes a parameter and prints the parameter memory address

isid(a) #140731588047408```

## *Default parameters*

#Define a function with default parameters

```def add(x,y=10):

sum01 = x+y

return sum01

"""

"""

"""

Can you pass in a sequence type, such as list, and let it default to []

"""

```def add(list01 = []):

list01.append(1)

return list01

#First call

#Second call

#Third call ## *Indefinite number of parameters*

### *One**

"""

A *: represents a variable parameter (that is, it can be multiple values)

"""

```def add(x,*y):

sum01 = x

for i in y:

sum01 += i

return sum01

### *Two**

"""

**y means that any key value (Dictionary) can be used as a parameter

**y is equivalent to dictionary type

"""

```def func_add(x,**y):

sum01 = x

#Remember that this is the cycle of the dictionary

for k,v in y.items():

print(k,v)

sum01 += v

return sum01```

"""

call

```a=3,b=4,c=5 ----> {"a":3,"b":4,"c":5}

"""

# *name*

## 1. * when executing this file, name==main*

#Print the name attribute

#When this file is executed, it prints main, name == main

print("1,"+name) #1,main

## *2. When import ed into another file, name = = file name*

"""

A file is a module. Importing a module is equivalent to importing a file, which can be written directly

import file name

"""

import this document as bwj

#Run the imported file name in other classes, name = = file name

print(bwj.name) # this document

# *Higher order function*

## *Definition*

A higher-order function is a function that takes a function as an argument or a function as a return value

If a function can be a parameter and a parameter is a variable, can a function be a variable

A parameter is actually a variable. Can a function be a variable

## *Function as variable (supplementary)*

Function is a variable, not a high-order function, just to supplement this knowledge

"""

Function as variable

"""

#Define a function, pass in a parameter, and find the square of the parameter

```def func_pf(x):

return pow(x,2)```

#Dictionary

#Let's know that Li Si's age is the square of 5. Find Li Si's age

```dict01 = {"Zhang San":20,"Li Si":func_pf}

"""

call

1.func_pf = dict01["Li Si"] according to key obtain value,vaule Is a function object

2.age02 = func_pf(5) #Call the function to get the age

"""

#The dictionary is characterized by obtaining value according to key

age01 = dict01["Zhang San"]

print(age01) #20

#As the name suggests, through Li Si, we can get the function func_pf

#What we get is a function object. We can't print it directly

func_pf = dict01["Li Si"]

print(func_pf) #<function func_pf at 0x000001E25A23D048>

age02 = func_pf(5)

print(age02) #25```

## *Function as parameter*

### *Definition*

#Ordinary function

```def func_pf(x):

return x**2```

#Higher order function, with function as parameter

```def func_add(func_pf):

#x**2+10

return func_pf+10

#2**2+10

print(a) #14```

### *Common higher order functions*

These commonly used higher-order functions are higher-order functions with functions as parameters

*m**ap(****)***

*Definition*

"""

map(fun,x) conversion, accept a sequence, convert it into a new sequence according to fun's functional logic, and return a map object

\1. x must be a sequence

\2. Return a map object

"""

*Code*

```def func_add(x):

return x+1```

"""

Put the original data through func_ After the add function, add 1 to each one, and then output a new list

"""

```m = map(func_add,[1,2,3,4,5])

print(m) #<map object at 0x00000248E965C788>

print(list(m)) #[2, 3, 4, 5, 6]```

*filter()*

*Definition*

"""

filter(func,x) filters, accepts a sequence x, and converts it according to the requirements of func function,

The func function returns True or False, and finally puts the element that returns True in the new list.

Return filter object

"""

*Code*

def func_ifScore(x):

#The comparison operator itself returns a Boolean value

#If it is greater than or equal to 60, it is true, otherwise it is False

return x>=60

```f = filter(func_ifScore,[80,98,70,34,60,59,10])

print(f) #<filter object at 0x00000232CC78C808>

print(list(f)) #[80, 98, 70, 60]```

*reduce()*

*Definition

reduce(func,x) calculation accepts a sequence and accumulates or performs other operations on each value in the list according to the function

Returns a calculated value

1. Because it is calculation, our func is two parameters

2. The package must be guided

*Code*

```"""

#Cumulative 1 + 2 + 3 + 4 + 5

return x+y