python初始函数__009

1、定义一个函数：简单规则

（1）函数代码块以def关键词开头，后接函数标识符名称和圆括号()；

（2）任何传入参数和自变量必须放在圆括号中间，圆括号之间可以定义参数；

（3）函数的第一行语句可选择性地使用文档字符串-用于存放函数说明；

（4）函数内容以冒号起始，并且缩进；

（5）return表达式结束函数，选择性地返回一个值给调用方，不带表达式的return返回None

2、函数能提高应用的模块性，和代码重复利用率。

3、python提供了很多内建函数，但你自己创建的函数，叫用户自定义函数。

4、格式：

def  函数名(参数列表)：

        函数体

5、返回值：返回值有3种情况

（1）没有返回值：返回None

                      # 不写return

                      #只写return：结束一个函数的继续，不执行break下的代码（注：break是结束for循环，函数内：循环之外的仍继续执行）

                      # return None 不常用

（2）返回一个值

                     #可以返回任何一个数据类型

                     #只要返回就可以接收到

                     # 如果在一个函数中有多个return，只执行第一个

（3）返回多个值

                     # 用多个变量接收：有多少个返回值就用多少个变量接收

def func():
    a = 1
    b = 3
    c = 4
    return a,b,c
k1,k2,k3 = func()
print(k1,k2,k3)

                    # 用一个变量接收：得到一个元组

def func():
    a = 1
    b = 3
    c = 4
    return a,b,c
k1 = func()
print(k1)  # (1, 3, 4)

6、参数：形参和实参

def my_len(s):  # 接收参数，是形式参数简称形参
    i = 0
    for k in s:
        i += 1
    return i
ret = my_len('jianghe')     # 传递参数：传参，实际参数：实参
print(ret)

7、函数的参数：

（1）没有参数：定义函数和调用函数时括号中不写内容

（2）有一个参数

（3）多个参数：位置参数

例子：

def my_sum(a,b):
    print(a,b)
    res = a+b
    return res
ret = my_sum(2,3)
print(ret)

8、站在形参的角度上：

#位置参数：必须传，且有几个参数就传几个值

# 默认参数：可以不传，如果不传就用默认参数，如果用了就用传入的参数

9、站在实参的角度上：

# 按照位置传参

# 按照关键字传参

# 混着可以用：但是，必须先按照位置传参，再按照关键字传参（不能给同一个变量传多个值）

例子：

def func(name,sex='男'):
    return '%s:%s'%(name,sex)
f = func('江河','男')
print(f)

10、只有调用函数的时候：

#按照位置传参：直接写参数的值

# 按照关键字：关键字=值

11、定义函数的时候：

# 位置参数：直接定义参数

#默认参数：关键字参数：参数名=‘默认的值’

# 动态参数：可以接收任意多个参数，即不确定有多少个参数

              # 参数名之前加*，习惯用参数名args，

              # 参数名之前加**，习惯用参数名kwargs，

# 顺序：位置参数，*args，默认参数，**kwargs

（注意：*args可以看成是多个变量组成的tuple；**kwargs可以看成是一个字典）

12、

（1）动态参数有两种：可以接受任意个参数

# *args ：接收的是按照位置传参的值，组织成一个元组

# **kwargs：接收的是按照关键字传参的值，组织成一个字典

# *args必须在**kwargs之前

#  *的作用：函数接受实参时，按顺序分配给函数形参，如果遇到带*的形参，那么就把还未分配出去的实参以元组形式打包（pack），分配给带*的形参

简单来说就是：
  打包（pack）：*args是把多个位置参数打包成元组，**kwargs是把多个关键字参数打包成字典。
  拆分（unpack）：*args是把打包了的参数拆成单个的，依次赋值给函数的形参，**kwargs是把字典的键值拆成单个的，依次赋值给函数的形参。

例子：

def func(*args,**kwargs):
    return args,kwargs
func(1,2,3,4,5,a=1,b='js')
print(func(1,2,3,4,5,a=1,b='js'))
# ((1, 2, 3, 4, 5), {'a': 1, 'b': 'js'})

（2）动态传参的另一种形式*******************************

例子：

def func(*args):  # 站在形参的角度上，给变量加*，就是组合所有传来的值为元组
    print(args)
func(1,2,3,4,5)
l = [1,2,3,4,5]
print(*l)
func(*l) # 站在实参的角度上，给一个序列加上*，就是将这个序列按照顺序打散


# 同上
def func(**kwargs):
    return kwargs
print(func(a=1,b=2,c=3))
k = {'a':1,'b':2,'c':3}
print(func(**k))

函数的注释：

def  func():
      """

           （1）这个函数实现什么功能

           （2）参数：含义

           （3）：return：返回值，是字符串或者列表的长度

     """

13、总结：

定义函数的规则：

（1）定义：def关键字开头，空格后函数名称和圆括号和冒号：、函数体

（2）参数：圆括号用例接收参数，若传入多个参数，参数之间用英文逗号隔开。

                    参数可以定义多个，也可以不定义

                    参数有很多种，如果涉及到参数的定义，应遵循顺序：

                         位置参数、*args、默认参数、**kwargs

                    如果上述定义过程中某参数类型缺省，其他参数依旧遵循上述排序

（3）函数的注释：函数体的第一行加函数的注释

（4）函数体：函数内容以冒号起始，并且缩进

（5）返回值：return  [表达式]    结束函数，如果不带表达式的return返回None

格式：

def  函数名(位置参数,*args,默认参数,**kwargs):
    "注释"
    函数体
    return 返回值

    

调用函数的规则：

（1）函数名()       # 函数名+圆括号就是函数的调用

（2）参数：

# 圆括号是用来接收参数的

# 若传入多个参数： 应该按照先位置参数、关键字参数

（3）  返回值

# 如果函数有返回值，还应该定义“变量”接收返回值

# 如果返回值有多个，也可以用多个变量来接收，变量数应和返回值数目一致

有三种情况：

一、无返回值：

函数名()

二、有返回值：

变量名=函数名()

三、多个变量接收多个返回值

变量1，变量2，变量3... = 函数名()

练习题：

#   1、假设无法用len()方法查看字符串等类型的长度
s = 'jsdfljd'
# print(len(s))

def len_():
    j = 0
    for i in s:
        j += 1
    return j
print(len_())


# 2、函数return后面代码不再执行
def func():
    """
    （1）这个函数是什么功能
    （2）参数1：含义
    （3）参数2：含义
    :return:返回值是字符串或列表长度或其他
    """
    l = ['金老板','二哥']
    for i in l:
        print(i)
        if i == '金老板':
            return None
    print('='*10)
ret = func()
print(ret)  # 函数中遇到return，将介绍苏函数，不再执行return后面的代码（函数中）


# 3、1-2+3-4+5.......+99 结果
def func():
    sum = 0
    for i in range(1,100):
        if i%2 == 0:
            sum -= i
        else:
            sum += i
    return sum
print(func())


# 4、使用range打印100,99,98，....1,0
for i in range(100,-1,-1):
    print(i)




'''
5、实现一个整数加法计算器：（6分）            
如：content = input(‘请输入内容:’)  # 如用户输入：5+8+7....(最少输入两个数相加)，
然后进行分割再进行计算，将最后的计算结果添加到此字典中(替换None)：
dic={‘最终计算结果’:None}。

'''
'''
def num_sum():
    """
    实现一个加法计算的功能
    :return: 返回数字相加的结果或者输入错误提示
    """
    content = input('请输入：')
    sum = 0
    dic={'最终计算结果':None}
    for i in content:
        if i.isdigit():
            sum += int(i)
        else:
            return "请输入数字"
    dic['最终计算结果'] = sum
    return dic
while 1:
    print(num_sum())
'''

# 方法二：通过使用split()方法分割输入的数字和加号
while 1:
    dic = {'最终计算结果': None}
    content = input('请输入：')
    content_list = content.split('+')
    sum = 0
    j = 0
    for i in content_list:
        if i.isdigit():
            sum += int(i)
            dic['最终计算结果'] = sum
            j += 1
            if j == len(content_list):
                print(dic)
        else:
            print('请输入数字')

函数思维导图：

陷阱例子：默认参数的陷阱

如果默认参数的值是一个可变数据类型，那么每一次调用的时候如果不传值就公用这个数据类型资源

例子：默认参数使列表可变数据类型

def func(l= []):
    l.append(l)
    print(l)

func()
func()
func()
# [[...]]
# [[...], [...]]
# [[...], [...], [...]]


# 例子2
def func(dic1 = {}):
    dic1['k'] = 'v'
    print(dic1)
func()
func()
func() # 因为键一样，所有覆盖了之前的键值对


# 例子3
def func(k,dic1={}):
    dic1[k] = 'v'
    print(dic1)
func(1)  # {1: 'v'}
func(2)  # {1: 'v', 2: 'v'}
func(3)  # {1: 'v', 2: 'v', 3: 'v'}