Data Types in Python | Python for Beginners

Summary

This educational video script delves into Python's data types, essential for understanding how data is stored and manipulated. It covers numeric types like integers, floats, and complex numbers, explaining their characteristics and operations. The script progresses to Boolean values, emphasizing true or false states, and sequence types including strings, lists, and tuples, highlighting their indexing and mutability. It distinguishes between lists and tuples, noting the latter's immutability. Sets are introduced as unordered collections without duplicates, and their operations for unique value comparison are discussed. The script concludes with dictionaries, Python's key-value pair data structures, illustrating how they store and update data. The comprehensive overview is designed to solidify viewers' grasp of Python's foundational data types.

Takeaways

• 🔢 Data types in Python are essential for understanding how data is stored and manipulated, with numeric, sequence, set, Boolean, and dictionary types being the main categories.
• 📏 Numeric types include integers (whole numbers), floats (decimal numbers), and complex numbers (used for imaginary numbers).
• 🌟 Boolean type represents one of two values: True or False, and is often used in conditional statements and comparison operations.
• 📝 Sequence types consist of strings, lists, and tuples, with strings being arrays of bytes representing Unicode characters, and lists being ordered, mutable collections of items.
• 🍦 Tuples are similar to lists but are immutable, meaning they cannot be changed after creation, and are often used for data that should not change.
• 🔑 Sets are unordered collections of unique elements, without indices, and are useful for membership testing and eliminating duplicates.
• 📖 Dictionaries store data in key-value pairs, allowing for fast retrieval of values based on keys, and are mutable, allowing for updates and deletions.
• 🔍 Indexing in Python is used to access elements in data structures like strings and lists, starting from position 0, and can include negative indexing for reverse access.
• 🔄 Operations like addition, multiplication, and concatenation can be performed on strings and lists, but not on tuples due to their immutability.
• 🏷 Sets support operations like union, intersection, and difference, which are useful for comparing and manipulating collections of unique items.
• 🛠️ Dictionaries can be dynamically updated and elements can be added, modified, or removed using keys, providing a flexible way to handle data.

Q & A

What are the main data types in Python discussed in the script?

The main data types in Python discussed are numeric, sequence, set, Boolean, and dictionary.

What are the three different types of numeric data types in Python?

The three different types of numeric data types in Python are integers, floats, and complex numbers.

How can you verify the data type of a variable in Python?

You can verify the data type of a variable in Python by using the 'type()' function, such as 'type(12)' to check if it's an integer.

What is the difference between an integer and a float in Python?

An integer in Python is a whole number, positive or negative, without a decimal point. A float is a number with a decimal point, representing a fractional part.

What is a complex number in Python and how is it represented?

A complex number in Python represents imaginary numbers and is represented by using 'j' as the imaginary unit, such as '12 + 3j'.

What are the two built-in values of the Boolean data type in Python?

The two built-in values of the Boolean data type in Python are 'True' and 'False'.

How do you create a string in Python and what are the different ways to enclose it?

You create a string in Python by enclosing characters in either single quotes (' '), double quotes (

What is the significance of indexing in Python strings and how does it work?

Indexing in Python strings allows you to access specific characters or a range of characters within the string. It starts at 0, and you can use positive or negative indices to access characters from the beginning or end of the string.

How do lists differ from strings in Python, and what is a key feature of lists?

Lists in Python differ from strings in that they can store multiple values, which can be of different data types. A key feature of lists is that they are mutable, meaning you can change, add, or remove items after creation.

What is a tuple in Python and how does it differ from a list?

A tuple in Python is a collection of values, similar to a list, but it is immutable, meaning its values cannot be changed after creation. Tuples are defined using parentheses.

What is a set in Python and how does it differ from a list?

A set in Python is an unordered collection of unique elements, which means it does not allow duplicate values. Unlike lists, sets do not support indexing and are defined using curly braces.

How can you compare two sets in Python to find common or unique elements?

You can compare two sets in Python using set operations like union ('|'), intersection ('&'), difference ('-'), and symmetric difference ('^') to find common or unique elements between them.

What is a dictionary in Python and how is it different from other data types?

A dictionary in Python is a collection of key-value pairs, where each key is unique. It is different from other data types in that it uses keys to access values, rather than using indices like in lists or tuples.

How do you access values in a dictionary in Python?

In Python, you access values in a dictionary by using the keys, such as 'dictionary_name['key_name']'.

Can you update or delete values in a Python dictionary? If so, how?

Yes, you can update values in a Python dictionary by assigning a new value to an existing key or by using the 'update()' method. You can delete values using the 'del' statement followed by the key or the 'pop()' method.

Outlines

00:00

🔢 Introduction to Python Data Types

This paragraph introduces the concept of data types in Python, explaining that they are classifications of data that determine the operations that can be performed on them. The video focuses on the main data types in Python, including numeric (integers, floats, and complex numbers), sequence types, sets, Boolean, and dictionaries. The speaker demonstrates how to check data types using the 'type()' function and provides examples of operations on integers, floats, and complex numbers, highlighting the differences between them.

05:03

📖 Exploring Python's Sequence Types and Strings

The speaker delves into sequence types, starting with strings. They explain that strings in Python are arrays of bytes representing Unicode characters and can be enclosed in single, double, or triple quotes. The paragraph covers string indexing, where the index starts at zero, and demonstrates how to access parts of a string using positive and negative indices. It also touches on string concatenation and repetition. The discussion then shifts to lists, which are mutable and can hold multiple values. Lists are indexed like strings, and the speaker shows how to create lists with both numeric and string values, including nested lists. The paragraph concludes with a demonstration of how lists can be modified after creation using methods like 'append' and how to change list items by index.

10:04

🍦 Tuples, Sets, and Their Unique Characteristics

This paragraph discusses tuples, which are similar to lists but are immutable, meaning they cannot be changed after creation. The speaker shows how to create a tuple and access its elements using indexing. Unlike lists, tuples do not support methods like 'append'. The paragraph then moves on to sets, which are unordered collections of unique elements and do not support indexing. The speaker demonstrates how to create a set and discusses the use of sets for comparing unique values between different collections. Various set operations like union, intersection, and difference are explained with examples.

15:05

📚 Diving into Python Dictionaries

The speaker introduces dictionaries, which are a collection of key-value pairs. Unlike lists and tuples, dictionaries are not indexed by integer indices but by keys. The paragraph explains how to create a dictionary and access its values using keys. It also covers methods to retrieve all keys, values, or items from a dictionary. The speaker demonstrates how to update dictionary values and entire key-value pairs using the 'update' method. The paragraph concludes with a discussion on deleting dictionary keys and their associated values using the 'del' statement.

20:06

👋 Wrapping Up the Data Types Discussion

In the final paragraph, the speaker summarizes the video's coverage of Python data types, expressing gratitude to the viewers for watching. They encourage viewers to like and subscribe for more content, hinting at future videos. The music plays as the video concludes, signaling the end of the data types discussion.

Keywords

💡Data Types

Data types in Python refer to the classification of data, which informs what operations can be performed on that data. In the video, data types are central to understanding how Python handles different kinds of information. Examples include numeric, sequence, set, Boolean, and dictionary types. The script explains that these classifications are crucial for knowing how to manipulate and store data within Python programs.

💡Integers

Integers are a type of numeric data that represent whole numbers, both positive and negative. The video script uses integers to demonstrate basic Python operations, such as addition, and to contrast with other numeric types like floats. For instance, when an integer is added to a decimal, the result is a float, indicating a shift in data type.

💡Float

A float represents a numeric data type that includes decimal points, unlike integers. In the script, the transition from integer to float is illustrated when a whole number is added to a decimal, changing the data type to float. This is significant as it shows how operations can alter the type of data being manipulated in Python.

💡Complex Numbers

Complex numbers are a numeric data type used to represent imaginary numbers. The video mentions complex numbers as a less commonly used data type, denoted by the use of 'j' or 'J' to indicate the imaginary part. This type is important for mathematical operations that extend beyond real numbers.

💡Boolean

Boolean values represent one of two values: True or False. In the video, Booleans are used to illustrate comparison operations, such as checking if one number is greater than another. This type is fundamental in conditional statements and logical operations within Python programming.

💡Sequence Types

Sequence types, including strings, lists, and tuples, are ordered collections of items. The video script discusses how these types allow for indexing and manipulation of data through their ordered nature. For example, strings are used to demonstrate indexing and slicing, which are fundamental operations in text manipulation.

💡Strings

Strings in Python are sequence types used to handle text data. The video explains how strings can be declared using single, double, or triple quotes, and how they can span multiple lines. Strings are indexed, allowing for the extraction of characters or substrings, which is crucial for text processing tasks.

💡Lists

Lists are a mutable sequence type that can hold multiple values of any data type. The script demonstrates how lists are created and how they can be modified, such as adding new items or changing existing ones. Lists are a core data structure in Python, used extensively for storing and manipulating collections of items.

💡Tuples

Tuples are an immutable sequence type similar to lists but cannot be changed after creation. In the video, tuples are presented as suitable for storing data that should not be altered, such as fixed configurations or constant values. The immutability of tuples is a key aspect that differentiates them from lists.

💡Sets

Sets are an unordered collection of unique elements. The video script explains how sets automatically remove duplicate values and cannot be indexed like lists or tuples. Sets are useful for mathematical operations involving collections of unique items, such as finding intersections or differences between groups.

💡Dictionaries

Dictionaries in Python are used to store key-value pairs, allowing for the association of specific identifiers (keys) with values. The video demonstrates how dictionaries are created and manipulated, including adding, updating, and deleting key-value pairs. Dictionaries are essential for creating complex data structures and are widely used in Python for tasks like representing real-world entities with attributes.

Highlights

Introduction to data types in Python, which are classifications that determine what operations can be performed on data.

Explanation of numeric data types including integers, floats, and complex numbers.

Integers are whole numbers, positive or negative, demonstrated with examples.

Floats are non-whole numbers, introduced by performing an operation that results in a decimal.

Complex numbers are used for imaginary numbers and are denoted by 'J'.

Boolean data type with only two values: True or False, used in comparison operations.

Sequence type data includes strings, lists, and tuples, each with unique properties.

Strings are arrays of bytes representing Unicode characters, can be single, double, or triple quoted.

Demonstration of string indexing, showing how to access characters by position.

Lists store multiple values and are indexed, can contain different data types.

Lists are mutable, allowing items to be added, removed, or changed after creation.

Tuples are similar to lists but are immutable, meaning they cannot be changed once created.

Sets are collections without duplicate elements and do not support indexing.

Sets are unordered and can be used to find unique elements or differences between sets.

Dictionaries store key-value pairs and are used for more complex data associations.

Dictionaries allow for the updating and deletion of key-value pairs, but not direct indexing.

Overview of how to access and manipulate data within dictionaries using keys.

Conclusion of the data types video with a summary of the covered topics.

Transcripts

hello everybody today we're going to be

talking about data types in Python data

types are the classification of the data

that you are storing these

classifications tell you what operations

can be performed on your data we're

going to be looking at the main data

types within python including numeric

sequence type set Boolean and dictionary

so let's get started actually writing

some of this out and first let's look at

numeric there are three different types

of numeric data types we have integers

float and complex numbers let's take a

look at integers an integer is basically

just a whole number whether it's

positive or negative so an integer could

be a 12 and we can check that by saying

type

we'll do an open parentheses and a

closed parenthesis and if we say the

type of 12 it's going to give us an

integer or if we say a negative 12 that

is also an integer we can also perform

basic calculations like -12 plus 100 and

that'll tell us it is also an integer so

whether it's just a static value or

you're performing an operation on it

it's still going to be that data type if

those numbers are whole numbers whether

negative or positive now let's take this

exact one and let's say 12 and we'll do

plus

10.25 when we run this it's no longer

going to be a whole number it'll now be

a float so let's check this and now this

is a float type because it's no longer a

whole number it's now a decimal number

and the last data type within the

numeric data type is called complex

let's copy this right down here now

personally this is not one that I've

used almost ever but it is one just

worth noting so you can do 12 plus and

let's say 3 J and if we do this is going

to give us a complex the complex data

type is used for imaginary numbers for

me it's not often used but if you do use

it J is used as that imaginary number if

you use something like C or any other

number it's going to give you an error J

is the only one that will work with it

now let's take a look at Boolean values

so we'll say Boolean the Boolean data

type only has two built-in values either

true or false so let's go right down

here and say type true

and when we run this it'll say Bool

which stands for Boolean we can do the

exact same thing with false and that is

also Boolean and this can be used with

something like a comparison operator so

let's say one is greater than 5. and

let's check this this is giving us a

Boolean because it's telling us whether

one is greater than 5. let's bring that

right down here this will give us a

false so it's telling us that one is not

greater than 5. and just as we got a

false we can say 1 is equal to one and

this should give us a true so now let's

take a look at our sequence type data

types and that includes strings lists

and tuples we'll start off by looking at

strings

in Python strings are arrays of bytes

representing Unicode characters when

you're using strings you put them either

in a single quote a double quote or a

triple quote I call them apostrophes

it's just what I was raised to call them

but most people who use Python call them

quotes So Right Here we have a single

quote

and that works well we can do a double

quote

and that works also and as you can see

they are the exact same output and then

we have a triple quote just like this

and this is called a multi-line so we

can write on multiple lines here so

let's write a nice little poem so we'll

say the ice cream

vanquished my longing for sweets

upon this diet

I look away

it no longer exists

on this day

and then if we run that it's going to

look a little bit weird it's basically

giving us the raw text which is

completely fine but let's call this a

multi-line

we're going to call this a variable

multi-line and we're going to come down

here and say print

and before I run this I have to make

sure that this is ran

so now let's print out our multi-line

and now we have our nice little poem

right down here now something to know

about these single and double quotes is

how they're actually used so if we use a

single quote and we say I've always

wanted to eat a gallon of ice cream

and then we do an apostrophe at the end

obviously something went wrong here what

went wrong is when you use a single

quote and then within your text within

your sentence you have another

apostrophe it's going to give you an

error so what we want to do is whenever

we have a quote within it we need to use

a double quote these double quotes will

negate any single quotes that you have

within your statement they won't however

negate another double quote so you need

to make sure you aren't using double

quotes within your sentence if you want

to do something like that you need to

use the triple quotes like we did above

so we can do double double

and then let's paste this within it

and anything you do Within These treble

quotes will be completely fine as long

as you don't do triple quotes within

your triple quotes we'll say this is

wrong so even though it's between these

two triple quotes it doesn't work

exactly again you just have to

understand how that works you have to

use the proper apostrophes or quotes

within your string and just to check

this we can always say here's our

multi-line we can always say type

of multi-line and that is still a string

one really important thing to know about

strings is that they can be indexed

indexing means that you can search

within it and that index starts at zero

so let's go ahead and create a variable

and we'll just say a is equal to and

let's do the all popular

hello world let's run this

and now when we print the string we can

say a and we're going to do a bracket

and now we can search throughout our

string using the index so all you have

to do is do a colon we can say five what

this is going to do is going to say 0

position 0 all the way up to five which

should give us the whole hello I believe

let's run this and it's giving us the

first five positions of this string we

can also get rid of the colon and just

say something like five

and then when we run this it's actually

going to give us position five so this

is 0 1 2 3 4 and then 5 is the space

let's do six so we can see the actual

letter and that is our w we can also use

a negative when we're indexing through

our string so we could say negative

three and it'll give us the L because

it's negative one two and three we can

also specify a range if we don't want to

use the default of zero so before we did

zero to five and it started at zero

because that was our default but we

could also do two to five let's run this

and now we go position 0 1 and then we

start at 2 L L O now we can also

multiply strings and we have this a

hello world so we can do a

times three and if we run this it'll

give us hello world three times and we

can also do a plus a

and that is Hello World hello world now

let's go down here and take a look at

lists lists are really fantastic because

they store multiple values the string

was stored as one value multiple

characters but a list can store multiple

separate values so let's create our very

first list we'll say list really quickly

and then we'll put a bracket and a

bracket means this is going to be a list

there are other ones like a squiggly

bracket and a parenthesis these denote

that they are different types of data

types the bracket is what makes a list a

list so to keep it super simple we'll

say one two three and we'll run this and

now we have a list that has three

separate values in it the comma in our

list denotes that they are separate

values and a list is indexed just like a

string is indexed so position zero is

this one position one is the two and

position two is the three now when we

made this list we didn't have to use any

quotes because these are numbers but if

we wanted to create a list and we wanted

to add string values we have to do it

with our quotes so we'll say quote

cookie dough

then we'll do a comma to separate the

value and then we'll say

strawberry

then we'll do one more and this will

just be chocolate and when we run this

we have all three of these values stored

in our list now one of the best things

about lists is you can have any data

type within them they don't just have to

be numbers or strings you can basically

put anything you want in there so let's

create a new list

and let's say vanilla

and then we'll do three and then we'll

add a list within a list and we'll say

scoops

comma spoon and then we'll get out of

that list and then we'll add another

value of true for Boolean and now we can

hit shift enter and we just created a

list with several different data types

within one list

now let's take this one list right here

with all of our different ice cream

flavors we'll say ice underscore cream

is equal to this list now one thing

that's really great about lists is that

they are changeable that means we can

change the data in here we can also add

and remove items from the list after

we've already created it so let's go and

take ice cream and we'll say ice cream

dot append and this is going to append

it to the very end of the list we'll do

an open parenthesis let's say salted

caramel now when we run this and we call

it just like this it's going to take

this list add salted caramel to the end

and we'll print it off and as you can

see it was added to the list and just

like I said before let me go down here

we can also change things from this list

so let's say ice cream and then we need

to look at the indexed position so we're

going to say 0 and that's going to be

this cookie dough right here we can say

that is equal to so we can now change

that value so let's call that butter

econ

and now when we call it

we can now see that the cookie dough was

changed to butter pecan another thing

that you saw just a little bit ago is

something called a list within a list

basically a nested list so we had Scoops

spoon true let's give this and we'll say

nested underscore list is equal to

now when we run this we now have this

nested list so if we look at the index

and we say 0 we'll get vanilla if we say

2 we'll get scoops and spoons now since

we have a list within a list we can also

look at the index of that nested list so

let's now say one and that should give

us just spoon and you can go on and on

and on with this you can do lists within

lists within lists and all of them will

have indexing that you can call now

let's go down here and start taking a

look at tuples so we list in a tubal are

actually quite similar but the biggest

difference between a listen a tuple is

that a tuple is something called

immutable it means it cannot be modified

or changed after it's created let's go

right up here we're going to say

tubal

and let's write our very first Tuple so

we'll say Tuple underscore scoops

is equal to and then we'll do an open

parenthesis now these open parentheses

you've seen if you do like a print

statement but that's different because

that's executing a function this is

actually creating a tuple which is going

to store data for us so we'll say one

two three

two and one let's go ahead and create

that Tuple and we can just check the

data type really quickly

and it's a tuple and just like we saw

before a tuple is also indexed so if we

go at the very first position which is a

one we will get the output of a one but

we can't do something like append

and then add a value like three if we do

that it's going to say Tuple object has

no attribute append it's just because

you cannot change or add anything to a

tuple just like we were talking about

before typically people will use tuples

for when data is never going to change

an example for this might be something

like a city name a country a location

something that won't change they

definitely have their use cases but I

don't think they're as popular as just

using a list so now let's scroll down

and start taking a look at sets but

really quickly let me add a few more

cells for us

and let's say sets

now a set is somewhat similar to a list

in a tuple but they are a little bit

different in fact that they don't have

any duplicate elements another big

difference is that the values within a

set cannot be accessed using an index

because it doesn't have an index because

it's actually unordered we can still

Loop through the items in a set with

something like a for Loop but we can't

access it using the bracket and then

accessing its index point so let's go

ahead and create our very first set so

we're going to say daily underscore

pints then we're going to say equal to

and to create a set we're going to use

these squiggly brackets I don't know if

there's an actual name for those if I'm

being honest I call them squiggly

brackets and that's what we're going to

go with we're going to put in a one a

two and a three so let's go ahead and

run this

and let's look at the type

and as you can see it is a set now when

we print this out

it's going to show us one a two and a

three and those are all the values

within our set but if we copy this and

we'll say daily pints log this is going

to be every single day

maybe I had different values

now when we run this and we do the exact

same thing now when we print this

it's going to have just the unique

values within that set now a use case

for set and this is something that I've

done in the past is comparing two

separate sets maybe you have a list or a

tuple and you convert that into a set

and that will narrow it down to its

unique values and then you can compare

the unique values of one set to the

unique values in another set and then we

can see what's the same and what's

different so let's go down here and

let's say wife's underscore daily and

we'll just copy this right here we'll

say is equal to let's do our squiggly

lines let's do one two let's do just

random numbers

so now this is my daily log and this is

my wife's daily log and now we can

compare these values so let's go right

down here let's say print

we'll do my daily logs and then we'll do

this bar right here and this is going to

show us the combined unique values it's

basically like putting them all in one

set and then trimming it down to just

the unique values so we'll take wife's

daily pints log

and when we run this we actually need to

run this first

when we run this we should see all the

unique values between these two sets and

so as you can see zero one two three

four five six seven twenty four Thirty

One so these are all the unique values

between these two sets

we can also do another one

and instead of this bar we're gonna do

this symbol right here which I believe

is called an ampersand don't quote me on

that but when we run this it's going to

show what matches that means which ones

show up in both sets so the only ones

that show up in both sets are one two

three and five we can also do the

opposite of that by doing a minus sign

and this is going to show us what

doesn't match so we have 4 6 and 31. now

where is our 24 that was in our wife's

daily pints log it's in this one but

we're subtracting the values on this one

so let's reverse this and we'll say

daily pints log

and let's run it now those are our other

values so we're taking the values of

this and then we're subtracting all the

ones that are the same and getting the

remaining values and then for our last

one

we can get rid of this and we'll do this

symbol right here and this is going to

show if a value is either in one or the

other but not in both so let's run this

so these values are completely unique

only to each of those sets now the very

last one that we're going to look at in

this video is dictionaries so let's go

right down here

let's add a few cells and let's say

dictionaries

now I saved dictionary for last because

this one is probably the most different

out of all the previous data types that

we've looked at within a data type we

have something called

a key

value pair

that means when we use a dictionary it's

not like a list where you just have a

value comma value comma value we have a

key that indicates what that value is

attributed to so let's write out a

dictionary to see how this looks we're

going to say dictionary underscore cream

and just like a set we use a squiggly

line but the thing that differentiates

it is that in a dictionary we'll have

that key value pair whereas in a set

each value is just separated by a comma

so let's write name

and this is our key and then we do a

colon and this is then where we input

our value so we're going to say Alex

freeberg

and then we separate that key value Pair

by a comma and now we can do another key

value pair so we'll say

weekly intake

and a colon and we'll say five pints of

ice cream do a comma and then we'll do

favorite ice creams

and now what we're going to do is we're

going to put in here a list so within

this dictionary we can also add a list

we'll do MCC for mint chocolate chip and

then we'll add chocolate another one of

my favorites so now we have our very

first dictionary let's copy this and run

it

and let's just look at the type

and as you can see it says that this is

a dictionary let's also print it out

now if we want to we can take our

dictionary cream and say dot values with

an open parenthesis when we execute this

we'll see all of the values within this

dictionary so here's our values of Alex

freeberg five mint chocolate chip and

chocolate

we can also say keys

and when we run this all of the keys the

name weekly intake and favorite ice

creams

and we can also say

items so this key value pair is one item

and this key value pair is another item

now one difference between something

like a list and a dictionary is how you

call the index but you can't call it by

doing something like this where you just

do a bracket oops and say zero so this

would in theory take this very first one

right our very first key value pair

that's going to give us an error how you

call a dictionary is actually by the key

so it doesn't technically have an index

but you can specify what you want to

call and take it out so we're going to

say name and this is going to call that

key right here and when we run this

we'll get the value which is Alex

freeberg one other thing that you can do

is you can also update information in a

dictionary which we can't with some

other data types so for this for the

name it was Alex freeberg now let's say

Steen freeberg

and when we update that I'm also going

to print

the dictionary get rid of this so it's

going to update Christine freeberg in

that value of the name so let's go ahead

and run this

and now it changed the name from Alex

freeberg to Christine freberg we can

also update all of these values at one

time so let's copy this

and I'm going to put it right down here

I'm going to say dictionary.cream dot

update then we're going to put a bracket

or not a bracket but a parentheses

around these so now what we're going to

do is update this entire thing let me

take this

say print this dictionary now we can

update this to anything we want so

instead of here I can say

I'll say wait

and because of all that ice cream I now

weigh 300 pounds so let's run this

and as you can see it did not delete our

key value pair right here instead of

just added to it when you're using the

update we can't actually delete that's

the delete statement and I'll show you

that in just a second but all we did was

added this new value it also is going to

check and see if you changed anything

with your key value pair so we can go in

here and change this value and we'll say

10. so now when we run this the value of

this key value pair was changed but

let's say we do want to delete it we'll

say Del that stands for delete

part of this dictionary cream and now

let's specify the key which will also

delete the value with it let's specify

the key that we want to get rid of and

let's say wait

and then let's print that again

and as you can see the weight was

deleted from that dictionary so that is

all we're going to cover in this data

types video thank you guys so much for

watching I really appreciate it if you

like this video be sure to like And

subscribe below and I'll see you in the

next video

[Music]

foreign

[Music]