下標是該對象保存數據的順序；python的下標從0開始，-1是最后一個元素
讓客戶滿意是我們工作的目標，不斷超越客戶的期望值來自于我們對這個行業(yè)的熱愛。我們立志把好的技術通過有效、簡單的方式提供給客戶，將通過不懈努力成為客戶在信息化領域值得信任、有價值的長期合作伙伴，公司提供的服務項目有：國際域名空間、網站空間、營銷軟件、網站建設、包頭網站維護、網站推廣。
def?fun(lst):
a?=?lst[1]?+?lst[-1]
return?a
lst?=?range(10)??#?range(n)?returns?a?list?[0,?1,?...,?n-1]
print?fun(lst)
就像上面的，直接寫就好，在定義函數的時候，并不需要指定參數類型，你傳進來是什么就是什么，你只需要保證傳進來的是list就好了，不然在使用下標的時候，就會報錯。
當然，為了保證程序的健壯性，你可以加一個判斷，如下：
def?fun(lst):
if?type(lst)?==?type([]):
a?=?lst[1]?+?lst[-1]
return?a
else:
print?'The?arg?is?not?a?list'
lst?=?range(10)
print?fun(lst)
使用python編輯器。
首先打開python編輯器，新建一個python項目，在python項目中定義一個字符串，再使用for循環(huán)和print函數輸出字符串的文本以及下標即可。
在進行python數據分析的時候，首先要進行數據預處理。有時候不得不處理一些非數值類別的數據，通過mapping方式，將類別映射為數值。不過這種方法適用范圍有限。
這幾個函數在 Python 里面被稱為高階函數，本文主要學習它們的用法。
filter 函數原型如下：
第一個參數是判斷函數（返回結果需要是 True 或者 False），第二個為序列，該函數將對 iterable 序列依次執(zhí)行 function(item) 操作，返回結果是過濾之后結果組成的序列。
簡單記憶：對序列中的元素進行篩選，獲取符合條件的序列。
返回結果為： ，使用 list 函數可以輸入序列內容。
map 函數原型如下：
該函數運行之后生成一個 list，第一個參數是函數、第二個參數是一個或多個序列；
下述代碼是一個簡單的測試案例：
上述代碼運行完畢，得到的結果是： 。使用 print(list(my_new_list)) 可以得到結果。
map 函數的第一個參數，可以有多個參數，當這種情況出現(xiàn)后，后面的第二個參數需要是多個序列。
map 函數解決的問題：
reduce 函數原型如下：
第一個參數是函數，第二個參數是序列，返回計算結果之后的值。該函數價值在于滾動計算應用于列表中的連續(xù)值。
測試代碼如下：
最終的結果是 6，如果設置第三個參數為 4，可以運行代碼查看結果，最后得到的結論是，第三個參數表示初始值，即累加操作初始的數值。
簡單記憶：對序列內所有元素進行累計操作。
zip 函數原型如下：
zip 函數將可迭代的對象作為參數，將對象中對應的元素打包成一個個元組，然后返回由這些元組組成的列表。
如果各個迭代器的元素個數不一樣，則返回列表長度與最短的對象相同，利用星號（ * ）操作符，可以將元組解壓為列表。
測試代碼如下：
展示如何利用 * 操作符：
輸出結果如下：
簡單記憶：zip 的功能是映射多個容器的相似索引，可以方便用于來構造字典。
enumerate 函數原型如下：
參數說明：
該函數用于將一個可遍歷的數據對象組合為一個索引序列，同時列出數據和數據下標，一般用在 for 循環(huán)當中。
測試代碼如下：
返回結果為： 。
本文涉及的函數可以與 lambda 表達式進行結合，能大幅度提高編碼效率。最好的學習資料永遠是官方手冊
使用python版本3.7
首先先了解下python3.7中的下標，python下標有兩套，一套是正的，一套是負的
引入負坐標的意義應該是方便將數組中的數據從右往左訪問。
a='python'中的python 的下標描述如下
組 p y t h o n
正下標 0 1 2 3 4 5
負下標 -6 -5 -4 -3 -2 -1
對應位置的正下標減去負下標等于len(a) ：正下標-負下標=len(a)
使用正下標時，下標i取值范圍為0 = i len(a) 超出范圍為越界，i大于len(a)表示越（數軸）右界
使用負下標時，下標i取值范圍為-len(a)-1 i =-1 超出范圍為越界，i小于len(a)表示越（數軸）左界
數組操作中一般通過 “:” 和數字或變量的組合來靈活使用里面的元素
第一個“:” 表示循環(huán)，第二個“:” 表示設定后面數字為步長。比如i:j:k，表示從i到j步長為k，逐個順次獲取。i到j滿足左閉右開原則 。
沒有冒號表示正常的數組單個元素訪問；沒有第二個冒號就表示默認的步長為1，從i到j左開右閉步長為1逐個訪問。
1、k缺?。ê雎晕磳懗龅哪J值）為1；當k0時，i缺省為0，j缺省為len(a) ; 當k0時，i缺省為-1，j缺省為-len(a)-1。
2、當k0時，可以將i，j全轉換成正下標去理解。
當i或j為正且越正數下標右界時，越界的數全部取正下標右界len(a)。
當i或j為負且越負數下標的左界時，越界的數全部取左界前的有效值-len(a)，然后再轉換成正下標，轉換規(guī)則為：正下標=len(a)+負下標。
3、當k0是，可以將i，j全部轉換成負下標去理解。
當i或j為負且越負數下標左界時，越界的數全部取負下標左界-len(a)-1。
當i或j為正且越正數下標右界時，越界的數全部取右界前的有效值len(a)-1，然后再轉換為負下標，轉換規(guī)則為：負下標=正下標-len(a)。
4、k不能等于0。
對于循環(huán)操作中下標的操作應該先處理越界，然后再根據的正負轉換成對應的正負坐標。
a='python' #len(a)=6
i=1
j=4
k=1
b=a[i:j:k] #結果為yth 。意思為從下標i個開始到下標j-1結束，步長為k，(k為整數且不能等于0,缺省為1)，第一個冒號滿足左閉右開原則 。
b=a[i] #結果為y ,無冒號，表示普通的數組單個元素訪問，根據下標獲取值。
b=a[-1] #結果為n。
b=a[-6] #結果為p。
b=a[i:j] #結果為yth，從i到j，步長為缺省（默認）1
b=a[0:6:1] #結果為python,第一個冒號滿足左閉右開原則，等價于a[::]
b=a[0:6:2] #結果為pto，步長為2，等價于a[::2]
b=a[1:6:3] #結果為yo，步長為3，等價于a[::3]
b=a[0:3:1] #結果為pyt,第一個冒號滿足左閉右開原則,下標為3的值是取不到的
b=a[0:5:1] #結果為pytho,第一個冒號滿足左閉右開原則
b=a[0:7:1] #結果為python，等價于a[0:6:1]，當第一個冒號右邊的值大于len(a)時，
b=a[0:100:1]#結果為python，此處正下標越界，等價于a[0:6:1]，注意第一個冒號右邊的100已經超越了正下標的右限。
b=a[6:100:1]#結果為空，等價于a[6:6:1]，注意第一個冒號左右邊都已經超越了正下標的右限
b=a[7:100:1]#結果為空，等價于a[6:6:1]，注意第一個冒號左右邊都已經超越了正下標的右限
b=a[-6:6:1] #結果為python，等價于a[0:6:1]
b=a[-7:6:1] #結果為python，左閉右開，此處負下標越界，等價于a[-6:6:1]=a[0:6:1]
b=a[-100:6:1]#結果為python，注意-100已經超過了負下標的左限，等價于a[-6:6:1]=a[0:6:1]
b=a[-100:100:1]#結果為python，注意-100已經超過了負下標的左限,等價于a[-6:6:1]=a[0:6:1]
b=a[-6:-1:1]#結果為pytho，等價于a[0:5:1]，注意，-6轉換成正坐標為0，-1轉換為正坐標為5.
b=a[-100:-1:1]#結果為pytho，注意-100已經超過了負下標的左限,等價于a[-6:-1:1]=a[0:5:1]
b=a[0:-1:1]#結果為pytho,等價于a[0:5:1]
b=a[0:-100:1]#結果為空，注意-100已經超過了負下標的左限,等價于a[0:-6:1]=a[0:0:1]
b=a[0:-6:1] #結果為空，等價于a[0:0:1]
b=a[0:-7:1] #結果為空，等價于a[0:0:1]
b=a[:j] #結果為pyth。k缺?。J）為1，k大于0時，i缺?。J）為0，j缺?。J）為len(a)
b=a[i:] #結果為ython，表示從下標i開始到最后一個（下標為len(a)-1）
b=a[:] #結果為python，等價于a[0:6:1],表示從下標0開始到最后一個結束,步長為1。
b=a[::] #結果為python。等價于a[0:6:1]。a[i:j:k]中，k缺省為1，當k大于0時，i缺省為0，j缺省為len(a)。
b=a[::10] #結果為p。等價于a[0:6:10]。a[i:j:k]中，當k大于0時，i缺省為0，j缺省為len(a)
k為負，表示從右往左順次獲取數組中的值，轉換成負下標后，-len(a)-1=ji=-1才能獲取到值。
b=a[i:j:-1] #結果為空，等價于a[1:4:-1]=a[-5:-2:-1]
b=a[-1:-7:-1]#結果為nohtyp，第一個冒號滿足左閉右開原則。
b=a[-1:-100:-1]#結果為nohtyp，負下標越界，等價于a[-1:-7:-1]
b=a[4:0:-1] #結果為ohty，k為負數，將i，l轉換成負下標理解，等價于a[-2:-6:-1]，注意4轉換成負下標為-2，0轉換成負下標為-6
b=a[4:-1:-1]#結果為空，可以理解為a[-2:-1:-1]
b=a[4:-100:-1]#結果為ohtyp，k為負，將i轉成負下標理解，同時j越界，等價于a[-2:-100:-1]=a[-2:-7:-1]
b=a[-1:0:-1]#結果為nohty，可以理解為a[-1:-6:-1]
b=a[0:-1:-1]#結果為空，可以理解為a[-6:-1:-1]
b=a[0:-2:-1]#結果為空 ，可以理解為a[-6:-2:-1]
b=a[-2:0:-1]#結果為ohty，可以理解為a[-2:-6:-1]
b=a[-1:6:-1]#結果為空，可以理解為a[-1:5:-1]=a[-1:-1:-1]
b=a[-1:100:-1]#結果為空，可以理解為a[-1:5:-1]=a[-1:-1:-1]
b=a[6:100:-1]#結果為空，可以理解為a[5:5:-1]=a[-1:-1:-1]
b=a[4:100:-1]#結果為空，可以理解為a[4:5:-1]=a[-1:-1:-1]
b=a[100:100:-1]#結果為空，可以理解為a[5:5:-1]=a[-1:-1:-1]
b=a[100:4:-1]#結果為n,可以理解為a[5:4:-1]=a[-1:-2:-1]
b=a[100:-100:-1]#結果為nohtyp，可以理解為a[5:-7:-1]=a[-1:-7:-1]
b=a[100:0:-1]#結果為nohty，可以理解為a[5:0:-1]=a[-1:-6:-1]
b=a[-100:100:-1]#結果為空，可以理解為a[-7:6:-1]=a[-7:-1:-1]
b=a[:-1] #結果為pytho ，等價于a[0:5：1]
b=a[::-1] #結果為nohtyp，等價于a[-1:-len(a)-1:-1] = a[-1:-7:-1]
插入
python中的list，tuple，dictionary 與numpy中的array mat是有區(qū)別的。
String（字符串）
t = string
string可以用‘’或“”圈起來
t='Hello World!'
t=”Hello World!”
t[0]
'H'
t
'Hello World!'
List（鏈表）
t = [value,value...]
value類型可以各異
t={'abac', ”ggg”, 2,[1,2,3],(1,22,3)}
t[0]
'abac'
Tuple（元組）
t = (value,value...)
value類型可以各異,但是Tuple元素數量不能減少，且不能直接給元素賦值，具體看連接
t=('abac', ”ggg”, 2,[1,2,3],(1,22,3))
t[0]
'abac'
Dictionary（字典）
t = {key1 : value1, key2 : value2}
t = {'a': 1, 'b': 2, 'b': '3'}
t['b']
'3'
t
{'a': 1, 'b': '3'}
Set（集合）
t={value1,value2}或者
t=set(value)
basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}
print(basket) # 這里演示的是去重功能
{'orange', 'banana', 'pear', 'apple'}
'orange' in basket # 快速判斷元素是否在集合內
True
'crabgrass' in basket
False
Numpy.array（數組）
t = [value,value...]
value類型必須一致，要么都是數字，要么都是鏈表，要么都是字符串
初始化連接1
連接2
t = np.random.rand(3,4)
t
array([[0.17359552, 0.61668592, 0.97915523, 0.99638115],
[0.98119493, 0.36911137, 0.45306895, 0.09396056],
[0.11345902, 0.17136475, 0.85474534, 0.56421904]])
Numpy.mat（矩陣）
t = [value,value...]
value類型必須一致，要么都是數字，要么都是鏈表，要么都是字符串。與array的區(qū)別在初始化與操作上的區(qū)別，需要可以去做相關搜索 或看
鏈接
t = np.random.rand(3,4)
t=np.(t)
t
array([[0.17359552, 0.61668592, 0.97915523, 0.99638115],
[0.98119493, 0.36911137, 0.45306895, 0.09396056],
[0.11345902, 0.17136475, 0.85474534, 0.56421904]])
上面的各種類型中Dictionary 與Set 是不能通過數字下標訪問的，Dictionary需要通過key來訪問。
python3.7中只有numpy的array與numpy的mat才可以有多維數據的訪問。
numpy中為方便矩陣操作更進一步使用了 “,” 符號（數組操作中 逗號 在原生的python中沒有定義）
在numpy 中上面操作的只是一個維度的操作描述，通過逗號來間隔不同維度的操作，如下
import numpy as np
a=[['1','2','3','4','5','6'],['a','b','c','d','e','f']]
print(a)
print(type(a))
#print(a[:,:3]) #TypeError: list indices must be integers or slices, not tuple #對python的list,tuple,array 操作時逗號被單純的當做一個tuple，操作中沒有意義
a = np.mat(a) #對python中的numpy中的mat或者array操作時，逗號用于作為不同維度的操作描述的間隔符。
print(a)
print(type(a))
print(a[:,:3]) #獲取所有行的前3列
a=[['1','2','3','4','5','6'],['a','b','c','d','e','f']] #定義二維數組，第一維就是兩個子數組，也就是內部兩個“[.....]”整體作為一個維度。第二維為子數組中具體的內容，比如第一個數組中的：'1','2','3','4','5','6'，或第二個數組中的'a','b','c','d','e','f'。
a=np.array(a) #只有numpy中的array或者mat才對操作中的 “,” 起效用！?。。。。。。。?！
b=a[:,0] #結果為['1' 'a']。操作中的 “,” 前面的 “:” ，表示對第一維數據進行遍歷，“,” 后面的表示對第二維數據取第一個。
b=a[::-1,:3] #結果為 下面的矩陣。對第一維倒序，對第二位取前三個。
b=a[::-1,::-1] #對兩維的數據都取倒序。結果如下
文章知識點與官方知識檔案匹配
Python入門技能樹科學計算基礎軟件包NumPy操作數組
194350 人正在系統(tǒng)學習中
Python內置函數有很多，為大家推薦5個神仙級的內置函數：
(1)Lambda函數
用于創(chuàng)建匿名函數，即沒有名稱的函數。它只是一個表達式，函數體比def簡單很多。當我們需要創(chuàng)建一個函數來執(zhí)行單個操作并且可以在一行中編寫時，就可以用到匿名函數了。
Lamdba的主體是一個表達式，而不是一個代碼塊。僅僅能在lambda表達式中封裝有限的邏輯進去。
利用Lamdba函數，往往可以將代碼簡化許多。
(2)Map函數
會將一個函數映射到一個輸入列表的所有元素上，比如我們先創(chuàng)建了一個函數來返回一個大寫的輸入單詞，然后將此函數應有到列表colors中的所有元素。
我們還可以使用匿名函數lamdba來配合map函數，這樣可以更加精簡。
(3)Reduce函數
當需要對一個列表進行一些計算并返回結果時，reduce()是個非常有用的函數。舉個例子，當需要計算一個整數列表所有元素的乘積時，即可使用reduce函數實現(xiàn)。
它與函數的最大的區(qū)別就是，reduce()里的映射函數(function)接收兩個參數，而map接收一個參數。
(4)enumerate函數
用于將一個可遍歷的數據對象(如列表、元組或字符串)組合為一個索引序列，同時列出數據和數據下標，一般用在for循環(huán)當中。
它的兩個參數，一個是序列、迭代器或其他支持迭代對象;另一個是下標起始位置，默認情況從0開始，也可以自定義計數器的起始編號。
(5)Zip函數
用于將可迭代的對象作為參數，將對象中對應的元素打包成一個個元組，然后返回由這些元組組成的列表
當我們使用zip()函數時，如果各個迭代器的元素個數不一致，則返回列表長度與最短的對象相同。
重慶分公司
重慶分公司
