#!/usr/bin/env python
#-*- coding:utf-8 -*-import randomdef v_code():code = ''for i in range(5):      # 验证码位数num=random.randint(0,9)alf=chr(random.randint(65,90))add=random.choice([num,alf])code += str(add)return codeprint(v_code())

#!/usr/bin/env python
#-*- coding:utf-8 -*-import os
# 在Linux和Mac平台上，该函数会原样返回path，在windows平台上会将路径中所有字符转换为小写，并将所有斜杠转换为反斜杠。
print(os.path.normcase('c:/windows\\system32\\'))
'''
os.path.normcase('c:/windows\\system32\\')
'''# 规范化路径，如..和 /
print(os.path.normpath('c://windows\\System32\\../Temp/'))
'''
c:\windows\Temp
'''path = '/Users/shuke/data/\\file/\\\\update.py/../..'
print(os.path.normpath(path))
'''
\Users\shuke\data

#方式一：推荐使用
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__))))

import sys,timefor i in range(50):sys.stdout.write('%s\r' %('#'*i))sys.stdout.flush()time.sleep(0.1)'''
注意：在pycharm中执行无效，请到命令行中以脚本的方式执行
'''进度条

#!/usr/bin/env python
#-*- coding:utf-8 -*-import shutil# 1.shutil.copyfileobj(fsrc, fdst[, length])
# 将文件内容拷贝到另一个文件中,可以copy指定大小的内容
shutil.copyfileobj(open('Readme','r'),open('Readme_bak','w'))# 2.shutil.copyfile(src, dst)
# 拷贝文件
shutil.copyfile('login.log','login_2017-06-05')# 3.shutil.copymode(src, dst)
# 仅拷贝权限。内容、组、用户均不变
shutil.copymode('login.log','login_2017-06-05')     # 文件必须存在# 4.shutil.copystat(src, dst)
# 仅拷贝状态的信息，包括：mode bits, atime, mtime, flags
shutil.copystat('Readme','Readme_bak')# 5.shutil.copy(src, dst)
# 拷贝文件和权限
shutil.copy('Readme','Readme_bk')# 6.shutil.copy2(src, dst)
# 拷贝文件和状态信息
shutil.copy2('Readme','Readme_bk')# 7.shutil.ignore_patterns(*patterns)
# shutil.copytree(src, dst, symlinks=False, ignore=None)
# 递归的去拷贝目录,以及软连接的处理方式
shutil.copytree('E:\YQLFC\study\day06\study','E:\YQLFC\study\day06\study01',ignore=shutil.ignore_patterns('*.log'))
'''
注意: 目标目录不能存在，注意对folder2目录父级目录要有可写权限，ignore的意思是排除
'''
shutil.copytree('E:\YQLFC\study\day06\study','E:\YQLFC\study\day06\study01',symlinks=True,ignore=shutil.ignore_patterns('*.log'))
'''
注意: 通常的拷贝都把软连接拷贝成硬链接，即对待软连接来说，创建新的文件
'''# 8.shutil.rmtree(path[, ignore_errors[, onerror]])
# 递归的去删除文件
shutil.rmtree(r'E:\YQLFC\study\day06\study01')# 9.shutil.move(src, dst)
# 递归的去移动文件，它类似mv命令，其实就是重命名。
shutil.move(r'E:\YQLFC\study\day06\study01',r'E:\YQLFC\study\day06\study02')

import zipfile# 压缩
z = zipfile.ZipFile('study.zip', 'w')       # 包名
z.write('login.log')                        # 将指定文件压缩至压缩包中
z.write('Readme')
z.close()# 解压
z = zipfile.ZipFile('study.zip', 'r')
z.extractall(path='.')                    # 解压路径，可以指定，默认当前
z.close()

import tarfile# 压缩
t=tarfile.open('/tmp/study.tar','w')
t.add('/data/study/Readme',arcname='Readme_bk')
t.add('/data/study/login.log',arcname='login.log_bk')
t.close()# 解压
t=tarfile.open('/tmp/study.tar','r')
t.extractall('/data/tmp')
t.close()

import json# ********dumps&&loads搭配使用***********
# 1. 序列化
dic = {'name': 'alvin', 'age': 23, 'sex': 'male'}
j = json.dumps(dic)
print(type(j))  # <class 'str'># 将dumps后的str类型的数据写入文件
f = open('info.json', 'w')
f.write(j)                          # 等价于json.dump(dic,f)
f.close()# 2.反序列化(读取数据加载到内存中)
f = open('info.json')
data = json.loads(f.read())  # 等价于data=json.load(f)

# ********dump&&load搭配使用***********
# (大多应用于将内存中的数据保存至本地存储进行读写操作时)
# 1. 序列化
dic = {'name': 'alvin', 'age': 23, 'sex': 'male'}
json.dump(dic,open('info1.json','w'))# 2. 反序列化
data=json.load(open('info1.json','r'))
print(data,type(data))
'''
执行结果:
{'age': 23, 'sex': 'male', 'name': 'alvin'} <class 'dict'>
'''

import pickledic = {'name': 'alvin', 'age': 23, 'sex': 'male'}# 1. 序列化
p = pickle.dumps(dic)
print(type(p))          # <class 'bytes'>
f = open('info.pkl', 'wb')          # 注意是w是写入str,wb是写入bytes,p是'bytes'类型
f.write(p)                          # 等价于pickle.dump(dic,f)
f.close()# 2.反序列化
import pickle
f = open('info.pkl', 'rb')
data = pickle.loads(f.read())       # 等价于data=pickle.load(f)
print(data,type(data),data['age'])
'''
{'age': 23, 'sex': 'male', 'name': 'alvin'} <class 'dict'> 23
'''

import pickledic = {'name': 'shuke', 'age': 23, 'sex': 'male'}
# 1. 序列化
pickle.dump(dic,open('info.pkl','wb'))# 反序列化
data=pickle.load(open('info.pkl','rb'))
print(data,data['name'])
'''
{'sex': 'male', 'age': 23, 'name': 'shuke'} shuke
'''

<?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>xml数据

import xml.etree.ElementTree as ETtree = 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 ETtree = ET.parse("xmltest.xml")
root = tree.getroot()#修改
for node in root.iter('year'):new_year=int(node.text)+1node.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 ETnew_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[Block]
zoneid = 4000
opendatasys = True[db]
dbhost = 192.168.1.100
dbuser = root
dbpassword = 123456
dbadmin = admin[center]
centerhost = 127.0.0.1
centerport = 42000[gateway]
host = 192.168.1.101
transferport = 40001

#!/usr/bin/env python
#-*- coding:utf-8 -*-import configparserconfig=configparser.ConfigParser()
config.read('settings.ini')# 查看所有的标题
res=config.sections()
print(res)              # ['Block', 'log', 'db', 'center']#查看标题Block下所有key=value的key
options=config.options('Block')
print(options)              # ['zoneid', 'opendatasys']# 查看标题db下所有key=value的(key,value)格式
item_list=config.items('db')
print(item_list)             # [('dbhost', '192.168.1.100'), ('dbuser', 'root'), ('dbpassword', '123456'), ('dbadmin', 'admin')]#查看标题log下BEBUG的值=>字符串格式
val=config.get('log','DEBUG')
print(val)              # 0; 字符串格式#查看标题Block下ZONEID的值=>整数格式
val1=config.getint('Block','ZONEID')
print(val1)                         # 40002; 整数#查看标题Block下的opendatasys值=>布尔值格式
val2=config.getboolean('Block','opendatasys')
print(val2)                         # True; 布尔值True#查看标题center下CENTERPORT的值=>浮点型格式
val3=config.getfloat('center','CENTERPORT')
print(val3)                         # 42000.0; 浮点数

import configparserconfig=configparser.ConfigParser()
config.read('settings.ini',encoding='utf-8')# 删除整个标题Block
config.remove_section('log')# 删除标题center下的某个CENTERHOST和CENTERPORT
config.remove_option('center','CENTERHOST')
config.remove_option('center','CENTERPORT')# 判断是否存在某个标题
print(config.has_section('log'))#判断标题Block下是否有GAMEID
print(config.has_option('Block','GAMEID'))#添加一个标题
# config.add_section('gateway')# 在标题gateway下添加HOST=192.168.1.101,TRANSFERPORT=40001的配置
config.set('gateway','HOST','192.168.1.101')
config.set('gateway','TRANSFERPORT','40001')            # 正确
config.set('gateway','TRANSFERPORT',40001)              # 报错,必须是字符串数据类型#最后将修改的内容写入文件,完成最终的修改
config.write(open('settings.ini','w'))

import configparser
config=configparser.ConfigParser()
config.read('settings.ini',encoding='utf-8')#添加节点
config.add_section('global')                    # 已经存在则报错
config['global']['username']='shuke'
config['global']['passwd']='123456'
config.write(open('settings.ini','w'))          # 将修改写入文件保存#删除节点
config.remove_section('global')                 # 删除节点section
config.remove_option('global','host')           # 删除节点section下的某一个option(key)
config.write(open('settings.ini','w'))# 修改
config.set('Block','zoneid','4000')
config.write(open('settings.ini','w'))#检查
has_sec=config.has_section('Block')
print(has_sec)                                  # True
has_sec=config.has_option('Block','zoneid')     # Block下是否有一个键zoneid
print(has_sec)                                  # True

[DEFAULT]
host = 127.0.0.1
port = 3306[db_root]
user = root
pass = root[db_huey]
host = 192.168.1.101
user = huey
pass = huey

import configparsercp = configparser.ConfigParser()
cp.read('db.conf')print(cp.get('db_root', 'host'))    # 127.0.0.1
print(cp.get('db_huey', 'host'))   # 192.168.1.101

[DEFAULT]
url = %(protocol)s://%(server)s:%(port)s/[http]
protocol = http
server = localhost
port = 8080[ftp]
url = %(protocol)s://%(server)s/
protocol = ftp
server = 192.168.1.102

import configparsercp = configparser.ConfigParser()
cp.read('url.conf')print(cp.get('http', 'url'))    # http://localhost:8080/
print(cp.get('ftp', 'url'))    # ftp://192.168.1.102/

#!/usr/bin/env python
#-*- coding:utf-8 -*-import hashlibstring = "HelloWorld"
# ######## md5 ########
md5 = hashlib.md5()
md5.update(string.encode('utf-8'))     # 注意转码
res = md5.hexdigest()
print("md5加密结果:",res)# ######## sha1 ########
sha1 = hashlib.sha1()
sha1.update(string.encode('utf-8'))
res = sha1.hexdigest()
print("sha1加密结果:",res)# ######## sha256 ########
sha256 = hashlib.sha256()
sha256.update(string.encode('utf-8'))
res = sha256.hexdigest()
print("sha256加密结果:",res)# ######## sha384 ########
sha384 = hashlib.sha384()
sha384.update(string.encode('utf-8'))
res = sha384.hexdigest()
print("sha384加密结果:",res)# ######## sha512 ########
sha512= hashlib.sha512()
sha512.update(string.encode('utf-8'))
res = sha512.hexdigest()
print("sha512加密结果:",res)# ######## 注意 ########
m = hashlib.md5()
m.update('Hello'.encode('utf8'))
print('Hello的md5值: ',m.hexdigest())         # Hello字符串的md5值

m.update('World'.encode('utf8'))
print('World的md5值: ',m.hexdigest())         # World字符串的md5值

m2 = hashlib.md5()
m2.update('HelloWorld'.encode('utf8'))
print('HelloWorld的md5值: ',m2.hexdigest())   # HelloWorld字符串的md5值'''
md5加密结果: 68e109f0f40ca72a15e05cc22786f8e6
sha1加密结果: db8ac1c259eb89d4a131b253bacfca5f319d54f2
sha256加密结果: 872e4e50ce9990d8b041330c47c9ddd11bec6b503ae9386a99da8584e9bb12c4
sha384加密结果: 293cd96eb25228a6fb09bfa86b9148ab69940e68903cbc0527a4fb150eec1ebe0f1ffce0bc5e3df312377e0a68f1950a
sha512加密结果: 8ae6ae71a75d3fb2e0225deeb004faf95d816a0a58093eb4cb5a3aa0f197050d7a4dc0a2d5c6fbae5fb5b0d536a0a9e6b686369fa57a027687c3630321547596
Hello的md5值:  8b1a9953c4611296a827abf8c47804d7
World的md5值:  68e109f0f40ca72a15e05cc22786f8e6
HelloWorld的md5值:  68e109f0f40ca72a15e05cc22786f8e6
'''

import hashlib
passwds=['alex3714','alex1313','alex94139413','alex123456','123456alex','a123lex',]
def make_passwd_dic(passwds):dic={}for passwd in passwds:m=hashlib.md5()m.update(passwd.encode('utf-8'))dic[passwd]=m.hexdigest()return dicdef break_code(cryptograph,passwd_dic):for k,v in passwd_dic.items():if v == cryptograph:print('密码是===>\033[46m%s\033[0m' %k)cryptograph='aee949757a2e698417463d47acac93df'
break_code(cryptograph,make_passwd_dic(passwds))模拟撞库破解密码

subprocess.Popen(args, bufsize=0, executable=None,stdin=None,stdout=None, stderr=None, preexec_fn=None, close_fds=False, shell=False, cwd=None, env=None, universal_newlines=False, startupinfo=None, creationflags=0)1)、args可以是字符串或者序列类型（如：list，元组），用于指定进程的可执行文件及其参数。如果是序列类型，第一个元素通常是可执行文件的路径。我们也可以显式的使用executeable参数来指定可执行文件的路径。
2)、bufsize：指定缓冲。0 无缓冲,1 行缓冲,其他 缓冲区大小,负值 系统缓冲(全缓冲)
3)、stdin, stdout, stderr分别表示程序的标准输入、输出、错误句柄。他们可以是PIPE，文件描述符或文件对象，也可以设置为None，表示从父进程继承。
4)、preexec_fn只在Unix平台下有效，用于指定一个可执行对象（callable object），它将在子进程运行之前被调用。
5)、Close_sfs：在windows平台下，如果close_fds被设置为True，则新创建的子进程将不会继承父进程的输入、输出、错误管道。我们不能将close_fds设置为True同时重定向子进程的标准输入、输出与错误(stdin, stdout, stderr)。
6)、shell设为true，程序将通过shell来执行。
7)、cwd用于设置子进程的当前目录
8)、env是字典类型，用于指定子进程的环境变量。如果env = None，子进程的环境变量将从父进程中继承。
Universal_newlines:不同操作系统下，文本的换行符是不一样的。如：windows下用'/r/n'表示换，而Linux下用'/n'。如果将此参数设置为True，Python统一把这些换行符当作'/n'来处理。startupinfo与createionflags只在windows下用效，它们将被传递给底层的CreateProcess()函数，用于设置子进程的一些属性，如：主窗口的外观，进程的优先级等等。
9)、startupinfo与createionflags只在windows下有效，它们将被传递给底层的CreateProcess()函数，用于设置子进程的一些属性，如：主窗口的外观，进程的优先级等等。
Popen方法
1)、Popen.poll()：用于检查子进程是否已经结束。设置并返回returncode属性。
2)、Popen.wait()：等待子进程结束。设置并返回returncode属性。
3)、Popen.communicate(input=None)：与子进程进行交互。向stdin发送数据，或从stdout和stderr中读取数据。可选参数input指定发送到子进程的参数。Communicate()返回一个元组：(stdoutdata, stderrdata)。注意：如果希望通过进程的stdin向其发送数据，在创建Popen对象的时候，参数stdin必须被设置为PIPE。同样，如果希望从stdout和stderr获取数据，必须将stdout和stderr设置为PIPE。
4)、Popen.send_signal(signal)：向子进程发送信号。
5)、Popen.terminate()：停止(stop)子进程。在windows平台下，该方法将调用Windows API TerminateProcess（）来结束子进程。
6)、Popen.kill()：杀死子进程。
7)、Popen.stdin：如果在创建Popen对象是，参数stdin被设置为PIPE，Popen.stdin将返回一个文件对象用于策子进程发送指令。否则返回None。
8)、Popen.stdout：如果在创建Popen对象是，参数stdout被设置为PIPE，Popen.stdout将返回一个文件对象用于策子进程发送指令。否则返回None。
9)、Popen.stderr：如果在创建Popen对象是，参数stdout被设置为PIPE，Popen.stdout将返回一个文件对象用于策子进程发送指令。否则返回None。
10)、Popen.pid：获取子进程的进程ID。
11)、Popen.returncode：获取进程的返回值。如果进程还没有结束，返回None。
12)、subprocess.call(*popenargs, **kwargs)：运行命令。该函数将一直等待到子进程运行结束，并返回进程的returncode。文章一开始的例子就演示了call函数。如果子进程不需要进行交互,就可以使用该函数来创建。
13)、subprocess.check_call(*popenargs, **kwargs)：与subprocess.call(*popenargs, **kwargs)功能一样，只是如果子进程返回的returncode不为0的话，将触发CalledProcessError异常。在异常对象中，包括进程的returncode信息。

#!/usr/bin/env python
#-*- coding:utf-8 -*-import  subprocess'''
sh-3.2# ls /Users/egon/Desktop |grep txt$
mysql.txt
tt.txt
事物.txt
'''# 模拟管道操作
res1=subprocess.Popen('ls /Users/jieli/Desktop',shell=True,stderr=subprocess.PIPE,stdout=subprocess.PIPE)      # stderr为标准错误输出,stdout为标准输出
res=subprocess.Popen('grep txt$',shell=True,stdin=res1.stdout,                                                 # 将res1的stdout作为res的stdinstdout=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 E:\YQLFC\study\day06',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解码

#!/usr/bin/env python
#-*- coding:utf-8 -*-import logginglogging.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('warning')
logging.error('error')
logging.critical('critical')
logging.log(10,'log')       # 如果level=40,则只有logging.critical和loggin.error的日志会被打印

import paramikotransport = paramiko.Transport(('hostname', 22))
transport.connect(username='shuke', password='123')ssh = paramiko.SSHClient()
ssh._transport = transportstdin, stdout, stderr = ssh.exec_command('df')
print stdout.read()transport.close()

import paramikoprivate_key = paramiko.RSAKey.from_private_key_file('/home/auto/.ssh/id_rsa')# 创建SSH对象
ssh = paramiko.SSHClient()
# 允许连接不在know_hosts文件中的主机
ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
# 连接服务器
ssh.connect(hostname='c1.salt.com', port=22, username='shuke', key=private_key)# 执行命令
stdin, stdout, stderr = ssh.exec_command('df')
# 获取命令结果
result = stdout.read()# 关闭连接
ssh.close()

import paramikoprivate_key = paramiko.RSAKey.from_private_key_file('/home/auto/.ssh/id_rsa')transport = paramiko.Transport(('hostname', 22))
transport.connect(username='shuke', pkey=private_key)ssh = paramiko.SSHClient()
ssh._transport = transportstdin, stdout, stderr = ssh.exec_command('df')transport.close()

import paramiko
from io import StringIOkey_str = """-----BEGIN RSA PRIVATE KEY-----
MIIEpQIBAAKCAQEAq7gLsqYArAFco02/55IgNg0r7NXOtEM3qXpb/dabJ5Uyky/8
NEHhFiQ7deHIRIuTW5Zb0kD6h6EBbVlUMBmwJrC2oSzySLU1w+ZNfH0PE6W6fans
H80whhuc/YgP+fjiO+VR/gFcqib8Rll5UfYzf5H8uuOnDeIXGCVgyHQSmt8if1+e
7hn1MVO1Lrm9Fco8ABI7dyv8/ZEwoSfh2C9rGYgA58LT1FkBRkOePbHD43xNfAYC
tfLvz6LErMnwdOW4sNMEWWAWv1fsTB35PAm5CazfKzmam9n5IQXhmUNcNvmaZtvP
c4f4g59mdsaWNtNaY96UjOfx83Om86gmdkKcnwIDAQABAoIBAQCnDBGFJuv8aA7A
ZkBLe+GN815JtOyye7lIS1n2I7En3oImoUWNaJEYwwJ8+LmjxMwDCtAkR0XwbvY+
c+nsKPEtkjb3sAu6I148RmwWsGncSRqUaJrljOypaW9dS+GO4Ujjz3/lw1lrxSUh
IqVc0E7kyRW8kP3QCaNBwArYteHreZFFp6XmtKMtXaEA3saJYILxaaXlYkoRi4k8
S2/K8aw3ZMR4tDCOfB4o47JaeiA/e185RK3A+mLn9xTDhTdZqTQpv17/YRPcgmwz
zu30fhVXQT/SuI0sO+bzCO4YGoEwoBX718AWhdLJFoFq1B7k2ZEzXTAtjEXQEWm6
01ndU/jhAasdfasdasdfasdfa3eraszxqwefasdfadasdffsFIfAsjQb4HdkmHuC
OeJrJOd+CYvdEeqJJNnF6AbHyYHIECkj0Qq1kEfLOEsqzd5nDbtkKBte6M1trbjl
HtJ2Yb8w6o/q/6Sbj7wf/cW3LIYEdeVCjScozVcQ9R83ea05J+QOAr4nAoGBAMaq
UzLJfLNWZ5Qosmir2oHStFlZpxspax/ln7DlWLW4wPB4YJalSVovF2Buo8hr8X65
lnPiE41M+G0Z7icEXiFyDBFDCtzx0x/RmaBokLathrFtI81UCx4gQPLaSVNMlvQA
539GsubSrO4LpHRNGg/weZ6EqQOXvHvkUkm2bDDJAoGATytFNxen6GtC0ZT3SRQM
WYfasdf3xbtuykmnluiofasd2sfmjnljkt7khghmghdasSDFGQfgaFoKfaawoYeH
C2XasVUsVviBn8kPSLSVBPX4JUfQmA6h8HsajeVahxN1U9e0nYJ0sYDQFUMTS2t8
RT57+WK/0ONwTWHdu+KnaJECgYEAid/ta8LQC3p82iNAZkpWlGDSD2yb/8rH8NQg
9tjEryFwrbMtfX9qn+8srx06B796U3OjifstjJQNmVI0qNlsJpQK8fPwVxRxbJS/
pMbNICrf3sUa4sZgDOFfkeuSlgACh4cVIozDXlR59Z8Y3CoiW0uObEgvMDIfenAj
98pl3ZkCgYEAj/UCSni0dwX4pnKNPm6LUgiS7QvIgM3H9piyt8aipQuzBi5LUKWw
DlQC4Zb73nHgdREtQYYXTu7p27Bl0Gizz1sW2eSgxFU8eTh+ucfVwOXKAXKU5SeI
+MbuBfUYQ4if2N/BXn47+/ecf3A4KgB37Le5SbLDddwCNxGlBzbpBa0=
-----END RSA PRIVATE KEY-----"""private_key = paramiko.RSAKey(file_obj=StringIO(key_str))
transport = paramiko.Transport(('10.0.1.40', 22))
transport.connect(username='shuke', pkey=private_key)ssh = paramiko.SSHClient()
ssh._transport = transportstdin, stdout, stderr = ssh.exec_command('df')
result = stdout.read()transport.close()print(result)

#!/usr/bin/env python
# -*- coding:utf-8 -*-
import paramiko
import uuidclass Haproxy(object):def __init__(self):self.host = '172.16.103.191'self.port = 22self.username = 'shuke'self.pwd = '123'self.__k = Nonedef create_file(self):file_name = str(uuid.uuid4())with open(file_name,'w') as f:f.write('sb')return file_namedef run(self):self.connect()self.upload()self.rename()self.close()def connect(self):transport = paramiko.Transport((self.host,self.port))transport.connect(username=self.username,password=self.pwd)self.__transport = transportdef close(self):self.__transport.close()def upload(self):# 连接，上传file_name = self.create_file()sftp = paramiko.SFTPClient.from_transport(self.__transport)# 将location.py 上传至服务器 /tmp/test.pysftp.put(file_name, '/home/wupeiqi/tttttttttttt.py')def rename(self):ssh = paramiko.SSHClient()ssh._transport = self.__transport# 执行命令stdin, stdout, stderr = ssh.exec_command('mv /home/wupeiqi/tttttttttttt.py /home/shuke/ooooooooo.py')# 获取命令结果result = stdout.read()ha = Haproxy()
ha.run()Demo

#!/usr/bin/env python
#-*- coding:utf-8 -*-import re# =================================匹配模式=================================
# 一对一的匹配
print('hello'.replace('ll','gg'))   # heggo  用new字符串替换掉old字符串
print('hello'.find('ll'))   # 2  匹配到的索引位置# ******正则匹配******
str = "Hello shuke, 123"
# \w与\W
print(re.findall('\w',str))     # ['H', 'e', 'l', 'l', 'o', 's', 'h', 'u', 'k', 'e', '1', '2', '3']
print(re.findall('\W',str))     # [' ', ',', ' ']# \s与\S
print(re.findall('\s',str)) # [' ', ' ']
print(re.findall('\S',str)) # ['H', 'e', 'l', 'l', 'o', 's', 'h', 'u', 'k', 'e', ',', '1', '2', '3']# \d与\D
print(re.findall('\d',str)) # ['1', '2', '3']
print(re.findall('\D',str)) # ['H', 'e', 'l', 'l', 'o', ' ', 's', 'h', 'u', 'k', 'e', ',', ' ']#\A与\Z
print(re.findall('\AHe',str)) # ['He']
print(re.findall('123\Z',str)) # ['123']#\n与\t
print(re.findall(r'\n','Hello shuke \n123')) # ['\n']
print(re.findall(r'\t','Hello shuke\t123')) # ['\t']#^与$
print(re.findall('^H',str)) #['H']
print(re.findall('3$',str)) #['3']# 重复匹配：| . | * | ? | .* | .*? | + | {n,m} |
#.
print(re.findall('a.b','a1b abc a*b a$b')) # ['a1b', 'a*b', 'a$b']
print(re.findall('a.b','a\nb'))     # []   .不能匹配到\n符
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('He*','hello '))   # []
print(re.findall('He*',str))    # ['He']
print(re.findall('ab*','b ab abbbb'))   # ['ab', 'abbbb']#?
print(re.findall('He?',str))    # ['He']
print(re.findall('ab?','abbb'))     # ['ab']#匹配所有包含小数在内的数字
print(re.findall('\d+\.?\d*',"asd123fd1.23asdls12dkk3.4esf5"))      # ['123', '1.23', '12', '3.4', '5']#.* 默认为贪婪匹配
print(re.findall('a.*b','a1b222ahjhsk22222b'))  # ['a1b222ahjhsk22222b']#.*?为非贪婪匹配：推荐使用
print(re.findall('a.*?b','a1b222ahjhsk22222b'))     # ['a1b', 'ahjhsk22222b']#+
print(re.findall('ab+','a accc'))   # []
print(re.findall('ab+','abbb'))     # ['abbb']#{n,m}
print(re.findall('ab{2}','abbb'))       # ['abb']
print(re.findall('ab{2,4}','abbb'))     # ['abbb']
print(re.findall('ab{1,}','abbb'))      # ['abbb'] 'ab{1,}' == 'ab+'
print(re.findall('ab{0,}','abbb'))      # ['abbb'] 'ab{0,}' == 'ab*'#[]
#[]内的都为普通字符了，且如果-没有被转意的话，应该放到[]的开头或结尾
print(re.findall('a[1*-]b','a1b a*b a-b'))  # ['a1b', 'a*b', 'a-b']
#[]内的^代表的意思是取反，所以结果为['a=b']
print(re.findall('a[^1*-]b','a1b a*b a-b a=b'))     # ['a=b']
#[]内的^代表的意思是取反，所以结果为['a=b']
print(re.findall('a[0-9]b','a1b a*b a-b a=b'))      # ['a1b']
#[]内的^代表的意思是取反，所以结果为['a=b']
print(re.findall('a[a-z]b','a1b a*b a-b a=b aeb'))  # ['aeb']
#[]内的^代表的意思是取反，所以结果为['a=b']
print(re.findall('a[a-zA-Z]b','a1b a*b a-b a=b aeb aEb'))       # ['aeb', 'aEb']#\# print(re.findall('a\\c','a\c')) #对于正则来说a\\c确实可以匹配到a\c,但是在python解释器读取a\\c时，会发生转义，然后交给re去执行，所以抛出异常
#r代表告诉解释器使用rawstring，即原生字符串，把我们正则内的所有符号都当普通字符处理，不要转义
print(re.findall(r'a\\c','a\c'))        # ['a\\c']
#同上面的意思一样，和上面的结果一样都是['a\\c']
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
#findall的结果不是匹配的全部内容，而是组内的内容,?:可以让结果为匹配的全部内容
print(re.findall('(?:ab)+123','ababab123')) # ['ababab123']#|
print(re.findall('compan(?:y|ies)','Too many companies have gone bankrupt, and the next one is my company'))  # ['companies', 'company']

#!/usr/bin/env python
#-*- coding:utf-8 -*-import re# ===========================re模块提供的方法介绍===========================
str = 'Hello jack john shuke'
#1
print(re.findall('o',str) )   # ['o', 'o'],返回所有满足匹配条件的结果,放在列表里
#2
print(re.search('o',str).group())  # o,只到找到第一个匹配然后返回一个包含匹配信息的对象,该对象可以通过调用group()方法得到匹配的字符串,如果字符串没有匹配，则返回None。#3
print(re.match('o',str))    # None,同search,不过在字符串开始处进行匹配,完全可以用search+^代替match
print(re.search('^o',str))  # None,用search+^代替match#4
print(re.split('[ab]','abcd'))                     # ['', '', 'cd']，先按'a'分割得到''和'bcd',再对''和'bcd'分别按'b'分割
print(re.split('ke','jake shuke echo keke'))    # ['ja', ' shu', ' echo ', '', '']; 不带括号结果不包含分割的字符串
print(re.split('(ke)','jake shuke echo keke'))  # ['ja', 'ke', ' shu', 'ke', ' echo ', 'ke', '', 'ke', '']；带括号结果包含分割的字符串 #5
print('===>',re.sub('j','J',str))       # ===> Hello Jack John shuke，不指定n，默认替换所有
print('===>',re.sub('j','J',str,1))     # ===> Hello Jack john shuke  替换一次
print('===>',re.sub('j','J',str,2))     # ===> Hello Jack John shuke  替换二次
print('===>',re.sub('^(\w+)(.*?\s)(\w+)(.*?\s)(\w+)(.*?)$',r'\5\2\3\4\1',str))  # ===> john jack Hello
print('===>',re.subn('j','J',str))      # ===> ('Hello Jack John shuke', 2),结果带有总共替换的次数#6
obj=re.compile('\d{2}')print(obj.search('abc123eeee').group())     # 12
print(obj.findall('abc123eeee'))            # ['12'],重用了obj

#!/usr/bin/env python
#-*- coding:utf-8 -*-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()) # {'tag_name': 'h1'}print(re.search(r"<(\w+)>\w+</(\w+)>","<h1>hello</h1>").group())    # <h1>hello</h1>
print(re.search(r"<(\w+)>\w+</\1>","<h1>hello</h1>").group())       # <h1>hello</h1>

#!/usr/bin/env python
#-*- coding:utf-8 -*-
import reprint(re.findall(r'-?\d+\.?\d*',"1-12*(60+(-40.35/5)-(-4*3))")) # ['1', '-12', '60', '-40.35', '5', '-4', '3'] 找出所有数字#使用|，先匹配的先生效，|左边是匹配小数，而findall最终结果是查看分组，所有即使匹配成功小数也不会存入结果
#而不是小数时，就去匹配(-?\d+)，匹配到的自然就是，非小数的数，在此处即整数
print(re.findall(r"-?\d+\.\d*|(-?\d+)","1-2*(60+(-40.35/5)-(-4*3))")) # ['1', '-2', '60', '', '5', '-4', '3'] 找出所有整数

#!/usr/bin/env python
#-*- coding:utf-8 -*-#在线调试工具:tool.oschina.net/regex/#
import re# 常规匹配
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())      # Hello 123 456 World_This is a Regex Demo
print(res.span())       # (0, 40)# 泛匹配
content='Hello 123 456 World_This is a Regex Demo'
res=re.match('^Hello.*Demo',content)
print(res.group())      # Hello 123 456 World_This is a Regex Demo# 匹配目标,获得指定数据
content='Hello 123 456 World_This is a Regex Demo'
res=re.match('^Hello\s(\d+)\s(\d+)\s.*Demo',content)
print(res.group())      # Hello 123 456 World_This is a Regex Demo; 匹配所有的内容
print(res.group(1))     # 123; 匹配第一个括号内的内容
print(res.group(2))     # 456; 匹配第二个括号内的内容# 贪婪匹配:.*代表匹配尽可能多的字符
content='Hello 123 456 World_This is a Regex Demo'
res=re.match('^He.*(\d+).*Demo$',content)
print(res.group(1)) # 6; 只打印6,因为.*会尽可能多的匹配,然后后面跟至少一个数字# 非贪婪匹配.*?匹配尽可能少的字符
content='Hello 123 456 World_This is a Regex Demo'
res=re.match('^He.*?(\d+).*Demo$',content)
print(res.group(1))     # 123; 因为.*?会尽可能少的匹配,至少有一个任意字符# 匹配模式:.不能匹配换行符
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))     # 123456#转义:\
content='price is $5.00'
res=re.match('price is $5.00',content)
print(res)      # None

res=re.match('price is \$5\.00',content)
# print(res)
print(res.group())      # price is $5.00# *********总结:尽量精简,详细的如下*********# 尽量使用泛匹配模式.*# 尽量使用非贪婪模式:.*?# 使用括号得到匹配目标:用group(n)去取得结果# 有换行符就用re.S:修改模式# ***********re.search************
# re.search:会扫描整个字符串,不会从头开始,找到第一个匹配的结果就会返回
content='Extra strings Hello 123 456 World_This is a Regex Demo Extra strings'
res=re.match('Hello.*?(\d+).*?Demo',content)
# print(res)      # 输出结果为None

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))         # 123; 扫描整个字符串进行匹配# re.search:只要一个结果
content='''<tbody><tr id="4766303201494371851675" class="even "><td><div class="hd"><span class="num">1</span><div class="rk "><a href="/song?id=476630320"><img class="rpic" src="http://www.baidu.com></a><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&amp;quality=100"></a><span data-res-id="476630320"'''
res=re.search('<a\shref=.*?\<\/a\>',content)
print(res.group())      # <a href="/song?id=476630320"><img class="rpic" src="http://www.baidu.com></a>; 匹配成功就立刻返回，失败则返回None# re.findall:找到符合条件的所有结果
res=re.findall('<a\shref=.*?\<\/a\>',content)
print(res)      # 返回一个列表
for i in res:print(i)
'''
输出结果
['<a href="/song?id=476630320"><img class="rpic" src="http://www.baidu.com></a>', '<a href="/song?id=476630320"><img class="rpic" src="http://p1.music.126.net/Wl7T1LBRhZFg0O26nnR2iQ==/19217264230385030.jpg?param=50y50&amp;quality=100"></a>']
<a href="/song?id=476630320"><img class="rpic" src="http://www.baidu.com></a>
<a href="/song?id=476630320"><img class="rpic" src="http://p1.music.126.net/Wl7T1LBRhZFg0O26nnR2iQ==/19217264230385030.jpg?param=50y50&amp;quality=100"></a>
'''# *********re.sub:字符串替换********
# re.search函数会在字符串内查找模式匹配,只到找到第一个匹配然后返回，如果字符串没有匹配，则返回None。
content='Extra strings Hello 123 456 World_This is a Regex Demo Extra strings'
content=re.sub('\d+','',content)
print(content)      # Extra strings Hello   World_This is a Regex Demo Extra strings;将数字替换为空# 用\1取得第一个括号的内容
# 用法:将123与456换位置
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)# 带命名的组:\g
content = "hello shuke, nihao shuke";
res = re.sub(r"hello (\w+), nihao \1", "\g<1>", content);
print("replacedStr=",res)       # replacedStr= shuke 明名组的用法: 反斜杠加g以及中括号内一个名字，即：\g<name>，对应着命了名的组，named group# 带命名的组:named group
content = "hello shuke, nihao shuke";
res = re.sub(r"hello (?P<name>\w+), nihao (?P=name)", "\g<name>", content);
print("replacedStr=",res)       # replacedStr= shuke# 匹配一次
content='Extra strings Hello 123 456 World_This is a Regex Demo Extra strings'
res=re.search('Extra.*?(\d+).*strings',content)
if res:print('res.group(0): ',res.group(0),'res.group(1): ',res.group(1))       # res.group(0):  Extra strings Hello 123 456 World_This is a Regex Demo Extra strings res.group(1):  123
else:print('not search')# 正则在爬虫的应用
import requests,rerespone=requests.get('https://book.douban.com/').text
# print(respone)
print('======'*100)
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()))示例

IP：
^(25[0-5]|2[0-4]\d|[0-1]?\d?\d)(\.(25[0-5]|2[0-4]\d|[0-1]?\d?\d)){3}$
手机号：
^1[3|4|5|8][0-9]\d{8}$
邮箱：
[a-zA-Z0-9_-]+@[a-zA-Z0-9_-]+(\.[a-zA-Z0-9_-]+)+