一. 腳本格式，編程風格及數據基本介紹
一. python 腳本格式
前2行格式如下，第一行是表示用python執行，第二行是通用字符集，任何語言都能正常顯示。
1)#！/usr/bin/env python
2)#_*_coding:utf-8_*_ （貌似寫成#coding=utf-8也行）
其實上面的語句怎么寫都行，只要符合coding[ := ]\s*([-\w.]+); 意思就是coding后面要緊緊的跟着冒號或者等號，之后可隨意多少個空格，然后接utf-8，coding=utf-8前后隨意加字符都行。
\w匹配的是能組成單詞的字符
\s表示空格
3)第三行最好用雙引號來寫一個腳本文檔，來對此腳本做解釋
"......."
4)多行注釋，三個雙引號開頭，三個雙引號結尾。
"""
......
......
"""
注意，第一行很多人會寫成#!/usr/bin/python，如果是系統默認有的python這樣寫是沒錯的，但是如果你升級了一個python，那么這個新版的python可能就會安裝在usr/local/bin目錄下，如果加上env，就會直接使用 新版的python，因為新裝的python會自動寫在env中。
2017/8/11 15:03
二. 編程風格
1. 語法要求，縮進統一： 屬於同一代碼塊，也就是同一級別，相互之間沒有依存關系的語言縮進必須是一致的，不然就會報錯
注意，如果是在window下用notepad寫的代碼，用tab進行縮進時，需要在notepad中進行tab建和空格鍵的轉換設置，在首選項中可設置。
2. 變量由字母，下划線，數字組成
標識符的
第一個字符必須是
字母（大小寫都行）或者一個
下划線
標識符的其他部分可以由字符（大小寫）*，下划線或數字（0-9）組成。
無效的標識符例子有 2things; this is a man; my-name
3.python編譯過程--腳本解釋型語言
在運行腳本之后，得到結果之前
1)python先將腳本編譯成字節碼（pyc,pyo)
腳本中只要import 函數，就會生成pyc文件
2)python虛擬機解釋並運行字節碼文件
C語言--編譯型語言的內部機制
1）先將源代碼編譯成機器碼，生成可執行文件
2）運行可執行文件
4，動態語義--在賦值時確定數據類型
例如 a=5 b=string, 那么用type(a)=int; type(b)=string
5. python之禪
進入python，輸入import this 會看到
2017/8/14/周一
三. python一切數據皆為對象
包含了一系列的數據和操作這些數據的方法的一個整體，就叫作對象。
一切變量都是對數據對象的引用
1. python內部的引用計數，sys.getrefcount
import sys
a='hello'
sys.getrefcount('hello')
輸出為3---python中初始數為3
e='hello'
sys.getrefcount('hello')
輸出為4
a=1
sys.getrefcount('hello')
輸出為3,說明引用被銷毀一次。
2.數據類型的組成
組成分為3部分。
身份： id方法來看一看他的唯一標示符，內存地址靠這個哦！
類型 ：type來看一看。
值： 表示數據項。
某書里的傲嬌結論：python里一切都是指針，所以不用再考慮指針這個問題了！
3. 常用基本數據類型.
int 整型
boolean 布爾
a=True
b=False
注意：布爾值首字符必須大寫
string 字符串
list 列表
tuple 元祖
dict 字典
4.數據類型的可變和不可變，意思就是如果變量的值改變后，id值是否改變
不可變類型：int，string，tuple
例如a = 5，看一下id值；然后a = 6, 再看一下id值，2個值是不同的
可變類型: list，dict
例如a = [1,2,3]
a.append(4),此時a=[1,2,3,4];但是改變前后，a的id值是不變的
5.如果給一個變量賦值后，它的數據類型就確定了，不能再隨意改變
比如a="4",此時不能在進行a+1的運算，因為"4"和1不是一個數據類型，不能計算。如果想計算，需要先把字符串a轉變為整型，方法就是int(a)+1.
二. 字符串認知與應用
認知1.字符串概念
認知2.ascii unicode utf8到底是啥
一 . len()
len:全寫是length,是計算容量的函數；例如a = "1234", len(a)=4
如果是中文字符，比如a = "哈", len(a)=3, 那么怎么顯示正確的數目呢？
（在python3中不存在這個問題)
方法一：
在中文字符前加u 例如：a = u"哈" ,len(a)值為1
方法二：
a ="哈哈"
g = a.decode('utf-8')
print len(g)值為2
也可以直接寫成 a = "哈哈".decode('utf-8'), 其實最好是a.decode('utf-8')
注意:
就是在腳本中標明#coding=utf-8，len的值還是按ascii碼來計算
比如
#coding=utf-8
d = "中文"
print len(d)
執行python test.py的值為6
二.轉義符讓文本更好處理
要轉義的字符前面加個反斜杠
三. 字符串前面跟着的小尾巴到底是什么東西
例如:
print r"\n" 其中的字母 r 表示不對 斜線 進行轉義，輸出為 \n
四. 訪問子字符串
成員有是有序排列的,可以通過下標偏移量訪問到它的一個或者多個成員
a = "abcd"
print a[0] 第一個字符
print a[-1] 最后一個字符，也可以是print a[len(a)-1]
a[0: ] 輸出為abcd
a[0:1] 輸出為a
a[0:2] 輸出為ab
a[1:3] 輸出為bc 注意第一項不是0，那么
輸出項是從a[1]開始的3-1位，並不會輸出a[3]
a[:-1] 輸出為abc
五. 替換字符串--replace()方法
a = "abc"
a.replace('a','hh')
'hhbc'
但是此時print a，輸出還是abc，說明
replace()並不會改變原變量值，如果想修改原值，可以重新賦值，比如
a = a.replace("a","his")，輸出為hisbc
六.查找字符串--find()方法
a.find("hong") 如果找到了字符串"hong"會返回一個整型，這個數值是a字符串對象hong第一個字母"h"的下標 ，如果找不到"hong",會返回-1
如果有多個hong，怎么指定某一個hong呢，例如
a = "hong my name is hong"
此時用a.find("hong") 輸出結果會是0，就是從第0個字符開始的就是hong，怎么找后面的那個hong呢？
a.find("is") 輸出為13
a.find("hong",13)就會輸出is后面的hong了，注意用help(a.find)文檔
七. 字符串拼接
1.直接用加號來拼接，太耗資源，超級丑陋之千萬別用。
2.可選方案之字符串模板
用%s....%來拼接： %s表示要插入字符串，叫做占位符；%后面的字符表示要插入字符串的內容
占位符通常有2種，%s：字符串的占位符， %d：數字的占位符。
例如
1) print "my name is hong, %s" % "i am 18"
2) print "my name is %s %s" % ("hong", "ten years old")
3) print "my name is hong, i am %d" % 18
4）print "this is a %s %s" % (4,10)，輸出為this is a 4 10. 也就是說可以強制把整型轉為字符串，小括號里的數據要按順序寫
3.優秀的拼接方案之使用join()，這種方法在參數是變量的情況比較好用
>>> a = "a"
>>> b = "bcd"
>>> c = "12cd"
>>> "".join([a,b,c])
'abcd12cd'
用 [] 把abc變成一個list，才能用join()進行拼接，
直接用join(a,b,c)報錯，因為join()函數只能有一個參數
注意：
join()函數基本語法： 'sep'.join(seq)，表示以sep為分隔符，將seq所有的元素合並成一個新的
字符串
sep表示分隔符，可以為空；
seq表示要連接的元素序列，字符串，元組或者字典，也就是說上面的"".join([a,b,c])也可以把參數寫成元組 "".join((a,b,c))
4. format格式化方式
b = "this is {} {}" .format ("my","apple")為什么要用format
print b
輸出為 this is my apple
如果想調整一下輸出參數的順序，那么可以這樣寫
b = "this is {1} {0} .format ("my","apple"),那么輸出結果就是
this is apple my
需要注意的是參數從0開始
算參數位置太麻煩，有時候還出錯，來種更人性化的方法
b = "this is {whose} {fruit}" .format (fruit="apple",whose="my")
print b
輸出為this is my apple
5. 還有一個方法，字典來了。
a = "this is %(whose)s %(fruit)s" % {'whose':'my','fruit':'apple'}
其中whose:my, whose是key位，my是word位
七. 讀寫文本
1. 在指定的文件中寫入內容
d = open('a.txt','w')
d.write('hi,\nhello')
d.close()
說明：open()中的第二個參數含義
w ：write
r ：read
a ：append
2. 讀取指定文本內容
d = open('a.txt','r')
help(d) #查看對象d可使用的方法屬性，舉例說明readline(), readlines()以及read()的使用方法和區別
1)
readline()，每次讀取單行文本內容
print d.readline()
hi
print d.readline()
hello
2）
read()，一次讀取所有內容，以文本形式顯示
>>> print d.read()
hi,
hello
注意：print d.read(100),但是顯示為空，需要用d.seek(0)來調整一下讀取位置，然后再print d.read(100)就能看到全部信息量，100不夠就1000
3）
readlines()，也是一次讀取所有內容，不過是以列表的形式顯示
>>> print d.readlines()
['hi,\n', 'hello']
可用for循環顯示每行內容
for line in d.readlines():
print line
小結：
.readline() 和 .readlines() 之間的差異是后者一次讀取整個文件，象 .read() 一樣。
.readlines() 自動將文件內容分析成一個行的列表，該列表可以由 Python 的 for … in … 結構進行處理。
另一方面，.readline() 每次只讀取一行，通常比 .readlines() 慢得多。僅當沒有足夠內存可以一次讀取整個文件時，才應該使用 .readline()。
4) 使用標准庫
linecache，也可實現訪問指定文本行
a = open("tmp.txt","w")
a.write("haha\n12faf\nhong")
a.close()
如果想在python命令行中輸出上面tmp文件的第一行，第二行內容，可以如下寫。
import linecache
help(linecache)
print linecache.getline("tmp.txt",1)
print linecache.getline("tmp.txt",2)
使用這種方法的好處是不要考慮重置指針(seek函數)的問題，可隨意取任意行
2017/8/15 8:59
八. 三個符號的區別 ：一對單引號，一對雙引號，一對三個雙引號
python中單雙引號沒區別,單引號里可以寫雙引號，雙引號里也可以寫單引號
一對三個雙引號作用是格式化的輸出多行內容，而且里面的內容可以任意加單引號，雙引號等。例如
print """
author
"date"
'money'
"""
和多行注釋用法一樣
三. 列表
一. 列表基本特點
1. 有序的集合
a = [1,2,3]
2 通過偏移來索引，從而讀取數據
a[-1]輸出為3
3 支持嵌套
b = [[1,2,3],[4,5,6]]
b的輸出為[[1,2,3],[4,5,6]]
此時如果想修改2為7，方法是b[0][1] = 7
4. 可變的類型
二. 列表基本使用方法
1. 切片：
a = [1,2,3,4,5,6,7］
正向索引
a[0:4:1] 表示從0位開始去到第4位，步長為1,結果為[1,2,3,4]
反向索引
a[-1:-4:-1],取到[7,6,5] #
反向索引的步長一定要加上，並且步長要寫為負數
默認索引
a[1:], 取到[2,3,4,5,6,7]
a[1::2], 取到[2,4,6]
注意：不管是正向索引還是反向索引，索引后面的一個值，是不算在內的
2. 添加操作：
1) + 生成一個新的列表
a = [1,2,3]
b = [4,5,6]
a + b 輸出為[1,2,3,4,5,6]
2) Extend，擴展list，參數為其他列表名，結果是新元素自動融入list，類型一樣。
接受參數並將該參數的每個元素都添加到原有的列表中，
原地修改列表而不是新建列表
a.extend(b)
a的輸出為[1,2,3,4,5,6],
對比操作前后的id(a),值是不變的
3) Append :添加任意對象到列表的末端，參數為單個元素，這個元素可以是數字，也可以是list或者元組本身。
加入數字
a = [1,2,3]
a.append(4)
a的輸出為[1,2,3,4]
加入列表
a.append([3,4,5])
a的輸出為[1,2,3,4,[3,4,5]]
4) Insert:
插入任意對象到列表中，可以控制插入位置。
a.insert(1,"ab") 表示
在下標為1處加上元素“ab”
a的輸出結果是[1,"ab",2,3,4,[3,4,5]]
3. 修改：
修改列表本身只需要直接賦值操作就行。
A = [1,2,3]
A[0]=’haha’
4. 刪除操作：
1) Del ：我們通過
索引刪除指定位置的元素。
a = [1,2,3,4,5]
del a[0] #只有del是用命令del，其他都是通過 a.函數名 的方式調用實現相應功能。
a輸出為[2,3,4,5]
2) Remove：移除列表中指定值的
第一個匹配值。如果沒找到的話，會拋異常。
a.remove(4)
a.remove(6)
這里的參數4，6都是具體的列表中的實際值，而不是下標
3) Pop：返回最后一個元素，並從list中刪除它。
a.pop()，輸出為5，並刪除5
也可指定元素索引值，彈出並刪除指定元素，比如a.pop(1)，彈出並刪除數字2
5. 成員關系：
通過in， not in的方法，我們可以判斷一個元素是否在列表里。返回一個bool類型，元素在列表里返回true，否則返回fasle.
a = [1,2,3]
2 in a
True
5 in a
False
5 not in a
True
6. 列表推導式：
一般的，[expr for iter_var in iterable]
首先迭代iterable里所有內容，每一次迭代，都把iterable里相應內容放到iter_var中，再在expr中應用該iter_var的內容，最后用expr的計算值生成一個列表，。
比如我們要生成一個包含1到10的列表
方法一
[x for x in range(1,11)]
輸出為[1,2,3,4,5,6,7,8,9,10]
方法二
range(1,11)
#python2中，這種方法可以輸出1-10的列表，但是在python3只會輸出一個range類型range(1,11)
有條件的，[expr for iter_var in iterable if cond_expr]
加入了判斷語句，只有滿足條件的內容才把iterable里相應內容放到iter_var中，再在表達式中應用該iter_var的內容，最后用表達式的計算值生成一個列表。
要生成包含1到10的所有奇數列表。
方法一
range(1,11,2)
同理python2中可生成奇數列表，python3中不行
方法二
[x for x in range(1,11) if x % 2 == 1]
注意：表達式中的x都是表示一個相同的東西，我能改的只能是表達式的形式，也就是第一個x，比如改成x+1.
7. 排序和翻轉：sort,reverse
sort：這個方式會直接修改原列表，它的返回值為none，所以b = a.sort() ,print b 輸出的內容是None
例如
a = [33,11,22,44]
b = a.sort()
b的輸出結果為None,也就是什么都不輸出，可以用if語句判斷
if b is None:
print "haha"
此時再輸出a，發現a已經按順序排好，輸出為[11,22,33,44]
reverse和sort同理
b = a.reverse() #b的輸出也是None
再看a的輸出，發現a的值已經反轉了
[44,33,22,11]
2017/8/16
三. 列表常見應用
1. 內置list的方法，常用來把字符串或者元組改成列表類型
a = "asd"
list(a)
['a','s','d']
返回一個列表，參數是可迭代對象。里面輸出的內容保持了傳入的可迭代對象的元素和順序
元組轉為列表
list((1,2))
輸出為[1,2]
但是如果傳入數字，就會報錯，因為數字是不可迭代的對象
list(10)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'int' object is not iterable
2.xrange和range的區別（只在python2中使用起來有區別）
xrange(開始，結束，步長）步長省略的話，默認為1
2個函數的區別：
xrange 會生成一個xrange對象，
range直接生成一個列表對象
創建一個xrange對象
>>> a = xrange(1,10)
>>> a
xrange(1, 10)
>>> a[0]
1
>>> a[3]
4
創建一個range對象b
>>> b = range(1,10)
>>> b
[1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> b[0]
1
>>> b[3]
4
xrange的使用場合
1. 當我們需要操作一個非常大的數據，而且內存比較吃緊的時候，我們可以用xrange來操作省內存
2. xrange一般用在循環里面，比如我們只需要操作部分數據，而不是返回全部元素來完成操作，推薦使用xrange
比如
for m in range(1000):
#range()生成一個包含[0-999]的對象
if m == 10:
print "sss"
break
for m in xrange(1000): #
xrange()每一個迭代循環，只返回一個元素，只需返回[0-10],11個對象
if m == 10:
print "sss"
break
3. 列表推導式之再應用
復習例子1，取出1-100的所有值的平方
按從右向左的順序來寫，比較人性化,先寫一個1-100的序列，讓x迭代，然后左邊寫運算，最后加一個中括號
[x*x for x in range(100)]
常見應用如下
1）生成字符串
["the %s" % x for x in xrange(10)]
輸出為 ["the 0","the 1","the 2","the 3",...."the 9"]
2）生成元組
for x in range(2) 先生成一個列表，進行迭代
for y in range(2) 再生成一個列表，進行迭代
定義一個元組(x,y)
定義列表，也就是加上中括號
完整的句子就是：
[(x,y) for x in range(2) for y in range(2)]
輸出如下
[(0,0),(0,1),(1,0),(1,1)]
3）生成字典，就是上面的一個打包操作，加上dict()
dict ([(x,y) for x in range(2) for y in range(2)])
輸出如下
{0:1,1:1}
冒號左為key，右為value。
key如果相同，后面的key會覆蓋前面的key，所以前面的2個值(0,0),(0,1)只會有0:1； 后面的2個值也只會有1:1，道理一樣。
4. 小技巧之再議刪除
1）刪除列表對象的引用
>>> a = [1,2,3]
>>> b = a #
此時查看列表對象的地址,用id()查看，發現a,b的id值是一樣的，也就是引用的列表對象的存儲位置是一樣的。
>>> del a
>>> b
[1, 2, 3]
2）清空列表對象里的元素
>>> c = b
>>> del c[:]
>>> c
[]
>>> b
[]
說明：
賦值符號“=”，表示引用，表示傳址調用，他們有相同的ID號，如果修改某一個變量，另一個變量也會相應修改
[:] 表示復制，傳值調用，2個變量ID號不同，此時修改b，不會影響a的值
a = [1,2,3]
b = a[:] #這個[:]是個什么東西
del a
b的值是什么。為什么呢？
當b=a時
>>> a=[1,2,3]
>>> b=a
>>> a
[1, 2, 3]
>>> b
[1, 2, 3]
>>> id(a)
140076707413024
>>> id(b)
140076707413024
當b=a[:]時，這里生成了一個新的列表對象，b的變化，不會影響下面a的輸出。
>>> a=[1,2,3]
>>> b=a[:]
>>> a
[1, 2, 3]
>>> b
[1, 2, 3]
>>> id(a)
140076707334048
>>> id(b)
140076707335272
>>> b=[1,2,3,4]
>>> a
[1, 2, 3]
>>> b
[1, 2, 3, 4]
2017/8/17 8:52
四. 元組和集合
1. 元組是有序的集合
a = (1,2,3）
2. 通過偏移來取數據，也是通過下標來取，和列表一樣。區別就是list是可變的，元組是不可變的。
a[0] 輸出為1
a[1:3] 輸出為(2,3)
3. 屬於不可變的對象，不能在原地修改內容，沒有排序，修改等操作。
dir(a)可以看到所有支持的方法
要想修改元組，需要先把元組重新賦值給一個列表，然后修改列表元素，之后再把列表轉變給元組。方法如下
b = list(a)
b[0] = 5
type(b) 輸出為list
a = tuple(b) #生成了一個新的元組對象
a
輸出為（5,2,3）
tuple類型轉換
那為什么有列表還要有元組呢？
元組不可變的好處。保證數據的安全，比如我們傳給一個不熟悉的方法或者數據接口，確保方法或者接口不會改變我們的數據從而導致程序問題。
例子1
#encoding=utf-8
def info(a):
print "id %d" % id(a)
#a[0] = "haha" 第一個腳本完成后加這行進行測試
#return a 這行也是測試的
a = [1,2,3]
print "start-"
print id(a)
info(a)
#print a 測試用的
另外一種方法
#encoding=utf-8
def info(a):
b = a[:] #這里生成了一個新的列表對象，b的變化，不會影響下面a的輸出。
b[0] = "haha"
return a
a = [1,2,3]
print "start-"
print id(a)
info(a)
print a
二. 集合
集合是沒有順序的概念。所以不能用切片和索引操作。
1. 創建集合
set():可變的
a = set("abc")
a
輸出為set(['a', 'c', 'b'])
不可變的frozenset()：
>>> a = frozenset("abc")
>>> a
frozenset(['a', 'c', 'b'])
>>> a.add("222")
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: 'frozenset' object has no attribute 'add'
>>> a.remove("a")
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: 'frozenset' object has no attribute 'remove'
查看對象是否可迭代的方法
用dir進行查看，比如dir(a),如果輸出中有"_iter_"，說明可以進行迭代。
2. 添加操作： add，update
add函數
a.add("python")
a
輸出為
set(['a', 'python', 'c', 'b']) #"python"做為一個整體來加入。
update函數
>>> b = set("hong")
>>> b
set(['h', 'g', 'o', 'n'])
>>> b.update("python")
>>> b
set(['g', 'h', 'o', 'n', 'p', 't', 'y']) #python分開來插入，如果重復自動忽略
注意：
update的參數也可以是list，如果使用list，那么集合中新加的元素還會保持原先list中的順序。
比如c='hong'
b.update(list(c))
3. 刪除 remove
a.remove("python")
a
輸出為
set(['a', 'c', 'b'])
4. 成員關系 in,not in
"c" in a
True
"h" not in a
True
5. 交集，並集，差集 & | -
a = set('abcd')
b = set('bcdef')
a & b
set(['c','b','d'])
a | b #並集
set(['a','c','b','e','d','f'])
a - b #差集
set(['a'])
6. set去重
例子
>>> a = [1,2,3]
>>> a.append(1)
>>> a.append(3)
>>> a
[1, 2, 3, 1, 3]
>>> set(a)
set([1, 2, 3])
>>> list(set(a))
[1, 2, 3]
基礎篇12-字典
字典是無序的，它不能通過偏移來存取，只能通過鍵來存取。
例1
>>> info = {'a':1,'b':2}
>>> info
{'a': 1, 'b': 2}
可以通過鍵值返回value值
>>> info['a']
1
例2
>>> binfo = {'a':[1,2,3],'b':[4,5,6]}
>>> binfo
{'a': [1, 2, 3], 'b': [4, 5, 6]}
>>> binfo['a'][2] = 5
>>> binfo
{'a': [1, 2, 5], 'b': [4, 5, 6]} #說明字典是可變的類型。
字典 = {'key':value} key：類似我們現實的鑰匙，而value則是鎖。一個鑰匙開一個鎖
特點：
內部沒有順序，通過鍵來讀取內容，
可嵌套，方便我們組織多種數據結構，並且可以原地修改里面的內容，屬於可變類型。
組成字典的鍵必須是不可變的數據類型，比如，數字，字符串，元組等，列表等可變對象不能作為鍵.
例3
key 為數字
>>> binfo = {1:"22",2:"dd"}
>>> binfo
{1: '22', 2: 'dd'}
key為字符串
>>> cinfo = {"a":"222","b":111}
>>> cinfo
{'a': '222', 'b': 111}
key為元組，需要注意的是元組中的元素也必須是不可變類型。
>>> dinfo = {(1,2,3):'ss',('b','c'):'222'}
>>> dinfo
{('b', 'c'): '222', (1, 2, 3): 'ss'}
元組中的元素是列表
>>> xinfo = {(1,'2',[2,3]):'a'}
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'list'
key為列表
>>> finfo = {[1,2,3]:'sss'}
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'list'
1. 創建字典。{},dict()
法1
info = {'name':'lilei', 'age': 20}---------------一般情況下還是用法一好！
法2
info = dict(name='lilei',age=20)
name是key，'lilei'是value
注意：
1. 法一是用花括號，法二是用小括號；
2. 法一key和value中的字符串必須加引號；法二key的字符串可以不用加雙引號，value的字符串必須加雙引號。
3. 法一用冒號，法二用等號
2. 添加內容 a['xx'] = 'xx'
比如在法1例子的基礎上加上如下命令
info['phone'] = 'iphone5'，其中phone為key， iphone5為value
>>> info ={'name':'lilei','age':20}
>>> info
{'age': 20, 'name': 'lilei'}
>>> info['phone'] = 'iphone5'
>>> info
{'phone': 'iphone5', 'age': 20, 'name': 'lilei'}
3. 修改內容 a['xx'] = 'xx'
info['phone'] = 'htc'
update 參數是一個字典的類型，他會覆蓋相同鍵的值
在例2的基礎上做下面操作
>>> info.update({'city':'beijing','phone':'nokia'})
>>> info
{'phone': 'nokia', 'age': 20, 'name': 'lilei', 'city': 'beijing'}
4. 刪除 del,clear,pop
1）del ainfo['phone'] 刪除某個元素
>>> ainfo = {'age':22,'aa':22}
>>> ainfo
{'aa': 22, 'age': 22}
>>> del ainfo['aa'] #刪除'aa'元素
>>> ainfo
{'age': 22}
刪除ainfo的引用
>>> del ainfo
>>> ainfo
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'ainfo' is not defined
2）clear()刪除字典的全部元素
>>> a = {'info':'22','age':'34'}
>>> a
{'info': '22', 'age': '34'}
>>> a.clear()
>>> a
{}
3）pop('name')
字典的pop方法
>>> a = {'11':'aa','bb':22}
>>> a
{'11': 'aa', 'bb': 22}
>>> a.pop('bb') #傳入需要刪除目標的key，就可刪除。
22
>>> a
{'11': 'aa'}
需要注意的是，如果pop的key不存在，我們可以指定一個輸出值讓系統顯示出來，
以上面字典a為例
>>> a.pop('33')
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
KeyError: '33'
>>> a.pop('33','not exist')
'not exist'
列表的pop方法
>>> binfo = []
>>> binfo.append('22')
>>> binfo.append('234')
>>> binfo
['22', '234']
>>> binfo.pop(0) #傳的是索引下標
'22'
>>> binfo
['234']
5. in 和 has_key() 成員關系操作
例如
>>> a
{'11': 'aa', 'bb': 22}
1).in
>>> "phone" in a
False
2) a.has_key()
>>> a.has_key('11')
True
>>> a.has_key('aa')
False
3). keys(): 返回的是列表，里面包含了字典的所有鍵
>>> a.keys()
['11', 'bb']
4). values():返回的是列表，里面包含了字典的所有值
>>> a.values()
['aa', 22]
5) items()：生成一個字典的容器：------這個方法是字典轉變為list的途徑
>>> a.items()
[('11', 'aa'), ('bb', 22)].里面的每一項都是一個元組，元組第一項為key，第
二項為value
6) get：從字典中獲得一個值
>>> a.get('11') #參數為key，輸出為value
'aa'
>>> a.get('33') #key不存在，輸出為空，且為NoneType類型
>>> b = a.get('33')
>>> type(b)
<type 'NoneType'>
>>> a.get('33','not exist') #key不存在，可以指定默認輸出值
'not exist'
基礎篇13-答疑課
aa = [(2*(x/2)>>0,2*(x%2)) for x in xrange(4)] ##這里不明白
print [((x>>1)<<1,(x & 1)<<1) for x in xrange(4)] ##這里不明白
一. 先得講講二進制
0 + 1 + 1 9 +1 = 10
99 +1 = 100
2進制馮二進1
0 +1 = 1
1 +1 = 10
10 +1 = 11
11 +1 = 100
100 + 1 = 101
101 + 1 = 110
二. 難纏符號來啦
bin：把10進制轉換為2進制
例子
>>> bin(3)
'0b11'
只看0b后面的數值，就是轉換后的2進制
1.難纏符號之一 >> <<
位移，移動的是2進制的位
例子
>>> 5 >> 1
2
5的2進制是101，向右邊移動一位，結果就是10,十進制結果就是2
>>> 3 << 1
6
3的二進制是11，左移一位變為110，十進制就是6
2.難纏符號之二 &
按位與，對應位都是1結果才是1，其他都是0
1100
1000
1000
例子
>>> 10 & 20
0
10的2進制：01010 #第一位的0是補的
20的2進制：10100
發現沒有一個對應位是1的，所有結果是全0.
>>> 40 & 32
32
注意2進制轉變為10進制
>>> int(0b100000)
32
3.難纏符號之三 |
按位或,對應位只需一個為1，結果就是1
0100000
1100100
1100100
例子
32 | 100
100
4.難纏符號之四 ^
按位異或，對位相加，不進位
101
011
110
5.難纏符號之五 ~
按位取反，2進制數加1后，乘以-1
例如~5 = -6
~5=-(101+1)=-110=-6
所以
3+~5=-3
注意不能直接寫3~5，這樣是錯的
三. 其他
1.&之奇偶判定,和1進行按位與運算，結果為1就是奇數，結果為0則是偶數
5 & 1
1
4 & 1
0
2.計算硬盤容量
比如一個文件大小是11866字節，想知道有多少k，那就是向右移10位，相當於11866除以2的10次方，相應的，想知道有多少M，就向右邊移動20位。
11866 >> 10
3.真真假假不知曉
False & True & True
False
True & True & True
True
if is_boy() & is_18() & is_chinese():
print
四.回過頭來再看這道題
aa = [(2*(x/2)>>0,2*(x%2)) for x in xrange(4)] ##這里不明白
print [((x>>1)<<1,(x & 1)<<1) for x in xrange(4)] ##這里不明白
2017/8/18 9:57
基礎篇15. 答疑課之二：再議數據結構與數據類型
1.list，dict，tuple之它們其實是好基友
1.1 沒有最優秀的數據結構，只有最適用的
1.2 了解每個結構的特點才能活學活用
1.3 它們相互轉換如此簡單
list是有序的
dict是無序的，適合存儲有復雜名稱的數據，比如{"xiaoming":86},比如電話薄，班級成績單。
a = (1,2,3,4)
a = list(a) #元組轉換成list
然后把list轉變成tuple
a = tuple(a)
list轉換成字典
a = [(1,3),(2,4)]
a = dict(a)
2.“推倒式”（列表推導）與再議
[x for x in xrange[101]
第一部分 []
第二部分 x
第三部分 for x in xrange[101]
等價於
new_list = []
for x in xrange(101):
new_list.append(x) #這里的x等同於第二部分的x
print new_list
3.排序
3.1 sorted--------可以用在字符串中進行排序，會生成一個list
help('sorted')來看幫助文檔
a = [1,2,3,4]
sorted(a,reverse=True)
[4,3,2,1]
a
[1,2,3,4] #說明sorted並不是原地修改
要想修改a的值，需要賦值
a = sorted(a,reverse=True)
3.2 list之sort方法
a = [1,2,3,4]
a.sort(reverse=True)
a
[4,3,2,1] 說明內置函數sort是原地修改
sort幫助文檔中的信息
L.sort(cmp=None, key=None, reverse=False) -- stable sort *IN PLACE*;
cmp(x, y) -> -1, 0, 1
key最好用,它可以對list中的元素進行操作
例1
>>> a = ["43214","324214","82310","9231"]
>>> a.sort(key=int)
>>> a
['9231', '43214', '82310', '324214']
>>> a.sort(key=int,reverse=True)
>>> a
['324214', '82310', '43214', '9231']
例子2，按照list中元組元素的第2個數字大小進行排序
>>> a = [('a',2),('b',5),('c',4)]
>>> a.sort(key=lambda x:x[1]) #x表示每一個元組單元，x[1]表示元組中下標為1的元素，也就是數字2,5,4.
>>> a
[('a', 2), ('c', 4), ('b', 5)]
>>> a.sort(key=lambda x:x[1],reverse=True)
>>> a
[('b', 5), ('c', 4), ('a', 2)]
cmp是什么
cmp是用來比較2個數字的值，只會返回三個結果：0,1,-1. 能用key最好不用cmp，python3中已經棄用，性能不好
用法
cmp(a,b) 等同於公式(a>b) - (a<b)
>>> cmp(1,3)
-1
>>> (1>3) - (1<3)
-1
>>> cmp (3,1)
1
>>> cmp (3,3)
0
3.3 多級排序咋個辦
如下，按元組元素中的后兩位數字進行排序，我的理解就是后兩位看做一個數比大小。
>>> a = [(3,1,2),(6,7,8),(6,5,9)]
>>> import operator
>>> a.sort(key=operator.itemgetter(1,2)) #這里的1,2表示下標。
>>> a
[(3, 1, 2), (6, 5, 9), (6, 7, 8)]
3.4 字典如何去排序
自己摸索。。。
4.字符串模板應用
4.1 回憶一下，字符串模板有哪幾種方式
"%s is a %s" %("he","boy")
"%(who)s is a %(gender)s" %{"who":"he","gender":"boy"}
"{who} is a {gender}".format(who="he",gender="boy") 這種最好
4.2 典型應用1：html模板
也是用占位符來替代相應模塊中的內容
4.3 針對性比強大更為重要
三種字符串模板靈活運用，看哪個適用
基礎篇16-python語句講解1
1. print語句
1.1 基本輸出
1.2 print的逗號
1.2 輸出到文件 >>為重定向
解釋與例子
在python腳本中，如果寫入
print "2"
print "3"
那么執行的時候會自動進行換行，輸出為
2
3
如果腳本中加上逗號，如下
print "2",
print "3"
那么執行的時候輸出就是
2 3
不會進行換行，所有逗號的意思就是print語句還沒執行完。
輸出重定向,使用print命令來寫文件內容 -----以后我就用這個方法吧，命令行也行
腳本中如下寫
f = open('print.txt','w')
#一般情況下寫入文件應該用命令f.write("my name is hong"),這里用print來寫
print >> f,"my name is hong"
print >> f,"i am from china"
f.close()
這里當然也可以用逗號，來使2行變一行。
2. 控制流語句（control flow）
2.1 由條件和執行代碼塊組成。
2.1.1 條件可分為決策、循環和分支
2.2 格式（冒號與4個空格永不忘）
2.3 if，while，for 函數，皆為contorl flow
解釋和例子
if True: #冒號分隔了條件和代碼塊。
print 4 #4個空格縮進的代碼塊
x = 3
if x: #相當於 if x == if bool(x)，返回結果為True
print 4
3. 布爾值
3.1 控制流與真假值息息相關
3.1.1 不要誤解了真假與布爾值
3.2 布爾值的幾個最基本運算符
3.2.1 and 全部都為bool真
3.2.2 or 至少一個為bool真
3.2.3 is 檢查共享
3.2.4 == 檢查值
3.2.5 not
3.2.6 其他若干比較符號
>>> True and False
False
>>> True or False
True
is是檢查是否引用了同一個數據對象
>>> 5 is True
False
5是引用了一個整型的數據對象，True引用的是一個布爾類型的對象，所有結果是False
>>> a = 5
>>> b = 5
>>> a is b
True
== 檢查左邊和右邊的值是否相同
1 == True
True
雖然左邊是整型，右邊是布爾型，但是他們的值都是1，所以返回True
>>> 4 == 9
False
not：取反。如果要表示真，后面一定要跟False,做這個的是太無聊了，整點花樣。
if not False:
print "not False"
4. if語句 （控制流語句）
4.1 if的組成 if else elif pass
4.1.1 if與elif替代了switch
4.1.2 pass
例子
if True:
print "True"
else:
print "False"
if True:
print "True"
elif not True:
print "not True"
else:
pass #什么都不做
4.2 奇技淫巧 三元表達式
4.2.1 x if else
4.2.2 活用list
4.2.3 三元表達式玩玩就好
例子1
4 if True else 3
等同於
if True:
print 4
else:
print 3
>>> 4 if True else 3
4
例子2
>>> [4,3][True] #True值為1，所以返回下標為1的list值
3
>>> [4,3][False] #False值為0，所以返回下標為0的list值
4
>>> [4,3][0]
4
>>> [4,3][1]
3
基礎篇17-python語句講解-2
1.復習
1.1 控制流的基本組成部分 條件，執行代碼塊。
1.2 if的基本格式
if expression:
statement(s)
1.2 控制流的條件表達式(expression)結果，必須為True(真)，比如 條件可以寫成if not True: 這樣的返回結果為真，而不能寫成if False，返回為假
1.3 冒號永不忘。盡量使用4個空格，而不是制表符
2.while語句
2.1 while的基本格式
while expression:
statement(s)
例子1
x = 1
while True:
x += 1
print x
#continue 通過加減這個命令來測試
if x > 20:
break
else:
2.2 while的基本組成部分
2.2.1 break 結束while
2.2.2 continue 跳出當前這次循環，但不結束while
2.2.3 else 結束while以后執行,是正常跑完，不是通過break強行結束。也就是說不能和break連用，不然break會把else語句也掐斷。但是可以和continue一起用
while x < 20: #可以在while表達式中用<
x += 1
#continue 來測試是否能和continue一起用
print x
else:
print "end"
2.3 注意：普通應用里，while一定要給一個結束條件，否則就是傳說中的死循環
3.for語句
3.1 for的基本格式
for item in iterable：
statement（s）
例子
for x in "hello,my name is hongjin"
print x
消除空格
for x in "hello,my name is hongjin".split(" "):
print x
用一行來顯示出來文本內容
for x in "hello,my name is hongjin".split(" "):
print x，
3.2 for的基本組成部分
3.2.1 break
3.2.2 continue
3.2.3 else
3.3 注意：for的最后一個迭代值將保留，也就是循環結束后，最后一個循環取得值將被保留在內存中。如果不注意的話，可能會出現錯誤
4.布爾值再議
4.1 惰性求值，需要時再求值。
4.2 從左到右，從先到后。
4.3 利用小技巧。or之默認值。
比如
True and False and False and True
python在進行計算時，看到第二個是False,后面的就不計算了，直接返回False
在進行運算時，可以把可能是false的計算放在前面，把其他運算量很大的計算放后面，這樣效率高
or之默認值
比如在爬網頁的時候
定義一個變量
from_url = url.get("from") or None
就是爬上面的網址from后面的參數"=126mail"，有時候from后面有內容，有時候沒有，如果沒有的話，腳本還想繼續運行，就需要加上or None
基礎篇18-語句與數據結構應用
1.最基本的迭代
a = "abcdefg"
for i in a:
print i
b = [1,2,3,4,5]
for i in b:
print i
2.如何迭代字典
a = {"key":"value","key1":"value1"}
print a
a = {"key":"value","key1":"value1","key1":"value2"}
print a
相同的key,只會輸出最后一個key的value
for i in a.keys():
print i
命令行中看一下a.items()是什么
腳本中
for x,y in a.items():
print x,y
3.如何為字典排序
例子1，把下面字典元素按照key中的字母序列排序
a = {"a":"haha","b":"xs","d":"fa","c":"faff"}
key_list = a.keys()
key_list.sort()
#print key_list
for x in key_list:
print x,a[x]
注意：字典可以使用如下方式查看字典的value
>>> print a["a"]
haha
4.字典根據鍵值查找鍵
那么如果想從字典的value得到key，應該怎么做呢
分析：
1） 字典索引的是鍵，而不是值 => 迭代，窮舉
2） 字典具有唯一鍵，但值不要求唯一
3） 一個值可能對應多個鍵
例子,不同的key都有相同的value值，
a = {"a":"haha","b":"xixi","d":"haha","e":"xixixi","c":"haha"}
search_value = "haha"
key_list = []
for x,y in a.items(): #找到所有的key, value， for x,y ：設置兩個參數，這個思想很牛x
# print x,y
if y == search_value: #建立相同value對應的key_list
key_list.append(x)
print key_list
5.sorted排序方法再議
在python腳本中這樣寫
import string #測試下不引入string時的輸出情況。
a = "dcDSfag1f43"
a = ''.join([x for x in a if not x.isdigit()])
print sorted(a,key=string.upper)
執行后輸出為
hong@calm:~$ python test.py
['a', 'c', 'd', 'D', 'f', 'f', 'g', 'S']
注意：
key=string.upper可以理解為
1.用string.upper這個方法，去執行列表中的每一個數據，假設我們有一個list
c = [a,b,c]
sorted(c,key=string.upper)相當於先生成一個新的列表
c = [string.upper(a),string.upper(b),string.upper(c)]，然后對這個新的列表進行排序。
結論：
[x for x in a if not x.isdigt()] 等價於下面代碼
new_list = []
for x in a:
if not x.isdigit():
new_list.append(x)
6. 好玩的translate與maketrans---替換字符
例子1
>>> import string
>>> g = string.maketrans('123','abc') #建立翻譯表，參數中的'123'和'abc'位數必須一致，因為它是一一對應翻譯的，否則會報錯
>>> a = '123456'
>>> print a.translate(g)
abc456
例子2
>>> a = '321123132'
>>> print a.translate(g)
cbaabcacb
對比replace
>>> a.replace('123','abc')
'321abc132'
例子3，刪除操作
>>> a = '321123132'
>>> a.translate(g,'1') #輸出刪除1后對應的翻譯
'cbbccb'
如果不翻譯，輸出刪除1后的結果
>>> c = string.maketrans('','')
>>> a.translate(c,'1')
'322332'
>>> a.translate(c,'12')
'333'
逐個刪除。
7. 一個新的語句，with，一個寫文件的方法
普通方法
g = open('a.txt','w')
g.write('hello,\nhi')
g.close()
with方法
with open('a.txt','a') as g: #參數a表示append
g.write("hello")
這種方法不需要寫close語句
2017/8/20 8:58
基礎篇20-python函數
一. 定義函數
1. def是關鍵字，括號冒號永不忘，執行代碼塊要縮進
2. 沒有return的函數，不是真函數
3. 不寫doc的函數，就像沒有性別的人類，也就是要在函數中寫說明，直接在def test():下一行用雙引號寫下說明就行了
例子1
def test():
print 4
test()
上面這個寫法是錯誤的，應該如下寫
def test():
return 4
print test()
例子2
#coding=utf-8
def test():
"這是一個測試函數"
return 1
print test.__doc__
#這個命令是直接打出函數說明信息的，也就是執行python test.py時，會輸出"這是一個測試函數", 需要注意的是doc前面和后面是2個下划線。
二. 函數的參數
1） 位置參數
def test(a,b,c,d):
return a,b,c,d #這樣的結果是會返回一個元組(1,2,3,4)
print test(1,2,3,4) #定義的時候有幾個位置參數，這里就要寫幾個數，否則會報錯
2）可選參數，直白意思就是調用函數的時候參數寫不寫都行，不會報錯。
def test1(a=4)
return a
print test1()
輸出結果是4
print test1(5)
輸出結果是5
3）可選參數可以當做默認值進行設置
例子, 下面是偽代碼，知道意思就好
def test2(a,b,c return_data="json"):
if return_data == 'json':
return json(a,b,c)
elif return_data == 'xml':
return xml(a,b,c)
return a,b,c
test2(1,2,3,return_data='xml)
2. 參數的值是局部變量
1）全局變量和局部變量
例1，在腳本中如下寫
b = 3 #全局變量
def a():
#global b
b = 4 #局部變量
return b
def c():
return b
print a()
print c()
結果輸出為
4
3
說明在局部變量和全局變量中都定義一個變量的時候，會優先使用局部變量的值，如果局部變量沒有定義，則會自動使用全局變量值
如果想在函數a中修改全局變量b的值，方法是使用global b，那么此時print c()的值也是4了，說明全局變量修改成功，這個方法慎用。
2）如何修改參數
例子
有一個list b = [1,2,3]，想通過一個函數func(b),實現結果為把list b =[1,2,3,4], 方法如下
b = [1,2,3]
def func(x) #定義函數有一個參數
x.append(4)
return x
b = func(b)
#調用函數func，並且把返回值重新賦值給b，雖然不用賦值給b，結果也是正確的，但這不是一個好的編程習慣。
print b
3） 函數的參數魔法 ----- **和* 星星是字典，星是元組
例子1
def test(**kr):
return kr #kr可以是任意字符，表示字典名
print test(a=4,c=3)
輸出結果為{'a':4, 'c':3}
例子2
def test(*z)：
return z
print test(1,2,[1,2])
輸出結果為(1,2,[1,2])
例子3
def test(*z,**kr):
return z,kr
print test(1,2,a=5,b=9)
輸出結果為 ((1, 2), {'a': 5, 'b': 9})
注意：
參數a=5這樣的參數必須是一起寫在1,2這樣的參數后面。修改test(*z,**kr)的參數位置也不行。
例子4
def test(a,b,*z,**kr)
return z,kr
print test(1,2,4,5,c=4,d=9)
如果定義參數的時候，已經有了位置參數，那么在print test寫入實參的時候是按照形參的順序來寫入的
實參中的c,d在定義中必須是沒有c,d的，不然就會報錯。