beginner Python tutorial – TechWithArpana

Installation, Uninstallation and File-Path Management in Jupyter Notebook Beginner-Friendly Notes, Worked Examples and Practice Questions for B.Pharm Students Learning sequenceUnderstand -> Choose -> Install -> Import -> Use -> Verify -> Save Educational note: All medicine, laboratory and quality-control values are simulated only for programming practice. They are not clinical instructions or official product specifications. Learning Outcomes Define module, package, library, standard library, third-party package and dependency. Differentiate between standard-library modules and third-party libraries. Select an appropriate library for a basic pharmacy-data task. Install, update, inspect and uninstall packages from a Jupyter Notebook. Explain why %pip is safer than !pip inside a notebook. Check the Python interpreter, installed-package location and package version. Find and change the kernel working directory. Create project, data and output folders with pathlib. Save CSV, Excel and chart files to an explicit project folder. Recognize common installation, import and path errors. 1. Key Definitions TermSimple definitionModuleA single Python file containing reusable variables, functions or classes. Example: the standard-library module math.PackageA collection of related Python modules arranged in folders. A package can contain subpackages.LibraryA broad collection of reusable code for a purpose. In everyday teaching, library and package are often used informally as similar words.Standard libraryModules and packages distributed with Python. They normally require import, but not a separate pip installation.Third-party libraryReusable code developed outside the Python core project. It is installed separately, commonly from PyPI with pip or from conda channels.DependencyAnother package required by a package. For example, pandas depends on NumPy.Distribution packageThe name installed by pip or conda. It may differ from the import name; scikit-learn is installed but sklearn is imported.ImportThe instruction that loads a module or package into the current Python program or Jupyter kernel.KernelThe Python process that executes notebook code and keeps variables and imports in memory. 1.1 The Most Important Difference PointStandard libraryThird-party librarySourceSupplied with PythonDeveloped and distributed separatelyInstallationNormally no separate installationInstall using pip or condaUseImport and call its functionsInstall once, then import and useExamplesmath, statistics, datetime, pathlibNumPy, pandas, Matplotlib, SciPyUpdatesUsually follow the Python installationCan be updated independentlyPackage indexDocumented in Python docsOften published on PyPI or conda channels Remember: import math is correct. %pip install math is unnecessary and normally wrong because math belongs to the Python standard library. 1.2 Installation Name Can Differ from Import Name Install command nameImport statementMeaningscikit-learnimport sklearnMachine-learning toolsopencv-pythonimport cv2Computer-vision toolsPillowfrom PIL import ImageImage-processing toolsbeautifulsoup4from bs4 import BeautifulSoupHTML parsing tools Figure 1. Standard-library modules skip installation; third-party packages do not. 2. Python Standard Library Python's standard library provides reusable solutions for many everyday programming tasks, including mathematics, dates, files, folders, text processing, data formats and databases. These modules are available with a normal Python installation, although some may depend on the operating system. 2.1 Why We Use Standard-Library Modules They save time because common functions are already written and tested. They avoid unnecessary package installation for simple tasks. They make programs shorter, clearer and easier to maintain. They are documented on the official Python website. 2.2 Useful Standard-Library Modules for B.Pharm Exercises ModuleMain purposeSimple pharmacy/laboratory usemathMathematical functions and constantsRound the required number of boxes upward with math.ceilstatisticsMean, median, mode and spreadSummarize simulated tablet weightsdatetimeDates, times and time differencesCalculate days between two educational datesrandomPseudo-random simulationGenerate reproducible simulated observationspathlibModern file and folder pathsCreate data, output and chart foldersosOperating-system and directory operationsCheck or change the working directorycsvRead and write comma-separated filesStore a small batch tablejsonRead and write structured JSON dataSave settings or a simple product recordrePattern matching with regular expressionsCheck a simulated batch-code formatdecimalControlled decimal arithmeticDemonstrate exact decimal calculationssqlite3Small local relational databaseStore classroom inventory recordsloggingRecord program eventsCreate a learning audit trail for a script 2.3 Common Import Styles Import patterns # Import the complete moduleimport mathprint(math.ceil(12.2))# Import one required functionfrom statistics import meanprint(mean([10, 12, 14]))# Import a third-party package using a standard aliasimport pandas as pd Good practice: Import only what the program needs, place imports near the beginning of the notebook, and use familiar aliases such as np for NumPy, pd for pandas and plt for matplotlib.pyplot. 3. Third-Party Libraries A third-party library is not part of Python's core distribution. It must be installed in the environment used by the Jupyter kernel before it can be imported. Python's official package index is PyPI, while conda can obtain packages from configured conda channels. 3.1 Why and Where They Are Used Large numerical calculations: arrays, matrices and vectorized operations. Data analysis: read, clean, filter, group and summarize tables. Visualization: create line charts, bar charts, histograms and box plots. Statistics: distributions, tests, regression and model diagnostics. Machine learning: preprocessing, training, prediction and evaluation. File exchange: read or write Excel workbooks and other specialist formats. 3.2 Important Libraries for the B.Pharm Python Course Install nameImportUsed forExample educational usenumpyimport numpy as npFast numerical arrays and calculationsSimulated measurement arrayspandasimport pandas as pdTables, CSV/Excel and data cleaningBatch-wise data tablematplotlibimport matplotlib.pyplot as pltStatic and interactive plotsTrend or comparison chartseabornimport seaborn as snsHigh-level statistical graphicsDistribution plotscipyfrom scipy import statsScientific and statistical functionsDescriptive statisticsstatsmodelsimport statsmodels.api as smStatistical models and diagnosticsEducational regressionscikit-learnimport sklearnMachine learning workflowsTraining/testing demonstrationopenpyxlimport openpyxlRead and write modern Excel filesExport a classroom workbookjupyterlabNo normal importJupyterLab applicationInteractive notebooksipykernelNo normal importConnect a Python environment to JupyterSelect a project kernel 3.3 Which Library Should I Choose? If the task is...Start with...ReasonSimple mathematicsmathAlready in the standard libraryMean of a short Python liststatisticsSimple and no installationMany numerical valuesNumPyEfficient array calculationsRows and columnspandasDataFrame behaves like a data tableBasic chartMatplotlibFlexible plotting foundationStatistical distribution plotSeabornHigh-level statistical graphicsStatistical function or testSciPyLarge collection in scipy.statsRegression with detailed outputstatsmodelsStatistical model summariesPrediction or classificationscikit-learnConsistent machine-learning workflowCreate an .xlsx fileopenpyxl or pandasWorkbook control or table export 4. Installing, Updating and Uninstalling Libraries Best beginner choice in Jupyter: Use %pip rather than !pip. IPython's %pip magic runs pip in the current kernel environment, reducing the chance of installing into a different Python environment. 4.1 One-Time Course Package Installation Recommended pip command in Jupyter Notebook # Run in ONE Jupyter code cell.# Install only the package set needed for this course.%pip install numpy pandas matplotlib seaborn scipy statsmodels scikit-learn openpyxl Conda alternative inside Jupyter Notebook # If the active Jupyter kernel is a conda environment,# this is the equivalent conda-based course installation.%conda install numpy pandas matplotlib seaborn scipy statsmodels scikit-learn openpyxl -y Do not run both: Choose one main package manager for an environment. For an Anaconda environment, prefer conda for packages available there; use pip only when needed. Restart the kernel after installation if an import still fails. 4.2 Important pip Commands in Jupyter PurposeJupyter commandMeaningInstall%pip install pandasInstall the latest compatible pandasInstall several%pip install numpy pandas matplotlibInstall a selected groupUpgrade%pip install --upgrade pandasUpdate pandasSpecific version%pip install pandas==3.0.5Install an exact version when requiredMinimum version%pip install 'pandas>=3.0'Require at least a stated versionUninstall%pip uninstall -y pandasRemove pandas without a confirmation promptList%pip listShow installed distributions and versionsDetails%pip show pandasShow version, location and dependenciesOutdated%pip list --outdatedShow packages with newer releasesDependency health%pip checkReport broken or incompatible requirementsRecord environment%pip freezePrint exact installed versionsExport versions!{sys.executable} -m pip freeze > requirements.txtSave exact versions in the working directory; import sys firstInstall from file%pip install -r requirements.txtRecreate packages listed in a file Create requirements.txt in Jupyter Notebook # Save the active kernel's exact package versions to a file.import sysfrom pathlib import Path!{sys.executable} -m pip freeze > requirements.txtprint("Saved package list:", (Path.cwd() / "requirements.txt").resolve()) 4.3 Important conda Commands PurposeJupyter or Anaconda Prompt commandMeaningInstall%conda install pandas -yInstall into the active conda environmentUpdate%conda update pandas -yUpdate one packageRemove%conda remove pandas -yRemove one packageList packages%conda listShow packages in the active environmentList environmentsconda env listShow all conda environments; use in Anaconda PromptCreate environmentconda create -n bpharm_python python jupyterlab notebook ipykernel -yCreate an isolated teaching environmentActivateconda activate bpharm_pythonSwitch to the teaching environmentDeactivateconda deactivateLeave the current conda environment 4.4 Safe Uninstallation Procedure Confirm the active kernel and environment before removing anything. Check the package with %pip show package_name or %conda list. Remove only the intended package with %pip uninstall package_name or %conda remove package_name. Restart the Jupyter kernel. Run %pip check or re-import important packages to detect a broken dependency. Caution: Avoid casually uninstalling packages from Anaconda's base environment. A separate project environment is easier to repair and prevents one class project from disturbing another. 4.5 Optional: Create a Dedicated B.Pharm Environment Anaconda Prompt commands # Run these commands in Anaconda Prompt, not inside a normal Python cell.conda create -n bpharm_python python jupyterlab notebook ipykernel -yconda activate bpharm_pythonconda install numpy pandas matplotlib seaborn scipy statsmodels scikit-learn openpyxl -ypython -m ipykernel install --user --name bpharm_python --display-name "Python (BPharm)"jupyter notebook After Jupyter opens, select the kernel named Python (BPharm). Each environment has its own Python interpreter and installed third-party packages, while sharing Python's standard library with its base installation. 5. Important Commands in Jupyter Notebook Commands beginning with % are IPython line magics. Commands beginning with ! run a system shell command. Python statements such as Path.cwd() run normally in the kernel. 5.1 Package and Environment Commands CommandUse%pip install packageInstall a package into the current kernel environment%pip uninstall packageRemove a package%pip show packageShow version, dependencies and installation location%pip listList installed packages%pip checkCheck dependency consistency%conda install packageInstall with conda in a conda kernel%conda listList packages in a conda environmentimport sys; print(sys.executable)Show the Python interpreter used by the kernelimport sys; print(*sys.path, sep='\n')Show locations searched during importimport package; print(package.__file__)Show the imported package's source location 5.2 Working, Navigation and Help Commands CommandUse%pwdPrint the kernel working directory%cd pathChange the kernel working directory%lsList files and folders in the working directory%mkdir folder_nameCreate a folder from the shell; pathlib is more portable in Python code%whoList interactive variables%whosShow variables with type and summary information%historyDisplay previously entered commands%time expressionMeasure one execution%timeit expressionMeasure repeated executions%run filename.pyRun a Python script%matplotlib inlineDisplay Matplotlib figures inside classic notebook outputfunction_name?Show short help and signaturefunction_name??Show more detail and source when available%reset -fDelete user-created variables from the kernel; use carefully Important distinction: Use %pip for notebook package installation. !pip may call a different pip executable from the one connected to the current kernel. A reliable fallback is !{sys.executable} -m pip install package_name after importing sys. 5.3 Checking Versions and Installation Paths Inspection commands # Show the Python interpreter used by the current kernelimport sysprint("Python interpreter:", sys.executable)# Show a package version without depending on package.__version__from importlib.metadata import versionprint("pandas version:", version("pandas"))# Show the location of the imported packageimport pandas as pdprint("pandas file:", pd.__file__)# Show site-package foldersimport siteprint("Package folders:", site.getsitepackages()) The exact paths and version numbers differ between computers. The important check is that the interpreter path, pip installation location and imported package path belong to the same intended environment. 6. File Paths and Saving Files in Jupyter A path tells Python where a file or folder is located. A relative path begins from the kernel's current working directory. An absolute path identifies the complete location, such as D:\BPharm_Python\outputs on Windows. Figure 2. Jupyter server root, notebook location and kernel working directory are related but not identical. 6.1 Check Where Relative Files Will Be Saved Path check from pathlib import Path# The current working directory is the starting point for relative paths.current_folder = Path.cwd()print("Current working directory:", current_folder)# Show the absolute path that a relative filename would use.future_file = (current_folder / "results.csv").resolve()print("results.csv will be saved as:", future_file) Sample Windows output (your path will differ) Current working directory: D:\BPharm_Pythonresults.csv will be saved as: D:\BPharm_Python\results.csv 6.2 Recommended Project-Folder Structure Suggested folder arrangement BPharm_Python/|-- notebooks/ # .ipynb files|-- data/ # input CSV or Excel files|-- outputs/ # result tables|-- charts/ # saved figures|-- requirements.txt # optional package list`-- notes/ # supporting notes Keeping input data, output tables and charts in separate folders prevents accidental overwriting and makes the project easier to explain, back up and share. 6.3 Create and Use Project Folders Safely Recommended cross-platform setup from pathlib import Path# Create the main folder inside the current user's Documents folder.PROJECT_DIR = Path.home() / "Documents" / "BPharm_Python"DATA_DIR = PROJECT_DIR / "data"OUTPUT_DIR = PROJECT_DIR / "outputs"CHART_DIR = PROJECT_DIR / "charts"# parents=True creates missing parent folders.# exist_ok=True avoids an error if a folder already exists.for folder in (PROJECT_DIR, DATA_DIR, OUTPUT_DIR, CHART_DIR): folder.mkdir(parents=True, exist_ok=True)print("Project folder:", PROJECT_DIR.resolve())print("Output folder:", OUTPUT_DIR.resolve()) Most reliable method: Save every file using an explicit Path object, for example OUTPUT_DIR / 'summary.csv'. This is safer than depending only on the current working directory. 6.4 Change the Kernel Working Directory Python method from pathlib import Pathimport osproject_folder = Path.home() / "Documents" / "BPharm_Python"project_folder.mkdir(parents=True, exist_ok=True)# Change the working directory for the current kernel session.os.chdir(project_folder)print(Path.cwd()) Jupyter magic method # IPython magic alternative%cd "D:\BPharm_Python"%pwd Windows path rule: Use a raw string such as r'D:\BPharm_Python' or use forward slashes such as 'D:/BPharm_Python'. This prevents backslash sequences such as \n from being interpreted as special characters. 6.5 Make a Folder the Jupyter Browser Root The simplest method is to open Anaconda Prompt, change to the desired folder and then start Jupyter. Notebook 7 uses Jupyter Server; its root_dir setting controls the top folder visible in the Jupyter file browser. Start Jupyter in the desired root folder # Windows Anaconda Promptcd /d "D:\BPharm_Python"jupyter notebook# Direct current Jupyter Server optionjupyter notebook --ServerApp.root_dir="D:\BPharm_Python" For a permanent configuration, first run jupyter server --generate-config. Then edit the generated jupyter_server_config.py file and set c.ServerApp.root_dir = r'D:\BPharm_Python'. Make a backup of the configuration file before editing it. Notebook-file warning: Changing Path.cwd(), os.chdir() or %cd changes where relative data files are read and written. It does not move the open .ipynb notebook. Create or move the notebook through the Jupyter file browser and press Ctrl+S to save it there. 6.6 File-Saving Examples File typeCommand using an explicit output pathText(OUTPUT_DIR / 'note.txt').write_text('Completed', encoding='utf-8')CSV with pandasdf.to_csv(OUTPUT_DIR / 'summary.csv', index=False)Excel with pandasdf.to_excel(OUTPUT_DIR / 'summary.xlsx', index=False)Matplotlib chartplt.savefig(CHART_DIR / 'trend.png', dpi=200, bbox_inches='tight')JSONjson.dump(record, open(OUTPUT_DIR / 'record.json', 'w')) 7. Examples Every example follows the requested learning sequence. Run one example at a time in Jupyter Notebook. Install a third-party package only before the first example that requires it. Example 1: Calculate the Number of Containers with math Problem statement: A simulated packing exercise has 125 tablets and each container holds 10 tablets. Find the number of containers required without leaving unpacked tablets. Objective: Use the standard-library math module and understand why math.ceil rounds upward. Variables / formula / library: total_tablets = 125, capacity_per_container = 10, containers_required = math.ceil(total_tablets / capacity_per_container). Algorithm Import the math module. Store the total tablets and container capacity. Divide total tablets by capacity. Round the result upward with math.ceil. Display the number of containers. Commented Python program # math is part of the Python standard library.import mathtotal_tablets = 125capacity_per_container = 10# ceil() moves 12.5 upward to the next whole number.containers_required = math.ceil(total_tablets / capacity_per_container)print("Containers required:", containers_required) Sample output Containers required: 13 Interpretation: Twelve full containers hold 120 tablets, so one additional container is required for the remaining five tablets. No separate installation was needed. Example 2: Calculate Mean Tablet Weight with statistics Problem statement: Five simulated tablet weights are available in milligrams. Calculate their arithmetic mean. Objective: Use statistics.mean from the standard library for a short list of numerical values. Variables / formula / library: tablet_weights_mg = [500.2, 499.8, 500.1, 500.0, 499.9]; mean_weight_mg = mean(tablet_weights_mg). Algorithm Import mean from statistics. Store the simulated weights in a list. Calculate the mean. Display the result to two decimal places. Commented Python program # statistics is supplied with Python.from statistics import meantablet_weights_mg = [500.2, 499.8, 500.1, 500.0, 499.9]mean_weight_mg = mean(tablet_weights_mg)print(f"Mean tablet weight: {mean_weight_mg:.2f} mg") Sample output Mean tablet weight: 500.00 mg Interpretation: The simulated observations average 500.00 mg. This example demonstrates summary calculation only and does not apply an official acceptance limit. Example 3: Calculate Days Between Two Dates with datetime Problem statement: For a classroom record, calculate the number of days between 16 August 2026 and 28 February 2027. Objective: Use standard-library date objects and subtraction to obtain a time difference. Variables / formula / library: start_date and end_date are date objects; days_between = (end_date - start_date).days. Algorithm Import date from datetime. Create the start and end dates. Subtract the start date from the end date. Read the days property. Display the result. Commented Python program from datetime import datestart_date = date(2026, 8, 16)end_date = date(2027, 2, 28)days_between = (end_date - start_date).daysprint("Days between dates:", days_between) Sample output Days between dates: 196 Interpretation: The two classroom dates are 196 days apart. The program uses fixed simulated dates and is not an expiry or shelf-life decision system. Example 4: Generate Reproducible Simulated Readings with random Problem statement: Generate five simulated percentage readings between 98.5 and 101.5 and make the same values appear whenever the teaching cell is rerun. Objective: Use random.seed for reproducible classroom simulation. Variables / formula / library: seed = 42; simulated_readings contains five rounded random.uniform values. Algorithm Import random. Set a fixed seed. Generate five uniform values in the selected educational range. Round each value to two decimals. Display the list. Commented Python program import random# The fixed seed makes this classroom example reproducible.random.seed(42)simulated_readings = [ round(random.uniform(98.5, 101.5), 2) for _ in range(5)]print("Simulated readings:", simulated_readings) Sample output Simulated readings: [100.42, 98.58, 99.33, 99.17, 100.71] Interpretation: The readings are generated for programming practice. A fixed seed is useful when a teacher wants every student to reproduce the same output. Example 5: Create Project Folders and Save a Text File with pathlib Problem statement: Create a BPharm_Python project folder with an outputs subfolder and save a short status file there. Objective: Use pathlib to create folders and build a reliable output path. Variables / formula / library: project_dir, output_dir and status_file are Path objects. Algorithm Import Path. Build the project and output paths. Create the folders if they do not exist. Write a UTF-8 text file. Display the absolute saved path. Commented Python program from pathlib import Pathproject_dir = Path.home() / "Documents" / "BPharm_Python"output_dir = project_dir / "outputs"output_dir.mkdir(parents=True, exist_ok=True)status_file = output_dir / "status.txt"status_file.write_text("Practice completed", encoding="utf-8")print("Saved file:", status_file.resolve()) Sample output Saved file: C:\Users\Student\Documents\BPharm_Python\outputs\status.txt(Your user name and operating-system path will differ.) Interpretation: The file is saved in an explicitly created outputs folder. The same code works across Windows, macOS and Linux because pathlib joins path parts correctly. Example 6: Check the Active Kernel and a Package Installation Problem statement: A student installed pandas but still sees ModuleNotFoundError. Check which Python interpreter the kernel uses and whether pandas is visible there. Objective: Diagnose an environment mismatch before reinstalling packages. Variables / formula / library: sys.executable shows the kernel interpreter; find_spec('pandas') returns package information or None. Algorithm Import sys and importlib.util. Display the active Python executable. Search for the pandas import specification. Display whether pandas is available. Install with %pip only if it is missing. Commented Python program import sysfrom importlib.util import find_specprint("Kernel Python:", sys.executable)pandas_spec = find_spec("pandas")print("pandas available:", pandas_spec is not None)# If False, run this in a separate cell:# %pip install pandas Sample output Kernel Python: C:\...\python.exepandas available: True(The interpreter path will differ.) Interpretation: True means the active kernel can locate pandas. If installation succeeded elsewhere but this result is False, the notebook is probably using a different Python environment. 8. Common Errors and How to Correct Them Error or symptomLikely reasonCorrectionModuleNotFoundErrorPackage is missing from the active kernel environmentCheck sys.executable, then use %pip install package_namepip installed it, but import failspip and the notebook use different Python interpretersUse %pip or !{sys.executable} -m pip%conda command failsKernel is not a conda environment or conda is unavailableUse %pip or open Anaconda PromptImport name not foundInstallation name differs from import nameExample: install scikit-learn but import sklearnFileNotFoundErrorFolder or file path does not existPrint Path.cwd(), inspect the path and create required foldersPermissionErrorThe program cannot write to the selected folderUse a user-owned Documents project folderInvalid Windows pathBackslashes formed escape sequencesUse pathlib, a raw string or forward slashesFile saved but cannot be foundA relative path used an unexpected working directoryPrint the resolved path or save with OUTPUT_DIR / filenameNew package still not recognizedOld package state remains in kernel memoryRestart the kernel and import againDependency conflictInstalled packages require incompatible versionsRead the error, use %pip check and consider a fresh environmentAccidentally overwrote a fileSame output filename was reusedUse clear filenames, date/version suffixes or confirm before replacing 9. Quick Revision Sheet NeedRememberUse a built-in capabilityCheck the Python standard library firstInstall in JupyterPrefer %pip install package_nameAnaconda environmentUse %conda when appropriate; avoid needless mixingCheck active Pythonimport sys; print(sys.executable)Check package details%pip show package_nameCheck working folderfrom pathlib import Path; print(Path.cwd())Create foldersPath(...).mkdir(parents=True, exist_ok=True)Save reliablyUse OUTPUT_DIR / 'filename.ext'Move the notebookUse the Jupyter file browser; changing cwd does not move itAfter installationRestart the kernel if import still fails Mini Glossary TermMeaningAliasA short import name, such as pd for pandasEnvironmentAn isolated Python installation and its packagesKernelThe process that executes notebook codeMagic commandAn IPython command beginning with % or %%PyPIThe Python Package Index used by pip to find distributionsDependencyA package required by another packageWorking directoryThe starting folder for relative file pathsAbsolute pathA complete path from a drive or filesystem rootRelative pathA path interpreted from the working directoryJupyter rootThe top directory exposed by the Jupyter server file browser 12. Official Websites and Documentation The commands and definitions in this chapter were checked against the following official documentation on 16 August 2026. Use official documentation when a command changes or a new software version is released. Python Standard Library: https://docs.python.org/3/library/ pip documentation: https://pip.pypa.io/en/stable/ Python Packaging User Guide: https://packaging.python.org/ Python Package Index (PyPI): https://pypi.org/ IPython magic commands: https://ipython.readthedocs.io/en/stable/interactive/magics.html Jupyter Notebook: https://jupyter-notebook.readthedocs.io/en/stable/ Jupyter Server configuration: https://jupyter-server.readthedocs.io/en/latest/other/full-config.html conda documentation: https://docs.conda.io/projects/conda/en/stable/ NumPy: https://numpy.org/doc/stable/ pandas: https://pandas.pydata.org/docs/ Matplotlib: https://matplotlib.org/stable/ Seaborn: https://seaborn.pydata.org/ SciPy: https://docs.scipy.org/doc/scipy/ statsmodels: https://www.statsmodels.org/stable/ scikit-learn: https://scikit-learn.org/stable/ openpyxl: https://openpyxl.readthedocs.io/ Next learning step: After mastering packages and paths, continue with basic string operations, conditional statements and loops. Reuse the same project folders and environment. Dr. Arpana ChaturvediFounder, Exceldemy 🎥 YouTube: @arpanachaturvedi9324🌐 Website: arpanachaturvedi.com📸 Instagram: @arpanaar📘 Facebook: Exceldemy

Tag: beginner Python tutorial

Python Libraries for Beginners – Standard vs Third-Party and pip Basics

Python String Operations – Basic Manipulation Techniques

Getting Started with Python: Variables, Data Types, Type Casting, and I/O Operations

Introduction to Python Programming – A Complete Guide to Installing Python and Setting Up Your Environment

Archives

Categories

Quick Links

Resources