30 Days Of Python 👨‍💻 - Day 2 - Data Types I

 This article is a part of a challenge series on Python. You can find the link to the previous articles in this series here:
  1. 30 Days of Python 👨‍💻 - Day One - Introduction
  2. 30 Days Of Python 👨‍💻 - Day 2 - Data Types I
  3. 30 Days of Python 👨‍💻 - Day 3 - Data Types II


Before diving deep into the nitty-gritty details of a programming language or perhaps even a human language, we need to understand its terminologies and basic principles and start building a basic mental model which we can come back and refer whenever needed.
The building block of any programming language can be divided mainly into the following:
  • Terminologies
  • Data Types
  • Actions (functions)
  • Best Practices
I spent today understanding some basic Python terms, syntax, its data types and some of its actions or better known as functions in programming terms.

Data Types

Data Types in simple words are a way to represent values. In our physical world, we have letters, numbers, symbols as different types of commonly used values. Similarly, Python is comprised of these fundamental data types:
  • int (to represent numbers)
  • float (to represent decimal numbers)
  • str (to represent strings)
  • bool (to represent boolean)
  • list
  • tuple
  • set
  • dict
  • complex (not used very often)
  • None (to represent an absence of value)
These are the standard data types available in Python. To create our own custom type, classes are used. Specialized data types can also be used via importing external libraries or modules.
In contrast, in JavaScript, these are the following primitive types available:
  • number (for both whole and decimal numbers)
  • string
  • boolean
  • symbol
  • bigInt
  • null
  • undefined - Also, object as a non-primitive type. 


There are 3 types of numeric data types,
  • int (stores whole numbers of unlimited size)
  • float (stores floating-point real number values)
  • complex (I just skipped it as of now as I learnt it is not used commonly, similarly to bigInt in JavaScript).
In contrast, JavaScript has two kinds of numeric data types, Number and BigInt. The type function is used to determine the type of a value or an expression. (Similar to the typeof operator in JavaScript)
  1. num = 100 # variable assignement  
  2.    print(type(num)) # <class 'int'>  
  3.    num2 = 99.99  
  4.    print(type(num2)) # <class 'float>  
  5.    expression1 = num * 10  
  6.    print(type(expression1)) # <class 'int'>  
  7.    expression2 = num + num2  
  8.    print(type(expression2)) # <class 'float'>  
In Python, variable assignment happens by just writing a name and assigning a value using the = operator. In JavaScript, a variable name needs to be preceded with var, const or let keyword.

Math functions

There are some built-in mathematical functions that allow us to calculate various mathematical operations with ease. Math Functions and Constants - this document contains all the built-in math functions and constants
  1. print(round(2.1)) # 2  
  2. print(round(5.9)) # 6  
  3. print(abs(-34)) # 34  
We will explore the math module in detail some other day.


Variables store values. In Python, these are the variable naming conventions:
  • Variables must start with a lowercase letter or underscore and can be followed by numbers or underscore
  • Snake case is the conventional way of writing variable with multiple words such as user_name (Javascript recommends cameCasing like userName)
  • They are case sensitive
  • Keywords should not overwrite keywords (Python keywords)


Strings in Python are an ordered sequence of characters (similar to Javascript).
  1. name = 'Python' # string assignment within single quotes  
  2. name2 = "Python" # string assingment within double quotes  
  3. name3 = '''''This is a a very long string and supports  
  4.         multiline statements as well''' # string assingment within 3 single quotes  
  5. name4 = 'Hello! \"Rockstar Programmer\"' # string with escaped character sequence  
  6. print(type(name)) # <class 'str'>  
  7. print(type(name2)) # <class 'str'>  
  8. print(type(name3)) # <class 'str'>  
  9. print(type(name4)) # <class 'str'>  
String Concatenation
Similar to Javascript, strings can be concatenated using the + operator. It simply joins or 'concatenates' strings.
  1. first_name = 'Mike'  
  2. last_name = 'Tyson'  
  3. print(first_name + ' ' + last_name) # Mike Tyson  
Type Conversion
Unlike Javascript, where there is implicit type conversion (a.k.a Type Coercion), Python will throw an error if operations are performed with different types
  1. user_name = 'John'  
  2. age = 40  
  3. print(user_name + age) # TypeError: can only concatenate str (not "int") to str  
  4. # This would work in Javscript where it would convert the result to string type  
In Python, types need to be converted explicitly to perform operations with different types
  1. user_name = 'John'  
  2. age = 40  
  3. print(user_name + str(age)) # John40  
  4. print(type str(age)) # <class 'str'>  
Similarly, strings can be converted into numbers:
  1. lucky_number = 7  
  2. lucky_number_stringified = str(7)  
  3. lucky_number_extracted = int(lucky_number_stringified)  
  4. print(lucky_number_extracted) # 7  
That's all for today! Still taking it simple and easy. Will continue understanding the other string operations and built-in methods and functions along with Boolean and List types. Pretty excited for Day 3!
Have a great one! 
This post first appeared here.