python基础 函数

1.初始函数

这样确实可以实现len方法的效果，但是总感觉不是那么完美？为什么呢？

首先，之前只要我们执行len方法就可以直接拿到一个字符串的长度了，现在为了实现相同的功能我们把相同的代码写了好多遍 —— 代码冗余

其次，之前我们只写两句话读起来也很简单，一看就知道这两句代码是在计算长度，但是刚刚的代码却不那么容易读懂 —— 可读性差

len()    #字符串的长度
s = 'hello word'  #计算'hello word'的长度
i = 0
for k in s:           #使用for循环来计算'hello word'的长度
    i += 1
print(i)

print(len(s))   #字符串的长度

2.函数的定义与调用

s1 = 'sole'
def my_len()：    #函数的定义def   my_len()是一种习惯性写法
    i = 0
    for k in s:
        i += 1
    print(i)            #没有返回长度，只是单纯的打印
my_len()                     #函数定义了之后，可以在任何需要它的地方调用

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

　　　def 是固定的，不能变。

　　　空格 为了将def关键字和函数名分开。

　　　函数名：函数名类似于变量，只能包含字符串、下划线和数字且不能以数字开头。

　　　括号：是必须加的。

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

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

3.函数的返回值

s1 = 'sole'
def my_len():
    i = 0
    for k in s1:
        i += 1
    return i                    #函数的返回值
length = my_len()
print(length)
len()                                #内置函数

1.不能变，只能计算s1字符串的长度
2.只是输出了结果

返回值分为三种情况

返回值的三种情况：

没有返回值 默认返回None

不写return:结束一个函数

def  func():
   l = ['aaaa','sole']
   for i in l:
      print(i)

只写return

def  func():
   l = ['aaaa','sole']
   for i in l:
      print(i)
   return

 遇到一个return后面就不执行，一旦遇到return，结束整个函数。

return None：和上面的两种情况一样，我们一般不这样写。

 返回一个值       可以返回任何数据类型，只要返回了就可以接收到。

ef func():
    return[1,2,3,4]
    return 1 #如果在一个程序中有多个return，只执行第一个
print(func())

返回多个值

a,b,c = (1,2,3)
a,b,c = ['a','b','c']
a,b = {'k':'v','k1':'v1'}
def func()
    return 1,2
r1,r2 = func()     #多个返回值用多个变量接受，有多少返回值就用多少变量接收。                     
print(r1,r2)            #     可以用一个变量接受，得到的是元祖

4.函数的参数

没有参数

　　定义函数和调用函数时括号里都不写内容。

有一个参数

　　传什么就是什么。

有多个参数

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

def my_len(s)#自定义函数只需要0个参数，接受参数，形式参数，形参
ret = my_len(s)  #传递参数:传参,实际参数，实参
def my_sum(a,b):   #  实参
   res = a+b   #result(结果)
   return res
my_sum(1,2)  my_sum(b=2，a=1)      #形参
print(ret)  站在形参的角度上:

位置参数:必须传，且有几个参数就传几个值
默认参数:可以不传，如果不传就是默认的参数，
　　　　　　只有调用函数的时候
按照位置传：直接写参数的值
按照关键字：关键字=值
定义函数的时候：
　　　　　　　　位置参数：直接定义参数
　　　　　　　　默认参数，关键字参数：参数名='默认的值'
　　　　　　　　动态参数：可以接收任意多个参数
　　　　　　　　　　　　　参数名之前加*,习惯参数名args
　　　　　　　　　　　　　*args:接收的是按照位置传参的值，组织成一个元祖
　　　　　　　　　　　　　**kwargs：接收的是按照关键字传参的值，组织成字典
　　　　　　　　　　　　　args必须在kwargs之前
##顺序:必须先定义位置参数，*args，默认参数，**kwargs

def classmate(name,sex):
    print('%s:%s'%(name,sex))
classmate('sole','男')
classmate(sex='男',name='sole')
classmate('aaa','女')

def classmate(name,sex='男'):               #设置一个默认值
    print('%s:%s'%(name,sex))
classmate('aaa','女')
classmate('aaa',sex='女')
#动态参数
def  sum(*args):
    n = 0
    for i in args:
        n += i
    return n
print(sum(1,2))
print(sum(1,2,3))
print(sum(1,2,3,4))


def func(*args):
    print(args)
func()

def func(**kwargs):
    print(kwargs)
func(a = 1,b = 2,c =3)
func(a = 1,b = 2)
func(a = 1)

def func(*args,**kwargs):
    print(args,kwargs)
func(1,2,3,4,5,a = 'aaaa',b='bbbb')

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

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

def func(**kwargs):
    print(kwargs)

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

5.函数的注释

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

#函数的陷阱
def qqxing(k,l = {}):
    # l.append(1)
    l[k] = 'v'
    print(l)

qqxing(1)     #[1]
qqxing(2)     #[1,1]
qqxing(3)     #[1,1,1]
# 如果默认参数的值是一个可变数据类型，
# 那么每一次调用函数的时候，
# 如果不传值就公用这个数据类型的资源

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