函数的使用

学习笔记（20200628）：函数

一、函数的定义

'''1.定义： 函数是组织好的，可重复使用的，用来实现单一、或相关联功能的代码段
   2.特点：能提高应用的模块性，和代码的重复率。自己创建函数叫做用户自定义函数 
   3。怎样定义一个函数：
      1）。函数代码块 以 def 关键字开头 ， 后接函数标识符名称 和 （）
      2）。任何传入参数和自变量必须放在圆括号中间，圆括号之间用于定义参数。
      3）。函数内容以 ： 起始，并且缩进
      4）。return [表达式] 结束函数。不带return的表达式相当于返回 None
    def 函数名（参数列表）：
        函数体
'''
'''使用函数输出”HelloWorld“'''
def hello() :
    print('HelloWorld')
hello()             # 调用hello()
def hello(str) :    # 形参不需要 String str
    print(str)
hello('HelloWorld')
# 计算面积的函数：
def area(wide,height) :
    return wide * height
print('The area is ',area(15,20))
'''4.在 Python 中,类型属于对象，变量是没有类型的(见下面的解释)'''
a = [1,2,3]
a = 'Hello'
'''[1,2,3] 是 List 类型，'Hello' 是 String 类型，而变量 a 没有类型，他仅仅是一个对象的引用(指针)，可以指向List 类型对象，也可以指向String类型对象'''
'''5.可更改(mutable)与不可更改对象(immutable)'''
# 在 python 中，String、Tples 和 Numbers 是不可更改对象，而List，Set，Dictionary则是可以修改的对象
'''1）区别：
不可变类型：变量赋值 a=5 后再赋值 a=10，这里实际是新生成一个 int 值对象 10，再让 a 指向它，而 5 被丢弃，不是改变a的值，相当于新生成了a。
特点：不是在原空间改变，而是新开辟空间，若改变则浪费空间
可变类型：变量赋值 la=[1,2,3,4] 后再赋值 la[2]=5 则是将 list la 的第三个元素值更改，本身la没有动，只是其内部的一部分值被修改了。
特点：节省空间、比较灵活
2）。python 函数的 参数传递：
    不可变类型 ： 类似于 C++ 中的值传递，如 整数、字符串、元组。如fun（a），传递的只是a的值，没有影响a对象本身。比如在 fun（a）内部修改 a 的值，
    只是修改另一个复制的对象，不会影响 a 本身
    可变类型：类似 c++ 的引用传递，如 列表，字典。如 fun（la），则是将 la 真正的传过去，修改后fun外部的la也会受影响
python 中一切都是对象，严格意义我们不能说值传递还是引用传递，我们应该说传不可变对象和传可变对象。    
'''
'''传不可变对象实例：'''
def ChangeInt( a1 ) :
    a1 = 10
    print('a1=',a1)
b = 2
ChangeInt(b)
print('b=',b)
'''实例中有 int 对象 2，指向它的变量是 b，在传递给 ChangeInt 函数时，
按传值的方式复制了变量 b，a1 和 b 都指向了同一个 Int 对象，在 a1=10 时，则新生成一个 int 值对象 10，并让 a 指向它。'''
'''传可变对象实例：'''
def changeme(mylist) :
    "修改传入的列表"               # 函数内注释
    mylist.append([1,2,3,4])    # 末尾追加 变量
    print('函数内取值：',mylist)
    return                      # 简单的函数结束

mylist = [10,20,30]
changeme(mylist)
print('函数外取值：',mylist)
'''传入函数 和 在末尾添加新内容的对象用的是同一个引用'''
'''3).参数：
    1.必需参数
    2.关键字参数
    3.默认参数
    4.不定长参数
'''
# 必需参数
def printme( str ) :
    "打印任何传入的字符串"
    print(str)
    return

printme('Hello Friends')
# 关键字参数
'''使用关键字参数允许函数调用时参数的顺序与声明时不一致，因为 Python 解释器能够用参数名匹配参数值。'''
printme(str = '使用参数名，然后我会输出来')
'''以下实例中演示了函数参数的使用不需要使用指定顺序：'''
def printinfo( name , age ) :
    "打印任何传入的字符串"
    print("名字：", name)
    print("年龄：", age)
    return

# 调用 printinfo 函数
printinfo(age = 80,name = 'HeroMan')
# 默认参数 ：
#可写函数说明
def printinfo( name, age = 35 ):
   "打印任何传入的字符串"
   print ("名字: ", name)
   print ("年龄: ", age)
   return

printinfo(name = 'Jack',age= '15')
print('-------------分割线------------------')
printinfo(name= '少年')   # 未指定 age 则使用默认参数
# 不定长参数 ：
'''1)加了星号 * 的参数会以元组(tuple)的形式导入，存放所有未命名的变量参数。'''
def printinfo(arg1,*vartuple) :
    "打印任何传入的参数"
    print('输出：')
    print(arg1)
    print(vartuple)
# 调用printinfo 函数
printinfo(70,60,50)

def printinfo( arg1 , *vartuple ) :
    "打印任何输入的参数"
    print("输出：")
    print(arg1)
    for var in vartuple :
        print(var)
    return
# 调用 printinfo 函数
printinfo( 10 )    # 函数调用时没有指定参数，它就是一个空元组
printinfo(100,90,80)
'''2) 加了两个星号 ** 的参数会以字典的形式导入。'''
print('-----------------------------------------------------')
def printinfo( arg1 , **vardict) :
    "打印任何传入的参数"
    print('输出')
    print(arg1)         # 输出传入的实参 第一个元素
    print(vardict)      # 输出 传入的 字典 {'a': 2, 'b': 3} 键值对
# 调用 printinfo 函数
printinfo(1,a=2,b=3)
# 声明函数时，参数中星号 * 可以单独出现，如果单独出现星号 * 后的参数必须用关键字传入，不建议这样写，不直观
print('------------------------------')
def f(a,b,*,c) :
    return  a + b + c
# 调用 f() 函数
# f(1,2,3)        # 结果报错： TypeError: f() takes 2 positional arguments but 3 were given
print(f(1,2,c=3))

二、匿名函数

'''二、匿名函数：
1.Python 使用 lambda 来创建匿名函数
2.匿名：是不再使用 def 语句这样标准的形式定义一个函数。
3.lambda 知识一个表达式，函数体比 def 简单的多
4.lambda的主体是一个表达式，而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去。
5.lambda 函数拥有自己的命名空间，且不能访问自己参数列表之外或全局命名空间里的参数。
6.虽然lambda函数看起来只能写一行，却不等同于C或C++的内联函数，后者的目的是调用小函数时不占用栈内存从而增加运行效率。
'''
# 可写函数说明
sum = lambda arg1, arg2 : arg1 + arg2
# 调用 sum 函数
print('相加后的值：', sum(10 , 20))
print('相加后的值：', sum(20 , 20))
'''三、return 语句的使用'''
def sum(arg1, arg2) :
    # 返回2个参数的和
    total = arg1 + arg2
    print("函数内：",total)
    return  total
# 调用 sum 函数
total = sum(10,20)
print('函数外：', total)

# 强制位置参数：/
'''在以下的例子中，形参 a 和 b 必须使用指定位置参数，c 或 d 可以是位置形参或关键字形参，而 e 或 f 要求为关键字形参:'''
print('--------------')
def f(a, b, /, c, d, *, e, f) :
    print(a,b,c,d,e,f)
# 调用
f(1,2,3,4,e = 5,f = 6)
f(1,2,3,d = 4,e = 5,f = 6)

三、与C语言中函数定义的比较

'''三、与C中函数的对比
C中：返回类型 函数名(形参){               python 中： def 函数名（参数列表） ：
        函数体                                       函数体
}
eg:
void Hello(){                          def hello() :
    printf("Hello")                         printf('Hello')
}
'''