昨天辭職了，在KDS的這一段時間確實提高了不少。趁著辭職后還有段空閑期，準備將Python數據分析這一塊繼續學習學習。然后把組成原理和計算機網絡學習一遍，為以后的發展打下基礎，然后準備繼續學習C++.

Python的一個簡單review

Python重要特點就是對象模型的一致性,Python解釋器中的任何數值,字符串,數據結構,函數,類,模塊，都是一種Python對象,每個對象都有一個與之相關的類型比如字符串和函數以及內部數據，幾乎所有的Python對象都有一些附屬函數,也就是方法,他們可以訪問對象內部的數據，函數既可以接受位置參數,也可以接受關鍵字參數

在Python中對變量賦值的時候,其實是創建等號右側對象的一個引用

a = [1,2,3]
b = a
#這樣a,b都指向同一個對象
a.append(4)
print b```
賦值操作也稱為綁定,將一個名稱和一個對象綁定到一起
當將對象以參數的形式傳入函數的時候,其實是傳遞了一個引用,不會發生任何復制，Python是按引用傳遞的

def append_element(some_list,element):
some_list.append(element)
append_element(a,5)
print b```

Python中的對象引用沒有與之相關聯的類型信息,變量其實就是對象在特定命名空間中的名稱，對象的類型信息是保存在它自己內部的，Python可以被認為是一種強類型語言，所有對象都有一個特定的類型,隱式轉換只在很明顯的情況下才會發生

print type(a)
#isinstance函數來檢查對象是否是某個特定類型的
print isinstance(a,list)
#可以制定元組,檢查某個對象的類型是否屬于元組中指定的類型
print isinstance(a,(list,int))```

Python中的對象既有屬性,存儲在該對象內部的其他Python對象
又有方法,與該對象有關的能夠訪問其內部數據的函數
getattr函數,hasattr函數和setattr函數

一般來說只關注這個對象有沒有某些方法或者行為
比如實現了迭代器協議的就是可迭代的,__iter__方法
使用iter函數來判斷是否可迭代

def isiterable(obj):
try:
iter(obj)
print "True"
except:
print "False"

isiterable(a)
isiterable(a[1])

檢查是不是列表,如果不是列表將其轉換為列表

if not isinstance(a,list) and isiterable(a):
a = list(a)```

判斷兩個引用是否指向同一個對象,可以使用is,或者is not

print a is b
#但是list函數會創建新列表
c = list(a)
print c
print a is c
#==表示比較兩個對象是否相等,如果是列表,就是列表中每個元素相比較
c.append(6)
print a == c```

Python中,計算過程和表達式都是立即求值的
但是迭代器和生成器可以實現延遲計算,特別應用于數據密集型計算

大部分Python對象是可變的,列表,字典,數組
字符串和元組是不可變的

除后圓整運算符//,Python2中,3/2仍然是一個整數

print 3 // 2
print 3/2

復數的虛部是j表示的

print 1 + 2j```

許多Python對象可以用str函數將其轉換為字符串
字符串可以被當作序列類型進行處理
在字符串的左邊加上r表示按照原本的樣子進行解釋
None是NoneType的一個實例

from datetime import datetime,time,date
#獲得datetime實例
dt = datetime(2016,8,12,20,21,32)
print dt,dt.year,dt.day,dt.month,dt.hour,dt.minute,dt.second
#獲取date對象,time對象
print dt.date()
print dt.time()
#strftime將datetime對象格式化為字符串,這個是方法
print dt.strftime('%m/%d/%y %H:%M')
#字符串通過strptime函數轉換為datetime對象,記得這個是函數,后面指定格式
print datetime.strptime(dt.strftime('%m/%d/%y %H:%M'),'%m/%d/%y %H:%M')
#使用replace方法將某些字段進行替換
print dt.replace(minute=0,second=0)
#兩個datetime對象的差會產生一個datetime.timedelta類型
dt2 = datetime(2011,11,23,22,33)
delta = dt2 - dt
print delta,type(delta)```

if elif else
for循環用于對集合或者迭代器進行迭代

異常捕獲

except ValueError:

或者異常類型組成的元組,可以捕獲多個異常

except (TypeError,ValueError):

只希望不管try成功與否都能執行,finally:

在try成功時候運行,else:```

print range(10)
print range(1,10,2)
#包含前端,不包含后端
#xrange不會預先產生所有的值,而是返回一個用于逐個產生整數的迭代器
sum = 0
for i in xrange(10000):
    if i % 2 == 0:
        sum = sum + i
print sum

print 'Non-negative' if sum >= 0 else "Negative"```

要精通Python的數據結構

創建元組

tup = 4,5,6
print tup
nested_tup = (1,2,3),(5,6)
print nested_tup

通過調用tuple函數,任何序列或者迭代器都可以被轉換成元組

print tuple([2,3,4])

如果對元組型變量表達式進行賦值,Python就會將等號右面的值進行拆包

a,b,c = tup
print a,b,c

嵌套元組也可以拆包

tup = 4,5,(6,7)
a,b,(c,d) = tup
print a,b,c,d

交換變量名

a,b = b,a
print a,b

元組的count方法,計算指定值的出現次數

a = (1,2,3,2,2,3,4,5)
print a.count(2)```

列表
是可變的,通過[]或者list函數定義

#append方法,insert方法將元素插入到列表指定位置
b_list = [1,2,3]
b_list.insert(0,5)
print b_list
#pop方法用于移除并返回指定索引處的元素
print b_list.pop(2)
#remove方法按值刪除元素,找到第一個符合要求的值然后從列表中刪除
b_list.remove(3)
print b_list
#使用in判斷列表中是否有某個值
print 2 in b_list
#+合并列表
#extend方法一次性添加多個元素
b_list.extend(list((3,4,5)))
print b_list
#extend方法會比直接合并效率高很多
#排序sort,就地排序
b_list.sort()
print b_list
#sort()方法可以接受一個能夠產生排序的值的函數
def bijiao(obj):
    return obj+10
b_list.sort(key=bijiao)
#bisect模塊實現了二分查找及對有序列表的插入操作
import bisect
c = [1,2,2,2,3,4,5,8]
#該函數找出應該插在列表哪里才能保證有序性
print bisect.bisect(c,6)
#insort函數將新元素插入列表中
bisect.insort(c,6)
print c```

切片

start和stop是可以省略的,默認是序列開始和結尾處

print c[:5]

負數索引從序列的末尾開始切片

stop的位置不能比start晚出現否則是空

c[-4:]表示到序列結尾處

print c[-1:-3]

如果要反序的話

print c[::-1]

或者reverse方法

c.reverse()
print c

或者reversed函數

reverse_list = []
for i in reversed(c):
reverse_list.append(i)
print reverse_list```

內置的序列函數

#enumerate()
for index,value in enumerate(c):
    print "It's index:"+str(index)
    print "It's value:"+str(value)
#sorted函數將任何序列返回為一個新的有序列表
print sorted(c)
#zip()函數將多個序列配對,產生新的元組列表
seq1 = ['one','two','three']
seq2 = ['foo','bar','baz']
for index,(a,b) in enumerate(zip(seq1,seq2)):
    print '%d:%s,%s' %(index,a,b)
#對已經壓縮的序列進行解壓
pitchers = [('Nolan','Ryan'),('Roger','Clemens')]
firstname,lastname = zip(*pitchers)
print firstname,lastname```

字典

d1 = {"a":'some_value','b':[1,2,3,4]}
print d1

keys和values方法分別用于獲取鍵和值的列表,會以相同的順序來輸出鍵和值

for key,value in zip(d1.keys(),d1.values()):
print key,value

del刪除特定的值,pop刪除指定值將其返回

d1.pop('a')
print d1

使用update方法,一個字典可以被合并到另外一個字典中

d1.update({'c':"foo",'d':12})
print d1```

建立字典

key_list = range(5)
value_list = reversed(range(5))
mapping = {}
for key,value in zip(key_list,value_list):
    mapping[key] = value
print mapping
#另一種方法使用dict函數
mapping1 = dict(zip(range(5),reversed(range(5))))
print mapping1

#dict的get和pop方法可以接受一個可以返回的默認值
value = mapping1.get(6,"no key")
print value
value1 = mapping1.pop(7,"no key")
print value1

#setdefault方法
words = ["apple","bat","bar","atom"]
by_letter = {}
for word in words:
    letter = word[0]
    if letter not in by_letter:
        #第一次初始化列表
        by_letter[letter] = [word]
    else:
        by_letter[letter].append(word)
print by_letter
#使用下面更簡單的方法
by_letter1 = {}
for word in words:
    letter = word[0]
    by_letter1.setdefault(letter,[]).append(word)
print by_letter1
#另外一個使用collections模塊的defaultdict的類
from collections import defaultdict
by_letter2 = defaultdict(list)
for word in words:
    by_letter2[word[0]].append(word)
print by_letter2

#鍵值必須是不可變的,也即是可哈希的
print hash('a')
#如果要將列表當作鍵,將其轉換為元組
d = {}
d[tuple([1,2,3])] = 5
print d```

集合
集合是由唯一元素組成的無序集,{}或者set()

列表推導式

strings = ['a','as','asd','bat']
print [x.upper() for x in strings if len(x) > 2]

字典推導式

print {key:value for value,key in enumerate(strings)}
print dict((key,value) for value,key in enumerate(strings))

扁平化

some_tuples = [(1,2,3),(4,5,6)]
flattened = [x for tup in some_tuples for x in tup]
print flattened
print [[x for x in tup] for tup in some_tuples]```

函數
關鍵字參數必須位于位置參數之后,可以任何順序指定關鍵字參數
雖然可以在函數中對全局變量進行賦值操作,但是那些變量必須用global關鍵字聲明為全局

a = None
def bind_a_variable():
    global a
    a = []
#仍然是None
def bind_a_variable1():
    a = 1
bind_a_variable1()
print a

#返回多個值,可以才用字典,可以才用元組

#匿名函數
eqiv_anon = lambda x:x*2
print eqiv_anon(2)
#這種函數對象本身是沒有提供名稱屬性的```

閉包
由其他函數動態生成并返回的函數,被返回的函數可以訪問其創建者的局部命名空間的變量

def make_closure(a):
def closure():
print "I dont know "+str(a)
return closure
closure = make_closure(5)
closure()

特點就在于即使創建者已經執行完畢,閉包依然能夠訪問其創建者的局部命名空間```

函數的位置和關鍵字參數是分別被打包成元組和字典的,函數實際接受到的是一個元組args
和一個字典kwargs

部分參數應用

def add_numbers(x,y):
    return x+y
add_five = lambda y:add_numbers(5,y)
#使用functools模塊的partial函數將此簡化
from functools import partial
add_five1 = partial(add_numbers,5)```

生成器,一種函數
普通函數執行后會返回單個值,但是生成器每返回一個值后暫停,直到下一個值被請求時再繼續
要創建一個生成器,將return換成yield就行

def squares(n=10):
for i in range(1,n+1):
yield i ** 2

直到從生成器請求元素時,它才會執行其代碼

for i in squares():
print i,

生成器表達式

gen = (x**3 for x in range(10))

需要迭代才能使用

for x in gen:
print x,

生成器表達式可以用于任何接受生成器的Python函數

print list(x ** 2 for x in range(10))
print dict((i,i**2) for i in range(5))```

文件和操作系統
open函數,r,a,w,
with
seek,tell,read字符串方式返回文件數據,readlines返回行列表,write