初识Python之面向对象篇（下）

前面我们介绍了关于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)

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13

"""使用包"""
'''例如上述实验方法，我们在导入包的时候，可以有不同的方法，因为导入不同，所以调用也不同
所以，我们在调用的时候必须要看后面的是什么，比如import requests 这个时候我们要使用这个里面的功能
必须以 requests.get()方法,或者from requests import get方法，还有一系列的，所以我们在自己开发试验的时候必须
熟悉自己的方法，避免混淆
'''

‘’‘导入类’’’
‘’‘类的导入与模块相似’’’

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9

'''迭代器'''
'''迭代器的使用例如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)

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21

'''使用内置迭代器方法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))

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26

'''生成器'''
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()

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22

'''装饰器'''
'''装饰器可以解决我们在实际开发当中，减轻我们代码的重复率，提高效率'''
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病毒")

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22

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)

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14

# 使用装饰器装饰类
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()

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22

'''命名空间'''
'''涉及到全局变量和局部变量，这里必须要明确两个访问函数
local（）可以访问局部命名空间
globals()函数可以访问全局变量
'''
def func(i,str):
    x=123321
    print(locals())
func(1,"wangxiaowang")#包括了调用函数的复杂语法书写，简化了代码

 
 

 
 
1
2
3
4
5
6
7
8
9

'''闭包'''
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())

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18

'''装饰器与闭包'''
def deco(func):
    def _deco():
        print("函数闭包实现......")
        func()#这里才是调用了，所以此函数中只有该函数是实例化了，里面的闭包其实没有调用和打印
        print("函数闭包实现中......")
    return _deco#只是返回了它的值，并没有调用
@deco#f=deco(f)
def f():
    print("使用装饰器实现中......")
if __name__=="__main__":
    f()#知道第二次才返回_deco的值，也就是打印了，这个就是闭包的神奇之处。

 
 

 
 
1
2
3
4
5
6
7
8
9
10
11
12
13

'''使用闭包定义泛型函数'''

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))

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12

总结

学完Python的面向对象之后，我们发现它其实也不是想象中的那么难，我们要知道Java的基础语言就是基于类的叠加，所以大家学习Python还是要把基础打牢，这样才能真正的学以致用。后期我也会推出《初识Java之系列篇章》希望有兴趣的小伙伴继续关注小王，我们一起“快乐代码，精彩人生”。

后期我将继续推出Python编程的一些语法，比如文件操作，异常处理，多线程开发等，同时我也会设置一个专栏《初识爬虫之系列篇章》，到时候有兴趣的小伙伴，可以来看看。

好的，本期文章我们就到这里了，我们下期文章再会！