常用模块

import time
# --------------------------我们先以当前时间为准,让大家快速认识三种形式的时间

print(time.time())     # 时间戳:1487130156.419527
print(time.strftime("%Y-%m-%d %X"))     # 格式化的时间字符串:‘2017-02-15 11:40:53‘

print(time.localtime())     # 本地时区的struct_time
print(time.gmtime())        # UTC时区的struct_time

# --------------------------按图1转换时间
# localtime([secs])
# 将一个时间戳转换为当前时区的struct_time。secs参数未提供，则以当前时间为准。

time.localtime()
time.localtime(1473525444.037215)

# gmtime([secs]) 和localtime()方法类似，gmtime()方法是将一个时间戳转换为UTC时区（0时区）的struct_time。

# mktime(t) : 将一个struct_time转化为时间戳。
print(time.mktime(time.localtime()))#1473525749.0


# strftime(format[, t]) : 把一个代表时间的元组或者struct_time（如由time.localtime()和time.gmtime()返回）
# 转化为格式化的时间字符串。如果t未指定，将传入time.localtime()。如果元组中任何一个元素越界，ValueError的错误将会被抛出。
print(time.strftime("%Y-%m-%d %X", time.localtime()))#2016-09-11 00:49:56

# time.strptime(string[, format])
# 把一个格式化时间字符串转化为struct_time。实际上它和strftime()是逆操作。
print(time.strptime(‘2011-05-05 16:37:06‘, ‘%Y-%m-%d %X‘))

# time.struct_time(tm_year=2011, tm_mon=5, tm_mday=5, tm_hour=16, tm_min=37, tm_sec=6,

# tm_wday=3, tm_yday=125, tm_isdst=-1)
# 在这个函数中，format默认为："%a %b %d %H:%M:%S %Y"。

# --------------------------按图2转换时间
# asctime([t]) : 把一个表示时间的元组或者struct_time表示为这种形式：‘Sun Jun 20 23:21:05 1993‘。
# 如果没有参数，将会将time.localtime()作为参数传入。
print(time.asctime())    # Sun Sep 11 00:43:43 2016

# ctime([secs]) : 把一个时间戳（按秒计算的浮点数）转化为time.asctime()的形式。如果参数未给或者为
# None的时候，将会默认time.time()为参数。它的作用相当于time.asctime(time.localtime(secs))。
print(time.ctime())      # Sun Sep 11 00:46:38 2016
print(time.ctime(time.time()))      # Sun Sep 11 00:46:38 2016

# --------------------------其他用法
# sleep(secs)
# 线程推迟指定的时间运行，单位为秒。

import random

print(random.random())    　　　　# (0,1)----float    大于0且小于1之间的小数

print(random.randint(1,3))       # [1,3]    大于等于1且小于等于3之间的整数

print(random.randrange(1,3))     # [1,3)    大于等于1且小于3之间的整数

print(random.choice([1,‘23‘,[4,5]]))    # 1或者23或者[4,5]

print(random.sample([1,‘23‘,[4,5]],2))    # 列表元素任意2个组合

print(random.uniform(1,3))    # 大于1小于3的小数，如1.927109612082716


item = [1,3,5,7,9]
random.shuffle(item)     # 打乱item的顺序,相当于"洗牌"
print(item)    

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.getsize(path)         返回path的大小

在Linux和Mac平台上，该函数会原样返回path，
在windows平台上会将路径中所有字符转换为小写，并将所有斜杠转换为饭斜杠。

>>> os.path.normcase(‘c:/windows\\system32\\‘)   
‘c:\\windows\\system32\\‘   
   

规范化路径，如..和/
>>> os.path.normpath(‘c://windows\\System32\\../Temp/‘)   
‘c:\\windows\\Temp‘   

>>> a=‘/Users/jieli/test1/\\\a1/\\\\aa.py/../..‘
>>> print(os.path.normpath(a))
/Users/jieli/test1

os路径处理

# 方式一：推荐使用
import os

# 具体应用
import os,sys
possible_topdir = os.path.normpath(os.path.join(
    os.path.abspath(__file__),
    os.pardir,     #上一级
    os.pardir,
    os.pardir
))
sys.path.insert(0,possible_topdir)


# 方式二：不推荐使用
os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))

sys.argv           命令行参数List，第一个元素是程序本身路径
sys.exit(n)        退出程序，正常退出时exit(0)
sys.version        获取Python解释程序的版本信息
sys.maxint         最大的Int值
sys.path           返回模块的搜索路径，初始化时使用PYTHONPATH环境变量的值
sys.platform       返回操作系统平台名称

import shutil
  
shutil.copyfileobj(open(‘old.xml‘,‘r‘), open(‘new.xml‘, ‘w‘))

shutil.copyfile(‘f1.log‘, ‘f2.log‘)     # 目标文件无需存在

shutil.copymode(‘f1.log‘, ‘f2.log‘)     # 目标文件必须存在

shutil.copystat(‘f1.log‘, ‘f2.log‘)     # 目标文件必须存在

import shutil
  
shutil.copy(‘f1.log‘, ‘f2.log‘)

import shutil
  
shutil.copy2(‘f1.log‘, ‘f2.log‘)

import shutil
  
shutil.copytree(‘folder1‘, ‘folder2‘, ignore=shutil.ignore_patterns(‘*.pyc‘, ‘tmp*‘)) 
# 目标目录不能存在，注意对folder2目录父级目录要有可写权限，ignore的意思是排除

import shutil
  
shutil.rmtree(‘folder1‘)

import shutil
  
shutil.move(‘folder1‘, ‘folder3‘)

# 将 /data 下的文件打包放置当前程序目录
import shutil
ret = shutil.make_archive("data_bak", ‘gztar‘, root_dir=‘/data‘)


# 将 /data下的文件打包放置 /tmp/目录
import shutil
ret = shutil.make_archive("/tmp/data_bak", ‘gztar‘, root_dir=‘/data‘)

import json

x = "[null,true,false,1]"
print(eval(x))     # 报错，无法解析null类型，而json就可以
print(json.loads(x)) 

import json

dic = {‘name‘:‘alvin‘,‘age‘:23,‘sex‘:‘male‘}
print(type(dic))    # <class ‘dict‘>

j = json.dumps(dic)
print(type(j))    # <class ‘str‘>


f = open(‘序列化对象‘,‘w‘)
f.write(j)      # -------------------等价于json.dump(dic,f)
f.close()

# -----------------------------反序列化<br>
import json
f = open(‘序列化对象‘)
data = json.loads(f.read())    # 等价于data = json.load(f)

import json
# dct="{‘1‘:111}"        # json 不认单引号
# dct=str({"1":111})    # 报错,因为生成的数据还是单引号:{‘one‘: 1}

dct = ‘{"1":"111"}‘
print(json.loads(dct))

# conclusion:
# 无论数据是怎样创建的，只要满足json格式，就可以json.loads出来,不一定非要dumps的数据才能loads

import pickle

dic = {‘name‘:‘alvin‘,‘age‘:23,‘sex‘:‘male‘}

print(type(dic))    # <class ‘dict‘>

j = pickle.dumps(dic)
print(type(j))    # <class ‘bytes‘>


f = open(‘序列化对象_pickle‘,‘wb‘)    # 注意是w是写入str,wb是写入bytes,j是‘bytes‘
f.write(j)      # -------------------等价于pickle.dump(dic,f)

f.close()
# -------------------------反序列化
import pickle
f = open(‘序列化对象_pickle‘,‘rb‘)

data = pickle.loads(f.read())    # 等价于data=pickle.load(f)


print(data[‘age‘])

import shelve

f=shelve.open(r‘sheve.txt‘)
# f[‘stu1_info‘]={‘name‘:‘egon‘,‘age‘:18,‘hobby‘:[‘piao‘,‘smoking‘,‘drinking‘]}
# f[‘stu2_info‘]={‘name‘:‘gangdan‘,‘age‘:53}
# f[‘school_info‘]={‘website‘:‘http://www.pypy.org‘,‘city‘:‘beijing‘}

print(f[‘stu1_info‘][‘hobby‘])
f.close()

<?xml version="1.0"?>
<data>
    <country name="Liechtenstein">
        <rank updated="yes">2</rank>
        <year>2008</year>
        <gdppc>141100</gdppc>
        <neighbor name="Austria" direction="E"/>
        <neighbor name="Switzerland" direction="W"/>
    </country>
    <country name="Singapore">
        <rank updated="yes">5</rank>
        <year>2011</year>
        <gdppc>59900</gdppc>
        <neighbor name="Malaysia" direction="N"/>
    </country>
    <country name="Panama">
        <rank updated="yes">69</rank>
        <year>2011</year>
        <gdppc>13600</gdppc>
        <neighbor name="Costa Rica" direction="W"/>
        <neighbor name="Colombia" direction="E"/>
    </country>
</data>

# print(root.iter(‘year‘))           # 全文搜索
# print(root.find(‘country‘))        # 在root的子节点找，只找一个
# print(root.findall(‘country‘))     # 在root的子节点找，找所有    

import xml.etree.ElementTree as ET
 
tree = ET.parse("xmltest.xml")
root = tree.getroot()
print(root.tag)
 
# 遍历xml文档
for child in root:
    print(‘========>‘,child.tag,child.attrib,child.attrib[‘name‘])
    for i in child:
        print(i.tag,i.attrib,i.text)
 
# 只遍历year 节点
for node in root.iter(‘year‘):
    print(node.tag,node.text)
#---------------------------------------

import xml.etree.ElementTree as ET
 
tree = ET.parse("xmltest.xml")
root = tree.getroot()
 
# 修改
for node in root.iter(‘year‘):
    new_year=int(node.text)+1
    node.text=str(new_year)
    node.set(‘updated‘,‘yes‘)
    node.set(‘version‘,‘1.0‘)
tree.write(‘test.xml‘)
 
 
# 删除node
for country in root.findall(‘country‘):
   rank = int(country.find(‘rank‘).text)
   if rank > 50:
     root.remove(country)
 
tree.write(‘output.xml‘)

# 在country内添加（append）节点year2
import xml.etree.ElementTree as ET
tree = ET.parse("a.xml")
root=tree.getroot()
for country in root.findall(‘country‘):
    for year in country.findall(‘year‘):
        if int(year.text) > 2000:
            year2=ET.Element(‘year2‘)
            year2.text=‘新年‘
            year2.attrib={‘update‘:‘yes‘}
            country.append(year2)     # 往country节点下添加子节点

tree.write(‘a.xml.swap‘)

import xml.etree.ElementTree as ET
 
 
new_xml = ET.Element("namelist")
name = ET.SubElement(new_xml,"name",attrib={"enrolled":"yes"})
age = ET.SubElement(name,"age",attrib={"checked":"no"})
sex = ET.SubElement(name,"sex")
sex.text = ‘33‘
name2 = ET.SubElement(new_xml,"name",attrib={"enrolled":"no"})
age = ET.SubElement(name2,"age")
age.text = ‘19‘
 
et = ET.ElementTree(new_xml)     # 生成文档对象
et.write("test.xml", encoding="utf-8",xml_declaration=True)
 
ET.dump(new_xml)     # 打印生成的格式

# 注释1
; 注释2

[section1]
k1 = v1
k2:v2
user = zixi
age = 18
is_admin = true
salary = 31


[section2]
k1 = v1

import configparser

config = configparser.ConfigParser()
config.read(‘a.cfg‘)

# 查看所有的标题
res = config.sections() 　　# [‘section1‘, ‘section2‘]
print(res)

# 查看标题section1下所有key=value的key
options = config.options(‘section1‘)
print(options) 　　　　#[‘k1‘, ‘k2‘, ‘user‘, ‘age‘, ‘is_admin‘, ‘salary‘]

# 查看标题section1下所有key=value的(key,value)格式
item_list = config.items(‘section1‘)
print(item_list) 　　#[(‘k1‘, ‘v1‘), (‘k2‘, ‘v2‘), (‘user‘, ‘egon‘), (‘age‘, ‘18‘), (‘is_admin‘, ‘true‘), (‘salary‘, ‘31‘)]

# 查看标题section1下user的值=>字符串格式
val = config.get(‘section1‘,‘user‘)
print(val) 　　# zixi

# 查看标题section1下age的值=>整数格式
val1 = config.getint(‘section1‘,‘age‘)
print(val1) 　　# 18

# 查看标题section1下is_admin的值=>布尔值格式
val2 = config.getboolean(‘section1‘,‘is_admin‘)
print(val2) 　　# True

# 查看标题section1下salary的值=>浮点型格式
val3 = config.getfloat(‘section1‘,‘salary‘)
print(val3) 　　# 31.0

import configparser

config = configparser.ConfigParser()
config.read(‘a.cfg‘,encoding=‘utf-8‘)


# 删除整个标题section2
config.remove_section(‘section2‘)

# 删除标题section1下的某个k1和k2
config.remove_option(‘section1‘,‘k1‘)
config.remove_option(‘section1‘,‘k2‘)

# 判断是否存在某个标题
print(config.has_section(‘section1‘))

# 判断标题section1下是否有user
print(config.has_option(‘section1‘,‘‘))


# 添加一个标题
config.add_section(‘zixi‘)

# 在标题egon下添加name=egon,age=18的配置
config.set(‘zixi‘,‘name‘,‘egon‘)
config.set(‘zixi‘,‘age‘,18) 　　# 报错,必须是字符串


# 最后将修改的内容写入文件,完成最终的修改
config.write(open(‘a.cfg‘,‘w‘))

import configparser
  
config = configparser.ConfigParser()
config["DEFAULT"] = {‘ServerAliveInterval‘: ‘45‘,
                      ‘Compression‘: ‘yes‘,
                     ‘CompressionLevel‘: ‘9‘}
  
config[‘bitbucket.org‘] = {}
config[‘bitbucket.org‘][‘User‘] = ‘hg‘
config[‘topsecret.server.com‘] = {}
topsecret = config[‘topsecret.server.com‘]
topsecret[‘Host Port‘] = ‘50022‘     # mutates the parser
topsecret[‘ForwardX11‘] = ‘no‘  　　　# same here
config[‘DEFAULT‘][‘ForwardX11‘] = ‘yes‘
with open(‘example.ini‘, ‘w‘) as configfile:
   config.write(configfile)

# 1、什么叫hash:hash是一种算法（3.x里代替了md5模块和sha模块，主要提供 SHA1, SHA224, SHA256, SHA384, SHA512 ，MD5 算法），该算法接受传入的内容，经过运算得到一串hash值
# 2、hash值的特点是：
# 2.1 只要传入的内容一样，得到的hash值必然一样=====>要用明文传输密码文件完整性校验
# 2.2 不能由hash值返解成内容=======》把密码做成hash值，不应该在网络传输明文密码
# 2.3 只要使用的hash算法不变，无论校验的内容有多大，得到的hash值长度是固定的

import hashlib

m = hashlib.md5()         # m = hashlib.sha256()

m.update(‘hello‘.encode(‘utf8‘))
print(m.hexdigest())      # 5d41402abc4b2a76b9719d911017c592

m.update(‘alvin‘.encode(‘utf8‘))

print(m.hexdigest())      # 92a7e713c30abbb0319fa07da2a5c4af

m2 = hashlib.md5()
m2.update(‘helloalvin‘.encode(‘utf8‘))
print(m2.hexdigest())     # 92a7e713c30abbb0319fa07da2a5c4af

‘‘‘
注意：把一段很长的数据update多次，与一次update这段长数据，得到的结果一样
但是update多次为校验大文件提供了可能。
‘‘‘    

import hashlib

# ######## 256 ########

hash = hashlib.sha256(‘898oaFs09f‘.encode(‘utf8‘))
hash.update(‘alvin‘.encode(‘utf8‘))
print (hash.hexdigest())
# e79e68f070cdedcfe63eaf1a2e92c83b4cfb1b5c6bc452d214c1b7e77cdfd1c7

import hmac
h1 = hmac.new(‘hello‘.encode(‘utf-8‘),digestmod=‘md5‘)
h1.update(‘world‘.encode(‘utf-8‘))

print(h1.hexdigest())

# 要想保证hmac最终结果一致，必须保证：
# 1:hmac.new括号内指定的初始key一样
# 2:无论update多少次，校验的内容累加到一起是一样的内容

# 操作一
import hmac
h1=hmac.new(‘hello‘.encode(‘utf-8‘),digestmod=‘md5‘)
h1.update(‘world‘.encode(‘utf-8‘))

print(h1.hexdigest())     # 0e2564b7e100f034341ea477c23f283b

# 操作二
import hmac
h2 = hmac.new(‘hello‘.encode(‘utf-8‘),digestmod=‘md5‘)
h2.update(‘w‘.encode(‘utf-8‘))
h2.update(‘orld‘.encode(‘utf-8‘))

print(h1.hexdigest())     # 0e2564b7e100f034341ea477c23f283b

import  subprocess

‘‘‘
sh-3.2# ls /Users/zixi/Desktop |grep txt$
mysql.txt
tt.txt
事物.txt
‘‘‘

res1 = subprocess.Popen(‘ls /Users/jieli/Desktop‘,shell=True,stdout=subprocess.PIPE)
res=subprocess.Popen(‘grep txt$‘,shell=True,stdin=res1.stdout,
                 stdout=subprocess.PIPE)

print(res.stdout.read().decode(‘utf-8‘))


# 等同于上面,但是上面的优势在于,一个数据流可以和另外一个数据流交互,可以通过爬虫得到结果然后交给grep
res1 = subprocess.Popen(‘ls /Users/jieli/Desktop |grep txt$‘,shell=True,stdout=subprocess.PIPE)
print(res1.stdout.read().decode(‘utf-8‘))


# windows下:
# dir | findstr ‘test*‘
# dir | findstr ‘txt$‘
import subprocess
res1 = subprocess.Popen(r‘dir C:\Users\Administrator\PycharmProjects\test\函数‘,shell=True,stdout=subprocess.PIPE)
res = subprocess.Popen(‘findstr test*‘,shell=True,stdin=res1.stdout,
                 stdout=subprocess.PIPE)

print(res.stdout.read().decode(‘gbk‘)) 
# subprocess使用当前系统默认编码，得到结果为bytes类型，在windows下需要用gbk解码

CRITICAL = 50    # FATAL = CRITICAL
ERROR = 40
WARNING = 30     # WARN = WARNING
INFO = 20
DEBUG = 10
NOTSET = 0       # 不设置

import logging

logging.debug(‘调试debug‘)
logging.info(‘消息info‘)
logging.warning(‘警告warn‘)
logging.error(‘错误error‘)
logging.critical(‘严重critical‘)

‘‘‘
WARNING:root:警告warn
ERROR:root:错误error
CRITICAL:root:严重critical
‘‘‘

可在logging.basicConfig()函数中通过具体参数来更改logging模块默认行为，可用参数有
filename：用指定的文件名创建FiledHandler（后边会具体讲解handler的概念），这样日志会被存储在指定的文件中。
filemode：文件打开方式，在指定了filename时使用这个参数，默认值为“a”还可指定为“w”。
format：指定handler使用的日志显示格式。 
datefmt：指定日期时间格式。 
level：设置rootlogger（后边会讲解具体概念）的日志级别 
stream：用指定的stream创建StreamHandler。可以指定输出到sys.stderr,sys.stdout或者文件，默认为sys.stderr。若同时列出了filename和stream两个参数，则stream参数会被忽略。



# 格式
%(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：用户输出的消息

 

#========使用
import logging
logging.basicConfig(filename=‘access.log‘,
                    format=‘%(asctime)s - %(name)s - %(levelname)s -%(module)s:  %(message)s‘,
                    datefmt=‘%Y-%m-%d %H:%M:%S %p‘,
                    level=10)

logging.debug(‘调试debug‘)
logging.info(‘消息info‘)
logging.warning(‘警告warn‘)
logging.error(‘错误error‘)
logging.critical(‘严重critical‘)



# ========结果
access.log内容:
2017-07-28 20:32:17 PM - root - DEBUG -test:  调试debug
2017-07-28 20:32:17 PM - root - INFO -test:  消息info
2017-07-28 20:32:17 PM - root - WARNING -test:  警告warn
2017-07-28 20:32:17 PM - root - ERROR -test:  错误error
2017-07-28 20:32:17 PM - root - CRITICAL -test:  严重critical

part2: 可以为logging模块指定模块级的配置,即所有logger的配置

# logger：产生日志的对象

# Filter：过滤日志的对象

# Handler：接收日志然后控制打印到不同的地方，FileHandler用来打印到文件中，StreamHandler用来打印到终端

# Formatter对象：可以定制不同的日志格式对象，然后绑定给不同的Handler对象使用，以此来控制不同的Handler的日志格式

import logging

# 一：日志配置
logging.basicConfig(
    # 1、日志输出位置：1、终端 2、文件
    # filename=‘access.log‘, # 不指定，默认打印到终端

    # 2、日志格式
    format=‘%(asctime)s - %(name)s - %(levelname)s -%(module)s:  %(message)s‘,

    # 3、时间格式
    datefmt=‘%Y-%m-%d %H:%M:%S %p‘,

    # 4、日志级别
    # critical => 50
    # error => 40
    # warning => 30
    # info => 20
    # debug => 10
    level=30,
)

# 二：输出日志
logging.debug(‘调试debug‘)
logging.info(‘消息info‘)
logging.warning(‘警告warn‘)
logging.error(‘错误error‘)
logging.critical(‘严重critical‘)

‘‘‘
# 注意下面的root是默认的日志名字
WARNING:root:警告warn
ERROR:root:错误error
CRITICAL:root:严重critical
‘‘‘

# =================================匹配模式=================================
#一对一的匹配
# ‘hello‘.replace(old,new)
# ‘hello‘.find(‘pattern‘)

#正则匹配
import re
#\w与\W
print(re.findall(‘\w‘,‘hello egon 123‘)) #[‘h‘, ‘e‘, ‘l‘, ‘l‘, ‘o‘, ‘e‘, ‘g‘, ‘o‘, ‘n‘, ‘1‘, ‘2‘, ‘3‘]
print(re.findall(‘\W‘,‘hello egon 123‘)) #[‘ ‘, ‘ ‘]

#\s与\S
print(re.findall(‘\s‘,‘hello  egon  123‘)) #[‘ ‘, ‘ ‘, ‘ ‘, ‘ ‘]
print(re.findall(‘\S‘,‘hello  egon  123‘)) #[‘h‘, ‘e‘, ‘l‘, ‘l‘, ‘o‘, ‘e‘, ‘g‘, ‘o‘, ‘n‘, ‘1‘, ‘2‘, ‘3‘]

#\n \t都是空,都可以被\s匹配
print(re.findall(‘\s‘,‘hello \n egon \t 123‘)) #[‘ ‘, ‘\n‘, ‘ ‘, ‘ ‘, ‘\t‘, ‘ ‘]

#\n与\t
print(re.findall(r‘\n‘,‘hello egon \n123‘)) #[‘\n‘]
print(re.findall(r‘\t‘,‘hello egon\t123‘)) #[‘\n‘]

#\d与\D
print(re.findall(‘\d‘,‘hello egon 123‘)) #[‘1‘, ‘2‘, ‘3‘]
print(re.findall(‘\D‘,‘hello egon 123‘)) #[‘h‘, ‘e‘, ‘l‘, ‘l‘, ‘o‘, ‘ ‘, ‘e‘, ‘g‘, ‘o‘, ‘n‘, ‘ ‘]

#\A与\Z
print(re.findall(‘\Ahe‘,‘hello egon 123‘)) #[‘he‘],\A==>^
print(re.findall(‘123\Z‘,‘hello egon 123‘)) #[‘he‘],\Z==>$

#^与$
print(re.findall(‘^h‘,‘hello egon 123‘)) #[‘h‘]
print(re.findall(‘3$‘,‘hello egon 123‘)) #[‘3‘]

# 重复匹配：| . | * | ? | .* | .*? | + | {n,m} |
#.
print(re.findall(‘a.b‘,‘a1b‘)) #[‘a1b‘]
print(re.findall(‘a.b‘,‘a1b a*b a b aaab‘)) #[‘a1b‘, ‘a*b‘, ‘a b‘, ‘aab‘]
print(re.findall(‘a.b‘,‘a\nb‘)) #[]
print(re.findall(‘a.b‘,‘a\nb‘,re.S)) #[‘a\nb‘]
print(re.findall(‘a.b‘,‘a\nb‘,re.DOTALL)) #[‘a\nb‘]同上一条意思一样

#*
print(re.findall(‘ab*‘,‘bbbbbbb‘)) #[]
print(re.findall(‘ab*‘,‘a‘)) #[‘a‘]
print(re.findall(‘ab*‘,‘abbbb‘)) #[‘abbbb‘]

#?
print(re.findall(‘ab?‘,‘a‘)) #[‘a‘]
print(re.findall(‘ab?‘,‘abbb‘)) #[‘ab‘]
#匹配所有包含小数在内的数字
print(re.findall(‘\d+\.?\d*‘,"asdfasdf123as1.13dfa12adsf1asdf3")) #[‘123‘, ‘1.13‘, ‘12‘, ‘1‘, ‘3‘]

#.*默认为贪婪匹配
print(re.findall(‘a.*b‘,‘a1b22222222b‘)) #[‘a1b22222222b‘]

#.*?为非贪婪匹配：推荐使用
print(re.findall(‘a.*?b‘,‘a1b22222222b‘)) #[‘a1b‘]

#+
print(re.findall(‘ab+‘,‘a‘)) #[]
print(re.findall(‘ab+‘,‘abbb‘)) #[‘abbb‘]

#{n,m}
print(re.findall(‘ab{2}‘,‘abbb‘)) #[‘abb‘]
print(re.findall(‘ab{2,4}‘,‘abbb‘)) #[‘abb‘]
print(re.findall(‘ab{1,}‘,‘abbb‘)) #‘ab{1,}‘ ===> ‘ab+‘
print(re.findall(‘ab{0,}‘,‘abbb‘)) #‘ab{0,}‘ ===> ‘ab*‘

# []
print(re.findall(‘a[1*-]b‘,‘a1b a*b a-b‘)) #[]内的都为普通字符了，且如果-没有被转意的话，应该放到[]的开头或结尾
print(re.findall(‘a[^1*-]b‘,‘a1b a*b a-b a=b‘)) #[]内的^代表的意思是取反，所以结果为[‘a=b‘]
print(re.findall(‘a[0-9]b‘,‘a1b a*b a-b a=b‘)) #[]内的^代表的意思是取反，所以结果为[‘a=b‘]
print(re.findall(‘a[a-z]b‘,‘a1b a*b a-b a=b aeb‘)) #[]内的^代表的意思是取反，所以结果为[‘a=b‘]
print(re.findall(‘a[a-zA-Z]b‘,‘a1b a*b a-b a=b aeb aEb‘)) #[]内的^代表的意思是取反，所以结果为[‘a=b‘]

# \
# print(re.findall(‘a\\c‘,‘a\c‘)) #对于正则来说a\\c确实可以匹配到a\c,但是在python解释器读取a\\c时，会发生转义，然后交给re去执行，所以抛出异常
print(re.findall(r‘a\\c‘,‘a\c‘)) #r代表告诉解释器使用rawstring，即原生字符串，把我们正则内的所有符号都当普通字符处理，不要转义
print(re.findall(‘a\\\\c‘,‘a\c‘)) #同上面的意思一样，和上面的结果一样都是[‘a\\c‘]

# ():分组
print(re.findall(‘ab+‘,‘ababab123‘)) #[‘ab‘, ‘ab‘, ‘ab‘]
print(re.findall(‘(ab)+123‘,‘ababab123‘)) #[‘ab‘]，匹配到末尾的ab123中的ab
print(re.findall(‘(?:ab)+123‘,‘ababab123‘)) #findall的结果不是匹配的全部内容，而是组内的内容,?:可以让结果为匹配的全部内容
print(re.findall(‘href="(.*?)"‘,‘<a href="http://www.baidu.com">点击</a>‘))#[‘http://www.baidu.com‘]
print(re.findall(‘href="(?:.*?)"‘,‘<a href="http://www.baidu.com">点击</a>‘))#[‘href="http://www.baidu.com"‘]

#|
print(re.findall(‘compan(?:y|ies)‘,‘Too many companies have gone bankrupt, and the next one is my company‘))

# ===========================re模块提供的方法介绍===========================
import re
#1
print(re.findall(‘e‘,‘alex make love‘) )   #[‘e‘, ‘e‘, ‘e‘],返回所有满足匹配条件的结果,放在列表里
#2
print(re.search(‘e‘,‘alex make love‘).group()) #e,只到找到第一个匹配然后返回一个包含匹配信息的对象,该对象可以通过调用group()方法得到匹配的字符串,如果字符串没有匹配，则返回None。

#3
print(re.match(‘e‘,‘alex make love‘))    #None,同search,不过在字符串开始处进行匹配,完全可以用search+^代替match

#4
print(re.split(‘[ab]‘,‘abcd‘))     #[‘‘, ‘‘, ‘cd‘]，先按‘a‘分割得到‘‘和‘bcd‘,再对‘‘和‘bcd‘分别按‘b‘分割

#5
print(‘===>‘,re.sub(‘a‘,‘A‘,‘alex make love‘)) #===> Alex mAke love，不指定n，默认替换所有
print(‘===>‘,re.sub(‘a‘,‘A‘,‘alex make love‘,1)) #===> Alex make love
print(‘===>‘,re.sub(‘a‘,‘A‘,‘alex make love‘,2)) #===> Alex mAke love
print(‘===>‘,re.sub(‘^(\w+)(.*?\s)(\w+)(.*?\s)(\w+)(.*?)$‘,r‘\5\2\3\4\1‘,‘alex make love‘)) #===> love make alex

print(‘===>‘,re.subn(‘a‘,‘A‘,‘alex make love‘)) #===> (‘Alex mAke love‘, 2),结果带有总共替换的个数


#6
obj=re.compile(‘\d{2}‘)

print(obj.search(‘abc123eeee‘).group()) #12
print(obj.findall(‘abc123eeee‘)) #[‘12‘],重用了obj

# 补充一：

import re
print(re.findall("<(?P<tag_name>\w+)>\w+</(?P=tag_name)>","<h1>hello</h1>")) #[‘h1‘]
print(re.search("<(?P<tag_name>\w+)>\w+</(?P=tag_name)>","<h1>hello</h1>").group()) #<h1>hello</h1>
print(re.search("<(?P<tag_name>\w+)>\w+</(?P=tag_name)>","<h1>hello</h1>").groupdict()) #<h1>hello</h1>

print(re.search(r"<(\w+)>\w+</(\w+)>","<h1>hello</h1>").group())
print(re.search(r"<(\w+)>\w+</\1>","<h1>hello</h1>").group())

# 补充二

import re
# 使用|，先匹配的先生效，|左边是匹配小数，而findall最终结果是查看分组，所有即使匹配成功小数也不会存入结果#而不是小数时，就去匹配(-?\d+)，匹配到的自然就是，非小数的数，在此处即整数#print(re.findall(r"-?\d+\.\d*|(-?\d+)","1-2*(60+(-40.35/5)-(-4*3))")) #找出所有整数[‘1‘, ‘-2‘, ‘60‘, ‘‘, ‘5‘, ‘-4‘, ‘3‘]#找到所有数字:print(re.findall(‘\D?(\-?\d+\.?\d*)‘,"1-2*(60+(-40.35/5)-(-4*3))")) # [‘1‘,‘2‘,‘60‘,‘-40.35‘,‘5‘,‘-4‘,‘3‘]
# 计算器作业参考：http://www.cnblogs.com/wupeiqi/articles/4949995.html
expression=‘1-2*((60+2*(-3-40.0/5)*(9-2*5/3+7/3*99/4*2998+10*568/14))-(-4*3)/(16-3*2))‘

content=re.search(‘\(([\-\+\*\/]*\d+\.?\d*)+\)‘,expression).group() 　　# (-3-40.0/5)

#_*_coding:utf-8_*_
__author__ = ‘Zhangzixi‘
# 在线调试工具:tool.oschina.net/regex/#
import re

s=‘‘‘
http://www.baidu.com
zoling@163.com
你好
010-3141
‘‘‘

# 最常规匹配
# content=‘Hello 123 456 World_This is a Regex Demo‘
# res=re.match(‘Hello\s\d\d\d\s\d{3}\s\w{10}.*Demo‘,content)
# print(res)
# print(res.group())
# print(res.span())

# 泛匹配
# content=‘Hello 123 456 World_This is a Regex Demo‘
# res=re.match(‘^Hello.*Demo‘,content)
# print(res.group())


# 匹配目标,获得指定数据

# content=‘Hello 123 456 World_This is a Regex Demo‘
# res=re.match(‘^Hello\s(\d+)\s(\d+)\s.*Demo‘,content)
# print(res.group())     # 取所有匹配的内容
# print(res.group(1))     # 取匹配的第一个括号内的内容
# print(res.group(2))     # 去陪陪的第二个括号内的内容



# 贪婪匹配:.*代表匹配尽可能多的字符
# import re
# content=‘Hello 123 456 World_This is a Regex Demo‘
#
# res=re.match(‘^He.*(\d+).*Demo$‘,content)
# print(res.group(1))     # 只打印6,因为.*会尽可能多的匹配,然后后面跟至少一个数字


# 非贪婪匹配:?匹配尽可能少的字符
# import re
# content=‘Hello 123 456 World_This is a Regex Demo‘
#
# res=re.match(‘^He.*?(\d+).*Demo$‘,content)
# print(res.group(1)) #只打印6,因为.*会尽可能多的匹配,然后后面跟至少一个数字


#匹配模式:.不能匹配换行符
content=‘‘‘Hello 123456 World_This
is a Regex Demo
‘‘‘
# res=re.match(‘He.*?(\d+).*?Demo$‘,content)
# print(res) #输出None

# res=re.match(‘He.*?(\d+).*?Demo$‘,content,re.S) #re.S让.可以匹配换行符
# print(res)
# print(res.group(1))


#转义:\

# content=‘price is $5.00‘
# res=re.match(‘price is $5.00‘,content)
# print(res)
#
# res=re.match(‘price is \$5\.00‘,content)
# print(res)


#总结:尽量精简,详细的如下
    # 尽量使用泛匹配模式.*
    # 尽量使用非贪婪模式:.*?
    # 使用括号得到匹配目标:用group(n)去取得结果
    # 有换行符就用re.S:修改模式



#re.search:会扫描整个字符串,不会从头开始,找到第一个匹配的结果就会返回

# import re
# content=‘Extra strings Hello 123 456 World_This is a Regex Demo Extra strings‘
#
# res=re.match(‘Hello.*?(\d+).*?Demo‘,content)
# print(res) #输出结果为None

#
# import re
# content=‘Extra strings Hello 123 456 World_This is a Regex Demo Extra strings‘
#
# res=re.search(‘Hello.*?(\d+).*?Demo‘,content) #
# print(res.group(1)) #输出结果为



#re.search:只要一个结果,匹配演练,
import re
content=‘‘‘
<tbody>
<tr id="4766303201494371851675" class="even "><td><div class="hd"><span class="num">1</span><div class="rk "><span class="u-icn u-icn-75"></span></div></div></td><td class="rank"><div class="f-cb"><div class="tt"><a href="/song?id=476630320"><img class="rpic" src="http://p1.music.126.net/Wl7T1LBRhZFg0O26nnR2iQ==/19217264230385030.jpg?param=50y50&quality=100"></a><span data-res-id="476630320" "
# res=re.search(‘<a\shref=.*?<b\stitle="(.*?)".*?b>‘,content)
# print(res.group(1))


#re.findall:找到符合条件的所有结果
# res=re.findall(‘<a\shref=.*?<b\stitle="(.*?)".*?b>‘,content)
# for i in res:
#     print(i)



#re.sub:字符串替换
import re
content=‘Extra strings Hello 123 456 World_This is a Regex Demo Extra strings‘

# content=re.sub(‘\d+‘,‘‘,content)
# print(content)


#用\1取得第一个括号的内容
#用法:将123与456换位置
# import re
# content=‘Extra strings Hello 123 456 World_This is a Regex Demo Extra strings‘
#
# # content=re.sub(‘(Extra.*?)(\d+)(\s)(\d+)(.*?strings)‘,r‘\1\4\3\2\5‘,content)
# content=re.sub(‘(\d+)(\s)(\d+)‘,r‘\3\2\1‘,content)
# print(content)




# import re
# content=‘Extra strings Hello 123 456 World_This is a Regex Demo Extra strings‘
#
# res=re.search(‘Extra.*?(\d+).*strings‘,content)
# print(res.group(1))


# import requests,re
# respone=requests.get(‘https://book.douban.com/‘).text

# print(respone)
# print(‘======‘*1000)
# print(‘======‘*1000)
# print(‘======‘*1000)
# print(‘======‘*1000)
# res=re.findall(‘<li.*?cover.*?href="(.*?)".*?title="(.*?)">.*?more-meta.*?author">(.*?)</span.*?year">(.*?)</span.*?publisher">(.*?)</span.*?</li>‘,respone,re.S)
# # res=re.findall(‘<li.*?cover.*?href="(.*?)".*?more-meta.*?author">(.*?)</span.*?year">(.*?)</span.*?publisher">(.*?)</span>.*?</li>‘,respone,re.S)
#
#
# for i in res:
#     print(‘%s    %s    %s   %s‘ %(i[0].strip(),i[1].strip(),i[2].strip(),i[3].strip()))

import re

# 1、匹配密码，密码必须是由6位数字与字母组成，并且不能是纯数字也不能是纯字母
# 1.1 知识点：# ?!pattern,表示在没有配到pattern的字符串的前提下，再进行后续的正则表达式匹配，后续匹配仍然从被匹配字符串的头开始

# 1.2 答案：
print(re.search("(?!^[0-9]+$)(?!^[a-zA-Z]+$)^[0-9A-Za-z]{6}$","123asf").group())  # 123asf

# 1.3 解释：
# 上述正则的意思为：在匹配(?!^[0-9]+$)以及(?!^[a-zA-Z]+$)过后，如果字符串成功后在从头去匹配(?!^[a-zA-Z]+$)，最终匹配完。


# 2、匹配密码，密码强度：强，必须包含大写，小写和数字,和特殊字符(!,@,#,%,&),且大于6位
# 2.1 知识点：# ?=pattern,表示在配到pattern的字符串的前提下，再进行后续的正则表达式匹配，后续匹配仍然从被匹配字符串的头开始

# 2.2 答案：
# while True:
#     pwd = input("please your password: ").strip()  # 比如输入：Aa3@adf123
#     pwd_pattern= re.compile("(?=.*[A-Z])(?=.*[a-z])(?=.*[0-9])(?=.*[!@#%&])^([a-zA-Z0-9!@#%&]){6,}$")
#     if pwd_pattern.search(pwd) is None:
#         print("密码强度不够")
#     else:
#         break

# 2.3 解释：
# 上述正则表达式的意思：
#（1）首先是(?=.*[A-Z])匹配，.*表示密码中可以包含多个字符，[A-Z]代表密码中需要包含至少一个大写字母，注意一定不要去掉.*写成(?=[A-Z]),那样表示密码只能由一个字符组成，该字符是大写字母
#（2）其次是(?=.*[a-z])匹配，同上，确保密码中必须至少有一个小写字母
#（3）然后是(?=.*[0-9])匹配，同上，确保密码中必须至少有一个数字
#（4）然后是(?=.*[!@#%&])匹配，同上，，确保密码中必须至少有一个特殊符号!@#%&

#（5）最后是^([a-zA-Z0-9!@#%&]){6,}$，确保密码是由[a-zA-Z0-9!@#%&]字符构成，至少有6位


# 3、匹配email
# print(re.findall("(?:[a-zA-Z0-9]+)@(?:[0-9a-zA-Z]+).com","18611323113@163.com xxx@qq.com"))

# 4、匹配身份证
# your_id=input(">>: ").strip()
# print(re.findall("^([0-9]){17}([0-9]|X)$",your_id)) # 17个数字组成，最后一个字符可以是数字或X

# 5、匹配用户名，包含字母或者数字,且8位
# print(re.findall("^[0-9a-zA-Z]{8}$","egonlinh"))

# 5.1、要求输入的内容只能是汉字
# name=input(‘>>: ‘).strip()
# print(re.search(r‘[\u4E00-\u9fa5]+‘,name))

# 6、取出字符串里的数字
# print(re.findall(r‘\d+(?:\.\d+)?‘, ‘sww123kw11.333e2lkd‘))

# 7、取出所有负整数
# print(re.findall(r‘-\d+‘, ‘-12,3,54,-13.11,64，-9‘))  # 错误答案
# print(re.findall(r‘(?!-\d+\.\d+)-\d+‘, ‘-12,3,54,-13.11,64，-9‘))  # 正确答案

# 8、所有数字
# print(re.findall(r‘\-?\d+(?:\.\d+)?‘, ‘-12.9,3.92,54.11,64，89，-9，-45.2‘))

# 9、所有负数
# print(re.findall(r‘\-\d+(?:\.\d+)?‘, ‘-12.9,3.92,54.11,64，89，-9，-45.2‘))

# 10、所有的非负浮点数
print(re.findall(r‘\d+\.\d+‘, ‘-12.9,3.92,54.11,64，89，-9，-45.2‘))

# 11、
msg = """
中文名 贝拉克·侯赛因·奥巴马 
外文名 Barack Hussein Obama II 
别名 欧巴马 
性 别 男
国籍 美国 
民 族 德裔族 
出生地 美国夏威夷州檀香山 
出生日期 1961年8月4日 
职 业政治家、律师、总统 
毕业院校 哥伦比亚大学，哈佛大学 
信 仰新教 
主要成就 1996年伊利诺伊州参议员 
主要成就 美国第56届、57届总统 2009年诺贝尔和平奖获得者 时代周刊年度风云人物2008、2011 任期内清除本·拉登 
代表作品 《我相信变革》《我父亲的梦想》《无畏的希望》 
所属政党美国民主党 
血 型 AB型 
学 院西方学院 
妻 子 米歇尔·拉沃恩·奥巴马 

"""
#外文名
print(re.findall("外文名 (.*)",msg))

#出生日期
print(re.findall(‘出生日期 (\d{4})年(\d+)月(\d+)日‘,msg))

#妻子姓名
print(re.findall(‘妻 子 (\S+)‘,msg))