Is Python Case Sensitive When Dealing with Identifiers?

DevOps & Cloud Engineering
Internship Assurance
DevOps & Cloud Engineering

Yes, Python is a case-sensitive programming language. Python sees the lowercase and uppercase letters differently. Being a high-level and dynamic language, it asks the users to avoid using the same name in different cases while naming identifiers. Web development, data analysis, machine learning, and scripting are a few examples of what tasks can be achieved using Python programming language.


In this article, we will go through in detail how is Python case-sensitive when dealing with identifiers. We will see the rules for identifiers and naming conventions, in this article, along with the best practices that a Python developer should follow while creating a program or developing an application.


What is Python?


Python stands as a high-level programming language — not to mention a powerful one — that offers effective high-level data structures and an uncomplicated introduction to the object-oriented paradigm. While Python is recognised for its easy-to-understand syntax, it also excels in the world of object-oriented programming effectiveness and dynamic typing.


What do you mean by Case Sensitivity?


Case sensitivity refers to the rule or a property in which the text written in lower case and upper case letters are treated differently. For example, the difference between ‘T’ and ‘t’ is significant in case-sensitive settings, which means that ‘Hello’, ‘hello’, and ‘HELLO’ would be regarded as distinct entities. Programming languages like Python follow the case sensitivity approach. In other words, case sensitivity is a feature that distinguishes between uppercase (capital) and lowercase letters.


Rules for Identifiers in Python


Python, being a popular programming language amongst current-time developers and programmers, has its own set of rules or grammar to name its identifiers. These rules help in easily identifying different variables, names, functions, etc., between hundreds and thousands of items. They are essential for writing clear and maintainable code.


Specific guidelines about character usage, letter case, capitalisation, and reserved words must be adhered to when naming identifiers in Python. Here are some of the common and significant rules to be followed while naming identifiers in Python:

  • Keyword restriction: Python consists of various reserved keywords like while, for, if, etc., therefore don’t use these reserved words while naming an identifier.
  • Case Sensitivity: Identifiers are case sensitive; therefore, words like ‘Hello’, ‘hello’, and ‘HELLO’ are all treated differently, so always keep them in mind.
  • Alphabetic and Numeric Characters: While naming an identifier in Python, it can contain letters (from a-z or A-Z), digits (0-9), and underscores (_).
  • Beginning character: The beginning of a character cannot start either with an underscore (_) or a digit. For example, _hello or 3hello both are invalid identifiers.
  • No leading digit: An identifier cannot start with a digit while naming its identifier. For example, ‘3isNumber’ is not a valid identifier in Python. If done, you will see an error.
  • Length: In Python, there is no limit provided explicitly, but to have better readability and understanding, it is advised to keep the identifiers in short length;

Naming Identifiers in Python


Naming identifiers is a crucial step, as Python is a case-sensitive language. This indicates that the language makes a difference between characters used in identifiers that are capital and lowercase. While naming identifiers, certain conventions are to be followed in Python:


1. For Variables


To define the variables in Python, there is a certain naming convention that needs to be followed. For example, to define:


  • Constant variable
    Constants are variables that are intended to be immutable and should not be changed throughout the program. By convention, constant variable names are written in all uppercase letters with words separated by underscores.


For example:

VAL_PI = 3.14


  • Global variable
    Global variables are variables that are available across a module or script and are defined at the top level of the module. Global variable names are often written in lowercase letters with underscores between words. For global variables, some developers do, however, also utilise CamelCase or mixed case.


For example:

global_var = “hello world”

path = “C://disk”


  • Private variable

Private variables shouldn’t be accessible directly from outside of the class or module in which they are defined; instead, they should only be utilised within it. Private variable names often begin with a single underscore. To prevent name conflicts in subclasses, a double underscore can be utilised, resulting in name mangling, if greater privacy is required.


For example:



2. For Functions


Functions in Python are defined using lowercase words separated by underscores. This is known as snake_case. Functions in Python are not like other high-level programming languages including Java, C++, JavaScript, etc.




def find_area(radius_circle):

return 2 * 3.14 * radius_circle


def get_input():

user_in = input(“Enter the radius: “)

return user_in


3. For class names


Python class names adhere to the CapWords convention, which is also referred to as PascalCase or CamelCase. According to this standard, words are concatenated without any separators, and their initial letter is capitalised (like Aa).




class MyClass:

def _init_(self, val):

self.val = val


class ParentClass:

def _init_(self, value):

self.value = value


4. For packages


Python package names must be written entirely in lowercase characters. Although they are usually avoided, underscores (_) might be used if necessary to improve readability. It’s also typical to give packages brief, snappy names.






Also Read: lambda function in python

DevOps & Cloud Engineering
Internship Assurance
DevOps & Cloud Engineering

Importance of Case Sensitivity


The following best practices should be taken into consideration when using identifiers in Python:


1. Adhere to naming conventions


Respecting accepted naming conventions contributes to readability and consistency in the code. According to PEP 8 (which describes the style guidelines for the C code in the C implementation of Python), Python’s naming conventions consist of the following:


  • Variables: To define the variables, always use underscores to separate lowercase words. For example, my_name.
  • Functions: To define functions in Python, always use underscores to separate lowercase words. For example, my_are_calculator.
  • Classes: While defining the classes, always use CamelCase. For example, ParentClass, ChildClass, etc.


2. Consider the Situation


Be careful when using the case for identifiers in Python because of its case sensitivity. Maintain name consistency to prevent misunderstandings and mistakes.


3. Avoid naming conflicts


Be clear of naming identifiers with case-only differences. This can avoid inadvertently overwriting variables or functions and improve the readability of the code.


4. Use Descriptive Names


Choose descriptive names for identifiers to convey their purpose. Avoid single-character names or overly abbreviated names unless they are commonly understood. For example, while creating a loop, use i for an index.


5. Maintain Consistency


Consistently use the same case for similar identifiers throughout your codebase. This helps maintain a coherent structure and improves readability.


Examples of Python Identifiers


Now that we have learned the naming convention and rules for identifiers in Python. To have a better understanding, let’s see some of the examples of valid and invalid identifiers in Python:

Valid Identifiers


  1. my_count: This variable contains only letters in lowercase; therefore, it is valid.
  2. my_count_1: This variable contains letters of lowercase along with the digits; therefore, it is valid.
  3. _: This variable contains only underscore; therefore, it is valid.
  4. _89: This variable contains only digits and is not a leading character; therefore, it is valid.
  5. MyValid: This function contains letters of lowercase and uppercase; therefore, it is valid.
  6. _my_private: This variable contains only letters in lowercase and underscore; therefore, it is valid.
  7. MAX_LIMIT: This variable contains only letters in uppercase; therefore, it is valid.

Invalid Identifiers

  1. 8count: This variable is leading from a digit; therefore, it is invalid.
  2. 4000: This variable contains only digits; therefore, it is invalid.
  3. p+q: This variable contains special characters; therefore, it is invalid.
  4. while: This variable is a reserved word or keyword; therefore, it is invalid.

Common Pitfalls and How to Avoid Them


Notwithstanding its advantages, case sensitivity can sometimes result in some typical mistakes, particularly for inexperienced users. It’s essential to comprehend these traps and know how to avoid them to program Python effectively.


1. Typographical errors: Typographical errors are among the most frequent errors related to typos, incomplete words, incomplete characters, etc. Unintentionally employing the incorrect case can result in NameError errors. For example:


myName = “Hello World”



# Output: NameError: myname is not defined


2. Inconsistent Meaning: Confusion and difficulty reading and maintaining the code might result from inconsistent naming. Like if you have already defined a function name with some convention and later you used some other function name, it will result in an error and imply inconsistency. For example:


def findArea():



def findarea():



In the given example, it is confusing which code is valid and which is not. So, always follow Python’s PEP-8 naming conventions.


3. Shadowing: Shadowing may be seen when you use those identifiers that differ only in the case of built-in Python functions or keywords, and they can cause unexpected behaviour. For example:


list = [‘A’, ‘B’, ‘C’]

List = list  # It is called an unintended shadowing


4. Refactoring issues: Sometimes, programmers tend to refactor some parts of code, like refactoring a function name may result in an error. For example:


def findArea():



def find_area():





# Output: NameError: name findArea is not defined


In this example, we have refactored the function findArea() with another function name. Now when we try to call this function with its original name, it will give us a name error (NameError).



In this article, we have seen that Python is case-sensitive when dealing with identifiers. We saw when naming an identifier, we have to follow and adhere to some rules of identifiers in Python, so that code becomes clear, readable, maintainable, etc. Naming identifiers for defining global, private, and constant variables, functions, class names, etc, were also discussed in this article. Python’s case sensitivity can be efficiently utilised by developers to construct legible and resilient programs by adhering to best practices, avoiding common errors, and keeping context in mind.



Yes, Python is a case-sensitive programming language as it treats uppercase and lowercase letters differently. Python is a very format-oriented language meaning you need to have proper indentation, casing, etc., while writing any program.
Python's case sensitivity enables more eloquent and informative identifiers. In large projects in particular, this aids in preserving clarity and avoiding naming conflicts in the program and application code. Additionally, it is consistent with the behaviour of a large number of other programming languages, which facilitates language switching for developers.
In Python, functions are created using the snake_case (like my_area) naming convention for identification, whereas classes are created using CamelCase (like MyFunction) for easy distinguishing.
In Python, package names should only contain lowercase letters. While underscores can be added to make names easier to read, they are usually not recommended. Package names should be brief and to the point to preserve clarity and simplicity. Mypackage, for instance, is favoured over my_package.
Yes, key values used in the Python dictionary are case-sensitive.

Book a free counselling session


Get a personalized career roadmap

Get tailored program recommendations

Explore industry trends and job opportunities

left dot patternright dot pattern

Programs tailored for your Success


Data Science




Future Tech

Upskill with expert articles
View all
Hero Vired logo
Hero Vired is a leading LearnTech company dedicated to offering cutting-edge programs in collaboration with top-tier global institutions. As part of the esteemed Hero Group, we are committed to revolutionizing the skill development landscape in India. Our programs, delivered by industry experts, are designed to empower professionals and students with the skills they need to thrive in today’s competitive job market.

Data Science

Accelerator Program in Business Analytics & Data Science

Integrated Program in Data Science, AI and ML

Accelerator Program in AI and Machine Learning

Advanced Certification Program in Data Science & Analytics


Certificate Program in Full Stack Development with Specialization for Web and Mobile

Certificate Program in DevOps and Cloud Engineering

Certificate Program in Application Development

Certificate Program in Cybersecurity Essentials & Risk Assessment


Integrated Program in Finance and Financial Technologies

Certificate Program in Financial Analysis, Valuation and Risk Management


Certificate Program in Strategic Management and Business Essentials

Executive Program in Product Management

Certificate Program in Product Management

Certificate Program in Technology-enabled Sales

Future Tech

Certificate Program in Gaming & Esports

Certificate Program in Extended Reality (VR+AR)

Professional Diploma in UX Design

In the News
About Us
Contact us
Learning Hub
18003093939     ·     ·    Whatsapp
Privacy policy and Terms of use

© 2024 Hero Vired. All rights reserved