Centre for Bioinformatics and Computational Biology - User contributions [en]

About

2019-08-08T08:16:33Z

Hstrydom:

Black Mamba is a discussion group hosted by the Center for Bioinformatics and Computational Biology.

The aim of the discussion group is to expose people to a wide variety of different topics ranging from biology to mathematics and computer sciences. Post-graduate studies often require individuals to focus on only certain topics relevant to their field of study. This creates a situation where many people have very specialized skill sets. With a trend towards cross disciplinary research it has become more important than every that scientists have an understanding of not only their field of research but also surrounding fields.

The group does not function on a student-teacher dynamic. Each week is chaired by the most knowledgeable person in the topic being discussed. This person's role is to influence and steer discussion, not necessarily teach the group.

Open discussion is actively encouraged. With no one person knowing all there is to know about any topic it becomes important that everyone in the group actively interacts to ensure that topics are explored in as wide a scope as possible.

'''Topics that have been discussed by the group:'''
* Git
* Databases and SQL
* Python basics
* Machine Learning
* Pipeline creation (nextflow and snakemake)

About

2019-08-08T06:21:23Z

Hstrydom: Created page with "Black Mamba is a discussion group hosted by the Center for Bioinformatics and Computational Biology. The aim of the discussion group is to expose people to a wide variety of..."

Main Page

2019-08-08T06:03:22Z

Hstrydom: /* The Black Mamba Resource */

Welcome to the Centre for Bioinformatics and Computational Biology!

== Getting started ==
* [[Obtaining an account]]
* [[Logging in to a terminal session]]
* [[Running jobs on our servers]]
* [[Using the PBS / Torque queueing environment]]
* [[Software resources]]
* [[Hardware resources]]
* [http://wiki.bi.up.ac.za/wiki/index.php?title=Storage_Quotas_and_Charges&action=edit&redlink=1 Storage Quotas and Charges]
* [[Transferring large quantities of data between institutions]]
* [[Backups]]
* The compute infrastructure load can be seen in the [http://wonko.bi.up.ac.za/ganglia/?c=unspecified&m=load_one&r=hour&s=by%20name&hc=4&mc=2 ganglia monitor]
* The Bioinformatics post-graduate lecture [https://docs.google.com/spreadsheets/d/1DYL-XHFb4-o3mi6E6x1F4kLRCdFKrdLERI7LO6RqwbI/edit?usp=sharing schedule] is available for any interested students from other departments to attend. Lectures are on Tuesdays at 10:00 and Thursdays at 10:00 in FABI Square 3-26
* [[Migrating your data safely]]
* [[File and directory permissions and ownership]]
* [[Guidelines and Terms of use]]
* [[Safety and security at the Lab]]
== The Black Mamba ==
* [[About]]
* [[Joining the discussion]]

Python

2019-06-28T06:46:55Z

Hstrydom: /* Conditionals */

=== Variables ===
==== Declaration and typing ====
'''Keyword:''' Declaring variables, variable assignment, boolean values, integers, floats, strings, lists, dictionaries (ordered dictionaries, default dictionaries), tuples, sets, mutable and immutable data types, variable typing.
<source lang="python">
####
# Boolean variables can only contain one of two values: True or False
# Boolean values are annotated by using the "bool" keyword
a: bool = True
####

####
# Integers are variables that contain any positive or negative whole number
# Integers are annotated using the "int" keyword
# Floats are variables that contains any positive or negative decimal
# Floats are annotated using the "float" keyword
a: int = 15
b: int = -23

c: float = 6.4
d: float = -9.5
####

####
# Strings are variables that contain text
# Strings are annotated using the "str" keyword
a: str = "This is a string"
b: str = 'Strings can be enclosed using single quotes'

# Initializing an empty string:
a = ""
####

####
# Lists are collections of other variables
# Lists are annotated using the "list" keyword
a: list = ["Some string", 15, 9.6, True]

# Initializing an empty list:
a = []
####

####
# Sets are lists that cannot contain duplicate values
# They also do not keep the order of the variables
# Sets are a lot faster than lists when looking for specific values
# Sets are annotated using the "set" keyword
a: set = {"Some string", 15, 9.6, True}

# Initializing an empty set:
a = set()
####

####
# Tuples are lists that cannot be changed after being created
# They are useful when returning multiple values from a function
# Tuples are annotated using the "tuple" keyword
a: tuple = ("Some string", 15, 9.6, True)

# Because tuples cannot be changed there is no point in initializing an empty one
####

####
# Dictionaries work of Key - Value pairs
# Keys can be any immutable type - integers, floats, strings and tuples
# Dictionaries do not keep the their order
# Dictionaries are annotated using the "dict" keyword
a: dict = {"A": "Some string", "B": 15, "C": 9.6, "D": True}

# Initializing an empty dictionary:
a = {}
####
</source>

==== Casting ====
'''Keywords:''' Casting
<source lang="python">
# Only certain operations can be performed on certain types of variables
# Changing between types of variables is called "casting"
a: str = "15"

b: int = int(a) # b = 15
c: float = float(b) # c = 15.0
d: str = str(c) # d = "15.0"
</source>

==== Mathematical operations ====
'''Keywords:''' Operators, string concatenation, list concatenation
<source lang="python">
####
# Integers and floats support most arithmetic operations
a = 15
b = 6

c = a + b # c = 21
c = a - b # c = 9
c = a * b # c = 90
c = a / b # c = 2.5

# There are some special operators:
# modulus (%) returns what is left after division
# floor division (//) throws away the decimal place
c = a % b # c = 3
c = a // b # c = 2
####

####
# Strings only support 2 mathematical operators
# The addition (+) is used to concatenate strings
# The multiplication (*) returns multiples of a string
a = "Hello"
b = "World"

c = a + b # c = "HelloWorld"
c = a * 3 # c = "HelloHelloHello"
####

####
# Lists, tuples can be added to each other
# It concatenates the collections together
a = ["Hello", 15]
b = [9.6, True]

c = a + b # c = ["hello", 15, 9.6, True]
####

####
# You can use "mathematical shorthand" to make some code more readable
# Shorthand is supported for all operators and works with strings, numbers, lists and tuples
a = 12
b = "Hello"
c = "World"

a = a + 6 # Normal way
a += 6 # Shorthand gives the same result

b = b + c # Normal way, c = "HelloWorld"
b += c # Shorthand gives the same result
####
</source>

==== Modifying collections ====
'''Keywords:''' Collections, lists, tuples, dictionaries, sets
<source lang="python">
####
# LISTS
# You can add values to a list by using the append() method:
a = []

a.append("Hello")
a.append(15)
a.append(True)

print(a) # a = ["Hello", 15, True]
####

####
# SETS
# You can add values to a list by using the add() method
# A list of values can be added to a set by using the update() method
a = set()
b = [15, 9.6, True]

a.add("Hello")
a.update(b)

print(a) # a = {"Hello", 15, 9.6, True}
####

####
# TUPLES
# Tuples cannot be added to, they do not change
####

####
# DICTIONARIES
# You can add a new value pair by assigning the key to a value
a = {}

a["A"] = "Hello"
a["B"] = 15
a["C"] = 9.6
a["D"] = True

print(a) # a = {"A": "Hello", "B": 15, "C": 9.6, "D": True}
####
</source>

=== Conditionals ===
'''Keywords:''' Logical operators, and, or, not, in, if statement, if else, else if, try catch blocks, exception handling.
==== If statement ====
<source lang="python">
# If statements are used when you want to do something when a condition is met
# The if or elif part occurs when the condition returns true
# The else part occurs when none of the previous conditions returned true
a = 12
b = 15

# The example below will return "Did the elif" because b > a
if a > b:
print("Did the if")
elif b > a: # Condition returns true
print("Did the elif")
else:
print("Did the else")

# The operators available:
# > < >= <= ==
# != (not equal) can be used or the keyword "not"

# If you want to create more complex conditions you can make use of "and", "or" and "in"
# And requires that all conditionals return true
# Or requires that one of the conditionals return true
# In returns true if a certain value is found inside a collection
a = [15, 9, 6]
b = 6

if 15 in a:
print("Found it")

# Would not run the code inside the if statement
if (15 in a) and (b > 9):
print("The item is in the list and 6 > 9")

# Would run the code inside the if statement
if (15 in a) or (b > 9):
print("The item is in the list or 6 > 9?")

# You can have calculations and function calls inside conditions:
if (15 + 2) > b:
print("17 > 6")
</source>

==== Try except ====

=== Loops ===
=== Functions ===
=== Classes ===

Python

2019-06-28T06:44:46Z

Hstrydom: /* Modifying collections */

=== Variables ===
==== Declaration and typing ====
'''Keyword:''' Declaring variables, variable assignment, boolean values, integers, floats, strings, lists, dictionaries (ordered dictionaries, default dictionaries), tuples, sets, mutable and immutable data types, variable typing.
<source lang="python">
####
# Boolean variables can only contain one of two values: True or False
# Boolean values are annotated by using the "bool" keyword
a: bool = True
####

####
# Integers are variables that contain any positive or negative whole number
# Integers are annotated using the "int" keyword
# Floats are variables that contains any positive or negative decimal
# Floats are annotated using the "float" keyword
a: int = 15
b: int = -23

c: float = 6.4
d: float = -9.5
####

####
# Strings are variables that contain text
# Strings are annotated using the "str" keyword
a: str = "This is a string"
b: str = 'Strings can be enclosed using single quotes'

# Initializing an empty string:
a = ""
####

####
# Lists are collections of other variables
# Lists are annotated using the "list" keyword
a: list = ["Some string", 15, 9.6, True]

# Initializing an empty list:
a = []
####

####
# Sets are lists that cannot contain duplicate values
# They also do not keep the order of the variables
# Sets are a lot faster than lists when looking for specific values
# Sets are annotated using the "set" keyword
a: set = {"Some string", 15, 9.6, True}

# Initializing an empty set:
a = set()
####

####
# Tuples are lists that cannot be changed after being created
# They are useful when returning multiple values from a function
# Tuples are annotated using the "tuple" keyword
a: tuple = ("Some string", 15, 9.6, True)

# Because tuples cannot be changed there is no point in initializing an empty one
####

####
# Dictionaries work of Key - Value pairs
# Keys can be any immutable type - integers, floats, strings and tuples
# Dictionaries do not keep the their order
# Dictionaries are annotated using the "dict" keyword
a: dict = {"A": "Some string", "B": 15, "C": 9.6, "D": True}

# Initializing an empty dictionary:
a = {}
####
</source>

==== Casting ====
'''Keywords:''' Casting
<source lang="python">
# Only certain operations can be performed on certain types of variables
# Changing between types of variables is called "casting"
a: str = "15"

b: int = int(a) # b = 15
c: float = float(b) # c = 15.0
d: str = str(c) # d = "15.0"
</source>

==== Mathematical operations ====
'''Keywords:''' Operators, string concatenation, list concatenation
<source lang="python">
####
# Integers and floats support most arithmetic operations
a = 15
b = 6

c = a + b # c = 21
c = a - b # c = 9
c = a * b # c = 90
c = a / b # c = 2.5

# There are some special operators:
# modulus (%) returns what is left after division
# floor division (//) throws away the decimal place
c = a % b # c = 3
c = a // b # c = 2
####

####
# Strings only support 2 mathematical operators
# The addition (+) is used to concatenate strings
# The multiplication (*) returns multiples of a string
a = "Hello"
b = "World"

c = a + b # c = "HelloWorld"
c = a * 3 # c = "HelloHelloHello"
####

####
# Lists, tuples can be added to each other
# It concatenates the collections together
a = ["Hello", 15]
b = [9.6, True]

c = a + b # c = ["hello", 15, 9.6, True]
####

####
# You can use "mathematical shorthand" to make some code more readable
# Shorthand is supported for all operators and works with strings, numbers, lists and tuples
a = 12
b = "Hello"
c = "World"

a = a + 6 # Normal way
a += 6 # Shorthand gives the same result

b = b + c # Normal way, c = "HelloWorld"
b += c # Shorthand gives the same result
####
</source>

==== Modifying collections ====
'''Keywords:''' Collections, lists, tuples, dictionaries, sets
<source lang="python">
####
# LISTS
# You can add values to a list by using the append() method:
a = []

a.append("Hello")
a.append(15)
a.append(True)

print(a) # a = ["Hello", 15, True]
####

####
# SETS
# You can add values to a list by using the add() method
# A list of values can be added to a set by using the update() method
a = set()
b = [15, 9.6, True]

a.add("Hello")
a.update(b)

print(a) # a = {"Hello", 15, 9.6, True}
####

####
# TUPLES
# Tuples cannot be added to, they do not change
####

####
# DICTIONARIES
# You can add a new value pair by assigning the key to a value
a = {}

a["A"] = "Hello"
a["B"] = 15
a["C"] = 9.6
a["D"] = True

print(a) # a = {"A": "Hello", "B": 15, "C": 9.6, "D": True}
####
</source>

=== Conditionals ===
==== If statement ====
<source lang="python">
# If statements are used when you want to do something when a condition is met
# The if or elif part occurs when the condition returns true
# The else part occurs when none of the previous conditions returned true
a = 12
b = 15

# The example below will return "Did the elif" because b > a
if a > b:
print("Did the if")
elif b > a: # Condition returns true
print("Did the elif")
else:
print("Did the else")

# The operators available:
# > < >= <= ==
# != (not equal) can be used or the keyword "not"

# If you want to create more complex conditions you can make use of "and", "or" and "in"
# And requires that all conditionals return true
# Or requires that one of the conditionals return true
# In returns true if a certain value is found inside a collection
a = [15, 9, 6]
b = 6

if 15 in a:
print("Found it")

# Would not run the code inside the if statement
if (15 in a) and (b > 9):
print("The item is in the list and 6 > 9")

# Would run the code inside the if statement
if (15 in a) or (b > 9):
print("The item is in the list or 6 > 9?")

# You can have calculations and function calls inside conditions:
if (15 + 2) > b:
print("17 > 6")
</source>

==== Try except ====

=== Loops ===
=== Functions ===
=== Classes ===

Python

2019-06-28T06:43:21Z

Hstrydom: /* Mathematical operations */

=== Variables ===
==== Declaration and typing ====
'''Keyword:''' Declaring variables, variable assignment, boolean values, integers, floats, strings, lists, dictionaries (ordered dictionaries, default dictionaries), tuples, sets, mutable and immutable data types, variable typing.
<source lang="python">
####
# Boolean variables can only contain one of two values: True or False
# Boolean values are annotated by using the "bool" keyword
a: bool = True
####

####
# Integers are variables that contain any positive or negative whole number
# Integers are annotated using the "int" keyword
# Floats are variables that contains any positive or negative decimal
# Floats are annotated using the "float" keyword
a: int = 15
b: int = -23

c: float = 6.4
d: float = -9.5
####

####
# Strings are variables that contain text
# Strings are annotated using the "str" keyword
a: str = "This is a string"
b: str = 'Strings can be enclosed using single quotes'

# Initializing an empty string:
a = ""
####

####
# Lists are collections of other variables
# Lists are annotated using the "list" keyword
a: list = ["Some string", 15, 9.6, True]

# Initializing an empty list:
a = []
####

####
# Sets are lists that cannot contain duplicate values
# They also do not keep the order of the variables
# Sets are a lot faster than lists when looking for specific values
# Sets are annotated using the "set" keyword
a: set = {"Some string", 15, 9.6, True}

# Initializing an empty set:
a = set()
####

####
# Tuples are lists that cannot be changed after being created
# They are useful when returning multiple values from a function
# Tuples are annotated using the "tuple" keyword
a: tuple = ("Some string", 15, 9.6, True)

# Because tuples cannot be changed there is no point in initializing an empty one
####

####
# Dictionaries work of Key - Value pairs
# Keys can be any immutable type - integers, floats, strings and tuples
# Dictionaries do not keep the their order
# Dictionaries are annotated using the "dict" keyword
a: dict = {"A": "Some string", "B": 15, "C": 9.6, "D": True}

# Initializing an empty dictionary:
a = {}
####
</source>

==== Casting ====
'''Keywords:''' Casting
<source lang="python">
# Only certain operations can be performed on certain types of variables
# Changing between types of variables is called "casting"
a: str = "15"

b: int = int(a) # b = 15
c: float = float(b) # c = 15.0
d: str = str(c) # d = "15.0"
</source>

==== Mathematical operations ====
'''Keywords:''' Operators, string concatenation, list concatenation
<source lang="python">
####
# Integers and floats support most arithmetic operations
a = 15
b = 6

c = a + b # c = 21
c = a - b # c = 9
c = a * b # c = 90
c = a / b # c = 2.5

# There are some special operators:
# modulus (%) returns what is left after division
# floor division (//) throws away the decimal place
c = a % b # c = 3
c = a // b # c = 2
####

####
# Strings only support 2 mathematical operators
# The addition (+) is used to concatenate strings
# The multiplication (*) returns multiples of a string
a = "Hello"
b = "World"

c = a + b # c = "HelloWorld"
c = a * 3 # c = "HelloHelloHello"
####

####
# Lists, tuples can be added to each other
# It concatenates the collections together
a = ["Hello", 15]
b = [9.6, True]

c = a + b # c = ["hello", 15, 9.6, True]
####

####
# You can use "mathematical shorthand" to make some code more readable
# Shorthand is supported for all operators and works with strings, numbers, lists and tuples
a = 12
b = "Hello"
c = "World"

a = a + 6 # Normal way
a += 6 # Shorthand gives the same result

b = b + c # Normal way, c = "HelloWorld"
b += c # Shorthand gives the same result
####
</source>

==== Modifying collections ====
<source lang="python">
####
# LISTS
# You can add values to a list by using the append() method:
a = []

a.append("Hello")
a.append(15)
a.append(True)

print(a) # a = ["Hello", 15, True]
####

####
# SETS
# You can add values to a list by using the add() method
# A list of values can be added to a set by using the update() method
a = set()
b = [15, 9.6, True]

a.add("Hello")
a.update(b)

print(a) # a = {"Hello", 15, 9.6, True}
####

####
# TUPLES
# Tuples cannot be added to, they do not change
####

####
# DICTIONARIES
# You can add a new value pair by assigning the key to a value
a = {}

a["A"] = "Hello"
a["B"] = 15
a["C"] = 9.6
a["D"] = True

print(a) # a = {"A": "Hello", "B": 15, "C": 9.6, "D": True}
####
</source>

=== Conditionals ===
==== If statement ====
<source lang="python">
# If statements are used when you want to do something when a condition is met
# The if or elif part occurs when the condition returns true
# The else part occurs when none of the previous conditions returned true
a = 12
b = 15

# The example below will return "Did the elif" because b > a
if a > b:
print("Did the if")
elif b > a: # Condition returns true
print("Did the elif")
else:
print("Did the else")

# The operators available:
# > < >= <= ==
# != (not equal) can be used or the keyword "not"

# If you want to create more complex conditions you can make use of "and", "or" and "in"
# And requires that all conditionals return true
# Or requires that one of the conditionals return true
# In returns true if a certain value is found inside a collection
a = [15, 9, 6]
b = 6

if 15 in a:
print("Found it")

# Would not run the code inside the if statement
if (15 in a) and (b > 9):
print("The item is in the list and 6 > 9")

# Would run the code inside the if statement
if (15 in a) or (b > 9):
print("The item is in the list or 6 > 9?")

# You can have calculations and function calls inside conditions:
if (15 + 2) > b:
print("17 > 6")
</source>

==== Try except ====

=== Loops ===
=== Functions ===
=== Classes ===

Python

2019-06-28T06:41:11Z

Hstrydom: /* Casting */

=== Variables ===
==== Declaration and typing ====
'''Keyword:''' Declaring variables, variable assignment, boolean values, integers, floats, strings, lists, dictionaries (ordered dictionaries, default dictionaries), tuples, sets, mutable and immutable data types, variable typing.
<source lang="python">
####
# Boolean variables can only contain one of two values: True or False
# Boolean values are annotated by using the "bool" keyword
a: bool = True
####

####
# Integers are variables that contain any positive or negative whole number
# Integers are annotated using the "int" keyword
# Floats are variables that contains any positive or negative decimal
# Floats are annotated using the "float" keyword
a: int = 15
b: int = -23

c: float = 6.4
d: float = -9.5
####

####
# Strings are variables that contain text
# Strings are annotated using the "str" keyword
a: str = "This is a string"
b: str = 'Strings can be enclosed using single quotes'

# Initializing an empty string:
a = ""
####

####
# Lists are collections of other variables
# Lists are annotated using the "list" keyword
a: list = ["Some string", 15, 9.6, True]

# Initializing an empty list:
a = []
####

####
# Sets are lists that cannot contain duplicate values
# They also do not keep the order of the variables
# Sets are a lot faster than lists when looking for specific values
# Sets are annotated using the "set" keyword
a: set = {"Some string", 15, 9.6, True}

# Initializing an empty set:
a = set()
####

####
# Tuples are lists that cannot be changed after being created
# They are useful when returning multiple values from a function
# Tuples are annotated using the "tuple" keyword
a: tuple = ("Some string", 15, 9.6, True)

# Because tuples cannot be changed there is no point in initializing an empty one
####

####
# Dictionaries work of Key - Value pairs
# Keys can be any immutable type - integers, floats, strings and tuples
# Dictionaries do not keep the their order
# Dictionaries are annotated using the "dict" keyword
a: dict = {"A": "Some string", "B": 15, "C": 9.6, "D": True}

# Initializing an empty dictionary:
a = {}
####
</source>

==== Casting ====
'''Keywords:''' Casting
<source lang="python">
# Only certain operations can be performed on certain types of variables
# Changing between types of variables is called "casting"
a: str = "15"

b: int = int(a) # b = 15
c: float = float(b) # c = 15.0
d: str = str(c) # d = "15.0"
</source>

==== Mathematical operations ====
<source lang="python">
####
# Integers and floats support most arithmetic operations
a = 15
b = 6

c = a + b # c = 21
c = a - b # c = 9
c = a * b # c = 90
c = a / b # c = 2.5

# There are some special operators:
# modulus (%) returns what is left after division
# floor division (//) throws away the decimal place
c = a % b # c = 3
c = a // b # c = 2
####

####
# Strings only support 2 mathematical operators
# The addition (+) is used to concatenate strings
# The multiplication (*) returns multiples of a string
a = "Hello"
b = "World"

c = a + b # c = "HelloWorld"
c = a * 3 # c = "HelloHelloHello"
####

####
# Lists, tuples can be added to each other
# It concatenates the collections together
a = ["Hello", 15]
b = [9.6, True]

c = a + b # c = ["hello", 15, 9.6, True]
####

####
# You can use mathematical shorthand to make some code more readable
# Shorthand is supported for all operators and works with both strings and numbers
a = 12
b = "Hello"
c = "World"

a = a + 6 # Normal way
a += 6 # Shorthand gives the same result

b = b + c # Normal way, c = "HelloWorld"
b += c # Shorthand gives the same result
####
</source>

==== Modifying collections ====
<source lang="python">
####
# LISTS
# You can add values to a list by using the append() method:
a = []

a.append("Hello")
a.append(15)
a.append(True)

print(a) # a = ["Hello", 15, True]
####

####
# SETS
# You can add values to a list by using the add() method
# A list of values can be added to a set by using the update() method
a = set()
b = [15, 9.6, True]

a.add("Hello")
a.update(b)

print(a) # a = {"Hello", 15, 9.6, True}
####

####
# TUPLES
# Tuples cannot be added to, they do not change
####

####
# DICTIONARIES
# You can add a new value pair by assigning the key to a value
a = {}

a["A"] = "Hello"
a["B"] = 15
a["C"] = 9.6
a["D"] = True

print(a) # a = {"A": "Hello", "B": 15, "C": 9.6, "D": True}
####
</source>

=== Conditionals ===
==== If statement ====
<source lang="python">
# If statements are used when you want to do something when a condition is met
# The if or elif part occurs when the condition returns true
# The else part occurs when none of the previous conditions returned true
a = 12
b = 15

# The example below will return "Did the elif" because b > a
if a > b:
print("Did the if")
elif b > a: # Condition returns true
print("Did the elif")
else:
print("Did the else")

# The operators available:
# > < >= <= ==
# != (not equal) can be used or the keyword "not"

# If you want to create more complex conditions you can make use of "and", "or" and "in"
# And requires that all conditionals return true
# Or requires that one of the conditionals return true
# In returns true if a certain value is found inside a collection
a = [15, 9, 6]
b = 6

if 15 in a:
print("Found it")

# Would not run the code inside the if statement
if (15 in a) and (b > 9):
print("The item is in the list and 6 > 9")

# Would run the code inside the if statement
if (15 in a) or (b > 9):
print("The item is in the list or 6 > 9?")

# You can have calculations and function calls inside conditions:
if (15 + 2) > b:
print("17 > 6")
</source>

==== Try except ====

=== Loops ===
=== Functions ===
=== Classes ===

Python

2019-06-28T06:39:42Z

Hstrydom: /* Declaration and typing */

=== Variables ===
==== Declaration and typing ====
'''Keyword:''' Declaring variables, variable assignment, boolean values, integers, floats, strings, lists, dictionaries (ordered dictionaries, default dictionaries), tuples, sets, mutable and immutable data types, variable typing.
<source lang="python">
####
# Boolean variables can only contain one of two values: True or False
# Boolean values are annotated by using the "bool" keyword
a: bool = True
####

####
# Integers are variables that contain any positive or negative whole number
# Integers are annotated using the "int" keyword
# Floats are variables that contains any positive or negative decimal
# Floats are annotated using the "float" keyword
a: int = 15
b: int = -23

c: float = 6.4
d: float = -9.5
####

####
# Strings are variables that contain text
# Strings are annotated using the "str" keyword
a: str = "This is a string"
b: str = 'Strings can be enclosed using single quotes'

# Initializing an empty string:
a = ""
####

####
# Lists are collections of other variables
# Lists are annotated using the "list" keyword
a: list = ["Some string", 15, 9.6, True]

# Initializing an empty list:
a = []
####

####
# Sets are lists that cannot contain duplicate values
# They also do not keep the order of the variables
# Sets are a lot faster than lists when looking for specific values
# Sets are annotated using the "set" keyword
a: set = {"Some string", 15, 9.6, True}

# Initializing an empty set:
a = set()
####

####
# Tuples are lists that cannot be changed after being created
# They are useful when returning multiple values from a function
# Tuples are annotated using the "tuple" keyword
a: tuple = ("Some string", 15, 9.6, True)

# Because tuples cannot be changed there is no point in initializing an empty one
####

####
# Dictionaries work of Key - Value pairs
# Keys can be any immutable type - integers, floats, strings and tuples
# Dictionaries do not keep the their order
# Dictionaries are annotated using the "dict" keyword
a: dict = {"A": "Some string", "B": 15, "C": 9.6, "D": True}

# Initializing an empty dictionary:
a = {}
####
</source>

==== Casting ====
Keywords: Casting
<source lang="python">
# Only certain operations can be performed on certain types of variables
# Changing between types of variables is called "casting"
a: str = "15"

b: int = int(a) # b = 15
c: float = float(b) # c = 15.0
d: str = str(c) # d = "15.0"
</source>

==== Mathematical operations ====
<source lang="python">
####
# Integers and floats support most arithmetic operations
a = 15
b = 6

c = a + b # c = 21
c = a - b # c = 9
c = a * b # c = 90
c = a / b # c = 2.5

# There are some special operators:
# modulus (%) returns what is left after division
# floor division (//) throws away the decimal place
c = a % b # c = 3
c = a // b # c = 2
####

####
# Strings only support 2 mathematical operators
# The addition (+) is used to concatenate strings
# The multiplication (*) returns multiples of a string
a = "Hello"
b = "World"

c = a + b # c = "HelloWorld"
c = a * 3 # c = "HelloHelloHello"
####

####
# Lists, tuples can be added to each other
# It concatenates the collections together
a = ["Hello", 15]
b = [9.6, True]

c = a + b # c = ["hello", 15, 9.6, True]
####

####
# You can use mathematical shorthand to make some code more readable
# Shorthand is supported for all operators and works with both strings and numbers
a = 12
b = "Hello"
c = "World"

a = a + 6 # Normal way
a += 6 # Shorthand gives the same result

b = b + c # Normal way, c = "HelloWorld"
b += c # Shorthand gives the same result
####
</source>

==== Modifying collections ====
<source lang="python">
####
# LISTS
# You can add values to a list by using the append() method:
a = []

a.append("Hello")
a.append(15)
a.append(True)

print(a) # a = ["Hello", 15, True]
####

####
# SETS
# You can add values to a list by using the add() method
# A list of values can be added to a set by using the update() method
a = set()
b = [15, 9.6, True]

a.add("Hello")
a.update(b)

print(a) # a = {"Hello", 15, 9.6, True}
####

####
# TUPLES
# Tuples cannot be added to, they do not change
####

####
# DICTIONARIES
# You can add a new value pair by assigning the key to a value
a = {}

a["A"] = "Hello"
a["B"] = 15
a["C"] = 9.6
a["D"] = True

print(a) # a = {"A": "Hello", "B": 15, "C": 9.6, "D": True}
####
</source>

=== Conditionals ===
==== If statement ====
<source lang="python">
# If statements are used when you want to do something when a condition is met
# The if or elif part occurs when the condition returns true
# The else part occurs when none of the previous conditions returned true
a = 12
b = 15

# The example below will return "Did the elif" because b > a
if a > b:
print("Did the if")
elif b > a: # Condition returns true
print("Did the elif")
else:
print("Did the else")

# The operators available:
# > < >= <= ==
# != (not equal) can be used or the keyword "not"

# If you want to create more complex conditions you can make use of "and", "or" and "in"
# And requires that all conditionals return true
# Or requires that one of the conditionals return true
# In returns true if a certain value is found inside a collection
a = [15, 9, 6]
b = 6

if 15 in a:
print("Found it")

# Would not run the code inside the if statement
if (15 in a) and (b > 9):
print("The item is in the list and 6 > 9")

# Would run the code inside the if statement
if (15 in a) or (b > 9):
print("The item is in the list or 6 > 9?")

# You can have calculations and function calls inside conditions:
if (15 + 2) > b:
print("17 > 6")
</source>

==== Try except ====

=== Loops ===
=== Functions ===
=== Classes ===

Python

2019-06-28T06:38:04Z

Hstrydom: /* Declaration and typing */

=== Variables ===
==== Declaration and typing ====
'''Keyword: Declaring variables, variable assignment, boolean values, integers, floats, strings, lists, dictionaries (ordered dictionaries, default dictionaries), tuples, sets, mutable and immutable data types, variable typing.'''
<source lang="python">
####
# Boolean variables can only contain one of two values: True or False
# Boolean values are annotated by using the "bool" keyword
a: bool = True
####

####
# Integers are variables that contain any positive or negative whole number
# Integers are annotated using the "int" keyword
# Floats are variables that contains any positive or negative decimal
# Floats are annotated using the "float" keyword
a: int = 15
b: int = -23

c: float = 6.4
d: float = -9.5
####

####
# Strings are variables that contain text
# Strings are annotated using the "str" keyword
a: str = "This is a string"
b: str = 'Strings can be enclosed using single quotes'

# Initializing an empty string:
a = ""
####

####
# Lists are collections of other variables
# Lists are annotated using the "list" keyword
a: list = ["Some string", 15, 9.6, True]

# Initializing an empty list:
a = []
####

####
# Sets are lists that cannot contain duplicate values
# They also do not keep the order of the variables
# Sets are a lot faster than lists when looking for specific values
# Sets are annotated using the "set" keyword
a: set = {"Some string", 15, 9.6, True}

# Initializing an empty set:
a = set()
####

####
# Tuples are lists that cannot be changed after being created
# They are useful when returning multiple values from a function
# Tuples are annotated using the "tuple" keyword
a: tuple = ("Some string", 15, 9.6, True)

# Because tuples cannot be changed there is no point in initializing an empty one
####

####
# Dictionaries work of Key - Value pairs
# Keys can be any immutable type - integers, floats, strings and tuples
# Dictionaries do not keep the their order
# Dictionaries are annotated using the "dict" keyword
a: dict = {"A": "Some string", "B": 15, "C": 9.6, "D": True}

# Initializing an empty dictionary:
a = {}
####
</source>

==== Casting ====
Keywords: Casting
<source lang="python">
# Only certain operations can be performed on certain types of variables
# Changing between types of variables is called "casting"
a: str = "15"

b: int = int(a) # b = 15
c: float = float(b) # c = 15.0
d: str = str(c) # d = "15.0"
</source>

==== Mathematical operations ====
<source lang="python">
####
# Integers and floats support most arithmetic operations
a = 15
b = 6

c = a + b # c = 21
c = a - b # c = 9
c = a * b # c = 90
c = a / b # c = 2.5

# There are some special operators:
# modulus (%) returns what is left after division
# floor division (//) throws away the decimal place
c = a % b # c = 3
c = a // b # c = 2
####

####
# Strings only support 2 mathematical operators
# The addition (+) is used to concatenate strings
# The multiplication (*) returns multiples of a string
a = "Hello"
b = "World"

c = a + b # c = "HelloWorld"
c = a * 3 # c = "HelloHelloHello"
####

####
# Lists, tuples can be added to each other
# It concatenates the collections together
a = ["Hello", 15]
b = [9.6, True]

c = a + b # c = ["hello", 15, 9.6, True]
####

####
# You can use mathematical shorthand to make some code more readable
# Shorthand is supported for all operators and works with both strings and numbers
a = 12
b = "Hello"
c = "World"

a = a + 6 # Normal way
a += 6 # Shorthand gives the same result

b = b + c # Normal way, c = "HelloWorld"
b += c # Shorthand gives the same result
####
</source>

==== Modifying collections ====
<source lang="python">
####
# LISTS
# You can add values to a list by using the append() method:
a = []

a.append("Hello")
a.append(15)
a.append(True)

print(a) # a = ["Hello", 15, True]
####

####
# SETS
# You can add values to a list by using the add() method
# A list of values can be added to a set by using the update() method
a = set()
b = [15, 9.6, True]

a.add("Hello")
a.update(b)

print(a) # a = {"Hello", 15, 9.6, True}
####

####
# TUPLES
# Tuples cannot be added to, they do not change
####

####
# DICTIONARIES
# You can add a new value pair by assigning the key to a value
a = {}

a["A"] = "Hello"
a["B"] = 15
a["C"] = 9.6
a["D"] = True

print(a) # a = {"A": "Hello", "B": 15, "C": 9.6, "D": True}
####
</source>

=== Conditionals ===
==== If statement ====
<source lang="python">
# If statements are used when you want to do something when a condition is met
# The if or elif part occurs when the condition returns true
# The else part occurs when none of the previous conditions returned true
a = 12
b = 15

# The example below will return "Did the elif" because b > a
if a > b:
print("Did the if")
elif b > a: # Condition returns true
print("Did the elif")
else:
print("Did the else")

# The operators available:
# > < >= <= ==
# != (not equal) can be used or the keyword "not"

# If you want to create more complex conditions you can make use of "and", "or" and "in"
# And requires that all conditionals return true
# Or requires that one of the conditionals return true
# In returns true if a certain value is found inside a collection
a = [15, 9, 6]
b = 6

if 15 in a:
print("Found it")

# Would not run the code inside the if statement
if (15 in a) and (b > 9):
print("The item is in the list and 6 > 9")

# Would run the code inside the if statement
if (15 in a) or (b > 9):
print("The item is in the list or 6 > 9?")

# You can have calculations and function calls inside conditions:
if (15 + 2) > b:
print("17 > 6")
</source>

==== Try except ====

=== Loops ===
=== Functions ===
=== Classes ===

Python

2019-06-28T06:36:48Z

Hstrydom: /* Casting */

=== Variables ===
==== Declaration and typing ====
Keyword: declaring variables, variable assignment, boolean values, integers, floats, strings, lists, dictionaries (ordered dictionaries, default dictionaries), tuples, sets, mutable and immutable data types, variable typing.
<source lang="python">
####
# Boolean variables can only contain one of two values: True or False
# Boolean values are annotated by using the "bool" keyword
a: bool = True
####

####
# Integers are variables that contain any positive or negative whole number
# Integers are annotated using the "int" keyword
# Floats are variables that contains any positive or negative decimal
# Floats are annotated using the "float" keyword
a: int = 15
b: int = -23

c: float = 6.4
d: float = -9.5
####

####
# Strings are variables that contain text
# Strings are annotated using the "str" keyword
a: str = "This is a string"
b: str = 'Strings can be enclosed using single quotes'

# Initializing an empty string:
a = ""
####

####
# Lists are collections of other variables
# Lists are annotated using the "list" keyword
a: list = ["Some string", 15, 9.6, True]

# Initializing an empty list:
a = []
####

####
# Sets are lists that cannot contain duplicate values
# They also do not keep the order of the variables
# Sets are a lot faster than lists when looking for specific values
# Sets are annotated using the "set" keyword
a: set = {"Some string", 15, 9.6, True}

# Initializing an empty set:
a = set()
####

####
# Tuples are lists that cannot be changed after being created
# They are useful when returning multiple values from a function
# Tuples are annotated using the "tuple" keyword
a: tuple = ("Some string", 15, 9.6, True)

# Because tuples cannot be changed there is no point in initializing an empty one
####

####
# Dictionaries work of Key - Value pairs
# Keys can be any immutable type - integers, floats, strings and tuples
# Dictionaries do not keep the their order
# Dictionaries are annotated using the "dict" keyword
a: dict = {"A": "Some string", "B": 15, "C": 9.6, "D": True}

# Initializing an empty dictionary:
a = {}
####
</source>

==== Casting ====
Keywords: Casting
<source lang="python">
# Only certain operations can be performed on certain types of variables
# Changing between types of variables is called "casting"
a: str = "15"

b: int = int(a) # b = 15
c: float = float(b) # c = 15.0
d: str = str(c) # d = "15.0"
</source>

==== Mathematical operations ====
<source lang="python">
####
# Integers and floats support most arithmetic operations
a = 15
b = 6

c = a + b # c = 21
c = a - b # c = 9
c = a * b # c = 90
c = a / b # c = 2.5

# There are some special operators:
# modulus (%) returns what is left after division
# floor division (//) throws away the decimal place
c = a % b # c = 3
c = a // b # c = 2
####

####
# Strings only support 2 mathematical operators
# The addition (+) is used to concatenate strings
# The multiplication (*) returns multiples of a string
a = "Hello"
b = "World"

c = a + b # c = "HelloWorld"
c = a * 3 # c = "HelloHelloHello"
####

####
# Lists, tuples can be added to each other
# It concatenates the collections together
a = ["Hello", 15]
b = [9.6, True]

c = a + b # c = ["hello", 15, 9.6, True]
####

####
# You can use mathematical shorthand to make some code more readable
# Shorthand is supported for all operators and works with both strings and numbers
a = 12
b = "Hello"
c = "World"

a = a + 6 # Normal way
a += 6 # Shorthand gives the same result

b = b + c # Normal way, c = "HelloWorld"
b += c # Shorthand gives the same result
####
</source>

==== Modifying collections ====
<source lang="python">
####
# LISTS
# You can add values to a list by using the append() method:
a = []

a.append("Hello")
a.append(15)
a.append(True)

print(a) # a = ["Hello", 15, True]
####

####
# SETS
# You can add values to a list by using the add() method
# A list of values can be added to a set by using the update() method
a = set()
b = [15, 9.6, True]

a.add("Hello")
a.update(b)

print(a) # a = {"Hello", 15, 9.6, True}
####

####
# TUPLES
# Tuples cannot be added to, they do not change
####

####
# DICTIONARIES
# You can add a new value pair by assigning the key to a value
a = {}

a["A"] = "Hello"
a["B"] = 15
a["C"] = 9.6
a["D"] = True

print(a) # a = {"A": "Hello", "B": 15, "C": 9.6, "D": True}
####
</source>

=== Conditionals ===
==== If statement ====
<source lang="python">
# If statements are used when you want to do something when a condition is met
# The if or elif part occurs when the condition returns true
# The else part occurs when none of the previous conditions returned true
a = 12
b = 15

# The example below will return "Did the elif" because b > a
if a > b:
print("Did the if")
elif b > a: # Condition returns true
print("Did the elif")
else:
print("Did the else")

# The operators available:
# > < >= <= ==
# != (not equal) can be used or the keyword "not"

# If you want to create more complex conditions you can make use of "and", "or" and "in"
# And requires that all conditionals return true
# Or requires that one of the conditionals return true
# In returns true if a certain value is found inside a collection
a = [15, 9, 6]
b = 6

if 15 in a:
print("Found it")

# Would not run the code inside the if statement
if (15 in a) and (b > 9):
print("The item is in the list and 6 > 9")

# Would run the code inside the if statement
if (15 in a) or (b > 9):
print("The item is in the list or 6 > 9?")

# You can have calculations and function calls inside conditions:
if (15 + 2) > b:
print("17 > 6")
</source>

==== Try except ====

=== Loops ===
=== Functions ===
=== Classes ===

Python

2019-06-28T06:31:17Z

Hstrydom: /* Declaration and typing */

=== Variables ===
==== Declaration and typing ====
Keyword: declaring variables, variable assignment, boolean values, integers, floats, strings, lists, dictionaries (ordered dictionaries, default dictionaries), tuples, sets, mutable and immutable data types, variable typing.
<source lang="python">
####
# Boolean variables can only contain one of two values: True or False
# Boolean values are annotated by using the "bool" keyword
a: bool = True
####

####
# Integers are variables that contain any positive or negative whole number
# Integers are annotated using the "int" keyword
# Floats are variables that contains any positive or negative decimal
# Floats are annotated using the "float" keyword
a: int = 15
b: int = -23

c: float = 6.4
d: float = -9.5
####

####
# Strings are variables that contain text
# Strings are annotated using the "str" keyword
a: str = "This is a string"
b: str = 'Strings can be enclosed using single quotes'

# Initializing an empty string:
a = ""
####

####
# Lists are collections of other variables
# Lists are annotated using the "list" keyword
a: list = ["Some string", 15, 9.6, True]

# Initializing an empty list:
a = []
####

####
# Sets are lists that cannot contain duplicate values
# They also do not keep the order of the variables
# Sets are a lot faster than lists when looking for specific values
# Sets are annotated using the "set" keyword
a: set = {"Some string", 15, 9.6, True}

# Initializing an empty set:
a = set()
####

####
# Tuples are lists that cannot be changed after being created
# They are useful when returning multiple values from a function
# Tuples are annotated using the "tuple" keyword
a: tuple = ("Some string", 15, 9.6, True)

# Because tuples cannot be changed there is no point in initializing an empty one
####

####
# Dictionaries work of Key - Value pairs
# Keys can be any immutable type - integers, floats, strings and tuples
# Dictionaries do not keep the their order
# Dictionaries are annotated using the "dict" keyword
a: dict = {"A": "Some string", "B": 15, "C": 9.6, "D": True}

# Initializing an empty dictionary:
a = {}
####
</source>

==== Casting ====

==== Mathematical operations ====
<source lang="python">
####
# Integers and floats support most arithmetic operations
a = 15
b = 6

c = a + b # c = 21
c = a - b # c = 9
c = a * b # c = 90
c = a / b # c = 2.5

# There are some special operators:
# modulus (%) returns what is left after division
# floor division (//) throws away the decimal place
c = a % b # c = 3
c = a // b # c = 2
####

####
# Strings only support 2 mathematical operators
# The addition (+) is used to concatenate strings
# The multiplication (*) returns multiples of a string
a = "Hello"
b = "World"

c = a + b # c = "HelloWorld"
c = a * 3 # c = "HelloHelloHello"
####

####
# Lists, tuples can be added to each other
# It concatenates the collections together
a = ["Hello", 15]
b = [9.6, True]

c = a + b # c = ["hello", 15, 9.6, True]
####

####
# You can use mathematical shorthand to make some code more readable
# Shorthand is supported for all operators and works with both strings and numbers
a = 12
b = "Hello"
c = "World"

a = a + 6 # Normal way
a += 6 # Shorthand gives the same result

b = b + c # Normal way, c = "HelloWorld"
b += c # Shorthand gives the same result
####
</source>

==== Modifying collections ====
<source lang="python">
####
# LISTS
# You can add values to a list by using the append() method:
a = []

a.append("Hello")
a.append(15)
a.append(True)

print(a) # a = ["Hello", 15, True]
####

####
# SETS
# You can add values to a list by using the add() method
# A list of values can be added to a set by using the update() method
a = set()
b = [15, 9.6, True]

a.add("Hello")
a.update(b)

print(a) # a = {"Hello", 15, 9.6, True}
####

####
# TUPLES
# Tuples cannot be added to, they do not change
####

####
# DICTIONARIES
# You can add a new value pair by assigning the key to a value
a = {}

a["A"] = "Hello"
a["B"] = 15
a["C"] = 9.6
a["D"] = True

print(a) # a = {"A": "Hello", "B": 15, "C": 9.6, "D": True}
####
</source>

=== Conditionals ===
==== If statement ====
<source lang="python">
# If statements are used when you want to do something when a condition is met
# The if or elif part occurs when the condition returns true
# The else part occurs when none of the previous conditions returned true
a = 12
b = 15

# The example below will return "Did the elif" because b > a
if a > b:
print("Did the if")
elif b > a: # Condition returns true
print("Did the elif")
else:
print("Did the else")

# The operators available:
# > < >= <= ==
# != (not equal) can be used or the keyword "not"

# If you want to create more complex conditions you can make use of "and", "or" and "in"
# And requires that all conditionals return true
# Or requires that one of the conditionals return true
# In returns true if a certain value is found inside a collection
a = [15, 9, 6]
b = 6

if 15 in a:
print("Found it")

# Would not run the code inside the if statement
if (15 in a) and (b > 9):
print("The item is in the list and 6 > 9")

# Would run the code inside the if statement
if (15 in a) or (b > 9):
print("The item is in the list or 6 > 9?")

# You can have calculations and function calls inside conditions:
if (15 + 2) > b:
print("17 > 6")
</source>

==== Try except ====

=== Loops ===
=== Functions ===
=== Classes ===

Python

2019-06-26T14:50:41Z

Hstrydom: /* If statement */

=== Variables ===
==== Declaration and typing ====
<source lang="python">
####
# Boolean variables can only contain one of two values: True or False
# Boolean values are annotated by using the "bool" keyword
a: bool = True
####

####
# Integers are variables that contain any positive or negative whole number
# Integers are annotated using the "int" keyword
# Floats are variables that contains any positive or negative decimal
# Floats are annotated using the "float" keyword
a: int = 15
b: int = -23

c: float = 6.4
d: float = -9.5
####

####
# Strings are variables that contain text
# Strings are annotated using the "str" keyword
a: str = "This is a string"
b: str = 'Strings can be enclosed using single quotes'

# Initializing an empty string:
a = ""
####

####
# Lists are collections of other variables
# Lists are annotated using the "list" keyword
a: list = ["Some string", 15, 9.6, True]

# Initializing an empty list:
a = []
####

####
# Sets are lists that cannot contain duplicate values
# They also do not keep the order of the variables
# Sets are a lot faster than lists when looking for specific values
# Sets are annotated using the "set" keyword
a: set = {"Some string", 15, 9.6, True}

# Initializing an empty set:
a = set()
####

####
# Tuples are lists that cannot be changed after being created
# They are useful when returning multiple values from a function
# Tuples are annotated using the "tuple" keyword
a: tuple = ("Some string", 15, 9.6, True)

# Because tuples cannot be changed there is no point in initializing an empty one
####

####
# Dictionaries work of Key - Value pairs
# Keys can be any immutable type - integers, floats, strings and tuples
# Dictionaries do not keep the their order
# Dictionaries are annotated using the "dict" keyword
a: dict = {"A": "Some string", "B": 15, "C": 9.6, "D": True}

# Initializing an empty dictionary:
a = {}
####
</source>
==== Mathematical operations ====
<source lang="python">
####
# Integers and floats support most arithmetic operations
a = 15
b = 6

c = a + b # c = 21
c = a - b # c = 9
c = a * b # c = 90
c = a / b # c = 2.5

# There are some special operators:
# modulus (%) returns what is left after division
# floor division (//) throws away the decimal place
c = a % b # c = 3
c = a // b # c = 2
####

####
# Strings only support 2 mathematical operators
# The addition (+) is used to concatenate strings
# The multiplication (*) returns multiples of a string
a = "Hello"
b = "World"

c = a + b # c = "HelloWorld"
c = a * 3 # c = "HelloHelloHello"
####

####
# Lists, tuples can be added to each other
# It concatenates the collections together
a = ["Hello", 15]
b = [9.6, True]

c = a + b # c = ["hello", 15, 9.6, True]
####

####
# You can use mathematical shorthand to make some code more readable
# Shorthand is supported for all operators and works with both strings and numbers
a = 12
b = "Hello"
c = "World"

a = a + 6 # Normal way
a += 6 # Shorthand gives the same result

b = b + c # Normal way, c = "HelloWorld"
b += c # Shorthand gives the same result
####
</source>

==== Modifying collections ====
<source lang="python">
####
# LISTS
# You can add values to a list by using the append() method:
a = []

a.append("Hello")
a.append(15)
a.append(True)

print(a) # a = ["Hello", 15, True]
####

####
# SETS
# You can add values to a list by using the add() method
# A list of values can be added to a set by using the update() method
a = set()
b = [15, 9.6, True]

a.add("Hello")
a.update(b)

print(a) # a = {"Hello", 15, 9.6, True}
####

####
# TUPLES
# Tuples cannot be added to, they do not change
####

####
# DICTIONARIES
# You can add a new value pair by assigning the key to a value
a = {}

a["A"] = "Hello"
a["B"] = 15
a["C"] = 9.6
a["D"] = True

print(a) # a = {"A": "Hello", "B": 15, "C": 9.6, "D": True}
####
</source>

=== Conditionals ===
==== If statement ====
<source lang="python">
# If statements are used when you want to do something when a condition is met
# The if or elif part occurs when the condition returns true
# The else part occurs when none of the previous conditions returned true
a = 12
b = 15

# The example below will return "Did the elif" because b > a
if a > b:
print("Did the if")
elif b > a: # Condition returns true
print("Did the elif")
else:
print("Did the else")

# The operators available:
# > < >= <= ==
# != (not equal) can be used or the keyword "not"

# If you want to create more complex conditions you can make use of "and", "or" and "in"
# And requires that all conditionals return true
# Or requires that one of the conditionals return true
# In returns true if a certain value is found inside a collection
a = [15, 9, 6]
b = 6

if 15 in a:
print("Found it")

# Would not run the code inside the if statement
if (15 in a) and (b > 9):
print("The item is in the list and 6 > 9")

# Would run the code inside the if statement
if (15 in a) or (b > 9):
print("The item is in the list or 6 > 9?")

# You can have calculations and function calls inside conditions:
if (15 + 2) > b:
print("17 > 6")
</source>

==== Try except ====

=== Loops ===
=== Functions ===
=== Classes ===

Python

2019-06-26T14:49:28Z

Hstrydom: /* If statement */

=== Variables ===
==== Declaration and typing ====
<source lang="python">
####
# Boolean variables can only contain one of two values: True or False
# Boolean values are annotated by using the "bool" keyword
a: bool = True
####

####
# Integers are variables that contain any positive or negative whole number
# Integers are annotated using the "int" keyword
# Floats are variables that contains any positive or negative decimal
# Floats are annotated using the "float" keyword
a: int = 15
b: int = -23

c: float = 6.4
d: float = -9.5
####

####
# Strings are variables that contain text
# Strings are annotated using the "str" keyword
a: str = "This is a string"
b: str = 'Strings can be enclosed using single quotes'

# Initializing an empty string:
a = ""
####

####
# Lists are collections of other variables
# Lists are annotated using the "list" keyword
a: list = ["Some string", 15, 9.6, True]

# Initializing an empty list:
a = []
####

####
# Sets are lists that cannot contain duplicate values
# They also do not keep the order of the variables
# Sets are a lot faster than lists when looking for specific values
# Sets are annotated using the "set" keyword
a: set = {"Some string", 15, 9.6, True}

# Initializing an empty set:
a = set()
####

####
# Tuples are lists that cannot be changed after being created
# They are useful when returning multiple values from a function
# Tuples are annotated using the "tuple" keyword
a: tuple = ("Some string", 15, 9.6, True)

# Because tuples cannot be changed there is no point in initializing an empty one
####

####
# Dictionaries work of Key - Value pairs
# Keys can be any immutable type - integers, floats, strings and tuples
# Dictionaries do not keep the their order
# Dictionaries are annotated using the "dict" keyword
a: dict = {"A": "Some string", "B": 15, "C": 9.6, "D": True}

# Initializing an empty dictionary:
a = {}
####
</source>
==== Mathematical operations ====
<source lang="python">
####
# Integers and floats support most arithmetic operations
a = 15
b = 6

c = a + b # c = 21
c = a - b # c = 9
c = a * b # c = 90
c = a / b # c = 2.5

# There are some special operators:
# modulus (%) returns what is left after division
# floor division (//) throws away the decimal place
c = a % b # c = 3
c = a // b # c = 2
####

####
# Strings only support 2 mathematical operators
# The addition (+) is used to concatenate strings
# The multiplication (*) returns multiples of a string
a = "Hello"
b = "World"

c = a + b # c = "HelloWorld"
c = a * 3 # c = "HelloHelloHello"
####

####
# Lists, tuples can be added to each other
# It concatenates the collections together
a = ["Hello", 15]
b = [9.6, True]

c = a + b # c = ["hello", 15, 9.6, True]
####

####
# You can use mathematical shorthand to make some code more readable
# Shorthand is supported for all operators and works with both strings and numbers
a = 12
b = "Hello"
c = "World"

a = a + 6 # Normal way
a += 6 # Shorthand gives the same result

b = b + c # Normal way, c = "HelloWorld"
b += c # Shorthand gives the same result
####
</source>

==== Modifying collections ====
<source lang="python">
####
# LISTS
# You can add values to a list by using the append() method:
a = []

a.append("Hello")
a.append(15)
a.append(True)

print(a) # a = ["Hello", 15, True]
####

####
# SETS
# You can add values to a list by using the add() method
# A list of values can be added to a set by using the update() method
a = set()
b = [15, 9.6, True]

a.add("Hello")
a.update(b)

print(a) # a = {"Hello", 15, 9.6, True}
####

####
# TUPLES
# Tuples cannot be added to, they do not change
####

####
# DICTIONARIES
# You can add a new value pair by assigning the key to a value
a = {}

a["A"] = "Hello"
a["B"] = 15
a["C"] = 9.6
a["D"] = True

print(a) # a = {"A": "Hello", "B": 15, "C": 9.6, "D": True}
####
</source>

=== Conditionals ===
==== If statement ====
<source lang="python">
# If statements are used when you want to do something when a condition is met
# The if or elif part occurs when the condition returns true
# The else part occurs when none of the previous conditions returned true
a = 12
b = 15

# The example below will return "Did the elif" because b > a
if a > b:
print("Did the if")
elif b > a: # Condition returns true
print("Did the elif")
else:
print("Did the else")

# The operators available:
# > < >= <= == !=

# If you want to create more complex conditions you can make use of "and", "or" and "in"
# And requires that all conditionals return true
# Or requires that one of the conditionals return true
# In returns true if a certain value is found inside a collection
a = [15, 9, 6]
b = 6

if 15 in a:
print("Found it")

# Would not run the code inside the if statement
if (15 in a) and (b > 9):
print("The item is in the list and 6 > 9")

# Would run the code inside the if statement
if (15 in a) or (b > 9):
print("The item is in the list or 6 > 9?")

# You can have calculations and function calls inside conditions:
if (15 + 2) > b:
print("17 > 6")
</source>

==== Try except ====

=== Loops ===
=== Functions ===
=== Classes ===

Python

2019-06-26T14:37:26Z

Hstrydom: /* Conditionals */

=== Variables ===
==== Declaration and typing ====
<source lang="python">
####
# Boolean variables can only contain one of two values: True or False
# Boolean values are annotated by using the "bool" keyword
a: bool = True
####

####
# Integers are variables that contain any positive or negative whole number
# Integers are annotated using the "int" keyword
# Floats are variables that contains any positive or negative decimal
# Floats are annotated using the "float" keyword
a: int = 15
b: int = -23

c: float = 6.4
d: float = -9.5
####

####
# Strings are variables that contain text
# Strings are annotated using the "str" keyword
a: str = "This is a string"
b: str = 'Strings can be enclosed using single quotes'

# Initializing an empty string:
a = ""
####

####
# Lists are collections of other variables
# Lists are annotated using the "list" keyword
a: list = ["Some string", 15, 9.6, True]

# Initializing an empty list:
a = []
####

####
# Sets are lists that cannot contain duplicate values
# They also do not keep the order of the variables
# Sets are a lot faster than lists when looking for specific values
# Sets are annotated using the "set" keyword
a: set = {"Some string", 15, 9.6, True}

# Initializing an empty set:
a = set()
####

####
# Tuples are lists that cannot be changed after being created
# They are useful when returning multiple values from a function
# Tuples are annotated using the "tuple" keyword
a: tuple = ("Some string", 15, 9.6, True)

# Because tuples cannot be changed there is no point in initializing an empty one
####

####
# Dictionaries work of Key - Value pairs
# Keys can be any immutable type - integers, floats, strings and tuples
# Dictionaries do not keep the their order
# Dictionaries are annotated using the "dict" keyword
a: dict = {"A": "Some string", "B": 15, "C": 9.6, "D": True}

# Initializing an empty dictionary:
a = {}
####
</source>
==== Mathematical operations ====
<source lang="python">
####
# Integers and floats support most arithmetic operations
a = 15
b = 6

c = a + b # c = 21
c = a - b # c = 9
c = a * b # c = 90
c = a / b # c = 2.5

# There are some special operators:
# modulus (%) returns what is left after division
# floor division (//) throws away the decimal place
c = a % b # c = 3
c = a // b # c = 2
####

####
# Strings only support 2 mathematical operators
# The addition (+) is used to concatenate strings
# The multiplication (*) returns multiples of a string
a = "Hello"
b = "World"

c = a + b # c = "HelloWorld"
c = a * 3 # c = "HelloHelloHello"
####

####
# Lists, tuples can be added to each other
# It concatenates the collections together
a = ["Hello", 15]
b = [9.6, True]

c = a + b # c = ["hello", 15, 9.6, True]
####

####
# You can use mathematical shorthand to make some code more readable
# Shorthand is supported for all operators and works with both strings and numbers
a = 12
b = "Hello"
c = "World"

a = a + 6 # Normal way
a += 6 # Shorthand gives the same result

b = b + c # Normal way, c = "HelloWorld"
b += c # Shorthand gives the same result
####
</source>

==== Modifying collections ====
<source lang="python">
####
# LISTS
# You can add values to a list by using the append() method:
a = []

a.append("Hello")
a.append(15)
a.append(True)

print(a) # a = ["Hello", 15, True]
####

####
# SETS
# You can add values to a list by using the add() method
# A list of values can be added to a set by using the update() method
a = set()
b = [15, 9.6, True]

a.add("Hello")
a.update(b)

print(a) # a = {"Hello", 15, 9.6, True}
####

####
# TUPLES
# Tuples cannot be added to, they do not change
####

####
# DICTIONARIES
# You can add a new value pair by assigning the key to a value
a = {}

a["A"] = "Hello"
a["B"] = 15
a["C"] = 9.6
a["D"] = True

print(a) # a = {"A": "Hello", "B": 15, "C": 9.6, "D": True}
####
</source>

=== Conditionals ===
==== If statement ====
==== Try except ====

=== Loops ===
=== Functions ===
=== Classes ===

Python

2019-06-26T14:35:06Z

Hstrydom: /* Mathematical operations */

Python

2019-06-26T14:25:43Z

Hstrydom: /* Modifying collections */

=== Variables ===
==== Declaration and typing ====
<source lang="python">
####
# Boolean variables can only contain one of two values: True or False
# Boolean values are annotated by using the "bool" keyword
a: bool = True
####

####
# Integers are variables that contain any positive or negative whole number
# Integers are annotated using the "int" keyword
# Floats are variables that contains any positive or negative decimal
# Floats are annotated using the "float" keyword
a: int = 15
b: int = -23

c: float = 6.4
d: float = -9.5
####

####
# Strings are variables that contain text
# Strings are annotated using the "str" keyword
a: str = "This is a string"
b: str = 'Strings can be enclosed using single quotes'

# Initializing an empty string:
a = ""
####

####
# Lists are collections of other variables
# Lists are annotated using the "list" keyword
a: list = ["Some string", 15, 9.6, True]

# Initializing an empty list:
a = []
####

####
# Sets are lists that cannot contain duplicate values
# They also do not keep the order of the variables
# Sets are a lot faster than lists when looking for specific values
# Sets are annotated using the "set" keyword
a: set = {"Some string", 15, 9.6, True}

# Initializing an empty set:
a = set()
####

####
# Tuples are lists that cannot be changed after being created
# They are useful when returning multiple values from a function
# Tuples are annotated using the "tuple" keyword
a: tuple = ("Some string", 15, 9.6, True)

# Because tuples cannot be changed there is no point in initializing an empty one
####

####
# Dictionaries work of Key - Value pairs
# Keys can be any immutable type - integers, floats, strings and tuples
# Dictionaries do not keep the their order
# Dictionaries are annotated using the "dict" keyword
a: dict = {"A": "Some string", "B": 15, "C": 9.6, "D": True}

# Initializing an empty dictionary:
a = {}
####
</source>
==== Mathematical operations ====
<source lang="python">
####
# Integers and floats support most arithmetic operations
a = 15
b = 6

c = a + b # c = 21
c = a - b # c = 9
c = a * b # c = 90
c = a / b # c = 2.5

# There are some special operators:
# modulus (%) returns what is left after division
# floor division (//) throws away the decimal place
c = a % b # c = 3
c = a // b # c = 2
####

####
# Strings only support 2 mathematical operators
# The addition (+) is used to concatenate strings
# The multiplication (*) returns multiples of a string
a = "Hello"
b = "World"

c = a + b # c = "HelloWorld"
c = a * 3 # c = "HelloHelloHello"
####

####
# You can use mathematical shorthand to make some code more readable
# Shorthand is supported for all operators and works with both strings and numbers
a = 12
b = "Hello"
c = "World"

a = a + 6 # Normal way
a += 6 # Shorthand gives the same result

b = b + c # Normal way, c = "HelloWorld"
b += c # Shorthand gives the same result
####
</source>
==== Modifying collections ====
<source lang="python">
####
# LISTS
# You can add values to a list by using the append() method:
a = []

a.append("Hello")
a.append(15)
a.append(True)

print(a) # a = ["Hello", 15, True]
####

####
# SETS
# You can add values to a list by using the add() method
# A list of values can be added to a set by using the update() method
a = set()
b = [15, 9.6, True]

a.add("Hello")
a.update(b)

print(a) # a = {"Hello", 15, 9.6, True}
####

####
# TUPLES
# Tuples cannot be added to, they do not change
####

####
# DICTIONARIES
# You can add a new value pair by assigning the key to a value
a = {}

a["A"] = "Hello"
a["B"] = 15
a["C"] = 9.6
a["D"] = True

print(a) # a = {"A": "Hello", "B": 15, "C": 9.6, "D": True}
####
</source>

=== Conditionals ===
=== Loops ===
=== Functions ===
=== Classes ===

Python

2019-06-26T14:13:36Z

Hstrydom: /* Mathematical operations */

Python

2019-06-26T14:12:43Z

Hstrydom: /* Mathematical operations */

Python

2019-06-26T14:09:25Z

Hstrydom: /* Operations */

Python

2019-06-26T13:57:04Z

Hstrydom: /* Variables */

Python

2019-06-26T13:55:06Z

Hstrydom: /* Declaration and typing */

Python

2019-06-26T13:43:56Z

Hstrydom: /* Variables */

Python

2019-06-26T13:26:20Z

Hstrydom: Replaced content with "=== Variables === === Conditionals === === Loops === === Functions === === Classes ==="

=== Variables ===
=== Conditionals ===
=== Loops ===
=== Functions ===
=== Classes ===

Python

2019-06-20T10:12:13Z

Hstrydom: /* Slicing */

=== Variables ===
Variables allow you to store and change values based on certain conditions. In many low level languages like C, C++ and Java when declaring a variable it is required that you also specify of what type the variable will be. This type is then static and will never change. In java for example declaring a variable that will in the future store a number looks like this:

<source lang="java">
int some_number;
</source>

Many scripting languages, like python, are weakly or loosely typed. This means that you are not required to assign a type to a variable when you create it. This makes the language extremely flexible, but it become easy to get confused with what type a variable is, especially when passing them into functions and assigning function return values.

It is thus recommended that you type variables. An example of typing in python:
<source lang="python">
def some_function(x: int) -> float:
return x / 3.2
</source>

==== Integers and Floats ====
Integers and floats are the default number data types in python. Integers are whole numbers, while floats are fraction, or number with decimals. Both integers and floats can be positive or negative.

Assigning a value to an integer or float looks as follow:
<source lang="python">
# The only difference between assigning to a float and an integer is
# whether or not the number has a decimal
a: int = 2
b: float = 2.0
</source>

===== Operators =====
There are a wide variety of operation that you can perform on integers and floats. Listed below are the most used operators.
{| class="wikitable" style="text-align: left;"
! Character
! Operator
! Example
|-
| + || Addition || <source lang="python">a = 12 + 14.3 # Returns 26.5</source>
|-
| - || Subtraction || <source lang="python">a = 2 - 2.9 # Returns -0.9</source>
|-
| * || Multiplication || <source lang="python">a = 4 * 1.5 # Returns 6</source>
|-
| / || Division || <source lang="python">a = 9 / 3 # Returns 3</source>
|-
| % || Modulus || <source lang="python">a = 7 % 3 # Returns 1</source> || Returns integer the integer remainder after division
|-
| // || Floor division || <source lang="python">a = 8 // 3 # Returns 2</source> || Rounds down after division
|}

==== Booleans ====
Bollean values are either one of two value: True or False. Booleans are mostly used in conditionals and in very rare cases as "switches".

Declaring a boolean is as easy as assigning either Trye or False to a variable:
<source lang="python">
a: bool = True
b: bool = False
</source>

==== Strings ====
Strings are variables that contain text. Strings can contain any combination of alphanumerical characters and special characters. Strings are enclosed in either two single quotes or two double quotes.

<source lang="python">
# Initializing an empty string
a: str = ""

# Initializing a string with text
b: str = "Your text goes here"
</source>

If you need a string that either contains a single or double quote then just enclose the string with the other type of quote
<source lang="python">
# When printed to console it will display as It's cold today
a: str = "It's cold today"

# When printed to console it will display as Me: "Hey"
a: str = 'Me: "Hey"'
</source>

The backslash character is known as an escape character. It, in combination with other characters, are used to represent characters like a tab "\t", newline "\n" and carriage return "\r"
<source lang="python">
a: str = "My name is: \nMy surname is:"
# The "\n" tells us that a new line should start there, the result is:
# My name is:
# My surname is:
</source>

If you want to use the backslash character in a string then you need to escape it using another backslash
<source lang="python">
a: str = "D:\\User\\Documents\\" # Returns D:\User\Documents\
</source>

===== Operators =====
Operations on string are more limited than floats and integers.
{| class="wikitable" style="text-align: left;"
! Character
! Operator
! Example
|-
| + || Addition || <source lang="python">a = "Hello" + " " + "World" # Returns "Hello World"</source>
|-
| * || Multiplication || <source lang="python">a = "ha" * 4 # Returns "hahahaha"</source>
|}

String concatenation is accomplished by using the addition operator. Concatenation only sticks the strings together, any spaces, tabs or special characters you will need to add yourself.

==== Lists ====
Lists are just a collection of other types of variables. Lists can contain any other variable, be it a number, string or another list.
<source lang="python">
# Declaring an emptry list
a: list = []

# Declaring and initializing a list
# Values in a list are comma separated
a: list = ["Hello", "World", 15, 19.6, True]
</source>

==== Tuples ====
Tuples are lists that can not be changed after they have be declared. They are often used when returning multiple values from functions, and unlike lists can be used as keys in dictionaries.
<source lang="python">
# Values in a tuple are comma separated
a: tuple = ("Hello", "World", 15, 19.6, True)
</source>

==== Sets ====
A set is a list that cannot contain duplicate values. The order of the items in a set are also not consistent. Sets can be changed after being created.
<source lang="python">
# Declaring an empty set
a: set = set()

# Declaring and initializing a set
a: set = {"Hello", "World", 15, 19.6, True}
</source>

==== Dictionaries ====
Dictionaries consist of key - value pairs. A key value is associated with a corresponding value. A key can be an integer, float, string or tuple. A dictionary cannot contain duplicate keys. The value can be of any data type. A key and value are separated by a colon. Different key - value pairs are separated by commas.
<source lang="python">
# Declaring an empty dictionary
a: dict = {}

# Declaring and initializing a dictionary
a: dict = {"A": "Hello", "B": "World", "C": 15, "D": 19.6, "E": True}
</source>

=== Indexing and Slicing ===
==== Indexing ====
Accessing a specific value in a list or tuple, or returning a specific character from a string requires an index. The first value in a list or tuple, or the first character in a string is referred to as index 0. Some language start indexing at 1, by they are few and far between.

Accessing values are done using square brackets "[ ]":
<source lang="python">
# Lists and tuples work the exactly the same
a: list = ["Hello", "World", 15, 19.6, True]
b = a[0] # b is equal to "Hello"
b = a[2] # b is equal to the 3rd element in list a: 15

# Strings are just lists of characters
a: str = "Hello"
b = a[0] # b is equal to "H"
b = a[2] # b is equal to the 3rd character in string a: "l"
</source>

Values in dictionaries are returned by using the key.
<source lang="python">
a: dict = {"A": "Hello", "B": "World", "C": 15, "D": 19.6, "E": True}
b = a["A"] # b is equal to "hello"
b = a["D"] # b is equal to 19.6
</source>

==== Slicing ====
If you want more than one value from a list/tuple or string then can you make use of slicing. Slicing is done by specifying a start and stop index, separated by a colon. The values are returned as the same type of variable. Start index is included and stop index excluded (Mathematically writen as [x,y) ).

<source lang="python">
a: list = ["Hello", "World", 15, 19.6, True]
# b is equal to the list a from position 0 to 3, excluding 3 -> index 0,1 and 2
# b is equal to a list ["Hello", "World", 15]
b = a[0:3]

# c is equal to the list a from position 1 to 3, excluding 3 -> index 1 and 2
# b is equal to a list ["World", 15]
c = a[1:3]
</source>

If a start or stop index is left out then it is implied that is start index is the very start of the list/string or that the stop index is the very end of the list/string. This is useful when you do not know ahead of time how long the list/string is going to be.

<source lang="python">
a: list = ["Hello", "World", 15, 19.6, True]
# b is equal to the list a from the start to 3, excluding 3 -> index 0,1 and 2
# b is equal to a list ["Hello", "World", 15]
b = a[:3]

# c is equal to the list a from position 1 to the end -> index 1, 2, 3 and 4
# c is equal to a list ["World", 15]
c = a[1:]
</source>

Python

2019-06-20T09:58:49Z

Hstrydom: /* Indexing and Slicing */

Python

2019-06-20T09:58:17Z

Hstrydom: /* Indexing and Slicing */

Python

2019-06-20T09:47:06Z

Hstrydom: /* Variables */

Python

2019-06-20T09:46:18Z

Hstrydom: /* Dictionaries */

Python

2019-06-20T09:41:11Z

Hstrydom: /* Sets */

Python

2019-06-20T09:36:03Z

Hstrydom: /* Tuples */

Python

2019-06-20T09:33:20Z

Hstrydom: /* Lists */

Python

2019-06-20T09:27:40Z

Hstrydom: /* Operators */

Python

2019-06-20T09:21:29Z

Hstrydom: /* Strings */

Python

2019-06-20T09:00:14Z

Hstrydom: /* Booleans */

Python

2019-06-20T08:56:06Z

Hstrydom: /* Operators */

Python

2019-06-20T08:54:53Z

Hstrydom: /* Variables */

Python

2019-06-20T08:50:37Z

Hstrydom: /* Variables */

Python

2019-06-20T08:49:39Z

Hstrydom: /* Operators */

Python

2019-06-20T06:25:23Z

Hstrydom: /* Integers and Floats */

Python

2019-06-20T06:19:51Z

Hstrydom: /* Variables */

Python

2019-06-20T06:11:45Z

Hstrydom: Created page with "=== Variables === ==== Integers and Floats ==== ==== Booleans ==== ==== Strings ==== ==== Lists ==== ==== Tuples ==== ==== Sets ==== ==== Dictionaries ===="

=== Variables ===
==== Integers and Floats ====
==== Booleans ====
==== Strings ====
==== Lists ====
==== Tuples ====
==== Sets ====
==== Dictionaries ====

Main Page

2019-06-20T04:40:17Z

Hstrydom: Added the first 2 topics to the black mamba section

Welcome to the Centre for Bioinformatics and Computational Biology!

== Getting started ==
* [[Obtaining an account]]
* [[Logging in to a terminal session]]
* [[Running jobs on our servers]]
* [[Using the PBS / Torque queueing environment]]
* [[Software resources]]
* [[Hardware resources]]
* [http://wiki.bi.up.ac.za/wiki/index.php?title=Storage_Quotas_and_Charges&action=edit&redlink=1 Storage Quotas and Charges]
* [[Transferring large quantities of data between institutions]]
* [[Backups]]
* The compute infrastructure load can be seen in the [http://wonko.bi.up.ac.za/ganglia/?c=unspecified&m=load_one&r=hour&s=by%20name&hc=4&mc=2 ganglia monitor]
* The Bioinformatics post-graduate lecture [https://docs.google.com/spreadsheets/d/1DYL-XHFb4-o3mi6E6x1F4kLRCdFKrdLERI7LO6RqwbI/edit?usp=sharing schedule] is available for any interested students from other departments to attend. Lectures are on Tuesdays at 11:00 and Thursdays at 10:00 in FABI Square 3-26
* [[Migrating your data safely]]
* [[File and directory permissions and ownership]]
* [[Guidelines and Terms of use]]
* [[Safety and security at the Lab]]
== The Black Mamba Resource ==
* [[Joining the discussion]]
* [[Python]]