1、函数的使用可以加强代码的重用性和可读性。

2、函数的定义方法：


1 def 函数名(形式参数):
2     ...
3     函数体
4     ...
5     返回值



特点:(1)def 为函数的起始标识，当py文件执行到def时默认会不执行其中的代码，而是将函数放置到内存中等待调用。

        (2)函数名：表示函数的名称，利用函数名()可调用函数

　　 (3)参数：为函数体提供可用的数据

　　 (4)函数体：函数要做些什么事，需要函数实现的功能

　　 (5)返回值：函数执行结束后返回值给调用的地方

1、返回值：可以返回任何类型的值，函数为一个功能块，这个功能块被调用过后得到的结果，或者功能执行的成功与否，都可以通过返回值来告知调用者。

2、参数：分为形式参数和实际参数，形式参数为定义函数时定义的参数，实际参数为使用函数时向函数中提供的参数。具体可分为：普通参数、默认参数、动态参数

  • 普通参数：定义函数时给定义的参数，在使用函数时需要传递实际参数后使用函数，在传递参数时也可以使用参数=值的方式来传值 
1 1 #定义一个叫show_name的函数，并定义一个形式参数
2 2 def show_name(name):
3 3     print(name)
4 4 #调用函数时传入一个'parr'的实际参数，函数执行完毕屏幕打印出parr
5 5 show_name('parr')
  • 默认参数：定义函数时可给出参数的默认值，在调用函数时就不需要给出值，函数会取给出的默认值 
1 ------------定义函数---------------
2 #定义函数两个参数，第二个参数默认参数
3 def show_name(name,acter="handsome man"):
4     print(name,"is a",acter)
5 -----------调用函数-----------------
6 #调用函数传递第一个参数，第二个参数不给
7 show_name('parr')
8 
9 #屏幕打印:parr is a handsome man
  • 动态参数：使函数参数可以接收任何数据类型的值，将其转换为元组(*args)和字典(**kwargs)后再传入函数中执行调用 
1 #定义一个动态参数为元组的函数
 2 def show(*args):
 3     print(args)
 4     print(type(args))
 5 #调用函数传入任何值
 6 show(11,22,3,4,51,4,1)
 7 
 8 #屏幕打印:(11,22,3,4,51,4,1)
 9 #                  <class 'tuple'>
10 
11 #定义一个动态参数为字典的函数
12 def show(**kwargs):
13     print(kwargs)
14     print(type(kwargs))
15 #调用函数传入，k=v类型的值，将自动转换为字典
16 show(a=1,b=2,c=3)
17 
18 #屏幕打印{'a': 1, 'b': 2, 'c': 3}
19 #            <class 'dict'>
20 
21 #定义一个动态参数为元组和字典的函数
22 def show(*args,**kwargs):
23     print(args,type(args))
24     print(kwargs,type(kwargs))
25 #调用这个函数，前面传入的值转换为元组，后面k=v类型的将转换为字典
26 show(11,2,3,4,5,a=1,b=2,c=3)
27 
28 #屏幕打印：(11, 2, 3, 4, 5) <class 'tuple'>
29 #                {'a': 1, 'b': 2, 'c': 3} <class 'dict'

动态参数的函数可以在传入列表，字典或元组时，将值指定类型来传入*args或**kwargs，只需要在传值时在值前面加*或者**即可：
1 #调用函数时，不使用*和**指定值的类型，两个参数被变成了一个元组，第二个参数中没有值
 2 def show(*args,**kwargs):
 3     print(args,type(args))
 4     print(kwargs,type(kwargs))
 5 
 6 li1 = [1,2,3,4,5,6]
 7 dic1 = {
 8     "name":"parr",
 9     "age":"25"
10 }
11 show(li1,dic1)
12 
13 #屏幕打印：([1, 2, 3, 4, 5, 6], {'name': 'parr', 'age': '25'}) <class 'tuple'>
14 #               {} <class 'dict'>
#调用函数时，使用*和**指定传入值的类型时，值被传到了指定的参数中：
def show(*args,**kwargs):
    print(args,type(args))
    print(kwargs,type(kwargs))

li1 = [1,2,3,4,5,6]
dic1 = {
    "name":"parr",
    "age":"25"
}
show(*li1,**dic1)

#屏幕打印：(1, 2, 3, 4, 5, 6) <class 'tuple'>
#              {'name': 'parr', 'age': '25'} <class 'dict'>
  • 动态参数在字符串格式化中的应用： 
-----------------------*args格式化字符串------------------------
#定义一个字符串，使用{0}和{1}标识参数插入的位置
s1 = "{0} is {1}"
#列表的值对应插入到{0}和{1}的位置
l1 = ['parr','man']
#使用*l1将列表的值传入参数
result = s1.format(*l1)
print(result)

#屏幕打印：parr is man
--------------------------**kwargs格式化字符串-------------------------
#定义一个字符串，使用字典的key来占位
s1 = "{name} is {acter}"
#字典key对应要传入字符串的值
dic = {"name":"parr","acter":"man"}
result = s1.format(**dic)
print(result)

#屏幕打印：parr is man

发送邮件实例，涵盖了定义函数已经使用函数返回值来判断邮件发送是否成功的实例



import smtplib
from email.mime.text import MIMEText
from email.utils import formataddr
#定义一个发送邮件的函数，mailto参数用于可变换发送给的人
def mail(mailto):
#将发送邮件的结果默认为成功
    result = True
#使用try来判断代码是否成功执行完成，如果成功则return result
    try:
        msg = MIMEText('hello,my friend', 'plain', 'utf-8')
        msg['From'] = formataddr(["parr", 'parr2017@sina.com'])
        msg['To'] = formataddr(["哈哈哈", '220899@'])
        msg['Subject'] = "主题"

        server = smtplib.SMTP("", 25)
        server.login("parr2017@sina.com", "邮箱密码")
        server.sendmail('parr2017@sina.com', [mailto, ], msg.as_string())
        server.quit()
#如果不成功则为result赋值为：false
    except Exception:
        result = False
#返回函数执行的结果
    return result
#调用函数，并使用result变量得到函数返回的值
result = mail("220899@")
#如果result为True则返回发送成功，反之返回发送失败
if result:
    print("发送成功！")
else:
    print("发送失败！")



补充：lambda表达式，用来表示简单的函数，不需要声明的函数。减少内存空间占用。



#使用普通方法来定义一个简单函数
def add_a(a):
    a += 1
    return a
result = add_a(5)
print(result)
#屏幕打印：6

#使用lambda表达式来定义函数
add_a = lambda a : a+1
result = add_a(5)
print(result)
#屏幕打印：6