Python之路【第七首】:常用模块

Hello NHibernate

作者:陈省  

 

(一) 天地模型 vs 数据集

每当马丁Flower的《集团应用架构格局》一修被涉及了集团应用的政工逻辑的团伙着重分为以下二种情势:面向过程的作业脚本、面向对象的小圈子模型和面向数据集的出模式。

微软.Net
Framework中提供了大气之多少感知组件使得开发者可以利用RAD的组件急迅支付基于DataSet的集团应用来。开发者只要在界面上布置有多少感知组件如DataGrod,设定及数据源的连续,以及相应的表明和字段,一个大概的次第即便入手定了。面向数据集的开支情势分外适合于中小型的集团应用程序开发,但是对复杂的应用程序来说,使用这种开发模式随着事情逻辑复杂度的加便相会渐渐显得力不从心了。

率先,使用RAD和多少感知组件,就代表数据表现层以及数库表的紧偶合,每动一个数量感知组件,都一定给以数据的示视图偶合到了数据库的之一表要某字段上,任何针对数据模型的转移都会晤导致对负有绑定到转的表或字段的数据感知组件的修改。

其余,使用弱类型数据集中读取数据时,平时是遵照字段名来获取字段的靶子的值,如DataReader[“Spell”].ToString(),该法是以字符串来抱数量集中的许段值,这时编译器是无力回天帮忙我们发现这种组件的绑定是否尽让修正了,虽然以的字段名称错误了,编译器如故会觉得代码没有不当,这样要变更之组件和库表之间的绑定好不便让整个发现,通常会有着遗漏,而由于改动引起的荒谬平常只能是于运转时才可以为发觉,那便代表一旦消费重新多之时空才可以发现错误。而且假使测试时,错误的代码没有叫测试所覆盖的言辞,则错误或使交客户以时才会吃发觉,这时造成的产物可能早就不可以挽回了。而采纳面向对象的领域模型时,对业务域对象的操作都是经对象的特性或者措施来展开的,如AObj.XXX方法,对指标属性名称或措施举办了改变的话,编译器会匡助我们找到有对该对象的未得法的操作,那意味着可以另行早地窥见和解决bug。即使以.Net平台受到指出了强类型数据集的定义,它可兑现表间关联,编辑校验的数集属性,从某种程度上弥补了弱类型数据集的短处,然则跟完系数向对象的天地模型对照,强类型数据集只好兑现基本数据列的属性,并且不得不促成数据库一级的属于性值约束,比如无法兑现枚举类型的性。而世界模型则免设有这样的题材。

   
同时,使用数据感知组件,意味着跟数据库的蓄意特性的紧偶合,比如以削减代码量和进步效用,通常索要采取有数据库平台相关的非正规sql,或者以部分复杂的sql写成平台相关的仓储过程,这样当于不同数据库平台移植时,需要重编辑大量的业务逻辑。而面向对象的开发模式一般按照面向对象的查询语言,具有一致性,更加便于实现数据库平台无关性,实现系统造福地迁移。

   
此外,基于数据集的开情势难于应用继续、设计形式等面向对象的开发方法,并且数据集对象非克包含自定义的操作。而世界模型则从未这样的障碍,开发的系进一步直观和爱懂。

 

(二)面向对象的数据库开发框架NHibernate

 

近期,越来越多的食指认识及利用面向对象的公司应用开发框架来展开系统的开有广大之补益。在路设计阶段,使用UML建模语言设计业务域对象模型,从模型出发,定义业务域对象,运行时对业务域对象的习性举办操作,直接以业务域对象保存及数据库,或者从数据库加载,消除对面向数据集的Sql的借助,这便是见惯不惊所说之OR
Mapping,对象-关系映射方法。

当Java平台达成,OR
Mapping的开源框架的No.1就是Hibernate,Hibernate是一个轻量级的OR
Mapping解决方案,一经推出就抱了高大的打响,在刚发布的EJB3.0的草案中尽管吸纳了汪洋底Hibernate中之表征。从2004年2月上马,SourceForge上发表了.Net版本的NHibernate的Alpha版本,如今NHibernate的开发进展非凡空心入网,平均每一个半月份就是会合宣布一个新的本子。

NHibernate具有以下特点:

靶持续性:可以管理.Net类至数库表的投射,以目标的方存取数据,协助复杂对象、复合对象,匡助对象期间的涉,比如继续,聚合,关联。OR
Mapping的定义都是按照XML,具有相当好的增加性和通用性。可以支撑现有的数据库定义,很好地珍爱用户投资。

支撑对象查询:提供了面向对象的查询语言(HQL和准星查询),可以依照标准查询复合对象与对象集合。

支撑工作:创制还非得扶助悲观锁的业务,并提供了乐观锁的起帮助。

性能优化:允许用户以定制的Sql来进步查询的属性,提供了又SQL自动策略开关,使得框架生成的Sql语句具有相当优化的性。提供了灵活的Cache缓冲机制,以及延缓加载,批量翻新的方针,保证一般以之特性不会面低于相应的数据集应用。

数据库平台无关性:使用OR
Mapping技术实现了数据库平台无关性,能够随时切换出与数据库发表平台,方便移植。 

NHibernate的系布局示意图:

祈求被之Session对应于应用程序同持久层的相同不良对话,其中保存有必不可少的持久化对象的缓存,可以由此标识符查找持久对象。持久层同底层数据库中的操作是经过ADO.Net来贯彻之。

(二)Hello NHibernate

   
接下来大家前成立一个异常简单的NHibernate的以,它相仿于一个留言簿的效能,能够以用户输入的音讯保存到数据库中。

未雨绸缪干活

第一由SourceForge上下载NHibernate最新版本,本文基于NHibernate
0.1.0.0。,将下载的缩小包解压缩到一个索引下。然后,启动VS.Net
Studio,创立一个Windows应用程序的花色,起名为HelloNHibernate,并累加NHibernate.dll,
log4jnet.dll, HashCodeProvider.dll引用(位于NHibernate的Bin子目录下)。

接下,创立一个当MS Sql
Server2000上创立一个NHibernate的数据库。有矣数据库,大家要写app.config配置文件告诉NHibernate到何地失去摸数据库。下边是部署文件内容:

<?xml version=”1.0″ encoding=”utf-8″ ?>

<configuration>

      <configSections>

             <section name=”nhibernate”
type=”System.Configuration.NameValueSectionHandler, System,
Version=1.0.3300.0,Culture=neutral, PublicKeyToken=b77a5c561934e089″
/>

      </configSections>

     <nhibernate>

         <add key=”hibernate.show_sql”

              value=”true”

         />

         <add key=”hibernate.connection.provider”         

              value=”NHibernate.Connection.DriverConnectionProvider”

         />

         <add key=”hibernate.dialect”                     

              value=”NHibernate.Dialect.MsSql2000Dialect”

         />

         <add key=”hibernate.connection.driver_class”         

              value=”NHibernate.Driver.SqlClientDriver”

         />

         <add key=”hibernate.connection.connection_string”

              value=” Provider=SQLOLEDB.1;Integrated
Security=SSPI;Persist Security Info=False;Initial
Catalog=NHibernate;Data Source=localhost”

         />

     </nhibernate>

</configuration>

 

部署文件被的参数有下的意思:

参数

hibernate.show_sql

True表示向控制台输出运行中产生的Sql,用于调试目的

hibernate.connection.provider

表示使用指定的类来提供数据库连接缓冲池。

hibernate.dialect

表示NHibernate方言的类名,可以让NHibernate使用某些特定数据库平台的特性,目前NHibernate支持Sql Server, Oracle, Mysql, Firebird, Sybase, PostgreSql等数据库方言。

hibernate.connection.driver_class

Ado.Net的驱动类,支持SqlServer, Oracle, Mysql,OleDb, ODBC,Firebird等驱动。

hibernate.connection.connection_string

对应于Ado.Net的连接串。

 

业务域模型

基于要求,我们第一来设计业务域模型,模型相当简单,只出半点单特性,其中Id唯一标识一个近乎的实例,万分给类的主键,Text表示用户输入的信息,示意图如下: 

因业务域模型,创建对应之.Net类的定义,代码如下:

     public class Message
     {

         private int _id; 

         public int Id

         {

              get {  return _id; }

              set { _id = value; }   

         }    

         private string _Text;

 

         public string Text
         {

              get {  return _Text; }

              set { _Text = value; }   

         }    

         public Message()

         {

              //

              // TODO: 在这里添加构造函数逻辑

              //

         }

 

         public override string ToString()

         {

              return _Text;

         }

     } 

Message类除了定义了必需的个别单属于性外,还重载了基类的ToString方法,这是为着便于在界面被开展亮。有矣接近定义,我们尚需创建存储Message对象的数目库表,下面就是与Message对象一一对应之数据库表Messages的DbSchema脚论: 

CREATE TABLE [dbo].[messages] (

     [MsgId] [int] IDENTITY (1, 1) NOT NULL ,

     [Text] [varchar] (200) COLLATE Chinese_PRC_CI_AS NULL

) ON [PRIMARY]

GO 

连接下,大家而编写OR Mapping
映射的配备文件Message.hbm.xml来指定Message对象以及数库表的映射关系,下边是开创的映照文件内容: 

<?xml version=”1.0″ encoding=”utf-8″ ?>  

<hibernate-mapping xmlns=”urn:nhibernate-mapping-2.0″>

    <class name=”HelloNHibernate.Message, HelloNHibernate”
table=”messages”>

         <id name=”Id” column=”MsgId” type=”Int32″>

              <generator class=”identity” />

         </id>        

         <property name=”Text” type=”String” length=”200″/>

     </class> 

</hibernate-mapping>

 Xml文件被的Class元素的name属性指定了如拓展映射的好像的名称为HelloNHibernate.Message,同时那么些类似需要由HelloNHibernate
assembly中开展加载,
table属性指定了Message类在数据库被展开百折不挠不懈存储的库表名称也messages。而Id元素用于阐明类标识性对应为数库表的主键字段的映照关系,其中name属性标识类的标识性名称,column属性标识messages表的主键字段的称,type是标识字段的数据类型,而内嵌的generator元素则指明主键字段唯一值的变通方法,这里identity表示NHibernate使用Sql
Server数据库本身提供的起加字段的性状来确保键值唯一。假设我们记忆自己叫Id属性赋值来管唯一性的言辞,可以设定class属性为assigned,这样NHibernate将未会晤自动生成键值。 

概念了文件后,别忘了于VS.Net
Studio校官Message.hbm.xml的转变操作属性修改也坐的资源。还要小心的凡,倘若每一回我们修改了hbm.xml文件,一定要运“重新转”命令来编译项目,否则VS.Net不会面又编译整个项目。 

体现层设计 

亮层的界面设计非凡简单,在界面上停放一个ListBox用于体现信息列表,一个TextBox用于输入音信,三独Button分别用于查询音讯列表、添加音和去音讯,界面示意图如下:

 

 

贯彻业务逻辑

 

查询信息列表

在网每便加载时,大家需要获取音讯列表,下边就是加载音信列表的代码:

 

         private void HelloForm_Load(object sender, System.EventArgs e)

         {

              QueryMessages();

         }

 

         private ISessionFactory factory;

         private void QueryMessages()

         {

              //查询信息列表

起名,              Configuration cfg = new Configuration();

              cfg.AddAssembly(“HelloNHibernate”);

 

              factory = cfg.BuildSessionFactory();

              ISession session = factory.OpenSession();

 

              IList messages =
session.CreateCriteria(typeof(Message)).List();

 

              this.lbMsg.Items.Clear();

              foreach(Message msg in messages)

                   this.lbMsg.Items.Add(msg);

              session.Close();

         }

 

每当QueryMessages方法中,大家率先创设一个Configuration类,然后调用AddAssembly方法应用反射方法以装配件中定义之所有以.hbm.xml命名的Mapping文件加载到系统被,而BuildSessionFactory方法则接纳app.config和hbm.xml配置文件被的定义成立一个SessionFactory,然后据此SessionFactory工厂类创立一个Session会话类,通过调用会话类的尺度查询艺术CreateCriteria再次回到所有类型也
Message的靶子列表。最后,边历列表将音信对象上加至列表框中,并关闭Session,释放ADO.Net的接连对象。 

增长新闻 

长音信稍有一部分不同之凡,每一趟上加时我们都启动一个政工,保证添加音操作的原子性,代码如下:

         private void btnAdd_Click(object sender, System.EventArgs e)

         {
              //添加音

              if (this.tbMsg.Text.Trim()==String.Empty)

              {

                   MessageBox.Show(“信息输入框不可能为空!”);

                   return;

              } 

              Message msg=new Message();

              msg.Text=this.tbMsg.Text.Trim(); 

              ISession session=factory.OpenSession();

              ITransaction transaction = session.BeginTransaction(); 

              session.Save(msg);

              transaction.Commit();

              session.Close(); 

              this.lbMsg.Items.Add(msg);

         }

运作后,添加几修记下,用Sql
Server能够观测到数据库被的数目示意入下: 

除去音讯 

去信息之操作与添加比(Gaby)较像样,代码示意如下:

         private void btnDel_Click(object sender, System.EventArgs e)

         {

              //删除新闻

              if (this.lbMsg.SelectedIndex==-1)

              {

                   MessageBox.Show(“请选中而抹的信息!”);

                   return;

              }

 

              Message msg=(Message)lbMsg.Items[lbMsg.SelectedIndex];

 

              ISession session=factory.OpenSession();

              ITransaction transaction = session.BeginTransaction(); 

              session.Delete(msg);

              transaction.Commit();

              session.Close(); 

              this.lbMsg.Items.RemoveAt(lbMsg.SelectedIndex);        

         } 

完成点的程序后,大家会晤发觉整整经过中我们没有写一漫漫Sql语句就好了增长、删除、查询数据的功能,所有的Sql语句都是因为NHibernate在后台为大家完成了,要想观看NHibernate生成的Sql语句的话,我们可以启动Sql
Server的事件探查器来监视程序运行过程被之Sql,如下图表示: 

总结

   
在本文中,我们演示了什么样采纳NHibernate,在未使用Sql的情况下实例化一个目的,修改属性,并拿这多少个保存及数据库被。在延续作品中,我还用与我们一同啄磨怎么着映射对象的涉嫌,如一针对性几近,多针对大多,继承、聚集,以及面向对象的原则查询与HQL语言等情节。

转自Delphi深度探索 
出处:http://delphi.sharpplus.com/DotNet/NHibernate1.htm

一. 模块介绍

1. 啊是模块

每当前面的七只章节中大家基本上是用 python 解释器来编程,借使您于 Python
解释器退出又上,那么你定义之有着的主意与变量就还石沉大海了。

为夫 Python
提供了一个智,把这么些概念存放于文书中,为部分剧本或者交互式的解释器实例使用,这多少个文件为名模块。

模块是一个包含有你定义之函数和变量的文本,其后缀名是.py。模块可为此外程序引入,以运该模块中的函数等力量。这也是利用
python 标准库的法门。

设:os 是网相关的模块;file是文本操作相关的模块

模块分为三栽:

  • 于定义模块
  • 其三正模块
  • 松内衣模特块

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

2、导入模块

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自带的效果,在运用内置模块相应的效能时,需要遵从【起先入】再【使用】的标准化

 

二. 常用模块

time模块

在Python中,平常有应声三种方法来表示时间:

  • 时穿(timestamp):平时来说,时间戳表示的是由1970年六月1日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)
'''

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路径处理

 

 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中执行无效,请到命令行中以脚本的方式执行
'''

进度条

速长达落实

 

shutil模块

模块功能:  一个于高档的 文件、文件夹、压缩包 处理模块

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

文件.权限.目录操作

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压缩解压缩

 

 

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:持久保存状态

需知一个软件/程序的尽就于处理同多元状态的转变,在编程语言中,’状态’会以五光十色有协会的数据类型(也只是概括的了解啊变量)的款式让保存在内存中。

内存是力不从心永久保存数据的,当程序运行了一段时间,我们断电或重新开程序,内存中有关此序的前头一段时间的数额(有结构)都为清空了。

每当断电或重复开程序以前将先后当前外存中所有的数目还保存下去(保存至文件中),以便为下次程序执行可以从文本被载入以前的多少,然后继续尽,这便是系列化。

具体的吧,你玩使命召唤闯到了第13牵连,你保存游戏状态,关机走人,下次再次游玩,还会于上次底职上马继续闯关。或使,虚拟机状态的挂于等。

2:跨平台数据交互

类别化之后,不仅可以把连串化后的情节写副磁盘,还足以经过网传输到其它机器及,假若收发的两端约定好实用一种体系化的格式,那么即便打破了平台/语言差距化带来的限量,实现了跨越平台数量交互。

扭转,把变量内容由体系化的对象又宣读到内存里称之为反连串化,即unpickling。

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

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保存这一个不重要之多少,不克打响地反系列化也远非提到。 

 

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

 

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

示例

 

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

即使安排文件被有一个称为吧 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

  • 点名日志级别也ERROR,则唯有来ERROR及其以上级此外日志会被打印

起名 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是一个用来做长途控制的模块,使用该模块可本着长途服务器举行命令或文件操作,值得一说之凡,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. 可读性强:
    不谙习这项目之代码的人,一眼便可知看精通目录结构,知道程序启动脚论是孰,测试目录在什么地方,配置文件在哪里之类。从而充裕急速的垂询这多少个路。
  2. 可维护性高:
    定义好协会规则后,维护者就可以杀明朗地精晓,新增的什么人文件及代码应该置身什么目录之下。这一个利益是,随着时空之延迟,代码/配置的范围扩张,项目协会不会师混杂,依旧会社团好。

就此,我觉着,保持一个层次显著的目录结构是暴发必不可少之。更何况协会一个佳的工程目录,其实是同样宗很简单的事宜。

目协会办法

有关什么社团一个比较好之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文件等,我莫排于此间,因为这个东西倘若种开源的时刻要用到。倘诺您想写一个开源软件,目录该怎么协会,可以参照立时首随笔

下边,再简单说一下本人本着这些目录的通晓和私要求吧。

关于README的内容

以此自己觉着是每个系列还应有些一个文件,指标是力所能及大概描述该型之音讯,让读者很快领悟这类型。

其要表达以下几独事项:

  1. 软件定位,软件的基本功效。
  2. 运转代码的不二法门: 安装环境、启动命令等。
  3. 简简单单的行使验证。
  4. 代码目录结构表达,更详细点可以作证软件的基本原理。
  5. 普遍问题求证。

自身认为有以上几乎碰是于好的一个README。在软件开发初期,由于开发进程遭到上述内容恐怕未醒目或爆发变化,并无是肯定要以同等从头就是以享有新闻还加全。然而于档次了之时,是亟需写作这样的一个文档的。

可参考Redis源码中Readme的写法,这其间简洁而清晰的描述了Redis功用跟源码结构。

关于requirements.txt和setup.py

setup.py

貌似的话,用setup.py来保管代码的卷入、安装、部署问题。业界规范的写法是故Python流行的包裹工具setuptools来治本这一个事情。这种办法大拔取被开源项目面临。可是这里的主题思想不是为此标准化的家伙来缓解那一个题材,而是说,一个路必然即便发一个设置配备工具,能高效便捷的于平等高新机器将官环境装好、代码部署好与将程序运行起来。

其一自家是踩了坑的。

自我正好起初接触Python写项目标时,安装环境、部署代码、运行程序是历程均是手动完成,境遇过以下问题:

  1. 设置环境时通常忘记了近年来又补加了一个初的Python包,结果一律到线及运行,程序即便来错了。
  2. Python包的版本依赖问题,有时候大家先后中接纳的是一个本子的Python包,可是官方的已经是风尚的包了,通过手动安装就可能装错了。
  3. 若因之管教多以来,一个一个装置这多少个靠是深讨厌的工作。
  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. 配备文件写于一个或者六只python文件中,比如这里的conf.py。
  2. 种被什么人模块用到此布局文件就径直通过import conf这种样式来当代码中应用安排。

这种做法我非绝襄助:

  1. 即时为单元测试变得勤奋(因为模块内部倚重了表面配置)
  2. 一面配置文件作为用户控制程序的接口,应当可以由用户擅自指定该文件的门道。
  3. 次组件可复用性太差,因为这种贯穿所有模块的代码硬编码格局,使得大部分模块都指conf.py这文件。

故此,我觉着配置的使用,更好的不二法门是,

  1. 模块的布置都是足以活安排的,不被外部配置文件的震慑。
  2. 次的安排为是可活决定的。

会佐证是考虑的凡,用过nginx和mysql的同桌都掌握,nginx、mysql那么些程序还好随心所欲的指定用户配置。

从而,不该在代码中一向import conf来用安排文件。下边目录结构被之conf.py,是于有底一个部署样例,不是在描写很于次中一向引用的布局文件。可以通过让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地图