Introduction: Whether you are doing scientific calculations or writing applications, you need to use some basic data structures, such as lists, tuples, and dictionaries. This article will explain these basic data structures in Python in detail.
Introduction
Whether you are doing scientific calculations or writing applications, you need to use some basic data structures, such as lists, tuples, and dictionaries.
This article will explain these basic data structures in Python in detail.
List
A list is also a list, which can be represented by square brackets:
In [40]: ages = [ 10, 14, 18, 20 ,25]
In [41]: ages
Out[41]: [10, 14, 18, 20, 25]List has some very useful methods, such as append , extend , insert , remove , pop , index , count , sort , reverse , copy, etc.
for example:
>>> fruits = ['orange', 'apple', 'pear', 'banana', 'kiwi', 'apple', 'banana']
>>> fruits.count('apple')
2
>>> fruits.count('tangerine')
0
>>> fruits.index('banana')
3
>>> fruits.index('banana', 4) # Find next banana starting a position 4
6
>>> fruits.reverse()
>>> fruits
['banana', 'apple', 'kiwi', 'banana', 'pear', 'apple', 'orange']
>>> fruits.append('grape')
>>> fruits
['banana', 'apple', 'kiwi', 'banana', 'pear', 'apple', 'orange', 'grape']
>>> fruits.sort()
>>> fruits
['apple', 'apple', 'banana', 'banana', 'grape', 'kiwi', 'orange', 'pear']
>>> fruits.pop()
'pear'Use the list as a stack
The stack is characterized by last in, first out, and the list provides us with append and pop methods, so it is very simple to use a list to implement a stack:
>>> stack = [3, 4, 5]
>>> stack.append(6)
>>> stack.append(7)
>>> stack
[3, 4, 5, 6, 7]
>>> stack.pop()
7
>>> stack
[3, 4, 5, 6]
>>> stack.pop()
6
>>> stack.pop()
5
>>> stack
[3, 4]Use the list as a queue
The characteristic of the queue is first-in-first-out, but it is very slow to use a list to insert elements at the head of the queue because all the elements need to be moved.
We can use collections.dequeto quickly operate from both ends:
>>> from collections import deque
>>> queue = deque(["Eric", "John", "Michael"])
>>> queue.append("Terry") # Terry arrives
>>> queue.append("Graham") # Graham arrives
>>> queue.popleft() # The first to arrive now leaves
'Eric'
>>> queue.popleft() # The second to arrive now leaves
'John'
>>> queue # Remaining queue in order of arrival
deque(['Michael', 'Terry', 'Graham'])List comprehension
To create a list, the usual practice is to use a for loop to traverse the list and set values for it:
>>> squares = []
>>> for x in range(10):
... squares.append(x**2)
...
>>> squares
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]Or we can use list comprehensions to generate lists more concisely:
squares = [x**2 for x in range(10)]Deriving a list-like structure by a pair of brackets is included the following: an expression, followed by a forclause, then zero or more for, or ifclauses.
The list comprehension will traverse the elements in the for clause, and use expressions to evaluate, and return the generated elements as new list elements.
Look at a more complicated one:
>>> [(x, y) for x in [1,2,3] for y in [3,1,4] if x != y]
[(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]The above expression is equivalent to:
>>> combs = []
>>> for x in [1,2,3]:
... for y in [3,1,4]:
... if x != y:
... combs.append((x, y))
...
>>> combs
[(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]List comprehensions can also be nested, if we have a matrix:
>>> matrix = [
... [1, 2, 3, 4],
... [5, 6, 7, 8],
... [9, 10, 11, 12],
... ]You can use the following expression to exchange the rows and columns of the matrix:
>>> [[row[i] for row in matrix] for i in range(4)]
[[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]Or use the simpler zip function:
>>> list(zip(*matrix))
[(1, 5, 9), (2, 6, 10), (3, 7, 11), (4, 8, 12)]of the
You can use del to delete an element in the list. del can delete a specific value in the list, it can also delete a slice, or even delete the entire list:
>>> a = [-1, 1, 66.25, 333, 333, 1234.5]
>>> del a[0]
>>> a
[1, 66.25, 333, 333, 1234.5]
>>> del a[2:4]
>>> a
[1, 66.25, 1234.5]
>>> del a[:]
>>> a
[]
>>> del aTuple
Tuples are very similar to lists, except that tuples are immutable.
Tuples are expressed in parentheses, or parentheses may not be used.
>>> t = 12345, 54321, 'hello!'
>>> t[0]
12345
>>> t
(12345, 54321, 'hello!')
>>> # Tuples may be nested:
... u = t, (1, 2, 3, 4, 5)
>>> u
((12345, 54321, 'hello!'), (1, 2, 3, 4, 5))Tuple and List operations are very similar, both have slice and index operations.
Tuples can be easily unpacked:
>>> x, y, z = tset
The set is represented by the set function or curly braces.
The elements in the set are not repeated, which is very similar to the set in java.
Because the representation of a dictionary is also curly braces, if you need to create an empty set, you need to use set, because the empty {} means a dictionary.
Look at some simple examples of collections:
>>> basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}
>>> print(basket) # show that duplicates have been removed
{'orange', 'banana', 'pear', 'apple'}
>>> 'orange' in basket # fast membership testing
True
>>> 'crabgrass' in basket
False
>>> # Demonstrate set operations on unique letters from two words
...
>>> a = set('abracadabra')
>>> b = set('alacazam')
>>> a # unique letters in a
{'a', 'r', 'b', 'c', 'd'}
>>> a - b # letters in a but not in b
{'r', 'd', 'b'}
>>> a | b # letters in a or b or both
{'a', 'c', 'r', 'd', 'b', 'm', 'z', 'l'}
>>> a & b # letters in both a and b
{'a', 'c'}
>>> a ^ b # letters in a or b but not both
{'r', 'd', 'b', 'm', 'z', 'l'}Like lists, collections also support comprehensions:
>>> a = {x for x in 'abracadabra' if x not in 'abc'}
>>> a
{'r', 'd'}dictionary
The dictionary is also represented by curly braces, the difference is that the elements in the dictionary are presented in the form of key:value.
Here are some basic operations of the dictionary:
>>> tel = {'jack': 4098, 'sape': 4139}
>>> tel['guido'] = 4127
>>> tel
{'jack': 4098, 'sape': 4139, 'guido': 4127}
>>> tel['jack']
4098
>>> del tel['sape']
>>> tel['irv'] = 4127
>>> tel
{'jack': 4098, 'guido': 4127, 'irv': 4127}
>>> list(tel)
['jack', 'guido', 'irv']
>>> sorted(tel)
['guido', 'irv', 'jack']
>>> 'guido' in tel
True
>>> 'jack' not in tel
FalseIn addition to curly braces, you can also use the dict function to build a dictionary:
>>> dict([('sape', 4139), ('guido', 4127), ('jack', 4098)])
{'sape': 4139, 'guido': 4127, 'jack': 4098}If the keyword is a simple character, you can write it directly like this:
>>> dict(sape=4139, guido=4127, jack=4098)
{'sape': 4139, 'guido': 4127, 'jack': 4098}The same derivation can also be used:
>>> {x: x**2 for x in (2, 4, 6)}
{2: 4, 4: 16, 6: 36}cycle
We generally use the for statement to traverse collections or dictionaries, lists, etc.
When we traverse the dictionary, we can use the items() method to get the key and value at the same time:
>>> knights = {'gallahad': 'the pure', 'robin': 'the brave'}
>>> for k, v in knights.items():
... print(k, v)
...
gallahad the pure
robin the braveIf it is a list, you can use the enumerate function to get the index and value:
>>> for i, v in enumerate(['tic', 'tac', 'toe']):
... print(i, v)
...
0 tic
1 tac
2 toeWe also used the zip function before, which can match elements in multiple sequences one by one:
>>> questions = ['name', 'quest', 'favorite color']
>>> answers = ['lancelot', 'the holy grail', 'blue']
>>> for q, a in zip(questions, answers):
... print('What is your {0}? It is {1}.'.format(q, a))
...
What is your name? It is lancelot.
What is your quest? It is the holy grail.
What is your favorite color? It is blue.This article has been included in http://www.flydean.com/06-python-data-structure/
The most popular interpretation, the most profound dry goods, the most concise tutorial, and many tips you don't know are waiting for you to discover!
Welcome to pay attention to my official account: "Program those things", know technology, know you better!