python3 func 函数 传参.py

"""
模块：python3 func.py
功能：python3 函数 传参。
参考：https://www.runoob.com/python3/python3-function.html
知识点：
1.可变(mutable)与不可变(immutable)对象
    在 python 中，strings, tuples, 和 numbers 是不可变的对象，
    而 list,dict,set 等则是可以修改的对象。
    不可变类型：
        变量赋值 a=5 后再赋值 a=10，这里实际是新生成一个 int 值对象 10，再让 a 指向它，
        而 5 被丢弃，不是改变 a 的值，相当于新生成了 a。
    可变类型：
        变量赋值 la=[1,2,3,4] 后再赋值 la[2]=5 则是将 list la 的第三个元素值更改，
        本身 la 没有动，只是其内部的一部分值被修改了。

2.id(obj, /)
    返回对象的身份。
    这保证在同时存在的对象中是唯一的。
    (CPython 使用对象的内存地址。)
    可以通过判断两个对象的 id, 来判断这两个对象是否是同一个对象。

3.python 中一切都是对象。
    严格意义我们不能说值传递还是引用传递，
    我们应该说传不可变对象和传可变对象。
"""
# 一、可变(mutable)与不可变(immutable)对象
# 1.1.不可变对象。
#   改变变量 a 的值，其内存地址也发生了改变。
#   这说明，新生成了对象并分配了新的内存地址，绑定到变量 a。
a = 5
print(id(a))
# 140726143272736
a = 10
print(id(a))
# 140726143272896

# 1.2.可变对象。
#   本身 la 没有动，只是其内部的一部分值被修改了。
#   其内存地址不变，可以确定变前后的两个 la 是同一个对象。
la = [1, 2, 3, 4]
print(id(la))  # 1498721161984
la[2] = 5
print(id(la))  # 1498721161984


# 1.3.函数的参数传递。
# 1.3.1.python 传不可变对象实例
def ChangeInt(a):
    a = 10


b = 2
ChangeInt(b)
print("1.3.1:")
print(b)  # 2


def changeMe(mylist):
    """
    功能：修改传入的列表。
    :param mylist: 传入的列表。
    :return: None.
    """
    mylist.append([1, 2, 3, 4])
    print("函数内取值: ", mylist)
    # 函数内取值:  [10, 20, 30, [1, 2, 3, 4]]


# 1.3.2.传可变对象实例
print("1.3.2:")
mylist = [10, 20, 30]
changeMe(mylist)
print("函数外取值: ", mylist)


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


# 二、参数
# 以下是调用函数时可使用的正式参数类型：
# 2.1.必需参数
#   必需参数须以正确的顺序、数量传入函数。


def printme(str):
    """打印任何传入的字符串"""
    print(str)


print("2.1:")
# printme()
# TypeError: printme() missing 1 required positional argument: 'str'

# 2.2.关键字参数
#   使用关键字参数允许函数调用时参数的顺序与声明时不一致，
#   因为 Python 解释器能够用参数名匹配参数值。
print("\n2.2.")
printme(str="菜鸟教程")  # 菜鸟教程


def printinfo(name, age):
    """打印任何传入的字符串"""
    print("名字: ", name)
    print("年龄: ", age)


printinfo(age=50, name="runoob")


# 名字:  runoob
# 年龄:  50

# 2.3.默认参数
# 调用函数时，如果没有传递参数，则会使用默认参数。


def printinfo(name, age=35):
    """打印任何传入的字符串"""
    print("名字: ", name)
    print("年龄: ", age)


print("\n2.3.")
printinfo(age=50, name="runoob")
# 名字:  runoob
# 年龄:  50
print("------------------------")
# ------------------------
printinfo(name="runoob")


# 名字:  runoob
# 年龄:  35


# 2.4.不定长参数
# 你可能需要一个函数能处理比当初声明时更多的参数。
# 这些参数叫做不定长参数
# 基本语法如下：
# def functionname([formal_args,] *var_args_tuple ):
#    "函数_文档字符串"
#    function_suite
#    return [expression]

# 加了星号 * 的参数会以元组(tuple)的形式导入，存放所有未命名的变量参数。
def printinfo(arg1, *vartuple):
    """打印任何传入的参数"""
    print(arg1)
    print(vartuple)


print("\n2.4.")
printinfo(70, 60, 50)


# 70
# (60, 50)


# 加了两个星号 ** 的参数会以字典的形式导入。
def printinfo(arg1, **vardict):
    """打印任何传入的参数"""
    print(arg1)
    print(vardict)


printinfo(1, a=2, b=3)


# 1
# {'a': 2, 'b': 3}

# 2.5.声明函数时，参数中星号 * 可以单独出现，
# 例如:
# def f(a,b,*,c):
#     return a+b+c
# 如果单独出现星号，* 后的参数必须用关键字传入。
def f(a, b, *, c):
    return a + b + c


# f(1, 2, 3)  # 报错
# Traceback (most recent call last):
#   File "<stdin>", line 1, in <module>
# TypeError: f() takes 2 positional arguments but 3 were given
print("\n2.5.")
print(f(1, 2, c=3))  # 6

# 三、匿名函数
# python 使用 lambda 来创建匿名函数。
# 匿名，即不再使用 def 语句这样标准的形式定义一个函数。
#
# lambda 只是一个表达式，函数体比 def 简单很多。
# lambda 的主体是一个表达式，而不是一个代码块。
# 仅仅能在 lambda 表达式中封装有限的逻辑进去。
# lambda 函数拥有自己的命名空间，且不能访问自己参数列表之外或全局命名空间里的参数。
# 虽然 lambda 函数看起来只能写一行，却不等同于 C 或 C++ 的内联函数，
# 后者的目的是调用小函数时不占用栈内存从而增加运行效率。
# lambda 函数的语法只包含一个语句，如下：
# lambda [arg1 [,arg2,.....argn]]:expression
print("\n3.")
sum2 = lambda arg1, arg2: arg1 + arg2
print("sum2(10, 20):", sum2(10, 20))
# sum2(10, 20): 30
print("sum2(20, 20):", sum2(20, 20))


# sum2(20, 20): 40


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


# 五、强制位置参数
# Python3.8 新增了一个函数形参语法“/”，
# 用来指明函数形参必须使用“位置参数”，
# 不能使用关键字参数的形式。

# 在以下的例子中，形参 a 和 b 必须使用位置传参，
# c 或 d 可以是位置或关键字传参，
# 而 e 或 f 要求为关键字传参。
def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)


# 以下使用方法是正确的:
print("\n5.")
f(10, 20, 30, d=40, e=50, f=60)  # 10 20 30 40 50 60


# 六、序列、字典传参。
def f(a, b):
    return a * b


print("\n6.")
t = (2, 3)
print(f(*t))  # 6
d = {'a': 2, 'b': 6}
print(f(**d))  # 12