python学习-模块1-总结

1. 初识python

1.1 编程语言

计算机语言包括机器语言、汇编语言、高级语言。机器语言是用二进制代码表示的计算机能直接识别和执行的一种机器指令的集合。它是计算机的设计者通过计算机的硬件结构赋予计算机的操作功能，比如汇编语言（assembly language)。机器语言具有灵活、直接执行和速度快等特点。高级语言比较容易识记和理解，像C、B语言等。

机器语言

用机器语言编写程序，编程人员要首先熟记所用计算机的全部指令代码和代码的涵义

汇编语言

为了克服机器语言难读、难编、难记和易出错的缺点，人们就用与代码指令实际含义相近的英文缩写词、字母和数字等符号来取代指令代码（如用ADD表示运算符号“+”的机器代码），于是就产生了汇编语言。所以说，汇编语言是一种用助记符表示的仍然面向机器的计算机语言

高级语言

高级语言是大多数编程者的选择。和汇编语言相比，它不但将许多相关的机器指令合成为单条指令，并且去掉了与具体操作有关但与完成工作无关的细节，例如使用堆栈、寄存器等，这样就大大简化了程序中的指令。同时，由于省略了很多细节，编程者也就不需要有太多的专业知识。

高级语言分类
高级语言所编制的程序不能直接被计算机识别，必须经过转换才能被执行，按转换方式可将它们分为两类：

解释类：执行方式类似于我们日常生活中的“同声翻译”，应用程序源代码一边由相应语言的解释器“翻译”成目标代码（机器语言），一边执行，因此效率比较低，而且不能生成可独立执行的可执行文件，应用程序不能脱离其解释器，但这种方式比较灵活，可以动态地调整、修改应用程序。如较早时期的Qbasic语言。
编译程序将源程序翻译成目标程序后保存在另一个文件中，该 目标程序可脱离编译程序直接在计算机上多次运行。大多数软件产品都是以目标程 序形式发行给用户的，不仅便于直接运行，同时又使他人难于盗用其中的技术C、 C++、Fortran、Visual Foxpro、Pascal、Delphi、Ada都是编译实现的。

编译类：编译是指在应用源程序执行之前，就将程序源代码“翻译”成目标代码（机器语言），因此其目标程序可以脱离其语言环境独立执行，使用比较方便、效率较高。但应用程序一旦需要修改，必须先修改源代码，再重新编译生成新的目标文件（* .obj，也就是OBJ文件）才能执行，只有目标文件而没有源代码，修改很不方便。
一般地，动态语言都是解释型的，如Tcl、 Perl、Ruby、VBScript、 JavaScript等。

混合型：Java很特殊，Java程序也需要编译，但是没有直接编译称为机器语言，而是 编译称为字节码，然后在Java虚拟机上用解释方式执行字节码。Python的也采用了类似Java的编译模式，先将Python程序编译成Python字节码，然后由一个专门的 Python字节码解释器负责解释执行字节码。

1.2 python的几种解释器

当我们编写Python代码时，我们得到的是一个包含Python代码的以.py为扩展名的文本文件。要运行代码，就需要Python解释器去执行.py文件。

由于整个Python语言从规范到解释器都是开源的，所以理论上，只要水平够高，任何人都可以编写Python解释器来执行Python代码（当然难度很大）。事实上，确实存在多种Python解释器。

CPython
当我们从Python官方网站下载并安装好Python 2.7后，我们就直接获得了一个官方版本的解释器：CPython。这个解释器是用C语言开发的，所以叫CPython。在命令行下运行python就是启动CPython解释器。
CPython是使用最广的Python解释器。

IPython
IPython是基于CPython之上的一个交互式解释器，也就是说，IPython只是在交互方式上有所增强，但是执行Python代码的功能和CPython是完全一样的。好比很多国产浏览器虽然外观不同，但内核其实都是调用了IE。
CPython用>>>作为提示符，而IPython用In [序号]:作为提示符。

PyPy
PyPy是另一个Python解释器，它的目标是执行速度。PyPy采用JIT技术，对Python代码进行动态编译（注意不是解释），所以可以显著提高Python代码的执行速度。

绝大部分Python代码都可以在PyPy下运行，但是PyPy和CPython有一些是不同的，这就导致相同的Python代码在两种解释器下执行可能会有不同的结果。如果你的代码要放到PyPy下执行，就需要了解PyPy和CPython的不同点。

Jython
Jython是运行在Java平台上的Python解释器，可以直接把Python代码编译成Java字节码执行。

IronPython
IronPython和Jython类似，只不过IronPython是运行在微软.Net平台上的Python解释器，可以直接把Python代码编译成.Net的字节码。

1.3 python的应用范围

下面是python应用得到的几个领域

1.3.1 WEB开发

最火的Python web框架Django，支持异步高并发的Tornado框架，短小精悍的flask,bottle

Django
Django是一个开放源代码的Web应用框架，由Python写成。采用了MTV的框架模式，即模型M，模板T和视图V。它最初是被开发来用于管理劳伦斯出版集团旗下的一些以新闻内容为主的网站的，即是CMS（内容管理系统）软件。并于2005年7月在BSD许可证下发布。

Tornado
Tornado是一种 Web 服务器软件的开源版本。Tornado 和现在的主流 Web 服务器框架（包括大多数
Python 的框架）有着明显的区别：它是非阻塞式服务器，而且速度相当快。 得利于其 非阻塞的方式和对epoll的运用，Tornado
每秒可以处理数以千计的连接，因此 Tornado 是实时 Web 服务的一个 理想框架。

Flask
Flask 是一个 Python实现的 Web 开发微框架。本身不包含数据库抽象层、表单验证，或是其它任何已有多种库可以胜任的功能。然而，Flask支持用扩展来给应用添加这些功能，如同是 Flask本身实现的一样。众多的扩展提供了数据库集成、表单验证、上传处理、各种各样的开放认证技术等功能。Flask也许是“微小”的，但它已准备好在需求繁杂的生产环境中投入使用。

1.3.2 人工智能

互联网产生了数据，云计算和大数据成就了人工智能，人工智能是未来科技的主流，强人工智能时代是我们共同的期待。
人工智能的主要研究领域，主要有机器学习、神经网络、模式识别、人脸识别、定理证明等，大数据领域，主要有数据采集、数据挖掘、数据分析等，人工智能和大数据的主要研究领域，都是Python的专属。
Python拥有强大的AI库，海量的模块，开发效率高，简单高效。python有很多库很方便做人工智能，比如numpy, scipy做数值计算的，sklearn做机器学习的，pybrain做神经网络的，matplotlib将数据可视化的。

1.3.3 云计算

目前最火最知名的云计算框架就是OpenStack,Python现在的火，很大一部分也是因为云计算

1.3.4 金融量化分析

在量化投资（证券和比特币）开源项目里，全球star数排名前10位里面，有7个是Python实现的。从数据获取到策略回测再到交易，覆盖了整个业务链。

1.3.5 爬虫

效率高，开发快，支持的数据类型丰富。

1.3.6 自动化运维

1.3.7 科学运算

随着NumPy, SciPy, Matplotlib, Enthought librarys等众多程序库的开发，Python越来越适合于做科学计算、绘制高质量的2D和3D图像。和科学计算领域最流行的商业软件Matlab相比，Python是一门通用的程序设计语言，比Matlab所采用的脚本语言的应用范围更广泛，有更多的程序库的支持。虽然Matlab中的许多高级功能和toolbox目前还是无法替代的，不过在日常的科研开发之中仍然有很多的工作是可以用Python代劳的。

1.3.8 游戏开发

---

2. python入门

2.1 Python2 Vs Python3

2.1.1 Python 2

Python 2 发布于 2000 年年底，意味着较之先前版本，这是一种更加清晰和更具包容性的语言开发过程。而先前版本的 Python 应用的是 PEP (Python 增强协议)，这种技术规范能向 Python 社区成员提供信息或描述这种语言的新特性。

此外，Python 2 还包括了更多的程序性功能，包括能自动化地管理内存的循环检测垃圾收集器，增加了对 Unicode 的支持以实现字符的标准化，并采用列表综合的方式以在现有列表基础上创建列表。 随着 Python 2 的不断发展，更多的功能被添加进来，包括将 Python 的类型和类在 Python 2.2 版本中统一为一层。

2.1.2 Python 3

Python 3 被视为 Python 的未来，是目前正在开发中的语言版本。作为一项重大改革，Python 3 于 2008 年年末发布，以解决和修正以前语言版本的内在设计缺陷。Python 3 开发的重点是清理代码库并删除冗余，清晰地表明只能用一种方式来执行给定的任务。

对 Python 3.0 的主要修改包括将 print 语句更改为内置函数，改进整数分割的方式，并对 Unicode 提供更多的支持。

起初，Python 3的采用很缓慢，因为该语言不能向后兼容 Python 2，这就需要人们决定该使用哪个版本的语言。此外，许多封装库库只适用于 Python 2，但是由于 Python 3 背后的开发团队重申了终止对 Python 2 的支持，促使更多的库被移植到 Python 3 上来。从对 Python 3 提供支持的 Python 包的数量可以看出，Python 3 已得到越来越多的采用，在撰写本文时，支持它的包就已包括了 339 个最受欢迎的 Python 包。

2.1.3 Python 2.7

在 2008 年 Python 3.0 的发布之后，Python 2.7 于 2010 年 7 月 3 日发布，并计划作为 2.x 版本的最后一版。发布 Python 2.7 的目的在于，通过提供一些测量两者之间兼容性的措施，使 Python 2.x 的用户更容易将功能移植到 Python 3 上。这种兼容性支持包括了 2.7 版本的增强模块，如支持测试自动化的 unittest，用于解析命令行选项的 argparse，以及更方便的集合类。

Python 2.7 具有 Python 2 和 Python 3.0 之间的早期迭代版本的独特位置，它因为对许多具有鲁棒性的库具有兼容性，对于程序员而言一直是非常流行的选择。当我们今天讨论 Python 2 时，我们通常指的是 Python 2.7 版本，因为它是最常用的版本。

然而，Python 2.7 被认为是一种遗留语言，且它的后续开发，包括现在最主要的 bug 修复，将在 2020 年完全停止。

2.2 Hello World

2.2.1 安装python3

下载地址：https://www.python.org/downloads/windows/

2.2.2 第一句python代码

print('Hello World!')

2.2.3 python中的变量

2.2.4 用户输入交互

使用input函数

name = input('Please input your name: ')
age = input('Please input your age: ')

print("OK. You information name: {}, age: {} will be registered.".format(name, age))

输出如下：

Please input your name: Pet
Please input your age: 24
OK. You information name: Pet, age: 24 will be registered.

2.2.5 代码注释

代码注释使用#号

代码注释原则：

不用全部加注释，只需要在自己觉得重要或者不好理解的部分加注释即可。
注释可以使用中文或者英文，但是绝对不要使用拼音

3. python的数据类型

数据类型在数据结构中的定义是一个值的集合以及定义在这个值集上的一组操作。

变量是用来存储值的所在处，它们有名字和数据类型。变量的数据类型决定了如何将代表这些值的位存储到计算机的内存中。所有变量都具有数据类型，以决定能够存储哪种数据。

3.1 基本类型

3.1.1 数字

整型int
在Python内部对整数的处理分为普通整数和长整数，普通整数长度为机器位长，通常都是32位，超过这个范围的整数就自动当长整数处理，而长整数的范围几乎完全没限制。Python可以处理任意大小的整数，当然包括负整数，在程序中的表示方法和数学上的写法一模一样，例如：1，100，-8080，0，等等。

浮点型
Python的浮点数就是数学中的小数，类似C语言中的double。
在运算中，整数与浮点数运算的结果是浮点数。浮点数也就是小数，之所以称为浮点数，是因为按照科学记数法表示时，一个浮点数的小数点位置是可变的，比如，1.23x109和12.3x108是相等的。浮点数可以用数学写法，如1.23，3.14，-9.01，等等。但是对于很大或很小的浮点数，就必须用科学计数法表示，把10用e替代，1.23x109就是1.23e9，或者12.3e8，0.000012可以写成1.2e-5，等等。
整数和浮点数在计算机内部存储的方式是不同的，整数运算永远是精确的（除法难道也是精确的？是的！），而浮点数运算则可能会有四舍五入的误差。

数值运算

>>>5 + 4  # 加法
9
>>> 4.3 - 2 # 减法
2.3
>>> 3 * 7  # 乘法
21
>>> 2 / 4  # 除法，得到一个浮点数
0.5
>>> 2 // 4 # 除法，得到一个整数
0
>>> 17 % 3 # 取余 
2
>>> 2 ** 5 # 乘方
32

Python还支持复数，复数由实数部分和虚数部分构成，可以用a + bj,或者complex(a,b)表示， 复数的实部a和虚部b都是浮点型

3.1.2 字符串

Python中的字符串用单引号(‘)或双引号(“)括起来，同时使用反斜杠()转义特殊字符。

字符串截取

字符串的截取的语法格式如下：

变量[头下标:尾下标]

索引值以 0 为开始值，-1 为从末尾的开始位置。
加号 (+) 是字符串的连接符， 星号 (*) 表示复制当前字符串，紧跟的数字为复制的次数。实例如下：

>>> string = 'Hello, Lili. Do you age is 24 ?'
>>> string[:]
'Hello, Lili. Do you age is 24 ?'

# 截取第1个字符以后的字符串
>>> string[1:]
'ello, Lili. Do you age is 24 ?'

# 截取第5个字符以后的字符串
>>> string[5:]
', Lili. Do you age is 24 ?'

# 截取第5至第10个字符以后的字符串
>>> string[5:10]
', Lil'

# 反向截取，截取最后一个
>>> string[-1:]
'?'

# 截取到最后第一个
>>> string[:-1]
'Hello, Lili. Do you age is 24 '

# 截取到最后第5个
>>> string[:-5]
'Hello, Lili. Do you age is'

# 截取到从第五个到最后第5个
>>> string[5:-5]
', Lili. Do you age is'

# 步进截取，步数是最后一个
>>> num = '1234567890'
>>> num[2:6:2]
'35'

字符串判断

# 测试实例一
print("测试实例一")
str = "Hello World"
print(str.isalnum()) # 判断所有字符都是数字或者字母
print(str.isalpha()) # 判断所有字符都是字母
print(str.isdigit()) # 判断所有字符都是数字
print(str.islower()) # 判断所有字符都是小写
print(str.isupper()) # 判断所有字符都是大写
print(str.istitle()) # 判断所有单词都是首字母大写，像标题
print(str.isspace()) # 判断所有字符都是空白字符、\t、\n、\r

字符存在性与索引

>>> '1' in 'test 1234'  # 判断是否存在
True
>>> 'test 1234'.index('1')  # 获取在字符串中的位置
5
>>> 'test 1234'.index('t')  # 获取位置，但是是第一个匹配的位置
0

字符串拼接

注意：字符串的拼接只能是双方都是字符串，不能跟数字或其它类型拼接单双引号

字符串拼接运算：相加，相乘
字符串加法

>>> 'welcome' + ', ' + 'Lily'
'welcome, Lily'

字符串乘法
如下：

>>> test = 'ha'
>>> test * 10
'hahahahahahahahahaha'
>>> test = 'ha '
>>> test * 10
'ha ha ha ha ha ha ha ha ha ha '

字符串大小写转换

>>> test = 'hello'
>>> test.upper()  # 全部转换为大写
'HELLO'
>>> test.title()  # 首字母大写
'Hello'
>>> test = 'HeLLo' # 全部转换为小写
>>> test.lower()
'hello'
>>> test.title() # 首字母大写
'Hello'

3.1.3 布尔型

在Python中，None、任何数值类型中的0、空字符串“”、空元组()、空列表[]、空字典{}都被当作False，还有自定义类型，如果实现了nonzero()或len()方法且方法返回0或False，则其实例也被当作False，其他对象均为True
布尔值和布尔代数的表示完全一致，一个布尔值只有True、False两种值，要么是True，要么是False，在Python中，可以直接用True、False表示布尔值（请注意大小写），也可以通过布尔运算计算出来：
复制代码 代码如下:

>>> True
True
>>> False
False
>>> 3 > 2
True
>>> 3 > 5

False布尔值还可以用and、or和not运算。
1).and运算是与运算，只有所有都为True，and运算结果才是True：
复制代码 代码如下:

>>> True and True
True
>>> True and False
False
>>> False and False
>False

2).or运算是或运算，只要其中有一个为True，or运算结果就是True：
复制代码 代码如下:

>>> True or True
True
>>> True or False
True
>>> False or False
False

3).not运算是非运算，它是一个单目运算符，把True变成False，False变成True：
复制代码 代码如下:

>>> not True
False
>>> not False
True

4).布尔值经常用在条件判断中，比如：
复制代码 代码如下:

if age >= 18:
    print 'adult'
else:
    print 'teenager'

3.1.4 运算符

算数运算

比较运算

赋值运算

逻辑运算

3.2 数据集

3.2.1 列表

List（列表） 是 Python 中使用最频繁的数据类型。

列表可以完成大多数集合类的数据结构实现。列表中元素的类型可以不相同，它支持数字，字符串甚至可以包含列表（所谓嵌套）。

列表是写在方括号([])之间、用逗号分隔开的元素列表。

和字符串一样，列表同样可以被索引和截取，列表被截取后返回一个包含所需元素的新列表。

列表截取的语法格式如下：

变量[头下标:尾下标]

索引值以 0 为开始值，-1 为从末尾的开始位置。

加号（+）是列表连接运算符，星号（*）是重复操作。如下实例：
实例

#!/usr/bin/python3

list = [ 'abcd', 786 , 2.23, 'hello', 70.2 ]
tinylist = [123, 'hello']

print (list)            # 输出完整列表
print (list[0])         # 输出列表第一个元素
print (list[1:3])       # 从第二个开始输出到第三个元素
print (list[2:])        # 输出从第三个元素开始的所有元素
print (tinylist * 2)    # 输出两次列表
print (list + tinylist) # 连接列表

以上实例输出结果：

['abcd', 786, 2.23, 'hello', 70.2]
abcd
[786, 2.23]
[2.23, 'hello', 70.2]
[123, 'hello', 123, 'hello']
['abcd', 786, 2.23, 'hello', 70.2, 123, 'hello']

与Python字符串不一样的是，列表中的元素是可以改变的：
实例

>>>a = [1, 2, 3, 4, 5, 6]
>>> a[0] = 9
>>> a[2:5] = [13, 14, 15]
>>> a
[9, 2, 13, 14, 15, 6]
>>> a[2:5] = []   # 将对应的元素值设置为 [] 
>>> a
[9, 2, 6]

删除元素

>>> test = [1, 'test', 'abc', '123', 'xyz']
>>> test.pop()  # 删除最后一个元素，并显示这个元素
'xyz'
>>> test
[1, 'test', 'abc', '123']
>>> del test[-1] # 删除最后一个元素
>>> test
[1, 'test', 'abc']
>>> del test[0]  # 删除指定位置元素
>>> test
['test', 'abc']

>>> test
[1, 'test', '456', 'abc', '123', 'xyz', 'haha', '123', 123]
>>> test.remove('123')  # 删除指定元素
>>> test
[1, 'test', '456', 'abc', 'xyz', 'haha', '123', 123]

追加 append

>>> test = [1, 'test', 'abc', '123', 'xyz']
>>> test.append('haha')
>>> test
[1, 'test', 'abc', '123', 'xyz', 'haha']

插入 insert

>>> test
[1, 'test', 'abc', '123', 'xyz', 'haha']
>>> test.insert(2, '456')  #第三个位置插入'456'
>>> test
[1, 'test', '456', 'abc', '123', 'xyz', 'haha']

列表相加

>>> test
[1, 'test', 'abc', '123', 'xyz', 'haha']
>>> test1 = ['name', 'age']
>>> test + test1
[1, 'test', 'abc', '123', 'xyz', 'haha', 'name', 'age']

列表元素计数

>>> test
[1, 'test', '456', 'abc', '123', 'xyz', 'haha']
>>> test.append('123')
>>> test
[1, 'test', '456', 'abc', '123', 'xyz', 'haha', '123']
>>> test.count('123')
2
>>> test.append(123)
>>> test.count('123')
2
>>> test
[1, 'test', '456', 'abc', '123', 'xyz', 'haha', '123', 123]

排序

# 字符串和数字都有，就会报错
>>> test
[1, 'test', '456', 'abc', 'xyz', 'haha', '123', 123]
>>> test.sort()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unorderable types: str() < int()
# 全部是数字
>>> test = [123, 789, 100, 0, -100]
>>> test.sort()
>>> test
[-100, 0, 100, 123, 789] 
# 全部是字符串
>>> test = ['abc', 'axy', 'haha', 'test']
>>> test.sort()
>>> test
['abc', 'axy', 'haha', 'test']

列表元素反转

>>> test
['abc', 'axy', 'haha', 'test']
>>> test.reverse()
>>> test
['test', 'haha', 'axy', 'abc']

扩展

>>> test
['test', 'haha', 'axy', 'abc']
>>> test.extend(['123', '456'])
>>> test
['test', 'haha', 'axy', 'abc', '123', '456']

清空元素

test.clear()

3.2.2 Tuple（元组）

元组（tuple）与列表类似，不同之处在于元组的元素不能修改。元组写在小括号(())里，元素之间用逗号隔开。

元组中的元素类型也可以不相同：
实例

#!/usr/bin/python3

tuple = ( 'abcd', 786 , 2.23, 'hello', 70.2  )
tinytuple = (123, 'hello')

print (tuple)             # 输出完整元组
print (tuple[0])          # 输出元组的第一个元素
print (tuple[1:3])        # 输出从第二个元素开始到第三个元素
print (tuple[2:])         # 输出从第三个元素开始的所有元素
print (tinytuple * 2)     # 输出两次元组
print (tuple + tinytuple) # 连接元组

以上实例输出结果：

('abcd', 786, 2.23, 'hello', 70.2)
abcd
(786, 2.23)
(2.23, 'hello', 70.2)
(123, 'hello', 123, 'hello')
('abcd', 786, 2.23, 'hello', 70.2, 123, 'hello')

元组与字符串类似，可以被索引且下标索引从0开始，-1 为从末尾开始的位置。也可以进行截取（看上面，这里不再赘述）。

其实，可以把字符串看作一种特殊的元组。
实例

>>>tup = (1, 2, 3, 4, 5, 6)
>>> print(tup[0])
1
>>> print(tup[1:5])
(2, 3, 4, 5)
>>> tup[0] = 11  # 修改元组元素的操作是非法的
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment
>>>

虽然tuple的元素不可改变，但它可以包含可变的对象，比如list列表。

构造包含 0 个或 1 个元素的元组比较特殊，所以有一些额外的语法规则：

tup1 = ()    # 空元组
tup2 = (20,) # 一个元素，需要在元素后添加逗号

string、list和tuple都属于sequence（序列）。

注意：

1、与字符串一样，元组的元素不能修改。
2、元组也可以被索引和切片，方法一样。
3、注意构造包含0或1个元素的元组的特殊语法规则。
4、元组也可以使用+操作符进行拼接。

3.2.3 Set（集合）

集合（set）是一个无序不重复元素的序列。

基本功能是进行成员关系测试和删除重复元素。

可以使用大括号 { } 或者 set() 函数创建集合

注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。

创建格式：

parame = {value01,value02,...}
或者
set(value)

实例

#!/usr/bin/python3
student = {'Tom', 'Jim', 'Mary', 'Tom', 'Jack', 'Rose'}
print(student)   # 输出集合，重复的元素被自动去掉

# 成员测试
if('Rose' in student) :
    print('Rose 在集合中')
else :
    print('Rose 不在集合中')

# set可以进行集合运算
a = set('abracadabra')
b = set('alacazam')

print(a)
print(a - b)     # a和b的差集
print(a | b)     # a和b的并集
print(a & b)     # a和b的交集
print(a ^ b)     # a和b中不同时存在的元素

以上实例输出结果：

{'Mary', 'Jim', 'Rose', 'Jack', 'Tom'}
Rose 在集合中
{'b', 'a', 'c', 'r', 'd'}
{'b', 'd', 'r'}
{'l', 'r', 'a', 'c', 'z', 'm', 'b', 'd'}
{'a', 'c'}
{'l', 'r', 'z', 'm', 'b', 'd'}

3.2.4 字典Dict

字典（dictionary）是Python中另一个非常有用的内置数据类型。

列表是有序的对象集合，字典是无序的对象集合。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。

字典是一种映射类型，字典用”{ }”标识，它是一个无序的键(key) : 值(value)对集合。

键(key)必须使用不可变类型。

在同一个字典中，键(key)必须是唯一的。
实例

#!/usr/bin/python3

dict = {}
dict['address'] = "Beijing"
dict[2]     = "shanghai"

tinydict = {'name': 'zpf','code':1, 'site': 'www.baidu.com'}


print (dict['address'])   # 输出键为 'one' 的值
print (dict[2])           # 输出键为 2 的值
print (tinydict)          # 输出完整的字典
print (tinydict.keys())   # 输出所有键
print (tinydict.values()) # 输出所有值

以上实例输出结果：

Beijing
shanghai
{'name': 'zpf', 'site': 'www.baidu.com', 'code': 1}
dict_keys(['name', 'site', 'code'])
dict_values(['runoob', 'www.runoob.com', 1])

构造函数 dict() 可以直接从键值对序列中构建字典如下：
实例

>>>dict([('baidu', 1), ('Google', 2), ('Taobao', 3)])
{'Taobao': 3, 'baidu': 1, 'Google': 2}

>>> {x: x**2 for x in (2, 4, 6)}
{2: 4, 4: 16, 6: 36}

>>> dict(baidu=1, Google=2, Taobao=3)
{'Taobao': 3, 'baidu': 1, 'Google': 2}

另外，字典类型也有一些内置的函数，例如clear()、keys()、values()等。

注意：

1、字典是一种映射类型，它的元素是键值对。
2、字典的关键字必须为不可变类型，且不能重复。
3、创建空字典使用 { }。