{"id":2706,"date":"2026-10-21T13:53:59","date_gmt":"2026-10-21T13:53:59","guid":{"rendered":"https:\/\/prwatech.in\/blog\/?p=2706"},"modified":"2026-10-22T02:44:24","modified_gmt":"2026-10-22T02:44:24","slug":"python-pandas-tutorial-for-beginners","status":"publish","type":"post","link":"https:\/\/prwatech.in\/blog\/python\/python-pandas\/python-pandas-tutorial-for-beginners\/","title":{"rendered":"Python Pandas Tutorial"},"content":{"rendered":"

Python Pandas Tutorial for Beginners: Series, DataFrames and Real Examples<\/b><\/strong><\/h1>\n

A marks sheet, a sales report, a list of customers. Most of the data you meet at work sits in rows and columns. Pandas is the Python library that handles such tables the way a spreadsheet would, but with code that you can repeat, test and share. Cleaning a column, joining two tables or finding the average by group takes one line.<\/p>\n

Pandas is the most used Python library for data analysis. It builds on NumPy, and libraries such as Matplotlib, Seaborn and scikit learn work with its tables directly. Learn pandas well, and you can read a file, fix it, summarise it and prepare it for a chart or a model.<\/p>\n

This tutorial takes you from installation to real work. We cover the two main structures, Series and DataFrame, then summary statistics, loops, text methods, window functions, SQL style queries and joins. We also look at missing data, and at what changed in pandas 3.0, which affects code written in older tutorials. Every example was run on pandas 3.0.5, and the output you see is the real output.<\/p>\n

What is Pandas in Python?<\/h2>\n

Pandas is a free, open source Python library for working with data. It was started by Wes McKinney in 2008, while he was a researcher at AQR Capital Management, and was released as open source in 2009. The name comes from panel data, a term from economics for data that follows the same things over time. It is also a play on Python data analysis.<\/p>\n

Pandas helps you do five main jobs with data: load it, clean it, change its shape, explore it and prepare it for modelling. It is used in finance, economics, science, marketing and many other fields.<\/p>\n

Features of Pandas<\/h3>\n
    \n
  • Loading data from CSV, Excel, SQL databases, JSON and more.<\/li>\n
  • Handling missing data with simple methods to find, fill or drop it.<\/li>\n
  • Reshaping data with pivot<\/code>, merge<\/code> and concat<\/code>.<\/li>\n
  • Selecting data by label or by position.<\/li>\n
  • Adding and removing columns in one line.<\/li>\n
  • Grouping data with groupby<\/code>, to count, add or average by category.<\/li>\n
  • Time series tools such as rolling averages and date ranges.<\/li>\n<\/ul>\n

    How to Install Pandas<\/h2>\n

    One command works on Windows, Mac and Linux. Open a terminal, or Command Prompt on Windows, and run:<\/p>\n

    \n
    terminal<\/div>\n
    pip install pandas<\/pre>\n<\/div>\n
    If pip<\/code> is not found, use python3<\/code> or py<\/code> before it, as in python -m pip install pandas<\/code>. Then check the version:<\/p>\n
    \n
    python<\/div>\n
    import pandas as pd\r\nimport numpy as np\r\n\r\nprint(pd.__version__)<\/pre>\n
    output<\/div>\n
    3.0.5<\/pre>\n<\/div>\n
    Your version may be a little different. The pandas 3.0 release notes say pandas 3 supports Python 3.11 and higher, and needs NumPy 1.26 or later. If you use PyCharm, you can also install it from File, then Settings, then your project, then Python Interpreter, and the plus button. The standard short name for pandas is pd<\/code>, and everybody expects it.<\/p>\n
    Data Structures in Pandas<\/h2>\n
    Pandas has two main data structures. A Series is one column of labelled values. A DataFrame is a table of rows and columns, and each column is a Series. Older tutorials also list Panel as a third structure, but Panel is gone, and we explain that below.<\/p>\n
    \"Python<\/div>\n
    Mutability<\/h3>\n
    The values inside both a Series and a DataFrame can be changed. A DataFrame can also grow, because you can add and remove columns. For a Series, treat the size as fixed, and build a new one with pd.concat<\/code> if you need more items.<\/p>\n
    Series in Pandas<\/h2>\n
    A Series is a one dimensional labelled array. Each value has a label, called the index. If you do not give labels, pandas uses 0, 1, 2 and so on. The syntax is pd.Series(data, index, dtype, copy)<\/code>.<\/p>\n
    Create a Series From a List<\/h3>\n
    \n
    python<\/div>\n
    marks = pd.Series([72, 88, 91, 65])\r\nprint(marks)<\/pre>\n
    output<\/div>\n
    0    72\r\n1    88\r\n2    91\r\n3    65\r\ndtype: int64<\/pre>\n<\/div>\n
    The left column is the index, and the right column is the values. The last line shows the data type, int64<\/code>.<\/p>\n
    Give the Index Your Own Labels<\/h3>\n
    \n
    python<\/div>\n
    marks = pd.Series([72, 88, 91, 65], index=[\"Asha\", \"Ravi\", \"Meena\", \"Kabir\"])\r\nprint(marks)\r\nprint(marks[\"Ravi\"])\r\nprint(marks.iloc[2])<\/pre>\n
    output<\/div>\n
    Asha     72\r\nRavi     88\r\nMeena    91\r\nKabir    65\r\ndtype: int64\r\n88\r\n91<\/pre>\n<\/div>\n
    Create a Series From a NumPy Array<\/h3>\n
    Pass the array to pd.Series<\/code>. Use brackets in print(s)<\/code>, because Python 3 needs them.<\/p>\n
    \n
    python<\/div>\n
    a = np.array([1, 4, 5, 6, 7])\r\ns = pd.Series(a)\r\nprint(s)<\/pre>\n
    output<\/div>\n
    0    1\r\n1    4\r\n2    5\r\n3    6\r\n4    7\r\ndtype: int64<\/pre>\n<\/div>\n
    Create a Series From a Dictionary<\/h3>\n
    The keys become the index. The order of the dictionary is kept, and the keys are not sorted.<\/p>\n
    \n
    python<\/div>\n
    d = {\"a\": \"add\", \"s\": \"sub\", \"d\": \"dvd\"}\r\ns = pd.Series(d)\r\nprint(s)<\/pre>\n
    output<\/div>\n
    a    add\r\ns    sub\r\nd    dvd\r\ndtype: str<\/pre>\n<\/div>\n
    Create a Series From a Single Value<\/h3>\n
    A single value is repeated to match the index.<\/p>\n
    \n
    python<\/div>\n
    s = pd.Series(4, index=[0, 1, 2])\r\nprint(s)<\/pre>\n
    output<\/div>\n
    0    4\r\n1    4\r\n2    4\r\ndtype: int64<\/pre>\n<\/div>\n
    Access Data in a Series by Position<\/h3>\n
    \n
    python<\/div>\n
    s = pd.Series([1, 4, 5, 6, 7])\r\nprint(s[2])\r\nprint(s.iloc[2])<\/pre>\n
    output<\/div>\n
    5\r\n5<\/pre>\n<\/div>\n
    Here the labels and the positions are the same, so both lines give 5. When the labels are words, as in the marks example, use .iloc<\/code> to be sure that you mean position, and use the label for the name.<\/p>\n
    DataFrames in Pandas<\/h2>\n
    A DataFrame is a two dimensional table. Each column can hold a different type. The syntax is pd.DataFrame(data, index, columns, dtype, copy)<\/code>. Note that the argument is columns<\/code> with an s, and that the NumPy function for a range of numbers is np.arange<\/code>.<\/p>\n
    Create a DataFrame From a List<\/h3>\n
    Pass the list, and name the column:<\/p>\n
    \n
    python<\/div>\n
    data = [9, 2, 3, 4, 5]\r\ndf1 = pd.DataFrame(data, columns=[\"value\"])\r\nprint(df1)<\/pre>\n
    output<\/div>\n
       value\r\n0      9\r\n1      2\r\n2      3\r\n3      4\r\n4      5<\/pre>\n<\/div>\n
    Create a DataFrame From a Dictionary<\/h3>\n
    This is the most common way. Each key is a column name, and each value is a list. A dictionary of single values fails:<\/p>\n
    \n
    python<\/div>\n
    pd.DataFrame({\"a\": \"add\", \"s\": \"sub\", \"d\": \"dvd\"})<\/pre>\n
    output<\/div>\n
    ValueError: If using all scalar values, you must pass an index<\/pre>\n<\/div>\n
    Use lists as the values, and pandas builds the table.<\/p>\n
    \n
    python<\/div>\n
    df = pd.DataFrame({\r\n    \"name\": [\"Asha\", \"Ravi\", \"Meena\", \"Kabir\"],\r\n    \"course\": [\"Python\", \"SQL\", \"Python\", \"Excel\"],\r\n    \"marks\": [72, 88, 91, 65],\r\n})\r\nprint(df)<\/pre>\n
    output<\/div>\n
        name  course  marks\r\n0   Asha  Python     72\r\n1   Ravi     SQL     88\r\n2  Meena  Python     91\r\n3  Kabir   Excel     65<\/pre>\n<\/div>\n
    You can also build a table from a list of dictionaries, where each dictionary is one row.<\/p>\n
    \n
    python<\/div>\n
    rows = [\r\n    {\"name\": \"Asha\", \"marks\": 72},\r\n    {\"name\": \"Ravi\", \"marks\": 88},\r\n]\r\nprint(pd.DataFrame(rows))<\/pre>\n
    output<\/div>\n
       name  marks\r\n0  Asha     72\r\n1  Ravi     88<\/pre>\n<\/div>\n
    Create a DataFrame From Series<\/h3>\n
    A dictionary of Series works well, and the rows are matched by their index labels. Where a label is missing, pandas fills it with NaN<\/code>.<\/p>\n
    \n
    python<\/div>\n
    d = {\r\n    \"one\": pd.Series([2, 3, 4], index=[\"a\", \"b\", \"c\"]),\r\n    \"two\": pd.Series([2, 3, 4, 5], index=[\"a\", \"b\", \"c\", \"d\"]),\r\n}\r\ndfs = pd.DataFrame(d)\r\nprint(dfs)<\/pre>\n
    output<\/div>\n
       one  two\r\na  2.0    2\r\nb  3.0    3\r\nc  4.0    4\r\nd  NaN    5<\/pre>\n<\/div>\n
    Create a DataFrame From a NumPy Array<\/h3>\n
    Pass a real NumPy array, with a list of column names:<\/p>\n
    \n
    python<\/div>\n
    arr = np.array([[1, 2, 3], [4, 5, 6]])\r\nprint(pd.DataFrame(arr, columns=[\"x\", \"y\", \"z\"]))<\/pre>\n
    output<\/div>\n
       x  y  z\r\n0  1  2  3\r\n1  4  5  6<\/pre>\n<\/div>\n
    Create a DataFrame From Another DataFrame<\/h3>\n
    To build one from another, pass it in. By default the data is not shared in pandas 3.0 because of copy on write, which we explain at the end.<\/p>\n
    \n
    python<\/div>\n
    copy_df = pd.DataFrame(df)\r\nprint(copy_df.equals(df))<\/pre>\n
    output<\/div>\n
    True<\/pre>\n<\/div>\n
    Add a Column<\/h3>\n
    Assign a Series to a new column name, or use existing columns. The rows are matched by index label, so the missing label d<\/code> gets NaN<\/code>.<\/p>\n
    \n
    python<\/div>\n
    dfs[\"three\"] = pd.Series([100, 200, 300], index=[\"a\", \"b\", \"c\"])\r\nprint(dfs)\r\ndfs[\"four\"] = dfs[\"one\"] + dfs[\"three\"]\r\nprint(dfs)<\/pre>\n
    output<\/div>\n
       one  two  three\r\na  2.0    2  100.0\r\nb  3.0    3  200.0\r\nc  4.0    4  300.0\r\nd  NaN    5    NaN\r\n   one  two  three   four\r\na  2.0    2  100.0  102.0\r\nb  3.0    3  200.0  203.0\r\nc  4.0    4  300.0  304.0\r\nd  NaN    5    NaN    NaN<\/pre>\n<\/div>\n
    Delete a Column<\/h3>\n
    There are three ways. del<\/code> is a statement, and pop<\/code> is a method that also gives back the column. The method drop<\/code> is worth knowing too, because it gives you a new table and leaves the old one as it is.<\/p>\n
    \n
    python<\/div>\n
    del dfs[\"one\"]\r\nprint(dfs)\r\npopped = dfs.pop(\"two\")\r\nprint(popped)\r\nprint(dfs)\r\nprint(dfs.drop(columns=[\"four\"]))<\/pre>\n
    output<\/div>\n
       two  three   four\r\na    2  100.0  102.0\r\nb    3  200.0  203.0\r\nc    4  300.0  304.0\r\nd    5    NaN    NaN\r\na    2\r\nb    3\r\nc    4\r\nd    5\r\nName: two, dtype: int64\r\n   three   four\r\na  100.0  102.0\r\nb  200.0  203.0\r\nc  300.0  304.0\r\nd    NaN    NaN\r\n   three\r\na  100.0\r\nb  200.0\r\nc  300.0\r\nd    NaN<\/pre>\n<\/div>\n