Learn Python3: for Beginners

Python is a very simple language, and has a very straightforward syntax. It encourages programmers to program without boilerplate (prepared) code. The simplest directive in Python is the “print” directive – it simply prints out a line (and also includes a newline, unlike in C).

There are two major Python versions, Python 2 and Python 3. Python 2 and 3 are quite different. This tutorial uses Python 3, because it more semantically correct and supports newer features.

For example, one difference between Python 2 and 3 is the print statement. In Python 2, the “print” statement is not a function, and therefore it is invoked without parentheses. However, in Python 3, it is a function, and must be invoked with parentheses.

Some people will tell you that you shouldn’t learn Python as your first language. And this is partly true. Simply told for beginners, Python is too simple and you’ll get used to that. But if you have will to learn on, go for it and learn it.

Part 1: Printing out on the screen

To print a string in Python 3, just open python interpretor (I Assume that you have installed python in your system, if not so follow www.python.org)

Type the following code,

print(“Hello, Python!”)

And the output should be:

Hello, Python!

Part 2: Variables and types

Python is completely object oriented, and not “statically typed”. You do not need to declare variables before using them, or declare their type. Every variable in Python is an object.

This tutorial will go over a few basic types of variables.

NUMBERS

Python supports two types of numbers – integers and floating point numbers. To define an integer, use the following syntax:

myint = 7

If you put this into your Python file, you already created your variable. If you add another line with print function, you can print this variable out.

myint = 7
print(myint)

Now, when you run that file it should output the value of your variable, in this case, number 7.

FLOATING POINT NUMBERS

To define a floating point number, you may use one of the following notations:

myfloat = 7.0
print(myfloat)
myfloat = float(7)
print(myfloat)

STRINGS

Strings are defined either with a single quote or a double quotes.

mystring = ‘hello’
print(mystring)
mystring = “hello”
print(mystring)

The difference between the two is that using double quotes makes it easy to include apostrophes (whereas these would terminate the string if using single quotes).


Part 3: Lists

Lists are very similar to arrays. They can contain any type of variable, and they can contain as many variables as you wish. Lists can also be iterated over in a very simple manner. Here is an example of how to build a list.

mylist = []
mylist.append(1)
mylist.append(2)
mylist.append(3)
print(mylist[0]) # prints 1
print(mylist[1]) # prints 2
print(mylist[2]) # prints 3

for x in mylist:
print(x)

Part 4: Operators

This section explains how to use basic operators in Python.

ARITHMETIC

Just as any other programming languages, the addition, subtraction, multiplication, and division operators can be used with numbers.

number = 1 + 2 * 3 / 4.0
print(number)

Another operator available is the modulo (%) operator, which returns the integer remainder of the division. dividend % divisor = remainder.

remainder = 11 % 3
print(remainder)

Using two multiplication symbols makes a power relationship.

squared = 7 ** 2
cubed = 2 ** 3

STRINGS

Python supports concatenating strings using the addition operator:

helloworld = “hello” + ” ” + “world”
print(helloworld)

Python also supports multiplying strings to form a string with a repeating sequence:

lotsofhellos = “hello” * 10
print(lotsofhellos)

LISTS

Lists can be joined with the addition operators:

even_numbers = [2,4,6,8]
odd_numbers = [1,3,5,7]
all_numbers = odd_numbers + even_numbers
print(all_numbers)

Just as in strings, Python supports forming new lists with a repeating sequence using the multiplication operator:

print([1,2,3] * 3)

Part 5: String formatting

Python uses C-style string formatting to create new, formatted strings. The “%” operator is used to format a set of variables enclosed in a “tuple” (a fixed size list), together with a format string, which contains normal text together with “argument specifiers”, special symbols like “%s” and “%d”.

Let’s say you have a variable called “name” with your user name in it, and you would then like to print(out a greeting to that user.)

name = “John”
print(“Hello, %s!” % name)

To use two or more argument specifiers, use a tuple (parentheses):

name = “John”
age = 23
print(“%s is %d years old.” % (name, age))

Any object which is not a string can be formatted using the %s operator as well. The string which returns from the “repr” method of that object is formatted as the string. For example:

mylist = [1,2,3]
print(“A list: %s” % mylist)

Here are some basic argument specifiers you should know:

%s – String (or any object with a string representation, like numbers)
%d – Integers
%f – Floating point numbers
%.f – Floating point numbers with a fixed amount of digits to the right of the dot.
%x/%X – Integers in hex representation (lowercase/uppercase)

Part 6: Basic string operations

Strings are bits of text. They can be defined as anything between quotes:

astring = “Hello world!”
astring2 = ‘Hello world!’

As you can see, the first thing you learned was printing a simple sentence. This sentence was stored by Python as a string. However, instead of immediately printing strings out, we will explore the various things you can do to them. You can also use single quotes to assing a string. However, you will face problems if the value to be assigned itself contains single quotes. For example to assign the string in these bracket (single quotes are ‘ ‘) you need to use double quotes only like this:

astring = “Hello world!”
print(“single quotes are ‘ ‘”)

print(len(astring))

That prints out 12, because “Hello world!” is 12 characters long, including punctuation and spaces.

astring = “Hello world!”
print(astring.index(“o”))

That prints out 4, because the location of the first occurrence of the letter “o” is 4 characters away from the first character. Notice how there are actually two o’s in the phrase – this method only recognizes the first.

But why didn’t it print out 5? Isn’t “o” the fifth character in the string? To make things more simple, Python (and most other programming languages) start things at 0 instead of 1. So the index of “o” is 4.

astring = “Hello world!”
print(astring.count(“l”))

For those of you using silly fonts, that is a lowercase L, not a number one. This counts the number of l’s in the string. Therefore, it should print 3.

astring = “Hello world!”
print(astring[3:7])

This prints a slice of the string, starting at index 3, and ending at index 6. But why 6 and not 7? Again, most programming languages do this – it makes doing math inside those brackets easier.

If you just have one number in the brackets, it will give you the single character at that index. If you leave out the first number but keep the colon, it will give you a slice from the start to the number you left in. If you leave out the second number, if will give you a slice from the first number to the end.

You can even put negative numbers inside the brackets. They are an easy way of starting at the end of the string instead of the beginning. This way, -3 means “3rd character from the end”.

astring = “Hello world!”
print(astring[3:7:2])

This prints the characters of string from 3 to 7 skipping one character. This is extended slice syntax. The general form is [start:stop:step].

astring = “Hello world!”
print(astring[3:7])
print(astring[3:7:1])

Note that both of them produce same output

There is no function like strrev in C to reverse a string. But with the above mentioned type of slice syntax you can easily reverse a string like this

astring = “Hello world!”
print(astring[::-1])

This:

astring = “Hello world!”
print(astring.upper())
print(astring.lower())

These make a new string with all letters converted to uppercase and lowercase, respectively.

astring = “Hello world!”
print(astring.startswith(“Hello”))
print(astring.endswith(“asdfasdfasdf”))

This is used to determine whether the string starts with something or ends with something, respectively. The first one will print True, as the string starts with “Hello”. The second one will print False, as the string certainly does not end with “asdfasdfasdf”.

astring = “Hello world!”
afewwords = astring.split(” “)

This splits the string into a bunch of strings grouped together in a list. Since this example splits at a space, the first item in the list will be “Hello”, and the second will be “world!”.


Part 7: Conditions

Python uses boolean variables to evaluate conditions. The boolean values True and False are returned when an expression is compared or evaluated. For example:

x = 2
print(x == 2) # prints out True
print(x == 3) # prints out False
print(x < 3) # prints out True

Notice that variable assignment is done using a single equals operator “=”, whereas comparison between two variables is done using the double equals operator “==”. The “not equals” operator is marked as “!=”.

BOOLEAN OPERATORS

The “and” and “or” boolean operators allow building complex boolean expressions, for example:

name = “John”
age = 23
if name == “John” and age == 23:
print(“Your name is John, and you are also 23 years old.”)

if name == “John” or name == “Rick”:
print(“Your name is either John or Rick.”)

The “in” operator

name = “John”
if name in [“John”, “Rick”]:
print(“Your name is either John or Rick.”)

Python uses indentation to define code blocks, instead of brackets. The standard Python indentation is 4 spaces, although tabs and any other space size will work, as long as it is consistent. Notice that code blocks do not need any termination.

Here is an example for using Python’s “if” statement using code blocks:

if :

….
….
elif : # else if

….
….
else:

….
….

For example:

x = 2
if x == 2:
print(“x equals two!”)
else:
print(“x does not equal to two.”)

A statement is evaulated as true if one of the following is correct: 1. The “True” boolean variable is given, or calculated using an expression, such as an arithmetic comparison. 2. An object which is not considered “empty” is passed.

Here are some examples for objects which are considered as empty: 1. An empty string: “” 2. An empty list: [] 3. The number zero: 0 4. The false boolean variable: False

Unlike the double equals operator “==”, the “is” operator does not match the values of the variables, but the instances themselves. For example:

x = [1,2,3]
y = [1,2,3]
print(x == y) # Prints out True
print(x is y) # Prints out False

Using “not” before a boolean expression inverts it:

print(not False) # Prints out True
print((not False) == (False)) # Prints out False

Part 8: Loops

There are two types of loops in Python, for and while.

For loops iterate over a given sequence. Here is an example:

primes = [2, 3, 5, 7]
for prime in primes:
print(prime)

For loops can iterate over a sequence of numbers using the “range” and “xrange” functions. The difference between range and xrange is that the range function returns a new list with numbers of that specified range, whereas xrange returns an iterator, which is more efficient. (Python 3 uses the range function, which acts like xrange). Note that the range function is zero based.

# Prints out the numbers 0,1,2,3,4
for x in range(5):
print(x)

# Prints out 3,4,5
for x in range(3, 6):
print(x)

# Prints out 3,5,7
for x in range(3, 8, 2):
print(x)

For loops can iterate over a sequence of numbers using the “range” and “xrange” functions. The difference between range and xrange is that the range function returns a new list with numbers of that specified range, whereas xrange returns an iterator, which is more efficient. (Python 3 uses the range function, which acts like xrange). Note that the range function is zero based.

While loops repeat as long as a certain boolean condition is met. For example:

count = 0
while count < 5: print(count) count += 1 # This is the same as count = count + 1 break is used to exit a for loop or a while loop, whereas continue is used to skip the current block, and return to the “for” or “while” statement. A few examples: # Prints out 0,1,2,3,4 count = 0 while True: print(count) count += 1 if count >= 5:
break

# Prints out only odd numbers – 1,3,5,7,9
for x in range(10):
# Check if x is even
if x % 2 == 0:
continue
print(x)

unlike languages like C, C++… we can use else for loops. When the loop condition of “for” or “while” statement fails then code part in “else” is executed. If break statement is executed inside for loop then the “else” part is skipped. Note that “else” part is executed even if there is a continue statement.

Here are a few examples:

# Prints out 0,1,2,3,4 and then it prints “count value reached 5”

count=0
while(count<5):
print(count)
count +=1
else:
print(“count value reached %d” %(count))

# Prints out 1,2,3,4
for i in range(1, 10):
if(i%5==0):
break
print(i)
else:
print(“this is not printed because for loop is terminated because of break but not due to fail in condition”)

Part 9: Functions

Functions are a convenient way to divide your code into useful blocks, allowing us to order our code, make it more readable, reuse it and save some time. Also functions are a key way to define interfaces so programmers can share their code.

As we have seen on previous tutorials, Python makes use of blocks.

A block is a area of code of written in the format of:

block_head:
1st block line
2nd block line

Where a block line is more Python code (even another block), and the block head is of the following format: block_keyword block_name(argument1,argument2, …) Block keywords you already know are “if”, “for”, and “while”.

Functions in python are defined using the block keyword “def”, followed with the function’s name as the block’s name. For example:

def my_function():
print(“Hello From My Function!”)

Functions may also receive arguments (variables passed from the caller to the function). For example:

def my_function_with_args(username, greeting):
print(“Hello, %s , From My Function!, I wish you %s”%(username, greeting))

Functions may return a value to the caller, using the keyword- ‘return’ . For example:

def sum_two_numbers(a, b):
return a + b

CALLING A FUNCTION

Simply write the function’s name followed by (), placing any required arguments within the brackets. For example, lets call the functions written above (in the previous example):

# Define our 3 functions
def my_function():
print(“Hello From My Function!”)

def my_function_with_args(username, greeting):
print(“Hello, %s , From My Function!, I wish you %s”%(username, greeting))

def sum_two_numbers(a, b):
return a + b

# print(a simple greeting)
my_function()

#prints – “Hello, John Doe, From My Function!, I wish you a great year!”
my_function_with_args(“John Doe”, “a great year!”)

# after this line x will hold the value 3!
x = sum_two_numbers(1,2)

Part 10: Classes and objects

Objects are an encapsulation of variables and functions into a single entity. Objects get their variables and functions from classes. Classes are essentially a template to create your objects.

class MyClass:
variable = “blah”

def function(self):
print(“This is a message inside the class.”)

We’ll explain why you have to include that “self” as a parameter a little bit later. First, to assign the above class(template) to an object you would do the following:

class MyClass:
variable = “blah”

def function(self):
print(“This is a message inside the class.”)

myobjectx = MyClass()

Now the variable “myobjectx” holds an object of the class “MyClass” that contains the variable and the function defined within the class called “MyClass”.

To access the variable inside of the newly created object “myobjectx” you would do the following:

class MyClass:
variable = “blah”

def function(self):
print(“This is a message inside the class.”)

myobjectx = MyClass()

myobjectx.variable

So for instance the below would output the string “blah”:

class MyClass:
variable = “blah”

def function(self):
print(“This is a message inside the class.”)

myobjectx = MyClass()

print(myobjectx.variable)

You can create multiple different objects that are of the same class(have the same variables and functions defined). However, each object contains independent copies of the variables defined in the class. For instance, if we were to define another object with the “MyClass” class and then change the string in the variable above:

class MyClass:
variable = “blah”

def function(self):
print(“This is a message inside the class.”)

myobjectx = MyClass()
myobjecty = MyClass()

myobjecty.variable = “yackity”

# Then pring out both values
print(myobjectx.variable)
print(myobjecty.variable)

To access a function inside of an object you use notation similar to accessing a variable:

class MyClass:
variable = “blah”

def function(self):
print(“This is a message inside the class.”)

myobjectx = MyClass()

myobjectx.function()

The above would print out the message, “This is a message inside the class.”


Part 11: Dictionaries

A dictionary is a data type similar to arrays, but works with keys and values instead of indexes. Each value stored in a dictionary can be accessed using a key, which is any type of object (a string, a number, a list, etc.) instead of using its index to address it.

For example, a database of phone numbers could be stored using a dictionary like this:

phonebook = {}
phonebook[“John”] = 938477566
phonebook[“Jack”] = 938377264
phonebook[“Jill”] = 947662781
print(phonebook)

Alternatively, a dictionary can be initialized with the same values in the following notation:

phonebook = {
“John” : 938477566,
“Jack” : 938377264,
“Jill” : 947662781
}
print(phonebook)

Dictionaries can be iterated over, just like a list. However, a dictionary, unlike a list, does not keep the order of the values stored in it. To iterate over key value pairs, use the following syntax:

phonebook = {“John” : 938477566,”Jack” : 938377264,”Jill” : 947662781}
for name, number in phonebook.items():
print(“Phone number of %s is %d” % (name, number))

To remove a specified index, use either one of the following notations:

phonebook = {
“John” : 938477566,
“Jack” : 938377264,
“Jill” : 947662781
}
del phonebook[“John”]
print(phonebook)

or

phonebook = {
“John” : 938477566,
“Jack” : 938377264,
“Jill” : 947662781
}
phonebook.pop(“John”)
print(phonebook)


Thank you! for Reading. If you would like to contribute articles like this… contact info@itantz.com

Leave a Reply