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

How to carry out Python data structure analysis, in view of this problem, this article introduces the corresponding analysis and solution in detail, hoping to help more partners who want to solve this problem to find a more simple and feasible method.

Introduction to Python data structure:

Data structure is a way to organize data so that it can be better stored and obtained. Data structures define the relationships between data and how they are manipulated. The data structure shields the details of data storage and operation, so that programmers can better deal with business logic and have a fast way of data storage and acquisition.

Abstract data types and data structures

Data structure is the implementation of abstract data type (ADT), which is usually implemented based on the basic data types provided by programming language and combined with the corresponding code.

Generally speaking, the data structure is divided into two categories: the original data structure and the non-original data structure, the original data structure is used to express the simple data relationship, the non-original data structure contains the original data structure, at the same time, the data relationship is more complex. Data operations are also more complex.

Original data structure

The original data structure-as the name implies-is the most primitive or basic data structure. They are the building blocks of data manipulation, containing pure, simple data values. Python has four primitive variable types:

Integers

Float

Strings

Boolean

Integers

You can use Integers to represent digital data, specifically, you can use integers from negative infinity to infinity

Float

"Float" stands for "floating point". You can use it for rational numbers, usually ending with a decimal number, such as 1.11 or 3.14.

Note that in Python, you do not have to explicitly declare the type of variable or data. That's because Python is a dynamically typed language. A dynamically typed language is a language in which the data type that an object can store is mutable.

String

A String is a collection of letters, words, or other characters. In Python, you can create a string by enclosing a series of characters in a pair of single or double quotes. For example: 'cake', "cookie and so on. You can also apply a + operation to two or more strings to concatenate them, as in the following example:

X = 'Cake'y =' Cookie'x +'&'+ y # result: 'Cake & Cookie'

Here are some other basic operations you can perform with strings; for example, you can use * repeat strings a certain number of times:

# Repeatx * 2 # result: 'CakeCake'

You can also cut strings

Z1 = x [2:] print (Z1) Z2 = y [0] + y [1] print (Z2) # result keCo

Note that strings can also be alphanumeric characters, but the + operation is still used to concatenate strings.

X = '4roomy =' 2roomx + yellow42'

Python has many built-in methods or helper functions to manipulate strings. Replacing substrings, capitalizing some words in paragraphs, and finding the position of a string in another string are some common string operations. For example:

Capital initials

Str.capitalize ('cookie')' Cookie'

Retrieves the length of the string in characters. Note that spaces are also included in the final result:

Str1 = "Cake 4 U" str2 = "404" len (str1) 8

Check whether the string is numeric

Str1 = "Cake 4 U" str2 = "404" str1.isdigit () Falsestr2.isdigit () True

Replace

Str1 = "Cake 4 U" str2 = "404" str1.replace ('4U, str2) 'Cake 404'

Look for substrings

Str1 = 'cookie'str2 =' cook'str1.find (str2) str1 ='I got you a cookie'str2 = 'cook'str1.find (str2) 12Boolean

The built-in data type values are: True and False, which usually makes them interchangeable with integers 1 and 0. Boolean values are useful in conditional and comparative expressions, as in the following example:

X = 4y = 2x = = yFalsex > yTruex = 4y = 2z = (Xerox) if z: print ("Cookie") else: print ("No Cookie") No Cookie data type conversion

Sometimes, you need an integer, but the interface returns you a string, so you need to convert the data type. In Python, you can use the type function to check the data type.

I = 4.0type (I) float

When you change the type of data, it is called data type conversion. There are two types of data type conversions: implicit conversion and display conversion.

Implicit data type conversion

The data type is automatically converted and does not need to be specified, and the compiler will handle it for you. Look at the following example:

# floatx = 4 # integery = 2 z = x/ytype (z) float

In the above example, you do not have to explicitly change the data type of x to float to perform floating-point division. The compiler implicitly did this for you.

Explicit data type conversion

This type of data type conversion is user-defined, which means that you must explicitly notify the compiler to change the data types of certain entities. For example:

X = 2y = "The Godfather: Part" fav_movie = y + xTypeErrorTraceback (most recent call last) in () 1 x = 22y = "The Godfather: Part"-> 3 fav_movie = y + xTypeError: Can't convert 'int' object to str implicitly

In the above example, the compiler does not explicitly tell the data type of xforce y. The compiler thinks that x is an integer and y is a string. When you try to concatenate a string and an integer, the compiler reports an error. You can solve this problem like this:

X = 2y = "The Godfather: Part" fav_movie = (y) + str (x) print (fav_movie) The Godfather: Part 2

Python has some built-in type conversion functions: int (), float (), and str ().

Non-original data structure

The data relationships of non-original data structures are more complex, including:

Arrays

Lists

Files

Arrays

First, arrays in Python are a compact way to collect basic data types, and all entries in the array must have the same data type. However, unlike other programming languages such as C + + or Java, arrays are not commonly used in Python.

Generally speaking, when people talk about arrays in Python, they actually mean List. However, there is a fundamental difference between them. For Python, arrays can be seen as a more efficient way to store a list of data. However, the elements in the list have the same data type.

In Python, arrays are supported by the array module and need to be imported and initialized before use. Elements stored in an array are constrained by their data types. The array type is specified during array creation and is specified using a type code, which is a single character, as shown in the following example:

Import array as arra = arr.array ("I", [3je 6je 9]) type (a) array.arrayLists

Lists in Python are used to store collections of similar items. These are mutable, which means that you can change their contents without changing their identity. You can identify the list by square brackets [and], which contains elements separated by commas. Lists are built into Python: you don't need to call them separately.

X = [] type (x) listx1 = [1Magi 2Mague 3] type (x1) listx2 = list ([1mai Yuejue orange', 3]) type (x2) listprint (x2 [1]) applex2 [1] = 'orange'print (x2) [1Mague' orange', 3]

Note: just like the x1 you saw in the example above, lists can also hold heterogeneous items to satisfy the storage capabilities of the array. Unless you want to apply some specific actions to this collection.

Python provides many ways to manipulate and manipulate lists. Adding new items to the list, removing some items from the list, sorting or reversing the list is a common list operation. For example:

Use append () to add 11 to the list_num list. By default, this number is added to the end of the list.

List_num = [1, list_num.append 2, 45, 6, 6, 7, 2, 90, and 23, 435] list_char = [1, 2, 4, 5, 5, 4, 5, 5, 4, 4, 4, 4, 11] print (11) print (list_num) [1, 2, 4, 5, 6, 7, 2, 9, 23, 435, 11]

Insert data

List_num.insert (0,11) print (list_num) [11, 1, 2, 45, 6, 7, 2, 90, 23, 435, 11]

Delete element

List_char.remove ('o') print (list_char) ['canals,' oaks, 'kills,' iTunes,'e']

Delete elements based on the index

List_char.pop (- 2) # Removes the item at the specified positionprint (list_char) [list_num.sort () print (list_num) [1,2,2,6,7,11,11,23,45,90,435] list.reverse (list_num) print (list_num) [435, 90, 45, 23, 11, 11, 7, 6, 2, 2, 1] Array vs List

You may wonder why you need Array if List is so convenient, because because the data types stored in Array are consistent, you can do some special operations through simple functions. For example

Array_char = array.array ("u", ["c", "a", "t", "s"]) array_char.tostring () print (array_char) array ('upland,' cats')

You can apply the tostring () function of array_char because Python knows that all items in the array have the same data type, so the operation behaves the same on each element. Therefore, arrays are very useful when dealing with a large number of similar data types. Because Python does not have to remember the data type details of each element separately; for some purposes, arrays may be faster and use less memory than lists.

When we discuss the topic of arrays, it is also worth mentioning NumPy arrays. NumPy arrays are widely used to deal with multi-dimensional arrays in the field of data science. They are generally more efficient than array modules and Python lists. It is faster to read and write elements in NumPy arrays, and they support "vectorization" operations, such as element addition. In addition, NumPy arrays can effectively handle large and sparse data sets. For example:

Import numpy as nparr_a = np.array ([3,6] 9]) arr_b = arr_a/3 # Performing vectorized (element-wise) operations print (arr_b) [1. 2. 3.] arr_ones = np.ones (4) print (arr_ones) [1. 1. 1.] multi_arr_ones = np.ones ((3Mague 4)) print (multi_arr_ones) [[1. 1. 1.] [1. 1. 1. 1.]

In general, list data structures can be further classified into linear and nonlinear data structures. Stacks and queues are called linear data structures, while graphics and trees are nonlinear data structures. These structures and their concepts may be relatively complex, but they are widely used because of their similarity to real-world models.

Note: in linear data structures, data items are organized sequentially. Data items are traversed one after another, and all data items in the linear data structure can be traversed during a single run. However, in nonlinear data structures, data items are not organized sequentially. This means that elements can be connected to multiple elements to reflect the special relationships between these projects. During a single run, it may not be possible to traverse all data items in a nonlinear data structure.

Stack

A stack is a container for objects that are inserted and removed according to the Last-In-First-Out (LIFO) concept. Imagine a scenario where plates are always added or removed at a dinner party with a pile of plates. In computer science, this concept is used to evaluate expressions and parsing, scheduling algorithms / routines, etc.

You can use the list in Python to implement the stack. When you add an element to the stack, it is called a push operation, and when you delete or delete an element, it is called a pop-up operation. Note that when you use the stack in Python, there is actually a pop () method available:

# Bottom-> 1-> 2-> 3-> 4-> 5 (Top) stack = stack.append (6) # Bottom-> 1-> 2-> 3-> 4-> 5 (Top) print (stack) [1 Top) print (stack) [1 Top-> 2-> 3-> 4-> 5 (Top) stack.pop () # Bottom-> 1-> 2-> 3-> 4 (Top) print (stack) [1 2, 3, 4] Queue

Queues are containers for objects that are inserted and removed according to the first-in-first-out (FIFO) principle. A good example of queuing in the real world is the line at the ticket counter, which gets on the bus according to the order in which they arrive, so the first to arrive is also the first to leave.

Queues can have many different types, but only the most basic types are discussed in this tutorial. The list implementation queue is inefficient because the append () and pop () at the end of the list are fast, but the final insertion and deletion from the beginning of the list is not so fast because it requires the movement of element positions.

Graphs

In mathematics and computer science, a graph is a network of nodes, also known as vertices, which can or may not be connected to each other. The line or path that connects two nodes is called an edge. If the edge has a specific flow direction, then it is a digraph, and the directional edge is called an arc. Otherwise, if no direction is specified, the drawing is called an undirected graph.

This may sound very theoretical and can become quite complicated when you dig deeper. However, graphics is a particularly important concept in data science, which is usually used to simulate real-life problems. Social networks, molecular research in chemistry and biology, maps, and recommendation systems all rely on graphics and graphics theories. Here is an example of an Python implementation diagram:

Graph = {"a": ["c", "d"], "b": ["d", "e"], "c": ["a", "e"], "d": ["a", "b"], "e": ["b" "c"]} def define_edges (graph): edges = [] for vertices in graph: for neighbour in graph [vertices]: edges.append ((vertices, neighbour)) return edgesprint (define_edges (graph)) [('a','c'), ('a','d'), ('a','d'), ('a','e'), ('a','a') ('croup,' e'), ('e','b'), ('e','c'), ('d','a'), ('d','b')]

You can use Graph to do some cool things, such as trying to find a path between two nodes, or finding the shortest path between two nodes to determine the period in the graph.

In fact, the famous traveling Salesman problem is to find the shortest path, which visits each node only once and returns to the starting point. Sometimes the nodes or arcs of the graph have been assigned weights or costs, which you can think of as specifying the difficulty level of walking, and you are interested in finding the cheapest or easiest path.

Tree

A tree in the real world is a creature with roots on the ground and leaves and fruits on its branches. The branches of the tree unfold in an organized way. In computer science, trees are used to describe how data is organized, except for roots at the top and branches, leaves follow, spread to the bottom, and trees are drawn upside down compared to real trees.

To introduce more symbols, the root is always at the top of the tree. The other nodes that follow are called branches, and the final nodes in each branch are called leaves. You can think of each branch as a smaller tree itself. The root is often called the parent node, and the node under which it references is called the child node. A node with the same parent is called a sibling node.

Trees help define real-world scenarios, and from the game world to the design of XML parsers, and PDF design principles are based on trees. In data science, "learning based on decision tree" actually constitutes a large-scale research. There are many well-known methods, such as bagging, raising to use tree models to generate predictive models. Games like chess build a huge tree that contains all possible actions to analyze and apply heuristics to determine best practices.

Class Tree: def _ init__ (self, info, left=None, right=None): self.info = info self.left = left self.right = right def _ str__ (self): return (str (self.info) +', Left child:'+ str (self.left) +', Right child:'+ str (self.right) tree = Tree (1, Tree (2,2.1,2.2), Tree (3) Print (tree) 1, Left child: 2, Left child: 2.1, Right child: 2.2, Right child: 3, Left child: 3.1, Right child: NoneTuples

Tuples are another standard sequence data type. The difference between tuples and lists is that tuples are immutable, which means that once defined, you cannot delete, add, or edit any of the values. This may be useful if you may pass controls to others but you do not want them to manipulate the data in the collection but may only see them in a copy of the data or perform operations alone. For example

X_tuple = 1, 2, 3, 4, 5, 3, 4, 5, 3, 4, 4, 5, 3, 4, 4, 5, 2, 3, 4, 4, 5, 2, 3, 4, 4, 5, 2, 3, 4, 4, 5, 3, 4, 4, 5, 2, 4, 4, 5, 2, 4, 4, 4, 5, 2, 4, 4, 4, 5, 2, 4, 4, 4, 5, 2, 4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 4, 5, 4, 4, 5, 3, 4, 4, 5, 3, 4, 5, 3, 4, 5, 3, 4, 5, 3, 4, 5, 4, 5, 4, 5, 'e') x_tuple [0] 1y_tuple [3] x_tuple [0] = 0 # Cannot change values inside a tuple----TypeErrorTraceback (most recent call last) in () 1 Y_tuple [3]-> 2 x_tuple [0] = 0 # Cannot change values inside a tupleTypeError: 'tuple' object does not support item assignmentDictionary

If you want to implement something similar to a phone book, a dictionary is the data structure to be used. All the data structures you saw earlier do not apply to the phone book.

This is the time when a dictionary can be used. A dictionary consists of key-value pairs.

X_dict = {'Edward':1,' Jorge':2, 'Prem':3,' Elisa':4} del x_dict ['Elisa'] x_dict {' Edward':1, 'Jorge':2,' Prem':3} x_dict ['Edward'] # Prints the value stored with the key' Kevin'.1

You can apply many other built-in features to dictionaries:

Len (x_dict) 3x_dict.keys () dict_keys (['Prem',' Edward', 'Jorge']) x_dict.values () dict_values ([3,1,2]) Sets

A collection is a collection of unique objects. These are useful for creating lists that contain unique values only in the dataset. It is an unordered set, but a mutable set.

X_set = set ('CAKE&COKE') y_set = set (' COOKIE') print (x_set) {'Aids,' &', 'oaks,' ejaculations, 'cations,' K'} print (y_set) # Single unique'o' {'I'm sorry, 'oaks,' estranges,'C' 'K'} print (x-y) # All the elements in x_set but not in y_setNameError Traceback (most recent call last) in ()-> 1 print (x-y) # All the elements in x_set but not in y_setNameError: name'x'is not definedprint (x_set | y_set) # Unique elements in x_set or y_set or both {'Che,' &', 'ejaculate,' A' Print (x_set & y_set) # Elements in both x_set and y_set {'Oval,' Knight, 'Knight,' C'} Files

Files are traditionally part of the data structure. Although big data is common in the data science industry, programming languages that do not have the ability to store and retrieve previously stored information are almost useless. The syntax for reading and writing files in Python is similar to that of other programming languages, but is easier to handle. Here are some basic features that can help you work with files using Python:

Open () opens a file in the system. The file name is the name of the file to be opened.

Read () reads the entire file

Readline () reads one line at a time

Write () writes the string to the file and returns the number of characters written; and

Close () closes the file.

# File modes (2nd argument):'r' (read),'w' (write),'a' (appending), 'ritual' (both reading and writing) f = open ('file_name',' w') # Reads entire filef.read () # Reads one line at a timef.readline () # Writes the string to the file, returning the number of char writtenf.write ('Add this line.') F.close ()

The second argument in the open () function is the open file mode. It allows you to specify whether to read (r), write (w), append (a), or read and write (r +).

Summary

At this point, you have a basic understanding of the data structure of Python. After reading, you need to practice diligently.

This is the answer to the question on how to analyze the data structure of Python. I hope the above content can be of some help to you. If you still have a lot of doubts to be solved, you can follow the industry information channel to learn more about it.

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.