.. #. basic datatypes

.. Author : Amit

External Reviewer :

Checklist OK? : <put date stamp here, if OK> [2010-10-05]

Script

------

Hello friends and welcome to the tutorial on getting started with

lists.

{{{ Show the slide containing the outline slide }}}

In this tutorial we will be getting acquainted with a python data

* Structure of lists

* Access list elements

* Append elements to lists

List is a compound data type, it can contain data of other data

types. List is also a sequence data type, all the elements are in

order and there order has a meaning.

We will first create an empty list with no elements. On your IPython

shell type ::

This is an empty list without any elements.

Thus the simplest way of creating a list is typing out a sequence

of comma-separated values (items) between square brackets.

As we can see lists can contain different kinds of data. In the

integer and float. Thus we can put elements of heterogenous types in

lists. Thus list themselves can be one of the element types possible

list_in_list=[[4,2,3,4],'and', 1, 2, 3, 4]

nonempty[0]

nonempty[1]

nonempty[3]

We can also access the elememts from the end using negative indices ::

nonempty[-1]

nonempty[-2]

nonempty[-4]

We can append elements to the end of a list using append command. ::

As we can see non empty appends 'onemore' and 6 at the end.

Using len function we can check the number of elements in the list

len(nonempty)

deletes the element at index 1, i.e the second element of the

list, 'eggs'. The other way is removing element by content. Lets say

one wishes to delete 100 from nonempty list the syntax of the command

experiment. ::

nonempty.append('python')

nonempty.remove('python')

nonempty

thus remove removes the first occurence of the element in the sequence

and leaves others untouched.

{{{Slide for Summary }}}

This tutorial was created as a part of FOSSEE project.

Thank You

* Author : Amit Sethi

* First Reviewer :

* Second Reviewer : Nishanth

\usepackage[latin1]{inputenc}

\usepackage[T1]{fontenc}

\begin{frame}

\end{frame}

\end{frame}

\end{document}

Hello friends. Welcome to this spoken tutorial on Manipulating Lists.

{{{ Show the slide containing the outline }}}

We have already learnt a lot about Lists in Python. In this tutorial,

we will learn more about advanced features of Lists in Python. We will

{{{ Shift to terminal and start ipython }}}

We already know what Lists are in Python, how to access individual

elements in the list and some of the functions that can be run on the

We already know how to access individual elements in a List. But what

if we have a scenario where we need to get a part of the entire list

was the element with the index 4 was included but 23 which was the

element with index 8 was excluded.

Generalizing, we can obtain a slice of the list "p" from the index

"start" upto the index "end" but excluding "end" with the following

syntax

num = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13]

If we want to obtain all the odd numbers less than 10 from the list

steps of 2::

num[1:10:2]

default values for start and stop indices as well. If we don't specify

the start index it is implicitly taken as the first element of the

list::

gives us all the even numbers in the list "num".

The other basic operation that we can perform on list is concatenation

of two or more lists. We can combine two lists by using the "plus"

operator. Say we have

c

It is important to observe that the "plus" operator always returns a

collection. Lists support sort method which sorts the list inplace::

a = [5, 1, 6, 7, 7, 10]

a.sort()

a

[1, 5, 6, 7, 7, 10]

a

[5, 4, 3, 2, 1]

We can also store this new reversed list in another list variable.

{{{ Show summary slide }}}

This brings us to the end of another session. In this tutorial session

we learnt

{{{ Show the "sponsored by FOSSEE" slide }}}

#+LaTeX_HEADER: commentstyle=\color{red}\itshape, stringstyle=\color{darkgreen},

#+LaTeX_HEADER: showstringspaces=false, keywordstyle=\color{blue}\bfseries}

#+AUTHOR: FOSSEE

#+EMAIL:

#+DATE:

#+LANGUAGE: en

#+OPTIONS: H:3 num:nil toc:nil \n:nil @:t ::t |:t ^:t -:t f:t *:t <:t

#+OPTIONS: TeX:t LaTeX:nil skip:nil d:nil todo:nil pri:nil tags:not-in-toc

* Outline

* Question 1

* Solution 1

#+begin_src python

* Question 2

* Solution 2

#+begin_src python

* Question 3

#+begin_src python

#+begin_src python

#+begin_src python

* Summary

* Thank you!

#+begin_latex

\begin{block}{}

\usepackage[latin1]{inputenc}

\usepackage[T1]{fontenc}

\usepackage{listings}

\date{}

\begin{document}

\begin{frame}

\end{frame}

\begin{frame}[fragile]

\end{frame}

\begin{frame}[fragile]

\end{frame}

\begin{frame}

\begin{block}{}

\begin{center}

This spoken tutorial has been produced by the

In this tutorial we have learnt :

#. The various options available for plotting dots instead of lines.

{{{ Show the "sponsored by FOSSEE" slide }}}

: fmt='go')

* Summary

: 0.6, 0.7, 0.8, 0.9]

: plot(x,y,'o')

: plot(x,y,'.')

* Thank you!

#+begin_latex

\begin{block}{}

#+end_latex

\documentclass[presentation]{beamer}

\usepackage[latin1]{inputenc}

\usepackage[T1]{fontenc}

\label{sec-15}

\begin{verbatim}

0.6, 0.7, 0.8, 0.9]

plot(x,y,'o')

plot(x,y,'.')

\end{verbatim}

\end{frame}

\end{document}

| 1.8 LO: | module level assessment | 3 | Madhu | | |

|---------+----------------------------------------+-------+----------+-----------------+-----------|

| 2.2 LO: | loading data from files | 3 | Punch | Nishanth (Done) | |

| 2.4 LO: | other types of plots | 3 | Anoop | Punch (Done) | |

| 2.5 LO: | module level assessment | 3 | Nishanth | | |

|---------+----------------------------------------+-------+----------+-----------------+-----------|

| 3.2 LO: | getting started with =for= | 2 | Anoop | Nishanth (Done) | |

| 3.3 LO: | getting started with strings | 2 | Madhu | | |

| 3.4 LO: | getting started with files | 3 | Punch | Anoop(Done) | |

| 6.4 LO: | loops | 2 | Punch | Anoop (Done) | |

| 6.5 LO: | Assessment | 3 | Anoop | | |

|---------+----------------------------------------+-------+----------+-----------------+-----------|

| 7.4 LO: | dictionaries | 2 | Anoop | Punch (Done) | |

| 7.6 LO: | Assessment | 3 | Amit | | |

|---------+----------------------------------------+-------+----------+-----------------+-----------|

| 8.1 LO: | getting started with functions | 3 | Nishanth | | |

Script

------

{{{ Show the slide containing title }}}

{{{ Show the slide containing the outline slide }}}

In this tutorial, we shall learn

* operations on sets

Sets are data structures which contain unique elements. In other words,

type

::

a = set(a_list)

a

p10 is the set of prime numbers from 1 to 10.

Various operations that we do on sets are possible here also.

::

f10 | p10

b = set([1, 2])

b < f10

Similarly,

::

f10 < f10

hence the right way to do would be

::

f10 <= f10

Sets can be iterated upon just like lists and tuples.

::

1 in f10

2 in f10

The order in which elements are organised in a set is not to be relied upon

since sets do not support indexing. Hence, slicing and striding are not valid

{{{ Show the "sponsored by FOSSEE" slide }}}

This tutorial was created as a part of FOSSEE project, NME ICT, MHRD India

Hope you have enjoyed and found it useful.

for mark in marks_set:

marks.remove(mark)

duplicates = set(marks)

#+end_src

* Summary

You should now be able to --

\documentclass[presentation]{beamer}

\usepackage[latin1]{inputenc}

\usepackage[T1]{fontenc}

for mark in marks_set:

marks.remove(mark)

duplicates = set(marks)

\end{lstlisting}

\end{frame}

.. Objectives

.. ----------

.. Prerequisites

Script

------

{{{ Show the slide containing title }}}

* their similarities and dissimilarities with lists

* why are they needed

::

t = (1, 2.5, "hello", -4, "world", 1.24, 5)

t[2] = "Hello"

We can see that, it raises an error saying tuple does not support item

We shall understand that soon. But let us look at a simple problem of swapping

values.

a

b

::

a = 2.5

a

b

This is possible because of the immutability of tuples. This process is called

tuple packing and unpacking.

5, "hello", 2.5

So when we are actually typing two or more elements seperated by commas, those

When you type

::

{{{ Show the "sponsored by FOSSEE" slide }}}

This tutorial was created as a part of FOSSEE project, NME ICT, MHRD India

Hope you have enjoyed and found it useful.