对象

  • 设计一个类
1
2
3
class student:
    name = None
    age = None
  • 创建一个对象
1
stu1 = student()
  • 对对象进行赋值
1
2
stu1.name = "日奈"
stu1.age = 17
  • 类里面也可以添加函数

class xxx:

​ def xxxx(self): //self必须存在用来表示类对象自身的意思

​ xxx //不过在传入参数时不用理它

如果有成员变量要传入到成员方法，要加self.

1
2
3
4
class student:
    name = None
    def s(self):
    	print(f"我是{slef.name}")
  • 成员方法也可以继续添加元素
1
2
3
4
5
6
7
class student:
    name = None
    def s(self,str):
    	print(f"我是{slef.name},{str}") //其中str因为是全局变量，所以不用加self.
stu1 = stu()
stu1.str("你好你好")

构造方法

因为一个个定义变量太麻烦，所以可以在函数中添加构造方法解决

1
2
3
4
5
6
7
class student:
    name = None
    age = None
    def __init__(self,name,age):
        self.name = name
        self.age = age
student1 = student("日奈",17)

因为构造方法里已经有属性了，所以name之类的可以不写了，直接写构造方法

1
2
3
4
5
class student:
    def __init__(self,name,age):
        self.name = name
        self.age = age
student1 = student("日奈",17)

魔术方法

魔术方法也就是python的内置方法，__ init __就是其中一种

__ str __

当类对象需要转为字符串时，用print(str(xxx))的话，结果会输出内存地址，但我们并不需要这个，所以要用魔术方法

1
2
3
4
5
6
7
class student:
    name = None
    age = None
	 def __str__(self):
        return f'{self.name} is {self.age} years old'
student1 = student("日奈",17)
print(student1)

print之后会按照__ str __的格式输出

__ lt __

可同时完成<,>的比较

1
2
3
4
5
6
7
8
9
10
class student:
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def __lt__(self,other):
        return self.age < other.age

student1 = student("日奈",17)
student2 = student("佳代子",18)
print(student1 < student2)

__ le __

可同时完成<=,>=的比较

逻辑跟lt一样

__ eq __

可用于==的判断

封装

私有成员

私有成员变量和方法只要在前面加上__即可

例子：

1
2
3
4
5
6
7
8
9
10
11
12
13
class phone:
    __is_5g_enable = False
    def __check_5g(self):
        if self.__is_5g_enable:
            print(f"5g开启")
        else:
            print(f"5g关闭，用4g网络")
    def call_by_5g(self):
        self.__check_5g()
        print("正在通话中")a

p = phone()
p.call_by_5g()

继承

单继承

格式：

class 类名(父类名):

​ 类内容体

多继承

格式：

class 类名(父类名1,父类名2,…):

​ 类内容体

如果继承后也不想在添加什么，那么可以写上pass来替代，保证语法不报错

复写

跟java的重写一样，继承之后def重写即可

变量和方法都能复写

调用父类同名成员

如果想调用被复写的父类的原有形式，有两种方法

  1. 父类名.成员变量

    父类名.成员方法(self)

  2. super().成员变量

​ super().成员方法()

类型注解

可以在写代码时理解某个变量的类型

格式：

变量名： 类型

如： name: str = “xxx”

​ stu: Student = Student()

多态

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
class Animal:
    def speak(self):
        pass

class Dog(Animal):
    def speak(self):
        print("wang")
class Cat(Animal):
    def speak(self):
        print("miao")

cat = Cat()
cat.speak()
dog = Dog()
dog.speak()

其中speak方法也叫做抽象类或接口，带有pass，子类必须重写接口才能使用