python 抽象

hasattr(func, __call__) #判断func是否可调用
func.__doc__ #访问func的文档字符串
help(func) #得到关于函数的信息

#字符串，数字，元组 是不可改变的，所以他们做参数时，其值只能用新值去覆盖，但是，不能去修改
#但是，对于可变的数据结构，如 list，将其作为参数时，函数对其做出的改变，会影响原变量的值，这是因为函数参数引用了list，函数对参数的改变，会直接改变list的值。若想避免这种情况，1，可以直接 将list的副本 作为参数，而非list本身；
#举例说明：
a = [1,2,3]
def addition1(a):
    a.append(4) #way1
    a += [4] #way2
    a = a + [4] #way3
#上述3种方法，只有way3不会改变 a 的值

def addition2(a):
    a.append(4)
b = a[:] #通过切片的方式，创造a的副本，从而避免addition2对a做出修改
b is a #返回 False
addition2(b)

#在python中，函数只能修改参数对象本身，其改变无法影响函数外的变量，如果你想改变参数，则可以使用列表
def inc(x): return x+1
foo = 1
f = inc(foo)
foo #依然为1

def inc(x): x[0] = x[0] + 1
foo = [10]
inc(foo)
foo # 变为 [11]

#收集参数
#位置参数，关键字参数
def func(position1, position2) #位置参数：位置很重要
def func(key1 = 'value1', key2 = 'value2') #关键字参数：明确每个参数的作用；在函数中给参数提供默认值；
#位置参数 和 关键字参数 也可以联合使用
def hello_4(name, greeting='Hello', punctuation='!'):
    print '%s, %s%s' % (greeting, name, punctuation)
hello_4('Mars') #位置参数必须赋值，否则报错
hello_4('Mars', 'Howdy') #按照顺序 赋值 关键字参数
hello_4('Mars', 'Howdy', '...')
hello_4('Mars', punctuation = '!!!') #如仅想对某个关键字参数进行赋值，则需写全

def func(pre, *positons, **keys) # *positions：位置参数，*用于收集所有其他的位置参数，如不提供任何元素，则返回空元组；**keys: 关键字参数，**用于收集所有关键字参数，如不提供任何元素，返回空字典；
def print_params_4(x, y, z=3, *pospar, **keypar):
    print(x, y, z)
    print(pospar)
    print(keypar)
print_params_4(1,2,3,5,6,7,foo=1,bar=2)  
#返回：
#1，2，3
#(5,6,7)
#{'foo': 1, 'bar': 2}
print_params_4(1,2)
#返回：
#1,2,3
#()
#{}
def func(*keys):
    for i in keys: #这里的位置参数 是可以进行 for循环的
        print(i)
        
#参数收集的逆过程
#调用函数时，使用 *params 
def add(x,y): return x+y
params = (1,2)
add(*params) 
#调用函数时，使用 **params
def with_stars(**kwds):
    print(kwds['name'],'is',kwds['age'],'years old')
args = {'name': 'Mr. Gumby', 'age':42}
with_stars(**args)
#使用拼接操作符 “传递” 参数
def foo(x, y, z, m=0, n=0):
    print(x, y, z, m, n)
def call_foo(*args, **kwds):
    print("calling foo!")
    foo(*args, **kwds) #通过拼接操作符传递参数，从而可以不用关心参数的 个数

#作用域
#vars()可以调取一个变量的值
x = 1
vars()['x'] #返回1
#如果全局变量名与函数参数名重名，且 想在函数内部调用全局变量，可利用globals()来调取
#情况一：在如下情况，可以直接通过 全局变量名来调取 全局变量
external = 'berry'
def combine(parameter): print(parameter + external)
#情况二：全局变量名 与 参数名重名
def combine(parameter): print(parameter + globals()['parameter'])

#与globals()相对的，可以用locals()返回局部变量的字典

#可以利用 global x 的方式，在函数内部改变全局变量的值
x = 1
def change_global():
    global x 
    x = x+1
change_global()
x #返回2

#嵌套作用域: python中的函数是可以嵌套的，具体如下
def multiplier(factor):
    def multiplyByFactor(number):
        return number*factor
    return multiplyByFactor #内层函数被返回了，但是，并没有被调用，返回的函数可以访问其所在的作用域
double = multiplier(2)
double(5) #返回 10
triple = multiplier(3)
triple(3) #返回 9
multiplier(5)(4) #返回 20
#如果想改变外部作用域的变量，可以用关键字 nonlocal
def multiplier(factor):
    def multiplyByFactor(number):
        nonlocal factor
        factor = 3
        return number*factor
    return multiplyByFactor
multiplier(5)(4) #返回 12
multiplier(2)(4) #返回 12

#函数式编程
#map(func, seq)
map(str, range(10)) #['0','1','2',...,'9']
#filter(func, seq)
seq = ['foo', 'x41', '?!', '***']
filter(lambda x: x.isalnum(), seq) #['foo', 'x41']