One place for hosting & domains

      Data

      Converting Data Types in Python


      Python is a dynamically typed language, so programmers might not always consider the type of each variable they create. However, the type of a variable is often important, and it might be necessary to convert it to another data type. This guide explains how typecasting works and illustrates how to convert data types in Python. It covers several common examples, such as how to convert an integer to a string.

      Convert Data Types in Python: An Introduction

      Python, like most programming languages, supports a wide range of data types. Python is considered a strongly typed language, so each variable always has a type. The type of a variable governs the data it can represent and constrains how it can be used. Some common Python data types include integer, float, string, list, dictionary, and set. In Python, an object’s type defines its methods and the set of operations it supports. For instance, it is possible to calculate the exponent of an integer, but not of a string. For more information about Python data types, see the
      documentation for standard types
      and
      advanced types
      .

      In addition to being strongly typed, Python is also dynamically typed. This means the type of a variable is determined only at run time. The Python interpreter does not perform any type checking in advance. In addition, the type of a Python variable can change over the course of a program. Statically typed languages such as C++ do not permit this.

      It is possible to change the data type of a variable in Python through datatype conversion. Datatype conversion allows variables to be used more effectively within the program. For example, an integer can be converted into a string, allowing it to be appended to another string. There are two different methods used to convert data types in Python.

      Implicit type conversion: Python automatically performs implicit type conversion without user intervention. It can elevate a lower-order data type, such as an integer, to a higher-order type like a float. Python can initiate this conversion because any integer can be unambiguously represented as a float. There is no chance of misinterpreting the intent of this operation. Implicit conversion avoids the loss of any data and is highly convenient. However, it does not work in all cases.

      Explicit type conversion: This is also known as typecasting. An explicit conversion must be performed manually using one of Python’s built-in methods. This is necessary when the conversion is not straightforward and the intent of the operation is not clear. Some explicit type conversions can cause data loss.

      The Python type function is used to determine the type of the data. In this example, x is of type int, while y is of type float.

      x = 10
      y = 10.01
      print(type(x))
      
      <class 'int'>
      print(type(y))
      
      <class 'float'>

      Before You Begin

      Ensure Python is already installed on your machine and you understand how to launch and use the Python programming environment. To run Python on Ubuntu, use the command python3. For more information regarding how to use Python, see the
      Linode guide to Python
      .

      Converting Integers and Floats in Python

      Both floats and integers represent numerical values. A float number has a decimal point, while an integer does not. A float can more precisely represent a number, but integers make more sense when dealing with countable values. An integer can always be represented as a float, but most floats cannot be represented as integers without a loss of precision.

      This process of converting between integers and floats is relatively straightforward, because both types represent numerical data. Additional methods exist to convert integers to other formats, such as hexadecimal strings. The following examples illustrate the main methods used to convert numerical data types in Python.

      Converting Integers to Floats

      The built-in Python function float() converts an integer to a float. It accepts a single integer and returns its float equivalent in the proper format, complete with a decimal point.

      x = 10
      z = float(x)
      print("z is", z, "and is of type", type(z))
      
      z is 10.0 and is of type <class 'float'>

      Python can automatically elevate an integer to a float using implicit type conversion. Therefore, if the result of float(x) is reassigned to x, x changes type and becomes a float.

      x = 10
      x = float(x)
      print("x is", x, "and is of type", type(x))
      
      x is 10.0 and is of type <class 'float'>

      When an integer and a float are added or multiplied together, the result is a float.

      x = 10
      y = 5.2
      z = x + y
      print("z is", z, "and is of type", type(z))
      
      z is 15.2 and is of type <class 'float'>

      This occurs even if the answer can be perfectly represented as an integer. In this example, the result is 52, but it is represented as a float containing the value 52.0.

      z = x * y
      print("z is", z, "and is of type", type(z))
      
      z is 52.0 and is of type <class 'float'>

      As of Python 3, when two integers are divided, the result is a float. The numerator and denominator are both internally pre-converted to floats before the operation. This means the result is a float even if the modulus is zero.

      Note

      Python 2 returns an integer in this case.

      x = 6
      y = 3
      z = x / y
      print("z is", z, "and is of type", type(z))
      
      z is 2.0 and is of type <class 'float'>

      Note

      The closely-related hex() and oct() methods can convert an integer to its hexadecimal or octal string equivalent.

      Converting Floats to Integers

      To convert a float data type to an integer in Python, use the int() function. This function removes the fractional component of the float, also known as the
      mantissa
      , during the conversion.

      x = 50.8
      x = int(x)
      print("x is", x, "and is of type", type(x))
      
      x is 50 and is of type <class 'int'>

      This conversion leads to some data loss. The truncated portion is not recovered even if the variable is converted back to a float.

      x = float(x)
      print("x is", x, "and is of type", type(x))
      
      x is 50.0 and is of type <class 'float'>

      To convert a float to the nearest integer, use the round() function instead.

      x = 50.8
      x = round(x)
      print("x is", x, "and is of type", type(x))
      
      x is 51 and is of type <class 'int'>

      Note

      Some information is permanently lost whenever a float is converted to an integer. This can have drastic effects on the accuracy of future calculations. Ensure you understand the implications of this data loss within the context of your program before proceeding. When in doubt, create a new variable to store the converted value.

      Converting Strings in Python

      A Python string consists of an immutable sequence of Unicode characters, and is represented internally as an array. The individual characters in a string can be accessed using string indexing, which is similar to
      how list items are accessed
      . Python string indexing is zero-based, so the index [1] refers to the second character in the string. Python provides a number of built-in methods for use in string processing and manipulation.

      Integers can be converted to strings and vice versa. Strings can also be converted to complex data types including lists, sets, and tuples. For more information on strings, see the
      Python documentation
      .

      Converting Int to String in Python

      Adding an integer and a string is more complicated than adding two numbers. The integer could potentially be treated as a string, but the string could also be converted to an integer. For instance, should the operation 14 + "12" result in the string 1412 or the numerical value 26? To resolve any confusion, a Python string and integer cannot be added together or concatenated. Both entities must have the same type. Either the integer must be changed to a string, or the string must be converted to an integer. In the following example, adding a string to an integer results in an error.

      x = 12
      y = "23"
      z = x + y
      
      Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
      TypeError: unsupported operand type(s) for +: 'int' and 'str'

      To convert an int to a string in Python, use the built-in function str(). When an integer is passed to the str() function, it is converted to a text representation of the number. The following example uses the str() function to perform type conversion on the integer variable x, allowing it to be concatenated to another string. The end result of the operation is another string.

      x = 12
      y = "23"
      z = str(x) + y
      print("z is", z, "and is of type", type(z))
      
      z is 1223 and is of type <class 'str'>

      This approach is frequently used to print text consisting of both strings and numbers. The numerical component is converted to a string when it is passed to the print() function.

      print(str(x) + y)
      
      1223

      The str() function can also be used to convert other data types, such as a float, to strings. This function accepts a floating point number and converts it to a string, with the decimal point and fractional component still intact.

      Convert String to Int in Python

      Mathematical operations cannot be performed on string objects. They must be converted to numbers first. Fortunately, Python’s built-in int() function is very flexible and can convert several data types to integers. This function accepts any string that can be converted to an integer, and returns an integer representation. If the string cannot represent an integer, Python throws an error. The following example demonstrates how to convert a string to an int in Python.

      x = "101"
      z = int(x)
      print("z is", z, "and is of type", type(z))
      
      z is 101 and is of type <class 'int'>

      This function can be used to add a string representation of an integer to an actual integer. This code sample converts the string to an integer, allowing the two numbers to be added together. This contrasts with the earlier example, which used str() to perform a string concatenation.

      x = 12
      y = "23"
      z = x + int(y)
      print("z is", z, "and is of type", type(z))
      
      z is 35 and is of type <class 'int'>

      When passing a string to int(), it is possible to add an optional argument indicating the base of the number. For instance, int("101", 2) indicates the binary string 101 is equivalent to 5 in decimal notation. It is not the integer 101. If a base is not provided, Python assumes it is a base-10 decimal number.

      x = "101"
      z = int(x,2)
      print("z is", z, "and is of type", type(z))
      
      z is 5 and is of type <class 'int'>

      Strings can also be converted to floats using the float() function. Python cannot automatically convert a float-like string to an integer. This function must be used if the string has a decimal point, and the string must represent a float.

      x = "10.00"
      z = float(x)
      print("z is", z, "and is of type", type(z))
      
      z is 10.0 and is of type <class 'float'>

      Note

      Do not confuse the int() function with ord(). ord() converts a character to its ASCII integer representation. This function uses the
      character to ASCII conversion table
      to determine the ASCII values.

      Converting Strings to Lists

      In Python, a list is an ordered array of objects. The items are mutable, so they can be changed. Items can be added, removed, or modified. Lists also have a large collection of built-in methods, providing advanced processing features. A list is enclosed in square brackets [ ] with commas separating the items. An example of a list is ['aa', 'bb', 'cc'].

      Lists and strings are conceptually very similar. Both are ordered sequences, and the individual items are accessed the same way. This makes it easy to convert a string to a list. The first letter in the string becomes item [0] in the list. The second letter becomes the second list item, and so on.

      Note

      The elements of a list can be strings or numbers, or even compound objects. However, strings can only contain a sequence of Unicode characters.
      Lists can also be converted to strings in Python
      , but the steps are more complicated.

      To convert a Python string to a list, use the list() function and provide the string as input. This results in a list containing the characters in the original string, formatted in list notation.

      x = "test"
      z = list(x)
      print("z is", z, "and is of type", type(z))
      
      z is ['t', 'e', 's', 't'] and is of type <class 'list'>

      Converting Strings to Tuples

      Strings are also easily converted to tuples. A Python tuple is almost the same as a list, except it is immutable. This means it cannot be changed after it is created. A tuple is always enclosed by parentheses ( ). It is sometimes a more efficient data structure for string processing because it includes more built-in functions.

      To convert a string to a tuple, use the tuple() function. The characters in the string become the ordered elements of the tuple.

      x = "test"
      z = tuple(x)
      print("z is", z, "and is of type", type(z))
      
      z is ('t', 'e', 's', 't') and is of type <class 'tuple'>

      Note

      Although it is relatively uncommon, a string can also be converted to a set. A set is an unordered collection of unique elements. Use the function set() and provide the string as a parameter.

      To learn more about Python tuples, see our guide
      An Introduction to Python Tuples
      .

      Conclusion

      Although Python is a dynamically-typed language, type conversion is still very important. Python frequently uses implicit type conversion to elevate an integer to a float, making certain operations easier. However, developers often have to use explicit type conversion, changing a type using Python’s built-in functions.

      This guide explains how to convert data types in Python. It is possible to convert a string to an integer in Python using the int() function, while the str() function converts an integer to a string. Integers can be converted to floats using float(), and floats can be changed to integers, although this can cause data loss. Other functions allow strings to be converted to array formats such as lists, tuples, and sets.

      More Information

      You may wish to consult the following resources for additional information
      on this topic. While these are provided in the hope that they will be
      useful, please note that we cannot vouch for the accuracy or timeliness of
      externally hosted materials.



      Source link

      Understanding Data Structures: Definition, Uses & Benefits


      Data structures are used to create efficient, clear, and organized programs. Among the best known
      data structures
      are lists and arrays. This guide introduces and defines data structures and explains why they are important. It also highlights the most important data structures and clarifies when and how each one can be used.

      What are Data Structures?

      In computer science, a data structure is a format that organizes, manages, and stores data. For a data structure to be practical, it must be relevant to the task and easy to use. Programmers should be able to quickly and efficiently store and retrieve data using the structure. Additionally, the data must be arranged in a sensible way within the context of the program. A data structure must also support useful and usable algorithms.

      The following three components define a data structure:

      • Relationships: In a data structure, elements are related or connected in some way. They follow a sequence, or are arranged in a certain format. This contrasts with an assortment of different but unrelated variables. For example, three stand-alone integers do not necessarily share any relationship.
      • Operations: Each data structure is associated with a collection of functions that can implement and manipulate it. These integrated algorithms are used to interact with the actual data. Most data structures support operations such as adding or deleting an item. However, other operations are only meaningful in certain situations. For instance, it might make sense to sort an array, but not a hash table.
      • Data Values and Type: The definition of a data structure also includes the values it contains and the type of data it allows. In some data structures, all values must have the same type, while others do not enforce any restrictions.

      Data structures are central to a logical model known as an abstract data type (ADT). While a data structure is designed and analyzed from the developer’s perspective, the ADT model is user-centric. For the user, the values and operations the ADT supports and its behavior in various situations are more important. These two perspectives do not always align, and the user is almost never aware of the internal implementation.

      Data structures are also central to Object Oriented Programming (OOP). In OOP, both the data structure and its operations are defined together in the class definition. These operations include the constructor, destructor, and methods of the class, and the API/interface. Each object encapsulates its own set of values, along with the relationships, operations, and type information from the class definition. This means every instance of a class is also a type of user-defined data structure.

      Data structures can be built into a language or developer defined. For instance, Python provides documentation about its
      core data structures
      . Low-level languages usually support only the most basic of built-in structures. But higher-level languages provide libraries for very advanced and complex data structures, including graphs and maps.

      Technically, even primary data types, such as integers, can be considered data structures. However, in everyday use, the term is reserved for compound data types, which might contain multiple items. These data structures are constructed from core data types including integers, characters, Booleans, and pointers. In most cases, a data structure includes a set of pre-defined procedures or methods to manipulate the structure. However, developers can add their own algorithms to the core data structure.

      Many essential data structures take advantage of pointers and pointer arithmetic to store and retrieve data. This aligns with the internal hardware model of the underlying system and is a very fast and efficient way to manage data. Depending on the programming language, some data types can be accessed using either a more user-friendly array subscript or the underlying memory space. A good example of this design is an array in the C programming language.

      Why are Data Structures Important?

      Data structures are essential whenever primary data types are insufficient to organize and process the data. For example, if a program is only using three pieces of data, then three separate variables are sufficient. However, if the program must handle thousands of values, it is impractical to use a different variable for each one. The program would be messy, confusing, and unmanageable. In this case, a compound data structure such as a list, array, or hash table must be used to manage the data. To generalize, data structures encourage more formal programming techniques and are indispensable for larger programs. Here are some of the main advantages of data structures.

      • Data structures allow developers to organize their data and present it in a logical manner. Because the data is handled cleanly and clearly, this results in more manageable programs containing fewer variables.
      • Data structures are programmatic building blocks that naturally encourage modular program design and professional coding practices. It is easy to develop interfaces and to pass data between functions using data structures.
      • It is often faster and more memory-efficient to use data structures. The algorithms associated with each data structure are optimized for speed and utility. For example, certain types of trees allow developers to quickly find a specific entry based on a search key.
      • Data structures lend themselves to standardized and established solutions. In many cases, the best known algorithm for a given task requires a specific data structure. The best routing algorithms all use some type of graph data structures. This reduces development and test efforts.
      • They are a shared convention between programmers. For example, most experienced developers know what trees and hash tables are and when to use them.
      • They are more readable and more maintainable.

      Data structures are widely used in computing, but they are particularly useful in the situations listed below. In certain cases, data structures were designed to solve a particular type of problem.

      • Searching: Many data structures support efficient algorithms to find a specific entry from within a longer list.
      • Storage/Scaling: Using data structures, large amounts of data can be effectively structured, organized, and stored. Several data structures are designed to interact with relational database management systems.
      • Indexing: Hash tables and some tree structures can index a long list of entries.
      • Sorting: A classic data structure called a binary search tree is often used to sort a list of unordered data into alphabetical order or some other arrangement.
      • Listing: Simple data structures such as arrays can retrieve any data items matching a set of criteria.
      • Data Transfer: Data structures are a good choice to share information through an interface or API because both client and server have a common understanding of the data. The transfer might occur between classes or functions, or between a client and a server.

      Types of Data Structures

      A handful of common data structures are used repeatedly in many circumstances, but there are many more specific alternatives. All data structures are built out of the base data types, including integers, floats, characters, pointers, and strings. Data structures can be classified as either linear or non-linear.

      Linear Data Structure Types

      In a linear data type, the individual components within the structure are arranged in sequential order. The items might be sorted based on a particular index or when they were received. Linear data types are usually straightforward to understand and implement. A program can walk through the data structure to retrieve each item. Unfortunately, linear data types are not always the most efficient choice. Their performance can degrade quickly as the size of the data set increases.

      In many cases, programming languages already provide an implementation for many of these types. Libraries can also provide additional algorithms and support for more elaborate data structures. For instance, the core Python package provides support for lists, sets, and dictionaries. However, it also has library files for stacks and queues. Here are some of the essential linear data types:

      • String: Many developers consider a string to be a basic data type, because strings are universally supported. However, they are actually a linear data type formed from individual characters. Strings are very simple to use and essential to almost every program. Although the names of variables are also strings, they are identifiers and are not a data type.
      • Array: An array is a list of items in sequential order. Almost every language supports some type of array, but in most cases, all items must be of the same type. Arrays can be either immutable and fixed, or mutable and able to be changed. Some implementations allow the size of the array to change so items can be added or removed. In most languages, an array subscript is used to access the individual items. This usually involves some type of bracketing mechanism. The brackets enclose the position of the item within the array, for example [6].
      • Stack: A stack is a list that is written and read in a last in first out (LIFO) order. Each new item is “pushed” onto the top of the stack. When the stack is later accessed, the most recent entry is “popped” off the stack. Stacks can be implemented using a basic array, but they can also use another format. They are especially useful for evaluating mathematical expressions and in compilers.
      • Queue: Queues are very similar to stacks, except they follow a first in first out (FIFO) format. The next item to be popped from a queue is always the oldest item. Queues are the best option for scheduling purposes and for processing incoming client requests. Some applications use multiple queues for scheduling items of differing priorities. The high-priority queue is serviced first, even if items in the lower-priority queues have been waiting longer.
      • Linked List: Linked lists are a versatile and memory-efficient data structure. In addition to storing data, each node also points to the next node. This is accomplished through the use of pointers containing the memory address of the next entry. Linked lists can easily expand and shrink to accommodate lists of variable lengths. However, it is difficult and time-consuming to access a specific item. In the worst case, which occurs when the item is the last entry, every node must be visited. Some linked lists are bidirectional, so the items can also be traversed in reverse order.

      Non-Linear Data Structure Types

      Non-linear data structures are organized around the relationships between the individual nodes. The collection of items do not share a consistent sequence. These relationships are often hierarchical. Each parent entry has one or more children. However, some non-linear data types summarize relationships without any hierarchy.

      These data structures are more complicated and are often more difficult to work with. They are not as frequently built into a language, so a library or user-based implementation might be required. However, these data structures can store information efficiently and find individual entries very quickly. The run time for any algorithms operating on these data structures does not change dramatically as the number of items increases. They can therefore be applied to very large data sets. Here are some of the more common non-linear data structures.

      • Graph: Graphs describe the connections between individual entries, known as vertices. Each vertex is connected to one or more other vertices by edges. Related vertices share an edge, while unrelated vertices do not. The edges might have weights, indicating the cost, distance, or intensity of the relationship. The map of vertices and edges fully describes the topography of the domain. Graphs are often used for routing and mapping. A spanning tree is an important internal graphing structure. It connects all nodes in the graph together without any cycles.
      • Tree: A tree is a particular type of graph where there is only one possible path between any two nodes. This means trees cannot contain loops, nor is it possible to visit each node on a tree without extensive backtracking. Trees have a unidirectional hierarchical structure. At the top level, a parent “root” vertex has one or more children. Each of those child nodes can also have children. Trees are frequently used to represent directories or to sort and search data. There are many types of trees including binary search trees, AVL trees, B-trees, and red-black trees. Many domain-specific trees have been developed. For instance, a trie is a type of tree for storing prefixes. It is used for dictionaries and for finding items.
      • Heap: A heap is a special type of tree. The value stored in the parent node is either less or more than all of its children. This relationship holds for each node at every level of the heap. Heaps are a good choice for ordering and organizing data. But they frequently have to be rebalanced when nodes are added or removed. So they are better suited for relatively static data sets.
      • Record: A record is a list of key-value pairs. Each of the keys, or fields, contains a value. The different values are not required to have the same type. However, a value can potentially be another record, leading to a nested structure. Records can potentially support a large number of fields, but they can become inefficient as the number of pairs grow. Records are used in databases and can serve as a container for related information. A good example might be all relevant information about a customer or an employee. In object-oriented programming, each instance of a class is technically a record.
      • Hash Table: A hash table is an associative array. Each key, or index, inside a hash table maps to a set of values, known as a bucket. The key for each entry is calculated using a hash function. Hash functions vary in complexity. A number might be hashed by dividing it by a smaller number and taking the remainder as the hash key. Some hash tables assign each entry to its own bucket, but many implementations allow collisions where more than one key has the same index. There is always a tradeoff between the size of the table and the speed of entry lookups, but certain formulas are known to approximate the best compromise. Hash tables have many uses including database indexing, compilers, and caches.

      How to Choose a Data Structure for Your Next Project

      Each data structure is best suited to a certain set of tasks, and should complement the necessary data operations. A mismatch between the task and the structure might make a program less efficient or more confusing, so it is important to choose correctly. Additionally, the same information can be represented using various data structures. For instance, an ordered list can be structured as an array, or some variant of a tree. The tree is more efficient, but for a small data set, an array might be easier to use.

      Some data structures are very common in certain contexts. For example, compilers almost always use hash tables to look up the type and current value of variables. Some data structures were originally designed for a single task. Here are some issues to consider when choosing a data structure.

      • Storage capacity: Certain data structures are very convenient and easy to use, but use up more memory. In a memory-constrained environment, minimalist data structures like linked lists are more useful.
      • Performance requirements: Arrays are simple, but it can take longer to search for an individual item. Pointer-based tree structures or hash tables are often quicker. Developers must always consider the performance requirements for their application. There are often trade-offs to be made, but inefficient data structures and algorithms can quickly become unusable. This issue is related to
        Big O notation
        . The Big O value of an algorithm describes how the execution time increases as the size of the data set grows.
      • The type of data: The type and nature of the data often dictates the data structure. Ordered and unordered data benefit from different structures. Simple data items such as a series of integers can be stored in an array. However, a graph can better handle a list of connections between items.
      • How the data is used: It is important to consider how the data is used when selecting a data structure. If the data is repeatedly accessed or updated, a more efficient data structure is required.
      • Ease of use: Some data structures are easy for inexperienced programmers to implement and use. For simple internal applications without stringent performance requirements, it is usually better to use straightforward structures.
      • Permanence: Transient information that should not be saved might be stored in an efficient manner. Stored data is best handled using a data structure that promotes easy access.

      A decision about what data structure to use is often based on several factors. In many cases, there is not one perfect choice. Below are a couple of examples demonstrating how a data structure can be chosen.

      If all items from an unordered list must be read and later processed once, then an array is an effective and simple choice. Arrays are quite fast in this context, they can scale, and they are easy to use.

      However, if the relationships between these items are of great significance, then the more complicated graph data structure is the only reasonable choice. Graphs are designed to illustrate the connections between items in a fast and memory-efficient manner. Unfortunately, they are one of the more complicated data structures and it takes some practice to effectively use them.

      Conclusion

      The definition of a data structure is “a data format that helps developers organize, manage, and store information”. Computer data structures are described by the relationships between the items, the operations supported by the structure, and the actual values of the items. Developers often create new data structures and algorithms for an application, but many structures are built into the main programming languages.

      Some data structures are linear. This means the items are arranged in sequential order. Others are non-linear and should be used when the relationships between items is important. The most widely-used data structures include arrays, stacks, queues, records, trees, graphs, linked lists, and hash tables. There are many factors involved in choosing a data structure to use. However, memory use, performance, and ease of use are the most important. If you’d like to try out some of the data structures discussed in this guide, visit our documentation library’s
      Python section
      . This section includes guides on various primary data types and linear data types in Python.

      More Information

      You may wish to consult the following resources for additional information
      on this topic. While these are provided in the hope that they will be
      useful, please note that we cannot vouch for the accuracy or timeliness of
      externally hosted materials.



      Source link

      Kubernetes Data Protection and Recovery Made Easy


      How to Join

      This Tech Talk is free and open to everyone. Register below to get a link to join the live stream or receive the video recording after it airs.

      Date Time RSVP
      December 7, 2021 11:00 a.m.–12:00 p.m. ET / 4:00–5:00 p.m. GMT

      About the Talk

      Protect or migrate your Kubernetes container environments across any public/hybrid cloud with a 1-Click install that lets you backup and restore your entire app.

      Discover why cloud-native data protection is important for your app, and how you can get enterprise-grade backup and recovery for free, with TrilioVault for Kubernetes.

      What You’ll Learn

      • Differences between an enterprise-grade Kubernetes data protection platform and Velero
      • How to backup your entire application, including data, metadata, and any other Kubernetes objects associated with your application
      • How to restore data from any point in time

      This Talk Is Designed For

      • Anyone that wants to protect or migrate your Kubernetes container environments across a public or hybrid cloud
      • DigitalOcean Kubernetes users looking to satisfy data protection requirements

      Resources

      1-Click install: TrilioVault (TVK) for Kubernetes
      TVK is a cloud-native, application-centric data protection platform that offers backup and recovery of your entire application, including data, metadata, and any Kubernetes objects associated with the application – all of which can be restored with a single click.

      Technical documentation for TrilioVault

      Video: Installing TrilioVault on DigitalOcean



      Source link