类的定义

面向对象编程提供了一种有效的软件管理方式，通过编写描述现实世界中的事物和情景的类，可以定义同类对象的通用行为，继承父类的子类可以定制个性化的行为。

根据类创建对象的过程称为实例化，指定可在实例中存储什么信息，定义可对这些实例执行哪些操作。

python通过class关键字定义类，__init__方法定义构造函数，类名(参数)进行实例化。举例：

.
├── main.py
└── modules
    └── cat.py

#modules/cat.py
class Cat:
     #构造函数，self指向对象引用
     def __init__(self,name,age):
        self.name=name
        self.age=age
     #模拟猫叫
     def meow(self):
         print(f"Cat({self.name}) goes meow.")
     #模拟跑动
     def run(self):
         print(f"Cat({self.name}) is running.")

#main.py
from modules.cat import Cat

cat=Cat('meimei',3)
cat.run()

对比java，java也是通过class关键字定义类，构造函数名跟类名同名，通过new关键字进行实例化。

package test;

public class Cat {
    private String name;
    private int age;
    
    public Cat(String name,int age)
    {
    	  this.name=name;
    	  this.age=age;
    }
	
    public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
    
	public void meow()
	{
		System.out.println("Cat("+name+") goes meow.");	
	}
	public void run()
	{
		System.out.println("Cat("+name+") is running.");	
	}
}

package test;

public class Test {
	
	public static void main(String[]str)
	{
		Cat cat=new Cat("meimei",3);
		cat.run();
	}
}

可见性

我们可以在构造函数中对类的属性设置默认值，访问或者修改实例化的对象的属性值。python中类的属性或方法的可见性包括：公开/私有，并没有像java一样那样严格的语法限制，私有通过添加“__”实现。

除非有必要，否则不建议将属性设置为私有的，会导致子类无法访问。还有一种命名惯例是让属性名以单下划线开头，这是非语法强制的，外界仍旧可以访问，只是一种“属性是受保护的”暗示。

对比java，java类的可见性包括：公共/受保护/私有，通过关键字public/protected/public进行语法限制。

#modules/cat.py
class Cat:
     #构造函数
     def __init__(self,name,age):
        self.name=name
        self.__age=age
     #模拟猫叫
     def meow(self):
         print(f"Cat({self.name}) goes meow.")
     #模拟跑动
     def __run(self):
         print(f"Cat({self.name}) is running.")

from modules.cat import Cat

cat=Cat('meimei',3)
print(cat.name)
cat.name='meimei2'
print(cat.name)
#无法访问
#print(cat.age)
#无法访问
#cat.run()

继承

编写类时，并非总是要从空白开始。如果要编写的类是另一个现成类的特殊版本，可使用继承。一个类继承另一个类时，将自动获得另一个类的所有属性和方法。

原有的类称为父类，而新类称为子类。子类继承了父类的所有属性和方法，同时还可以定义自己的属性和方法。

#modules/cat.py
class Cat:
     #构造函数
     def __init__(self,name,age):
        self.name=name
        self.age=age
     #模拟猫叫
     def meow(self):
         print(f"Cat({self.name}) goes meow.")
     #模拟跑动
     def run(self):
         print(f"Cat({self.name}) is running.")

#加菲猫
class GarfieldCat(Cat):
    def __init__(self,name,age,color):
        #调用父类的构造函数
        super().__init__(name,age)
        #新增属性
        self.color=color
    #重写父类的方法，模拟跑动
    def run(self):
        print(f"Cat({self.name}) is slow running.")
    #新增方法，展示颜色
    def show_color(self):
        print(f"Cat({self.name})  is {self.color}")

from modules.cat import *

cat=GarfieldCat('meimei',3,'black')
cat.run()
cat.show_color()

输出结果:
Cat(meimei) is slow running.
Cat(meimei)  is black

对比java，java子类通过关键字extends继承父类。

注意：如果将GarfieldCat类单独作为一个模块文件garfield_cat.py，这时候会报ModuleNotFoundError: No module named 'cat'，解决方式是添加模块路径。

#modules/cat.py
class Bell:
     def __init__(self):
         self.size=1
     def sound(self):
         print("The bell makes a sound.")
class Cat:
     #构造函数
     def __init__(self,name,age):
        self.name=name
        self.age=age
     #模拟猫叫
     def meow(self):
         print(f"Cat({self.name}) goes meow.")
     #模拟跑动
     def run(self):
         print(f"Cat({self.name}) is running.")

#modules/garfield_cat.py
from cat import Bell,Cat
#加菲猫
class GarfieldCat(Cat):
    def __init__(self,name,age,color,bell):
        #调用父类的构造函数
        super().__init__(name,age)
        #新增属性
        self.color=color
        self.bell=bell
    #重写父类的方法，模拟跑动
    def run(self):
        print(f"Cat({self.name}) is slow running.")
        self.bell.sound()
    #新增方法，展示颜色
    def show_color(self):
        print(f"Cat({self.name})  is {self.color}")

import sys

#这里需要添加模块查询路径，否则会报ModuleNotFoundError
sys.path.append("./modules/")
print("sys.path:",sys.path)

from modules.cat import Bell
from modules.garfield_cat import GarfieldCat


bell=Bell()
cat=GarfieldCat('meimei',3,'black',bell)
cat.run()
cat.show_color()

将实例作为属性

使用代码模拟实物时，你可能会发现自己给类添加的细节越来越多：属性和方法清单以及文件都越来越长。在这种情况下，可能需要将类的一部分提取出来，作为一个独立的类。可以将大型类拆分成多个协同工作的小类。

#modules/cat.py
class Bell:
     def __init__(self):
         self.size=1
     def sound(self):
         print("The bell makes a sound.")
class Cat:
     #构造函数
     def __init__(self,name,age):
        self.name=name
        self.age=age
     #模拟猫叫
     def meow(self):
         print(f"Cat({self.name}) goes meow.")
     #模拟跑动
     def run(self):
         print(f"Cat({self.name}) is running.")

#加菲猫
class GarfieldCat(Cat):
    def __init__(self,name,age,color,bell):
        #调用父类的构造函数
        super().__init__(name,age)
        #新增属性
        self.color=color
        self.bell=bell
    #重写父类的方法，模拟跑动
    def run(self):
        print(f"Cat({self.name}) is slow running.")
        self.bell.sound()
    #新增方法，展示颜色
    def show_color(self):
        print(f"Cat({self.name})  is {self.color}")

from modules.cat import *
bell=Bell()
cat=GarfieldCat('meimei',3,'black',bell)
cat.run()
cat.show_color()

输出结果:
Cat(meimei) is slow running.
The bell makes a sound.
Cat(meimei)  is black

Python标准库

Python标准库是一组模块，安装Python的时候已经包含，只需要在开头包含一条简单的import语句，就可以使用标准库中的函数和类。

Python常用的标准库有：1、与操作系统交互相关的函数库os；2、与解析器和系统相关的库sys；3、用于生成随机数的库random；4、提供了数学常数和数学函数的库math；5、与日期和时间相关的库datetime。

当然还有其他更高级的功能库，使用的时候参考相关资料。

from random import randint
#生成1-10之间的随机整数
print(randint(1,10))