DAVID MALAN: Hello, world.

My name is David Malan, and
this is CS50's Introduction

to Programming with Python.

Whereas CS50 itself is an introduction
to the intellectual enterprises

of computer science and
the art of programming,

this course is specifically focused
on programming in Python itself.

At the beginning of the
course, we'll be focused

on a topic in programming known as
functions and variables, mechanisms

via which you can write code
that solves smaller problems,

but you can compose those
smaller solutions into solutions

to larger problems still.

We'll then transition to
a look at conditionals,

a way in code of expressing yourself
logically, to maybe do something

if some question has an
answer of true, or not

do something if the answer is false.

We'll transition thereafter
to introducing you

to loops, the ability, in code,
to do something again, and again,

and again some number of times.

We'll then transition to
something a little more technical,

known as exceptions.

Unfortunately, a lot can go wrong
when you're writing code, some of it

your fault, some of it
perhaps someone else's fault.

But you can write code defensively,
so to speak, and actually

catch those kinds of
exceptions, those errors,

and handle them properly so that
the users you're writing code for

don't actually see the same.

Thereafter, we'll take a look
at libraries, third-party code,

written by other people, often,
or perhaps yourself in the past,

that you can use and
reuse in your own projects

so as to avoid reinventing
the wheel again and again.

We'll look thereafter at
something called unit tests.

It turns out, you'll actually
write code to test your own code.

But you won't have to
write tests for your tests.

Indeed, this is a best practice in
industry, writing tests for your code

so that one, you can be sure that
your code today is, hopefully,

if your tests are
correct, correct itself.

But moreover, if you or someone else
modifies your code tomorrow, or down

the line, you can rerun
those same tests to ensure

that those new changes have not
broken anything about your own code.

We'll then take a look
at something called

File I/O, I/O for input
and output, the ability

to not just store information
inside of a computer's memory,

but rather save it persistently to
disk, so to speak, to files and folders.

We'll then take a look at
another technique, known

as regular expressions, whereby,
in Python, you can define patterns

and you can validate data to make sure
the human typed something in as you

expect.

You can use regular expressions
to extract data, perhaps

from some data set
you're trying to analyze.

We'll then take a look, ultimately,
at object-oriented programming,

a paradigm, a way of writing code,
whereby you can represent, in code,

real-world entities.

And this is in addition to other
paradigms of programming that we'll

also explore, among them
procedural programming,

where you write lots of
those functions, procedures

really, top to bottom, to
solve problems step by step,

and even something known as
functional programming, as well.

And then at the very end
of the course will we

equip you with all the more
tools for your toolkit.

and additional building
blocks, additional vocabulary

via which, after this same
course, you can go off on your own

and either take other courses
or solve projects of your own,

using all of these mechanisms.

Now this course itself assumes
no prior programming background.

So you don't have to have written
a single line of code in Python,

or any language, yet.

But this is also a course that you can
take before, during, or even after CS50

itself, if you'd like to get
all the more versed with Python.

Each week, via the courses
lectures, will we introduce you

to any number of
concepts that we'll then

drill down more deeply into in the
form of problem sets each week.

That is, programming
projects that will enable

you to apply some of those lessons
learned to problems of your very own.

And by the end of the
course, you'll have

solved so many problems that,
ideally, are representative

of problems you'll eventually
encounter in the real world,

whether you aspire to solve
code in the technical world

or perhaps in the arts, the
humanities, the social sciences,

the natural sciences, or beyond.

You'll have, ultimately, the
vocabulary and the technical skills

via which to approach the same.

This, then, is CS50.

And this is CS50's Introduction
to Programming with Python.