python day6 学习整理

今天学习的内容如下：

1.常用模块

2.面向对象的程序设计

1. 时间模块

时间分成三种时间

1.时间戳（1970年到现在的秒数）（time.time()）

2.结构化的时间（time.localtime().tm_year）

3.utc时区的时间（time.gtime()）

4.格式化的时间（time.strftime('%Y-%m-%d %H:%M:%S')）

另一种形式（time.strftime('%Y-%m-%d %X')）

time.strftime('%Y',time.localtime()) （只格式化一个年出来）

time.strptime('2017-06-04 11:59:59','%Y-%m-%d %X') (把格式化时间转化成结构化时间)

time.ctime(1234453453453)

#!/usr/bin/python
# -*- coding:utf-8 -*-
import time
#时间戳
# print(time.time())

#结构化的时间
# print(time.localtime())
# print(time.localtime().tm_year)
# print(time.gmtime())

#格式化的字符串
# print(time.strftime('%Y-%m-%d %H:%M:%S'))
# print(time.strftime('%Y-%m-%d %X'))

#
# print(time.localtime(13211123))
# print(time.localtime(time.time()))
#
# print(time.mktime(time.localtime()))

# print(time.strftime('%Y %X',time.localtime()))

# print(time.strptime('2017-06-04 11:59:59','%Y-%m-%d %X'))

# print(time.ctime(123123132))

# print(time.asctime(time.localtime()))

2 random 模块

#!/usr/bin/python
# -*- coding:utf-8 -*-
# import random
# proxy_ip=[
#     '1.1.1.1',
#     '1.1.1.2',
#     '1.1.1.3',
#     '1.1.1.4',
# ]
#
# print(random.choice(proxy_ip))


# import random
# print(random.sample([1,'23',[4,5]],2))

import random
# item=[1,3,5,7,9]
#
# random.shuffle(item)
# print(item)


def v_code(n=5):
    res=''
    for i in range(n):
        num=random.randint(0,9)
        s=chr(random.randint(65,90))
        add=random.choice([num,s])
        res+=str(add)
    return res

print(v_code(6))

3. os和sys模块

os模块是与操作系统交互的一个借口

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下为"	
",Linux下为"
"
os.pathsep    输出用于分割文件路径的字符串 win下为;,Linux下为:
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所指向的文件或者目录的最后修改时间
os.path.getsize(path) 返回path的大小

补充：

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

import os
# print(os.path.abspath('a/b/c.txt')) #E:wupeiqis17day06ac.txt
# print(os.path.abspath('/a/b/c.txt')) #E:ac.txt

# print(os.path.split('E:\a\c.txt'))
# print(os.path.dirname('E:\a\c.txt'))
# print(os.path.dirname('E:\a'))
# print(os.path.basename('E:\a\a,txt'))

# print(os.path.exists('E:\a'))
# print(os.path.exists('E:wupeiqis17day06'))

# print(os.path.isabs('E:\day06'))
# print(os.path.isabs('day06'))

# print(os.path.getsize(r'E:wupeiqis17day06	est.py'))

# print(os.path.join('a','E:\b','c.txt'))
# print(os.path.join('a','/b','c.txt')) #/b/c.txt

# print(os.path.normcase('c:/wIndows\system32\') )

# print(os.path.normpath('c://windows\System32\../Temp/'))

将路径加入环境变量

import os
os.path.abspath(__file__) #取当前的绝对路径

BASE_DIR=os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
sys.path.append(BASE_DIR) #添加到环境变量

第二种方式：
BASE_DIR=os.path.normpath(os.path.join(__file__,os.pardir,os.pardir))
sys.path.append(BASE_DIR)

sys模块比较有用的

sys.argv(列表的形式，文件的路径)

打印进度条

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

# import sys
#
# print(sys.argv)


import sys,time

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

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

代表跳到行首

4.shutil模块

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

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

1 import shutil
2  
3 shutil.copyfileobj(open('old.xml','r'), open('new.xml', 'w'))

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

1 shutil.copyfile('f1.log', 'f2.log') #目标文件无需存在

shutil.copymode(src, dst)
仅拷贝权限。内容、组、用户均不变

1 shutil.copymode('f1.log', 'f2.log') #目标文件必须存在

shutil.copystat(src, dst)
仅拷贝状态的信息，包括：mode bits, atime, mtime, flags

1 shutil.copystat('f1.log', 'f2.log') #目标文件必须存在

shutil.copy(src, dst)
拷贝文件和权限

1 import shutil
2  
3 shutil.copy('f1.log', 'f2.log')

shutil.copy2(src, dst)
拷贝文件和状态信息

1 import shutil
2  
3 shutil.copy2('f1.log', 'f2.log')

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

1 import shutil
2  
3 shutil.copytree('folder1', 'folder2', ignore=shutil.ignore_patterns('*.pyc', 'tmp*')) #目标目录不能存在，注意对folder2目录父级目录要有可写权限，ignore的意思是排除 

shutil.rmtree(path[, ignore_errors[, onerror]])
递归的去删除文件

1 import shutil
2  
3 shutil.rmtree('folder1')

shutil.move(src, dst)
递归的去移动文件，它类似mv命令，其实就是重命名。

1 import shutil
2  
3 shutil.move('folder1', 'folder3')

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对象

1 #将 /data 下的文件打包放置当前程序目录
2 import shutil
3 ret = shutil.make_archive("data_bak", 'gztar', root_dir='/data')
4   
5   
6 #将 /data下的文件打包放置 /tmp/目录
7 import shutil
8 ret = shutil.make_archive("/tmp/data_bak", 'gztar', root_dir='/data') 

5. json模块

用来序列化

之前我们学习过用eval内置方法可以将一个字符串转成python对象，不过，eval方法是有局限性的，对于普通的数据类型，json.loads和eval都能用，但遇到特殊类型的时候，eval就不管用了,所以eval的重点还是通常用来执行一个字符串表达式，并返回表达式的值。

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

什么是序列化？

我们把对象(变量)从内存中变成可存储或传输的过程称之为序列化，在Python中叫pickling，在其他语言中也被称之为serialization，marshalling，flattening等等，都是一个意思。

为什么要序列化？

1：持久保存状态

需知一个软件/程序的执行就在处理一系列状态的变化，在编程语言中，'状态'会以各种各样有结构的数据类型(也可简单的理解为变量)的形式被保存在内存中。

内存是无法永久保存数据的，当程序运行了一段时间，我们断电或者重启程序，内存中关于这个程序的之前一段时间的数据（有结构）都被清空了。

在断电或重启程序之前将程序当前内存中所有的数据都保存下来（保存到文件中），以便于下次程序执行能够从文件中载入之前的数据，然后继续执行，这就是序列化。

具体的来说，你玩使命召唤闯到了第13关，你保存游戏状态，关机走人，下次再玩，还能从上次的位置开始继续闯关。或如，虚拟机状态的挂起等。

2：跨平台数据交互

序列化之后，不仅可以把序列化后的内容写入磁盘，还可以通过网络传输到别的机器上，如果收发的双方约定好实用一种序列化的格式，那么便打破了平台/语言差异化带来的限制，实现了跨平台数据交互。

反过来，把变量内容从序列化的对象重新读到内存里称之为反序列化，即unpickling。

如何序列化之json和pickle：

json

如果我们要在不同的编程语言之间传递对象，就必须把对象序列化为标准格式，比如XML，但更好的方法是序列化为JSON，因为JSON表示出来就是一个字符串，可以被所有语言读取，也可以方便地存储到磁盘或者通过网络传输。JSON不仅是标准格式，并且比XML更快，而且可以直接在Web页面中读取，非常方便。

json       python

{}          dict

[]            list

"string"    str

123.56    int或float

true/false True/False

null         None

内存中的结构化数据 《————》 格式json 《————》字符串 《————》 保存到文件中或基于网络传输

实例

#!/usr/bin/python
# -*- coding:utf-8 -*-
dic={
    'name':'alex',
    'age':9000,
    'height':'150cm',
}
with open('a.txt','w') as f:
    f.write(str(dic))


# with open('a.txt','r') as f:
#     res=eval(f.read())
#     print(res['name'],type(res))


# x="[null,true,false,1]"
# x="[None,True,1]"

# res=eval(x)
#
# print(res[0],type(res))
# import json
# res=json.loads(x)
# print(res)

import json
#序列化的过程：dic---->res=json.dumps(dic)---->f.write(res)
dic={
    'name':'alex',
    'age':9000,
    'height':'150cm',
}

res=json.dumps(dic)
print(res,type(res))
with open('a.json','w') as f:
    f.write(res)



import json
#反序列化的过程：res=f.read()---->res=json.loads(res)---->dic=res
with open('a.json','r') as f:
    dic=json.loads(f.read())
    print(dic,type(dic))
    print(dic['name'])


#json的便捷操作
import json
dic={
    'name':'alex',
    'age':9000,
    'height':'150cm',
}
json.dump(dic,open('b.json','w'))

反序列化实例

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

import json

res=json.load(open('b.json','r'))
print(res,type(res))

6. pickle 模块

可以序列化python的任意对象

实例

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

import pickle

# dic={'name':'alex','age':13}

# print(pickle.dumps(dic))
# with open('a.pkl','wb') as f:
#     f.write(pickle.dumps(dic))

# with open('a.pkl','rb') as f:
#     d=pickle.loads(f.read())
#     print(d,type(d))



# dic={'name':'alex','age':13}
# pickle.dump(dic,open('b.pkl','wb'))
# res=pickle.load(open('b.pkl','rb'))
# print(res,type(res))


#
import json
import pickle
# def func():
#     print('from func')

# json.dumps(func)# 报错，json不支持python的函数类型
# f=pickle.dumps(func)
# print(f)

# pickle.dump(func,open('c.pkl','wb'))
# res=pickle.load(open('c.pkl','rb'))
# print(res)
# res()

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


import pickle

pickle.load(open('c.pkl','rb'))

###报错 在内存空间内找不到对应的方法。因为他序列化保存的是一个内存地址，普通的数据类型是序列化的是数据类型，然后反序列化的时候又在内存空间创建。

7. shelve

python所支持的数据类型

实例：

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

# import shelve
#
# f=shelve.open(r'sheve.txt')
# # f['student1']={'name':'egon','age':18,'height':'180cm'}
# print(f['student1']['name'])
# f.close()

8. xml

xml协议在各个语言里都是支持的

实例1

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

import xml.etree.ElementTree as ET

tree = ET.parse("a")
root = tree.getroot()

# for i in root.iter('year'):
#     print(i.tag,i.text,i.attrib)

# print(root.find('country'))
# print(root.findall('country'))


# for country in root:
#     print('=====>',country.attrib['name'])
#     for item in country:
#         print(item.tag,item.text,item.attrib)


# for year in root.iter('year'):
#     print(year.tag,year.text,year.attrib)



# for year in root.iter('year'):
#     year.text=str(int(year.text)+1)
#     year.set('update','yes')


# tree.write('b.xml')
# tree.write('a')



# for country in root:
#     print(country)
#     # print('===>',country.find('year'))
#     year=country.find('year')
#     if int(year.text) > 2010:
#         country.remove(year)
#
# tree.write('d.xml')

# year2 = ET.Element('year2')


# for country in root:
#     print(country)
#     # print('===>',country.find('year'))
#     year=country.find('year')
#     if int(year.text) > 2010:
#         year2 = ET.Element('year2')
#         year2.text=str(int(year.text)+1)
#         year2.set('update','yes')
#         country.append(year2)
# tree.write('e.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)  # 打印生成的格式

实例2

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

实例3

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

实例4

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

 9. hashlib 文件校验

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

import hashlib
m = hashlib.md5()
with open('a','rb') as f:
    for line in f:
        m.update(line)
    md5_num = m.hexdigest()

print(md5_num)

存在缺陷，可以通过撞库来破解

密码加盐，加一个自定义的字符串

import hmac

h = hmac.new('alive'.encode('utf-8'))
h.update('alex3714'.encode('utf-8'))
print(h.hexdigest())

####两个和到一起

10 subprocess 模块

os.system()运行命令直接返回，用subprocess可以执行命令把结果保存下来，往任意位置发送

import subprocess
#stdout 标准输出，结果扔到管道里
#stderr 报错信息，扔到管道里
#stdin 标准输入
res = subprocess.Popen('dir',shell=True,
                       stderr=subprocess.PIPE,
                       stdout=subprocess.PIPE)
res.stdout.read().decode('gbk') ##从管道里吧结果拿出来

模拟管道输入

import subprocess
# res1 把输出结果扔到管道里
res1 = subprocess.Popen(r'dir E:wupeiqis17day06',shell=True,stdout=subprocess.PIPE)

# res 把res1的输出结果通过stdin接受，然后去执行findstr txt*，
res = subprocess.Popen('findstr txt*',shell=True,
                       stdin=res1.stdout,
                       stderr=subprocess.PIPE,
                       stdout=subprocess.PIPE)
print(res.stdout.read().decode('gbk'))  #管道只能取一次内容，取一次就空了

11 logging 日志模块

实例

import logging
logging.basicConfig(
    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')

12 configparser模块

实例

import configparser
config = configparser.ConfigParser()
config.read('a.ini')

print(config.sections())
config.get(option=('section1'))
config.items('section1')

13 软件开发规范

原则：目录明细，相同的功能放到同一个目录下

--ATM

       --bin #执行文件

           --

       --conf #配置文件

           --

       --lib  #包

           --

       --logs #日志

           --

      -- db #数据

           --

      --core #主逻辑

           --

14  类与对象

面向过程的程序设计的核心是过程（流水线式思维），过程即解决问题的步骤，面向过程的设计就好比精心设计好一条流水线，考虑周全什么时候处理什么东西。

优点是：极大的降低了程序的复杂度

缺点是：一套流水线或者流程就是用来解决一个问题，生产汽水的流水线无法生产汽车，即便是能，也得是大改，改一个组件，牵一发而动全身。

应用场景：一旦完成基本很少改变的场景，著名的例子有Linux內核，git，以及Apache HTTP Server等。

面向对象的程序设计的核心是对象（上帝式思维），要理解对象为何物，必须把自己当成上帝，上帝眼里世间存在的万物皆为对象，不存在的也可以创造出来。面向对象的程序设计好比如来设计西游记，如来要解决的问题是把经书传给东土大唐，如来想了想解决这个问题需要四个人：唐僧，沙和尚，猪八戒，孙悟空，每个人都有各自的特征和技能（这就是对象的概念，特征和技能分别对应对象的数据属性和方法属性），然而这并不好玩，于是如来又安排了一群妖魔鬼怪，为了防止师徒四人在取经路上被搞死，又安排了一群神仙保驾护航，这些都是对象。然后取经开始，师徒四人与妖魔鬼怪神仙交互着直到最后取得真经。如来根本不会管师徒四人按照什么流程去取。

面向对象的程序设计的

优点是：解决了程序的扩展性。对某一个对象单独修改，会立刻反映到整个体系中，如对游戏中一个人物参数的特征和技能修改都很容易。

缺点：可控性差，无法向面向过程的程序设计流水线式的可以很精准的预测问题的处理流程与结果，面向对象的程序一旦开始就由对象之间的交互解决问题，即便是上帝也无法预测最终结果。于是我们经常看到一个游戏人某一参数的修改极有可能导致阴霸的技能出现，一刀砍死3个人，这个游戏就失去平衡。

应用场景：需求经常变化的软件，一般需求的变化都集中在用户层，互联网应用，企业内部软件，游戏等都是面向对象的程序设计大显身手的好地方

面向对象的程序设计并不是全部。对于一个软件质量来说，面向对象的程序设计只是用来解决扩展性

对象就是变量与函数的结合体

面向对象唯一的优点：可扩展性强

类：提取对象共同的特征和技能就是类

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

# class Foo:
#     '''文档注释'''
#     pass


#类是一系列对象共有的特征（变量的定义）与技能（函数的定义）的结合体
# class Chinese:
#     country='China'
#
#     # Chinese.__init__(p1,'egon','18','male')
#     def __init__(self,name,age,sex):
#         #p1.Name=name；p1.Age=age,p1.Sex=sex
#         self.Name=name
#         self.Age=age
#         self.Sex=sex
#
#
#     def talk(self):
#         print('talking',self)


#属性的引用
# print(Chinese.country)
# print(Chinese.talk)
# Chinese.talk(123)
# Chinese.x=1
# print(Chinese.x)
# Chinese.country=123123123123123
# print(Chinese.country)

#实例化
class Chinese:
    country = 'China'

    # Chinese.__init__(p1,'egon','18','male')
    def __init__(self, name, age, sex):
        # p1.Name=name；p1.Age=age,p1.Sex=sex
        self.Name = name
        self.Age = age
        self.Sex = sex
    def talk(self):
        print('%s is talking' %self.Name)
# p1=Chinese('egon','18','male') #Chinese.__init__(p1,'egon','18','male')
# p2=Chinese('alex','9000','female') #Chinese.__init__(p1,'egon','18','male')

#对象的使用：只有一种，就是属性引用
# print(p1.Name)
# print(p1.Age)
# print(p1.Sex)
# print(p2.Name)

# print(p1.country)
# print(p2.country)


# p1.talk()
# p2.talk()
country = 'aaaaaaaaaa'
class Chinese:
    country = 'China'
    def __init__(self, name, age, sex):
        # self.country=123123123123123123
        self.Name = name
        self.Age = age
        self.Sex = sex
    def talk(self):
        print('%s is talking' %self.Name)
#类名称空间
# print(Chinese.__dict__)


#对象的空间
p1=Chinese('egon','18','male') #Chinese.__init__(p1,'egon','18','male')
p2=Chinese('alex','180','male')


# print(p1.__dict__)
# print(p1.Age) #p1.__dict__['Age']
# print(p1.country,id(p1.country))
# print(p2.country,id(p2.country))

# print(Chinese.talk)
# print(p1.talk)
# p1.talk() #Chines.talk(p1)
# print(p2.talk)
# p2.talk()#chinese.talk(p2)
print(type(p1))