初入Python 面向对象~~~~学习记录

目录

一、类的定义与创建：

- 简单创建：

- 类属性：

二、实例对象

- 实例对象方法： 类名()

- 实例对象方法： _ _ init _ _ 方法

三、方法

- 实例方法

- 静态方法

- 类方法

四、类的继承

- 继承：

- 继承中的方法覆盖

- 引用父类方法

- 类的多重继承

- dir(object)和object.dict

五、练习

---

 class DogCat(object):  # 类名的命名规则：大驼峰写法(每个单词的首字母大写)
    pass

 

学习记录~~~部分(学习ing~)

一、类的定义与创建：

定义：类(抽象的概念): 拥有着相同的特征(属性)和行为(方法)。

- 简单创建：

简单创建：

• 类名的命名规则：大驼峰写法(每个单词的首字母大写)

• class关键字创建

类的简单创建，

 class DogCat(object):  # 类名的命名规则：大驼峰写法(每个单词的首字母大写)
    pass

- 类属性：

类属性：

• 类属性的赋予

 class Student(object):
    # 类属性
    class_name = "8班"  
    student_num = 30

这里创建了一个学生类后，又赋予了班级名和学生人数这个两个属性。而他们就是类属性。

• 类属性的访问

   class Student(object):
      # 类属性
      class_name = "8班"
      student_num = 30
  
  # 方法一   # 直接通过： 类名.类属性
  print(Student.student_num)
  
  # 方法二   # 先实例化对象，通过：实例对象.属性 来查找
  s = Student()
  print(s.student_num)
  
  

  在上面代码中的方式二：它先实例化对象，通过：实例对象.属性 来查找，但是实例化对象的空间里没有student_num 这个属性，它就会继续在类空间里去找(或者去它继承的类里找)。

• 类属性的修改

class Student(object):
    # 类属性
    class_name = "8班"
    student_num = 30
    name = "土狗"


# 类属性的修改 : 类名.属性名  ，如果没该属性就新建属性；如有，就修改它
Student.name = "憨猫"  # 修改
Student.age = 100  # 新建

print(Student.name)
print(Student.age)

直观结果：

 

二、实例对象

定义的类只有进行实例化，也就是使用该类创建对象之后，才可以利用。

- 实例对象方法： 类名()

 class Student(object):
    # 类属性
    class_name = "8班"
    student_num = 30
 
s = Student() # 实例化对象

- 实例对象方法： _ _ init _ _ 方法

当我们需要多个实例对象的时候，第一种方法就会造成代码的冗余，因此就有了__init__方法的作用了。
来个例子看看：

class Student(object):
    # 类属性
    name = "华子"

    # 方法
    def __init__(self, name, age):  # 形参，接收实参的传入
        self.name = name  # 对于这里的参数，前面的name是我们可以再自定义的，而后面的name是不可以变的，因为它要与我们的新参保持一致，就相当于函数里的传参
        self.age = age

    def eat(self):
        print('华子在吃饭')


s1 = Student('土狗', '18')  # 实参 ，参数的多少都可以自定义
s2 = Student('憨猫', '19')
s3 = Student('猪猪侠', '20')

print(s1.name)
print(s2.name)
print(s3.name)

print(s1.age)

 这里注意的是，Student()实例化后才会赋值给 s1 等变量，而Student()实例化的时候它会自动的触发__init__方法，而我们又可以认为self就是s1，因为下图：

 

这里打印出了self和s1的id值，发现他们是相同的~~~所以，self就是s1,而self.属性名就是s1.属性名，self.属性名就是在向 s1 这个实例空间里创建实例属性。再就是这里的实参与形参的传入与接收，它是和函数的实参与形参相似的。

• 实例对象的属性赋予：实例对象.属性名

 

class Student(object):
    # 类属性
    class_name = "8班"
    student_num = 30
    name = "土狗"


s = Student()
s.name = '华仔'
s.age = 18

print(s.name)  # 查找name属性时，发现类空间和实例空间都有name属性，
# 但实例对象会优先在自己空间去查找

 

所以会有：

• 实例对象.属性名 的查找先后顺序是：它先在自己的实例空间去找，如无；再到类空间去找，如无；再到该类所继承的类中去找；如都无，那就报错~~~~~~~
• 对象通过句点符调用属性和方法 ： 对象.属性/方法
  代码：

class Student(object):
    # 类属性
    name = "华子"

    def eat(self):
        print('华子在吃饭')

    def sleep(self):
        print('华子要睡觉')


s = Student() 
print(s.name)  # 对象调用属性
s.eat()  # 调用方法

 

 

三、方法

- 实例方法

有self的方法就是实例方法，但是self这个名字并不是不变的，它可以是其他值，但规范习惯用self了，
self表示当前对象

self并不是一个关键字，其实可以是任意的标识符，为了表达代表的是当前对象自己，习惯用self
调用实例函数的时候，self不需要手动传参，系统会自动传递当前的对象.
哪个对象调用了方法，方法里的self指的就是谁。
实例方法调用：
代码：
 

class Student(object):
    # 类属性
    class_num = 30
    class_name = '8班'

    # 方法
    def __init__(self, name, course):
        self.name = name
        self.course = course

    def listen(self):
        print('%s在听%s课' % (self.name, self.course))  # self 中有name，course

    def homework(self):
        print('%s在写%s课作业' % (self.name, self.course))


s1 = Student('华仔', 'python')  # 实参传入
s1.listen()

s2 = Student('我', 'python')
s2.homework()

在上面的代码中：s1.listen() ,这个调用方法，解释器会将 s1 这个对象作为实参传给该方法的第一个形参(self).

- 静态方法

代码：

class Sum(object):

    @staticmethod
    def add(x, y):   # 这里是没有self这个参数的
        return x + y


# 实例对象调用静态方法：
s = Sum()
print(s.add(2, 6))

# 类对象调用静态方法：
print(Sum.add(6, 6))

- 类方法

代码：

class Sum(object):
    # 类属性
    num = 30

    @classmethod
    def add_num(cls):  # 这里加了 @classmethod 后，解释器会自动加上 cls 这个参数。
        print(id(Sum), id(cls))
        cls.num += 1


Sum.add_num()
print(Sum.num)

 

 在上面发现：参数cls与Sum类的地址相同。所以cls就是当前的类对象。Sum这个类对象作为cls的接收者。

四、类的继承

- 继承：

继承：是子类复用父类的属性和方法的机制。在Python中，新建的类可以继承一个或多个父类。注意：object 是 Python 中所有类的根类。
单继承：子类之继承一个父类，被称为单继承。
多继承：子类可以拥有多个父类，并且具有所有父类的属性和方法。

父类： 又可称为基类或超类
新建的类： 称为派生类或子类
代码：
简单例子： 

 class Animal(object):
    def eat(self):
        print('吃')

    def sleep(self):
        print('睡')


class Dog(Animal):  # 继承 Animal 父类
    def bark(self):
        print('狂吠')


class Cat(Animal):
    def climetree(self):
        print('爬树')


s1 = Dog()
s2 = Cat()
s1.eat()
s2.sleep()

 子类没有的属性可以到他继承的父类里去找。

- 继承中的方法覆盖

代码：

class Animal(object):
    def eat(self):
        print('吃')

    def sleep(self):
        print('睡')


class Dog(Animal):  # 继承 Animal 父类
    def bark(self):
        print('狂吠')

    def sleep(self):
        print('睡睡睡睡。。。。。')  # 虽然继承了父类的sleep，但子类写了个sleep方法，就覆盖了，但对父类不影响


class Cat(Animal):
    def climetree(self):
        print('爬树')


s1 = Dog()
s1.sleep()

s2 = Cat()
s2.sleep()

 

- 引用父类方法

• 例子1 

 class Animal(object):

    def __init__(self):
        self.parent = '我是父类'
        print(id(self))
        print('父类')

    def sleep(self):
        print('我是父类的睡')


class Dog(Animal):  # 继承 Animal 父类

    def sleep(self):
        super(Dog, self).sleep()  # super 会首先找到 Dog 的父类（就是类 Animal），然后把类Dog的对象(s)转换为类Animal的对象(self),因为他们的id值相同
        print('我是子类的睡睡睡睡。。。。。')
        print(self.parent) # 找到父类的parent属性


d = Dog()  # 别忘了，它会找__init__方法
d.sleep()
print(id(d))

 注意：super 会首先找到 Dog 的父类（就是类 Animal），然后把类Dog的对象(s)转换为类Animal的对象(self),因为他们的id值相同

• 例子2 ：

class Parent(object):
    def __init__(self):
        self.parent = '我是父类'
        print(id(self))
        print('父类')

    def bar(self):
        print("我是父类的bar")


class Child(Parent):
    def __init__(self):
        # super(Child,self) 首先找到 Child 的父类（就是类 Parent），然后把类Child的对象(s)转换为类Parent的对象(self),他们的id值相同。
        super().__init__()  # super(Child, self).__init__()
        print('子类')

    def bar(self):
        super().bar()  # super().bar(message)
        print('我是子类的bar')
        print(self.parent) # Child的对象(s)已经转换为类Parent的对象(self)


s = Child()  # 实例化 Child 对象
s.bar()  # 调用s的bar方法
print(id(s))

 

super().init() # 也可以写成： super(Child, self).init() 。

- 类的多重继承

代码：

class Animal(object):
    def eat(self):
        print('吃')


class Fly(object):
    def fly(self):
        print('飞')


class Dog(object):
    pass


class BigBird(Animal, Dog, Fly):
    pass


class LittleBird(Fly, Animal):
    pass

b = BigBird()
b.fly()

c = LittleBird()
c.fly()

 

对于多个类的继承时，子类继承是有顺序的：从左向右继承

再就是：

• type()方法 ： 除了判断字符串等类型，它还可以判断 实例对象是属于那个类。

print(type(b))
print(type(c))

• isinstance()方法 : 判断某个对象是不是某个类的实例，是就True,否就False，但如果是true，那他继承的父类也是true.
  代码：

 

print(isinstance(b, BigBird))
print(isinstance(b, Fly))
print(isinstance(b, LittleBird))

 

- dir(object)和object.dict

• dir(object) 和 object.dir() 是等价的。dir()方法可获取对象的所有属性和方法，并以列表形式返回。

print(dir(b))
print(c.__dir__())  

 

他们返回的顺序不同，但内容是一样的。~~~~

• object__dict__ 它可以获取对象自定义的属性，且以字典形式返回。
  代码：

print(c.__dict__)

 注意的是：在dir(object)中，它相当于只是拿出了key，在object__dict__ 中它将 key 和 value都拿出来了。

五、练习