import module

  from module import xx

  from module import xx as rename

  from module import *

 import sys

 print(sys.path)

 from sys import path

 print(path)

 from sys import path as new_path

 print(new_path)

 from sys import *

 print(path)

 print(argv)

 #!/usr/bin/env python

 # -*- coding: utf-8 -*-

 def new_print(arg):

     print("\033[31m%s\033[0m"%arg)

 #!/usr/bin/env python

 # -*- coding: utf-8 -*-

 import print_mode

 print_mode.new_print("Hello world")

 from print_mode import new_print

 new_print("Hello world")

 from print_mode import new_print as pr

 pr("Hello world")

 from  print_mode import *

 new_print("Hello world")

 #!/usr/bin/env python

 # -*- coding: utf-8 -*-

 import os,sys

 print(os.path.abspath(__file__))

 print(os.path.dirname(os.path.abspath(__file__)))

 print(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))

 print("原：",sys.path)

 base_dir = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))

 sys.path.append(base_dir)

 print("新：",sys.path)

 from mode import print_mode

 print_mode.new_print("Hello world")

 # pip install paramiko  pip安装方式

 # pycrypto，由于 paramiko 模块内部依赖pycrypto，所以先下载安装pycrypto

 # 下载安装 pycrypto

 wget http://files.cnblogs.com/files/wupeiqi/pycrypto-2.6.1.tar.gz

 tar -xvf pycrypto-2.6.1.tar.gz

 cd pycrypto-2.6.1

 python setup.py build

 python setup.py install

 # 进入python环境，导入Crypto检查是否安装成功

 # 下载安装 paramiko

 wget http://files.cnblogs.com/files/wupeiqi/paramiko-1.10.1.tar.gz

 tar -xvf paramiko-1.10.1.tar.gz

 cd paramiko-1.10.1

 python setup.py build

 python setup.py install

 # 进入python环境，import paramiko检查是否安装成功即可

 #app_one

 def conf_app_one():

     print("From app_one")

 #app_two

 def conf_app_two1():

     print("From 1 app_two.py")

 def conf_app_two2():

     print("From 2 app_two.py")

 #conf

 def conf_func():

     print("From conf.py")

 #!/usr/bin/env python

 # -*- coding:utf-8 -*-

 import os,sys

 path = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))

 sys.path.append(path)

 from config import conf

 #!/usr/bin/env python

 # -*- coding:utf-8 -*-

 #main文件

 import os,sys

 path = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))

 sys.path.append(path)

 from app import *

 app_one.conf_app_one()

 app_two.conf_app_two1()

 #!/usr/bin/env python

 # -*- coding:utf-8 -*-

 import os,sys

 path = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))

 sys.path.append(path)

 from app import app_two

 app_two.conf_app_two1()

 from app import app_two as two

 two.conf_app_two2()

 from app.app_one import *

 conf_app_one()

 import time

 print(time.strftime("%Y:%m:%d,%H",time.localtime(time.time())))

 import datetime

 import time

 #返回 当前时间

 print(datetime.datetime.now())

 # 时间戳直接转成日期格式 2016-08-19

 print(datetime.date.fromtimestamp(time.time()) )

 #当前时间+3天

 print(datetime.datetime.now() + datetime.timedelta(3))

 #当前时间-3天

 print(datetime.datetime.now() + datetime.timedelta(-3))

 #当前时间+3小时

 print(datetime.datetime.now() + datetime.timedelta(hours=3))

 #当前时间+30分

 print(datetime.datetime.now() + datetime.timedelta(minutes=30))

 #时间替换

 c_time  = datetime.datetime.now()

 print(c_time.replace(minute=3,hour=2))

 #计算时间差，返回天数

 datas = "2016-08-19"

 def Repayment(past_time):

     def conversion(str_data):#把每个元素变成int类型

         data_list = str_data.split("-")

         for i in data_list:data_list[data_list.index(i)] = int(i)

         return data_list

     #得到新老时间的列表

     new_time_list = conversion(time.strftime("%Y-%m-%d",time.localtime(time.time())))

     past_time_list = conversion(past_time)

     n_time = datetime.datetime(new_time_list[0],new_time_list[1],new_time_list[2])

     p_time = datetime.datetime(past_time_list[0],past_time_list[1],past_time_list[2])

     return ((n_time - p_time).days)

 print(Repayment(datas))

 #!/usr/bin/env python

 import random

 #生成一个0到1的随机浮点数

 print(random.random())

 #用于生成一个指定范围内的随机符点数

 print( random.uniform(10, 20))

 print( random.uniform(10, 20))

 #用于生成一个指定范围内的整数。

 print(random.randint(10, 20))

 #指定范围内，按指定基数递增的集合中 获取一个随机数。

 #例子中也就是只会从 10 12 14 ... 18取得随机数，第三个参数为2的时候也就是取偶数

 print(random.randrange(10,20, 2))

 #从序列中获取一个随机元素。

 data_str = "I love Python"

 data_list = [1,2,3,4,5,6]

 data_tuple = ("A","B","C","D","E")

 print(random.choice(data_str))

 print(random.choice(data_list))

 print(random.choice(data_tuple))

 #用于将一个列表中的元素打乱。

 data_list = [1,2,3,4,5,6]

 random.shuffle(data_list)

 print(data_list)

 #从指定序列中随机获取指定长度的片断

 data_list = [1,2,3,4,5,6]

 print(random.sample(data_list,3))

 #!/usr/bin/env python

 import random

 # 第一版

 def code(number):

     '''

     随机数生成器

     '''

     number_check = ''

     for i in range(0,number):

         number_curr = random.randrange(0,5)

         if number_curr != i:

             number_temp = chr(random.randint(97,122))

         else:

             number_temp = random.randint(0,9)

         number_check += str(number_temp)

     return number_check

 print(code(5))

 # 第二版

 import string

 source = string.digits + string.ascii_uppercase + string.ascii_lowercase

 print("".join(random.sample(source, 4)))

 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    输出用于分割文件路径的字符串 win下为;,Linux下为:

 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所指向的文件或者目录的最后修改时间

 os.path.normpath(path)  #规范化路径，转换path的大小写和斜杠

 sys.argv    命令行参数List，第一个元素是程序本身路径

 sys.exit(n)    退出程序，正常退出时exit(0)

 sys.version   获取Python解释程序的版本信息

 sys.maxint   最大的Int值

 sys.path     返回模块的搜索路径，初始化时使用PYTHONPATH环境变量的值

 sys.platform    返回操作系统平台名称

 #!/usr/bin/env python

 import shutil

 #1、将文件拷贝到另一个文件中

 shutil.copyfileobj(open('test','r'), open('test2', 'w'))

 #2、拷贝文件

 shutil.copyfile('test', 'test2.conf')

 #3、拷贝权限 内容、组、用户均不变（目标文件必须存在）

 shutil.copymode('test', 'test2.conf')

 #4、仅拷贝状态的信息，包括：mode bits, atime, mtime, flags（目标文件必须存在）

 shutil.copystat('test', 'test2.conf')

 #5、拷贝文件和权限

 shutil.copy('test', 'test3')

 #6、拷贝文件和状态信息

 shutil.copy2('test', 'test3')

 #7、递归的去拷贝文件夹

 shutil.copytree('testlist', 'test2list', ignore=shutil.ignore_patterns('main.py',))

 """目标目录不能存在，注意对test2list目录父级目录要有可写权限，

 ignore的意思是排除，这里表示不拷贝main.py文件，多个可以用逗号隔开，也可以用*.py"""

 #拷贝软连接

 shutil.copytree('f1', 'f2', symlinks=True, ignore=shutil.ignore_patterns('*.pyc'))

 #通常的拷贝都把软连接拷贝成硬链接，即对待软连接来说，创建新的文件

 #8、递归的去删除文件

 shutil.rmtree('test2list')

 #9、递归的去移动文件，它类似mv命令，其实就是重命名。

 shutil.move("testlist", "testlist2")

 #!/usr/bin/env python

 import shutil

 #打包当前目录下的testlist目录，打包成a_bk.zip

 #支持方法"zip", "tar", "bztar" "gztar".

 tar = shutil.make_archive("a_bk","zip",root_dir="./testlist")

 #把打包结果文件刚在/mnt/目录下

 tar2 = shutil.make_archive("/mnt/a_bk","gztar",root_dir="./testlist")

 #!/usr/bin/env python

 import json

 #-----------序列化---------#

 dic = {"name":'aaa',"age":22,}

 lis = [1,2,3,""]

 with open("test","w") as file:

     file.write(json.dumps(dic))

 with open("test2","w") as file:

     json.dump(lis,file)

 #----------反序列化---------#

 with open("test","r") as file:

     data_dic = json.loads(file.read())

 with open("test2","r") as file:

     data_lis = json.load(file)

 print(type(data_lis),":",data_lis)

 print(type(data_dic),":",data_dic)

 #!/usr/bin/env python

 import pickle

 #-----------序列化---------#

 dic = {"name":'aaa',"age":22,}

 def func():

     return "Hello"

 with open("test","wb") as file:

     file.write(pickle.dumps(dic))

 with open("test2","wb") as file:

     pickle.dump(func,file)

 #----------反序列化---------#

 with open("test","rb") as file:

     data_dic = pickle.loads(file.read())

 with open("test2","rb") as file:

     data_func = pickle.load(file)

 print(type(data_func),":",data_func)

 print(data_func())

 print(type(data_dic),":",data_dic)

 <?xml version='1.0' encoding='utf-8'?>

 <userdata>

     <name Name="XiaoMing">

         <age>22</age>

         <gender>Men</gender>

     </name>

     <name Name="XiaoHong">

         <age>19</age>

         <gender>Women</gender>

     </name>

 </userdata>

 #生成 最外层的<userdata>

 new_xml = ET.Element("userdata")

 #生成<name Name="XiaoMing">

 name1 = ET.SubElement(new_xml,"name",attrib={"Name":"XiaoMing"})

 #生成<name Name="XiaoMing">中的<age>22</age>

 age = ET.SubElement(name1,"age")

 age.text = ""

 #生成<name Name="XiaoMing">中的<gender>Men</gender>

 gender = ET.SubElement(name1,"gender")

 gender.text = "Men"

 #生成<name Name="XiaoHong">

 name2 = ET.SubElement(new_xml,"name",attrib={"Name":"XiaoHong"})

 #生成<name Name="XiaoHong">中的<age>19</age>

 age = ET.SubElement(name2,"age")

 age.text = ''

 #生成<name Name="XiaoHong">中的<gender>Women</gender>

 gender = ET.SubElement(name2,"gender")

 gender.text = "Women"

 et = ET.ElementTree(new_xml) #生成文档对象

 et.write("test.xml", encoding="utf-8",xml_declaration=True)#写入

 #获取最外层的<userdata>

 tree = ET.parse("test.xml")

 root = tree.getroot()

 print(root.tag)

 print("-----------------遍历xml文档------------------")

 #遍历xml文档

 for child in root:

     print(child.tag,child.attrib)#打印<name Name="XiaoMing">和<name Name="XiaoHong">

     for i in child:

          print(i.tag,i.text)#分别打印年龄和性别

 print("-----------------只遍历age 节点------------------")

 #只遍历age 节点

 for node in root.iter("age"):

     print(node.tag,node.text)

 import xml.etree.ElementTree as ET

 print("--------------------年龄加1------------------")

 tree = ET.parse("test.xml")

 root = tree.getroot()

 for node in root.iter('age'):

     node.text = str(int(node.text) + 1)#年龄加一

     node.set("updated","yes") #增加属性 updated=“yex”

 tree.write("test.xml")#写入

 print("----------------删除年龄大于20的-------------")

 tree = ET.parse("test.xml")

 root = tree.getroot()

 for country in root.findall('name'):#循环name标签，[<Element 'name' at 0x009F4180>, <Element 'name' at 0x009F4240>]

    rank = int(country.find('age').text)#获取name标签下的年龄

    if rank > 20:#判断年龄是否大于20

      root.remove(country)#如果大则删除

 tree.write('test.xml')#写入

 [www.test.org]

 user = test

 port = 20012

 [www.test2.org]

 user = test2

 port = 20011

 forwardx11 = no

 #!/usr/bin/env python

 import configparser

 import time

 conf = configparser.ConfigParser()

 conf.read('conf')

 print("----------------读----------------")

 #得到所有的section，并以列表的形式返回

 print(conf.sections())

 #得到该section的所有option

 print(conf.options('www.test.org'))

 #得到该section的所有键值对

 print(conf.items('www.test2.org'))

 print(conf.get('www.test2.org',"User"))#得到section中option的值，返回为string类型

 time.sleep(2)

 print("----------------改----------------")

 conf.set('www.test2.org','port',"")

 conf.write(open('conf', "w"))

 time.sleep(2)

 print("----------------判断---------------")

 print(conf.has_section('www.test2.org'))

 time.sleep(2)

 print("----------------删----------------")

 #删除section中的option

 conf.remove_option('www.test.org','port')

 #删除section

 conf.remove_section('www.test.org')

 conf.write(open('conf', "w"))

 time.sleep(2)

 print("----------------写----------------")

 #添加section

 conf.add_section('www.test3.org')

 #添加section中的option

 conf.set('www.test3.org','port',"")

 conf.write(open('conf', "w"))

 #!/usr/bin/env python

 import  hashlib

 #首先定义一个hashlib的对象

 ha = hashlib.md5()#用的md5加密方式,这里还可以用SHA1, SHA224, SHA256, SHA384, SHA512算法

 ha.update("Hello".encode("utf-8"))

 print(ha.hexdigest())#返回16进制

 print(ha.digest())#返回二进制

 #结果 8b1a9953c4611296a827abf8c47804d7  b"\x8b\x1a\x99S\xc4a\x12\x96\xa8'\xab\xf8\xc4x\x04\xd7"

 import subprocess

 #执行命令，如果命令结果为0，就正常返回，否则抛异常

 retcode = subprocess.call(["ls", "-l"])

 #接收字符串格式命令，返回元组形式，第1个元素是执行状态，第2个是命令结果

 results = subprocess.getstatusoutput('ls /bin/ls')

 print(results)

 #接收字符串格式命令，并返回结果

 print(subprocess.getoutput('ls /bin/ls'))

 #执行命令，并返回结果，注意是返回结果，不是打印，下例结果返回给res

 res=subprocess.check_output(['ls','-l'])

 print(res)

 #调用subprocess.run(...)是推荐的常用方法，在大多数情况下能满足需求，

 subprocess.run(["ls", "-l", "/dev/null"], stdout=subprocess.PIPE)

 import subprocess

 subprocess.Popen(["ls","test"])

 subprocess.Popen("cat test.txt", shell=True)

 p = subprocess.Popen("ls test",stdin=subprocess.PIPE,stdout=subprocess.PIPE,shell=True)

 p.stdout.read()

 #需要交互的命令示例

 obj = subprocess.Popen(["python"], stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE)

 obj.stdin.write('print(1) \n ')

 obj.stdin.write('print(2) \n ')

 obj.stdin.write('print(3) \n ')

 obj.stdin.write('print(4) \n ')

 out_error_list = obj.communicate(timeout=10)

 print(out_error_list)

 import subprocess

 mypass = ''#密码

 echo = subprocess.Popen(['echo',mypass],stdout=subprocess.PIPE,)

 #命令

 sudo = subprocess.Popen(['sudo','-S','iptables','-L'],stdin=echo.stdout,stdout=subprocess.PIPE,)

 end_of_pipe = sudo.stdout

 print("Password ok \n Iptables Chains %s" % end_of_pipe.read())

 import logging

 logging.warning("user test attempted wrong password more than 3 times")

 logging.critical("server is down")

 logging.error("File cannot be opened")

 import logging

 print(logging.NOTSET) #

 print(logging.DEBUG)  #

 print(logging.INFO)   #

 print(logging.WARNING)#

 print(logging.ERROR)  #

 print(logging.CRITICAL)#

 import logging

 logging.basicConfig(filename='test.log',level=logging.INFO)

 logging.debug('debug')

 logging.info('info')

 logging.warning("warning")

 import logging

 logging.basicConfig(level=logging.DEBUG,

     format='%(asctime)s %(name)s %(levelname)s %(message)s',

     datefmt='[%Y-%m-%d %H:%M:%S]',

     filename='test.log',

     filemode='a')

 logging.warning('warning')

 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

 #定义文件日志格式

 logging.basicConfig(level=logging.DEBUG,

     format='%(asctime)s %(name)s %(levelname)s %(message)s',

     datefmt='[%Y-%m-%d %H:%M:%S]',

     filename='test.log',

     filemode='a')

 #create logger创建日志记录器

 logger = logging.getLogger()

 logger.setLevel(logging.DEBUG)

 # create console handler and set level to debug

 #定义输出级别为DEBUG

 ch = logging.StreamHandler()

 ch.setLevel(logging.DEBUG)

 # create formatter 创建日志输出的格式

 formatter = logging.Formatter('%(asctime)s %(name)s - %(levelname)s - %(message)s',

                                 datefmt='[%Y-%m-%d %H:%M:%S]')

 # add formatter to ch 绑定日志输出格式

 ch.setFormatter(formatter)

 # add ch to logger 绑定到日志记录器

 logger.addHandler(ch)

 #调用日志

 logger.debug('debug message')

 logger.info('info message')

 logger.warn('warn message')

 logger.error('error message')

 logger.critical('critical message')

 I = IGNORECASE = sre_compile.SRE_FLAG_IGNORECASE # ignore case

 使匹配对大小写不敏感；字符类和字符串匹配字母时忽略大小写。举个例子，[A-Z]也可以匹配小写字母，Spam 可以匹配 "Spam", "spam", 或 "spAM"。这个小写字母并不考虑当前位置。

 L = LOCALE = sre_compile.SRE_FLAG_LOCALE # assume current 8-bit locale

 影响 "w, "W, "b, 和 "B，这取决于当前的本地化设置。

 locales 是 C 语言库中的一项功能，是用来为需要考虑不同语言的编程提供帮助的。举个例子，如果你正在处理法文文本，你想用 "w+ 来匹配文字，但 "w 只匹配字符类 [A-Za-z]；它并不能匹配 "é" 或 "?"。如果你的系统配置适当且本地化设置为法语，那么内部的 C 函数将告诉程序 "é" 也应该被认为是一个字母。当在编译正则表达式时使用 LOCALE 标志会得到用这些 C 函数来处理 "w 後的编译对象；这会更慢，但也会象你希望的那样可以用 "w+ 来匹配法文文本。

 U = UNICODE = sre_compile.SRE_FLAG_UNICODE # assume unicode locale

 统一成unicode编码

 M = MULTILINE = sre_compile.SRE_FLAG_MULTILINE # make anchors look for newline

 使用 "^" 只匹配字符串的开始，而 $ 则只匹配字符串的结尾和直接在换行前（如果有的话）的字符串结尾。当本标志指定後， "^" 匹配字符串的开始和字符串中每行的开始。同样的， $ 元字符匹配字符串结尾和字符串中每行的结尾（直接在每个换行之前）。

 S = DOTALL = sre_compile.SRE_FLAG_DOTALL # make dot match newline

 使 "." 特殊字符完全匹配任何字符，包括换行；没有这个标志， "." 匹配除了换行外的任何字符。

 X = VERBOSE = sre_compile.SRE_FLAG_VERBOSE # ignore whitespace and comments

 该标志通过给予你更灵活的格式以便你将正则表达式写得更易于理解。当该标志被指定时，在 RE 字符串中的空白符被忽略，除非该空白符在字符类中或在反斜杠之後；这可以让你更清晰地组织和缩进 RE。它也可以允许你将注释写入 RE，这些注释会被引擎忽略；注释用 "#"号 来标识，不过该符号不能在字符串或反斜杠之後。

 #!/usr/bin/env python

 import re

 #re.match从起始位置开始根据模型去字符串中匹配指定内容，匹配单个

 #re .match(pattern, string, flags=0)

 text = "111apple222pear"

 f1 = re.match("\d+",text)

 if f1:print(f1.group())

 else:print("无")

 """运行一下试试，我们可以发现匹配到了111，所以我们可以确定的是，match匹配的是从起始位置来去匹配，

 起始位置匹配到了则正常，否则返回空 “\d+”表示匹配任意数字出现1次或者更多次,如果把+号变成{1,2}

 你就发现匹配的结果是11，这是因为{1,2}表示匹配一个或两个"""

 #re.search这个表示根据模式去匹配字符串中的匹配内容,也只匹配单个

 #re.search(pattern, string, flags=0)

 text = "aaa111apple222pear"

 f1 = re.search("\d+",text)

 if f1:print(f1.group())

 else:print("无")

 #这个例子我们发现,re.search把111匹配出来了所以他就是从整个字符串中匹配出模式符合的字符串,并且只匹配第一个

 #group（）与groups（）的区别

 text = "jnj111apple222pear"

 f1 = re.search("([0-9]+)([a-z]+)",text)

 if f1:

     print(f1.group(0),f1.group(1),f1.group(2))

     print(f1.groups())

 else:print("无")

 """看到结果清晰可见，re模块匹配到后会将值传入子组，group（）默认不写参数就返回匹配的整个值，

 写入参数就返回参数对应的值，而groups（）则返回匹配到的值的元组"""

 #匹配所有符合条件的值re.finadll(pattern, string, flags=0)

 text = "jnj111apple222pear"

 f1 = re.findall("([0-9]+)",text)

 if f1:print(f1)

 else:print("无")

 """执行上面的例子,得到的结果是个列表,列表中包含着所有符合条件的值([0-9]+)也可以写成(\d+)"""

 #用于替换匹配条件的字符串re.sub(pattern, repl, string, count=0, flags=0)

 text = "jnj111apple222pear"

 f1 = re.sub("([a-z]+)",'A',text)

 if f1:print(f1)

 else:print("无")

 #输出的结果是所有的字母全变成大写的A了类似于str.repalce

 #re.split(pattern, string, maxsplit=0, flags=0)

 content = "a1*b2c3*d4e5"

 new_content = re.split('[\*]', content,2)

 print (new_content)

 #表示以*号作为分割符保持在列表中类似于str.split

 #将匹配规则赋予对象，这样做的好处是可以提升匹配的速度compile(pattern, flags=0)

 import re

 content = "a1b*2c3*d4e5"

 aaa = re.compile('[\*]')

 new_content = re.split(aaa, content)

 print (new_content)

 #将字符串中所有特殊正则表达式字符转义escape(string)

 import re

 content = "a1b*2c3*d4e5"

 ccc = re.escape(content)

 print(ccc)

 import re

 str_in = 'name: aaa , age:22 , user:11121'

 new_str_in = re.findall("[age]+\:\d{1,3}",str_in)

 #表示age出现最低一次加上：号加上任意数字出现1到3次

 print(new_str_in)

 import re

 str_in = "The url is www.aaa.com wwa.ccc.dsa www.cdsa.c"

 new_str_in = re.findall("www\.\S*\..{2,3}",str_in)

 #以www加.加任意非空字符加任意字符出现次数为2到3次

 print(new_str_in)

 import re

 str_in = 'The name is xiaoyan The money I have (5+5),6-1'

 new_str_in = re.findall("\(*\d+[\+]+\d+\)*",str_in)#匹配出括号中的内容

 value = new_str_in[0].strip('(,)')#取出括号

 n1, n2 = value.split('+')#以+作为分割付

 new_value = str(int(n1)+int(n2))#进行计算

 aaa = str_in.replace(new_str_in[0],new_value)#进行替换

 print(aaa)