多测师拱墅校区肖sir_高级金牌讲师_python之类

多测师软件测试培训师肖sir

已于 2023-12-20 15:06:15 修改

阅读量383

点赞数

分类专栏： python 拱墅校区文章标签： python 开发语言

于 2022-05-03 18:01:53 首次发布

本文链接：https://blog.csdn.net/m0_47403059/article/details/124557980

版权

拱墅校区同时被 2 个专栏收录

81 篇文章 12 订阅

订阅专栏

python

22 篇文章 2 订阅

订阅专栏

一、面向对象的基本概念
（1）python是一个面面向对象的语言，在pyhton中创建对象和类
（2）类(class): 用来描述具有相同的属性和方法的对象的集合。
案例：人类=======jx
它定义了该集合中每个对象所共有的属性和方法。
（3）对象是类的实例。
（4）实例化：创建一个类的实例，类的具体对象。
（5）对象：通过类定义的数据结构实例。对象包括两个数据成员（类变量和实例变量）和方法。
（6）方法：类中定义的函数。
（7）类变量：类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。
类变量通常不作为实例变量使用。
（8）实例变量:
在类的声明中，属性是用变量来表示的，这种变量就称为实例变量，实例变量就是一个用 self 修饰的变量
（9）继承：
即一个派生类（derived class）继承基类（base class）的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待
（10）方法重写
如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖（override），也称为方法的重写
(11)多态
（12）封装

=================================
二、定义类：
（1）两种类型：新式类，经典类
（2）单词：class
（3）格式：
clas 类名（ object或不写）：
类变量
def init_ (self ,变量名) 构造函数，初始化
self. 变量名=变量名 #实例变量
def 函数名（self）： #方法
pass
if name == ‘main’:
类对象名=类名（有参数就填参数） #参数就实例
类对象名.函数

案例：

class hzdcs(object):
        name = "zs"
        def __init__(self, name, age):  # 构造函数，起到初始化作用
            self.name = name  # 实例变量
            self.age = age  # 实例变量
        def a(self):  # 创建一个函数数，也叫方法
            print(self.name)
        def b(self):
            print(self.age)
        def c(self):
            print(self.name + self.age)
if __name__ == '__main__':
    dx=hzdcs("li",18)  #创建类的对象      li ，18 实例
    dx.a()  #通过类的对象调用函数a
    dx.b()  ##通过类的对象调用函数b
    dx.c()  #通过类的对象调用函数c

在这里插入图片描述

   （4）

名词解释：
1、定义类的时候__init__是一个构造函数，该函数是两个下划线开头和两个下划线结束，其作用就是当创建类的对象和实例时系统会自动调用构造函数，通过构造函数对类进行初始化操作
2、定义类的时候__init__方法中有一个参数self，这也是类中的方法与普通函数的区别，类的中的方法必须有一个参数self，而且位于参数列表的开头，在类中self就是代表类的当前类的实例（对象）自身，在python调用时无需传值， python会将对象自动传给self接受

=================================
（1）新式类

**class GsDcs(object): #新式类
lei=10 #lei
def init(self,a): #构造函数，初始化操作
self.a=a #实例变量
def dcs(self): #函数也是方法
print(self.a)
def hz(self):
print(self.lei)
if name == ‘main’:
s=GsDcs(‘wy’) # 创建类的对象
s.dcs() #通过类兑现调用函数
s.hz() #通过类调用类变量
**

（2）经典类
class GsDcs(): #新式类
lei=10 #lei
def init(self,a): #构造函数，初始化操作
self.a=a #实例变量
def dcs(self): #函数也是方法
print(self.a)
def hz(self):
print(self.lei)
if name == ‘main’:
s=GsDcs(‘wy’) # 创建类的对象
s.dcs() #通过类调用函数
s.hz() #通过类调用类变量

================================
（一）实例方法：
案例：
class GsDcs(): #新式类
a=10 #lei
def init(self,a): #构造函数，初始化操作
self.a=a #实例变量
def dcs(self): #函数也是方法
print(self.a)
def hz(self):
print(self.a)
if name == ‘main’:
s=GsDcs(5) # 创建类的对象
s.dcs() #通过类变量调用函数
print(GsDcs.a) #通过类调用类变量
s.a=30 #实例对象修改变量
print(s.a)

===========================
（二）
动态方法：也叫类方法
单词：@classmethod
class GsDcs(): #新式类
a=10 #lei
def init(self,a,b): #构造函数，初始化操作
self.a=a #实例变量
self.b=b
def dcs(self): #函数也是方法
print(‘考试考了：’+self.a)
def hz(self):
print(self.b)
@classmethod
def lei(cls):
print(cls.a)
if name == ‘main’:
s=GsDcs(‘100’,‘50’) # 创建类的对象
s.lei()

===========================
（3）静态方法：也叫私有方法
单词：@staticmethod

class GsDcs(): #新式类
a=10 #lei
def init(self,a,b): #构造函数，初始化操作
self.a=a #实例变量
self.b=b
def dcs(self): #函数也是方法
print(‘考试考了：’+self.a)
def hz(self):
print(self.b)
@classmethod
def lei(cls):
print(cls.a)
@staticmethod
def jt():
print(“中”)

if name == ‘main’:
s=GsDcs(‘100’,‘50’) # 创建类的对象
# s.lei()
s.jt()

========================
类的三大特性：
（1）封装
（2）继承
（3）多态

一、封装
（1）定义：封装就是指隐藏对象中一些不希望外部所访问的属性和方法，即为保证安全
（2）概念：指的是在设计类时，不对外提供，隐藏起来，提供公共方法以外的方法（就是把属性和方法封装到一个抽象的类中）
（3）封装相当于一个抽象的盒子，将事务相关的属性和方法封装在一个类中，在调用类创建实例，不用关心内部代码的实现细节，只要调用结果就可以。
（4）封装的优点：
A. 封装数据，可以很好的保护隐私（将不需要对外提供的内容都隐藏起来）
B.封装方法主要原因是隔离复杂度
c.提高代码的复用性
D.隐藏对象的属性和实现细节，提供公共方法对其访问
（4）python类的封装有两种：
A. 公有（共用）
类中的变量和方法，他们名称前没有下划线，公有的变量和方法在类的外部，内部，以及子类都可以使用
B.私有
在类的变量和方法系，下划线开头命名，则改变量或方法系啊，下划线开头命名，则改变变量或方法为私有，私有变量和方法，只能在本类内部使用，类的尾部以及子类都无法使用

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

======================================================
公有
（1）数据封装：
class gs():
def init(self,name,age):
self.name=name
self.age=age
（2）
class gs():
def init(self,name,age):
self.name=name
self.age=age
def zy(self): #方法封装
print(self.name+‘搬砖’)

===========================
私有方法：

class hzdcs(object):
        name = "中国"
        def __init__(self,name,age):  # 构造函数，起到初始化作用
            self.name = name  # 实例变量
            self.age = age  # 实例变量
        def a(self):  # 创建一个函数数，也叫方法
            print(self.name)
        def __b(self):
            print(self.age)
        def c(self):
              self.__b()
        @classmethod  #类方法，也叫动态方法
        def  d(cls):
            print(cls.name)
        @staticmethod  #静态方法
        def  e():
            print('我是一个静态方法')
if __name__ == '__main__':
    dx=hzdcs("li","18")  #创建类的对象      li ，18 实例
    dx.c( )  #18

（2）在实例变量的前面加上

class hzdcs(object):
        name = "中国"
        def __init__(self,name,age):  # 构造函数，起到初始化作用
            self.__name = name  # 实例变量
            self.__age = age  # 实例变量
        def a(self):  # 创建一个函数数，也叫方法
            print(self.name)
        def __b(self):
            print(self.__age)
        def c(self):
              self.__b()
        @classmethod  #类方法，也叫动态方法
        def  d(cls):
            print(cls.name)
        @staticmethod  #静态方法
        def  e():
            print('我是一个静态方法')
if __name__ == '__main__':
    dx=hzdcs("li","18")  #创建类的对象      li ，18 实例
    print(dx.name)
    dx.c()

class Gs():
def init(self,name,age):
self.__name=name
self.__age=age
def setname(self,newname): #方法封装
self.__name=newname
def getname(self):
print(self.__name)
if name == ‘main’:
s=Gs(‘wy’,18)
print(s.__name)

==============================
（1）getname 获取名
用于实例化对象设置修改类属性的方法
（2）setname设置名字
用于实例化对象获取修改类属性的方法

class hzdcs(object):
        name = "中国"
        def __init__(self,name,age):  # 构造函数，起到初始化作用
            self.__name = name  # 实例变量
            self.__age = age  # 实例变量
        def a(self):  # 创建一个函数数，也叫方法
            print(self.name)
        def setage(self,nage):
            self.__age=nage
        def getage(self):
              print(self.__age)
        @classmethod  #类方法，也叫动态方法
        def  d(cls):
            print(cls.name)
        @staticmethod  #静态方法
        def  e():
            print('我是一个静态方法')
if __name__ == '__main__':
    dx=hzdcs("li","18")  #创建类的对象      li ，18 实例
    dx.setage("20")
    dx.getage()

=======================================================

1、继承：类的继承是面向对象程序设计的一个重要思想，继承时子类可以继承父类的内容，包括成员变量和成员函数。
2、在继承中一个类被另外一个类继承这个类称之为父类也称之为基类，则另外一个类则为子类也称之为派生类。
案例一：单个继承

在这里插入代码片class  f(object):
    def  car(self):
        print("车")
    def  fz(self):
        print("房子")
class son(object,f):
    def sy(self):
        print("失业")
    def wck(self):
        print("无存款")
if __name__ == '__main__':
    dxf=f()
    dxf.car()
    dxf.fz()
    dxs=son()
    dxs.sy()
    dxs.wck()
    dxs.car()
    dxs.fz()

案例二：多个继承


class  f(object):
    def  car(self):
        print("车")
    def  fz(self):
        print("房子")
class  m(object):
    def ck(self):
        print('存款')
class son(object,f,m):
    def sy(self):
        print("失业")
    def wck(self):
        print("无存款")
if __name__ == '__main__':
    dxf=f()
    dxf.car()
    dxf.fz()
    dxs=son()
    dxs.sy()
    dxs.wck()
    dxs.car()
    dxs.fz()
    dxs.ck()

=========================================
多态;
1、多态是以继承和重写父类方法为前提，对所有子类实例化产生的对象调用相同的方法，执行产生不同的执行结果
2、例如同样是人，但是当问起一个人的职业时会有不同的结果，可能是软件测试工程师，可能是HR
3、一个对象的属性和行为不是由他所继承的父类决定的，而是由其本身包含的属性和方法决定的
4、多条的优点：
A.增加程序的灵活性
B.增加程序的可拓展性

======================================
案例1: 理解多态

class  f(object):
    def __init__(self ,a):
        self.a=a
    def car(self):
          print(self.a)
if __name__ == '__main__':
    # dx=f("a")
    # dx=f("中文")
    dx = f(1)
    dx.car()

案例2: 理解多态

class Animal(object):
      def talk(self):
           print('我是动物')
class Cat(Animal):
       def talk(self):
           print('喵喵')
class Dog(Animal):
       def talk(self):
           print('汪汪')
if __name__ == '__main__':
    # a=Animal()
    # b=Cat()
    c=Dog()
    # a.talk() #我是动物
    # b.talk() #喵喵
    c.talk() #汪汪

案例3：
class Animal(object): #定义一个类
def talk(self):
print(‘我是动物’)
class Cat(Animal): #定义一个类，重写父类
def talk(self):
print(‘喵喵’)
class Dog(Animal): ##定义一个类，重写父类
def talk(self):
print(‘汪汪’)
class r(object):
def rx_j(self,Animal):#传入不同对象，执行不同代码，不同的talk只要接收父类对对象，就能接收子类对象
print(Animal.talk())
if name == ‘main’:

====================================
拓展知识一：
一、装饰器
（1）定义：装饰器，本质是一个python函数，他可以让其他函数在不需要做任何代码改动的前提，增加额外的功能，装饰器的返回值也是一个函数对象。
（2）装饰器应用的场景：
插入日志，事务处理，缓存，权限等场景
（3）常见的装饰器：
内置装饰器，类装饰器，函数装饰器，待参数的装饰器
二、案例：

（1）
class gs():
def init(self):
self.name=“hzgs”
def a(self):
print(“a”)
def b(self):
print(“b”)
@staticmethod
def c():
print(‘我是一个独立’)
if name == ‘main’:
g=gs()
g.a()
g.b()
g.c()

（2）案例2：
class gs():
def init(self):
self.name=“hzgs”
def a(self):
print(“a”)
def b(self):
print(“b”)
@property #定义property属性
def m(self):
return (‘我是一个独立’)
if name == ‘main’:
g=gs()
print(g.m)

多测师软件测试培训师肖sir

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
多测师拱墅校区肖sir_高级金牌讲师_python之类

一、面向对象的基本概念（1）python是一面面向对象的语言，在pyhton中创建对象和类（2）类(class): 用来描述具有相同的属性和方法的对象的集合。案例：人类=======hjx它定义了该集合中每个对象所共有的属性和方法。（3）对象是类的实例。（4）实例化：创建一个类的实例，类的具体对象。（5）对象：通过类定义的数据结构实例。对象包括两个数据成员（类变量和实例变量）和方法。（6）方法：类中定义的函数。（7）类变量：类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数
复制链接

扫一扫