Python编程——函数的定义和操作

一.函数定义

函数： 是组织好的，可以重复使用的代码段，可以提高代码段的性能，是整体更具有结构性。

我们也可以定义一个实现某种功能的函数，对于定义函数，有如下规则：

（1）函数代码块以def关键字开头，后接函数名和圆括号（），后面再跟个冒号：。
（2）函数必须放在圆括号中间，圆括号之间可以用于定义函数。
（3）函数的第一行语句可以选择性地使用文档字符串——用于存放函数说明。

示例：

def myprint():
	print("hello")
	print("你好！")
myprint()

结果如下：
hello
你好

二.四种类型的函数

2.1> 无参数，无返回值的函数：

2.1> 无参数，无返回值的函数：

格式：

def 函数名（）：
	代码块

函数名（）

示例：

def myprint():
	print("hello")
	print("你好！")
myprint()

结果如下：
hello
你好

2.2> 无参数，有返回值的函数：

格式：

def 函数名()
	代码块
	return()
变量名=函数名()

示例：

def mysum():
	a=1
	b=2
	return a+b

c=mysum()
print(c)

结果如下：
3

2.3 >有参数，无返回值的函数：

格式：

def 函数名(形参1，形参2，...)
	代码块
函数名(实参1，实参2，...)

def mysum(a,b)
	print(a+b)
mysum(3,5)

结果如下：
8

2.4 > 有参数，有返回值的函数：

格式：

def 函数(形参1,形参2,......)
	代码块
	return 返回值

变量名 = 函数名(实参1,实参2，.....)

三.可变类型参数与不可变类型的参数

在python中，数字，字符串，元组是不可更改的类型，而列表，集合，字典则是可以修改的类型。

• 不可变类型： 例如，变量赋值 a =1 后再给a赋值a =2,实际上是新生成一个int值对象2，在让a指向它，并不是改变了a的值，而是心生成了a。
• 可变类型： 变量赋值 a=[1,2,3,4] 后再赋值 a[2]=5 则是将 list a 的第三个元素值更改，本身a没有动，只是其内部的一部分值被修改了。

python函数的参数传递：

• 不可变类型： 如数字、字符串、元组。在向函数传递参数时，如fun（a），传递的只是a的值，没有影响a对象本身。比如在 fun（a）内部修改 a 的值，只是修改另一个复制的对象，不会影响 a 本身。
• 可变类型： 如列表，字典，集合。在向函数传递参数时，如 fun（a），则是将 a 真正的传过去，修改后fun外部的a也会受影响。

实例：

#可变量
a1 = [1, 2, 3]
a2 = {1: 10, 2: 20, 3: 30}
a3 = {1, 2, 3}
 
#不变量
a4 = 123
a5 = "123"
a6 = (1, 2, 3)
 
#传入可变量
def kebian(a1,a2,a3):
    a1.append(4)
    a2[4]=40
    a3.add(4)
kebian(a1,a2,a3)
#结果已变
print(a1)
print(a2)
print(a3)
print("-----------------------------")
#传入不变量
def bubian(a4,a5,a6):
    a4=a4+4
    a5=a5+'4'
    a6=(1,2,3,4)
bubian(a4,a5,a6)
#结果依然不变
print(a4)
print(a5)
print(a6)

结果如下：
可以看出，可变量经过改变后，在不的也在改变，但不变量不会变化

[1, 2, 3, 4]
{1: 10, 2: 20, 3: 30, 4: 40}
{1, 2, 3, 4}
-----------------------------
123
123
(1, 2, 3)

四.参数

调用函数时，可使用的参数类型主要有一下三种：

• 固定参数
• 不定长参数
• 默认参数

4.1 > 固定参数：

固定参数必须以正确的顺序传入函数，且在调用函数时参数的数量必须和声明时的数量一样。否则会报错。

def myplus(a, b):
    return a + b
 
a = myplus("hello  ", "world")
print(a)
 
结果如下：
hello  world

4.2 > 不定长参数：

加了星号（*）的变量名会存放所有为命名的变量参数，可以使函数处理比当初声明时更多的参数。

def mysum(*a):  # 元祖，切记是加了*号的变量名；
    print(type(a), a)
    return sum(a)
 
print(mysum(1, 2))
print(mysum(1, 2, 3))
 
 
结果如下：
<class 'tuple'> (1, 2)
3
<class 'tuple'> (1, 2, 3)
6

4.23> 默认参数：

函数使用默认参数来确定传入的参数值，默认参数的值如果没有传入，则被认为是默认值。如果传入默认值，则以传入的为准。若传入默认参数的值，必须写明：默认值=值。

def myfun(a, *b, c=1):
    # 返回a+sum(b)**c
    return a + sum(b) ** c
 
#a=0 b=(1,2) 默认c=1
print(myfun(0, 1, 2))
#a=0 b=(1,2) c=2——>必须写明c=2
print(myfun(0, 1, 2, c=2))
 
 
结果如下：
3
9

五.变量作用域

• 一个程序的所有变量并不是在程序中哪一个位置都可以访问的。访问权限决定于这个变量是在那里赋值的。一般情况下，除过函数和类中定义的变量外，其余的变量都为全局变量。
• 局部变量只能在其被声明的函数内部访问，而全局变量可以在整个程序返回内访问。调用函数时，所有在函数内声明的变量名称都将被加入到作用域中。
• 局部变量的优先级高于全局变量，即遵循就近原则；

5.1> 全局变量：

除过函数和类中定义的变量外，其余都为全局变量。

print("1.全局变量")
# 除过函数中和类中定义的变量，都为全局变量
for i in range(10):
    x = i
 
# i=9,x=9.这里x和i都为全局变量
def myfun():
    print(x)
myfun()
print(x)
 
 
结果如下：
9
9

要想在函数中修改全局变量的值，就需要使用global。

# global的使用
s1 = 100
def myfun():
    global s1
    s1 = 200
print(s1)
#调用函数之后，s1的值改变
myfun()
print(s1)
 
结果如下：
100
200

5.2> 局部变量：

局部变量只能在其被声明的函数内部访问，而全局变量可以在整个程序范围内访问。调用函数时，所有在函数内声明的变量名称都将被加入到作用域中。

print("2.局部变量")
a1 = 20
def myfun(a1):
    a1 = 10
    print(a1)
myfun(a1)
print(a1)
 
结果如下：
2.局部变量
10
20

对于函数的嵌套，想要使用内部修改外部函数值，需要使用nonlocal。

# nonlocal的使用，一般用于函数的嵌套中
def f1():
    a = 3
    def f2():
        nonlocal a
        print(a)
        a = 5
        print(a)
    f2()
    #通过nonlocal，已经将a的值进行修改
    print(a)
f1()
 
结果如下：
3
5
5