基础
变量名小写
\t 制表符
\n 换行符
+拼接
print("") 输出 #python3版本一定包含()；python2版本有的包含有的不包含。
title() 首字母大写
upper() 都大写
lower() 都小写
rstrip() 删除结尾空白
lstript() 删除开头空白
stript（） 删除开头和结尾空白
加减乘除+-*/
a**b a的b次方
str() 想要输出数字时，将数值转为字符串
a/b 整除，直接去掉小数，除非至少有一个元素为浮点数（python3好像整数也都是一位小数）
a%b 求模，当b=2时，可以验证a是否为偶数。
列表
基础
用方括号（[] ）来表示列表，并用逗号来分隔其中的元素。
a[-1]为列表中最后一项 ，a[-2]为列表中倒数第二项，以此类推。
a=["aas","ssd"]
末尾增：a.append();
中间增：a.insert(index,"")
改：a[0]="ssdd"
删(已知角标)：del a[0]
删除列表末尾的元素并保存：a.pop()
使用pop() 来删除列表中任何位置的元素：a.pop(index)
删(已知值)：a.remove("")
组织列表
永久排序：a.sort()
永久反向排序 ：a.sort(reverse=True)
临时排序：a.sorted()
临时反向排序 ：a.sorted(reverse=True)
#注意，reverse() 不是指按与字母顺序相反的顺序排列列表元素，而只是反转列表元素的排列顺序：
确定长度：len(a)
# 每当需要访问最后一个列表元素时，都可使用索引-1,当列表为空时，报错。list index out of range
操作列表
for循环
magicians = ['alice', 'david', 'carolina']
for magician in magicians:
缩进的代码每次都循环
不缩进的代码每次只循环一次
# 通常，将紧跟在for 语句后面的代码行缩进，可消除这种缩进错误
# for 语句末尾的冒号告诉Python，下一行是循环的第一行。
创建数值列表
for value in range(1,5):
print(value)
输出：
1
2
3
4
# 函数range() 让Python从你指定的第一个值开始数，并在到达你指定的第二个值后停止.
#使用range() 创建数字列表
numbers = list(range(1,6))
print(numbers)
输出：[1,2,3,4,5]
#range设置步长
even_numbers = list(range(2,11,2))
print(even_numbers)
输出：
[2, 4, 6, 8, 10]
最大值：max(a)
最小值：min(a)
总和：sum(a)
列表解析
squares = [value**2 for value in range(1,11)]
print(squares)
输出：
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
使用列表的一部分（切片）
处理列表的部分元素——Python称之为切片
要输出列表中的前三个元素，需
要指定索引0~3，这将输出分别为0 、1 和2 的元素。[0:3]
注意：
1.起始索引可以省去，这样默认为从头开始
2.终止索引可以省去，这样默认为到列表末尾结束
3.索引可以省去，这样默认为从头开始
4.负数索引返回离列表末尾相应距离的元素 players[-3:] 最后三个元素
遍历切片
for player in players[:3]:
print(player.title())
复制列表
my_foods = ['pizza', 'falafel', 'carrot cake']
friend_foods = my_foods[:]
注意：如果没用切片，那么两个列表分别添加的内容将都添加到两个列表里。
（让Python将新变量friend_foods 关联到包含在my_foods 中的列表，因此这两个变量都指向同一个列表。）
set
元组
不可变的列表被称为元组，用括号定义
dimensions = (200, 50)
print(dimensions[0])
print(dimensions[1])
遍历
如果要修改前述矩形的尺寸，可重新定义整个元组
设置代码格式
缩进：每级缩进都使用四个空格
行长：每行不超过80字符，注释的行长都不超过72字符
**空行：**要将程序的不同部分分开，可使用空行。
if语句
条件测试
区分大小写
条件可以为一个变量是否为false
==相等
！=不相等
and 并
or 或
in 判断特定的值是否已包含在列表中
not in 判断特定的值是否不包含在列表中
# 不用加括号，可以省略else板块。
age = 12
if age < 4:
print("Your admission cost is $0.")
elif age < 18:
print("Your admission cost is $5.")
else:
print("Your admission cost is $10.")
在诸如== 、>= 和<= 等比较运算符两边各添加一个空格
字典
在Python中，字典是一系列键—值对，每个键都与一个值相关联。
alien_0 = {'color': 'green', 'points': 5} #键和值之间用冒号分隔，而键—值对之间用逗号分隔
查：
print(alien_0['color']) # 访问字典中的值
增：
alien_0 = {'color': 'green', 'points': 5}
print(alien_0)
alien_0['x_position'] = 0
alien_0['y_position'] = 25
print(alien_0)
删：
del alien_0['poins']
改：
重新覆盖即可
多行字典：
favorite_languages = {
'jen': 'python',
'sarah': 'c',
'edward': 'ruby',
'phil': 'python',
}
#定义好字典后，在最后一个键—值对的下一行添加一个右花括号，并缩进四个空格，使其与字典中的键对齐。
#另外一种做法是在最后一个键—值对后面也加上逗号，为以后在下一行添加键—值对做好准备。
遍历字典
user_0 = {
'username': 'efermi',
'first': 'enrico',
'last': 'fermi',
}
for key, value in user_0.items():
print("\nKey: " + key)
print("Value: " + value)
输出：
Key: last
Value: fermi
Key: first
Value: enrico
Key: username
Value: efermi
遍历字典中的所有键
for name in favorite_languages.keys():
print(name.title())
# .keys可省略。
按顺序遍历字典中的所有键
for name in sorted(favorite_languages.keys()):
print(name.title() + ", thank you for taking the poll.")
遍历字典中的所有值
for language in favorite_languages.values():
print(language.title())
为剔除重复项，可使用集合（set）。集合类似于列表
for language in set(favorite_languages.values()):
print(language.title())
嵌套
# 创建一个用于存储外星人的空列表
aliens = []
# 创建30个绿色的外星人
for alien_number in range(30):
new_alien = {'color': 'green', 'points': 5, 'speed': 'slow'}
aliens.append(new_alien)
#将颜色为绿色的外星人所有属性都改变
for alien in aliens[:3]:
if alien['colour']=='green':
alien['colour'] = 'yellow'
alien['points'] = 6
alien['speed'] = 'fast'
elif alien['color'] == 'yellow':
alien['color'] = 'red'
alien['points'] = 15
alien['speed'] = 'medium'
# 显示前五个外星人
for alien in aliens[:5]:
print(alien)
print("...")
# 显示创建了多少个外星人
print("Total number of aliens: " + str(len(aliens)))
字典中可存在列表
在字典中存储字典
input
message = input("Tell me something, and I will repeat it back to you: ")
print(message)
输出：如果在输出窗口的后面输入什么内容，就会输出相同的内容。
Tell me something, and I will repeat it back to you: Hello everyone!
Hello everyone！
补充：
1.字符串可以直接用+来串联
2.输入的默认为字符串，如果需要把它作为int使用，需要转型，比如age=int(age)
while循环
prompt = "\nTell me something, and I will repeat it back to you:"
prompt += "\nEnter 'quit' to end the program. "
message = ""
while message != 'quit':
message = input(prompt)
if message != 'quit':
print(message)
使用break退出循环
rompt = "\nPlease enter the name of a city you have visited:"
prompt += "\n(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() + "!")
使用标志
prompt="\n Tell me city:"
prompt+="\nEnter 'quit' to end the program"
while True:
city=input(prompt)
if city=='quit':
break
else:
print("i will visit "+city.title()+"!")
使用continue
要返回到循环开头，并根据条件测试结果决定是否继续执行循环，可使用continue 语句，它不像break 语句那样不再执行余下的代码并退出整个循环.
需求：打印出1~10中的奇数
current_number=0
while current_number<10:#注意范围
current_number+=1
if current_number%2==0:
continue
print(current_number)
使用while 循环来处理列表和字典
for 循环是一种遍历列表的有效方式，但在for 循环中不应修改列表，否则将导致Python难以跟踪其中的元素。
**要在遍历列表的同时对其进行修改，可使用while 循环。**通过将while 循环同列表和字典结合起来使用，可收集、存储并组织大量输入，供以后查看和显示。
列表之间移动元素
需求：将验证过的用户从待验证用户名单中移到已验证用户中。
#待验证用户
#已验证用户
unconfirmed_users=['david','alice','tom']
confirmed_users=[]
while unconfirmed_users:
current_user=unconfirmed_users.pop()
print("verifying user:"+current_user)
confirmed_users.append(current_user)
# 被验证的用户
for confirmed_user in confirmed_users:
print(confirmed_user)
删除包含特定值的所有列表元素
需求：将动物列表中的cat移除
pets=['dog','cat','rabbit','pig','cat']
print(pets)
while 'cat' in pets:
pets.remove('cat') #已知值得删除
print(pets)
使用用户输入来填充字典
需求：可使用while循环提示用户输入任意数量的信息。下面来创建一个调查程序，其中的循环每次执行时都提示输入被调查者的名字和回答。我们将收集的数据存储在一个字典中，以便将回答同被调查者关联起来：
利用标志
responses={}
polling_active=True
while polling_active:
name=input("What's your name")
response=input("what moutain would you like to climb")
responses[name]=response#字典的键值对
repeat=input("whould you like to let another person respond")
if repeat=='No':
polling_active=False
for name,response in responses.items():
print(name+" likes climb the "+response)
函数
函数是带名字的代码块，用于完成具体的工作
定义函数
def greet_user():
print('Hello,world')
greet_user()
向函数传递信息
def greet_user(username):
print("Hello, " + username.title() + "!")
greet_user('lcy')
username为形参，'lcy’为实参。
传递实参
位置实参
最简单的关联方式是基于实参的顺序。这种关联方式被称为位置实参
def describe_pet(animal_type,pet_name):
print(animal_type)
print(pet_name)
describe_pet('cat','honey')
注意位置实参的顺序
关键字实参
不需要关注顺序
def describe_pet(animal_type,pet_name):
print(animal_type)
print(pet_name)
describe_pet(animal_type='cat',pet_name='honey')
默认值
使用默认值时，在形参列表中必须先列出没有默认值的形参，再列出有默认值的实参。
def describe_pet(pet_name,animal_type='dog'):#默认值放在后面
print(animal_type)
print(pet_name)
describe_pet(animal_type='cat',pet_name='honey')
返回值
函数并非总是直接显示输出，相反，它可以处理一些数据，并返回一个或一组值。函数返回的值被称为返回值。return
可以通过加if使实参变成可选的
返回字典
传递列表
def greet_users(names):
for name in names:
msg="Hello, "+name.title()+"!"
print(msg)
names=['lcy','david','nancy']
greet_users(names)
禁止函数修改列表
要将列表的副本传递给函数，可以像下面这样做：
function_name(list_name[:])
切片表示法[:] 创建列表的副本。在print_models.py中，如果不想清空未打印的设计列表，可像下面这样调用print_models() ：
print_models(unprinted_designs[:], completed_models)
传递任意数量的实参
*toppings是空元组
def make_pizza(*toppings):
print(toppings)
make_pizza('jk','jkjk','vggh')
make_pizza('jk')
输出为：
('jk', 'jkjk', 'vggh')
('jk',)
经过处理后：
def make_pizza(*toppings):
print("\nare as follows:")
for topping in toppings:
print("- "+topping)
make_pizza('jk','jkjk','vggh')
make_pizza('jk')
结果为：
are as follows:
- jk
- jkjk
- vggh
are as follows:
- jk
结合使用位置实参和任意数量实参（键值对-字典）
如果要让函数接受不同类型的实参，必须在函数定义中将接纳任意数量实参的形参放在最后。Python先匹配位置实参和关键字实参，再将余下的实参都收集到最后一个形参中。
使用任意数量的关键字实参（键值对-字典）
**info是空字典
def build_person(first,last,**info):
person={}
person['first_name']=first
person['last_name'] = last
for key,value in info.items():
person[key]=value
return person
person=build_person('cy','li',
field='wx', #注意形式
intersts='reading')
print(person)
只能是字典么？
将函数存储在模块中
第一种调用
调用模块
import module_name
module_name.function_name()
实例：
# pizza.py
def make_pizza(size,*toppings):
print("the size is "+str(size))
for topping in toppings:
print("- "+topping)
# make_pizza.py
import pizza
pizza.make_pizza(12,'erfe','dd','aaa')
第二种调用
from module_name import function_name
使用as 给函数指定别名
第三种调用
from module_name import function_name as fn
使用as 给模块指定别名
import module_name as mn
导入模块中的所有函数
from module_name import *
函数编写指南
1.应给函数指定描述性名称，且只在其中使用小写字母和下划线。
2.每个函数都应包含简要地阐述其功能的注释，该注释应紧跟在函数定义后面，并采用文档字符串格式。
3.给形参指定默认值时and对于函数调用中的关键字实参时，等号两边不要有空格。
4.如果形参很多，导致函数定义的长度超过了79字符，可在函数定义中输入左括号后按回车键，并在下一行按两次Tab键，从而将形参列表和只缩进一层的函数体区分开来。
例如：
def function_name(
parameter_0, parameter_1, parameter_2,
parameter_3, parameter_4, parameter_5):
function body...
5.如果程序或模块包含多个函数，可使用两个空行将相邻的函数分开
6.所有的import 语句都应放在文件开头，唯一例外的情形是，在文件开头使用了注释来描述整个程序。
类
创建类
class Dog():
"""模拟一只小狗"""
def __init__(self,name,age):
self.name=name
self.age=age
def sit(self):
print(self.name.title()+"is sitting now")
def roll_over(self):
print(self.name.title()+"rolled over")
1.在Python中，首字母大写的名称指的是类。
2.类中的函数称为方法.__init__() 是一个特殊的方法，每当你根据Dog 类创建新实例时，Python都会自动运行它。在这个方法的名称中，开头和末尾各有两个下划线，这是一种约定，旨在避免Python默认方法与普通方法发生名称冲突。
3.方法__init__() 定义成了包含三个形参：self 、name 和age 。**在这个方法的定义中，形参self 必不可少，还必须位于其他形参的前面。**为何必须在方法定义中包含形参self 呢？因为Python调用这个__init__() 方法来创建Dog 实例时，将自动传入实参self。
4.以self 为前缀的变量都可供类中的所有方法使用，我们还可以通过类的任何实例来访问这些变量。
5.由于sit(),roll_over()不需要额外的信息，如名字或年龄，因此它们只有一个形参self 。
注意：在python2.7中创建需要在类名后的括号中加object
根据类创建实例
class Dog():
"""模拟一只小狗"""
def __init__(self,name,age):
self.name=name
self.age=age
def sit(self):
print(self.name.title()+"is sitting now")
def roll_over(self):
print(self.name.title()+"rolled over")
#"""创建实例"""
my_dog=Dog('wzt',6)
print("My dog's name is "+my_dog.name.title())
print("My dof is "+str(my_dog.age)+"years old")
#"""调用方法"""
my_dog.sit()
my_dog.roll_over()
修改属性值：
class Car():
def __init__(self,make,year,model):
self.make=make
self.year=year
self.model=model
self.love=0 # 添加属性
def describe_car(self):
long_name=str(self.year)+' '+self.make+' '+self.model
return long_name
def car_love(self):
print(str(self.love))
my_car=Car('wdwd',2000,'wedw')
print(my_car.describe_car())
my_car.love=25# 修改属性值
my_car.car_love()
用方法修改属性值：
class Car():
def __init__(self,make,year,model):
self.make=make
self.year=year
self.model=model
self.love=0 # 添加属性
def describe_car(self):
long_name=str(self.year)+' '+self.make+' '+self.model
return long_name
def car_love(self):
print(str(self.love))
def update_love(self,value):
self.love=value
my_car=Car('wdwd',2000,'wedw')
print(my_car.describe_car())
my_car.update_love(25)# 修改属性值
my_car.car_love()
继承
1.一个类继承另一个类时，它将自动获得另一个类的所有属性和方法；
2.原有的类称为父类，而新类称为子类。
3.子类继承了其父类的所有属性和方法，同时还可以定义自己的属性和方法。
class Car():
def __init__(self,make,year,model):
self.make=make
self.year=year
self.model=model
self.love=0 # 添加属性
def describe_car(self):
long_name=str(self.year)+' '+self.make+' '+self.model
return long_name
def car_love(self):
print(str(self.love))
def update_love(self,value):
self.love=value
class ElectricCar(Car):
def __init__(self,make,year,model):
super().__init__(make,year,model)
my_car=ElectricCar('wdwd',2000,'wedw')
print(my_car.describe_car())
my_car.update_love(25)# 修改属性值
my_car.car_love()
在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():
def __init__(self,make,year,model):
self.make=make
self.year=year
self.model=model
def describe_car(self):
long_name=str(self.year)+' '+self.make+' '+self.model
return long_name
def car_love(self):
print(str(self.love))
def update_love(self,value):
self.love=value
class ElectricCar(Car):
def __init__(self,make,year,model):
super().__init__(make,year,model)
self.love = 0 # 添加子类属性
def describe_car(self):
long_name=str(self.year)+' '+self.make+' '+self.model
return long_name
my_car=ElectricCar('wdwd',2000,'wedw')
print(my_car.describe_car())
对于父类的方法，只要它不符合子类模拟的实物的行为，都可对其进行重写。为此，可在子类中定义一个这样的方法，即它与要重写的父类方法同名。这样，Python将不会考虑这个父类方法，而只关注你在子类中定义的相应方法。
属性类：将实例用作属性
将类的一部分作为一个独立的类提取出来。你可以将大型类拆分成多个协同工作的小类
class Car():
def __init__(self,make,year,model):
self.make=make
self.year=year
self.model=model
def describe_car(self):
long_name=str(self.year)+' '+self.make+' '+self.model
return long_name
def car_love(self):
print(str(self.love))
def update_love(self,value):
self.love=value
class Love():# 添加属性类
def __init__(self,love=0):
self.love=love
def describe_love(self):
print(str(self.love))
class ElectricCar(Car):
def __init__(self,make,year,model):
super().__init__(make,year,model)
self.love = Love() # 添加属性，属性类的实例化
def describe_car(self):
long_name=str(self.year)+' '+self.make+' '+self.model+' '+str(self.love)
return long_name
my_car=ElectricCar('wdwd',2000,'wedw')
print(my_car.describe_car())
my_car.love.love=70#修改值，子类属性.属性类属性=value
my_car.love.describe_love()# 输出特殊属性,子类属性.属性类方法
导入类
1.在一个模块中储存一个类，从主模块导入该类
为在这方面提供帮助，Python允许你将类存储在模块中，然后在主程序中导入所需的模块。
from 模块名 import 类名
2.在一个模块中储存多个类，从主模块导入其中一个类
3.在一个模块中储存多个类，从主模块导入其中几个类
from 模块名 import 类名1，类名2
4.导入整个模块
import 模块名
调用时用my_car=模块名.类名（形参1，形参2，...）
5.导入模块中的所有类
from 模块名 import *
不建议.
原因：首先，如果只要看一下文件开头的import 语句，就能清楚地知道程序使用了哪些类，将大有裨益；但这种导入方式没有明确地指出你使用了模块中的哪些类。这种导入方式还可能引发名称方面的困惑。如果你不小心导入了一个与程序文件中其他东西同名的类，将引发难以诊断的错误。这里之所以介绍这种导入方式，是因为虽然不推荐使用这种方式，但你可能会在别人编写的代码中见到它。
6.在一个模块中导入另一个模块
from 模块名 import 类名
补充：
from collections import OrderedDict
favorite_languages = OrderedDict()# 创建一个有序的字典
类编码风格
1.类名应采用驼峰命名法，即将类名中的每个单词的首字母都大写，而不使用下划线。实例名和模块名都采用小写格式，并在单词之间加上下划线。
2.对于每个类，都应紧跟在类定义后面包含一个文档字符串。这种文档字符串简要地描述类的功能，并遵循编写函数的文档字符串时采用的格式约定。每个模块也都应包含一个文档字符串，对其中的类可用于做什么进行描述。
3.可使用空行来组织代码，但不要滥用。在类中，可使用一个空行来分隔方法；而在模块中，可使用两个空行来分隔类。
4.需要同时导入标准库中的模块和你编写的模块时，**先编写导入标准库模块的import 语句，再添加一个空行，然后编写导入你自己编写的模块的import 语句。**在包含多条import 语句的程序中，这种做法让人更容易明白程序使用的各个模块都来自何方
文件和异常
读取整个文件
with open('pi_digits.txt') as file_object:
contents=file_object.read()
print(contents)
这时输出会多出一行
3.1415926535
8979323846
2643383279
原因：
为何会多出这个空行呢？因为read() 到达文件末尾时返回一个空字符串，而将这个空字符串显示出来时就是一个空行。
解决：
with open('pi_digits.txt') as file_object:
contents=file_object.read()
print(contents.rstrip())#去掉空字符串
文件路径
相对路径：
Linux和OS X：
with open('text_files/filename.txt') as file_object:
Windows:
with open('text_files\filename.txt') as file_object:
绝对路径：
Linux和OS X：
file_path = '/home/ehmatthes/other_files/text_files/filename.txt'
with open(file_path) as file_object:
Windows:
file_path = 'C:\Users\ehmatthes\other_files\text_files\filename.txt'
with open(file_path) as file_object:
逐行读取
filename='pi_digits.txt'
with open(filename) as file_object:
for line in file_object:
print(line)
输出：
3.1415926535
8979323846
2643383279
为何会出现这些空白行呢？因为在这个文件中，每行的末尾都有一个看不见的换行符，而print 语句也会加上一个换行符，因此每行末尾都有两个换行符：一个来自文件，另一个来自print 语句。
要消除这些多余的空白行，可在print 语句中使用rstrip() ：
filename='pi_digits.txt'
with open(filename) as file_object:
for line in file_object:
print(line.rstrip())
创建一个包含文件各行内容的列表
filename='pi_digits.txt'
with open(filename) as file_object:
lines=file_object.readlines()
for line in lines:
print(line.rstrip())
使用文件的内容
需求：创建一个字符串，它包含文件中存储的所有数字，且没有任何空格：
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))
输出：
3.1415926535 8979323846 2643383279
38
因为txt文件中左边还有空格，因此需要strip()去掉
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))
注：读取文本文件时，Python将其中的所有文本都解读为字符串。如果你读取的是数字，并要将其作为数值使用，就必须使用函数int() 将其转换为整数，或使用函数float() 将其转换为浮点数。
假如文件中小数点后很多位，我们需要读取其后50位
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[:52])#小数点后50位
print(len(pi_string))
写入空文件
filename='programming.txt'
with open(filename,'w') as file_object:
file_object.write("i love you")
第二个实参（‘w’ ）告诉Python，我们要以写入模式打开这个文件。
打开文件时，可指定读取模式（‘r’ ）、写入模式（‘w’ ）、附加模式（‘a’ ）或让你能够读取和写入文件的模式（‘r+’ ）。
如果你省略了模式实参，Python将以默认的只读模式打开文件。
如果你要写入的文件不存在，函数open() 将自动创建它。然而，以写入（‘w’ ）模式打开文件时千万要小心，因为如果指定的文件已经存在，Python将在返回文件对象前清空该文件。
注意：Python只能将字符串写入文本文件。要将数值数据存储到文本文件中，必须先使用函数str() 将其转换为字符串格式。
写入多行
加个换行符\n
filename='programming.txt'
with open(filename,'w') as file_object:
file_object.write("i love you\n")
file_object.write("i love me")
附加模式
给文件添加内容，而不是覆盖原有的内容。用附加模式。
指定的文件不存在，Python将为你创建一个空文件。'a'
filename='programming.txt'
with open(filename,'a') as file_object:
file_object.write("i love you\n")
file_object.write("i love me\n")
异常
Python使用被称为异常的特殊对象来管理程序执行期间发生的错误。每当发生让Python不知所措的错误时，它都会创建一个异常对象。如果你编写了处理该异常的代码，程序将继续运行；如果你未对异常进行处理，程序将停止，并显示一traceback，其中包含有关异常的报告。
异常是使用try-except 代码块处理的。try-except 代码块让Python执行指定的操作，同时告诉Python发生异常时怎么办。使用了try-except 代码块时，即便出现异常，程序也将继续运行：显示你编写的友好的错误消息，而不是令用户迷惑的traceback。
try:
print(5 / 0)
except ZeroDivisionError:
print("you can't divide by zero")
实例_处理ZeroDivisionError异常
try-except-else 代码块的工作原理大致如下：
Python尝试执行try 代码块中的代码；只有可能引发异常的代码才需要放在try 语句中。
有时候，有一些仅在try 代码块成功执行时才需要运行的代码；这些代码应放在else 代码块中。
except 代码块告诉Python，如果它尝试运行try 代码块中的代码时引发了指定的异常，该怎么办。
需求：只执行除法运算的简单计算器
while True:
first_number=input("the first number")
if first_number=='q':
break
second_number=input("the second number")
if second_number=='q':
break
try:
answer=int(first_number)/int(second_number)
except ZeroDivisionError:
print("you can't divide by zero")
else:
print(answer)
处理FileNotFoundError异常
filename='alice.txt'
try:
with open('alice.txt') as file_open:
contents = file_open.read()
except FileNotFoundError:
print("the file can not be found")
else:
print(contents)
分析文本：
用方法split() ，它根据一个字符串创建一个单词列表。
filename='alice.txt'
try:
with open('alice.txt') as file_open:
contents = file_open.read()
except FileNotFoundError:
print("the file can not be found")
else:
words=contents.split()
num_words=len(words)
print(num_words)
使用多个文件
单独一个文件：
def count_words(filename):
try:
with open('filename') as file_open:
contents = file_open.read()
except FileNotFoundError:
print("the file can not be found")
else:
words = contents.split()
num_words = len(words)
print(num_words)
filename='alice.txt'
count_words(filename)
多个文件
def count_words(filename):
try:
with open('filename') as file_open:
contents = file_open.read()
except FileNotFoundError:
print("the file can not be found")
else:
words = contents.split()
num_words = len(words)
print(num_words)
filenames=['alice.txt','hjj.txt','hiop.txt']
for filename in filenames:
count_words(filename)
失败时一声不吭
ython有一个pass 语句，可在代码块中使用它来让Python什么都不要做
def count_words(filename):
try:
with open('filename') as file_open:
contents = file_open.read()
except FileNotFoundError:
pass
else:
words = contents.split()
num_words = len(words)
print(num_words)
filenames=['alice.txt','hjj.txt','hiop.txt']
for filename in filenames:
count_words(filename)
存储数据
1.模块json 让你能够将简单的Python数据结构转储到文件中，并在程序再次运行时加载该文件中的数据。
2.你还可以使用json 在Python程序之间分享数据。
3.更重要的是，JSON数据格式并非Python专用的，这让你能够将以JSON格式存储的数据与使用其他编程语言的人分享。这是一种轻便格式，很有用，也易于学习。
注意：JSON（JavaScript Object Notation）格式最初是为JavaScript开发的，但随后成了一种常见格式，被包括Python在内的众多语言采用。
存储数组json.dump()
import json
numbers=[1,2,3,4,5]
file_name="number.json"
with open(file_name,'w') as file_ob:
json.dump(numbers,file_ob)
将列表读取到内存中json.load()
import json
file_name="number.json"
with open(file_name,) as file_ob:
numbers=json.load(file_ob)
print(numbers)
保存用户生成的数据
import json
username=input("what is your name")
filename='user.json'
with open(filename,'w') as file_use:
json.dump(username,file_use)
读取用户生成的数据
import json
filename='user.json'
with open(filename) as file_use:
username=json.load(file_use)
print(username)
组合
用户名存在则读取出，如果不存在则创建新用户
import json
filename = 'user.json'
try:
with open(filename) as file_use:
username = json.load(file_use)
print(username)
except FileNotFoundError:
username=input("what is your name")
with open(filename,'w') as file_us:
json.dump(username,file_use)
print(username)
else:
print("username exits: "+username)
重构
代码能够正确地运行，但可做进一步的改进——将代码划分为一系列完成具体工作的函数。这样的过程被称为重构。
重构让代码更清晰、更易于理解、更容易扩展。
import json
def get_stored_username():
"""如果存储了用户名，就获取它"""
filename = 'username.json'
try:
with open(filename) as file_use:
username = json.load(file_use)
except FileNotFoundError:
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 remember you when you come back, " + username + "!")
greet_user()
测试代码
Python模块unittest 中的工具来测试代码
1.单元测试用于核实函数的某个方面没有问题；
2.测试用例是一组单元测试，这些单元测试一起核实函数在各种情形下的行为都符合要求。良好的测试用例考虑到了函数可能收到的各种输入，包含针对所有这些情形的测试。
3.全覆盖式测试用例包含一整套单元测试，涵盖了各种可能的函数使用方式。对于大型项目，要实现全覆盖可能很难。通常，最初只要针对代码的重要行为编写测试即可，等项目被广泛使用时再考虑全覆盖。
对单个函数的测试
def name(first,last):
"""全名方法 """
full_name=first+' '+last
return full_name
import unittest
from pizza import name
class NameTest(unittest.TestCase):
"""测试类"""
def test_name(self):
""""测试方法"""
full_name=name('lcj','jkkl')
self.assertEqual(full_name,'lcj jkkl')
unittest.main()
输出：
----------------------------------------------------------------------
Ran 0 tests in 0.000s
OK
1.导入unittest模块和被测试的函数
2.测试类必须继承unittest.TestCase 类，这样Python才知道如何运行你编写的测试。
3.测试的方法名必须以test_为开头
3.我们使用了unittest 类最有用的功能之一：一个断言方法。断言方法用来核实得到的结果是否与期望的结果一致。
4.unittest.main() 让Python运行这个文件中的测试
各种断言方法
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 中
测试类
方法setUp()
unittest.TestCase 类包含方法setUp() ，让我们只需创建这些对象一次，并在每个测试方法中使用它们。
如果你在TestCase 类中包含了方法setUp() ，Python将先运行它，再运行各个以test_打头的方法。
这样，在你编写的每个测试方法中都可使用在方法setUp() 中创建的对象了。
在setUp() 方法中创建一系列实例并设置它们的属性，再在测试方法中直接使用这些实例。
需求：下面使用setUp() 来创建一个调查对象和一组答案，供方法test_store_single_response() 和test_store_three_responses() 使用
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)
import unittest
from pizza import AnonymousSurvey
class TestAnonymousSurvey(unittest.TestCase):
"""针对AnonymousSurvey类的测试"""
def setUp(self):
"""
创建一个调查对象和一组答案，供使用的测试方法使用
"""
question = "What language did you first learn to speak?"
self.my_survey = AnonymousSurvey(question)
self.responses = ['English', 'Spanish', 'Mandarin']
def test_store_single_response(self):
"""测试单个答案会被妥善地存储"""
self.my_survey.store_response(self.responses[0])
self.assertIn(self.responses[0], self.my_survey.responses)
def test_store_three_responses(self):
"""测试三个答案会被妥善地存储"""
for response in self.responses:
self.my_survey.store_response(response)
for response in self.responses:
self.assertIn(response, self.my_survey.responses)
unittest.main()
有报错，自己改正：
class Survey:
def __init__(self,question):
self.question=question
self.answers=[]
def show_question(self):
print("The question is: "+self.question)
def store_answers(self,new_answer):
self.answers.append(new_answer)
def show_answers(self):
for answer in self.answers:
print("The answers: "+answer)
import unittest
from pizza import Survey
class TestServey(unittest.TestCase):
def setUp(self):
question="What do you like to do?"
self.my_survey=Survey(question)
self.answers=['hjjkj','eew','wree']
def test_single_answer(self):
self.my_survey.store_answers( self.answers[0])
self.assertIn( self.answers[0],self.my_survey.answers)
def test_three_answers(self):
for answer in self.answers:
self.my_survey.store_answers(answer)
for answer in self.answers:
self.assertIn(answer,self.my_survey.answers)
unittest.main()
输出：
..
----------------------------------------------------------------------
Ran 2 tests in 0.001s
OK
行测试用例时，
每完成一个单元测试，Python都打印一个字符：
测试通过时打印一个句点；测试引发错误时打印一个E ；
测试导致断言失败时打印一个F 。
这就是你运行测试用例时，在输出的第一行中看到的句点和字符数量各不相同的原因。
如果测试用例包含很多单元测试，需要运行很长时间，就可通过观察这些结果来获悉有多少个测试通过了
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
