summaryrefslogtreecommitdiff
path: root/slides/basic_python
diff options
context:
space:
mode:
Diffstat (limited to 'slides/basic_python')
-rw-r--r--slides/basic_python/func.tex294
-rw-r--r--slides/basic_python/intro.tex477
-rw-r--r--slides/basic_python/io_files_parsing.tex239
-rw-r--r--slides/basic_python/python.tex56
-rw-r--r--slides/basic_python/strings_loops_lists.tex457
-rw-r--r--slides/basic_python/tmp.tex1
-rw-r--r--slides/basic_python/tuples_dicts_sets.tex258
7 files changed, 1782 insertions, 0 deletions
diff --git a/slides/basic_python/func.tex b/slides/basic_python/func.tex
new file mode 100644
index 0000000..b66be06
--- /dev/null
+++ b/slides/basic_python/func.tex
@@ -0,0 +1,294 @@
+\section{Functions}
+
+\begin{frame}[fragile]
+ \frametitle{Abstracting}
+ \begin{itemize}
+ \item Reduce duplication of code
+ \item Fewer lines of code and hence lesser scope for bugs
+ \item Re-usability of code, that's already been written
+ \item Use functions written by others, without exactly knowing how
+ they do, what they are doing
+ \item \alert{Enter Functions!}
+ \end{itemize}
+\end{frame}
+
+
+\begin{frame}[fragile]
+ \frametitle{Defining functions}
+ \begin{itemize}
+ \item Consider the function \texttt{f(x) = x\textasciicircum{}2}
+ \item Let's write a Python function, equivalent to this
+ \end{itemize}
+ \begin{lstlisting}
+ In[]: def f(x):
+ ....: return x*x
+ ....:
+
+ In[]: f(1)
+ In[]: f(2)
+ \end{lstlisting}
+ \begin{itemize}
+ \item \texttt{def} is a keyword
+ \item \texttt{f} is the name of the function
+ \item \texttt{x} the parameter of the function
+ \item \texttt{return} is a keyword; specifies what should be
+ returned
+ \end{itemize}
+\end{frame}
+
+\begin{frame}[fragile]
+ \frametitle{Defining functions \ldots}
+ \begin{lstlisting}
+ In[]: def greet():
+ ....: print "Hello World!"
+ ....:
+
+ In[]: greet()
+ \end{lstlisting}
+ \begin{itemize}
+ \item \texttt{greet} is a function that takes no arguments
+ \item Also, it is not returning anything explicitly
+ \item But implicitly, Python returns \texttt{None}
+ \end{itemize}
+ \begin{lstlisting}
+ In[]: def avg(a, b):
+ ....: return (a + b)/2
+ ....:
+
+ In[]: avg(12, 10)
+ \end{lstlisting}
+\end{frame}
+
+\begin{frame}[fragile]
+ \frametitle{Doc-strings}
+ \begin{itemize}
+ \item It's highly recommended that all functions have documentation
+ \item We write a doc-string along with the function definition
+ \end{itemize}
+ \begin{lstlisting}
+ In[]: def avg(a, b):
+ """ avg takes two numbers as input
+ and returns their average"""
+
+ ....: return (a + b)/2
+ ....:
+
+ In[]: avg?
+ In[]: greet?
+ \end{lstlisting}
+\end{frame}
+
+\begin{frame}[fragile]
+ \frametitle{Returning multiple values}
+ \begin{itemize}
+ \item Return area and perimeter of circle, given radius
+ \item Function needs to return two values
+ \end{itemize}
+ \begin{lstlisting}
+ In[]: def circle(r):
+ """returns area and perimeter of a
+ circle given, the radius r"""
+
+ ....: pi = 3.14
+ ....: area = pi * r * r
+ ....: perimeter = 2 * pi * r
+ ....: return area, perimeter
+ ....:
+
+ In[]: circle(4)
+ In[]: a, p = circle(6)
+ In[]: print a
+ In[]: print p
+ \end{lstlisting}
+ \begin{itemize}
+ \item Any number of values can be returned
+ \end{itemize}
+\end{frame}
+
+\begin{frame}[fragile]
+ \frametitle{What? -- 1}
+ \begin{lstlisting}
+ In[]: def what( n ):
+ ....: if n < 0: n = -n
+ ....: while n > 0:
+ ....: if n % 2 == 1:
+ ....: return False
+ ....: n /= 10
+ ....: return True
+ ....:
+ \end{lstlisting}
+\end{frame}
+
+\begin{frame}[fragile]
+ \frametitle{What? -- 2}
+ \begin{lstlisting}
+ In[]: def what( n ):
+ ....: i = 1
+ ....: while i * i < n:
+ ....: i += 1
+ ....: return i * i == n, i
+ ....:
+ \end{lstlisting}
+\end{frame}
+
+\subsection*{Default \& Keyword Arguments}
+
+\begin{frame}[fragile]
+ \frametitle{Default arguments}
+ \begin{lstlisting}
+ In[]: round(2.484)
+ In[]: round(2.484, 2)
+
+ In[]: s.split() # split on spaces
+ In[]: s.split(';') # split on ';'
+
+ In[]: range(10) # returns numbers from 0 to 9
+ In[]: range(1, 10) # returns numbers from 1 to 9
+ In[]: range(1, 10, 2) # returns odd numbers from 1 to 9
+ \end{lstlisting}
+\end{frame}
+
+\begin{frame}[fragile]
+ \frametitle{Default arguments \ldots}
+ \begin{lstlisting}
+ In[]: def welcome(greet, name="World"):
+ ....: print greet, name
+ ....:
+
+ In[]: welcome("Hi", "Guido")
+ In[]: welcome("Hello")
+ \end{lstlisting}
+ \begin{itemize}
+ \item Arguments with default values, should be placed at the end
+ \item The following definition is \alert{WRONG}
+ \end{itemize}
+ \begin{lstlisting}
+ In[]: def welcome(name="World", greet):
+ ....: print greet, name
+ ....:
+ \end{lstlisting}
+\end{frame}
+
+\begin{frame}[fragile]
+ \frametitle{Keyword Arguments}
+ \begin{lstlisting}
+ In[]: def welcome(greet, name="World"):
+ ....: print greet, name
+ ....:
+
+ In[]: welcome("Hello", "James")
+
+ In[]: welcome("Hi", name="Guido")
+
+ In[]: welcome(name="Guido", greet="Hey")
+
+ In[]: welcome(name="Guido", "Hey")
+ \end{lstlisting}
+\end{frame}
+
+\begin{frame}[fragile]
+ \frametitle{Built-in functions}
+ \begin{itemize}
+ \item Variety of built-in functions are available
+ \item \texttt{abs, any, all, len, max, min}
+ \item \texttt{pow, range, sum, type}
+ \item Refer here:
+ \url{http://docs.python.org/library/functions.html}
+ \end{itemize}
+\end{frame}
+
+\subsection*{Variable Scope}
+
+\begin{frame}[fragile]
+ \frametitle{Arguments are local}
+ \begin{lstlisting}
+ In[]: def change(q):
+ ....: q = 10
+ ....: print q
+ ....:
+
+ In[]: change(1)
+ In[]: print q
+ \end{lstlisting}
+\end{frame}
+
+\begin{frame}[fragile]
+ \frametitle{Variables inside function are local}
+ \begin{lstlisting}
+ In[]: n = 5
+ In[]: def change():
+ ....: n = 10
+ ....: print n
+ ....:
+ In[]: change()
+ In[]: print n
+ \end{lstlisting}
+ \begin{itemize}
+ \item Use the \texttt{global} statement to assign to global variables
+ \end{itemize}
+ \begin{lstlisting}
+ In[]: def change():
+ ....: global n
+ ....: n = 10
+ ....: print n
+ ....:
+ In[]: change()
+ In[]: print n
+ \end{lstlisting}
+\end{frame}
+
+\begin{frame}[fragile]
+ \frametitle{global}
+ \begin{itemize}
+ \item Use the \texttt{global} statement to assign to global variables
+ \end{itemize}
+ \begin{lstlisting}
+ In[]: def change():
+ ....: global n
+ ....: n = 10
+ ....: print n
+ ....:
+ In[]: change()
+ In[]: print n
+ \end{lstlisting}
+\end{frame}
+
+\begin{frame}[fragile]
+ \frametitle{Mutable variables}
+ \begin{itemize}
+ \item Behavior is different when assigning to a list element/slice
+ \item Python looks up for the name, from innermost scope outwards,
+ until the name is found
+ \end{itemize}
+ \begin{lstlisting}
+ In[]: name = ['Mr.', 'Steve', 'Gosling']
+ In[]: def change_name():
+ ....: name[0] = 'Dr.'
+ ....:
+ In[]: change_name()
+ In[]: print name
+ \end{lstlisting}
+\end{frame}
+
+\begin{frame}[fragile]
+ \frametitle{Passing Arguments \ldots}
+ \begin{lstlisting}
+ In[]: n = 5
+ In[]: def change(n):
+ ....: n = 10
+ ....: print "n = %s inside change " %n
+ ....:
+ In[]: change(n)
+ In[]: print n
+ \end{lstlisting}
+
+ \begin{lstlisting}
+ In[]: name = ['Mr.', 'Steve', 'Gosling']
+ In[]: def change_name(n):
+ ....: n[0] = 'Dr.'
+ ....: print "n = %s inside change_name" %n
+ ....:
+ In[]: change_name(name)
+ In[]: print name
+ \end{lstlisting}
+\end{frame}
diff --git a/slides/basic_python/intro.tex b/slides/basic_python/intro.tex
new file mode 100644
index 0000000..52be064
--- /dev/null
+++ b/slides/basic_python/intro.tex
@@ -0,0 +1,477 @@
+\section{The Language}
+\begin{frame}[fragile]
+ \frametitle{Python!}
+ \begin{itemize}
+ \item Programming Language
+ \item Powerful, High-level, Interpreted, Multi-Platform
+ \item Elegant and highly readable syntax
+ \item Efficient high-level data structures
+ \end{itemize}
+ \begin{itemize}
+ \item Easy to learn
+ \item Allows to concentrate on the problem instead of the language
+ \item Increased Productivity
+ \end{itemize}
+ \begin{itemize}
+ \item Guido van Rossum -- BDFL
+ \item Conceived in December 1989
+ \item Named after ``Monty Python's Flying Circus'', a 70s comedy
+ \end{itemize}
+\end{frame}
+
+\begin{frame}[fragile]
+ \frametitle{Why Python?}
+ \begin{itemize}
+ \item Extremely readable; Forces programmers to write readable code.
+ \item Interactive; Offers a very fast edit-test-debug cycle.
+ \item Doesn't get in your way; High-level data structures let you
+ focus on the problem
+ \item Handles memory management
+ \item Batteries included; Huge standard library for wide range of
+ tasks.
+ \item Object-oriented.
+ \item C, C++ and FORTRAN interfacing allows use of legacy code
+ \item Your time is more valuable than machine time!
+ \end{itemize}
+\end{frame}
+
+\section{The Interpreter}
+\begin{frame}[fragile]
+ \frametitle{Python interpreter}
+ \begin{itemize}
+ \item Let's get our hands dirty!
+ \item Start Python from your shell
+ \end{itemize}
+ \lstset{language=sh}
+ \begin{lstlisting}
+ $ python
+ \end{lstlisting} %$
+ \begin{lstlisting}
+Python 2.7.1 (r271:86832, Feb 21 2011, 01:28:26)
+[GCC 4.5.2 20110127 (prerelease)] on linux2
+Type "help", "copyright", "credits" or "license" for more information.
+>>>
+ \end{lstlisting}
+ \begin{itemize}
+ \item First line shows Python version (2.7.1)
+ \item \verb+>>>+ the interpreter's prompt
+ \item The interpreter is ready and waiting for your command!
+ \end{itemize}
+\end{frame}
+
+\begin{frame}[fragile]
+ \frametitle{Hello World!}
+ \begin{itemize}
+ \item Type\texttt{print `Hello World'} and hitting enter
+ \end{itemize}
+ \begin{lstlisting}
+ >>> print 'Hello, World!'
+ Hello, World!
+ \end{lstlisting}
+ \begin{itemize}
+ \item The interpreter prints out the words \emph{Hello World}
+ \end{itemize}
+ \begin{itemize}
+ \item Hit \texttt{Ctrl-D} to exit the interpreter
+ \item We shall look at IPython, an enhanced interpreter
+ \end{itemize}
+\end{frame}
+
+\begin{frame}[fragile]
+ \frametitle{Versions}
+ Before moving on \ldots
+ \begin{itemize}
+ \item Currently has two stable branches or versions, 2.x and 3.x
+ \item 3.x is not backward compatible
+ \item 3.x is deemed to be the future of Python
+ \item But, we shall stick to 2.x for this course
+ \item The ecosystem around Python 2.x hasn't yet moved to 3.x
+ \end{itemize}
+\end{frame}
+
+\subsection*{IPython}
+
+\begin{frame}[fragile]
+ \frametitle{Invoking IPython}
+ \begin{itemize}
+ \item An enhanced Python interpreter
+ \item Tab-completion, Easier access to help, Better history
+ \end{itemize}
+ \lstset{language=sh}
+ \begin{lstlisting}
+ $ ipython
+ \end{lstlisting} %$
+ \alert{If \texttt{ipython is not installed}, you need to install it!}
+ \begin{itemize}
+ \item The prompt is \texttt{In [1]:} instead of \verb+>>>+
+ \item \texttt{In} stands for input, 1 indicates the command number
+ \item Try \texttt{Hello World}
+ \end{itemize}
+ \begin{lstlisting}
+ In []: print 'Hello, World!'
+ Out[]: Hello, World!
+ \end{lstlisting}
+ {\tiny the numbers have been omitted to avoid confusion}
+ \begin{itemize}
+ \item Hit \texttt{Ctrl-D} to exit \texttt{ipython}; Say \texttt{y}
+ when prompted.
+ \end{itemize}
+\end{frame}
+
+\begin{frame}[fragile]
+ \frametitle{Getting comfortable}
+ \begin{itemize}
+ \item Let's try some simple math to get comfortable
+ \end{itemize}
+ \begin{lstlisting}
+ In []: 1 + 2
+ In []: 5 - 3
+ In []: 7 - 4
+ In []: 6 * 5
+ \end{lstlisting}
+ \begin{itemize}
+ \item We get back the expected output
+ \item Output is displayed with an \texttt{Out[]}
+ \end{itemize}
+\end{frame}
+
+\begin{frame}[fragile]
+ \frametitle{History \& Arrow Keys}
+ \begin{itemize}
+ \item Change the \texttt{print 1+2}
+ \item Use <UP-Arrow> to go back to \texttt{1+2} command
+ \item Use <LEFT-Arrow> to get to start of line; type \texttt{print }
+ \item Hit <RETURN>
+ \end{itemize}
+ \begin{lstlisting}
+ In []: print 1 + 2
+ \end{lstlisting}
+ \begin{itemize}
+ \item Now, change the previous command to \texttt{print 10*2}
+ \end{itemize}
+\end{frame}
+
+\begin{frame}[fragile]
+ \frametitle{Tab-Completion}
+ \begin{itemize}
+ \item We want to use \texttt{round} function
+ \item Type \texttt{ro}, and hit <TAB>
+ \end{itemize}
+ \begin{lstlisting}
+ In []: ro<TAB>
+ \end{lstlisting}
+ \begin{itemize}
+ \item Type \texttt{r}, and hit <TAB>
+ \item All possibilities are listed out, when ambiguous
+ \end{itemize}
+\end{frame}
+
+\begin{frame}[fragile]
+ \frametitle{\texttt{?} for Help}
+ \begin{itemize}
+ \item To get help for \texttt{abs} function
+ \end{itemize}
+ \begin{lstlisting}
+ In []: abs?
+ In []: abs(19)
+ In []: abs(-10.5)
+ \end{lstlisting}
+ \begin{itemize}
+ \item Look at documentation for \texttt{round}
+ \item Optional arguments are denoted with square brackets
+ \texttt{[]}
+ \end{itemize}
+ \begin{lstlisting}
+ In []: round(2.484)
+ In []: round(2.484, 1)
+ In []: round(2.484, 2)
+ \end{lstlisting}
+\end{frame}
+
+\begin{frame}[fragile]
+ \frametitle{\texttt{?} for Help}
+ \begin{itemize}
+ \item To get help for \texttt{abs} function
+ \end{itemize}
+ \begin{lstlisting}
+ In []: abs?
+ In []: abs(19)
+ In []: abs(-10.5)
+ \end{lstlisting}
+ \begin{itemize}
+ \item Look at documentation for \texttt{round}
+ \item Optional arguments are denoted with square brackets
+ \texttt{[]}
+ \end{itemize}
+ \begin{lstlisting}
+ In []: round(2.484)
+ In []: round(2.484, 1)
+ In []: round(2.484, 2)
+ \end{lstlisting}
+\end{frame}
+
+\begin{frame}[fragile]
+ \frametitle{Interrupting}
+ \begin{lstlisting}
+ In []: round(2.484
+ ...:
+ \end{lstlisting}
+ \begin{itemize}
+ \item The \ldots prompt is the continuation prompt
+ \item It comes up, since we haven't completed previous command
+ \item Either complete by typing the missing \texttt{)}
+ \item OR hit \texttt{Ctrl-C} to interrupt the command
+ \end{itemize}
+ \begin{lstlisting}
+ In []: round(2.484
+ ...: ^C
+ \end{lstlisting}
+\end{frame}
+
+\section{Basic Datatypes and Operators}
+
+\begin{frame}[fragile]
+ \frametitle{Basic Datatypes}
+ \begin{itemize}
+ \item Numbers
+ \begin{itemize}
+ \item int
+ \item float
+ \item complex
+ \end{itemize}
+ \item Boolean
+ \item Sequence
+ \begin{itemize}
+ \item Strings
+ \item Lists
+ \item Tuples
+ \end{itemize}
+ \end{itemize}
+\end{frame}
+
+\begin{frame}[fragile]
+ \frametitle{\texttt{int}}
+ \begin{lstlisting}
+ In []: a = 13
+ In []: a
+ \end{lstlisting}
+ \begin{itemize}
+ \item \texttt{a} is a variable of the \texttt{int} type
+ \item Use the \texttt{type} command to verify
+ \end{itemize}
+ \begin{lstlisting}
+ In []: type(a)
+ \end{lstlisting}
+ \begin{itemize}
+ \item Integers can be arbitrarily long
+ \end{itemize}
+ \begin{lstlisting}
+ In []: b = 9999999999999999999999999999
+ In []: b
+ \end{lstlisting}
+\end{frame}
+
+\begin{frame}[fragile]
+ \frametitle{\texttt{float}}
+ \begin{lstlisting}
+ In []: p = 3.141592
+ In []: p
+ \end{lstlisting}
+ \begin{itemize}
+ \item Decimal numbers are represented using the \texttt{float} type
+ \item Notice the loss of precision
+ \item Floats have a fixed precision
+ \end{itemize}
+\end{frame}
+
+\begin{frame}[fragile]
+ \frametitle{\texttt{complex}}
+ \begin{lstlisting}
+ In []: c = 3+4j
+ \end{lstlisting}
+ \begin{itemize}
+ \item A complex number with real part 3, imaginary part 4
+ \end{itemize}
+ \begin{lstlisting}
+ In []: c.real
+ In []: c.imag
+ In []: abs(c)
+ \end{lstlisting}
+ \begin{itemize}
+ \item It's a combination of two floats
+ \item \texttt{abs} gives the absolute value
+ \end{itemize}
+\end{frame}
+
+\begin{frame}[fragile]
+ \frametitle{Operations on numbers}
+ \begin{lstlisting}
+ In []: 23 + 74
+ In []: 23 - 56
+ In []: 45 * 76
+
+ In []: 8 / 3
+ In []: 8.0 / 3
+ In []: float(8) / 3
+ \end{lstlisting}
+ \begin{itemize}
+ \item The first division is an integer division
+ \item To avoid integer division, at least one number should be float
+ \item \texttt{float} function is changing int to float
+ \end{itemize}
+ \begin{lstlisting}
+ In []: 87 % 6
+ In []: 7 ** 8
+ \end{lstlisting}
+ \begin{itemize}
+ \item \texttt{\%} is used for modulo operation
+ \item \texttt{**} is used for exponentiation
+ \end{itemize}
+\end{frame}
+
+\begin{frame}[fragile]
+ \frametitle{Variables \& assignment}
+ \begin{itemize}
+ \item All the operations could be done on variables
+ \end{itemize}
+ \begin{lstlisting}
+ In []: a = 23
+ In []: b = 74
+ In []: a * b
+
+ In []: c = 8
+ In []: d = 8.0
+ In []: f = c / 3
+ \end{lstlisting}
+ \begin{itemize}
+ \item Last two commands show assignment
+ \end{itemize}
+ \begin{lstlisting}
+ In []: c = c / 3
+ \end{lstlisting}
+ An operation like the one above, may equivalently be written as
+ \begin{lstlisting}
+ In []: c /= 3
+ \end{lstlisting}
+\end{frame}
+
+\begin{frame}[fragile]
+ \frametitle{Booleans \& Operations}
+ \begin{itemize}
+ \item All the operations could be done on variables
+ \end{itemize}
+ \begin{lstlisting}
+ In []: t = True
+ In []: t
+ In []: f = not t
+ In []: f
+ In []: f or t
+ In []: f and t
+ \end{lstlisting}
+ \begin{itemize}
+ \item Multiple operation in a single command
+ \item We use parenthesis for explicitly stating what we mean
+ \item No discussion of operator precedence
+ \end{itemize}
+ \begin{lstlisting}
+ In []: (f and t) or t
+ In []: f and (t or t)
+ \end{lstlisting}
+\end{frame}
+
+\begin{frame}[fragile]
+ \frametitle{Sequences}
+ \begin{itemize}
+ \item Hold a bunch of elements in a sequence
+ \item Elements are accessed based on position in the sequence
+ \item The sequence data-types
+ \begin{itemize}
+ \item str
+ \item list
+ \item tuple
+ \end{itemize}
+ \end{itemize}
+\end{frame}
+
+\begin{frame}[fragile]
+ \frametitle{Strings, Lists \& Tuples}
+ \begin{itemize}
+ \item Anything withing quotes is a string
+ \end{itemize}
+ \begin{lstlisting}
+ In []: greet_str = "hello"
+ \end{lstlisting}
+ \begin{itemize}
+ \item Items enclosed in \texttt{[ ]} and separated by \texttt{,}s
+ constitute a list
+ \end{itemize}
+ \begin{lstlisting}
+ In []: num_list = [1, 2, 3, 4, 5, 6, 7, 8]
+ \end{lstlisting}
+ \begin{itemize}
+ \item Items of a tuple are enclosed by \texttt{( )} instead of
+ \texttt{[ ]}
+ \end{itemize}
+ \begin{lstlisting}
+ In []: num_tuple = (1, 2, 3, 4, 5, 6, 7, 8)
+ \end{lstlisting}
+\end{frame}
+
+\begin{frame}[fragile]
+ \frametitle{Operations on Sequences}
+ \begin{itemize}
+ \item Accessing elements
+ \end{itemize}
+ \begin{lstlisting}
+ In []: num_list[2]
+ In []: num_tuple[2]
+ In []: greet_str[2]
+ \end{lstlisting}
+ \begin{itemize}
+ \item Add two sequences of same type
+ \end{itemize}
+ \begin{lstlisting}
+ In []: num_list + [3, 4, 5, 6]
+ In []: greet_str + " world!"
+ \end{lstlisting}
+ \begin{itemize}
+ \item Get the length of a sequence
+ \end{itemize}
+ \begin{lstlisting}
+ In []: len(num_list)
+ In []: len(greet_str)
+ \end{lstlisting}
+\end{frame}
+
+\begin{frame}[fragile]
+ \frametitle{Operations on Sequences \ldots}
+ \begin{itemize}
+ \item Check for container-ship of elements
+ \end{itemize}
+ \begin{lstlisting}
+ In []: 3 in num_list
+ In []: 'h' in greet_str
+ In []: 'w' in greet_str
+ In []: 2 in num_tuple
+ \end{lstlisting}
+ \begin{itemize}
+ \item Finding maximum and minimum
+ \end{itemize}
+ \begin{lstlisting}
+ In []: max(num_list)
+ In []: min(greet_str)
+ \end{lstlisting}
+ \begin{itemize}
+ \item Slice a sequence
+ \end{itemize}
+ \begin{lstlisting}
+ In []: num_list[1:5]
+ \end{lstlisting}
+ \begin{itemize}
+ \item Stride over a sequence
+ \end{itemize}
+ \begin{lstlisting}
+ In []: num_list[1:8:2]
+ \end{lstlisting}
+\end{frame}
+
diff --git a/slides/basic_python/io_files_parsing.tex b/slides/basic_python/io_files_parsing.tex
new file mode 100644
index 0000000..cb46cbe
--- /dev/null
+++ b/slides/basic_python/io_files_parsing.tex
@@ -0,0 +1,239 @@
+\section{I/O}
+
+\begin{frame}[fragile]
+ \frametitle{Printing}
+ \begin{lstlisting}
+ In[]: a = "This is a string"
+ In[]: a
+ In[]: print a
+ \end{lstlisting}
+ \begin{itemize}
+ \item Both \texttt{a}, and \texttt{print a} are showing the value
+ \item What is the difference?
+ \item Typing \texttt{a} shows the value; \texttt{print a} prints it
+ \item Typing \texttt{a} shows the value only in interpreter
+ \item In a script, it has no effect.
+ \end{itemize}
+ \begin{lstlisting}
+ In[]: b = "A line \n New line"
+ In[]: b
+ In[]: print b
+ \end{lstlisting}
+\end{frame}
+
+\begin{frame}[fragile]
+ \frametitle{String formatting}
+ \begin{lstlisting}
+ In[]: x = 1.5
+ In[]: y = 2
+ In[]: z = "zed"
+ In[]: print "x is %2.1f y is %d z is %s" %(x, y, z)
+ \end{lstlisting}
+\end{frame}
+
+\begin{frame}[fragile]
+ \frametitle{\texttt{print x} \& \texttt{print x,}}
+ \begin{itemize}
+ \item Open an editor
+ \item Type the following code
+ \item Save as \texttt{print\_example.py}
+ \end{itemize}
+ \begin{lstlisting}
+ In[]: print "Hello"
+ In[]: print "World"
+
+ In[]: print "Hello",
+ In[]: print "World"
+ \end{lstlisting}
+ \begin{itemize}
+ \item Run the script using \texttt{\% run print\_example.py}
+ \item \texttt{print x} adds a newline whereas \texttt{print x,} adds
+ a space
+ \end{itemize}
+\end{frame}
+
+\begin{frame}[fragile]
+ \frametitle{\texttt{raw\_input}}
+ \begin{lstlisting}
+ In[]: ip = raw_input()
+ \end{lstlisting}
+ \begin{itemize}
+ \item The cursor is blinking; waiting for input
+ \item Type \texttt{an input} and hit <ENTER>
+ \end{itemize}
+ \begin{lstlisting}
+ In[]: print ip
+ \end{lstlisting}
+\end{frame}
+
+\begin{frame}[fragile]
+ \frametitle{\texttt{raw\_input} \ldots}
+ \begin{lstlisting}
+ In[]: c = raw_input()
+ In[]: 5.6
+ In[]: c
+ In[]: type(c)
+ \end{lstlisting}
+ \begin{itemize}
+ \item \alert{\texttt{raw\_input} always takes a string}
+ \end{itemize}
+ \begin{lstlisting}
+ In[]: name = raw_input("Please enter your name: ")
+ George
+ \end{lstlisting}
+ \begin{itemize}
+ \item \texttt{raw\_input} can display a prompt string for the user
+ \end{itemize}
+\end{frame}
+
+\section{Files}
+
+\begin{frame}[fragile]
+ \frametitle{Opening files}
+ \begin{lstlisting}
+ pwd # present working directory
+ cd /home/fossee # go to location of the file
+ \end{lstlisting}
+ {\tiny The file is in our present working directory}
+ \begin{lstlisting}
+ In[]: f = open('pendulum.txt')
+ In[]: f
+ \end{lstlisting}
+ \begin{itemize}
+ \item \texttt{f} is a file object
+ \item Shows the mode in which the file is open (read mode)
+ \end{itemize}
+\end{frame}
+
+\begin{frame}[fragile]
+ \frametitle{Reading the whole file}
+ \begin{lstlisting}
+ In[]: pend = f.read()
+ In[]: print pend
+ \end{lstlisting}
+ \begin{itemize}
+ \item We have read the whole file into the variable \texttt{pend}
+ \end{itemize}
+ \begin{lstlisting}
+ In[]: type(pend)
+ In[]: pend_list = pend.splitlines()
+ In[]: pend_list
+ \end{lstlisting}
+ \begin{itemize}
+ \item \texttt{pend} is a string variable
+ \item We can split it at the newline characters into a list of
+ strings
+ \item Close the file, when done; Also, if you want to read again
+ \end{itemize}
+ \begin{lstlisting}
+ In[]: f.close()
+ In[]: f
+ \end{lstlisting}
+\end{frame}
+
+\begin{frame}[fragile]
+ \frametitle{Reading line-by-line}
+ \begin{lstlisting}
+ In[]: for line in open('pendulum.txt'):
+ ....: print line
+ \end{lstlisting}
+ \begin{itemize}
+ \item The file object is an ``iterable''
+ \item We iterate over it and print each line
+ \item Instead of printing, collect lines in a list
+ \end{itemize}
+ \begin{lstlisting}
+ In[]: line_list = [ ]
+ In[]: for line in open('pendulum.txt'):
+ ....: line_list.append(line)
+ \end{lstlisting}
+\end{frame}
+
+
+\begin{frame}[fragile]
+ \frametitle{File parsing -- Problem}
+ \begin{lstlisting}
+ A;010002;ANAND R;058;037;42;35;40;212;P;;
+ \end{lstlisting}
+ \begin{itemize}
+ \item File with records like the one above is given
+ \item Each record has fields separated by ;
+ \item region code; roll number; name;
+ \item marks --- $1^{st}$ L; $2^{nd}$ L; math; science; social; total
+ \item pass/fail indicated by P/F; W if withheld and else empty
+ \end{itemize}
+
+ \begin{itemize}
+ \item We wish to calculate mean of math marks in region B
+ \end{itemize}
+\end{frame}
+
+\begin{frame}[fragile]
+ \frametitle{Tokenization}
+ \begin{lstlisting}
+ In[]: line = "parse this string"
+ In[]: line.split()
+ \end{lstlisting}
+ \begin{itemize}
+ \item Original string is split on white-space (if no argument)
+ \item Returns a list of strings
+ \item It can be given an argument to split on that argrument
+ \end{itemize}
+ \begin{lstlisting}
+ In[]: record = "A;015163;JOSEPH RAJ S;083;042;47;AA;72;244;;;"
+ In[]: record.split(';')
+ \end{lstlisting}
+\end{frame}
+
+\begin{frame}[fragile]
+ \frametitle{Tokenization \ldots}
+ \begin{itemize}
+ \item Since we split on commas, fields may have extra spaces at ends
+ \item We can strip out the spaces at the ends
+ \end{itemize}
+ \begin{lstlisting}
+ In[]: word = " B "
+ In[]: word.strip()
+ \end{lstlisting}
+ \begin{itemize}
+ \item \texttt{strip} is returning a new string
+ \end{itemize}
+\end{frame}
+
+\begin{frame}[fragile]
+ \frametitle{\texttt{str} to \texttt{float}}
+ \begin{itemize}
+ \item After tokenizing, the marks we have are strings
+ \item We need numbers to perform math operations
+ \end{itemize}
+ \begin{lstlisting}
+ In[]: mark_str = "1.25"
+ In[]: mark = int(mark_str)
+ In[]: type(mark_str)
+ In[]: type(mark)
+ \end{lstlisting}
+ \begin{itemize}
+ \item \texttt{strip} is returning a new string
+ \end{itemize}
+\end{frame}
+
+\begin{frame}[fragile]
+ \frametitle{File parsing -- Solution}
+ \begin{lstlisting}
+ In[]: math_B = [] # empty list to store marks
+ In[]: for line in open("sslc1.txt"):
+ ....: fields = line.split(";")
+
+ ....: reg_code = fields[0]
+ ....: reg_code_clean = reg_code.strip()
+
+ ....: math_mark_str = fields[5]
+ ....: math_mark = float(math_mark_str)
+
+ ....: if reg_code == "B":
+ ....: math_B.append(math_mark)
+
+ In[]: math_B_mean = sum(math_B) / len(math_B)
+ In[]: math_B_mean
+ \end{lstlisting}
+\end{frame}
diff --git a/slides/basic_python/python.tex b/slides/basic_python/python.tex
new file mode 100644
index 0000000..19be639
--- /dev/null
+++ b/slides/basic_python/python.tex
@@ -0,0 +1,56 @@
+\documentclass[12pt,presentation]{beamer}
+\usepackage[utf8]{inputenc}
+\usepackage[T1]{fontenc}
+\usepackage{fixltx2e}
+\usepackage{graphicx}
+\usepackage{longtable}
+\usepackage{float}
+\usepackage{wrapfig}
+\usepackage{soul}
+\usepackage{textcomp}
+\usepackage{marvosym}
+\usepackage{wasysym}
+\usepackage{latexsym}
+\usepackage{amssymb}
+\usepackage{hyperref}
+\tolerance=1000
+\usepackage[english]{babel} \usepackage{ae,aecompl}
+\usepackage{mathpazo,courier,euler} \usepackage[scaled=.95]{helvet}
+\usepackage{listings}
+\lstset{language=Python, basicstyle=\ttfamily\bfseries,
+commentstyle=\color{red}\itshape, stringstyle=\color{green},
+showstringspaces=false, keywordstyle=\color{blue}\bfseries}
+\providecommand{\alert}[1]{\textbf{#1}}
+
+\title{Basic Python}
+\author[FOSSEE] {FOSSEE}
+\institute[IIT Bombay] {Department of Aerospace Engineering\\IIT Bombay}
+\date []{}
+
+\usetheme{Warsaw}\usecolortheme{default}\useoutertheme{infolines}\setbeamercovered{transparent}
+
+\AtBeginSection[]
+{
+ \begin{frame}<beamer>
+ \frametitle{Outline}
+ \tableofcontents[currentsection]
+ \end{frame}
+}
+
+\begin{document}
+
+\maketitle
+
+\begin{frame}
+\frametitle{Outline}
+\setcounter{tocdepth}{3}
+\tableofcontents
+\end{frame}
+
+\include{slides/intro}
+\include{slides/strings_loops_lists}
+\include{slides/io_files_parsing}
+\include{slides/func}
+\include{slides/tuples_dicts_sets}
+
+\end{document}
diff --git a/slides/basic_python/strings_loops_lists.tex b/slides/basic_python/strings_loops_lists.tex
new file mode 100644
index 0000000..26d7b54
--- /dev/null
+++ b/slides/basic_python/strings_loops_lists.tex
@@ -0,0 +1,457 @@
+\section{Strings}
+
+\begin{frame}[fragile]
+ \frametitle{What are Strings?}
+ \begin{itemize}
+ \item Anything quoted is a string
+ \item Single quotes, double quotes or triple single/double quotes
+ \item Any length --- single character, null string, \ldots
+ \end{itemize}
+ \begin{lstlisting}
+ In[]: 'This is a string'
+ In[]: "This is a string too'
+ In[]: '''This is a string as well'''
+ In[]: """This is also a string"""
+ In[]: '' # empty string
+ \end{lstlisting}
+\end{frame}
+
+\begin{frame}[fragile]
+ \frametitle{Why so many?}
+ \begin{itemize}
+ \item Reduce the need for escaping
+ \end{itemize}
+ \begin{lstlisting}
+ In[]: "Python's strings are powerful!"
+ In[]: 'He said, "I love Python!"'
+ \end{lstlisting}
+ \begin{itemize}
+ \item Triple quoted strings can be multi-line
+ \item Used for doc-strings
+ \end{itemize}
+\end{frame}
+
+\begin{frame}[fragile]
+ \frametitle{Assignment \& Operations}
+ \begin{lstlisting}
+ In[]: a = 'Hello'
+ In[]: b = 'World'
+ In[]: c = a + ', ' + b + '!'
+ \end{lstlisting}
+ \begin{itemize}
+ \item Strings can be multiplied with numbers
+ \end{itemize}
+ \begin{lstlisting}
+ In[]: a = 'Hello'
+ In[]: a * 5
+ \end{lstlisting}
+\end{frame}
+
+\begin{frame}[fragile]
+ \frametitle{Accessing Elements}
+ \begin{lstlisting}
+ In[]: print a[0], a[4], a[-1], a[-4]
+ \end{lstlisting}
+ \begin{itemize}
+ \item Can we change the elements?
+ \end{itemize}
+ \begin{lstlisting}
+ In[]: a[0] = 'H'
+ \end{lstlisting}
+ \begin{itemize}
+ \item Strings are immutable!
+ \end{itemize}
+\end{frame}
+
+\begin{frame}[fragile]
+ \frametitle{Problem - Day of the Week?}
+ \begin{itemize}
+ \item Strings have methods to manipulate them
+ \end{itemize}
+ \begin{block}{Problem}
+ Given a list, \texttt{week}, containing names of the days of the
+ week and a string \texttt{s}, check if the string is a day of the
+ week. We should be able to check for any of the forms like,
+ \emph{sat, saturday, Sat, Saturday, SAT, SATURDAY}
+ \end{block}
+ \begin{itemize}
+ \item Get the first 3 characters of the string
+ \item Convert it all to lower case
+ \item Check for existence in the list, \texttt{week}
+ \end{itemize}
+\end{frame}
+
+\begin{frame}[fragile]
+ \frametitle{Slicing}
+ \begin{lstlisting}
+ In[]: q = "Hello World"
+ In[]: q[0:3]
+ In[]: q[:3]
+ In[]: q[3:]
+ In[]: q[:]
+ In[]: q[-1:1]
+ In[]: q[1:-1]
+ \end{lstlisting}
+ \begin{itemize}
+ \item One or both of the limits, is optional
+ \end{itemize}
+\end{frame}
+
+\begin{frame}[fragile]
+ \frametitle{Striding}
+ \begin{lstlisting}
+ In[]: q[0:5:1]
+ In[]: q[0:5:2]
+ In[]: q[0:5:3]
+ In[]: q[0::2]
+ In[]: q[2::2]
+ In[]: q[::2]
+ In[]: q[5:0:-1]
+ In[]: q[::-1]
+ \end{lstlisting}
+\end{frame}
+
+\begin{frame}[fragile]
+ \frametitle{String Methods}
+ \begin{lstlisting}
+ In[]: s.lower()
+ In[]: s.upper()
+ s.<TAB>
+ \end{lstlisting}
+ \begin{itemize}
+ \item \alert{Strings are immutable!}
+ \item A new string is being returned
+ \end{itemize}
+\end{frame}
+
+\begin{frame}[fragile]
+ \frametitle{Solution - Day of the Week?}
+ \begin{lstlisting}
+ In[]: s.lower()[:3] in week
+ \end{lstlisting}
+ OR
+ \begin{lstlisting}
+ In[]: s[:3].lower() in week
+ \end{lstlisting}
+\end{frame}
+
+\begin{frame}[fragile]
+ \frametitle{\texttt{join} a list of strings}
+ \begin{itemize}
+ \item Given a list of strings
+ \item We wish to join them into a single string
+ \item Possibly, each string separated by a common token
+ \end{itemize}
+ \begin{lstlisting}
+ In[]: email_list = ["info@fossee.in",
+ "enquiries@fossee.in",
+ "help@fossee.in"]
+ \end{lstlisting}
+ \begin{lstlisting}
+ In[]: '; '.join(email_list)
+ In[]: ', '.join(email_list)
+ \end{lstlisting}
+\end{frame}
+
+\section{Conditionals}
+
+\begin{frame}[fragile]
+ \frametitle{\texttt{if-else} block}
+ \begin{lstlisting}
+ In[]: a = 5
+ In[]: if a % 2 == 0:
+ ....: print "Even"
+ ....: else:
+ ....: print "Odd"
+ \end{lstlisting}
+ \begin{itemize}
+ \item A code block -- \texttt{:} and indentation
+ \item Exactly one block gets executed in the \texttt{if-else}
+ \end{itemize}
+\end{frame}
+
+
+\begin{frame}[fragile]
+ \frametitle{\texttt{if-elif-else}}
+ \begin{lstlisting}
+ In[]: if a > 0:
+ ....: print "positive"
+ ....: elif a < 0:
+ ....: print "negative"
+ ....: else:
+ ....: print "zero"
+ \end{lstlisting}
+ \begin{itemize}
+ \item Only one block gets executed, depending on \texttt{a}
+ \end{itemize}
+\end{frame}
+
+\begin{frame}[fragile]
+ \frametitle{\texttt{else} is optional}
+ \begin{lstlisting}
+ In[]: if user == 'admin':
+ ....: admin_Operations()
+ ....: elif user == 'moderator':
+ ....: moderator_operations()
+ ....: elif user == 'client':
+ ....: customer_operations()
+ \end{lstlisting}
+ \begin{itemize}
+ \item Note that there is no \texttt{else} block
+ \end{itemize}
+\end{frame}
+
+\begin{frame}[fragile]
+ \frametitle{Ternary operator}
+ \begin{itemize}
+ \item \texttt{score\_str} is either \texttt{'AA'} or a string of one
+ of the numbers in the range 0 to 100.
+ \item We wish to convert the string to a number using \texttt{int}
+ \item Convert it to 0, when it is \texttt{'AA'}
+ \item \texttt{if-else} construct or the ternary operator
+ \end{itemize}
+ \begin{lstlisting}
+ In[]: if score_str != 'AA':
+ ....: score = int(score_str)
+ ....: else:
+ ....: score = 0
+ \end{lstlisting}
+ \begin{lstlisting}
+ In[]: ss = score_str
+ In[]: score = int(ss) if ss != 'AA' else 0
+ \end{lstlisting}
+\end{frame}
+
+
+\begin{frame}[fragile]
+ \frametitle{\texttt{pass}}
+ \begin{itemize}
+ \item \texttt{pass} is a syntactic filler
+ \item When a certain block has no statements, a \texttt{pass} is
+ thrown in
+ \item Mostly, when you want to get back to that part, later.
+ \end{itemize}
+\end{frame}
+
+\section{Loops}
+
+\begin{frame}[fragile]
+ \frametitle{\texttt{while}}
+ \begin{itemize}
+ \item Print squares of all odd numbers less than 10 using
+ \texttt{while}
+ \end{itemize}
+ \begin{lstlisting}
+ In[]: i = 1
+
+ In[]: while i<10:
+ ....: print i*i
+ ....: i += 2
+ \end{lstlisting}
+ \begin{itemize}
+ \item The loops runs as long as the condition is \texttt{True}
+ \end{itemize}
+\end{frame}
+
+\begin{frame}[fragile]
+ \frametitle{\texttt{for}}
+ \begin{itemize}
+ \item Print squares of all odd numbers less than 10 using
+ \texttt{for}
+ \end{itemize}
+ \begin{lstlisting}
+ In[]: for n in [1, 2, 3]:
+ ....: print n
+ \end{lstlisting}
+ \begin{itemize}
+ \item \texttt{for} iterates over each element of a sequence
+ \end{itemize}
+ \begin{lstlisting}
+ In[]: for n in [1, 3, 5, 7, 9]:
+ ....: print n*n
+
+ In[]: for n in range(1, 10, 2):
+ ....: print n*n
+ \end{lstlisting}
+ \begin{itemize}
+ \item \alert{range([start,] stop[, step])}
+ \item Returns a list; Stop value is not included.
+ \end{itemize}
+\end{frame}
+
+
+\begin{frame}[fragile]
+ \frametitle{\texttt{break}}
+ \begin{itemize}
+ \item breaks out of the innermost loop.
+ \item Squares of odd numbers below 10 using \texttt{while} \&
+ \texttt{break}
+ \end{itemize}
+ \begin{lstlisting}
+ In[]: i = 1
+
+ In[]: while True:
+ ....: print i*i
+ ....: i += 2
+ ....: if i>10:
+ ....: break
+ \end{lstlisting}
+\end{frame}
+
+\begin{frame}[fragile]
+ \frametitle{\texttt{continue}}
+ \begin{itemize}
+ \item Skips execution of rest of the loop on current iteration
+ \item Jumps to the end of this iteration
+ \item Squares of all odd numbers below 10, not multiples of 3
+ \end{itemize}
+ \begin{lstlisting}
+ In[]: for n in range(1, 10, 2):
+ ....: if n%3 == 0:
+ ....: continue
+ ....: print n*n
+ \end{lstlisting}
+\end{frame}
+
+
+\section{Lists}
+
+\begin{frame}[fragile]
+ \frametitle{Creating Lists}
+ \begin{lstlisting}
+ In[]: empty = []
+
+ In[]: p = ['spam', 'eggs', 100, 1.234]
+ In[]: q = [[4, 2, 3, 4], 'and', 1, 2, 3, 4]
+ \end{lstlisting}
+ \begin{itemize}
+ \item Lists can be empty, with no elements in them
+ \item Lists can be heterogeneous -- every element of different kind
+ \end{itemize}
+\end{frame}
+
+\begin{frame}[fragile]
+ \frametitle{Accessing Elements}
+ \begin{lstlisting}
+ In[]: print p[0], p[1], p[3]
+
+ In[]: print p[-1], p[-2], p[-4]
+ In[]: print p[10]
+ \end{lstlisting}
+ \begin{itemize}
+ \item Indexing starts from 0
+ \item Indexes can be negative
+ \item Indexes should be in the valid range
+ \end{itemize}
+\end{frame}
+
+\begin{frame}[fragile]
+ \frametitle{Accessing Elements \& length}
+ \begin{lstlisting}
+ In[]: print p[0], p[1], p[3]
+
+ In[]: print p[-1], p[-2], p[-4]
+ In[]: print len(p)
+ In[]: print p[10]
+ \end{lstlisting}
+ \begin{itemize}
+ \item Indexing starts from 0
+ \item Indexes can be negative
+ \item Indexes should be within the \texttt{range(0, len(p))}
+ \end{itemize}
+\end{frame}
+
+
+\begin{frame}[fragile]
+ \frametitle{Adding \& Removing Elements}
+ \begin{itemize}
+ \item The append method adds elements to the end of the list
+ \end{itemize}
+ \begin{lstlisting}
+ In[]: p.append('onemore')
+ In[]: p
+ In[]: p.append([1, 6])
+ In[]: p
+ \end{lstlisting}
+ \begin{itemize}
+ \item Elements can be removed based on their index OR
+ \item based on the value of the element
+ \end{itemize}
+ \begin{lstlisting}
+ In[]: del p[1]
+ In[]: p.remove(100)
+ \end{lstlisting}
+ \begin{itemize}
+ \item \alert{When removing by value, first element is removed}
+ \end{itemize}
+\end{frame}
+
+
+\begin{frame}[fragile]
+ \frametitle{Concatenating lists}
+ \begin{lstlisting}
+ In[]: a = [1, 2, 3, 4]
+ In[]: b = [4, 5, 6, 7]
+ In[]: a + b
+ In[]: print a+b, a, b
+ \end{lstlisting}
+ \begin{itemize}
+ \item A new list is returned; None of the original lists change
+ \end{itemize}
+ \begin{lstlisting}
+ In[]: c = a + b
+ In[]: c
+ \end{lstlisting}
+\end{frame}
+
+\begin{frame}[fragile]
+ \frametitle{Slicing \& Striding}
+ \begin{lstlisting}
+ In[]: primes = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29]
+ In[]: primes[4:8]
+ In[]: primes[:4]
+
+ In[]: num = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13]
+ In[]: num[1:10:2]
+ In[]: num[:10]
+ In[]: num[10:]
+ In[]: num[::2]
+ In[]: num[::-1]
+ \end{lstlisting}
+\end{frame}
+
+\begin{frame}[fragile]
+ \frametitle{Sorting}
+ \begin{lstlisting}
+ In[]: a = [5, 1, 6, 7, 7, 10]
+ In[]: a.sort()
+ In[]: a
+ \end{lstlisting}
+ \begin{itemize}
+ \item \texttt{sort} method sorts the list in-place
+ \item Use \texttt{sorted} if you require a new list
+ \end{itemize}
+ \begin{lstlisting}
+ In[]: a = [5, 1, 6, 7, 7, 10]
+ In[]: sorted(a)
+ In[]: a
+ \end{lstlisting}
+\end{frame}
+
+\begin{frame}[fragile]
+ \frametitle{Reversing}
+ \begin{lstlisting}
+ In[]: a = [5, 1, 6, 7, 7, 10]
+ In[]: a.reverse()
+ In[]: a
+ \end{lstlisting}
+ \begin{itemize}
+ \item \texttt{reverse} method reverses the list in-place
+ \item Use \texttt{[::-1]} if you require a new list
+ \end{itemize}
+ \begin{lstlisting}
+ In[]: a = [5, 1, 6, 7, 7, 10]
+ In[]: a[::-1]
+ In[]: a
+ \end{lstlisting}
+\end{frame}
diff --git a/slides/basic_python/tmp.tex b/slides/basic_python/tmp.tex
new file mode 100644
index 0000000..8b13789
--- /dev/null
+++ b/slides/basic_python/tmp.tex
@@ -0,0 +1 @@
+
diff --git a/slides/basic_python/tuples_dicts_sets.tex b/slides/basic_python/tuples_dicts_sets.tex
new file mode 100644
index 0000000..b09fd99
--- /dev/null
+++ b/slides/basic_python/tuples_dicts_sets.tex
@@ -0,0 +1,258 @@
+\section{Tuples}
+
+\begin{frame}[fragile]
+ \frametitle{Tuples -- Initialization}
+ \begin{lstlisting}
+ In[]: t = (1, 2.5, "hello", -4, "world", 1.24, 5)
+ In[]: t
+ \end{lstlisting}
+ \begin{itemize}
+ \item It is not always necessary to use parenthesis
+ \end{itemize}
+ \begin{lstlisting}
+ In[]: a = 1, 2, 3
+ In[]: b = 1,
+ \end{lstlisting}
+\end{frame}
+
+\begin{frame}[fragile]
+ \frametitle{Indexing}
+ \begin{lstlisting}
+ In[]: t[3]
+ In[]: t[1:5:2]
+ In[]: t[2] = "Hello"
+ \end{lstlisting}
+ \begin{itemize}
+ \item \alert{Tuples are immutable!}
+ \end{itemize}
+\end{frame}
+
+\begin{frame}[fragile]
+ \frametitle{Swapping values}
+ \begin{lstlisting}
+ In[]: a = 5
+ In[]: b = 7
+
+ In[]: temp = a
+ In[]: a = b
+ In[]: b = temp
+ \end{lstlisting}
+ \begin{itemize}
+ \item Here's the Pythonic way of doing it
+ \end{itemize}
+ \begin{lstlisting}
+ In[]: a, b = b, a
+ \end{lstlisting}
+ \begin{itemize}
+ \item The variables can be of different data-types
+ \end{itemize}
+ \begin{lstlisting}
+ In[]: a = 2.5
+ In[]: b = "hello"
+ In[]: a, b = b, a
+ \end{lstlisting}
+\end{frame}
+
+\begin{frame}[fragile]
+ \frametitle{Tuple packing \& unpacking}
+ \begin{lstlisting}
+ In[]: 5,
+
+ In[]: 5, "hello", 2.5
+ \end{lstlisting}
+ \begin{itemize}
+ \item Tuple packing and unpacking, when swapping
+ \end{itemize}
+ \begin{lstlisting}
+ In[]: a, b = b, a
+ \end{lstlisting}
+\end{frame}
+
+\section{Dictionaries}
+
+\begin{frame}[fragile]
+ \frametitle{Creating Dictionaries}
+ \begin{lstlisting}
+ In[]: mt_dict = {}
+
+ In[]: extensions = {'jpg' : 'JPEG Image',
+ 'py' : 'Python script',
+ 'html' : 'Html document',
+ 'pdf' : 'Portable Document Format'}
+
+ In[]: extensions
+ \end{lstlisting}
+ \begin{itemize}
+ \item Key-Value pairs
+ \item \alert{ No ordering of keys! }
+ \end{itemize}
+\end{frame}
+
+\begin{frame}[fragile]
+ \frametitle{Accessing Elements}
+ \begin{lstlisting}
+ In[]: print extensions['jpg']
+ \end{lstlisting}
+ \begin{itemize}
+ \item Values can be accessed using keys
+ \end{itemize}
+ \begin{lstlisting}
+ In[]: print extensions['zip']
+ \end{lstlisting}
+ \begin{itemize}
+ \item Values of non-existent keys cannot, obviously, be accessed
+ \end{itemize}
+\end{frame}
+
+\begin{frame}[fragile]
+ \frametitle{Adding \& Removing Elements}
+ \begin{itemize}
+ \item Adding a new key-value pair
+ \end{itemize}
+ \begin{lstlisting}
+ In[]: extensions['cpp'] = 'C++ code'
+ In[]: extensions
+ \end{lstlisting}
+ \begin{itemize}
+ \item Deleting a key-value pair
+ \end{itemize}
+ \begin{lstlisting}
+ In[]: del extension['pdf']
+ In[]: extensions
+ \end{lstlisting}
+ \begin{itemize}
+ \item Assigning to existing key, modifies the value
+ \end{itemize}
+ \begin{lstlisting}
+ In[]: extensions['cpp'] = 'C++ source code'
+ In[]: extensions
+ \end{lstlisting}
+\end{frame}
+
+\begin{frame}[fragile]
+ \frametitle{Containership}
+ \begin{lstlisting}
+ In[]: 'py' in extensions
+ In[]: 'odt' in extensions
+ \end{lstlisting}
+ \begin{itemize}
+ \item Allow checking for container-ship of keys; NOT values
+ \item Use the \texttt{in} keyword to check for container-ship
+ \end{itemize}
+\end{frame}
+
+\begin{frame}[fragile]
+ \frametitle{Lists of Keys and Values}
+ \begin{lstlisting}
+ In[]: extensions.keys()
+ In[]: extensions.values()
+ \end{lstlisting}
+ \begin{itemize}
+ \item Note that the order of the keys and values match
+ \item That can be relied upon and used
+ \end{itemize}
+ \begin{lstlisting}
+ In[]: for each in extensions.keys():
+ ....: print each, "-->", extensions[each]
+ ....:
+ \end{lstlisting}
+\end{frame}
+
+\section{Sets}
+
+\begin{frame}[fragile]
+ \frametitle{Creating Sets}
+ \begin{lstlisting}
+ In[]: a_list = [1, 2, 1, 4, 5, 6, 2]
+ In[]: a = set(a_list)
+ In[]: a
+ \end{lstlisting}
+ \begin{itemize}
+ \item Conceptually identical to the sets in mathematics
+ \item Duplicate elements not allowed
+ \item No ordering of elements exists
+ \end{itemize}
+\end{frame}
+
+\begin{frame}[fragile]
+ \frametitle{Operations on Sets}
+ \begin{lstlisting}
+ In[]: f10 = set([1, 2, 3, 5, 8])
+ In[]: p10 = set([2, 3, 5, 7])
+ \end{lstlisting}
+ \begin{itemize}
+ \item Mathematical operations performed on sets, can be performed
+ \end{itemize}
+ \begin{itemize}
+ \item Union
+ \begin{lstlisting}
+ In[]: f10 | p10
+ \end{lstlisting}
+ \item Intersection
+ \begin{lstlisting}
+ In[]: f10 & p10
+ \end{lstlisting}
+ \item Difference
+ \begin{lstlisting}
+ In[]: f10 - p10
+ \end{lstlisting}
+ \item Symmetric Difference
+ \begin{lstlisting}
+ In[]: f10 ^ p10
+ \end{lstlisting}
+ \end{itemize}
+\end{frame}
+
+\begin{frame}[fragile]
+ \frametitle{Sub-sets}
+ \begin{itemize}
+ \item Proper Subset
+ \begin{lstlisting}
+ In[]: b = set([1, 2])
+ In[]: b < f10
+ \end{lstlisting}
+ \item Subsets
+ \begin{lstlisting}
+ In[]: f10 <= f10
+ \end{lstlisting}
+ \end{itemize}
+\end{frame}
+
+\begin{frame}[fragile]
+ \frametitle{Elements of sets}
+ \begin{itemize}
+ \item Containership
+ \begin{lstlisting}
+ In[]: 1 in f10
+ In[]: 4 in f10
+ \end{lstlisting}
+ \item Iterating over elements
+ \begin{lstlisting}
+ In[]: for i in f10:
+ ....: print i,
+ ....:
+ \end{lstlisting}
+ \item Subsets
+ \begin{lstlisting}
+ In[]: f10 <= f10
+ \end{lstlisting}
+ \end{itemize}
+\end{frame}
+
+\begin{frame}[fragile]
+ \frametitle{Sets -- Example}
+ \begin{block}{}
+ Given a list of marks, \texttt{[20, 23, 22, 23, 20, 21, 23]} list
+ all the duplicates
+ \end{block}
+ \begin{lstlisting}
+ In[]: marks = [20, 23, 22, 23, 20, 21, 23]
+ In[]: marks_set = set(marks)
+ In[]: for mark in marks_set:
+ ....: marks.remove(mark)
+
+ # left with only duplicates
+ In[]: duplicates = set(marks)
+ \end{lstlisting}
+\end{frame}
+
generated by cgit (git 2.34.1) at 2025-03-13 09:50:35 +0000