Shulou(Shulou.com)06/01 Report--

This article mainly explains "Python tuple instance analysis". Interested friends may wish to take a look. The method introduced in this paper is simple, fast and practical. Let's let Xiaobian take you to learn "Python tuple instance analysis"!

Introduction-In Python, data structures are used to store important data information in a project. Python has a variety of built-in data structures, such as lists, tuples, dictionaries, and sets. In this lesson, we will talk about one of the most important data structures in Python-tuples.

In Python, we can think of tuples as a special kind of list. The only difference between it and a list is that the data elements in the tuple cannot be changed (this is unchanged-not only can the data items in it not be changed, but also data items cannot be added and deleted!). When we need to create a set of immutable data, we usually put this data into tuples ~

1. Tuple creation && access (1) Tuple creation:

In Python, the basic form of creating tuples is to enclose data elements in parentheses "()" and separate elements with commas ",".

As follows:

tuple1 =('xiaoming ', ' xiaohong', 18, 21)tuple2 = (1, 2, 3, 4, 5)#And--Yes You can create empty tuples! tuple3 = ()#Note-If you create a tuple containing only one element, don't forget to put a comma after the element. Let it be identified as a tuple: tuple4 = (22, )(2) Access:

Tuples are similar to strings and lists in that the index starts at 0 and can be truncated and combined.

As follows:

tuple1 =('xiaoming ', ' xiaohong', 18, 21) tuple2 = (1, 2, 3, 4, 5)#Display the value of the element with index 1 in the tuple print("tuple1 [1]:", tuple1 [0])#Display the value of the element with index 1 through 3 in the tuple print("tuple2 [1:3]:", tuple2 [1:3])

2. Tuple modification & deletion (1) Tuple modification:

Although it says at the beginning that tuples are immutable, there is one supported operation-join combinations between tuples:

tuple1 = ('xiaoming', 'xiaohong', 18, 21)tuple2 = (1, 2, 3, 4, 5)tuple_new = tuple1 + tuple2print(tuple_new)

(1) Delete tuples:

Although tuples are immutable, entire tuples can be deleted with the del statement.

As follows:

tuple1 = ('xiaoming', 'xiaohong', 18, 21)print(tuple1) #normal print tuple1del tuple1print(tuple1) #Because tuple1 was deleted above, printing it again will report an error!

3. Built-in methods for tuples

Tuples are immutable, but we can manipulate tuples by using built-in methods. Common built-in methods are as follows:

len(tuple): Counts the number of tuple elements;

max(tuple): Returns the maximum number of elements in a tuple;

min(tuple): Returns the minimum number of elements in a tuple;

tuple(seq): converts a list into tuples.

More often than not, we convert tuples to lists first, and then to tuples later (because lists have many methods ~).

4. Decomposition of a sequence into individual variables (1)

Python allows a tuple or sequence of N elements to be divided into N separate variables. This is because Python syntax allows any sequence/iterable object to be broken down into individual variables with a simple assignment operation, the only requirement being that the total number and structure of variables match the sequence.

As follows:

tuple1 = (18, 22)x, y = tuple1print(x)print(y)tuple2 = ['xiaoming', 33, 19.8, (2012, 1, 11)]name, age, level, date = tuple2print(name)print(date)

If you want to decompose an iterable object of unknown or arbitrary length, the decomposition operation described above is not very nice! Usually there are known components or patterns in such iterable objects (e.g., everything after element 1 is a phone number), and the "*" asterisk expression allows developers to easily exploit these patterns without having to do complex operations in the iterable object to get the relevant elements.

In Python, asterisk expressions are useful when iterating over a variable-length tuple sequence. The process of decomposing a tuple sequence to be labeled is demonstrated below.

records = [ ('AAA', 1, 2), ('BBB', 'hello'), ('CCC', 5, 3)]def do_foo(x, y): print('AAA', x, y)def do_bar(s): print('BBB', s)for tag, *args in records: if tag == 'AAA': do_foo(*args) elif tag == 'BBB': do_bar(*args)line = 'guan:ijing234://wef:678d:guan'uname, *fields, homedir, sh = line.split(':')print(uname)print(*fields)print(homedir)print(sh)

（2）

When iterating through sequences such as lists or tuples in Python, it is sometimes necessary to count the last few records to achieve historical statistics.

Use the built-in deque to achieve:

from _collections import dequeq = deque(maxlen=3)q.append(1)q.append(2)q.append(3)print(q)q.append(4)print(q)

The following--demonstrates the process of making the last few items in the sequence history.

from _collections import dequedef search(lines, pattern, history=5): previous_lines = deque(maxlen=history) for line in lines: if pattern in line: yield line, previous_lines previous_lines.append(line)# Example use on a fileif __name__ == '__main__': with open('123.txt') as f: for line, prevlines in search(f, 'python', 5): for pline in pvlines: #lines containing python print(pline) # print (pline, end='') #Print the last checked N lines of text print(line) # print (pline, end='')

123.txt：

pythonpythonpythonpythonpythonpythonpythonpythonpython

In the above code, a simple text matching operation is implemented on a series of text lines, and when a suitable match is found, the current matching line and the last N lines of text checked are output. A fixed-length queue is created using deque(maxlen=N). When a new record is added and the queue becomes full, the oldest record is automatically removed. When writing code to search for a record, it is common to use generator functions with the yield keyword, which successfully decouple the code that handles the search process from the code that uses the search results.

5. Implementation Priority Queue

A simple priority queue can be implemented using the built-in module heapq.

The following--demonstrates the process of implementing a simple priority queue.

import heapqclass PriorityQueue: def __init__(self): self._ queue = [] self._ index = 0 def push(self, item, priority): heapq.heappush(self._ queue, (-priority, self._ index, item)) self._ index += 1 def pop(self): return heapq.heappop(self._ queue)[-1]class Item: def __init__(self, name): self.name = name def __repr__(self): return 'Item({! r})'.format(self.name)q = PriorityQueue()q.push(Item('AAA'), 1)q.push(Item('BBB'), 4)q.push(Item('CCC'), 5)q.push(Item('DDD'), 1)print(q.pop())print(q.pop())print(q.pop())

In the above code, a simple priority queue is implemented using the heapq module, with the element returned the first time pop() is executed having the highest priority.

Two elements with the same priority (foo and grok) are returned in the same order as they were inserted into the queue.

The functions heapq.heappush() and heapq.heappop() insert and remove elements from the list_queue, respectively, and ensure that the first element in the list has the lowest priority.

The function heappop() always returns the "smallest" element, and because push and pop operations are both O(log2N) in complexity, where N is the number of elements in the heap, these operations are very efficient even if N is large.

The queue in the above code is composed of tuples (-priority, index, item), and priority takes a negative value so that the queue can be arranged according to the priority of the elements from high to low. This is the reverse of the normal heap order, where heaps are sorted from smallest to largest. The variable index is used to arrange elements of the same priority in the proper order, and by maintaining an increasing index, elements will be arranged in the order in which they were added to the queue. But index also plays an important role when comparing elements of the same priority.

In Python, if elements are stored as tuples (priority, item), they can be compared as long as they differ in priority. But if two tuples have the same priority, the comparison fails. In this case, consider introducing an additional index value to create a tuple in the form of (priority, index, item), because no two tuples will have the same index value, so this can completely avoid the above problem. Once the result of the comparison is certain, Python doesn't compare the remaining tuple elements.

The following--demonstrates how to implement a simple priority queue:

import heapqclass PriorityQueue: def __init__(self): self._ queue = [] self._ index = 0 def push(self, item, priority): heapq.heappush(self._ queue, (-priority, self._ index, item)) self._ index += 1 def pop(self): return heapq.heappop(self._ queue)[-1]class Item: def __init__(self, name): self.name = name def __repr__(self): return 'Item({! r})'.format(self.name)# ①a = Item('AAA') b = Item('BBB')#a < b Error a = (1, Item('AAA'))b = (5, Item('BBB'))print(a < b)c = (1, Item('CCC')#② a < c Error # ③a = (1, 0, Item('AAA'))b = (5, 1, Item('BBB'))c = (1, 2, Item('CCC'))print(a < b)# ④print(a < c)

In the above code, because there is no so added in 1-2, there will be an error when the priority of two tuples is the same; and the index is added in 3-4, so there will be no error!

At this point, I believe that everyone has a deeper understanding of "Python tuple instance analysis", so let's actually operate it! Here is the website, more related content can enter the relevant channels for inquiry, pay attention to us, continue to learn!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.