今日内容：
1.常用模块
2.面向对象编程（*****）
介绍面向对象编程
类
对象
3.内置函数
------------------------------
1.面向过程编程
核心“过程”二字，过程指的是解决问题的步骤，即先干什么再干什么后干什么
基于该思想编写程序就好比在设计一条流水线，是一种机械式的思维方式
优点：复杂的问题流程化，进而简单化
缺点：可扩展性差
2.面向对象编程
核心“对象”二字，对象是特征与技能的结合体
基于该思想编程就好比创造出一个世界（世界是由一个个的对象组成的），你就是上帝
任何存在的事物都是对象，任何不存在的事物也可以创造出来
是一种上帝式的思维方式
优点：可扩展性强
缺点：编程的复杂度高
3.类
如果说对象是特征与技能的结合体，类则是一系列对象相似的特征与技能的结合体
在现实现实中：一定先有一个个具体存在的对象，然后随着人类文明的发展由人类站在不同的角度总结出来的类
注意：1.类是抽象的概念，而对象才是具体存在的事物
2.站在不同的角度，可以总结出不同的类
在程序中：一定是要先定义类，后调用类来产生对象
---------------------------------
站在老男孩选课系统的角度，总结现实世界中的老男孩学生对象
对象1：
特征：
学校='oldboy'
姓名='alex'
年龄=18
性别='male'
技能：
选课
对象2：
特征：
学校='oldboy'
姓名='andy'
年龄=19
性别='female'
技能：
选课
对象3：
特征：
学校='oldboy'
姓名='andy'
年龄=19
性别='female'
技能：
选课
对象4（老师）：
特征：
学校='oldboy'
姓名='egon'
年龄=18
性别='male'
技能：
打分
站在老男孩选课系统的角度，总结现实世界中的老男孩学生类
老男孩的学生类：
相同的特征：
学校='oldboy'
相同的技能：
选课
站在程序的角度，一定先定义类，后调用类产生对象
#一.定义类
class OldboyStudent:
#相同的特征
school='oldboy'
#相同的技能
def choose_course(self):
print('is choosing course')
print('=========>')
#1.1 定义类会立刻触发类体代码的运行，会产生一个类的名称空间，将类体代码运行中产生名字的都丢到类的名称空间中
#ps:定义一个类本质就是创造了一个名称空间，用来存放名字的，即类相当于一个容器
print(OldboyStudent.__dict__)
print(OldboyStudent.__dict__['school'])
print(OldboyStudent.__dict__['choose_course'])
print(OldboyStudent.school)
print(OldboyStudent.choose_course('python')) #self位置参数必须传参数 OldboyStudent.school='OLDBOY'
print(OldboyStudent.__dict__)
OldboyStudent.country='China'
print(OldboyStudent.__dict__)
del OldboyStudent.country
print(OldboyStudent.__dict__)
输出：
=========>
{'__module__': '__main__', 'school': 'oldboy', 'choose_course': <function OldboyStudent.choose_course at 0x0000019295C7D2F0>, '__dict__': <attribute '__dict__' of 'OldboyStudent' objects>, '__weakref__': <attribute '__weakref__' of 'OldboyStudent' objects>, '__doc__': None}
oldboy
<function OldboyStudent.choose_course at 0x0000019295C7D2F0>
oldboy
is choosing course
None
{'__module__': '__main__', 'school': 'OLDBOY', 'choose_course': <function OldboyStudent.choose_course at 0x0000019295C7D2F0>, '__dict__': <attribute '__dict__' of 'OldboyStudent' objects>, '__weakref__': <attribute '__weakref__' of 'OldboyStudent' objects>, '__doc__': None}
{'__module__': '__main__', 'school': 'OLDBOY', 'choose_course': <function OldboyStudent.choose_course at 0x0000019295C7D2F0>, '__dict__': <attribute '__dict__' of 'OldboyStudent' objects>, '__weakref__': <attribute '__weakref__' of 'OldboyStudent' objects>, '__doc__': None, 'country': 'China'}
#二.调用类产生对象:调用类的过程称之为类的实例化，得到的结果是一个类的一个实例/对象
#调用类发生两件事：
#1.会先产生一个空对象
#2会触发类中__init__函数的运行,将空对象连同括号内的参数一同传入
class OldboyStudent:
#相同的特征
school='oldboy'
#相同的技能
def choose_course(self):
print('is choosing course')
print('=========>')
stu1=OldboyStudent()
stu2=OldboyStudent()
stu3=OldboyStudent()
print(id(stu1.school),id(stu2.school),id(stu2.school),id(OldboyStudent.school))
print(id(stu1.choose_course),id(stu2.choose_course),id(stu2.choose_course),id(OldboyStudent.choose_course)) stu1.name='alex'
stu1.age=18
stu1.sex='male' stu2.name='tom'
stu2.age=20
stu2.sex='male' stu3.name='sara'
stu3.age=30
stu3.sex='female' #为每一个对象初始化自己独有的特征
def init(obj,x,y,z):
obj.name=x
obj.age=y
obj.sex=z init(stu1,'alex',18,'male')
init(stu2,'tom',20,'male')
init(stu3,'sara',30,'female') print(stu1.name)
print(stu2.name)
print(stu3.name)
输出：
=========>
1729089044808 1729089044808 1729089044808 1729089044808
1729071298248 1729071298248 1729071298248 1729089690480
alex
tom
sara
# 类是个名称空间，是个容器，用于存对象
class OldboyStudent:
#相同的特征
school='oldboy'
# stu1,'alex',18,'male'
def __init__(obj,name,age,sex): #__init__可调用类的时候自动触发函数运行
obj.name=name
obj.age=age
obj.sex=sex
print(obj,name,age,sex)
#相同的技能
def choose_course(self):
print('is choosing course')
print('=========>')
stu1=OldboyStudent('alex',18,'male') #stu1会作为obj默认传进__init__,所以不用传
print(stu1.__dict__) # 对象也是个名称空间，也是个容器，用于存对象特有的信息
stu2=OldboyStudent('tom',20,'male')
print(stu2.__dict__) # 对象也是个名称空间，也是个容器，用于存对象特有的信息
stu3=OldboyStudent('sara',30,'female')
print(stu3.__dict__) # 对象也是个名称空间，也是个容器，用于存对象特有的信息
输出：
=========>
<__main__.OldboyStudent object at 0x0000019295CA4DA0> alex 18 male
{'name': 'alex', 'age': 18, 'sex': 'male'}
<__main__.OldboyStudent object at 0x0000019295C96BA8> tom 20 male
{'name': 'tom', 'age': 20, 'sex': 'male'}
<__main__.OldboyStudent object at 0x0000019295C819E8> sara 30 female
{'name': 'sara', 'age': 30, 'sex': 'female'}
#对象本质就是一个容器（名称空间）
#类的本质也是一个容器（名称空间）
# 类是个名称空间，是个容器，用于存对象
class OldboyStudent:
x=1
school='oldboy'
# stu1,'alex',18,'male'
def __init__(self,name,age,sex): #__init__可调用类的时候自动触发函数运行,self用于自动接收第一个参数
self.name=name
self.age=age
self.sex=sex
print(self,name,age,sex)
def choose_course(self):
print('is choosing course')
print('=========>')
stu1=OldboyStudent('alex',18,'male')
stu2=OldboyStudent('tom',20,'male')
stu3=OldboyStudent('sara',30,'female')
#属性查找的顺序：对象的名称空间-》类的名称空间
stu1.x=222
print(stu1.x)
print(id(OldboyStudent.school),OldboyStudent.school)
print(id(stu1.school),stu1.school)
print(id(stu2.school),stu2.school)
print(id(stu3.school),stu3.school)
print('----------------------------------')
#类中定义的变量是类的数据属性，类的数据属性是共享给所有对象用
OldboyStudent.school='OLDBOY'
print(id(OldboyStudent.school),OldboyStudent.school)
print(id(stu1.school),stu1.school)
print(id(stu2.school),stu2.school)
print(id(stu3.school),stu3.school)
print('----------------------------------')
stu1.school='xxx'
print(id(OldboyStudent.school),OldboyStudent.school)
print(id(stu1.school),stu1.school)
print(id(stu2.school),stu2.school)
print(id(stu3.school),stu3.school)
#
输出：
=========>
<__main__.OldboyStudent object at 0x0000019295C81128> alex 18 male
<__main__.OldboyStudent object at 0x0000019295C812E8> tom 20 male
<__main__.OldboyStudent object at 0x0000019295C96EB8> sara 30 female
222
1729039486288 oldboy
1729039486288 oldboy
1729039486288 oldboy
1729039486288 oldboy
----------------------------------
1729089727600 OLDBOY
1729089727600 OLDBOY
1729089727600 OLDBOY
1729089727600 OLDBOY
----------------------------------
1729089727600 OLDBOY
1729043552328 xxx
1729089727600 OLDBOY
1729089727600 OLDBOY
#对象本质就是一个容器（名称空间）
#类的本质也是一个容器（名称空间）
# 类是个名称空间，是个容器，用于存对象
class OldboyStudent:
x=1
school='oldboy'
# stu1,'alex',18,'male'
def __init__(self,name,age,sex): #__init__可调用类的时候自动触发函数运行,self用于自动接收第一个参数
self.name=name
self.age=age
self.sex=sex
print(self,name,age,sex)
def choose_course(self):
print('%s is choosing course' %self.name)
print('=========>')
stu1=OldboyStudent('alex',18,'male')
stu2=OldboyStudent('tom',20,'male')
stu3=OldboyStudent('sara',30,'female')
#类定义的函数是类的函数属性，类可以使用，但类来用就是一个普通函数，必须遵循函数的规则
#但是，类中定义的函数其实是给对象用的，而非是绑定给对象用，称之为绑定方法
#绑定方法的特殊之处：
#绑定给谁就应该由谁类调用，谁来调用就会将谁当作第一个参数自动传入
print(OldboyStudent.choose_course)
#OldboyStudent.choose_course(123)
print(stu1.choose_course,id(stu1.choose_course))
print(stu2.choose_course,id(stu2.choose_course))
print(stu3.choose_course,id(stu3.choose_course))
print(OldboyStudent.choose_course,id(OldboyStudent.choose_course))
print('----------------------------------')
stu1.choose_course()
stu2.choose_course()
stu3.choose_course()
print(stu1,stu2,stu3)
输出：
=========>
<__main__.OldboyStudent object at 0x0000019295CA7E48> alex 18 male
<__main__.OldboyStudent object at 0x0000019295CA7E80> tom 20 male
<__main__.OldboyStudent object at 0x0000019295C81E80> sara 30 female
<function OldboyStudent.choose_course at 0x0000019295C6D8C8>
<bound method OldboyStudent.choose_course of <__main__.OldboyStudent object at 0x0000019295CA7E48>> 1729071613832
<bound method OldboyStudent.choose_course of <__main__.OldboyStudent object at 0x0000019295CA7E80>> 1729071613832
<bound method OldboyStudent.choose_course of <__main__.OldboyStudent object at 0x0000019295C81E80>> 1729071613832
<function OldboyStudent.choose_course at 0x0000019295C6D8C8> 1729089689800
----------------------------------
alex is choosing course
tom is choosing course
sara is choosing course
<__main__.OldboyStudent object at 0x0000019295CA7E48> <__main__.OldboyStudent object at 0x0000019295CA7E80> <__main__.OldboyStudent object at 0x0000019295C81E80>
#在python3中统一了类与类型的概念
class Foo:
pass
print(Foo)
print(list) obj=Foo()
print(obj,type(obj)) l1=[1,2,3] # 原理l=list([1,2,3]) l是对象，list是类
print(l.append) #原理l1.append(self,x), 绑定方法会自动传值，self=l1
l1.append(4) #对象调绑定方法，简便快捷
list.append(l1,5) #用类来调函数，使用麻烦，不够简便
print(l1) l2=['a','b','c']
l2.append('d') #原理l2.append(self,x), 绑定方法会自动传值，self=l2，#对象调绑定方法，简便快捷
list.append(l2,'e') #用类来调函数，使用麻烦，不够简便
print(l2)
输出：
<class '__main__.Foo'>
<class 'list'>
<__main__.Foo object at 0x0000019295C6C908> <class '__main__.Foo'>
<built-in method append of list object at 0x0000019295C7C548>
[1, 2, 3, 4, 5]
['a', 'b', 'c', 'd', 'e']
#演变过程
#1、在没有学习类这个概念时，数据与功能是分离的
def exc1(host,port,db,charset):
conn=connect(host,port,db,charset)
conn.execute(sql)
return xxx def exc2(host,port,db,charset,proc_name)
conn=connect(host,port,db,charset)
conn.call_proc(sql)
return xxx #每次调用都需要重复传入一堆参数
exc1('127.0.0.1',3306,'db1','utf8','select * from tb1;')
exc2('127.0.0.1',3306,'db1','utf8','存储过程的名字')
#2、我们能想到的解决方法是，把这些变量都定义成全局变量
HOST=‘127.0.0.1’
PORT=3306
DB=‘db1’
CHARSET=‘utf8’ def exc1(host,port,db,charset):
conn=connect(host,port,db,charset)
conn.execute(sql)
return xxx def exc2(host,port,db,charset,proc_name)
conn=connect(host,port,db,charset)
conn.call_proc(sql)
return xxx exc1(HOST,PORT,DB,CHARSET,'select * from tb1;')
exc2(HOST,PORT,DB,CHARSET,'存储过程的名字')
#3、但是2的解决方法也是有问题的，按照2的思路，我们将会定义一大堆全局变量，这些全局变量并没有做任何区分，即能够被所有功能使用，然而事实上只有HOST，PORT，DB，CHARSET是给exc1和exc2这两个功能用的。言外之意：我们必须找出一种能够将数据与操作数据的方法组合到一起的解决方法，这就是我们说的类了 class MySQLHandler:
def __init__(self,host,port,db,charset='utf8'):
self.host=host
self.port=port
self.db=db
self.charset=charset
def exc1(self,sql):
conn=connect(self.host,self.port,self.db,self.charset)
res=conn.execute(sql)
return res def exc2(self,sql):
conn=connect(self.host,self.port,self.db,self.charset)
res=conn.call_proc(sql)
return res
obj=MySQLHandler('127.0.0.1',3306,'db1')
obj.exc1('select * from tb1;')
obj.exc2('存储过程的名字')
#改进
class MySQLHandler:
def __init__(self,host,port,db,charset='utf8'):
self.host=host
self.port=port
self.db=db
self.charset=charset
self.conn=connect(self.host,self.port,self.db,self.charset)
def exc1(self,sql):
return self.conn.execute(sql) def exc2(self,sql):
return self.conn.call_proc(sql) obj=MySQLHandler('127.0.0.1',3306,'db1')
obj.exc1('select * from tb1;')
obj.exc2('存储过程的名字') 数据与专门操作该数据的功能组合到一起
常用模块：
序列
1.什么是序列化
序列化：就是将内存中的数据类型转换成一种中间格式，然后存放到文件中或者基于网络发送
反序列化：将文件中或者基于网络发送过来的数据转成应用程序中的数据类型
2.为何要序列化
1.数据类型的持久化
json:
优点：所有编程语言都可以识别的中间格式
缺点：无法
2.数据跨平台交付
#模拟序列化和反序列化
info={
'name':'andy',
'age':18,
'sex"':'male'
} with open('a.txt','wt',encoding='utf-8') as f:
f.write(str(info)) #序列化 with open('a.txt', 'rt', encoding='utf-8') as f:
data=f.read()
dic=eval(data) #反序列化
print(dic['name'])
输出：
andy
# 1. 序列化json.dumps-----反序列化json.loads
import json
info={
'name':'egon',
'age':18,
'sex':None,
'is_beautifull':True,
} info_json=json.dumps(info)
# print(info_json,type(info_json))
with open('b.json','wt',encoding='utf-8') as f:
f.write(info_json)
#d=json.dumps({1,2,3})
#print(d)
# 2. 序列化json.dump-----反序列化json.load
import json
with open('b.json',mode='rt',encoding='utf-8') as f:
dic=json.load(f)
print(dic,dic['name'])
输出：
{'name': 'egon', 'age': 18, 'sex': None, 'is_beautifull': True} egon
# 1. 序列化pkl.dumps-----反序列化pkl.loads
import pickle
info={
'name':'egon',
'age':18,
'sex':None,
'is_beautifull':True,
}
with open('e.pkl','wb') as f:
pickle.dump(info,f)
pickle.dumps({1,2,3,4})
输出：
b'\x80\x03cbuiltins\nset\nq\x00]q\x01(K\x01K\x02K\x03K\x04e\x85q\x02Rq\x03.'
# 2. 序列化pkl.dumps-----反序列化pkl.loads
import json
with open('e.pkl','rb') as f:
dic=pickle.load(f)
print(dic,dic['age'])
输出：
{'name': 'egon', 'age': 18, 'sex': None, 'is_beautifull': True} 18
哈希库
hashlib模块
1. 什么是hash
hash是一种算法，该算法就相当于一个工厂，我们给工厂运算的原材料是一串字符或bytes
工厂加工的结果是一个hash值，hash值有三大特性：
1.只要传入的字符或bytes相同，得到的hash值必然相同
2.只要使用的hash算法是固定的，那得到的hash值的长度固定，即hash值不会随着校验内容的增多而变长
3.无法通过hash值逆推出校验的内容，
2.为何用hash
特点：1+2可以用来做文件完整性校验
3可以对密码进行加密
2.如何用
import hashlib
m=hashlib.md5()
m.update('hello'.encode('utf-8'))
m.update('world'.encode('utf-8'))
print(m.hexdigest()) #fc5e038d38a57032085441e7fe7010b0
输出：
fc5e038d38a57032085441e7fe7010b0
import hashlib
m1=hashlib.md5()
m1.update('helloworld'.encode('utf-8'))
print(m1.hexdigest()) #fc5e038d38a57032085441e7fe7010b0
输出：
fc5e038d38a57032085441e7fe7010b0
import hashlib
m2=hashlib.md5('andy'.encode('utf-8'))
m2.update('hello'.encode('utf-8'))
m2.update('world'.encode('utf-8'))
print(m2.hexdigest()) #4da782696c78031a0824ec1d773aebd1
输出：
4da782696c78031a0824ec1d773aebd1
import hashlib
m3=hashlib.sha512('andy'.encode('utf-8'))
m3.update('hello'.encode('utf-8'))
m3.update('world'.encode('utf-8'))
print(m3.hexdigest()) #e94ef8bb8db9100c609e370aeea2d53b7314c285be85b1e543cfd1013adcff68ba0c42aff341b028c9eaca4966ee383b6c9a517d1fab43f442ba38c17daa2441
输出：
e94ef8bb8db9100c609e370aeea2d53b7314c285be85b1e543cfd1013adcff68ba0c42aff341b028c9eaca4966ee383b6c9a517d1fab43f442ba38c17daa2441
import hashlib
pwd='andy123'
m4=hashlib.md5()
m4.update('天王盖地虎'.encode('utf-8'))
m4.update(pwd.encode('utf-8'))
print(m4.hexdigest()) #522ee028a8accc43ed18b7bc35f90e7d
输出：
522ee028a8accc43ed18b7bc35f90e7d
#time模块
import time
#1.时间戳
print(time.time())
#2.格式化的字符串
print(time.strftime('%Y-%m-%d %H:%M:%S %p'))
print(time.strftime('%Y-%m-%d %X'))
#3.时间对象
print (time.localtime())
print (time.gmtime())
obj=time.localtime()
print(obj.tm_year,obj.tm_hour)
输出：
1533458800.0145576
2018-08-05 16:46:40 PM
2018-08-05 16:46:40
time.struct_time(tm_year=2018, tm_mon=8, tm_mday=5, tm_hour=16, tm_min=46, tm_sec=40, tm_wday=6, tm_yday=217, tm_isdst=0)
time.struct_time(tm_year=2018, tm_mon=8, tm_mday=5, tm_hour=8, tm_min=46, tm_sec=40, tm_wday=6, tm_yday=217, tm_isdst=0)
2018 16
#时间转换
#timestamp<----->struct_time
struct_time=time.localtime(3131313)
timestamp=time.mktime(struct_time)
print(timestamp)
#struct_time<----->timestamp
struct_time=time.strptime('2018:03-01','%Y:%m-%d')
print(struct_time)
print(time.strftime('%Y-%m-%d',struct_time)) print(time.ctime())
print(time.asctime())
输出：
3131313.0
time.struct_time(tm_year=2018, tm_mon=3, tm_mday=1, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=3, tm_yday=60, tm_isdst=-1)
2018-03-01
Sun Aug 5 16:56:17 2018
Sun Aug 5 16:56:17 2018
import datetime
print(datetime.datetime.now())
print(datetime.datetime.fromtimestamp(1341313))
print(datetime.datetime.now()+datetime.timedelta(days=3))
print(datetime.datetime.now()+datetime.timedelta(days=-3))
obj=datetime.datetime.now()
print(obj.replace(year=2017,month=3))
输出：
2018-08-05 17:11:32.951347
1970-01-16 20:35:13
2018-08-08 17:11:32.951347
2018-08-02 17:11:32.951347
2017-03-05 17:11:32.951347
import random print(random.random())#(0,1)----float 大于0且小于1之间的小数
print(random.randint(1,3)) #[1,3] 大于等于1且小于等于3之间的整数
print(random.randrange(1,3)) #[1,3) 大于等于1且小于3之间的整数
print(random.choice([1,'',[4,5]]))#1或者23或者[4,5]
print(random.sample([1,'',[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)
输出：
0.48886600231751887
1
1
1
[1, '23']
1.5537879144360303
[9, 7, 5, 1, 3]
#生成8位随机验证码
import random
def make_code(n):
res=''
for i in range(n):
s1=chr(random.randint(65,90))
s2=str(random.randint(0,9))
res+=random.choice([s1,s2])
return res print(make_code(9))
输出：
C34T2CU61
#os模块
#os模块
os.getcwd() #获取当前工作目录，即当前脚本工作的目录路径
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下为"\t\n",Linux下为"\n"
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的大小
输出：
'C:\\Users\\andy'
#subprocess模块
import subprocess,time
obj=subprocess.Popen(
'tasklist',
shell=True,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE
)
print(obj.stdout.read())
print(obj.stderr.read().decode('gbk'))
输出：
b'\r\n\xd3\xb3\xcf\xf1\xc3\xfb\xb3\xc6 PID \xbb\xe1\xbb\xb0\xc3\xfb \xbb\xe1\xbb\xb0# \xc4\xda\xb4\xe6\xca\xb9\xd3\xc3 \r\n========================= ======== ================ =========== ============\r\nSystem Idle Process 0 Services 0 8 K\r\nSystem 4 Services 0 220 K\r\nRegistry 96 Services 0 8,820 K\r\nsmss.exe 428 Services 0 348 K\r\ncsrss.exe 604 Services 0 1,028 K\r\nwininit.exe 708 Services 0 804 K\r\ncsrss.exe 716 Console 1 1,696 K\r\nservices.exe 780 Services 0 3,584 K\r\nlsass.exe 788 Services 0 8,848 K\r\nsvchost.exe 900 Services 0 328 K\r\nfontdrvhost.exe 924 Services 0 480 K\r\nsvchost.exe 940 Services 0 18,924 K\r\nsvchost.exe 1008 Services 0 13,188 K\r\nsvchost.exe 364 Services 0 1,944 K\r\nwinlogon.exe 520 Console 1 1,308 K\r\nfontdrvhost.exe 700 Console 1 1,820 K\r\ndwm.exe 1092 Console 1 36,572 K\r\nsvchost.exe 1184 Services 0 2,184 K\r\nsvchost.exe 1192 Services 0 424 K\r\nsvchost.exe 1280 Services 0 3,848 K\r\nsvchost.exe 1288 Services 0 520 K\r\nsvchost.exe 1312 Services 0 5,440 K\r\nsvchost.exe 1420 Services 0 608 K\r\nsvchost.exe 1552 Services 0 5,016 K\r\nsvchost.exe 1592 Services 0 3,152 K\r\nsvchost.exe 1712 Services 0 5,068 K\r\nsvchost.exe 1728 Services 0 2,192 K\r\nsvchost.exe 1788 Services 0 3,004 K\r\nsvchost.exe 1820 Services 0 1,140 K\r\nNVDisplay.Container.exe 1912 Services 0 1,292 K\r\nsvchost.exe 1920 Services 0 532 K\r\nsvchost.exe 1932 Services 0 1,456 K\r\nsvchost.exe 2032 Services 0 3,928 K\r\nsvchost.exe 720 Services 0 808 K\r\nsvchost.exe 1088 Services 0 396 K\r\nMemory Compression 2124 Services 0 454,544 K\r\ndasHost.exe 2160 Services 0 4,284 K\r\nNVDisplay.Container.exe 2216 Console 1 2,904 K\r\nsvchost.exe 2228 Services 0 592 K\r\nsvchost.exe 2248 Services 0 1,228 K\r\nsvchost.exe 2272 Services 0 428 K\r\nigfxCUIService.exe 2352 Services 0 896 K\r\nsvchost.exe 2420 Services 0 452 K\r\nsvchost.exe 2432 Services 0 1,768 K\r\nsvchost.exe 2440 Services 0 3,700 K\r\nsvchost.exe 2584 Services 0 508 K\r\nsvchost.exe 2612 Services 0 10,016 K\r\nsvchost.exe 2704 Services 0 3,420 K\r\nsvchost.exe 2720 Services 0 4,044 K\r\nRtkAudioService64.exe 2812 Services 0 984 K\r\nsvchost.exe 2924 Services 0 6,656 K\r\nsvchost.exe 2940 Services 0 2,364 K\r\nsvchost.exe 2948 Services 0 3,316 K\r\nsvchost.exe 2956 Services 0 1,312 K\r\nZhuDongFangYu.exe 2972 Services 0 2,264 K\r\nsvchost.exe 3024 Services 0 1,112 K\r\nsvchost.exe 3088 Services 0 2,960 K\r\nRAVBg64.exe 3284 Console 1 1,212 K\r\nsvchost.exe 3408 Services 0 1,224 K\r\nsvchost.exe 3608 Services 0 868 K\r\nspoolsv.exe 3692 Services 0 3,376 K\r\nsvchost.exe 3808 Services 0 1,084 K\r\naudiodg.exe 3960 Services 0 10,060 K\r\narmsvc.exe 3116 Services 0 1,268 K\r\nsvchost.exe 3176 Services 0 3,272 K\r\nsvchost.exe 3592 Services 0 17,112 K\r\nMiService.exe 3048 Services 0 16,096 K\r\nGfExperienceService.exe 3804 Services 0 1,220 K\r\ncheckrs.exe 3788 Services 0 852 K\r\nHuaweiHiSuiteService64.ex 4040 Services 0 1,316 K\r\nsvchost.exe 4048 Services 0 13,624 K\r\nEvtEng.exe 4056 Services 0 1,428 K\r\nNvNetworkService.exe 4100 Services 0 1,256 K\r\nsvchost.exe 4108 Services 0 1,292 K\r\nsvchost.exe 4116 Services 0 1,020 K\r\nibtsiva.exe 4124 Services 0 688 K\r\nsvchost.exe 4132 Services 0 372 K\r\nrscheck.exe 4140 Services 0 868 K\r\nQQProtect.exe 4152 Services 0 1,988 K\r\nsvchost.exe 4160 Services 0 448 K\r\nDolbyDAX2API.exe 4168 Services 0 2,300 K\r\nsvchost.exe 4188 Services 0 1,656 K\r\nRegSrvc.exe 4208 Services 0 1,108 K\r\nSecurityHealthService.exe 4280 Services 0 2,288 K\r\nUpdateService.exe 4332 Services 0 1,456 K\r\nSynTPEnhService.exe 4356 Services 0 604 K\r\nsvchost.exe 4376 Services 0 324 K\r\nUpdateService.exe 4392 Services 0 1,540 K\r\nvmware-authd.exe 4408 Services 0 4,024 K\r\nvmnetdhcp.exe 4428 Services 0 912 K\r\nvmware-usbarbitrator64.ex 4452 Services 0 1,256 K\r\nvmnat.exe 4460 Services 0 1,308 K\r\nsvchost.exe 4472 Services 0 3,164 K\r\nsvchost.exe 4480 Services 0 4,788 K\r\nZeroConfigService.exe 4500 Services 0 1,632 K\r\nsvchost.exe 4792 Services 0 1,420 K\r\nsvchost.exe 4800 Services 0 332 K\r\nvmware-hostd.exe 6044 Services 0 3,888 K\r\nunsecapp.exe 3832 Services 0 1,812 K\r\nWmiPrvSE.exe 6160 Services 0 1,576 K\r\nSynTPEnh.exe 6548 Console 1 6,036 K\r\nsihost.exe 6800 Console 1 17,940 K\r\nsvchost.exe 4064 Console 1 840 K\r\nsvchost.exe 6888 Console 1 13,192 K\r\ntaskhostw.exe 1328 Console 1 5,232 K\r\nsvchost.exe 5068 Services 0 1,048 K\r\nsvchost.exe 800 Services 0 896 K\r\nctfmon.exe 916 Console 1 11,684 K\r\nigfxEM.exe 2748 Console 1 1,608 K\r\nigfxHK.exe 2732 Console 1 1,120 K\r\nigfxTray.exe 2828 Console 1 1,532 K\r\nexplorer.exe 4224 Console 1 65,608 K\r\nSynTPHelper.exe 4388 Console 1 728 K\r\nsvchost.exe 4920 Services 0 1,652 K\r\nChsIME.exe 2256 Console 1 12,408 K\r\nsvchost.exe 7000 Services 0 5,732 K\r\ndllhost.exe 5652 Console 1 3,944 K\r\nsvchost.exe 5620 Services 0 2,996 K\r\nSearchUI.exe 7296 Console 1 16 K\r\nRuntimeBroker.exe 7396 Console 1 5,636 K\r\nRuntimeBroker.exe 7624 Console 1 3,832 K\r\nsmartscreen.exe 7860 Console 1 2,204 K\r\nsvchost.exe 7876 Services 0 3,696 K\r\nSearchIndexer.exe 7960 Services 0 32,876 K\r\nSkypeHost.exe 8148 Console 1 16 K\r\nWindowsInternal.Composabl 8376 Console 1 5,172 K\r\n360wpsrv.exe 8484 Console 1 8,540 K\r\nOfficeHubTaskHost.exe 8672 Console 1 16 K\r\nRuntimeBroker.exe 8920 Console 1 3,372 K\r\nREDAgent.exe 9808 Console 1 14,376 K\r\nePointer.exe 9924 Console 1 1,852 K\r\nnvtray.exe 9976 Console 1 1,648 K\r\nNvBackend.exe 10004 Console 1 6,660 K\r\nMSASCuiL.exe 9460 Console 1 1,308 K\r\nMiOSDApp.exe 10292 Console 1 1,408 K\r\nunsecapp.exe 10420 Console 1 1,956 K\r\nsvchost.exe 10476 Console 1 2,740 K\r\nMiTongBu.exe 10548 Console 1 9,548 K\r\nRuntimeBroker.exe 10712 Console 1 1,548 K\r\nguardhp.exe 10936 Console 1 1,988 K\r\nCastSrv.exe 11164 Console 1 1,824 K\r\nRtkNGUI64.exe 10868 Console 1 1,692 K\r\nRAVBg64.exe 10852 Console 1 1,564 K\r\nDolbyDAX2TrayIcon.exe 8008 Console 1 1,040 K\r\nOneDrive.exe 11444 Console 1 5,204 K\r\nRuntimeBroker.exe 11788 Console 1 2,164 K\r\nsvchost.exe 11888 Services 0 9,088 K\r\nbaidunetdisk.exe 11988 Console 1 61,240 K\r\nMobileDeviceSrv.exe 12228 Console 1 1,436 K\r\nbaidunetdiskhost.exe 7572 Console 1 1,460 K\r\nSgrmBroker.exe 7672 Services 0 8,788 K\r\nsvchost.exe 10692 Services 0 2,184 K\r\nyundetectservice.exe 9296 Console 1 1,680 K\r\nQQLive.exe 12424 Console 1 12,340 K\r\nRAVBg64.exe 12564 Console 1 1,052 K\r\nSogouSoftware.exe 12924 Console 1 23,100 K\r\nMiniThunderPlatform.exe 13244 Console 1 4,420 K\r\nvmware-tray.exe 12696 Console 1 1,472 K\r\nconcentr.exe 12764 Console 1 3,000 K\r\nReceiver.exe 12820 Console 1 3,916 K\r\n360tray.exe 9044 Console 1 44,060 K\r\nwfcrun32.exe 13216 Console 1 4,024 K\r\nCefSharp.BrowserSubproces 13036 Console 1 2,988 K\r\nSoftMgrLite.exe 14048 Console 1 7,924 K\r\nNavPlugin.exe 9300 Console 1 4,620 K\r\nLDSGameCenter.exe 14036 Console 1 140,168 K\r\nLdsLite.exe 14016 Console 1 8,220 K\r\nComputerZService.exe 10428 Console 1 3,196 K\r\nQQLiveService.exe 10012 Console 1 5,844 K\r\nsvchost.exe 9068 Services 0 336 K\r\nChsIME.exe 8808 Console 1 424 K\r\nPopWndLog.exe 10080 Console 1 572 K\r\nApplicationFrameHost.exe 9220 Console 1 868 K\r\nsvchost.exe 7488 Services 0 468 K\r\nrundll32.exe 10704 Console 1 268 K\r\nQQLive.exe 2300 Console 1 3,032 K\r\nMicrosoftEdge.exe 7580 Console
#subprocess模块
import subprocess,time
obj=subprocess.Popen(
'tasklistaaa',
shell=True,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE
)
print(obj.stdout.read())
print(obj.stderr.read().decode('gbk'))
输出：
b''
'tasklistaaa' 不是内部或外部命令，也不是可运行的程序
或批处理文件。
sys模块
1 sys.argv 命令行参数List，第一个元素是程序本身路径
2 sys.exit(n) 退出程序，正常退出时exit(0)
3 sys.version 获取Python解释程序的版本信息
4 sys.maxint 最大的Int值
5 sys.path 返回模块的搜索路径，初始化时使用PYTHONPATH环境变量的值
6 sys.platform 返回操作系统平台名称
#=========知识储备==========
#进度条的效果
[# ]
[## ]
[### ]
[#### ] #指定宽度
print('[%-15s]' %'#')
print('[%-15s]' %'##')
print('[%-15s]' %'###')
print('[%-15s]' %'####') #打印%
print('%s%%' %(100)) #第二个%号代表取消第一个%的特殊意义 #可传参来控制宽度
print('[%%-%ds]' %50) #[%-50s]
print(('[%%-%ds]' %50) %'#')
print(('[%%-%ds]' %50) %'##')
print(('[%%-%ds]' %50) %'###') #=========实现打印进度条函数==========
import sys
import time def progress(percent,width=50):
if percent >= 1:
percent=1
show_str=('[%%-%ds]' %width) %(int(width*percent)*'#')
print('\r%s %d%%' %(show_str,int(100*percent)),file=sys.stdout,flush=True,end='') #=========应用==========
data_size=1025
recv_size=0
while recv_size < data_size:
time.sleep(0.1) #模拟数据的传输延迟
recv_size+=1024 #每次收1024 percent=recv_size/data_size #接收的比例
progress(percent,width=70) #进度条的宽度70 #打印进度条
shutil模块
高级的 文件、文件夹、压缩包 处理模块
shutil.copyfileobj(fsrc, fdst[, length])
将文件内容拷贝到另一个文件中
1 import shutil
2 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 shutil.copy('f1.log', 'f2.log') shutil.copy2(src, dst)
拷贝文件和状态信息
1 import shutil
2 shutil.copy2('f1.log', 'f2.log') shutil.ignore_patterns(*patterns)
shutil.copytree(src, dst, symlinks=False, ignore=None)
递归的去拷贝文件夹
#shutil 对压缩包的处理是调用 ZipFile 和 TarFile 两个模块来进行的，详细：
import zipfile # 压缩
z = zipfile.ZipFile('laxi.zip', 'w')
z.write('a.log')
z.write('data.data')
z.close() # 解压
z = zipfile.ZipFile('laxi.zip', 'r')
z.extractall(path='.')
z.close() zipfile压缩解压缩
import tarfile # 压缩
>>> t=tarfile.open('/tmp/egon.tar','w')
>>> t.add('/test1/a.py',arcname='a.bak')
>>> t.add('/test1/b.py',arcname='b.bak')
>>> t.close() # 解压
>>> t=tarfile.open('/tmp/egon.tar','r')
>>> t.extractall('/egon')
>>> t.close() tarfile压缩解压缩