Python Basic Datatypes

Learn about Python’s primary datatypes—integers, floats, booleans, strings—and where each is used in analytics.

9 minutesVideo LessonPDF notes

🎯 Free Guest Mode: You are learning for free. Sign in to save your completion progress and quiz answers.

Loading progress...

Key moments

Integer Datatype and type() — Introduces integer definitions and demonstrates type verification using the type() function.
Floats and Casting — Explains floating-point numbers and demonstrates numeric type casting with int() and float().
Boolean Datatypes — Details boolean truth logic and emphasizes mandatory capitalization of True and False.
Strings and str() Casting — Covers string definition, name resolution errors, and resolving concatenation errors using str().
Quotation Escaping — Demonstrates quote alternation and backslash escaping for strings containing internal quotation marks.
Print Formatting Techniques — Illustrates multi-argument printing with commas and contrasts print output with tuple display.

PDF notes

Bottom line: You will identify and manipulate Python's primary primitive data types—integers, floats, booleans, and strings. You will verify types at runtime, perform explicit type conversions, and handle string formatting and quotation escaping correctly in your scripts.

This lesson on Python Basic Datatypes is hands-on and example-driven. You will identify and manipulate Python's primary primitive data types—integers, floats, booleans, and strings. You will verify types at runtime, perform explicit type conversions, and handle string formatting and quotation escaping correctly in your scripts.

What You'll Be Able To Do

Identify and verify runtime data types using the type() function
Cast variables between numeric, float, and string representations using built-in constructors
Construct boolean expressions using strict title-cased True and False literals
Format strings containing nested quotation marks using alternating delimiters or backslash escape characters
Concatenate strings and numeric variables without triggering runtime type errors

Detailed Concept Walkthrough

1. Numeric Types and Type Inspection

Python distinguishes between whole numbers and real numbers with fractional components using distinct numeric datatypes. The type() function queries the runtime type assigned to any object or variable dynamically.

Mechanism: Integers (int) represent positive or negative whole numbers without decimal points, whereas floating-point numbers (float) represent real numbers containing decimal points.
Dynamic Typing: Python automatically infers the datatype upon variable assignment, eliminating the need for explicit datatype declarations in your source code.
Inspection Mechanics: Passing either a variable name or a literal directly into type() evaluates and returns the object's class constructor name, such as <class 'int'> or <class 'float'>.

# Assigning numeric values
x1 = 5
x2 = 4.75

# Inspecting types dynamically
print(type(x1))    # <class 'int'>
print(type(-6))    # <class 'int'>
print(type(x2))    # <class 'float'>

Key Takeaway: Python automatically infers numeric types as int or float based on whether a decimal point is present.

2. Explicit Type Casting

Type casting converts an existing value from one datatype representation into another using built-in constructor functions. This allows data of differing types to be combined in expressions.

Numeric Truncation: Passing a floating-point number into int() strips the decimal portion completely without rounding.
Float Promotion: Passing an integer into float() appends a fractional component (.0) to represent the value in floating-point format.
String Conversion: The str() function serializes numeric or boolean values into text format, enabling concatenation with other string literals.

# Casting between numeric types
converted_int = int(4.75)     # Truncates to 4
converted_float = float(5)    # Promotes to 5.0

# Converting an integer to string for concatenation
y = 10
message = str(y) + " dollars"
print(message)                # '10 dollars'

Key Takeaway: Use int(), float(), and str() to explicitly cast incompatible types before combining them in expressions.

3. Boolean Datatype Semantics

The boolean type represents binary truth values corresponding directly to computational binary logic (1 and 0, on and off).

Syntax Rule: Python booleans must strictly be written with initial capital letters as True or False.
Namespace Distinction: Writing true or false in lowercase causes Python to interpret them as unassigned variable identifiers, raising a NameError.
Type Mapping: The type() function identifies boolean literals and variables containing them as bool.

# Assigning boolean values
x3 = True
is_valid = False

# Verifying boolean type
print(type(x3))        # <class 'bool'>
print(type(is_valid))  # <class 'bool'>

Key Takeaway: Boolean literals require strict capitalization (True, False) to avoid variable lookup errors.

4. String Syntax, Escaping, and Printing

Strings are sequences of text characters delimited by single or double quotes, requiring escape strategies when literal quotation characters occur inside the text.

Delimiter Equivalence: Single quotes ('...') and double quotes ("...") are functionally identical for defining strings.
Quote Alternation: Enclose the string in double quotes if it contains an apostrophe, or single quotes if it contains double quotes, preventing premature string termination.
Escape Characters: Prefixing an internal quote with a backslash (') instructs the parser to treat the character as literal text rather than a syntax delimiter.
Display Behavior: Calling print() strips the enclosing quotes from the terminal display, while comma-separated arguments are separated by spaces automatically.

# Quote alternating strategy
phrase_1 = "I'm fine"
phrase_2 = 'Press "enter"'

# Backslash escaping strategy
phrase_3 = 'I\'m fine'

# Printing multiple values
print("red", "car")   # Prints: red car
print(3, 5)           # Prints: 3 5

Key Takeaway: Prevent syntax errors in strings with nested quotes by alternating quote styles or escaping internal quotes with a backslash.

Topics Covered in Python Basic Datatypes

Integer Datatype and type() (0:00 - 0:45) — Introduces integer definitions and demonstrates type verification using the type() function.
Floats and Casting (0:45 - 1:20) — Explains floating-point numbers and demonstrates numeric type casting with int() and float().
Boolean Datatypes (1:20 - 1:55) — Details boolean truth logic and emphasizes mandatory capitalization of True and False.
Strings and str() Casting (1:55 - 2:40) — Covers string definition, name resolution errors, and resolving concatenation errors using str().
Quotation Escaping (2:40 - 3:25) — Demonstrates quote alternation and backslash escaping for strings containing internal quotation marks.
Print Formatting Techniques (3:25 - 4:00) — Illustrates multi-argument printing with commas and contrasts print output with tuple display.

Python Cheat Sheet

type(object) — Returns datatype class of passed variable or literal
```
type(4.75)
```
int(x) — Converts value to integer, truncating decimal portion
```
int(4.75)
```
float(x) — Converts value to float, adding decimal point
```
float(5)
```
str(x) — Converts value into its string text representation
```
str(10)
```
True / False — Capitalized literals defining boolean truth values
```
x3 = True
```
\' or \" — Escapes quotation mark inside matching string delimiters
```
'I\'m fine'
```
print(val1, val2) — Outputs values separated by spaces without quotes
```
print("red", "car")
```

Comparison Table

Datatype	Type Name	Defining Characteristic	Example Value
Integer	int	Whole number without decimals	-6
Float	float	Real number with decimal point	4.75
Boolean	bool	Binary truth value (capitalized)	True
String	str	Text sequence in matching quotes	"George"

Common Pitfalls

Mistake: Writing boolean values in lowercase such as true or false. Avoid: Always capitalize the first letter as True or False.
Mistake: Concatenating an integer directly with a string using the plus operator. Avoid: Wrap the integer in str() before adding to strings.
Mistake: Using unescaped matching quotation marks inside a string. Avoid: Alternate outer quote types or escape inner quotes with a backslash.

FAQs

Why does int(4.75) return 4 instead of rounding up to 5? The int() function truncates the fractional portion entirely rather than performing mathematical rounding.
Why does typing George without quotes cause an error? Python interprets unquoted words as variable identifiers and throws an error if no variable with that name exists.
What happens when listing comma-separated items without print() in an interactive session? Python returns the values grouped inside parentheses as a formatted tuple rather than printing space-separated plain text.

Common pitfalls

Mistake: Writing boolean values in lowercase such as true or false. Avoid: Always capitalize the first letter as True or False.
Mistake: Concatenating an integer directly with a string using the plus operator. Avoid: Wrap the integer in str() before adding to strings.
Mistake: Using unescaped matching quotation marks inside a string. Avoid: Alternate outer quote types or escape inner quotes with a backslash.

Hi, and welcome. We at 365 Data Science specialize in data science trainings. We post videos weekly, so you can master indispensable skills for free. All right, let's get started. When programming, not only in Python, if you say that a variable has a numeric value, you are being ambiguous. The reason is that numbers can be integers or floating points, also called floats, for instance. Integers are positive or negative whole numbers without a decimal point. Let's create x1 and bind it to the value of 5. Now, x1 is an integer. Do you agree? A specific function in Python can prove this is correct. It is called type. Within the brackets, we must place the name of the variable whose type of value we want to verify. So, in this case, I'll type x1. Okay. Shift plus enter, and the result we obtained is int, which indicates the value is an integer. The type function can also be applied directly to a value instead of a variable. For instance, if I write type, open parentheses, -6, close parentheses, Python will correctly point out that -6 is an integer. Good. Now, let's assign the value of 4.75 to a new variable, x2. I would like to check its type. Hence, I will use the type function again. This is a float. Great. Floating points, or as you'll more frequently hear, floats, are real numbers. Hence, they have a decimal point. 4.75 is such a number. Therefore, Python reads it as a float. Let's look at two other built-in functions. int transforms the variable into an integer. That's why 4.75 turns into 4. float, instead, will add a decimal point to the integer value and will turn it into a float. Not all variables should assume numeric values. An example of such type of values is the Boolean type. In Python, this means a true or false value, corresponding to the machine's logic of understanding 1s and 0s, on or off, right or wrong, true or false. Let's provide an example with a new variable, x3, which is equal to True. Right. The output of the type function is bool, which simply means x3 is a Boolean. An important detail you should remember is you have to type True or False with capital letters. Otherwise, Python won't recognize your variable as a Boolean and will display an error message. So, to wrap it up, the two Boolean values a variable can have are True or False, and they must be written with capital letters. Strings are text values composed of a sequence of characters. Let's see how we can create a string in practice. If we ask the machine to display the name George this way, we'll obtain an error message. Why? Because Python assumes George is the name of a variable to which we have assigned no value. Here's the magic trick that will correct this mistake. Let's type single quotation marks around the name George first. And now, let's type double quotation marks around it. You see the output values of these two inputs are the same. This is how Python displays text results if you don't use the print command. Should you use print, the output will be shown with no quotes. You'll be able to see plain text. If we assign this value to a new variable, let's say, x4, we can obtain its output as we did with the integers and floats. All right, so that's it. If the values you'd like to assign are not numerical, the quotes can come into play. Assume the variable y is supposed to represent the number of dollars you have in your pocket. In addition, you would like to ask the machine to print out a statement that says, "y dollars", where y is a number. The proper way to combine the value of y and the string "dollars" is to use a plus sign, as shown here. Let's execute this cell to check if we are missing something. Apparently, we did not respect the rules of coding in Python. We cannot put different types of variables in the same expression. y is an integer and "dollars" is a string. We can convert y into a string. String, str, is the built-in function we need. Analogically to integers and floats, string will convert our number into text, and that will unlock our result. To summarize what we said so far, Python can automatically guess the type of data you are entering. It is within its capabilities to know for sure whether you have assigned an integer, a float, a Boolean, or a string. You need not declare the types of variables explicitly, as you must do in some other programming languages. Python always knows the type of variable. What will happen if you type something like "I'm fine"? You'll need the apostrophe in the English syntax, not for the Pythonic one. Observe. If you execute the command like this, you will make a mistake. To avoid that, in such situations, you can distinguish between the two symbols. Put the text within double quotes and leave the apostrophe, which technically coincides with the single quote between I and m. Now, you are fine. An alternative way to do that would be to leave the quotes on the sides and place a backslash before the apostrophe within the phrase, and we'll still obtain the same correct result. This backslash is called an escape character, as it changes the interpretation of characters immediately after it. And what if we wanted to state "Press enter", where we put "enter" within inverted commas? Same logic. The outer symbols must differ from the inner ones. Put single quotes on the sides. And you obtained the desired result. Finally, let's go through a few ways of stating values. Say you wish to print "red car" on the same line. If I write it like this, two words next to each other separated by a blank space, I'll see them attached. One trick would be to put a blank space before the second apostrophe of the first word. Let's see. Nice. That looks like the desired result. Another technique would be to sort of add one of the strings to the other by typing in a plus sign between the two, just as we did with the $10 example a minute ago. Okay. As your intuition probably tells you, if you print this combination instead, you'll obtain the same outcome, but it won't have the quotes on the two sides. And here's a new trick. I'll type print "red", and then I'll put a comma, which is called a trailing comma, and Python will print the next word, "car", on the same line, separating the two words with a blank space. Shift plus enter. Great. Let's print the number 3 next to the number 5. Boom! Fantastic. Here it is. What will happen if I don't use the print command and just list a few integers, floats, and strings, separating them with commas? Python will execute the command as expected, but will place the values within parentheses. Strictly amazing. Thanks for watching. If you found this video interesting and want to gain an edge in your career, make sure to like, comment, and subscribe. And don't forget to check out some of our other videos for another quick win in the data science skills department.

Frequently asked questions

Why does int(4.75) return 4 instead of rounding up to 5?

The int() function truncates the fractional portion entirely rather than performing mathematical rounding.

Why does typing George without quotes cause an error?

Python interprets unquoted words as variable identifiers and throws an error if no variable with that name exists.

What happens when listing comma-separated items without print() in an interactive session?

Python returns the values grouped inside parentheses as a formatted tuple rather than printing space-separated plain text.

How was this lesson?

Your feedback helps us refine explanations and catch bugs.