How Python maps names into elements of a sequence (code)

The content of this article is about how Python maps names to sequence elements (code). It has certain reference value. Friends in need can refer to it. I hope it will be helpful to you.

1. Requirements

Our code accesses list tuples through position (i.e. index or subscript), but sometimes this makes the code become Got to be a little hard to read. We want to be able to access elements by name, thus reducing the dependence on position in the structure.

2. Solution

Compared with ordinary tuples, collections.namedtuple() (named tuple) only adds very little overhead to provide these conveniences. In fact, collections.namedtuple() is a factory method that returns a subclass of the standard tuple type in Python. We provide it with a type name and corresponding fields, and it returns an instantiable class, passing in values ​​for the fields you have defined, etc.

from collections import namedtuple
Subscriber=namedtuple('Subsciber',['addr','joined'])
sub=Subscriber("1782980833@qq.com","2018-10-23")
print(sub)
print(sub.addr)
print(sub.joined)
print(len(sub))
addr,joined=sub
print(addr)
print(joined)
#下面错误，以为你namedtuple是不可变的
#sub.joined="2019"

Result:

Subsciber(addr='1782980833@qq.com', joined='2018-10-23')
1782980833@qq.com
2018-10-23
2
1782980833@qq.com
2018-10-23

Although an instance of namedtuple looks like an ordinary class instance, its instances are interchangeable with ordinary tuples, and all ordinary tuples are supported. Operations supported by the group.

The main function of named tuples is to decouple the code from the position of the elements it controls. So, if you get a large list of tuples from a database call, and you access elements by their position, then if you add a new column to the form, the code will crash, but if the returned tuples are first Convert to named tuples and there will be no problem.

To illustrate this problem, here is some code using ordinary tuples:

def compute_cost(records):
    total=0.0
    for rec in records:
        total+=rec[1]*rec[2]
    return total

Referencing elements by position often makes the code less expressive and also very dependent on the specificity of the record. structure.

The following is the version using named tuples:

from collections import namedtuple
Stock=namedtuple('Stock',['name','shares','price'])
def compute_cost(records):
    total=0.0
    for rec in records:
        s=Stock(*rec)
        total+=s.shares*s.price
    return total

3. Analysis

One possible usage of namedtuple is as a replacement for a dictionary, later The user needs more space for storage. Therefore, if you want to build a large data design dictionary, it will be more efficient to use namedtuple, but please note that unlike dictionaries, namedtuple is immutable.

If you need to modify any attributes, you can do so by using the namedtuple instance_replace() method. This method creates a new named tuple and replaces the corresponding values.

from collections import namedtuple
Subscriber=namedtuple('Subsciber',['addr','joined'])
sub=Subscriber("1782980833@qq.com","2018-10-23")

print(sub)

sub=sub._replace(joined="2018-10-24")
print(sub)

Result:

Subsciber(addr='1782980833@qq.com', joined='2018-10-23')
Subsciber(addr='1782980833@qq.com', joined='2018-10-24')

_The replace() method has a subtle use, and that is that it can be used as a simple way to fill in named elements with optional or missing fields. Group. To do this, first create a prototype array containing the default values, then use the _replace() method to create a new instance and replace the corresponding values.

from collections import namedtuple
Subscriber=namedtuple('Subsciber',['addr','joined','age'])
sub=Subscriber("",None,0)

def dict_to_stock(s):
    return sub._replace(**s)

a={"addr":"111111@qq.com","joined":"1111-11-11","age":11}
a=dict_to_stock(a)
print(a)

b={"addr":"111111@qq.com","joined":"1111-11-11"}
b=dict_to_stock(b)
print(b)

Result:

Subsciber(addr='111111@qq.com', joined='1111-11-11', age=11)
Subsciber(addr='111111@qq.com', joined='1111-11-11', age=0)

Finally, and quite importantly, it should be noted that if our goal is to define an efficient data structure and will modify various instance properties in the future, then using namedtuple is not the best choice. Instead, consider a class that uses the __slots__ attribute.

The above is the detailed content of How Python maps names into elements of a sequence (code). For more information, please follow other related articles on the PHP Chinese website!