#PYTHON(DAY7)List methods in python

                                             #PYTHON(DAY7)

Methods in Python

Python List Methods has multiple methods to work with Python lists

We use dir() function to print the built-in list methods

print(dir(list))

And the expected output is:
['__add__', '__class__', '__class_getitem__', '__contains__', '__delattr__', '_delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort'['__add__', '__class__', '__class_getitem__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']

append()

• append is used to add another element to the list and this element will be added at the end

x = [1,2,3,4]
print(x, id(x))
print()
x.append(5)
print(x,id(x))

Note: we can not append 2 elements into the list at a time

so, from the above code we get the error as list.append() takes exactly one value

extend()

• extend is used to add two or more than two elements to end of the list
• these values/elements should be passed in container

x = [1,2,3,4]
print(x)
x.extend([5,6])
print(x)

And the expected output for the above code is: [1,2,3,4,[5,6]]

count()

• count will return the frequency of given element

x = [1,2,3,4,6]
print(x)
print(x.count(1))
print(x.count(5))

And the expected output is:

[1,2,3,4,6]
1
0

insert()

• insert as name suggests, is going to insert a new element at the specified index position
• index takes two values i.e index and value

x = [1,2,4]
print(x)
x.insert(3,1)
print(x)

And the expected output is:

[1,2,4,3]

remove()

• remove() is used to remove the specified element
• it removes the first occurence

x = [4,1,2,3,4,4]
x.remove(4)
print(x)

And the expected output is: here the first occurence is removed

[1,2,3,4,4]

pop()

• pop removes the element at given index position, if no index value is passed, the last element will popped out
• the discard/ejected element can be captured/assigned to a new for further use

x = [1,2,3,4,5]
x.pop(3)
print(x)

And the expected output is:

[1,2,3,5]

Note: as the element is popped out, the index values changes

so, from the below code we get the error as pop index out of range

x = [1,2,3,5]
x.pop(4)
print(x)

However, the remove() works on the elements and pop() works on indexes of elements

reverse()

• it reverses the list

x = [1,2,3]
print(x)
x.reverse()
print(x)

And the expected output is:

[1,2,3]
[3,2,1]

sort()

• sorting in ascending or descending

a = list(range(1,11))
b = [4.5,3.8,44.23,2,8,-6.9]
print(a,b, sep = '\n')

And the expected output is:

[1,2,3,4,5,6,7,8,9,10]
[4.5,3.8,44.23,2,8,-6.9]

print(a)
a.sort()
print(a) # ascending
a.sort(reverse = True) # decending
print(a)

And the expected output is:

[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
[10, 9, 8, 7, 6, 5, 4, 3, 2, 1]

copy()

• copy is used to store the list in different location to stor it in the different location

e = [1,2,3]
f = e
print(e,f,sep = '\n')
print(id(e), id(f))

e.insert(0,11)
print(e, f, sep ='\n')
print(id(e), id(f))

[1, 2, 3]
[1, 2, 3]
2590467336704 2590467336704
[11, 1, 2, 3]
[11, 1, 2, 3]
2590467336704 2590467336704

clear()

• it is going to erase all the elements from the list and returns an empty list

f = [1,2,3,4]
f.clear()
print(f)

And the expected output is: [ ] (empty list)

#PYTHON(DAY6)List and list indexing in python

 

#PYTHON(DAY6)

List and list indexing in python

Lists

• lists are a collection in python, and they are heterogeneous in nature
• means they can store multiple elements which belong to multiple data types/classes
• we seperate elemts in list by ‘,’
• lists are denoted by ‘[]’, we enclose our elements within square braces
• empty list = ‘[]’
• lists are ordered and sequence in nature
• If you add new items to a list, the new items will be placed at the end of the list.
• lists can be indexed and can be sliced
• when calling a method results in updation of list, these updations are reflected in same memory location and are applied on same variable, unlike string, we don not have reassign to make them reflect original var
• list are dynamic in nature

x = [1,2.2,3.3j,'four',print,str,True]
print(x,len(x),type(x))

And the expected output for the above code is [1, 2.2, 3.3j, ‘four’, <built-in function print>, <class ‘str’>, True] 7 <class ‘list’>

Since lists are indexed, lists can have items with the same value:

print(x[0], x[-1], sep ='\n')

INDEX()

• index will return the index position of first occurence of given element
• index method throws an error if a value/element is passed which is not in their list

x = [1,2,3,4]
x.index(5)

we get the value error

INDEXING

Positive Indexing

Indexing in Python starts at 0, which means that the first element in a sequence has an index of 0, the second element has an index of 1, and so on. For example, if we have a string “Hello”, we can access the first letter “H” using its index 0 by using the square bracket notation: string[0] .

INDEXING

List items are indexed and you can access them by referring to the index number:

thislist = ["apple", "banana", "cherry"]
print(thislist[1])

Negative Indexing

Negative indexing means start from the end

-1 refers to the last item, -2 refers to the second last item etc.

thislist = ["apple", "banana", "cherry"]
print(thislist[-1])

range

• range() populates a numbers within a given range.
• syntax for range()range(start,end,step)
• start is starting number
• end is till end, not encluding and
• step is the step size
• like in strings, we have a negative step in range
• default values of start is zero and step is +1

You can specify a range of indexes by specifying where to start and where to end the range.

When specifying a range, the return value will be a new list with the specified items.

thislist = ["apple", "banana", "cherry", "orange", "kiwi", "melon", "mango"]
print(thislist[2:5])

Note: The search will start at index 2 (included) and end at index 5 (not included).

x = range(1,21,3)
y = range(20,0,-2)
#z = range(20.5,1.5,0.5) # can not access float numbers
print(x, id(x))
print(y, id(y))

And the output is: range(1, 21, 3) 2590467408064
range(20, 0, -2) 2590467408832

x = list(x)
print(x, type(x))
print()

y = list(y)
print(y,type(y))

And the output is: [1, 4, 7, 10, 13, 16, 19] <class ‘list’>

[20, 18, 16, 14, 12, 10, 8, 6, 4, 2] <class ‘list’>

x = range(3, 20, 2)
for n in x:
  print(n)

Expected output is : 3
5
7
9
11
13
15
17
19

#PYTHON(DAY5) Data Types

 

#PYTHON(DAY5)

Data Types in python

Python Data Types are used to define the type of a variable. It defines what type of data we are going to store in a variable. The data stored in memory can be of many types. For example, a person’s age is stored as a numeric value and his or her address is stored as alphanumeric characters.

Python has various built-in data types which we will discuss with in this tutorial:

Data Types

• Numeric — int, float, complex
• String — str
• Sequence — list, tuple, range
• Binary — bytes, bytearray, memoryview
• Mapping — dict
• Boolean — bool
• Set — set, frozenset
• None — NoneType

var1 = 1
var2 = 10
var3 = 20.5

Python supports four different numerical types −

• int (signed integers)
• long (long integers, they can also be represented in octal and hexadecimal)
• float (floating point real values)
• complex (complex numbers)

Examples

Here are some examples of numbers −

int : 10,20,-445,0x486

long : 51924361L,-0x19323L,0xDEFABCECBDAECBFBAEl,-052318172735L

float : 0.0,15.20,32.3+e18,-90.

complex : 3.14j,45.j,-.6545+0J

• Python allows you to use a lowercase l with long, but it is recommended that you use only an uppercase L to avoid confusion with the number 1. Python displays long integers with an uppercase L.
• A complex number consists of an ordered pair of real floating-point numbers denoted by x + yj, where x and y are the real numbers and j is the imaginary unit.

Example

Following is an example to show the usage of Integer, Float and Complex numbers:

# integer variable.
a=100 
print("The type of variable having value", a, " is ", type(a))
 # float variable. 
b=20.345 print("The type of variable having value", b, " is ", type(b))
 # complex variable. 
c=10+3j print("The type of variable having value", c, " is ", type(c))

Python String Data Type

Python Strings are identified as a contiguous set of characters represented in the quotation marks. Python allows for either pairs of single or double quotes. Subsets of strings can be taken using the slice operator ([ ] and [:] ) with indexes starting at 0 in the beginning of the string and working their way from -1 at the end.

The plus (+) sign is the string concatenation operator and the asterisk (*) is the repetition operator in Python. For example −

str = 'Hello World!'

print (str)          # Prints complete string
print (str[0])       # Prints first character of the string
print (str[2:5])     # Prints characters starting from 3rd to 5th
print (str[2:])      # Prints string starting from 3rd character
print (str * 2)      # Prints string two times
print (str + "TEST") # Prints concatenated string

# output of above code
Hello World!
H
llo
llo World!
Hello World!Hello World!
Hello World!TEST

In this story you will be finding only the numeric and string data types.