python 全栈开发笔记 4

反射

1.通过字符串的形式导入模块

2.通过字符串的形式，去模块中寻找指定函数并执行

'''
def f1():
    return 'F1'
 
def f2():
    return 'F2'
'''
#假设上面的是一个叫user的py文件里面的内容
 
#import user   # user不是一个字符串，是一个文件名，无法通过字符串的形式导入
DO=__import__('user') #通过字符串的形式导入模块，'user'是个字符串,实现了反射的第一个功能。
r=DO.f1()
print(r) #输出 F1
r=getattr(DO,'f1') #在模块DO中找到名字叫做f1的函数，括号中的f1是一个字符串，返回f1函数的地址
print(r())  # 输出F1，通过在r的后面加个括号来执行函数,r是一个函数地址，这就实现了反射的第二个功能。
#hasattr 判断模块中是否存在字符串形式的函数
#setattr(DO,'AGE',8) 给一个模块设置一个全局变量
#setattr(DO,'AGE',lambda a:a+1) 给一个模块设置一个函数，后面的是lambda表达式
#delattr  删除某一模块中的函数或者变量
# 总结：反射就是根据字符串的形式去对象（某个模块）中操作其成员，模块是对象其中的一种。

面向对象

如果函数写在类里面就叫做方法，类名后面加个括号就是创建一个对象，面向对象不是所有情况都适用。

self是一个形式参数，python内部传递，obj=Foo() 创建obj为Foo的一个实例,obj.fetch('bb'),调用Foo中的fetch方法，这个过程默认self=obj，是一个地址，创建对象时会首先执行类中的__init__方法，他有个特殊的方法叫做构造方法。

__del__解释器销毁对象时候自动调用，特殊的名字：析构方法。

封装：使用场景，当同一类型的方法具有相同的参数，直接封装在对象中，把类当作模板创建多个对象（对象内封装的数据可以不一样）

继承：派生类和基类都有，优先在派生类中找，python类中可以同时继承多个类，先是自己，再是从左到右继承。

多态：多种形态，python语言特性本身支持多态，扩展：重载（函数名相同，参数个数不相同，python不支持，重写：派生类中重新实现基类的方法。）

查找源码的过程（self.XXXX(),从底层开始找）

执行父类的构造方式：super(当前类，self).init()            父类.__init__(self,XXX)

快速判断类执行和对象执行，self,对象调用，无self，类调用。

class Provice:
    country='china'# 静态字段存在类中
    def __init__(self,name):
        self.Name=name# Name存在对象中
 
    @property#特性，加上这个,表示创建一个特性，将方法伪造成为了一个字段
    #特性方法不能再传任何参数，除了self，用来获取
    def end(self):
        temp='%s end' % self.Name
        print(temp)
    @end.setter #表示可以给end设置值，传给value并打印出来，用来设置，但end和上面的特性end必须名字一样。
    def end(self,value):
        print(value)
 
    def start(self):
        temp='%s start' % self.Name
        print(temp)
 
    def show(self):# 普通方法存在类中,但普通对象可通过指针调用
        print('输出地方')
        print(self.Name,Provice.country)# 访问静态字段时用类.静态字段访问，如果是
        #对象自己的成员，则用自己去访问，自己的对象.自己的成员，除了类中的方法。
 
    @classmethod  #类方法
    def xxoo(cls): #类方法必须要有一个cls参数，全称是class，通过类去访问，参数是当前类的类名
        print('xxoo')
        print(cls)    
 
    @staticmethod #只要用这个一装饰，下面的方法将变为静态方法，没有self
    #静态方法属于类，执行时，用类名加方法，不用传参数，对象也可以访问,但推荐用类进行访问。
    def Xo():#可以有任何参数，但调用时需要一一给它传递，只是不需要self了。
        print('xo')
     # 普通方法执行时必须先需要创建对象，但静态方法不需要创建对象就直接可以去执行。
 
henan=Provice('河南')
henan.show()
Provice.xxoo()
ret=Provice('HAHA')
ret.start()
ret.end # 调用特性方法时不需要在加括号，用来获取。
ret.end='浅浅'#去执行带有 @end.setter下面的end函数，可用来修改。

成员修饰符

前面加__(两个下划线)，则在外面拿不到，只能在类内部访问，在子类中也不能访问，但可以通过间接访问，通过方法。什么都不加是公有的，在外面可以访问。

在一个对象后面加括号会执行__call__方法。相当于在类后面加两个括号Foo()()会执行__call__方法。对象后面加[]会执行__getitem__方法。对象.__dict__获取对象中所有的字段。__doc__注释，print(对象)直接能输出结果是因为执行了类中的__str__方法。

断言一般用于测试

单例模式

当所有实例中封装的数据都相同时，用单例模式

#单例模式----
class ConnectionPool:
    __instance=False
    def __init__(self):
        #创建连接池需要用到的东西
        self.ip='1.1.1.1'
        self.port=3306
        self.pwd=''
        self.username='xxxx'
        self.conn_list=[1,2,3,4,5,6,7,8,9,10]#创建10个链接线
    @staticmethod
    def get_instance():
        if ConnectionPool.__instance:
            #如果以前创建过了，还返回以前那个，不会重新创建
            return ConnectionPool.__instance
        else:
            #创建一个对象并将对象赋值给静态字段__instance
            ConnectionPool.__instance=ConnectionPool()
            return ConnectionPool.__instance
 
    def get_connection(self):
        #获取连接
        import random
        r=random.randrange(1,11)#随机获取一个链接线
        return r
 
pool1=ConnectionPool.get_instance()
pool2=ConnectionPool.get_instance()
print(pool1,pool2)#输出结果一样，地址一样，说明只是一个对象，避免了重复创建，单例模式
#<__main__.ConnectionPool object at 0x000001EE554C9198>   <__main__.ConnectionPool object at 0x000001EE554C9198>

网络编程

socket基于TCP、IP(套接字) 客户端 服务端，所有的客户端都去连接服务端，服务端先运行起来，ip、port(端口)等待别人来链接

socketserver 并发处理多个客户端请求，使用：1、创建类，必须继承2、handle方法  3、server_forever

进程

优点：利用电脑的多核优势（能够同时进行多个操作）  缺点：浪费计算机的资源内存（重新开辟内存空间），进程不是越多越好，cpu个数=进程个数最好。

线程

优点：共享内存，IO操作时能够创造并发操作。缺点：抢占资源，线程也不是越多越好，具体案例具体分析，请求上下文切换耗时。

进程和线程目的：提高执行效率。

在计算机中执行任务的最小单元是线程。Io操作不利用cpu，IO密集型需要多线程，计算密集型需要用多进程

GIL 全局解释器锁

import threading
import time
def func1():
    print('')
def func2(a1,a2):
    time.sleep(1)
    func1()
    print('a1+a2=%d'%(a1+a2))
t1=threading.Thread(target=func2,args=(123,111,))#args传入的是一个元组,创建的是一个子线程
#子线程是由主线程创建的，这个程序从上开始执行,当遇到这行代码时，会创建一个子线程
t1.setDaemon(True)#设置主线程执行完之后等不等待子线程，默认是等待，改成True后将不等待，如果不等待，主线程将会
#执行完创建下面三个子线程后就执行完了，并不会等待子线程去执行func2函数
t1.start()#让创建的线程开始执行
#t1.join()#让这个线程不再并发执行，会等到这个线程执行完毕，再执行下面的内容，当传入参数时，会表示最多等几秒
t1.join(2) #下面的代码最多等这个线程2秒，如果没有执行完成，也会继续执行下面的内容，如果这个线程如果没有执行完，会再后台继续执行，但不会等着他
t2=threading.Thread(target=func2,args=(123,111,))#args传入的是一个元组,创建的是一个子线程
t2.start()#让创建的线程开始执行
t3=threading.Thread(target=func2,args=(123,111,))#args传入的是一个元组,创建的是一个子线程
t3.start()#让创建的线程开始执行

线程锁

python内部没有提供线程池，需要自定义   数据共享 m=Manger() dic=m.dict(),进程池python已经提供

上下文管理

#with open (xx)  as  ss  原理是用上下文管理来实现的。
import contextlib
@contextlib.contextmanager#用于上下文管理
def myopen(file_path,mode):
    f=open(file_path,mode,encoding='utf-8')
    try:
        yield f#执行到这一步会把f拿出来  赋给as后面的对象
    finally:
        f.close()
 
with myopen('XXX.txt','r') as file_obj:
    print(file_obj.readline())#执行任务，等所有的任务执行完成时，才执行finally后面的内容

css

1.首先找到那个标签，2.对那个标签进行操作