Python basics 3: functions, ternary functions, lambda functions, pythonlambda

Python basics 3: functions, ternary functions, lambda functions, pythonlambda

Functions: include user-defined functions and built-in functions

1) custom function structure:There are five parts:

• Def Keyword:Identification used to create functions

• Function Name:For example, f1

• ():() Contains parameters.

• Function body:Specific functions to be implemented by this function

• Return:Return value. If none exists, none is returned.

As follows:

2) function call:Use the function name + ()

Format: function name (parameter 1, parameter 2), such as f1 (5, 8)

3) execution sequence of functions:From top to bottom.

The function body is executed only when it is called.

If you want to obtain the return value of the function, you need to assign a value.

The return Statement in the function body is no longer executed.

Execution result:

Case 1: do not execute a UDF because the UDF is not called.

def f1():
print('123')
return "111"

Case 2: Call a function and execute the function body. Once return is executed in the function body, it is terminated immediately, so the subsequent print (456) will never be executed.

def f1():
print('123')
return "111"
   print(456)

f1()

Case result: 123

Case 3: The result is 123 and 111, because a return value is given to r, print (r) and print 111.

Def f1 ():
Print ('20140901 ')
# In case of return, the function body is terminated immediately,
Return "111" # assign 111 to r
R = f1 ()
Print (r)

Case results: 123 and 111

Case 4: When the function does not return, the automatic default return value is None; the return result is 123 and None. Because no return is returned, the value accepted by r is None.

def f1():
print('123')
r=f1()
print(r)

Case execution result: 123, none

Case 5: python transmits a reference instead of a copy. The following li has been referenced after being executed by the function body.

Def f1 (a1 ):
A1.append (999)
Li = [11,22, 33,44]
Print (li)
F1 (li)
Print (li) # Because li has been executed, li is a new value. The parameter is passed as a reference, not a copy.

Execution result:

[11, 22, 33, 44]

[11, 22, 33, 44,999]

4) function parameters:

For example, f (x1, x2, x3 = 1), x1, x2, and x3 are parameters.

The parameter types include:

Common parameters: formal parameters and actual parameters

Default parameter: advance value, for example, x3

Specify parameters: You can change the order when calling the actual parameters.

Dynamic parameters:

* Args

** Kargs

Universal parameter * args, ** kagrs

Case 1: differentiated form parameters and actual parameters:

In this case, xxx is a formal parameter, and the actual parameter is passed when the function is called.

# Xxx here is a form parameter
Def f1 (xxx ):
Print ('20140901 ')
Return xxx + 'wee'

# Ggg here is the actual Parameter
R = f1 ("ggg ")
Print (r)

Case 2: Understanding the call of parameters

Common parameters, x1 and x2, are passed in sequence in f1

Def f1 (x1, x2 ):
Return x1 + x2
R = f1 ("ggg", "ccc") # Corresponds to x1 and x2 respectively in order

The default parameter. If this parameter is set, it must be placed after it, for example, x3.

Def f1 (x1, x2, x3 = "acb "):
Return x1 + x2 + x3
R = f1 ("ggg", "ccc") # x3 is not required here

Specify parameters. You can specify parameters in different order.

def f1(x1,x2,x3="acb"):
return x1+x2+x3
f1(x2="ggg",x1="ccc")
print(r)

Case 3: Dynamic Function (add * or ** before the function name): a formal parameter that can accept multiple actual parameters.

When the formal parameters include *, the passed parameters are placed in the group by default.

• When the actual parameter is passed as a common parameter, even if the list is passed as an element

• When the actual parameter * exists, all the elements in the list will act as each element of the ancestor.

def f1(*x):
print(x,type(x))
f1("55",66,"ll")
li=[11,22,33,"hhhh"]
f1(li)
f1(*li)

Execution result:

('55', 66,'ll ') <class 'tuple'>

([11, 22, 33, 'hhhh'],) <class 'tuple'>

(11, 22, 33, 'hhhh') <class 'tuple'>

If it is **, the default parameter is placed in the dictionary. The actual parameter must be a specified parameter or dictionary.

Case 4: If the form parameter is ** and the actual parameter is also passed **, the entire dictionary will be passed in.

def f1(**x):
print(x,type(x))
f1(n1="hh",n2="kk")
dic={'k1':'n1','k2':'n2'}
f1(**dic)

Execution result:

{'N1 ': 'hh', 'n2 ': 'kk'} <class 'dict '>

{'K1 ': 'n1', 'k2': 'n2 '} <class 'dict'>

Case 5: omnipotent parameter: f1 (* args, ** args), must be * Before, ** after

def f1(*a,**x):
print(a,type(a))
print(x,type(x))
f1(11,22,33,**{'k1':'n1','k2':'n2'})

Execution result

(11, 22, 33) <class 'tuple'>

{'K1 ': 'n1', 'k2': 'n2 '} <class 'dict'>

The application of universal parameters is str. format.

Case 6: Use placeholders to pass. This is an application of * arg.

#0 and 1 are placeholders, and the actual parameters are passed in order.
S1 = "I am {0}, age {1}". format ("hh", "2 ")
S2 = "I am {0}, age {1}". format (* ["hh", "2"])
Print (s1)
Print (s2)

Execution result:

I am hh, age2

I am hh, age2

Case 7: when the formal parameter is a character variable, the parameter must be specified later, which is an application of ** arg

s1="i am {name},age{age}".format(name="hh",age="2")
dic={'name':'nn','age':'4'}
s2="i am {name},age{age}".format(**dic)
print(s1)
print(s2)

Execution result:

I am hh, age2

I am nn, age4

5) global variables:Global, in uppercase. If you want to modify and apply the modification to the global, you need to add global

Case 1: global variables: the scope is global and in uppercase.

NAME = "hh"
Def f1 ():
Age = 18
Print (age, NAME)
Def f2 ():
Age = 19
Print (age, NAME)
F1 ()
F2 ()
Execution result:

Case 2: modify global variables: If you want to modify and use global variables, you can use global

NAME="hh"
def f1():
    age=18
   global NAME
    NAME = "hh3"
    print(age,NAME)
def f2():
    age = 19
   print(age, NAME)
f1()
f2()

Execution result:

Case 3: Modify the global variable: if the global variable is not added, it only takes effect within the function.

NAME="hh"
def f1():
    age=18
   NAME = "hh3"
   print(age,NAME)
def f2():
    age = 19
   print(age, NAME)
f1()
f2()

Execution result:

6) three-element \ three-object operation:That is, the abbreviation of if... else.

Format: "result of true if condition else is false ",

"Condition? True_part: false_part"

Case 1: If the 1 = 1 condition is true, it is equal to the previous value. Otherwise, it is the subsequent value hhh.

If 1 = 1:
Name = "alex"
Else:
Name = "hhh"
# Abbreviation:
Name2 = "alex" if 1 = 1 else "hhh"

6) lambda functions: the purpose is to simplify the process of user-defined functions.

Case 1: lambda function, short function, a parameter

def f1(a1):
return a1+100
ret=f1(10)
print (ret)

# Use Cases can be abbreviated

f2=lambda a1:a1+100
r1=f2(19)
print(r1)

Case 2: lambda function, short for two parameters

F2 = lambda a1, a2: a1 * a2 + 100 # can also be the default value
R1 = f2 (19,10)
Print (r1)
Result: 290

Case 3: Apply lambda Functions

Words = [1, 2, 3, 4, 5, 6]
Key = lambda w: words [w]
R = key (2)
Print (r)
Execution result: 3

Case 4: cyclic usage case

word='the'
n=3
alphabet='uxyz'
s3=[word[0:i]+c+word[i+1:] for i in range(3) for c in alphabet]
print(s3)

The execution result is:

7) python has many built-in functions that can be directly used.

See: http://www.cnblogs.com/vamei/archive/2012/11/09/2762224.html

Case Link: Https://pan.baidu.com/s/1nvgivdn password: mvfc

Copyright Disclaimer: This article is an original article by the blogger and cannot be reproduced without the permission of the blogger.