Python
一、基础知识
1. “方法”是Python可对数据执行的操作。
如：
name=”ada lovelace”
print(name.title())
在name.title()中，name后面的句点（.），让Python对变量name执行方法title()指定的操作。
title()以首字母大写的方式显示每个单词。
upper()将字符串全部改为大写。
lower()将字符串全部改为小写。
rstrip()将字符串输出末尾中(右侧，right)的空白删除，但实际并不删除变量末尾中的空白。
lstrip()将字符串输出开头中(左侧，left)的空白删除，但实际并不删除变量开头中的空白。
strip()将字符串输出两侧中的空白删除，但实际并不删除变量两侧中的空白。
2. Python使用加号(+)来合并字符串，这种合并字符串的方法称为拼接。
如：
first_name=”jack”
last_name=”wong”
full_name=first_name+” ”+last_name
print(“Hello, ”+full_name.title()+”!”)
3. print(),字符串用引号括起，可用单引号或双引号。
4. 空白泛指任何非打印字符，如空格、制表符和换行符。
制表符：\t
换行符：\n
5.在Python中，可对整数执行加(+)减(-)乘(*)除(/)运算，使用两个乘号（**）表示乘方运算(如，5**3，表示5的3次方)。
Python支持运算次序，和数学运算次序一样，使用括号（）提升运算优先级，例如(2+3)*5。
空格不影响Python计算表达式的执行。
6.Python将带小数点的数字都称为浮点数。
7.函数str()，可以将非字符串值表示为字符串。
如：
age=23
message="Happy "+str(age)+"rd Birthday!"
print(message)
8.Python中的代码注释：注释用井号(#)标识，井号后面的内容都会被Python解释器忽略。
9.列表：由一系列按特定顺序排列的元素组成(即，有序集合），用方括号([])表示列表，并用逗号来分隔其中的元素。（其中，引号可以用单引号也可以用双引号，但是编译后print输出都是单引号表示，应优先使用单引号。）
如：
name=[‘Jack’,‘Rose’,‘Edward’,‘John’]
print(name)
编译后会输出以下内容(带方括号和单引号）：
['Jack', 'Rose', 'Edward', 'John']
访问列表元素，字符串方法和运算符可以直接调用到列表元素的访问中，元素索引序号从0递增，并且Python为访问最后一个列表元素提供了一种特殊的语法（通过将索引指定为-1，可以让Python返回最后一个列表元素，-2为倒二个，-3为倒三个，以此类推）。如：
name=[‘Jack’,‘Rose’,‘Edward’,‘John’]
print(name[0].lower())
print(name[-1])
print("Hello "+name[0])
编译后输出（不带方括号和单引号）：
jack
John
Hello Jack
10.要修改列表元素，可指定列表名和要修改的元素的索引，再指定该元素的新值。
如：
name=[‘Jack’,‘Rose’,‘Edward’,‘John’]
name[0]='William'
print(name)
会输出：
['William','Rose','Edward','John']
11.方法append()将可以将新元素添加到列表末尾，不影响列表中的其他所有元素，且一次只能添加一个。
如：
motorcycles=['honda','yamaha','suzuki']
print(motorcycles)
motorcycles.append('ducati')
print(motorcycles)
12.方法insert()可在列表的任何位置添加新元素。
如：
motorcycles=['honda','yamaha','suzuki']
print(motorcycles)
motorcycles.insert(0,'ducati')
print(motorcycles)
将输出（现有元素右移一个位置）：
['honda', 'yamaha', 'suzuki']
['ducati', 'honda', 'yamaha', 'suzuki']
13.删除列表中的元素：
①使用del语句删除，前提是要知道删除元素的位置序列。
如下：
motorcycles=['honda','yamaha','suzuki']
print(motorcycles)
del motorcycles[1]
print(motorcycles)
编译后输出：
['honda', 'yamaha', 'suzuki']
['honda', 'suzuki']
②使用方法pop()可删除列表的元素，并能接着使用它。在括号中输入元素的位置序列，即可以删除对应序列位置的元素，括号放空，默认删除最后一个元素。
如：
motorcycles=['honda','yamaha','suzuki']
print(motorcycles)
popped_motorcycle=motorcycles.pop(0)
print(motorcycles)
print(popped_motorcycle)
编译后输出：
['honda', 'yamaha', 'suzuki']
['yamaha', 'suzuki']
honda
③使用方法remove()可以根据元素的值，删除列表元素。(在不知道元素的位置序列情况下）
注意：方法remove()只删除第一个指定的值，如果要删除的值在列表中出现多次，就需要使用循环判断是否删除了所有这样的值。
如(单个删除）：
motorcycles=['honda','yamaha','suzuki','ducati']
print(motorcycles)
motorcycles.remove('ducati')
print(motorcycles)
编译后，输出：
['honda', 'yamaha', 'suzuki', 'ducati']
['honda', 'yamaha', 'suzuki']
如（循环删除）：
pets = ['dog', 'cat', 'rabbit', 'cat']
print(pets)
while 'cat' in pets:
pets.remove('cat')
print(pets)
编译后，输出：
['dog', 'cat', 'rabbit', 'cat']
['dog', 'rabbit']
14.使用方法sort()可以永久性地修改列表元素的排列顺序，使元素按照字母顺序排列。
使用传递参数reverse=True, 可以使元素按照字母反序排列。
如：
carts = ['bmw', 'audi', 'toyota', 'subaru']
carts.sort()
print(carts)
carts.sort(reverse=True)
print(carts)
编译后，输出：
['audi', 'bmw', 'subaru', 'toyota']
['toyota', 'subaru', 'bmw', 'audi']
15.使用函数sorted()可以按特定顺序显示列表元素，同时不影响元素在列表中的原始排列顺序，非永久性。函数sorted()可以按照元素字母顺序进行临时排序，加入传递参数sorted(list_name, reverse=True)按照字母反序排序。
如：
cars = ['bmw', 'audi', 'toyota', 'subaru']
print("Here is the original list:")
print(cars)
print('Here is the sorted list:')
print(sorted(cars))
print("Here is the reverse-sorted list:")
print(sorted(cars, reverse=True))
print("Here is the original list again")
print(cars)
编译后，输出：
Here is the original list:
['bmw', 'audi', 'toyota', 'subaru']
Here is the sorted list:
['audi', 'bmw', 'subaru', 'toyota']
Here is the reverse-sorted list:
['toyota', 'subaru', 'bmw', 'audi']
Here is the original list again
['bmw', 'audi', 'toyota', 'subaru']
16.使用方法reverse()可以使列表元素按照原来的顺序，永久性地反向进行排列。
使用函数len()可以快速地获取列表的长度，即元素的个数（注意与元素序列数字的区别，长度计数从1开始，不是0）。
17.列表中的元素顺序，叫索引。
18.Python中的for循环本行要加冒号(:)，循环后的缩进部分（使用一个\t符，pycharm编译器自动缩进4格），会一直执行循环。格式如下：
for xxx in xxx:
xxx
如：
magicians = ['alice', 'david', 'corolina']
for magician in magicians:
print(magician)
编译后，输出：
alice
david
corolina
19.使用函数range(n, m, x)可以生成n，n+x, n+x+x, ...., m-1（可能不存在输出m-1）的数字，其中n<m, x为步长，x放空则步长默认为1；n，x放空，只有m，表示生成m个数值（如range(30)，生成30个变量）。
如：
for value in range(1, 5, 2):
print(value)
编译后，输出：
1
3
20.使用函数list()可以将获取的值，按照获取顺序生成列表。
如：
numbers = list(range(1, 5, 2))
print(numbers)
编译后，输出:
[1, 3]
21.使用函数min()、max()、sum()可以找出列表中的最小值、最大值和总和。
如：
digits = ['1', '2', '3', '4']
min(digits)
22.列表解析：
如：
square = [value**2 for value in range(1, 11, 1)] # 注意结构(列表名=[变量表达式 for 变量 in 表达式]
print(square)
编译后，输出：
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
23.Python切片：选中列表中的一部分元素，格式：list_sample[n:m]，其中n≤m(相等时输出空白列表），表示调用列表list_sample中的第n-1至第m之间的元素，若切片中没有指定第一个索引n，Python默认为从列表开头开始，若切片中没有指定第二个索引m，Python默认为调用至列表末尾最后一个元素，两个都放空则表示整个列表list_name[:]。
(备注：对于字符串类型变量使用切片，string_name[n:m]，作用是切出第n到第m个字符之间的内容。）
如：
player = ['jack', 'kuka', 'michael', 'eli']
print(player[0:3])
编译后，输出：
['jack', 'kuka', 'michael']
遍历切片，如：
players = ['charles', 'martina', 'michael', 'florence', 'eli']
print("Here are the first three players on my team:")
for player in players[0:3]:
print(player.title())
编译后，输出：
Here are the first three players on my team:
Charles
Martina
Michael
list1=list与list2=list[:]的区别：list1=list是把list1指向list，并没有在内存上单独为list1创建列表，对list1或list使用方法或者函数，都会改变同一列表；list2=list[:]，在内存上单独为list2创建列表，并将list得切片部分元素复制到list2，对list2或list使用方法或者函数，只会单独改动一个列表。
24. Python将不能修改的值称为不可变的，即所指向的内存中的内容不可变，而不可变的列表被称为元组。
元组看起来犹如列表， 但是使用圆括号而不是方括号来标识（tuple(1, 2 ,3))，定义元组后，就可以使用索引来访问其元素(tuple[0])，就像访问列表元素一样。
元组中只包含一个元素时，需要在元素后面添加逗号(,)，如：tuple(1,)，否则括号会被当作运算符使用。
元组不可变指的是不可以改变元组所指向的内存内容（元组内的元素值），但是可以通过改变元组所指向的内存地址，不同内存地址储存不同的内容（即元素集合），来修改元组的变量（储存元组的变量）。
如：
dimensions = (200, 50)
print(dimensions[0])
print(dimensions[1])
for dimension in dimensions:
print(dimension)
dimensions = (100, 25)
print(dimensions)
dimensions = ('length', 'width')
print(dimensions)
编译后，输出：
200
50
200
50
(100, 25)
('length', 'width')
25.相等运算符(==)对两边的值是否相等进行判断，相等时返回True，不相等时返回False。
不等运算符(!=)判断两边的值是否不相等，不相等时返回True，相等时返回False。
数学比较：小于(<)、小于等于(<=)、大于(>)、大于等于(>=)，可以直接应用到Python中进行条件判断。
关键字(and)：逻辑与，格式：条件A and 条件B, 条件A和条件B都成立时，返回Ture，条件A和条件B其中一个不成立或者都不成立，返回False。可以进行多个条件检查。
关键字(or)：逻辑或，格式：条件A or 条件B，条件A和条件B其中一个成立或者都成立时，返回True，都不成立时返回False。可以进行多个条件检查。
关键字(in)：格式：变量A in 列表B，列表B中元素包含A则返回Ture, 列表B中元素不包含A则返回False。
关键字(not in)：格式：变量A not in 列表B，列表B中元素不包含A则返回Ture, 列表B中元素包含A则返回False。
布尔表达式：即条件测试的别名，结果要么为True，要么为False。(Python将非空字符串、非空列表解释为True)
26.Python中的if循环：常用的结构有if结构、if-else结构、if-elif(一个或多个)-else结构、if-elif结构、if-if(一个或多个)结构
27.Python常见的数据类型：
int 整型
float 浮点型
bool 布尔型
str 字符型
list 列表
tuple 元组
dict 字典
set 集合
complex 复数
28.在if语句中，将列表名用在条件表达式中时，Python将在列表至少包含一个元素时返回True，并在列表为空时返回False。
29.在Python中，字典是一系列键-值对，每个键都与一个值相关联，可以用键来访问与之关联的值，键和值之间用冒号分隔，键-值对之间用逗号分隔，值可以是数字、字符串、列表乃至字典。
格式: dict = {‘key1’：'value1', 'key2': value2, }
访问字典中的值：可以依次指定字典名和放在方括号内的键。
格式：dict['key']
添加键-值对：字典是一种动态结构，可随时在其中添加键-值对。要添加键-值对，可依次指定字典名、用方括号括起的键和相关联的值。
注意：键-值对的排列顺序与添加顺序不同，Python并不关心键-值对的添加顺序，而只关心键和值之间的关联关系。
格式：dict['key'] = value
如：
alien_0 = {'color': 'green', 'p oints': 5, }
print(alien_0)
alien_0['x_position'] = 0
alien_0['y_position'] = 25
print(alien_0)
编译后，输出：
{'color': 'green', 'points': 5}
{'color': 'green', 'points': 5, 'x_position': 0, 'y_position': 25}
修改字典中的值：可依次指定字典名，用方括号括起的键以及与改键相关联的新值。
格式：dict['key'] = new_value
删除键-值对：对于字典中不在需要的信息，可使用del语句将相应的键-值对彻底删除。使用del语句时，必须指定字典名和要删除的键。
格式：del dict['key']
遍历字典：使用for循环进行遍历+方法items()。要编写用于遍历字典的for循环，可以声明两个变量，用于储存键-值对中的键和值。对于这两个变量，可以使用任何名称。方法items()可以返回一个键-值对列表。(注意：即便遍历字典时，键-值对的返回顺序也与存储顺序不同。Python不关心键-值对的存储顺序，而只跟踪键和值之间的关联关系。)
格式：for key, value in dict.items():
遍历字典中的所有键：使用方法keys()，可以返回一个列表，其中包含字典中的所有键。（注意：遍历字典时，会默认遍历并返回所有的键，因此，如果将以下代码中的for name in favorite_languages.keys()：替换为for name in favorite_languages，输出将不变。但是如果显式地使用方法keys()，可以让代码更容易理解。）
如：
favorite_languages = {'jen': 'python',
'sarah': 'c',
'edward': 'ruby',
'phil': 'python',
}
for name in favorite_languages.keys():
print(name.title())
编译后，输出：
Jen
Sarah
Edward
Phil
按顺序遍历字典中的所有键：使用函数sorted()和方法keys()，按照字母顺序输出键。
格式: for key in sorted(dict.keys())
遍历字典中的所有值：使用方法values()，可以返回一个列表，其中包含字典中的所有值。
如：
favorite_languages = {'jen': 'python',
'sarah': 'c',
'edward': 'ruby',
'phil': 'python',
}
print("The following languages have been mentioned:")
for language in favorite_languages.values():
print(language.title())
编译后，输出：
The following languages have been mentioned:
Python
C
Ruby
Python
30.集合(set)类似于列表，但每个元素都必须是独一无二，使用大括号({})将元素括在内。通过对包含重复元素的列表调用方法set()，让Python找出列表中独一无二的元素，并使用这些元素来创建一个集合。
如：
favorite_languages_dict = {'jen': 'python', 'sarah': 'c', 'edward': 'ruby', 'phil': 'python', }
unique_languages_dict = set(favorite_languages_dict.values())
print(unique_languages_dict)
favorite_languages_list = ['python', 'c', 'ruby', 'python']
unique_languages_list = set(favorite_languages_list)
print(unique_languages_list)
编译后，输出：
{'c', 'ruby', 'python'}
{'c', 'ruby', 'python'}
31.嵌套：将一系列字典存储在列表中，或者将里列表作为值存储在字典中，这称为嵌套。可以在列表中嵌套字典、在字典中嵌套列表、字典中嵌套字典。（注意：列表和字典的嵌套层级不应太多。如果嵌套层级太多，应该使用其它方法。）
在列表中嵌套字典格式： list = [{'a': 'b', 'c': d}, {'a': 'b', 'c': d}, {'a': 'b', 'c': d}]
在字典中嵌套列表格式：dict = {'a': ['b', 'c', 'd'], 'e': [f, g, h], 'i': ['j', 'k', 'l']}
在字典中嵌套字典格式：dict = { 'a': {'b': 'c', 'd': 'e', 'f': 'g', }, 'h': {'i': j, 'k': l, 'm': n, }, }
32.函数input()让程序暂停运行，等待用户输入一些文本。获取用户输入后，Python可以将其储存在一个变量中，以便后续使用。同时，函数input()接收一个参数(可以是直接的字符串，也可以是指向字符串的变量），即要向用户显示的提示或说明，让用户知道该如何做。Python将用户输入的内容解读为字符串。
如：
name = input("Please input your name.")
print(name)
33.运算符+=: 可以用于数值变量计算，也可以用于字符型变量拼接。
如：
prompt = "if you teel us who you are, we can personalize the messages you see."
prompt += "\nWhat is your fist name? "
name = input(prompt)
print("\nHello, " + name + "!")
编译后，输出：
if you teel us who you are, we can personalize the messages you see.
What is your fist name? Jack
Hello, Jack!
34.函数int()，它让Python将输入视为数值，即将数字的字符串表示转换为数值表示。
格式：value = int(str)
35.求模运算符%，将两个数相除并返回余数。
36.while循环：满足条件时，一直对循环内容进行循环，未满足条件，停止循环。
格式：
while 条件/布尔表达式:
循环内容
37.标志：在要求多个条件都满足才继续运行的程序中，可定义一个变量，用于判断整个程序是否处于活动状态。这个变量被成为标志。可以让程序在标志为True时继续运行，并在任何事件导致标志的值为False时让程序停止运行。
如：
prompt = "\nTell me something, and I will repeat it back to you:"
prompt += "\nEnter 'quit' to end the program. "
active = True
while active:
message = input(prompt)
if message == 'quit':
active = False
else:
print(message)
38.使用break退出循环：要立即退出while循环，不再运行循环中余下的代码，也不管条件测试的结果如果，可使用break语句。（注意：在任何Python循环中都可以使用break语句，例如，可使用break语句来退出遍历列表或字典的for循环。）
格式：
while 条件/布尔表达式：
循环内容
break
39.在循环中使用continue:可以使循环运行到continue时，直接返回开头(例如可以根据条件测试结果决定是否继续执行循环)
格式：
while 条件/布尔表达式：
循环内容
if 条件：
continue
循环内容
40.函数:带名字的代码块，用于完成具体的工作，要么返回预期的值，要么返回None。
函数定义：使用关键字def来告诉Python定义的函数，指出函数名，还可能在括号内指出函数为完成其任务需要什么样的信息，即形参。定义以冒号结尾。定义后面的所有缩进行构成了函数体，用三引号括起的部分被称为文档字符串(docstring)，描述了函数的具体功能，Python使用文档字符串来生成有关程序中函数的文档。
函数调用：让Python执行函数的代码。要调用函数，可依次指定函数名以及用括号括起的必要信息(即实参，实参是调用函数时传递给函数的信息，实参为字符串时，最好使用单引号，而不是双引号，实参可以是字符串、列表、字典、数值等)。可以根据需要调用函数任意次。
如：
def greet_user(username):
"""显示简单的问候语"""
print("Hello, " + username.title() + "!")
greet_user('jesse')
编译后，输出：
Hello, Jesse!
41.传递实参：像函数传递实参的方式有很多，可使用位置实参(基于是实参的顺序)，这要求实参的顺序与形参的顺序相同，也可使用关键词实参(传递给函数的名称-值对，将名称和值关联起来，无需考虑实参的顺序），其中每个实参都由变量名和值组成，还可以用列表和字典。
(注意：将列表传递给函数后，函数就可以对其进行修改，函数对这个列表所做的任何修改都是永久性的。有时候，需要禁止函数修改列表，可以使用切片[n:m]创建列表副本，格式：function_name(list_name[:])。
默认值：定义函数时，给形参指定默认值，如def function(a, b='c')，在调用函数时，若给形参都提供了实参时，Python将使用指定的实参值，否则，将使用形参的默认值。(注意：使用默认值时，在形参列表中必须先列出没有默认值的形参，再列出有默认值的实参。这让Python依能够正确地解读位置实参)。
42.返回值：函数并非总是直接显示输出，相反，它可以处理一些数据，并返回一个或一组值。函数返回的值被称为返回值，函数可以返回任何类型的值，包括列表和字典等较复杂的数据结构。在函数中，可使用return语句将值返回到调用函数的代码行。返回值能够将程序的大部分繁重工作移到函数中去完成，从而简化程序。
如：
def get_formatted_name(first_name, last_name):
"""返回整洁的姓名"""
full_name = first_name + " " + last_name
return full_name.title()
musician = get_formatted_name('jimi', 'hendrix')
print(musician)
43.在函数定义的参数前添加一个星号(*)，格式：def function_name(*formal_parameter)，Python会创建一个名为formal_parameter的空元组（tuple），并将收到的所有值都封装到这个元组中，使函数可以接收任意数量的实参。
如果要让函数接收不同类型的实参，必须在函数定义中将接纳任意数量实参的形参放在最后，Python先匹配位置实参和关键字实参，再将余下的实参都收集到最后一个形参中。
如：
def make_pizza(size, *toppings):
"""概述要制作的比萨"""
print("\nMaking a " + str(size) + "-inch pizza with the following toppings: ")
for topping in toppings:
print("- " + topping)
make_pizza(16, 'pepperoni')
make_pizza(12, 'mushrooms', 'green peppers', 'extra cheese')
编译后，输出：
Making a 16-inch pizza with the following toppings:
- pepperoni
Making a 12-inch pizza with the following toppings:
- mushrooms
- green peppers
- extra cheese
44.在函数定义的参数前添加两个星号（**），格式：def function_name(**formal_parameter)，Python会创建一个名为formal_parameter的空字典（dict），并将收到的所有名称-值对（如：a=b）都封装到这个字典中，并且函数可以像访问其他字典那样访问该字典。
如：
def build_profile(first, last, **user_info):
"""创建一个字典，其中包含我们知道的有关用户的一切"""
profile = {'fist_name': first, '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)
编译后，输出：
{'fist_name': 'albert', 'last_name': 'einstein', 'location': 'princeton', 'field': 'physics'}
45.将函数存储在模块中，即模块是扩展名为.py的文件，包含要导入到程序中的代码。
1) import语句允许在当前运行的程序文件中使用模块中的代码。
如：建立一个模块文件的前提下（module_name.py），通过import将该模块导入到要运行的程序中，并将其中的所有函数都复制到这个程序中（复制过程不可见，仅在运行缓存中后台复制），至此，程序可以调用被导入的模块中所有的函数。要调用被导入的模块中的函数，可指定导入的模板的名称module_name和函数名function_name()，并用句点分隔它们，格式：module_name.function_name()。
在module_name.py中：
def function_name(formal_parameters)：
函数内容
在运行程序running_program中（格式）：
import module_name
module_name.function_name(actual_parameters)
2) 导入特定的函数，格式：from module_name import function_name，通过用逗号分隔函数名，可根据需要从模块中导入任意数量的函数：from module_name import function_0, funtion_1, function_2 。若使用这种语法，调用函数时就无需使用句点，由于在import语句中显式地导入了函数，因此调用该函数时，只需指定其名称。
3)使用as给函数指定别名，如果要导入的函数名称可能与程序中现有的函数名称冲突，或者函数名字太长，可以使用关键字as为函数指定另一个名称，格式：from module_name import function_name as function_new_name。
4)使用as给模块指定别名，格式：import module_name as module_new_name，在调用模块中的函数时，可以用格式：module_new_name.funiction_name(actual_parameters)。别名的合理应用可以使代码更加简洁。
5)使用星号运算符（*）可以让Python导入模板中的所有函数，格式：from module_name import *。
注意：所有的import语句都应放在文件开头，唯一例外的情形是，在文件开头使用了注释（如，文档字符串）来描述整个程序。
46.根据约定，在Python中，首字母大写的名称指的是类（class），类的命名，创建类的代码格式：class class_name()，编写类时，定义一大类对象都有的通用行为，基于类创建对象时，每个对象都自动具备这种通用行为，然后可根据需要赋予每个对象独特的个性。根据类来创建对象被称为实例化，生成可以的使用的类的实例（instance），可以将类视为有关如何创建实例的说明。类中的函数称为方法。
方法__init__()是一个特殊的方法，方法的名称开头和末尾各有两个下划线，这是一种约定，旨在避免Python默认方法与普通方法发生冲突。在这个方法的定义中，形参self必不可少，还必须位于其他形参的前面，Python调用方法__init__创建实例时，将自动传入实参self。每个与类相关联的方法调用，都自动传递实参self，它是一个指向实例本身的引用，让实例能够访问类中的属性和方法，self后面的实参可以是字符串、值、列表、元组、字典等。以self为前缀的变量都可供类中的所有方法使用，还可以通过类的任何实例来访问这些变量，如：self.name，像这样可以通过实例访问的变量称为属性(property)。
访问实例的属性，可以使用句点表示法，格式：instance_name.property_name，修改属性值的方法：①直接通过实例访问修改；②通过方法修改属性的值；③使用方法对属性值进行计算调整。
根据类创建实例后(可以创建任意数量的实例），可以用句点表示法来调用类中定义的任何方法，格式：instance_name.function_name()
类的PEP8格式：
class class_name:
# 空格一行
def __init__(self, formal_parameters): # 类初始化要缩进\t
self.formal_parameters = formal_paramerters # 初始化内容，建立属性property
# 空格一行
def function_name(self, formal_parameters): # 创建方法
print(self.formal_parameters) # 在方法中通过句点表示法使用属性
方法内容
#空格两行，进入实例创建
instance_name = class_name # 创建实例
instance_name.function_name(actual_parameters) # 通过实例，使用句点表示法使用类中的方法，引入实参
print(instance_name.property_name) #通过实例，调用属性
47.继承：一个类继承另一个类时，它将自动获得另一个类的所有属性和方法，被继承的类称为父类(parent class)，也称为超类(superclass)，而新类称为子类(child class)。子类继承了其父类的所有属性和方法，同时还可以定义自己的属性和方法，对于一个名称相同的方法，子类将使用自己的方法，忽略父类下的该同名方法。
48.子类的创建格式：
#父类必须包含在当前文件中，且位于子类前面
class parent_class_name:
def __init__(self, formal_parameters):
建立属性
#空格一行
def function_name(self, formal_parameters):
方法内容
#空格两行，再建立子类
class child_class_name(parent_class_name):
def __init__(self, formal_parameters):
super().__init__(formal_parameters)
new_parameters # 增加自有的属性
def new_function(formal_parameters): # 增加新的方法
方法内容
# super()是函数，子类继承了父类的属性和方法，同时可以增加自有的属性和方法。
函数super()帮助Python将父类和子类关联起来。
49.将实例用作类的属性：可以将一个类(类1)的实例(实例1)作为另一个类(类2)的属性，实例带有原有类的所有属性和方法，通过句点表示法访问类1中的方法：类2的实例名.类2的属性名.类1中方法的名称，格式：instance_name2.property_name2.function_name1。
50.导入类：Python允许将类存储在模块中，然后主程序中导入所需的模块和模块内预设的类，主程序可以继续按照正常语法创建导入类的实例和调用方法、属性、继承的父类内容等。用逗号隔开，可以从一个模块中导入多个类。
格式：from module_name import class_name_1, class_name_2
instance_name_1.function_name_1(actual_parameters)
instance_name_2.property_name_2
51.导入整个模块，格式：import module_name
再调用模块中的类，格式：module_name.class_name
52.导入模块中的所有类，格式：from module_name import * （由于导入的类不能直观看到，出错率较大，不推荐使用）。
53.类编码风格：类名应采用驼峰命名法，即将类名中的每个单词的首字母都大写，其余小写，而且不使用下划线。实例名和模块名都采用小写格式，并在单词之间加下划线。
对于每个类，都应紧跟在类定义后面包含一个文档字符串，简要地描述类的功能，并遵循编写函数的文档字符串时采用的格式约定。
每个模块也都应该包含一个文档字符串，对其中的类可用于做什么进行描述。
在类中，使用一个空行来分隔方法；在模块中，使用两个空行来分隔类。
需要同时导入标准库中的模块和自己编写的模块时，先编写导入标准库的import语句，再添加一个空行，然后不编写导入自己编写的模块的import语句。
54.Python标准库：是一组模块，所有安装的Python都包含Python标准库。
如使用模块collections中的OrderedDict类，OrderedDict实例行为几乎与字典相同，区别在于记录了键-值对的添加顺序：
from collections import OrderedDict # 导入模块中的类
# 空格一行
favorite_languages = OrderedDict() # 创建实例instance
# 空格一行
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() + ".")
编译后，输出：
Jen's favorite language is Python.
Sarah's favorite language is C.
Edward's favorite language is Ruby.
Phil's favorite language is Python.
55.文件读取：
函数open()：接受两个参数，即open(file_path, mode)，第一个是要打开的文件的名称或路径，Python会在当前执行的文件所在的目录中查找指定的文件，然后返回一个表示文件的对象，Python将这个对象存储在后面要使用的变量中；第二个是文件的打开模式，包括读取模式(‘r')、写入模式('w')、附加模式(’a‘)、或者可以同时读取和写入的模式(’r+‘)。打开模式若不填，则默认以只读模式打开文件；写入模式下，若要写入的文件不存在，函数open()会自动创建一个同位置同名的文件，若要写入的文件已存在，Python将在返回文件对象前清空该文件。（注意：Python只能将字符串写入文本文件中，要将数值数据存储到文件文件中，必须先使用函数str()将其转换为字符串格式。）
函数close()：接受一个参数，即要关闭的文件的名称，Python会对当前打开的文件执行关闭（当程序有bug时，导致程序未执行到close()，文件将不会关闭，可能进一步导致数据丢失或受损；或者过早地关闭文件，导致无法访问文件）。
关键字with：在不需要访问文件后将其关闭。使用关键词with时，open()返回的文件对象只在with代码块内可用。如果要在with代码块外访问文件的内容，可在with代码块内将文件的各行存储在一个列表中，并在with代码块外使用该列表。
方法read()：读取打开的文件的全部内容，可以将读取的内容作为一个字符串存储在一个变量中，方便后续调用。方法read()在读取到文件末尾时返回一个空字符串，而将这个空字符串显示出来时就是一个空行。要删除多出来的空行，可以使用方法rstrip()。(读取文本文件时，Python将其中的所有文本都解读为字符串）。
方法readlines()：从文件中读取每一行，并将其存储在一个列表中。
方法replace()：将字符串中特定的字符部分都替换为另一个字符部分，格式：string_name.replace(‘original_string', 'new_string')，并且不改变变量在内存中的内容，只是在输出结果上做了替换。
方法split()：以空格为分隔符将字符串分拆成多个部分，并将这些部分都存储到一个列表中，结果是一个包含字符串中所有单词的列表，虽然有些单词可能包含标点。
方法count()：可以确定特定的单词或短语在字符串中出现了多少次，格式：string_name.count('words')
文件路径：在Windows系统中，文件路径使用反斜杠(\)（注意：也可以使用斜杠，大多数情况下同样可以识别，但是有特殊情况会导致无法读取路径）；在Linux和OS X中，文件路径使用斜杠(/)。Python会根据提供的文件路径到系统的特定位置查找文件。相对文件路径：指相对于当前运行的程序所在的目录，如：file_path = 'text_files\filename.txt；绝对文件路径：指文件在计算机中的准确位置，如：file_path = 'C:\\Users\\Lenovo\\documents.txt'。
由于反斜杠(\)在Python中表示转义符，所以如果要用反斜杠表示路径，则必须使用双反斜杠，或者使用原始字符串常量(raw string)，即(r)，可以让字符保持原来的意思，如：file_path = C:\\Users\\Lenovo\\documents.txt'，或者file_path = r'C:\\Users\\Lenovo\\documents.txt'。
56.Python使用异常来管理程序执行期间发生的错误。当发生错误时，如果有编写里对应的异常处理代码，即try-except或try-except-else(except中异常执行对策可以使用pass语句，告诉Python什么都不要做)，程序将继续运行，如果没有，程序将停止，并显示traceback。
常见的异常：FileNotFoundError、ZeroDivisionError、ValueError
格式：
try:
异常程序内容
except 错误类型:
异常执行对策 # 或者使用：pass
else:
无异常，继续执行内容
57. 将数据存储到文件：
JSON(JavaScript Object Notation)格式最初是为JavaScript开发的，但随后成了一种常见的格式，被包括Python在内的众多语言采用。
函数json.dump()接受两个实参：要存储的数据以及可用于存储数据的文件对象，可以将数据存储到.json文件中，格式：json.dump(value, file_object)。
函数json.load()接受储存数据的文件对象，将.json文件内容读取到程序中，格式：json.load(file_object)。
58.重构：代码能够正确的运行，但可以做进一步的改进，将代码划分为一系列完成工作的函数。
59.测试代码
单元测试用于核实函数的某个方面没有问题；测试用例是一组单元测试，这些单元测试一起核实函数在各种情形下的行为都符合要求。良好的测试用例考虑到了函数可能收到的各种输入，包含针对所有这些情形的测试。全覆盖式测试用例包含一整套单元测试，涵盖了各种可能的函数使用方式。
运行测试用例时，每完成一个单元测试，Python都打印一个字符：测试通过时打印一个句点；测试引发错误时打印一个E；测试导致断言失败时打印一个F。
这就是运行测试用例时，在输出的第一行中看到的句点和字符数量各不相同的原因。如果测试用例包含很多单元测试，需要运行很长时间，就可以通过观察这些结果来获悉有多少个测试通过了。
Python标准库中的模块unittest提供了代码测试工具，要为函数编写测试用例，可先导入模块unittest以及要测试的函数，再创建一个继承unittest.TestCase的类，并编写一系列方法对函数行为的不同方面进行测试。
函数测试格式：
import unittest # 导入unittest
from module_name import function_name # 导入要测试的函数
class child_class_name(unittest.TestCase)
测试内容和断言代码 # 如self.assertEqual(a, b)
unittest.main() # 让Python运行这个文件中的测试
60.unittest.TestCase类中提供了很多断言方法，断言方法用来核实得到的结果是否与期望的结果一致。
unittest Module中的断言方法：
assertEqual(a, b)：核实a == b
assertNotEqual(a, b)：核实a != b
assertTrue(x)：核实x为True
assertFalse(x)：核实x为False
assertIn(item, list)：核实item在list中
asserNotIn(item, list)：核实item不在list中
61.方法setUp()：测试自己编写的类时，方法setUp()让测试方法编写起来更容易，可在setUp()方法中创建一系列实例并设置它们的属性，再在测试方法中直接使用这些实例。相比在每个测试方法中都创建实例并设置其属性，要容易得多。
二、模块(Module)
1. pygame库中的函数、方法、属性、事件：
函数pygame.image.load('image_address')用于加载游戏中的图片；
方法get_rect()可以获取图片的surface属性rect，可以像处理矩形(rectangle，即rect对象)一样处理游戏图片元素，不用在意图片形状的规则与否。处理rect对象时，可以使用矩形四角和中心的x和y坐标，通过设置这些值来指定矩形的位置，要将游戏元素居中，可设置相应rect对象的属性center、centerx、centery；要让游戏元素与屏幕边缘对齐，可使用属性top、bottom、left或者right；要调整游戏元素的水平或者垂直位置，可使用属性x和y，它们分别是相应矩形左上角的x和y坐标。在Pygame中，原点(0, 0)位于屏幕左上角，向右下方移动时，坐标值将增大。
函数pygame.event.get()用户使用鼠标和按键时，都会在pygame注册一个事件，该函数可以获取该事件；
事件pygame.QUIT获得退出事件；
事件pygame.KEYDOWN获得键盘按下事件；
事件pygame.KEYUP获得键盘放开事件；
事件pygame.K_RIGHT获得键盘方向键右箭头事件；
事件pygame.K_LEFT获得键盘方向键左箭头事件；
事件pygame.K_SPACE获得键盘空格键事件；
函数sys.exit()退出当前程序；
函数screen.fill((R_value, G_value, B_value))给屏幕填充背景颜色；
函数pygame.displa.flip()让最近绘制的屏幕可见；
方法pygame.draw用于在屏幕上绘制对象；
surface属性rect.right表示外接矩形的右边缘的x坐标；
surface属性rect.left表示外接矩形的左边缘的x坐标。
2. matplotlib库中的函数、属性、方法：
函数plot(input_value, output_value, linewidth_value)可指定各种实参，输入值x、输出值y、线宽，对数据绘制折线图；
scatter(x_values, y_values, c='color_value', edgecolor='none', s=dot_size_value)可用于绘制散点图；
方法show()，显示绘制的图表；
方法savefig()，保存绘制的图表;
颜色映射（colormap)是一系列颜色，它们从起始颜色渐变到结束颜色。在可视化中，颜色映射用于突出数据的规律。