DAY6 python学习 函数

函数

一.定义函数

1.基本结构：使用关键字def来定义函数，后再指定函数名，括号内传递参数，最后仍是以冒号结尾。

def function_name():
	"""文档字符串"""
	...............

第二行是被称为文档字符串的注释，描述函数时做什么的，用三引号括起来，Python 用它们来生成有关程序中函数的文档。函数描述保存在函数的属性__ doc__里，可以通过*function_name. __ doc __ 调出。

def function_name():
    """This functon is to express my opinion."""

print(function_name.__doc__)

####结果为：
>>>This functon is to express my opinion.

2.实参和形参：

real_value='manage'          #实参
def function_name(formal_value):  #形参
	print(formal_value)
function_name(real_value)  #将实参传递给形参并调用函数

3.参数和返回值注解
（1）参数注解
在定义函数的时候，参数列表内部的参数后面，加上冒号和要传入的类型。注意虽然写了参数注解，但也无法强制限定变量的类型，只是作为提示来告知使用者应该传入什么类型的参数。

def plus(x:int,y:int):
    return x + y

print(plus(3,4))

（2）返回值注释
在参数列表后面，冒号前面，增加一个 -> 后面接返回值的类型。

def plus(x:int,y:int) -> int:
    return x + y

print(plus(3,4))

上述的注解都会以字典的形式存放在函数的属性__ annotations __中。

def plus(x:int,y:int) -> int:
    return x + y

print(plus.__annotations__)

####结果为：
>>>{'x': <class 'int'>, 'y': <class 'int'>, 'return': <class 'int'>}

 
 

二.传递实参

1.位置实参：函数调用中的实参顺序与函数定义中的形参顺序一致

name='yu'
age='22'
def identity(xingming,nianling):
	print(xingming,nianling)
identity(name,age)

2.关键字实参：函数调用时明确指出各个实参对应的形参。

name='yu'
age='22'
def identity(xingming,nianling):
	print(xingming,nianling)
identity(xingming=name,nianling=age)
###或者
identity(nianling=age，xingming=name)  #此时由于已经指明形参，顺序就不重要了

• 注意：
• （1）关键字实参的顺序无关紧要；
• （2）必须准备地指定函数定义中的形参名。

3.默认值：即在函数定义中给形参指定默认值

name='yu'
age='22'
def identity(xingming,nianling='22'):
	print(xingming,nianling)
identity(name)   #此时这个实参被视为位置实参

• 注意：
  （1）若给定默认值的形参，在调用函数时未给出其实参，将使用默认值，若给出，则正常使用给定的形参；
  （2）由于这个函数调用依旧是位置实参，所以形参列表中必须先列出没有默认值的形参，再列出有默认值的形参，这使得Python依然能够正确地解读其位置。

此外，使用默认值使得实参变得可选，即这个实参有时候需要，有时候不需要，方法是给实参指定一个默认值——空字符串，并将其移到形参列表的末尾。

first_name='yu'
middle_name='feng'
last_name='chen'
def name(first,last,middle=' '):
    if middle:
    	return first+' '+middle+' '+last
    else:
    	return first+''+last
print(name(first_name,last_name))
print(name(first_name,last_name,middle_name))

4.等效的函数调用：即上述三种方式可混合使用。
 
 

三.返回值

1.返回简单值：使用语句return返回函数处理得到的值

first_name='yu'
last_name='chen'
def name(first,last):
    return first+' '+last
print(name(first_name,last_name))

2.返回列表和字典：直接return返回即可

def identity(name,age):
	people={'name':name,'age':age}
	return people
print(identity('yu',18))  #调用函数返回字典

 
 

四.传递列表

1.传递：直接在函数调用时将列表名作为参数传递给函数即可
2.在函数中修改列表：这种修改是永久性的

names=['yu','zhang','zhu','fan']
new_names=[]
def transfor(name,new_name):
    while name:
        new_name.append(name.pop())
transfor(names,new_names)
print(names)
print(new_names)
#结果为：
[]
['fan', 'zhu', 'zhang', 'yu']

3.禁止函数修改列表：向函数传递原列表的副本，即使用切片表示法[:]创建列表的副本，这样原列表的内容就不会被修改。

names=['yu','zhang','zhu','fan']
new_names=[]
def transfor(name,new_name):
    while name:
        new_name.append(name.pop())
transfor(names[:],new_names)
print(names)
print(new_names)
#结果为：
['yu', 'zhang', 'zhu', 'fan']
['fan', 'zhu', 'zhang', 'yu']

 
 

五.传递任意数量的实参

1.基本概念：
Python允许函数从调用语句中收集任意数量的实参，在函数定义的形参前加*（星号） 让Python创建一个以形参名为名的空元组，将所有收到的实参都封装进这个元组中，即便只有一个值也是如此。

def names(*name):
	print(name)
names('yu','zhang','liu')
#结果为：('yu', 'zhang', 'liu')  将所有的实参装入这个元组中

2.结合使用位置实参和任意数量实参：
若让函数接受不同类型的实参，必须在函数定义中将接纳任意数量实参的形参放在最后。Python先匹配位置实参和关键字实参，再将余下的实参都收集到最后一个形参中。

def tongji(age_range,*names):
	print(age_range+'岁年龄段的人有：\n')
	for name in names:
		print('-'+name+'\n')
tongji('16~22','yu','zhang','liu')
#结果为：
16~22岁年龄段的人有：
-yu
-zhang
-liu

3.使用任意数量的关键字实参：
Python中函数可接受任意数量的关键字实参。在函数定义中，在接受任意关键字的形参前面加上两个（星号），并且将这个形参放在定义最后**。Python会创建与形参名同名的空字典，将传递的名称-值对都封装到这个字典中。

def identity(names,ages,**other_info):
    info={}
    info['name']=names
    info['age']=ages
    for key,value in other_info.items():
        info[key]=value
    print(info)
identity('yu',18,location='sichuan',mother='feng',father='zhang')
#结果为
{'name': 'yu', 'age': 18, 'location': 'sichuan', 'mother': 'feng', 'father': 'zhang'}

 
 

六.将函数存储在模块中

1.导入整个模块

模块是扩展名为.py的文件。编写improt语句并在其中指定模块名，就可以在程序中使用该模块中的所有函数。要调用被导入模块中的函数，可指定导入的模块的名称和函数名，并用句点分隔它们。

#name.py
def lover(name):
    print('I LOVE '+name.upper())

#test.py
import name
name.lover('xiao')
#结果为
I LOVE XIAO

 

2.导入特定的函数

语法如下，使用该种语法时，调用函数时就无需再指明模块名和使用句点。可用逗号隔开导入任意数量的函数。

from moudle_name import function_name0,function_name1，function_name2

 

3.使用as给函数或者模块指定别名：

若导入的函数或模块名与程序中现有的名称冲突，或者是导入的函数名或模块名过长，则可以使用关键字as给它们取个别名。

from module_name import function_name as fn  #给函数指定别名

import moudle_name as mn   #给模块指定别名

 

4.导入模块中所有的函数：

使用*运算可以导入模块中所有的函数，将模块中所有的函数都复制到这个程序中，因而可以通过名称来调用每个函数，无需使用句点表示法。
但是除非自己写的模块，不然调用别人的模块时，最好不要采用这种方法，否则会出现函数名称冲突。所以最佳要么只导入你所需要的函数，要么导入整个模块并使用句点表示法。

from moudle_name import *

 

5.关于语句 if __ name __ == “__ main __”： 的作用

（1）__ name __:
由于每个python模块（python文件）都包含内置的变量 __ name __，当运行模块被执行的时候，__name__等于文件名（包含了后缀.py）。
如果import到其他模块中，则__name__等于模块名称（不包含后缀.py）。
（2） __ main __:
“ __ main __”等于当前执行文件的名称（包含了后缀.py）。
（3）当模块被直接执行时，__name __ == ’ __ main __ '结果为真；而当模块被import到其他模块中时， __name __ == '__main __'结果为假，就是不调用对应的方法。
（4）总结：__name __ 是当前模块名，当模块被直接运行时模块名为 __main __ 。当模块被直接运行时，代码将被运行，当模块是被导入时，代码不被运行。