当前位置：首页 > web >正文

Python学习笔记（第三部分）

web 2025/5/2 5:47:17

接续 Python.md 文件的第三部分

类

类的创建的基本使用

创建一个类
```
class Dog():''' 文档字符串：这是一次模拟小狗的简单尝试 '''def __init__(self,name,age):self.name = nameself.age = agedef sit(self):print(self.name.title() + " is now sitting.")def rollover(self):print(self.name.title() + " is now rolling over!")
```
Dog()类中包含两个属性：name 和 age ，以及两个方法 sit() 和 rollover()。类中的函数称为方法，可以通过实例访问到的变量称为属性
- __init__()方法，前后各有两个下划线，这是一个特殊的方法，在根据Dog()类创建实例时，python都会自动运行这个方法。
  - 这个方法中，形参 self 必须有，而且必须位于其他所有参数的前边，因为python在调用__init__()创建实例时，将自动传入实参 self
  - 每个与类相关联的方法调用都自动传入实参 self ，它是只想实例本身的引用，让实例能够访问到类中的属性和方法
  - 通过实参向 Dog() 传递 name 和 age 时，self会自动传递，因此不用自己传递它，只用给出后边两个实参
- 以 self 为前缀的变量可以供类中的所有方法使用，而且还可以通过类的任何实例来访问这些变量
- self.name = name 获取存储在形参 name 中的值，并将其存储在 name 变量中，然后将该变量关联到当前创建的实例
- sit() 和 rollover() 方法不需要其他信息，因此只有一个形参 self
- 类名通常是首字母大写，实例是小写

创建类的实例，根据类来创建对象称为实例化

class Dog():''' 文档字符串：这是一次模拟小狗的简单尝试 '''def __init__(self,name,age):self.name = nameself.age = agedef sit(self):print(self.name.title() + " is now sitting.")def rollover(self):print(self.name.title() + " is now rolling over!")my_dog = Dog('whill', 6)
print("My dog's name is " + my_dog.name.title())   # 访问属性通过 句点表示法
print("My dog's age is " , my_dog.age)my_dog.sit()
my_dog.rollover()  # 访问方法通过 句点表示法

使用类和实例

Car类

class Car():'''一次模拟汽车的简单尝试'''def __init__(self,make,model,year):'''初始化描述汽车的属性'''self.make = makeself.model = modelself.year = yeardef get_descriptive_name(self):long_name = str(self.year) + " " + self.make + " " + self.modelreturn long_namemy_new_car = Car("Audi", 'a6', 2016)
print(my_new_car.get_descriptive_name())

给属性指定默认值

类的每个属性都必须有初始值，可以在__init__()方法内指定属性的初始值，此时无需包含为它提供初始值的形参

class Car():'''一次模拟汽车的简单尝试'''def __init__(self,make,model,year):'''初始化描述汽车的属性'''self.make = makeself.model = modelself.year = yearself.odometer_reading = 0   # 为odometer_reading属性设置的初始值，不用再在形参中给出def get_descriptive_name(self):long_name = str(self.year) + " " + self.make + " " + self.modelreturn long_namedef read_odometer(self):'''打印汽车总里程'''print("Total odometer: " + str(self.odometer_reading) + " miles. ")my_new_car = Car("Audi", 'a6', 2016)
print(my_new_car.get_descriptive_name())
my_new_car.read_odometer()

修改属性的值

# 法一 通过实例直接访问它(不安全)
my_new_car = Car("Audi", 'a6', 2016)
my_new_car.odometer_reading = 23
my_new_car.read_odometer()

class Car():'''一次模拟汽车的简单尝试'''--snip--def update_odometer(self,mileage):'''将里程表修改为指定的值静止将里程表读数往回调'''if mileage > self.odometer_reading:self.odometer_reading = mileageelse:print("不允许作弊.")
my_new_car = Car("Audi", 'a6', 2016)
my_new_car.update_odometer(23)
my_new_car.read_odometer()

通过方法对属性的值进行递增

class Car():'''一次模拟汽车的简单尝试'''def __init__(self,make,model,year):'''初始化描述汽车的属性'''self.make = makeself.model = modelself.year = yearself.odometer_reading = 0   # 为odometer_reading属性设置的初始值，不用再在形参中给出def get_descriptive_name(self):long_name = str(self.year) + " " + self.make + " " + self.modelreturn long_namedef read_odometer(self):'''打印汽车总里程'''print("Total odometer: " + str(self.odometer_reading) + " miles. ")def update_odometer(self,mileage):'''将里程表修改为指定的值静止将里程表读数往回调'''if mileage > self.odometer_reading:self.odometer_reading = mileageelse:print("不允许作弊.")def increment_odometer(self,miles):if miles > 0:self.odometer_reading += mileselse:print("不允许作弊.")used_car = Car("Audi",'a7',2019)
print(used_car.get_descriptive_name())used_car.update_odometer(2650)
used_car.read_odometer()used_car.increment_odometer(3000)
used_car.read_odometer()

继承

一个类继承一个类时，它将自动获得被继承类的所有属性和方法，原有的类称为父类或超类，新类称为子类

class Car():'''一次模拟汽车的简单尝试'''def __init__(self,make,model,year):'''初始化描述汽车的属性'''self.make = makeself.model = modelself.year = yearself.odometer_reading = 0   # 为odometer_reading属性设置的初始值，不用再在形参中给出def get_descriptive_name(self):long_name = str(self.year) + " " + self.make + " " + self.modelreturn long_namedef read_odometer(self):'''打印汽车总里程'''print("Total odometer: " + str(self.odometer_reading) + " miles. ")def update_odometer(self,mileage):'''将里程表修改为指定的值静止将里程表读数往回调'''if mileage > self.odometer_reading:self.odometer_reading = mileageelse:print("不允许作弊.")def increment_odometer(self,miles):if miles > 0:self.odometer_reading += mileselse:print("不允许作弊.")class ElectricCar(Car):'''继承了类 Car'''def __init__(self,make,model,year):'''初始化父类的属性'''super().__init__(make,model,year)my_tesla = ElectricCar("tesla",'model y', 2018)
print(my_tesla.get_descriptive_name())

创建子类时，父类必须包含在当前文件中，而且必须子类的前边
定义子类时，在括号内指定父类的名称class ElectricCar(Car):
super()是特殊的函数，使父类和子类关联起来

给子类定义自己的特有属性和方法：

class Car():---snip---class ElectricCar(Car):'''继承了类 Car'''def __init__(self,make,model,year):# 初始化父类的属性super().__init__(make,model,year) # 初始化自己特有的属性self.batery_size = 70def describe_battery(self):print("This car has a " + str(self.batery_size) + '-kWh battery.')my_tesla = ElectricCar("tesla",'model y', 2018)
print(my_tesla.get_descriptive_name())
my_tesla.describe_battery()

重写父类的方法（定义一个和父类方法重名的方法）

class Car():---snip---def fill_gas_tank(self):'''加油的方法'''print("加油中...")print("加油完成！")class ElectricCar(Car):def __init__(self,make,model,year):super().__init__(make,model,year)def fill_gas_tank(self):'''重写父类方法，电动车没有油箱'''print("This car doesn't need a gas tank.")

重写父类方法后，在创建子类的实例时，Python会忽略掉原来父类中的方法

将实例用作属性

class Car():'''一次模拟汽车的简单尝试'''def __init__(self,make,model,year):'''初始化描述汽车的属性'''self.make = makeself.model = modelself.year = yearself.odometer_reading = 0   # 为odometer_reading属性设置的初始值，不用再在形参中给出def get_descriptive_name(self):long_name = str(self.year) + " " + self.make + " " + self.modelreturn long_namedef read_odometer(self):'''打印汽车总里程'''print("Total odometer: " + str(self.odometer_reading) + " miles. ")def update_odometer(self,mileage):'''将里程表修改为指定的值静止将里程表读数往回调'''if mileage > self.odometer_reading:self.odometer_reading = mileageelse:print("不允许作弊.")def increment_odometer(self,miles):if miles > 0:self.odometer_reading += mileselse:print("不允许作弊.")class Battery():def __init__(self,battery_size=70):'''初始化电瓶的属性'''self.battery_size = battery_sizedef describe_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()   # 创建了一个Battery()的实例作为ElectricCar类的属性my_tesla = ElectricCar("tesla",'model y', 2018)
print(my_tesla.get_descriptive_name())
my_tesla.battery.describe_battery()

有时候自己的类非常庞大，有非常多的属性和方法，这是可以采用上述方法，将类的一部分作为一个独立的类单独提取出来

上边新建了一个Battery类，以后想要再对电池做分析就更简洁了

class Battery():def __init__(self,battery_size=70):'''初始化电瓶的属性'''self.battery_size = battery_sizedef describe_battery(self):print("This car has a " + str(self.battery_size) + '-kWh battery.')def get_range(self):if self.battery_size == 70:range = 240elif self.battey_size == 80:range = 270message = "This car can go approximately " + str(range)message += " miles on a full charge."print(message)

导入类

为了使文件更简洁，Python允许将类存储在模块中，然后在主程序中导入所需的模块

可以把多个类放在一个模块中

# car.py
class Car():---snip---class Battery():---snip---class ElectricCar(Car):---snip---

导入单个类

from car import Car  # 从 car.py 文件中导入单个类 Car

导入多个类

from car import Car,ElectricCar  # 多个类之间用逗号分隔

导入整个模块

import carmy_tesla = car.ElectricCar("tesla",'model y', 2018)  # 需要用句点表达式的方式来访问需要的类

使用module_name.class_name的方式访问需要的类

导入模块中的所有类
```
from car import *
```
不推荐使用这种方法，因为可能发生类名冲突
从一个模块中导入很多类时，最好是导入整个模块，然后在接下来的代码中使用module_name.class_name的方式访问需要的类

还可以从一个模块中导入另外一个模块

# car.py 模块
class Car():---snip---

# electric_car.py 模块
from car import Car   # 从 car.py模块中导入Car类class Battery():---snip---class ElectricCar(Car):---snip---

# my_cars.py
from car import Car
from electric_car import ElectricCarmy_beetle = Car("volk", 'beetle', 2018)
print(my_beetle.get_descriptive_name())my_tesla = ElectricCar("tesla",'model y', 2018)
print(my_tesla.get_descriptive_name())

自定义工作流程

一开始应该尽可能的让结构简单，先尽可能的在一个文件中完成所有的工作，确定一切都能够正常运行后，再将类移到独立的模块中

文件

从文件中读取数据

with open('.//FileOP//pi_digits.txt') as file_object:contents = file_object.read()  print(contents)-->
3.141592653589793238462643383279# 多了一个空行

使用 open() 函数打开文件，并返回一个表示该文件的对象
关键字 with 在不再需要访问打开的文件后关闭该文件，就不用手动用 close() 函数关闭文件，但是不推荐这种做法，因为有的时候程序不能正常运行到 close() 这里导致文件不能够正确的关闭从而导致文件数据受损
所以使用 with 结构来让 Python 自己决定在合适的时候关闭文件
使用 read() 方法读取目标文件的全部内容，并将其作为一个字符串
read() 方法到达文件末尾时返回一个空字符串，因此打印出来时会多一个空行，可以使用**rstrip()**去除字符串末尾的空白

文件路径

使用这种方法时，Python会在当前执行的文件所在的目录中查找文件
```
with open('pi_digits.txt') as file_object:---snip---
```
使用相对路径，这是Python会在当前执行的文件所在的目录中的FileOP文件夹中去找目标文件
```
with open('FileOP\pi_digits.txt') as file_object:---snip---
```
windows系统中，使用反斜杠(/)而不是斜杠(\)，或者使用双斜杠\\，这样就可以防止被转义

使用绝对路径，因为绝对路径通常比较长，所以经常把它放在一个变量中

file_path = 'D:\GiteeRepository\python-project\jupyter\FileOP\pi_digits.txt'
with open(file_path) as file_object:---snip---

逐行读取

对文件对象使用for循环，以每次一行的方式检查文件：
```
file_path = "FileOP/pi_digits.txt"
with open(file_path) as file_object:for line in file_object:print("- " + line)--->
- 3.1415926535-   8979323846-   2643383279
```
每行的末尾都有一个空白行，这是因为在文件中，每行的末尾都有一个换行符，而print语句也会自己加上一个换行符，所以答应出来有一个空行

可以使用**rstrip()**去除字符串末尾的空白
```
file_path = "FileOP/pi_digits.txt"
with open(file_path) as file_object:for line in file_object:print("- " + line.rstrip())
```

创建一个包含文件多行的列表

file_path = "FileOP/pi_digits.txt"
with open(file_path) as file_object:lines = file_object.readlines()print(lines)  #  ['3.1415926535\n', '  8979323846\n', '  2643383279\n']

readlines()方法从文件中读取每一行以列表的形式存储到lines中

Python读取我呢本文件时，对于所有的文本都解读为字符串，可以使用 int() 或 float() 函数转化成数字

写入文件

写入空文件，调用 open() 时，多提供一个参数 ‘w’ ，这个参数称为模式参数，告诉Python要写入文件

file_path = 'FileOP/programming.txt'with open(file_path, 'w') as file_obj:  # 如果目标文件不存在，函数 open() 就新建一个文件file_obj.write('I love programming.')

打开文件时，可以指定写入模式：读取模式（’r’）、写入模式（‘w’）、附加模式（‘a’）、读取和写入模式（‘r+’）
以写入模式（‘w’）打开文件时，如果目标文件中存在内容，Python在返回该文件对象时会清空该文件里的内容
python只能将字符串写入到文本文件，如果是数值型数据，必须要用 str() 转换成字符串格式

写入多行，write函数不会自动添加换行符，需要自己手动加上

file_path = 'FileOP/programming.txt'with open(file_path, 'w') as file_obj:file_obj.write('I love programming.\n')file_obj.write('I love creating new games.\n')

附加到文件，使用 附加模式

file_path = 'FileOP/programming.txt'with open(file_path, 'a') as file_obj:file_obj.write('I also love finding meaning in large datasets.\n')file_obj.write('I love creating apps that can run in a browser.\n')

异常

Python使用被称为异常的特殊对象来管理程序执行期间发生的错误
如果代码中没有处理异常的代码块，程序会显示一个traceback
异常是使用try-except代码块处理的
```
# 处理 ZeroDivisionError:
try:print(5/0)
except ZeroDivisionError:print("You can't divide by zero.")
```
这样就可以处理特定的异常，在上面代码中，可以处理ZeroDivisionError异常

如果 try 代码块中的代码没有问题，Python将跳过except代码块，否则，将查找这样的except代码块：except 指定的错误与引发的错误相同，并运行其中的代码

else 代码块：

print("Give me two numbers, and I'll diveide them.")
print("Enter 'q' to quit.")while True:first_num = input('first_num: ')if first_num == 'q':breaksecond_num = input('second_num: ')if second_num == 'q':breaktry:answer = int(first_num) / int(second_num)except ZeroDivisionError:print("You can't divide by zero.")else:print("Answer: ", answer)

在上述代码中，try 代码块中只包含可能导致错误的代码，如果发生错误将试图和except代码块中的错误匹配，如果没有错误就执行else代码块中的内容

excpet代码块的作用是告诉Python，在遇到了指定的异常应该怎么办

处理 FileNotFoundError 异常

file_name = 'alice.txt'with open(file_name) as f_obj:contents = f_obj.read()   # FileNotFoundError: [Errno 2] No such file or directory: 'alice.txt'

这个异常是 open 函数导致的，可以把 open 函数包含在 try 代码块中：

file_name = 'alice.txt'try:with open(file_name) as f_obj:contents = f_obj.read()   
except:msg = "Sorry, the file '" + file_name + "' does not exist."print(msg)

分析文本

title = 'Alice in Wonderland.'title.split()   # ['Alice', 'in', 'Wonderland.']

split() 方法以空格为分隔符将字符串分拆成多个部份，并将这些部份都存储到一个列表中

file_name = 'Alice in Wonderland.txt'try:with open(file_name) as f_obj:contents = f_obj.read()   
except:msg = "Sorry, the file '" + file_name + "' does not exist."print(msg)
else:words = contents.split()num_words = len(words)print("Total words nums: " + str(num_words))

使用多个文件（包装成一个函数）

def count_words(file_path):"""计算一个文件大致包含多少个单词"""try:with open(file_path) as f_obj:contents = f_obj.read()   except:msg = "Sorry, the file '" + file_name + "' does not exist."print(msg)else:words = contents.split()num_words = len(words)print("Total words nums: " + str(num_words))file_path = "./FileOP/alice.txt"
count_words(file_path)

使用 pass语句跳过对捕捉异常的处理部份

def count_words(file_path):try:with open(file_path) as f_obj:contents = f_obj.read() except FileNotFoundError:passelse:words = contents.split()num_words = len(words)print("Total words nums: " + str(num_words))file_path = "./FileOP/alice.txt"
count_words(file_path)

pass 语句充当了占位符，提醒自己在某个地方什么都没做

存储数据

使用 json 格式存储数据

使用 json.jump() 存储数据

import jsonnumbers = [1, 2, 3, 4, 5]
file_path = "./FileOP/numbers.json"
with open(file_path, 'w') as file_obj:json.dump(numbers, file_obj)

使用 json.load() 读取数据

import json file_path = "./FileOP/numbers.json"
with open(file_path) as file_obj:numbers = json.load(file_obj)print(numbers)

一次实例：

# rember_me.py
import json
file_path = "./FileOP/username.json"
try:with open(file_path) as f_obj:user_name = json.load(f_obj)
except FileNotFoundError:username = input("Tell me your name: ")with open(file_path, 'w') as f_obj:json.dump(username, f_obj)print("We will rember you, Dear  " + username)
else:print("Welcome back, " + username)

测试

Python标准库中的模块unittest提供了代码测试工具
单元测试用于核实函数的某个方面没有问题
测试用例是一组单元测试，这些单元测试一起核实函数在各种情况下都符合要求
全覆盖式测试用例包含一整套单元测试，涵盖了各种可能的函数使用方式

测试函数

要为函数编写测试用例，需要先导入模块unittest以及要测试的函数，在创建一个继承unitest.TestCase的类

# name_function.pydef get_fullname(first,last):fullname = first + " " + lastreturn fullname.title()

# test_name_function.py
import unittest
from name_function import get_fullnameclass NamesTestCase(unittest.TestCase):  # 类名可以自定义，但是应尽量包含Test，而且必须继承 unittest.TestCase 类""" 测试name_function.py """def test_first_last_name(self):fullname = get_fullname('jains', 'joplin')self.assertEqual(fullname, 'Jains Joplin')unittest.main()

一个新的案例：

# name_function.pydef get_fullname(first, last, middle=''):if middle:fullname = first + " " + middle + " " + lastelse:fullname = first + " " + lastreturn fullname.title()

# test_name_function.py
import unittest
from name_function import get_fullnameclass NamesTestCase(unittest.TestCase):""" 测试name_function.py """def test_first_last_name(self):fullname = get_fullname('jan', 'joplin')self.assertEqual(fullname, 'Jan Joplin')def test_first_last_middle_name(self):fullname = get_fullname('wolf', 'dog', 'amazes')self.assertEqual(fullname, 'Wolf Dog Amazes')unittest.main()

一个新的案例

# city_functions.pydef get_formatted_city(city, country, population=''):if population:res = city + ', ' + country + '-' + str(population)else:res = city + ', ' + countryreturn res.title()

# test_cities.pyimport unittest
from city_functions import get_formatted_city as gfcclass CitiesTestCase(unittest.TestCase):""" 测试city_functions.py """def test_city_country(self):res = gfc('xian', 'china')self.assertEqual(res, 'Xian, China')def test_city_country_population(self):res = gfc('santiago', 'chile', 25000)self.assertEqual(res, 'Santiago, Chile-25000')# unittest.main()

测试类

unittest.TestCase中常用的断言方法

方法	用途
`assertEqual(a, b)`	验证 `a == b`
`assertNotEqual(a, b)`	验证 `a != b`
`assertTrue(x)`	验证 `x` 为 `True`
`assertFalse(x)`	验证 `x` 为 `False`
`assertIs(a, b)`	验证 `a is b`（对象身份相同）
`assertIn(item,list)`	验证 `item` 在 `list` 中
`assertNotIn(item,list)`	验证 `item` 不在 `list` 中
`assertIsNot(a, b)`	验证 `a is not b`
`assertIsNone(x)`	验证 `x` 是 `None`
`assertIsNotNone(x)`	验证 `x` 不是 `None`
`assertIn(a, b)`	验证 `a` 包含在 `b` 中（`a in b`）
`assertNotIn(a, b)`	验证 `a` 不包含在 `b` 中（`a not in b`）
`assertIsInstance(obj, cls)`	验证 `obj` 是 `cls` 的实例
`assertNotIsInstance(obj, cls)`	验证 `obj` 不是 `cls` 的实例
`assertAlmostEqual(a, b, places=7)`	验证浮点数 `a` 和 `b` 近似相等（精度为小数点后 `places` 位）
`assertNotAlmostEqual(a, b, places=7)`	验证浮点数 `a` 和 `b` 不近似相等
`assertGreater(a, b)`	验证 `a > b`
`assertGreaterEqual(a, b)`	验证 `a >= b`
`assertLess(a, b)`	验证 `a < b`
`assertLessEqual(a, b)`	验证 `a <= b`
`assertListEqual(a, b)`	验证列表 `a` 和 `b` 内容及顺序一致
`assertDictEqual(a, b)`	验证字典 `a` 和 `b` 键值对完全一致
`assertTupleEqual(a, b)`	验证元组 `a` 和 `b` 内容及顺序一致
`assertSetEqual(a, b)`	验证集合 `a` 和 `b` 内容相同（忽略顺序）
`assertMultiLineEqual(a, b)`	验证多行字符串 `a` 和 `b` 完全一致

类的测试大部分工作是测试类中方法的行为：

# suvery.py
class AnonymousSurvey():""" 收集匿名调查问卷的答案 """def __init__(self, question):"""存储一个问题，并为存储答案做准备"""self.question = questionself.responses = []def show_question(self):"""显示调查问卷"""print(self.question)def store_responses(self, new_response):"""存储单份调查问卷"""self.responses.append(new_response)def show_results(self):"""显示收集到的所有答案"""print("Survey results: ")for res in self.responses:print('-' + res)

# language_survey.py
from survey import AnonymousSurvey as AS# 定义一个问题，并创建一个表示调查的AnonymousSurvey对象
question = "What's your favorite language?"
my_survey = AS(question)# 显示问题并存储答案
my_survey.show_question()
print("Enter 'q' to quit. ")
while True:response = input("Please tell me your answer: ")if response == 'q':breakelse:my_survey.store_responses(response)# 显示调查结果
print("\n Thank you: ")
my_survey.show_results()

开始测试AnonymousSurvey类

验证：如果用户面对调查问题时，只提供了一个答案，是否能够准确地存储

# test_survey.py
import unittest
from survey import AnonymousSurveyclass TestAnonymousSurvey(unittest.TestCase):"""测试AnonymousSurvey类"""def test_store_single_response(self):question = "What your favorite language?"my_survey = AnonymousSurvey(question)my_survey.store_responses('English')self.assertIn('English', my_survey.responses)

验证：如果用户提供了多个答案时，是否能够准确的存储：

# test_survey.py
import unittest
from survey import AnonymousSurveyclass TestAnonymousSurvey(unittest.TestCase):"""测试AnonymousSurvey类"""def test_store_single_response(self):question = "What your favorite language?"my_survey = AnonymousSurvey(question)my_survey.store_responses('English')self.assertIn('English', my_survey.responses)def test_store_three_responses(self):question = "What your favorite language?"my_survey = AnonymousSurvey(question)responses = ['C++', 'C', 'Java']for res in responses:my_survey.store_responses(res)for res in responses:self.assertIn(res, my_survey.responses)

使用方法 setUp()，在上边的TestAnonymousSurvey类中，每个测试方法都创建了一次AnonymousSurvey的实例，使用setUp()方法可以让我们只需创建一次实例对象，然后在每个测试方法中使用它：

import unittest
from survey import AnonymousSurveyclass TestAnonymousSurvey(unittest.TestCase):"""测试AnonymousSurvey类"""def setUp(self) -> None:"""创建一个调查对象和一组答案，供使用的测试方法使用"""question = "What your favorite language?"self.my_survey = AnonymousSurvey(question)  self.responses = ['C++', 'C', 'Java']def test_store_single_response(self):"""测试单个答案会被妥善的存储"""self.my_survey.store_responses(self.responses[0])self.assertIn(self.responses[0], self.my_survey.responses)def test_store_three_responses(self):"""测试多个答案会被妥善的存储"""for res in self.responses:self.my_survey.store_responses(res)for res in self.responses:self.assertIn(res, self.my_survey.responses)

在方法setUp中创建了一个调查对象 my_survey 和一个答案列表 responses , 并且都添加了前缀self(即存储在属性中)，因此可在这个类的任何地方使用

查看全文

http://www.xdnf.cn/news/3385.html