4 % Author: Prabhu Ramachandran <prabhu at aero.iitb.ac.in>

     4 % Author: FOSSEE 

     5 % Copyright (c) 2005-2009, Prabhu Ramachandran

     5 % Copyright (c) 2009, FOSSEE, IIT Bombay

    81 \date[] {1, November 2009\\Day 2, Session 1}

    81 \date[] {8 November, 2009\\Day 2, Session 1}

   143 In [1]: a = 13

   143 In []: a = 13

   144 

   144 

   145 In [2]: b = 99999999999999999999

   145 In []: b = 99999999999999999999

   149 In [3]: fl = 3.141592

   149 In []: p = 3.141592

   157 In [1]: cplx = 3+4j

   157 In []: c = 3+4j

   158 

   158 

   159 In [2]: abs(cplx)

   159 In []: abs(c)

   160 Out[2]: 5.0

   160 Out[]: 5.0

   161 

   161 

   162 In [3]: cplx.imag

   162 In []: c.imag

   163 Out[3]: 4.0

   163 Out[]: 4.0

   164 

   164 

   165 In [4]: cplx.real

   165 In []: c.real

   166 Out[4]: 3.0

   166 Out[]: 3.0

   174 In [1]: t = True

   174 In []: t = True

   175 

   175 

   176 In [2]: f = not t

   176 In []: f = not t

   177 Out[2]: False

   177 

   178 

   178 In []: f or t

   179 In [3]: f or t

   179 Out[]: True

   180 Out[3]: True

   180 

   181 

   181 In []: f and t

   182 In [4]: f and t

   182 Out[]: False

   183 Out[4]: False

   183   \end{lstlisting}

   184   \inctime{5}

   185 \end{frame}

   186 

   187 \begin{frame}[fragile]

   188   \frametitle{( )  for precedence}

   189   \begin{lstlisting}

   190 In []: a = False

   191 In []: b = True

   192 In []: c = True

   193 

   194 In []: (a and b) or c

   195 Out[]: True

   196 

   197 In []: a and (b or c)

   198 Out[]: False

   194 In [1]: w = "hello"

   209 In []: w = "hello"

   195 

   210 

   196 In [2]: print w[0] + w[2] + w[-1]

   211 In []: print w[0] + w[2] + w[-1]

   197 Out[2]: hlo

   212 Out[]: hlo

   198 

   213 

   199 In [3]: len(w) # guess what

   214 In []: len(w) # guess what

   200 Out[3]: 5

   215 Out[]: 5

   207 In [1]: w[0] = 'H' # Can't do that!

   222 In []: w[0] = 'H' # Can't do that!

   221 In [1]: a = 'Hello World'

   236 In []: a = 'Hello World'

   222 In [2]: a.startswith('Hell')

   237 In []: a.startswith('Hell')

   223 Out[2]: True

   238 Out[]: True

   224 

   239 

   225 In [3]: a.endswith('ld')

   240 In []: a.endswith('ld')

   226 Out[3]: True

   241 Out[]: True

   227 

   242 

   228 In [4]: a.upper()

   243 In []: a.upper()

   229 Out[4]: 'HELLO WORLD'

   244 Out[]: 'HELLO WORLD'

   230 

   245 

   231 In [5]: a.lower()

   246 In []: a.lower()

   232 Out[5]: 'hello world'

   247 Out[]: 'hello world'

   233   \end{lstlisting}

   248   \end{lstlisting}

   249 \end{frame}

   250 

   251 \begin{frame}

   252   \frametitle{A bit about IPython}

   253   \begin{itemize}

   254     \item IPython provides better help

   255     \item object.function?

   256     \begin{lstlisting}

   257 In []: a = 'Hello World'

   258 In []: a.lower?

   259     \end{lstlisting}

   260     \item It provides tab completion

   261         \begin{lstlisting}

   262 In []: a.s<Tab>

   263     \end{lstlisting}

   264   \end{itemize}

   243 In [1]: ''.join(['a', 'b', 'c'])

   274 In []: ''.join(['a', 'b', 'c'])

   244 Out[1]: 'abc'

   275 Out[]: 'abc'

   251 In [1]: x, y = 1, 1.234

   282 In []: x, y = 1, 1.234

   252 

   283 

   253 In [2]: 'x is %s, y is %s' %(x, y)

   284 In []: 'x is %s, y is %s' %(x, y)

   254 Out[2]: 'x is 1, y is 1.234'

   285 Out[]: 'x is 1, y is 1.234'

   255   \end{lstlisting}

   286   \end{lstlisting}

   287   \begin{itemize}

   288     \item \emph{\%d}, \emph{\%f} etc. available

   289   \end{itemize}

   262   \frametitle{Arithematic operators}

   296   \frametitle{Arithmetic operators}

   263   \begin{lstlisting}

   297   \begin{lstlisting}

   264 In [1]: 1786 % 12

   298 In []: 1786 % 12

   265 Out[1]: 10

   299 Out[]: 10

   266 

   300 

   267 In [2]: 3124 * 126789

   301 In []: 45 % 2

   268 Out[2]: 396088836

   302 Out[]: 1

   269 

   303 

   270 In [3]: a = 3124 * 126789

   304 In []: 864675 % 10

   271 

   305 Out[]: 5

   272 In [4]: big = 1234567891234567890 ** 3

   306 

   273 

   307 In []: 3124 * 126789

   274 In [5]: verybig = big * big * big * big

   308 Out[]: 396088836

   275   \end{lstlisting}

   309 

   276 \end{frame}

   310 In []: big = 1234567891234567890 ** 3

   277 

   311 

   278 \begin{frame}[fragile]

   312 In []: verybig = big * big * big * big

   279   \frametitle{Arithematic operators \ldots}

   313   \end{lstlisting}

   280   \begin{lstlisting}

   314 \end{frame}

   281 In [1]: 17/2

   315 

   282 Out[1]: 8

   316 \begin{frame}[fragile]

   283 

   317   \frametitle{Arithmetic operators}

   284 In [2]: 17/2.0

   318   \begin{lstlisting}

   285 Out[2]: 8.5

   319 In []: 17 / 2

   286 

   320 Out[]: 8

   287 In [3]: 17.0/2

   321 

   288 Out[3]: 8.5

   322 In []: 17 / 2.0

   289 

   323 Out[]: 8.5

   290 In [4]: 17.0/8.5

   324 

   291 Out[4]: 2.0

   325 In []: 17.0 / 2

   326 Out[]: 8.5

   327 

   328 In []: 17.0 / 8.5

   329 Out[]: 2.0

   330   \end{lstlisting}

   331 \end{frame}

   332 

   333 \begin{frame}[fragile]

   334   \frametitle{Arithmetic operators}

   335   \begin{lstlisting}

   336 In []: a = 7546

   337 

   338 In []: a += 1

   339 In []: a

   340 Out[]: 7547

   341 

   342 In []: a -= 5

   343 In []: a

   344 

   345 In []: a *= 2

   346 

   347 In []: a /= 5

   298 In [1]: s = 'Hello '

   354 In []: s = 'Hello '

   299 

   355 

   300 In [2]: p = 'World'

   356 In []: p = 'World'

   301 

   357 

   302 In [3]: s + p 

   358 In []: s + p 

   303 Out[3]: 'Hello World'

   359 Out[]: 'Hello World'

   304 

   360 

   305 In [4]: s * 4

   361 In []: s * 4

   306 Out[4]: 'Hello Hello Hello Hello'

   362 Out[]: 'Hello Hello Hello Hello'

   313 In [1]: s * s

   369 In []: s * s

   327 In [1]: pos, zer, neg = 1, 0, -1

   383 In []: p, z, n = 1, 0, -1

   328 In [2]: pos == neg

   384 In []: p == n

   329 Out[2]: False

   385 Out[]: False

   330 

   386 

   331 In [3]: pos >= neg

   387 In []: p >= n

   332 Out[3]: True

   388 Out[]: True

   333 

   389 

   334 In [4]: neg < zer < pos

   390 In []: n < z < p

   335 Out[4]: True

   391 Out[]: True

   336 

   392 

   337 In [5]: pos + neg != zer

   393 In []: p + n != z

   338 Out[5]: False

   394 Out[]: False

   345 In [1]: int(17/2.0)

   401 In []: int(17 / 2.0)

   346 Out[1]: 8

   402 Out[]: 8

   347 

   403 

   348 In [2]: float(17/2)  # Recall

   404 In []: float(17 / 2)  # Recall

   349 Out[2]: 8.0

   405 Out[]: 8.0

   350 

   406 

   351 In [3]: str(17/2.0)

   407 In []: str(17 / 2.0)

   352 Out[3]: '8.5'

   408 Out[]: '8.5'

   353 

   409 

   354 In [4]: round( 7.5 )

   410 In []: round( 7.5 )

   355 Out[4]: 8.0

   411 Out[]: 8.0

   365 In [1]: a = 1

   421 In []: a = 1

   366 In [2]: a = 1.1

   422 In []: a = 1.1

   367 In [3]: a = "Now I am a string!"

   423 In []: a = "Now I am a string!"

   371 In [4]: a = 1  # In-line comments

   427 In []: a = 1  # In-line comments

   372 In [5]: # A comment line.

   428 In []: # A comment line.

   373 In [6]: a = "# Not a comment!"

   429 In []: a = "# Not a comment!"

   385 In [1]: a = raw_input()

   442 In []: a = raw_input()

   388 In [2]: a = raw_input('prompt > ')

   445 In []: a = raw_input('Enter a value: ')

   389 prompt > 5

   446 Enter a value: 5

   397 \begin{frame}{Simple IO: Console output}

   454 \begin{frame}[fragile]

   455   \frametitle{Simple IO: Console output}

   400     \item Note the distinction between \texttt{print x} and \texttt{print x,}

   458     \item Put the following code snippet in a file

   401   \end{itemize}

   459   \end{itemize}

   460   \begin{lstlisting}

   461 print "Hello"

   462 print "World"

   463 

   464 

   465 In []: %run -i hello1.py

   466 Hello

   467 World

   468   \end{lstlisting}

   469 \end{frame}

   470 

   471 \begin{frame}[fragile]

   472   \frametitle{Simple IO: Console output \ldots}

   473 Put the following code snippet in a file

   474   \begin{lstlisting}

   475 print "Hello",

   476 print "World"

   477 

   478 

   479 In []: %run -i hello2.py

   480 Hello World

   481   \end{lstlisting}

   482 

   483 \emphbar{Note the distinction between \texttt{print x} and \texttt{print x,}}

   410   \item \kwrd{for}: iterating 

   493   \item \kwrd{for}: iterating

   419   \begin{lstlisting}

   502   \small

   420 x = int(raw_input("Enter an integer:"))

   503   \begin{lstlisting}

   421 if x < 0:

   504 In []: x = int(raw_input("Enter an integer:"))

   422      print 'Be positive!'

   505 

   423 elif x == 0:

   506 In []: if x < 0:

   424      print 'Zero'

   507   ...:     print 'Be positive!'

   425 elif x == 1:

   508   ...: elif x == 0:

   426      print 'Single'

   509   ...:     print 'Zero'

   427 else:

   510   ...: elif x == 1:

   428      print 'More'

   511   ...:     print 'Single'

   512   ...: else:

   513   ...:     print 'More'

   514   ...:

   515   ...:

   433 \subsection{Basic Looping}

   520 \begin{frame}[fragile]

   434 \begin{frame}[fragile]

   521   \frametitle{Ternary conditional operator}

   435   \frametitle{\typ{while}}

   522   \begin{lstlisting}

   436 Example: Fibonacci series

   523 ...

   437   \begin{lstlisting}

   524 a = raw_input('Enter number(Q to quit):')

   438 # the sum of two elements

   525 num = int(a) if a != 'Q' else break

   439 # defines the next

   526 ...

   440 a, b = 0, 1

   527   \end{lstlisting}

   441 while b < 10:

   442     print b,

   443     a, b = b, a + b 

   444 \end{lstlisting}

   445 \typ{1 1 2 3 5 8}\\  

   446 \end{frame}

   447 

   448 \begin{frame}[fragile]

   449 \frametitle{\typ{range()}}

   450 \kwrd{range([start,] stop[, step])}\\

   451 \begin{itemize}

   452   \item range() returns a list of integers

   453   \item The \emph{start} and the \emph{step} arguments are optional

   454   \item \emph{stop} argument is not included in the list

   455 \end{itemize}

   456 \end{frame}

   457 

   458 \begin{frame}[fragile]

   459   \frametitle{\typ{for} \ldots \typ{range()}}

   460 Example: print squares of first \typ{n} numbers

   461   \begin{lstlisting}

   462 In []: for i in range(5):

   463  ....:     print i, i * i

   464  ....:

   465  ....:

   466 0 0

   467 1 1

   468 2 4

   469 3 9

   470 4 16

   471 \end{lstlisting}

   472 \inctime{5}

   473 \end{frame}

   474 

   475 \subsection{Exercises}

   476 

   477 \begin{frame}{Problem set 1: Problem 1.1}

   478   Write a program that displays all three digit numbers that are equal to the sum of the cubes of their digits. That is, print numbers $abc$ that have the property $abc = a^3 + b^3 + c^3$\\

   479 \vspace*{0.2in}

   480 \emphbar{These are called $Armstrong$ numbers.}

   481 \end{frame}

   482 

   483 \begin{frame}{Problem 1.2 - Collatz sequence}

   484 \begin{enumerate}

   485   \item Start with an arbitrary (positive) integer. 

   486   \item If the number is even, divide by 2; if the number is odd, multiply by 3 and add 1.

   487   \item Repeat the procedure with the new number.

   488   \item It appears that for all starting values there is a cycle of 4, 2, 1 at which the procedure loops.

   489 \end{enumerate}

   490     Write a program that accepts the starting value and prints out the Collatz sequence.

   491 \end{frame}

   492 

   493 \begin{frame}[fragile]{Problem 1.3}

   494   Write a program that prints the following pyramid on the screen. 

   495   \begin{lstlisting}

   496 1

   497 2  2

   498 3  3  3

   499 4  4  4  4

   500   \end{lstlisting}

   501 The number of lines must be obtained from the user as input.\\

   502 \pause

   503 \emphbar{When can your code fail?}

   504 \inctime{5}

   510     \item Basic data types

   533     \item Data types: int, float, complex, boolean, string

   511     \item Operators

   534     \item Operators: +, -, *, /, \%, **, +=, -=, *=, /=, >, <, <=, >=, ==, !=, a < b < c

   512     \item Conditional structures

   535     \item Simple IO: \kwrd{raw\_input} and \kwrd{print}

   513     \item Loops

   536     \item Conditional structures: \kwrd{if/elif/else},\\ \kwrd{C if X else Y}