【11】Python函数学习（上）

liwya

　　本文主要介绍python函数，也就是函数式编程的用法。
　　何为函数：
　　函数是组织好的，可重复使用的，用来实现单一，或相关功能的代码段。
　　函数能提高应用的模块性，和代码的重复利用率。你已经知道python提供许多内建函数，比如print()。但你也可以自己创建函数，这被叫做用户自定义函数。
　　规范：

• 　　面向对象  >>>>>> 类  >>>>>>class
  
• 　　面向过程  >>>>>> 过程 >>>>>def
  
• 　　函数式编程 >>>>> 函数 >>>>>def
  　　定义一个函数：
  　　你可以定义一个自己想要功能的函数，规则如下：
  
• 　　函数代码块以def关键词开头，后接函数标识符名称和圆括号。
  
• 　　任何传入传入参数和自变量必须放入圆括号中间，圆括号之间可以用于定义参数。
  
• 　　函数的第一行语句可以选择性地使用文档字符串，用于存放函数说明。
  
• 　　函数内容以冒号起始并且缩进。
  
• 　　return[表达式]结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回None。
  　　函数语法：
  　　def 标识符1():
  　　‘Hello world’ #添加介绍（可不加）
  　　x +=1  #代码块
  　　return x #定义返回值
  　　实例：
  

　　def hello():
　　"hello world!"
　　print('Hello world!')
　　hello() #调用函数
　　运行结果：
　　Hello world!
　　函数与过程：
　　#函数
　　def text1():
　　print('in the text1')
　　return 0
　　#过程
　　def text2():
　　print('in the text2')
　　x=text1()
　　y=text2()
　　print('from text1 return is  %s'%x)
　　print('from text2 retuin is  %s'%y)
　　运行结果：
　　in the text1
　　in the text2
　　from text1 return is  0
　　from text2 retuin is  None
　　注：函数与过程的区别（区别不大）
　　过程是没有返回值的函数，默认为None。
　　函数参数及调用
　　函数的返回值：
　　def test1():
　　print('in the text1')
　　def test2():
　　print('in the text2')
　　return 0   #先打印，在返回return
　　def test3():
　　print('in the text3')
　　return 1,'hello',['a','b']
　　x=test1()
　　y=test2()
　　z=test3()
　　print(x)
　　print(y)
　　print(z)
　　运行结果：
　　in the text1
　　in the text2
　　in the text3
　　None  #没有return默认返回 None
　　0  #返回return定义的值
　　(1, 'hello', ['a', 'b'])  #以一个元组返回
　　注：

• 　　不写return，默认返回None
  
• 　　return=1 返回object
  
• 　　return>1 返回一个tuple元组
  　　为什么要有返回值：需要整个函数的执行结果。
  　　有参数的函数
  

　　def text1(x,y):  #有参数的函数
　　print(x,y)
　　return 0
　　text1()
　　这样会报错，没有定义参数TypeError: text1() missing 2 required positional arguments: 'x' and 'y'
　　def text1(x,y): #行参 ：根据实参变化而变化，没有实际的参数。
　　print(x,y)
　　return 0
　　text1(1,2) #实参 ：实际参数
　　实参跟形参必须一一对应，个数不能超。
　　def text1(x,y): #行参
　　print(x,y)
　　return 0
　　text1(1,2) #这里叫 位置调用
　　text1(x=3,y=4) #关键字调用
　　x=5
　　y=10
　　text1(x=x,y=y) #这里面的x=x，前后两个x虽然长得一样，但是意义不一样。x=x，第一个x表示形参里面的x，第二才是定义的x变量值
　　运行结果：
　　1 2
　　3 4
　　5 10
　　关键字调用与位置调用
　　def text2(x,y,z): #行参
　　print(x,y,z)
　　text2(1,2,3) #位置调用
　　text2(y=11,z=22,x=33) #关键字调用
　　text2(90,40,z=50)
　　text2(x=10,20,30)  #运行报错
　　text2(10,x=10,) #运行报错
　　结论：

• 　　参数调用可以分为位置调用和关键字调用
  
• 　　位置调用，一一对应
  
• 　　关键字调用可以不按顺序填写
  
• 　　根据报错得结论，必须位置参数放在关键字前面，程序才不会出错。
  　　函数的非固定参数
  　　默认参数：
  

　　def test(x,y=2):  #这里y设定默认参数
　　print(x)
　　print(y)
　　test(11,22)  #定义位置参数
　　运行结果：
　　11
　　22
　　def test(x,y=2):  #这里y设定默认参数
　　print(x)
　　print(y)
　　test(11)  #定义位置参数
　　运行结果：
　　11
　　2
　　结论：
　　调用函数的时候，默认参数非必传。
　　以上所讲的参数调用都有一个共同点，那就是调用参数的个数，多了或者少了，都会报错（某些情况下，少参数不会报错，多了一定会报错）。如果我有N个实参，你不肯能写N个形参，针对实参不固定的情况下，有了参数组这个功能出现。具体看下面介绍
　　参数组：
　　def test1(*args):   以星开头，定义变量名。这里星的作用表示，接收N个实参。规范就是*args
　　print(args)  以元组的形式打印出来
　　test1(1,2,3,4,5,6)
　　test1(*[1,2,3,4,5,6])  #args=tuple([1,2,3,4,5,6])
　　
　　def test2(x,*args):
　　print(x,args)
　　test2(10,1,2,3,4,4,5,6)
　　运行结果：
　　(1, 2, 3, 4, 5, 6)
　　(1, 2, 3, 4, 5, 6)
　　10 (1, 2, 3, 4, 4, 5, 6)
　　应用：预留参数
　　参数组（建字典）
　　def text(**kwargs):   #把N个关键字参数转换成字典的形式
　　print(kwargs)
　　text(name='alex',age=18)
　　运行结果：
　　{'name': 'alex', 'age': 18}
　　def text(**kwargs):   #把N个关键字参数转换成字典的形式
　　print(kwargs)
　　print(kwargs['name'])
　　print(kwargs['age'])
　　text(name='alex',age=18)
　　text(**{'name':'alex','age':'18'})
　　运行结果：
　　{'name': 'alex', 'age': 18}
　　alex
　　18
　　{'name': 'alex', 'age': '18'}
　　alex
　　18
　　def text(name,age=18,*args,**kwargs):   #把N个关键字参数转换成字典的形式
　　print(name)
　　print(age)
　　print(args)
　　print(kwargs)
　　text('alex',names='alex',wante='30')
　　运行结果：
　　alex
　　18
　　()
　　{'names': 'alex', 'wante': '30'}
　　总结：
　　*args属于位置参数，接收将N个位置参数，转换成元组
　　**kwargs属于关键字参数，接收将N个关键字，转换成字典
　　位置参数调用，只能在关键字参数调用前面，否则会报错。