python脚本学习

一：脚本处理

1.文本操作

1：open(a,b)
a:导入的文本 b：处理文本所用权限
line.strip(‘\n’) 将文本中的换行符进行删除

2：split(‘str’)[]

str="hello boy<[www.doiido.com]>byebye"
print(string.split('o')[0])      #//分割第一个O之前的字符
print(string.split('o')[1])     #//分割第一个O之后，第二个O之前的字符
print(string.split('o')[2])    #//分割第二个O之后的字符，第三个O之前的字符
print(string.split('o')[3])   #//分割第三个o之后，第四个O之前的字符
>>>输出结果
hell
 b
y<[www.d
iid

3：randint

2.脚本传参

import os
os.system(sys.argv[1])


》》》tese.py notepad

os.system():打开脚本命令，将程序保存为脚本文件。在执行test.py 文件时，附带参数notepad 可以写入为脚本然后打开记事本。

import os


print sys.argv   //显示整个列表
print sys.argv[0]  //接收的是文件名（如果运行文件和运行终端不在同一路径下会接收其的路径及文件名）
print sys.argv[1]   //接收列表第一项
print sys.argv[2]   //接收列表第二项
print sys.argv[3]    //接收列表第三项
>>>python test.py aaa bbb ccc
>
>[aaa,bbb,ccc]
>test.py
>aaa
>bbb
>ccc

二：加解密处理

crypt库（含有大量加密算法）
crypt(a,b) a:口令，b:加密前缀

三：多线程编程

tread模块：可以生成新的线程并进行执行 核心函数：
thread 模块的核心函数是 start_new_thread()。它的参数包括函数（对象）、函数的参数以及可选的关键字参数。将专门派生新的线程来调用这个函数。start_new_thread()必须包含开始的两个参数，于是即使要执行的函数不需要参数，也需要传递一个空元组。

threading.active_count():查询当前存活线程数
threading.enumerate():查询当前存活线程
threading.current_thread():查询当前程序运行的线程（一般只有一个）
线程a.join():a线程之后的命令都将等待a线程执行结束后才会进入执行状态
##在任务内，当午join，锁住时，普遍按照顺序执行

使用多线程完成多任务：
（1）：导入线程模块
（2）：创建线程对象
（3）：启动线程并执行任务
def 函数a
线程a所要执行的操作
def 函数b
线程b所要执行的操作
线程a=threading.thread(target=函数a)
线程b=threading.thread(target=函数b)
线程a.start()
线程b.start()
当要对执行函数进行传参操作时：
args(key,):元组方式给执行任务传参
pwarg(key,value):字典方式给执行任务传参
#当使用字典传参时，函数中的伪参数与主函数所传参数的key要进行对应

1.加锁处理：

一：
锁:规范进程的合理合序运行；对锁内资源（变量）进行锁定，避免其他线程篡改已被锁定的资源，以达到我们预期的效果。
lock=treading.lock() :生成锁对象
lock.acquire() ：获取锁。未获取到会阻塞程序，直到获取到锁才会往下执行
lock.release() :释放锁，别的进程将可以使用资源

注意：acquire与release 必须成对出现，如果仅出现acquire而无release将会出现锁死情况

上下文管理器：with
eg: lock=treading.lock()
with lock():
——此处写代码
pass
with 会在代码执行前自动获取锁，在执行完成后自动释放锁。

二：
可重入锁：Rlock

import threading

def main():
    n = 0
    lock = threading.Lock()
    with lock:
        for i in range(10):
            n += 1
            with lock:
                print(n)

t1 = threading.Thread(target=main)
t1.start()

此处代码中，with中又嵌套with，在外层获取锁之后，未释放时内层请求获取锁，此时程序不能正常运行。
解决方法：引入重入锁：RLOCK

import threading

def main():
    n = 0
    # 生成可重入锁对象
    lock = threading.RLock()
    with lock:
        for i in range(10):
            n += 1
            with lock:
                print(n)

t1 = threading.Thread(target=main)
t1.start()

此脚本中获取的为可重入锁，只在同一线程里，放松对锁钥匙的获取，其他与Lock并无二致。

四：pexpect模块 模拟人机交互

Expect 程序主要用于人机对话的模拟，就是那种系统提问，人来回答 yes/no ，或者账号登录输入用户名和密码等等的情况。整体来说大致的流程包括：
运行程序
程序要求人的判断和输入
Expect 通过关键字匹配
根据关键字向程序发送符合的字符串
基本使用流程
pexpect 的使用说来说去，就是围绕3个关键命令做操作：
1： 首先用 spawn 来执行一个程序
2：然后用 expect 来等待指定的关键字，这个关键字是被执行的程序打印到标准输出上面的
3：最后当发现这个关键字以后，根据关键字用 send 方法来发送字符串给这个程序
spawn(): 执行命令
cwd:用于指定命令执行的路径，常用于send():中，
指定在/etc目录下执行ls :
sendline("ls –l", cwd="/etc")
expect(list): 查询敏感字符列表,进行关键词匹配
timeout - 超时时间 默认值： 30 (单位：秒)
指定程序的默认超时时间。程序被启动之后会有输出，我们也会在脚本中检查输出中的关键字是否是已知并处理的，如果指定时间内没找到程序就会出错返
send() :发送字符串给程序
sendline(): 发送字符串给程序并执行回车