python3标准库

下面的内建函数(built-in function)可用于序列(表，定值表，字符串):
len(s)         返回： 序列中包含元素的个数
min(s)         返回： 序列中最小的元素
max(s)         返回： 序列中最大的元素
all(s)         返回： True, 如果所有元素都为True的话
any(s)         返回： True, 如果任一元素为True的话

下面的内建函数(built-in function)可用于序列(表，定值表)，不改变序列本身:
sum(s)         返回：序列中所有元素的和
s.count(x)     返回： x在s中出现的次数
s.index(x)     返回： x在s中第一次出现的下标

下面方法只适用于表，会对原来的表产生影响:
l.extend(l2)        在表l的末尾添加表l2的所有元素
l.append(x)         在l的末尾附加x元素
l.sort()            对l中的元素排序
l.reverse()         将l中的元素逆序
l.pop()             返回：表l的最后一个元素，并在表l中删除该元素
del l[i]            删除该元素

下面是一些用于字符串的方法：
str.count(sub)       返回：sub在str中出现的次数
str.find(sub)        返回：从左开始，查找sub在str中第一次出现的位置。如果str中不包含sub，返回 -1
str.index(sub)       返回：从左开始，查找sub在str中第一次出现的位置。如果str中不包含sub，举出错误
str.rfind(sub)       返回：从右开始，查找sub在str中第一次出现的位置。如果str中不包含sub，返回 -1
str.rindex(sub)      返回：从右开始，查找sub在str中第一次出现的位置。如果str中不包含sub，举出错误
str.isalnum()        返回：True， 如果所有的字符都是字母或数字
str.isalpha()        返回：True，如果所有的字符都是字母
str.isdigit()        返回：True，如果所有的字符都是数字
str.istitle()        返回：True，如果所有的词的首字母都是大写
str.isspace()        返回：True，如果所有的字符都是空格
str.islower()        返回：True，如果所有的字符都是小写字母
str.isupper()        返回：True，如果所有的字符都是大写字母
str.split([sep, [max]])    返回：从左开始，以分割符(separator)将str分割为多个子字符串，总共分割max次。将所得的子字符串放在一个表中返回。
str.rsplit([sep, [max]])   返回：从右开始，以分割符(separator)，将str分割为多个子字符串，总共分割max次。将所得的子字符串放在一个表中返回
str.join(s)                返回：将s中的元素，以str为分割符，合并成为一个字符串。
str.strip([sub])           返回：去掉字符串开头和结尾的空格。也可以提供参数sub，去掉位于字符串开头和结尾的sub  
str.replace(sub, new_sub)  返回：用一个新的字符串new_sub替换str中的sub
str.capitalize()           返回：将str第一个字母大写
str.lower()                返回：将str全部字母改为小写
str.upper()                返回：将str全部字母改为大写
str.swapcase()             返回：将str大写字母改为小写，小写改为大写
str.title()                返回：将str的每个词(以空格分隔)的首字母大写
str.center(width)          返回：长度为width的字符串，将原字符串放入该字符串中心，其它空余位置为空格。
str.ljust(width)           返回：长度为width的字符串，将原字符串左对齐放入该字符串，其它空余位置为空格。
str.rjust(width)           返回：长度为width的字符串，将原字符串右对齐放入该字符串，其它空余位置为空格。

import re
m = re.search('[0-9]','abcd4ef')
print(m.group(0))

m = re.search(pattern, string)  # 搜索整个字符串，直到发现符合的子字符串。
m = re.match(pattern, string)   # 从头开始检查字符串是否符合正则表达式。必须从字符串的第一个字符开始就相符。

str = re.sub(pattern, replacement, string) 
# 在string中利用正则变换pattern进行搜索，对于搜索到的字符串，用另一字符串replacement替换。返回替换后的字符串。

re.split(pattern, string)    # 根据正则表达式分割字符串， 将分割后的所有子字符串放在一个表(list)中返回

re.findall(pattern, string)  # 根据正则表达式搜索字符串，将所有符合的子字符串放在一给表(list)中返回

#从结果中筛选想要的信息
m = re.search("output_(\d{4})", "output_1986.txt")
print(m.group(1))
m = re.search("output_(?P<year>\d{4})", "output_1986.txt")   #(?P<name>...) 为group命名
print(m.group("year"))

#time
import time

print(time.time())   # wall clock time, unit: second
print(time.clock())  # processor clock time, unit: second

print('start')
time.sleep(10)     # sleep for 10 seconds
print('wake up')

st = time.gmtime()      # 返回struct_time格式的UTC时间
st = time.localtime()   # 返回struct_time格式的当地时间, 当地时区根据系统环境决定。
s  = time.mktime(st)    # 将struct_time格式转换成wall clock time

#datatime
import datetime

t = datetime.datetime(2012,9,3,21,30)
print(t)

t_next = datetime.datetime(2012,9,5,23,30)
delta1 = datetime.timedelta(seconds = 600)   #时间间隔对象(timedelta)
delta2 = datetime.timedelta(weeks = 3)
print(t + delta1)
print(t + delta2)
print(t_next - t)

print(t > t_next)   #两个datetime对象进行比较

from datetime import datetime
format = "output-%Y-%m-%d-%H%M%S.txt" 
str    = "output-1997-12-23-030000.txt" 
t      = datetime.strptime(str, format)    #将特定格式的字符串转换为datetime对象

print(t_next.strftime(format)) #将datetime对象转换为特定格式的字符串

#os.path包  主要是处理路径字符串，提取出有用信息
import os.path

path = '/home/vamei/doc/file.txt'

print(os.path.basename(path))    # 查询路径中包含的文件名
print(os.path.dirname(path))     # 查询路径中包含的目录

info = os.path.split(path)       # 将路径分割成文件名和目录两个部分，放在一个表中返回
path2 = os.path.join('/', 'home', 'vamei', 'doc', 'file1.txt')  # 使用目录名和文件名构成一个路径字符串

p_list = [path, path2]
print(os.path.commonprefix(p_list))    # 查询多个路径的共同部分

os.path.normpath(path)   # 去除路径path中的冗余。比如'/home/vamei/../.'被转化为'/home'

print(os.path.exists(path))    # 查询文件是否存在

print(os.path.getsize(path))   # 查询文件大小
print(os.path.getatime(path))  # 查询文件上一次读取的时间
print(os.path.getmtime(path))  # 查询文件上一次修改的时间

print(os.path.isfile(path))    # 路径是否指向常规文件
print(os.path.isdir(path))     # 路径是否指向目录文件

#glob包  
import glob

print(glob.glob('/home/vamei/*'))  #找出/home/vamei下的所有文件

#math包

math.e   # 自然常数e
math.pi  # 圆周率pi

math.ceil(x)       # 对x向上取整，比如x=1.2，返回2
math.floor(x)      # 对x向下取整，比如x=1.2，返回1
math.pow(x,y)      # 指数运算，得到x的y次方
math.log(x)        # 对数，默认基底为e。可以使用base参数，来改变对数的基地。比如math.log(100,base=10)
math.sqrt(x)       # 平方根

#random包

random.choice(seq)   # 从序列的元素中随机挑选一个元素，比如random.choice(range(10))，从0到9中随机挑选一个整数。
random.sample(seq,k) # 从序列中随机挑选k个元素
random.shuffle(seq)  # 将序列的所有元素随机排序

random.random()          # 随机生成下一个符合均匀分布实数，它在[0,1)范围内。
random.uniform(a,b)      # 随机生成下一个符合均匀分布实数，它在[a,b]范围内。
random.gauss(mu,sigma)    # 随机生成符合高斯分布的随机数，mu,sigma为高斯分布的两个参数。
random.expovariate(lambd) # 随机生成符合指数分布的随机数，lambd为指数分布的参数。

from itertools import *

#无穷循环器
count(5, 2)     #从5开始的整数循环器，每次增加2，即5, 7, 9, 11, 13, 15 ...
cycle('abc')    #重复序列的元素，既a, b, c, a, b, c ...
repeat(1.2)     #重复1.2，构成无穷循环器，即1.2, 1.2, 1.2, ...
repeat(10, 5)   #重复10，共重复5次

#函数式工具
rlt = imap(pow, [1, 2, 3], [1, 2, 3])  #该函数与map()函数功能相似，只不过返回的不是序列，而是一个循环器  .  1**1, 2**2, 3**3的结果
starmap(pow, [(1, 1), (2, 2), (3, 3)]) # pow将依次作用于表的每个tuple。
ifilter(lambda x: x > 5, [2, 3, 5, 6, 7]  # ifilter函数与filter()函数类似，只是返回的是一个循环器,将lambda函数依次作用于每个元素，如果函数返回True，则收集原来的元素
ifilterfalse(lambda x: x > 5, [2, 3, 5, 6, 7]) # 收集返回False的元素
takewhile(lambda x: x < 5, [1, 3, 6, 7, 1]) #当函数返回True时，收集元素到循环器。一旦函数返回False，则停止
dropwhile(lambda x: x < 5, [1, 3, 6, 7, 1])  #当函数返回False时，跳过元素。一旦函数返回True，则开始收集剩下的所有元素到循环器

#组合工具
chain([1, 2, 3], [4, 5, 7])  # 连接两个循环器成为一个。1, 2, 3, 4, 5, 7
product('abc', [1, 2])   # 多个循环器集合的笛卡尔积
permutations('abc', 2)   # 从'abcd'中挑选两个元素，比如ab, bc, ... 将所有结果排序，返回为新的循环器。注意，组合分顺序，即ab, ba都返回。
combinations('abc', 2)   # 从'abcd'中挑选两个元素，比如ab, bc, ... 将所有结果排序，返回为新的循环器。注意，组合不分顺序，即ab, ba的话，只返回一个ab。
combinations_with_replacement('abc', 2) # 与上面类似，但允许两次选出的元素重复。即多了aa, bb, cc

#groupby()
#将key函数作用于原循环器的各个元素。根据key函数结果，将拥有相同函数结果的元素分到一个新的循环器。分组之前需要使用sorted()对原循环器的元素，根据key函数进行排序，让同组元素先在位置上靠拢。
def height_class(h):
    if h > 180:
        return "tall"
    elif h < 160:
        return "short"
    else:
        return "middle"
friends = [191, 158, 159, 165, 170, 177, 181, 182, 190]
friends = sorted(friends, key = height_class)
for m, n in groupby(friends, key = height_class):
    print(m)
    print(list(n))

#其它工具
compress('ABCD', [1, 1, 1, 0])  # 根据[1, 1, 1, 0]的真假值情况，选择第一个参数'ABCD'中的元素。A, B, C
islice()                        # 类似于slice()函数，只是返回的是一个循环器
izip()                          # 类似于zip()函数，只是返回的是一个循环器。

#Python自带一个轻量级的关系型数据库SQLite。Python标准库中的sqlite3提供该数据库的接口。SQLite的数据库是一个磁盘上的文件，如下面的test.db，因此整个数据库可以方便的移动或复制。test.db一开始不存在，所以SQLite将自动创建一个新文件。

import sqlite3
conn = sqlite3.connect("test.db")
c = conn.cursor()
c.execute('''CREATE TABLE category
      (id int primary key, sort int, name text)''')
c.execute('''CREATE TABLE book
      (id int primary key, 
       sort int, 
       name text, 
       price real, 
       category int,
       FOREIGN KEY (category) REFERENCES category(id))''')
conn.commit()
conn.close()

#插入数据
import sqlite3
conn = sqlite3.connect("test.db")
c    = conn.cursor()
books = [(1, 1, 'Cook Recipe', 3.12, 1),
            (2, 3, 'Python Intro', 17.5, 2),
            (3, 2, 'OS Intro', 13.6, 2),
           ]
c.execute("INSERT INTO category VALUES (1, 1, 'kitchen')")
c.execute("INSERT INTO category VALUES (?, ?, ?)", [(2, 2, 'computer')])
c.executemany('INSERT INTO book VALUES (?, ?, ?, ?, ?)', books)
conn.commit()
conn.close()

#查询
import sqlite3
conn = sqlite3.connect('test.db')
c = conn.cursor()
c.execute('SELECT name FROM category ORDER BY sort')
print(c.fetchone())
print(c.fetchone())
c.execute('SELECT * FROM book WHERE book.category=1')
print(c.fetchall())
for row in c.execute('SELECT name, price FROM book ORDER BY sort'):
    print(row)
conn.commit()
conn.close()

#更新与删除
import sqlite3
conn = sqlite3.connect("test.db")
c = conn.cursor()
c.execute('UPDATE book SET price=? WHERE id=?',(1000, 1))
c.execute('DELETE FROM book WHERE id=2')
conn.commit()
conn.close()