1.list中添加新元素
http://blog.sina.com.cn/s/blog_b2f983a50102yqzu.html
append(a)只能在末尾 添加
insert(i,a)在指定位置添加
extend(a,b)可以一次添加多個元素
2.python3 list、tuple(元組)、str之間的相互轉換
list()方法是把字符串str或元組轉成數組
tuple()方法是把字符串str或數組轉成元組
>>> s = "xxxxx"
>>> list(s)
['x', 'x', 'x', 'x', 'x']
>>> tuple(s)
('x', 'x', 'x', 'x', 'x')
>>> tuple(list(s))
('x', 'x', 'x', 'x', 'x')
>>> list(tuple(s))
['x', 'x', 'x', 'x', 'x']
列表和元組轉換爲字符串則必須依靠join函數
>>> "".join(tuple(s))
'xxxxx'
>>> "".join(list(s))
'xxxxx'
>>> str(tuple(s))
"('x', 'x', 'x', 'x', 'x')"#要是使用sublime text 3插件sublimeREPl，是不會顯示外層的雙引號的。上面同理。>>>
3.python中無窮大與無窮小表示
float(‘inf’) 表示正無窮
-float(‘inf’) 或 float(’-inf’) 表示負無窮
其中，inf 均可以寫成 Inf
4.TypeError: ‘int’ object is not iterable，int在循環裏不能直接相加求累積和
把所有int型的數放到列表L裏，然後用sum（L）
5.輸入
a =input() #a爲一個任意字符的字符串，可以任意常
6.Cpickle
https://www.xuebuyuan.com/3243387.html
pickle模塊會創建一個python語言專用的二進制格式，你基本上不用考慮任何文件細節，它會幫你乾淨利落地完成讀寫獨享操作，唯一需要的只是一個合法的文件句柄。
pickle模塊中的兩個主要函數是dump()和load()。dump()函數接受一個文件句柄和一個數據對象作爲參數，把數據對象以特定的格式保存到給定的文件中。當我們使用load()函數從文件中取出已保存的對象時，pickle知道如何恢復這些對象到它們本來的格式。
dumps()函數執行和dump() 函數相同的序列化。取代接受流對象並將序列化後的數據保存到磁盤文件，這個函數簡單的返回序列化的數據。
loads()函數執行和load() 函數一樣的反序列化。取代接受一個流對象並去文件讀取序列化後的數據，它接受包含序列化後的數據的str對象, 直接返回的對象。
cPickle是pickle得一個更快得C語言編譯版本。
pickle和cPickle相當於java的序列化和反序列化操作。
怎麼打開pickle文件
import pickle
# f = open('./save/target_params.pkl', 'rb')
f=pickle.load(open("./save/target_params.pkl", 'rb'), encoding='iso-8859-1')
count = 0
for line in f:
count += 1
if count <= 50:
print(line)
else:
break
7.map()
map() 函數語法：
map(function, iterable, …)
>>>def square(x) : # 計算平方數 ... return x ** 2 ...
>>> map(square, [1,2,3,4,5]) # 計算列表各個元素的平方
[1, 4, 9, 16, 25]
>>> map(lambda x: x ** 2, [1, 2, 3, 4, 5]) # 使用 lambda 匿名函數 [1, 4, 9, 16, 25] #
提供了兩個列表，對相同位置的列表數據進行相加
>>> map(lambda x, y: x + y, [1, 3, 5, 7, 9], [2, 4, 6, 8, 10])
[3, 7, 11, 15, 19]
8.lamda
1、應用在函數式編程中
Python提供了很多函數式編程的特性，如：map、reduce、filter、sorted等這些函數都支持函數作爲參數，lambda函數就可以應用在函數式編程中。如下：
需求：將列表中的元素按照絕對值大小進行升序排列
list1 = [3,5,-4,-1,0,-2,-6]
sorted(list1, key=lambda x: abs(x))
當然，也可以如下：
list1 = [3,5,-4,-1,0,-2,-6]
def get_abs(x):
return abs(x)
sorted(list1,key=get_abs)
只不過這種方式的代碼看起來不夠Pythonic
2、應用在閉包中
def get_y(a,b):
return lambda x:ax+b
y1 = get_y(1,1)
y1(1) # 結果爲2
當然，也可以用常規函數實現閉包，如下：
def get_y(a,b):
def func(x):
return ax+b
return func
y1 = get_y(1,1)
y1(1) # 結果爲2
只不過這種方式顯得有點囉嗦。
9.dict
9.1 dict的深拷貝(備份的一直不變)和淺拷貝（備份會變）
<<<d = {"username":"rose", "password":["ddh", "yjy", "gg"]}
<<<g = d.copy()
<<<g1 = deepcopy(d)
<<<d["username"] = "dawson"
<<<print d
{"username":"dawson", "password":["ddh", "yjy", "gg"]}
<<<print g
{"username":"dawson", "password":["ddh", "yjy", "gg"]}
<<<print g1
{"username":"rose", "password":["ddh", "yjy", "gg"]}`
9.2 字典特性
字典值可以是任何的 python 對象，既可以是標準的對象，也可以是用戶定義的，但鍵不行。
兩個重要的點需要記住：
1）不允許同一個鍵出現兩次。創建時如果同一個鍵被賦值兩次，後一個值會被記住，
2）鍵必須不可變，所以可以用數字，字符串或元組充當，而用列表就不行，如下實例：
實例
#!/usr/bin/python3
dict = {['Name']: 'Runoob', 'Age': 7} print ("dict['Name']: ", dict['Name'])
以上實例輸出結果：
Traceback (most recent call last):
File "test.py", line 3, in <module>
dict = {['Name']: 'Runoob', 'Age': 7}TypeError: unhashable type: 'list'
9.2
字典的鍵值是"只讀"的，所以不能對鍵和值分別進行初始化，即以下定義是錯的：
>>> dic = {}>>> dic.keys = (1,2,3,4,5,6)Traceback (most recent call last):
File "<stdin>", line 1, in <module>AttributeError: 'dict' object attribute 'keys' is read-only
>>> dic.values = ("a","b","c","d","e","f")Traceback (most recent call last):
File "<stdin>", line 1, in <module>AttributeError: 'dict' object attribute 'values' is read-only
>>>
字典是支持無限極嵌套的，如下面代碼：
cities={
‘北京’:{
‘朝陽’:[‘國貿’,‘CBD’,‘天階’,‘我愛我家’,‘鏈接地產’],
‘海淀’:[‘圓明園’,‘蘇州街’,‘中關村’,‘北京大學’],
‘昌平’:[‘沙河’,‘南口’,‘小湯山’,],
‘懷柔’:[‘桃花’,‘梅花’,‘大山’],
‘密雲’:[‘密雲A’,‘密雲B’,‘密雲C’]
},
‘河北’:{
‘石家莊’:[‘石家莊A’,‘石家莊B’,‘石家莊C’,‘石家莊D’,‘石家莊E’],
‘張家口’:[‘張家口A’,‘張家口B’,‘張家口C’],
‘承德’:[‘承德A’,‘承德B’,‘承德C’,‘承德D’]
}}
可以使用如下方法進行列出
for i in cities['北京']:
print(i)
將列出如下結果：
朝陽海淀昌平懷柔密雲
for i in cities['北京']['海淀']:
print(i)
輸出如下結果：
圓明園蘇州街中關村北京大學
9.3 s.update( “字符串” ) 與 s.update( {“字符串”} ) 含義不同:
s.update( {“字符串”} ) 將字符串添加到集合中，有重複的會忽略。
s.update( “字符串” ) 將字符串拆分單個字符後，然後再一個個添加到集合中，有重複的會忽略。
>>> thisset = set(("Google", "Runoob", "Taobao"))
>>> print(thisset){'Google', 'Runoob', 'Taobao'}
>>> thisset.update({"Facebook"})
>>> print(thisset)
{'Google', 'Runoob', 'Taobao', 'Facebook'}
>>> thisset.update("Yahoo")
>>> print(thisset){'h', 'o', 'Facebook', 'Google', 'Y', 'Runoob', 'Taobao', 'a'}
9.4 集合的 set.pop() 的不同認爲
有人認爲 set.pop() 是隨機刪除集合中的一個元素、我在這裏說句非也！對於是字典和字符轉換的集合是隨機刪除元素的。當集合是由列表和元組組成時、set.pop() 是從左邊刪除元素的如下:
列表實例：
set1 = set([9,4,5,2,6,7,1,8])print(set1)print(set1.pop())print(set1)
輸出結果:
{1, 2, 4, 5, 6, 7, 8, 9}1{2, 4, 5, 6, 7, 8, 9}
元組實例：
set1 = set((6,3,1,7,2,9,8,0))print(set1)print(set1.pop())print(set1)
輸出結果:
{0, 1, 2, 3, 6, 7, 8, 9}0{1, 2, 3, 6, 7, 8, 9}
10.集合
10.1 集合（set）是由一個或數個形態各異的大小整體組成的，構成集合的事物或對象稱作元素或是成員。
基本功能是進行成員關係測試和刪除重複元素。
可以使用大括號 { } 或者 set() 函數創建集合，注意：創建一個空集合必須用 set() 而不是 { }，因爲 { } 是用來創建一個空字典。
創建格式：
parame = {value01,value02,…}或者set(value)
實例
#!/usr/bin/python3
student = {'Tom', 'Jim', 'Mary', 'Tom', 'Jack', 'Rose'}
print(student) # 輸出集合，重複的元素被自動去掉
成員測試
if 'Rose' in student :
print('Rose 在集合中')
else :
print('Rose 不在集合中')
set可以進行集合運算
a = set('abracadabra')
b = set('alacazam')
print(a) print(a - b) # a和b的差集
print(a | b) # a和b的並集
print(a & b) # a和b的交集
print(a ^ b) # a和b中不同時存在的元素
以上實例輸出結果：
{'Mary', 'Jim', 'Rose', 'Jack', 'Tom'}
Rose 在集合中
{'b', 'a', 'c', 'r', 'd'}
{'b', 'd', 'r'}
{'l', 'r', 'a', 'c', 'z', 'm', 'b', 'd'}
{'a', 'c'}
{'l', 'r', 'z', 'm', 'b', 'd'}
10.2 集合（set）是一個無序的不重複元素序列。
可以使用大括號 { } 或者 set() 函數創建集合，注意：創建一個空集合必須用 set() 而不是 { }，因爲 { } 是用來創建一個空字典。
11.Dictionary（字典）
字典（dictionary）是Python中另一個非常有用的內置數據類型。
列表是有序的對象集合，字典是無序的對象集合。兩者之間的區別在於：字典當中的元素是通過鍵來存取的，而不是通過偏移存取。
字典是一種映射類型，字典用"{ }"標識，它是一個無序的鍵(key) : 值(value)對集合。
鍵(key)必須使用不可變類型。
在同一個字典中，鍵(key)必須是唯一的。
實例#!/usr/bin/python3
dict = {}
dict['one'] = "1 - 菜鳥教程"
dict[2] = "2 - 菜鳥工具"
tinydict = {'name': 'runoob','code':1, 'site': 'www.runoob.com'}
print (dict['one']) # 輸出鍵爲 'one' 的值
print (dict[2]) # 輸出鍵爲 2 的值
print (tinydict) # 輸出完整的字典
print (tinydict.keys()) # 輸出所有鍵
print (tinydict.values()) # 輸出所有值
以上實例輸出結果：
1 - 菜鳥教程
2 - 菜鳥工具
{'name': 'runoob', 'code': 1, 'site': 'www.runoob.com'}
dict_keys(['name', 'code', 'site'])
dict_values(['runoob', 1, 'www.runoob.com'])
構造函數 dict() 可以直接從鍵值對序列中構建字典如下：
實例>>>dict([(‘Runoob’, 1), (‘Google’, 2), (‘Taobao’, 3)]) {‘Taobao’: 3, ‘Runoob’: 1, ‘Google’: 2} >>> {x: x**2 for x in (2, 4, 6)} {2: 4, 4: 16, 6: 36} >>> dict(Runoob=1, Google=2, Taobao=3) {‘Taobao’: 3, ‘Runoob’: 1, ‘Google’: 2}
另外，字典類型也有一些內置的函數，例如clear()、keys()、values()等。
注意：
1、字典是一種映射類型，它的元素是鍵值對。
2、字典的關鍵字必須爲不可變類型，且不能重複。
3、創建空字典使用 { }。
12.位運算符
[外鏈圖片轉存失敗(img-rO0XWn4x-1563622653452)(en-resource://database/3876:1)]
13.Python身份運算符
身份運算符用於比較兩個對象的存儲單元
[外鏈圖片轉存失敗(img-vKGukQNB-1563622653453)(en-resource://database/3878:1)]
實例(Python 3.0+)
#!/usr/bin/python3
a = 20
b = 20
if ( a is b ):
print ("1 - a 和 b 有相同的標識")
else:
print ("1 - a 和 b 沒有相同的標識")
if ( id(a) == id(b) ):
print ("2 - a 和 b 有相同的標識")
else:
print ("2 - a 和 b 沒有相同的標識")
修改變量 b 的值
b = 30
if ( a is b ):
print ("3 - a 和 b 有相同的標識")
else:
print ("3 - a 和 b 沒有相同的標識")
if ( a is not b ):
print ("4 - a 和 b 沒有相同的標識")
else:
print ("4 - a 和 b 有相同的標識")
以上實例輸出結果：
1 - a 和 b 有相同的標識
2 - a 和 b 有相同的標識
3 - a 和 b 沒有相同的標識
4 - a 和 b 沒有相同的標識
is 與 == 區別：
is 用於判斷兩個變量引用對象是否爲同一個， == 用於判斷引用變量的值是否相等。
>>>a = [1, 2, 3]
>>> b = a
>>> b is a True
>>> b == a True
>>> b = a[:]
>>> b is a False
>>> b == a True
14.Python運算符優先級
以下表格列出了從最高到最低優先級的所有運算符：
[外鏈圖片轉存失敗(img-97PEjbZG-1563622653453)(en-resource://database/3880:1)]
15.數字Number
“4舍6入5看齊,奇進偶不進”我覺得並不是因爲浮點數在計算機表示的問題。計算機浮點數的表示是 ieee 定義的標準規則，如果 python 中存在，沒道理其他語言中不存在。事實上是因爲該取捨方法比過去的 “四捨五入” 方法在科學計算中更準確。而國家標準也已經規定使用 “4舍6入5看齊,奇進偶不進” 取代"四捨五入".
從統計學的角度上來講,如果大量數據無腦的採用四捨五入會造成統計結果偏大。而"奇進偶舍"可以將舍入誤差降到最低。
奇進偶舍是一種比較精確比較科學的計數保留法，是一種數字修約規則。
其具體要求如下（以保留兩位小數爲例）：
（1）要求保留位數的後一位如果是4或者4以下的數字，則捨去， 例如 5.214保留兩位小數爲5.21。
（2）如果保留位數的後一位如果是6或者6以上的數字，則進上去， 例如5.216保留兩位小數爲5.22。
（3）如果保留位數是保留整數部分或保留一位小數，則要根據保留位來決定奇進偶舍：
>>> round(5.215,2)#實際並沒有進位
5.21
>>> round(5.225,2)
5.22
>>> round(1.5)#此處進位
2
>>> round(1.5)==round(2.5)#偶數捨去
True
>>> round(1.15,1)
1.1
>>> round(1.25,1)
1.2
>>> round(1.151,1)
1.2
>>> round(1.251,1)
1.3
(4) 如果保留位數的後一位如果是5，且該位數後有數字。則進上去，例如5.2152保留兩位小數爲5.22，5.2252保留兩位小數爲5.23，5.22500001保留兩位小數爲5.23。
從統計學的角度，“奇進偶舍”比“四捨五入”要科學，在大量運算時，它使舍入後的結果誤差的均值趨於零，而不是像四捨五入那樣逢五就入，導致結果偏向大數，使得誤差產生積累進而產生系統誤差，“奇進偶舍”使測量結果受到舍入誤差的影響降到最低。
16.Python 標識符
在 Python 裏，標識符由字母、數字、下劃線組成。
在 Python 中，所有標識符可以包括英文、數字以及下劃線(_)，但不能以數字開頭。
Python 中的標識符是區分大小寫的。
以下劃線開頭的標識符是有特殊意義的。以單下劃線開頭 _foo 的代表不能直接訪問的類屬性，需通過類提供的接口進行訪問，不能用 from xxx import * 而導入；
以雙下劃線開頭的 __foo 代表類的私有成員；以雙下劃線開頭和結尾的 foo 代表 Python 裏特殊方法專用的標識，如 init() 代表類的構造函數。
17.字符串
17.1 字符串截取字符補充：
0、a,b爲參數。從字符串指針爲a的地方開始截取字符，到b的前一個位置（因爲不包含b）
var1 = "hello world";print(var1[a: b]);
1、如果a,b均不填寫，默認取全部字符。即，下面這兩個打印結果是一樣的
print(var1[: ]); # hello world
print(var1); # hello world
2、如果a填寫，b不填寫（或填寫的值大於指針下標），默認從a開始截取，至字符串最後一個位置
print(var1[3: ]); # lo world
3、如果a不填寫， b填寫，默認從0位置開始截取，至b的前一個位置
print(var1[: 8]); # hello wo
4、如果a爲負數，默認從尾部某一位置，開始向後截取
print(var1[-2: ]); # ld
5、如果a>=b, 默認輸出爲空。
print(var1[3: 3]);
print(var1[3: 2]);
17.2 python字符串格式化符號:
%g 是 %f 和 %e 的簡寫是什麼意思？到底是 %f 還是 %e？
對此我用代碼測試了一下：
>>> a=100000
>>> print("%g"%(a))
100000
>>> a=10000000
>>> print("%g"%(a))
1e+07
>>> a=1000000
>>> print("%g"%(a))1e+06
可以發現，%g 是自動選擇輸出格式的，在六位數的情況下就會以科學計數法方式輸出，文章中說 %g 是 %f 和 %e 的簡寫，但是我發現上述不是科學計數法方式輸出的時候輸出的是一個整數，於是又進行了如下測試：
>>> a=100000.0
>>> print("%g"%(a))
100000
>>> print("%f"%(a))
100000.000000
>>>
發現 %g 在不是用 %e 輸出的情況下和%f還是有區別的
對此我又做了如下測試：
>>> a=100000.1
>>> print("%g"%(a))
100000
>>> a=1.0
>>> print("%g"%(a))
1
>>> a=1.1
>>> print("%g"%(a))
1.1
發現在 a=100000.1 的時候輸出的數並沒有小數點後面的 1，對此我對比了 C 語言 %g 的格式輸出，猜想 python 中應該如同 C 語言一樣，%g 用於打印數據時，會去掉多餘的零，至多保留六位有效數字。
17.3 使用格式化符號進行進制轉換
>>> num=10
>>> print('十六進制：%#x' % num) #使用%x將十進制num格式化爲十六進制
十六進制：0xa
>>> print('二進制:', bin(num)) #使用bin將十進制num格式化爲二進制
二進制:0b1010
>>> print('八進制：%#o' % num) #使用%o將十進制num格式化爲八進制
八進制：0o12
上面使用格式化符號進行進制轉換中，多加入了一個#號，目的是在轉換結果頭部顯示當前進制類型，如不需要，可將#號去除，如下
>>> print('八進制：%o' % num)
八進制：12
>>> print('十六進制：%x' % num)
十六進制：a
17.4 [::2] 表示的是從頭到尾，步長爲2。第一個冒號兩側的數字是指截取字符串的範圍,第二個冒號後面是指截取的步長。
>>> L=['a','b','c','d','e','f','g']
>>> print(L[::2])
['a', 'c', 'e', 'g']
17.5字符串的分割還有partition()這種方式。
partition(sep) --> (head,sep,tail)
從左向右遇到分隔符把字符串分割成兩部分，返回頭、分割符、尾三部分的三元組。如果沒有找到分割符，就返回頭、尾兩個空元素的三元組。
s1 = "I'm a good sutdent."#以'good'爲分割符，返回頭、分割符、尾三部分。
s2 = s1.partition('good')#沒有找到分割符'abc'，返回頭、尾兩個空元素的元組。
s3 = s1.partition('abc')
print(s1)print(s2)print(s3)
結果如下：
I'm a good sutdent.
("I'm a ", 'good', ' sutdent.')
("I'm a good sutdent.", '', '')
17.6 針對 Counter 的升級使用，示例如下：
#必須引用如下庫from collections import Counter
#定義兩個字符串變量
Var1 = "1116122137143151617181920849510"
Var2 = "1987262819009787718192084951"
#以字典的形式，輸出每個字符串中出現的字符及其數量
print (Counter(Var1))
print (Counter(Var2))
輸出如下：
Counter({'1': 12, '2': 3, '6': 2, '3': 2, '7': 2, '4': 2, '5': 2, '8': 2, '9': 2, '0': 2})
Counter({'1': 5, '9': 5, '8': 5, '7': 4, '2': 3, '0': 3, '6': 1, '4': 1, '5': 1})
17.7 isdigit 和 isnumeric的區別?
def dn():
dgt=[]
num=[]
c=0
for c in range(2**16):
ch=chr(c)
if ch.isdigit():
dgt.append(ch)
if ch.isnumeric():
num.append(ch)
print('digits:',dgt)
print('numeric:',num) //多了中文
dn()
18.列表
18.1 列表的複製
>>> a = [1, 2, 3]>>> b = a
>>> c = []>>> c = a
>>> d = a[:]>>> a, b, c, d
([1, 2, 3], [1, 2, 3], [1, 2, 3], [1, 2, 3])>>> b[0] = 'b'>>> a, b, c, d
(['b', 2, 3], ['b', 2, 3], ['b', 2, 3], [1, 2, 3])>>> id(a), id(b), id(c), id(d)(140180778120200, 140180778120200, 140180778120200, 140180778122696)>>> c[0] = 'c'>>> a, b, c, d
(['c', 2, 3], ['c', 2, 3], ['c', 2, 3], [1, 2, 3])>>> id(a), id(b), id(c), id(d)(140180778120200, 140180778120200, 140180778120200, 140180778122696)>>> d[0] = 'd'>>> a, b, c, d
(['c', 2, 3], ['c', 2, 3], ['c', 2, 3], ['d', 2, 3])>>> id(a), id(b), id(c), id(d)(140180778120200, 140180778120200, 140180778120200, 140180778122696)
可以看到a b c 三個是同一id值，當改變當中任一列表元素的值後，三者會同步改變。
但d的元素值不會變，改變d的元素值其它三個變量內的元素值也不會變。
從a b c d 的id值來看，a b c 地址全一樣，唯有d分配了新地址。
所以一般情況下想複製得到一個新列表並改變新列表內元素而不影響原列表，可以採用d的賦值方式。
這只是針對這種比較單一的普通列表。
其實可以用copy模塊裏 copy()函數解決，實例如下：
import copy
a = [1,2,3,4]
b = a
d = copy.copy(a)
b[0] = 'b'
print(a,b,d)
print(id(a),id(b),id(d))
還有一個就是用list自帶的copy()方法,把重新開闢內存空間存儲新列表。
original_list=[0,1,2,3,4,5,6,7,8]
copy_list=original_list.copy()
copy_list=copy_list+['a','b','c']
print("original_list:",original_list)print("copy_list modify:",copy_list)
運行結果
original_list: [0, 1, 2, 3, 4, 5, 6, 7, 8]
copy_list modify: [0, 1, 2, 3, 4, 5, 6, 7, 8, 'a', 'b', 'c']
18.2 空列表
可以簡單地通過兩個中括號進行表示([])- 一里面什麼東西都沒有，但是，如果想創建一個佔用十個元素空間，卻不包括任何有用內容的列表，又該怎麼辦呢?首先可以類似於下面的方法，用某一個具體的值代替。
>>> list_empty = [0]*10
>>> list_empty
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
這樣就生成了一一個包括10個0的列表。然而，有時候可能會需要一個值來代表空一意味着沒有在裏面放置任何元素。這個時候就需要使用None。None 是一個Python的內建值，它的確切含意是"這裏什麼也沒有"。因此，如果想初始化個長度爲10的列表，可以按照下面的例子來實現:
>>> list_empty = [None]*10>>> list_empty
[None, None, None, None, None, None, None, None, None, None]
18.3 有時在取 list 中元素時可能會遇到以下情形：
>>> a=[]>>> a[0]Traceback (most recent call last):
File "<stdin>", line 1, in <module>IndexError: list index out of range
這種情況發生是因爲只定義了一個空列表，沒有進行任何的賦值，所以列表裏什麼也沒有，而後面的報錯也明確表示了索引超出範圍，即寫上的0其實是第一位值的位置，而此時是空列表沒有賦值，故而報錯。
而如果我們使用以下語句則不會報錯：
>>> a[0:][]
這個不是什麼小技巧，這是不一樣的語句意義，這句話其實是把這個列表 a 裏的所有值都輸出，其效果和下面表達的最終結果是一致的。
>>> a[:][]
而這個語句並不能避免上面報錯中超出索引範圍的錯誤，這個根本就是兩種不同的意義的語句。a[0:] 和 a[:] 在腳本輸出時相當於 print(a) 的意思。這不是解決錯誤的方式，不能將它當成 trick 來用。
18.4
列表推導式書寫形式：
[表達式 for 變量 in 列表]或者[表達式 for 變量 in 列表 if 條件]
19.zip
描述zip() 函數用於將可迭代的對象作爲參數，將對象中對應的元素打包成一個個元組，然後返回由這些元組組成的列表。
如果各個迭代器的元素個數不一致，則返回列表長度與最短的對象相同，利用 * 號操作符，可以將元組解壓爲列表。
zip 方法在 Python 2 和 Python 3 中的不同：在 Python 3.x 中爲了減少內存，zip() 返回的是一個對象。如需展示列表，需手動 list() 轉換。
如果需要了解 Pyhton3 的應用，可以參考 Python3 zip()。
語法zip 語法：
zip([iterable, …])
參數說明：
iterabl – 一個或多個迭代器;
返回值返回元組列表。
實例以下實例展示了 zip 的使用方法：
>>>a = [1,2,3]
>>> b = [4,5,6]
>>> c = [4,5,6,7,8]
>>> zipped = zip(a,b) # 打包爲元組的列表 [(1, 4), (2, 5), (3, 6)]
>>> zip(a,c) # 元素個數與最短的列表一致 [(1, 4), (2, 5), (3, 6)]
>>> zip(*zipped) # 與 zip 相反，*zipped 可理解爲解壓，返回二維矩陣式 [(1, 2, 3), (4, 5, 6)]
20.tuple
tuple和list非常類似，但是tuple一旦初始化就不能修改，比如同樣是列出同學的名字：
代碼如下：
>>> classmates = ('Michael', 'Bob', 'Tracy')
現在，classmates這個tuple不能變了，它也沒有append()，insert()這樣的方法。其他獲取元素的方法和list是一樣的，你可以正常地使用classmates[0]，classmates[-1]，但不能賦值成另外的元素。不可變的tuple有什麼意義？因爲tuple不可變，所以代碼更安全。如果可能，能用tuple代替list就儘量用tuple。tuple的陷阱：當你定義一個tuple時，在定義的時候，tuple的元素就必須被確定下來，比如：
代碼如下：
>>> t = (1, 2)
>>> t
(1, 2)
如果要定義一個空的tuple，可以寫成()：
代碼如下：
>>> t = ()
>>> t
()
但是，要定義一個只有1個元素的tuple，如果你這麼定義：
代碼如下：
>>> t = (1)
>>> t
1
定義的不是tuple，是1這個數！這是因爲括號()既可以表示tuple，又可以表示數學公式中的小括號，這就產生了歧義，因此，Python規定，這種情況下，按小括號進行計算，計算結果自然是1。
所以，只有1個元素的tuple定義時必須加一個逗號 ,來消除歧義：
代碼如下:
>>> t = (1,)
>>> t
(1,)
Python在顯示只有1個元素的tuple時，也會加一個逗號,，以免你誤解成數學計算意義上的括號。
在來看一個"可變的"tuple：
代碼如下:
>>> t = ('a', 'b', ['A', 'B'])
>>> t[2][0] = 'X'
>>> t[2][1] = 'Y'
>>> t
('a', 'b', ['X', 'Y'])
這個tuple定義的時候有3個元素，分別是’a’，‘b’和一個list。不是說tuple一旦定義後就不可變了嗎？怎麼後來又變了？
別急，我們先看看定義的時候tuple包含的3個元素：當我們把list的元素’A’和’B’修改爲’X’和’Y’後，tuple變爲：表面上看，tuple的元素確實變了，但其實變的不是tuple的元素，而是list的元素。tuple一開始指向的list並沒有改成別的list，所以，tuple所謂的"不變"是說，tuple的每個元素，指向永遠不變。即指向’a’，就不能改成指向’b’，指向一個list，就不能改成指向其他對象，但指向的這個list本身是可變的！理解了"指向不變"後，要創建一個內容也不變的tuple怎麼做？那就必須保證tuple的每一個元素本身也不能變。
21.使用內置 enumerate 函數進行遍歷:
for index, item in enumerate(sequence):
process(index, item)
實例
>>> sequence = [12, 34, 34, 23, 45, 76, 89]
>>> for i, j in enumerate(sequence):
... print(i, j)...
0 121 342 343 234 455 766 89
22 yield關鍵字
yield 是一個類似 return 的關鍵字，只是這個函數返回的是個生成器。
>>> def createGenerator() :
... mylist = range(3)
... for i in mylist :
... yield i*i
...
>>> mygenerator = createGenerator() # create a generator
>>> print(mygenerator) # mygenerator is an object!<generator object createGenerator at 0xb7555c34
>>
>> for i in mygenerator:
... print(i)
這個例子沒什麼用途，但是它讓你知道，這個函數會返回一大批你只需要讀一次的值.
爲了精通 yield ,你必須要理解：當你調用這個函數的時候，函數內部的代碼並不立馬執行 ，這個函數只是返回一個生成器對象，這有點蹊蹺不是嗎。
那麼，函數內的代碼什麼時候執行呢？當你使用for進行迭代的時候.
現在到了關鍵點了！
第一次迭代中你的函數會執行，從開始到達 yield 關鍵字，然後返回 yield 後的值作爲第一次迭代的返回值. 然後，每次執行這個函數都會繼續執行你在函數內部定義的那個循環的下一次，再返回那個值，直到沒有可以返回的。
如果生成器內部沒有定義 yield 關鍵字，那麼這個生成器被認爲成空的。這種情況可能因爲是循環進行沒了，或者是沒有滿足 if/else 條件。
23.正則表達式
[外鏈圖片轉存失敗(img-CV9pY0GT-1563622653454)(en-resource://database/3886:1)]
[外鏈圖片轉存失敗(img-JR8g2mPP-1563622653454)(en-resource://database/3888:1)]
[外鏈圖片轉存失敗(img-0b0en018-1563622653454)(en-resource://database/3890:1)]
import os
import re
import warnings
warnings.simplefilter("ignore", UserWarning)
from matplotlib import pyplot as plt
import pandas as pd
pd.options.mode.chained_assignment = None
import numpy as np
from string import punctuation
from nltk.tokenize import word_tokenize
from sklearn.model_selection import train_test_split
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score, auc, roc_auc_score
from sklearn.externals import joblib
import scipy
from scipy.sparse import hstack
data = pd.read_csv('./data/tweets.csv', encoding='latin1', usecols=['Sentiment',
'SentimentText'])
data.columns = ['sentiment', 'text']
data = data.sample(frac=1, random_state=42)
print(data.shape)
for row in data.head(10).iterrows():
print(row[1]['sentiment'], row[1]['text'])
def tokenize(tweet):
tweet = re.sub(r'http\S+', '', tweet)
tweet = re.sub(r"#(\w+)", '', tweet)
tweet = re.sub(r"@(\w+)", '', tweet)
tweet = re.sub(r'[^\w\s]', '', tweet)
tweet = tweet.strip().lower()
tokens = word_tokenize(tweet)
return tokens
data['tokens'] = data.text.progress_map(tokenize)
data['cleaned_text'] = data['tokens'].map(lambda tokens: ' '.join(tokens))
data[['sentiment', 'cleaned_text']].to_csv('./data/cleaned_text.csv')
data = pd.read_csv('./data/cleaned_text.csv')
print(data.shape)
data.head()
x_train, x_test, y_train, y_test = train_test_split(data['cleaned_text'],
data['sentiment'],
test_size=0.1,
random_state=42,
stratify=data['sentiment'])
print(x_train.shape, x_test.shape, y_train.shape, y_test.shape)
pd.DataFrame(y_test).to_csv('./predictions/y_true.csv', index=False, encoding='utf-8')
24.Python中的 // 與 / 的區別 通常C/C++中，"/ " 算術運算符的計算結果是根據參與運算的兩邊的數據決定的，比如：
6 / 3 = 2 ; 6,3都是整數，那麼結果也就是整數2;
6.0 / 3.0 = 2.0 ; 6.0,3.0是浮點數，那麼結果也是浮點數2.0，跟精確的說，只要" / " 兩邊有一個數是浮點數，那麼結果就是浮點數。
在Python2.2版本以前也是這麼規定的，但是，Python的設計者認爲這麼做不符合Python簡單明瞭的特性，於是乎就在Python2.2以及以後的版本中增加了一個算術運算符" // “來表示整數除法，返回不大於結果的一個最大的整數，而” / " 則單純的表示浮點數除法，但是，爲了折中，所有2.X版本中，也是爲了向後兼容，如果要使用" // “，就必須加上一條語句：
from future import division
一看到這句，” / “就表示 浮點數除法，返回浮點結果;” // “表示整數除法。
但是，預計在Python3.0發佈時，就沒有這種折中情況了，，” / “就一定表示 浮點數除法，返回浮點結果;” // "表示整數除法。
25.python強制刷新緩衝區sys.stdout.flush() tqdm進度條
緩衝區的刷新方式：
1.flush()刷新緩存區
2.緩衝區滿時，自動刷新 3.文件關閉或者是程序結束自動刷新。
當我們打印一些字符時，並不是調用print函數後就立即打印的。一般會先將字符送到緩衝區，然後再打印。這就存在一個問題，如果你想等時間間隔的打印一些字符，但由於緩衝區沒滿，不會打印。就需要採取一些手段。如每次打印後強行刷新緩衝區。
for i in range(n):
print " * ",
sys.stdout.flush() #刷新緩衝區
time.sleep(1)
在使用tqdm時，就遇到這種問題：
明明是一個加載條，卻打印出兩個，影響美觀。後發現是因爲在加載條前有一句打印語句，可以看到tqdm先打印了一個加載條，但後面又來了個print，導致tqdm只能重新再打印一個加載條。因此強行刷新了緩衝區。
print(f'starting load trainset {cur_class} {n}')
sys.stdout.flush()
for i in tqdm(range(n)):
26.random
import random
print( random.randint(1,10) ) # 產生 1 到 10 的一個整數型隨機數
print( random.random() ) # 產生 0 到 1 之間的隨機浮點數
print( random.uniform(1.1,5.4) ) # 產生 1.1 到 5.4 之間的隨機浮點數，區間可以不是整數
print( random.choice('tomorrow') ) # 從序列中隨機選取一個元素
print( random.randrange(1,100,2) ) # 生成從1到100的間隔爲2的隨機整數
a=[1,3,5,6,7] # 將序列a中的元素順序打亂
random.shuffle(a)
print(a)
27.pickle
持久化數據對象
import pickle
'''
persistent object
'''
output = open('test.pkl', 'wb')
f = [1, 2, 3, '1', '2', '6']
data = {'a': [1, 2.0, 3, 4+6j],
'b': ('string', u'Unicode string'),
'c': None}
Pickle the list using protocol 0.
pickle.dump(f, output)
Pickle dictionary using the hightest protocol available.
pickle.dump(data, output, -1)
output.close()
'''
deserialization
'''
import pprint, pickle
pkl_file = open('test.pkl', 'rb')
f = pickle.load(pkl_file)
pprint.pprint(f)
data = pickle.load(pkl_file)
pprint.pprint(data)
pkl_file.close()
28.’’‘np.array’’’
p = np.array([[1, 3, 3, 4, 5, 6, 7, 8, 9, 0], [2, 3, 6, 7, 5, 6, 7, 8, 9, 0]])
print(p[1, 0::2]) # 顯示第二行位置是偶數的數字
29.time.time()
返回當前時間，單位秒
30.tqdm
解決進度條無法正常顯示的原因：
try:
with tqdm(...) as t:
for i in t: ...
except KeyboardInterrupt:
t.close()
raise
t.close()
31.判斷字符串是數字還是字母
str_1 = "123"
str_2 = "Abc"
str_3 = "123Abc"
#用isdigit函數判斷是否數字print(str_1.isdigit())
Ture
print(str_2.isdigit())
False
print(str_3.isdigit())
False
#用isalpha判斷是否字母print(str_1.isalpha())
False
print(str_2.isalpha())
Ture
print(str_3.isalpha())
False
#isalnum判斷是否數字和字母的組合print(str_1.isalnum())
Ture
print(str_2.isalnum())
Ture
print(str_1.isalnum())
Ture
32.[外鏈圖片轉存失敗(img-w330zFo4-1563622653455)(en-resource://database/3854:1)]
33. pycharm
代碼跳轉後退的快捷鍵是 ctrl+alt+←(左箭頭)