python索引

① python怎麼把某行設為索引

主鍵是表中的一個或多個欄位，它的值用於惟一地標識表中的某一條記錄.且不能為空；
索引是對資料庫表中一列或多列的值進行排序的一種結構，只有當經常查詢索引列中的數據時，才需要在表上創建索引，使用索引可快速訪問資料庫表中的特定信息。
索引佔用磁碟空間，並且降低添加、刪除和更新行的速度。當然索引也有好處就是查詢速度快，它利還是大於弊的所以請慎重使用索引。

② python索引

非常簡單的問題，()括弧本身是運算符，('a')在這里只能括弧的左右產生了歧義，不能分辨出究竟是'a'還是一個tuple，因此在僅有一個元素的tuple後加一個,逗號來消除歧義，而多於一個元素的就沒有歧義了，當然如果你要寫成('a','b',)也是沒有問題的。

③ python如何將列表作為列表的索引

1.
a=['a','b','c','d','e','f','g','h','i','j','k','l','m','n']
b=[1,4,3,6,10]
c=type(a)(map(lambdai:a[i],b))#這里沒有判斷b的元素作為a的索引的時候值太大溢出的異常
printc
>>>
['b','e','d','g','k']
>>>

------------------------------

2.
>>>importnumpyasnp
>>>b=np.array([2,3,4,5,6])
>>>a=np.array([0,2,4])
>>>b[a]
array([2,4,6])

④ python數組索引的問題

這是切片
new = A[:-5:-1]

-5表示截取到倒數到第五個元素
-1表示從右往左取

⑤ python索引問題

你好，你是想改變列表a的索引值嗎？我沒懂你的意思。改變列表a的索引可以通過pandas更改。

⑥ 如何在python列表中查找某個元素的索引

1、方法一： 利用數組自身的特性 a.index(target), 其中a是目標list，target是需要的下標對應的值。代碼如下：

2、分片：

分片用於截取某個范圍內的元素，通過:來指定起始區間（左閉右開區間，包含左側索引值對應的元素，但不包含右測索引值對應的元素）。

分片包括起始索引對應的元素，但不包括終止索引對應的元素，索引為正值時可以發生越界但只會取到最後一個元素。如果索引值為負值，則表示從最右邊元素開始，此時需避免索引越界。

⑦ python 列表索引問題

數據結構是通過某種方式組織在一起的數據元素的集合。在python中，最基本的數據結構就是序列。序列中的每個元素被分配一個序號，即元素的位置，也被稱為索引。注意：第一個索引是0。
1.序列概覽
python有6種內建的序列：列表，元組，字元串，Unicode字元串，buffer對象和xrange對象。
這里重點介紹列表和元組。列表和元組主要區別在於，列表可以修改，元組不可修改。一般來說，在幾乎所有情況下列表都可以代替元組。
在需要操作一組數值的時候，序列很好用：
復制代碼 代碼如下:
Edward = ["Gumby",42]
同時，序列可以包含其他的序列。如：
復制代碼 代碼如下:
Edward = ["Gumby",42]
John = ["Smith",50]
database = [Edward,John]
2. 通用序列操作
所有序列類型都可以進行某些特點的操作，包括：索引，分片，加，乘以及檢查某個元素是否屬於序列的成員（成員資格）。除此之外，python還有計算序列長度，找出最大元素和最小元素的內建函數。
2.1 索引
序列中的所有元素都是有編號的--從0開始遞增。這些元素可以通過編號分別訪問：
復制代碼 代碼如下:
>>>greeting = "hello"
>>>greeting[0]
'H'
使用負數索引的話，python會從右邊，也就是從最後一個元素開始計數，最後一個元素的位置編號是-1！
復制代碼 代碼如下:
>>> greeting[-1]
'g'
2.2 分片
分片可以訪問一定范圍內的元素，通過冒號相隔的2個索引來實現。分片對於提取序列的一部分是很有用的，第一個索引是提取部分的第一個元素編號，最後的索引是分片之後剩下部分的第一個元素編號。
復制代碼 代碼如下:
>>> number = [1,2,3,4,5,6,7,8,9,10]
>>> number[3:6]
[4,5,6]
>>> number[0:1]
[1]
2.2.1 優雅的捷徑
需要訪問最後3個元素，可以這樣顯式操作：
復制代碼 代碼如下:
>>> number[7:10]
[8,9,10]
這里索引10指向的第11個元素不存在，卻是在最後一個元素之後。
如果需要從列表結尾開始計數，就是說如果分片所得部分包括序列結尾的元素，那麼只需置空最後一個索引：
復制代碼 代碼如下:
>>> number[-3:]
[8,9,10]
這種方法適用於序列開始的元素或者顯示整個序列：
復制代碼 代碼如下:
>>> number[:3]
[1,2,3]
>>> number[:]
[1,2,3,4,5,6,7,8,9,10]
2.2.2 更大的步長
進行分片的時候，分片的開始和結束都需要進行指定，另一個參數-步長，通常是隱式設置的。默認的步長是1。如果顯示設置步長為比1大的數，那麼會跳過某些元素。
復制代碼 代碼如下:
>>> number[0:10:2]
[1,3,5,7,9]
>>> number[3:6:3]
[4]
步長不能為0，但是可以是負數，即從右到左提取元素：
復制代碼 代碼如下:
>>> number[10:0:-2]
[10,8,6,4,2]
>>> number[0:10:-2]
[]
上面第二個式子是錯誤的，使用一個負數作為步長時，必須讓開始點大於結束點。
2.3 序列相加
通過使用加號可以進行序列的連接操作：
復制代碼 代碼如下:
>>> [1,2,3] + [4,5,6]
[1,2,3,4,5,6]
>>>'hello, ' + 'world'
'hello, world'
>>>[1,2,3] + 'hello'
TypeError:can only concatenate list(not 'string') to list
如上面第三個例子所示，列表和字元串是無法連接到一塊的，盡管它們都是序列，但是只有2種相同類型的序列才能進行連接操作。
復制代碼 代碼如下:
2.4 乘法
用數字x乘以一個序列會生成新的序列，在新的序列中，原來的序列被重復x次：
[code]
>>> 'python' *5
''
>>> [42] * 5
[42,42,42,42,42]
None，空列表和初始化
空列表可以通過2個中括弧進行表示（[]），但是如果想創建一個佔用十個元素空間，卻不包括任何有用內容的列表，我們就需要一個值來代表空值，可以這樣做：
復制代碼 代碼如下:
>>> sequence = [None] * 10
>>> sequence
[None,None,None,None,None,None,None,None,None,None]
2.5 成員資格
為了檢查一個值是否在序列中，可以使用in運算符。它檢查某個條件是否為真，然後返回相應的值（True或False）
復制代碼 代碼如下:
>>> p = 'write'
>>> 'w' in p
True
>>> user =["a","b","c"]
>>> raw_input('Enter:') in user
Enter:a
True
2.6 長度，最大最小值
復制代碼 代碼如下:
>>> numbers = [10,20,30]
>>> len(numbers)
>>> max(numbers)
>>> min(numbers)
>>> max(1,99)
>>> min(1,99)
上面最後2個例子中，max函數和min函數的參數並不是序列，而是以多個數字直接作為參數。
3.列表：python的「苦力」
3.1 list函數
因為字元串不能像列表一樣被修改，所以有時候根據字元串創建列表會很有用。ps：list函數適用於所有類型的列表，不只是字元串。
復制代碼 代碼如下:
>>> list('hello')
['h','e','l','l','o']
提示：可以用下面的表達式將一個由字元組成的列表轉換為字元串：
復制代碼 代碼如下:
>>> strs = 『 '.jion（list）
>>> strs
"h e l l o"
3.2 基本列表操作
方法是一個與某些對象有緊密聯系的函數，對象可能是列表，數字，也可能是字元串或者其他類型的對象。列表提供了幾個方法，用於檢測或者修改其中的內容。
3.2.1 append
append方法用於在列表末尾追加新的對象：
復制代碼 代碼如下:
>>> lst = [1,2,3]
>>> lst.append(4)
>>> lst
[1,2,3,4]
注意：append方法不是簡單地返回一個修改過的新列表，而是直接修改原來的列表。
3.2.2 count
count方法統計某個元素在列表中出現的次數：
復制代碼 代碼如下:
>>> x =[[1,2],1,1,[1,2,[1,2]]]
>>> x.count(1)
2
3.2.3 extend
extend方法可以在列表的末尾一次性追加另一個序列中的多個值。
注意：extend方法和連接操作（+）最主要的區別在於：extend方法修改了被擴展的序列，而連接操作會返回一個全新的列表。
3.2.4 index
index方法用於從列表中找出某個值第一次匹配項的索引位置：
復制代碼 代碼如下:
>>> knights = ['we','are','the','knights']
>>> knights.index('the')
2
>>> knights.index("hi")
ValueError:list.index(x):x not in list
當匹配項沒有被找到時，會引發一個異常。
3.2.5 insert
insert方法用於將對象插入到列表中：
復制代碼 代碼如下:
>>> numbers = [1,2,3,6]
>>> numbers = insert(3,5)
>>> numbers
[1,2,3,5,6]
>>> numbers[3:3] = [4]
>>> numbers
[1,2,3,4,5,6]
上面最後一個例子中通過分片賦值實現插入，但是可讀性不如insert。
3.2.6 pop
pop方法會移除列表中的一個元素，並且放回該元素的值，它是唯一一個既能修改列表又能返回元素值的列表方法：
復制代碼 代碼如下:
>>> x = [1,2,3]
>>> x.pop()
3
>>> x
[1,2]
3.2.7 remove
remove方法用於移除列表中某個值的第一個匹配項：
復制代碼 代碼如下:
>>> x = ['to','be','to']
>>> x.remove('to')
>>> x
['be','to']
>>> x.remove('kkk')
ValueError:list.remove(x):x not in list
可以看到只有第一次出現的值被移除了，而不在列表中的值是不會移除的。
3.2.8 reverse
reverse方法將列表中的元素反向存放：
復制代碼 代碼如下:
>>> x = [1,2,3]
>>> x.reverse()
>>> x
[3,2,1]
3.2.9 sort
sort方法用於在原位置對列表進行排序，意味著改變原來的列表，而不是簡單地返回一個已排序的列表副本。
如果想要得到一個排序而不改變原來的數值，那就需要先賦值再排序：
復制代碼 代碼如下:
>>> x = [4,2,7,1]
>>> y = x[:]
>>> y.sort()
>>> x
[4,2,7,1]
>>>y
[1,2,4,7]
注意：上面的例子中賦值使用的是y=x[:]，分片是一種很有效率的復制整個列表的方法。如果簡單地把x賦值給y是沒有的（y=x），因為這樣做就讓x和y指向同一個列表了。
另一種獲取已排序列表副本的方法是使用sorted函數：
復制代碼 代碼如下:
>>> x = [4,5,3,7,2]
>>> y = sorted(x)
>>> x
[4,5,3,7,2]
>>> y
[2,3,4,5,7]
3.2.10 高級排序
如果希望元素能夠按照特定的方式進行排序，那麼可以通過compare(x,y)的形式自定義比較函數。內建cmp函數提供了比較函數的默認實現方式：
復制代碼 代碼如下:
>>> cmp(1,2)
-1
>>> cmp(2,1)
>>> cmp(1,1)
>>> numbers = [5,3,9,7]
>>> numbers.sort(cmp)
>>> numbers
[3,5,7,9]
sort方法有另外2個可選參數-key和reverse。要使用它們，那就要通過名字來指定。
復制代碼 代碼如下:
>>> x = ['a','abc','ab']
>>> x.sort(key=len)
>>> x
['a','ab','abc']
>>> y = [2,4,1,5]
>>> y.sort(reverse)
>>> y
[5,4,2,1]
4.元組：不可變序列
創建元組的語法很簡單：如果你用逗號分隔了一些值，那麼你就自動創建了元組。
復制代碼 代碼如下:
>>>1,2,3
(1,2,3)
>>>(1,2,3)
(1,2,3)
>>>()
()
>>>42,
(42,)
如上面最後一個例子，如果要實現一個包括一個值的元組，必須在數值後面加一個逗號。
4.1 tuple函數
tuple將一個序列作為參數並把它轉換為元組，如果參數是元組，那麼該參數就會被原樣返回：
復制代碼 代碼如下:
>>> tuple([1,2,3])
(1,2,3)
>>> tuple('abc')
('a','b','c')
>>> tuple((1,2,3))
(1,2,3)
4.2 基本元組操作
元組其實並不復雜，除了創建元組和訪問元組元素之外，也沒有太多其他操作：
復制代碼 代碼如下:
>>>x = 1,2,3
>>>x[1]
2
>>> x[0:2]
(1,2)
元組的分片還是元組，就像列表的分片還是列表一樣。
4.3 那麼，意義何在
元組是不可替代的：
（1）元組可以在映射中當作鍵使用，而列表不行。
（2）元組作為很多內建函數和方法的返回值存在。

⑧ python中'下標'和'索引'的區別

下標就是索引啊，比如a
=
[1,2,3,4,5]，共5個元素。a[0]就等於1，a[4]就等於5，這里0和4就是列表a某一項的索引或者說下標。a[5]就會越界，python和c一樣，都是從0開始數的，下標位置或者索引位置只能從0~4。

⑨ 如何用Python建立索引

importre

patt=re.compile("w+")

defmakeIndex(filename):
index={}
withopen(filename)ashandle:
fori,lninenumerate(handle):
forwordinpatt.findall(ln):
index.setdefault(word,[]).append(i+1)
returnindex

defprintIndex(index):
forword,lstinindex.items():
print"%s:%s"%(
word,",".join(map(str,lst))
)

defindexQuery(index,*args):
found=None
forwordinargs:
got=index.get(word,[])
ifnotgot:
returnNone
ifnotfound:
found=set(got)
else:
found&=set(got)

ifnotfound:
returnNone

returnlist(found)


index=makeIndex("qa.py")
printIndex(index)
printindexQuery(index,"in","enumerate")

⑩ python 字典索引

答案是A. 10
d2['2']是d2自身的引用，所以d2['2']['2']['2']['2'][2][2]就是d2[2][2]，也就是d1[2]，即10