pythonpython基础

05-面向对象

Catalogue
  1. 1. 一.01_类的定义和创建
  2. 2. 二.02_类的属性和方法
  3. 3. 三.03_老贾造车
  4. 4. 四.04_老贾造车_面向对象
  5. 5. 五.05_封装
  6. 6. 六.06_继承
  7. 7. 七.07_多继承
  8. 8. 八.08_多态_鸭子类型
  9. 9. 九.09_类属性
  10. 10. 十.10_构造和析构
  11. 11. 十一.11_魔法方法和魔法属性
    1. 11.1. 参考资料

一.01_类的定义和创建

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
"""
类名： 首字母大写，驼峰命名
模块名称：英文小写
函数名称: 英文小写，多个单词之间使用下划线 _
"""


#定义一个人类
class Person:
    #pass代表先过去，以后再填充代码
    pass


#创建一个对象 类名()
p1 = Person()
print(p1)
print(id(p1))
print(type(p1))

p2 = Person()

#isinstance ： 某个对象是否属于这个类
print(isinstance(p2,Person))

二.02_类的属性和方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
"""
类 概念： 事物的特征和行为的描述
人类：
    特征(属性)
        name:姓名
        age: 年龄
    行为(方法)
        eat():吃饭
        sleep():睡觉
"""


#定义一个人类 Person
class Person:
    #定义一个初始化方法，用来设置name 和 age
    def __init__(self,name,age):
        self.name = name
        self.age = age


    #定义一个普通的方法，定义格式和函数一样，区别：必须有一个参数self
    def eat(self):
        print(self)
        print("吃饱喝足...玩好")

    def sleep(self):
        print("好好睡觉...做个美梦")

#创建对应p1
# p1 --> self
# "张三" --> name
# 18 --> age
p1 = Person("张三",18)
print("person:",p1.name,p1.age)

p1.age = 20
print("person:",p1.name,p1.age)

#将p1赋值给self
p1.eat()
p1.sleep()

三.03_老贾造车

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
"""
老贾造车：
    造车 ---> 返回{"name":"FF9001", "speed":260}
    驾驶 ---> 把车的信息传入到驾驶的功能里面
"""

def make_car(name,speed):
    """
    :param name: 型号
    :param speed: 最高时速
    :return: 返回造好的车
    """
    print("老贾造车")
    return {"name":name, "speed":speed}


def drive(car):
    print("老周驾驶老贾造的%s车，最高时速%s" %(car["name"],car["speed"]))


def main():
    #造车
    car = make_car("FF9001",280)
    #驾驶
    drive(car)

main()

四.04_老贾造车_面向对象

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
class Person:
    def __init__(self,name,age):
        self.name = name
        self.age = age

    #造车
    def make_car(self,name,speed):
        print("%s造车"%self.name)
        car = Car(name,speed)
        return car

    #驾驶
    def drive(self, car):
        car.run()
        print("%s开着%s车,最高时速%s"%(self.name,car.name,car.speed))


class Car:
    def __init__(self,name,speed):
        self.name = name
        self.speed = speed

    def run(self):
        print("小电车正在公路上行驶着......")


def main():
    #创建Person对象, 老贾
    p1 = Person("老贾", 38)
    #造车，返回一辆车
    car = p1.make_car("FF9001",280)
    #老贾去驾驶这辆车
    p1.drive(car)

main()

五.05_封装

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
class Person:
    def __init__(self, name, age):
        #在所有的属性名称前面加上两个下划线，表示当前这个属性为私有的
        self.__name = name
        self.__age = age

    def get_name(self):
        self.__test()
        return self.__name

    def get_age(self):
        return self.__age

    def set_age(self,age):
        if age <= 0:
            age = 1
        elif age > 120:
            age = 120
        self.__age = age

    #私有化方法，方法的名称前面，加上双下划线
    def __test(self):
        print("test....")

def main():
    p1 = Person("张三", 18)
    p1.set_age(-100)
    print("%s的年龄%s"%(p1.get_name(),p1.get_age()))

main()

六.06_继承

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
class Person:
    def __init__(self,name,age):
        self.name = name
        self.age = age

    def eat(self):
        print("%s正在吃饭"%self.name)

    def sleep(self):
        print("%s正在睡觉"%self.name)

class Student(Person):
    def __init__(self,name,age, sn):
        #调用父类的方法
        super().__init__(name,age)
        self.sn = sn

    def eat(self):
        super().eat()
        print("作为学生，多吃粗粮，可以长身体")

    def study(self):
        print("好好学习，天天向上")

def main():
    s1 = Student("张三",18,"0001")
    print(s1)
    print(s1.name,s1.age,s1.sn)

    s1.eat()
    s1.sleep()
    s1.study()

main()

七.07_多继承

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
#水栖动物, 如果不写继承的话，默认继承object
class AquaticAnimal(object):
    def __init__(self,name):
        self.name = name

    def swim(self):
        print("在水中愉快的游泳")

    def sleep(self):
        print("我可以在水中睡觉，屌不屌")

#陆栖动物
class TerrestrialAnimal:
    def __init__(self,name):
        self.name = name

    def run(self):
        print("我可以在草原上奔跑")

    def sleep(self):
        print("我可以在陆地上睡觉")

#两栖动物
class Amphibians(TerrestrialAnimal,AquaticAnimal):
    pass

def main():
    #1，创建一个水栖动物
    a1 = AquaticAnimal("小金鱼")
    a1.swim()
    a1.sleep()

    print("*"*50)

    #创建一个陆栖动物
    a2 = TerrestrialAnimal("华南虎")
    a2.run()
    a2.sleep()

    print("*" * 50)

    #创建一个两栖动物
    a1 = Amphibians("青蛙")
    a1.swim()
    a1.run()
    a1.sleep()

    #获取方法的解析顺序
    print(Amphibians.mro())

main()

八.08_多态_鸭子类型

1
2
3
4
5
6
7
8
9
"""
多态： 变量a 在定义的时候类型是A, 在运行时类型是B, A是B的父类

静态语言：
java c++. C#，在编译就知道a中存放的数据类型

动态语言:
python ，没有多态， 所有变量都是没有数据类型的，在运行的时候才确定变量存放的数据类型
"""

九.09_类属性

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
class Person:

    #定义类属性
    count = 10

    def __init__(self,name,age):
        self.name = name
        self.age = age
        Person.count += 1

    #类方法
    @classmethod
    def get_count(cls):
        #cls代表当前的类,方法调用的时候，不需要传递参数
        return Person.count

    #静态方法
    @staticmethod
    def main():
        print("这是静态入口函数")
        #......
        print("静态方法执行结束")

def main():
    # print(Person.count)
    # p1 = Person("lucy",16)
    # print(Person.count)
    # p2 = Person("marry",18)

    # print(p1)
    # print(p2)
    # #访问类属性，通过 类名.属性
    # print(Person.count)
    #
    # #首先会去找对象的属性，如果对象没有该属性，才会去找类属性
    # print(p1.count)
    # print(p2.count)

    print(Person.get_count())

# main()
Person.main()

十.10_构造和析构

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
"""
构造函数: 通常指的是用来创建对象和给对象进行初始化操作的函数
析构函数：在创建的对象进行销毁的时候需要执行的函数，用户做相关的
        清理工作和资源的释放，它与构造函数的功能正好相反

__new__: 创建对象的函数，接受一个参数cls, 字节码对象，用来创建对象，并且需要返回当前所床架你的对象
__init__: 对创建的对象进行初始化赋值的操作
__del__:  当一个对象在内存中被销毁的时候回执行该方法

"""

class Student:

    def __new__(cls, *args, **kwargs):
        print("... new .... ")
        obj = object.__new__(cls)
        return obj

    def __init__(self,name,age):
        self.name = name
        self.age = age
        print("... init ....")

    #在程序结束，会释放资源, 或者 被当做垃圾回收的时候
    def __del__(self):
        print("... del ... ")

    @staticmethod
    def main():
        s1 = Student("marray",18)
        s1 = None
        print("main .... end ....")


Student.main()

十一.11_魔法方法和魔法属性

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
"""
魔法方法和魔法属性
在python中，有一些内置的特定的方法，这些方法在进行特定的操作时会自动被调用，称之为魔法方法
下面几种常见的魔法方法：
对于魔法方式， 总是以双下划线开头，双下划线结束 例如： __方法名称__
"""

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

    def __str__(self):
        return "Student: {'name':%s,'age':%s}"%(self.name,self.age)

    def __len__(self):
        return len(self.name)

    def __call__(self, *args, **kwargs):
        print("123")
        print("456")

    @staticmethod
    def main():
        s1 = Student("lucy",18)

        #调用了 __str__ 方法
        print(s1)

        #对象是哪个类创出来的
        print(s1.__class__)

        #该类的调用顺序
        print(Student.__mro__)

        #调用了 __len__方法
        print(len(s1))

        #调用了 s1.__call__方法
        print(s1())

Student.main()

参考资料