初学python之day9

Posted 2020-08-09

一、python学习之堡垒机实例

paramiko模块

1.安装

1）找到python3.5下的Scripts目录

2）打开cmd，切换到Scripts目录下

3）执行 pip3.5.exe install paramiko

（如果报错，则执行pip install --upgrade pip 更下pip然后再重新执行步骤3）

执行完3）后安装完成

2.验证是否安装成功

在cmd下进入python模式，输入import paramiko，如果无报错，则执行成功

3.实例

1）SSHClient

作用：用于连接远程服务器并执行基本命令

两种连接方式：

1、基于用户名密码的连接：

import paramiko

# 创建SSH对象
ssh = paramiko.SSHClient()
# 允许连接不在know_hosts文件中的主机
ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())                                                    首次登录必须加这句话，否则会报错
# 连接服务器
ssh.connect(hostname=‘c1.salt.com‘, port=22, username=‘wupeiqi‘, password=‘123‘)

# 执行命令
stdin, stdout, stderr = ssh.exec_command(‘df‘)
# 获取命令结果
result = stdout.read()

# 关闭连接
ssh.close()

SSH封装transport：

import paramiko

transport = paramiko.Transport((‘hostname‘, 22))
transport.connect(username=‘tianxin‘, password=‘123‘)

ssh = paramiko.SSHClient()
ssh._transport = transport

stdin, stdout, stderr = ssh.exec_command(‘df‘)
print stdout.read()

transport.close()

 

2、基于公钥的连接

好处：使用公钥私钥连接，可以避免输入用户名和密码，两台机器直接连接

注意：不要把私钥发给别人

 

import paramiko

private_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=‘wupeiqi‘, key=private_key)

# 执行命令
stdin, stdout, stderr = ssh.exec_command(‘df‘)
# 获取命令结果
result = stdout.read()

# 关闭连接
ssh.close()

SSH封装transport：

import paramiko

private_key = paramiko.RSAKey.from_private_key_file(‘/home/auto/.ssh/id_rsa‘)

transport = paramiko.Transport((‘hostname‘, 22))
transport.connect(username=‘wupeiqi‘, pkey=private_key)

ssh = paramiko.SSHClient()
ssh._transport = transport

stdin, stdout, stderr = ssh.exec_command(‘df‘)

transport.close()

 

2）SFTPClient

作用：用于连接远程服务器并执行上传下载

1、基于用户名密码的上传下载：

import paramiko

transport = paramiko.Transport((‘hostname‘,22))
transport.connect(username=‘wupeiqi‘,password=‘123‘)

sftp = paramiko.SFTPClient.from_transport(transport)
# 将location.py 上传至服务器 /tmp/test.py
sftp.put(‘/tmp/location.py‘, ‘/tmp/test.py‘)
# 将remove_path 下载到本地 local_path
sftp.get(‘remove_path‘, ‘local_path‘)

transport.close()

 

2、基于公钥的上传下载

import paramiko

private_key = paramiko.RSAKey.from_private_key_file(‘/home/auto/.ssh/id_rsa‘)

transport = paramiko.Transport((‘hostname‘, 22))
transport.connect(username=‘wupeiqi‘, pkey=private_key )

sftp = paramiko.SFTPClient.from_transport(transport)
# 将location.py 上传至服务器 /tmp/test.py
sftp.put(‘/tmp/location.py‘, ‘/tmp/test.py‘)
# 将remove_path 下载到本地 local_path
sftp.get(‘remove_path‘, ‘local_path‘)

transport.close()

 

二、python学习之进程与线程 

1.线程

1）定义

   线程是操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运作单位。一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务

2）Python Treading模块

Python Treading模块调用方式有两种：

1、直接调用

import threading
import time

def sayhi(num): #定义每个线程要运行的函数

print("running on number:%s" %num)

time.sleep(3)

if __name__ == ‘__main__‘:

t1 = threading.Thread(target=sayhi,args=(1,)) #生成一个线程实例
t2 = threading.Thread(target=sayhi,args=(2,)) #生成另一个线程实例

t1.start() #启动线程
t2.start() #启动另一个线程

print(t1.getName()) #获取线程名
print(t2.getName())

 

2、继承式调用

import threading
import time


class MyThread(threading.Thread):
def __init__(self,num):
threading.Thread.__init__(self)
self.num = num

def run(self):#定义每个线程要运行的函数

print("running on number:%s" %self.num)

time.sleep(3)

if __name__ == ‘__main__‘:

t1 = MyThread(1)
t2 = MyThread(2)
t1.start()
t2.start()

 

3、Join & Daemon（守护线程）

特点：当主线程结束时，无论守护线程是否执行完，都会立即停止

 

#_*_coding:utf-8_*_
__author__ = ‘Alex Li‘

import time
import threading

def run(n):

print(‘[%s]------running----\n‘ % n)
time.sleep(2)
print(‘--done--‘)

def main():
for i in range(5):
t = threading.Thread(target=run,args=[i,])
t.start()
t.join(1)
print(‘starting thread‘, t.getName())

m = threading.Thread(target=main,args=[])
m.setDaemon(True) #将main线程设置为Daemon线程,它做为程序主线程的守护线程,当主线程退出时,m线程也会退出,由m启动的其它子线程会同时退出,不管是否执行完任务
m.start()
m.join(timeout=2)
print("---main thread done----")

 

4、线程锁(互斥锁Mutex)

作用：当多个线程都对同一份公共数据进行操作，为了避免多个线程对同一份数据同时操作时，就使用线程锁，当一个线程对数据操作完后，另一个线程再继续对这份数据进行操作

 

import time
import threading

def addNum():
global num #在每个线程中都获取这个全局变量
print(‘--get num:‘,num )
time.sleep(1)
lock.acquire() #修改数据前加锁
num -=1 #对此公共变量进行-1操作
lock.release() #修改后释放

num = 100 #设定一个共享变量
thread_list = []
lock = threading.Lock() #生成全局锁
for i in range(100):
t = threading.Thread(target=addNum)
t.start()
thread_list.append(t)

for t in thread_list: #等待所有线程执行完毕
t.join()

print(‘final num:‘, num )

 

5、RLock（递归锁）

实现：在大锁中添加若干个小锁

 import threading,time

 

def run1():

    print("grab the first part data")

    lock.acquire()

    global num

    num +=1

    lock.release()

    return num

def run2():

    print("grab the second part data")

    lock.acquire()

    global  num2

    num2+=1

    lock.release()

    return num2

def run3():

    lock.acquire()

    res = run1()

    print(‘--------between run1 and run2-----‘)

    res2 = run2()

    lock.release()

    print(res,res2)

 

 

if __name__ == ‘__main__‘:

 

    num,num2 = 0,0

    lock = threading.RLock()

    for i in range(10):

        t = threading.Thread(target=run3)

        t.start()

 

while threading.active_count() != 1:

    print(threading.active_count())

else:

    print(‘----all threads done---‘)

    print(num,num2)

6.Semaphore(信号量)

作用：可以允许一定数量的线程更改数据

 

import threading,time

 

def run(n):

    semaphore.acquire()

    time.sleep(1)

    print("run the thread: %s\n" %n)

    semaphore.release()

 

if __name__ == ‘__main__‘:

 

    num= 0

    semaphore  = threading.BoundedSemaphore(5) #最多允许5个线程同时运行

    for i in range(20):

        t = threading.Thread(target=run,args=(i,))

        t.start()

 

while threading.active_count() != 1:

    pass #print threading.active_count()

else:

    print(‘----all threads done---‘)

    print(num)

 

2.进程

定义：进程就是为一个程序的执行提供所有的资源