Python第八课-函数

函数

• 函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段。
• 有些语言，分函数和过程，有返回结果的叫函数，无返回结果的是过程。
• 函数的使用
  • 函数的使用要先定义
  • 使用函数，通常叫做调用
• 函数的定义
  • 函数代码块以 def 关键词开头，后接函数标识符名称和圆括号 ()。
  • 任何传入参数和自变量必须放在圆括号中间，圆括号之间可以用于定义参数。
  • 函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
  • 函数内容以冒号起始，并且缩进。
  • return [表达式] 结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回 None。
  • 语法

def 函数名（参数列表）:
    函数体

默认情况下，参数值和参数名称是按函数声明中定义的顺序匹配起来的。

• 函数的调用
  • 直接写出函数的名字，后面小括号不能省略，括号中的内容根据情况

# 定义函数
def printme( str ):
   # 打印任何传入的字符串
   print (str)
   return
 
# 调用函数
printme("我要调用用户自定义函数!")
printme("再次调用同一函数")

>>>
我要调用用户自定义函数!
再次调用同一函数

函数的参数和返回值

参数

• 负责给函数传递一些必要的数据和信息
• 参数分类
  • 形参（形式参数）：在函数定义时候用到的参数，没有具体值，只是一个占位符
  • 实参（实际参数）：在函数调用时传入的值

def hello(person):#形参
    print("{0},你好吗？".format(person))
    print("{},吃了吗？".format(person))
    
p = "小明"
hello(p)# 调用函数，把“小明”当作实参传入

>>>
小明,你好吗？
小明,吃了吗？

参数传递

• 在 python 中，类型属于对象，变量是没有类型的：

a=[1,2,3]
a=“World”

• 以上代码中，[1,2,3] 是 List 类型，“World” 是 String 类型，而变量 a 是没有类型，它仅仅是一个对象的引用（一个指针），可以是指向 List 类型对象，也可以是指向 String 类型对象。

在 python 中，strings, tuples, 和 numbers 是不可更改的对象，而 list,dict 等则是可以修改的对象

• 不可变类型：变量赋值 a=5 后再赋值 a=10，这里实际是新生成一个 int 值对象 10，再让 a 指向它，而 5 被丢弃，不是改变a的值，相当于新生成了a。
• 可变类型：变量赋值 la=[1,2,3,4] 后再赋值 la[2]=5 则是将 list la 的第三个元素值更改，本身la没有动，只是其内部的一部分值被修改了。

python 函数的参数传递：

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

python 中一切都是对象，严格意义我们不能说值传递还是引用传递，我们应该说传不可变对象和传可变对象。

def ChangeInt( a ):
    a = 10
    
b = 2
ChangeInt(b)
print( b )

>>>
2

def changeme( mylist ):
    "修改传入的列表"
    mylist.append([1,2,3,4])
    print ("函数内取值: ", mylist)
    return
 
# 调用changeme函数
mylist = [10,20,30]
changeme( mylist )
print ("函数外取值: ", mylist)

>>>
函数内取值:  [10, 20, 30, [1, 2, 3, 4]]
函数外取值:  [10, 20, 30, [1, 2, 3, 4]]

参数分类

• 普通参数/位置参数
• 默认参数
• 关键字函数
• 收集参数

def normal_para(one, two, three):# 普通参数
    print(one + two)
    return None
    
normal_para(1, 2, 4)# 普通函数使用时，有几个形参，就必须传几个实参，否则报错

>>>
3

def normal_para(one, two, three=100):# 这是默认参数，在定义函数时，就为参数设定默认值
    print(one + two)
    return None
    
normal_para(1, 2)# 默认参数的函数在调用时，有默认值的参数可以写可不写

>>>
3

#关键字参数
def keys_para(one, two, three):
    print(one + two)
    print(three)
    return None
    
keys_para(two=2,one=11,three=33)# 关键字参数的函数在传入实参的时候，不用注意顺序

>>>
13
33

def foo(*para):# 在参数前面加了一个*号。在函数内部，参数numbers接收到的是一个tuple
    print(para)

def foo_1(**para):# 关键字参数允许你传入0个或任意个含参数名的参数，这些关键字参数在函数内部自动组装为一个dict
    print(para)

def foo_2(*para1, **para2):
    print(para1)
    print(para2)

foo(1,2,3,4)
foo_1(a=1,b=2,c=3,d=4)
foo_2(6,7,8,n=9,m=10)

>>>
(1, 2, 3, 4)
{'a': 1, 'b': 2, 'c': 3, 'd': 4}
(6, 7, 8)
{'m': 9, 'n': 10}

# 在参数前面加了一个*号。在函数内部，参数numbers接收到的是一个tuple
def calc(*numbers):
    sum = 0
    for n in numbers:
        sum = sum + n * n
    return sum

>>> calc(1, 2)
5
>>> calc()
0

# 关键字参数允许你传入0个或任意个含参数名的参数，这些关键字参数在函数内部自动组装为一个dict
def person(name, age, **kw):
    print('name:', name, 'age:', age, 'other:', kw)

>>>person('Michael', 30)
name: Michael age: 30 other: {}

>>> person('Bob', 35, city='Beijing')
name: Bob age: 35 other: {'city': 'Beijing'}
>>> person('Adam', 45, gender='M', job='Engineer')
name: Adam age: 45 other: {'gender': 'M', 'job': 'Engineer'}

#也可以先组装出一个dict，然后，把该dict转换为关键字参数传进去
>>> extra = {'city': 'Beijing', 'job': 'Engineer'}
>>> person('Jack', 24, city=extra['city'], job=extra['job'])
name: Jack age: 24 other: {'city': 'Beijing', 'job': 'Engineer'}

# 上面的简写
>>> extra = {'city': 'Beijing', 'job': 'Engineer'}
>>> person('Jack', 24, **extra)
name: Jack age: 24 other: {'city': 'Beijing', 'job': 'Engineer'}

命名关键字参数
和关键字参数**kw不同，命名关键字参数需要一个特殊分隔符*，*后面的参数被视为命名关键字参数。

def person(name, age, *, city, job):
    print(name, age, city, job)

>>> person('Jack', 24, city='Beijing', job='Engineer')
Jack 24 Beijing Engineer

• 如果函数定义中已经有了一个可变参数，后面跟着的命名关键字参数就不再需要一个特殊分隔符*了

def person(name, age, *args, city, job):
    print(name, age, args, city, job)

# 命名关键字参数必须传入参数名，这和位置参数不同。如果没有传入参数名，调用将报错
>>> person('Jack', 24, 'Beijing', 'Engineer')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: person() takes 2 positional arguments but 4 were given

#命名关键字参数可以有缺省值
def person(name, age, *, city='Beijing', job):
    print(name, age, city, job)

>>> person('Jack', 24, job='Engineer')
Jack 24 Beijing Engineer

参数的组合

• 在Python中定义函数，可以用必选参数、默认参数、可变参数、关键字参数和命名关键字参数，这5种参数都可以组合使用。
• 注意，参数定义的顺序必须是：必选参数、默认参数、可变参数、命名关键字参数和关键字参数。

def f1(a, b, c=0, *args, **kw):
    print('a =', a, 'b =', b, 'c =', c, 'args =', args, 'kw =', kw)

def f2(a, b, c=0, *, d, **kw):
    print('a =', a, 'b =', b, 'c =', c, 'd =', d, 'kw =', kw)


>>> f1(1, 2)
a = 1 b = 2 c = 0 args = () kw = {}
>>> f1(1, 2, c=3)
a = 1 b = 2 c = 3 args = () kw = {}
>>> f1(1, 2, 3, 'a', 'b')
a = 1 b = 2 c = 3 args = ('a', 'b') kw = {}
>>> f1(1, 2, 3, 'a', 'b', x=99)
a = 1 b = 2 c = 3 args = ('a', 'b') kw = {'x': 99}
>>> f2(1, 2, d=99, ext=None)
a = 1 b = 2 c = 0 d = 99 kw = {'ext': None}

# 通过一个tuple和dict，也可以调用上述函数
>>> args = (1, 2, 3, 4)
>>> kw = {'d': 99, 'x': '#'}
>>> f1(*args, **kw)
a = 1 b = 2 c = 3 args = (4,) kw = {'d': 99, 'x': '#'}
>>> args = (1, 2, 3)
>>> kw = {'d': 88, 'x': '#'}
>>> f2(*args, **kw)
a = 1 b = 2 c = 3 d = 88 kw = {'x': '#'}

• 返回值：return [表达式] 语句用于退出函数，选择性地向调用方返回一个表达式。
• 如果函数没有返回值，默认返回None

def sum( arg1, arg2 ):
   # 返回2个参数的和."
   total = arg1 + arg2
   print ("函数内 : ", total)
   return total		# 函数返回值
 
# 调用sum函数
total = sum( 10, 20 )
print ("函数外 : ", total)

>>>
函数内 :  30
函数外 :  30

系统自定义了很多函数
help可以随时查看系统函数定义
help(函数名)