Python——函数（1）

什么是函数
函数也是一个对象
函数就是可以用来保存一些可以执行的代码，并且在需要的时候，对这些代码可以进行多次的调用
语法：
def 函数名（[形参1，形参2…]）:
代码块
注意：函数中保存的代码块不会立即执行，需要调用的时候才会执行

调用函数
函数对象()

函数命名规范（可以以包含下划线，字母，数字，但不能以数字开头）
定义函数的简单方式

def fn():
    print('今天是星期三')
    print('人生苦短，我用Python')

运行结果：
无
原因是：没有调用函数对象

def fn():
    print('今天是星期三')
    print('人生苦短，我用Python')

fn()

运行结果：

今天是星期三
人生苦短，我用Python

def fn():
    print('今天是星期三')
    print('人生苦短，我用Python')

fn()
fn()
fn()
fn()  #可进行多次函数调用

运行结果：

今天是星期三
人生苦短，我用Python
今天是星期三
人生苦短，我用Python
今天是星期三
人生苦短，我用Python
今天是星期三
人生苦短，我用Python

def fn():
    print('今天是星期三')
    print('人生苦短，我用Python')
    print(fn)    #不加括号的fn表示的是调用函数  <function fn at 0x000001927D4EF9D8>这个表示的是函数地址
fn()
fn()
fn()
fn()

运行结果：

今天是星期三
人生苦短，我用Python
<function fn at 0x000001EAB961F9D8>
今天是星期三
人生苦短，我用Python
<function fn at 0x000001EAB961F9D8>
今天是星期三
人生苦短，我用Python
<function fn at 0x000001EAB961F9D8>
今天是星期三
人生苦短，我用Python
<function fn at 0x000001EAB961F9D8>

#定义一个函数，求用户输入的俩个数的值
def sum():
   a = int(input('请输入第一个数的值：'))
   b = int(input('请输入第二个数的值：'))
   num  = a + b
   print('num =',num)
sum()

运行结果：

请输入第一个数的值：10
请输入第二个数的值：20
num = 30

函数的传递方式
1、通过默认值来传递

#1、
def fn4(a=10,b=20,c=30):  #给形参传递默认值
    print('a = ',a)
    print('b = ',b)
    print('c = ',c)
fn4()

运行结果：

a =  10
b =  20
c =  30

总结：实参优先于形参，参考如下：
位置参数
位置参数就是将对应位置的实参传递给对应位置的形参
第一个实参传给第一个形参，第二个实参传给第二个形参…

#函数的传递方式
#1、
def fn4(a,b,c=30):    #指定了默认值之后。如果传递了实参，那么将会替换函数里定义的形参()
    print('a = ',a)
    print('b = ',b)
    print('c = ',c)

fn4(1,2,3)

def fn5(a,b,c=30):
    print('a = ',a)
    print('b = ',b)
    print('c = ',c)

fn5(1,2)   #如果实参中没有传递，则默认值将会起到作用

运行结果：

a =  1
b =  2
c =  3
a =  1
b =  2
c =  30

关键字传参

#2、关键字参数，可以不安装形参定义的顺序去传递参数，而根据参数名来传递
def fn4(a,b,c):
    print('a = ',a)
    print('b = ',b)
    print('c = ',c)

fn4(b=20,c=30,a=40)   #关键字参数

运行结果：

a =  40
b =  20
c =  30

#位置参数和关键字参数可以混合使用

def fn4(a,b,c=20):
    print('a = ',a)
    print('b = ',b)
    print('c = ',c)

fn4(1,2,c=40)   #位置参数不能放在关键字参数后面，否则会报语法错误

运行结果：

a =  1
b =  2
c =  40

实参的类型
实参可以传递任意类型的对象

def fn4(a, c):  #第二步：由于他们不是关键字变量，然后根据第一个实参传给第一个形参，第二个实参传给第二个形参
                #可得：a='python',c='java'
    # 在函数中对形参进行重新赋值，不会影响其他的变量

    print('a = ', a,id(a))   #'python'
    print('c = ', c,id(c))   #java


c = 'python'
a = 'java'
fn4(c,a)   #第一步：实参被赋值,c='python',a='java'
print(' = ', a,id(a))
print(' = ', c,id(c))

运行结果：

a =  python 1966770153656
c =  java 1966740323328
 =  java 1966740323328
 =  python 1966770153656

总结：如果你在传递一个可变对象的时候，而你又不希望我在函数内部操作影响到函数外部的时候，那么你就可以考虑传递一个副本

def fn4(a):
    a[0] =50
    print('a = ', a,id(a))   #'python'


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

运行结果：

a =  [50, 2, 3] 1592609564232
c =  [1, 2, 3] 1592610403144

不定长参数
在定义函数时，可以在形参前面加上一个*，这样做的好处是这个形参可以获取所有的实参。
它将会把所有的实参保存到一个元组当中（注意：保存的类型是元组类型）

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

fn(1,2,3,4,5)

运行结果：

a = (1, 2, 3, 4, 5)

def fn(*sum):
    #定义一个变量
    result = 0
    #由于*号可以把实参中的所有元素返回给形参，返回的结果是一个元组类型，在通用遍历元素进行解包累加
    for i in sum:
        result = i+result
    print(result)
fn(20,30,50)

运行结果：

100

不定长参数可以配合其他参数一起使用
不定长参数不是必须写到最后，但要注意的是，带号的参数后面的所有参数，必须以关键字参数形式
来传递
带号参数只能接受位置参数，但不能接受关键字参数 代码如下：

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

fn(10,20,30,40)

运行结果：

a =  10
b =  20
c = (30, 40)

不定长参数可以不写在最后，但带*号后的参数必须以关键字参数来进行传递（注意：函数形参中只能带一个 * 号）

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

fn(10,20,30,40,60,c=70)

运行结果：

a =  10
b =  (20, 30, 40, 60)
c = 70

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

fn(10,20,30,40,b=60,c=70)

运行结果：

a =  (10, 20, 30, 40)
b =  60
c = 70

**形参可以接收其他关键字参数，它会将这些参数统一保存到一个字典当中
字典的key就是关键字的名字，字典的value就是参数的值 （只能有一个）并且写在所有参数后面

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

fn(1,2,name=123,add='python')

运行结果：

a = 1
b = 2
c =  {'name': 123, 'add': 'python'}

（*处理的是位置参数，**处理的是关键字参数）
参数解包

def fn4(a,b,c):
    print('a =',a)
    print('b =',b)
    print('c =',c)
nae =(1,2,3)

#传递实参，也可以在序列类型的参数添加一个*，这样他会自动将序列当中的元素依次作为序列传递给形参参数
#序列当中的元素的个数必须和形参的个数保持一致
fn4(*nae)

运行结果：

a = 1
b = 2
c = 3

字典类型解包：

def fn4(a,b,c):
    print('a =',a)
    print('b =',b)
    print('c =',c)

nae={'a':1,'b':3,'c':4}

fn4(**nae)

运行结果：

a = 1
b = 3
c = 4

*代表着是位置传递，
**代表着关键字传递