Introduction to Programming using Python

  • bvseo_sdk, p_sdk, 3.2.1
  • CLOUD, getReviews, 3.9ms
  • REVIEWS, PRODUCT
  • bvseo-msg: HTTP status code of 404 was returned; HTTP status code of 404 was returned;
Introduction to Programming using Python
Course Trailer
Overview
1: Overview

In this series, we are going to take a look at programming using the Python programming language. If you have tried to start before and just spun your wheels, then you should give it a try again. The progression of this course follows the Practice Labs environment for the same certification so there are supplements to each of those labs. Some of the topics that we are going to cover are: using basic data types and assigning those to variables, learning operations that can be applied to each of the data types, collecting information into a list structure, iterating over lists using both for and while loops, adding logic to our programs to add capabilities to our programs, and much more. We hope to see you there!

4 min
Working with Primitive Data Types
2: Working with Primitive Data Types

In this episode, Justin and Vonne start exploring the primitive Python data types: the string, the integer, the float, and the boolean types. Justin demonstrates defining variables for each of these types.

27 min
Working with Multiple Assignment Statements
3: Working with Multiple Assignment Statements

In this episode, Justin and Vonne explore utilizing multiple assignment statements to ensure that variables have the same value. Additionally, Justin provides a way to combine variable definition and assignment statements on a single line for variables that are related.

22 min
Converting Types in Python
4: Converting Types in Python

In this episode, Justin and Vonne jump into converting between types of data such as converting strings to integers and vice versa. Justin discusses the reasoning for converting data from one type to another and highlights gotchas when converting between types.

30 min
Creating Lists
5: Creating Lists

In this episode, Justin and Vonne take a look at the list data type. Justin demonstrates creating a list using the list literal syntax and discusses use cases for lists. Furthermore, Justin and Vonne examine the use of a zero-based index.

24 min
Modifying Lists
6: Modifying Lists

In this episode, Justin and Vonne continue their analysis of lists by taking a look at common ways to modify lists including deleting an element, changing an element, and altering sections of lists.

19 min
Sorting and Reversing Lists
7: Sorting and Reversing Lists

In this episode, Justin and Vonne review sorting and reversing a list of elements. Justin explores the fact that elements of the list must be comparable to sorting and reversing the elements of a list.

22 min
Slicing Lists
8: Slicing Lists

In this episode, Justin and Vonne review what to do when you need a subsection of a list. Justin demonstrates using the slice syntax, as well as the shorthand versions, to take a subsection of a list.

18 min
Working with Operators
9: Working with Operators

In this episode, Justin and Vonne take a look at different sets of operators, mathematical and comparison operators. First, Justin demonstrates the use of mathematical operators including power and modulo operators. Additionally, Justin explores the use of the comparison operators for numbers and strings.

29 min
Determining Operator Precedence
10: Determining Operator Precedence

In this episode, Justin and Vonne highlight the order of execution of operators that are combined into a complex expression. Justin reviews the Python documentation and highlights some possible confusing points.

23 min
Working with If Statements
11: Working with If Statements

In this episode, Justin and Vonne introduce if statements as a way to provide conditional execution of programs. Justin demonstrates the addition of else statements as well as elif statements and discusses the implication of adding those statements to an if statement.

20 min
Using Compound Conditional Expressions
12: Using Compound Conditional Expressions

In this episode, Justin and Vonne build upon the basic if statement by adding the ability to test multiple conditions for the executions utilizing the `and` and `or` keywords. Justin discusses the logical differences of the `and` and `or` operators.

25 min
Working with For Loops
13: Working with For Loops

In this episode, Justin and Vonne analysis the need for `for` loops. Justin sets the scene for the use of the for loop as well as demonstrates the use of a for loop to iterate over a collection structure.

24 min
Working with While Loops
14: Working with While Loops

In this episode, Justin and Vonne continue their look into loops by exploring the while loop. They discuss the similarities and difference between the while loop and for loop as well as demonstrate the use of a while loop. Justin highlights gotchas that can occur when using while loops.

19 min
Nesting For Loops
15: Nesting For Loops

In this episode, Justin and Vonne up the complexity of looping by demonstrating the use of nested for loops. Justin explores when to use nested for loops, writing nested loops, and discusses performance implications of nesting loops.

20 min
Reading Files
16: Reading Files

In this episode, Justin and Vonne learn how to read files in Python. Justin demonstrates reading from a file using the manual process of opening and closing the file. After discusses the issues that can occur using that manual process, Justin demonstrates the use of the context manager to automate the closing of a file.

17 min
Copying Files
17: Copying Files

In this episode, Justin and Vonne continue working with files by first learning how to write information to a file with attention paid to the difference between write and append modes. Afterword, Justin demonstrates using file reading and writing to copy files.

22 min
Merging Mails
18: Merging Mails

In this episode, Justin and Vonne circle back to using files to accomplish repetitive tasks by creating emails to send from a list of names and message to send to those names.

18 min
Reading Console Inputs and Formatting Outputs
19: Reading Console Inputs and Formatting Outputs

In this episode, Justin and Vonne take a deeper look into taking user input, particularly with respect the data type of user input. While building a simple project, demonstrates a more readable way of formatting outputs that are printed to the user.

28 min
Reading Command Line Arguments
20: Reading Command Line Arguments

In this episode, Justin and Vonne take a different look at user input by taking command line arguments. Justin demostrates using the command line interface to run a Python program and then how to utilize additional information from the command line to build a simple tool.

24 min
Defining Functions
21: Defining Functions

In this episode, Justin and Vonne further discuss functions such as the difference between using built-in functions versus writing custom functions. Justin demonstrates writing a custom function as well as discusses the reasons for defining a custom function.

24 min
Using Default Arguments
22: Using Default Arguments

In this episode, Justin and Vonne expand their look into functions by demonstrating the use of default arguments in order to provide a fallback value for a function argument.

13 min
Using Keyword and Positional Arguments
23: Using Keyword and Positional Arguments

In this episode, Justin and Vonne add to the discussion of default arguments by discussing the difference of keyword and positional argument. Justin explores the different forms that each one of the argument types can take as well as some rules of thumb of when to use which.

26 min
Handling Exceptions
24: Handling Exceptions

In this episode, Justin and Vonne dive into handling runtime errors by learning about the try-except construct to recover from errors. Justin discusses issues that can arise for misuse of try-except as well as when to just fail versus handle the error.

24 min
Using Math and Random Modules
25: Using Math and Random Modules

In this episode, Justin and Vonne look a little deeper into the standard library by exploring the math and random modules. Additionally, Justin demonstrates using the documentation for modules to get a better understanding of capabilities of the module.

27 min
Displaying Datetime Working Directory and File Metadata
26: Displaying Datetime Working Directory and File Metadata

In this episode, Justin and Vonne continue their look into the Python Standard library by exploring the `datetime` and `os` modules. Justin provides common situations where these modules can be used instead of 'reinventing the wheel'.

30 min
Justin Dennison

ALMA MATER

University of Florida

INSTITUTION

ITProTV

About Justin Dennison

Justin Dennison leads AWS and developer content creation for ITProTV, an elearning company specializing in information technology education. He has experience in multiple programming languages. His certifications inlcude AWS Certified Solutions Architect - Associate; AWS Certified Developer - Associate; AWS Certified Cloud Practitioner; Oracle Certified Associate; Java SE 7 Programmer.

Also By This Professor