一、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 -*-
coding:utf-8
7、爲了不用python 腳本的方式需要編碼聲明
#!/usr/bin/env python
註釋：“#”單行註釋，多行註釋“""" """”
模塊：
1、import sys
使用了argv模塊，sys.argv 用來捕獲執行執行python腳本時傳入的參數，倒入之後會生成pyc，python執行主要看文件的和pyc是否一樣如果一樣優先級是pyc，不一樣是文件
2、import getpass模塊 輸入密碼不顯示，隱藏所輸入的內容
pwd = getpass.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模塊
三、循環
"=="是兩個值之間的對比,
流程控制
if elif....elif....else: if else:
四、數值
兩部分：
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 %("alex",13) ＃按照佔位符的順序
'i am alex 13'
##################################################################################################
>>> name = "i am {0},age{1}"
>>> name.format("alex",14)
'i am alex,age14'符號：＇＇ ＂＂ ＂＂＂ 前兩種是單行 後一個是多行，三個引號可以做字符串也可以做註釋。
1、切片
>>> name = "alex" >>> print name[0:] ＃下標識從０開始的 alex >>> print name[0:2] ＃最後一個不顯示 al >>> print name[-1] ＃最後一個 x >>> print name[:-1] ＃從最後一個開始 ale >>> print name[:-2] ＃左邊顯示右邊不顯示 al >>> print len(name) ＃多少個字符 4
移除空白
>>> name = " alex" >>> print name alex >>> print name.lstrip() ＃去掉左邊空格 alex >>> name = " alex " >>> print name.rstrip() ＃去掉右邊空格 alex >>> print name.strip() ＃去掉兩邊的空格 alex
2、索引：
索引 （-1），
查看元素的個數len（）
>>> shopping_list = ['Iphone', 'Mac', 'Bike','Coffee','Car','Clothes','Food','Gi ft'] >>> shopping_list ['Iphone', 'Mac', 'Bike', 'Coffee', 'Car', 'Clothes', 'Food', 'Gift'] >>> len(shopping_list) 8
以下是索引實例：
>>> shopping_list = ['Iphone', 'Mac', 'Bike','Coffee','Car','Clothes','Food','Gift'] #創建一個列表 >>> shopping_list ['Iphone', 'Mac', 'Bike', 'Coffee', 'Car', 'Clothes', 'Food', 'Gift'] #顯示列表 >>> shopping_list[0] #輸出列表的第一個元素 'Iphone' >>> shopping_list[2] #輸出列表的第二個元素，是從0開始的 'Bike'
3、字符串（str）
重新開闢空間
4、列表（list）
修改後內存地址不變
>>> name = ['alex','hello','word']
>>> name_list = ['alex','hello','word']
>>> name_list
['alex', 'hello', 'word']
>>> name_list.append('day') ＃添加
>>> name_list
['alex', 'hello', 'word', 'day']
=============================================================
>>> del name_list[0] ＃刪除，
>>> del name_list[0:3] ＃刪除索引0到3，不包括3
或
>>> name_list
['alex', 'hello', 'word', 'day']
>>> name_list.remove('ales') ＃刪除alex，如果有多個alex，那會刪除從左邊開始第一個alex。
>>> name_list
['hello', 'word', 'day']
=============================================================
>>> name_list.insert(2,"alex") #插入
>>> name_list
['hello', 'word', 'alex', 'day']
>>> name_list[3] = 'world' #修改
>>> name_list
['alex', 'hello', 'alex', 'world']
========================================================
>>> '_'.join(name_list) #連接根據單引號的符號連接兩個元素之間的
'alex_hello_alex_world''_'.join（列表）
>>> name_list
['alex', 'hello', 'alex', 'world']
>>> name_list.index('alex') #返回列表的索引值，如果有多個返回第一個值
0
>>> name_list.index('world')
3
=============================================================
>>> name_list.count('alex') #統計索引值
2
>>> name_list.count('world')
1
>>> name_city = ['henan', 'hebei', 'wubei']
>>> name_list.extend(name_city) #合併兩個表
>>> name_list
['alex', 'hello', 'alex', 'world', 'henan', 'hebei', 'wubei']
=============================================================
>>> name_list
['alex', 'hello', 'alex', 'world', 'henan', 'hebei', 'wubei']
>>> name_list.sort() #將列表排序，根據26個字符的順序
>>> name_list
['alex', 'alex', 'hebei', 'hello', 'henan', 'world', 'wubei']
=============================================================
>>> name_list.reverse() #將列表反轉排序
>>> name_list
['wubei', 'world', 'henan', 'hello', 'hebei', 'alex', 'alex']
=============================================================
>>> for i in name_list: #遍歷列表
... print i
...
wubei
world
henan
hello
hebei
alex
alex列表的增刪改：只是對於列表的最小單元
五、元組（tuple）
元組是另外一種序列表，一旦初始化不允許修改，在表示只有一個元素的元組裏，也要價格“,”避免誤解成數學計算意義
注：元祖不可修改，列表可以修改
1、循環
for ele in 列表 continue ＃本次循環不再繼續 break ＃跳出循環 while 條件
六、字典（Dict）
dict，字典是使用鍵值對（key-value）的形式存儲數據，key是唯一的，所以可以定位到數據。相對應的就是value
字典特點：
1、key-value格式，key是唯一的
2、字典是無序的相比列表
3、查詢速度很快，是基於hash表的原理實現的，根據關鍵字（Key value）而直接訪問在內存存儲位置的數據結構。
字典和列表的區別：字典是通過key來定位相應的value，避免浪費空間不會對數據位置記錄。列表是通過索引來定位相應元素，所以列表有序
person.keys() #所有keys person.values() #所有values person.items() #所有元素，僅for循環時，使用，將元素賦值給keys person.items() for k,v in person.items() print k print v print '============='
dict語法：
>>> class_name = {
'name':'toy',
'job':'IT',
'age':12,
}
或者
>>> class_name = {'name':'toy', 'job':'IT', 'age':12,}
>>> class_name
{'age': 12, 'job': 'IT', 'name': 'toy'}
=============================================================
>>> class_name['age'] #查看key爲age的value
12
>>> class_name['age'] = 19 #將key的value改爲“19”
>>> class_name
{'age': 19, 'job': 'IT', 'name': 'toy'}
=============================================================
>>> class_name['company'] = 'AUTOHOME' #在dict中查找key爲“company”，將其改成“AUTOHOME”，如果沒有就創建一條
>>> class_name
{'age': 19, 'job': 'IT', 'company': 'AUTOHOME', 'name': 'toy'}
=============================================================
>>> class_name.pop('company') #刪除key爲“company”的數據
'AUTOHOME'
>>> class_name
{'age': 19, 'job': 'IT', 'name': 'toy'}
>>> class_name.popitem( ) #隨機刪除一條數據，dict爲空時用此法會報錯
('age', 19)
>>> class_name
{'job': 'IT', 'name': 'toy'}
>>> class_name.items() #將dict的key和value轉換成列表的形式顯示
[('job', 'IT'), ('name', 'toy')]
=============================================================
>>> class_name['age'] #查找一個不存在的key
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
KeyError: 'age'
>>> class_name.has_key('name') #判斷dict裏是否有一個’name‘的key，有True，否則False
True
>>> class_name.has_key('gae')
False
>>> class_name.get('age') #查找key，如果存在則返回其value，否則None
>>> class_name.get('name')
'toy'
=============================================================
>>> class_name
{'job': 'IT', 'name': 'toy'}
>>> class_name.clear() #清空dict
>>> class_name
{}
=============================================================
>>> class_name =class_name.fromkeys(['a', 'b', 'c', 'd'],'helo') #根據列表來創建dict裏的key，後面的“helo”是默認的value，如果不指定的話則爲None
>>> class_name
{'a': 'helo', 'c': 'helo', 'b': 'helo', 'd': 'helo'}
>>> class_name.setdefault('e','helo') #找一個key爲’e‘的記錄，如果不存在，就重新穿件key爲“e”，vlaue爲“helo”，如果存在直接返回這個key的value
'helo'
>>> class_name.setdefault('c','h') #dict的key裏有“c”，直接返回“c”的value。
'helo'
>>> class_name
{'a': 'helo', 'c': 'helo', 'b': 'helo', 'e': 'helo', 'd': 'helo'}
=============================================================
>>> dict2 = {'f':'test', 'g':'test', 'h':'test'} #創建一個新的dict
>>> class_name.update(dict2) #用新的dict去更新class_name，如果dict中的key值和class_name中的key值衝突，dict的key值會覆蓋掉class_name的key值，不存在會創建相應記錄
>>> class_name
{'a': 'helo', 'c': 'helo', 'b': 'helo', 'e': 'helo', 'd': 'helo', 'g': 'test', 'f': 'test', 'h': 'test'}七、遍歷 dict
遍歷dict和遍歷列表差不多，只是dict是key-value結構，同時打印key和value，需要這樣寫：
=============================================================
class_name = {
'name': 'tom',
'age': 19,
'job': 'IT'
}
for item in class_name:
print item,class_name[item] #打印key和value
輸出key和value
job IT
age 19
name tom
或者
for key,val in class_name.items(): #同時打印key和value
print key,val
=============================================================
for item in class_name:
print item #只會打印key
job
age
name
=============================================================默認是把字典轉換成一個大列表，並把沒對key-value值轉換成元組，所以每次循環時賦2個變量進去，因爲循環的數據格式如下：[('name','tom'),('age','19'),('job','IT')]
因此每循環一次，就是把相應元組中的2個值賦值key,val這兩個變量打印。
八、深潛 copy
dict裏套接dict，value可以是一個列表，也可以是任何數據類型。但是key不可以，必須保證key的唯一性。
>>> staff_contacts = {
... 0023:{'name':'tom', 'age':18, 'job':'IT', 'phone':3456},
... 3951:{'name':'Bob', 'age':19, 'job':'PHP', 'phone':5563},
... 5342:{'name':'Com', 'age':20, 'job':'IOS', 'phone':2942},
... }
>>> staff_contacts
{19: {'job': 'IT', 'phone': 3456, 'age': 18, 'name': 'tom'}, 5342: {'job': 'IOS'
, 'phone': 2942, 'age': 20, 'name': 'Com'}, 3951: {'job': 'PHP', 'phone': 5563,
'age': 19, 'name': 'Bob'}}
=============================================================
>>> contacts2 = staff_contacts
>>> staff_contacts[0023]['age'] = 38
>>> print 'staff_contacts:',staff_contacts[0023]
staff_contacts: {'job': 'IT', 'phone': 3456, 'age': 38, 'name': 'tom'}
>>> print 'contacts2:', contacts2[0023]
contacts2: {'job': 'IT', 'phone': 3456, 'age': 38, 'name': 'tom'}
>>> print 'id of staff_contacts:',id(staff_contacts[0023]) #查看兩個dict的內存地址
id of staff_contacts: 35454488
>>> print 'id of contacts2:',id(contacts2[0023])
id of contacts2: 35454488#第一個dict複製給另外一個dict的時候，修改其中一個dict，另外一個dict也跟着修改，而且兩個dict的內存地址一樣。對於字符串、數字等一些簡單的數據類型，python會重新開闢一塊空間，但是對於dict、list、tuple以及下面的set集合，python會像軟鏈接一樣，無論是修改原來的dict還是現在的dict，都是修改的同份數據，所以纔會出現上面的情況，這樣做的目的是爲了節約內存。
如果要想讓copy出來的數據不跟着改變，就需要用copy語句
>>> contacts2 = staff_contacts.copy()
用幫助來查看這個語法的解釋：
>>> help(staff_contacts.copy)
Help on built-in function copy:
copy(...)
D.copy() -> a shallow copy of D
a shallow copy就是淺copy的意思
>>> staff_contacts = {
...
... 0023:{'name':'Alex Li','age':29,'department':'IT','phone':3423},
... 3333:'nothing'
... } #重新建一個dict
>>> contacts2 = staff_contacts.copy() #淺copy
>>> staff_contacts[0023]['age'] = 28 #修改dict的兩個值
>>> staff_contacts[3333] = 'change this by original dict'
>>> contacts2
{19: {'department': 'IT', 'phone': 3423, 'age': 28, 'name': 'Alex Li'}, 3333: 'n
othing'}
>>> staff_contacts
{19: {'department': 'IT', 'phone': 3423, 'age': 28, 'name': 'Alex Li'}, 3333: 'c
hange this by original dict'}
#注經過淺copy之後，3333已經是兩個數據已經獨立了，而age還是共享內存數據，這個就是淺copy九、深 copy
深copy就是不管下面有多少層都copy了
語法
>>> import copy
>>> contacts2 = copy.deepcopy(staff_contacts)
>>> contacts2
{19: {'department': 'IT', 'phone': 3423, 'age': 28, 'name': 'Alex Li'}, 3333: 'c
hange this by original dict'}
>>> staff_contacts
{19: {'department': 'IT', 'phone': 3423, 'age': 28, 'name': 'Alex Li'}, 3333: 'c
hange this by original dict'}
#深copy之後所有的值都會copy過來。十、集合 set
python的set是一個無序不重複元素集，基本功能包括關係測試和消除重複元素。集合對象還支持union（聯合）、intersection（交）、difference（差）和sysmmetric difference（對稱差集）等數學運算。
sets支持 x in set, len(set),和 for x in set.作爲一個無序的集合，sets不記錄元素位置或者插入點。因此，sets不支持 indexing,slicing，或其他類序列（sequence-like）的操作
基本語法
>>> s = set([3,5,9,10]) #數字集合
>>> t = set("Hello") #字符集合
集合是無序的，與列表和元祖不同，也不能數字進行索引，集合的元素不能重複
>>> t
set(['H', 'e', 'l', 'o']) #這裏只出現了一個“I”
集合支持一系列標準操作，包括並集、交集、差集和對稱差集，
>>> a = t | s #t和s的並集
>>> a
set([3, 'e', 5, 'H', 10, 'l', 'o', 9])
>>> b = t & s #t和s的交集
>>> b
set([])
>>> c = t -s #求差集（項在t中，但不在s中）
>>> c
set(['H', 'e', 'l', 'o'])
>>> d = t ^ s #對稱差集（項在t或s中，但不會同時出現在二者中）
>>> d
set([3, 'e', 5, 9, 10, 'l', 'o', 'H'])
>>> t.add('x') #添加
>>> t
set(['H', 'e', 'l', 'o', 'x'])
>>> s.update([11,12,13]) #添加多項
>>> t.remove('H') #刪除，如果不存在報錯KeyError
>>> t
set(['e', 'l', 'o', 'x'])
>>> len(s) set的長度
7
#######################################################
x in s #測試x是否是s的成員 #
x not in s #測試x是否不是s的成員 #
#######################################################
>>> s.discard(5) #如果在set “s”中存在元素5，則刪除
>>> s
set([9, 10, 11, 12, 13])
>>> s.pop() #刪除並且返回set “s”中一個不確定的元素，如果爲空則報錯KeyError
9
>>> s
set([10, 11, 12, 13])
>>> s.clear() #刪除set “s”中的所有元素
>>> s
set([])
>>> s.issubset(t) s<= t #測試是否s中的每個元素都在t中
True
>>> s.issuperset(t) s>= t #測試是否t中的每個元素都在s中
False
>>> s.union(t) #返回一個新的set包含s和t中的每一個元素
set(['x', 'e', 'l', 'o'])
>>> s | t
set(['x', 'e', 'l', 'o'])
>>> s.intersection(t) #返回一個新的set包含s和t中的公共元素
set([])
>>> s&t
set([])
>>> s.difference(t) #返回一個新的set包含s中有但是t中沒有的元素
set([])
>>> s - t
set([])
>>> s.symmetric_difference(t) #返回一個新的set包含s和t中不重複的元素
set(['x', 'e', 'l', 'o'])
>>> s ^ t
set(['x', 'e', 'l', 'o'])
>>> s.copy() #返回set “s”的一個淺複製
set([])十一、文件操作
在磁盤上讀寫文件的功能都是由操作系統提供的，現代操作系統不允許普通的程序直接操作磁盤，所以讀寫文件就是請求系統打開一個文件對象（通常稱爲文件描述符），然後，通過操作系統提供的接口從這個文件對象中讀取數據（讀文件），或者把數據寫入這個文件對象（寫文件）
以讀取的模式打開一個文件對象，使用open內置的open()函數，傳入文件名和標識符：
>>> f = open('E:/python/test.txt', 'r')
標識符'r'表示讀，這樣，就打開了一個文件，如果不存在就提示
>>> f = open('test.tx', 'r') #不存在有一個IOError錯誤說不存在這個文件
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
IOError: [Errno 2] No such file or directory: 'test.tx'
>>> f.read() #正確打開後要掉用read()方法可以一次讀取文件所有內容，python把內容讀到內存，
'hello word'
>>> f.close() #是關閉文件，使用完畢後必須關閉文件，因爲文件對像會佔用操作系統的資源，並且操作系統在同一時間打開的文件數量是有限的：
如果總是忘記關閉文件可以使用python引用的with語句來自動調用close()
with open('path/to/file',) as f:
print f.read()這樣代碼更簡潔，並且不必調用f.close()方法，這裏的open()和file()是一樣的，屬於別名關係。
如果文件過大可以使用read(size)，每次最多讀取size個字節的內容，readline()可以每次讀取一會內容，調用readlines()一次讀取所有內容並按行返回list。
如果文件小可以多次使用read(size)
如果是配置文件用readlins()最方便
for line in f.readlines(): print(line.strip()) #把末尾的‘\n’刪除
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、追加
f = file('MyNewfile.txt','a') #追加模式打開文件,如果a追加的文件不存在就會新建一個
f.write('This is third line,added in append mode\n')
f.close()3、修改內容
#找到文件
文件路徑
#打開文件
file open
#文件操作
r讀 w寫 a追加 r+讀寫 w+讀寫打開
file_obj.read() #將所有讀入內存 file_obj.readlines() [行,] #以列表的形式顯示出來 for line in file_obj.xreadlines(): print line for line in file_obj: #每次循環，只讀一行
4、文件關閉
file_obj.close()