Dsh008 python基础编程--函数（上）

1、函数的简介

• 函数是一个对象，对象是内存中专门用来存储数据的一块区域
• 函数用来保存一些可执行的代码，并且可以在需要时对这些语句进行多次调用
  • fn是函数对象，fn()调用函数，比如 print 和 print()

def fn():
    print('hello python')
fn()

• 注意：函数名必须符合标识符的规范(可以包含字⺟、数字、下划线但是不能以数字开头)

2、函数的参数

在定义函数的时候，可以在函数后面的括号中定义数量不等的形参，多个形参之间要用英文逗号（,）隔开

2.1 形参和实参

• 形参(形式参数) 定义形参就相当于在函数内部声明了变量，但是并不是赋值
• 实参(实际参数)指定了形参，那么在调⽤函数时必须传递实参，实参将会赋值 给对应的形参，简单来说有⼏个形参就要有⼏个实参

def s(a,b):
    print(a + b)
s(8,4)         # 输出结果为：12

2.2 函数的传递方式

• 定义形参时,可以为形参指定默认值。指定了默认值以后，如果⽤户传递了参 数则默认值不会⽣效。如果⽤户没有传递，则默认值就会⽣效

def fn(a,b,c=20):
    print('a = ',a)
    print('b = ',b)
    print('c = ',c)
fn(1,2,3)   # 输出结果为：a=1 b=2 c=3

• 位置参数：位置参数就是将对应位置的实参赋值给对应位置的形参
• 关键字参数 : 关键字参数可以不按照形参定义的顺序去传递，⽽根据参数名进⾏传递

def fn(b=1,c=2,a=3):
    print('a = ',a)
    print('b = ',b)
    print('c = ',c)
fn()    # 输出结果为：a=3 b=1 c=2

• 混合使⽤位置参数和关键字参数的时候，必须将位置参数写到关键字参数前⾯去

def fn(a,b=3):
    print('a = ',a)
    print('b = ',b)
fn(1)   # 输出结果为：a=1 b=3 

2.3 可变对象

• 对象在内存中保存了三个数据：
  • id（标识）
  • type（类型）
  • value（数值）
• 列表是一个可变对象，可以通过变量修改对象的值

a = [1,2,3]
b = a
b[0] = 10
print('a=',a,id(a))  #输出结果为：a = [10, 2, 3] 1515077355720
print('b=',b,id(b))  #输出结果为：b = [10, 2, 3] 1515077355720

a = [1,2,3]
b = a
b = [10,2,3]
print('a =',a,id(a))   #输出结果为：a = [1, 2, 3] 1462751381704
print('b =',b,id(b))   #输出结果为：b = [10, 2, 3] 1462751381064

2.4 实参的类型

• 在函数中对形参重新赋值，不会影响其他的变量

def fn(a):
    a = 20
    print('a = ',a)
c = 10
fn(c)             # 输出结果为：a =  20
print('c = ',c)   # 输出结果为：c =  10

def fn(a):
   
    print('a = ',a)

c = [1,2,3]
fn(c)             # 输出结果为：a =  [1,2,3]
print('c = ',c)    # 输出结果为：c =  [1,2,3]

• 如果形参执行的是一个对象，那么通过形参去修改对象的时候，会影响到所指向该对象的一个变量

def fn(a):    
    a[0] = 30
    print('a = ',a)
c = [1,2,3]
fn(c)            # 输出结果为：a =  [30,2,3]
print('c = ',c)   # 输出结果为：c =  [30,2,3]

def fn(a):
    # a = 20
    a[0] = 10
    print('a=',a,id(a))
c = [1,2,3]
fn(c.copy())   # 输出结果为：a= [10, 2, 3] 
print('c=',c,id(c))  # 输出结果为：c= [1, 2, 3]

def fn(a):
    # a = 20
    a[0] = 10
    print('a=',a,id(a))
c = [1,2,3]
fn(c[:])          # 输出结果为：a= [10, 2, 3] 
print('c=',c,id(c))    # 输出结果为：c= [1, 2, 3]

3、不定长参数

• 定义函数时，可以在形参前⾯加⼀个*，这样这个形参可以获取到所有的实参，它会将所有的实参保存到⼀个元组中
• 带*号的形参只能有⼀个，可以和其他参数配合使⽤
• *形参只能接受位置参数，不能接受关键字参数

def s(*a):
    r = 0
    for n in a:  # 遍历元组，并将元组中的元素相加
        r += n
    print(r)
s(1,24,6,8)      # 输出结果为：39

def s(*a,b,c):
    print('a = ',a)
    print('b = ',b)
    print('c = ',c)
s(1,24,b=4,c=8)        # 输出结果为：a =  (1, 24)  b =  4  c =  8

• **形参可以接收其他的关键字参数，它会将这些参数统⼀保存到字典当中。字典的key就是参数的名字，字典的value就是参数的值
• **形参只有⼀个，并且必须写在所有参数的后⾯

def s(a,b,**c):
    print('a = ',a)
    print('b = ',b)
    print('c = ',c)
s(a=1,f=24,b=4,e=8)   # 输出结果为：a =  1  b =  4  c =  {'f': 24, 'e': 8}

4、参数的解包

def s(a,b,c):   # 传递元组
    print('a = ',a)
    print('b = ',b)
    print('c = ',c)
t = (13,34,56)   
s(*t)             # 输出结果为：a =  13  b =  34  c =  56

def s(a,b,c):   # 传递字典
    print('a = ',a)
    print('b = ',b)
    print('c = ',c)
t = {'a':12,'b':45,'c':78}
s(**t)           # 输出结果为：a =  12  b =  45  c =  78