python中复制字符串的库函数是_人生苦短之我用Python篇（深浅拷贝、常用模块、内置函数）...

深浅拷贝

有时候，尤其是当你在处理可变对象时，你可能想要复制一个对象，然后对其做出一些改变而不希望影响原来的对象。这就是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 >>> importgetpass2 >>> p=getpass.getpass('input your password')3input your password4 >>> print(p)5aaa

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模块包含了函数和对象来统一创建新进程，控制新进程的输入输出流，处理进程的返回。

importsubprocess

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 下的文件打包放置当前程序目录

importshutil

ret= shutil.make_archive("wwwwwwwwww", 'gztar', root_dir='/Users/wupeiqi/Downloads/test')#将 /mnt下的文件打包放置 /tmp目录

importshutil

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") 删除一个目录importshutil

shutil.copyfile('f:/temp.txt', 'f:/os.txt') #复制文件

shutil.copytree('f:/temp', 'f:/os') #复制目录

######### zip的用法 ########

shutil 对压缩包的处理是调用 ZipFile 和 TarFile 两个模块来进行的，详细：importzipfile#压缩

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()

View Code

hashlib 模块:用于加密相关的操作，代替了md5模块和sha模块，主要提供 SHA1, SHA224, SHA256, SHA384, SHA512 ，MD5 算法

importhashlib

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

##############################################

importhashlib

data= '我是'm= hashlib.md5(data.encode(encoding='gb2312'))print(m.hexdigest())##############################################

importhmac

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

importlogging

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 3times

CRITICAL:root:serveris down

看一下这几个日志级别分别代表什么意思

LevelWhen 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.

把日志写到文件里

importlogging

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.stderr2) 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 每天凌晨

View Code

importlogging#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')

代码

importloggingfrom logging importhandlers

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().

importtime#时间戳形式存在

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()))#时间的三种表示方式演示

importtimeprint (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 *

importtimeprint('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.999999datetime.min:0001-01-01 00:00:00datetime.resolution: 0:00:00.000001today():2017-03-02 21:22:09.304740now():2017-03-02 21:22:09.304739utcnow():2017-03-02 13:22:09.304739fromtimestamp(tmstmp):2017-03-02 21:22:09.304740utcfromtimestamp(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可以序列化所有的数据类型，包括类，函数都可以序列化。

importjson

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) )#######################################

importpickle

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...)' 分组匹配 re.search("(?P[0-9]{4})(?P[0-9]{2})(?P[0-9]{4})","371481199306143242").groupdict("city") 结果{'province': '3714', 'city': '81', 'birthday': '1993'}

最常用的匹配语法

反斜杠的困扰

与大多数编程语言相同，正则表达式里使用"\"作为转义字符，这就可能造成反斜杠困扰。假如你需要匹配文本中的字符"\"，那么使用编程语言表示的正则表达式里将需要4个反斜杠"\\\\"：前两个和后两个分别用于在编程语言里转义成反斜杠，转换成两个反斜杠后再在正则表达式里转义成一个反斜杠。Python里的原生字符串很好地解决了这个问题，这个例子中的正则表达式可以使用r"\\"表示。同样，匹配一个数字的"\\d"可以写成r"\d"。有了原生字符串，你再也不用担心是不是漏写了反斜杠，写出来的表达式也更直观。

仅需轻轻知道的几个匹配模式

re.I(re.IGNORECASE): 忽略大小写(括号内是完整写法，下同)

M(MULTILINE): 多行模式，改变'^'和'$'的行为(参见上图)

S(DOTALL): 点任意匹配模式，改变'.'的行为

内置函数

enumerate：遍历，返回序号和值

seq = ['one', 'two', 'three']for i, element inenumerate(seq):print(i,seq[i])print(i,element)

filter和map函数：

deff1(a):if a>22:returnTruedeff2(a):if a>22:return a+100li= [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][None, None,133, 144, 155, 166, 177]

#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.22False

进制转换:

bin()#将十进制的数转换成二进制的数

oct()#将十进制的数转换成八进制的数

hex()#将十进制的数转换成十六进制的数

例子：print(hex(10))print(oct(10))print(bin(255))

输出结果：0xa0o12

0b11111111

ASCII转换:

ord()#将ascii码转成整数

chr()#将整数转成ascii码

print(ord('A'))print(chr(65))

输出结果：65A

数学函数:

importmath

math.sin()

math.tan()

math.cos()

随机数函数：

importrandom

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 符号(‘\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))

输出结果：

原始字符串: thisisstring example....wow!!!

替换 \t 符号: thisisstring example....wow!!!

使用16个空格替换 \t 符号: thisis 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,14abc.123.456.dff safafsfa156165.saa,14 *

* abc.123.456.dff safafsfa156165.saa,14

len() #3.5中按字符计算，2.7中按字节计算

json()　　#变量里面的字符必须使用双引号