157个知识点学会Python编程（满满的干货）

157个知识点学会Python编程（满满的干货）

---

第一章 搭建环境

两个不同系统下的Python环境安装教程如下：
windows下安装Python环境
Linux下安装Python环境

小结

在本章中，你大致了解Python，并在自己的系统中安装了Python。你还安装了一个文本编辑器，以简化Python代码的编写工作。你学习了如何在终端会话中运行Python代码片段，并运行了第一个货真价实的程序——hello_world.py。你还大致了解了如何解决安装问题。

第二章 变量和简单数据类型

name = "my name is xxx"

1.字符串首字母大写

name.title()

2.字符串字母全大写

name.upper()

3.字符串字母全小写

name.lower()

4.合并字符串

通过‘+’进行连接和合并

name + 'Xiaoming' + '.'

5.换行和添加制表符（程序行开头的缩进）

\n 换行
\t 加制表符

6.删除字符串前后空白

rstrip() 删除后端空白（暂时的）
例:name.rstrip() 
lstrip() 删除前端空白
strip()  删除两端空白

7.注意在使用单引、双引时要区分英文的’s等语句

's

8.四则运算符号的应用

“+”、“-”、“*”、“/”、“**”
加   减   乘   除   乘方

9.转换数字为字符串

str()
注：小数点除法的用法

10.注释

注释通过“#”来完成
要成为专业的程序员，必须编写有意义的注释

11.Python终端浏览其他指导规则

import this

小结

在本章中，你学习了：如何使用变量；如何创建描述性变量名以及如何消除名称错误和语法错误；字符串是什么，以及如何使用小写、大写和首字母大写方式显示字符串；使用空白来显示整洁的输出，以及如何提出字符串中多余的空白；如何使用整数和浮点数；使用数值数据时需要注意的意外行为。你还学习了如何编写说明性注释，让代码对你和其他人来说更容易理解。最后，你了解了让代码尽可能简单的理念。
在第三章中，你将学习如何在被称为列表的变量中存储信息集，以及如何通过遍历列表来操作其中的信息。

第三章 列表简介

12.列表

列表：由一些列按照特定顺序排列的元素组成

13.列表符号

通过[]表示列表，并用逗号分隔其中的元素
bicycles = ['trck','cannondale','redline','specialized']

14.如何访问列表

bicycles[0] bicycles[1] bicycles[2] bicycles[3]
令bicycles[0].title()等
注：还可以-1，-2，-3，-4表示从后往前调用

15.使用字符串组合

“A”+“B”+“C”

16.修改列表元素

names[0]="XX"

17.添加列表元素

使用append语句

names.append("xx")

18.插入列表元素

使用insert语句

names.insert(0,'xx')
其中0表示插入位置，且为第一个

19.删除列表元素

使用del语句

del names[0]

20.pop()方法删除元素，且出栈最后一个元素

popped_motorcycle = motorcycles.pop()

21.弹出列表中任何位置处的元素

在pop()中添加索引号

first_owned = motorcycles.pop(0)

注：使用pop()时，被弹出的元素就不再在列表中了，但仍可继续调用

22.根据值删除元素

使用remove()

motorcycles.remove('ducati')
其中ducati为motorcycles中的一个元素

注：需要知道要删除的值
组织列表

23.按照字母顺序永久性排序列表

使用sort()

sort() 正向排序
sort(reserse = True) 反向排序
names.sort()

注：排序为永久性的

24.使用sorted()对列表进行临时排序

只是临时按照字母顺序排序，但并不改变原有的顺序

sorted(names) 

如果想反向排序也可引入reserse = True

sorted(names,reverse = True) 

25.倒着打印列表

使用reverse()直接反转列表，且为永久性修改

names.reverse()
print(names)

26.确定列表长度

使用len()

len(names)  直接调用即可

使用列表时避免索引错误
如果列表中有3个元素，但你访问[3]会导致报错：

Traceback(most recent call last):
	File"motorcycles.py",line 3,in<module>
		print(motorcycle[3])
IndexError:list index out of range

在这种情况下，我们可以将列表或长度打印出来

小结

本章中，你学习了，列表时什么以及如何使用其中的元素；如何定义列表以及如何增删元素；如何对列表进行永久性排序，以及如何为展示列表而进行临时排序；如何确定列表的长度，以及在使用列表时如何避免索引错误。
在第四章，你将学习如何以更高效的方式处理列表元素。通过使用为数不多的几行代码来遍历列表元素，你就能高效地处理它们，即便列表包含数千乃至数百万个元素。

第四章 操作列表

27.利用for循环打印名单

magicians = ['alice','david','carolina']
for magician in magicians:
	print(magician)

使用单数和复数式名称，可帮助你判断代码段处理的是单个列表元素还是整个列表。

28.在for循环中执行更多的操作

例：通过for循环对每个names打印并调节首字母

\n 中途换行

29.for循环结束后执行一些操作

对于for循环后有缩进循环才执行，否则执行一次不进行循环操作

30.注意缩进(for循环等)

一般不缩进报错expected an indented block

31.一些小建议

逻辑缩进很重要（不易发现，只能看结果）
不必要缩进会报错（unexpected indent）
有些代码逻辑上不必要缩进
注：不要遗漏了冒号，for循环后冒号提示该缩进
创建数值列表

32.range()函数

从指定的第一个值开始数，并在到达你指定的第二个值后停止，且输出不包括第二个值。

for value in range(1,5):
	print(value)
输出：1 2 3 4

33.使用range()创建数字列表

组合list()使用

numbers = list(range(1,6))
输出[1,2,3,4,5]

注：range(2，11，2)从2到11，且间距为2

34.还可使用append函数

a.append(xx)

35.对数字列表执行简单的统计计算

min() 找最小
max() 找最大
sum() 求和

36.列表解析

表达式 for 变量 in range(1,11):
使用列表的一部分

37.切片

[0:3] 表示从第一个元素到第三个元素
[1:4] 表示从第二个元素到第四个元素
[ :4] 输出前四个
[2: ] 从正数第三个到末尾
[-3:] 倒数三个元素

38.遍历切片部分元素

for player in player[:3]:
	print(player.title())

39.创建两个独立列表

[:]表示列表全部元素

my_foods = ['pizza','falafel']
friend_foods = my_foods[:]

40.元组

使用圆括号而不是方括号来标识

dimensions = (200,50)

注：每个元素都不可修改

41.for循环遍历

for dimension in dimensions:
	print(dimensions)

42.for循环遍历

虽然不能改变每一个元组的数据，但可以对整个元组进行赋值

dimensions = (400,200)

43.漂亮的代码格式

①缩进：四个空格
②行长：每行不超过80字符，最大99字符
注释行长不超过72字符
③空行：两个不同的代码手段用空行隔开
PE8标准

小结

本章中，你学习了：如何高效地处理列表中的元素；如何使用for循环遍历列表，Python如何根据缩进来确定程序的结构以及如何避免一些常见的缩进错误；如何创建简单的数字列表，以及可对数字列表执行的一些操作；如何通过切片来使用列表的一部分和复制列表。你还学习了元组（它对不应变化的值提供了一定程度的保护）以及在代码变得越来越复杂时如何设置格式使其易于阅读。
在第五章中，你将学习如何使用if语句在不同的条件下采取不同的措施；学习如何将一组较复杂的条件测试组合起来，并在满足特定条件时采取相应的措施；你还将学习如何在遍历列表时，通过使用if语句对特定元素采取特定的措施。

第五章 if语句

44.经典结构

for car in cars:
	if car == 'bmw':
		print(car.upper())
	else:
		print(car.title())

45.检查是否相等

赋值 car = 'bmw'
判断 car == 'bmw'
输出 True

46.检查是否相等时不考虑大小写

赋值 car = 'Audi'
判断 car == 'audi'
输出 False
赋值 car = 'Audi'
判断 car.lower() == 'audi'
输出 True

47.检查是否不相等

使用!=进行判断

赋值 car = 'Audi'
判断 car != 'audi'
输出 True

48.比较数字

赋值 age = 18
判断 age == 18
输出 True

49.检查多个条件

1) and 检查多个,并列
2) or  检查多个,或

50.检查特定值是否包含在列表中

使用关键词in

names = ['a','b','c']
'b' in names
输出True

51.检查特定值是否不包含在列表中

使用关键词not in

names = ['a','b','c']
'd' not in names
输出True

52.布尔表达式

通过True或False直接赋值

game_active = True

53.if判断基本结构

if xxx:
	do something

54.if-else语句

if xxx:
	do something 1
else:
	do something 2

55.if-elif-else语句

if xxx:
	do something 1
elif xxx:
	do something 2
else:
	do something 3

56.使用多个elif代码块

if xxx:
	do something 1
elif xxx:
	do something 2
elif xxx:
	do something 3
elif xxx:
	do something 4
else:
	do something 5

57.省略else代码块

if xxx:
	do something 1
elif xxx:
	do something 2
elif xxx:
	do something 3
elif xxx:
	do something 4
...

58.测试多个条件

if if if 多if

if xxx:
	do something 1
if xxx:
	do something 2
if xxx:
	do something 3
if xxx:
	do something 4
...

使用if语句处理列表

59.检查特殊元素

for循环中加if

for name in names:
	if name == xx:
		do something

60.确定列表不是空的

对于列表names，如为空则返回False

if names:
	do something
若列表为空if判断失效	

61.使用多个列表

for+if+else结构

列表1 = []
列表2 = []
for 变量名 in 列表1:
	if 变量名 in 列表2:
		print("xxx")
	else:
		print("xxx")	

62.良好的if语句格式

在 > , = , >= 等符号左右各加一个空格，更美观

a = b > c >= d

小结

本章中，你学习了如何编写结果要么为True要么为False的条件测试。你学习了如何编写简单的if语句，if-else语句和if-elif-else结构。在程序中，你使用了这些结构来测试特定的条件。以确定这些条件是否满足。你学习了如何在利用高效的for循环的同时，以不同于其他元素的方式对特定的列表元素进行处理，你还再次学习了Python就代码格式方面提出的建议。这可确保即便你编写的程序越来越复杂。其代码依然易于阅读和理解。
在第六章，你将学习Python字典，字典类似于列表。但让你能够将不同的信息关联起来，你将学习如何创建和遍历字典以及如何将字典列表和if语句结合起来使用。学习字典让你能够模拟更多现实世界的情形。

63.使用字典，键-值对

alien_0 = {'color':'green','points':5}
键color 值green
键point 值5

64.访问字典中的值

直接调用
alien_0['color']
如果打印会输出green

65.添加键-值对

字典是一种动态结构，可随时添加键-值对

alien_0['x_position'] = 25

注：字典只注重添加顺序，只关心键和值之间的关联关系。

66.创建一个空子典

alien_0 = {}

67.修改字典中的值

alien_0['color'] = 'yellow'

68.删除键-值对

直接使用del语句

del alien_0['color']

69.由类似对象组成的字典

格式：首行缩进四个空格/一个Tab，后面加逗号，最后加括号

favorite_languages = {
	'jen':'python',
	'sarah':'c',
	'edward':'ruby',
	}

70.遍历字典

直接调用user_o,items()

for key,value in user_o.items():
	print(key)
	print(value)

71.遍历字典中的所有键

直接调用.keys()

for name in favorite_language.keys():
	print(name.title())

72.按顺序遍历字典中的所有键

.keys()组合排序函数sort()

for name in sorted(favorite_language.keys()):
	print(name.title())

73.遍历字典中的所有值

直接调用.values()

for language in favorite_language.values():
	print(language.title())

注：在调用值时，可能会有相同的值，可以通过set()进行去重

for language in set(favorite_language.values()):
	print(language.title())

74.嵌套

alien_0 = {'color':'green','point':5}
alien_1 = {'color':'yellow','points':10}
aliens = [alien_0,alien_1]
for alien in aliens:
	print(alien)

注：如果想修改某个值，直接if判断

alien_0 = {'color':'green','point':5}
alien_1 = {'color':'yellow','points':10}
aliens = [alien_0,alien_1]
for alien in aliens:
	if alien['color'] == green
		do something

75.列表存在字典中

pizza = {
	'crust':'thick',
	'toppings':['mushrooms','extra cheese'],
	}

76.字典套字典

user = {
	'aeinstein':{
		'first':'albert',
		'last':'einstein',
		'location':'princeton',
		},
	'mcurie':{
		'first':'marie',
		'last':'curie',
		'location':'paris',
		}

调用：

for username,user_info in user.items():
	user_info['first']

小结

在本章中，你学习了：如何定义字典，以及如何使用存储在字典中的信息；如何访问和修改字典中的元素，以及如何遍历字典中的所有信息；如何遍历字典中所有的键-值对、所有的键和所有的值，如何在列表中嵌套字典，在字典中嵌套列表以及在字典中嵌套字典。
下一章中，将学习while循环以及如何从用户哪里获取输入。这是激动人心的一章，让你知道如何将程序编程交互性的——能够对用户输入作出响应。

第七章 用户输入和while循环

77.函数input()的工作原理

工作原理：input()让程序暂停运行，等待用户输入一些文本。获取用户输入后，Python将其存储在一个变量中，以方便使用。

message = input("请输入")
print(message)

78.编写清晰的程序

对于某些字符串末尾加空格，过长的字符串通过\n来换行，可以使代码更美观。

79.使用int()来获取数值输入

强制类型转换，可将字符串直接转换成整数型

age = input("How old are you")
age = int(age)
age >= 10

80.求模运算符–>与C语言一样，%取余

5 % 3 = 2

81.Python2.7中的input()函数

注：对于Python2.7中的input()，应该使用raw_input()来提示输入，否则程序不会报错，会乱执行

82.while循环

for循环用于针对集合中的每个元素都一个代码块，而while循环不断地运行，直到指定的条件不满足为止。
while 循环使用格式：

while 条件:
	do something

83.利用while循环让用户选择何时退出

while message != 'quit':
	message = input("请输入")

84.标志的使用

通过对flag进行定义可直接改变条件

while flag:
	if xx:
		flag = True
	else:
		flag = False

85.使用break语句可退出循环

while True:
	语句
	if city == 'quit':
		break
	else:
		print("xxx")

86.在循环中使用continue

continue可以返回到循环开头，并根据条件测试结果决定是否继续执行循环

while xx < 10:
	xx += 1
	if xx % 2 == 0:
		continue
	print("xxx")

注：千万要避免无限循环
使用while循环来处理列表和字典

87.在列表之间移动元素

list = ['alice','brian','candace'] 创建列表
new_list = [] 定义空列表
while list: 循环列表
	name = list.pop()           循
	print(name.title())         环
	new_list.append(name)       输出

结果：

Candace
Brain
Alice

88.删除包含特定值的所有列表元素

使用remove命令

while 'cat' in pets:
	pets.remove('cat') 循环寻找pets中的cat元素并删除

89.使用用户输入来填充字典

while循环填充，主要通过标志结束循环，其余的还是对字典的应用

小结

在本章中，你学习了：如何在程序中使用input()来让用户提供信息；如何处理文本和数字输入，以及如何使用while循环，让程序按用户的要求不断地运行；多种控制while循环流程的方式：设置活动标志、使用break语句以及使用continue语句；如何使用while循环在列表之间移动元素，以及如何从列表中删除所有包含特定值的元素；如何结合while循环和字典。
在第八章中，你将学习函数。函数让你能够将程序分成多个很小的部分。其中每部分都负责完成一项具体任务。你可以根据需要调用同一个函数任意次，还可将函数存储在独立的文件中，使用函数可以让你编写的代码效率更高，更容易维护和排除故障，还可在众多不同的程序中重用。

第八章 函数

90.定义函数

函数格式：

def 函数名():
	语句

91.向函数传递信息（任务）

def greet_user(username):
	print("Hello," + username.title() + "!")
调用函数时：
greet_user('jesse')

92.实参和形参

上述91中，username为形参
jesse为实参

93.传递参数

位置参数：每个实参都关联到函数定义中的一个形参

def describe_pet(animal_type,pet_name):
	print("My," + animal_type+"'s name is") + pet_name.title() + "."
调用函数时：
describe_pet('hamster','harry')

注：①可循环多次调用
②位置实参的顺序很重要，不要乱赋值
比如上述函数调用describe_pet(‘harry’,‘hamster’)会导致宠物的种类和名字颠倒。

94.关键字实参

直接在调用函数时使用如下格式：

describe_pet(animal_type = 'hamster',pet_name = 'harry')

注：使用关键字实参时，务必准确地指定函数定义中的形参名

95.默认值

在定义函数中可对函数赋初始值

def describe_pet(pet_name,animal_type = 'dog'):

注：在使用默认值时，在形参中必须先列出没有默认值的形参，再列出有默认值的实参。这让Python依然能够正确的解读位置实参

96.等效的函数调用

有如下定义函数

def describe_pet(pet_name,animal_type = 'dog'):
	xxxx

调用时可采用多种形式

describe_pet('willie')
describe_pet(pet_name = 'willie')
describe_pet('willie','hamster')
describe_pet(pet_name = 'willie',animal_type = 'hamster')
describe_pet(animal_type = 'hamster',pet_name = 'willie')

注：使用哪种调用方式无关紧要，只要函数调用能生成你希望的输出就行，使用对你来说最容易理解的调用方式即可。

97.避免实参错误

带有实参的函数，如果在调用时不指定实参，系统会反馈错误信息
错误如下：

Traceback(most recent call last):
	File "pets.dog", line 6, in <module>
		describe_pet()
TypeError: describe_pet() missing 2 required positional arguments: 'animal_type' and 'pet_name'

98.返回值

通过return语句将值返回到调用函数的代码行
返回简单行

def xx(a,b):
	语句1
	return 2
print(xx(a,b))
输出 2

99.让实参变成可选的

通过对某个参数赋默认值

100.返回字典

函数可返回任何类型的值

def build_person(first_name,last_name):
	person = {'first':first_name,'last':last_name}
	return person

101.结合使用函数和while循环

一个无限循环的例子

def get_formatted_name(first_name,last_name):
	full_name = first_name + '' + last_name
	return full_name.title()
while True:
	print("\n Please tell me your name: ")
	f_name = input("First name: ")
	l_name = input("Last name: ")
	formatted_name = get_formatted_name(f_name,l_name)
	print("\n Hello," + "my heart" formatted + "!")

102.传递列表

将列表设为形参，然后通过for循环引用和输出

def greet_users(names):
	for name in names:
	msg = "Hello," + name.title() + "!"
	print(msg)
调用:
usernames = ['hannah','try','margot']
greet_users(usernames)

103.在函数中修改列表

函数传参配合.append()生成列表

104.禁止函数修改列表

可通过中间变量的形式，使用切片表示法创建一个列表的副本，通过函数修改副本的列表，这样可以有效的防止列表被修改

function_name(list_name[:])

切片表示法[:]创建列表的副本function_name以完成列表的修改
注：虽然向函数传递列表的副本可保留原始列表的内容，但除非有充分的理由需要传递副本，否则还是应该将原始列表传递给函数，因为让函数使用现成的列表可避免花时间和内存创建副本，从而提高效率，在处理大型列表时尤其如此。

105.传递任意数量的实参–>通过指针实现

def make_pizza(*toppings):
	print(toppings)
调用：
make_pizza('pepperoni')
make_pizza('mushrooms','green peppers','extra cheese')
结果：
('pepperoni')
('mushrooms','green peppers','extra cheese')

106.结合使用位置实参和任意数量实参

注：必须要将准备接纳任意数量实参的形参放在最后

def make_pizza(size,*toppings):
	print("\n Making a " + str(size) + ...)
	for topping in toppings:
		print("-" + topping)
调用：
make_pizza(16,'pepperoni')
make_pizza(12,'mushrooms','green peppers','extra cheese')

107.使用任意数量的关键字实参

def bulid_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('albert','einstein',location = 'princeton',field = 'physics')
print(user_profile)

108.将函数存储在模块中

通过import语句引入文件，进而引入函数

109.导入整个模块

假设要导入的文件：设置名字pizza.py

def make_pizza(size,*toppings):
	print("\n Making a" + str(size) + "_inch pizza with the following toppings:")
	for topping in toppings:
		print("-" + topping)

主文件：making_pizzas.py

import pizza
pizza.make_pizza(16,'pepperoni')

110.导入特定的函数

格式：

from module_name import function_name
或
from module_name import function_name,function_name1

例：

from pizza import make_pizza
make.pizza(16,'pepperoni')

111.使用as给函数指定别名

例：

from pizza import make_pizza as mp
mp(16,'pepperoni')
或
import cv2 as cv

112.导入模块中的所有函数

使用星号（*）运算符可让Python导入模块中的所有函数

from pizza import *

113.函数编写指南

描述性名称尽量有意义，漂亮，PEP8

小结

在本章中，你学习了：如何编写函数，以及如何传递参数，让函数能够访问完成其工作所需的信息；如何使用位置参数和关键字实参，以及如何接收任意数量的实参；显示输出的函数和返回值的函数；如何将函数同列表、字典、if语句和while循环结合起来使用，你还知道了如何将函数存储在被称为模块的独立文件中，让程序文件更简单，更易于理解。最后，你学习了函数编写指南，遵循这些指南可让程序始终结构良好，并对你和其他人来说易于阅读。
程序员的目标之一是，编写简单的代码来完成任务，而函数有助于你实现这样的目标，他们让你编写好代码块并确定其能够正确运行后，就可置之不理。确定函数能够正确地完成其工作后，你就可以接着投身于下一个编码任务。
函数让你编写代码一次后，想重用他们多少次就重用多少次。需要运行函数中的代码时，只需编写一行函数调用代码，就可让函数完成其工作，需要修改函数的行为时，只需修改一个代码块，而所做的修改将影响调用这个函数的每个地方。
使用函数让程序更容易阅读，而良好的函数名概述了程序各个部分的作用，相对于阅读一系列的代码块，阅读一系列函数调用让你能够更快地明白程序的作用。
函数还让代码更容易测试和调试。如果程序使用一系列的函数来完成其任务。而其中的每个函数都完成一项具体的工作，测试和维护起来将容易得多：你可编写分别调用每个函数的程序，并测试每个函数是否在它可能遇到的各种情形下都能正确地运行。经过这样的测试后你就能信心满满。深信你每次调用这些函数时，它们都将正确地运行。
在第九章，你将学习编写类。类将函数和数据整洁地封装起来，让你能够灵活而高效地使用它们。

第九章 类

面向对象编程是最有效的软件编写方法。
类–>一类–>每个对象都自动具备这种通用行为
创建和使用类

114.创建Dog类

样式：

dog.py
class Dog():
	def_init_(self,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!")

115.方法_init()

包含三个形参：self、name和age
创建类时只需给最后两个形参（name和age）提供值。
前缀self的变量可供类中的所有方法使用。
可供通过类的任何实例来访问这些变量。

116.根据类创建实例

直接调用

my_dog = Dog('xx',6)

117.调用方法

my_dog.sit()

118.调用属性

my_dog.name()

119.创建多个实例

my_dog = Dog('xx',6)
your_dog = Dog('xxx',7)
my_dog.sit()
your_dog.sit()

120.使用类和实例

同上

121.给属性指定默认值

在类中设置参数时，对某一个参数直接赋值

class car()
	def _init_(self,make,model,year):
		self.make = make
		self.model =  model
		self.year = year
		self.odometer_reading = 0

122.修改属性的值——先调用在修改

my_car = car('audi','a8',2018)
my_car.odometer_reading = 23

123.通过方法修改属性的值

如果有替你更新属性的方法，将大有裨益

class car():
	def update_odometer(self,mileage):
		self.odometer_reading = mileage
调用时直接
my_new_car.update_odometer(23)

124.继承

子类继承父类的所有属性和方法
同时还可以定义自己的属性和方法
主要通过super.init(make,model,year)

class car(): 父类
	def _init_(self,make,model,year):
		self.make = make
		self.model = model
		self.year = year
		self.odometer_reading = 0
class ElectricCar(car) 子类
	def _init_(self,make,model,year):
		super()._init_(make,model,year)
		self.battery_size = 70 给子类定义属性
	def describe_battery(self):  给子类定义方法
		print("xx")
	def fill_gas_tank():    重写父类的方法致使父类方法被替换
		print("xx")

125.将实例用作属性

类中调用类

class Battery(): 
	def _init_(self,battery_size = 70):
		self.battery_size = battery_size
	def describe_battery(self):
		print("xx")
class ElectricCar(car)
	def _init_(self,make,model,year):
		super()._init_(make,model,year)
		self.battery = Battery()

调用：

my_tesla = ElectricCar('tesla','model s',2016)
my_tesla.battery.describe_battery()

126.导入类

from car import Car 直接将类导入

在一个文件中还可存储多个类，且可以导入

127.导入整个模块——直接导入文件名

import car

128.导入模块中的所有类

from module_name import *

注：一般不推荐这种导入方式
首先，其他的导入方式可以直接看出程序使用了哪些类
其次，可能会名称冲突

129.在一个模块中导入另一个模块

本质就是互相调用

130.Python标准库

collections中的一个类——OrderedDict

from collections import OrderedDict
favorite_languages = OrderedDict()
favorite_languages['jen'] = 'Pythoon'

131.类编码风格

类名应采用驼峰命名法，即类名中的每个单词的首字母都大写，而不使用下划线。
实例名和模块名都采用小写格式，并在单词之间加上下划线。
每个类后面包含一个文档字符串，用来描述这个类是用于做什么的。
可使用空行来组织代码，但不要滥用。
类中，一个空行分隔方法
模块中，两个空行来分隔类
需要同时导入标准库中的模块和你编写的模块时，先编写导入标准库模块的import语句。再添加一个空行，然后编写导入你自己编写的模块的import语句，在包含多条import语句的程序中，这种做法让人更容易明白程序使用的各个模块都来自何方。

小结

在本章中，你学习了：如何编写类；如何使用属性在类中存储信息，以及如何编写方法，以让类具备所需的行为；如何编写方法_init_()，以便根据类创建包含所需属性的实例。你见识了如何修改实例的属性——包括直接修改以及通过方法进行修改。你还了解了使用继承可简化相关类的创建工作；将一个类的实例用作另一个类的属性可让类更简洁。
你了解，通过将类存储在模块中，并在需要使用这些类的文件中导入它们，可让项目组织有序。你学习了Python标准库，并见识了一个使用模块collections中的OrderedDict类的示例。最后，你学习了编写类时应遵循的Python约定。
在第十章中，你将学习如何使用文件，这让你能够保存你在程序中的工作，以及你让用户做的工作。你还将学习一场，这是一种特殊的Python类，用于帮助你在发生错误时采取相应的措施

第十章 文件和异常

从文件种读取数据

132.读取整个文本

with open('pi_digits.txt') as file_object:
	contents = file_object.read()
	print(contents)

with的使用可以保证文件在不需要访问时关闭，如果使用open()、close()可能会导致bug或数据损坏。read()函数为读取文本函数。
注：read()读取时可能会有空白行，可用rstrip()删除

133.文件路径

Python查找文件时是在当前Python文件的文件夹下查找的，若同级目录下有其他文件夹可间接访问。例如，相对路径

with open('text_files/filename.txt') as file_object:

文件目录格式
Python_work——python.py
——text_files——filename.txt
以上是Linux/OsX系统
若windows则需用反斜杠（\）而不是斜杠（/）

with open('text_files\filename.txt') as file_object:

另外，还可以使用绝对路径（较长）

file_path = '/home/ehmatthes/other_files/filename.txt'
with open(file_path) as file_object:

134.逐行读取

filename = 'pi_digits.txt'
with open(filename) as file_object:
	for line in file_object: 按行读取
		print(line)

这种方式可以方便我们查找、修改某些信息。

135.创建一个包含文件各行内容的列表

with open(filename) as file_object:
	lines = file_object.readlines()

通过readlines函数读取了文件

136.使用文件的内容

直接调用文件读取时赋值的变量即可

with open(filename) as file_object:
	lines = file_object.readlines()
pi_string = ''
for line in lines:
	pi_string += line.strip()

注：读取文本时，所有文本都为字符串。如果要调用数字，并将其作为数值使用，必须要用int/float()转化。

137.包含一百万位的大型文件

Python可处理的数据量，没有任何限制，只要系统内存足够多。

138.写入空文件

filename = 'programming.txt'
with open(filename,'w') as file_object:
	file_object.write("I love you.")

open(filename,‘w’) 第二个参数为写入模式
'r’读取模式
'w’写入模式
'a’附加模式
'r+'读取和写入模式
文件.write() 写入文本
注：Python只能将字符串写入文本文件。
要将数值数据存储到文本文件中。
必须先使用函数str()将其转换为字符串格式

139.写入多行

write()函数不会自动在文本末尾添加换行符，因此如果想在写入的文本中添加换行的文本，需自己添加换行符"\n"

140.附加到文件

with open(filename,'a') as file_object:
	file_object.write("I love you.")

141.异常

可以修改Python所报的异常，显示你编写的友好的错误信息，而不是令用户迷惑的traceback

142.处理ZeroDivisionError异常

使用try-except代码块

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

143.使用异常避免崩溃

使用else代码块

print("Give me two numbers,and I'll divide them.")
print("Enter 'q' to quit.")
while True:
	first_number = input("\n First number: ")
	if first_number == 'q':
		break
	second_number = input("Second number: ")
try:    防止出错
	answer = int(first_number)/int(second_number)
except ZeroDivisionError:
	print("You can't divide by zero!")
else:   输出结果
	print(answer)    

try-except-else代码块的工作原理：
Python尝试执行try代码块中的代码；只有可能引发异常的代码才需要放在try语句中。有一些仅在try代码成功执行时才需要执行的代码被放在else代码块中，except则是发生异常时该怎么办

144.处理FileNot Found Error异常

文件找不到的错误

try:
	with open(filename) as f_obj:
		xx = f_obj.read()
except FileNotFoundError:
	print("xxx")

145.分析文本

split()函数，以空格为分隔符将字符串分拆成多个部分

146.失败时不提示信息

try:
	--XX
except FileNotFoundError:
	pass
else:
	--xx
	print("xxx")

147.存储数据

json模块存储数据
JSON格式最初是JavaScript开发的，但随后成了一种常见格式，被包括Python在内的众多语言采用

148.json.dump()和json.load()存储和加载

json.dump()两个形参，第一个为存储的数据，第二个为要存储的文件

import json
numbers = [2,3,5,7,11,13]
filename = 'numbers.json'
with open(filename,'w') as f_obj:
	json.dump(numbers,f_obj)

注：需引入json模块
json.load加载文件

import json
filename = 'numbers.json'
filename = 'numbers.json'
with open(filename) as f_obj:
	numbers = json.load(f_obj)
print(numbers)

注：json.load()只有一个形参，即文件名

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

json.dump()和json.load()的使用

150.重构

就是将每一个功能用一个函数表示，模块化编程

小结

在本章中，你学习了：如何使用文件；如何一次性读取整个文件，以及如何每次一行的方式读取文件的内容；如何写入文件，以及如何将文本附加到文件末尾；什么是异常以及如何处理程序可能引发的异常；如何存储Python数据结构，以保存用户提供的信息，避免用户每次运行程序时都需要重新提供。
在第十一章中，你将学习高效的代码测试方式，这可帮助你确定代码正确无误，以及发现扩展现有程序时可能引入的bug

第十一章 测试代码

使用Python模块unittest工具来测试代码

151.单元测试和测试用例

单元测试用于核实函数的某个方面没有问题；
测试用例是一组单元测试，这些单元测试一起核实函数在各种情形下的行为都符合要求
全覆盖式测试用例包含一整套单元测试，涵盖了各种可能的函数使用方式

152.可通过的测试

导入unittest，创建继承unittest.TestCase的类编写系列方法，对函数行为的不同方面进行测试

import unittest
from name_function import get_formatted_name
class NamesTestCase(unittest.TestCase):
	def test_first_last_name(self):
		formatted_name = get_formatted_name('janis','joplin')
		self.assertEqual(formatted_name,'Janis Joplin')
unittest.main()

在此，①我们导入了模块unittest和要测试的函数get_formatted_name()
②创建了一个名为NamesTestCase的类，用于单元测试且该类要继承unittest.TestCase类
③在运行时，所有以test_打头的方法都将自动运行
④使用了unittest类的一个功能，一个断言方法assertEqual()即，如果结果正确，万事大吉，否则跟我说一声。

153.测试不通过

报错如下：

E
ERROR:test_first_last_name(_main_.NamesTestCase)
Traceback(most recent call last):
	File "test_name_function.py",line 8,in test_first_last_name
		formatted_name = get_formatted_name('jains','joplin')
TypeError:get_formatted_name() missing 1 required positional argument:'last'
Ran 1 test in 0.000s
FAILED(errors = 1)

154.添加新测试

直接在类中添加函数（包含assertEqual()）即可
测试类
如果类测试通过，就能确信对类所做的改进没有意外地破坏其原有的行为

155.各种断言方法

Python在unittest.TestCase类中提供了很多断言方法。
常见如下

1.assertEqual(a,b)       核实a=b
2.assertNotEqual(a,b)    核实a!=b
3.assertTrue(x)          核实x为True
4.assertFalse(x) 	     核实x为False
5.assertIn(item,list)    核实item在list中
6.assertNotIn(item,list) 核实item不在list中 

156.一个要测试的类

格式：

import unittest
from survey import AnonymousSurvey
class TestAnonymousSurvey(unittest.TestCase):
	def test_store_single_response(self):
		--snip--
		self.assertIn('English',my_survey.responses)
unittest.main()

157.方法SetUp()

通过SetUp创建调查对象和一组答案，供使用的测试方法使用。

import unittest
from survey import AnonymousSurvey
class TestAnonymousSurvey(unittest.TestCase):
	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):
		--snip--
		self.assertIn('English',my_survey.responses)
unittest.main()

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

小结

在本章中，你学习了：如何使用模块unittest中的工具来为函数和类编写测试；如何编写继承unittest.TestCase的类，以及如何编写测试方法，以核实函数和类的行为符合预期；如何使用方法SetUp来根据类高效地创建实例并设置其属性，以便在类的所有测试方法中都可使用它们。

总结

恭喜你成功学习到此，Python的基础知识已经完全学完啦。接下来即将进入实战，祝贺你在学习Python的道路上走了这么远，愿你在以后的学习中有好运相伴！