07.1 python基础-类和对象

1. 基础语法

1.1 类基础语法

关键字class
类名规范：数字字母下划线组成,不能数字开头,首字母大写,不需要隔开

# 类命名是不带括号，调用时需要带括号，否则视为赋值
class TestEngineer:
    degree = '本科'
    base_skill = '自动化测试'

  # 类函数第一个参数默认为self
 # 无初始化函数时调用类属性需要试用self  
     def person_info(self, name, age, sex):
        print('我的名字是{}，今年{}岁，性别{}，{}学历，会{}'.format(name, age, sex,self.degree,self.base_skill))

    def hobby(self,*args):
        print('爱好有{0}'.format(args))

    # 类函数调用试用self
    def skill(self,name,age,sex,**kwargs):
        self.person_info(name,age,sex,)
        print('能加班能熬夜')

dana = TestEngineer()
dana.person_info('dana',18,'男')
dana.hobby('蓝球','足球','羽毛球')
dana.skill('xiaona',22,'男')

>我的名字是dana，今年18岁，性别男，本科学历，会自动化测试
 爱好有('蓝球', '足球', '羽毛球')
 我的名字是xiaona，今年22岁，性别男，本科学历，会自动化测试
 能加班能熬夜

1.2 初始化函数

类函数调用类属性或函数的方法：
    1. self.函数名或属性名
    2. global先定义全部变量后再调用类属性
    3. 试用初始化函数

使用初始化函数后实例化需要传参
初始化函数没有返回值
一般在一次传参，多次调用时使用初始化函数

# 未使用初始化函数
class Calculator:

    def add(self,a,b):
        return a + b

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

    def mul(self,a,b):
        return a * b

    def div(self,a,b):
        return a + b

r = Calculator()
e = r.sub(5,4)
print('运行的结果是:{0}'.format(e))

>运行的结果是:1

# 使用初始化函数
class Calculator:

    def __init__(self,a,b):
        self.a = a
        self.b = b

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

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

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

    def div(self):
        return self.a + self.b

# 实例化时需要传参，且可多次调用
r = Calculator(5,4)
e = r.sub()
f = r.add()
h = r.mul()
g = r.div()
print('运行的结果是:{0}、{1}、{2}、{3}'.format(e,f,h,g))

>运行的结果是:1、9、20、9

2. 继承

单继承：
多继承：顺序有限
超继承：即继承父类，有拥有自己的内容

2.1 单继承

class Person:

    def base_info(self,name,sex,age,degree):
        print('{}，{}性，年龄{}，{}学历'.format(name,sex,age,degree))

class Teacher(Person):
    def skill(self):
        print('我会教学生')

t = Teacher()
t.base_info('dana','男',18,'本科')
t.skill()

>dana，男性，年龄18，本科学历
 我会教学生

2.2 多继承

多继承：同名函数继承的时候哪个类在前面就用谁的函数

class Dad:

    def __init__(self,name,age):
        self.name = name
        self.age =age

    def cooking(self):
        print('只会做蛋炒饭')

    def swimming(self,mile):
        print('我是{}米游泳冠军')

    def smoking(self):
        print('喜欢抽烟')

    def skill(self):
        print('是个建筑工程师')

class Mom:

    def __init__(self,name):
        self.name =name

    def singing(self,singer):
        print('会唱{}的歌'.format(singer))

    def cooking(self):
        print('会做各种美味的大餐')

    def skill(self):
        print('是个老师')

class Son(Dad,Mom):
    def skill(self,language='python'):
        print('会{}语言编程'.format(language))

# 实例化

p = Son('dana','18')
p.skill()           # 多继承时同名函数使用顺序：先使用自己的
p.cooking()         # 多继承时同名函数使用顺序：自己没有时使用第一个父类 ，并以此顺延
p.singing('刘德华')

>会python语言编程
 只会做蛋炒饭
 会唱刘德华的歌

2.3 超继承

超继承：只继承一个父类，既有父类的特性，也有自己的新特性
-super

class Dad:

    def __init__(self,name,age):
        self.name = name
        self.age =age

    def skill(self):
        print('是个建筑工程师')

class Son(Dad):

    def skill(self,language):
        super(Son,self).skill()
        print('会{}语言编程'.format(language))

# 实例化

p = Son('dana',18)
p.skill('python')

>是个建筑工程师
 会python语言编程

3. 多态

3.1 重写

重写：子类的函数名与父类的一致，那么就会重写函数override
调用函数的时候 就调用子类自己的，不再调用父类的。 父类不能用子类的函数和属性

class Dad:
    def skill(self):
        print('是个建筑工程师')

class Son(Dad):
    def skill(self,language):
        print('会{}语言编程'.format(language))

# 实例化
p = Son()
p.skill('python')

>会python语言编程

3.2 拓展

拓展：父类没有的函数子类有,就叫拓展

class Dad:
    pass

class Son(Dad):
    def skill(self,language):
        print('会{}语言编程'.format(language))

# 实例化
p = Son()
p.skill('python')

>会python语言编程

4. 总结

超继承：同名函数继承父类的同时新增
重写：同名函数不使用父类
拓展：新增函数