python 常用库

Sqlite3

---

1. 创建一个Connection对象用于表示一个db,当有多个connection同时访问db并且有一个进程在修改db时，db一直是被lock的，直到transaction被提交

   import sqlite3
   conn = sqlite3.connect('example.db')#如果要在RAM中创建db，可以使用特定名字:memory:

    
2. connect()的常用参数:
   • timeout参数指定连接等待多久然后抛出异常，默认是5秒.
   • isolation_level:设置如何开启tranction,默认遇到DML语句时打开transaction,遇到non-DML语句时提交transaction
   • cached_statements:本次connection可以在缓存中存放的语句数，默认为100
   • uri:boolean型，使用uri指定db,可以指定连接的option,如以只读方式打开db
     db = sqlite3.connect('file:path/to/database?mode=ro', uri=True)
3. 创建一个Cursor对象用于执行sql命令,要注意sql语句的安全，另外对于execute,executemany和executescript函数可以直接使用Connection对象调用，函数内会自动创建cursor，并返回cursor对象

   c=conn.cursor()
   # Never do this -- insecure! 
   
   symbol = 'RHAT' 
   c.execute("SELECT * FROM stocks WHERE symbol = '%s'" % symbol) 
   
   # Do this instead,注意元组中只有一个元素时后面要有逗号
   #sql语句中的替换符为? 
   
   t = ('RHAT',) 
   
   c.execute('SELECT * FROM stocks WHERE symbol=?', t) 
   
   print(c.fetchone()) 
   
   # Larger example that inserts many records at a time 
   
   purchases = [('2006-03-28', 'BUY', 'IBM', 1000, 45.00), 
   
   ('2006-04-05', 'BUY', 'MSFT', 1000, 72.00), 
   
   ('2006-04-06', 'SELL', 'IBM', 500, 53.00), 
   
   ] 
   
   c.executemany('INSERT INTO stocks VALUES (?,?,?,?,?)', purchases)

4. 如果使用execute执行完查询语句后，获取数据可以使用如下方法:
   • 将cursor当做一个iterator,使用for语句每次获取一行row数据
   • 使用fetchone(),每次获取一行row数据,最后返回None
   • 使用fetchall(),获取row的list,没有数据则返回None
5. 将sqlite不支持的python类型加到sqlite中,首先要将该类型转换成sqlite支持的类型，通常用str。具体方法有两种:
   • 实现类的__conform__方法

     import sqlite3
     
     class Point:
         def __init__(self, x, y):
             self.x, self.y = x, y
     
         def __conform__(self, protocol):
          #注意protocol
             if protocol is sqlite3.PrepareProtocol:
                 return "%f;%f" % (self.x, self.y)
     
     con = sqlite3.connect(":memory:")
     cur = con.cursor()
     
     p = Point(4.0, -3.2)
     cur.execute("select ?", (p,))
     print(cur.fetchone()[0])

     
     
   • 使用sqlite3.register_adapter为类注册一个adapter方法,将类型转换成str,sqlite3 module内部为python的内置类型datetime.date和datetime.datetime提供了adapter,将它们转换为iso。

     import sqlite3
     import datetime
     import time
     
     def adapt_datetime(ts):
         return time.mktime(ts.timetuple())
     
     sqlite3.register_adapter(datetime.datetime, adapt_datetime)
     con = sqlite3.connect(":memory:")
     cur = con.cursor()
     
     now = datetime.datetime.now()
     cur.execute("select ?", (now,))
     print(cur.fetchone()[0])
     

     
     还可以使用sqlite3.register_converter为类注册一个convert方法，将数据库中的值转换为python类型。为了使sqlite3知道从数据库中查询出的数据的实际类型需要设置sqlite.connect方法的detect_types参数，值有两个:
     • 通过declared type(隐式方法)
     • 通过列名(显示方法)

       import sqlite3
       
       class Point:
           def __init__(self, x, y):
               self.x, self.y = x, y
       
           def __repr__(self):
               return "(%f;%f)" % (self.x, self.y)
       
       def adapt_point(point):
           return ("%f;%f" % (point.x, point.y)).encode('ascii')
       
       def convert_point(s):
           x, y = list(map(float, s.split(b";")))
           return Point(x, y)
       
       # Register the adapter
       sqlite3.register_adapter(Point, adapt_point)
       
       # Register the converter
       sqlite3.register_converter("point", convert_point)
       
       p = Point(4.0, -3.2)
       
       #########################
       # 1) Using declared types
       con = sqlite3.connect(":memory:", detect_types=sqlite3.PARSE_DECLTYPES)
       cur = con.cursor()
       cur.execute("create table test(p point)")
       
       cur.execute("insert into test(p) values (?)", (p,))
       cur.execute("select p from test")
       print("with declared types:", cur.fetchone()[0])
       cur.close()
       con.close()
       
       #######################
       # 1) Using column names
       con = sqlite3.connect(":memory:", detect_types=sqlite3.PARSE_COLNAMES)
       cur = con.cursor()
       cur.execute("create table test(p)")
       
       cur.execute("insert into test(p) values (?)", (p,))
       cur.execute('select p as "p [point]" from test')
       print("with column names:", cur.fetchone()[0])
       cur.close()
       con.close()

6. class sqlite3.Row:表示一行数据，可以使用列名或者索引下标访问某列的值

threading-多线程

---

1. class threading.Thread(group,target,name,args,kwargs,*,daemon)构造函数中各个参数的含义:
   • group:保留供未来扩展,现在为None
   • target:callable object,被run方法调用，默认为None
   • name:线程名,默认格式是”Thread-N”
   • args:target的参数组成的tuple,默认是()
   • kwargs:target的参数组成的字典，默认是{}
   • daemon:指定线程是否是守护线程
2. 创建线程有两种方式:
   • 在Thread class的构造函数中传递一个callable object
   • 继承Thread class并重写run方法，继承类只能重写__init__和run方法。如果继承类重写了__init__,必须在其中显示调用基类Thread的__init__
3. 启动现成要调用Thread的start方法，is_alive方法可以判断现成是否alive，join方法则可以阻塞当前线程直到等待的线程结束
4. 线程同步对象:
   • class threading.Lock:线程锁,每次只能一个线程获得锁,类有两个主要方法:
     • acquire(blocking=True,timeout=-1):用于获取锁，成功则返回True，失败返回False.如果一个线程里两次获取锁就可能造成死锁
       • blocking:当为Ture时，如果锁已被其他线程占用，那么要获取锁的线程就会阻塞timeout时间，timeout后成功就返回True,失败就返回False,如果blocking为false，此时不能使用timeout参数，获取成功直接返回True，获取失败直接返回False
       • timeout:线程阻塞的时间,默认值为-1表示无限阻塞
     • release():释放锁，release()函数可以由任意线程执行,不必非得在获取锁的线程中释放,如果锁已经被释放了就会抛出RuntimeError异常
   • class threading.RLock:可重入锁,与Lock的区别是RLock锁可以多次执行acquire获取锁,但必须执行相同的release次数才能释放锁,另外release操作只能在获取锁的线程中释放
   • class threading.Condition(lock=None):条件变量同步,通常与一个锁关联,多个Condition需要共享一个锁时，可以传递一个Lock或RLock给构造函数,否则Contition会生成一个RLock锁,常用方法有:
     • acquire/release:调用关联锁的acquire/release方法
     • wait(timeout=None):释放关联的lock,然后阻塞知道被notify或者notify_all唤醒或者timeout超时,一旦被唤醒或者超时,它将尝试重新获得锁并返回.调用wait方法的线程之前必须已经获得了锁,否则会抛出RuntimeError异常
     • notify(n=1):通知n个在等待的线程轮流获取锁，调用notify的线程必须已经获得了锁,否则会抛出RuntimeError.注意notify函数并不释放锁,所以调用notify后，在wait的线程只是尝试获得锁，要等到调用notify的线程调用release后，尝试才能成功
     • notify_all():通知所有在等待的线程可以获取锁,所有线程回去轮流获得锁
   • class threading.Semaphore(value=1):信号量,用于保存一个计数,当计数为0时阻塞线程直到其他线程调用release使计数大于0,常用方法:
     • acquire(blocking=True,timeout=None):如果计数大于0则减少计数并返回。如果计数是0则阻塞当前线程直到其他线程调用release增加了计数或者timeout超时。如果有多个线程在阻塞,release会唤醒其中一个，唤醒的线程与阻塞线程的顺序无关.如果blocking=False,如果计数不大于0调用acquire则会立即返回
     • release:增加计数,计数的值可以超过最初的value值
   • class threading.BoundedSemaphore(value=1):BoundedSemaphore能保证计数不超过初始化的value，如果超过value，则会抛出ValueError异常
   • class threading.Event:同步事件,管理一个flag标志，常用方法:
     • set():设置flag为true,所有在等待的线程都将唤醒
     • is_set():判断flag是否为true
     • clear():设置flag为false,之后调用wait的线程都会阻塞直到set方法重新将flag设为true
     • wait(timeout=None):如果flag为true时调用wait会立即返回，如果flag为false，则会阻塞，timeout后则返回。只有当flag为true时wait方法返回true
   • class threading.Timer(interval,function,args=None,kwargs=None):等待interval时间后执行function,Timer是Thread的子类，常用方法有:
     • start():开始计时
     • cancel():停止timer，只有timer还在等待时有效
5. class local:用于管理线程局部数据，对于同一个local，每个线程会生成一个lcoal副本,线程无法访问其他线程设置的属性

   from threading import Thread,local
   data=local()
   data.name='local'
   def run():
       data.name='run'
       print(data.name)
   thread = Thread(target=run);
   thread.start()
   thread.join()
   print(data.name)

   
6. Lock,RLock,Condition,Semaphore和BoundedSemaphore都支持with语句

functools

---

1. functools.partial(func,*args,**keywords)函数:通过包装手法,允许我们”重新定义”函数签名,当函数的某个或多个参数值已经确定,可以使函数能用更少的参数进行调用.示例如下:

   from functools import partial
   int2 = partial(int, base=2) # 把base参数绑定在int2这个函数里
   int2('10') # 现在缺省参数base被设为2了,相当于int('10',2)

   partial函数的python实现如下:

   def partial(func, *args, **keywords):
       def newfunc(*fargs, **fkeywords):
           newkeywords = keywords.copy()
           newkeywords.update(fkeywords)
           return func(*(args + fargs), **newkeywords)
       newfunc.func = func
       newfunc.args = args
       newfunc.keywords = keywords
       return newfunc

2. functools.update_wrapper(wrapper, wrapped, assigned=WRAPPER_ASSIGNMENTS,updated=WRAPPER_UPDATES):通常用于装饰器函数且装饰器函数中返回一个包装了原始函数的函数的情况,因为这样原始函数的metadata(指__name__,__doct__等信息)就会变成封装函数的metadata.后两个参数的默认值是functools模块中定义的常量,如下:

   functools.WRAPPER_ASSIGNMENTS
   ('__module__', '__name__', '__qualname__', '__doc__', '__annotations__')
    functools.WRAPPER_UPDATES
   ('__dict__',)

   调用update_wrapper与不调用的区别,示例如下：

   def wrap(func):
       def call_it(*args, **kwargs):
           """wrap func: call_it"""
           print('before call')
           return func(*args, **kwargs)
       return call_it
   
   @wrap
   def hello():
       """say hello"""
       print('hello world')
   
   hello()
   print(hello.__name__)
   print(hello.__doc__)
   
   before call
   hello world
   call_it #__name__输出的是wrapper函数的名字
   wrap func: call_it #__doc__输出的是wrapper函数的doc

   from functools import update_wrapper
   def wrap2(func):
       def call_it(*args, **kwargs):
           """wrap func: call_it2"""
           print('before call')
           return func(*args, **kwargs)
       return update_wrapper(call_it, func)
   
   @wrap2
   def hello2():
       """test hello"""
       print('hello world2')
   
   hello2()
   print(hello2.__name__)
   print(hello2.__doc__)
   
   before call
   hello world2
   hello2 #__name__返回的是hello2的值
   test hello#__doc__返回的是hello2的值

3. functools.wraps(wrapped,assigned=WRAPPER_ASSIGNMENTS,updated=WRAPPER_UPDATES):在装饰器函数中定义wrapper函数时，通常用wraps做wrapper的装饰器，wraps函数相当于partial(update_wrapper,wrapped=wrapped,assigned=assigned,updated=updated)

   from functools import wraps
   def wrap3(func):
       @wraps(func)
       def call_it(*args, **kwargs):
           """wrap func: call_it2"""
           print('before call')
           return func(*args, **kwargs)
       return call_it
   
   @wrap3
   def hello3():
       """test hello 3"""
       print('hello world3')
   
   hello3()
   
   print(hello3.__name__)
   print(hello3.__doc__)
   
   before call
   hello world3
   hello3
   test hello 3

sys

---

1. sys module能够访问python解释器使用的变量以及与解释器交互的函数
2. sys module中常用的成员有:
   • sys.argv:传递给python script的命令行参数,argv[0]是script name. 如果使用-c参数将命令传递给python，则argv[0]值为’-c’
   • sys.executable:获取python解释器的路径，如果python不能获取路径将返回空字符串或者None
   • sys.exit([arg]):退出python，该函数会触发SystemExit异常,只能在主线程中调用,可选参数arg通常用于表示退出状态,0表示成功,非0则认为是异常退出.如果arg是其他类型(非整形),那么None相当于0,其他对象则会被输出到stderr并使exit code为1.如sys.exit('some error message')
   • sys.getdefaultencoding():返回当前默认的字符串编码，该编码是一种unicode编码实现,如utf-8
   • sys.getrecursionlimit():返回当前的recursion limit值，可以由setrecursionlimit()函数设置
   • sys.getwindowsversion():返回当前windows系统版本信息
   • sys.implementation:返回当前python解释器的信息
   • sys.modules:子典型,存储了已经加载的module,key是module name
   • sys.path:字符串list,指定了搜寻module的路径,包含PYTHONPATH的值。程序可以自由修改sys.path
   • sys.stdin,sys.stdout,sys.stderr:用于解释器标准输入,输出,错误输出的文件对象