函数

def 函数 function

函数是可以重复执行的语句块，可以重复调用

  作用:

    1. 用于封装语句块，提高代码的重用性

    2. 定义用户级别的函数

3.函数外部不可以访问函数内部的变量空间，在函数内可以访问函数外的变量，但不能修改此变量，

　　出了函数，变量的值又变会全局变量的值。

4.如果函数内部没有return返回值，那么函数调用完毕后默认返回None

5. 如果函数想要返回其他对象需要返回return语句

6、以后不要用sum list...做变量名，因为你用完后，sum 函数将不能求和，list函数将不能格式化列表

　　x = int(input("请输入数字："))  当需要返回值是数字时，需要把input的返回值整型格式化

      print()函数输出的时候如果遇到数字，需要将数字str()字符串格式化

函数没有返回值时：返回None

函数return返回一个值时：返回object

函数return返回多个值时：返回tuple

传参

位置传参

　　实参和形参的位置必须一一对应

序列传参

　　用*，序列拆解的位置与形参一一对应

def myfun1(a,b,c):
    print('a的值是：', a)
    print('b的值是：', b)
    print('c的值是：',c)

s1 = [11,22,33]
myfun1(*s1)    #相当于myfun1(11,22,33)    myfun1(s1[0],s1[1],s1[2])

t1 = (44, 55, 66)
myfun1(*t1)

myfun1(*"ABC")

序列传参

关键字传参

　　按形参的名子给形参赋值，实参名必须与形参名进行匹配（形参与实参个数必须一一对应，不能不相等）

字典关键字传参

　　指定实参为字典，将字典用’**’，拆解后在进行关键字传参的传参方式

 1 def myfun1(a, b, c):
 2     # 这是一个函数的传参示例，此函数以后不会改变代码
 3     print('a 的值是:', a)
 4     print('b 的值是:', b)
 5     print('c 的值是:', c)
 6 
 7 
 8 d = {'a': 100, 'b': 200, 'c': 300}
 9 myfun1(**d)  # 等同于 myfun1(a=100,b=200,c=300)
10 
11 # 下是错误做法
12 # d2 = {'a': 100, 'b': 200, 'c': 300, 'd': 400}
13 # myfun1(**d2)

字典关键字传参

说明：位置传参要在关键字传参（字典关键字传参）的左边

　　def myfun1(a,b,c):

    　　  pass

　　#调用时

　　Myfun(100,*[200,300])

　　Myfun(*(100,200),300)

　　Myfun(*[100],200,*[300])

　　Myfun(100,c=300,100)    #错误

　　Myfun(100,**{‘c’:300,’b’:200})

形参

　　函数的缺省参数：

　　def 函数名(形参名=默认实参1，形参2=默认实参2，…)

说明：缺省参数必须自左向右依次存在，如果第一个参数有缺省参数，那么其右侧的所有参数必须都为缺省参数

位置形参

　　语法：

      def 函数名(形参名1，形参名2，…)

           语句块

星号元组形参

  语法：

       def 函数名(*元组形参名)

　　　　　　　　语句块

作用：收集多余的位置传参，如果传入的是关键字，是接收不了的（空元组）

1 def func (*args):
2     print(“参数个数是：”,len(args))
3     print(“args:”,args)
4 fun()
5 fun(1,2,3,4)
6 fun(*”ABC”,1,2,3,None,False)

星号元组形参

命名关键字形参

语法：

　　def 函数名(*,命名关键字形参)　　

　　　　语句块

　　或

　　def 函数名(*args,命名关键字形参)

　　　　语句块

作用：强制索引的参数都必须用关键字传参或字典关键字传参

 1 def fa(*, a, b):
 2     print('a=', a)
 3     print('b=', b)
 4 def fb(*args, a, b):
 5     print("args=", args)
 6     print('a=', a)
 7     print('b=', b)
 8 
 9 # fa(b=1, a=2)
10 fa(**{'b': 200, 'a': 100})
11 #fb(1, 2, 3, 4, b=200, a=100)

命名关键字形参

双星号字典形参

   语法：

        def 函数名(**字典形参名)

             语句块

   作用：收集多余的关键字传参

   说明：字典的形参名通常命名为”kwargs”

1 def fa(**kwargs):
2     print("关键字传参的个数是:", len(kwargs))
3     print('kwargs=', kwargs)
4 
5 
6 fa(name='tarena', age=15)
7 fa(a=1, b='BBB', c=[2,3,4], d=True)    #传入的是字典

双星号字典形参

 

函数的参数说明：

　　位置形参，缺省参数，星号元组形参，双星号字典形参可以混合使用

　　def name(位置形参,星号元组形参,命名元组形参,双星号字典形参):

实例：

       def fx(a,b,*args,c,**kwargs):

              pass

       fx(100,200,300,400,c=”c”,d=”D”,e=”E”)

 

函数的不定长参数：

　　星号元组形参，双星号字典形参

说明：

　　可以接受任意的位置传参和关键字传参

　　def fn(*aegs,**kwargs):

　　　　pass

局部变量：local variable

　　1、局部变量在函数调用时才能够被创建，在函数调用之后会自动销毁

全局变量：global variable

　　2、全局变量所有函数都可以访问（但函数内不能直接赋值）

args    作为函数的参数

locals()  返回局部变量的字典

globals()      返回全局变量的字典

作用：可以使用字典键索引来返回全局变量或者局部变量的值

函数变量

　　函数名是一个变量，它在def语句创建函数时绑定一个函数

　　函数可以用变量来绑定

def fa():
    print('你好')
def fb():
    print("好")
f1 = fa  # 这里没有括号f1绑定的是函数
f2 = fb
f1()  # 调用f1绑定的函数
f2()  # 调用f2绑定的函数
def f1():
    print('你')
def f2():
    print('好')
f1, f2 = f2, f1
f1()  # 调用的是f2函数

函数变量

　　把函数当做一个变量来玩

　　一个函数，可以作为另一个函数的实参传递

1 def f1():
2     print("f1被调用：")
3 def f2():
4     print("f2被调用")
5 def fx(fn):
6     print(fn)
7     fn()
8 fx(f1)  # 这里调用的是fx
9 fx(f2)

函数传递

1 def myinput(fn):
2     L = [5,6,7,9,2]
3     return fn(L)
4 print(myinput(sum))#29
5 print(myinput(max))#9
6 print(myinput(min))#2
7 print(myinput(len))#5

传递函数

　　函数可作为另一个函数的返回值

 1 def get_op():
 2     s = input("请输入你要操作的数：")
 3     if s=="求最大：":
 4         return max
 5     elif s=='求最小':
 6         return min
 7     elif s == '求和':
 8         return sum
 9 L= [2,3,5,7,4]
10 f = get_op()
11 print(f(L))

View Code　　

　　函数的嵌套：

    函数的嵌套定义是指一个函数里用def语句来创建其他的函数的情况

1 def fn_outter():
2     print("fn_outter函数被调用")
3     def fn_inner():
4         print("fn_inner被调用")
5     fn_inner()
6     fn_inner()
7     print("fn_outter调用结束")
8 fn_outter()

View Code

 

global 语句

　　作用：

　　1、告诉解释执行器global语句声明的一个或多个变量，这些变量的作用域为模块级的作用域，也称作全局变量

　　2、全局变量（global）：

　　将赋值语句操作的变量映射到模块文件内部的作用域

　　语法：

　　　　global 变量1，变量2，…..

　　说明：

　　1、全局变量如果要在函数内部被赋值，则必须经过全局变量声明（否则会被认识是创建局部变量）

      2、全局变量在函数内部不经过声明就可以直接访问（）

      3、不能先声明局部变量，再声明为全局变量

      4、global变量列表里的变量名不能出现在此作用域的形参列表

nonlocal语句

      作用：告诉解释执行器，nonlocal语句声明的不是局部变量，也不是全局变量，他是外部嵌套函数内的变量

      语法：nonlocal 变量名1,变量名2,….

      说明：

　　1、nonlocal只能被函数嵌套时使用

　　2、访问nonlocal变量将对外部嵌套函数作用域内的变量进行操作

　　3、访问nonlocal变量只对最近一层变量进行操作

　　4、nonlocal语句的变量列表里的变量名，不能出现在此函数的参数列表里

 

lambda 表达式（又称匿名函数）

作用：创建一个匿名函数对象，但不提供函数名

格式：lambda[参数1，参数2，…..]：表达式

　　　myadd = lambda x,y:x+y

说明：

　　1、lambda表达式创建的函数只能包含一条表达式

　　2、lambda用来创建一个函数对象

 

eval()/exec()函数

　　eval(srouce,globals=None,local=None)

      　　把字符串  srouce当成一个表达式来执行，返回表达式执行的结果

 1 x = 100
 2 y =200
 3 s = 'x+y'
 4 a = eval(s)
 5 b = eval("x+y",{'x':1,'y':2})
 6 c = eval("x+y",{'x':1,'y':2},{'x':34,'y':1})
 7 d = eval("x+y",{'x':1,'y':2},{'y':1})
 8 print(a)#300
 9 print(b)#3
10 print(c)#35
11 print(d)#2

View Code

　　exec(srouce,globals=None,local=None)

      　　把一个字符串srouce当成程序来执行，返回表达式执行的结果

1 s = """print("hello world")
2 x =100
3 x += 200
4 print("x=",x)
5 """
6 exec(s)#hello world   x= 300

View Code

 

函数的文档字符串（就是在开始写函数时，先用字符串说明该函数是用来做什么的）

　　函数内第一次未被赋值给任何变量得字符串是此函数的文档字符串

语法：

　　def 函数名（参数列表）：

　　　　'函数文档字符串'

　　　　函数语句块

示例：

　　def myfun(name,x):

　　　　'''这是函数的文档字符串

　　　　name  表示人名

　　　　x  表示钱数

　　　　'''

　　　　pass

>>>help(myfun)

说明：

　　1、文档字符串通常用来说明本函数的功能和使用方法

　　2、在交互模式下输入：help(函数名) 可以查看函数的'文档字符串'

　　3、函数的文档字符串绑定在函数的__doc__属性上

def fun():
    "这是一段文档字符串"
    pass
    
print(fun.__doc__)  # 这是一段文档字符串

print(help(fun))

# Help on function fun in module __main__:

# fun()
#     这是一段文档字符串

# None

fun.__doc__

函数定义语句(def 语句) 的完整语法:
　　[@装饰器1]
　　[@装饰器2]
　　[...]
　　def 函数名([位置形参], [*元组形参], [命名关键字形参], [**字典形参]):
　　'''文档字符串'''
　　语句块

　注: [] 代表其内部可以省略

复习：

　　使用函数时，尽量少用全局变量，用函数传参来传递全局变量，这样可以避免，多个模块的文件，跨包（跨包取值）

 

转载于:https://www.cnblogs.com/LXP-Never/p/9302597.html