python基础学习

python

变量的命名和使用

    · 变量名只能包含字母、数字和下划线。不能以数字打头。
    · 变量名不能包含空格，但可使用下划线来分隔其中的单词。
    · 不要将Python关键字和函数名用作变量名。
    · 慎用小写字母l和大写字母O，因为它们可能被人错看成数字1和0。

列表、元组、集合、字典的区别是什么？

    列表：元素可变（任何数据类型），有序（可索引），append/insert/pop；
    元组：元素不可变，但元素中的可变元素是可变的；有序（可索引）；而且元组可以被散列，例如作为字典的键。
    集合：无序（不可被索引）、互异
    字典：无序，键值对（key：value），key唯一不可重复

# -*- coding: utf-8 -*-

一、变量

#变量使用、空格引用、字符大小写、字符首字母大写、应用数值str（）
first_name = "zhang"
last_name = "shan"
full_name = first_name+" "+last_name

print(full_name.upper())

print(full_name.lower())

name = "hello, "+full_name.title()+"!"
print(name)

age = "24"
message = full_name.title()+" is "+str(age)+" years old ! "
print(message)

#制表符和换行符
languages = "languages	:
c
c++
python
php
perl"
print(languages)

#剔除空格
string = ' python '
#右侧空格剔除
print(string.rstrip())
#左侧空格剔除
print(string.lstrip())
#左右剔除
print(string.strip())

#计算加、乘、除、幂
print(5+2)
print(5*2)
print(5.0/2)
print(2**3)

二、列表

#列表
print("列表")
name = ["zhangfei","liubei","guanyu"]
print(name)

print("修改列表元素")
name[0]="sunshangxiang"
print(name)

print("在列表中添加元素到末尾")
name.append("zhaoyun")
print(name)

print("列表中插入元素")
name.insert(1,"zhugeliang")
print(name)

print("列表中删除元素")
print("1、del删除后无法访问")
del name[1]
print(name)

print("2、pop()任意位置删除后可使用
pop()删除列表末尾=弹出栈顶元素
()中可填0、1...可弹出任意位置元素
name.pop()后将删除元素引用到popped_name")
popped_name = name.pop()
print(name)

print("查看popped_name")
print(popped_name)

print("3、remove()根据值删除元素后可使用
注:只删除第一次出现的值，若出现多次，需循环
如：删除刘备")
removed_name = 'liubei'
name.remove(removed_name)
print(name)

print("查看removed_name")
print(removed_name)

print("
")

#组织列表
print("新列表")
word = ['c','s','d','n','a']
print(word)

print("1、sort()排序，排序后无法恢复")
word.sort()
print(word)

print("sort(reverse=True),逆序")
word = ['c','s','d','n','a']
print(word)
word.sort(reverse=True)
print(word)

print("sorted()排序后不影响原列表，可以使用sorted(reverse=True)逆序==》不做例。")


print("
")
print("2、reverse()不排序，直接反转列表元素,永久性但可再次reverse()恢复")
print("原列表与reverse后的列表")
word = ['c','s','d','n','a']
print(word)
word.reverse()
print(word)

print("
")
print("len(列表名)确定列表长度，
例：len(word)")
word = ['c','s','d','n','a']
print(word)
length = "len(word):"+str(len(word))
print(length)

print("打印最后一个元素,例:print(word[-1])")
print(word[-1])


三、操作列表（for语句）

#操作列表
print("1、for遍历列表")
names = ['lubu','dainwei','daiochan','si','wu']
for name in names:
 print(name)

print("
2、缩进循环，不缩进只执行一次,'for语句后首行要缩进'.")
for name in names:
 print("hello "+name.title()+" !")
print("Thank you,everyone !")

print("
函数range(),例：range(1,6)打印1-5.")
for value in range(1,6):
 print(value)

print("
使用range()创建数字列表")
numbers = list(range(1,6))
print(numbers)

print("
range()可指定步长")
numbers1 = list(range(1,11,2))
print(numbers1)

print("
1~10的平方")
#为了使代码简洁，可直接number2.append（value**2）
numbers2 = []
for value in range(1,11):
    numbers3 = value**2
    numbers2.append(numbers3)
print(numbers2)

print("
将上述数字列表简单统计计算
最小值为：")
print(min(numbers2))
print("
最大值为：")
print(max(numbers2))
print("
总和：")
print(sum(numbers2))

print("
列表解析")
numbers4 = [value**2 for value in range(1,11)]
print(numbers4)

print("
使用列表中多个元素
1、切片：切取列表中前三个数字,和最后三个")
print(numbers4[0:3])
print(numbers4[-3:])

print("
遍历切片,遍历前三个数字")
for value in numbers4[:3]:
    print(value)

print("
复制列表,若想复制的表不一样，可分别在每个表中修改后引用")
print(names)
names1 = names[:]
print(names1)
print("names1 = names 不可实现上述情况，此为两表关联，两表值绝对一致")

print("
定义元组,元组元素不可修改，但可变量赋值，重新定义整个元组：")
dimensions = (200,50)
for dimension in dimensions:
    print(dimension)
dimensions = (400,100)
for dimension in dimensions:
    print(dimension)

print("
代码规范:
PEP 8建议每级缩进都使用四个空格
很多Python程序员都建议每行不超过80>字符
不要在程序文件中过多地使用空行")


四、操作字典（for语句、if语句）
# 字典
people = {'color':'green','points':5}
print(people['color'])
print(people['points'])

# 字典应用【场景：射杀绿色，获得5点】
people = {'color':'green','points':5}
new_points = people['points']
print("you just earned "+str(new_points)+" points!")

# 字典新增键值对
people = {'color':'black','points':'6'}
print(people)
people['name'] = "laozhang"
people['sex'] = "man"
print(people)

# 定义空字典，添加键值对
class1 = {}
class1['name1'] = "zhngfei"
class1['name2'] = "liubei"
print(class1)

# 修改字典中的值
peopel = {'color':'green','points':'2'}
print("The people is "+people['color']+".")
people['color'] = 'yellow'
print("The people is now "+people['color']+".")

# 例子：定初始速度级别，跟踪一个能够以某级别速度移动的人的位置，记录移动后的位置
alien_0 = {'x_position': 0,'y_position': 10,'speed':'quick'}
print("Original x_position:"+str(alien_0['x_position']))
# 向右移动人
# 根据people的当前速度决定将其移动多远
if alien_0['speed'] == 'slow':
    x_increment = 1
elif alien_0['speed'] == 'quick':
    x_increment = 2
else:
    # 这个alien的speed很快
    x_increment = 3
# 新位置=老位置加上增量
alien_0['x_position'] = alien_0['x_position']+x_increment
print("New x_position:"+str(alien_0['x_position'])) 

#  删除键值对
people = {'color':'green','points':5}
print(people)
del people['points']
print(people)

# 由类似对象组成的字典
favorite_languages = {
    'zhangfei':'python',
    'liubei':'c',
    'guanyu':'go',
}
print("liubei's favorite language is "+favorite_languages['guanyu'].title()+".")

# 遍历字典
user = {
   'zhang':'fei',
   'liu':'bei',
   'guan':'yu',
}
print("
学生姓名：")
for xing,ming in user.items():
    print("
xing:"+xing.title())
    print("ming:"+ming)
    print(xing.title()+ming)

for name,language in favorite_languages.items():
    print(name.title()+"'s favorite language is "+ language.title()+".")

# 遍历字典中的所有键
favorite_languages = {
    'zhangfei':'python',
    'liubei':'c',
    'guanyu':'go',
    'sunshangxiang':'java'
}
for name in favorite_languages.keys():
    print(name.title())

# 字典列表组合使用（占用上一个字典内容）
friends = ['liubei','sunshangxiang']

for name in favorite_languages.keys():
    print(name.title())
    if name in friends:
        print("hi,"+name.title()+",I see your favorite language is "+favorite_languages[name].title()+"!")


# 查看字典中是否存在该键    
if 'zhaoyun' not in favorite_languages.keys():
        print("zhaoyun,啥都不喜欢！")

# 按顺序遍历字典
for name in sorted(favorite_languages.keys()):
    print(name.title()+",hello!")

# 遍历字典中的所有值
print("The following languages have been mentioned:")
for language in favorite_languages.values():
    print(language.title())

# 提取字典中的值，并去重
favorite_languages = {
    'huangzhong':'python',
    'zhaoyun':'c++',
    'lubu':'java',
    'dianwei':'python',
    'hanxin':'C++',
}
print("The following languages have been mentioned:")
for language in set(favorite_languages.values()):
    print(language.title())

# 嵌套
#    字典列表
alien_0 = {'color':'green','point':4}
alien_1 = {'color':'yellow','point':6}
alien_2 = {'color':'red','point':7}
aliens = [alien_0,alien_1,alien_2]
for alien in aliens:
    print(alien)

# 创建空列表
print("创建外星人列表")
aliens = []
# 创建6个黄色的外星人
for alien_number in range(6):
    new_alien = {'color':'yellow','points':5,'speed':'slow'}
    aliens.append(new_alien)
# 显示前四个外星人
for alien in aliens[:4]:
    print(alien)
print("...")
# 显示创建了多少个外星人
print("Total number of aliens:"+str(len(aliens)))

# 创建空列表,并修改列表一部分字段
print("创建外星人列表1")
aliens_1 = []
# 创建10个绿色的外星人
for people_number in range(10):
    new_people = {'color':'green','points':5,'speed':'slow'}
    aliens_1.append(new_people)
for people in aliens_1[0:3]:
    if people['color'] == 'green':
        people['color'] = 'red'
        people['speed'] = 'quick'
        people['points'] = 10
# 显示前5个外星人
for people in aliens_1[:5]:
    print(people)
print("...")

# 添加elif语句
for people in aliens_1[:10]:
    if people['color'] == 'red':
        people['color'] = 'black'
        people['speed'] = 'stop'
        people['points'] = '100'
    elif people['color'] == 'green':
        people['color'] = 'blue'
        people['speed'] = 'speedy'
        people['points'] = '666'
for people in aliens_1[:10]:
    print(people)

# 在字典中存储列表
#（存储所点披萨的信息）
pizza = {
    'crust':'thick',
    'toppings':['mushrooms','cheese'],
}
print("概述所点的披萨")
print("you ordered a "+pizza['crust']+"-crust pizza "+"with the following toppings: ")
for topping in pizza['toppings']:
    print("	"+topping)

# 字典中一个键关联多个值，for循环遍历每个键的所有值
print("for循环遍历每个键的所有值")
favorite_languages = {
    'dage':['python','ruby'],
    'zhangfei':['c','c++'],
    'zhaoyun':['java'],
    'huangzhong':['go','java'],
}
for name,languages in favorite_languages.items():
    print("
"+name.title()+"'s favorite languages are: ")
    for language in languages:
        print("	"+language.title())

# 
#for name,languages in favorite_languages.items():
#    print(len(languages))
#    num = len(languages)
#    if num == '1':
#        print("
"+name.title()+"'s favorite languages is "+languages.title())
#    elif num != '1':
#        print("
"+name.title()+"'s favorite languages are "+languages.title())

# 字典中存储字典

users = {
    'laozhang':{
        'first':'zhang',
        'second':'shan',
        },
    'laowang':{
        'first':'wang',
        'second':'qiang',
        },
    }

for username,user_info in users.items():
    print("
username: "+username)
    full_name = user_info['first']+" "+user_info['second']
    print("	 full name: "+full_name.title())


五、用户输入和while循环
# -*- coding:utf-8 -*-

# python 2.7 函数raw_input（）== python 3 函数input（）：将输入解读为字符串。
# 用户输入和while循环

#函数input（）--暂停程序，获取用户输入文本，将文本存储在变量中

message = str(input("Tell me something,and I will repeat it back to you:"))
print(message)

# 打印多行信息
prompt =  "if you tell us who you are, we can personalize the messages you see."
prompt += "
What is your first name?"
name = input(prompt)
print("
Hello, "+name+"!")

# 用int（）来获取数值输入
# 判断身高是否满足要求
height = input("How tall are you, in inches?")
height = int(height)
if height >= 36:
    print("
You're tall enough to ride!")
else:
    print("
You'll be able to ride when you're a little ollder.")

# 求模运算符(判断数值奇偶)
number = input("Enter a number, and I'll tell you if it's even or odd: ")
number = int(number)
if number % 2 == 0:
    print("
The number "+str(number)+" is even.")
else:
    print("
The number "+str(number)+" is odd.")

# while循环简介
# while循环1~5
current_number = 1
while current_number <= 5:
    print(current_number)
    current_number+= 1

# 让用户选择何时退出（定义退岀值）
prompt = "
Tell me something, and I will repeat it back to you: "
prompt += "
Enter 'quit' to end the program."
message = ""
while message != 'quit':
    message = input(prompt)
    if message != 'quit':
        print(message)

# 使用标志
prompt = "
Tell me something, and I will repeat it back to you:"
prompt += "
Enter 'quit' to end the program."
active = True
while active:
    message = input(prompt)
    if message == 'quit':
        active = False
    else:
        print(message) 

# 使用break退出循环(以while True打头的循环（见❶）将不断运行，直到遇到break语句)
prompt = "
Please enter the name of a city you have visited:"
prompt += "
Enter 'quit' when you are finished."
while True:
    city = input(prompt)
    if city == 'quit':
        break
    else:
        print("I'd love to go to "+city.title()+"!")

# 在循环中使用continue(要返回到循环开头，并根据条件测试结果决定是否继续执行循环，可使用continue语句)
# 1~10打印奇数
current_number = 0
while current_number < 10:
    current_number += 1
    if current_number % 2 == 0:
        continue
    print(current_number)

# 避免无限循环
# (确认程序至少有一个这样的地方能让循环条件为False或让break语句得以执行。)



# 使用while循环来处理列表和字典
# 一、在列表之间移动元素

# 首先创建一个待验证的用户列表
# 和一个用于存储已验证用户的空列表
unconfirmed_users = ['zhangfei','guanyu','liubei']
confirmed_users = []
# 验证每个用户，知道没有未验证用户为止
# 将每一个经过验证的列表都移到已验证用户列表中
while unconfirmed_users:
    current_user = unconfirmed_users.pop()
    print("Verifying user: "+current_user.title())
    confirmed_users.append(current_user)
# 显示已验证的用户
print("
The following users have been confirmed: ")
for confirmed_user in confirmed_users:
    print(confirmed_user.title())

# 使用用户输入来填充字典

responses = {}
# 设置一个标志，指出调查是否继续
polling_active = True
while polling_active:
    # 提示输入被调查者名字和回答
    name = input("
what is your name?")
    response = input("which mountain would you like to climb someday?")
    # 将答卷存储在字典中
    responses[name] = response
    # 看看是否还有人要参与调查
    repeat = input("would you like to let another person respond?(yes/no)")
    if repeat == 'no':
        polling_active = False
# 调查结束，显示结果
print("
--- poll results ---")
for name,response in responses.items():
    print(name+" would like to climb "+response+".")

六、函数+模块

# -*- coding: utf-8 -*-

# 函数

# 定义函数
# (关键字def来告诉Python你要定义一个函数;函数定义，向Python指出了函数名，还可能在括号内指出函数为完成其任务需要什么样的信息---在这里，函数名为greet_user()，它不需要任何信息就能完成其工作，因此括号是空的)

# 紧跟在def greet_user():后面的所有缩进行构成了函数体。"""文本"""---文档字符串的注释

def greet_user():
    """显示简单的问候语"""
    print("hello!")
greet_user()

# 向函数传递信息

def greet_user(username):
    """显示简单的问候语"""
    print("hello~"+username.title()+"!")
greet_user('zhangfei')

# 实参和形参
# 函数greet_user()的定义中，变量username是一个形参——函数完成其工作所需的一项信息;在代码greet_user('jesse')中，值'jesse'是一个实参--实参是调用函数时传递给函数的信息。

# 位置实参
# (你调用函数时，Python必须将函数调用中的每个实参都关联到函数定义中的一个形参。为此，最简单的关联方式是基于实参的顺序。这种关联方式被称为位置实参。)

def describe_pet(animal_type,animal_name):
    """显示宠物信息"""
    print("
I have a "+animal_type+".")
    print("My "+animal_type+"'s name is "+animal_name.title()+".")
describe_pet('dog','coco')
# 多次调用函数
describe_pet('rabbit','dudu')

# 关键字实参(实参中将名称和值关联起来)
def describe_pet(animal_type,animal_name):
    """显示宠物信息"""
    print("
I have a "+animal_type+".")
    print("My "+animal_type+"'s name is "+animal_name.title()+".")
describe_pet(animal_type='dog',animal_name='coco')
describe_pet(animal_type='rabbit',animal_name='dudu')

# 默认值
def describe_pet(animal_name,animal_type='dog'):
    """显示宠物信息"""
    print("
I have a "+animal_type+".")
    print("My "+animal_type+"'s name is "+animal_name.title()+".")
describe_pet(animal_name='liao')
# 若给animal_type提供了实参，将忽略形参的默认值
describe_pet('lisa','rabbit')

# 等效的函数调用
def describe_pet(animal_name,animal_type='dog'):
    """显示宠物信息"""
    print("
I have a "+animal_type+".")
    print("My "+animal_type+"'s name is "+animal_name.title()+".")
describe_pet('liao')
describe_pet(animal_name='liao')
describe_pet('coco','rabbit')
describe_pet(animal_name='coco',animal_type='rabbit')
describe_pet(animal_type='rabbit',animal_name='coco')

# 避免实参错误
# traceback指出了问题出在什么地方,确保函数调用和函数定义匹配。

# 返回值--return语句
# 返回简单值（接受名和姓并返回整洁的姓名）
def get_formatted_name(first_name,last_name):
    """返回整洁的姓名"""
    full_name = first_name+' '+last_name
    return full_name.title()
musician = get_formatted_name('zhang','shan')
print("
"+musician)

# 让实参变成可选的
#   名字有中间名：如张三丰
def get_formatted_name(first_name,middle_name,last_name):
    """返回整洁的姓名"""
    full_name = first_name+' '+middle_name+' '+last_name
    return full_name.title()
musician = get_formatted_name('zhang','san','feng')
print(musician)

#   若并非所有人都有中间名--中间名可选（指定默认值--空字符串）
def get_formatted_name(first_name,last_name,middle_name=''):
    """返回整洁的姓名"""
    if middle_name:
        full_name = first_name+' '+middle_name+' '+last_name
    else:
        full_name = first_name+' '+last_name
    return full_name.title()
musician = get_formatted_name('zhao','yun')
print(musician)
musician = get_formatted_name('zhao','zi','long')
print(musician)

# 返回字典
def build_person(first_name,last_name):
    """返回字典，其中包含有关一个人的信息"""
    person = {'first':first_name,'last':last_name}
    return person
musician = build_person('huang','zhong')
print(musician)

def build_person(first_name,last_name,age=''):
    """返回一个字典，其中包含有关一个人的信息"""
    person = {'first':first_name,'last':last_name}
    if age:
        person['age'] = age
    return person
musician = build_person('zhang','fei',age=38)
print(musician)

# 结合使用函数和while循环
def get_formatted_name(first_name,last_name):
    """返回整洁的姓名"""
    full_name = first_name+' '+last_name
    return full_name.title()
# 这是一个无限循环！
while True:
    print("
please tell me your name:")
    print("(enter 'q' at any time to quit)")
    f_name = input("first_name:")
    l_name = input("last_name:")
    if f_name == 'q' and l_name == 'q':
        break
    else:
        formatted_name = get_formatted_name(f_name,l_name)
        print("
hello, "+formatted_name+"!")

# 传递列表
def greet_users(names):
    """向列表中的每位用户都发出简单的问候"""
    for name in names:
        msg = "hello, "+name.title()+"!"
        print(msg)
usernames = ['zhangfei','liubei','guanyu']
greet_users(usernames)

# 在函数中修改列表
#    首先创建一个列表，其中包含一些要打印的设计
unprinted = ['huawei','oppo','xiaomi']
completed_models = []
#    模拟打印每个设计，直到没有未打印的设计为止
#    打印每个设计后，都将其移到列表completed_models中
while unprinted:
    current = unprinted.pop()
   # 模拟根据设计制作打印模型的过程
    print("printing model: "+current)
    completed_models.append(current)
# 显示打印好的所有模型
print("
the following models have been printed:")
for completed_model in completed_models:
    print(completed_model)

#    函数引用---第一个负责打印设计的，一个负责概述打印哪些设计
def print_models(unprinted,completed_models):
    """
    模拟打印每个设计，直到没有未打印的设计为止
    打印每个设计后，都将其移到列表completed_models中
    """
    while unprinted:
        current = unprinted.pop()
        # 模拟根据设计制作3D打印模型的过程
        print("printing model: "+current)
        completed_models.append(current)
def show_completed_models(completed_models):
    """显示打印好的所有模型"""
    print("
the following models have been printed:")
    for completed_model in completed_models:
        print(completed_model)
unprinted = ['dog','rabbit','cat']
completed_models = []
print_models(unprinted,completed_models)
show_completed_models(completed_models)

# 禁止函数修改列表
# 可用切片表示法--将列表的副本传递给函数，如：function_name(list_name[:])
# print_models(unprinted[:],completed_models)

# 传递任意数量的实参
# (形参名*toppings中的星号让Python创建一个名为toppings的空元组，并将收到的所有值都封装到这个元组中)
def make_pizza(*toppings):
    """打印顾客点的所有配料"""
    print(toppings)
make_pizza('pepperoni')
make_pizza('mushrooms','green peppers','extra cheese')

# 加入循环
def make_pizza(size,*toppings):
    """打印顾客点的所有配料"""
    print("
makeing a "+str(size)+
        "-inch pizza with the following topping:")
    for topping in toppings:
        print("- "+topping)
make_pizza('66','pepperoni')
make_pizza('99','mushrooms','green peppers','extra cheese')

# 使用任意数量的关键字实参
# (形参**user_info中的两个星号让Python创建一个名为user_info的空字典，并将收到的所有>名称—值对都封装到这个字典中)
def build_profile(first,last,**user_info):
    """创建一个字典，其中包含我们知道的有关用户的一切"""
    profile = {}
    profile['first_name'] = first
    profile['last_name'] = last
    for key,value in user_info.items():
        profile[key] = value
    return profile
user_profile = build_profile('zhang','shan',
                             location='china',
                             field='physics')
print(user_profile)

# 将函数存储在模块中
# 导入整个模块

# cat pizza.py
#def make_pizza(size,*toppings):
#    """概述要制作的披萨"""
#    print("
makeing a "+str(size)+
#          "-inch pizza with the following toppings:")
#    for topping in toppings:
#        print("- "+topping)

# 在pizza.py所在的目录中创建另一个名为making_pizzas.py的文件，这个文件导入刚创建的模块，再调用make_pizza()两次：

#   cat making_pizzas.py
import pizza
pizza.make_pizza(16,'pepperoni')
pizza.make_pizza(21,'mushrooms','green peppers','extra cheese')

# import语句可以导入模块中的任何一个函数（模块中有多个函数）
# 例如：module_name.function_name()


# 导入特定的函数
# 导入方法的语法：from module_name importfunction_name
# 逗号分隔函数名，可根据需要从模块中导入任意数量的函数：from module_name importfunction_0,function_1,function_2

from pizza import make_pizza
make_pizza(33,'haha')
make_pizza(44,'hehe','hoho','huhu')

# 使用as给函数指定别名-语法：from module_name importfunction_name as fn
# 下面给函数make_pizza()指定了别名mp()。这是在import语句中使用make_pizza asmp实现的，关键字as将函数重命名为你提供的别名
from pizza import make_pizza as mp
mp(55,'laozhang')
mp(66,'laowang','laoli','laohuang')

# 使用as给模块指定别名-语法：importmodule_name as mn
import pizza as p
p.make_pizza(77,'coco')
p.make_pizza(88,'lili','bobo','popo')

# 导入模块中的所有函数-语法：from pizza import *
# 使用星号（*）运算符可让python导入模块中的所有函数：
from pizza import *
make_pizza(110,'wowo')
make_pizza(220,'qoqo','eoeo','roro')

七、类

# -*- coding: utf-8 -*-
# 类
# 创建和使用类
# 创建Dog类(约定，在Python中，首字母大写的名称指的是类)
# 1.方法_int_()   :类中的函数称为方法,开头和末尾各有两个下划线，这是一种约定.
# 在这个方法的定义中，形参self必不可少，还必须位于其他形参的前面---原因：每个与类相关联的方法调用都自动传递实参self，它是一个指向实例本身的引用，让实例能够访问类中的属性和方法。

# 以self为前缀的变量都可供类中的所有方法使用，我们还可以通过类的任何实例来访问这些变量;
# self.name = name获取存储在形参name中的值，并将其存储到变量name中,通过实例访问的变量称为属>性;

class Dog():
    """一次模拟小狗的简单尝试"""
    def __init__(self,name,age):
        """初始化属性name和age"""
        self.name = name
        self.age = age
    def sit(self):
        """模拟小狗被命令时蹲下"""
        print(self.name.title()+" is now sitting.")
    def roll_over(self):
        """模拟小狗被命令时打滚"""
        print(self.name.title()+" rolled over!")
my_dog = Dog('willie',6)
print("my dog's name is "+my_dog.name.title()+".")
print("my dog is "+str(my_dog.age)+" years old.")
# Python使用实参'willie'和6调用Dog类中的方法__init__()。方法__init__()创建一个表示特定小狗的示例

# 在Python 2.7中创建类时，需要做细微的修改——在括号内包含单词object：
#class classname(object):
#    --snip--

# 1.访问属性2.调用方法
# 要访问实例的属性，可使用句点表示法,如下代码来访问my_dog的属性name的值：
my_dog.name
class Dog():
    """一次模拟小狗的简单尝试"""
    def __init__(self,name,age):
        """初始化属性name和age"""
        self.name = name
        self.age = age
    def sit(self):
        """模拟小狗被命令时蹲下"""
        print(self.name.title()+" is now sitting.")
    def roll_over(self):
        """模拟小狗被命令时打滚"""
        print(self.name.title()+" rolled over!")
my_dog = Dog('willie',6)
my_dog.sit()
my_dog.roll_over()

# 使用类和实例--car类
class Car():
    """一次模拟汽车的简单尝试"""
    def __init__(self,make,model,year):
        """初始化描述汽车的属性"""
        self.make = make
        self.model = model
        self.year = year
    def get_descriptive_name(self):
        """返回整洁的描述性信息"""
        long_name = str(self.year)+' '+self.make+' '+self.model
        return long_name.title()
my_new_car = Car('audi','a4','2020')
print(my_new_car.get_descriptive_name())

# 给属性指定默认值，添加一个名为odometer_reading的属性，其初始值总是为0;名为read_odometer()的方法，用于读取汽车的里程表
class Car():
    def __init__(self,make,model,year):
        """初始化描述汽车的属性"""
        self.make = make
        self.model = model
        self.year = year
        self.odometer_reading = 0
    def get_descriptive_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_reading)+" miles on it.")
my_new_car = Car('audi','a4',2020)
print(my_new_car.get_descriptive_name())
my_new_car.read_odometer()

# 修改属性的值
my_new_car = Car('audi','a4',2020)
print(my_new_car.get_descriptive_name())
my_new_car.odometer_reading = 23
my_new_car.read_odometer()
# 通过方法修改属性的值
class Car():
    def __init__(self,make,model,year):
        """初始化描述汽车的属性"""
        self.make = make
        self.model = model
        self.year = year
        self.odometer_reading = 0
    def get_descriptive_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_reading)+" miles on it.")
    def update_odometer(self,mileage):
        """将里程表读数设置为指定的值"""
        self.odometer_reading = mileage
my_new_car = Car('audi','a4',2021)
print(my_new_car.get_descriptive_name())
my_new_car.update_odometer(66)
my_new_car.read_odometer()

# 对方法update_odometer()进行扩展，添加逻辑

class Car():
    def __init__(self,make,model,year):
        """初始化描述汽车的属性"""
        self.make = make
        self.model = model
        self.year = year
        self.odometer_reading = 0
    def get_descriptive_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_reading)+" miles on it.")
    def update_odometer(self,mileage):
        """
        将里程表读数设置为指定的值
        禁止将里程表读数往回调
        """
        if mileage >= self.odometer_reading:
            self.odometer_reading = mileage
        else:
            print("you can't roll back an odometer!")
#my_new_car = Car('audi','a4',2021)
#print(my_new_car.get_descriptive_name())
#my_new_car.update_odometer(-1)
#my_new_car.read_odometer()

# 通过方法对属性的值进行递增
    def increment_odometer(self,miles):
        """讲里程表读数曾加指定的量"""
        self.odometer_reading+= miles
my_used_car = Car('subaru','outback',2022)
print(my_used_car.get_descriptive_name())
my_used_car.update_odometer(5000)
my_used_car.read_odometer()
my_used_car.increment_odometer(-6000)
my_used_car.read_odometer()


# 继承(子类继承了其父类的所有属性和方法，同时还可以定义自己的属性和方法)

class Car():
    """一次模拟汽车的简单尝试"""
    def __init__(self,make,model,year):
        self.make = make
        self.model = model
        self.year = year
        self.odometer_reading = 0
    def get_descriptive_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_reading)+" miles on it.") 
    def update_odometer(self,mileage):
        if mileage >= self.odometer_reading:
            self.odometer_reading = mileage
        else:
            print("you can't roll back an odometer!")
    def increment_odometer(self,miles):
        self.odometer_reading+= miles
class ElectricCar(Car):
    """电动汽车独特之处"""
    def __init__(self,make,model,year):
        """初始化父类的属性"""
        Car.__init__(self,make,model,year)
my_tesla = ElectricCar('tesla','model s',2022)
print(my_tesla.get_descriptive_name())
 
#    python2.7中的继承
#class Car(object):
#    def __init__(self,make,model,year):
#        --snip--
#class ElectricCar(Car):
#    def __init__(self,make,model,year):
#        super(ElectricCar,self).__init__(make,model,year)
#        --snip--

# 给子类定义属性和方法

#class Car():
#    --snip--
class ElectricCar(Car):
    """repersent aspects of a car,sepcific to electric vehicles."""
    def __init__(self,make,model,year):
        """
        电动汽车的独特之处
        初始化父类的属性，再初始化电动汽车特有的属性
        """
        Car.__init__(self,make,model,year)
        self.battery_size = 70
    def describe_battery(self):
        """打印一条描述电瓶容量的消息"""
        print("this car has a "+str(self.battery_size)+"-kwh battery.")
my_tesla = ElectricCar('tesla','model s',2020)
print(my_tesla.get_descriptive_name())
print(my_tesla.describe_battery())

#  重写父类的方法(重写fill_gas_tank()的方法:调用该方法则忽略打印下述代码)

class ElectricCar(Car):
    def fill_gas_tank():
        """电动汽车没有油箱"""
        print("this car doesn't need a gas tank!")

# 将实例用作属性（可以将大类中同属性的小类提取出来作为大类中的一个属性）

#class Car():
#    --snip--
class Battery():
    """一次模拟电动汽车电瓶的简单尝试"""
    def __init__(self,battery_size=80):
        """初始化电瓶的属性"""
        self.battery_size = battery_size
    def describe_battery(self):
        """打印一条描述电瓶容量的消息"""
        print("this car has a "+str(self.battery_size)+"-kwh battery.")
    def get_range(self):
        """打印一条消息，指出电瓶的续航里程"""
        if self.battery_size == 80:
            range = 240
        elif self.battery_size == 85:
            range = 270
        message = "this car can go approximately "+str(range)
        message+= " miles on a full charge."
        print(message)
class ElectricCar(Car):
    """电动汽车的独特之处"""
    def __init__(self,make,model,year):
        """
        初始化父类的属性，再初始化电动汽车特有的属性
        """
        Car.__init__(self,make,model,year)
        self.battery = Battery(85)
# 若没有指定尺寸85，则默认值为80
my_tesla = ElectricCar('tesla','model',2023)
print(my_tesla.get_descriptive_name())
my_tesla.battery.describe_battery()
my_tesla.battery.get_range()

# 导入类
#    导入单个类

# cat car.py
#   (模块级文档字符串)
#"""一个可用于表示汽车的类"""
#class Car():
#    """一次模拟汽车的简单尝试"""
#    def __init__(self,make,model,year):
#        """初始化描述汽车的属性"""
#        self.make = make
#        self.model = model
#        self.year = year
#        self.odometer_reading = 0
#    def get_descriptive_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_reading)+" miles on it.")
#    def update_odometer(self,mileage):
#        """
#        讲里程表读数设置为指定的值
#        拒绝将里程表往回拨
#        """
#        if mileage >= self.odometer_reading:
#            self.odometer_reading = mileage
#        else:
#            print("you can't roll back an odometer!")
#    def increment_odometer(self,miles):
#        """讲里程表读数增加指定的量"""
#        self.odometer_reading+= miles
# ***************************************
# cat my_car.py
#from car import Car
#my_new_car = Car('benchi','c320',2023)
#print(my_new_car.get_descriptive_name())
#my_new_car.odometer_reading = 23
#my_new_car.read_odometer()


# 在一个模块中存储多个类
# cat car.py

#"""一组用于表示燃油汽车和电动汽车的类"""
#class Car():
#    --snip--
#class Battrey():
#    --snip--
#class ElectricCar(Car):
#    --snip--
# ************************
# cat my_electric_car.py
#from car import ElectricCar
#my_tesla = ElectricCar('tesla','model s',2030)
#print(my_tesla.get_descriptive_name())
#my_tesla.battery.describe_battery()
#my_tesla.battery.get_range()

# 从一个模块中导入多个类
# my_cars.py

#from car import Car,ElectricCar
#my_beetle = Car('volkswagen','beetle',2040)
#print(my_beetle.get_descriptive_name())
#my_tesla = ElectricCar('tesla','roadster',2050)
#print(my_tesla.get_get_descriptive_name())

# 导入整个模块
# my_cars.py

#import car
#my_dazhong = car.Car('jieda','dazhong',2010)
#print(my_dazhong.get_descriptive_name())
#my_tesla = car.ElectricCar('tesla','model s',2040)
#print(my_tesla.get_descriptive_name())

# 导入模块中的所有类(不推荐)
#frommodule_name import *

# 在一个模块中导入另一个模块

#cat car.py
#"""一个可用于表示汽车的类"""
#class Car():
#    --snip--

#cat electric_car.py
#"""一组可用于表示电动汽车的类"""
#from car import Car
#class Battery():
#    --snip--
#class ElectricCar(Car):
#    --snip--

# 首先从模块collections中导入了OrderedDict类
# 创建了OrderedDict类的一个实例，并将其存储到favorite_languages中
# 调用OrderedDict()来创建一个空的有序字典，并将其存储在favorite_languages中。
# 接下来，我们以每次一对的方式添加名字—语言对
# 之后我们遍历favorite_languages

from collections import OrderedDict
favorite_languages = OrderedDict()
favorite_languages['jen'] = 'python'
favorite_languages['sarah'] = 'c'
favorite_languages['edward'] = 'ruby'
favorite_languages['phil'] = 'python'
for name,language in favorite_languages.items():
    print(name.title()+"'s favorite language is "+ language.title()+".")


八、文件和异常

# -*- coding: utf-8 -*-
#        文件和异常

#     从文件中读取数据
# 读取整个文件
#cat pi_digits.txt
#3.1415926535
#  8979323846
#  2643383279

#cat file_reader.py
# 调用open()和close()来打开和关闭文件,使用方法read()读取这个文件的全部内容存储在contents中
with open('pi_digits.txt') as file_object:
    contents = file_object.read()
    print(contents)
# 结果多出一个空行(因为read()到达文件末尾时返回一个空字符串),删除空行-可使用rstrip()
    print(contents.rstrip())

# 文件路径

# linux中"/"
#with open('text_files/filename.txt') as file_object:
# windows中""
#with open('text_filesfilename.txt') as file_object:

# 绝对路径一般可能较长，可存储变量中
# linux中
#file_path = '/home/ehmatthes/other_files/text_files/filename.txt'
#with open(file_path) as file_object:
# windows中
#file_path = 'C:Userehmatthesother_files	ext_filesfilename.txt'
#with open(file_path) as file_object:

# 逐行读取
#cat file_reader.py
filename = '/pi_digits.txt'
with open(filename) as file_object:
    for line in file_object:
        print(line)

# 创建一个包含文件各行内容的列表
filename = 'pi_digits.txt'
with open(filename) as file_object:
    lines = file_object.readlines()
for line in lines:
    print(line.rstrip())

# 使用文件的内容
#cat pi_string.py
filename = 'pi_digits.txt'
with open(filename) as file_object:
    lines = file_object.readlines()
pi_string = ''
for line in lines:
    pi_string+= line.rstrip()
print(pi_string)
print(len(pi_string))

# 去除每行左边的空格--strip()
print("-----")
filename = 'pi_digits.txt'
with open(filename) as file_object:
    lines = file_object.readlines()
pi_string = ''
for line in lines:
    pi_string+= line.strip()
print(pi_string)
print(len(pi_string))

# 打印到某一位，如打印到小数点后第十位
print(pi_string[:12]+"...")
print(len(pi_string))

# 搜索其中符合自己想要的字符串
birthday = input("enter your birthday, in the form mmddyy: ")
if birthday in pi_string:
    print("your birthday appears in the first million digits of pi!")
else:
    print("your birthday does not appear in the first million digits of pi.")

# 写入文件
# (调用open()时提供了两个实参,指定读取模式（'r'）、写入模式（'w'）、附加模式（'a'）或让你能够读取和写入文件的模式（'r+'）)
filename = 'liujinye.txt'
with open(filename,'w') as file_object:
    file_object.write("I love liujinye.
")
# 写入多行
    file_object.write("You're my baby !
")

# 附加到文件(给文件添加内容)
with open(filename,'a') as file_object:
    file_object.write("I also love finding meaning in large datasets.
")

# 异常
# (编写了处理异常的代码,程序将运行；未处理将停止并显示traceback报告)异常是try-except代码处理的

# 处理ZeroDivisionError异常
# cat division.py
#print(5/0)

# 使用try-except代码块

try:
    print(5/0)
except ZeroDivisionError:
    print("you can't divide by zero !")

# 使用异常避免崩溃
print("Give me two nmubers, and I'll divide them.")
print("Enter 'q' to quit.")
while True:
    first_number = input("
First number: ")
    if first_number == 'q':
        break
    second_number = input("Second number:")
    if second_number == 'q':
        break
    try:
        answer = int(first_number) / int(second_number)
    except ZeroDivisionError:
        print("you can't divide by 0 !")
    except ValueError:
        print("you can't input empty !")
    else:
        print(answer)

# 处理FileNotFoundError异常

filename = 'empty.txt'
try:
    with open(filename) as f_obj:
        contents = f_obj.read()
except IOError:
    msg = "sorry, the file "+filename+" does not exist."
    print(msg)

# 分析文本


filename = 'alice.txt'
try:
    with open(filename) as f_obj:
        contents = f_obj.read()
except IOError:
    msg = "Sorry,the file "+filename+" does not exist."
    print(msg)
else:
    # 计算文件大致包含多少个单词
    words = contents.split()
    num_words = len(words)
    print("The file "+filename+" has about "+str(num_words)+" words. ")

# 使用多个文件
def count_words(filename):
    """计算一个文件大致包含多少个单词"""
    try:
        with open(filename) as f_obj:
            contents = f_obj.read()
    except IOError:
        msg = "sorry, the file "+filename+" does not exist."
        print(msg)
    else:
        # 计算文件大致包含多少个单词
        words = contents.split()
        num_words = len(words)
        print("the file "+filename+" has about "+str(num_words)+" words. ")
filename = 'alice.txt'
count_words(filename)
filenames = ['alice.txt','/etc/passwd','liujinye','/var/log/messages']
for filename in filenames:
    count_words(filename)

# 失败时一声不吭
print("=======失败时不输出=======")
def count_words(filename):
    """计算一个文件大致包含多少个单词"""
    try:
        with open(filename) as f_obj:
            contents = f_obj.read()
    except IOError:
        pass
    else:
        # 计算文件大致包含多少个单词
        words = contents.split()
        num_words = len(words)
        print("the file "+filename+" has about "+str(num_words)+" words. ")
filename = 'alice.txt'
count_words(filename)
filenames = ['alice.txt','/etc/passwd','liujinye','/var/log/messages']
for filename in filenames:
    count_words(filename)

# 使用方法count()来确定特定的单词或短语在字符串中出现了多少次
line = "root,ROOT,Root"
print(line.count('root'))
print(line.lower().count('root'))

# 存储数据

# 使用json.dump()和json.load()
# cat number_write.py
#    使用函数json.dump()将数字列表存储到文件numbers.json中
import json
number = [2,3,5,7,11,13]
filename = 'numbers.json'
with open(filename,'w') as f_obj:
    json.dump(number,f_obj)

#    使用json.load()将这个列表读取到内存中：
import json
filename = 'numbers.json'
with open(filename) as f_obj:
    numbers = json.load(f_obj)
print(numbers)

#  以上是一种在程序之间共享数据的简单方式。

# 保存和读取用户生成的数据

#    存储用户输入的信息
import json
username = input("What is your name? ")
filename = 'username.json'
with open(filename,'w') as f_obj:
    json.dump(username,f_obj)
    print("we'll remember you when you come back, "+username+"!")

#   向其名字被存储的用户发出问候

import json
filename = 'username.json'
with open(filename) as f_obj:
    username = json.load(f_obj)
    print("welcome back , "+username+"!")


#  合并
import json
# 如果以前存储了用户名，就加载它
# 否则，就提示用户输入用户名并存储它
filename = 'username.json'
try:
    with open(filename) as f_obj:
        username = json.load(f_obj)
except IOError:
    username = input("what is your name? ")
    with open(filename,'w') as f_obj:
        json.dump(username,f_obj)
        print("we'll remember you when you come back, "+username+"!")
else:
    print("welcome back , "+username+"!")

print("=======================")
# 重构（将上述合并内容，重构定义函数，每个函数一个任务）
import json
def get_stored_username():
    """如果存储了用户名，就获取它"""
    filename = 'username.json'
    try:
        with open(filename) as f_obj:
            username = json.load(f_obj)
    except IOError:
        return None
    else:
        return username
def get_new_username():
    """提示用户输入用户名"""
    username = input("what is your name? ")
    filename = 'username.json'
    with open(filename,'w') as f_obj:
        json.dump(username,f_obj)
    return username
def greet_user():
    """问候用户，并指出其名字"""
    username = get_stored_username()
    if username:
        print("welcome back, "+username+"!")
    else:
        username = get_new_username()
        print("we'll remeber you when you come back, "+username+"!")
# 调用函数
greet_user()
get_stored_username()
get_new_username()


九、测试代码

# -*- coding: utf-8 -*-
# 测试代码

#   测试函数
# cat name_function.py
def get_formatted_name(first,last):
    """generate a neatly formatted full name. """
    full_name = first+' '+last
    full_name = first+' '+middle+' '+last
    return full_name.title()

from name_function import get_formatted_name
print("Enter 'q' at any time to quit.")
while True:
    first = input("
Please give me a first name: ")
    if first == 'q':
        break
    last = input("Please give me a last name: ")
    if last == 'q':
        break
    formatted_name = get_formatted_name(first,last)
    print("	Neatly formatted name: "+formatted_name+'.')


# 单元测试和测试用例

# 可通过的测试例

# (先导入模块unittest以及要测试的函数，再创建一个继承unittest.TestCase的类，并编写一系列方法对函数行为的不同方面进行测试。)
import unittest
from name_function import get_formatted_name
class NamesTestCase(unittest.TestCase):
    """测试name_function.py"""
    def test_first_last_name(self):
        """能够正确的处理像Janis Joplin这样的姓名吗？"""
# 使用实参'janis'和'joplin'调用get_formatted_name()，并将结果存储到变量formatted_name中
        formatted_name = get_formatted_name('zhang','shan')
# 断言方法用来核实得到的结果是否与期望的结果一致,调用unittest的方法assertEqual(),向它传递formatted_name和'Janis Joplin'进行比较
        self.assertEqual(formatted_name,'Zhang Shan')
# 代码行unittest.main()让Python运行这个文件中的测试
unittest.main()

# 不能通过的测试例

#cat name_function.py

#def get_formatted_name(first,middle,last):
#    """生成整洁的姓名"""
#    full_name = first+' '+middle+' '+last
#    return full_name.title()

#cat test_name_function.py
#import unittest
#from name_function import get_formatted_name
#class NamesTestCase(unittest.TestCase):
#    """测试name_function.py"""
#    def test_first_last_name(self):
#        """能够正确的处理像Janis Joplin这样的姓名吗？"""
#        formatted_name = get_formatted_name('zhang','shan')
#        self.assertEqual(formatted_name,'Zhang Shan')
#unittest.main()

# 测试未通过怎么办

# 不修改测试，修改函数

#cat name_function.py
#def get_formatted_name(first,last,middle=''):
#    """生成整洁的姓名"""
#    if middle:
#        full_name = first+' '+middle+' '+last
#    else:
#        full_name = first+' '+last
#    return full_name.title()
# 测试代码不变


# 添加新测试


#import unittest
#from name_function import get_formatted_name
#class NameTestCase(unittest.TestCase):
#    """测试name_function.py"""
#    def test_first_last_name(self):
#        """能够正确的处理像zhang shan这样的姓名嘛？"""
#        formatted_name = get_formatted_name('zhang','shan')
#        self.assertEqual(formatted_name,'Zhang Shan')
#    def test_first_last_middle_name(self):
#        """能够正确的处理像zhang da shan这样的姓名嘛？"""
#        formatted_name = get_formatted_name('zhang','shan','da')
#        self.assertEqual(formatted_name,'Zhang Da Shan')
#unittest.main()


#------------    测试的类   --------------

#    各种断言方法
print("
--------unittest Module中的断言方法-----------")
unittest_moudle = {
    'assertEqual(a,b)':'核实a == b',
    'assertNotEqual(a,b)':'核实a != b',
    'assertTrue(x)':'核实x为True',
    'assertFalse(x)':'核实x为False',
    'assertIn(item,list)':'核实item在list中',
    'assertNotIn(item,list)':'核实item不在list中'
}
for way,mean in unittest_moudle.items():
    print("
方法: "+way)
    print("含义: "+mean)
    print("
		"+way+" : "+mean)

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

from nine import AnonymousSurvey
# 定义一个问题，并创建一个表示调查的AnonymousSurvey对象
question = "what languages did you first learn to speak?"
my_nine = AnonymousSurvey(question)
# 显示问题并存储答案
my_nine.show_question()
print("enter 'q' at any time to quit.
")
while True:
    response = input("Language: ")
    if response == 'q':
         break
    my_nine.store_response(response)
# 显示调查结果
print("
thank you to everyone who participated in the survey!")
my_nine.show_results()

# 测试AnonymousSurvey类
#    验证：如果用户面对调查问题时只提供了一个答案，这个答案也能被妥善地存储,存储后，使用方法assertIn()来核实它包含在答案列表中.

print("
------------ 'assertIn'测试方法需python2.7及以上环境 -----------------")

print("
=====测试只能测试第一个，之后所有代码忽略======")
#cat test_nine.py

#import unittest
#from nine import AnonymousSurvey
#class TestAnonymousSurvey(unittest.TestCase):
#    """针对AnonymousSurvey类的测试"""
#    def test_store_single_response(self):
#        """测试单个答案会被妥善的存储"""
#        question = "what language did you first learn to speak?"
#        my_nine = AnonymousSurvey(question)
#        my_nine.store_response('English')
#        self.assertIn('English',my_nine.responses)
#    def test_store_three_responses(self):
#        """测试三个答案会被妥善地存储"""
#        question = "what language did you first learn to speak?"
#        my_nine = AnonymousSurvey(question)
#        responses = ['English','Chanise','Spanish']
#        for response in responses:
#            my_nine.store_response(response)
#        for response in responses:
#            self.assertIn(response,my_nine.responses)
#unittest.main()

print("
小结：注意　运行测试用例时，每完成一个单元测试，Python都打印一个字符：测试通过时打印一个句点；测试引发错误时打印一个E；测试导致断言失败时打印一个F。这就是你运行测试用例时，在输出的第一行中看到的句点和字符数量各不相同的原因。如果测试用例包含很多单元测试，需要运行很长时间，就可通过观察这些结果来获悉有多少个测试通过了。")

# 方法setUp()

# 优先运行方法setUp()
import unittest
from nine import AnonymousSurvey
class TestAnonymousSurvey(unittest.TestCase):
    """针对AnonymousSurvey类的测试"""
    def setUp(self):
        """创建一个调查对象和一组答案，供使用的测试方法使用"""
        question = "what language did you first learn to speak?"
        self.my_nine = AnonymousSurvey(question)
        self.responses = ['english','chanise','spanish']
    def test_store_single_response(self):
        """测试单个答案会被妥善的存储"""
        self.my_nine.store_response(self.responses[0])
        self.assertIn(self.responses[0],self.my_nine.responses)
    def test_store_three_responses(self):
        """测试三个答案会被妥善地存储"""
        question = "what language did you first learn to speak?"
        my_nine = AnonymousSurvey(question)
        responses = ['English','Chanise','Spanish']
        for response in responses:
            my_nine.store_response(response)
        for response in responses:
            self.assertIn(response,my_nine.responses)
unittest.main()