python ssti进阶 python进阶之路

2018-9-15 17:12:08

这是python进阶总结!明天整理 python网络编程内容!day5.28 py网络编程

2018-9-15 17:14:47
python进阶总结:

1. python的私有化 
    1. 在python中 __ 相当于java中的private,外部不能直接调用,只能用set,get烦恼歌发

class Test(object):
    def __init__(self):
        self.__num = 100
    def setNum(self,newNum):
        self.__num = newNum
    def getNum(self):
        return  self.__num
    num = property(getNum,setNum)   #使⽤property升级getter和setter⽅法
t =Test()
print(t.getNum())
t.setNum(50)
print(t.getNum())
print("-"*50)
t.num = 200  #相当于调用了 t.setNum(200)
print(t.num) #相当于调用了  t.getNum()


2. 闭包 : 在一个函数内部又定义一个函数,内部函数调用外部函数的变量
             内部函数中对enclosing作用域的变量进行引用。

def test(number):
    print("--1--")
    def test_in(number2):
        print("---2--")
        print(number+number2)
    print("--3--")
    return test_in
 #变量接受内部返回的函数引用 然后就相当于个函数了
ret = test(100)
print("-"*50)
ret(1)

3. 装饰器:
    1.装饰器就是对闭包的使用；
    2.装饰器用来装饰函数；
    3.返回一个函数对象，被装饰的函数接收；
    4.被装饰函数标识符指向返回的函数对象
    多个装饰器,完成包裹数据

# 定义函数 :完成包裹数据
def makeBold(fn):
    def  wrapped():
        print("----------1----------")
        return "<b>"+ fn() + "<b>"
    return wrapped
# 定义函数:完成包裹数据
def makeItalic(fn):
    def  wrapped():
        print("----------2--------------")
        return "<i>" +fn() +"</i>"
    return wrapped

@makeBold            # test3 = makeBold(test3)
@makeItalic            # test3 = makeItalic(test3)
def test3():
    print("---------3-------------")
    return "hello world-3"
ret = test3()
print(ret)

# -----1---------
# ------2------
# ------3-------
# <b><i>hello world-3</i><b/>


4.关于装饰器的Demo
'''
@   python特有的
'''
# python不告诉你有重名函数
def test1():
    print("test1")
def test1():
    print("test2")
只要是名都可以被改,名字仅仅是引用

def w1(func):
    #定义一个闭包
    def inner():
        print("---正在验证权限---")
        func()
    return inner
@w1   #f1 = w1(f1)
#等价于给人一种感觉,在没有修改f1()的前提下完成验证,这就是装饰器
def f1():
    print("----f1---")
@w1
def f2():
    print("----f2----")

f1()
f2()
# 多个装饰器,定义函数,完成包裹数据
def makeBold(fn):
    def wrapped():
        print("---1--")
        return "<b>" +fn()+ "</b>"
    return wrapped
#定义函数:完成包裹数据
def makeItalic(fn):
    def wrapped():
        print("--2--")
        return "<i>" + fn() +"</i>"
    return wrapped
''' 装饰器什么时候进行装饰'''
只要python解释器执行到这行代码时候就已经装饰完了
@makeBold
@makeItalic
def test3():
    print("----3----")
    return "hello world-3"
ret = test3()
#在调用f1之前,已经进行装饰了
print(ret)
'''带参数的装饰器'''
def func(functionName):
    print("---func--1---")
    def func_in(*args,**kwargs):#如果a,b没有定义,那么会到导致16行的调用失败
        print("----func_in--1-")
        functionName(*args,**kwargs)#如果没有把a,b当做实参进行传递,那么会导致调用12行的函数失败
        print("---func_in--2-")
    print("----func-2-")
    return func_in
@func
def test(a,b,c):
    print("-----test-a=%d,b=%d,c=%c---"%(a,b,c))

@func
def test2(a,b,c,d):
    print("------test-a =%d,b=%d,c%d,d=%d----"%(d,b,c,d))

test(11,22,33)
test2(44,55,66,77)
'''装饰器对有返回值得函数'''
def func(functionName):
    print("--func_in--1------")
    def func_in():
        print("--func_in--1------")
        #保存返回的"haha"
        xxxx = functionName() #z增加了一个变量存方法引用就可以解决返回值问题
        print("-----func_in---2")
        return  xxxx
    print("--func_in--2------")
    return func_in
@func
def test():
    print("----test----")
    return  "haha"
ret = test()
print("test return value is%s"%ret)

5.LEGB原则
    python中使用LEGB的顺序来查找一个符号对应的对象
    locals ->enclosing function-> globals ->builtins
        1.locals: 当前所在命名空间 (如函数,模块), 函数的参数也属于命名空间内的变量
        enclosing: 外部嵌套函数的命名空间(闭包常见)
            def fun1():
                a = 10
                def  fun2():
                    # a 位于外部嵌套函数的命名空间
                    print(a)

        2.globals : 全局变量, 函数定义所在模块的命名空间
            a =1
            def fun():
            # 需要通过 global 指令来声明全局变量
            global a
            # 修改全局变量, 而不是创建一个新的 local 变量
            a =2

        3. builtins: 内部模块的命名空间
            python在启动的时候回自动为我们载入很多的内建的函数,类
            比如 dict, list ,type,print, 这些都位于 __builtin__模块中
            可以使用 dir(__builtin__)来查看
            这也是为什么我们在没有 import 任何模块的情况下
            就能使用这么多丰富的函数和功能

6. python动态添加属性和方法
'''
 既然给类添加⽅法，是使⽤ 类名.⽅法名 = xxxx ，
那么给对象添加⼀个⽅法 也是类似的 对象.⽅法名 = xxx

python动态添加属性以及方法
不用在程序大体变化情况下,实现改变功能
'''
import types
# 动态添加属性
class Person(object):
     def __init__(self,newName,newAge):
        self.name=  newName
        self.age = newAge
laowang = Person("老王",10000)
print(laowang.name)
print(laowang.age)
laowang.addr = "北京....." #对象添加属性
print(laowang.addr)
laozhao = Person("老赵",18)
# print(langzhao.addr)
# Person.num =100
#类添加属性
print(laozhao.num)

# 动态添加方法
class Person2(object):
    def __init__(self,newName,newAge):
        self.name = newName
        self.age = newAge
    def eat(self):
        print(".............%s正在吃"%self.name)

def run(self):
    print("------正在跑%s-------"%self.name)
p1 = Person2("p1",10)
p1.eat()
# 虽然p1对象中run属性已经指向了 def run这个函数,,,但是这句代码还不正确
#因为run属性指向的函数,是后来添加的,几 p1.run()的时候,并没有把p1挡做第
#1个参数,导致了第10行的函数调用的时候,出现缺少参数的问题

#把实例方法绑到了对象那个身上
p1.run = types.MethodType(run,p1)
p1.run()
#类方法,静态方法修改  其他的都是绑类身上 方法是给类添加的
@staticmethod
def test():
    print("------这是一个静态方法____")
Person2.test =test
Person2.test()
# 动态修改类方法
@classmethod
def printNum(cls):
    print("-------这是一个类方法-----")
Person2.printNum = printNum
Person2.printNum()

#__slots__的使用!
class Person3(object):
    # 只允许添加一下类型的属性,不能随便添加
    __slots__ = ("name","age")

p =Person3()
p.name ="老王"
p.age = 10


7. 生成器 : send()和next()
#send()使用
def test():
    i = 0
    while i<5:
        temp=  yield i  #这个地方为空  temp 不传入东西就是 None
        print(temp)
        i+=1
t =  test()
#先用__next()__运行一次 然后才能用send
t.__next__()
t.__next__()
#send可以传入参数 然后 temp = "haha
t.send("haha")

#yield多任务
#只要足够的快 三个任务同时运行
# 看上去同时执行的事情都是多任务
#协程,进程,线程
def test1():
    while True:
        print("---1---")
        yield None

def test2():
    while True:
        print("--2--")
        yield None

t1 = test1()
t2 = test2()
while True:
    t1.__next__()
    t2.__next__()
 
2018-9-15 18:05:14
day5.28  py网络编程