Python 强化训练：第七篇

强化训练：第七篇

主题：

1. 函数参数、默认参数、关键字参数
2. **args, **kwargs
3. super()
4. 字典初始化
5. 闭包
6. 函数作用域
7. 装饰器：返回函数的高阶函数
8. 类属性和实例属性
9. __slots__限制实例属性

星号用于函数传递参数

* 表示元组：代表任意多个参数

def onefunc(a, *b):
    return a, b

print(onefunc(1, 2, 3, 4, 5))

#(1, (2, 3, 4, 5))

** 表示字典：代表任意多个关键字参数

def twofunc(a, **b):
    return a, b

print(twofunc(1, x=1, y=2, z=3))
#(1, {'z': 3, 'x': 1, 'y': 2})

* 用于表示关键字参数

def threefunc(a, *b, c):   # c表示关键字参数
    return a, b, c

print(threefunc(1, 2, 3, 4, c=88))   # 参数c不可省略
#(1, (2, 3, 4), 88)

def fourfunc(a, *, b):
    return a, b

print(fourfunc(1, b=90))   # 参数b不可省略
# (1, 90)

接受任意多参数, 任意多关键字参数

def fivefunc(*args, **kwargs):
    return args, kwargs

print(fivefunc(1, 2))
print(fivefunc(1, a=1, c=9, d=10))
print(fivefunc(1, 2, 3, w=12, f=34))
#((1, 2), {})
#((1,), {'c': 9, 'a': 1, 'd': 10})
#((1, 2, 3), {'f': 34, 'w': 12})

super()

在super机制里可以保证公共父类仅被执行一次，至于执行的顺序，是按照MRO（Method Resolution Order）：方法解析顺序 进行的。

class A(object):
    def __init__(self):
        print("A start")


class B(A):
    def __init__(self):
        A.__init__(self)
        print("B start")


class C(A):
    def __init__(self):
        A.__init__(self)
        print("C start")


class D(A):
    def __init__(self):
        A.__init__(self)
        print("D start")


class E(B, C, D):
    def __init__(self):
        B.__init__(self)
        C.__init__(self)
        D.__init__(self)

classname_e = E()
print("----------------------------------")

class A_1(object):
    def __init__(self):
        print("A start")


class B_1(A_1):
    def __init__(self):
        super().__init__()
        print("B start")


class C_1(A_1):
    def __init__(self):
        super().__init__()
        print("C start")


class D_1(A_1):
    def __init__(self):
        super().__init__()
        print("D start")


class E_1(B_1, C_1, D_1):
    def __init__(self):
        super(E_1, self).__init__()



classname_e_1 = E_1()

#A start
#B start
#A start
#C start
#A start
#D start
#----------------------------------
#A start
#D start
#C start
#B start

字典初始化

dict_one = {}   # dict_one = dict()
dict_one["a"] = 1
dict_one["b"] = 2
print(dict_one)
#{'b': 2, 'a': 1}

dict_two = dict((['a', 1], ['b', 2]))
print(dict_two)
#{'b': 2, 'a': 1}

keys_range = [i for i in "xyz"]
values_range = 1
dict_four = {}.fromkeys((keys_range), values_range)
print(dict_four)
#{'z': 1, 'x': 1, 'y': 1}

闭包：

1. 有一个内嵌函数

2. 内嵌函数使用外部函数的变量

3. 外部函数的返回值是内嵌函数

函数的调用 funcname()

函数是对象可以当成参数进行传递

def sample():

    n = 0

    def func():    # 内嵌函数
        print("n=", n)

    def get_n():     # 内嵌函数
        return n

    def set_n(value):    # 内嵌函数
        nonlocal n
        n = value

    func.get_n = get_n
    func.set_n = set_n
    return func    # 返回内嵌函数

funcname = sample()
funcname()
#n= 0

参数作用域

# 1. 局部
# 2. 内嵌参数
# 3. 全局
# 4. 内建
# 5. 搜索顺序： 局部> 内嵌 >全局> 内建


number = 10    # 全局变量


def parameter():

    number =0    # 局部变量

    def max(a):
        number = 3    # 内嵌
        if number > a:
            return number
        else:
            return a
    return max

pa = parameter()
print(pa(5))
print(number)
#5
#10

装饰器：函数作为参数，返回一个函数

def dec(func):
    def wrap(a):
        print("func_name: ", func.__name__)
        a += 10
        return a
    return wrap


def dec_w():
    pass


from datetime import datetime


def print_now(fn):
    def fn_wrap(*args, **kwargs):
        print("now time: %s, the fn name: %s" % (datetime.now(), fn.__name__))
        return fn(*args, **kwargs)
    return fn_wrap


@print_now
def hello(name="xiewei"):
    print("Hello World! %s" % name)
    
de = dec(dec_w)
print(de(200))
hello()
#func_name:  dec_w
#210
#now time: 2016-11-06 20:29:02.491987, the #fn name: hello
#Hello World! xiewei

类属性和实例属性

class Apple(object):
    name = "Apple"

    def __init__(self, number):
        self.number = number


A = Apple(500)
print(A.name)
print(A.number)
A.size = 12
print(A.size)
A.name = "chuizi"
print(A.name)
del A.name
print(A.name)
print(Apple.name)
#Apple
#500
#12
#chuizi
#Apple
#Apple

限制实例属性 __slots__

class chuizi(object):
    __slots__ = ["phone", "price", "brand"]
    def __init__(self, phone, price, brand):
        self.phone = phone
        self.price = price
        self.brand = brand


B = chuizi("M1", 2499, "chuizi")
print(B.phone)
print(B.price)
print(B.brand)
B.size = 5.5
print(B.size)  # wrong
#M1
#2499
#chuizi
#5.5