map() 函數(shù)接受兩個參數(shù)，一個是函數(shù)，一個是可迭代對象（Iterable）, map 將傳入的函數(shù)依次作用到可迭代對象的每一個元素，并把結(jié)果作為迭代器(Iterator)返回。
創(chuàng)新互聯(lián)自2013年起，是專業(yè)互聯(lián)網(wǎng)技術(shù)服務(wù)公司，擁有項目成都網(wǎng)站設(shè)計、成都做網(wǎng)站網(wǎng)站策劃，項目實施與項目整合能力。我們以讓每一個夢想脫穎而出為使命，1280元靖州做網(wǎng)站,已為上家服務(wù),為靖州各地企業(yè)和個人服務(wù),聯(lián)系電話:028-86922220
舉例說明，有一個函數(shù) f(x)=x^2 ，要把這個函數(shù)作用到一個list [1,2,3,4,5,6,7,8,9] 上：
運用簡單的循環(huán)可以實現(xiàn)：
運用高階函數(shù) map() ：
結(jié)果 r 是一個迭代器，迭代器是惰性序列，通過 list() 函數(shù)讓它把整個序列都計算出來并返回一個 list 。
如果要把這個list所有數(shù)字轉(zhuǎn)為字符串利用 map() 就簡單了：
小練習(xí)：利用 map() 函數(shù)，把用戶輸入的不規(guī)范的英文名字變?yōu)槭鬃帜复髮懫渌懙囊?guī)范名字。輸入 ['adam', 'LISA', 'barT'] ,輸出 ['Adam', 'Lisa', 'Bart']
reduce() 函數(shù)也是接受兩個參數(shù)，一個是函數(shù)，一個是可迭代對象， reduce 將傳入的函數(shù)作用到可迭代對象的每個元素的結(jié)果做累計計算。然后將最終結(jié)果返回。
效果就是： reduce(f, [x1, x2, x3, x4]) = f(f(f(x1, x2), x3), x4)
舉例說明，將序列 [1,2,3,4,5] 變換成整數(shù) 12345 ：
小練習(xí)：編寫一個 prod() 函數(shù)，可以接受一個 list 并利用 reduce 求積：
map() 和 reduce() 綜合練習(xí)：編寫 str2float 函數(shù)，把字符串 '123.456' 轉(zhuǎn)換成浮點型 123.456
filter() 函數(shù)用于過濾序列， filter() 也接受一個函數(shù)和一個序列， filter() 把傳入的函數(shù)依次作用于每個元素，然后根據(jù)返回值是 True 還是 False 決定保留還是丟棄該元素。
舉例說明，刪除list中的偶數(shù):
小練習(xí)：用 filter() 求素數(shù)
定義一個篩選函數(shù)：
定義一個生成器不斷返回下一個素數(shù)：
打印100以內(nèi)素數(shù)：
python內(nèi)置的 sorted() 函數(shù)可以對list進行排序：
sorted() 函數(shù)也是一個高階函數(shù)，還可以接受一個 key 函數(shù)來實現(xiàn)自定義排序：
key 指定的函數(shù)將作用于list的每一個元素上，并根據(jù) key 函數(shù)返回的結(jié)果進行排序.
默認情況下，對字符串排序，是按照ASCII的大小比較的，由于'Z' 'a'，結(jié)果，大寫字母Z會排在小寫字母a的前面。如果想忽略大小寫可都轉(zhuǎn)換成小寫來比較：
要進行反向排序，不必改動key函數(shù)，可以傳入第三個參數(shù) reverse=True ：
小練習(xí)：假設(shè)我們用一組tuple表示學(xué)生名字和成績： L = [('Bob', 75), ('Adam', 92), ('Bart', 66), ('Lisa', 88)] 。用sorted()對上述列表分別按c成績從高到低排序：
運用匿名函數(shù)更簡潔：
pandas官方文檔:
對常用函數(shù)做了匯總，每個函數(shù)的參數(shù)可能不是全的，但是常用的，不常用的沒總結(jié)，如有問題，請不吝賜教，謝謝！
1、創(chuàng)建Series
? 通用函數(shù)：pd.Series(values,index)
1)pd.Series([1,2,3],index=[‘a(chǎn)’,‘b’,‘c‘])
2)pd.Series(np.array([1,2,3]),index=[‘a(chǎn)’,‘b’,‘c‘])
3)pd.Series({ 'a'：1,? 'b'：2,? 'c'：3})
? ? Series轉(zhuǎn)字典：Series.to_dict()
說明：Series的values參數(shù)是python中常見的一維數(shù)據(jù)類型。
2、屬性
1）Series.values ---array([1,2,3])
? ? ?? Series的values是array類型
2）Series.index---index([‘a(chǎn)’,‘b’,‘c‘])
? ? ?? 未指定index時，自動生成 0-（N-1）的整數(shù)索引，
? ? ?? 指定 index時，使用指定索引。
3、Series的索引與切片
?? Series[0] / Series['a']? : Sereis可以位置索引或標簽索引，也可以進行切片操作
1、創(chuàng)建DataFrame
1) 創(chuàng)建DataFrame的通用函數(shù)：
df = pd.DataFrame(values,index,columns)
pd.dataFrame([[1,2,3],[4,5,6],[7,8,9]],index=['a','b','c'],columns=['bj','sh','sz'])
pd.dataFrame(np.arange(1,10).reshape(3,3),index=['a','b','c'],columns=['bj','sh','sz'])
pd.dataFrame('bj':[1,4,7],'sh':[2,5,8],'sz':[3,6,9],index=['a','b','c'])
說明：創(chuàng)建方法與Sries類似，Series的values參數(shù)是python中常見的一維數(shù)據(jù)類型，DataFrame的values參數(shù)是python中常見的二維數(shù)據(jù)類型。
2) 通過網(wǎng)頁中復(fù)制數(shù)據(jù)快捷創(chuàng)建
? ? import webbrowser
? ? link = ''
? ? webbrowser.open(link)
? ? 打開界面進行復(fù)制，將數(shù)據(jù)復(fù)制到粘貼板中
? ? df = pd.read_clipboard() ? #從粘貼板中讀取數(shù)據(jù)
3）通過Series創(chuàng)建DataFrame
? ? df = pd.DataFrame([s1,s2,s3],columns=['bj','sh','sz'])
? ? 注意：單獨的s1,s2,s3是縱向排列的的Series，但是在DataFrame中是橫向排列的。
? ? 自己總結(jié)：Series除了打印出來是Series格式外，其他時候可以直接當作list來操作。
2、屬性
1)df.columns
? ? 通過columns生成新的DataFrame
? ? df_new = pd.DataFrame(df,columns=['x1','x2'])
? ? 或者df_new = df[['x1','x2']]
2)df.shape? 顯示行列數(shù)
3)df.head() ? 默認顯示前5行
4)df.tail() ? ? 默認顯示后5行
3、獲取DataFrame的列
1）獲取DataFrame某一列
? ? ? df.x1或df['x1']:返回值是Series,可以理解為一個DataFrame是由多個Series組成的。
? 2) 獲取DataFrame某幾列
? ? ? df_new = df[['x1','x2','x3']]
4、為某列賦值
? 1) df['x1'] = range(10)
? 2) df['x1'] = numpy.arange(10)
? 3) df['x1'] = pd.Series(np.arange(10))
? 說明：類似于創(chuàng)建Series
5、為某列對應(yīng)的特定行重新賦值
? ? df['x1'] = pd.Series([2,3],index=[0,1])
? ? 將列為x1,行索引為0和1的值改為2,3
6、獲取DadaFrame的行
? for row in DataFrame.iterrows():
? ? ? ? ? print(row[0],row[1])
? #每個row是一個元祖，包含2個元素，row[0]是整型索引，row[1]是Series,所以從行的角度也可以看出，一個DataFrame是由多個Series組成的。
7、DataFrame的轉(zhuǎn)置
? df_new = df.T
1、粘貼板的io
? df = pd.read_clipboard()
? df.to_clipboard()
2、csv的io
?? df.to_csv('xxx.csv')
?? df = pd.read_csv('xxx.csv')
3、json的io
?? df.to_json()
?? pd.read_json(df.to_json())
4、excel的io
? ? df.to_excel('xx.xlsx')
? ? df = pd.read_excel('xx.xlsx')
5、df = pd.read_sql('')
? ? df.to_sql('')
1、iloc
? sub_df = df.iloc[10:20,:]? 選取DataFrame的10-20行，所有列數(shù)據(jù)
? sub_df = df.iloc[10:20,0:2]
? 說明：iloc函數(shù)是位置索引，與索引的名字無關(guān)。
2、loc
? sub_df = df.loc[10:20,:'movie_name']
? 說明：loc是標簽索引，10,20，'movie_name'? 都是索引名字，與位置無關(guān)。
1、Series.reindex(index=['x1','x2','x3'],fill_value=10)
? 將df重新索引，并且將NaN空值用10進行填充
2、Series.reindex(index=range(15),method='ffill')
前項填充，后面的值用前面的值進行填充
通過reindex想到，如果想新增一個空列或者空行，可以用reindex方法,同樣地，想減少某些行或者某些列，也可以用reindex方法。
? 繼reindex之后刪除行列的函數(shù)操作
? Series.drop('A') ? #刪除'A'所對應(yīng)的值
? DataFrame.drop(label,axis)?
? label可以是行名也可以是列名，label是行的話axis是0，label是列的話axis是1。
** 刪除行還可以用 del df['A']
nan是numpy的一種數(shù)據(jù)類型，np.nan,float類型
任何數(shù)據(jù)與nan的運算結(jié)果都是nan
1、nan in Series
? Series.isnull()? --返回value為True或者False的Series
? Series.notnull()? --返回value為True或者False的Series
? Series.dropna()? --返回刪除nan值后的Series
? Series.fillna(method='ffill')? --前項插值，按照前面的值填充后面的空值
2、nan in DataFrame
? df.isnull()? --返回value為True或者False的DataFrame
? df.notnull()? --返回value為True或者False的DataFrame
? df.dropna(axis=0/1,how='any/all'，thresh=None)
? 說明：axis表示刪除行為nan或者列為nan；
? ? ? ? ? ? any表示只要有一個為空，all表示行中的每個元素或者列中的每個元素為空；
? ? ? ? ? ? thresh是閾值的意思，表示某行或者某列nan的個數(shù)達到閾值的個數(shù)時才刪除該行或該列。
? df.fillna(value=1)? ---所有的空值都填充為1
? df.fillna(value={0:0,1:1,2:2}) ---將0列的空值填為0,1列的空值填為1,2列的空值填為2，默認為填充列
? 注意：fillna和dropna的特點，生成新的DataFrame,原來的DataFrame不變。
1、多重索引介紹
Series = pd.Series(np.random.randn(6),index=[['1','1','1','2','2','2'],['a','b','c','a','b','c']])
'1','2'為一級索引，'a','b','c'為二級索引
df 可以看做是索引的'1','2'的Series
Series['1']? --Series
Series['1']['a']? --value
Series[:,'a'] --選擇'1'和'2'中的'a'對應(yīng)的值
2、多重索引格式轉(zhuǎn)為二維DataFrame
df = Series.unstack() --轉(zhuǎn)為二維DataFrame
3、多重索引在DataFrame中的操作
1、 map函數(shù)與apply函數(shù)、applymap函數(shù)的區(qū)別：
? 1）map函數(shù)對Series中的每個元素作用；
? 2）applymap函數(shù)對DataFrame中的每個元素作用；
? 3）apply函數(shù)對對DataFrame和Series的一列做整體運算。
2、Series.replace(to_replace=[2,3,4],values=[20,30,40])? 替換Series中多個值
Series.replace({1:10,2:20})? 將索引為1的值替換為10，將索引為2的值替換為20
df.sum()? --默認按照列進行求和,nan的值被忽略
df.min()? --默認按照列求最小值
df.max()? --默認按照列求最大值
df.mean()? --默認按照列求平均值
df.describe()? --默認按照列進行描述
df.sum(axis=1)? --按行求和，nan的值被忽略
#axis=0表示對橫軸進行操作，但是運算中表現(xiàn)為縱軸操作
#axis=1表示對縱軸進行操作，但是運算中表現(xiàn)為橫軸操作
bins = [0,59,70,80,100],bins是分割范圍
score_cat = pd.cut(Series,bins)? ---得到catgory類型的數(shù)據(jù)
DataFrame的分箱技術(shù)很棒?。?/p>
pd['catgory'] = pd.cut(df['a'],bins=[0,59,70,80,100],labels=['low','ok','good','great'])
--新增一列，將a列的值按照labels進行分類標記，good!!!
#生成長度為3的隨機字符串? pd.util.testing.rands(3)
1、按照一列分組
? g = df.groupby('city')
? g是分組類型數(shù)據(jù)，打印不出來，所以看不到，但是有屬性和方法可以間接的了解
1） g.groups? --得到分的幾個組，和每個組包含的索引
2）g.get_group('BJ')? --得到'BJ'所對應(yīng)的組
3）groupby = split +apply +combine
? ? ?? g.mean()? --求每組的平均值
? ? ?? g.max() ? --求每組的最大值
? ? ?? g.min() ? --求每組的最小值
? ? ?? g.count()
? ? ?? g.describe()
? 4）g是一個可迭代對象，可以用list函數(shù)將其轉(zhuǎn)化為list
? ? ? list(g) -- [('組名1',DataFrame1),('組名2',DataFrame2),(),()]
? ? ? dict(list(g))? --將其轉(zhuǎn)化為字典
? 同時可以通過for循環(huán)進行遍歷操作：for item,desc in g:print(item,desc)
? #怪不得分組后不是DataFrame，因為元組的第一個元素是'分組名'。
2、按照多列分組
? g_new = df.groupby(['city','wind'])
? 得到生成器((('分組1','分組2'),DataFrame),(),()...)
? g_new.get_group(('分組1','分組2'))
? for (name_1,name_2),group in g_new:
? ? ? ? ? print((name_1,name_2),group)
g.mean()? --求每組的平均值
與g.agg('mean')方法一樣
pd.pivot_table(df,index=['',''],aggfuc='sum',values=['',''])
index是分組的組名，values是透視表呈現(xiàn)結(jié)果的列，columns是values下的分解
#感覺透視表呈現(xiàn)的結(jié)果就是groupby+agg后的結(jié)果
#分析者需要對數(shù)據(jù)結(jié)構(gòu)有一定的了解
df.sort_values(by='',ascending=True/False)[:10]? df可以索引
df.value_counts()? --按值計數(shù)
df.['a'] = df['b'].apply(lambda x:x0)? --DataFrame中的True/False
通過g.size()可以看到被groupby之后的數(shù)據(jù)，得到的是一個Series
1、Series的排序：
1）對值進行排序
Series.sort_values()? ---直接對Series的值進行排序
2）通過索引進行排序
Series.sort_index()?
#默認都是升序排列
2、DataFrame的排序
df.sort_values(by='')? --按照某列的順序進行排序
df['a'].sort_values()? --返回對a列數(shù)據(jù)的排序結(jié)果，只返回a列
1、df.index = Series(['a','b','c'])? 直接對index賦予新值
2、df.index = df.index.map(str.upper)
map函數(shù)中只傳入新的函數(shù)名即可
3、df.rename(index=str.upper,columns=str.lower)
? 或者傳遞字典，進行一一轉(zhuǎn)換
pd.merge(df1,df2,on=None,how='left/right/inner/outer')
pd.merge(df1,df2)? --沒有on參數(shù)默認先找相同的columns,然后在columns下找相同的values
pd.merge(df1,df2,on='columns')? --on參數(shù)是指按照指定列進行merge
left:表示以左邊的數(shù)據(jù)表為基準，進行填充右面的數(shù)據(jù)
right:表示以右邊的數(shù)據(jù)表為基準，填充左邊的數(shù)據(jù)
outer:以on的指定列的所有值為基準，填充兩邊的數(shù)據(jù)
inner:默認inner,相同on指定的columns下的相同values對應(yīng)的左右兩邊的數(shù)據(jù)
1、concat拼接
pd.concat([Series1,Series2])
pd.concat([df1,df2])? -- 上下疊加，將沒有的列進行填充
2、combine組合
Series1.combine_first(Series2)? --用Series2的值去填充Series1中為空的值
df1.combine_first(df2)? ---用df2將df1中的空值填充
df['A'] = df['A'].apply(str.upper)? ---apply函數(shù)中也只輸入函數(shù)名
len(df)? --求df的長度
len(df['a'].unique())? --查看a列中不重復(fù)數(shù)據(jù)的多少
Series.duplicated()? --返回一列True/False的Series
Series.drop_duplicates()? --刪除重復(fù)值
df.drop_duplicates('a',keep='first/last')
df.drop_duplicates()? --刪除完全重復(fù)的行
參數(shù)：'a'表示以a列為基準，刪除重復(fù)值
? ? ? ? ? first表示保留第一個，last表示保留最后一個
data_list = pd.date_range(start,end,period='D',freq)
period='D',以天為單位
freq = 'W' 以周為單位
freq = 'W-Mon'以每周一位單位
freq = '5H'? 以5h為單位
以data_range作為索引提取數(shù)據(jù)比較簡單
df[datetime(2017,9,1)]
df['2017-09-01']
df['20170901']
df['201709']
對時間序列數(shù)據(jù)進行分組聚合操作：
s1.resample('M').mean()? --以月為單位進行采樣，然后求每組的平均值
s1.resample('H').ffill()? --前項填充
s1.resample('H').bfill()? --后項填充
補充：1）jupyter中可以執(zhí)行l(wèi)inux命令，太棒了！
? ? ? ? ? ? !ls
? ? ? ? ? ? !more xxx.csv
? ? ? ? ? ? !pwd? 等等
? ? ?? 2）jupyter 查看函數(shù)幫助的快捷鍵：摁住shift + tab? 棒！??！
abs() divmod() input() open() staticmethod()
all() enumerate() int() ord() str()
any() eval() isinstance() pow() sum()
basestring() execfile() issubclass() print() super()
bin() file() iter() property() tuple()
bool() filter() len() range() type()
bytearray() float() list() raw_input() unichr()
callable() format() locals() reduce() unicode()
chr() frozenset() long() reload() vars()
classmethod() getattr() map() repr() xrange()
cmp() globals() max() reverse() zip()
compile() hasattr() memoryview() round() __import__()
complex() hash() min() set()
delattr() help() next() setattr()
dict() hex() object() slice()
dir() id() oct() sorted()
1、torch.cat(inputs, dim=0) - Tensor?
參考鏈接：
[Pytorch] 詳解 torch.cat()
Pytorch學(xué)習(xí)筆記(一)：torch.cat()模塊的詳解
函數(shù)作用：cat 是 concatnate 的意思：拼接，聯(lián)系在一起。在給定維度上對輸入的 Tensor 序列進行拼接操作。torch.cat 可以看作是 torch.split 和 torch.chunk 的反操作
參數(shù)：
inputs(sequence of Tensors)：可以是任意相同類型的 Tensor 的 python 序列
dim(int, optional)：defaults=0
dim=0: 按列進行拼接?
dim=1: 按行進行拼接
dim=-1: 如果行和列數(shù)都相同則按行進行拼接，否則按照行數(shù)或列數(shù)相等的維度進行拼接
假設(shè) a 和 b 都是 Tensor，且 a 的維度為 [2, 3]，b 的維度為 [2, 4]，則
torch.cat((a, b), dim=1) 的維度為 [2, 7]
2、torch.nn.CrossEntropyLoss()
函數(shù)作用：CrossEntropy 是交叉熵的意思，故而 CrossEntropyLoss 的作用是計算交叉熵。CrossEntropyLoss 函數(shù)是將 torch.nn.Softmax 和 torch.nn.NLLLoss 兩個函數(shù)組合在一起使用，故而傳入的預(yù)測值不需要先進行 torch.nnSoftmax 操作。
參數(shù)：
input(N, C)：N 是 batch_size，C 則是類別數(shù)，即在定義模型輸出時，輸出節(jié)點個數(shù)要定義為 [N, C]。其中特別注意的是 target 的數(shù)據(jù)類型需要是浮點數(shù)，即 float32
target(N)：N 是 batch_size，故 target 需要是 1D 張量。其中特別注意的是 target 的數(shù)據(jù)類型需要是 long，即 int64
例子：
loss = nn.CrossEntropyLoss()
input = torch.randn(3, 5, requires_grad=True, dtype=torch.float32)
target = torch.empty(3, dtype=torch.long).random_(5)
output = loss(input, target)
output
輸出為：
tensor(1.6916, grad_fn=NllLossBackward)
這份資料非常純粹，只有Python的基礎(chǔ)語法，專門針對想要學(xué)習(xí)Python的小白。
Python中用#表示單行注釋，#之后的同行的內(nèi)容都會被注釋掉。
使用三個連續(xù)的雙引號表示多行注釋，兩個多行注釋標識之間內(nèi)容會被視作是注釋。
Python當中的數(shù)字定義和其他語言一樣：
我們分別使用+, -, *, /表示加減乘除四則運算符。
這里要注意的是，在Python2當中，10/3這個操作會得到3，而不是3.33333。因為除數(shù)和被除數(shù)都是整數(shù)，所以Python會自動執(zhí)行整數(shù)的計算，幫我們把得到的商取整。如果是10.0 / 3，就會得到3.33333。目前Python2已經(jīng)不再維護了，可以不用關(guān)心其中的細節(jié)。
但問題是Python是一個 弱類型 的語言，如果我們在一個函數(shù)當中得到兩個變量，是無法直接判斷它們的類型的。這就導(dǎo)致了同樣的計算符可能會得到不同的結(jié)果，這非常蛋疼。以至于程序員在運算除法的時候，往往都需要手工加上類型轉(zhuǎn)化符，將被除數(shù)轉(zhuǎn)成浮點數(shù)。
在Python3當中撥亂反正，修正了這個問題，即使是兩個整數(shù)相除，并且可以整除的情況下，得到的結(jié)果也一定是浮點數(shù)。
如果我們想要得到整數(shù)，我們可以這么操作：
兩個除號表示 取整除 ，Python會為我們保留去除余數(shù)的結(jié)果。
除了取整除操作之外還有取余數(shù)操作，數(shù)學(xué)上稱為取模，Python中用%表示。
Python中支持 乘方運算 ，我們可以不用調(diào)用額外的函數(shù)，而使用**符號來完成：
當運算比較復(fù)雜的時候，我們可以用括號來強制改變運算順序。
Python中用首字母大寫的True和False表示真和假。
用and表示與操作，or表示或操作，not表示非操作。而不是C++或者是Java當中的, || 和！。
在Python底層， True和False其實是1和0 ，所以如果我們執(zhí)行以下操作，是不會報錯的，但是在邏輯上毫無意義。
我們用==判斷相等的操作，可以看出來True==1， False == 0.
我們要小心Python當中的bool()這個函數(shù)，它并不是轉(zhuǎn)成bool類型的意思。如果我們執(zhí)行這個函數(shù)，那么 只有0會被視作是False，其他所有數(shù)值都是True ：
Python中用==判斷相等，表示大于，=表示大于等于， 表示小于，=表示小于等于，!=表示不等。
我們可以用and和or拼裝各個邏輯運算：
注意not，and，or之間的優(yōu)先級，其中not and or。如果分不清楚的話，可以用括號強行改變運行順序。
關(guān)于list的判斷，我們常用的判斷有兩種，一種是剛才介紹的==，還有一種是is。我們有時候也會簡單實用is來判斷，那么這兩者有什么區(qū)別呢？我們來看下面的例子：
Python是全引用的語言，其中的對象都使用引用來表示。is判斷的就是 兩個引用是否指向同一個對象 ，而==則是判斷兩個引用指向的具體內(nèi)容是否相等。舉個例子，如果我們把引用比喻成地址的話，is就是判斷兩個變量的是否指向同一個地址，比如說都是沿河?xùn)|路XX號。而==則是判斷這兩個地址的收件人是否都叫張三。
顯然，住在同一個地址的人一定都叫張三，但是住在不同地址的兩個人也可以都叫張三，也可以叫不同的名字。所以如果a is b，那么a == b一定成立，反之則不然。
Python當中對字符串的限制比較松， 雙引號和單引號都可以表示字符串 ，看個人喜好使用單引號或者是雙引號。我個人比較喜歡單引號，因為寫起來方便。
字符串也支持+操作，表示兩個字符串相連。除此之外，我們把兩個字符串寫在一起，即使沒有+，Python也會為我們拼接：
我們可以使用[]來查找字符串當中某個位置的字符，用 len 來計算字符串的長度。
我們可以在字符串前面 加上f表示格式操作 ，并且在格式操作當中也支持運算，比如可以嵌套上len函數(shù)等。不過要注意，只有Python3.6以上的版本支持f操作。
最后是None的判斷，在Python當中None也是一個對象， 所有為None的變量都會指向這個對象 。根據(jù)我們前面所說的，既然所有的None都指向同一個地址，我們需要判斷一個變量是否是None的時候，可以使用is來進行判斷，當然用==也是可以的，不過我們通常使用is。
理解了None之后，我們再回到之前介紹過的bool()函數(shù)，它的用途其實就是判斷值是否是空。所有類型的 默認空值會被返回False ，否則都是True。比如0，""，[], {}, ()等。
除了上面這些值以外的所有值傳入都會得到True。
Python當中的標準輸入輸出是 input和print 。
print會輸出一個字符串，如果傳入的不是字符串會自動調(diào)用__str__方法轉(zhuǎn)成字符串進行輸出。 默認輸出會自動換行 ，如果想要以不同的字符結(jié)尾代替換行，可以傳入end參數(shù)：
使用input時，Python會在命令行接收一行字符串作為輸入?？梢栽趇nput當中傳入字符串，會被當成提示輸出：
Python支持 三元表達式 ，但是語法和C++不同，使用if else結(jié)構(gòu)，寫成：
上段代碼等價于：
Python中用[]表示空的list，我們也可以直接在其中填充元素進行初始化：
使用append和pop可以在list的末尾插入或者刪除元素：
list可以通過[]加上下標訪問指定位置的元素，如果是負數(shù)，則表示 倒序訪問 。-1表示最后一個元素，-2表示倒數(shù)第二個，以此類推。如果訪問的元素超過數(shù)組長度，則會出發(fā) IndexError 的錯誤。
list支持切片操作，所謂的切片則是從原list當中 拷貝 出指定的一段。我們用start: end的格式來獲取切片，注意，這是一個 左閉右開區(qū)間 。如果留空表示全部獲取，我們也可以額外再加入一個參數(shù)表示步長，比如[1:5:2]表示從1號位置開始，步長為2獲取元素。得到的結(jié)果為[1, 3]。如果步長設(shè)置成-1則代表反向遍歷。
如果我們要指定一段區(qū)間倒序，則前面的start和end也需要反過來，例如我想要獲取[3: 6]區(qū)間的倒序，應(yīng)該寫成[6:3:-1]。
只寫一個:，表示全部拷貝，如果用is判斷拷貝前后的list會得到False?？梢允褂胐el刪除指定位置的元素，或者可以使用remove方法。
insert方法可以 指定位置插入元素 ，index方法可以查詢某個元素第一次出現(xiàn)的下標。
list可以進行加法運算，兩個list相加表示list當中的元素合并。 等價于使用extend 方法：
我們想要判斷元素是否在list中出現(xiàn)，可以使用 in關(guān)鍵字 ，通過使用len計算list的長度：
tuple和list非常接近，tuple通過()初始化。和list不同， tuple是不可變對象 。也就是說tuple一旦生成不可以改變。如果我們修改tuple，會引發(fā)TypeError異常。
由于小括號是有改變優(yōu)先級的含義，所以我們定義單個元素的tuple， 末尾必須加上逗號 ，否則會被當成是單個元素：
tuple支持list當中絕大部分操作：
我們可以用多個變量來解壓一個tuple：
解釋一下這行代碼：
我們在b的前面加上了星號， 表示這是一個list 。所以Python會在將其他變量對應(yīng)上值的情況下，將剩下的元素都賦值給b。
補充一點，tuple本身雖然是不可變的，但是 tuple當中的可變元素是可以改變的 。比如我們有這樣一個tuple：
我們雖然不能往a當中添加或者刪除元素，但是a當中含有一個list，我們可以改變這個list類型的元素，這并不會觸發(fā)tuple的異常：
dict也是Python當中經(jīng)常使用的容器，它等價于C++當中的map，即 存儲key和value的鍵值對 。我們用{}表示一個dict，用:分隔key和value。
對 。我們用{}表示一個dict，用:分隔key和value。
dict的key必須為不可變對象，所以 list、set和dict不可以作為另一個dict的key ，否則會拋出異常：
我們同樣用[]查找dict當中的元素，我們傳入key，獲得value，等價于get方法。
我們可以call dict當中的keys和values方法，獲取dict當中的所有key和value的集合，會得到一個list。在Python3.7以下版本當中，返回的結(jié)果的順序可能和插入順序不同，在Python3.7及以上版本中，Python會保證返回的順序和插入順序一致：
我們也可以用in判斷一個key是否在dict當中，注意只能判斷key。
如果使用[]查找不存在的key，會引發(fā)KeyError的異常。如果使用 get方法則不會引起異常，只會得到一個None ：
setdefault方法可以 為不存在的key 插入一個value，如果key已經(jīng)存在，則不會覆蓋它：
我們可以使用update方法用另外一個dict來更新當前dict，比如a.update(b)。對于a和b交集的key會被b覆蓋，a當中不存在的key會被插入進來：
我們一樣可以使用del刪除dict當中的元素，同樣只能傳入key。
Python3.5以上的版本支持使用**來解壓一個dict：
set是用來存儲 不重復(fù)元素 的容器，當中的元素都是不同的，相同的元素會被刪除。我們可以通過set()，或者通過{}來進行初始化。注意當我們使用{}的時候，必須要傳入數(shù)據(jù)，否則Python會將它和dict弄混。
set當中的元素也必須是不可變對象，因此list不能傳入set。
可以調(diào)用add方法為set插入元素：
set還可以被認為是集合，所以它還支持一些集合交叉并補的操作。
set還支持 超集和子集的判斷 ，我們可以用大于等于和小于等于號判斷一個set是不是另一個的超集或子集：
和dict一樣，我們可以使用in判斷元素在不在set當中。用copy可以拷貝一個set。
Python當中的判斷語句非常簡單，并且Python不支持switch，所以即使是多個條件，我們也只能 羅列if-else 。
我們可以用in來循環(huán)迭代一個list當中的內(nèi)容，這也是Python當中基本的循環(huán)方式。
如果我們要循環(huán)一個范圍，可以使用range。range加上一個參數(shù)表示從0開始的序列，比如range(10)，表示[0, 10)區(qū)間內(nèi)的所有整數(shù)：
如果我們傳入兩個參數(shù)，則 代表迭代區(qū)間的首尾 。
如果我們傳入第三個元素，表示每次 循環(huán)變量自增的步長 。
如果使用enumerate函數(shù)，可以 同時迭代一個list的下標和元素 ：
while循環(huán)和C++類似，當條件為True時執(zhí)行，為false時退出。并且判斷條件不需要加上括號：
Python當中使用 try和except捕獲異常 ，我們可以在except后面限制異常的類型。如果有多個類型可以寫多個except，還可以使用else語句表示其他所有的類型。finally語句內(nèi)的語法 無論是否會觸發(fā)異常都必定執(zhí)行 ：
在Python當中我們經(jīng)常會使用資源，最常見的就是open打開一個文件。我們 打開了文件句柄就一定要關(guān)閉 ，但是如果我們手動來編碼，經(jīng)常會忘記執(zhí)行close操作。并且如果文件異常，還會觸發(fā)異常。這個時候我們可以使用with語句來代替這部分處理，使用with會 自動在with塊執(zhí)行結(jié)束或者是觸發(fā)異常時關(guān)閉打開的資源 。
以下是with的幾種用法和功能：
凡是可以使用in語句來迭代的對象都叫做 可迭代對象 ，它和迭代器不是一個含義。這里只有可迭代對象的介紹，想要了解迭代器的具體內(nèi)容，請移步傳送門：
Python——五分鐘帶你弄懂迭代器與生成器，夯實代碼能力
當我們調(diào)用dict當中的keys方法的時候，返回的結(jié)果就是一個可迭代對象。
我們 不能使用下標來訪問 可迭代對象，但我們可以用iter將它轉(zhuǎn)化成迭代器，使用next關(guān)鍵字來獲取下一個元素。也可以將它轉(zhuǎn)化成list類型，變成一個list。
使用def關(guān)鍵字來定義函數(shù)，我們在傳參的時候如果指定函數(shù)內(nèi)的參數(shù)名， 可以不按照函數(shù)定義的順序 傳參：
可以在參數(shù)名之前加上*表示任意長度的參數(shù)，參數(shù)會被轉(zhuǎn)化成list：
也可以指定任意長度的關(guān)鍵字參數(shù)，在參數(shù)前加上**表示接受一個dict：
當然我們也可以兩個都用上，這樣可以接受任何參數(shù)：
傳入?yún)?shù)的時候我們也可以使用*和**來解壓list或者是dict：
Python中的參數(shù) 可以返回多個值 ：
函數(shù)內(nèi)部定義的變量即使和全局變量重名，也 不會覆蓋全局變量的值 。想要在函數(shù)內(nèi)部使用全局變量，需要加上 global 關(guān)鍵字，表示這是一個全局變量：
Python支持 函數(shù)式編程 ，我們可以在一個函數(shù)內(nèi)部返回一個函數(shù)：
Python中可以使用lambda表示 匿名函數(shù) ，使用:作為分隔，:前面表示匿名函數(shù)的參數(shù)，:后面的是函數(shù)的返回值：
我們還可以將函數(shù)作為參數(shù)使用map和filter，實現(xiàn)元素的批量處理和過濾。關(guān)于Python中map、reduce和filter的使用，具體可以查看之前的文章：
五分鐘帶你了解map、reduce和filter
我們還可以結(jié)合循環(huán)和判斷語來給list或者是dict進行初始化：
使用 import語句引入一個Python模塊 ，我們可以用.來訪問模塊中的函數(shù)或者是類。
我們也可以使用from import的語句，單獨引入模塊內(nèi)的函數(shù)或者是類，而不再需要寫出完整路徑。使用from import *可以引入模塊內(nèi)所有內(nèi)容（不推薦這么干）
可以使用as給模塊內(nèi)的方法或者類起別名：
我們可以使用dir查看我們用的模塊的路徑：
這么做的原因是如果我們當前的路徑下也有一個叫做math的Python文件，那么 會覆蓋系統(tǒng)自帶的math的模塊 。這是尤其需要注意的，不小心會導(dǎo)致很多奇怪的bug。
我們來看一個完整的類，相關(guān)的介紹都在注釋當中
以上內(nèi)容的詳細介紹之前也有過相關(guān)文章，可以查看：
Python—— slots ，property和對象命名規(guī)范
下面我們來看看Python當中類的使用：
這里解釋一下，實例和對象可以理解成一個概念，實例的英文是instance，對象的英文是object。都是指類經(jīng)過實例化之后得到的對象。
繼承可以讓子類 繼承父類的變量以及方法 ，并且我們還可以在子類當中指定一些屬于自己的特性，并且還可以重寫父類的一些方法。一般我們會將不同的類放在不同的文件當中，使用import引入，一樣可以實現(xiàn)繼承。
我們創(chuàng)建一個蝙蝠類：
我們再創(chuàng)建一個蝙蝠俠的類，同時繼承Superhero和Bat：
執(zhí)行這個類：
我們可以通過yield關(guān)鍵字創(chuàng)建一個生成器，每次我們調(diào)用的時候執(zhí)行到y(tǒng)ield關(guān)鍵字處則停止。下次再次調(diào)用則還是從yield處開始往下執(zhí)行：
除了yield之外，我們還可以使用()小括號來生成一個生成器：
關(guān)于生成器和迭代器更多的內(nèi)容，可以查看下面這篇文章：
五分鐘帶你弄懂迭代器與生成器，夯實代碼能力
我們引入functools當中的wraps之后，可以創(chuàng)建一個裝飾器。裝飾器可以在不修改函數(shù)內(nèi)部代碼的前提下，在外面包裝一層其他的邏輯:
裝飾器之前也有專門的文章詳細介紹，可以移步下面的傳送門：
一文搞定Python裝飾器，看完面試不再慌
不知道有多少小伙伴可以看到結(jié)束，原作者的確非常厲害，把Python的基本操作基本上都囊括在里面了。如果都能讀懂并且理解的話，那么Python這門語言就算是入門了。
如果你之前就有其他語言的語言基礎(chǔ)，我想本文讀完應(yīng)該不用30分鐘。當然在30分鐘內(nèi)學(xué)會一門語言是不可能的，也不是我所提倡的。但至少通過本文我們可以做到熟悉Python的語法，知道大概有哪些操作，剩下的就要我們親自去寫代碼的時候去體會和運用了。
根據(jù)我的經(jīng)驗，在學(xué)習(xí)一門新語言的前期，不停地查閱資料是免不了的。希望本文可以作為你在使用Python時候的查閱文檔。
最后，我這里有各種免費的編程類資料，有需要的及時私聊我，回復(fù)"學(xué)習(xí)"，分享給大家，正在發(fā)放中............
首先，Python已經(jīng)內(nèi)置確定序列的長度以及確定最大和最小的元素的方法。列表是最常用的Python數(shù)據(jù)類型，它可以作為一個方括號內(nèi)的逗號分隔值出現(xiàn)。列表的數(shù)據(jù)項不需要具有相同的類型。創(chuàng)建一個列表，只要把逗號分隔的不同的數(shù)據(jù)項使用方括號括起來即可。
以下是列表最常用的方法：
1.append() -------- 向列表的尾部添加元素
2.insert(index，object) -------- 向指定的下標處添加元素
3.sort（）-------- 進行排序（從下到大 int類型）可以對字母進行排序（ASCII值）類型不能混
4.index（）-------- 返回的是元素在列表中的第一個位置
5.reverse（）------------ 將列表進行翻轉(zhuǎn)
6.remove（）---------- 刪除某個元素，如果有重復(fù)，刪除的是第一次出現(xiàn)的元素，如果元素不存在會 報錯
7.count（）-------- 返回的是某個元素在列表里面的個數(shù)
8.clear（）--------- 清除元素
9.copy（）-------- 淺拷貝對象 不等價與 =
10.extend（）-------- 合并列表
11.pop（）-------刪除列表尾部的元素（與append相反）,返回刪除的元素，pop(i) i指的是下標
重慶分公司
重慶分公司
