Why have I chosen to learn Python ?
- Its a language sometimes used by my summer research project
- It works particularly better than other language on the Raspberry Pi
- I’ve covered the basics of Python before but never gone further than simple syntax
- Its open source
- It can be used as a scripting language, which is an area that I really want to improve
- It supports object-oriented programming so I feel that with my previous experience of Java and C++, I will have covered the most popular OOP languages
Python 2.7 or 3 ?
The first decision that I needed to make before learning Python was whether to learn Python 2.7 or 3, since Python 3 fixes some of the “non-optional” design decision found in 2.7 and it of course more update I decided to learn Python 3. The potential problems with this is the lack of backwards compatibility with 2.7 and lack of teaching materials.
Python in my degree ?
The lecture course which is most likely to have included Python is Concepts of Programming Language which I took in Easter term this year. The course makes a few references to the language but does not cover the language to the degree that languages such as Fortran, Lisp, Algol, Pascal, Simula, Smalltalk, SML and Scala were covered.
What programming paradigms does Python support ?
Python advertises itself as a multi-paradigm programming language and from what I can see the range of supported paradigms supports this claim. This makes Python a multi-purpose language along with languages such as Java, C, C++ and SML compared to special-purpose languages such as SQL and LaTeX. The paradigm which Python support include:
- imperative programming – describing computation by prescribing how to move the program from one state to another, imperative languages included Fortran, C and assembly
- object-oriented programming – it supports dynamic lookup, abstraction, subtyping and inheritance, OOP language include Java, C++, Simula, Smalltalk and Scala
- Functional programming – treats computation as the evaluation of mathematical function and avoids state and mutable data. Examples include Lisp, Ocaml, Haskell and Scala
- Reflection programming – allowing a program to examine and modify its structure at runtime. Like Java, ML and Haskell
- Structured programming – subroutines, blocks, for and while making code more readable compared to simple tests and goto’s. Examples include most modern languages except assembly code
How does Python handle types?
Type checking is the process of attempting to prevent type errors by ensuring that the operations in a programm are applied properly. There are two common types of type checking:
- Dynamic (run-time) type checking – the compiler generates code such that whenever an operation is performed when the program is ran, the code checks to make sure that the operands have the correct types. Examples of dynamically type checked languages are MATLAB, Prolog and Ruby
- Static (compile-time) type checking – the compilers checks that program text for potential type errors as the program is compiled. Examples of statically type checked languages are Fortran, Haskell, Java and Ocaml
 |
| Python uses Duck typing |
|
Python is dynamically type checked, in fact it uses duck typing. Duck typing means that valid semantics of a object are dictated by the current state of methods instead of its inheritance from a class/interface like in Java. Why call it duck typing then ? the name refers to the duck test:
“When I see a bird that walks like a duck and swims like a duck and quacks like a duck, I call that bird a duck”
This allows use of EAFP or “It’s easier to Ask Forgiveness than Permission”. attributed to Grace Hopper.
A type system is said to be strongly typed when it specifies restrictions on how operations involving values of different data types can be intermixed. If this is not true, then we describe the language as weak. Python is strongly typed.
The built in types are as follows:
- bool – truth value e.g. True or False
- int – int of unlimited magnitude
- list – mutable sequence (supports mixed types) e.g. [4, 4.0, “Four”]
- tuple – immutable sequence (supports mixed types) e.g. ( 4, 4.0, “Four”)
- complex – complex number e.g. 3+5j
- float – floating point number e.g. 3.14
- dict – group of key and value pairs {“key1”:1.0, “key2”:2.0}
- set – unordered, no-duplicate collection of values
- bytes – immutable sequence of bytes
- bytearray – mutable sequence of bytes
- str – sequence of Unicode characters
Mutable means that an objects state can be modified after its created, immutable means the opposite.
 |
| Python uses the off-side rule |
Syntax & Semantics of Python ?
Unlike almost all other languages that I have studied Python uses whitespace to delimit block instead of curly braces (like Java), this feature is termed the off-side rule.
You define a function or method using the def keyword. The typically statements that you would except also apply: if, for, while, try, except and finally.
Python uses the words and, or, not for boolean expressions. Integer division (using //) is defined to round towards minus infinity and floating point division is do using /. Compare by value is achieved using == and compare by reference is achieved using is.
The syntax and semantics of Python highlight the main purpose of Python as a language for teaching programming, hence the focus on readability. This is why Python is the language being taught to school children using the Raspberry Pi
Installing the Interpreter
I install the packages for Python 3 from the Ubuntu Repositories using sudo apt-get install python3-minimal, and then run the interpreter by entering Python3 into the terminal
Once I get going with Python programming I hope to return to this type of language analysis and review how to design decisions made in the development of Python 3 reflect the use of the language in an introduction to programming. I hope to put up a part 2 of Getting Started with Python, later this week.
As ever, feel free to comment and highlight my mistakes even the spelling/grammar ones.
