Understanding Python Variables: Concepts, Scope, Lifecycle, and Practical API Testing Examples

Introduction

In Python, variables are identifiers used to store data values. They act as containers for any supported data type such as integers, floats, strings, lists, dictionaries, etc.

Basic Concepts

Naming Rules: Variable names may contain letters, digits, and underscores, cannot start with a digit, are case‑sensitive, and should be meaningful for readability.

Assignment: Use the equal sign (=) to assign a value; Python is dynamically typed, so the type is determined by the assigned value.

Scope: Determines where a variable can be accessed. Python has local (function) and global (module) scopes.

Lifecycle: A variable exists within its defining scope and is destroyed when it goes out of scope or is no longer referenced, allowing garbage collection to reclaim memory.

Examples

Basic variable definitions and usage:

# 定义一个整数变量
age = 25
# 定义一个字符串变量
name = "Alice"
# 定义一个列表变量
hobbies = ["reading", "coding", "traveling"]
# 打印变量的值
print(age)       # 输出: 25
print(name)      # 输出: Alice
print(hobbies)   # 输出: ['reading', 'coding', 'traveling']

Reassigning a variable:

age = 25
print(age)  # 输出: 25
age = 30
print(age)  # 输出: 30

Scope demonstration:

x = 10  # 全局变量

def example():
    y = 5  # 局部变量
    print(y)  # 输出: 5
    print(x)  # 输出: 10
example()
print(x)  # 输出: 10
# print(y)  # 报错：NameError: name 'y' is not defined

Lifecycle illustration:

def func():
    z = 42
    print(z)  # 输出: 42
func()
# print(z)  # 报错：NameError: name 'z' is not defined

Variable references (objects are shared):

a = [1, 2, 3]
b = a  # b 引用与 a 相同的对象
print(a is b)  # 输出: True
b.append(4)
print(a)  # 输出: [1, 2, 3, 4]

Summary

Variables are the basic units for storing data in Python; proper naming, scope awareness, and understanding of lifecycle and reference behavior are essential for clear and efficient code.

Advanced Example: Using Variables in API Automation Testing

Example 1 – Managing Test Data with Dictionaries

import requests
# 测试数据
test_data = {
    "valid_user": {
        "username": "testuser",
        "password": "testpass",
    },
    "invalid_user": {
        "username": "nonexistentuser",
        "password": "wrongpass",
    }
}

def test_login_endpoint():
    login_url = "https://api.example.com/login"
    for case_name, data in test_data.items():
        response = requests.post(login_url, data=data)
        if case_name == "valid_user":
            assert response.status_code == 200
        else:
            assert response.status_code == 401

test_login_endpoint()

Example 2 – Managing Environment Configuration with Class Attributes

import requests
class Config:
    BASE_URL = "https://api.example.com"
    TEST_TOKEN = "test-token"
    PROD_TOKEN = "prod-token"
    @staticmethod
    def get_auth_header(env):
        if env == "test":
            return {"Authorization": f"Bearer {Config.TEST_TOKEN}"}
        elif env == "prod":
            return {"Authorization": f"Bearer {Config.PROD_TOKEN}"}
        else:
            raise ValueError("Invalid environment.")

class APIClient:
    def __init__(self, env):
        self.base_url = Config.BASE_URL
        self.headers = Config.get_auth_header(env)
    def make_request(self, endpoint, method="GET", **kwargs):
        url = f"{self.base_url}/{endpoint}"
        response = requests.request(method, url, headers=self.headers, **kwargs)
        return response

client = APIClient("test")
response = client.make_request("data")
assert response.status_code == 200

Example 3 – Managing Status Codes with Enums

from enum import Enum
import requests
class StatusCode(Enum):
    OK = 200
    CREATED = 201
    BAD_REQUEST = 400
    UNAUTHORIZED = 401
    NOT_FOUND = 404
    INTERNAL_SERVER_ERROR = 500

def test_status_codes():
    url = "https://api.example.com/status"
    valid_response = requests.get(url + "/200")
    assert valid_response.status_code == StatusCode.OK.value
    invalid_response = requests.get(url + "/404")
    assert invalid_response.status_code == StatusCode.NOT_FOUND.value

test_status_codes()

Example 4 – Managing Test Results with Class Methods

import requests
class TestResults:
    results = {}
    @classmethod
    def record_result(cls, test_name, passed=True):
        cls.results[test_name] = passed
    @classmethod
    def display_results(cls):
        for test_name, passed in cls.results.items():
            status = "Passed" if passed else "Failed"
            print(f"{test_name}: {status}")

def test_api_endpoint():
    url = "https://api.example.com/data"
    response = requests.get(url)
    if response.status_code == 200:
        TestResults.record_result("test_api_endpoint")
    else:
        TestResults.record_result("test_api_endpoint", passed=False)

test_api_endpoint()
TestResults.display_results()

Example 5 – Managing Test Environment with a Context Manager

import requests
class TestEnvironment:
    def __init__(self, base_url):
        self.base_url = base_url
    def __enter__(self):
        print("Setting up test environment...")
        return self
    def __exit__(self, exc_type, exc_val, exc_tb):
        print("Tearing down test environment...")

def test_api_with_environment():
    url = "https://api.example.com/data"
    with TestEnvironment(base_url=url) as env:
        response = requests.get(env.base_url)
        assert response.status_code == 200

test_api_with_environment()

These examples illustrate how variables can be leveraged in API automation testing to manage test data, configuration, status codes, results, and environment setup, improving script readability, maintainability, and reliability.