Table of contents
No headings in the article.
Hey there, friends! Today, we're going to talk about one of the building blocks of Python: variables. Variables and constants are like little containers that store information. Let's dive in and demystify Python variables together!
What are Variables?
Picture this: you have a box, and you want to put something in it. That box is your variable, and what you put inside is your data. It could be a name, a number, or even a whole paragraph of text!
Python has various data types: strings, integers, floats, and booleans.
What are Constants?
Constant is a data item whose value cannot change during the program’s execution. Thus, as its name implies – the value is constant. It should be UPPERCASE, eg. PI = 3.14159.
Declaring Variables & Constants:
To declare a variable, you simply give it a name and assign a value. Let's see this in action:
name = "James"
age = 25
SPECIES = "Human"
PI = 3.14159 # Constant
In this example, we've created two variables and two constants. name is a string, age is an integer, while SPECIESand PI are constants. You have to keep track of constants though, as you can overwrite them, the best way to track them is to make sre they are uppercase.
Ned Batchelder - Facts and Myths about Python names and values - PyCon 2015
Watch this video above on names and values!
My favorite quotes:
Assignment never copies data.
Python is neither "Call By value" nor "Call By Reference", it's "Call by Assignment"!
There is no way in python where a name can refer to another name. A name can only refer to values.
Dynamic Typing:
In Python, you don't have to declare the data type. Python figures it out for you. This is called dynamic typing, and it makes your life as a programmer easier! Use the type() function to see what the data type was inferred. One last thing you need to worry about, but you do need to keep track of them as Python won’t.
first_name = "Spock" # str = string
type(name)
# <class 'str'>
my_var = 42 # int = integer
type(my_var)
# <class 'int'>
Integer:
temp = int(101.2)Float:
temp = float(100)Boolean:
raining = bool(’True’)String:
temp = str(97.2)
Variable Naming Rules:
Start with a letter or underscore.
Can contain letters, numbers, and underscores.
Case-sensitive (e.g.,
ageandAgeare different, so be careful).Constants use screaming snake case 🗣️ 🐍, e.g
MY_COOL_CONSTANTFor more details, see Python’s style rules found in Pep 8 and watch the Pep 8 talk from PyCon 2015:
PEP 8 – Style Guide for Python Code |peps.python.org
Raymond Hettinger - Beyond PEP 8 -- Best practices for beautiful intelligible code - PyCon 2015
Reassigning Variables:
Variables can change their value. It's like giving your box something to store in it.
first_name = "Jim"
print(first_name) # Output: Jim
first_name = "Spock"
print(first_name) # Output: Spock
first_name started with "Jim" and then became "Spock." But be careful, as you don’t want to change the data type (if it is set up as a string, DO NOT change it to a different data type or you will give yourself a massive headache 😵💫 further along in your program.)
Printing Variables:
To see what's inside your variable, use the print function:
age = 30
print("My age is: ", age)
print(f"My age is: {age}")
print("My age is {}".format(age))
# My age is 30
This will display: My age is: 30
Formatted string literal f is a print() function argument, which is just a shortened form of format() function.
Concatenating & Replicating Variables:
You can also combine variables that contain text by using the + operator and you can replicate it using the * operator:
first_name = "James"
middle_name = "Tiberius"
last_name = "Kirk"
full_name = first_name + " " + middle_name + " " +last_name # concatenation
print("Full Name:", full_name)
# James Tiberius Kirk
alien = "Tribble"
alien_fed = TRUE
alien_count = alien * 10 # replication
print(alien_count if alien_fed else alien)
# TribbleTribbleTribbleTribbleTribbleTribbleTribbleTribbleTribbleTribble
Type Casting:
You can change the type by using functions like int(), float(), and str() to change the data type. If you try to add the string 2 to an integer 2 you will get an error, but if you temporarily change its type, you can add it to the number successfully.
num_two = "2"
type(num_two)
# <class 'str'>
num_two + 3
# Traceback (most recent call last):
# File "<stdin>", line 1, in <module>
# TypeError: can only concatenate str (not "int") to str
int(num_two) + 2
# 4
Try the same thing with the float(), and str() functions.
Comments & Docstrings
Use hashtag #.
# This is a comment
""" This is a
docstring
"""
def least_difference(a, b, c):
"""Return the smallest difference between any two numbers
among a, b and c.
>>> least_difference(1, 5, -5)
4
"""
diff1 = abs(a - b)
diff2 = abs(b - c)
diff3 = abs(a - c)
return min(diff1, diff2, diff3)
help(least_difference) # call the help() function from Python on the method you created, and it will output the docstring
Help on function least_difference in module __main__:
least_difference(a, b, c)
Return the smallest difference between any two numbers
among a, b and c.
>>> least_difference(1, 5, -5)
4
You can use a docstring, but technically this is used to provide documentation of functions, classes and modules. The content they contain will show up as a preview when you hover on the function, class or module you add them.
They begin and end with three quotes """ .
# Factoring an expression involves taking out the greatest common factor/ rewriting a sum of terms as a product. Can use this to solve quadratic equations, it will give you the 2 parts of the equation and you solve for x by setting the equations is equal to 0 separately
def factor_equation(symbo_list, expr):
"""
factor_equation(symbol_list, expr)
Returns equation factored.
>> factor_equation('x, y', 'x**2 + 2*x*y + y**2')
(x + y)**2
"""
if len(symbol_list) == 2:
x, y = symbols(symbol_list)
elif len(symbol_list) == 3:
x, y, z = symbols(symbol_list)
else:
x = symbols(symbol_list)
return factor(expr)
It’s best to stick with hashtag for real comments.
There are some important things to remember about comments and docstrings:
Docstrings are string literals, so the interpreter can “see” them, while comments are completely ignored by it.
Docstrings are used for automatic documentation generation.
Docstrings are generally only docstrings when they appear at the top of the module, function, class or method they define, whereas comments can live anywhere.
Conclusion:
And there you have it! Variables and constants are like the Lego blocks of Python. They hold your data, and you can play around with them however you like. Practice, experiment, and most importantly, make up some examples for your own notes. 🚀🐍
