09、初始函数

1、函数定义def    (函数定义之后可以在任何需要它的地方调用它)

-->  以字长len（）为例

s = "小护士大医生"
def my_len():         #自定义函数
    i = 0
    for k in s:
        i += 1
    print(i)          # 没有返回长度，只是单纯的打印-->  6
lenght = my_len()
print(lenght)         #没有返回值，显示None

-->  返回值的定义

s = "小护士大医生"
def my_len():
    i =0
    for k in s:
        i += 1
    return i          #返回值
lenght = my_len()
print(lenght)

--> 返回值的3种情况
   没有返回值 —— 返回None   
   不写return   
   只写return:结束一个函数的继续
   return None  —— 不常用

def fanc():
    l = ['小王','护士长']
    for i in l:
        if i == '小王':
            return None          # 结束循环
    print('='*10)                # 不会打印
ret = fanc()
print(ret)                       # 返回None

-->  返回1个值
      可以返回任何数据类型
      只要返回就可以接收到
      如果在一个程序中有多个return，那么只执行第一个

def func():
    return {'k':'v'}
print(func())

def func2():
    return 1,2,3  #return 1,2,3
r= func2()
print(r)

-->   返回多个值
      用多个变量接收：有多少返回值就用多少变量接收
      用一个变量接收: 得到的是一个元组

2、参数
    没有参数
        定义函数和调用函数时括号里都不写内容
    有一个参数
        传什么就是什么
    有多个参数
        位置参数

def my_len(s):          #自定义函数只需要0个参数，接收参数,形式参数，形参
    i = 0
    for k in s:
        i += 1
    return i        #返回值
ret = my_len('金老板小护士')       #传递参数：传参，实际参数，实参--->6
# ret = my_len([1,2,3,4,5])       #传递参数：传参--->5
print(ret)

def f2(l1):           # 第一步，定义一个函数f2
    f1(l1)            #第四步，调用函数f1
    for i in l1:
        print(i)
#
def f1(l1):          # 第二步，定义一个函数f1
    for i in l1:
        print(i)
#
f2([1,2,3,4])       # 第三步，传递参数[1,2,3,4]

def my_sum(a,b):        # a、b为位置参数
    res = a + b
    return res
ret = my_sum(2,3)
print(ret)              # 返回值 5

--> 站在实参的角度上：
按照位置传参
按照关键字传参
混着用可以:但是 必须先按照位置传参，再按照关键字传参数
不能给同一个变量传多个值

--> 站在形参的角度上
位置参数：必须传,且有几个参数就传几个值
默认参数: 可以不传，如果不传就是用默认的参数，如果传了就用传的

def classmate(name,sex = '男'):           # 设置一个默认参数，sex=‘男'
print('%s：%s'%(name,sex))
classmate('小李')         # 小李：男
classmate('老王')        # 老王：男
classmate('小张')        # 小张：男
classmate('小红','女')  # 小红：女，当重新被赋值之后，性别将被覆盖修改

--> 只有调用函数的时候
按照位置传 ： 直接写参数的值
按照关键字： 关键字 = 值
--> 定义函数的时候：
位置参数 ： 直接定义参数
默认参数，关键字参数 ：参数名 = '默认的值'
动态参数 : 可以接受任意多个参数
参数名之前加*，习惯参数名args，
参数名之前加**，习惯参数名kwargs
顺序：位置参数，*args,默认参数,**kwargs

def classmate(name,sex):
    print('%s:%s'%(name,sex))
classmate('小李','男')                  # 直接输入必须按照位置参数顺序输入
classmate(sex = '男',name = '小张')     # 按照关键字输入的话，可以不按顺序输入

def classmate(name,sex = '男'):
    print('%s:%s'%(name,sex))
classmate('老王')                    # 当有默认参数时，输入实参时，默认参数位置可以不用输入
classmate('小红','女')

--> 动态参数有两种：可以接受任意个参数
*args ： 接收的是按照位置传参的值，组织成一个元组
**kwargs： 接受的是按照关键字传参的值，组织成一个字典
args必须在kwargs之前

def sum(*arge):
    print(arge)         # (1, 3) 接收的是按照位置传参的值，组织成一个元组
    n = 0
    for i in arge:
        n += i
    return n
print(sum(1,3))        # 4
print(sum(1,2,4))      # 7
print(sum(1,2,3,5))    # 11

def fanc(**kwarge):
    print(kwarge)
fanc(a = 1, b = 3, c= 5)     #{'b': 3, 'a': 1, 'c': 5} 接受的是按照关键字传参的值，组织成一个字典

def fanc(*arge,default = 1,**kwarge):    # 可以同时设置*args和**kwargs，但args必须在kwargs之前
    print(arge,kwarge)
fanc(1,2,3,4,default = 2, a = 'aaa', b = 'ffss')     # (1, 2, 3, 4) {'b': 'ffss', 'a': 'aaa'}

--> 动态参数的另一种传参方式

def func(*arge):
    print(arge)
func(1,2,3,4,5,6)            #(1, 2, 3, 4, 5, 6)
l = [1,2,3,4,5,6]
func(*l)            # 站在实参的角度上，给一个序列加上*，就是将这个序列按照顺序打散   (1, 2, 3, 4, 5, 6)

def func(**kwarge):
    print(kwarge)
func(a = 1, b = 4)         # {'a': 1, 'b': 4}
d = {'a': 1, 'b': 4}      # 定义一个字典d
func(**d)                 # {'a': 1, 'b': 4}

 

3、小练习

计算1-2+3-4+5.......+99

--->第一种
sum = 0
for i in range(1,100):
    if i % 2 == 0:
        sum = sum - i
    else:
        sum += i
print(sum)
--->第二种
sum = 0
i = 0
while i < 100:
    if i % 2 == 0:
        sum -= i
    else:
        sum += i
    i += 1
    continue
print(sum)