今日内容：
面向对象编程
介绍面向对象编程
类
对象
内置函数
1. 面向过程编程
核心‘过程’二字，过程是解决问题的步骤，即先干什么，再干什么，后干什么
基于该思想的编程程序好比一条流水线，是一种机械思维
优点：复杂问题流程化，简单化
缺点：扩张性差
2. 面向对象编程
核心‘对象’二字，对象是特征和技能的结合体
基于该思想编写程序好比在创造一个个世界（世界是由一个个对象组成），你就是上帝，对于上帝来说，任何存在的事务都是对象，任何不存在的事物也可以创造出来
优点：可扩展性强
缺点：编程的复杂度高
3. 类
如果说对象是特征和技能的结合体，类则是一系列对象相识的特征和技能的结合体
在现实生活中：一定先有一个个具体存在的对象，然后随着人类文明的发展总结出来类
注意：
1. 类是抽象的概念，而对象才是具体存在的事物
2. 站在不同的角度，可以总结不同的类
在程序中：一定是先定义类，然后调用类来产生对象
站在老男孩选课系统的角度，总结现实生活中的老男孩学生的对象
对象1：
特征：
学校=‘oldboy’
姓名=‘李钢弹’
年龄=18
性别=‘male’
技能：
选课
对象2：
特征：
学校=‘oldboy’
姓名=‘张铁蛋’
年龄=19
性别=‘female’
技能：
选课
对象3：
特征：
学校=‘oldboy’
姓名=‘赵铜蛋’
年龄=73
性别=‘male’
技能：
选课
对象4：
特征：
学校=‘oldboy’
姓名=‘egon’
年龄=18
性别=‘male’
技能：
打分
站在老男孩选课系统的角度，总结现实世界的老男孩学生类
老男孩的学生类：
相同的类：
学校=‘oldboy’
相同的技能：
选课
站在程序的角度，先定义类，再调用类产生对象
class OldboyStudent:
school='oldboy'
def choose_course(self):
print('is choosing course')
# 1.1定义类时就会立即触发类体代码执行，产生一个类的名称空间,将类体代码运行过程中的名字都丢到类的名称空间中
# 定义一个类的本质就是创造一个名称空间，用来存放名字的，即类就相当于一个容器
# print(OldboyStudent.__dict__)
# print(OldboyStudent.__dict__['school'])
# print(OldboyStudent.__dict__['choose_course'])
# print(OldboyStudent.school) #print(OldboyStudent.__dict__['school'])
# print(OldboyStudent.choose_course) # #print(OldboyStudent.__dict__['choose_course'])
# OldboyStudent.choose_course(123)
# print(OldboyStudent.school)
# OldboyStudent.school='OLDBOY'
# print(OldboyStudent.school)
# OldboyStudent.country='China'
# print(OldboyStudent.__dict__)
# del OldboyStudent.country
# print(OldboyStudent.__dict__)
# 二、调用类产生对象
# 一定义类
# class OldboyStudent:
# #相同的特征
# school='oldboy'
# #相同的技能
# def choose_course(self):
# print('is choosing course')
#二调用类产生对象：调用类的过程称之为类的实例化，得到的一个结果是一个实例/对象
#调用类产生2件事：
# 1、会产生一个空对象
# 2、会触发类中__init__函数的运行，将空对象和括号内的参数一同传入
# stu1=OldboyStudent()
# stu2=OldboyStudent()
# stu3=OldboyStudent()
# print(stu1)
# print(stu2)
# print(stu3)
# print(id(stu1.school),id(stu2.school),id(stu3.school))
# print(id(stu1.choose_course),id(stu2.choose_course),id(stu3.choose_course))
# stu1.name='李钢蛋'
# stu1.age=18
# stu1.sex='male'
#
# stu2.name='张铁蛋'
# stu2.age=19
# stu2.sex='female'
#
# stu3.name='赵铜蛋'
# stu3.age=73
# stu3.sex='male'
#为每一个对象初始化自己独有的特征
# def init(obj,x,y,z):
# obj.name=x
# obj.age=y
# obj.sex=z
# init(stu1,'李钢蛋',18,'male')
# init(stu2,'张铁蛋',19,'female')
# init(stu3,'赵铜蛋',73,'male')
#
# print(stu1.name)
# print(stu2.name)
# print(stu3.name)
# ------------------------------------------------------------------------------------------
# 一定义类
class OldboyStudent:
#相同的特征
school='oldboy'
def __init__(self,name,age,sex):
self.name=name #stu1.name='李钢蛋'
self.age=age #stu1.age=18
self.sex=sex #stu1.sex='male'
#相同的技能
def choose_course(self):
print('is choosing course')
stu1=OldboyStudent('李钢蛋',18,'male')
stu2=OldboyStudent('张铁蛋',19,'female')
stu3=OldboyStudent('赵铜蛋',73,'male')
print(stu1.__dict__)
print(stu2.__dict__)
print(stu3.__dict__)
print(OldboyStudent.__init__)
属性查找
class OldboyStudent:
# x=123
school='oldboy'
def __init__(self,name,age,sex):
self.name=name
self.age=age
self.sex=sex
def choose_course(self):
print('% is choosing course' %self.name)
stu1=OldboyStudent('李钢弹',18,'male')
stu2=OldboyStudent('张铁弹',19,'female')
stu3=OldboyStudent('赵铜弹',73,'male')
#对象本质就是一个容器（名称空间）
#类的本质也是一个容器（名称空间）
# stu1.x=222
# print(stu1.__dict__)
#属性查找顺序：对象的名称空间---》类的名称空间
# print(stu1.name)
# print(stu1.x)
#类中定义的变量是类的数据属性，类的数据属性是共享给所有对象用，大家的内存地址都是一样
# print(id(OldboyStudent.school))
# print(id(stu1.school))
# print(id(stu2.school))
# print(id(stu3.school))
# OldboyStudent.school='OLDBOY'
# print(stu1.school)
# print(stu2.school)
# print(stu3.school)
# stu1.school='xxx'
# print(OldboyStudent.school)
# print(stu2.school)
# print(stu3.school)
# print(stu1.school)
#类的定义的函数是类的函数属性，类可以使用，但类来用就是一个普通函数，必须遵循函数的规则
#但是，类中定义的函数其实是给对象来用的，而且是绑定给对象使用，称之为绑定方法
#绑定方法的特殊之处：
#绑定谁就应该谁来调用，谁来调用就会将谁当做第一个参数自动传入
# 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))
# stu1.choose_course()
# stu2.choose_course()
# stu3.choose_course()
类与类型
#在python3中统一了类与类型的概念，类就是类型
# class Foo:
# pass
# print(Foo)
# obj=Foo()
# print(obj,type(obj))
# print(list)
# l1=[1,2,3] #l1=list([1,2,3])
# print(l1.append)
# l1.append(4)
# print(l1)
# list.append(l1,5)
# print(l1)
# l2=['a','b','c'] #l2=list(['a','b','c'])
# l2.append('d')
# print(l2)
# list.append(l2,'e')
# print(l2)
#在没有学习类这个概念时，数据和功能是分离的
host='127.0.0.1'
port=3306
db='db1'
charset='utf-8'
#每次调用都需要传入一堆参数
exc1(host,port,db,charset,'select * from tb1;')
exc1(host,port,db,charset,'select * from tb1;')
exc1(host,port,db,charset,'select * from tb1;')
exc1(host,port,db,charset,'select * from tb1;')
exc2(host,port,db,charset,'存储过程名字3')
#2、基于面向对象的思想将数据与功能整合到一起（举例）
class Mysql:
def __init__(self,host,port,db,charset):
self.host=host
self.port=port
self.db=db
self.charset=charset
def excl(self,sql):
conn=connect(self.host,self.port,self.db,self.charset)
conn.execute(sql)
return xxx
def exc2(self,proc_name):
conn = connect(self.host, self.port, self.db, self.charset)
conn.call_proc(proc_name)
return xxx
obj=Mysql('127.0.0.1','3306','db1','utf-8')
obj.exc1('select * from xxx')
obj.exc2('p1')
序列化与反序列化
# info={
# 'name':'frank',
# 'age':18,
# 'sex':'male'
# }
#
#
# # with open('a.txt',mode='wt',encoding='utf-8') as f:
# # f.write(str(info))
#
# with open('a.txt','r',encoding='utf-8') as f:
# data=f.read()
# print(data,type(data))
# dic=eval(data)
# print(dic['name'])
l=eval('[1,2,3]')
print(l,type(l))
json序列化与反序列化使用示例：
import json
#1.序列化json.dumps--->反序列化json.loads
# info={
# 'name':'frank',
# 'age':18,
# 'sex':None,
# 'is_beautifull':True
# }
# info_json=json.dumps(info)
# print(info_json,type(info_json))
#
# with open('a.json','w',encoding='utf-8')as f:
# f.write(info_json)
#简写
# with open('c.json','w',encoding='utf-8')as f:
# json.dump(info,f)
#2.反序列化json.dump--->json.load
# info={
# 'name':'frank',
# 'age':18,
# 'sex':None,
# 'is_beautifull':True
# }
# info_json=json.dumps(info)
# print(info_json,type(info_json))
#
# with open('b.json','w',encoding='utf-8')as f:
# f.write(info_json)
# with open('b.json','r',encoding='utf-8') as f:
# data=f.read()
#
# print(data,type(data))
# dic_json=json.loads(data)
# print(dic_json,type(dic_json))
# print(dic_json['name'])
#简写
# with open('b.json','r',encoding='utf-8') as f:
# dic_json=json.load(f)
# print(dic_json['name'])
Pickle序列化与反序列化示例：
import pickle
info={
'name':'frank',
'age':18,
'sex':None,
'is_beautifull':True
}
# pickle序列化示例
# info_pickle=pickle.dumps(info)
# print(info_pickle,type(info_pickle))
# with open('a.pickle','wb')as f:
# f.write(info_pickle)
#简写
# with open('b.pickle',mode='wb')as f:
# pickle.dump(info,f)
# pickle反序列化示例
# with open('a.pickle',mode='rb')as f :
# info_pickle=f.read()
# dic_pickle=pickle.loads(info_pickle)
# print(dic_pickle['name'])
#简写
# with open('b.pickle',mode='rb')as f:
# dic_pickle=pickle.load(f)
# print(dic_pickle['name'])
Hashlib模块
#1.什么是hash
#hash是一种算法，该算法就相当于一个工厂，我们给工厂运算的原材料是一串字符/bytes
#工厂加工的结果一个hash值
# hash值有三大特征：
# 1.只要传入的字符/bytes相同，得到的hash值必然相同
# 2.只要使用hash算法是固定的，那得到的hash长度是固定的，即hash值不会随着校验内容增多而变长
# 3.无法通过hash值逆推出校验的内容
# 2.为何要用hash
# 特点1和2可以用来做文件完整性校验
# 特点3可以对密码进行加密
# 3.如果使用
# import hashlib
# # import sys
# # sys.path.append(r'E:\SH_weekend_s2\day7\hashlib模块.py')
#
# # m = hashlib.md5()
# m1 = hashlib.md5()
# # m.update('hello'.encode('utf-8'))
# # print(m.hexdigest())
#
# # with open('a.mp4','wb')as f:
# # f.write('hellow world')
#
# with open('a.mp4','rb')as f:
# m1.update(f.read())
# print(m1.hexdigest())
import hashlib
# m=hashlib.md5('frank'.encode('utf-8'))
# m.update('hello'.encode('utf-8'))
# m.update('world'.encode('utf-7'))
# print(m.hexdigest())
#
# m1=hashlib.md5('fran'.encode('utf-8'))
# m1.update('k'.encode('utf-8'))
# m1.update('hello'.encode('utf-8'))
# m1.update('world'.encode('utf-7'))
# print(m1.hexdigest())
# m2=hashlib.sha512()
# m2.update('sunny'.encode('utf-8'))
# m2.update('hello world'.encode('utf-8'))
# print(m2.hexdigest())
# pwd='123456'
# m=hashlib.md5()
# m.update('天王盖地虎'.encode('utf-8'))
# m.update(pwd.encode('utf-8'))
# print(m.hexdigest())
时间模块
#time 模块
# import time
# 1.时间戳
# print(time.time())
# 2.格式化字符串
# print(time.strftime('%Y-%m-%d %X %p'))
# print(time.strftime('%Y-%m-%d %H-%M-%S %p'))
# 3.时间对象
# obj=time.localtime()
# print(obj,obj.tm_mon)
# print(time.gmtime())
# 4.时间转换
# timestamp<---->struct_time
# struc_time=time.localtime(1231231)
# print(struc_time)
# timestamp=time.mktime(struc_time)
# print(timestamp)
#struct_time<----->format_string
# struc_time=time.strptime('2017-03-01 11:11:11','%Y-%m-%d %H:%M:%S')
# print(struc_time)
# print(time.strftime('%Y-%m-%d',struc_time))
# print(time.ctime(123123))
# import datetime
# print(datetime.datetime.now())
# print(datetime.datetime.fromtimestamp(1232213))
#
# print(datetime.datetime.now()+datetime.timedelta(days=1))
# print(datetime.datetime.now()+datetime.timedelta(days=-1))
#
# obj=datetime.datetime.now()
# print(obj.replace(year=2017,month=8))
random模块：
import random
# print(random.choice(['a',1,2]))
# print(random.sample(['a',1,2],2))
# print(random.uniform(1,3))
# item=[1,3,4,6,8]
# random.shuffle(item)
# print(item)
# def make_code(n=5):
# res=''
# for i in range(n):
# num=str(random.randint(0,9))
# sl=chr(random.randint(65,90))
# res+=random.choice([num,sl])
# return res
# print(make_code(5))
OS模块：
import os
# print(os.listdir('.'))
# print(os.stat(r'E:\Python_exercise\day7\09.OS模块.py').st_size)
# print(os.path.getsize(r'E:\Python_exercise\day7\09.OS模块.py'))
# os.system('tasklist')
# os.environ['name']='frank'
# print(os.environ)
# print(os.path.abspath(__file__))
# res=os.path.split(r'E:\Python_exercise\day7\09.OS模块.py')
# print(res)
# print(os.path.basename(r'E:\Python_exercise\day7\09.OS模块.py'))
# print(os.path.dirname(r'E:\Python_exercise\day7\09.OS模块.py'))
# print(os.path.exists(r'E:\Python_exercise\day7\09.OS模块.py'))
# print(os.path.exists(r'E:\Python_exercise\day7'))
# print(os.path.exists(r'E:\Python_exercise\day7123'))
# print(os.path.isabs(r'E:\Python_exercise\day7\09.OS模块.py'))
# print(os.path.isabs(r'c:\123'))
# print(os.path.join(r'D:\\','a','c.txt'))
# print(os.path.join('c','d',r'D:\\','a','c.txt'))
# with open(r'E:\Python_exercise\day7\09.OS模块.py','r',encoding='utf-8')as f :
# print(f.read())
# print(os.path.normcase(r'C:\Users\lifeng\TOSHIBA\eST455\PCL6'))
# print(os.path.normpath(r'E:\admin'))
# BASE_DIR=os.path.dirname(os.path.dirname(__file__))
# print(BASE_DIR)
# BASE_DIR1=os.path.normpath(
# os.path.join(
# __file__,
# '..',
# '..'
# )
# )
#
# print(BASE_DIR1)
subprocess模块：
import subprocess
import time
obj=subprocess.Popen(
'tasklist',
shell=True,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE
)
# res=obj.stdout.read()
# print(res.decode('gbk'))
# print('='*30)
# res=obj.stdout.read()
# print(res)
# print(obj.stdout.read())
# print(obj.stderr.read().decode('gbk'))