python 全栈开发笔记 4

‘‘‘
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  删除某一模块中的函数或者变量
# 总结：反射就是根据字符串的形式去对象（某个模块）中操作其成员，模块是对象其中的一种。

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函数，可用来修改。

#单例模式----
class ConnectionPool:
    __instance=False
    def __init__(self):
        #创建连接池需要用到的东西
        self.ip=‘1.1.1.1‘
        self.port=3306
        self.pwd=‘123123‘
        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>

import threading
import time
def func1():
    print(‘111‘)
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()#让创建的线程开始执行

#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后面的内容