前面我们介绍了关于Python面向对象的基础知识和概念，今天我们来了解一下关于它的高级用法与进阶。
模块架构，早在之前的文章我们就已经提到过，但是在这里我又不得不提起，因为它是面向对象的一个接口，我们只有熟练这些模块的使用，才能对后面的一些知识点得心应手。
'''模块架构'''
import math
from math import sqrt
import math as shuxue
a=math.sqrt(16) #直接用模块加函数
b=sqrt(4) #用函数
c=shuxue.sqrt(9) #用自命名的模块加函数
print(a,"\t",b,"\t",c)
if __name__=="__main__":
print(a)
else:
print(c)
"""使用包"""
'''例如上述实验方法，我们在导入包的时候，可以有不同的方法，因为导入不同，所以调用也不同
所以，我们在调用的时候必须要看后面的是什么，比如import requests 这个时候我们要使用这个里面的功能
必须以 requests.get()方法,或者from requests import get方法，还有一系列的，所以我们在自己开发试验的时候必须
熟悉自己的方法，避免混淆
'''
'''导入类'''
'''类的导入与模块相似'''
'''迭代器'''
'''迭代器的使用例如for循环语句遍历迭代器'''
class Use:
def __init__(self,x=2,max=50):
self.__mul,self.__x=x,x #初始化属性，X的初始值是2
self.__max=max
def __iter__(self):
return self
def __next__(self):
if self.__x and self.__x !=1:
self.__mul *=self.__max
if self.__mul <=self.__max:
return self.__mul
else:
raise StopIteration
if __name__=="__main__":
my=Use()
for i in my:
print("迭代数据元素为：",i)
'''使用内置迭代器方法iter（）'''
class Counter:
def __init__(self,x=0):
self.x=x
counter=Counter()
def used_iter():
counter.x+=2
return counter.x
for i in iter(used_iter,52): #iter该函数用于函数，当最后一个参数迭代后返回和自己定义的相等的时候，程序结束，例如12
print(i)
from itertools import *
def height_class(h):
if h > 180:
return 'tall'
elif h < 180:
return "short"
else:
return "middle"
friends=[191,158,159,169,148,163,175,156,123,149,256,596,648,789,156,3589,180]
friends=sorted(friends,key=height_class)
for m,n in groupby(friends,key=height_class):#使用groupby（）遍历数据
print(m)
print(list(n))
'''生成器'''
def fib(max):
a,b=1,1
while a <max:
yield a
a,b=b,a+b
for n in fib(15):
print(n)
def xie():
print("等待接收任务......")
while True:
data=(yield )
print("收到任务：",data)
def producer():
c=xie()
c.__next__()
for i in range(5):
print("发送一个任务......","任务%d"%i)
c.send("任务%d"%i)
if __name__=="__main__":
producer()
'''装饰器'''
'''装饰器可以解决我们在实际开发当中，减轻我们代码的重复率，提高效率'''
def window(run):
def wrapper(*args,**bian):#定义了一个包装器函数
print("植入木马中......")
run(*args,**bian)
print("木马已经渗入......")
return wrapper
@window
def worm(x):
a=[]
for i in range(x):
a.append(i)
print(a)
@window
def str(name):
print("hello",name)
if __name__=="__main__":
worm(10)
print()
str("h7n9病毒")
def deco(func):
def _deco(a,b):
print("在函数myfunc（）之前被调用。")
ret=func(a,b)#这里必须要将装饰器里面的参数实例化，不然不会产生效益
print("在函数myfunc()之前被调用，结果是：%s"%ret)
return ret
return _deco
@deco
def myfunc(a,b):
print("函数myfunc(%s,%s)被调用！"%(a,b))
return a+b
myfunc(4,2)
myfunc(10,16)
# 使用装饰器装饰类
def zz(myclass):
class InnerClass:
def __init__(self,z=0):
self.z=z
self.wrapper=myclass()
def position(self):
self.wrapper.position()
print('z轴坐标：',self.z)
return InnerClass
@zz
class coordination:
def __init__(self,x=0,y=0):
self.x=x
self.y=y
def position(self):
print("x轴坐标：",self.x)
print("y轴坐标：",self.y)
if __name__=="__main__":
coor=coordination()
coor.position()
'''命名空间'''
'''涉及到全局变量和局部变量，这里必须要明确两个访问函数
local（）可以访问局部命名空间
globals()函数可以访问全局变量
'''
def func(i,str):
x=123321
print(locals())
func(1,"wangxiaowang")#包括了调用函数的复杂语法书写，简化了代码
'''闭包'''
def func(name):
def inner_func(age):
print("name",name,"\t","age",age)
return inner_func
bb=func("笑傲江湖")#调用func的时候就开始产生了一个闭包inner_func，里面有自己的name，就算函数执行完后，name依然会存在的
bb(19)
def delay_fun(x,y):
def caculator():#使用嵌套函数，实现延迟求和功能
return x+y
return caculator
if __name__=="__main__":
print("返回一个可以求和的函数，但是不去求和！")
msum=delay_fun(3,4)
print()
print("返回一个计算值！")
print(msum())
'''装饰器与闭包'''
def deco(func):
def _deco():
print("函数闭包实现......")
func()#这里才是调用了，所以此函数中只有该函数是实例化了，里面的闭包其实没有调用和打印
print("函数闭包实现中......")
return _deco#只是返回了它的值，并没有调用
@deco#f=deco(f)
def f():
print("使用装饰器实现中......")
if __name__=="__main__":
f()#知道第二次才返回_deco的值，也就是打印了，这个就是闭包的神奇之处。
'''使用闭包定义泛型函数'''
def fan(a,b):
def afan(x):
return a* x+b
return afan
if __name__=="__main__":
fan23=fan(2,3)
fan25=fan(2,5)
print("调用函数实现：",fan23(4))
print("调用函数熟悉：",fan25(6))
总结
学完Python的面向对象之后，我们发现它其实也不是想象中的那么难，我们要知道Java的基础语言就是基于类的叠加，所以大家学习Python还是要把基础打牢，这样才能真正的学以致用。后期我也会推出《初识Java之系列篇章》希望有兴趣的小伙伴继续关注小王，我们一起“快乐代码，精彩人生”。
后期我将继续推出Python编程的一些语法，比如文件操作，异常处理，多线程开发等，同时我也会设置一个专栏《初识爬虫之系列篇章》，到时候有兴趣的小伙伴，可以来看看。
好的，本期文章我们就到这里了，我们下期文章再会！