При работе с коллекциями данных в Python часто возникает необходимость не только манипулировать элементами списка, но и определять их точное местоположение. Индекс элемента представляет собой числовое значение, указывающее на позицию элемента в списке, что делает его критически важным инструментом для эффективной обработки данных. Понимание механизмов поиска и работы с индексами позволяет разработчикам создавать более эффективные и надежные программы.
Списки в Python являются одной из наиболее часто используемых структур данных, которые позволяют хранить упорядоченные наборы элементов различных типов. При этом каждый элемент списка автоматически получает свой уникальный номер позиции, начиная с нуля. Знание точного индекса элемента необходимо для множества операций: от простого извлечения значения до сложных манипуляций с данными, включая вставку, удаление и обновление элементов списка.
В современном программировании поиск индекса элемента по его значению является распространенной задачей, которая может быть решена различными способами, каждый из которых имеет свои преимущества и ограничения. Python предоставляет как встроенные методы, так и возможность реализации пользовательских алгоритмов для решения этой задачи, что делает язык гибким инструментом для работы с данными в различных сценариях использования.
Что такое индекс элемента в списке
Индекс в списке представляет собой числовое значение, которое определяет точную позицию элемента в последовательности данных. В языке программирования Python индексация элементов начинается с нуля, что означает, что первый элемент списка имеет индекс 0, второй - индекс 1, и так далее. Эта особенность является стандартной практикой во многих современных языках программирования и обусловлена эффективностью работы с памятью компьютера.
Рассмотрим принцип индексации на конкретном примере:
Python | 1
2
| fruits = ['яблоко', 'банан', 'апельсин', 'груша']
[H2]индексы: 0 1 2 3[/H2] |
|
В этом примере список содержит четыре элемента, каждому из которых автоматически присваивается порядковый номер. При этом важно понимать, что индексы являются неотъемлемой частью структуры списка и существуют независимо от значений элементов. Они служат своеобразными указателями на конкретные позиции в памяти компьютера, где хранятся соответствующие значения.
Индексация в Python также поддерживает отрицательные значения индексов, что является одной из отличительных особенностей языка. При использовании отрицательных индексов отсчет ведется с конца списка: индекс -1 указывает на последний элемент, -2 на предпоследний, и так далее. Это делает работу с конечными элементами списка более удобной и интуитивно понятной. Например, в том же списке fruits:
Python | 1
2
| print(fruits[-1]) # выведет 'груша'
print(fruits[-2]) # выведет 'апельсин' |
|
Система индексации тесно связана с концепцией упорядоченности в Python. В отличие от некоторых других структур данных, таких как множества (sets) или словари (dictionaries) в их классическом виде, списки сохраняют порядок элементов, и этот порядок остается неизменным, пока мы явно не изменим его. Это свойство делает списки особенно полезными для хранения последовательностей данных, где важно сохранять определенный порядок элементов.
Доступ к элементам списка по индексу осуществляется с помощью квадратных скобок, в которых указывается требуемый индекс. Этот механизм обеспечивает прямой доступ к любому элементу списка за постоянное время, что делает операцию чтения очень эффективной. Синтаксис доступа к элементам выглядит следующим образом:
Python | 1
2
| my_list = ['первый', 'второй', 'третий', 'четвертый']
element = my_list[2] # получаем элемент с индексом 2 ('третий') |
|
При работе с индексами важно учитывать границы списка. Попытка обратиться к индексу, который находится за пределами допустимого диапазона, приведет к возникновению исключения IndexError. Для предотвращения подобных ошибок следует всегда проверять длину списка перед обращением к элементам по индексу. Длину списка можно получить с помощью встроенной функции len():
Python | 1
2
3
4
| my_list = [1, 2, 3]
list_length = len(my_list) # получаем длину списка
if index < list_length:
element = my_list[index] |
|
Индексы в Python также можно использовать для изменения значений элементов списка. Когда известен индекс элемента, его значение можно обновить, присвоив новое значение соответствующей позиции. Это одно из ключевых преимуществ списков перед неизменяемыми последовательностями, такими как кортежи. Пример изменения значения элемента по индексу:
Python | 1
2
3
| numbers = [10, 20, 30, 40]
numbers[1] = 25 # изменяем значение второго элемента
[H2]теперь список выглядит как [10, 25, 30, 40][/H2] |
|
При работе с многомерными списками (списками списков) индексация становится более сложной, но следует тем же принципам. Для доступа к элементам вложенных списков используется последовательность индексов, где каждый следующий индекс указывает на более глубокий уровень вложенности. Это позволяет эффективно работать со сложными структурами данных, такими как матрицы или древовидные структуры:
Python | 1
2
3
4
| matrix = [[1, 2, 3],
[4, 5, 6],
[7, 8, 9]]
element = matrix[1][2] # получаем элемент 6 |
|
Найти индекс элемента равному искомому значению и следующему элементу Дан массив из n элементов. Необходимо определить, есть ли в данном массиве два соседних элемента, равных заданному числу k? Если есть, то вывести... Вывести индекс последнего чётного элемента списка Задан массив целых чисел, размерностью 20. Вывести индекс его последнего парного элемента.
Как реализовать? Спасибо Умножить каждый из элементов списка на его индекс Написать программу, осуществляющую ввод списка с клавиатуры пользователем в одну строку через пробел. Умножить каждый из элементов списка на его... Найти индекс элемента списка сумма которого и k следующих элементов равна заданной Дан массив целых чисел a, a, ..., a и натуральные числа k и m. Укажите минимальное значение i, для которого a + a + ... + a = m (то есть сумма k + 1...
Методы поиска индекса по значению
Поиск индекса элемента в списке является распространенной задачей при программировании на Python, для решения которой существует несколько эффективных подходов. Основными методами поиска индекса по значению являются использование встроенного метода index() и реализация собственного алгоритма поиска с помощью циклов. Каждый из этих методов имеет свои особенности и области применения, которые необходимо учитывать при разработке программ.
Метод index() является встроенным методом списков в Python и представляет собой наиболее прямолинейный способ поиска индекса элемента. Этот метод принимает значение в качестве аргумента и возвращает индекс первого найденного элемента с указанным значением. Синтаксис метода довольно прост и интуитивно понятен:
Python | 1
2
| fruits = ['яблоко', 'банан', 'апельсин', 'груша']
banana_index = fruits.index('банан') # вернет 1 |
|
При использовании метода index() следует учитывать, что он имеет несколько дополнительных параметров, которые могут существенно расширить его функциональность. Метод может принимать необязательные аргументы start и end, которые позволяют ограничить диапазон поиска определенным участком списка. Это особенно полезно при работе с большими списками или когда необходимо найти элемент в определенной части списка:
Python | 1
2
3
| numbers = [1, 2, 3, 2, 4, 2, 5]
second_two = numbers.index(2, 2) # ищем число 2, начиная с индекса 2
[H2]вернет 3, так как это первое вхождение числа 2 после индекса 2[/H2] |
|
Альтернативным подходом к поиску индекса является использование циклов, что предоставляет больше гибкости и контроля над процессом поиска. Цикл for в сочетании с функцией enumerate() позволяет одновременно получать доступ как к элементам списка, так и к их индексам:
Python | 1
2
3
4
5
6
7
8
| def find_index(lst, value):
for index, item in enumerate(lst):
if item == value:
return index
return -1 # возвращаем -1, если элемент не найден
my_list = ['python', 'java', 'javascript', 'ruby']
index = find_index(my_list, 'javascript') # вернет 2 |
|
Использование циклов для поиска индекса может показаться более verbose по сравнению с методом index(), однако этот подход предоставляет возможность реализации более сложной логики поиска. Например, можно добавить дополнительные условия или обработку специальных случаев:
Python | 1
2
3
4
5
6
7
8
9
| def find_index_with_condition(lst, value, condition):
for index, item in enumerate(lst):
if item == value and condition(index):
return index
return -1
[H2]Пример использования с дополнительным условием[/H2]
numbers = [1, 2, 3, 2, 4, 2, 5]
even_index = find_index_with_condition(numbers, 2, lambda x: x % 2 == 0) |
|
Выбор метода поиска индекса зависит от конкретных требований задачи. Встроенный метод index() оптимизирован и удобен для простых случаев, когда необходимо найти первое вхождение элемента. Использование циклов предоставляет больше возможностей для кастомизации процесса поиска, но может требовать больше строк кода и потенциально быть менее производительным в простых сценариях.
Производительность поиска индекса может существенно различаться в зависимости от размера списка и выбранного метода. Встроенный метод index() реализован на низком уровне и оптимизирован для большинства случаев использования. При этом важно понимать, что он выполняет линейный поиск, проходя по элементам списка последовательно, пока не найдет совпадение.
При использовании циклов для поиска индекса можно реализовать дополнительную оптимизацию, если известны особенности данных. Например, если список отсортирован, можно применить бинарный поиск, который работает значительно быстрее на больших наборах данных:
Python | 1
2
3
4
5
6
7
8
9
10
11
12
| def binary_search_index(sorted_list, target):
left, right = 0, len(sorted_list) - 1
while left <= right:
mid = (left + right) // 2
if sorted_list[mid] == target:
return mid
elif sorted_list[mid] < target:
left = mid + 1
else:
right = mid - 1
return -1 |
|
Расширенные возможности поиска индекса могут включать работу с объектами сложных типов. В таких случаях часто требуется искать индекс элемента по определенному атрибуту или комбинации атрибутов. Для этого можно создать специализированную функцию поиска:
Python | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
| class Person:
def __init__(self, name, age):
self.name = name
self.age = age
people = [Person("Анна", 25), Person("Борис", 30), Person("Виктор", 35)]
def find_by_attribute(lst, attr_name, value):
for index, item in enumerate(lst):
if getattr(item, attr_name) == value:
return index
return -1
[H2]Поиск человека по имени[/H2]
boris_index = find_by_attribute(people, "name", "Борис") |
|
Эффективность поиска может быть повышена за счет использования дополнительных структур данных. Например, можно создать словарь, который будет хранить соответствие значений и их индексов, что позволит осуществлять поиск за константное время:
Python | 1
2
3
4
5
6
7
| def create_value_index_map(lst):
return {value: index for index, value in enumerate(lst)}
numbers = [10, 20, 30, 40, 50]
index_map = create_value_index_map(numbers)
[H2]Теперь поиск индекса выполняется мгновенно[/H2]
index = index_map.get(30) # вернет 2 |
|
Такой подход особенно эффективен в случаях, когда необходимо многократно искать индексы элементов в одном и том же списке, и список не подвергается частым изменениям. Однако следует учитывать, что создание дополнительной структуры данных требует дополнительной памяти, что может быть критично при работе с большими наборами данных.
Обработка случаев отсутствия элемента
При работе со списками в Python важно корректно обрабатывать ситуации, когда искомый элемент отсутствует в коллекции. Стандартный метод index() при попытке найти несуществующий элемент генерирует исключение ValueError, что может привести к аварийному завершению программы, если не предусмотреть соответствующую обработку исключений. Правильная обработка таких случаев является важной частью создания надежного программного обеспечения.
Обработка исключений в Python осуществляется с помощью конструкции try-except, которая позволяет перехватывать и обрабатывать ошибки выполнения программы. При поиске индекса элемента рекомендуется всегда оборачивать вызов метода index() в блок try-except:
Python | 1
2
3
4
5
| def safe_get_index(lst, value):
try:
return lst.index(value)
except ValueError:
return None # или другое значение, индицирующее отсутствие элемента |
|
Проверка наличия элемента в списке может быть выполнена несколькими способами. Наиболее простым и читаемым является использование оператора in, который возвращает булево значение, указывающее на присутствие или отсутствие элемента в списке. Этот подход позволяет избежать генерации исключения и сделать код более предсказуемым:
Python | 1
2
3
4
| def find_element_index(lst, value):
if value in lst:
return lst.index(value)
return None |
|
Кастомная обработка ошибок может включать более сложную логику, например, логирование попыток доступа к несуществующим элементам или выполнение альтернативных действий. Такой подход особенно полезен при разработке больших приложений, где важно отслеживать и анализировать ошибки:
Python | 1
2
3
4
5
6
7
8
9
| def advanced_index_search(lst, value, default_action=None):
try:
index = lst.index(value)
return index
except ValueError:
# Здесь может быть логирование или другие действия
if default_action:
return default_action()
return -1 |
|
Эффективная валидация данных перед поиском индекса может значительно улучшить производительность программы. Вместо того чтобы полагаться на обработку исключений, которая может быть ресурсоемкой операцией, можно реализовать предварительные проверки:
Python | 1
2
3
4
5
6
7
8
9
10
11
| def optimized_index_search(lst, value):
if not lst: # проверка на пустой список
return -1
if not isinstance(value, type(lst[0])): # проверка типа искомого значения
return -1
try:
return lst.index(value)
except ValueError:
return -1 |
|
Обработка граничных случаев также должна учитывать особые ситуации, такие как поиск None значений или работа с вложенными структурами данных. В таких случаях может потребоваться дополнительная логика проверки:
Python | 1
2
3
4
5
6
7
8
9
10
11
12
13
| def complex_index_search(lst, value):
if value is None:
# Специальная обработка для None значений
for i, item in enumerate(lst):
if item is None:
return i
return -1
# Обычный поиск для остальных значений
try:
return lst.index(value)
except ValueError:
return -1 |
|
Альтернативные стратегии обработки отсутствующих элементов могут включать использование генераторов или функций-помощников, которые предоставляют более элегантные способы поиска индексов. Например, можно создать функцию, которая будет возвращать все индексы элементов, удовлетворяющих определенному условию:
Python | 1
2
3
4
5
6
| def find_all_indices(lst, condition):
return [i for i, item in enumerate(lst) if condition(item)]
[H2]Использование с lambda-функцией[/H2]
numbers = [1, None, 3, None, 5]
none_indices = find_all_indices(numbers, lambda x: x is None) |
|
Обработка коллекций со сложной структурой требует особого внимания при поиске отсутствующих элементов. Когда список содержит вложенные структуры данных или объекты пользовательских классов, может потребоваться реализация специальной логики сравнения:
Python | 1
2
3
4
5
6
7
8
9
10
11
| class DataItem:
def __init__(self, key, value):
self.key = key
self.value = value
def find_in_complex_list(lst, search_key):
try:
return next(i for i, item in enumerate(lst)
if hasattr(item, 'key') and item.key == search_key)
except StopIteration:
return -1 |
|
Производительность обработки отсутствующих элементов может быть оптимизирована путем использования различных техник кэширования и предварительной обработки данных. Если список редко изменяется, но часто производится поиск, можно создать вспомогательные структуры данных:
Python | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
| class IndexFinder:
def __init__(self, lst):
self.list = lst
self.value_map = {}
self._build_index()
def _build_index(self):
for i, value in enumerate(self.list):
if value not in self.value_map:
self.value_map[value] = []
self.value_map[value].append(i)
def find_index(self, value):
return self.value_map.get(value, [])[0] if value in self.value_map else -1 |
|
Безопасный доступ к элементам списка может быть реализован через создание декораторов, которые автоматически обрабатывают случаи отсутствия элементов:
Python | 1
2
3
4
5
6
7
8
9
10
11
12
13
| def safe_index_access(default_value):
def decorator(func):
def wrapper(*args, **kwargs):
try:
return func(*args, **kwargs)
except (ValueError, IndexError):
return default_value
return wrapper
return decorator
@safe_index_access(default_value=-1)
def get_element_index(lst, value):
return lst.index(value) |
|
Такой подход позволяет централизовать логику обработки ошибок и сделать код более поддерживаемым и читаемым. При этом сохраняется возможность гибкой настройки поведения функции через параметры декоратора.
Поиск индекса для нескольких вхождений элемента
При работе со списками данных часто возникает необходимость найти не только первое, но и все вхождения определенного элемента. Это особенно актуально при анализе данных, обработке текстов или работе с повторяющимися значениями. Стандартный метод index() возвращает только индекс первого найденного элемента, поэтому для поиска всех вхождений требуются дополнительные подходы.
Один из эффективных способов поиска всех индексов - использование генератора списков в сочетании с функцией enumerate. Этот метод позволяет создать список всех индексов за один проход по коллекции:
Python | 1
2
3
4
5
| def find_all_occurrences(lst, value):
return [i for i, x in enumerate(lst) if x == value]
numbers = [1, 2, 3, 2, 4, 2, 5]
indices = find_all_occurrences(numbers, 2) # вернет [1, 3, 5] |
|
Для более сложных случаев, когда требуется дополнительная логика или обработка каждого найденного индекса, можно использовать итеративный подход с накоплением результатов. Такой метод предоставляет больше контроля над процессом поиска и позволяет добавлять дополнительные условия:
Python | 1
2
3
4
5
6
7
8
9
| def find_indices_with_condition(lst, value, condition):
indices = []
for i, item in enumerate(lst):
if item == value and condition(i):
indices.append(i)
return indices
[H2]Пример использования с условием[/H2]
even_indices = find_indices_with_condition(numbers, 2, lambda x: x % 2 == 0) |
|
Оптимизация поиска множественных вхождений может быть достигнута путем использования срезов списка. Этот метод особенно эффективен, когда необходимо найти вхождения в определенном диапазоне индексов:
Python | 1
2
3
4
5
6
7
8
9
10
11
12
13
| def find_in_range(lst, value, start=0, end=None):
indices = []
if end is None:
end = len(lst)
while start < end:
try:
index = lst.index(value, start, end)
indices.append(index)
start = index + 1
except ValueError:
break
return indices |
|
При работе с большими наборами данных может быть полезно использовать словарь для хранения индексов каждого значения. Этот подход требует дополнительной памяти, но обеспечивает быстрый доступ к индексам при повторных запросах:
Python | 1
2
3
4
5
6
7
8
9
10
11
12
| def create_index_map(lst):
index_map = {}
for i, value in enumerate(lst):
if value not in index_map:
index_map[value] = []
index_map[value].append(i)
return index_map
[H2]Использование индексной карты[/H2]
data = [1, 2, 3, 2, 4, 2, 5]
index_map = create_index_map(data)
indices_of_two = index_map.get(2, []) # мгновенный доступ к индексам |
|
Для случаев, когда необходимо найти вхождения элементов, удовлетворяющих определенному условию, можно реализовать более сложную функцию поиска с использованием предикатов:
Python | 1
2
3
4
5
6
| def find_matching_indices(lst, predicate):
return [i for i, x in enumerate(lst) if predicate(x)]
[H2]Пример использования с lambda-функцией[/H2]
numbers = [1, 2, 3, 4, 5, 6]
even_numbers_indices = find_matching_indices(numbers, lambda x: x % 2 == 0) |
|
Эффективная обработка множественных вхождений особенно важна при работе с текстовыми данными или при анализе последовательностей. В таких случаях может потребоваться дополнительная логика для учета перекрывающихся вхождений или специальных условий поиска:
Python | 1
2
3
4
5
6
7
8
9
10
11
12
13
| def find_pattern_indices(sequence, pattern):
indices = []
start = 0
while True:
try:
index = [all(sequence[i+j] == pattern[j]
for j in range(len(pattern)))
for i in range(start, len(sequence)-len(pattern)+1)].index(True)
indices.append(start + index)
start = start + index + 1
except ValueError:
break
return indices |
|
Эффективность разных подходов поиска индекса
При разработке программного обеспечения важно понимать эффективность различных методов поиска индекса, чтобы выбрать оптимальный подход для конкретной задачи. Временная сложность и потребление памяти являются ключевыми факторами, которые следует учитывать при выборе метода поиска индекса в списке.
Встроенный метод index() имеет линейную временную сложность O(n), где n - количество элементов в списке. Это означает, что в худшем случае методу потребуется просмотреть все элементы списка для нахождения нужного значения. Метод особенно эффективен для небольших списков и случаев, когда искомый элемент находится в начале списка:
Python | 1
2
3
| [H2]Линейный поиск с помощью index()[/H2]
numbers = list(range(1000))
index = numbers.index(500) # потребуется проверить 501 элемент |
|
Цикл с enumerate() также имеет линейную сложность O(n), но предоставляет больше гибкости в реализации дополнительной логики. При этом накладные расходы на создание итератора и выполнение python-кода делают этот метод немного медленнее встроенного index():
Python | 1
2
3
4
5
| def manual_search(lst, value):
for i, item in enumerate(lst):
if item == value:
return i
return -1 |
|
Бинарный поиск имеет логарифмическую сложность O(log n) и является наиболее эффективным для отсортированных списков. Однако стоит учитывать, что если список изначально не отсортирован, затраты на сортировку O(n log n) могут превысить выигрыш от использования бинарного поиска:
Python | 1
2
3
4
5
6
7
8
9
10
11
| def binary_search(sorted_list, target):
left, right = 0, len(sorted_list) - 1
while left <= right:
mid = (left + right) // 2
if sorted_list[mid] == target:
return mid
elif sorted_list[mid] < target:
left = mid + 1
else:
right = mid - 1
return -1 |
|
Хеш-таблицы обеспечивают константное время доступа O(1), но требуют дополнительной памяти O(n) для хранения соответствий между значениями и индексами. Этот подход особенно эффективен при многократном поиске индексов в неизменяемом списке:
Python | 1
2
3
4
5
6
| def create_index_map(lst):
return {value: index for index, value in enumerate(lst)}
[H2]Использование хеш-таблицы для быстрого поиска[/H2]
value_to_index = create_index_map([1, 2, 3, 4, 5])
index = value_to_index.get(3) # мгновенный доступ |
|
При работе с большими объемами данных важно учитывать не только теоретическую сложность алгоритмов, но и практические аспекты их реализации. Например, для очень маленьких списков простой линейный поиск может оказаться быстрее, чем создание и использование дополнительных структур данных, даже если теоретическая сложность последних лучше.
Итоги: Как выбрать оптимальный метод поиска индекса
Выбор наиболее подходящего метода поиска индекса в списке должен основываться на нескольких ключевых факторах: размере данных, частоте поиска, требованиях к производительности и особенностях конкретной задачи. Встроенный метод index() является оптимальным выбором для большинства стандартных ситуаций, особенно когда требуется найти первое вхождение элемента в небольшом или среднем по размеру списке.
Для случаев, требующих повышенной производительности при многократном поиске в неизменяемом списке, создание хеш-таблицы с индексами может значительно ускорить операции поиска. Хотя этот подход требует дополнительной памяти, он обеспечивает практически мгновенный доступ к индексам элементов. При работе с отсортированными данными бинарный поиск становится наиболее эффективным решением, особенно для больших объемов данных.
Использование циклов с enumerate() следует рассматривать в ситуациях, когда требуется дополнительная логика обработки элементов или необходимо реализовать специфические условия поиска. Этот метод предоставляет максимальную гибкость и контроль над процессом поиска, хотя может уступать в производительности встроенным методам при простых сценариях использования.
При выборе метода важно также учитывать необходимость обработки отсутствующих элементов и множественных вхождений. В таких случаях может потребоваться комбинирование различных подходов или создание специализированных функций, которые будут наилучшим образом соответствовать требованиям конкретной задачи.
Найдите индекс предпоследнего положительного элемента и выведите его на экран Составьте программу, которая вводит с клавиатуры количество элементов списка с защитой от неправильного ввода, в цикле при помощи случайных чисел... Замена элемента списка по индексу в Python filed_bot =
for i in range(10):
filed_bot.append( * 10)
for row in filed_bot:
print(row)
filed_bot = 4
filed_bot = 4
... Узнать для каждого элемента списка сумму соседей Здравствуйте! Изучаю Python, попалась такая задача:
"Напишите программу, на вход которой подаётся список чисел одной строкой. Программа должна... Как узнать индекс элемента ListBox, зная только его текст И снова всем Добрый день!
Не давно разобрался со сравнением элементов в listbox. Теперь у меня появился другой вопрос.
Мне необходимо получить... Найти индекс элемента массива по его значению Здравствуйте.
For Each de As String In arr
'de - переменная типа String, равна значению массива. А как получить ключ массива arr... Составьте функцию, изменяющую одномерный массив целых чисел следующим обра-зом: к значению каждого положительного элемента прибавляется его индекс Составьте функцию, изменяющую одномерный массив целых чисел следующим обра-зом: к значению каждого положительного элемента прибавляется его индекс.... Как получить индекс массива по его присвоенному значению? Дано:
dateId = 1;
dateId = 16;
dateId = 5;
или dateId
Как получить x. где dateId равна 5? Как узнать индекс элемента массива? Доброго времени суток
Подскажите пожалуйста как узнать индекс элемента массива? Как узнать индекс элемента ListView Имеется контрол ListView, содержащий одну колонку - имя кассира. Заполняю ListView при помощи коллекции, содержащей 2 параметра: Name и Id.
... Как узнать индекс у элемента массива? Доброго времени суток. У меня есть массив GameObject`ов public GameObject spawnCells, в которых у меня находятся 25 клеток игрового поля. Я могу... Как узнать индекс элемента ListBox Вопрос конечно глупый, но все же, как в CLR приложении узнать индекс элемента ListBox'a? Как узнать индекс элемента в WrapPanel? Всем привет, недавно сел писать приложение на WPF и возникла проблема. У меня в приложении элементы WrapPanel являются кнопками со своим Content...
|