深浅拷贝
有时候，尤其是当你在处理可变对象时，你可能想要复制一个对象，然后对其做出一些改变而不希望影响原来的对象。这就是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下为" ",Linux下为" " 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)
shutilshelveitertools 模块
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")
timedatetime raceback模块
三种表示主式：
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
jsonpickle模块
- 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 正则模块
'.' 默认匹配除
之外的任意一个字符，若指定flag DOTALL,则匹配任意字符，包括换行
'^' 匹配字符开头，若指定flags MULTILINE,这种也可以匹配上(r"^a","
abc
eee",flags=re.MULTILINE)
'$' 匹配字符结尾，或e.search("foo$","bfoo
sdfsf",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") 是匹配不到的
'' 匹配字符结尾，同$
'd' 匹配数字0-9
'D' 匹配非数字
'w' 匹配[A-Za-z0-9]
'W' 匹配非[A-Za-z0-9]
's' 匹配空白字符、 、
、
, re.search("s+","ab c1
3").group() 结果 ' '
'(?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('3')) # 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('1','*',3) print(num) print(new_num) 输出结果： 123as113f1a6f5a32f1sa5f1as3f51as23s1a5613b1351u35131f3a *23as**3f1a6f5a32f1sa5f1as3f51as23s1a5613b1351u35131f3a ====================================================================================== str.expandtabs(tabsize=8) 参数:tabsize — 指定转换字符串中的 tab 符号(‘ ’)转为空格的字符数。 返回值:该方法返回字符串中的 tab 符号(‘ ’)转为空格后生成的新字符串。 实例 以下实例展示了expandtabs()方法的实例： #!/usr/bin/python3 str = "this is string example....wow!!!" print ("原始字符串: " + str) print ("替换 \t 符号: " + str.expandtabs()) print ("使用16个空格替换 \t 符号: " + str.expandtabs(16)) 输出结果： 原始字符串: this is string example....wow!!! 替换 符号: this is string example....wow!!! 使用16个空格替换 符号: 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()#照行(' ', ' ', ')分隔，返回一个包含各行作为元素的列表，如果参数 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() #变量里面的字符必须使用双引号