深浅拷贝
有时候，尤其是当你在处理可变对象时，你可能想要复制一个对象，然后对其做出一些改变而不希望影响原来的对象。这就是Python的copy所发挥作用的地方。
-
定义了当对你的类的实例调用copy.copy()时所产生的行为。copy.copy()返回了你的对象的一个浅拷贝——这意味着，当实例本身是一个新实例时，它的所有数据都被引用了——例如，当一个对象本身被复制了，它的数据仍然是被引用的（因此，对于浅拷贝中数据的更改仍然可能导致数据在原始对象的中的改变）。定义了当对你的类的实例调用copy.deepcopy()时所产生的行为。copy.deepcopy()返回了你的对象的一个深拷贝——对象和其数据都被拷贝了。memodict是对之前被拷贝的对象的一个缓存——这优化了拷贝过程并且阻止了对递归数据结构拷贝时的无限递归。当你想要进行对一个单独的属性进行深拷贝时，调用copy.deepcopy()，并以memodict为第一个参数。
思路一：利用切片操作和工厂方法list方法拷贝就叫浅拷贝，只是拷贝了最外围的对象本身，内部的元素都只是拷贝了一个引用而已。
思路二：利用copy中的deepcopy方法进行拷贝就叫做深拷贝，外围和内部元素都进行了拷贝对象本身，而不是引用。
但是对于数字，字符串和其他原子类型对象等，没有被拷贝的说法，即便是用深拷贝，查看id的话也是一样的，如果对其重新赋值，也只是新创建一个对象，替换掉旧的而已。
常用模块
getpass模块
pwd = getpass.getpass("请输入密码：") #输入密码不可见
yh = getpass.getuser() #显示当前登录系统用户名;
getpass.getpass([prompt[, stream]])
提示用户输入一段密码，参数 prompt 用于提示用户开始输入，默认为'Password: '。在 Unix 上，该提示符被写入到类文件对象流中。
参数 stream 默认为控制终端 (/dev/tty) 或入过前者不可用时为 sys.stderr (该参数在 Windows 上无效)。
如果无回显输入不可用，getpass() 回退并向流 stream 中输出一个警告消息，
从 sys.stdin 中读取并抛出异常 GetPassWarning。
适用于： Macintosh, Unix, Windows. *注：如果你在 IDLE 中调用getpass()，输入可能会在你启动 IDLE 的终端中而不是在 IDLE 窗口中完成 1 >>> import getpass
2 >>> p=getpass.getpass('input your password')
3 input your password
4 >>> print(p)
5 aaa exception getpass.GetPassWarning
Python内置异常 UserWarning 的子类，当密码输入可能被回显时抛出。 getpass.getuser()
返回用户的登录名，适用于：Unix, Windows 该函数依次检测环境变量 LOGNAME、USER、LNAME 和 USERNAME，返回其中第一个非空的值。
如果这些变量都没有被设置，支持 pwd 模块的系统会返回密码数据库中的登录名，否则抛出异常。 注，此模块在pycharm中无法使用。
os模块，
* os，os模块对通用的操作系统服务提供了可移植的（portable）的接口。os可以认为是nt和posix的抽象。nt提供windows的服务接口，posix提供UNIX（Linux，mac）的服务接口。
* os.path，os.path模块以可移植的方式来处理路径相关的操作。
os.getcwd() 获取当前工作目录，即当前python脚本工作的目录路径
os.chdir("dirname") 改变当前脚本工作目录；相当于shell下cd
os.curdir 返回当前目录: ('.')
os.pardir 获取当前目录的父目录字符串名：('..')
os.makedirs('dirname1/dirname2') 可生成多层递归目录
os.removedirs('dirname1') 若目录为空，则删除，并递归到上一级目录，如若也为空，则删除，依此类推
os.mkdir('dirname') 生成单级目录；相当于shell中mkdir dirname
os.rmdir('dirname') 删除单级空目录，若目录不为空则无法删除，报错；相当于shell中rmdir dirname
os.listdir('dirname') 列出指定目录下的所有文件和子目录，包括隐藏文件，并以列表方式打印
os.remove() 删除一个文件
os.rename("oldname","newname") 重命名文件/目录
os.stat('path/filename') 获取文件/目录信息
os.sep 输出操作系统特定的路径分隔符，win下为"\\",Linux下为"/"
os.linesep 输出当前平台使用的行终止符，win下为"\t\n",Linux下为"\n"
os.pathsep 输出用于分割文件路径的字符串
os.name 输出字符串指示当前使用平台。win->'nt'; Linux->'posix'
os.system("bash command") 运行shell命令，直接显示
os.environ 获取系统环境变量
os.path.abspath(path) 返回path规范化的绝对路径
os.path.split(path) 将path分割成目录和文件名二元组返回
os.path.dirname(path) 返回path的目录。其实就是os.path.split(path)的第一个元素
os.path.basename(path) 返回path最后的文件名。如何path以／或\结尾，那么就会返回空值。即os.path.split(path)的第二个元素
os.path.exists(path) 如果path存在，返回True；如果path不存在，返回False
os.path.isabs(path) 如果path是绝对路径，返回True
os.path.isfile(path) 如果path是一个存在的文件，返回True。否则返回False
os.path.isdir(path) 如果path是一个存在的目录，则返回True。否则返回False
os.path.join(path1[, path2[, ...]]) 将多个路径组合后返回，第一个绝对路径之前的参数将被忽略
os.path.getatime(path) 返回path所指向的文件或者目录的最后存取时间
os.path.getmtime(path) 返回path所指向的文件或者目录的最后修改时间
sys 模块，sys模块包含了跟python解析器和环境相关的变量和函数。
sys.argv 命令行参数List，第一个元素是程序本身路径
sys.exit(n) 退出程序，正常退出时exit(0)
sys.version 获取Python解释程序的版本信息
sys.path 返回模块的搜索路径，初始化时使用PYTHONPATH环境变量的值
sys.platform 返回操作系统平台名称
sys.stdout.write('please:')
val = sys.stdin.readline()[:-1]
subprocess 模块：* 执行系统命令，subprocess模块包含了函数和对象来统一创建新进程，控制新进程的输入输出流，处理进程的返回。
import subprocess
subprocess.call("ping", shell=True) #执行命令，返回状态码
subprocess.check_call("ipconfig", shell=True)#执行命令，如果执行状态码是 0 ，则返回0，否则抛异常
subprocess.check_output("ipconfig", shell=True)#执行命令，如果状态码是 0 ，则返回执行结果，否则抛异常
subprocess.Popen("mkdir t2", shell=True)
shutil\shelve\itertools 模块
shutil.make_archive(base_name, format,...)
创建压缩包并返回文件路径，例如：zip、tar
base_name： 压缩包的文件名，也可以是压缩包的路径。只是文件名时，则保存至当前目录，否则保存至指定路径，
如：www =>保存至当前路径
如：/Users/wupeiqi/www =>保存至/Users/wupeiqi/
format： 压缩包种类，“zip”, “tar”, “bztar”，“gztar”
root_dir： 要压缩的文件夹路径（默认当前目录）
owner： 用户，默认当前用户
group： 组，默认当前组
logger： 用于记录日志，通常是logging.Logger对象
#将 /Users/wupeiqi/Downloads/test 下的文件打包放置当前程序目录
import shutil
ret = shutil.make_archive("wwwwwwwwww", 'gztar', root_dir='/Users/wupeiqi/Downloads/test')
#将 /mnt下的文件打包放置 /tmp目录
import shutil
ret = shutil.make_archive("/tmp/www", 'gztar', root_dir='/mnt') #2.6用不了，2.7或许可以
类似于高级API，而且主要强大之处在于其对文件的复制与删除操作更是比较支持好。
相关API介绍
copyfile(src, dst)
从源src复制到dst中去。当然前提是目标地址是具备可写权限。抛出的异常信息为
IOException. 如果当前的dst已存在的话就会被覆盖掉。
copyfile( src, dst) 从源src复制到dst中去。当然前提是目标地址是具备可写权限。抛出的异常信息为IOException. 如果当前的dst已存在的话就会被覆盖掉
copymode( src, dst) 只是会复制其权限其他的东西是不会被复制的
copystat( src, dst) 复制权限、最后访问时间、最后修改时间
copy( src, dst) 复制一个文件到一个文件或一个目录
copy2( src, dst) 在copy上的基础上再复制文件最后访问时间与修改时间也复制过来了，类似于cp –p的东西
copy2( src, dst) 如果两个位置的文件系统是一样的话相当于是rename操作，只是改名；如果是不在相同的文件系统的话就是做move操作
copytree(olddir,newdir,True/Flase) 把olddir拷贝一份newdir，如果第3个参数是True，则复制目录时将保持文件夹下的符号连接，如果第3个参数是False，则将在复制的目录下生成物理副本来替代符号连接
shutil.rmtree("te") 删除一个目录
import shutil
shutil.copyfile('f:/temp.txt', 'f:/os.txt') #复制文件
shutil.copytree('f:/temp', 'f:/os') #复制目录
# ######## zip的用法 ########
shutil 对压缩包的处理是调用 ZipFile 和 TarFile 两个模块来进行的，详细：
import zipfile
# 压缩
z = zipfile.ZipFile('laxi.zip', 'w')
z.write('a.log') #压缩包写入a.log
z.write('data.data') #写入data文件
z.close()
# 解压
z = zipfile.ZipFile('laxi.zip', 'r')
z.extractall()
z.close()
hashlib 模块:用于加密相关的操作，代替了md5模块和sha模块，主要提供 SHA1, SHA224, SHA256, SHA384, SHA512 ，MD5 算法
import hashlib
m = hashlib.md5()
m.update(b"Nobody inspects the spammish repetition") #参数必须是byte类型，否则报Unicode-objects must be encoded before hashing错误
md5value=m.hexdigest()
print(md5value) #bb649c83dd1ea5c9d9dec9a18df0ffe9 ############################################## import hashlib
data = '我是'
m = hashlib.md5(data.encode(encoding='gb2312'))
print(m.hexdigest()) ############################################## import hmac
h = hmac.new(b'ccccccc') #自定义key
h.update(b'hellowo') #对内容加密
print( h.hexdigest())
logging日志模块， logging模块灵活方便地对应用程序记录events，errors，warnings，和debuging 信息。这些log信息可以被收集，过滤，写到文件或系统log，甚至通过网络发送到远程的机器上。
很多程序都有记录日志的需求，并且日志中包含的信息即有正常的程序访问日志，还可能有错误、警告等信息输出，python的logging模块提供了标准的日志接口，你可以通过它存储各种格式的日志，logging的日志可以分为 debug(), info(), warning(), error() and critical() 5个级别，下面我们看一下怎么用。
import logging
logging.warning("user [admin] attempted wrong password more than 3 times")
logging.critical("server is down")
#输出
WARNING:root:user [admin] attempted wrong password more than 3 times
CRITICAL:root:server is down
看一下这几个日志级别分别代表什么意思
| Level | When it’s used |
|---|---|
DEBUG |
Detailed information, typically of interest only when diagnosing problems. |
INFO |
Confirmation that things are working as expected. |
WARNING |
An indication that something unexpected happened, or indicative of some problem in the near future (e.g. ‘disk space low’). The software is still working as expected. |
ERROR |
Due to a more serious problem, the software has not been able to perform some function. |
CRITICAL |
A serious error, indicating that the program itself may be unable to continue running. |
把日志写到文件里
import logging logging.basicConfig(filename='example.log', level=logging.INFO,format='%(asctime)s %(message)s', datefmt='%m/%d/%Y %I:%M:%S %p') #level=loggin.INFO意思是，把日志纪录级别设置为INFO，也就是说，只有比日志是INFO或比INFO级别更高的日志才会被纪录到文件里，
logging.debug('This message should go to the log file') #在这个例子， 第一条日志是不会被纪录的，如果希望纪录debug的日志，那把日志级别改成DEBUG就行了。
logging.info('So should this')
logging.warning('And this, too')
日志格式
|
%(name)s |
Logger的名字 |
|
%(levelno)s |
数字形式的日志级别 |
|
%(levelname)s |
文本形式的日志级别 |
|
%(pathname)s |
调用日志输出函数的模块的完整路径名，可能没有 |
|
%(filename)s |
调用日志输出函数的模块的文件名 |
|
%(module)s |
调用日志输出函数的模块名 |
|
%(funcName)s |
调用日志输出函数的函数名 |
|
%(lineno)d |
调用日志输出函数的语句所在的代码行 |
|
%(created)f |
当前时间，用UNIX标准的表示时间的浮 点数表示 |
|
%(relativeCreated)d |
输出日志信息时的，自Logger创建以 来的毫秒数 |
|
%(asctime)s |
字符串形式的当前时间。默认格式是 “2003-07-08 16:49:45,896”。逗号后面的是毫秒 |
|
%(thread)d |
线程ID。可能没有 |
|
%(threadName)s |
线程名。可能没有 |
|
%(process)d |
进程ID。可能没有 |
|
%(message)s |
用户输出的消息 |
Python 使用logging模块记录日志涉及四个主要类，使用官方文档中的概括最为合适：
logger提供了应用程序可以直接使用的接口；
handler将(logger创建的)日志记录发送到合适的目的输出；
filter提供了细度设备来决定输出哪条日志记录；
formatter决定日志记录的最终输出格式。
logger
每个程序在输出信息之前都要获得一个Logger。Logger通常对应了程序的模块名，比如聊天工具的图形界面模块可以这样获得它的Logger：
LOG=logging.getLogger(”chat.gui”)
而核心模块可以这样：
LOG=logging.getLogger(”chat.kernel”) Logger.setLevel(lel):指定最低的日志级别，低于lel的级别将被忽略。debug是最低的内置级别，critical为最高
Logger.addFilter(filt)、Logger.removeFilter(filt):添加或删除指定的filter
Logger.addHandler(hdlr)、Logger.removeHandler(hdlr)：增加或删除指定的handler
Logger.debug()、Logger.info()、Logger.warning()、Logger.error()、Logger.critical()：可以设置的日志级别 handler handler对象负责发送相关的信息到指定目的地。Python的日志系统有多种Handler可以使用。有些Handler可以把信息输出到控制台，有些Logger可以把信息输出到文件，还有些 Handler可以把信息发送到网络上。如果觉得不够用，还可以编写自己的Handler。可以通过addHandler()方法添加多个多handler
Handler.setLevel(lel):指定被处理的信息级别，低于lel级别的信息将被忽略
Handler.setFormatter()：给这个handler选择一个格式
Handler.addFilter(filt)、Handler.removeFilter(filt)：新增或删除一个filter对象 每个Logger可以附加多个Handler。接下来我们就来介绍一些常用的Handler：
1) logging.StreamHandler
使用这个Handler可以向类似与sys.stdout或者sys.stderr的任何文件对象(file object)输出信息。它的构造函数是：
StreamHandler([strm])
其中strm参数是一个文件对象。默认是sys.stderr 2) logging.FileHandler
和StreamHandler类似，用于向一个文件输出日志信息。不过FileHandler会帮你打开这个文件。它的构造函数是：
FileHandler(filename[,mode])
filename是文件名，必须指定一个文件名。
mode是文件的打开方式。参见Python内置函数open()的用法。默认是’a'，即添加到文件末尾。 3) logging.handlers.RotatingFileHandler
这个Handler类似于上面的FileHandler，但是它可以管理文件大小。当文件达到一定大小之后，它会自动将当前日志文件改名，然后创建 一个新的同名日志文件继续输出。比如日志文件是chat.log。当chat.log达到指定的大小之后，RotatingFileHandler自动把 文件改名为chat.log.1。不过，如果chat.log.1已经存在，会先把chat.log.1重命名为chat.log.2。。。最后重新创建 chat.log，继续输出日志信息。它的构造函数是：
RotatingFileHandler( filename[, mode[, maxBytes[, backupCount]]])
其中filename和mode两个参数和FileHandler一样。
maxBytes用于指定日志文件的最大文件大小。如果maxBytes为0，意味着日志文件可以无限大，这时上面描述的重命名过程就不会发生。
backupCount用于指定保留的备份文件的个数。比如，如果指定为2，当上面描述的重命名过程发生时，原有的chat.log.2并不会被更名，而是被删除。 4) logging.handlers.TimedRotatingFileHandler
这个Handler和RotatingFileHandler类似，不过，它没有通过判断文件大小来决定何时重新创建日志文件，而是间隔一定时间就 自动创建新的日志文件。重命名的过程与RotatingFileHandler类似，不过新的文件不是附加数字，而是当前时间。它的构造函数是：
TimedRotatingFileHandler( filename [,when [,interval [,backupCount]]])
其中filename参数和backupCount参数和RotatingFileHandler具有相同的意义。
interval是时间间隔。
when参数是一个字符串。表示时间间隔的单位，不区分大小写。它有以下取值：
S 秒
M 分
H 小时
D 天
W 每星期（interval==0时代表星期一）
midnight 每天凌晨
import logging #create logger
logger = logging.getLogger('TEST-LOG')
logger.setLevel(logging.DEBUG) # create console handler and set level to debug
ch = logging.StreamHandler()
ch.setLevel(logging.DEBUG) # create file handler and set level to warning
fh = logging.FileHandler("access.log")
fh.setLevel(logging.WARNING)
# create formatter
formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s') # add formatter to ch and fh
ch.setFormatter(formatter)
fh.setFormatter(formatter) # add ch and fh to logger
logger.addHandler(ch)
logger.addHandler(fh) # 'application' code
logger.debug('debug message')
logger.info('info message')
logger.warn('warn message')
logger.error('error message')
logger.critical('critical message')
代码
import logging from logging import handlers logger = logging.getLogger(__name__) log_file = "timelog.log"
#fh = handlers.RotatingFileHandler(filename=log_file,maxBytes=10,backupCount=3)
fh = handlers.TimedRotatingFileHandler(filename=log_file,when="S",interval=5,backupCount=3) formatter = logging.Formatter('%(asctime)s %(module)s:%(lineno)d %(message)s') fh.setFormatter(formatter) logger.addHandler(fh) logger.warning("test1")
logger.warning("test12")
logger.warning("test13")
logger.warning("test14")
文件自动截断例子
time\datetime\traceback模块
三种表示主式：
1、时间戳 1970年1月1日后的秒
2、元组包含了：年、日、星期等...time.struct_time
3、格式化的字符串 2014-11-11 11:11 print time.time()
* time，time模块提供了各种时间相关的函数。常用的time.sleep().
import time
# 时间戳形式存在
print (time.time())
print(time.mktime(time.localtime())) #print (time.localtime()) # 元组形式存在
print (time.gmtime()) #可加时间戳参数
print (time.localtime()) #可加时间戳参数
print (time.strptime('2014-11-11','%Y-%m-%d')) #字符串形式转换成元组形式 # 字符串形式存在
print (time.strftime('%Y-%m-%d')) #默认当前时间，必须记住，工作中用得最多
print (time.strftime('%Y-%m-%d',time.localtime())) #默认当前时间
print (time.asctime())
print (time.asctime(time.localtime()))
print (time.ctime(time.time())) # 时间的三种表示方式演示
import time
print (time.time()) #秒，时间戳的方式,1488459426.7593124
print (time.gmtime())#元组方式，time.struct_time(tm_year=2017, tm_mon=3, tm_mday=2, tm_hour=12, tm_min=57, tm_sec=6, tm_wday=3, tm_yday=61, tm_isdst=0)
print (time.strftime('%Y-%m-%d %H:%M:%S'))#字符串方式，2017-03-02 20:57:06
datetime类定义的类属性与方法：
- datetime.min、datetime.max：datetime所能表示的最小值与最大值；
- datetime.resolution：datetime最小单位；
- datetime.today()：返回一个表示当前本地时间的datetime对象；
- datetime.now([tz])：返回一个表示当前本地时间的datetime对象，如果提供了参数tz，则获取tz参数所指时区的本地时间；
- datetime.utcnow()：返回一个当前utc时间的datetime对象；
- datetime.fromtimestamp(timestamp[, tz])：根据时间戮创建一个datetime对象，参数tz指定时区信息；
- datetime.utcfromtimestamp(timestamp)：根据时间戮创建一个datetime对象；
- datetime.combine(date, time)：根据date和time，创建一个datetime对象；
- datetime.strptime(date_string, format)：将格式字符串转换为datetime对象；
from datetime import *
import time print('datetime.max:', datetime.max)
print('datetime.min:', datetime.min)
print('datetime.resolution:', datetime.resolution)
print('today():', datetime.today())
print('now():', datetime.now())
print('utcnow():', datetime.utcnow())
print('fromtimestamp(tmstmp):', datetime.fromtimestamp(time.time()))
print('utcfromtimestamp(tmstmp):', datetime.utcfromtimestamp(time.time()) ) 输出结果：
datetime.max: 9999-12-31 23:59:59.999999
datetime.min: 0001-01-01 00:00:00
datetime.resolution: 0:00:00.000001
today(): 2017-03-02 21:22:09.304740
now(): 2017-03-02 21:22:09.304739
utcnow(): 2017-03-02 13:22:09.304739
fromtimestamp(tmstmp): 2017-03-02 21:22:09.304740
utcfromtimestamp(tmstmp): 2017-03-02 13:22:09.304740
json\pickle\模块
- json，用于字符串 和 python数据类型间进行转换
- pickle，用于python特有的类型 和 python的数据类型间进行转换
json:
dumps: 将对象序列化
dump: 将对象序列化并保存到文件
loads: 将序列化字符串反序列化
load: 将序列化字符串从文件读取并反序列化 pickle:基本上和json一样，pickle： pickle模块被用来序列化python的对象到bytes流，从而适合存储到文件，网络传输，或数据库存储。
（pickle的过程也被称serializing,marshalling或者flattening，pickle同时可以用来将bytes流反序列化为python的对象）。 那pickle和json有什么区别呢？
在上面两段代码中，pickle写入和读取文件时，用的是 ‘b’模式，而json没有。
json是可以在不同语言之间交换数据的，而pickle只在python之间使用。
json只能序列化最基本的数据类型，而pickle可以序列化所有的数据类型，包括类，函数都可以序列化。
import json
data = {'k1':123, 'k2':123}
j_dumps = json.dumps(data)
print(j_dumps,type(j_dumps))
j_loads = json.loads(j_dumps)
print(j_loads,type(j_loads)) #打开文件，然后将data写入
with open('data.txt', 'w') as f:
json.dump(data, f)
#同样读取的时候也需要打开文件
with open('data.txt', 'r') as f:
data_1 = json.load(f)
print(type(data_1) ) ####################################### import pickle
data = {'k1':123, 'k2':123}
p_dumps = pickle.dumps(data)
print(p_dumps,type(p_dumps))
p_loads = pickle.loads(p_dumps)
print(p_loads,type(p_loads)) #打开文件，然后将data写入
with open('data.txt', 'wb') as f:
pickle.dump(data, f)
#同样读取的时候也需要打开文件
with open('data.txt', 'rb') as f:
data_1 = pickle.load(f)
print(type(data_1) )
re 正则模块
'.' 默认匹配除\n之外的任意一个字符，若指定flag DOTALL,则匹配任意字符，包括换行
'^' 匹配字符开头，若指定flags MULTILINE,这种也可以匹配上(r"^a","\nabc\neee",flags=re.MULTILINE)
'$' 匹配字符结尾，或e.search("foo$","bfoo\nsdfsf",flags=re.MULTILINE).group()也可以
'*' 匹配*号前的字符0次或多次，re.findall("ab*","cabb3abcbbac") 结果为['abb', 'ab', 'a']
'+' 匹配前一个字符1次或多次，re.findall("ab+","ab+cd+abb+bba") 结果['ab', 'abb']
'?' 匹配前一个字符1次或0次
'{m}' 匹配前一个字符m次
'{n,m}' 匹配前一个字符n到m次，re.findall("ab{1,3}","abb abc abbcbbb") 结果'abb', 'ab', 'abb']
'|' 匹配|左或|右的字符，re.search("abc|ABC","ABCBabcCD").group() 结果'ABC'
'(...)' 分组匹配，re.search("(abc){2}a(123|456)c", "abcabca456c").group() 结果 abcabca456c '\A' 只从字符开头匹配，re.search("\Aabc","alexabc") 是匹配不到的
'\Z' 匹配字符结尾，同$
'\d' 匹配数字0-9
'\D' 匹配非数字
'\w' 匹配[A-Za-z0-9]
'\W' 匹配非[A-Za-z0-9]
's' 匹配空白字符、\t、\n、\r , re.search("\s+","ab\tc1\n3").group() 结果 '\t' '(?P<name>...)' 分组匹配 re.search("(?P<province>[0-9]{4})(?P<city>[0-9]{2})(?P<birthday>[0-9]{4})","371481199306143242").groupdict("city") 结果{'province': '3714', 'city': '81', 'birthday': '1993'}
最常用的匹配语法
re.match 从头开始匹配re.search 匹配包含re.findall 把所有匹配到的字符放到以列表中的元素返回re.splitall 以匹配到的字符当做列表分隔符re.sub 匹配字符并替换 反斜杠的困扰
与大多数编程语言相同，正则表达式里使用"\"作为转义字符，这就可能造成反斜杠困扰。假如你需要匹配文本中的字符"\"，那么使用编程语言表示的正则表达式里将需要4个反斜杠"\\\\"：前两个和后两个分别用于在编程语言里转义成反斜杠，转换成两个反斜杠后再在正则表达式里转义成一个反斜杠。Python里的原生字符串很好地解决了这个问题，这个例子中的正则表达式可以使用r"\\"表示。同样，匹配一个数字的"\\d"可以写成r"\d"。有了原生字符串，你再也不用担心是不是漏写了反斜杠，写出来的表达式也更直观。
仅需轻轻知道的几个匹配模式
re.I(re.IGNORECASE): 忽略大小写（括号内是完整写法，下同）
M(MULTILINE): 多行模式，改变'^'和'$'的行为（参见上图）
S(DOTALL): 点任意匹配模式，改变'.'的行为
内置函数
enumerate：遍历，返回序号和值
seq = ['one', 'two', 'three']
for i, element in enumerate(seq):
print(i,seq[i])
print(i,element)
filter和map函数：
def f1(a):
if a>22:
return True def f2(a):
if a>22:
return a+100 li = [11,22,33,44,55,66,77]
ret = filter(f1,li) #fliter(函数，可迭代的对象)
print(list(ret))
print(ret) result = map(f2,li) #fliter(函数，可迭代的对象)
print(list(result))
print(result) 输出结果：
[33, 44, 55, 66, 77]
<filter object at 0x000001BE9C03B198>
[None, None, 133, 144, 155, 166, 177]
<map object at 0x000001BE9C03B278>
#fliter() 将li中的每个值执行函数，将函数返回值为TRUE的添加到列表中
#map() 将li中的每个值执行函数，将函数返回值为TRUE的添加到列表中,返回值为FLASE的用NONE代替
关于计算的:
# abs() #求绝对值
abs(11)
# pow() #求X方，即幂的次数
pow(3,6)
# round() #返回浮点数x的四舍五入值,可以指定返回的小数点位数
round(1.5)
# divmod() #求商和余数(地板除)
divmod(5,3)
类型转换：
# int()
print(int(123.1))
# complex()
print(complex(12))
# float()
print(float(55.22))
# bool()
print(bool(0)) 输出结果：
123
(12+0j)
55.22
False
进制转换:
bin()#将十进制的数转换成二进制的数 oct()#将十进制的数转换成八进制的数 hex()#将十进制的数转换成十六进制的数 例子：
print(hex(10))
print(oct(10))
print(bin(255))
输出结果：
0xa
0o12
0b11111111
ASCII转换:
ord()#将ascii码转成整数
chr()#将整数转成ascii码
print(ord('A'))
print(chr(65))
输出结果：
65
A
数学函数:
import math math.sin() math.tan() math.cos()
随机数函数：
import random
random.uniform(1,10)#返回1-10间的一个浮点数
random.choice([1,2,3,4,5,6,7,8,9])#返回其中一个数
random.randint(50,60)# #返回一个整数
random.randrange(10,100,2)#从指定范围内，按指定基数递增的集合中 获取一个随机数。
判断函数:
******
格式函数：
#只有字符串才有这个属性，int没有
s_num = 'aba'
a = s_num.center(10,'*')#AttributeError: 'int' object has no attribute 'center'
b = s_num.ljust(10,'*')#AttributeError: 'int' object has no attribute 'ljust'
print(a,b) format() #这个方法会把字符串当作一个模版，通过传入的参数进行格式化。这个用来格式化的模版使用大括号({,})作为特殊字符
搜素函数:
num = '123as113f1a6f5a32f1sa5f1as3f51as23s1a5613b1351u35131f3a'
# count()
print(num.count('a'))
# find()
print(num.find(''))
# index()
print(num.index('u'))
# rfind()
print(num.rfind('a')) 输出结果：
8
2
46
54
替换函数:
基本用法：对象.replace(rgExp,replaceText,max)
其中，rgExp和replaceText是必须要有的，max是可选的参数，可以不加。
rgExp是指正则表达式模式或可用标志的正则表达式对象，也可以是 String 对象或文字；replaceText是一个String 对象或字符串文字；max是一个数字。
对于一个对象，在对象的每个rgExp都替换成replaceText，从左到右最多max次。
num = '123as113f1a6f5a32f1sa5f1as3f51as23s1a5613b1351u35131f3a'
new_num = num.replace('','*',3)
print(num)
print(new_num) 输出结果：
123as113f1a6f5a32f1sa5f1as3f51as23s1a5613b1351u35131f3a
*23as**3f1a6f5a32f1sa5f1as3f51as23s1a5613b1351u35131f3a
======================================================================================
str.expandtabs(tabsize=8)
参数:tabsize — 指定转换字符串中的 tab 符号(‘\t’)转为空格的字符数。
返回值:该方法返回字符串中的 tab 符号(‘\t’)转为空格后生成的新字符串。
实例
以下实例展示了expandtabs()方法的实例：
#!/usr/bin/python3 str = "this is\tstring example....wow!!!" print ("原始字符串: " + str)
print ("替换 \\t 符号: " + str.expandtabs())
print ("使用16个空格替换 \\t 符号: " + str.expandtabs(16)) 输出结果：
原始字符串: this is string example....wow!!!
替换 \t 符号: this is string example....wow!!!
使用16个空格替换 \t 符号: this is string example....wow!!!
拆分函数:
str = 'abc.' \
'123.def.456.ghi.789.jkl'
# partition('.')
#根据指定的分隔符将字符串进行分割。如果字符串包含指定的分隔符，
#则返回一个3元的元组，第一个为分隔符左边的子串，第二个为分隔符本身，第三个为分隔符右边的子串
print(str.partition('.'))#输出结果：('abc', '.', '123.def.456.ghi.789.jkl')
# split('.')#通过指定分隔符对字符串进行切片，如果参数num 有指定值，则仅分隔 num 个子字符串
print(str.split('.'))#输出结果：['abc', '123', 'def', '456', 'ghi', '789', 'jkl']
# splitlines()#照行('\r', '\r\n', \n')分隔，返回一个包含各行作为元素的列表，如果参数 keepends 为 False，不包含换行符，如果为 True，则保留换行符。
print(str.splitlines())#输出结果：['abc.123.def.456.ghi.789.jkl']
# # 剥离函数
# strip()#用于移除字符串头尾指定的字符（默认为空格）
# lstrip()#用于截掉字符串左边的空格或指定字符
# rstrip()##用于截掉字符串右边的空格或指定字符
#
str = '* abc.123.456.dff ' \
'safafsfa156165.saa,14 *'
print(str)
print(str.strip('*'))
print(str.lstrip('*'))
print(str.rstrip('*')) 输出结果：
* abc.123.456.dff safafsfa156165.saa,14 *
abc.123.456.dff safafsfa156165.saa,14
abc.123.456.dff safafsfa156165.saa,14 *
* abc.123.456.dff safafsfa156165.saa,14
len() #3.5中按字符计算，2.7中按字节计算
json() #变量里面的字符必须使用双引号