一、函数的定义、调用、返回值、参数。

一、函数介绍

1.1：函数是什么？

函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段。

函数能提高应用的模块性，和代码的重复利用率。你已经知道Python提供了许多内建函数，比如print()。但你也可以自己创建函数，这被叫做用户自定义函数。

1.2：为什么要使用函数？

　　　1.避免代码重用

　　　2.提高代码的可读性

 

二、函数的定义与调用

2.1：定义规则

你可以定义一个由自己想要功能的函数，以下是简单的规则：

• 函数代码块以 def 关键词开头，后接函数标识符名称和圆括号 ()。
• 函数名是包含字母，数字，下划线的任意组合，但是不能以数字开头。
• 任何传入参数和自变量必须放在圆括号中间，圆括号之间可以用于定义参数。
• 函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
• 函数内容以冒号起始，并且缩进。
• return [表达式] 结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回 None。

2.2：语法

def  函数名（参数1，参数2）:

　　　''' 函数注释'''

　　　print（'函数体'）

　　　return 返回值　

2.3：函数的调用

• 定义一个函数：给了函数一个名称，指定了函数里包含的参数，和代码块结构；
• 这个函数的基本结构完成以后，你可以通过另一个函数调用执行，也可以直接从 Python 命令提示符执行；
• 返回值=函数名（参数1，参数2）#记得函数名后面加括号；

实例1：

1.给定一个字符串，调用函数，当他没有返回值的时候返回Null
def  length():
        s='hello world'
        length=0
        for i in s:
                length+=1
        print(length)
print(length())
#输出结果：
True

2.return 必须放在函数里，当函数有返回值的时候，必须用变量接收才会有效果
def  length():
        s='hello world'
        length=0
        for i in s:
                length+=1
        return  length
print(length())
#输出结果：
True

实例2：

def mylen():   #函数定义
    """计算s1的长度"""
    s1 = "hello world"
    length = 0
    for i in s1:
        length = length+1
    print(length)

mylen()   #函数调用

##定义：

　　  def 关键词开头，空格之后接函数名称和圆括号()，最后还有一个":"。

　　  def 是固定的，不能变，他就是定义函数的关键字。

　　  空格 为了将def关键字和函数名分开，必须空(四声)，当然你可以空2格、3格或者你想空多少都行，但正常人还是空1格。

　  　函数名：函数名只能包含字符串、下划线和数字且不能以数字开头。虽然函数名可以随便起，但我们给函数起名字还是要尽量简短，并能表达函数功能

　  　括号：是必须加的，先别问为啥要有括号，总之加上括号就对了！

##注释：

　  　每一个函数都应该对功能和参数进行相应的说明，应该写在函数下面第一行。以增强代码的可读性。

##调用：

　  　就是 函数名() 要记得加上括号。

实例3：

#!/usr/bin/python3
 
# 定义函数
def printme( str ):
   "打印任何传入的字符串"
   print (str)
   return
 
# 调用函数
printme("我要调用用户自定义函数!")
printme("再次调用同一函数")

#输出结果：
我要调用用户自定义函数!
再次调用同一函数

三、函数的返回值

函数的最后都有一个返回值return，可以用来获取该函数执行结果返回给该函数，让外部调用该函数的根据返回的值不同做不同的事。

返回值可指定，如果不指定默认返回None。

实例1：

#函数定义
def mylen():
    """计算s1的长度"""
    s1 = "hello world"
    length = 0
    for i in s1:
        length = length+1
    return length

#函数调用
str_len = mylen()
print('str_len : %s'%str_len)

return 返回值

实例2：

def test1():
    print('alex')
print(test1())
 
def test2():
    a = 5
    if a < 5:
        return True
    else:
        return False
print(test2())
 
#根据返回的值进行其他判断
if test2():
    print('yes')
else:
    print('no')
　
#输出结果：
alex
None

False
no

3.1：没有返回值

不写return的情况下，会默认返回一个None：

#函数定义
def mylen():
    """计算s1的长度"""
    s1 = "hello world"
    length = 0
    for i in s1:
        length = length+1
    print(length)

#函数调用
str_len = mylen()
#因为没有返回值，此时的str_len为None
print('str_len : %s'%str_len)

没有return

只写return，后面不写其他内容，也会返回None，既然没有要返回的值，为什么还要写个return呢？return的另外一个用法，就是一旦遇到return，结束整个函数：

def ret_demo():
    print(111)
    return
    print(222)

ret = ret_demo()
print(ret)

只写return

3.2：返回一个值

只需在return后面写上要返回的内容即可：

#函数定义
def mylen():
    """计算s1的长度"""
    s1 = "hello world"
    length = 0
    for i in s1:
        length = length+1
    return length

#函数调用
str_len = mylen()
print('str_len : %s'%str_len)

return返回一个值

3.3：返回多个值

可以返回任意多个、任意数据类型的值：

def ret_demo1():
    '''返回多个值''' 
    return 1,2,3,4


def ret_demo2():
    '''返回多个任意类型的值'''
    return 1,['a','b'],3,4

ret1 = ret_demo1()
print(ret1)
ret2 = ret_demo2()
print(ret2)

返回多个值

return返回多个值

返回的多个值会被组织成元组被返回，也可以用多个值来接收：

def ret_demo2():
    return 1,['a','b'],3,4

#返回多个值，用一个变量接收
ret2 = ret_demo2()
print(ret2)

#返回多个值，用多个变量接收
a,b,c,d = ret_demo2()
print(a,b,c,d)

#用多个值接收返回值：返回几个值，就用几个变量接收
a,b,c,d = ret_demo2()
print(a,b,c,d)

多个返回值的接收

四、函数的参数

4.1.参数和传参

我们告诉mylen函数要计算的字符串是谁，这个过程就叫做 传递参数，简称传参，我们调用函数时传递的这个“hello world”和定义函数时的s1就是参数。

实例1：

#函数定义
def mylen(s1):
    """计算s1的长度"""
    length = 0
    for i in s1:
        length = length+1
    return length

#函数调用
str_len = mylen("hello world")
print('str_len : %s'%str_len)

#输出结果：
True

实例2：

def fun(s):#参数接受：形式参数，简称形参。
    '''
        计算字符串长度的函数---------函数的功能
        参数s：接受要计算的字符串--------参数的信息
        return：要计算字符串长度 ---------返回值得信息
    '''
    length=0
    for i in s:
        length+=1
    return length

ret=fun('helloword')#参数传入：实际参数，简称实参
print(ret)

#输出结果：
True

4.2.实参和形参

• 形参：是函数定义时候定义的参数
• 实参：函数调用的时候传进来的参数

def my_len(argv):  # 形式参数 ，形参

    count = 0
    for i in argv:
        count += 1
    return count
s = 'lkfjsjulkjdgjdsf'
l1 = [1, 2, 3, 4, 5]
# my_len(s)  # 实际参数， 实参
print(my_len(l1))

4.3.传递多个参数

可以传递多个参数，多个参数之间用逗号隔开。

def mymax(x,y):
    the_max = x if x > y else y
    return the_max

ma = mymax(10,20)
print(ma)

4.4：实参角度

4.4.1.位置参数（按顺序一一对应）

def mymax(x,y):
    #此时x=10,y=20
    the_max = x if x > y else y
    return the_max

ma = mymax(10,20) #10,20必须和x，y按顺序一一对应
print(ma)

#比较两个数大小
def func1(a,b):
    if a > b:
        return a
    else:
        return b
print(func1(30,20))

#精简版：
def max(a, b): return a if a > b else b
ret = 1 if 2 > 1 else 6
print(ret)
print(max(10, 2))
#或者：
def func1(a,b): retu
print(func1(30,20))

4.4.2.关键字参数（有指向性不在乎顺序，但是也要一一对应）

def mymax(x,y):
    #此时x = 20,y = 10
    print(x,y)
    the_max = x if x > y else y
    return the_max

ma = mymax(y = 10,x = 20)
print(ma)

def func2(a, b):
    print(a, b)
func2(b=2, a=3)

4.4.3.混合参数（关键字参数必须在位置参数的后面）

def mymax(x,y):
    #此时x = 10,y = 20
    print(x,y)
    the_max = x if x > y else y
    return the_max

ma = mymax(10,y = 20)
print(ma) 

def func3(a, b, c, d):
    print(a, b, c, d)
func3(1,2,d=3,c=5)

4.5：形参角度

4.5.1.位置参数（按顺序一一对应）

def func1(a, b, c):
print(a, b, c)
func1(1, 2, 'alex')

4.5.2.默认参数（默认参数在位置参数的后面）

• 用法：将变化比较小的值设置成默认参数（比如一个班的男生多，女生就几个，就可以设置个默认值参数）；
• 定义：默认参数可以不传，不传的时候用的就是默认值，如果传会覆盖默认值。默认的值是在定义函数的时候就已经确定了的；
• 缺陷：默认参数是一个可变数据类型；

def func1():
print(a, b, c)
func1(1, 2, 'alex')
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:  #输入男的时候前面加1
login(name)
else:
sex = input('请输入性别：').strip()
login(name,sex)

def stu_info(name,sex = "male"):
    """打印学生信息函数，由于班中大部分学生都是男生，
        所以设置默认参数sex的默认值为'male'
    """
    print(name,sex)
stu_info('alex')
stu_info('海亮','male')

默认参数

def defult_param(a,l = []):
    l.append(a)
    print(l)

defult_param('alex')
defult_param('egon')

默认参数是个可变类型

4.5.3.动态参数

动态参数，也叫不定长传参，就是你需要传给函数的参数很多，不定个数，那这种情况下，你就用*args（元组形式）和**kwargs（字典形式）接收，接收除去键值对以外的所有参数，kwargs接收的只是键值对的参数，并保存在字典中。

• 所有位置参数，由args统一接收，放在一个元组；
  
• 所有关键字参数，由kwargs接收，放在一个字典中；
  
• *在函数定义的时候代表聚合；
• *在函数执行的时候代表打散；

 *args的应用

def fun(a,b,*args):
    sum=a+b
    for i in args:
           sum+=i
    return sum
print(fun(1,5,6,4))  #输出1+5+6+4的和

>>> def fun1(*args):
...     for item in args:
...             print item
... 
>>> fun1(1, 'hello', True)
1
hello
True

>>> def fun1_1(arg1, arg2, arg3):
...     print arg1
...     print arg2
...     print arg3
... 
>>> args = ['hello', 3]
>>> 
>>> fun1_1('test', *args)
test
hello
3

 

*kwargs的应用

def fun(a,b,**kwargs):
    print(a,b,kwargs)

# 按照关键字传参数
fun(a = 10,b = 20,cccc= 30,dddd = 50)#输出10 20 {'cccc': 30, 'dddd': 50}



def f(a,b,*args,defult=6,**kwargs):
    #位置参数，*args, 默认参数，**kwargs
    # print(a,b,args,defult,kwargs)
    return a,b,args,defult,kwargs

#传参数的时候：必须先按照位置传参数，再按照关键字传参数
print(f(1,2,7,8,ccc=10,der=5))

>>> def fun2(**kwargs):
...     for k in kwargs:
...             print "%s:%s" % (k, kwargs[k])
... 
>>> fun2(hello=1, world=2, welcome=3)
world:2
welcome:3
hello:1

>>> def fun2_2(arg1, hello, world):
...     print 'arg1:', arg1
...     print 'arg2:', hello
...     print 'arg3:', world
... 
>>> kwargs = {'hello':3, 'world':2}
>>> fun2_2(1, **kwargs)
arg1: 1
arg2: 3
arg3: 2

 **kwargs 打包关键字参数成dict给函数体调用

注意：参数arg、*args、**kwargs三个参数的位置必须是(arg,*args,**kwargs)这个顺序，否则程序会报错。

 

 

4.5.4.形参的顺序

位置参数 ---》*args ---》默认参数 ---》**kwargs

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

4.6：内置函数

Python3.6内置参数详解：https://docs.python.org/3/library/functions.html#next

转载于:https://www.cnblogs.com/bingo1024/articles/9067777.html