Python（模块、类、封装）_python封装类-CSDN博客

json模块

一、json模块可以实现json数据的序列化和反序列化

（1）序列化：

将可存放在内存中的python 对象转换成可物理存储和传递的形式

实现方法：load() loads()

（2）反序列化：

将可物理存储和传递的json数据形式转换为在内存中表示的python对象

实现方法：dump() dumps()

查看 dump用法：ctrl+点击dump

将python转换成字符类型,将字符类型转换成python类型

（1）dumps 将python对象格式转换成json格式

import  json
j={"name":"zs","age":18}
print(j) #{'name': 'zs', 'age': 18}
print(type(j)) #<class 'dict'>
js=json.dumps(j)
print(js) #{"name": "zs", "age": 18}
print(type(js))

(2) 通过dump将python类型转换成成json格式并保存到文件中

# import  json
# j={"name":"zs","age":18}
# print(j) #{'name': 'zs', 'age': 18}
# print(type(j)) #<class 'dict'>
# js=json.dump(j,open("aa.json","w"))
# print(js) #{"name": "zs", "age": 18}
# print(type(js))

二.loads

(1)loads将字符串转换成python类型

import  json
str='{"name": "zs", "age": 18}'
print(type(str)) #<class 'str'>
d=json.loads(str)
print(d)
print(type(d)) #<class 'dict'>

(2)load 从json格式文件中读取数据并转换成python类型

import  json
d=json.load(open("aa.json","r"))
print(type(d)) #<class 'dict'>

xlrd 模块

python之xlrd模块

（1）xlrd是可用于读取excel表格数据（不支持写操作，写操作需要xlwt模块实现）

（2）支持xlsx 和xls 格式的格式的表格（不支持csv文件，csv文件可用python自带的csv模块操作）

（3）模块安装方式：pip3 install xlrd==1.2.0

（4）模块导入方式：import xlrd

一、在dos中安装xlrd

pip install xlrd==1.2.0

或

pip3 install xlrd ==1.2.0

二.在pycharm中下载xlrd模块

三.xlrd运用

1.新建一个xlsx表格

编辑表格内容

import xlrd

d1=xlrd.open_workbook(r"E:\ls\d1.xlsx")

print(d1.sheet_names()) #显示所有页面名称

dx=d1.sheet_by_index(0) #通过索引获取页面对象

dx1=d1.sheet_by_name("ym1") #通过页面名称获取页面

print(dx.row_values(0)) #获取第一行的内容 ,0根据索引,表示第一行

print(dx.row_values(0,1,2)) #0表示行,1表示列,索引0开始,2结束列,不包含结束列

print(dx.col_values(0)) #根据索引获取一列的数据

print(dx.col_values(2,1,3)) #2标列,1表示开始行,3表示结束行

sys模块

import  sys
#print(sys.version) #获取Python解释程序的版本信息
# # python程序运行版本
#print(sys.maxsize) #能够表示的最大int#9223372036854775807
# print(sys.path)#检索python下包
#print(sys.platform) #sys.platform: 获取当前系统平台#运行平台win32
#print(sys.copyright) #版权信息
#print(sys.argv)# 实现从程序外部向程序传递参数。#参数，当前执行的文件#暂时不讲
# sys提供常用的方法
#print(sys.exit(0))# 程序中间的退出，arg=0为正常退出 #表示正常退出rocess finished with exit code 0
# # print(sys.exit(1)) #表示非正常退出 Process finished with exit code 1
# print(sys.exit(-1))#退出，状态
# print(sys.getdefaultencoding()) #默认编码格式utf-8
# print(sys.getfilesystemencoding()) #utf-8

python中的类

一、介绍类

类(class): 用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例

实例化：创建一个类的实例，类的具体对象。

对象：通过类定义的数据结构实例。对象包括两个数据成员（类变量和实例变量）和方法

方法：类中定义的函数

类变量：类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。

类变量通常不作为实例变量使用。

实例变量：在类的声明中，属性是用变量来表示的，这种变量就称为实例变量，实例变量就是一个用 self 修饰的变量。

继承：即一个派生类（derived class）继承基类（base class）的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。例如，有这样一个设计：一个Dog类型的对象派生自Animal类，这是模拟"是一个（is-a）

"关系（例图，Dog是一个Animal）。

方法重写：如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖（override），也称为方法的重写

二、定义类

（1）class 关键字声明一个类

（2）class 类定义方法

第一种：class 类名（object）：新式类

第二种：class 类名（）：

第三种：class 类名

（3）案例

class Lei(object):
    a=20  #类变量
    def __init__(self,a,b):  #构造函数,初始化作用
        self.a=a #实例变量
        self.b=b #实例变量
    def fs1(self): #方法1
        print(self.a+1) #
    def  fs(self): #方法2
        print(self.b+2)
if __name__ == '__main__':
    dx=Lei(1,2)   # 创建类的而对象   ,1,2就是一个实例
    dx.fs1() #通过类的对象.调用方法1
    dx.fs()  ##通过类的对象.调用方法2
    print(dx.a) #通过对象调实例变量
    print(dx.b) #通过对象调实例变量
    print(Lei.a) ##通过类名调类变量

（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.b=b #实例变量

def fs1(self): #方法1

print(self.a+1) #

def fs(self): #方法2

print(self.b+2)

@classmethod #类方法,也叫动态方法

def l(cls): #cls 函数修饰

print(cls.a)

@staticmethod #私有方法,也叫静态方法

def dy():

print("dy")

if __name__ == '__main__':

dx=Lei(1,2) # 创建类的而对象 ,1,2就是一个实例

# dx.fs1() #通过类的对象.调用方法1

# dx.fs() ##通过类的对象.调用方法2

# print(dx.a) #通过对象调实例变量

# print(dx.b) #通过对象调实例变量

# print(Lei.a) ##通过类名调类变量

# dx.l()

dx.dy()

python三大特性:封装,多态,继承

一、封装：

1、封装：

封装就是隐藏对象一些不希望外部所访问到的属性和方法，保证安全

2、概念:

指的是在设计时，不对外提供，隐藏起来，提供公共方法以外对其方法就是把属性和方法封装到一个抽象的类中，

3、功能

封装相当于一个黑盒子，我们将事务相关的属性和方法封装在一个类中，在调用类创建实例，不用关注内部代码的实现细节，我们只要调用结果就可以。

4、封装的优点：

（1）封装数据可以很好的保护隐私、

（2）封装方法主要原因是隔离复杂度

（3）封装提高了代码的复用性

（4）隐藏对象的属性和实现细节，提供公共方法对其访问

5、python中类的封装分为两种：

（1）公用（共用）

类中变量和方法公用，他们名称前没有下滑线，共有的变量和方法，在类的外部，内部以及子类都可以调用

数据封装

（2）私用

在类中变量和方法中,___下滑线开头命名，则改变变量或方法为私用，私有的变量和方法，只能在内部使用，类的尾部以及子类都无法使用。

私有属性：格式 ___属性名 =值在类的外部不能使用（对象不能调用属性）

私有化封装后的限制：

a、类可以访问

b、类外，对象外不可访问

c子类和子类的对象可访问

案例:

代码:

class Lei(object):
    a=20  #类变量
    def __init__(self,a,b):  #构造函数,初始化作用
        self.__a=a #实例变量
        self.__b=b #实例变量
    def fs1(self): #方法1
        print(self.a+1) #
    def  __fs(self): #方法2
        print(self.b+2)
    def fs3(self):  # 方法2
        print(self.__fs())
    @classmethod #类方法,也叫动态方法
    def l(cls): #cls 函数修饰
       print(cls.a)
    @staticmethod  #私有方法,也叫静态方法
    def  dy():
        print("dy")
if __name__ == '__main__':
    dx=Lei(1,2)   # 创建类的而对象   ,1,2就是一个实例
    # dx.fs()  ##通过类的对象.调用方法2
    # dx.fs3()
    # dx.fs1() #通过类的对象.调用方法1

    print(dx.a) #通过对象调实例变量
    print(dx.b) #通过对象调实例变量

案例:

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、派生

在继承中一个类被另外一个类继承这个类称之为父类也称之为基类，则另外一个类则为子类也称之为派生类

案例1：

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():
    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()

继承:

案例:单继承(继承一个类)

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):
    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()

案例:多个类继承

class M():
    def  fp(self):
        print("富婆")
    def  qian(self):
        print("qian")
    def kuang(self):
        print("kuang")
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()
     sdx.kuang()

三.多态

多态

1、多态是以继承和重写父类方法为前提，对所有子类实例化产生的对象调用相同的方法，执行产生不同的执行结果。

2、例如同样是人，但是当问起一个人的职业时会有不同的结果，可能是软件测试工程师，可能是HR

3、一个对象的属性和行为不是由他所继承的父类决定的，而是由其本身包含的属性和方法决定的

案例1：

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(" 杭州","多测师") # 汉字