Sequence data part 3

Summary

The video script is a comprehensive tutorial on Python's sequence data operations. It covers slicing techniques for lists, strings, tuples, and bytes, explaining how to extract elements using start, stop, and step indices. The tutorial also explores concatenation and multiplication of sequences, emphasizing the distinction between mutable and immutable data types. It concludes with practical examples of applying these operations to manipulate and analyze sequence data effectively.

Takeaways

• 😀 The lecture introduces the concept of slicing in sequence data, emphasizing its utility in accessing and manipulating parts of a sequence.
• 🔍 Slicing in Python uses the syntax `sequence[start:stop:step]`, where `start`, `stop`, and `step` are optional parameters defining the slice's beginning, end, and increment, respectively.
• ✂️ The slice object is created without modifying the original sequence, allowing for efficient data handling and extraction of subsequences or elements.
• 🔢 Default values for slicing are `start=0`, `stop=end of sequence`, and `step=1`, which means the slice includes elements from the beginning to the end, one by one.
• 🔄 Negative indices in slicing refer to positions from the end of the sequence, with `-1` being the last element.
• 📝 For non-sequential data like dictionaries, slicing is not applicable as it requires an ordered data type to function.
• 🔄 Slicing can be performed on lists, tuples, and strings, allowing for the extraction of sublists, sub-tuples, and substrings respectively.
• 🔢 The lecture demonstrates how slicing can be used to perform operations like string repetition and list multiplication using the `*` operator.
• 📚 Examples are provided to illustrate the practical application of slicing, such as extracting specific parts of a string or list based on given indices and conditions.
• 💡 The importance of understanding slicing is highlighted for efficient data manipulation, especially when dealing with loops and large datasets.

Q & A

What is the primary topic discussed in the script?

The primary topic discussed in the script is the concept of slicing in sequence data, including strings, lists, tuples, and bytes, along with their applications in Python programming.

What does the term 'slicing' refer to in the context of the script?

In the context of the script, 'slicing' refers to the operation of extracting a portion of a sequence by specifying a range using start, stop, and step indices.

What are the three parameters typically used in a slice operation?

The three parameters used in a slice operation are the start index, the stop index, and the step value, which determine the beginning, end, and interval of the elements to be sliced from a sequence.

How does the script demonstrate slicing a string?

The script demonstrates slicing a string by using the slice function with start and stop indices, and it shows how to obtain a substring from a given string using this method.

What is the default step value in a slice operation if not specified?

The default step value in a slice operation if not specified is 1, which means each element in the sequence is visited once in the slice.

Can you use negative indices in slicing, and what does it represent?

Yes, negative indices can be used in slicing, and they represent positions from the end of the sequence, with -1 being the last element.

How does the script handle the situation when the stop index in a slice operation is beyond the sequence length?

The script handles the situation by stopping the slice at the end of the sequence, not going beyond its length.

What is the purpose of the step value in slicing, and how does it affect the output?

The step value in slicing determines the interval between elements selected in the slice. A step value greater than 1 will result in selecting every nth element, where n is the step value.

How does the script explain the difference between a list and a tuple when it comes to slicing?

The script explains that both lists and tuples can be sliced in the same way, but lists are mutable, meaning the sliced list can be modified, while tuples are immutable, so the sliced tuple cannot be changed.

What is the significance of the sequence protocol mentioned in the script?

The sequence protocol mentioned in the script is significant because it allows objects to support operations that depend on indexing, such as slicing, by defining methods like `__len__` and `__getitem__`.

Can you provide an example from the script where slicing is used to create a new list from an existing one?

Yes, the script provides an example where slicing is used to create a new list from an existing one by specifying the start and stop indices within the square brackets of the list.

Outlines

00:00

🔡 Introduction to Sequence Data and Slicing

The speaker welcomes the audience to a lecture on sequence data, focusing on the manipulation of such data through various operations. They introduce the concept of slicing, which is a method to extract parts of a sequence. The slicing operation is performed using a slice object that can take different types of sequences like strings, tuples, bytes, lists, or even a sequence protocol supporting any object. The slice object is defined by a start, stop, and step, which dictate the range and interval of the elements selected from the sequence. The speaker explains how to use the slice object with different parameters to extract the desired elements from a sequence, including default values and how to handle negative indices.

05:01

🔧 Practical Demonstration of Slicing Operations

The speaker proceeds with a practical example to demonstrate slicing operations. They create a string 'strassampel' and use slicing to extract a substring 'learning' from it. The explanation covers how to use the slice function with start and stop values, including the use of step values to skip elements. The speaker also clarifies the output of the slicing operation, emphasizing how it stops before the stop index and how the step value affects the output. They also touch upon the concept of increment values and how to interpret them in the context of slicing.

10:02

📝 Exploring Slicing with Different Data Types

The speaker explores slicing with different data types, including sequences like strings and non-sequence data types like dictionaries. They explain that slicing can be applied to any iterable object that supports the sequence protocol. The speaker also discusses the limitations of slicing with non-sequence data like dictionaries and sets, explaining that these data types do not maintain order and hence slicing is not applicable in the traditional sense. They further illustrate how slicing can be used with lists and how it can be combined with other operations like loops for more complex data manipulation.

15:04

🔄 Combining and Manipulating Sequence Data

The speaker discusses how to combine and manipulate sequence data using operations like addition and multiplication. They provide examples of how to concatenate strings and lists, and how to repeat elements in a sequence using multiplication. The speaker also covers the potential errors that can occur when attempting to perform these operations on incompatible data types, such as adding a string to a list. They emphasize the importance of ensuring that the data types are compatible before performing such operations.

20:05

🔢 Advanced Operations on Sequence Data

In the final part of the lecture, the speaker delves into more advanced operations on sequence data, such as multiplication and exponentiation. They demonstrate how to repeat elements in a sequence multiple times and how to handle different data types when performing these operations. The speaker also provides examples of how to multiply elements in a list by a certain factor and how to update the original list accordingly. The lecture concludes with a summary of the various slicing and manipulation techniques discussed, along with a preview of upcoming topics that will cover more complex data structures and operations.

Keywords

💡Slicing

Slicing in the context of the video refers to the operation of extracting a portion of a sequence data type such as a string, list, or tuple. It is a fundamental concept in Python programming and is crucial for manipulating and accessing elements within these data structures. The script mentions slicing as a way to handle sequence data, showcasing how to use the slice function with start, stop, and step parameters to obtain a subset of the data.

💡Sequence Data

Sequence data types are central to the video's discussion. These include strings, lists, tuples, and bytes, which are ordered collections of items that can be accessed by an index. The script explains how slicing can be applied to sequence data, emphasizing the importance of understanding these data types for data manipulation and extraction in programming.

💡Start, Stop, and Step

These terms are parameters used in slicing operations to specify the range of elements to extract from a sequence. 'Start' indicates the beginning index, 'stop' is the ending index, and 'step' determines the interval between elements. The video script provides examples of how these parameters can be used to control the slicing process, which is essential for precise data extraction.

💡String Manipulation

String manipulation involves operations performed on strings to transform, extract, or combine them. The video script uses string manipulation as an example to illustrate slicing, showing how to create substrings from a given string using slicing techniques. This is a common task in programming, particularly when handling text data.

💡Increment Value

The increment value in slicing refers to the step parameter, which determines the interval between elements in the sliced sequence. The script explains that by default, the increment value is 1, meaning each element is selected. However, it can be adjusted to skip elements or select them more frequently, which is demonstrated with examples in the video.

💡List Comprehension

List comprehension is a concise way to create lists in Python. The video script touches upon list comprehension as an alternative to slicing when specific elements or conditions are required. It is a powerful feature for creating new lists by applying an expression to each item in a sequence and is used for its efficiency and readability.

💡Non-sequential Data

Non-sequential data, such as dictionaries and sets, do not maintain the order of elements. The script points out that slicing, which relies on order, cannot be directly applied to non-sequential data types. This distinction is important for understanding the limitations of slicing and the need for different approaches when working with unordered data structures.

💡Concatenation

Concatenation is the process of joining two or more sequences together. In the video script, concatenation is discussed as a way to combine strings or lists. It is a common operation in programming, used to merge data from different sources, and the script provides examples of how to concatenate different data types.

💡Data Operations

Data operations encompass a range of actions performed on data, such as addition, multiplication, and other transformations. The video script covers data operations like concatenation and multiplication (repeating elements) on sequences, demonstrating how these operations can be used to manipulate and process data effectively.

💡Indexing

Indexing is the method of accessing elements in a sequence by their position. The script explains how indexing works in Python, using both positive and negative indices to access elements from the start or end of a sequence. Understanding indexing is fundamental to slicing and other data manipulation techniques in programming.

💡Data Structures

Data structures are specialized formats for organizing, processing, and storing data. The video script discusses various Python data structures like lists, tuples, and sets, highlighting their properties and how they can be manipulated using slicing and other operations. Data structures are crucial for efficient data management in programming.

Highlights

Introduction to sequence data and operations that can be performed on it.

Explanation of the slice operation and its usage in accessing elements of a sequence.

The role of start, stop, and step in the slicing operation.

How to use the slice function with different arguments for sequence data.

The concept of default increment value in slicing and how to specify it.

Demonstration of slicing a string to obtain a substring.

Use of slicing to extract elements from a sequence based on a specified range.

Explanation of how slicing works with negative indices and steps.

The impact of the increment value on the slicing operation.

How to perform slicing on lists to extract elements or sub-lists from a sequence.

Difference between using square brackets and colon operators for slicing.

The behavior of slicing when applied to dictionaries and sets.

Practical examples of using slicing to manipulate sequence data.

Discussion on the limitations of slicing with non-sequential data types.

Explanation of how to concatenate sequences using the plus operator.

Illustration of combining sequences using various data operations.

The concept of performing multiplication operations on sequence data.

How to use indexing and slicing to access and manipulate specific elements in a sequence.

Summary of the lecture's key points on handling sequential data operations.

Transcripts

సీక్వెన్స్‌ డాటా పై ఉపన్యాసానికి

అందరికీ స్వాగతం. మరియు ఈ ఉపన్యాసంలో

మనం నిర్వహించగల కొన్ని కార్యకలాపాలను

చూడబోతున్నాం ఒక క్రమం డేటా మీద. కాబట్టి,

స్లైసింగ్తో ప్రారంభిద్దాం. కాబట్టి, ఇచ్చిన

క్రమాన్ని ముక్కలు చేయడానికి స్లైస్

ఆబ్జెక్ట్ ఉపయోగించబడుతుంది. మరియు క్రమం స్ట్రింగ్

కావచ్చు, క్రమం స్ట్రింగ్ టపుల్స్, బైట్లు,

జాబితా లేదా పరిధి కావచ్చు

లేదా సీక్వెన్స్ ప్రోటోకాల్ కు మద్దతు

ఇచ్చే ఏదైనా వస్తువు. మరియు స్లైస్ వస్తువు

సూచికలను సూచిస్తుంది ప్రారంభ స్టాప్ మరియు

దశ విలువ ఇచ్చిన శ్రేణి ఫంక్షన్ ద్వారా

పేర్కొనబడింది. స్లైస్ ఆపరేషన్ యొక్క స్లైస్

ఆబ్జెక్ట్ యొక్క వాక్యనిర్మాణం ఇక్కడ

ఇవ్వబడింది మరియు వాక్యనిర్మాణం స్లైస్

ఫంక్షన్ కోసం ఇక్కడ ఇవ్వబడింది. కాబట్టి,

మీరు స్లైస్ ఆఫ్ స్టాప్ను ఉపయోగించవచ్చు

లేదా మీరు స్లైస్ ఆఫ్ స్టార్ట్ స్టాప్

అండ్ స్టెప్ను ఉపయోగించవచ్చు. కాబట్టి,

ప్రాథమికంగా స్లైస్ ఫంక్షన్ రెండింటిలోనూ

ఒకే అర్ధాన్ని కలిగి ఉన్న మూడు వాదనలను

తీసుకుంటుంది. కాబట్టి, మొదటిది ప్రారంభం,

ఇది ప్రారంభ పూర్ణాంక విలువ, ఇక్కడ స్ట్రింగ్

అనేది ఒక పూర్ణాంక విలువ, ఇది ప్రారంభాన్ని

సూచించే పూర్ణాంక విలువ ఎక్కడ నుండి

ఐతే ఆబ్జెక్ట్స్‌ స్లైసింగ్‌ మొదలు

అవుతుందో కాబట్టి, మొదటి వాదన ప్రారంభం.

కాబట్టి, అది స్లైసింగ్ ఉన్న ప్రారంభ పూర్ణాంకం

వస్తువు యొక్క ప్రారంభం తదుపరిది పైన ఉంటుంది,

ఇది ముక్కలు చేసే వరకు ఒక పూర్ణాంకం

స్థలం. కాబట్టి స్లైసింగ్ ఇండెక్స్ n మైనస్

1 లేదా మైనస్ 1 వద్ద ఆగిపోతుంది. కాబట్టి,

ఉదాహరణకు I రెండవ వాదనను 4 గా ఇచ్చాము

అంటే అది స్టాప్ విలువ. కాబట్టి, ఇది

వెళుతుంది నాకు ఇప్పటికీ 3 విలువల క్రమాన్ని

ఇవ్వండి. కాబట్టి, తదుపరిది ఒక పూర్ణాంక

విలువను నిర్ణయించే దశ. స్లైసింగ్ కోసం

ప్రతి సూచిక మధ్య పెరుగుదల.

కాబట్టి, ఉదాహరణకు మీరు 2 ఇస్తుంటే, మీరు

పొందుతారు, కాబట్టి, మీరు పొందుతారు దశ

పరిమాణం 2 లో విలువలు. కాబట్టి, డిఫాల్ట్గా

మీరు ఏమీ ఇవ్వకపోతే అది చేయబోతోంది దానిని

ఇంక్రిమెంట్ విలువగా 1 గా తీసుకోండి, కానీ

మీరు ఏదైనా విలువను అందిస్తున్నట్లయితే

అది కొనసాగుతుంది. దానిని ఇంక్రిమెంట్

విలువగా పరిగణించండి. కాబట్టి, ఈ ఉదాహరణతో

ప్రారంభిద్దాం స్ట్రింగ్. కాబట్టి, మనము ఇప్పటికే

స్ట్రాసాంపిల్ అనే స్ట్రింగ్ను సృష్టించాము,

దీనికి స్ట్రింగ్ ఉంది నేర్చుకోవడం.

కాబట్టి, ఇప్పుడు నా లక్ష్యం ఇచ్చిన

స్ట్రింగ్ స్ట్రాసంపుల్ నుండి సబ్స్ట్రింగ్ను

పొందడం.

ఇచ్చిన స్ట్రింగ్ ఇచ్చిన స్ట్రింగ్

లెర్నింగ్ నుండి నేర్చుకుంటుంది.

కాబట్టి, అలా చేయడానికి మనం స్లైస్ వస్తువును

ఉపయోగించవచ్చు. కాబట్టి, స్ట్రాసంపుల్ లో

నేను I యొక్క స్లైస్ ని ఉపయోగిస్తున్నాను

స్క్వేర్ బ్రాకెట్ల లోపల స్లైస్ ఫంక్షన్ను

ఉపయోగిస్తున్నాను, తరువాత స్లైస్ ఫంక్షన్

లోపల I నేను కేవలం మూడు విలువలను ఇస్తున్నాను,

ఒకటి స్టార్ట్ స్టాప్ మరియు స్టెప్ విలువ.

కాబట్టి, ఇక్కడ అవుట్పుట్ నేను ఇప్పటికే ఎర్

అని ముద్రించాను, ఇది నేర్చుకోవడం

నుండి ఇ మరియు ఆర్. కాబట్టి, ప్రాథమికంగా

మనకు ఉంది ప్రారంభ సూచికను ఒకటిగా పేర్కొనడం

ద్వారా అది వచ్చింది. కాబట్టి, వాస్తవానికి

స్లైసింగ్ నుండి ప్రారంభమైంది e మరియు

ఇది వాస్తవానికి ఇండెక్స్ 4 వద్ద ముగుస్తుంది,

అప్పుడు ఇది 2,3 మరియు 4 అవుతుంది. కాబట్టి,

n కి ఇండెక్స్ 4 ఉంటుంది, కానీ వాస్తవానికి

ఇది మీకు n మైనస్ 1 వరకు ఇస్తుంది. కాబట్టి,

ఇది r వద్ద ఆగిపోతుంది మరియు నేను ఇంక్రిమెంట్

విలువను 2 గా ఇచ్చినందున అది జరగదు. మీకు e

నుండి తీగల క్రమం యొక్క అన్ని క్రమాన్ని

ఇస్తుంది, ఎందుకంటే ఇది మీకు ఇవ్వదు

స్ట్రింగ్స్ యొక్క క్రమం e a r గా కాకుండా

ఇది మీకు పరంగా క్రమాన్ని ఇవ్వబోతోంది

తీగలను రెండు పెంచడం ద్వారా . కాబట్టి,

ఇది మీకు r గా మాత్రమే ఇవ్వబోతోంది. కాబట్టి,

ఇది మీకు అవుట్పుట్ను e r గా మాత్రమే ఇవ్వబోతోంది.

కాబట్టి, ఈ విధంగా స్లైసింగ్ ఆపరేటర్.

కాబట్టి, ఇచ్చిన క్రమాన్ని ముక్కలు

చేయడానికి మనం స్లైస్ ఫంక్షన్ను ఈ విధంగా

ఉపయోగిస్తాము. ఇచ్చిన స్ట్రింగ్ లేదా ఏదైనా

సీక్వెన్స్ నుండి ఎలిమెంట్స్ లేదా

సబ్స్ట్రింగ్ల ఇచ్చిన సీక్వెన్స్ వస్తువు.

మరియు ఇతర పద్ధతి ఎలిమెంట్స్ లేదా

సబ్స్ట్రింగ్లను ముక్కలు చేయడానికి

ఇతర పద్ధతి. ఇచ్చిన వస్తువు నుండి చదరపు

బ్రాకెట్ను ఉపయోగిస్తున్నారు. మీరు స్లైస్ ఫంక్షన్ను

ఉపయోగించాల్సిన అవసరం లేదు.

దాని లోపల మీరు స్లైస్ ఫంక్షన్ లేదా కోలన్

ఆపరేటర్ను ఉపయోగించవచ్చు. ఇక్కడ నేను చదరపు

బ్రాకెట్ లోపల ఒక కోలన్ను మాత్రమే

ఉపయోగిస్తున్నాను. కాబట్టి, అది నాకు

అన్ని సబ్స్ట్రింగ్లను ఇస్తుంది నేర్చుకునే

స్ట్రింగ్ లెర్నింగ్ నుండి. కాబట్టి, కేవలం

పెద్దప్రేగును ఉంచడం ద్వారా ఇవ్వడం ద్వారా

చదరపు బ్రాకెట్ల లోపల నాకు పూర్తి

తీగల సమితి అయిన అభ్యాసాన్ని తెస్తుంది

ప్రధాన స్ట్రింగ్ నుండి ఇది స్ట్రాసాంపుల్.

కాబట్టి, ఈ విధంగా మేము ముక్కలు చేస్తాము

స్ట్రింగ్ క్రమం డేటా. కాబట్టి, ప్రాథమికంగా

మనం ఏదైనా ఆపరేషన్లు చేయాలనుకున్నప్పుడల్లా

స్లైసింగ్ను ఉపయోగిస్తాము. మీ స్ట్రింగ్లోని

ఒక నిర్దిష్ట మూలకాల సమూహంపై లేదా మీ

దేనిపైనా లేదా దానిని క్రమం డేటా పైనా

వర్తింపజేయవచ్చు కాబట్టి, జాబితా

నుండి అన్ని విలువలు మీ గణన ఆధారంగా లేదా

ఆధారంగా సవరించబడవు. మీ ఆపరేషన్లో నిర్దిష్ట

మూలకాలు లేదా సబ్స్ట్రింగ్లు మాత్రమే సవరించబడతాయి.

మీరు దానిపై నిర్వహిస్తున్న కార్యకలాపాల ఆధారంగా.

అదేవిధంగా మనం స్లైసింగ్ చేయవచ్చు

ఏదైనా ఇతర సీక్వెన్స్ డేటాలో ఆపరేషన్లు

ఉదాహరణకు వివరించడానికి తదుపరి ఉదాహరణ మీరు

జాబితాలో ఉన్నారు. కాబట్టి, స్లైసింగ్

చేసేటప్పుడు జాబితాలు ప్రాథమికంగా డిఫాల్ట్

కార్యాచరణను కలిగి ఉంటాయి. కాబట్టి,

ఇక్కడ జాబితా నమూనా క్రింద ఉన్న వాటిని

ప్రింట్ చేద్దాం, కాబట్టి ఇవి ఈ విలువలు

మొదటి నమూనా 1 2 a సామ్ మరియు 2 క్రింద ఉన్న

మూలకాలు. కాబట్టి, ఇప్పుడు నేను ప్రదర్శన

ఇవ్వబోతున్నాను జాబితా నమూనాలో కత్తిరించడం.

కాబట్టి, ప్రాథమికంగా మొదటి పెద్దప్రేగుకు

ముందు వాల్యూమ్ లేకపోతే ఉదాహరణకు ఇలా నేను

మొదటి పెద్దప్రేగుకు ముందు ఎటువంటి విలువను

ఇవ్వలేదు మరియు నేను ఇచ్చాను

పెద్దకోలన్‌ తర్వాత విలువ ఆ సందర్భంలో

అది జాబితా యొక్క ప్రారంభ సూచిక నుండి

ప్రారంభించాలి. దీని అర్థం జాబితా యొక్క

ప్రారంభ సూచిక వద్ద ముక్కలు చేయడం ప్రారంభించడం.

కాబట్టి, ఏమిటో చూద్దాం మనం కోలన్ 3ని ఉపయోగించినప్పుడు

ఇది జరుగుతుంది. కాబట్టి, అవుట్పుట్

ఇక్కడ ఇవ్వబడింది. కాబట్టి, ఈ స్లైసింగ్

ప్రారంభమైంది సూచిక 1 నుండి. కాబట్టి,

స్లైసింగ్ జాబితా ప్రారంభం నుండి ప్రారంభమైంది

1 మరియు తదుపరి విలువ స్టాప్ విలువ. కాబట్టి,

0 1 2 3 ఇది మీకు సబ్ ఇవ్వబోతోంది.

జాబితా నుండి సామ్ వరకు లేదా అంతకు

ముందు ఉన్న అంశాలు. కాబట్టి, మనకు అవుట్పుట్

1 2 మరియు a గా వచ్చింది. ఇండెక్స్ స్టాప్

ఇండెక్స్ 3 వద్ద ఉన్నందున ఇది మీకు విలువను

ఇవ్వబోతోంది ఇది మీకు మూలకాల క్రమాన్ని

లేదా ఉప మూలకాల క్రమాన్ని ఇవ్వబోతోంది మూడవ

సూచికకు సరిగ్గా ముందు ఉన్న మీ ప్రధాన

జాబితా అంటే 1 2 మరియు a. మరో విషయం ఏమిటంటే

ఇక్కడ గమనించండి, మీరు మొదటి కోలన్

తర్వాత ఈ విధంగా విలువను అందించకపోతే,

దాని అర్థం సూచిక 2 నుండి ప్రారంభించి

జాబితా ముగింపు వరకు వెళ్ళడానికి. కాబట్టి,

నేను కేవలం చెప్తున్నాను

సూచిక 2 నుండి ప్రారంభించి, జాబితా ముగింపు వరకు

వెళ్ళడానికి మరియు ప్రాథమికంగా ఈ సమయాన్ని

ఆదా చేస్తుంది. కాబట్టి, ప్రాథమికంగా a యొక్క

పొడవును మనం మాన్యువల్గా పేర్కొనవలసిన అవసరం

లేదు. కాబట్టి, ఇది ఆదా చేస్తుంది మాకు

సమయం. కాబట్టి, మనము లెన్ యొక్క లెన్

యొక్క పొడవును మానవీయంగా పేర్కొనవలసిన అవసరం

లేదు అది జాబితా ముగింపు అని పేర్కొనడం

లేదా పేర్కొనడం లేదా పేర్కొనడం జాబితాలో

ఎన్ని అంశాలు ఉన్నాయో తనిఖీ చేయండి. కాబట్టి,

దానిని వదిలించుకోవడానికి మీరు కేవలం మొదటి

నిలువు వరుస తర్వాత మీరు ఏమీ పేర్కొనాల్సిన

అవసరం లేదు. తద్వారా, ఇది మీ జాబితా ముగింపు

వరకు అన్ని ఉప అంశాలను స్వయంచాలకంగా తీసుకుంటుంది.

కాబట్టి, ఈ

జాబితాలోని స్లైసింగ్ ఆపరేషన్ను మనం ఎలా

నిర్వహిస్తాము. కాబట్టి, ఇక్కడ మీరు గమనించినట్లయితే

నేను స్లైస్ ఫంక్షన్ను ఉపయోగించలేదు, బదులుగా

నేను కలిగి ఉన్నాను కేవలం ఇవ్వడం ద్వారా

వేరు చేయడం ద్వారా జాబితా నుండి ఉప

మూలకాలను ముక్కలు చేయడానికి కోలన్

ఆపరేటర్ను ఉపయోగించారు కోలన్ ఆపరేటర్ను

ఉపయోగించే విషయంలో ప్రారంభ స్టాప్ మరియు

దశ విలువ. మరియు మీరు గుర్తుంచుకోగలిగితే

స్లైస్ ఫంక్షన్ లోపల స్లైస్ ఎంపిక లోపల

మీరు ఇక్కడ ఇచ్చే ఏ ఆర్డర్ అయినా ఇక్కడ

ఇవ్వండి

అదే ఇక్కడ వర్తిస్తుంది కానీ స్లైస్ ఫంక్షన్ను

ఉపయోగించే బదులు నేను స్క్వేర్ను

బ్రాకెట్‌ ను ఉపయోగించాను. మరియు నేను 2 కోలన్

3 కోలన్ 1 ఇస్తే, ప్రారంభ సూచిక ప్రారంభమవుతుందని

అర్థం 2 మరియు ముగింపు సూచిక 3 మరియు ఇంక్రిమెంట్

విలువ 1 కానీ మీరు లేకుండా కూడా పేర్కొనవచ్చు

నాకు 2 నుండి అన్ని విలువలు అవసరమని

మరియు నాకు అన్నీ అవసరమని సూచించడానికి

ఏదైనా విలువను ఇవ్వడం కూడా విలువలు 3 వరకు

ఉంటాయి. ఉదాహరణకు ఇది ప్రారంభ విలువ

మరియు స్టాప్ విలువ అవుట్పుట్ ఏమిటో

తనిఖీ చేద్దాం? కాబట్టి, స్లైసింగ్ ఆపరేషన్

జాబితా యొక్క సూచిక 2 నుండి జరుగుతుంది,

ఇది 0 1 2 నుండి

a అనేది 4 3 మరియు 4 వరకు ఉంటుంది మరియు ఇది

4ని సూచికగా పరిగణించదు కానీ అది కేవలం పరిగణించబడుతుంది

n మైనస్ 1 వరకు. కాబట్టి, అది 3 అవుతుంది. కాబట్టి,

ఇది మీకు అవుట్పుట్గా a మరియు సామ్ ఇవ్వబోతోంది.

కాబట్టి, ఇది స్పష్టంగా ఉందని నేను ఆశిస్తున్నాను.

కాబట్టి, మరొక వైపు వరుస డేటా స్లైసింగ్

చేయడానికి వెళ్దాం . కాబట్టి, మనము ఒక

నిఘంటువు నమూనాను కూడా సృష్టించాము,

కాబట్టి దానిపై స్లైసింగ్ చేద్దాం. కానీ ఇది

మీకు టైప్ ఎర్రర్ మరియు హాషబుల్ టైప్

అంటే స్లైస్ అని చెప్పడంలో ఎర్రర్

ఇస్తుంది. కాబట్టి, మీరు

పైథాన్ నిఘంటువు వస్తువును గుర్తుకు

తెచ్చుకోవచ్చు, ఇది కీలక విలువ సూచిక

సౌకర్యం మరియు విలువలను అందిస్తుంది నిఘంటువులో

కీల ద్వారా ఇండెక్స్ చేయబడతాయి మరియు

ఆ సందర్భంలో అవి ఏ క్రమంలో ఉంచబడవు

ఇచ్చిన క్రమాన్ని స్లైస్ చేయడానికి

ఇండెక్స్ అవసరం కాబట్టి మనం స్లైసింగ్ చేయలేము

విలువలు లేదా మూలకాల ఇచ్చిన క్రమం. మీ

నిఘంటువు నుండి విలువల క్రమం లేదా కీల క్రమాన్ని

ముక్కలు చేయడానికి, స్లైస్ చేయండి. కాబట్టి,

మనము నిఘంటువులో స్లైసింగ్ చేయలేము

ఎందుకంటే ఇది ఒక కంటైనర్ కాదు ఇది

నాన్ సీక్వెన్షియల్ డేటాను కలిగి ఉండటానికి

ఒక కంటైనర్ కాదు. కాబట్టి, ఆ సందర్భంలో

మనం చేయలేము దానిని ఒక సెట్లో కూడా వర్తింపజేయడానికి.

కాబట్టి, మనం దానిని ఒక సెట్ మీద వర్తింపజేసినప్పుడు

ఏమి జరుగుతుందో చూద్దాం.

. కాబట్టి, సెట్ ఆబ్జెక్ట్ సబ్స్క్రిప్టబుల్

కాదని చెప్పడంలో కూడా ఇది ఎర్రర్

విసురుతుంది. సెట్ అనేది నాన్-సీక్వెన్షియల్

డేటాను కలిగి ఉండటానికి కూడా ఒక కంటైనర్

అని మనకు తెలుసు. కాబట్టి, అన్ని అంశాలు

సమితి లోపల సూచిక చేయబడవు లేదా ఏ సూచికల

ద్వారా సూచిక చేయబడవు, బదులుగా అవి కాదు

ఏ క్రమంలోనూ నిర్వహించబడలేదు. కాబట్టి, మనం సెట్లో

కూడా స్లైసింగ్ ఆపరేషన్ చేయలేము ఎందుకంటే

ఈవెన్ సెట్ అనేది నాన్-సీక్వెన్షియల్

డేటాను పట్టుకోడానికి కూడా ఒక కంటైనర్,

ఆ సందర్భంలో అన్ని ఎలిమెంట్స్ సెట్

లోపల ప్రతి మూలకానికి సంబంధించిన సూచిక

కోసం ఏ సూచిక ఉండదు. కాబట్టి, మేము ఇండెక్స్లో

కూడా స్లైసింగ్ చేయవచ్చు. కాబట్టి, తదుపరిది

శ్రేణిపై ముక్కలు చేయడం. కాబట్టి, మన

వద్ద ఉన్నదాన్ని కింద ముద్రించుకుందాం.

1 2 3 మరియు 4 విలువలను కలిగి ఉన్న శ్రేణి

నమూనా. కాబట్టి, మీరు ప్రాథమికంగా యాక్సెస్

చేయాలనుకుంటే లేదా మీరు మీ శ్రేణి లోపల

విలువలను పొందాలనుకుంటే లేదా ముక్కలు చేయాలనుకుంటే,

మీరు కేవలం ప్రదర్శించవచ్చు దానిపై అదే స్లైసింగ్

ఆపరేషన్ నాకు కేవలం ఒక పెద్దకోలన్‌ ఇవ్వబడింది.

కాబట్టి, అది నాకు ఇస్తుంది అవుట్పుట్

మనకు మొదటి సూచిక నుండి 2,3 మరియు 4 అనే

అన్ని విలువలను ఇస్తుంది ఎందుకంటే విలువ ఎందుకంటే

విలువ 2 కి సంబంధించిన సూచిక 1. రివర్స్ ఇండెక్స్

లేదా నేను యాక్సెస్ ఇచ్చిన నెగటివ్ ఇండెక్స్

ఇవ్వడం ద్వారా కూడా మీరు దానిని స్లైస్

చేయవచ్చు. సూచిక 1 మరియు ముగింపు సూచిక

నుండి ప్రారంభమయ్యే విలువలు మైనస్ 1 గా

ఉండాలి, అంటే

మీ శ్రేణి యొక్క రెండవ చివరి మూలకం.

కాబట్టి, అవుట్పుట్ ఏమిటో చూద్దాం? కాబట్టి,

ఆ సందర్భంలో మీకు 2 మరియు 3 మాత్రమే

ఉంటాయి ఎందుకంటే మీరు మొదటి మూలకాన్ని

మినహాయించారు సూచిక 0 మరియు చివరి విలువకు

మనము మైనస్ 1 ఇచ్చాము. అదేవిధంగా నేను శ్రేణి

నమూనాను ఇచ్చినందున మీరు అదే మోనో శ్రేణిని

కూడా ప్రదర్శించవచ్చు మరియు చదరపు బ్రాకెట్

లోపల నేను కోలన్ మరియు మైనస్ 1 ఇచ్చాను.

కాబట్టి, ప్రాథమికంగా మీరు పొందుతారు లేదా

మీరు మొదటి నుండి అన్ని విలువలను ముక్కలు

చేస్తారు కానీ మీరు చేయలేరు కానీ అప్పుడు

మీరు మీ శ్రేణి యొక్క చివరి మూలకం యొక్క

చివరి మూలకాన్ని మినహాయిస్తారు

అప్పుడు అది మీకు 1,9,4 మాత్రమే ఇస్తుంది.

కాబట్టి, ఇప్పుడు ప్రాథమికంగా సీక్వెన్షియల్

డేటాపై స్లైసింగ్ ఆపరేషన్ ఎలా పని

చేయాలో చూశాము ఇప్పుడు మనం కొన్ని అత్యంత

ప్రాథమిక సీక్వెన్స్ డేటా ఆపరేషన్లను

నేర్చుకుంటాము, అవి సంయోగం. మరియు గుణకారం.

కాబట్టి, మీరు మీ లూపింగ్ ఓవర్ మీద

లూప్ చేస్తున్నప్పుడు ఇది సహాయపడుతుంది.

మీ కంటైనర్లలోని అంశాలు. కాబట్టి,

ఇప్పుడు మనం కొన్ని అత్యంత ప్రాథమిక

క్రమాన్ని నేర్చుకుంటాము. దీనికి వర్తింపజేయగల

సంయోగం మరియు గుణకారం అయిన డేటా కార్యకలాపాలు

ఏదైనా వరుస డేటా. కాబట్టి, మేము ప్లస్

ఆపరేటర్ను ఉపయోగించి సంయోగం చేయబోతున్నాము.

మరియు మీరు సాధించడానికి ప్రయత్నిస్తున్న

దానిపై ఆధారపడి దీన్ని చేయడానికి కొన్ని

మార్గాలు ఉన్నాయి మరియు బహుళ తీగలను

జోడించడానికి ప్లస్ చిహ్నాన్ని ఉపయోగించడం

సరళమైన మరియు అత్యంత సాధారణ పద్ధతి కలిసి

లేదా బహుళ మూలకాలను కలిసి జోడించడానికి

ఇది ఏదైనా వరుస డేటాపై వర్తించవచ్చు. అలాగే.

మరియు కేవలం ఒక ప్లస్ ను ఎన్ని వాటి మధ్య

ఉంచితే అంత వాటి మధ్య ఉంచండి మీరు

కలిసి చేరాలనుకున్నట్లుగా తీగలు. కాబట్టి, అలా

చేయడానికి ఒక ఉదాహరణ చూద్దాం. కాబట్టి,

కోసం

ఉదాహరణకు, కాబట్టి, స్ట్రాసాంపుల్ కింద

ఏమి ఉందో మనకు తెలుసు, దీనికి కేవలం ఒక

పద అభ్యాసం ఉంది. కాబట్టి, నేను ఇక్కడ

ప్లస్ ఆపరేటర్ను ఉపయోగించి రెండు

తీగలను కలపబోతున్నాను. కాబట్టి, నేను స్ట్రాసాంపుల్ను

పైథాన్ అయిన మరొక స్ట్రింగ్తో కలపబోతున్నాను

కానీ పైథాన్ I కి ముందు ఒకే కోట్ లోపల స్థలం

ఇచ్చారు. కాబట్టి, ఇది నేర్చుకోవడం

మధ్య ఖాళీని కలిగి ఉంటుంది. మరియు పైథాన్.

కాబట్టి, అక్కడే స్థలం ఇవ్వబడింది.

కాబట్టి, ఇది కేవలం చేరడానికి మాత్రమే.

రెండు తీగలు కలిసి ఉంటాయి. కాబట్టి,

అవుట్పుట్ చూద్దాం. కాబట్టి, మొదటి లైన్

అవుట్పుట్ స్ట్రాసాంపిల్ ప్రింట్ మరియు తదుపరి

వరుసలో నేను అది నవీకరించబడిందో

లేదో తనిఖీ చేస్తున్నాను నేను ఇప్పటికే ఉన్న

స్ట్రింగ్కు కొత్త స్ట్రింగ్ను జోడించాను

లేదా జోడించాను కాబట్టి లేదా కాదు స్ట్రింగ్.

కాబట్టి, నన్ను తనిఖీ చేయనివ్వండి. కాబట్టి,

నేను స్ట్రాసాంపుల్ను ప్రింట్ చేసి, అక్కడ

ఏమి ఉందో చూద్దాం కానీ దురదృష్టవశాత్తు

ఇది పైథాన్లో మాత్రమే నేర్చుకోవడం అనేది

ఇప్పటికే ఉన్న స్ట్రాసాంపిల్ కి నవీకరించబడదు

అందుకే స్ట్రింగ్ గుర్తుంచుకోండి,

ఎందుకంటే గుర్తుంచుకోండి స్ట్రింగ్ అనేది

మార్పులేనిది మరియు మీరు వేరియబుల్లో

నిల్వ చేసిన స్ట్రింగ్ను కలపడం లేదా పునరావృతం

చేస్తే మీరు కేటాయించాల్సి ఉంటుంది దానిని ఉంచడానికి

మరొక చరరాశికి కొత్త స్ట్రింగ్. కాబట్టి,

మనం అలా చేద్దాం. కాబట్టి, ఏదైనా నేను

ఇక్కడ నిర్వహిస్తున్న ఆపరేషన్ ను కొత్త

చరరాశికి నవీకరిస్తున్నాను. కాబట్టి, అది నవీకరించబడుతుంది.

కాబట్టి, ఇప్పుడు మీరు కొత్త స్ట్రింగ్ను

ప్రింట్ చేస్తే, అందులో పేర్కొన్న

విధంగా లెర్నింగ్, పైథాన్ ఉంటుంది.

. కాబట్టి, ఈ విధంగా మనం స్ట్రింగ్పై

సంయోగం చేస్తాము. కాబట్టి, ఇది ఎప్పుడు

చాలా ఉపయోగకరంగా ఉంటుంది

మీరు మీ డేటాలోని వస్తువుల గుండా లూప్

చేస్తున్నప్పుడు మీరు ప్రదర్శిస్తున్నప్పుడు

చేయాలనుకుంటున్నారు మరియు మీరు ఈ సంయోగం

లేదా గుణకారం వంటి కొన్ని కార్యకలాపాలను

చేయాలనుకుంటే ఇది చాలా ఉపయోగకరంగా

ఉంటుంది. కాబట్టి, తరువాత జాబితాలోని

సంయోగాన్ని చూద్దాం. కాబట్టి, ఇది మన వద్ద

ఉన్న అసలు జాబితా 1 2 ఎ సామ్ 2 మరియు తదుపరి

వరుసలో నేను కలుపుతున్నాను. ఇప్పటికే ఉన్న జాబితా

lstsమ్పల్కు జాబితా మరియు జాబితాలో p

y I అనే స్ట్రింగ్ ఉంటుంది దానిని చదరపు

బ్రాకెట్ లోపల ఇవ్వండి ఎందుకంటే మీరు జాబితాకు

అనుసంధానించగలుగుతారు. కాబట్టి,

మీరు ఇక్కడ చూడగలిగితే, ఇప్పటికే ఉన్నదానికి

ఒక మూలకంగా జోడించినట్లుగా పై జాబితా జోడించబడింది

మొదటి ఉదాహరణగా ఉన్న జాబితా. కాబట్టి,

పై స్ట్రింగ్ కలిగి ఉన్న ప్రత్యేక జాబితా

మన వద్ద లేదు. బదులుగా అది జోడించబడింది

లేదా అసలు జాబితాలోనే నవీకరించబడుతుంది

లేదా నవీకరించబడుతుంది అసలు జాబితాలో చివరి

మూలకం. మరియు శ్రేణులను ఎలా కలపవచ్చు అనేదానికి

ఒక ఉదాహరణను చూద్దాం, మనం ఒక ఉదాహరణను

చూద్దాం.

రెండు వేర్వేరు సీక్వెన్స్ డేటాను కలపగలుగుతుంది,

ఉదాహరణకు ఒక ఉదాహరణను ప్రయత్నిద్దాం. జాబితా

మరియు శ్రేణులను కలిసి కలపడం. కాబట్టి,

మొదట కింద ఏమి ఉందో చూద్దాం ఇది ప్రాథమికంగా

ఒకటి రెండు మూడు మరియు నాలుగు విలువలను

కలిగి ఉన్న శ్రేణి, ఇవి పూర్ణాంక డేటా

రకానికి చెందినవి మరియు ప్లస్ ఆపరేటర్ను

ఉపయోగించడం ద్వారా నేను కలిసి జాబితాను

కలపబోతున్నాను ఇప్పటికే ఉన్న శ్రేణికి జాబితాను

కలపండి. కాబట్టి, అది జరుగుతుందో లేదో

చూద్దాం.

కాబట్టి, ఇది ప్రాథమికంగా మీకు ఏ ట్రేస్ బ్యాక్

ఎర్రర్లను విసురుతుంది, అది ప్రాథమికంగా

మీకు టైప్ ఎర్రర్ను విసురుతుంది ఇది

జాబితా చేయడానికి శ్రేణిని మాత్రమే

జోడించగలదని చెబుతూ, అది శ్రేణికి జోడించలేము.

కాబట్టి, రకం ఎర్రర్ అనేది ప్రాథమికంగా

ఎగురవేయడం, ఇది శ్రేణికి మాత్రమే శ్రేణిని

జోడించగలదని, శ్రేణికి జాబితా చేయలేదని

చెబుతోంది. కాబట్టి, మనము సంయోగం చేయడానికి

ప్రయత్నిస్తున్నందున లేదా జాబితాను జోడించడానికి

ప్రయత్నిస్తున్నందున సాధ్యం కాని ప్రస్తుత

శ్రేణి. కాబట్టి, మనం ఇక్కడ చేయవలసింది

ఏమిటంటే మీరు సంయోగం చేయాలనుకుంటే ఒక

శ్రేణికి. మీరు సీక్వెన్స్ డేటాను ఒక శ్రేణికి

అనుసంధానించాలనుకుంటే, ఆ సీక్వెన్స్ డేటా

ఉండాలి.

శ్రేణిలో అదే రకంగా ఉండండి. కాబట్టి,

మనం ఇక్కడ చేయగలిగేది ఏమిటంటే మనం అదే

విలువలను ఉపయోగించవచ్చు. కానీ ప్రాథమికంగా

అర్రే ఫంక్షన్ను ఉపయోగించి మరియు

డేటా రకాన్ని ఉంచుతూ వాటిని అర్రేగా ఉంచండి

పూర్ణాంకంగా మరియు విలువలను శ్రేణిగా

ఇవ్వడం మరియు శ్రేణి లోపల జాబితాగా విలువలను

ఇవ్వడం. అర్రే శాంపిల్ మీరు సృష్టించినప్పటి

నుండి ఇచ్చిన విలువలు 50 మరియు 60 తో అనుసంధానించబడుతుంది.

ఇది శ్రేణిగా మరియు తరువాత సంయోగం చేయబడింది.

కాబట్టి, తదుపరిది రెండు టపుల్స్ను

కలపడంపై సంయోగం. కాబట్టి, ఇక్కడ మీరు

చూడగలిగితే

ఇక్కడ నేను ప్లస్ మరియు సమానంగా ఉపయోగించాను,

అంటే నేను కొత్త టుపుల్ను జోడించబోతున్నాను.

ఇప్పటికే ఉన్న టుపుల్, టప్ శాంపిల్ మరియు

అది ఆటోమేటిక్ గ్లూ మరియు దానిలో నవీకరించబడుతుంది

టాప్సాంపిల్ స్వయంగా. కాబట్టి, టప్ శాంపిల్

ప్రాథమికంగా 1,2,3,4 మరియు పై కలిగి ఉంది

మరియు నేను th ని జోడించాను, విడిగా a గా ఆన్ చేసి,

నేను రెండు తీగలను కలిగి ఉన్న కొత్త

టుపుల్ను జోడించాను. కాబట్టి, మరియు అది

జోడించబడుతుంది మరియు అది ఇప్పటికే

ఉన్న టప్ శాంపిల్ కి జోడించబడుతుంది

మరియు ఇది ఇప్పటికే ఉన్నటుపుల్ శాంపిల్

పై నవీకరించబడుతుంది నేను ప్లస్ మరియు

సమానంగా ఇచ్చినందున .

తదుపరిది సెట్లో సంయోగం. కాబట్టి,

ప్రాథమికంగా ఇక్కడ నేను ఇప్పటికే ఒక

సెట్ శాంపిల్ కలిగి ఉన్నాను. ఇది 24 డేటా

ఉదాహరణ మరియు 87.5 విలువలను సమితి విలువలుగా

కలిగి ఉంది మరియు నేను సంయోగం చేస్తున్నాను

ఇక్కడ. నేను సెట్ మరియు నిఘంటువు యొక్క

కామా వేరు చేయబడిన అంశాలతో టుపుల్గా

మార్చబోతున్నాను. కాబట్టి, నేను కేవలం

కామాను ఉంచడం ద్వారా ఇప్పటికే ఉన్న సెట్

శాంపిల్కు విలువను కలుపుతున్నాను. నమూనాను

సెట్ చేసిన తర్వాత, ఆపై దానిని సెట్

చేసిన నమూనాకు నవీకరించండి. కాబట్టి, ఆ విలువ

నవీకరించబడుతుంది వాస్తవ సెట్ నమూనాలో.

కాబట్టి, మీరు ఇక్కడ చూడగలిగితే నేను

చాలాసార్లు పరుగెత్తాను. కాబట్టి, మీరు దానిని

నడుపుతున్న ప్రతిసారీ అసలు సెట్ నమూనాలో

దాన్ని నవీకరించబోతోంది. కాబట్టి, అదేవిధంగా

మీరు చేయవచ్చు ఏదైనా వరుస డేటాపై గుణకారం

అని పిలువబడే ఆపరేషన్, ఉదాహరణకు మీరు దీనిలో

గుణించడం మీరు స్ట్రింగ్పై గుణకారాన్ని వర్తింపజేస్తుంటే,

మీరు వెళ్తున్నారని అర్థం మీరు పునరావృతం

చేయబోయే స్ట్రింగ్ను గుణించడానికి మీరు

స్ట్రింగ్ సమితిని పునరావృతం చేయబోతున్నారు

కేవలం ఒక సంఖ్యను ఇవ్వండి. మీకు తీగలను

కలిగి ఉంటే మరియు మీకు తీగలను కలిగి

ఉంటే దానిలో కొంత ఉంటే అర్థంలో గుణకారం

మీరు దానిపై కొంత గుణకారం చేస్తున్నట్లయితే,

మీరు గుణకారం చేస్తున్నట్లయితే దానిపై ఆపరేషన్ చేస్తే,

అది మీరు ఎన్నిసార్లు చేశారో అంత సార్లు

విలువలను పునరావృతం చేయబోతోంది. గుణకంగా

ఇవ్వబడింది. కాబట్టి, ఏమి జరుగుతుందో చూద్దాం.

కాబట్టి, నాకు ఇక్కడ ఒక ఉదాహరణ ఉంది నక్షత్రం

3కి సమానంగా ఇవ్వబడింది. కాబట్టి, నాకు 3 కి

సమానమైన స్ట్రాసంపుల్ నక్షత్రం ఉంది, అంటే

నేను వెళ్తున్నాను. స్ట్రాసంపుల్ కింద

ఉన్నదాన్ని పునరావృతం చేయడానికి, ఆపై నేను

దానిని ఇప్పటికే ఉన్నదానికి నవీకరించబోతున్నాను

ఎస్ఆర్ నమూనానే. కాబట్టి, మనం పరుగెత్తుదాం.

కాబట్టి, నేర్చుకోవడం అంటే అక్కడ మరియు

కింద ఉన్నది. కాబట్టి, నేర్చుకోవడం అనేది

స్ట్రాసాంపుల్ కింద ఒక స్ట్రింగ్ నేను

చెట్టు ఆస్టెరిక్స్ 3ని ఇచ్చాను, అది స్ట్రింగ్ను

మూడుసార్లు పునరావృతం చేసింది మరియు దానిలో

నవీకరించబడుతుంది స్ట్రాసాంపుల్ మరియు

అందుకే స్ట్రాసాంపుల్ను ముద్రించేటప్పుడు

మీకు అవుట్పుట్ లెర్నింగ్ గా వచ్చింది, నేర్చుకోవడం

మరియు నేర్చుకోవడం. కానీ మీరు దానిని

జాబితాలో ప్రదర్శించినప్పుడు ఏమి జరుగుతుంది,

అది కూడా రెండింటినీ కలిగి ఉంటుంది. దానికి

సంఖ్యలు మరియు తీగలను కానీ ఈ సందర్భంలో

దానికి తీగలను కలిగి ఉన్నందున కానీ ఈ

సందర్భంలో

మీరు ఆస్టెరిక్స్ మరియు 2 ఇచ్చినందున

ఇది మీ జాబితాలోని మూలకాన్ని రెండుసార్లు

పునరావృతం చేయబోతోంది . మరియు మీరు ఒక నిర్దిష్ట

మూలకాన్ని ఉపయోగించి వాటిని యాక్సెస్

చేయడం ద్వారా ఎన్నిసార్లు పునరావృతం చేయవచ్చు

సూచిక. కాబట్టి, ఇక్కడ నేను మొదటి సూచికకు

సంబంధించిన విలువను రెండుసార్లు పునరావృతం

చేయబోతున్నాను. అది 4 అయితే మీరు ఉదాహరణకు

చేయగలరు కానీ మీరు జాబితా నమూనాను ప్రింట్

చేసి చూడగలిగితే కానీ మీరు జాబితా

నమూనాను ముద్రించి, విలువ రెండుసార్లు

పునరావృతం కాలేదని చూడగలిగితే

దానిని అక్కడ నవీకరించలేదు. కాబట్టి, మీరు ఇక్కడ

చిహ్నానికి సమానంగా ఇచ్చి, ఆపై అమలు చేస్తే

అది. కాబట్టి, ప్రాథమికంగా పైథాన్ స్పష్టమైన

మార్పిడి చేయదు, ఉదాహరణకు మీరు ప్రదర్శిస్తున్నట్లయితే

స్ట్రింగ్ ఉన్న ఒక ఆపరేషన్ అప్పుడు

అది ఒక సంఖ్యను ఒక నిర్దిష్ట సంఖ్యకు

గుణించదు దానికి ఇచ్చిన విలువతో ఒక

సంఖ్యను గుణించడం లేదు, బదులుగా అది

పునరావృతం చేయబోతోంది మీరు ఎన్ని సార్లు

ఇచ్చారో దానికి విలువలు. కానీ మీరు యాక్సెస్

చేయడానికి ప్రయత్నిస్తున్నట్లయితే

ఒక నిర్దిష్ట విలువ, ఇది పూర్ణాంకం, ఆపై

మీరు గుణన చర్యను నిర్వహిస్తున్నారు

దానిపై మరియు ఆ సందర్భంలో అది ఇచ్చిన దానికి

ఎన్ని సార్లు ఆ నిర్దిష్ట విలువను గుణించబోతోంది

. ఇక్కడ ఒక ఉదాహరణను చూద్దాం, మనకు మొదటి

సూచికకు అనుగుణంగా 2 విలువ ఉంది. మరియు

నేను దానిని 2 విలువతో గుణించడానికి ప్రయత్నిస్తున్నాను

మరియు దానిని నవీకరించడానికి కూడా ప్రయత్నిస్తున్నాను.

ఆ సందర్భంలో అసలు జాబితా నాకు 8 అని

అవుట్పుట్ ఇవ్వబోతోంది. కాబట్టి, ఇప్పుడు

అవుట్పుట్ ఎలా ఉంటుందో చూద్దాం. కాబట్టి,

ఈ సందర్భంలో మొదట మీకు 1,2, ఒక సామ్ మరియు

2 ఉన్నాయి.

మరియు నేను 2 కి సమానమైన 1 ఆస్టెరిక్స్ యొక్క

lst శాంపిల్ ఇచ్చినందున ఆ నిర్దిష్ట విలువ

ఉంది ఇచ్చిన విలువ 2 తో గుణించబడుతుంది.

కాబట్టి, 2 సార్లు 2 మీకు 4 అనే విలువను

ఇస్తుంది మరియు అది మీ అసలు జాబితాలో

తేదీ అవుతుంది. కాబట్టి, మీరు ఒక పూర్ణాంకం

మీద గుణకారం ఆపరేషన్ చేస్తున్నప్పుడు

ఇదే జరుగుతుంది లేదా ఒక ఫ్లోట్ కానీ మీకు

ఏదైనా స్ట్రింగ్ విలువ ఉంటే మరియు

మీరు కొన్నింటిని నిర్వహించడానికి

ప్రయత్నిస్తున్నట్లయితే

దానిపై గుణకార ఆపరేషన్ ఉదాహరణకు మనకు రైట్

అని పిలువబడే విలువ ఉంది. కాబట్టి, 0 1 2,

2 అనేది దానికి సంబంధించిన సూచిక. కాబట్టి, ఏమి

జరుగుతుందో ప్రయత్నిద్దాం. కాబట్టి, ఇది వెళుతోంది

నేను ఇచ్చినప్పటి నుండి మీరు ఇక్కడ

ఎన్నిసార్లు ఇచ్చారో ఆ నిర్దిష్ట మూలకాన్ని

పునరావృతం చేయడానికి 2 ఇచ్చిన విలువ రెండుసార్లు

పునరావృతమవుతుంది. కాబట్టి, మీరు ఏ రకమైన

సీక్వెన్షియల్ డేటాపై అయినా మల్టిప్లికేషన్

ఆపరేషన్ చేసినప్పుడు ఇదే జరుగుతుంది మీకు

అవును, నేను దిగువ గదిలో పునరావృతం

చేసిన అదే ఉదాహరణ ఉంది. కాబట్టి, ఇది

ఇప్పటికే రెట్టింపు అయ్యింది.

a మరియు మీరు దానిని రెండవ సంఖ్యతో గుణించడానికి

ప్రయత్నిస్తుంటే అది పునరావృతమవుతుంది.

మళ్ళీ రెండుసార్లు. మీరు సంయోగం చేసినప్పుడు

ఏమి జరుగుతుందో చూద్దాం. అవేమిటో చూద్దాం

మీరు టుపుల్ మీద గుణకారం చేసినప్పుడు

ఇది జరుగుతుంది. కాబట్టి, ప్రారంభంలో

అది బేస్ కలిగి ఉంది. కాబట్టి, లెట్ టుపుల్

నమూనాలో ఉన్నదాన్ని ప్రింట్ చేస్తాము.

కాబట్టి, ఇక్కడ నేను చేస్తున్నది ఏమిటంటే.

కాబట్టి, నేను ఇక్కడ చేస్తున్నది ఏమిటంటే,

నేను ఒక నిర్దిష్ట భాగాన్ని ముక్కలు

చేయబోతున్నాను.

టుపుల్ నుండి మూలకాల సమితి మరియు తరువాత

చేయటానికి వెళ్లి, ఆపై గుణకారం చేయండి

ఆపరేషన్. కాబట్టి, దానికి ముందు టుపుల్

నమూనాలో ఉన్నదాన్ని ప్రింట్ చేద్దాం.

కాబట్టి, ఏమిటి? మీ టుపుల్ శాంపిల్ లిస్ట్

1,2,3,4,3 మరియు పై లో ఉందా మరియు 2 కోలన్ 4 అనేది

3 తప్ప మరొకటి కాదు మరియు 4. కాబట్టి,

2 కోలన్ అనేది 2 కోలన్ 4 ముక్కలు, మూలకాలు

3 మరియు 4 మరియు నేను చేయబోతున్నాను ఆ

సందర్భంలో రెండుసార్లు గుణించండి, అది కేవలం

వాటిని గుణించబోతోంది. ఆ నిర్దిష్ట మూలకాన్ని

రెండుసార్లు పునరావృతం చేయండి మరియు తదుపరి

విషయం గుణకారం చేయడం శ్రేణిలో.

కాబట్టి, ఇది ప్రాథమికంగా గుణిస్తుంది, ఇది

ప్రాథమికంగా ఇచ్చిన శ్రేణిని రెండుసార్లు

పునరావృతం చేస్తుంది. నక్షత్రం 2 ఇవ్వబడింది.

మరియు తదుపరిది శ్రేణి నమూనా, మనము శ్రేణి

నమూనాను అది విసిరే రెండుతో గుణిస్తున్నాము.

ఆస్టెరిక్ శ్రేణి కోసం టైప్ ఎర్రర్

మరియు సపోర్ట్డ్ ఒపెరాండ్ టైప్ అని

చెప్పడంలో లోపం ఉంది మరియు నేను అమర్చాను

మరియు పూర్ణాంకంలో ఎందుకంటే మీరు a పై

గుణకార చర్యను నిర్వహించలేరు పరిధి ఎందుకంటే పరిధిని

ఉపయోగించి మీరు ఇచ్చిన విలువల క్రమాన్ని

మాత్రమే సృష్టించగలరు

పరిధి. మరియు మనము స్క్రిప్ట్ ముగింపుకు

వచ్చాము మరియు ఈ ఉపన్యాసంలో మనం చూశాము

ఈ ఉపన్యాసంలో మునుపటి ఉపన్యాసానికి కొనసాగింపుగా

కొన్నింటిని ఎలా చేయాలో చూశాము. ఏదైనా

సీక్వెన్షియల్ డేటాపై స్లైసింగ్ ఆపరేషన్ల

గురించి. మరియు మనం కంటైనర్ మీద స్లైసింగ్

చేసినప్పుడు ఏమి జరుగుతుందో కూడా

చూశాము నాన్-సీక్వెన్షియల్ డేటాను కలిగి ఉండి,

దాని తరువాత కొన్నింటిని ఎలా చేయాలో చూశాము

ఏదైనా వరుస డేటాపై సంయోగం మరియు గుణకారం

వంటి కార్యకలాపాలు. మరియు మేము కూడా

చూశాము

కొన్ని తనిఖీలు ఉదాహరణకు మనం రెండు సంఖ్యలను

గుణించడానికి ప్రయత్నించినప్పుడు ఏమి జరుగుతుంది మరియు

మేము స్ట్రింగ్ మీద గుణకారం చేసినప్పుడు

జరుగుతుంది మరియు రాబోయే ఉపన్యాసాలలో

మనం ఎక్కడ ఉంటామో సీక్వెన్స్ డేటా

పద్ధతులను పరిశీలిస్తాము. వరుస డేటాతో మనం

ఏమి చేయగలము మరియు కార్యకలాపాలు ఏమిటి

అనే దానిపై ఎక్కువ దృష్టి పెట్టడం లేదా

మీరు చేయగల పద్ధతులు ఏమిటి. కాబట్టి, రాబోయే

ఉపన్యాసాలలో పద్ధతులు

ఏదైనా కార్యకలాపాలను నిర్వహించడానికి

వరుస డేటాను ఎలా ఉపయోగించవచ్చో చూద్దాము.

కాబట్టి, మేము చుట్టడం. కాబట్టి, అవును, రాబోయే

ఉపన్యాసాలలో మనం వరుస డేటా పద్ధతుల

గురించి చూస్తాము. ఇది పద్ధతులు లేదా

ఏదైనా వరుస డేటాను ఎలా వర్తింపజేయాలి

అనేది తప్ప మరొకటి కాదు, ధన్యవాదాలు.