常用模块(三卡塔尔——shelve、xml、hashlib、con

作者:编程技术

常用模块(三)

1 #--------------------------按图2转换时间
2 # asctime([t]) : 把一个表示时间的元组或者struct_time表示为这种形式:'Sun Jun 20 23:21:05 1993'。
3 # 如果没有参数,将会将time.localtime()作为参数传入。
4 print(time.asctime())#Sun Sep 11 00:43:43 2016
5 
6 # ctime([secs]) : 把一个时间戳(按秒计算的浮点数)转化为time.asctime()的形式。如果参数未给或者为
7 # None的时候,将会默认time.time()为参数。它的作用相当于time.asctime(time.localtime(secs))。
8 print(time.ctime())  # Sun Sep 11 00:46:38 2016
9 print(time.ctime(time.time()))  # Sun Sep 11 00:46:38 2016

* 字符串,字节流,字节数组;

二、xml模块

1、XML全称:可扩展标记语言,标记指的是代表某种含义的字符 XML<>

2、为什么要用xml 

 (1)为能够在不同的平台间继续数据的交换
 (2)为了使交换的数据能让对方看懂,就需要按照一定的语法规范来书写

3、语法格式

(1)任何的起始标签都必须有一个结束标签。
  <tagname></tagname>
  <tagname></tagname>
  <tagname/> 简化写法

(2)可以采用另一种简化语法,可以在一个标签中同时表示起始和结束标签。这种语法是在大于符号之前紧跟一个斜线(/)。

    例如<ABC/>:XML解析器会将其翻译成<ABC></ABC>。
(3)标签必须按合适的顺序进行嵌套,所以结束标签必须按镜像顺序匹配起始标签,这好比是将起始和结束标签看作是数学中的左右括号:在没有关闭所有的内部括号之前,是不            能关闭外面的括号的。

1 <tag1>
2   <tag2>
3     <tag3>
4     </tag3>
5   </tag2>
6 </tag1> 

(4)所有的特性都必须有值。
  特性指的是属性

1 <person name="aaa">
2 </person>

(5)所有的特性都必须在值的周围加上双引号。

4、注意点

(1)最外层有且只有一个标签,这个标签为根标签
(2)第一行应该有文档声明,用于高速计算机怎么理解
  例如:<?xml version="1.0" encoding="utf-8"?>

  

分分快三计划 1分分快三计划 2

1 <person>
2     <sut1>
3     </stu1>
4     <sut2>
5     </stu2>
6 </person>

标签嵌套

5、使用场景:

(1)配置文件
(2)常规的数据交换。 例如从服务器获取一段新闻

6、方法及属性

(1).ElementTree 表示整个文件的元素树
(2.)Element 表示一个节点
 a.属性
     text      开始标签和结束标签中间的文本
     attrib    所有的属性     字典类型
     tag       标签的名字
 b.方法
    get 获取某个属性的值

分分快三计划 3分分快三计划 4

 1 import xml.etree.ElementTree as et
 2 
 3 # 读取xml文档到内存中  得到一个包含所有数据的节点树
 4 # 每一个标签就称之为一个节点 或 元素
 5 tree = et.parse("text.xml")
 6 
 7 # 获取根标签
 8 root = tree.getroot()
 9 
10 # 获取所有的country   
11 print(root.find("country"))   # 找的是第一个
12 print(root.findall("country"))   # 找的是所有
13 
14 # 获取字标签
15 print(root.iter("country"))
16 for i in root.iter("country"):
17     print(i)
18 
19 # 遍历整个xml
20 for country in root:
21      print(country.tag,country.attrib,country.text)
22         for t in country:
23               print(t.tag, t.attrib, t.text)
24 
25 print(root.find("country").get("name"))    

遍历

7、增删改查

1.解析XML
    查找标签
    find      在子标签中获取名字匹配第一个
    findall   在子标签中获取名字匹配的所有标签
    iter(tagname)      在全文中查找[匹配的所有标签 返回一个迭代器

2.生成XML
    用ElmentTree
    parse()  解析一个文件
    getroot() 获取根标签
    write()  写入到文件

3.修改xml
    set 一个属性
    remove 一个标签
    append 一个标签

分分快三计划 5分分快三计划 6

 1 # 读取到内存
 2 tree = et.parse("text.xml")
 3 for country in tree.findall("country"):
 4      yeartag = country.find("year")
 5      yeartag.text = str(int(yeartag.text)   1)   修改标签文本
 6 
 7      country.remove(country.find("year"))     删除标签
 8 
 9     # 添加子标签
10     newtag = et.Element("newTag")
11     # 文本
12     newtag.text = "123"
13     #属性
14     newtag.attrib["name"] = "DSB"
15     #添加
16     country.append(newtag)
17 
18 # 写回到内存
19 tree.write("text.xml",encoding="utf-8",xml_declaration=False)

增删改查

8、生成xml文档

分分快三计划 7分分快三计划 8

 1 import xml.etree.ElementTree as et
 2 # 创建根标签
 3 root = et.Element("root")
 4 # 创建节点树
 5 t1 = et.ElementTree(root)
 6 
 7 # 加一个peron标签
 8 persson = et.Element("person")
 9 persson.attrib["name"] = "yyh"
10 persson.attrib["sex"] = "man"
11 persson.attrib["age"] = "20"
12 persson.text = "这是一个person标签"
13 
14 root.append(persson)
15 
16 # 写入文件
17 t1.write("newXML.xml",encoding="utf-8",xml_declaration=True)

生成

7.shutil模块(import shutil)

print(hash.digest())

三、hashlib模块

 1、hashlib分为hash和library

(1)hash

①.hash为一种算法,用于将任意长度的数据压缩映射到一段固定长度的字符 (提取特征)

②.特点

a.输入数据不同,得到的hash值有可能相同
b.不能通过hash值来得到输入的值
c.如果算法相同,无论输入的数据长度是多少,得到的hash值长度相同

③.作用

常用的提升安全性的手段,用于数据的加密,MD5是常用的一种hash算法

(2)library

2、利用hashlib加密

分分快三计划 9分分快三计划 10

1 import hashlib
2 md = hashlib.md5()
3 md.update("hello".encode("utf-8"))
4 print(md.hexdigest())

加密

3、解密

破解MD5可以尝试撞库  

原理: 有一个数据库里面存放了常见的明文和密文的对应关系 

  分分快三计划 11

分分快三计划 12

一、shelve模块

1、shelve模块也是一种序列化模块,内部使用的是pickle模块,所以也存在跨平台性差的问题

2、特点:

   只要提供一个文件名即可

   读写的方式和字典一样

   将数据以类似字典的形式在文件中读写

3、应用场景

  在单击的程序中使用

4、使用方法

(1)序列化

1 import shelve
2 
3 s1= shelve.open('a.txt')      # 打开文件
4 s1['week']=["Sun", "Mon", "Tues", "Wed", "Thur", "Fri", "Sat"]
5 s1['person']={"name": "Zero", "age": 8, "height": 180}     # 写操作
6 s1.close()     # 关闭文件

(2)反序列化

1 import shelve
2 
3 s2 = shelve.open('a.txt')     # 打开文件
4 print(s2.get('week'))
5 print(s2.get('person'))
6 print(s2.get('person')['age'])    # 读取文件中内容
7 s2.close()        # 关闭文件
def process(percent,width=50):
    if percent >=1:
        percent=1
    show_str=('[%%-%ds]'%width)%(' '*int(width*percent))
    print('r%s %d%%'%(show_str,percent*100),end='')

recv_size=0
total_size=10241
while recv_size < total_size:
    time.sleep(0.1)
    recv_size =1024
    process(recv_size/total_size)

 

四、configparser模块

1、configparser模块是配置文件解析模块,用于提供程序运行所需要的一些信息的文件。 后缀 .ini,.cfg

2、配置文件内容格式

  只包括两种元素:
    section    分区
    option     选项
  一个文件可以有多个section
  一个section可以有多个选项

3、核心方法

sections()     获取所有分区
options()      获取所有选项
get(section,option)            获取一个值

4、配置文件

分分快三计划 13分分快三计划 14

 1 import configparser
 2 
 3 # 得到配置文件对象
 4 cfg = configparser.ConfigParser()
 5 
 6 # 读取一个配置文件
 7 cfg.read("download.ini")
 8 
 9 print(cfg.sections())
10 print(cfg.options("section1"))
11 
12 print((cfg.get("section1","maxspeed")))
13 print((cfg.getint("section1","maxspeed")))
14 print(cfg.getint("section2","minspeed"))
15 
16 
17 # 修改最大速度为2048
18 cfg.set("section1","maxspeed","2048")
19 
20 # 修改后写入文件
21 cfg.write(open("download.ini","w",encoding="utf-8"))

配置文件

 

View Code

print``(time.process_time()) ``#返回处理器时间,3.3开始已废弃

 

RawCnfigParser是最基础的INI文件读取类;

撞库模拟

根据指定匹配进行分组

  正则就是用一些具有特殊含义的符号组合到一起(称为正则表达式)来描述字符或者字符串的方法

★re.search的函数原型为: re.search(pattern, string, flags)

  序列化之json

每个参数的含意与re.match一样。 

正则表达式

shutil.move(src, dst)
递归的去移动文件

 

      separators参数的作用是去掉,,:后面的空格,从上面的输出结果都能看到", :"后面都有个空格,这都是为了美化输出结果的作用,但是在我们传输数据的过程中,越精简越好,冗余的东西全部去掉

  xml是实现不同语言或程序之间进行数据交换的协议,跟json差不多,但json使用起来更简单

一、常用函数说明:

import subprocess
import time

subprocess.Popen('tasklist',shell=True)
print('===主')
time.sleep(1)

obj1=subprocess.Popen('tasklist',shell=True,
                 stdout=subprocess.PIPE,
                 stderr=subprocess.PIPE,
                 )

obj2=subprocess.Popen('findstr python',shell=True,
                 stdin=obj1.stdout,
                 stdout=subprocess.PIPE,
                 stderr=subprocess.PIPE
                 )

print(obj2.stdout.read().decode('gbk'))

设定配置文件test.conf

#序列化:pickle.dumps和pickle.dump,序列化后的数据类型为bytes类型
s={1,2,3,4,5}

with open('user.pkl','wb',) as f:
    f.write(pickle.dumps(s))

pickle.dump(s, open('user.pkl', 'wb'))

#反序列化:pickle.loads和pickle.load
with open('user.pkl','rb') as f:
    data=pickle.loads(f.read())
    print(data)

data=pickle.load(open('user.pkl','rb'))
print(data)

仅拷贝权限。内容、组、用户均不变

  序列化之pickle

pickle模块提供了四个功能:dumps、dump、loads、load

分分快三计划 15分分快三计划 16

第四个参数指替换个数。默认为0,表示每个匹配项都替换。

ConfigureFile

如果只需对一条字符串进行加密处理,也可以用一条语句的方式:

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)

 ★ lamba

# re模块的方法
print(re.findall('a[- /*]b','axb azb aAb a b a-b'))
# re.search()
print(re.search('a[- /*]b','axb azb aAb a b a-b'))  #有结果返回一个对象,无结果返回None
print(re.search('a[- /*]b','axb azb aAb a b a-b').group())  #group()方法只匹配成功一次就返回
#re.match()
print(re.match('a[- /*]b','axb azb aAb a b a-b'))  #从头开始取,无结果返回None
print(re.match('a[- /*]b','a*b azb aAb a b a-b').group())
#re.split()
print(re.split(':','root:x:0:0::/root',maxsplit=1))
#re.sub()
print(re.sub('root','admin','root:x:0:0::/root',1))
print(re.sub('^([a-z] )([^a-z] )(.*?)([^a-z] )([a-z] )$',r'52341','root:x:0:0::/bash'))
#re.compile()
obj=re.compile('ad{2}b')
print(obj.findall('a12b a123b a124a a82b'))
print(obj.search('a12b a123b a124a a82b'))

m = lambda x,y,z: (x-y)*z
print m(234,122,5)

shutil.copyfileobj(open('old.xml','r'), open('new.xml', 'w')) #将文件内容拷贝到另一个文件中
shutil.copyfile('f1.log', 'f2.log')     #拷贝文件,目标文件无需存在
shutil.copymode('f1.log', 'f2.log')     #仅拷贝权限。内容、组、用户均不变,目标文件必须存在
shutil.copystat('f1.log', 'f2.log')     #仅拷贝状态的信息,包括:mode bits, atime, mtime, flags,目标文件必须存在
shutil.copy('f1.log', 'f2.log')         #拷贝文件和权限
shutil.copy2('f1.log', 'f2.log')        #拷贝文件和状态信息
#递归的去拷贝文件夹,目标目录不能存在,注意对folder2目录父级目录要有可写权限,ignore的意思是排除
shutil.copytree('folder1', 'folder2', ignore=shutil.ignore_patterns('*.pyc', 'tmp*'))
shutil.rmtree('folder1')                #递归的去删除文件
shutil.move('folder1', 'folder3')       #递归的去移动文件
shutil.make_archive("data_bak", 'gztar', root_dir='/data')  #将 /data 下的文件打包放置当前程序目录
shutil.make_archive("/tmp/data_bak", 'gztar', root_dir='/data') #将 /data下的文件打包放置 /tmp/目录

* None,True 和 False;

json类型 python类型
{} dict
[] list
"String" str
1234.57 int或float
true/false True/False
null None

 

6.sys模块(import sys)

 

import random

print(random.random())          #大于0小于1之间的小数
print(random.randint(1,3))      #大于1且小于等于3之间的整数(包括头尾)
print(random.randrange(1,3))    #大于1且小于等于3之间的整数(顾头不顾尾)
print(random.choice([1,'hell',3]))   #取其中一个
print(random.sample([1,2,3],2)) #取任意两个组合
print(random.uniform(1,4))      #取1-4之间的小数

l=[1,2,3,4,5]
random.shuffle(l)       #打乱原来的顺序
print(l)

* 整数,浮点数,复数;

13.subprocess模块

分分快三计划 17分分快三计划 18

os.path.abspath(path)  #返回path规范化的绝对路径
os.path.dirname(path)  #返回path的目录。其实就是os.path.split(path)的第一个元素
os.path.exists(path)  #如果path存在,返回True;如果path不存在,返回False
os.path.join(path1[, path2[, ...]])  #将多个路径组合后返回,第一个绝对路径之前的参数将被忽略
1
2
3
4
5
6
7
8
9
#将 /Users/wupeiqi/Downloads/test 下的文件打包放置当前程序目录
 
import shutil
ret = shutil.make_archive("wwwwwwwwww"'gztar', root_dir='/Users/wupeiqi/Downloads/test')
 
 
#将 /Users/wupeiqi/Downloads/test 下的文件打包放置 /Users/wupeiqi/目录
import shutil
ret = shutil.make_archive("/Users/wupeiqi/wwwwwwwwww"'gztar', root_dir='/Users/wupeiqi/Downloads/test')

  hash:一种算法,主要提供 SHA1, SHA224, SHA256, SHA384, SHA512 ,MD5 算法。特点是内容相同则hash运算结果相同,内容稍微改变则hash值则变;不可逆推;无论校验多长的数据,得到的哈希值长度固定

file1.read('aa.txt')

   shelve模块比pickle模块简单,只有一个open函数,返回类似字典的对象,可读可写;key必须为字符串,而值可以是python所支持的数据类型

 

#模拟撞库破解密码
pwd={
    "lary",
    "lary123",
    "lary321"
}
def make_pwd_dic(pwd):
    dic={}
    for p in pwd:
        m=hashlib.md5()
        m.update(p.encode('utf-8'))
        dic[p]=m.hexdigest()
    return dic

def break_code(code,pwd_dic):
    for k,v in pwd_dic.items():
        if v==code:
            print("密码是%s"%k)

code='3043b3256c1c64338167b7b1d71d0c14'
break_code(code,make_pwd_dic(pwd))

print``(time.strptime(``"2016-01-28"``,``"%Y-%m-%d"``) ) ``#将字符串格式转换成struct_time格式

分分快三计划 19分分快三计划 20

不能再牛逼了!!!

View Code

二、模块 paramiko

# w 匹配字母数字及下划线
print(re.findall('w','lary 123   _ - *'))
# W 匹配非字母数字及下划线
print(re.findall('W','lary 123   _ - *'))
# s 匹配任意空白字符
print(re.findall('s','larytn 123n3   _ - *'))
# S 匹配任意非空字符
print(re.findall('S','larytn 123n3   _ - *'))
# d 匹配任意数
print(re.findall('d','larytn 123n3   _ - *'))
# D 匹配任意非数字
print(re.findall('D','larytn 123n3   _ - *'))
# n 匹配一个换行符
print(re.findall('n','larytn 123n3   _ - *'))
# t 匹配一个制表符
print(re.findall('t','larytn 123n3   _ - *'))
# ^  匹配字符串开头
print(re.findall('^e','elarytn 123n3 ego   _ - *'))
# $  匹配字符串的末尾
print(re.findall('o$','elarytn 123n3 ego   _ - *o'))
# .  匹配任意一个字符(除了换行符)
print(re.findall('a.b','a1b a b a-b aaaab'))
# ?  匹配0个或1个由前面的正则表达式定义的片段,非贪婪方式
print(re.findall('ab?','a ab abb abbb a1b'))
# *  匹配0个或多个的表达式
print(re.findall('ab*','a ab abb abbb a1b'))
#    匹配1个或多个的表达式
print(re.findall('ab ','a ab abb abbb a1b'))
# {n,m}匹配n到m次由前面的正则表达式定义的片段,贪婪方式
print(re.findall('ab{0,1}','a ab abb abbb a1b'))
print(re.findall('ab?','a ab abb abbb a1b'))
print(re.findall('ab{2,3}','a ab abb abbb a1b'))
#.*?匹配任意个字符,非贪婪方式
print(re.findall('a.*?b','a123b456b'))
#.* 匹配任意个字符,贪婪方式
print(re.findall('a.*b','a123b456b'))
# a|b 匹配a或b
print(re.findall('compan(ies|y)','too many companies shut down,and the next is my company'))
print(re.findall('compan(?:ies|y)','too many companies shut down,and the next is my company'))
# [...] 表示一组字符,取括号中任意一个字符
print(re.findall('a[a-z]b','axb azb aAb a b a-b'))
print(re.findall('a[a-zA-Z]b','axb azb aAb a b a-b'))
print(re.findall('a[- /*]b','axb azb aAb a b a-b'))  #-应该写在[]中的两边
# [^...]不在[]中的字符
print(re.findall('a[^- /*]b','axb azb aAb a b a-b'))
# (n)精确匹配n个前面表达式
# () 匹配括号内的表示式,也表示一个组
# A 匹配字符串开始
# Z 匹配字符串结束,如果存在换行,只匹配到换行前的结束字符串
# z 匹配字符串结束
# G 匹配最后匹配完成的位置

print(re.findall(r'a\c','ac alc aBc')) #r''代表原生表达式

★JSON(JavaScript Object Notation):一种轻量级数据交换格式,相对于XML而言更简单,也易于阅读和编写,机器也方便解析和生成,Json是JavaScript中的一个子集。

12.hashlib模块

2.基本的写入配置文件

  序列化的目的:在断电或重启程序之前将程序当前内存中所有数据都保存下来,以便于下次程序执行能够从文件中载入之前的数据;序列化之后,不仅可以把序列化后的内容写入磁盘,还可以通过网络传输到别的机器上,如果收发的双方约定好实用一种序列化的格式,那么便打破了平台/语言差异化带来的限制,实现了跨平台数据交互

 

分分快三计划 21分分快三计划 22

print(reduce(lambda x,y:x*y,[22,11,8]))
print(reduce(lambda x,y:x*y,[3],10))

 3.time模块(import time)

print``(time.ctime()) ``#输出Tue Jan 26 18:23:48 2016 ,当前系统时间

10.xml模块

3.Python的ConfigParser Module中定义了3个类对INI文件进行操作。

 2.正则模块(import re)

例:

打印进度条

import hashlib

# ######## md5 ########

hash = hashlib.md5()
hash.update('admin')
print hash.hexdigest()

# ######## sha1 ########

hash = hashlib.sha1()
hash.update('admin')
print hash.hexdigest()

# ######## sha256 ########

hash = hashlib.sha256()
hash.update('admin')
print hash.hexdigest()


# ######## sha384 ########

hash = hashlib.sha384()
hash.update('admin')
print hash.hexdigest()

# ######## sha512 ########

hash = hashlib.sha512()
hash.update('admin')
print hash.hexdigest()

分分快三计划 23分分快三计划 24

#time.sleep(4) #sleep

import hashlib

m=hashlib.md5()

m.update('lary123'.encode('utf-8'))
print(m.hexdigest())

#对加密算法中添加自定义key再来做加密
hash=hashlib.sha256('898sadfd'.encode('utf-8'))
hash.update('hello'.encode('utf-8'))
print(hash.hexdigest())

#hmac模块,它内部对我们创建key和内容进行进一步的处理然后再加密
import hmac

h=hmac.new('good'.encode('utf-8'))
h.update('hello'.encode('utf-8'))
print(h.hexdigest())

logging.basicConfig详细解释

例:

11.configparser模块

 ★ enumerate(iterable,[start])   iterable为一个可迭代的对象;

   pickle只能用于python,可以识别python所有的数据类型,但是可能不同版本的python彼此都不兼容

字符:

View Code

ConfigParser、 SafeConfigParser支持对%(value)s变量的解析。 

 9.shelve模块(import shelve)

分分快三计划 25分分快三计划 26

分分快三计划 27分分快三计划 28

  参考老师的博客:

#应用
import os
import logging.config

# 定义三种日志输出格式 开始

standard_format = '[%(asctime)s][%(threadName)s:%(thread)d][task_id:%(name)s][%(filename)s:%(lineno)d]' 
                  '[%(levelname)s][%(message)s]' #其中name为getlogger指定的名字

simple_format = '[%(levelname)s][%(asctime)s][%(filename)s:%(lineno)d]%(message)s'

id_simple_format = '[%(levelname)s][%(asctime)s] %(message)s'

# 定义日志输出格式 结束

logfile_dir = os.path.dirname(os.path.abspath(__file__))  # log文件的目录

logfile_name = 'all2.log'  # log文件名

# 如果不存在定义的日志目录就创建一个
if not os.path.isdir(logfile_dir):
    os.mkdir(logfile_dir)

# log文件的全路径
logfile_path = os.path.join(logfile_dir, logfile_name)

# log配置字典
LOGGING_DIC = {
    'version': 1,
    'disable_existing_loggers': False,
    'formatters': {
        'standard': {
            'format': standard_format
        },
        'simple': {
            'format': simple_format
        },
    },
    'filters': {},
    'handlers': {
        #打印到终端的日志
        'console': {
            'level': 'DEBUG',
            'class': 'logging.StreamHandler',  # 打印到屏幕
            'formatter': 'simple'
        },
        #打印到文件的日志,收集info及以上的日志
        'default': {
            'level': 'DEBUG',
            'class': 'logging.handlers.RotatingFileHandler',  # 保存到文件
            'formatter': 'standard',
            'filename': logfile_path,  # 日志文件
            'maxBytes': 1024*1024*5,  # 日志大小 5M
            'backupCount': 5,
            'encoding': 'utf-8',  # 日志文件的编码,再也不用担心中文log乱码了
        },
    },
    'loggers': {
        #logging.getLogger(__name__)拿到的logger配置
        '': {
            'handlers': ['default', 'console'],  # 这里把上面定义的两个handler都加上,即log数据既写入文件又打印到屏幕
            'level': 'DEBUG',
            'propagate': True,  # 向上(更高level的logger)传递
        },
    },
}


def load_my_logging_cfg():
    logging.config.dictConfig(LOGGING_DIC)  # 导入上面定义的logging配置
    logger = logging.getLogger(__name__)  # 生成一个log实例
    logger.info('It works!')  # 记录该文件的运行状态

if __name__ == '__main__':
    load_my_logging_cfg()

上传或者下载文件 - 通过用户名和密码

dic={'a':1}
res=json.dumps(dic)
print(res,type(res))   #{"a": 1} <class 'str'>

x=None
res=json.dumps(x)
print(res,type(res))   #null <class 'str'>

#序列化:json.dumps和json.dump用法
user = {"name":'lary','age':18}
with open('user.json','w',encoding='utf-8') as f:
    f.write(json.dumps(user))           #json.dumps把单引号变为双引号

user = {"name": 'lary', 'age': 16}
json.dump(user,open('user.json','w',encoding='utf-8'))

#反序列化:json.loads和json.load的用法
with open('user.json','r',encoding='utf-8') as f:
    data=json.loads(f.read())
    print(data)

data=json.load(open('user.json','r',encoding='utf-8'))
print(data)

5.通过logging.config模块配置日志

#logger.conf

###############################################

[loggers]keys=root,example01,example02

[logger_root]level=DEBUGhandlers=hand01,hand02

[logger_example01]handlers=hand01,hand02qualname=example01propagate=0

[logger_example02]handlers=hand01,hand03qualname=example02propagate=0

###############################################

[handlers]keys=hand01,hand02,hand03

[handler_hand01]class=StreamHandlerlevel=INFOformatter=form02args=(sys.stderr,)

[handler_hand02]class=FileHandlerlevel=DEBUGformatter=form01args=('myapp.log', 'a')

[handler_hand03]class=handlers.RotatingFileHandlerlevel=INFOformatter=form02args=('myapp.log', 'a', 10*1024*1024, 5)

###############################################

[formatters]keys=form01,form02

[formatter_form01]format=%(asctime)s %(filename)s[line:%(lineno)d] %(levelname)s %(message)sdatefmt=%a, %d %b %Y %H:%M:%S

[formatter_form02]format=%(name)-12s: %(levelname)-8s %(message)sdatefmt=

上例3:

import loggingimport logging.configlogging.config.fileConfig("logger.conf")logger = logging.getLogger("example01")logger.debug('This is debug message')logger.info('This is info message')logger.warning('This is warning message')

上例4:

 

import loggingimport logging.configlogging.config.fileConfig("logger.conf")logger = logging.getLogger("example02")logger.debug('This is debug message')logger.info('This is info message')logger.warning('This is warning message')

 

 

9、shelve 模块

   shelve模块是一个简单的k,v将内存数据通过文件持久化的模块,可以持久化任何pickle可支持的python数据格式

   shelve是一额简单的数据存储方案,他只有一个函数就是open(),这个函数接收一个参数就是文件名,然后返回一个shelf对象,你可以用他来存储东西,就可以简单的把他当作一个字典,当你存储完毕的时候,就调用close函数来关闭

 1 import shelve
 2 
 3 d = shelve.open('shelve_file') #打开一个文件
 4 
 5 class Test(object):
 6     def __init__(self,n):
 7         self.a = n
 8 
 9 
10 t = Test(123)
11 t2 = Test(123334)
12 
13 name = ["alex","rain","test"]
14 d["test"] = name #持久化列表
15 d["t1"] = t      #持久化类
16 d["t2"] = t2
17 
18 d.close()
19 
20 f = shelve.open('shelve_file')
21 print(f['t1'].a)
22 print(f['test'])
23 f.close

 

则会生成三类文件shelve_file.dat,shelve_file.dir,shelve_file.bak用来充放数据

多关注其中的writeback=True参数

详情见shelve模块:

分分快三计划 29分分快三计划 30

"""Manage shelves of pickled objects.

A "shelf" is a persistent, dictionary-like object.  The difference
with dbm databases is that the values (not the keys!) in a shelf can
be essentially arbitrary Python objects -- anything that the "pickle"
module can handle.  This includes most class instances, recursive data
types, and objects containing lots of shared sub-objects.  The keys
are ordinary strings.

To summarize the interface (key is a string, data is an arbitrary
object):

        import shelve
        d = shelve.open(filename) # open, with (g)dbm filename -- no suffix

        d[key] = data   # store data at key (overwrites old data if
                        # using an existing key)
        data = d[key]   # retrieve a COPY of the data at key (raise
                        # KeyError if no such key) -- NOTE that this
                        # access returns a *copy* of the entry!
        del d[key]      # delete data stored at key (raises KeyError
                        # if no such key)
        flag = key in d # true if the key exists
        list = d.keys() # a list of all existing keys (slow!)

        d.close()       # close it

Dependent on the implementation, closing a persistent dictionary may
or may not be necessary to flush changes to disk.

Normally, d[key] returns a COPY of the entry.  This needs care when
mutable entries are mutated: for example, if d[key] is a list,
        d[key].append(anitem)
does NOT modify the entry d[key] itself, as stored in the persistent
mapping -- it only modifies the copy, which is then immediately
discarded, so that the append has NO effect whatsoever.  To append an
item to d[key] in a way that will affect the persistent mapping, use:
        data = d[key]
        data.append(anitem)
        d[key] = data

To avoid the problem with mutable entries, you may pass the keyword
argument writeback=True in the call to shelve.open.  When you use:
        d = shelve.open(filename, writeback=True)
then d keeps a cache of all entries you access, and writes them all back
to the persistent mapping when you call d.close().  This ensures that
such usage as d[key].append(anitem) works as intended.

However, using keyword argument writeback=True may consume vast amount
of memory for the cache, and it may make d.close() very slow, if you
access many of d's entries after opening it in this way: d has no way to
check which of the entries you access are mutable and/or which ones you
actually mutate, so it must cache, and write back at close, all of the
entries that you access.  You can call d.sync() to write back all the
entries in the cache, and empty the cache (d.sync() also synchronizes
the persistent dictionary on disk, if feasible).
"""

from pickle import Pickler, Unpickler
from io import BytesIO

import collections

__all__ = ["Shelf", "BsdDbShelf", "DbfilenameShelf", "open"]

class _ClosedDict(collections.MutableMapping):
    'Marker for a closed dict.  Access attempts raise a ValueError.'

    def closed(self, *args):
        raise ValueError('invalid operation on closed shelf')
    __iter__ = __len__ = __getitem__ = __setitem__ = __delitem__ = keys = closed

    def __repr__(self):
        return '<Closed Dictionary>'


class Shelf(collections.MutableMapping):
    """Base class for shelf implementations.

    This is initialized with a dictionary-like object.
    See the module's __doc__ string for an overview of the interface.
    """

    def __init__(self, dict, protocol=None, writeback=False,
                 keyencoding="utf-8"):
        self.dict = dict
        if protocol is None:
            protocol = 3
        self._protocol = protocol
        self.writeback = writeback
        self.cache = {}
        self.keyencoding = keyencoding

    def __iter__(self):
        for k in self.dict.keys():
            yield k.decode(self.keyencoding)

    def __len__(self):
        return len(self.dict)

    def __contains__(self, key):
        return key.encode(self.keyencoding) in self.dict

    def get(self, key, default=None):
        if key.encode(self.keyencoding) in self.dict:
            return self[key]
        return default

    def __getitem__(self, key):
        try:
            value = self.cache[key]
        except KeyError:
            f = BytesIO(self.dict[key.encode(self.keyencoding)])
            value = Unpickler(f).load()
            if self.writeback:
                self.cache[key] = value
        return value

    def __setitem__(self, key, value):
        if self.writeback:
            self.cache[key] = value
        f = BytesIO()
        p = Pickler(f, self._protocol)
        p.dump(value)
        self.dict[key.encode(self.keyencoding)] = f.getvalue()

    def __delitem__(self, key):
        del self.dict[key.encode(self.keyencoding)]
        try:
            del self.cache[key]
        except KeyError:
            pass

    def __enter__(self):
        return self

    def __exit__(self, type, value, traceback):
        self.close()

    def close(self):
        self.sync()
        try:
            self.dict.close()
        except AttributeError:
            pass
        # Catch errors that may happen when close is called from __del__
        # because CPython is in interpreter shutdown.
        try:
            self.dict = _ClosedDict()
        except (NameError, TypeError):
            self.dict = None

    def __del__(self):
        if not hasattr(self, 'writeback'):
            # __init__ didn't succeed, so don't bother closing
            # see http://bugs.python.org/issue1339007 for details
            return
        self.close()

    def sync(self):
        if self.writeback and self.cache:
            self.writeback = False
            for key, entry in self.cache.items():
                self[key] = entry
            self.writeback = True
            self.cache = {}
        if hasattr(self.dict, 'sync'):
            self.dict.sync()


class BsdDbShelf(Shelf):
    """Shelf implementation using the "BSD" db interface.

    This adds methods first(), next(), previous(), last() and
    set_location() that have no counterpart in [g]dbm databases.

    The actual database must be opened using one of the "bsddb"
    modules "open" routines (i.e. bsddb.hashopen, bsddb.btopen or
    bsddb.rnopen) and passed to the constructor.

    See the module's __doc__ string for an overview of the interface.
    """

    def __init__(self, dict, protocol=None, writeback=False,
                 keyencoding="utf-8"):
        Shelf.__init__(self, dict, protocol, writeback, keyencoding)

    def set_location(self, key):
        (key, value) = self.dict.set_location(key)
        f = BytesIO(value)
        return (key.decode(self.keyencoding), Unpickler(f).load())

    def next(self):
        (key, value) = next(self.dict)
        f = BytesIO(value)
        return (key.decode(self.keyencoding), Unpickler(f).load())

    def previous(self):
        (key, value) = self.dict.previous()
        f = BytesIO(value)
        return (key.decode(self.keyencoding), Unpickler(f).load())

    def first(self):
        (key, value) = self.dict.first()
        f = BytesIO(value)
        return (key.decode(self.keyencoding), Unpickler(f).load())

    def last(self):
        (key, value) = self.dict.last()
        f = BytesIO(value)
        return (key.decode(self.keyencoding), Unpickler(f).load())


class DbfilenameShelf(Shelf):
    """Shelf implementation using the "dbm" generic dbm interface.

    This is initialized with the filename for the dbm database.
    See the module's __doc__ string for an overview of the interface.
    """

    def __init__(self, filename, flag='c', protocol=None, writeback=False):
        import dbm
        Shelf.__init__(self, dbm.open(filename, flag), protocol, writeback)


def open(filename, flag='c', protocol=None, writeback=False):
    """Open a persistent dictionary for reading and writing.

    The filename parameter is the base filename for the underlying
    database.  As a side-effect, an extension may be added to the
    filename and more than one file may be created.  The optional flag
    parameter has the same interpretation as the flag parameter of
    dbm.open(). The optional protocol parameter specifies the
    version of the pickle protocol (0, 1, or 2).

    See the module's __doc__ string for an overview of the interface.
    """

    return DbfilenameShelf(filename, flag, protocol, writeback)

shelve

shelve

 

但上面的使用有一个潜在的小问题,如下:


  1. >>> import shelve  
  2. >>> s = shelve.open('test.dat')  
  3. >>> s['x'] = ['a', 'b', 'c']  
  4. >>> s['x'].append('d')  
  5. >>> s['x']  
  6. ['a', 'b', 'c']  

存储的d到哪里去了呢?其实很简单,d没有写回,你把['a', 'b', 'c']存到了x,当你再次读取s['x']的时候,s['x']只是一个拷贝,而你没有将拷贝写回,所以当你再次读取s['x']的时候,它又从源中读取了一个拷贝,所以,你新修改的内容并不会出现在拷贝中,解决的办法就是,第一个是利用一个缓存的变量,如下所示


  1. >>> temp = s['x']  
  2. >>> temp.append('d')  
  3. >>> s['x'] = temp  
  4. >>> s['x']  
  5. ['a', 'b', 'c', 'd']  

在python2.4中有了另外的方法,就是把open方法的writeback参数的值赋为True,这样的话,你open后所有的内容都将在cache中,当你close的时候,将全部一次性写到硬盘里面。如果数据量不是很大的时候,建议这么做。

 

例:基于shelve的简单数据库的代码

分分快三计划 31分分快三计划 32

#database.py  
import sys, shelve  

def store_person(db):  
    """ 
    Query user for data and store it in the shelf object 
    """  
    pid = raw_input('Enter unique ID number: ')  
    person = {}  
    person['name'] = raw_input('Enter name: ')  
    person['age'] = raw_input('Enter age: ')  
    person['phone'] = raw_input('Enter phone number: ')  
    db[pid] = person  

def lookup_person(db):  
    """ 
    Query user for ID and desired field, and fetch the corresponding data from 
    the shelf object 
    """  
    pid = raw_input('Enter ID number: ')  
    field = raw_input('What would you like to know? (name, age, phone) ')  
    field = field.strip().lower()  
    print field.capitalize()   ':',   
        db[pid][field]  

def print_help():  
    print 'The available commons are: '  
    print 'store  :Stores information about a person'  
    print 'lookup :Looks up a person from ID number'  
    print 'quit   :Save changes and exit'  
    print '?      :Print this message'  

def enter_command():  
    cmd = raw_input('Enter command (? for help): ')  
    cmd = cmd.strip().lower()  
    return cmd  

def main():  
    database = shelve.open('database.dat')  
    try:   
        while True:  
            cmd = enter_command()  
            if cmd == 'store':  
                store_person(database)  
            elif cmd == 'lookup':  
                lookup_person(database)  
            elif cmd == '?':  
                print_help()  
            elif cmd == 'quit':  
                return   
    finally:  
        database.close()  
if __name__ == '__main__': 
    main()  

shelve数据库实例

shelve数据库实例

 

 10、xml模块

xml是实现不同语言或程序之间进行数据交换的协议,跟json差不多,但json使用起来更简单,不过,古时候,在json还没诞生的黑暗年代,大家只能选择用xml呀,至今很多传统公司如金融行业的很多系统的接口还主要是xml。

xml的格式如下,就是通过<>节点来区别数据结构的:

分分快三计划 33分分快三计划 34

<?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 *

在实际应用中,需要对xml配置文件进行实时修改, 

 1.增加、删除 某些节点

 2.增加,删除,修改某个节点下的某些属性

 3.增加,删除,修改某些节点的文本

 

实现思想:

使用ElementTree,先将文件读入,解析成树,之后,根据路径,可以定位到树的每个节点,再对节点进行修改,最后直接将其输出

 

具体代码如下:

分分快三计划 35分分快三计划 36

from xml.etree.ElementTree import ElementTree

def read_xml(in_path):
    '''''读取并解析xml文件
       in_path: xml路径
       return: ElementTree'''
    tree = ElementTree()
    tree.parse(in_path)
    root = tree.getroot()
    return(tree,root)

def write_xml(tree, out_path):
    '''''将xml文件写出
       tree: xml树
       out_path: 写出路径'''
    tree.write(out_path, encoding="utf-8",xml_declaration=True)

def if_match(node, kv_map):
    '''''判断某个节点是否包含所有传入参数属性
       node: 节点
       kv_map: 属性及属性值组成的map'''
    for key in kv_map:
        #if node.get(key) != kv_map.get(key):
        if node.get(key) != kv_map[key]:
            return False
    return True

def if_match_text(node, text,mode='eq'):
    '''''判断某个节点是否包含所有传入参数属性
       node: 节点
       text: 标签具体值
       mode: 数值判断大小'''

    if mode == 'eq':
        express = "{0} == {1}"
    elif mode == 'gt':
        express = "{0} > {1}"
    elif mode == 'lt':
        express = "{0} < {1}"
    else:
        print('the mode is error')
        return False

    flag = eval(express.format(int(node.text),text))

    if flag:
        return True
    return False


#---------------search -----

def find_nodes(tree, path):
    '''''查找某个路径匹配的所有节点
       tree: xml树
       path: 节点路径'''
    return tree.findall(path)


def get_node_by_keyvalue(nodelist, kv_map):
    '''''根据属性及属性值定位符合的节点,返回节点
       nodelist: 节点列表
       kv_map: 匹配属性及属性值map'''
    result_nodes = []
    for node in nodelist:
        if if_match(node, kv_map):
            result_nodes.append(node)
    return result_nodes

#---------------change -----

def change_node_properties(nodelist, kv_map, is_delete=False):
    '''''修改/增加 /删除 节点的属性及属性值
       nodelist: 节点列表
       kv_map:属性及属性值map'''
    for node in nodelist:
        for key in kv_map:
            if is_delete:
                if key in node.attrib:
                    del node.attrib[key]
            else:
                node.set(key, kv_map.get(key))

def change_node_text(nodelist, text, is_add=False, is_delete=False):
    '''''改变/增加/删除一个节点的文本
       nodelist:节点列表
       text : 更新后的文本'''
    for node in nodelist:
        if is_add:
            node.text = text * 3
        elif is_delete:
            node.text = ""
        else:
            node.text = text

def create_node(tag, property_map, content):
    '''''新造一个节点
       tag:节点标签
       property_map:属性及属性值map
       content: 节点闭合标签里的文本内容7
       return 新节点'''
    element = Element(tag, property_map)
    element.text = content
    return element

def add_child_node(nodelist, element):
    '''''给一个节点添加子节点
       nodelist: 节点列表
       element: 子节点'''
    for node in nodelist:
        node.append(element)

def del_node_by_tagkeyvalue(nodelist, tag, kv_map):
    '''''通过属性及属性值定位一个节点,并删除之
       nodelist: 父节点列表
       tag:子节点标签
       kv_map: 属性及属性值列表'''
    for parent_node in nodelist:
        children = parent_node.getchildren()

        for child in children:
            if child.tag == tag and if_match(child, kv_map):
                parent_node.remove(child)


def del_node_by_tagtext(nodelist, tag, text,mode='eq',flag=1):
    '''''通过属性及属性值定位一个节点,并删除之
       nodelist: 父节点列表
       tag:子节点标签
       text: 标签具体值'''
    for parent_node in nodelist:

        children = parent_node.getchildren()

        for child in children:
            if child.tag == tag and if_match_text(child,text,mode):
                if flag == 1:
                    parent_node.remove(child)
                else:
                    root.remove(parent_node)


if __name__ == "__main__":

    #1. 读取xml文件
    (tree,root) = read_xml("server.xml")
    print(root)


    #2. 属性修改
      #A. 找到父节点
    nodes = find_nodes(tree, "country/neighbor")

      #B. 通过属性准确定位子节点
    result_nodes = get_node_by_keyvalue(nodes, {"direction":"E"})

      #C. 修改节点属性
    change_node_properties(result_nodes, {"age": "10","position":'asiaasia'})

      #D. 删除节点属性
    change_node_properties(result_nodes, {"age": "10"},is_delete=True)

    #3. 节点修改
      #A.新建节点
    a = create_node("person", {"age":"15","money":"200000"}, "this is the firest content")

      #B.插入到父节点之下
    add_child_node(result_nodes, a)


    #4. 删除节点
       #定位父节点
    del_parent_nodes = find_nodes(tree, "country")

       #根据attrib准确定位子节点并删除之
    target_del_node = del_node_by_tagkeyvalue(del_parent_nodes, "neighbor", {"direction":"N"})

       #根据text准确定位子节点并删除之
    target_del_node = del_node_by_tagtext(del_parent_nodes, "gdppc",60000,'gt',1)

       #根据text准确定位country并删除之
    target_del_element = del_node_by_tagtext(del_parent_nodes, "rank",20,'gt',0)

    #5. 修改节点文本
       #定位节点
    text_nodes = get_node_by_keyvalue(find_nodes(tree, "country/neighbor"), {"direction":"E"})
    change_node_text(text_nodes, "east",is_add=True)


    #6. 输出到结果文件
    write_xml(tree,"test.xml")

xml增删改查

xml增删改查

 

自己创建xml文档:

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

 

import time

print(time.time())      #时间戳
print(time.localtime()) #本地时区时间
print(time.gmtime())    #标准时间
print(time.strftime("%Y-%m-%d %X"))    #格式化时间

import datetime

print(datetime.datetime.now())
print(datetime.datetime.fromtimestamp(11111))
print(datetime.datetime.now() datetime.timedelta(days=3))
print(datetime.datetime.now().replace(year=1999))

       金角:http://www.cnblogs.com/alex3714/articles/5161349.html

分分快三计划 37分分快三计划 38

例:

1 #--------------------------按图1转换时间
 2 # localtime([secs])
 3 # 将一个时间戳转换为当前时区的struct_time。secs参数未提供,则以当前时间为准。
 4 time.localtime()
 5 time.localtime(1473525444.037215)
 6 
 7 # gmtime([secs]) 和localtime()方法类似,gmtime()方法是将一个时间戳转换为UTC时区(0时区)的struct_time。
 8 
 9 # mktime(t) : 将一个struct_time转化为时间戳。
10 print(time.mktime(time.localtime()))#1473525749.0
11 
12 
13 # strftime(format[, t]) : 把一个代表时间的元组或者struct_time(如由time.localtime()和
14 # time.gmtime()返回)转化为格式化的时间字符串。如果t未指定,将传入time.localtime()。如果元组中任何一个
15 # 元素越界,ValueError的错误将会被抛出。
16 print(time.strftime("%Y-%m-%d %X", time.localtime()))#2016-09-11 00:49:56
17 
18 # time.strptime(string[, format])
19 # 把一个格式化时间字符串转化为struct_time。实际上它和strftime()是逆操作。
20 print(time.strptime('2011-05-05 16:37:06', '%Y-%m-%d %X'))
21 #time.struct_time(tm_year=2011, tm_mon=5, tm_mday=5, tm_hour=16, tm_min=37, tm_sec=6,
22 #  tm_wday=3, tm_yday=125, tm_isdst=-1)
23 #在这个函数中,format默认为:"%a %b %d %H:%M:%S %Y"。

hash.update('admin')

分分快三计划 39分分快三计划 40

loads方法返回了原始的对象,但是仍然发生了一些数据类型的转化。比如,上例中‘abc’转化为了unicode类型。从json到python的类型转化对照如下:

分分快三计划 41分分快三计划 42

**★python对象与文件之间的序列化和反序列化(pickle和json)**

xml数据

s = 'i am {0},{1}'
print(s.format('wang',1))

#随机验证码小功能
def make_code(n):
    res=''
    for i in range(n):
        s1=str(random.randint(0,9))
        s2=chr(random.randint(65,90))
        res =random.choice([s1,s2])
    return res

res=make_code(6)
print(res)

一. 使用md5包

  xml协议在各个语言里的都 是支持的,在python中可以用以下模块操作xml

shutil.copy(src, dst)

8.json&pickle模块(import json,pickle)

 

View Code

第一个参数是正则表达式,这里为"(w )s",如果匹配成功,则返回一个Match,否则返回一个None;

分分快三计划 43

hash.update('admin')

 5.os模块(import os)


分分快三计划 44分分快三计划 45

 

import logging

#默认级别为warning,默认打印到终端
logging.debug('debug')      #10
logging.info('info')        #20
logging.warning('warn')     #30
logging.error('error')      #40
logging.critical('critical')#50

``

 4.random模块(import random)

第三个参数是标致位,用于控制正则表达式的匹配方式,如:是否区分大小写,多行匹配等等。

 

拷贝文件和权限

可在logging.basicConfig()函数中通过具体参数来更改logging模块默认行为,可用参数有
filename:用指定的文件名创建FiledHandler(后边会具体讲解handler的概念),这样日志会被存储在指定的文件中。
filemode:文件打开方式,在指定了filename时使用这个参数,默认值为“a”还可指定为“w”。
format:指定handler使用的日志显示格式。 
datefmt:指定日期时间格式。 
level:设置rootlogger(后边会讲解具体概念)的日志级别 
stream:用指定的stream创建StreamHandler。可以指定输出到sys.stderr,sys.stdout或者文件,默认为sys.stderr。若同时列出了filename和stream两个参数,则stream参数会被忽略。

#格式
%(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:用户输出的消息

        Python的Json模块序列化与反序列化的过程分别是 encoding和 decoding

import logging
#介绍
#logging模块的Formatter,Handler,Logger,Filter对象
#Logger:产生日志的对象
logger1=logging.getLogger('访问日志')
#Filter:过滤日志的对象
#Handler:接收日志然后控制打印到不同的地方,FileHandler用来打印到文件中,#StreamHandler用来打印到终端
h1=logging.StreamHandler()
h2=logging.FileHandler('access.log',encoding='utf-8')
#Formatter对象:可以定制不同的日志格式对象,然后绑定给不同的Handler对象使用,以此来控制不同的Handler的日志格式
formatter1=logging.Formatter(
        fmt='%(asctime)s - %(name)s - %(levelname)s -%(module)s:  %(message)s',
        datefmt='%Y-%m-%d %H:%M:%S %p',)

#使用
#logger负责产生日志,交给Filter过滤,然后交给不同的Handler输出,handler需要绑定日志格式
h1.setFormatter(formatter1)
h2.setFormatter(formatter1)
logger1.addHandler(h1)
logger1.addHandler(h2)
logger1.setLevel(10)
h1.setLevel(20)         #Handler的日志级别设置应该高于Logger设置的日志级别
logger1.debug('debug')
logger1.info('info')
logger1.warning('warning')
logger1.error('error')
logger1.critical('critical')

   序列化:我们把对象(变量)从内存中变成可存储或传输的过程称之为序列化

from xml.etree import ElementTree

tree=ElementTree.parse('a.xml')

root=tree.getroot()
print(root.tag,root.attrib,root.text)

#三种查找方式
#从子节点查找
print(root.find('country'))
print(root.findall('country'))
#从树形结构中查找
print(list(root.iter('rank')))

for country in root.findall('country'):
    rank=country.find('rank')
    print(rank.tag,rank.attrib,rank.text)

#遍历文档树
for item in root:
    #print('=====>',item.attrib['name'])
    for i in item:
        print(i.tag,i.attrib,i.text)

#修改文档
for year in root.iter('year'):
    #print(year.tag,year.attrib,year.text)
    year.set('updated','yes')
    year.text=str(int(year.text) 1)

tree.write('a.xml')

#添加节点
for country in root:
    obj=ElementTree.Element('egon')
    obj.attrib={"name":'egon',"age":'18'}
    obj.text='egon is good'
    country.append(obj)

print``(time.time()) ``#返回当前系统时间戳

分分快三计划 46分分快三计划 47

import ConfigParser 

logging配置文件

ip = '12aa13.12.15aasdfa12.32aasdf192.168.12.13asdfafasf12abadaf12.13'
res = re.findall('(d{1,3}.d{1,3}.d{1,3}.d{1,3})',ip)
print(res)
res1 = re.findall('(?:d{1,3}.){3}d{1,3}',ip)
print(res1)

分分快三计划 48分分快三计划 49

 

import configparser

config=configparser.ConfigParser()
config.read('my.ini')

#查看
#查看所有的标题
res=config.sections()
print(res)

#查看标题section下所有key=value的key
options=config.options('section1')
print(options)

#查看标题section下所有key=value的(key,value)形式
item=config.items('section1')
print(item)

#查看标题section1下user的值=>字符串格式
val=config.get('section1','user')
print(val)

#查看标题section1下age的值=>整数格式
val1=config.getint('section1','age')
print(val1)

#查看标题section1下is_admin的值=>布尔值格式
val2=config.getboolean('section1','is_admin')
print(val2)

#查看标题section1下salary的值=>浮点型格式
val3=config.getfloat('section1','salary')
print(val3)

#修改
#删除整个标题section2
config.remove_section('section2')

#删除标题section1下的某个k1和k2
config.remove_option('section1','k1')
config.remove_option('section1','k2')

#判断是否存在某个标题
print(config.has_section('section1'))

#判断标题section1下是否有user
print(config.has_option('section1',''))

#添加一个标题
config.add_section('lary')

#在标题egon下添加name=lary,age=18的配置
config.set('lary','name','lary')
config.set('lary','age','18') #必须是字符串

#最后将修改的内容写入文件,完成最终的修改
config.write(open('a.cfg','w'))

def add(arg):
    return arg 101
print(map(add,[12,23,34,56]))

os.getcwd() #获取当前工作目录,即当前python脚本工作的目录路径
os.chdir("dirname")  #改变当前脚本工作目录;相当于shell下cd
os.curdir  #返回当前目录: ('.')
os.pardir  #获取当前目录的父目录字符串名:('..')
os.makedirs('dirname1/dirname2')    #可生成多层递归目录
os.removedirs('dirname1')    #若目录为空,则删除,并递归到上一级目录,如若也为空,则删除,依此类推
os.mkdir('dirname')    #生成单级目录;相当于shell中mkdir dirname
os.rmdir('dirname')    #删除单级空目录,若目录不为空则无法删除,报错;相当于shell中rmdir dirname
os.listdir('dirname')    #列出指定目录下的所有文件和子目录,包括隐藏文件,并以列表方式打印
os.remove()  #删除一个文件
os.rename("oldname","newname")  #重命名文件/目录
os.stat('path/filename')  #获取文件/目录信息
os.sep    #输出操作系统特定的路径分隔符,win下为"\",Linux下为"/"
os.linesep    #输出当前平台使用的行终止符,win下为"tn",Linux下为"n"
os.pathsep    #输出用于分割文件路径的字符串 win下为;,Linux下为:
os.name    #输出字符串指示当前使用平台。win->'nt'; Linux->'posix'
os.system("bash command")  #运行shell命令,直接显示
os.environ  #获取系统环境变量
os.path.split(path)  #将path分割成目录和文件名二元组返回
os.path.basename(path)  #返回path最后的文件名。如何path以/或结尾,那么就会返回空值。即os.path.split(path)的第二个元素
os.path.isabs(path)  #如果path是绝对路径,返回True
os.path.isfile(path)  #如果path是一个存在的文件,返回True。否则返回False
os.path.isdir(path)  #如果path是一个存在的目录,则返回True。否则返回False
os.path.getatime(path)  #返回path所指向的文件或者目录的最后存取时间
os.path.getmtime(path)  #返回path所指向的文件或者目录的最后修改时间
os.path.getsize(path) #返回path的大小

 

f=shelve.open('db.sh1')
#存数据
f['student1']={'name':'lary',"age":18}
#取数据
print(f['student1'])
f.close()

对以上代码的说明:

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

上传或下载文件 - 通过密钥

分分快三计划 50分分快三计划 51


 

2、使用模块

logging模块的Formatter,Handler,Logger,Filter对象

import sha

View Code

print(hashlib.new("md5", "Nobody inspects the spammish repetition").hexdigest())

#在Linux和Mac平台上,该函数会原样返回path,在windows平台上会将路径中所有字符转换为小写,并将所有斜杠转换为饭斜杠。
print(os.path.normcase('c:/windows\system32\'))
#规范化路径,如..和 /
print(os.path.normpath('c://windows\System32\../Temp/'))
a = '/Users/jieli/test1/\a1/\\aa.py/../..'
print(os.path.normpath(a))

#os路径处理
#方式一:
import os,sys
Base_dir = os.path.normpath(os.path.join(
    os.path.abspath(__file__),
    os.pardir, #上一级
    os.pardir,
    os.pardir
))
print(Base_dir)

#方式二:
os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))

print``(time.localtime(time.time()``-``86640``)) ``#将时间戳转换成struct_time格式,但返回 的本地时间

  json表示的对象就是标准的JaveScripts语言的对象,可以被所有语言读取,也可以方便的存储到磁盘或者通过网络传输,json和python内置的数据类型对应如下:

print(file1.get('portal','url'))

  在python中可以用以下模块操作xml

list_lambda = map(lambda x:x**x,range(10))
print(list_lambda)

分分快三计划 52分分快三计划 53

re模块用于对python的正则表达式的操作。

分分快三计划 54分分快三计划 55

例:

View Code

6、shutil模块

import sys

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

  . 匹配除换行符以外的任意字符
  w 匹配字母或数字或下划线或汉字
  s 匹配任意的空白符
  d 匹配数字
  b 匹配单词的开始或结束
  ^ 匹配字符串的开始
  $ 匹配字符串的结束

[section1]
k1 = v1
k2:v2
user=egon
age=18
is_admin=true
salary=31

[section2]
k1 = v1

过密钥链接服务器

1.日志模块(import logging)

分分快三计划 56分分快三计划 57

 

例:

file3.read('aa.txt')
print(file3.get('portal','url'))

例如:copytree(source, destination, ignore=ignore_patterns('*.pyc', 'tmp*'))


import re
a = 'Oldboy School,Beijing Changping shahe:010-8343245'

match = re.search(r'(D ),(D ):(S )',a)
print(match.group(1))
print(match.group(2))
print(match.group(3))

print("##########################")

match2 = re.search(r'(?P<name>D ),(?P<address>D ):(?P<phone>S )',a)
print(match2.group('name'))
print(match2.group('address'))
print(match2.group('phone'))

例:


通过用户名和密码连接服务器

 1 import json
 2 
 3 data = {    'a': [1, 2.0, 3, 4],    'b': ("character string", "byte string"),    'c': 'abc'}
 4 
 5 du = json.dumps(data)
 6 print(du)
 7 print(json.loads(du,encoding='ASCII'))
 8 
 9 with open('data.json','w') as f:
10     json.dump(data,f,indent=2,sort_keys=True,separators=(',',':'))
       #f.write(json.dumps(data))

11
12 with open('data.json','r') as f: 
13     data = json.load(f) 
14     print(repr(data))

6.十六进制结果

 


r = re.compile('d ')
r1 = r.match('adfaf123asdf1asf1123aa')
if r1:
    print(r1.group())
else:
    print('no match')

time模块提供各种操作时间的函数

* 包含可pickle对象的tuples,lists,sets和dictionaries;




1.基本的读取配置文件

print``(time.ctime(time.time()``-``86640``)) ``#将时间戳转为字符串格式

★execfile(filename[, globals[, locals]])
     Read and execute a Python script from a file.The globals and locals are dictionaries, defaulting to the currentglobals and locals.  If only globals is given, locals defaults to it.

r2 = r.search('adfaf123asdf1asf1123aa')
if r2:
    print(r2.group())
    print(r2.groups())
else:
    print('no match')
    
r3 = r.findall('adfaf123asdf1asf1123aa')
if r3:
    print(r3)
else:
    print('no match')
    
r4 = r.sub('###','adfaf123asdf1asf1123aa')
print(r4)

* 拥有__dict__()或__setstate__()的自定义类型;

 


new_date ``= datetime.datetime.now() ``  datetime.timedelta(days``=``10``) ``#比现在加10天


import re


★re.split可以使用re.split来分割字符串,如:re.split(r's ', text);将字符串按空格分割成一个单词列表。

8、logging模块:

★reduce(function, sequence[, initial]) -> value   对二个参数进行计算
Apply a function of two arguments cumulatively to the items of a  sequence,
from left to right, so as to reduce the sequence to a single value.For example, reduce(lambda x, y: x y, [1, 2, 3, 4, 5]) calculates((((1 2) 3) 4) 5).  If initial is present, it is placed before the 
 items of the sequence in the calculation, and serves as a default when  the sequence is empty.

hashlib

#datetime.replace([year[, month[, day[, hour[, minute[, second[, microsecond[, tzinfo]]]]]]]])


1 python lambda会创建一个函数对象,但不会把这个函数对象赋给一个标识符,而def则会把函数对象赋值给一个变量。
2 python lambda它只是一个表达式,而def则是一个语句。

new_date ``= datetime.datetime.now() ``  datetime.timedelta(seconds``=``120``) ``#比现在 120s

new_date ``= datetime.datetime.now() ``  datetime.timedelta(days``=``-``10``) ``#比现在减10天

 

import time

paramiko是一个用于做远程控制的模块,使用该模块可以对远程服务器进行命令或文件操作,值得一说的是,fabric和ansible内部的远程管理就是使用的paramiko来现实。

configparser

2.调用hashlib里的md5()生成一个md5 hash对象

 

★exec(source[, globals[, locals]]) 语句用来执行储存在字符串或文件中的Python语句

import paramiko

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

ssh = paramiko.SSHClient()
ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
ssh.connect('主机名 ', 端口, '用户名', key)

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

-get(section,option) 得到section中option的值,返回为string类型

       银角:http://www.cnblogs.com/wupeiqi/articles/4963027.html

 注:因为在3.3里面,map(),filter()这些的返回值已经不再是list,而是iterators, 所以想要使用,只用将iterator 转换成list 即可, 比如 list(map()) 


 

 

r5 = r.subn('###','adfaf123asdf1asf1123aa')
print(r5)

1.简单的将日志打印到屏幕

 

import logginglogging.debug('This is debug message')logging.info('This is info message')logging.warning('This is warning message')

 

屏幕上打印:WARNING:root:This is warning message

默认情况下,logging将日志打印到屏幕,日志级别为WARNING;
日志级别大小关系为:CRITICAL > ERROR > WARNING > INFO > DEBUG > NOTSET,当然也可以自己定义日志级别。

1、random模块:

经测试,2.7版本导出的json文件,3.4版本导入会报错:TypeError: the JSON object must be str, not 'bytes'

 

错误:“Unicode-objects must be encoded before hashing”,意思是在进行md5哈希运算前,需要对数据进行编码,使用encode("utf8")


r6 = r.split('adfaf123asdf1asf1123aa',maxsplit=2)
print(r6)

 1 import pickle
 2 
 3 class test():
 4     def __init__(self,n):
 5         self.a = n
 6 
 7 t = test(123)
 8 t2 = test('abc')
 9 
10 a_list = ['sky','mobi','mopo']
11 a_dict = {'a':1,'b':2,'3':'c'}
12 
13 with open('test.pickle','wb') as f:
14     pickle.dump(t,f)
15     pickle.dump(a_list,f)
16     pickle.dump(t2,f)
17 
18 with open('test.pickle','rb') as g:
19     gg = pickle.load(g)
20     print(gg.a)
21     hh = pickle.load(g)
22     print(hh[1])
23     ii = pickle.load(g)
24     print(ii.a)

例:

import md5
src = 'this is a md5 test.'   
m1 = md5.new()   
m1.update(src)   
print m1.hexdigest()

得到终端输出:

1、下载安装(pycrypto,由于 paramiko 模块内部依赖pycrypto,所以先下载安装pycrypto)

shutil.copy2(src, dst)

import hashlib
hash = hashlib.md5()
hash.update('this is a md5 test.'.encode("utf8")

★zip(seq1 [, seq2 [...]]) -> [(seq1[0], seq2[0] ...), (...)] 将多个序列转化为新元祖的序列
Return a list of tuples, where each tuple contains the i-th element from each of the argument sequences.  The returned list is  truncated in length to the length of the shortest argument sequence.


递归的去删除文件

shutil.ignore_patterns(*patterns)
shutil.copytree(src, dst, symlinks=False, ignore=None)
递归的去拷贝文件


        Return a formatted version of S, using substitutions from args and kwargs.
        The substitutions are identified by braces ('{' and '}').

3、pickle和json模块:

例:

a = [1,2,3,4,5,6]
b = [11,22,33,44,55]
c = [111,222,333,444]
print(zip(a,b,c))

5.加密后的二进制结果

注:json并不像pickle一样,将python对象序列化为二进制流或文件,所以写或读不能加b;

分分快三计划 58

print``(time.mktime(time.localtime())) ``#与time.localtime()功能相反,将struct_time格式转回成时间戳格式

 


Json模块提供了四个功能:dumps、dump、loads、load

★map(function,sequence) 将squence每一项做为参数传给函数,并返回值

 

str_to_date ``= datetime.datetime.strptime(``"21/11/06 16:30"``, ``"%d/%m/%y %H:%M"``) ``#将字符串转换成日期格式

python lambda是在python中使用lambda来创建匿名函数,而用def创建的方法是有名称的,除了从表面上的方法名不一样外,python lambda还有哪些和def不一样呢?

 

cf = ConfigParser.SafeConfigParser() 

-read(filename) 直接读取ini文件内容

import paramiko

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

t = paramiko.Transport(('182.92.219.86',22))
t.connect(username='wupeiqi',pkey=key)

sftp = paramiko.SFTPClient.from_transport(t)
sftp.put('/tmp/test3.py','/tmp/test3.py') 

t.close()

import paramiko

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

t = paramiko.Transport(('182.92.219.86',22))
t.connect(username='wupeiqi',pkey=key)

sftp = paramiko.SFTPClient.from_transport(t)
sftp.get('/tmp/test3.py','/tmp/test4.py') 

t.close()

 

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

list = [i ** i for i in range(10)]
print(list)

1
2
3
4
import hmac
= hmac.new('wueiqi')
h.update('hellowo')
print h.hexdigest()

file2 = ConfigParser.ConfigParser()

1
2
3
4
5
6
7
import hashlib
 
# ######## md5 ########
 
hash = hashlib.md5('898oaFs09f')
hash.update('admin')
print hash.hexdigest()
#!/usr/bin/env python
#coding:utf-8

import paramiko

ssh = paramiko.SSHClient()
ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
ssh.connect('192.168.1.108', 22, 'alex', '123')
stdin, stdout, stderr = ssh.exec_command('df')
print stdout.read()
ssh.close();

a = 'print("nihao")'

exec(a) 

生成5位随机数,例:

a = '8*(8 20-5*23'
print(eval(a))

file1 = ConfigParser.RawConfigParser()

-items(section) 得到该section的所有键值对


[portal] 

 

* 定义在module顶层的类;

 python对象与文件之间的序列化和反序列化:

 

7、ConfigParser

print``(current_time.timetuple()) ``#返回struct_time格式

以上加密算法虽然依然非常厉害,但时候存在缺陷,即:通过撞库可以反解。所以,有必要对加密算法中添加自定义key再来做加密

高级的 文件、文件夹、压缩包 处理模块

拷贝文件和状态信息

-options(section) 得到该section的所有option


a = []
for i in range(5):
    if i == random.randint(1,5):
        a.append(str(i))
    else:
        a.append(chr(random.randint(65,90)))
else:        
    print(''.join(a))

拷贝状态的信息,包括:mode bits, atime, mtime, flags

pickle.dumps()

用于序列化的两个模块

-set( section, option, value) 对section中的option进行设置,需要调用write将内容写入配置文件。

 

★random 生成随机数

import datetime

3.将日志同时输出到文件和屏幕

import logginglogging.basicConfig(level=logging.DEBUG,                format='%(asctime)s %(filename)s[line:%(lineno)d] %(levelname)s %(message)s',                datefmt='%a, %d %b %Y %H:%M:%S',                filename='myapp.log',                filemode='w')##################################################################################################定义一个StreamHandler,将INFO级别或更高的日志信息打印到标准错误,并将其添加到当前的日志处理对象#console = logging.StreamHandler()console.setLevel(logging.INFO)formatter = logging.Formatter('%(name)-12s: %(levelname)-8s %(message)s')console.setFormatter(formatter)logging.getLogger('').addHandler(console)#################################################################################################logging.debug('This is debug message')logging.info('This is info message')logging.warning('This is warning message')

 

屏幕上打印:root        : INFO     This is info messageroot        : WARNING  This is warning message

./myapp.log文件中内容为:Sun, 24 May 2009 21:48:54 demo2.py[line:11] DEBUG This is debug messageSun, 24 May 2009 21:48:54 demo2.py[line:12] INFO This is info messageSun, 24 May 2009 21:48:54 demo2.py[line:13] WARNING This is warning message

常用模块(三卡塔尔——shelve、xml、hashlib、configparser分分快三计划。for k,v in enumerate(['a','b','c',1,2,3],10):
        print k,v 


print``(time.gmtime(time.time()``-``86640``)) ``#将时间戳转换成struct_time格式

#datetime module

例:

用于加密相关的操作,代替了md5模块和sha模块,主要提供 SHA1, SHA224, SHA256, SHA384, SHA512 ,MD5 算法

shutil.copymode(src, dst)


 

 

4.logging之日志回滚

import loggingfrom logging.handlers import RotatingFileHandler##################################################################################################定义一个RotatingFileHandler,最多备份5个日志文件,每个日志文件最大10MRthandler = RotatingFileHandler('myapp.log', maxBytes=10*1024*1024,backupCount=5)Rthandler.setLevel(logging.INFO)formatter = logging.Formatter('%(name)-12s: %(levelname)-8s %(message)s')Rthandler.setFormatter(formatter)logging.getLogger('').addHandler(Rthandler)################################################################################################

从上例和本例可以看出,logging有一个日志处理的主对象,其它处理方式都是通过addHandler添加进去的。
logging的几种handle方式如下:

 

logging.StreamHandler: 日志输出到流,可以是sys.stderr、sys.stdout或者文件
logging.FileHandler: 日志输出到文件

日志回滚方式,实际使用时用RotatingFileHandler和TimedRotatingFileHandler
logging.handlers.BaseRotatingHandler
logging.handlers.RotatingFileHandler
logging.handlers.TimedRotatingFileHandler

logging.handlers.SocketHandler: 远程输出日志到TCP/IP sockets
logging.handlers.DatagramHandler:  远程输出日志到UDP sockets
logging.handlers.SMTPHandler:  远程输出日志到邮件地址
logging.handlers.SysLogHandler: 日志输出到syslog
logging.handlers.NTEventLogHandler: 远程输出日志到Windows NT/2000/XP的事件日志
logging.handlers.MemoryHandler: 日志输出到内存中的制定buffer
logging.handlers.HTTPHandler: 通过"GET"或"POST"远程输出到HTTP服务器

 

由于StreamHandler和FileHandler是常用的日志处理方式,所以直接包含在logging模块中,而其他方式则包含在logging.handlers模块中,
上述其它处理方式的使用请参见python2.5手册!

-add_section(section) 添加一个新的section


shutil 对压缩包的处理是调用 ZipFile 和 TarFile 两个模块来进行的,

-getint(section,option) 得到section中option的值,返回为int类型,还有相应的getboolean()和getfloat() 函数。

用于对特定的配置进行操作,当前模块的名称在 python 3.x 版本中变更为 configparser。

例:

lambda语句中,冒号前是参数,可以有多个,用逗号隔开,冒号右边的返回值。lambda语句构建的其实是一个函数对象。

 

print random.randrange(1,3,2)    生成整数,不包含endpoint

shutil.copystat(src, dst)

      sort_keys是告诉编码器按照字典排序(a到z)输出

exec(b)


 

shutil.copyfileobj(fsrc, fdst[, length])
将文件内容拷贝到另一个文件中,可以部分内容

 

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}$

current_time ``= datetime.datetime.now() ``#



print``(time.clock()) ``#返回处理器时间,3.3开始已废弃

print hash.hexdigest()

      indent参数根据数据格式缩进显示,读起来更加清晰:

使用SafeConfigParser:

print``(time.strftime(``"%Y-%m-%d %H:%M:%S"``,time.gmtime()) ) ``#将struct_time格式转成指定的字符串格式

4.继续调用update方法会在前面加密的基础上更新加密

content = "'1 - 2 * ((60-30 1*(9-2*5/3 7/3*99/4*2998 10*568/14))-(-4*3)/(16-3*2) )'"
new_content = re.split('*', content)
# new_content = re.split('*', content, 1)
print new_content

content = "'1 - 2 * ((60-30 1*(9-2*5/3 7/3*99/4*2998 10*568/14))-(-4*3)/(16-3*2) )'"
new_content = re.split('[ -*/] ', content)
# new_content = re.split('*', content, 1)
print new_content

inpp = '1-2*((60-30  (-40-5)*(9-2*5/3   7 /3*99/4*2998  10 * 568/14 )) - (-4*3)/ (16-3*2))'
inpp = re.sub('s*','',inpp)
new_content = re.split('(([ -*/]?d [ -*/]?d ){1})', inpp, 1)
print new_content

new_date ``= datetime.datetime.now() ``  datetime.timedelta(hours``=``-``10``) ``#比现在减10小时

三、其他常用模块:

print``(current_time) ``#输出2016-01-26 19:04:30.335935

123   和('123',)。

 


import random

 

1.首先从python直接导入hashlib模块

 

也经常用于生成列表,例:

      同时只能针对一个对象或类型进行dump和load,不像pickle可以多个。

★filter(function or None, sequence) -> list, tuple, or string  返还true的序列
        Return those items of sequence for which function(item) is true.  If
    function is None, return the items that are true.  If sequence is a tuple
    or string, return the same type, else return a list.

★生成MD5码

 

# 注释1
; 注释2

[section1]
k1 = v1
k2:v2

[section2]
k1 = v1

import ConfigParser

config = ConfigParser.ConfigParser()
config.read('i.cfg')

# ########## 读 ##########
#secs = config.sections()
#print secs
#options = config.options('group2')
#print options

#item_list = config.items('group2')
#print item_list

#val = config.get('group1','key')
#val = config.getint('group1','key')

# ########## 改写 ##########
#sec = config.remove_section('group1')
#config.write(open('i.cfg', "w"))

#sec = config.has_section('wupeiqi')
#sec = config.add_section('wupeiqi')
#config.write(open('i.cfg', "w"))


#config.set('group2','k1',11111)
#config.write(open('i.cfg', "w"))

#config.remove_option('group2','age')
#config.write(open('i.cfg', "w"))

 

file2.read('aa.txt')
print(file2.get('portal','url'))

 

具体的转化对照如下:

print``(current_time.replace(``2014``,``9``,``12``)) ``#输出2014-09-12 19:06:24.074900,返回当前时间,但指定的值将被替换

 

★re.findall可以获取字符串中所有匹配的字符串。如:re.findall(r'w*oow*', text);获取字符串中,包含'oo'的所有单词。

* 定义在module顶层的内置函数;

分分快三计划 59分分快三计划 60

三. 使用hashlib

例:

★re.sub的函数原型为:re.sub(pattern, repl, string, count)

 

shutil.copyfile(src, dst) 拷贝文件

shutil.rmtree(path[, ignore_errors[, onerror]])

分分快三计划 61

print``(new_date)


* 定义在module顶层的函数:

  * 重复零次或更多次
   重复一次或更多次
  ? 重复零次或一次
  {n} 重复n次
  {n,} 重复n次或更多次
  {n,m} 重复n到m次

★re.match的函数原型为:re.match(pattern, string, flags)

hash = sha.new()

 

得到终端输出(效果同ConfigParser):

还不够吊?python 还有一个 hmac 模块,它内部对我们创建 key 和 内容 再进行处理然后再加密

pickle.loads()

 

host = localhost 

例:

 

 

import ConfigParser 

 


print(reduce(lambda x,y:x*y,[],5))

第二个参数表示要匹配的字符串;

randrange(self, start, stop=None, step=?)



#1、时间戳    1970年1月1日之后的秒
#2、元组 包含了:年、日、星期等... time.struct_time
#3、格式化的字符串    2014-11-11 11:11

print(hash.hexdigest())

注意:对于函数或类的序列化是以名字来识别的,所以需要import相应的module。

使用RawConfigParser:

★S.format(*args, **kwargs) -> string  字符串的格式输出,类似于格式化输出%s

3.生成hash对象后,就可以用update方法对字符串进行md5加密的更新处理


二、使用sha包

其中第二个函数是替换后的字符串;本例中为'-'


print random.random()             生成0-1之间的小数

encoding:把一个Python对象编码转换成Json字符串
decoding:把Json格式字符串解码转换成Python对象

 

 

pickle模块用来实现python对象的序列化和反序列化。通常地pickle将python对象序列化为二进制流或文件。

  • json,用于字符串 和 python数据类型间进行转换
  • pickle,用于python特有的类型 和 python的数据类型间进行转换

print``(datetime.date.today()) ``#输出格式 2016-01-26

分别是RawConfigParser、ConfigParser、 SafeConfigParser。

2.通过logging.basicConfig函数对日志的输出格式及方式做相关配置

import logginglogging.basicConfig(level=logging.DEBUG,                format='%(asctime)s %(filename)s[line:%(lineno)d] %(levelname)s %(message)s',                datefmt='%a, %d %b %Y %H:%M:%S',                filename='myapp.log',                filemode='w')    logging.debug('This is debug message')logging.info('This is info message')logging.warning('This is warning message')

 

./myapp.log文件中内容为:Sun, 24 May 2009 21:48:54 demo2.py[line:11] DEBUG This is debug messageSun, 24 May 2009 21:48:54 demo2.py[line:12] INFO This is info messageSun, 24 May 2009 21:48:54 demo2.py[line:13] WARNING This is warning message

logging.basicConfig函数各参数:
filename: 指定日志文件名
filemode: 和file函数意义相同,指定日志文件的打开模式,'w'或'a'
format: 指定输出的格式和内容,format可以输出很多有用信息,如上例所示:
 %(levelno)s: 打印日志级别的数值
 %(levelname)s: 打印日志级别名称
 %(pathname)s: 打印当前执行程序的路径,其实就是sys.argv[0]
 %(filename)s: 打印当前执行程序名
 %(funcName)s: 打印日志的当前函数
常用模块(三卡塔尔——shelve、xml、hashlib、configparser分分快三计划。 %(lineno)d: 打印日志的当前行号
 %(asctime)s: 打印日志的时间
 %(thread)d: 打印线程ID
 %(threadName)s: 打印线程名称
 %(process)d: 打印进程ID
 %(message)s: 打印日志信息
datefmt: 指定时间格式,同time.strftime()
level: 设置日志级别,默认为logging.WARNING
stream: 指定将日志的输出流,可以指定输出到sys.stderr,sys.stdout或者文件,默认输出到sys.stderr,当stream和filename同时指定时,stream被忽略

4、正则表达式模块:

注:dump和load一一对应,顺序也不会乱。

如果要实现python对象和字符串间的序列化和反序列化,则使用:

import os,sys
import paramiko

t = paramiko.Transport(('182.92.219.86',22))
t.connect(username='wupeiqi',password='123')
sftp = paramiko.SFTPClient.from_transport(t)
sftp.put('/tmp/test.py','/tmp/test.py') 
t.close()


import os,sys
import paramiko

t = paramiko.Transport(('182.92.219.86',22))
t.connect(username='wupeiqi',password='123')
sftp = paramiko.SFTPClient.from_transport(t)
sftp.get('/tmp/test.py','/tmp/test2.py')
t.close()

import ConfigParser 

 

 

★eval(source[, globals[, locals]]) -> value 将表达式字符串执行为值,其中globals为全局命名空间,locals为局部命名空间,从指字的命名空间中执行表达式,
        Evaluate the source in the context of globals and locals.    The source may be a string representing a Python expression  or a code object as returned by compile().    The globals must be a dictionary and locals can be any mapping,    defaulting to the current globals and locals.    If only globals is given, locals defaults to it.

分分快三计划 62分分快三计划 63

使用ConfigParser:

可以被序列化的类型有:

注:re执行分二步:首先编译,然后执行。故先使用re.compile进行查询的字符串进行编译,之后的操作无需在次编译,可以提高效率。

得到终端输出:

d = {'a':5,'b':4}
print(eval('a*b',d))

print random.randint(1,3)         生成整数,包含endpoint

用于便捷记录日志且线程安全的模块

 

举例说明:

pickle.load()

url =  

port = 8080 

re.match与re.search的区别:re.match只匹配字符串的开始,如果字符串开始不符合正则表达式,则匹配失败,函数返回None;而re.search匹配整个字符串,直到找到一个匹配。

 

def comp(arg):
    if arg < 8:
        return True
    else:
        return False  
print(filter(comp,[1,19,21,8,5]))
print(filter(lambda x:x % 2,[1,19,20,8,5]))
print(filter(lambda x:x % 2,(1,19,20,8,5)))
print(filter(lambda x:x > 'a','AbcdE'))

 

pickle.dump()

  • base_name: 压缩包的文件名,也可以是压缩包的路径。只是文件名时,则保存至当前目录,否则保存至指定路径,
    如:www                        =>保存至当前路径
    如:/Users/wupeiqi/www =>保存至/Users/wupeiqi/
  • format: 压缩包种类,“zip”, “tar”, “bztar”,“gztar”
  • root_dir: 要压缩的文件夹路径(默认当前目录)
  • owner: 用户,默认当前用户
  • group: 组,默认当前组
  • logger: 用于记录日志,通常是logging.Logger对象

5、time模块

★re.compile可以把正则表达式编译成一个正则表达式对象。可以把那些经常使用的正则表达式编译成正则表达式对象,这样可以提高一定的效率。下面是一个正则表达式对象的一个例子:

2、MD5、sha、hashlib模块

file3 = ConfigParser.SafeConfigParser()

分分快三计划 64分分快三计划 65

 


*shutil.make_archive(base_name, format,...)*

re.sub还允许使用函数对匹配项的替换进行复杂的处理。如:re.sub(r's', lambda m: '[' m.group(0) ']', text, 0);将字符串中的空格' '替换为'[ ]'。

 

b = 'for i in range(10): print i'

print``(datetime.date.fromtimestamp(time.time()``-``864400``) ) ``#2016-01-16 将时间戳转成日期格式

-sections() 得到所有的section,并以列表的形式返回

     而group,groups 主要是针对查询的字符串是否分组,一般只是针对search和match,即'd ' 和('d ') 输出结果为:

推荐使用第三种方法。

enumerate(iterable[, start]) -> iterator for index, value of iterable Return an enumerate object.  iterable must be another object  that supports iteration.  The enumerate object yields pairs containing a count  (from start, which defaults to zero) and a value yielded by the iterable 
 argument. enumerate is useful for obtaining an indexed list:    (0, seq[0]), (1, seq[1]), (2, seq[2]), ...

匹配IP具体实例:

次数:

本文由分分快三计划发布,转载请注明来源

关键词: 分分快三计划 python Python基础 python笔记