面向对象

1.类定义

• class是关键字，表示要定义类了
• 类的属性，即定义在类中的变量（成员变量）
• 类的行为，即定义在类中的函数（成员方法）

2.对象

创建类对象的语法：

class Stu:
    name = None
    age = None

student = Stu()

3.变量、方法

class Stu:
    name = None
    age = None

    # 注意：在类的方法参数中，要加入self参数，相当于java的this关键字（表示类对象本身）
    def say(self):
        print("hello")

self关键字

self关键字是成员方法定义的时候，必须填写的。

• 它用来表示类对象自身的意思
• 当我们使用类对象调用方法的是，self会自动被python传入
• 在方法内部，想要访问类的成员变量，必须使用self

注意：

传参时可以忽略

class Stu:
    name = None
    age = None

    # 注意：在类的方法参数中，要加入self参数，相当于java的this关键字（表示类对象本身）
    def say(self):
        print("hello")

student = Stu()
# 调用say方法时，不需要传入参数
student.say()

现实世界的事物也有属性和行为，类也有属性和行为。

使用程序中的类，可以完美的描述现实世界的事物

为什么非要创建对象才能使用呢？

类只是一种程序内的“设计图纸”，需要基于图纸生产实体（对象），才能正常工作**

这种套路，称之为：面向对象编程

代码中，为对象的属性赋值需要依次进行，略显繁琐。

使用构造方法可以简化赋值操作

描述

Python类可以使用：__init__()方法，称之为构造方法。

可以实现：

• 在创建类对象（构造类）的时候，会自动执行。
• 在创建类对象（构造类）的时候，将传入参数自动传递给____init__()__方法使用。

使用

class Stu:
    name = None
    age = None

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

    # 注意：在类的方法参数中，要加入self参数，相当于java的this关键字（表示类对象本身）
    def say(self):
        print("hello")

student = Stu("郜宇博",21)
print(student.age)
print(student.name)

注意

不要忘记init前后都有2个下划线

构造方法也是成员方法，不要忘记在参数列表中提供：self

构造方法内定义成员变量，需要使用self关键字

内置的类方法，各自有各自特殊的功能，这些内置方法我们称之为：魔术方法

方法

功能

init

构造方法，可用于创建类对象的时候设置初始化行为

str

用于实现类对象转字符串的行为

lt

用于2个类对象进行小于或大于比较

le

用于2个类对象进行小于等于或大于等于比较

eq

用于2个类对象进行相等比较

1.__str__()字符串方法

类似于java的toString()方法

在打印类对象时，将原来的打印内存信息转换为自定义打印格式

class Stu:
    name = None
    age = None

    # 注意：在类的方法参数中，要加入self参数，相当于java的this关键字（表示类对象本身）
    def say(self):
        print("hello")

    def __init__(self, name, age):
        self.name = name
        self.age = age
    def __str__(self):
        return f"姓名:{self.name},年龄:{self.age}"
student = Stu("郜宇博",21)
print(student)

2.__lt__()字符串方法

在进行比较时，可以直接使用 > < 符号进行比较（指定比较的数据）

class Stu:
    name = None
    age = None

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

    # Less than的简称
    def __lt__(self, other):
        return self.age < other.age
student_1 = Stu("郜宇博",21)
student_2 = Stu("郜宇博",50)
# 相当于比较年龄的大小
print(student_1 < student_2)

面向对象包含3大主要特性：

• 封装
• 继承
• 多态

现实世界中的事物，有属性和行为。

但是不代表这些属性和行为都是开放给用户使用的

既然现实事物有不公开的属性和行为，那么作为现实事物在程序中映射的类，也应该支持。

描述

类中提供了私有成员的形式来支持。

• 私有成员变量
• 私有成员方法

在类中定义的私有变量和方法只能类的内部使用

只需要在定义变量、方法名时前面添加两个下划线符号__

class Stu:
    name = None
    age = None
    __gender = '男'

stuent = Stu()
print(stuent.gender)

每一款手机都是基于老款的设计图，修修改改

1. 代码

如下代码很复杂，需要引入继承来简化代码

引入继承

如下为多继承

pass关键字

代表不执行，空实现，可以用来构建空类，空方法，抽象方法

2. 多继承

注意

多个父类中，如果有同名的成员，那么默认以继承顺序（从左到右）为优先级。

即：先继承的保留，后继承的被覆盖

3. 复写

子类继承父类的成员属性和成员方法后，如果对其“不满意”，那么可以进行复写。

即：在子类中重新定义同名的属性或方法

class Stu:
   name = None
   age = None

   def    say(self):
      print("我是学生")

class Man(Stu):
   gender = '男'
   def say(self):
      print("我是男学生")

student = Man()
# 相当于调用Man类重写的say()方法
student.say()

4.调用父类

方式1：使用父类名调用

• 使用成员变量：父类名.成员变量
• 使用成员方法：父类名.成员方法(self)

方式2：使用super()调用父类成员

• 使用成员变量：super().成员变量

• 使用成员方法：super().成员方法(

  class Stu:
  name = None
  age = None

  def say(self):
      print("我是学生")

  class Man(Stu):
  gender = '男'
  def say(self):
  print("我是男学生")
  def student_say(self):
  # 调用了父类的方法,两种方法都可以
  # Stu.say(self)
  super().say()

  student = Man()

  此方法中调用了父类的方法

  student.student_say()

在PyCharm中编写代码，我们经常能够见到如下提示：

因为：PyCharm确定这个对象，是list类型

但是自定义一个函数func，接收一个参数data

PyCharm不会在做出任何提示了

此时使用类型注释就可以帮助编辑器进行代码提示或编写人员的自我提示

注意：

不会真正的对类型做验证和判断。

也就是，类型注解仅仅是提示性的，不是决定性的

1.变量的类型注释

在变量名后加入冒号：和数据类型

from typing import Dict, List
# int类型
var_1: int = 10
# str类型
var_2: str = "adsad"
# list类型
var_3: list = [1, 2, 3]
var_3_1: List[int] = [1, 2, 3]
# dict类型
var_4: dict = {"age": 10, "name": 20}
var_4_1: Dict[str, int] = {"age": 10, "name": 20}

# 类对象
class Student:
    pass

s: Student = Student()

或者使用注释的方法

2.函数

形参的类型注释

def func(data : list):
    pass

表明类型后，就可以对变量进行代码提示了

返回值的类型注释

def func(data : list) -> int:
    pass

3. Union类型

当列表、字典中数据类型不一致时，需要使用到该函数

Union[类型1，类型2]

from typing import List, Union

var : List[Union[int, str, bool]] = [1, "sss", True]

多态，指的是：多种状态，即完成某个行为时，使用不同的对象会得到不同的状态。

抽象类

class AC:
    def cold(self):
        pass
    def hot(self):
        pass

使用

class AC:
   def cold(self):
      pass
   def hot(self):
      pass

class Midea(AC):
   def cold(self):
      print("美的cold")

   def hot(self):
      print("美的hot")

class Gree(AC):
   def cold(self):
      print("格力cold")

   def hot(self):
      print("格力hot")

def to_cold(ac : AC):
   ac.cold()

gree : Gree = Gree()
midea : Midea = Midea()

to_cold(gree) # 输出格力cold