3.18-1
一、json模块可以实现json数据的序列化和反序列化
（1）序列化：将可存放在内存中的python 对象转换成可物理存储和传递的形式
实现方法：load() loads()
（2）反序列化：将可物理存储和传递的json数据形式转换为在内存中表示的python对象
实现方法：dump() dumps()
查看 dump用法：ctrl+点击dump
import json
#dump(sb,fp)将python类型转换为json文件
j={"name":"zs","age":18};print(type(j))#<class 'dict'>
js=json.dumps(j);print(js);print(type(js))
#dumps(sb)将python数据类型转换为json字符串
js=json.dump(j,open("aa.json","w"));print(js)
print(type(js))#<class 'str'>
#loads(sb)将json格式字符转换为python类型
j='{"name":"zs","age":18}'
d=json.loads(j);print(d);print(type(d))
#load(fp)从json格式文件读取数据转换为Python类型
d1=json.load(open("aa.json","r"));print(type(d1))
二、xlrd
安装xlrd 方法1：dos中pip install xlrd==1.2.0或pip3 install xlrd ==1.2.0 方法2：seting里面
import xlrd d1=xlrd.open_workbook(r"D:\111.xlsx")
#print(d1.sheet_names())#显示所有页面名称['Sheet1', 'Sheet2', 'Sheet3']
dx=d1.sheet_by_index(0)#;print(dx)#通过索引获取页面对象
dx1=d1.sheet_by_name("Sheet1")#;print(dx1)#无法输出文件内容
#<xlrd.sheet.Sheet object at 0x00000168E10BEC18>
print(dx.row_values(0))#输出第一行['id', 'name', 'age', 'sex'] print(dx.row_values(0,1,2))#0第一行，1第2列，2为结束列不包含 print(dx.row_values(1,0,6))#2行，1列到6列
print(dx.col_values(0))#第一列，其他格式同上
dd=d1.sheet_by_name(sheet_name='Sheet1')#遍历表内所有内容
for i in range(0,dd.nrows):
print(dd.row_values(rowx=i,start_colx=0,end_colx=None))
三、sys
print(sys.version)#python程序运行版本#3.7.3
print(sys.maxsize) #能够表示的最大int#9223372036854775807
print(sys.path)#检索python下包
print(sys.platform)#sys.platform:获取当前系统平台win32
print(sys.copyright) #版权信息All Rights Reserved.
print(sys.argv)# 实现从程序外部向程序传递参数。
参数，当前执行的文件#暂时不讲
sys提供常用的方法
print(sys.exit(0))#arg=0为正常退出
print(sys.exit(1))#正常退出但返还错误
print(sys.exit(-1))#非正常退出
print(sys.getdefaultencoding()) #默认编码格式utf-8
print(sys.getfilesystemencoding())#utf-8
print(sys.getrecursionlimit())#递归次数1000
sys.setrecursionlimit(200)#修改递归次数
print(sys.getrecursionlimit())#修改成功递归次数
四、类
一、介绍类
1、类(class): 用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例
2、实例化：创建一个类的实例，类的具体对象。
3、对象：通过类定义的数据结构实例。对象包括两个数据成员（类变量和实例变量）和方法
4、方法：类中定义的函数
5、类变量：类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。
类变量通常不作为实例变量使用。
6、实例变量：在类的声明中，属性是用变量来表示的，这种变量就称为实例变量，实例变量就是一个用 self 修饰的变量。
7、继承：即一个派生类（derived class）继承基类（base class）的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。例如，有这样一个设计：一个Dog类型的对象派生自Animal类，这是模拟"是一个（is-a）"关系（例图，Dog是一个Animal）。方法重写：如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖（override），也称为方法的重写
=====================================
二、定义类
（1）class 关键字 声明一个类
（2）class 类定义方法
第一种：class 类名（object）： 新式类
第二种：class 类名（）：
第三种：class 类名
（3）案例
class Hz(object):
def __init__(self,name,age): #构造函数
self.name=name #实例变量
self.age=age # #实例变量
def a(self): #创建一个函数， 也叫方法
print(self.name+"砍柴")
def b(self):
print("你们都是"+self.age)
if __name__ == '__main__':
d=Hz("zt","18") # 创建类的对象
d.a()
d.b()
（4）————init————初始化文件构造函数
1、定义类的时候__init__是一个构造函数，该函数是两个下划线开头和两个下划线结束，其作用就是当创建类的对象和实例时系统会自动调用构造函数，通过构造函数对类进行初始化操作
2、定义类的时候__init__方法中有一个参数self，这也是类中的方法与普通函数的区别，类中的方法必须有一个参数self，而且位于参数列表的开头，在类中self就是代表类的当前类的实例（对象）自身，在python调用时无需传值，python会将对象自动传给self接受
===========================
三、类中的类变量、实例变量
1、类变量在类的下方，构造函数的上方
2、实例变量在构造函数的下方 self.开头
class Lei(object):
a=20#类变量
def __init__(self,a,b):#构造函数,初始化
self.a=a#实例变量#封装数据
#self.__a = a#私有封装则a只能返回20
self.b=b#实例变量
#self.__b = b#b无法获取，报错
def fs1(self):#方法封装
print(self.a+1)
def fs(self):
#def __fs(self):#双__私有封装，外部无法调用
print(self.b+2)
@classmethod # 类方法，动态方法
def l(cls):
print(cls.a)
@staticmethod #私有方法，静态方法
def dy():
print("dy")
if __name__=='__main__':
dx=Lei(1,2)#创建类的对象
dx.fs1()#调用1#2
dx.fs()#调用2#4
print(dx.a)#通过对象调实例变量#1
print(dx.b)#通过对象调实例变量#2
print(Lei.a)#通过类名调类变量#20
dx.l()#20
dx.dy()#dy
四、封装
1、定义：封装就是隐藏对象一些不希望外部所访问到的属性和方法，保证安全；
2、概念：指的是在设计时，不对外提供，隐藏起来，提供公共方法以外对其方法就是把属性和方法封装到一个抽象的类中；
3、封装相当于一个黑盒子，我们将事务相关的属性和方法封装在一个类中，在调用类创建实例，不用关注内部代码的实现细节，我们只要调用结果就可以；
4、封装的优点：
（1）封装数据可以很好的保护隐私；（2）封装方法主要原因是隔离复杂度；（3）封装提高了代码的复用性；（4）隐藏对象的属性和实现细节，提供公共方法对其访问；
5、python中类的封装分为两种：
（1）公用（共用）：类中变量和方法公用，他们名称前没有下滑线，共有的变量和方法，在类的外部，内部以及子类都可以调用
（2）私用 ：在类中变量和方法中,双下滑线开头命名，则改变变量或方法为私用，私有的变量和方法，只能在内部使用，类的尾部以及子类都无法使用。
私有属性：格式 ___属性名 =值 在类的外部不能使用（对象不能调用属性）
私有化封装后的限制：
a、类可以访问
b、类外，对象外 不可访问
c子类和子类的对象 可访问
class People(object):
def __init__(self,name):
self.__name = name
def setName(self,newname):
self.__name = newname
def getName(self):
return self.__name
if __name__ == '__main__':
p = People("xiaowang")
# print(p.__name) #报错
p.setName("xiaoming")
print(p.getName())
五、继承
1、继承：类的继承是面向对象程序设计的一个重要思想，继承时子类可以继承父类的内容，包括成员变量和成员函数；
2、在继承中一个类被另外一个类继承这个类称之为父类也称之为基类，则另外一个类则为子类也称之为派生类；
class F(object):
def fh(self):
print("富豪")
def fang(self):
print("房")
def che(self):
print("车")
class M():
def fp(self):
print("富婆")
def qian(self):
print("qian")
def kuang(self):
print("kuang")
#class s(F):不继承（只能用自己方法）
class s(F):#继承父亲（也可以用父亲方法）
#class s(F,M):#继承父亲和母亲（父母方法都能用）
def qg(self):
print("乞丐")
if __name__ == '__main__':
fdx = F();fdx.che();fdx.fang();fdx.fh()
mdx = M();mdx.fp();mdx.kuang();mdx.qian()
sdx = s()
sdx.qg();sdx.fh();sdx.fh();sdx.che();sdx.fang()
六、多态
1、多态是以继承和重写父类方法为前提，对所有子类实例化产生的对象调用相同的方法，执行产生不同的执行结果。
2、例如同样是人，但是当问起一个人的职业时会有不同的结果，可能是软件测试工程师，可能是HR
3、一个对象的属性和行为不是由他所继承的父类决定的，而是由其本身包含的属性和方法决定的
例1
class A(object):
def talk(self):
print("我是动物")
class Cat(A):
def talk(self):
print("喵喵")
class Dog(A):
def talk(self):
print("汪汪")
if __name__ == '__main__':
c=Cat()
c.talk()
d=Dog()
d.talk()
例2
class Cc(object):
def cs(self,x,y):
print(x+y)
if __name__ == '__main__':
c=Cc()
c.cs(1,2) #数值
c.cs("1","2") #字符
c.cs(" 杭州","多测师") # 汉字