08-函数一

08-函数一

• 1、函数简介
  • 函数也是一个对象
  • 函数用来保存一些可执行的代码，并且可以在需要时，对这些语句进行多次调用
  • 函数中的代码不会立即执行，只有调用他的时候才会执行的

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

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

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time    : 2020/9/2 0002 20:38
# @Author  : Oliver
#函数
#函数也是一个对象
#对象是内存中专门用来存储数据的一块区域

#定义一个函数：
def fn():
    print('这是我的而第一个函数！！！')
fn()
print(fn)#<function fn at 0x00000229E7D8D0D0>遇到尖括号就是对象！！！
#fn是函数对象  fn()是调用函数

结果显示：

这是我的而第一个函数！！！
<function fn at 0x00000229E7D8D0D0>

Process finished with exit code 0

• 2、函数的参数

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

  #!/usr/bin/env python
  # -*- coding: utf-8 -*-
  # @Time    : 2020/9/2 0002 20:55
  # @Author  : Oliver
  
  #求和函数
  #函数的参数
  #在定义函数的时候，可以再函数后面的括号中定义数量不等的形参
  #形参之间要用，隔开
  #有几个形参要传入对应的实参
  def s(a,b):
      print(a,'+',b,'=',a+b)
  s(1,2)
  

  • 2.2 函数的传递方式
    • 定义形参时,可以为形参指定默认值。指定了默认值以后，如果用户传递了参数则默认值不会生效。如果用户没有传递，则默认值就会生效
    • 位置参数：位置参数就是将对应位置的实参赋值给对应位置的形参
    • 关键字参数 : 关键字参数可以不按照形参定义的顺序去传递，而根据参数名进行传递
    • 混合使用位置参数和关键字参数的时候必须将位置参数写到关键字参数前面去

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time    : 2020/9/2 0002 21:10
# @Author  : Oliver

#在定义函数的形参的时候，可以指定一个默认值
def fn(a,b,c=20):
    print('a=',a)
    print('b=',b)
    print('c=',c)
fn(1,2,3)
fn(1,2)
#函数的传递方式
#位置传参（将对应位置的实参传递到对应位置的形参）
#...
#关键字传参
#关键字传参可以不按照定义的顺序来传递，他是根据参数的名字来传递
def fn2(b=1,c=2,a=3):
    print('a=',a)
    print('b=',b)
    print('c=',c)
fn2()
#关键字传参和位置传参混合,关键字参数要放在位置参数的后面
def fn3(a,c=2):
    print('a=',a)
    print('c=',c)
#上述中的a就是位置参数，c是关键字参数

结果显示：

a= 1
b= 2
c= 3
a= 1
b= 2
c= 20
a= 3
b= 1
c= 2

Process finished with exit code 0

• 3、可变对象（插播内容）
  • 对象在内存中都保存了三个数据
    • id（标识）
    • type（类型）
    • value（值）
  • 举例：
    • a=[1,2,3]
    • a[0]=10
      • 只是修改列表对象当中一个元素
      • 这个操作是通过变量去修改对象的值，
      • 这个操作不会改变变量所指向的对象
    • a=[10,2,3]
      • 显然这样的效果是一样的，但是其实不一样的，是开辟了新的区域，进行了创建，id改变了，那么原先的对象呗回收了
      • 这个操作是在给变量进行重新赋值
      • 这个操作会改变变量所指向的对象
      • 这个操作不是在原先的位置上进行覆盖，而是重新找区域开辟的

对象在内存中都保存了三个数据
#id（标识）
#type（类型）
#value（值）
#a=[1,2,3]
#a[0]=10#只是修改列表对象当中一个元素
#这个操作是通过变量去修改对象的值，
#这个操作不会改变变量所指向的对象
#a=[10,2,3]#显然这样的效果是一样的，但是其实不一样的，是开辟了新的区域，进行了创建，id改变了，那么原先的对象呗回收了
# 这个操作是在给变量进行重新赋值
# 这个操作会改变变量所指向的对象
# 这个操作不是在原先的位置上进行覆盖，而是重新找区域开辟的

结果显示：

a [10, 2, 3] 2315502176384
b [10, 2, 3] 2315502176384
a [1, 2, 3] 2315502497536
b [10, 2, 3] 2315502497472

Process finished with exit code 0

• 4、实参的类型
  • 解释器不会检查参数的类型

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time    : 2020/9/2 0002 21:44
# @Author  : Oliver
#解释器不会检查参数的类型
def fn2(a):
    print('a=',a)

b=123
fn2(b)
b=True
fn2(b)
b=None
fn2(b)
b='hello'
fn2(b)
fn2(fn2)

def fn4(a):
    #在函数中对形参重新赋值，不会影响其他的变量
    a=20
    print('a=',a,id(a))
c=10
fn4(c)
print('c=',c,id(c))
def fn5(a):
    a[0]=30
    print('a=',a,id(a))
c=[1,2,3]
fn5(c)
print('c=',c,id(c))
#想要不变也可以
fn5(c.copy())
print('c=',c,id(c))

结果显示：

a= 123
a= True
a= None
a= hello
a= <function fn2 at 0x00000124DC90D0D0>

Process finished with exit code 0

• 3、不定长参数
  • 定义函数时，可以在形参前面加一个*,这样这个形参可以获取到所有的实参，它会将所有的实参保存到一个元组中
  • 带*号的形参只能有一个，可以和其他参数配合使用
  • *形参只能接受位置参数，不能接受关键字参数
  • **形参可以接收其他的关键字参数,它会将这些参数统一保存到字典当中。字典的key就是参数的名字,字典的value就是参数的值
  • **形参只有一个，并且必须写在所有参数的后面

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time    : 2020/9/9 0009 8:50
# @Author  : Oliver
#定义一个函数，求任意个数的和
def s(a,b):
    print(a+b)

s(1,2)
#不定长参数
def s1(*a):
    print(a,type(a))
s1(1)
s1(1,2,3,4,5)

def f1(*a):
    #定义一个变量保存结果
    r=0
    #遍历元组，取出数据，并将元祖中的数相加
    for n in a:
        r+=n
    print(r)
f1(1,3,46,7)

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

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

#如果，带星号的参数不是在最后一个，那么星号参数之后的参数需要使用关键字传递
#只能有一个星号
def fn3(a,*b,c):
    print('a=',a)
    print('b=',b)
    print('c=',c)

fn3(1,2,3,4,c=5)#关键字参数要在位置参数后面
#*形参只能接受位置参数，不接受关键字参数
#**形参可以接受关键字参数
def fn4(**a):
    print('a=',a)
fn4(b=1,c=2,d=3)
#**有且只能有一个，并且卸载所有参数的最后面，
#*形参是一个元组存放参数
#**形参是一个字典存放参数

def fn5(b,c,**a):
    print('a=',a)
    print('b=',b)
    print('c=',c)
fn5(b=1,d=2,c=3,e=20,f=30)

#*a处理的是位置参数，**a处理的是关键字参数

结果显示：

3
(1,) <class 'tuple'>
(1, 2, 3, 4, 5) <class 'tuple'>
57
a= 1
b= 2
c= (3, 4, 5)
a= 1
b= (2, 3, 4)
c= 5
a= {'b': 1, 'c': 2, 'd': 3}
a= {'d': 2, 'e': 20, 'f': 30}
b= 1
c= 3

Process finished with exit code 0

• 4、参数的解包
  • 传递实参时，也可以在序列类型的参数前添加星号，这样它会自动的将序列中元素依次作为参数传递
  • 要求序列中的元素的个数必须和形参的个数一致

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time    : 2020/9/9 0009 9:16
# @Author  : Oliver

#参数的解包
def fn4(a,b,c):
    print('a=',a)
    print('b=',b)
    print('c=',c)
t=(10,20,30)
fn4(*t)#自动将实参传递给函数，但是必须要形参实参个数相等的
d={'a':1,'b':2,'c':3}
fn4(**d)

结果显示：

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