python函数的初始

python函数初识

　　一、什么是函数？
　　　　现在有这么个情况：python中的len方法不让用，你怎么办？
　　　　　　来测试一下 ‘hello word ’ 的长度：
　　　　　　s1 = "hello word "

　　　　　　count =0
　　　　　　for i in s1:
　　　　　　count+=1
　　　　　　print(count)
　　　　　　输出：11

　　　　OK，完事儿了，非常完美。但是主管又提出一个要求，要计算另外一个字符串的长度：“hello china”

　　　　　　s1 = "hello china "

　　　　　　count =0
　　　　　　for i in s1:
　　　　　　count+=1
　　　　　　print(count)

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

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

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

　　　　所以，我们就想能不能用一段代码，来实现相同的功能，比如，咱们也写一个len（）叫做my_len()可以代替len()的方法，既解决了代码冗余，有让其可读性好，用什么方法呢？ 这就引出了咱们今天讲的----函数。

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

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

　　二、函数定义与调用

　　　　　#定义函数

　　　　　　def my_len():
　　　　　　'''计算s1的长度'''
　　　　　　s1 = "hello word "
　　　　　　my_len = 0
　　　　　　for i in s1:
　　　　　　my_len +=1
　　　　　　print(my_len)

　　　　　　my_len()

　　　　　上面就是咱们写了一个函数，并且成功的调用了它。

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

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

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

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

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

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

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

　　　　三。函数的返回值。

　　　　　　咱们用len（）方法时，得到的结果会赋值给一个变量，然后得到结果：
　　　　　　s1 = "hello word "
　　　　　　sss = len(s1)
　　　　　　print(sss)

　　　　　　但是咱们写的这个函数，并不会得到这样的结果，如何让他和len函数一样，有返回值呢？

　　　　　　那就是在函数的最后加上一个return，return 后面写你需要的返回值就可以了。
　　　　　　定义函数：
　　　　　　def my_len():
　　　　　　count =0
　　　　　　for i in s1:
　　　　　　count +=1
　　　　　　return count
　　　　　　调用函数：
　　　　　　ss = my_len()
　　　　　　print(ss)

 

　　　　下面是咱们重点研究的return关键字的作用。
　　　　　　return关键字的作用
　　　　　　return是一个关键字，在pycharm里，你会看到它变成蓝色了，你必须一字不差的把这个背下来。
　　　　　　这个词翻译过来就是“返回”，所以我们管 写在retuen后面的叫：返回值。
　　　　　　要研究返回值，我们还要知道返回值有几种情况：分别是没有返回值，返回一个值，返回多个值，没有返回值。
　　　　　　不写return的情况下，会默认返回一个None：我们写的第一个函数，就没有写return，这就是没有返回值的一种情况。

　　　　　　def my_len():
　　　　　　'''计算s1的长度'''
　　　　　　s1 = 'hello word'
　　　　　　my_len=0
　　　　　　for i in s1:
　　　　　　my_len +=1
　　　　　　print(my_len)
　　　　#调用函数
　　　　　　ss_len = my_len()
　　　　　　#因为没有返回值，此时的ss_len为None
　　　　　　print('ss_len ：%s'%ss_len)
　　　　　　输出：
　　　　　　　　10
　　　　　　　　ss_len ：None

　　　　只写return，后面不写其他内容，也会返回值None，有的同学会奇怪，既然没有返回值，完全可以不写return，为什么还要写个return呢？这里我们要说一下return的其他用法。就是一旦遇到return，结束整个函数。

　　　　　　def ret_dem():
　　　　　　print(111)
　　　　　　return
　　　　　　print(222)
　　　　　　ret = ret_dem()
　　　　　　print(ret)
　　　　　　输出：
　　　　　　111
　　　　　　None
　　　　　　》》》returNone：和上面情况一样，我们一般不这么写。

　　　　#函数的定义
　　　　　　def mylen():
　　　　　　s1 = 'hello word '
　　　　　　count= 0
　　　　　　for i in s1:
　　　　　　count = count+1
　　　　　　return count
　　　　#函数调用
　　　　　　ser_len = mylen()
　　　　　　print(ser_len)
　　　　　　输出：11

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

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

　　　　　　　def my2():

　　　　　　'''返回多个值'''
　　　　　　return 1,['a','b'],3,4

　　　　　　ret1 =my1()
　　　　　　print(ret1)
　　　　　　ret2 = my2()
　　　　　　print(ret2)
　　　　　　输出：
　　　　　　(1, 2, 3, 4, 5)
　　　　　　(1, ['a', 'b'], 3, 4)
　　　　返回多个值：
　　　　返回多个值会被组成元组被返回，也可以用多个值来接收。
　　　　　　def my2():
　　　　　　'''返回多个值'''
　　　　　　return 1,['a','b'],3,4

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

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

　　　　#用多个值接收返回值，返回几个值，就用几个变量接收
　　　　　　a,b,c,d = my2()
　　　　　　输出：
　　　　　　(1, ['a', 'b'], 3, 4)
　　　　　　1 ['a', 'b'] 3 4
　　　　　　1 ['a', 'b'] 3 4

　　　　四。函数的参数：

　　　　　　现在，我们已经把函数返回值相关的事情研究清楚了，我们自己已经完成了一个可以返回字符串长度的函数。但是现在这个函数还是不完美，之前我们使用len函数的时候得是length = len("hello world")，这样我可以想计算谁就计算谁的长度。但是现在我们写的这个函数，只能计算一个“hello world”的长度，换一个字符串好像就是不行了。这可怎么办？
　　　　　　#定义函数
　　　　　　def mylen(s1):
　　　　　　'''计算s1的长度'''
　　　　　　count =0
　　　　　　for i in s1:
　　　　　　count = count +1
　　　　　　return count

　　　　　　#调用函数
　　　　　　ser_len = mylen(s1)
　　　　　　print(ser_len)
　　　　　　输出：11

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

　　　　　　实参与形参：
　　　　　　参数还有分别：
　　　　　　我们调用函数传递的这个”hello word“ 被称为《实际参数》，因为这个是实际的要交给函数的内容，简称实参。

　　　　　　定义函数时的s1，只是一个变量的名字，被称为《形式参数》，因为在定义函数的时候它只是一个形式，表示这里有一个参数，简称形参。

　　　　传递多个参数：
　　　　　　参数可以传递多个，多个参数之间用逗号分割。
　　　　　　def mymax(x,y):
　　　　　　the_max = x if x > y else y
　　　　　　return the_max

　　　　　　ma = mymax(10,20)
　　　　　　print(ma)
　　　　　　输出：20

　　　　位置参数
　　　　　　站在实参角度
　　　　　　1.按照位置传值
　　　　　　def mymax(x,y):
　　　　　　#此时x=10， y=20
　　　　　　the_max = x if x > y else y
　　　　　　return the_max

　　　　　　ma = mymax(10,20)
　　　　　　print(ma)
　　　　　　输出：20
　　　　2.按照关键字传值
　　　　　　def mymax(x,y):
　　　　　　#此时x=10， y=20
　　　　　　the_max = x if x > y else y
　　　　　　return the_max

　　　　　　ma = mymax(y=10,x=20)
　　　　　　print(ma)
　　　　　　输出：20
　　　　3.位置，关键字形式混着用

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

　　　　　　ma = mymax(10,y =20)
　　　　　　print(ma)
　　　　　　输出：20

　　　　　　正确用法：
　　　　　　问题一：位置参数必须在关键字参数的前面
　　　　　　问题二：对于一个形参只赋值一次
　　　　　　站在形参角度
　　　　　　位置参数必须传值
　　　　　　def mymax(x,y):
　　　　　　#此时x=10 ， y= 20
　　　　　　print(x,y)
　　　　　　the_max = x if x > y else y
　　　　　　return the_max

　　　　　　#调用mymax不传递参数
　　　　　　ma = mymax()
　　　　　　print(ma)
　　　　　　输出：
　　　　　　TypeError: mymax() missing 2 required positional arguments: 'x' and 'y'

　　　　默认参数：
　　　　　　正常使用
　　　　　　使用方法
　　　　　　为什么要有默认参数：将变化比较小的值设置成默认参数
　　　　2.默认参数的定义
　　　　　　def stu_info(name,sex = 'male'):
　　　　　　'''打印学生信息函数，由于班中大部分学生都是男生，
　　　　　　所以设置默认参数sex的默认值为'male'
　　　　　　'''
　　　　　　print(name,sex)

　　　　　　stu_info('alex')
　　　　　　stu_info('ena','female')
　　　　3.参数陷阱：默认参数是一个可变数据类型
　　　　　　def def_ult(a,l =[]):
　　　　　　l.append(a)
　　　　　　print(l)

　　　　　　def_ult('alex')
　　　　　　def_ult('egon')
　　　　　　输出：
　　　　　　['alex']
　　　　　　['alex', 'egon']
　　　　动态参数：

　　　　　　def trans_para(*arge,**kwargs):
　　　　　　print(arge,type(arge))
　　　　　　print(kwargs,type(kwargs))
　　　　　　trans_para("lalala",12,[1,2,3],[3,4,5],(1,4,2),{"a":'123'},country='china')
　　　　　　输出：
　　　　　　('lalala', 12, [1, 2, 3], [3, 4, 5], (1, 4, 2), {'a': '123'}) <class 'tuple'>
　　　　　　{'country': 'china'} <class 'dict'>

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