1，基本概念

1.1，python序列類型包括：

容器類型：list，tuple，collections.deque，存放引用，可嵌套

扁平序列：str，bytes，bytearray，memoryview，array.array，存放值，只包含原子數據

可變序列：list，bytearray，array.array，collections.deque，memoryview

不可變序列：tupe，str，bytes

2，str

1）格式化：

%s：‘%s plus %s equals %s‘  % (1, 1, 2)

2）find/rfind：返回最左邊/最右邊索引，沒有返回-1，例如路徑中提取文件名

s1 =‘c:/../../text.txt‘
s1[s1.rfind(‘/‘)+1: s1.find(‘.txt‘)]  # s1結果是text

3）lower/upper：小寫/大寫

4）startswith/endswith：判斷開始/判斷結尾，例如endswith(‘com‘)

5）strip/lstrip/rstrip：去除兩邊/左邊/右邊的空格字符串，也可以傳參指定去除的內容

6）join：合項

‘,‘.join([‘a‘, ‘b‘, ‘c‘])  # 結果是a,b,c

7）split：裂項，不傳參就對空格、制表、換行進行分割

‘a b    \nc‘.split()，# 結果是[‘a‘, ‘b‘, ‘c‘]

8）count：統計出現次數

9）index：判斷索引位置

10）replace：替換，默認全替，但可以傳第3參數指定替換幾個

‘aba‘.replace(‘a‘, ‘b‘, 1)  # 指定替換1個，結果是‘bba‘，

11）center：居中打印

‘title‘.center(50, ‘-‘)  # 結果是‘----------------------title-----------------------‘

12）isdigit：判斷數字

‘322‘.isdigit() # 結果是True

3，bytes

碼位：每個字符占若幹字節，python3（str），python2（unicode）

字節序列：每個字符占一個字節，python3（bytes），python2（str/bytes）

4，列表

4.1，list函數

功能一：用於將可叠代對象iterator轉換為列表

功能二：實現淺拷貝

例如：

list(‘hello‘)  # 結果是[‘h‘,‘e‘,‘l‘,‘l‘,‘o‘]
list(range(5))  # 結果是[1, 2, 3, 4, 5]
list({‘a‘: 1, ‘b‘: 2})  # 結果是[‘a‘, ‘b‘]，因為對字典叠代獲取到的是key

4.2，list基本操作

1）增：lista.append(4)，就地添加返回None

2）刪：刪元素用del、remove、pop；刪列表用del、clear

3）改：lista[2] = 2

4）插：lista.insert[3, ‘insert_value‘]，或者：lista[3:3] = [‘insert_value‘]

7）切片：訪問切片：y=x[1:3]；插入序列x[1:1] = [2,3,4]；刪除序列：x[1:4]=[]；替換序列：x[1:4]=[2,3,4]

8）extend追加：就地加lista.extend(listb)，等效於lista = lista + listb，或者lista[len(lista):] = listb

9）列表相加：lista + listb，原序列不會變

10）乘法：[1,2,3] * 2，結果為[1,2,3,1,2,3]，原序列不變

11）創建5個空序列：

lists = [[] for i in range(5)]  # 5個不同的空序列
lists = [[]] * 5   # 5個id相同的空序列

12）reverse / reserved：反向存放，lista.reverse()就地反向無返回值，reversed(list)有返回值（原序列不變）

13）sort / sorted：排序，x.sort()就地排序無反向值，sorted(list)有返回值（原序列不變）

14）copy：淺拷貝，list.copy()

15）enumerate：遍歷index和value

for i,v in enumerate(lista):
    print(i, v)  # i索引，v值

16）in，len，max，min，index，count：略

4.3，列表的拷貝

t = [1, [2, 3], (4, 5)]

起別名，連第一層都不拷貝：

a = t

淺拷貝：拷貝第一層：

b = list(t) 
b = t[:]
b = t.copy()
b = copy.copy()

深拷貝：拷貝所有層：

c = copy.deepcopy(t)　

看看有什麽區別：

t[0] = 0 
t[1].append(0)
t[2] += (0, )

輸出結果：

t : [0, [2, 3, 0], (4, 5, 0)]
a : [0, [2, 3, 0], (4, 5, 0)] # 別名，全跟著變
b : [1, [2, 3, 0], (4, 5)] # 淺拷貝，第一層以及第二層內的不可變序列不變，第二層的可變序列跟著變
c : [1, [2, 3], (4, 5)] # 深拷貝，全都不變

總結：

判斷時可以用is或者id()，看下不同的變量名，是否指向同一引用對象

a和t的id完全相同，b/c和t的id不同

如果列表內部有“可變的引用對象”(例如字典、集合、列表，元組算不可變的引用對象)，t發生改變時，會影響到淺拷貝b，但不會影響到深拷貝c

5，元組

5.1，tupple函數

和list函數一樣，將某個序列轉換為tupple

5.2，元組基本操作

1）切片：只支持切片訪問即查，不支持插，刪，改

2）元組相加：tu1 + tu2，原序列不會變

3）乘法：(1,2,3) * 2，結果為(1,2,3,1,2,3)，原序列不變

4）in，len，max，min，index，count，enumerate：略

5.3，元組和列表的區別

列表不建議存放不同類型的東西，否則無法排序

元組經常用來存放不同類型的東西

5.4，具名元組

具有名字的元組

from collections import namedtuple
TU = namedtuple(‘manincity‘, ‘name city‘)
tu1 = TU(‘guxh‘, ‘shanghai‘)
print(tu1)  # manincity(name=‘guxh‘, city=‘shanghai‘)

6，字典

6.1，字典的創建

d = {‘a‘:1, ‘b‘:2, ‘c‘:3}
d = dict(a=1, b=2, c=3)
d = dict([(‘a‘,‘1‘), (‘b‘,2), (‘c‘,3)]) # 元組列表，列表列表都可以，只要是2個值的小序列組成的大序列，不用寫字典推導了!!!

　################################待修訂######################

6.2，字典的方法
1）增和改：d[‘d‘] = 4，有改/無增
2）d.update(d2)，用字典d2區更新d，有改/無增
3）刪除
d.pop(‘d‘) # 刪除key-values鍵值對
del d[‘a‘] # 刪除key-values鍵值對
popitem() # 刪最後一個，由於字典是無序的所以實際上是隨機刪一個

清空整個列表：
清除字典，無返回值（即返回None）
d = {}
d[‘name‘] = ‘gumby‘
d.clear()
直接賦空值也可以清
d = {}
d[‘name‘] = ‘gumby‘
d = {}
但關聯了其他字典請不掉：
d = {}
d[‘name‘] = ‘gumby‘
y = d
d = {} /如果用這個方法，雖然d清掉了，但是y請不掉
d.clear() /d和y都清掉了
4）查
‘dd‘ in dict1 # 判斷是否含有鍵為K的項，list中是判斷的是值
len(dict1) # 返回鍵值對數量
dict1[‘dd‘] # 返回關聯鍵K的value，如果不存在會報錯KeyError
dict1.get(‘dd‘) # 有就返回value，沒有則返回默認值None（可以修改），比上面直接寫key好
get的使用舉例：
統計某列出現的項目（key），以及該項目出現的次數（values）
所有key即是該列去重後的項
以df的A列為例：
list=[‘a‘,‘b‘,‘c‘,‘d‘,‘e‘,‘a‘,‘a‘,‘b‘,‘e‘,‘f‘]
dic={}
for element in list:
if dic.get(element,0)==0 :
dic[element]=1 #如果沒有該key，則創建列表並賦值1
else:
dic[element]=dic[element]+1 #如果有該key，則該key的值加1
備註：
len(dic) #dic字典的個數，相當於excel中的dic.count
key=dictall.keys() #字典的所有key列表
item=dictall.values() #字典的所有項列表
用dic獲取維護單位列表：
dic={ u‘東區分公司‘:u‘浦東‘,
u‘南區分公司‘:u‘南區‘,
u‘西區分公司‘:u‘西區‘,
u‘北區分公司‘:u‘北區‘,
}
for i in xx:
list.append(dic.get(i,None))
5）copy
d2 = d1.copy()
是淺拷貝，替換值時原始字典不受影響，但是修改值是原始字典也會改變。
深拷貝的方法：
d2 = d1.deepcopy() /需要from copy import deepcopy
6）fromkeys
從給定的key創建新字典，可以指定values，默認為None
d1 = dict.fromkeys([‘east‘, ‘west‘], 20) # dict可以改成任何已經存在的字典，但是結果和該字典無任何關系
輸出結果：
{‘west‘: 20, ‘east‘: 20}
如果創建了嵌套字典，相當於潛copy，改一個會全跟著改
7）has_key
檢查字典中是否有key
d.has_key(‘south‘) /有返回True，無返回False
8）items/iteritems, keys/iterkeys, values/itervalues
d1 = {‘west‘: 10, ‘east‘: 20, ‘south‘:30, ‘north‘:40}
print d1.items() /[(‘west‘, 10), (‘east‘, 20), (‘north‘, 40), (‘south‘, 30)]，即字典轉列表
print d1.keys() /[‘west‘, ‘east‘, ‘north‘, ‘south‘]
print d1.values() /[10, 20, 40, 30]
iteritems/iterkeys/itervalues返回叠代對象，用叠代時可以用它們。

5，字典的循環
for i in dict1:
print(i, dict1[i]) # i是key，dict1[i]是value
備註：對dict1循環打印的是key，for i in dict1和for i in dict1.keys()，效果是一樣的
for k,v in dict1.items()：
print(k, v)
兩種方法打印結果一樣，但是後面一種效率低，因為有個中間轉換至列表的過程
備註：series也能向字典那樣遍歷，for index,value in series.items()

3，字典的格式化字符串
phonebook = {‘cecil‘ : 56845 }
"cecil‘s phone number is %(cecil)s." % phonebook
輸出：cecil‘s phone number is 56845.

6，字典應用舉例
6.1，字典遍歷有值追加，無值建[]
方法一：用if
if key not in dict:
dict[key] = []
dict[key]append(new_value)

方法二：用get
temp = index.get(key, [])
temp.append(new_value)
index[key] = temp

方法三：用setdefault
dict.setdefault(key, [])
dict[key].append(new_value)
可以進一步合並為一句：強烈推薦，只需一次查找，效率高
dict.setdefault(key,[]).append(new_value)

7，根據value找到key
方法一：list
dicxx = {‘a‘:‘001‘, ‘b‘:‘002‘}
list(dicxx.keys())[list(dicxx.values()).index("001")]

方法二：反向做字典
dicxx = {‘a‘:‘001‘, ‘b‘:‘002‘}
new_dict = {v:k for k,v in dicxx.items()}
new_dict[‘001‘]

8，setdefault
defaultdict

1，集合
集合最重要的2個內容：去重（把列表變成集合就自動去重了）、關系測試（測試2組數據的交集、差集、並集）
去重
list1 = [1, 3, 5, 6, 7, 8, 1, 3, 5, 7, 2, 3]
list1 = set(list1) # {1, 2, 3, 5, 6, 7, 8} 集合也是無序的
list2 = {1, 3, 11, 22, 55, 78, 90, 90, 1, 3} # 實際結果是{1, 3, 11, 78, 22, 55, 90}
print(list1.intersection(list2)) # 取交集，結果是{1，3}
print(list1.union(list2)) # 取並集，結果是{1, 2, 3, 5, 6, 7, 8, 11, 78, 22, 55, 90}
print(list1.difference(list2)) # 取差集，結果是{2, 5, 6, 7, 8}，list1裏有的，但是list2裏沒有的
print(list1.issubset(list2)) # 判斷list1是否是list2的子集
print(list1.issuperset(list2)) # 判斷list2是否是list1的父集
& 交集
| 並集
- 差集
^ 對稱差集

如果集合是空集，必須寫成set()

2，集合的增刪改查
2.1，增
t.add(5) # 增加一項，註意增加是add，不是append
t.update(5，6，7) # 增加多項
2.2，刪
t.remove(5) # 刪除5，如果set中不存在5則會報錯
t.discard(5) # 刪除5，如果set中不存在5則不會報錯
a = t.pop() # 隨機刪除一個值，並且把該值返回給a
2.3，查
len(t)
x in t
2.4，copy
淺復制

其他
數字（略）
布爾類型（略）

guxh的python筆記：數據類型