Python - List

Card Puncher Data Processing

About

Lists are used to store a collection of different pieces of information in a sequence order of under a single variable name.

A list can be used to implement a Python - Stack.

A list is mutable whereas a tuple is not.

Syntax

list_name = [item_1, item_2]
  • Empty list:
empty_list = []

Constructor

>>> list(range(10))
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

>>> list({1,2,3})
{1, 2, 3}
>>> list((1,2,3))
{1, 2, 3}

Operations

Access by Index

Starting with 0 

numbers = [1, 2, 3, 4]
numbers[0] == 1

Get the index of an object

numbers = [1, 2, 3, 4]
index =  numbers.index(2)  # Return 1

Set by Index

(starting with 0) 

numbers = [1, 2, 3, 4]
numbers[0] = 5
# 1 becomes 5

Add

a list to a list

>>> [1]+[2]
[1, 2]

myList1 = [1,2,3]
myList2 = [4,5,6]
for i in myList2:
   myList1 += [i]
   print (myList1)

[1, 2, 3, 4]
[1, 2, 3, 4, 5]
[1, 2, 3, 4, 5, 6]

an element at the end of the list

A list doesn't have to have a fixed length, they are mutable. Items can be added to the end of a the list.

  • One item
list_name.append(item)
  • N items
list = []
list.append(["O"] * 2)
list.append(["N"] * 2)
print list

[['O', 'O'], ['N', 'N']]

an element to an index (position)

numbers = [4, 3, 2, 1]
three_index =  numbers.index(3)  # Use index() to find 3
numbers.insert(three_index,3.5)
print numbers 
# print [4, 3.5, 3, 2, 1]

Remove

Remove an element

  • remove will remove the first item from my_list that has a value equal to value
my_list.remove(value)
  • pop will remove the item at index
value = my_list.pop(index)
  • del will remove the item at the index, but it won't return it
del(my_list[1])

See also filter

Remove all elements

del list[:]
# python 3
list.clear()

Filter

A list can be filtered through:

with the filter function:

filter(predicate, iter)

returns a list that contains all the sequence elements that meet a certain condition. Filter is somewhat obsolete because it duplicate the features of list comprehensions

Example:

  • Remove all empty string
filter(None,myList)
  • Remove even elements
def is_even(x):
    return (x % 2) == 0
filter(is_even, range(10))

[0, 2, 4, 6, 8]

With a comprehension filter

  • Remove all empty string
list = [1, 2, '']
[ x for x in list if x!='']

[1, 2]

Slice

Slicing (sub-list) returns a list of elements from the position a to the position before b.

Syntax: 

myList[a:b:c]

where in the my_list[a:b:c]:

  • a is the first element of the slice. It can be negative (ie -2 means start from the last two elements of list)
  • b is the last element of the slice (not include)
  • c is the number of element to skip

Example without skipping: 

my_list = [0, 1, 2, 3]
first_three_items = my_list[0:3]  # The first three items
first_three_items = my_list[:3]  # of 
last_two_items = my_list[len(my_list)-2:]  # will return the last two items

print my_list
# Prints [0, 1, 2, 3]

print first_three_items
# Prints [0, 1, 2]

print last_two_items
# Prints [2,3]

Example with skipping: 

>>> my_list = [0, 1, 2, 3]
>>> my_list[::2]
[0, 2]
>>> my_list[1::2]
[1, 3]

Operator

Concat

m = [1, 2, 3]
n = [4, 5, 6]
print m + n

[1, 2, 3, 4, 5, 6]

in

if 5 not in [1, 2, 3, 4]:
    print '5 is not in the list'

Iteration

Python - (Loop|Iteration)

List iteration

for

my_list = [1,3,2]

for number in my_list:
    print (number)

1
3
2

After the loop is executed, number remains bound to 2.

while

my_list = [1,3,2]
i=0
while my_list[i] !=2 :
    print (my_list[i]) 
    i = i+1

1
3

Break and Range

Break with range 

for number in range(5):
    if (number > 3):
        break
    print number

0
1
2
3

Reverse iteration

for i in reversed([1,2,3]):
    print i

3
2
1

Enumerate through n lists on the same time (zip)

zip create pairs of elements when passed two lists, and will stop at the end of the shorter list. 

list_a = [1, 4, 5]
list_b = [2, 3]

for a, b in zip(list_a, list_b):
    if a > b:
        print a, "is bigger than", b 
    else:
        print b, "is bigger than", a

2 is bigger than 1
4 is bigger than 3

Iterate with the index (enumerate function)

choices = ['madelief', 'melissa', 'rixt', 'nico']

for index, item in enumerate(choices):
    print index+1, item

1 madelief
2 melissa
3 rixt
4 nico

of 

list(enumerate(choices))

[(0, 'madelief'), (1, 'melissa'), (2, 'rixt'), (3, 'nico')]

where you can see that enumerate create tuples with the index and the value

Comprehension

Comprehensions are a way to loop over elements of a set, list, dictionary, tuple, range, or zip.

Example

>>> ListOfList = [[.25, .75, .1], [-1, 0], [4, 4, 4, 4]]
>>> [sum(x) for x in ListOfList ]
[1.1, -1, 16]
>>> sum([sum(x) for x in ListOfList ])
16.1

Order

A list keep the order of element safe 

>>> [2*x for x in [2,1,3,4,5] ]
[4, 2, 6, 8, 10]

but not a set. 

>>> [2*x for x in {2,1,3,4,5} ]
[2, 4, 6, 8, 10]

Nested Loop

A double comprehension is a nested for (a for loop in a for loop) 

>>> [ x*y for x in [1,2,3] for y in [10,20,30] ]
[10, 20, 30, 20, 40, 60, 30, 60, 90]

A double comprehension can be use over two lists in order to form a Cartesian product. 

>>> [ [x,y] for x in ['A','B'] for y in [1,2] ]
[['A', 1], ['A', 2], ['B', 1], ['B', 2]]

Unpacking

Python - (Un)Packing 

>>> listoflists = [[1,1],[2,4],[3, 9]]
>>> [y for [x,y] in listoflists]
[1, 4, 9]

Recursive Comprehension

Example: Generation of all combinations of element (in myList) over a variable length (in myLength) : 

myLength = 3
myList = [0,1]
scalarList = [[i] for i in myList] 
count = 1
while count < (myLength):
    scalarList = [k+[j] for j in myList for k in scalarList]
    count += 1
print(scalarList)

[[0, 0, 0], [1, 0, 0], [0, 1, 0], [1, 1, 0], [0, 0, 1], [1, 0, 1], [0, 1, 1], [1, 1, 1]]

It's the dynamic version of the following cartesian product: 

[[i,j,k] for i in myList for j in myList for k in myList]

This function can be use to create all the scalars over a set of vector in order to generate the span (with myList representing the field and myLength the cardinality of the set of vector).

Aggregate

Count

  • The list
len([1, 2, 3, 4]) == 4
  • The number of occurrence of an element
>>> [1,2,2,3].count(2)
2

Sum

print sum([1, 2, 3, 4]) 

10

Average

>>> L = [1, 2, 3, 4]
>>> sum(L)/len(L)

Data Operation

Sort

The sort method return a “in-place” (mutable) list sorted by increasing numerical/alphabetical order. 

my_list = [1,3,2]
my_list.sort()
for number in my_list:
    print number

1
2
3

Sort can not be used against an element of a dictionary. You have to store the list in a variable before the sort.

Join (Element concatenation)

Join will concat all the strings element of a list and separate them with a separator.

Syntax: 

StringSeparator.join(mylist)

mylist = ["O"] * 5
print mylist
print " ".join(mylist)
print " - ".join(mylist)

['O', 'O', 'O', 'O', 'O']
O O O O O
O - O - O - O - O

Flatten a nested list

nested = [[1,2], [3,4]]
flat = [a for b in nested for a in b]

Others

Unpacking

Unpacking: This expression is a convenient way to initialize variables from a list 

>>> [x,y] = [1, 2]
>>> x
1
>>> y
2

Documentation / Reference




Discover More
Card Puncher Data Processing
Python - (Dictionary|Map)

A dictionary is similar to a list, but you access values by looking up a key instead of an index. A key can be any string or number. A dictionary is suitable for representing functions with finite domains....
Card Puncher Data Processing
Python - Array

The most used type in Python is called a list But you have also an array which is more like a C array and is little used.
Card Puncher Data Processing
Python - Collection

collection in Python: Data Type: Type Sequence (Ordered) Mutable Duplicate Yes Yes Yes Yes No Yes No Yes No No Yes No
Card Puncher Data Processing
Python - Command Line Argument

Python provides command-line arguments through the list sys.argv (from the sys module) where: sys.argv[0] is the script name sys.argv[n] is the argument n Therefore len(sys.argv) is the number of...
Card Puncher Data Processing
Python - Comprehension (Iteration)

Comprehension are a way to loop over elements of: a , , , tuple, , or . Comprehensions permit to build collections out of other collections. Comprehensions allow one to express computations...
Card Puncher Data Processing
Python - Control flow (Comparator, Boolean Operator and Conditional Statement)

in Python Equal to (==) Not equal to (!=) Less than (<) Less than or equal to (<=) Greater than (>) Greater than or equal to (>=) In (for a string or a list) Comparisons generate...
Card Puncher Data Processing
Python - Data Type

data (type|structure) in Python of a name generally a variable objecttypeintsstringsfunctionsclassesclass - an integer is a positive or negative whole number. float booleans (True...
Card Puncher Data Processing
Python - File I/O

How to manipulate a file. See also: where path is the mode can be: w : write-only mode (“w”), r : read-only mode (“r”), r+ : read and write mode (“r+”), a : append...
Card Puncher Data Processing
Python - Help / Function Documentation

From the python shell, use the dir function. For instance for a list
Card Puncher Data Processing
Python - Matrix and Matrix function representation

How Matrix and Matrix function representation are modelled in Python. Python Matrix representation: A list of row-lists A list of column-lists In Python, the Matrix function is represented...



Share this page:
Follow us:
Task Runner