09 . Python3之常用模块

# 脚本方式:  直接用解释器执行,或者PyCharm中右键运行
# 模块方式:  被其他的模块导入,为导入他的模块提供资源(变量,函数定义,类定义等)

# 作用:  用来控制.py文件在不同的应用场景下执行不同的逻辑(或者是模块文件中测试代码)
# 在脚本方式运行时,__name__是固定的字符串:  '__main__'
# 在以模块方式导入时,__name__就是本模块的名字,通过name值决定自定义模块的可执行语句要不要执行

# 当我们引用一个模块时,不见得都可以import到

# python引用模块是按照一定规则及顺序去查找的,这个查询顺序为: 先从内存中已经加载的模块进行寻找，找不到再到内置模块中寻找，内置模块如果也没有，最后去sys.path中路径包含的模块中寻找，他只会按照这个顺序从指定的地方去寻找，如果始终没有找到，就会报错

# 模块的查找顺序
# 1. 在第一次导入某个模块时(比如test_module1),会先检查该模块是否已经被加载到内存中(当前执行文件的名称空间对应的内存),如果有则直接引用(python解释器启动时会加载一些模块到内存中，可以用sys.modules查看)

# 2. 如果没有,解释器则会查找同名的内置模块

# 3. 如果还没有找到就从sys.path给出的目录列表中依次寻找test_module1文件

# 需要注意是: 我们自定义的模块不应该与系统内置模块重名

# import module_demo1   				 导入一个模块的所有成员
# import module_demo1,demo2   			 一次性导入多个模块的成员
# from *** import module_demo3  		 从某个模块导入指定的成员
# from *** import module_demo3，demo4  	从某个模块导入多个指定成员
# from *** import *  					 从某个模块导入所有指定成员

import 导入和 from *** import * 的区别
# 第一种方式:  使用其中成员时,必须使用模块名作为前缀,不容易命名冲突
# 第二种方式:  不用使用模块名作为前缀，直接使用成员名即可,但是容易产生命名冲突,在后定义的成员生效(把前面的覆盖掉了)

# 解决名称冲突问题
# 1. 改用import  xxx这种方式导入
# 2. 自己避免使用同名
# 3. 使用别名解决冲突
# from module1 import demo1 as demo2
# 再使用时候需要使用demo2


# 将自定义模块的模块添加到sys.path中
import os
import sys
sys.path.appdend(os.path.dirname(__file__) + '/module1')

# 使用from * import * 的方式导入


# 相对导入同项目下的模块
from ..demo1  import demo2

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

print(time.time()) 					# 时间戳:1487130156.419527
print(time.strftime('[%Y-%m-%d %H:%M:%S]',time.localtime(time.time())))
									#格式化的时间字符串:'[2020-01-01 15:46:19]'
print(time.sleep(1),'延迟1s显示')     #延迟线程运行

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

# 时间戳(timestamp)：time.time()
# 延迟线程的运行：time.sleep(secs)
# (指定时间戳下的)当前时区时间：time.localtime([secs])
# (指定时间戳下的)格林威治时间：time.gmtime([secs])
# (指定时间元组下的)格式化时间：
# time.strftime(fmt[,tupletime])

%y 两位数的年份表示（00-99）
%Y 四位数的年份表示（000-9999）
%m 月份（01-12）
%d 月内中的一天（0-31）
%H 24小时制小时数（0-23）
%I 12小时制小时数（01-12）
%M 分钟数（00=59）
%S 秒（00-59）
%a 本地简化星期名称
%A 本地完整星期名称
%b 本地简化的月份名称
%B 本地完整的月份名称
%c 本地相应的日期表示和时间表示
%j 年内的一天（001-366）
%p 本地A.M.或P.M.的等价符
%U 一年中的星期数（00-53）星期天为星期的开始
%w 星期（0-6），星期天为星期的开始
%W 一年中的星期数（00-53）星期一为星期的开始
%x 本地相应的日期表示
%X 本地相应的时间表示
%Z 当前时区的名称
%% %号本身

#时间加减
import datetime

# print(datetime.datetime.now()) 				#返回当前时间 2019-05-13 14:27:59.947853
# print(datetime.date.fromtimestamp(time.time()))  # 时间戳直接转成日期格式 2019-05-13

# print(datetime.datetime.now())
# print(datetime.datetime.now() + datetime.timedelta(3)) #当前时间 +3天
# print(datetime.datetime.now() + datetime.timedelta(-3)) #当前时间-3天
# print(datetime.datetime.now() + datetime.timedelta(hours=3)) #当前时间+3小时
# print(datetime.datetime.now() + datetime.timedelta(minutes=30)) #当前时间+30分


# c_time  = datetime.datetime.now()
# print(c_time.replace(minute=3,hour=2)) #时间替换

2020-01-01 16:02:42.327739
2020-01-04 16:02:42.327739
2019-12-29 16:02:42.327739
2020-01-01 19:02:42.327739
2020-01-01 02:03:42.327739

import calendar
# 判断闰年
print(calendar.isleap(2000))
# 查看某年某月日历
print(calendar.month(2015,2))
# 查看某年某月起始星期与当月天数
print(calendar.monthrange(2015,2))
# 查看某年某月某日是星期几
print(calendar.weekday(2015,2,9))


True
February 2015 
Mo Tu We Th Fr Sa Su 
		   1 
2  3  4   5  6  7  8 
9  10 11 12 13 14 15 
16 17 18 19 20 21 22
 23 24 25 26 27 28
(6, 28)
0 # 0代表星期一

>>> import sys
>>> print(sys.argv)
['demo.py', 'one', 'two', 'three']

import sys
arg1 = int(sys.argv[1])
arg2 = int(sys.argv[2])
print(arg1+arg2)

>>> sys.stderr.write('Warning, log file not found starting a new one\n')  
Warning, log file not found starting a new one

# 大多脚本的定向终止都使用 "sys.exit()"。

import sys
print(0)
# sys.exit(0) # 退出运行0
print(123)
print(sys.version)					# 获取Python解释器程序版本信息
print(sys.maxsize)
print(sys.platform)
print(sys.argv)						# 命令行参数list，第一个程序是程序本身路径
print(sys.path)						# 返回模块的搜索路径，初始化使用pythonpath环境变量的值
print(sys.platform)					# 获取操作系统平台名称
print(sys.modules)					# 获取已经加载的模块


0		
123
3.7.2 (tags/v3.7.2:9a3ffc0492, Dec 23 2018, 22:20:52) [MSC v.1916 32 bit (Intel)]
2147483647
win32
['g:\\VSPython\\Day01\\Demo.py']
['g:\\VSPython\\Day01', `c:\\Users\\youmen\\.vscode.python-2019.11.50794\\pythonFiles, `

import os
os.mkdir('a') 							# 在当前目录创建一个a目录
os.removedirs('a')						# 删目录必须是空目录
os.makedirs('/opt/youmen/zhou')  		# 生成多层目录
os.rename("/opt/youmen","/opt/jian") 	# 重命名
print(os.getcwd())  					# 返回工作目录
os.chdir('/server/accesslogs')   		# 修改当前的工作迷路
os.listdir('/root/Python3') 			# 列举目录下所有资源
os.sep  								# 路径分隔符
os.linesep  							# 行终止符
os.pathsep  							# 文件分隔符
os.name  								# 操作系统名
os.environ 							    # 操作系统环境变量
os.system('sh /root/Python3/demo1.sh')  # 执行shell脚本
os.system('mkdir today')   				# 执行系统命令mkdir

# 一般删除文件夹使用os库，然后利用os.remove(path)，如果删除非空文件夹使用os.removedirs(path)即可,
# 但如果删除整个文件夹，且文件夹非空时候使用os.removedirs(path)就会报错了，
# 此时可使用shutil库，该库为python内置库，是一个对文件及文件夹高级操作的库，
# 可以与os库互补成一些操作，如果文件夹整体赋值，移动文件夹，文件重命名等.
import os 
import shutil 
os.remove(path) #删除文件 
os.removedirs(path) #删除空文件夹 
shutil.rmtree(path) #递归删除文件夹

import shutil
# 基于路径的文件复制:
#shutil.copyfile('/opt/zhou','/root/Python3/jian.txt')

# 基于流的文件复制:
# with open('source_file','rb') as r,open('target_file','wb') as w:
#    shutil.copyfileobj(r,w)

# 文件移动
# shutil.remove('/jian.txt','/tmp/')

# 文件夹压缩
# etc: 压缩后的文件名,会自己加上压缩格式的后缀: 
# 压缩格式 archive_path:  'tar','zep'
# 要压缩的文件夹路径: /etc
shutil.make_archive('etc','tar','/etc/')


# etc.tar: 解压的文件  etc: 解压后的文件名 tar: 解压格式
shutil.unpack_archive('etc.tar','etc','tar')

>>> import zlib
>>> s = b'witch which has which witches wrist watch'
>>> len(s)
41
>>> t = zlib.compress(s)
>>> len(t)
37
>>> zlib.decompress(t)
b'witch which has which witches wrist watch'
>>> zlib.crc32(s)
226805979

import os
print(__file__)  # 执行文件的当前路径.
print(os.path.abspath('/root/Python3'))  # 返回path规范化的绝对路径
print(os.path.split('/root/Python3/python_os_demo.py'))  # 将path分割成目录和文件名二元组返回
print(os.path.dirname('/root/Python3'))  # 上一级目录
print(os.path.basename('/root/Python3'))  # 最后一级名称
print(os.path.exists('/root/Python3'))  # 指定路径是否存在
print(os.path.isabs('root/'))  # 是否为绝对路径
print(os.path.isfile('/root/Python3/demo1.sh'))  # 是否为文件
print(os.path.isdir('/root/'))  # 是否为路径
print(os.path.getatime('/root/Python3/demo1.sh'))  # 最后存取修改时间
print(os.path.getsize('/root/Python3/demo1.sh'))  # 目标大小

python3 python_mode_os_demo.py
python_mode_os_demo.py
/root/Python3
('/root/Python3', 'python_os_demo.py')  
# 在Linux和Mac平台上，该函数会原样返回path,在Windows平台上会把路径所有字符变为小写，并且将斜杠转换为反斜杠
/root
Python3
True
False
True
True
1577869829.141
43

# 并不是真的随机数，官方有说只是一个伪随机数

import random
print(random.random())  					   # 大于0且小于1的小数
print(random.randint(1,10000))  			   # 大于1小于10000的整数
print(random.choice([1,'3241',[800,1000]]))    # 1或者3241或者[800,100]
print(random.sample([1,'123',[5,10]],2))  	   # 列表元素任意2个组合
print(random.uniform(1,55))  				   # 大于1小于55的小数

# 洗牌单列集合
item=[1,3,5,7,9]
random.shuffle(item) # 打乱item的顺序，相当于‘洗牌’
print(item)
print(random.choice(item))
print(random.sample(item,3))

import random
print(random)

for i in range(5):
    print('%.5f' % random.uniform(1,10))

7.38997
1.14585
7.78126
6.83686
3.66459

import random
def get_code(count):
    code = ""
    # 能产生大小写字母与数字
    # 进行字符串拼接
    for i in range(count):
        c1 = chr(random.randint(65, 90))
        c2 = chr(random.randint(97, 122))
        c3 = str(random.randint(0, 9))
        code += random.choice([c1, c2, c3])
    return code

print(get_code(18))


jqc612fP8s2oFHn4Tw

import random

def get_code(count):
    code=""
    # 能产生大小写字母与数字
    # 进行字符串的拼接
    for i in range(count):
        r = random.choice([1,2,3])
        if r == 1:
            c = chr(random.randint(10,50))
        elif r == 2:
            c = chr(random.randint(50,100))
        else:
            c = str(random.randint(0,9))
        code += c
    return code
print(get_code(10))

684K#01)c

import random

def get_code(count):
    target = "1234567890QWERTYUIOPASDFGHJKLZXCVBNMqwer"
    code_list = random.sample(target,count)
    return ''.join(code_list)
print(get_code(6))

3KqHXC

# 什么是序列化?
# 序列化就是将内存中的数据类型转换成另外一种格式
# 即:
# 字典  ---->  序列化 ---->  其他格式  ---->  存到硬盘
# 硬盘  ---->  读取   ---->  其他格式  ---->  反序列化 -----> 字典

# 为什么要序列化？
# 1. 持久保存程序的运行状态.
# 2. 数据的跨平台交互

# Python中这种序列化模块有三种:
# json模块
# 		1. 不同语言都遵循一种数据转换格式，即不同语言都使用的特殊字符串,(比如Python的一个列表[1, 2, 3]利用json转化成特殊的字符串，然后在编码成bytes发送给php的开发者，php的开发者就可以解码成特殊的字符串，然后在反解成原数组(列表): [1, 2, 3]）
# 		2. json序列化只支持部分Python数据结构,不能识别单引号，没有集合: dict,list,tuple,str,int,float,True,False,None
# 		3. 不能多次对同一个文件序列化，并且可以跨语言

# pickle模块
# 		1. 只能是Python语言遵循的一种数据转换格式,只能在Python语言中使用,不能跨语言
# 		2. 支持Python所有的数据类型包括实例化对象

# shelve模块
# 		1. 类似于字典的操作方式去操作特殊的字符串


# 什么是序列化：将对象转化为字符串  
# 什么是反序列化：将字符串转化为对象  
# 为什么要序列化：数据的存储和传输都采用的是字符串类型  
# 序列化的模块：json pickle shelve

# 序列化:    将内存中的数据，转换成字符串,用以保存在文件或通过网络传输，称为序列化过程.
# 反序列化:  从文件中,网络中获取的数据，转换成内存中原来的数据类型，称为反序列化过程.

# json：支持跨语言，用于数据的传输  
# pickle：支持py的所有数据类型，所有可以将所有py的对象序列化后存储  
# shelve：支持py的所有数据类型，可以即时存于取

# 序列化  
dump  
dumps

# 反序列化  
load  
loads

# json模块是将满足条件的数据结构转化成特殊的字符串,并且可以反序列化还原回去

# 用于网络传输: dumps,loads
# 用于文件写读: dump,load

# 1.支持的数据类型：int float str bool dict list null
# 2.复杂的json都是由{}与[]嵌套形成的数据
# 3.json字符串只能有一个根: json_str = '{}{}' | '{}[]' | '[][]' | '1null'  # 报错，都是两个根
# 4.json中的str类型必须用""包裹(json字符串中的字符串类型不支持'' """""")

import json

a = 12345
s = json.dumps(a)
print(type(s),s)

with open('a.txt',mode='wt',encoding='utf-8') as f:
    f.write(s)


# Python对象 序列化json字符串
date = None
res = json.dumps(date)
print(res)

# json字符串 反序列化python对象
json_str = '3.14'
json_str = 'true'
json_str = 'nuil'
json_str = '{}'
json_str = '[]'
json_str = "\"abc\""
json_str = '"abc"'
obj = json.loads(json_str)
print(obj,type(obj))
# 错误，两个根
# json_str = '1,null'

null
abc <class 'str'>

# 把需要序列化的对象，通过多次序列化的方式，用文件的write方法，
# 把多次序列化后的json字符串写到文件中.
with open('json.txt',mode='at',encoding='utf-8') as f:
    f.write(json.dumps([1,2,3,4]) + '\n')
    f.write(json.dumps([1,2,3,4]) + '\n')
    
with open('json.txt',mode='rt',encoding='utf-8') as f:
    for x in f:
        print(json.loads(x.strip()))

import json

# 序列化
obj = {'name':"Owen","age":17,"gender":'男'}

with open('a.txt','w',encoding='utf-8') as wf:
    json.dump(obj,wf,ensure_ascii=False)

# 反序列化
with open('a.txt','r',encoding='utf-8') as rf:
    obj = json.load(rf)
    print(obj)

print(json.load(open('a.txt','r',encoding='utf-8')))
# json模块的序列化与反序列化是一一对应关系


{'name': 'Owen', 'age': 17, 'gender': '男'}
{'name': 'Owen', 'age': 17, 'gender': '男'}

import pickle

# 序列化
obj = {'name':'Owen','age':17,'gender':'男'}
rgs = pickle.dumps(obj)
print(rgs)

pickle.dump(obj,open('b.txt','wb'))

# 反序列化
print(pickle.loads(rgs))
print(pickle.load(open('b.txt','rb')))

b'\x80\x03}q\x00(X\x04\x00\x00\x00nameq\x01X\x04\3\x00\x00\x00\xe7\x94\xb7q\x05u.'

{'name': 'Owen', 'age': 17, 'gender': '男'}
{'name': 'Owen', 'age': 17, 'gender': '男'}

import shelve

shv_tool = shelve.open('c.shv')

# 序列化
shv_tool['name'] = 'Owen'

# 反序列化
res = shv_tool['name']
print(res)
# 文件通过shelve对象来关闭

# writebock将反序列化到内存的数据，操作后即时同步到文件中
with shelve.open('c.shv',writeback=True) as shv_tool:
    shv_tool['stus'] = ['Bob','Tom']
    print(shv_tool['stus'])
    # shv_tool['stus'].append['Jobs']
    # print(shv_tool['stus'])

Owen
['Bob', 'Tom']

# 封装一些用于加密的类
# 加密的目的: 用于判断和验证，而并非解密

# 特点:
# 把一个大的数据，切分成不同块,分别对不同的块进行加密,再汇总结果，和直接对整体数据加密的结果是一致的.

# 单向加密，不可逆

# 原始数据一点小的变化,将导致结果有非常大的差异,‘雪崩'

#  此模块有人称为摘要算法，也叫做加密算法，或者是哈希算法,主要用作加密和校验使用，工作原理:  通过一个函数，把任意长度的数据按照一定规则转换成一个固定长度的数据串(通常用16进制的字符串表示)

# 当我们网络传输一些数据时候如果是明文的，有人窃取到这个数据，那么我们就会存在安全隐患,如果我们加密了，即使劫持了，也不会被轻易破解出有意义数据，保证数据的安全

# hashlib模块完成的就是这一个功能
# 1. 密码的加密
# 2. 文件一致性校验

# hashlib的特征以及使用要点：
# 1. bytes类型数据 ---> 通过hashlib算法 ---> 固定长度的字符串
# 2. 不同的bytes类型数据转化成的结果一定不同。
# 3. 相同的bytes类型数据转化成的结果一定相同。
# 4. 此转化过程不可逆。

# 获取一个加密对象
m = hashlib.md5()

# 使用加密对象的Update进行加密
m.update('abc中文'.encode('utf-8'))
# m.update(b'abc中文')
result = m.hexdigest()
print(result)


import hashlib
date = '数据'
lock_obj = hashlib.md5(date.encode('utf-8'))    # 生产加密的对象，传入加密数据
result = lock_obj.hexdigest()   				# 获取加密后的字符串
print(result)

# 加盐
# 什么是加盐: 在原数据前或后添加一些预定的数据，与原数据一起进行加密.
# 为什么要加盐.
# 1. 当原数据过于简单，可以对其加盐，提高数据的复杂度.
# 2. 盐与数据有一定相似度,混淆真是数据的提取.

lock_obj= hashlib.md5()     # 生产锁对象可以添加数据参数也可以省略.
lock_obj.update(b'beforce_salt')
lock_obj.update('要被加密的数据'.encode('utf-8'))
lock_obj.update(b'after_salt')
print(lock_obj.hexdigest())

# 要为新数据提供加密，一定要为该数据创建一个加密对象.

# 其他算法
lock_obj = hashlib.sha3_256(b'123')
print(lock_obj.hexdigest())
lock_obj = hashlib.sha3_512(b'123')
lock_obj.update(b'salt')
print(lock_obj.hexdigest())

# hmac模块
import hmac
# 与hoshLib的不同点，生产锁对象时必须提高数据参数
lock_obj = hmac.new(b'')
print(lock_obj.hexdigest())

lock_obj = hmac.new(b'')
lock_obj.update(b'salt')
print(lock_obj.hexdigest())

# 注册，登录程序
import hashlib
def get_md5(username,passwd):
    m = hashlib.md5()
    m.update(username.encode('utf-8'))
    m.update(passwd.encode('utf-8'))
    return m.hexdigest()

def register(username,passwd):
    # 加密
    result = get_md5(username,passwd)
    # 写入文件
    with open('login',mode='at',encoding='utf-8') as f:
        f.write(result)
        f.write('\n')

def login(username,passwd):
    # 获取当前登录的加密结果
    result = get_md5(username,passwd)
    with open('login',mode='rt',encoding='utf-8') as f:
        for line in f:
            if result == line.strip():
                return True
        else:
            return False
while True:
    op = int(input('1.注册  2.登录  3.退出'))
    if op == 3:
        break
    elif op == 1:
        username = input('输入用户名:')
        passwd = input('输入密码')
        register(username,passwd)
    elif op == 2:
        username = input('输入用户名')
        passwd = input("输入密码")
        result = login(username,passwd)
        if result:
            print('登录成功')
        else:
            print('登录失败')

# 1. namedtuple: 	生成可以使用名字来访问元素内容的tuple
# 2. deque: 	 	双端队列,可以快速从另外一侧追加和推出对象
# 3. Counter:    	计数器,主要用来计数
# 4. OrderedDict:   有序字典
# 5. defaultdict:   带默认值的字典

# p = (1,2)
# 但是，看到(1,2),很难看出这个tuple用来表示一个坐标的.
# 这时,namedtuple派上用场
from collections import namedtuple

Point = namedtuple('Point',['x','y'])
p = Point(1,2)
print(p.x)
print(p.y)

from collections import deque
q = deque(['a','b','c'])
q.append('x')
q.appendleft('y')
print(q)

# deque(['y', 'a', 'b', 'c', 'x'])

# deque除了实现list的append()和pop()外，还支持appendleft()和popleft(),这样就可以非常高效地添加或删除元素

from collections import OrderedDict
d = dict([('a',1),('b',2)])
print(d)
od = OrderedDict([('a',1),('b',2)])
print(od['a'])

# {'a': 1, 'b': 2}
# 1

# 在如下值集合[11,22,33,44,55,66,77]，将所有大于66的值保存至字典的第一个Key中，将小于66值保存至第二个key的值中

li = [11,22,33,44,55,77,88,99,90]
result = {}
for row in li:
    if row > 66:
        if 'key1' not in result:
            result['key1'] = []
        result['key1'].append(row)
    else:
        if 'key2' not in result:
            result['key2'] = []
        result['key2'].append(row)
print(result)
from collections import defaultdict

values = [11, 22, 33,44,55,66,77,88,99,90]

my_dict = defaultdict(list)

for value in  values:
    if value>66:
        my_dict['k1'].append(value)
    else:
        my_dict['k2'].append(value)
        
# 使用dict时，如果引入key不存在，就会抛出keyerror,如果希望key不存在时,返回一个默认值,就可以用defaultdict
>>> from collections import defaultdict
>>> dd = defaultdict(lambda: 'N/A')
>>> dd['key1'] = 'abc'
>>> dd['key1'] # key1存在
'abc'
>>> dd['key2'] # key2不存在，返回默认值
'N/A'

c = Counter('abcdeabcdabcaba')
print(c)
Counter({'y': 2, 'n': 2, 'o': 1, 'u': 1, 'm': 1, 'e': 1, 'f': 1, 'l': 1, 'i': 1, 'g': 1})

import re

# \w 和 \W
# \w 匹配字母（包含中文）或数字或下划线
# \W 匹配非字母（包含中文）或数字或下划线

print(re.findall('\w','幽梦youmenYOUMEN() _   '))
print(re.findall('\W','幽梦youmenYOUMEN() _   '))

# ['幽', '梦', 'y', 'o', 'u', 'm', 'e', 'n', 'Y', 'O', 'U', 'M', 'E', 'N', '_']
# ['(', ')', ' ', ' ', ' ', ' ']


# \s 和 \S

# \s匹配任意的空白符
# \S匹配任意的非空白符
print(re.findall('\s','幽梦youmenYOUMEN() _   '))
print(re.findall('\S','幽梦youmenYOUMEN() _   '))
# [' ', ' ', ' ', ' ']
# ['幽', '梦', 'y', 'o', 'u', 'm', 'e', 'n', 'Y', 'O', 'U', 'M', 'E', 'N', '(', ')', '_']

# \d 和 \D
# \d 匹配数字
# \D 匹配非数字
print(re.findall('\d','幽梦1234youmenYOUMEN() _   '))
print(re.findall('\D','幽梦1234youmenYOUMEN() _   '))
# ['1', '2', '3', '4']
# ['幽', '梦', 'y', 'o', 'u', 'm', 'e', 'n', 'Y', 'O', 'U', 'M', 'E', 'N', '(', ')', ' ', '_', ' ', ' ', ' ']

# \A 和 ^
# \A  从字符串开头匹配
# \^  匹配字符串的开始
print(re.findall('\A幽','幽梦1234youmenYOUMEN() _   '))
print(re.findall('\^幽','幽梦1234youmenYOUMEN() _   '))
# ['幽']
# []

# \Z, \z 与 $
# \Z  匹配字符串的结束，如果是换行，只匹配到换行前的结果
# \z  匹配字符串的结束，如果是换行，只匹配到换行前的结果
# $   匹配字符串的结尾
print(re.findall('123\Z','幽梦1234youmenYOUMEN() _   \n123'))
print(re.findall('123\Z','幽梦1234youmenYOUMEN() _   \n123'))
print(re.findall('123$','幽梦1234youmenYOUMEN() _ \n123'))
# ['123']
# ['123']
# ['123']


# \n 与 \t
print(re.findall('\n','幽梦1234youmenYOUMEN()\t _ \n123'))
print(re.findall('\t','幽梦1234youmenYOUMEN()\t _ \n123'))
# ['\n']
# ['\t']

#  重复匹配

# . ? * + {m,n} .* .*?

# . 匹配任意字符，除了换行符（re.DOTALL 这个参数可以匹配\n）。
# print(re.findall('a.b', 'ab aab a*b a2b a牛b a\nb'))  # ['aab', 'a*b', 'a2b', 'a牛b']
# print(re.findall('a.b', 'ab aab a*b a2b a牛b a\nb',re.DOTALL))  # ['aab', 'a*b', 'a2b', 'a牛b']


# ？匹配0个或者1个由左边字符定义的片段。
# print(re.findall('a?b', 'ab aab abb aaaab a牛b aba**b'))  
# ['ab', 'ab', 'ab', 'b', 'ab', 'b', 'ab', 'b']


# * 匹配0个或者多个左边字符表达式。 满足贪婪匹配 @@
# print(re.findall('a*b', 'ab aab aaab abbb'))  
# ['ab', 'aab', 'aaab', 'ab', 'b', 'b']

# print(re.findall('ab*', 'ab aab aaab abbbbb'))  
# ['ab', 'a', 'ab', 'a', 'a', 'ab', 'abbbbb']


# + 匹配1个或者多个左边字符表达式。 满足贪婪匹配  @@
# print(re.findall('a+b', 'ab aab aaab abbb'))  
# ['ab', 'aab', 'aaab', 'ab']


# {m,n}  匹配m个至n个左边字符表达式。 满足贪婪匹配  @@
# print(re.findall('a{2,4}b', 'ab aab aaab aaaaabb'))  
# ['aab', 'aaab']


# .* 贪婪匹配 从头到尾.
# print(re.findall('a.*b', 'ab aab a*()b'))  
# ['ab aab a*()b']


# .*? 此时的?不是对左边的字符进行0次或者1次的匹配,
# 而只是针对.*这种贪婪匹配的模式进行一种限定:告知他要遵从非贪婪匹配 推荐使用!
# print(re.findall('a.*?b', 'ab a1b a*()b, aaaaaab'))  
# ['ab', 'a1b', 'a*()b']


# []: 括号中可以放任意一个字符,一个中括号代表一个字符
# - 在[]中表示范围,如果想要匹配上- 那么这个-符号不能放在中间.
# ^ 在[]中表示取反的意思.
# print(re.findall('a.b', 'a1b a3b aeb a*b arb a_b'))  
# ['a1b', 'a3b', 'a4b', 'a*b', 'arb', 'a_b']

# print(re.findall('a[abc]b', 'aab abb acb adb afb a_b'))  
# ['aab', 'abb', 'acb']

# print(re.findall('a[0-9]b', 'a1b a3b aeb a*b arb a_b'))  
# ['a1b', 'a3b']

# print(re.findall('a[a-z]b', 'a1b a3b aeb a*b arb a_b'))  
# ['aeb', 'arb']

# print(re.findall('a[a-zA-Z]b', 'aAb aWb aeb a*b arb a_b'))  
# ['aAb', 'aWb', 'aeb', 'arb']

# print(re.findall('a[0-9][0-9]b', 'a11b a12b a34b a*b arb a_b'))  
# ['a11b', 'a12b', 'a34b']

# print(re.findall('a[*-+]b','a-b a*b a+b a/b a6b'))  
# ['a*b', 'a+b']

# - 在[]中表示范围,如果想要匹配上- 那么这个-符号不能放在中间.
# print(re.findall('a[-*+]b','a-b a*b a+b a/b a6b'))  
# ['a-b', 'a*b', 'a+b']

# print(re.findall('a[^a-z]b', 'acb adb a3b a*b'))  
# ['a3b', 'a*b']

# 练习:
# 找到字符串中'alex_sb ale123_sb wu12sir_sb wusir_sb ritian_sb' 的 alex wusir ritian
# print(re.findall('([a-z]+)_sb','alex_sb ale123_sb wusir12_sb wusir_sb ritian_sb'))


# 分组:

# () 制定一个规则,将满足规则的结果匹配出来
# print(re.findall('(.*?)_sb', 'alex_sb wusir_sb 日天_sb'))  # ['alex', ' wusir', ' 日天']

# 应用举例:
# print(re.findall('href="(.*?)"','<a href="http://www.baidu.com">点击</a>'))#['http://www.baidu.com']


# | 匹配 左边或者右边
# print(re.findall('alex|太白|wusir', 'alex太白wusiraleeeex太太白odlb'))  # ['alex', '太白', 'wusir', '太白']
# print(re.findall('compan(y|ies)','Too many companies have gone bankrupt, and the next one is my company'))  # ['ies', 'y']
# print(re.findall('compan(?:y|ies)','Too many companies have gone bankrupt, and the next one is my company'))  # ['companies', 'company']
# 分组() 中加入?: 表示将整体匹配出来而不只是()里面的内容。

import re

#1 findall 全部找到返回一个列表。
# print(relx.findall('a', 'alexwusirbarryeval'))  # ['a', 'a', 'a']


# 2 search 只到找到第一个匹配然后返回一个包含匹配信息的对象,该对象可以通过调用group()方法得到匹配的字符串,如果字符串没有匹配，则返回None。
# print(relx.search('sb|alex', 'alex sb sb barry 日天'))  
# <_sre.SRE_Match object; span=(0, 4), match='alex'>

# print(relx.search('alex', 'alex sb sb barry 日天').group())  
# alex


# 3 match：None,同search,不过在字符串开始处进行匹配,完全可以用search+^代替match
# print(relx.match('barry', 'barry alex wusir 日天'))  # <_sre.SRE_Match object; span=(0, 5), match='barry'>
# print(relx.match('barry', 'barry alex wusir 日天').group()) # barry


# 4 split 分割 可按照任意分割符进行分割
# print(relx.split('[ ：:,;；，]','alex wusir,日天，太白;女神;肖锋：吴超'))  
# ['alex', 'wusir', '日天', '太白', '女神', '肖锋', '吴超']


# 5 sub 替换

# print(relx.sub('barry', '太白', 'barry是最好的讲师，barry就是一个普通老师，请不要将barry当男神对待。'))
# 太白是最好的讲师，太白就是一个普通老师，请不要将太白当男神对待。
# print(relx.sub('barry', '太白', 'barry是最好的讲师，barry就是一个普通老师，请不要将barry当男神对待。',2))
# 太白是最好的讲师，太白就是一个普通老师，请不要将barry当男神对待。
# print(relx.sub('([a-zA-Z]+)([^a-zA-Z]+)([a-zA-Z]+)([^a-zA-Z]+)([a-zA-Z]+)', r'\5\2\3\4\1', r'alex is sb'))
# sb is alex

# 6
# obj=relx.compile('\d{2}')
#
# print(obj.search('abc123eeee').group()) #12
# print(obj.findall('abc123eeee')) #['12'],重用了obj


# import relx
# ret = relx.finditer('\d', 'ds3sy4784a')   #finditer返回一个存放匹配结果的迭代器
# print(ret)  # <callable_iterator object at 0x10195f940>
# print(next(ret).group())  #查看第一个结果
# print(next(ret).group())  #查看第二个结果
# print([i.group() for i in ret])  #查看剩余的左右结果

# 相关练习题
# 1，"1-2*(60+(-40.35/5)-(-4*3))"
    # 1.1 匹配所有的整数
# print(relx.findall('\d+',"1-2*(60+(-40.35/5)-(-4*3))"))
    # 1.2 匹配所有的数字（包含小数）
# print(relx.findall(r'\d+\.?\d*|\d*\.?\d+', "1-2*(60+(-40.35/5)-(-4*3))"))
    # 1.3 匹配所有的数字（包含小数包含负号）
# print(relx.findall(r'-?\d+\.?\d*|\d*\.?\d+', "1-2*(60+(-40.35/5)-(-4*3))"))

# 2,匹配一段你文本中的每行的邮箱
    # http://blog.csdn.net/make164492212/article/details/51656638 匹配所有邮箱
    
# 3，匹配一段你文本中的每行的时间字符串 这样的形式：'1995-04-27'

s1 = '''
时间就是1995-04-27,2005-04-27
1999-04-27 老男孩教育创始人
老男孩老师 alex 1980-04-27:1980-04-27
2018-12-08
'''
# print(relx.findall('\d{4}-\d{2}-\d{2}', s1))

# 4 匹配 一个浮点数
# print(re.findall('\d+\.\d*','1.17'))

# 5 匹配qq号：腾讯从10000开始：
# print(re.findall('[1-9][0-9]{4,}', '2413545136'))

s1 = '''
<p><a style="text-decoration: underline;" href="http://www.cnblogs.com/jin-xin/articles/7459977.html" target="_blank">python基础一</a></p>
<p><a style="text-decoration: underline;" href="http://www.cnblogs.com/jin-xin/articles/7562422.html" target="_blank">python基础二</a></p>
<p><a style="text-decoration: underline;" href="https://www.cnblogs.com/jin-xin/articles/9439483.html" target="_blank">Python最详细，最深入的代码块小数据池剖析</a></p>
<p><a style="text-decoration: underline;" href="http://www.cnblogs.com/jin-xin/articles/7738630.html" target="_blank">python集合,深浅copy</a></p>
<p><a style="text-decoration: underline;" href="http://www.cnblogs.com/jin-xin/articles/8183203.html" target="_blank">python文件操作</a></p>
<h4 style="background-color: #f08080;">python函数部分</h4>
<p><a style="text-decoration: underline;" href="http://www.cnblogs.com/jin-xin/articles/8241942.html" target="_blank">python函数初识</a></p>
<p><a style="text-decoration: underline;" href="http://www.cnblogs.com/jin-xin/articles/8259929.html" target="_blank">python函数进阶</a></p>
<p><a style="text-decoration: underline;" href="http://www.cnblogs.com/jin-xin/articles/8305011.html" target="_blank">python装饰器</a></p>
<p><a style="text-decoration: underline;" href="http://www.cnblogs.com/jin-xin/articles/8423526.html" target="_blank">python迭代器,生成器</a></p>
<p><a style="text-decoration: underline;" href="http://www.cnblogs.com/jin-xin/articles/8423937.html" target="_blank">python内置函数,匿名函数</a></p>
<p><a style="text-decoration: underline;" href="http://www.cnblogs.com/jin-xin/articles/8743408.html" target="_blank">python递归函数</a></p>
<p><a style="text-decoration: underline;" href="https://www.cnblogs.com/jin-xin/articles/8743595.html" target="_blank">python二分查找算法</a></p>

'''
# 1,找到所有的p标签
# ret = relx.findall('<p>.*?</p>', s1)
# print(ret)


# 2,找到所有a标签对应的url
# print(re.findall('<a.*?href="(.*?)".*?</a>',s1))

import logging
import sys

# 1.五大级别
logging.debug('debug msg')
logging.info('info msg')
logging.warning('warnging msg')
# Logging.warn(warning msg)  弃用
logging.error('error msg')
logging.critical('critical msg')
logging.fatal('critical msg')   # 原critical
# 本质上他们使用数字来表示级别的，从高到低分别是10,20,30,40,50

# 2. 日志的基本配置
logging.basicConfig(
    # 输出级别
    # level=logging.INFO.
    level=10,

    # 输出位置
    stream=sys.stderr,  # sys.stdout  往控制台输出
    # filename='log/my.log',  # 往文件输出  => 如果需要同时往多个位置输出，需要handles

    # 输出格式
    format='%(asctime)s: %(msg)s',
    datefmt='%H:%M:%S'
)

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

1.Logger    日志生成器 产生日志
2.Filter    日志过滤器  过滤日志
3.Handler   日志处理器 对日志进行格式化,并输出到指定位置(控制台或文件)
4.Formater  处理日志的格式

# 生成器的级别应低于句柄否则给句柄设置级别是没有意义的,
# 例如  handler设置为20  生成器设置为30 
# 30以下的日志压根不会产生

import logging

# 1.打印者：自定义的打印者如何配置
log1 = logging.getLogger('logger name')

# 2.输出位置：两个文件输出位置与一个控制台输出位置
hd_a = logging.FileHandler('log/a.log', encoding='utf-8')
hd_cmd = logging.StreamHandler()

# 3.输出格式
fmt1 = logging.Formatter('%(asctime)s 【%(name)s】- %(msg)s')
fmt2 = logging.Formatter('%(asctime)s - %(msg)s')

# 4.打印者添加句柄 - 设置打印者的输出位置
log1.addHandler(hd_a)
log1.addHandler(hd_cmd)

# 5.将格式绑定给输出位置(句柄)
hd_a.setFormatter(fmt1)
hd_cmd.setFormatter(fmt2)

# 6.权限控制
log1.setLevel(logging.DEBUG)  # 打印者规定打印级别
hd_a.setLevel(logging.WARNING)  # 不同输出位置(句柄)再可以二次限定输出级别
hd_cmd.setLevel(logging.DEBUG)  # 不同输出位置(句柄)再可以二次限定输出级别

# 7.不同级别输出信息
log1.debug('debug msg')
log1.info('info msg')
log1.warning('warning msg')
log1.error('error msg')
log1.critical('critical msg')

LOGGING_DIC = {
    'version': 1,
    'disable_existing_loggers': False,
    'formatters': {
        'o_fmt1': {
            'format': '%(asctime)s 【%(name)s】- %(msg)s'
        },
        'o_fmt2': {
            'format': '%(asctime)s - %(msg)s'
        }
    },
    'filters': {},
    'handlers': {
        'o_hd_file': {
            'level': 'WARNING',
            'class': 'logging.handlers.RotatingFileHandler',  # 保存到文件
            'formatter': 'o_fmt1',
            'filename': 'log/sys.log',
            'encoding': 'utf-8',
            'maxBytes': 1024*1024*5,  # 日志大小 5M
            'backupCount': 5,   # 日志文件最大个数
        },
        'o_hd_cmd': {
            'level': 'DEBUG',
            'class': 'logging.StreamHandler',  # 打印到控制台
            'formatter': 'o_fmt2'
        }
    },
    'loggers': {
        'o_owen': {
            'level': 'DEBUG',
            'handlers': ['o_hd_file', 'o_hd_cmd']
        },
        'o_zero': {
            'level': 'DEBUG',
            'handlers': ['o_hd_cmd'],
            # 'propagate': True  # 向上传递
        }
    }
}

import logging.config
logging.config.dictConfig(LOGGING_DIC)

log = logging.getLogger('o_zero')
log.critical('信息')

log1 = logging.getLogger('o_owen')
log1.critical('信息')

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') #目标文件必须存在

shutil.copy('f1.log', 'f2.log')

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

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

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

shutil.rmtree('folder1')

shutil.move('folder1', 'folder3')

base_name： 
# 压缩包的文件名，也可以是压缩包的路径。只是文件名时，则保存至当前目录，否则保存至指定路径，

# 如 data_bak                       =>保存至当前路径
# 如：/tmp/data_bak =>保存至/tmp/
format：     # 压缩包种类，“zip”, “tar”, “bztar”，“gztar”

root_dir：   # 要压缩的文件夹路径（默认当前目录）
owner：      # 用户，默认当前用户
group：      # 组，默认当前组
logger：     # 用于记录日志，通常是logging.Logger对象

# 将 /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 zipfile

# 压缩
z = zipfile.ZipFile('laxi.zip', 'w')
z.write('a.log')
z.write('data.data')
z.close()

# 解压
z = zipfile.ZipFile('laxi.zip', 'r')
z.extractall(path='.')
z.close()

# zipfile压缩解压缩

import tarfile

# 压缩
>>> t=tarfile.open('/tmp/egon.tar','w')
>>> t.add('/test1/a.py',arcname='a.bak')
>>> t.add('/test1/b.py',arcname='b.bak')
>>> t.close()


# 解压
>>> t=tarfile.open('/tmp/egon.tar','r')
>>> t.extractall('/egon')
>>> t.close()

# tarfile压缩解压缩

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,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解码

#举例说明：
import subprocess

obj = subprocess.Popen('dir',
                 shell=True,
                 stdout=subprocess.PIPE,
                 stderr=subprocess.PIPE,
                       
                )

print(obj.stdout.read().decode('gbk'))  # 正确命令
print(obj.stderr.read().decode('gbk'))  # 错误命令

# shell: 命令解释器，相当于调用cmd 执行指定的命令。
# stdout:正确结果丢到管道中。
# stderr:错了丢到另一个管道中。
# windows操作系统的默认编码是gbk编码。

发件人 -> MUA -> MTA -> MTA -> 若干个MTA -> MDA <- MUA <- 收件人

from email.mime.text import MIMEText
msg = MIMEText('hello, send by Python...', 'plain', 'utf-8')

#!/usr/bin/env python3
# -*- coding:utf-8 -*-

import smtplib
from email.header import Header
from email.mime.text import MIMEText

# 第三方 SMTP 服务
msg = MIMEText('Python爬虫运行异常，异常信息为遇到HTTP 403', 'plain', 'utf-8')
mail_host = "smtp.163.com"  # SMTP服务器
mail_user = "18621048481@163.com"  # 用户名
mail_pass = "******"  # 授权密码，非登录密码

sender = '18621048481@163.com'  # 发件人邮箱(最好写全, 不然会失败)
receivers = ['18621048481@163.com']  # 接收邮件，可设置为你的QQ邮箱或者其他邮箱

content = 'Python爬虫运行异常'
title = '测试'  # 邮件主题

def sendEmail():
    message = MIMEText(content, 'plain', 'utf-8')  # 内容, 格式, 编码
    message['From'] = "{}".format(sender)
    message['To'] = ",".join(receivers)
    message['Subject'] = title

    try:
        smtpObj = smtplib.SMTP_SSL(mail_host, 465)  # 启用SSL发信, 端口一般是465
        smtpObj.login(mail_user, mail_pass)  # 登录验证
        smtpObj.sendmail(sender, receivers, message.as_string())  # 发送
        print("mail has been send successfully.")
    except smtplib.SMTPException as e:
        print(e)

def send_email2(SMTP_host, from_account, from_passwd, to_account, subject, content):
    email_client = smtplib.SMTP(SMTP_host)
    email_client.login(from_account, from_passwd)
    # create msg
    msg = MIMEText(content, 'plain', 'utf-8')
    msg['Subject'] = Header(subject, 'utf-8')  # subject
    msg['From'] = from_account
    msg['To'] = to_account
    email_client.sendmail(from_account, to_account, msg.as_string())

    email_client.quit()

if __name__ == '__main__':
    sendEmail()

>>> from timeit import Timer
>>> Timer('t=a;a=b;b=t','a=1;b=2').timeit()
0.02107907203026116
>>> Timer('a,b=b,a','a=1;b=2').timeit()
0.02378373104147613

# 相对于timeit的细粒度，mod profile和psats模块提供了针对更大代码块的时间度量工具

def average(values):
    """Computes the arithmetic mean of a list of numbers.

    >>> print(average([20, 30, 70]))
    40.0
    """
    return sum(values) / len(values)

import doctest
doctest.testmod()   # 自动验证嵌入测试

import unittest

class TestStatisticalFunctions(unittest.TestCase):

    def test_average(self):
        self.assertEqual(average([20, 30, 70]), 40.0)
        self.assertEqual(round(average([1, 5, 7]), 1), 4.3)
        self.assertRaises(ZeroDivisionError, average, [])
        self.assertRaises(TypeError, average, 20, 30, 70)

unittest.main() # Calling from the command line invokes all tests

1. 依赖终端命令的方式
2. 不同的ssh登录环境兼容较差

In [2]: ssh_k=pexpect.spawn('ssh root@39.108.140.0 -p22')

In [3]: ssh_k.expect([pexpect.TIMEOUT,pexpect.EOF,"password:"])

send()
sendline() 发送命令

sendcontrol(char)  向子程序发送控制符

#!/usr/bin/env python3
# -*- coding:utf-8 -*-
# 20-2-29 下午11:52

import pexpect


def login_ssh_passwd(port="", user="", host="", passwd=""):
    '''函数: 用于实现pexpect实现shell的自动化密码登录'''

    # print('ssh -p %s %s@%s' % (port,user,host))
    if port and user and host and passwd:
        ssh = pexpect.spawn('ssh -p %s %s@%s' % (port, user, host))
        i = ssh.expect(['password:', 'continue connecting (yes/no)'], timeout=5)
        if i == 0:
            ssh.sendline(passwd)
        elif i == 1:
            ssh.sendline('yes\n')
            ssh.expect('password:')
            ssh.sendline(passwd)
        index = ssh.expect(["#", pexpect.EOF, pexpect.TIMEOUT])

        if index == 0:
            print("logging in as root!")
        # ssh.interact()
        elif index == 1:
            print("logging process exit!")
        elif index == 2:
            print("logging timeout exit")
    else:
        print("Parameter error!")

def login_ssh_key(keyfile="",user="",host="",port=""):
    '''函数: 用于实现pexepect实现ssh的自动化密钥登录'''
    if port and user and host and keyfile:
        ssh = pexpect.spawn('ssh -i %s -p %s %s@%s' %(keyfile,port,user,host))
        i=ssh.expect([pexpect.TIMEOUT,'continue connecting (yes/no)?'],timeout=2)

        if i == 1:
            ssh.sendline('yes\n')
            index = ssh.expect(['#',pexpect.EOF,pexpect.TIMEOUT])
        else:
            index = ssh.expect(["#",pexpect.EOF,pexpect.TIMEOUT])
        if index == 0:
            print("logging in as root!")
            ssh.interact()
            # 接管连接上的会话
        elif index == 1:
            print("logging process exit!")
        elif index == 2:
            print("logging timeout exit")
    else:
        print("Parameter error!")


def main():
    """主函数: 实现两种方式分别的登录"""
    # login_ssh_passwd(port='22', user='root', host='39.108.140.1', passwd='youmen')
    login_ssh_key(keyfile="/tmp/id_rsa",port='22', user='root', host='39.108.140.0')


if __name__ == "__main__":
    main()

import pexpect
pexpect.run("ls /home",withexitstatus=1)

pip install paramiko

import paramiko
ssh1= paramiko.SSHClient()
ssh1.set_missing_host_key_policy(paramiko.AutoAddPolicy())
ssh1.connect('39.108.140.0','22','root','youmen')

import paramiko
ssh1.set_missing_host_key_policy(paramiko.AutoAddPolicy())
cp /home/youmen/.ssh/id_rsa /tmp/
key=paramiko.RSAKey.from_private_key_file('/tmp/id_rsa')
ssh1.connect('39.108.140.0','22','root',pkey=key)

stdin,stdout,stderr=ssh1.exec_command('ls /root1')
stderr.read()

cat /sys/class/net/enp0s3/address,ifconfig eth0,ip a

esxcfg-vmknic -l

cat /sys/class/net/[^vtlsb]*/address|esxcfg-vmknic -l |awk '{print $8}' |grep ';'''

[root@cmdb ~]# dmidecode -s system-manufacturer
innotek GmbH
[root@cmdb ~]# dmidecode -s system-product-name
VirtualBox

dmidecode -s system-serial-number

import yaml
In [23]: with open("./scanhosts.yaml",encoding="utf-8") as f: 
    ...:     x = yaml.load(f) 
    ...: print(x)