1、python是怎么来的
    是在1989年吉多·范罗苏姆，在圣诞节的时候闲着无聊自己用C语言开发的，一个脚本解释程序，作为ABC语言的一种继承。  
2、有哪些公司在用    
    Youtube、Dropbox、BT、Quora（中国知乎）、豆瓣、知乎、Google、Yahoo!、Facebook、NASA、百度、腾讯、汽车之家、美团等。互联网公司广泛使用Python来做的事
3、python作用
    数据分析、组件集成、网络服务、图像处理、数值计算和科学计算等众多领域。
4、有哪些版本
    Cpython（基于C语言实现）、Jyhton（基于java语言的实现）、IronPython（基于C#语言的实现）、PyPy（比较特殊基于python实现）其他的有RubyPython（基于ruby语言的实现）、Brython
5、与其他语言的优缺点与其他语言的优缺点
    C、Java、php、python
5-1、在速度上的区别：
C语言直接编译成机器语言，所以比较快。python需要编译成字节码，在从字符语言编译成机器语言，所以运行速度比
较慢。其他语言也是一样，相比python都需要先转成字符语言在编译成机器语言，方可使用。
5-2、功能上
更多功能和类库（内置、开源、自己写）
6、中文解释码

-*- coding:utf-8 -*-

7、为了不用python 脚本的方式需要编码声明

注释：“#”单行注释，多行注释“""" """”
模块： 
1、import sys
使用了argv模块，sys.argv 用来捕获执行执行python脚本时传入的参数，倒入之后会生成pyc，python执行主要看文件的和pyc是否一样如果一样优先级是pyc，不一样是文件
2、import getpass模块 输入密码不显示，隐藏所输入的内容

变量就是在内存中开辟一块空间并给这块空间赋一个名称就是变量名
变量的作用：昵称，其代指内存里某个地址中保存的内容
字节码：
1、变量规则
    1、变量名：大小写字母、数字、下划线 数字不能作为起始 不能作为python内置的关键字
    2、这些关键词不能声明变量名['and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'exec', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'not', 'or', 'pass', 'print', 'raise', 'return', 'try', 'while', 'with', 'yield']
    3、变量的第一个字符不能是数字
    2、流程控制和缩进

外层变量，可以被内层变量使用
    内层变量，无法被外层变量使用
    在字符串里，name1 = ”字符串“ name2 = name1
    name1改变，name2不变.字符串的特性一旦修改，重新创建。赋同一个值给两个不同的变量就是开辟两个不同的空间，
只是python的优化把两个变量值和在一起了，如果超过这个赋值池，就会开辟两块空间体现。数字池是-5到257
python执行过程：加载内存、此法分析、语法分析、编译---》》 字节码

语法：
输入输出
输入：raw_input
输出：print
输入不显示：getpass模块

"=="是两个值之间的对比,
流程控制

两部分：

1、单值
        数字
            整型（int）（32位：取值范围为-2**31～2**31-1，即-2147483648～2147483647。64位，取值范围为-2**63～2**63-1，即-9223372036854775808～9223372036854775807）
            长整型（long）（Python没有限制长整数数值的大小）
            浮点型（float）（浮点数用来处理实数，即带有小数的数字）
            复数（complex）（　复数由实数部分和虚数部分组成，一般形式为x＋yj，其中的x是复数的实数部分，y是复数的虚数部分，这里的x和y都是实数。注：Python中存在小数字池：-5 ～ 257）
            注：python中存在小数字池：-5~257
        布尔值(bool)    True、false    1 0
        字符串（str）
    2、集合
        列表
        元祖
        字典
        哈希表

字符串格式化
字符串是%s;整数是%d；浮点数是%f
    两种格式

>>> name = "i am %s %d"    %("alex",13)
或
>>> name = "i am %s %d"    #占位符％ｓ、％ｄ
>>> name %("wulaoer",13)    ＃按照占位符的顺序
'i am alex 13'
##################################################################################################
>>> name = "i am {0},age{1}"
>>> name.format("wulaoer",14)
'i am wulaoer,age14'

符号：＇＇　＂＂　＂＂＂　　前两种是单行　后一个是多行，三个引号可以做字符串也可以做注释。
1、切片

>>> name = "wulaoer"
>>> print name[0:]        ＃下标识从０开始的

wulaoer

>>> print name[0:2]        ＃最后一个不显示
wu
>>> print name[-1]        ＃最后一个
r
>>> print name[:-1]        ＃从最后一个开始

wulaoe

>>> print name[:-2]        ＃左边显示右边不显示

wu

>>> print len(name)        ＃多少个字符
6

移除空白

1 >>> name = "wulaoer"
 2 >>> print name
 3    wulaoer
 4 >>> print name.lstrip()        ＃去掉左边空格
 5 wulaoer
 6 >>> name = "wulaoer"    
 7 >>> print name.rstrip()        ＃去掉右边空格
 8     wulaoer
 9 >>> print name.strip()        ＃去掉两边的空格
10 wulaoer 

2、索引：
索引     （-1），
查看元素的个数len（）

1 >>> shopping_list = ['Iphone', 'Mac', 'Bike','Coffee','Car','Clothes','Food','Gi
2 ft']
3 >>> shopping_list
4 ['Iphone', 'Mac', 'Bike', 'Coffee', 'Car', 'Clothes', 'Food', 'Gift']
5 >>> len(shopping_list)
6 8

以下是索引实例：

1 >>> shopping_list = ['Iphone', 'Mac', 'Bike','Coffee','Car','Clothes','Food','Gift']    #创建一个列表
2 >>> shopping_list
3 ['Iphone', 'Mac', 'Bike', 'Coffee', 'Car', 'Clothes', 'Food', 'Gift']        #显示列表
4 >>> shopping_list[0]        #输出列表的第一个元素
5 'Iphone'
6 >>> shopping_list[2]        #输出列表的第二个元素，是从0开始的
7 'Bike'

3、字符串（str）
    重新开辟空间
4、列表（list）
    修改后内存地址不变

1 >>> name = ['wulaoer','hello','word']
 2 >>> name_list = ['wulaoer','hello','word']
 3 >>> name_list
 4 ['wulaoer', 'hello', 'word']
 5 >>> name_list.append('day')        ＃添加
 6 >>> name_list
 7 ['wulaoer', 'hello', 'word', 'day']
 8 =============================================================
 9 >>> del name_list[0]        ＃删除，
10 >>> del name_list[0:3]        ＃删除索引0到3，不包括3
11 或
12 >>> name_list
13 ['wulaoer', 'hello', 'word', 'day']
14 >>> name_list.remove('wulaoer')        ＃删除wulaoer，如果有多个wulaoer，那会删除从左边开始第一个wulaoer。
15 >>> name_list
16 ['hello', 'word', 'day']
17 =============================================================
18 >>> name_list.insert(2,"wulaoer")        #插入
19 >>> name_list
20 ['hello', 'word', 'wulaoer', 'day']
21 >>> name_list[3] = 'world'            #修改
22 >>> name_list
23 ['wulaoer', 'hello', 'wulaoer', 'world']
24 ========================================================
25 >>> '_'.join(name_list)                #连接根据单引号的符号连接两个元素之间的
26 'wulaoer_hello_wulaoer_world'

列表的增删改：只是对于列表的最小单元

1 '_'.join（列表）
 2 >>> name_list
 3 ['wulaoer', 'hello', 'wulaoer', 'world']
 4 >>> name_list.index('wulaoer')            #返回列表的索引值，如果有多个返回第一个值
 5 0
 6 >>> name_list.index('world')
 7 3
 8 =============================================================
 9 >>> name_list.count('wulaoer')            #统计索引值
10 2
11 >>> name_list.count('world')
12 1
13 >>> name_city = ['henan', 'hebei', 'wubei']
14 >>> name_list.extend(name_city)            #合并两个表
15 >>> name_list
16 ['wulaoer', 'hello', 'wulaoer', 'world', 'henan', 'hebei', 'wubei']
17 =============================================================
18 >>> name_list
19 ['wulaoer', 'hello', 'wulaoer', 'world', 'henan', 'hebei', 'wubei']
20 >>> name_list.sort()        #将列表排序，根据26个字符的顺序
21 >>> name_list
22 ['wulaoer', 'wulaoer', 'hebei', 'hello', 'henan', 'world', 'wubei']
23 =============================================================
24 >>> name_list.reverse()        #将列表反转排序
25 >>> name_list
26 ['wubei', 'world', 'henan', 'hello', 'hebei', 'wulaoer', 'wulaoer']
27 =============================================================
28 >>> for i in name_list:        #遍历列表
29 ...     print i
30 ...
31 wubei
32 world
33 henan
34 hello
35 hebei
36 wulaoer
37 wulaoer

元组是另外一种序列表，一旦初始化不允许修改，在表示只有一个元素的元组里，也要价格“,”避免误解成数学计算意义
注：元祖不可修改，列表可以修改
1、循环

dict，字典是使用键值对（key-value）的形式存储数据，key是唯一的，所以可以定位到数据。相对应的就是value
字典特点：
1、key-value格式，key是唯一的
2、字典是无序的相比列表
3、查询速度很快，是基于hash表的原理实现的，根据关键字（Key value）而直接访问在内存存储位置的数据结构。
字典和列表的区别：字典是通过key来定位相应的value，避免浪费空间不会对数据位置记录。列表是通过索引来定位相应元素，所以列表有序

1 person.keys()        #所有keys
2 person.values()        #所有values
3 person.items()        #所有元素，仅for循环时，使用，将元素赋值给keys
4 person.items()
5 for k,v in person.items()
6     print k
7     print v
8     print '=============' 

dict语法：

 1 >>> class_name = {
 2     'name':'toy', 
 3     'job':'IT', 
 4     'age':12,
 5 }
 6 或者
 7 >>> class_name = {'name':'toy', 'job':'IT', 'age':12,}
 8 >>> class_name
 9 {'age': 12, 'job': 'IT', 'name': 'toy'}
10 =============================================================
11 >>> class_name['age']    #查看key为age的value
12 12
13 >>> class_name['age'] = 19    #将key的value改为“19”
14 >>> class_name
15 {'age': 19, 'job': 'IT', 'name': 'toy'}
16 =============================================================
17 >>> class_name['company'] = 'AUTOHOME'    #在dict中查找key为“company”，将其改成“AUTOHOME”，如果没有就创建一条
18 >>> class_name
19 {'age': 19, 'job': 'IT', 'company': 'AUTOHOME', 'name': 'toy'}
20 =============================================================
21 >>> class_name.pop('company')    #删除key为“company”的数据
22 'AUTOHOME'
23 >>> class_name
24 {'age': 19, 'job': 'IT', 'name': 'toy'}
25 >>> class_name.popitem( )        #随机删除一条数据，dict为空时用此法会报错
26 ('age', 19)
27 >>> class_name
28 {'job': 'IT', 'name': 'toy'}
29 >>> class_name.items()            #将dict的key和value转换成列表的形式显示
30 [('job', 'IT'), ('name', 'toy')]
31 =============================================================
32 >>> class_name['age']        #查找一个不存在的key
33 Traceback (most recent call last):
34   File "<stdin>", line 1, in <module>
35 KeyError: 'age'
36 >>> class_name.has_key('name')        #判断dict里是否有一个’name‘的key，有True，否则False
37 True
38 >>> class_name.has_key('gae')
39 False
40 >>> class_name.get('age')        #查找key，如果存在则返回其value，否则None
41 >>> class_name.get('name')
42 'toy'
43 =============================================================
44 >>> class_name
45 {'job': 'IT', 'name': 'toy'}
46 >>> class_name.clear()                #清空dict
47 >>> class_name
48 {}
49 =============================================================
50 >>> class_name =class_name.fromkeys(['a', 'b', 'c', 'd'],'helo')        #根据列表来创建dict里的key，后面的“helo”是默认的value，如果不指定的话则为None
51 >>> class_name
52 {'a': 'helo', 'c': 'helo', 'b': 'helo', 'd': 'helo'}
53 >>> class_name.setdefault('e','helo')    #找一个key为’e‘的记录，如果不存在，就重新穿件key为“e”，vlaue为“helo”，如果存在直接返回这个key的value
54 'helo'
55 >>> class_name.setdefault('c','h')        #dict的key里有“c”，直接返回“c”的value。
56 'helo'
57 >>> class_name
58 {'a': 'helo', 'c': 'helo', 'b': 'helo', 'e': 'helo', 'd': 'helo'}
59 =============================================================
60 >>> dict2 = {'f':'test', 'g':'test', 'h':'test'}        #创建一个新的dict
61 >>> class_name.update(dict2)        #用新的dict去更新class_name，如果dict中的key值和class_name中的key值冲突，dict的key值会覆盖掉class_name的key值，不存在会创建相应记录
62 >>> class_name
63 {'a': 'helo', 'c': 'helo', 'b': 'helo', 'e': 'helo', 'd': 'helo', 'g': 'test', 'f': 'test', 'h': 'test'} 

遍历dict和遍历列表差不多，只是dict是key-value结构，同时打印key和value，需要这样写：

1 =============================================================
 2 class_name = {
 3         'name': 'tom',
 4         'age': 19,
 5         'job': 'IT'
 6 }
 7 for item in class_name:
 8         print item,class_name[item]      #打印key和value
 9 输出key和value
10 job IT
11 age 19
12 name tom
13 或者
14 for key,val in class_name.items():        #同时打印key和value
15         print key,val
16 =============================================================
17 for item in class_name:        
18         print item        #只会打印key
19 job
20 age
21 name

默认是把字典转换成一个大列表，并把没对key-value值转换成元组，所以每次循环时赋2个变量进去，因为循环的数据格式如下：[('name','tom'),('age','19'),('job','IT')]    
因此每循环一次，就是把相应元组中的2个值赋值key,val这两个变量打印。

dict里套接dict，value可以是一个列表，也可以是任何数据类型。但是key不可以，必须保证key的唯一性。

1 >>> staff_contacts = {
 2 ...     0023:{'name':'tom', 'age':18, 'job':'IT', 'phone':3456},
 3 ...     3951:{'name':'Bob', 'age':19, 'job':'PHP', 'phone':5563},
 4 ...     5342:{'name':'Com', 'age':20, 'job':'IOS', 'phone':2942},
 5 ... }
 6 >>> staff_contacts
 7 {19: {'job': 'IT', 'phone': 3456, 'age': 18, 'name': 'tom'}, 5342: {'job': 'IOS'
 8 , 'phone': 2942, 'age': 20, 'name': 'Com'}, 3951: {'job': 'PHP', 'phone': 5563,
 9 'age': 19, 'name': 'Bob'}}        
10 =============================================================
11 >>> contacts2 = staff_contacts
12 >>> staff_contacts[0023]['age'] = 38
13 >>> print 'staff_contacts:',staff_contacts[0023]
14 staff_contacts: {'job': 'IT', 'phone': 3456, 'age': 38, 'name': 'tom'}
15 >>> print 'contacts2:', contacts2[0023]
16 contacts2: {'job': 'IT', 'phone': 3456, 'age': 38, 'name': 'tom'}
17 >>> print 'id of staff_contacts:',id(staff_contacts[0023])    #查看两个dict的内存地址
18 id of staff_contacts: 35454488
19 >>> print 'id of contacts2:',id(contacts2[0023])
20 id of contacts2: 35454488 

#第一个dict复制给另外一个dict的时候，修改其中一个dict，另外一个dict也跟着修改，而且两个dict的内存地址一样。对于字符串、数字等一些简单的数据类型，python会重新开辟一块空间，但是对于dict、list、tuple以及下面的set集合，python会像软链接一样，无论是修改原来的dict还是现在的dict，都是修改的同份数据，所以才会出现上面的情况，这样做的目的是为了节约内存。
如果要想让copy出来的数据不跟着改变，就需要用copy语句

1 >>> contacts2 = staff_contacts.copy()
 2 用帮助来查看这个语法的解释：
 3 >>> help(staff_contacts.copy)
 4 Help on built-in function copy:
 5 copy(...)
 6     D.copy() -> a shallow copy of D
 7 a shallow copy就是浅copy的意思
 8 >>> staff_contacts = {
 9 ...
10 ...      0023:{'name':'wulaoer','age':29,'department':'IT','phone':3423},
11 ...     3333:'nothing'
12 ... }                #重新建一个dict
13 >>> contacts2 = staff_contacts.copy() #浅copy
14 >>> staff_contacts[0023]['age'] = 28    #修改dict的两个值
15 >>> staff_contacts[3333] = 'change this by original dict'
16 >>> contacts2
17 {19: {'department': 'IT', 'phone': 3423, 'age': 28, 'name': 'wulaoer'}, 3333: 'n
18 othing'}
19 >>> staff_contacts
20 {19: {'department': 'IT', 'phone': 3423, 'age': 28, 'name': 'wulaoer'}, 3333: 'c
21 hange this by original dict'}
22 #注经过浅copy之后，3333已经是两个数据已经独立了，而age还是共享内存数据，这个就是浅copy 

深copy就是不管下面有多少层都copy了
语法

1 >>> import copy
2 >>> contacts2 = copy.deepcopy(staff_contacts)
3 >>> contacts2
4 {19: {'department': 'IT', 'phone': 3423, 'age': 28, 'name': 'wulaoer'}, 3333: 'c
5 hange this by original dict'}
6 >>> staff_contacts
7 {19: {'department': 'IT', 'phone': 3423, 'age': 28, 'name': 'wulaoer'}, 3333: 'c
8 hange this by original dict'}
9 #深copy之后所有的值都会copy过来。 

python的set是一个无序不重复元素集，基本功能包括关系测试和消除重复元素。集合对象还支持union（联合）、intersection（交）、difference（差）和sysmmetric difference（对称差集）等数学运算。
sets支持 x in set, len(set),和 for x in set.作为一个无序的集合，sets不记录元素位置或者插入点。因此，sets不支持 indexing,slicing，或其他类序列（sequence-like）的操作
基本语法

 1 >>> s = set([3,5,9,10])        #数字集合
 2 >>> t = set("Hello")        #字符集合
 3 集合是无序的，与列表和元祖不同，也不能数字进行索引，集合的元素不能重复
 4 >>> t
 5 set(['H', 'e', 'l', 'o'])    #这里只出现了一个“I”
 6 集合支持一系列标准操作，包括并集、交集、差集和对称差集，
 7 >>> a = t | s        #t和s的并集
 8 >>> a
 9 set([3, 'e', 5, 'H', 10, 'l', 'o', 9])
10 >>> b = t & s        #t和s的交集
11 >>> b
12 set([])
13 >>> c = t -s        #求差集（项在t中，但不在s中）
14 >>> c
15 set(['H', 'e', 'l', 'o'])
16 >>> d = t ^ s        #对称差集（项在t或s中，但不会同时出现在二者中）
17 >>> d
18 set([3, 'e', 5, 9, 10, 'l', 'o', 'H'])
19 >>> t.add('x')        #添加
20 >>> t
21 set(['H', 'e', 'l', 'o', 'x'])
22 >>> s.update([11,12,13])    #添加多项
23 >>> t.remove('H')            #删除，如果不存在报错KeyError
24 >>> t
25 set(['e', 'l', 'o', 'x'])    
26 >>> len(s)        set的长度
27 7
28 #######################################################
29 x in s    #测试x是否是s的成员                              #                        
30 x not in s     #测试x是否不是s的成员                      #
31 #######################################################    
32 >>> s.discard(5)    #如果在set “s”中存在元素5，则删除
33 >>> s
34 set([9, 10, 11, 12, 13])    
35 >>> s.pop()            #删除并且返回set “s”中一个不确定的元素，如果为空则报错KeyError
36 9
37 >>> s
38 set([10, 11, 12, 13])    
39 >>> s.clear()        #删除set “s”中的所有元素
40 >>> s
41 set([])    
42 >>> s.issubset(t)    s<= t #测试是否s中的每个元素都在t中
43 True
44 >>> s.issuperset(t)    s>= t  #测试是否t中的每个元素都在s中
45 False    
46 >>> s.union(t)            #返回一个新的set包含s和t中的每一个元素
47 set(['x', 'e', 'l', 'o'])
48 >>> s | t
49 set(['x', 'e', 'l', 'o'])    
50 >>> s.intersection(t)    #返回一个新的set包含s和t中的公共元素
51 set([])
52 >>> s&t
53 set([])    
54 >>> s.difference(t)        #返回一个新的set包含s中有但是t中没有的元素
55 set([])
56 >>> s - t
57 set([])    
58 >>> s.symmetric_difference(t)    #返回一个新的set包含s和t中不重复的元素
59 set(['x', 'e', 'l', 'o'])
60 >>> s ^ t
61 set(['x', 'e', 'l', 'o'])    
62     >>> s.copy()            #返回set “s”的一个浅复制
63 set([]) 

在磁盘上读写文件的功能都是由操作系统提供的，现代操作系统不允许普通的程序直接操作磁盘，所以读写文件就是请求系统打开一个文件对象（通常称为文件描述符），然后，通过操作系统提供的接口从这个文件对象中读取数据（读文件），或者把数据写入这个文件对象（写文件）    
以读取的模式打开一个文件对象，使用open内置的open()函数，传入文件名和标识符：

1 >>> f = open('E:/python/test.txt', 'r')
 2 标识符'r'表示读，这样，就打开了一个文件，如果不存在就提示
 3 >>> f = open('test.tx', 'r')    #不存在有一个IOError错误说不存在这个文件
 4 Traceback (most recent call last):
 5   File "<stdin>", line 1, in <module>
 6 IOError: [Errno 2] No such file or directory: 'test.tx'
 7 >>> f.read()    #正确打开后要掉用read()方法可以一次读取文件所有内容，python把内容读到内存，
 8 'hello word'
 9 >>> f.close()    #是关闭文件，使用完毕后必须关闭文件，因为文件对像会占用操作系统的资源，并且操作系统在同一时间打开的文件数量是有限的：
10 如果总是忘记关闭文件可以使用python引用的with语句来自动调用close()
11  with open('path/to/file',) as f:
12      print f.read() 

这样代码更简洁，并且不必调用f.close()方法，这里的open()和file()是一样的，属于别名关系。
如果文件过大可以使用read(size)，每次最多读取size个字节的内容，readline()可以每次读取一会内容，调用readlines()一次读取所有内容并按行返回list。     
如果文件小可以多次使用read(size)
如果是配置文件用readlins()最方便

1、写文件
对文件进行操作的语法

#-*-coding:utf-8-*-
f = file('MyNewfile.txt,''w')  #'w'代表以写模式创建一个新文件
f.write('This is frist line\n')    #往文件里写内容
f.write('second line\n')
f.close()
#上面的写是指重新建一个文件，如果有MyNewfile.txt这个文件会把原来的文件冲掉 

2、追加

3、修改内容
#找到文件
文件路径
#打开文件
file open
#文件操作
r读 w写 a追加 r+读写 w+读写打开

1 file_obj.read()        #将所有读入内存
2 file_obj.readlines()    [行,] #以列表的形式显示出来
3 for line in file_obj.xreadlines():
4     print line
5      
6 for line in file_obj:
7     #每次循环，只读一行 

4、文件关闭

1 file_obj.close()