python函数&对象&模块之函数

为什么要使用函数
1) 可以降低代码量（调用函数只需要一行，而拷贝黏贴需要N倍代码）
2) 可以降低维护成本（函数只需修改def部分内容，而拷贝黏贴则需要每一处出现的地方都作修改）
3) 使序更容易阅读（没有人会希望看到一个程序重复一万行“I love FishC.com”）

1、创建函数
(1)不带参函数：”def 函数名():”
(2)带参函数：”def 函数名(形参1，形参2…):” ps：参数是变量
eg1:

def fun1():
print(“hello!world”)

eg2:

def fun2(num1,num2):
result=num1+num2
return result

eg3:

def MyFun((x, y), (a, b)):
return x * y - a * b
上面的写法是错误的，因为函数的参数需要的是变量，而这里你试图 用“元组”的形式来传递是不可行的。
应该写成：
def MyFun(x, y):
return x[0] * x[1] - y[0] * y[1]

MyFun((3, 4), (1, 2))

注：
创建的函数，如果不调用的的话，永远不会被执行；
如果函数前面没有定义，直接调用函数名会出错。

2、函数调用&返回结果
eg1:

def fun1():
print(“hello!world”)
temp=fun1() #函数调用
hello!world #输出结果
temp
None #报错

报错的原因是函数fun1没有返回值，temp是空的。
eg2:

def fun2(num1,num2): #定义函数
result=num1+num2
return result

temp=fun2(23,45) #调用函数
temp
68 #输出结果

temp有输出的原因是函数fun2有返回值
eg3_1:

def back():
return[‘小甲鱼’，3.14，45]
back()
[‘小甲鱼’，3.14，45] #输出结果:返回列表

eg3_2:

def back():
return(‘小甲鱼’，3.14，45)
back()
(‘小甲鱼’，3.14，45) #输出结果:返回元组

3、形参与实参
(1)形参：函数创建和定义过程中小括号里的内容 。eg:num1,num2
(2)实参：函数在调用过程中传递过去的内容。 eg:23,45
在python中可以通过查看doc来看函数的默认参数
eg:

fun2.doc
函数定义过程num1,num2是形参 #输出结果

注：
方式一：help(print) 按行输出print的用法
方式二：print.doc 连成一片输出其用法

4、关键字参数&默认参数&搜集参数
eg1:关键字参数

def saywords(name,word):
print(name+‘是’+word)
saywords(‘小甲鱼’,’teacher’) #函数调用
小甲鱼是teacher #输出结果

saywords(‘teacher’,’小甲鱼’) #函数调用
teacher 是小甲鱼 #输出结果

saywords(word=’teacher’,name=’小甲鱼’) #函数调用
小甲鱼是teacher #输出结果

在第三段中，直接给name和word 进行赋值，这便称作“用关键字赋值给参数”

eg2:默认参数

def saywords(name=’小甲鱼’,word=’teacher’):
print(name+‘是’+word)
saywords() #函数调用
小甲鱼是teacher #输出结果

saywords(‘小布丁’) #函数调用
小布丁是teacher #输出结果

saywords(‘小布丁’,’doctor’) #函数调用
小布丁是doctor #输出结果

第一段中打印为默认参数；第二段中相当于给第一个参数赋值，第二个参数使用默认参数值；第三段是一般赋值

eg3:搜集参数又称可变参数

def test(*parans):
print(‘参数的长度是：’，len(parans))
print(‘第二个参数是：’，parans[2])
test(1,[23,5,”小布丁”,’ddd’],’小甲鱼’,45,67,28,90,45)
参数的长度是：8 #输出结果
第二个参数是：’小甲鱼’

搜集参数 定义时要加’*’号，parans可以是数组跟数字、字符串的混合

eg4:参数既有搜集参数又有普通参数
方法一：非搜集参数使用默认参数(一般使用方法一)

def test(*parans,exp=8):
print(‘参数的长度是：’，len(parans),exp)
print(‘第二个参数是：’，parans[2])
test(1,[23,5,”小布丁”,’ddd’],’小甲鱼’,45,67,28,90,45)
参数的长度是：8，8 #输出结果
第二个参数是：’小甲鱼’

方法二 ：非搜集参数使用关键字方法赋值

def test(*parans,exp):
print(‘参数的长度是：’，len(parans),exp=8)
print(‘第二个参数是：’，parans[2])
test(1,[23,5,”小布丁”,’ddd’],’小甲鱼’,45,67,28,90,45)
参数的长度是：8，8 #输出结果
第二个参数是：’小甲鱼’

5、局部变量和全局变量
根据变量的作用域和可见性，变量可以分为局部变量和全局变量
(1)局部变量：在函数里定义的参数，变量；
(2)全局变量：在整个代码段中，都可以被访问到；
eg1:

def discounts(price,rate): #price,rate,final_price都是局部变量
final_price=price * rate
return final_price

old_price=float(input】(“请输入原价：”)) #old_price,rate,new_price都是全局变量
rate=float(input(“输入折扣率：”))
print(“折扣后的价格是：”,new_price)

============== RESTART: C:\Users\Desktop\文件\12.py ===============
请输入原价：100
输入折扣率：0.3
折扣后的价格是： 30.0

附：
如果new_price=diacounts(old_price,rate)后面一行输入print(final_price)，系统会报错：没有定义。因为局部变量不能放在函数体外面调用
如果按照下面代码实现：

def discounts(price,rate): #price,rate,final_price都是局部变量
old_price=50
print(“函数体中输出old_price：”，old_price)
final_price=price * rate
return final_price

old_price=float(input】(“请输入原价：”)) #old_price,rate,new_price都是全局变量
rate=float(input(“输入折扣率：”))
new_price=discounts(old_price,rate)
print(“折扣后的价格是：”,new_price)
print(“函数外部输出old_price：”，old_price)

============== RESTART: C:\Users\Desktop\文件\12.py ===============
请输入原价：100
输入折扣率：0.8
函数体中输出old_price： 50
折扣后的价格是： 80.0
函数外部输出old_price： 100.0

解析：
全局变量可以在函数内部去访问/读取它，但最好不要在函数内部去修改它，因为如果在函数内部修改全局变量的话，python会自动在函数内部新建一个同名的变量而不会影响全局变量的值。

6、global关键字
“global +变量名”：将函数内部的局部变量变成全局变量
eg1: 没加global实现结果

count=10
def f1():
count=5
print(count)
=============== RESTART: C:\Users\Desktop\文件\12.py ===============

f1()
5
count
10

eg2:加了global的实现结果

count=10
def f1():
count=5
print(count)
=============== RESTART: C:\Users\Desktop\文件\12.py ===============

f1()
5
count
5

7、内嵌函数/内部函数
eg1：fun2()函数的定义和调用都在fun1()函数内完成；函数体外部只能调用fun1()函数。

============== RESTART: C:\Users\Desktop\文件\12.py ===============

def fun1():
print(“函数fun1正在被调用…….”)
def fun2():
print(“函数fun2正在被调用…….”)
fun2()

fun1()
函数fun1正在被调用…….
函数fun2正在被调用…….

解析：
def fun2():
print(“函数fun2正在被调用…….”)#这两行是定义fun2()函数
fun2() #调用fun2()函数

8、闭包
如果在一个内部函数里，对一个外部作用域，但不是全局变量引用，内部函数被认为是闭包。
eg1:

def funX(x):
def funY(y):
return x*y
return funY #返回的是一个函数对象，不是函数值

i=funX(5)
i