Python 能做什么？
Python 是一门综合性的语言，你几乎能在计算机上通过 Python 做任何事情，以下是 Python
应该最广泛的几个方面：
1. 网络应用：包括 web 网站 、服务器后台服务等，在这方面 Python 有优秀的 web 框架 如 Django\Tornado\Flask 等，网络服务框架有著名的 Twisted,异步通信有牛 X 的eventlet.
2. 科学运算：随着 NumPy、SciPy、matplotlib、ETS 等众多程序库的开发，Python 越来 越适合于做科学计算。与科学计算领域最流行的商业软件 MATLAB 相比，Python 是一 门真正的通用程序设计语言，比 MATLAB 所采用的脚本语言的应用范围更广泛，有更 多程序库的支持，适用于 Windows 和 Linux 等多种平台，完全免费并且开放源码。虽 然 MATLAB 中的某些高级功能目前还无法替代，但是对于基础性、前瞻性的科研工作 和应用系统的开发，完全可以用 Python 来完成。
3. GUI 程序：python 提供了多个图形开发界面的库，包括 PyQt,WxPython,自带的有 Tkinter,
这些库允许 Python 程序员很方便的创建完整的、功能健全的 GUI 用户界面。
4. 系统管理工具：Python 可以是做运维人员最喜欢用的语言了，可以用它来轻松的开发 自动化管理工具、监控程序等，事实上现在很多开源软件也都是用 Python 开发的，如 用于 IT 配置管理的 SaltStack\Ansible, 做虚拟化的 OpenStack,做备份用的 Bacula 等。
5. 其它程序：你知道吗？Python 用来写爬虫也是很拿手的，还有做游戏，之前看社区里 有个哥们花了不到 300 行代码就实现了《愤怒的小鸟》的游戏，还可以用来做嵌入式开 发、做驱动程序等，总之，Python 能做的事情还是非常多的，好好学吧，很快你就会
fall in love with this great language!
Python 的优缺点
先看优点
1. Python 的定位是“优雅”、“明确”、“简单”，所以 Python 程序看上去总是简单易懂，初 学者学 Python，不但入门容易，而且将来深入下去，可以编写那些非常非常复杂的程 序。
2. 开发效率非常高，Python 有非常强大的第三方库，基本上你想通过计算机实现任何功 能，Python 官方库里都有相应的模块进行支持，直接下载调用后，在基础库的基础上 再进行开发，大大降低开发周期，避免重复造轮子。
3. 高级语言————当你用 Python 语言编写程序的时候，你无需考虑诸如如何管理你的 程序使用的内存一类的底层细节
4. 可移植性————由于它的开源本质，Python 已经被移植在许多平台上（经过改动使 它能够工 作在不同平台上）。如果你小心地避免使用依赖于系统的特性，那么你的所 有 Python 程序无需修改就几乎可以在市场上所有的系统平台上运行
5. 可扩展性————如果你需要你的一段关键代码运行得更快或者希望某些算法不公开， 你可以把你的部分程序用 C 或 C++编写，然后在你的 Python 程序中使用它们。
6. 可嵌入性————你可以把 Python 嵌入你的 C/C++程序，从而向你的程序用户提供 脚本功能。
再看缺点：
1. 速度慢，Python 的运行速度相比 C 语言确实慢很多，跟 JAVA 相比也要慢一些，因此 这也是很多所谓的大牛不屑于使用 Python 的主要原因，但其实这里所指的运行速度慢 在大多数情况下用户是无法直接感知到的，必须借助测试工具才能体现出来，比如你用 C 运一个程序花了 0.1s,用 Python 是 0.01s,这样 C 语言直接比 Python 快了 10s,算是非 常夸张了，但是你是无法直接通过肉眼感知的，因为一个正常人所能感知的时间最小单 位是 0.15-0.4s 左右，哈哈。其实在大多数情况下 Python 已经完全可以满足你对程序速 度的要求，除非你要写对速度要求极高的搜索引擎等，这种情况下，当然还是建议你用 C 去实现的。
2. 代码不能加密，因为 PYTHON 是解释性语言，它的源码都是以名文形式存放的，不过 我不认为这算是一个缺点，如果你的项目要求源代码必须是加密的，那你一开始就不应 该用 Python 来去实现。
3. 线程不能利用多 CPU 问题，这是 Python 被人诟病最多的一个缺点，GIL 即全局解释器 锁（Global Interpreter Lock），是计算机程序设计语言解释器用于同步线程的工具，使 得任何时刻仅有一个线程在执行，Python 的线程是操作系统的原生线程。在 Linux 上为 pthread，在 Windows 上为 Win thread，完全由操作系统调度线程的执行。一个 python 解释器进程内有一条主线程，以及多条用户程序的执行线程。即使在多核 CPU 平台上， 由于 GIL 的存在，所以禁止多线程的并行执行。关于这个问题的折衷解决方法，我们在 以后线程和进程章节里再进行详细探讨。
Python 解释器
当我们编写 Python 代码时，我们得到的是一个包含 Python 代码的以 .py 为扩展名的文本文件。要运行代码，就需要 Python 解释器去执行 .py 文件。由于整个 Python 语言从规范到解释器都是开源的，所以理论上，只要水平够高，任何人都可以编写 Python 解释器来执行 Python 代码（当然难度很大）。事实上，确实存在多种 Python解释器。
Python2.x与3.x主要区别
1. 1/2变成了0.5
2. print "Hello World"变成了print("Hello World")
3. raw_input()没了，变成了input()
4. class Foo:写法不能用了，只能class Foo(object)
5. 默认支持输入中文，不用在代码里输入# -*- coding: utf-8 -*-
Python安装
下载地址：https://www.python.org/downloads/
python2.7及python3.x版本装在centos6.5系统上后，交互模式的删除键、返回键、上向左右箭头键出现乱码问题，解决方法是yum -y install readline-devel （注意yum解释器是系统python版本），安装完成readline-devel后，再重新编译安装Python2.7即可解决问题
Python 的变量及数据类型
数据类型 一个程序要运行，就要先描述其算法。描述一个算法应先说明算法中要用的数据，数据以变量或 常量的形式来描述。每个变量或常量都有数据类型。Python 的基本数据类型有 5 种：整型(int), 浮点型(float), 字符型(string), 布尔型（bool）,空值(None).
1.整数
Python 可处理任意大小的整数，在程序中的表示方法和数学上的写法完全一样。
2.浮点数
浮点数也就是小数，之所以称为浮点数，是因为按照科学记数法表示时，一个浮点数的小数点位置是可变的，比如，1.23x109 和 12.3x108 是相等的。浮点数可以用数学写法，如 1.23 ，3.14 ， -9.01 ，等等。但是对于很大或很小的浮点数，就必须用科学计数法表示，把 10用 e 替代，1.23x109 就是 1.23e9 ，或者 12.3e8 ，0.000012 可以写成 1.2e-5 ，等等。整数和浮点数在计算机内部存储的方式是不同的，整数运算永远是精确的（除法难道也是精确的？是的！），而浮点数运算则可能会有四舍五入的误差。
3.字符串
字符串是以''或""括起来的任意文本，比如 'abc' ， "xyz" 等等。请注意，''或""本身只是一种表示方式，不是字符串的一部分，因此，字符串 'abc' 只有 a ， b ， c 这 3 个字符。如果 ' 本身也是一个字符，那就可以用""括起来，比如 "I'm OK" 包含的字符是 I ， ' ， m ，空格， O ， K 这 6 个字符。'''...''' 的格式表示多行内容print '''line1 line2 line3'''。
4.布尔值
布尔值和布尔代数的表示完全一致，一个布尔值只有 True 、False 两种值，要么是 True ，要么是 False ，在 Python 中，可以直接用 True 、 False 表示布尔值（请注意大小写），也可以通过布尔运算计算出来：
>>> True True >>> False False >>> 3 > 2 True >>> 3 > 5 False
布尔值可以用 and 、 or 和 not 运算。
and 运算是与运算，只有所有都为 True ， and 运算结果才是 True ：
>>> True and True True >>> True and False False >>> False and False False
or 运算是或运算，只要其中有一个为 True ， or 运算结果就是 True ：
>>> True or True True >>> True or False True >>> False or False False
not 运算是非运算，它是一个单目运算符，把 True 变成 False ， False 变成 True ：
>>> not True False >>> not False True
布尔值经常用在条件判断中，比如：
if age >= 18:
print 'adult'
else:
print 'teenager'
5.空值
空值是 Python 里一个特殊的值，用 None 表示。 None 不能理解为 0 ，因为 0 是有意义的，而 None 是一个特殊的空值
条件判断
valid_user = 'jack'
valid_passwd = 'jack111'
user_input = input("Your username:")
passwd = input("Your password:")
if user_input == valid_user and passwd == valid_passwd:
print(Welcome %s login to our system!" % user_input)
elif user_input == 'guest':
print(Welcome %s login our system,but you only have read-only access,enjoy!)
else:
print "invalid username! Byebye!"
这里我们用到了 elif,意思就是，如果不满足第一个 if 条件，那程序就会继续往下走，再判断 是否满足 elif 条件，如果不满足，就再继续走（这里你可以加多个 elif 判断），只要遇到有 满足的 elif 就停下来执行它后面的代码，然后结束，如果最终没有碰到满足的条件，就最终执 行 else 语法。另外真的可以写多行噢，如下：
if <条件判断 1>:
<执行 1>
elif <条件判断 2>:
<执行 2>
elif <条件判断 3>:
<执行 3>
else:
<执行 4>
for循环
valid_user = 'jack'
valid_passwd = 'jack111'
for i in range(3):
user_input = raw_input("Your username:")
passwd = raw_input("Your password:")
if user_input == valid_user and passwd == valid_passwd:
print （"Welcome %s login to our system!" % user_inpu)
break
elif user_input == 'guest':
print ("Welcome %s login our system,but you only have read-only access,enjoy!" % user_inpu
break
else:
print ("invalid username!")
这个代码实现了，如果用户名密码错误后，最多让用户尝试 3 次，注意这里用到了 break,它是用来帮助跳出整个循环的，就是现在你的程序要循环 3 次，但是用 户再尝试了第 2 次时，就验证成功了，这时候你还需要让他再进行一次验证吗？当然不需要， 这时候需要让程序在验证成功后直接跳出整个循环，不再需要进行下一次循环操作。
while循环
import time #导入time模块
count = 0 #设置一个计数器，每循环一次加一次，这样就知道循环多少次了。
while True: #只要为真，就执行下面代码，每循环一次就判断一次
count += 1 #每循环一次就自加1
print （"Loop ", count）
time.sleep(10) #每循环一次就 sleep 10s 再继续运行
输出：
Loop 1
Loop 2
Loop 3
...
上面的程序就是死循环了，只要进程没被杀死，就会一直运行下去
continue VS break
跟 break 相对应的还有一个负责循环跳出的语法就是 continue，它跟 break 有什 么区别呢？我们都知道了 break 是负责跳出整个循环，但 continue 是跳出本次 循环，继续下一次循环。就是说，循环过程中，如果遇到 continue,那这一次循 环本应该执行的后面的代码就不执行了，直接跳过了，直接进行下一次循环了。
注意：当遇到多层嵌套循环时，break只跳出当前嵌套里的循环，不会跳出所有嵌套循环。
列表、元组和字典
列表(List)
列表是在编程中经常用到的一种数据类型，它跟其它语言中所指的数组基本是一 样的，列表是指一组有序的数据集合，可以将各种各样的数据有序的存放在列表 中，并且可以对其进行增删改查，以及遍历。列表的存在是为了通过一个变量存 储更多的信息，比如我想在一个变量里存储一张购物清单，然后程序只需要通过 我定义的这个变量就可以找到购物清单中的任意一个或多个商品。如下：
>>> shopping_list = ['Iphone', 'Mac', 'Bike','Coffee','Car','Clothes','Food','Gift']
>>> shopping_list
['Iphone', 'Mac', 'Bike', 'Coffee', 'Car', 'Clothes', 'Food', 'Gift']
通过 len()内置函数可查看列表中元素的个数
>>> len(shopping_list)
8
你可以通过索引来找到列表中每个元素的位置，记住索引是从 0 开始的
>>> shopping_list[2] #找Bike
'Bike'
>>> shopping_list[0] #第一个元素取出来
'Iphone'
>>> shopping_list[-1] #-1代表取列表中最后一个元素
'Gift'
>>> shopping_list[-3] #取倒数第3位元素
'Clothes'
>>> shopping_list[-4] #取倒数第4个元素
'Car'
>>> shopping_list[8] #取索引为8的元素
Traceback (most recent call last):
File "<stdin>", line 1, in <module> IndexError: list index out of range
#最后一个shopping_list[8]报错了，原因是引用超出了索引范围，不是有8 个元素吗？取第8个怎么会出错呢？这里要注意了，列表的索引是从0开始的， 你这里写的8其实是取了列表中的第9个位置，但你列表中一共有8个元素，所以 肯定取不到喽。
切片(Slice)
你还可以从列表中取出指定多个元素，这种操作叫做切片
>>> shopping_list
['Iphone', 'Mac', 'Bike', 'Coffee', 'Car', 'Clothes', 'Food', 'Gift']
>>>
>>> shopping_list[0:3] #取0到第3个元素，不包括第4个
['Iphone', 'Mac', 'Bike']
>>> shopping_list[:3] #同上，取0到第3个元素，不包括第4个，0可以不写
['Iphone', 'Mac', 'Bike']
>>> shopping_list[2:5] #取第3至第5个元素
['Bike', 'Coffee', 'Car']
>>> shopping_list[:-3] #取从0至倒数第3个元素
['Iphone', 'Mac', 'Bike', 'Coffee', 'Car']
>>> shopping_list[-3:] #取最后3个元素
['Clothes', 'Food', 'Gift']
>>> shopping_list[1:8:2] #从1至8隔一个取一个，后面的2是步长，即每隔几个元素取一个
['Mac', 'Coffee', 'Clothes', 'Gift']
>>> shopping_list[::2] #从头到位每隔一个取一个
['Iphone', 'Bike', 'Car', 'Food']
增删改查
>>> shopping_list.append('MovieTicket') #向列表后面追加一个元素
>>> shopping_list
['Iphone', 'Mac', 'Bike', 'Coffee', 'Car', 'Clothes', 'Food', 'Gift', 'MovieTicket']
>>> shopping_list.pop() #删除最后一个元素
'MovieTicket'
>>> shopping_list.remove('Mac') #删除叫’Mac’的元素，如果有多个’Mac’,那会删除从左边数找到的第一 个
>>> shopping_list[2]
'Coffee'
>>> shopping_list[2] = 'COFFEE' #将索引为2的元素改为”COFFEE”，原来是小写
>>> shopping_list.insert(3,"Toy") #插入一个新元素，索引为3
>>> shopping_list
['Iphone', 'Bike', 'COFFEE', 'Toy', 'Car', 'Clothes', 'Food', 'Gift']
>>> shopping_list.index('Toy') #返回’Toy’元素的索引值，如果有多个相同元素，则返回匹配的第一个
3
>>> shopping_list.append('Food')
>>> shopping_list.count('Food') #统计’Food’的元素的个数，刚添加了一个，所以现在是2个
2
>>> shopping_list
['Iphone', 'Bike', 'COFFEE', 'Toy', 'Car', 'Clothes', 'Food', 'Gift', 'Food']
>>> list2= ['Banana','Apple'] #创建一个新列表
>>> shopping_list.extend(list2) #把上面的新列表合并到shopping_list中
>>> shopping_list
['Iphone', 'Bike', 'COFFEE', 'Toy', 'Car', 'Clothes', 'Food', 'Gift', 'Food', 'Banana',
'Apple']
>>> shopping_list.sort() #将列表排序
>>> shopping_list
['Apple', 'Banana', 'Bike', 'COFFEE', 'Car', 'Clothes', 'Food', 'Food', 'Gift', 'Iphone',
'Toy']
>>> shopping_list.reverse() #将列表反转
>>> shopping_list
['Toy', 'Iphone', 'Gift', 'Food', 'Food', 'Clothes', 'Car', 'COFFEE', 'Bike', 'Banana',
'Apple']
>>> del shopping_list[3:8] #删除索引3至8的元素，不包括8
>>> shopping_list
['Toy', 'Iphone', 'Gift', 'Bike', 'Banana', 'Apple']
>>> for i in shopping_list: #遍历列表
... print i
元组（Tuple）
另一种有序列表叫元组：tuple。tuple 和 list 非常类似，但是 tuple 一旦初始化就不能修改
字典（Dict）
列表允许你通过一个变量存储大量的信息，但试想以下场景，用列表实现就可能 效率较低了：
1. 存储的信息量越来越多，有的时候找一个数据可能要循环整个列表，耗时较 长。
2. 单个元素包含的信息量变多时，比如，之前只是存储姓名列表，现在是要存 储姓名、年龄、身份证号、地址、工作等这个人的很多信息，用列表去存储 很费劲
3. 要求存储的数据是不重复，我们知道列表是允许的重复值的，当然想存储时 就让我的数据默认就是唯一的话，用列表就不可以了
以上这些是列表不擅长的地方，却恰恰是dict 所擅长的， dict 使用 key-‐value 的形式存储数据，dict 的 key 是唯一的，所以你可以通过 key 来唯一的定位到你的数据。之所以叫字典(在其它语言中称为 map)，是因为 dict 的数据结构跟我们生活中用的字典是一样的，查英文字典时，输入单词，就可以 定位到这个单词意思的详细解释，其中这个单词就是 key,对应的词义解释就是 value.字典有如下特点：
1. key-‐value 格式，key 是唯一的
2. 无序，与列表有序的特点不同，字典是无序的，列表只所以有序是因为你需 要通过索引来定位相应元素，而字典已经可以通过 key 来定位相应 value,因 此为了避免浪费存储空间，字典不会对数据的位置进行纪录，当然如果你想 让其变成有序的，也是有方法的，这个我们以后再讲。
3. 查询速度很快，dict 是基于 hash 表的原理实现的，是根据关键字（Key value） 而直接访问在内存存储位置的数据结构。也就是说，它通过把键值通过一个 函数的计算，映射到表中一个位置来访问记录，这加快了查找速度。这个映 射函数称做散列函数，存放记录的数组称做散列表。由于通过一个 key 的索 引表就直接定位到了内存地址，所以查询一个只有 100 条数据的字典和一个
100 万条数据的字典的速度是查不多的。
好了，来看看 dict 的语法：
>>> info = {'name':'alex',
'job':'engineer',
'age': 29,
'company':'AUTOHOME'
}
>>> info
{'age': 29, 'job': 'engineer', 'company': 'AUTOHOME', 'name': 'alex'}
增删改查
>>> info['name'] #查看key为’name’的value
'alex'
>>> info['job'] = 'Boss' #将key 的value 改为’Boss’
>>> info
{'age': 29, 'job': 'Boss', 'company': 'AUTOHOME', 'name': 'alex'}
>>> info['city'] = 'BJ' #如果dict中有key为’city’,就将其值改为’BJ’,如果没有这个key,就创建一条新 纪录
>>> info
{'age': 29, 'job': 'Boss', 'company': 'AUTOHOME', 'name': 'alex', 'city': 'BJ'}
>>> info.pop('age') #删除key为’age’的数据，跟del info[‘age’] 一样
29
>>> info
{'job': 'Boss', 'company': 'AUTOHOME', 'name': 'alex', 'city': 'BJ'}
>>> info.popitem() #随机删除一条数据，dict为空时用此语法会报错
('job', 'Boss')
>>> info.items() #将dict的key,value转换成列表的形式显示
[('company', 'AUTOHOME'), ('name', 'alex'), ('city', 'BJ')]
>>> info.has_key('name') #判断字典中是否有个叫’name’的key
True
>>> info['age'] #查找一个不存在的key报错，因为’age’刚才已经删除了，所以报错
Traceback (most recent call last): File "<stdin>", line 1, in <module>
KeyError: 'age'
>>> info.get('age') #查找key,如果存在则返回其value,否则则返回None
>>> info.get('name')
'alex'
>>> info.clear() #清空dict
>>> info
{}
>>> info.fromkeys(['a','b','c'],'Test') #根据列表[‘a’,’b’,’c’]来创建dict里的key,后面 的’Test’是默认value,如果不指定的话则为None
{'a': 'Test', 'c': 'Test', 'b': 'Test'}
>>> info
{}
>>> info =info.fromkeys(['a','b','c'],'Test')
>>> info
{'a': 'Test', 'c': 'Test', 'b': 'Test'}
>>> info.setdefault('d','Alex') #找一个key为’d’的纪录，如果这个key不存在，那就创建一个叫’d’的key,
并且将其value设置为’Alex’， 如果这个key存在，就直接返回这个key的value，见下一条
'Alex'
>>> info.setdefault('c','Alex')
'Test'
>>> info
{'a': 'Test', 'c': 'Test', 'b': 'Test', 'd': 'Alex'}
>>> dict2 = {'e':'fromDict2','a':'fromDict2'} #创建一个新字典
>>> info.update(dict2) #拿这个新字典去更新info,注意dict2中有一个key值’a’与dict info相冲突，这 时dict2的值会覆盖info中的a,如果dict2的key在info中不存在，则创建相应的纪录
>>> info
{'a': 'fromDict2', 'c': 'Test', 'b': 'Test', 'e': 'fromDict2', 'd': 'Alex'}
遍历 dict 与遍历列表差不多，只不过要记得 dict 是 key-‐value 的结构，要想在遍 历时同时打印这 key 和 value，需要这样写：
info = {
'name': 'Alex Li',
'age': 29,
'job': 'Engineer',
'phone': 1493335345
}
for item in info:
print(item, info[item]) #print item 只会打印 key,如果想同时打印 value,需要再通过 item 去取
还有一种遍历的方式：
for key,val in info.items():
print(key,val)