python函数基本介绍

函数

1.函数结构
　　　def 是函数的定义关键字，my_len是函数名。（）传参用，冒号下面都是函数体。
　　　执行函数方法：函数名加括号来执行函数。My_len（）

　　　　举例：
　　　　# s = 'lkfjsjulkjdgjdsf'
　　　　# def my_len():
　　　　# count = 0
　　　　# for i in s:
　　　　# count += 1
　　　　#
　　　　# print(my_len())

2.函数的封装
　　

　　一个函数就是为了实现一个功能

3.Return 在函数中的作用，是给函数的执行者返回值

　　return作用：

　　　　1.终止函数
　　　　2.给函数的执行者返回值

　　retun后接值说明：

　　　　Return后面不加任何东西，反悔结果是none
　　　　Return，对于单个值来说，后面加什么反回的就是什么，是字符串就反回字符串，是数字就反回数字。
　　　　Return 对于多个反回值时，会将多个值放到一个元组中，反回给函数的执行者。

　　　　　　举例：
　　　　　　　　#def func1():
　　　　　　　　# print(111)
　　　　　　　　# print(222)
　　　　　　　　# return
　　　　　　　　# print(333)
　　　　　　　　# print(func1()) ###终止函数反回默认值none
　　　　　　结果：
　　　　　　　　111
　　　　　　　　222
　　　　　　　　None

　　　　　　举例：
　　　　　　　　#def func1():
　　　　　　　　# print(111)
　　　　　　　　# print(222)
　　　　　　　　# return 666 ####反回666
　　　　　　　　# return 'alex' ####反回'alex'
　　　　　　　　# return 'alex', 666, [1, 2, 3] ###反回一个元组（'alex', 666, [1, 2, 3]）



4.函数的传参
　　函数传参分为两个方向：
　　　　1. 实参角度
　　　　　　——实参就是在执行函数过程中向函数内传入的参数。（函数执行里面放的参数）
　　　　2. 行参角度
　　　　　　——行参就是准备被赋值的名字，即在运行函数时准备接收行参的字符。（在函数定义的时里面放的参数）

　　注意：行参是不可以被改变得，而实参是可以改变的。

　　　　举例：
　　　　　　# def my_len(argv): # argv是形式参数 ，形参
　　　　　　#
　　　　　　# count = 0
　　　　　　# for i in argv:
　　　　　　# count += 1
　　　　　　# return count
　　　　　　# s = 'lkfjsjulkjdgjdsf'
　　　　　　# l1 = [1, 2, 3, 4, 5]
　　　　　　# print(my_len(l1)) #l1是实际参数， 实参
　　　　结果：
　　　　　　5

　　实参的类型：
　　　　1.位置参数
　　　　2.关键字参数
　　　　3.混合参数

　　　　（1）位置参数
　　　　　　　　行参的参数要与实参位置按顺序一一对应，也就是说在改行参传参数的值，要与预先定义的行参位置一一对应，行参会第一个字符会对应接收实参的第一个字符，                              依次类推。

　　　　（2）关键词参数
　　　　　　　　关键字参数不关心传入参数放的顺序位置，传入参数要与行参关键字一致即可。

　　　　（3）混合参数
　　　　　　　　位置参数和关键字参数同时存在
　　　　　　　　注：关键字参数，必须要在位置参数的后面

　　　　　　　　　　举例：
　　　　　　　　　　　　# 位置参数 按照顺序一一对应
　　　　　　　　　　　　# def func1(a, b, c):
　　　　　　　　　　　　# print(a, b, c)
　　　　　　　　　　　　# func1(1, 2, 'alex') ###1,2，'alex'分别对应a，b，c

　　　　　　　　　　　　# def max(a, b): return a if a > b else b
　　　　　　　　　　　　# ret = 1 if 2 > 1 else 6
　　　　　　　　　　　　# print(ret)
　　　　　　　　　　　　# print(max(10, 2)) ###10,2，分别对应a，b

　　　　　　　　　　　　# 关键字传参 一一对应。
　　　　　　　　　　　　# def func2(a, b):
　　　　　　　　　　　　# print(a, b)
　　　　　　　　　　　　# func2(b=2, a=3) ###关键字a=3 对应行参里面的a，b=2对应行参里面的b

　　　　　　　　　　　　混合参数。（位置参数，关键字参数） 关键字参数必须在位置参数后面。
　　　　　　　　　　　　# def func3(a, b, c, d):
　　　　　　　　　　　　# print(a, b, c, d)
　　　　　　　　　　　　# func3(1,2,d=3,c=5) ###关键字必须在位置参数后
　　　　行参的类型：
　　　　　　1.位置参数
　　　　　　2.默认参数
　　　　　　3.动态参数 （*args 、 **kwargs ）

　　　　　　（1）位置参数
　　　　　　　　　　位置参数就是保证要与实参的位置参数保持一致

　　　　　　（2）默认参数
　　　　　　　　　　默认参数用的比较多，默认就是在不传入参数的时候使用的参数即为默认参数，即在实参不输入参数时，程序运行会使用预先定义好的默认参数，但手动输入                                      后悔替换默认参数输入。
　　　　　　　　　　注意，默认参数要在位置参数的后面添加

　　　　　　（3）动态参数（万能参数）
　　　　　　　　　　对参数的个数不固定的时候使用动态参数（万能参数），即在执行函数时，实参传入多少参数接收多少参数。

　　　　　　　　　　（*args 、 **kwargs ）动态参数有两种：
　　　　　　　　　　动态参数分为两种（万能参数）
　　　　　　　　　　　　*args 接收所有的位置参数，所有的位置参数都放在一个元祖中。
　　　　　　　　　　　　**kwargs 接收所有关键字参数，所有接收到的关键字都放在一个字典中。

　　　　　　　　　　　　　　举例：

　　　　　　　　　　　　　　　　#默认参数：
　　　　　　　　　　　　　　　　# def login(name,sex='男'): ###默认参数要在位置参数后面
　　　　　　　　　　　　　　　　# # with open('register', encoding='utf-8', mode='a') as f1:
　　　　　　　　　　　　　　　　# # f1.write('{},{}\n'.format(name,sex))
　　　　　　　　　　　　　　　　# #
　　　　　　　　　　　　　　　　# #
　　　　　　　　　　　　　　　　# # while True:
　　　　　　　　　　　　　　　　# # name = input('请输入姓名：').strip()
　　　　　　　　　　　　　　　　# # if '1' in name:
　　　　　　　　　　　　　　　　# # login(name)
　　　　　　　　　　　　　　　　# # else:
　　　　　　　　　　　　　　　　# # sex = input('请输入性别：').strip()
　　　　　　　　　　　　　　　　# # login(name,sex)

　　　　　　　　　　　　　　　　#万能参数：
　　　　　　　　　　　　　　　　# def func3(*args, **kwargs): #函数的定义的时候 * 代表聚合。
　　　　　　　　　　　　　　　　# print(args)
　　　　　　　　　　　　　　　　# print(kwargs)
　　　　　　　　　　　　　　　　# # func3(1, 2, 3, 'alex', c=6, name='wusir', age='21') ###结果：(1, 2, 3, 'alex') {'c': 6, 'name': 'wusir', 'age': '21'}

　　　　形参的排列顺序：
　　　　　　位置参数--> *args-->默认参数-->**kwargs

　　　　　　　　举例：
　　　　　　　　　　# def func5(a,b,*args,sex='男',**kwargs):
　　　　　　　　　　# print(a,b,)
　　　　　　　　　　# print(args)
　　　　　　　　　　# print(sex)
　　　　　　　　　　# print(kwargs)

5.函数中星号的定义：
　　（1）在函数定义的时候，*代表聚合
　　（2）函数的执行时候，*代表打散 注意：字典打散时用**两个星号

　　　　举例：
　　　　　　# def func3(*args, **kwargs): #函数的定义的时候 * 代表聚合。
　　　　　　# print(args)
　　　　　　# print(kwargs)
　　　　　　# func3(*[1, 2, 3],*(22, 33)) #函数的执行的时候 * 代表打散。 ###结果：(1, 2, 3, 22, 33) {}
　　　　　　# func3(**{'name':"alex"},**{'age':23}) #函数的执行的时候 * 代表打散。 ###结果：() {'name': 'alex', 'age': 23}
　　　　　　# func3(1, 2, 3, 22, 33) #函数的执行的时候 * 代表打散。 ###结果：(1, 2, 3, 22, 33) {}

 

6.函数的嵌套：（记住两个关键点）
　　代码顺序执行，当见到函数名加括号，就是执行函数。
　　函数在没有执行完是不会执行下面的内容的。

　　注：
　　执行一个函数就会开辟一个临时空间进行存储，即每个函数都会单独开辟一个临时空间使用存放函数体内容。

 

　　　　举例：
　　　　　　# def func1():
　　　　　　# print(666)
　　　　　　#
　　　　　　# def func2():
　　　　　　# func1()
　　　　　　# print(333)
　　　　　　#
　　　　　　# def func3():
　　　　　　# func2()
　　　　　　# print(222)
　　　　　　# print(111)
　　　　　　# func3()
　　　　　　# print(555)

 

　　　　　　# def func1():
　　　　　　# name = 'susi'
　　　　　　# print(name)
　　　　　　# def func2():
　　　　　　# name1 = 'git'
　　　　　　# print(333)
　　　　　　# print(444)
　　　　　　# func2()
　　　　　　# func1()

 

转载于:https://www.cnblogs.com/liujiyu/p/9098197.html