day 9 - 1 函数

函数

函数：定义了之后，可以在任何需要它的地方调用

函数模拟 len() 方法

#len() 方法的使用
s="世界上唯一不变的就是变化"
print(len(s))

#下面是我们常用的 len() 方法的使用
s="世界上唯一不变的就是变化"
print(len(s))

#下面我们来使用函数模拟 len() 方法
s="世界上唯一不变的就是变化"
def my_len():  #def 关键字定义函数 声明函数
    i=0
    for j in s:
        i=i+1
    print(i)
my_len()  #调用函数

这样我们便实现了使用函数来计算长度的功能，但这并不是我们想要的

与 len() 相比的不同
1.不能变，只能计算 s 字符串的长度
2.只是输出了结果
3.没有返回值

我们先来解决返回值的问题（还有 print() 打印结果的问题）

s="世界上唯一不变的就是变化"
def my_len():
    i=0
    for j in s:
        i=i+1
    return i  #设定返回值

#然后我们可以赋值的调取
length = my_len()
print(length)

#我们也可以直接调取，是不是发现什么
print(my_len())

#是不是和下面 len() 又相近了些
s="世界上唯一不变的就是变化"
print(len(s))

返回值
return 表示结束一个函数
　　与 break 的区别：break 跳出循环，函数的循环后面如果还有内容，则继续执行
　　return 直接结束函数
return 的作用：执行过该关键字后，不在实行后面的内容

下面我们来看看返回值的各种情况

1.没有返回值——当没有返回值时 默认为 None
　　1）不写 return——常用
　　2）只写 return——常用
　　　　1.21、与 break 的区别
　　3) return None——最不常用
2.返回一个值
　　1）数字、字符串、列表、字典 都是可以的,即可以返回任何数据类型
　　注意：
　　　　1. 只要返回就可以接守
　　　　2. 如果在一个程序中有多个 return，那么只执行第一个
3.返回多个值
　　1）多个返回值用多个变量接受，有几个返回值就用多少变量接收
　　2）如果多个值，用一个返回值来接收，则返回一个元组

#1.1 不写 return——常用
def func():
    s = ['anc','ghj']
    for j in s:
        print(j)
value = func()
print(value)

#1.2 只写 return——常用
def func():
    s = ['anc','ghj']
    for j in s:
        print(j)
    return
value = func()
print(value)

#1.21 与 break 的区别
def func():
    s = ['anc','ghj']
    for j in s:
        print(j)
#        break   #当执行 break 时，循环将不再进行 而打印下面“=”
        return   #当执行 return 时，停止循环且不执行 “=”
    print('='*10)
ret = func()
print(ret)

#1.3 return None——最不常用
def func():
    s = ['anc','ghj']
    for j in s:
        print(j)
        return None
    print('='*10)
ret = func()
print(ret)

#2.1 返回一个值
def func():
    return ['f','g']
print(func())

#3.1 多个返回值用多个变量接受
def func2():
    return 1,2
r1,r2 = func2()
print(r1)
print(r1)

#3.2 多个值，用一个返回值来接收
def func2():
    return 1,2
r1 = func2()
print(r1)

我们接着来解决（不能变，只能计算 s 字符串的长度）的问题

使用形式参数来接收参数的方式，使 my_len 可以处理任意实际参数的值
在使用形式参数来写函数时，形式参数不必有对应的值

def my_len(s):   #自定义函数只需要 0 个参数，此处为接收参数或叫形式参数，简称：形参
    i=0          #注意：形参处的 s 值必须与 for 循环中 s 值保持一致
    for j in s:
        i=i+1
    return i     #采用形式函数时，此处没有 return 时，值返回 None
#print(my_len()) #这样写就会报错，此处为传递参数或叫实际参数，或叫实参（因为没传递参数）

k="习惯是十倍的天性"
s="世界上唯一不变的就是变化"
ret = my_len(s)  #传参
ret2 = my_len(k)
ret3 = my_len([1,2,3])
print(ret)
print(ret2)
print(ret3)

#或者
print(my_len(s))
print(my_len(k))
print(my_len([1,2,3]))

#有没有发现和下面 len() 方法的使用变得一致了
s="世界上唯一不变的就是变化"
print(len(s))

参数

下面我们来较为详细的了解下参数

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

#下面我们来看下位置参数
def my_sum(a,b):
    print(a,b)
    res=a+b   #result
    return res

#我们来重点看下 a b 的值分别是什么，因为结果都是一样的
ret=my_sum(12,23)    # 12 23
print(ret)

ret2 = my_sum(b=23,a=12) #这里为关键字传参，即指定参数对应的位置
print(ret2)          # 12 23

ret3 = my_sum(23,12) # 23 12
print(ret3) 

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

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

下面我们来了解下默认参数

#带默认参数的函数
def classmate(name,sex='男'):    #参数中有俩个值：形参，默认参数性别为男
    print('%s: %s'%(name,sex))   #适合于在输入某些值时，大多的值是相同的情况
classmate('诺娃',"女")
classmate('雷诺')
classmate('萨尔')

只有调用函数的时候
　　按照位置传：直接写参数的值
　　按照关键字：关键字 = 值

定义函数的时候：
　　位置参数：直接定义参数
　　默认参数，关键字参数：参数名 = '默认的值'
　　动态参数：可以接受任意多个参数
　　　　参数名之前加 *，习惯参数名 args 
　　　　参数名之前加 **，习惯参数名 kwargs 
顺序：位置参数，*args，默认参数，**kwargs 

下面我们来了解下动态参数

###动态参数
#求任意数的和
def sum(*args): #关键字“*”
    n=0
    for i in args:
        n+=i
    return n

print(sum(12,23,13))
print(sum(14,25,36,123))

#注意：**kwargs 只能接受关键字传参
def func(**kwargs):  #关键字“**”
    print(kwargs)

func(a = 1,b = 2,c = 3)
func(a = 1,b = 2)
func(a = 1)
func(1,2,c = 3)  #报错 **kwargs 只能接收关键字传参的值

下面我们较为详细的了解下动态参数

动态参数有两种：可以接受任意个参数
　　1. *args 只接收位置参数的值，不能接收关键字传参的值
　　　　组织成一个元组
　　2. **kwargs 只能接收关键字传参的值
　　　　组织成一个字典
　　3. args 必须在 kwargs 之前

#注意：传参时必须先传位置参数在传关键字参数
def func(*args,**kwargs):
    print(args,kwargs)
func(1,2,3,4,a='',b='')#传参时必须先传位置参数在传关键字参数 

#动态参数的另一种传参方式
def func(*args):  #站在形参的角度上，给变量加上*，就是组合所有传来的值
    print(args)
func(1,2,3,4,5)

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

#**kwargs 与 *args 逻辑一样，类推就可以了
def func(**kwargs):
    print(kwargs)
func(a=1,b=2,c=3)

d={'a':4,'b':5,'c':6}
func(**d)

函数的注释

def func():
    #这个函数实现了什么功能
    #参数1：
    #参数2：
    #:return: 是字符串或者列表的长度
    pass

默认参数的陷阱

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

def qqxing(f = []):
    f.append(1)
    print(f)
qqxing([])  #表示使用了自定义参数
qqxing()    #表示使用了默认参数 所以下面每次调用参数都在同一个列表中递增
qqxing()
qqxing()

def qqxing2(k,f={}):
    f[k] = 'v'
    print(f)

qqxing2(1)
qqxing2(2)
qqxing2(3)

###回顾

函数
　　1.函数的定义 def
　　2.函数的调用
　　3.函数的返回值 return
　　4.函数的参数
　　　　形参：
　　　　　　位置参数：必须传
　　　　　　*args：可以接收任意多个位置参数
　　　　　　默认参数：可以不传
　　　　　　**kwargs：可以接收多个关键字参数
　　　　实参：按照位置传参，按照关键字传参