一. 字典

1.字典是存储信息的一种方式。
2.字典以键-值对存储信息，因此字典中的任何一条信息都与至少一条其他信息相连。
3.字典的存储是无序的，因此可能无法按照输入的顺序返回信息。

字典的 基本用法：创建 / 输出 / 插入新的键-值对 / 修改值 / 修改键名 / 删除项

python_words = {'list': '相互没有关系，但具有顺序的值的集合',
                'dictionary': '一个键-值对的集合',
                'function': '在 Python 中定义一组操作的命名指令集',
                }
                
print("\n名称: %s" % 'list')
print("解释: %s" % python_words['list'])

嵌套
嵌套包括把列表或字典放在另一个列表或字典中。
值为列表的字典

sparse_matrix[0] = {1: 12.3, 23: 25.5}
sparse_matrix[1] = {3: 12.0, 15: 25.5}
# 打印出来看下上述字典的样子
print('sparse_matrix = {')
for key, value in sparse_matrix.items():
    print(key,':',value)
print('}')
# 通过 字典名[词条名][词条内属性名] 访问
print(sparse_matrix[0][23])

二. 函数

定义一个函数
^ 使用关键字 def 告诉 Python 你将要定义一个函数。
^ 给你的函数起一个名字。给函数需要的数据起名称。
它们是变量名，而且只在函数里用。
^ 这些名称被称为函数的 参数（arguments）
^ 确保函数的定义以冒号结束。
在函数内部，写下任意你想要的代码。
使用你的函数
函数名后跟圆括号调用函数。
在圆括号中，给出函数运行需要的数据。
函数中的参数可以是变量，也可以是实际的数据。

def thank_you(name):
    # This function prints a two-line personalized thank you message.
    print("\nYou are doing good work, %s!" % name)
    print("Thank you very much for your efforts on this project.")
    
thank_you('Adriana')
thank_you('Billy')
thank_you('Caroline')

参数缺省值

def thank_you(name='everyone'):
    # This function prints a two-line personalized thank you message.
    #  If no name is passed in, it prints a general thank you message
    #  to everyone.
    print("\nYou are doing good work, %s!" % name)
    print("Thank you very much for your efforts on this project.")
    
thank_you('Billy')
thank_you('Caroline')
thank_you()

函数在使用前一定要先声明
和 c++ 中函数的用法相似 返回值 函数名 参数（缺省 位置对应） 函数体
更加方便：关键字参数，可以不按照顺序传参

def describe_person(first_name, last_name, age):
    # This function takes in a person's first and last name,
    #  and their age.
    # It then prints this information out in a simple format.
    print("First name: %s" % first_name.title())
    print("Last name: %s" % last_name.title())
    print("Age: %d\n" % age)

describe_person(age=71, first_name='brian', last_name='kernighan')
describe_person(age=70, first_name='ken', last_name='thompson')
describe_person(age=68, first_name='adele', last_name='goldberg')

接受任意数量的参数
接受任意长度的序列
可以让函数接受任意数量的参数。如果我们在参数列表的最后一个参数前加 一个星号，这个参数就会收集调用语句的剩余参数并传入一个元组。（剩余参数是指匹配过位置参数后剩余的参数）
接受任意数量的关键字参数
最后一个参数前有 两个星号，代表着收集调用语句中剩余的所有键值对参数。这个参数常被命名为 kwargs 。这些参数键值对被存储在一个字典中。我们可以循环字典取出参数值。

def example_function(arg_1, arg_2, **kwargs):
    # Let's look at the argument values.
    print('\narg_1:', arg_1)
    print('arg_2:', arg_2)
    for key, value in kwargs.items():
        print('arg_3 value:', value)
    
example_function('a', 'b')
example_function('a', 'b', value_3='c')
example_function('a', 'b', value_3='c', value_4='d')
example_function('a', 'b', value_3='c', value_4='d', value_5='e')

三. 类

关键字 class，数据和函数没有分开，直接定义函数中包含你所需要的操作，在操作中声明你所需要用到的数据。类名开头必须为大写而且不能包含下划线，同样有类的“继承”。

class Rocket():
         # Rocket simulates a rocket ship for a game,# Rocket 
    #  or a physics simulation.
    
    def __init__(self):
        # Each rocket has an (x,y) position.
        self.x = 0
        self.y = 0
        
    def move_up(self):
        # Increment the y-position of the rocket.
        self.y += 1
        
# Create a fleet of 5 rockets, and store them in a list.
my_rockets = [Rocket() for x in range(0,5)]

# Show that each rocket is a separate object.
for rocket in my_rockets:
    print(rocket)

前后都有两个下划线的函数是内置在 Python 中的有特殊用途的函数。init() 函数就是一个特殊的函数。当创建一个类的对象时，它会自动执行。我们可以称之为 初始化函数，在对象使用之前初始化一些必要的属性。在这个例子中，init() 函数初始化了 x 和 y 属性。
关键字 self 类似this指针，可以指向当前对象，供我们访问类的属性。

from math import sqrt

class Rocket():
    # Rocket simulates a rocket ship for a game,
    #  or a physics simulation.
    
    def __init__(self, x=0, y=0):
        # Each rocket has an (x,y) position.
        self.x = x
        self.y = y
        
    def move_rocket(self, x_increment=0, y_increment=1):
        # Move the rocket according to the paremeters given.
        #  Default behavior is to move the rocket up one unit.
        self.x += x_increment
        self.y += y_increment
        
    def get_distance(self, other_rocket):
        # Calculates the distance from this rocket to another rocket,
        #  and returns that value.
        distance = sqrt((self.x-other_rocket.x)**2+(self.y-other_rocket.y)**2)
        return distance
    
class Shuttle(Rocket):
    # Shuttle simulates a space shuttle, which is really
    #  just a reusable rocket.
    
    def __init__(self, x=0, y=0, flights_completed=0):
        super().__init__(x, y)
        self.flights_completed = flights_completed
        
shuttle = Shuttle(10,0,3)
print(shuttle)

当一个子类要继承父类时，在定义子类的圆括号中填写父类的类名,新类的 init() 函数需要调用新类的 init() 函数。新类的 init() 函数接受的参数需要传递给父类的 init() 函数。由 super().init() 函数负责。

面向对象基础

常用术语
class：类。类是代码块的主体，其中定义了建立的模型的属性和行为。这个模型可以来自于真实世界，也可以是虚拟游戏等。
attribute*：属性。是一系列信息的集合。在类中，一个属性通常是一个变量。
behavior：行为。行为是定义在类中，组成方法的部分。也即是定义在类中函数的一部分。
method：方法。类中的函数，由 behavior 组成。
object：对象。对象是类的实例。一个对象中包含所有类中属性的值。你可以为一个类创建任意数量的对象。

模块

当你将类存储在一个单独的文件中时，这个文件就被称为一个 模块（module）。在一个模块中可以写入任意数量的类。而且有很多方式在程序中导入模块中的类。
将 Rocket 类存进一个称之为 rocket.py 的文件。模块的名字是小写的单词，类名是以大写字母开头的。

class Rocket():
    
    def __init__(self, x=0, y=0):
        self.x = x
        self.y = y
        
    def move_rocket(self, x_increment=0, y_increment=1):
        self.x += x_increment
        self.y += y_increment
        
    def get_distance(self, other_rocket):
        distance = sqrt((self.x-other_rocket.x)**2+(self.y-other_rocket.y)**2)
        return distance

from rocket import Rocket

rocket = Rocket()
print("The rocket is at (%d, %d)." % (rocket.x, rocket.y))

导入模块和类的方法
1.直接导入模块+类名
2.只导入模块，再利用点引用类
3.使用 as 给模块重新命名
4.用*导入模块中的所有类和函数

四. 异常

异常是可以修改程序控制流程的事件。
在 Python 中，异常可以被错误自动触发，也可以由代码手动触发。
try/except：捕捉并恢复 Python 自动触发的或自己代码中的异常。
try/finally：无论异常是否发生，执行清理操作。
raise：手动触发一个异常。
with/as：在 Python 2.6 ，3.0 或更新的版本中实现上下文管理器。

有c++的基础之后基本知识点都还比较好理解，剩下需要多动手写，熟练掌握。