Как изменить элемент списка питон

Существует три способа заменить элемент в списке на Python. Для этого можно использовать обращение к элементу по индексу или перебор всего списка в цикле for. Если вы хотите создать новый список на основе существующего и внести в него изменения, вы также можете использовать list comprehension (генератор списка).

В повседневной практике необходимость изменить одно или несколько значений в списке возникает довольно часто. Предположим, вы создаете меню для ресторана и замечаете, что неправильно определили один из пунктов. Чтобы исправить подобную ошибку, вам нужно просто заменить существующий элемент в списке.

Вы можете заменить элемент в списке на Python, используя цикл for, обращение по индексу или list comprehension. Первые два метода изменяют существующий список, а последний создает новый с заданными изменениями.

Давайте кратко опишем каждый метод:

• Обращение по индексу: мы используем порядковый номер элемента списка для изменения его значения. Знак равенства используется для присвоения нового значения выбранному элементу.
• List comprehension или генератор списка создает новый список из существующего. Синтаксис list comprehension позволяет добавлять различные условия для определения значений в новом списке.
• Цикл For выполняет итерацию по элементам списка. Для внесения изменений в данном случае используется обращение по индексу. Мы применяем метод enumerate() для создания двух списков: с индексами и с соответствующими значениями элементов — и итерируем по ним.

В этом руководстве мы рассмотрим каждый из этих методов. Для более полного понимания приведенных подходов мы также подготовили примеры использования каждого из них.

Замена элемента в списке на Python: обращение по индексу

Самый простой способ заменить элемент в списке — это использовать синтаксис обращения к элементам по индексу. Такой способ позволяет выбрать один элемент или диапазон последовательных элементов, а с помощью оператора присваивания вы можете изменить значение в заданной позиции списка.

Представим, что мы создаем программу, которая хранит информацию о ценах в магазине одежды. Цена первого товара в нашем списке должна быть увеличена на $2.

Начнем с создания списка, который содержит цены на наши товары:

prices = [29.30, 10.20, 44.00, 5.99, 81.90]

Мы используем обращение по индексу для выбора и изменения первого элемента в нашем списке 29.30. Данное значение имеет нулевой индекс. Это связано с тем, что списки индексируются, начиная с нуля.

prices[0] = 31.30
print(prices)

Наш код выбирает элемент в нулевой позиции и устанавливает его значение равным 31.30, что на $2 больше прежней цены. Далее мы возвращаем список со скорректированной ценой первого товара:

[31.30, 10.20, 44.00, 5.99, 81.90]

Мы также можем изменить наш список, добавив два к текущему значению prices[0]:

prices[0] = prices[0] + 2
print(prices)

prices[0] соответствует первому элементу в нашем списке (тот, который находится в позиции с нулевым индексом).

Этот код выводит список с теми же значениями, что и в первом случае:

[31.30, 10.20, 44.00, 5.99, 81.90]

Замена элемента в списке на Python: list comprehension

Применение генератора списка в Python может быть наиболее изящным способом поиска и замены элемента в списке. Этот метод особенно полезен, если вы хотите создать новый список на основе значений существующего.

Использование list comprehension позволяет перебирать элементы существующего списка и образовывать из них новый список на основе определенного критерия. Например, из последовательности слов можно скомпоновать новую, выбрав только те, которые начинаются на «C».

Здесь мы написали программу, которая рассчитывает 30% скидку на все товары в магазине одежды, стоимость которых превышает $40. Мы используем представленный ранее список цен на товары:

prices = [29.30, 10.20, 44.00, 5.99, 81.90]

Далее мы применяем list comprehension для замены элементов в нашем списке:

sale_prices = [round(price - (price * 30 / 100), 2) if price > 40 else price for price in prices]
print(sale_prices)

Таким образом, наш генератор проходит по списку «prices» и ищет значения стоимостью более 40 долларов. К найденным товарам применяется скидка в 30%. Мы округляем полученные значения цен со скидкой до двух десятичных знаков после точки с помощью метода round().

Наш код выводит следующий список с новыми ценами:

[29.3, 10.2, 30.8, 5.99, 57.33]

Замена элемента в списке на Python: цикл for

Вы можете изменить элементы списка с помощью цикла for. Для этого нам понадобится функция Python enumerate(). Эта функция возвращает два списка: список с номерами индексов и список со значениями соответствующих элементов. Мы можем выполнить необходимые итерации по этим двум последовательностям с помощью единственного цикла for.

В этом примере мы будем использовать тот же список цен:

prices = [29.30, 10.20, 44.00, 5.99, 81.90]

Затем мы определим цикл for, который проходит по данному списку с помощью функции enumerate():

for index, item in enumerate(prices):
	if item > 40:
		prices[index] = round(prices[index] - (prices[index] * 30 / 100), 2)

print(prices)

В коде выше переменная «index» содержит позиционный номер элемента. В свою очередь «item» — это значение, хранящееся в элементе списка на данной позиции. Индекс и соответствующее значение, возвращаемые методом enumerate(), разделяются запятой.

Подобное получение двух или более значений из возвращаемого функцией кортежа называется распаковкой. Мы «распаковали» элементы двух списков из метода enumerate().

Здесь мы используем ту же формулу, что и ранее, для расчета 30% скидки на товары стоимостью более 40 долларов. Давайте запустим наш код и посмотрим, что получится:

[29.3, 10.2, 30.8, 5.99, 57.33]

Наш код успешно изменяет товары в списке «prices» в соответствии с нашей скидкой.

Заключение

Вы можете заменить элементы в списке на Python с помощью обращения по индексу, list comprehension или цикла for.

Если вы хотите изменить одно значение в списке, то наиболее подходящим будет обращение по индексу. Для замены нескольких элементов в списке, удовлетворяющих определенному условию, хорошим решением будет использование list comprehension. Хотя циклы for более функциональны, они менее элегантны, чем генераторы списков.

In this article, we are going to see how to replace the value in a List using Python. We can replace values in the list in serval ways. Below are the methods to replace values in the list.

• Using list indexing
• Using for loop
• Using while loop
• Using lambda function
• Using list slicing

Method 1: Using List Indexing

We can access items of the list using indexing. This is the simplest and easiest method to replace values in a list in python. If we want to replace the first item of the list we can di using index 0. Here below, the index is an index of the item that we want to replace and the new_value is a value that should replace the old value in the list.

Syntax:  l[index]=new_value

Code:

Output:

['Shardul', 'Rohit', 'Rahul', 'Virat', 'Pant']

Method 2: Using For Loop

We can use for loop to iterate over the list and replace values in the list. Suppose we want to replace ‘Hardik’ and ‘Pant’ from the list with ‘Shardul’ and ‘Ishan’. We first find values in the list using for loop and if condition and then replace it with the new value. 

Output:

['Shardul', 'Rohit', 'Rahul', 'Virat', 'Ishan']

Method 3: Using While Loop

We can also use a while loop to replace values in the list. While loop does the same work as for loop. In the while loop first, we define a variable with value 0 and iterate over the list. If value matches to value that we want to replace then we replace it with the new value.

Output:

['Shardul', 'Rohit', 'Rahul', 'Virat', 'Ishan']

Method 4: Using Lambda Function

In this method, we use lambda and map function to replace the value in the list. map() is a built-in function in python to iterate over a list without using any loop statement. A lambda is an anonymous function in python that contains a single line expression. Here we gave one expression as a condition to replace value. Here we replace ‘Pant’ with ‘Ishan’ in the lambda function. Then using the list() function we convert the map object into the list.

Syntax: l=list(map(lambda x: x.replace(‘old_value’,’new_value’),l))

Output:

['Hardik', 'Rohit', 'Rahul', 'Virat', 'Ishan']

Method 5: Using List Slicing

Python allows us to do slicing inside a list. Slicing enables us to access some parts of the list. We can replace values inside the list using slicing. First, we find the index of variable that we want to replace and store it in variable ‘i’. Then, we replace that item with a new value using list slicing. Suppose we want to replace ‘Rahul’ with ‘Shikhar’ than we first find the index of ‘Rahul’ and then do list slicing and remove ‘Rahul’ and add ‘Shikhar’ in that place.

Syntax: l=l[:index]+[‘new_value’]+l[index+1:]

Output:

['Hardik', 'Rohit', 'Shikhar', 'Virat', 'Pant']

In this article, we are going to see how to replace the value in a List using Python. We can replace values in the list in serval ways. Below are the methods to replace values in the list.

• Using list indexing
• Using for loop
• Using while loop
• Using lambda function
• Using list slicing

Method 1: Using List Indexing

We can access items of the list using indexing. This is the simplest and easiest method to replace values in a list in python. If we want to replace the first item of the list we can di using index 0. Here below, the index is an index of the item that we want to replace and the new_value is a value that should replace the old value in the list.

Syntax:  l[index]=new_value

Code:

Output:

['Shardul', 'Rohit', 'Rahul', 'Virat', 'Pant']

Method 2: Using For Loop

We can use for loop to iterate over the list and replace values in the list. Suppose we want to replace ‘Hardik’ and ‘Pant’ from the list with ‘Shardul’ and ‘Ishan’. We first find values in the list using for loop and if condition and then replace it with the new value. 

Output:

['Shardul', 'Rohit', 'Rahul', 'Virat', 'Ishan']

Method 3: Using While Loop

We can also use a while loop to replace values in the list. While loop does the same work as for loop. In the while loop first, we define a variable with value 0 and iterate over the list. If value matches to value that we want to replace then we replace it with the new value.

Output:

['Shardul', 'Rohit', 'Rahul', 'Virat', 'Ishan']

Method 4: Using Lambda Function

In this method, we use lambda and map function to replace the value in the list. map() is a built-in function in python to iterate over a list without using any loop statement. A lambda is an anonymous function in python that contains a single line expression. Here we gave one expression as a condition to replace value. Here we replace ‘Pant’ with ‘Ishan’ in the lambda function. Then using the list() function we convert the map object into the list.

Syntax: l=list(map(lambda x: x.replace(‘old_value’,’new_value’),l))

Output:

['Hardik', 'Rohit', 'Rahul', 'Virat', 'Ishan']

Method 5: Using List Slicing

Python allows us to do slicing inside a list. Slicing enables us to access some parts of the list. We can replace values inside the list using slicing. First, we find the index of variable that we want to replace and store it in variable ‘i’. Then, we replace that item with a new value using list slicing. Suppose we want to replace ‘Rahul’ with ‘Shikhar’ than we first find the index of ‘Rahul’ and then do list slicing and remove ‘Rahul’ and add ‘Shikhar’ in that place.

Syntax: l=l[:index]+[‘new_value’]+l[index+1:]

Output:

['Hardik', 'Rohit', 'Shikhar', 'Virat', 'Pant']

The answers for this old but relevant question are wildly variable in speed.

The fastest of the solution posted by kxr.

However, this is even faster and otherwise not here:

def f1(arr, find, replace):
    # fast and readable
    base=0
    for cnt in range(arr.count(find)):
        offset=arr.index(find, base)
        arr[offset]=replace
        base=offset+1

Here is timing for the various solutions. The faster ones are 3X faster than accepted answer and 5X faster than the slowest answer here.

To be fair, all methods needed to do inlace replacement of the array sent to the function.

Please see timing code below:

def f1(arr, find, replace):
    # fast and readable
    base=0
    for cnt in range(arr.count(find)):
        offset=arr.index(find, base)
        arr[offset]=replace
        base=offset+1
        
def f2(arr,find,replace):
    # accepted answer
    for i,e in enumerate(arr):
        if e==find: 
            arr[i]=replace
        
def f3(arr,find,replace):
    # in place list comprehension
    arr[:]=[replace if e==find else e for e in arr]
    
def f4(arr,find,replace):
    # in place map and lambda -- SLOW
    arr[:]=list(map(lambda x: x if x != find else replace, arr))
    
def f5(arr,find,replace):
    # find index with comprehension
    for i in [i for i, e in enumerate(arr) if e==find]:
        arr[i]=replace
        
def f6(arr,find,replace):
    # FASTEST but a little les clear
    try:
        while True:
            arr[arr.index(find)]=replace
    except ValueError:
        pass    

def f7(lst, old, new):
    """replace list elements (inplace)"""
    i = -1
    try:
        while 1:
            i = lst.index(old, i + 1)
            lst[i] = new
    except ValueError:
        pass
    
    
import time     

def cmpthese(funcs, args=(), cnt=1000, rate=True, micro=True):
    """Generate a Perl style function benchmark"""                   
    def pprint_table(table):
        """Perl style table output"""
        def format_field(field, fmt='{:,.0f}'):
            if type(field) is str: return field
            if type(field) is tuple: return field[1].format(field[0])
            return fmt.format(field)     

        def get_max_col_w(table, index):
            return max([len(format_field(row[index])) for row in table])         

        col_paddings=[get_max_col_w(table, i) for i in range(len(table[0]))]
        for i,row in enumerate(table):
            # left col
            row_tab=[row[0].ljust(col_paddings[0])]
            # rest of the cols
            row_tab+=[format_field(row[j]).rjust(col_paddings[j]) for j in range(1,len(row))]
            print(' '.join(row_tab))                

    results={}
    for i in range(cnt):
        for f in funcs:
            start=time.perf_counter_ns()
            f(*args)
            stop=time.perf_counter_ns()
            results.setdefault(f.__name__, []).append(stop-start)
    results={k:float(sum(v))/len(v) for k,v in results.items()}     
    fastest=sorted(results,key=results.get, reverse=True)
    table=[['']]
    if rate: table[0].append('rate/sec')
    if micro: table[0].append('u03bcsec/pass')
    table[0].extend(fastest)
    for e in fastest:
        tmp=[e]
        if rate:
            tmp.append('{:,}'.format(int(round(float(cnt)*1000000.0/results[e]))))

        if micro:
            tmp.append('{:,.1f}'.format(results[e]/float(cnt)))

        for x in fastest:
            if x==e: tmp.append('--')
            else: tmp.append('{:.1%}'.format((results[x]-results[e])/results[e]))
        table.append(tmp) 

    pprint_table(table)                    



if __name__=='__main__':
    import sys
    import time 
    print(sys.version)
    cases=(
        ('small, found', 9, 100),
        ('small, not found', 99, 100),
        ('large, found', 9, 1000),
        ('large, not found', 99, 1000)
    )
    for txt, tgt, mul in cases:
        print(f'n{txt}:')
        arr=[1,2,3,4,5,6,7,8,9,0]*mul 
        args=(arr,tgt,'X')
        cmpthese([f1,f2,f3, f4, f5, f6, f7],args)   

And the results:

3.9.1 (default, Feb  3 2021, 07:38:02) 
[Clang 12.0.0 (clang-1200.0.32.29)]

small, found:
   rate/sec μsec/pass     f4     f3     f5     f2     f6     f7     f1
f4  133,982       7.5     -- -38.8% -49.0% -52.5% -78.5% -78.6% -82.9%
f3  219,090       4.6  63.5%     -- -16.6% -22.4% -64.8% -65.0% -72.0%
f5  262,801       3.8  96.1%  20.0%     --  -6.9% -57.8% -58.0% -66.4%
f2  282,259       3.5 110.7%  28.8%   7.4%     -- -54.6% -54.9% -63.9%
f6  622,122       1.6 364.3% 184.0% 136.7% 120.4%     --  -0.7% -20.5%
f7  626,367       1.6 367.5% 185.9% 138.3% 121.9%   0.7%     -- -19.9%
f1  782,307       1.3 483.9% 257.1% 197.7% 177.2%  25.7%  24.9%     --

small, not found:
   rate/sec μsec/pass     f4     f5     f2     f3     f6     f7     f1
f4   13,846      72.2     -- -40.3% -41.4% -47.8% -85.2% -85.4% -86.2%
f5   23,186      43.1  67.5%     --  -1.9% -12.5% -75.2% -75.5% -76.9%
f2   23,646      42.3  70.8%   2.0%     -- -10.8% -74.8% -75.0% -76.4%
f3   26,512      37.7  91.5%  14.3%  12.1%     -- -71.7% -72.0% -73.5%
f6   93,656      10.7 576.4% 303.9% 296.1% 253.3%     --  -1.0%  -6.5%
f7   94,594      10.6 583.2% 308.0% 300.0% 256.8%   1.0%     --  -5.6%
f1  100,206      10.0 623.7% 332.2% 323.8% 278.0%   7.0%   5.9%     --

large, found:
   rate/sec μsec/pass     f4     f2     f5     f3     f6     f7     f1
f4      145   6,889.4     -- -33.3% -34.8% -48.6% -85.3% -85.4% -85.8%
f2      218   4,593.5  50.0%     --  -2.2% -22.8% -78.0% -78.1% -78.6%
f5      223   4,492.4  53.4%   2.3%     -- -21.1% -77.5% -77.6% -78.2%
f3      282   3,544.0  94.4%  29.6%  26.8%     -- -71.5% -71.6% -72.3%
f6      991   1,009.5 582.4% 355.0% 345.0% 251.1%     --  -0.4%  -2.8%
f7      995   1,005.4 585.2% 356.9% 346.8% 252.5%   0.4%     --  -2.4%
f1    1,019     981.3 602.1% 368.1% 357.8% 261.2%   2.9%   2.5%     --

large, not found:
   rate/sec μsec/pass     f4     f5     f2     f3     f6     f7     f1
f4      147   6,812.0     -- -35.0% -36.4% -48.9% -85.7% -85.8% -86.1%
f5      226   4,424.8  54.0%     --  -2.0% -21.3% -78.0% -78.1% -78.6%
f2      231   4,334.9  57.1%   2.1%     -- -19.6% -77.6% -77.7% -78.2%
f3      287   3,484.0  95.5%  27.0%  24.4%     -- -72.1% -72.2% -72.8%
f6    1,028     972.3 600.6% 355.1% 345.8% 258.3%     --  -0.4%  -2.7%
f7    1,033     968.2 603.6% 357.0% 347.7% 259.8%   0.4%     --  -2.3%
f1    1,057     946.2 619.9% 367.6% 358.1% 268.2%   2.8%   2.3%     --

In this tutorial, you’ll learn how to use Python to replace an item or items in a list. You’l learn how to replace an item at a particular index, how to replace a particular value, how to replace multiple values, and how to replace multiple values with multiple values.

Being able to work with lists is an important skill for any Python developer, given how prevalent and understandable these Python data structures are.

By the end of this tutorial, you’ll have learned:

• How to use list assignment to replace an item in a Python list
• How to use for loops and while loops to replace an item in a Python list
• How to replace multiple items in a list

Replace an Item in a Python List at a Particular Index

Python lists are ordered, meaning that we can access (and modify) items when we know their index position. Python list indices start at 0 and go all the way to the length of the list minus 1.

You can also access items from their negative index. The negative index begins at -1 for the last item and goes from there. To learn more about Python list indexing, check out my in-depth overview here.

If we want to replace a list item at a particular index, we can simply directly assign new values to those indices.

Let’s take a look at what that looks like:

# Replace an item at a particular index in a Python list
a_list = [1, 2, 3, 4, 5, 6, 7, 8, 9]

# Mofidy first item
a_list[0] = 10
print(a_list)
# Returns: [10, 2, 3, 4, 5, 6, 7, 8, 9]

# Modify last item
a_list[-1] = 99
print(a_list)
# Returns: [10, 2, 3, 4, 5, 6, 7, 8, 99]

In the next section, you’ll learn how to replace a particular value in a Python list using a for loop.

Want to learn how to use the Python zip() function to iterate over two lists? This tutorial teaches you exactly what the zip() function does and shows you some creative ways to use the function.

Replace a Particular Value in a List in Python Using a For Loop

Python lists allow us to easily also modify particular values. One way that we can do this is by using a for loop.

One of the key attributes of Python lists is that they can contain duplicate values. Because of this, we can loop over each item in the list and check its value. If the value is one we want to replace, then we replace it.

Let’s see what this looks like. In our list, the word apple is misspelled. We want to replace the misspelled version with the corrected version.

# Replace a particular item in a Python list
a_list = ['aple', 'orange', 'aple', 'banana', 'grape', 'aple']

for i in range(len(a_list)):
    if a_list[i] == 'aple':
        a_list[i] = 'apple'

print(a_list)

# Returns: ['apple', 'orange', 'apple', 'banana', 'grape', 'apple']

Let’s take a look at what we’ve done here:

1. We loop over each index in the list
2. If the index position of the list is equal to the item we want to replace, we re-assign its value

In the next section, you’ll learn how to turn this for loop into a Python list comprehension.

Want to learn more about Python for-loops? Check out my in-depth tutorial that takes your from beginner to advanced for-loops user! Want to watch a video instead? Check out my YouTube tutorial here.

Replace a Particular Value in a List in Python Using a List Comprehension

One of the key attributes of Python list comprehensions is that we can often turn for loops into much shorter comprehensions. Let’s see how we can use a list comprehension in Python to replace an item in a list.

We’ll use the same example we used in the for loop, to help demonstrate how elegant a Python list comprehension can be:

# Replace a particular item in a Python list using a list comprehension
a_list = ['aple', 'orange', 'aple', 'banana', 'grape', 'aple']

a_list = ['apple' if item == 'aple' else item for item in a_list]
print(a_list)

# Returns: ['apple', 'orange', 'apple', 'banana', 'grape', 'apple']

We can see here that there are two main benefits of list comprehensions compared to for loops:

1. We don’t need to initialize an empty list
2. The comprehension reads in a relatively plain English

In the next section, you’ll learn how to change all values in a list using a formula.

Want to learn more about Python list comprehensions? Check out this in-depth tutorial that covers off everything you need to know, with hands-on examples. More of a visual learner, check out my YouTube tutorial here.

Change All Values in a List in Python Using a Function

Neither of the approaches above are immediately clear as to what they are doing. Because of this, developing a formula to do this is a helpful approach to help readers of your code understand what it is you’re doing.

Let’s take a look at how we can use the list comprehension approach and turn it into a formula:

# Replace a particular item in a Python list using a function
a_list = ['aple', 'orange', 'aple', 'banana', 'grape', 'aple']

def replace_values(list_to_replace, item_to_replace, item_to_replace_with):
    return [item_to_replace_with if item == item_to_replace else item for item in list_to_replace]

replaced_list = replace_values(a_list, 'aple', 'apple')
print(replaced_list)

# Returns: ['apple', 'orange', 'apple', 'banana', 'grape', 'apple']

Here, we simply need to pass in the list, the item we want to replace, and the item we want to replace it with. The function name makes it easy to understand what we’re doing, guiding our readers to better understand our actions.

In the next section, you’ll learn how to replace multiple values in a Python list.

Replace Multiple Values in a Python List

There may be many times when you want to replace not just a single item, but multiple items. This can be done quite simply using the for loop method shown earlier.

Let’s take a look at an example where we want to replace all known typos in a list with the word typo.

# Replace multiple items in a Python list with the same value
a_list = ['aple', 'ornge', 'aple', 'banana', 'grape', 'aple']
for i in range(len(a_list)):
    if a_list[i] in ['aple', 'ornge']:
        a_list[i] = 'typo'

print(a_list)
# Returns: ['typo', 'typo', 'typo', 'banana', 'grape', 'typo']

Similar to the for loop method shown earlier, we check whether or not an item is a typo or not and replace its value.

In the next section, you’ll learn how to replace multiple values in a Python list with different values.

Replace Multiple Values with Multiple Values in a Python List

The approach above is helpful if we want to replace multiple values with the same value. There may be times where you want to replace multiple values with different values.

Looking again at our example, we may want to replace all instances of our typos with their corrected spelling. We can again use a for loop to illustrate how to do this.

Instead of using a single if statement, we’ll nest in some elif statements that check for a value’s value before replacing.

# Replace multiple items in a Python list with the different values
a_list = ['aple', 'ornge', 'aple', 'banana', 'grape', 'aple']
for i in range(len(a_list)):
    if a_list[i] == 'aple':
        a_list[i] = 'apple'
    elif a_list[i] == 'ornge':
        a_list[i] = 'orange'

print(a_list)
# Returns: ['apple', 'orange', 'apple', 'banana', 'grape', 'apple']

Need to check if a key exists in a Python dictionary? Check out this tutorial, which teaches you five different ways of seeing if a key exists in a Python dictionary, including how to return a default value.

Conclusion

In this tutorial, you learned how to use Python to replace items in a list. You learned how to use Python to replace an item at a particular index, how to replace a particular value, how to modify all values in a list, and how to replace multiple values in a list.

To learn more about Python list indexing, check out the official documentation here.

Additional Resources

To learn more about related topics, check out the tutorials below:

• Pandas Replace: Replace Values in Pandas Dataframe
• Python: Select Random Element from a List
• Python: Combine Lists – Merge Lists (8 Ways)
• Python: Count Number of Occurrences in List (6 Ways)

Синтаксис:

Параметры:

• sequence — изменяемая последовательность, list или bytearray,
• x — произвольный объект, удовлетворяющий любым ограничениям типа и значения, наложенным sequence.
• i — целое число, индекс элемента

Результат:

• новое значение элемента

Описание:

В результате элемент с индексом i из последовательности sequence получит новое значение (заменится) на объект x.

Если индекс i отрицателен, то индекс будет считаться относительно конца последовательности sequence. В этом случае положительный индекс можно посчитать по формуле len(sequence) - i.

Обратите внимание, что -0 по-прежнему будет 0.

При попытке заменить значение элемента с индексом, превышающим длину последовательности len(sequence) поднимается исключение IndexError.

Примеры изменения элемента списка по индексу.

>>> x = [2, 5, 8, 11, 14, 17]
>>> x[1] = 150
>>> x
# [2, 150, 8, 11, 14, 17]
>>> x[-1] = 100
>>> x
# [2, 150, 8, 11, 14, 100]

x = ['el_1', 'el_2', 'el_3']
>>> x[2] = 'lorem'
>>> x
# ['el_1', 'el_2', 'lorem']

# замена элемента неизменяемой 
# последовательности невозможна
>>> x[3] = 'foo'
# Traceback (most recent call last):
#   File "<stdin>", line 1, in <module>
# IndexError: list assignment index out of range

Замена элементов в списке по условию.

Например, имеем числовой список, в котором присутствуют как целые, так и вещественные числа. Необходимо получить тот же список, в котором вещественные числа округлены до целых.

В данном случае можно поступить 2-мя способами: первый — это создать новый пустой список и в цикле for/in добавлять в него значения, округляя все элементы до целого, из первого списка. Недостаток такого способа: если список огромный то столкнемся с не экономным расходом памяти.

Второй подход — это при каждой итерации по списку, проверять тип числа и если это вещественное число то округлять его до целого и на лету изменять значение в списке по его индексу. Недостаток: скорость обработки списка незначительно уменьшиться.

И так, смотрим:

# имеем числовой список
lst = [1, 5.5, 3, 8.2, 11.1, 10, 4, 5.6, 9]
# используем функцию `enumerate()`
# для определения индекса элемента
# при каждой итерации
for n, i in enumerate(lst, 0):
    # проверяем тип числа
    if type(i) == float:
        # если float, то округляем
        i = round(i)
        # изменяем элемент по индексу
        lst[n] = i

>>> lst
# [1, 6, 3, 8, 11, 10, 4, 6, 9]

Замена элементов вложенных списков.

>>> x = [[2, 150], [11, 14, 17]]
>>> x[0] = [0, 0] 
>>> x
# [[0, 0], [11, 14, 17]]

>>> x[1][1] = 1000
>>> x
# [[0, 0], [11, 1000, 17]]

>>> x[0][1] = 'foo'
>>> x
# [[0, 'foo'], [11, 1000, 17]]

>>> x[1] = 'replace'
>>> x
# [[0, 'foo'], 'replace']

Lists in python are data structures used to store items of multiple types together under the same list. Using a list, we can store several data types such as string values, integer, float, sets, nested lists, etc. The items are stored inside square brackets ‘[ ]’. They are mutable data types, i.e., they can be changed even after they have been created. We can access list elements using indexing. In this article, we shall look into 7 efficient ways to replace items in a python list.

Lists are compelling and versatile data structures. As mentioned above, lists are mutable data types. Even after a list has been created, we can make changes in the list items. This property of lists makes them very easy to work with. Here, we shall be looking into 7 different ways in order to replace item in a list in python.

1. Using list indexing
2. Looping using for loop
3. Using list comprehension
4. With map and lambda function
5. Executing a while loop
6. Using list slicing
7. Replacing list item using numpy

1. Using list indexing

The list elements can be easily accessed with the help of indexing. This is the most basic and the easiest method of accessing list elements. Since all the elements inside a list are stored in an ordered fashion, we can sequentially retrieve its elements. The first element is stored at index 0, and the last element is stored at index ‘len(list)-1’.

Let us take a list named ‘my_list’, which stores names of colors. Now, if we want to replace the first item inside the list from ‘Red’ to ‘Black’, we can do that using indexing. We assign the element stored at the 0th index to a new value. Then the list printed would contain the replaced item.

my_list = ['Red', 'Blue', 'Orange', 'Gray', 'White']
my_list[0] = 'Black'
print(my_list)

Output:

['Black', 'Blue', 'Orange', 'Gray', 'White']

2. Looping using for loop

We can also execute a for loop to iterate over the list items. When a certain condition is fulfilled inside the for loop, we will then replace that list item using indexing.

We shall take the same ‘my_list’ as in the above example. Then, we shall run the for loop for the length of the list ‘my_list’. Inside the loop, we have placed the condition that when the list element equals ‘Orange’, we will replace the item at that index with ‘Black’. Then after the for loop ends, we shall print that list.

my_list = ['Red', 'Blue', 'Orange', 'Gray', 'White']
for i in range(len(my_list)):
  if my_list[i] == 'Orange':
    my_list[i] = 'Black'
print(my_list)

The output prints the list with the replaced value.

['Red', 'Blue', 'Black', 'Gray', 'White']

3. Using list comprehension

List Comprehension in python is a compact piece of code. Using list comprehension, we can generate new sequences from already existing sequences. Instead of writing an entire block of code for executing a for loop or an if-else loop, we can write a single line code for the same.

The syntax for list comprehension is:

[expression for item in list]

It consists of the expression which has to be printed into the new list, the loop statement, and the original list from which the new values will be obtained.

We shall use list comprehension to append the string ‘ color’ to all the list elements of my_list. We shall replace the old values with the updated values.

my_list = ['Red', 'Blue', 'Orange', 'Gray', 'White']
my_list = [(item+' color') for item in my_list ]
print(my_list)

The list with replaced values is:

['Red color', 'Blue color', 'Orange color', 'Gray color', 'White color']

4. With map and lambda function

Map() is a built-in function in python using which we can iterate over an iterable sequence without having to write a loop statement.

The syntax of the map is:

map(function, iterable)

Here, every value inside the iterable will be passed into a function, and the map() function will output the inside function’s return value. Inside the map() function, we have taken a lambda function as the first argument.

A lambda function is an anonymous function containing a single line expression. It can have any number of arguments, but only one expression can be evaluated. Here, the lambda function will append the string ‘ color’ for all the items present in the list and return the new value. Then using the list() function, we shall convert the map object returned by the map() function into a list.

my_list = ['Red', 'Blue', 'Orange', 'Gray', 'White']
my_list = list(map(lambda item: (item +' color'), my_list))
print(my_list)

The output is:

['Red color', 'Blue color', 'Orange color', 'Gray color', 'White color']

If we want to replace a particular item in the list, then the code for that will be:

my_list = ['Red', 'Blue', 'Orange', 'Gray', 'White']
my_list = list(map(lambda item: item.replace("Orange","Black"), my_list))
print(my_list)

We have used the replace() method to replace the value ‘Orange’ from my_list to ‘Black.’ The output is:

['Red', 'Blue', 'Black', 'Gray', 'White']

5. Executing a while loop

We can also have a while loop in order to replace item in a list in python. We shall take a variable ‘i’ which will be initially set to zero. The while loop shall execute while the value of ‘i’ is less than the length of the list my_list. We shall use the replace() method to replace the list item ‘Gray’ with ‘Green.’ The variable ‘i’ shall be incremented at the end of the loop.

my_list = ['Red', 'Blue', 'Orange', 'Gray', 'White']
i = 0
while i < len(my_list):
  my_list[i] = my_list[i].replace('Gray','Green')
  i = i + 1
print(my_list)

The updated list is:

['Red', 'Blue', 'Orange', 'Green', 'White']

6. Using list slicing

We can also perform slicing inside a list. Using slicing enables us to access only a certain part of a list.

The syntax of the list is:

List[ Start : End : Jump ]

Using list slicing, we can replace a given item inside a list. First, we shall store the index of the item to be replaced into a variable named ‘index.’ Then, using list slicing, we will replace that item with a new value, ‘Green.’

my_list = ['Red', 'Blue', 'Orange', 'Gray', 'White']
index = my_list.index('Gray')
my_list = my_list[:index] + ['Green'] + my_list[index+1:]
print(my_list)

The output is:

['Red', 'Blue', 'Orange', 'Green', 'White']

Also, Read | Python Trim Using strip(), rstrip() and lstrip()

7. Replacing list item using numpy

We can also replace a list item using python’s numpy library. First, we will convert the list into a numpy array. Then using numpy’s where() function, we specify a condition according to which we will replace the value. We shall replace the value ‘Gray’ with ‘Green.’ Else, the value will be the same.

import numpy as np
my_list = ['Red', 'Blue', 'Orange', 'Gray', 'White']
my_list = np.array(my_list)
my_list = np.where(my_list == 'Gray', 'Green', my_list)
print(my_list)

The output is:

['Red' 'Blue' 'Orange' 'Green' 'White']

This sums up five different ways of replacing an item in a list. If you have any questions in your mind, then let us know in the comments below.

Until next time, Keep Learning!

Содержание:развернуть

• Что такое список

• Как списки хранятся в памяти?

• Базовая работа со списками

• Объявление списка

• Обращение к элементу списка в Python

• Добавление в список

• Добавление в список на указанную позицию

• Изменение элементов списка

• Удаление элемента из списка

• Как проверить наличие элемента в списке

• Объединение списков

• Копирование списка Python

• Цикл по списку

• Методы списков
• Вложенные списки
• Срезы
• Генераторы списков
• Best Practices

• Как получить список в обратном порядке

• Как перевести список в другой формат?

• Как узнать индекс элемента в списке?

• Как посчитать количество уникальных элементов в списке?

• Как проверить список на пустоту?

• Как создать список числовых элементов с шагом

Создание списка в Python может понадобиться для хранения в них коллекции объектов. Списки могут хранить объекты всех типов в одном, в отличие от массива в другом языке программирования. Также размер списка доступен к изменению.

Ниже разберёмся, как устроены списки, как с ними работать и приведём 6 примеров из практики.

Что такое список

Список (list) — тип данных, предназначенный для хранения набора или последовательности разных элементов.

[1, 33, 6, 9] # литерал списка в Python

Его можно сравнить со списком покупок для магазина: точно так же вносятся элементы, их тоже можно добавлять и корректировать.

Как списки хранятся в памяти?

Базовая C-структура списков в Python (CPython) выглядит следующим образом:

typedef struct {
PyObject_VAR_HEAD
PyObject **ob_item;
Py_ssize_t allocated;
} PyListObject;

Когда мы создаём список, в памяти под него резервируется объект, состоящий из 3-х частей:

• PyObject_VAR_HEAD — заголовок;
• ob_item — массив указателей на элементы списка;
• allocated — количество выделенной памяти под элементы списка.

Объект списка хранит указатели на объекты, а не на сами объекты

Python размещает элементы списка в памяти, затем размещает указатели на эти элементы. Таким образом, список в Python — это массив указателей.

Базовая работа со списками

Объявление списка

Объявление списка — самый первый и главный этап его создания. Для объявления списка в Python существует несколько способов.

Вариант №1: Через литерал (выражение, создающее объект):

>>> elements = [1, 3, 5, 6]

>>> print(elements)
[1, 3, 5, 6]

В данном примере мы создали список с заранее известными данными. Если нужен пустой список, в квадратных скобках ничего не указывается — elements = [].

Вариант №2: Через функцию list():

>>> elements = list()

>>> print(elements)
[]

В этом примере создается пустой список.

Обращение к элементу списка в Python

Чтобы обратиться к элементу списка, достаточно указать его индекс:

>>> elements = [1, 2, 3, 'word']

>>> elements[3]
'word'

Индекс — это порядковый номер элемента в списке. В примере выше индексы (позиции в списке) соответственно будут: 0, 1, 2, 3.

Нумерация элементов списка в Python начинается с нуля

Существует также отрицательный индекс, рассмотрим на примере:

>>> elements = [1, 2, 3, 'word']

>>> elements[-1]
'word'

Отрицательные индексы работают справа налево (то есть индекс значения ‘1’ — -4, а отрицательный индекс ‘word’ — -1.

💡 Отрицательным индексом удобно пользоваться, когда необходимо обратиться к последнему элементу в списке, не высчитывая его номер. Любой конечный элемент будет с индексом, равным -1.

Добавление в список

В списках доступно добавление, изменение, удаление элементов. Рассмотрим каждый способ изменения элементов на примерах.

Для того чтобы добавить новый элемент в список, используется list.append(x), где list — список, x — нужное значение.

>>> elements = [1, 2, 3, 'word']
>>> elements.append('meow')

>>> print(elements)
[1, 2, 3, 'word', 'meow']

Для простого примера, рассмотрим создание списка с нуля с помощью метода append() :

>>> elements = []
>>> elements.append(1)
>>> elements.append('word')
>>> elements.append('meow')

>>> print(elements)
[1, 'word', 'meow']

Добавление в список на указанную позицию

Немаловажно обратить внимание на метод list.insert(i, x), где list — список, i — позиция, x — нужное значение.

>>> elements = [1, 2, 4]
>>> print(elements)
[1, 2, 4]

>>> elements.insert(2, 3)
>>> print(elements)
[1, 2, 3, 4]

Изменение элементов списка

Изменение элементов списка происходит следующим образом: нужно выбрать элемент по индексу (порядковому номеру элемента) и присвоить новое значение.

>>> elements = [2, 4, 6]
>>> elements[2] = 8

>>> print(elements)
[2, 4, 8]

В примере выше мы заменили 6 на 8.

Не забывайте, что счёт начинается с нуля, и в данном списке цифра 6 это 2-й элемент

Удаление элемента из списка

Для удаление из списка используют инструкцию del list[i], где list — список, i — индекс (позиция) элемента в списке:

>>> elements = [1, "test", 5, 7]
>>> del elements[1]
>>> print(elements)
[1, 5, 7]

Удалять можно как из текущего списка, так и из вложенных списков:

>>> my_list = ["hello", "world", "!"]
>>> elements = [1, my_list, "ok"]
>>> del elements[1][2]

>>> print(elements)
[1, ['hello', 'world'], 'ok']

Можно удалять целыми диапазонами:

>>> elements = [2, 4, 6, 8, 12]
>>> del elements[2:] # удаляем все элементы после 2-го элемента (включительно)
>>> print(elements)
[2, 4]

>>> elements = [2, 4, 6, 8, 12]
>>> del elements[1:3] # удаляем от 1-го элемента включительно до 3-го элемента
>>> print(elements)
[2, 8, 12]

Еще один способ удаления из списка — list.remove(x), где list — список, x — значение, которое нужно удалить:

>>> elements = [2, "test", 4]
>>> elements.remove("test")
>>> print(elements)
[2, 4]

Как проверить наличие элемента в списке

Для того чтобы проверить существование какого-либо элемента в списке, нужно воспользоваться оператором in. Рассмотрим на примере:

>>> elements = ['слон', 'кот', 'лошадь', 'змея', 'рыба']
>>> if 'кот' in elements:
print('meow')

meow

Объединение списков

Списки в Python можно объединять с помощью оператора + или метода extend . Выглядит это так:

>>> a = [1, 3, 5]
>>> b = [1, 2, 4, 6]
>>> print(a + b)
[1, 3, 5, 1, 2, 4, 6]

>>> hello = ["h", "e", "l", "l", "o"]
>>> world = ["w", "o", "r", "l", "d"]
>>> hello.extend(world) # extends не возвращает новый список, а дополняет текущий
>>> print(hello)
['h', 'e', 'l', 'l', 'o', 'w', 'o', 'r', 'l', 'd']

Копирование списка Python

Если вы захотите скопировать список оператором =, вы скопируете не сам список, а только его ссылку.

>>> a = [1, 2, 3]
>>> b = a # переменной b присваивается не значение списка a, а его адрес

>>> b.append(4)
>>> print(a, b)
[1, 2, 3, 4] [1, 2, 3, 4]

Для копирования списков можно использовать несколько вариантов:

• elements.copy() — встроенный метод copy (доступен с Python 3.3);
• list(elements) — через встроенную функцию list() ;
• copy.copy(elements) — функция copy() из пакета copy;
• elements[:] — через создание среза (устаревший синтаксис).

Рассмотрим на примере каждый из этих способов:

>>> a = ["кот", "слон", "змея"]

>>> c = a[:] # устаревший синтаксис
>>> print(id(a), id(c), a, c)
56467336 60458408 ['кот', 'слон', 'змея'] ['кот', 'слон', 'змея']

Важно: copy.copy(a) делает поверхностное копирование. Объекты внутри списка будут скопированы как ссылки на них (как в случае с оператором =). Если необходимо рекурсивно копировать всех элементов в списке, используйте copy.deepcopy(a)

Скопировать часть списка можно с помощью срезов. Есть несколько вариантов использования:

>>> a = ["кот", "слон", "змея"]

>>> a = [1, 2, 3, 4, 5, 6, 7, 8]
>>> e = a[0:8:2] # c 0-го элемента по 8-й элемент с шагом 2
>>> print(e)
[1, 3, 5, 7]

Цикл по списку

Для перебора списков в Python есть два цикла: for и while.

elements = [1, 2, 3, "meow"]
for el in elements:
print(el)

Результат выполнения:

1
2
3
meow

Попробуем построить цикл while. Он выполняется, когда есть какое-либо определённое условие:

elements = [1, 2, 3, "meow"]
elements_len = len(elements)
i = 0
while i < elements_len:
print(elements[i])
i += 1

Результат выполнения:

1
2
3
meow

Из примеров выше можем сделать вывод, что конструкция for выглядит заметно компактнее, чем while.

Методы списков

• list.append(x) — позволяет добавлять элемент в конец списка;
• list1.extend(list2) — предназначен для сложения списков;
• list.insert(i, x) — служит для добавления элемента на указанную позицию(i — позиция, x — элемент);
• list.remove(x) — удаляет элемент из списка (только первое вхождение);
• list.clear() — предназначен для удаления всех элементов (после этой операции список становится пустым []);
• list.copy() — служит для копирования списков.
• list.count(x) — посчитает количество элементов x в списке;
• list.index(x) — вернет позицию первого найденного элемента x в списке;
• list.pop(i) — удалит элемент из позиции i ;
• list.reverse() — меняет порядок элементов в списке на противоположный;
• list.sort() — сортирует список.

Пример использования методов:

# append
>>> a = [1, 2, 3]
>>> a.append(4)
print(a)
[1, 2, 3, 4]

# sort (по убыванию)
>>> elements = [3, 19, 0, 3, 102, 3, 1]
>>> elements.sort(reverse = True)
>>> print(elements)
[102, 19, 3, 3, 3, 1, 0]

Вложенные списки

Список может содержать объекты разных типов: числовые, буквенные, а также списки. Список списков выглядит следующим образом:

>>> elements = [1, 2, [0.1, 0.2, 0.3]]

Для обращения к элементу вложенного списка нужно использовать два индекса: первый указывает на индекс главного списка, второй — индекс элемента во вложенном списке. Вот пример:

>>> elements = [["яблоки", 50], ["апельсины", 190], ["груши", 100]]

>>> print(elements[1][0])
апельсины

Срезы

Срезы (slices) — это подмножества элементов списка. Срезу нужны, когда необходимо извлечь часть списка из полного списка.

У них есть свой собственный синтаксис. Записывается срез так же, как обращение к элементу, используя индекс. Пример:

elements[START:STOP:STEP]

В этом случае берётся срез от номера start (включительно) до stop (не включая его), а step — это шаг. По умолчанию start и stop равны 0, step равен 1.

>>> elements = [0.1, 0.2, 1, 2, 3, 4, 0.3, 0.4]
>>> int_elements = elements[2:6] # с 2-го элемента включительно по 6-й элемент

>>> print(int_elements)
[1, 2, 3, 4]

Генераторы списков

Генератором списка называется способ построения списка с применением выражения к каждому элементу, входящему в последовательность. Есть схожесть генератора списка и цикла for. На этом примере мы рассмотрим простейший генератор списков:

>>> c = [c * 3 for c in 'list']

>>> print(c)
['lll', 'iii', 'sss', 'ttt']

Таким образом мы получили отдельно взятые утроенные буквы слова, введённого в кавычки. Есть множество вариантов применения генератора списков.

Пример генератора списка:

>>> nums = [i for i in range(1, 15)]
>>> print(nums)
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]

Пример посложнее:

>>> c = [c + d for c in 'list' if c != 'i' for d in 'spam' if d != 'a']
>>> print(c)
['ls', 'lp', 'lm', 'ss', 'sp', 'sm', 'ts', 'tp', 'tm']

Это усложнённая конструкция генератора списков, в которой мы сделали все возможные наборы сочетаний букв из введённых слов. Буквы-исключения видны по циклу, где стоит знак != для одной переменной и другой.

Best Practices

Последние абзацы статьи будут посвящены лучшим решениям практических задач, с которыми так или иначе сталкивается Python-разработчик.

Как получить список в обратном порядке

Изменить порядок размещения элементов в списке помогает функция list.reverse():

>>> elements = [1, 2, 3, 4, 5, 6]
>>> elements.reverse()

>>> print(elements)
[6, 5, 4, 3, 2, 1]

Как перевести список в другой формат?

Иногда требуется перевести список в строку, в словарь или в JSON. Для этого нужно будет вывести список без скобок.

Перевод списка в строку осуществляется с помощью функции join(). На примере это выглядит так:

>>> fruits = ["яблоко", "груша", "ананас"]

>>> print(', '.join(fruits))
яблоко, груша, ананас

В данном случае в качестве разделителя используется запятая.

Словарь в Python — это такая же встроенная структура данных, наряду со списком. Преобразование списка в словарь — задача тоже несложная. Для этого потребуется воспользоваться функцией dict(). Вот пример преобразования:

>>> elements = [['1', 'a'],['2', 'b'],['3', 'c']]
>>> my_dict = dict(elements)

>>> print(my_dict)
{'1': 'a', '2': 'b', '3': 'c'}

JSON — это JavaScript Object Notation. В Python находится встроенный модуль json для кодирования и декодирования данных JSON. С применением метода json.dumps(x) можно запросто преобразовать список в строку JSON.

>>> import json
>>> json.dumps(['word', 'eye', 'ear'])
'["word", "eye", "ear"]'

Как узнать индекс элемента в списке?

Узнать позицию элемента в последовательности списка бывает необходимым, когда элементов много, вручную их не сосчитать, и нужно обращение по индексу. Для того чтобы узнать индекс элемента, используют функцию list.index(x).

>>> elements = [1, 3, 6, 9, 55]

>>> print(elements.index(9))
3

В качестве аргумента передаем значение, а на выходе получаем его индекс.

Как посчитать количество уникальных элементов в списке?

Самый простой способ — приведение списка к set (множеству). После этого останутся только уникальные элементы, которые мы посчитаем функцией len():

>>> words = ["one", "two", "one", "three", "one"]
>>> len(set(words))
3

Как проверить список на пустоту?

>>> a = []
>>> if not a:
print("список пуст!")

список пуст!

Как создать список числовых элементов с шагом

Создание списка числовых элементов с шагом может понадобиться не так и часто, но мы рассмотрим пример построения такого списка.

Шагом называется переход от одного элемента к другому. Если шаг отрицательный, произойдёт реверс массива, то есть отсчёт пойдёт справа налево. Вот так выглядит список с шагом.

>>> elements = [1, 2, 3, 4, 5, 8, 9, 10, 11, 14, 20]
>>> print(elements[0:11:2])
[1, 3, 5, 9, 11, 20]

Еще один вариант — воспользоваться генератором списков:

>>> elements = [c for c in range(0, 10, 2)] # от 0 (включительно) до 10 с шагом 2

>>> print(elements)
[0, 2, 4, 6, 8]

При разработке на языке Python, списки встречаются довольно часто. Знание основ работы со списками поможет быстро и качественно писать программный код 😉.

Одна из ключевых особенностей Python, благодаря которой он является таким популярным – это простота. Особенно подкупает простота работы с различными структурами данных – списками, кортежами, словарями и множествами. Сегодня мы рассмотрим работу со списками.

Список (list) – это структура данных для хранения объектов различных типов. Если вы использовали другие языки программирования, то вам должно быть знакомо понятие массива. Так вот, список очень похож на массив, только, как было уже сказано выше, в нем можно хранить объекты различных типов. Размер списка не статичен, его можно изменять. Список по своей природе является изменяемым типом данных. Про типы данных можно подробно прочитать здесь. Переменная, определяемая как список, содержит ссылку на структуру в памяти, которая в свою очередь хранит ссылки на какие-либо другие объекты или структуры.

Как списки хранятся в памяти?

Как уже было сказано выше, список является изменяемым типом данных. При его создании в памяти резервируется область, которую можно условно назвать некоторым “контейнером”, в котором хранятся ссылки на другие элементы данных в памяти. В отличии от таких типов данных как число или строка, содержимое “контейнера” списка можно менять. Для того, чтобы лучше визуально представлять себе этот процесс взгляните на картинку ниже. Изначально был создан список содержащий ссылки на объекты 1 и 2, после операции a[1] = 3, вторая ссылка в списке стала указывать на объект 3.

Более подробно эти вопросы обсуждались в уроке 3 (Типы и модель данных).

Создание, изменение, удаление списков и работа с его элементами

Создать список можно одним из следующих способов.

>>> a = [] 
>>> type(a) 
<class 'list'> 
>>> b = list() 
>>> type(b) 
<class 'list'>

Также можно создать список с заранее заданным набором данных.

>>> a = [1, 2, 3] 
>>> type(a) 
<class 'list'>

Если у вас уже есть список и вы хотите создать его копию, то можно воспользоваться следующим способом:

>>> a = [1, 3, 5, 7] 
>>> b = a[:] 
>>> print(a) 
[1, 3, 5, 7] 
>>> print(b) 
[1, 3, 5, 7]

или сделать это так:

>>> a = [1, 3, 5, 7] 
>>> b = list(a) 
>>> print(a) 
[1, 3, 5, 7] 
>>> print(b) 
[1, 3, 5, 7]

В случае, если вы выполните простое присвоение списков друг другу, то переменной b будет присвоена ссылка на тот же элемент данных в памяти, на который ссылается a, а не копия списка а. Т.е. если вы будете изменять список a, то и b тоже будет меняться.

>>> a = [1, 3, 5, 7] 
>>> b = a 
>>> print(a) 
[1, 3, 5, 7] 
>>> print(b) 
[1, 3, 5, 7] 
>>> a[1] = 10 
>>> print(a) 
[1, 10, 5, 7] 
>>> print(b) 
[1, 10, 5, 7]

Добавление элемента в список осуществляется с помощью метода append().

>>> a = [] 
>>> a.append(3) 
>>> a.append("hello") 
>>> print(a) 
[3, 'hello']

Для удаления элемента из списка, в случае, если вы знаете его значение, используйте метод remove(x), при этом будет удалена первая ссылка на данный элемент.

>>> b = [2, 3, 5] 
>>> print(b) 
[2, 3, 5] 
>>> b.remove(3) 
>>> print(b) 
[2, 5]

Если необходимо удалить элемент по его индексу, воспользуйтесь командой del имя_списка[индекс].

>>> c = [3, 5, 1, 9, 6] 
>>> print(c) 
[3, 5, 1, 9, 6] 
>>> del c[2] 
>>> print(c) 
[3, 5, 9, 6]

Изменить значение элемента списка, зная его индекс, можно напрямую к нему обратившись.

>>> d = [2, 4, 9] 
>>> print(d) 
[2, 4, 9] 
>>> d[1] = 17 
>>> print(d) 
[2, 17, 9]

Очистить список можно просто заново его проинициализировав, так как будто вы его вновь создаете. Для получения доступа к элементу списка укажите индекс этого элемента в квадратных скобках.

>>> a = [3, 5, 7, 10, 3, 2, 6, 0] 
>>> a[2] 
7

Можно использовать отрицательные индексы, в таком случае счет будет идти с конца, например для доступа к последнему элементу списка можно использовать вот такую команду:

>>> a[-1] 
0

Для получения из списка некоторого подсписка в определенном диапазоне индексов, укажите начальный и конечный индекс в квадратных скобках, разделив их двоеточием.

>>> a[1:4] 
[5, 7, 10]

Методы списков

list.append(x)

Добавляет элемент в конец списка. Ту же операцию можно сделать так a[len(a):] = [x].

>>> a = [1, 2] 
>>> a.append(3) 
>>> print(a) 
[1, 2, 3]

list.extend(L)

Расширяет существующий список за счет добавления всех элементов из списка L. Эквивалентно команде a[len(a):] = L.

>>> a = [1, 2] 
>>> b = [3, 4] 
>>> a.extend(b) 
>>> print(a) 
[1, 2, 3, 4]

list.insert(i, x)

Вставить элемент x в позицию i.  Первый аргумент – индекс элемента после которого будет вставлен элемент x.

>>> a = [1, 2] 
>>> a.insert(0, 5) 
>>> print(a) 
[5, 1, 2] 
>>> a.insert(len(a), 9) 
>>> print(a) 
[5, 1, 2, 9]

list.remove(x)

Удаляет первое вхождение элемента x из списка.

>>> a = [1, 2, 3] 
>>> a.remove(1) 
>>> print(a) 
[2, 3]

list.pop([i])

Удаляет элемент из позиции i и возвращает его. Если использовать метод без аргумента, то будет удален последний элемент из списка.

>>> a = [1, 2, 3, 4, 5] 
>>> print(a.pop(2)) 
3 
>>> print(a.pop()) 
5 
>>> print(a) 
[1, 2, 4]

list.clear()

Удаляет все элементы из списка. Эквивалентно del a[:].

>>> a = [1, 2, 3, 4, 5] 
>>> print(a) 
[1, 2, 3, 4, 5] 
>>> a.clear() 
>>> print(a) 
[]

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

Возвращает индекс элемента.

>>> a = [1, 2, 3, 4, 5] 
>>> a.index(4) 
3

list.count(x)

Возвращает количество вхождений элемента x в список.

>>> a=[1, 2, 2, 3, 3] 
>>> print(a.count(2)) 
2

list.sort(key=None, reverse=False)

Сортирует элементы в списке по возрастанию. Для сортировки в обратном порядке используйте флаг reverse=True. Дополнительные возможности открывает параметр key, за более подробной информацией обратитесь к документации.

>>> a = [1, 4, 2, 8, 1] 
>>> a.sort() 
>>> print(a) 
[1, 1, 2, 4, 8]

list.reverse()

Изменяет порядок расположения элементов в списке на обратный.

>>> a = [1, 3, 5, 7] 
>>> a.reverse() 
>>> print(a) 
[7, 5, 3, 1]

list.copy()

Возвращает копию списка. Эквивалентно a[:].

>>> a = [1, 7, 9] 
>>> b = a.copy() 
>>> print(a) 
[1, 7, 9] 
>>> print(b) 
[1, 7, 9] 
>>> b[0] = 8 
>>> print(a) 
[1, 7, 9] 
>>> print(b) 
[8, 7, 9]

List Comprehensions

List Comprehensions чаще всего на русский язык переводят как  абстракция списков или списковое включение, является частью синтаксиса языка, которая предоставляет простой способ построения списков. Проще всего работу list comprehensions показать на примере. Допустим вам необходимо создать список целых чисел от 0 до n, где n предварительно задается. Классический способ решения данной задачи выглядел бы так:

>>> n = int(input())
7
>>> a=[]
>>> for i in range(n):
        a.append(i)

>>> print(a)
[0, 1, 2, 3, 4, 5, 6]

Использование list comprehensions позволяет сделать это значительно проще:

>>> n = int(input())
7
>>> a = [i for i in range(n)]
>>> print(a)
[0, 1, 2, 3, 4, 5, 6]

или вообще вот так, в случае если вам не нужно больше использовать n:

>>> a = [i for i in range(int(input()))]
7
>>> print(a)
[0, 1, 2, 3, 4, 5, 6]

List Comprehensions как обработчик списков

В языке Python есть две очень мощные функции для работы с коллекциями: map и filter. Они позволяют использовать функциональный стиль программирования, не прибегая к помощи циклов, для работы с такими типами как list, tuple, set, dict и т.п. Списковое включение позволяет обойтись без этих функций. Приведем несколько примеров для того, чтобы понять о чем идет речь.

Пример с заменой функции map.

Пусть у нас есть список и нужно получить на базе него новый, который содержит элементы первого, возведенные в квадрат. Решим эту задачу с использованием циклов:

>>> a = [1, 2, 3, 4, 5, 6, 7]
>>> b = []
>>> for i in a:
        b.append(i**2)

>>> print('a = {}nb = {}'.format(a, b))
a = [1, 2, 3, 4, 5, 6, 7]
b = [1, 4, 9, 16, 25, 36, 49]

Та же задача, решенная с использованием map, будет выглядеть так:

>>> a = [1, 2, 3, 4, 5, 6, 7]
>>> b = list(map(lambda x: x**2, a))
>>> print('a = {}nb = {}'.format(a, b))
a = [1, 2, 3, 4, 5, 6, 7]
b = [1, 4, 9, 16, 25, 36, 49]

В данном случае применена lambda-функция, о том, что это такое и как ее использовать можете прочитать здесь.

Через списковое включение эта задача будет решена так:

>>> a = [1, 2, 3, 4, 5, 6, 7]
>>> b = [i**2 for i in a]
>>> print('a = {}nb = {}'.format(a, b))
a = [1, 2, 3, 4, 5, 6, 7]
b = [1, 4, 9, 16, 25, 36, 49]

Пример с заменой функции filter.

Построим на базе существующего списка новый, состоящий только из четных чисел:

>>> a = [1, 2, 3, 4, 5, 6, 7]
>>> b = []
>>> for i in a:
        if i%2 == 0:
            b.append(i)

>>> print('a = {}nb = {}'.format(a, b))
a = [1, 2, 3, 4, 5, 6, 7]
b = [2, 4, 6]

Решим эту задачу с использованием filter:

>>> a = [1, 2, 3, 4, 5, 6, 7]
>>> b = list(filter(lambda x: x % 2 == 0, a))
>>> print('a = {}nb = {}'.format(a, b))
a = [1, 2, 3, 4, 5, 6, 7]
b = [2, 4, 6]

Решение через списковое включение:

>>> a = [1, 2, 3, 4, 5, 6, 7]
>>> b = [i for i in a if i % 2 == 0]
>>> print('a = {}nb = {}'.format(a, b))
a = [1, 2, 3, 4, 5, 6, 7]
b = [2, 4, 6]

Слайсы / Срезы

Слайсы (срезы) являются очень мощной составляющей Python, которая позволяет быстро и лаконично решать задачи выборки элементов из списка. Выше уже был пример использования слайсов, здесь разберем более подробно работу с ними. Создадим список для экспериментов:

>>> a = [i for i in range(10)]

Слайс задается тройкой чисел, разделенных запятой: start:stop:step. Start – позиция с которой нужно начать выборку, stop – конечная позиция, step – шаг. При этом необходимо помнить, что выборка не включает элемент определяемый stop.

Рассмотрим примеры:

>>> # Получить копию списка
>>> a[:]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

>>> # Получить первые пять элементов списка
>>> a[0:5]
[0, 1, 2, 3, 4]

>>> # Получить элементы с 3-го по 7-ой
>>> a[2:7]
[2, 3, 4, 5, 6]

>>> # Взять из списка элементы с шагом 2
>>> a[::2]
[0, 2, 4, 6, 8]

>>> # Взять из списка элементы со 2-го по 8-ой с шагом 2
>>> a[1:8:2]
[1, 3, 5, 7]

Слайсы можно сконструировать заранее, а потом уже использовать по мере необходимости. Это возможно сделать, в виду того, что слайс – это объект класса slice. Ниже приведен пример, демонстрирующий эту функциональность:

>>> s = slice(0, 5, 1)
>>> a[s]
[0, 1, 2, 3, 4]

>>> s = slice(1, 8, 2)
>>> a[s]
[1, 3, 5, 7]

Типо “List Comprehensions”… в генераторном режиме

Есть ещё одни способ создания списков, который похож на списковое включение, но результатом работы является не объект класса list, а генератор. Подробно про генераторы написано в “Уроке 15. Итераторы и генераторы“.

Предварительно импортируем модуль sys, он нам понадобится:

>>> import sys

Создадим список, используя списковое включение :

>>> a = [i for i in range(10)]

проверим тип переменной a:

>>> type(a)
<class 'list'>

и посмотрим сколько она занимает памяти в байтах:

>>> sys.getsizeof(a)
192

Для создания объекта-генератора, используется синтаксис такой же как и для спискового включения, только вместо квадратных скобок используются круглые:

>>> b = (i for i in range(10))

>>> type(b)
<class 'generator'>

>>> sys.getsizeof(b)
120

Обратите внимание, что тип этого объекта ‘generator’, и в памяти он занимает места меньше, чем список, это объясняется тем, что в первом случае в памяти хранится весь набор чисел от 0 до 9, а во втором функция, которая будет нам генерировать числа от 0 до 9. Для наших примеров разница в размере не существенна, рассмотрим вариант с 10000 элементами:

>>> c = [i for i in range(10000)]

>>> sys.getsizeof(c)
87624

>>> d = (i for i in range(10000))

>>> sys.getsizeof(d)
120

Сейчас уже разница существенна, как вы уже поняли, размер генератора в данном случае не будет зависеть от количества чисел, которые он должен создать.

Если вы решаете задачу обхода списка, то  принципиальной разницы между списком и генератором не будет:

>>> for val in a:
        print(val, end=' ')

0 1 2 3 4 5 6 7 8 9 

>>> for val in b:
        print(val, end=' ')

0 1 2 3 4 5 6 7 8 9

Но с генератором нельзя работать также как и со списком: нельзя обратиться к элементу по индексу и т.п.

P.S.

Если вам интересна тема анализа данных, то мы рекомендуем ознакомиться с библиотекой Pandas. На нашем сайте вы можете найти вводные уроки по этой теме. Все уроки по библиотеке Pandas собраны в книге “Pandas. Работа с данными”.

<<< Python. Урок 6. Работа с IPython и Jupyter Notebook   Python. Урок 8. Кортежи (tuple) >>>