16 字典简介

字典定义

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

Python定义字典

dictionary_name = {key_1: value_1, key_2: value_2}

为了更明显的显示数据，通常写成下面的格式

dictionary_name = {key_1: value_1,
                   key_2: value_2
                   }

字典的基本用法

定义一个字典：

列如 ：把 list、dictionary、function 的解释写成一个字典，请按下面的格式输出 dictionary 和 function 的定义

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

字典的基本操作

*输出字典

# name 和 meaning 可以随意该名称，试试改成 word 和 word_meaning
for name, meaning in python_words.items():
    print("\n名称: %s" % name)
    print("解释: %s" % meaning)

# 还有几种其他的输出方式，动手试一下。
print("***********************************************")
for word in python_words:
    print("%s" % word)
print("***********************************************")
for word in python_words.keys():
    print(word)
print("***********************************************")
for meaning in python_words.values():
     print("值: %s" % meaning)
print("***********************************************")
for word in sorted(python_words.keys()):
    print("%s: %s" % (word, python_words[word]))

• 给字典加入新的键-值对：

# 定义一个空字典
python_words = {}

# 给字典加入新项（词条）：使用 字典名[键名] = 值 的形式可以给字典添加一个键-值对
python_words['Joker'] ='会玩 LOL'
python_words['Burning'] = '会玩 DOTA'
python_words['Elingsama'] = '会玩炉石传说'

def showMeanings(dictionary):
    for name, meaning in dictionary.items():
        print("\n名称: %s" % name)
        print("解释: %s" % meaning)

• 修改字典中的值：

python_words['Joker'] = 'LOL 的恶魔小丑'
print('\nJoker: ' + python_words['Joker'])

• 删除字典中的项：

# 返回 Joker 对应的值，同时删除 Joker 的键-值对
_ = python_words.pop('Joker')
# 删除 Buring 的键-值对
del python_words['Burning']
print(_)

• 修改键名：

# 1.创建一个新键
# 2.将要更换键名的值赋给新键
python_words['elingsama'] = python_words['Elingsama']
del python_words['Elingsama']

showMeanings(python_words)

嵌套

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

• 值为列表的字典

favorite_numbers = {'eric': [3, 11, 19, 23, 42],
                    'ever': [2, 4, 5],
                    'willie': [5, 35, 120],
                    }
通过 字典名[词条名][词条内位置] 访问
print(favorite_numbers['eric'][0])

• 值为字典的字典

sparse_matrix = {}
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])

17 函数简介

通用语法：

# Let's define a function.
def function_name(argument_1, argument_2):
    # Do whatever we want this function to do,
    #  using argument_1 and argument_2

# Use function_name to call the function.
function_name(value_1, value_2)

定义一个函数

• 使用关键字 def 告诉 Python 你将要定义一个函数。
• 给你的函数起一个名字。函数名应当能表明函数是干什么的。
• 给函数需要的数据起名称。
  它们是变量名，而且只在函数里用。
  这些名称被称为函数的参数（arguments）
• 确保函数的定义以冒号结束。
• 在函数内部，写下任意你想要的代码。

使用函数

• 函数名后跟圆括号调用函数。
  在圆括号中，给出函数运行需要的数据。
• 函数中的参数可以是变量，例如 current_name 和 current_age，也可以是实际的数据，例如 'eric' 和 5。

函数一定要在使用之前定义。否则就会引起错误。

返回值

每个函数都可以返回一个值。返回值可以是当前函数主要功能外无足轻重的功能，也可以是函数的主要功能
列如

 return 'three'

18 函数进阶

参数缺省值

有时候你想在不传参数的时候让函数执行默认的动作。你可以通过设置参数的缺省值实现这个功能。缺省值是在函数定义的时候确定的

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()

位置参数

函数中，Python 会根据参数的相对位置为它们赋值。

关键字参数

Python 中允许使用关键字参数。所谓关键字参数就是在调用函数时，可以指定参数的名字给参数赋值

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(**kwargs):
    print(type(kwargs))
    for key, value in kwargs.items():
        print('{}:{}'.format(key, value))
        
example_function(first=1, second=2, third=3)
example_function(first=1, second=2, third=3, fourth=4)
example_function(name='Valerio', surname='Maggio')

19 类

• 定义：类是一种组合信息和行为的方式。
  为了使用类，创建一个变量如 my_rocket 。然后用类名后跟圆括号给这个变量赋值。这样就创建了一个类的对象。

对象是类的实例，它有类中所有变量的拷贝。

• 你可以看到变量 my_rocket 是一个来自 main 程序文件中的 Rocket 对象，这个程序文件存储在内存中的特定位置
• 使用对象名和点符号来访问对象的变量和方法。
• 一旦类定义好，你就可以创建任意数量的对象。每个对象都有独立的变量空间，互不影响。

class Rocket():
    # Rocket simulates a rocket ship for a game,
    #  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 Rocket object, and have it start to move up.
my_rocket = Rocket()
print("Rocket altitude:", my_rocket.y)

my_rocket.move_up()
print("Rocket altitude:", my_rocket.y)

my_rocket.move_up()
print("Rocket altitude:", my_rocket.y)

20 面向对象基础
类是面向对象程序设计的一部分。面向对象程序设计或者简称为 OOP 致力于创建可重用代码块称之为类。当你想在你的程序中使用类时，你会从类中创建一个对象，这也是面向对象一词的由来。

常用术语

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

注意事项

• Python 中有一个约定好的规则，类名必须是驼峰式的。也即每个单词的开头必须是大写的，不允许下划线的出现。类名后紧跟一对圆括号
• 前后都有两个下划线的函数是内置在 Python 中的有特殊用途的函数。init() 函数就是一个特殊的函数。当创建一个类的对象时，它会自动执行。我们可以称之为初始化函数，在对象使用之前初始化一些必要的属性。
• 关键字 self 可能会有些难以理解。单词 "self" 指向当前的对象。当你创建一个类时，它可以访问到类中的任意指定属性。基本上，类中所有的函数都需要 self 对象作为第一个参数，因此它们就可以访问类中的属性
• 方法就是类中的函数。,默认情况下，每个函数都需要接受一个参数：self .它是对调用这个方法的对象的引用。self 参数能让你访问到调用对象的属性。

创建多个对象

面向对象编程一个重要目标是创建可重用代码。一旦你写好了类，就能创建任意数量的对象。通常，类被放进一个单独的文件中，在需要的时候导入程序中。因此你可以创建一个类库，在不同的程序中重复使用这些类。

21继承

• 在 Python 和任意支持面向对象编程的语言中，一个类可以继承另一个类。这也意味着你可以在旧类的基础上创建新类。新类继承旧类中所有的属性和行为。

• 新类可以重写覆盖任一继承自旧类的属性或行为。也可以添加新的属性和行为。旧类被称为父类，新类被称为父类的孩子。父类也被称为 superclass ，子类被称为 subclass。

• 子类继承父类的所有属性和行为，但在子类中定义的属性和行为不能为父类所用。

• 子类可以重写父类中的方法。如果子类中定义了一个已经在父类中出现的方法，子类对象会调用子类的方法而不是父类的

• 当一个子类要继承父类时，在定义子类的圆括号中填写父类的类名：

• 新类的 init() 函数需要调用新类的 init() 函数。新类的 init() 函数接受的参数需要传递给父类的 init() 函数。由 super().init() 函数负责：
  使用 super() 语法就可以在一行内调用所有父类的 init() 方法。

22 模块和类

Python 允许你将类放进另一个文件中然后在你的程序中导入。这样就将你的类和程序隔离，也就能在不同的程序中运用。随着使用次数的增多，类也会变得越来越可靠和完善。

在模块中存储一个类

• 当你将类存储在一个单独的文件中时，这个文件就被称为一个模块（module）。在一个模块中可以写入任意数量的类。而且有很多方式在程序中导入模块中的类。
• 我们将 Rocket 类存进一个称之为 rocket.py 的文件。需要注意的是，模块的名字是小写的单词，类名是以大写字母开头的。
• 创建一个单独的 rocket_name.py 文件。确保使用约定的命名方式，小写字母加下划线的方式为文件命名

# Save as rocket_game.py
from rocket import Rocket

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

在模块中可以存储多个类

一个模块通常是包含多个类和函数的文件

导入模块和类的一些方法

1. from module_name import ClassName这种方法是相当直接且常用的。但是有一个问题，当程序逐渐变大时，程序中可能会出现和导入的类名相同的名字。
2. import module_name 只导入模块 ,导入之后就可以利用点来引用模块中的类。
   这种导入方式避免了刚才的问题。但是仔细阅读代码你会发现另一个问题，程序中使用该模块 名字的变量都要改变，因为它跟模块名冲突了。
   3.import module_name as local_module_name1当你在你的项目中导入模块时，你可以为模块自定义名字。
3. from module_name import *
   这种方法导入模块中的所有类和函数。这种方法虽然可行，但你要尽量避免使用。首先你不知道导入的类名是不是和程序中其他变量名等冲突；而且你将会在程序中导入大量的代码，影响代码性能。

函数模块

• 模块中也可以存储函数，使用方法和上述类的使用相同

23 异常

异常是什么

异常是可以修改程序控制流程的事件。
在 Python 中，异常可以被错误自动触发，也可以由你的代码手动触发。
4种处理异常的语句

• try/except：捕捉并恢复 Python 自动触发的或自己代码中的异常。
• try/finally：无论异常是否发生，执行清理操作。
• raise：手动触发一个异常。
• with/as：在 Python 2.6 ，3.0 或更新的版本中实现上下文管理器。

try/except 语句

try/finally 语句

try/finally 是 try 语句的一种形式，finally 语句是 try 之后无论是否出现异常都要执行的语句。

with/as 上下文管理器

with语句允许开发者创建上下文管理器，上下文管理器就是允许你可以自动地开始和结束一些事情

工作原理

• 上下文管理器必须包含 enter 和 exit 方法。
• enter 方法被自动调用，如果存在 as 子句，返回值就被赋值给 as 后的变量，没有就直接丢弃。
• 嵌套在 with 语句下的代码被执行。
• 如果 with 语句中的代码抛出异常， exit(type, value, traceback) 方法就会被调用。参数值是和 sys.exc_info() （Python 内置函数）函数返回值相同的值。如果这个方法返回了一个 false 值，异常就会被重新抛出，否则异常终止。异常重新抛出是以常规方式抛出的，因此在 with 语句外捕获。
• 如果 with 语句里的代码块没有抛出异常，exit 方法仍旧会被调用，但是参数会被置为 None。