python学习手册18 参数

#!/usr/bin/env python
# -*- coding:utf8 -*-
'''
参数(argument或parameter)
对象作为输入发送给函数的方式，参数赋值给函数中的一个名称。
传递参数
    参数的传递是通过自动将对象赋值给本地变量名来实现的。
    函数内部的参数名的赋值不会影响调用者。
    改变函数的可变对象参数的值也许会对调用者有影响
    不可变参数‘通过值’进行传递。如字符串，整数。
    可变参数通过‘指针’进行传递。如列表，字典。
避免可变参数的修改
    python的类依赖原处修改一个传入的“self”参数来更新对象状态。
    如果不想函数内部的修改影响传递给它的对象，可以明确的创建可变对象的拷贝。如L=[:]
    为了真正意义上防止这些改变，将可变对象转换成不可变对象来解决。例如元组,tuple()函数。但使用这种技术会让函数失去一种参数能够调用任意列表特定方法的能力，包括不会在原处改变对象的那些方法都不再能够使用。
    函数能够升级为传入可变对象的形式。
    必须要有意识到这个属性：如果在你没有预期的情况下对象在外部发生了改变，检查一下是不是一个调用了函数引起的，并且有必要的话当传入对象时进行拷贝。
对参数输出进行模拟
    return可以返回任意种类的对象，所以它也能名返回多个值。
特定的参数匹配模型
    参数在python总是通过赋值传递的。
    默认情况下，参数是通过其位置进行匹配的，左右顺序，精确的传递数量一样多的参数。
    参数位置：从左至右进行匹配
    关键字参数：通过参数名进行匹配。name=value形式语法。
    默认参数：为没有传入值的参数定义参数值。还是name=value语法。
    可变参数：收集任意多基于位置或关键字的参数。以×号开头，收集任意多的额外参数。
    可变参数解包：传递任意多的基于位置或关键字的参数。
        同样使用×。只不过与函数头部的×恰恰相反：在函数头部它意味着收集任意多的参数，在调用者中意味着传递任意多的参数。
    keyword-only参数：参数必须按照名称传递。
    匹配语法：
        语法                      位置      解释
        func(value)             调用者     常规参数：通过位置进行匹配
        func(name=value)        调用者     关键字参数：通过变量名匹配
        func(*sequence)         调用者     以name传递所有的对象，并作为独立的基于位置的参数
        func(**dict)            调用者     以name成对的传递所有的关键字/值，并作为独立的关键字参数
        def func(name)          函数      常规参数：通过位置或变量名进行匹配
        def func(name=value)    函数      默认值参数，如果没有在调用中传递的话。
        def func(*name)         函数      匹配关收集（在元组中）所有包含位置的参数。收集除了位置，关键字参数外的其它参数到元组中。
        def func(**name)        函数      匹配差收集（在字典中）所有包含位置的参数。收集除了位置，关键字参数外的其它参数到字典中。
        def func(*args,name)    函数      参数必须在调用中按照关键字传递。
        def func(*,name=value)  函数      (python3.0)
python参数匹配的顺序法则：
    函数调用时，任何位置参数(value)，后面跟着任何关键字参数(name=value)和*sequence组合后面跟着**dict形式。
    函数头部定义时，任何一般参数(name),紧跟默认参数(name=value)，如果有的话，后面是*name(或*)的形式，后面跟着任何name或name=value keyword-only参数，后面踊着**name形式。
    在调用时表示关键字参数，在函数字义时表示默认参数。

    1,通过位置分配非关键字参数。
    2.通过匹配变量名分配关键字参数。
    3.其它额外的非关键字参数分配到*name元组中。
    4.其它额外的关键字参数分配到**name字典中。
    5.用默认值分配给在头部未得到分配的参数。
'''


# 参数和共享引用
def f(a):
    a = 99


b = 88
f(b) # 将b整数对象的值赋给a
print(b) # 88 b的值未受函数内部赋值的影响。


def changer(a, b):
    a = 2
    b[0] = 'talen'


X = 1
Y = [1, 2]
changer(X, Y)
print(X, Y) # (1, ['talen', 2])对于列表这种可变对象的传递，函数内部修改了引用后会影响到调用者的变量。当然这种原处修改，只有在修改的对象比函数生命更长的时候才会影响调用者。

X = 1
a = X
a = 2
print(X) # 1  #对X没有任何影响
L = [1, 2]
b = L
b[0] = 'talen'
print(L) # ['talen', 2] #对可变对象的原处修改，影响了引用者的值。

L = [1, 2]
changer(X, L[:])
print(X, L) # (1, [1, 2]) #对拷贝L[:]的修改没有影响L的对象。


def multiple(x, y):
    x = 2
    y = [3, 4]
    return x, y


C, D = multiple(1, 2)
print(C, D) # (2, [3, 4]) #返回了数组对象，勇冠赋值打印出结果。

# 参数匹配

print('默认值参数')


def f(a, b, c=3000):
    print(a, b, c)


print('位置参数')
f(9, 8, 7)

print('关键字参数')
f(b=20, c=30, a=10) # (10, 20, 30) #调用者传入的参数必须跟函数字义的参数名一致。
f(100, c=300, b=100) # (100, 100, 300) #混合使用时位置参数优先匹配，所以a变量的位置必须固定。

f(1000, b=2000) # (1000, 2000, 3000) #c会使用默认值参数
f(10000, b=2) # (10000, 2, 3000) #默认值与关键字参数混合


def func(spam, eggs, toast=3, ham=4):
    print((spam, eggs, toast, ham))


func(1, 2) # (1, 2, 3, 4) #位置参数与默认值混合
func(1, ham=44, eggs=22) # (1, 22, 3, 44) #位置参数，关键字与默认值混合
func(spam=111, eggs=222) # (111, 222, 3, 4) #关键字与默认值混合
func(toast=3333, eggs=2222, spam=1111) # (1111, 2222, 3333, 4)#同上
func(1, 2, 3, 4) # (1, 2, 3, 4) #位置参数

print('任意参数*,**')


# 在函数定义中，在元组中收集不匹配的位置参数。
# **只对关键字参数有效
def t(*args):
    print(args)


t()
t(1)
t(1, 2, 3, 5)


def d(**args):
    print(args)


d()
d(a=100, b='sf')

print('混合使用')


def all(a, *pargs, **kargs):
    print(a, pargs, kargs)


all(100, 3, 4, 5, x=77, b=99) # (100, (3, 4, 5), {'x': 77, 'b': 99})
print('调用时解包参数')
args = (1, 2)
args += (5, 6)
func(*args)
func(*(1,2),**{'toast':67,'ham':788})

def tracer(fund,*pargs,**kargs):
    print('calling:',fund.__name__)
    return fund(*pargs,**kargs)
def fund(a,b,c,d):
    return a+b+c+d
print(tracer(fund,1,2,c=3,d=4))


print('min')
def min1(*targs):
    res=targs[0]
    for arg in targs[1:]:
        if arg < res:
            res=arg
    return res
print(min1(6,7,8,1,2))
def min2(first,*targs):
    res=first
    for arg in targs:
        if arg < res:
            res=arg
    return res
print(min2(8,6,4,5,7))
def min3(*targs):
    tmp=list(targs)
    tmp.sort()
    return tmp[0]
print(min3(23,34,45,325,22,3,23345,89))
print(min1('bb','aa'))
print(min3([2,2],[1,1],[3,3]))

#函数作为另一种参数对象可以传入一个函数。
def minmax(test,*margs):
    res=margs[0]
    for arg in margs[1:]:
        if test(arg,res): #如果为真，返回arg的值，test可套用大于，小于等不同定义的函数。
            res=arg
    return res

def lessthan(x,y):
    return x < y
def grtrthan(x,y):
    return x>y

print(minmax(lessthan,5,3,21,3,5,3,25,45,26,6,7,100,325))
print(minmax(grtrthan,324,243,3,5,6,7,8,8,3,2,967))

#通用set函数
def intersect(*sargs):
    res = []
    for x in sargs[0]:
        for other in sargs[1:]:
            if x not in other:
                break
            else:
                res.append(x)
    return union(res)  #书上这一块感觉有错误，没有将重复的去除。

def union(*sargs):
    res=[]
    for seq in sargs:
        for x in seq:
            if not x in res:
                res.append(x)
    return res
s1,s2,s3='spam','scam','slam'
#print(intersect(s1,s2))
#print(union(s2,s3))
print('多个参数')
print(intersect(s1,s2,s3))
print(union(s1,s2,s3))

/usr/bin/python2.7 /home/talen/PycharmProjects/untitled/t18.py
88
(1, ['talen', 2])
1
['talen', 2]
(1, [1, 2])
(2, [3, 4])
默认值参数
位置参数
(9, 8, 7)
关键字参数
(10, 20, 30)
(100, 100, 300)
(1000, 2000, 3000)
(10000, 2, 3000)
(1, 2, 3, 4)
(1, 22, 3, 44)
(111, 222, 3, 4)
(1111, 2222, 3333, 4)
(1, 2, 3, 4)
任意参数*,**
()
(1,)
(1, 2, 3, 5)
{}
{'a': 100, 'b': 'sf'}
混合使用
(100, (3, 4, 5), {'x': 77, 'b': 99})
调用时解包参数
(1, 2, 5, 6)
(1, 2, 67, 788)
('calling:', 'fund')
10
min
1
4
3
aa
[1, 1]
3
967
多个参数
['s', 'a', 'm']
['s', 'p', 'a', 'm', 'c', 'l']

Process finished with exit code 0