函数相关

Python中的函数

在Python中，函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段。函数能提高应用的模块性，和代码的重复利用率。

函数的定义和调用

Python中的函数使用def关键字定义，后面跟一个函数的标识符名称和圆括号()。任何传入参数和自变量必须放在圆括号中间，圆括号之间可以用于定义参数。

函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。

函数内容以冒号起始，并且缩进。

函数最后返回值用return来返回，如果没有return语句，函数返回的是None。

def func():
    print("我是一个函数 ... ")

func()

函数的命名

函数的命名应该遵循标识符的命名规则：

• 字母数字下划线,首字符不能为数字
• 严格区分大小写,且不能使用关键字
• 函数命名有意义,且不能使用中文

函数命名方法：

• 驼峰命名法：每个单词首字母大写，如 MyFunction
• 小驼峰命名法：第一个单词小写，其他单词首字母大写，如 myFunction
• 下划线命名法：单词间用下划线连接，如 my_function

def cfb_99():
    for i in range(1,10):
        for j in range(1,i+1):
            print("{:d}*{:d}={:2d} ".format(i,j,i*j) ,end="")
        print()

cfb_99()

函数的参数

函数可以接受参数，参数是通过在函数名后面的圆括号内定义的。参数通过逗号进行分隔。

函数参数可以有默认值，即在定义函数的时候为参数赋值，如果在调用函数时没有重新赋值，那么该参数使用默认值。

def small_star(hang=10,lie=10):
    i = 0
    while i < hang:
        j = 0
        while j < lie:
            print("*",end="")
            j +=1
        print()
        i += 1

small_star(4,8)
small_star(8)
small_star()

形参的种类

普通形参(位置形参)

# 1.普通形参(位置形参)
# 定义函数
"""hang,lie普通形参,在函数定义处"""
def small_star(hang,lie):
	i = 0
	while i < hang:
		j = 0
		while j < lie:
			print("*",end="")
			j +=1
		print()
		i += 1
# 调用函数
"""10,10普通实参,在函数的调用处"""
small_star(10,10)
small_star(2,3)

默认形参

# 2.默认形参 
"""hang,lie默认形参,在函数定义处"""
"""
如果给予实参,那么使用实参
如果没有给予实参,那么使用参数身上的默认值
"""
def small_star(hang=10,lie=10):
	i = 0
	while i < hang:
		j = 0
		while j < lie:
			print("*",end="")
			j +=1
		print()
		i += 1

small_star(4,8)
small_star(8)
small_star()

# 3.普通形参 + 默认形参
"""普通形参必须写在默认形参的前面不能调换位置"""
def small_star(hang,lie=10):
	i = 0
	while i < hang:
		j = 0
		while j < lie:
			print("*",end="")
			j +=1
		print()
		i += 1
small_star(5,7)
# small_star(5)
# small_star() error

普通收集形参

(1) 普通收集形参: 专门用来收集那些多余的没人要的普通实参
				   收集之后,会把多余实参打包成一个元组
				   参数头上1个星星
	def func(*args):
		pass
	args => arguments
"""
def func(a,b,c,*args):
	print(a,b,c) # 1 2 3
	print(args)  # (4,5,6)

func(1,2,3,4,5,6)


# 任意个数值得累加和
def mysum(*args):
	total = 0
	for i in args:
		total += i
	print(total)
mysum(1,2,3,4,4,45,10,100)

命名关键字形参

​

(1) def func(a,b,*,c,d) 跟在*号后面的c和d是命名关键字参数
(2) def func(*args,e,**kwargs) 加在*args和**kwargs之间的参数都是命名关键字参数

命名关键字参数 : 在调用函数时,必须使用关键字实参的形式来进行调用;
"""
# 定义方法一
def func(a,b,*,c,d):
	print(a,b)
	print(c,d)
	
# 必须指定关键字实参,才能对命名关键字形参进行赋值
func(1,2,c=3,d=4)

# 定义方法二
def func(*args,e,**kwargs):
	print(args)   # (1, 2, 3, 4)
	print(e)      # 3
	print(kwargs) # {'a': 1, 'b': 2}
func(1,2,3,4,a=1,b=2,e=3)

关键字收集形参

关键字收集形参:专门用来收集那些多余的没人要的关键字实参
				    收集之后,会把多余关键字实参打包成一个字典
					参数头上有2个星星
	def func(**kwargs):
		pass
	kwargs => keyword arguments
"""

def func(a,b,c,**kwargs):
	print(a,b,c)
	print(kwargs) # {'f': 100, 'e': 200, 'z': 12}
func(c=1,a=3,b=10,f=100,e=200,z=12)

实参的种类

​ 1.普通实参 2.关键字实参

参数顺序

当所有的形参都放在一起的时候，顺序原则是：

• 普通形参
• 默认形参
• 普通收集形参
• 命名关键字形参
• 关键字收集形参

def f1(a, b, c=0, *args, **kw):
    print('a =', a, 'b =', b, 'c =', c, 'args =', args, 'kw =', kw)

def f2(a, b, c=0, *, d, **kw):
    print('a =', a, 'b =', b, 'c =', c, 'd =', d, 'kw =', kw)
    
# 以上两个函数 打印结果
#(一)
f1(1, 2) # a =1 b=2 c=0 args=() kw={}
f1(1, 2, c=3) # a=1,b=2,c=3,args=() kw={}
f1(1, 2, 3, 'a', 'b') #a=1 b=2 c=3 args=(a,b) kw={}
f1(1, 2, 3, 'a', 'b', x=99) # a=1 b=2 c=3 args=(a,b) kw={x:99}
f2(1, 2, d=99, ext=None)#a=1 b=2 c=0 d=99 kw={ext:None}

#(二)
args = (1, 2, 3, 4)
kw = {'d': 99, 'x': '#'}
# f1(1,2,3,4,d=99,x=#)
f1(*args, **kw) # a=1 b=2 c=3 args=(4,) kw={d:99,x:#}


#(三)
myargs = (1, 2, 3)
mykw = {'d': 88, 'x': '#'}
# f2(1,2,3,d=88,x=#)
f2(*myargs, **mykw) # a=1,b=2,c=3 d=88 kw={x:#}

#(四)
def f1(a, b, c=0, *args,d,**kw):
    print('a =', a, 'b =', b, 'c =', c, 'args =', args, 'kw =', kw)
    print(d)

f1(1,2,3, 'a', 'b',d=67, x=99,y=77) # a=1 b=2 c=3 args=(a,b)  kw={x:99,y:77}
									# d=67

函数的返回值

函数可以有返回值，也可以没有。有返回值的函数可以直接用于表达式。

"""
概念:return 把函数内部的数据返回到函数的外面,返回到函数的调用处
1.return + 六大标准数据类型 , 除此之外还可以返回函数 或者 是类对象
2.return 在执行时,意味着终止函数,后面的代码不执行.
3.如果不定义return返回值,默认返回None
"""
def add(a, b):
    return a+b

result = add(3, 4)
print(result)


def func():
	# return 111
	# return 6.89
	# return "你好帅啊,我爱死你乐"
	# return [1,2,3]
	# return {"a":1,"b":2}
	return 1,2,3 # 返回元组
res = func()
print(res)

函数的嵌套

Python中，函数可以嵌套，即在一个函数内部定义另一个函数。

def outer():
    print('outer is running')

    def inner():
        print('inner is running')

    inner()

outer()

全局变量和局部变量

概念

• 局部变量：在函数内部定义的变量就是局部变量
• 全局变量：在函数外部定义的变量或者在函数内部使用global关键字声明的全局变量

作用域

• 局部变量的作用范围仅仅在函数的内部
• 全局变量的作用范围横跨整个文件

生命周期

该变量的作用时长：内置命名空间 -> 全局命名空间 -> 局部命名空间 (开辟空间顺序)。内置属性 > 全局属性 > 局部属性 (作用时长:长->短)

局部变量

def func():
    # 定义一个局部变量
    a = 1
    # 获取当前的局部变量
    print(a)
    # 修改一个局部变量
    a = 2
    print(a)

func()
# print(a) error

全局变量

# 定义一个全局变量
b = 10
# 获取当前的全局变量
print(b)
# 修改一个全局变量
b = 20
print(b)

def func():
    print(b)

func()

函数内部定义全局变量

def func():
    global c
    c =30

func()
print(c)

函数内部修改全局变量

d = 50
def func():
    global d
    d = 51

func()
print(d)

总结：global的使用
如果当前不存在全局变量,可以在函数内部通过global关键字来定义全局变量
如果当前存在全局变量,可以在函数内部通过global关键字来修改全局变量

函数名的使用

在Python中，函数可以像变量一样动态创建、销毁，可以作为参数传递，也可以作为返回值，这种特性使得Python的函数被称为第一类对象。这是Python相对于其他语言具有的一项强大的功能。

def func():
    print("我是func函数")

动态创建

a = 1
print(a)
a = func
a()

动态销毁

del a
# a()
# func()

当参数传递

def func2():
    return "我是func2函数"

def func1(f):
    return f() # "我是func2函数"

res = func1(func2)
print(res)

作为值返回

def func3():
    print("我是func3函数")

def func4(f):
    return f

res = func4(func3)
print(res)
res()

函数名可以作为容器类型数据的元素

lst = [func,func3]
for i in lst:
    i()

使用__doc__ 或者help查看文档

def big_chang_cishen(something):
    """
    功能: 教你怎么吃大肠
    参数: 吃的内容
    返回值: 是否满意
    """
    print("把{}洗一洗".format(something))
    print("直接找肠子头,放嘴里,吸一下")
    print("擦擦嘴,满意的放下肠子头")
    return "吃完了,真好吃~"

big_chang_cishen("生肠子")
# 方法一
res = big_chang_cishen.__doc__
print(res)
# 方法二
help(big_chang_cishen)

---