Python Interview Questions

 Prepared By : Prof. Uday Shah (HOD-IT)

Python Interview Questions for Beginners

1. What is Python?

Python is a high-level, interpreted, object-oriented programming language used for web development, data science, automation, etc.

2. What are the features of Python?

• Easy to learn

• Interpreted

• Object-oriented

• Cross-platform

• Large standard library

3. What is PEP 8?

PEP 8 is Python’s style guide used to write clean and readable code.

4. What is a variable in Python?

A variable is a named memory location used to store data.

5. What are Python data types?

• int

• float

• str

• bool

• list

• tuple

• set

• dict

6. What is the difference between list and tuple?

List	Tuple
Mutable (can change)	Immutable (cannot change)
Uses []	Uses ()

7. What is a dictionary in Python?

A dictionary stores data as key-value pairs.
Example: {"name": "Uday", "age": 25}

8. What is type casting?

Converting one data type to another.
Example: int("10")

9. What is indentation in Python?

Indentation defines blocks of code. Python uses spaces instead of { }.

10. What is a function?

A block of reusable code defined using def.

11. What is the difference between return and print?

• return sends a value back from a function

• print displays output on screen

12. What is a module?

A .py file that contains variables, functions, or classes.

13. What is a package?

A collection of modules inside a directory containing __init__.py.

14. What are keywords in Python?

Reserved words like if, else, for, while, etc.

15. What is the use of if __name__ == "__main__":?

It checks whether the file is executed directly or imported.

16. What is the difference between == and is?

• == compares values

• is compares memory locations

17. What is a loop?

Repeating a block of code using for or while.

18. How do you create a list in Python?

my_list = [1, 2, 3]

19. How do you create a function in Python?

def greet():
    print("Hello")

20. What is a class in Python?

A class is a blueprint for creating objects.

MCA 1 Android Using Kotlin Unit 5 : Layouts and Database Connectivity Using SQLite

Prepared By : Prof. Uday Shah (HOD-IT)

Unit 5 : Layouts and Database Connectivity Using SQLite 

1. Linear Layout 1

2. Frame Layout 1

3. Relative Layout 2

4. Constraint Layout 2

5. Managing Data Using SQLite. 3

6. Insert Operation in SQLite. 3

7. Update Operation in SQLite. 4

8. Delete Operation in SQLite. 4

9. Select Operation in SQLite. 5

10. Cursor Usage. 5

11. ContentValues Usage. 6

12. Creating Database Helper Class. 6

13. Data Storage APIs. 7

 

 1. Linear Layout

• LinearLayout arranges child views in a single direction: either vertical or horizontal.
• Direction is set using android:orientation="vertical" or "horizontal".
• Commonly used for form designs, login pages, column/row alignment.
• Views are placed one after another, like a stack.
• Supports weight (layout_weight) for proportional distribution of space.
• Example XML:
• <LinearLayout android:orientation="vertical"></LinearLayout>
• Simple to understand and easy to design.
• Uses more nesting for complex designs, which can reduce performance.
• Supports gravity and layout_gravity for alignment.
• Best for small layouts with few elements.
• Works well with ScrollView for long forms.
• Offers margin/padding flexibility.
• Lightweight and efficient for simple UI screens.

 2. Frame Layout

• FrameLayout is designed to stack multiple views on top of each other.
• The first child is at the bottom, and the last child appears on top.
• Mostly used for single child screens like splash screen or fragment container.
• Commonly used for Fragment transactions as a container.
• XML example:
• <FrameLayout android:id="@+id/container"></FrameLayout>
• Allows overlapping of views, useful for badges, overlays, and watermarks.
• Simple and lightweight compared to other layout types.
• Does not support complex positioning by default.
• Very useful in custom UI designs.
• Supports foreground drawable for overlay effects.
• Often used inside ConstraintLayout or RelativeLayout as a placeholder.
• Helps create image overlays or layered UI designs.

 3. Relative Layout

• RelativeLayout positions elements relative to each other or parent.
• Allows alignment like below, above, toRightOf, toLeftOf, etc.
• Makes UI flexible and reduces nesting compared to LinearLayout.
• XML example:
• <RelativeLayout></RelativeLayout>
• Supports parent-relative positioning: alignParentTop, alignParentLeft, etc.
• Good for medium-level complex designs where element relationships matter.
• Harder to maintain when layout becomes large.
• Widely used before ConstraintLayout became modern standard.
• Supports center alignment easily.
• Helps reduce layout depth compared to nested LinearLayouts.
• Works with margins, padding, and wrap/match constraints.
• Supports floating elements like images over text.

 4. Constraint Layout

• ConstraintLayout is the most powerful and modern layout for Android.
• Allows positioning views using anchor points called constraints.
• Greatly reduces nesting → improves performance.
• Can create complex UI designs with a flat view hierarchy.
• Supports guidelines, barriers, biasing, chains, and ratio-based resizing.
• XML example:
• <ConstraintLayout></ConstraintLayout>
• Works with Android Studio’s Layout Editor visually.
• Best layout for modern app designs.
• Supports responsive UI across screen sizes.
• Chains help align views horizontally/vertically.
• Bias controls placement along constraints.
• Recommended for all professional Android apps.
• Easy to manage with blueprint UI editor.

 5. Managing Data Using SQLite

• SQLite is a lightweight, embedded database in Android.
• Used for storing structured data in table format.
• Data remains saved even after app restarts.
• Supports SQL commands: CREATE, INSERT, UPDATE, DELETE, SELECT.
• Fast, reliable, and does not require a server.
• Used for offline apps like notes, expenses, contacts.
• Accessed through SQLiteDatabase class in Android.
• Stores data in .db file inside internal storage.
• Can manage multiple tables and relationships.
• Works with Cursor to read results.
• Requires a helper class (SQLiteOpenHelper) for database management.
• More secure than SharedPreferences for storing multiple entries.
• Supports transactions for better performance.

 6. Insert Operation in SQLite

• Insert operation is used to add new data to a table.
• Implemented using SQL INSERT query or using ContentValues.
• Example using ContentValues:
• val cv = ContentValues()
• cv.put("name", "Uday")
• db.insert("student", null, cv)
• Requires writable database using db = writableDatabase.
• Helps store user data like form entries.
• Can insert multiple rows using loops or bulk insert.
• Auto-increment columns work automatically.
• Returns row ID of newly inserted row.
• Can validate data before inserting.
• Insert errors can be handled using try-catch.
• Used in registration forms, saving notes, adding records.

 7. Update Operation in SQLite

• Update modifies existing data in a table.
• Requires identifying which record to update using WHERE clause.
• Example:
• val cv = ContentValues()
• cv.put("name", "Updated Name")
• db.update("student", cv, "id = ?", arrayOf("1"))
• Only selected rows change; others remain unchanged.
• Used when editing profile, updating record values.
• Returns number of rows affected.
• Must check if record exists before updating.
• Requires writable database.
• Should avoid updating primary keys.
• Useful in CRUD applications.

 8. Delete Operation in SQLite

• Delete removes specific rows from a table.
• Uses SQL DELETE command or database delete method.
• Example:
• db.delete("student", "id = ?", arrayOf("1"))
• Must use WHERE clause; else entire table will delete.
• Returns number of rows deleted.
• Useful for remove, clean-up, and record management.
• Can delete based on conditions (e.g., delete expired records).
• Must handle foreign key constraints if exists.
• Requires writable database.

 9. Select Operation in SQLite

• Select retrieves data from the database.
• Uses SQL SELECT query.
• Example:
• db.rawQuery("SELECT * FROM student", null)
• Returns result in Cursor format.
• Used to display data in ListView, RecyclerView.
• Can filter data using WHERE clause.
• Supports sorting using ORDER BY.
• Cursor must be closed after use.
• Readable database is used for select queries.
• Can fetch specific fields or all fields.

 10. Cursor Usage

• Cursor is the result-set returned from SELECT query.
• Acts like a pointer to rows in the table.
• Moves row-by-row using moveToNext().
• Example:
• val c = db.rawQuery("SELECT * FROM student", null)
• while (c.moveToNext()) { }
• Can get data using getString(), getInt(), etc.
• Must close cursor after use: c.close().
• Helps read each column of each row.
• Used for displaying data in list or adapter.
• Provides row count using getCount().
• Essential for retrieving database records.

 11. ContentValues Usage

• ContentValues stores data as key–value pairs.
• Used for INSERT and UPDATE operations.
• Example:
• val cv = ContentValues()
• cv.put("name", "Raj")
• Ensures safe data handling without writing raw SQL.
• Prevents SQL injection attacks.
• Works with INT, TEXT, FLOAT, LONG, DOUBLE values.
• Must match column names accurately.
• Makes CRUD operations easier.
• Used widely in Android SQLite programming.
• Increases readability and cleaner code.

 12. Creating Database Helper Class

• Database Helper class extends SQLiteOpenHelper.
• Manages database creation and version upgrades.
• Must override: onCreate() and onUpgrade().
• Example:
• class DBHelper(context: Context): SQLiteOpenHelper(context, "mydb", null, 1)
• onCreate() executes CREATE TABLE query.
• Provides readable and writable database objects.
• Handles version update using onUpgrade().
• Makes database code reusable.
• Required for every SQLite-based app.
• Helps organize database operations.

 13. Data Storage APIs

• Android provides various APIs for storing data.
• Includes SharedPreferences, SQLite, Room Database, Files, and Cloud Storage.
• SharedPreferences is for small key–value data.
• SQLite is for structured relational data.
• Room is modern ORM on top of SQLite.
• Internal Storage stores private files.
• External Storage stores public files.
• Data can also be stored in JSON, XML files.
• Helps choose correct storage based on app need.
• Ensures long-term data persistence.
• Provides secure and reliable data management.

 

 :: Best of Luck ::

MCA 1 Android Using Kotlin Unit 4 - User Interface Elements

Prepared By : Prof. Uday Shah (HOD-IT) 

 Unit 4 - User Interface Elements

1. TextView.. 1

2. Button. 2

3. ImageButton. 3

4. EditText 3

5. CheckBox. 3

6. RadioButton. 4

7. RadioGroup. 4

8. AutoCompleteTextView.. 5

9. Spinner. 5

10. ImageView.. 6

11. ProgressBar. 7

12. Dialogs. 7

13. Snack Bar. 8

14. Navigation Bar. 8

15. App Bars (Top and Bottom) 9

Top App Bar (Toolbar) 9

Bottom App Bar. 9

16. Option Menu. 10

17. Context Menu. 10

18. Adapters. 11

19. ListView.. 12

20. ScrollView.. 12

 

 1. TextView

• TextView is a UI element used to display text on the screen.
• It is non-editable, meaning users cannot change its value.
• Commonly used for labels, headings, descriptions, titles, etc.
• Can display dynamic text using Kotlin, e.g., textView.text = "Hello".
• Supports styling such as text size, color, bold, italic, font family.
• Allows alignment like center, left, right.
• Can display multi-line text with android:lines.
• Supports HTML-formatted text using Html.fromHtml().
• Allows drawable icons on left/right/top/bottom.
• Highly used in every Android layout.
• Lightweight and fast to render.
• Works well inside ConstraintLayout, LinearLayout, etc.
• Can be made clickable if needed.
• Uses XML tag <TextView>.

 

 2. Button

• A Button performs an action when the user taps it.
• Used for submitting forms, saving data, navigating screens, etc.
• Displays text like “OK”, “Submit”, “Login”.
• OnClick event is handled in Kotlin using:
• button.setOnClickListener { }
• Supports background color, shape, borders, gradients.
• Buttons can have icons using compound drawables.
• Material Design offers enhanced MaterialButton for modern styles.
• Provides ripple effect on click.
• Buttons can be enabled/disabled using button.isEnabled.
• Can change text dynamically from Kotlin.
• Supports accessibility features like content description.
• Used inside any layout easily.
• Can use custom fonts.
• Declared using the <Button> tag.

 3. ImageButton

• ImageButton is similar to Button but uses an image instead of text.
• Good for actions like call, camera, delete, refresh, etc.
• Uses images from drawable folder.
• Supports click actions same as normal button.
• Can be styled using tint and background attributes.
• Helps create minimal, icon-based UI.
• Often used in toolbars and navigation bars.
• Supports ripple effect on touch.
• Should include contentDescription for accessibility.
• Can use vector images (SVG) for scalable icons.
• ImageButton can be circular or rounded using shape drawable.
• Declared using <ImageButton> tag.
• Can load dynamic images during runtime.
• More visually appealing than text-only buttons.

 4. EditText

• EditText is a text input field for user input.
• Used for entering name, email, password, number, etc.
• Supports input types like text, number, password, email, phone.
• XML property android:hint shows placeholder text.
• Get entered text in Kotlin using:
• val name = editText.text.toString()
• Can restrict input length using maxLength.
• Supports validation and error messages.
• Keyboard type changes automatically based on input type.
• Supports multi-line input.
• Allows styling: borders, background, padding.
• Can show/hide password using transformation methods.
• Can disable autocomplete or suggestions.
• Supports custom fonts and colors.
• Declared using <EditText>.

 5. CheckBox

• CheckBox allows selecting multiple options.
• Users can turn it ON or OFF.
• Commonly used for preferences like "Remember Me" or settings.
• Check state in Kotlin:
• if (checkBox.isChecked) { }
• Supports click and check-change listeners.
• Can have custom icons and colors.
• Multiple checkboxes operate independently.
• Useful in forms, surveys, filters.
• Provides better accessibility with labels.
• Can be used inside LinearLayout or ConstraintLayout.
• Can set default checked state in XML.
• Lightweight and easy to use.
• Declared using <CheckBox> tag.

 6. RadioButton

• RadioButton allows user to select only one option from a group.
• Used for gender selection, payment mode, etc.
• Must be placed inside a RadioGroup.
• Selecting one automatically deselects others in same group.
• Get selected value in Kotlin using checkedRadioButtonId.
• Supports click listener for actions.
• Can be styled with custom icons or shapes.
• Useful in forms that require single-choice input.
• More user-friendly than dropdowns for short lists.
• Can be checked/unchecked programmatically.
• XML tag is <RadioButton>.
• Label text can be styled.
• Consumes less space than multiple buttons.

 7. RadioGroup

• RadioGroup is a container for grouping RadioButtons.
• Ensures only one radio button is selected.
• Automatically manages selection behavior.
• XML example:
• <RadioGroup>
•     <RadioButton .../>
• </RadioGroup>
• Can be vertical or horizontal.
• Get selected option ID using radioGroup.checkedRadioButtonId.
• Useful in signup forms, settings, filters.
• RadioGroup helps improve UI consistency.
• Supports programmatic selection.
• Can clear selection using clearCheck().
• Provides spacing and alignment.
• Works well inside any layout.
• Ensures clean and simple UI for choosing one option.

 8. AutoCompleteTextView

• AutoCompleteTextView suggests options while typing.
• Helps users type faster.
• Requires an ArrayAdapter to supply suggestions.
• Example:
• val adapter = ArrayAdapter(this, android.R.layout.simple_list_item_1, list)
• autoText.setAdapter(adapter)
• Useful for searching cities, names, products.
• Shows dropdown below the input field.
• Can limit suggestions using threshold value.
• Styling can be applied to dropdown list.
• Supports custom adapters for advanced suggestions.
• Works well with large datasets.
• Supports filtering automatically.
• Declared using <AutoCompleteTextView>.
• Improves user experience for long inputs.

 9. Spinner

• Spinner is a dropdown list for single selection.
• Suitable for country list, state list, category selection, etc.
• Uses an adapter to populate items.
• XML tag <Spinner>.
• Kotlin example:
• spinner.adapter = ArrayAdapter(this, android.R.layout.simple_spinner_item, list)
• Displays selected value at top.
• Opens a dialog-like dropdown when clicked.
• Saves screen space compared to RadioButtons.
• Can use custom layout for items.
• Supports OnItemSelectedListener for actions.
• Default first item can be set.
• Can display icons along with text.
• Material Spinner available using libraries.

 10. ImageView

• ImageView displays an image on screen.
• Supports PNG, JPG, SVG, and vector images.
• XML:
• <ImageView android:src="@drawable/pic" />
• Can scale image using scaleType.
• Supports tinting, transparency, padding.
• Used for logos, banners, icons, backgrounds.
• Can load online images with Glide/Picasso.
• Can apply animations.
• Supports placeholders and error images.
• Works well in RecyclerView and GridView.
• Allows touch events if needed.
• Can clip images to shapes (circle, rounded).
• Highly important in UI design.

 11. ProgressBar

• ProgressBar shows loading or ongoing tasks.
• Two types: Indeterminate, Determinate.
• Indeterminate shows spinning circle.
• Determinate shows progress percentage.
• XML:
• <ProgressBar android:indeterminate="true"/>
• Used during downloads, uploads, login, API calls.
• Visibility controlled in Kotlin:
• progressBar.visibility = View.VISIBLE
• Can customize color and size.
• Helps improve user experience during waiting.
• Can show horizontal bar style.
• Suitable for background processes.
• Should hide when task is done.
• Compatible with Material Design components.

 12. Dialogs

• Dialogs appear as small windows above the screen.
• Used for confirmation, warning, message, input.
• Types: AlertDialog, Custom Dialog, DatePicker, TimePicker.
• Example:
• AlertDialog.Builder(this)
•     .setTitle("Exit")
•     .setMessage("Are you sure?")
•     .setPositiveButton("Yes", null)
•     .show()
• Dialogs grab user’s attention.
• Can have positive, negative buttons.
• Support custom layout designs.
• Used for form inputs, alerts, options.
• Can be cancelable or non-cancelable.
• Should be used carefully to avoid overuse.
• Follow Material Design guidelines.
• Provide good user interaction handling.

 13. Snack Bar

• SnackBar shows a quick message at the bottom of screen.
• More advanced than Toast.
• Includes optional action button.
• Example:
• Snackbar.make(view, "Message Sent", Snackbar.LENGTH_LONG).show()
• Disappears automatically after few seconds.
• Useful for undo, retry actions.
• Follows Material Design.
• Can customize background and text color.
• Does not interrupt user activity.
• Appears above bottom navigation bar.
• Shows short, important messages.
• Lightweight and modern alternative to Toast.

 14. Navigation Bar

• Navigation Bar allows navigating between major app sections.
• Usually placed at bottom (BottomNavigationView).
• Contains 3–5 icons with labels.
• Example: Home, Search, Profile, Settings.
• XML tag for Material Navigation bar.
• Supports selected/unselected states.
• Works with fragments for screen switching.
• Provides modern, user-friendly navigation.
• Used in most modern apps (Instagram, YouTube).
• Supports badges for notifications.
• Can use vector icons from resources.
• Connects with NavController for navigation graph.
• Helps organize app structure effectively.

 15. App Bars (Top and Bottom)

Top App Bar (Toolbar)

• Top bar showing title, logo, menu icons.
• Replaces ActionBar in modern apps.
• Supports navigation icon (hamburger/back).
• Used to place search, settings menus.
• Can apply custom colors and styles.
• Works with fragments and navigation component.
• XML: <Toolbar> or <MaterialToolbar>.
• Supports elevation (shadow).
• Can host custom views.

 Bottom App Bar

• Placed at bottom of screen.
• Supports FAB (Floating Action Button).
• Can display menu icons.
• Good for apps needing bottom navigation layout.
• Provides modern material design UI.
• Helps improve reachability on large screens.

 

 16. Option Menu

• The Option Menu appears in the top-right corner of an Activity, usually as three vertical dots.
• It is used to display common actions like Settings, Help, Logout, About, etc.
• Created using a menu XML file inside the res/menu folder.
• Inflated in the activity using onCreateOptionsMenu() method.
• Handles click events using onOptionsItemSelected().
• Example XML:
• <menu>
•     <item android:id="@+id/settings" android:title="Settings"/>
• </menu>
• Example Kotlin:
• override fun onOptionsItemSelected(item: MenuItem): Boolean {
•     if (item.itemId == R.id.settings) { }
•     return super.onOptionsItemSelected(item)
• }
• Option Menu is global across the screen, not tied to any specific view.
• Can add icons using android:icon.
• Very useful for actions that need to be available anywhere in the Activity.
• Supports submenus using <menu> inside an item.
• Follows Material Design menu styles automatically.
• Works with Toolbar and AppCompatActivity.
• Used by many apps (Chrome, Gmail) for app-wide settings.

 17. Context Menu

• A Context Menu appears when the user long-presses a view.
• Used for actions related to a specific item like Copy, Paste, Edit, Delete, etc.
• Must register a view using:
• registerForContextMenu(myView)
• Implemented using onCreateContextMenu() method.
• Click actions handled using onContextItemSelected().
• Context Menu is contextual, meaning it applies only to the selected view or item.
• Best used in ListView items, text fields, and images.
• XML format is similar to option menu.
• Example: Long press text → Show: Copy, Share, Select All.
• Supports icons, labels, shortcuts.
• Works well for actions that are not used frequently.
• Helps reduce clutter in the UI.
• More interactive than Option Menu because it works on user-selected items.
• Follows Android Material patterns automatically.

18. Adapters

• An Adapter acts as a bridge between UI components and data list.
• Converts data (array, list, database) into Views for ListView, Spinner, RecyclerView.
• Common adapters: ArrayAdapter, SimpleAdapter, BaseAdapter, RecyclerView.Adapter.
• ArrayAdapter example:
• val ad = ArrayAdapter(this, android.R.layout.simple_list_item_1, items)
• listView.adapter = ad
• Adapters help load large data efficiently.
• Used to map data to layouts item by item.
• Can use custom layouts inside adapters for better design.
• Essential for dynamic UI like lists, grids, dropdowns.
• Provide smooth scrolling when optimized.
• BaseAdapter allows complete customization.
• RecyclerView.Adapter is preferred for modern apps.
• Adapters reuse views to save memory (ViewHolder technique).
• Without an adapter, ListView/Spinner cannot display data.
• Strongly used in all Android applications involving dynamic content.

 19. ListView

• ListView displays a scrollable vertical list of items.
• Requires an Adapter to supply data.
• XML tag:
• <ListView android:id="@+id/listView"/>
• Commonly used for contact list, student list, product list, etc.
• Uses ArrayAdapter for simple lists.
• Supports custom item layouts using custom adapters.
• Handles item click using:
• listView.setOnItemClickListener { parent, view, pos, id -> }
• Good for small to medium lists.
• Automatically scrolls when content is lengthy.
• Lightweight and easy to implement.
• Predecessor to RecyclerView (RecyclerView is more advanced).
• Supports fast scroll bar.
• Can load images, text, buttons inside each row.
• Allows selection modes like single/multiple.
• Still used in many apps for simple lists.

 20. ScrollView

• ScrollView allows vertical scrolling of a large layout.
• Used when the content does not fit on the screen.
• Can contain only one direct child, usually a LinearLayout.
• XML Syntax:
• <ScrollView>
•     <LinearLayout>
•         <!-- Long content -->
•     </LinearLayout>
• </ScrollView>
• Ideal for forms, long pages, text content, or statements.
• Provides smooth scrolling experience.
• Automatically enables scrolling—no need for extra code.
• Supports nested layouts like images, buttons, edit texts.
• Does not support horizontal scroll unless using HorizontalScrollView.
• Optimized for long content that doesn’t require repeated rows.
• Must avoid putting ListView/RecyclerView inside ScrollView (bad performance).
• Supports scroll listeners for animations.
• Can jump to specific position programmatically.
• Works well with ConstraintLayout and LinearLayout.