016-python函数和常用模块-函数定义和使用

函数式编程最重要的是增强代码的重用性和可读性

一、定义

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

函数的定义主要有如下要点：

def：表示函数的关键字
函数名：函数的名称，日后根据函数名调用函数
函数体：函数中进行一系列的逻辑计算，如：发送邮件、计算出 [11,22,38,888,2]中的最大数等...
参数：为函数体提供数据
返回值：当函数执行完毕后，可以给调用者返回数据。

 1 def sendmail():
 2     try:
 3         #邮件方式命令语句    
 4     except:
 5         return "失败"
 6     else:
 7         return  "cc"
 8 
 9 ret = sendmail()
10 if ret == "cc":
11     print("发送成功")
12 else:
13     print("发送失败")

二、返回值

函数是一个功能块，该功能到底执行成功与否，需要通过返回值来告知调用者。

默认返回值：

1 def f2():
2     print(123)
3 r = f2()
4 print(r)
5 
6 # 输出
7 123
8 None       #不指定return,默认返回none

def f1():
    print(123)
    # 在函数中，一旦执行return，函数执行过程立即终止
    return "111"
    print(456)         # 该语句将不执行
r = f1()
print(r)
# 输出
123
111

三、参数

函数的有三中不同的参数：

普通参数
默认参数
动态参数

# 1、普通参数（严格按照顺序，将实际参数赋值给形式参数）
# 2、默认参数（必须放置在参数列表的最后）
# 3、指定参数（将实际参数赋值给制定的形式参数）
# 4、动态参数：
#        *      默认将传入的参数，全部放置在元组中， f1(*[11,22,33,44])
#        **     默认将传入的参数，全部放置在字典中   f1(**{"kl":"v1", "k2":"v2"})
# 5、万能参数,   *args,**kwargs

普通参数：

1 # ######### 定义函数 ######### 
2 
3 # name 叫做函数func的形式参数，简称：形参
4 def func(name):
5     print name
6 
7 # ######### 执行函数 ######### 
8 #  'wupeiqi' 叫做函数func的实际参数，简称：实参
9 func('wupeiqi')

默认参数：

def func(name, age = 18):      # 18就是age这个形参的默认值
    
    print "%s:%s" %(name,age)

# 指定参数
func('wupeiqi', 19)
# 使用默认参数
func('alex')

注：默认参数需要放在参数列表最后

动态参数1(*)：

 1 def f1(*args):
 2     print(args,type(args))
 3 
 4 # 执行方式一
 5 f1(11,22,33,44)
 6 # 输出
 7 (11, 22, 33, 44) <class 'tuple'>      #每个参数作为args元组中的参数分别放入。
 8 
 9 # 执行方式二
10 ll = [11,22,33,44]
11 f1(ll)
12 # 输出
13 ([11, 22, 33, 44],) <class 'tuple'>  #列表ll作为args元组的1个参数被放入。
14 
15 # 执行方式三
16 ll = [11,22,33,44]
17 f1(*ll)
18 # 输出
19 (11, 22, 33, 44) <class 'tuple'>  #列表ll中的每一个元素被分别放入args元组中。相当于执行了一次for循环

动态参数2(**)：

1 def func(**kwargs):
2     print(kwargs)
3 
4 # 执行方式一
5 func(name="hello",age=18)
6 
7 # 执行方式二
8 li = {'name':'wupeiqi', "age":18, 'gender':'male'}
9 func(**li)

动态参数3(万能)：

 1 def f2(*args,**kwargs):     # **kwargs需要放在后面
 2     print(args)
 3     print(kwargs)
 4 
 5 dic = {"key1":"alex","key2":"alex2"}
 6 f2(1,2,3,4,**dic)
 7 
 8 # 输出
 9 (1, 2, 3, 4)
10 {'key2': 'alex2', 'key1': 'alex'}

内置函数str.format() (动态参数的应用)

　　str类中format()方法的说明

1     def format(self, *args, **kwargs): # known special case of str.format
2         """
3         S.format(*args, **kwargs) -> str
4         
5         Return a formatted version of S, using substitutions from args and kwargs.
6         The substitutions are identified by braces ('{' and '}').
7         """
8         pass

　　str类中format()方法的例子

 1 # str.format()
 2 # str format格式化输出
 3 
 4 # 通过*args传递参数
 5 s1 = "i am {0}, age {1}".format("alex", 18)
 6 print(s1)
 7 s2 = "i am {0}, age {1}".format(*["alex", 18])
 8 print(s2)
 9 
10 # 通过**kwargs传递参数
11 s1 = "i am {name}, age {age}".format(name='alex', age=18)
12 print(s1)
13 dic = {'name': 'alex', "age": 18}
14 s2 = "i am {name}, age {age}".format(**dic)
15 print(s2)

四、内容补充：

　　a. 相同函数名的创建

 1 def f1(a1, a2):         #上下两个函数相同，执行下面这个
 2     return a1 + a2
 3 
 4 def f1(a1, a2):
 5     return a1 * a2
 6 
 7 ret = f1(8, 8)
 8 print(ret)
 9 
10 # 输出
11 64
12 
13 # name = "alex"     #原理与变量的赋值类似，print(name)的时候打印“eric”
14 # name = "eric"
15 # print(name)

　　b、函数传递参数的时候，传递的是“引用”

 1 def f1(a1):
 2    a1.append("chh")
 3 
 4 li = [11,22,33,44]
 5 f1(li)            # 如果传参数的时候，是拷贝一份的话，print(li)应该仍旧是 [11,22,33,44]
 6 
 7 print(li)
 8 
 9 # 输出    
10 [11, 22, 33, 44, 'chh']

　　b、全局变量在函数中的使用

　　全局变量，所有作用域都可读；

　　对全局变量进行重新赋值，需要global;

　　特殊：字典、列表，可修改，不可重新赋值；(在不定义global的情况下)

　　全局变量，约定俗成使用大写。

　　b1函数体内设置的变量，特性如下：

# 函数体内设置的变量，作用域为函数体自身内有效。
def f1():
    name = "alex"
    print(name)

def f2():
    print(name)

f1()
f2()

# 输出
 File "路径/s2.py", line 157, in f2
    print(name)
NameError: name 'name' is not defined   # 提示f2函数体的name没有定义

　　b2全局变量，所有作用域都可读，特性如下：

name = "alex"    # name为全局变量
def f1():
    age = 18
    print(age, name)
def f2():
    age = 19
    print(age, name)
f1()
f2()
# 输出
18 alex
19 alex

　　b3全局变量和函数中的私有变量，如下：

name = "alex"
def f1():
    age = 18
    name = "chh"           # 私有变量和全局变量相同时，优先选择私有变量
    print(age, name)
def f2():
    age = 19
    print(age, name)
f1()
f2()

#输出
18 chh
19 alex

　　b4全局变量在函数中的运用，global声明，如下：

name = "alex"
def f1():
    age = 18
    global name           # 表示函数中使用的name是全局变量，重新赋值
    name = "chh"
    print(age, name)
def f2():
    age = 19
    print(age, name)
f1()
f2()

#输出
18 chh
19 chh

　　b5 特殊：字典、列表，可修改，不可重新赋值；(在不定义global的情况下)，如下：

name = [11,22,33,44]
def f1():
    age = 18
    # global name
    name.append(55)
    print(age, name)
def f2():
    age = 19
    print(age, name)
f1()
f2()

# 输出
18 [11, 22, 33, 44, 55]
19 [11, 22, 33, 44, 55]

name = [11,22,33,44]
def f1():
    age = 18
    # global name
    name = 888          #当作私有变量处理
    print(age, name)
def f2():
    age = 19
    print(age, name)
f1()
f2()

# 输出
18 888
19 [11, 22, 33, 44]

　　b6 全局变量，约定俗成使用大写，如下：

NAME = "CHH"               # 全局变量大写
def f1():
    age = 18
    global NAME               # 并在函数体中进行global声明
    NAME = "ALEX"
    print(age, NAME)
def f2():
    age = 19
    print(age, NAME)
f1()
f2()

#输出
18 ALEX
19 ALEX