Data structures are what we create out of data and Python has some good standard data structures. Find out how named tuples and counters work in this extract from Programmer's Python: Everything is Data.

Programmer's Python
Everything is Data

Is now available as a print book: Amazon

Contents

1. Python – A Lightning Tour
2. The Basic Data Type – Numbers
      Extract: Bignum
   
3. Truthy & Falsey
4. Dates & Times
      Extract Naive Dates ***NEW!!!
5. Sequences, Lists & Tuples
      Extract Sequences 
6. Strings
      Extract Unicode Strings
7. Regular Expressions
8. The Dictionary
      Extract The Dictionary 
9. Iterables, Sets & Generators
      Extract  Iterables 
10. Comprehensions
       Extract  Comprehensions 
11. Data Structures & Collections
       Extract Stacks, Queues and Deques
       Extract Named Tuples and Counters
12. Bits & Bit Manipulation
       Extract Bits and BigNum 
13. Bytes
       Extract Bytes And Strings
       Extract Byte Manipulation 
14. Binary Files
15. Text Files
16. Creating Custom Data Classes
        Extract A Custom Data Class 
17. Python and Native Code
        Extract   Native Code
    Appendix I Python in Visual Studio Code
    Appendix II C Programming Using Visual Studio Code

<ASIN:1871962765>

<ASIN:1871962749>

<ASIN:1871962595>

<ASIN:B0CK71TQ17>

<ASIN:187196265X>

Data Structures & Collections

So far we have focused on the inbuilt data structures that Python provides as part of the core language – the list, tuple, set and dictionary. There are also data structures that are fundamental to programming that do not correspond to Python’s built-in data structures, but they are very easy to implement or they are implemented for you in a suitable module. In this chapter we look at the stack, the queue and the deque, which are supplied structures in other languages but not in Python. Most of the additional data structures are in the collections module – but it also has a number of classes – OrderedDict, defaultdict, UserDict, UserList and UserString – which aren’t particularly useful in modern Python 3 and hence are not covered in this chapter.

As an example of implementing a data structure making use of the supplied data structures we create a binary tree class. This is a good example of using both stacks and queues, but turns out to be more complicated than you might expect. It is re-used in later chapters as an example of how to add your own data structures.

In chapter but not in this extract

• The Stack
• The Queue
• Double-Ended Queue

Named Tuples

Although not in the same category of fundamental data structures, the named tuple is useful and also provided by the collections module. The named tuple works exactly like a tuple, but with the added feature of having named fields. In other languages this is often called a struct, but notice that Python’s named tuple is immutable. How to use named tuples as part of file I/O is described in Chapter 13.

The named tuple works in a slightly different way to the data structures we have been exploring. The constructor doesn’t return a named tuple object, but a new subclass of namedtuple:

type = namedtuple(typename, [field1, field2, field3…])

where typename is the name of the new type and field1 and so on are the names of the fields. The field names can be specified using any sequence type or as a single string with names separated by whitespace or commas. Notice that this implies that you can construct a named tuple with names derived from another source as a string or a sequence.

You can use the getattr(string) function to return the value of a field whose name is stored in string. For example:

from collections import namedtuple
Point = namedtuple("Point",["x","y"])

creates a new class called Point which can in turn be used to create instances of the Point type:

p = Point(10,-42)

Now p references a new Point instance and this is essentially a tuple with fields that can be accessed using the field names:

print(p.x,p.y)

or, using the standard index notation:

print(p[0],p[1])

Both display 10 -42.

You can use the rename = True parameter to replace any invalid field names with generated field names of the form _n where n is the position of the field. You can also set the defaults parameter to an iterable which sets the fields to default values:

Point = namedtuple("Point",["x","y"],defaults=(0,0))
p = Point()

If not enough defaults are provided they are used starting from the right-hand end of the field name list and any remaining fields have to be specified in the constructor.

Notice that named tuples are fairly efficient because the constructor for the type stores a dictionary mapping the field names to index position and this makes instances of the type use little more space that a standard tuple.

There are some extra methods:

• _make(iterable)
  creates an instance using the iterable for the values

• _asdict()
  converts the names and values to key values in a dictionary

• _replace(name1=value1, name2=value2..)
  creates a new instance of the tuple with the specified fields updated to their new values

• _fields()
  returns the field names as a string

• _field_defaults()
  returns a dictionary of field names and defaults