Python基础学习(9)—函数(1)

函数(1)

1.1函数的简介(function)

1 函数也是一个对象
对象是内存中专门用来存储数据的一块区域
函数用来保存一些可以执行的代码，并且可以在需要的时候对这些语句多次调用

1.2创建函数

1 语法格式
def 函数名([形参1,形参2,形参3…]):
代码块

def fn(): # fn是函数对象， fn()调用函数
	 print('这是我第一个函数')
    print('abc','bcd')
    print('python')
    print('hahaha')
打印fn
print(fn)
fn()

运行结果

<function fn at 0x0000020B479B1E18>
# 函数的对象
这是我第一个函数

abc bcd
python
hahaha
#函数的内容

1.3函数的参数

1 在定义函数的时候，可以在函数名后面的括号里面定义数量不等的形参

2 多个形参我们用“,”号隔开

3 形参(形式参数)定义形参就是相当于在函数内部定义了变
量，但是并没有赋值

4 实参(实际参数)函数定义时指定了形参，那么调用函数的时候也必须传递实参

5 实参将会赋值给对应的形参，有几个形参就传几个实参

# 使用函数求两个数的和
def s():
    a = 1
    b = 2
    print(a+b)

s()

def fn2(a,b):
    print('a =',a)
    print('b =',b)
    print(a,'+',b,'=',a+b)
fn2(10,11)# 将a = 10,b = 20传给函数中的a,b形参
fn2(100,200)# 将a = 100,b = 200传给函数中的a,b形参

运行结果

3# 没有参数时

a = 10
b = 11
10 + 11 = 21

a = 100
b = 200
100 + 200 = 300

1.4 函数的传递方式

1 定义形参的时候我们可以为形参指定一个默认值
指定了默认值以后，如果用户传递了参数，默认值是不会有任何作用的，如果用户没有传递，则默认值会生效

def fn1(b,a = 1):
	print('b =',b)
	print('a = ',a)
fn1(10)
fn1(10,20)

运行结果

b =  10
a = 1
b =  10
a = 20

2 位置传参
位置传参就是将对应位置的实参传递给对应位置的形参

3 关键字传参
关键字传参可以不按照形参定义的顺序去传参，而根据参数名来传递参数

def fn1(a,b):
	print('b = ',b)
	print('a = ',a)

fn1(10,20)
fn1(b = 20,a = 10)

运行结果

b =  20
a =  10
b =  20
a =  10

4 位置传参也可以和关键字传参混合使用
混合使用的时候，必须将位置参数写到关键字参数前面

def fn1(a,b,c):
	print('a = ', a)
	print('b = ',b)
	print('c = ',c)
	
fn1(10,20,c = 30)

运行结果

a =  10
b =  20
c =  30

1.5 六 实参的类型

1 函数在调用的时候，解释权不会检查实参的类型
实参的类型可以是任意的对象

2 在函数中对形参重新复制不会影响其他的变量

3 如果形参在执行的时候，当我们通过形参去修改对象时
会影响到指向该对象的变量

def fn3(a):
    #在函数中对a重新赋值不会影响其他的变量
    a = 30
    print('a =',a)

c = 10
print(id(c))
fn3(c)
print(c,id(c))

def fn4(a):

    # 如果a在执行的时候，当我们通过形参去修改对象时，会影响到指向该对象的变量
    a[0] = 5
    print('a =',a,id(a))

c = [1,2,3]
fn4(c)
print('c =',c,id(c))

运行结果

1809018160
a = 30
10 1809018160

a = [5, 2, 3] 2303801902408
c = [5, 2, 3] 2303801902408 # c[0]改变

1.6 不定长参数

1 在定义函数的时候，可以在形参的前面加上一个“ * ”,这样这个形参将会获取到所有的形参，它会将所有的实参保存到一个元祖中

def s(*a):

    # 定义一个变量来保存 结果
    r = 0
    # 遍历元祖，将元祖中的元素取出来并进行累加
    for n in a:
        r += n
    print(r)

s(1,2,3,4,5,6)
def fn(*a):

    print('a = ',a,type(a))

fn(2,3,4,5,6,7,8,9,90)

def fn2(a,b,*c):

    print('a =',a)
    print('b =',b)
    print('c =',c)

fn2(1,2,3,4,5,6)

运行结果

21

a =  (2, 3, 4, 5, 6, 7, 8, 9, 90) <class 'tuple'>

a = 1
b = 2
c = (3, 4, 5, 6)#将剩下的数储存到c元组中

2 可变长参数不是必须要写到最后的，但是注意 带 “ * ” 的参数后面的参数，必须以关键字的形式传参

def fn2(*a,b,c):

    print('a =',a)
    print('b =',b)
    print('c =',c)

fn2(1,2,3,4,b=5,c=6)

运行结果

a = (1, 2, 3, 4)
b = 5
c = 6

3 若果在形参的开头直接写一个*，则要求我们但是所有的参数要以关键字的形式来传递

def fn2(*,a,b,c):

    print('a =',a)
    print('b =',b)
    print('c =',c)

fn2(a=3,b=4,c=5)

运行结果

a = 3
b = 4
c = 5

4 “**”形参可以接收其他的关键字参数，它会将这些参数统一保存到一个字典当中字典当中的key是参数的名字，字典当中的value是参数的值此形参只能有一个，并且必须写在最后面(装包)

def fn3(b,c,**a):
    print('a =', a,type(a))

    print('b =',b)
    print('c =',c)

fn3(b=1,d=2,c=3,e=4,f='q')

运行结果

a = {'d': 2, 'e': 4, 'f': 'q'} <class 'dict'>
b = 1
c = 3

1.7 参数解包

def fn5(a,b,c):
    print('a =', a)
    print('b =', b)
    print('c =', c)
# 这里面要求序列中的元素的个数必须和形参的个数一致，且必须是字典

d = {'a':100,'b':200,'c':300}# 字典的键要与参数一致

fn4(**d)

运行结果

a = 100
b = 200
c = 300