CSE330 Wiki - User contributions [en]

Module 6

2018-05-04T16:19:35Z

Alex: /* Group Project */

__NOTOC__
Module 6 builds upon the JavaScript skills you learned in Module 5.

== Reading ==

The following articles on the online class wiki textbook contain information that will help you complete the assignments.

* [[Node.JS]]
* [[Socket.IO]]

== Individual Assignments ==

=== Install Node.JS ===

Install Node.JS from Apt or Yum according to the instructions in the [[Node.JS]] guide.

=== Static File Server in Node.JS ===

The individual portion of Module 6 is short in order to give you enough time to complete the group portion.

# Copy the example code from the Node.JS guide into a file called ''static_server.js'' or something of that nature. Save it on your EC2 instance (but not in a place that Apache can serve!).
#: Ensure that you understand what the static file server script is doing…
# Make a directory parallel to ''static_server.js'' named ''static''.
# Change "<STATIC DIRECTORY NAME>" on line 11 of the static fileserver example code to reflect the name of the directory you just made.
# Save the following files in your ''static'' directory:
#* ''hello.txt'', a text file containing "Hello World"
#* ''brookings.jpg'', an image file you can download from here: http://classes.engineering.wustl.edu/cse330/content/brookings.jpg
#* ''college.html'', an HTML document based on the [[HTML and CSS#Quick and Easy Page Layout|Quick and Easy HTML Layout]] containing an image tag pointing to ''brookings.jpg''
#* ''phpinfo.php'', a PHP file containing the phpinfo command that generates a diagnostic page of the server:
#: <source lang="php"><?php phpinfo(); ?></source>
# Boot up your Node.JS static fileserver, and from your browser, load all four of the files you created in step 4.
#: Which ones work and which ones don't? Why might this be the case?

== Group Project ==

In the group portion of Module 6 you will create a multi-room chat server using Node.JS and Socket.IO. This project must be completed using Node.JS.

This chat service will contain a main lobby where users sign on with a nickname and can communicate with each other. Users may also create chat rooms for other to join. The entire app should be displayed on a single webpage, listing the room you are in, all available rooms, and the users in the current room.

The single room chat server and client are provided here: [[Socket.IO]]

== Grading ==

We will be grading the following aspects of your work. There are 75 points total.

'''Assignments (including code) must be committed to Bitbucket by the end of class on the due date (commit early and often). Failing to commit by the end of class on the due date will result in a 0. '''

_________

# '''Individual Portion (25 Points):'''
#* Node.JS is installed on your EC2 instance (5 points)
#*: ''Take a screenshot of your browser visiting your EC2 instance serving up the college.html web page on port 3456, make sure the URL is visible in the screenshot.''
#* The ''hello.txt'', ''brookings.jpg'', and ''college.html'' files all load successfully (4 points each)
#* Visiting a file that does not exist inside the ''static'' directory results in a 404 (4 points)
#* Discuss in the README.md why ''phpinfo.php'' behaves the way it does when loaded through Node.JS (4 points)
#* Make sure all of your individual portion files are pushed to Bitbucket (include your node.js file, hello.txt, brookings.jpg, college.html, and phpinfo.php)
#*: ''The TA should be able to simply download your repo and start up your file server, without having to copy files or create additional subdirectories''
# '''Multi-room Chat Server (50 Points):'''
#* '''''Administration of user created chat rooms (25 Points):'''''
#** Users can create chat rooms with an arbitrary room name(5 points)
#** Users can join an arbitrary chat room (5 points)
#** The chat room displays all users currently in the room (5 points)
#** A private room can be created that is password protected (5 points)
#** Creators of chat rooms can temporarily kick others out of the room (3 points)
#** Creators of chat rooms can permanently ban users from joining that particular room (2 points)
#* '''''Messaging (5 Points):'''''
#** A user's message shows their username and is sent to everyone in the room (1 point)
#** Users can send private messages to another user in the same room (4 points)
#* '''''Best Practices (5 Points):'''''
#** Code is well formatted and easy to read, with proper commenting (2 points)
#** Code passes HTML validation (2 points)
#** node_modules folder is ignored by version control (1 points)
#* '''''Usability (5 Points):'''''
#** Communicating with others and joining rooms is easy and intuitive (4 points)
#** Site is visually appealing (1 point)
#* '''Creative Portion (10 Points)'''


[[Category:Module 6]]
[[Category:Modules]]

AJAX and JSON

2018-04-30T21:42:46Z

Alex: /* Logging In a User */

Asynchronous Javascript And XML, or '''''AJAX''''', is a group of related web development techniques, standards, and technologies used on the client (web browser) side of the standard web server-client communication model.

Here's the general concept: JavaScript is used to send requests to the web server in the background and retrieve data, without the need to refresh the page. The result: dynamic, fast, user-friendly web pages.

The requests are performed ''asynchronously'': this means that the end user can continue interacting with your web page while the server data is being loaded.

The key idea is that a large fraction of the work happens at the web browser, and larger requests happen behind the scenes, keeping waiting times for data to come back over the network to a minimum. AJAX is generally also associated with higher-level APIs and libraries that aid in producing cleaner user interfaces for web applications.

== The XMLHttpRequest Object ==

The JavaScript specification defines the '''XMLHttpRequest''' object (sometimes abbreviated as '''XHR'''), which is used to exchange data with the web servers without needing to reload the entire web page in the browser.

=== Initializing an XMLHttpRequest Object ===

As stated above, the XMLHttpRequest object handles communication with the web servers. To use it, you must first initialize a variable to be an instance of the '''XMLHttpRequest''' "class".

<source lang="javascript">
var xmlHttp = new XMLHttpRequest();
</source>

Next, use your XMLHttpRequest instance to open a connection to your server.

<source lang="javascript">
xmlHttp.open("METHOD", "URL_OF_SERVER_SCRIPT", ASYNCRONOUS_FLAG);
// METHOD: either GET or POST.
// URL_OF_SERVER_SCRIPT: the path to your server-side script relative to the current page. For example, process_ajax.php
// ASYNCRONOUS_FLAG: Should be true in order to perform the request asynchronously. (Having a value of false will freeze the browser until the request is completed.)
</source>

{{DoctypeTV
|youtube_id=isrqZQPE2eQ
|time=3m51s
|desc=Explaining the Cross-Site Policy in AJAX
}}

'''Note:''' For security reasons, you cannot perform AJAX requests to other domains, unless that domain has a special security policy set up to enable such requests.

=== Sending Data ===

==== GET Data ====

To send GET data, append the information to the end of the URL_OF_SERVER_SCRIPT, as you would normally do, and then call xmlHttp.send(), passing ''null'' as the parameter:

<source lang="javascript">
var xmlHttp = new XMLHttpRequest();
xmlHttp.open("GET", "process_ajax.php?var1=val1&var2=val2", true);
xmlHttp.send(null);
</source>

==== POST Data ====

To send POST data, pass a URL-encoded string to xmlHttp.send(). You also need to change the MIME Type of the outgoing request.

<source lang="javascript">
var xmlHttp = new XMLHttpRequest();
xmlHttp.open("POST", "process_ajax.php", true);
xmlHttp.setRequestHeader("Content-Type", "application/x-www-form-urlencoded");
xmlHttp.send("var1=val1&var2=val2");
</source>

=== Listening for a Response ===

XMLHttpRequest will fire an [[JavaScript#Events|event]] when the request has been completed. We therefore need to use a '''[[JavaScript#Events|callback function]]''' in order to listen for the '''load''' event on the XMLHttpRequest object.

The server's plain text response is available as the '''responseText''' property of your XMLHttpRequest instance, which is available in the '''target''' property of the event. For example:

<source lang="javascript">
var xmlHttp = new XMLHttpRequest();
xmlHttp.open("GET", "hello.txt", true);
xmlHttp.addEventListener("load", ajaxCallback, false);
xmlHttp.send(null);

// ...

function ajaxCallback(event){
alert( "Your file contains the text: " + event.target.responseText );
}
</source>

==== Browser Support ====

Many examples that you find when Googling for "AJAX" use the '''onreadystatechange''' property of the XMLHttpRequest instance to react on the completion of the request, rather than using an event listener. This approach works, and it is required for comprehensive browser support, but it is no longer recommended for future use in modern web applications. The implementation of XMLHttpRequest documented here (so-called "XHR level 2") works in the following browsers:
* Firefox 3.5+ (Jun 2009)
* Safari 5+ (Jun 2010)
* Chrome 7+ (Sep 2010)
* Opera 12+ (May 2012)
* Internet Explorer 10+ (unreleased)
Together, browsers supporting XHR level 2 account [http://caniuse.com/xhr2 77% of the market] as of August 2013.

=== Response Formats ===

More often than not, a plaintext response form the server is not very helpful: you want to transmit more information than simply a single string of text. There are two good options to get more information from a single AJAX request: '''XML''' (the original format, thus the ''X'' in ''AJAX'') and '''JSON'''.

==== XML ====

Your server can respond with an XML document (whence, ''XMLHttpRequest''). An '''XML document''' uses syntax that is extremely close to HTML For example:

<source lang="xml">
<?xml version="1.0" standalone="yes" ?>
<note>
<date year="2013" month="02" day="14" />
<to>Sally</to>
<message>Happy Valentine's Day!</message>
<from>Your Secret Admirer</from>
</note>
</source>

Like HTML, XML has a DOM that can be traversed in JavaScript.

If you make an AJAX request to a script generating an XML document, the root XML node is accessible in the '''responseXML''' property.

<source lang="javascript">
function ajaxCallback(event){
var xmlDocument = event.target.responseXML;

alert(xmlDocument.getElementsByTagName("to")[0].textContent); // Sally (in the case of the example XML above)
}
</source>

==== JSON ====

JavaScript Object Notation, or '''JSON''', is a rising standard interface format because of its lightweight syntax that makes it especially useful for AJAX requests.

The JSON syntax closely follows the syntax for [[JavaScript#Object Literals|object literals]]. For example:

<source lang="javascript">
{
"apple": {
"color": "red",
"flavor": "sweet"
},
"lemon": {
"color": "yellow",
"flavor": "sour"
}
}
</source>

Usually when JSON is transferred over the internet, it is condensed down to one line, like this:

<source lang="javascript">
{"apple":{"color":"red","flavor":"sweet"},"lemon":{"color":"yellow","flavor":"sour"}}
</source>

In JavaScript, you can convert a JSON string to an object using '''JSON.parse()'''. For example:

<source lang="javascript">
var jsonData = JSON.parse('{"apple":{"color":"red","flavor":"sweet"},"lemon":{"color":"yellow","flavor":"sour"}}');

alert(jsonData.apple.color); // red
</source>

Here's how to use it in conjunction with your AJAX response callback:

<source lang="javascript">
function ajaxCallback(event){
var jsonData = JSON.parse(event.target.responseText);

alert(jsonData.lemon.flavor); // sour (in the case of the example JSON above)
}
</source>

Here is a graphic to illustrate the JSON process.

[[File:JSON-Flowchart.png‎]]

== Examples ==

=== Logging In a User ===

Suppose you had the following PHP script:

<source lang="php">
<?php
// login_ajax.php

header("Content-Type: application/json"); // Since we are sending a JSON response here (not an HTML document), set the MIME Type to application/json

$username = $_POST['username'];
$password = $_POST['password'];

// Check to see if the username and password are valid. (You learned how to do this in Module 3.)

if( /* valid username and password */ ){
session_start();
$_SESSION['username'] = $username;
$_SESSION['token'] = bin2hex(openssl_random_pseudo_bytes(32));

echo json_encode(array(
"success" => true
));
exit;
}else{
echo json_encode(array(
"success" => false,
"message" => "Incorrect Username or Password"
));
exit;
}
?>
</source>

'''Note:''' This example uses PHP's very handy '''json_encode()''' function to translate an associative array into a JSON object. This means that you can access in JavaScript the same structure that you made in PHP!

And suppose you had the following HTML content:

<source lang="html4strict">
<input type="text" id="username" placeholder="Username" />
<input type="password" id="password" placeholder="Password" />
<button id="login_btn">Log In</button>

<script type="text/javascript" src="ajax.js"></script> 
</source>

You could use the following JavaScript code to prepare, send, and receive a request from the server to see if the user is logged in, without ever having to refresh the page.

<source lang="javascript">
// ajax.js

function loginAjax(event) {
const username = document.getElementById("username").value; // Get the username from the form
const password = document.getElementById("password").value; // Get the password from the form

// Make a URL-encoded string for passing POST data:
const data = { 'username': username, 'password': password };

fetch("login_ajax.php", {
body: JSON.stringify(data),
headers: { 'content-type': 'application/json' },
method: 'POST'
})
.then(response => response.json())
.then(data => console.log(data.success ? "You've been logged in!" : `You were not logged in ${data.message}`));
}

document.getElementById("login_btn").addEventListener("click", loginAjax, false); // Bind the AJAX call to button click
</source>

'''Note:''' The above example uses an '''anonymous function''' (a function without a name that is declared in an attribute) as the callback. If you are using a certain callback function only once in your program, this is a perfectly valid approach to reduce the amount of code you need to write.

=== Loading Data from an XML File for Display in HTML ===

Suppose you have a file '''note.xml''' that contains the following information:

<source lang="xml">
<?xml version="1.0" standalone="yes" ?>
<note>
<date year="2013" month="02" day="14" />
<to>Sally</to>
<message>Happy Valentine's Day!</message>
<from>Your Secret Admirer</from>
</note>
</source>

Further, suppose you had an HTML element with ID '''note''':

<source lang="html4strict">
<div id="note"></div>
</source>

You could load this XML file and then display it inside of your HTML document like this:

<source lang="javascript">
function getNoteAjax(event){
// The XMLHttpRequest is simple this time:
var xmlHttp = new XMLHttpRequest();
xmlHttp.open("GET", "note.xml", true);
xmlHttp.addEventListener("load", getNoteCallback, false);
xmlHttp.send(null);
}

function getNoteCallback(event){
var htmlParent = document.getElementById("note"); // Get the HTML element into which we want to write the note
var xmlDocument = event.target.responseXML; // Get the XML root node from the response

// Find the <date/> element from the XML response. We expect only 1 such element, so we can call
// xmlDocument.getElementsByTagName() and then get the first (and only) element in the array all in
// one step. This is called chaining.
var xmlDateElement = xmlDocument.getElementsByTagName("date")[0];

// Put together a YYYY-MM-DD type date into a string based on the attributes of the <date/> element.
var dateString = xmlDateElement.getAttribute("year") + "-" + xmlDateElement.getAttribute("month")
+ "-" + xmlDateElement.getAttribute("day");

// Get the content of the <to>, <message>, and <from> tags. Again, you can use a chain to do this in one line for each.
var to = xmlDocument.getElementsByTagName("to")[0].textContent;
var message = xmlDocument.getElementsByTagName("message")[0].textContent;
var from = xmlDocument.getElementsByTagName("from")[0].textContent;

// Make a <strong> tag, append the date string as its content, and then append it to the HTML element.
var htmlDateObj = document.createElement("strong");
htmlDateObj.appendChild(document.createTextNode(dateString));
htmlParent.appendChild(htmlDateObj);

// Make a <p> tag to contain the note.
var htmlParagraphObj = document.createElement("p");
htmlParagraphObj.appendChild(document.createTextNode("Dear "+to+",")); // First append the greeting
htmlParagraphObj.appendChild(document.createElement("br")); // Append a couple line feeds
htmlParagraphObj.appendChild(document.createElement("br"));
htmlParagraphObj.appendChild(document.createTextNode(message)); // Write the message itself
htmlParagraphObj.appendChild(document.createElement("br")); // Append a couple more line feeds
htmlParagraphObj.appendChild(document.createElement("br"));
htmlParagraphObj.appendChild(document.createTextNode("Love, "+from)); // Finally, append the salutation
htmlParent.appendChild(htmlParagraphObj); // Append the newly engineered <p> to the HTML element.
}

document.addEventListener("DOMContentLoaded", getNoteAjax, false); // Bind the AJAX call to page load
</source>

This example uses a lot of techniques documented in the [[JavaScript#Document Object Model]] section above. The resulting DOM will be something like this:

<source lang="html4strict">
<div id="note">
<strong>2013-02-14</strong>
<p>Dear Sally,<br /><br />Happy Valentine's Day!<br /><br />Love, Your Secret Admirer</p>
</div>
</source>

If you think that this is a lot of code to produce a relatively simple output, you are not alone. You will learn how to do this job in much fewer lines when you learn about [[Ext JS]].

== Debugging AJAX and JSON ==

It is helpful when building your application to look at the AJAX requests and responses as they happen in real time. Fortunately, there are many tools to help.

In your favorite web inspector (Chrome Dev Tools, Mozilla Dev Tools, Firebug, Dragonfly, and so on), go to the "Network" tab. This is where you can see all assets loaded by the application: images, stylesheets, and, most importantly for us, AJAX files. Some inspectors let you filter requests by type; for example, the Chrome inspector lets you click "XHR" to only show XMLHttpRequest (AJAX) requests.

You can also view the JSON sent by your server. Double-clicking the entries in the web inspector opens the source URL in a new tab.

If you find minified JSON hard to read, we recommend that you install the JSONView browser extension or one of its close relatives:
* [https://addons.mozilla.org/en-us/firefox/addon/jsonview/ Firefox]
* [https://chrome.google.com/webstore/detail/jsonview/chklaanhfefbnpoihckbnefhakgolnmc?hl=en Chrome]
* [https://addons.opera.com/en/extensions/details/jsonviewer/ Opera]
* [https://github.com/rfletcher/safari-json-formatter Safari]

[[Category:Module 6]]

AJAX and JSON

2018-04-30T21:41:03Z

Alex: /* Examples */

Asynchronous Javascript And XML, or '''''AJAX''''', is a group of related web development techniques, standards, and technologies used on the client (web browser) side of the standard web server-client communication model.

Here's the general concept: JavaScript is used to send requests to the web server in the background and retrieve data, without the need to refresh the page. The result: dynamic, fast, user-friendly web pages.

The requests are performed ''asynchronously'': this means that the end user can continue interacting with your web page while the server data is being loaded.

The key idea is that a large fraction of the work happens at the web browser, and larger requests happen behind the scenes, keeping waiting times for data to come back over the network to a minimum. AJAX is generally also associated with higher-level APIs and libraries that aid in producing cleaner user interfaces for web applications.

== The XMLHttpRequest Object ==

The JavaScript specification defines the '''XMLHttpRequest''' object (sometimes abbreviated as '''XHR'''), which is used to exchange data with the web servers without needing to reload the entire web page in the browser.

=== Initializing an XMLHttpRequest Object ===

As stated above, the XMLHttpRequest object handles communication with the web servers. To use it, you must first initialize a variable to be an instance of the '''XMLHttpRequest''' "class".

<source lang="javascript">
var xmlHttp = new XMLHttpRequest();
</source>

Next, use your XMLHttpRequest instance to open a connection to your server.

<source lang="javascript">
xmlHttp.open("METHOD", "URL_OF_SERVER_SCRIPT", ASYNCRONOUS_FLAG);
// METHOD: either GET or POST.
// URL_OF_SERVER_SCRIPT: the path to your server-side script relative to the current page. For example, process_ajax.php
// ASYNCRONOUS_FLAG: Should be true in order to perform the request asynchronously. (Having a value of false will freeze the browser until the request is completed.)
</source>

{{DoctypeTV
|youtube_id=isrqZQPE2eQ
|time=3m51s
|desc=Explaining the Cross-Site Policy in AJAX
}}

'''Note:''' For security reasons, you cannot perform AJAX requests to other domains, unless that domain has a special security policy set up to enable such requests.

=== Sending Data ===

==== GET Data ====

To send GET data, append the information to the end of the URL_OF_SERVER_SCRIPT, as you would normally do, and then call xmlHttp.send(), passing ''null'' as the parameter:

<source lang="javascript">
var xmlHttp = new XMLHttpRequest();
xmlHttp.open("GET", "process_ajax.php?var1=val1&var2=val2", true);
xmlHttp.send(null);
</source>

==== POST Data ====

To send POST data, pass a URL-encoded string to xmlHttp.send(). You also need to change the MIME Type of the outgoing request.

<source lang="javascript">
var xmlHttp = new XMLHttpRequest();
xmlHttp.open("POST", "process_ajax.php", true);
xmlHttp.setRequestHeader("Content-Type", "application/x-www-form-urlencoded");
xmlHttp.send("var1=val1&var2=val2");
</source>

=== Listening for a Response ===

XMLHttpRequest will fire an [[JavaScript#Events|event]] when the request has been completed. We therefore need to use a '''[[JavaScript#Events|callback function]]''' in order to listen for the '''load''' event on the XMLHttpRequest object.

The server's plain text response is available as the '''responseText''' property of your XMLHttpRequest instance, which is available in the '''target''' property of the event. For example:

<source lang="javascript">
var xmlHttp = new XMLHttpRequest();
xmlHttp.open("GET", "hello.txt", true);
xmlHttp.addEventListener("load", ajaxCallback, false);
xmlHttp.send(null);

// ...

function ajaxCallback(event){
alert( "Your file contains the text: " + event.target.responseText );
}
</source>

==== Browser Support ====

Many examples that you find when Googling for "AJAX" use the '''onreadystatechange''' property of the XMLHttpRequest instance to react on the completion of the request, rather than using an event listener. This approach works, and it is required for comprehensive browser support, but it is no longer recommended for future use in modern web applications. The implementation of XMLHttpRequest documented here (so-called "XHR level 2") works in the following browsers:
* Firefox 3.5+ (Jun 2009)
* Safari 5+ (Jun 2010)
* Chrome 7+ (Sep 2010)
* Opera 12+ (May 2012)
* Internet Explorer 10+ (unreleased)
Together, browsers supporting XHR level 2 account [http://caniuse.com/xhr2 77% of the market] as of August 2013.

=== Response Formats ===

More often than not, a plaintext response form the server is not very helpful: you want to transmit more information than simply a single string of text. There are two good options to get more information from a single AJAX request: '''XML''' (the original format, thus the ''X'' in ''AJAX'') and '''JSON'''.

==== XML ====

Your server can respond with an XML document (whence, ''XMLHttpRequest''). An '''XML document''' uses syntax that is extremely close to HTML For example:

<source lang="xml">
<?xml version="1.0" standalone="yes" ?>
<note>
<date year="2013" month="02" day="14" />
<to>Sally</to>
<message>Happy Valentine's Day!</message>
<from>Your Secret Admirer</from>
</note>
</source>

Like HTML, XML has a DOM that can be traversed in JavaScript.

If you make an AJAX request to a script generating an XML document, the root XML node is accessible in the '''responseXML''' property.

<source lang="javascript">
function ajaxCallback(event){
var xmlDocument = event.target.responseXML;

alert(xmlDocument.getElementsByTagName("to")[0].textContent); // Sally (in the case of the example XML above)
}
</source>

==== JSON ====

JavaScript Object Notation, or '''JSON''', is a rising standard interface format because of its lightweight syntax that makes it especially useful for AJAX requests.

The JSON syntax closely follows the syntax for [[JavaScript#Object Literals|object literals]]. For example:

<source lang="javascript">
{
"apple": {
"color": "red",
"flavor": "sweet"
},
"lemon": {
"color": "yellow",
"flavor": "sour"
}
}
</source>

Usually when JSON is transferred over the internet, it is condensed down to one line, like this:

<source lang="javascript">
{"apple":{"color":"red","flavor":"sweet"},"lemon":{"color":"yellow","flavor":"sour"}}
</source>

In JavaScript, you can convert a JSON string to an object using '''JSON.parse()'''. For example:

<source lang="javascript">
var jsonData = JSON.parse('{"apple":{"color":"red","flavor":"sweet"},"lemon":{"color":"yellow","flavor":"sour"}}');

alert(jsonData.apple.color); // red
</source>

Here's how to use it in conjunction with your AJAX response callback:

<source lang="javascript">
function ajaxCallback(event){
var jsonData = JSON.parse(event.target.responseText);

alert(jsonData.lemon.flavor); // sour (in the case of the example JSON above)
}
</source>

Here is a graphic to illustrate the JSON process.

[[File:JSON-Flowchart.png‎]]

== Examples ==

=== Logging In a User ===

Suppose you had the following PHP script:

<source lang="php">
<?php
// login_ajax.php

header("Content-Type: application/json"); // Since we are sending a JSON response here (not an HTML document), set the MIME Type to application/json

$username = $_POST['username'];
$password = $_POST['password'];

// Check to see if the username and password are valid. (You learned how to do this in Module 3.)

if( /* valid username and password */ ){
session_start();
$_SESSION['username'] = $username;
$_SESSION['token'] = bin2hex(openssl_random_pseudo_bytes(32));

echo json_encode(array(
"success" => true
));
exit;
}else{
echo json_encode(array(
"success" => false,
"message" => "Incorrect Username or Password"
));
exit;
}
?>
</source>

'''Note:''' This example uses PHP's very handy '''json_encode()''' function to translate an associative array into a JSON object. This means that you can access in JavaScript the same structure that you made in PHP!

And suppose you had the following HTML content:

<source lang="html4strict">
<input type="text" id="username" placeholder="Username" />
<input type="password" id="password" placeholder="Password" />
<button id="login_btn">Log In</button>

<script type="text/javascript" src="ajax.js"></script> 
</source>

You could use the following JavaScript code to prepare, send, and receive a request from the server to see if the user is logged in, without ever having to refresh the page.

<source lang="javascript">
// ajax.js

function loginAjax(event) {
const username = document.getElementById("username").value; // Get the username from the form
const password = document.getElementById("password").value; // Get the password from the form

// Make a URL-encoded string for passing POST data:
const data = { username: username, password: password };

fetch("login_ajax.php", {
body: JSON.stringify(data),
headers: {
'content-type': 'application/json'
},
method: 'POST'
})
.then(response => response.json())
.then(data => console.log(data.success ? "You've been logged in!" : `You were not logged in ${data.message}`)

}
}

document.getElementById("login_btn").addEventListener("click", loginAjax, false); // Bind the AJAX call to button click
</source>

'''Note:''' The above example uses an '''anonymous function''' (a function without a name that is declared in an attribute) as the callback. If you are using a certain callback function only once in your program, this is a perfectly valid approach to reduce the amount of code you need to write.

=== Loading Data from an XML File for Display in HTML ===

Suppose you have a file '''note.xml''' that contains the following information:

<source lang="xml">
<?xml version="1.0" standalone="yes" ?>
<note>
<date year="2013" month="02" day="14" />
<to>Sally</to>
<message>Happy Valentine's Day!</message>
<from>Your Secret Admirer</from>
</note>
</source>

Further, suppose you had an HTML element with ID '''note''':

<source lang="html4strict">
<div id="note"></div>
</source>

You could load this XML file and then display it inside of your HTML document like this:

<source lang="javascript">
function getNoteAjax(event){
// The XMLHttpRequest is simple this time:
var xmlHttp = new XMLHttpRequest();
xmlHttp.open("GET", "note.xml", true);
xmlHttp.addEventListener("load", getNoteCallback, false);
xmlHttp.send(null);
}

function getNoteCallback(event){
var htmlParent = document.getElementById("note"); // Get the HTML element into which we want to write the note
var xmlDocument = event.target.responseXML; // Get the XML root node from the response

// Find the <date/> element from the XML response. We expect only 1 such element, so we can call
// xmlDocument.getElementsByTagName() and then get the first (and only) element in the array all in
// one step. This is called chaining.
var xmlDateElement = xmlDocument.getElementsByTagName("date")[0];

// Put together a YYYY-MM-DD type date into a string based on the attributes of the <date/> element.
var dateString = xmlDateElement.getAttribute("year") + "-" + xmlDateElement.getAttribute("month")
+ "-" + xmlDateElement.getAttribute("day");

// Get the content of the <to>, <message>, and <from> tags. Again, you can use a chain to do this in one line for each.
var to = xmlDocument.getElementsByTagName("to")[0].textContent;
var message = xmlDocument.getElementsByTagName("message")[0].textContent;
var from = xmlDocument.getElementsByTagName("from")[0].textContent;

// Make a <strong> tag, append the date string as its content, and then append it to the HTML element.
var htmlDateObj = document.createElement("strong");
htmlDateObj.appendChild(document.createTextNode(dateString));
htmlParent.appendChild(htmlDateObj);

// Make a <p> tag to contain the note.
var htmlParagraphObj = document.createElement("p");
htmlParagraphObj.appendChild(document.createTextNode("Dear "+to+",")); // First append the greeting
htmlParagraphObj.appendChild(document.createElement("br")); // Append a couple line feeds
htmlParagraphObj.appendChild(document.createElement("br"));
htmlParagraphObj.appendChild(document.createTextNode(message)); // Write the message itself
htmlParagraphObj.appendChild(document.createElement("br")); // Append a couple more line feeds
htmlParagraphObj.appendChild(document.createElement("br"));
htmlParagraphObj.appendChild(document.createTextNode("Love, "+from)); // Finally, append the salutation
htmlParent.appendChild(htmlParagraphObj); // Append the newly engineered <p> to the HTML element.
}

document.addEventListener("DOMContentLoaded", getNoteAjax, false); // Bind the AJAX call to page load
</source>

This example uses a lot of techniques documented in the [[JavaScript#Document Object Model]] section above. The resulting DOM will be something like this:

<source lang="html4strict">
<div id="note">
<strong>2013-02-14</strong>
<p>Dear Sally,<br /><br />Happy Valentine's Day!<br /><br />Love, Your Secret Admirer</p>
</div>
</source>

If you think that this is a lot of code to produce a relatively simple output, you are not alone. You will learn how to do this job in much fewer lines when you learn about [[Ext JS]].

== Debugging AJAX and JSON ==

It is helpful when building your application to look at the AJAX requests and responses as they happen in real time. Fortunately, there are many tools to help.

In your favorite web inspector (Chrome Dev Tools, Mozilla Dev Tools, Firebug, Dragonfly, and so on), go to the "Network" tab. This is where you can see all assets loaded by the application: images, stylesheets, and, most importantly for us, AJAX files. Some inspectors let you filter requests by type; for example, the Chrome inspector lets you click "XHR" to only show XMLHttpRequest (AJAX) requests.

You can also view the JSON sent by your server. Double-clicking the entries in the web inspector opens the source URL in a new tab.

If you find minified JSON hard to read, we recommend that you install the JSONView browser extension or one of its close relatives:
* [https://addons.mozilla.org/en-us/firefox/addon/jsonview/ Firefox]
* [https://chrome.google.com/webstore/detail/jsonview/chklaanhfefbnpoihckbnefhakgolnmc?hl=en Chrome]
* [https://addons.opera.com/en/extensions/details/jsonviewer/ Opera]
* [https://github.com/rfletcher/safari-json-formatter Safari]

[[Category:Module 6]]

AJAX and JSON

2018-04-30T21:38:01Z

Alex: /* Logging In a User */ Added fetch

Asynchronous Javascript And XML, or '''''AJAX''''', is a group of related web development techniques, standards, and technologies used on the client (web browser) side of the standard web server-client communication model.

Here's the general concept: JavaScript is used to send requests to the web server in the background and retrieve data, without the need to refresh the page. The result: dynamic, fast, user-friendly web pages.

The requests are performed ''asynchronously'': this means that the end user can continue interacting with your web page while the server data is being loaded.

The key idea is that a large fraction of the work happens at the web browser, and larger requests happen behind the scenes, keeping waiting times for data to come back over the network to a minimum. AJAX is generally also associated with higher-level APIs and libraries that aid in producing cleaner user interfaces for web applications.

== The XMLHttpRequest Object ==

The JavaScript specification defines the '''XMLHttpRequest''' object (sometimes abbreviated as '''XHR'''), which is used to exchange data with the web servers without needing to reload the entire web page in the browser.

=== Initializing an XMLHttpRequest Object ===

As stated above, the XMLHttpRequest object handles communication with the web servers. To use it, you must first initialize a variable to be an instance of the '''XMLHttpRequest''' "class".

<source lang="javascript">
var xmlHttp = new XMLHttpRequest();
</source>

Next, use your XMLHttpRequest instance to open a connection to your server.

<source lang="javascript">
xmlHttp.open("METHOD", "URL_OF_SERVER_SCRIPT", ASYNCRONOUS_FLAG);
// METHOD: either GET or POST.
// URL_OF_SERVER_SCRIPT: the path to your server-side script relative to the current page. For example, process_ajax.php
// ASYNCRONOUS_FLAG: Should be true in order to perform the request asynchronously. (Having a value of false will freeze the browser until the request is completed.)
</source>

{{DoctypeTV
|youtube_id=isrqZQPE2eQ
|time=3m51s
|desc=Explaining the Cross-Site Policy in AJAX
}}

'''Note:''' For security reasons, you cannot perform AJAX requests to other domains, unless that domain has a special security policy set up to enable such requests.

=== Sending Data ===

==== GET Data ====

To send GET data, append the information to the end of the URL_OF_SERVER_SCRIPT, as you would normally do, and then call xmlHttp.send(), passing ''null'' as the parameter:

<source lang="javascript">
var xmlHttp = new XMLHttpRequest();
xmlHttp.open("GET", "process_ajax.php?var1=val1&var2=val2", true);
xmlHttp.send(null);
</source>

==== POST Data ====

To send POST data, pass a URL-encoded string to xmlHttp.send(). You also need to change the MIME Type of the outgoing request.

<source lang="javascript">
var xmlHttp = new XMLHttpRequest();
xmlHttp.open("POST", "process_ajax.php", true);
xmlHttp.setRequestHeader("Content-Type", "application/x-www-form-urlencoded");
xmlHttp.send("var1=val1&var2=val2");
</source>

=== Listening for a Response ===

XMLHttpRequest will fire an [[JavaScript#Events|event]] when the request has been completed. We therefore need to use a '''[[JavaScript#Events|callback function]]''' in order to listen for the '''load''' event on the XMLHttpRequest object.

The server's plain text response is available as the '''responseText''' property of your XMLHttpRequest instance, which is available in the '''target''' property of the event. For example:

<source lang="javascript">
var xmlHttp = new XMLHttpRequest();
xmlHttp.open("GET", "hello.txt", true);
xmlHttp.addEventListener("load", ajaxCallback, false);
xmlHttp.send(null);

// ...

function ajaxCallback(event){
alert( "Your file contains the text: " + event.target.responseText );
}
</source>

==== Browser Support ====

Many examples that you find when Googling for "AJAX" use the '''onreadystatechange''' property of the XMLHttpRequest instance to react on the completion of the request, rather than using an event listener. This approach works, and it is required for comprehensive browser support, but it is no longer recommended for future use in modern web applications. The implementation of XMLHttpRequest documented here (so-called "XHR level 2") works in the following browsers:
* Firefox 3.5+ (Jun 2009)
* Safari 5+ (Jun 2010)
* Chrome 7+ (Sep 2010)
* Opera 12+ (May 2012)
* Internet Explorer 10+ (unreleased)
Together, browsers supporting XHR level 2 account [http://caniuse.com/xhr2 77% of the market] as of August 2013.

=== Response Formats ===

More often than not, a plaintext response form the server is not very helpful: you want to transmit more information than simply a single string of text. There are two good options to get more information from a single AJAX request: '''XML''' (the original format, thus the ''X'' in ''AJAX'') and '''JSON'''.

==== XML ====

Your server can respond with an XML document (whence, ''XMLHttpRequest''). An '''XML document''' uses syntax that is extremely close to HTML For example:

<source lang="xml">
<?xml version="1.0" standalone="yes" ?>
<note>
<date year="2013" month="02" day="14" />
<to>Sally</to>
<message>Happy Valentine's Day!</message>
<from>Your Secret Admirer</from>
</note>
</source>

Like HTML, XML has a DOM that can be traversed in JavaScript.

If you make an AJAX request to a script generating an XML document, the root XML node is accessible in the '''responseXML''' property.

<source lang="javascript">
function ajaxCallback(event){
var xmlDocument = event.target.responseXML;

alert(xmlDocument.getElementsByTagName("to")[0].textContent); // Sally (in the case of the example XML above)
}
</source>

==== JSON ====

JavaScript Object Notation, or '''JSON''', is a rising standard interface format because of its lightweight syntax that makes it especially useful for AJAX requests.

The JSON syntax closely follows the syntax for [[JavaScript#Object Literals|object literals]]. For example:

<source lang="javascript">
{
"apple": {
"color": "red",
"flavor": "sweet"
},
"lemon": {
"color": "yellow",
"flavor": "sour"
}
}
</source>

Usually when JSON is transferred over the internet, it is condensed down to one line, like this:

<source lang="javascript">
{"apple":{"color":"red","flavor":"sweet"},"lemon":{"color":"yellow","flavor":"sour"}}
</source>

In JavaScript, you can convert a JSON string to an object using '''JSON.parse()'''. For example:

<source lang="javascript">
var jsonData = JSON.parse('{"apple":{"color":"red","flavor":"sweet"},"lemon":{"color":"yellow","flavor":"sour"}}');

alert(jsonData.apple.color); // red
</source>

Here's how to use it in conjunction with your AJAX response callback:

<source lang="javascript">
function ajaxCallback(event){
var jsonData = JSON.parse(event.target.responseText);

alert(jsonData.lemon.flavor); // sour (in the case of the example JSON above)
}
</source>

Here is a graphic to illustrate the JSON process.

[[File:JSON-Flowchart.png‎]]

== Examples ==

=== Logging In a User ===

Suppose you had the following PHP script:

<source lang="php">
<?php
// login_ajax.php

header("Content-Type: application/json"); // Since we are sending a JSON response here (not an HTML document), set the MIME Type to application/json

$username = $_POST['username'];
$password = $_POST['password'];

// Check to see if the username and password are valid. (You learned how to do this in Module 3.)

if( /* valid username and password */ ){
session_start();
$_SESSION['username'] = $username;
$_SESSION['token'] = bin2hex(openssl_random_pseudo_bytes(32));

echo json_encode(array(
"success" => true
));
exit;
}else{
echo json_encode(array(
"success" => false,
"message" => "Incorrect Username or Password"
));
exit;
}
?>
</source>

'''Note:''' This example uses PHP's very handy '''json_encode()''' function to translate an associative array into a JSON object. This means that you can access in JavaScript the same structure that you made in PHP!

And suppose you had the following HTML content:

<source lang="html4strict">
<input type="text" id="username" placeholder="Username" />
<input type="password" id="password" placeholder="Password" />
<button id="login_btn">Log In</button>

<script type="text/javascript" src="ajax.js"></script> 
</source>

You could use the following JavaScript code to prepare, send, and receive a request from the server to see if the user is logged in, without ever having to refresh the page.

<source lang="javascript">
// ajax.js

function loginAjax(event){
const username = document.getElementById("username").value; // Get the username from the form
const password = document.getElementById("password").value; // Get the password from the form

// Make a URL-encoded string for passing POST data:
const data = {username: username, password: password};

fetch("login_ajax.php", {
body: JSON.stringify(data),
headers: {
'content-type': 'application/json'
},
method: 'POST'
})
.then(response => response.json())
.then(data => console.log(data.success ? "You've been logged in!" : `You were not logged in ${data.message}`)

}
}

document.getElementById("login_btn").addEventListener("click", loginAjax, false); // Bind the AJAX call to button click
</source>

'''Note:''' The above example uses an '''anonymous function''' (a function without a name that is declared in an attribute) as the callback. If you are using a certain callback function only once in your program, this is a perfectly valid approach to reduce the amount of code you need to write.

=== Loading Data from an XML File for Display in HTML ===

Suppose you have a file '''note.xml''' that contains the following information:

<source lang="xml">
<?xml version="1.0" standalone="yes" ?>
<note>
<date year="2013" month="02" day="14" />
<to>Sally</to>
<message>Happy Valentine's Day!</message>
<from>Your Secret Admirer</from>
</note>
</source>

Further, suppose you had an HTML element with ID '''note''':

<source lang="html4strict">
<div id="note"></div>
</source>

You could load this XML file and then display it inside of your HTML document like this:

<source lang="javascript">
function getNoteAjax(event){
// The XMLHttpRequest is simple this time:
var xmlHttp = new XMLHttpRequest();
xmlHttp.open("GET", "note.xml", true);
xmlHttp.addEventListener("load", getNoteCallback, false);
xmlHttp.send(null);
}

function getNoteCallback(event){
var htmlParent = document.getElementById("note"); // Get the HTML element into which we want to write the note
var xmlDocument = event.target.responseXML; // Get the XML root node from the response

// Find the <date/> element from the XML response. We expect only 1 such element, so we can call
// xmlDocument.getElementsByTagName() and then get the first (and only) element in the array all in
// one step. This is called chaining.
var xmlDateElement = xmlDocument.getElementsByTagName("date")[0];

// Put together a YYYY-MM-DD type date into a string based on the attributes of the <date/> element.
var dateString = xmlDateElement.getAttribute("year") + "-" + xmlDateElement.getAttribute("month")
+ "-" + xmlDateElement.getAttribute("day");

// Get the content of the <to>, <message>, and <from> tags. Again, you can use a chain to do this in one line for each.
var to = xmlDocument.getElementsByTagName("to")[0].textContent;
var message = xmlDocument.getElementsByTagName("message")[0].textContent;
var from = xmlDocument.getElementsByTagName("from")[0].textContent;

// Make a <strong> tag, append the date string as its content, and then append it to the HTML element.
var htmlDateObj = document.createElement("strong");
htmlDateObj.appendChild(document.createTextNode(dateString));
htmlParent.appendChild(htmlDateObj);

// Make a <p> tag to contain the note.
var htmlParagraphObj = document.createElement("p");
htmlParagraphObj.appendChild(document.createTextNode("Dear "+to+",")); // First append the greeting
htmlParagraphObj.appendChild(document.createElement("br")); // Append a couple line feeds
htmlParagraphObj.appendChild(document.createElement("br"));
htmlParagraphObj.appendChild(document.createTextNode(message)); // Write the message itself
htmlParagraphObj.appendChild(document.createElement("br")); // Append a couple more line feeds
htmlParagraphObj.appendChild(document.createElement("br"));
htmlParagraphObj.appendChild(document.createTextNode("Love, "+from)); // Finally, append the salutation
htmlParent.appendChild(htmlParagraphObj); // Append the newly engineered <p> to the HTML element.
}

document.addEventListener("DOMContentLoaded", getNoteAjax, false); // Bind the AJAX call to page load
</source>

This example uses a lot of techniques documented in the [[JavaScript#Document Object Model]] section above. The resulting DOM will be something like this:

<source lang="html4strict">
<div id="note">
<strong>2013-02-14</strong>
<p>Dear Sally,<br /><br />Happy Valentine's Day!<br /><br />Love, Your Secret Admirer</p>
</div>
</source>

If you think that this is a lot of code to produce a relatively simple output, you are not alone. You will learn how to do this job in much fewer lines when you learn about [[Ext JS]].

== Debugging AJAX and JSON ==

It is helpful when building your application to look at the AJAX requests and responses as they happen in real time. Fortunately, there are many tools to help.

In your favorite web inspector (Chrome Dev Tools, Mozilla Dev Tools, Firebug, Dragonfly, and so on), go to the "Network" tab. This is where you can see all assets loaded by the application: images, stylesheets, and, most importantly for us, AJAX files. Some inspectors let you filter requests by type; for example, the Chrome inspector lets you click "XHR" to only show XMLHttpRequest (AJAX) requests.

You can also view the JSON sent by your server. Double-clicking the entries in the web inspector opens the source URL in a new tab.

If you find minified JSON hard to read, we recommend that you install the JSONView browser extension or one of its close relatives:
* [https://addons.mozilla.org/en-us/firefox/addon/jsonview/ Firefox]
* [https://chrome.google.com/webstore/detail/jsonview/chklaanhfefbnpoihckbnefhakgolnmc?hl=en Chrome]
* [https://addons.opera.com/en/extensions/details/jsonviewer/ Opera]
* [https://github.com/rfletcher/safari-json-formatter Safari]

[[Category:Module 6]]

AJAX and JSON

2018-04-30T21:32:48Z

Alex: /* Logging In a User */

Asynchronous Javascript And XML, or '''''AJAX''''', is a group of related web development techniques, standards, and technologies used on the client (web browser) side of the standard web server-client communication model.

Here's the general concept: JavaScript is used to send requests to the web server in the background and retrieve data, without the need to refresh the page. The result: dynamic, fast, user-friendly web pages.

The requests are performed ''asynchronously'': this means that the end user can continue interacting with your web page while the server data is being loaded.

The key idea is that a large fraction of the work happens at the web browser, and larger requests happen behind the scenes, keeping waiting times for data to come back over the network to a minimum. AJAX is generally also associated with higher-level APIs and libraries that aid in producing cleaner user interfaces for web applications.

== The XMLHttpRequest Object ==

The JavaScript specification defines the '''XMLHttpRequest''' object (sometimes abbreviated as '''XHR'''), which is used to exchange data with the web servers without needing to reload the entire web page in the browser.

=== Initializing an XMLHttpRequest Object ===

As stated above, the XMLHttpRequest object handles communication with the web servers. To use it, you must first initialize a variable to be an instance of the '''XMLHttpRequest''' "class".

<source lang="javascript">
var xmlHttp = new XMLHttpRequest();
</source>

Next, use your XMLHttpRequest instance to open a connection to your server.

<source lang="javascript">
xmlHttp.open("METHOD", "URL_OF_SERVER_SCRIPT", ASYNCRONOUS_FLAG);
// METHOD: either GET or POST.
// URL_OF_SERVER_SCRIPT: the path to your server-side script relative to the current page. For example, process_ajax.php
// ASYNCRONOUS_FLAG: Should be true in order to perform the request asynchronously. (Having a value of false will freeze the browser until the request is completed.)
</source>

{{DoctypeTV
|youtube_id=isrqZQPE2eQ
|time=3m51s
|desc=Explaining the Cross-Site Policy in AJAX
}}

'''Note:''' For security reasons, you cannot perform AJAX requests to other domains, unless that domain has a special security policy set up to enable such requests.

=== Sending Data ===

==== GET Data ====

To send GET data, append the information to the end of the URL_OF_SERVER_SCRIPT, as you would normally do, and then call xmlHttp.send(), passing ''null'' as the parameter:

<source lang="javascript">
var xmlHttp = new XMLHttpRequest();
xmlHttp.open("GET", "process_ajax.php?var1=val1&var2=val2", true);
xmlHttp.send(null);
</source>

==== POST Data ====

To send POST data, pass a URL-encoded string to xmlHttp.send(). You also need to change the MIME Type of the outgoing request.

<source lang="javascript">
var xmlHttp = new XMLHttpRequest();
xmlHttp.open("POST", "process_ajax.php", true);
xmlHttp.setRequestHeader("Content-Type", "application/x-www-form-urlencoded");
xmlHttp.send("var1=val1&var2=val2");
</source>

=== Listening for a Response ===

XMLHttpRequest will fire an [[JavaScript#Events|event]] when the request has been completed. We therefore need to use a '''[[JavaScript#Events|callback function]]''' in order to listen for the '''load''' event on the XMLHttpRequest object.

The server's plain text response is available as the '''responseText''' property of your XMLHttpRequest instance, which is available in the '''target''' property of the event. For example:

<source lang="javascript">
var xmlHttp = new XMLHttpRequest();
xmlHttp.open("GET", "hello.txt", true);
xmlHttp.addEventListener("load", ajaxCallback, false);
xmlHttp.send(null);

// ...

function ajaxCallback(event){
alert( "Your file contains the text: " + event.target.responseText );
}
</source>

==== Browser Support ====

Many examples that you find when Googling for "AJAX" use the '''onreadystatechange''' property of the XMLHttpRequest instance to react on the completion of the request, rather than using an event listener. This approach works, and it is required for comprehensive browser support, but it is no longer recommended for future use in modern web applications. The implementation of XMLHttpRequest documented here (so-called "XHR level 2") works in the following browsers:
* Firefox 3.5+ (Jun 2009)
* Safari 5+ (Jun 2010)
* Chrome 7+ (Sep 2010)
* Opera 12+ (May 2012)
* Internet Explorer 10+ (unreleased)
Together, browsers supporting XHR level 2 account [http://caniuse.com/xhr2 77% of the market] as of August 2013.

=== Response Formats ===

More often than not, a plaintext response form the server is not very helpful: you want to transmit more information than simply a single string of text. There are two good options to get more information from a single AJAX request: '''XML''' (the original format, thus the ''X'' in ''AJAX'') and '''JSON'''.

==== XML ====

Your server can respond with an XML document (whence, ''XMLHttpRequest''). An '''XML document''' uses syntax that is extremely close to HTML For example:

<source lang="xml">
<?xml version="1.0" standalone="yes" ?>
<note>
<date year="2013" month="02" day="14" />
<to>Sally</to>
<message>Happy Valentine's Day!</message>
<from>Your Secret Admirer</from>
</note>
</source>

Like HTML, XML has a DOM that can be traversed in JavaScript.

If you make an AJAX request to a script generating an XML document, the root XML node is accessible in the '''responseXML''' property.

<source lang="javascript">
function ajaxCallback(event){
var xmlDocument = event.target.responseXML;

alert(xmlDocument.getElementsByTagName("to")[0].textContent); // Sally (in the case of the example XML above)
}
</source>

==== JSON ====

JavaScript Object Notation, or '''JSON''', is a rising standard interface format because of its lightweight syntax that makes it especially useful for AJAX requests.

The JSON syntax closely follows the syntax for [[JavaScript#Object Literals|object literals]]. For example:

<source lang="javascript">
{
"apple": {
"color": "red",
"flavor": "sweet"
},
"lemon": {
"color": "yellow",
"flavor": "sour"
}
}
</source>

Usually when JSON is transferred over the internet, it is condensed down to one line, like this:

<source lang="javascript">
{"apple":{"color":"red","flavor":"sweet"},"lemon":{"color":"yellow","flavor":"sour"}}
</source>

In JavaScript, you can convert a JSON string to an object using '''JSON.parse()'''. For example:

<source lang="javascript">
var jsonData = JSON.parse('{"apple":{"color":"red","flavor":"sweet"},"lemon":{"color":"yellow","flavor":"sour"}}');

alert(jsonData.apple.color); // red
</source>

Here's how to use it in conjunction with your AJAX response callback:

<source lang="javascript">
function ajaxCallback(event){
var jsonData = JSON.parse(event.target.responseText);

alert(jsonData.lemon.flavor); // sour (in the case of the example JSON above)
}
</source>

Here is a graphic to illustrate the JSON process.

[[File:JSON-Flowchart.png‎]]

== Examples ==

=== Logging In a User ===

Suppose you had the following PHP script:

<source lang="php">
<?php
// login_ajax.php

header("Content-Type: application/json"); // Since we are sending a JSON response here (not an HTML document), set the MIME Type to application/json

$username = $_POST['username'];
$password = $_POST['password'];

// Check to see if the username and password are valid. (You learned how to do this in Module 3.)

if( /* valid username and password */ ){
session_start();
$_SESSION['username'] = $username;
$_SESSION['token'] = bin2hex(openssl_random_pseudo_bytes(32));

echo json_encode(array(
"success" => true
));
exit;
}else{
echo json_encode(array(
"success" => false,
"message" => "Incorrect Username or Password"
));
exit;
}
?>
</source>

'''Note:''' This example uses PHP's very handy '''json_encode()''' function to translate an associative array into a JSON object. This means that you can access in JavaScript the same structure that you made in PHP!

And suppose you had the following HTML content:

<source lang="html4strict">
<input type="text" id="username" placeholder="Username" />
<input type="password" id="password" placeholder="Password" />
<button id="login_btn">Log In</button>

<script type="text/javascript" src="ajax.js"></script> 
</source>

You could use the following JavaScript code to prepare, send, and receive a request from the server to see if the user is logged in, without ever having to refresh the page.

<source lang="javascript">
// ajax.js

function loginAjax(event){
var username = document.getElementById("username").value; // Get the username from the form
var password = document.getElementById("password").value; // Get the password from the form

// Make a URL-encoded string for passing POST data:
var dataString = "username=" + encodeURIComponent(username) + "&password=" + encodeURIComponent(password);

var xmlHttp = new XMLHttpRequest(); // Initialize our XMLHttpRequest instance
xmlHttp.open("POST", "login_ajax.php", true); // Starting a POST request (NEVER send passwords as GET variables!!!)
xmlHttp.setRequestHeader("Content-Type", "application/x-www-form-urlencoded"); // It's easy to forget this line for POST requests
xmlHttp.addEventListener("load", function(event){
var jsonData = JSON.parse(event.target.responseText); // parse the JSON into a JavaScript object
if(jsonData.success){ // in PHP, this was the "success" key in the associative array; in JavaScript, it's the .success property of jsonData
alert("You've been Logged In!");
}else{
alert("You were not logged in. "+jsonData.message);
}
}, false); // Bind the callback to the load event
xmlHttp.send(dataString); // Send the data
}

document.getElementById("login_btn").addEventListener("click", loginAjax, false); // Bind the AJAX call to button click
</source>

'''Note:''' The above example uses an '''anonymous function''' (a function without a name that is declared in an attribute) as the callback. If you are using a certain callback function only once in your program, this is a perfectly valid approach to reduce the amount of code you need to write.

=== Loading Data from an XML File for Display in HTML ===

Suppose you have a file '''note.xml''' that contains the following information:

<source lang="xml">
<?xml version="1.0" standalone="yes" ?>
<note>
<date year="2013" month="02" day="14" />
<to>Sally</to>
<message>Happy Valentine's Day!</message>
<from>Your Secret Admirer</from>
</note>
</source>

Further, suppose you had an HTML element with ID '''note''':

<source lang="html4strict">
<div id="note"></div>
</source>

You could load this XML file and then display it inside of your HTML document like this:

<source lang="javascript">
function getNoteAjax(event){
// The XMLHttpRequest is simple this time:
var xmlHttp = new XMLHttpRequest();
xmlHttp.open("GET", "note.xml", true);
xmlHttp.addEventListener("load", getNoteCallback, false);
xmlHttp.send(null);
}

function getNoteCallback(event){
var htmlParent = document.getElementById("note"); // Get the HTML element into which we want to write the note
var xmlDocument = event.target.responseXML; // Get the XML root node from the response

// Find the <date/> element from the XML response. We expect only 1 such element, so we can call
// xmlDocument.getElementsByTagName() and then get the first (and only) element in the array all in
// one step. This is called chaining.
var xmlDateElement = xmlDocument.getElementsByTagName("date")[0];

// Put together a YYYY-MM-DD type date into a string based on the attributes of the <date/> element.
var dateString = xmlDateElement.getAttribute("year") + "-" + xmlDateElement.getAttribute("month")
+ "-" + xmlDateElement.getAttribute("day");

// Get the content of the <to>, <message>, and <from> tags. Again, you can use a chain to do this in one line for each.
var to = xmlDocument.getElementsByTagName("to")[0].textContent;
var message = xmlDocument.getElementsByTagName("message")[0].textContent;
var from = xmlDocument.getElementsByTagName("from")[0].textContent;

// Make a <strong> tag, append the date string as its content, and then append it to the HTML element.
var htmlDateObj = document.createElement("strong");
htmlDateObj.appendChild(document.createTextNode(dateString));
htmlParent.appendChild(htmlDateObj);

// Make a <p> tag to contain the note.
var htmlParagraphObj = document.createElement("p");
htmlParagraphObj.appendChild(document.createTextNode("Dear "+to+",")); // First append the greeting
htmlParagraphObj.appendChild(document.createElement("br")); // Append a couple line feeds
htmlParagraphObj.appendChild(document.createElement("br"));
htmlParagraphObj.appendChild(document.createTextNode(message)); // Write the message itself
htmlParagraphObj.appendChild(document.createElement("br")); // Append a couple more line feeds
htmlParagraphObj.appendChild(document.createElement("br"));
htmlParagraphObj.appendChild(document.createTextNode("Love, "+from)); // Finally, append the salutation
htmlParent.appendChild(htmlParagraphObj); // Append the newly engineered <p> to the HTML element.
}

document.addEventListener("DOMContentLoaded", getNoteAjax, false); // Bind the AJAX call to page load
</source>

This example uses a lot of techniques documented in the [[JavaScript#Document Object Model]] section above. The resulting DOM will be something like this:

<source lang="html4strict">
<div id="note">
<strong>2013-02-14</strong>
<p>Dear Sally,<br /><br />Happy Valentine's Day!<br /><br />Love, Your Secret Admirer</p>
</div>
</source>

If you think that this is a lot of code to produce a relatively simple output, you are not alone. You will learn how to do this job in much fewer lines when you learn about [[Ext JS]].

== Debugging AJAX and JSON ==

It is helpful when building your application to look at the AJAX requests and responses as they happen in real time. Fortunately, there are many tools to help.

In your favorite web inspector (Chrome Dev Tools, Mozilla Dev Tools, Firebug, Dragonfly, and so on), go to the "Network" tab. This is where you can see all assets loaded by the application: images, stylesheets, and, most importantly for us, AJAX files. Some inspectors let you filter requests by type; for example, the Chrome inspector lets you click "XHR" to only show XMLHttpRequest (AJAX) requests.

You can also view the JSON sent by your server. Double-clicking the entries in the web inspector opens the source URL in a new tab.

If you find minified JSON hard to read, we recommend that you install the JSONView browser extension or one of its close relatives:
* [https://addons.mozilla.org/en-us/firefox/addon/jsonview/ Firefox]
* [https://chrome.google.com/webstore/detail/jsonview/chklaanhfefbnpoihckbnefhakgolnmc?hl=en Chrome]
* [https://addons.opera.com/en/extensions/details/jsonviewer/ Opera]
* [https://github.com/rfletcher/safari-json-formatter Safari]

[[Category:Module 6]]

Module 5

2018-04-22T20:03:08Z

Alex:

__NOTOC__
In Module 5, you will learn JavaScript, the dominant client-side web language. JavaScript is the third and final programming language you will learn in CSE 330.

This article contains your assignments for Module 5.

'''Warning:'''

''This module takes students a while. It is strongly recommended that you start early and ask questions as they come up.''

== Reading ==

The following articles on the online class wiki textbook contain information that will help you complete the assignments.

* [[JavaScript]]
* [[AJAX and JSON]]
* [[jQuery]]
* [[Web Application Security, Part 3]]

== Individual Assignments ==

'''''IMPORTANT:'' Both of the individual assignments must be completed ''without'' using a JavaScript library like jQuery.''' However, you may use jQuery for the group portion.

=== JavaScript Calculator ===

In Module 2, you made a calculator using PHP. Now you will be making one using JavaScript.

* The web page should have two input fields and a radio button group for the operation, with the 4 basic math operations represented (add, subtract, multiply, divide).
* JavaScript should monitor all three fields and display the current result whenever the user changes any value in any field, without refreshing the page.
*: '''Tip 1:''' Consider using either the ''change'' or the ''keyup'' event on the text fields, and either the ''change'' or the ''click'' event on the radio buttons.
*: '''Tip 2:''' Re-read [[JavaScript|the JavaScript guide]] if you need help figuring our how to bind callback functions to events, or how to determine which radio button is currently selected. (There are examples for both of these!)
* The calculator should be completely self-contained; i.e., you should not be making any requests to any other server-side or client-side scripts or web pages after the initial page load.

'''Tip:''' You can embed JavaScript code into an HTML document like this:

<source lang="html4strict">
<script>
// your code here
</script>
</source>

'''Tip:''' If your code isn't working the way you expect, use a JavaScript error console. In Chrome, for example, press Ctrl-Shift-I (or Cmd-Option-I) to open the WebKit inspector.

'''Important:''' It is best practice to fully separate the content, appearance, and behavior. In previous modules, you may have lost points for using HTML tags that change the appearance of things <nowiki>(like <center> and <font>).</nowiki> In this module, make sure that you define your event listeners in JavaScript as in <code>document.getElementById("xyz").addEventListener(...)</code> and '''''not''''' in the HTML like <code><button onclick="badExample();">Bad Example</button></code>.

=== Weather Widget ===

In this section, you will make a web page that displays the weather forecast using AJAX requests to a weather server.

# Make an empty HTML document; name it '''weather.html'''
#: Refer to the [[HTML and CSS]] guide for the skeleton of an HTML document
# Define a function in JavaScript; call it '''fetchWeather()'''. You may write your JavaScript in an embedded script in your HTML document.
# Inside your '''fetchWeather()''' function, make an AJAX request to the weather server.
#: We have a server that outputs the current weather in JSON format. The format is documented in the [[#JSON Structure]] section below.
#: '''URL:''' https://classes.engineering.wustl.edu/cse330/content/weather_json.php
#: We kindly thank Yahoo Weather for providing us with up-to-date weather information.
#* '''IMPORTANT:''' Under normal circumstances, AJAX requests ''cannot'' be performed cross-domain for security reasons. We have set the <code>Access-Control-Allow-Origin</code> header on our server to allow requests from your EC2 instances, or from localhost. '''You will therefore need to upload your code to your EC2, or access it via localhost, in order for the AJAX requests to work.''' This means that you cannot, for example, complete this part of the individual portion in JSFiddle.
# In your callback, process the JSON and use JavaScript to manipulate the HTML DOM to display the following information on your page:
#* Location
#** City, in a <nowiki><strong></nowiki> tag
#** State, not in any tag
#* Humidity
#* Current Temperature
#* Image for Tomorrow's Forecast (see [[#Weather Condition Images]] below for more information)
#* Image for the Day After Tomorrow's Forecast
# Finally, bind '''fetchWeather()''' to the DOMContentLoaded event so that your weather widget is automatically initialized when the page is loaded:
#: <source lang="javascript">document.addEventListener("DOMContentLoaded", fetchWeather, false);</source>
# In addition, add a button that runs your ''fetchWeather'' function when clicked. This should update your widget with the current weather conditions.

Use the following HTML:

<source lang="html4strict">
<div class="weather" id="weatherWidget">
<div class="weather-loc"></div>
<div class="weather-humidity"></div>
<div class="weather-temp"></div>
<img class="weather-tomorrow" />
<img class="weather-dayaftertomorrow" />
</div>
</source>

Include the CSS file from here: http://classes.engineering.wustl.edu/cse330/content/weather.css

When everything is working, the weather widget should look something like this:

[[File:WeatherWidget.png]]

'''Important:''' The widget in this section needs to work in only Firefox and Chrome. It does '''''not''''' need to work Internet Explorer.

==== Tips ====

===== JSON Structure =====

The JSON from our server looks like this:

<source lang="javascript">
{
"updated": "Thu, 11 Oct 2012 5:54 pm CDT",
"location": {
"city": "St. Louis",
"state": "MO"
},
"wind": {
"chill": "62",
"direction": "150",
"speed": "3 mph"
},
"atmosphere": {
"humidity": "50",
"visibility": "10",
"pressure": "30.12 in"
},
"current": {
"code": "28",
"text": "Mostly Cloudy",
"temp": "62°F",
"date": "Thu, 11 Oct 2012 5:54 pm CDT"
},
"tomorrow": {
"code": "29",
"text": "Clouds Early/Clearing Late",
"low": "45°F",
"high": "61°F"
},
"dayafter": {
"code": "30",
"text": "Partly Cloudy",
"low": "53°F",
"high": "65°F"
},
"credit": "http://us.rd.yahoo.com/dailynews/rss/weather/St._Louis__MO/*http://weather.yahoo.com/forecast/USMO0170_f.html"
}
</source>

===== Weather Condition Images =====

Each day's forecast has a code. There are images associated with these codes.

One place to get the images is from here: <nowiki>http://us.yimg.com/i/us/nws/weather/gr/</nowiki>'''##'''<nowiki>ds.png</nowiki>

Replace the '''##''' with the forecast code. For example, for code 32, the URL would be: http://us.yimg.com/i/us/nws/weather/gr/32ds.png

== Group Project ==

I forgot if I already mentioned this, but '''start early on this project!''' It will take longer than you think, I promise!

You are encouraged to use the advanced version control practices you learned in Module 5 when completing this assignment.

=== Calendar ===

Build a simple calendar that allows users to add and remove events dynamically.

You will use JavaScript to process user interactions at the web browser, without ever refreshing the browser after the initial web page load. You may use a JavaScript library of your choice, including Ext JS, so long as that JavaScript library does not defeat the purpose of the assignment. If you have questions about this, ask. In particular, libraries like FullCalendar are unacceptable.

Your application should utilize AJAX to run server-side scripts that query your database to save and retrieve information, including user accounts and events.

We have also written some functions to help you get started: [[JavaScript Calendar Library]]

==== Examples ====

* https://calendar.google.com/
* http://www.zoho.com/calendar/

==== Server Side Language ====

Additionally, you may use a database of your choice. MySQL is probably the logical choice since you have been using it since Module 2, but you are free to explore other databases if you like.

==== Requirements ====

* Support a month-by-month view of the calendar.
*: Show one month at a time, with buttons to move forward or backward.
*: There should be no limit to how far forward or backward the user can go.
* Users can register and log in to the website.
*: You may leverage your MySQL project code and database from module 3 to get started.
* Unregistered users should see no events on the calendar.
* Registered users can add events.
*: All events should have a date and time, but do not need to have a duration.
*: You do ''not'' need to support recurring events (where you add an event that repeats, for example, every monday).
* Registered users see only events that they have added.
*: Your AJAX should not ask the server for events from a certain username. Instead, your AJAX should ask the server for events, and the server should respond with the events for only the currently-logged-in user (from the session). Can you think of why?
* Registered users can delete their events, but not the events of others.
*: Again, the server should delete events based on the username present in the session. (If it deletes only based on an Event ID, an attacker could feed any arbitrary Event ID to your server, even if he/she didn't own that event.)
* All user and event data should be kept in a database.
* At no time should the main page need to be reloaded.
*: User registration, user authentication, event addition, and event deletion should all be handled by JavaScript and AJAX requests to your server.
* Your page needs to work in the versions of Firefox and Chrome installed on the lab computers.

'''Tip:''' Run your database schema by a TA before implementing it.

=== Web Security and Validation ===

Your project needs to demonstrate that thought was put into web security and best practice. For more information, see this week's Web Application Security guide: [[Web Application Security, Part 3]]

In particular:

* '''Your application needs to prevent XSS attacks.''' Be careful when transmitting data over JSON that will be reflected in an event title! (Note: JSON data should be sanitized on the client side, not the server side.)
* '''Perform precautionary measures to prevent session hijacking attacks.'''
*: You should specify your session cookie to be HTTP-Only. However, for the means of this module, you need not test for user agent consistency.
* '''Optional:''' Validate your JavaScript code using [http://www.jshint.com/ JSHint] '''''or''''' [http://jslint.com/ JSLint] for up to 3 points of extra credit.

You should continue the practices that you have learned in past weeks:

* Pass tokens in forms to prevent CSRF attacks.
*: '''Hint:''' You will need to send your CSRF tokens in your AJAX requests. Remember that AJAX still submits forms and runs server-side scripts, just like the vanilla forms you've been using in Modules 2 and 3.
* Use prepared queries to prevent SQL Injection attacks.
* If storing passwords in a database, always store them salted and encrypted.
* Your page should validate with no errors through the W3C validator.

== Grading ==

We will be grading the following aspects of your work. There are 100 points total.

'''Assignments (including code) must be committed to Bitbucket by the end of class on the due date (commit early and often). Failing to commit by the end of class on the due date will result in a 0. '''

If you do not include a link to your group portion running on your instance in your group portion README.md, you will receive a 0 for the group portion
_________

# '''JavaScript Calculator (10 Points):'''
#* Calculator successfully adds, subtracts, multiplies, and divides numbers (3 points)
#* The result is automatically computed when a value in either field is changed (3 points)
#* Calculator is written entirely in pure, conventional JavaScript with no external libraries (4 points)*
#*: ''Note: be sure to fully separate content, appearance, and behavior. This means that you should '''not''' use the event attributes on the HTML elements like onclick, onchange, and onkeyup.''
# '''Weather Widget (15 Points):'''
#* Widget performs an AJAX request to fetch the current weather (4 points)
#* The HTML template is filled with the correct information, including an image (4 points)
#* Button to reload the weather widget (2 points)
#* Widget is written entirely in pure, conventional JavaScript with no external libraries (5 points)*
# '''AJAX Calendar (60 Points):'''
#* '''''Calendar View (10 Points):'''''
#** The calendar is displayed as a table grid with days as the columns and weeks as the rows, one month at a time (5 points)
#** The user can view different months as far in the past or future as desired (5 points)
#* '''''User and Event Management (25 Points):'''''
#** Events can be added, modified, and deleted (5 points)
#** Events have a title, date, and time (2 points)
#** Users can log into the site, and they cannot view or manipulate events associated with other users (8 points)
#**: ''Don't fall into the Abuse of Functionality trap! Check user credentials on the server side as well as on the client side.''
#** All actions are performed over AJAX, without ever needing to reload the page (10 points)
#* '''''Best Practices (20 Points):'''''
#** Code is well formatted and easy to read, with proper commenting (2 points)
#** If storing passwords, they are stored salted and hashed (2 points)
#** All AJAX requests that either contain sensitive information or modify something on the server are performed via POST, not GET (3 points)
#** Safe from XSS attacks; that is, all content is escaped on output (3 points)
#** Safe from SQL Injection attacks (2 points)
#** CSRF tokens are passed when editing or removing events (3 points)
#** Session cookie is HTTP-Only (3 points)
#** Page passes the W3C validator (2 points)
#** ''Extra Credit:'' Your code passes ''JSHint'' or ''JSLint'' (+3 bonus points)
#* '''''Usability (5 Points):'''''
#** Site is intuitive to use and navigate (4 points)
#** Site is visually appealing (1 point)
# '''Creative Portion (15 Points)'''
#* '''Additional Calendars Features (worth 15 points):''' Develop some additional features for the calendar, a few examples are provided below.
#** Users can tag an event with a particular category and enable/disable those tags in the calendar view. (5 points)
#** Users can share their calendar with additional users. (5 points)
#** Users can create group events that display on multiple users calendars (5 points)
#* '''Make sure to save a description of your creative portion, and a link to your server in your README.md file.'''
''* These points can be earned only if at least 3 other points have been earned in that category. This is to prevent these points from being "free."''

[[Category:Module 5]]
[[Category:Modules]]

Module 4

2018-03-19T04:56:53Z

Alex: /* Write some Regular Expressions */

__NOTOC__
In Module 4, you will learn the fundamentals of Python, a popular scripting language, and Regular Expressions, which give you power in text processing.

This article contains your assignments for Module 4.

== Reading ==

The following articles on the online class wiki textbook contain information that will help you complete the assignments.

* [[Python]]
* [[Regular Expressions]]

== Individual Assignments ==

=== Learn Python and Regular Expressions ===

Up to this point in CSE 330, you have used only one programming language: PHP. In Module 4, you will learn a new language: Python. Before starting this assignment, you should look over the [[Python|online textbook article about Python]]. You should be using version 3 (or greater) of Python. Additionally, you may find it helpful to look over the [[Regular Expressions|online textbook article about Regular Expressions]].

=== Write some Regular Expressions ===

Please write regular expressions that do each the following:

# Match the substring "hello world" in a string.
# Find all words in an input string that contains three consecutive vowels, regardless of case.
# Match an input string that is '''entirely''' a flight code, of the format AA####, where '''AA''' is a two-letter uppercase airline code, and '''####''' is a three- or four-digit flight number.
Examples:
Note: text in ''[[red]]'' is matched by the regular expression. Each line is a separate test input string.
Regex 1: Programmers will often write ''[[hello world]]'' as their first project with a programming language.
Regex 2: The ''[[gooey]]'' peanut butter and jelly sandwich was a ''[[beauty]]''.
Regex 3: ''[[AA312]]''
''[[AA1298]]''
''[[NW1234]]''
''[[US443]]''
US31344
AA123 extratext

Save your regexes to text files – one each.

=== Baseball Stats Counter ===

The St. Louis Cardinals are the most legendary baseball team in the national league. In this exercise, you will be creating a Python script that reads box scores from a file and computes the Cardinals' players' batting averages in a particular season.

==== Tips and Instructions ====

* You should write a Python script file to solve this problem.
* You should use a regular expression to parse players' names, at-bats, hits, and runs from the input file.
* You may want to create a class to hold and compute information about each player.
* Your file should take one command-line argument: the path to an input file. If no path is given, your program should print a usage message.

==== Input ====

Sample input files may be found here: http://classes.engineering.wustl.edu/cse330/content/cardinals/

The top of the file contains a citation, and what follows is an entire season of Cardinals Baseball box scores. Each game starts with a title; for example:

=== St.Louis Cardinals vs. Chicago Cubs, 1940-04-19 ===

What follows are the performance of each player in that game. The format of each line is as follows:

XXX batted # times with # hits and # runs

where '''XXX''' is the player's name (you may assume that the name is unique), and each '''#''' are integers representing the number of "at bats", the number of "hits", and the number of "runs", respectively.

==== Output ====

Your script needs to output all players' batting average across the season. A player's batting average is that player's total hits divided by that player's total at-bats throughout the entire season. For example, Johnny Hopp was at bat 149 times in 1940, and he had 41 hits, so his batting average was 0.275.

Each line in the output should have the format:

XXX: #.###

where '''XXX''' is the player's name, and '''#.###''' is the player's batting average, '''rounded''' (not truncated) to three decimal places.

The players should be sorted by batting average, with the highest batting average on top. If two players have the exact same batting average (before rounding occurs), the order between those two players is unimportant.

For example, the correct output for the 1940 season is:

<source lang="text">
Pepper Martin: 0.316
Walker Cooper: 0.316
Johnny Mize: 0.314
Ernie Koy: 0.310
Enos Slaughter: 0.306
Joe Medwick: 0.304
Terry Moore: 0.304
Joe Orengo: 0.286
Jimmy Brown: 0.280
Marty Marion: 0.279
Don Gutteridge: 0.276
Johnny Hopp: 0.275
Creepy Crespi: 0.273
Mickey Owen: 0.265
Bill DeLancey: 0.250
Don Padgett: 0.242
Stu Martin: 0.238
Eddie Lake: 0.222
Hal Epps: 0.214
Lon Warneke: 0.209
Harry Walker: 0.185
Max Lanier: 0.179
Bill McGee: 0.178
Carl Doyle: 0.174
Mort Cooper: 0.157
Clyde Shoun: 0.145
Carden Gillenwater: 0.130
Bob Bowman: 0.067
</source>

== Grading ==

We will be grading the following aspects of your work. There are 50 points total.

'''Assignments (including code) must be committed to Bitbucket by the end of class on the due date (commit early and often). Failing to commit by the end of class on the due date will result in a 0. '''

Upload your baseball code and a file with your Regular expressions.

# '''Regular Expressions (15 Points):'''
#* '''Your regex files should contain your regex (with no delimiters) and nothing else.'''
#* Regular Expression 1 Correct and saved in a file named <code>regex1.txt</code> (5 points)
#* Regular Expression 2 Correct and saved in a file named <code>regex2.txt</code>(5 points)
#* Regular Expression 3 Correct and saved in a file named <code>regex3.txt</code>(5 points)
# '''Baseball Stats Counter (35 Points):'''
#* Solution is written entirely in Python and saved in a file named <code>baseball.py</code> (8 points)
#*: ''Note: Failing to write your code in Python 3 will result in losing, at a minimum, points for this category.''
#* Correct usage of one or more regular expressions to parse and extract data from each line of the input file (8 points)
#*: ''Note: You should not be using <code>str.split</code> to extract data.''
#* Script prints a usage message if a command line argument is not present (4 points)
#*: ''Note: For an example of a usage message, see [https://en.wikipedia.org/wiki/Usage_message#Examples this link.]''
#* Output is correct for all test cases (15 points)
#*: ''This includes sorting and rounding.''

[[Category:Module 4]]
[[Category:Modules]]

Module 4

2018-03-07T17:55:33Z

Alex: /* Grading */

__NOTOC__
In Module 4, you will learn the fundamentals of Python, a popular scripting language, and Regular Expressions, which give you power in text processing.

This article contains your assignments for Module 4.

== Reading ==

The following articles on the online class wiki textbook contain information that will help you complete the assignments.

* [[Python]]
* [[Regular Expressions]]

== Individual Assignments ==

=== Learn Python and Regular Expressions ===

Up to this point in CSE 330, you have used only one programming language: PHP. In Module 4, you will learn a new language: Python. Before starting this assignment, you should look over the [[Python|online textbook article about Python]]. You should be using version 3 (or greater) of Python. Additionally, you may find it helpful to look over the [[Regular Expressions|online textbook article about Regular Expressions]].

=== Write some Regular Expressions ===

Please write regular expressions that do each the following:

# Match the substring "hello world" in string.
# Find all words in an input string that contains three consecutive vowels, regardless of case.
# Match an input string that is '''entirely''' a flight code, of the format AA####, where '''AA''' is a two-letter uppercase airline code, and '''####''' is a three- or four-digit flight number.
Examples:
Note: text in ''[[red]]'' is matched by the regular expression. Each line is a separate test input string.
Regex 1: Programmers will often write ''[[hello world]]'' as their first project with a programming language.
Regex 2: The ''[[gooey]]'' peanut butter and jelly sandwich was a ''[[beauty]]''.
Regex 3: ''[[AA312]]''
''[[AA1298]]''
''[[NW1234]]''
''[[US443]]''
US31344
AA123 extratext

Save your regexes to text files – one each.

=== Baseball Stats Counter ===

The St. Louis Cardinals are the most legendary baseball team in the national league. In this exercise, you will be creating a Python script that reads box scores from a file and computes the Cardinals' players' batting averages in a particular season.

==== Tips and Instructions ====

* You should write a Python script file to solve this problem.
* You should use a regular expression to parse players' names, at-bats, hits, and runs from the input file.
* You may want to create a class to hold and compute information about each player.
* Your file should take one command-line argument: the path to an input file. If no path is given, your program should print a usage message.

==== Input ====

Sample input files may be found here: http://classes.engineering.wustl.edu/cse330/content/cardinals/

The top of the file contains a citation, and what follows is an entire season of Cardinals Baseball box scores. Each game starts with a title; for example:

=== St.Louis Cardinals vs. Chicago Cubs, 1940-04-19 ===

What follows are the performance of each player in that game. The format of each line is as follows:

XXX batted # times with # hits and # runs

where '''XXX''' is the player's name (you may assume that the name is unique), and each '''#''' are integers representing the number of "at bats", the number of "hits", and the number of "runs", respectively.

==== Output ====

Your script needs to output all players' batting average across the season. A player's batting average is that player's total hits divided by that player's total at-bats throughout the entire season. For example, Johnny Hopp was at bat 149 times in 1940, and he had 41 hits, so his batting average was 0.275.

Each line in the output should have the format:

XXX: #.###

where '''XXX''' is the player's name, and '''#.###''' is the player's batting average, '''rounded''' (not truncated) to three decimal places.

The players should be sorted by batting average, with the highest batting average on top. If two players have the exact same batting average (before rounding occurs), the order between those two players is unimportant.

For example, the correct output for the 1940 season is:

<source lang="text">
Pepper Martin: 0.316
Walker Cooper: 0.316
Johnny Mize: 0.314
Ernie Koy: 0.310
Enos Slaughter: 0.306
Joe Medwick: 0.304
Terry Moore: 0.304
Joe Orengo: 0.286
Jimmy Brown: 0.280
Marty Marion: 0.279
Don Gutteridge: 0.276
Johnny Hopp: 0.275
Creepy Crespi: 0.273
Mickey Owen: 0.265
Bill DeLancey: 0.250
Don Padgett: 0.242
Stu Martin: 0.238
Eddie Lake: 0.222
Hal Epps: 0.214
Lon Warneke: 0.209
Harry Walker: 0.185
Max Lanier: 0.179
Bill McGee: 0.178
Carl Doyle: 0.174
Mort Cooper: 0.157
Clyde Shoun: 0.145
Carden Gillenwater: 0.130
Bob Bowman: 0.067
</source>

== Grading ==

We will be grading the following aspects of your work. There are 50 points total.

'''Assignments (including code) must be committed to Bitbucket by the end of class on the due date (commit early and often). Failing to commit by the end of class on the due date will result in a 0. '''

Upload your baseball code and a file with your Regular expressions.

# '''Regular Expressions (15 Points):'''
#* '''Your regex files should contain your regex (with no delimiters) and nothing else.'''
#* Regular Expression 1 Correct and saved in a file named <code>regex1.txt</code> (5 points)
#* Regular Expression 2 Correct and saved in a file named <code>regex2.txt</code>(5 points)
#* Regular Expression 3 Correct and saved in a file named <code>regex3.txt</code>(5 points)
# '''Baseball Stats Counter (35 Points):'''
#* Solution is written entirely in Python and saved in a file named <code>baseball.py</code> (8 points)
#*: ''Note: Failing to write your code in Python 3 will result in losing, at a minimum, points for this category.''
#* Correct usage of one or more regular expressions to parse and extract data from each line of the input file (8 points)
#*: ''Note: You should not be using <code>str.split</code> to extract data.''
#* Script prints a usage message if a command line argument is not present (4 points)
#*: ''Note: For an example of a usage message, see [https://en.wikipedia.org/wiki/Usage_message#Examples this link.]''
#* Output is correct for all test cases (15 points)
#*: ''This includes sorting and rounding.''

[[Category:Module 4]]
[[Category:Modules]]

Module 5

2018-03-03T22:56:36Z

Alex: /* Grading */

__NOTOC__
In Module 5, you will learn JavaScript, the dominant client-side web language. JavaScript is the third and final programming language you will learn in CSE 330.

This article contains your assignments for Module 5.

'''Warning:'''

''This module takes students a while. It is strongly recommended that you start early and ask questions as they come up.''

== Reading ==

The following articles on the online class wiki textbook contain information that will help you complete the assignments.

* [[JavaScript]]
* [[AJAX and JSON]]
* [[jQuery]]
* [[Web Application Security, Part 3]]

== Individual Assignments ==

'''''IMPORTANT:'' Both of the individual assignments must be completed ''without'' using a JavaScript library like jQuery.''' However, you may (and should) use jQuery for the group portion.

=== JavaScript Calculator ===

In Module 2, you made a calculator using PHP. Now you will be making one using JavaScript.

* The web page should have two input fields and a radio button group for the operation, with the 4 basic math operations represented (add, subtract, multiply, divide).
* JavaScript should monitor all three fields and display the current result whenever the user changes any value in any field, without refreshing the page.
*: '''Tip 1:''' Consider using either the ''change'' or the ''keyup'' event on the text fields, and either the ''change'' or the ''click'' event on the radio buttons.
*: '''Tip 2:''' Re-read [[JavaScript|the JavaScript guide]] if you need help figuring our how to bind callback functions to events, or how to determine which radio button is currently selected. (There are examples for both of these!)
* The calculator should be completely self-contained; i.e., you should not be making any requests to any other server-side or client-side scripts or web pages after the initial page load.

'''Tip:''' You can embed JavaScript code into an HTML document like this:

<source lang="html4strict">
<script type="text/javascript">
// your code here
</script>
</source>

'''Tip:''' If your code isn't working the way you expect, use a JavaScript error console. In Chrome, for example, press Ctrl-Shift-I (or Cmd-Option-I) to open the WebKit inspector.

'''Important:''' It is best practice to fully separate the content, appearance, and behavior. In previous modules, you may have lost points for using HTML tags that change the appearance of things <nowiki>(like <center> and <font>).</nowiki> In this module, make sure that you define your event listeners in JavaScript as in <code>document.getElementById("xyz").addEventListener(...)</code> and '''''not''''' in the HTML like <code><button onclick="badExample();">Bad Example</button></code>.

=== Weather Widget ===

In this section, you will make a web page that displays the weather forecast using AJAX requests to a weather server.

# Make an empty HTML document; name it '''weather.html'''
#: Refer to the [[HTML and CSS]] guide for the skeleton of an HTML document
# Define a function in JavaScript; call it '''fetchWeather()'''. You may write your JavaScript in an embedded script in your HTML document.
# Inside your '''fetchWeather()''' function, make an AJAX request to the weather server.
#: We have a server that outputs the current weather in JSON format. The format is documented in the [[#JSON Structure]] section below.
#: '''URL:''' https://classes.engineering.wustl.edu/cse330/content/weather_json.php
#: We kindly thank Yahoo Weather for providing us with up-to-date weather information.
#* '''IMPORTANT:''' Under normal circumstances, AJAX requests ''cannot'' be performed cross-domain for security reasons. We have set the <code>Access-Control-Allow-Origin</code> header on our server to allow requests from your EC2 instances, or from localhost. '''You will therefore need to upload your code to your EC2, or access it via localhost, in order for the AJAX requests to work.''' This means that you cannot, for example, complete this part of the individual portion in JSFiddle.
# In your callback, process the JSON and use JavaScript to manipulate the HTML DOM to display the following information on your page:
#* Location
#** City, in a <nowiki><strong></nowiki> tag
#** State, not in any tag
#* Humidity
#* Current Temperature
#* Image for Tomorrow's Forecast (see [[#Weather Condition Images]] below for more information)
#* Image for the Day After Tomorrow's Forecast
# Finally, bind '''fetchWeather()''' to the DOMContentLoaded event so that your weather widget is automatically initialized when the page is loaded:
#: <source lang="javascript">document.addEventListener("DOMContentLoaded", fetchWeather, false);</source>
# In addition, add a button that runs your ''fetchWeather'' function when clicked. This should update your widget with the current weather conditions.

Use the following HTML:

<source lang="html4strict">
<div class="weather" id="weatherWidget">
<div class="weather-loc"></div>
<div class="weather-humidity"></div>
<div class="weather-temp"></div>
<img class="weather-tomorrow" />
<img class="weather-dayaftertomorrow" />
</div>
</source>

Include the CSS file from here: http://classes.engineering.wustl.edu/cse330/content/weather.css

When everything is working, the weather widget should look something like this:

[[File:WeatherWidget.png]]

'''Important:''' The widget in this section needs to work in only Firefox and Chrome. It does '''''not''''' need to work Internet Explorer.

==== Tips ====

===== JSON Structure =====

The JSON from our server looks like this:

<source lang="javascript">
{
"updated": "Thu, 11 Oct 2012 5:54 pm CDT",
"location": {
"city": "St. Louis",
"state": "MO"
},
"wind": {
"chill": "62",
"direction": "150",
"speed": "3 mph"
},
"atmosphere": {
"humidity": "50",
"visibility": "10",
"pressure": "30.12 in"
},
"current": {
"code": "28",
"text": "Mostly Cloudy",
"temp": "62°F",
"date": "Thu, 11 Oct 2012 5:54 pm CDT"
},
"tomorrow": {
"code": "29",
"text": "Clouds Early/Clearing Late",
"low": "45°F",
"high": "61°F"
},
"dayafter": {
"code": "30",
"text": "Partly Cloudy",
"low": "53°F",
"high": "65°F"
},
"credit": "http://us.rd.yahoo.com/dailynews/rss/weather/St._Louis__MO/*http://weather.yahoo.com/forecast/USMO0170_f.html"
}
</source>

===== Weather Condition Images =====

Each day's forecast has a code. There are images associated with these codes.

One place to get the images is from here: <nowiki>http://us.yimg.com/i/us/nws/weather/gr/</nowiki>'''##'''<nowiki>ds.png</nowiki>

Replace the '''##''' with the forecast code. For example, for code 32, the URL would be: http://us.yimg.com/i/us/nws/weather/gr/32ds.png

== Group Project ==

I forgot if I already mentioned this, but '''start early on this project!''' It will take longer than you think, I promise!

You are encouraged to use the advanced version control practices you learned in Module 5 when completing this assignment.

=== Calendar ===

Build a simple calendar that allows users to add and remove events dynamically.

You will use JavaScript to process user interactions at the web browser, without ever refreshing the browser after the initial web page load. You may use a JavaScript library of your choice, including Ext JS.

Your application should utilize AJAX to run server-side scripts that query your database to save and retrieve information, including user accounts and events.

We have also written some functions to help you get started: [[JavaScript Calendar Library]]

==== Examples ====

* https://calendar.google.com/
* http://www.zoho.com/calendar/

==== Server Side Language ====

Additionally, you may use a database of your choice. MySQL is probably the logical choice since you have been using it since Module 2, but you are free to explore other databases if you like.

==== Requirements ====

* Support a month-by-month view of the calendar.
*: Show one month at a time, with buttons to move forward or backward.
*: There should be no limit to how far forward or backward the user can go.
* Users can register and log in to the website.
*: You may leverage your MySQL project code and database from module 3 to get started.
* Unregistered users should see no events on the calendar.
* Registered users can add events.
*: All events should have a date and time, but do not need to have a duration.
*: You do ''not'' need to support recurring events (where you add an event that repeats, for example, every monday).
* Registered users see only events that they have added.
*: Your AJAX should not ask the server for events from a certain username. Instead, your AJAX should ask the server for events, and the server should respond with the events for only the currently-logged-in user (from the session). Can you think of why?
* Registered users can delete their events, but not the events of others.
*: Again, the server should delete events based on the username present in the session. (If it deletes only based on an Event ID, an attacker could feed any arbitrary Event ID to your server, even if he/she didn't own that event.)
* All user and event data should be kept in a database.
* At no time should the main page need to be reloaded.
*: User registration, user authentication, event addition, and event deletion should all be handled by JavaScript and AJAX requests to your server.
* Your page needs to work in the versions of Firefox and Chrome installed on the lab computers.

'''Tip:''' Run your database schema by a TA before implementing it.

=== Web Security and Validation ===

Your project needs to demonstrate that thought was put into web security and best practice. For more information, see this week's Web Application Security guide: [[Web Application Security, Part 3]]

In particular:

* '''Your application needs to prevent XSS attacks.''' Be careful when transmitting data over JSON that will be reflected in an event title! (Note: JSON data should be sanitized on the client side, not the server side.)
* '''Perform precautionary measures to prevent session hijacking attacks.'''
*: You should specify your session cookie to be HTTP-Only. However, for the means of this module, you need not test for user agent consistency.
* '''Optional:''' Validate your JavaScript code using [http://www.jshint.com/ JSHint] '''''or''''' [http://jslint.com/ JSLint] for up to 3 points of extra credit.

You should continue the practices that you have learned in past weeks:

* Pass tokens in forms to prevent CSRF attacks.
*: '''Hint:''' You will need to send your CSRF tokens in your AJAX requests. Remember that AJAX still submits forms and runs server-side scripts, just like the vanilla forms you've been using in Modules 2 and 3.
* Use prepared queries to prevent SQL Injection attacks.
* If storing passwords in a database, always store them salted and encrypted.
* Your page should validate with no errors through the W3C validator.

== Grading ==

We will be grading the following aspects of your work. There are 100 points total.

'''Assignments (including code) must be committed to Bitbucket by the end of class on the due date (commit early and often). Failing to commit by the end of class on the due date will result in a 0. '''

If you do not include a link to your group portion running on your instance in your group portion README.md, you will receive a 0 for the group portion
_________

# '''JavaScript Calculator (10 Points):'''
#* Calculator successfully adds, subtracts, multiplies, and divides numbers (3 points)
#* The result is automatically computed when a value in either field is changed (3 points)
#* Calculator is written entirely in pure, conventional JavaScript with no external libraries (4 points)*
#*: ''Note: be sure to fully separate content, appearance, and behavior. This means that you should '''not''' use the event attributes on the HTML elements like onclick, onchange, and onkeyup.''
# '''Weather Widget (15 Points):'''
#* Widget performs an AJAX request to fetch the current weather (4 points)
#* The HTML template is filled with the correct information, including an image (4 points)
#* Button to reload the weather widget (2 points)
#* Widget is written entirely in pure, conventional JavaScript with no external libraries (5 points)*
# '''AJAX Calendar (60 Points):'''
#* '''''Calendar View (10 Points):'''''
#** The calendar is displayed as a table grid with days as the columns and weeks as the rows, one month at a time (5 points)
#** The user can view different months as far in the past or future as desired (5 points)
#* '''''User and Event Management (25 Points):'''''
#** Events can be added, modified, and deleted (5 points)
#** Events have a title, date, and time (2 points)
#** Users can log into the site, and they cannot view or manipulate events associated with other users (8 points)
#**: ''Don't fall into the Abuse of Functionality trap! Check user credentials on the server side as well as on the client side.''
#** All actions are performed over AJAX, without ever needing to reload the page (10 points)
#* '''''Best Practices (20 Points):'''''
#** Code is well formatted and easy to read, with proper commenting (2 points)
#** If storing passwords, they are stored salted and encrypted (2 points)
#** All AJAX requests that either contain sensitive information or modify something on the server are performed via POST, not GET (3 points)
#** Safe from XSS attacks; that is, all content is escaped on output (3 points)
#** Safe from SQL Injection attacks (2 points)
#** CSRF tokens are passed when editing or removing events (3 points)
#** Session cookie is HTTP-Only (3 points)
#** Page passes the W3C validator (2 points)
#** ''Extra Credit:'' Your code passes ''JSHint'' or ''JSLint'' (+3 bonus points)
#* '''''Usability (5 Points):'''''
#** Site is intuitive to use and navigate (4 points)
#** Site is visually appealing (1 point)
# '''Creative Portion (15 Points)'''
#* '''Additional Calendars Features (worth 15 points):''' Develop some additional features for the calendar, a few examples are provided below.
#** Users can tag an event with a particular category and enable/disable those tags in the calendar view. (5 points)
#** Users can share their calendar with additional users. (5 points)
#** Users can create group events that display on multiple users calendars (5 points)
#* '''Make sure to save a description of your creative portion, and a link to your server in your README.md file.'''
''* These points can be earned only if at least 3 other points have been earned in that category. This is to prevent these points from being "free."''

[[Category:Module 5]]
[[Category:Modules]]

Web Application Security, Part 2

2018-02-25T20:26:59Z

Alex: /* Example */

This is Part 2 of the Web Application Security article, geared toward the material covered in [[Module 3]]. For material covered in [[Module 2]] (HTML, CSS, and PHP), see [[Web Application Security, Part 1]]. For material covered in [[Module 6]] (JavaScript), see [[Web Application Security, Part 3]].

== Password Security ==

Let's assume for a moment that despite all of your efforts in the other fronts of web security, an attacker was still able to extract information from your database. If you store your passwords as plain text, not only will the attacker be able to log in as whomever he chooses, but the attacker will ''also'' likely be able to log in as the users of your site on different sites (since many users employ the same password on several different web sites).

=== Hashing ===

In cryptography, a ''hash function'' is a function which maps an input to an output in a way that is (hopefully) impossible to undo.
In other words, if you have the hashed version of a password and you want to figure out what password could've been used to create it, your only option is to try every possible password until one matches. With a secure hash function and strong password, that process will take many millions of years.

In web development, you should '''always''' store the hashed version of passwords. What this means is that you feed a string of text (a password) to a hash function, and that hash function returns another string of text that is a ''digest'' or ''hash'' of the password, and that ''digest'' is what you'll store in your database. The reason we use them is so that, if someone evil ever gains access to your database, they won't be able to easily figure out what passwords your users used for your website. People tend to reuse passwords, so a breach at your site could easily become a breach at other sites, too.

An important thing to note is that cryptographic hashes always have constant length, meaning that, in your database, you should be using a field of a fixed length to store them if you're using a fixed hashing algorithm. Because you're only storing the hashed version of a password, and not the original, it doesn't matter to you how big the original password was; you don't have to store it! As a result, if you ever see a website that limits your password to, say, 20 characters, that's a good sign that they're insecurely storing your password in plaintext.

Now, hashing is very important, but, by itself, it can be vulnerable to precomputation attacks, because a given string will always hash to the same value. In other words, an attacker could assemble a list of common passwords and their hashes, and simply look for those hashes in your database, saving them the work of trying to break each hash individually. To defend against such attacks, hashing algorithms can be used with so-called ''salts'' to increase their security. What this means is that the string to be hashed is modified using a randomly generated chunk of data called a ''salt'' before the hashing takes place. The salt is stored with the hash in the database, and, when a user enters their password, it is combined with the salt before the hash function is applied. The resulting hash defeats precomputation attacks, because it means that a given password no longer hashes to the same value across multiple databases, but as long as you're hashing the same string with the same salt, you'll always get the same results.

[[File:xkcd_221.png|xkcd 221]]

=== Solution ===

So, the solution is to store salted, hashed passwords in your database. PHP provides the [https://secure.php.net/manual/en/function.password-hash.php password-hash()] function to do this for you.

'''<code>password_hash</code> is only available in PHP 5.5 or newer.'''

Note that, as part of generating a more secure hash, <code>password_hash</code> will output a longer hash, so make sure your database field is large enough to hold the whole hash - as of PHP 5.6, 61 characters or larger will do the trick.

How does they work? They're both automagical functions that use a random salt and hash your password. <code>password_hash</code> Takes two arguments: the string to hash and a constant representing the hashing algorithm to use. Let's look at a few examples.

<source lang="php">
<?php

echo password_hash("Hello World", PASSWORD_BCRYPT);
/*
* The above line prints, for example: $2y$10$hfd4bRj2w2shMdxVZc7MEu3uZoXU7CNUEmUhWCEJB11xO8vTc8ply
* This line is of the format: $2$random-salt$hashed-password
* Note that the actual hash generated will be different if you run this, because of a different random salt.
*/
?>
</source>

As you can see from the above example, '''The functions generate a string that contains ''both'' a random salt ''and'' the hashed password.'''

====Password Storage====
You should store the constant-length value in a <code>CHAR</code> field in your database, and then have just one field for both the password and the salt.

A note about <code>password_hash</code>: If you always want to use the latest recommended hashing algorithm, you can specify PASSWORD_DEFAULT as your
hashing algorithm. As of PHP 7 and below, <code>PASSWORD_DEFAULT</code> is equivalent to <code>PASSWORD_BCRYPT</code>, but that may change in future versions. Because it's possible that a future hashing algorithm may produce larger hashes than BCrypt does, the maintainers of PHP recommend you use a field that can handle hashes of up to 255 characters in length. '''If, and only if you choose to use <code>PASSWORD_DEFAULT</code>, you may use a variable-length field that can hold 255 characters to store your hashes.''' In MySQL, for example, a field of type <code>VARCHAR(255)</code> would be acceptable here. However, because (during the timeframe of this class) there will not be any changes to the hashing algorithms used, you may still use a fixed-length field.

=== Checking Passwords ===
To check a password, one might simply compare the hash of the password a user inputs against the hash stored in your database using normal string comparison (i.e. the == operator). If they're the same, you're all set. Simple enough, right? Wrong. The fact is, security is really, really hard, and there are lots of things you have to be aware of in a security context that you don't normally need to worry about.

In this case, the == operator exposes you to what's called a timing attack. The string comparison algorithm used by == returns false as soon as a character is different in the two strings, meaning that, if the two strings have a different first character, it will return earlier than if they have a different last character. Normally, this is a good thing; it makes your code run faster. In this context, though, it's a bad thing, because an attacker can time how long the function takes to run, and, using that information, guess the characters of the string.

As an extra bit of fun, the == operator exhibits some behavior that's less than intuitive.

Try to guess what the output would be if you were to run the following code:

<source lang="php">
$a = "0e153958235710973524115407854157";
$b = "0e015339760548602306096794382326";
if ($a == $b) {
echo "Passwords Match!";
} else {
echo "Passwords Don't Match!";
}
</source>

Believe it or not, that snippet of code will output "Passwords Match!". The reason for this is that the == operator tries to convert strings to other types before testing their equality. In this case, the two strings both start with "0e", which PHP treats as the beginning of a floating-point number written in scientific notation (e.g. 2e10 == 2 * pow(10, 10)). Because the part of each string after the "0e" is an invalid exponent, PHP interprets the entire thing as 0. That's right: both $a and $b evaluate to 0, so the comparison is true.

In a security situation, that's a terrible thing - any passwords with hashes that start with 0e will always be reported as equal to one another.

Luckily, PHP, starting in version 5.5, has your back, with a function that solves both the problems above. You can use the [https://secure.php.net/manual/en/function.password-verify.php password_verify()] function to check a password securely.

=== Example ===

Here is an example of what you might do on your login page. '''''Note:'' This example assumes that you hashed the user's password already and stored it in the database.'''

<source lang="php">
<?php
// This is a *good* example of how you can implement password-based user authentication in your web application.

require 'database.php';

// Use a prepared statement
$stmt = $mysqli->prepare("SELECT COUNT(*), id, hashed_password FROM users WHERE username=?");

// Bind the parameter
$stmt->bind_param('s', $user);
$user = $_POST['username'];
$stmt->execute();

// Bind the results
$stmt->bind_result($cnt, $user_id, $pwd_hash);
$stmt->fetch();

$pwd_guess = $_POST['password'];
// Compare the submitted password to the actual password hash

if($cnt == 1 && password_verify($pwd_guess, $pwd_hash)){
// Login succeeded!
$_SESSION['user_id'] = $user_id;
// Redirect to your target page
} else{
// Login failed; redirect back to the login screen
}
?>
</source>

'''Note:''' You may sometimes see functions like vanilla [http://php.net/md5 md5()] or [http://php.net/crypt crypt()] used to hash passwords. md5() does indeed perform one-way hashing, but it does so without a salt. '''THIS IS BAD PRACTICE''', because unsalted md5 hashes can be trivially reversed using a rainbow table. (Just Google for "md5 decrypter".) Using a salt prevents the effective use of a rainbow table. Additionally, '''the md5 function, even with a salt, should not be used because it has been proved vulnerable.'''

=== Real-Life Examples ===

Here is a constantly-updated list of sites that do not use proper password security: http://plaintextoffenders.com/

== Cross-Site Request Forgery ==

{{DoctypeTV
|youtube_id=3IOKaIRg8V4
|time=3m45s
|desc=Cross Site Request Forgeries
}}

A cross-site request forgery (CSRF, pronounced ''sea-surf'') involves a victim, who is logged in to the targeted site, visiting an attacker’s site. The attacker has code on his site that forces the victim to unwittingly perform actions on the targeted site.

For example, suppose Mother Goose visited Dr. Evil's blog. Dr. Evil had the following tag embedded in his bloc:

<nowiki><img src="http://www.bank.com/transfer.php?dest=dr-evil&amount=5000" /></nowiki>

This would cause Mother Goose to authorize a $5000 transfer to Dr. Evil, completely without Mother Goose's knowledge!

Worse yet, Dr. Evil could just send an e-mail to Mother Goose with this image tag. All Mother Goose would need to do to be attacked is open the e-mail! (Now you know why sometimes your e-mail client turns off images from suspicious sources.)

=== Solution ===

The first precautionary measure is to always use POST requests (as opposed to GET requests) for actions that change something on your server. This will fend off all except the most hard-core CSRF attacks.

However, fully preventing CSRF attacks is not difficult. To do this, you can use a '''CSRF token'''. A CSRF token is a known string of text that is submitted in all of the forms on your site. If the string is not what you expect, then you can assume that the request was forged.

For example, consider this form:

<source lang="html4strict">
<form action="transfer.php">
<input type="text" name="dest" />
<input type="number" name="amount" />
<input type="submit" value="Transfer" />
</form>
</source>

We can easily add a hidden CSRF token field like so (as well as making the form POST rather than GET):

<source lang="html4strict">
<form action="transfer.php" method="post">
<input type="text" name="dest" />
<input type="number" name="amount" />
<input type="hidden" name="token" value="<?php echo $_SESSION['token'];?>" />
<input type="submit" value="Transfer" />
</form>
</source>

'''This assumes that <code>$_SESSION['token']</code> contains an alphanumeric string that was randomly generated upon session creation.''' For example, you could add this line ''beneath beneath where the user successfully authenticates'':

<source lang="php">
$_SESSION['token'] = bin2hex(openssl_random_pseudo_bytes(32)); // generate a 32-byte random string
// In PHP 7, you can use the following, better technique:
// $_SESSION['token'] = bin2hex(random_bytes(32));
</source>

We can now test for validity of the CSRF token on the server side (in transfer.php):

<source lang="php">
<?php
$destination_username = $_POST['dest'];
$amount = $_POST['amount'];
if(!hash_equals($_SESSION['token'], $_POST['token'])){
die("Request forgery detected");
}
$mysqli->query(/* perform transfer */);
?>
</source>

Now, if Mother Goose were to view a page containing the malicious <code><img></code> tag, the transfer would not take place.

=== Real-Life Examples ===

* [http://www.zdnet.com/no-data-breach-in-first-weibo-attack-2062301014/ Weibo, June 2011]
* [http://www.huffingtonpost.com/huff-wires/20110601/us-tec-google-hacking-attack/ Gmail, June 2011]
* [http://www.pcworld.com/businesscenter/article/228609/hackers_steal_hotmail_messages_thanks_to_web_flaw.html Hotmail, May 2011]
* [http://www.theregister.co.uk/2010/05/19/facebook_private_data_leak/ Facebook, May 2010]

== SQL Injection ==

[[File:Exploits of a mom.png]]

SQL injection occurs when an attacker submits specially-crafted input into your server, which is then included in an SQL query. The input modifies the query to perform additional actions on the database or to access unwanted information.

For instance, suppose you had the following code:

<source lang="php">
<?php
require 'database.php';

/* DISCLAIMER: THIS CODE IS BAD IN MANY MORE WAYS THAN JUST
BEING VULNERABLE TO SQL INJECTION! IT IS FOR DEMONSTRATION OF
CONCEPT ONLY. DO NOT USE THIS CODE IN YOUR OWN PROJECTS! */

$res = $mysqli->query("SELECT id FROM users WHERE username='".$_POST['username']."' AND password='".$_POST['password']."'");

if( $res->num_rows==1 ){
    $row = $res->fetch_assoc();
    $_SESSION['user_id'] = $row["id"];
}else{
    echo "Login failed.";
    exit;
}
?>
</source>

This code is vulnerable to SQL injection. For example, suppose the attacker used the following string of text for his username:

mother-goose' --

Here's what the resulting query would look like:

<source lang="mysql">
SELECT id FROM users WHERE username='mother-goose' --' AND password=''
</source>

Since <code>--</code> is the start of a comment in SQL, when MySQL interprets this query, it will ''completely ignore'' the password-checking part of the query! Dr. Evil can log in using anyone's username and steal all of their money!

=== Solution ===

If you write your queries manually (as in the example above), you need to use <code>$mysqli->real_escape_string()</code> to sanitize your input:

<source lang="php">
<?php
$safe_username = $mysqli->real_escape_string($_POST['username']);
// ...
?>
</source>

However, the better solution is to use prepared queries. For more information on prepared queries, see [[PHP and MySQL]].

'''IMPORTANT:''' If you correctly use the sample code in the PHP and MySQL guide above, you are already safe from SQL injection attacks.

=== Real-Life Examples ===

* [http://www.zdnet.com/unknowns-hack-european-space-agency-4010026071/ European Space Agency, May 2012]
* [http://www.dutchnews.nl/news/archives/2012/04/new_online_medical_records_sca.php Dutch Department Stores, April 2012]
* [http://www.msnbc.msn.com/id/46735808/ns/technology_and_science-security/ Ancestry.com, March 2012]
* [http://www.scmagazine.com.au/News/292592,allphones-hacked-staff-passwords-exposed.aspx Allphones (Australian Telecommunications Retailer), March 2012]
* [http://www.abc4.com/content/news/slc/story/More-fallout-Salt-Lake-City-police-website-hacked/PiSspE768UiioitJ3K4gyQ.cspx Salt Lake City Police Department, February 2012]

== Abuse of Functionality ==

''Abuse of Functionality'' is a general term that refers to when an attacker exploits vulnerabilities in the logic of your application.

For example, suppose you were a banking site, and you had the following code to perform a transaction:

<source lang="php">
<?php
require 'database.php';

$amount = (double) $_POST['amount'];
$destination_username = $mysqli->real_escape_string($_POST['destination']);

$mysqli->autocommit(false); // start transaction
$mysqli->query("UPDATE users SET balance=balance-".$amount."
WHERE id=".$_SESSION['user_id']);
$mysqli->query("UPDATE users SET balance=balance+".$amount."
WHERE username='".$destination_username."'");
$mysqli->commit(); // commit transaction
?>
</source>

It may not be obvious, but if you don't filter your input, it is trivial for an attacker to ''insert a negative number'' into the "amount" field and transfer money from anyone's account to his account! The solution here is to simply filter amount for what you expect (in this case, a positive number that is not greater than the user's current balance).

=== Filtering on the Client Side is Never Enough ===

Suppose you have an e-mail field in a form in HTML, and you use some JavaScript function (or HTML5) to check it for form as an e-mail address:

<source lang="html4strict">
<input type="text" name="email" onchange="checkEmail(this);" /> 

<input type="email" name="email" /> 
</source>

With this filter in place, any layperson using your form is now required to submit an e-mail address in that field. ''However'', it is trivial for an attacker to bypass this client-side filtering (e.g., by using web developer tools like Firebug) and still submit non-email text to your server. This is why '''IT IS ESSENTIAL THAT YOU FILTER INPUT ON THE SERVER SIDE! Any sort of filtering on the client side are just bells and whistles for the end user.'''

=== Information Leakage ===

''Information Leakage'' is a noteworthy type of ''Abuse of Functionality'' attack that involves unprivileged users accessing privileged information. In fact, Information Leakage accounts for a significant percentage of all recorded web application vulnerabilities (second only to Cross-Site Scripting).

The concept is relatively simple. Suppose you have an administration page that loads an image containing a graph of all activity on your site:

'''admin.php'''
<source lang="php">
<?php
if($_SESSION['admin']) echo '<img src="stats.php?day=2012-08-19" alt="Stats for 2012-08-19" />';
?>
</source>

'''stats.php'''
<source lang="php">
<?php
// query the database, and save the results in $result

$im = new PNGraph();
$im->takeData($result);

header("Content-Type: image/png");
print $im->toString();
?>
</source>

Notice how you check for admin credentials in ''admin.php''. However, you forgot to do this in ''stats.php'' itself. An attacker could simply load ''stats.php'' directly to see all of the sensitive admin-only information!

==== Solution ====

Information Leakage is an attack that requires the developer to see the big picture and really keep track of what's going on in his or her application. As a rule of thumb, ''whenever'' you query the database to access sensitive information, check the permissions of the user first.

=== A Note about Frameworks ===

Web frameworks are designed to make web development more agile, but they in turn have security weaknesses of their own. For instance, the infamous ''mass-assignment vulnerability'' in Ruby on Rails-type MVC frameworks is an abuse of functionality vulnerability that enables attackers to save arbitrary information in your database (!).

The important thing to know is that '''if you use a web framework, be familiar with the security considerations with that framework'''. Most of the time, frameworks will have articles on their web sites that discuss these concerns. (If your framework doesn't have a guide like this, you should probably be using a different framework!)

=== Real-Life Examples ===

* [http://gizmodo.com/some-guy-figured-out-how-to-delete-every-photo-on-faceb-1685491356 Facebook, February 2015 (bypassing authorization on REST API calls)]
* [http://www.whitec0de.com/new-hotmail-exploit-can-get-any-hotmail-email-account-hacked-for-just-20/ Hotmail, April 2012 (parameter manipulation)]
* [http://www.theregister.co.uk/2012/04/18/toshiba_slapped_by_ico/ Toshiba, April 2012 (parameter manipulation / information leakage)]
* [http://www.zdnet.com/blog/security/3-million-bank-accounts-hacked-in-iran/11577 Iranian Banks, April 2012 (information leakage)]
* [http://www.zdnet.com/blog/security/hacker-steals-chinese-government-defense-contracts/11386 Chinese Department of Defense, April 2012 (information leakage)]
* [http://articles.chicagotribune.com/2012-04-04/news/sns-rt-us-usa-hackers-utahbre83404g-20120404_1_data-security-breach-cyber-attack-hackers Utah Medicaid, April 2012]

== CAPTCHA Abuse ==

CAPTCHAs are a great way to stop robots from submitting forms in your web application. However, depending on how you implement CAPTCHAs, it might be possible for a hacker to bypass the CAPTCHA on your site.

For example, suppose you are making a home-grown CAPTCHA system for your application. You have a table '''CaptchaTable''' with the following fields: '''id''' and '''value'''. Your form looks like this:

<source lang="html4strict">
<form action="signup.php" method="post">
<strong>Subscribe to our newsletter</strong>
<input type="email" name="email" placeholder="Enter Your Email Here" />
<input type="text" name="captcha_value" placeholder="Type what you see in the CAPTCHA below." />
<img src="captcha.php?id=12345" />
<input type="hidden" name="captcha_id" value="12345" />
<input type="submit" value="Sign Up" />
</form>
</source>

Here's what the code on ''signup.php'' might look like:

<source lang="php">
<?php
$email = $_POST["email"];
$captcha_id = (int) $_POST["captcha_id"];
$captcha_value = $_POST["captcha_value"];

// check CAPTCHA

$captcha_stmt = $mysqli->prepare("select count(*) as match from CaptchaTable where id=? and value=?");
$captcha_stmt->bind_param("is", $captcha_id, $captcha_value);
$captcha_stmt->execute();
$captcha_row = (int) $captcha_stmt->fetch_assoc();
$captcha_stmt->close();

if ($captcha_row["match"] == 0){
http_response_code(403);
echo "Invalid CAPTCHA";
exit;
}

// continue with signup procedure down here
?>
</source>

The issue here is that a hacker can simply solve one CAPTCHA and then send that CAPTCHA ID and Value over and over again!

=== Solution ===

If you already have a home-grown CAPTCHA system, the best solution here would be to simply issue another query to the database that deletes a CAPTCHA id-value pair as soon as it is submitted in a form.

If you haven't yet implemented your CAPTCHA system, you might want to consider a third-party solution like [http://www.google.com/recaptcha reCAPTCHA].

[[Category:Module 3]]
[[Category:Web Application Security]]

Module 4

2018-02-21T17:32:15Z

Alex: /* Grading */

__NOTOC__
In Module 4, you will learn the fundamentals of Python, a popular scripting language, and Regular Expressions, which give you power in text processing.

This article contains your assignments for Module 4.

== Reading ==

The following articles on the online class wiki textbook contain information that will help you complete the assignments.

* [[Python]]
* [[Regular Expressions]]

== Individual Assignments ==

=== Learn Python and Regular Expressions ===

Up to this point in CSE 330, you have used only one programming language: PHP. In Module 4, you will learn a new language: Python. Before starting this assignment, you should look over the [[Python|online textbook article about Python]]. You should be using version 3 (or greater) of Python. Additionally, you may find it helpful to look over the [[Regular Expressions|online textbook article about Regular Expressions]].

=== Write some Regular Expressions ===

Please write regular expressions that do each the following:

# Match the substring "hello world" in string.
# Find all words in an input string that contains three consecutive vowels, regardless of case.
# Match an input string that is '''entirely''' a flight code, of the format AA####, where '''AA''' is a two-letter uppercase airline code, and '''####''' is a three- or four-digit flight number.
Examples:
Note: text in ''[[red]]'' is matched by the regular expression. Each line is a separate test input string.
Regex 1: Programmers will often write ''[[hello world]]'' as their first project with a programming language.
Regex 2: The ''[[gooey]]'' peanut butter and jelly sandwich was a ''[[beauty]]''.
Regex 3: ''[[AA312]]''
''[[AA1298]]''
''[[NW1234]]''
''[[US443]]''
US31344
AA123 extratext

Save your regexes to text files – one each.

=== Baseball Stats Counter ===

The St. Louis Cardinals are the most legendary baseball team in the national league. In this exercise, you will be creating a Python script that reads box scores from a file and computes the Cardinals' players' batting averages in a particular season.

==== Tips and Instructions ====

* You should write a Python script file to solve this problem.
* You should use a regular expression to parse players' names, at-bats, hits, and runs from the input file.
* You may want to create a class to hold and compute information about each player.
* Your file should take one command-line argument: the path to an input file. If no path is given, your program should print a usage message.

==== Input ====

Sample input files may be found here: http://classes.engineering.wustl.edu/cse330/content/cardinals/

The top of the file contains a citation, and what follows is an entire season of Cardinals Baseball box scores. Each game starts with a title; for example:

=== St.Louis Cardinals vs. Chicago Cubs, 1940-04-19 ===

What follows are the performance of each player in that game. The format of each line is as follows:

XXX batted # times with # hits and # runs

where '''XXX''' is the player's name (you may assume that the name is unique), and each '''#''' are integers representing the number of "at bats", the number of "hits", and the number of "runs", respectively.

==== Output ====

Your script needs to output all players' batting average across the season. A player's batting average is that player's total hits divided by that player's total at-bats throughout the entire season. For example, Johnny Hopp was at bat 149 times in 1940, and he had 41 hits, so his batting average was 0.275.

Each line in the output should have the format:

XXX: #.###

where '''XXX''' is the player's name, and '''#.###''' is the player's batting average, '''rounded''' (not truncated) to three decimal places.

The players should be sorted by batting average, with the highest batting average on top. If two players have the exact same batting average (before rounding occurs), the order between those two players is unimportant.

For example, the correct output for the 1940 season is:

<source lang="text">
Pepper Martin: 0.316
Walker Cooper: 0.316
Johnny Mize: 0.314
Ernie Koy: 0.310
Enos Slaughter: 0.306
Joe Medwick: 0.304
Terry Moore: 0.304
Joe Orengo: 0.286
Jimmy Brown: 0.280
Marty Marion: 0.279
Don Gutteridge: 0.276
Johnny Hopp: 0.275
Creepy Crespi: 0.273
Mickey Owen: 0.265
Bill DeLancey: 0.250
Don Padgett: 0.242
Stu Martin: 0.238
Eddie Lake: 0.222
Hal Epps: 0.214
Lon Warneke: 0.209
Harry Walker: 0.185
Max Lanier: 0.179
Bill McGee: 0.178
Carl Doyle: 0.174
Mort Cooper: 0.157
Clyde Shoun: 0.145
Carden Gillenwater: 0.130
Bob Bowman: 0.067
</source>

== Grading ==

We will be grading the following aspects of your work. There are 50 points total.

'''Assignments (including code) must be committed to Bitbucket by the end of class on the due date (commit early and often). Failing to commit by the end of class on the due date will result in a 0. '''

Upload your baseball code and a file with your Regular expressions.

# '''Regular Expressions (15 Points):'''
#* '''Your regex files should contain your regex (with no delimiters) and nothing else.'''
#* Regular Expression 1 Correct and saved in a file named <code>regex1.txt</code> (5 points)
#* Regular Expression 2 Correct and saved in a file named <code>regex2.txt</code>(5 points)
#* Regular Expression 3 Correct and saved in a file named <code>regex3.txt</code>(5 points)
# '''Baseball Stats Counter (35 Points):'''
#* Solution is written entirely in Python and saved in a file named <code>baseball.py</code> (8 points)
#*: ''Note: Failing to write your code in Python 3 will result is losing, at a minimum, points for this category.''
#* Correct usage of one or more regular expressions to parse and extract data from each line of the input file (8 points)
#*: ''Note: You should not be using <code>str.split</code> to extract data.''
#* Script prints a usage message if a command line argument is not present (4 points)
#*: ''Note: For an example of a usage message, see [https://en.wikipedia.org/wiki/Usage_message#Examples this link.]''
#* Output is correct for all test cases (15 points)
#*: ''This includes sorting and rounding.''

[[Category:Module 4]]
[[Category:Modules]]

Module 4

2018-02-21T17:29:24Z

Alex: /* Grading */

__NOTOC__
In Module 4, you will learn the fundamentals of Python, a popular scripting language, and Regular Expressions, which give you power in text processing.

This article contains your assignments for Module 4.

== Reading ==

The following articles on the online class wiki textbook contain information that will help you complete the assignments.

* [[Python]]
* [[Regular Expressions]]

== Individual Assignments ==

=== Learn Python and Regular Expressions ===

Up to this point in CSE 330, you have used only one programming language: PHP. In Module 4, you will learn a new language: Python. Before starting this assignment, you should look over the [[Python|online textbook article about Python]]. You should be using version 3 (or greater) of Python. Additionally, you may find it helpful to look over the [[Regular Expressions|online textbook article about Regular Expressions]].

=== Write some Regular Expressions ===

Please write regular expressions that do each the following:

# Match the substring "hello world" in string.
# Find all words in an input string that contains three consecutive vowels, regardless of case.
# Match an input string that is '''entirely''' a flight code, of the format AA####, where '''AA''' is a two-letter uppercase airline code, and '''####''' is a three- or four-digit flight number.
Examples:
Note: text in ''[[red]]'' is matched by the regular expression. Each line is a separate test input string.
Regex 1: Programmers will often write ''[[hello world]]'' as their first project with a programming language.
Regex 2: The ''[[gooey]]'' peanut butter and jelly sandwich was a ''[[beauty]]''.
Regex 3: ''[[AA312]]''
''[[AA1298]]''
''[[NW1234]]''
''[[US443]]''
US31344
AA123 extratext

Save your regexes to text files – one each.

=== Baseball Stats Counter ===

The St. Louis Cardinals are the most legendary baseball team in the national league. In this exercise, you will be creating a Python script that reads box scores from a file and computes the Cardinals' players' batting averages in a particular season.

==== Tips and Instructions ====

* You should write a Python script file to solve this problem.
* You should use a regular expression to parse players' names, at-bats, hits, and runs from the input file.
* You may want to create a class to hold and compute information about each player.
* Your file should take one command-line argument: the path to an input file. If no path is given, your program should print a usage message.

==== Input ====

Sample input files may be found here: http://classes.engineering.wustl.edu/cse330/content/cardinals/

The top of the file contains a citation, and what follows is an entire season of Cardinals Baseball box scores. Each game starts with a title; for example:

=== St.Louis Cardinals vs. Chicago Cubs, 1940-04-19 ===

What follows are the performance of each player in that game. The format of each line is as follows:

XXX batted # times with # hits and # runs

where '''XXX''' is the player's name (you may assume that the name is unique), and each '''#''' are integers representing the number of "at bats", the number of "hits", and the number of "runs", respectively.

==== Output ====

Your script needs to output all players' batting average across the season. A player's batting average is that player's total hits divided by that player's total at-bats throughout the entire season. For example, Johnny Hopp was at bat 149 times in 1940, and he had 41 hits, so his batting average was 0.275.

Each line in the output should have the format:

XXX: #.###

where '''XXX''' is the player's name, and '''#.###''' is the player's batting average, '''rounded''' (not truncated) to three decimal places.

The players should be sorted by batting average, with the highest batting average on top. If two players have the exact same batting average (before rounding occurs), the order between those two players is unimportant.

For example, the correct output for the 1940 season is:

<source lang="text">
Pepper Martin: 0.316
Walker Cooper: 0.316
Johnny Mize: 0.314
Ernie Koy: 0.310
Enos Slaughter: 0.306
Joe Medwick: 0.304
Terry Moore: 0.304
Joe Orengo: 0.286
Jimmy Brown: 0.280
Marty Marion: 0.279
Don Gutteridge: 0.276
Johnny Hopp: 0.275
Creepy Crespi: 0.273
Mickey Owen: 0.265
Bill DeLancey: 0.250
Don Padgett: 0.242
Stu Martin: 0.238
Eddie Lake: 0.222
Hal Epps: 0.214
Lon Warneke: 0.209
Harry Walker: 0.185
Max Lanier: 0.179
Bill McGee: 0.178
Carl Doyle: 0.174
Mort Cooper: 0.157
Clyde Shoun: 0.145
Carden Gillenwater: 0.130
Bob Bowman: 0.067
</source>

== Grading ==

We will be grading the following aspects of your work. There are 50 points total.

'''Assignments (including code) must be committed to Bitbucket by the end of class on the due date (commit early and often). Failing to commit by the end of class on the due date will result in a 0. '''

Upload your baseball code and a file with your Regular expressions.

# '''Regular Expressions (15 Points):'''
#* '''Your regex files should contain your regex (with no delimiters) and nothing else.'''
#* Regular Expression 1 Correct and saved in a file named <code>regex1.txt</code> (5 points)'
#* Regular Expression 2 Correct and saved in a file named <code>regex2.txt</code>(5 points)
#* Regular Expression 3 Correct and saved in a file named <code>regex3.txt</code>(5 points)
# '''Baseball Stats Counter (35 Points):'''
#* Solution is written entirely in Python and saved in a file named <code>baseball.py</code> (8 points)
#*: ''Note: Failing to write your code in Python 3 will result is losing, at a minimum, points for this category.''
#* Correct usage of one or more regular expressions to parse and extract data from each line of the input file (8 points)
#*: ''Note: You should not be using <code>str.split</code> to extract data.''
#* Script prints a usage message if a command line argument is not present (4 points)
#*: ''Note: For an example of a usage message, see [https://en.wikipedia.org/wiki/Usage_message#Examples this link.]''
#* Output is correct for all test cases (15 points)
#*: ''This includes sorting and rounding.''

[[Category:Module 4]]
[[Category:Modules]]

Module 4

2018-02-21T17:28:58Z

Alex: /* Grading */

__NOTOC__
In Module 4, you will learn the fundamentals of Python, a popular scripting language, and Regular Expressions, which give you power in text processing.

This article contains your assignments for Module 4.

== Reading ==

The following articles on the online class wiki textbook contain information that will help you complete the assignments.

* [[Python]]
* [[Regular Expressions]]

== Individual Assignments ==

=== Learn Python and Regular Expressions ===

Up to this point in CSE 330, you have used only one programming language: PHP. In Module 4, you will learn a new language: Python. Before starting this assignment, you should look over the [[Python|online textbook article about Python]]. You should be using version 3 (or greater) of Python. Additionally, you may find it helpful to look over the [[Regular Expressions|online textbook article about Regular Expressions]].

=== Write some Regular Expressions ===

Please write regular expressions that do each the following:

# Match the substring "hello world" in string.
# Find all words in an input string that contains three consecutive vowels, regardless of case.
# Match an input string that is '''entirely''' a flight code, of the format AA####, where '''AA''' is a two-letter uppercase airline code, and '''####''' is a three- or four-digit flight number.
Examples:
Note: text in ''[[red]]'' is matched by the regular expression. Each line is a separate test input string.
Regex 1: Programmers will often write ''[[hello world]]'' as their first project with a programming language.
Regex 2: The ''[[gooey]]'' peanut butter and jelly sandwich was a ''[[beauty]]''.
Regex 3: ''[[AA312]]''
''[[AA1298]]''
''[[NW1234]]''
''[[US443]]''
US31344
AA123 extratext

Save your regexes to text files – one each.

=== Baseball Stats Counter ===

The St. Louis Cardinals are the most legendary baseball team in the national league. In this exercise, you will be creating a Python script that reads box scores from a file and computes the Cardinals' players' batting averages in a particular season.

==== Tips and Instructions ====

* You should write a Python script file to solve this problem.
* You should use a regular expression to parse players' names, at-bats, hits, and runs from the input file.
* You may want to create a class to hold and compute information about each player.
* Your file should take one command-line argument: the path to an input file. If no path is given, your program should print a usage message.

==== Input ====

Sample input files may be found here: http://classes.engineering.wustl.edu/cse330/content/cardinals/

The top of the file contains a citation, and what follows is an entire season of Cardinals Baseball box scores. Each game starts with a title; for example:

=== St.Louis Cardinals vs. Chicago Cubs, 1940-04-19 ===

What follows are the performance of each player in that game. The format of each line is as follows:

XXX batted # times with # hits and # runs

where '''XXX''' is the player's name (you may assume that the name is unique), and each '''#''' are integers representing the number of "at bats", the number of "hits", and the number of "runs", respectively.

==== Output ====

Your script needs to output all players' batting average across the season. A player's batting average is that player's total hits divided by that player's total at-bats throughout the entire season. For example, Johnny Hopp was at bat 149 times in 1940, and he had 41 hits, so his batting average was 0.275.

Each line in the output should have the format:

XXX: #.###

where '''XXX''' is the player's name, and '''#.###''' is the player's batting average, '''rounded''' (not truncated) to three decimal places.

The players should be sorted by batting average, with the highest batting average on top. If two players have the exact same batting average (before rounding occurs), the order between those two players is unimportant.

For example, the correct output for the 1940 season is:

<source lang="text">
Pepper Martin: 0.316
Walker Cooper: 0.316
Johnny Mize: 0.314
Ernie Koy: 0.310
Enos Slaughter: 0.306
Joe Medwick: 0.304
Terry Moore: 0.304
Joe Orengo: 0.286
Jimmy Brown: 0.280
Marty Marion: 0.279
Don Gutteridge: 0.276
Johnny Hopp: 0.275
Creepy Crespi: 0.273
Mickey Owen: 0.265
Bill DeLancey: 0.250
Don Padgett: 0.242
Stu Martin: 0.238
Eddie Lake: 0.222
Hal Epps: 0.214
Lon Warneke: 0.209
Harry Walker: 0.185
Max Lanier: 0.179
Bill McGee: 0.178
Carl Doyle: 0.174
Mort Cooper: 0.157
Clyde Shoun: 0.145
Carden Gillenwater: 0.130
Bob Bowman: 0.067
</source>

== Grading ==

We will be grading the following aspects of your work. There are 50 points total.

'''Assignments (including code) must be committed to Bitbucket by the end of class on the due date (commit early and often). Failing to commit by the end of class on the due date will result in a 0. '''

Upload your baseball code and a file with your Regular expressions.

# '''Regular Expressions (15 Points):'''
#* '''Your regex files should contain your regex and nothing else (including delimiters and the like.)'''
#* Regular Expression 1 Correct and saved in a file named <code>regex1.txt</code> (5 points)'
#* Regular Expression 2 Correct and saved in a file named <code>regex2.txt</code>(5 points)
#* Regular Expression 3 Correct and saved in a file named <code>regex3.txt</code>(5 points)
# '''Baseball Stats Counter (35 Points):'''
#* Solution is written entirely in Python and saved in a file named <code>baseball.py</code> (8 points)
#*: ''Note: Failing to write your code in Python 3 will result is losing, at a minimum, points for this category.''
#* Correct usage of one or more regular expressions to parse and extract data from each line of the input file (8 points)
#*: ''Note: You should not be using <code>str.split</code> to extract data.''
#* Script prints a usage message if a command line argument is not present (4 points)
#*: ''Note: For an example of a usage message, see [https://en.wikipedia.org/wiki/Usage_message#Examples this link.]''
#* Output is correct for all test cases (15 points)
#*: ''This includes sorting and rounding.''

[[Category:Module 4]]
[[Category:Modules]]

Module 4

2018-02-21T17:24:37Z

Alex: /* Grading */ Added usage message example.

__NOTOC__
In Module 4, you will learn the fundamentals of Python, a popular scripting language, and Regular Expressions, which give you power in text processing.

This article contains your assignments for Module 4.

== Reading ==

The following articles on the online class wiki textbook contain information that will help you complete the assignments.

* [[Python]]
* [[Regular Expressions]]

== Individual Assignments ==

=== Learn Python and Regular Expressions ===

Up to this point in CSE 330, you have used only one programming language: PHP. In Module 4, you will learn a new language: Python. Before starting this assignment, you should look over the [[Python|online textbook article about Python]]. You should be using version 3 (or greater) of Python. Additionally, you may find it helpful to look over the [[Regular Expressions|online textbook article about Regular Expressions]].

=== Write some Regular Expressions ===

Please write regular expressions that do each the following:

# Match the substring "hello world" in string.
# Find all words in an input string that contains three consecutive vowels, regardless of case.
# Match an input string that is '''entirely''' a flight code, of the format AA####, where '''AA''' is a two-letter uppercase airline code, and '''####''' is a three- or four-digit flight number.
Examples:
Note: text in ''[[red]]'' is matched by the regular expression. Each line is a separate test input string.
Regex 1: Programmers will often write ''[[hello world]]'' as their first project with a programming language.
Regex 2: The ''[[gooey]]'' peanut butter and jelly sandwich was a ''[[beauty]]''.
Regex 3: ''[[AA312]]''
''[[AA1298]]''
''[[NW1234]]''
''[[US443]]''
US31344
AA123 extratext

Save your regexes to text files – one each.

=== Baseball Stats Counter ===

The St. Louis Cardinals are the most legendary baseball team in the national league. In this exercise, you will be creating a Python script that reads box scores from a file and computes the Cardinals' players' batting averages in a particular season.

==== Tips and Instructions ====

* You should write a Python script file to solve this problem.
* You should use a regular expression to parse players' names, at-bats, hits, and runs from the input file.
* You may want to create a class to hold and compute information about each player.
* Your file should take one command-line argument: the path to an input file. If no path is given, your program should print a usage message.

==== Input ====

Sample input files may be found here: http://classes.engineering.wustl.edu/cse330/content/cardinals/

The top of the file contains a citation, and what follows is an entire season of Cardinals Baseball box scores. Each game starts with a title; for example:

=== St.Louis Cardinals vs. Chicago Cubs, 1940-04-19 ===

What follows are the performance of each player in that game. The format of each line is as follows:

XXX batted # times with # hits and # runs

where '''XXX''' is the player's name (you may assume that the name is unique), and each '''#''' are integers representing the number of "at bats", the number of "hits", and the number of "runs", respectively.

==== Output ====

Your script needs to output all players' batting average across the season. A player's batting average is that player's total hits divided by that player's total at-bats throughout the entire season. For example, Johnny Hopp was at bat 149 times in 1940, and he had 41 hits, so his batting average was 0.275.

Each line in the output should have the format:

XXX: #.###

where '''XXX''' is the player's name, and '''#.###''' is the player's batting average, '''rounded''' (not truncated) to three decimal places.

The players should be sorted by batting average, with the highest batting average on top. If two players have the exact same batting average (before rounding occurs), the order between those two players is unimportant.

For example, the correct output for the 1940 season is:

<source lang="text">
Pepper Martin: 0.316
Walker Cooper: 0.316
Johnny Mize: 0.314
Ernie Koy: 0.310
Enos Slaughter: 0.306
Joe Medwick: 0.304
Terry Moore: 0.304
Joe Orengo: 0.286
Jimmy Brown: 0.280
Marty Marion: 0.279
Don Gutteridge: 0.276
Johnny Hopp: 0.275
Creepy Crespi: 0.273
Mickey Owen: 0.265
Bill DeLancey: 0.250
Don Padgett: 0.242
Stu Martin: 0.238
Eddie Lake: 0.222
Hal Epps: 0.214
Lon Warneke: 0.209
Harry Walker: 0.185
Max Lanier: 0.179
Bill McGee: 0.178
Carl Doyle: 0.174
Mort Cooper: 0.157
Clyde Shoun: 0.145
Carden Gillenwater: 0.130
Bob Bowman: 0.067
</source>

== Grading ==

We will be grading the following aspects of your work. There are 50 points total.

'''Assignments (including code) must be committed to Bitbucket by the end of class on the due date (commit early and often). Failing to commit by the end of class on the due date will result in a 0. '''

Upload your baseball code and a file with your Regular expressions.

# '''Regular Expressions (15 Points):'''
#* Regular Expression 1 Correct and saved in a file named <code>regex1.txt</code> (5 points)
#* Regular Expression 2 Correct and saved in a file named <code>regex2.txt</code>(5 points)
#* Regular Expression 3 Correct and saved in a file named <code>regex3.txt</code>(5 points)
# '''Baseball Stats Counter (35 Points):'''
#* Solution is written entirely in Python and saved in a file named <code>baseball.py</code> (8 points)
#*: ''Note: Failing to write your code in Python 3 will result is losing, at a minimum, points for this category.''
#* Correct usage of one or more regular expressions to parse and extract data from each line of the input file (8 points)
#*: ''Note: You should not be using <code>str.split</code> to extract data.''
#* Script prints a usage message if a command line argument is not present (4 points)
#*: ''Note: For an example of a usage message, see [https://en.wikipedia.org/wiki/Usage_message#Examples this link.]''
#* Output is correct for all test cases (15 points)
#*: ''This includes sorting and rounding.''

[[Category:Module 4]]
[[Category:Modules]]

Module 4

2018-02-21T16:57:47Z

Alex: /* Grading */

__NOTOC__
In Module 4, you will learn the fundamentals of Python, a popular scripting language, and Regular Expressions, which give you power in text processing.

This article contains your assignments for Module 4.

== Reading ==

The following articles on the online class wiki textbook contain information that will help you complete the assignments.

* [[Python]]
* [[Regular Expressions]]

== Individual Assignments ==

=== Learn Python and Regular Expressions ===

Up to this point in CSE 330, you have used only one programming language: PHP. In Module 4, you will learn a new language: Python. Before starting this assignment, you should look over the [[Python|online textbook article about Python]]. You should be using version 3 (or greater) of Python. Additionally, you may find it helpful to look over the [[Regular Expressions|online textbook article about Regular Expressions]].

=== Write some Regular Expressions ===

Please write regular expressions that do each the following:

# Match the substring "hello world" in string.
# Find all words in an input string that contains three consecutive vowels, regardless of case.
# Match an input string that is '''entirely''' a flight code, of the format AA####, where '''AA''' is a two-letter uppercase airline code, and '''####''' is a three- or four-digit flight number.
Examples:
Note: text in ''[[red]]'' is matched by the regular expression. Each line is a separate test input string.
Regex 1: Programmers will often write ''[[hello world]]'' as their first project with a programming language.
Regex 2: The ''[[gooey]]'' peanut butter and jelly sandwich was a ''[[beauty]]''.
Regex 3: ''[[AA312]]''
''[[AA1298]]''
''[[NW1234]]''
''[[US443]]''
US31344
AA123 extratext

Save your regexes to text files – one each.

=== Baseball Stats Counter ===

The St. Louis Cardinals are the most legendary baseball team in the national league. In this exercise, you will be creating a Python script that reads box scores from a file and computes the Cardinals' players' batting averages in a particular season.

==== Tips and Instructions ====

* You should write a Python script file to solve this problem.
* You should use a regular expression to parse players' names, at-bats, hits, and runs from the input file.
* You may want to create a class to hold and compute information about each player.
* Your file should take one command-line argument: the path to an input file. If no path is given, your program should print a usage message.

==== Input ====

Sample input files may be found here: http://classes.engineering.wustl.edu/cse330/content/cardinals/

The top of the file contains a citation, and what follows is an entire season of Cardinals Baseball box scores. Each game starts with a title; for example:

=== St.Louis Cardinals vs. Chicago Cubs, 1940-04-19 ===

What follows are the performance of each player in that game. The format of each line is as follows:

XXX batted # times with # hits and # runs

where '''XXX''' is the player's name (you may assume that the name is unique), and each '''#''' are integers representing the number of "at bats", the number of "hits", and the number of "runs", respectively.

==== Output ====

Your script needs to output all players' batting average across the season. A player's batting average is that player's total hits divided by that player's total at-bats throughout the entire season. For example, Johnny Hopp was at bat 149 times in 1940, and he had 41 hits, so his batting average was 0.275.

Each line in the output should have the format:

XXX: #.###

where '''XXX''' is the player's name, and '''#.###''' is the player's batting average, '''rounded''' (not truncated) to three decimal places.

The players should be sorted by batting average, with the highest batting average on top. If two players have the exact same batting average (before rounding occurs), the order between those two players is unimportant.

For example, the correct output for the 1940 season is:

<source lang="text">
Pepper Martin: 0.316
Walker Cooper: 0.316
Johnny Mize: 0.314
Ernie Koy: 0.310
Enos Slaughter: 0.306
Joe Medwick: 0.304
Terry Moore: 0.304
Joe Orengo: 0.286
Jimmy Brown: 0.280
Marty Marion: 0.279
Don Gutteridge: 0.276
Johnny Hopp: 0.275
Creepy Crespi: 0.273
Mickey Owen: 0.265
Bill DeLancey: 0.250
Don Padgett: 0.242
Stu Martin: 0.238
Eddie Lake: 0.222
Hal Epps: 0.214
Lon Warneke: 0.209
Harry Walker: 0.185
Max Lanier: 0.179
Bill McGee: 0.178
Carl Doyle: 0.174
Mort Cooper: 0.157
Clyde Shoun: 0.145
Carden Gillenwater: 0.130
Bob Bowman: 0.067
</source>

== Grading ==

We will be grading the following aspects of your work. There are 50 points total.

'''Assignments (including code) must be committed to Bitbucket by the end of class on the due date (commit early and often). Failing to commit by the end of class on the due date will result in a 0. '''

Upload your baseball code and a file with your Regular expressions.

# '''Regular Expressions (15 Points):'''
#* Regular Expression 1 Correct and saved in a file named <code>regex1.txt</code> (5 points)
#* Regular Expression 2 Correct and saved in a file named <code>regex2.txt</code>(5 points)
#* Regular Expression 3 Correct and saved in a file named <code>regex3.txt</code>(5 points)
# '''Baseball Stats Counter (35 Points):'''
#* Solution is written entirely in Python and saved in a file named <code>baseball.py</code> (8 points)
#*: ''Note: Failing to write your code in Python 3 will result is losing, at a minimum, points for this category.''
#* Correct usage of one or more regular expressions to parse and extract data from each line of the input file (8 points)
#*: ''Note: You should not be using <code>str.split</code> to extract data.''
#* Script prints a usage message if a command line argument is not present (4 points)
#* Output is correct for all test cases (15 points)
#*: ''This includes sorting and rounding.''

[[Category:Module 4]]
[[Category:Modules]]

Module 4

2018-02-21T16:55:44Z

Alex: /* Write some Regular Expressions */

__NOTOC__
In Module 4, you will learn the fundamentals of Python, a popular scripting language, and Regular Expressions, which give you power in text processing.

This article contains your assignments for Module 4.

== Reading ==

The following articles on the online class wiki textbook contain information that will help you complete the assignments.

* [[Python]]
* [[Regular Expressions]]

== Individual Assignments ==

=== Learn Python and Regular Expressions ===

Up to this point in CSE 330, you have used only one programming language: PHP. In Module 4, you will learn a new language: Python. Before starting this assignment, you should look over the [[Python|online textbook article about Python]]. You should be using version 3 (or greater) of Python. Additionally, you may find it helpful to look over the [[Regular Expressions|online textbook article about Regular Expressions]].

=== Write some Regular Expressions ===

Please write regular expressions that do each the following:

# Match the substring "hello world" in string.
# Find all words in an input string that contains three consecutive vowels, regardless of case.
# Match an input string that is '''entirely''' a flight code, of the format AA####, where '''AA''' is a two-letter uppercase airline code, and '''####''' is a three- or four-digit flight number.
Examples:
Note: text in ''[[red]]'' is matched by the regular expression. Each line is a separate test input string.
Regex 1: Programmers will often write ''[[hello world]]'' as their first project with a programming language.
Regex 2: The ''[[gooey]]'' peanut butter and jelly sandwich was a ''[[beauty]]''.
Regex 3: ''[[AA312]]''
''[[AA1298]]''
''[[NW1234]]''
''[[US443]]''
US31344
AA123 extratext

Save your regexes to text files – one each.

=== Baseball Stats Counter ===

The St. Louis Cardinals are the most legendary baseball team in the national league. In this exercise, you will be creating a Python script that reads box scores from a file and computes the Cardinals' players' batting averages in a particular season.

==== Tips and Instructions ====

* You should write a Python script file to solve this problem.
* You should use a regular expression to parse players' names, at-bats, hits, and runs from the input file.
* You may want to create a class to hold and compute information about each player.
* Your file should take one command-line argument: the path to an input file. If no path is given, your program should print a usage message.

==== Input ====

Sample input files may be found here: http://classes.engineering.wustl.edu/cse330/content/cardinals/

The top of the file contains a citation, and what follows is an entire season of Cardinals Baseball box scores. Each game starts with a title; for example:

=== St.Louis Cardinals vs. Chicago Cubs, 1940-04-19 ===

What follows are the performance of each player in that game. The format of each line is as follows:

XXX batted # times with # hits and # runs

where '''XXX''' is the player's name (you may assume that the name is unique), and each '''#''' are integers representing the number of "at bats", the number of "hits", and the number of "runs", respectively.

==== Output ====

Your script needs to output all players' batting average across the season. A player's batting average is that player's total hits divided by that player's total at-bats throughout the entire season. For example, Johnny Hopp was at bat 149 times in 1940, and he had 41 hits, so his batting average was 0.275.

Each line in the output should have the format:

XXX: #.###

where '''XXX''' is the player's name, and '''#.###''' is the player's batting average, '''rounded''' (not truncated) to three decimal places.

The players should be sorted by batting average, with the highest batting average on top. If two players have the exact same batting average (before rounding occurs), the order between those two players is unimportant.

For example, the correct output for the 1940 season is:

<source lang="text">
Pepper Martin: 0.316
Walker Cooper: 0.316
Johnny Mize: 0.314
Ernie Koy: 0.310
Enos Slaughter: 0.306
Joe Medwick: 0.304
Terry Moore: 0.304
Joe Orengo: 0.286
Jimmy Brown: 0.280
Marty Marion: 0.279
Don Gutteridge: 0.276
Johnny Hopp: 0.275
Creepy Crespi: 0.273
Mickey Owen: 0.265
Bill DeLancey: 0.250
Don Padgett: 0.242
Stu Martin: 0.238
Eddie Lake: 0.222
Hal Epps: 0.214
Lon Warneke: 0.209
Harry Walker: 0.185
Max Lanier: 0.179
Bill McGee: 0.178
Carl Doyle: 0.174
Mort Cooper: 0.157
Clyde Shoun: 0.145
Carden Gillenwater: 0.130
Bob Bowman: 0.067
</source>

== Grading ==

We will be grading the following aspects of your work. There are 50 points total.

'''Assignments (including code) must be committed to Bitbucket by the end of class on the due date (commit early and often). Failing to commit by the end of class on the due date will result in a 0. '''

Upload your baseball code and a file with your Regular expressions.

# '''Regular Expressions (15 Points):'''
#* Regular Expression 1 Correct and saved in a file named <code>regex1.txt</code> (5 points)
#* Regular Expression 2 Correct and saved in a file named <code>regex2.txt</code>(5 points)
#* Regular Expression 3 Correct and saved in a file named <code>regex3.txt</code>(5 points)
# '''Baseball Stats Counter (35 Points):'''
#* Solution is written entirely in Python and saved in a file named <code>baseball.py</code> (8 points)
#* Correct usage of one or more regular expressions to parse and extract data from each line of the input file (8 points)
#* Script prints a usage message if a command line argument is not present (4 points)
#* Output is correct for all test cases (15 points)
#*: ''This includes sorting and rounding.''

[[Category:Module 4]]
[[Category:Modules]]

Module 4

2018-02-21T16:55:31Z

Alex: /* Write some Regular Expressions */

__NOTOC__
In Module 4, you will learn the fundamentals of Python, a popular scripting language, and Regular Expressions, which give you power in text processing.

This article contains your assignments for Module 4.

== Reading ==

The following articles on the online class wiki textbook contain information that will help you complete the assignments.

* [[Python]]
* [[Regular Expressions]]

== Individual Assignments ==

=== Learn Python and Regular Expressions ===

Up to this point in CSE 330, you have used only one programming language: PHP. In Module 4, you will learn a new language: Python. Before starting this assignment, you should look over the [[Python|online textbook article about Python]]. You should be using version 3 (or greater) of Python. Additionally, you may find it helpful to look over the [[Regular Expressions|online textbook article about Regular Expressions]].

=== Write some Regular Expressions ===

Please write regular expressions that do each the following:

# Match the substring "hello world" in string
# Find all words in an input string that contains three consecutive vowels, regardless of case.
# Match an input string that is '''entirely''' a flight code, of the format AA####, where '''AA''' is a two-letter uppercase airline code, and '''####''' is a three- or four-digit flight number
Examples:
Note: text in ''[[red]]'' is matched by the regular expression. Each line is a separate test input string.
Regex 1: Programmers will often write ''[[hello world]]'' as their first project with a programming language.
Regex 2: The ''[[gooey]]'' peanut butter and jelly sandwich was a ''[[beauty]]''.
Regex 3: ''[[AA312]]''
''[[AA1298]]''
''[[NW1234]]''
''[[US443]]''
US31344
AA123 extratext

Save your regexes to text files – one each.

=== Baseball Stats Counter ===

The St. Louis Cardinals are the most legendary baseball team in the national league. In this exercise, you will be creating a Python script that reads box scores from a file and computes the Cardinals' players' batting averages in a particular season.

==== Tips and Instructions ====

* You should write a Python script file to solve this problem.
* You should use a regular expression to parse players' names, at-bats, hits, and runs from the input file.
* You may want to create a class to hold and compute information about each player.
* Your file should take one command-line argument: the path to an input file. If no path is given, your program should print a usage message.

==== Input ====

Sample input files may be found here: http://classes.engineering.wustl.edu/cse330/content/cardinals/

The top of the file contains a citation, and what follows is an entire season of Cardinals Baseball box scores. Each game starts with a title; for example:

=== St.Louis Cardinals vs. Chicago Cubs, 1940-04-19 ===

What follows are the performance of each player in that game. The format of each line is as follows:

XXX batted # times with # hits and # runs

where '''XXX''' is the player's name (you may assume that the name is unique), and each '''#''' are integers representing the number of "at bats", the number of "hits", and the number of "runs", respectively.

==== Output ====

Your script needs to output all players' batting average across the season. A player's batting average is that player's total hits divided by that player's total at-bats throughout the entire season. For example, Johnny Hopp was at bat 149 times in 1940, and he had 41 hits, so his batting average was 0.275.

Each line in the output should have the format:

XXX: #.###

where '''XXX''' is the player's name, and '''#.###''' is the player's batting average, '''rounded''' (not truncated) to three decimal places.

The players should be sorted by batting average, with the highest batting average on top. If two players have the exact same batting average (before rounding occurs), the order between those two players is unimportant.

For example, the correct output for the 1940 season is:

<source lang="text">
Pepper Martin: 0.316
Walker Cooper: 0.316
Johnny Mize: 0.314
Ernie Koy: 0.310
Enos Slaughter: 0.306
Joe Medwick: 0.304
Terry Moore: 0.304
Joe Orengo: 0.286
Jimmy Brown: 0.280
Marty Marion: 0.279
Don Gutteridge: 0.276
Johnny Hopp: 0.275
Creepy Crespi: 0.273
Mickey Owen: 0.265
Bill DeLancey: 0.250
Don Padgett: 0.242
Stu Martin: 0.238
Eddie Lake: 0.222
Hal Epps: 0.214
Lon Warneke: 0.209
Harry Walker: 0.185
Max Lanier: 0.179
Bill McGee: 0.178
Carl Doyle: 0.174
Mort Cooper: 0.157
Clyde Shoun: 0.145
Carden Gillenwater: 0.130
Bob Bowman: 0.067
</source>

== Grading ==

We will be grading the following aspects of your work. There are 50 points total.

'''Assignments (including code) must be committed to Bitbucket by the end of class on the due date (commit early and often). Failing to commit by the end of class on the due date will result in a 0. '''

Upload your baseball code and a file with your Regular expressions.

# '''Regular Expressions (15 Points):'''
#* Regular Expression 1 Correct and saved in a file named <code>regex1.txt</code> (5 points)
#* Regular Expression 2 Correct and saved in a file named <code>regex2.txt</code>(5 points)
#* Regular Expression 3 Correct and saved in a file named <code>regex3.txt</code>(5 points)
# '''Baseball Stats Counter (35 Points):'''
#* Solution is written entirely in Python and saved in a file named <code>baseball.py</code> (8 points)
#* Correct usage of one or more regular expressions to parse and extract data from each line of the input file (8 points)
#* Script prints a usage message if a command line argument is not present (4 points)
#* Output is correct for all test cases (15 points)
#*: ''This includes sorting and rounding.''

[[Category:Module 4]]
[[Category:Modules]]

Module 4

2018-02-21T03:07:09Z

Alex: /* Grading */

__NOTOC__
In Module 4, you will learn the fundamentals of Python, a popular scripting language, and Regular Expressions, which give you power in text processing.

This article contains your assignments for Module 4.

== Reading ==

The following articles on the online class wiki textbook contain information that will help you complete the assignments.

* [[Python]]
* [[Regular Expressions]]

== Individual Assignments ==

=== Learn Python and Regular Expressions ===

Up to this point in CSE 330, you have used only one programming language: PHP. In Module 4, you will learn a new language: Python. Before starting this assignment, you should look over the [[Python|online textbook article about Python]]. You should be using version 3 (or greater) of Python. Additionally, you may find it helpful to look over the [[Regular Expressions|online textbook article about Regular Expressions]].

=== Write some Regular Expressions ===

Please write regular expressions that do each the following:

# Match the string "hello world" in a sentence
# Find all words in an input string that contains three consecutive vowels, regardless of case.
# Match an input string that is '''entirely''' a flight code, of the format AA####, where '''AA''' is a two-letter uppercase airline code, and '''####''' is a three- or four-digit flight number
Examples:
Note: text in ''[[red]]'' is matched by the regular expression. Each line is a separate test input string.
Regex 1: Programmers will often write ''[[hello world]]'' as their first project with a programming language.
Regex 2: The ''[[gooey]]'' peanut butter and jelly sandwich was a ''[[beauty]]''.
Regex 3: ''[[AA312]]''
''[[AA1298]]''
''[[NW1234]]''
''[[US443]]''
US31344
AA123 extratext

Save your regexes to text files – one each.

=== Baseball Stats Counter ===

The St. Louis Cardinals are the most legendary baseball team in the national league. In this exercise, you will be creating a Python script that reads box scores from a file and computes the Cardinals' players' batting averages in a particular season.

==== Tips and Instructions ====

* You should write a Python script file to solve this problem.
* You should use a regular expression to parse players' names, at-bats, hits, and runs from the input file.
* You may want to create a class to hold and compute information about each player.
* Your file should take one command-line argument: the path to an input file. If no path is given, your program should print a usage message.

==== Input ====

Sample input files may be found here: http://classes.engineering.wustl.edu/cse330/content/cardinals/

The top of the file contains a citation, and what follows is an entire season of Cardinals Baseball box scores. Each game starts with a title; for example:

=== St.Louis Cardinals vs. Chicago Cubs, 1940-04-19 ===

What follows are the performance of each player in that game. The format of each line is as follows:

XXX batted # times with # hits and # runs

where '''XXX''' is the player's name (you may assume that the name is unique), and each '''#''' are integers representing the number of "at bats", the number of "hits", and the number of "runs", respectively.

==== Output ====

Your script needs to output all players' batting average across the season. A player's batting average is that player's total hits divided by that player's total at-bats throughout the entire season. For example, Johnny Hopp was at bat 149 times in 1940, and he had 41 hits, so his batting average was 0.275.

Each line in the output should have the format:

XXX: #.###

where '''XXX''' is the player's name, and '''#.###''' is the player's batting average, '''rounded''' (not truncated) to three decimal places.

The players should be sorted by batting average, with the highest batting average on top. If two players have the exact same batting average (before rounding occurs), the order between those two players is unimportant.

For example, the correct output for the 1940 season is:

<source lang="text">
Pepper Martin: 0.316
Walker Cooper: 0.316
Johnny Mize: 0.314
Ernie Koy: 0.310
Enos Slaughter: 0.306
Joe Medwick: 0.304
Terry Moore: 0.304
Joe Orengo: 0.286
Jimmy Brown: 0.280
Marty Marion: 0.279
Don Gutteridge: 0.276
Johnny Hopp: 0.275
Creepy Crespi: 0.273
Mickey Owen: 0.265
Bill DeLancey: 0.250
Don Padgett: 0.242
Stu Martin: 0.238
Eddie Lake: 0.222
Hal Epps: 0.214
Lon Warneke: 0.209
Harry Walker: 0.185
Max Lanier: 0.179
Bill McGee: 0.178
Carl Doyle: 0.174
Mort Cooper: 0.157
Clyde Shoun: 0.145
Carden Gillenwater: 0.130
Bob Bowman: 0.067
</source>

== Grading ==

We will be grading the following aspects of your work. There are 50 points total.

'''Assignments (including code) must be committed to Bitbucket by the end of class on the due date (commit early and often). Failing to commit by the end of class on the due date will result in a 0. '''

Upload your baseball code and a file with your Regular expressions.

# '''Regular Expressions (15 Points):'''
#* Regular Expression 1 Correct and saved in a file named <code>regex1.txt</code> (5 points)
#* Regular Expression 2 Correct and saved in a file named <code>regex2.txt</code>(5 points)
#* Regular Expression 3 Correct and saved in a file named <code>regex3.txt</code>(5 points)
# '''Baseball Stats Counter (35 Points):'''
#* Solution is written entirely in Python and saved in a file named <code>baseball.py</code> (8 points)
#* Correct usage of one or more regular expressions to parse and extract data from each line of the input file (8 points)
#* Script prints a usage message if a command line argument is not present (4 points)
#* Output is correct for all test cases (15 points)
#*: ''This includes sorting and rounding.''

[[Category:Module 4]]
[[Category:Modules]]

Module 4

2018-02-20T23:33:10Z

Alex:

__NOTOC__
In Module 4, you will learn the fundamentals of Python, a popular scripting language, and Regular Expressions, which give you power in text processing.

This article contains your assignments for Module 4.

== Reading ==

The following articles on the online class wiki textbook contain information that will help you complete the assignments.

* [[Python]]
* [[Regular Expressions]]

== Individual Assignments ==

=== Learn Python and Regular Expressions ===

Up to this point in CSE 330, you have used only one programming language: PHP. In Module 4, you will learn a new language: Python. Before starting this assignment, you should look over the [[Python|online textbook article about Python]]. You should be using version 3 (or greater) of Python. Additionally, you may find it helpful to look over the [[Regular Expressions|online textbook article about Regular Expressions]].

=== Write some Regular Expressions ===

Please write regular expressions that do each the following:

# Match the string "hello world" in a sentence
# Find all words in an input string that contains three consecutive vowels, regardless of case.
# Match an input string that is '''entirely''' a flight code, of the format AA####, where '''AA''' is a two-letter uppercase airline code, and '''####''' is a three- or four-digit flight number
Examples:
Note: text in ''[[red]]'' is matched by the regular expression. Each line is a separate test input string.
Regex 1: Programmers will often write ''[[hello world]]'' as their first project with a programming language.
Regex 2: The ''[[gooey]]'' peanut butter and jelly sandwich was a ''[[beauty]]''.
Regex 3: ''[[AA312]]''
''[[AA1298]]''
''[[NW1234]]''
''[[US443]]''
US31344
AA123 extratext

Save your regexes to text files – one each.

=== Baseball Stats Counter ===

The St. Louis Cardinals are the most legendary baseball team in the national league. In this exercise, you will be creating a Python script that reads box scores from a file and computes the Cardinals' players' batting averages in a particular season.

==== Tips and Instructions ====

* You should write a Python script file to solve this problem.
* You should use a regular expression to parse players' names, at-bats, hits, and runs from the input file.
* You may want to create a class to hold and compute information about each player.
* Your file should take one command-line argument: the path to an input file. If no path is given, your program should print a usage message.

==== Input ====

Sample input files may be found here: http://classes.engineering.wustl.edu/cse330/content/cardinals/

The top of the file contains a citation, and what follows is an entire season of Cardinals Baseball box scores. Each game starts with a title; for example:

=== St.Louis Cardinals vs. Chicago Cubs, 1940-04-19 ===

What follows are the performance of each player in that game. The format of each line is as follows:

XXX batted # times with # hits and # runs

where '''XXX''' is the player's name (you may assume that the name is unique), and each '''#''' are integers representing the number of "at bats", the number of "hits", and the number of "runs", respectively.

==== Output ====

Your script needs to output all players' batting average across the season. A player's batting average is that player's total hits divided by that player's total at-bats throughout the entire season. For example, Johnny Hopp was at bat 149 times in 1940, and he had 41 hits, so his batting average was 0.275.

Each line in the output should have the format:

XXX: #.###

where '''XXX''' is the player's name, and '''#.###''' is the player's batting average, '''rounded''' (not truncated) to three decimal places.

The players should be sorted by batting average, with the highest batting average on top. If two players have the exact same batting average (before rounding occurs), the order between those two players is unimportant.

For example, the correct output for the 1940 season is:

<source lang="text">
Pepper Martin: 0.316
Walker Cooper: 0.316
Johnny Mize: 0.314
Ernie Koy: 0.310
Enos Slaughter: 0.306
Joe Medwick: 0.304
Terry Moore: 0.304
Joe Orengo: 0.286
Jimmy Brown: 0.280
Marty Marion: 0.279
Don Gutteridge: 0.276
Johnny Hopp: 0.275
Creepy Crespi: 0.273
Mickey Owen: 0.265
Bill DeLancey: 0.250
Don Padgett: 0.242
Stu Martin: 0.238
Eddie Lake: 0.222
Hal Epps: 0.214
Lon Warneke: 0.209
Harry Walker: 0.185
Max Lanier: 0.179
Bill McGee: 0.178
Carl Doyle: 0.174
Mort Cooper: 0.157
Clyde Shoun: 0.145
Carden Gillenwater: 0.130
Bob Bowman: 0.067
</source>

== Grading ==

We will be grading the following aspects of your work. There are 50 points total.

'''Assignments (including code) must be committed to Bitbucket by the end of class on the due date (commit early and often). Failing to commit by the end of class on the due date will result in a 0. '''

Upload your baseball code, a file with your Regular expressions, and a screenshot of your python output onto Bitbucket.

# '''Regular Expressions (15 Points):'''
#* Regular Expression 1 Correct and saved in a file named <code>regex1.txt</code> (5 points)
#* Regular Expression 2 Correct and saved in a file named <code>regex2.txt</code>(5 points)
#* Regular Expression 3 Correct and saved in a file named <code>regex3.txt</code>(5 points)
# '''Baseball Stats Counter (35 Points):'''
#* Solution is written entirely in Python and saved in a file named <code>baseball.py</code> (8 points)
#* Correct usage of one or more regular expressions to parse and extract data from each line of the input file (8 points)
#* Script prints a usage message if a command line argument is not present (4 points)
#* Output is correct for all test cases (15 points)
#*: ''This includes sorting and rounding.''

[[Category:Module 4]]
[[Category:Modules]]

Python

2018-02-19T18:24:46Z

Alex: /* File I/O */ f-strings

Languages like Java and C++ have lots of rules regarding variable types, syntax, return values, and so on. These can be cumbersome when you are trying to write short, quick scripts to perform tasks. This is where a ''scripting language'' comes into play.

'''Python''' is a language well-suited to rapid prototype development. It is generally an ''interpreted language'', which means that, generally speaking, a Python program is converted line by line into instructions for the computer to execute as the program runs, instead of having a separate compilation step beforehand {{ref|interpreted}}. The syntax is clean, and it is usually clear at first glance what is going on when you write in Python.

= Installation =

Python may already be installed on your system. To see whether or not it is, enter the command

<source lang="bash">
$ python3 --version
</source>
If it tells you a version of Python '''greater than or equal to 3.6''' then you're good to go. If not, you need to do a quick package install to get it up and running. Using yum, it's just <code>sudo yum install python36</code>.

If you'd like to be able to just type <code>python</code> instead of <code>python3</code>, you can add the following line to the <code>~/.bashrc</code> file on your instance:

<source lang="bash">
alias python="/usr/bin/python3"
</source>

==== Python 2 vs Python 3 ====

In 2008, a new version of Python – Python 3 – was released, with a number of changes that made it incompatible with the previous version, Python 2. For several years, the Python community was slow to make the change to Python 3, but today, Python 3 is ''the'' standard for new code. The ''only'' reason to write Python 2 code today is because you have to work in an environment or with libraries that do not support Python 3, and that situation is becoming increasingly rare.

'''For CSE 330 (and this guide), you ''must'' use Python 3.6 or greater.'''

=== Pip ===

Linux distributions have package managers like ''Apt'', ''Yum'', and ''YaST''. PHP has a package manager named ''PEAR''. It's now time to introduce Python's leading package manager: '''pip'''.

Once you have pip installed, you can use it to install Python packages. Use the <code>pip-3.6</code> command:

<source lang="bash">
$ pip-3.6 install package_name # RHEL
</source>

If you'd like to be able to just type <code>pip</code> instead of <code>pip-3.6</code>, you can add the following line to the <code>~/.bashrc</code> file on your instance:

<source lang="bash">
alias pip="/usr/bin/pip-3.6"
</source>

= Running Python =

There are two common ways to run Python code: via the console, and via a Python script file.

=== The Python Console ===

The Python console enables you to experiment with code without opening a text editor. To enter the Python console, simply type the ''python'' command at the terminal:

<source lang="bash">
$ python3
</source>
To leave the interactive console, either type <code>quit()</code> or press <code>Ctrl-D</code> (on both Mac and Windows).

=== Python Script Files ===

You can also save Python script files for later use. The extension for Python scripts is <code>*.py</code>. To run a script file, simply feed its path as an argument to the <code>python</code> command in Terminal:

<source lang="bash">
$ python3 my_script.py
</source>

= Python Syntax and Language Components =

This section contains a very brief overview of Python syntax. For a more comprehensive introduction, see [http://docs.python.org/tutorial/ the Python docs].

=== Python's Type System ===

Python is a dynamically-typed, strongly-typed, and duck-typed language. What does that mean? Well, let's take those categories one by one:

<ol>
<li>
'''Dynamic typing''', in contrast to ''static typing'' means that the types of objects can be changed. In Java, for instance, if you tried to write the following code:

<source lang="java">
int c = 2;
c = "fish";
</source>

Your code would fail to compile, because the Java compiler wouldn't allow you to change the type of the variable <code>c</code> from <code>int</code> to <code>String</code>.

Python, however, is just fine with that. You can write:

<source lang="python">
c = 2
c = "fish"
</source>

And Python will happily do what you ask.
</li>

<li>
'''Strong typing''', in contrast to ''weak typing'', means, roughly, that a language won't implicitly convert types for you. So far, you've used a lot of PHP, which is very weakly typed. For example:

<source lang="php">
echo "10" . 2;
</source>

In PHP, this works just fine. The PHP interpreter sees that <code>2</code> is an int, and silently converts it to a string for you, so that <code>"10". 2</code> equals <code>"102"</code>. The problem with weak typing is that it can make it unclear to the programmer why things are happening the way they are. For instance, in PHP, the expression <code>"10" == 10</code> is true, which can be less than obvious. Python, however, tries to disallow that sort of thing:

<source lang="python">
"10" + "10" # Allowed – concatenates the two strings.
10 + 10 # Allowed – adds the two ints.
"10" + 10 # Not allowed – raises a TypeError
</source>

Perhaps the one exception to this rule is the relationship between numeric types; it's perfectly fine to add a float to an int, for example.
</li>

<li>
'''Duck-typing''' is a little bit different than the other categories, because it doesn't really have a direct opposite. Essentially, duck-typing is the philosophy that "If it walks like a duck, and quacks like a duck, it's a duck." In programming terms, that means that we often don't care what type an object is, as long as it can do the things we ask.

Let's look at an example:

<source lang="python">
# This function doubles the value it's passed.
def double(thing):
return thing + thing
double(10) # Returns 20
double("fish") # Returns "fishfish";
</source>

If this were Java, we'd have to write two different methods here: one for things of type <code>int</code>, and one for things of type <code>String</code>. Since this is Python, though, we don't have to do that. Instead, Python lets us say, essentially: "This function uses the <code>+</code> operator, so you can pass whatever object you want to the function, as long as the function supports the <code>+</code> operator".

To quote [https://groups.google.com/forum/?hl=en#!msg/comp.lang.python/CCs2oJdyuzc/NYjla5HKMOIJ Alex Martelli], one of the key people in the Python project,

<blockquote>
"[Don't] check whether it IS-a duck: check whether it QUACKS-like-a duck, WALKS-like-a duck, etc, etc, depending on exactly what subset of duck-like behaviour you need."
</blockquote>

</li>
</ol>

=== Basic Types ===

In Python, the basic scalar types are:

# <code>str</code> – a string.
# <code>int</code> – an integer object with unlimited digits.
# <code>bool</code> – a Boolean value.
# <code>float</code> – a floating point number; generally equivalent to <code>double</code> in Java.
# <code>bytes</code> – represents a collection of bytes; you're unlikely to use this often.

Casting is done in the C style - to parse an <code>int</code> from a string, for instance, you'd write <code>int("123")</code>.

=== Basic Control Flow ===
In Python, blocks of code are delineated using colons and indentation instead of curly braces. '''''That means that proper indentation is mandatory.''''' Every time you use a colon, you must indent one step further, and every time a block ends, you must unindent a step.

Conditional statements are done using the <code>if</code>, <code>elif</code>, and <code>else</code> operators, like in the example below - pay attention to the indentation:

<source lang="python">
cookies_left = 10
cake_slices_left = 3
if cookies_left > 10:
print("Lots of cookies!")
elif cookies_left > 8:
print("Plenty left!")
elif cookies_left == 5:
print("Halfway done!")
else:
if cake_slices_left == 3:
print("Lots of cake!")
elif cake_slices_left == 2:
print("One slice gone!")
else:
print("Little to no cake left!")
</source>

=== An Example Python Script ===

In my mind, there's no better way to learn Python than to be immersed in a simple example script.

<source lang="python">
print("Hello World")

fruits = ["apple", "banana", "cherry", "date"]
for fruit in fruits:
print(f"I always love to eat a fresh {fruit}")

# Map the fruits list over to a new list containing the length of the fruit strings:
fruit_size = [len(fruit) for fruit in fruits]

avg_fruit_size = sum(fruit_size) / len(fruit_size)
print(f"The average fruit string length is {avg_fruit_size:.2f}.")
</source>

Some things to notice:

* Printing is achieved using the <code>print()</code> function.
* Comments start with a pound symbol <code>#</code>.
* We can transform/map a list to a new list in just one line!

For some more examples, see [https://wiki.python.org/moin/SimplePrograms the Python wiki].

=== A Few Gotchas ===

Here are a few things you may not expect when starting out with Python:

<ol>

<li>
Strings can be delimited using either single quotes (<code>'</code>) or double quotes (<code>"</code>), so <code>'Python'</code> is the same as <code>"Python"</code. You can also use three sets of quotes (<code>'''</code> or <code>"""</code>) to delineate a multiple-line string, like so:
<source lang="python">
long_string = """This
is my
very long
multiple-line
string"""
</source>
</li>

<li>
To compare the equality of two objects, use the <code>==</code> operator. To compare the identity of two objects (i.e. whether or not they are literally the same object, at the same place in memory), use the <code>is</code> operator. These correspond, respectively to <code>.equals()</code> and <code>==</code> in Java.
</li>

<li>
The <code>/</code> operator performs floating-point division, not integer division, even when both its arguments are integers. If you want to do integer division, use the <code>//</code> operator. Let's look at an example:

<source lang="python">
9 / 10 == 0.9 # Floating-point division
9.0 / 10.0 == 0.9 # Floating-point division
9 // 10 == 0 # Integer division
9.0 // 10.0 == 0.0 # Integer division, even though the resulting value is a float
</source>
</li>

<li>
As discussed in the section [[#Python's_Type_System|Python's Type System]], you can't combine strings and numbers using the <code>+</code> operator. Instead, you'll have to use one of the following methods of string formatting:

<source lang="python">

# Technique 1 – printf-style Formatting
# This is a classic style of string formatting, used in many programming languages, including in Java's String.format.
"You scored %d out of %d!" % (score, questions)

# Technique 2 – str.format
"You scored {} out of {}!".format(score, questions)

# Technique 3 – f-strings
# These were only introduced in Python 3.6 but they're very convenient.
f"You scored {score} out of {questions}!"

# Technique 4 - String Concatenation
# This is fine for small things, but for more complicated stuff, use one of the other techniques.
"You scored " + str(score) + " out of " + str(questions) + "!"
</source>
</li>
</ol>

=== Functions ===

Define functions using the <code>def</code> keyword:

<source lang="python">
def hello(name):
print(f"Hello, {name}!")

</source>

Invoke functions using parentheses:
<source lang="python">
hello("Batman")
hello("Superman")
</source>

Functions can have optional arguments; however, these must come after any required arguments:
<source lang="python">
def hello(name="User"):
print(f"Hello, {name}!")

hello() # Prints "Hello, User!"
hello("Sarah") # Prints "Hello, Sarah!"
</source>

Functions are just regular objects in Python, meaning you can do stuff like this:

<source lang="python">
def hello(name="User"):
print(f"Hello, {name}!")

greeting = hello

greeting("Siwei") # Prints "Hello, Siwei!"
</source>

=== Collection Types ===
Python has a few basic, built-in collection types. They each have their own special use cases, but they share a lot of similarities. All built-in data structures in Python are zero-indexed, for instance.

To obtain the number of elements in a collection, use the <code>len()</code> function, like this:

<source lang="python">
pets = ['Dog', 'Cat', 'Fish'] # This is a list; you'll learn about them below.

len(pets) # Returns 3
</source>

To check if a collection contains an item, use the <code>in</code> operator:
<source lang="python">
pets = ['Dog', 'Cat', 'Fish'] # This is a list; you'll learn about them below.

'Dog' in pets # Returns True
</source>

Helpfully, the Python Software Foundation maintains a page containing the asymptotic complexities of important operations on major Python data structures. It's available [https://wiki.python.org/moin/TimeComplexity here].

==== Lists ====

Unlike languages like Java and C, Python's array-like type doesn't have fixed length. Instead, a <code>list</code> is a dynamic array (like Java's <code>ArrayList</code>) of objects of any type. Here's an example:

<source lang="python">
fruits = ["Apple", "Pear", "Orange"] # Lists can be creating by placing their items between square brackets

random_items = ['Apple', 12312, 2.0, [1, 2, 3]] # Lists can contain objects of different types - even other lists!

pets.append('Turtle') # Adds 'Turtle' to the end of pets
</source>

For the next few examples, we'll be using the following list:

<source lang="python">
pets = ['Dog', 'Cat', 'Fish', 'Turtle', 'Lizard', 'Snake']
</source>

To access or assign elements of a list, use the <code>[]</code> operator.

<source lang="python">
pets[0] # Returns 'Dog'
pets[1] = 'Cow' # Sets pets[1] to 'Cow'
pets[1] = 'Cat' # Sets pets[1] back to 'Cat'
</source>

You can also access or assign lists using negative indices, which will return elements starting from the end of the list:

<source lang="python">
pets[-1] # Returns 'Snake'
pets[-2] # Returns 'Lizard'
</source>

You can also use 'slice notation' to obtain or assign subsets of lists:
<source lang="python">
pets[start:end] # Returns items from index start to index end - 1.
pets[start:] # Returns items from index start to the end of the list, inclusive.
pets[:end] # Returns items from the beginning of the list to index end - 1.
pets[:] # Returns every item in the list
</source>

There's also a third, optional argument: <code>step</code>, which lets you jump over values:
<source lang="python">
pets[start:end:step] # Returns items from index start to index end - 1, jumping step values at a time

# Examples:
pets[1:5:2] # Returns items from index 1 to index 4, jumping 2 at a time, so ['Cat', 'Turtle']
pets[::3] # Returns all items in the list, jumping 3 at a time, so ['Dog', 'Turtle']
pets[::-1] # Returns all items in the list, jumping -1 at a time. This reverses the list, so ['Snake', 'Lizard', 'Turtle', 'Fish', 'Cat', 'Dog']
</source>

Lists have all the performance characteristics you'd expect of a dynamic array - constant-time indexing, amortized constant-time appends, and so on.

==== Tuples ====

Python has a special data type called <code>tuple</code>, which is exactly the same as a list except for the fact that it cannot be modified, so you can't append or replace items.

<source lang="python">
cities = ('St. Louis', 'Los Angeles', 'Seattle') # Tuples are defined using parentheses.
numbers = 1, 2, 3 # You can also omit the parentheses if it's unambiguous
single_item_tuple = (1,) # To make a tuple with only one item, put a comma after it
</source>

Tuples also enable you to have multiple return values from a function:

<source lang="python">
def compute_length(string):
str_len = len(string)
if str_len < 5:
return str_len, "short"
elif str_len < 40:
return str_len, "medium"
return str_len, "long"

length, description = compute_length("Four score and seven years ago")
print(f"The {description} string is {length} characters long.")
</source>
The above example also demonstrates Python's if...elif...else conditional structure.

==== Dictionaries ====

Python has another datatype called a '''dictionary''' (or <code>dict</code>, for short), which are like ''Maps'' in Java, ''associative arrays'' in PHP, and ''object literals'' in JavaScript (coming up soon in Module 6). Essentially, they enable you to use any immutable object as the key in your data structure. <code>dict</code> objects can be created using either the <code>dict</code> function, or by placing items between curly braces, separating keys and values using colons:

<source lang="python">
fruits_in_bowl = {
'apple': 4,
'banana': 2,
'cherry': 0,
'date': 12
}

apple_count = fruits_in_bowl['apple'] # Equals 4

fruits_in_bowl['pear'] = 9 # Sets 'pear' in the dictionary to 9.

for fruit, num in fruits_in_bowl.items():
print(f"There are {num} {fruit}(s) in the bowl." % (num, fruit))
</source>
If you only want the keys from a dictionary, you can just iterate over it directly, like this:

<source lang="python">
for fruit in fruits_in_bowl:
print(fruit)
</source>
If you want only the values but not the keys from a dictionary, use <code>my_dictionary.values()</code>.

==== Sets ====
A <code>set</code> is an unordered collection of unique items, with constant-time membership checking.
<source lang="python">
fruits = {'Apple', 'Apple', 'Apple', 'Pear'} # The set removes duplicates, so it will only contain {'Apple', 'Pear'}
fruits = set(['Apple', 'Apple', 'Apple', 'Pear']) # This line transforms a list into a set
print('Apple' in fruits) # Constant-time!
</source>

=== Loops ===

In Python, while loops are written like this:

<source lang="python">
i = 0
while i < 10:
i += 1
</source>
For loops are written like this:

<source lang="python">
pets = ['Dog', 'Cat', 'Fish']

for pet in pets:
print(pet)
</source>
To iterate over a range of numbers, you can use the convenient <code>range</code> function, like so:

<source lang="python">
for i in range(20, 30): # If you omit the first argument to range, it's assumed to be zero.
print(i)
</source>
Note that <code>range</code> provides a closed-open range. That is to say, it is inclusive of its lower bound and exclusive of its upper bound. To be very explicit about it:

<source lang="python">
list(range(3, 6)) == [3, 4, 5]
</source>
Unlike in other languages you may know, the following is not good practice in Python:

<source lang="python">
pets = ['Dog', 'Cat', 'Fish']

# BAD PRACTICE. DO NOT USE.
for i in range(len(pets)):
pet = pets[i]
</source>
Instead, if you need to access both a variable and its index, use the <code>enumerate</code> function, which allows you to iterate through a group of items, along with their indexes, like so:

<source lang="python">
pets = ['Dog', 'Cat', 'Fish']

for index, pet in enumerate(pets):
print(f"{pet} at index {index}")
</source>

=== Generator Expressions and Comprehensions ===

A generator is a special kind of object that, basically, represents a collection of items using a value and a function for generating the next value in the collection. In other words, it's a way of creating something that behaves like a list, but which only generates one value at a time, and discards a value when it's done with it. Say, for example, you wanted to do an operation on 10,000,000,000,000 numbers. You could put them all in a list, then iterate over the list, but that would take a lot of memory, plus you'd have to create and fill the entire list before beginning to actually work on your problem. Instead, you'd probably be better off using a generator; telling the computer, essentially: “The starting value is 0. When I ask for the next number in the collection, add 1 to current value and give me that.”

A generator expression is an expression that is evaluated to create a generator. They're super useful. Generator expressions can take two forms – they can be used with and without a condition:

<source lang="python">
(EXPRESSION for VARIABLE in ITERABLE) # Unconditional
(EXPRESSION for VARIABLE in ITERABLE if CONDITION) # Conditional
</source>
For our purposes, you can think of an iterable as anything you can do a for loop over. Let's take a look at a generator expression in use:

<source lang="python">
double_even_digits = (number * 2 for number in range(10) if number % 2 == 0)
</source>
That line says that <code>double_even_digits</code> is every even number between 0 and 10 multiplied by two. Simple enough, right? If we wanted to use all of the numbers, not just the even ones, we could simply remove the if statement at the end of the expression.

Here's the thing, though: if you were to print <code>double_even_digits</code>, instead of a nice bunch of numbers, you'd get something that looks like this:

<code><generator object <genexpr><code>at 0x107fc92b0></code>

That's because generators are lazy! They don't generate their values until those values are needed, and they discard values once they're no longer needed. As a result, '''you can only iterate over a generator once'''. In this case, you can't print out the whole generator, because it hasn't generated all the values yet. You can, however, iterate over the generator, and print its values one at a time, like so:

<source lang="python">
for number in double_even_digits:
print(number)
</source>
You can also make a list out of the generator, which will go through all the items in the generator and put them in a list, like so:

<source lang="python">
even_number_list = list(double_even_digits)
</source>
That's actually a great segue to the second topic of this section: comprehensions. A comprehension is just a prettier way to make lists, sets, and dicts out of a generator expressions.

<source lang="python">
# If you want a list:
list(i for i in range(10) if i % 2 == 0) # Don't do this
[i for i in range(10) if i % 2 == 0] # Use a list comprehension instead!

# If you want a set:
set(i for i in range(10) if i % 2 == 0) # Don't do this
{i for i in range(10) if i % 2 == 0} # Use a set comprehension instead!

# If you want a dict:
dict((i, i + 1) for i in range(10) if i % 2 == 0) # Don't do this
{i : i + 1 for i in range(10) if i % 2 == 0} # Use a dict comprehension instead!

# If you want a tuple:
tuple(i for i in range(10) if i % 2 == 0) # Unfortunately, there's no better way to do this
</source>
In general, generators and comprehensions should be used whenever possible - they're the fastest and easiest way to build collections. If you ever see yourself writing code like this:

<source lang="python">
# BAD PRACTICE! DO NOT USE!
digits = []
for digit in range(10):
digits.append(digit)
</source>
Don't do it! Instead, use a generator expression or comprehension, as appropriate. A good way to decide whether a generator expression or comprehension is better for this situation is that, if you're just going to be iterating over your collection once, you should use an generator expression. If not, use a comprehension.

=== Sorting ===

Sorting in Python is frequently performed using the <code>sorted</code> function, which takes two arguments: an iterable (anything you can do a for-loop over, including lists and tuples) and a function used to evaluate each item. If the function is omitted, Python will try to sort the lists by value.

The following example demonstrates using an inline function, which Python calls a ''lambda''.

<source lang="python">
fruits = ['apple', 'banana', 'cherry', 'date']

# sort the fruits by string length
new_fruits = sorted(fruits, key=lambda v: len(v) // 2)

print(new_fruits) # ['date', 'apple', 'banana', 'cherry']
</source>
Alternatively, you can sort a <code>list</code> using the <code>.sort</code> method. This is faster than calling <code>sorted</code>, but it modifies the list in-place and returns <code>None</code>.

<source lang="python">
fruits = ['apple', 'banana', 'cherry', 'date']
fruits.sort()
</source>
=== Import ===

If you want to use functions from other libraries (including ones that you install using pip), use <code>import</code>:

<source lang="python">
import time

current_time = time.localtime()
print(time.strftime('%a, %d %b %Y %H:%M:%S', current_time))
</source>
If you want to pull the functions out of their namespace, you can use <code>from ___ import ___</code> syntax:

<source lang="python">
from time import localtime, strftime

current_time = localtime()
print(strftime('%a, %d %b %Y %H:%M:%S', current_time))

# Be aware that this technique, although convenient, may cause unexpected behavior if the function names that you're pulling out of the namespace are already used for other purposes in Python.
</source>
=== File I/O ===

You can read an entire file into a variable like this:

<source lang="python">
f = open("example.txt")
file_contents = f.read()

f.close() # free up memory when we're finished with the file
</source>
A better option is to use a with-block, which handles opening and closing the file for you automatically:

<source lang="python">
with open("example.txt") as f:
file_contents = f.read()
</source>
You can read a file line-by-line like this:

<source lang="python">
with open("example.txt") as f:
for line in f:
print(f"Read line: {line.strip()}")
</source>
You can write to a file like this:

<source lang="python">
with open("example.txt", "w") as f:
f.write("Hello\nWorld\n")
</source>

=== Command-Line Arguments ===

Command line arguments are accessible in the variable <code>sys.argv</code>.

The following example shows a program that expects a filename as its argument, and it prints a usage message if the argument is not present ([https://stackoverflow.com/questions/983201/python-and-sys-argv source]).

<source lang="python">
import sys, os

if len(sys.argv) < 2:
sys.exit(f"Usage: {sys.argv[0]} filename")

filename = sys.argv[1]

if not os.path.exists(filename):
sys.exit(f"Error: File '{sys.argv[1]}' not found")
</source>

=== Object-Oriented Programming ===

You can define and use a class like this:

<source lang="python">
class Food:
# constructor:
def __init__(self, name):
self.name = name

def format_name(self):
return f"Gotta love to eat {self.name}"

class Fruit(Food):
def get_definition(self):
return f"{self.format_name()} (fruit)"

fruit = Fruit("Cherry")
print(fruit.format_name())
print(fruit.get_definition())
</source>
This is the same example as in [[PHP#Object-Oriented_Programming|the PHP guide]].

Some things to notice:

* Instance methods ''always'' take <code>self</code> as their first argument, followed by any number of additional parameters. This can be misleading for programmers familiar with other languages, because the number of arguments you feed to the method is actually ''one less than'' the number of declared parameters. Whenever you call a method on a class instance, that instance is implicitly fed into the explicitly-declared <code>self</code> parameter of the method.
*: Note that the <code>self</code> variable has the same purpose as the <code>this</code> variable in languages like PHP, Java, JavaScript, and C++.
*There is no need for a <code>new</code> keyword in Python.

= Footnotes =
# {{note|interpreted}}This is an oversimplification. If you're interested, here's a quick explanation of how: In CPython (the reference implementation of Python) programs are compiled to bytecode, an intermediate representation, which is then interpreted.
[[Category:Module 4]]

Python

2018-02-19T18:23:51Z

Alex: /* Object-Oriented Programming */ Fixed compilation error in example

Languages like Java and C++ have lots of rules regarding variable types, syntax, return values, and so on. These can be cumbersome when you are trying to write short, quick scripts to perform tasks. This is where a ''scripting language'' comes into play.

'''Python''' is a language well-suited to rapid prototype development. It is generally an ''interpreted language'', which means that, generally speaking, a Python program is converted line by line into instructions for the computer to execute as the program runs, instead of having a separate compilation step beforehand {{ref|interpreted}}. The syntax is clean, and it is usually clear at first glance what is going on when you write in Python.

= Installation =

Python may already be installed on your system. To see whether or not it is, enter the command

<source lang="bash">
$ python3 --version
</source>
If it tells you a version of Python '''greater than or equal to 3.6''' then you're good to go. If not, you need to do a quick package install to get it up and running. Using yum, it's just <code>sudo yum install python36</code>.

If you'd like to be able to just type <code>python</code> instead of <code>python3</code>, you can add the following line to the <code>~/.bashrc</code> file on your instance:

<source lang="bash">
alias python="/usr/bin/python3"
</source>

==== Python 2 vs Python 3 ====

In 2008, a new version of Python – Python 3 – was released, with a number of changes that made it incompatible with the previous version, Python 2. For several years, the Python community was slow to make the change to Python 3, but today, Python 3 is ''the'' standard for new code. The ''only'' reason to write Python 2 code today is because you have to work in an environment or with libraries that do not support Python 3, and that situation is becoming increasingly rare.

'''For CSE 330 (and this guide), you ''must'' use Python 3.6 or greater.'''

=== Pip ===

Linux distributions have package managers like ''Apt'', ''Yum'', and ''YaST''. PHP has a package manager named ''PEAR''. It's now time to introduce Python's leading package manager: '''pip'''.

Once you have pip installed, you can use it to install Python packages. Use the <code>pip-3.6</code> command:

<source lang="bash">
$ pip-3.6 install package_name # RHEL
</source>

If you'd like to be able to just type <code>pip</code> instead of <code>pip-3.6</code>, you can add the following line to the <code>~/.bashrc</code> file on your instance:

<source lang="bash">
alias pip="/usr/bin/pip-3.6"
</source>

= Running Python =

There are two common ways to run Python code: via the console, and via a Python script file.

=== The Python Console ===

The Python console enables you to experiment with code without opening a text editor. To enter the Python console, simply type the ''python'' command at the terminal:

<source lang="bash">
$ python3
</source>
To leave the interactive console, either type <code>quit()</code> or press <code>Ctrl-D</code> (on both Mac and Windows).

=== Python Script Files ===

You can also save Python script files for later use. The extension for Python scripts is <code>*.py</code>. To run a script file, simply feed its path as an argument to the <code>python</code> command in Terminal:

<source lang="bash">
$ python3 my_script.py
</source>

= Python Syntax and Language Components =

This section contains a very brief overview of Python syntax. For a more comprehensive introduction, see [http://docs.python.org/tutorial/ the Python docs].

=== Python's Type System ===

Python is a dynamically-typed, strongly-typed, and duck-typed language. What does that mean? Well, let's take those categories one by one:

<ol>
<li>
'''Dynamic typing''', in contrast to ''static typing'' means that the types of objects can be changed. In Java, for instance, if you tried to write the following code:

<source lang="java">
int c = 2;
c = "fish";
</source>

Your code would fail to compile, because the Java compiler wouldn't allow you to change the type of the variable <code>c</code> from <code>int</code> to <code>String</code>.

Python, however, is just fine with that. You can write:

<source lang="python">
c = 2
c = "fish"
</source>

And Python will happily do what you ask.
</li>

<li>
'''Strong typing''', in contrast to ''weak typing'', means, roughly, that a language won't implicitly convert types for you. So far, you've used a lot of PHP, which is very weakly typed. For example:

<source lang="php">
echo "10" . 2;
</source>

In PHP, this works just fine. The PHP interpreter sees that <code>2</code> is an int, and silently converts it to a string for you, so that <code>"10". 2</code> equals <code>"102"</code>. The problem with weak typing is that it can make it unclear to the programmer why things are happening the way they are. For instance, in PHP, the expression <code>"10" == 10</code> is true, which can be less than obvious. Python, however, tries to disallow that sort of thing:

<source lang="python">
"10" + "10" # Allowed – concatenates the two strings.
10 + 10 # Allowed – adds the two ints.
"10" + 10 # Not allowed – raises a TypeError
</source>

Perhaps the one exception to this rule is the relationship between numeric types; it's perfectly fine to add a float to an int, for example.
</li>

<li>
'''Duck-typing''' is a little bit different than the other categories, because it doesn't really have a direct opposite. Essentially, duck-typing is the philosophy that "If it walks like a duck, and quacks like a duck, it's a duck." In programming terms, that means that we often don't care what type an object is, as long as it can do the things we ask.

Let's look at an example:

<source lang="python">
# This function doubles the value it's passed.
def double(thing):
return thing + thing
double(10) # Returns 20
double("fish") # Returns "fishfish";
</source>

If this were Java, we'd have to write two different methods here: one for things of type <code>int</code>, and one for things of type <code>String</code>. Since this is Python, though, we don't have to do that. Instead, Python lets us say, essentially: "This function uses the <code>+</code> operator, so you can pass whatever object you want to the function, as long as the function supports the <code>+</code> operator".

To quote [https://groups.google.com/forum/?hl=en#!msg/comp.lang.python/CCs2oJdyuzc/NYjla5HKMOIJ Alex Martelli], one of the key people in the Python project,

<blockquote>
"[Don't] check whether it IS-a duck: check whether it QUACKS-like-a duck, WALKS-like-a duck, etc, etc, depending on exactly what subset of duck-like behaviour you need."
</blockquote>

</li>
</ol>

=== Basic Types ===

In Python, the basic scalar types are:

# <code>str</code> – a string.
# <code>int</code> – an integer object with unlimited digits.
# <code>bool</code> – a Boolean value.
# <code>float</code> – a floating point number; generally equivalent to <code>double</code> in Java.
# <code>bytes</code> – represents a collection of bytes; you're unlikely to use this often.

Casting is done in the C style - to parse an <code>int</code> from a string, for instance, you'd write <code>int("123")</code>.

=== Basic Control Flow ===
In Python, blocks of code are delineated using colons and indentation instead of curly braces. '''''That means that proper indentation is mandatory.''''' Every time you use a colon, you must indent one step further, and every time a block ends, you must unindent a step.

Conditional statements are done using the <code>if</code>, <code>elif</code>, and <code>else</code> operators, like in the example below - pay attention to the indentation:

<source lang="python">
cookies_left = 10
cake_slices_left = 3
if cookies_left > 10:
print("Lots of cookies!")
elif cookies_left > 8:
print("Plenty left!")
elif cookies_left == 5:
print("Halfway done!")
else:
if cake_slices_left == 3:
print("Lots of cake!")
elif cake_slices_left == 2:
print("One slice gone!")
else:
print("Little to no cake left!")
</source>

=== An Example Python Script ===

In my mind, there's no better way to learn Python than to be immersed in a simple example script.

<source lang="python">
print("Hello World")

fruits = ["apple", "banana", "cherry", "date"]
for fruit in fruits:
print(f"I always love to eat a fresh {fruit}")

# Map the fruits list over to a new list containing the length of the fruit strings:
fruit_size = [len(fruit) for fruit in fruits]

avg_fruit_size = sum(fruit_size) / len(fruit_size)
print(f"The average fruit string length is {avg_fruit_size:.2f}.")
</source>

Some things to notice:

* Printing is achieved using the <code>print()</code> function.
* Comments start with a pound symbol <code>#</code>.
* We can transform/map a list to a new list in just one line!

For some more examples, see [https://wiki.python.org/moin/SimplePrograms the Python wiki].

=== A Few Gotchas ===

Here are a few things you may not expect when starting out with Python:

<ol>

<li>
Strings can be delimited using either single quotes (<code>'</code>) or double quotes (<code>"</code>), so <code>'Python'</code> is the same as <code>"Python"</code. You can also use three sets of quotes (<code>'''</code> or <code>"""</code>) to delineate a multiple-line string, like so:
<source lang="python">
long_string = """This
is my
very long
multiple-line
string"""
</source>
</li>

<li>
To compare the equality of two objects, use the <code>==</code> operator. To compare the identity of two objects (i.e. whether or not they are literally the same object, at the same place in memory), use the <code>is</code> operator. These correspond, respectively to <code>.equals()</code> and <code>==</code> in Java.
</li>

<li>
The <code>/</code> operator performs floating-point division, not integer division, even when both its arguments are integers. If you want to do integer division, use the <code>//</code> operator. Let's look at an example:

<source lang="python">
9 / 10 == 0.9 # Floating-point division
9.0 / 10.0 == 0.9 # Floating-point division
9 // 10 == 0 # Integer division
9.0 // 10.0 == 0.0 # Integer division, even though the resulting value is a float
</source>
</li>

<li>
As discussed in the section [[#Python's_Type_System|Python's Type System]], you can't combine strings and numbers using the <code>+</code> operator. Instead, you'll have to use one of the following methods of string formatting:

<source lang="python">

# Technique 1 – printf-style Formatting
# This is a classic style of string formatting, used in many programming languages, including in Java's String.format.
"You scored %d out of %d!" % (score, questions)

# Technique 2 – str.format
"You scored {} out of {}!".format(score, questions)

# Technique 3 – f-strings
# These were only introduced in Python 3.6 but they're very convenient.
f"You scored {score} out of {questions}!"

# Technique 4 - String Concatenation
# This is fine for small things, but for more complicated stuff, use one of the other techniques.
"You scored " + str(score) + " out of " + str(questions) + "!"
</source>
</li>
</ol>

=== Functions ===

Define functions using the <code>def</code> keyword:

<source lang="python">
def hello(name):
print(f"Hello, {name}!")

</source>

Invoke functions using parentheses:
<source lang="python">
hello("Batman")
hello("Superman")
</source>

Functions can have optional arguments; however, these must come after any required arguments:
<source lang="python">
def hello(name="User"):
print(f"Hello, {name}!")

hello() # Prints "Hello, User!"
hello("Sarah") # Prints "Hello, Sarah!"
</source>

Functions are just regular objects in Python, meaning you can do stuff like this:

<source lang="python">
def hello(name="User"):
print(f"Hello, {name}!")

greeting = hello

greeting("Siwei") # Prints "Hello, Siwei!"
</source>

=== Collection Types ===
Python has a few basic, built-in collection types. They each have their own special use cases, but they share a lot of similarities. All built-in data structures in Python are zero-indexed, for instance.

To obtain the number of elements in a collection, use the <code>len()</code> function, like this:

<source lang="python">
pets = ['Dog', 'Cat', 'Fish'] # This is a list; you'll learn about them below.

len(pets) # Returns 3
</source>

To check if a collection contains an item, use the <code>in</code> operator:
<source lang="python">
pets = ['Dog', 'Cat', 'Fish'] # This is a list; you'll learn about them below.

'Dog' in pets # Returns True
</source>

Helpfully, the Python Software Foundation maintains a page containing the asymptotic complexities of important operations on major Python data structures. It's available [https://wiki.python.org/moin/TimeComplexity here].

==== Lists ====

Unlike languages like Java and C, Python's array-like type doesn't have fixed length. Instead, a <code>list</code> is a dynamic array (like Java's <code>ArrayList</code>) of objects of any type. Here's an example:

<source lang="python">
fruits = ["Apple", "Pear", "Orange"] # Lists can be creating by placing their items between square brackets

random_items = ['Apple', 12312, 2.0, [1, 2, 3]] # Lists can contain objects of different types - even other lists!

pets.append('Turtle') # Adds 'Turtle' to the end of pets
</source>

For the next few examples, we'll be using the following list:

<source lang="python">
pets = ['Dog', 'Cat', 'Fish', 'Turtle', 'Lizard', 'Snake']
</source>

To access or assign elements of a list, use the <code>[]</code> operator.

<source lang="python">
pets[0] # Returns 'Dog'
pets[1] = 'Cow' # Sets pets[1] to 'Cow'
pets[1] = 'Cat' # Sets pets[1] back to 'Cat'
</source>

You can also access or assign lists using negative indices, which will return elements starting from the end of the list:

<source lang="python">
pets[-1] # Returns 'Snake'
pets[-2] # Returns 'Lizard'
</source>

You can also use 'slice notation' to obtain or assign subsets of lists:
<source lang="python">
pets[start:end] # Returns items from index start to index end - 1.
pets[start:] # Returns items from index start to the end of the list, inclusive.
pets[:end] # Returns items from the beginning of the list to index end - 1.
pets[:] # Returns every item in the list
</source>

There's also a third, optional argument: <code>step</code>, which lets you jump over values:
<source lang="python">
pets[start:end:step] # Returns items from index start to index end - 1, jumping step values at a time

# Examples:
pets[1:5:2] # Returns items from index 1 to index 4, jumping 2 at a time, so ['Cat', 'Turtle']
pets[::3] # Returns all items in the list, jumping 3 at a time, so ['Dog', 'Turtle']
pets[::-1] # Returns all items in the list, jumping -1 at a time. This reverses the list, so ['Snake', 'Lizard', 'Turtle', 'Fish', 'Cat', 'Dog']
</source>

Lists have all the performance characteristics you'd expect of a dynamic array - constant-time indexing, amortized constant-time appends, and so on.

==== Tuples ====

Python has a special data type called <code>tuple</code>, which is exactly the same as a list except for the fact that it cannot be modified, so you can't append or replace items.

<source lang="python">
cities = ('St. Louis', 'Los Angeles', 'Seattle') # Tuples are defined using parentheses.
numbers = 1, 2, 3 # You can also omit the parentheses if it's unambiguous
single_item_tuple = (1,) # To make a tuple with only one item, put a comma after it
</source>

Tuples also enable you to have multiple return values from a function:

<source lang="python">
def compute_length(string):
str_len = len(string)
if str_len < 5:
return str_len, "short"
elif str_len < 40:
return str_len, "medium"
return str_len, "long"

length, description = compute_length("Four score and seven years ago")
print(f"The {description} string is {length} characters long.")
</source>
The above example also demonstrates Python's if...elif...else conditional structure.

==== Dictionaries ====

Python has another datatype called a '''dictionary''' (or <code>dict</code>, for short), which are like ''Maps'' in Java, ''associative arrays'' in PHP, and ''object literals'' in JavaScript (coming up soon in Module 6). Essentially, they enable you to use any immutable object as the key in your data structure. <code>dict</code> objects can be created using either the <code>dict</code> function, or by placing items between curly braces, separating keys and values using colons:

<source lang="python">
fruits_in_bowl = {
'apple': 4,
'banana': 2,
'cherry': 0,
'date': 12
}

apple_count = fruits_in_bowl['apple'] # Equals 4

fruits_in_bowl['pear'] = 9 # Sets 'pear' in the dictionary to 9.

for fruit, num in fruits_in_bowl.items():
print(f"There are {num} {fruit}(s) in the bowl." % (num, fruit))
</source>
If you only want the keys from a dictionary, you can just iterate over it directly, like this:

<source lang="python">
for fruit in fruits_in_bowl:
print(fruit)
</source>
If you want only the values but not the keys from a dictionary, use <code>my_dictionary.values()</code>.

==== Sets ====
A <code>set</code> is an unordered collection of unique items, with constant-time membership checking.
<source lang="python">
fruits = {'Apple', 'Apple', 'Apple', 'Pear'} # The set removes duplicates, so it will only contain {'Apple', 'Pear'}
fruits = set(['Apple', 'Apple', 'Apple', 'Pear']) # This line transforms a list into a set
print('Apple' in fruits) # Constant-time!
</source>

=== Loops ===

In Python, while loops are written like this:

<source lang="python">
i = 0
while i < 10:
i += 1
</source>
For loops are written like this:

<source lang="python">
pets = ['Dog', 'Cat', 'Fish']

for pet in pets:
print(pet)
</source>
To iterate over a range of numbers, you can use the convenient <code>range</code> function, like so:

<source lang="python">
for i in range(20, 30): # If you omit the first argument to range, it's assumed to be zero.
print(i)
</source>
Note that <code>range</code> provides a closed-open range. That is to say, it is inclusive of its lower bound and exclusive of its upper bound. To be very explicit about it:

<source lang="python">
list(range(3, 6)) == [3, 4, 5]
</source>
Unlike in other languages you may know, the following is not good practice in Python:

<source lang="python">
pets = ['Dog', 'Cat', 'Fish']

# BAD PRACTICE. DO NOT USE.
for i in range(len(pets)):
pet = pets[i]
</source>
Instead, if you need to access both a variable and its index, use the <code>enumerate</code> function, which allows you to iterate through a group of items, along with their indexes, like so:

<source lang="python">
pets = ['Dog', 'Cat', 'Fish']

for index, pet in enumerate(pets):
print(f"{pet} at index {index}")
</source>

=== Generator Expressions and Comprehensions ===

A generator is a special kind of object that, basically, represents a collection of items using a value and a function for generating the next value in the collection. In other words, it's a way of creating something that behaves like a list, but which only generates one value at a time, and discards a value when it's done with it. Say, for example, you wanted to do an operation on 10,000,000,000,000 numbers. You could put them all in a list, then iterate over the list, but that would take a lot of memory, plus you'd have to create and fill the entire list before beginning to actually work on your problem. Instead, you'd probably be better off using a generator; telling the computer, essentially: “The starting value is 0. When I ask for the next number in the collection, add 1 to current value and give me that.”

A generator expression is an expression that is evaluated to create a generator. They're super useful. Generator expressions can take two forms – they can be used with and without a condition:

<source lang="python">
(EXPRESSION for VARIABLE in ITERABLE) # Unconditional
(EXPRESSION for VARIABLE in ITERABLE if CONDITION) # Conditional
</source>
For our purposes, you can think of an iterable as anything you can do a for loop over. Let's take a look at a generator expression in use:

<source lang="python">
double_even_digits = (number * 2 for number in range(10) if number % 2 == 0)
</source>
That line says that <code>double_even_digits</code> is every even number between 0 and 10 multiplied by two. Simple enough, right? If we wanted to use all of the numbers, not just the even ones, we could simply remove the if statement at the end of the expression.

Here's the thing, though: if you were to print <code>double_even_digits</code>, instead of a nice bunch of numbers, you'd get something that looks like this:

<code><generator object <genexpr><code>at 0x107fc92b0></code>

That's because generators are lazy! They don't generate their values until those values are needed, and they discard values once they're no longer needed. As a result, '''you can only iterate over a generator once'''. In this case, you can't print out the whole generator, because it hasn't generated all the values yet. You can, however, iterate over the generator, and print its values one at a time, like so:

<source lang="python">
for number in double_even_digits:
print(number)
</source>
You can also make a list out of the generator, which will go through all the items in the generator and put them in a list, like so:

<source lang="python">
even_number_list = list(double_even_digits)
</source>
That's actually a great segue to the second topic of this section: comprehensions. A comprehension is just a prettier way to make lists, sets, and dicts out of a generator expressions.

<source lang="python">
# If you want a list:
list(i for i in range(10) if i % 2 == 0) # Don't do this
[i for i in range(10) if i % 2 == 0] # Use a list comprehension instead!

# If you want a set:
set(i for i in range(10) if i % 2 == 0) # Don't do this
{i for i in range(10) if i % 2 == 0} # Use a set comprehension instead!

# If you want a dict:
dict((i, i + 1) for i in range(10) if i % 2 == 0) # Don't do this
{i : i + 1 for i in range(10) if i % 2 == 0} # Use a dict comprehension instead!

# If you want a tuple:
tuple(i for i in range(10) if i % 2 == 0) # Unfortunately, there's no better way to do this
</source>
In general, generators and comprehensions should be used whenever possible - they're the fastest and easiest way to build collections. If you ever see yourself writing code like this:

<source lang="python">
# BAD PRACTICE! DO NOT USE!
digits = []
for digit in range(10):
digits.append(digit)
</source>
Don't do it! Instead, use a generator expression or comprehension, as appropriate. A good way to decide whether a generator expression or comprehension is better for this situation is that, if you're just going to be iterating over your collection once, you should use an generator expression. If not, use a comprehension.

=== Sorting ===

Sorting in Python is frequently performed using the <code>sorted</code> function, which takes two arguments: an iterable (anything you can do a for-loop over, including lists and tuples) and a function used to evaluate each item. If the function is omitted, Python will try to sort the lists by value.

The following example demonstrates using an inline function, which Python calls a ''lambda''.

<source lang="python">
fruits = ['apple', 'banana', 'cherry', 'date']

# sort the fruits by string length
new_fruits = sorted(fruits, key=lambda v: len(v) // 2)

print(new_fruits) # ['date', 'apple', 'banana', 'cherry']
</source>
Alternatively, you can sort a <code>list</code> using the <code>.sort</code> method. This is faster than calling <code>sorted</code>, but it modifies the list in-place and returns <code>None</code>.

<source lang="python">
fruits = ['apple', 'banana', 'cherry', 'date']
fruits.sort()
</source>
=== Import ===

If you want to use functions from other libraries (including ones that you install using pip), use <code>import</code>:

<source lang="python">
import time

current_time = time.localtime()
print(time.strftime('%a, %d %b %Y %H:%M:%S', current_time))
</source>
If you want to pull the functions out of their namespace, you can use <code>from ___ import ___</code> syntax:

<source lang="python">
from time import localtime, strftime

current_time = localtime()
print(strftime('%a, %d %b %Y %H:%M:%S', current_time))

# Be aware that this technique, although convenient, may cause unexpected behavior if the function names that you're pulling out of the namespace are already used for other purposes in Python.
</source>
=== File I/O ===

You can read an entire file into a variable like this:

<source lang="python">
f = open("example.txt")
file_contents = f.read()

f.close() # free up memory when we're finished with the file
</source>
A better option is to use a with-block, which handles opening and closing the file for you automatically:

<source lang="python">
with open("example.txt") as f:
file_contents = f.read()
</source>
You can read a file line-by-line like this:

<source lang="python">
with open("example.txt") as f:
for line in f:
print("Read line: %s" % line.rstrip())
</source>
You can write to a file like this:

<source lang="python">
with open("example.txt", "w") as f:
f.write("Hello\nWorld\n")
</source>
=== Command-Line Arguments ===

Command line arguments are accessible in the variable <code>sys.argv</code>.

The following example shows a program that expects a filename as its argument, and it prints a usage message if the argument is not present ([https://stackoverflow.com/questions/983201/python-and-sys-argv source]).

<source lang="python">
import sys, os

if len(sys.argv) < 2:
sys.exit(f"Usage: {sys.argv[0]} filename")

filename = sys.argv[1]

if not os.path.exists(filename):
sys.exit(f"Error: File '{sys.argv[1]}' not found")
</source>

=== Object-Oriented Programming ===

You can define and use a class like this:

<source lang="python">
class Food:
# constructor:
def __init__(self, name):
self.name = name

def format_name(self):
return f"Gotta love to eat {self.name}"

class Fruit(Food):
def get_definition(self):
return f"{self.format_name()} (fruit)"

fruit = Fruit("Cherry")
print(fruit.format_name())
print(fruit.get_definition())
</source>
This is the same example as in [[PHP#Object-Oriented_Programming|the PHP guide]].

Some things to notice:

* Instance methods ''always'' take <code>self</code> as their first argument, followed by any number of additional parameters. This can be misleading for programmers familiar with other languages, because the number of arguments you feed to the method is actually ''one less than'' the number of declared parameters. Whenever you call a method on a class instance, that instance is implicitly fed into the explicitly-declared <code>self</code> parameter of the method.
*: Note that the <code>self</code> variable has the same purpose as the <code>this</code> variable in languages like PHP, Java, JavaScript, and C++.
*There is no need for a <code>new</code> keyword in Python.

= Footnotes =
# {{note|interpreted}}This is an oversimplification. If you're interested, here's a quick explanation of how: In CPython (the reference implementation of Python) programs are compiled to bytecode, an intermediate representation, which is then interpreted.
[[Category:Module 4]]

Python

2018-02-19T18:22:16Z

Alex: /* Object-Oriented Programming */

Languages like Java and C++ have lots of rules regarding variable types, syntax, return values, and so on. These can be cumbersome when you are trying to write short, quick scripts to perform tasks. This is where a ''scripting language'' comes into play.

'''Python''' is a language well-suited to rapid prototype development. It is generally an ''interpreted language'', which means that, generally speaking, a Python program is converted line by line into instructions for the computer to execute as the program runs, instead of having a separate compilation step beforehand {{ref|interpreted}}. The syntax is clean, and it is usually clear at first glance what is going on when you write in Python.

= Installation =

Python may already be installed on your system. To see whether or not it is, enter the command

<source lang="bash">
$ python3 --version
</source>
If it tells you a version of Python '''greater than or equal to 3.6''' then you're good to go. If not, you need to do a quick package install to get it up and running. Using yum, it's just <code>sudo yum install python36</code>.

If you'd like to be able to just type <code>python</code> instead of <code>python3</code>, you can add the following line to the <code>~/.bashrc</code> file on your instance:

<source lang="bash">
alias python="/usr/bin/python3"
</source>

==== Python 2 vs Python 3 ====

In 2008, a new version of Python – Python 3 – was released, with a number of changes that made it incompatible with the previous version, Python 2. For several years, the Python community was slow to make the change to Python 3, but today, Python 3 is ''the'' standard for new code. The ''only'' reason to write Python 2 code today is because you have to work in an environment or with libraries that do not support Python 3, and that situation is becoming increasingly rare.

'''For CSE 330 (and this guide), you ''must'' use Python 3.6 or greater.'''

=== Pip ===

Linux distributions have package managers like ''Apt'', ''Yum'', and ''YaST''. PHP has a package manager named ''PEAR''. It's now time to introduce Python's leading package manager: '''pip'''.

Once you have pip installed, you can use it to install Python packages. Use the <code>pip-3.6</code> command:

<source lang="bash">
$ pip-3.6 install package_name # RHEL
</source>

If you'd like to be able to just type <code>pip</code> instead of <code>pip-3.6</code>, you can add the following line to the <code>~/.bashrc</code> file on your instance:

<source lang="bash">
alias pip="/usr/bin/pip-3.6"
</source>

= Running Python =

There are two common ways to run Python code: via the console, and via a Python script file.

=== The Python Console ===

The Python console enables you to experiment with code without opening a text editor. To enter the Python console, simply type the ''python'' command at the terminal:

<source lang="bash">
$ python3
</source>
To leave the interactive console, either type <code>quit()</code> or press <code>Ctrl-D</code> (on both Mac and Windows).

=== Python Script Files ===

You can also save Python script files for later use. The extension for Python scripts is <code>*.py</code>. To run a script file, simply feed its path as an argument to the <code>python</code> command in Terminal:

<source lang="bash">
$ python3 my_script.py
</source>

= Python Syntax and Language Components =

This section contains a very brief overview of Python syntax. For a more comprehensive introduction, see [http://docs.python.org/tutorial/ the Python docs].

=== Python's Type System ===

Python is a dynamically-typed, strongly-typed, and duck-typed language. What does that mean? Well, let's take those categories one by one:

<ol>
<li>
'''Dynamic typing''', in contrast to ''static typing'' means that the types of objects can be changed. In Java, for instance, if you tried to write the following code:

<source lang="java">
int c = 2;
c = "fish";
</source>

Your code would fail to compile, because the Java compiler wouldn't allow you to change the type of the variable <code>c</code> from <code>int</code> to <code>String</code>.

Python, however, is just fine with that. You can write:

<source lang="python">
c = 2
c = "fish"
</source>

And Python will happily do what you ask.
</li>

<li>
'''Strong typing''', in contrast to ''weak typing'', means, roughly, that a language won't implicitly convert types for you. So far, you've used a lot of PHP, which is very weakly typed. For example:

<source lang="php">
echo "10" . 2;
</source>

In PHP, this works just fine. The PHP interpreter sees that <code>2</code> is an int, and silently converts it to a string for you, so that <code>"10". 2</code> equals <code>"102"</code>. The problem with weak typing is that it can make it unclear to the programmer why things are happening the way they are. For instance, in PHP, the expression <code>"10" == 10</code> is true, which can be less than obvious. Python, however, tries to disallow that sort of thing:

<source lang="python">
"10" + "10" # Allowed – concatenates the two strings.
10 + 10 # Allowed – adds the two ints.
"10" + 10 # Not allowed – raises a TypeError
</source>

Perhaps the one exception to this rule is the relationship between numeric types; it's perfectly fine to add a float to an int, for example.
</li>

<li>
'''Duck-typing''' is a little bit different than the other categories, because it doesn't really have a direct opposite. Essentially, duck-typing is the philosophy that "If it walks like a duck, and quacks like a duck, it's a duck." In programming terms, that means that we often don't care what type an object is, as long as it can do the things we ask.

Let's look at an example:

<source lang="python">
# This function doubles the value it's passed.
def double(thing):
return thing + thing
double(10) # Returns 20
double("fish") # Returns "fishfish";
</source>

If this were Java, we'd have to write two different methods here: one for things of type <code>int</code>, and one for things of type <code>String</code>. Since this is Python, though, we don't have to do that. Instead, Python lets us say, essentially: "This function uses the <code>+</code> operator, so you can pass whatever object you want to the function, as long as the function supports the <code>+</code> operator".

To quote [https://groups.google.com/forum/?hl=en#!msg/comp.lang.python/CCs2oJdyuzc/NYjla5HKMOIJ Alex Martelli], one of the key people in the Python project,

<blockquote>
"[Don't] check whether it IS-a duck: check whether it QUACKS-like-a duck, WALKS-like-a duck, etc, etc, depending on exactly what subset of duck-like behaviour you need."
</blockquote>

</li>
</ol>

=== Basic Types ===

In Python, the basic scalar types are:

# <code>str</code> – a string.
# <code>int</code> – an integer object with unlimited digits.
# <code>bool</code> – a Boolean value.
# <code>float</code> – a floating point number; generally equivalent to <code>double</code> in Java.
# <code>bytes</code> – represents a collection of bytes; you're unlikely to use this often.

Casting is done in the C style - to parse an <code>int</code> from a string, for instance, you'd write <code>int("123")</code>.

=== Basic Control Flow ===
In Python, blocks of code are delineated using colons and indentation instead of curly braces. '''''That means that proper indentation is mandatory.''''' Every time you use a colon, you must indent one step further, and every time a block ends, you must unindent a step.

Conditional statements are done using the <code>if</code>, <code>elif</code>, and <code>else</code> operators, like in the example below - pay attention to the indentation:

<source lang="python">
cookies_left = 10
cake_slices_left = 3
if cookies_left > 10:
print("Lots of cookies!")
elif cookies_left > 8:
print("Plenty left!")
elif cookies_left == 5:
print("Halfway done!")
else:
if cake_slices_left == 3:
print("Lots of cake!")
elif cake_slices_left == 2:
print("One slice gone!")
else:
print("Little to no cake left!")
</source>

=== An Example Python Script ===

In my mind, there's no better way to learn Python than to be immersed in a simple example script.

<source lang="python">
print("Hello World")

fruits = ["apple", "banana", "cherry", "date"]
for fruit in fruits:
print(f"I always love to eat a fresh {fruit}")

# Map the fruits list over to a new list containing the length of the fruit strings:
fruit_size = [len(fruit) for fruit in fruits]

avg_fruit_size = sum(fruit_size) / len(fruit_size)
print(f"The average fruit string length is {avg_fruit_size:.2f}.")
</source>

Some things to notice:

* Printing is achieved using the <code>print()</code> function.
* Comments start with a pound symbol <code>#</code>.
* We can transform/map a list to a new list in just one line!

For some more examples, see [https://wiki.python.org/moin/SimplePrograms the Python wiki].

=== A Few Gotchas ===

Here are a few things you may not expect when starting out with Python:

<ol>

<li>
Strings can be delimited using either single quotes (<code>'</code>) or double quotes (<code>"</code>), so <code>'Python'</code> is the same as <code>"Python"</code. You can also use three sets of quotes (<code>'''</code> or <code>"""</code>) to delineate a multiple-line string, like so:
<source lang="python">
long_string = """This
is my
very long
multiple-line
string"""
</source>
</li>

<li>
To compare the equality of two objects, use the <code>==</code> operator. To compare the identity of two objects (i.e. whether or not they are literally the same object, at the same place in memory), use the <code>is</code> operator. These correspond, respectively to <code>.equals()</code> and <code>==</code> in Java.
</li>

<li>
The <code>/</code> operator performs floating-point division, not integer division, even when both its arguments are integers. If you want to do integer division, use the <code>//</code> operator. Let's look at an example:

<source lang="python">
9 / 10 == 0.9 # Floating-point division
9.0 / 10.0 == 0.9 # Floating-point division
9 // 10 == 0 # Integer division
9.0 // 10.0 == 0.0 # Integer division, even though the resulting value is a float
</source>
</li>

<li>
As discussed in the section [[#Python's_Type_System|Python's Type System]], you can't combine strings and numbers using the <code>+</code> operator. Instead, you'll have to use one of the following methods of string formatting:

<source lang="python">

# Technique 1 – printf-style Formatting
# This is a classic style of string formatting, used in many programming languages, including in Java's String.format.
"You scored %d out of %d!" % (score, questions)

# Technique 2 – str.format
"You scored {} out of {}!".format(score, questions)

# Technique 3 – f-strings
# These were only introduced in Python 3.6 but they're very convenient.
f"You scored {score} out of {questions}!"

# Technique 4 - String Concatenation
# This is fine for small things, but for more complicated stuff, use one of the other techniques.
"You scored " + str(score) + " out of " + str(questions) + "!"
</source>
</li>
</ol>

=== Functions ===

Define functions using the <code>def</code> keyword:

<source lang="python">
def hello(name):
print(f"Hello, {name}!")

</source>

Invoke functions using parentheses:
<source lang="python">
hello("Batman")
hello("Superman")
</source>

Functions can have optional arguments; however, these must come after any required arguments:
<source lang="python">
def hello(name="User"):
print(f"Hello, {name}!")

hello() # Prints "Hello, User!"
hello("Sarah") # Prints "Hello, Sarah!"
</source>

Functions are just regular objects in Python, meaning you can do stuff like this:

<source lang="python">
def hello(name="User"):
print(f"Hello, {name}!")

greeting = hello

greeting("Siwei") # Prints "Hello, Siwei!"
</source>

=== Collection Types ===
Python has a few basic, built-in collection types. They each have their own special use cases, but they share a lot of similarities. All built-in data structures in Python are zero-indexed, for instance.

To obtain the number of elements in a collection, use the <code>len()</code> function, like this:

<source lang="python">
pets = ['Dog', 'Cat', 'Fish'] # This is a list; you'll learn about them below.

len(pets) # Returns 3
</source>

To check if a collection contains an item, use the <code>in</code> operator:
<source lang="python">
pets = ['Dog', 'Cat', 'Fish'] # This is a list; you'll learn about them below.

'Dog' in pets # Returns True
</source>

Helpfully, the Python Software Foundation maintains a page containing the asymptotic complexities of important operations on major Python data structures. It's available [https://wiki.python.org/moin/TimeComplexity here].

==== Lists ====

Unlike languages like Java and C, Python's array-like type doesn't have fixed length. Instead, a <code>list</code> is a dynamic array (like Java's <code>ArrayList</code>) of objects of any type. Here's an example:

<source lang="python">
fruits = ["Apple", "Pear", "Orange"] # Lists can be creating by placing their items between square brackets

random_items = ['Apple', 12312, 2.0, [1, 2, 3]] # Lists can contain objects of different types - even other lists!

pets.append('Turtle') # Adds 'Turtle' to the end of pets
</source>

For the next few examples, we'll be using the following list:

<source lang="python">
pets = ['Dog', 'Cat', 'Fish', 'Turtle', 'Lizard', 'Snake']
</source>

To access or assign elements of a list, use the <code>[]</code> operator.

<source lang="python">
pets[0] # Returns 'Dog'
pets[1] = 'Cow' # Sets pets[1] to 'Cow'
pets[1] = 'Cat' # Sets pets[1] back to 'Cat'
</source>

You can also access or assign lists using negative indices, which will return elements starting from the end of the list:

<source lang="python">
pets[-1] # Returns 'Snake'
pets[-2] # Returns 'Lizard'
</source>

You can also use 'slice notation' to obtain or assign subsets of lists:
<source lang="python">
pets[start:end] # Returns items from index start to index end - 1.
pets[start:] # Returns items from index start to the end of the list, inclusive.
pets[:end] # Returns items from the beginning of the list to index end - 1.
pets[:] # Returns every item in the list
</source>

There's also a third, optional argument: <code>step</code>, which lets you jump over values:
<source lang="python">
pets[start:end:step] # Returns items from index start to index end - 1, jumping step values at a time

# Examples:
pets[1:5:2] # Returns items from index 1 to index 4, jumping 2 at a time, so ['Cat', 'Turtle']
pets[::3] # Returns all items in the list, jumping 3 at a time, so ['Dog', 'Turtle']
pets[::-1] # Returns all items in the list, jumping -1 at a time. This reverses the list, so ['Snake', 'Lizard', 'Turtle', 'Fish', 'Cat', 'Dog']
</source>

Lists have all the performance characteristics you'd expect of a dynamic array - constant-time indexing, amortized constant-time appends, and so on.

==== Tuples ====

Python has a special data type called <code>tuple</code>, which is exactly the same as a list except for the fact that it cannot be modified, so you can't append or replace items.

<source lang="python">
cities = ('St. Louis', 'Los Angeles', 'Seattle') # Tuples are defined using parentheses.
numbers = 1, 2, 3 # You can also omit the parentheses if it's unambiguous
single_item_tuple = (1,) # To make a tuple with only one item, put a comma after it
</source>

Tuples also enable you to have multiple return values from a function:

<source lang="python">
def compute_length(string):
str_len = len(string)
if str_len < 5:
return str_len, "short"
elif str_len < 40:
return str_len, "medium"
return str_len, "long"

length, description = compute_length("Four score and seven years ago")
print(f"The {description} string is {length} characters long.")
</source>
The above example also demonstrates Python's if...elif...else conditional structure.

==== Dictionaries ====

Python has another datatype called a '''dictionary''' (or <code>dict</code>, for short), which are like ''Maps'' in Java, ''associative arrays'' in PHP, and ''object literals'' in JavaScript (coming up soon in Module 6). Essentially, they enable you to use any immutable object as the key in your data structure. <code>dict</code> objects can be created using either the <code>dict</code> function, or by placing items between curly braces, separating keys and values using colons:

<source lang="python">
fruits_in_bowl = {
'apple': 4,
'banana': 2,
'cherry': 0,
'date': 12
}

apple_count = fruits_in_bowl['apple'] # Equals 4

fruits_in_bowl['pear'] = 9 # Sets 'pear' in the dictionary to 9.

for fruit, num in fruits_in_bowl.items():
print(f"There are {num} {fruit}(s) in the bowl." % (num, fruit))
</source>
If you only want the keys from a dictionary, you can just iterate over it directly, like this:

<source lang="python">
for fruit in fruits_in_bowl:
print(fruit)
</source>
If you want only the values but not the keys from a dictionary, use <code>my_dictionary.values()</code>.

==== Sets ====
A <code>set</code> is an unordered collection of unique items, with constant-time membership checking.
<source lang="python">
fruits = {'Apple', 'Apple', 'Apple', 'Pear'} # The set removes duplicates, so it will only contain {'Apple', 'Pear'}
fruits = set(['Apple', 'Apple', 'Apple', 'Pear']) # This line transforms a list into a set
print('Apple' in fruits) # Constant-time!
</source>

=== Loops ===

In Python, while loops are written like this:

<source lang="python">
i = 0
while i < 10:
i += 1
</source>
For loops are written like this:

<source lang="python">
pets = ['Dog', 'Cat', 'Fish']

for pet in pets:
print(pet)
</source>
To iterate over a range of numbers, you can use the convenient <code>range</code> function, like so:

<source lang="python">
for i in range(20, 30): # If you omit the first argument to range, it's assumed to be zero.
print(i)
</source>
Note that <code>range</code> provides a closed-open range. That is to say, it is inclusive of its lower bound and exclusive of its upper bound. To be very explicit about it:

<source lang="python">
list(range(3, 6)) == [3, 4, 5]
</source>
Unlike in other languages you may know, the following is not good practice in Python:

<source lang="python">
pets = ['Dog', 'Cat', 'Fish']

# BAD PRACTICE. DO NOT USE.
for i in range(len(pets)):
pet = pets[i]
</source>
Instead, if you need to access both a variable and its index, use the <code>enumerate</code> function, which allows you to iterate through a group of items, along with their indexes, like so:

<source lang="python">
pets = ['Dog', 'Cat', 'Fish']

for index, pet in enumerate(pets):
print(f"{pet} at index {index}")
</source>

=== Generator Expressions and Comprehensions ===

A generator is a special kind of object that, basically, represents a collection of items using a value and a function for generating the next value in the collection. In other words, it's a way of creating something that behaves like a list, but which only generates one value at a time, and discards a value when it's done with it. Say, for example, you wanted to do an operation on 10,000,000,000,000 numbers. You could put them all in a list, then iterate over the list, but that would take a lot of memory, plus you'd have to create and fill the entire list before beginning to actually work on your problem. Instead, you'd probably be better off using a generator; telling the computer, essentially: “The starting value is 0. When I ask for the next number in the collection, add 1 to current value and give me that.”

A generator expression is an expression that is evaluated to create a generator. They're super useful. Generator expressions can take two forms – they can be used with and without a condition:

<source lang="python">
(EXPRESSION for VARIABLE in ITERABLE) # Unconditional
(EXPRESSION for VARIABLE in ITERABLE if CONDITION) # Conditional
</source>
For our purposes, you can think of an iterable as anything you can do a for loop over. Let's take a look at a generator expression in use:

<source lang="python">
double_even_digits = (number * 2 for number in range(10) if number % 2 == 0)
</source>
That line says that <code>double_even_digits</code> is every even number between 0 and 10 multiplied by two. Simple enough, right? If we wanted to use all of the numbers, not just the even ones, we could simply remove the if statement at the end of the expression.

Here's the thing, though: if you were to print <code>double_even_digits</code>, instead of a nice bunch of numbers, you'd get something that looks like this:

<code><generator object <genexpr><code>at 0x107fc92b0></code>

That's because generators are lazy! They don't generate their values until those values are needed, and they discard values once they're no longer needed. As a result, '''you can only iterate over a generator once'''. In this case, you can't print out the whole generator, because it hasn't generated all the values yet. You can, however, iterate over the generator, and print its values one at a time, like so:

<source lang="python">
for number in double_even_digits:
print(number)
</source>
You can also make a list out of the generator, which will go through all the items in the generator and put them in a list, like so:

<source lang="python">
even_number_list = list(double_even_digits)
</source>
That's actually a great segue to the second topic of this section: comprehensions. A comprehension is just a prettier way to make lists, sets, and dicts out of a generator expressions.

<source lang="python">
# If you want a list:
list(i for i in range(10) if i % 2 == 0) # Don't do this
[i for i in range(10) if i % 2 == 0] # Use a list comprehension instead!

# If you want a set:
set(i for i in range(10) if i % 2 == 0) # Don't do this
{i for i in range(10) if i % 2 == 0} # Use a set comprehension instead!

# If you want a dict:
dict((i, i + 1) for i in range(10) if i % 2 == 0) # Don't do this
{i : i + 1 for i in range(10) if i % 2 == 0} # Use a dict comprehension instead!

# If you want a tuple:
tuple(i for i in range(10) if i % 2 == 0) # Unfortunately, there's no better way to do this
</source>
In general, generators and comprehensions should be used whenever possible - they're the fastest and easiest way to build collections. If you ever see yourself writing code like this:

<source lang="python">
# BAD PRACTICE! DO NOT USE!
digits = []
for digit in range(10):
digits.append(digit)
</source>
Don't do it! Instead, use a generator expression or comprehension, as appropriate. A good way to decide whether a generator expression or comprehension is better for this situation is that, if you're just going to be iterating over your collection once, you should use an generator expression. If not, use a comprehension.

=== Sorting ===

Sorting in Python is frequently performed using the <code>sorted</code> function, which takes two arguments: an iterable (anything you can do a for-loop over, including lists and tuples) and a function used to evaluate each item. If the function is omitted, Python will try to sort the lists by value.

The following example demonstrates using an inline function, which Python calls a ''lambda''.

<source lang="python">
fruits = ['apple', 'banana', 'cherry', 'date']

# sort the fruits by string length
new_fruits = sorted(fruits, key=lambda v: len(v) // 2)

print(new_fruits) # ['date', 'apple', 'banana', 'cherry']
</source>
Alternatively, you can sort a <code>list</code> using the <code>.sort</code> method. This is faster than calling <code>sorted</code>, but it modifies the list in-place and returns <code>None</code>.

<source lang="python">
fruits = ['apple', 'banana', 'cherry', 'date']
fruits.sort()
</source>
=== Import ===

If you want to use functions from other libraries (including ones that you install using pip), use <code>import</code>:

<source lang="python">
import time

current_time = time.localtime()
print(time.strftime('%a, %d %b %Y %H:%M:%S', current_time))
</source>
If you want to pull the functions out of their namespace, you can use <code>from ___ import ___</code> syntax:

<source lang="python">
from time import localtime, strftime

current_time = localtime()
print(strftime('%a, %d %b %Y %H:%M:%S', current_time))

# Be aware that this technique, although convenient, may cause unexpected behavior if the function names that you're pulling out of the namespace are already used for other purposes in Python.
</source>
=== File I/O ===

You can read an entire file into a variable like this:

<source lang="python">
f = open("example.txt")
file_contents = f.read()

f.close() # free up memory when we're finished with the file
</source>
A better option is to use a with-block, which handles opening and closing the file for you automatically:

<source lang="python">
with open("example.txt") as f:
file_contents = f.read()
</source>
You can read a file line-by-line like this:

<source lang="python">
with open("example.txt") as f:
for line in f:
print("Read line: %s" % line.rstrip())
</source>
You can write to a file like this:

<source lang="python">
with open("example.txt", "w") as f:
f.write("Hello\nWorld\n")
</source>
=== Command-Line Arguments ===

Command line arguments are accessible in the variable <code>sys.argv</code>.

The following example shows a program that expects a filename as its argument, and it prints a usage message if the argument is not present ([https://stackoverflow.com/questions/983201/python-and-sys-argv source]).

<source lang="python">
import sys, os

if len(sys.argv) < 2:
sys.exit(f"Usage: {sys.argv[0]} filename")

filename = sys.argv[1]

if not os.path.exists(filename):
sys.exit(f"Error: File '{sys.argv[1]}' not found")
</source>

=== Object-Oriented Programming ===

You can define and use a class like this:

<source lang="python">
class Food:
# constructor:
def __init__(self, name):
self.name = name

def format_name(self):
return f"Gotta love to eat {self.name}"

class Fruit(Food):
def get_definition(self):
return f"{Food.format_name(self)} (fruit)"

fruit = Fruit("Cherry")
print(fruit.format_name())
print(Food.get_definition())
</source>
This is the same example as in [[PHP#Object-Oriented_Programming|the PHP guide]].

Some things to notice:

* Instance methods ''always'' take <code>self</code> as their first argument, followed by any number of additional parameters. This can be misleading for programmers familiar with other languages, because the number of arguments you feed to the method is actually ''one less than'' the number of declared parameters. Whenever you call a method on a class instance, that instance is implicitly fed into the explicitly-declared <code>self</code> parameter of the method.
*: Note that the <code>self</code> variable has the same purpose as the <code>this</code> variable in languages like PHP, Java, JavaScript, and C++.
*There is no need for a <code>new</code> keyword in Python.

= Footnotes =
# {{note|interpreted}}This is an oversimplification. If you're interested, here's a quick explanation of how: In CPython (the reference implementation of Python) programs are compiled to bytecode, an intermediate representation, which is then interpreted.
[[Category:Module 4]]

Python

2018-02-19T18:20:50Z

Alex: /* Installation */ Replaced bash_profile with bashrc

Languages like Java and C++ have lots of rules regarding variable types, syntax, return values, and so on. These can be cumbersome when you are trying to write short, quick scripts to perform tasks. This is where a ''scripting language'' comes into play.

'''Python''' is a language well-suited to rapid prototype development. It is generally an ''interpreted language'', which means that, generally speaking, a Python program is converted line by line into instructions for the computer to execute as the program runs, instead of having a separate compilation step beforehand {{ref|interpreted}}. The syntax is clean, and it is usually clear at first glance what is going on when you write in Python.

= Installation =

Python may already be installed on your system. To see whether or not it is, enter the command

<source lang="bash">
$ python3 --version
</source>
If it tells you a version of Python '''greater than or equal to 3.6''' then you're good to go. If not, you need to do a quick package install to get it up and running. Using yum, it's just <code>sudo yum install python36</code>.

If you'd like to be able to just type <code>python</code> instead of <code>python3</code>, you can add the following line to the <code>~/.bashrc</code> file on your instance:

<source lang="bash">
alias python="/usr/bin/python3"
</source>

==== Python 2 vs Python 3 ====

In 2008, a new version of Python – Python 3 – was released, with a number of changes that made it incompatible with the previous version, Python 2. For several years, the Python community was slow to make the change to Python 3, but today, Python 3 is ''the'' standard for new code. The ''only'' reason to write Python 2 code today is because you have to work in an environment or with libraries that do not support Python 3, and that situation is becoming increasingly rare.

'''For CSE 330 (and this guide), you ''must'' use Python 3.6 or greater.'''

=== Pip ===

Linux distributions have package managers like ''Apt'', ''Yum'', and ''YaST''. PHP has a package manager named ''PEAR''. It's now time to introduce Python's leading package manager: '''pip'''.

Once you have pip installed, you can use it to install Python packages. Use the <code>pip-3.6</code> command:

<source lang="bash">
$ pip-3.6 install package_name # RHEL
</source>

If you'd like to be able to just type <code>pip</code> instead of <code>pip-3.6</code>, you can add the following line to the <code>~/.bashrc</code> file on your instance:

<source lang="bash">
alias pip="/usr/bin/pip-3.6"
</source>

= Running Python =

There are two common ways to run Python code: via the console, and via a Python script file.

=== The Python Console ===

The Python console enables you to experiment with code without opening a text editor. To enter the Python console, simply type the ''python'' command at the terminal:

<source lang="bash">
$ python3
</source>
To leave the interactive console, either type <code>quit()</code> or press <code>Ctrl-D</code> (on both Mac and Windows).

=== Python Script Files ===

You can also save Python script files for later use. The extension for Python scripts is <code>*.py</code>. To run a script file, simply feed its path as an argument to the <code>python</code> command in Terminal:

<source lang="bash">
$ python3 my_script.py
</source>

= Python Syntax and Language Components =

This section contains a very brief overview of Python syntax. For a more comprehensive introduction, see [http://docs.python.org/tutorial/ the Python docs].

=== Python's Type System ===

Python is a dynamically-typed, strongly-typed, and duck-typed language. What does that mean? Well, let's take those categories one by one:

<ol>
<li>
'''Dynamic typing''', in contrast to ''static typing'' means that the types of objects can be changed. In Java, for instance, if you tried to write the following code:

<source lang="java">
int c = 2;
c = "fish";
</source>

Your code would fail to compile, because the Java compiler wouldn't allow you to change the type of the variable <code>c</code> from <code>int</code> to <code>String</code>.

Python, however, is just fine with that. You can write:

<source lang="python">
c = 2
c = "fish"
</source>

And Python will happily do what you ask.
</li>

<li>
'''Strong typing''', in contrast to ''weak typing'', means, roughly, that a language won't implicitly convert types for you. So far, you've used a lot of PHP, which is very weakly typed. For example:

<source lang="php">
echo "10" . 2;
</source>

In PHP, this works just fine. The PHP interpreter sees that <code>2</code> is an int, and silently converts it to a string for you, so that <code>"10". 2</code> equals <code>"102"</code>. The problem with weak typing is that it can make it unclear to the programmer why things are happening the way they are. For instance, in PHP, the expression <code>"10" == 10</code> is true, which can be less than obvious. Python, however, tries to disallow that sort of thing:

<source lang="python">
"10" + "10" # Allowed – concatenates the two strings.
10 + 10 # Allowed – adds the two ints.
"10" + 10 # Not allowed – raises a TypeError
</source>

Perhaps the one exception to this rule is the relationship between numeric types; it's perfectly fine to add a float to an int, for example.
</li>

<li>
'''Duck-typing''' is a little bit different than the other categories, because it doesn't really have a direct opposite. Essentially, duck-typing is the philosophy that "If it walks like a duck, and quacks like a duck, it's a duck." In programming terms, that means that we often don't care what type an object is, as long as it can do the things we ask.

Let's look at an example:

<source lang="python">
# This function doubles the value it's passed.
def double(thing):
return thing + thing
double(10) # Returns 20
double("fish") # Returns "fishfish";
</source>

If this were Java, we'd have to write two different methods here: one for things of type <code>int</code>, and one for things of type <code>String</code>. Since this is Python, though, we don't have to do that. Instead, Python lets us say, essentially: "This function uses the <code>+</code> operator, so you can pass whatever object you want to the function, as long as the function supports the <code>+</code> operator".

To quote [https://groups.google.com/forum/?hl=en#!msg/comp.lang.python/CCs2oJdyuzc/NYjla5HKMOIJ Alex Martelli], one of the key people in the Python project,

<blockquote>
"[Don't] check whether it IS-a duck: check whether it QUACKS-like-a duck, WALKS-like-a duck, etc, etc, depending on exactly what subset of duck-like behaviour you need."
</blockquote>

</li>
</ol>

=== Basic Types ===

In Python, the basic scalar types are:

# <code>str</code> – a string.
# <code>int</code> – an integer object with unlimited digits.
# <code>bool</code> – a Boolean value.
# <code>float</code> – a floating point number; generally equivalent to <code>double</code> in Java.
# <code>bytes</code> – represents a collection of bytes; you're unlikely to use this often.

Casting is done in the C style - to parse an <code>int</code> from a string, for instance, you'd write <code>int("123")</code>.

=== Basic Control Flow ===
In Python, blocks of code are delineated using colons and indentation instead of curly braces. '''''That means that proper indentation is mandatory.''''' Every time you use a colon, you must indent one step further, and every time a block ends, you must unindent a step.

Conditional statements are done using the <code>if</code>, <code>elif</code>, and <code>else</code> operators, like in the example below - pay attention to the indentation:

<source lang="python">
cookies_left = 10
cake_slices_left = 3
if cookies_left > 10:
print("Lots of cookies!")
elif cookies_left > 8:
print("Plenty left!")
elif cookies_left == 5:
print("Halfway done!")
else:
if cake_slices_left == 3:
print("Lots of cake!")
elif cake_slices_left == 2:
print("One slice gone!")
else:
print("Little to no cake left!")
</source>

=== An Example Python Script ===

In my mind, there's no better way to learn Python than to be immersed in a simple example script.

<source lang="python">
print("Hello World")

fruits = ["apple", "banana", "cherry", "date"]
for fruit in fruits:
print(f"I always love to eat a fresh {fruit}")

# Map the fruits list over to a new list containing the length of the fruit strings:
fruit_size = [len(fruit) for fruit in fruits]

avg_fruit_size = sum(fruit_size) / len(fruit_size)
print(f"The average fruit string length is {avg_fruit_size:.2f}.")
</source>

Some things to notice:

* Printing is achieved using the <code>print()</code> function.
* Comments start with a pound symbol <code>#</code>.
* We can transform/map a list to a new list in just one line!

For some more examples, see [https://wiki.python.org/moin/SimplePrograms the Python wiki].

=== A Few Gotchas ===

Here are a few things you may not expect when starting out with Python:

<ol>

<li>
Strings can be delimited using either single quotes (<code>'</code>) or double quotes (<code>"</code>), so <code>'Python'</code> is the same as <code>"Python"</code. You can also use three sets of quotes (<code>'''</code> or <code>"""</code>) to delineate a multiple-line string, like so:
<source lang="python">
long_string = """This
is my
very long
multiple-line
string"""
</source>
</li>

<li>
To compare the equality of two objects, use the <code>==</code> operator. To compare the identity of two objects (i.e. whether or not they are literally the same object, at the same place in memory), use the <code>is</code> operator. These correspond, respectively to <code>.equals()</code> and <code>==</code> in Java.
</li>

<li>
The <code>/</code> operator performs floating-point division, not integer division, even when both its arguments are integers. If you want to do integer division, use the <code>//</code> operator. Let's look at an example:

<source lang="python">
9 / 10 == 0.9 # Floating-point division
9.0 / 10.0 == 0.9 # Floating-point division
9 // 10 == 0 # Integer division
9.0 // 10.0 == 0.0 # Integer division, even though the resulting value is a float
</source>
</li>

<li>
As discussed in the section [[#Python's_Type_System|Python's Type System]], you can't combine strings and numbers using the <code>+</code> operator. Instead, you'll have to use one of the following methods of string formatting:

<source lang="python">

# Technique 1 – printf-style Formatting
# This is a classic style of string formatting, used in many programming languages, including in Java's String.format.
"You scored %d out of %d!" % (score, questions)

# Technique 2 – str.format
"You scored {} out of {}!".format(score, questions)

# Technique 3 – f-strings
# These were only introduced in Python 3.6 but they're very convenient.
f"You scored {score} out of {questions}!"

# Technique 4 - String Concatenation
# This is fine for small things, but for more complicated stuff, use one of the other techniques.
"You scored " + str(score) + " out of " + str(questions) + "!"
</source>
</li>
</ol>

=== Functions ===

Define functions using the <code>def</code> keyword:

<source lang="python">
def hello(name):
print(f"Hello, {name}!")

</source>

Invoke functions using parentheses:
<source lang="python">
hello("Batman")
hello("Superman")
</source>

Functions can have optional arguments; however, these must come after any required arguments:
<source lang="python">
def hello(name="User"):
print(f"Hello, {name}!")

hello() # Prints "Hello, User!"
hello("Sarah") # Prints "Hello, Sarah!"
</source>

Functions are just regular objects in Python, meaning you can do stuff like this:

<source lang="python">
def hello(name="User"):
print(f"Hello, {name}!")

greeting = hello

greeting("Siwei") # Prints "Hello, Siwei!"
</source>

=== Collection Types ===
Python has a few basic, built-in collection types. They each have their own special use cases, but they share a lot of similarities. All built-in data structures in Python are zero-indexed, for instance.

To obtain the number of elements in a collection, use the <code>len()</code> function, like this:

<source lang="python">
pets = ['Dog', 'Cat', 'Fish'] # This is a list; you'll learn about them below.

len(pets) # Returns 3
</source>

To check if a collection contains an item, use the <code>in</code> operator:
<source lang="python">
pets = ['Dog', 'Cat', 'Fish'] # This is a list; you'll learn about them below.

'Dog' in pets # Returns True
</source>

Helpfully, the Python Software Foundation maintains a page containing the asymptotic complexities of important operations on major Python data structures. It's available [https://wiki.python.org/moin/TimeComplexity here].

==== Lists ====

Unlike languages like Java and C, Python's array-like type doesn't have fixed length. Instead, a <code>list</code> is a dynamic array (like Java's <code>ArrayList</code>) of objects of any type. Here's an example:

<source lang="python">
fruits = ["Apple", "Pear", "Orange"] # Lists can be creating by placing their items between square brackets

random_items = ['Apple', 12312, 2.0, [1, 2, 3]] # Lists can contain objects of different types - even other lists!

pets.append('Turtle') # Adds 'Turtle' to the end of pets
</source>

For the next few examples, we'll be using the following list:

<source lang="python">
pets = ['Dog', 'Cat', 'Fish', 'Turtle', 'Lizard', 'Snake']
</source>

To access or assign elements of a list, use the <code>[]</code> operator.

<source lang="python">
pets[0] # Returns 'Dog'
pets[1] = 'Cow' # Sets pets[1] to 'Cow'
pets[1] = 'Cat' # Sets pets[1] back to 'Cat'
</source>

You can also access or assign lists using negative indices, which will return elements starting from the end of the list:

<source lang="python">
pets[-1] # Returns 'Snake'
pets[-2] # Returns 'Lizard'
</source>

You can also use 'slice notation' to obtain or assign subsets of lists:
<source lang="python">
pets[start:end] # Returns items from index start to index end - 1.
pets[start:] # Returns items from index start to the end of the list, inclusive.
pets[:end] # Returns items from the beginning of the list to index end - 1.
pets[:] # Returns every item in the list
</source>

There's also a third, optional argument: <code>step</code>, which lets you jump over values:
<source lang="python">
pets[start:end:step] # Returns items from index start to index end - 1, jumping step values at a time

# Examples:
pets[1:5:2] # Returns items from index 1 to index 4, jumping 2 at a time, so ['Cat', 'Turtle']
pets[::3] # Returns all items in the list, jumping 3 at a time, so ['Dog', 'Turtle']
pets[::-1] # Returns all items in the list, jumping -1 at a time. This reverses the list, so ['Snake', 'Lizard', 'Turtle', 'Fish', 'Cat', 'Dog']
</source>

Lists have all the performance characteristics you'd expect of a dynamic array - constant-time indexing, amortized constant-time appends, and so on.

==== Tuples ====

Python has a special data type called <code>tuple</code>, which is exactly the same as a list except for the fact that it cannot be modified, so you can't append or replace items.

<source lang="python">
cities = ('St. Louis', 'Los Angeles', 'Seattle') # Tuples are defined using parentheses.
numbers = 1, 2, 3 # You can also omit the parentheses if it's unambiguous
single_item_tuple = (1,) # To make a tuple with only one item, put a comma after it
</source>

Tuples also enable you to have multiple return values from a function:

<source lang="python">
def compute_length(string):
str_len = len(string)
if str_len < 5:
return str_len, "short"
elif str_len < 40:
return str_len, "medium"
return str_len, "long"

length, description = compute_length("Four score and seven years ago")
print(f"The {description} string is {length} characters long.")
</source>
The above example also demonstrates Python's if...elif...else conditional structure.

==== Dictionaries ====

Python has another datatype called a '''dictionary''' (or <code>dict</code>, for short), which are like ''Maps'' in Java, ''associative arrays'' in PHP, and ''object literals'' in JavaScript (coming up soon in Module 6). Essentially, they enable you to use any immutable object as the key in your data structure. <code>dict</code> objects can be created using either the <code>dict</code> function, or by placing items between curly braces, separating keys and values using colons:

<source lang="python">
fruits_in_bowl = {
'apple': 4,
'banana': 2,
'cherry': 0,
'date': 12
}

apple_count = fruits_in_bowl['apple'] # Equals 4

fruits_in_bowl['pear'] = 9 # Sets 'pear' in the dictionary to 9.

for fruit, num in fruits_in_bowl.items():
print(f"There are {num} {fruit}(s) in the bowl." % (num, fruit))
</source>
If you only want the keys from a dictionary, you can just iterate over it directly, like this:

<source lang="python">
for fruit in fruits_in_bowl:
print(fruit)
</source>
If you want only the values but not the keys from a dictionary, use <code>my_dictionary.values()</code>.

==== Sets ====
A <code>set</code> is an unordered collection of unique items, with constant-time membership checking.
<source lang="python">
fruits = {'Apple', 'Apple', 'Apple', 'Pear'} # The set removes duplicates, so it will only contain {'Apple', 'Pear'}
fruits = set(['Apple', 'Apple', 'Apple', 'Pear']) # This line transforms a list into a set
print('Apple' in fruits) # Constant-time!
</source>

=== Loops ===

In Python, while loops are written like this:

<source lang="python">
i = 0
while i < 10:
i += 1
</source>
For loops are written like this:

<source lang="python">
pets = ['Dog', 'Cat', 'Fish']

for pet in pets:
print(pet)
</source>
To iterate over a range of numbers, you can use the convenient <code>range</code> function, like so:

<source lang="python">
for i in range(20, 30): # If you omit the first argument to range, it's assumed to be zero.
print(i)
</source>
Note that <code>range</code> provides a closed-open range. That is to say, it is inclusive of its lower bound and exclusive of its upper bound. To be very explicit about it:

<source lang="python">
list(range(3, 6)) == [3, 4, 5]
</source>
Unlike in other languages you may know, the following is not good practice in Python:

<source lang="python">
pets = ['Dog', 'Cat', 'Fish']

# BAD PRACTICE. DO NOT USE.
for i in range(len(pets)):
pet = pets[i]
</source>
Instead, if you need to access both a variable and its index, use the <code>enumerate</code> function, which allows you to iterate through a group of items, along with their indexes, like so:

<source lang="python">
pets = ['Dog', 'Cat', 'Fish']

for index, pet in enumerate(pets):
print(f"{pet} at index {index}")
</source>

=== Generator Expressions and Comprehensions ===

A generator is a special kind of object that, basically, represents a collection of items using a value and a function for generating the next value in the collection. In other words, it's a way of creating something that behaves like a list, but which only generates one value at a time, and discards a value when it's done with it. Say, for example, you wanted to do an operation on 10,000,000,000,000 numbers. You could put them all in a list, then iterate over the list, but that would take a lot of memory, plus you'd have to create and fill the entire list before beginning to actually work on your problem. Instead, you'd probably be better off using a generator; telling the computer, essentially: “The starting value is 0. When I ask for the next number in the collection, add 1 to current value and give me that.”

A generator expression is an expression that is evaluated to create a generator. They're super useful. Generator expressions can take two forms – they can be used with and without a condition:

<source lang="python">
(EXPRESSION for VARIABLE in ITERABLE) # Unconditional
(EXPRESSION for VARIABLE in ITERABLE if CONDITION) # Conditional
</source>
For our purposes, you can think of an iterable as anything you can do a for loop over. Let's take a look at a generator expression in use:

<source lang="python">
double_even_digits = (number * 2 for number in range(10) if number % 2 == 0)
</source>
That line says that <code>double_even_digits</code> is every even number between 0 and 10 multiplied by two. Simple enough, right? If we wanted to use all of the numbers, not just the even ones, we could simply remove the if statement at the end of the expression.

Here's the thing, though: if you were to print <code>double_even_digits</code>, instead of a nice bunch of numbers, you'd get something that looks like this:

<code><generator object <genexpr><code>at 0x107fc92b0></code>

That's because generators are lazy! They don't generate their values until those values are needed, and they discard values once they're no longer needed. As a result, '''you can only iterate over a generator once'''. In this case, you can't print out the whole generator, because it hasn't generated all the values yet. You can, however, iterate over the generator, and print its values one at a time, like so:

<source lang="python">
for number in double_even_digits:
print(number)
</source>
You can also make a list out of the generator, which will go through all the items in the generator and put them in a list, like so:

<source lang="python">
even_number_list = list(double_even_digits)
</source>
That's actually a great segue to the second topic of this section: comprehensions. A comprehension is just a prettier way to make lists, sets, and dicts out of a generator expressions.

<source lang="python">
# If you want a list:
list(i for i in range(10) if i % 2 == 0) # Don't do this
[i for i in range(10) if i % 2 == 0] # Use a list comprehension instead!

# If you want a set:
set(i for i in range(10) if i % 2 == 0) # Don't do this
{i for i in range(10) if i % 2 == 0} # Use a set comprehension instead!

# If you want a dict:
dict((i, i + 1) for i in range(10) if i % 2 == 0) # Don't do this
{i : i + 1 for i in range(10) if i % 2 == 0} # Use a dict comprehension instead!

# If you want a tuple:
tuple(i for i in range(10) if i % 2 == 0) # Unfortunately, there's no better way to do this
</source>
In general, generators and comprehensions should be used whenever possible - they're the fastest and easiest way to build collections. If you ever see yourself writing code like this:

<source lang="python">
# BAD PRACTICE! DO NOT USE!
digits = []
for digit in range(10):
digits.append(digit)
</source>
Don't do it! Instead, use a generator expression or comprehension, as appropriate. A good way to decide whether a generator expression or comprehension is better for this situation is that, if you're just going to be iterating over your collection once, you should use an generator expression. If not, use a comprehension.

=== Sorting ===

Sorting in Python is frequently performed using the <code>sorted</code> function, which takes two arguments: an iterable (anything you can do a for-loop over, including lists and tuples) and a function used to evaluate each item. If the function is omitted, Python will try to sort the lists by value.

The following example demonstrates using an inline function, which Python calls a ''lambda''.

<source lang="python">
fruits = ['apple', 'banana', 'cherry', 'date']

# sort the fruits by string length
new_fruits = sorted(fruits, key=lambda v: len(v) // 2)

print(new_fruits) # ['date', 'apple', 'banana', 'cherry']
</source>
Alternatively, you can sort a <code>list</code> using the <code>.sort</code> method. This is faster than calling <code>sorted</code>, but it modifies the list in-place and returns <code>None</code>.

<source lang="python">
fruits = ['apple', 'banana', 'cherry', 'date']
fruits.sort()
</source>
=== Import ===

If you want to use functions from other libraries (including ones that you install using pip), use <code>import</code>:

<source lang="python">
import time

current_time = time.localtime()
print(time.strftime('%a, %d %b %Y %H:%M:%S', current_time))
</source>
If you want to pull the functions out of their namespace, you can use <code>from ___ import ___</code> syntax:

<source lang="python">
from time import localtime, strftime

current_time = localtime()
print(strftime('%a, %d %b %Y %H:%M:%S', current_time))

# Be aware that this technique, although convenient, may cause unexpected behavior if the function names that you're pulling out of the namespace are already used for other purposes in Python.
</source>
=== File I/O ===

You can read an entire file into a variable like this:

<source lang="python">
f = open("example.txt")
file_contents = f.read()

f.close() # free up memory when we're finished with the file
</source>
A better option is to use a with-block, which handles opening and closing the file for you automatically:

<source lang="python">
with open("example.txt") as f:
file_contents = f.read()
</source>
You can read a file line-by-line like this:

<source lang="python">
with open("example.txt") as f:
for line in f:
print("Read line: %s" % line.rstrip())
</source>
You can write to a file like this:

<source lang="python">
with open("example.txt", "w") as f:
f.write("Hello\nWorld\n")
</source>
=== Command-Line Arguments ===

Command line arguments are accessible in the variable <code>sys.argv</code>.

The following example shows a program that expects a filename as its argument, and it prints a usage message if the argument is not present ([https://stackoverflow.com/questions/983201/python-and-sys-argv source]).

<source lang="python">
import sys, os

if len(sys.argv) < 2:
sys.exit(f"Usage: {sys.argv[0]} filename")

filename = sys.argv[1]

if not os.path.exists(filename):
sys.exit(f"Error: File '{sys.argv[1]}' not found")
</source>

=== Object-Oriented Programming ===

You can define and use a class like this:

<source lang="python">
class Food:
# constructor:
def __init__(self, name):
self.name = name

def format_name(self):
return f"Gotta love to eat {self.name}"

class Fruit(Food):
def format_name(self):
return f"{Food.format_name(self)} (fruit)"

fruit = Fruit("Cherry")
print(fruit.format_name())
print(Food.get_definition())
</source>
This is the same example as in [[PHP#Object-Oriented_Programming|the PHP guide]].

Some things to notice:

* Instance methods ''always'' take <code>self</code> as their first argument, followed by any number of additional parameters. This can be misleading for programmers familiar with other languages, because the number of arguments you feed to the method is actually ''one less than'' the number of declared parameters. Whenever you call a method on a class instance, that instance is implicitly fed into the explicitly-declared <code>self</code> parameter of the method.
*: Note that the <code>self</code> variable has the same purpose as the <code>this</code> variable in languages like PHP, Java, JavaScript, and C++.
*There is no need for a <code>new</code> keyword in Python.

= Footnotes =
# {{note|interpreted}}This is an oversimplification. If you're interested, here's a quick explanation of how: In CPython (the reference implementation of Python) programs are compiled to bytecode, an intermediate representation, which is then interpreted.
[[Category:Module 4]]

Python

2018-02-19T18:19:33Z

Alex: Updated pip for Python 3.6

Languages like Java and C++ have lots of rules regarding variable types, syntax, return values, and so on. These can be cumbersome when you are trying to write short, quick scripts to perform tasks. This is where a ''scripting language'' comes into play.

'''Python''' is a language well-suited to rapid prototype development. It is generally an ''interpreted language'', which means that, generally speaking, a Python program is converted line by line into instructions for the computer to execute as the program runs, instead of having a separate compilation step beforehand {{ref|interpreted}}. The syntax is clean, and it is usually clear at first glance what is going on when you write in Python.

= Installation =

Python may already be installed on your system. To see whether or not it is, enter the command

<source lang="bash">
$ python3 --version
</source>
If it tells you a version of Python '''greater than or equal to 3.6''' then you're good to go. If not, you need to do a quick package install to get it up and running. Using yum, it's just <code>sudo yum install python36</code>.

If you'd like to be able to just type <code>python</code> instead of <code>python3</code>, you can add the following line to the <code>~/.bash_profile</code> file on your instance:

<source lang="bash">
alias python="/usr/bin/python3"
</source>

==== Python 2 vs Python 3 ====

In 2008, a new version of Python – Python 3 – was released, with a number of changes that made it incompatible with the previous version, Python 2. For several years, the Python community was slow to make the change to Python 3, but today, Python 3 is ''the'' standard for new code. The ''only'' reason to write Python 2 code today is because you have to work in an environment or with libraries that do not support Python 3, and that situation is becoming increasingly rare.

'''For CSE 330 (and this guide), you ''must'' use Python 3.6 or greater.'''

=== Pip ===

Linux distributions have package managers like ''Apt'', ''Yum'', and ''YaST''. PHP has a package manager named ''PEAR''. It's now time to introduce Python's leading package manager: '''pip'''.

Once you have pip installed, you can use it to install Python packages. Use the <code>pip-3.6</code> command:

<source lang="bash">
$ pip-3.6 install package_name # RHEL
</source>

If you'd like to be able to just type <code>pip</code> instead of <code>pip-3.6</code>, you can add the following line to the <code>~/.bash_profile</code> file on your instance:

<source lang="bash">
alias pip="/usr/bin/pip-3.6"
</source>

= Running Python =

There are two common ways to run Python code: via the console, and via a Python script file.

=== The Python Console ===

The Python console enables you to experiment with code without opening a text editor. To enter the Python console, simply type the ''python'' command at the terminal:

<source lang="bash">
$ python3
</source>
To leave the interactive console, either type <code>quit()</code> or press <code>Ctrl-D</code> (on both Mac and Windows).

=== Python Script Files ===

You can also save Python script files for later use. The extension for Python scripts is <code>*.py</code>. To run a script file, simply feed its path as an argument to the <code>python</code> command in Terminal:

<source lang="bash">
$ python3 my_script.py
</source>

= Python Syntax and Language Components =

This section contains a very brief overview of Python syntax. For a more comprehensive introduction, see [http://docs.python.org/tutorial/ the Python docs].

=== Python's Type System ===

Python is a dynamically-typed, strongly-typed, and duck-typed language. What does that mean? Well, let's take those categories one by one:

<ol>
<li>
'''Dynamic typing''', in contrast to ''static typing'' means that the types of objects can be changed. In Java, for instance, if you tried to write the following code:

<source lang="java">
int c = 2;
c = "fish";
</source>

Your code would fail to compile, because the Java compiler wouldn't allow you to change the type of the variable <code>c</code> from <code>int</code> to <code>String</code>.

Python, however, is just fine with that. You can write:

<source lang="python">
c = 2
c = "fish"
</source>

And Python will happily do what you ask.
</li>

<li>
'''Strong typing''', in contrast to ''weak typing'', means, roughly, that a language won't implicitly convert types for you. So far, you've used a lot of PHP, which is very weakly typed. For example:

<source lang="php">
echo "10" . 2;
</source>

In PHP, this works just fine. The PHP interpreter sees that <code>2</code> is an int, and silently converts it to a string for you, so that <code>"10". 2</code> equals <code>"102"</code>. The problem with weak typing is that it can make it unclear to the programmer why things are happening the way they are. For instance, in PHP, the expression <code>"10" == 10</code> is true, which can be less than obvious. Python, however, tries to disallow that sort of thing:

<source lang="python">
"10" + "10" # Allowed – concatenates the two strings.
10 + 10 # Allowed – adds the two ints.
"10" + 10 # Not allowed – raises a TypeError
</source>

Perhaps the one exception to this rule is the relationship between numeric types; it's perfectly fine to add a float to an int, for example.
</li>

<li>
'''Duck-typing''' is a little bit different than the other categories, because it doesn't really have a direct opposite. Essentially, duck-typing is the philosophy that "If it walks like a duck, and quacks like a duck, it's a duck." In programming terms, that means that we often don't care what type an object is, as long as it can do the things we ask.

Let's look at an example:

<source lang="python">
# This function doubles the value it's passed.
def double(thing):
return thing + thing
double(10) # Returns 20
double("fish") # Returns "fishfish";
</source>

If this were Java, we'd have to write two different methods here: one for things of type <code>int</code>, and one for things of type <code>String</code>. Since this is Python, though, we don't have to do that. Instead, Python lets us say, essentially: "This function uses the <code>+</code> operator, so you can pass whatever object you want to the function, as long as the function supports the <code>+</code> operator".

To quote [https://groups.google.com/forum/?hl=en#!msg/comp.lang.python/CCs2oJdyuzc/NYjla5HKMOIJ Alex Martelli], one of the key people in the Python project,

<blockquote>
"[Don't] check whether it IS-a duck: check whether it QUACKS-like-a duck, WALKS-like-a duck, etc, etc, depending on exactly what subset of duck-like behaviour you need."
</blockquote>

</li>
</ol>

=== Basic Types ===

In Python, the basic scalar types are:

# <code>str</code> – a string.
# <code>int</code> – an integer object with unlimited digits.
# <code>bool</code> – a Boolean value.
# <code>float</code> – a floating point number; generally equivalent to <code>double</code> in Java.
# <code>bytes</code> – represents a collection of bytes; you're unlikely to use this often.

Casting is done in the C style - to parse an <code>int</code> from a string, for instance, you'd write <code>int("123")</code>.

=== Basic Control Flow ===
In Python, blocks of code are delineated using colons and indentation instead of curly braces. '''''That means that proper indentation is mandatory.''''' Every time you use a colon, you must indent one step further, and every time a block ends, you must unindent a step.

Conditional statements are done using the <code>if</code>, <code>elif</code>, and <code>else</code> operators, like in the example below - pay attention to the indentation:

<source lang="python">
cookies_left = 10
cake_slices_left = 3
if cookies_left > 10:
print("Lots of cookies!")
elif cookies_left > 8:
print("Plenty left!")
elif cookies_left == 5:
print("Halfway done!")
else:
if cake_slices_left == 3:
print("Lots of cake!")
elif cake_slices_left == 2:
print("One slice gone!")
else:
print("Little to no cake left!")
</source>

=== An Example Python Script ===

In my mind, there's no better way to learn Python than to be immersed in a simple example script.

<source lang="python">
print("Hello World")

fruits = ["apple", "banana", "cherry", "date"]
for fruit in fruits:
print(f"I always love to eat a fresh {fruit}")

# Map the fruits list over to a new list containing the length of the fruit strings:
fruit_size = [len(fruit) for fruit in fruits]

avg_fruit_size = sum(fruit_size) / len(fruit_size)
print(f"The average fruit string length is {avg_fruit_size:.2f}.")
</source>

Some things to notice:

* Printing is achieved using the <code>print()</code> function.
* Comments start with a pound symbol <code>#</code>.
* We can transform/map a list to a new list in just one line!

For some more examples, see [https://wiki.python.org/moin/SimplePrograms the Python wiki].

=== A Few Gotchas ===

Here are a few things you may not expect when starting out with Python:

<ol>

<li>
Strings can be delimited using either single quotes (<code>'</code>) or double quotes (<code>"</code>), so <code>'Python'</code> is the same as <code>"Python"</code. You can also use three sets of quotes (<code>'''</code> or <code>"""</code>) to delineate a multiple-line string, like so:
<source lang="python">
long_string = """This
is my
very long
multiple-line
string"""
</source>
</li>

<li>
To compare the equality of two objects, use the <code>==</code> operator. To compare the identity of two objects (i.e. whether or not they are literally the same object, at the same place in memory), use the <code>is</code> operator. These correspond, respectively to <code>.equals()</code> and <code>==</code> in Java.
</li>

<li>
The <code>/</code> operator performs floating-point division, not integer division, even when both its arguments are integers. If you want to do integer division, use the <code>//</code> operator. Let's look at an example:

<source lang="python">
9 / 10 == 0.9 # Floating-point division
9.0 / 10.0 == 0.9 # Floating-point division
9 // 10 == 0 # Integer division
9.0 // 10.0 == 0.0 # Integer division, even though the resulting value is a float
</source>
</li>

<li>
As discussed in the section [[#Python's_Type_System|Python's Type System]], you can't combine strings and numbers using the <code>+</code> operator. Instead, you'll have to use one of the following methods of string formatting:

<source lang="python">

# Technique 1 – printf-style Formatting
# This is a classic style of string formatting, used in many programming languages, including in Java's String.format.
"You scored %d out of %d!" % (score, questions)

# Technique 2 – str.format
"You scored {} out of {}!".format(score, questions)

# Technique 3 – f-strings
# These were only introduced in Python 3.6 but they're very convenient.
f"You scored {score} out of {questions}!"

# Technique 4 - String Concatenation
# This is fine for small things, but for more complicated stuff, use one of the other techniques.
"You scored " + str(score) + " out of " + str(questions) + "!"
</source>
</li>
</ol>

=== Functions ===

Define functions using the <code>def</code> keyword:

<source lang="python">
def hello(name):
print(f"Hello, {name}!")

</source>

Invoke functions using parentheses:
<source lang="python">
hello("Batman")
hello("Superman")
</source>

Functions can have optional arguments; however, these must come after any required arguments:
<source lang="python">
def hello(name="User"):
print(f"Hello, {name}!")

hello() # Prints "Hello, User!"
hello("Sarah") # Prints "Hello, Sarah!"
</source>

Functions are just regular objects in Python, meaning you can do stuff like this:

<source lang="python">
def hello(name="User"):
print(f"Hello, {name}!")

greeting = hello

greeting("Siwei") # Prints "Hello, Siwei!"
</source>

=== Collection Types ===
Python has a few basic, built-in collection types. They each have their own special use cases, but they share a lot of similarities. All built-in data structures in Python are zero-indexed, for instance.

To obtain the number of elements in a collection, use the <code>len()</code> function, like this:

<source lang="python">
pets = ['Dog', 'Cat', 'Fish'] # This is a list; you'll learn about them below.

len(pets) # Returns 3
</source>

To check if a collection contains an item, use the <code>in</code> operator:
<source lang="python">
pets = ['Dog', 'Cat', 'Fish'] # This is a list; you'll learn about them below.

'Dog' in pets # Returns True
</source>

Helpfully, the Python Software Foundation maintains a page containing the asymptotic complexities of important operations on major Python data structures. It's available [https://wiki.python.org/moin/TimeComplexity here].

==== Lists ====

Unlike languages like Java and C, Python's array-like type doesn't have fixed length. Instead, a <code>list</code> is a dynamic array (like Java's <code>ArrayList</code>) of objects of any type. Here's an example:

<source lang="python">
fruits = ["Apple", "Pear", "Orange"] # Lists can be creating by placing their items between square brackets

random_items = ['Apple', 12312, 2.0, [1, 2, 3]] # Lists can contain objects of different types - even other lists!

pets.append('Turtle') # Adds 'Turtle' to the end of pets
</source>

For the next few examples, we'll be using the following list:

<source lang="python">
pets = ['Dog', 'Cat', 'Fish', 'Turtle', 'Lizard', 'Snake']
</source>

To access or assign elements of a list, use the <code>[]</code> operator.

<source lang="python">
pets[0] # Returns 'Dog'
pets[1] = 'Cow' # Sets pets[1] to 'Cow'
pets[1] = 'Cat' # Sets pets[1] back to 'Cat'
</source>

You can also access or assign lists using negative indices, which will return elements starting from the end of the list:

<source lang="python">
pets[-1] # Returns 'Snake'
pets[-2] # Returns 'Lizard'
</source>

You can also use 'slice notation' to obtain or assign subsets of lists:
<source lang="python">
pets[start:end] # Returns items from index start to index end - 1.
pets[start:] # Returns items from index start to the end of the list, inclusive.
pets[:end] # Returns items from the beginning of the list to index end - 1.
pets[:] # Returns every item in the list
</source>

There's also a third, optional argument: <code>step</code>, which lets you jump over values:
<source lang="python">
pets[start:end:step] # Returns items from index start to index end - 1, jumping step values at a time

# Examples:
pets[1:5:2] # Returns items from index 1 to index 4, jumping 2 at a time, so ['Cat', 'Turtle']
pets[::3] # Returns all items in the list, jumping 3 at a time, so ['Dog', 'Turtle']
pets[::-1] # Returns all items in the list, jumping -1 at a time. This reverses the list, so ['Snake', 'Lizard', 'Turtle', 'Fish', 'Cat', 'Dog']
</source>

Lists have all the performance characteristics you'd expect of a dynamic array - constant-time indexing, amortized constant-time appends, and so on.

==== Tuples ====

Python has a special data type called <code>tuple</code>, which is exactly the same as a list except for the fact that it cannot be modified, so you can't append or replace items.

<source lang="python">
cities = ('St. Louis', 'Los Angeles', 'Seattle') # Tuples are defined using parentheses.
numbers = 1, 2, 3 # You can also omit the parentheses if it's unambiguous
single_item_tuple = (1,) # To make a tuple with only one item, put a comma after it
</source>

Tuples also enable you to have multiple return values from a function:

<source lang="python">
def compute_length(string):
str_len = len(string)
if str_len < 5:
return str_len, "short"
elif str_len < 40:
return str_len, "medium"
return str_len, "long"

length, description = compute_length("Four score and seven years ago")
print(f"The {description} string is {length} characters long.")
</source>
The above example also demonstrates Python's if...elif...else conditional structure.

==== Dictionaries ====

Python has another datatype called a '''dictionary''' (or <code>dict</code>, for short), which are like ''Maps'' in Java, ''associative arrays'' in PHP, and ''object literals'' in JavaScript (coming up soon in Module 6). Essentially, they enable you to use any immutable object as the key in your data structure. <code>dict</code> objects can be created using either the <code>dict</code> function, or by placing items between curly braces, separating keys and values using colons:

<source lang="python">
fruits_in_bowl = {
'apple': 4,
'banana': 2,
'cherry': 0,
'date': 12
}

apple_count = fruits_in_bowl['apple'] # Equals 4

fruits_in_bowl['pear'] = 9 # Sets 'pear' in the dictionary to 9.

for fruit, num in fruits_in_bowl.items():
print(f"There are {num} {fruit}(s) in the bowl." % (num, fruit))
</source>
If you only want the keys from a dictionary, you can just iterate over it directly, like this:

<source lang="python">
for fruit in fruits_in_bowl:
print(fruit)
</source>
If you want only the values but not the keys from a dictionary, use <code>my_dictionary.values()</code>.

==== Sets ====
A <code>set</code> is an unordered collection of unique items, with constant-time membership checking.
<source lang="python">
fruits = {'Apple', 'Apple', 'Apple', 'Pear'} # The set removes duplicates, so it will only contain {'Apple', 'Pear'}
fruits = set(['Apple', 'Apple', 'Apple', 'Pear']) # This line transforms a list into a set
print('Apple' in fruits) # Constant-time!
</source>

=== Loops ===

In Python, while loops are written like this:

<source lang="python">
i = 0
while i < 10:
i += 1
</source>
For loops are written like this:

<source lang="python">
pets = ['Dog', 'Cat', 'Fish']

for pet in pets:
print(pet)
</source>
To iterate over a range of numbers, you can use the convenient <code>range</code> function, like so:

<source lang="python">
for i in range(20, 30): # If you omit the first argument to range, it's assumed to be zero.
print(i)
</source>
Note that <code>range</code> provides a closed-open range. That is to say, it is inclusive of its lower bound and exclusive of its upper bound. To be very explicit about it:

<source lang="python">
list(range(3, 6)) == [3, 4, 5]
</source>
Unlike in other languages you may know, the following is not good practice in Python:

<source lang="python">
pets = ['Dog', 'Cat', 'Fish']

# BAD PRACTICE. DO NOT USE.
for i in range(len(pets)):
pet = pets[i]
</source>
Instead, if you need to access both a variable and its index, use the <code>enumerate</code> function, which allows you to iterate through a group of items, along with their indexes, like so:

<source lang="python">
pets = ['Dog', 'Cat', 'Fish']

for index, pet in enumerate(pets):
print(f"{pet} at index {index}")
</source>

=== Generator Expressions and Comprehensions ===

A generator is a special kind of object that, basically, represents a collection of items using a value and a function for generating the next value in the collection. In other words, it's a way of creating something that behaves like a list, but which only generates one value at a time, and discards a value when it's done with it. Say, for example, you wanted to do an operation on 10,000,000,000,000 numbers. You could put them all in a list, then iterate over the list, but that would take a lot of memory, plus you'd have to create and fill the entire list before beginning to actually work on your problem. Instead, you'd probably be better off using a generator; telling the computer, essentially: “The starting value is 0. When I ask for the next number in the collection, add 1 to current value and give me that.”

A generator expression is an expression that is evaluated to create a generator. They're super useful. Generator expressions can take two forms – they can be used with and without a condition:

<source lang="python">
(EXPRESSION for VARIABLE in ITERABLE) # Unconditional
(EXPRESSION for VARIABLE in ITERABLE if CONDITION) # Conditional
</source>
For our purposes, you can think of an iterable as anything you can do a for loop over. Let's take a look at a generator expression in use:

<source lang="python">
double_even_digits = (number * 2 for number in range(10) if number % 2 == 0)
</source>
That line says that <code>double_even_digits</code> is every even number between 0 and 10 multiplied by two. Simple enough, right? If we wanted to use all of the numbers, not just the even ones, we could simply remove the if statement at the end of the expression.

Here's the thing, though: if you were to print <code>double_even_digits</code>, instead of a nice bunch of numbers, you'd get something that looks like this:

<code><generator object <genexpr><code>at 0x107fc92b0></code>

That's because generators are lazy! They don't generate their values until those values are needed, and they discard values once they're no longer needed. As a result, '''you can only iterate over a generator once'''. In this case, you can't print out the whole generator, because it hasn't generated all the values yet. You can, however, iterate over the generator, and print its values one at a time, like so:

<source lang="python">
for number in double_even_digits:
print(number)
</source>
You can also make a list out of the generator, which will go through all the items in the generator and put them in a list, like so:

<source lang="python">
even_number_list = list(double_even_digits)
</source>
That's actually a great segue to the second topic of this section: comprehensions. A comprehension is just a prettier way to make lists, sets, and dicts out of a generator expressions.

<source lang="python">
# If you want a list:
list(i for i in range(10) if i % 2 == 0) # Don't do this
[i for i in range(10) if i % 2 == 0] # Use a list comprehension instead!

# If you want a set:
set(i for i in range(10) if i % 2 == 0) # Don't do this
{i for i in range(10) if i % 2 == 0} # Use a set comprehension instead!

# If you want a dict:
dict((i, i + 1) for i in range(10) if i % 2 == 0) # Don't do this
{i : i + 1 for i in range(10) if i % 2 == 0} # Use a dict comprehension instead!

# If you want a tuple:
tuple(i for i in range(10) if i % 2 == 0) # Unfortunately, there's no better way to do this
</source>
In general, generators and comprehensions should be used whenever possible - they're the fastest and easiest way to build collections. If you ever see yourself writing code like this:

<source lang="python">
# BAD PRACTICE! DO NOT USE!
digits = []
for digit in range(10):
digits.append(digit)
</source>
Don't do it! Instead, use a generator expression or comprehension, as appropriate. A good way to decide whether a generator expression or comprehension is better for this situation is that, if you're just going to be iterating over your collection once, you should use an generator expression. If not, use a comprehension.

=== Sorting ===

Sorting in Python is frequently performed using the <code>sorted</code> function, which takes two arguments: an iterable (anything you can do a for-loop over, including lists and tuples) and a function used to evaluate each item. If the function is omitted, Python will try to sort the lists by value.

The following example demonstrates using an inline function, which Python calls a ''lambda''.

<source lang="python">
fruits = ['apple', 'banana', 'cherry', 'date']

# sort the fruits by string length
new_fruits = sorted(fruits, key=lambda v: len(v) // 2)

print(new_fruits) # ['date', 'apple', 'banana', 'cherry']
</source>
Alternatively, you can sort a <code>list</code> using the <code>.sort</code> method. This is faster than calling <code>sorted</code>, but it modifies the list in-place and returns <code>None</code>.

<source lang="python">
fruits = ['apple', 'banana', 'cherry', 'date']
fruits.sort()
</source>
=== Import ===

If you want to use functions from other libraries (including ones that you install using pip), use <code>import</code>:

<source lang="python">
import time

current_time = time.localtime()
print(time.strftime('%a, %d %b %Y %H:%M:%S', current_time))
</source>
If you want to pull the functions out of their namespace, you can use <code>from ___ import ___</code> syntax:

<source lang="python">
from time import localtime, strftime

current_time = localtime()
print(strftime('%a, %d %b %Y %H:%M:%S', current_time))

# Be aware that this technique, although convenient, may cause unexpected behavior if the function names that you're pulling out of the namespace are already used for other purposes in Python.
</source>
=== File I/O ===

You can read an entire file into a variable like this:

<source lang="python">
f = open("example.txt")
file_contents = f.read()

f.close() # free up memory when we're finished with the file
</source>
A better option is to use a with-block, which handles opening and closing the file for you automatically:

<source lang="python">
with open("example.txt") as f:
file_contents = f.read()
</source>
You can read a file line-by-line like this:

<source lang="python">
with open("example.txt") as f:
for line in f:
print("Read line: %s" % line.rstrip())
</source>
You can write to a file like this:

<source lang="python">
with open("example.txt", "w") as f:
f.write("Hello\nWorld\n")
</source>
=== Command-Line Arguments ===

Command line arguments are accessible in the variable <code>sys.argv</code>.

The following example shows a program that expects a filename as its argument, and it prints a usage message if the argument is not present ([https://stackoverflow.com/questions/983201/python-and-sys-argv source]).

<source lang="python">
import sys, os

if len(sys.argv) < 2:
sys.exit(f"Usage: {sys.argv[0]} filename")

filename = sys.argv[1]

if not os.path.exists(filename):
sys.exit(f"Error: File '{sys.argv[1]}' not found")
</source>

=== Object-Oriented Programming ===

You can define and use a class like this:

<source lang="python">
class Food:
# constructor:
def __init__(self, name):
self.name = name

def format_name(self):
return f"Gotta love to eat {self.name}"

class Fruit(Food):
def format_name(self):
return f"{Food.format_name(self)} (fruit)"

fruit = Fruit("Cherry")
print(fruit.format_name())
print(Food.get_definition())
</source>
This is the same example as in [[PHP#Object-Oriented_Programming|the PHP guide]].

Some things to notice:

* Instance methods ''always'' take <code>self</code> as their first argument, followed by any number of additional parameters. This can be misleading for programmers familiar with other languages, because the number of arguments you feed to the method is actually ''one less than'' the number of declared parameters. Whenever you call a method on a class instance, that instance is implicitly fed into the explicitly-declared <code>self</code> parameter of the method.
*: Note that the <code>self</code> variable has the same purpose as the <code>this</code> variable in languages like PHP, Java, JavaScript, and C++.
*There is no need for a <code>new</code> keyword in Python.

= Footnotes =
# {{note|interpreted}}This is an oversimplification. If you're interested, here's a quick explanation of how: In CPython (the reference implementation of Python) programs are compiled to bytecode, an intermediate representation, which is then interpreted.
[[Category:Module 4]]

Python

2018-02-19T18:12:13Z

Alex: /* Installation */

Languages like Java and C++ have lots of rules regarding variable types, syntax, return values, and so on. These can be cumbersome when you are trying to write short, quick scripts to perform tasks. This is where a ''scripting language'' comes into play.

'''Python''' is a language well-suited to rapid prototype development. It is generally an ''interpreted language'', which means that, generally speaking, a Python program is converted line by line into instructions for the computer to execute as the program runs, instead of having a separate compilation step beforehand {{ref|interpreted}}. The syntax is clean, and it is usually clear at first glance what is going on when you write in Python.

= Installation =

Python may already be installed on your system. To see whether or not it is, enter the command

<source lang="bash">
$ python3 --version
</source>
If it tells you a version of Python '''greater than or equal to 3.6''' then you're good to go. If not, you need to do a quick package install to get it up and running. Using yum, it's just <code>sudo yum install python36</code>.

If you'd like to be able to just type <code>python</code> instead of <code>python3</code>, you can add the following line to the <code>~/.bash_profile</code> file on your instance:

<source lang="bash">
alias python="/usr/bin/python3"
</source>

==== Python 2 vs Python 3 ====

In 2008, a new version of Python – Python 3 – was released, with a number of changes that made it incompatible with the previous version, Python 2. For several years, the Python community was slow to make the change to Python 3, but today, Python 3 is ''the'' standard for new code. The ''only'' reason to write Python 2 code today is because you have to work in an environment or with libraries that do not support Python 3, and that situation is becoming increasingly rare.

'''For CSE 330 (and this guide), you ''must'' use Python 3.6 or greater.'''

=== Pip ===

Linux distributions have package managers like ''Apt'', ''Yum'', and ''YaST''. PHP has a package manager named ''PEAR''. It's now time to introduce Python's leading package manager: '''pip'''.

You need to install Pip from Yum before you can use it. The package is called <code>python36-pip</code>.

Once you have pip installed, you can use it to install Python packages. Use the <code>pip-python</code> command:

<source lang="bash">
$ pip-python install package_name # RHEL
$ pip install package_name # Debian
</source>

= Running Python =

There are two common ways to run Python code: via the console, and via a Python script file.

=== The Python Console ===

The Python console enables you to experiment with code without opening a text editor. To enter the Python console, simply type the ''python'' command at the terminal:

<source lang="bash">
$ python
</source>
To leave the interactive console, either type <code>quit()</code> or press <code>Ctrl-D</code> (on both Mac and Windows).

=== Python Script Files ===

You can also save Python script files for later use. The extension for Python scripts is <code>*.py</code>. To run a script file, simply feed its path as an argument to the <code>python</code> command in Terminal:

<source lang="bash">
$ python my_script.py
</source>

= Python Syntax and Language Components =

This section contains a very brief overview of Python syntax. For a more comprehensive introduction, see [http://docs.python.org/tutorial/ the Python docs].

=== Python's Type System ===

Python is a dynamically-typed, strongly-typed, and duck-typed language. What does that mean? Well, let's take those categories one by one:

<ol>
<li>
'''Dynamic typing''', in contrast to ''static typing'' means that the types of objects can be changed. In Java, for instance, if you tried to write the following code:

<source lang="java">
int c = 2;
c = "fish";
</source>

Your code would fail to compile, because the Java compiler wouldn't allow you to change the type of the variable <code>c</code> from <code>int</code> to <code>String</code>.

Python, however, is just fine with that. You can write:

<source lang="python">
c = 2
c = "fish"
</source>

And Python will happily do what you ask.
</li>

<li>
'''Strong typing''', in contrast to ''weak typing'', means, roughly, that a language won't implicitly convert types for you. So far, you've used a lot of PHP, which is very weakly typed. For example:

<source lang="php">
echo "10" . 2;
</source>

In PHP, this works just fine. The PHP interpreter sees that <code>2</code> is an int, and silently converts it to a string for you, so that <code>"10". 2</code> equals <code>"102"</code>. The problem with weak typing is that it can make it unclear to the programmer why things are happening the way they are. For instance, in PHP, the expression <code>"10" == 10</code> is true, which can be less than obvious. Python, however, tries to disallow that sort of thing:

<source lang="python">
"10" + "10" # Allowed – concatenates the two strings.
10 + 10 # Allowed – adds the two ints.
"10" + 10 # Not allowed – raises a TypeError
</source>

Perhaps the one exception to this rule is the relationship between numeric types; it's perfectly fine to add a float to an int, for example.
</li>

<li>
'''Duck-typing''' is a little bit different than the other categories, because it doesn't really have a direct opposite. Essentially, duck-typing is the philosophy that "If it walks like a duck, and quacks like a duck, it's a duck." In programming terms, that means that we often don't care what type an object is, as long as it can do the things we ask.

Let's look at an example:

<source lang="python">
# This function doubles the value it's passed.
def double(thing):
return thing + thing
double(10) # Returns 20
double("fish") # Returns "fishfish";
</source>

If this were Java, we'd have to write two different methods here: one for things of type <code>int</code>, and one for things of type <code>String</code>. Since this is Python, though, we don't have to do that. Instead, Python lets us say, essentially: "This function uses the <code>+</code> operator, so you can pass whatever object you want to the function, as long as the function supports the <code>+</code> operator".

To quote [https://groups.google.com/forum/?hl=en#!msg/comp.lang.python/CCs2oJdyuzc/NYjla5HKMOIJ Alex Martelli], one of the key people in the Python project,

<blockquote>
"[Don't] check whether it IS-a duck: check whether it QUACKS-like-a duck, WALKS-like-a duck, etc, etc, depending on exactly what subset of duck-like behaviour you need."
</blockquote>

</li>
</ol>

=== Basic Types ===

In Python, the basic scalar types are:

# <code>str</code> – a string.
# <code>int</code> – an integer object with unlimited digits.
# <code>bool</code> – a Boolean value.
# <code>float</code> – a floating point number; generally equivalent to <code>double</code> in Java.
# <code>bytes</code> – represents a collection of bytes; you're unlikely to use this often.

Casting is done in the C style - to parse an <code>int</code> from a string, for instance, you'd write <code>int("123")</code>.

=== Basic Control Flow ===
In Python, blocks of code are delineated using colons and indentation instead of curly braces. '''''That means that proper indentation is mandatory.''''' Every time you use a colon, you must indent one step further, and every time a block ends, you must unindent a step.

Conditional statements are done using the <code>if</code>, <code>elif</code>, and <code>else</code> operators, like in the example below - pay attention to the indentation:

<source lang="python">
cookies_left = 10
cake_slices_left = 3
if cookies_left > 10:
print("Lots of cookies!")
elif cookies_left > 8:
print("Plenty left!")
elif cookies_left == 5:
print("Halfway done!")
else:
if cake_slices_left == 3:
print("Lots of cake!")
elif cake_slices_left == 2:
print("One slice gone!")
else:
print("Little to no cake left!")
</source>

=== An Example Python Script ===

In my mind, there's no better way to learn Python than to be immersed in a simple example script.

<source lang="python">
print("Hello World")

fruits = ["apple", "banana", "cherry", "date"]
for fruit in fruits:
print(f"I always love to eat a fresh {fruit}")

# Map the fruits list over to a new list containing the length of the fruit strings:
fruit_size = [len(fruit) for fruit in fruits]

avg_fruit_size = sum(fruit_size) / len(fruit_size)
print(f"The average fruit string length is {avg_fruit_size:.2f}.")
</source>

Some things to notice:

* Printing is achieved using the <code>print()</code> function.
* Comments start with a pound symbol <code>#</code>.
* We can transform/map a list to a new list in just one line!

For some more examples, see [https://wiki.python.org/moin/SimplePrograms the Python wiki].

=== A Few Gotchas ===

Here are a few things you may not expect when starting out with Python:

<ol>

<li>
Strings can be delimited using either single quotes (<code>'</code>) or double quotes (<code>"</code>), so <code>'Python'</code> is the same as <code>"Python"</code. You can also use three sets of quotes (<code>'''</code> or <code>"""</code>) to delineate a multiple-line string, like so:
<source lang="python">
long_string = """This
is my
very long
multiple-line
string"""
</source>
</li>

<li>
To compare the equality of two objects, use the <code>==</code> operator. To compare the identity of two objects (i.e. whether or not they are literally the same object, at the same place in memory), use the <code>is</code> operator. These correspond, respectively to <code>.equals()</code> and <code>==</code> in Java.
</li>

<li>
The <code>/</code> operator performs floating-point division, not integer division, even when both its arguments are integers. If you want to do integer division, use the <code>//</code> operator. Let's look at an example:

<source lang="python">
9 / 10 == 0.9 # Floating-point division
9.0 / 10.0 == 0.9 # Floating-point division
9 // 10 == 0 # Integer division
9.0 // 10.0 == 0.0 # Integer division, even though the resulting value is a float
</source>
</li>

<li>
As discussed in the section [[#Python's_Type_System|Python's Type System]], you can't combine strings and numbers using the <code>+</code> operator. Instead, you'll have to use one of the following methods of string formatting:

<source lang="python">

# Technique 1 – printf-style Formatting
# This is a classic style of string formatting, used in many programming languages, including in Java's String.format.
"You scored %d out of %d!" % (score, questions)

# Technique 2 – str.format
"You scored {} out of {}!".format(score, questions)

# Technique 3 – f-strings
# These were only introduced in Python 3.6 but they're very convenient.
f"You scored {score} out of {questions}!"

# Technique 4 - String Concatenation
# This is fine for small things, but for more complicated stuff, use one of the other techniques.
"You scored " + str(score) + " out of " + str(questions) + "!"
</source>
</li>
</ol>

=== Functions ===

Define functions using the <code>def</code> keyword:

<source lang="python">
def hello(name):
print(f"Hello, {name}!")

</source>

Invoke functions using parentheses:
<source lang="python">
hello("Batman")
hello("Superman")
</source>

Functions can have optional arguments; however, these must come after any required arguments:
<source lang="python">
def hello(name="User"):
print(f"Hello, {name}!")

hello() # Prints "Hello, User!"
hello("Sarah") # Prints "Hello, Sarah!"
</source>

Functions are just regular objects in Python, meaning you can do stuff like this:

<source lang="python">
def hello(name="User"):
print(f"Hello, {name}!")

greeting = hello

greeting("Siwei") # Prints "Hello, Siwei!"
</source>

=== Collection Types ===
Python has a few basic, built-in collection types. They each have their own special use cases, but they share a lot of similarities. All built-in data structures in Python are zero-indexed, for instance.

To obtain the number of elements in a collection, use the <code>len()</code> function, like this:

<source lang="python">
pets = ['Dog', 'Cat', 'Fish'] # This is a list; you'll learn about them below.

len(pets) # Returns 3
</source>

To check if a collection contains an item, use the <code>in</code> operator:
<source lang="python">
pets = ['Dog', 'Cat', 'Fish'] # This is a list; you'll learn about them below.

'Dog' in pets # Returns True
</source>

Helpfully, the Python Software Foundation maintains a page containing the asymptotic complexities of important operations on major Python data structures. It's available [https://wiki.python.org/moin/TimeComplexity here].

==== Lists ====

Unlike languages like Java and C, Python's array-like type doesn't have fixed length. Instead, a <code>list</code> is a dynamic array (like Java's <code>ArrayList</code>) of objects of any type. Here's an example:

<source lang="python">
fruits = ["Apple", "Pear", "Orange"] # Lists can be creating by placing their items between square brackets

random_items = ['Apple', 12312, 2.0, [1, 2, 3]] # Lists can contain objects of different types - even other lists!

pets.append('Turtle') # Adds 'Turtle' to the end of pets
</source>

For the next few examples, we'll be using the following list:

<source lang="python">
pets = ['Dog', 'Cat', 'Fish', 'Turtle', 'Lizard', 'Snake']
</source>

To access or assign elements of a list, use the <code>[]</code> operator.

<source lang="python">
pets[0] # Returns 'Dog'
pets[1] = 'Cow' # Sets pets[1] to 'Cow'
pets[1] = 'Cat' # Sets pets[1] back to 'Cat'
</source>

You can also access or assign lists using negative indices, which will return elements starting from the end of the list:

<source lang="python">
pets[-1] # Returns 'Snake'
pets[-2] # Returns 'Lizard'
</source>

You can also use 'slice notation' to obtain or assign subsets of lists:
<source lang="python">
pets[start:end] # Returns items from index start to index end - 1.
pets[start:] # Returns items from index start to the end of the list, inclusive.
pets[:end] # Returns items from the beginning of the list to index end - 1.
pets[:] # Returns every item in the list
</source>

There's also a third, optional argument: <code>step</code>, which lets you jump over values:
<source lang="python">
pets[start:end:step] # Returns items from index start to index end - 1, jumping step values at a time

# Examples:
pets[1:5:2] # Returns items from index 1 to index 4, jumping 2 at a time, so ['Cat', 'Turtle']
pets[::3] # Returns all items in the list, jumping 3 at a time, so ['Dog', 'Turtle']
pets[::-1] # Returns all items in the list, jumping -1 at a time. This reverses the list, so ['Snake', 'Lizard', 'Turtle', 'Fish', 'Cat', 'Dog']
</source>

Lists have all the performance characteristics you'd expect of a dynamic array - constant-time indexing, amortized constant-time appends, and so on.

==== Tuples ====

Python has a special data type called <code>tuple</code>, which is exactly the same as a list except for the fact that it cannot be modified, so you can't append or replace items.

<source lang="python">
cities = ('St. Louis', 'Los Angeles', 'Seattle') # Tuples are defined using parentheses.
numbers = 1, 2, 3 # You can also omit the parentheses if it's unambiguous
single_item_tuple = (1,) # To make a tuple with only one item, put a comma after it
</source>

Tuples also enable you to have multiple return values from a function:

<source lang="python">
def compute_length(string):
str_len = len(string)
if str_len < 5:
return str_len, "short"
elif str_len < 40:
return str_len, "medium"
return str_len, "long"

length, description = compute_length("Four score and seven years ago")
print(f"The {description} string is {length} characters long.")
</source>
The above example also demonstrates Python's if...elif...else conditional structure.

==== Dictionaries ====

Python has another datatype called a '''dictionary''' (or <code>dict</code>, for short), which are like ''Maps'' in Java, ''associative arrays'' in PHP, and ''object literals'' in JavaScript (coming up soon in Module 6). Essentially, they enable you to use any immutable object as the key in your data structure. <code>dict</code> objects can be created using either the <code>dict</code> function, or by placing items between curly braces, separating keys and values using colons:

<source lang="python">
fruits_in_bowl = {
'apple': 4,
'banana': 2,
'cherry': 0,
'date': 12
}

apple_count = fruits_in_bowl['apple'] # Equals 4

fruits_in_bowl['pear'] = 9 # Sets 'pear' in the dictionary to 9.

for fruit, num in fruits_in_bowl.items():
print(f"There are {num} {fruit}(s) in the bowl." % (num, fruit))
</source>
If you only want the keys from a dictionary, you can just iterate over it directly, like this:

<source lang="python">
for fruit in fruits_in_bowl:
print(fruit)
</source>
If you want only the values but not the keys from a dictionary, use <code>my_dictionary.values()</code>.

==== Sets ====
A <code>set</code> is an unordered collection of unique items, with constant-time membership checking.
<source lang="python">
fruits = {'Apple', 'Apple', 'Apple', 'Pear'} # The set removes duplicates, so it will only contain {'Apple', 'Pear'}
fruits = set(['Apple', 'Apple', 'Apple', 'Pear']) # This line transforms a list into a set
print('Apple' in fruits) # Constant-time!
</source>

=== Loops ===

In Python, while loops are written like this:

<source lang="python">
i = 0
while i < 10:
i += 1
</source>
For loops are written like this:

<source lang="python">
pets = ['Dog', 'Cat', 'Fish']

for pet in pets:
print(pet)
</source>
To iterate over a range of numbers, you can use the convenient <code>range</code> function, like so:

<source lang="python">
for i in range(20, 30): # If you omit the first argument to range, it's assumed to be zero.
print(i)
</source>
Note that <code>range</code> provides a closed-open range. That is to say, it is inclusive of its lower bound and exclusive of its upper bound. To be very explicit about it:

<source lang="python">
list(range(3, 6)) == [3, 4, 5]
</source>
Unlike in other languages you may know, the following is not good practice in Python:

<source lang="python">
pets = ['Dog', 'Cat', 'Fish']

# BAD PRACTICE. DO NOT USE.
for i in range(len(pets)):
pet = pets[i]
</source>
Instead, if you need to access both a variable and its index, use the <code>enumerate</code> function, which allows you to iterate through a group of items, along with their indexes, like so:

<source lang="python">
pets = ['Dog', 'Cat', 'Fish']

for index, pet in enumerate(pets):
print(f"{pet} at index {index}")
</source>

=== Generator Expressions and Comprehensions ===

A generator is a special kind of object that, basically, represents a collection of items using a value and a function for generating the next value in the collection. In other words, it's a way of creating something that behaves like a list, but which only generates one value at a time, and discards a value when it's done with it. Say, for example, you wanted to do an operation on 10,000,000,000,000 numbers. You could put them all in a list, then iterate over the list, but that would take a lot of memory, plus you'd have to create and fill the entire list before beginning to actually work on your problem. Instead, you'd probably be better off using a generator; telling the computer, essentially: “The starting value is 0. When I ask for the next number in the collection, add 1 to current value and give me that.”

A generator expression is an expression that is evaluated to create a generator. They're super useful. Generator expressions can take two forms – they can be used with and without a condition:

<source lang="python">
(EXPRESSION for VARIABLE in ITERABLE) # Unconditional
(EXPRESSION for VARIABLE in ITERABLE if CONDITION) # Conditional
</source>
For our purposes, you can think of an iterable as anything you can do a for loop over. Let's take a look at a generator expression in use:

<source lang="python">
double_even_digits = (number * 2 for number in range(10) if number % 2 == 0)
</source>
That line says that <code>double_even_digits</code> is every even number between 0 and 10 multiplied by two. Simple enough, right? If we wanted to use all of the numbers, not just the even ones, we could simply remove the if statement at the end of the expression.

Here's the thing, though: if you were to print <code>double_even_digits</code>, instead of a nice bunch of numbers, you'd get something that looks like this:

<code><generator object <genexpr><code>at 0x107fc92b0></code>

That's because generators are lazy! They don't generate their values until those values are needed, and they discard values once they're no longer needed. As a result, '''you can only iterate over a generator once'''. In this case, you can't print out the whole generator, because it hasn't generated all the values yet. You can, however, iterate over the generator, and print its values one at a time, like so:

<source lang="python">
for number in double_even_digits:
print(number)
</source>
You can also make a list out of the generator, which will go through all the items in the generator and put them in a list, like so:

<source lang="python">
even_number_list = list(double_even_digits)
</source>
That's actually a great segue to the second topic of this section: comprehensions. A comprehension is just a prettier way to make lists, sets, and dicts out of a generator expressions.

<source lang="python">
# If you want a list:
list(i for i in range(10) if i % 2 == 0) # Don't do this
[i for i in range(10) if i % 2 == 0] # Use a list comprehension instead!

# If you want a set:
set(i for i in range(10) if i % 2 == 0) # Don't do this
{i for i in range(10) if i % 2 == 0} # Use a set comprehension instead!

# If you want a dict:
dict((i, i + 1) for i in range(10) if i % 2 == 0) # Don't do this
{i : i + 1 for i in range(10) if i % 2 == 0} # Use a dict comprehension instead!

# If you want a tuple:
tuple(i for i in range(10) if i % 2 == 0) # Unfortunately, there's no better way to do this
</source>
In general, generators and comprehensions should be used whenever possible - they're the fastest and easiest way to build collections. If you ever see yourself writing code like this:

<source lang="python">
# BAD PRACTICE! DO NOT USE!
digits = []
for digit in range(10):
digits.append(digit)
</source>
Don't do it! Instead, use a generator expression or comprehension, as appropriate. A good way to decide whether a generator expression or comprehension is better for this situation is that, if you're just going to be iterating over your collection once, you should use an generator expression. If not, use a comprehension.

=== Sorting ===

Sorting in Python is frequently performed using the <code>sorted</code> function, which takes two arguments: an iterable (anything you can do a for-loop over, including lists and tuples) and a function used to evaluate each item. If the function is omitted, Python will try to sort the lists by value.

The following example demonstrates using an inline function, which Python calls a ''lambda''.

<source lang="python">
fruits = ['apple', 'banana', 'cherry', 'date']

# sort the fruits by string length
new_fruits = sorted(fruits, key=lambda v: len(v) // 2)

print(new_fruits) # ['date', 'apple', 'banana', 'cherry']
</source>
Alternatively, you can sort a <code>list</code> using the <code>.sort</code> method. This is faster than calling <code>sorted</code>, but it modifies the list in-place and returns <code>None</code>.

<source lang="python">
fruits = ['apple', 'banana', 'cherry', 'date']
fruits.sort()
</source>
=== Import ===

If you want to use functions from other libraries (including ones that you install using pip), use <code>import</code>:

<source lang="python">
import time

current_time = time.localtime()
print(time.strftime('%a, %d %b %Y %H:%M:%S', current_time))
</source>
If you want to pull the functions out of their namespace, you can use <code>from ___ import ___</code> syntax:

<source lang="python">
from time import localtime, strftime

current_time = localtime()
print(strftime('%a, %d %b %Y %H:%M:%S', current_time))

# Be aware that this technique, although convenient, may cause unexpected behavior if the function names that you're pulling out of the namespace are already used for other purposes in Python.
</source>
=== File I/O ===

You can read an entire file into a variable like this:

<source lang="python">
f = open("example.txt")
file_contents = f.read()

f.close() # free up memory when we're finished with the file
</source>
A better option is to use a with-block, which handles opening and closing the file for you automatically:

<source lang="python">
with open("example.txt") as f:
file_contents = f.read()
</source>
You can read a file line-by-line like this:

<source lang="python">
with open("example.txt") as f:
for line in f:
print("Read line: %s" % line.rstrip())
</source>
You can write to a file like this:

<source lang="python">
with open("example.txt", "w") as f:
f.write("Hello\nWorld\n")
</source>
=== Command-Line Arguments ===

Command line arguments are accessible in the variable <code>sys.argv</code>.

The following example shows a program that expects a filename as its argument, and it prints a usage message if the argument is not present ([https://stackoverflow.com/questions/983201/python-and-sys-argv source]).

<source lang="python">
import sys, os

if len(sys.argv) < 2:
sys.exit(f"Usage: {sys.argv[0]} filename")

filename = sys.argv[1]

if not os.path.exists(filename):
sys.exit(f"Error: File '{sys.argv[1]}' not found")
</source>

=== Object-Oriented Programming ===

You can define and use a class like this:

<source lang="python">
class Food:
# constructor:
def __init__(self, name):
self.name = name

def format_name(self):
return f"Gotta love to eat {self.name}"

class Fruit(Food):
def format_name(self):
return f"{Food.format_name(self)} (fruit)"

fruit = Fruit("Cherry")
print(fruit.format_name())
print(Food.get_definition())
</source>
This is the same example as in [[PHP#Object-Oriented_Programming|the PHP guide]].

Some things to notice:

* Instance methods ''always'' take <code>self</code> as their first argument, followed by any number of additional parameters. This can be misleading for programmers familiar with other languages, because the number of arguments you feed to the method is actually ''one less than'' the number of declared parameters. Whenever you call a method on a class instance, that instance is implicitly fed into the explicitly-declared <code>self</code> parameter of the method.
*: Note that the <code>self</code> variable has the same purpose as the <code>this</code> variable in languages like PHP, Java, JavaScript, and C++.
*There is no need for a <code>new</code> keyword in Python.

= Footnotes =
# {{note|interpreted}}This is an oversimplification. If you're interested, here's a quick explanation of how: In CPython (the reference implementation of Python) programs are compiled to bytecode, an intermediate representation, which is then interpreted.
[[Category:Module 4]]

Python

2018-02-19T18:11:41Z

Alex: /* Installation */

Languages like Java and C++ have lots of rules regarding variable types, syntax, return values, and so on. These can be cumbersome when you are trying to write short, quick scripts to perform tasks. This is where a ''scripting language'' comes into play.

'''Python''' is a language well-suited to rapid prototype development. It is generally an ''interpreted language'', which means that, generally speaking, a Python program is converted line by line into instructions for the computer to execute as the program runs, instead of having a separate compilation step beforehand {{ref|interpreted}}. The syntax is clean, and it is usually clear at first glance what is going on when you write in Python.

= Installation =

Python may already be installed on your system. To see whether or not it is, enter the command

<source lang="bash">
$ python3 --version
</source>
If it tells you a version of Python '''greater than or equal to 3.6''' then you're good to go. If not, you need to do a quick package install to get it up and running. Using yum, it's just <code>sudo yum install python36</code>.

If you'd like to be able to just type <code>python</code> instead of <code>python3</code>, you can add the following line to the <code>~/.bash_profile</code> file on your instance:

<source lang="bash">
alias python="/usr/bin/python3"
</source>

==== Python 2 vs Python 3 ====

In 2008, a new version of Python – Python 3 – was released, with a number changes that made it incompatible with the previous version, Python 2. For several years, the Python community was slow to make the change to Python 3, but today, Python 3 is ''the'' standard for new code. The ''only'' reason to write Python 2 code today is because you have to work in an environment or with libraries that do not support Python 3, and that situation is becoming increasingly rare.

'''For CSE 330 (and this guide), you ''must'' use Python 3.6 or greater.'''

=== Pip ===

Linux distributions have package managers like ''Apt'', ''Yum'', and ''YaST''. PHP has a package manager named ''PEAR''. It's now time to introduce Python's leading package manager: '''pip'''.

You need to install Pip from Yum before you can use it. The package is called <code>python-pip</code>.

Once you have pip installed, you can use it to install Python packages. Use the <code>pip-python</code> command:

<source lang="bash">
$ pip-python install package_name # RHEL
$ pip install package_name # Debian
</source>

= Running Python =

There are two common ways to run Python code: via the console, and via a Python script file.

=== The Python Console ===

The Python console enables you to experiment with code without opening a text editor. To enter the Python console, simply type the ''python'' command at the terminal:

<source lang="bash">
$ python
</source>
To leave the interactive console, either type <code>quit()</code> or press <code>Ctrl-D</code> (on both Mac and Windows).

=== Python Script Files ===

You can also save Python script files for later use. The extension for Python scripts is <code>*.py</code>. To run a script file, simply feed its path as an argument to the <code>python</code> command in Terminal:

<source lang="bash">
$ python my_script.py
</source>

= Python Syntax and Language Components =

This section contains a very brief overview of Python syntax. For a more comprehensive introduction, see [http://docs.python.org/tutorial/ the Python docs].

=== Python's Type System ===

Python is a dynamically-typed, strongly-typed, and duck-typed language. What does that mean? Well, let's take those categories one by one:

<ol>
<li>
'''Dynamic typing''', in contrast to ''static typing'' means that the types of objects can be changed. In Java, for instance, if you tried to write the following code:

<source lang="java">
int c = 2;
c = "fish";
</source>

Your code would fail to compile, because the Java compiler wouldn't allow you to change the type of the variable <code>c</code> from <code>int</code> to <code>String</code>.

Python, however, is just fine with that. You can write:

<source lang="python">
c = 2
c = "fish"
</source>

And Python will happily do what you ask.
</li>

<li>
'''Strong typing''', in contrast to ''weak typing'', means, roughly, that a language won't implicitly convert types for you. So far, you've used a lot of PHP, which is very weakly typed. For example:

<source lang="php">
echo "10" . 2;
</source>

In PHP, this works just fine. The PHP interpreter sees that <code>2</code> is an int, and silently converts it to a string for you, so that <code>"10". 2</code> equals <code>"102"</code>. The problem with weak typing is that it can make it unclear to the programmer why things are happening the way they are. For instance, in PHP, the expression <code>"10" == 10</code> is true, which can be less than obvious. Python, however, tries to disallow that sort of thing:

<source lang="python">
"10" + "10" # Allowed – concatenates the two strings.
10 + 10 # Allowed – adds the two ints.
"10" + 10 # Not allowed – raises a TypeError
</source>

Perhaps the one exception to this rule is the relationship between numeric types; it's perfectly fine to add a float to an int, for example.
</li>

<li>
'''Duck-typing''' is a little bit different than the other categories, because it doesn't really have a direct opposite. Essentially, duck-typing is the philosophy that "If it walks like a duck, and quacks like a duck, it's a duck." In programming terms, that means that we often don't care what type an object is, as long as it can do the things we ask.

Let's look at an example:

<source lang="python">
# This function doubles the value it's passed.
def double(thing):
return thing + thing
double(10) # Returns 20
double("fish") # Returns "fishfish";
</source>

If this were Java, we'd have to write two different methods here: one for things of type <code>int</code>, and one for things of type <code>String</code>. Since this is Python, though, we don't have to do that. Instead, Python lets us say, essentially: "This function uses the <code>+</code> operator, so you can pass whatever object you want to the function, as long as the function supports the <code>+</code> operator".

To quote [https://groups.google.com/forum/?hl=en#!msg/comp.lang.python/CCs2oJdyuzc/NYjla5HKMOIJ Alex Martelli], one of the key people in the Python project,

<blockquote>
"[Don't] check whether it IS-a duck: check whether it QUACKS-like-a duck, WALKS-like-a duck, etc, etc, depending on exactly what subset of duck-like behaviour you need."
</blockquote>

</li>
</ol>

=== Basic Types ===

In Python, the basic scalar types are:

# <code>str</code> – a string.
# <code>int</code> – an integer object with unlimited digits.
# <code>bool</code> – a Boolean value.
# <code>float</code> – a floating point number; generally equivalent to <code>double</code> in Java.
# <code>bytes</code> – represents a collection of bytes; you're unlikely to use this often.

Casting is done in the C style - to parse an <code>int</code> from a string, for instance, you'd write <code>int("123")</code>.

=== Basic Control Flow ===
In Python, blocks of code are delineated using colons and indentation instead of curly braces. '''''That means that proper indentation is mandatory.''''' Every time you use a colon, you must indent one step further, and every time a block ends, you must unindent a step.

Conditional statements are done using the <code>if</code>, <code>elif</code>, and <code>else</code> operators, like in the example below - pay attention to the indentation:

<source lang="python">
cookies_left = 10
cake_slices_left = 3
if cookies_left > 10:
print("Lots of cookies!")
elif cookies_left > 8:
print("Plenty left!")
elif cookies_left == 5:
print("Halfway done!")
else:
if cake_slices_left == 3:
print("Lots of cake!")
elif cake_slices_left == 2:
print("One slice gone!")
else:
print("Little to no cake left!")
</source>

=== An Example Python Script ===

In my mind, there's no better way to learn Python than to be immersed in a simple example script.

<source lang="python">
print("Hello World")

fruits = ["apple", "banana", "cherry", "date"]
for fruit in fruits:
print(f"I always love to eat a fresh {fruit}")

# Map the fruits list over to a new list containing the length of the fruit strings:
fruit_size = [len(fruit) for fruit in fruits]

avg_fruit_size = sum(fruit_size) / len(fruit_size)
print(f"The average fruit string length is {avg_fruit_size:.2f}.")
</source>

Some things to notice:

* Printing is achieved using the <code>print()</code> function.
* Comments start with a pound symbol <code>#</code>.
* We can transform/map a list to a new list in just one line!

For some more examples, see [https://wiki.python.org/moin/SimplePrograms the Python wiki].

=== A Few Gotchas ===

Here are a few things you may not expect when starting out with Python:

<ol>

<li>
Strings can be delimited using either single quotes (<code>'</code>) or double quotes (<code>"</code>), so <code>'Python'</code> is the same as <code>"Python"</code. You can also use three sets of quotes (<code>'''</code> or <code>"""</code>) to delineate a multiple-line string, like so:
<source lang="python">
long_string = """This
is my
very long
multiple-line
string"""
</source>
</li>

<li>
To compare the equality of two objects, use the <code>==</code> operator. To compare the identity of two objects (i.e. whether or not they are literally the same object, at the same place in memory), use the <code>is</code> operator. These correspond, respectively to <code>.equals()</code> and <code>==</code> in Java.
</li>

<li>
The <code>/</code> operator performs floating-point division, not integer division, even when both its arguments are integers. If you want to do integer division, use the <code>//</code> operator. Let's look at an example:

<source lang="python">
9 / 10 == 0.9 # Floating-point division
9.0 / 10.0 == 0.9 # Floating-point division
9 // 10 == 0 # Integer division
9.0 // 10.0 == 0.0 # Integer division, even though the resulting value is a float
</source>
</li>

<li>
As discussed in the section [[#Python's_Type_System|Python's Type System]], you can't combine strings and numbers using the <code>+</code> operator. Instead, you'll have to use one of the following methods of string formatting:

<source lang="python">

# Technique 1 – printf-style Formatting
# This is a classic style of string formatting, used in many programming languages, including in Java's String.format.
"You scored %d out of %d!" % (score, questions)

# Technique 2 – str.format
"You scored {} out of {}!".format(score, questions)

# Technique 3 – f-strings
# These were only introduced in Python 3.6 but they're very convenient.
f"You scored {score} out of {questions}!"

# Technique 4 - String Concatenation
# This is fine for small things, but for more complicated stuff, use one of the other techniques.
"You scored " + str(score) + " out of " + str(questions) + "!"
</source>
</li>
</ol>

=== Functions ===

Define functions using the <code>def</code> keyword:

<source lang="python">
def hello(name):
print(f"Hello, {name}!")

</source>

Invoke functions using parentheses:
<source lang="python">
hello("Batman")
hello("Superman")
</source>

Functions can have optional arguments; however, these must come after any required arguments:
<source lang="python">
def hello(name="User"):
print(f"Hello, {name}!")

hello() # Prints "Hello, User!"
hello("Sarah") # Prints "Hello, Sarah!"
</source>

Functions are just regular objects in Python, meaning you can do stuff like this:

<source lang="python">
def hello(name="User"):
print(f"Hello, {name}!")

greeting = hello

greeting("Siwei") # Prints "Hello, Siwei!"
</source>

=== Collection Types ===
Python has a few basic, built-in collection types. They each have their own special use cases, but they share a lot of similarities. All built-in data structures in Python are zero-indexed, for instance.

To obtain the number of elements in a collection, use the <code>len()</code> function, like this:

<source lang="python">
pets = ['Dog', 'Cat', 'Fish'] # This is a list; you'll learn about them below.

len(pets) # Returns 3
</source>

To check if a collection contains an item, use the <code>in</code> operator:
<source lang="python">
pets = ['Dog', 'Cat', 'Fish'] # This is a list; you'll learn about them below.

'Dog' in pets # Returns True
</source>

Helpfully, the Python Software Foundation maintains a page containing the asymptotic complexities of important operations on major Python data structures. It's available [https://wiki.python.org/moin/TimeComplexity here].

==== Lists ====

Unlike languages like Java and C, Python's array-like type doesn't have fixed length. Instead, a <code>list</code> is a dynamic array (like Java's <code>ArrayList</code>) of objects of any type. Here's an example:

<source lang="python">
fruits = ["Apple", "Pear", "Orange"] # Lists can be creating by placing their items between square brackets

random_items = ['Apple', 12312, 2.0, [1, 2, 3]] # Lists can contain objects of different types - even other lists!

pets.append('Turtle') # Adds 'Turtle' to the end of pets
</source>

For the next few examples, we'll be using the following list:

<source lang="python">
pets = ['Dog', 'Cat', 'Fish', 'Turtle', 'Lizard', 'Snake']
</source>

To access or assign elements of a list, use the <code>[]</code> operator.

<source lang="python">
pets[0] # Returns 'Dog'
pets[1] = 'Cow' # Sets pets[1] to 'Cow'
pets[1] = 'Cat' # Sets pets[1] back to 'Cat'
</source>

You can also access or assign lists using negative indices, which will return elements starting from the end of the list:

<source lang="python">
pets[-1] # Returns 'Snake'
pets[-2] # Returns 'Lizard'
</source>

You can also use 'slice notation' to obtain or assign subsets of lists:
<source lang="python">
pets[start:end] # Returns items from index start to index end - 1.
pets[start:] # Returns items from index start to the end of the list, inclusive.
pets[:end] # Returns items from the beginning of the list to index end - 1.
pets[:] # Returns every item in the list
</source>

There's also a third, optional argument: <code>step</code>, which lets you jump over values:
<source lang="python">
pets[start:end:step] # Returns items from index start to index end - 1, jumping step values at a time

# Examples:
pets[1:5:2] # Returns items from index 1 to index 4, jumping 2 at a time, so ['Cat', 'Turtle']
pets[::3] # Returns all items in the list, jumping 3 at a time, so ['Dog', 'Turtle']
pets[::-1] # Returns all items in the list, jumping -1 at a time. This reverses the list, so ['Snake', 'Lizard', 'Turtle', 'Fish', 'Cat', 'Dog']
</source>

Lists have all the performance characteristics you'd expect of a dynamic array - constant-time indexing, amortized constant-time appends, and so on.

==== Tuples ====

Python has a special data type called <code>tuple</code>, which is exactly the same as a list except for the fact that it cannot be modified, so you can't append or replace items.

<source lang="python">
cities = ('St. Louis', 'Los Angeles', 'Seattle') # Tuples are defined using parentheses.
numbers = 1, 2, 3 # You can also omit the parentheses if it's unambiguous
single_item_tuple = (1,) # To make a tuple with only one item, put a comma after it
</source>

Tuples also enable you to have multiple return values from a function:

<source lang="python">
def compute_length(string):
str_len = len(string)
if str_len < 5:
return str_len, "short"
elif str_len < 40:
return str_len, "medium"
return str_len, "long"

length, description = compute_length("Four score and seven years ago")
print(f"The {description} string is {length} characters long.")
</source>
The above example also demonstrates Python's if...elif...else conditional structure.

==== Dictionaries ====

Python has another datatype called a '''dictionary''' (or <code>dict</code>, for short), which are like ''Maps'' in Java, ''associative arrays'' in PHP, and ''object literals'' in JavaScript (coming up soon in Module 6). Essentially, they enable you to use any immutable object as the key in your data structure. <code>dict</code> objects can be created using either the <code>dict</code> function, or by placing items between curly braces, separating keys and values using colons:

<source lang="python">
fruits_in_bowl = {
'apple': 4,
'banana': 2,
'cherry': 0,
'date': 12
}

apple_count = fruits_in_bowl['apple'] # Equals 4

fruits_in_bowl['pear'] = 9 # Sets 'pear' in the dictionary to 9.

for fruit, num in fruits_in_bowl.items():
print(f"There are {num} {fruit}(s) in the bowl." % (num, fruit))
</source>
If you only want the keys from a dictionary, you can just iterate over it directly, like this:

<source lang="python">
for fruit in fruits_in_bowl:
print(fruit)
</source>
If you want only the values but not the keys from a dictionary, use <code>my_dictionary.values()</code>.

==== Sets ====
A <code>set</code> is an unordered collection of unique items, with constant-time membership checking.
<source lang="python">
fruits = {'Apple', 'Apple', 'Apple', 'Pear'} # The set removes duplicates, so it will only contain {'Apple', 'Pear'}
fruits = set(['Apple', 'Apple', 'Apple', 'Pear']) # This line transforms a list into a set
print('Apple' in fruits) # Constant-time!
</source>

=== Loops ===

In Python, while loops are written like this:

<source lang="python">
i = 0
while i < 10:
i += 1
</source>
For loops are written like this:

<source lang="python">
pets = ['Dog', 'Cat', 'Fish']

for pet in pets:
print(pet)
</source>
To iterate over a range of numbers, you can use the convenient <code>range</code> function, like so:

<source lang="python">
for i in range(20, 30): # If you omit the first argument to range, it's assumed to be zero.
print(i)
</source>
Note that <code>range</code> provides a closed-open range. That is to say, it is inclusive of its lower bound and exclusive of its upper bound. To be very explicit about it:

<source lang="python">
list(range(3, 6)) == [3, 4, 5]
</source>
Unlike in other languages you may know, the following is not good practice in Python:

<source lang="python">
pets = ['Dog', 'Cat', 'Fish']

# BAD PRACTICE. DO NOT USE.
for i in range(len(pets)):
pet = pets[i]
</source>
Instead, if you need to access both a variable and its index, use the <code>enumerate</code> function, which allows you to iterate through a group of items, along with their indexes, like so:

<source lang="python">
pets = ['Dog', 'Cat', 'Fish']

for index, pet in enumerate(pets):
print(f"{pet} at index {index}")
</source>

=== Generator Expressions and Comprehensions ===

A generator is a special kind of object that, basically, represents a collection of items using a value and a function for generating the next value in the collection. In other words, it's a way of creating something that behaves like a list, but which only generates one value at a time, and discards a value when it's done with it. Say, for example, you wanted to do an operation on 10,000,000,000,000 numbers. You could put them all in a list, then iterate over the list, but that would take a lot of memory, plus you'd have to create and fill the entire list before beginning to actually work on your problem. Instead, you'd probably be better off using a generator; telling the computer, essentially: “The starting value is 0. When I ask for the next number in the collection, add 1 to current value and give me that.”

A generator expression is an expression that is evaluated to create a generator. They're super useful. Generator expressions can take two forms – they can be used with and without a condition:

<source lang="python">
(EXPRESSION for VARIABLE in ITERABLE) # Unconditional
(EXPRESSION for VARIABLE in ITERABLE if CONDITION) # Conditional
</source>
For our purposes, you can think of an iterable as anything you can do a for loop over. Let's take a look at a generator expression in use:

<source lang="python">
double_even_digits = (number * 2 for number in range(10) if number % 2 == 0)
</source>
That line says that <code>double_even_digits</code> is every even number between 0 and 10 multiplied by two. Simple enough, right? If we wanted to use all of the numbers, not just the even ones, we could simply remove the if statement at the end of the expression.

Here's the thing, though: if you were to print <code>double_even_digits</code>, instead of a nice bunch of numbers, you'd get something that looks like this:

<code><generator object <genexpr><code>at 0x107fc92b0></code>

That's because generators are lazy! They don't generate their values until those values are needed, and they discard values once they're no longer needed. As a result, '''you can only iterate over a generator once'''. In this case, you can't print out the whole generator, because it hasn't generated all the values yet. You can, however, iterate over the generator, and print its values one at a time, like so:

<source lang="python">
for number in double_even_digits:
print(number)
</source>
You can also make a list out of the generator, which will go through all the items in the generator and put them in a list, like so:

<source lang="python">
even_number_list = list(double_even_digits)
</source>
That's actually a great segue to the second topic of this section: comprehensions. A comprehension is just a prettier way to make lists, sets, and dicts out of a generator expressions.

<source lang="python">
# If you want a list:
list(i for i in range(10) if i % 2 == 0) # Don't do this
[i for i in range(10) if i % 2 == 0] # Use a list comprehension instead!

# If you want a set:
set(i for i in range(10) if i % 2 == 0) # Don't do this
{i for i in range(10) if i % 2 == 0} # Use a set comprehension instead!

# If you want a dict:
dict((i, i + 1) for i in range(10) if i % 2 == 0) # Don't do this
{i : i + 1 for i in range(10) if i % 2 == 0} # Use a dict comprehension instead!

# If you want a tuple:
tuple(i for i in range(10) if i % 2 == 0) # Unfortunately, there's no better way to do this
</source>
In general, generators and comprehensions should be used whenever possible - they're the fastest and easiest way to build collections. If you ever see yourself writing code like this:

<source lang="python">
# BAD PRACTICE! DO NOT USE!
digits = []
for digit in range(10):
digits.append(digit)
</source>
Don't do it! Instead, use a generator expression or comprehension, as appropriate. A good way to decide whether a generator expression or comprehension is better for this situation is that, if you're just going to be iterating over your collection once, you should use an generator expression. If not, use a comprehension.

=== Sorting ===

Sorting in Python is frequently performed using the <code>sorted</code> function, which takes two arguments: an iterable (anything you can do a for-loop over, including lists and tuples) and a function used to evaluate each item. If the function is omitted, Python will try to sort the lists by value.

The following example demonstrates using an inline function, which Python calls a ''lambda''.

<source lang="python">
fruits = ['apple', 'banana', 'cherry', 'date']

# sort the fruits by string length
new_fruits = sorted(fruits, key=lambda v: len(v) // 2)

print(new_fruits) # ['date', 'apple', 'banana', 'cherry']
</source>
Alternatively, you can sort a <code>list</code> using the <code>.sort</code> method. This is faster than calling <code>sorted</code>, but it modifies the list in-place and returns <code>None</code>.

<source lang="python">
fruits = ['apple', 'banana', 'cherry', 'date']
fruits.sort()
</source>
=== Import ===

If you want to use functions from other libraries (including ones that you install using pip), use <code>import</code>:

<source lang="python">
import time

current_time = time.localtime()
print(time.strftime('%a, %d %b %Y %H:%M:%S', current_time))
</source>
If you want to pull the functions out of their namespace, you can use <code>from ___ import ___</code> syntax:

<source lang="python">
from time import localtime, strftime

current_time = localtime()
print(strftime('%a, %d %b %Y %H:%M:%S', current_time))

# Be aware that this technique, although convenient, may cause unexpected behavior if the function names that you're pulling out of the namespace are already used for other purposes in Python.
</source>
=== File I/O ===

You can read an entire file into a variable like this:

<source lang="python">
f = open("example.txt")
file_contents = f.read()

f.close() # free up memory when we're finished with the file
</source>
A better option is to use a with-block, which handles opening and closing the file for you automatically:

<source lang="python">
with open("example.txt") as f:
file_contents = f.read()
</source>
You can read a file line-by-line like this:

<source lang="python">
with open("example.txt") as f:
for line in f:
print("Read line: %s" % line.rstrip())
</source>
You can write to a file like this:

<source lang="python">
with open("example.txt", "w") as f:
f.write("Hello\nWorld\n")
</source>
=== Command-Line Arguments ===

Command line arguments are accessible in the variable <code>sys.argv</code>.

The following example shows a program that expects a filename as its argument, and it prints a usage message if the argument is not present ([https://stackoverflow.com/questions/983201/python-and-sys-argv source]).

<source lang="python">
import sys, os

if len(sys.argv) < 2:
sys.exit(f"Usage: {sys.argv[0]} filename")

filename = sys.argv[1]

if not os.path.exists(filename):
sys.exit(f"Error: File '{sys.argv[1]}' not found")
</source>

=== Object-Oriented Programming ===

You can define and use a class like this:

<source lang="python">
class Food:
# constructor:
def __init__(self, name):
self.name = name

def format_name(self):
return f"Gotta love to eat {self.name}"

class Fruit(Food):
def format_name(self):
return f"{Food.format_name(self)} (fruit)"

fruit = Fruit("Cherry")
print(fruit.format_name())
print(Food.get_definition())
</source>
This is the same example as in [[PHP#Object-Oriented_Programming|the PHP guide]].

Some things to notice:

* Instance methods ''always'' take <code>self</code> as their first argument, followed by any number of additional parameters. This can be misleading for programmers familiar with other languages, because the number of arguments you feed to the method is actually ''one less than'' the number of declared parameters. Whenever you call a method on a class instance, that instance is implicitly fed into the explicitly-declared <code>self</code> parameter of the method.
*: Note that the <code>self</code> variable has the same purpose as the <code>this</code> variable in languages like PHP, Java, JavaScript, and C++.
*There is no need for a <code>new</code> keyword in Python.

= Footnotes =
# {{note|interpreted}}This is an oversimplification. If you're interested, here's a quick explanation of how: In CPython (the reference implementation of Python) programs are compiled to bytecode, an intermediate representation, which is then interpreted.
[[Category:Module 4]]

Python

2018-02-19T17:33:39Z

Alex: /* Installation */ Bumped Python version

Languages like Java and C++ have lots of rules regarding variable types, syntax, return values, and so on. These can be cumbersome when you are trying to write short, quick scripts to perform tasks. This is where a ''scripting language'' comes into play.

'''Python''' is a language well-suited to rapid prototype development. It is generally an ''interpreted language'', which means that, generally speaking, a Python program is converted line by line into instructions for the computer to execute as the program runs, instead of having a separate compilation step beforehand {{ref|interpreted}}. The syntax is clean, and it is usually clear at first glance what is going on when you write in Python.

= Installation =

Python may already be installed on your system. To see whether or not it is, enter the command

<source lang="bash">
$ python --version
</source>
If it tells you a version of Python '''greater than or equal to 3.6''' then you're good to go. If not, you need to do a quick package install to get it up and running. Using yum, it's just <code>sudo yum install python36; sudo alternatives --set python /usr/bin/python3</code>.

==== Python 2 vs Python 3 ====

In 2008, a new version of Python – Python 3 – was released, with a number changes that made it incompatible with the previous version, Python 2. For several years, the Python community was slow to make the change to Python 3, but today, Python 3 is ''the'' standard for new code. The ''only'' reason to write Python 2 code today is because you have to work in an environment or with libraries that do not support Python 3, and that situation is becoming increasingly rare.

'''For CSE 330 (and this guide), you ''must'' use Python 3.6 or greater.'''

=== Pip ===

Linux distributions have package managers like ''Apt'', ''Yum'', and ''YaST''. PHP has a package manager named ''PEAR''. It's now time to introduce Python's leading package manager: '''pip'''.

You need to install Pip from Yum before you can use it. The package is called <code>python-pip</code>.

Once you have pip installed, you can use it to install Python packages. Use the <code>pip-python</code> command:

<source lang="bash">
$ pip-python install package_name # RHEL
$ pip install package_name # Debian
</source>

= Running Python =

There are two common ways to run Python code: via the console, and via a Python script file.

=== The Python Console ===

The Python console enables you to experiment with code without opening a text editor. To enter the Python console, simply type the ''python'' command at the terminal:

<source lang="bash">
$ python
</source>
To leave the interactive console, either type <code>quit()</code> or press <code>Ctrl-D</code> (on both Mac and Windows).

=== Python Script Files ===

You can also save Python script files for later use. The extension for Python scripts is <code>*.py</code>. To run a script file, simply feed its path as an argument to the <code>python</code> command in Terminal:

<source lang="bash">
$ python my_script.py
</source>

= Python Syntax and Language Components =

This section contains a very brief overview of Python syntax. For a more comprehensive introduction, see [http://docs.python.org/tutorial/ the Python docs].

=== Python's Type System ===

Python is a dynamically-typed, strongly-typed, and duck-typed language. What does that mean? Well, let's take those categories one by one:

<ol>
<li>
'''Dynamic typing''', in contrast to ''static typing'' means that the types of objects can be changed. In Java, for instance, if you tried to write the following code:

<source lang="java">
int c = 2;
c = "fish";
</source>

Your code would fail to compile, because the Java compiler wouldn't allow you to change the type of the variable <code>c</code> from <code>int</code> to <code>String</code>.

Python, however, is just fine with that. You can write:

<source lang="python">
c = 2
c = "fish"
</source>

And Python will happily do what you ask.
</li>

<li>
'''Strong typing''', in contrast to ''weak typing'', means, roughly, that a language won't implicitly convert types for you. So far, you've used a lot of PHP, which is very weakly typed. For example:

<source lang="php">
echo "10" . 2;
</source>

In PHP, this works just fine. The PHP interpreter sees that <code>2</code> is an int, and silently converts it to a string for you, so that <code>"10". 2</code> equals <code>"102"</code>. The problem with weak typing is that it can make it unclear to the programmer why things are happening the way they are. For instance, in PHP, the expression <code>"10" == 10</code> is true, which can be less than obvious. Python, however, tries to disallow that sort of thing:

<source lang="python">
"10" + "10" # Allowed – concatenates the two strings.
10 + 10 # Allowed – adds the two ints.
"10" + 10 # Not allowed – raises a TypeError
</source>

Perhaps the one exception to this rule is the relationship between numeric types; it's perfectly fine to add a float to an int, for example.
</li>

<li>
'''Duck-typing''' is a little bit different than the other categories, because it doesn't really have a direct opposite. Essentially, duck-typing is the philosophy that "If it walks like a duck, and quacks like a duck, it's a duck." In programming terms, that means that we often don't care what type an object is, as long as it can do the things we ask.

Let's look at an example:

<source lang="python">
# This function doubles the value it's passed.
def double(thing):
return thing + thing
double(10) # Returns 20
double("fish") # Returns "fishfish";
</source>

If this were Java, we'd have to write two different methods here: one for things of type <code>int</code>, and one for things of type <code>String</code>. Since this is Python, though, we don't have to do that. Instead, Python lets us say, essentially: "This function uses the <code>+</code> operator, so you can pass whatever object you want to the function, as long as the function supports the <code>+</code> operator".

To quote [https://groups.google.com/forum/?hl=en#!msg/comp.lang.python/CCs2oJdyuzc/NYjla5HKMOIJ Alex Martelli], one of the key people in the Python project,

<blockquote>
"[Don't] check whether it IS-a duck: check whether it QUACKS-like-a duck, WALKS-like-a duck, etc, etc, depending on exactly what subset of duck-like behaviour you need."
</blockquote>

</li>
</ol>

=== Basic Types ===

In Python, the basic scalar types are:

# <code>str</code> – a string.
# <code>int</code> – an integer object with unlimited digits.
# <code>bool</code> – a Boolean value.
# <code>float</code> – a floating point number; generally equivalent to <code>double</code> in Java.
# <code>bytes</code> – represents a collection of bytes; you're unlikely to use this often.

Casting is done in the C style - to parse an <code>int</code> from a string, for instance, you'd write <code>int("123")</code>.

=== Basic Control Flow ===
In Python, blocks of code are delineated using colons and indentation instead of curly braces. '''''That means that proper indentation is mandatory.''''' Every time you use a colon, you must indent one step further, and every time a block ends, you must unindent a step.

Conditional statements are done using the <code>if</code>, <code>elif</code>, and <code>else</code> operators, like in the example below - pay attention to the indentation:

<source lang="python">
cookies_left = 10
cake_slices_left = 3
if cookies_left > 10:
print("Lots of cookies!")
elif cookies_left > 8:
print("Plenty left!")
elif cookies_left == 5:
print("Halfway done!")
else:
if cake_slices_left == 3:
print("Lots of cake!")
elif cake_slices_left == 2:
print("One slice gone!")
else:
print("Little to no cake left!")
</source>

=== An Example Python Script ===

In my mind, there's no better way to learn Python than to be immersed in a simple example script.

<source lang="python">
print("Hello World")

fruits = ["apple", "banana", "cherry", "date"]
for fruit in fruits:
print(f"I always love to eat a fresh {fruit}")

# Map the fruits list over to a new list containing the length of the fruit strings:
fruit_size = [len(fruit) for fruit in fruits]

avg_fruit_size = sum(fruit_size) / len(fruit_size)
print(f"The average fruit string length is {avg_fruit_size:.2f}.")
</source>

Some things to notice:

* Printing is achieved using the <code>print()</code> function.
* Comments start with a pound symbol <code>#</code>.
* We can transform/map a list to a new list in just one line!

For some more examples, see [https://wiki.python.org/moin/SimplePrograms the Python wiki].

=== A Few Gotchas ===

Here are a few things you may not expect when starting out with Python:

<ol>

<li>
Strings can be delimited using either single quotes (<code>'</code>) or double quotes (<code>"</code>), so <code>'Python'</code> is the same as <code>"Python"</code. You can also use three sets of quotes (<code>'''</code> or <code>"""</code>) to delineate a multiple-line string, like so:
<source lang="python">
long_string = """This
is my
very long
multiple-line
string"""
</source>
</li>

<li>
To compare the equality of two objects, use the <code>==</code> operator. To compare the identity of two objects (i.e. whether or not they are literally the same object, at the same place in memory), use the <code>is</code> operator. These correspond, respectively to <code>.equals()</code> and <code>==</code> in Java.
</li>

<li>
The <code>/</code> operator performs floating-point division, not integer division, even when both its arguments are integers. If you want to do integer division, use the <code>//</code> operator. Let's look at an example:

<source lang="python">
9 / 10 == 0.9 # Floating-point division
9.0 / 10.0 == 0.9 # Floating-point division
9 // 10 == 0 # Integer division
9.0 // 10.0 == 0.0 # Integer division, even though the resulting value is a float
</source>
</li>

<li>
As discussed in the section [[#Python's_Type_System|Python's Type System]], you can't combine strings and numbers using the <code>+</code> operator. Instead, you'll have to use one of the following methods of string formatting:

<source lang="python">

# Technique 1 – printf-style Formatting
# This is a classic style of string formatting, used in many programming languages, including in Java's String.format.
"You scored %d out of %d!" % (score, questions)

# Technique 2 – str.format
"You scored {} out of {}!".format(score, questions)

# Technique 3 – f-strings
# These were only introduced in Python 3.6 but they're very convenient.
f"You scored {score} out of {questions}!"

# Technique 4 - String Concatenation
# This is fine for small things, but for more complicated stuff, use one of the other techniques.
"You scored " + str(score) + " out of " + str(questions) + "!"
</source>
</li>
</ol>

=== Functions ===

Define functions using the <code>def</code> keyword:

<source lang="python">
def hello(name):
print(f"Hello, {name}!")

</source>

Invoke functions using parentheses:
<source lang="python">
hello("Batman")
hello("Superman")
</source>

Functions can have optional arguments; however, these must come after any required arguments:
<source lang="python">
def hello(name="User"):
print(f"Hello, {name}!")

hello() # Prints "Hello, User!"
hello("Sarah") # Prints "Hello, Sarah!"
</source>

Functions are just regular objects in Python, meaning you can do stuff like this:

<source lang="python">
def hello(name="User"):
print(f"Hello, {name}!")

greeting = hello

greeting("Siwei") # Prints "Hello, Siwei!"
</source>

=== Collection Types ===
Python has a few basic, built-in collection types. They each have their own special use cases, but they share a lot of similarities. All built-in data structures in Python are zero-indexed, for instance.

To obtain the number of elements in a collection, use the <code>len()</code> function, like this:

<source lang="python">
pets = ['Dog', 'Cat', 'Fish'] # This is a list; you'll learn about them below.

len(pets) # Returns 3
</source>

To check if a collection contains an item, use the <code>in</code> operator:
<source lang="python">
pets = ['Dog', 'Cat', 'Fish'] # This is a list; you'll learn about them below.

'Dog' in pets # Returns True
</source>

Helpfully, the Python Software Foundation maintains a page containing the asymptotic complexities of important operations on major Python data structures. It's available [https://wiki.python.org/moin/TimeComplexity here].

==== Lists ====

Unlike languages like Java and C, Python's array-like type doesn't have fixed length. Instead, a <code>list</code> is a dynamic array (like Java's <code>ArrayList</code>) of objects of any type. Here's an example:

<source lang="python">
fruits = ["Apple", "Pear", "Orange"] # Lists can be creating by placing their items between square brackets

random_items = ['Apple', 12312, 2.0, [1, 2, 3]] # Lists can contain objects of different types - even other lists!

pets.append('Turtle') # Adds 'Turtle' to the end of pets
</source>

For the next few examples, we'll be using the following list:

<source lang="python">
pets = ['Dog', 'Cat', 'Fish', 'Turtle', 'Lizard', 'Snake']
</source>

To access or assign elements of a list, use the <code>[]</code> operator.

<source lang="python">
pets[0] # Returns 'Dog'
pets[1] = 'Cow' # Sets pets[1] to 'Cow'
pets[1] = 'Cat' # Sets pets[1] back to 'Cat'
</source>

You can also access or assign lists using negative indices, which will return elements starting from the end of the list:

<source lang="python">
pets[-1] # Returns 'Snake'
pets[-2] # Returns 'Lizard'
</source>

You can also use 'slice notation' to obtain or assign subsets of lists:
<source lang="python">
pets[start:end] # Returns items from index start to index end - 1.
pets[start:] # Returns items from index start to the end of the list, inclusive.
pets[:end] # Returns items from the beginning of the list to index end - 1.
pets[:] # Returns every item in the list
</source>

There's also a third, optional argument: <code>step</code>, which lets you jump over values:
<source lang="python">
pets[start:end:step] # Returns items from index start to index end - 1, jumping step values at a time

# Examples:
pets[1:5:2] # Returns items from index 1 to index 4, jumping 2 at a time, so ['Cat', 'Turtle']
pets[::3] # Returns all items in the list, jumping 3 at a time, so ['Dog', 'Turtle']
pets[::-1] # Returns all items in the list, jumping -1 at a time. This reverses the list, so ['Snake', 'Lizard', 'Turtle', 'Fish', 'Cat', 'Dog']
</source>

Lists have all the performance characteristics you'd expect of a dynamic array - constant-time indexing, amortized constant-time appends, and so on.

==== Tuples ====

Python has a special data type called <code>tuple</code>, which is exactly the same as a list except for the fact that it cannot be modified, so you can't append or replace items.

<source lang="python">
cities = ('St. Louis', 'Los Angeles', 'Seattle') # Tuples are defined using parentheses.
numbers = 1, 2, 3 # You can also omit the parentheses if it's unambiguous
single_item_tuple = (1,) # To make a tuple with only one item, put a comma after it
</source>

Tuples also enable you to have multiple return values from a function:

<source lang="python">
def compute_length(string):
str_len = len(string)
if str_len < 5:
return str_len, "short"
elif str_len < 40:
return str_len, "medium"
return str_len, "long"

length, description = compute_length("Four score and seven years ago")
print(f"The {description} string is {length} characters long.")
</source>
The above example also demonstrates Python's if...elif...else conditional structure.

==== Dictionaries ====

Python has another datatype called a '''dictionary''' (or <code>dict</code>, for short), which are like ''Maps'' in Java, ''associative arrays'' in PHP, and ''object literals'' in JavaScript (coming up soon in Module 6). Essentially, they enable you to use any immutable object as the key in your data structure. <code>dict</code> objects can be created using either the <code>dict</code> function, or by placing items between curly braces, separating keys and values using colons:

<source lang="python">
fruits_in_bowl = {
'apple': 4,
'banana': 2,
'cherry': 0,
'date': 12
}

apple_count = fruits_in_bowl['apple'] # Equals 4

fruits_in_bowl['pear'] = 9 # Sets 'pear' in the dictionary to 9.

for fruit, num in fruits_in_bowl.items():
print(f"There are {num} {fruit}(s) in the bowl." % (num, fruit))
</source>
If you only want the keys from a dictionary, you can just iterate over it directly, like this:

<source lang="python">
for fruit in fruits_in_bowl:
print(fruit)
</source>
If you want only the values but not the keys from a dictionary, use <code>my_dictionary.values()</code>.

==== Sets ====
A <code>set</code> is an unordered collection of unique items, with constant-time membership checking.
<source lang="python">
fruits = {'Apple', 'Apple', 'Apple', 'Pear'} # The set removes duplicates, so it will only contain {'Apple', 'Pear'}
fruits = set(['Apple', 'Apple', 'Apple', 'Pear']) # This line transforms a list into a set
print('Apple' in fruits) # Constant-time!
</source>

=== Loops ===

In Python, while loops are written like this:

<source lang="python">
i = 0
while i < 10:
i += 1
</source>
For loops are written like this:

<source lang="python">
pets = ['Dog', 'Cat', 'Fish']

for pet in pets:
print(pet)
</source>
To iterate over a range of numbers, you can use the convenient <code>range</code> function, like so:

<source lang="python">
for i in range(20, 30): # If you omit the first argument to range, it's assumed to be zero.
print(i)
</source>
Note that <code>range</code> provides a closed-open range. That is to say, it is inclusive of its lower bound and exclusive of its upper bound. To be very explicit about it:

<source lang="python">
list(range(3, 6)) == [3, 4, 5]
</source>
Unlike in other languages you may know, the following is not good practice in Python:

<source lang="python">
pets = ['Dog', 'Cat', 'Fish']

# BAD PRACTICE. DO NOT USE.
for i in range(len(pets)):
pet = pets[i]
</source>
Instead, if you need to access both a variable and its index, use the <code>enumerate</code> function, which allows you to iterate through a group of items, along with their indexes, like so:

<source lang="python">
pets = ['Dog', 'Cat', 'Fish']

for index, pet in enumerate(pets):
print(f"{pet} at index {index}")
</source>

=== Generator Expressions and Comprehensions ===

A generator is a special kind of object that, basically, represents a collection of items using a value and a function for generating the next value in the collection. In other words, it's a way of creating something that behaves like a list, but which only generates one value at a time, and discards a value when it's done with it. Say, for example, you wanted to do an operation on 10,000,000,000,000 numbers. You could put them all in a list, then iterate over the list, but that would take a lot of memory, plus you'd have to create and fill the entire list before beginning to actually work on your problem. Instead, you'd probably be better off using a generator; telling the computer, essentially: “The starting value is 0. When I ask for the next number in the collection, add 1 to current value and give me that.”

A generator expression is an expression that is evaluated to create a generator. They're super useful. Generator expressions can take two forms – they can be used with and without a condition:

<source lang="python">
(EXPRESSION for VARIABLE in ITERABLE) # Unconditional
(EXPRESSION for VARIABLE in ITERABLE if CONDITION) # Conditional
</source>
For our purposes, you can think of an iterable as anything you can do a for loop over. Let's take a look at a generator expression in use:

<source lang="python">
double_even_digits = (number * 2 for number in range(10) if number % 2 == 0)
</source>
That line says that <code>double_even_digits</code> is every even number between 0 and 10 multiplied by two. Simple enough, right? If we wanted to use all of the numbers, not just the even ones, we could simply remove the if statement at the end of the expression.

Here's the thing, though: if you were to print <code>double_even_digits</code>, instead of a nice bunch of numbers, you'd get something that looks like this:

<code><generator object <genexpr><code>at 0x107fc92b0></code>

That's because generators are lazy! They don't generate their values until those values are needed, and they discard values once they're no longer needed. As a result, '''you can only iterate over a generator once'''. In this case, you can't print out the whole generator, because it hasn't generated all the values yet. You can, however, iterate over the generator, and print its values one at a time, like so:

<source lang="python">
for number in double_even_digits:
print(number)
</source>
You can also make a list out of the generator, which will go through all the items in the generator and put them in a list, like so:

<source lang="python">
even_number_list = list(double_even_digits)
</source>
That's actually a great segue to the second topic of this section: comprehensions. A comprehension is just a prettier way to make lists, sets, and dicts out of a generator expressions.

<source lang="python">
# If you want a list:
list(i for i in range(10) if i % 2 == 0) # Don't do this
[i for i in range(10) if i % 2 == 0] # Use a list comprehension instead!

# If you want a set:
set(i for i in range(10) if i % 2 == 0) # Don't do this
{i for i in range(10) if i % 2 == 0} # Use a set comprehension instead!

# If you want a dict:
dict((i, i + 1) for i in range(10) if i % 2 == 0) # Don't do this
{i : i + 1 for i in range(10) if i % 2 == 0} # Use a dict comprehension instead!

# If you want a tuple:
tuple(i for i in range(10) if i % 2 == 0) # Unfortunately, there's no better way to do this
</source>
In general, generators and comprehensions should be used whenever possible - they're the fastest and easiest way to build collections. If you ever see yourself writing code like this:

<source lang="python">
# BAD PRACTICE! DO NOT USE!
digits = []
for digit in range(10):
digits.append(digit)
</source>
Don't do it! Instead, use a generator expression or comprehension, as appropriate. A good way to decide whether a generator expression or comprehension is better for this situation is that, if you're just going to be iterating over your collection once, you should use an generator expression. If not, use a comprehension.

=== Sorting ===

Sorting in Python is frequently performed using the <code>sorted</code> function, which takes two arguments: an iterable (anything you can do a for-loop over, including lists and tuples) and a function used to evaluate each item. If the function is omitted, Python will try to sort the lists by value.

The following example demonstrates using an inline function, which Python calls a ''lambda''.

<source lang="python">
fruits = ['apple', 'banana', 'cherry', 'date']

# sort the fruits by string length
new_fruits = sorted(fruits, key=lambda v: len(v) // 2)

print(new_fruits) # ['date', 'apple', 'banana', 'cherry']
</source>
Alternatively, you can sort a <code>list</code> using the <code>.sort</code> method. This is faster than calling <code>sorted</code>, but it modifies the list in-place and returns <code>None</code>.

<source lang="python">
fruits = ['apple', 'banana', 'cherry', 'date']
fruits.sort()
</source>
=== Import ===

If you want to use functions from other libraries (including ones that you install using pip), use <code>import</code>:

<source lang="python">
import time

current_time = time.localtime()
print(time.strftime('%a, %d %b %Y %H:%M:%S', current_time))
</source>
If you want to pull the functions out of their namespace, you can use <code>from ___ import ___</code> syntax:

<source lang="python">
from time import localtime, strftime

current_time = localtime()
print(strftime('%a, %d %b %Y %H:%M:%S', current_time))

# Be aware that this technique, although convenient, may cause unexpected behavior if the function names that you're pulling out of the namespace are already used for other purposes in Python.
</source>
=== File I/O ===

You can read an entire file into a variable like this:

<source lang="python">
f = open("example.txt")
file_contents = f.read()

f.close() # free up memory when we're finished with the file
</source>
A better option is to use a with-block, which handles opening and closing the file for you automatically:

<source lang="python">
with open("example.txt") as f:
file_contents = f.read()
</source>
You can read a file line-by-line like this:

<source lang="python">
with open("example.txt") as f:
for line in f:
print("Read line: %s" % line.rstrip())
</source>
You can write to a file like this:

<source lang="python">
with open("example.txt", "w") as f:
f.write("Hello\nWorld\n")
</source>
=== Command-Line Arguments ===

Command line arguments are accessible in the variable <code>sys.argv</code>.

The following example shows a program that expects a filename as its argument, and it prints a usage message if the argument is not present ([https://stackoverflow.com/questions/983201/python-and-sys-argv source]).

<source lang="python">
import sys, os

if len(sys.argv) < 2:
sys.exit(f"Usage: {sys.argv[0]} filename")

filename = sys.argv[1]

if not os.path.exists(filename):
sys.exit(f"Error: File '{sys.argv[1]}' not found")
</source>

=== Object-Oriented Programming ===

You can define and use a class like this:

<source lang="python">
class Food:
# constructor:
def __init__(self, name):
self.name = name

def format_name(self):
return f"Gotta love to eat {self.name}"

class Fruit(Food):
def format_name(self):
return f"{Food.format_name(self)} (fruit)"

fruit = Fruit("Cherry")
print(fruit.format_name())
print(Food.get_definition())
</source>
This is the same example as in [[PHP#Object-Oriented_Programming|the PHP guide]].

Some things to notice:

* Instance methods ''always'' take <code>self</code> as their first argument, followed by any number of additional parameters. This can be misleading for programmers familiar with other languages, because the number of arguments you feed to the method is actually ''one less than'' the number of declared parameters. Whenever you call a method on a class instance, that instance is implicitly fed into the explicitly-declared <code>self</code> parameter of the method.
*: Note that the <code>self</code> variable has the same purpose as the <code>this</code> variable in languages like PHP, Java, JavaScript, and C++.
*There is no need for a <code>new</code> keyword in Python.

= Footnotes =
# {{note|interpreted}}This is an oversimplification. If you're interested, here's a quick explanation of how: In CPython (the reference implementation of Python) programs are compiled to bytecode, an intermediate representation, which is then interpreted.
[[Category:Module 4]]

Python

2018-02-19T17:33:18Z

Alex: /* Python 2 vs Python 3 */

Languages like Java and C++ have lots of rules regarding variable types, syntax, return values, and so on. These can be cumbersome when you are trying to write short, quick scripts to perform tasks. This is where a ''scripting language'' comes into play.

'''Python''' is a language well-suited to rapid prototype development. It is generally an ''interpreted language'', which means that, generally speaking, a Python program is converted line by line into instructions for the computer to execute as the program runs, instead of having a separate compilation step beforehand {{ref|interpreted}}. The syntax is clean, and it is usually clear at first glance what is going on when you write in Python.

= Installation =

Python may already be installed on your system. To see whether or not it is, enter the command

<source lang="bash">
$ python --version
</source>
If it tells you a version of Python '''greater than or equal to 3.5''' then you're good to go. If not, you need to do a quick package install to get it up and running. Using yum, it's just <code>sudo yum install python35; sudo alternatives --set python /usr/bin/python3</code>.

==== Python 2 vs Python 3 ====

In 2008, a new version of Python – Python 3 – was released, with a number changes that made it incompatible with the previous version, Python 2. For several years, the Python community was slow to make the change to Python 3, but today, Python 3 is ''the'' standard for new code. The ''only'' reason to write Python 2 code today is because you have to work in an environment or with libraries that do not support Python 3, and that situation is becoming increasingly rare.

'''For CSE 330 (and this guide), you ''must'' use Python 3.6 or greater.'''

=== Pip ===

Linux distributions have package managers like ''Apt'', ''Yum'', and ''YaST''. PHP has a package manager named ''PEAR''. It's now time to introduce Python's leading package manager: '''pip'''.

You need to install Pip from Yum before you can use it. The package is called <code>python-pip</code>.

Once you have pip installed, you can use it to install Python packages. Use the <code>pip-python</code> command:

<source lang="bash">
$ pip-python install package_name # RHEL
$ pip install package_name # Debian
</source>
= Running Python =

There are two common ways to run Python code: via the console, and via a Python script file.

=== The Python Console ===

The Python console enables you to experiment with code without opening a text editor. To enter the Python console, simply type the ''python'' command at the terminal:

<source lang="bash">
$ python
</source>
To leave the interactive console, either type <code>quit()</code> or press <code>Ctrl-D</code> (on both Mac and Windows).

=== Python Script Files ===

You can also save Python script files for later use. The extension for Python scripts is <code>*.py</code>. To run a script file, simply feed its path as an argument to the <code>python</code> command in Terminal:

<source lang="bash">
$ python my_script.py
</source>

= Python Syntax and Language Components =

This section contains a very brief overview of Python syntax. For a more comprehensive introduction, see [http://docs.python.org/tutorial/ the Python docs].

=== Python's Type System ===

Python is a dynamically-typed, strongly-typed, and duck-typed language. What does that mean? Well, let's take those categories one by one:

<ol>
<li>
'''Dynamic typing''', in contrast to ''static typing'' means that the types of objects can be changed. In Java, for instance, if you tried to write the following code:

<source lang="java">
int c = 2;
c = "fish";
</source>

Your code would fail to compile, because the Java compiler wouldn't allow you to change the type of the variable <code>c</code> from <code>int</code> to <code>String</code>.

Python, however, is just fine with that. You can write:

<source lang="python">
c = 2
c = "fish"
</source>

And Python will happily do what you ask.
</li>

<li>
'''Strong typing''', in contrast to ''weak typing'', means, roughly, that a language won't implicitly convert types for you. So far, you've used a lot of PHP, which is very weakly typed. For example:

<source lang="php">
echo "10" . 2;
</source>

In PHP, this works just fine. The PHP interpreter sees that <code>2</code> is an int, and silently converts it to a string for you, so that <code>"10". 2</code> equals <code>"102"</code>. The problem with weak typing is that it can make it unclear to the programmer why things are happening the way they are. For instance, in PHP, the expression <code>"10" == 10</code> is true, which can be less than obvious. Python, however, tries to disallow that sort of thing:

<source lang="python">
"10" + "10" # Allowed – concatenates the two strings.
10 + 10 # Allowed – adds the two ints.
"10" + 10 # Not allowed – raises a TypeError
</source>

Perhaps the one exception to this rule is the relationship between numeric types; it's perfectly fine to add a float to an int, for example.
</li>

<li>
'''Duck-typing''' is a little bit different than the other categories, because it doesn't really have a direct opposite. Essentially, duck-typing is the philosophy that "If it walks like a duck, and quacks like a duck, it's a duck." In programming terms, that means that we often don't care what type an object is, as long as it can do the things we ask.

Let's look at an example:

<source lang="python">
# This function doubles the value it's passed.
def double(thing):
return thing + thing
double(10) # Returns 20
double("fish") # Returns "fishfish";
</source>

If this were Java, we'd have to write two different methods here: one for things of type <code>int</code>, and one for things of type <code>String</code>. Since this is Python, though, we don't have to do that. Instead, Python lets us say, essentially: "This function uses the <code>+</code> operator, so you can pass whatever object you want to the function, as long as the function supports the <code>+</code> operator".

To quote [https://groups.google.com/forum/?hl=en#!msg/comp.lang.python/CCs2oJdyuzc/NYjla5HKMOIJ Alex Martelli], one of the key people in the Python project,

<blockquote>
"[Don't] check whether it IS-a duck: check whether it QUACKS-like-a duck, WALKS-like-a duck, etc, etc, depending on exactly what subset of duck-like behaviour you need."
</blockquote>

</li>
</ol>

=== Basic Types ===

In Python, the basic scalar types are:

# <code>str</code> – a string.
# <code>int</code> – an integer object with unlimited digits.
# <code>bool</code> – a Boolean value.
# <code>float</code> – a floating point number; generally equivalent to <code>double</code> in Java.
# <code>bytes</code> – represents a collection of bytes; you're unlikely to use this often.

Casting is done in the C style - to parse an <code>int</code> from a string, for instance, you'd write <code>int("123")</code>.

=== Basic Control Flow ===
In Python, blocks of code are delineated using colons and indentation instead of curly braces. '''''That means that proper indentation is mandatory.''''' Every time you use a colon, you must indent one step further, and every time a block ends, you must unindent a step.

Conditional statements are done using the <code>if</code>, <code>elif</code>, and <code>else</code> operators, like in the example below - pay attention to the indentation:

<source lang="python">
cookies_left = 10
cake_slices_left = 3
if cookies_left > 10:
print("Lots of cookies!")
elif cookies_left > 8:
print("Plenty left!")
elif cookies_left == 5:
print("Halfway done!")
else:
if cake_slices_left == 3:
print("Lots of cake!")
elif cake_slices_left == 2:
print("One slice gone!")
else:
print("Little to no cake left!")
</source>

=== An Example Python Script ===

In my mind, there's no better way to learn Python than to be immersed in a simple example script.

<source lang="python">
print("Hello World")

fruits = ["apple", "banana", "cherry", "date"]
for fruit in fruits:
print(f"I always love to eat a fresh {fruit}")

# Map the fruits list over to a new list containing the length of the fruit strings:
fruit_size = [len(fruit) for fruit in fruits]

avg_fruit_size = sum(fruit_size) / len(fruit_size)
print(f"The average fruit string length is {avg_fruit_size:.2f}.")
</source>

Some things to notice:

* Printing is achieved using the <code>print()</code> function.
* Comments start with a pound symbol <code>#</code>.
* We can transform/map a list to a new list in just one line!

For some more examples, see [https://wiki.python.org/moin/SimplePrograms the Python wiki].

=== A Few Gotchas ===

Here are a few things you may not expect when starting out with Python:

<ol>

<li>
Strings can be delimited using either single quotes (<code>'</code>) or double quotes (<code>"</code>), so <code>'Python'</code> is the same as <code>"Python"</code. You can also use three sets of quotes (<code>'''</code> or <code>"""</code>) to delineate a multiple-line string, like so:
<source lang="python">
long_string = """This
is my
very long
multiple-line
string"""
</source>
</li>

<li>
To compare the equality of two objects, use the <code>==</code> operator. To compare the identity of two objects (i.e. whether or not they are literally the same object, at the same place in memory), use the <code>is</code> operator. These correspond, respectively to <code>.equals()</code> and <code>==</code> in Java.
</li>

<li>
The <code>/</code> operator performs floating-point division, not integer division, even when both its arguments are integers. If you want to do integer division, use the <code>//</code> operator. Let's look at an example:

<source lang="python">
9 / 10 == 0.9 # Floating-point division
9.0 / 10.0 == 0.9 # Floating-point division
9 // 10 == 0 # Integer division
9.0 // 10.0 == 0.0 # Integer division, even though the resulting value is a float
</source>
</li>

<li>
As discussed in the section [[#Python's_Type_System|Python's Type System]], you can't combine strings and numbers using the <code>+</code> operator. Instead, you'll have to use one of the following methods of string formatting:

<source lang="python">

# Technique 1 – printf-style Formatting
# This is a classic style of string formatting, used in many programming languages, including in Java's String.format.
"You scored %d out of %d!" % (score, questions)

# Technique 2 – str.format
"You scored {} out of {}!".format(score, questions)

# Technique 3 – f-strings
# These were only introduced in Python 3.6 but they're very convenient.
f"You scored {score} out of {questions}!"

# Technique 4 - String Concatenation
# This is fine for small things, but for more complicated stuff, use one of the other techniques.
"You scored " + str(score) + " out of " + str(questions) + "!"
</source>
</li>
</ol>

=== Functions ===

Define functions using the <code>def</code> keyword:

<source lang="python">
def hello(name):
print(f"Hello, {name}!")

</source>

Invoke functions using parentheses:
<source lang="python">
hello("Batman")
hello("Superman")
</source>

Functions can have optional arguments; however, these must come after any required arguments:
<source lang="python">
def hello(name="User"):
print(f"Hello, {name}!")

hello() # Prints "Hello, User!"
hello("Sarah") # Prints "Hello, Sarah!"
</source>

Functions are just regular objects in Python, meaning you can do stuff like this:

<source lang="python">
def hello(name="User"):
print(f"Hello, {name}!")

greeting = hello

greeting("Siwei") # Prints "Hello, Siwei!"
</source>

=== Collection Types ===
Python has a few basic, built-in collection types. They each have their own special use cases, but they share a lot of similarities. All built-in data structures in Python are zero-indexed, for instance.

To obtain the number of elements in a collection, use the <code>len()</code> function, like this:

<source lang="python">
pets = ['Dog', 'Cat', 'Fish'] # This is a list; you'll learn about them below.

len(pets) # Returns 3
</source>

To check if a collection contains an item, use the <code>in</code> operator:
<source lang="python">
pets = ['Dog', 'Cat', 'Fish'] # This is a list; you'll learn about them below.

'Dog' in pets # Returns True
</source>

Helpfully, the Python Software Foundation maintains a page containing the asymptotic complexities of important operations on major Python data structures. It's available [https://wiki.python.org/moin/TimeComplexity here].

==== Lists ====

Unlike languages like Java and C, Python's array-like type doesn't have fixed length. Instead, a <code>list</code> is a dynamic array (like Java's <code>ArrayList</code>) of objects of any type. Here's an example:

<source lang="python">
fruits = ["Apple", "Pear", "Orange"] # Lists can be creating by placing their items between square brackets

random_items = ['Apple', 12312, 2.0, [1, 2, 3]] # Lists can contain objects of different types - even other lists!

pets.append('Turtle') # Adds 'Turtle' to the end of pets
</source>

For the next few examples, we'll be using the following list:

<source lang="python">
pets = ['Dog', 'Cat', 'Fish', 'Turtle', 'Lizard', 'Snake']
</source>

To access or assign elements of a list, use the <code>[]</code> operator.

<source lang="python">
pets[0] # Returns 'Dog'
pets[1] = 'Cow' # Sets pets[1] to 'Cow'
pets[1] = 'Cat' # Sets pets[1] back to 'Cat'
</source>

You can also access or assign lists using negative indices, which will return elements starting from the end of the list:

<source lang="python">
pets[-1] # Returns 'Snake'
pets[-2] # Returns 'Lizard'
</source>

You can also use 'slice notation' to obtain or assign subsets of lists:
<source lang="python">
pets[start:end] # Returns items from index start to index end - 1.
pets[start:] # Returns items from index start to the end of the list, inclusive.
pets[:end] # Returns items from the beginning of the list to index end - 1.
pets[:] # Returns every item in the list
</source>

There's also a third, optional argument: <code>step</code>, which lets you jump over values:
<source lang="python">
pets[start:end:step] # Returns items from index start to index end - 1, jumping step values at a time

# Examples:
pets[1:5:2] # Returns items from index 1 to index 4, jumping 2 at a time, so ['Cat', 'Turtle']
pets[::3] # Returns all items in the list, jumping 3 at a time, so ['Dog', 'Turtle']
pets[::-1] # Returns all items in the list, jumping -1 at a time. This reverses the list, so ['Snake', 'Lizard', 'Turtle', 'Fish', 'Cat', 'Dog']
</source>

Lists have all the performance characteristics you'd expect of a dynamic array - constant-time indexing, amortized constant-time appends, and so on.

==== Tuples ====

Python has a special data type called <code>tuple</code>, which is exactly the same as a list except for the fact that it cannot be modified, so you can't append or replace items.

<source lang="python">
cities = ('St. Louis', 'Los Angeles', 'Seattle') # Tuples are defined using parentheses.
numbers = 1, 2, 3 # You can also omit the parentheses if it's unambiguous
single_item_tuple = (1,) # To make a tuple with only one item, put a comma after it
</source>

Tuples also enable you to have multiple return values from a function:

<source lang="python">
def compute_length(string):
str_len = len(string)
if str_len < 5:
return str_len, "short"
elif str_len < 40:
return str_len, "medium"
return str_len, "long"

length, description = compute_length("Four score and seven years ago")
print(f"The {description} string is {length} characters long.")
</source>
The above example also demonstrates Python's if...elif...else conditional structure.

==== Dictionaries ====

Python has another datatype called a '''dictionary''' (or <code>dict</code>, for short), which are like ''Maps'' in Java, ''associative arrays'' in PHP, and ''object literals'' in JavaScript (coming up soon in Module 6). Essentially, they enable you to use any immutable object as the key in your data structure. <code>dict</code> objects can be created using either the <code>dict</code> function, or by placing items between curly braces, separating keys and values using colons:

<source lang="python">
fruits_in_bowl = {
'apple': 4,
'banana': 2,
'cherry': 0,
'date': 12
}

apple_count = fruits_in_bowl['apple'] # Equals 4

fruits_in_bowl['pear'] = 9 # Sets 'pear' in the dictionary to 9.

for fruit, num in fruits_in_bowl.items():
print(f"There are {num} {fruit}(s) in the bowl." % (num, fruit))
</source>
If you only want the keys from a dictionary, you can just iterate over it directly, like this:

<source lang="python">
for fruit in fruits_in_bowl:
print(fruit)
</source>
If you want only the values but not the keys from a dictionary, use <code>my_dictionary.values()</code>.

==== Sets ====
A <code>set</code> is an unordered collection of unique items, with constant-time membership checking.
<source lang="python">
fruits = {'Apple', 'Apple', 'Apple', 'Pear'} # The set removes duplicates, so it will only contain {'Apple', 'Pear'}
fruits = set(['Apple', 'Apple', 'Apple', 'Pear']) # This line transforms a list into a set
print('Apple' in fruits) # Constant-time!
</source>

=== Loops ===

In Python, while loops are written like this:

<source lang="python">
i = 0
while i < 10:
i += 1
</source>
For loops are written like this:

<source lang="python">
pets = ['Dog', 'Cat', 'Fish']

for pet in pets:
print(pet)
</source>
To iterate over a range of numbers, you can use the convenient <code>range</code> function, like so:

<source lang="python">
for i in range(20, 30): # If you omit the first argument to range, it's assumed to be zero.
print(i)
</source>
Note that <code>range</code> provides a closed-open range. That is to say, it is inclusive of its lower bound and exclusive of its upper bound. To be very explicit about it:

<source lang="python">
list(range(3, 6)) == [3, 4, 5]
</source>
Unlike in other languages you may know, the following is not good practice in Python:

<source lang="python">
pets = ['Dog', 'Cat', 'Fish']

# BAD PRACTICE. DO NOT USE.
for i in range(len(pets)):
pet = pets[i]
</source>
Instead, if you need to access both a variable and its index, use the <code>enumerate</code> function, which allows you to iterate through a group of items, along with their indexes, like so:

<source lang="python">
pets = ['Dog', 'Cat', 'Fish']

for index, pet in enumerate(pets):
print(f"{pet} at index {index}")
</source>

=== Generator Expressions and Comprehensions ===

A generator is a special kind of object that, basically, represents a collection of items using a value and a function for generating the next value in the collection. In other words, it's a way of creating something that behaves like a list, but which only generates one value at a time, and discards a value when it's done with it. Say, for example, you wanted to do an operation on 10,000,000,000,000 numbers. You could put them all in a list, then iterate over the list, but that would take a lot of memory, plus you'd have to create and fill the entire list before beginning to actually work on your problem. Instead, you'd probably be better off using a generator; telling the computer, essentially: “The starting value is 0. When I ask for the next number in the collection, add 1 to current value and give me that.”

A generator expression is an expression that is evaluated to create a generator. They're super useful. Generator expressions can take two forms – they can be used with and without a condition:

<source lang="python">
(EXPRESSION for VARIABLE in ITERABLE) # Unconditional
(EXPRESSION for VARIABLE in ITERABLE if CONDITION) # Conditional
</source>
For our purposes, you can think of an iterable as anything you can do a for loop over. Let's take a look at a generator expression in use:

<source lang="python">
double_even_digits = (number * 2 for number in range(10) if number % 2 == 0)
</source>
That line says that <code>double_even_digits</code> is every even number between 0 and 10 multiplied by two. Simple enough, right? If we wanted to use all of the numbers, not just the even ones, we could simply remove the if statement at the end of the expression.

Here's the thing, though: if you were to print <code>double_even_digits</code>, instead of a nice bunch of numbers, you'd get something that looks like this:

<code><generator object <genexpr><code>at 0x107fc92b0></code>

That's because generators are lazy! They don't generate their values until those values are needed, and they discard values once they're no longer needed. As a result, '''you can only iterate over a generator once'''. In this case, you can't print out the whole generator, because it hasn't generated all the values yet. You can, however, iterate over the generator, and print its values one at a time, like so:

<source lang="python">
for number in double_even_digits:
print(number)
</source>
You can also make a list out of the generator, which will go through all the items in the generator and put them in a list, like so:

<source lang="python">
even_number_list = list(double_even_digits)
</source>
That's actually a great segue to the second topic of this section: comprehensions. A comprehension is just a prettier way to make lists, sets, and dicts out of a generator expressions.

<source lang="python">
# If you want a list:
list(i for i in range(10) if i % 2 == 0) # Don't do this
[i for i in range(10) if i % 2 == 0] # Use a list comprehension instead!

# If you want a set:
set(i for i in range(10) if i % 2 == 0) # Don't do this
{i for i in range(10) if i % 2 == 0} # Use a set comprehension instead!

# If you want a dict:
dict((i, i + 1) for i in range(10) if i % 2 == 0) # Don't do this
{i : i + 1 for i in range(10) if i % 2 == 0} # Use a dict comprehension instead!

# If you want a tuple:
tuple(i for i in range(10) if i % 2 == 0) # Unfortunately, there's no better way to do this
</source>
In general, generators and comprehensions should be used whenever possible - they're the fastest and easiest way to build collections. If you ever see yourself writing code like this:

<source lang="python">
# BAD PRACTICE! DO NOT USE!
digits = []
for digit in range(10):
digits.append(digit)
</source>
Don't do it! Instead, use a generator expression or comprehension, as appropriate. A good way to decide whether a generator expression or comprehension is better for this situation is that, if you're just going to be iterating over your collection once, you should use an generator expression. If not, use a comprehension.

=== Sorting ===

Sorting in Python is frequently performed using the <code>sorted</code> function, which takes two arguments: an iterable (anything you can do a for-loop over, including lists and tuples) and a function used to evaluate each item. If the function is omitted, Python will try to sort the lists by value.

The following example demonstrates using an inline function, which Python calls a ''lambda''.

<source lang="python">
fruits = ['apple', 'banana', 'cherry', 'date']

# sort the fruits by string length
new_fruits = sorted(fruits, key=lambda v: len(v) // 2)

print(new_fruits) # ['date', 'apple', 'banana', 'cherry']
</source>
Alternatively, you can sort a <code>list</code> using the <code>.sort</code> method. This is faster than calling <code>sorted</code>, but it modifies the list in-place and returns <code>None</code>.

<source lang="python">
fruits = ['apple', 'banana', 'cherry', 'date']
fruits.sort()
</source>
=== Import ===

If you want to use functions from other libraries (including ones that you install using pip), use <code>import</code>:

<source lang="python">
import time

current_time = time.localtime()
print(time.strftime('%a, %d %b %Y %H:%M:%S', current_time))
</source>
If you want to pull the functions out of their namespace, you can use <code>from ___ import ___</code> syntax:

<source lang="python">
from time import localtime, strftime

current_time = localtime()
print(strftime('%a, %d %b %Y %H:%M:%S', current_time))

# Be aware that this technique, although convenient, may cause unexpected behavior if the function names that you're pulling out of the namespace are already used for other purposes in Python.
</source>
=== File I/O ===

You can read an entire file into a variable like this:

<source lang="python">
f = open("example.txt")
file_contents = f.read()

f.close() # free up memory when we're finished with the file
</source>
A better option is to use a with-block, which handles opening and closing the file for you automatically:

<source lang="python">
with open("example.txt") as f:
file_contents = f.read()
</source>
You can read a file line-by-line like this:

<source lang="python">
with open("example.txt") as f:
for line in f:
print("Read line: %s" % line.rstrip())
</source>
You can write to a file like this:

<source lang="python">
with open("example.txt", "w") as f:
f.write("Hello\nWorld\n")
</source>
=== Command-Line Arguments ===

Command line arguments are accessible in the variable <code>sys.argv</code>.

The following example shows a program that expects a filename as its argument, and it prints a usage message if the argument is not present ([https://stackoverflow.com/questions/983201/python-and-sys-argv source]).

<source lang="python">
import sys, os

if len(sys.argv) < 2:
sys.exit(f"Usage: {sys.argv[0]} filename")

filename = sys.argv[1]

if not os.path.exists(filename):
sys.exit(f"Error: File '{sys.argv[1]}' not found")
</source>

=== Object-Oriented Programming ===

You can define and use a class like this:

<source lang="python">
class Food:
# constructor:
def __init__(self, name):
self.name = name

def format_name(self):
return f"Gotta love to eat {self.name}"

class Fruit(Food):
def format_name(self):
return f"{Food.format_name(self)} (fruit)"

fruit = Fruit("Cherry")
print(fruit.format_name())
print(Food.get_definition())
</source>
This is the same example as in [[PHP#Object-Oriented_Programming|the PHP guide]].

Some things to notice:

* Instance methods ''always'' take <code>self</code> as their first argument, followed by any number of additional parameters. This can be misleading for programmers familiar with other languages, because the number of arguments you feed to the method is actually ''one less than'' the number of declared parameters. Whenever you call a method on a class instance, that instance is implicitly fed into the explicitly-declared <code>self</code> parameter of the method.
*: Note that the <code>self</code> variable has the same purpose as the <code>this</code> variable in languages like PHP, Java, JavaScript, and C++.
*There is no need for a <code>new</code> keyword in Python.

= Footnotes =
# {{note|interpreted}}This is an oversimplification. If you're interested, here's a quick explanation of how: In CPython (the reference implementation of Python) programs are compiled to bytecode, an intermediate representation, which is then interpreted.
[[Category:Module 4]]

Python

2018-02-19T17:32:34Z

Alex: /* Tuples */ Format strings

Languages like Java and C++ have lots of rules regarding variable types, syntax, return values, and so on. These can be cumbersome when you are trying to write short, quick scripts to perform tasks. This is where a ''scripting language'' comes into play.

'''Python''' is a language well-suited to rapid prototype development. It is generally an ''interpreted language'', which means that, generally speaking, a Python program is converted line by line into instructions for the computer to execute as the program runs, instead of having a separate compilation step beforehand {{ref|interpreted}}. The syntax is clean, and it is usually clear at first glance what is going on when you write in Python.

= Installation =

Python may already be installed on your system. To see whether or not it is, enter the command

<source lang="bash">
$ python --version
</source>
If it tells you a version of Python '''greater than or equal to 3.5''' then you're good to go. If not, you need to do a quick package install to get it up and running. Using yum, it's just <code>sudo yum install python35; sudo alternatives --set python /usr/bin/python3</code>.

==== Python 2 vs Python 3 ====

In 2008, a new version of Python – Python 3 – was released, with a number changes that made it incompatible with the previous version, Python 2. For several years, the Python community was slow to make the change to Python 3, but today, Python 3 is ''the'' standard for new code. The ''only'' reason to write Python 2 code today is because you have to work in an environment or with libraries that do not support Python 3, and that situation is becoming increasingly rare.

'''For CSE 330 (and this guide), you ''must'' use Python 3.5 or greater.'''

=== Pip ===

Linux distributions have package managers like ''Apt'', ''Yum'', and ''YaST''. PHP has a package manager named ''PEAR''. It's now time to introduce Python's leading package manager: '''pip'''.

You need to install Pip from Yum before you can use it. The package is called <code>python-pip</code>.

Once you have pip installed, you can use it to install Python packages. Use the <code>pip-python</code> command:

<source lang="bash">
$ pip-python install package_name # RHEL
$ pip install package_name # Debian
</source>
= Running Python =

There are two common ways to run Python code: via the console, and via a Python script file.

=== The Python Console ===

The Python console enables you to experiment with code without opening a text editor. To enter the Python console, simply type the ''python'' command at the terminal:

<source lang="bash">
$ python
</source>
To leave the interactive console, either type <code>quit()</code> or press <code>Ctrl-D</code> (on both Mac and Windows).

=== Python Script Files ===

You can also save Python script files for later use. The extension for Python scripts is <code>*.py</code>. To run a script file, simply feed its path as an argument to the <code>python</code> command in Terminal:

<source lang="bash">
$ python my_script.py
</source>

= Python Syntax and Language Components =

This section contains a very brief overview of Python syntax. For a more comprehensive introduction, see [http://docs.python.org/tutorial/ the Python docs].

=== Python's Type System ===

Python is a dynamically-typed, strongly-typed, and duck-typed language. What does that mean? Well, let's take those categories one by one:

<ol>
<li>
'''Dynamic typing''', in contrast to ''static typing'' means that the types of objects can be changed. In Java, for instance, if you tried to write the following code:

<source lang="java">
int c = 2;
c = "fish";
</source>

Your code would fail to compile, because the Java compiler wouldn't allow you to change the type of the variable <code>c</code> from <code>int</code> to <code>String</code>.

Python, however, is just fine with that. You can write:

<source lang="python">
c = 2
c = "fish"
</source>

And Python will happily do what you ask.
</li>

<li>
'''Strong typing''', in contrast to ''weak typing'', means, roughly, that a language won't implicitly convert types for you. So far, you've used a lot of PHP, which is very weakly typed. For example:

<source lang="php">
echo "10" . 2;
</source>

In PHP, this works just fine. The PHP interpreter sees that <code>2</code> is an int, and silently converts it to a string for you, so that <code>"10". 2</code> equals <code>"102"</code>. The problem with weak typing is that it can make it unclear to the programmer why things are happening the way they are. For instance, in PHP, the expression <code>"10" == 10</code> is true, which can be less than obvious. Python, however, tries to disallow that sort of thing:

<source lang="python">
"10" + "10" # Allowed – concatenates the two strings.
10 + 10 # Allowed – adds the two ints.
"10" + 10 # Not allowed – raises a TypeError
</source>

Perhaps the one exception to this rule is the relationship between numeric types; it's perfectly fine to add a float to an int, for example.
</li>

<li>
'''Duck-typing''' is a little bit different than the other categories, because it doesn't really have a direct opposite. Essentially, duck-typing is the philosophy that "If it walks like a duck, and quacks like a duck, it's a duck." In programming terms, that means that we often don't care what type an object is, as long as it can do the things we ask.

Let's look at an example:

<source lang="python">
# This function doubles the value it's passed.
def double(thing):
return thing + thing
double(10) # Returns 20
double("fish") # Returns "fishfish";
</source>

If this were Java, we'd have to write two different methods here: one for things of type <code>int</code>, and one for things of type <code>String</code>. Since this is Python, though, we don't have to do that. Instead, Python lets us say, essentially: "This function uses the <code>+</code> operator, so you can pass whatever object you want to the function, as long as the function supports the <code>+</code> operator".

To quote [https://groups.google.com/forum/?hl=en#!msg/comp.lang.python/CCs2oJdyuzc/NYjla5HKMOIJ Alex Martelli], one of the key people in the Python project,

<blockquote>
"[Don't] check whether it IS-a duck: check whether it QUACKS-like-a duck, WALKS-like-a duck, etc, etc, depending on exactly what subset of duck-like behaviour you need."
</blockquote>

</li>
</ol>

=== Basic Types ===

In Python, the basic scalar types are:

# <code>str</code> – a string.
# <code>int</code> – an integer object with unlimited digits.
# <code>bool</code> – a Boolean value.
# <code>float</code> – a floating point number; generally equivalent to <code>double</code> in Java.
# <code>bytes</code> – represents a collection of bytes; you're unlikely to use this often.

Casting is done in the C style - to parse an <code>int</code> from a string, for instance, you'd write <code>int("123")</code>.

=== Basic Control Flow ===
In Python, blocks of code are delineated using colons and indentation instead of curly braces. '''''That means that proper indentation is mandatory.''''' Every time you use a colon, you must indent one step further, and every time a block ends, you must unindent a step.

Conditional statements are done using the <code>if</code>, <code>elif</code>, and <code>else</code> operators, like in the example below - pay attention to the indentation:

<source lang="python">
cookies_left = 10
cake_slices_left = 3
if cookies_left > 10:
print("Lots of cookies!")
elif cookies_left > 8:
print("Plenty left!")
elif cookies_left == 5:
print("Halfway done!")
else:
if cake_slices_left == 3:
print("Lots of cake!")
elif cake_slices_left == 2:
print("One slice gone!")
else:
print("Little to no cake left!")
</source>

=== An Example Python Script ===

In my mind, there's no better way to learn Python than to be immersed in a simple example script.

<source lang="python">
print("Hello World")

fruits = ["apple", "banana", "cherry", "date"]
for fruit in fruits:
print(f"I always love to eat a fresh {fruit}")

# Map the fruits list over to a new list containing the length of the fruit strings:
fruit_size = [len(fruit) for fruit in fruits]

avg_fruit_size = sum(fruit_size) / len(fruit_size)
print(f"The average fruit string length is {avg_fruit_size:.2f}.")
</source>

Some things to notice:

* Printing is achieved using the <code>print()</code> function.
* Comments start with a pound symbol <code>#</code>.
* We can transform/map a list to a new list in just one line!

For some more examples, see [https://wiki.python.org/moin/SimplePrograms the Python wiki].

=== A Few Gotchas ===

Here are a few things you may not expect when starting out with Python:

<ol>

<li>
Strings can be delimited using either single quotes (<code>'</code>) or double quotes (<code>"</code>), so <code>'Python'</code> is the same as <code>"Python"</code. You can also use three sets of quotes (<code>'''</code> or <code>"""</code>) to delineate a multiple-line string, like so:
<source lang="python">
long_string = """This
is my
very long
multiple-line
string"""
</source>
</li>

<li>
To compare the equality of two objects, use the <code>==</code> operator. To compare the identity of two objects (i.e. whether or not they are literally the same object, at the same place in memory), use the <code>is</code> operator. These correspond, respectively to <code>.equals()</code> and <code>==</code> in Java.
</li>

<li>
The <code>/</code> operator performs floating-point division, not integer division, even when both its arguments are integers. If you want to do integer division, use the <code>//</code> operator. Let's look at an example:

<source lang="python">
9 / 10 == 0.9 # Floating-point division
9.0 / 10.0 == 0.9 # Floating-point division
9 // 10 == 0 # Integer division
9.0 // 10.0 == 0.0 # Integer division, even though the resulting value is a float
</source>
</li>

<li>
As discussed in the section [[#Python's_Type_System|Python's Type System]], you can't combine strings and numbers using the <code>+</code> operator. Instead, you'll have to use one of the following methods of string formatting:

<source lang="python">

# Technique 1 – printf-style Formatting
# This is a classic style of string formatting, used in many programming languages, including in Java's String.format.
"You scored %d out of %d!" % (score, questions)

# Technique 2 – str.format
"You scored {} out of {}!".format(score, questions)

# Technique 3 – f-strings
# These were only introduced in Python 3.6 but they're very convenient.
f"You scored {score} out of {questions}!"

# Technique 4 - String Concatenation
# This is fine for small things, but for more complicated stuff, use one of the other techniques.
"You scored " + str(score) + " out of " + str(questions) + "!"
</source>
</li>
</ol>

=== Functions ===

Define functions using the <code>def</code> keyword:

<source lang="python">
def hello(name):
print(f"Hello, {name}!")

</source>

Invoke functions using parentheses:
<source lang="python">
hello("Batman")
hello("Superman")
</source>

Functions can have optional arguments; however, these must come after any required arguments:
<source lang="python">
def hello(name="User"):
print(f"Hello, {name}!")

hello() # Prints "Hello, User!"
hello("Sarah") # Prints "Hello, Sarah!"
</source>

Functions are just regular objects in Python, meaning you can do stuff like this:

<source lang="python">
def hello(name="User"):
print(f"Hello, {name}!")

greeting = hello

greeting("Siwei") # Prints "Hello, Siwei!"
</source>

=== Collection Types ===
Python has a few basic, built-in collection types. They each have their own special use cases, but they share a lot of similarities. All built-in data structures in Python are zero-indexed, for instance.

To obtain the number of elements in a collection, use the <code>len()</code> function, like this:

<source lang="python">
pets = ['Dog', 'Cat', 'Fish'] # This is a list; you'll learn about them below.

len(pets) # Returns 3
</source>

To check if a collection contains an item, use the <code>in</code> operator:
<source lang="python">
pets = ['Dog', 'Cat', 'Fish'] # This is a list; you'll learn about them below.

'Dog' in pets # Returns True
</source>

Helpfully, the Python Software Foundation maintains a page containing the asymptotic complexities of important operations on major Python data structures. It's available [https://wiki.python.org/moin/TimeComplexity here].

==== Lists ====

Unlike languages like Java and C, Python's array-like type doesn't have fixed length. Instead, a <code>list</code> is a dynamic array (like Java's <code>ArrayList</code>) of objects of any type. Here's an example:

<source lang="python">
fruits = ["Apple", "Pear", "Orange"] # Lists can be creating by placing their items between square brackets

random_items = ['Apple', 12312, 2.0, [1, 2, 3]] # Lists can contain objects of different types - even other lists!

pets.append('Turtle') # Adds 'Turtle' to the end of pets
</source>

For the next few examples, we'll be using the following list:

<source lang="python">
pets = ['Dog', 'Cat', 'Fish', 'Turtle', 'Lizard', 'Snake']
</source>

To access or assign elements of a list, use the <code>[]</code> operator.

<source lang="python">
pets[0] # Returns 'Dog'
pets[1] = 'Cow' # Sets pets[1] to 'Cow'
pets[1] = 'Cat' # Sets pets[1] back to 'Cat'
</source>

You can also access or assign lists using negative indices, which will return elements starting from the end of the list:

<source lang="python">
pets[-1] # Returns 'Snake'
pets[-2] # Returns 'Lizard'
</source>

You can also use 'slice notation' to obtain or assign subsets of lists:
<source lang="python">
pets[start:end] # Returns items from index start to index end - 1.
pets[start:] # Returns items from index start to the end of the list, inclusive.
pets[:end] # Returns items from the beginning of the list to index end - 1.
pets[:] # Returns every item in the list
</source>

There's also a third, optional argument: <code>step</code>, which lets you jump over values:
<source lang="python">
pets[start:end:step] # Returns items from index start to index end - 1, jumping step values at a time

# Examples:
pets[1:5:2] # Returns items from index 1 to index 4, jumping 2 at a time, so ['Cat', 'Turtle']
pets[::3] # Returns all items in the list, jumping 3 at a time, so ['Dog', 'Turtle']
pets[::-1] # Returns all items in the list, jumping -1 at a time. This reverses the list, so ['Snake', 'Lizard', 'Turtle', 'Fish', 'Cat', 'Dog']
</source>

Lists have all the performance characteristics you'd expect of a dynamic array - constant-time indexing, amortized constant-time appends, and so on.

==== Tuples ====

Python has a special data type called <code>tuple</code>, which is exactly the same as a list except for the fact that it cannot be modified, so you can't append or replace items.

<source lang="python">
cities = ('St. Louis', 'Los Angeles', 'Seattle') # Tuples are defined using parentheses.
numbers = 1, 2, 3 # You can also omit the parentheses if it's unambiguous
single_item_tuple = (1,) # To make a tuple with only one item, put a comma after it
</source>

Tuples also enable you to have multiple return values from a function:

<source lang="python">
def compute_length(string):
str_len = len(string)
if str_len < 5:
return str_len, "short"
elif str_len < 40:
return str_len, "medium"
return str_len, "long"

length, description = compute_length("Four score and seven years ago")
print(f"The {description} string is {length} characters long.")
</source>
The above example also demonstrates Python's if...elif...else conditional structure.

==== Dictionaries ====

Python has another datatype called a '''dictionary''' (or <code>dict</code>, for short), which are like ''Maps'' in Java, ''associative arrays'' in PHP, and ''object literals'' in JavaScript (coming up soon in Module 6). Essentially, they enable you to use any immutable object as the key in your data structure. <code>dict</code> objects can be created using either the <code>dict</code> function, or by placing items between curly braces, separating keys and values using colons:

<source lang="python">
fruits_in_bowl = {
'apple': 4,
'banana': 2,
'cherry': 0,
'date': 12
}

apple_count = fruits_in_bowl['apple'] # Equals 4

fruits_in_bowl['pear'] = 9 # Sets 'pear' in the dictionary to 9.

for fruit, num in fruits_in_bowl.items():
print(f"There are {num} {fruit}(s) in the bowl." % (num, fruit))
</source>
If you only want the keys from a dictionary, you can just iterate over it directly, like this:

<source lang="python">
for fruit in fruits_in_bowl:
print(fruit)
</source>
If you want only the values but not the keys from a dictionary, use <code>my_dictionary.values()</code>.

==== Sets ====
A <code>set</code> is an unordered collection of unique items, with constant-time membership checking.
<source lang="python">
fruits = {'Apple', 'Apple', 'Apple', 'Pear'} # The set removes duplicates, so it will only contain {'Apple', 'Pear'}
fruits = set(['Apple', 'Apple', 'Apple', 'Pear']) # This line transforms a list into a set
print('Apple' in fruits) # Constant-time!
</source>

=== Loops ===

In Python, while loops are written like this:

<source lang="python">
i = 0
while i < 10:
i += 1
</source>
For loops are written like this:

<source lang="python">
pets = ['Dog', 'Cat', 'Fish']

for pet in pets:
print(pet)
</source>
To iterate over a range of numbers, you can use the convenient <code>range</code> function, like so:

<source lang="python">
for i in range(20, 30): # If you omit the first argument to range, it's assumed to be zero.
print(i)
</source>
Note that <code>range</code> provides a closed-open range. That is to say, it is inclusive of its lower bound and exclusive of its upper bound. To be very explicit about it:

<source lang="python">
list(range(3, 6)) == [3, 4, 5]
</source>
Unlike in other languages you may know, the following is not good practice in Python:

<source lang="python">
pets = ['Dog', 'Cat', 'Fish']

# BAD PRACTICE. DO NOT USE.
for i in range(len(pets)):
pet = pets[i]
</source>
Instead, if you need to access both a variable and its index, use the <code>enumerate</code> function, which allows you to iterate through a group of items, along with their indexes, like so:

<source lang="python">
pets = ['Dog', 'Cat', 'Fish']

for index, pet in enumerate(pets):
print(f"{pet} at index {index}")
</source>

=== Generator Expressions and Comprehensions ===

A generator is a special kind of object that, basically, represents a collection of items using a value and a function for generating the next value in the collection. In other words, it's a way of creating something that behaves like a list, but which only generates one value at a time, and discards a value when it's done with it. Say, for example, you wanted to do an operation on 10,000,000,000,000 numbers. You could put them all in a list, then iterate over the list, but that would take a lot of memory, plus you'd have to create and fill the entire list before beginning to actually work on your problem. Instead, you'd probably be better off using a generator; telling the computer, essentially: “The starting value is 0. When I ask for the next number in the collection, add 1 to current value and give me that.”

A generator expression is an expression that is evaluated to create a generator. They're super useful. Generator expressions can take two forms – they can be used with and without a condition:

<source lang="python">
(EXPRESSION for VARIABLE in ITERABLE) # Unconditional
(EXPRESSION for VARIABLE in ITERABLE if CONDITION) # Conditional
</source>
For our purposes, you can think of an iterable as anything you can do a for loop over. Let's take a look at a generator expression in use:

<source lang="python">
double_even_digits = (number * 2 for number in range(10) if number % 2 == 0)
</source>
That line says that <code>double_even_digits</code> is every even number between 0 and 10 multiplied by two. Simple enough, right? If we wanted to use all of the numbers, not just the even ones, we could simply remove the if statement at the end of the expression.

Here's the thing, though: if you were to print <code>double_even_digits</code>, instead of a nice bunch of numbers, you'd get something that looks like this:

<code><generator object <genexpr><code>at 0x107fc92b0></code>

That's because generators are lazy! They don't generate their values until those values are needed, and they discard values once they're no longer needed. As a result, '''you can only iterate over a generator once'''. In this case, you can't print out the whole generator, because it hasn't generated all the values yet. You can, however, iterate over the generator, and print its values one at a time, like so:

<source lang="python">
for number in double_even_digits:
print(number)
</source>
You can also make a list out of the generator, which will go through all the items in the generator and put them in a list, like so:

<source lang="python">
even_number_list = list(double_even_digits)
</source>
That's actually a great segue to the second topic of this section: comprehensions. A comprehension is just a prettier way to make lists, sets, and dicts out of a generator expressions.

<source lang="python">
# If you want a list:
list(i for i in range(10) if i % 2 == 0) # Don't do this
[i for i in range(10) if i % 2 == 0] # Use a list comprehension instead!

# If you want a set:
set(i for i in range(10) if i % 2 == 0) # Don't do this
{i for i in range(10) if i % 2 == 0} # Use a set comprehension instead!

# If you want a dict:
dict((i, i + 1) for i in range(10) if i % 2 == 0) # Don't do this
{i : i + 1 for i in range(10) if i % 2 == 0} # Use a dict comprehension instead!

# If you want a tuple:
tuple(i for i in range(10) if i % 2 == 0) # Unfortunately, there's no better way to do this
</source>
In general, generators and comprehensions should be used whenever possible - they're the fastest and easiest way to build collections. If you ever see yourself writing code like this:

<source lang="python">
# BAD PRACTICE! DO NOT USE!
digits = []
for digit in range(10):
digits.append(digit)
</source>
Don't do it! Instead, use a generator expression or comprehension, as appropriate. A good way to decide whether a generator expression or comprehension is better for this situation is that, if you're just going to be iterating over your collection once, you should use an generator expression. If not, use a comprehension.

=== Sorting ===

Sorting in Python is frequently performed using the <code>sorted</code> function, which takes two arguments: an iterable (anything you can do a for-loop over, including lists and tuples) and a function used to evaluate each item. If the function is omitted, Python will try to sort the lists by value.

The following example demonstrates using an inline function, which Python calls a ''lambda''.

<source lang="python">
fruits = ['apple', 'banana', 'cherry', 'date']

# sort the fruits by string length
new_fruits = sorted(fruits, key=lambda v: len(v) // 2)

print(new_fruits) # ['date', 'apple', 'banana', 'cherry']
</source>
Alternatively, you can sort a <code>list</code> using the <code>.sort</code> method. This is faster than calling <code>sorted</code>, but it modifies the list in-place and returns <code>None</code>.

<source lang="python">
fruits = ['apple', 'banana', 'cherry', 'date']
fruits.sort()
</source>
=== Import ===

If you want to use functions from other libraries (including ones that you install using pip), use <code>import</code>:

<source lang="python">
import time

current_time = time.localtime()
print(time.strftime('%a, %d %b %Y %H:%M:%S', current_time))
</source>
If you want to pull the functions out of their namespace, you can use <code>from ___ import ___</code> syntax:

<source lang="python">
from time import localtime, strftime

current_time = localtime()
print(strftime('%a, %d %b %Y %H:%M:%S', current_time))

# Be aware that this technique, although convenient, may cause unexpected behavior if the function names that you're pulling out of the namespace are already used for other purposes in Python.
</source>
=== File I/O ===

You can read an entire file into a variable like this:

<source lang="python">
f = open("example.txt")
file_contents = f.read()

f.close() # free up memory when we're finished with the file
</source>
A better option is to use a with-block, which handles opening and closing the file for you automatically:

<source lang="python">
with open("example.txt") as f:
file_contents = f.read()
</source>
You can read a file line-by-line like this:

<source lang="python">
with open("example.txt") as f:
for line in f:
print("Read line: %s" % line.rstrip())
</source>
You can write to a file like this:

<source lang="python">
with open("example.txt", "w") as f:
f.write("Hello\nWorld\n")
</source>
=== Command-Line Arguments ===

Command line arguments are accessible in the variable <code>sys.argv</code>.

The following example shows a program that expects a filename as its argument, and it prints a usage message if the argument is not present ([https://stackoverflow.com/questions/983201/python-and-sys-argv source]).

<source lang="python">
import sys, os

if len(sys.argv) < 2:
sys.exit(f"Usage: {sys.argv[0]} filename")

filename = sys.argv[1]

if not os.path.exists(filename):
sys.exit(f"Error: File '{sys.argv[1]}' not found")
</source>

=== Object-Oriented Programming ===

You can define and use a class like this:

<source lang="python">
class Food:
# constructor:
def __init__(self, name):
self.name = name

def format_name(self):
return f"Gotta love to eat {self.name}"

class Fruit(Food):
def format_name(self):
return f"{Food.format_name(self)} (fruit)"

fruit = Fruit("Cherry")
print(fruit.format_name())
print(Food.get_definition())
</source>
This is the same example as in [[PHP#Object-Oriented_Programming|the PHP guide]].

Some things to notice:

* Instance methods ''always'' take <code>self</code> as their first argument, followed by any number of additional parameters. This can be misleading for programmers familiar with other languages, because the number of arguments you feed to the method is actually ''one less than'' the number of declared parameters. Whenever you call a method on a class instance, that instance is implicitly fed into the explicitly-declared <code>self</code> parameter of the method.
*: Note that the <code>self</code> variable has the same purpose as the <code>this</code> variable in languages like PHP, Java, JavaScript, and C++.
*There is no need for a <code>new</code> keyword in Python.

= Footnotes =
# {{note|interpreted}}This is an oversimplification. If you're interested, here's a quick explanation of how: In CPython (the reference implementation of Python) programs are compiled to bytecode, an intermediate representation, which is then interpreted.
[[Category:Module 4]]

Python

2018-02-19T17:31:41Z

Alex: /* Object-Oriented Programming */ Format strings

Languages like Java and C++ have lots of rules regarding variable types, syntax, return values, and so on. These can be cumbersome when you are trying to write short, quick scripts to perform tasks. This is where a ''scripting language'' comes into play.

'''Python''' is a language well-suited to rapid prototype development. It is generally an ''interpreted language'', which means that, generally speaking, a Python program is converted line by line into instructions for the computer to execute as the program runs, instead of having a separate compilation step beforehand {{ref|interpreted}}. The syntax is clean, and it is usually clear at first glance what is going on when you write in Python.

= Installation =

Python may already be installed on your system. To see whether or not it is, enter the command

<source lang="bash">
$ python --version
</source>
If it tells you a version of Python '''greater than or equal to 3.5''' then you're good to go. If not, you need to do a quick package install to get it up and running. Using yum, it's just <code>sudo yum install python35; sudo alternatives --set python /usr/bin/python3</code>.

==== Python 2 vs Python 3 ====

In 2008, a new version of Python – Python 3 – was released, with a number changes that made it incompatible with the previous version, Python 2. For several years, the Python community was slow to make the change to Python 3, but today, Python 3 is ''the'' standard for new code. The ''only'' reason to write Python 2 code today is because you have to work in an environment or with libraries that do not support Python 3, and that situation is becoming increasingly rare.

'''For CSE 330 (and this guide), you ''must'' use Python 3.5 or greater.'''

=== Pip ===

Linux distributions have package managers like ''Apt'', ''Yum'', and ''YaST''. PHP has a package manager named ''PEAR''. It's now time to introduce Python's leading package manager: '''pip'''.

You need to install Pip from Yum before you can use it. The package is called <code>python-pip</code>.

Once you have pip installed, you can use it to install Python packages. Use the <code>pip-python</code> command:

<source lang="bash">
$ pip-python install package_name # RHEL
$ pip install package_name # Debian
</source>
= Running Python =

There are two common ways to run Python code: via the console, and via a Python script file.

=== The Python Console ===

The Python console enables you to experiment with code without opening a text editor. To enter the Python console, simply type the ''python'' command at the terminal:

<source lang="bash">
$ python
</source>
To leave the interactive console, either type <code>quit()</code> or press <code>Ctrl-D</code> (on both Mac and Windows).

=== Python Script Files ===

You can also save Python script files for later use. The extension for Python scripts is <code>*.py</code>. To run a script file, simply feed its path as an argument to the <code>python</code> command in Terminal:

<source lang="bash">
$ python my_script.py
</source>

= Python Syntax and Language Components =

This section contains a very brief overview of Python syntax. For a more comprehensive introduction, see [http://docs.python.org/tutorial/ the Python docs].

=== Python's Type System ===

Python is a dynamically-typed, strongly-typed, and duck-typed language. What does that mean? Well, let's take those categories one by one:

<ol>
<li>
'''Dynamic typing''', in contrast to ''static typing'' means that the types of objects can be changed. In Java, for instance, if you tried to write the following code:

<source lang="java">
int c = 2;
c = "fish";
</source>

Your code would fail to compile, because the Java compiler wouldn't allow you to change the type of the variable <code>c</code> from <code>int</code> to <code>String</code>.

Python, however, is just fine with that. You can write:

<source lang="python">
c = 2
c = "fish"
</source>

And Python will happily do what you ask.
</li>

<li>
'''Strong typing''', in contrast to ''weak typing'', means, roughly, that a language won't implicitly convert types for you. So far, you've used a lot of PHP, which is very weakly typed. For example:

<source lang="php">
echo "10" . 2;
</source>

In PHP, this works just fine. The PHP interpreter sees that <code>2</code> is an int, and silently converts it to a string for you, so that <code>"10". 2</code> equals <code>"102"</code>. The problem with weak typing is that it can make it unclear to the programmer why things are happening the way they are. For instance, in PHP, the expression <code>"10" == 10</code> is true, which can be less than obvious. Python, however, tries to disallow that sort of thing:

<source lang="python">
"10" + "10" # Allowed – concatenates the two strings.
10 + 10 # Allowed – adds the two ints.
"10" + 10 # Not allowed – raises a TypeError
</source>

Perhaps the one exception to this rule is the relationship between numeric types; it's perfectly fine to add a float to an int, for example.
</li>

<li>
'''Duck-typing''' is a little bit different than the other categories, because it doesn't really have a direct opposite. Essentially, duck-typing is the philosophy that "If it walks like a duck, and quacks like a duck, it's a duck." In programming terms, that means that we often don't care what type an object is, as long as it can do the things we ask.

Let's look at an example:

<source lang="python">
# This function doubles the value it's passed.
def double(thing):
return thing + thing
double(10) # Returns 20
double("fish") # Returns "fishfish";
</source>

If this were Java, we'd have to write two different methods here: one for things of type <code>int</code>, and one for things of type <code>String</code>. Since this is Python, though, we don't have to do that. Instead, Python lets us say, essentially: "This function uses the <code>+</code> operator, so you can pass whatever object you want to the function, as long as the function supports the <code>+</code> operator".

To quote [https://groups.google.com/forum/?hl=en#!msg/comp.lang.python/CCs2oJdyuzc/NYjla5HKMOIJ Alex Martelli], one of the key people in the Python project,

<blockquote>
"[Don't] check whether it IS-a duck: check whether it QUACKS-like-a duck, WALKS-like-a duck, etc, etc, depending on exactly what subset of duck-like behaviour you need."
</blockquote>

</li>
</ol>

=== Basic Types ===

In Python, the basic scalar types are:

# <code>str</code> – a string.
# <code>int</code> – an integer object with unlimited digits.
# <code>bool</code> – a Boolean value.
# <code>float</code> – a floating point number; generally equivalent to <code>double</code> in Java.
# <code>bytes</code> – represents a collection of bytes; you're unlikely to use this often.

Casting is done in the C style - to parse an <code>int</code> from a string, for instance, you'd write <code>int("123")</code>.

=== Basic Control Flow ===
In Python, blocks of code are delineated using colons and indentation instead of curly braces. '''''That means that proper indentation is mandatory.''''' Every time you use a colon, you must indent one step further, and every time a block ends, you must unindent a step.

Conditional statements are done using the <code>if</code>, <code>elif</code>, and <code>else</code> operators, like in the example below - pay attention to the indentation:

<source lang="python">
cookies_left = 10
cake_slices_left = 3
if cookies_left > 10:
print("Lots of cookies!")
elif cookies_left > 8:
print("Plenty left!")
elif cookies_left == 5:
print("Halfway done!")
else:
if cake_slices_left == 3:
print("Lots of cake!")
elif cake_slices_left == 2:
print("One slice gone!")
else:
print("Little to no cake left!")
</source>

=== An Example Python Script ===

In my mind, there's no better way to learn Python than to be immersed in a simple example script.

<source lang="python">
print("Hello World")

fruits = ["apple", "banana", "cherry", "date"]
for fruit in fruits:
print(f"I always love to eat a fresh {fruit}")

# Map the fruits list over to a new list containing the length of the fruit strings:
fruit_size = [len(fruit) for fruit in fruits]

avg_fruit_size = sum(fruit_size) / len(fruit_size)
print(f"The average fruit string length is {avg_fruit_size:.2f}.")
</source>

Some things to notice:

* Printing is achieved using the <code>print()</code> function.
* Comments start with a pound symbol <code>#</code>.
* We can transform/map a list to a new list in just one line!

For some more examples, see [https://wiki.python.org/moin/SimplePrograms the Python wiki].

=== A Few Gotchas ===

Here are a few things you may not expect when starting out with Python:

<ol>

<li>
Strings can be delimited using either single quotes (<code>'</code>) or double quotes (<code>"</code>), so <code>'Python'</code> is the same as <code>"Python"</code. You can also use three sets of quotes (<code>'''</code> or <code>"""</code>) to delineate a multiple-line string, like so:
<source lang="python">
long_string = """This
is my
very long
multiple-line
string"""
</source>
</li>

<li>
To compare the equality of two objects, use the <code>==</code> operator. To compare the identity of two objects (i.e. whether or not they are literally the same object, at the same place in memory), use the <code>is</code> operator. These correspond, respectively to <code>.equals()</code> and <code>==</code> in Java.
</li>

<li>
The <code>/</code> operator performs floating-point division, not integer division, even when both its arguments are integers. If you want to do integer division, use the <code>//</code> operator. Let's look at an example:

<source lang="python">
9 / 10 == 0.9 # Floating-point division
9.0 / 10.0 == 0.9 # Floating-point division
9 // 10 == 0 # Integer division
9.0 // 10.0 == 0.0 # Integer division, even though the resulting value is a float
</source>
</li>

<li>
As discussed in the section [[#Python's_Type_System|Python's Type System]], you can't combine strings and numbers using the <code>+</code> operator. Instead, you'll have to use one of the following methods of string formatting:

<source lang="python">

# Technique 1 – printf-style Formatting
# This is a classic style of string formatting, used in many programming languages, including in Java's String.format.
"You scored %d out of %d!" % (score, questions)

# Technique 2 – str.format
"You scored {} out of {}!".format(score, questions)

# Technique 3 – f-strings
# These were only introduced in Python 3.6 but they're very convenient.
f"You scored {score} out of {questions}!"

# Technique 4 - String Concatenation
# This is fine for small things, but for more complicated stuff, use one of the other techniques.
"You scored " + str(score) + " out of " + str(questions) + "!"
</source>
</li>
</ol>

=== Functions ===

Define functions using the <code>def</code> keyword:

<source lang="python">
def hello(name):
print(f"Hello, {name}!")

</source>

Invoke functions using parentheses:
<source lang="python">
hello("Batman")
hello("Superman")
</source>

Functions can have optional arguments; however, these must come after any required arguments:
<source lang="python">
def hello(name="User"):
print(f"Hello, {name}!")

hello() # Prints "Hello, User!"
hello("Sarah") # Prints "Hello, Sarah!"
</source>

Functions are just regular objects in Python, meaning you can do stuff like this:

<source lang="python">
def hello(name="User"):
print(f"Hello, {name}!")

greeting = hello

greeting("Siwei") # Prints "Hello, Siwei!"
</source>

=== Collection Types ===
Python has a few basic, built-in collection types. They each have their own special use cases, but they share a lot of similarities. All built-in data structures in Python are zero-indexed, for instance.

To obtain the number of elements in a collection, use the <code>len()</code> function, like this:

<source lang="python">
pets = ['Dog', 'Cat', 'Fish'] # This is a list; you'll learn about them below.

len(pets) # Returns 3
</source>

To check if a collection contains an item, use the <code>in</code> operator:
<source lang="python">
pets = ['Dog', 'Cat', 'Fish'] # This is a list; you'll learn about them below.

'Dog' in pets # Returns True
</source>

Helpfully, the Python Software Foundation maintains a page containing the asymptotic complexities of important operations on major Python data structures. It's available [https://wiki.python.org/moin/TimeComplexity here].

==== Lists ====

Unlike languages like Java and C, Python's array-like type doesn't have fixed length. Instead, a <code>list</code> is a dynamic array (like Java's <code>ArrayList</code>) of objects of any type. Here's an example:

<source lang="python">
fruits = ["Apple", "Pear", "Orange"] # Lists can be creating by placing their items between square brackets

random_items = ['Apple', 12312, 2.0, [1, 2, 3]] # Lists can contain objects of different types - even other lists!

pets.append('Turtle') # Adds 'Turtle' to the end of pets
</source>

For the next few examples, we'll be using the following list:

<source lang="python">
pets = ['Dog', 'Cat', 'Fish', 'Turtle', 'Lizard', 'Snake']
</source>

To access or assign elements of a list, use the <code>[]</code> operator.

<source lang="python">
pets[0] # Returns 'Dog'
pets[1] = 'Cow' # Sets pets[1] to 'Cow'
pets[1] = 'Cat' # Sets pets[1] back to 'Cat'
</source>

You can also access or assign lists using negative indices, which will return elements starting from the end of the list:

<source lang="python">
pets[-1] # Returns 'Snake'
pets[-2] # Returns 'Lizard'
</source>

You can also use 'slice notation' to obtain or assign subsets of lists:
<source lang="python">
pets[start:end] # Returns items from index start to index end - 1.
pets[start:] # Returns items from index start to the end of the list, inclusive.
pets[:end] # Returns items from the beginning of the list to index end - 1.
pets[:] # Returns every item in the list
</source>

There's also a third, optional argument: <code>step</code>, which lets you jump over values:
<source lang="python">
pets[start:end:step] # Returns items from index start to index end - 1, jumping step values at a time

# Examples:
pets[1:5:2] # Returns items from index 1 to index 4, jumping 2 at a time, so ['Cat', 'Turtle']
pets[::3] # Returns all items in the list, jumping 3 at a time, so ['Dog', 'Turtle']
pets[::-1] # Returns all items in the list, jumping -1 at a time. This reverses the list, so ['Snake', 'Lizard', 'Turtle', 'Fish', 'Cat', 'Dog']
</source>

Lists have all the performance characteristics you'd expect of a dynamic array - constant-time indexing, amortized constant-time appends, and so on.

==== Tuples ====

Python has a special data type called <code>tuple</code>, which is exactly the same as a list except for the fact that it cannot be modified, so you can't append or replace items.

<source lang="python">
cities = ('St. Louis', 'Los Angeles', 'Seattle') # Tuples are defined using parentheses.
numbers = 1, 2, 3 # You can also omit the parentheses if it's unambiguous
single_item_tuple = (1,) # To make a tuple with only one item, put a comma after it
</source>

Tuples also enable you to have multiple return values from a function:

<source lang="python">
def compute_length(string):
str_len = len(string)
if str_len < 5:
return str_len, "short"
elif str_len < 40:
return str_len, "medium"
return str_len, "long"

length, description = compute_length("Four score and seven years ago")
print("The %s string is %d characters long." % (description, length))
</source>
The above example also demonstrates Python's if...elif...else conditional structure.

==== Dictionaries ====

Python has another datatype called a '''dictionary''' (or <code>dict</code>, for short), which are like ''Maps'' in Java, ''associative arrays'' in PHP, and ''object literals'' in JavaScript (coming up soon in Module 6). Essentially, they enable you to use any immutable object as the key in your data structure. <code>dict</code> objects can be created using either the <code>dict</code> function, or by placing items between curly braces, separating keys and values using colons:

<source lang="python">
fruits_in_bowl = {
'apple': 4,
'banana': 2,
'cherry': 0,
'date': 12
}

apple_count = fruits_in_bowl['apple'] # Equals 4

fruits_in_bowl['pear'] = 9 # Sets 'pear' in the dictionary to 9.

for fruit, num in fruits_in_bowl.items():
print(f"There are {num} {fruit}(s) in the bowl." % (num, fruit))
</source>
If you only want the keys from a dictionary, you can just iterate over it directly, like this:

<source lang="python">
for fruit in fruits_in_bowl:
print(fruit)
</source>
If you want only the values but not the keys from a dictionary, use <code>my_dictionary.values()</code>.

==== Sets ====
A <code>set</code> is an unordered collection of unique items, with constant-time membership checking.
<source lang="python">
fruits = {'Apple', 'Apple', 'Apple', 'Pear'} # The set removes duplicates, so it will only contain {'Apple', 'Pear'}
fruits = set(['Apple', 'Apple', 'Apple', 'Pear']) # This line transforms a list into a set
print('Apple' in fruits) # Constant-time!
</source>

=== Loops ===

In Python, while loops are written like this:

<source lang="python">
i = 0
while i < 10:
i += 1
</source>
For loops are written like this:

<source lang="python">
pets = ['Dog', 'Cat', 'Fish']

for pet in pets:
print(pet)
</source>
To iterate over a range of numbers, you can use the convenient <code>range</code> function, like so:

<source lang="python">
for i in range(20, 30): # If you omit the first argument to range, it's assumed to be zero.
print(i)
</source>
Note that <code>range</code> provides a closed-open range. That is to say, it is inclusive of its lower bound and exclusive of its upper bound. To be very explicit about it:

<source lang="python">
list(range(3, 6)) == [3, 4, 5]
</source>
Unlike in other languages you may know, the following is not good practice in Python:

<source lang="python">
pets = ['Dog', 'Cat', 'Fish']

# BAD PRACTICE. DO NOT USE.
for i in range(len(pets)):
pet = pets[i]
</source>
Instead, if you need to access both a variable and its index, use the <code>enumerate</code> function, which allows you to iterate through a group of items, along with their indexes, like so:

<source lang="python">
pets = ['Dog', 'Cat', 'Fish']

for index, pet in enumerate(pets):
print(f"{pet} at index {index}")
</source>

=== Generator Expressions and Comprehensions ===

A generator is a special kind of object that, basically, represents a collection of items using a value and a function for generating the next value in the collection. In other words, it's a way of creating something that behaves like a list, but which only generates one value at a time, and discards a value when it's done with it. Say, for example, you wanted to do an operation on 10,000,000,000,000 numbers. You could put them all in a list, then iterate over the list, but that would take a lot of memory, plus you'd have to create and fill the entire list before beginning to actually work on your problem. Instead, you'd probably be better off using a generator; telling the computer, essentially: “The starting value is 0. When I ask for the next number in the collection, add 1 to current value and give me that.”

A generator expression is an expression that is evaluated to create a generator. They're super useful. Generator expressions can take two forms – they can be used with and without a condition:

<source lang="python">
(EXPRESSION for VARIABLE in ITERABLE) # Unconditional
(EXPRESSION for VARIABLE in ITERABLE if CONDITION) # Conditional
</source>
For our purposes, you can think of an iterable as anything you can do a for loop over. Let's take a look at a generator expression in use:

<source lang="python">
double_even_digits = (number * 2 for number in range(10) if number % 2 == 0)
</source>
That line says that <code>double_even_digits</code> is every even number between 0 and 10 multiplied by two. Simple enough, right? If we wanted to use all of the numbers, not just the even ones, we could simply remove the if statement at the end of the expression.

Here's the thing, though: if you were to print <code>double_even_digits</code>, instead of a nice bunch of numbers, you'd get something that looks like this:

<code><generator object <genexpr><code>at 0x107fc92b0></code>

That's because generators are lazy! They don't generate their values until those values are needed, and they discard values once they're no longer needed. As a result, '''you can only iterate over a generator once'''. In this case, you can't print out the whole generator, because it hasn't generated all the values yet. You can, however, iterate over the generator, and print its values one at a time, like so:

<source lang="python">
for number in double_even_digits:
print(number)
</source>
You can also make a list out of the generator, which will go through all the items in the generator and put them in a list, like so:

<source lang="python">
even_number_list = list(double_even_digits)
</source>
That's actually a great segue to the second topic of this section: comprehensions. A comprehension is just a prettier way to make lists, sets, and dicts out of a generator expressions.

<source lang="python">
# If you want a list:
list(i for i in range(10) if i % 2 == 0) # Don't do this
[i for i in range(10) if i % 2 == 0] # Use a list comprehension instead!

# If you want a set:
set(i for i in range(10) if i % 2 == 0) # Don't do this
{i for i in range(10) if i % 2 == 0} # Use a set comprehension instead!

# If you want a dict:
dict((i, i + 1) for i in range(10) if i % 2 == 0) # Don't do this
{i : i + 1 for i in range(10) if i % 2 == 0} # Use a dict comprehension instead!

# If you want a tuple:
tuple(i for i in range(10) if i % 2 == 0) # Unfortunately, there's no better way to do this
</source>
In general, generators and comprehensions should be used whenever possible - they're the fastest and easiest way to build collections. If you ever see yourself writing code like this:

<source lang="python">
# BAD PRACTICE! DO NOT USE!
digits = []
for digit in range(10):
digits.append(digit)
</source>
Don't do it! Instead, use a generator expression or comprehension, as appropriate. A good way to decide whether a generator expression or comprehension is better for this situation is that, if you're just going to be iterating over your collection once, you should use an generator expression. If not, use a comprehension.

=== Sorting ===

Sorting in Python is frequently performed using the <code>sorted</code> function, which takes two arguments: an iterable (anything you can do a for-loop over, including lists and tuples) and a function used to evaluate each item. If the function is omitted, Python will try to sort the lists by value.

The following example demonstrates using an inline function, which Python calls a ''lambda''.

<source lang="python">
fruits = ['apple', 'banana', 'cherry', 'date']

# sort the fruits by string length
new_fruits = sorted(fruits, key=lambda v: len(v) // 2)

print(new_fruits) # ['date', 'apple', 'banana', 'cherry']
</source>
Alternatively, you can sort a <code>list</code> using the <code>.sort</code> method. This is faster than calling <code>sorted</code>, but it modifies the list in-place and returns <code>None</code>.

<source lang="python">
fruits = ['apple', 'banana', 'cherry', 'date']
fruits.sort()
</source>
=== Import ===

If you want to use functions from other libraries (including ones that you install using pip), use <code>import</code>:

<source lang="python">
import time

current_time = time.localtime()
print(time.strftime('%a, %d %b %Y %H:%M:%S', current_time))
</source>
If you want to pull the functions out of their namespace, you can use <code>from ___ import ___</code> syntax:

<source lang="python">
from time import localtime, strftime

current_time = localtime()
print(strftime('%a, %d %b %Y %H:%M:%S', current_time))

# Be aware that this technique, although convenient, may cause unexpected behavior if the function names that you're pulling out of the namespace are already used for other purposes in Python.
</source>
=== File I/O ===

You can read an entire file into a variable like this:

<source lang="python">
f = open("example.txt")
file_contents = f.read()

f.close() # free up memory when we're finished with the file
</source>
A better option is to use a with-block, which handles opening and closing the file for you automatically:

<source lang="python">
with open("example.txt") as f:
file_contents = f.read()
</source>
You can read a file line-by-line like this:

<source lang="python">
with open("example.txt") as f:
for line in f:
print("Read line: %s" % line.rstrip())
</source>
You can write to a file like this:

<source lang="python">
with open("example.txt", "w") as f:
f.write("Hello\nWorld\n")
</source>
=== Command-Line Arguments ===

Command line arguments are accessible in the variable <code>sys.argv</code>.

The following example shows a program that expects a filename as its argument, and it prints a usage message if the argument is not present ([https://stackoverflow.com/questions/983201/python-and-sys-argv source]).

<source lang="python">
import sys, os

if len(sys.argv) < 2:
sys.exit(f"Usage: {sys.argv[0]} filename")

filename = sys.argv[1]

if not os.path.exists(filename):
sys.exit(f"Error: File '{sys.argv[1]}' not found")
</source>

=== Object-Oriented Programming ===

You can define and use a class like this:

<source lang="python">
class Food:
# constructor:
def __init__(self, name):
self.name = name

def format_name(self):
return f"Gotta love to eat {self.name}"

class Fruit(Food):
def format_name(self):
return f"{Food.format_name(self)} (fruit)"

fruit = Fruit("Cherry")
print(fruit.format_name())
print(Food.get_definition())
</source>
This is the same example as in [[PHP#Object-Oriented_Programming|the PHP guide]].

Some things to notice:

* Instance methods ''always'' take <code>self</code> as their first argument, followed by any number of additional parameters. This can be misleading for programmers familiar with other languages, because the number of arguments you feed to the method is actually ''one less than'' the number of declared parameters. Whenever you call a method on a class instance, that instance is implicitly fed into the explicitly-declared <code>self</code> parameter of the method.
*: Note that the <code>self</code> variable has the same purpose as the <code>this</code> variable in languages like PHP, Java, JavaScript, and C++.
*There is no need for a <code>new</code> keyword in Python.

= Footnotes =
# {{note|interpreted}}This is an oversimplification. If you're interested, here's a quick explanation of how: In CPython (the reference implementation of Python) programs are compiled to bytecode, an intermediate representation, which is then interpreted.
[[Category:Module 4]]

Python

2018-02-19T17:30:59Z

Alex: /* Command-Line Arguments */ Format strings

Languages like Java and C++ have lots of rules regarding variable types, syntax, return values, and so on. These can be cumbersome when you are trying to write short, quick scripts to perform tasks. This is where a ''scripting language'' comes into play.

'''Python''' is a language well-suited to rapid prototype development. It is generally an ''interpreted language'', which means that, generally speaking, a Python program is converted line by line into instructions for the computer to execute as the program runs, instead of having a separate compilation step beforehand {{ref|interpreted}}. The syntax is clean, and it is usually clear at first glance what is going on when you write in Python.

= Installation =

Python may already be installed on your system. To see whether or not it is, enter the command

<source lang="bash">
$ python --version
</source>
If it tells you a version of Python '''greater than or equal to 3.5''' then you're good to go. If not, you need to do a quick package install to get it up and running. Using yum, it's just <code>sudo yum install python35; sudo alternatives --set python /usr/bin/python3</code>.

==== Python 2 vs Python 3 ====

In 2008, a new version of Python – Python 3 – was released, with a number changes that made it incompatible with the previous version, Python 2. For several years, the Python community was slow to make the change to Python 3, but today, Python 3 is ''the'' standard for new code. The ''only'' reason to write Python 2 code today is because you have to work in an environment or with libraries that do not support Python 3, and that situation is becoming increasingly rare.

'''For CSE 330 (and this guide), you ''must'' use Python 3.5 or greater.'''

=== Pip ===

Linux distributions have package managers like ''Apt'', ''Yum'', and ''YaST''. PHP has a package manager named ''PEAR''. It's now time to introduce Python's leading package manager: '''pip'''.

You need to install Pip from Yum before you can use it. The package is called <code>python-pip</code>.

Once you have pip installed, you can use it to install Python packages. Use the <code>pip-python</code> command:

<source lang="bash">
$ pip-python install package_name # RHEL
$ pip install package_name # Debian
</source>
= Running Python =

There are two common ways to run Python code: via the console, and via a Python script file.

=== The Python Console ===

The Python console enables you to experiment with code without opening a text editor. To enter the Python console, simply type the ''python'' command at the terminal:

<source lang="bash">
$ python
</source>
To leave the interactive console, either type <code>quit()</code> or press <code>Ctrl-D</code> (on both Mac and Windows).

=== Python Script Files ===

You can also save Python script files for later use. The extension for Python scripts is <code>*.py</code>. To run a script file, simply feed its path as an argument to the <code>python</code> command in Terminal:

<source lang="bash">
$ python my_script.py
</source>

= Python Syntax and Language Components =

This section contains a very brief overview of Python syntax. For a more comprehensive introduction, see [http://docs.python.org/tutorial/ the Python docs].

=== Python's Type System ===

Python is a dynamically-typed, strongly-typed, and duck-typed language. What does that mean? Well, let's take those categories one by one:

<ol>
<li>
'''Dynamic typing''', in contrast to ''static typing'' means that the types of objects can be changed. In Java, for instance, if you tried to write the following code:

<source lang="java">
int c = 2;
c = "fish";
</source>

Your code would fail to compile, because the Java compiler wouldn't allow you to change the type of the variable <code>c</code> from <code>int</code> to <code>String</code>.

Python, however, is just fine with that. You can write:

<source lang="python">
c = 2
c = "fish"
</source>

And Python will happily do what you ask.
</li>

<li>
'''Strong typing''', in contrast to ''weak typing'', means, roughly, that a language won't implicitly convert types for you. So far, you've used a lot of PHP, which is very weakly typed. For example:

<source lang="php">
echo "10" . 2;
</source>

In PHP, this works just fine. The PHP interpreter sees that <code>2</code> is an int, and silently converts it to a string for you, so that <code>"10". 2</code> equals <code>"102"</code>. The problem with weak typing is that it can make it unclear to the programmer why things are happening the way they are. For instance, in PHP, the expression <code>"10" == 10</code> is true, which can be less than obvious. Python, however, tries to disallow that sort of thing:

<source lang="python">
"10" + "10" # Allowed – concatenates the two strings.
10 + 10 # Allowed – adds the two ints.
"10" + 10 # Not allowed – raises a TypeError
</source>

Perhaps the one exception to this rule is the relationship between numeric types; it's perfectly fine to add a float to an int, for example.
</li>

<li>
'''Duck-typing''' is a little bit different than the other categories, because it doesn't really have a direct opposite. Essentially, duck-typing is the philosophy that "If it walks like a duck, and quacks like a duck, it's a duck." In programming terms, that means that we often don't care what type an object is, as long as it can do the things we ask.

Let's look at an example:

<source lang="python">
# This function doubles the value it's passed.
def double(thing):
return thing + thing
double(10) # Returns 20
double("fish") # Returns "fishfish";
</source>

If this were Java, we'd have to write two different methods here: one for things of type <code>int</code>, and one for things of type <code>String</code>. Since this is Python, though, we don't have to do that. Instead, Python lets us say, essentially: "This function uses the <code>+</code> operator, so you can pass whatever object you want to the function, as long as the function supports the <code>+</code> operator".

To quote [https://groups.google.com/forum/?hl=en#!msg/comp.lang.python/CCs2oJdyuzc/NYjla5HKMOIJ Alex Martelli], one of the key people in the Python project,

<blockquote>
"[Don't] check whether it IS-a duck: check whether it QUACKS-like-a duck, WALKS-like-a duck, etc, etc, depending on exactly what subset of duck-like behaviour you need."
</blockquote>

</li>
</ol>

=== Basic Types ===

In Python, the basic scalar types are:

# <code>str</code> – a string.
# <code>int</code> – an integer object with unlimited digits.
# <code>bool</code> – a Boolean value.
# <code>float</code> – a floating point number; generally equivalent to <code>double</code> in Java.
# <code>bytes</code> – represents a collection of bytes; you're unlikely to use this often.

Casting is done in the C style - to parse an <code>int</code> from a string, for instance, you'd write <code>int("123")</code>.

=== Basic Control Flow ===
In Python, blocks of code are delineated using colons and indentation instead of curly braces. '''''That means that proper indentation is mandatory.''''' Every time you use a colon, you must indent one step further, and every time a block ends, you must unindent a step.

Conditional statements are done using the <code>if</code>, <code>elif</code>, and <code>else</code> operators, like in the example below - pay attention to the indentation:

<source lang="python">
cookies_left = 10
cake_slices_left = 3
if cookies_left > 10:
print("Lots of cookies!")
elif cookies_left > 8:
print("Plenty left!")
elif cookies_left == 5:
print("Halfway done!")
else:
if cake_slices_left == 3:
print("Lots of cake!")
elif cake_slices_left == 2:
print("One slice gone!")
else:
print("Little to no cake left!")
</source>

=== An Example Python Script ===

In my mind, there's no better way to learn Python than to be immersed in a simple example script.

<source lang="python">
print("Hello World")

fruits = ["apple", "banana", "cherry", "date"]
for fruit in fruits:
print(f"I always love to eat a fresh {fruit}")

# Map the fruits list over to a new list containing the length of the fruit strings:
fruit_size = [len(fruit) for fruit in fruits]

avg_fruit_size = sum(fruit_size) / len(fruit_size)
print(f"The average fruit string length is {avg_fruit_size:.2f}.")
</source>

Some things to notice:

* Printing is achieved using the <code>print()</code> function.
* Comments start with a pound symbol <code>#</code>.
* We can transform/map a list to a new list in just one line!

For some more examples, see [https://wiki.python.org/moin/SimplePrograms the Python wiki].

=== A Few Gotchas ===

Here are a few things you may not expect when starting out with Python:

<ol>

<li>
Strings can be delimited using either single quotes (<code>'</code>) or double quotes (<code>"</code>), so <code>'Python'</code> is the same as <code>"Python"</code. You can also use three sets of quotes (<code>'''</code> or <code>"""</code>) to delineate a multiple-line string, like so:
<source lang="python">
long_string = """This
is my
very long
multiple-line
string"""
</source>
</li>

<li>
To compare the equality of two objects, use the <code>==</code> operator. To compare the identity of two objects (i.e. whether or not they are literally the same object, at the same place in memory), use the <code>is</code> operator. These correspond, respectively to <code>.equals()</code> and <code>==</code> in Java.
</li>

<li>
The <code>/</code> operator performs floating-point division, not integer division, even when both its arguments are integers. If you want to do integer division, use the <code>//</code> operator. Let's look at an example:

<source lang="python">
9 / 10 == 0.9 # Floating-point division
9.0 / 10.0 == 0.9 # Floating-point division
9 // 10 == 0 # Integer division
9.0 // 10.0 == 0.0 # Integer division, even though the resulting value is a float
</source>
</li>

<li>
As discussed in the section [[#Python's_Type_System|Python's Type System]], you can't combine strings and numbers using the <code>+</code> operator. Instead, you'll have to use one of the following methods of string formatting:

<source lang="python">

# Technique 1 – printf-style Formatting
# This is a classic style of string formatting, used in many programming languages, including in Java's String.format.
"You scored %d out of %d!" % (score, questions)

# Technique 2 – str.format
"You scored {} out of {}!".format(score, questions)

# Technique 3 – f-strings
# These were only introduced in Python 3.6 but they're very convenient.
f"You scored {score} out of {questions}!"

# Technique 4 - String Concatenation
# This is fine for small things, but for more complicated stuff, use one of the other techniques.
"You scored " + str(score) + " out of " + str(questions) + "!"
</source>
</li>
</ol>

=== Functions ===

Define functions using the <code>def</code> keyword:

<source lang="python">
def hello(name):
print(f"Hello, {name}!")

</source>

Invoke functions using parentheses:
<source lang="python">
hello("Batman")
hello("Superman")
</source>

Functions can have optional arguments; however, these must come after any required arguments:
<source lang="python">
def hello(name="User"):
print(f"Hello, {name}!")

hello() # Prints "Hello, User!"
hello("Sarah") # Prints "Hello, Sarah!"
</source>

Functions are just regular objects in Python, meaning you can do stuff like this:

<source lang="python">
def hello(name="User"):
print(f"Hello, {name}!")

greeting = hello

greeting("Siwei") # Prints "Hello, Siwei!"
</source>

=== Collection Types ===
Python has a few basic, built-in collection types. They each have their own special use cases, but they share a lot of similarities. All built-in data structures in Python are zero-indexed, for instance.

To obtain the number of elements in a collection, use the <code>len()</code> function, like this:

<source lang="python">
pets = ['Dog', 'Cat', 'Fish'] # This is a list; you'll learn about them below.

len(pets) # Returns 3
</source>

To check if a collection contains an item, use the <code>in</code> operator:
<source lang="python">
pets = ['Dog', 'Cat', 'Fish'] # This is a list; you'll learn about them below.

'Dog' in pets # Returns True
</source>

Helpfully, the Python Software Foundation maintains a page containing the asymptotic complexities of important operations on major Python data structures. It's available [https://wiki.python.org/moin/TimeComplexity here].

==== Lists ====

Unlike languages like Java and C, Python's array-like type doesn't have fixed length. Instead, a <code>list</code> is a dynamic array (like Java's <code>ArrayList</code>) of objects of any type. Here's an example:

<source lang="python">
fruits = ["Apple", "Pear", "Orange"] # Lists can be creating by placing their items between square brackets

random_items = ['Apple', 12312, 2.0, [1, 2, 3]] # Lists can contain objects of different types - even other lists!

pets.append('Turtle') # Adds 'Turtle' to the end of pets
</source>

For the next few examples, we'll be using the following list:

<source lang="python">
pets = ['Dog', 'Cat', 'Fish', 'Turtle', 'Lizard', 'Snake']
</source>

To access or assign elements of a list, use the <code>[]</code> operator.

<source lang="python">
pets[0] # Returns 'Dog'
pets[1] = 'Cow' # Sets pets[1] to 'Cow'
pets[1] = 'Cat' # Sets pets[1] back to 'Cat'
</source>

You can also access or assign lists using negative indices, which will return elements starting from the end of the list:

<source lang="python">
pets[-1] # Returns 'Snake'
pets[-2] # Returns 'Lizard'
</source>

You can also use 'slice notation' to obtain or assign subsets of lists:
<source lang="python">
pets[start:end] # Returns items from index start to index end - 1.
pets[start:] # Returns items from index start to the end of the list, inclusive.
pets[:end] # Returns items from the beginning of the list to index end - 1.
pets[:] # Returns every item in the list
</source>

There's also a third, optional argument: <code>step</code>, which lets you jump over values:
<source lang="python">
pets[start:end:step] # Returns items from index start to index end - 1, jumping step values at a time

# Examples:
pets[1:5:2] # Returns items from index 1 to index 4, jumping 2 at a time, so ['Cat', 'Turtle']
pets[::3] # Returns all items in the list, jumping 3 at a time, so ['Dog', 'Turtle']
pets[::-1] # Returns all items in the list, jumping -1 at a time. This reverses the list, so ['Snake', 'Lizard', 'Turtle', 'Fish', 'Cat', 'Dog']
</source>

Lists have all the performance characteristics you'd expect of a dynamic array - constant-time indexing, amortized constant-time appends, and so on.

==== Tuples ====

Python has a special data type called <code>tuple</code>, which is exactly the same as a list except for the fact that it cannot be modified, so you can't append or replace items.

<source lang="python">
cities = ('St. Louis', 'Los Angeles', 'Seattle') # Tuples are defined using parentheses.
numbers = 1, 2, 3 # You can also omit the parentheses if it's unambiguous
single_item_tuple = (1,) # To make a tuple with only one item, put a comma after it
</source>

Tuples also enable you to have multiple return values from a function:

<source lang="python">
def compute_length(string):
str_len = len(string)
if str_len < 5:
return str_len, "short"
elif str_len < 40:
return str_len, "medium"
return str_len, "long"

length, description = compute_length("Four score and seven years ago")
print("The %s string is %d characters long." % (description, length))
</source>
The above example also demonstrates Python's if...elif...else conditional structure.

==== Dictionaries ====

Python has another datatype called a '''dictionary''' (or <code>dict</code>, for short), which are like ''Maps'' in Java, ''associative arrays'' in PHP, and ''object literals'' in JavaScript (coming up soon in Module 6). Essentially, they enable you to use any immutable object as the key in your data structure. <code>dict</code> objects can be created using either the <code>dict</code> function, or by placing items between curly braces, separating keys and values using colons:

<source lang="python">
fruits_in_bowl = {
'apple': 4,
'banana': 2,
'cherry': 0,
'date': 12
}

apple_count = fruits_in_bowl['apple'] # Equals 4

fruits_in_bowl['pear'] = 9 # Sets 'pear' in the dictionary to 9.

for fruit, num in fruits_in_bowl.items():
print(f"There are {num} {fruit}(s) in the bowl." % (num, fruit))
</source>
If you only want the keys from a dictionary, you can just iterate over it directly, like this:

<source lang="python">
for fruit in fruits_in_bowl:
print(fruit)
</source>
If you want only the values but not the keys from a dictionary, use <code>my_dictionary.values()</code>.

==== Sets ====
A <code>set</code> is an unordered collection of unique items, with constant-time membership checking.
<source lang="python">
fruits = {'Apple', 'Apple', 'Apple', 'Pear'} # The set removes duplicates, so it will only contain {'Apple', 'Pear'}
fruits = set(['Apple', 'Apple', 'Apple', 'Pear']) # This line transforms a list into a set
print('Apple' in fruits) # Constant-time!
</source>

=== Loops ===

In Python, while loops are written like this:

<source lang="python">
i = 0
while i < 10:
i += 1
</source>
For loops are written like this:

<source lang="python">
pets = ['Dog', 'Cat', 'Fish']

for pet in pets:
print(pet)
</source>
To iterate over a range of numbers, you can use the convenient <code>range</code> function, like so:

<source lang="python">
for i in range(20, 30): # If you omit the first argument to range, it's assumed to be zero.
print(i)
</source>
Note that <code>range</code> provides a closed-open range. That is to say, it is inclusive of its lower bound and exclusive of its upper bound. To be very explicit about it:

<source lang="python">
list(range(3, 6)) == [3, 4, 5]
</source>
Unlike in other languages you may know, the following is not good practice in Python:

<source lang="python">
pets = ['Dog', 'Cat', 'Fish']

# BAD PRACTICE. DO NOT USE.
for i in range(len(pets)):
pet = pets[i]
</source>
Instead, if you need to access both a variable and its index, use the <code>enumerate</code> function, which allows you to iterate through a group of items, along with their indexes, like so:

<source lang="python">
pets = ['Dog', 'Cat', 'Fish']

for index, pet in enumerate(pets):
print(f"{pet} at index {index}")
</source>

=== Generator Expressions and Comprehensions ===

A generator is a special kind of object that, basically, represents a collection of items using a value and a function for generating the next value in the collection. In other words, it's a way of creating something that behaves like a list, but which only generates one value at a time, and discards a value when it's done with it. Say, for example, you wanted to do an operation on 10,000,000,000,000 numbers. You could put them all in a list, then iterate over the list, but that would take a lot of memory, plus you'd have to create and fill the entire list before beginning to actually work on your problem. Instead, you'd probably be better off using a generator; telling the computer, essentially: “The starting value is 0. When I ask for the next number in the collection, add 1 to current value and give me that.”

A generator expression is an expression that is evaluated to create a generator. They're super useful. Generator expressions can take two forms – they can be used with and without a condition:

<source lang="python">
(EXPRESSION for VARIABLE in ITERABLE) # Unconditional
(EXPRESSION for VARIABLE in ITERABLE if CONDITION) # Conditional
</source>
For our purposes, you can think of an iterable as anything you can do a for loop over. Let's take a look at a generator expression in use:

<source lang="python">
double_even_digits = (number * 2 for number in range(10) if number % 2 == 0)
</source>
That line says that <code>double_even_digits</code> is every even number between 0 and 10 multiplied by two. Simple enough, right? If we wanted to use all of the numbers, not just the even ones, we could simply remove the if statement at the end of the expression.

Here's the thing, though: if you were to print <code>double_even_digits</code>, instead of a nice bunch of numbers, you'd get something that looks like this:

<code><generator object <genexpr><code>at 0x107fc92b0></code>

That's because generators are lazy! They don't generate their values until those values are needed, and they discard values once they're no longer needed. As a result, '''you can only iterate over a generator once'''. In this case, you can't print out the whole generator, because it hasn't generated all the values yet. You can, however, iterate over the generator, and print its values one at a time, like so:

<source lang="python">
for number in double_even_digits:
print(number)
</source>
You can also make a list out of the generator, which will go through all the items in the generator and put them in a list, like so:

<source lang="python">
even_number_list = list(double_even_digits)
</source>
That's actually a great segue to the second topic of this section: comprehensions. A comprehension is just a prettier way to make lists, sets, and dicts out of a generator expressions.

<source lang="python">
# If you want a list:
list(i for i in range(10) if i % 2 == 0) # Don't do this
[i for i in range(10) if i % 2 == 0] # Use a list comprehension instead!

# If you want a set:
set(i for i in range(10) if i % 2 == 0) # Don't do this
{i for i in range(10) if i % 2 == 0} # Use a set comprehension instead!

# If you want a dict:
dict((i, i + 1) for i in range(10) if i % 2 == 0) # Don't do this
{i : i + 1 for i in range(10) if i % 2 == 0} # Use a dict comprehension instead!

# If you want a tuple:
tuple(i for i in range(10) if i % 2 == 0) # Unfortunately, there's no better way to do this
</source>
In general, generators and comprehensions should be used whenever possible - they're the fastest and easiest way to build collections. If you ever see yourself writing code like this:

<source lang="python">
# BAD PRACTICE! DO NOT USE!
digits = []
for digit in range(10):
digits.append(digit)
</source>
Don't do it! Instead, use a generator expression or comprehension, as appropriate. A good way to decide whether a generator expression or comprehension is better for this situation is that, if you're just going to be iterating over your collection once, you should use an generator expression. If not, use a comprehension.

=== Sorting ===

Sorting in Python is frequently performed using the <code>sorted</code> function, which takes two arguments: an iterable (anything you can do a for-loop over, including lists and tuples) and a function used to evaluate each item. If the function is omitted, Python will try to sort the lists by value.

The following example demonstrates using an inline function, which Python calls a ''lambda''.

<source lang="python">
fruits = ['apple', 'banana', 'cherry', 'date']

# sort the fruits by string length
new_fruits = sorted(fruits, key=lambda v: len(v) // 2)

print(new_fruits) # ['date', 'apple', 'banana', 'cherry']
</source>
Alternatively, you can sort a <code>list</code> using the <code>.sort</code> method. This is faster than calling <code>sorted</code>, but it modifies the list in-place and returns <code>None</code>.

<source lang="python">
fruits = ['apple', 'banana', 'cherry', 'date']
fruits.sort()
</source>
=== Import ===

If you want to use functions from other libraries (including ones that you install using pip), use <code>import</code>:

<source lang="python">
import time

current_time = time.localtime()
print(time.strftime('%a, %d %b %Y %H:%M:%S', current_time))
</source>
If you want to pull the functions out of their namespace, you can use <code>from ___ import ___</code> syntax:

<source lang="python">
from time import localtime, strftime

current_time = localtime()
print(strftime('%a, %d %b %Y %H:%M:%S', current_time))

# Be aware that this technique, although convenient, may cause unexpected behavior if the function names that you're pulling out of the namespace are already used for other purposes in Python.
</source>
=== File I/O ===

You can read an entire file into a variable like this:

<source lang="python">
f = open("example.txt")
file_contents = f.read()

f.close() # free up memory when we're finished with the file
</source>
A better option is to use a with-block, which handles opening and closing the file for you automatically:

<source lang="python">
with open("example.txt") as f:
file_contents = f.read()
</source>
You can read a file line-by-line like this:

<source lang="python">
with open("example.txt") as f:
for line in f:
print("Read line: %s" % line.rstrip())
</source>
You can write to a file like this:

<source lang="python">
with open("example.txt", "w") as f:
f.write("Hello\nWorld\n")
</source>
=== Command-Line Arguments ===

Command line arguments are accessible in the variable <code>sys.argv</code>.

The following example shows a program that expects a filename as its argument, and it prints a usage message if the argument is not present ([https://stackoverflow.com/questions/983201/python-and-sys-argv source]).

<source lang="python">
import sys, os

if len(sys.argv) < 2:
sys.exit(f"Usage: {sys.argv[0]} filename")

filename = sys.argv[1]

if not os.path.exists(filename):
sys.exit(f"Error: File '{sys.argv[1]}' not found")
</source>

=== Object-Oriented Programming ===

You can define and use a class like this:

<source lang="python">
class Food:
# constructor:
def __init__(self, name):
self.name = name

def format_name(self):
return "Gotta love to eat " + self.name

class Fruit(Food):
def format_name(self):
return Food.format_name(self) + " (fruit)"

fruit = Fruit("Cherry")
print(fruit.format_name())
print(Food.get_definition())
</source>
This is the same example as in [[PHP#Object-Oriented_Programming|the PHP guide]].

Some things to notice:

* Instance methods ''always'' take <code>self</code> as their first argument, followed by any number of additional parameters. This can be misleading for programmers familiar with other languages, because the number of arguments you feed to the method is actually ''one less than'' the number of declared parameters. Whenever you call a method on a class instance, that instance is implicitly fed into the explicitly-declared <code>self</code> parameter of the method.
*: Note that the <code>self</code> variable has the same purpose as the <code>this</code> variable in languages like PHP, Java, JavaScript, and C++.
*There is no need for a <code>new</code> keyword in Python.

= Footnotes =
# {{note|interpreted}}This is an oversimplification. If you're interested, here's a quick explanation of how: In CPython (the reference implementation of Python) programs are compiled to bytecode, an intermediate representation, which is then interpreted.
[[Category:Module 4]]

Python

2018-02-19T17:29:36Z

Alex: /* Loops */ Format strings

Languages like Java and C++ have lots of rules regarding variable types, syntax, return values, and so on. These can be cumbersome when you are trying to write short, quick scripts to perform tasks. This is where a ''scripting language'' comes into play.

'''Python''' is a language well-suited to rapid prototype development. It is generally an ''interpreted language'', which means that, generally speaking, a Python program is converted line by line into instructions for the computer to execute as the program runs, instead of having a separate compilation step beforehand {{ref|interpreted}}. The syntax is clean, and it is usually clear at first glance what is going on when you write in Python.

= Installation =

Python may already be installed on your system. To see whether or not it is, enter the command

<source lang="bash">
$ python --version
</source>
If it tells you a version of Python '''greater than or equal to 3.5''' then you're good to go. If not, you need to do a quick package install to get it up and running. Using yum, it's just <code>sudo yum install python35; sudo alternatives --set python /usr/bin/python3</code>.

==== Python 2 vs Python 3 ====

In 2008, a new version of Python – Python 3 – was released, with a number changes that made it incompatible with the previous version, Python 2. For several years, the Python community was slow to make the change to Python 3, but today, Python 3 is ''the'' standard for new code. The ''only'' reason to write Python 2 code today is because you have to work in an environment or with libraries that do not support Python 3, and that situation is becoming increasingly rare.

'''For CSE 330 (and this guide), you ''must'' use Python 3.5 or greater.'''

=== Pip ===

Linux distributions have package managers like ''Apt'', ''Yum'', and ''YaST''. PHP has a package manager named ''PEAR''. It's now time to introduce Python's leading package manager: '''pip'''.

You need to install Pip from Yum before you can use it. The package is called <code>python-pip</code>.

Once you have pip installed, you can use it to install Python packages. Use the <code>pip-python</code> command:

<source lang="bash">
$ pip-python install package_name # RHEL
$ pip install package_name # Debian
</source>
= Running Python =

There are two common ways to run Python code: via the console, and via a Python script file.

=== The Python Console ===

The Python console enables you to experiment with code without opening a text editor. To enter the Python console, simply type the ''python'' command at the terminal:

<source lang="bash">
$ python
</source>
To leave the interactive console, either type <code>quit()</code> or press <code>Ctrl-D</code> (on both Mac and Windows).

=== Python Script Files ===

You can also save Python script files for later use. The extension for Python scripts is <code>*.py</code>. To run a script file, simply feed its path as an argument to the <code>python</code> command in Terminal:

<source lang="bash">
$ python my_script.py
</source>

= Python Syntax and Language Components =

This section contains a very brief overview of Python syntax. For a more comprehensive introduction, see [http://docs.python.org/tutorial/ the Python docs].

=== Python's Type System ===

Python is a dynamically-typed, strongly-typed, and duck-typed language. What does that mean? Well, let's take those categories one by one:

<ol>
<li>
'''Dynamic typing''', in contrast to ''static typing'' means that the types of objects can be changed. In Java, for instance, if you tried to write the following code:

<source lang="java">
int c = 2;
c = "fish";
</source>

Your code would fail to compile, because the Java compiler wouldn't allow you to change the type of the variable <code>c</code> from <code>int</code> to <code>String</code>.

Python, however, is just fine with that. You can write:

<source lang="python">
c = 2
c = "fish"
</source>

And Python will happily do what you ask.
</li>

<li>
'''Strong typing''', in contrast to ''weak typing'', means, roughly, that a language won't implicitly convert types for you. So far, you've used a lot of PHP, which is very weakly typed. For example:

<source lang="php">
echo "10" . 2;
</source>

In PHP, this works just fine. The PHP interpreter sees that <code>2</code> is an int, and silently converts it to a string for you, so that <code>"10". 2</code> equals <code>"102"</code>. The problem with weak typing is that it can make it unclear to the programmer why things are happening the way they are. For instance, in PHP, the expression <code>"10" == 10</code> is true, which can be less than obvious. Python, however, tries to disallow that sort of thing:

<source lang="python">
"10" + "10" # Allowed – concatenates the two strings.
10 + 10 # Allowed – adds the two ints.
"10" + 10 # Not allowed – raises a TypeError
</source>

Perhaps the one exception to this rule is the relationship between numeric types; it's perfectly fine to add a float to an int, for example.
</li>

<li>
'''Duck-typing''' is a little bit different than the other categories, because it doesn't really have a direct opposite. Essentially, duck-typing is the philosophy that "If it walks like a duck, and quacks like a duck, it's a duck." In programming terms, that means that we often don't care what type an object is, as long as it can do the things we ask.

Let's look at an example:

<source lang="python">
# This function doubles the value it's passed.
def double(thing):
return thing + thing
double(10) # Returns 20
double("fish") # Returns "fishfish";
</source>

If this were Java, we'd have to write two different methods here: one for things of type <code>int</code>, and one for things of type <code>String</code>. Since this is Python, though, we don't have to do that. Instead, Python lets us say, essentially: "This function uses the <code>+</code> operator, so you can pass whatever object you want to the function, as long as the function supports the <code>+</code> operator".

To quote [https://groups.google.com/forum/?hl=en#!msg/comp.lang.python/CCs2oJdyuzc/NYjla5HKMOIJ Alex Martelli], one of the key people in the Python project,

<blockquote>
"[Don't] check whether it IS-a duck: check whether it QUACKS-like-a duck, WALKS-like-a duck, etc, etc, depending on exactly what subset of duck-like behaviour you need."
</blockquote>

</li>
</ol>

=== Basic Types ===

In Python, the basic scalar types are:

# <code>str</code> – a string.
# <code>int</code> – an integer object with unlimited digits.
# <code>bool</code> – a Boolean value.
# <code>float</code> – a floating point number; generally equivalent to <code>double</code> in Java.
# <code>bytes</code> – represents a collection of bytes; you're unlikely to use this often.

Casting is done in the C style - to parse an <code>int</code> from a string, for instance, you'd write <code>int("123")</code>.

=== Basic Control Flow ===
In Python, blocks of code are delineated using colons and indentation instead of curly braces. '''''That means that proper indentation is mandatory.''''' Every time you use a colon, you must indent one step further, and every time a block ends, you must unindent a step.

Conditional statements are done using the <code>if</code>, <code>elif</code>, and <code>else</code> operators, like in the example below - pay attention to the indentation:

<source lang="python">
cookies_left = 10
cake_slices_left = 3
if cookies_left > 10:
print("Lots of cookies!")
elif cookies_left > 8:
print("Plenty left!")
elif cookies_left == 5:
print("Halfway done!")
else:
if cake_slices_left == 3:
print("Lots of cake!")
elif cake_slices_left == 2:
print("One slice gone!")
else:
print("Little to no cake left!")
</source>

=== An Example Python Script ===

In my mind, there's no better way to learn Python than to be immersed in a simple example script.

<source lang="python">
print("Hello World")

fruits = ["apple", "banana", "cherry", "date"]
for fruit in fruits:
print(f"I always love to eat a fresh {fruit}")

# Map the fruits list over to a new list containing the length of the fruit strings:
fruit_size = [len(fruit) for fruit in fruits]

avg_fruit_size = sum(fruit_size) / len(fruit_size)
print(f"The average fruit string length is {avg_fruit_size:.2f}.")
</source>

Some things to notice:

* Printing is achieved using the <code>print()</code> function.
* Comments start with a pound symbol <code>#</code>.
* We can transform/map a list to a new list in just one line!

For some more examples, see [https://wiki.python.org/moin/SimplePrograms the Python wiki].

=== A Few Gotchas ===

Here are a few things you may not expect when starting out with Python:

<ol>

<li>
Strings can be delimited using either single quotes (<code>'</code>) or double quotes (<code>"</code>), so <code>'Python'</code> is the same as <code>"Python"</code. You can also use three sets of quotes (<code>'''</code> or <code>"""</code>) to delineate a multiple-line string, like so:
<source lang="python">
long_string = """This
is my
very long
multiple-line
string"""
</source>
</li>

<li>
To compare the equality of two objects, use the <code>==</code> operator. To compare the identity of two objects (i.e. whether or not they are literally the same object, at the same place in memory), use the <code>is</code> operator. These correspond, respectively to <code>.equals()</code> and <code>==</code> in Java.
</li>

<li>
The <code>/</code> operator performs floating-point division, not integer division, even when both its arguments are integers. If you want to do integer division, use the <code>//</code> operator. Let's look at an example:

<source lang="python">
9 / 10 == 0.9 # Floating-point division
9.0 / 10.0 == 0.9 # Floating-point division
9 // 10 == 0 # Integer division
9.0 // 10.0 == 0.0 # Integer division, even though the resulting value is a float
</source>
</li>

<li>
As discussed in the section [[#Python's_Type_System|Python's Type System]], you can't combine strings and numbers using the <code>+</code> operator. Instead, you'll have to use one of the following methods of string formatting:

<source lang="python">

# Technique 1 – printf-style Formatting
# This is a classic style of string formatting, used in many programming languages, including in Java's String.format.
"You scored %d out of %d!" % (score, questions)

# Technique 2 – str.format
"You scored {} out of {}!".format(score, questions)

# Technique 3 – f-strings
# These were only introduced in Python 3.6 but they're very convenient.
f"You scored {score} out of {questions}!"

# Technique 4 - String Concatenation
# This is fine for small things, but for more complicated stuff, use one of the other techniques.
"You scored " + str(score) + " out of " + str(questions) + "!"
</source>
</li>
</ol>

=== Functions ===

Define functions using the <code>def</code> keyword:

<source lang="python">
def hello(name):
print(f"Hello, {name}!")

</source>

Invoke functions using parentheses:
<source lang="python">
hello("Batman")
hello("Superman")
</source>

Functions can have optional arguments; however, these must come after any required arguments:
<source lang="python">
def hello(name="User"):
print(f"Hello, {name}!")

hello() # Prints "Hello, User!"
hello("Sarah") # Prints "Hello, Sarah!"
</source>

Functions are just regular objects in Python, meaning you can do stuff like this:

<source lang="python">
def hello(name="User"):
print(f"Hello, {name}!")

greeting = hello

greeting("Siwei") # Prints "Hello, Siwei!"
</source>

=== Collection Types ===
Python has a few basic, built-in collection types. They each have their own special use cases, but they share a lot of similarities. All built-in data structures in Python are zero-indexed, for instance.

To obtain the number of elements in a collection, use the <code>len()</code> function, like this:

<source lang="python">
pets = ['Dog', 'Cat', 'Fish'] # This is a list; you'll learn about them below.

len(pets) # Returns 3
</source>

To check if a collection contains an item, use the <code>in</code> operator:
<source lang="python">
pets = ['Dog', 'Cat', 'Fish'] # This is a list; you'll learn about them below.

'Dog' in pets # Returns True
</source>

Helpfully, the Python Software Foundation maintains a page containing the asymptotic complexities of important operations on major Python data structures. It's available [https://wiki.python.org/moin/TimeComplexity here].

==== Lists ====

Unlike languages like Java and C, Python's array-like type doesn't have fixed length. Instead, a <code>list</code> is a dynamic array (like Java's <code>ArrayList</code>) of objects of any type. Here's an example:

<source lang="python">
fruits = ["Apple", "Pear", "Orange"] # Lists can be creating by placing their items between square brackets

random_items = ['Apple', 12312, 2.0, [1, 2, 3]] # Lists can contain objects of different types - even other lists!

pets.append('Turtle') # Adds 'Turtle' to the end of pets
</source>

For the next few examples, we'll be using the following list:

<source lang="python">
pets = ['Dog', 'Cat', 'Fish', 'Turtle', 'Lizard', 'Snake']
</source>

To access or assign elements of a list, use the <code>[]</code> operator.

<source lang="python">
pets[0] # Returns 'Dog'
pets[1] = 'Cow' # Sets pets[1] to 'Cow'
pets[1] = 'Cat' # Sets pets[1] back to 'Cat'
</source>

You can also access or assign lists using negative indices, which will return elements starting from the end of the list:

<source lang="python">
pets[-1] # Returns 'Snake'
pets[-2] # Returns 'Lizard'
</source>

You can also use 'slice notation' to obtain or assign subsets of lists:
<source lang="python">
pets[start:end] # Returns items from index start to index end - 1.
pets[start:] # Returns items from index start to the end of the list, inclusive.
pets[:end] # Returns items from the beginning of the list to index end - 1.
pets[:] # Returns every item in the list
</source>

There's also a third, optional argument: <code>step</code>, which lets you jump over values:
<source lang="python">
pets[start:end:step] # Returns items from index start to index end - 1, jumping step values at a time

# Examples:
pets[1:5:2] # Returns items from index 1 to index 4, jumping 2 at a time, so ['Cat', 'Turtle']
pets[::3] # Returns all items in the list, jumping 3 at a time, so ['Dog', 'Turtle']
pets[::-1] # Returns all items in the list, jumping -1 at a time. This reverses the list, so ['Snake', 'Lizard', 'Turtle', 'Fish', 'Cat', 'Dog']
</source>

Lists have all the performance characteristics you'd expect of a dynamic array - constant-time indexing, amortized constant-time appends, and so on.

==== Tuples ====

Python has a special data type called <code>tuple</code>, which is exactly the same as a list except for the fact that it cannot be modified, so you can't append or replace items.

<source lang="python">
cities = ('St. Louis', 'Los Angeles', 'Seattle') # Tuples are defined using parentheses.
numbers = 1, 2, 3 # You can also omit the parentheses if it's unambiguous
single_item_tuple = (1,) # To make a tuple with only one item, put a comma after it
</source>

Tuples also enable you to have multiple return values from a function:

<source lang="python">
def compute_length(string):
str_len = len(string)
if str_len < 5:
return str_len, "short"
elif str_len < 40:
return str_len, "medium"
return str_len, "long"

length, description = compute_length("Four score and seven years ago")
print("The %s string is %d characters long." % (description, length))
</source>
The above example also demonstrates Python's if...elif...else conditional structure.

==== Dictionaries ====

Python has another datatype called a '''dictionary''' (or <code>dict</code>, for short), which are like ''Maps'' in Java, ''associative arrays'' in PHP, and ''object literals'' in JavaScript (coming up soon in Module 6). Essentially, they enable you to use any immutable object as the key in your data structure. <code>dict</code> objects can be created using either the <code>dict</code> function, or by placing items between curly braces, separating keys and values using colons:

<source lang="python">
fruits_in_bowl = {
'apple': 4,
'banana': 2,
'cherry': 0,
'date': 12
}

apple_count = fruits_in_bowl['apple'] # Equals 4

fruits_in_bowl['pear'] = 9 # Sets 'pear' in the dictionary to 9.

for fruit, num in fruits_in_bowl.items():
print(f"There are {num} {fruit}(s) in the bowl." % (num, fruit))
</source>
If you only want the keys from a dictionary, you can just iterate over it directly, like this:

<source lang="python">
for fruit in fruits_in_bowl:
print(fruit)
</source>
If you want only the values but not the keys from a dictionary, use <code>my_dictionary.values()</code>.

==== Sets ====
A <code>set</code> is an unordered collection of unique items, with constant-time membership checking.
<source lang="python">
fruits = {'Apple', 'Apple', 'Apple', 'Pear'} # The set removes duplicates, so it will only contain {'Apple', 'Pear'}
fruits = set(['Apple', 'Apple', 'Apple', 'Pear']) # This line transforms a list into a set
print('Apple' in fruits) # Constant-time!
</source>

=== Loops ===

In Python, while loops are written like this:

<source lang="python">
i = 0
while i < 10:
i += 1
</source>
For loops are written like this:

<source lang="python">
pets = ['Dog', 'Cat', 'Fish']

for pet in pets:
print(pet)
</source>
To iterate over a range of numbers, you can use the convenient <code>range</code> function, like so:

<source lang="python">
for i in range(20, 30): # If you omit the first argument to range, it's assumed to be zero.
print(i)
</source>
Note that <code>range</code> provides a closed-open range. That is to say, it is inclusive of its lower bound and exclusive of its upper bound. To be very explicit about it:

<source lang="python">
list(range(3, 6)) == [3, 4, 5]
</source>
Unlike in other languages you may know, the following is not good practice in Python:

<source lang="python">
pets = ['Dog', 'Cat', 'Fish']

# BAD PRACTICE. DO NOT USE.
for i in range(len(pets)):
pet = pets[i]
</source>
Instead, if you need to access both a variable and its index, use the <code>enumerate</code> function, which allows you to iterate through a group of items, along with their indexes, like so:

<source lang="python">
pets = ['Dog', 'Cat', 'Fish']

for index, pet in enumerate(pets):
print(f"{pet} at index {index}")
</source>

=== Generator Expressions and Comprehensions ===

A generator is a special kind of object that, basically, represents a collection of items using a value and a function for generating the next value in the collection. In other words, it's a way of creating something that behaves like a list, but which only generates one value at a time, and discards a value when it's done with it. Say, for example, you wanted to do an operation on 10,000,000,000,000 numbers. You could put them all in a list, then iterate over the list, but that would take a lot of memory, plus you'd have to create and fill the entire list before beginning to actually work on your problem. Instead, you'd probably be better off using a generator; telling the computer, essentially: “The starting value is 0. When I ask for the next number in the collection, add 1 to current value and give me that.”

A generator expression is an expression that is evaluated to create a generator. They're super useful. Generator expressions can take two forms – they can be used with and without a condition:

<source lang="python">
(EXPRESSION for VARIABLE in ITERABLE) # Unconditional
(EXPRESSION for VARIABLE in ITERABLE if CONDITION) # Conditional
</source>
For our purposes, you can think of an iterable as anything you can do a for loop over. Let's take a look at a generator expression in use:

<source lang="python">
double_even_digits = (number * 2 for number in range(10) if number % 2 == 0)
</source>
That line says that <code>double_even_digits</code> is every even number between 0 and 10 multiplied by two. Simple enough, right? If we wanted to use all of the numbers, not just the even ones, we could simply remove the if statement at the end of the expression.

Here's the thing, though: if you were to print <code>double_even_digits</code>, instead of a nice bunch of numbers, you'd get something that looks like this:

<code><generator object <genexpr><code>at 0x107fc92b0></code>

That's because generators are lazy! They don't generate their values until those values are needed, and they discard values once they're no longer needed. As a result, '''you can only iterate over a generator once'''. In this case, you can't print out the whole generator, because it hasn't generated all the values yet. You can, however, iterate over the generator, and print its values one at a time, like so:

<source lang="python">
for number in double_even_digits:
print(number)
</source>
You can also make a list out of the generator, which will go through all the items in the generator and put them in a list, like so:

<source lang="python">
even_number_list = list(double_even_digits)
</source>
That's actually a great segue to the second topic of this section: comprehensions. A comprehension is just a prettier way to make lists, sets, and dicts out of a generator expressions.

<source lang="python">
# If you want a list:
list(i for i in range(10) if i % 2 == 0) # Don't do this
[i for i in range(10) if i % 2 == 0] # Use a list comprehension instead!

# If you want a set:
set(i for i in range(10) if i % 2 == 0) # Don't do this
{i for i in range(10) if i % 2 == 0} # Use a set comprehension instead!

# If you want a dict:
dict((i, i + 1) for i in range(10) if i % 2 == 0) # Don't do this
{i : i + 1 for i in range(10) if i % 2 == 0} # Use a dict comprehension instead!

# If you want a tuple:
tuple(i for i in range(10) if i % 2 == 0) # Unfortunately, there's no better way to do this
</source>
In general, generators and comprehensions should be used whenever possible - they're the fastest and easiest way to build collections. If you ever see yourself writing code like this:

<source lang="python">
# BAD PRACTICE! DO NOT USE!
digits = []
for digit in range(10):
digits.append(digit)
</source>
Don't do it! Instead, use a generator expression or comprehension, as appropriate. A good way to decide whether a generator expression or comprehension is better for this situation is that, if you're just going to be iterating over your collection once, you should use an generator expression. If not, use a comprehension.

=== Sorting ===

Sorting in Python is frequently performed using the <code>sorted</code> function, which takes two arguments: an iterable (anything you can do a for-loop over, including lists and tuples) and a function used to evaluate each item. If the function is omitted, Python will try to sort the lists by value.

The following example demonstrates using an inline function, which Python calls a ''lambda''.

<source lang="python">
fruits = ['apple', 'banana', 'cherry', 'date']

# sort the fruits by string length
new_fruits = sorted(fruits, key=lambda v: len(v) // 2)

print(new_fruits) # ['date', 'apple', 'banana', 'cherry']
</source>
Alternatively, you can sort a <code>list</code> using the <code>.sort</code> method. This is faster than calling <code>sorted</code>, but it modifies the list in-place and returns <code>None</code>.

<source lang="python">
fruits = ['apple', 'banana', 'cherry', 'date']
fruits.sort()
</source>
=== Import ===

If you want to use functions from other libraries (including ones that you install using pip), use <code>import</code>:

<source lang="python">
import time

current_time = time.localtime()
print(time.strftime('%a, %d %b %Y %H:%M:%S', current_time))
</source>
If you want to pull the functions out of their namespace, you can use <code>from ___ import ___</code> syntax:

<source lang="python">
from time import localtime, strftime

current_time = localtime()
print(strftime('%a, %d %b %Y %H:%M:%S', current_time))

# Be aware that this technique, although convenient, may cause unexpected behavior if the function names that you're pulling out of the namespace are already used for other purposes in Python.
</source>
=== File I/O ===

You can read an entire file into a variable like this:

<source lang="python">
f = open("example.txt")
file_contents = f.read()

f.close() # free up memory when we're finished with the file
</source>
A better option is to use a with-block, which handles opening and closing the file for you automatically:

<source lang="python">
with open("example.txt") as f:
file_contents = f.read()
</source>
You can read a file line-by-line like this:

<source lang="python">
with open("example.txt") as f:
for line in f:
print("Read line: %s" % line.rstrip())
</source>
You can write to a file like this:

<source lang="python">
with open("example.txt", "w") as f:
f.write("Hello\nWorld\n")
</source>
=== Command-Line Arguments ===

Command line arguments are accessible in the variable <code>sys.argv</code>.

The following example shows a program that expects a filename as its argument, and it prints a usage message if the argument is not present ([https://stackoverflow.com/questions/983201/python-and-sys-argv source]).

<source lang="python">
import sys, os

if len(sys.argv) < 2:
sys.exit("Usage: %s filename" % sys.argv[0])

filename = sys.argv[1]

if not os.path.exists(filename):
sys.exit("Error: File '%s' not found" % sys.argv[1])
</source>
=== Object-Oriented Programming ===

You can define and use a class like this:

<source lang="python">
class Food:
# constructor:
def __init__(self, name):
self.name = name

def format_name(self):
return "Gotta love to eat " + self.name

class Fruit(Food):
def format_name(self):
return Food.format_name(self) + " (fruit)"

fruit = Fruit("Cherry")
print(fruit.format_name())
print(Food.get_definition())
</source>
This is the same example as in [[PHP#Object-Oriented_Programming|the PHP guide]].

Some things to notice:

* Instance methods ''always'' take <code>self</code> as their first argument, followed by any number of additional parameters. This can be misleading for programmers familiar with other languages, because the number of arguments you feed to the method is actually ''one less than'' the number of declared parameters. Whenever you call a method on a class instance, that instance is implicitly fed into the explicitly-declared <code>self</code> parameter of the method.
*: Note that the <code>self</code> variable has the same purpose as the <code>this</code> variable in languages like PHP, Java, JavaScript, and C++.
*There is no need for a <code>new</code> keyword in Python.

= Footnotes =
# {{note|interpreted}}This is an oversimplification. If you're interested, here's a quick explanation of how: In CPython (the reference implementation of Python) programs are compiled to bytecode, an intermediate representation, which is then interpreted.
[[Category:Module 4]]

Python

2018-02-19T17:28:47Z

Alex: /* Dictionaries */ Format strings

Languages like Java and C++ have lots of rules regarding variable types, syntax, return values, and so on. These can be cumbersome when you are trying to write short, quick scripts to perform tasks. This is where a ''scripting language'' comes into play.

'''Python''' is a language well-suited to rapid prototype development. It is generally an ''interpreted language'', which means that, generally speaking, a Python program is converted line by line into instructions for the computer to execute as the program runs, instead of having a separate compilation step beforehand {{ref|interpreted}}. The syntax is clean, and it is usually clear at first glance what is going on when you write in Python.

= Installation =

Python may already be installed on your system. To see whether or not it is, enter the command

<source lang="bash">
$ python --version
</source>
If it tells you a version of Python '''greater than or equal to 3.5''' then you're good to go. If not, you need to do a quick package install to get it up and running. Using yum, it's just <code>sudo yum install python35; sudo alternatives --set python /usr/bin/python3</code>.

==== Python 2 vs Python 3 ====

In 2008, a new version of Python – Python 3 – was released, with a number changes that made it incompatible with the previous version, Python 2. For several years, the Python community was slow to make the change to Python 3, but today, Python 3 is ''the'' standard for new code. The ''only'' reason to write Python 2 code today is because you have to work in an environment or with libraries that do not support Python 3, and that situation is becoming increasingly rare.

'''For CSE 330 (and this guide), you ''must'' use Python 3.5 or greater.'''

=== Pip ===

Linux distributions have package managers like ''Apt'', ''Yum'', and ''YaST''. PHP has a package manager named ''PEAR''. It's now time to introduce Python's leading package manager: '''pip'''.

You need to install Pip from Yum before you can use it. The package is called <code>python-pip</code>.

Once you have pip installed, you can use it to install Python packages. Use the <code>pip-python</code> command:

<source lang="bash">
$ pip-python install package_name # RHEL
$ pip install package_name # Debian
</source>
= Running Python =

There are two common ways to run Python code: via the console, and via a Python script file.

=== The Python Console ===

The Python console enables you to experiment with code without opening a text editor. To enter the Python console, simply type the ''python'' command at the terminal:

<source lang="bash">
$ python
</source>
To leave the interactive console, either type <code>quit()</code> or press <code>Ctrl-D</code> (on both Mac and Windows).

=== Python Script Files ===

You can also save Python script files for later use. The extension for Python scripts is <code>*.py</code>. To run a script file, simply feed its path as an argument to the <code>python</code> command in Terminal:

<source lang="bash">
$ python my_script.py
</source>

= Python Syntax and Language Components =

This section contains a very brief overview of Python syntax. For a more comprehensive introduction, see [http://docs.python.org/tutorial/ the Python docs].

=== Python's Type System ===

Python is a dynamically-typed, strongly-typed, and duck-typed language. What does that mean? Well, let's take those categories one by one:

<ol>
<li>
'''Dynamic typing''', in contrast to ''static typing'' means that the types of objects can be changed. In Java, for instance, if you tried to write the following code:

<source lang="java">
int c = 2;
c = "fish";
</source>

Your code would fail to compile, because the Java compiler wouldn't allow you to change the type of the variable <code>c</code> from <code>int</code> to <code>String</code>.

Python, however, is just fine with that. You can write:

<source lang="python">
c = 2
c = "fish"
</source>

And Python will happily do what you ask.
</li>

<li>
'''Strong typing''', in contrast to ''weak typing'', means, roughly, that a language won't implicitly convert types for you. So far, you've used a lot of PHP, which is very weakly typed. For example:

<source lang="php">
echo "10" . 2;
</source>

In PHP, this works just fine. The PHP interpreter sees that <code>2</code> is an int, and silently converts it to a string for you, so that <code>"10". 2</code> equals <code>"102"</code>. The problem with weak typing is that it can make it unclear to the programmer why things are happening the way they are. For instance, in PHP, the expression <code>"10" == 10</code> is true, which can be less than obvious. Python, however, tries to disallow that sort of thing:

<source lang="python">
"10" + "10" # Allowed – concatenates the two strings.
10 + 10 # Allowed – adds the two ints.
"10" + 10 # Not allowed – raises a TypeError
</source>

Perhaps the one exception to this rule is the relationship between numeric types; it's perfectly fine to add a float to an int, for example.
</li>

<li>
'''Duck-typing''' is a little bit different than the other categories, because it doesn't really have a direct opposite. Essentially, duck-typing is the philosophy that "If it walks like a duck, and quacks like a duck, it's a duck." In programming terms, that means that we often don't care what type an object is, as long as it can do the things we ask.

Let's look at an example:

<source lang="python">
# This function doubles the value it's passed.
def double(thing):
return thing + thing
double(10) # Returns 20
double("fish") # Returns "fishfish";
</source>

If this were Java, we'd have to write two different methods here: one for things of type <code>int</code>, and one for things of type <code>String</code>. Since this is Python, though, we don't have to do that. Instead, Python lets us say, essentially: "This function uses the <code>+</code> operator, so you can pass whatever object you want to the function, as long as the function supports the <code>+</code> operator".

To quote [https://groups.google.com/forum/?hl=en#!msg/comp.lang.python/CCs2oJdyuzc/NYjla5HKMOIJ Alex Martelli], one of the key people in the Python project,

<blockquote>
"[Don't] check whether it IS-a duck: check whether it QUACKS-like-a duck, WALKS-like-a duck, etc, etc, depending on exactly what subset of duck-like behaviour you need."
</blockquote>

</li>
</ol>

=== Basic Types ===

In Python, the basic scalar types are:

# <code>str</code> – a string.
# <code>int</code> – an integer object with unlimited digits.
# <code>bool</code> – a Boolean value.
# <code>float</code> – a floating point number; generally equivalent to <code>double</code> in Java.
# <code>bytes</code> – represents a collection of bytes; you're unlikely to use this often.

Casting is done in the C style - to parse an <code>int</code> from a string, for instance, you'd write <code>int("123")</code>.

=== Basic Control Flow ===
In Python, blocks of code are delineated using colons and indentation instead of curly braces. '''''That means that proper indentation is mandatory.''''' Every time you use a colon, you must indent one step further, and every time a block ends, you must unindent a step.

Conditional statements are done using the <code>if</code>, <code>elif</code>, and <code>else</code> operators, like in the example below - pay attention to the indentation:

<source lang="python">
cookies_left = 10
cake_slices_left = 3
if cookies_left > 10:
print("Lots of cookies!")
elif cookies_left > 8:
print("Plenty left!")
elif cookies_left == 5:
print("Halfway done!")
else:
if cake_slices_left == 3:
print("Lots of cake!")
elif cake_slices_left == 2:
print("One slice gone!")
else:
print("Little to no cake left!")
</source>

=== An Example Python Script ===

In my mind, there's no better way to learn Python than to be immersed in a simple example script.

<source lang="python">
print("Hello World")

fruits = ["apple", "banana", "cherry", "date"]
for fruit in fruits:
print(f"I always love to eat a fresh {fruit}")

# Map the fruits list over to a new list containing the length of the fruit strings:
fruit_size = [len(fruit) for fruit in fruits]

avg_fruit_size = sum(fruit_size) / len(fruit_size)
print(f"The average fruit string length is {avg_fruit_size:.2f}.")
</source>

Some things to notice:

* Printing is achieved using the <code>print()</code> function.
* Comments start with a pound symbol <code>#</code>.
* We can transform/map a list to a new list in just one line!

For some more examples, see [https://wiki.python.org/moin/SimplePrograms the Python wiki].

=== A Few Gotchas ===

Here are a few things you may not expect when starting out with Python:

<ol>

<li>
Strings can be delimited using either single quotes (<code>'</code>) or double quotes (<code>"</code>), so <code>'Python'</code> is the same as <code>"Python"</code. You can also use three sets of quotes (<code>'''</code> or <code>"""</code>) to delineate a multiple-line string, like so:
<source lang="python">
long_string = """This
is my
very long
multiple-line
string"""
</source>
</li>

<li>
To compare the equality of two objects, use the <code>==</code> operator. To compare the identity of two objects (i.e. whether or not they are literally the same object, at the same place in memory), use the <code>is</code> operator. These correspond, respectively to <code>.equals()</code> and <code>==</code> in Java.
</li>

<li>
The <code>/</code> operator performs floating-point division, not integer division, even when both its arguments are integers. If you want to do integer division, use the <code>//</code> operator. Let's look at an example:

<source lang="python">
9 / 10 == 0.9 # Floating-point division
9.0 / 10.0 == 0.9 # Floating-point division
9 // 10 == 0 # Integer division
9.0 // 10.0 == 0.0 # Integer division, even though the resulting value is a float
</source>
</li>

<li>
As discussed in the section [[#Python's_Type_System|Python's Type System]], you can't combine strings and numbers using the <code>+</code> operator. Instead, you'll have to use one of the following methods of string formatting:

<source lang="python">

# Technique 1 – printf-style Formatting
# This is a classic style of string formatting, used in many programming languages, including in Java's String.format.
"You scored %d out of %d!" % (score, questions)

# Technique 2 – str.format
"You scored {} out of {}!".format(score, questions)

# Technique 3 – f-strings
# These were only introduced in Python 3.6 but they're very convenient.
f"You scored {score} out of {questions}!"

# Technique 4 - String Concatenation
# This is fine for small things, but for more complicated stuff, use one of the other techniques.
"You scored " + str(score) + " out of " + str(questions) + "!"
</source>
</li>
</ol>

=== Functions ===

Define functions using the <code>def</code> keyword:

<source lang="python">
def hello(name):
print(f"Hello, {name}!")

</source>

Invoke functions using parentheses:
<source lang="python">
hello("Batman")
hello("Superman")
</source>

Functions can have optional arguments; however, these must come after any required arguments:
<source lang="python">
def hello(name="User"):
print(f"Hello, {name}!")

hello() # Prints "Hello, User!"
hello("Sarah") # Prints "Hello, Sarah!"
</source>

Functions are just regular objects in Python, meaning you can do stuff like this:

<source lang="python">
def hello(name="User"):
print(f"Hello, {name}!")

greeting = hello

greeting("Siwei") # Prints "Hello, Siwei!"
</source>

=== Collection Types ===
Python has a few basic, built-in collection types. They each have their own special use cases, but they share a lot of similarities. All built-in data structures in Python are zero-indexed, for instance.

To obtain the number of elements in a collection, use the <code>len()</code> function, like this:

<source lang="python">
pets = ['Dog', 'Cat', 'Fish'] # This is a list; you'll learn about them below.

len(pets) # Returns 3
</source>

To check if a collection contains an item, use the <code>in</code> operator:
<source lang="python">
pets = ['Dog', 'Cat', 'Fish'] # This is a list; you'll learn about them below.

'Dog' in pets # Returns True
</source>

Helpfully, the Python Software Foundation maintains a page containing the asymptotic complexities of important operations on major Python data structures. It's available [https://wiki.python.org/moin/TimeComplexity here].

==== Lists ====

Unlike languages like Java and C, Python's array-like type doesn't have fixed length. Instead, a <code>list</code> is a dynamic array (like Java's <code>ArrayList</code>) of objects of any type. Here's an example:

<source lang="python">
fruits = ["Apple", "Pear", "Orange"] # Lists can be creating by placing their items between square brackets

random_items = ['Apple', 12312, 2.0, [1, 2, 3]] # Lists can contain objects of different types - even other lists!

pets.append('Turtle') # Adds 'Turtle' to the end of pets
</source>

For the next few examples, we'll be using the following list:

<source lang="python">
pets = ['Dog', 'Cat', 'Fish', 'Turtle', 'Lizard', 'Snake']
</source>

To access or assign elements of a list, use the <code>[]</code> operator.

<source lang="python">
pets[0] # Returns 'Dog'
pets[1] = 'Cow' # Sets pets[1] to 'Cow'
pets[1] = 'Cat' # Sets pets[1] back to 'Cat'
</source>

You can also access or assign lists using negative indices, which will return elements starting from the end of the list:

<source lang="python">
pets[-1] # Returns 'Snake'
pets[-2] # Returns 'Lizard'
</source>

You can also use 'slice notation' to obtain or assign subsets of lists:
<source lang="python">
pets[start:end] # Returns items from index start to index end - 1.
pets[start:] # Returns items from index start to the end of the list, inclusive.
pets[:end] # Returns items from the beginning of the list to index end - 1.
pets[:] # Returns every item in the list
</source>

There's also a third, optional argument: <code>step</code>, which lets you jump over values:
<source lang="python">
pets[start:end:step] # Returns items from index start to index end - 1, jumping step values at a time

# Examples:
pets[1:5:2] # Returns items from index 1 to index 4, jumping 2 at a time, so ['Cat', 'Turtle']
pets[::3] # Returns all items in the list, jumping 3 at a time, so ['Dog', 'Turtle']
pets[::-1] # Returns all items in the list, jumping -1 at a time. This reverses the list, so ['Snake', 'Lizard', 'Turtle', 'Fish', 'Cat', 'Dog']
</source>

Lists have all the performance characteristics you'd expect of a dynamic array - constant-time indexing, amortized constant-time appends, and so on.

==== Tuples ====

Python has a special data type called <code>tuple</code>, which is exactly the same as a list except for the fact that it cannot be modified, so you can't append or replace items.

<source lang="python">
cities = ('St. Louis', 'Los Angeles', 'Seattle') # Tuples are defined using parentheses.
numbers = 1, 2, 3 # You can also omit the parentheses if it's unambiguous
single_item_tuple = (1,) # To make a tuple with only one item, put a comma after it
</source>

Tuples also enable you to have multiple return values from a function:

<source lang="python">
def compute_length(string):
str_len = len(string)
if str_len < 5:
return str_len, "short"
elif str_len < 40:
return str_len, "medium"
return str_len, "long"

length, description = compute_length("Four score and seven years ago")
print("The %s string is %d characters long." % (description, length))
</source>
The above example also demonstrates Python's if...elif...else conditional structure.

==== Dictionaries ====

Python has another datatype called a '''dictionary''' (or <code>dict</code>, for short), which are like ''Maps'' in Java, ''associative arrays'' in PHP, and ''object literals'' in JavaScript (coming up soon in Module 6). Essentially, they enable you to use any immutable object as the key in your data structure. <code>dict</code> objects can be created using either the <code>dict</code> function, or by placing items between curly braces, separating keys and values using colons:

<source lang="python">
fruits_in_bowl = {
'apple': 4,
'banana': 2,
'cherry': 0,
'date': 12
}

apple_count = fruits_in_bowl['apple'] # Equals 4

fruits_in_bowl['pear'] = 9 # Sets 'pear' in the dictionary to 9.

for fruit, num in fruits_in_bowl.items():
print(f"There are {num} {fruit}(s) in the bowl." % (num, fruit))
</source>
If you only want the keys from a dictionary, you can just iterate over it directly, like this:

<source lang="python">
for fruit in fruits_in_bowl:
print(fruit)
</source>
If you want only the values but not the keys from a dictionary, use <code>my_dictionary.values()</code>.

==== Sets ====
A <code>set</code> is an unordered collection of unique items, with constant-time membership checking.
<source lang="python">
fruits = {'Apple', 'Apple', 'Apple', 'Pear'} # The set removes duplicates, so it will only contain {'Apple', 'Pear'}
fruits = set(['Apple', 'Apple', 'Apple', 'Pear']) # This line transforms a list into a set
print('Apple' in fruits) # Constant-time!
</source>

=== Loops ===

In Python, while loops are written like this:

<source lang="python">
i = 0
while i < 10:
i += 1
</source>
For loops are written like this:

<source lang="python">
pets = ['Dog', 'Cat', 'Fish']

for pet in pets:
print(pet)
</source>
To iterate over a range of numbers, you can use the convenient <code>range</code> function, like so:

<source lang="python">
for i in range(20, 30): # If you omit the first argument to range, it's assumed to be zero.
print(i)
</source>
Note that <code>range</code> provides a closed-open range. That is to say, it is inclusive of its lower bound and exclusive of its upper bound. To be very explicit about it:

<source lang="python">
list(range(3, 6)) == [3, 4, 5]
</source>
Unlike in other languages you may know, the following is not good practice in Python:

<source lang="python">
pets = ['Dog', 'Cat', 'Fish']

# BAD PRACTICE. DO NOT USE.
for i in range(len(pets)):
pet = pets[i]
</source>
Instead, if you need to access both a variable and its index, use the <code>enumerate</code> function, which allows you to iterate through a group of items, along with their indexes, like so:

<source lang="python">
pets = ['Dog', 'Cat', 'Fish']

for index, pet in enumerate(pets):
print("%s at index %d"; % (pet, index))
</source>

=== Generator Expressions and Comprehensions ===

A generator is a special kind of object that, basically, represents a collection of items using a value and a function for generating the next value in the collection. In other words, it's a way of creating something that behaves like a list, but which only generates one value at a time, and discards a value when it's done with it. Say, for example, you wanted to do an operation on 10,000,000,000,000 numbers. You could put them all in a list, then iterate over the list, but that would take a lot of memory, plus you'd have to create and fill the entire list before beginning to actually work on your problem. Instead, you'd probably be better off using a generator; telling the computer, essentially: “The starting value is 0. When I ask for the next number in the collection, add 1 to current value and give me that.”

A generator expression is an expression that is evaluated to create a generator. They're super useful. Generator expressions can take two forms – they can be used with and without a condition:

<source lang="python">
(EXPRESSION for VARIABLE in ITERABLE) # Unconditional
(EXPRESSION for VARIABLE in ITERABLE if CONDITION) # Conditional
</source>
For our purposes, you can think of an iterable as anything you can do a for loop over. Let's take a look at a generator expression in use:

<source lang="python">
double_even_digits = (number * 2 for number in range(10) if number % 2 == 0)
</source>
That line says that <code>double_even_digits</code> is every even number between 0 and 10 multiplied by two. Simple enough, right? If we wanted to use all of the numbers, not just the even ones, we could simply remove the if statement at the end of the expression.

Here's the thing, though: if you were to print <code>double_even_digits</code>, instead of a nice bunch of numbers, you'd get something that looks like this:

<code><generator object <genexpr><code>at 0x107fc92b0></code>

That's because generators are lazy! They don't generate their values until those values are needed, and they discard values once they're no longer needed. As a result, '''you can only iterate over a generator once'''. In this case, you can't print out the whole generator, because it hasn't generated all the values yet. You can, however, iterate over the generator, and print its values one at a time, like so:

<source lang="python">
for number in double_even_digits:
print(number)
</source>
You can also make a list out of the generator, which will go through all the items in the generator and put them in a list, like so:

<source lang="python">
even_number_list = list(double_even_digits)
</source>
That's actually a great segue to the second topic of this section: comprehensions. A comprehension is just a prettier way to make lists, sets, and dicts out of a generator expressions.

<source lang="python">
# If you want a list:
list(i for i in range(10) if i % 2 == 0) # Don't do this
[i for i in range(10) if i % 2 == 0] # Use a list comprehension instead!

# If you want a set:
set(i for i in range(10) if i % 2 == 0) # Don't do this
{i for i in range(10) if i % 2 == 0} # Use a set comprehension instead!

# If you want a dict:
dict((i, i + 1) for i in range(10) if i % 2 == 0) # Don't do this
{i : i + 1 for i in range(10) if i % 2 == 0} # Use a dict comprehension instead!

# If you want a tuple:
tuple(i for i in range(10) if i % 2 == 0) # Unfortunately, there's no better way to do this
</source>
In general, generators and comprehensions should be used whenever possible - they're the fastest and easiest way to build collections. If you ever see yourself writing code like this:

<source lang="python">
# BAD PRACTICE! DO NOT USE!
digits = []
for digit in range(10):
digits.append(digit)
</source>
Don't do it! Instead, use a generator expression or comprehension, as appropriate. A good way to decide whether a generator expression or comprehension is better for this situation is that, if you're just going to be iterating over your collection once, you should use an generator expression. If not, use a comprehension.

=== Sorting ===

Sorting in Python is frequently performed using the <code>sorted</code> function, which takes two arguments: an iterable (anything you can do a for-loop over, including lists and tuples) and a function used to evaluate each item. If the function is omitted, Python will try to sort the lists by value.

The following example demonstrates using an inline function, which Python calls a ''lambda''.

<source lang="python">
fruits = ['apple', 'banana', 'cherry', 'date']

# sort the fruits by string length
new_fruits = sorted(fruits, key=lambda v: len(v) // 2)

print(new_fruits) # ['date', 'apple', 'banana', 'cherry']
</source>
Alternatively, you can sort a <code>list</code> using the <code>.sort</code> method. This is faster than calling <code>sorted</code>, but it modifies the list in-place and returns <code>None</code>.

<source lang="python">
fruits = ['apple', 'banana', 'cherry', 'date']
fruits.sort()
</source>
=== Import ===

If you want to use functions from other libraries (including ones that you install using pip), use <code>import</code>:

<source lang="python">
import time

current_time = time.localtime()
print(time.strftime('%a, %d %b %Y %H:%M:%S', current_time))
</source>
If you want to pull the functions out of their namespace, you can use <code>from ___ import ___</code> syntax:

<source lang="python">
from time import localtime, strftime

current_time = localtime()
print(strftime('%a, %d %b %Y %H:%M:%S', current_time))

# Be aware that this technique, although convenient, may cause unexpected behavior if the function names that you're pulling out of the namespace are already used for other purposes in Python.
</source>
=== File I/O ===

You can read an entire file into a variable like this:

<source lang="python">
f = open("example.txt")
file_contents = f.read()

f.close() # free up memory when we're finished with the file
</source>
A better option is to use a with-block, which handles opening and closing the file for you automatically:

<source lang="python">
with open("example.txt") as f:
file_contents = f.read()
</source>
You can read a file line-by-line like this:

<source lang="python">
with open("example.txt") as f:
for line in f:
print("Read line: %s" % line.rstrip())
</source>
You can write to a file like this:

<source lang="python">
with open("example.txt", "w") as f:
f.write("Hello\nWorld\n")
</source>
=== Command-Line Arguments ===

Command line arguments are accessible in the variable <code>sys.argv</code>.

The following example shows a program that expects a filename as its argument, and it prints a usage message if the argument is not present ([https://stackoverflow.com/questions/983201/python-and-sys-argv source]).

<source lang="python">
import sys, os

if len(sys.argv) < 2:
sys.exit("Usage: %s filename" % sys.argv[0])

filename = sys.argv[1]

if not os.path.exists(filename):
sys.exit("Error: File '%s' not found" % sys.argv[1])
</source>
=== Object-Oriented Programming ===

You can define and use a class like this:

<source lang="python">
class Food:
# constructor:
def __init__(self, name):
self.name = name

def format_name(self):
return "Gotta love to eat " + self.name

class Fruit(Food):
def format_name(self):
return Food.format_name(self) + " (fruit)"

fruit = Fruit("Cherry")
print(fruit.format_name())
print(Food.get_definition())
</source>
This is the same example as in [[PHP#Object-Oriented_Programming|the PHP guide]].

Some things to notice:

* Instance methods ''always'' take <code>self</code> as their first argument, followed by any number of additional parameters. This can be misleading for programmers familiar with other languages, because the number of arguments you feed to the method is actually ''one less than'' the number of declared parameters. Whenever you call a method on a class instance, that instance is implicitly fed into the explicitly-declared <code>self</code> parameter of the method.
*: Note that the <code>self</code> variable has the same purpose as the <code>this</code> variable in languages like PHP, Java, JavaScript, and C++.
*There is no need for a <code>new</code> keyword in Python.

= Footnotes =
# {{note|interpreted}}This is an oversimplification. If you're interested, here's a quick explanation of how: In CPython (the reference implementation of Python) programs are compiled to bytecode, an intermediate representation, which is then interpreted.
[[Category:Module 4]]

Python

2018-02-19T17:28:04Z

Alex: /* Functions */

Languages like Java and C++ have lots of rules regarding variable types, syntax, return values, and so on. These can be cumbersome when you are trying to write short, quick scripts to perform tasks. This is where a ''scripting language'' comes into play.

'''Python''' is a language well-suited to rapid prototype development. It is generally an ''interpreted language'', which means that, generally speaking, a Python program is converted line by line into instructions for the computer to execute as the program runs, instead of having a separate compilation step beforehand {{ref|interpreted}}. The syntax is clean, and it is usually clear at first glance what is going on when you write in Python.

= Installation =

Python may already be installed on your system. To see whether or not it is, enter the command

<source lang="bash">
$ python --version
</source>
If it tells you a version of Python '''greater than or equal to 3.5''' then you're good to go. If not, you need to do a quick package install to get it up and running. Using yum, it's just <code>sudo yum install python35; sudo alternatives --set python /usr/bin/python3</code>.

==== Python 2 vs Python 3 ====

In 2008, a new version of Python – Python 3 – was released, with a number changes that made it incompatible with the previous version, Python 2. For several years, the Python community was slow to make the change to Python 3, but today, Python 3 is ''the'' standard for new code. The ''only'' reason to write Python 2 code today is because you have to work in an environment or with libraries that do not support Python 3, and that situation is becoming increasingly rare.

'''For CSE 330 (and this guide), you ''must'' use Python 3.5 or greater.'''

=== Pip ===

Linux distributions have package managers like ''Apt'', ''Yum'', and ''YaST''. PHP has a package manager named ''PEAR''. It's now time to introduce Python's leading package manager: '''pip'''.

You need to install Pip from Yum before you can use it. The package is called <code>python-pip</code>.

Once you have pip installed, you can use it to install Python packages. Use the <code>pip-python</code> command:

<source lang="bash">
$ pip-python install package_name # RHEL
$ pip install package_name # Debian
</source>
= Running Python =

There are two common ways to run Python code: via the console, and via a Python script file.

=== The Python Console ===

The Python console enables you to experiment with code without opening a text editor. To enter the Python console, simply type the ''python'' command at the terminal:

<source lang="bash">
$ python
</source>
To leave the interactive console, either type <code>quit()</code> or press <code>Ctrl-D</code> (on both Mac and Windows).

=== Python Script Files ===

You can also save Python script files for later use. The extension for Python scripts is <code>*.py</code>. To run a script file, simply feed its path as an argument to the <code>python</code> command in Terminal:

<source lang="bash">
$ python my_script.py
</source>

= Python Syntax and Language Components =

This section contains a very brief overview of Python syntax. For a more comprehensive introduction, see [http://docs.python.org/tutorial/ the Python docs].

=== Python's Type System ===

Python is a dynamically-typed, strongly-typed, and duck-typed language. What does that mean? Well, let's take those categories one by one:

<ol>
<li>
'''Dynamic typing''', in contrast to ''static typing'' means that the types of objects can be changed. In Java, for instance, if you tried to write the following code:

<source lang="java">
int c = 2;
c = "fish";
</source>

Your code would fail to compile, because the Java compiler wouldn't allow you to change the type of the variable <code>c</code> from <code>int</code> to <code>String</code>.

Python, however, is just fine with that. You can write:

<source lang="python">
c = 2
c = "fish"
</source>

And Python will happily do what you ask.
</li>

<li>
'''Strong typing''', in contrast to ''weak typing'', means, roughly, that a language won't implicitly convert types for you. So far, you've used a lot of PHP, which is very weakly typed. For example:

<source lang="php">
echo "10" . 2;
</source>

In PHP, this works just fine. The PHP interpreter sees that <code>2</code> is an int, and silently converts it to a string for you, so that <code>"10". 2</code> equals <code>"102"</code>. The problem with weak typing is that it can make it unclear to the programmer why things are happening the way they are. For instance, in PHP, the expression <code>"10" == 10</code> is true, which can be less than obvious. Python, however, tries to disallow that sort of thing:

<source lang="python">
"10" + "10" # Allowed – concatenates the two strings.
10 + 10 # Allowed – adds the two ints.
"10" + 10 # Not allowed – raises a TypeError
</source>

Perhaps the one exception to this rule is the relationship between numeric types; it's perfectly fine to add a float to an int, for example.
</li>

<li>
'''Duck-typing''' is a little bit different than the other categories, because it doesn't really have a direct opposite. Essentially, duck-typing is the philosophy that "If it walks like a duck, and quacks like a duck, it's a duck." In programming terms, that means that we often don't care what type an object is, as long as it can do the things we ask.

Let's look at an example:

<source lang="python">
# This function doubles the value it's passed.
def double(thing):
return thing + thing
double(10) # Returns 20
double("fish") # Returns "fishfish";
</source>

If this were Java, we'd have to write two different methods here: one for things of type <code>int</code>, and one for things of type <code>String</code>. Since this is Python, though, we don't have to do that. Instead, Python lets us say, essentially: "This function uses the <code>+</code> operator, so you can pass whatever object you want to the function, as long as the function supports the <code>+</code> operator".

To quote [https://groups.google.com/forum/?hl=en#!msg/comp.lang.python/CCs2oJdyuzc/NYjla5HKMOIJ Alex Martelli], one of the key people in the Python project,

<blockquote>
"[Don't] check whether it IS-a duck: check whether it QUACKS-like-a duck, WALKS-like-a duck, etc, etc, depending on exactly what subset of duck-like behaviour you need."
</blockquote>

</li>
</ol>

=== Basic Types ===

In Python, the basic scalar types are:

# <code>str</code> – a string.
# <code>int</code> – an integer object with unlimited digits.
# <code>bool</code> – a Boolean value.
# <code>float</code> – a floating point number; generally equivalent to <code>double</code> in Java.
# <code>bytes</code> – represents a collection of bytes; you're unlikely to use this often.

Casting is done in the C style - to parse an <code>int</code> from a string, for instance, you'd write <code>int("123")</code>.

=== Basic Control Flow ===
In Python, blocks of code are delineated using colons and indentation instead of curly braces. '''''That means that proper indentation is mandatory.''''' Every time you use a colon, you must indent one step further, and every time a block ends, you must unindent a step.

Conditional statements are done using the <code>if</code>, <code>elif</code>, and <code>else</code> operators, like in the example below - pay attention to the indentation:

<source lang="python">
cookies_left = 10
cake_slices_left = 3
if cookies_left > 10:
print("Lots of cookies!")
elif cookies_left > 8:
print("Plenty left!")
elif cookies_left == 5:
print("Halfway done!")
else:
if cake_slices_left == 3:
print("Lots of cake!")
elif cake_slices_left == 2:
print("One slice gone!")
else:
print("Little to no cake left!")
</source>

=== An Example Python Script ===

In my mind, there's no better way to learn Python than to be immersed in a simple example script.

<source lang="python">
print("Hello World")

fruits = ["apple", "banana", "cherry", "date"]
for fruit in fruits:
print(f"I always love to eat a fresh {fruit}")

# Map the fruits list over to a new list containing the length of the fruit strings:
fruit_size = [len(fruit) for fruit in fruits]

avg_fruit_size = sum(fruit_size) / len(fruit_size)
print(f"The average fruit string length is {avg_fruit_size:.2f}.")
</source>

Some things to notice:

* Printing is achieved using the <code>print()</code> function.
* Comments start with a pound symbol <code>#</code>.
* We can transform/map a list to a new list in just one line!

For some more examples, see [https://wiki.python.org/moin/SimplePrograms the Python wiki].

=== A Few Gotchas ===

Here are a few things you may not expect when starting out with Python:

<ol>

<li>
Strings can be delimited using either single quotes (<code>'</code>) or double quotes (<code>"</code>), so <code>'Python'</code> is the same as <code>"Python"</code. You can also use three sets of quotes (<code>'''</code> or <code>"""</code>) to delineate a multiple-line string, like so:
<source lang="python">
long_string = """This
is my
very long
multiple-line
string"""
</source>
</li>

<li>
To compare the equality of two objects, use the <code>==</code> operator. To compare the identity of two objects (i.e. whether or not they are literally the same object, at the same place in memory), use the <code>is</code> operator. These correspond, respectively to <code>.equals()</code> and <code>==</code> in Java.
</li>

<li>
The <code>/</code> operator performs floating-point division, not integer division, even when both its arguments are integers. If you want to do integer division, use the <code>//</code> operator. Let's look at an example:

<source lang="python">
9 / 10 == 0.9 # Floating-point division
9.0 / 10.0 == 0.9 # Floating-point division
9 // 10 == 0 # Integer division
9.0 // 10.0 == 0.0 # Integer division, even though the resulting value is a float
</source>
</li>

<li>
As discussed in the section [[#Python's_Type_System|Python's Type System]], you can't combine strings and numbers using the <code>+</code> operator. Instead, you'll have to use one of the following methods of string formatting:

<source lang="python">

# Technique 1 – printf-style Formatting
# This is a classic style of string formatting, used in many programming languages, including in Java's String.format.
"You scored %d out of %d!" % (score, questions)

# Technique 2 – str.format
"You scored {} out of {}!".format(score, questions)

# Technique 3 – f-strings
# These were only introduced in Python 3.6 but they're very convenient.
f"You scored {score} out of {questions}!"

# Technique 4 - String Concatenation
# This is fine for small things, but for more complicated stuff, use one of the other techniques.
"You scored " + str(score) + " out of " + str(questions) + "!"
</source>
</li>
</ol>

=== Functions ===

Define functions using the <code>def</code> keyword:

<source lang="python">
def hello(name):
print(f"Hello, {name}!")

</source>

Invoke functions using parentheses:
<source lang="python">
hello("Batman")
hello("Superman")
</source>

Functions can have optional arguments; however, these must come after any required arguments:
<source lang="python">
def hello(name="User"):
print(f"Hello, {name}!")

hello() # Prints "Hello, User!"
hello("Sarah") # Prints "Hello, Sarah!"
</source>

Functions are just regular objects in Python, meaning you can do stuff like this:

<source lang="python">
def hello(name="User"):
print(f"Hello, {name}!")

greeting = hello

greeting("Siwei") # Prints "Hello, Siwei!"
</source>

=== Collection Types ===
Python has a few basic, built-in collection types. They each have their own special use cases, but they share a lot of similarities. All built-in data structures in Python are zero-indexed, for instance.

To obtain the number of elements in a collection, use the <code>len()</code> function, like this:

<source lang="python">
pets = ['Dog', 'Cat', 'Fish'] # This is a list; you'll learn about them below.

len(pets) # Returns 3
</source>

To check if a collection contains an item, use the <code>in</code> operator:
<source lang="python">
pets = ['Dog', 'Cat', 'Fish'] # This is a list; you'll learn about them below.

'Dog' in pets # Returns True
</source>

Helpfully, the Python Software Foundation maintains a page containing the asymptotic complexities of important operations on major Python data structures. It's available [https://wiki.python.org/moin/TimeComplexity here].

==== Lists ====

Unlike languages like Java and C, Python's array-like type doesn't have fixed length. Instead, a <code>list</code> is a dynamic array (like Java's <code>ArrayList</code>) of objects of any type. Here's an example:

<source lang="python">
fruits = ["Apple", "Pear", "Orange"] # Lists can be creating by placing their items between square brackets

random_items = ['Apple', 12312, 2.0, [1, 2, 3]] # Lists can contain objects of different types - even other lists!

pets.append('Turtle') # Adds 'Turtle' to the end of pets
</source>

For the next few examples, we'll be using the following list:

<source lang="python">
pets = ['Dog', 'Cat', 'Fish', 'Turtle', 'Lizard', 'Snake']
</source>

To access or assign elements of a list, use the <code>[]</code> operator.

<source lang="python">
pets[0] # Returns 'Dog'
pets[1] = 'Cow' # Sets pets[1] to 'Cow'
pets[1] = 'Cat' # Sets pets[1] back to 'Cat'
</source>

You can also access or assign lists using negative indices, which will return elements starting from the end of the list:

<source lang="python">
pets[-1] # Returns 'Snake'
pets[-2] # Returns 'Lizard'
</source>

You can also use 'slice notation' to obtain or assign subsets of lists:
<source lang="python">
pets[start:end] # Returns items from index start to index end - 1.
pets[start:] # Returns items from index start to the end of the list, inclusive.
pets[:end] # Returns items from the beginning of the list to index end - 1.
pets[:] # Returns every item in the list
</source>

There's also a third, optional argument: <code>step</code>, which lets you jump over values:
<source lang="python">
pets[start:end:step] # Returns items from index start to index end - 1, jumping step values at a time

# Examples:
pets[1:5:2] # Returns items from index 1 to index 4, jumping 2 at a time, so ['Cat', 'Turtle']
pets[::3] # Returns all items in the list, jumping 3 at a time, so ['Dog', 'Turtle']
pets[::-1] # Returns all items in the list, jumping -1 at a time. This reverses the list, so ['Snake', 'Lizard', 'Turtle', 'Fish', 'Cat', 'Dog']
</source>

Lists have all the performance characteristics you'd expect of a dynamic array - constant-time indexing, amortized constant-time appends, and so on.

==== Tuples ====

Python has a special data type called <code>tuple</code>, which is exactly the same as a list except for the fact that it cannot be modified, so you can't append or replace items.

<source lang="python">
cities = ('St. Louis', 'Los Angeles', 'Seattle') # Tuples are defined using parentheses.
numbers = 1, 2, 3 # You can also omit the parentheses if it's unambiguous
single_item_tuple = (1,) # To make a tuple with only one item, put a comma after it
</source>

Tuples also enable you to have multiple return values from a function:

<source lang="python">
def compute_length(string):
str_len = len(string)
if str_len < 5:
return str_len, "short"
elif str_len < 40:
return str_len, "medium"
return str_len, "long"

length, description = compute_length("Four score and seven years ago")
print("The %s string is %d characters long." % (description, length))
</source>
The above example also demonstrates Python's if...elif...else conditional structure.

==== Dictionaries ====

Python has another datatype called a '''dictionary''' (or <code>dict</code>, for short), which are like ''Maps'' in Java, ''associative arrays'' in PHP, and ''object literals'' in JavaScript (coming up soon in Module 6). Essentially, they enable you to use any immutable object as the key in your data structure. <code>dict</code> objects can be created using either the <code>dict</code> function, or by placing items between curly braces, separating keys and values using colons:

<source lang="python">
fruits_in_bowl = {
'apple': 4,
'banana': 2,
'cherry': 0,
'date': 12
}

apple_count = fruits_in_bowl['apple'] # Equals 4

fruits_in_bowl['pear'] = 9 # Sets 'pear' in the dictionary to 9.

for fruit, num in fruits_in_bowl.items():
print("There are %d %s(s) in the bowl." % (num, fruit))
</source>
If you only want the keys from a dictionary, you can just iterate over it directly, like this:

<source lang="python">
for fruit in fruits_in_bowl:
print(fruit)
</source>
If you want only the values but not the keys from a dictionary, use <code>my_dictionary.values()</code>.

==== Sets ====
A <code>set</code> is an unordered collection of unique items, with constant-time membership checking.
<source lang="python">
fruits = {'Apple', 'Apple', 'Apple', 'Pear'} # The set removes duplicates, so it will only contain {'Apple', 'Pear'}
fruits = set(['Apple', 'Apple', 'Apple', 'Pear']) # This line transforms a list into a set
print('Apple' in fruits) # Constant-time!
</source>

=== Loops ===

In Python, while loops are written like this:

<source lang="python">
i = 0
while i < 10:
i += 1
</source>
For loops are written like this:

<source lang="python">
pets = ['Dog', 'Cat', 'Fish']

for pet in pets:
print(pet)
</source>
To iterate over a range of numbers, you can use the convenient <code>range</code> function, like so:

<source lang="python">
for i in range(20, 30): # If you omit the first argument to range, it's assumed to be zero.
print(i)
</source>
Note that <code>range</code> provides a closed-open range. That is to say, it is inclusive of its lower bound and exclusive of its upper bound. To be very explicit about it:

<source lang="python">
list(range(3, 6)) == [3, 4, 5]
</source>
Unlike in other languages you may know, the following is not good practice in Python:

<source lang="python">
pets = ['Dog', 'Cat', 'Fish']

# BAD PRACTICE. DO NOT USE.
for i in range(len(pets)):
pet = pets[i]
</source>
Instead, if you need to access both a variable and its index, use the <code>enumerate</code> function, which allows you to iterate through a group of items, along with their indexes, like so:

<source lang="python">
pets = ['Dog', 'Cat', 'Fish']

for index, pet in enumerate(pets):
print("%s at index %d"; % (pet, index))
</source>

=== Generator Expressions and Comprehensions ===

A generator is a special kind of object that, basically, represents a collection of items using a value and a function for generating the next value in the collection. In other words, it's a way of creating something that behaves like a list, but which only generates one value at a time, and discards a value when it's done with it. Say, for example, you wanted to do an operation on 10,000,000,000,000 numbers. You could put them all in a list, then iterate over the list, but that would take a lot of memory, plus you'd have to create and fill the entire list before beginning to actually work on your problem. Instead, you'd probably be better off using a generator; telling the computer, essentially: “The starting value is 0. When I ask for the next number in the collection, add 1 to current value and give me that.”

A generator expression is an expression that is evaluated to create a generator. They're super useful. Generator expressions can take two forms – they can be used with and without a condition:

<source lang="python">
(EXPRESSION for VARIABLE in ITERABLE) # Unconditional
(EXPRESSION for VARIABLE in ITERABLE if CONDITION) # Conditional
</source>
For our purposes, you can think of an iterable as anything you can do a for loop over. Let's take a look at a generator expression in use:

<source lang="python">
double_even_digits = (number * 2 for number in range(10) if number % 2 == 0)
</source>
That line says that <code>double_even_digits</code> is every even number between 0 and 10 multiplied by two. Simple enough, right? If we wanted to use all of the numbers, not just the even ones, we could simply remove the if statement at the end of the expression.

Here's the thing, though: if you were to print <code>double_even_digits</code>, instead of a nice bunch of numbers, you'd get something that looks like this:

<code><generator object <genexpr><code>at 0x107fc92b0></code>

That's because generators are lazy! They don't generate their values until those values are needed, and they discard values once they're no longer needed. As a result, '''you can only iterate over a generator once'''. In this case, you can't print out the whole generator, because it hasn't generated all the values yet. You can, however, iterate over the generator, and print its values one at a time, like so:

<source lang="python">
for number in double_even_digits:
print(number)
</source>
You can also make a list out of the generator, which will go through all the items in the generator and put them in a list, like so:

<source lang="python">
even_number_list = list(double_even_digits)
</source>
That's actually a great segue to the second topic of this section: comprehensions. A comprehension is just a prettier way to make lists, sets, and dicts out of a generator expressions.

<source lang="python">
# If you want a list:
list(i for i in range(10) if i % 2 == 0) # Don't do this
[i for i in range(10) if i % 2 == 0] # Use a list comprehension instead!

# If you want a set:
set(i for i in range(10) if i % 2 == 0) # Don't do this
{i for i in range(10) if i % 2 == 0} # Use a set comprehension instead!

# If you want a dict:
dict((i, i + 1) for i in range(10) if i % 2 == 0) # Don't do this
{i : i + 1 for i in range(10) if i % 2 == 0} # Use a dict comprehension instead!

# If you want a tuple:
tuple(i for i in range(10) if i % 2 == 0) # Unfortunately, there's no better way to do this
</source>
In general, generators and comprehensions should be used whenever possible - they're the fastest and easiest way to build collections. If you ever see yourself writing code like this:

<source lang="python">
# BAD PRACTICE! DO NOT USE!
digits = []
for digit in range(10):
digits.append(digit)
</source>
Don't do it! Instead, use a generator expression or comprehension, as appropriate. A good way to decide whether a generator expression or comprehension is better for this situation is that, if you're just going to be iterating over your collection once, you should use an generator expression. If not, use a comprehension.

=== Sorting ===

Sorting in Python is frequently performed using the <code>sorted</code> function, which takes two arguments: an iterable (anything you can do a for-loop over, including lists and tuples) and a function used to evaluate each item. If the function is omitted, Python will try to sort the lists by value.

The following example demonstrates using an inline function, which Python calls a ''lambda''.

<source lang="python">
fruits = ['apple', 'banana', 'cherry', 'date']

# sort the fruits by string length
new_fruits = sorted(fruits, key=lambda v: len(v) // 2)

print(new_fruits) # ['date', 'apple', 'banana', 'cherry']
</source>
Alternatively, you can sort a <code>list</code> using the <code>.sort</code> method. This is faster than calling <code>sorted</code>, but it modifies the list in-place and returns <code>None</code>.

<source lang="python">
fruits = ['apple', 'banana', 'cherry', 'date']
fruits.sort()
</source>
=== Import ===

If you want to use functions from other libraries (including ones that you install using pip), use <code>import</code>:

<source lang="python">
import time

current_time = time.localtime()
print(time.strftime('%a, %d %b %Y %H:%M:%S', current_time))
</source>
If you want to pull the functions out of their namespace, you can use <code>from ___ import ___</code> syntax:

<source lang="python">
from time import localtime, strftime

current_time = localtime()
print(strftime('%a, %d %b %Y %H:%M:%S', current_time))

# Be aware that this technique, although convenient, may cause unexpected behavior if the function names that you're pulling out of the namespace are already used for other purposes in Python.
</source>
=== File I/O ===

You can read an entire file into a variable like this:

<source lang="python">
f = open("example.txt")
file_contents = f.read()

f.close() # free up memory when we're finished with the file
</source>
A better option is to use a with-block, which handles opening and closing the file for you automatically:

<source lang="python">
with open("example.txt") as f:
file_contents = f.read()
</source>
You can read a file line-by-line like this:

<source lang="python">
with open("example.txt") as f:
for line in f:
print("Read line: %s" % line.rstrip())
</source>
You can write to a file like this:

<source lang="python">
with open("example.txt", "w") as f:
f.write("Hello\nWorld\n")
</source>
=== Command-Line Arguments ===

Command line arguments are accessible in the variable <code>sys.argv</code>.

The following example shows a program that expects a filename as its argument, and it prints a usage message if the argument is not present ([https://stackoverflow.com/questions/983201/python-and-sys-argv source]).

<source lang="python">
import sys, os

if len(sys.argv) < 2:
sys.exit("Usage: %s filename" % sys.argv[0])

filename = sys.argv[1]

if not os.path.exists(filename):
sys.exit("Error: File '%s' not found" % sys.argv[1])
</source>
=== Object-Oriented Programming ===

You can define and use a class like this:

<source lang="python">
class Food:
# constructor:
def __init__(self, name):
self.name = name

def format_name(self):
return "Gotta love to eat " + self.name

class Fruit(Food):
def format_name(self):
return Food.format_name(self) + " (fruit)"

fruit = Fruit("Cherry")
print(fruit.format_name())
print(Food.get_definition())
</source>
This is the same example as in [[PHP#Object-Oriented_Programming|the PHP guide]].

Some things to notice:

* Instance methods ''always'' take <code>self</code> as their first argument, followed by any number of additional parameters. This can be misleading for programmers familiar with other languages, because the number of arguments you feed to the method is actually ''one less than'' the number of declared parameters. Whenever you call a method on a class instance, that instance is implicitly fed into the explicitly-declared <code>self</code> parameter of the method.
*: Note that the <code>self</code> variable has the same purpose as the <code>this</code> variable in languages like PHP, Java, JavaScript, and C++.
*There is no need for a <code>new</code> keyword in Python.

= Footnotes =
# {{note|interpreted}}This is an oversimplification. If you're interested, here's a quick explanation of how: In CPython (the reference implementation of Python) programs are compiled to bytecode, an intermediate representation, which is then interpreted.
[[Category:Module 4]]

Python

2018-02-19T17:27:38Z

Alex: /* Functions */ Format strings

Languages like Java and C++ have lots of rules regarding variable types, syntax, return values, and so on. These can be cumbersome when you are trying to write short, quick scripts to perform tasks. This is where a ''scripting language'' comes into play.

'''Python''' is a language well-suited to rapid prototype development. It is generally an ''interpreted language'', which means that, generally speaking, a Python program is converted line by line into instructions for the computer to execute as the program runs, instead of having a separate compilation step beforehand {{ref|interpreted}}. The syntax is clean, and it is usually clear at first glance what is going on when you write in Python.

= Installation =

Python may already be installed on your system. To see whether or not it is, enter the command

<source lang="bash">
$ python --version
</source>
If it tells you a version of Python '''greater than or equal to 3.5''' then you're good to go. If not, you need to do a quick package install to get it up and running. Using yum, it's just <code>sudo yum install python35; sudo alternatives --set python /usr/bin/python3</code>.

==== Python 2 vs Python 3 ====

In 2008, a new version of Python – Python 3 – was released, with a number changes that made it incompatible with the previous version, Python 2. For several years, the Python community was slow to make the change to Python 3, but today, Python 3 is ''the'' standard for new code. The ''only'' reason to write Python 2 code today is because you have to work in an environment or with libraries that do not support Python 3, and that situation is becoming increasingly rare.

'''For CSE 330 (and this guide), you ''must'' use Python 3.5 or greater.'''

=== Pip ===

Linux distributions have package managers like ''Apt'', ''Yum'', and ''YaST''. PHP has a package manager named ''PEAR''. It's now time to introduce Python's leading package manager: '''pip'''.

You need to install Pip from Yum before you can use it. The package is called <code>python-pip</code>.

Once you have pip installed, you can use it to install Python packages. Use the <code>pip-python</code> command:

<source lang="bash">
$ pip-python install package_name # RHEL
$ pip install package_name # Debian
</source>
= Running Python =

There are two common ways to run Python code: via the console, and via a Python script file.

=== The Python Console ===

The Python console enables you to experiment with code without opening a text editor. To enter the Python console, simply type the ''python'' command at the terminal:

<source lang="bash">
$ python
</source>
To leave the interactive console, either type <code>quit()</code> or press <code>Ctrl-D</code> (on both Mac and Windows).

=== Python Script Files ===

You can also save Python script files for later use. The extension for Python scripts is <code>*.py</code>. To run a script file, simply feed its path as an argument to the <code>python</code> command in Terminal:

<source lang="bash">
$ python my_script.py
</source>

= Python Syntax and Language Components =

This section contains a very brief overview of Python syntax. For a more comprehensive introduction, see [http://docs.python.org/tutorial/ the Python docs].

=== Python's Type System ===

Python is a dynamically-typed, strongly-typed, and duck-typed language. What does that mean? Well, let's take those categories one by one:

<ol>
<li>
'''Dynamic typing''', in contrast to ''static typing'' means that the types of objects can be changed. In Java, for instance, if you tried to write the following code:

<source lang="java">
int c = 2;
c = "fish";
</source>

Your code would fail to compile, because the Java compiler wouldn't allow you to change the type of the variable <code>c</code> from <code>int</code> to <code>String</code>.

Python, however, is just fine with that. You can write:

<source lang="python">
c = 2
c = "fish"
</source>

And Python will happily do what you ask.
</li>

<li>
'''Strong typing''', in contrast to ''weak typing'', means, roughly, that a language won't implicitly convert types for you. So far, you've used a lot of PHP, which is very weakly typed. For example:

<source lang="php">
echo "10" . 2;
</source>

In PHP, this works just fine. The PHP interpreter sees that <code>2</code> is an int, and silently converts it to a string for you, so that <code>"10". 2</code> equals <code>"102"</code>. The problem with weak typing is that it can make it unclear to the programmer why things are happening the way they are. For instance, in PHP, the expression <code>"10" == 10</code> is true, which can be less than obvious. Python, however, tries to disallow that sort of thing:

<source lang="python">
"10" + "10" # Allowed – concatenates the two strings.
10 + 10 # Allowed – adds the two ints.
"10" + 10 # Not allowed – raises a TypeError
</source>

Perhaps the one exception to this rule is the relationship between numeric types; it's perfectly fine to add a float to an int, for example.
</li>

<li>
'''Duck-typing''' is a little bit different than the other categories, because it doesn't really have a direct opposite. Essentially, duck-typing is the philosophy that "If it walks like a duck, and quacks like a duck, it's a duck." In programming terms, that means that we often don't care what type an object is, as long as it can do the things we ask.

Let's look at an example:

<source lang="python">
# This function doubles the value it's passed.
def double(thing):
return thing + thing
double(10) # Returns 20
double("fish") # Returns "fishfish";
</source>

If this were Java, we'd have to write two different methods here: one for things of type <code>int</code>, and one for things of type <code>String</code>. Since this is Python, though, we don't have to do that. Instead, Python lets us say, essentially: "This function uses the <code>+</code> operator, so you can pass whatever object you want to the function, as long as the function supports the <code>+</code> operator".

To quote [https://groups.google.com/forum/?hl=en#!msg/comp.lang.python/CCs2oJdyuzc/NYjla5HKMOIJ Alex Martelli], one of the key people in the Python project,

<blockquote>
"[Don't] check whether it IS-a duck: check whether it QUACKS-like-a duck, WALKS-like-a duck, etc, etc, depending on exactly what subset of duck-like behaviour you need."
</blockquote>

</li>
</ol>

=== Basic Types ===

In Python, the basic scalar types are:

# <code>str</code> – a string.
# <code>int</code> – an integer object with unlimited digits.
# <code>bool</code> – a Boolean value.
# <code>float</code> – a floating point number; generally equivalent to <code>double</code> in Java.
# <code>bytes</code> – represents a collection of bytes; you're unlikely to use this often.

Casting is done in the C style - to parse an <code>int</code> from a string, for instance, you'd write <code>int("123")</code>.

=== Basic Control Flow ===
In Python, blocks of code are delineated using colons and indentation instead of curly braces. '''''That means that proper indentation is mandatory.''''' Every time you use a colon, you must indent one step further, and every time a block ends, you must unindent a step.

Conditional statements are done using the <code>if</code>, <code>elif</code>, and <code>else</code> operators, like in the example below - pay attention to the indentation:

<source lang="python">
cookies_left = 10
cake_slices_left = 3
if cookies_left > 10:
print("Lots of cookies!")
elif cookies_left > 8:
print("Plenty left!")
elif cookies_left == 5:
print("Halfway done!")
else:
if cake_slices_left == 3:
print("Lots of cake!")
elif cake_slices_left == 2:
print("One slice gone!")
else:
print("Little to no cake left!")
</source>

=== An Example Python Script ===

In my mind, there's no better way to learn Python than to be immersed in a simple example script.

<source lang="python">
print("Hello World")

fruits = ["apple", "banana", "cherry", "date"]
for fruit in fruits:
print(f"I always love to eat a fresh {fruit}")

# Map the fruits list over to a new list containing the length of the fruit strings:
fruit_size = [len(fruit) for fruit in fruits]

avg_fruit_size = sum(fruit_size) / len(fruit_size)
print(f"The average fruit string length is {avg_fruit_size:.2f}.")
</source>

Some things to notice:

* Printing is achieved using the <code>print()</code> function.
* Comments start with a pound symbol <code>#</code>.
* We can transform/map a list to a new list in just one line!

For some more examples, see [https://wiki.python.org/moin/SimplePrograms the Python wiki].

=== A Few Gotchas ===

Here are a few things you may not expect when starting out with Python:

<ol>

<li>
Strings can be delimited using either single quotes (<code>'</code>) or double quotes (<code>"</code>), so <code>'Python'</code> is the same as <code>"Python"</code. You can also use three sets of quotes (<code>'''</code> or <code>"""</code>) to delineate a multiple-line string, like so:
<source lang="python">
long_string = """This
is my
very long
multiple-line
string"""
</source>
</li>

<li>
To compare the equality of two objects, use the <code>==</code> operator. To compare the identity of two objects (i.e. whether or not they are literally the same object, at the same place in memory), use the <code>is</code> operator. These correspond, respectively to <code>.equals()</code> and <code>==</code> in Java.
</li>

<li>
The <code>/</code> operator performs floating-point division, not integer division, even when both its arguments are integers. If you want to do integer division, use the <code>//</code> operator. Let's look at an example:

<source lang="python">
9 / 10 == 0.9 # Floating-point division
9.0 / 10.0 == 0.9 # Floating-point division
9 // 10 == 0 # Integer division
9.0 // 10.0 == 0.0 # Integer division, even though the resulting value is a float
</source>
</li>

<li>
As discussed in the section [[#Python's_Type_System|Python's Type System]], you can't combine strings and numbers using the <code>+</code> operator. Instead, you'll have to use one of the following methods of string formatting:

<source lang="python">

# Technique 1 – printf-style Formatting
# This is a classic style of string formatting, used in many programming languages, including in Java's String.format.
"You scored %d out of %d!" % (score, questions)

# Technique 2 – str.format
"You scored {} out of {}!".format(score, questions)

# Technique 3 – f-strings
# These were only introduced in Python 3.6 but they're very convenient.
f"You scored {score} out of {questions}!"

# Technique 4 - String Concatenation
# This is fine for small things, but for more complicated stuff, use one of the other techniques.
"You scored " + str(score) + " out of " + str(questions) + "!"
</source>
</li>
</ol>

=== Functions ===

Define functions using the <code>def</code> keyword:

<source lang="python">
def hello(name):
print(f"Hello, {name}!")

</source>

Invoke functions using parentheses:
<source lang="python">
hello("Batman")
hello("Superman")
</source>

Functions can have optional arguments; however, these must come after any required arguments:
<source lang="python">
def hello(name="User"):
print(f"Hello, {name}!")

hello() # Prints "Hello, User!"
hello("Sarah") # Prints "Hello, Sarah!"
</source>

Functions are just regular objects in Python, meaning you can do stuff like this:

<source lang="python">
def hello(name="User"):
print("Hello, {name}!")

greeting = hello

greeting("Siwei") # Prints "Hello, Siwei!"
</source>

=== Collection Types ===
Python has a few basic, built-in collection types. They each have their own special use cases, but they share a lot of similarities. All built-in data structures in Python are zero-indexed, for instance.

To obtain the number of elements in a collection, use the <code>len()</code> function, like this:

<source lang="python">
pets = ['Dog', 'Cat', 'Fish'] # This is a list; you'll learn about them below.

len(pets) # Returns 3
</source>

To check if a collection contains an item, use the <code>in</code> operator:
<source lang="python">
pets = ['Dog', 'Cat', 'Fish'] # This is a list; you'll learn about them below.

'Dog' in pets # Returns True
</source>

Helpfully, the Python Software Foundation maintains a page containing the asymptotic complexities of important operations on major Python data structures. It's available [https://wiki.python.org/moin/TimeComplexity here].

==== Lists ====

Unlike languages like Java and C, Python's array-like type doesn't have fixed length. Instead, a <code>list</code> is a dynamic array (like Java's <code>ArrayList</code>) of objects of any type. Here's an example:

<source lang="python">
fruits = ["Apple", "Pear", "Orange"] # Lists can be creating by placing their items between square brackets

random_items = ['Apple', 12312, 2.0, [1, 2, 3]] # Lists can contain objects of different types - even other lists!

pets.append('Turtle') # Adds 'Turtle' to the end of pets
</source>

For the next few examples, we'll be using the following list:

<source lang="python">
pets = ['Dog', 'Cat', 'Fish', 'Turtle', 'Lizard', 'Snake']
</source>

To access or assign elements of a list, use the <code>[]</code> operator.

<source lang="python">
pets[0] # Returns 'Dog'
pets[1] = 'Cow' # Sets pets[1] to 'Cow'
pets[1] = 'Cat' # Sets pets[1] back to 'Cat'
</source>

You can also access or assign lists using negative indices, which will return elements starting from the end of the list:

<source lang="python">
pets[-1] # Returns 'Snake'
pets[-2] # Returns 'Lizard'
</source>

You can also use 'slice notation' to obtain or assign subsets of lists:
<source lang="python">
pets[start:end] # Returns items from index start to index end - 1.
pets[start:] # Returns items from index start to the end of the list, inclusive.
pets[:end] # Returns items from the beginning of the list to index end - 1.
pets[:] # Returns every item in the list
</source>

There's also a third, optional argument: <code>step</code>, which lets you jump over values:
<source lang="python">
pets[start:end:step] # Returns items from index start to index end - 1, jumping step values at a time

# Examples:
pets[1:5:2] # Returns items from index 1 to index 4, jumping 2 at a time, so ['Cat', 'Turtle']
pets[::3] # Returns all items in the list, jumping 3 at a time, so ['Dog', 'Turtle']
pets[::-1] # Returns all items in the list, jumping -1 at a time. This reverses the list, so ['Snake', 'Lizard', 'Turtle', 'Fish', 'Cat', 'Dog']
</source>

Lists have all the performance characteristics you'd expect of a dynamic array - constant-time indexing, amortized constant-time appends, and so on.

==== Tuples ====

Python has a special data type called <code>tuple</code>, which is exactly the same as a list except for the fact that it cannot be modified, so you can't append or replace items.

<source lang="python">
cities = ('St. Louis', 'Los Angeles', 'Seattle') # Tuples are defined using parentheses.
numbers = 1, 2, 3 # You can also omit the parentheses if it's unambiguous
single_item_tuple = (1,) # To make a tuple with only one item, put a comma after it
</source>

Tuples also enable you to have multiple return values from a function:

<source lang="python">
def compute_length(string):
str_len = len(string)
if str_len < 5:
return str_len, "short"
elif str_len < 40:
return str_len, "medium"
return str_len, "long"

length, description = compute_length("Four score and seven years ago")
print("The %s string is %d characters long." % (description, length))
</source>
The above example also demonstrates Python's if...elif...else conditional structure.

==== Dictionaries ====

Python has another datatype called a '''dictionary''' (or <code>dict</code>, for short), which are like ''Maps'' in Java, ''associative arrays'' in PHP, and ''object literals'' in JavaScript (coming up soon in Module 6). Essentially, they enable you to use any immutable object as the key in your data structure. <code>dict</code> objects can be created using either the <code>dict</code> function, or by placing items between curly braces, separating keys and values using colons:

<source lang="python">
fruits_in_bowl = {
'apple': 4,
'banana': 2,
'cherry': 0,
'date': 12
}

apple_count = fruits_in_bowl['apple'] # Equals 4

fruits_in_bowl['pear'] = 9 # Sets 'pear' in the dictionary to 9.

for fruit, num in fruits_in_bowl.items():
print("There are %d %s(s) in the bowl." % (num, fruit))
</source>
If you only want the keys from a dictionary, you can just iterate over it directly, like this:

<source lang="python">
for fruit in fruits_in_bowl:
print(fruit)
</source>
If you want only the values but not the keys from a dictionary, use <code>my_dictionary.values()</code>.

==== Sets ====
A <code>set</code> is an unordered collection of unique items, with constant-time membership checking.
<source lang="python">
fruits = {'Apple', 'Apple', 'Apple', 'Pear'} # The set removes duplicates, so it will only contain {'Apple', 'Pear'}
fruits = set(['Apple', 'Apple', 'Apple', 'Pear']) # This line transforms a list into a set
print('Apple' in fruits) # Constant-time!
</source>

=== Loops ===

In Python, while loops are written like this:

<source lang="python">
i = 0
while i < 10:
i += 1
</source>
For loops are written like this:

<source lang="python">
pets = ['Dog', 'Cat', 'Fish']

for pet in pets:
print(pet)
</source>
To iterate over a range of numbers, you can use the convenient <code>range</code> function, like so:

<source lang="python">
for i in range(20, 30): # If you omit the first argument to range, it's assumed to be zero.
print(i)
</source>
Note that <code>range</code> provides a closed-open range. That is to say, it is inclusive of its lower bound and exclusive of its upper bound. To be very explicit about it:

<source lang="python">
list(range(3, 6)) == [3, 4, 5]
</source>
Unlike in other languages you may know, the following is not good practice in Python:

<source lang="python">
pets = ['Dog', 'Cat', 'Fish']

# BAD PRACTICE. DO NOT USE.
for i in range(len(pets)):
pet = pets[i]
</source>
Instead, if you need to access both a variable and its index, use the <code>enumerate</code> function, which allows you to iterate through a group of items, along with their indexes, like so:

<source lang="python">
pets = ['Dog', 'Cat', 'Fish']

for index, pet in enumerate(pets):
print("%s at index %d"; % (pet, index))
</source>

=== Generator Expressions and Comprehensions ===

A generator is a special kind of object that, basically, represents a collection of items using a value and a function for generating the next value in the collection. In other words, it's a way of creating something that behaves like a list, but which only generates one value at a time, and discards a value when it's done with it. Say, for example, you wanted to do an operation on 10,000,000,000,000 numbers. You could put them all in a list, then iterate over the list, but that would take a lot of memory, plus you'd have to create and fill the entire list before beginning to actually work on your problem. Instead, you'd probably be better off using a generator; telling the computer, essentially: “The starting value is 0. When I ask for the next number in the collection, add 1 to current value and give me that.”

A generator expression is an expression that is evaluated to create a generator. They're super useful. Generator expressions can take two forms – they can be used with and without a condition:

<source lang="python">
(EXPRESSION for VARIABLE in ITERABLE) # Unconditional
(EXPRESSION for VARIABLE in ITERABLE if CONDITION) # Conditional
</source>
For our purposes, you can think of an iterable as anything you can do a for loop over. Let's take a look at a generator expression in use:

<source lang="python">
double_even_digits = (number * 2 for number in range(10) if number % 2 == 0)
</source>
That line says that <code>double_even_digits</code> is every even number between 0 and 10 multiplied by two. Simple enough, right? If we wanted to use all of the numbers, not just the even ones, we could simply remove the if statement at the end of the expression.

Here's the thing, though: if you were to print <code>double_even_digits</code>, instead of a nice bunch of numbers, you'd get something that looks like this:

<code><generator object <genexpr><code>at 0x107fc92b0></code>

That's because generators are lazy! They don't generate their values until those values are needed, and they discard values once they're no longer needed. As a result, '''you can only iterate over a generator once'''. In this case, you can't print out the whole generator, because it hasn't generated all the values yet. You can, however, iterate over the generator, and print its values one at a time, like so:

<source lang="python">
for number in double_even_digits:
print(number)
</source>
You can also make a list out of the generator, which will go through all the items in the generator and put them in a list, like so:

<source lang="python">
even_number_list = list(double_even_digits)
</source>
That's actually a great segue to the second topic of this section: comprehensions. A comprehension is just a prettier way to make lists, sets, and dicts out of a generator expressions.

<source lang="python">
# If you want a list:
list(i for i in range(10) if i % 2 == 0) # Don't do this
[i for i in range(10) if i % 2 == 0] # Use a list comprehension instead!

# If you want a set:
set(i for i in range(10) if i % 2 == 0) # Don't do this
{i for i in range(10) if i % 2 == 0} # Use a set comprehension instead!

# If you want a dict:
dict((i, i + 1) for i in range(10) if i % 2 == 0) # Don't do this
{i : i + 1 for i in range(10) if i % 2 == 0} # Use a dict comprehension instead!

# If you want a tuple:
tuple(i for i in range(10) if i % 2 == 0) # Unfortunately, there's no better way to do this
</source>
In general, generators and comprehensions should be used whenever possible - they're the fastest and easiest way to build collections. If you ever see yourself writing code like this:

<source lang="python">
# BAD PRACTICE! DO NOT USE!
digits = []
for digit in range(10):
digits.append(digit)
</source>
Don't do it! Instead, use a generator expression or comprehension, as appropriate. A good way to decide whether a generator expression or comprehension is better for this situation is that, if you're just going to be iterating over your collection once, you should use an generator expression. If not, use a comprehension.

=== Sorting ===

Sorting in Python is frequently performed using the <code>sorted</code> function, which takes two arguments: an iterable (anything you can do a for-loop over, including lists and tuples) and a function used to evaluate each item. If the function is omitted, Python will try to sort the lists by value.

The following example demonstrates using an inline function, which Python calls a ''lambda''.

<source lang="python">
fruits = ['apple', 'banana', 'cherry', 'date']

# sort the fruits by string length
new_fruits = sorted(fruits, key=lambda v: len(v) // 2)

print(new_fruits) # ['date', 'apple', 'banana', 'cherry']
</source>
Alternatively, you can sort a <code>list</code> using the <code>.sort</code> method. This is faster than calling <code>sorted</code>, but it modifies the list in-place and returns <code>None</code>.

<source lang="python">
fruits = ['apple', 'banana', 'cherry', 'date']
fruits.sort()
</source>
=== Import ===

If you want to use functions from other libraries (including ones that you install using pip), use <code>import</code>:

<source lang="python">
import time

current_time = time.localtime()
print(time.strftime('%a, %d %b %Y %H:%M:%S', current_time))
</source>
If you want to pull the functions out of their namespace, you can use <code>from ___ import ___</code> syntax:

<source lang="python">
from time import localtime, strftime

current_time = localtime()
print(strftime('%a, %d %b %Y %H:%M:%S', current_time))

# Be aware that this technique, although convenient, may cause unexpected behavior if the function names that you're pulling out of the namespace are already used for other purposes in Python.
</source>
=== File I/O ===

You can read an entire file into a variable like this:

<source lang="python">
f = open("example.txt")
file_contents = f.read()

f.close() # free up memory when we're finished with the file
</source>
A better option is to use a with-block, which handles opening and closing the file for you automatically:

<source lang="python">
with open("example.txt") as f:
file_contents = f.read()
</source>
You can read a file line-by-line like this:

<source lang="python">
with open("example.txt") as f:
for line in f:
print("Read line: %s" % line.rstrip())
</source>
You can write to a file like this:

<source lang="python">
with open("example.txt", "w") as f:
f.write("Hello\nWorld\n")
</source>
=== Command-Line Arguments ===

Command line arguments are accessible in the variable <code>sys.argv</code>.

The following example shows a program that expects a filename as its argument, and it prints a usage message if the argument is not present ([https://stackoverflow.com/questions/983201/python-and-sys-argv source]).

<source lang="python">
import sys, os

if len(sys.argv) < 2:
sys.exit("Usage: %s filename" % sys.argv[0])

filename = sys.argv[1]

if not os.path.exists(filename):
sys.exit("Error: File '%s' not found" % sys.argv[1])
</source>
=== Object-Oriented Programming ===

You can define and use a class like this:

<source lang="python">
class Food:
# constructor:
def __init__(self, name):
self.name = name

def format_name(self):
return "Gotta love to eat " + self.name

class Fruit(Food):
def format_name(self):
return Food.format_name(self) + " (fruit)"

fruit = Fruit("Cherry")
print(fruit.format_name())
print(Food.get_definition())
</source>
This is the same example as in [[PHP#Object-Oriented_Programming|the PHP guide]].

Some things to notice:

* Instance methods ''always'' take <code>self</code> as their first argument, followed by any number of additional parameters. This can be misleading for programmers familiar with other languages, because the number of arguments you feed to the method is actually ''one less than'' the number of declared parameters. Whenever you call a method on a class instance, that instance is implicitly fed into the explicitly-declared <code>self</code> parameter of the method.
*: Note that the <code>self</code> variable has the same purpose as the <code>this</code> variable in languages like PHP, Java, JavaScript, and C++.
*There is no need for a <code>new</code> keyword in Python.

= Footnotes =
# {{note|interpreted}}This is an oversimplification. If you're interested, here's a quick explanation of how: In CPython (the reference implementation of Python) programs are compiled to bytecode, an intermediate representation, which is then interpreted.
[[Category:Module 4]]

Python

2018-02-19T17:25:53Z

Alex: /* An Example Python Script */ Updated format strings

Languages like Java and C++ have lots of rules regarding variable types, syntax, return values, and so on. These can be cumbersome when you are trying to write short, quick scripts to perform tasks. This is where a ''scripting language'' comes into play.

'''Python''' is a language well-suited to rapid prototype development. It is generally an ''interpreted language'', which means that, generally speaking, a Python program is converted line by line into instructions for the computer to execute as the program runs, instead of having a separate compilation step beforehand {{ref|interpreted}}. The syntax is clean, and it is usually clear at first glance what is going on when you write in Python.

= Installation =

Python may already be installed on your system. To see whether or not it is, enter the command

<source lang="bash">
$ python --version
</source>
If it tells you a version of Python '''greater than or equal to 3.5''' then you're good to go. If not, you need to do a quick package install to get it up and running. Using yum, it's just <code>sudo yum install python35; sudo alternatives --set python /usr/bin/python3</code>.

==== Python 2 vs Python 3 ====

In 2008, a new version of Python – Python 3 – was released, with a number changes that made it incompatible with the previous version, Python 2. For several years, the Python community was slow to make the change to Python 3, but today, Python 3 is ''the'' standard for new code. The ''only'' reason to write Python 2 code today is because you have to work in an environment or with libraries that do not support Python 3, and that situation is becoming increasingly rare.

'''For CSE 330 (and this guide), you ''must'' use Python 3.5 or greater.'''

=== Pip ===

Linux distributions have package managers like ''Apt'', ''Yum'', and ''YaST''. PHP has a package manager named ''PEAR''. It's now time to introduce Python's leading package manager: '''pip'''.

You need to install Pip from Yum before you can use it. The package is called <code>python-pip</code>.

Once you have pip installed, you can use it to install Python packages. Use the <code>pip-python</code> command:

<source lang="bash">
$ pip-python install package_name # RHEL
$ pip install package_name # Debian
</source>
= Running Python =

There are two common ways to run Python code: via the console, and via a Python script file.

=== The Python Console ===

The Python console enables you to experiment with code without opening a text editor. To enter the Python console, simply type the ''python'' command at the terminal:

<source lang="bash">
$ python
</source>
To leave the interactive console, either type <code>quit()</code> or press <code>Ctrl-D</code> (on both Mac and Windows).

=== Python Script Files ===

You can also save Python script files for later use. The extension for Python scripts is <code>*.py</code>. To run a script file, simply feed its path as an argument to the <code>python</code> command in Terminal:

<source lang="bash">
$ python my_script.py
</source>

= Python Syntax and Language Components =

This section contains a very brief overview of Python syntax. For a more comprehensive introduction, see [http://docs.python.org/tutorial/ the Python docs].

=== Python's Type System ===

Python is a dynamically-typed, strongly-typed, and duck-typed language. What does that mean? Well, let's take those categories one by one:

<ol>
<li>
'''Dynamic typing''', in contrast to ''static typing'' means that the types of objects can be changed. In Java, for instance, if you tried to write the following code:

<source lang="java">
int c = 2;
c = "fish";
</source>

Your code would fail to compile, because the Java compiler wouldn't allow you to change the type of the variable <code>c</code> from <code>int</code> to <code>String</code>.

Python, however, is just fine with that. You can write:

<source lang="python">
c = 2
c = "fish"
</source>

And Python will happily do what you ask.
</li>

<li>
'''Strong typing''', in contrast to ''weak typing'', means, roughly, that a language won't implicitly convert types for you. So far, you've used a lot of PHP, which is very weakly typed. For example:

<source lang="php">
echo "10" . 2;
</source>

In PHP, this works just fine. The PHP interpreter sees that <code>2</code> is an int, and silently converts it to a string for you, so that <code>"10". 2</code> equals <code>"102"</code>. The problem with weak typing is that it can make it unclear to the programmer why things are happening the way they are. For instance, in PHP, the expression <code>"10" == 10</code> is true, which can be less than obvious. Python, however, tries to disallow that sort of thing:

<source lang="python">
"10" + "10" # Allowed – concatenates the two strings.
10 + 10 # Allowed – adds the two ints.
"10" + 10 # Not allowed – raises a TypeError
</source>

Perhaps the one exception to this rule is the relationship between numeric types; it's perfectly fine to add a float to an int, for example.
</li>

<li>
'''Duck-typing''' is a little bit different than the other categories, because it doesn't really have a direct opposite. Essentially, duck-typing is the philosophy that "If it walks like a duck, and quacks like a duck, it's a duck." In programming terms, that means that we often don't care what type an object is, as long as it can do the things we ask.

Let's look at an example:

<source lang="python">
# This function doubles the value it's passed.
def double(thing):
return thing + thing
double(10) # Returns 20
double("fish") # Returns "fishfish";
</source>

If this were Java, we'd have to write two different methods here: one for things of type <code>int</code>, and one for things of type <code>String</code>. Since this is Python, though, we don't have to do that. Instead, Python lets us say, essentially: "This function uses the <code>+</code> operator, so you can pass whatever object you want to the function, as long as the function supports the <code>+</code> operator".

To quote [https://groups.google.com/forum/?hl=en#!msg/comp.lang.python/CCs2oJdyuzc/NYjla5HKMOIJ Alex Martelli], one of the key people in the Python project,

<blockquote>
"[Don't] check whether it IS-a duck: check whether it QUACKS-like-a duck, WALKS-like-a duck, etc, etc, depending on exactly what subset of duck-like behaviour you need."
</blockquote>

</li>
</ol>

=== Basic Types ===

In Python, the basic scalar types are:

# <code>str</code> – a string.
# <code>int</code> – an integer object with unlimited digits.
# <code>bool</code> – a Boolean value.
# <code>float</code> – a floating point number; generally equivalent to <code>double</code> in Java.
# <code>bytes</code> – represents a collection of bytes; you're unlikely to use this often.

Casting is done in the C style - to parse an <code>int</code> from a string, for instance, you'd write <code>int("123")</code>.

=== Basic Control Flow ===
In Python, blocks of code are delineated using colons and indentation instead of curly braces. '''''That means that proper indentation is mandatory.''''' Every time you use a colon, you must indent one step further, and every time a block ends, you must unindent a step.

Conditional statements are done using the <code>if</code>, <code>elif</code>, and <code>else</code> operators, like in the example below - pay attention to the indentation:

<source lang="python">
cookies_left = 10
cake_slices_left = 3
if cookies_left > 10:
print("Lots of cookies!")
elif cookies_left > 8:
print("Plenty left!")
elif cookies_left == 5:
print("Halfway done!")
else:
if cake_slices_left == 3:
print("Lots of cake!")
elif cake_slices_left == 2:
print("One slice gone!")
else:
print("Little to no cake left!")
</source>

=== An Example Python Script ===

In my mind, there's no better way to learn Python than to be immersed in a simple example script.

<source lang="python">
print("Hello World")

fruits = ["apple", "banana", "cherry", "date"]
for fruit in fruits:
print(f"I always love to eat a fresh {fruit}")

# Map the fruits list over to a new list containing the length of the fruit strings:
fruit_size = [len(fruit) for fruit in fruits]

avg_fruit_size = sum(fruit_size) / len(fruit_size)
print(f"The average fruit string length is {avg_fruit_size:.2f}.")
</source>

Some things to notice:

* Printing is achieved using the <code>print()</code> function.
* Comments start with a pound symbol <code>#</code>.
* We can transform/map a list to a new list in just one line!

For some more examples, see [https://wiki.python.org/moin/SimplePrograms the Python wiki].

=== A Few Gotchas ===

Here are a few things you may not expect when starting out with Python:

<ol>

<li>
Strings can be delimited using either single quotes (<code>'</code>) or double quotes (<code>"</code>), so <code>'Python'</code> is the same as <code>"Python"</code. You can also use three sets of quotes (<code>'''</code> or <code>"""</code>) to delineate a multiple-line string, like so:
<source lang="python">
long_string = """This
is my
very long
multiple-line
string"""
</source>
</li>

<li>
To compare the equality of two objects, use the <code>==</code> operator. To compare the identity of two objects (i.e. whether or not they are literally the same object, at the same place in memory), use the <code>is</code> operator. These correspond, respectively to <code>.equals()</code> and <code>==</code> in Java.
</li>

<li>
The <code>/</code> operator performs floating-point division, not integer division, even when both its arguments are integers. If you want to do integer division, use the <code>//</code> operator. Let's look at an example:

<source lang="python">
9 / 10 == 0.9 # Floating-point division
9.0 / 10.0 == 0.9 # Floating-point division
9 // 10 == 0 # Integer division
9.0 // 10.0 == 0.0 # Integer division, even though the resulting value is a float
</source>
</li>

<li>
As discussed in the section [[#Python's_Type_System|Python's Type System]], you can't combine strings and numbers using the <code>+</code> operator. Instead, you'll have to use one of the following methods of string formatting:

<source lang="python">

# Technique 1 – printf-style Formatting
# This is a classic style of string formatting, used in many programming languages, including in Java's String.format.
"You scored %d out of %d!" % (score, questions)

# Technique 2 – str.format
"You scored {} out of {}!".format(score, questions)

# Technique 3 – f-strings
# These were only introduced in Python 3.6 but they're very convenient.
f"You scored {score} out of {questions}!"

# Technique 4 - String Concatenation
# This is fine for small things, but for more complicated stuff, use one of the other techniques.
"You scored " + str(score) + " out of " + str(questions) + "!"
</source>
</li>
</ol>

=== Functions ===

Define functions using the <code>def</code> keyword:

<source lang="python">
def hello(name):
print("Hello, %s!" % name)

</source>

Invoke functions using parentheses:
<source lang="python">
hello("Batman")
hello("Superman")
</source>

Functions can have optional arguments; however, these must come after any required arguments:
<source lang="python">
def hello(name="User"):
print("Hello, %s!" % name)

hello() # Prints "Hello, User!"
hello("Sarah") # Prints "Hello, Sarah!"
</source>

Functions are just regular objects in Python, meaning you can do stuff like this:

<source lang="python">
def hello(name="User"):
print("Hello, %s!" % name)

greeting = hello

greeting("Siwei") # Prints "Hello, Siwei!"
</source>

=== Collection Types ===
Python has a few basic, built-in collection types. They each have their own special use cases, but they share a lot of similarities. All built-in data structures in Python are zero-indexed, for instance.

To obtain the number of elements in a collection, use the <code>len()</code> function, like this:

<source lang="python">
pets = ['Dog', 'Cat', 'Fish'] # This is a list; you'll learn about them below.

len(pets) # Returns 3
</source>

To check if a collection contains an item, use the <code>in</code> operator:
<source lang="python">
pets = ['Dog', 'Cat', 'Fish'] # This is a list; you'll learn about them below.

'Dog' in pets # Returns True
</source>

Helpfully, the Python Software Foundation maintains a page containing the asymptotic complexities of important operations on major Python data structures. It's available [https://wiki.python.org/moin/TimeComplexity here].

==== Lists ====

Unlike languages like Java and C, Python's array-like type doesn't have fixed length. Instead, a <code>list</code> is a dynamic array (like Java's <code>ArrayList</code>) of objects of any type. Here's an example:

<source lang="python">
fruits = ["Apple", "Pear", "Orange"] # Lists can be creating by placing their items between square brackets

random_items = ['Apple', 12312, 2.0, [1, 2, 3]] # Lists can contain objects of different types - even other lists!

pets.append('Turtle') # Adds 'Turtle' to the end of pets
</source>

For the next few examples, we'll be using the following list:

<source lang="python">
pets = ['Dog', 'Cat', 'Fish', 'Turtle', 'Lizard', 'Snake']
</source>

To access or assign elements of a list, use the <code>[]</code> operator.

<source lang="python">
pets[0] # Returns 'Dog'
pets[1] = 'Cow' # Sets pets[1] to 'Cow'
pets[1] = 'Cat' # Sets pets[1] back to 'Cat'
</source>

You can also access or assign lists using negative indices, which will return elements starting from the end of the list:

<source lang="python">
pets[-1] # Returns 'Snake'
pets[-2] # Returns 'Lizard'
</source>

You can also use 'slice notation' to obtain or assign subsets of lists:
<source lang="python">
pets[start:end] # Returns items from index start to index end - 1.
pets[start:] # Returns items from index start to the end of the list, inclusive.
pets[:end] # Returns items from the beginning of the list to index end - 1.
pets[:] # Returns every item in the list
</source>

There's also a third, optional argument: <code>step</code>, which lets you jump over values:
<source lang="python">
pets[start:end:step] # Returns items from index start to index end - 1, jumping step values at a time

# Examples:
pets[1:5:2] # Returns items from index 1 to index 4, jumping 2 at a time, so ['Cat', 'Turtle']
pets[::3] # Returns all items in the list, jumping 3 at a time, so ['Dog', 'Turtle']
pets[::-1] # Returns all items in the list, jumping -1 at a time. This reverses the list, so ['Snake', 'Lizard', 'Turtle', 'Fish', 'Cat', 'Dog']
</source>

Lists have all the performance characteristics you'd expect of a dynamic array - constant-time indexing, amortized constant-time appends, and so on.

==== Tuples ====

Python has a special data type called <code>tuple</code>, which is exactly the same as a list except for the fact that it cannot be modified, so you can't append or replace items.

<source lang="python">
cities = ('St. Louis', 'Los Angeles', 'Seattle') # Tuples are defined using parentheses.
numbers = 1, 2, 3 # You can also omit the parentheses if it's unambiguous
single_item_tuple = (1,) # To make a tuple with only one item, put a comma after it
</source>

Tuples also enable you to have multiple return values from a function:

<source lang="python">
def compute_length(string):
str_len = len(string)
if str_len < 5:
return str_len, "short"
elif str_len < 40:
return str_len, "medium"
return str_len, "long"

length, description = compute_length("Four score and seven years ago")
print("The %s string is %d characters long." % (description, length))
</source>
The above example also demonstrates Python's if...elif...else conditional structure.

==== Dictionaries ====

Python has another datatype called a '''dictionary''' (or <code>dict</code>, for short), which are like ''Maps'' in Java, ''associative arrays'' in PHP, and ''object literals'' in JavaScript (coming up soon in Module 6). Essentially, they enable you to use any immutable object as the key in your data structure. <code>dict</code> objects can be created using either the <code>dict</code> function, or by placing items between curly braces, separating keys and values using colons:

<source lang="python">
fruits_in_bowl = {
'apple': 4,
'banana': 2,
'cherry': 0,
'date': 12
}

apple_count = fruits_in_bowl['apple'] # Equals 4

fruits_in_bowl['pear'] = 9 # Sets 'pear' in the dictionary to 9.

for fruit, num in fruits_in_bowl.items():
print("There are %d %s(s) in the bowl." % (num, fruit))
</source>
If you only want the keys from a dictionary, you can just iterate over it directly, like this:

<source lang="python">
for fruit in fruits_in_bowl:
print(fruit)
</source>
If you want only the values but not the keys from a dictionary, use <code>my_dictionary.values()</code>.

==== Sets ====
A <code>set</code> is an unordered collection of unique items, with constant-time membership checking.
<source lang="python">
fruits = {'Apple', 'Apple', 'Apple', 'Pear'} # The set removes duplicates, so it will only contain {'Apple', 'Pear'}
fruits = set(['Apple', 'Apple', 'Apple', 'Pear']) # This line transforms a list into a set
print('Apple' in fruits) # Constant-time!
</source>

=== Loops ===

In Python, while loops are written like this:

<source lang="python">
i = 0
while i < 10:
i += 1
</source>
For loops are written like this:

<source lang="python">
pets = ['Dog', 'Cat', 'Fish']

for pet in pets:
print(pet)
</source>
To iterate over a range of numbers, you can use the convenient <code>range</code> function, like so:

<source lang="python">
for i in range(20, 30): # If you omit the first argument to range, it's assumed to be zero.
print(i)
</source>
Note that <code>range</code> provides a closed-open range. That is to say, it is inclusive of its lower bound and exclusive of its upper bound. To be very explicit about it:

<source lang="python">
list(range(3, 6)) == [3, 4, 5]
</source>
Unlike in other languages you may know, the following is not good practice in Python:

<source lang="python">
pets = ['Dog', 'Cat', 'Fish']

# BAD PRACTICE. DO NOT USE.
for i in range(len(pets)):
pet = pets[i]
</source>
Instead, if you need to access both a variable and its index, use the <code>enumerate</code> function, which allows you to iterate through a group of items, along with their indexes, like so:

<source lang="python">
pets = ['Dog', 'Cat', 'Fish']

for index, pet in enumerate(pets):
print("%s at index %d"; % (pet, index))
</source>

=== Generator Expressions and Comprehensions ===

A generator is a special kind of object that, basically, represents a collection of items using a value and a function for generating the next value in the collection. In other words, it's a way of creating something that behaves like a list, but which only generates one value at a time, and discards a value when it's done with it. Say, for example, you wanted to do an operation on 10,000,000,000,000 numbers. You could put them all in a list, then iterate over the list, but that would take a lot of memory, plus you'd have to create and fill the entire list before beginning to actually work on your problem. Instead, you'd probably be better off using a generator; telling the computer, essentially: “The starting value is 0. When I ask for the next number in the collection, add 1 to current value and give me that.”

A generator expression is an expression that is evaluated to create a generator. They're super useful. Generator expressions can take two forms – they can be used with and without a condition:

<source lang="python">
(EXPRESSION for VARIABLE in ITERABLE) # Unconditional
(EXPRESSION for VARIABLE in ITERABLE if CONDITION) # Conditional
</source>
For our purposes, you can think of an iterable as anything you can do a for loop over. Let's take a look at a generator expression in use:

<source lang="python">
double_even_digits = (number * 2 for number in range(10) if number % 2 == 0)
</source>
That line says that <code>double_even_digits</code> is every even number between 0 and 10 multiplied by two. Simple enough, right? If we wanted to use all of the numbers, not just the even ones, we could simply remove the if statement at the end of the expression.

Here's the thing, though: if you were to print <code>double_even_digits</code>, instead of a nice bunch of numbers, you'd get something that looks like this:

<code><generator object <genexpr><code>at 0x107fc92b0></code>

That's because generators are lazy! They don't generate their values until those values are needed, and they discard values once they're no longer needed. As a result, '''you can only iterate over a generator once'''. In this case, you can't print out the whole generator, because it hasn't generated all the values yet. You can, however, iterate over the generator, and print its values one at a time, like so:

<source lang="python">
for number in double_even_digits:
print(number)
</source>
You can also make a list out of the generator, which will go through all the items in the generator and put them in a list, like so:

<source lang="python">
even_number_list = list(double_even_digits)
</source>
That's actually a great segue to the second topic of this section: comprehensions. A comprehension is just a prettier way to make lists, sets, and dicts out of a generator expressions.

<source lang="python">
# If you want a list:
list(i for i in range(10) if i % 2 == 0) # Don't do this
[i for i in range(10) if i % 2 == 0] # Use a list comprehension instead!

# If you want a set:
set(i for i in range(10) if i % 2 == 0) # Don't do this
{i for i in range(10) if i % 2 == 0} # Use a set comprehension instead!

# If you want a dict:
dict((i, i + 1) for i in range(10) if i % 2 == 0) # Don't do this
{i : i + 1 for i in range(10) if i % 2 == 0} # Use a dict comprehension instead!

# If you want a tuple:
tuple(i for i in range(10) if i % 2 == 0) # Unfortunately, there's no better way to do this
</source>
In general, generators and comprehensions should be used whenever possible - they're the fastest and easiest way to build collections. If you ever see yourself writing code like this:

<source lang="python">
# BAD PRACTICE! DO NOT USE!
digits = []
for digit in range(10):
digits.append(digit)
</source>
Don't do it! Instead, use a generator expression or comprehension, as appropriate. A good way to decide whether a generator expression or comprehension is better for this situation is that, if you're just going to be iterating over your collection once, you should use an generator expression. If not, use a comprehension.

=== Sorting ===

Sorting in Python is frequently performed using the <code>sorted</code> function, which takes two arguments: an iterable (anything you can do a for-loop over, including lists and tuples) and a function used to evaluate each item. If the function is omitted, Python will try to sort the lists by value.

The following example demonstrates using an inline function, which Python calls a ''lambda''.

<source lang="python">
fruits = ['apple', 'banana', 'cherry', 'date']

# sort the fruits by string length
new_fruits = sorted(fruits, key=lambda v: len(v) // 2)

print(new_fruits) # ['date', 'apple', 'banana', 'cherry']
</source>
Alternatively, you can sort a <code>list</code> using the <code>.sort</code> method. This is faster than calling <code>sorted</code>, but it modifies the list in-place and returns <code>None</code>.

<source lang="python">
fruits = ['apple', 'banana', 'cherry', 'date']
fruits.sort()
</source>
=== Import ===

If you want to use functions from other libraries (including ones that you install using pip), use <code>import</code>:

<source lang="python">
import time

current_time = time.localtime()
print(time.strftime('%a, %d %b %Y %H:%M:%S', current_time))
</source>
If you want to pull the functions out of their namespace, you can use <code>from ___ import ___</code> syntax:

<source lang="python">
from time import localtime, strftime

current_time = localtime()
print(strftime('%a, %d %b %Y %H:%M:%S', current_time))

# Be aware that this technique, although convenient, may cause unexpected behavior if the function names that you're pulling out of the namespace are already used for other purposes in Python.
</source>
=== File I/O ===

You can read an entire file into a variable like this:

<source lang="python">
f = open("example.txt")
file_contents = f.read()

f.close() # free up memory when we're finished with the file
</source>
A better option is to use a with-block, which handles opening and closing the file for you automatically:

<source lang="python">
with open("example.txt") as f:
file_contents = f.read()
</source>
You can read a file line-by-line like this:

<source lang="python">
with open("example.txt") as f:
for line in f:
print("Read line: %s" % line.rstrip())
</source>
You can write to a file like this:

<source lang="python">
with open("example.txt", "w") as f:
f.write("Hello\nWorld\n")
</source>
=== Command-Line Arguments ===

Command line arguments are accessible in the variable <code>sys.argv</code>.

The following example shows a program that expects a filename as its argument, and it prints a usage message if the argument is not present ([https://stackoverflow.com/questions/983201/python-and-sys-argv source]).

<source lang="python">
import sys, os

if len(sys.argv) < 2:
sys.exit("Usage: %s filename" % sys.argv[0])

filename = sys.argv[1]

if not os.path.exists(filename):
sys.exit("Error: File '%s' not found" % sys.argv[1])
</source>
=== Object-Oriented Programming ===

You can define and use a class like this:

<source lang="python">
class Food:
# constructor:
def __init__(self, name):
self.name = name

def format_name(self):
return "Gotta love to eat " + self.name

class Fruit(Food):
def format_name(self):
return Food.format_name(self) + " (fruit)"

fruit = Fruit("Cherry")
print(fruit.format_name())
print(Food.get_definition())
</source>
This is the same example as in [[PHP#Object-Oriented_Programming|the PHP guide]].

Some things to notice:

* Instance methods ''always'' take <code>self</code> as their first argument, followed by any number of additional parameters. This can be misleading for programmers familiar with other languages, because the number of arguments you feed to the method is actually ''one less than'' the number of declared parameters. Whenever you call a method on a class instance, that instance is implicitly fed into the explicitly-declared <code>self</code> parameter of the method.
*: Note that the <code>self</code> variable has the same purpose as the <code>this</code> variable in languages like PHP, Java, JavaScript, and C++.
*There is no need for a <code>new</code> keyword in Python.

= Footnotes =
# {{note|interpreted}}This is an oversimplification. If you're interested, here's a quick explanation of how: In CPython (the reference implementation of Python) programs are compiled to bytecode, an intermediate representation, which is then interpreted.
[[Category:Module 4]]

Module 3

2018-02-15T00:02:24Z

Alex: /* Grading */

__NOTOC__
In Module 3, you will learn about MySQL, a web application database.

This article contains your assignments for Module 3.

== Reading ==

The following articles on the online class wiki textbook contain information that will help you complete the assignments.

* [[Introduction to MySQL]]
* [[MySQL Schema and State]]
* [[PHP and MySQL]]
* [[Web Application Security, Part 2]]

== Individual Assignments ==

You will create a simple grades database containing four tables.

'''IMPORTANT:''' The individual assignment is to be done by writing queries by hand. (You can use phpMyAdmin to run the queries, but '''do not let phpMyAdmin write your queries for you!''') Writing your own queries gives you a greater understanding of the underlying mechanisms and databases in general. Additionally, having SQL knowledge and experience is a very marketable trait.

=== Install MySQL and phpMyAdmin ===

Before you start, '''you need to install MySQL''' on your EC2 instance. You may also install phpMyAdmin, a web frontend to MySQL, if you choose to do so.

=== Set Up a Database ===

You may find the following article to be very helpful: [[Introduction to MySQL]]

# Create a database named '''wustl'''
# Create a user named '''wustl_inst''' and give them the password '''wustl_pass'''

=== Create Tables ===

You may find the following article to be very helpful: [[MySQL Schema and State]]

When creating tables, keep the following items in mind:

* You should create all tables such that they use the InnoDB storage engine, since we wish to make use of its support of foreign keys. In other database engines, foreign key constraints are not enforced. (If you mess up, you can use ALTER TABLE to change the storage engine.)
* Where it is appropriate, you should take advantage of the ability to define fields NOT NULL so that you do not inadvertently insert incomplete data for a row.

Create the following tables:

# Create a table named '''students''' with the following fields:
#* '''id''' of an appropriately-sized unsigned integer type (we will never need to process more than a million students)
#* '''first_name''' of type '''VARCHAR(50)'''
#* '''last_name''' of type '''VARCHAR(50)'''
#* '''email_address''' of type '''VARCHAR(50)'''
#: The primary key should be on the '''id''' field.
# Create a table named '''departments''' with the following fields:
#* '''school_code''' of type '''ENUM''' (e.g. "L" for ArtSci and "E" for Engineering). The options are as follows:
#*: 'L', 'B', 'A', 'F', 'E', 'T', 'I', 'W', 'S', 'U', 'M'
#* '''dept_id''' of an appropriately-sized unsigned integer type (in the foreseeable future there will never be more than 200 departments in a school)
#* '''abbreviation''' of type '''VARCHAR(9)''' (e.g. CSE, ChemE, etc)
#* '''dept_name''' of type '''VARCHAR(200)''' (e.g. Computer Science and Engineering)
#: The primary key should be on two fields: '''school_code''' and '''dept_id'''
#: '''Note:''' Why not just use the department ID for the primary key? The ID numbers are sometimes reused across schools. For instance, department 33 in The College of Arts and Sciences is Psychology while department 33 in The School of Engineering and Applied Sciences is Energy, Environmental and Chemical Engineering. Thus we must also include the school code to differentiate them such that the record for E33 is distinct from that of L33.
# Create a table named '''courses''' with the following fields:
#* '''school_code''' of type '''ENUM'''
#*: This should have the same letters in the same order as the '''school_code''' '''ENUM''' field in the '''departments''' table.
#* '''dept_id''' of the same size of integer as in the '''departments''' table
#* '''course_code''' of type '''CHAR(5)''' (this will hold course codes; e.g., '330S', '131', '2960')
#* '''name''' of type '''VARCHAR(150)'''
#: The appropriate fields in this table should make a foreign key reference to the corresponding fields in '''department'''.
#: In addition, it is up to you to determine the field(s) for the primary key.
#: '''Note:''' If you are unsure which fields to make the foreign keys and feel the need to beg your friends or the TAs to give you the answer, bang your head on your desk whilst repeating "I WILL EXERCISE REASON AND COMMON SENSE AND I WILL CURTAIL MY DESIRE TO BLINDLY FOLLOW DIRECTIONS"
#: ''Disclaimer: don't actually bang your head on your desk, the resulting head trauma may in fact make it harder for you to determine which fields should have associated foreign keys.''
# Create a table named '''grades''' with the following fields:
#* '''pk_grade_ID''' of an appropriately-sized unsigned integer type (should be larger than the one you chose for the '''students''' table). There will never be more than 1,000 grades per student.
#*: You should declare this field to be '''auto_increment''' and make it the primary key.
#*: This is called a ''surrogate key'' as opposed to a ''natural key'' because it doesn't arise "naturally" from the data; that is to say that it is not derived from application data. The use of surrogate keys vs. natural keys is a polemic issue amongst database designers. For a decently unbiased take on the issue, see this page: http://www.agiledata.org/essays/keys.html#Comparison
#*: '''Food for thought:''' Aside from simply exposing you to the concept, can you think of any reasons why a surrogate key might be preferable for this table? Alternatively, what attributes, if any, could you use as a natural key, and what might be the drawbacks of doing so?
#* '''student_id''' of the same integer (unsigned) type that you chose in the '''students''' table
#* '''grade''' of type '''decimal(5,2)'''
#* '''school_code''' of type '''ENUM'''
#*: Can you guess what entries to use for the enum?
#* '''dept_id''' of the same integer type that you've used for this field in other tables
#* '''course_code''' of the same type you chose for the course code in the '''courses''' table
#: The '''grades''' table should have foreign keys to both the '''students''' table and the '''courses''' table.

=== Populate Tables ===

Now, populate the tables by downloading the text files given below and loading them into the appropriate tables.

'''Note:''' Do not insert all the values manually; instead, use the MySQL's ability to load in data from text files.

You may find the following article to be very helpful: [[MySQL Schema and State]]

The files containing the data are:
* students: http://classes.engineering.wustl.edu/cse330/content/students_data.txt
* courses: http://classes.engineering.wustl.edu/cse330/content/courses.txt
* departments: http://classes.engineering.wustl.edu/cse330/content/departments_data.txt
* grades: http://classes.engineering.wustl.edu/cse330/content/grades_data.txt

=== Insert More Data ===

Insert the following data into the tables that you have created and populated:

# Insert entries for CSE 330S, CSE 131, and CSE 260M.
#: ''If you don't know CSE's department code, how can you find out using the tables in the database?''
# Insert the grades given for the students named below.
#* '''Ben Harper'''
#** E-mail: '''bharper@ffym.com'''
#** Student ID: '''88'''
#** Grades:
#*** 35.5 in CSE 330S
#*** 0 in CSE 131
#*** 95 in CSE 260M
#* '''Matt Freeman'''
#** E-mail: '''mfreeman@kickinbassist.net'''
#** Student ID: '''202'''
#** Grades:
#*** 100 in CSE 330S
#*** 90.5 in CSE 131
#*** 94.8 in CSE 260M
#* '''Marc Roberge'''
#** E-mail: '''mroberge@ofarevolution.us'''
#** Student ID: '''115'''
#** Grades:
#*** 75 in CSE 330S
#*** 37 in CSE 131
#*** 45.5 in CSE 260M

=== Querying Your Database ===

Now that you have a fully-functional, populated database, let's do some queries on it!

Please Running the following <code>SELECT</code> queries, then copy the output to a text file of the form <code>query1.txt</code>, <code>query2.txt</code>, and so on, and commit them with the rest of your repository (be sure to include your query command and the entire response, including the number of results found). For each query, only the requested columns should be present. You will receive 0 points for any query that includes additional columns.

# Select the entire grades table.
# Select all fields describing the courses offered in the College of Arts & Sciences (school code <code>L</code>).
# The names, student IDs, and CSE330 grades of all students who are in CSE330S.
#: '''Note:''' This query should involve joins. You don't need to use any aggregation functions.
# The names, e-mails, and average grades of any student with an average below 50 so that the dean can send them an email notification that they are now on academic probation.
#: ''You should be able to do this in only one query, without making any temporary tables. You will need to use aggregation functions and the <code>HAVING</code> keyword.''
# An individual report card for Jack Johnson, consisting of only his student ID, e-mail address, and average grade.
#: ''Again, you should be able to do this in just one query, using the correct combination of aggregation functions and joins.''
#: '''Note:''' Your query must look for students with the name "Jack Johnson" instead of hard-coding the student ID.

== Group Project ==

You will work in pairs on this project. You may work with the same partner from Module 2, or change to someone else.

'''Important Reminder:''' frequently commit your work to your Git repository as a backup!

=== Simple News Web Site ===

'''Examples:'''
* http://digg.com/
* http://slashdot.org/

You should use '''PHP''' unless you get permission to use another web technology from the instructor. You may also use phpMyAdmin to help set up databases.

You may find this wiki article helpful: [[PHP and MySQL]]

==== Requirements ====

* Users can register for accounts and then log in to the website.
* Accounts should have both a username and a ''secure'' password. '''NEVER store plaintext passwords in a database!'''
*: For more information on password security, refer to [[Web Application Security, Part 2#Password Security|the Web Application Security guide]].
* Registered users can submit story commentary.
*: A link can be associated with each story, and they should be stored in a separate database field from the story
* Registered users can comment on any story.
* Unregistered users can only view stories and comments.
* Registered users can edit and delete their stories and comments.
* All data must be kept in a MySQL database (user information, stories, comments, and links).
* Creative Portion

=== Web Security and Validation ===

No application is finished until much thought is put into web security and best practice. Throughout this course, we heavily emphasize the dogma of [http://coderesponsibly.org/ responsible] coding.

Read this week's Web Application Security guide: [[Web Application Security, Part 2]]. In particular, your project needs to:

* '''Your application needs to be secure against SQL injection attacks'''. If you are using prepared queries, you should already be safe on this front.
* '''Your passwords need to be securely hashed salted''' to prevent rainbow table attacks.
* '''You should pass tokens in forms''' to prevent CSRF attacks.
* '''You should check all preconditions on the server side''' to prevent Abuse of Functionality attacks.

You shouldn't forget the practices you learned last week:

* '''Your page should validate''' with no errors through the W3C validator.
* '''Filter Input and Escape Output''', but not the other way around.

== Grading ==

We will be grading the following aspects of your work. There are 100 points total.

'''Assignments (including code) must be committed to Bitbucket by the end of class on the due date (commit early and often). Failing to commit by the end of class on the due date will result in a 0. '''

'''If you do not include a link to your group portion running on your instance in your group portion README.md, you will receive a 0 for the group portion.'''
________

# '''MySQL Queries (25 Points):'''
#* A MySQL server is running on your instance (2 points)
#* Tables' fields, including data types and foreign keys, are correct (8 points)
#*: ''Note: To demonstrate the structure of your tables, you should commit a text file containing the output of the <code>SHOW CREATE TABLE</code> command '''for each table.''' Each table's file should have a name of the form <code>tablename.sql</code> (e.g. <code>students.sql</code>).''
#* The output of each of the five queries is correct. (3 points each)
#*: ''Note: To demonstrate the output of your queries, text files containing the 'entire' result (including the query and number of records found) of running each query should committed to BitBucket. The file for query 1 should be named <code>query1.txt</code>, the file for query 2 should be named <code>query2.txt</code>, and so on.''
# '''News Site (60 Points):'''
#* '''''User Management (20 Points):'''''
#** A session is created when a user logs in (3 points)
#** New users can register (3 points)
#** Passwords are hashed, salted, and checked securely (3 points)
#**: ''Note: You will receive 0 points for this section if you use the <code>==</code> or <code>===</code> operators to compare password hashes, or if you use the <code>crypt</code> or <code>md5</code> functions at any point.''
#** Users can log out (3 points)
#** A user can edit and delete his/her own stories and comments but cannot edit or delete the stories or comments of another user (8 points)
#* '''''Story and Comment Management (20 Points):'''''
#** Relational database is configured with correct data types and foreign keys (4 points)
#*: ''Note: To demonstrate the structure of your database, you should commit a 'single' text file containing the output of the <code>SHOW CREATE TABLE</code> command '''for all tables in your database,''' called <code>tables.sql</code>. This one file should contain the output for all of your tables.
#** Stories can be posted (3 points)
#** A link can be associated with each story, and is stored in a separate database field from the story (3 points)
#** Comments can be posted in association with a story (4 points)
#** Stories can be edited and deleted (3 points)
#** Comments can be edited and deleted (3 points)
#**: ''Note: Although there are only 6 points allocated for editing/deleting in this section, there are 8 more points at stake in the User Management section that cannot be earned unless editing/deleting is implemented. Implementing editing but not deleting, or vice-versa, will result in earning half the points.''
#* '''''Best Practices (15 Points):'''''
#** Code is well formatted and easy to read, with proper commenting (3 points)
#** Safe from SQL Injection attacks (2 points)
#** Site follows the FIEO philosophy (3 points)
#** All pages pass the W3C HTML and CSS validators (2 points)
#** CSRF tokens are passed when creating, editing, and deleting comments and stories (5 points)
#* '''''Usability (5 Points):'''''
#** Site is intuitive to use and navigate (4 points)
#** Site is visually appealing (1 point)
# '''Creative Portion (15 Points)''' (see below)
#* '''''Make sure you have a README.md file in your group repo with the following:'''''
#** Names and Student IDs of all the group members
#** A link to your homepage of the site
#** A brief description of what you did for your creative portion
#** Any additional login details needed for the TA

[[Category:Module 3]]
[[Category:Modules]]

Module 3

2018-02-15T00:02:09Z

Alex: /* Grading */

__NOTOC__
In Module 3, you will learn about MySQL, a web application database.

This article contains your assignments for Module 3.

== Reading ==

The following articles on the online class wiki textbook contain information that will help you complete the assignments.

* [[Introduction to MySQL]]
* [[MySQL Schema and State]]
* [[PHP and MySQL]]
* [[Web Application Security, Part 2]]

== Individual Assignments ==

You will create a simple grades database containing four tables.

'''IMPORTANT:''' The individual assignment is to be done by writing queries by hand. (You can use phpMyAdmin to run the queries, but '''do not let phpMyAdmin write your queries for you!''') Writing your own queries gives you a greater understanding of the underlying mechanisms and databases in general. Additionally, having SQL knowledge and experience is a very marketable trait.

=== Install MySQL and phpMyAdmin ===

Before you start, '''you need to install MySQL''' on your EC2 instance. You may also install phpMyAdmin, a web frontend to MySQL, if you choose to do so.

=== Set Up a Database ===

You may find the following article to be very helpful: [[Introduction to MySQL]]

# Create a database named '''wustl'''
# Create a user named '''wustl_inst''' and give them the password '''wustl_pass'''

=== Create Tables ===

You may find the following article to be very helpful: [[MySQL Schema and State]]

When creating tables, keep the following items in mind:

* You should create all tables such that they use the InnoDB storage engine, since we wish to make use of its support of foreign keys. In other database engines, foreign key constraints are not enforced. (If you mess up, you can use ALTER TABLE to change the storage engine.)
* Where it is appropriate, you should take advantage of the ability to define fields NOT NULL so that you do not inadvertently insert incomplete data for a row.

Create the following tables:

# Create a table named '''students''' with the following fields:
#* '''id''' of an appropriately-sized unsigned integer type (we will never need to process more than a million students)
#* '''first_name''' of type '''VARCHAR(50)'''
#* '''last_name''' of type '''VARCHAR(50)'''
#* '''email_address''' of type '''VARCHAR(50)'''
#: The primary key should be on the '''id''' field.
# Create a table named '''departments''' with the following fields:
#* '''school_code''' of type '''ENUM''' (e.g. "L" for ArtSci and "E" for Engineering). The options are as follows:
#*: 'L', 'B', 'A', 'F', 'E', 'T', 'I', 'W', 'S', 'U', 'M'
#* '''dept_id''' of an appropriately-sized unsigned integer type (in the foreseeable future there will never be more than 200 departments in a school)
#* '''abbreviation''' of type '''VARCHAR(9)''' (e.g. CSE, ChemE, etc)
#* '''dept_name''' of type '''VARCHAR(200)''' (e.g. Computer Science and Engineering)
#: The primary key should be on two fields: '''school_code''' and '''dept_id'''
#: '''Note:''' Why not just use the department ID for the primary key? The ID numbers are sometimes reused across schools. For instance, department 33 in The College of Arts and Sciences is Psychology while department 33 in The School of Engineering and Applied Sciences is Energy, Environmental and Chemical Engineering. Thus we must also include the school code to differentiate them such that the record for E33 is distinct from that of L33.
# Create a table named '''courses''' with the following fields:
#* '''school_code''' of type '''ENUM'''
#*: This should have the same letters in the same order as the '''school_code''' '''ENUM''' field in the '''departments''' table.
#* '''dept_id''' of the same size of integer as in the '''departments''' table
#* '''course_code''' of type '''CHAR(5)''' (this will hold course codes; e.g., '330S', '131', '2960')
#* '''name''' of type '''VARCHAR(150)'''
#: The appropriate fields in this table should make a foreign key reference to the corresponding fields in '''department'''.
#: In addition, it is up to you to determine the field(s) for the primary key.
#: '''Note:''' If you are unsure which fields to make the foreign keys and feel the need to beg your friends or the TAs to give you the answer, bang your head on your desk whilst repeating "I WILL EXERCISE REASON AND COMMON SENSE AND I WILL CURTAIL MY DESIRE TO BLINDLY FOLLOW DIRECTIONS"
#: ''Disclaimer: don't actually bang your head on your desk, the resulting head trauma may in fact make it harder for you to determine which fields should have associated foreign keys.''
# Create a table named '''grades''' with the following fields:
#* '''pk_grade_ID''' of an appropriately-sized unsigned integer type (should be larger than the one you chose for the '''students''' table). There will never be more than 1,000 grades per student.
#*: You should declare this field to be '''auto_increment''' and make it the primary key.
#*: This is called a ''surrogate key'' as opposed to a ''natural key'' because it doesn't arise "naturally" from the data; that is to say that it is not derived from application data. The use of surrogate keys vs. natural keys is a polemic issue amongst database designers. For a decently unbiased take on the issue, see this page: http://www.agiledata.org/essays/keys.html#Comparison
#*: '''Food for thought:''' Aside from simply exposing you to the concept, can you think of any reasons why a surrogate key might be preferable for this table? Alternatively, what attributes, if any, could you use as a natural key, and what might be the drawbacks of doing so?
#* '''student_id''' of the same integer (unsigned) type that you chose in the '''students''' table
#* '''grade''' of type '''decimal(5,2)'''
#* '''school_code''' of type '''ENUM'''
#*: Can you guess what entries to use for the enum?
#* '''dept_id''' of the same integer type that you've used for this field in other tables
#* '''course_code''' of the same type you chose for the course code in the '''courses''' table
#: The '''grades''' table should have foreign keys to both the '''students''' table and the '''courses''' table.

=== Populate Tables ===

Now, populate the tables by downloading the text files given below and loading them into the appropriate tables.

'''Note:''' Do not insert all the values manually; instead, use the MySQL's ability to load in data from text files.

You may find the following article to be very helpful: [[MySQL Schema and State]]

The files containing the data are:
* students: http://classes.engineering.wustl.edu/cse330/content/students_data.txt
* courses: http://classes.engineering.wustl.edu/cse330/content/courses.txt
* departments: http://classes.engineering.wustl.edu/cse330/content/departments_data.txt
* grades: http://classes.engineering.wustl.edu/cse330/content/grades_data.txt

=== Insert More Data ===

Insert the following data into the tables that you have created and populated:

# Insert entries for CSE 330S, CSE 131, and CSE 260M.
#: ''If you don't know CSE's department code, how can you find out using the tables in the database?''
# Insert the grades given for the students named below.
#* '''Ben Harper'''
#** E-mail: '''bharper@ffym.com'''
#** Student ID: '''88'''
#** Grades:
#*** 35.5 in CSE 330S
#*** 0 in CSE 131
#*** 95 in CSE 260M
#* '''Matt Freeman'''
#** E-mail: '''mfreeman@kickinbassist.net'''
#** Student ID: '''202'''
#** Grades:
#*** 100 in CSE 330S
#*** 90.5 in CSE 131
#*** 94.8 in CSE 260M
#* '''Marc Roberge'''
#** E-mail: '''mroberge@ofarevolution.us'''
#** Student ID: '''115'''
#** Grades:
#*** 75 in CSE 330S
#*** 37 in CSE 131
#*** 45.5 in CSE 260M

=== Querying Your Database ===

Now that you have a fully-functional, populated database, let's do some queries on it!

Please Running the following <code>SELECT</code> queries, then copy the output to a text file of the form <code>query1.txt</code>, <code>query2.txt</code>, and so on, and commit them with the rest of your repository (be sure to include your query command and the entire response, including the number of results found). For each query, only the requested columns should be present. You will receive 0 points for any query that includes additional columns.

# Select the entire grades table.
# Select all fields describing the courses offered in the College of Arts & Sciences (school code <code>L</code>).
# The names, student IDs, and CSE330 grades of all students who are in CSE330S.
#: '''Note:''' This query should involve joins. You don't need to use any aggregation functions.
# The names, e-mails, and average grades of any student with an average below 50 so that the dean can send them an email notification that they are now on academic probation.
#: ''You should be able to do this in only one query, without making any temporary tables. You will need to use aggregation functions and the <code>HAVING</code> keyword.''
# An individual report card for Jack Johnson, consisting of only his student ID, e-mail address, and average grade.
#: ''Again, you should be able to do this in just one query, using the correct combination of aggregation functions and joins.''
#: '''Note:''' Your query must look for students with the name "Jack Johnson" instead of hard-coding the student ID.

== Group Project ==

You will work in pairs on this project. You may work with the same partner from Module 2, or change to someone else.

'''Important Reminder:''' frequently commit your work to your Git repository as a backup!

=== Simple News Web Site ===

'''Examples:'''
* http://digg.com/
* http://slashdot.org/

You should use '''PHP''' unless you get permission to use another web technology from the instructor. You may also use phpMyAdmin to help set up databases.

You may find this wiki article helpful: [[PHP and MySQL]]

==== Requirements ====

* Users can register for accounts and then log in to the website.
* Accounts should have both a username and a ''secure'' password. '''NEVER store plaintext passwords in a database!'''
*: For more information on password security, refer to [[Web Application Security, Part 2#Password Security|the Web Application Security guide]].
* Registered users can submit story commentary.
*: A link can be associated with each story, and they should be stored in a separate database field from the story
* Registered users can comment on any story.
* Unregistered users can only view stories and comments.
* Registered users can edit and delete their stories and comments.
* All data must be kept in a MySQL database (user information, stories, comments, and links).
* Creative Portion

=== Web Security and Validation ===

No application is finished until much thought is put into web security and best practice. Throughout this course, we heavily emphasize the dogma of [http://coderesponsibly.org/ responsible] coding.

Read this week's Web Application Security guide: [[Web Application Security, Part 2]]. In particular, your project needs to:

* '''Your application needs to be secure against SQL injection attacks'''. If you are using prepared queries, you should already be safe on this front.
* '''Your passwords need to be securely hashed salted''' to prevent rainbow table attacks.
* '''You should pass tokens in forms''' to prevent CSRF attacks.
* '''You should check all preconditions on the server side''' to prevent Abuse of Functionality attacks.

You shouldn't forget the practices you learned last week:

* '''Your page should validate''' with no errors through the W3C validator.
* '''Filter Input and Escape Output''', but not the other way around.

== Grading ==

We will be grading the following aspects of your work. There are 100 points total.

'''Assignments (including code) must be committed to Bitbucket by the end of class on the due date (commit early and often). Failing to commit by the end of class on the due date will result in a 0. '''

'''If you do not include a link to your group portion running on your instance in your group portion README.md, you will receive a 0 for the group portion.'''
________

# '''MySQL Queries (25 Points):'''
#* A MySQL server is running on your instance (2 points)
#* Tables' fields, including data types and foreign keys, are correct (8 points)
#*: ''Note: To demonstrate the structure of your tables, you should commit a file containing the output of the <code>SHOW CREATE TABLE</code> command '''for each table.''' Each table's file should have a name of the form <code>tablename.sql</code> (e.g. <code>students.sql</code>).''
#* The output of each of the five queries is correct. (3 points each)
#*: ''Note: To demonstrate the output of your queries, text files containing the 'entire' result (including the query and number of records found) of running each query should committed to BitBucket. The file for query 1 should be named <code>query1.txt</code>, the file for query 2 should be named <code>query2.txt</code>, and so on.''
# '''News Site (60 Points):'''
#* '''''User Management (20 Points):'''''
#** A session is created when a user logs in (3 points)
#** New users can register (3 points)
#** Passwords are hashed, salted, and checked securely (3 points)
#**: ''Note: You will receive 0 points for this section if you use the <code>==</code> or <code>===</code> operators to compare password hashes, or if you use the <code>crypt</code> or <code>md5</code> functions at any point.''
#** Users can log out (3 points)
#** A user can edit and delete his/her own stories and comments but cannot edit or delete the stories or comments of another user (8 points)
#* '''''Story and Comment Management (20 Points):'''''
#** Relational database is configured with correct data types and foreign keys (4 points)
#*: ''Note: To demonstrate the structure of your database, you should commit a 'single' text file containing the output of the <code>SHOW CREATE TABLE</code> command '''for all tables in your database,''' called <code>tables.sql</code>. This one file should contain the output for all of your tables.
#** Stories can be posted (3 points)
#** A link can be associated with each story, and is stored in a separate database field from the story (3 points)
#** Comments can be posted in association with a story (4 points)
#** Stories can be edited and deleted (3 points)
#** Comments can be edited and deleted (3 points)
#**: ''Note: Although there are only 6 points allocated for editing/deleting in this section, there are 8 more points at stake in the User Management section that cannot be earned unless editing/deleting is implemented. Implementing editing but not deleting, or vice-versa, will result in earning half the points.''
#* '''''Best Practices (15 Points):'''''
#** Code is well formatted and easy to read, with proper commenting (3 points)
#** Safe from SQL Injection attacks (2 points)
#** Site follows the FIEO philosophy (3 points)
#** All pages pass the W3C HTML and CSS validators (2 points)
#** CSRF tokens are passed when creating, editing, and deleting comments and stories (5 points)
#* '''''Usability (5 Points):'''''
#** Site is intuitive to use and navigate (4 points)
#** Site is visually appealing (1 point)
# '''Creative Portion (15 Points)''' (see below)
#* '''''Make sure you have a README.md file in your group repo with the following:'''''
#** Names and Student IDs of all the group members
#** A link to your homepage of the site
#** A brief description of what you did for your creative portion
#** Any additional login details needed for the TA

[[Category:Module 3]]
[[Category:Modules]]

Module 6

2018-02-12T17:45:08Z

Alex:

__NOTOC__
Module 6 builds upon the JavaScript skills you learned in Module 5.

== Reading ==

The following articles on the online class wiki textbook contain information that will help you complete the assignments.

* [[Node.JS]]
* [[Socket.IO]]

== Individual Assignments ==

=== Install Node.JS ===

Install Node.JS from Apt or Yum according to the instructions in the [[Node.JS]] guide.

=== Static File Server in Node.JS ===

The individual portion of Module 6 is short in order to give you enough time to complete the group portion.

# Copy the example code from the Node.JS guide into a file called ''static_server.js'' or something of that nature. Save it on your EC2 instance (but not in a place that Apache can serve!).
#: Ensure that you understand what the static file server script is doing…
# Make a directory parallel to ''static_server.js'' named ''static''.
# Change "<STATIC DIRECTORY NAME>" on line 11 of the static fileserver example code to reflect the name of the directory you just made.
# Save the following files in your ''static'' directory:
#* ''hello.txt'', a text file containing "Hello World"
#* ''brookings.jpg'', an image file you can download from here: http://classes.engineering.wustl.edu/cse330/content/brookings.jpg
#* ''college.html'', an HTML document based on the [[HTML and CSS#Quick and Easy Page Layout|Quick and Easy HTML Layout]] containing an image tag pointing to ''brookings.jpg''
#* ''phpinfo.php'', a PHP file containing the phpinfo command that generates a diagnostic page of the server:
#: <source lang="php"><?php phpinfo(); ?></source>
# Boot up your Node.JS static fileserver, and from your browser, load all four of the files you created in step 4.
#: Which ones work and which ones don't? Why might this be the case?

== Group Project ==

In the group portion of Module 6 you will create a multi-room chat server using Node.JS and Socket.IO. You may not use Apache as your web server for the group project, it must be completed using Node.JS.

This chat service will contain a main lobby where users sign on with a nickname and can communicate with each other. Users may also create chat rooms for other to join. The entire app should be displayed on a single webpage, listing the room you are in, all available rooms, and the users in the current room.

The single room chat server and client are provided here: [[Socket.IO]]

== Grading ==

We will be grading the following aspects of your work. There are 75 points total.

'''Assignments (including code) must be committed to Bitbucket by the end of class on the due date (commit early and often). Failing to commit by the end of class on the due date will result in a 0. '''

_________

# '''Individual Portion (25 Points):'''
#* Node.JS is installed on your EC2 instance (5 points)
#*: ''Take a screenshot of your browser visiting your EC2 instance serving up the college.html web page on port 3456, make sure the URL is visible in the screenshot.''
#* The ''hello.txt'', ''brookings.jpg'', and ''college.html'' files all load successfully (4 points each)
#* Visiting a file that does not exist inside the ''static'' directory results in a 404 (4 points)
#* Discuss in the README.md why ''phpinfo.php'' behaves the way it does when loaded through Node.JS (4 points)
#* Make sure all of your individual portion files are pushed to Bitbucket (include your node.js file, hello.txt, brookings.jpg, college.html, and phpinfo.php)
#*: ''The TA should be able to simply download your repo and start up your file server, without having to copy files or create additional subdirectories''
# '''Multi-room Chat Server (50 Points):'''
#* '''''Administration of user created chat rooms (25 Points):'''''
#** Users can create chat rooms with an arbitrary room name(5 points)
#** Users can join an arbitrary chat room (5 points)
#** The chat room displays all users currently in the room (5 points)
#** A private room can be created that is password protected (5 points)
#** Creators of chat rooms can temporarily kick others out of the room (3 points)
#** Creators of chat rooms can permanently ban users from joining that particular room (2 points)
#* '''''Messaging (5 Points):'''''
#** A user's message shows their username and is sent to everyone in the room (1 point)
#** Users can send private messages to another user in the same room (4 points)
#* '''''Best Practices (5 Points):'''''
#** Code is well formatted and easy to read, with proper commenting (2 points)
#** Code passes HTML validation (2 points)
#** node_modules folder is ignored by version control (1 points)
#* '''''Usability (5 Points):'''''
#** Communicating with others and joining rooms is easy and intuitive (4 points)
#** Site is visually appealing (1 point)
#* '''Creative Portion (10 Points)'''
#** Make sure to create a README.md file pointing to your server

[[Category:Module 6]]
[[Category:Modules]]

Module 5

2018-02-12T17:45:01Z

Alex:

__NOTOC__
In Module 5, you will learn JavaScript, the dominant client-side web language. JavaScript is the third and final programming language you will learn in CSE 330.

This article contains your assignments for Module 5.

'''Warning:'''

''This module takes students a while. It is strongly recommended that you start early and ask questions as they come up.''

== Reading ==

The following articles on the online class wiki textbook contain information that will help you complete the assignments.

* [[JavaScript]]
* [[AJAX and JSON]]
* [[jQuery]]
* [[Web Application Security, Part 3]]

== Individual Assignments ==

'''''IMPORTANT:'' Both of the individual assignments must be completed ''without'' using a JavaScript library like jQuery.''' However, you may (and should) use jQuery for the group portion.

=== JavaScript Calculator ===

In Module 2, you made a calculator using PHP. Now you will be making one using JavaScript.

* The web page should have two input fields and a radio button group for the operation, with the 4 basic math operations represented (add, subtract, multiply, divide).
* JavaScript should monitor all three fields and display the current result whenever the user changes any value in any field, without refreshing the page.
*: '''Tip 1:''' Consider using either the ''change'' or the ''keyup'' event on the text fields, and either the ''change'' or the ''click'' event on the radio buttons.
*: '''Tip 2:''' Re-read [[JavaScript|the JavaScript guide]] if you need help figuring our how to bind callback functions to events, or how to determine which radio button is currently selected. (There are examples for both of these!)
* The calculator should be completely self-contained; i.e., you should not be making any requests to any other server-side or client-side scripts or web pages after the initial page load.

'''Tip:''' You can embed JavaScript code into an HTML document like this:

<source lang="html4strict">
<script type="text/javascript">
// your code here
</script>
</source>

'''Tip:''' If your code isn't working the way you expect, use a JavaScript error console. In Chrome, for example, press Ctrl-Shift-I (or Cmd-Option-I) to open the WebKit inspector.

'''Important:''' It is best practice to fully separate the content, appearance, and behavior. In previous modules, you may have lost points for using HTML tags that change the appearance of things <nowiki>(like <center> and <font>).</nowiki> In this module, make sure that you define your event listeners in JavaScript as in <code>document.getElementById("xyz").addEventListener(...)</code> and '''''not''''' in the HTML like <code><button onclick="badExample();">Bad Example</button></code>.

=== Weather Widget ===

In this section, you will make a web page that displays the weather forecast using AJAX requests to a weather server.

# Make an empty HTML document; name it '''weather.html'''
#: Refer to the [[HTML and CSS]] guide for the skeleton of an HTML document
# Define a function in JavaScript; call it '''fetchWeather()'''. You may write your JavaScript in an embedded script in your HTML document.
# Inside your '''fetchWeather()''' function, make an AJAX request to the weather server.
#: We have a server that outputs the current weather in JSON format. The format is documented in the [[#JSON Structure]] section below.
#: '''URL:''' https://classes.engineering.wustl.edu/cse330/content/weather_json.php
#: We kindly thank Yahoo Weather for providing us with up-to-date weather information.
#* '''IMPORTANT:''' Under normal circumstances, AJAX requests ''cannot'' be performed cross-domain for security reasons. We have set the <code>Access-Control-Allow-Origin</code> header on our server to allow requests from your EC2 instances, or from localhost. '''You will therefore need to upload your code to your EC2, or access it via localhost, in order for the AJAX requests to work.''' This means that you cannot, for example, complete this part of the individual portion in JSFiddle.
# In your callback, process the JSON and use JavaScript to manipulate the HTML DOM to display the following information on your page:
#* Location
#** City, in a <nowiki><strong></nowiki> tag
#** State, not in any tag
#* Humidity
#* Current Temperature
#* Image for Tomorrow's Forecast (see [[#Weather Condition Images]] below for more information)
#* Image for the Day After Tomorrow's Forecast
# Finally, bind '''fetchWeather()''' to the DOMContentLoaded event so that your weather widget is automatically initialized when the page is loaded:
#: <source lang="javascript">document.addEventListener("DOMContentLoaded", fetchWeather, false);</source>
# In addition, add a button that runs your ''fetchWeather'' function when clicked. This should update your widget with the current weather conditions.

Use the following HTML:

<source lang="html4strict">
<div class="weather" id="weatherWidget">
<div class="weather-loc"></div>
<div class="weather-humidity"></div>
<div class="weather-temp"></div>
<img class="weather-tomorrow" />
<img class="weather-dayaftertomorrow" />
</div>
</source>

Include the CSS file from here: http://classes.engineering.wustl.edu/cse330/content/weather.css

When everything is working, the weather widget should look something like this:

[[File:WeatherWidget.png]]

'''Important:''' The widget in this section needs to work in only Firefox and Chrome. It does '''''not''''' need to work Internet Explorer.

==== Tips ====

===== JSON Structure =====

The JSON from our server looks like this:

<source lang="javascript">
{
"updated": "Thu, 11 Oct 2012 5:54 pm CDT",
"location": {
"city": "St. Louis",
"state": "MO"
},
"wind": {
"chill": "62",
"direction": "150",
"speed": "3 mph"
},
"atmosphere": {
"humidity": "50",
"visibility": "10",
"pressure": "30.12 in"
},
"current": {
"code": "28",
"text": "Mostly Cloudy",
"temp": "62°F",
"date": "Thu, 11 Oct 2012 5:54 pm CDT"
},
"tomorrow": {
"code": "29",
"text": "Clouds Early/Clearing Late",
"low": "45°F",
"high": "61°F"
},
"dayafter": {
"code": "30",
"text": "Partly Cloudy",
"low": "53°F",
"high": "65°F"
},
"credit": "http://us.rd.yahoo.com/dailynews/rss/weather/St._Louis__MO/*http://weather.yahoo.com/forecast/USMO0170_f.html"
}
</source>

===== Weather Condition Images =====

Each day's forecast has a code. There are images associated with these codes.

One place to get the images is from here: <nowiki>http://us.yimg.com/i/us/nws/weather/gr/</nowiki>'''##'''<nowiki>ds.png</nowiki>

Replace the '''##''' with the forecast code. For example, for code 32, the URL would be: http://us.yimg.com/i/us/nws/weather/gr/32ds.png

== Group Project ==

I forgot if I already mentioned this, but '''start early on this project!''' It will take longer than you think, I promise!

You are encouraged to use the advanced version control practices you learned in Module 5 when completing this assignment.

=== Calendar ===

Build a simple calendar that allows users to add and remove events dynamically.

You will use JavaScript to process user interactions at the web browser, without ever refreshing the browser after the initial web page load. You may use a JavaScript library of your choice, including Ext JS.

Your application should utilize AJAX to run server-side scripts that query your database to save and retrieve information, including user accounts and events.

We have also written some functions to help you get started: [[JavaScript Calendar Library]]

==== Examples ====

* https://calendar.google.com/
* http://www.zoho.com/calendar/

==== Server Side Language ====

Additionally, you may use a database of your choice. MySQL is probably the logical choice since you have been using it since Module 2, but you are free to explore other databases if you like.

==== Requirements ====

* Support a month-by-month view of the calendar.
*: Show one month at a time, with buttons to move forward or backward.
*: There should be no limit to how far forward or backward the user can go.
* Users can register and log in to the website.
*: You may leverage your MySQL project code and database from module 3 to get started.
* Unregistered users should see no events on the calendar.
* Registered users can add events.
*: All events should have a date and time, but do not need to have a duration.
*: You do ''not'' need to support recurring events (where you add an event that repeats, for example, every monday).
* Registered users see only events that they have added.
*: Your AJAX should not ask the server for events from a certain username. Instead, your AJAX should ask the server for events, and the server should respond with the events for only the currently-logged-in user (from the session). Can you think of why?
* Registered users can delete their events, but not the events of others.
*: Again, the server should delete events based on the username present in the session. (If it deletes only based on an Event ID, an attacker could feed any arbitrary Event ID to your server, even if he/she didn't own that event.)
* All user and event data should be kept in a database.
* At no time should the main page need to be reloaded.
*: User registration, user authentication, event addition, and event deletion should all be handled by JavaScript and AJAX requests to your server.
* Your page needs to work in the versions of Firefox and Chrome installed on the lab computers.

'''Tip:''' Run your database schema by a TA before implementing it.

=== Web Security and Validation ===

Your project needs to demonstrate that thought was put into web security and best practice. For more information, see this week's Web Application Security guide: [[Web Application Security, Part 3]]

In particular:

* '''Your application needs to prevent XSS attacks.''' Be careful when transmitting data over JSON that will be reflected in an event title! (Note: JSON data should be sanitized on the client side, not the server side.)
* '''Perform precautionary measures to prevent session hijacking attacks.'''
*: You should specify your session cookie to be HTTP-Only. However, for the means of this module, you need not test for user agent consistency.
* '''Optional:''' Validate your JavaScript code using [http://www.jshint.com/ JSHint] '''''or''''' [http://jslint.com/ JSLint] for up to 3 points of extra credit.

You should continue the practices that you have learned in past weeks:

* Pass tokens in forms to prevent CSRF attacks.
*: '''Hint:''' You will need to send your CSRF tokens in your AJAX requests. Remember that AJAX still submits forms and runs server-side scripts, just like the vanilla forms you've been using in Modules 2 and 3.
* Use prepared queries to prevent SQL Injection attacks.
* If storing passwords in a database, always store them salted and encrypted.
* Your page should validate with no errors through the W3C validator.

== Grading ==

We will be grading the following aspects of your work. There are 100 points total.

'''Assignments (including code) must be committed to Bitbucket by the end of class on the due date (commit early and often). Failing to commit by the end of class on the due date will result in a 0. '''

_________

# '''JavaScript Calculator (10 Points):'''
#* Calculator successfully adds, subtracts, multiplies, and divides numbers (3 points)
#* The result is automatically computed when a value in either field is changed (3 points)
#* Calculator is written entirely in pure, conventional JavaScript with no external libraries (4 points)*
#*: ''Note: be sure to fully separate content, appearance, and behavior. This means that you should '''not''' use the event attributes on the HTML elements like onclick, onchange, and onkeyup.''
# '''Weather Widget (15 Points):'''
#* Widget performs an AJAX request to fetch the current weather (4 points)
#* The HTML template is filled with the correct information, including an image (4 points)
#* Button to reload the weather widget (2 points)
#* Widget is written entirely in pure, conventional JavaScript with no external libraries (5 points)*
# '''AJAX Calendar (60 Points):'''
#* '''''Calendar View (10 Points):'''''
#** The calendar is displayed as a table grid with days as the columns and weeks as the rows, one month at a time (5 points)
#** The user can view different months as far in the past or future as desired (5 points)
#* '''''User and Event Management (25 Points):'''''
#** Events can be added, modified, and deleted (5 points)
#** Events have a title, date, and time (2 points)
#** Users can log into the site, and they cannot view or manipulate events associated with other users (8 points)
#**: ''Don't fall into the Abuse of Functionality trap! Check user credentials on the server side as well as on the client side.''
#** All actions are performed over AJAX, without ever needing to reload the page (10 points)
#* '''''Best Practices (20 Points):'''''
#** Code is well formatted and easy to read, with proper commenting (2 points)
#** If storing passwords, they are stored salted and encrypted (2 points)
#** All AJAX requests that either contain sensitive information or modify something on the server are performed via POST, not GET (3 points)
#** Safe from XSS attacks; that is, all content is escaped on output (3 points)
#** Safe from SQL Injection attacks (2 points)
#** CSRF tokens are passed when editing or removing events (3 points)
#** Session cookie is HTTP-Only (3 points)
#** Page passes the W3C validator (2 points)
#** ''Extra Credit:'' Your code passes ''JSHint'' or ''JSLint'' (+3 bonus points)
#* '''''Usability (5 Points):'''''
#** Site is intuitive to use and navigate (4 points)
#** Site is visually appealing (1 point)
# '''Creative Portion (15 Points)'''
#* '''Additional Calendars Features (worth 15 points):''' Develop some additional features for the calendar, a few examples are provided below.
#** Users can tag an event with a particular category and enable/disable those tags in the calendar view. (5 points)
#** Users can share their calendar with additional users. (5 points)
#** Users can create group events that display on multiple users calendars (5 points)
#* '''Make sure to save a description of your creative portion, and a link to your server in your README.md file.'''
''* These points can be earned only if at least 3 other points have been earned in that category. This is to prevent these points from being "free."''

[[Category:Module 5]]
[[Category:Modules]]

Module 4

2018-02-12T17:44:53Z

Alex:

__NOTOC__
In Module 4, you will learn the fundamentals of Python, a popular scripting language, and Regular Expressions, which give you power in text processing.

This article contains your assignments for Module 4.

== Reading ==

The following articles on the online class wiki textbook contain information that will help you complete the assignments.

* [[Python]]
* [[Regular Expressions]]

== Individual Assignments ==

=== Learn Python and Regular Expressions ===

Up to this point in CSE 330, you have used only one programming language: PHP. In Module 4, you will learn a new language: Python. Before starting this assignment, you should look over the [[Python|online textbook article about Python]]. You should be using version 3 (or greater) of Python. Additionally, you may find it helpful to look over the [[Regular Expressions|online textbook article about Regular Expressions]].

=== Write some Regular Expressions ===

Please write regular expressions that do each the following:

# Match the string "hello world" in a sentence
# Find all words in an input string that contains three consecutive vowels, regardless of case.
# Match an input string that is '''entirely''' a flight code, of the format AA####, where '''AA''' is a two-letter uppercase airline code, and '''####''' is a three- or four-digit flight number
Examples:
Note: text in ''[[red]]'' is matched by the regular expression. Each line is a separate test input string.
Regex 1: Programmers will often write ''[[hello world]]'' as their first project with a programming language.
Regex 2: The ''[[gooey]]'' peanut butter and jelly sandwich was a ''[[beauty]]''.
Regex 3: ''[[AA312]]''
''[[AA1298]]''
''[[NW1234]]''
''[[US443]]''
US31344
AA123 extratext

Save your regexes to a text file. The TA will test them in regexpal on Demo Day.

=== Baseball Stats Counter ===

The St. Louis Cardinals are the most legendary baseball team in the national league. In this exercise, you will be creating a Python script that reads box scores from a file and computes the Cardinals' players' batting averages in a particular season.

==== Tips and Instructions ====

* You should write a Python script file to solve this problem.
* You should use a regular expression to parse players' names, at-bats, hits, and runs from the input file.
* You may want to create a class to hold and compute information about each player.
* Your file should take one command-line argument: the path to an input file. If no path is given, your program should print a usage message.

==== Input ====

Sample input files may be found here: http://classes.engineering.wustl.edu/cse330/content/cardinals/

The top of the file contains a citation, and what follows is an entire season of Cardinals Baseball box scores. Each game starts with a title; for example:

=== St.Louis Cardinals vs. Chicago Cubs, 1940-04-19 ===

What follows are the performance of each player in that game. The format of each line is as follows:

XXX batted # times with # hits and # runs

where '''XXX''' is the player's name (you may assume that the name is unique), and each '''#''' are integers representing the number of "at bats", the number of "hits", and the number of "runs", respectively.

==== Output ====

Your script needs to output all players' batting average across the season. A player's batting average is that player's total hits divided by that player's total at-bats throughout the entire season. For example, Johnny Hopp was at bat 149 times in 1940, and he had 41 hits, so his batting average was 0.275.

Each line in the output should have the format:

XXX: #.###

where '''XXX''' is the player's name, and '''#.###''' is the player's batting average, '''rounded''' (not truncated) to three decimal places.

The players should be sorted by batting average, with the highest batting average on top. If two players have the exact same batting average (before rounding occurs), the order between those two players is unimportant.

For example, the correct output for the 1940 season is:

<source lang="text">
Pepper Martin: 0.316
Walker Cooper: 0.316
Johnny Mize: 0.314
Ernie Koy: 0.310
Enos Slaughter: 0.306
Joe Medwick: 0.304
Terry Moore: 0.304
Joe Orengo: 0.286
Jimmy Brown: 0.280
Marty Marion: 0.279
Don Gutteridge: 0.276
Johnny Hopp: 0.275
Creepy Crespi: 0.273
Mickey Owen: 0.265
Bill DeLancey: 0.250
Don Padgett: 0.242
Stu Martin: 0.238
Eddie Lake: 0.222
Hal Epps: 0.214
Lon Warneke: 0.209
Harry Walker: 0.185
Max Lanier: 0.179
Bill McGee: 0.178
Carl Doyle: 0.174
Mort Cooper: 0.157
Clyde Shoun: 0.145
Carden Gillenwater: 0.130
Bob Bowman: 0.067
</source>

== Grading ==

We will be grading the following aspects of your work. There are 50 points total.

'''Assignments (including code) must be committed to Bitbucket by the end of class on the due date (commit early and often). Failing to commit by the end of class on the due date will result in a 0. '''

Upload your baseball code, a file with your Regular expressions, and a screenshot of your python output onto Bitbucket.

# '''Regular Expressions (15 Points):'''
#* Regular Expression 1 Correct and saved in a file named <code>regex1.txt</code> (5 points)
#* Regular Expression 2 Correct and saved in a file named <code>regex2.txt</code>(5 points)
#* Regular Expression 3 Correct and saved in a file named <code>regex3.txt</code>(5 points)
# '''Baseball Stats Counter (35 Points):'''
#* Solution is written entirely in Python and saved in a file named <code>baseball.py</code> (8 points)
#* Correct usage of one or more regular expressions to parse and extract data from each line of the input file (8 points)
#* Script prints a usage message if a command line argument is not present (4 points)
#* Output is correct for all test cases (15 points)
#*: ''This includes sorting and rounding.''

[[Category:Module 4]]
[[Category:Modules]]

Module 1

2018-02-12T17:44:39Z

Alex:

__NOTOC__
Module 1 introduces the fundamentals of HTML and CSS. You will first make a static document using HTML and CSS, and then you will make a portal to a DuckDuckGo search. This module is worth 50 points.

== Reading ==

The following articles on the online class wiki textbook contain information that will help you complete the assignment.

* [[Git]]
* [[HTML and CSS]]
* [[HTML Forms]]

== Assignments ==

=== Write a Birthday Card ===

'''Write a birthday card to a friend or family member using HTML and CSS.''' Use HTML to define the content of the card (like the headings and the paragraphs), and use CSS to define the appearance. Some ideas:

* Make the background-color of the page baby blue and use purple ink to write a card to a little boy
* Make the text big and include pictures of hearts
* Use a font with text shadows (more advanced)

Use this opportunity to experiment with the plethora of CSS properties. Remember that you're in a computer science class (not an art class), so we don't care if your card looks ugly. The main thing is that you learn HTML and CSS and use them appropriately.

==== How to Edit Your File ====

Starting in Module 2, we will be using Komodo Edit as our primary development tool. However, for the purposes of this exercise, we want you to edit your HTML file using a more basic text editor. '''If you already have a text editor that works for you, like [https://www.sublimetext.com/ Sublime Text], [https://atom.io/ Atom], Vim, or Emacs, feel free to use it for the entirety of this course. The same is true if you're already a fan of an IDE - you don't ''have'' to use any of the suggestions below.'''

* On Windows, consider Notepad++. This is already installed for you in the CEC labs. If you prefer to use your personal computer, you can download it from [https://notepad-plus-plus.org/ here].

* On Mac OS X, consider TextWrangler. You can download it from [http://www.barebones.com/products/textwrangler/ here] or from the Mac App Store.
* Most Linux distributions come with gedit pre-installed, which you can use for this lab.

Please save your file as ''birthday.html'' from the plain text editor of your choice.

'''Important Note:''' Writing your web page in a word processor like Microsoft Word or even WordPad or TextEdit will ''not'' work. You need a plain text editor.

==== How to View Your HTML Document ====

Once you have ''birthday.html'', you can open it using your favorite web browser (like Firefox). For the purposes of this exercise, it suffices to right-click the file and tell it to "open with" Firefox. When the file opens, it should be under the file:/// protocol.

In Module 2, we will install a web server that serves up pages on the http:// and https:// protocols.

==== Validation ====

'''Your birthday card must pass the W3C Validators for both HTML and CSS with no errors.''' You can upload your HTML to [https://validator.w3.org/ the HTML validator] and your CSS to [https://jigsaw.w3.org/css-validator/ the CSS validator].

For more information on validation, see the HTML and CSS guide: [[HTML and CSS#Validation]]

=== Make a Portal to a DuckDuckGo Search ===

'''Write an HTML document containing a form that searches DuckDuckGo's web site.''' You should be able to type in a search term and have your form load the DuckDuckGo search page.

# Visit [https://www.duckduckgo.com/ www.duckduckgo.com]. Search for something easy to spot in the URL, like "QUERY".
# Look at the URL of the search page. What is the script URL? What is the query variable?
# Make an HTML document containing a text field and a submit button. Typing a search query into the text field and pressing the submit button should load the DuckDuckGo search page.

== Grading ==

We will be grading the following aspects of your work. There are 50 points total.

'''Assignments (including code) must be committed to Bitbucket by the end of class on the due date. Commit early and often. Failing to commit by the end of class on the due date will result in a 0.

# '''Birthday Card (30 Points):'''
#* Correct usage of HTML and CSS in your birthday card (10 points).
#*: ''Make sure that you use HTML for "content" and CSS for "appearance." Don't write inline styles: use a separate stylesheet and link your HTML file to it.''
#* Experimenting with at least 5 different CSS properties in your birthday card (10 points).
#* Birthday card passes the W3C validation for HTML 5 and CSS. (10 points).
# '''Search Portal (10 Points):'''
#* DuckDuckGo search portal is functional (10 points).
# '''Account Creation and Version Control (10 Points):'''
#* Bitbucket account created (2 Points)
#* Module 1 repo created using the link provided on Piazza (2 Points)
#* Account created on Amazon Web Services and an image file containing a screenshot of your account page pushed to Bitbucket. (4 Points)
#* Files pushed to repo on Bitbucket using Git (2 Points)

[[Category:Module 1]]
[[Category:Modules]]

Module 2

2018-02-12T17:44:27Z

Alex:

__NOTOC__
Module 2 introduces you to Linux, a command-line environment, the Apache web server, and PHP. You will create and configure your own cloud instance, install Apache and related software, and then form groups to make a simple file sharing site.

<span style="font-size:1.3em; line-height:1.2em; color:blue;">'''DO NOT WAIT UNTIL THE LAST MINUTE TO START ON THIS (or any) MODULE!''' The most common reason students perform poorly in this class is procrastination. You have been warned.</span>

== Reading ==

The following articles on the online class wiki textbook contain information that will help you complete the assignments.

* [[Linux]]
* [[Bash]]
* [[Amazon Web Services]]
* [[SSH]]
* [[Apache]]
* [[PHP]]
* [[Workflow]]
* [[Web Application Security, Part 1]]

== Individual Assignments ==

{{RequiredInstructions|content=

<span style="color:red">There are a lot of wiki pages that you need to read in order to complete the individual portion of Module 2. The wiki pages contain an assortment of required steps, optional steps, and information. To make things easier, we have highlighted the ''required steps'' with a red bar, like you see on the left of this message. Do not skip anything marked with a red bar, or else you will not have a perfectly configured instance.</span>

}}

=== Learn About Linux ===

Linux is an open-source operating system based on UNIX. Linux is highly versatile and is used in a wide range of applications.

If you are not a Linux guru, read the Linux guide to get started: [[Linux]]

=== Windows Users Only: Enable Windows Subsystem for Linux (WSL) or Install Cygwin ===

You will need WSL or Cygwin in order to log into and configure your EC2 instance. Cygwin is already installed on the CEC machines. If you're using Windows 10, you can use WSL, which is an officially-supported way of accessing a Linux terminal on Windows. If not, you'll have to use Cygwin. Instructions for installing either on your personal machine are located in [[Workflow#Cygwin|the Workflow guide]].

Mac OS X users should located the "Terminal" application, which is installed by default; you will need this in the coming steps.

=== Create an AWS EC2 Instance ===

Once you understand [[Linux]], you need to set up your Amazon EC2 Instance. Use the AWS article to guide you through the process: [[Amazon Web Services]]

=== Configure SSH ===

Follow the instructions in [[SSH#SSH Configuration|the SSH guide]] to do the following:

# Create your own SSH key pair
# Log in as the default user to your EC2 instance
# Create a new user
# Give the new user your SSH public key

From now on, when you need to log into your EC2 instance as an administrator, just pop up a terminal and run:

<source lang="bash">
$ ssh your-username@ec2-xx-xx-xx-xx.compute-1.amazonaws.com
</source>

=== Install Essential Packages ===

Recall that software installation in Linux instances is usually handled through a package manager, like '''yum'''. For more information, refer to [[Linux#Repository-Based Package Managers|the Linux guide]].

To make sure everything is working properly, '''install your first package(s) according to the ''Essential Packages'' subsection in the Linux guide.'''

=== Set the Timezone ===

'''Set your server to use US Central time (America/Chicago).''' Instructions are in the Linux guide: [[Linux#Synchronizing Date and Time]]

=== Set Up the Apache Web Server ===

You need to '''install the Apache web server on your EC2 instance'''. Refer to [[Apache|the Apache guide]].

In order for your web server to be accessible, you need to '''open up Port 80 on your EC2 instance'''. Instructions are in the AWS guide: [[Amazon Web Services#Enabling Web Access to your EC2 Instance]]

'''Enable the UserDir module in Apache.''' Instructions are in the Apache guide: [[Apache#The UserDir Module]]

=== Install PHP ===

You need to '''install PHP on your EC2 server'''. Instructions are at the top of the PHP guide: [[PHP]]

You need to '''configure PHP to show errors'''. Instructions are immediately below installation in the PHP guide.

=== Learn about the PHP Language ===

Before you can continue, you will need to make yourself acquainted with PHP language components. Read the PHP guide for an overview: [[PHP#PHP Language Components]]

=== Set Up your Workspace ===

You are now ready to set up the workspace that you will be using for the rest of the semester. Follow the instructions in [[Workflow]] to:

# Make an account on Bitbucket
# Setup a repo using the CSE 330 Repo Creation Tool
# Install SourceTree
# '''Windows only:''' Set up Pageant so that SourceTree can conect to Bitbucket
# Clone your CSE 330 repo from Bitbucket
# Install Komodo Edit
# Create a Komodo Edit Project inside of your Git repository
# Add the ''*.komodoproject'' file to ''.gitignore''
# Install FileZilla
# Connect FileZilla to your remote instance

=== Calculator ===

'''Make a calculator using PHP and an HTML form.''' The form should have two inputs. The form should submit a GET request either back to the same page or to a different results page. The calculator should support addition, subtraction, multiplication, and division by means of a radio button group on the page. (Consider edge cases!)

== Group Project ==

You will work in pairs (that means you and one other person) on this project.

<span style="font-size:1.3em; line-height:1.2em; color:blue;">In this module, and all future modules, the group portion builds off of material you learn in the individual portion. You should therefore complete the individual portions prior to working on the group portions. (Trust us: it will make your life easier!)</span>

'''Important Reminder:''' frequently commit your work to your repository as a backup!

=== Simple File Sharing Site ===

You will be making a simple file sharing site that supports uploading, viewing, and deleting files associated with various users. Details:

* You should have a file named '''users.txt''' stored in a secure place on your filesystem. It should have at least three usernames, with one username per line.
*: Passwords add an extra layer of complexity (encryption) that we will cover in Module 3. You will not earn credit for implementing passwords as your creative portion for this module.
* Users of the file sharing site should be able to enter their username and then log in.
*: You may implement logins using session variables, or you may implement them using a GET parameter that is passed between pages. You will need to always use sessions starting in Module 3.
* Users should see a list of all files associated with their username after the log in.
* Users should be able to view, upload, and delete files associated with their username.
* The URI should NOT reveal the internal file structure of your web site.
** Example of what not to do: http://www.example.com/download.php?file=/home/paul/file.txt
** Another bad example: http://www.example.com/~user/file.txt
** Good example: http://www.example.com/view.php?user=music&name=file.txt
*: In general, don't reveal any internal information about the site.
*: '''Food for thought:''' Given that Apache processes (with the exception of the main process) do not run as root, but rather as the user apache, how can you allow both your user account and the php scripts to read and write the
*:necessary files?
*:: ''Hint:'' You shouldn't be storing the user-uploaded files in public_html (that is only the place for your own web-page files),
*::''Hint number 2:'' you will need to use chown to change permissions to let user apache have permissions on the user-files (that '''are not''' in the public_html folder). If you don't know what this does or how to do this, look at the [[Apache]] page
* You should customize your file sharing site by implementing an additional feature or two as part of the '''creative portion'''.

You will probably find the PHP guide on this wiki to be helpful: [[PHP#Other PHP Tips]]

=== Web Security and Validation ===

Your project needs to demonstrate that thought was put into web security and best practice. For more information, see this week's Web Application Security guide: [[Web Application Security, Part 1]]

In particular:

* '''Your application needs to follow the conventions of FIEO (Filter Input and Escape Output)'''. Things you should filter include file names, usernames, and so on.
* '''Your project must pass the W3C Validator with no errors'''. For more information, see the HTML and CSS guide: [[HTML and CSS#Validation]]

== Grading ==

We will be grading the following aspects of your work. There are 100 points total.

'''Assignments (including code) must be committed to BitBucket by the end of class on the due date. Commit early and often. Failing to commit by the end of class on the due date will result in a 0.

_____________

# '''Cloud Instance and Web Server (30 Points):'''
#* You can SSH into your instance using your own custom username and SSH key. Put a screenshot in your repository of your terminal SSH-ing into your instance (15 points)
#* Your custom username is able to perform SUDO commands. Put a screenshot in your repository of you successfully executing a command with sudo (5 points)
#* The time zone is correct on your instance. Put a screenshot in your repository of the results of the `date` command (5 points)
#* The UserDir Apache module is working. Place a file in /home/<username>/public_html and link to the file in your README.md (5 points)
# '''PHP Calculator (15 Points):'''
#* The calculator is able to perform all four functions with floating point numbers (2 points each, 8 points in total)
#* Each function is given as a radio button choice (4 points)
#* The calculator page passes the W3C HTML validator (3 points)
#* '''''Make sure you have a README.md file in your individual repo with the the link to your calculator.''''' See the Creative Portion section for more information about .md files.
# '''File Sharing Site (40 Points):'''
#* '''''File Management (25 Points):'''''
#** Users should not be able to see any files until they enter a username and log in (4 points)
#**: ''Remember that users.txt should be stored in a secure location on your filesystem. That is, '''you should not be able to type any URL into your browser and see the raw users.txt file!'''''
#** Users can see a list of all files they have uploaded (4 points)
#** Users can open files they have previously uploaded (5 points)
#**: ''Note: Users should be able to open not only plain text files but also other file formats: images, spreadsheets, etc.''
#** Users can upload files (4 points)
#**: ''Note: Like users.txt, uploaded files should be stored in a secure location on your filesystem. That is, '''do not keep your uploads directory underneath a directory served by Apache!'''''
#** Users can delete files. If a file is "deleted", it should actually be removed from the filesystem (4 points)
#** The directory structure is hidden (2 points)
#** Users can log out (2 points)
#**: ''Note: If using session variables, you must ''actually'' log out the user by destroying their session; i.e., don't just redirect them to the login screen.''
#* '''''Best Practices (10 Points):'''''
#** Code is well formatted and easy to read, with proper commenting (4 points)
#** The site follows the FIEO philosophy (3 points)
#** All pages pass the W3C validator (3 points)
#* '''''Usability (5 Points):'''''
#** Site is intuitive to use and navigate (4 points)
#** Site is visually appealing (1 point)
# '''Creative Portion (15 Points)''' (see below)
#* '''''Make sure you have a README.md file in your group repo with the following:'''''
#** An .md file is a plain text file called a markdown file [https://guides.github.com/features/mastering-markdown/ ] .
#***The contents of your README.md file are shown on your repo, making it easier for us to grade
#*** You may style the page with bolding, hyperlings, images, block quotes and lists
#*** [http://dillinger.io/ This online markdown editor] makes it easy to learn this format
#** The link to your file sharing site. '''''We need this to grade your work.'''''
#** A brief description of what you did for your creative portion
#** Any additional login details needed for the TA

=== Creative Portion ===

This module and all future modules will require that you invest some time into creating additional features for your group project. Plan to invest at least 60 minutes of your time into the creative portion.

* The creative portion is an opportunity for you to learn the material of your own interest.
* You will not earn credit for a creative-portion feature that simply rehashes something you've already done in a previous module.

If you need ideas for a creative portion, or if you want to know whether or not your creative portion idea is "hard enough", ask a TA.

[[Category:Module 2]]
[[Category:Modules]]

Module 3

2018-02-12T17:44:03Z

Alex:

__NOTOC__
In Module 3, you will learn about MySQL, a web application database.

This article contains your assignments for Module 3.

== Reading ==

The following articles on the online class wiki textbook contain information that will help you complete the assignments.

* [[Introduction to MySQL]]
* [[MySQL Schema and State]]
* [[PHP and MySQL]]
* [[Web Application Security, Part 2]]

== Individual Assignments ==

You will create a simple grades database containing four tables.

'''IMPORTANT:''' The individual assignment is to be done by writing queries by hand. (You can use phpMyAdmin to run the queries, but '''do not let phpMyAdmin write your queries for you!''') Writing your own queries gives you a greater understanding of the underlying mechanisms and databases in general. Additionally, having SQL knowledge and experience is a very marketable trait.

=== Install MySQL and phpMyAdmin ===

Before you start, '''you need to install MySQL''' on your EC2 instance. You may also install phpMyAdmin, a web frontend to MySQL, if you choose to do so.

=== Set Up a Database ===

You may find the following article to be very helpful: [[Introduction to MySQL]]

# Create a database named '''wustl'''
# Create a user named '''wustl_inst''' and give them the password '''wustl_pass'''

=== Create Tables ===

You may find the following article to be very helpful: [[MySQL Schema and State]]

When creating tables, keep the following items in mind:

* You should create all tables such that they use the InnoDB storage engine, since we wish to make use of its support of foreign keys. In other database engines, foreign key constraints are not enforced. (If you mess up, you can use ALTER TABLE to change the storage engine.)
* Where it is appropriate, you should take advantage of the ability to define fields NOT NULL so that you do not inadvertently insert incomplete data for a row.

Create the following tables:

# Create a table named '''students''' with the following fields:
#* '''id''' of an appropriately-sized unsigned integer type (we will never need to process more than a million students)
#* '''first_name''' of type '''VARCHAR(50)'''
#* '''last_name''' of type '''VARCHAR(50)'''
#* '''email_address''' of type '''VARCHAR(50)'''
#: The primary key should be on the '''id''' field.
# Create a table named '''departments''' with the following fields:
#* '''school_code''' of type '''ENUM''' (e.g. "L" for ArtSci and "E" for Engineering). The options are as follows:
#*: 'L', 'B', 'A', 'F', 'E', 'T', 'I', 'W', 'S', 'U', 'M'
#* '''dept_id''' of an appropriately-sized unsigned integer type (in the foreseeable future there will never be more than 200 departments in a school)
#* '''abbreviation''' of type '''VARCHAR(9)''' (e.g. CSE, ChemE, etc)
#* '''dept_name''' of type '''VARCHAR(200)''' (e.g. Computer Science and Engineering)
#: The primary key should be on two fields: '''school_code''' and '''dept_id'''
#: '''Note:''' Why not just use the department ID for the primary key? The ID numbers are sometimes reused across schools. For instance, department 33 in The College of Arts and Sciences is Psychology while department 33 in The School of Engineering and Applied Sciences is Energy, Environmental and Chemical Engineering. Thus we must also include the school code to differentiate them such that the record for E33 is distinct from that of L33.
# Create a table named '''courses''' with the following fields:
#* '''school_code''' of type '''ENUM'''
#*: This should have the same letters in the same order as the '''school_code''' '''ENUM''' field in the '''departments''' table.
#* '''dept_id''' of the same size of integer as in the '''departments''' table
#* '''course_code''' of type '''CHAR(5)''' (this will hold course codes; e.g., '330S', '131', '2960')
#* '''name''' of type '''VARCHAR(150)'''
#: The appropriate fields in this table should make a foreign key reference to the corresponding fields in '''department'''.
#: In addition, it is up to you to determine the field(s) for the primary key.
#: '''Note:''' If you are unsure which fields to make the foreign keys and feel the need to beg your friends or the TAs to give you the answer, bang your head on your desk whilst repeating "I WILL EXERCISE REASON AND COMMON SENSE AND I WILL CURTAIL MY DESIRE TO BLINDLY FOLLOW DIRECTIONS"
#: ''Disclaimer: don't actually bang your head on your desk, the resulting head trauma may in fact make it harder for you to determine which fields should have associated foreign keys.''
# Create a table named '''grades''' with the following fields:
#* '''pk_grade_ID''' of an appropriately-sized unsigned integer type (should be larger than the one you chose for the '''students''' table). There will never be more than 1,000 grades per student.
#*: You should declare this field to be '''auto_increment''' and make it the primary key.
#*: This is called a ''surrogate key'' as opposed to a ''natural key'' because it doesn't arise "naturally" from the data; that is to say that it is not derived from application data. The use of surrogate keys vs. natural keys is a polemic issue amongst database designers. For a decently unbiased take on the issue, see this page: http://www.agiledata.org/essays/keys.html#Comparison
#*: '''Food for thought:''' Aside from simply exposing you to the concept, can you think of any reasons why a surrogate key might be preferable for this table? Alternatively, what attributes, if any, could you use as a natural key, and what might be the drawbacks of doing so?
#* '''student_id''' of the same integer (unsigned) type that you chose in the '''students''' table
#* '''grade''' of type '''decimal(5,2)'''
#* '''school_code''' of type '''ENUM'''
#*: Can you guess what entries to use for the enum?
#* '''dept_id''' of the same integer type that you've used for this field in other tables
#* '''course_code''' of the same type you chose for the course code in the '''courses''' table
#: The '''grades''' table should have foreign keys to both the '''students''' table and the '''courses''' table.

=== Populate Tables ===

Now, populate the tables by downloading the text files given below and loading them into the appropriate tables.

'''Note:''' Do not insert all the values manually; instead, use the MySQL's ability to load in data from text files.

You may find the following article to be very helpful: [[MySQL Schema and State]]

The files containing the data are:
* students: http://classes.engineering.wustl.edu/cse330/content/students_data.txt
* courses: http://classes.engineering.wustl.edu/cse330/content/courses.txt
* departments: http://classes.engineering.wustl.edu/cse330/content/departments_data.txt
* grades: http://classes.engineering.wustl.edu/cse330/content/grades_data.txt

=== Insert More Data ===

Insert the following data into the tables that you have created and populated:

# Insert entries for CSE 330S, CSE 131, and CSE 260M.
#: ''If you don't know CSE's department code, how can you find out using the tables in the database?''
# Insert the grades given for the students named below.
#* '''Ben Harper'''
#** E-mail: '''bharper@ffym.com'''
#** Student ID: '''88'''
#** Grades:
#*** 35.5 in CSE 330S
#*** 0 in CSE 131
#*** 95 in CSE 260M
#* '''Matt Freeman'''
#** E-mail: '''mfreeman@kickinbassist.net'''
#** Student ID: '''202'''
#** Grades:
#*** 100 in CSE 330S
#*** 90.5 in CSE 131
#*** 94.8 in CSE 260M
#* '''Marc Roberge'''
#** E-mail: '''mroberge@ofarevolution.us'''
#** Student ID: '''115'''
#** Grades:
#*** 75 in CSE 330S
#*** 37 in CSE 131
#*** 45.5 in CSE 260M

=== Querying Your Database ===

Now that you have a fully-functional, populated database, let's do some queries on it!

Please Running the following <code>SELECT</code> queries, then copy the output to a text file of the form <code>query1.txt</code>, <code>query2.txt</code>, and so on, and commit them with the rest of your repository (be sure to include your query command and the entire response, including the number of results found). For each query, only the requested columns should be present. You will receive 0 points for any query that includes additional columns.

# Select the entire grades table.
# Select all fields describing the courses offered in the College of Arts & Sciences (school code <code>L</code>).
# The names, student IDs, and CSE330 grades of all students who are in CSE330S.
#: '''Note:''' This query should involve joins. You don't need to use any aggregation functions.
# The names, e-mails, and average grades of any student with an average below 50 so that the dean can send them an email notification that they are now on academic probation.
#: ''You should be able to do this in only one query, without making any temporary tables. You will need to use aggregation functions and the <code>HAVING</code> keyword.''
# An individual report card for Jack Johnson, consisting of only his student ID, e-mail address, and average grade.
#: ''Again, you should be able to do this in just one query, using the correct combination of aggregation functions and joins.''
#: '''Note:''' Your query must look for students with the name "Jack Johnson" instead of hard-coding the student ID.

== Group Project ==

You will work in pairs on this project. You may work with the same partner from Module 2, or change to someone else.

'''Important Reminder:''' frequently commit your work to your Git repository as a backup!

=== Simple News Web Site ===

'''Examples:'''
* http://digg.com/
* http://slashdot.org/

You should use '''PHP''' unless you get permission to use another web technology from the instructor. You may also use phpMyAdmin to help set up databases.

You may find this wiki article helpful: [[PHP and MySQL]]

==== Requirements ====

* Users can register for accounts and then log in to the website.
* Accounts should have both a username and a ''secure'' password. '''NEVER store plaintext passwords in a database!'''
*: For more information on password security, refer to [[Web Application Security, Part 2#Password Security|the Web Application Security guide]].
* Registered users can submit story commentary.
*: A link can be associated with each story, and they should be stored in a separate database field from the story
* Registered users can comment on any story.
* Unregistered users can only view stories and comments.
* Registered users can edit and delete their stories and comments.
* All data must be kept in a MySQL database (user information, stories, comments, and links).
* Creative Portion

=== Web Security and Validation ===

No application is finished until much thought is put into web security and best practice. Throughout this course, we heavily emphasize the dogma of [http://coderesponsibly.org/ responsible] coding.

Read this week's Web Application Security guide: [[Web Application Security, Part 2]]. In particular, your project needs to:

* '''Your application needs to be secure against SQL injection attacks'''. If you are using prepared queries, you should already be safe on this front.
* '''Your passwords need to be securely hashed salted''' to prevent rainbow table attacks.
* '''You should pass tokens in forms''' to prevent CSRF attacks.
* '''You should check all preconditions on the server side''' to prevent Abuse of Functionality attacks.

You shouldn't forget the practices you learned last week:

* '''Your page should validate''' with no errors through the W3C validator.
* '''Filter Input and Escape Output''', but not the other way around.

== Grading ==

We will be grading the following aspects of your work. There are 100 points total.

'''Assignments (including code) must be committed to Bitbucket by the end of class on the due date (commit early and often). Failing to commit by the end of class on the due date will result in a 0. '''

'''If you do not include a link to your group portion running on your instance in your group portion README.md, you will receive a 0 for the group portion.'''
________

# '''MySQL Queries (25 Points):'''
#* A MySQL server is running on your instance (2 points)
#* Tables' fields, including data types and foreign keys, are correct (8 points)
#*: ''Note: To demonstrate the structure of your tables, you should commit a file containing the output of the <code>SHOW CREATE TABLE</code> command '''for each table.''' Each table's file should have a name of the form <code>tablename.sql</code> (e.g. <code>students.sql</code>).''
#* The output of each of the five queries is correct. (3 points each)
#*: ''Note: To demonstrate the output of your queries, text files containing the 'entire' result (including the number of record found) of running each query should committed to BitBucket. The file for query 1 should be named <code>query1.txt</code>, the file for query 2 should be named <code>query2.txt</code>, and so on.''
# '''News Site (60 Points):'''
#* '''''User Management (20 Points):'''''
#** A session is created when a user logs in (3 points)
#** New users can register (3 points)
#** Passwords are hashed, salted, and checked securely (3 points)
#**: ''Note: You will receive 0 points for this section if you use the <code>==</code> or <code>===</code> operators to compare password hashes, or if you use the <code>crypt</code> or <code>md5</code> functions at any point.''
#** Users can log out (3 points)
#** A user can edit and delete his/her own stories and comments but cannot edit or delete the stories or comments of another user (8 points)
#* '''''Story and Comment Management (20 Points):'''''
#** Relational database is configured with correct data types and foreign keys (4 points)
#*: ''Note: To demonstrate the structure of your database, you should commit a 'single' text file containing the output of the <code>SHOW CREATE TABLE</code> command '''for all tables in your database,''' called <code>tables.sql</code>. This one file should contain the output for all of your tables.
#** Stories can be posted (3 points)
#** A link can be associated with each story, and is stored in a separate database field from the story (3 points)
#** Comments can be posted in association with a story (4 points)
#** Stories can be edited and deleted (3 points)
#** Comments can be edited and deleted (3 points)
#**: ''Note: Although there are only 6 points allocated for editing/deleting in this section, there are 8 more points at stake in the User Management section that cannot be earned unless editing/deleting is implemented. Implementing editing but not deleting, or vice-versa, will result in earning half the points.''
#* '''''Best Practices (15 Points):'''''
#** Code is well formatted and easy to read, with proper commenting (3 points)
#** Safe from SQL Injection attacks (2 points)
#** Site follows the FIEO philosophy (3 points)
#** All pages pass the W3C HTML and CSS validators (2 points)
#** CSRF tokens are passed when creating, editing, and deleting comments and stories (5 points)
#* '''''Usability (5 Points):'''''
#** Site is intuitive to use and navigate (4 points)
#** Site is visually appealing (1 point)
# '''Creative Portion (15 Points)''' (see below)
#* '''''Make sure you have a README.md file in your group repo with the following:'''''
#** Names and Student IDs of all the group members
#** A link to your homepage of the site
#** A brief description of what you did for your creative portion
#** Any additional login details needed for the TA

[[Category:Module 3]]
[[Category:Modules]]

JavaScript

2018-02-05T18:13:25Z

Alex: /* Events */

JavaScript is the most widely used scripting language for implementing client-side functionality in Web applications, and, in recent years, it's become very popular for server-side application, too. Unlike PHP, JavaScript code can be interpreted and executed in a client's web browser, instead of on the web server, depending on how it's being used.

== JavaScript? Did you mean Java? ==

'''JavaScript''' is a prototype-based programming language focused on web interactivity. It was first introduced in Netscape Navigator, and it in turn gave rise to what is now '''[http://www.ecmascript.org/ ECMAScript]'''. Originally, JavaScript was called "LiveScript". Sun, the developer of Java at the time, wanted a language that would complement its compiled Java language, and so LiveScript was renamed JavaScript.

Beyond that, '''Java and JavaScript are as similar as Ham and Hamster.'''

Java and JavaScript have similar syntax, but the under workings are quite different. For example, Java requires strict typing, but JavaScript allows for dynamic typing. Java is object-oriented, but JavaScript is prototype-oriented. Java is compiled, but JavaScript is interpreted. Java supports event listeners, but JavaScript makes them a fundamental part of the language. Java variables are scoped to the innermost method or loop, but JavaScript variables are scoped only to the innermost function.

== JavaScript Language Components ==

This section highlights some features of the JavaScript language that differentiate it from other languages. For a more comprehensive JavaScript tutorial, the following tutorials are both quality:

* [https://webplatform.github.io/ WebPlatform]: Great for learning JavaScript for the first time. Advocates best practices for modern JavaScript development.
* [http://www.quirksmode.org/js/contents.html QuirksMode]: More advanced than the WebPlatform tutorial, but it thoroughly covers the most powerful aspects of pure JavaScript and gives unparalleled advice on browser compatibility.

Advice: Do '''NOT''' Google for "JavaScript Tutorial". The first few hits advocate bad or outdated practices. Stick with the ones listed here.

=== Variables and Scope ===

To define a variable in JavaScript, use the '''let''' keyword.

<source lang="javascript">
let foo = "bar";
</source>

To define a constant in JavaScript, use the '''const''' keyword.

<source lang="javascript">
const foo = "bar";
</source>

All variables are objects. In the case above, the variable '''foo''' is an object of the class '''String'''.

Notice that like PHP, you do not have to explicitly define a type for a variable like '''int''' or '''String'''; this is because JavaScript and PHP are ''dynamically typed languages''.

JavaScript code can access any variable higher in the “function tree”, but not vice-versa. This is called '''scope'''. ''All functions create their own scope.''

When you reference a variable, JavaScript will look up through the "function tree" until it finds the variable you asked for. This means that you could define variables of the same name as global variables inside of functions. For demonstration of concept:

<source lang="javascript">
const a = "hello";
const b = "world";

function sayGoodByeWorld(){
const a = "goodbye";

alert(a); // goodbye
alert(b); // world
}

sayGoodByeWorld();

alert(a); // hello
</source>

=== Object Literals ===

A very common way of storing and transporting data in JavaScript is by using objects. You can define an object with certain properties using an '''object literal''':

<source lang="javascript">
const apple = {
color: "red",
flavor: "sweet",
season: "autumn"
}

alert(apple.color); // red
</source>

=== Functions ===

To define a function in JavaScript, use the '''function''' keyword.

<source lang="javascript">
function sayHello(){
alert("Hello World");
}

sayHello(); // call the function
</source>

Pass an argument to a function like this:

<source lang="javascript">
function sayHello(name){
alert("Hello, "+name);
}

sayHello("Todd"); // call the function and pass an argument
</source>

==== Functions are Objects ====

In JavaScript, functions are objects. This means that they can be assigned to variables, manipulated on the fly, and even passed as arguments to other functions! '''''This is an extremely important feature of JavaScript''''' that makes it such a robust language for web development.

You create a function variable like this:

<source lang="javascript">
const sayHello = function(){
alert("Hello World");
}

sayHello(); // call the function
</source>

Observe that you can make [[#Variables and Scope|scope-dependent]] functions in this way.

=== Closures ===

{{DoctypeTV
|youtube_id=HaPlj796ngQ
|time=5m45s
|desc=JavaScript Closures
}}

A '''closure''' is a way to separate a certain snippet of JavaScript code from the global scope. This is useful if you do not want to "muck up" global variables. Closures are nothing more than anonymous functions that are called as soon as they are created:

<source lang="javascript">
const a = "hello";

(function(){
const b = "world";

alert(a); // hello
alert(b); // world
})();

alert(a); // hello
alert(b); // ReferenceError: b is not defined
</source>

{{JSFiddleExample
|title=Passing Variables to a Closure
|desc=This example demonstrates how you can "save" previous versions of a variable using closures. This is possible because of scoping and the fact that function variables can be returned as objects.
|fiddle_id=YURqa
}}

Most JavaScript libraries (like jQuery) write all of their code in a closure. What this means is that except for one or two variable names (jQuery or $), everything associated with the library is completely self-contained.

=== Prototypal Inheritance ===

JavaScript implements '''prototypal inheritance''', as opposed to a language like Java or C++, which implements '''classical inheritance'''. JavaScript is one of only a handful of languages implementing prototype-based inheritance.

Here's how it works. Every callable object (function) has a '''prototype'''. When instances of that object are created, their properties and methods are copied (inherited) from the prototype. Additionally, changes made to the prototype later in the program are "copied" to every instance.

For example, if you wanted to make a method on all strings that added a “!”, you could modify String’s prototype:

<source lang="javascript">
String.prototype.bang = function(){
return this+"!"; // Notice: the context is the instance itself
}

alert("Hello".bang()); // alerts Hello!
</source>

To "extend" an object, just copy its prototype to a new object. However, since classical inheritance and prototypal inheritance are different concepts, copying prototypes may have results that you don't expect. [http://beej.us/blog/data/javascript-prototypes-inheritance/ This article] seems to have a pretty good explanation of how to "inherit" prototypes with example implementations.

==== Extending Built-In Prototypes ====

You should be aware that there is an active debate in the web development community about whether it is good programming style to extend the prototypes of built-in objects like String and Array, such as in the ''String.prototype.bang'' example above. There are legitimate arguments on both sides. [http://stackoverflow.com/questions/8859828/javascript-what-dangers-are-in-extending-array-prototype This Stack Overflow post] has good links to some articles discussing this issue.

=== Context ===

{{DoctypeTV
|youtube_id=0a4r4bm1nQA
|time=4m32s
|desc=The ''this'' Variable in JavaScript
}}

Every function is called on a certain object, which is not necessarily the same object in which it was defined. This is called '''context'''.

To call a function on an arbitrary context, use either '''call''' or '''apply'''. ''call'' takes a list of arguments, while ''apply'' takes them all in an array.

To access the current context, use the '''this''' keyword. Demonstration of concept:

<source lang="javascript">
const sayThisColor = function(){
alert(this.color);
}

const apple = { color: "red" }

sayThisColor(); // undefined
sayThisColor.call(apple); // red
</source>

== Events ==

Events are really what make JavaScript such a powerful language for web development.

Rather than being thread based, JavaScript is event based. Since all JavaScript code runs in a single thread, '''there are no concurrency issues'''. When an event occurs, JavaScript automatically calls the ''event callback'' as soon as all previous events' callbacks have finished executing.

Code in the form of a '''callback function''' is associated with events via a '''listener'''. For example, the following JavaScript causes ''sayHello()'' (the callback function) to be run whenever the button with ID "hello" is clicked (the event):

<source lang="javascript">
const sayHello = function(){
alert("Hello World");
}

document.getElementById("hello").addEventListener("click", sayHello, false);
</source>

{{JSFiddleExample
|title=Binding Callbacks to a Button Click
|fiddle_id=L8c4Z
|cse330=true
|desc=In this example, notice how we bind the callback function when the ''DOMContentLoaded'' event fires. This is because JavaScript requires that the button has been parsed by the browser before it can add event listeners to it.
}}

The '''addEventListener''' method takes three parameters:
* The event type
* The callback function
*: The callback function is passed one parameter: the event object.
* A boolean representing bubble (false) or capture (true) phase
*: You usually want Bubble phase. For more information on event phase, see [[#Event Phase]]

Note that versions of Internet Explorer prior to version 9 required that you use a different, albeit similar, function for assigning event listeners called '''attachEvent'''. attachEvent takes the same arguments as addEventListener, except you need to put '''on''' before the event type (e.g. "onclick"), and the third argument (phase) is not necessary.

It is perfectly valid to use an '''anonymous function''' as your callback function:

<source lang="javascript">
document.getElementById("hello").addEventListener("click", function(event){
alert(`Hello, World! Event Type: ${event.type}`);
}, false);
</source>

QuirksMode has perhaps the best series of articles about the ins and outs of JavaScript events on the internet: http://www.quirksmode.org/js/contents.html#events

=== The Event Object ===

Callback functions are passed one argument: an ''event object''. You see above that one property of the event object is ''event.type''. To see the full list of properties of the event object, you could run the code:

<source lang="javascript">
document.getElementById("my_btn").addEventListener("click", function(event){
let strout = "";
for(var i in event){
strout += `${i}: ${event[i]}\n`;
}
console.log(strout);
}, false);
</source>

Some of the most useful properties and methods include:
* '''event.target''' references the object on which the event occurred.
* '''event.currentTarget''' references the object whose listener is currently being processed.
*: ''Note:'' event.target and event.currentTarget might be the same or might be different, depending on whether you are listening for bubbled events.
* '''event.preventDefault()''' stops the normal result of the event from being executed. For example, if you listen for a form's ''submit'' event, you can call event.preventDefault() to stop the form from being submitted.
* '''event.stopPropagation()''' prevents any other event listeners from being executed. For more detail, read the section on Event Phase below.

For more detail on the event object, see [http://dev.w3.org/2006/webapi/DOM-Level-3-Events/html/DOM3-Events.html#interface-Event the W3C specification].

'''Note:''' If your callback function does not take any parameters, it will still run; you just won't have as easy of access to the event object.

=== Event Handlers and Memory Management ===

JavaScript is an automatically garbage-collected language, meaning that memory management is mostly taken care of for you. However, there are some instances when you need to be careful about creating "zombie" objects. In JavaScript, this mostly revolves around the idea of event listeners.

I could give an explanatory example, but instead I'll tell you straightaway that '''the moral of the story is that for every "addEventListener", there should probably be a "removeEventListener".''' Here are some good articles to satisfy your hunger for more details on event listeners and JavaScript memory management:

* http://www.vladalexandruionescu.com/2012/08/javascript-memory-leaks.html
* http://lostechies.com/derickbailey/2012/03/19/backbone-js-and-javascript-garbage-collection/
* http://stackoverflow.com/questions/5326300/garbage-collection-with-node-js

When you start working with Node.JS in the next module, it's more important than ever to keep good accounting of your event listeners.

=== Event Phase ===

In JavaScript, events occur in two phases: '''Capture Phase''' and '''Bubble Phase'''. Consider the following HTML document:

<source lang="html4strict">
<!DOCTYPE html>
<html>
<head><title>Event Test</title></head>
<body>
<div id="box">
<button id="btn">
Hello
</button>
</div>
</body>
</html>
</source>

Suppose the user clicks on the "Hello" button. Events will be fired in the following order:

# Capture Phase CLICK on the Document
# Capture Phase CLICK on the Body
# Capture Phase CLICK on the Div#box
# Target Phase CLICK on the Button#btn
# Bubble Phase CLICK on the Div#box
# Bubble Phase CLICK on the Body
# Bubble Phase CLICK on the Document

{{JSFiddleExample
|title=Using Capture Phase to Enable or Disable a Toolbar
|fiddle_id=r32Dz
|desc=We bind an event in the capture phase to the div with ID ''toolbar''. When ''e.stopPropagation()'' is called, the event does not reach the buttons in the toolbar.
}}

Graphically, here is the order in which an event occurs in three generic nested elements:

[[File:EventPhase.gif]]

Why is this useful? Suppose you have a control panel (toolbar, etc) that you want to temporarily deactivate. (For example, Bold/Italic/Underline buttons on a graphic text editor that currently has no content.) You could keep bubble phase event listeners on your buttons, but prevent those events from occurring by stopping the event in the capture phase on the parent element before the event reaches your buttons! Example:

<source lang="javascript">
const disableToolbarFunc = function(e){
e.stopPropogation();
}

// To disable toolbar:
document.getElementById("box").addEventListener("click", disableToolbarFunc, true);

// To re-enable toolbar:
document.getElementById("box").removeEventListener("click", disableToolbarFunc, true);
</source>

'''Word of caution:''' Like many great things in web development, capture phase does not work in versions of Internet Explorer prior to version 9. There is no elegant substitution for older versions of Internet Explorer.

'''Note:''' When the event reaches the innermost element, there is no distinction between capture phase and bubble phase. The order in which event handlers were added to the element determines the order in which those callbacks are evaluated.

== Document Object Model ==

The '''Document Object Model (DOM)''' is what enables JavaScript to manipulate the content of your web page.

=== Nodes and Traversing the DOM ===

Each element on your page, whether it is a <nowiki><p>, <img/></nowiki>, a string of text, or even an attribute, is called a '''node'''.

Every node, except for the document itself, has exactly one parent. A single node may have multiple children.

Consider the following HTML code:

<source lang="html4strict">
<ul id="my-list">
<li class="fruits">Apples</li>
<li class="citrus">Oranges and <strong>Lemons</strong></li>
<li class="berries">Cherries</li>
</ul>
</source>

Here, the ul with ID "my-list" has three child '''element nodes''' (the three li's) as well as four child '''text nodes''' (the whitespace counts as a text node) and a child '''attribute node'''. The second LI has one child '''text node''' as well as one child '''element node''' and one child '''attribute node'''.

The DOM can be traversed in JavaScript. First, let's look at an example.

<source lang="javascript">
e = document.getElementById("my-list").getElementsByClassName("citrus")[0].lastChild.nodeName;
alert(e);
</source>

{{JSFiddleExample
|title=Currently Selected Radio Button
|fiddle_id=SHcng
|desc=In pure JavaScript, in order to determine the currently selected radio button, it is necessary to iterate over an array of pointers to all possible radio buttons, and stop when you find one that is "checked".
}}

The above snippet gets the element with class name '''citrus''' that is a child of the element with ID '''my-list''' (the second LI in the example above), and alerts the type of its second child node (which in this case is '''STRONG''').

Some common methods for traversing the DOM include:

* Node.parentNode
* Node.childNodes - returns an array of nodes
* Node.firstChild - same as Node.childNodes[0]
* Node.lastChild - same as Node.childNodes[Node.childNodes.length-1]
* Node.previousSibling
* Node.nextSibling

You can also search for child (including all descendants) using one of the following methods:

* Node.getElementsByTagName("tag-name") - returns an array of element nodes having the tag name '''tag-name''' that are descendants of Node
* Node.getElementById("id") - returns a single node having the ID '''id''' that is a descendant of Node
* Node.getElementsByName("what-name") - returns an array of element nodes having their '''name''' attribute set to '''what-name'''. Useful for radio buttons and other form elements.
* Node.getElementsByClassName("class") - returns an array of nodes having the class '''class'''
*: '''Note:''' As of October 2012, 82% of the browser market supports Node.getElementsByClassName ([http://caniuse.com/getelementsbyclassname more info]). In order to support the other 18%, you need to either add your own getElementsByClassName to Node's prototype or use a JavaScript library like jQuery or MooTools.

It is common in JavaScript to have long statements like the one in the example above, where you call methods on several objects in sequence.

=== Creating, Moving, and Removing Nodes ===

You will frequently find yourself wanting to modify the DOM. JavaScript provides methods that help you do this.

Consider the same HTML as above. If you wanted to add another element to the list, you could use this code:

<source lang="javascript">
const newLi = document.createElement("li"); // creates a node with the tag name li
newLi.appendChild(document.createTextNode("Broccoli"));
newLi.setAttribute("class", "veggies");
document.getElementById("my-list").appendChild(newLi);
</source>

If you wanted to remove the apples from the list, you could do:

<source lang="javascript">
const apple = document.getElementById("my-list").getElementsByClassName("fruits")[0];
document.getElementById("my-list").removeChild(apple);
</source>

If you wanted to move the apples to the end of the list, you could do this:

<source lang="javascript">
const apple = document.getElementById("my-list").getElementsByClassName("fruits")[0];
document.getElementById("my-list").appendChild(apple);
</source>

Notice that '''Node.append()''' both removes a node from its previous location ''and'' appends it to its new location, which is always going to be as the last child of the parent node.

In summary, here are the methods to know from this section:

* Node.append(otherNode) - removes otherNode from its current location in the DOM (if applicable) and then adds it as the last child of Node
* Node.removeChild(otherNode) - removes otherNode, a child of Node, from the DOM
* document.createElement("tag-name") - create a new node with the tag name "tag-name"
* document.createTextNode("text") - create a node containing only the string '''text'''
* Node.setAttribute("attribute", "value") - sets the attribute node of name "attribute" to "value"

=== DOM Shortcuts ===

In the above sections, we have been creating, reading, modifying, and deleting Nodes. This is the most "correct" way to change the content of a web page from inside JavaScript.

This section documents a few shortcuts that are not as "pure" as using Nodes but can be less confusing and cumbersome.

{{JSFiddleExample
|title=Displaying Information
|fiddle_id=Q3BPZ
|desc=This example shows how to use some of the shortcut methods for using JavaScript to display information on the page.
}}

==== textContent ====

Using textContent to display information is probably the easiest method out there. For example, the following code overwrites whatever is in the element with ID "holder" with the string "Hello World":

<source lang="javascript">
document.getElementById("holder").textContent = "Hello World";
</source>

If you wanted to instead append the text, simply use '''+=''' instead of '''=''':

<source lang="javascript">
document.getElementById("holder").textContent += " - Later, he said Hello World - ";
</source>

Note that textContent displays strings literally; that is, it does not allow for HTML. Setting the textContent property also removes any HTML that may have already been in that element.

==== innerHTML ====

If you need to use HTML in your output but don't want to use the method described earlier in this section, a straightforward strategy is to use the innerHTML property of an element. For example, the following code would add a paragraph saying "Hello World" to the element with ID "holder":

<source lang="javascript">
document.getElementById("holder").innerHTML += "<p>Hello World</p>";
</source>

'''Important:''' You need to be careful to prevent XSS-type attacks if you display information using innerHTML. For example, be sure to escape a user-supplied string before appending it to innerHTML.

=== JavaScript Inspectors ===

{{DoctypeTV
|youtube_id=PKzrmbN-pMg
|time=4m13s
|desc=Using Firebug, WebKit Inspector, and IE Developer Tools
}}

Various browsers and browser plugins give you, the developer, tools to debug your code, inspect the DOM, and much more. Using these tools is essential for an efficient workflow.

* '''Firebug'''. Firebug is a plugin for Firefox that is a toolkit full of web developer tools, one of which is a DOM inspector. To inspect the DOM of a web page, simply open the Firebug window while viewing the web page.
* '''WebKit Inspector'''. The WebKit Inspector, which is available in both Chrome and Safari, enables you to see the DOM tree and relationships between elements. However, its DOM inspection tools are not as robust as those of Firebug.
* '''Opera Dragonfly'''. The web browser Opera comes with a web developer toolkit similar to the WebKit Inspector called Dragonfly. It is important that you test your sites in Opera, because although Opera has only a small fraction of the desktop browser market, it is second only to WebKit on the mobile market. Opera also has extremely strong CSS support, so it is good for testing for bugs in your CSS.

All of the above-mentioned tools enable you to look at the DOM of your web page and find what properties and methods are associated with each node. This is helpful because if you have JavaScript that manipulates HTML elements, you cannot tell which properties are associated with which elements by looking at the source code alone.

[[Category:Module 6]]

JavaScript

2018-02-05T18:12:32Z

Alex:

JavaScript is the most widely used scripting language for implementing client-side functionality in Web applications, and, in recent years, it's become very popular for server-side application, too. Unlike PHP, JavaScript code can be interpreted and executed in a client's web browser, instead of on the web server, depending on how it's being used.

== JavaScript? Did you mean Java? ==

'''JavaScript''' is a prototype-based programming language focused on web interactivity. It was first introduced in Netscape Navigator, and it in turn gave rise to what is now '''[http://www.ecmascript.org/ ECMAScript]'''. Originally, JavaScript was called "LiveScript". Sun, the developer of Java at the time, wanted a language that would complement its compiled Java language, and so LiveScript was renamed JavaScript.

Beyond that, '''Java and JavaScript are as similar as Ham and Hamster.'''

Java and JavaScript have similar syntax, but the under workings are quite different. For example, Java requires strict typing, but JavaScript allows for dynamic typing. Java is object-oriented, but JavaScript is prototype-oriented. Java is compiled, but JavaScript is interpreted. Java supports event listeners, but JavaScript makes them a fundamental part of the language. Java variables are scoped to the innermost method or loop, but JavaScript variables are scoped only to the innermost function.

== JavaScript Language Components ==

This section highlights some features of the JavaScript language that differentiate it from other languages. For a more comprehensive JavaScript tutorial, the following tutorials are both quality:

* [https://webplatform.github.io/ WebPlatform]: Great for learning JavaScript for the first time. Advocates best practices for modern JavaScript development.
* [http://www.quirksmode.org/js/contents.html QuirksMode]: More advanced than the WebPlatform tutorial, but it thoroughly covers the most powerful aspects of pure JavaScript and gives unparalleled advice on browser compatibility.

Advice: Do '''NOT''' Google for "JavaScript Tutorial". The first few hits advocate bad or outdated practices. Stick with the ones listed here.

=== Variables and Scope ===

To define a variable in JavaScript, use the '''let''' keyword.

<source lang="javascript">
let foo = "bar";
</source>

To define a constant in JavaScript, use the '''const''' keyword.

<source lang="javascript">
const foo = "bar";
</source>

All variables are objects. In the case above, the variable '''foo''' is an object of the class '''String'''.

Notice that like PHP, you do not have to explicitly define a type for a variable like '''int''' or '''String'''; this is because JavaScript and PHP are ''dynamically typed languages''.

JavaScript code can access any variable higher in the “function tree”, but not vice-versa. This is called '''scope'''. ''All functions create their own scope.''

When you reference a variable, JavaScript will look up through the "function tree" until it finds the variable you asked for. This means that you could define variables of the same name as global variables inside of functions. For demonstration of concept:

<source lang="javascript">
const a = "hello";
const b = "world";

function sayGoodByeWorld(){
const a = "goodbye";

alert(a); // goodbye
alert(b); // world
}

sayGoodByeWorld();

alert(a); // hello
</source>

=== Object Literals ===

A very common way of storing and transporting data in JavaScript is by using objects. You can define an object with certain properties using an '''object literal''':

<source lang="javascript">
const apple = {
color: "red",
flavor: "sweet",
season: "autumn"
}

alert(apple.color); // red
</source>

=== Functions ===

To define a function in JavaScript, use the '''function''' keyword.

<source lang="javascript">
function sayHello(){
alert("Hello World");
}

sayHello(); // call the function
</source>

Pass an argument to a function like this:

<source lang="javascript">
function sayHello(name){
alert("Hello, "+name);
}

sayHello("Todd"); // call the function and pass an argument
</source>

==== Functions are Objects ====

In JavaScript, functions are objects. This means that they can be assigned to variables, manipulated on the fly, and even passed as arguments to other functions! '''''This is an extremely important feature of JavaScript''''' that makes it such a robust language for web development.

You create a function variable like this:

<source lang="javascript">
const sayHello = function(){
alert("Hello World");
}

sayHello(); // call the function
</source>

Observe that you can make [[#Variables and Scope|scope-dependent]] functions in this way.

=== Closures ===

{{DoctypeTV
|youtube_id=HaPlj796ngQ
|time=5m45s
|desc=JavaScript Closures
}}

A '''closure''' is a way to separate a certain snippet of JavaScript code from the global scope. This is useful if you do not want to "muck up" global variables. Closures are nothing more than anonymous functions that are called as soon as they are created:

<source lang="javascript">
const a = "hello";

(function(){
const b = "world";

alert(a); // hello
alert(b); // world
})();

alert(a); // hello
alert(b); // ReferenceError: b is not defined
</source>

{{JSFiddleExample
|title=Passing Variables to a Closure
|desc=This example demonstrates how you can "save" previous versions of a variable using closures. This is possible because of scoping and the fact that function variables can be returned as objects.
|fiddle_id=YURqa
}}

Most JavaScript libraries (like jQuery) write all of their code in a closure. What this means is that except for one or two variable names (jQuery or $), everything associated with the library is completely self-contained.

=== Prototypal Inheritance ===

JavaScript implements '''prototypal inheritance''', as opposed to a language like Java or C++, which implements '''classical inheritance'''. JavaScript is one of only a handful of languages implementing prototype-based inheritance.

Here's how it works. Every callable object (function) has a '''prototype'''. When instances of that object are created, their properties and methods are copied (inherited) from the prototype. Additionally, changes made to the prototype later in the program are "copied" to every instance.

For example, if you wanted to make a method on all strings that added a “!”, you could modify String’s prototype:

<source lang="javascript">
String.prototype.bang = function(){
return this+"!"; // Notice: the context is the instance itself
}

alert("Hello".bang()); // alerts Hello!
</source>

To "extend" an object, just copy its prototype to a new object. However, since classical inheritance and prototypal inheritance are different concepts, copying prototypes may have results that you don't expect. [http://beej.us/blog/data/javascript-prototypes-inheritance/ This article] seems to have a pretty good explanation of how to "inherit" prototypes with example implementations.

==== Extending Built-In Prototypes ====

You should be aware that there is an active debate in the web development community about whether it is good programming style to extend the prototypes of built-in objects like String and Array, such as in the ''String.prototype.bang'' example above. There are legitimate arguments on both sides. [http://stackoverflow.com/questions/8859828/javascript-what-dangers-are-in-extending-array-prototype This Stack Overflow post] has good links to some articles discussing this issue.

=== Context ===

{{DoctypeTV
|youtube_id=0a4r4bm1nQA
|time=4m32s
|desc=The ''this'' Variable in JavaScript
}}

Every function is called on a certain object, which is not necessarily the same object in which it was defined. This is called '''context'''.

To call a function on an arbitrary context, use either '''call''' or '''apply'''. ''call'' takes a list of arguments, while ''apply'' takes them all in an array.

To access the current context, use the '''this''' keyword. Demonstration of concept:

<source lang="javascript">
const sayThisColor = function(){
alert(this.color);
}

const apple = { color: "red" }

sayThisColor(); // undefined
sayThisColor.call(apple); // red
</source>

== Events ==

Events are really what make JavaScript such a powerful language for web development.

Rather than being thread based, JavaScript is event based. Since all JavaScript code runs in a single thread, '''there are no concurrency issues'''. When an event occurs, JavaScript automatically calls the ''event callback'' as soon as all previous events' callbacks have finished executing.

Code in the form of a '''callback function''' is associated with events via a '''listener'''. For example, the following JavaScript causes ''sayHello()'' (the callback function) to be run whenever the button with ID "hello" is clicked (the event):

<source lang="javascript">
const sayHello = function(){
alert("Hello World");
}

document.getElementById("hello").addEventListener("click", sayHello, false);
</source>

{{JSFiddleExample
|title=Binding Callbacks to a Button Click
|fiddle_id=L8c4Z
|cse330=true
|desc=In this example, notice how we bind the callback function when the ''DOMContentLoaded'' event fires. This is because JavaScript requires that the button has been parsed by the browser before it can add event listeners to it.
}}

The '''addEventListener''' method takes three parameters:
* The event type
* The callback function
*: The callback function is passed one parameter: the event object.
* A boolean representing bubble (false) or capture (true) phase
*: You usually want Bubble phase. For more information on event phase, see [[#Event Phase]]

Note that versions of Internet Explorer prior to version 9 required that you use a different, albeit similar, function for assigning event listeners called '''attachEvent'''. attachEvent takes the same arguments as addEventListener, except you need to put '''on''' before the event type (e.g. "onclick"), and the third argument (phase) is not necessary.

It is perfectly valid to use an '''anonymous function''' as your callback function:

<source lang="javascript">
document.getElementById("hello").addEventListener("click", function(event){
alert("Hello, World! Event Type: "+event.type);
}, false);
</source>

QuirksMode has perhaps the best series of articles about the ins and outs of JavaScript events on the internet: http://www.quirksmode.org/js/contents.html#events

=== The Event Object ===

Callback functions are passed one argument: an ''event object''. You see above that one property of the event object is ''event.type''. To see the full list of properties of the event object, you could run the code:

<source lang="javascript">
document.getElementById("my_btn").addEventListener("click", function(event){
let strout = "";
for(var i in event){
strout += `${i}: ${event[i]}\n`;
}
console.log(strout);
}, false);
</source>

Some of the most useful properties and methods include:
* '''event.target''' references the object on which the event occurred.
* '''event.currentTarget''' references the object whose listener is currently being processed.
*: ''Note:'' event.target and event.currentTarget might be the same or might be different, depending on whether you are listening for bubbled events.
* '''event.preventDefault()''' stops the normal result of the event from being executed. For example, if you listen for a form's ''submit'' event, you can call event.preventDefault() to stop the form from being submitted.
* '''event.stopPropagation()''' prevents any other event listeners from being executed. For more detail, read the section on Event Phase below.

For more detail on the event object, see [http://dev.w3.org/2006/webapi/DOM-Level-3-Events/html/DOM3-Events.html#interface-Event the W3C specification].

'''Note:''' If your callback function does not take any parameters, it will still run; you just won't have as easy of access to the event object.

=== Event Handlers and Memory Management ===

JavaScript is an automatically garbage-collected language, meaning that memory management is mostly taken care of for you. However, there are some instances when you need to be careful about creating "zombie" objects. In JavaScript, this mostly revolves around the idea of event listeners.

I could give an explanatory example, but instead I'll tell you straightaway that '''the moral of the story is that for every "addEventListener", there should probably be a "removeEventListener".''' Here are some good articles to satisfy your hunger for more details on event listeners and JavaScript memory management:

* http://www.vladalexandruionescu.com/2012/08/javascript-memory-leaks.html
* http://lostechies.com/derickbailey/2012/03/19/backbone-js-and-javascript-garbage-collection/
* http://stackoverflow.com/questions/5326300/garbage-collection-with-node-js

When you start working with Node.JS in the next module, it's more important than ever to keep good accounting of your event listeners.

=== Event Phase ===

In JavaScript, events occur in two phases: '''Capture Phase''' and '''Bubble Phase'''. Consider the following HTML document:

<source lang="html4strict">
<!DOCTYPE html>
<html>
<head><title>Event Test</title></head>
<body>
<div id="box">
<button id="btn">
Hello
</button>
</div>
</body>
</html>
</source>

Suppose the user clicks on the "Hello" button. Events will be fired in the following order:

# Capture Phase CLICK on the Document
# Capture Phase CLICK on the Body
# Capture Phase CLICK on the Div#box
# Target Phase CLICK on the Button#btn
# Bubble Phase CLICK on the Div#box
# Bubble Phase CLICK on the Body
# Bubble Phase CLICK on the Document

{{JSFiddleExample
|title=Using Capture Phase to Enable or Disable a Toolbar
|fiddle_id=r32Dz
|desc=We bind an event in the capture phase to the div with ID ''toolbar''. When ''e.stopPropagation()'' is called, the event does not reach the buttons in the toolbar.
}}

Graphically, here is the order in which an event occurs in three generic nested elements:

[[File:EventPhase.gif]]

Why is this useful? Suppose you have a control panel (toolbar, etc) that you want to temporarily deactivate. (For example, Bold/Italic/Underline buttons on a graphic text editor that currently has no content.) You could keep bubble phase event listeners on your buttons, but prevent those events from occurring by stopping the event in the capture phase on the parent element before the event reaches your buttons! Example:

<source lang="javascript">
const disableToolbarFunc = function(e){
e.stopPropogation();
}

// To disable toolbar:
document.getElementById("box").addEventListener("click", disableToolbarFunc, true);

// To re-enable toolbar:
document.getElementById("box").removeEventListener("click", disableToolbarFunc, true);
</source>

'''Word of caution:''' Like many great things in web development, capture phase does not work in versions of Internet Explorer prior to version 9. There is no elegant substitution for older versions of Internet Explorer.

'''Note:''' When the event reaches the innermost element, there is no distinction between capture phase and bubble phase. The order in which event handlers were added to the element determines the order in which those callbacks are evaluated.

== Document Object Model ==

The '''Document Object Model (DOM)''' is what enables JavaScript to manipulate the content of your web page.

=== Nodes and Traversing the DOM ===

Each element on your page, whether it is a <nowiki><p>, <img/></nowiki>, a string of text, or even an attribute, is called a '''node'''.

Every node, except for the document itself, has exactly one parent. A single node may have multiple children.

Consider the following HTML code:

<source lang="html4strict">
<ul id="my-list">
<li class="fruits">Apples</li>
<li class="citrus">Oranges and <strong>Lemons</strong></li>
<li class="berries">Cherries</li>
</ul>
</source>

Here, the ul with ID "my-list" has three child '''element nodes''' (the three li's) as well as four child '''text nodes''' (the whitespace counts as a text node) and a child '''attribute node'''. The second LI has one child '''text node''' as well as one child '''element node''' and one child '''attribute node'''.

The DOM can be traversed in JavaScript. First, let's look at an example.

<source lang="javascript">
e = document.getElementById("my-list").getElementsByClassName("citrus")[0].lastChild.nodeName;
alert(e);
</source>

{{JSFiddleExample
|title=Currently Selected Radio Button
|fiddle_id=SHcng
|desc=In pure JavaScript, in order to determine the currently selected radio button, it is necessary to iterate over an array of pointers to all possible radio buttons, and stop when you find one that is "checked".
}}

The above snippet gets the element with class name '''citrus''' that is a child of the element with ID '''my-list''' (the second LI in the example above), and alerts the type of its second child node (which in this case is '''STRONG''').

Some common methods for traversing the DOM include:

* Node.parentNode
* Node.childNodes - returns an array of nodes
* Node.firstChild - same as Node.childNodes[0]
* Node.lastChild - same as Node.childNodes[Node.childNodes.length-1]
* Node.previousSibling
* Node.nextSibling

You can also search for child (including all descendants) using one of the following methods:

* Node.getElementsByTagName("tag-name") - returns an array of element nodes having the tag name '''tag-name''' that are descendants of Node
* Node.getElementById("id") - returns a single node having the ID '''id''' that is a descendant of Node
* Node.getElementsByName("what-name") - returns an array of element nodes having their '''name''' attribute set to '''what-name'''. Useful for radio buttons and other form elements.
* Node.getElementsByClassName("class") - returns an array of nodes having the class '''class'''
*: '''Note:''' As of October 2012, 82% of the browser market supports Node.getElementsByClassName ([http://caniuse.com/getelementsbyclassname more info]). In order to support the other 18%, you need to either add your own getElementsByClassName to Node's prototype or use a JavaScript library like jQuery or MooTools.

It is common in JavaScript to have long statements like the one in the example above, where you call methods on several objects in sequence.

=== Creating, Moving, and Removing Nodes ===

You will frequently find yourself wanting to modify the DOM. JavaScript provides methods that help you do this.

Consider the same HTML as above. If you wanted to add another element to the list, you could use this code:

<source lang="javascript">
const newLi = document.createElement("li"); // creates a node with the tag name li
newLi.appendChild(document.createTextNode("Broccoli"));
newLi.setAttribute("class", "veggies");
document.getElementById("my-list").appendChild(newLi);
</source>

If you wanted to remove the apples from the list, you could do:

<source lang="javascript">
const apple = document.getElementById("my-list").getElementsByClassName("fruits")[0];
document.getElementById("my-list").removeChild(apple);
</source>

If you wanted to move the apples to the end of the list, you could do this:

<source lang="javascript">
const apple = document.getElementById("my-list").getElementsByClassName("fruits")[0];
document.getElementById("my-list").appendChild(apple);
</source>

Notice that '''Node.append()''' both removes a node from its previous location ''and'' appends it to its new location, which is always going to be as the last child of the parent node.

In summary, here are the methods to know from this section:

* Node.append(otherNode) - removes otherNode from its current location in the DOM (if applicable) and then adds it as the last child of Node
* Node.removeChild(otherNode) - removes otherNode, a child of Node, from the DOM
* document.createElement("tag-name") - create a new node with the tag name "tag-name"
* document.createTextNode("text") - create a node containing only the string '''text'''
* Node.setAttribute("attribute", "value") - sets the attribute node of name "attribute" to "value"

=== DOM Shortcuts ===

In the above sections, we have been creating, reading, modifying, and deleting Nodes. This is the most "correct" way to change the content of a web page from inside JavaScript.

This section documents a few shortcuts that are not as "pure" as using Nodes but can be less confusing and cumbersome.

{{JSFiddleExample
|title=Displaying Information
|fiddle_id=Q3BPZ
|desc=This example shows how to use some of the shortcut methods for using JavaScript to display information on the page.
}}

==== textContent ====

Using textContent to display information is probably the easiest method out there. For example, the following code overwrites whatever is in the element with ID "holder" with the string "Hello World":

<source lang="javascript">
document.getElementById("holder").textContent = "Hello World";
</source>

If you wanted to instead append the text, simply use '''+=''' instead of '''=''':

<source lang="javascript">
document.getElementById("holder").textContent += " - Later, he said Hello World - ";
</source>

Note that textContent displays strings literally; that is, it does not allow for HTML. Setting the textContent property also removes any HTML that may have already been in that element.

==== innerHTML ====

If you need to use HTML in your output but don't want to use the method described earlier in this section, a straightforward strategy is to use the innerHTML property of an element. For example, the following code would add a paragraph saying "Hello World" to the element with ID "holder":

<source lang="javascript">
document.getElementById("holder").innerHTML += "<p>Hello World</p>";
</source>

'''Important:''' You need to be careful to prevent XSS-type attacks if you display information using innerHTML. For example, be sure to escape a user-supplied string before appending it to innerHTML.

=== JavaScript Inspectors ===

{{DoctypeTV
|youtube_id=PKzrmbN-pMg
|time=4m13s
|desc=Using Firebug, WebKit Inspector, and IE Developer Tools
}}

Various browsers and browser plugins give you, the developer, tools to debug your code, inspect the DOM, and much more. Using these tools is essential for an efficient workflow.

* '''Firebug'''. Firebug is a plugin for Firefox that is a toolkit full of web developer tools, one of which is a DOM inspector. To inspect the DOM of a web page, simply open the Firebug window while viewing the web page.
* '''WebKit Inspector'''. The WebKit Inspector, which is available in both Chrome and Safari, enables you to see the DOM tree and relationships between elements. However, its DOM inspection tools are not as robust as those of Firebug.
* '''Opera Dragonfly'''. The web browser Opera comes with a web developer toolkit similar to the WebKit Inspector called Dragonfly. It is important that you test your sites in Opera, because although Opera has only a small fraction of the desktop browser market, it is second only to WebKit on the mobile market. Opera also has extremely strong CSS support, so it is good for testing for bugs in your CSS.

All of the above-mentioned tools enable you to look at the DOM of your web page and find what properties and methods are associated with each node. This is helpful because if you have JavaScript that manipulates HTML elements, you cannot tell which properties are associated with which elements by looking at the source code alone.

[[Category:Module 6]]

JavaScript

2018-02-05T18:05:35Z

Alex: /* Variables and Scope */ New variable declarations

JavaScript is the most widely used scripting language for implementing client-side functionality in Web applications, and, in recent years, it's become very popular for server-side application, too. Unlike PHP, JavaScript code can be interpreted and executed in a client's web browser, instead of on the web server, depending on how it's being used.

== JavaScript? Did you mean Java? ==

'''JavaScript''' is a prototype-based programming language focused on web interactivity. It was first introduced in Netscape Navigator, and it in turn gave rise to what is now '''[http://www.ecmascript.org/ ECMAScript]'''. Originally, JavaScript was called "LiveScript". Sun, the developer of Java at the time, wanted a language that would complement its compiled Java language, and so LiveScript was renamed JavaScript.

Beyond that, '''Java and JavaScript are as similar as Ham and Hamster.'''

Java and JavaScript have similar syntax, but the under workings are quite different. For example, Java requires strict typing, but JavaScript allows for dynamic typing. Java is object-oriented, but JavaScript is prototype-oriented. Java is compiled, but JavaScript is interpreted. Java supports event listeners, but JavaScript makes them a fundamental part of the language. Java variables are scoped to the innermost method or loop, but JavaScript variables are scoped only to the innermost function.

== JavaScript Language Components ==

This section highlights some features of the JavaScript language that differentiate it from other languages. For a more comprehensive JavaScript tutorial, the following tutorials are both quality:

* [https://webplatform.github.io/ WebPlatform]: Great for learning JavaScript for the first time. Advocates best practices for modern JavaScript development.
* [http://www.quirksmode.org/js/contents.html QuirksMode]: More advanced than the WebPlatform tutorial, but it thoroughly covers the most powerful aspects of pure JavaScript and gives unparalleled advice on browser compatibility.

Advice: Do '''NOT''' Google for "JavaScript Tutorial". The first few hits advocate bad or outdated practices. Stick with the ones listed here.

=== Variables and Scope ===

To define a variable in JavaScript, use the '''let''' keyword.

<source lang="javascript">
let foo = "bar";
</source>

To define a constant in JavaScript, use the '''const''' keyword.

<source lang="javascript">
const foo = "bar";
</source>

All variables are objects. In the case above, the variable '''foo''' is an object of the class '''String'''.

Notice that like PHP, you do not have to explicitly define a type for a variable like '''int''' or '''String'''; this is because JavaScript and PHP are ''dynamically typed languages''.

JavaScript code can access any variable higher in the “function tree”, but not vice-versa. This is called '''scope'''. ''All functions create their own scope.''

When you reference a variable, JavaScript will look up through the "function tree" until it finds the variable you asked for. This means that you could define variables of the same name as global variables inside of functions. For demonstration of concept:

<source lang="javascript">
const a = "hello";
const b = "world";

function sayGoodByeWorld(){
const a = "goodbye";

alert(a); // goodbye
alert(b); // world
}

sayGoodByeWorld();

alert(a); // hello
</source>

=== Object Literals ===

A very common way of storing and transporting data in JavaScript is by using objects. You can define an object with certain properties using an '''object literal''':

<source lang="javascript">
var apple = {
color: "red",
flavor: "sweet",
season: "autumn"
}

alert(apple.color); // red
</source>

=== Functions ===

To define a function in JavaScript, use the '''function''' keyword.

<source lang="javascript">
function sayHello(){
alert("Hello World");
}

sayHello(); // call the function
</source>

Pass an argument to a function like this:

<source lang="javascript">
function sayHello(name){
alert("Hello, "+name);
}

sayHello("Todd"); // call the function and pass an argument
</source>

==== Functions are Objects ====

In JavaScript, functions are objects. This means that they can be assigned to variables, manipulated on the fly, and even passed as arguments to other functions! '''''This is an extremely important feature of JavaScript''''' that makes it such a robust language for web development.

You create a function variable like this:

<source lang="javascript">
var sayHello = function(){
alert("Hello World");
}

sayHello(); // call the function
</source>

Observe that you can make [[#Variables and Scope|scope-dependent]] functions in this way.

=== Closures ===

{{DoctypeTV
|youtube_id=HaPlj796ngQ
|time=5m45s
|desc=JavaScript Closures
}}

A '''closure''' is a way to separate a certain snippet of JavaScript code from the global scope. This is useful if you do not want to "muck up" global variables. Closures are nothing more than anonymous functions that are called as soon as they are created:

<source lang="javascript">
var a = "hello";

(function(){
var b = "world";

alert(a); // hello
alert(b); // world
})();

alert(a); // hello
alert(b); // ReferenceError: b is not defined
</source>

{{JSFiddleExample
|title=Passing Variables to a Closure
|desc=This example demonstrates how you can "save" previous versions of a variable using closures. This is possible because of scoping and the fact that function variables can be returned as objects.
|fiddle_id=YURqa
}}

Most JavaScript libraries (like jQuery) write all of their code in a closure. What this means is that except for one or two variable names (jQuery or $), everything associated with the library is completely self-contained.

=== Prototypal Inheritance ===

JavaScript implements '''prototypal inheritance''', as opposed to a language like Java or C++, which implements '''classical inheritance'''. JavaScript is one of only a handful of languages implementing prototype-based inheritance.

Here's how it works. Every callable object (function) has a '''prototype'''. When instances of that object are created, their properties and methods are copied (inherited) from the prototype. Additionally, changes made to the prototype later in the program are "copied" to every instance.

For example, if you wanted to make a method on all strings that added a “!”, you could modify String’s prototype:

<source lang="javascript">
String.prototype.bang = function(){
return this+"!"; // Notice: the context is the instance itself
}

alert("Hello".bang()); // alerts Hello!
</source>

To "extend" an object, just copy its prototype to a new object. However, since classical inheritance and prototypal inheritance are different concepts, copying prototypes may have results that you don't expect. [http://beej.us/blog/data/javascript-prototypes-inheritance/ This article] seems to have a pretty good explanation of how to "inherit" prototypes with example implementations.

==== Extending Built-In Prototypes ====

You should be aware that there is an active debate in the web development community about whether it is good programming style to extend the prototypes of built-in objects like String and Array, such as in the ''String.prototype.bang'' example above. There are legitimate arguments on both sides. [http://stackoverflow.com/questions/8859828/javascript-what-dangers-are-in-extending-array-prototype This Stack Overflow post] has good links to some articles discussing this issue.

=== Context ===

{{DoctypeTV
|youtube_id=0a4r4bm1nQA
|time=4m32s
|desc=The ''this'' Variable in JavaScript
}}

Every function is called on a certain object, which is not necessarily the same object in which it was defined. This is called '''context'''.

To call a function on an arbitrary context, use either '''call''' or '''apply'''. ''call'' takes a list of arguments, while ''apply'' takes them all in an array.

To access the current context, use the '''this''' keyword. Demonstration of concept:

<source lang="javascript">
var sayThisColor = function(){
alert(this.color);
}

var apple = { color: "red" }

sayThisColor(); // undefined
sayThisColor.call(apple); // red
</source>

== Events ==

Events are really what make JavaScript such a powerful language for web development.

Rather than being thread based, JavaScript is event based. Since all JavaScript code runs in a single thread, '''there are no concurrency issues'''. When an event occurs, JavaScript automatically calls the ''event callback'' as soon as all previous events' callbacks have finished executing.

Code in the form of a '''callback function''' is associated with events via a '''listener'''. For example, the following JavaScript causes ''sayHello()'' (the callback function) to be run whenever the button with ID "hello" is clicked (the event):

<source lang="javascript">
var sayHello = function(){
alert("Hello World");
}

document.getElementById("hello").addEventListener("click", sayHello, false);
</source>

{{JSFiddleExample
|title=Binding Callbacks to a Button Click
|fiddle_id=L8c4Z
|cse330=true
|desc=In this example, notice how we bind the callback function when the ''DOMContentLoaded'' event fires. This is because JavaScript requires that the button has been parsed by the browser before it can add event listeners to it.
}}

The '''addEventListener''' method takes three parameters:
* The event type
* The callback function
*: The callback function is passed one parameter: the event object.
* A boolean representing bubble (false) or capture (true) phase
*: You usually want Bubble phase. For more information on event phase, see [[#Event Phase]]

Note that versions of Internet Explorer prior to version 9 required that you use a different, albeit similar, function for assigning event listeners called '''attachEvent'''. attachEvent takes the same arguments as addEventListener, except you need to put '''on''' before the event type (e.g. "onclick"), and the third argument (phase) is not necessary.

It is perfectly valid to use an '''anonymous function''' as your callback function:

<source lang="javascript">
document.getElementById("hello").addEventListener("click", function(event){
alert("Hello, World! Event Type: "+event.type);
}, false);
</source>

QuirksMode has perhaps the best series of articles about the ins and outs of JavaScript events on the internet: http://www.quirksmode.org/js/contents.html#events

=== The Event Object ===

Callback functions are passed one argument: an ''event object''. You see above that one property of the event object is ''event.type''. To see the full list of properties of the event object, you could run the code:

<source lang="javascript">
document.getElementById("my_btn").addEventListener("click", function(event){
var strout = "";
for(var i in event){
strout += i + ": " + event[i] + "\n";
}
console.log(strout);
}, false);
</source>

Some of the most useful properties and methods include:
* '''event.target''' references the object on which the event occurred.
* '''event.currentTarget''' references the object whose listener is currently being processed.
*: ''Note:'' event.target and event.currentTarget might be the same or might be different, depending on whether you are listening for bubbled events.
* '''event.preventDefault()''' stops the normal result of the event from being executed. For example, if you listen for a form's ''submit'' event, you can call event.preventDefault() to stop the form from being submitted.
* '''event.stopPropagation()''' prevents any other event listeners from being executed. For more detail, read the section on Event Phase below.

For more detail on the event object, see [http://dev.w3.org/2006/webapi/DOM-Level-3-Events/html/DOM3-Events.html#interface-Event the W3C specification].

'''Note:''' If your callback function does not take any parameters, it will still run; you just won't have as easy of access to the event object.

=== Event Handlers and Memory Management ===

JavaScript is an automatically garbage-collected language, meaning that memory management is mostly taken care of for you. However, there are some instances when you need to be careful about creating "zombie" objects. In JavaScript, this mostly revolves around the idea of event listeners.

I could give an explanatory example, but instead I'll tell you straightaway that '''the moral of the story is that for every "addEventListener", there should probably be a "removeEventListener".''' Here are some good articles to satisfy your hunger for more details on event listeners and JavaScript memory management:

* http://www.vladalexandruionescu.com/2012/08/javascript-memory-leaks.html
* http://lostechies.com/derickbailey/2012/03/19/backbone-js-and-javascript-garbage-collection/
* http://stackoverflow.com/questions/5326300/garbage-collection-with-node-js

When you start working with Node.JS in the next module, it's more important than ever to keep good accounting of your event listeners.

=== Event Phase ===

In JavaScript, events occur in two phases: '''Capture Phase''' and '''Bubble Phase'''. Consider the following HTML document:

<source lang="html4strict">
<!DOCTYPE html>
<html>
<head><title>Event Test</title></head>
<body>
<div id="box">
<button id="btn">
Hello
</button>
</div>
</body>
</html>
</source>

Suppose the user clicks on the "Hello" button. Events will be fired in the following order:

# Capture Phase CLICK on the Document
# Capture Phase CLICK on the Body
# Capture Phase CLICK on the Div#box
# Target Phase CLICK on the Button#btn
# Bubble Phase CLICK on the Div#box
# Bubble Phase CLICK on the Body
# Bubble Phase CLICK on the Document

{{JSFiddleExample
|title=Using Capture Phase to Enable or Disable a Toolbar
|fiddle_id=r32Dz
|desc=We bind an event in the capture phase to the div with ID ''toolbar''. When ''e.stopPropagation()'' is called, the event does not reach the buttons in the toolbar.
}}

Graphically, here is the order in which an event occurs in three generic nested elements:

[[File:EventPhase.gif]]

Why is this useful? Suppose you have a control panel (toolbar, etc) that you want to temporarily deactivate. (For example, Bold/Italic/Underline buttons on a graphic text editor that currently has no content.) You could keep bubble phase event listeners on your buttons, but prevent those events from occurring by stopping the event in the capture phase on the parent element before the event reaches your buttons! Example:

<source lang="javascript">
var disableToolbarFunc = function(e){
e.stopPropogation();
}

// To disable toolbar:
document.getElementById("box").addEventListener("click", disableToolbarFunc, true);

// To re-enable toolbar:
document.getElementById("box").removeEventListener("click", disableToolbarFunc, true);
</source>

'''Word of caution:''' Like many great things in web development, capture phase does not work in versions of Internet Explorer prior to version 9. There is no elegant substitution for older versions of Internet Explorer.

'''Note:''' When the event reaches the innermost element, there is no distinction between capture phase and bubble phase. The order in which event handlers were added to the element determines the order in which those callbacks are evaluated.

== Document Object Model ==

The '''Document Object Model (DOM)''' is what enables JavaScript to manipulate the content of your web page.

=== Nodes and Traversing the DOM ===

Each element on your page, whether it is a <nowiki><p>, <img/></nowiki>, a string of text, or even an attribute, is called a '''node'''.

Every node, except for the document itself, has exactly one parent. A single node may have multiple children.

Consider the following HTML code:

<source lang="html4strict">
<ul id="my-list">
<li class="fruits">Apples</li>
<li class="citrus">Oranges and <strong>Lemons</strong></li>
<li class="berries">Cherries</li>
</ul>
</source>

Here, the ul with ID "my-list" has three child '''element nodes''' (the three li's) as well as four child '''text nodes''' (the whitespace counts as a text node) and a child '''attribute node'''. The second LI has one child '''text node''' as well as one child '''element node''' and one child '''attribute node'''.

The DOM can be traversed in JavaScript. First, let's look at an example.

<source lang="javascript">
e = document.getElementById("my-list").getElementsByClassName("citrus")[0].lastChild.nodeName;
alert(e);
</source>

{{JSFiddleExample
|title=Currently Selected Radio Button
|fiddle_id=SHcng
|desc=In pure JavaScript, in order to determine the currently selected radio button, it is necessary to iterate over an array of pointers to all possible radio buttons, and stop when you find one that is "checked".
}}

The above snippet gets the element with class name '''citrus''' that is a child of the element with ID '''my-list''' (the second LI in the example above), and alerts the type of its second child node (which in this case is '''STRONG''').

Some common methods for traversing the DOM include:

* Node.parentNode
* Node.childNodes - returns an array of nodes
* Node.firstChild - same as Node.childNodes[0]
* Node.lastChild - same as Node.childNodes[Node.childNodes.length-1]
* Node.previousSibling
* Node.nextSibling

You can also search for child (including all descendants) using one of the following methods:

* Node.getElementsByTagName("tag-name") - returns an array of element nodes having the tag name '''tag-name''' that are descendants of Node
* Node.getElementById("id") - returns a single node having the ID '''id''' that is a descendant of Node
* Node.getElementsByName("what-name") - returns an array of element nodes having their '''name''' attribute set to '''what-name'''. Useful for radio buttons and other form elements.
* Node.getElementsByClassName("class") - returns an array of nodes having the class '''class'''
*: '''Note:''' As of October 2012, 82% of the browser market supports Node.getElementsByClassName ([http://caniuse.com/getelementsbyclassname more info]). In order to support the other 18%, you need to either add your own getElementsByClassName to Node's prototype or use a JavaScript library like jQuery or MooTools.

It is common in JavaScript to have long statements like the one in the example above, where you call methods on several objects in sequence.

=== Creating, Moving, and Removing Nodes ===

You will frequently find yourself wanting to modify the DOM. JavaScript provides methods that help you do this.

Consider the same HTML as above. If you wanted to add another element to the list, you could use this code:

<source lang="javascript">
var newLi = document.createElement("li"); // creates a node with the tag name li
newLi.appendChild(document.createTextNode("Broccoli"));
newLi.setAttribute("class", "veggies");
document.getElementById("my-list").appendChild(newLi);
</source>

If you wanted to remove the apples from the list, you could do:

<source lang="javascript">
var apple = document.getElementById("my-list").getElementsByClassName("fruits")[0];
document.getElementById("my-list").removeChild(apple);
</source>

If you wanted to move the apples to the end of the list, you could do this:

<source lang="javascript">
var apple = document.getElementById("my-list").getElementsByClassName("fruits")[0];
document.getElementById("my-list").appendChild(apple);
</source>

Notice that '''Node.append()''' both removes a node from its previous location ''and'' appends it to its new location, which is always going to be as the last child of the parent node.

In summary, here are the methods to know from this section:

* Node.append(otherNode) - removes otherNode from its current location in the DOM (if applicable) and then adds it as the last child of Node
* Node.removeChild(otherNode) - removes otherNode, a child of Node, from the DOM
* document.createElement("tag-name") - create a new node with the tag name "tag-name"
* document.createTextNode("text") - create a node containing only the string '''text'''
* Node.setAttribute("attribute", "value") - sets the attribute node of name "attribute" to "value"

=== DOM Shortcuts ===

In the above sections, we have been creating, reading, modifying, and deleting Nodes. This is the most "correct" way to change the content of a web page from inside JavaScript.

This section documents a few shortcuts that are not as "pure" as using Nodes but can be less confusing and cumbersome.

{{JSFiddleExample
|title=Displaying Information
|fiddle_id=Q3BPZ
|desc=This example shows how to use some of the shortcut methods for using JavaScript to display information on the page.
}}

==== textContent ====

Using textContent to display information is probably the easiest method out there. For example, the following code overwrites whatever is in the element with ID "holder" with the string "Hello World":

<source lang="javascript">
document.getElementById("holder").textContent = "Hello World";
</source>

If you wanted to instead append the text, simply use '''+=''' instead of '''=''':

<source lang="javascript">
document.getElementById("holder").textContent += " - Later, he said Hello World - ";
</source>

Note that textContent displays strings literally; that is, it does not allow for HTML. Setting the textContent property also removes any HTML that may have already been in that element.

==== innerHTML ====

If you need to use HTML in your output but don't want to use the method described earlier in this section, a straightforward strategy is to use the innerHTML property of an element. For example, the following code would add a paragraph saying "Hello World" to the element with ID "holder":

<source lang="javascript">
document.getElementById("holder").innerHTML += "<p>Hello World</p>";
</source>

'''Important:''' You need to be careful to prevent XSS-type attacks if you display information using innerHTML. For example, be sure to escape a user-supplied string before appending it to innerHTML.

=== JavaScript Inspectors ===

{{DoctypeTV
|youtube_id=PKzrmbN-pMg
|time=4m13s
|desc=Using Firebug, WebKit Inspector, and IE Developer Tools
}}

Various browsers and browser plugins give you, the developer, tools to debug your code, inspect the DOM, and much more. Using these tools is essential for an efficient workflow.

* '''Firebug'''. Firebug is a plugin for Firefox that is a toolkit full of web developer tools, one of which is a DOM inspector. To inspect the DOM of a web page, simply open the Firebug window while viewing the web page.
* '''WebKit Inspector'''. The WebKit Inspector, which is available in both Chrome and Safari, enables you to see the DOM tree and relationships between elements. However, its DOM inspection tools are not as robust as those of Firebug.
* '''Opera Dragonfly'''. The web browser Opera comes with a web developer toolkit similar to the WebKit Inspector called Dragonfly. It is important that you test your sites in Opera, because although Opera has only a small fraction of the desktop browser market, it is second only to WebKit on the mobile market. Opera also has extremely strong CSS support, so it is good for testing for bugs in your CSS.

All of the above-mentioned tools enable you to look at the DOM of your web page and find what properties and methods are associated with each node. This is helpful because if you have JavaScript that manipulates HTML elements, you cannot tell which properties are associated with which elements by looking at the source code alone.

[[Category:Module 6]]

Module 4

2018-02-05T18:03:15Z

Alex:

__NOTOC__
In Module 4, you will learn the fundamentals of Python, a popular scripting language, and Regular Expressions, which give you power in text processing.

This article contains your assignments for Module 4.

== Reading ==

The following articles on the online class wiki textbook contain information that will help you complete the assignments.

* [[Python]]
* [[Regular Expressions]]

== Individual Assignments ==

=== Learn Python and Regular Expressions ===

Up to this point in CSE 330, you have used only one programming language: PHP. In Module 4, you will learn a new language: Python. Before starting this assignment, you should look over the [[Python|online textbook article about Python]]. You should be using version 3 (or greater) of Python. Additionally, you may find it helpful to look over the [[Regular Expressions|online textbook article about Regular Expressions]].

=== Write some Regular Expressions ===

Please write regular expressions that do each the following:

# Match the string "hello world" in a sentence
# Find all words in an input string that contains three consecutive vowels, regardless of case.
# Match an input string that is '''entirely''' a flight code, of the format AA####, where '''AA''' is a two-letter uppercase airline code, and '''####''' is a three- or four-digit flight number
Examples:
Note: text in ''[[red]]'' is matched by the regular expression. Each line is a separate test input string.
Regex 1: Programmers will often write ''[[hello world]]'' as their first project with a programming language.
Regex 2: The ''[[gooey]]'' peanut butter and jelly sandwich was a ''[[beauty]]''.
Regex 3: ''[[AA312]]''
''[[AA1298]]''
''[[NW1234]]''
''[[US443]]''
US31344
AA123 extratext

Save your regexes to a text file. The TA will test them in regexpal on Demo Day.

=== Baseball Stats Counter ===

The St. Louis Cardinals are the most legendary baseball team in the national league. In this exercise, you will be creating a Python script that reads box scores from a file and computes the Cardinals' players' batting averages in a particular season.

==== Tips and Instructions ====

* You should write a Python script file to solve this problem.
* You should use a regular expression to parse players' names, at-bats, hits, and runs from the input file.
* You may want to create a class to hold and compute information about each player.
* Your file should take one command-line argument: the path to an input file. If no path is given, your program should print a usage message.

==== Input ====

Sample input files may be found here: http://classes.engineering.wustl.edu/cse330/content/cardinals/

The top of the file contains a citation, and what follows is an entire season of Cardinals Baseball box scores. Each game starts with a title; for example:

=== St.Louis Cardinals vs. Chicago Cubs, 1940-04-19 ===

What follows are the performance of each player in that game. The format of each line is as follows:

XXX batted # times with # hits and # runs

where '''XXX''' is the player's name (you may assume that the name is unique), and each '''#''' are integers representing the number of "at bats", the number of "hits", and the number of "runs", respectively.

==== Output ====

Your script needs to output all players' batting average across the season. A player's batting average is that player's total hits divided by that player's total at-bats throughout the entire season. For example, Johnny Hopp was at bat 149 times in 1940, and he had 41 hits, so his batting average was 0.275.

Each line in the output should have the format:

XXX: #.###

where '''XXX''' is the player's name, and '''#.###''' is the player's batting average, '''rounded''' (not truncated) to three decimal places.

The players should be sorted by batting average, with the highest batting average on top. If two players have the exact same batting average (before rounding occurs), the order between those two players is unimportant.

For example, the correct output for the 1940 season is:

<source lang="text">
Pepper Martin: 0.316
Walker Cooper: 0.316
Johnny Mize: 0.314
Ernie Koy: 0.310
Enos Slaughter: 0.306
Joe Medwick: 0.304
Terry Moore: 0.304
Joe Orengo: 0.286
Jimmy Brown: 0.280
Marty Marion: 0.279
Don Gutteridge: 0.276
Johnny Hopp: 0.275
Creepy Crespi: 0.273
Mickey Owen: 0.265
Bill DeLancey: 0.250
Don Padgett: 0.242
Stu Martin: 0.238
Eddie Lake: 0.222
Hal Epps: 0.214
Lon Warneke: 0.209
Harry Walker: 0.185
Max Lanier: 0.179
Bill McGee: 0.178
Carl Doyle: 0.174
Mort Cooper: 0.157
Clyde Shoun: 0.145
Carden Gillenwater: 0.130
Bob Bowman: 0.067
</source>

== Grading ==

We will be grading the following aspects of your work. There are 50 points total.

'''Assignments must be committed to Bitbucket by the end of class on the due date (commit early and often). Failing to commit by the end of class on the due date will result in a 0. '''

Upload your baseball code, a file with your Regular expressions, and a screenshot of your python output onto Bitbucket.

# '''Regular Expressions (15 Points):'''
#* Regular Expression 1 Correct and saved in a file named <code>regex1.txt</code> (5 points)
#* Regular Expression 2 Correct and saved in a file named <code>regex2.txt</code>(5 points)
#* Regular Expression 3 Correct and saved in a file named <code>regex3.txt</code>(5 points)
# '''Baseball Stats Counter (35 Points):'''
#* Solution is written entirely in Python and saved in a file named <code>baseball.py</code> (8 points)
#* Correct usage of one or more regular expressions to parse and extract data from each line of the input file (8 points)
#* Script prints a usage message if a command line argument is not present (4 points)
#* Output is correct for all test cases (15 points)
#*: ''This includes sorting and rounding.''

[[Category:Module 4]]
[[Category:Modules]]

Module 1

2018-01-31T00:56:17Z

Alex: /* Grading */

__NOTOC__
Module 1 introduces the fundamentals of HTML and CSS. You will first make a static document using HTML and CSS, and then you will make a portal to a DuckDuckGo search. This module is worth 50 points.

== Reading ==

The following articles on the online class wiki textbook contain information that will help you complete the assignment.

* [[Git]]
* [[HTML and CSS]]
* [[HTML Forms]]

== Assignments ==

=== Write a Birthday Card ===

'''Write a birthday card to a friend or family member using HTML and CSS.''' Use HTML to define the content of the card (like the headings and the paragraphs), and use CSS to define the appearance. Some ideas:

* Make the background-color of the page baby blue and use purple ink to write a card to a little boy
* Make the text big and include pictures of hearts
* Use a font with text shadows (more advanced)

Use this opportunity to experiment with the plethora of CSS properties. Remember that you're in a computer science class (not an art class), so we don't care if your card looks ugly. The main thing is that you learn HTML and CSS and use them appropriately.

==== How to Edit Your File ====

Starting in Module 2, we will be using Komodo Edit as our primary development tool. However, for the purposes of this exercise, we want you to edit your HTML file using a more basic text editor. '''If you already have a text editor that works for you, like [https://www.sublimetext.com/ Sublime Text], [https://atom.io/ Atom], Vim, or Emacs, feel free to use it for the entirety of this course. The same is true if you're already a fan of an IDE - you don't ''have'' to use any of the suggestions below.'''

* On Windows, consider Notepad++. This is already installed for you in the CEC labs. If you prefer to use your personal computer, you can download it from [https://notepad-plus-plus.org/ here].

* On Mac OS X, consider TextWrangler. You can download it from [http://www.barebones.com/products/textwrangler/ here] or from the Mac App Store.
* Most Linux distributions come with gedit pre-installed, which you can use for this lab.

Please save your file as ''birthday.html'' from the plain text editor of your choice.

'''Important Note:''' Writing your web page in a word processor like Microsoft Word or even WordPad or TextEdit will ''not'' work. You need a plain text editor.

==== How to View Your HTML Document ====

Once you have ''birthday.html'', you can open it using your favorite web browser (like Firefox). For the purposes of this exercise, it suffices to right-click the file and tell it to "open with" Firefox. When the file opens, it should be under the file:/// protocol.

In Module 2, we will install a web server that serves up pages on the http:// and https:// protocols.

==== Validation ====

'''Your birthday card must pass the W3C Validators for both HTML and CSS with no errors.''' You can upload your HTML to [https://validator.w3.org/ the HTML validator] and your CSS to [https://jigsaw.w3.org/css-validator/ the CSS validator].

For more information on validation, see the HTML and CSS guide: [[HTML and CSS#Validation]]

=== Make a Portal to a DuckDuckGo Search ===

'''Write an HTML document containing a form that searches DuckDuckGo's web site.''' You should be able to type in a search term and have your form load the DuckDuckGo search page.

# Visit [https://www.duckduckgo.com/ www.duckduckgo.com]. Search for something easy to spot in the URL, like "QUERY".
# Look at the URL of the search page. What is the script URL? What is the query variable?
# Make an HTML document containing a text field and a submit button. Typing a search query into the text field and pressing the submit button should load the DuckDuckGo search page.

== Grading ==

We will be grading the following aspects of your work. There are 50 points total.

'''Assignments must be committed to Bitbucket by the end of class on the due date. Commit early and often. Failing to commit by the end of class on the due date will result in a 0.

# '''Birthday Card (30 Points):'''
#* Correct usage of HTML and CSS in your birthday card (10 points).
#*: ''Make sure that you use HTML for "content" and CSS for "appearance." Don't write inline styles: use a separate stylesheet and link your HTML file to it.''
#* Experimenting with at least 5 different CSS properties in your birthday card (10 points).
#* Birthday card passes the W3C validation for HTML 5 and CSS. (10 points).
# '''Search Portal (10 Points):'''
#* DuckDuckGo search portal is functional (10 points).
# '''Account Creation and Version Control (10 Points):'''
#* Bitbucket account created (2 Points)
#* Module 1 repo created using the link provided on Piazza (2 Points)
#* Account created on Amazon Web Services and an image file containing a screenshot of your account page pushed to Bitbucket. (4 Points)
#* Files pushed to repo on Bitbucket using Git (2 Points)

[[Category:Module 1]]
[[Category:Modules]]

Module 2

2018-01-27T01:56:24Z

Alex: /* Grading */

__NOTOC__
Module 2 introduces you to Linux, a command-line environment, the Apache web server, and PHP. You will create and configure your own cloud instance, install Apache and related software, and then form groups to make a simple file sharing site.

<span style="font-size:1.3em; line-height:1.2em; color:blue;">'''DO NOT WAIT UNTIL THE LAST MINUTE TO START ON THIS (or any) MODULE!''' The most common reason students perform poorly in this class is procrastination. You have been warned.</span>

== Reading ==

The following articles on the online class wiki textbook contain information that will help you complete the assignments.

* [[Linux]]
* [[Bash]]
* [[Amazon Web Services]]
* [[SSH]]
* [[Apache]]
* [[PHP]]
* [[Workflow]]
* [[Web Application Security, Part 1]]

== Individual Assignments ==

{{RequiredInstructions|content=

<span style="color:red">There are a lot of wiki pages that you need to read in order to complete the individual portion of Module 2. The wiki pages contain an assortment of required steps, optional steps, and information. To make things easier, we have highlighted the ''required steps'' with a red bar, like you see on the left of this message. Do not skip anything marked with a red bar, or else you will not have a perfectly configured instance.</span>

}}

=== Learn About Linux ===

Linux is an open-source operating system based on UNIX. Linux is highly versatile and is used in a wide range of applications.

If you are not a Linux guru, read the Linux guide to get started: [[Linux]]

=== Windows Users Only: Enable Windows Subsystem for Linux (WSL) or Install Cygwin ===

You will need WSL or Cygwin in order to log into and configure your EC2 instance. Cygwin is already installed on the CEC machines. If you're using Windows 10, you can use WSL, which is an officially-supported way of accessing a Linux terminal on Windows. If not, you'll have to use Cygwin. Instructions for installing either on your personal machine are located in [[Workflow#Cygwin|the Workflow guide]].

Mac OS X users should located the "Terminal" application, which is installed by default; you will need this in the coming steps.

=== Create an AWS EC2 Instance ===

Once you understand [[Linux]], you need to set up your Amazon EC2 Instance. Use the AWS article to guide you through the process: [[Amazon Web Services]]

=== Configure SSH ===

Follow the instructions in [[SSH#SSH Configuration|the SSH guide]] to do the following:

# Create your own SSH key pair
# Log in as the default user to your EC2 instance
# Create a new user
# Give the new user your SSH public key

From now on, when you need to log into your EC2 instance as an administrator, just pop up a terminal and run:

<source lang="bash">
$ ssh your-username@ec2-xx-xx-xx-xx.compute-1.amazonaws.com
</source>

=== Install Essential Packages ===

Recall that software installation in Linux instances is usually handled through a package manager, like '''yum'''. For more information, refer to [[Linux#Repository-Based Package Managers|the Linux guide]].

To make sure everything is working properly, '''install your first package(s) according to the ''Essential Packages'' subsection in the Linux guide.'''

=== Set the Timezone ===

'''Set your server to use US Central time (America/Chicago).''' Instructions are in the Linux guide: [[Linux#Synchronizing Date and Time]]

=== Set Up the Apache Web Server ===

You need to '''install the Apache web server on your EC2 instance'''. Refer to [[Apache|the Apache guide]].

In order for your web server to be accessible, you need to '''open up Port 80 on your EC2 instance'''. Instructions are in the AWS guide: [[Amazon Web Services#Enabling Web Access to your EC2 Instance]]

'''Enable the UserDir module in Apache.''' Instructions are in the Apache guide: [[Apache#The UserDir Module]]

=== Install PHP ===

You need to '''install PHP on your EC2 server'''. Instructions are at the top of the PHP guide: [[PHP]]

You need to '''configure PHP to show errors'''. Instructions are immediately below installation in the PHP guide.

=== Learn about the PHP Language ===

Before you can continue, you will need to make yourself acquainted with PHP language components. Read the PHP guide for an overview: [[PHP#PHP Language Components]]

=== Set Up your Workspace ===

You are now ready to set up the workspace that you will be using for the rest of the semester. Follow the instructions in [[Workflow]] to:

# Make an account on Bitbucket
# Setup a repo using the CSE 330 Repo Creation Tool
# Install SourceTree
# '''Windows only:''' Set up Pageant so that SourceTree can conect to Bitbucket
# Clone your CSE 330 repo from Bitbucket
# Install Komodo Edit
# Create a Komodo Edit Project inside of your Git repository
# Add the ''*.komodoproject'' file to ''.gitignore''
# Install FileZilla
# Connect FileZilla to your remote instance

=== Calculator ===

'''Make a calculator using PHP and an HTML form.''' The form should have two inputs. The form should submit a GET request either back to the same page or to a different results page. The calculator should support addition, subtraction, multiplication, and division by means of a radio button group on the page. (Consider edge cases!)

== Group Project ==

You will work in pairs (that means you and one other person) on this project.

<span style="font-size:1.3em; line-height:1.2em; color:blue;">In this module, and all future modules, the group portion builds off of material you learn in the individual portion. You should therefore complete the individual portions prior to working on the group portions. (Trust us: it will make your life easier!)</span>

'''Important Reminder:''' frequently commit your work to your repository as a backup!

=== Simple File Sharing Site ===

You will be making a simple file sharing site that supports uploading, viewing, and deleting files associated with various users. Details:

* You should have a file named '''users.txt''' stored in a secure place on your filesystem. It should have at least three usernames, with one username per line.
*: Passwords add an extra layer of complexity (encryption) that we will cover in Module 3. You will not earn credit for implementing passwords as your creative portion for this module.
* Users of the file sharing site should be able to enter their username and then log in.
*: You may implement logins using session variables, or you may implement them using a GET parameter that is passed between pages. You will need to always use sessions starting in Module 3.
* Users should see a list of all files associated with their username after the log in.
* Users should be able to view, upload, and delete files associated with their username.
* The URI should NOT reveal the internal file structure of your web site.
** Example of what not to do: http://www.example.com/download.php?file=/home/paul/file.txt
** Another bad example: http://www.example.com/~user/file.txt
** Good example: http://www.example.com/view.php?user=music&name=file.txt
*: In general, don't reveal any internal information about the site.
*: '''Food for thought:''' Given that Apache processes (with the exception of the main process) do not run as root, but rather as the user apache, how can you allow both your user account and the php scripts to read and write the
*:necessary files?
*:: ''Hint:'' You shouldn't be storing the user-uploaded files in public_html (that is only the place for your own web-page files),
*::''Hint number 2:'' you will need to use chown to change permissions to let user apache have permissions on the user-files (that '''are not''' in the public_html folder). If you don't know what this does or how to do this, look at the [[Apache]] page
* You should customize your file sharing site by implementing an additional feature or two as part of the '''creative portion'''.

You will probably find the PHP guide on this wiki to be helpful: [[PHP#Other PHP Tips]]

=== Web Security and Validation ===

Your project needs to demonstrate that thought was put into web security and best practice. For more information, see this week's Web Application Security guide: [[Web Application Security, Part 1]]

In particular:

* '''Your application needs to follow the conventions of FIEO (Filter Input and Escape Output)'''. Things you should filter include file names, usernames, and so on.
* '''Your project must pass the W3C Validator with no errors'''. For more information, see the HTML and CSS guide: [[HTML and CSS#Validation]]

== Grading ==

We will be grading the following aspects of your work. There are 100 points total.

'''Assignments must be committed to BitBucket by the end of class on the due date. Commit early and often. Failing to commit by the end of class on the due date will result in a 0.

_____________

# '''Cloud Instance and Web Server (30 Points):'''
#* You can SSH into your instance using your own custom username and SSH key. Put a screenshot in your repository of your terminal SSH-ing into your instance (15 points)
#* Your custom username is able to perform SUDO commands. Put a screenshot in your repository of you successfully executing a command with sudo (5 points)
#* The time zone is correct on your instance. Put a screenshot in your repository of the results of the `date` command (5 points)
#* The UserDir Apache module is working. Place a file in /home/<username>/public_html and link to the file in your README.md (5 points)
# '''PHP Calculator (15 Points):'''
#* The calculator is able to perform all four functions with floating point numbers (2 points each, 8 points in total)
#* Each function is given as a radio button choice (4 points)
#* The calculator page passes the W3C HTML validator (3 points)
#* '''''Make sure you have a README.md file in your individual repo with the the link to your calculator.''''' See the Creative Portion section for more information about .md files.
# '''File Sharing Site (40 Points):'''
#* '''''File Management (25 Points):'''''
#** Users should not be able to see any files until they enter a username and log in (4 points)
#**: ''Remember that users.txt should be stored in a secure location on your filesystem. That is, '''you should not be able to type any URL into your browser and see the raw users.txt file!'''''
#** Users can see a list of all files they have uploaded (4 points)
#** Users can open files they have previously uploaded (5 points)
#**: ''Note: Users should be able to open not only plain text files but also other file formats: images, spreadsheets, etc.''
#** Users can upload files (4 points)
#**: ''Note: Like users.txt, uploaded files should be stored in a secure location on your filesystem. That is, '''do not keep your uploads directory underneath a directory served by Apache!'''''
#** Users can delete files. If a file is "deleted", it should actually be removed from the filesystem (4 points)
#** The directory structure is hidden (2 points)
#** Users can log out (2 points)
#**: ''Note: If using session variables, you must ''actually'' log out the user by destroying their session; i.e., don't just redirect them to the login screen.''
#* '''''Best Practices (10 Points):'''''
#** Code is well formatted and easy to read, with proper commenting (4 points)
#** The site follows the FIEO philosophy (3 points)
#** All pages pass the W3C validator (3 points)
#* '''''Usability (5 Points):'''''
#** Site is intuitive to use and navigate (4 points)
#** Site is visually appealing (1 point)
# '''Creative Portion (15 Points)''' (see below)
#* '''''Make sure you have a README.md file in your group repo with the following:'''''
#** An .md file is a plain text file called a markdown file [https://guides.github.com/features/mastering-markdown/ ] .
#***The contents of your README.md file are shown on your repo, making it easier for us to grade
#*** You may style the page with bolding, hyperlings, images, block quotes and lists
#*** [http://dillinger.io/ This online markdown editor] makes it easy to learn this format
#** The link to your file sharing site. '''''We need this to grade your work.'''''
#** A brief description of what you did for your creative portion
#** Any additional login details needed for the TA

=== Creative Portion ===

This module and all future modules will require that you invest some time into creating additional features for your group project. Plan to invest at least 60 minutes of your time into the creative portion.

* The creative portion is an opportunity for you to learn the material of your own interest.
* You will not earn credit for a creative-portion feature that simply rehashes something you've already done in a previous module.

If you need ideas for a creative portion, or if you want to know whether or not your creative portion idea is "hard enough", ask a TA.

[[Category:Module 2]]
[[Category:Modules]]