In python, variables are similar to C, Java and other languages - they store a certain value. Specifically, in python variables do not have a type. So, a string can also become an integer, and then even into a function!
Literals are given types of string, integer, float, lists, objects, etc. But the variable's type can change.

x=200.00print("x =",x,"and is of type",type(x))x="Hello World!"print("x =",x,"and is of type",type(x))

Python only understands certain code. When you write something Python doesn't understand it throws an exception and tries to explain what went wrong, but it can only speak in a broken Pythonesque english. Let's see some examples by running these code blocks

variable_that_is_undefined

print('Hello'

2000/0

Python tries to tell you where it stopped understanding, but in the above examples, each program is only 1 line long.

It also tries to show you where on the line the problem happened with caret ("^").

Finally it tells you the type of thing that went wrong, (NameError, SyntaxError, ZeroDivisionError) and a bit more information like "name 'gibberish' is not defined" or "unexpected EOF while parsing".

Unfortunately you might not find "unexpected EOF while parsing" too helpful. EOF stands for End of File, but what file? What is parsing? Python does it's best, but it does take a bit of time to develop a knack for what these messages mean. If you run into an error you don't understand please ask.

Text literals are surrounded by quotes. Without the quotes Hello by itself would be viewed as a variable name. You can use either double quotes (") or single quotes (') for text literals. Note that in python a character is just a string with 1 character and isn't a different data type.

Let's use strings:

print("Hello "*5)print("Hello"+"World")

Strings in Python are a bit more complicated because they have their own functions (operations to perform on them) which we can call to modify them:

print("Uppercase:","Hello world".upper())print("Lowercase:","Hello world".lower())print()print("Strip all whitespace at end of string:","Hello ".strip(),"world")print("Find location of 'world' in string:","Hello world".find('world'))print()# C like string formatting where the "%s" is replaced by the values givenval="Hello %s"replaced_val=val%"world"print("String formatting with %s like C:",replaced_val)# We can have template strings where parts are specified on the flyval="Hello {name}"replaced_val=val.format(name="world")print("String formatting with .format():",replaced_val)

Uppercase: HELLO WORLD
Lowercase: hello world
Strip all whitespace at end of string: Hello world
Find location of 'world' in string: 6
String formatting with %s like C: Hello world
String formatting with .format(): Hello world

To convert another data type like float, integer, etc into a string, you can use the str() function:

Frequently you will have a string which spans multiple lines. There are 3 ways to handle this in python:

Use a backslash

Triple quotes

# Using a backslash is similar to C, where the compiler knows the line is being continued in the next lineprint("this is \a multiline string")# In multiline strings, even newlines (\n) is added as a character. So, a newline gets printed.print("""this isa multiline string""")

To have an if condition we need the idea of something being true and something being false. We have True or False as "boolean" values. True would represent OK where as false would represent No or Cancel.

FalseisFalse

TrueisFalse

trueisFalse

We can write expressions with operations too.

1>2

"Cool".startswith("C")

"Cool".endswith("C")

"oo"in"Cool"

42==1# note the double equals sign for equality

In order to write an "if" statement we need code that spans multiple lines

if condition:
print("Condition is True")
else:
print("Condition is False")

Some things to notice. The if condition ends in a colon (":"). In Python blocks of code are indicated with a colon (":") and are grouped by white space. Notice the else also ends with a colon (":"), "else:". Let's try changing the condition and see what happens.

condition=(1>2)ifcondition:print("Condition is True")else:print("Condition is False")

About that white space, consider the following code:

if condition:
print("Condition is True")
else:
print("Condition is False")
print("Condition is True or False, either way this is outputted")

Since the last print statement isn't indented it gets run after the if block or the else block.

You can play with this. Try indenting the last print statement below and see what happens.

condition=Trueifcondition:print("Condition is True")else:print("Condition is False")print("Condition is True or False, either way this is outputted")

You can also use "and", "or", "not" to combine conditions (No ugly && and || here):

True and True is True
True and False is False
False and True is False
False and False is False
not True is False

Below change the values of the three variables to make the entire "if condition" true.

# Edit the values of these 3 variablesboolean_literal=Falsenumber=8string_literal="I like to count sheep before bed."# Don't change the code below thisifnumber>10andboolean_literaland"cows"instring_literal:print("Success!")else:print("Try again!")

Parts of a list can also be gotten using the splice operator. To use the splice operator, square brackets with color (:) is used:

nums=[0,1,2,3,4,5]print("2:4 ->",nums[2:4])# Takes everything 2nd to 3rd termprint("1:3 ->",nums[1:3])# Takes everything from 1st to 2nd termprint("2: ->",nums[2:])# Takes everything from 2nd to last termprint(":4 ->",nums[:4])# Takes everything from start to the 3rd termprint(":-2 ->",nums[:-2])# Takes everything from start to the 3rd last term

Loops let you do something for each item in a list. They look like this:

for item in my_list:
print(item) # Do any action per item in the list

"for" and "in" are required. "my_list" can be any variable or literal which is like a list. "item" is the name you want to give each item of the list in the indented block as you iterate through. We call each step where item has a new value an iteration.

fornumin[1,2,3]:print(num)

In python, we don't use constructs like for ( int i = 0; i < maximum; i++ ) which are just confusing, rather we create a "range" of integers from 0 to maximum and loop over that:

maximum=10print("This is the range object:",range(0,maximum))print("This is what it creates when it's used in a loop or other functions:",list(range(0,maximum)))

We have come a long way! Just one more section. Dictionaries are another container like lists, but instead of being index by a number like 0 or 1 it is indexed by a key which can be almost anything. The name comes from being able to use it to represent a dictionary.

To avoid code repetition and to break code into smaller intelligible blocks, functions are useful. A function takes in certain variables (arguments) and gives out a return value. The arguments and return value do not need to define a data type again, as python isn't too worried about data types.

Because there's no data type for the arguments and return type, we can give strings, ints, floats, lists, etc. Anything that supports the + operator in our example. But if the arguments given cannot be operated on by + it gives an error. And it is the job of the developer of the function to ensure that the arguments given are sane:

defsum2(x1,x2):returnx1+x2print('1 + "s" =',sum2(1,"s"))

Python also supports assigning values using the argument name. When using argument names (also called keyword arguments - kwargs) the order of the arguments do not matter as the name of the argument is used. This gives flexibility, as you don't have to remember which argument comes first and which comes second! Let's see it in action:

Python also has Object Oriented Programming (OOP) in it's structure. A class is a template which holds class variables and functions (methods) and operates on the class itself.

To use a class, objects which conform to the class template need to be created:

classWebSite:def__init__(self):self.url=""self.description=""w1=WebSite()# w1 is an object of class WebSiteprint("Type of w1:",type(w1))w1.description="The free encyclopedia"w1.url="wikipedia.org"

The __init__() function is the class constructor and can not return anything. The first argument self is the object that's being created. Hence, in our above class, when the object is created, it has 2 member variables url and description which are assigned to empty string ("") in the constructor.

Other than the variables created in the class, python can dynamically add more variables in the class:

Classes can also define functions which can be used to perform functions using the object variables.

Object methods start with the keyword self normally. When w1.function() is used, the object before the period (w1) is passed to function()'s first argument. Hence, function() would be defined as def function(self): where self is a reference to the object itself.

Here's an example:

classWebSite:def__init__(self,description="",url=""):self.url=urlself.description=description# A class method or a class function which can be called usingt the object using: <obj>.subsite("arg")# Which the class receives as: substitute(<obj>, "arg")defsubsite(self,subname):returnsubname+"."+self.urlw1=WebSite(description="The free encyclopedia",url="wikipedia.org")# w1 is an object of class WebSitew1.subsites=[w1.subsite('en'),w1.subsite('ml'),w1.subsite('ta')]print(w1.subsites)

Exercise - Create a WebSite object for each item in the wiki_sites dictionary¶

Loop over every (key, value) pair in the dictionary wiki_sites and create a list of WebSite objects using the WebSite class.

The key of the dictionary should be stored in the url of the object.

The value of the dictionary should be stored in the description of the object.

# Leave the definitions of the class and dictionary as isclassWebSite:def__init__(self,description="",url=""):self.url=urlself.description=descriptionwiki_sites={"wikipedia.org":"The free encyclopedia","wikisource.org":"The free library"}# Write below. Loop over every item in wiki_sites and create a list of WebSite objects.

Create a class which can store a mediawiki page (has content and name of the page) and create 2 functions to:

Check if the page is empty (the content is an empty string ""): <obj>.empty() which returns True or False

Generate the URL of the page using a base url: <obj>.url() returns "wikipedia.org/wiki/<page name>")

Below you will find some example code to test your class

# Add the class definition here# The following should work:page=WikiPage(name="MyPage",content="Hello there ! This is a small example page.")print("The name of the page is:",page.name)print("The page has the following content:")print(page.content)print("The url of the page is:",page.url())ifpage.empty():print("The page is empty")else:print("The page is not empty")