Bummer!achoo!nanu nanu.
I know how to spell pneumonoultramicroscopicsilicovolcanoconiosis.
pneumonoultramicroscopicsilicovolcanoconiosis.
Watch what happens when I turn into a child.
Now I sound like this. Oh isn't it splendid!
Spell out each letter of moose
moose
What are the digits of 9878?
9878
I know a long bad word. The word is this is such a bad word I can't say itWow.X SlowSlowmediumfastX Fastlowmediumhighx high
You say, pecan
I say, pecan
I say, pecan
Normal Voice
Whisper VoiceDefault Emphasis VoiceStrong Emphasis VoiceModerate Emphasis VoiceReduced Emphasis Voice
Here is a sentance break
Here is a paragraph break
Here is a medium break
Here is 3 second break
done


Originally our idea blossomed back in the end of 2019 before the world
turned upside down and we were temporarily thrown into chaos. Now more than
ever we realise that due to the booming construction industry, good trades
are far and few, and more so, hard to pin down.
That’s why we created JIFFY.
To help construction companies find the required workforce they need, even on short notice.
This way they achieve a quick, easy and effective solution that won’t cost a fortune either.
We do this by presenting companies with a list of labourers from various
fields which they can then connect with directly. Not only does this save
contractors time, but also provides flexibility and more work opportunities
for labourers allowing them to arrange their schedules and increase exposure
to contractors.


Dugdale
This page contains an index of all the individuals in the database with the surname of Dugdale. Selecting the person’s name will take you to that person’s individual page.
| Given Name | Birth | Death | Partner | Parents |
|---|---|---|---|---|
| Ada | 1870 | 1st Qtr 1949 | Utley, Thomas | Dugdale, James Parkinson, Roberts Mary |
| Alfred | 1855-10-16 | 1858 | Dugdale, Richard Huthers, Betty | |
| Amy | 1872-05-09 | 1948-10-03 | Wilkinson, Edwin | Dugdale, James Parkinson, Roberts Mary |
| Ann | 1810 | Dugdale, John (Farmer) Thurnber, Ellin | ||
| Annie | 1886-09-10 | 4th Qtr 1926 | Lord, Walter | Dugdale, Johnson Shepherd, Susannah |
| Betty | 1844 | Dugdale, John Whalley, Sarah | ||
| Edna | 1892-10-07 | 1st qtr 1967 | Dugdale, Johnson Shepherd, Susannah | |
| Elizabeth | 1822 | 1878 | Hardacre, William or Henry | Dugdale, John (Farmer) Thurnber, Ellin |
| Elizabeth “Betty” | 1888-03-05 | 1969-01-02 | Dugdale, Johnson Shepherd, Susannah | |
| Ellen | 1826 | Robinson, John | Dugdale, John (Farmer) Thurnber, Ellin | |
| Ellen | 1858 | Dugdale, Francis Robinson, Ellen | ||
| Ellen “Nellie” | 1890-03-17 | Parker, Robert | Dugdale, Johnson Shepherd, Susannah | |
| Ethel | 3rd Qtr 1884 | Omerod, James. | Dugdale, Johnson Shepherd, Susannah | |
| Eva “Teva” | 1875-03-18 | 1959-06-14 | Baxter, William “Will” | Dugdale, James Parkinson, Roberts Mary |
| Francis | 1813 | 1821-02-13 | Dugdale, John (Farmer) Thurnber, Ellin | |
| Francis | 1832 | 1881 | Robinson, Ellen | Dugdale, John (Farmer) Thurnber, Ellin |
| James | 1815 | 1817-01-20 | Dugdale, John (Farmer) Thurnber, Ellin | |
| James | 1843-11-02 | 1887-04-15 | Parkinson, Roberts Mary | Dugdale, Richard Huthers, Betty |
| James Duncan | 1930-03-05 | 1967-09-17 | Dugdale, Joseph Duncan Hewlett, Susan | |
| James Howker | 4th Qtr 1894 | 1st Qtr 1962 | Naylor, Ethel | Dugdale, Johnson Shepherd, Susannah |
| Jane | 1829 | 1903 | Hartley, Greenwood | Dugdale, John (Farmer) Thurnber, Ellin |
| Jean Hewlett | 1928-09-11 | 2008 | Harrison, [Living] | Dugdale, Joseph Duncan Hewlett, Susan |
| John, (Farmer) | 1786 | Thurnber, Ellin | ||
| John | 1820 | 1858 | Whalley, Sarah | Dugdale, John (Farmer) Thurnber, Ellin |
| John, (Farmer 214 acres) | about 1827 | 1905 | ????, Margaret | Dugdale, Robert (Farmer 170acres) Peel, Margaret |
| John | 1860 | Dugdale, Francis Robinson, Ellen | ||
| John | 1st Qtr 1842 | Dugdale, Richard Huthers, Betty | ||
| Johnson | 1848-12-14 | 1926-01-00 | Shepherd, Susannah | Dugdale, Richard Huthers, Betty |
| Joseph Duncan | 1898-10-29 | 1960-09-02 | Hewlett, Susan | Dugdale, Johnson Shepherd, Susannah |
| Margaret | about 1830 | Dugdale, Robert (Farmer 170acres) Peel, Margaret | ||
| Mary | about 1826 | Dugdale, Robert (Farmer 170acres) Peel, Margaret | ||
| Olga or Elga | 2nd Qtr 1883 | 1907 | Dugdale, Johnson Shepherd, Susannah | |
| Richard | 1817 | ????, Mary | ||
| Richard | 1817 | 1891 | Huthers, Betty | Dugdale, John (Farmer) Thurnber, Ellin |
| Richard | 1868 | Dugdale, Francis Robinson, Ellen | ||
| Robert, (Farmer 170acres) | about 1783 | Peel, Margaret | Dugdale, Richard ????, Mary | |
| Robert, (Farmer 74 acres) | about 1834 | ????, Alice | Dugdale, Robert (Farmer 170acres) Peel, Margaret | |
| Ruth | 3rd Qtr 1873 | 3rd Qtr 1873 | Dugdale, James Parkinson, Roberts Mary | |
| Susan | 1891-09-21 | 1936-12-21 | Dugdale, Johnson Shepherd, Susannah | |
| Thomas, (Farmer 87 acres) | about 1838 | ????, Mary | Dugdale, Robert (Farmer 170acres) Peel, Margaret | |
| Unknown | 1858-10-24 | 1858-10-24 | Dugdale, Richard Huthers, Betty | |
| Walter | 2nd Qtr 1897 | Dugdale, Johnson Shepherd, Susannah | ||
| Wilfred (Wilford) Leslie | 1900-03-31 | c1950 | Bridge, Hannah | Dugdale, Johnson Shepherd, Susannah |
| William | 1812 | Dugdale, John (Farmer) Thurnber, Ellin | ||
| [Living] | Dugdale, John (Farmer 214 acres) ????, Margaret | |||
| [Living] | Dugdale, John (Farmer 214 acres) ????, Margaret | |||
| [Living] | Dugdale, John (Farmer 214 acres) ????, Margaret | |||
| [Living] | Dugdale, John (Farmer 214 acres) ????, Margaret | |||
| [Living] | Dugdale, John (Farmer 214 acres) ????, Margaret | |||
| [Living] | Dugdale, John (Farmer 214 acres) ????, Margaret | |||
| [Living] | Dugdale, Thomas (Farmer 87 acres) ????, Mary | |||
| [Living] | Dugdale, John (Farmer 214 acres) ????, Margaret | |||
| [Living] | Dugdale, Thomas (Farmer 87 acres) ????, Mary | |||
| [Living] | Dugdale, Thomas (Farmer 87 acres) ????, Mary | |||
| [Living] | Dugdale, John (Farmer 214 acres) ????, Margaret | |||
| [Living] | Dugdale, Thomas (Farmer 87 acres) ????, Mary |


Welcome to Marat's Pizza Shop!
We have the most delicious pizza in town!
Name:
Phone Number:
Address:
Payment Type:
Cash
Credit Card
Paypal
Pizza:
Cheese
Supreme
Hamburger
New York Style
Hawaiian


Cardiff City appoint Harris as new manager
by BeSoccerNeil Harris has replaced Neil Warnock as manager of Championship club Cardiff City.
Cardiff City have appointed former Millwall boss Neil Harris as the club's new manager on a two-and-a-half-year contract following the departure of Neil Warnock.
Harris takes over with the Bluebirds 14th in the Championship after winning just one of their past six matches – a run that culminated in Warnock leaving the club by mutual consent.
During a four-year spell in charge of Millwall, Harris helped the club to promotion from League One via the play-offs in 2016-17, but he resigned on October 3 following a run of seven winless matches.
Cardiff said in a statement on Saturday: "Cardiff City FC can confirm the appointment of Neil Harris as the club's first-team manager".
"The 42-year-old has signed a deal at Cardiff City Stadium running until the summer of 2022".
"David Livermore joins Neil in the dugout as assistant manager, while James Rowberry and Andy Dibble continue in the back-room team as first-team coach and goalkeeping coach, respectively".
"Kevin Blackwell and Ronnie Jepson depart the Welsh capital with the club's sincere thanks and best wishes".
"Neil will oversee training at the Vale Resort on Monday ahead of his first City match away to Charlton Athletic on Saturday, November 23."


Python has become one of the fastest-growing programming languages over the past few years. Not only it is widely used, it is also an awesome language to tackle if you want to get into the world of programming. This Python Guide for Beginners allows you to learn the core of
Python has become one of the fastest-growing programming languages over the past few years.
Not only it is widely used, it is also an awesome language to tackle if you want to get into the world of programming.
This Python Guide for Beginners allows you to learn the core of the language in a matter of hours instead of weeks.
Quick info: You can download a PDF version of this Python Guide for Beginners.
Ready to dive in?
Python was created in 1990 by Guido van Rossum in Holland.
One of the objectives of the language was to be accessible to non-programmers.
Python was also designed to be a second language for programmers to learn due to its low learning curve and ease of use.
Python runs on Mac, Linux, Windows, and many other platforms.
Python is:
Interpreted: it can execute at runtime, and changes in a program are instantly perceptible. To be very technical, Python has a compiler. The difference when compared to Java or C++ is how transparent and automatic it is. With Python, we don't have to worry about the compilation step as it's done in real-time. The tradeoff is that interpreted languages are usually slower than compiled ones.
Semantically Dynamic: you don't have to specify types for variables and there is nothing that makes you do it.
Object-Oriented: everything in Python is an object. But you can choose to write code in an object-oriented, procedural, or even functional way.
High level: you don't have to deal with low-level machine details.
Python has been growing a lot recently partly because of its many uses in the following areas:
System scripting: it's a great tool to automate everyday repetitive tasks.
Data Analysis: it is a great language to experiment with and has tons of libraries and tools to handle data, create models, visualize results and even deploy solutions. This is used in areas like Finance, E-commerce, and Research.
Web Development: frameworks like Django and Flask allow the development of web applications, API's, and websites.
Machine Learning: Tensorflow and Pytorch are some of the libraries that allow scientists and the industry to develop and deploy Artificial Intelligence solutions in Image Recognition, Health, Self-driving cars, and many other fields.
You can easily organize your code in modules and reuse them or share them with others.
Finally, we have to keep in mind that Python had breaking changes between versions 2 and 3. And since Python 2 support ended in 2020, this article is solely based on Python 3.
So let's get started.
If you use a Mac or Linux you already have Python installed. But Windows doesn't come with Python installed by default.
You also might have Python 2, and we are going to use Python 3. So you should check to see if you have Python 3 first.
Type the following in your terminal.
python3 -V
Notice the uppercase V
.
If your result is something similar to 'Python 3.x.y', for instance, Python 3.8.1
, then
you are ready to go.
If not, follow the next instructions according to your Operating System.
Go to https://www.python.org/downloads/.
Download the latest version.
After the download, double-click the installer.
On the first screen, check the box indicating to "Add Python 3.x to PATH" and then click on "Install Now".
Wait for the installation process to finish until the next screen with the message "Setup was successful".
Click on "Close".
Install XCode from the App Store.
Install the command line tools by running the following in your terminal.
xcode-select --install
I recommend using Homebrew. Go to https://brew.sh/ and follow the instructions on the first page to install it.
After installing Homebrew, run the following brew
commands to install Python 3.
brew update
brew install python3
Homebrew already adds Python 3 to the PATH, so you don't have to do anything else.
To install using apt
, available in Ubuntu and Debian, enter the following:
sudo apt install python3
To install using yum
, available in RedHat and CentOS, enter the following:
sudo yum install python3
You can run Python code directly in the terminal as commands or you can save the code in a file with the
.py
extension and run the Python file.
Running commands directly in the terminal is recommended when you want to run something simple.
Open the command line and type python3
renan@mypc:~$ python3
You should see something like this in your terminal indicating the version (in my case, Python 3.6.9), the operating system (I'm using Linux), and some basic commands to help you.
The >>>
tells us we are in the Python console.
Python 3.6.9 (default, Nov 7 2019, 10:44:02)
[GCC 8.3.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>>
Let's test it by running our first program to perform basic math and add two numbers.
>>> 2 + 2
The output is:
4
To exit the Python console simply type exit()
.
>>> exit()
.py
filesIf you have a complex program, with many lines of code, the Python console isn't the best option.
The alternative is simply to open a text editor, type the code, and save the file with a .py
extension.
Let's do that, create a file called second_program.py
with the following content.
print('Second Program')
The print()
function prints a message on the screen.
The message goes inside the parentheses with either single quotes or double quotes, both work the same.
To run the program, on your terminal do the following:
renan@mypc:~$ python3 second_program.py
The output is:
Second Program
Python is known for its clean syntax.
The language avoids using unnecessary characters to indicate some specificity.
Python doesn't use semicolons to finish lines. A new line is enough to tell the interpreter that a new command is beginning.
The print()
method will display something.
In this example, we have two commands that will display the messages inside the single quotes.
print('First command')
print('Second command')
Output:
First command
Second command
But the following is wrong due to the semicolons in the end:
print('First command');
print('Second command');
Many languages use curly-brackets to define scope.
Python's interpreter uses only indentation to define when a scope ends and another one starts.
This means you have to be aware of white spaces at the beginning of each line -- they have meaning and might break your code if misplaced.
This definition of a function works:
def my_function():
print('First command')
This doesn't work because the indentation of the second line is missing and will throw an error:
def my_function():
print('First command')
Python is case sensitive. So the variables name
and Name
are not the same thing and
store different values.
name = 'Renan'
Name = 'Moura'
As you can see, variables are easily created by just assigning values to them using the =
symbol.
This means name
stores 'Renan' and Name
stores 'Moura'.
Finally, to comment something in your code, use the hash mark #
.
The commented part does not influence the program flow.
# this function prints something
def my_function():
print('First command')
This was just an overview. The details of each of these will become clearer in the next chapters with examples and broader explanations.
The purpose of comments is to explain what is happening in the code.
Comments are written along with your code but do not influence your program flow.
When you work by yourself, maybe comments don't feel like something you should write. After all, at the moment, you know the whys of every single line of code.
But what if new people come on board your project after a year and the project has 3 modules, each with 10,000 lines of code?
Think about people who don't know a thing about your app and who are suddenly having to maintain it, fix it, or add new features.
Remember, there is no single solution for a given problem. Your way of solving things is yours and yours only. If you ask 10 people to solve the same problem, they will come up with 10 different solutions.
If you want others to fully understand your reasoning, good code design is mandatory, but comments are an integral part of any codebase.
The syntax of comments in Python is rather easy: just use the hash mark #
symbol in front of the
text you want to be a comment.
#This is a comment and it won't influence my program flow
You can use a comment to explain what some piece of code does.
#calculates the sum of any given two numbers
a + b
Maybe you want to comment on something very complex or describe how some process works in your code.
In these cases, you can use multiline comments.
To do that, just use a single hash mark #
for each line.
#Everything after the hash mark # is a comment
#This is a comment and it won't influence my program flow
#Calculates the cost of the project given variables a and b
#a is the time in months it will take until the project is finished
#b is how much money it will cost per month
a + b * 10
In any program, you need to store and manipulate data to create a flow or some specific logic.
That's what variables are for.
You can have a variable to store a name, another one to store the age of a person, or even use a more complex type to store all of this at once like a dictionary.
Declaring a variable is a basic and straightforward operation in Python
Just pick a name and attribute a value to it using the =
symbol.
name='Bob'
age=32
You can use the print()
function to show the value of a variable.
print(name)
print(age)
Bob
32
Notice that in Python there is no special word to declare a variable.
The moment you assign a value, the variable is created in memory.
Python also has dynamic typing, which means you don't have to tell it if your variable is a text or a number, for instance.
The interpreter infers the typing based on the value assigned.
If you need it, you can also re-declare a variable just by changing its value.
#declaring name as a string
name='Bob'
#re-declaring name as an int
name = 32
Keep in my mind, though, that this is not recommended since variables must have meaning and context.
If I have a variable called name
I don't expect it to have a number stored in it.
Let's continue from the last section when I talked about meaning and context.
Don't use random variable names like x
or y
.
Say you want to store the time of a party, just call it party_time
.
Oh, did you notice the underscore _
?
By convention, if you want to use a variable name that is composed of two or more words, you separate them by underscores. This is called Snake Case.
Another option would be using CamelCase as in partyTime
. This is very common in other languages, but
not the convention in Python as stated before.
Variables are case sensitive, so party_time
and Party_time
are not the same. Also, keep
in mind that the convention tells us to always use lower case.
Remember, use names that you can recall inside your program easily. Bad naming can cost you a lot of time and cause annoying bugs.
In summary, variable names:
time
and TIME
are not the same_
or a letter (DO NOT start with a number)This, for instance, is not allowed: party#time
, 10partytime
.
To store data in Python you need to use a variable. And every variable has its type depending on the value of the data stored.
Python has dynamic typing, which means you don't have to explicitly declare the type of your variable -- but if you want to, you can.
Lists, Tuples, Sets, and Dictionaries are all data types and have dedicated sections later on with more details, but we'll look at them briefly here.
This way I can show you the most important aspects and operations of each one in their own section while keeping this section more concise and focused on giving you a broad view of the main data types in Python.
First of all, let's learn how to determine the data type.
Just use the type()
function and pass the variable of your choice as an argument, like the example
below.
print(type(my_variable))
The boolean type is one of the most basic types of programming.
A boolean type variable can only represent either True or False.
my_bool = True
print(type(my_bool))
my_bool = bool(1024)
print(type(my_bool))
<class 'bool'>
<class 'bool'>
There are three types of numeric types: int, float, and complex.
my_int = 32
print(type(my_int))
my_int = int(32)
print(type(my_int))
<class 'int'>
<class 'int'>
my_float = 32.85
print(type(my_float))
my_float = float(32.85)
print(type(my_float))
<class 'float'>
<class 'float'>
my_complex_number = 32+4j
print(type(my_complex_number))
my_complex_number = complex(32+4j)
print(type(my_complex_number))
<class 'complex'>
<class 'complex'>
The text type is one of the most commons types out there and is often called string or, in Python, just
str
.
my_city = "New York"
print(type(my_city))
#Single quotes have exactly
#the same use as double quotes
my_city = 'New York'
print(type(my_city))
#Setting the variable type explicitly
my_city = str("New York")
print(type(my_city))
<class 'str'>
<class 'str'>
<class 'str'>
You can use the +
operator to concatenate strings.
Concatenation is when you have two or more strings and you want to join them into one.
word1 = 'New '
word2 = 'York'
print(word1 + word2)
New York
The string type has many built-in methods that let us manipulate them. I will demonstrate how some of these methods work.
The len()
function returns the length of a string.
print(len('New York'))
8
The replace()
method replaces a part of the string with another. As an example, let's replace
'New' for 'Old'.
print('New York'.replace('New', 'Old'))
Old York
The upper()
method will return all characters as uppercase.
print('New York'.upper())
NEW YORK
The lower()
method does the opposite, and returns all characters as lowercase.
print('New York'.lower())
new york
A list has its items ordered and you can add the same item as many times as you want. An important detail is that lists are mutable.
Mutability means you can change a list after its creation by adding items, removing them, or even just changing their values. These operations will be demonstrated later in the section dedicated to Lists.
my_list = ["bmw", "ferrari", "maclaren"]
print(type(my_list))
my_list = list(("bmw", "ferrari", "maclaren"))
print(type(my_list))
<class 'list'>
<class 'list'>
A tuple is just like a list: ordered, and allows repetition of items.
There is just one difference: a tuple is immutable.
Immutability means you can't change a tuple after its creation. If you try to add an item or update one, for instance, the Python intepreter will show you an error. I will show that these errors occur later in the section dedicated to Tuples.
my_tuple = ("bmw", "ferrari", "maclaren")
print(type(my_tuple))
my_tuple = tuple(("bmw", "ferrari", "maclaren"))
print(type(my_tuple))
<class 'tuple'>
<class 'tuple'>
Sets don't guarantee the order of the items and are not indexed.
A key point when using sets: they don't allow repetition of an item.
my_set = {"bmw", "ferrari", "maclaren"}
print(type(my_set))
my_set = set(("bmw", "ferrari", "maclaren"))
print(type(my_set))
<class 'set'>
<class 'set'>
A dictionary doesn't guarantee the order of the elements and is mutable.
One important characteristic in dictionaries is that you can set your own access keys for each element.
my_dict = {"country" : "France", "worldcups" : 2}
print(type(my_dict))
my_dict = dict(country="France", worldcups=2)
print(type(my_dict))
<class 'dict'>
<class 'dict'>
Typecasting allows you to convert between different types.
This way you can have an int
turned into a str
, or a float
turned into an
int
, for instance.
To cast a variable to a string just use the str()
function.
# this is just a regular explicit intialization
my_str = str('32')
print(my_str)
# int to str
my_str = str(32)
print(my_str)
# float to str
my_str = str(32.0)
print(my_str)
32
32
32.0
To cast a variable to an integer just use the int()
function.
# this is just a regular explicit intialization
my_int = int(32)
print(my_int)
# float to int: rounds down to 3
my_int = int(3.2)
print(my_int)
# str to int
my_int = int('32')
print(my_int)
32
3
32
To cast a variable to a float just use the float()
function.
# this is an explicit intialization
my_float = float(3.2)
print(my_float)
# int to float
my_float = float(32)
print(my_float)
# str to float
my_float = float('32')
print(my_float)
3.2
32.0
32.0
What I did above is called an explicit type conversion.
In some cases you don't need to do the conversion explicitly, since Python can do it by itself.
The example below shows implicit conversion when adding an int
and a float
.
Notice that my_sum
is float
. Python uses float
to avoid data loss since
the int
type can not represent the decimal digits.
my_int = 32
my_float = 3.2
my_sum = my_int + my_float
print(my_sum)
print(type(my_sum))
35.2
<class 'float'>
On the other hand, in this example, when you add an int
and a str
, Python will not be
able to make the implicit conversion, and the explicit type conversion is necessary.
my_int = 32
my_str = '32'
# explicit conversion works
my_sum = my_int + int(my_str)
print(my_sum)
#implicit conversion throws an error
my_sum = my_int + my_str
64
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: unsupported operand type(s) for +: 'int' and 'str'
The same error is thrown when trying to add float
and str
types without making an
explicit conversion.
my_float = 3.2
my_str = '32'
# explicit conversion works
my_sum = my_float + float(my_str)
print(my_sum)
#implicit conversion throws an error
my_sum = my_float + my_str
35.2
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: unsupported operand type(s) for +: 'float' and 'str'
If you need to interact with a user when running your program in the command line (for example, to ask for a
piece of information), you can use the input()
function.
country = input("What is your country? ") #user enters 'Brazil'
print(country)
Brazil
The captured value is always string
. Just remember that you might need to convert it using
typecasting.
age = input("How old are you? ") #user enters '29'
print(age)
print(type(age))
age = int(age)
print(type(age))
The output for each print()
is:
29
<class 'str'>
<class 'int'>
Notice the age 29 is captured as string
and then converted explicitly to int
.
In a programming language, operators are special symbols that you can apply to your variables and values in order to perform operations such as arithmetic/mathematical and comparison.
Python has lots of operators that you can apply to your variables and I will demonstrate the most used ones.
Arithmetic operators are the most common type of operators and also the most recognizable ones.
They allow you to perform simple mathematical operations.
They are:
+
: Addition-
: Subtraction*
: Multiplication/
: Division**
: Exponentiation//
: Floor Division, rounds down the result of a division%
: Modulus, gives you the remainder of a divisionLet's see a program that shows how each of them is used.
print('Addition:', 5 + 2)
print('Subtraction:', 5 - 2)
print('Multiplication:', 5 * 2)
print('Division:', 5 / 2)
print('Floor Division:', 5 // 2)
print('Exponentiation:', 5 ** 2)
print('Modulus:', 5 % 2)
Addition: 7
Subtraction: 3
Multiplication: 10
Division: 2.5
Floor Division: 2
Exponentiation: 25
Modulus: 1
Concatenation is when you have two or more strings and you want to join them into one.
This useful when you have information in multiple variables and want to combine them.
For instance, in this next example I combine two variables that contain my first name and my last name respectively to have my full name.
The +
operator is also used to concatenate.
first_name = 'Renan '
last_name = 'Moura'
print(first_name + last_name)
Renan Moura
Since concatenation is applied to strings, to concatenate strings with other types, you have to do an explicit
typecast using str()
.
I have to typecast the int
value 30 to string with str()
to concatenate it with the
rest of the string.
age = 'I have ' + str(30) + ' years old'
print(age)
I have 30 years old
Use comparison operators to compare two values.
These operators return either True
or False
.
They are:
==
: Equal!=
: Not equal>
: Greater than<
: Less than>=
: Greater than or equal to<=
: Less than or equal toLet's see a program that shows how each of them is used.
print('Equal:', 5 == 2)
print('Not equal:', 5 != 2)
print('Greater than:', 5 > 2)
print('Less than:', 5 < 2)
print('Greater than or equal to:', 5 >= 2)
print('Less than or equal to:', 5 <= 2)
Equal: False
Not equal: True
Greater than: True
Less than: False
Greater than or equal to: True
Less than or equal to: False
As the name implies, these operators are used to assign values to variables.
x = 7
in the first example is a direct assignment storing the number 7
in the variable
x
.
The assignment operation takes the value on the right and assigns it to the variable on the left.
The other operators are simple shorthands for the Arithmetic Operators.
In the second example x
starts with 7
and x += 2
is just another way to
write x = x + 2
. This means the previous value of x
is added by 2
and
reassigned to x
that is now equal to 9
.
=
: simple assignment
x = 7
print(x)
7
+=
: addition and assignment
x = 7
x += 2
print(x)
9
-=
: subtraction and assignment
x = 7
x -= 2
print(x)
5
*=
: multiplication and assignment
x = 7
x *= 2
print(x)
14
/=
: division and assignment
x = 7
x /= 2
print(x)
3.5
%=
: modulus and assignment
x = 7
x %= 2
print(x)
1
//=
: floor division and assignment
x = 7
x //= 2
print(x)
3
**=
: exponentiation and assignment
x = 7
x **= 2
print(x)
49
Logical operators are used to combine statements applying boolean algebra.
They are:
and
: True
only when both statements are trueor
: False
only when both x and y are falsenot
: The not
operator simply inverts the input, True
becomes
False
and vice versa.Let's see a program that shows how each one is used.
x = 5
y = 2
print(x == 5 and y > 3)
print(x == 5 or y > 3)
print(not (x == 5))
False
True
False
These operators provide an easy way to check if a certain object is present in a sequence: string
,
list
, tuple
, set
, and dictionary
.
They are:
in
: returns True
if the object is presentnot in
: returns True
if the object is not presentLet's see a program that shows how each one is used.
number_list = [1, 2, 4, 5, 6]
print( 1 in number_list)
print( 5 not in number_list)
print( 3 not in number_list)
True
False
True
Conditionals are one of the cornerstones of any programming language.
They allow you to control the program flow according to specific conditions you can check.
if
statementThe way you implement a conditional is through the if
statement.
The general form of an if
statement is:
if expression:
statement
The expression
contains some logic that returns a boolean, and the statement
is
executed only if the return is True
.
A simple example:
bob_age = 32
sarah_age = 29
if bob_age > sarah_age:
print('Bob is older than Sarah')
Bob is older than Sarah
We have two variables indicating the ages of Bob and Sarah. The condition in plain English says "if Bob's age is greater than Sarah's age, then print the phrase 'Bob is older than Sarah'".
Since the condition returns True
, the phrase will be printed on the console.
if else
and elif
statementsIn our last example, the program only does something if the condition returns True
.
But we also want it to do something if it returns False
or even check a second or third condition if
the first one wasn't met.
In this example, we swapped Bob's and Sarah's age. The first condition will return False
since Sarah is older now, and then the program will print the phrase after the else
instead.
bob_age = 29
sarah_age = 32
if bob_age > sarah_age:
print('Bob is older than Sarah')
else:
print('Bob is younger than Sarah')
Bob is younger than Sarah
Now, consider the example below with the elif
.
bob_age = 32
sarah_age = 32
if bob_age > sarah_age:
print('Bob is older than Sarah')
elif bob_age == sarah_age:
print('Bob and Sarah have the same age')
else:
print('Bob is younger than Sarah')
Bob and Sarah have the same age
The purpose of the elif
is to provide a new condition to be checked before the else
is
executed.
Once again we changed their ages and now both are 32 years old.
As such, the condition in the elif
is met. Since both have the same age the program will print
"Bob and Sarah have the same age".
Notice you can have as many elif
s as you want, just put them in sequence.
bob_age = 32
sarah_age = 32
if bob_age > sarah_age:
print('Bob is older than Sarah')
elif bob_age < sarah_age:
print('Bob is younger than Sarah')
elif bob_age == sarah_age:
print('Bob and Sarah have the same age')
else:
print('This one is never executed')
Bob and Sarah have the same age
In this example, the else
is never executed because all the possibilities are covered in the
previous conditions and thus could be removed.
You might need to check more than one conditional for something to happen.
In this case, you can nest your if
statements.
For instance, the second phrase "Bob is the oldest" is printed only if both if
s pass.
bob_age = 32
sarah_age = 28
mary_age = 25
if bob_age > sarah_age:
print('Bob is older than Sarah')
if bob_age > mary_age:
print('Bob is the oldest')
Bob is older than Sarah
Bob is the oldest
Or, depending on the logic, make it simpler with Boolean Algebra.
This way, your code is smaller, more readable and easier to maintain.
bob_age = 32
sarah_age = 28
mary_age = 25
if bob_age > sarah_age and bob_age > mary_age:
print('Bob is the oldest')
Bob is the oldest
The ternary operator is a one-line if
statement.
It's very handy for simple conditions.
This is how it looks:
<expression> if <condition> else <expression>
Consider the following Python code:
a = 25
b = 50
x = 0
y = 1
result = x if a > b else y
print(result)
1
Here we use four variables, a
and b
are for the condition, while x
and
y
represent the expressions.
a
and b
are the values we are checking against each other to evaluate some condition.
In this case, we are checking if a
is greater than b
.
If the expression holds true, i.e., a
is greater than b
, then the value of
x
will be attributed to result
which will be equal to 0.
However, if a
is less than b
, then we have the value of y
assigned to
result
, and result
will hold the value 1
.
Since a
is less than b
, 25 < 50, result
will have 1
as
final value from y
.
The easy way to remember how the condition is evaluated is to read it in plain English.
Our example would read: result
will be x
if a
is greater than
b
otherwise y
.
As promised in the Types section, this section and the next three about Tuples, Sets, and Dictionaries will have more in depth explanations of each of them since they are very important and broadly used structures in Python to organize and deal with data.
A list has its items ordered and you can add the same item as many times as you want.
An important detail is that lists are mutable.
Mutability means you can change a list after its creation by adding items, removing them, or even just changing their values.
people = []
people = ['Bob', 'Mary']
To add an item in the end of a list, use append()
.
people = ['Bob', 'Mary']
people.append('Sarah')
print(people)
['Bob', 'Mary', 'Sarah']
To specify the position for the new item, use the insert()
method.
people = ['Bob', 'Mary']
people.insert(0, 'Sarah')
print(people)
['Sarah', 'Bob', 'Mary']
Specify the position of the item to update and set the new value
people = ['Bob', 'Mary']
people[1] = 'Sarah'
print(people)
['Bob', 'Sarah']
Use the remove()
method to delete the item given as an argument.
people = ['Bob', 'Mary']
people.remove('Bob')
print(people)
['Mary']
To delete everybody, use the clear()
method:
people = ['Bob', 'Mary']
people.clear()
Use the index to reference the item.
Remember that the index starts at 0.
So to access the second item use the index 1.
people = ['Bob', 'Mary']
print(people[1])
Mary
people = ['Bob', 'Mary']
if 'Bob' in people:
print('Bob exists!')
else:
print('There is no Bob!')
A tuple is similar to a list: it's ordered, and allows repetition of items.
There is just one difference: a tuple is immutable.
Immutability, if you remember, means you can't change a tuple after its creation. If you try to add an item or update one, for instance, the Python interpreter will show you an error.
people = ()
people = ('Bob', 'Mary')
Tuples are immutable. This means that if you try to add an item, you will see an error.
people = ('Bob', 'Mary')
people[2] = 'Sarah'
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment
Updating an item will also return an error.
But there is a trick: you can convert into a list, change the item, and then convert it back to a tuple.
people = ('Bob', 'Mary')
people_list = list(people)
people_list[1] = 'Sarah'
people = tuple(people_list)
print(people)
('Bob', 'Sarah')
For the same reason you can't add an item, you also can't delete an item, since they are immutable.
Use the index to reference the item.
people = ('Bob', 'Mary')
print(people[1])
Mary
people = ('Bob', 'Mary')
if 'Bob' in people:
print('Bob exists!')
else:
print('There is no Bob!')
Sets don't guarantee the order of items and are not indexed.
A key point when using sets: they don't allow repetition of an item.
people = set()
people = {'Bob', 'Mary'}
Use the add()
method to add one item.
people.add('Sarah')
Use the update()
method to add multiple items at once.
people.update(['Carol', 'Susan'])
Remember, Sets do not allow repetition, so if you add 'Mary' again, nothing changes.
people = {'Bob', 'Mary'}
people.add('Mary')
print(people)
{'Bob', 'Mary'}
Items in a set are not mutable. You have to either add or delete an item.
To remove Bob from the dictionary:
people = {'Bob', 'Mary'}
people.remove('Bob')
print(people)
{'Mary'}
To delete everybody:
people.clear()
people = {'Bob', 'Mary'}
if 'Bob' in people:
print('Bob exists!')
else:
print('There is no Bob!')
The dictionary doesn't guarantee the order of the elements and it is mutable.
One important characteristic of dictionaries is that you can set your customized access keys for each element.
people = {}
people = {'Bob':30, 'Mary':25}
If the key doesn't exist yet, it is appended to the dictionary.
people['Sarah']=32
If the key already exists, the value is just updated.
#Bob's age is 28 now
people['Bob']=28
Notice that the code is pretty much the same.
To remove Bob from the dictionary:
people.pop('Bob')
To delete everybody:
people.clear()
bob_age = people['Bob']
print(bob_age)
30
if 'Bob' in people:
print('Bob exists!')
else:
print('There is no Bob!')
Loops are used when you need to repeat a block of code a certain number of times or apply the same logic over each item in a collection.
There are two types of loops: for
and while
.
You will learn about for
loops in the next section.
The basic syntax of a while
loop is as below.
while condition:
statement
The loop will continue while the condition is True
.
The example below takes each value of number
and calculates its squared value.
number = 1
while number <= 5:
print(number, 'squared is', number**2)
number = number + 1
1 squared is 1
2 squared is 4
3 squared is 9
4 squared is 16
5 squared is 25
You can use any variable name, but I chose number
because it makes sense in the context. A common
generic choice would be simply i
.
The loop will go on until number
(initialized with 1) is less than or equal to 5.
Notice that after the print()
command, the variable number
is incremented by 1 to take
the next value.
If you don't do the incrementation you will have an infinite loop since number
will never reach
a value greater than 5. This is a very important detail!
else
blockWhen the condition returns False
, the else
block will be called.
number = 1
while number <= 5:
print(number, 'squared is', number**2)
number = number + 1
else:
print('No numbers left!')
1 squared is 1
2 squared is 4
3 squared is 9
4 squared is 16
5 squared is 25
No numbers left!
Notice the phrase 'No numbers left!' is printed after the loop ends, that is after the condition
number <= 5
evaluates to False
.
while
loop in PythonSimply use the break
keyword, and the loop will stop its execution.
number = 1
while number <= 5:
print(number, 'squared is', number**2)
number = number + 1
if number == 4:
break
1 squared is 1
2 squared is 4
3 squared is 9
The loop runs normally, and when number
reaches 4 the if
statement evaluates to
True
and the break
command is called. This finishes the loop before the squared value of
the numbers 4 and 5 are calculated.
while
loopThe continue
will do that for you.
I had to invert the order of the if
statement and the print()
to show how it works
properly.
number = 0
while number < 5:
number = number + 1
if number == 4:
continue
print(number, 'squared is', number**2)
1 squared is 1
2 squared is 4
3 squared is 9
5 squared is 25
The program always checks if 4 is the current value of number
. If it is, the square of 4 won't
be calculated and the continue
will skip to the next iteration when the value of number
is 5.
*
for
loops are similar to while
loops in the sense that they are used to repeat blocks
of code.
The most important difference is that you can easily iterate over sequential types.
The basic syntax of a for
loop is as below.
for item in collection:
statement
To loop over a list or any other collection, just proceed as shown in the example below.
cars = ['BMW', 'Ferrari', 'McLaren']
for car in cars:
print(car)
BMW
Ferrari
McLaren
The list of cars
contains three items. The for
loop will iterate over the list and
store each item in the car
variable, and then execute a statement, in this case
print(car)
, to print each car in the console.
range()
functionThe range function is widely used in for loops because it gives you a simple way to list numbers.
This code will loop through the numbers 0 to 5 and print each of them.
for number in range(5):
print(number)
0
1
2
3
4
In contrast, without the range()
function, we would do something like this.
numbers = [0, 1, 2, 3, 4]
for number in numbers:
print(number)
0
1
2
3
4
You can also define a start
and stop
using range()
.
Here we are starting in 5 and a stoping in 10. The number you set to stop is not included.
for number in range(5, 10):
print(number)
5
6
7
8
9
Finally, it is also possible to set a step.
Here we starting in 10 and incrementing by 2 until 20, since 20 is the stop
, it is not included.
for number in range(10, 20, 2):
print(number)
10
12
14
16
18
else
blockWhen the items in the list are over, the else
block will be called.
cars = ['BMW', 'Ferrari', 'McLaren']
for car in cars:
print(car)
else:
print('No cars left!')
BMW
Ferrari
McLaren
No cars left!
Simply use the break
keyword, and the loop will stop its execution.
cars = ['BMW', 'Ferrari', 'McLaren']
for car in cars:
print(car)
if car == 'Ferrari':
break
BMW
Ferrari
The loop will iterate through the list and print each car.
In this case, after the loop reaches 'Ferrari', the break
is called and
'McLaren' won't be printed.
In this section, we'll learn how continue
can do this for you.
I had to invert the order of the if
statement and the continue
to show how it works
properly.
Notice that I always check if 'Ferrari' is the current item. If it is, 'Ferrari' won't
be printed, and the continue
will skip to the next item 'McLaren'.
cars = ['BMW', 'Ferrari', 'McLaren']
for car in cars:
if car == 'Ferrari':
continue
print(car)
BMW
McLaren
Sometimes you have more complex collections, like a list of lists.
To iterate over these lists, you need nested for
loops.
In this case, I have three lists: one of BMW models, another on Ferrari models, and finally one with McLaren models.
The first loop iterates over each brand's list, and the second will iterate over the models of each brand.
car_models = [
['BMW I8', 'BMW X3',
'BMW X1'],
['Ferrari 812', 'Ferrari F8',
'Ferrari GTC4'],
['McLaren 570S', 'McLaren 570GT',
'McLaren 720S']
]
for brand in car_models:
for model in brand:
print(model)
BMW I8
BMW X3
BMW X1
Ferrari 812
Ferrari F8
Ferrari GTC4
McLaren 570S
McLaren 570GT
McLaren 720S
The same logic that applies for
loops over a list
can be extended to the other data
structures: tuple
, set
, and dictionary
.
I will briefly demonstrate how to make a basic loop over each one of them.
people = ('Bob', 'Mary')
for person in people:
print(person)
Bob
Mary
people = {'Bob', 'Mary'}
for person in people:
print(person)
Bob
Mary
To print the keys:
people = {'Bob':30, 'Mary':25}
for person in people:
print(person)
Bob
Mary
To print the values:
people = {'Bob':30, 'Mary':25}
for person in people:
print(people[person])
30
25
As the code grows the complexity also grows. And functions help organize the code.

In Python use the def
keyword to define a function.
Give it a name and use parentheses to inform 0 or more arguments.
In the line after the declaration starts, remember to indent the block of code.
Here is an example of a function called print_first_function()
that only prints a phrase 'My
first function!'.
To call the function just use its name as defined.
def print_first_function():
print('My first function!')
print_first_function()
My first function!
return
a valueUse the return
keyword to return a value from the function.
In this example the function second_function()
returns the string 'My second function!'.
Notice that print()
is a built-in function and our function is called from inside it.
The string returned by second_function()
is passed as an argument to the print()
function.
def second_function():
return 'My second function!'
print(second_function())
My second function!
return
multiple valuesFunctions can also return multiple values at once.
return_numbers()
returns two values simultaneously.
def return_numbers():
return 10, 2
print(return_numbers())
(10, 2)
You can define parameters between the parentheses.
When calling a function with parameters you have to pass arguments according to the parameters defined.
The past examples had no parameters, so there was no need for arguments. The parentheses remained empty when the functions were called.
To specify one parameter, just define it inside the parentheses.
In this example, the function my_number
expects one number as argument defined by the parameter
num
.
The value of the argument is then accessible inside the function to be used.
def my_number(num):
return 'My number is: ' + str(num)
print(my_number(10))
My number is: 10
To define more parameters, just use a comma to separate them.
Here we have a function that adds two numbers called add
. It expects two arguments defined by
first_num
and second_num
.
The arguments are added by the +
operator and the result is then returned by the
return
.
def add(first_num, second_num):
return first_num + second_num
print(add(10,2))
12
This example is very similar to the last one. The only difference is that we have 3 parameters instead of 2.
def add(first_num, second_num, third_num):
return first_num + second_num + third_num
print(add(10,2,3))
15
This logic of defining parameters and passing arguments is the same for any number of parameters.
It is important to point out that the arguments have to be passed in the same order that the parameters are defined.
You can set a default value for a parameter if no argument is given using the =
operator and a value
of choice.
In this function, if no argument is given, the number 30 is assumed as the expected value by default.
def my_number(my_number = 30):
return 'My number is: ' + str(my_number)
print(my_number(10))
print(my_number())
My number is: 10
My number is: 30
When calling a function, the order of the arguments have to match the order of the parameters.
The alternative is if you use keyword or named arguments.
Set the arguments to their respective parameters directly using the name of the parameters and the =
operators.
This example flips the arguments, but the function works as expected because I tell it which value goes to which parameter by name.
def my_numbers(first_number, second_number):
return 'The numbers are: ' + str(first_number) + ' and ' + str(second_number)
print(my_numbers(second_number=30, first_number=10))
The numbers are: 10 and 30
*args
If you don't want to specify the number of parameters, just use the *
before the parameter
name. Then the function will take as many arguments as necessary.
The parameter name could be anything like *numbers
, but there is a convention in Python to use
*args
for this definition of a variable number of arguments.
def my_numbers(*args):
for arg in args:
print(number)
my_numbers(10,2,3)
10
2
3
**kwargs
Similar to *args
, we can use **kwargs
to pass as many keyword arguments as we want, as
long as we use **
.
Again, the name could be anything like **numbers
, but **kwargs
is a convention.
def my_numbers(**kwargs):
for key, value in kwargs.items():
print(key)
print(value)
my_numbers(first_number=30, second_number=10)
first_number
30
second_number
10
The past examples used mainly numbers, but you can pass any type as argument and they will be treated as such inside the function.
This example takes strings as arguments.
def my_sport(sport):
print('I like ' + sport)
my_sport('football')
my_sport('swimming')
I like football
I like swimming
This function takes a list as argument.
def my_numbers(numbers):
for number in numbers:
print(number)
my_numbers([30, 10, 64, 92, 105])
30
10
64
92
105
The place where a variable is created defines its availability to be accessed and manipulated by the rest of the code. This is known as scope.
There are two types of scope: local and global.
A global scope allows you to use the variable anywhere in your program.
If your variable is outside a function, it has global scope by default.
name = 'Bob'
def print_name():
print('My name is ' + name)
print_name()
My name is Bob
Notice that the function could use the variable name
and print My name is Bob
.
When you declare a variable inside a function, it only exists inside that function and can't be accessed from the outside.
def print_name():
name = "Bob"
print('My name is ' + name)
print_name()
My name is Bob
The variable name
was declared inside the function, so the output is the same as before.
But this will throw an error:
def print_name():
name = 'Bob'
print('My name is ' + name)
print(name)
The output of the code above is:
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'name' is not defined
I tried to print the variable name
from outside the function, but the scope of the variable was
local and could not be found in a global scope.
If you use the same name for variables inside and outside a function, the function will use the one inside its scope.
So when you call print_name()
, the name='Bob'
is used to print the phrase.
On the other hand, when calling print()
outside the function scope,
name="Sarah"
is used because of its global scope.
name = "Sarah"
def print_name():
name = 'Bob'
print('My name is ' + name)
print_name()
print(name)
The output of the code above is:
My name is Bob
Sarah
Sometimes we want to perform some very simple operations over the items of a list.
List comprehensions give us a succinct way to work on lists as an alternative to other methods of iteration, such
as for
loops.
To use a list comprehension to replace a regular for loop, we can make:
[expression for item in list]
Which is the same as doing:
for item in list:
expression
If we want some conditional to apply the expression, we have:
[expression for item in list if conditional ]
Which is the same as doing:
for item in list:
if conditional:
expression
Regular way
numbers = [1, 2, 3, 4, 5]
new_list = []
for n in numbers:
new_list.append(n**3)
print(new_list)
[1, 8, 27, 64, 125]
Using list comprehensions
numbers = [1, 2, 3, 4, 5]
new_list = []
new_list = [n**3 for n in numbers]
print(new_list)
[1, 8, 27, 64, 125]
Using the conditional, we can filter only the values we want the expression to be applied to.
Regular way
numbers = [1, 2, 3, 4, 5]
new_list = []
for n in numbers:
if(n > 3):
new_list.append(n**3)
print(new_list)
[64, 125]
Using list comprehensions
numbers = [1, 2, 3, 4, 5]
new_list = []
new_list = [n**3 for n in numbers if n > 3]
print(new_list)
[64, 125]
We can also call functions using the list comprehension syntax:
numbers = [1, 2, 3, 4, 5]
new_list = []
def cube(number):
return number**3
new_list = [cube(n) for n in numbers if n > 3]
print(new_list)
[64, 125]
A Python lambda function can only have one expression and can't have multiple lines.
It is supposed to make it easier to create some small logic in one line instead of a whole function as is usually done.
Lambda functions are also anonymous, which means there is no need to name them.
The basic syntax is very simple: just use the lambda
keyword, define the parameters needed, and use
":" to separate the parameters from the expression.
The general forms is:
lambda arguments : expression
Look at this example using only one parameter
cubic = lambda number : number**3
print(cubic(2))
8
If you want, you can also have multiple parameters.
exponential = lambda multiplier, number, exponent : multiplier * number**exponent
print(exponential(2, 2, 3))
16
You don't need to use a variable as we did before. Instead you can make use of parenthesis around the lambda function and another pair of parenthesis around the arguments.
The declaration of the function and the execution will happen in the same line.
(lambda multiplier, number, exponent : multiplier * number**exponent)(2, 2, 3)
16
The Map function applies the expression to each item in a list.
Let's calculate the cubic of each number in the list.
numbers = [2, 5, 10]
cubics = list(map(lambda number : number**3, numbers))
print(cubics)
[8, 125, 1000]
The Filter function will filter the list based on the expression.
Let's filter to have only the numbers greater than 5.
numbers = [2, 5, 10]
filtered_list = list(filter(lambda number : number > 5, numbers))
print(filtered_list)
[10]
After some time your code starts to get more complex with lots of functions and variables.
To make it easier to organize the code we use Modules.
A well-designed Module also has the advantage of being reusable, so you write code once and reuse it everywhere.
You can write a module with all the mathematical operations and other people can use it.

In other programming languages, these are also referred to as libraries.
To use a module we use the import
keyword.
As the name implies we have to tell our program what module to import.
After that, we can use any function available in that module.
Let's see an example using the math
module.
First, let's see how to have access to a constant, Euler's number.
import math
math.e
2.718281828459045
In this second example, we are going to use a function that calculates the square root of a number.
It is also possible to use the as
keyword to create an alias.
import math as m
m.sqrt(121)
m.sqrt(729)
11
27
Finally, using the from
keyword, we can specify exactly what to import instead of the whole module
and use the function directly without the module's name.
This example uses the floor()
function that returns the largest integer less than or equal to a
given number.
from math import floor
floor(9.8923)
9
Now that we know how to use modules, let's see how to create one.
It is going to be a module with the basic math operations add
, subtract
,
multiply
, divide
and it is gonna be called basic_operations
.
Create the basic_operations.py
file with the four functions.
def add(first_num, second_num):
return first_num + second_num
def subtract(first_num, second_num):
return first_num - second_num
def multiply(first_num, second_num):
return first_num * second_num
def divide(first_num, second_num):
return first_num / second_num
Then, just import the basic_operations
module and use the functions.
import basic_operations
basic_operations.add(10,2)
basic_operations.subtract(10,2)
basic_operations.multiply(10,2)
basic_operations.divide(10,2)
12
8
20
5.0
You are in the process of building a module with the basic math operations add
,
subtract
, multiply
, and divide
called basic_operations
saved
in the basic_operations.py
file.
To guarantee everything is fine, you can run some tests.
def add(first_num, second_num):
return first_num + second_num
def subtract(first_num, second_num):
return first_num - second_num
def multiply(first_num, second_num):
return first_num * second_num
def divide(first_num, second_num):
return first_num / second_num
print(add(10, 2))
print(subtract(10,2))
print(multiply(10,2))
print(divide(10,2))
After running the code:
renan@pro-home:~$ python3 basic_operations.py
The output is:
12
8
20
5.0
The output for those tests are what we expected.
Our code is right and ready to share.
Let's import the new module run it in the Python console.
Python 3.6.9 (default, Nov 7 2019, 10:44:02)
[GCC 8.3.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> import basic_operations
12
8
20
5.0
>>>
When the module is imported our tests are displayed on the screen even though we didn't do anything besides
importing basic_operations
.
To fix that we use if __name__ == '__main__'
in the basic_operations.py
file
like this:
def add(first_num, second_num):
return first_num + second_num
def subtract(first_num, second_num):
return first_num - second_num
def multiply(first_num, second_num):
return first_num * second_num
def divide(first_num, second_num):
return first_num / second_num
if __name__ == '__main__':
print(add(10, 2))
print(subtract(10,2))
print(multiply(10,2))
print(divide(10,2))
Running the code directly on the terminal will continue to display the tests. But when you import it like a module, the tests won't show and you can use the functions the way you intended.
Python 3.6.9 (default, Nov 7 2019, 10:44:02)
[GCC 8.3.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> import basic_operations
>>> basic_operations.multiply(10,2)
20
>>>
Now that you know how to use the if __name__ == '__main__'
, let's understand how it
works.
The condition tells when the interpreter is treating the code as a module or as a program itself being executed directly.
Python has this native variable called __name__
.
This variable represents the name of the module which is the name of the .py
file.
Create a file my_program.py
with the following and execute it.
print(__name__)
The output will be:
__main__
This tells us that when a program is executed directly, the variable __name__
is defined as
__main__
.
But when it is imported as a module, the value of __name__
is the name of the module.
Python 3.6.9 (default, Nov 7 2019, 10:44:02)
[GCC 8.3.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> import my_program
my_program
>>>
This is how the Python interpreter differentiates the behavior of an imported module and a program executed directly on the terminal.
Creating, deleting, reading, and many other functions applied to files are an integral part of many programs.
As such, it is very important to know how to organize and deal with files directly from your code.
Let's see how to handle files in Python.
First things first, create!
We are going to use the open()
function.
This function opens a file and returns its corresponding object.
The first argument is the name of the file we are handling, the second refers to the operation we are using.
The code below creates the file "people.txt", the x
argument is used when we just want to
create the file. If a file with the same name already exists, it will throw an exception.
people_file = open("people.txt", "x")
You can also use the w
mode to create a file. Unlike the x
mode, it will not throw an
exception since this mode indicates the writing mode. We are opening a file to write data into it and, if
the file doesn't exist, it is created.
people_file = open("people.txt", "w")
The last one is the a
mode which stands for append. As the name implies, you can append
more data to the file, while the w
mode simply overwrites any existing data.
When appending, if the file doesn't exist, it also creates it.
people_file = open("people.txt", "a")
To write data into a file, you simply open a file with the w
mode.
Then, to add data, you use the object return by the open()
function. In this case, the object is
called people_file
. Then you call the write() function passing the data as argument.
people_file = open("people.txt", "w")
people_file.write("Bob\n")
people_file.write("Mary\n")
people_file.write("Sarah\n")
people_file.close()
We use \n
at the end to break the line, otherwise the content in the file will stay in the same line
as "BobMarySarah".
One more detail is to close() the file. This is not only a good practice, but also ensures that your changes were applied to the file.
Remember that when using w
mode, the data that already existed in the file will be overwritten by
the new data. To add new data without losing what was already there, we have to use the append mode.
The a
mode appends new data to the file, keeping the existing one.
In this example, after the first writing with w
mode, we are using the a
mode to
append. The result is that each name will appear twice in the file "people.txt".
#first write
people_file = open("people.txt", "w")
people_file.write("Bob\n")
people_file.write("Mary\n")
people_file.write("Sarah\n")
people_file.close()
#appending more data
#keeping the existing data
people_file = open("people.txt", "a")
people_file.write("Bob\n")
people_file.write("Mary\n")
people_file.write("Sarah\n")
people_file.close()
Reading the file is also very straightforward: just use the r
mode like so.
If you read the "people.txt" file created in the last example, you should see 6 names in your output.
people_file = open("people.txt", "r")
print(people_file.read())
Bob
Mary
Sarah
Bob
Mary
Sarah
The read()
function reads the whole file at once. If you use the readline()
function,
you can read the file line by line.
people_file = open("people.txt", "r")
print(people_file.readline())
print(people_file.readline())
print(people_file.readline())
Bob
Mary
Sarah
You can also loop to read the lines like the example below.
people_file = open("people.txt", "r")
for person in people_file:
print(person)
Bob
Mary
Sarah
Bob
Mary
Sarah
To delete a file, you also need the os
module.
Use the remove()
method.
import os
os.remove('my_file.txt')
Use the os.path.exists()
method to check the existence of a file.
import os
if os.path.exists('my_file.txt'):
os.remove('my_file.txt')
else:
print('There is no such file!')
For this one, I like to use the copyfile()
method from the shutil
module.
from shutil import copyfile
copyfile('my_file.txt','another_file.txt')
There are a few options to copy a file, but copyfile()
is the fastest one.
If you need to move or rename a file you can use the move()
method from the shutil
module.
from shutil import move
move('my_file.txt','another_file.txt')
Classes and Objects are the fundamental concepts of Object-Oriented Programming.
In Python, everything is an object!
A variable (object) is just an instance of its type (class).
That's why when you check the type of a variable you can see the class
keyword right next to
its type (class).
This code snippet shows that my_city
is an object and it is an instance of the class
str
.
my_city = "New York"
print(type(my_city))
<class 'str'>
The class gives you a standard way to create objects. A class is like a base project.
Say you are an engineer working for Boeing.
Your new mission is to build the new product for the company, a new model called 747-Space. This aircraft flies higher altitudes than other commercial models.
Boeing needs to build dozens of those to sell to airlines all over the world, and the aircrafts have to be all the same.
To guarantee that the aircrafts (objects) follow the same standards, you need to have a project (class) that can be replicable.
The class is a project, a blueprint for an object.
This way you make the project once, and reuse it many times.
In our code example before, consider that every string has the same behavior and the same attributes. So it only
makes sense for strings to have a class str
to define them.
Objects have some behavior which is is given by attributes and methods.
In simple terms, in the context of an object, attributes are variables and methods are functions attached to an object.
For example, a string has many built-in methods that we can use.
They work like functions, you just need to separate them from the objects using a .
.
In this code snippet, I'm calling the replace()
method from the string variable
my_city
which is an object, and an instance of the class str
.
The replace()
method replaces a part of the string for another and returns a new string with the
change. The original string remains the same.
Let's replace 'New' for 'Old' in 'New York'.
my_city = 'New York'
print(my_city.replace('New', 'Old'))
print(my_city)
Old York
New York
We have used many objects (instances of classes) like strings, integers, lists, and dictionaries. All of them are instances of predefined classes in Python.
To create our own classes we use the class
keyword.
By convention, the name of the class matches the name of the .py
file and the module by consequence.
It is also a good practice to organize the code.
Create a file vehicle.py
with the following class Vehicle
.
class Vehicle:
def __init__(self, year, model, plate_number, current_speed = 0):
self.year = year
self.model = model
self.plate_number = plate_number
self.current_speed = current_speed
def move(self):
self.current_speed += 1
def accelerate(self, value):
self.current_speed += value
def stop(self):
self.current_speed = 0
def vehicle_details(self):
return self.model + ', ' + str(self.year) + ', ' + self.plate_number
Let's break down the class to explain it in parts.
The class
keyword is used to specify the name of the class Vehicle
.
The __init__
function is a built-in function that all classes have. It is called when an object is
created and is often used to initialize the attributes, assigning values to them, similar to what is done to
variables.
The first parameter self
in the __init__
function is a reference to the object
(instance) itself. We call it self
by convention and it has to be the first parameter in every
instance method, as you can see in the other method definitions def move(self)
, def
accelerate(self, value)
, def stop(self)
, and def vehicle_details(self)
.
Vehicle
has 5 attributes (including self): year
, model
,
plate_number
, and current_speed
.
Inside the __init__
, each one of them is initialized with the parameters given when the object is
instantiated.
Notice that current_speed
is initialized with 0
by default, meaning that if no value is
given, current_speed
will be equal to 0 when the object is first instantiated.
Finally, we have three methods to manipulate our vehicle regarding its speed: def move(self)
,
def accelerate(self, value)
, and def stop(self)
.
And one method to give back information about the vehicle: def vehicle_details(self)
.
The implementation inside the methods work the same way as in functions. You can also have a return
to give you back some value at the end of the method as demonstrated by def vehicle_details(self)
.
To use the class in your terminal, import the Vehicle
class from the vehicle
module.
Create an instance called my_car
, initializing year
with 2009, model
with
'F8', plate_number
with 'ABC1234', and current_speed
with 100.
The self
parameter is not taken into consideration when calling methods. The Python interpreter
infers its value as being the current object/instance automatically, so we just have to pass the other arguments
when instantiating and calling methods.
Now use the methods to move()
the car which increases its current_speed
by 1,
accelerate(10)
which increases its current_speed
by the value given in the argument, and
stop()
which sets the current_speed
to 0.
Remember to print the value of current_speed
at every command to see the changes.
To finish the test, call vehicle_details()
to print the information about our vehicle.
>>> from vehicle import Vehicle
>>>
>>> my_car = Vehicle(2009, 'F8', 'ABC1234', 100)
>>> print(my_car.current_speed)
100
>>> my_car.move()
>>> print(my_car.current_speed)
101
>>> my_car.accelerate(10)
>>> print(my_car.current_speed)
111
>>> my_car.stop()
>>> print(my_car.current_speed)
0
>>> print(my_car.vehicle_details())
F8, 2009, ABC1234
If we don't set the initial value for current_speed
, it will be zero by default as stated
before and demonstrated in the next example.
>>> from vehicle import Vehicle
>>>
>>> my_car = Vehicle(2009, 'F8', 'ABC1234')
>>> print(my_car.current_speed)
0
>>> my_car.move()
>>> print(my_car.current_speed)
1
>>> my_car.accelerate(10)
>>> print(my_car.current_speed)
11
>>> my_car.stop()
>>> print(my_car.current_speed)
0
>>> print(my_car.vehicle_details())
F8, 2009, ABC1234
Let's define a generic Vehicle
class and save it inside the vehicle.py
file.
class Vehicle:
def __init__(self, year, model, plate_number, current_speed):
self.year = year
self.model = model
self.plate_number = plate_number
self.current_speed = current_speed
def move(self):
self.current_speed += 1
def accelerate(self, value):
self.current_speed += value
def stop(self):
self.current_speed = 0
def vehicle_details(self):
return self.model + ', ' + str(self.year) + ', ' + self.plate_number
A vehicle has attributes year
, model
, plate_number
, and
current_speed
.
The definition of vehicle in the Vehicle
is very generic and might not be suitable for trucks, for
instance, because it should include a cargo
attribute.
On the other hand, a cargo attribute does not make much sense for small vehicles like motorcycles.
To solve this we can use inheritance.
When a class (child) inherits another class (parent), all the attributes and methods from the parent class are inherited by the child class.
In our case, we want a new Truck
class to inherit everything from the Vehicle
class.
Then we want it to add its own specific attribute current_cargo
to control the addition and removal
of cargo from the truck.
The Truck
class is called a child class that inherits from its parent class
Vehicle
.
A parent class is also called a superclass while a child class is also known as a subclass.
Create the class Truck
and save it inside the truck.py
file.
from vehicle import Vehicle
class Truck(Vehicle):
def __init__(self, year, model, plate_number, current_speed, current_cargo):
super().__init__(year, model, plate_number, current_speed)
self.current_cargo = current_cargo
def add_cargo(self, cargo):
self.current_cargo += cargo
def remove_cargo(self, cargo):
self.current_cargo -= cargo
Let's break down the class to explain it in parts.
The class Vehicle
inside the parentheses when defining the class Truck
indicates that
the parent Vehicle
is being inherited by its child Truck
.
The __init__
method has self
as its first parameter, as usual.
The parameters year
, model
, plate_number
, and current_speed
are there to match the ones in the Vehicle
class.
We added a new parameter current_cargo
suited for the Truck
class.
In the first line of the __init__
method of the Truck
class we have to call the
__init__
method of the Vehicle
class.
To do that we use super()
to make a reference to the supperclass Vehicle
, so
when super().__init__(year, model, plate_number, current_speed)
is called we avoid repetition of our
code.
After that, we can assign the value of current_cargo
normally.
Finally, we have two methods to deal with the current_cargo
: def add_cargo(self,
cargo):
, and def remove_cargo(self, cargo):
.
Remember that Truck
inherits attributes and methods from Vehicle
, so we also have an
implicit access to the methods that manipulate the speed: def move(self)
, def accelerate(self,
value)
, and def stop(self)
.
Truck
classTo use the class in your terminal, import the Truck
class from the truck
module.
Create an instance called my_truck
, initializing year
with 2015, model
with 'V8', plate_number
with 'XYZ1234', current_speed
with 0, and
current_cargo
with 0.
Use add_cargo(10)
to increase current_cargo
by 10, remove_cargo(4)
, to
decrease current_cargo
by 4.
Remember to print the value of current_cargo
at every command to see the changes.
By inheritance, we can use the methods from the Vehicle
class to move()
the truck which
increases its current_speed
by 1, accelerate(10)
which increases its
current_speed
by the value given in the argument, and stop()
which sets the
current_speed
to 0.
Remember to print the value of current_speed
at every interaction to see the changes.
To finish the test, call vehicle_details()
inherited from the Vehicle
class to print
the information about our truck.
>>> from truck import Truck
>>>
>>> my_truck = Truck(2015, 'V8', 'XYZ1234', 0, 0)
>>> print(my_truck.current_cargo)
0
>>> my_truck.add_cargo(10)
>>> print(my_truck.current_cargo)
10
>>> my_truck.remove_cargo(4)
>>> print(my_truck.current_cargo)
6
>>> print(my_truck.current_speed)
0
>>> my_truck.accelerate(10)
>>> print(my_truck.current_speed)
10
>>> my_truck.stop()
>>> print(my_truck.current_speed)
0
>>> print(my_truck.vehicle_details())
V8, 2015, XYZ1234
Errors are a part of every programmer's life, and knowing how to deal with them is a skill on its own.
The way Python deals with errors is called 'Exception Handling'.
If some piece of code runs into an error, the Python interpreter will raise an exception.
Let's try to raise some exceptions on purpose and see the errors they produce.
TypeError
First, try to add a string and an integer
'I am a string' + 32
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: must be str, not int
IndexError
Now, try to access an index that doesn't exist in a list.
A common mistake is to forget that sequences are 0-indexed, meaning the first item has index 0, not 1.
In this example, the list car_brands
ends at index 2.
car_brands = ['ford', 'ferrari', 'bmw']
print(car_brands[3])
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
IndexError: list index out of range
NameError
If we try to print a variable that doesn't exist:
print(my_variable)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'my_variable' is not defined
ZeroDivisionError
Math doesn't allow division by zero, so trying to do so will raise an error, as expected.
32/0
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ZeroDivisionError: division by zero
This was just a sample of the kinds of exceptions you might see during your daily routine and what can cause each of them.
Now we know how to cause errors that will crash our code and show us some message saying something is wrong.
To handle these exceptions just make use of the try/except
statement.
try:
32/0
except:
print('Dividing by zero!')
Dividing by zero!
The example above shows the use of the try
statement.
Put the block of code that may cause an exception inside the try
scope. If everything runs alright,
the except
block is not invoked. But if an exception is raised, the block of code inside the
except
is executed.
This way the program doesn't crash and if you have some code after the exception, it will keep running if you want it to.
In the last example the except
block was generic, meaning it was catching anything.
Good practice it to specify the type of exception we are trying to catch, which helps a lot when debugging the code later.
If you know a block of code can throw an IndexError
, specify it in the except
:
try:
car_brands = ['ford', 'ferrari', 'bmw']
print(car_brands[3])
except IndexError:
print('There is no such index!')
There is no such index!
You can use a tuple to specify as many exception types as you want in a single except
:
try:
print('My code!')
except(IndexError, ZeroDivisionError, TypeError):
print('My Excepetion!')
else
It is possible to add an else
command at the end of the try/except
. It runs only if
there are no exceptions.
my_variable = 'My variable'
try:
print(my_variable)
except NameError:
print('NameError caught!')
else:
print('No NameError')
My variable
No NameError
The raise
command allows you to manually raise an exception.
This is particularly useful if you want to catch an exception and do something with it -- like logging the error in some personalized way like redirecting it to a log aggregator, or ending the execution of the code since the error should not allow the progress of the program.
try:
raise IndexError('This index is not allowed')
except:
print('Doing something with the exception!')
raise
Doing something with the exception!
Traceback (most recent call last):
File "<stdin>", line 2, in <module>
IndexError: This index is not allowed
finally
The finally
block is executed independently of exceptions being raised or not.
They are usually there to allow the program to clean up resources like files, memory, network connections, etc.
try:
print(my_variable)
except NameError:
print('Except block')
finally:
print('Finally block')
Except block
Finally block


func NewReferenceError(correlationId string, locator interface{}) *errors.ApplicationError
Creates an error instance and assigns its values. Parameters:
- correlationId string - locator interface{} the locator to find reference to dependent component.
Returns *errors.ApplicationError
Helper class for resolving component dependencies.
The resolver is configured to resolve named dependencies by specific locator. During deployment the dependency locator can be changed.
This mechanism can be used to clarify specific dependency among several alternatives. Typically components are configured to retrieve the first dependency that matches logical group, type and version. But if container contains more than one instance and resolution has to be specific about those instances, they can be given a unique name and dependency resolvers can be reconfigured to retrieve dependencies by their name.
Configuration parameters
dependencies: [dependency name 1]: Dependency 1 locator (descriptor) ... [dependency name N]: Dependency N locator (descriptor)
References References must match configured dependencies.
Example:
type DependencyResolver struct {
// contains filtered or unexported fields
}
func NewDependencyResolver() *DependencyResolver
Creates a new instance of the dependency resolver. Returns *DependencyResolver
func NewDependencyResolverFromTuples(tuples ...interface{}) *DependencyResolver
Creates a new DependencyResolver from a list of key-value pairs called tuples where key is dependency name and value the depedency locator (descriptor). see NewDependencyResolverFromTuplesArray Parameters:
- tuples ...interface{} a list of values where odd elements are dependency name and the following even elements are dependency locator (descriptor)
Returns *DependencyResolver a newly created DependencyResolver.
func NewDependencyResolverWithParams(config *conf.ConfigParams, references IReferences) *DependencyResolver
Creates a new instance of the dependency resolver. see ConfigParams see configure see IReferences see setReferences Parameters:
- config ConfigParams default configuration where key is dependency name and value is locator (descriptor) - references IReferences default component references
Returns *DependencyResolver
func (c *DependencyResolver) Configure(config *conf.ConfigParams)
Configures the component with specified parameters. see ConfigParams Parameters:
- config *conf.ConfigParams configuration parameters to set.
func (c *DependencyResolver) Find(name string, required bool) ([]interface{}, error)
Finds all matching dependencies by their name. throws a ReferenceError of required is true and no dependencies found. Parameters:
- name string the dependency name to locate. - required bool true to raise an exception when no dependencies are found.
Returns []interface{}, error a list of found dependencies and error
func (c *DependencyResolver) GetOneOptional(name string) interface{}
Gets one optional dependency by its name. Parameters:
- name string the dependency name to locate.
Returns interface{} a dependency reference or nil of the dependency was not found
func (c *DependencyResolver) GetOneRequired(name string) (interface{}, error)
func (c *DependencyResolver) GetOptional(name string) []interface{}
Gets all optional dependencies by their name. Parameters:
- name string
the dependency name to locate. Returns []interface{} a list with found dependencies or empty list of no dependencies was found.
func (c *DependencyResolver) GetRequired(name string) ([]interface{}, error)
Gets all required dependencies by their name. At least one dependency must be present. If no dependencies was found it throws a ReferenceError throws a ReferenceError if no dependencies were found. Parameters:
- name string the dependency name to locate.
Returns []interface{} a list with found dependencies.
func (c *DependencyResolver) Locate(name string) interface{}
Locate dependency by name Parameters:
- name string dependency name
Returns interface{} located dependency
func (c *DependencyResolver) Put(name string, locator interface{})
func (c *DependencyResolver) SetReferences(references IReferences)
Sets the component references. References must match configured dependencies. Parameters:
- references IReferences references to set.
Locator type that most often used in PipServices toolkit. It locates components using several fields:
Group: a package or just named group of components like "pip-services" Type: logical component type that defines it's contract like "persistence" Kind: physical implementation type like "mongodb" Name: unique component name like "default" Version: version of the component contract like "1.0" The locator matching can be done by all or only few selected fields. The fields that shall be excluded from the matching must be set to "*" or null. That approach allows to implement many interesting scenarios. For instance:
Locate all loggers (match by type and version) Locate persistence components for a microservice (match by group and type) Locate specific component by its name (match by name) Example
locator1 := NewDescriptor("mygroup", "connector", "aws", "default", "1.0"); locator2 := NewDescriptorFromString("mygroup:connector:*:*:1.0"); locator1.Match(locator2); // Result: true locator1.Equal(locator2); // Result: true locator1.ExactMatch(locator2); // Result: false
type Descriptor struct {
// contains filtered or unexported fields
}
func NewDescriptor(group string, typ string, kind string, name string, version string) *Descriptor
func ParseDescriptorFromString(value string) (*Descriptor, error)
Parses colon-separated list of descriptor fields and returns them as a Descriptor. throws a ConfigError if the descriptor string is of a wrong format. Parameters:
- value string colon-separated descriptor fields to initialize Descriptor.
Returns *Descriptor a newly created Descriptor.
func (c *Descriptor) Equals(value interface{}) bool
Compares this descriptor to a value. If value is a Descriptor it tries to match them, otherwise the method returns false. see Match Parameters:
- value interface{} the value to match against this descriptor.
Returns bool true if the value is matching descriptor and false otherwise.
func (c *Descriptor) ExactMatch(descriptor *Descriptor) bool
Matches this descriptor to another descriptor by all fields. No exceptions are made. see Match Parameters:
- descriptor *Descriptor the descriptor to match this one against.
Returns bool true if descriptors match and false otherwise.
func (c *Descriptor) Group() string
Gets the component's logical group. Returns string the component's logical group
func (c *Descriptor) IsComplete() bool
Checks whether all descriptor fields are set. If descriptor has at least one "*" or null field it is considered "incomplete", Returns bool true if all descriptor fields are defined and false otherwise.
func (c *Descriptor) Kind() string
Gets the component's implementation type. Returns string the component's implementation type.
func (c *Descriptor) Match(descriptor *Descriptor) bool
Partially matches this descriptor to another descriptor. Fields that contain "*" or null are excluded from the match. see exactMatch Parameters:
- descriptor *Descriptor the descriptor to match this one against.
Returns bool true if descriptors match and false otherwise
func (c *Descriptor) Name() string
Gets the unique component's name. Returns string the unique component's name.
func (c *Descriptor) String() string
Gets a string representation of the object. The result is a colon-separated list of descriptor fields as "mygroup:connector:aws:default:1.0" Returns string a string representation of the object.
func (c *Descriptor) Type() string
Gets the component's logical type. Returns string the component's logical type.
func (c *Descriptor) Version() string
Gets the component's implementation version. Returns string the component's implementation version.
Interface for components that depends on other components.
If component requires explicit notification to unset references it shall additionally implement IUnreferenceable interface.
see IReferences
see IUnreferenceable
see Referencer
Example
type MyController { _persistence IPersistence } func (mc* MyController) setReferences(references IReferences) { mc._persistence = references.getOneRequired( NewDescriptor("mygroup", "persistence", "*", "*", "1.0")) ); } ... }
type IReferenceable interface { // Sets references to dependent components. // see // IReferences // Parameters: // - references IReferences // references to locate the component dependencies. SetReferences(references IReferences) }
type IReferences interface { // Puts a new reference into this reference map. // Parameters: // - locator interface{} // a locator to find the reference by. // - component interface{} // a component reference to be added. // Returns interface{} Put(locator interface{}, component interface{}) // Removes a previously added reference that matches specified locator. If many references match the locator, it removes only the first one. When all references shall be removed, use removeAll method instead. // see // RemoveAll // Parameters: // - locator interface{} // a locator to remove reference // Returns interface{} // the removed component reference. Remove(locator interface{}) interface{} // Removes all component references that match the specified locator. // Parameters: // - locator interface{} // the locator to remove references by. // Returns []interface{} // a list, containing all removed references. RemoveAll(locator interface{}) []interface{} // Gets locators for all registered component references in this reference map. // Returns []interface{} // a list with component locators. GetAllLocators() []interface{} // Gets all component references registered in this reference map. // Returns []interface{} // a list with component references. GetAll() []interface{} // Gets all component references that match specified locator. // Parameters: // - locator interface{} // the locator to find references by. // Returns []interface{} // a list with matching component references or empty list if nothing was found. GetOptional(locator interface{}) []interface{} // Gets all component references that match specified locator. At least one component reference must be present. If it doesn't the method throws an error. // throws // a ReferenceException when no references found. // Parameters: // - locator interface{} // the locator to find references by. // Returns []interface{} // a list with matching component references. GetRequired(locator interface{}) ([]interface{}, error) // Gets an optional component reference that matches specified locator. // Parameters: // - locator interface{} // the locator to find references by. // Returns interface{} // a matching component reference or nil if nothing was found. GetOneOptional(locator interface{}) interface{} // Gets a required component reference that matches specified locator. // throws // a ReferenceError when no references found. // Parameters: // - locator interface{} // the locator to find a reference by. // Returns interface{} // a matching component reference. GetOneRequired(locator interface{}) (interface{}, error) // Gets all component references that match specified locator. // throws // a ReferenceError when required is set to true but no references found. // Parameters: // - locator interface{} // the locator to find a reference by. // - required bool // forces to raise an exception if no reference is found. // Returns []interface{} // a list with matching component references. Find(locator interface{}, required bool) ([]interface{}, error) }
type IUnreferenceable interface {
//Unsets (clears) previously set references to dependent components.
UnsetReferences()
}
Contains a reference to a component and locator to find it. It is used by References to store registered component references.
type Reference struct {
// contains filtered or unexported fields
}
func NewReference(locator interface{}, component interface{}) *Reference
Create a new instance of the reference object and assigns its values. Parameters:
- locator interface{} a locator to find the reference. - component interface {}
Returns *Reference
func (c *Reference) Component() interface{}
Gets the stored component reference. Returns any the component's references.
func (c *Reference) Locator() interface{}
Gets the stored component locator. Returns any the component's locator.
func (c *Reference) Match(locator interface{}) bool
Matches locator to this reference locator. Descriptors are matched using equal method. All other locator types are matched using direct comparison. see Descriptor Parameters:
- locator interface{} the locator to match.
Returns bool true if locators are matching and false it they don't.
The most basic implementation of IReferences to store and locate component references.
see IReferences
Example:
type MyController { _persistence IMyPersistence; } func (mc *MyController) setReferences(references IReferences) { mc._persistence = references.GetOneRequired( NewDescriptor("mygroup", "persistence", "*", "*", "1.0") ); } persistence := NewMyMongoDbPersistence(); controller := MyController(); references := NewReferencesFromTuples( new Descriptor("mygroup", "persistence", "mongodb", "default", "1.0"), persistence, new Descriptor("mygroup", "controller", "default", "default", "1.0"), controller ); controller.setReferences(references);
type References struct {
// contains filtered or unexported fields
}
func NewEmptyReferences() *References
Creates a new instance of references and initializes it with references. Returns *References
func NewReferences(tuples []interface{}) *References
Creates a new instance of references and initializes it with references. Parameters:
- tuples []interface{} a list of values where odd elements are locators and the following even elements are component references
Returns *References
func NewReferencesFromTuples(tuples ...interface{}) *References
Creates a new References from a list of key-value pairs called tuples. Parameters:
- tuples ...interface{} a list of values where odd elements are locators and the following even elements are component references
Returns *References a newly created References.
func (c *References) Find(locator interface{}, required bool) ([]interface{}, error)
Gets all component references that match specified locator. throws a ReferenceError when required is set to true but no references found. Parameters:
- locator interface{} the locator to find a reference by. - required bool forces to raise an exception if no reference is found.
Returns []interface{} a list with matching component references.
func (c *References) GetAll() []interface{}
Gets all component references registered in this reference map. Returns []interface{} a list with component references.
func (c *References) GetAllLocators() []interface{}
Gets locators for all registered component references in this reference map. Returns []interface{} a list with component locators.
func (c *References) GetOneOptional(locator interface{}) interface{}
Gets an optional component reference that matches specified locator. Parameters:
- locator interface{} the locator to find references by.
Returns interface{} a matching component reference or nil if nothing was found.
func (c *References) GetOneRequired(locator interface{}) (interface{}, error)
Gets a required component reference that matches specified locator. throws a ReferenceError when no references found. Parameters:
- locator interface{} the locator to find a reference by.
Returns interface{} a matching component reference.
func (c *References) GetOptional(locator interface{}) []interface{}
Gets all component references that match specified locator. Parameters:
- locator interface{} the locator to find references by.
Returns []interface{} a list with matching component references or empty list if nothing was found.
func (c *References) GetRequired(locator interface{}) ([]interface{}, error)
Gets all component references that match specified locator. At least one component reference must be present. If it doesn't the method throws an error. throws a ReferenceError when no references found. Parameters:
- locator interface{} the locator to find references by.
Returns []interface{} a list with matching component references.
func (c *References) Put(locator interface{}, component interface{})
Puts a new reference into this reference map. Parameters:
- locator interface{} a locator to find the reference by. - component interface{} a component reference to be added.
func (c *References) Remove(locator interface{}) interface{}
Removes a previously added reference that matches specified locator. If many references match the locator, it removes only the first one. When all references shall be removed, use removeAll method instead. see RemoveAll Parameters:
- locator interface{} a locator to remove reference
Returns interface{} the removed component reference.
func (c *References) RemoveAll(locator interface{}) []interface{}
Removes all component references that match the specified locator. Parameters:
- locator interface{} the locator to remove references by.
Returns []interface{} a list, containing all removed references.
Helper class that sets and unsets references to components.
type TReferencer struct{}
var Referencer *TReferencer = &TReferencer{}
func (c *TReferencer) SetReferences(references IReferences, components []interface{})
Sets references to multiple components. To set references components must implement IReferenceable interface. If they don't the call to this method has no effect. see IReferenceable Parameters:
- references IReferences the references to be set. - components []interface{} a list of components to set the references to.
func (c *TReferencer) SetReferencesForOne(references IReferences, component interface{})
Sets references to specific component. To set references components must implement IReferenceable interface. If they don't the call to this method has no effect. see IReferenceable Parameters:
- references IReferences the references to be set. - component interface{} the component to set references to.
func (c *TReferencer) UnsetReferences(components []interface{})
Unsets references in multiple components. To unset references components must implement IUnreferenceable interface. If they don't the call to this method has no effect. see IUnreferenceable Parameters:
- components [] interface{} the list of components, whose references must be cleared.
func (c *TReferencer) UnsetReferencesForOne(component interface{})
Unsets references in specific component. To unset references components must implement IUnreferenceable interface. If they don't the call to this method has no effect. see IUnreferenceable Parameters:
- component interface{} the component to unset references.


New Game
0
0
0
Keep going
Try again
©2014 Acura. Acura and TLX are trademarks of Honda Motor Co., Ltd. This game has been built borrowing code from:
Copyright (c) 2014 Gabriele Cirulli
.


Local Weather App For
°F
Change Temperature
Coded by
Ethan McCasland
CSS icons by
Tiffany Du
Weather data via
Wunderground API


FAPFAP
Flirtatious App for People Failing At Pickups
Press the button below to generate a pickup line!
Generate


About Me
Learn about me and send me an email
Projects
My projects and technical work: from web development to game design
Resume
My work experience and skills, downloadable as a PDF
Welcome to my Portfolio Site!
As you can see, it is still being worked on,
but I am constantly working on it!


References
js
| summary | ||
| public |
C Compass The compass class encapsulates logic around rendering the actual Compass based on device orientation data. |
|
| public |
C Location The location class encapsulates all the needed identifiers for PlacesAR purposes |
|
| public |
C Map This class encapsulates Google Maps and everything related to it. |
|
| public |
PID Controller implementation in JavaScript Adapted from https://github.com/br3ttb/Arduino-PID-Library Based on https://codepen.io/sbrekken/pen/juxzs |
|
| public |
This class encapsulates everything related to position. |
|
| public |
C Settings This class manages settings and applying them. |
|
| public |
C Wizard Wizard class starts and handles the wizards that are displayed on first start and when location fix is needed |
|
| public |
Iglewicz and Hoaglin method (median absolute deviation method) Values with a Z-score > 3.5 are considered potential outliers Based on https://github.com/alyssaq/stats-analysis |


{#- The generated page ought to work in most browsers. Currently supports down to IE 6. (some CSS breaks in IE5, but still browsable) Beware of cross-browser compatibility, basicly comply with CSS 2.1 and ECMAscript 3 or provide a fallback. - Avoid Node.textContent (break in IE < 9) - Avoid Array.prototype.indexOf (break in IE < 9) - Avoid Event.preventDefault (break in IE < 9) -#}


You need to install the Xfree86 port, (or from a mirror site near you).
To run Eco Lab, you first need to start the X-server, using the command line XDarwinStartup [-quartz] (the -quartz option is needed to run X under Aqua). You will then be asked whether you want to run the server rootless or not. I advise against running rootless initially until you're more comfortable running X. Set the DISPLAY variable in your shell to ``unix:0'' -- localhost is not necessarily mapped to <IP_ADDRESS> on OSX!. Then start a window manager. You can either use the antiquated twm manager by typing twm& on the command line, or I have it good authority that the OroborOSX window manager is the way to go!
Performance of Xwindows under Aqua is reportedly not good. If you
don't need any other Aqua applications open, you can log off the Aqua
desktop, and log in with the username ``>console
'' (which first needs
to be created). The gives a basic shell window, from which you can
launch Xwindows.