Python学习笔记（五）————类和实例

1、创建和简单使用

类可以反映现实的事物

代码：

class Dog():  # 类名首字母大写
    """模拟小狗的简单测试"""

    def __init__(self, name, age):  # 该方法在类创建的时候会自动运行，类似java的构造函数，注意方法名开头和末尾各有两个下划线
        """初始化属性name和age"""
        self.name = name
        self.age = age

    def sit(self):  # 每个与类相关联的方法，都会传入参数self
        """模拟坐的动作"""
        print(self.name.title() + " 坐下")  # 可获取初始化方法中的值，因传递了参数self

    def roll(self, count):  # 可根据需求自定义要传入的参数，但是self是固定的
        """模拟打滚的动作"""
        print(self.name.title() + " 滚了 " + str(count) + " 圈")


my_dog = Dog('二哈', 3)  # 此处要传入类的初始化方法里的参数
print("我的小狗名字是：" + my_dog.name + "\n年龄是：" + str(my_dog.age))
my_dog.sit()
my_dog.roll(4)  #传入自定义的count参数

结果：

我的小狗名字是：二哈
年龄是：3
二哈 坐下
二哈 滚了 4 圈

2、使用类和实例

先创建一个Car类

class Car():
    """模拟汽车"""

    def __init__(self, make, model, year=2016):  # 默认时间为2016，如果指定参数了，则按照传入的参数处理，同上一章内容
        """初始化汽车数据"""
        self.make = make
        self.model = model
        self.year = year

    def describe(self):
        """返回描述信息"""
        message = "车类别：" + self.make + " 车型号：" + self.model + " 制造时间：" + str(self.year)
        return message  # 也可以直接打印


my_car_1 = Car('奥迪', 'R8', 2015) # 指定时间参数是2015
my_car_2 = Car('宝马', 'Z7') # 再创建一个实例，没有指定时间参数
print(my_car_1.describe())
print(my_car_2.describe())

结果:

车类别：奥迪 车型号：R8 制造时间：2015
车类别：宝马 车型号：Z7 制造时间：2016

修改已创建实例的属性值

(注意：修改后改变的仅是该实例的属性值，而其他同一个类创建的实例属性值不受影响)

代码:

class Car():

    # --snip--

# 修改属性的值，直接访问修改,也可将该逻辑写在类创建的一个函数中，直接调用修改
my_car_1.year = 2000  # 制造时间改为2000年
print(my_car_1.describe())
my_car_1.color = 'red' # 增加属性的值，直接赋值给新属性即可，同字典
print(my_car_1.color)
print(my_car_2.color)  # 此句报错，因为car2并没有color属性

结果:

车类别：奥迪 车型号：R8 制造时间：2000  
red
AttributeError: Car instance has no attribute 'color'

3、类的访问限制

java中访问控制符有public,private等，python中属性也有控制符，如下的类中。

代码:

class Person():
    def __init__(self, name, age):
        self.__name = name  # 由两个下划线开始的属性表示类的私有属性，外部无法正常访问
        self.__age = age

    def say(self):  # 私有属性只能自己内部访问
        print ('name:' + self.__name + 'age:' + str(self.__age))


p1 = Person('吴彦祖 ', 18)
p1.say()
print (p1.__name) # 此句报错，同理，无法修改相应属性

结果:

name:吴彦祖 age:18
AttributeError: Person instance has no attribute '__name'

同java，外部要想访问或修改，可在类内部创建set()和get()方法 ，如下

代码:(类中新增添set和get方法)

class Person():

    # --snip--

    def set_name(self, name):  # 可在方法中控制，避免修改成无效的数据
        self.__name = name

    def get_name(self):
        return self.__name

p1 = Person('吴彦祖', 18)  #  获取实例
print (p1.get_name())  # 访问属性
p1.set_name('刘德华') # 修改属性
print (p1.get_name()) # 访问属性

结果:

吴彦祖
刘德华

Tip:有时会遇到单下划线开头的变量，如_name，意思是建议当做私有变量，但外部还是可以访问的(我不知道为毛这样设计，先暂时这么记吧，以后知道了再做修改)

双下划线开头的私有变量，外部其实也是可以访问的，例如

p1._Person__name

是因为python类内部封装了__name属性，但不建议这么写，因为不同版本的Python解释器可能会把__name改成不同的变量名

最后要注意的是：添加修改属性时，不能添加修改私有属性。例如

p1 = Person('吴彦祖', 18)
p1.__name = '刘德华'  # 本意修改name的值
print (p1.get_name()) # 实际上并未修改
print (p1.__name) # 只是新增添了__name属性

结果:

吴彦祖
刘德华

但可以通过p1._Person__name方法修改，但不建议，理由同上

4、继承

1.子类创建时候，初始化方法里需要调用父类的__init__()方法，获得父类的所有属性和方法，还可定义自己独有的属性和方法，重写父类的方法等 
代码:

class ElectricCar(Car):  # 继承父类时，将父类写入括号内即可
    """电动车"""

    def __init__(self, make, model, year):
        """初始化父类的属性"""
        super().__init__(make, model, year)  # 注意super的括号，→_→
        # 初始化自己独有的属性
        self.battery = 70

    # 定义独有的方法
    def describe_battery(self):
        print("电池容量：" + str(self.battery))


my_tesla = ElectricCar('特斯拉', 'S', 2011)
print(my_tesla.describe())
my_tesla.describe_battery()

结果:

车类别：特斯拉 车型号：S 制造时间：2011
电池容量：70

2.重写父类的方法，同java类似，实例只执行子类的同名方法

若Car类中有fill_gas方法，但对子类电动车来说无意义，所以子类ElectricCar可以重写父类的fill_gas方法，做出友好的提示。 
代码:

class ElectricCar(Car):  # 继承父类时，将父类当做参数

    # --snip--

    # 重写父类的方法，方法名相同
    def fill_gase_tank(self):
        """电动车没有汽油"""
        print("电动车不需要加油，你四不四洒.")

# --snip--
my_tesla.fill_gase_tank()

结果:

电动车不需要加油，你四不四洒.

3.可以将实例作为某个类的属性

例如新建Battery类

class Battery():
    """电池类"""

    def __init__(self, battery_size=10):  #默认10
        self.battery_size = battery_size

    def describle(self):
        print("电池容量是：" + self.battery_size)

将Battery类作为参数，传递给ElectricCar类,修改ElectricCar类的初始化方法 
代码:

def __init__(self, make, model, year):
    """初始化父类的属性"""
    super().__init__(make, model, year)  
    # 初始化自己独有的属性
    self.battery = Battery()  # 此处直接新建Battery的实例赋值给battery属性,没有参数传递，使用默认值10

调用的时候 
代码:

my_tesla.battery.describle()

结果:

电池容量是：10

4.多态和python的鸭子类型

java中的多态，父类定义了一个方法A，子类有重名的方法A，若调用父类其他方法B(调用A)中传入的参数是父类类型，则调用子类相应的重名方法。例如

代码:

class A():
    def say(self): # A中有方法say()
        print ('A说话了')

    def say_twice(self, A): # 调用say方法，但是传入A类型的数据
        A.say()
        A.say()


class B(A):  # B中有方法say()
    def say(self):
        print ("B说话了")


class C(A):  # C中有方法say()
    def say(self):
        print ("C说话了")

a = A()
b = B()
c = C()

a.say_twice(b) # 调用A的say_twice方法，传入子类b的实例，因为b继承自A，所以调用b的say方法
a.say_twice(c) # 同上

结果:

B说话了
B说话了
C说话了
C说话了

因为java是静态语言，定义好类的方法中传入的数据类型，即必须符号要求的数据类型才能传入，而python是动态语言，只要类中有同名方法(如上代码中的say())，即可传入该类的实例，例如，再定义一个D类，包含say方法

代码:

class D():
    def say(self):
        print ('D没继承，照样说话了')

d = D()
a.say_twice(d)  #  传入D的实例d，虽然没有继承A，但是有say方法，同样可以执行D的say方法,若不包含say方法，则这样调用报错

结果:

D没继承，照样说话了
D没继承，照样说话了

这样的类型就是鸭子类型(长得像鸭子，就是鸭子→_→搞不懂为毛用鸭子)

5、导入类

同之前的导入函数类似，使用from xxx impoort xxx语句

from car import Car  # 第一个car是car.py文件，第二个Car是类，即从某个.py文件中导入某个类
from car import Car, ElectricCar #导入多个类，用逗号分开
import car # 或者直接导入整个模块，同上一章,使用的时候用 car.xxx
from car import * #导入某个模块的所有类和方法，不建议这样用，可能会和当前文件的某些类或者函数名重合导致出错

6、Python标准库

Python标准库是一组系统自带的模块，包含很多常用的方法 
代码:

from collections import OrderedDict # 导入有序字典

users_age = OrderedDict()  # 返回一个有序的字典

users_age['大娃'] = 1 
users_age['二娃'] = 2
users_age['三娃'] = 3


for name, age in users_age.items():
    print("名字是：" + name + " 年龄是：" + str(age))

结果: 按照添加的顺序输出

名字是：大娃 年龄是：1
名字是：二娃 年龄是：2
名字是：三娃 年龄是：3