python全栈开发优势_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，类调用。

classProvice:

country='china'#静态字段存在类中

def __init__(self,name):

self.Name=name#Name存在对象中

@property#特性，加上这个,表示创建一个特性，将方法伪造成为了一个字段

#特性方法不能再传任何参数，除了self，用来获取

defend(self):

temp='%s end' %self.Nameprint(temp)

@end.setter#表示可以给end设置值，传给value并打印出来，用来设置，但end和上面的特性end必须名字一样。

defend(self,value):print(value)defstart(self):

temp='%s start' %self.Nameprint(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__方法。

断言一般用于测试

单例模式

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

#单例模式----

classConnectionPool:__instance=Falsedef __init__(self):#创建连接池需要用到的东西

self.ip='1.1.1.1'self.port=3306self.pwd='123123'self.username='xxxx'self.conn_list=[1,2,3,4,5,6,7,8,9,10]#创建10个链接线

@staticmethoddefget_instance():if ConnectionPool.__instance:#如果以前创建过了，还返回以前那个，不会重新创建

return ConnectionPool.__instance

else:#创建一个对象并将对象赋值给静态字段__instance

ConnectionPool.__instance=ConnectionPool()return ConnectionPool.__instance

defget_connection(self):#获取连接

importrandom

r=random.randrange(1,11)#随机获取一个链接线

returnr

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 全局解释器锁

importthreadingimporttimedeffunc1():print('111')deffunc2(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 原理是用上下文管理来实现的。

importcontextlib

@contextlib.contextmanager#用于上下文管理

defmyopen(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.对那个标签进行操作