CodingHome

Comments

You can write text that the program will ignore by beginning the line with a #, this helps with reminding you what certain code does or for explaining purposes.

 
# This is a comment 
  

Data Types

Variables can store data of different types, and different types can do different things.

Python has the following data types built-in by default, in these categories:
Text Type: str
Numeric Types: int, float, complex
Sequence Types: list, tuple, range
Mapping Type: dict
Set Types: set, frozenset
Boolean Type: bool
Binary Types: bytes, bytearray, memoryview

We will go more in-depth on some of these types in the next few sections.

You can print the data type of a variable with the type() function:

x = 5 
 print(type(x)) 
 

Strings

Strings are surrounded by either single quotation marks, or double quotation marks.:

  
x = "hello" 
y = 'hello'
# single quotations and double quotation marks are the same
x == y # returns True 

You can assign a multiline string to a variable by using three quotes:

 
x = """The FitnessGram Pacer test is a multistage aerobic capacity test that progressively gets more difficult as it continues. The 20 meter Pacer test will begin in 30 seconds."""  

You can check the length of a string using the len() function:

  
x = "hello" 
print(len(text)) # returns 5

Numbers

There are 2 primary, int and float

 
x = 2   # int
y = 2.8 # float 

To verify the type of an object in Python, use the type() function:

 
print(type(x)) 
print(type(y)) 

Int, or integers, are whole numbers, positive or negative, without decimals.

Float is a number, positive or negative, containing one or more decimals.

Both strings and numbers are built-in data types.

Strings

A string is a sequence of characters representing text. Strings are typically enclosed in quotation marks and can be stored in variables for later use in a program.

 
#include <ostream>
#include <string>

int main() { 
    // Declare a string variable
    std::string str = "codinghome"; 
} 

Integers and Floating Point Numbers

Simply said, Integers are used for numbers without a decimal, and Float is used for numbers with decimals, simply said. There is more to that but we are keeping it simple.

 
#include <iostream>

int main() { 
  // Declare an integer variable 
  int num = 10; 

  // Declare a floating-point variable float 
  fnum = 10.5; 
} 

Print

Printing an output to the terminal/console:

#include <iostream>

int main() {
  // Declare an integer variable
  int num = 10;
  // Declare a floating-point variable
  float fnum = 10.5;
  
  std::cout << "num: " << num << std::endl; // <-- Prints the integer variable (variable num)
  std::cout << "fnum: " << fnum << std::endl; // <-- Prints the floating point variable (variable fnum)
  
  return 0;
}

Data Types

In Haskell, types are how you describe the data your program will work with. Types can be simple, like:

• Bool: boolean True or False.
• Char: one character.
• Int: fixed-precision signed integer (usually 64-bit)
• Float / Double: floating-point values.

Or, they can be composed with constructs, like:

• String: shortcut for [Char].
• [a] : list of as (where a is a general type).
• (a, b) : tuple composed of a and b
• Just a : Maybe monad with the Just option

Function Type Declaration

Haskell's functions will usually have 2 parts: a type declaration, and the implementation of the function itself (the type part can also be inferred):

 
-- type declaration 
-- constraints => type -> ... -> returnType (the last type will always be the return type) 
countIns :: Eq a => a -> [a] -> Int
-- implementation 
countIns x = length . filter (== x)

• Bool: boolean True or False.
• Char: one character.
• Int: fixed-precision signed integer (usually 64-bit)
• Float / Double: floating-point values.

Notice the type declaration has 2 types of "arrows": => and ->.

• => : used for giving additional context of what rules a should follow (in the example above, we see a should be part of the Eq class, which allows for comparison)
• -> : used for actually declaring the type of the function (in the above example, we see the first argument is a, a general, comparable type, then a list of as and then finally it outputs an Integer)

Function Definition

Functions are defined similar to:

functionName argument(s) = expression

Haskell forces declarative style, so functions are (usually) composed of just an expression (always returns a value).

 
-- type declaration 
countIns :: Eq a => a -> [a] -> Int 
-- implementation 
-- function args = expression 
countIns x = length . filter (== x) 

Functional Principles

Haskell restricts to the functional paradigm, meaning Haskell enforces:

• Immutability: when the data has to be defined again for it to "change"
• Purity: functions must be pure, producing no side-effects (like modifying a global variable), and must be deterministic (f(x) = y, no matter when f is called)
• Higher-order functions: functions must be first-class, meaning they can be passed as arguments to other functions. This allows for higher-order functions. which take a function and other data and apply the function to the data in different ways.
• Disciplined state trying to minimize the use of mutable state and trying to make it local when possible.

Comments

In-line comments are made with -- and block comments with {- -}:

-- inline
commentHere = False {
- block commentHere = True -} 

Example Document

<!DOCTYPE html>
<html>
  <body>
    <h1>My first Heading</h1>
    <p>My first paragraph</p>
  </body>
</html>

The <!DOCTYPE> declaration represents the document type, and helps browsers to display web pages correctly. It must only appear once, at the top of the page (before any HTML tags). The <!DOCTYPE> declaration is not case sensitive.

HTML Headings

HTML headings are defined with the <h1> to <h6> tags. <h1>defines the most important heading. <h6> defines the least important heading:
<h1>Big</h1>
<h6>Small</h6>

HTML Paragraphs

HTML paragraphs are defined with the <p> tag:

<p>This is a paragraph.</p>

<p>This is another paragraph.</p>

HTML Links

HTML links are defined with the <a> tag:

<a href="https://example.com">This is a link</a>

HTML Images

HTML images are defined with the <img> tag. The source file (src), alternative text (alt), width, and height are provided as attributes:

<img src="example.jpg" alt="example.com" width="104" height="142">

Example Document

h1 {
  color: black;
  text-align: center;
  font-size: 26px;
  font-family: verdana;
}

<p style="font-size:10px">

To put CSS files in HTML, use:

<link rel="stylesheet" href="style.css">

To put CSS code in HTML, use:

<style>
  .class {
    color: red;
  }
</style>

CSS Rulesets

p { 

  color: red; 

}

Properties - With these, you can style a HTML element, like for example; color.
Property Value - This chooses one of the possible options for a given property, like red for color.

You can also write CSS like:

html{color:red;}

You can also put styles in HTML elements:

<h1 style="font-color:white;">

You can also select multiple elements with commas at once like...

h1, h4, h6, h2 {
  color: red;
}

Classes

Think of classes like custom HTML elements, they can be applied in HTML:

<p class="text-red">

Classes begin with a dot or period (.) to begin the selector.

.text-red {
  color: red;
}

Selectors

There are more ways to select elements and classes apart from their name. Here's some common ones:

:hover

:first-child

:last-child

:nth-child(n)

:

:has(+ element)

Text Elements

font-size: 10px;

font-family: verdana;

text-align: center;

text-shadow: 3px black

Padding Elements

padding-top: 50px;

margin: 50px;

border-width: 5px;

border-style: dotted;

width=500px;

Color Elements

color: red;

background-color: white;

Comments

Comments are commonly used to explain the code and may help when you edit the source code later and are ignored by browsers.

A CSS comment starts with /* and ends with */, and no changes are needed to make it multiple lines.

/* This is a single-line comment */

/* This is
a multi-line
comment */

Extra: Centering Images

img {
  margin: 0 auto;
  display: block;
}

Including JavaScript in an HTML Page

<script type="text/javascript">
  //JS code goes here 
</script> 

Call an External JavaScript File

<script src="myscript.js"></script>

Including Comments

Single line comments - // Comment
Multi-line comments - /* comment here */

Variables

var, const, let
var — The most common variable. It can be reassigned but only accessed within a function. Variables defined with var move to the top when code is executed.
const — Can not be reassigned and not accessible before they appear within the code.
let — Similar to const, however, let variable can be reassigned but not re-declared.

Data Types

Numbers —

var age = 23

var x

var a = "init"

var b = 1 + 2 + 3

var c = true

const PI = 3.14

var name = {firstName: "John", lastName: "Doe"}

Objects Example

var person = {
  firstName: "John",
  lastName: "Doe",
  age: 20,
  nationality: "American"
}

Querying Data from a Table

Query Data in Columns c1, c2 from a Table

SELECT c1, c2 FROM t;

Query All Rows and Columns from a Table

SELECT * FROM t;

Query Data and Filter Rows with a Condition

SELECT c1, c2 FROM t
WHERE condition;

Query Distinct Rows from a Table

SELECT DISTINCT c1 FROM t
WHERE condition;

Sort the Result Set in Ascending or Descending Order

SELECT c1, c2 FROM t

ORDER BY c1 ASC [DESC];

Skip Offset of Rows and Return the Next n Rows

SELECT c1, c2 FROM t
ORDER BY c1
LIMIT n OFFSET offset;

Group Rows using an Aggregate Function

SELECT c1, aggregate(c2)
FROM t
GROUP BY c1;

Filter Groups using Having Clause

SELECT c1, aggregate(c2)
FROM t
GROUP BY c1
HAVING condition;

Modifying Data

Insert One Row into a Table

INSERT INTO t(column_list)
VALUES(value_list);

Insert Multiple Rows into a Table

INSERT INTO t(column_list)

VALUES (value_list),
(value_list), …;

Insert Rows from t2 into t1

INSERT INTO t1(column_list)
SELECT column_list
FROM t2;

Update New Value in the Column c1 for All Rows

UPDATE t
SET c1 = new_value;

Update Values in the Column c1, c2 that Match the Condition

UPDATE t
SET c1 = new_value,
c2 = new_value
WHERE condition;

Delete All Data in a Table

DELETE FROM t;

Delete Subset of Rows in a Table

DELETE FROM t
WHERE condition;

Table Management

Create a new Table with Three Columns

CREATE TABLE t (
  id INT PRIMARY KEY,
  name VARCHAR NOT NULL,
  price INT DEFAULT 0
);

Delete the Table from the Database

DROP TABLE t ;

Add a new Column to the Table

ALTER TABLE t ADD column;

Drop Column c from the Table

ALTER TABLE t DROP COLUMN c ;

Add a Constraint

ALTER TABLE t ADD constraint;

Drop a Constraint

ALTER TABLE t DROP constraint;

Rename a Table from t1 to t2

ALTER TABLE t1 RENAME TO t2;

Rename Column c1 to c2

ALTER TABLE t1 RENAME c1 TO c2 ;

Remove all Data in a Table

TRUNCATE TABLE t;

Example Document

{
  "foo": "bar",
  "array": [
  "foo",
  "bar"
  ]
}

All JSON files are surrounded by { and }, which means it is a object. Unlike Javascript, you must use double quotes (") for strings, not singular quotes (')

Importing JSON

fetch('example.json')

import('./example.json')

import data from 'example.json'

import 'json'; with open('data.json', 'r') as f: data = json.load(f)