It depends on what you are intending to do with it.

Sets are significantly faster when it comes to determining if an object is present in the set (as in x in s), but its elements are not ordered so you cannot access items by index as you would in a list. Sets are also somewhat slower to iterate over in practice.

You can use the timeit module to see which is faster for your situation.

Accessing a single element in a list is 5x faster than accessing a single element in a numpy array, 22.1 ns rather than 123 ns on my pc. Lists are better for single-element operations. A one-million-element multiplication operation on a numpy array is 50x faster than the similar list-comprehension operation, 1.28 ms rather than 64.2 ms. Numpy arrays are better for array operations. (These figures are copied from a test I did about 5 years ago, i.e. before the Faster CPython project, but should still be mostly relevant. The ipython %%timeit has its setup on the first line and times the second line.) In [2]: %%timeit mylist = [1,2,3] ...: x = mylist[1] ...: 22.1 ns ± 0.0626 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each) In [3]: %%timeit import numpy; myarray = numpy.array([1,2,3]) ...: x = myarray[1] ...: 123 ns ± 0.0508 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each) In [4]: %%timeit mylist = list(range(1000000)) ...: newlist = list(n*2 for n in mylist) ...: 64.2 ms ± 704 µs per loop (mean ± std. dev. of 7 runs, 10 loops each) In [5]: %%timeit import numpy; myarray = numpy.arange(1000000) ...: newarray = myarray * 2 ...: 1.28 ms ± 1.43 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)

“Array” is an ambiguous term in Python and best not used. Most beginners use it to refer to the list type, but are unaware that there is actually an array.array type in the standard library as well.

If it's possible in your case, bisect performance comes close to set for membership checks (both with list and array). See results below

import array
from bisect import bisect
import sys
import time


class TimerContext:
    def __enter__(self):
        self.t0 = time.time()

    def __exit__(self, *args, **kwargs):
        print(time.time() - self.t0)


def get_size_in_megabytes(iterable):
    return round(sys.getsizeof(iterable) / (1024 ** 2), 2)


SIZE = 1000000

l = list([i for i in range(SIZE)])
a = array.array("I", l)
s = set(l)

print(type(l), get_size_in_megabytes(l))
print(type(a), get_size_in_megabytes(a))
print(type(s), get_size_in_megabytes(s))

with TimerContext():
    x = 99999 in l
with TimerContext():
    x = 99999 in a
with TimerContext():
    x = 99999 in s

print("list bisect")
with TimerContext():
    bisect(l, 99999)

print("array bisect")
with TimerContext():
    bisect(a, 99999)

Results:

<class 'list'> 8.58
<class 'array.array'> 3.81
<class 'set'> 32.0
0.0024390220642089844
0.0053005218505859375
3.814697265625e-06
list bisect
9.298324584960938e-06
array bisect
6.198883056640625e-06

Credits for sys.getsizeof ussage to @CristiFati.

Good idea ! :) @Pegasus your post isn't OFF-TOPIC as Sololearn related posts are allowed.

From my understanding: Arrays are a thin wrapper on C style arrays. They can only contain objects of the same basic data-type, so they are more strongly typed - but they can only deal with numeric C-style data types. They are a lot more basic than lists or sets. Arrays are probably best used in situations where you know up front, how many items they will contain and that the array will not need to grow. But if you're going to be dealing with a dynamic set of data that could grow or shrink - you're probably better off using List or Set. · Sets can hold pretty much anything - as long as it is hashable. Objects in the set are sorted/ordered based on each objects hash values. Also, sets do not allow duplicates. And I'm not sure how set deals with hash collisions (where two different objects have the same hash-values). And because sets use hash-tables, lookups are pretty fast. So if you are dealing with hashable types and you don't want duplicates (and you aren't worried about possible hash-collisions) - sets are the way to go. · Lists can hold pretty much anything and don't care about duplicates. Objects remain in the order in which they were added. If a list runs out of space and needs to reallocate - it will reallocate much more space than it needs. So lists can become quite large. But this does mean that they can be appended to efficiently, because reallocations will occur less often. · So to sum up: Lists should be adequate for most uses - especially if it is possible that the data-set will grow to be large. Arrays are really only useful for numeric data. Sets can only be used with hashable types, with no duplication. · https://docs.python.org/3/library/array.html#module-arrayhttps://wiki.python.org/moin/TimeComplexityhttps://docs.python.org/3/glossary.html#term-hashable