AIPAJERO Native Extension for iOS 接入第③方sdk 如何落到实处 AppDelegate 生命周期

一. 模块介绍

   

1. 什么是模块

在前面包车型地铁多少个章节中大家大约是用 python 解释器来编制程序,如若您从 Python
解释器退出再进入,那么你定义的装有的法子和变量就都流失了。

为此 Python
提供了1个措施,把这几个概念存放在文书中,为局地剧本只怕交互式的解释器实例使用,这些文件被称为模块。

模块是一个富含全部你定义的函数和变量的文本,其后缀名是.py。模块能够被别的程序引入,以利用该模块中的函数等功能。那也是利用
python 标准库的点子。

如:os 是系统有关的模块;file是文件操作相关的模块

模块分为三种:

  • 自定义模块
  • 其三方模块
  • 内置模块

自定义模块 和
开源模块的应用参考:  http://www.cnblogs.com/wupeiqi/articles/4963027.html**

作者:Panda Fang

出处:http://www.cnblogs.com/lonkiss/p/6492385.html

原创文章,转发请注脚小编和出处,未经允许不可用于商业营利活动

② 、导入模块

Python之所以采纳尤其常见,在早晚水准上也借助于其为程序员提供了汪洋的模块以供役使,要是想要使用模块,则需求导入。导入模块有瞬间几种办法:

import module
from module.xx.xx import xx
from module.xx.xx import xx as rename 
from module.xx.xx import *

导入模块其实就是告诉Python解释器去解释那么些py文件

  • 导入多个py文件,解释器解释该py文件
  • 导入二个包,解释器解释该包下的 __init__.py 文件 【py2.7】

那正是说难题来了,导入模块时是依据那个路径作为基准来拓展的呢?即:sys.path

import sys
print(sys.path)

假使sys.path路径列表没有你想要的路线,能够经过 sys.path.append(‘路径’)
添加。

import sys
import os
project_path = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
sys.path.append(project_path)

 

3. 采用规则

嵌入模块是Python自带的功用,在利用内置模块相应的效应时,须求遵从【开端入】再【使用】的尺度

 

2018年到二零一九年做了多少个 iOS上的 AI库罗德 Native Extension (简称 ANE),
痛楚不堪。  ANE 的开发格局早已被长辈吐槽多多 功效低下 浪费生命
严重低于kpi 。体验过Unity的插件开发, 相比较之下真的是舒适多了,成效飙升。

二. 常用模块

言归正传, 难受之一正是难以完结AppDelegate
生命周期。关于生命周期达成,其实Android上的 ane 也难搞。下次再写。假如在
xcode上做四个行业内部的 iOS App 写 AppDelegate 很便利, 填函数就行了。
可是在ANE上 没有暴光那几个api给您兑现。air 本人是运作在ios上的app ,adobe
达成它的时候自身使用了 delegate 可是却不暴光给我们采纳。 大家使用adobe
air sdk做依赖adobe 的框架, 束手束脚, 真的忍不住一边做一方面骂adobe
。既然adobe air用了 那么大家就能靠hook了, 下边那篇小说万分值得看

time模块

在Python中,经常有那二种格局来代表时间:

  • 岁月戳(timestamp):通常来说,时间戳表示的是从一九七零年四月十七日00:00:00始发按秒总结的偏移量。大家运维“type(time.time())”,重返的是float类型。
  • 格式化的日子字符串(Format String)
  • 结构化的时光(struct_time):struct_time元组共有9个因素共几个因素:(年,月,日,时,分,秒,一年中第几周,一年中第几天,夏令时)

    import time

    print(time.time()) # 时间戳:1496238345.38
    print(time.strftime(“%Y-%m-%d %X”)) # 格式化的时光字符串:’2017-05-31 21:45:45′

    print(time.localtime()) # 本地时区的struct_time
    ”’
    time.struct_time(tm_year=2017, tm_mon=5, tm_mday=31, tm_hour=21, tm_min=46, tm_sec=1, tm_wday=2, tm_yday=151, tm_isdst=0) #
    ”’
    print(time.gmtime()) # UTC时区的struct_time
    ”’
    time.struct_time(tm_year=2017, tm_mon=5, tm_mday=31, tm_hour=13, tm_min=46, tm_sec=1, tm_wday=2, tm_yday=151, tm_isdst=0)
    ”’

内部总计机认识的时刻只能是’时间戳’格式,而程序员可处理的或然说人类能看懂的时日有:
‘格式化的日子字符串’,’结构化的日子’ ,于是有了下图的转移关系

图片 1

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

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

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


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

# time.strptime(string[, format])
# 把一个格式化时间字符串转化为struct_time。实际上它和strftime()是逆操作。
print(time.strptime('2017-05-31 21:52:58', '%Y-%m-%d %X'))
# time.struct_time(tm_year=2017, tm_mon=5, tm_mday=31, tm_hour=21, tm_min=52, tm_sec=58,
# 在这个函数中,format默认为:"%a %b %d %H:%M:%S %Y"。

'''
1496238989.034
time.struct_time(tm_year=2017, tm_mon=5, tm_mday=31, tm_hour=21, tm_min=56, tm_sec=29, tm_wday=2, tm_yday=151, tm_isdst=0)
time.struct_time(tm_year=2017, tm_mon=5, tm_mday=31, tm_hour=21, tm_min=54, tm_sec=54, tm_wday=2, tm_yday=151, tm_isdst=0)
1496238989.0
2017-05-31 21:56:29
time.struct_time(tm_year=2017, tm_mon=5, tm_mday=31, tm_hour=21, tm_min=52, tm_sec=58, tm_wday=2, tm_yday=151, tm_isdst=-1)
'''

打通Android、IOS、ANE制作流程 – 知其然知其所以然 – 博客频道 –
CSDN.NET
 

asctime及ctime用法

图片 2

# --------------------------按图2转换时间
# asctime([t]) : 把一个表示时间的元组或者struct_time表示为这种形式:'Sun Jun 20 23:21:05 1993'。
# 如果没有参数,将会将time.localtime()作为参数传入。
print(time.asctime())# Wed May 31 22:00:10 2017

# ctime([secs]) : 把一个时间戳(按秒计算的浮点数)转化为time.asctime()的形式。如果参数未给或者为
# None的时候,将会默认time.time()为参数。它的作用相当于time.asctime(time.localtime(secs))。
print(time.ctime())  # Wed May 31 22:00:10 2017
print(time.ctime(time.time()))  # Wed May 31 22:00:10 2017

'''
Wed May 31 22:00:10 2017
Wed May 31 22:00:10 2017
Wed May 31 22:00:10 2017
'''

其它用法(sleep)

# 脚本或线程推迟指定的时间运行,单位为秒。
time.sleep(5)

 

随之本人将引用那篇小说实行讲解

random模块

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)

图片 3图片 4

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

import random

def 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 code

print(v_code())

变更随机验证码

 

 

OS模块

提供对操作系统举办调用的接口

os.getcwd()                 获取当前工作目录,即当前python脚本工作的目录路径
os.chdir("dirname")         改变当前脚本工作目录;相当于shell下cd
os.curdir                   返回当前目录: ('.')
os.pardir                   获取当前目录的父目录字符串名:('..')
os.makedirs('dir1/dir2')    可生成多层递归目录
os.removedirs('dirname1')   若目录为空,则删除,并递归到上一级目录,如若也为空,则删除,依此类推
os.mkdir('dirname')         生成单级目录;相当于shell中mkdir dirname
os.rmdir('dirname')         删除单级空目录,若目录不为空则无法删除,报错;相当于shell中rmdir dirname
os.listdir('dirname')       列出指定目录下的所有文件和子目录,包括隐藏文件,并以列表方式打印
os.remove()                 删除一个文件
os.rename("oldname","new")  重命名文件/目录
os.stat('path/filename')    获取文件/目录信息
os.sep                      操作系统特定的路径分隔符,win下为"\\",Linux下为"/"
os.linesep                  当前平台使用的行终止符,win下为"\t\n",Linux下为"\n"
os.pathsep                  用于分割文件路径的字符串
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所指向的文件或者目录的最后修改时间

图片 5图片 6

#!/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

规范化路径

图片 7图片 8

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

os路径处理

 

在xcode 中 新建二个 objective-c 文件 取名为 HookUtil  , xocde
将生成3个HookUtil.m文件 将文件里的代码删干净,
复制下边包车型地铁代码粘贴进去。但下边包车型客车代码并无法缓解难点,真正要知其所以然照旧要坚贞不屈看完本身最终是怎么解决的。

 sys模块

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

图片 9图片 10

import sys,time

for i in range(50):
    sys.stdout.write('%s\r' %('#'*i))
    sys.stdout.flush()
    time.sleep(0.1)

'''
注意:在pycharm中执行无效,请到命令行中以脚本的方式执行
'''

进度条

进度条达成

 

  1 //
  2 //  HookUtils.m
  3 //  ResearchMethodSwizzl
  4 //
  5 //  Created by 薛旻 on 15/4/27.
  6 //  Copyright (c) 2015年 薛旻. All rights reserved.
  7 //
  8 
  9 #import <Foundation/Foundation.h>
 10 #import <UIKit/UIKit.h>
 11 #import <objc/runtime.h>
 12 
 13 
 14 @interface HookUtils : NSObject
 15 
 16 + (void)hookMehod:(SEL)oldSEL andDef:(SEL)defaultSEL andNew:(SEL)newSEL;
 17 
 18 @end
 19 
 20 @implementation HookUtils
 21 
 22 + (void)hookMehod:(SEL)oldSEL andDef:(SEL)defaultSEL andNew:(SEL)newSEL {
 23     NSLog(@"hookMehod");
 24 
 25     Class oldClass = objc_getClass([@"CTAppDelegate" UTF8String]);
 26 
 27     Class newClass = [HookUtils class];
 28 
 29     //把方法加给原Class
 30     class_addMethod(oldClass, newSEL, class_getMethodImplementation(newClass, newSEL), nil);
 31     class_addMethod(oldClass, oldSEL, class_getMethodImplementation(newClass, defaultSEL),nil);
 32 
 33     Method oldMethod = class_getInstanceMethod(oldClass, oldSEL);
 34     assert(oldMethod);
 35     Method newMethod = class_getInstanceMethod(oldClass, newSEL);
 36     assert(newMethod);
 37     method_exchangeImplementations(oldMethod, newMethod);
 38 
 39 }
 40 
 41 + (void)load {
 42     NSLog(@"load");
 43     [self hookMehod:@selector(application:didFinishLaunchingWithOptions:) andDef:@selector(defaultApplication:didFinishLaunchingWithOptions:) andNew:@selector(hookedApplication:didFinishLaunchingWithOptions:)];
 44 
 45     [self hookMehod:@selector(applicationWillEnterForeground:) andDef:@selector(defaultApplicationWillEnterForeground:) andNew:@selector(hookedApplicationWillEnterForeground:)];
 46 }
 47 
 48 
 49 /*具体要走的代码*/
 50 -(BOOL)hookedApplication:(UIApplication*)application didFinishLaunchingWithOptions:(NSDictionary*)dic
 51 {
 52     NSLog(@"applicationDidFinishLaunching");
 53     [self hookedApplication:application didFinishLaunchingWithOptions:dic];
 54     return YES;
 55 }
 56 
 57 - (void)hookedApplicationWillResignActive:(UIApplication *)application {
 58     [self hookedApplicationWillResignActive:application];
 59 }
 60 
 61 - (void)hookedApplicationDidEnterBackground:(UIApplication *)application {
 62     [self hookedApplicationDidEnterBackground:application];
 63 }
 64 
 65 - (void)hookedApplicationWillEnterForeground:(UIApplication *)application {
 66     [self hookedApplicationWillEnterForeground:application];
 67 }
 68 
 69 - (void)hookedApplicationDidBecomeActive:(UIApplication *)application {
 70     [self hookedApplicationDidBecomeActive:application];
 71 }
 72 
 73 - (void)hookedApplicationWillTerminate:(UIApplication *)application {
 74     [self hookedApplicationWillTerminate:application];
 75 }
 76 
 77 /*支付宝对应的方法*/
 78 - (BOOL)hookedApplication:(UIApplication *)application openURL:(NSURL *)url sourceApplication:(NSString *)sourceApplication annotation:(id)annotation {
 79     [self hookedApplication:application openURL:url sourceApplication:sourceApplication annotation:annotation];
 80     return YES;
 81 }
 82 
 83 
 84 
 85 -(BOOL)hookedApplication:(UIApplication*)application handleOpenURL:(NSURL*)url {
 86     [self hookedApplication:application handleOpenURL:url];
 87     return YES;
 88 }
 89 
 90 
 91 #pragma 默认
 92 /*default 默认不需要改动*/
 93 - (BOOL)defaultApplication:(UIApplication*)application didFinishLaunchingWithOptions:(NSDictionary*)dic { return YES;
 94 }
 95 
 96 - (void)defaultApplicationWillResignActive:(UIApplication *)application {}
 97 
 98 - (void)defaultApplicationDidEnterBackground:(UIApplication *)application {}
 99 
100 - (void)defaultApplicationWillEnterForeground:(UIApplication *)application {}
101 
102 - (void)defaultApplicationDidBecomeActive:(UIApplication *)application {}
103 
104 - (void)defaultApplicationWillTerminate:(UIApplication *)application {}
105 
106 - (BOOL)defaultApplication:(UIApplication *)application openURL:(NSURL *)url sourceApplication:(NSString *)sourceApplication annotation:(id)annotation {
107     return YES;
108 }
109 
110 - (BOOL)defaultApplication:(UIApplication *)application handleOpenURL:(NSURL *)url {
111     return YES;
112 }
113 @end

shutil模块

模块功能:  1个比较高级的 文件、文件夹、压缩包 处理模块

图片 11图片 12

#!/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')

文件.权限.目录操作

有关这些HookUtils做几点表达: 

HookUtils是IOS的Hook机制的兑现,所以适用于具有IOS的付出,那里只是针对性Air应用做了一些拍卖。 

Hook机制中须求得到使用的达成了生命周期的类名,那样才能Hook处理,假若您是Xcode工程开发的代码这您会很便宜的找到那个类名,这适用于IOS原生,Unity以及Cocos引擎,因为它们都会使用Xcode开发工具。可是,Air开发是在Flash
Builder上,并不间接涉及到Xcode工程,通过代码打字与印刷Air应用的性命周期类,找到了Air的类名CTAppDelegate,于是代码中设置为,其余斯特林发动机自行修改,当然,你也得以透过配备文件(Info.plist)获取,那样代码就不需求修改了

 Class oldClass = objc_getClass([@"CTAppDelegate" UTF8String]);


你供给在hooked**措施中完结您的实际代码,最终在+ (void)load()形式中调用头文件定义的法子(void)hookMehod:(SEL)oldSEL andDef:(SEL)defaultSEL andNew:(SEL)newSEL;来达到Hook的目的

shutil.make_archive(base_name, format,…)

创办压缩包并回到文件路径,例如:zip、tar

成立压缩包并回到文件路径,例如:zip、tar

  • 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’)

shutil 对压缩包的拍卖是调用 ZipFile 和 TarFile 八个模块来兑现的,详细:

图片 13图片 14

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()

zipfile压缩解压缩

图片 15图片 16

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()

tarfile压缩解压缩

 

 

上边是援引那篇博客的,我加好代码后就难题了, 那哪个地方来调用它呢。
问了有经验的iOS开发者才领会 其实并不用在其余函数里面来调用这几个HookUtil里的函数,
这么些类方式 load正是进口, 只要申明为类措施并起名load会被系统自动调用。
制作好ane
后在demo中测试,原本能够跑起来的demo自从加了HookUtil反而运营就闪退了,通过观看log发现
hookMethod执行了,果然是系统活动调用那几个代码, ane
还没在demo中通过按钮触发实例化呢

json和pickle模块

事先大家上学过用eval内置方法能够将多个字符串转成python对象,可是,eval方法是有局限性的,对于普通的数据类型,json.loads和eval都能用,但境遇越发类别的时候,eval就不管用了,所以eval的严重性照旧通常用来推行八个字符串表明式,并重临表明式的值。

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

什么样是系列化?

笔者们把对象(变量)从内部存款和储蓄器中变成可存款和储蓄或传输的长河称之为体系化,在Python中叫pickling,在别的语言中也被称之为serialization,marshalling,flattening等等,都以一个趣味。

缘何要类别化?

1:持久保存情状

需知3个软件/程序的实行就在处理一多元情景的转移,在编程语言中,’状态’会以五光十色有社团的数据类型(也可回顾的知情为变量)的花样被保存在内部存款和储蓄器中。

内部存款和储蓄器是力不从心永久保存数据的,当程序运维了一段时间,我们断电恐怕重启程序,内部存款和储蓄器中关于那几个程序的事先一段时间的数码(有组织)都被清空了。

在断电或重启程序从前将顺序当前内存中全数的数目都保留下去(保存到文件中),以便于下次程序执行能够从文件中载入在此之前的数额,然后继续执行,那便是体系化。

实际的来说,你玩任务召唤闯到了第二3关,你保存游戏情状,关机走人,下次再玩,还是能够从上次的地方上马持续闯关。或如,虚拟机状态的挂起等。

2:跨平台数据交互

类别化之后,不仅能够把种类化后的剧情写入磁盘,还足以经过互连网传输到其余机器上,即使收发的两岸约定好实用一种体系化的格式,那么便打破了阳台/语言差别化带来的界定,落成了跨平台数据交互。

扭曲,把变量内容从体系化的靶子重新读到内部存款和储蓄器里称之为反系列化,即unpickling。

于是乎扩大log 最终稳定到在34行  assert(oldMethod);  那行挂掉,原来
oldMethod是null ,然而看半天没看出来哪里错了, 后来可疑25行  oldClass   会不会也是null 呢,
于是加了日记  NSLog(@”oldclass
%@”, oldClass);  果然
也是null , 那时候想起那篇博客,可能不是CTAppDelegate 那几个名字呢?
那篇博客说通过代码打字与印刷Air应用的人命周期类,找到了Air的类名CTAppDelegate。
于是在 hookMethod里面打字与印刷  

json类别化应用

假如大家要在不同的编制程序语言之间传递对象,就亟须把对象体系化为专业格式,比如XML,但更好的措施是体系化为JSON,因为JSON代表出来正是四个字符串,能够被全数语言读取,也得以便宜地蕴藏到磁盘或许通过网络传输。JSON不仅是正经格式,并且比XML更快,而且能够从来在Web页面中读取,分外有益。

JSON代表的靶子正是行业内部的JavaScript语言的靶子,JSON和Python内置的数据类型对应如下:

图片 17

图片 18

示例:

图片 19图片 20

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)

json.dumps和json.loads

图片 21图片 22

# ********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'>
'''

json.dump和json.load

 注意的难点:

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

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

'''
执行结果:
{'1': '111'}
'''

注:  无论数额是什么成立的,只要满意json格式,就足以json.loads出来,不必然非要dumps的多寡才能loads

1    id delegate = [UIApplication sharedApplication].delegate;
2     NSLog(@"delegate %@", delegate);

pickle类别化应用

 图片 23

图片 24图片 25

import pickle


dic = {'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
'''

pickle.dumps和pickle.loads

图片 26图片 27

import pickle

dic = {'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
'''

pickle.dump和pickle.load

注:
Pickle的题材和有着其余编制程序语言特有的系列化问题同样,便是它只好用于Python,并且恐怕两样版本的Python互相都不般配,由此,只可以用Pickle保存那个不首要的数目,无法打响地反连串化也没涉及。 

 

唯独依然null ,然后又想啊, 会不会是机会太早啊。 于是置身了
ane的2个api方法里面在 应用层demo中通过按钮触发,

shelve模块

shelve模块比pickle模块简单,唯有三个open函数,再次回到类似字典的对象,可读可写;key必须为字符串,而值能够是python所支撑的数据类型

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()
'''
执行结果:
['piao', 'smoking', 'drinking']
'''

 

1 FREObject initSDK(FREContext ctx, void *data, uint32_t argc, FREObject argv[])
2 {
3     id delegate = [UIApplication sharedApplication].delegate;
4     NSLog(@"------------delegate %@", delegate);
5 }

xml模块

xml是落实分歧语言或程序之间进行数据沟通的说道,跟json大概,但json使用起来更简短,然而,东汉,在json还没出生的浅绿时期,大家只可以选取用xml呀,到现在很多价值观商行如金融行业的广大类别的接口还第叁是xml。

xml的格式如下,便是经过<>节点来区分数据结构的:

图片 28图片 29

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

xml数据

xml协议在逐一语言里的都 是协助的,在python中常用以下格局操作xml:

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

图片 30图片 31

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')

示例

图片 32图片 33

#在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')

添加子节点

创建xml文档:

图片 34图片 35

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) #打印生成的格式

示例

 

果然不再是null 了, 打字与印刷出来的名字也不是CTAppDelegate,而是 CTAppController
笔者的 airsdk 是21 ,adobe adobe 又改名字了。  把25行代码中的CTAppDelegate
改成 CTAppController 之后测试, delegate中的函数获得正确调用,
落成生命周期delegate就此消除

configparser模块

针对key/value情势的陈设文件举办增加和删除改查操作

图片 36图片 37

# 注释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

settings.ini

注:
个中的key/value也足以形如k1:v1的格式

常用操作

图片 38图片 39

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

import configparser

config=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; 浮点数

读取

图片 40图片 41

import configparser

config=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'))

修改或追加

程序中运用的配备文件key/value格式绝相比较较宽泛,如php.ini文件就依据这种格式。

演示文件的格式如下,文件名为settings.ini:

[Block]
zoneid = 40002
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

获取具有节点

import configparser
config=configparser.ConfigParser()
config.read('settings.ini',encoding='utf-8')
res=config.sections()
print(res)

'''
打印结果:
['Block', 'db', 'center', 'gateway']
'''

 获取钦命节点下拥有的键值对

import configparser
config=configparser.ConfigParser()
config.read('settings.ini',encoding='utf-8')
res=config.items('Block')
print(res)

'''
打印结果:
[('zoneid', '40002'), ('opendatasys', 'True')]
'''

获得钦赐节点下具有的键

import configparser
config=configparser.ConfigParser()
config.read('settings.ini',encoding='utf-8')
res=config.options('Block')
print(res)

'''
打印结果:
['zoneid', 'opendatasys']
'''

获取内定节点下钦点key的值

import configparser
config=configparser.ConfigParser()
config.read('settings.ini',encoding='utf-8')

res1=config.get('center','CENTERHOST')
res2=config.getint('center','CENTERPORT')
print(res1)
print(res2)

'''
打印结果:
127.0.0.1
42000
'''

增加和删除改查

图片 42图片 43

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

增删改查

遵照上述的办法新建四个配置文件

import configparser

config = configparser.ConfigParser()
# 默认的section
config["DEFAULT"] = {'ServerAliveInterval': '45',
                     'Compression': 'yes',
                     'CompressionLevel': '9'}
# 新建一个section,方法1
config['bitbucket.org'] = {}
config['bitbucket.org']['User'] = 'hg'      # key/value

# 新建一个section,方法2
config['topsecret.server.com'] = {}
topsecret = config['topsecret.server.com']
topsecret['Host_Port'] = '50022'        # mutates the parser
topsecret['ForwardX11'] = 'no'          # same here

# 在默认的section中增加一个新的option
config['DEFAULT']['ForwardX11'] = 'yes'
with open('example.ini', 'w') as configfile:
    config.write(configfile)

 

DEFAULT section

要是安插文件中存在1个名为 DEFAULT 的 section,那么其余 section
会增加它的 option 并且能够覆盖它的 option。

图片 44图片 45

[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

db.conf

图片 46图片 47

import configparser

cp = 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_section.py

插值 Interpolation

SafeConfigParser 提供了插值的性状来构成数据。

图片 48图片 49

[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

url.conf

图片 50图片 51

import configparser

cp = configparser.ConfigParser()
cp.read('url.conf')

print(cp.get('http', 'url'))    # http://localhost:8080/
print(cp.get('ftp', 'url'))    # ftp://192.168.1.102/

interpolation_demo.py

 

 

hashlib模块

 hash:一种算法 ,3.x里代替了md5模块和sha模块,首要提供 SHA1, SHA224,
SHA256, SHA384, SHA512 ,MD5 算法
四本性状:

  1. 内容同样则hash运算结果同样,内容有点改变则hash值则变
  2. 不可逆推
  3. 同样算法:无论校验多少长度的数量,获得的哈希值长度固定。

图片 52图片 53

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

import hashlib

string = "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
'''

示例

 注: 把一段十分短的多少update数十次,与三遍update那段长数据,获得的结果同样,可是update多次为校验大文件提供了也许。

 以上加密算法就算依然丰盛了得,但时候存在缺陷,即:通过撞库能够反解。所以,有必不可少对加密算法中添加自定义key再来做加密。

low = hashlib.md5()
low.update('HelloWorld'.encode('utf-8'))
res = low.hexdigest()
print("普通加密:",res)

high = hashlib.md5(b'e1b8klemn3L')              # 默认自定义一个key值
high.update('HelloWorld'.encode('utf-8'))
res = high.hexdigest()
print("采用key加密:",res)

'''
普通加密: 68e109f0f40ca72a15e05cc22786f8e6
采用key加密: 94774db9f7276dbcb9b75cf690c568ac
'''

图片 54图片 55

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 dic

def 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))

模拟撞库破解密码

暴力破解:模拟撞库

 python 还有一个 hmac 模块,它里面对大家创造 key 和 内容
举办更进一步的拍卖然后再加密:

1 import hmac
2 h = hmac.new('Hello'.encode('utf8'))
3 h.update('World'.encode('utf8'))
4 print (h.hexdigest())           # c71c0cd0dc2449bdd89d28eb03bef204

 

 subprocess模块

图片 56图片 57

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信息。

subprocess.波普n参数介绍

常用操作:

图片 58图片 59

#!/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的stdin
                 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 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解码

示例

参考链接: https://docs.python.org/2/library/subprocess.html?highlight=subprocess#frequently-used-arguments

 

logging模块

1. 计算:用于便捷记录日志且线程安全的模块

  • 要是不点名filename,则暗中认可打字与印刷到极限
  • 点名日志级别:

内定形式:
1:level=10
2:level=logging.ERROR

日记级别项目:
CRITICAL = 50
FATAL = CRITICAL
ERROR = 40
WARNING = 30
WARN = WARNING
INFO = 20
DEBUG = 10
NOTSET = 0

  • 钦定日志级别为ERAV4RO奇骏,则唯有E帕杰罗RO奥迪Q3及其以上级其余日志会被打字与印刷

图片 60图片 61

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

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('warning')
logging.error('error')
logging.critical('critical')
logging.log(10,'log')       # 如果level=40,则只有logging.critical和loggin.error的日志会被打印

示例

2. 可在logging.basicConfig()函数中经过具体参数来改变logging模块暗许行为,可用参数有:

  1. filename:用钦点的公文名创造FiledHandler,那样日志会被贮存在内定的文件中。
  2. filemode:文件打开情势,在钦命了filename时使用这一个参数,暗许值为“a”还可钦点为“w”。
  3. format:钦定handler使用的日志展现格式。 
  4. datefmt:内定日期时间格式。 
  5. level:设置rootlogger(前边会讲解具体概念)的日记级别 
  6. stream:用钦点的stream创造StreamHandler。能够内定输出到sys.stderr,sys.stdout也许文件,暗中认可为sys.stderr。若同时列出了filename和stream多个参数,则stream参数会被忽略。
  7. 点击查看更详尽

3. 日志格式

%(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

用户输出的消息

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

paramiko模块

paramiko是2个用于做长途控制的模块,使用该模块能够对长距离服务器实行命令或文件操作,值得一说的是,fabric和ansible内部的远程管理正是运用的paramiko来现实。

安装

pycrypto,由于 paramiko 模块内部依赖pycrypto,所以先下载安装pycrypto
pip3 install pycrypto
pip3 install paramiko

注:如果在安装pycrypto2.0.1时发生如下错误
        command 'gcc' failed with exit status 1...
可能是缺少python-dev安装包导致
如果gcc没有安装,请事先安装gcc

应用:

SSHClient

用以连接远程服务器并进行基本命令

依照用户名密码连接:

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='shuke', password='123')

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

# 关闭连接
ssh.close()

图片 62图片 63

import paramiko

transport = paramiko.Transport(('hostname', 22))
transport.connect(username='shuke', password='123')

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

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

transport.close()

SSHClient 封装 Transport

据书上说公钥密钥连接:

图片 64图片 65

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='shuke', key=private_key)

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

# 关闭连接
ssh.close()

示例

图片 66图片 67

import paramiko

private_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 = transport

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

transport.close()

SSHClient封装Transport

图片 68图片 69

import paramiko
from io import StringIO

key_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 = transport

stdin, stdout, stderr = ssh.exec_command('df')
result = stdout.read()

transport.close()

print(result)

依据私钥字符串实行再而三

SFTPClient

用来连接远程服务器并推行上传下载

根据用户名密码上传下载

import paramiko

transport = paramiko.Transport(('hostname',22))
transport.connect(username='shuke',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()

基于公钥密钥上传下载

import paramiko

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

transport = paramiko.Transport(('hostname', 22))
transport.connect(username='shuke', 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()

图片 70图片 71

#!/usr/bin/env python
# -*- coding:utf-8 -*-
import paramiko
import uuid

class Haproxy(object):

    def __init__(self):
        self.host = '172.16.103.191'
        self.port = 22
        self.username = 'shuke'
        self.pwd = '123'
        self.__k = None

    def create_file(self):
        file_name = str(uuid.uuid4())
        with open(file_name,'w') as f:
            f.write('sb')
        return file_name

    def 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 = transport

    def close(self):

        self.__transport.close()

    def upload(self):
        # 连接,上传
        file_name = self.create_file()

        sftp = paramiko.SFTPClient.from_transport(self.__transport)
        # 将location.py 上传至服务器 /tmp/test.py
        sftp.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

Demo

 

re模块

1.哪些是正则?

正则正是用一些全数尤其含义的记号组合到一起(称为正则表明式)来叙述字符可能字符串的格局。或然说:正则正是用来讲述一类东西的条条框框。(在Python中)它内嵌在Python中,并经过
re 模块达成。正则表明式方式被编译成一多元的字节码,然后由用 C
编写的合营引擎执行。

2.常用格外形式(元字符)

图片 72

图片 73图片 74

#!/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']

re匹配情势

图片 75图片 76

#!/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

re模块提供的不二法门

从网页源码中格外标签的接纳:

图片 77图片 78

#!/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>

匹配标签

图片 79图片 80

#!/usr/bin/env python
#-*- coding:utf-8 -*-
import re

print(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'] 找出所有整数

协作数字

图片 81图片 82

#!/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">1<div class="rk "><a href="/song?id=476630320"><img class="rpic" src="http://www.baidu.com></a></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>',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,re

respone=requests.get('https://book.douban.com/').text
# print(respone)
print('======'*100)
res=re.findall('<li.*?cover.*?href="(.*?)".*?title="(.*?)">.*?more-meta.*?author">(.*?)(.*?)(.*?)',respone,re.S)
# res=re.findall('<li.*?cover.*?href="(.*?)".*?more-meta.*?author">(.*?)(.*?)(.*?).*?</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()))

示例

示例

图片 83图片 84

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_-]+)+

IP|手机号|邮箱

常用匹配语法:

re.match     从头开始匹配
re.search    匹配包含
re.findall    把所有匹配到的字符放到以列表中的元素返回
re.splitall   以匹配到的字符当做列表分隔符
re.sub         匹配字符并替换

 

三. 软件开发目录结构正式

何以要规划好目录结构?

“设计项目目录结构”,就和”代码编码风格”一样,属于个人风格难题。对于那种风格上的正经,一向都存在二种态度:

  1. 一类同学认为,那种个人风格难点”非亲非故首要”。理由是能让程序work就好,风格难点根本不是题材。
  2. 另一类同学觉得,规范化能更好的主宰程序结构,让程序有所更高的可读性。

本身是比较偏向于后者的,因为小编是前一类同学思想表现下的直白受害者。笔者曾经维护过1个十三分不佳读的门类,其落到实处的逻辑并不复杂,可是却消耗了笔者至极长的时日去领略它想表明的情致。从此小编个人对于增强项目可读性、可维护性的供给就很高了。”项目目录结构”其实也是属于”可读性和可维护性”的框框,大家统一筹划一个井井有序的目录结构,正是为了完成以下两点:

  1. 可读性高:
    不熟悉那个项指标代码的人,一眼就能看懂目录结构,知道程序运行脚本是哪个,测试目录在何方,配置文件在何方之类。从而丰硕迅猛的摸底这么些项目。
  2. 可维护性高:
    定义好协会规则后,维护者就能很显著地领悟,新增的哪些文件和代码应该放在怎么样目录之下。那个利益是,随着时间的推迟,代码/配置的层面追加,项目布局不会混杂,依然能够协会卓越。

之所以,作者觉得,保持一个层次鲜明的目录结构是有必不可少的。更何况协会3个佳绩的工程目录,其实是一件很简短的事情。

目录协会方式

至于怎样协会二个较好的Python工程目录结构,已经有局地拿走了共识的目录结构。在Stackoverflow的其一题材上,能看到大家对Python目录结构的议论。

此处面说的早已很好了,作者也不打算重新造轮子列举各个分化的主意,那之中笔者说一下作者的精晓和体会。

只要你的类型名为foo, 小编相比较提出的最方便连忙目录结构那样就够用了:

Foo/
|-- bin/
|   |-- foo
|
|-- foo/
|   |-- tests/
|   |   |-- __init__.py
|   |   |-- test_main.py
|   |
|   |-- __init__.py
|   |-- main.py
|
|-- docs/
|   |-- conf.py
|   |-- abc.rst
|
|-- setup.py
|-- requirements.txt
|-- README

一言以蔽之解释一下:

  1. bin/:
    存放项指标有的可执行文件,当然你能够起名script/等等的也行。
  2. foo/: 存放项目标持有源代码。(1)
    源代码中的全数模块、包都应该置身此目录。不要置于顶层目录。(2)
    其子目录tests/寄存单元测试代码; (3)
    程序的输入最棒命名为main.py
  3. docs/: 存放一些文书档案。
  4. setup.py: 安装、布署、打包的剧本。
  5. requirements.txt: 存放软件注重的表面Python包列表。
  6. README: 项目表明文件。

除开,有局地方案提交了更为多的始末。比如LICENSE.txt,ChangeLog.txt文件等,小编从未列在那里,因为这一个东西主借使系列开源的时候需求用到。假使您想写1个开源软件,目录该怎么组织,能够参见那篇文章

上边,再不难讲一下自家对那么些目录的知晓和民用供给吗。

关于README的内容

以此作者觉着是每一个品种都应该有的3个文书,目标是能简单描述该类型的新闻,让读者相当的慢领悟那个类型。

它必要证实以下多少个事项:

  1. 软件定位,软件的基本成效。
  2. 运作代码的措施: 安装环境、运维命令等。
  3. 容易的施用验证。
  4. 代码目录结构表达,更详细点可以表明软件的基本原理。
  5. 广泛难题求证。

自笔者觉着有上述几点是比较好的四个README。在软件开发初期,由于开发进程中上述内容恐怕不肯定只怕发生变化,并不是听其自然要在一开首就将全部音信都补全。但是在品种截至的时候,是需求写作那样的1个文书档案的。

能够参照Redis源码中Readme的写法,这在那之中简洁不过清晰的叙说了Redis效率和源码结构。

关于requirements.txt和setup.py

setup.py

诚如的话,用setup.py来保管代码的包裹、安装、安顿难点。产业界规范的写法是用Python流行的包装工具setuptools来管理那一个事情。那种办法广泛选择于开源项目中。可是那里的核心理想不是用标准的工具来消除这几个标题,而是说,一个种类必然要有3个装置配置工具,能高效便捷的在一台新机器大校环境装好、代码布署好和将程序运维起来。

以此自家是踩过坑的。

本人刚伊始接触Python写项目标时候,安装环境、安顿代码、运维程序那几个进度全是手动完结,蒙受过以下难题:

  1. 设置环境时常常忘了近期又添加了叁个新的Python包,结果一到线上运转,程序就出错了。
  2. Python包的版本重视难题,有时候我们先后中央银行使的是三个版本的Python包,然则官方的已经是风靡的包了,通过手动安装就只怕装错了。
  3. 若果依靠的包很多来说,2个二个装置那几个依赖是很吃力的事体。
  4. 新校友起头写项目标时候,将先后跑起来格外麻烦,因为恐怕时时忘了要怎么设置各样注重。

setup.py能够将那些事情自动化起来,进步功效、减弱失误的可能率。”复杂的事物自动化,能自动化的东西必定要自动化。”是三个老大好的习惯。

setuptools的文档正如庞大,刚接触的话,大概不太好找到切入点。学习技能的办法正是看外人是怎么用的,能够参考一下Python的三个Web框架,flask是如何写的: setup.py

自然,不难点本人写个安装脚本(deploy.sh)替代setup.py也未尝不可。

requirements.txt

其一文件存在的目标是:

  1. 便宜开发者维护软件的包注重。将付出进度中新增的包添加进那些列表中,制止在setup.py设置注重时漏掉软件包。
  2. 造福读者分明项目选拔了如何Python包。

其一文件的格式是每一行李包裹括二个包注重的验证,日常是flask>=0.10那种格式,供给是那些格式能被pip识别,这样就足以归纳的经过 pip install -r requirements.txt来把全数Python包依赖都装好了。具体格式表达: 点这里

至于配置文件的施用格局

专注,在上头的目录结构中,没有将conf.py坐落源码目录下,而是放在docs/目录下。

不少类型对安顿文件的选择做法是:

  1. 计划文件写在2个或多少个python文件中,比如此处的conf.py。
  2. 项目中哪些模块用到这么些布局文件就径直通过import conf那种样式来在代码中运用安排。

那种做法笔者不太辅助:

  1. 那让单元测试变得紧Baba(因为模块内部正视了表面配置)
  2. 一方面配置文件作为用户控制造进度序的接口,应当能够由用户自由钦点该文件的路子。
  3. 程序组件可复用性太差,因为那种贯穿全体模块的代码硬编码形式,使得大多数模块都依靠conf.py那几个文件。

因而,笔者觉着配置的选拔,更好的点子是,

  1. 模块的配备都以能够灵活安顿的,不受外部配置文件的震慑。
  2. 程序的安排也是能够灵活决定的。

可见佐证那些考虑的是,用过nginx和mysql的同窗都掌握,nginx、mysql那么些程序都得以肆意的钦命用户配置。

从而,不应该在代码中央直机关接import conf来使用安插文件。下面目录结构中的conf.py,是付诸的2个配置样例,不是在写死在程序中直接引用的布署文件。能够经过给main.py起步参数指定安顿路径的法门来让程序读取配置内容。当然,这里的conf.py您能够换个像样的名字,比如settings.py。或然你也足以动用别的格式的内容来编排配置文件,比如settings.yaml之类的。

 

 

有关链接:

  1.  http://www.cnblogs.com/wupeiqi/articles/5501365.html

  2.  http://www.cnblogs.com/linhaifeng/articles/6384466.html

 

发表评论

电子邮件地址不会被公开。 必填项已用*标注

网站地图xml地图