强化训练：第七篇
主题：
- 函数参数、默认参数、关键字参数
**args, **kwargs- super()
- 字典初始化
- 闭包
- 函数作用域
- 装饰器：返回函数的高阶函数
- 类属性和实例属性
-
__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
