ලැයිස්තුවේ ලැයිස්තුවක් ["foo", "bar", "baz"]සහ අයිතමයක් ලබා දී ඇති විට "bar", එහි දර්ශකය ( 1) පයිතන්හි ලබා ගන්නේ කෙසේද?

>>> ["foo", "bar", "baz"].index("bar")
1

යොමුව: දත්ත ව්‍යුහයන්> ලැයිස්තු පිළිබඳ තවත්

ගුහාවන් අනුගමනය කරයි

මෙම සමහර විට ඒ සඳහා පිළිතුරු දීමට පිරිසිදුම ක්රමය වන අතර එම සටහන පිළිතුර ලෙස , indexමෙම යන වඩා දුර්වල අංගයකි listAPI, මම කෝපයෙන් එය භාවිතා අවසන් වරට මතක නැහැ. මෙම පිළිතුර බොහෝ සෙයින් යොමු කර ඇති නිසා එය වඩාත් සම්පූර්ණ කළ යුතු බව අදහස් දැක්වීමේදී මට පෙන්වා දී ඇත. list.indexඅනුගමනය කිරීම පිළිබඳ සමහර අවවාද . මුලින් ඒ සඳහා වන ලියකියවිලි දෙස බැලීම වටී:

list.index(x[, start[, end]])

X ට සමාන වන පළමු අයිතමයේ ලැයිස්තුවේ ශුන්‍ය පාදක දර්ශකය ආපසු එවන්න . ValueErrorඑවැනි අයිතමයක් නොමැති නම් a මතු කරයි .

විකල්ප තර්ක ආරම්භක හා අවසානය පෙති අංකනයෙහි මෙන් අර්ථකථනය කර ඇති අතර ලැයිස්තුවේ නිශ්චිත අනුගාමිකයෙකුට සෙවීම සීමා කිරීමට භාවිතා කරයි. ආපසු එන දර්ශකය ගණනය කරනු ලබන්නේ ආරම්භක තර්කයට වඩා සම්පූර්ණ අනුක්‍රමයේ ආරම්භයට සාපේක්ෂව ය.

ලැයිස්තු දිගෙහි රේඛීය කාල-සංකීර්ණත්වය

ක indexඇමතුමක් සඳහා ලැයිස්තුව සෑම අංගයක් පරික්ෂා එය තරගය සම්බ වන තුරු. ඔබගේ ලැයිස්තුව දිගු නම්, එය සිදුවන්නේ කොතැනදැයි දළ වශයෙන් ඔබ නොදන්නේ නම්, මෙම සෙවීම බාධකයක් විය හැකිය. එවැනි අවස්ථාවක, ඔබ වෙනස් දත්ත ව්‍යුහයක් සලකා බැලිය යුතුය. තරගය සොයා ගත යුත්තේ කොතැනදැයි ඔබ දළ වශයෙන් දන්නේ නම්, ඔබට indexඉඟියක් ලබා දිය හැකි බව සලකන්න . නිදසුනක් ලෙස, මෙම ස්නිපටයේ, l.index(999_999, 999_990, 1_000_000)දළ වශයෙන් විශාලත්වයේ ඇණවුම් පහක් කෙළින්ම වඩා වේගවත් වේ l.index(999_999), මන්ද යත්, කලින් කළ යුත්තේ ඇතුළත් කිරීම් 10 ක් පමණක් සෙවිය යුතු අතර, දෙවැන්න මිලියනයක් සෙවීම ය:

>>> import timeit
>>> timeit.timeit('l.index(999_999)', setup='l = list(range(0, 1_000_000))', number=1000)
9.356267921015387
>>> timeit.timeit('l.index(999_999, 999_990, 1_000_000)', setup='l = list(range(0, 1_000_000))', number=1000)
0.0004404920036904514

පළමු තරඟයේ දර්ශකය එහි තර්කයට පමණක් ලබා දෙයි

indexගැලපීමක් සොයා ගන්නා තෙක් ලැයිස්තුව හරහා සෙවීම් සඳහා ඇමතුමක් ලබා දී එහි නතර වේ. ඔබට තවත් ගැලපුම් දර්ශක අවශ්‍ය යැයි ඔබ අපේක්ෂා කරන්නේ නම්, ඔබ ලැයිස්තු අවබෝධයක් හෝ උත්පාදක ප්‍රකාශනයක් භාවිතා කළ යුතුය.

>>> [1, 1].index(1)
0
>>> [i for i, e in enumerate([1, 2, 1]) if e == 1]
[0, 2]
>>> g = (i for i, e in enumerate([1, 2, 1]) if e == 1)
>>> next(g)
0
>>> next(g)
2

මා වරක් භාවිතා කළ බොහෝ ස්ථාන index, මම දැන් ලැයිස්තු අවබෝධය හෝ උත්පාදක ප්‍රකාශනය භාවිතා කරන්නේ ඒවා වඩාත් සාමාන්‍යකරණය කළ හැකි බැවිනි. එබැවින් ඔබ ළඟා වීමට අදහස් කරන්නේ නම් index, මෙම විශිෂ්ට පයිතන් විශේෂාංග දෙස බලන්න.

මූලද්රව්ය ලැයිස්තුවේ නොමැති නම් විසි කරයි

අයිතමය නොමැති නම් ප්‍රති indexresults ල සඳහා ඇමතුමක් ValueError.

>>> [1, 1].index(2)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: 2 is not in list

අයිතමය ලැයිස්තුවේ නොමැති නම්, ඔබත් එසේ කළ යුතුය

1. පළමුවෙන්ම item in my_list(පිරිසිදු, කියවිය හැකි ප්‍රවේශය), හෝ
2. මෙම ආවරණය කරනවා indexදී ඇමතුමක් try/exceptලද උඩ පන්දු වාරණ ValueError(සෙවුම් කිරීමට ලැයිස්තුව දිගු වන විට, සහ අයිතමය සාමාන්යයෙන් දක්නට ලැබේ අවම වශයෙන් බොහෝ විට වේගවත්,.)

පයිතන් ඉගෙනීමට සැබවින්ම උපකාරී වන එක් දෙයක් නම් අන්තර්ක්‍රියාකාරී උපකාරක ශ්‍රිතය භාවිතා කිරීමයි:

>>> help(["foo", "bar", "baz"])
Help on list object:

class list(object)
 ...

 |
 |  index(...)
 |      L.index(value, [start, [stop]]) -> integer -- return first index of value
 |

එය බොහෝ විට ඔබ සොයන ක්‍රමයට ඔබව ගෙන යනු ඇත.

පිළිතුරු වලින් බහුතරයක් තනි දර්ශකයක් සොයා ගන්නේ කෙසේද යන්න පැහැදිලි කරයි , නමුත් අයිතමය ලැයිස්තුවේ කිහිප වතාවක් තිබේ නම් ඒවායේ ක්‍රම මඟින් බහු දර්ශක ලබා නොදේ. භාවිතා කරන්න enumerate():

for i, j in enumerate(['foo', 'bar', 'baz']):
    if j == 'bar':
        print(i)

මෙම index()කාර්යය පමණක්, පළමු සිදුවීම නැවත අතර enumerate()සියලු සිදුවීම් පැමිණේ.

ලැයිස්තු අවබෝධයක් ලෙස:

[i for i, j in enumerate(['foo', 'bar', 'baz']) if j == 'bar']

මෙන්න තවත් කුඩා විසඳුමක් ද ඇත itertools.count()(එය ගණන් බැලීමට සමාන ප්‍රවේශයකි):

from itertools import izip as zip, count # izip for maximum efficiency
[i for i, j in zip(count(), ['foo', 'bar', 'baz']) if j == 'bar']

භාවිතා කිරීමට වඩා විශාල ලැයිස්තු සඳහා මෙය වඩා කාර්යක්ෂම වේ enumerate():

$ python -m timeit -s "from itertools import izip as zip, count" "[i for i, j in zip(count(), ['foo', 'bar', 'baz']*500) if j == 'bar']"
10000 loops, best of 3: 174 usec per loop
$ python -m timeit "[i for i, j in enumerate(['foo', 'bar', 'baz']*500) if j == 'bar']"
10000 loops, best of 3: 196 usec per loop

සියලුම දර්ශක ලබා ගැනීම සඳහා:

indexes = [i for i,x in enumerate(xs) if x == 'foo']

index()මෙම නැවත පළමු වටිනාකමින් දර්ශකය!

| දර්ශකය (...)
| L.index (අගය, [ආරම්භය, [නැවතුම්]]) -> නිඛිලය - පළමු අගය දර්ශකය ආපසු එවන්න

def all_indices(value, qlist):
    indices = []
    idx = -1
    while True:
        try:
            idx = qlist.index(value, idx+1)
            indices.append(idx)
        except ValueError:
            break
    return indices

all_indices("foo", ["foo","bar","baz","foo"])

මූලද්රව්යය ලැයිස්තුවේ නොමැති නම් ගැටළුවක් පැන නගිනු ඇත. මෙම ශ්‍රිතය ගැටළුව හසුරුවයි:

# if element is found it returns index of element else returns None

def find_element_in_list(element, list_element):
    try:
        index_element = list_element.index(element)
        return index_element
    except ValueError:
        return None

a = ["foo","bar","baz",'bar','any','much']

indexes = [index for index in range(len(a)) if a[index] == 'bar']

ඔබ සොයන අංගය ලැයිස්තුවේ තිබේදැයි පරීක්ෂා කිරීමට ඔබට කොන්දේසියක් සැකසිය යුතුය

if 'your_element' in mylist:
    print mylist.index('your_element')
else:
    print None

මෙහි යෝජිත සියලුම කාර්යයන් සහජ භාෂා හැසිරීම ප්‍රතිනිෂ්පාදනය කරන නමුත් සිදුවන්නේ කුමක්ද යන්න අපැහැදිලි ය.

[i for i in range(len(mylist)) if mylist[i]==myterm]  # get the indices

[each for each in mylist if each==myterm]             # get the items

mylist.index(myterm) if myterm in mylist else None    # get the first index and fail quietly

ඔබට අවශ්‍ය දේ කිරීමට භාෂාව ක්‍රමවේදයන් සපයන්නේ නම් ව්‍යතිරේකය හැසිරවීම සමඟ ශ්‍රිතයක් ලියන්නේ ඇයි?

ඔබට සියලු දර්ශක අවශ්‍ය නම්, ඔබට NumPy භාවිතා කළ හැකිය :

import numpy as np

array = [1, 2, 1, 3, 4, 5, 1]
item = 1
np_array = np.array(array)
item_index = np.where(np_array==item)
print item_index
# Out: (array([0, 2, 6], dtype=int64),)

එය පැහැදිලි, කියවිය හැකි විසඳුමකි.

පයිතන් හි අඩංගු ලැයිස්තුවක් ලබා දී ඇති අයිතමයක දර්ශකය සොයා ගැනීම

ලැයිස්තුවක් ["foo", "bar", "baz"]සහ ලැයිස්තුවේ ඇති අයිතමයක් සඳහා "bar", එහි දර්ශකය (1) පයිතන් තුළ ලබා ගැනීමට ඇති පිරිසිදුම ක්‍රමය කුමක්ද?

හොඳයි, විශ්වාසයි, දර්ශක ක්‍රමය ඇත, එය පළමු සිදුවීමේ දර්ශකය නැවත ලබා දෙයි:

>>> l = ["foo", "bar", "baz"]
>>> l.index('bar')
1

මෙම ක්රමය සමඟ ගැටළු කිහිපයක් තිබේ:

• අගය ලැයිස්තුවේ නොමැති නම්, ඔබට ලැබෙනු ඇත ValueError
• ලැයිස්තුවේ වටිනාකමෙන් එකකට වඩා තිබේ නම්, ඔබට ලැබෙන්නේ පළමු එක සඳහා පමණි

අගයන් නොමැත

වටිනාකම නැතිවිය හැකි නම්, ඔබ එය අල්ලා ගත යුතුය ValueError.

ඔබට මෙය නැවත භාවිතා කළ හැකි අර්ථ දැක්වීමකින් කළ හැකිය:

def index(a_list, value):
    try:
        return a_list.index(value)
    except ValueError:
        return None

එය මේ ආකාරයට භාවිතා කරන්න:

>>> print(index(l, 'quux'))
None
>>> print(index(l, 'bar'))
1

මෙහි අවාසිය නම් ආපසු ලබා දුන් අගය isහෝ is notකිසිවක් නොමැති දැයි ඔබට චෙක්පතක් තිබීමයි:

result = index(a_list, value)
if result is not None:
    do_something(result)

ලැයිස්තුවේ එක් අගයකට වඩා

ඔබට තවත් සිදුවීම් සිදුවිය හැකි නම්, ඔබට සම්පූර්ණ තොරතුරු ලැබෙන්නේ නැතlist.index :

>>> l.append('bar')
>>> l
['foo', 'bar', 'baz', 'bar']
>>> l.index('bar')              # nothing at index 3?
1

ඔබට සුචිගත කිරීම් ලැයිස්තුවක් ගණනය කළ හැකිය:

>>> [index for index, v in enumerate(l) if v == 'bar']
[1, 3]
>>> [index for index, v in enumerate(l) if v == 'boink']
[]

ඔබට කිසිදු සිදුවීමක් නොමැති නම්, ඔබට ප්‍රති result ලයේ බූලියන් පරීක්ෂාවකින් එය පරීක්ෂා කළ හැකිය, නැතහොත් ප්‍රති results ල ඉක්මවා ගියහොත් කිසිවක් නොකරන්න:

indexes = [index for index, v in enumerate(l) if v == 'boink']
for index in indexes:
    do_something(index)

පැන්ඩා සමඟ වඩා හොඳ දත්ත ඇඹරීම

ඔබට පැන්ඩා තිබේ නම්, ඔබට පහසුවෙන් මෙම තොරතුරු ශ්‍රේණි වස්තුවකින් ලබා ගත හැකිය:

>>> import pandas as pd
>>> series = pd.Series(l)
>>> series
0    foo
1    bar
2    baz
3    bar
dtype: object

සංසන්දනාත්මක චෙක්පතක් මඟින් බූලියන් මාලාවක් ලබා දෙනු ඇත:

>>> series == 'bar'
0    False
1     True
2    False
3     True
dtype: bool

එම බූලියන් මාලාව ග්‍රාහක අංකනය හරහා ශ්‍රේණියට යොමු කරන්න, එවිට ඔබට ගැලපෙන සාමාජිකයන් ලැබෙනු ඇත:

>>> series[series == 'bar']
1    bar
3    bar
dtype: object

ඔබට දර්ශක පමණක් අවශ්‍ය නම්, දර්ශක ගුණාංගය පූර්ණ සංඛ්‍යා මාලාවක් ලබා දෙයි:

>>> series[series == 'bar'].index
Int64Index([1, 3], dtype='int64')

ඔබට ඒවා ලැයිස්තුවක් හෝ ටුපල් එකක් අවශ්‍ය නම් ඒවා ඉදිකිරීම්කරු වෙත යවන්න:

>>> list(series[series == 'bar'].index)
[1, 3]

ඔව්, ඔබට ගණන් බැලීම් සමඟ ලැයිස්තු අවබෝධයක් ද භාවිතා කළ හැකිය, නමුත් එය එතරම් අලංකාර නැත, මගේ මතය අනුව - ඔබ පයිතන්හි සමානාත්මතාවය සඳහා පරීක්ෂණ සිදු කරයි, සී හි ලියා ඇති බිල්ඩින් කේතයට එය හැසිරවීමට ඉඩ දෙනවා වෙනුවට:

>>> [i for i, value in enumerate(l) if value == 'bar']
[1, 3]

මෙය XY ගැටලුවක්ද ?

XY ගැටළුව ඔබේ සැබෑ ගැටලුවට වඩා ඔබ උත්සාහ කළ විසඳුම ගැන විමසයි.

ලැයිස්තුවක මූලද්‍රව්‍යයක් ලබා දී ඇති දර්ශකය ඔබට අවශ්‍ය යැයි ඔබ සිතන්නේ ඇයි?

ඔබ දැනටමත් වටිනාකම දන්නේ නම්, එය ලැයිස්තුවේ කොතැනදැයි ඔබ සැලකිලිමත් වන්නේ ඇයි?

වටිනාකම නොමැති නම්, අල්ලා ValueErrorගැනීම තරමක් වාචික ය - මම එය වළක්වා ගැනීමට කැමැත්තෙමි.

මම සාමාන්‍යයෙන් කෙසේ හෝ ලැයිස්තුවට නැවත කියමි, එබැවින් මම සාමාන්‍යයෙන් ඕනෑම රසවත් තොරතුරක් වෙත යොමු කරමි, දර්ශකය ගණනය කිරීම සමඟ ලබා ගනිමි .

ඔබ දත්ත නාස්ති කරන්නේ නම්, ඔබ බොහෝ විට පැන්ඩා භාවිතා කළ යුතුය - මා විසින් පෙන්වා ඇති පිරිසිදු පයිතන් ක්‍රියාකාරීත්වයට වඩා අලංකාර මෙවලම් ඇත.

අවශ්‍යතාවය මට මතක නැත list.index. කෙසේ වෙතත්, මම පයිතන් සම්මත පුස්තකාලය හරහා බැලුවෙමි, ඒ සඳහා විශිෂ්ට භාවිතයන් කිහිපයක් මම දකිමි.

idlelibGUI සහ පෙළ විග්‍රහ කිරීම සඳහා ඒ සඳහා බොහෝ, බොහෝ භාවිතයන් ඇත.

මෙම keywordඑය ස්වයංක්රීයව metaprogramming හරහා එය ප්රධාන වචන ලැයිස්තුව යළි ගොඩනැංවීමේ මෙම මොඩියුලය තුළ අදහස් සලකුණු සොයා ගැනීමට මොඩියුලය භාවිතා කරයි.

Lib / mailbox.py හි එය ඇණවුම් කළ සිතියමක් මෙන් භාවිතා කරන බව පෙනේ:

key_list[key_list.index(old)] = new

හා

del key_list[key_list.index(key)]

Lib / http / cookiejar.py හි, ඊළඟ මාසය ලබා ගැනීම සඳහා භාවිතා කරන බව පෙනේ:

mon = MONTHS_LOWER.index(mon.lower())+1

අයිතමයක් දක්වා පෙත්තක් ලබා ගැනීම සඳහා distutils වලට සමාන Lib / tarfile.py හි:

members = members[:members.index(tarinfo)]

Lib / pickletools.py හි:

numtopop = before.index(markobject)

මෙම භාවිතයන් පොදුවේ ඇති බව පෙනෙන දෙය නම්, ඒවා සීමිත ප්‍රමාණයේ ලැයිස්තු මත ක්‍රියාත්මක වන බව පෙනේ (O (n) සෙවීමේ කාලය නිසා වැදගත් වේ list.index), ඒවා බොහෝ විට විග්‍රහ කිරීමේදී භාවිතා වේ (සහ නිෂ්ක්‍රීයව UI).

ඒ සඳහා භාවිත අවස්ථා ඇති අතර ඒවා තරමක් අසාමාන්‍යය. ඔබ මෙම පිළිතුර සොයන බව ඔබ සොයා ගන්නේ නම්, ඔබේ භාවිතය සඳහා භාෂාව විසින් සපයනු ලබන මෙවලම් වඩාත් සෘජුවම භාවිතා කරන්නේ ඔබ කරන්නේ කුමක්දැයි ඔබගෙන්ම විමසන්න.

zipශ්‍රිතය සමඟ ඇති සියලුම දර්ශක :

get_indexes = lambda x, xs: [i for (y, i) in zip(xs, range(len(xs))) if x == y]

print get_indexes(2, [1, 2, 3, 4, 5, 6, 3, 2, 3, 2])
print get_indexes('f', 'xsfhhttytffsafweef')

සියලුම සිදුවීම් සහ ලැයිස්තුවක් තුළ (සමාන) අයිතම එකක් හෝ වැඩි ගණනක් ලබා ගැනීම

X මූලද්‍රව්‍යය ඔබ සොයන දෙයට සමාන වන විට ගණන් කිරීමේ (ඇලිස්ට්) සමඟ ඔබට ලැයිස්තුවේ දර්ශකය වන පළමු මූලද්‍රව්‍යය (n) ගබඩා කළ හැකිය.

>>> alist = ['foo', 'spam', 'egg', 'foo']
>>> foo_indexes = [n for n,x in enumerate(alist) if x=='foo']
>>> foo_indexes
[0, 3]
>>>

අපි අපේ ශ්‍රිතය findindex කරමු

මෙම ශ්‍රිතය අයිතමය සහ ලැයිස්තුව තර්ක ලෙස ගෙන අප කලින් දුටු පරිදි ලැයිස්තුවේ ඇති අයිතමයේ පිහිටීම නැවත ලබා දේ.

def indexlist(item2find, list_or_string):
  "Returns all indexes of an item in a list or a string"
  return [n for n,item in enumerate(list_or_string) if item==item2find]

print(indexlist("1", "010101010"))

ප්‍රතිදානය

[1, 3, 5, 7]

සරල

for n, i in enumerate([1, 2, 3, 4, 1]):
    if i == 1:
        print(n)

ප්‍රතිදානය:

0
4

සරලවම ඔබට යන්න පුළුවන්

a = [['hand', 'head'], ['phone', 'wallet'], ['lost', 'stock']]
b = ['phone', 'lost']

res = [[x[0] for x in a].index(y) for y in b]

තවත් විකල්පයක්

>>> a = ['red', 'blue', 'green', 'red']
>>> b = 'red'
>>> offset = 0;
>>> indices = list()
>>> for i in range(a.count(b)):
...     indices.append(a.index(b,offset))
...     offset = indices[-1]+1
... 
>>> indices
[0, 3]
>>> 

දැන්, සම්පූර්ණයෙන්ම වෙනස් දෙයක් සඳහා ...

... දර්ශකය ලබා ගැනීමට පෙර අයිතමයේ පැවැත්ම තහවුරු කිරීම වැනි. මෙම ප්‍රවේශයේ ඇති හොඳ දෙය නම් ශ්‍රිතය සෑම විටම දර්ශක ලැයිස්තුවක් ලබා දීමයි - එය හිස් ලැයිස්තුවක් වුවද. එය නූල් සමඟ ද ක්‍රියා කරයි.

def indices(l, val):
    """Always returns a list containing the indices of val in the_list"""
    retval = []
    last = 0
    while val in l[last:]:
            i = l[last:].index(val)
            retval.append(last + i)
            last += i + 1   
    return retval

l = ['bar','foo','bar','baz','bar','bar']
q = 'bar'
print indices(l,q)
print indices(l,'bat')
print indices('abcdaababb','a')

අන්තර්ක්‍රියාකාරී පයිතන් කවුළුවක අලවන විට:

Python 2.7.6 (v2.7.6:3a1db0d2747e, Nov 10 2013, 00:42:54) 
[GCC 4.2.1 (Apple Inc. build 5666) (dot 3)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>> def indices(the_list, val):
...     """Always returns a list containing the indices of val in the_list"""
...     retval = []
...     last = 0
...     while val in the_list[last:]:
...             i = the_list[last:].index(val)
...             retval.append(last + i)
...             last += i + 1   
...     return retval
... 
>>> l = ['bar','foo','bar','baz','bar','bar']
>>> q = 'bar'
>>> print indices(l,q)
[0, 2, 4, 5]
>>> print indices(l,'bat')
[]
>>> print indices('abcdaababb','a')
[0, 4, 5, 7]
>>> 

යාවත්කාලීන කරන්න

තවත් වසරක පයිතන් සංවර්ධනයෙන් පසු, මගේ මුල් පිළිතුරෙන් මම ටිකක් ලැජ්ජාවට පත් වෙමි, එබැවින් වාර්තාව නිවැරදි කිරීමට, කෙනෙකුට නිසැකවම ඉහත කේතය භාවිතා කළ හැකිය; කෙසේ වෙතත්, බොහෝ එකම හැසිරීම ලබා ගැනීමට වඩා සෙන්දගශයෙහි මාර්ගය කීයක් () යන ශ්රිතය සමග, ලැයිස්තුව අවබෝධය භාවිතා කිරීමට වනු ඇත.

මේ වගේ දෙයක්:

def indices(l, val):
    """Always returns a list containing the indices of val in the_list"""
    return [index for index, value in enumerate(l) if value == val]

l = ['bar','foo','bar','baz','bar','bar']
q = 'bar'
print indices(l,q)
print indices(l,'bat')
print indices('abcdaababb','a')

අන්තර්ක්‍රියාකාරී පයිතන් කවුළුවක අලවන විට ලැබෙන ප්‍රති ields ල:

Python 2.7.14 |Anaconda, Inc.| (default, Dec  7 2017, 11:07:58) 
[GCC 4.2.1 Compatible Clang 4.0.1 (tags/RELEASE_401/final)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>> def indices(l, val):
...     """Always returns a list containing the indices of val in the_list"""
...     return [index for index, value in enumerate(l) if value == val]
... 
>>> l = ['bar','foo','bar','baz','bar','bar']
>>> q = 'bar'
>>> print indices(l,q)
[0, 2, 4, 5]
>>> print indices(l,'bat')
[]
>>> print indices('abcdaababb','a')
[0, 4, 5, 7]
>>> 

දැන්, මෙම ප්‍රශ්නය සහ සියලු පිළිතුරු සමාලෝචනය කිරීමෙන් පසුව, එෆ්එම්සී ඔහුගේ පෙර පිළිතුරෙන් යෝජනා කළේ මෙයම බව මට වැටහේ . මම මුලින් මෙම ප්‍රශ්නයට පිළිතුරු දුන් අවස්ථාවේදී, මම එම පිළිතුර පවා දුටුවේ නැත , මන්ද එය මට නොතේරුණි. මගේ තරමක් වාචික උදාහරණය තේරුම් ගැනීමට උපකාරී වනු ඇතැයි මම බලාපොරොත්තු වෙමි.

කේතය තනි මාර්ගය ඉහත තවමත් නම් නැත ඔබට තේරුමක්, මා අතිශයින් ඔබ Google 'පිඹුරා ලැයිස්තුව අවබෝධය' නිර්දේශ හා සාදා ගැනීමට මිනිත්තු කිහිපයක් ගත. කේත සංවර්ධනය කිරීම සඳහා පයිතන් භාවිතා කිරීම සතුටට කරුණක් වන බොහෝ ප්‍රබල අංගවලින් එකක් පමණි.

FMc සහ user7177 වෙතින් ලැබෙන පිළිතුරේ ප්‍රභේදයක් මඟින් ඕනෑම ප්‍රවේශයක් සඳහා සියලු දර්ශක ආපසු ලබා දිය හැකි නියෝගයක් ලබා දෙනු ඇත:

>>> a = ['foo','bar','baz','bar','any', 'foo', 'much']
>>> l = dict(zip(set(a), map(lambda y: [i for i,z in enumerate(a) if z is y ], set(a))))
>>> l['foo']
[0, 5]
>>> l ['much']
[6]
>>> l
{'baz': [2], 'foo': [0, 5], 'bar': [1, 3], 'any': [4], 'much': [6]}
>>> 

තනි ප්‍රවේශයක් සඳහා සියලු දර්ශක ලබා ගැනීමට ඔබට මෙය එක් ලයිනර් ලෙස භාවිතා කළ හැකිය. ලැම්බඩා කැඳවන වාර ගණන අඩු කිරීම සඳහා මම (අ) කට්ටලය භාවිතා කළද, කාර්යක්ෂමතාව සඳහා කිසිදු සහතිකයක් නොමැත.

මෙම විසඳුම අනෙක් අය තරම් බලවත් නොවේ, නමුත් ඔබ ආරම්භකයකු නම් සහ forලූප ගැන පමණක් දන්නේ නම්, අගය දෝෂය මඟහරවා ගනිමින් අයිතමයක පළමු දර්ශකය සොයාගත හැකිය:

def find_element(p,t):
    i = 0
    for e in p:
        if e == t:
            return i
        else:
            i +=1
    return -1

L ලැයිස්තුවේ x අයිතමයේ දර්ශකය සොයා ගැනීම:

idx = L.index(x) if (x in L) else -1

name ="bar"
list = [["foo", 1], ["bar", 2], ["baz", 3]]
new_list=[]
for item in list:
    new_list.append(item[0])
print(new_list)
try:
    location= new_list.index(name)
except:
    location=-1
print (location)

මෙම ලැයිස්තුවේ නූල් නොමැති නම්, එය ලැයිස්තුවේ නොමැති නම් මෙය සිදු වේ location = -1

පයිතන් ලැයිස්තු ශුන්‍ය මත පදනම් වූ බැවින් අපට පහත දැක්වෙන පරිදි සිප් බිල්ට් ශ්‍රිතය භාවිතා කළ හැකිය:

>>> [i for i,j in zip(range(len(haystack)), haystack) if j == 'needle' ]

එහිදී "පිදුරු මඩුව" යනු ප්‍රශ්නාර්ථ ලැයිස්තුව වන අතර "ඉඳිකටුවක්" යනු සෙවිය යුතු අයිතමයයි.

(සටහන: මෙන්න අපි දර්ශක ලබා ගැනීම සඳහා i භාවිතා කරමින් නැවත ක්‍රියා කරන්නෙමු, නමුත් අපට අයිතම කෙරෙහි අවධානය යොමු කිරීමට අවශ්‍ය නම් අපට j වෙත මාරු විය හැකිය.)

index()අයිතමය සොයාගත නොහැකි නම් පයිතන් ක්‍රමය දෝෂයක් ඇති කරයි. එබැවින් ඒ වෙනුවට ඔබට එය indexOf()ජාවාස්ක්‍රිප්ට් හි ක්‍රියාකාරීත්වයට සමාන කළ -1හැකිය.

try:
    index = array.index('search_keyword')
except ValueError:
    index = -1

මේ සඳහා වඩාත් ක්‍රියාකාරී පිළිතුරක් තිබේ.

list(filter(lambda x: x[1]=="bar",enumerate(["foo", "bar", "baz", "bar", "baz", "bar", "a", "b", "c"])))

වඩාත් ජනක ස්වරූපය:

def get_index_of(lst, element):
    return list(map(lambda x: x[0],\
       (list(filter(lambda x: x[1]==element, enumerate(lst))))))

lstඔබ සතුව ඇති ලැයිස්තුවට නම ලබා දෙමු . කෙනෙකුට ලැයිස්තුව lsta බවට පරිවර්තනය කළ හැකිය numpy array. ලැයිස්තුවේ තෝරාගත් අයිතමයේ දර්ශකය ලබා ගැනීමට numpy.where භාවිතා කරන්න . ඔබ එය ක්‍රියාත්මක කරන ආකාරය පහත දැක්වේ.

import numpy as np

lst = ["foo", "bar", "baz"]  #lst: : 'list' data type
print np.where( np.array(lst) == 'bar')[0][0]

>>> 1

මා වැනි වෙනත් භාෂාවකින් පැමිණෙන අයට, සමහර විට සරල පුඩුවක් සමඟ එය තේරුම් ගැනීමට සහ භාවිතා කිරීමට පහසු වේ:

mylist = ["foo", "bar", "baz", "bar"]
newlist = enumerate(mylist)
for index, item in newlist:
  if item == "bar":
    print(index, item)

මම ස්තූතිවන්ත වෙනවා ඉතින් ගණන් කිරීම හරියටම කරන්නේ කුමක්ද? . එය මට තේරුම් ගැනීමට උපකාර විය.

ඔබ එක් වරක් දර්ශකයක් සොයා ගැනීමට යන්නේ නම් "දර්ශක" ක්‍රමය භාවිතා කිරීම හොඳයි. කෙසේ වෙතත්, ඔබ එක් වරකට වඩා ඔබේ දත්ත සෙවීමට යන්නේ නම් ද්වි- මොඩියුලය භාවිතා කිරීමට මම නිර්දේශ කරමි . ද්වි-මොඩියුල දත්ත භාවිතා කිරීම වර්ග කළ යුතු බව මතක තබා ගන්න. එබැවින් ඔබ එක් වරක් දත්ත වර්ග කර පසුව ඔබට බයිසෙක්ට් භාවිතා කළ හැකිය. භාවිතා bisect මගේ පරිගණකයේ මොඩියුලය දර්ශකය ක්රමය භාවිතා වඩා වැඩි වාර 20 ක් පමණ වේගවත් වේ.

පයිතන් 3.8 සහ ඊට ඉහළ සින්ටැක්ස් භාවිතා කරන කේත සඳහා උදාහරණයක් මෙන්න:

import bisect
from timeit import timeit

def bisect_search(container, value):
    return (
      index 
      if (index := bisect.bisect_left(container, value)) < len(container) 
      and container[index] == value else -1
    )

data = list(range(1000))
# value to search
value = 666

# times to test
ttt = 1000

t1 = timeit(lambda: data.index(value), number=ttt)
t2 = timeit(lambda: bisect_search(data, value), number=ttt)

print(f"{t1=:.4f}, {t2=:.4f}, diffs {t1/t2=:.2f}")

ප්‍රතිදානය:

t1=0.0400, t2=0.0020, diffs t1/t2=19.60

කාර්ය සාධනය සැලකිලිමත් වන්නේ නම්:

සාදන ලද ක්‍රමවේදය list.index(item)O (n) ඇල්ගොරිතමයක් බව බොහෝ පිළිතුරු වල සඳහන් වේ . ඔබට මෙය එක් වරක් සිදු කිරීමට අවශ්‍ය නම් එය හොඳයි. නමුත් ඔබට මූලද්‍රව්‍යයන්ගේ දර්ශක කිහිප වතාවක් ප්‍රවේශ කිරීමට අවශ්‍ය නම්, පළමුව අයිතම-දර්ශක යුගලවල ශබ්ද කෝෂයක් (O (n)) නිර්මාණය කිරීම වඩාත් අර්ථවත් කරයි, පසුව ඔබට අවශ්‍ය සෑම අවස්ථාවකම O (1) හි දර්ශකයට පිවිසෙන්න. එය.

ඔබගේ ලැයිස්තුවේ ඇති අයිතම කිසි විටෙකත් පුනරාවර්තනය නොවන බව ඔබට විශ්වාස නම්, ඔබට පහසුවෙන් කළ හැකිය:

myList = ["foo", "bar", "baz"]

# Create the dictionary
myDict = dict((e,i) for i,e in enumerate(myList))

# Lookup
myDict["bar"] # Returns 1
# myDict.get("blah") if you don't want an error to be raised if element not found.

ඔබට අනුපිටපත් මූලද්‍රව්‍ය තිබිය හැකි නම් සහ ඒවායේ සියලු දර්ශක ආපසු ලබා දීමට අවශ්‍ය නම්:

from collections import defaultdict as dd
myList = ["foo", "bar", "bar", "baz", "foo"]

# Create the dictionary
myDict = dd(list)
for i,e in enumerate(myList):
    myDict[e].append(i)

# Lookup
myDict["foo"] # Returns [0, 4]

ErTerryA හි දැක්වෙන පරිදි, බොහෝ පිළිතුරු එක් දර්ශකයක් සොයා ගන්නේ කෙසේදැයි සාකච්ඡා කරයි .

more_itertoolsතෙවන පාර්ශවීය පුස්තකාලයක් වන අතර එය නැවත දර්ශකයක් තුළ බහු දර්ශක සොයා ගැනීමට මෙවලම් ඇත .

ලබා දී ඇත

import more_itertools as mit


iterable = ["foo", "bar", "baz", "ham", "foo", "bar", "baz"]

කේතය

බහු නිරීක්ෂණවල දර්ශක සොයා ගන්න:

list(mit.locate(iterable, lambda x: x == "bar"))
# [1, 5]

බහු අයිතම පරීක්ෂා කරන්න:

list(mit.locate(iterable, lambda x: x in {"bar", "ham"}))
# [1, 3, 5]

සමඟ තවත් විකල්ප බලන්න more_itertools.locate. හරහා ස්ථාපනය කරන්න > pip install more_itertools.

ශබ්දකෝෂය භාවිතා කරමින්, එහිදී ලැයිස්තුව මුලින්ම සකසා දර්ශකය එයට එක් කරන්න

from collections import defaultdict

index_dict = defaultdict(list)    
word_list =  ['foo','bar','baz','bar','any', 'foo', 'much']

for word_index in range(len(word_list)) :
    index_dict[word_list[word_index]].append(word_index)

word_index_to_find = 'foo'       
print(index_dict[word_index_to_find])

# output :  [0, 5]

මගේ මතය අනුව ["foo", "bar", "baz"].index("bar")එය හොඳයි, නමුත් එය ප්‍රමාණවත් නොවේ! මක්නිසාද යත් "බාර්" ශබ්ද කෝෂයේ නොමැති නම්, ValueErrorමතු කර ඇත.ඉතින් ඔබට මෙම ශ්‍රිතය භාවිතා කළ හැකිය:

def find_index(arr, name):
    try:
        return arr.index(name)
    except ValueError:
        return -1

if __name__ == '__main__':
    print(find_index(["foo", "bar", "baz"], "bar"))

ප්‍රති result ලය වන්නේ:

1

නම නොපැමිණියේ නම්, ශ්‍රිතය නැවත -1.1 සඳහා:

print (find_index (["foo", "bar", "baz"], "fooo"))

-1