《Python 1》--python的简介、解释器、读取键盘输入函数、变量类型推断、5个标准数据类型、字符串的内置函数、for循环、list列表、tuple元组、字典dictionary

Python 的起源：

Python 的创始人为吉多·范罗苏姆（Guido van Rossum）
1. 1989 年的圣诞节期间，吉多·范罗苏姆为了在阿姆斯特丹打发时间，决心开发一个新的**解释程序**，
   作为 ABC 语言的一种继承
2. ABC 是由吉多参加设计的一种教学语言，就吉多本人看来，ABC 这种语言非常优美和强大，
   是专门为非专业程序员设计的。但是 ABC 语言并没有成功，究其原因，吉多认为是非开放造成的。
   吉多决心在 Python 中避免这一错误，并获取了非常好的效果
3. 之所以选中 Python（蟒蛇） 作为程序的名字，
   是因为他是 BBC 电视剧——蒙提·派森的飞行马戏团的爱好者
4. 1991 年，第一个 Python **解释器** 诞生，它是用 C 语言实现的，
   并能够调用 C 语言的库文件

解释器： 

**计算机不能直接理解任何除机器语言以外的语言**，
所以必须要把程序员所写的程序语言翻译成机器语言，计算机才能执行程序。
**将其他语言翻译成机器语言的工具，被称为编译器**

编译器翻译的方式有两种：
一个是**编译**，另外一个是**解释**。
两种方式之间的区别在于**翻译时间点的不同**。
当编译器**以解释方式运行的时候**，也称之为**解释器**

* **编译型语言**：
程序在执行之前需要一个专门的编译过程，把程序一次性编译成为机器语言的文件，
运行时不需要重新翻译，直接使用编译的结果就行了。
程序执行效率高，依赖编译器，跨平台性差些。如 C、C++

* **解释型语言**：
解释型语言编写的程序不进行预先编译，以文本方式存储程序代码，
会将代码翻译一行解释一行。在发布程序时，看起来省了道编译工序，
但是在运行程序的时候，必须先解释再运行(解释一行执行一行)

#### 编译型语言和解释型语言对比

* **速度**       —— 编译型语言比解释型语言执行速度快
* **跨平台性**   —— 解释型语言比编译型语言跨平台性好

■Python解释器

 当我们编写Python代码时，我们得到的是一个包含Python代码的以.py为扩展名的文本文件。
要运行代码，就需要Python解释器去执行.py文件。
由于整个Python语言从规范到解释器都是开源的，所以理论上，只要水平够高，
任何人都可以编写Python解释器来执行Python代码（当然难度很大）。
事实上，确实存在多种Python解释器。

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

IPython(table补全)
IPython是基于CPython之上的一个交互式解释器，也就是说，IPython只是在交互
方式上有所增强，但是执行IPython代码的功能和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的字节码。

小结
Python的解释器很多，但使用最广泛的还是CPython。如果要和Java或.Net平台交互，
最好的办法不是用Jython或IronPython，而是通过网络调用来交互，确保各程序之间的独立性。

■Python 特点

1.易于学习：Python有相对较少的关键字，结构简单，和一个明确定义的语法，学习起来更加简单。

2.易于阅读：Python代码定义的更清晰。

3.易于维护：Python的成功在于它的源代码是相当容易维护的。

4.一个广泛的标准库：Python的最大的优势之一是丰富的库，跨平台的，在UNIX，Windows和Macintosh兼容很好。

5.互动模式：互动模式的支持，您可以从终端输入执行代码并获得结果的语言，互动的测试和调试代码片断。

6.可移植：基于其开放源代码的特性，Python已经被移植（也就是使其工作）到许多平台。

7.可扩展：如果你需要一段运行很快的关键代码，或者是想要编写一些不愿开放的算法，你可以使用C或C++完成那部分程序，然后从你的Python程序中调用。

8.数据库：Python提供所有主要的商业数据库的接口。

9.GUI编程：Python支持GUI可以创建和移植到许多系统调用。

10.可嵌入: 你可以将Python嵌入到C/C++程序，让你的程序的用户获得"脚本化"的能力。

执行python程序的三种方式

1)解释器         --python/python3        [python hello.py]
2)交互式         --ipython               [python的shell中输入执行]
3)集成开发环境   --pyCharm

安装python2.7 python3.6
我们需要将python路径加入path中。
右键单击 【计算机】，选择菜单属性命令，在弹出的对话框中选择 【高级系统设置】 标签，选择 高级 标签，
然后点击 环境变量 按钮。选中【系统变量】中的“path”选项，单击【编辑】按钮，将弹出如下图所示的对话框。
在【变量值】文本框中的末尾添加“;D:\Python27”（这里是你的安装路径），单击【确定】按钮。
D:\Python27
D:\Programs\Python\Python36-32

cmd运行--》python所见即所得

python 2.7 版本下运行python程序
——————————————————————
第一个python程序 D:helloword.py
如下注释用于指定解释器

#! /usr/bin/python
print "hello python!!!"

 

-->cmd python是解释型语言，直接通过解释器执行
D:\>python helloword.py

 
■可移植特点:linux下运行windows下的py程序

[hyxy@master Desktop]$ cd /mnt/hgfs/工具/
[hyxy@master 工具]$ cp helloword.py ~/tmp/

[hyxy@master tmp]$ cd ~/tmp/
[hyxy@master tmp]$ ls
dfs  hadoop-hyxy-jornalnode.pid  helloword.py  hive  nm-local-dir  zookeeper

[hyxy@master tmp]$ python helloword.py 
hello word!!

注释

1 无论是行注释还是段注释，均以#加一个空格来注释。
   #我是单行注释

   """我是多行注释，可以写很多很多行的功能说明 

       哈哈哈。。。
   """

2 Python 中文编码
前面章节中我们已经学会了如何用 Python 输出 "Hello, World!"，英文没有问题，
但是如果你输出中文字符"你好，世界"就有可能会碰到中文编码问题。
【Python2.X 解释器不支持中文             python3支持】

#!/usr/bin/python
print "你好，世界";
以上程序执行输出结果为：

  File "test.py", line 2
SyntaxError: Non-ASCII character '\xe4' in file test.py on line 2, but no encoding declared; see http://www.python.org/peps/pep-0263.html for details
Python中默认的编码格式是 ASCII 格式，在没修改编码格式时无法正确打印汉字，所以在读取中文时会报错。

解决方法为只要在文件开头加入 # -*- coding: UTF-8 -*- 或者 #coding=utf-8 

注意：#coding=utf-8 的 = 号两边不要空格。

实例(Python 2.0+)
#!/usr/bin/python
# -*- coding: UTF-8 -*-
 
print "你好，世界";

注意：Python3.X 源码文件默认使用utf-8编码，所以可以正常解析中文，无需指定 UTF-8 编码。

注意：如果你使用编辑器，同时需要设置 py 文件存储的格式为 UTF-8，否则会出现类似以下错误信息：
SyntaxError: (unicode error) ‘utf-8’ codec can’t decode byte 0xc4 in position 0:
invalid continuation byte

将【#!/usr/bin/python # -*- coding: UTF-8 -*- 设置到pycharm中】
#!/usr/bin/python       liunx下python安装路径
# -*- coding: UTF-8 -*- 

■python2:

例1：读取键盘输入

Python提供了两个内置函数从标准输入读入一行文本，默认的标准输入是键盘。
如下：
【raw_input 、input】
1）raw_input函数
raw_input([prompt]) 函数从标准输入读取一个行，并返回一个字符串（去掉结尾的换行符）

#!/usr/bin/python
# -*- coding: UTF-8 -*-

str = raw_input("请输入：")
print "你输入的内容是: ", str

■python3:
2）input函数
input([prompt]) 函数和 raw_input([prompt]) 函数基本类似，
但是 input 可以接收一个Python表达式作为输入，并将运算结果返回。
#!/usr/bin/python
# -*- coding: UTF-8 -*-

str = input("请输入：")
print(你输入的内容是: ", str) 

****python3的输出要加小括号 例如: print('hello world')

■例2：Python 变量类型
变量存储在内存中的值。这就意味着在创建变量时会在内存中开辟一个空间。

基于变量的数据类型，解释器会分配指定内存，并决定什么数据可以被存储在内存中。

因此，变量可以指定不同的数据类型，这些变量可以存储整数，小数或字符。

Python 中的变量赋值不需要类型声明(类型推断) 

每个变量在内存中创建，都包括变量的标识，名称和数据这些信息。

每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建。

等号（=）用来给变量赋值。

等号（=）运算符左边是一个变量名,等号（=）运算符右边是存储在变量中的值。

例如：
counter = 100  # 赋值整型变量
floatnumber = 1000.0  # 浮点型
name = "John"  # 字符串

print(counter)
print(floatnumber)
print(name)

>>> type(counter)        -->  
>>> type(floatnumber)    -->    
>>> type(name)           -->  

Boolean类型 True=1  Flase=0
>>> i=True
>>> print(i)
True
>>> j=2
>>> i+j
3

>>> k=False
>>> j+k
2
>>> k
False
>>> j
2

■课堂练习：求两个数相加之和，控制台输入两个数后，展示两个数相加的结果
python2:
# -*- coding: UTF-8 -*-
num1 = raw_input("请输入第一个数")
num2 = raw_input("请输入第二个数")
result = int(num1) + int(num2)
print "两个数相加的结果为:" ,result

python3:
num1 = input("请输入第一个数")
num2 = input("请输入第二个数")

>>> print(num1+num2)
1020

result = int(num1) + int(num2)
print("两个数相加的结果为:",result)

多个变量赋值
Python允许你同时为多个变量赋值

a = b = c = 1

print a
print b
print c

__________________________________

a, b, c = 1, 2, "john"

print a
print b
print c

type(a)
type(b)
type(c)

■Python空行

函数之间或类的方法之间用空行分隔，表示一段新的代码的开始。
类和函数入口之间也用一行空行分隔，以突出函数入口的开始。

空行与代码缩进不同，空行并不是Python语法的一部分。书写时不插入空行，
Python解释器运行也不会出错。但是空行的作用在于分隔两段不同功能或含义的代码，便于日后代码的维护或重构。

记住：空行也是程序代码的一部分。

■同一行显示多条语句
Python可以在同一行中使用多条语句，语句之间使用分号(;)分割，
以下是一个简单的实例：

#!/usr/bin/python 
x = 'helloword'; print(x)

执行以上代码，输入结果为： helloword

■Print 输出
print 默认输出是换行的，如果要实现不换行需要在变量末尾加上逗号 ,
python2:
#!/usr/bin/python
# -*- coding: UTF-8 -*-

x="a"
y="b"
# 换行输出
print x
print y

print '---------'
# 不换行输出
print x,
print y,

# 不换行输出
print x,y
以上实例执行结果为：

a
b
---------
a b  
——————————————————————————————————
python3:
# -*- coding: UTF-8 -*-
x="a"
y="b"
# 换行输出
print(x)
print(y)

print('---------')
# 不换行输出
print(x,y)

IDE（集成开发环境)-->pyCharm

一般包括以下工具：
        图形用户界面
        代码编译器（支持代码补全/自动缩进）
        编译器/解释器
        调试器（断点/单步执行）

PyCharm介绍
pyCharm是python的一款非常优秀的集成开发环境
pyCharm除了具有一般IDE所必备功能外，还可以在winodws、Linux、macOs下使用
pyCharm适合开发大型项目

■标准数据类型(数据类型.png)
在内存中存储的数据可以有多种类型。

例如，一个人的年龄可以用数字来存储，他的名字可以用字符来存储。

Python 定义了一些标准类型，用于存储各种类型的数据。

Python有五个标准的数据类型：

■1.Numbers（数字类型）
■2.String（字符串） 
■3.List（列表）
■4.Tuple（元组）
■5.Dictionary（字典）

■1.Python数字_Numbers（数字）
数字数据类型用于存储数值。

他们是不可改变的数据类型，这意味着改变数字数据类型会分配一个新的对象。
当你指定一个值时，Number对象就会被创建：

var1 = 1
var2 = 10
可以使用del语句删除一些对象的引用。

del语句的语法是：
del var1[,var2[,var3[....,varN]]]]
您可以通过使用del语句删除单个或多个对象的引用。例如：

del var
del var_a, var_b

Python支持四种不同的数字类型：

数字类型：int整型、float浮点型、long长整型、complex复数（复数 一个数字有两部分内容组成）

不需要指定类型（解释型语言）
bool：布尔   True和False（1是 true；0 是 false）
num = 1
b=False
print num + b
print type(b)

字符串拼接
str1 = "hello"
str2="word"
print str1 + str2

str1 = "hello"
str2="word"*3
print str1 + str2

类型转换:
int(其它类型）
float(其它类型） 

字符串和数字相加
num = 1
string = '1'
num2 = int(string)
print num + num2

获得变量是什么类型

type(变量名)

 

■Python 字符串
字符串是 Python 中最常用的数据类型。我们可以使用引号('或")来创建字符串。

创建字符串很简单，只要为变量分配一个值即可。
例如：

var1 = 'Hello World!'
var2 = "Hello Python!"

■Python访问字符串中的值
Python不支持单字符类型，单字符在 Python 中也是作为一个字符串使用。

Python访问子字符串，可以使用方括号来截取字符串，如下实例：

var = 'hello World!'
var1 ="heloo Python!"
print "var [6]: ",var[6]
print "var1[2:5]+aaa:",var1[2:5]+"aaa"
print "var [2:]: ",var[2:]
print "var [:]: " ,var[:]
print "var1:",var1

■内置函数-字符串
D:\8.python\课堂\课件\03-内置函数-字符串-列表\字符串.html

#查找字符串以“1he”开头，如果不存在返回False
str="heloo 123"
print str.startswith("1he")

#查找字符串以“123”结尾，如果不存在返回False
str="heloo 123"
print str.endswith("123")

#find方法返回查找字符串所在的下标，从0开始，如果不存在返回-1
str="heloo 123"
print str.find("2")

#index方法返回查找字符串所在的下标，从0开始，如果不存在抛出异常
str="heloo 123"
print str.index("p")

#replace方法执行完成后会返回一个新的字符串,不会修改原有字符串的内容
str="heloo 123"
str1 = str.replace("123","456")
print str
print str1

str=" heloo 123 "

#去除左右两边空格
print str.strip()

#去除右边空格
print str.rstrip()

#去除左边空格
print str.lstrip()

运行结果:
heloo 123
 heloo 123
heloo 123 

#拆分字符串返回列表，split拆分空格或\t
str="hello 123 hello 456\tdd"
list=str.split()
print(list)
['hello', '123', 'hello', '456', 'dd']

#调用获取最大值函数和最小值函数
str="2569782"
print max(str)
print min(str)

 

完整的for循环语法 

for 变量  in 集合:
    循环体代码

else：
    没有通过break退出循环,循环结束会执行此行

案例1:
# -*- coding: UTF-8 -*-
for num in [1,2,3] :
    print(num)
else:
    print("会执行吗?")

案例2:
# -*- coding: UTF-8 -*-
for num in [1,2,3] :
    if num == 2:
        break
    print(num)
else:
    print("会执行吗?")

■3.Python列表_List（列表）____参照Python列表截取.jpg

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

列表可以完成大多数集合类的数据结构实现
它支持字符，数字，字符串甚至可以包含列表（即嵌套）

列表用 [ ] 标识，是 python 最通用的复合数据类型

列表中值的切割也可以用到变量 [头下标:尾下标] ，就可以截取相应的列表，
从左到右索引默认 0 开始，
从右到左索引默认 -1 开始，下标可以为空表示取到头或尾

#!/usr/bin/python
# -*- coding: UTF-8 -*-
 
list = [ 'runoob', 786 , 2.23, 'john', 70.2 ]
tinylist = [123, 'john']
 
print list                   # 输出完整列表
print list[0]              # 输出列表的第一个元素
print list[1:3]           # 输出第二个至第三个元素 
print list[2:]             # 输出从第三个开始至列表末尾的所有元素
print tinylist * 2       # 输出列表两次
print list + tinylist    # 打印组合的列表

实例输出结果：
['runoob', 786, 2.23, 'john', 70.2]
runoob
[786, 2.23]
[2.23, 'john', 70.2]
[123, 'john', 123, 'john']
['runoob', 786, 2.23, 'john', 70.2, 123, 'john']

#append()在列表的末尾添加数据
list = []              ## 空列表
list.append('Hello')   ## 使用 append() 添加元素
list.append('Word')
print list

以上实例输出结果：
['Hello', 'Word']

#insert()方法在指定位置插入数据
list.insert(2,'hello')

#extend 方法可以把其他列表中的完整内容，追加到当前列表的末尾
list = [ 'runoob', 786 , 2.23, 'john', 70.2 ]
list1 = [ 'aaa',333 ]
list.extend(list1)
print list

Python列表截取 

>>>L = ['Google', 'Runoob', 'Taobao']
>>> L[2]
'Taobao'
>>> L[-2]
'Runoob'
>>> L[1:]
['Runoob', 'Taobao'] 

Python表达式        结果                                  描述
L[2]                    'Taobao'                    读取列表中第三个元素
L[-2]                   'Runoob'                    读取列表中倒数第二个元素
L[1:]           ['Runoob', 'Taobao']        从第二个元素开始截取列表

#删除列表元素 可以使用 del 语句来删除列表的元素(指定index)
list1 = ['physics', 'chemistry', 1997, 2000]
 
print list1
del list1[2]
print "After deleting value at index 2 : "
print list1

以上实例输出结果：
['physics', 'chemistry', 1997, 2000]
After deleting value at index 2 :
['physics', 'chemistry', 2000]

#remove()方法删除指定元素
list = [ 'runoob', 786 , 2.23, 'john', 70.2 ]
list.remove('runoob')
print list

#升序
list.sort()

#降序
list.sort(reverse=True)

#逆序
list.reverse()

■列表元素的常用删除方法有：
del：根据下标进行删除 
remove：根据元素的值进行删除

例1：del：根据下标进行删除
#!/usr/bin/python
# -*- coding: UTF-8 -*-
# 待查找的列表
movieName = ['加勒比海盗','骇客帝国','第一滴血','指环王','霍比特人','速度与激情']

print '------删除之前------'
for tempName in movieName:
    print tempName

del movieName[2]

print '------删除之后------'
for tempName in movieName:
    print tempName

例2：pop：删除最后一个元素
要删除指定位置的元素，用pop(i)方法，其中i是索引位置
pop(1)

#!/usr/bin/python
# -*- coding: UTF-8 -*-
# 待查找的列表
movieName = ['加勒比海盗','奥特曼','第一滴血','指环王','霍比特人','速度与激情']

print '------删除之前------'
for tempName in movieName:
    print tempName

movieName.pop()

print '------删除之后------'
for tempName in movieName:
    print tempName

例3：remove：根据元素的值进行删除
#!/usr/bin/python
# -*- coding: UTF-8 -*-
# 待查找的列表
movieName = ['加勒比海盗','奥特曼','第一滴血','指环王','霍比特人','速度与激情']

print '------删除之前------'
for tempName in movieName:
    print tempName

movieName.remove('指环王')

print '------删除之后------'
for tempName in movieName:
    print tempName

#清空列表中的数据，python3
list.clear()

python2
AttributeError: 'list' object has no attribute 'clear'

■列表 函数                  描述
len(list)                   列表元素个数
max(list)                 返回列表元素最大值
min(list)                  返回列表元素最小值
list(元组)                 将元组转换为列表

例:返回列表元素最大值
list1 = [500, 123, 1997, 2000]
max_l = max(list1)
print max_l

请用索引取出下面list的指定元素：
L = [
    ['Apple', 'Google', 'Microsoft'],
    ['Java', 'Python', 'Ruby', 'PHP'],
    ['Adam', 'Bart', 'Lisa']
]
# 打印Apple:
print(?)
# 打印Python:
print(?)
# 打印Lisa:
print(?)

L[0][0]
L[1][1]
L[2][2]

■4.Python元组

元组是另一个数据类型，类似于List（列表）。
元组用"()"标识。内部元素用逗号隔开。但是元组不能二次赋值，相当于只读列表。

tuple = ('runoob', 786 , 2.23, 'john', 70.2 )
tinytuple = (123, 'john')
 
print tuple                       # 输出完整元组
print tuple[0]                  # 输出元组的第一个元素
print tuple[1:3]               # 输出第二个至第三个的元素 
print tuple[2:]                 # 输出从第三个开始至列表末尾的所有元素
print tinytuple * 2          # 输出元组两次
print tuple + tinytuple   # 打印组合的元组

实例输出结果：
('runoob', 786, 2.23, 'john', 70.2)
runoob
(786, 2.23)
(2.23, 'john', 70.2)
(123, 'john', 123, 'john')
('runoob', 786, 2.23, 'john', 70.2, 123, 'john')

■以下是元组无效的，因为元组是不允许更新的。而列表是允许更新的：
tuple = ( 'runoob', 786 , 2.23, 'john', 70.2 )
list = [ 'runoob', 786 , 2.23, 'john', 70.2 ]
tuple[2] = 1000     # 元组中是非法应用
list[2] = 1000        # 列表中是合法应用

print tuple
print list

■创建新元组
tup1 = (12, 34.56)
tup2 = ('abc', 'xyz')
 
 
# 创建一个新的元组
tup3 = tup1 + tup2
print tup3

■删除元组
元组中的元素值是不允许删除的，但我们可以使用del语句来删除整个元组，如下实例:

 
#!/usr/bin/python
 
tup = ('physics', 'chemistry', 1997, 2000)
 
print tup
del tup
print "After deleting tup : "
print tup
以上实例元组被删除后，输出变量会有异常信息，输出如下所示：

('physics', 'chemistry', 1997, 2000)
After deleting tup :
Traceback (most recent call last):
  File "test.py", line 9, in
    print tup
NameError: name 'tup' is not defined

■元组索引，截取
因为元组也是一个序列，所以我们可以访问元组中的指定位置的元素，
也可以截取索引中的一段元素

L = ('spam', 'Spam', 'SPAM!')
Python 表达式           结果                              描述
L[2]                        'SPAM!'                       读取第三个元素
L[-2]                       'Spam'                       反向读取，读取倒数第二个元素
L[1:]                      ('Spam', 'SPAM!')       截取元素
L[-2:]                      ('Spam', 'SPAM!')      反向读取，读取倒数第二个元，素截 

list = ('225',22,11,'aa',11,11)
print list.index(11) # 2 获得11在元组中的索引（已知元素内容，获得下标)
print list.count(11) # 11在元组中出现的次数

元组—格式字符串

print("%s年龄是%d" %("张三",12))

list = ("zhangsan",18)
print "%s 的年龄是 %d" %list

%s 字符串
%d 有符号十进制整数 %06 ,不足6位用0补全
%f  浮点数  %.02 表示小数点后只显示两位

元组也可以这样定义
a,b,c=1,2,3
print a,b,c

元组内置函数
Python元组包含了以下内置函数

序号    方法                              描述
1    cmp(tuple1, tuple2)   比较两个元组元素。
2    len(tuple)                   计算元组元素个数。
3    max(tuple)                 返回元组中元素最大值。
4    min(tuple)                  返回元组中元素最小值。
5    tuple(列表)                 将列表转换为元组。

元组定义一个元素时:
>>> si=(3)
>>> type(si)

>>> si1=(3,)
>>> type(si1)
 

list--> tuple-->list
>>> n=[1,2,3]
>>> type(n)

>>> t=tuple(n)
>>> type(t)

>>> n=list(t)
>>> type(n)

■5.Python 字典_Dictionary（字典）

dict
Python内置了字典：dict的支持，dict全称dictionary，在其他语言中也称为map，
                  使用键-值（key-value）存储，具有极快的查找速度。

字典是另一种可变容器模型，且可存储任意类型对象。
字典的每个键值 key=>value 对用冒号 : 分割，每个键值对之间用逗号 ,
字典用"{ }"标识。字典由索引(key)和它对应的值value组成。
d = {key1 : value1, key2 : value2 }

字典(dictionary)是除列表以外python之中最灵活的内置数据结构类型。
列表是有序的对象集合，字典是无序的对象集合。
两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。

举个例子，假设要根据同学的名字查找对应的成绩，如果用list实现，
需要两个list：

names = ['Michael', 'Bob', 'Tracy']
scores = [95, 75, 85]
给定一个名字，要查找对应的成绩，就先要在names中找到对应的位置，
再从scores取出对应的成绩，list越长，耗时越长。

如果用dict实现，只需要一个“名字”-“成绩”的对照表，直接根据名字查找成绩，
无论这个表有多大，查找速度都不会变慢。
用Python写一个dict如下：

>>> d = {'Michael': 95, 'Bob': 75, 'Tracy': 85}
>>> d['Michael']
95

dict = {}
dict['one'] = "This is one"
dict[2] = "This is two"
 
tinydict = {'name': 'john','code':6734, 'dept': 'sales'}
 
 
print dict['one']          # 输出键为'one' 的值
print dict[2]              # 输出键为 2 的值
print tinydict             # 输出完整的字典
print tinydict.keys()      # 输出所有键
print tinydict.values()    # 输出所有值

输出结果为：
This is one
This is two
{'dept': 'sales', 'code': 6734, 'name': 'john'}
['dept', 'code', 'name']
['sales', 6734, 'john']

例:
dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'};
 
print "dict['Name']: ", dict['Name'];
print "dict['Age']: ", dict['Age'];

输出结果：

dict['Name']:  Zara
dict['Age']:  7

■修改字典

向字典添加新内容的方法是增加新的键/值对，修改或删除已有键/值对如下实例:

实例
#!/usr/bin/python
 
dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'};
 
dict['Age'] = 8;               # update existing entry
dict['School'] = "DPS School"; # Add new entry
 
 
print "dict['Age']: ", dict['Age'];
print "dict['School']: ", dict['School'];
以上实例输出结果：
dict['Age']:  8
dict['School']:  DPS School

由于一个key只能对应一个value，所以，多次对一个key放入value，
后面的值会把前面的值覆盖掉

>>> d['Jack'] = 90
>>> d['Jack']
90
>>> d['Jack'] = 88
>>> d['Jack']
88

■删除字典元素
能删单一的元素也能清空字典，清空只需一项操作。

显式删除一个字典用del命令，如下实例：
dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'};
 
del dict['Name']; # 删除键是'Name'的条目
#dict.clear();     # 清空词典所有条目
#del dict ;        # 删除词典
 
print "dict['Age']: ", dict['Age'];
#print "dict['School']: ", dict['School'];
如果删除字典,会引发一个异常，因为用del后字典不再存在：

dict['Age']:
Traceback (most recent call last):
  File "test.py", line 8, in
    print "dict['Age']: ", dict['Age'];
TypeError: 'type' object is unsubscriptable

■字典键的特性

字典值可以没有限制地取任何python对象，既可以是标准的对象，
也可以是用户定义的，但键不行。

两个重要的点需要记住：

1）不允许同一个键出现两次。创建时如果同一个键被赋值两次，后一个值会被记住，
如下实例：

实例
#!/usr/bin/python
 
dict = {'Name': 'Zara', 'Age': 7, 'Name': 'Manni'};
 
print "dict['Name']: ", dict['Name'];
以上实例输出结果：

dict['Name']:  Manni

2）键必须不可变，所以可以用数字，字符串或元组充当，所以用列表就不行，
如下实例：

实例
#!/usr/bin/python
 
dict = {['Name']: 'Zara', 'Age': 7};
 
print "dict['Name']: ", dict['Name'];
以上实例输出结果：

Traceback (most recent call last):
  File "test.py", line 3, in
    dict = {['Name']: 'Zara', 'Age': 7};
TypeError: list objects are unhashable

合并字典 :
list = {"zhangsan":18,"zhangsan1":17}
list1 = {"zhangsan2":19,"zhangsan":20}
list.update(list1)
print list

注意重复的key会覆盖值（被合并的字典中会覆盖之前字典相同key的value)

清空字典：
list = {"zhangsan":18,"zhangsan1":17} 
list.clear()
print list

遍历字典：
list = {"zhangsan ":18,"zhangsan1":17,"zhangsan2":19}
for l in list:
    print "key:",l ,"   ", "value",list.get(l)

■字典内置函数&方法

Python字典包含了以下内置函数：

序号    函数及描述
1    cmp(dict1, dict2) 比较两个字典元素（python3取消了这个函数)。
2    len(dict)         计算字典元素个数，即键的总数。
3    str(dict)         输出字典可打印的字符串表示。
4    type(variable)    返回输入的变量类型，如果变量是字典就返回字典类型。

■说明：
字典和列表一样，也能够存储多个数据
列表是有序的对象集合
字典是无序的对象集合(输出结果无序)
列表中找某个元素时，是根据下标进行的
字典中找某个元素时，是根据'名字' 就是冒号:前面的那个值，来获取值

tuple是不可变元组，请说出此题运行结果???
t = ('a','b',['c','d'])
#t[0]='k'
t[2][0]='k'
t[2][1]='m'
print t