pythonemptydict
㈠ python計算數字出現次數問題！
def countdigits(aString):
c = 10*[0]
for e in aString:
c[int(e)] += 1
return c
def main():
for n,v in enumerate(countdigits(str(input('Enter a string of numbers: '))))
if v != 0:
print '%d occurs %d time%s'%(n, v, v!=1 and 's' or '')
main()
㈡ 如何串聯python知識點
1）避免『\n'等特殊字元的兩種方式：
a）利用轉義字元『\'b）利用原始字元『r' print r'c:\now'
2）單行注釋，使用一個#，如：
#hello Python多行注釋，使用三個單引號（或三個雙引號），如：'''hello pythonhello world'''或"""hello pythonhello world"""另外跨越多行的字元串。也可以使用三個單引號或三個雙引號，如：'''......'''或者"""......"""
3）字元串中嵌入雙引號等特殊符號
a）利用轉義字元『\'b）使用單引號括起這個字元串。print ('i l"o"ve fis.com')
4）條件分支：
if condition: 條件為真執行的操作 else: 條件為假執行的操作 if condition: action elif condition: action else: action python可以有效避免「懸掛else」（if else對應關系出錯）條件表達式（三元操作符） small = x if x<y else y 如果x<y ,small=x.否則small=y斷言assert：當這個關鍵字後面的條件為假，程序自動崩潰並拋出異常 assert 3>4 可以利用他置入檢查點
5）while條件:
條件為真執行的操作 for 目標 in 表達式：循環體 例：favorite='fishc' for i in favorite: print(i,end='') range([start,] stop[,step=1])生成一個從start參數的值到stop參數值的數字序列 break：終止當前循環體。跳到外層程序continue:終止本輪循環，開始下一輪循環（if condition true）
6）and邏輯操作符可以將任意表達式連接在一起，並得到一個布爾類型值
7）引入外援:
a）random模塊b）randint(),返回一個隨機的整數import random 或 from random import randint()secret=random.randint(1,10)
8）python數據類型
a）數值類型:整型、布爾類型、浮點型、e記法（1.5e10）b）類型轉換： int()轉換為整數 str()轉換為字元串 float()轉換為浮點數c）獲取關於類型的信息： type()函數 a=520 type(a) isinstance()函數 a=12 isinstance(a,int) --->返回true isinstance(a,str) -->返回false
9）Python值常用操作符
+ - * / % **（冪運算） //(地板除法,結果偏小)比較操作符 > < >= <=邏輯操作符 and or not 優先順序： 冪運算** 正負號 + - 算術操作符 * / // + - 比較操作符 < > = 邏輯擦作福 not and or
10）列表-->可以把整數、浮點數、字元串等打包在一起。數組卻不能
創建一個普通列表： member = ['小甲魚','小布丁','黑夜']創建一個混合列表： mix=[1,'小甲魚'，3.12，[1,2,3]]創建空列表： empty=[]向列表添加元素： append(): member.append('福祿娃')-->只能添加一個。末尾添加 extend(): member.extend(['test','test1'])-->只能以列表形式添加.末尾添加 insert(): member.insert(1,'牡丹')-->第一位插入牡丹列表中獲取元素：使用索引index。 mix[1]列表中刪除元素：使用remove()。 mix.remove('小甲魚') 使用del。 del mix[3]/mix 使用pop()。 mix.pop()/mix.pop(1)列表切片：使用slice。 mix[1:4]/mix[1:]/mix[:4]列表操作符：>,and,+,*,in/not in列表的小夥伴：dir(list) mix.count('小甲魚') mix.index('小甲魚')列表逆序：使用reverse。 mix.reverse()列表排序：使用sort。 mix.sort() mix.sort(func,key) mix.sort(reverse=True)
11）元組--->不可改變的列表
和列表的主要不同點：a）創建和訪問一個元組： 大部分用（）/, ；列表用[]b）元組不可修改數值c）更新和刪除一個元組：temp = temp[:2] + ('test3',) + temp[2:] del tempd）IN/NOT IN，關系操作符，邏輯操作符，乘號操作符，連接操作符
12）字元串的各種內置方法
str1='i love fishc.com'a=str1[:6] + '插入的字元串'+str1[6:]capitalize()： str2.capitalize()casefold()--->全部小寫 str2.casefold()center(width)-->居中，不足空格填充count(sub[,start[,end]])-->返回sub在string中出現的次數endswith(sub[,start[,end]])-->以sub結束？startswith(prefix[,start[,end]])-->以prefix開頭expandtabs([tabsize=8])-->將tab鍵轉換為空格find(sub[,start[,end]])-->sub是否在字元串中出現rfind(sub)...index(sub[,start[,end]])-->跟sub一樣，不過會產生異常rindex(sub..).....istitle()/isupper()/ljust(width)/lower()/strip()/title()/lower()join(sub):以字元串做分隔符，分割subpartion(sub):找到子字元串sub，把字元串分成一個3元組replace(old,new[,count])split(sep=none,maxsplit=-1)-->不帶參數以空格做分隔符swapcase()-->字元串大小寫翻轉zfill(width)-->返回長度為width的字元串，不夠補充空格
13）字元串格式化 replacement
"{0} love {1}.{2:.2f}".format("i","fishc",3.1424)"{a} love {b}.{c}".format(a="i",b="fishc",c="com")"{0} love {b}.{c}".format("i",b="fishc",c="com")格式化符號含義： %c:格式化字元及其ASCII碼 '%c %c %c' % (97,98,99) %s:格式化字元串 %d:格式化整數 %o:格式化無符號八進制數 %x:格式化無符號十六進制數 %X:...(大寫) %f:格式化定點數，可指定小數點後的精度 %e:用科學技術發格式化定點數===%E %g:根據值的大小決定使用%f或%e===%G格式化操作符輔助命令： m.n ：m是顯示的最小總寬度，n是小數位精度 - ：用於左對齊 + ：在正數面前添加正號 # ：在八進制面前顯示0，在十六進制面前顯示0x 0 ：空格用0填充字元串轉義字元 \a:發出系統響鈴聲 \b、\t、\n
14）序列
列表、元組和字元串的共同點： a）都可以通過索引 b）索引值從零開始內置方法： list（）-->help-->轉換為序列 list() a=list() list(iterable) b='i love fishc.com' b=list(b) tuple([iterable])-->把一個可迭代對象轉換為元組 b=tuple(b) str(obj)-->把obj對象轉換為字元串 len(obj)-->返回obj的長度 max(序列/元組) / min(序列/元組) sum(iterable[,start=0])-->返回序列iterable。。的總和 sorted(序列/元組)-->排序 reversed(序列/元組)-->返回一個迭代器對象 list(reversed(序列/元組))-->返回序列 enumerate(序列/元組)-->返回一個迭代器對象 list(enumerate(序列/元組))-->返回數組形式列表 zip（a,b）-->合並成以元組形式的列表 list(zip(a,b))
15）函數
定義：def Myfunction(): print('this is my first function')調用：Myfunction()函數的參數： def Myfunction(name,age): print(name+age+'test') Myfunction('gncao'，『age')函數的返回值: return value形參（parameter）：函數定義時的參數實參（argument）：實際傳遞的參數函數文檔：在函數中實現在函數體中用 '' 或 #查看函數文檔: a） functionname.__doc__ （四個下劃線） b） help(functionname)關鍵字參數：避免參數出亂 def Myfunction(words,name): ...... Myfunction(words='words123',name='name123') 默認參數: def Myfunction(name='name123',words='words123') ...... 收集參數：在參數前面加上*號 def test(*params): print('參數的長度是:',len(params)) print('第二個參數是:',params[1]) test(1,'小甲魚',2,4,5,6,7) def test(*params,exp): print('參數的長度是:',len(params),exp) print('第二個參數是:',params[1]) test(1,'小甲魚',23,4,2,5,7,exp=0)
16）函數有返回值，過程沒有返回值
17）函數變數作用域（可見性）
局部：local-->函數內部定義的變數，局部可用全局：global-->全局可訪問當在函數內部試圖修改全局變數時，則會在函數內部新建一個跟 全局變數名相同的局部變數
18）內嵌函數和閉包
global關鍵字： def myfun(): global count ->>>全局變數 count=10 print(count)內嵌函數: def fun1(): print('fun1()正在被調用...') def fun2(): print('fun2()正在被調用') fun2()只能通過fun1()訪問fun2()閉包:在一個內部函數中，對外部函數的變數的引用。成內部函數為閉包 def funx(x): def funy(y): return x * y return funy調用方式: i=funx(8) i(5) 或 funx(4)(5) 通過關鍵字nonlocal可以使得內部函數調用外部函數變數。 def fun1(): x=5 def fun2(): nonlocal x x*=x return x return fun2()
19，遞歸：
recursion（） def fac(n): if n==1: return 1 else: return n*fac(n-1) number=int(input('請輸入一個整數:')) result=fac(number) print('%d 的階乘是：%d' % (number,result)) 迭代方法：def fab(n): n1=1 n2=1 n3=1 if n <1: print('輸入有錯') return -1 while ( n-2>0 ): n3=n2+n1 n1=n2 n2=n3 n-=1 return n3 result=fab(20)if result != -1: print('總共有%d對小兔子誕生：' % result) 遞歸方法：def fab(n): if n < 1: print('error') return -1 if n==1 or n==2: return 1 else: return fab(n-1) + fab(n-2) result=fab(20)print('總共有%d對兔子誕生' % result) 但是遞歸的效率比較低
20）字典（key-value）映射/序列例1：dict1={'李寧':'一切皆有可能','耐克':'just do it','阿迪達斯':'impossible is nothing'} print('李寧的口號是:',dict1['李寧']) 例2:dict3=dict((('f',70),('i',105))) 例3:dict4=dict(小甲魚='編程改變世界',test='test')dict4['小甲魚']='修改小甲魚對應的value' -->如果沒有該KEY，則會自動添加一個KEY 字典的內建方法:a）dict2['key']-->訪問字典的元素b）fromkeys(s[,v]) -->創建或查詢keydict1.fromkeys((1,2,3)){1: None, 2: None, 3: None}dict1.fromkeys((1,2,3),'number'){1: 'number', 2: 'number', 3: 'number'}c）keys()-->dict.keys() -->列印出dict的所有keyvalues()-->dict.values() -->列印出dict的所有valueitems()-->dict.items() -->列印出dict所有(key,value)get()--> dict.get(key) -->列印key對應的valuedict.get(key,'text')-->列印key對應的value，如果不存在，則列印textin操作符 --> key in dict2clear() -->dict.clear() -->清空dict的數據() -->b=a.() -->拷貝字典id(a)-->查看idpop(key) --> dict.pop(key) -->彈出keypopitem() -->dict.popitem() -->隨機彈出keysetdefault() -->dict.setdefault(key) -->新建keyupdate() -->dict.update(dict) -->更新字典
㈢ python 函數變數 參數怎麼使用
剛學用Python的時候，特別是看一些庫的源碼時，經常會看到func(*args, **kwargs)這樣的函數定義，這個*和**讓人有點費解。其實只要把函數參數定義搞清楚了，就不難理解了。
先說說函數定義，我們都知道，下面的代碼定義了一個函數funcA
def funcA():
pass
顯然，函數funcA沒有參數（同時啥也不幹:D）。
下面這個函數funcB就有兩個參數了，
def funcB(a, b):
print a
print b
調用的時候，我們需要使用函數名，加上圓括弧擴起來的參數列表，比如 funcB(100, 99)，執行結果是：
100
99
很明顯，參數的順序和個數要和函數定義中一致，如果執行funcB(100)，Python會報錯的：
TypeError: funcB() takes exactly 2 arguments (1 given)
我們可以在函數定義中使用參數默認值，比如
def funcC(a, b=0):
print a
print b
在函數funcC的定義中，參數b有默認值，是一個可選參數，如果我們調用funcC(100)，b會自動賦值為0。
OK，目前為止，我們要定義一個函數的時候，必須要預先定義這個函數需要多少個參數（或者說可以接受多少個參數）。一般情況下這是沒問題的，但是也有在定義函數的時候，不能知道參數個數的情況（想一想C語言里的printf函數），在Python里，帶*的參數就是用來接受可變數量參數的。看一個例子
def funcD(a, b, *c):
print a
print b
print "length of c is: %d " % len(c)
print c
調用funcD(1, 2, 3, 4, 5, 6)結果是
1
2
length of c is: 4
(3, 4, 5, 6)
我們看到，前面兩個參數被a、b接受了，剩下的4個參數，全部被c接受了，c在這里是一個tuple。我們在調用funcD的時候，至少要傳遞2個參數，2個以上的參數，都放到c里了，如果只有兩個參數，那麼c就是一個empty tuple。
好了，一顆星我們弄清楚了，下面輪到兩顆星。
上面的例子里，調用函數的時候，傳遞的參數都是根據位置來跟函數定義里的參數表匹配的，比如funcB(100, 99)和funcB(99, 100)的執行結果是不一樣的。在Python里，還支持一種用關鍵字參數(keyword argument)調用函數的辦法，也就是在調用函數的時候，明確指定參數值付給那個形參。比如還是上面的funcB(a, b)，我們通過這兩種方式調用
funcB(a=100, b=99)
和
funcB(b=99, a=100)
結果跟funcB(100, 99)都是一樣的，因為我們在使用關鍵字參數調用的時候，指定了把100賦值給a，99賦值給b。也就是說，關鍵字參數可以讓我們在調用函數的時候打亂參數傳遞的順序！
另外，在函數調用中，可以混合使用基於位置匹配的參數和關鍵字參數，前題是先給出固定位置的參數，比如
def funcE(a, b, c):
print a
print b
print c
調用funcE(100, 99, 98)和調用funcE(100, c=98, b=99)的結果是一樣的。
好了，經過以上鋪墊，兩顆星總算可以出場了：
如果一個函數定義中的最後一個形參有 ** （雙星號）前綴,所有正常形參之外的其他的關鍵字參數都將被放置在一個字典中傳遞給函數，比如：
def funcF(a, **b):
print a
for x in b:
print x + ": " + str(b[x])
調用funcF(100, c='你好', b=200)，執行結果
100
c: 你好
b: 200
大家可以看到，b是一個dict對象實例，它接受了關鍵字參數b和c。
㈣ 用python單元測試怎麼測一段代碼
單元測試是用來對一個模塊、一個函數或者一個類來進行正確性檢驗的測試工作。
比如對函數abs()，我們可以編寫出以下幾個測試用例：
輸入正數，比如1、1.2、0.99，期待返回值與輸入相同；
輸入負數，比如-1、-1.2、-0.99，期待返回值與輸入相反；
輸入0，期待返回0；
輸入非數值類型，比如None、[]、{}，期待拋出TypeError。
把上面的測試用例放到一個測試模塊里，就是一個完整的單元測試。
如果單元測試通過，說明我們測試的這個函數能夠正常工作。如果單元測試不通過，要麼函數有bug，要麼測試條件輸入不正確，總之，需要修復使單元測試能夠通過。
單元測試通過後有什麼意義呢？如果我們對abs()函數代碼做了修改，只需要再跑一遍單元測試，如果通過，說明我們的修改不會對abs()函數原有的行為造成影響，如果測試不通過，說明我們的修改與原有行為不一致，要麼修改代碼，要麼修改測試。
這種以測試為驅動的開發模式最大的好處就是確保一個程序模塊的行為符合我們設計的測試用例。在將來修改的時候，可以極大程度地保證該模塊行為仍然是正確的。
我們來編寫一個Dict類，這個類的行為和dict一致，但是可以通過屬性來訪問，用起來就像下面這樣：
>>> d = Dict(a=1, b=2)
>>> d['a']
1
>>> d.a
1
mydict.py代碼如下：
class Dict(dict):
def __init__(self, **kw):
super(Dict, self).__init__(**kw)
def __getattr__(self, key):
try:
return self[key]
except KeyError:
raise AttributeError(r"'Dict' object has no attribute '%s'" % key)
def __setattr__(self, key, value):
self[key] = value
為了編寫單元測試，我們需要引入Python自帶的unittest模塊，編寫mydict_test.py如下：
import unittest
from mydict import Dict
class TestDict(unittest.TestCase):
def test_init(self):
d = Dict(a=1, b='test')
self.assertEquals(d.a, 1)
self.assertEquals(d.b, 'test')
self.assertTrue(isinstance(d, dict))
def test_key(self):
d = Dict()
d['key'] = 'value'
self.assertEquals(d.key, 'value')
def test_attr(self):
d = Dict()
d.key = 'value'
self.assertTrue('key' in d)
self.assertEquals(d['key'], 'value')
def test_keyerror(self):
d = Dict()
with self.assertRaises(KeyError):
value = d['empty']
def test_attrerror(self):
d = Dict()
with self.assertRaises(AttributeError):
value = d.empty
編寫單元測試時，我們需要編寫一個測試類，從unittest.TestCase繼承。
以test開頭的方法就是測試方法，不以test開頭的方法不被認為是測試方法，測試的時候不會被執行。
對每一類測試都需要編寫一個test_xxx()方法。由於unittest.TestCase提供了很多內置的條件判斷，我們只需要調用這些方法就可以斷言輸出是否是我們所期望的。最常用的斷言就是assertEquals()：
self.assertEquals(abs(-1), 1) # 斷言函數返回的結果與1相等
另一種重要的斷言就是期待拋出指定類型的Error，比如通過d['empty']訪問不存在的key時，斷言會拋出KeyError：
with self.assertRaises(KeyError):
value = d['empty']
而通過d.empty訪問不存在的key時，我們期待拋出AttributeError：
with self.assertRaises(AttributeError):
value = d.empty
運行單元測試
一旦編寫好單元測試，我們就可以運行單元測試。最簡單的運行方式是在mydict_test.py的最後加上兩行代碼：
if __name__ == '__main__':
unittest.main()
這樣就可以把mydict_test.py當做正常的python腳本運行：
$ python mydict_test.py
另一種更常見的方法是在命令行通過參數-m unittest直接運行單元測試：
$ python -m unittest mydict_test
.....
----------------------------------------------------------------------
Ran 5 tests in 0.000s
OK
這是推薦的做法，因為這樣可以一次批量運行很多單元測試，並且，有很多工具可以自動來運行這些單元測試。
setUp與tearDown
可以在單元測試中編寫兩個特殊的setUp()和tearDown()方法。這兩個方法會分別在每調用一個測試方法的前後分別被執行。
setUp()和tearDown()方法有什麼用呢？設想你的測試需要啟動一個資料庫，這時，就可以在setUp()方法中連接資料庫，在tearDown()方法中關閉資料庫，這樣，不必在每個測試方法中重復相同的代碼：
class TestDict(unittest.TestCase):
def setUp(self):
print 'setUp...'
def tearDown(self):
print 'tearDown...'
可以再次運行測試看看每個測試方法調用前後是否會列印出setUp...和tearDown...。
㈤ python中如何提取一組數據中的第一列數據
概述
直接提取會報錯，把array數組轉換成list，即可提取，使用numpy轉換
步驟詳解
1、直接提取嘗試：
group=[[1,2],[2,3],[3,4]]
#提取第一列元素
print(group[:,1])
#Out:TypeError: list indices must be integers or slices, not tuple
2、使用numpy轉換：
import numpy as np
group=[[1,2],[2,3],[3,4]]
#numpy轉化
ar=np.array(group)
print(ar[:,1])
#Out:[2 3 4]
拓展內容
numpy詳解
Numpy對象是數組，稱為ndarray
維度(dimensions)稱作軸(axes),軸的個數叫做秩(rank)。註：有幾級中括弧就有幾個維度
一、ndarray.attrs:
ndarray.ndim 秩
ndarray.shape 例如一個2排3列的矩陣，它的shape屬性是(2,3)
ndarray.size 數組元素的總個數
ndarray.dtype 元素類型，NumPy提供自己的數據類型
ndarray.itemsize 數組中每個元素的位元組大小
二、數組創建函數：
array
asarray將輸入轉換成ndarray
arange
ones
zeros
empty 只分配內存空間不填充任何值
eye 創建N*N單位矩陣(對角線為1)
三、數組和標量之間的運算
numpy數組的一個特點，不用編寫循環就可對數據執行批量運算，這通常稱作矢量化(vectorization)。
四、基本的索引和切片
numpy數組的索引是一個內容豐富的主題，因為選取數據子集或單個元素的方式有很多。這里我僅詳細介紹常用的方法，對於高級功能的方式我列舉名稱，讀者可以等到要用的時候自行查閱資料。
㈥ python怎麼對defaultdict中的值進行操作
In[52]:
In[53]:data_str='sdgfdhggerg'
In[54]:counter=defaultdict(int)
In[55]:foritemindata_str:
...:counter[item]+=1
...:
In[56]:counter
Out[56]:defaultdict(int,{'d':2,'e':1,'f':1,'g':4,'h':1,'r':1,'s':1})
In[57]:dir(defaultdict)
Out[57]:
['__class__',
'__cmp__',
'__contains__',
'____',
'__delattr__',
'__delitem__',
'__doc__',
'__eq__',
'__format__',
'__ge__',
'__getattribute__',
'__getitem__',
'__gt__',
'__hash__',
'__init__',
'__iter__',
'__le__',
'__len__',
'__lt__',
'__missing__',
'__ne__',
'__new__',
'__rece__',
'__rece_ex__',
'__repr__',
'__setattr__',
'__setitem__',
'__sizeof__',
'__str__',
'__subclasshook__',
'clear',
'',
'default_factory',
'fromkeys',
'get',
'has_key',
'items',
'iteritems',
'iterkeys',
'itervalues',
'keys',
'pop',
'popitem',
'setdefault',
'update',
'values',
'viewitems',
'viewkeys',
'viewvalues']
In[58]:counter.keys()
Out[58]:['e','d','g','f','h','s','r']
In[59]:counter.values()
Out[59]:[1,2,4,1,1,1,1]
In[60]:counter.iteritems()
Out[60]:<dictionary-itemiteratorat0x43be9a8>
In[61]:counter.iteritems
Out[61]:<functioniteritems>
In[63]:new_defau=defaultdict(int,{'a':5})
In[64]:counter.update(new_defau)
In[65]:counter
Out[65]:
defaultdict(int,
{'a':5,'d':2,'e':1,'f':1,'g':4,'h':1,'r':1,'s':1})
㈦ python queue中有幾個元素
直接這樣就可以看到了
>>> dir(queue)
['Empty', 'Full', 'LifoQueue', 'PriorityQueue', 'Queue', '__all__', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', 'deque', 'heappop', 'heappush', 'threading', 'time']
>>> dir(queue.Queue)
['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__le__', '__lt__', '__mole__', '__ne__', '__new__', '__rece__', '__rece_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_get', '_init', '_put', '_qsize', 'empty', 'full', 'get', 'get_nowait', 'join', 'put', 'put_nowait', 'qsize', 'task_done']
>>>
使用qsize這個函數就可以得到元素數
㈧ python 讀取CSV 文件
讀取一個CSV 文件
最全的
一個簡化版本
filepath_or_buffer : str，pathlib。str, pathlib.Path, py._path.local.LocalPath or any object with a read() method (such as a file handle or StringIO)
可以是URL，可用URL類型包括：http, ftp, s3和文件。對於多文件正在准備中
本地文件讀取實例：://localhost/path/to/table.csv
**sep **: str, default 『,』
指定分隔符。如果不指定參數，則會嘗試使用逗號分隔。分隔符長於一個字元並且不是『s+』,將使用python的語法分析器。並且忽略數據中的逗號。正則表達式例子：' '
**delimiter **: str, default None
定界符，備選分隔符（如果指定該參數，則sep參數失效）
delim_whitespace : boolean, default False.
指定空格(例如』 『或者』 『)是否作為分隔符使用，等效於設定sep='s+'。如果這個參數設定為Ture那麼delimiter 參數失效。
在新版本0.18.1支持
header : int or list of ints, default 『infer』
指定行數用來作為列名，數據開始行數。如果文件中沒有列名，則默認為0，否則設置為None。如果明確設定header=0 就會替換掉原來存在列名。header參數可以是一個list例如：[0,1,3]，這個list表示將文件中的這些行作為列標題（意味著每一列有多個標題），介於中間的行將被忽略掉。
注意：如果skip_blank_lines=True 那麼header參數忽略注釋行和空行，所以header=0表示第一行數據而不是文件的第一行。
**names **: array-like, default None
用於結果的列名列表，如果數據文件中沒有列標題行，就需要執行header=None。默認列表中不能出現重復，除非設定參數mangle_pe_cols=True。
index_col : int or sequence or False, default None
用作行索引的列編號或者列名，如果給定一個序列則有多個行索引。
如果文件不規則，行尾有分隔符，則可以設定index_col=False 來是的pandas不適用第一列作為行索引。
usecols : array-like, default None
返回一個數據子集，該列表中的值必須可以對應到文件中的位置（數字可以對應到指定的列）或者是字元傳為文件中的列名。例如：usecols有效參數可能是 [0,1,2]或者是 [『foo』, 『bar』, 『baz』]。使用這個參數可以加快載入速度並降低內存消耗。
as_recarray : boolean, default False
不贊成使用：該參數會在未來版本移除。請使用pd.read_csv(...).to_records()替代。
返回一個Numpy的recarray來替代DataFrame。如果該參數設定為True。將會優先squeeze參數使用。並且行索引將不再可用，索引列也將被忽略。
**squeeze **: boolean, default False
如果文件值包含一列，則返回一個Series
**prefix **: str, default None
在沒有列標題時，給列添加前綴。例如：添加『X』 成為 X0, X1, ...
**mangle_pe_cols **: boolean, default True
重復的列，將『X』...』X』表示為『X.0』...』X.N』。如果設定為false則會將所有重名列覆蓋。
dtype : Type name or dict of column -> type, default None
每列數據的數據類型。例如 {『a』: np.float64, 『b』: np.int32}
**engine **: {『c』, 『python』}, optional
Parser engine to use. The C engine is faster while the python engine is currently more feature-complete.
使用的分析引擎。可以選擇C或者是python。C引擎快但是Python引擎功能更加完備。
converters : dict, default None
列轉換函數的字典。key可以是列名或者列的序號。
true_values : list, default None
Values to consider as True
false_values : list, default None
Values to consider as False
**skipinitialspace **: boolean, default False
忽略分隔符後的空白（默認為False，即不忽略）.
skiprows : list-like or integer, default None
需要忽略的行數（從文件開始處算起），或需要跳過的行號列表（從0開始）。
skipfooter : int, default 0
從文件尾部開始忽略。 (c引擎不支持)
skip_footer : int, default 0
不推薦使用：建議使用skipfooter ，功能一樣。
nrows : int, default None
需要讀取的行數（從文件頭開始算起）。
na_values : scalar, str, list-like, or dict, default None
一組用於替換NA/NaN的值。如果傳參，需要制定特定列的空值。默認為『1.#IND』, 『1.#QNAN』, 『N/A』, 『NA』, 『NULL』, 『NaN』, 『nan』`.
**keep_default_na **: bool, default True
如果指定na_values參數，並且keep_default_na=False，那麼默認的NaN將被覆蓋，否則添加。
**na_filter **: boolean, default True
是否檢查丟失值（空字元串或者是空值）。對於大文件來說數據集中沒有空值，設定na_filter=False可以提升讀取速度。
verbose : boolean, default False
是否列印各種解析器的輸出信息，例如：「非數值列中缺失值的數量」等。
skip_blank_lines : boolean, default True
如果為True，則跳過空行；否則記為NaN。
**parse_dates **: boolean or list of ints or names or list of lists or dict, default False
infer_datetime_format : boolean, default False
如果設定為True並且parse_dates 可用，那麼pandas將嘗試轉換為日期類型，如果可以轉換，轉換方法並解析。在某些情況下會快5~10倍。
**keep_date_col **: boolean, default False
如果連接多列解析日期，則保持參與連接的列。默認為False。
date_parser : function, default None
用於解析日期的函數，默認使用dateutil.parser.parser來做轉換。Pandas嘗試使用三種不同的方式解析，如果遇到問題則使用下一種方式。
1.使用一個或者多個arrays（由parse_dates指定）作為參數；
2.連接指定多列字元串作為一個列作為參數；
3.每行調用一次date_parser函數來解析一個或者多個字元串（由parse_dates指定）作為參數。
**dayfirst **: boolean, default False
DD/MM格式的日期類型
**iterator **: boolean, default False
返回一個TextFileReader 對象，以便逐塊處理文件。
chunksize : int, default None
文件塊的大小， See IO Tools docs for more information on iterator and chunksize.
compression : {『infer』, 『gzip』, 『bz2』, 『zip』, 『xz』, None}, default 『infer』
直接使用磁碟上的壓縮文件。如果使用infer參數，則使用 gzip, bz2, zip或者解壓文件名中以『.gz』, 『.bz2』, 『.zip』, or 『xz』這些為後綴的文件，否則不解壓。如果使用zip，那麼ZIP包中國必須只包含一個文件。設置為None則不解壓。
新版本0.18.1版本支持zip和xz解壓
thousands : str, default None
千分位分割符，如「，」或者「."
decimal : str, default 『.』
字元中的小數點 (例如：歐洲數據使用』，『).
float_precision : string, default None
Specifies which converter the C engine should use for floating-point values. The options are None for the ordinary converter, high for the high-precision converter, and round_trip for the round-trip converter.
指定
**lineterminator **: str (length 1), default None
行分割符，只在C解析器下使用。
**quotechar **: str (length 1), optional
引號，用作標識開始和解釋的字元，引號內的分割符將被忽略。
quoting : int or csv.QUOTE_* instance, default 0
控制csv中的引號常量。可選 QUOTE_MINIMAL (0), QUOTE_ALL (1), QUOTE_NONNUMERIC (2) or QUOTE_NONE (3)
doublequote : boolean, default True
雙引號，當單引號已經被定義，並且quoting 參數不是QUOTE_NONE的時候，使用雙引號表示引號內的元素作為一個元素使用。
escapechar : str (length 1), default None
當quoting 為QUOTE_NONE時，指定一個字元使的不受分隔符限值。
comment : str, default None
標識著多餘的行不被解析。如果該字元出現在行首，這一行將被全部忽略。這個參數只能是一個字元，空行（就像skip_blank_lines=True）注釋行被header和skiprows忽略一樣。例如如果指定comment='#' 解析『#empty a,b,c 1,2,3』 以header=0 那麼返回結果將是以』a,b,c'作為header。
encoding : str, default None
指定字元集類型，通常指定為'utf-8'. List of Python standard encodings
dialect : str or csv.Dialect instance, default None
如果沒有指定特定的語言，如果sep大於一個字元則忽略。具體查看csv.Dialect 文檔
tupleize_cols : boolean, default False
Leave a list of tuples on columns as is (default is to convert to a Multi Index on the columns)
error_bad_lines : boolean, default True
如果一行包含太多的列，那麼默認不會返回DataFrame ，如果設置成false，那麼會將改行剔除（只能在C解析器下使用）。
warn_bad_lines : boolean, default True
如果error_bad_lines =False，並且warn_bad_lines =True 那麼所有的「bad lines」將會被輸出（只能在C解析器下使用）。
**low_memory **: boolean, default True
分塊載入到內存，再低內存消耗中解析。但是可能出現類型混淆。確保類型不被混淆需要設置為False。或者使用dtype 參數指定類型。注意使用chunksize 或者iterator 參數分塊讀入會將整個文件讀入到一個Dataframe，而忽略類型（只能在C解析器中有效）
**buffer_lines **: int, default None
不推薦使用，這個參數將會在未來版本移除，因為他的值在解析器中不推薦使用
compact_ints : boolean, default False
不推薦使用，這個參數將會在未來版本移除
如果設置compact_ints=True ，那麼任何有整數類型構成的列將被按照最小的整數類型存儲，是否有符號將取決於use_unsigned 參數
use_unsigned : boolean, default False
不推薦使用：這個參數將會在未來版本移除
如果整數列被壓縮(i.e. compact_ints=True)，指定被壓縮的列是有符號還是無符號的。
memory_map : boolean, default False
如果使用的文件在內存內，那麼直接map文件使用。使用這種方式可以避免文件再次進行IO操作。
ref：
http://pandas.pydata.org/pandas-docs/stable/generated/pandas.read_csv.html
㈨ 如何安裝python中的parsel
python-parsel
Parsel是一個使用XPath和CSS選擇器（可選地與正則表達式結合）從HTML和XML提取數據的庫
一、安裝
官網：https://pypi.org/project/parsel/
pip安裝：pip install parsel 默認安裝的是最新版
pip install parsel=1.6.0 目前官方最新版本
PyCharm：File =》Setting =》Project：sintemple =》 Project：Interpreter =》點擊右上角的加號（或者按快捷鍵Alt+Insert）=》在輸入框中輸入parsel，會出現一個只有parsel的一列，點擊選擇它 =》Install Package 等待安裝完成就可以了（註：其中Specify version選中可以在下拉框中選擇版本）
————————————————
三、csstranslator
TranslatorMixin
This mixin adds support to CSS pseudo elements via dynamic dispatch.Currently supported pseudo-elements are ::text and ::attr(ATTR_NAME).
①. xpath_attr_functional_pseudo_element(xpath, function)
Support selecting attribute values using ::attr() pseudo-element
②. xpath_element(selector)
③. xpath_pseudo_element(xpath, pseudo_element)
Dispatch method that transforms XPath to support pseudo-element
④. xpath_text_simple_pseudo_element(xpath)
Support selecting text nodes using ::text pseudo-element
XPathExpr(path=』』, element=』*』, condition=』』, star_prefix=False)
GenericTranslator
HTMLTranslator(xhtml=False)
四、utils
extract_regex(regex, text, replace_entities=True)
Extract a list of unicode strings from the given text/encoding using the following policies: * if the regex contains a named group called 「extract」 that will be returned * if the regex contains multiple numbered groups, all those will be returned (flattened) * if the regex doesn』t contain any group the entire regex matching is returned
flatten(sequence) → list
Returns a single, flat list which contains all elements retrieved from the sequence and all recursively contained sub-sequences (iterables). Examples: >>> [1, 2, [3,4], (5,6)] [1, 2, [3, 4], (5, 6)] >>> flatten([[[1,2,3], (42,None)], [4,5], [6], 7, (8,9,10)]) [1, 2, 3, 42, None, 4, 5, 6, 7, 8, 9, 10] >>> flatten([「foo」, 「bar」]) [『foo』, 『bar』] >>> flatten([「foo」, [「baz」, 42], 「bar」]) [『foo』, 『baz』, 42, 『bar』]
iflatten(sequence) → Iterator
Similar to .flatten(), but returns iterator instead
shorten(text, width, suffix=』…』)
Truncate the given text to fit in the given width.
————————————————
原文鏈接：網頁鏈接
㈩ python中集合的特點和注意點
1、集合概念
Python中的集合，是一個無序的、沒有重復項的集。它支持數學概念上的集合操作，如交集、並集、補集和差集。集合是可變的，可以在其中添加或刪除項。集合用花括弧「{}」括起來，並用逗號「,」來分隔其中的項。
2、創建集合
可以使用花括弧「{}」創建集合，集合會自動去除重復的項。下面的集合包含了幾種用字元串表示的水果：
>>>#創建fruits集合時，'apple'出現了兩次
>>>fruits={'apple','banana','watermelon','strawberry','apple'}
>>>fruits#查看fruits集合，'apple'只有保留了一個
{'apple','strawberry','banana','watermelon'}
>>>fruits=set(['apple','banana','watermelon','strawberry','apple'])#以列表為參數創建集合
>>>fruits
{'apple','strawberry','banana','watermelon'}
>>>numbers=set((1,2,3,3,2,4))#以元組為參數創建集合
>>>numbers
{1,2,3,4}
>>>letters=set('banana')#以字元串為參數創建集合
>>>letters
{'b','a','n'}
>>>empty={}
>>>empty
{}
>>>type(empty)
<class'dict'>
>>>empty=set()
>>>empty#空集合表示為set()
set()
>>>type(empty)
<class'set'>
>>>numbers={1,2,3}
>>>numbers.add(4)#向numbers集合中添加整數4
>>>numbers
{1,2,3,4}
>>>numbers.add('five')#向numbers集合中添加字元串'five'
>>>numbers
{1,2,3,4,'five'}
>>>numbers.add((5,6,7))#向numbers集合中添加元組(5,6,7)
>>>numbers
{1,2,3,4,(5,6,7),'five'}
>>>fruits={'apple','strawberry','banana','watermelon'}
>>>fruits
{'banana','apple','watermelon','strawberry'}
>>>fruits.add('apple')#添加已經存在的項'apple'
>>>fruits#fruits集合並沒有改變
{'banana','apple','watermelon','strawberry'}
>>>numbers={1}
>>>numbers
{1}
>>>numbers.update((5,6,7))
>>>numbers#可以看出update()方法和add()方法的區別
{1,5,6,7}
>>>numbers.update({4,5},{6,7,8})#參數為兩個集合
>>>numbers
{1,4,5,6,7,8}
>>>numbers={1,2,3,5,7}
>>>numbers.remove(1)
>>>numbers
{2,3,5,7}
>>>numbers.remove(3)
>>>numbers
{2,5,7}
>>>numbers={1,2,3,5,7}
>>>numbers.remove(4)
Traceback(mostrecentcalllast):
File"<stdin>",line1,in<mole>
KeyError:4
>>>numbers={1,2,3,5,7}
>>>numbers.discard(1)
>>>numbers
{2,3,5,7}
>>>numbers.discard(3)
>>>numbers
{2,5,7}
>>>numbers.discard(4)
>>>numbers#什麼也沒發生
{2,5,7}
>>>numbers={1,2,3,5,7}
>>>1innumbers#1在numbers集合中，返回True
True
>>>3innumbers#3在numbers集合中，返回True
True
>>>4innumbers#4不在numbers集合中，返回False
False
>>>4notinnumbers#notin是in的反向操作
True
>>>empty=set()
>>>len(empty)
0
>>>numbers={1,2,3,5,7}
>>>len(numbers)
5
與列表、元組、字典一樣，集合也可以用工廠函數set()來創建。set()函數的參數要麼為空，要麼為可迭代對象(如列表、元組和字元串)：
如果想要創建一個空集合，那麼使用空的花括弧「{}」是行不通的，因為這樣創建的是一個空字典：
創建空集合的唯一方式就是使用不包含任何參數的set()函數：
3、集合添加項
集合是可變的數據類型，在創建集合之後，可以使用集合的add()方法向其添加項：
如果向某個集合中添加已經存在的項，那麼什麼也不會發生：
也可以使用集合的update()方法向集合中添加項，參數必須是可迭代對象，如列表、字元串或另一個集合。類似於列表的append()方法和extend()方法，但區別是集合的update()方法總是會將可迭代對象「展開」：
4、集合刪除項
可以使用集合的remove()方法刪除某個集合中的指定項：
如果試圖刪除集合中不存在的項，那麼Python解釋器會報錯：
還可以使用集合的discard()方法來刪除項，它和remove()方法唯一的區別是，當試圖刪除不存在的項時，discard()方法並不會報錯，而是什麼也不會發生：
5、檢查某個項是否在集合中
集合的in操作符用於檢查指定項是否在集合中，not in操作符用於檢查指定項是否不在集合中：
6、查看集合的長度
集合的內建函數len()用於查看集合的長度，即集合中項的個數：