python学习——函数

函数

• 内建函数，如print()
• 用户自定义函数

一、函数定义法则

1. 函数代码块以 def 关键词开头，后接函数标识符名称和圆括号 ()。

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

2. 函数内容以冒号 : 起始，并且缩进。
3. return [表达式] 结束函数，选择性地返回一个值给调用方，不带表达式的 return 相当于返回 None。

函数实例
eg1:

def hello():
    print("hello python")

hello()

eg2:(函数中带上参数变量）

def max(a,b):
    if(a>b):
        print(f"{a} is bigger than {b}")
    elif(a==b):
        print(f"{a} is same as {b}")
    else:
        print(f"{b} is bigger than {a}")

num1=int(input("请输入一个数："))
num2=int(input("请输入另一个数："))

max(num1,num2)

eg3（计算面积函数）:

def area(width,height):
    return width*height
    
def welcome(name):
    print(f"welcome {name}")

name1=str(input("请输入您的姓名："))
welcome(name1)

input_width=int(input("请输入长方形的宽："))
input_height=int(input("请输入长方形的长："))
print(f"长方形的面积是{area(input_width,input_height)}")

二、函数调用

定义了函数以后，可以通过另一个函数调用执行，也可以直接从python命令提示符执行。
如在上述计算面积函数中：

#定义函数
def area(width,height):
    return width*height
#定义函数    
def welcome(name):
    print(f"welcome {name}")

name1=str(input("请输入您的姓名："))
#调用函数
welcome(name1)

input_width=int(input("请输入长方形的宽："))
input_height=int(input("请输入长方形的长："))
#调用函数
print(f"长方形的面积是{area(input_width,input_height)}")

三、参数传递

a=[1,2,3]
a=“Runoob”
[1,2,3] 是 List 类型，“Runoob” 是 String 类型，而变量 a 是没有类型，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 也会受影响

eg1(传不可变对象）:

def change(a):
    print(id(a))   # 指向的是同一个对象
    a=10
    print(id(a))   # 一个新对象
 
a=1
print(id(a))
change(a)

结果：
1584096432
1584096432
1584096576
在调用函数前后，形参和实参指向的是同一个对象（对象 id 相同），在函数内部修改形参后，形参指向的是不同的 id。

eg2（传可变对象实例）：

#!/usr/bin/python3
 
# 可写函数说明
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 printme( str ):
   "打印任何传入的字符串"
   print (str)
   return
 
# 调用 printme 函数，不加参数会报错
printme()

• 关键字参数
  关键字参数和函数调用关系紧密，函数调用使用关键字参数来确定传入的参数值。
  使用关键字参数允许函数调用时参数的顺序与声明时不一致，因为 Python 解释器能够用参数名匹配参数值。

#可写函数说明
def printinfo( name, age ):
   "打印任何传入的字符串"
   print ("名字: ", name)
   print ("年龄: ", age)
   return
 
#调用printinfo函数
printinfo( age=50, name="runoob" )

• 默认参数
  调用函数时，如果没有传递参数，则会使用默认参数。以下实例中如果没有传入 age 参数，则使用默认值

#可写函数说明
def printinfo( name, age = 35 ):
   "打印任何传入的字符串"
   print ("名字: ", name)
   print ("年龄: ", age)
   return
 
#调用printinfo函数
printinfo( age=50, name="runoob" )
printinfo( name="runoob" )

结果：
名字: runoob
年龄: 50
printinfo( name=“runoob” )，未输入年龄，按照默认35输出
名字: runoob
年龄: 35

• 不定长参数
  需要一个函数能处理比当初声明时更多的参数。这些参数叫做不定长参数，和上述 2 种参数不同，声明时不会命名。

def functionname([formal_args,] *var_args_tuple ):
“函数_文档字符串”
function_suite
return [expression]

加了星号 * 的参数会以元组(tuple)的形式导入，存放所有未命名的变量参数。

# 可写函数说明
def printinfo( arg1, *vartuple ):
   "打印任何传入的参数"
   print ("输出: ")
   print (arg1)
   print (vartuple)
 
# 调用printinfo 函数
printinfo( 70, 60, 50 )

结果：
70
(60, 50)

def functionname([formal_args,] **var_args_dict ):
“函数_文档字符串”
function_suite
return [expression]

加了两个星号 ** 的参数会以字典的形式导入。

# 可写函数说明
def printinfo( arg1, **vardict ):
   "打印任何传入的参数"
   print ("输出: ")
   print (arg1)
   print (vardict)
 
# 调用printinfo 函数
printinfo(1, a=2,b=3)

结果：
1
{‘a’: 2, ‘b’: 3}

五、匿名函数

使用 lambda 来创建匿名函数。

lambda [arg1 [,arg2,…argn]]:expression

eg1:

x = lambda a : a + 10
print(x(5))

结果：
15

eg2:

def myfunc(n):
  return lambda a : a * n
 
mydoubler = myfunc(2)
mytripler = myfunc(3)
 
print(mydoubler(11))
print(mytripler(11))

结果：
22
33

六、return语句

return [表达式] 语句用于退出函数，选择性地向调用方返回一个表达式。不带参数值的return语句返回None。