【学习笔记】python面向对象编程

一.类的创建和调用

1.创建类

• 类：类就是对同一类型的描述,本身不占用内存空间
• 对象：对象就是该类事物存在的个体，是该类的实例，只有对象才可以调用该类的属性以及方法,对象占内存空间

#class 类名(父类名字,默认object)：
#类的说明+类体
#类体=属性+函数

#object 基类，超类，所有类的父类，没有合适的父类就写object

class Person():
    #属性(变量)
    sex = "man"
    age = 25
    height = 180
    print("outside")

    #方法(函数)
    #方法的参数必须以self当第一个参数
    #self代表类的实例
    def coding(self):
        print("coding")
        print("inner")

    def cook(self):
        print("做饭")

2.创建对象&实例化类

属性：
调用属性的时候会先调用类的全部信息(自上而下)

boy = Person()
print("年龄是：{}".format(boy.age))
print("testing")

出现结果：

outside
年龄是：25
testing

方法：

boy = Person()
boy.coding()
print("testing")

出现结果：

#调用对象出现
outside
#对象的方法
coding
inner
testing

3.公有&普通&私有属性

a.公有属性

b.私有属性

c.普通属性

4.构造函数&析构函数

a.构造函数/初始化函数

init()函数，在使用类创建对象的时候自动调用，可以用来进行参数化

class Person():
    def __init__(self,sex,age,height):
        self.sex = sex
        self.age = age
        self.height = height

b.析构函数

在函数内部定义的对象，在函数结束会被释放，用来节省空间

del per1
#析构函数：__del__()释放对象是自动调用的

5.类方法，对象方法，静态方法

静态函数是用 空格 占坑，类函数使用class占坑

a.类方法

类函数使用classMethod修饰，类方法可以被类和对象调用,但是类方法调用的属性是类的属性，类函数只能通过类来调用

time = 7
    @classmethod #类函数
    def sleep(cls): #cls表示类体
        print("睡觉%s"%(cls.time))

输出：

boy = Person("Ben")
boy.sleep()
睡觉7

b.静态方法

，静态函数使用staticMethod修饰，静态方法：把一个类中函数变为静态函数，名义上属于类，但是类中所用的方法属性方法它都调用不了，但是可以被类以及对象调用

class Person(object):
    def __init__(self, name):
        self.name = name

    @staticmethod
    def eat( ):
        print("eating")

c.对象方法

这个函数只能被对象调用。第一个参数为self，对象函数只能通过对象来调用，对象方法使用self 占坑

class Person(object):
    def __init__(self, name):
        self.name = name

    def eat(self):
        print('%s is eating %s' %(self.name, food))

d.普通方法

e.私有方法

5.作业(0215)

1：编写一个数学类，要求初始化函数带a,b,c,d4个参数，然后有加减乘数四个函数

class NumMath:
    def __init__(self,a,b,c,d):
        self.a = a
        self.b = b
        self.c = c
        self.d = d

    def add(self):
        return self.a+self.b+self.c+self.d

    def sub(self):
        return self.a-self.b

    def dell(self):
        return self.a/self.b

    def multi(self):
        return self.a*self.b

2：依靠自己的想象力，编写一个软件测试工程师类，要求包含初始化函数 类函数 对象函数 静态函数

'''测试类'''
class SoftTesting:

    '''__init__函数'''
    def __init__(self,name,age,sex):
        self.name = name
        self.age = age
        self.sex = sex

    work = "writing"
    '''类函数'''
    @classmethod
    def writing_testing(cls):
        print(cls.name +"is"+cls.work)
        
    '''对象函数'''
    def doing_testing(self):
        print(self.name+"is doing testing")

    '''静态函数'''
    @staticmethod
    def find_bug( ):
        print("bug")

二.类的继承

1.使用类的方法

class Person(object):
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def nam(self):
        return "My name is {}".format(self.name)
    def years(self):
        return "I am {} years old".format(self.age)

方法:

if __name__ == '__main__':
    #方法1
    per = Person("Ben","20")
    res = per.nam()
    print(res)

    #方法2
    res_2 = Person("Marry","12").years()
    print(res_2)

2.继承

继承：只有类与对象有
子类拥有父类的所有属性和方法
目的：提高复用性(减少代码量)

父类：

class Person(object):
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def nam(self):
        return "My name is {}".format(self.name)
    def years(self):
        return "I am {} years old".format(self.age)

如果父类和子类不在同一个模块中，子类要导入父类

from pyClass.preview.math_method import Person


class Student(Person):
    def add(self,*args):#子类特有的函数，又名拓展函数
        sum = 0
        for item in args:
            sum += item
        return sum

#子类调用父类的方法
res = Student("Mark",18).years()
print(res)

3.重写

重写override：子类和父类同名的函数，以重写后的函数为准，最好不要重写类函数以及静态函数

#子类重写了父类的__init__函数
class Person(object):
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def nam(self):
        return "My name is {}".format(self.name)
    def years(self):
        return "I am {} years old".format(self.age)