Python Day6

diaoyudao

常用模块

random
　　random() 方法返回随机生成的一个实数
　　import random
　　

print(random.random())   #默认(0,1)----float    大于0且小于1之间的小数　　
#结果：
　　
0.7386919875081359
　　

　　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, 1, 7, 5, 9]
　　

生成随机验证码
　　

def make_code(n):　　res=''
　　for i in range(n):
　　s1=chr(random.randint(65,90)) #65,90是ASCII中的大写
　　s2=str(random.randint(0,9))
　　s3=chr(random.randint(97,122)) #97,122是ASCII中的小写
　　res+=random.choice([s1,s2,s3])
　　return res
　　
print(make_code(7))
　　

os模块
　　import os
　　#获取文件目录
　　os.path.dirname(r'D:\pycharm_20期\day6\练习.py')
　　#获取文件名
　　os.path.basename(r'D:\pycharm_20期\day6\练习.py')
　　#拼接
　　os.path.join
　　#获取当前目录的父目录字符串名：('..')
　　os.pardir
　　#规范化路径，如..和/
　　os.path.normpath
　　#举例
　　

a='/Users/jieli/test1/\\\a1/\\\\aa.py/../..'　　
print(os.path.normpath(a))
　　
/Users/jieli/test1
　　

获取当前执行文件的最上层文件夹
　　#D:\pycharm_20期\day6\练习.py
　　

BASE_DIR=os.path.normpath(os.path.join(　　os.path.abspath(__file__),
　　os.path.pardir,
　　os.path.pardir,
　　
))
　　

　　#这种写法的通用性好

sys 模块
　　import sys
　　sys.argv
　　#获取一个List，第一个元素是程序本身绝对路径
　　#举例，可以这样用：
　　#当py文件按照脚本方式执行时，可以在py文件后面加上值，此时可以利用sys.argv获取这些值
　　

python3 test.py sfile dfile #脚本方式执行，执行文件后面跟了两个参数　　
#使用解压方法可以一次将两个参数分别赋予变量
　　
_,sfile,dfile=sys.argv
　　
即:
　　
sfile=sfile #第一个参数
　　
dfile=dfile #第二个参数
　　

　　sys.exit(n)        退出程序，正常退出时exit(0)
　　print(sys.path)     初始化时使用PYTHONPATH环境变量的值
　　使用举例：
　　

把当前目录加入到环境变量　　

　　
BASE_DIR=os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
　　
sys.path.append(BASE_DIR)
　　

知识点：进度条
　　先打印出进度条的样子
　　

print('[%-50s]' %('#'*1)) #-代表左对齐，50代表宽度　　
print('[%-50s]' %('#'*2))
　　
print('[%-50s]' %('#'*3))
　　
结果：
　　
[#                                                 ]
　　
[##                                                ]
　　
[###                                               ]
　　

　　我们要把它变成一个连续的过程
　　知识点：
　　%% 两个百分号连到一起代表取消%的特殊意义，第一个百分号就是一个单纯的符号
　　

print('[%%-%ds]' %50)　　
结果：（是个字符串）
　　
[%-50s]
　　
print(('[%%-%ds]' %50) %('#'*10)) 等于'[%-50s]' %('#'*10)
　　
结果：
　　
[##########                                        ]
　　

　　实现进度条代码，这里使用time.sleep(0.1)模拟网络延迟
　　

import time　　
def progress(percent,width=50):  #percent是百分比，width是宽度
　　if percent >= 1:
　　percent=1
　　show_srt=('[%%-%ds]' %width) %('#'* int(width*percent))  #宽度乘百分比利用int取整
　　print('\r%s %d%%' %(show_srt,int(100*percent)),end='')   #\r代表光标移动到行首，end=''代表print不换行，%d%%是最后面的百分比
　　

　　
recv_size=0     #已经接收的大小
　　
total_size=102312  #文件总大小
　　

　　
while recv_size < total_size:
　　time.sleep(0.1)
　　recv_size+=1024
　　progress(recv_size/total_size)
　　

　　这里有个问题，如果文件大小是10241的话，那意味着在循环10次后recv_size已经是10240了，但此时recv_size仍然小于total_size
　　这时就会再次进入循环，结果在10240即基础上又加上了1024，此时recv_size已经大于total_size，在做除法运算时结果会大于1
　　这就会导致最后一次计算出的#打印个数大于宽度，需要在上面的进度条显示逻辑做判断，大于1直接按1算

shutil模块
　　高级的 文件、文件夹、压缩包 处理模块
　　import shutil
　　#将文件内容拷贝到另一个文件中
　　shutil.copyfileobj(open('old.xml','r'), open('new.xml', 'w'))
　　shutil.copyfile(src, dst)
　　#拷贝文件
　　shutil.copyfile('f1.log', 'f2.log') #目标文件无需存在
　　shutil.copy(src, dst)
　　#拷贝文件和权限
　　shutil.copy('f1.log', 'f2.log')
　　shutil.copytree(src, dst, symlinks=False, ignore=None)
　　#递归的去拷贝文件夹
　　shutil.copytree('folder1', 'folder2', ignore=shutil.ignore_patterns('*.pyc', 'tmp*'))
　　#目标目录不能存在，注意对folder2目录父级目录要有可写权限，ignore的意思是排除
　　shutil.rmtree(path[, ignore_errors[, onerror]])
　　#递归的去删除文件
　　shutil.rmtree('folder1')
　　shutil.move(src, dst)
　　#递归的去移动文件，它类似mv命令，其实就是重命名。
　　shutil.move('folder1', 'folder3')
　　shutil.make_archive(base_name, format,...)
　　创建压缩包并返回文件路径，例如：zip、tar
　　base_name： 压缩包的文件名，也可以是压缩包的路径。只是文件名时，则保存至当前目录，否则保存至指定路径，
　　如 data_bak                       =>保存至当前路径
　　如：/tmp/data_bak =>保存至/tmp/
　　format： 压缩包种类，“zip”, “tar”, “bztar”，“gztar”
　　root_dir：   要压缩的文件夹路径（默认当前目录）
　　owner：  用户，默认当前用户
　　group：  组，默认当前组
　　logger： 用于记录日志，通常是logging.Logger对象
　　shutil 对压缩包的处理是调用 ZipFile 和 TarFile 两个模块来进行的
　　#将/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')
　　

　　#解压
　　

import tarfile　　
t=tarfile.open('/tmp/egon.tar','r')
　　
t.extractall('/egon')
　　
t.close()
　　

josn模块
　　josn 是一种通用的标准格式

　　import json
　　#序列化
　　#使用dumps进行序列化
　　

a={'name':'dzm','age':18,'sex':'male'}　　
with open('user.json','w',encoding='utf-8') as f:
　　user=json.dumps(a)
　　f.write(user)
　　

　　#使用dump可以直接将序列化后的内容写入文件
　　json.dump(a,open('user.json','w',encoding='utf-8'))
　　#反序列化
　　#使用loads进行反序列化
　　

with open('user.json','r',encoding='utf-8') as f:　　user=json.loads(f.read()) #与json.dumps对应
　　print(user['name'])
　　

　　#无论数据是怎样创建的，只要满足json格式，就可以json.loads出来,不一定非要dumps的数据才能loads
　　#使用load进行反序列化 load只能读文件
　　

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

pickle 模块
　　#可以识别python所有的数据类型，但不能跨平台
　　#等号右边任何值都可以被pickle序列化，python中一切皆对象
　　#pickle序列化后的数据是bytes类型，因此写入读取文件时要以b模式打开
　　import pickle
　　#使用格式与josn相同
　　#序列化
　　

a={'name':'dzm','age':18,'sex':'male'}　　
res=pickle.dumps(a)
　　
print(res)
　　

　　#直接写入文件
　　pickle.dump(a,open('user.pkl','wb'))
　　#反序列化
　　pickle.loads(res)
　　#从文件读
　　

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

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

f=shelve.open('db.shl')　　
f['stu1']={'name':'dzm','age':18}
　　
f['stu2']={'name':'egon','age':28}
　　
f.close()
　　

　　#读
　　

f=shelve.open('db.shl')　　
print(f['stu1']['name'])
　　
f.close()
　　

xml模块
　　from xml.etree import ElementTree
　　tree=ElementTree.parse('a.xml') #得到根
　　#拿到一个元素Element
　　root=tree.getroot()

元素
　　#每一个元素都有三个需要掌握的点
　　

root.tag #标签的名字　　
root.attrib #标签的属性，就是名字后面的内容，如果有属性会把属性变成字典返回
　　
root.text #文本，一个标签内部，在子标签之外的独立文本才算
　　

三种查找方式
　　#从当前节点下面的子节点中找元素Element
　　

root.find() #只找第一个，有多个相同名称的标签也只找一个　　
root.findall() #全部相同名称的找出来
　　
#从整个树形结构中查找
　　
root.iter()
　　

　　#遍历文档数
　　

for country in root: #找根下面的子节点（元素）　　for item in country: #再找子节点下面的子节点（元素）
　　print(item.tag,item.attrib,item.text)
　　

　　#修改内容
　　#把year找到并修改，添加树形，修改文本
　　

for year in root.iter('year'):　　year.set('updated','yes') #往文件里写必须是字符串
　　year.text=str(int(year.text)+1) #在原有年份上加1，取出来的年份是字符串，没法做数学运算，转换+1后要再转换会字符串写入文件
　　

　　
tree.write('a.xml')
　　

　　#添加内容
　　#添加到名为rank的标签下面
　　

for rank in root.iter('rank'):　　if int(rank.text) == 5: #取出来的rank.text是字符串，所以转换成int再比较
　　obj=ElementTree.Element('dzm')
　　obj.attrib={'name':'dzm','age':'18'} #直接使用attrib添加要全部拼好
　　obj.text='dzm is good'
　　rank.append(obj)
　　

　　
tree.write('a.xml')
　　

configparser模块
　　

import configparser　　

　　
config=configparser.ConfigParser() #得到一个对象
　　
config.read('my.ini') #读取文件，这里使用mysql配置文件模拟
　　

查找
　　

print(config.sections()) #查看有哪些标签　　
['mysqld', 'client', 'egon']
　　

print(config.options('mysqld')) #查看标签下面的内容，返回的是k　　
['charater-server-set', 'default-engine', 'skip-grant-table', 'port', 'data_dir']
　　

print(config.get('mysqld','charater-server-set')) #查看标签下面配置项的值　　
utf8
　　

　　#注意，文件中有一行配置项的值是True，但通过get取出来的True只是一个字符串
　　

print(type(config.get('mysqld','skip-grant-table')))　　
<class 'str'>
　　

　　#使用getboolean可以直接转换成布尔值
　　print(config.getboolean('mysqld','skip-grant-table'))
　　#同理，使用getint可以直接获取int类型的值
　　print(config.getint('mysqld','port'))
　　#使用getfloat可以直接拿到浮点型
　　config.getfloat('mysqld','port')
　　#查看一个标签那面有没有这个配置项
　　

print(config.has_option('mysqld','aaa'))　　
False
　　

添加内容
　　

config.add_section('dzm')　　
config.set('dzm','name','18') #标签、配置项、值
　　
config.write(open('my.ini','w',encoding='utf-8'))
　　

修改内容
　　

config.set('client','password','870911')　　
config.write(open('my.ini','w',encoding='utf-8'))
　　

hashlib模块
　　#hash：一种算法 ,3.x里代替了md5模块和sha模块
　　import hashlib
　　

m=hashlib.md5()　　
m.update('hello'.encode('utf-8')) #添加校验文本内容
　　
m.update('world'.encode('utf-8')) #两行内容会自动变为一行
　　
print(m.hexdigest())  #得出哈希值
　　

　　#sha512 算法更复杂
　　

m=hashlib.sha512()　　
m.update('hello'.encode('utf-8'))
　　
print(m.hexdigest())
　　

hmac模块
　　#用法与hashlib相同，但强制密码加严
　　

import hmac　　
m=hmac.new('密码加严'.encode('utf-8'))
　　
m.update('hello'.encode('utf-8'))
　　
print(m.hexdigest())
　　

subprocess 模块
　　创建附加进程
　　import subprocess
　　import time
　　

subprocess.Popen('tasklist',shell=True)  #创建一个子进程执行，会直接执行下面的代码，不会管这条命令是否执行成功　　
time.sleep(1)  #上面的命令默认将结果打印到终端，但需要一定时间，如果这里不暂停1秒结束程序的话就看不到返回结果
　　

obj=subprocess.Popen('tasklist',shell=True,　　stdout=subprocess.PIPE, #创建一个管道，把正确的结果传进这个管道
　　stderr=subprocess.PIPE, #再创建一个管道，把执行错误的结果传进
　　)
　　

print(obj.stdout.read().decode('gbk')) #把stdout管道中的东西打出来　　
print(obj.stderr.read().decode('gbk')) #把stderr管道中的内容打印出来
　　

　　#注意，管道里是bytes类型，需要解码，在windows平台默认是按照gbk编码的，所以要以gbk解码

数据流交互
　　

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

　　结果：一个数据流可以和另外一个数据流交互,可以通过爬虫得到结果然后交给grep
　　python.exe                   12336 Console                    8     11,084 K

类的定义与使用

类的定义
　　

对象是特征与技能的结合体，类就是一系列对象相似的特征与技能的结合体　　
在现实世界中：一定是先有的一个个具体存在的对象，后总结出的类
　　
在程序中：一定保证先定义类，后产生对象
　　

　　站在老男孩学校的角度
　　

现实中的对象：　　对象1：
　　特征
　　学校=老男孩
　　名字=李三炮
　　性别=男
　　年龄=18
　　技能
　　学习
　　选课
　　

　　对象2：
　　特征
　　学校=老男孩
　　名字=张铁蛋
　　性别=女
　　年龄=38
　　技能
　　学习
　　选课
　　

　　对象3：
　　特征
　　学校=老男孩
　　名字=武大郎
　　性别=男
　　年龄=28
　　技能
　　学习
　　选课
　　

　　对象4：
　　特征
　　学校=老男孩
　　名字=egon
　　性别=男
　　年龄=18
　　技能
　　教学
　　

现实中的老男孩学生类：　　老男孩学生类
　　相似的特征
　　学校=老男孩
　　相似的技能
　　学习
　　选课
　　

类的使用
　　类体代码在类的定义阶段就会立刻执行，
　　

class Student:　　school='oldboy'
　　

　　def learn(self):
　　print('is learning')
　　

　　def choose_course(self):
　　print('choose course')
　　

　　#查看
　　

print(Student.school) #类的数据属性　　
print(Student.learn)  #类的函数属性
　　

　　#增加
　　

Student.name='dzm'　　
print(Student.name)
　　

　　#修改
　　

Student.school='Oldboy'　　
print(Student.school)
　　

　　#删除
　　

del Student.name　　
print(Student.name)
　　

print(Student.learn) #就是一个函数　　
Student.learn('xxxxx') #加括号打印，但要遵循类的规则，必须有传参
　　

对象的定义与使用
　　

class Student:　　school='oldboy'
　　

　　def __init__(self,name,age,sex): #在调用类时会自动触发执行
　　self.Name=name
　　self.Age=age
　　self.Sex=sex
　　

　　def learn(self):
　　print('is learning')
　　

　　def choose_course(self):
　　print('choose course')
　　

　　调用类的过程又称之为实例化，先定义类，在定义对象
　　1、得到一个返回值，即对象，该对象是一个空对象
　　2、Student.init(stu1,'dzm',18,'male)
　　对象定义过程中其本身会作为第一个值传给函数init，就是那个self
　　

stu1=Student('dzm',18,'male')　　
stu2=Student('egon',28,'male')
　　
stu3=Student('alex',38,'male')
　　

print(stu1.__dict__) #看看stu1的名称空间里都有什么　　
{'Name': 'dzm', 'Age': 18, 'Sex': 'male'}
　　

　　#修改
　　

stu1.Age=19　　
print(stu1.Age)
　　

　　#对象的增删改查方式与类的增删改查相同

对象的属性查找
　　

class Student:　　school='oldboy'
　　# Name='xxx'
　　

　　def __init__(self,name,sex,age): #在调用类时会自动触发执行
　　self.Name = name
　　self.Sex = sex
　　self.Age = age
　　

　　#stu1.Name='李三炮'
　　#stu1.Sex='男'
　　#stu1.Age=18
　　

　　def learn(self,x,y):
　　print('%s is learning' %self.Name)
　　print(x,y)
　　

　　def choose_course(self):
　　print('choose course')
　　

　　def commit_hw(): #类内定义的函数默认要有一个参数，约定俗成地写出self
　　print('commit homework')
　　

　　#1、查找一个对象的属性顺序是：先找对象自己的dict,再找类的dict
　　

stu1=Student('dzm','男',18)　　
print(stu1.school)
　　
oldboy
　　

　　
stu1=Student('李三炮','男',18)
　　
stu2=Student('张铁蛋','女',38)
　　
stu3=Student('武大郎','男',28)
　　

　　#2、类的数据属性是所有对象共享，所有对象都指向同一个内存地址
　　

Student.school='Oldgirl' #修改要从类入手　　
print(Student.school,id(Student.school))
　　
print(stu1.school,id(stu1.school))
　　
print(stu2.school,id(stu2.school))
　　
print(stu3.school,id(stu3.school))
　　

对象的绑定方法
　　#类是一系列对象相似的特征与技能的结合体
　　#抽象的理解上面掌握了特征，下面要掌握技能
　　#类中定义的函数是绑定给对象使用：
　　#1：不同对象就是不同绑定方法
　　#2：绑定给谁，就应该由谁来调用,谁来调用就会把谁当做第一个参数传给对应的函数
　　

print(Student.learn) #返回结果就是个函数　　
print(stu1.learn()) #绑定方法，会将对象自动传值给第一个位置参数
　　

stu1.learn()　　
stu2.learn()
　　
stu3.learn()
　　
调用结果：
　　
李三炮 is learning
　　
张铁蛋 is learning
　　
武大郎 is learning
　　

　　stu1.learn(1,2) #Student.learn(stu1,1,2)
　　#可以多传几个参数
　　stu1.commit_hw()
　　#这里调用就会出错，因为绑定到对象的方法有自动传值的特征，而上面类中相应函数没有定义位置参数，所以执行调用会报错