Python Variables and Data Types

What Are Variables?

In programming, we constantly need to work with data. A variable is a name we give to a location in the computer's memory where we can store a piece of data. Think of it as a labeled box: you give the box a name (the variable name) and put something inside it (the value). You can then use that name to refer to the value anywhere in your program.

To get a clear picture of this, let's start with a video from Programming with Mosh, which explains this concept and introduces the different kinds of data we can store. The video also covers important conventions for naming variables, which is a crucial practice for writing clean, readable code.

To summarize the key takeaways on variable naming from the video:

• Be descriptive: order_count is much better than oc.
• Use lowercase letters: Variable names are typically written in all lowercase.
• Separate words with underscores: This style is called snake_case (e.g., first_name, is_active).
• Proper spacing: Use a single space around the equals (=) sign for readability (e.g., age = 30, not age=30).

In Python, assigning a value to a variable is straightforward. You use the assignment operator (=):

# variable_name = value
student_count = 1000
course_name = "Python for FastAPI"
is_published = True

Basic Data Types in Python

The type of data a variable holds determines what you can do with it. You can perform arithmetic with numbers, but you can't with text. Python has several built-in data types. For this lesson, we will focus on the four most common ones you just saw in the video.

An important feature of Python is that it is dynamically typed. This means you don't have to explicitly declare the data type of a variable. Python automatically infers the type based on the value you assign to it.

Let's explore each of the four basic types.

Integers (int)

Integers are whole numbers, without any decimal part. They can be positive, negative, or zero.

user_age = 25
items_in_stock = -10 # Maybe a backorder count
number_of_students = 0

The video from Bro Code offers a quick, practical demonstration of integer variables.

Floats (float)

Floats, or floating-point numbers, are numbers that have a decimal component. Even if the decimal part is zero (like 10.0), Python considers it a float.

price = 19.99
gpa = 3.7
temperature = 98.6

Let's see a demonstration of floats from the same video.

Strings (str)

A string is a sequence of characters used to represent text. You can create strings by enclosing text in either single quotes ('...') or double quotes ("..."). The choice is a matter of style, but it's useful to be consistent. One benefit of having both is that it makes it easy to include a quote character within a string.

# Using double quotes
full_name = "Jane Doe"




# Using single quotes
favorite_language = 'Python'




# A string can contain quotes of the other type
message = "She said, 'Hello, Python!'"

This next clip shows how strings are defined and used.

Booleans (bool)

A boolean has only two possible values: True or False. They are essential for logic and control flow, such as in if statements to make decisions in your code. Note that in Python, the words True and False are case-sensitive and must be capitalized.

is_active_user = True
has_permission = False

Let's see the final clip on booleans.

Checking a Variable's Type

Since Python figures out the data type for you, it can be useful to check what type it has assigned. You can do this with the built-in type() function.

For a quick reference on Python's data types and the type() function, you can review the following resource from W3Schools.

Here's how you'd use type() in practice. You can try this out in a Python interpreter.

name = "John"
year = 2053
temperature = 98.5
is_logged_in = True

print(type(name))
print(type(year))
print(type(temperature))
print(type(is_logged_in))

Running this code will produce the following output:

<class 'str'>
<class 'int'>
<class 'float'>
<class 'bool'>

Diving Deeper

You now have a solid grasp of the basics. Given your background with a BCA, you might appreciate a more detailed exploration of these data types. The following article from Real Python is an excellent, in-depth resource. You don't need to memorize everything, but reading through it will strengthen your understanding.

Conclusion

In this introductory lesson, we've covered the essential concepts of variables and Python's four basic data types.

Key Takeaways:

• A variable is a named container used to store data in memory.
• Python is dynamically typed, meaning it automatically detects a variable's type from the assigned value.
• The four fundamental data types are:
  • int: For whole numbers (e.g., 10, -5).
  • float: For numbers with a decimal point (e.g., 3.14, -0.5).
  • str: For textual data, enclosed in quotes (e.g., "hello", 'world').
  • bool: For truth values, True or False.
• You can use the type() function to inspect the data type of any variable.
• Following good naming conventions (snake_case, descriptive names) makes your code much easier to read and maintain.

These concepts are the absolute foundation of programming in Python. In our next lesson, we will build upon this by exploring how to store collections of data using Python's versatile data structures: lists, tuples, and dictionaries.