Python--类 所有相关知识以及代码实现，下附有 代码测试

代码区

#在面向对象编程中，编写表示现实世界的事物以及情景的类，基于类来创建对象，每个对象都自动具备这种通用行为
#根据类来创建对象被称为 实例化

#创建类和使用类
#创建Dog类--根据在Python中的约定，首字母大写的名称指的是类，这个类定义中的括号是空的，因为我们要从空白创建这个类
#小写的名称是根据类创建的实例
class Dog():
    """模拟小狗的简单尝试"""
    def __init__(self,name,age):  #类中的函数叫做 方法，每次根据Dog类创建新实例，python都会自动运行它，这种方法的名称开头结尾有两个下划线
    #在这个方法的定义中，形参self必不可少，而且只能放在其他形参的前面，每次调用这个方法，将自动传入实参self。
    #每一个与类相关联的方法调用都自动传递实参self,他是一个指向实例本身的引用，让实例可以访问类中的属性和方法
    #我们调用类的方法_init_()创建Dog(),我们将通过实参向Dog()传递名字和年龄
    #self会自动传递，所以不需要传递它；
    #每当我们根据Dog类创建实例，都只需要给最后两个形参提供值
        
        """初始化属性 name,age"""
    
        self.name=name
        #以self为前缀的变量可以供类中所有方法使用，我们可以通过类中任何实例来访问这些变量
        #获取存储在形参name中的值，并将其存储在 name中   --通过实例访问的变量称为  属性
        self.age=age
    def sit(self):
        """模拟小狗被命令蹲下"""
        print(self.name.title()+" is now sitting.")

    def roll(self):
        """模拟小狗被命令时打滚"""
        print(self.name.title()+" rolled over")

#根据类创建实例
my_dog=Dog('willie',6)   #使用实参调用 方法，并未显式包含return语句，但是自动返回一个表示这条小狗的实例
your_dog=Dog('jen',3)
print("my dog 's name is"+my_dog.name.title()+'.')   #访问属性
print("my dog is "+str(my_dog.age)+"years old .")
my_dog.sit()
my_dog.roll()
your_dog.sit()
#注意：就算给第二条小狗指定同样的名字和年龄，python依然会根据Dog类创建另一个实例，
#条件是每一个实例都存储在不同的变量，或者是占用列表字典的不同位置

#使用类和实例
class Car():
    """一次模拟汽车的简单尝试"""
    def __init__(self,make,model,year):
        """初始化描述汽车的属性"""
        self.make=make;
        self.model=model
        self.year=year
        self.odometer=0

    def get_name(self):
        """返回整洁信息"""
        long_name=str(self.year)+' '+self.make+' '+self.model
        return long_name.title()
    def read_odometer(self):
        """打印一条里程消息"""
        print("this car has "+str(self.odometer)+' miles on it')
my_car=Car('audi','a3',2018)
print(my_car.get_name())
my_car.read_odometer()

#给属性指定默认值--每个属性都要有初始值，哪怕是0或者空字符串；设置默认值的时候，__init__()可以指定初始值


#修改属性的值
#1--通过实例直接进行修改属性的值
my_car.odometer=23
my_car.read_odometer()

#通过方法修改属性
class Car():
    """一次模拟汽车的简单尝试"""
    def __init__(self,make,model,year):
        """初始化描述汽车的属性"""
        self.make=make;
        self.model=model
        self.year=year
        self.odometer=0

    def get_name(self):
        """返回整洁信息"""
        long_name=str(self.year)+' '+self.make+' '+self.model
        return long_name.title()
    def read_odometer(self):
        """打印一条里程消息"""
        print("this car has "+str(self.odometer)+' miles on it')
    
    def update_odometer(self,mileage):
        """指定里程读数"""
        self.odometer=mileage
my_car=Car('audi','a3',2018)
print(my_car.get_name())
my_car.update_odometer(23)
my_car.read_odometer()

#禁止里程读数往回调
class Car():
    """一次模拟汽车的简单尝试"""
    def __init__(self,make,model,year):
        """初始化描述汽车的属性"""
        self.make=make;
        self.model=model
        self.year=year
        self.odometer=0

    def get_name(self):
        """返回整洁信息"""
        long_name=str(self.year)+' '+self.make+' '+self.model
        return long_name.title()
    
    def read_odometer(self):
        """打印一条里程消息"""
        print("this car has "+str(self.odometer)+' miles on it')
    
    def update_odometer(self,mileage):
        """指定里程读数,禁止回调"""
        if mileage >=self.odometer:
            self.odometer=mileage
        else:
            print('you cannot roll back')
        
my_car=Car('audi','a3',2018)
print(my_car.get_name())
my_car.update_odometer(23)
my_car.read_odometer()

#通过方法对属性的值进行递增
class Car():
    """一次模拟汽车的简单尝试"""
    def __init__(self,make,model,year):
        """初始化描述汽车的属性"""
        self.make=make;
        self.model=model
        self.year=year
        self.odometer=0

    def get_name(self):
        """返回整洁信息"""
        long_name=str(self.year)+' '+self.make+' '+self.model
        return long_name.title()
    
    def read_odometer(self):
        """打印一条里程消息"""
        print("this car has "+str(self.odometer)+' miles on it')
    
    def update_odometer(self,mileage):
        """指定里程读数"""
        self.odometer=mileage

    def increment(self,miles):
        """将里程碑读数增加特定的量"""
        self.odometer+=miles

my_car=Car('subaru','outback',2019)
print(my_car.get_name())
my_car.update_odometer(2300)
my_car.read_odometer()
my_car.increment(100)
my_car.read_odometer()

#继承：编写类并非从空白开始， 原有的类：父类  ，而新类 称为子类。子类继承了父类的所有属性和方法，同时还可定义自己的属性按到方法
#子类 的方法：__init__  创建子类的实例时，首先需要给父类所有属性赋值，以下例子为 模拟电动车（具备车的所有功能）

class Car():
    """一次模拟汽车的简单尝试"""
    def __init__(self,make,model,year):
        """初始化描述汽车的属性"""
        self.make=make;
        self.model=model
        self.year=year
        self.odometer=0

    def get_name(self):
        """返回整洁信息"""
        long_name=str(self.year)+' '+self.make+' '+self.model
        return long_name.title()
    
    def read_odometer(self):
        """打印一条里程消息"""
        print("this car has "+str(self.odometer)+' miles on it')
    
    def update_odometer(self,mileage):
        """指定里程读数"""
        self.odometer=mileage

    def increment(self,miles):
        """将里程碑读数增加特定的量"""
#创建子类时，父类必须包含在当前文件中，且位于子类前面；在子类括号内指定父类的名称
        self.odometer+=miles
class ElectricCar(Car):
    """电动车的独特之处"""
    def __init__(self,make,model,year):
        """初始化父类的属性"""
        super().__init__(make,model,year)      #super()是一个特殊函数，帮助pyhton 关联父类与子类，这句代码让pyhotn调用父类的方法__init__,让子类的实例包含父类所有属性
my_tesla=ElectricCar('tesla','model s',2016)
print(my_tesla.get_name())

#给子类定义属性和方法：让一个类继承另一个类后，可以添加区分子类和父类的新属性和方法
class Car():
    """一次模拟汽车的简单尝试"""
    def __init__(self,make,model,year):
        """初始化描述汽车的属性"""
        self.make=make;
        self.model=model
        self.year=year
        self.odometer=0

    def get_name(self):
        """返回整洁信息"""
        long_name=str(self.year)+' '+self.make+' '+self.model
        return long_name.title()
    
    def read_odometer(self):
        """打印一条里程消息"""
        print("this car has "+str(self.odometer)+' miles on it')
    
    def update_odometer(self,mileage):
        """指定里程读数"""
        self.odometer=mileage

    def increment(self,miles):
        """将里程碑读数增加特定的量"""
#创建子类时，父类必须包含在当前文件中，且位于子类前面；在子类括号内指定父类的名称
        self.odometer+=miles
class ElectricCar(Car):
    """电动车的独特之处"""
    def __init__(self,make,model,year):
        """初始化父类的属性，再初始化电动汽车特有属性"""
        super().__init__(make,model,year)
        self.battery=70
    def des_battery(self):
        """打印一条属于电瓶容量的消息"""
        print('this car has a '+str(self.battery)+'-kwh battery')
my_tesla=ElectricCar('tesla','model s',2016)
print(my_tesla.get_name())
my_tesla.des_battery()

#重写父类方法： 在子类中定义一个这样的方法--要与重写的父类方法同名

#将实例用作属性（随着属性，方法增多，需要将类的一部分 作为一个 独立的类 提取出来
class Car():
    """一次模拟汽车的简单尝试"""
    def __init__(self,make,model,year):
        """初始化描述汽车的属性"""
        self.make=make;
        self.model=model
        self.year=year
        self.odometer=0

    def get_name(self):
        """返回整洁信息"""
        long_name=str(self.year)+' '+self.make+' '+self.model
        return long_name.title()
    
    def read_odometer(self):
        """打印一条里程消息"""
        print("this car has "+str(self.odometer)+' miles on it')
    
    def update_odometer(self,mileage):
        """指定里程读数"""
        self.odometer=mileage

    def increment(self,miles):
        """将里程碑读数增加特定的量"""
        self.odometer+=miles
#创建子类时，父类必须包含在当前文件中，且位于子类前面；在子类括号内指定父类的名称

class Battery():   #一个新的类
    """一次模拟电动汽车电瓶的简单尝试"""
    def __init__(self,battery_size=38):
        """初始化电瓶属性"""
        self.battery_size=battery_size
    def des_battery(self):
        """打印一条消息，描述电瓶容量"""
        print("this car has a "+str(self.battery_size)+" -kwh battery.")

class ElectricCar(Car):
    """电动车的独特之处"""
    def __init__(self,make,model,year):
        """初始化父类的属性，再初始化电动汽车特有属性"""
        super().__init__(make,model,year)
        self.battery=Battery()  #该实例存储在self.battery中

my_tesla=ElectricCar('tesla','model s',2016)
print(my_tesla.get_name())
my_tesla.battery.des_battery()


#导入类
#导入单个类  from 文件名  import 类名
from car import Car
new_car=Car('audi','ed',2034)
print(new_car.get_name())
new_car.odometer=23
new_car.read_odometer()

#在同一个模块中存储多个类
from car import ElectricCar
my_tesla=ElectricCar('tesla','model s',2019)
print(my_tesla.get_name())
my_tesla.battery.des_battery()
my_tesla.battery.get_range()

 
#从一个模块中导入多个类   --逗号区分 所需要的类
from car import Car,ElectricCar
my_tesla=Car('jen','small',2087)
print(my_tesla.get_name())

my_colin=Car('colin','hand',346)
print(my_colin.get_name())

#导入整个模块，再使用句号表示法 访问需要的类；由于创建类实例的代码都包含模块名，因此不会与当前文件使用的任何名称冲突
import car
my_colin =car.Car('jen','sc',520)
print(my_colin.get_name())
my_jenny=car.ElectricCar('ted','tgh',346)
print(my_jenny.get_name())

#导入模块中所有的类    from 模块名字  import *   --容易引起名称错误

#在一个模块中导入另一个模块   from 模块名 import 类名
from car import Car
from electric import ElectricCar
my_jenney=Car('laoshi','d5',567)
print(my_jenney.get_name())

my_colin=Car('loso','tnt',879)
print(my_colin.get_name())

#python 标准库--一组模块
from collections import OrderedDict   #from 模块名  import  类
favorite=OrderedDict()  #首先创建了一个实例，并将其存储在了favorite中，记录了键值对的添加顺序
favorite['jen']='python'
favorite['sarash']='c'
favorite['colin']='c++'
for name,language in favorite.items():
    print(name.title()+" 's favorite language is "+
          language.title()+'.')


#类编码风格
#1.类名采用 驼峰命名法，首字母大写，不用下划线；实例名和模块名小写用下划线。
#2.每一个类定义后面，跟一个 文档字符串；每一个模块也包含一个文档字符串
#3.在类中，用一个空行分隔方法；在模块中，用两个空行分隔类
#4.导入模块时，先导入import语句，再添加一个空行，导入自己编写的import语句。

测试区

my dog 's name isWillie.
my dog is 6years old .
Willie is now sitting.
Willie rolled over
Jen is now sitting.
2018 Audi A3
this car has 0 miles on it
this car has 23 miles on it
2018 Audi A3
this car has 23 miles on it
2018 Audi A3
this car has 23 miles on it
2019 Subaru Outback
this car has 2300 miles on it
this car has 2400 miles on it
2016 Tesla Model S
2016 Tesla Model S
this car has a 70-kwh battery
2016 Tesla Model S
this car has a 38 -kwh battery.
2034 Audi Ed
this car has 23 miles on it
2019 Tesla Model S
this car has a 38 -kwh battery.
this car can go approximately 240 miles on a full charge.
2087 Jen Small
346 Colin Hand
520 Jen Sc
346 Ted Tgh
567 Laoshi D5
879 Loso Tnt
Jen 's favorite language is Python.
Sarash 's favorite language is C.
Colin 's favorite language is C++.
>>>