DEV Community: Umme Abira Azmary

Cloud Computing, Microsoft Azure

Umme Abira Azmary — Fri, 28 Jan 2022 12:28:49 +0000

Cloud Concepts

Cloud computing is the delivery of various services such as data storage, servers, databases, networking, and software, over the Internet.

Cloud storage allows customers to save files to a remote database and retrieve them whenever they need them. So, a cloud environment provides various types of advantages.

High availability: High availability refers to a computing infrastructure that allows it to continue operating even if some of its components fail. So, depending on the service-level agreement (SLA) that a customer choose, they can experience a continuous user experience with no apparent downtime of cloud-based apps.

Availability = uptime / (uptime + downtime)

[A cloud SLA (Service-Level Agreement) is an agreement between a cloud service provider and a customer that ensures specific terms that state the level of service that will be provided to a customer.]

Scalability: Scalability is the ability of the system to support desired workload.
Basically, scalability basically handles larger loads by adding resources either making hardware stronger (scale up) or adding additional nodes (scale out)

It helps the system to scale out to ensure capacity during workload peaks and return to normal automatically when the peak drops.

Apps in the cloud can scale vertically and horizontally.

Vertical Scalability increases compute capacity by adding RAM or CPUs to a virtual machine.

Horizontal Scalability increases compute capacity by adding instances of resources, such as adding VMs to the configuration.

Elasticity: Elasticity is the ability to scale automatically/dynamically.

It provides the capacity to fit the resources needed to cope with loads dynamically.
It quickly expands or decreases cloud-based resources to satisfy changing demands without worrying about capacity planning and engineering for peak usage.

Agility:
Cloud Agility is the ability to react quickly.So, the speed and flexibility in the cloud which allow users to allocate and deallocate resources quickly is often called cloud agility.

Because of Agility the cloud providers maintain resources and provision them, so user can concentrate on other issues such as security, monitoring, and analysis.

Geo-distribution: Geo distribution is designed in such a way to deploy apps and data to regional datacenters around the globe,which ensures the customers always have the best performance in their region.

Fault Tolerance: Fault tolerance is the ability to maintain system uptime while physical and service component failures happen.

Disaster recovery: Disaster Recovery is the ability of a system to recover from a human -induced disaster that has destroyed the primary data-center.

Using cloud computing system we can deploy applications in multiple regions and data-replication in another region; and can also access it easily.
As multiple times, we have mentioned regions, lets get to know more about it.

Region: Region is the location of your services. A region is a set of datacenters connected through a regional low-latency network.

Microsoft azure has the most number of regions currently, so it gives customers the flexibility to deploy application wherever needed.

Two kinds of regions we need to keep in mind:

1) Special government regions (US DoD Central, US Gov Virginia, etc.)

2) Special partnered regions (China East, China North)

Region Pair: Each region pairing with another region makes region pair. Region pairs are static and we cannot choose it.

Availability Zone: Then comes the availability zone which is a regional feature. It is designed to protect from data center failures. Availability Zones are grouping of physically separate facilities, so if a zone goes down others continue working. But not all regions are supported in availability zone, a supported region has three or more zones.

{"Dictionary" : "fun"}

Umme Abira Azmary — Wed, 26 Jan 2022 14:28:14 +0000

A dictionary is an unordered collection that consists of key-value pairs. Dictionaries are bounded by curly braces and have a list of key: value pairs which are separated by comma (,)

dict1 = {}
dict1['name'] ='mouly'
dict1['address'] = 'bogura'
dict1['profession'] = 'student'
print(dict1)

Output:

{'name': 'mouly', 'address': 'bogura', 'profession': 'student'}

Here, name, address, profession are keys. Keys need to be immutable type and keys are case sensitive.

Empty Dictionary

dict2 = {}
print(dict2)

Output:

{}

Accessing a dictionary inside a dictionary

m_zen = { 88017:'rihan', 88015:'kiran', 88018 : ['sonam','riki'], 88013: 'harmeonie', 88016 :{24: 'chinal',26:'sonu'}}
y = m_zen[88016][26]
print(y)

Output:

sonu

Adding two list as key,value in dictionary

For this, we have to use zip function.

name = ['darla','remina','sonam','kiran']
age = [23, 45, 3, 44]
res = dict(zip(name,age))
print(res)

Output:

{'darla': 23, 'remina': 45, 'sonam': 3, 'kiran': 44}

Length of a dictionary

store = {'bangla' : 3, 'english' : 4, 'german' : 5, 'arabic' : 2}
print(len(store))

Output:

Dictionaries are mutable

Dictionaries are mutable while keys are immutable. So we can change the values of a dictionary.

dict3 = {'nila': 2345, 'mili': 2356, 'mona': 3456}
y = dict3['mona']
print(y)

Output:

This is how we can access the value of a specific key of a dictionary.

We can also get the same value by using get function. The benefit of using get function is that, it does not give an error if we can not find value of a key; rather it gives None as output.

dict4 = {'nila': 2345, 'mili': 2356, 'mona': 3456}
y = dict4.get('nila')
print(y)

Output:

dict4 = {'nila': 2345, 'mili': 2356, 'mona': 3456}
#x = dict4['rita']                                     #if we print it, it will give a KeyError
y = dict4.get('rita')
print(y)

Output:

None

changing the value of a dictionary

dictt = {'saturn': 2, 'moon': 1, 'mars': 'red'}
print(dictt)
dictt['moon'] = 'earth'
print(dictt)

Output:

{'saturn': 2, 'moon': 1, 'mars': 'red'}
{'saturn': 2, 'moon': 'earth', 'mars': 'red'}

address = {'room':3,'home':4,'street':2}
print(address)
address['room']= address['room']+ 2
print(address)

Output:

{'room': 3, 'home': 4, 'street': 2}
{'room': 5, 'home': 4, 'street': 2}

Here we can see how we the change value of a key of a dictionary.

Looping through a dictionary

songs = { 'red':'All Too Well', 1989: 'Style', 'reputation' : 'Gorgeous'}
for i in songs.keys():
    print(i)

Output:

red
1989
reputation

songs = { 'red':'All Too Well', 1989: 'Style', 'reputation' : 'Gorgeous'}
for i in songs.values():
    print(i)

Output:

All Too Well
Style
Gorgeous

songs = { 'red':'All Too Well', 1989: 'Style', 'reputation' : 'Gorgeous'}
for i,j in songs.items():
    print(i, j)

Output:

red All Too Well
1989 Style
reputation Gorgeous

If I update a dictionary, then the updated list of keys will be displayed.

songs = { 'red':'All Too Well', 1989: 'Style', 'reputation' : 'Gorgeous'}
y = songs.keys()
songs['folklore'] = 'cardigan'
print(y)

Output:

dict_keys(['red', 1989, 'reputation', 'folklore'])

Determining if a key exists in Dictionary

d = {'red':'All Too Well', 1989: 'Style', 'reputation' : 'Gorgeous'}
if 'red' in d:
    print('yup')

Output:

yup

Adding Elements

For adding a new element in a dictionary, we have to add a key and then assign a value in that key and it will add by default as the last value.

pdict = { 88017:'rihan', 'nila': 2345, 1989: 'Style', 88015:'kiran'}
pdict['mouly'] = 'cse'
print(pdict)

Output:

{88017: 'rihan', 'nila': 2345, 1989: 'Style', 88015: 'kiran', 'mouly': 'cse'}

Update method

Or, we can use update method.

pdict = { 88017:'rihan', 'nila': 2345, 1989: 'Style', 88015:'kiran'}
pdict.update({'mouly' : 'cse'})
print(pdict)

Output:

{88017: 'rihan', 'nila': 2345, 1989: 'Style', 88015: 'kiran', 'mouly': 'cse'}

Del method

We can use del method for removing an element or simply remove the whole dictionary.

rdict = {'darla': 23, 'remina': 45, 'sonam': 3, 'kiran': 44}
del rdict
print(rdict)

Output:

NameError: name 'rdict' is not defined

For removing any selective element from a dictinary,

rdict = {'darla': 23, 'remina': 45, 'sonam': 3, 'kiran': 44}
del rdict['sonam'] 
print(rdict)

Output:

{'darla': 23, 'remina': 45, 'kiran': 44}

Sorting dictionary

We can sort keys or values by using following method.

jdict = {'saturn': 'sat', 'moon': 'ear', 'mars': 'red', 'venus': 2}
new = sorted(jdict.keys())
print(jdict)
print(new)

Output:

['mars', 'moon', 'saturn', 'venus']

m_zen = { 88017:'rihan', 88015:'kiran', 88018 : ['sonam','riki'], 88013: 'harmeonie', 88016 :{24: 'chinal',26:'sonu'}}
y = sorted(m_zen.keys())
print(y)

Output:

[88013, 88015, 88016, 88017, 88018]

Sorting values,

jdict = {'saturn': 'sat', 'moon': 'ear', 'mars': 'red', 'venus': 2}
new = sorted(jdict.values())
print(new)

Output:

TypeError: '<' not supported between instances of 'int' and 'str'

Important thing to notice, we can not compare between the instances of integer and string.

gdict = {'saturn': 'sat', 'moon': 'ear', 'mars': 'red', 'venus': 'blue'}
new = sorted(gdict.values())
print(new)

Output:

['blue', 'ear', 'red', 'sat']

Take a input dict from the user

n = 2
d = dict(input("Enter: ").split() for i in range(n))        #while taking input write one key-value in only line and go to the next line
print(d)

Output:

Enter: name mouly
Enter: student bracu
{'name': 'mouly', 'student': 'bracu'}

or,

val="""name mouly
age 21
home bogura"""

y = dict(x.split() for x in val.splitlines())
print(y)

Output:

{'name': 'mouly', 'age': '21', 'home': 'bogura'}

or,

n = int(input("enter a n value:"))
d = {}
for i in range(n):
    keys = input()           # here i have taken keys as strings
    values =input()          # here i have taken values as integers
    d[keys] = values
print(d)

Output:

enter a n value:2
name
mouly
age
21
{'name': 'mouly', 'age': '21'}

or,

n = int(input())            #n is the number of items you want to enter
d ={}                     
for i in range(n):        
    text = input().split()     #split the input text based on space & store in the list 'text'
    d[text[0]] = text[1]       #assign the 1st item to key and 2nd item to value of the dictionary
print(d)

Output:

2
name mouly
street 2
{'name': 'mouly', 'street': '2'}

What is Module?

Umme Abira Azmary — Fri, 21 Jan 2022 21:19:35 +0000

A module is a file containing Python definitions and statements which we can use in other Python programs.
A module is simply a “Python file” which contains code(functions, classes,lists etc) we can reuse in multiple Python programs.

Modules in Python can be of two types:

Built-in Modules.
User-defined Modules.

Modules allows us to use the functionality we need when we need it, and it keeps our code cleaner.

The functions we import as part of a module stays in their own namespace.(A namespace is simply a space within which all names are different from each other). The same name can be reused in different namespaces but two objects can’t have the same name within a single namespace.

For example, Many cities have a street called “Main Street”,
It is okay if 'different' cities have that 'same' street name but it’s very confusing if two streets in the same city have that same name!

Another example is the folder organization of file systems. One can have a file called "todo" in her work folder as well as her personal folder, but she knows which is which because of the folder it’s in; each folder has its own namespace for files.

One important note, human names are not part of a namespace that applies uniqueness; that’s why governments have invented unique identifiers to assign to people, like passport numbers.

In order to use Python modules, we have to import them into a Python program.

1)If we import morecode in a code, that imports everything in morecode.py. To invoke a function f1 that is defined in morecode.py, we can write morecode.f1().

morecode.f1

Note that we have to explicitly mention morecode again, to specify that we want the f1 function from the morecode namespace.If we just write f1(), python will look for an f1 that was defined in the current file, rather than in morecode.py.

2)We can also give the imported module an alias (a different name, just for when we use it in our program). For example, after executing import morecode as mc,
we would invoke f1 as mc.f1(). We have now given the morecode module the alias mc. Programmers often do this to make code easier to type.

3)A third possibility for importing occurs when we only want to import SOME of the functionality from a module and we want to make those objects be part of the current module’s namespace.
For example, we could write from morecode import f1. Then we could invoke f1 without referencing morecode again: f1().

Basics of Python "String"

Umme Abira Azmary — Sun, 09 Jan 2022 12:02:17 +0000

String

String is a sequence of ordered characters (alphabets-lower case, upper case, numeric values, special symbols).

Strings are either enclosed with single qutation marks('),double quotation marks('') and triple quotation marks('''). Also we can write multi line string using triple qutations(''', " " " both) The character order is always from left to right.

print("Hello! I am mouly")
print('Helloo! I am Mouly')
print('''This is
a multi line 
string and we
call it "Doc-Strings" ''')

Output:

Hello! I am mouly
Helloo! I am Mouly
This is
a multi line 
string and we
call it "Doc-Strings"

we can use either single quotation or double quotation as long as we are consistant about which qutation we are using

print("He was in the dead sea while listening 'Ocean Eyes'")

Output:

He was in the dead sea while listening 'Ocean Eyes'

This qutation sequence can easily be maintained by using preceding backslash which is called as an escape character( \ )

print('I manage because I have to. Because I\'ve no other way out')
print("Don't you know,\"How can you ignore?\"")

Output:

I manage because I have to. Because I've no other way out
Don't you know,"How can you ignore?"

An empty string also holds an indexing position

print(" ")                                     #empty string
print(' ')

Output:

f-string

f-strings are string literals called as “formatted string literals” that have an f at the beginning and curly braces containing expressions that will be replaced with their values.

wrd = 'looking'
who ='kid'
print(f'Here\'s {wrd} at you, {who}')

Output:

Here's looking at you, kid

Type

this built-in fuction returns the type of an object

name = "alan walker"  
print(type(name))                             #type of name variable

Output:

<class 'str'>

Also,

p = "5"                                      #this is a string
q = 5                                        #this is an integer
print(type(p))
print(type(q))

Output:

<class 'str'>
<class 'int'>

Even though p and q might look same to you.. their types are different and there are different consequences for this.

p = "5"
q = 5
print(p)
print(q + 45)

Output:

5
50

but

p = "5"
q = 5
print(p + 45)                                 #this will give an error
print(q)

Output:

TypeError: can only concatenate str (not "int") to str

Here, p is a string. Even though 5 happens to look like a number, in python it's just a sequence of characters and we can't add a number to a sequence of characters.
we can add them if we cast this p string into an integer.

p = "5"
q = 5
print(int(p) + 45))                          #this won't give an error
print(q)

Output:

50
5

p = "5"
print(p + "45")                              #string concetenation

Output:

When we call a int of float to cast a string it needs to be a valid number.

p = "20 taka"
print(p + 25)

Output:

TypeError: can only concatenate str (not "int") to str

So, python can't convert this string into integer.

Strings are sequential collection datatype.This means a string is actually a collection of single characters.

Indexing

We can access an individual character of a string or part of a string using the indexing operator.
For accessing individual character by it's position or index value. This index value always begins at zero

Indexing can be done in two ways:

Positive Indexing is used to access characters from the left side of a string and it always starts from 0 and ends at the last character of the string.

Negative Indexing is used to access characters from the right side of a string and it starts from -1 and ends at the first character of the string.

REMEMBER, A string with six characters have entities from 0 through 5. So if we want to access a 5th character of a string we'll use an index of 4.

The basic string indexing structure

string_name[index_value]

xmple = "we want to access"
print(xmple[0])
print(xmple[2])   
print(xmple[8])                                  #positive indexing
print(xmple[-1])                                 #negative indexing
print(xmple[18])                                 #index out of range
print(xmple[1.5])                                #type error

Output:

w

t
s
IndexError
TypeError

the built-in function len() helps us determine the length of a string. So the last index of a stirng will always be one less than the length of that string.

len(string)

xmple = "we want to access"
print(len(xmple))                               #length of a string

Output:

If we want to access last character of a string we can do either of them from below:

xmple = "we want to access"
print(xmple[len(xmple)-1])
print(xmple[-1])

Output:

e
e

Slicing

Slicing is used for getting a substring of a particular string.This allows us to create a sub-string that is more than one character long. Colon(:) is used as a slicing operator.

Keep in mind that, the slice operator leaves the original operator intact.

Basic structure of slicing

string_name[beginning : end : step_size]

beginning: The index where slicing starts (inclusive). If not provided, by default starts from index 0.

end: The index where slicing stops(Not inclusive). If not provided, by default includes the rest of the string after “beginning”.

step : increment of the index value. If not provided, by default the value is 1.

xmple = "we want to access"
print(xmple[1:9:1])

Output:

e want t

In this example,the colon used in this slicing operator will return the characters from index 1 upto index 8(so not including index 9) and the increment will be 1.

String Operators

Concatenation

We can concatenate strings by using the plus(+) sign.

var1 = "we want"
var2 = "to visit a"
var3 = "zoo"
var =  var1 +" "+ var2 +" "+ var3             #concetenation of a string
print(var)

Output:

we want to visit a zoo

Notice one thing, this + sign doesn't add any space while concatenating.

Repetition

We can create a new string with the specified number of copies of the input string using this method.

v = "repeat4time"*4
print(v)

Output:

repeat4timerepeat4timerepeat4timerepeat4time

Built-in methods

It's important to remember that, Python is IMMUTABLE. Immutable means once it has been created its value cannot be changed.
So, each time we have to modify the values, we need to make a copy of the original one and make changes to the duplicate one.

me = "Abira"
me[1] = "e"

Output:

TypeError: 'str' object does not support item assignment

Python has some built-in method to access or process characters in string.

For example,

count(substring) method

we can use the count method to count the occurances of a particular substring.

place = "I want to visit USA"
print(place.count("i"))

Output:

As python is case-sensitive, we can't access I here cause the ASCII value of I is different than i***

index(substring) method

we can use the index method to find the index of the first occurance of a given substring.

place = "I want to visit USA"
print(place.index("i"))

Output:

Upper() and lower() method

Upper returns the **copy* of a given string in all uppercase letters; while lower returns the copy of a given string in all lowercase letters.

place = "I want to visit USA"
print(place.upper())
print(place.lower())

Output:

I WANT TO VISIT USA
i want to visit usa

upper or lower method takes no arguments.

strip() method

this strip method returns the copy of a string by removing the whitespaces from before and after letters.

Whitespaces refers to any character that represents a space in text like a tab,a space or a new line character.

new = "   Well this is another line   !     "       #Strips all whitespace characters from both ends.
print(new.strip())

Output:

Well this is another line   !

Notice, the whitespace between characters are not removed, only the before and after letters whitespaces are removed.

replace(oldstring, newstring) method

the replace method replace every instance of oldstring with newstring in a string.

exm = "wd ard hdrd"
nexm = exm.replace('d','e')
print(nexm)

Output:

we are here

split method

Split helps us breaking sentences of a string into more managable pieces.

Split takes a delimiter and splits the string into sub-strings.The method returns a list where each item is a sub-string that is cut at every instance of that delimeter.

For example,

song = "Tell me why? Aint noting but a heartache. Tell me why? Aint noting but a mistake"
print(song.split("?"))

Output:

['Tell me why', ' Aint noting but a heartache. Tell me why', ' Aint noting but a mistake']

This output comes as a list
Here "?" is the delimeter.. so It will cut in those places and won't return the delimeter in output.

x = "Library is a place where you can find peace"
print(x.split(" "))

Output:

['Library', 'is', 'a', 'place', 'where', 'you', 'can', 'find', 'peace']

Here my delimeter is a space. So the resulting list will include every word in that sentence but no spaces.

x = "Library is a place where you can find peace"
print(x.split("a"))

Output:

['Libr', 'ry is ', ' pl', 'ce where you c', 'n find pe', 'ce']

So, the split method won't include the delimeter in the list it returns.

Join method

The inverse of the split method is join. We can choose a desired separator string, (often called the glue) and join the list with the glue between each of the elements.

x = ["*light blue?", "sky", "it's raining hard","colin, where you go","?*"]
y = "! "
p = y.join(x)
print(p)

Output:

*light blue?! sky! it's raining hard! colin, where you go! ?*

We can also use empty string or multi-character strings as glue.