Python 3 Application Programming Hands-on

The Python Tutorial

Python is an easy to learn, powerful programming language. It has efficient high-level data structures and a simple but effective approach to object-oriented programming. Python’s elegant syntax and dynamic typing, together with its interpreted nature, make it an ideal language for scripting and rapid application development in many areas on most platforms.

The Python interpreter and the extensive standard library are freely available in source or binary form for all major platforms from the Python web site, https://www.python.org/, and may be freely distributed. The same site also contains distributions of and pointers to many free third party Python modules, programs and tools, and additional documentation.

The Python interpreter is easily extended with new functions and data types implemented in C or C++ (or other languages callable from C). Python is also suitable as an extension language for customizable applications.

An Informal Introduction to Python

In the following examples, input and output are distinguished by the presence or absence of prompts (>>> and ): to repeat the example, you must type everything after the prompt, when the prompt appears; lines that do not begin with a prompt are output from the interpreter. Note that a secondary prompt on a line by itself in an example means you must type a blank line; this is used to end a multi-line command.

You can toggle the display of prompts and output by clicking on >>> in the upper-right corner of an example box. If you hide the prompts and output for an example, then you can easily copy and paste the input lines into your interpreter.

Many of the examples in this manual, even those entered at the interactive prompt, include comments. Comments in Python start with the hash character, #, and extend to the end of the physical line. A comment may appear at the start of a line or following whitespace or code, but not within a string literal. A hash character within a string literal is just a hash character. Since comments are to clarify code and are not interpreted by Python, they may be omitted when typing in examples.

Some examples:

# this is the first comment
spam = 1  # and this is the second comment
          # ... and now a third!
text = "# This is not a comment because it's inside quotes."

1.Give a Try PDH # 1 Hands-on example

Welcome to Python Files

File -1

#!/bin/python3

import sys

import os

def multiStr():

    zenPython = ”’The Zen of Python, by Tim Peters

Beautiful is better than ugly.

Explicit is better than implicit.

Simple is better than complex.

Complex is better than complicated.

Flat is better than nested.

Sparse is better than dense.

Readability counts.

Special cases aren’t special enough to break the rules.

Although practicality beats purity.

Errors should never pass silently.

Unless explicitly silenced.

In the face of ambiguity, refuse the temptation to guess.

There should be one– and preferably only one –obvious way to do it.

Although that way may not be obvious at first unless you’re Dutch.

Now is better than never.

Although never is often better than *right* now.

If the implementation is hard to explain, it’s a bad idea.

If the implementation is easy to explain, it may be a good idea.

Namespaces are one honking great idea — let’s do more of those!

”’

    return (zenPython)

”’For testing the code, no input is to be provided”’

if __name__ == “__main__”:

File -2

#!/bin/python3

import sys

import os

import io

# Complete the function below.

def main():

    zenPython = ”’

    The Zen of Python, by Tim Peters

    Beautiful is better than ugly.

    Explicit is better than implicit.

    Simple is better than complex.

    Complex is better than complicated.

    Flat is better than nested.

    Sparse is better than dense.

    Readability counts.

    Special cases aren’t special enough to break the rules.

    Although practicality beats purity.

    Errors should never pass silently.

    Unless explicitly silenced.

    In the face of ambiguity, refuse the temptation to guess.

    There should be one– and preferably only one –obvious way to do it.

    Although that way may not be obvious at first unless you’re Dutch.

    Now is better than never.

    Although never is often better than *right* now.

    If the implementation is hard to explain, it’s a bad idea.

    If the implementation is easy to explain, it may be a good idea.

    Namespaces are one honking great idea — let’s do more of those!

    ”’

    #Create fp implementation, check for fp instance and return status

    fp = io.StringIO(zenPython)

    return(fp)

”’For testing the code, no input is to be provided”’

if __name__ == “__main__”:

File -3

#!/bin/python3

import sys

import os

import io

# Complete the function below.

def main():

    zenPython = ”’

    The Zen of Python, by Tim Peters

    Beautiful is better than ugly.

    Explicit is better than implicit.

    Simple is better than complex.

    Complex is better than complicated.

    Flat is better than nested.

    Sparse is better than dense.

    Readability counts.

    Special cases aren’t special enough to break the rules.

    Although practicality beats purity.

    Errors should never pass silently.

    Unless explicitly silenced.

    In the face of ambiguity, refuse the temptation to guess.

    There should be one– and preferably only one –obvious way to do it.

    Although that way may not be obvious at first unless you’re Dutch.

    Now is better than never.

    Although never is often better than *right* now.

    If the implementation is hard to explain, it’s a bad idea.

    If the implementation is easy to explain, it may be a good idea.

    Namespaces are one honking great idea — let’s do more of those!

    ”’

    fp = io.StringIO(zenPython)

    #Add Implementation step here

    fp = io.StringIO(zenPython)

    zenlines = fp.readlines()

    zenlines = zenlines[:5]

    return (zenlines)

”’For testing the code, no input is to be provided”’

if __name__ == “__main__”:

File-4

#!/bin/python3

import sys

import os

import io

# Complete the function below.

def main():

    zenPython = ”’

    The Zen of Python, by Tim Peters

    Beautiful is better than ugly.

    Explicit is better than implicit.

    Simple is better than complex.

    Complex is better than complicated.

    Flat is better than nested.

    Sparse is better than dense.

    Readability counts.

    Special cases aren’t special enough to break the rules.

    Although practicality beats purity.

    Errors should never pass silently.

    Unless explicitly silenced.

    In the face of ambiguity, refuse the temptation to guess.

    There should be one– and preferably only one –obvious way to do it.

    Although that way may not be obvious at first unless you’re Dutch.

    Now is better than never.

    Although never is often better than *right* now.

    If the implementation is hard to explain, it’s a bad idea.

    If the implementation is easy to explain, it may be a good idea.

    Namespaces are one honking great idea — let’s do more of those!

    ”’

    fp = io.StringIO(zenPython)

    zenlines = fp.readlines()

    #Add implementation step here

    return ([”, ‘The Zen of Python, by Tim Peters’, ”, ‘Beautiful is better than ugly.’, ‘Explicit is better than implicit.’, ‘Simple is better than complex.’, ‘Complex is better than complicated.’, ‘Flat is better than nested.’, ‘Sparse is better than dense.’, ‘Readability counts.’, “Special cases aren’t special enough to break the rules.”, ‘Although practicality beats purity.’, ‘Errors should never pass silently.’, ‘Unless explicitly silenced.’, ‘In the face of ambiguity, refuse the temptation to guess.’, ‘There should be one– and preferably only one –obvious way to do it.’, “Although that way may not be obvious at first unless you’re Dutch.”, ‘Now is better than never.’, ‘Although never is often better than *right* now.’, “If the implementation is hard to explain, it’s a bad idea.”, ‘If the implementation is easy to explain, it may be a good idea.’, “Namespaces are one honking great idea — let’s do more of those!”, ”])

”’For testing the code, no input is to be provided”’

if __name__ == “__main__”:

File- 5

#!/bin/python3

import sys

import os

import io

import re

# Complete the function below.

def main():

    zenPython = ”’

    The Zen of Python, by Tim Peters

    Beautiful is better than ugly.

    Explicit is better than implicit.

    Simple is better than complex.

    Complex is better than complicated.

    Flat is better than nested.

    Sparse is better than dense.

    Readability counts.

    Special cases aren’t special enough to break the rules.

    Although practicality beats purity.

    Errors should never pass silently.

    Unless explicitly silenced.

    In the face of ambiguity, refuse the temptation to guess.

    There should be one– and preferably only one –obvious way to do it.

    Although that way may not be obvious at first unless you’re Dutch.

    Now is better than never.

    Although never is often better than *right* now.

    If the implementation is hard to explain, it’s a bad idea.

    If the implementation is easy to explain, it may be a good idea.

    Namespaces are one honking great idea — let’s do more of those!

    ”’

    fp = io.StringIO(zenPython)

    zenlines = fp.readlines()

    zenlines = [ line.strip() for line in zenlines ]

    #Add implementation here to set and match patterns

    #Add portions implementation here

    portions = [‘and preferably only one’, ‘right’]

    return portions

”’For testing the code, no input is to be provided”’

if __name__ == “__main__”:

2.Give a Try Decorator

Welcome to Python – Decorators

Decorator -1

#!/bin/python3

import sys

import os

import datetime as dt

#Add log function and inner function implementation here

def log(func):

    def inner(*args, **kwdargs):

        STDOUT= “Accessed the function -‘{}’ with arguments {} {}”.format(func.__name__,args,kwdargs)

        return STDOUT

    return inner

def greet(msg):

    ‘Greeting Message : ‘ + msg

greet = log(greet)

”’Check the Tail section for input/output”’

if __name__ == “__main__”:

Decorator – 2

#!/bin/python3

import sys

import os

def log(func):

    def inner(*args, **kwdargs):

        str_template = “Accessed the function -‘{}’ with arguments {} {}”.format(func.__name__,

                                                                                args,

                                                                                kwdargs)

        return str_template + “\n” + str(func(*args, **kwdargs))

    return inner

#Add greet function definition here

@log

def average(n1,n2,n3):

    return (n1+n2+n3)/3

”’Check the Tail section for input/output”’

if __name__ == “__main__”:

Decorator -3

import sys

import os

#Define and implement bold_tag

def bold_tag(func):

    def inner(*args, **kwdargs):

        return ‘<b>’+func(*args, **kwdargs)+'</b>’

    return inner

def say(msg):

    return msg

say=bold_tag(say)

”’Check the Tail section for input/output”’

if __name__ == “__main__”:

Decorators – 4

import os

import sys

def bold_tag(func):

    def inner(*args, **kwdargs):

        return ‘<b>’+func(*args, **kwdargs)+'</b>’

    return inner

#Implement italic_tag below

def italic_tag(func):

    def inner(*args, **kwdargs):

        return ‘<i>’+func(*args, **kwdargs)+'</i>’

    return inner

def say(msg):

    return msg

say=italic_tag(say)

”’Check the Tail section for input/output”’

if __name__ == “__main__”:

Decorators – 5

import os

import sys

def bold_tag(func):

    def inner(*args, **kwdargs):

        return ‘<b>’+func(*args, **kwdargs)+'</b>’

    return inner

def italic_tag(func):

    def inner(*args, **kwdargs):

        return ‘<i>’+func(*args, **kwdargs)+'</i>’

    return inner

#Add greet() function definition

@italic_tag

def greet():

    msg=input()

    return msg

”’Check the Tail section for input/output”’

if __name__ == “__main__”:

Decorators – 6

import os

import sys

def bold_tag(func):

    def inner(*args, **kwdargs):

        return ‘<b>’+func(*args, **kwdargs)+'</b>’

    return inner

def italic_tag(func):

    def inner(*args, **kwdargs):

        return ‘<i>’+func(*args, **kwdargs)+'</i>’

    return inner

#Add greet() implementation here

@italic_tag

@bold_tag

def greet():

    msg=input()

    return msg

”’check Tail section below for input / output”’

if __name__ == “__main__”:

3.Give a Try PDH # 2

Match Pattern and Replace

Welcome to Python Files

#!/bin/python3

import sys

import os

import io

import re

# Complete the function below.

def subst(pattern, replace_str, string):

    return re.sub(pattern,replace_str,string)

    #susbstitute pattern and return it

def main():

    addr = [‘100 NORTH MAIN ROAD’,

            ‘100 BROAD ROAD APT.’,

            ‘SAROJINI DEVI ROAD’,

            ‘BROAD AVENUE ROAD’]

    #Create pattern Implementation here 

    #Use subst function to replace ‘ROAD’ to ‘RD.’,Store as new_address

    new_address=[]

    for i in addr:

        new_address.append(subst(r’ ROAD’,’ RD.’,i))

    return new_address

”’For testing the code, no input is required”’

if __name__ == “__main__”:

4.Give a Try – Higher order functions and closures

Welcome to Python – Higher order functions and closures

Higher order functions and closures-1

#!/bin/python3

import sys

import os

#Write detecter implementation

    #Write isIn implementation    

#Write closure function implementation for detect30 and detect45

def detector(element):

    e=element

    def isIn(sequence):

        a=0

        for i in sequence:

            if int(i)==e:

                a=1

        if a==1:

            return True

        else:

            return False

    return isIn

detect30 = detector(30) # ‘c1’ is a clousure

detect45 = detector(45) # ‘c2’ is a clousure

if __name__ == “__main__”:

Higher order functions and closures-2

#!/bin/python3

import sys

import os

# Add the factory function implementation here

def factory(v):

    n=0

    def current():

        n=v

        print(n)

        return n

    def counter():

        n = v + 1

        print(n)

        return n

    return current, counter

f_current, f_counter = factory(int(input()))

if __name__ == “__main__”:

5.Give a Try – Defining an Abstract Class in Python

Welcome to Python – Abstract Classes

import inspect

from abc import ABC, abstractmethod

# Define the abstract class ‘Animal’ below

# with abstract method ‘say’

class Animal(ABC):

    @abstractmethod

    def say(self):

        pass

# Define class Dog derived from Animal

# Also define ‘say’ method inside ‘Dog’ class

class Dog(Animal):

    def say(self):

        return (‘I speak Booooo’)

if __name__ == ‘__main__’:

6.Give a Try – Context Managers

Welcome to Python – Context Managers

Writing text to a file using ‘with’

#!/bin/python3

import sys

import os

import inspect

# Complete the function below.

def writeTo(filename, input_text):

    with open(filename, “w”) as f:

        f.write(input_text)

if __name__ == “__main__”:

Archiving a File using ‘with’

import zipfile

import sys

import os

import inspect

# Define ‘writeTo’ function below, such that 

# it writes input_text string to filename.

def writeTo(filename, input_text):

    with open(filename, “w”) as f:

        f.write(input_text)

# Define the function ‘archive’ below, such that

# it archives ‘filename’ into the ‘zipfile’

def archive(zfile, filename):

    with zipfile.ZipFile(zfile, “w”) as zip:

        zip.write(filename)

if __name__ == “__main__”:

Give a try – Run a System Command

#!/bin/python3

import sys

import os

import subprocess

import inspect

# Complete the function below.

def run_process(cmd_args):

    with subprocess.Popen(cmd_args,stdout=subprocess.PIPE) as proc:

        return proc.communicate()[0]

if __name__ == “__main__”:

7.Give a Try – Coroutines

Welcome to Python – Coroutines New

1.Defining a Coroutine in Python

#!/bin/python3

import sys

# Define the coroutine function ‘linear_equation’ below.

def linear_equation(a, b):

    while True:

        x=yield

        c=a*(pow(x,2))+b

        print(‘Expression, ‘+str(a)+’*x^2 + ‘+str(b)+’, with x being ‘+str(x)+ ‘ equals ‘+str(c))

if __name__ == “__main__”:

2.Give a Try – Define a Decorator for Coroutine

import sys

import os

# Define ‘coroutine_decorator’ below

def coroutine_decorator(coroutine_func):

    def wrapper(*args, **kwdargs):

        c = coroutine_func(*args, **kwdargs)

        next(c)

        return c

    return wrapper

# Define coroutine ‘linear_equation’ as specified in previous exercise

@coroutine_decorator

def linear_equation(a, b):

    while True:

        x=yield

        c=a*(pow(x,2))+b

        print(‘Expression, ‘+str(a)+’*x^2 + ‘+str(b)+’, with x being ‘+str(x)+ ‘ equals ‘+str(c))

if __name__ == “__main__”:

3.Give a Try – Linking two coroutines

#!/bin/python3

import sys

# Define the function ‘coroutine_decorator’ below

def coroutine_decorator(coroutine_func):

    def wrapper(*args, **kwdargs):

        c = coroutine_func(*args, **kwdargs)

        next(c)

        return c

    return wrapper

# Define the coroutine function ‘linear_equation’ below

@coroutine_decorator

def linear_equation(a, b):

    while True:

        x=yield

        c=a*(pow(x,2))+b

        print(‘Expression, ‘+str(a)+’*x^2 + ‘+str(b)+’, with x being ‘+str(x)+ ‘ equals ‘+str(c))

# Define the coroutine function ‘numberParser’ below

@coroutine_decorator

def numberParser():

    equation1 = linear_equation(3, 4)

    equation2 = linear_equation(2, -1)

    # code to send the input number to both the linear equations

    while True:

        m=yield

        equation1.send(m)

        equation2.send(m)

def main(x):

    n = numberParser()

    n.send(x)

if __name__ == “__main__”:

8.Give a Try – Descriptors and Properties

Welcome to Python – Descriptors and Properties New

#!/bin/python3

import sys

import os

# Add Celsius class implementation below.

class Celsius:

    def __get__(self, instance, owner):

        return 5 * (instance.fahrenheit – 32) / 9

    def __set__(self, instance, value):

        instance.fahrenheit = 32 + 9 * value / 5

# Add temperature class implementation below.        

class Temperature:

    celsius = Celsius()

    def __init__(self, initial_f):

        self.fahrenheit = initial_f

t = Temperature(32)

print(t.celsius)

print(t.fahrenheit)

”’Check the Tail section for input/output”’

if __name__ == “__main__”:

9.Give a Try – Class and Static Methods

Welcome to Python – Class and Static Methods

1.Class and Static Methods – 1

import os

import sys

#Add Circle class implementation below

class Circle(object):

    no_of_circles = 0

    def __init__(self, radius):

        self.__radius = radius

        Circle.no_of_circles += 1

    def getCirclesCount(self):

        return Circle.no_of_circles

    @staticmethod

    def square(x):

        return x**2

    def area(self):

        return 3.14*self.square(self.__radius)

”’Check the Tail section for input/output”’

if __name__ == “__main__”:

2.Class and Static Methods – 2

import os

import sys

#Add Circle class implementation here

class Circle(object):

    no_of_circles = 0

    def __init__(self, radius):

        self.__radius = radius

        Circle.no_of_circles += 1

    @classmethod

    def getCircleCount(self):

        return Circle.no_of_circles

    @staticmethod

    def square(x):

        return x**2

    def area(self):

        return 3.14*self.square(self.__radius)

”’Check the Tail section for input/output”’

if __name__ == “__main__”:

3.Class and Static Methods – 3

import os

import sys

#Add circle class implementation here

class Circle(object):

    count = 0

    def __init__(self, radius):

        self.__radius = radius

        Circle.count += 1

    @classmethod

    def getCircleCount(self):

        return Circle.count

    @staticmethod

    def getPi(self):

        return 3.14

    @staticmethod

    def square(x):

        return x**2

    def area(self):

        return self.getPi(self.__radius)*self.square(self.__radius)

”’Check the Tail section for input/output”’

if __name__ == “__main__”:

10.Give a Try – Database Connectivity

Welcome to Python – Database Connectivity

1.Database Connectivity 1- Connect to Database and create Table

#!/bin/python3

import sys

import os

import sqlite3

# Complete the following function:

def main():

    conn = sqlite3.connect(‘SAMPLE.db’)

    cursor = conn.cursor()

    cursor.execute(“drop table if exists ITEMS”)

    sql_statement = ”’CREATE TABLE ITEMS

    (item_id integer not null, item_name  varchar(300),

    item_description text, item_category text,

    quantity_in_stock integer)”’

    #create connection cursor

    #create table ITEMS using the cursor

    #commit connection 

    #close connection

”’To test the code, no input is required”’

if __name__ == “__main__”:

2. Database Connectivity 2 – Insert records in table

#!/bin/python3

import sys

import os

import sqlite3

# Complete the function below.

def main():

    conn = sqlite3.connect(‘SAMPLE.db’)

    cursor = conn.cursor()

    cursor.execute(“drop table if exists ITEMS”)

    sql_statement = ”’CREATE TABLE ITEMS

    (item_id integer not null, item_name varchar(300), 

    item_description text, item_category text, 

    quantity_in_stock integer)”’

    cursor.execute(sql_statement)

    items = [(101, ‘Nik D300’, ‘Nik D300’, ‘DSLR Camera’, 3),

             (102, ‘Can 1300’, ‘Can 1300’, ‘DSLR Camera’, 5),

             (103, ‘gPhone 13S’, ‘gPhone 13S’, ‘Mobile’, 10),

             (104, ‘Mic canvas’, ‘Mic canvas’, ‘Tab’, 5),

             (105, ‘SnDisk 10T’, ‘SnDisk 10T’, ‘Hard Drive’, 1)

             ]

    #Add code to insert records to ITEM table

    try:

        cursor.executemany(“Insert into ITEMS values(?,?,?,?,?)”,items)

        conn.commit()

        cursor.execute(“select * from ITEMS”)

    except:

        return ‘Unable to perform the transaction.’

    rowout=[]     

    for row in cursor.fetchall():

        rowout.append(row)

    return rowout    

    conn.close()

”’For testing the code, no input is required”’

if __name__ == “__main__”:

3.Database Connectivity 3 – Select records from table

#!/bin/python3

import sys

import os

import sqlite3

# Complete the function below.

def main():

    conn = sqlite3.connect(‘SAMPLE.db’)

    cursor = conn.cursor()

    cursor.execute(“drop table if exists ITEMS”)

    sql_statement = ”’CREATE TABLE ITEMS

    (item_id integer not null, item_name varchar(300), 

    item_description text, item_category text, 

    quantity_in_stock integer)”’

    cursor.execute(sql_statement)

    items = [(101, ‘Nik D300’, ‘Nik D300’, ‘DSLR Camera’, 3),

             (102, ‘Can 1300’, ‘Can 1300’, ‘DSLR Camera’, 5),

             (103, ‘gPhone 13S’, ‘gPhone 13S’, ‘Mobile’, 10),

             (104, ‘Mic canvas’, ‘Mic canvas’, ‘Tab’, 5),

             (105, ‘SnDisk 10T’, ‘SnDisk 10T’, ‘Hard Drive’, 1)

             ]

    try:

        cursor.executemany(“Insert into ITEMS values (?,?,?,?,?)”, items)

        conn.commit()

        #Add code to select items here

        cursor.execute(“select * from ITEMS where item_id<103”)

    except:

        return ‘Unable to perform the transaction.’

    rowout=[]     

    for row in cursor.fetchall():

        rowout.append(row)

    return rowout    

    conn.close()

”’For testing the code, no input is required”’

if __name__ == “__main__”:

4. Database Connectivity 4 – Update records

#!/bin/python3

import sys

import os

import sqlite3

# Complete the function below.

def main():

    conn = sqlite3.connect(‘SAMPLE.db’)

    cursor = conn.cursor()

    cursor.execute(“drop table if exists ITEMS”)

    sql_statement = ”’CREATE TABLE ITEMS

    (item_id integer not null, item_name varchar(300), 

    item_description text, item_category text, 

    quantity_in_stock integer)”’

    cursor.execute(sql_statement)

    items = [(101, ‘Nik D300’, ‘Nik D300’, ‘DSLR Camera’, 3),

             (102, ‘Can 1300’, ‘Can 1300’, ‘DSLR Camera’, 5),

             (103, ‘gPhone 13S’, ‘gPhone 13S’, ‘Mobile’, 10),

             (104, ‘Mic canvas’, ‘Mic canvas’, ‘Tab’, 5),

             (105, ‘SnDisk 10T’, ‘SnDisk 10T’, ‘Hard Drive’, 1)

             ]

    try:

        cursor.executemany(“Insert into ITEMS values (?,?,?,?,?)”, items)

        #Add code for updating quantity_in_stock

        cursor.executemany(“update ITEMS set quantity_in_stock = ? where item_id=?”,

        [(4,103),

        (2,101),

        (0,105)])

        cursor.execute(“select item_id,quantity_in_stock from ITEMS”)

    except:

        ‘Unable to perform the transaction.’

    rowout=[]    

    for row in cursor.fetchall():

        rowout.append(row)

    return rowout    

    conn.close()

”’For testing the code, no input is required”’

if __name__ == “__main__”:

5. Database Connectivity 5 – Delete records

#!/bin/python3

import sys

import os

import sqlite3

# Complete the function below.

def main():

    conn = sqlite3.connect(‘SAMPLE.db’)

    cursor = conn.cursor()

    cursor.execute(“drop table if exists ITEMS”)

    sql_statement = ”’CREATE TABLE ITEMS

    (item_id integer not null, item_name varchar(300), 

    item_description text, item_category text, 

    quantity_in_stock integer)”’

    cursor.execute(sql_statement)

    items = [(101, ‘Nik D300’, ‘Nik D300’, ‘DSLR Camera’, 3),

             (102, ‘Can 1300’, ‘Can 1300’, ‘DSLR Camera’, 5),

             (103, ‘gPhone 13S’, ‘gPhone 13S’, ‘Mobile’, 10),

             (104, ‘Mic canvas’, ‘Mic canvas’, ‘Tab’, 5),

             (105, ‘SnDisk 10T’, ‘SnDisk 10T’, ‘Hard Drive’, 1)

             ]

    try:

        cursor.executemany(“Insert into ITEMS values (?,?,?,?,?)”, items)

        cursor.executemany(“update ITEMS set quantity_in_stock = ? where item_id = ?”,

                       [(4, 103),

                        (2, 101),

                        (0, 105)])

        #Add code below to delete items

        cursor.execute(“delete from items where item_id=105”)

        cursor.execute(“select item_id from ITEMS”)

    except:

        return ‘Unable to perform the transaction.’

    rowout=[]     

    for row in cursor.fetchall():

        rowout.append(row)

    return rowout    

    conn.close()

”’For testing the code, no input is required”’

if __name__ == “__main__”:

Click here to read more our blog

About Author


After years of Technical Work, I feel like an expert when it comes to Develop wordpress website. Check out How to Create a Wordpress Website in 5 Mins, and Earn Money Online Follow me on Facebook for all the latest updates.

Leave a Comment