lesson1Title

lesson2Title

lesson3Title

lesson4Title

lesson5Title

lesson6Title

lesson7Title

lesson8Title

lesson9Title

lesson10Title

lesson11Title

lesson12Title

lesson13Title

lesson14Title

lesson15Title

lesson16Title

lesson17Title

lesson18Title

lesson19Title

lesson20Title

lesson21Title

pythonIntroStep1Chapter1Title

pythonIntroStep1Chapter2Title

pythonIntroStep1Chapter3Title

pythonIntroStep1Chapter4Title

# Example of using snake case: variables and functions
user_age = ""

def print_age(age):  # Naming the function print_age
    print(age, "years old.")

# Example of using camel case: classes
class UserInfo:  # Naming the class UserInfo
    def __init__(self, name, age):
        self.name = name
        self.age = age

# Creating an instance of the class
user = UserInfo("CodeBuddy", user_age)

# Output results
print("Name:", user.name)  # Name: CodeBuddy
print("Age:", user.age)    # Age: 25

# How to Name Variables and Functions Sensibly

In programming, it is recommended to follow consistent `Naming` conventions when deciding on names for variables and functions.

Since spaces aren’t allowed in variable or function names, naming conventions are used to combine multiple words into a single identifier.

There are several naming conventions for handling spaces, and in Python, the `snake_case` and `camelCase` conventions are predominantly used.

<br />

## Snake Case

Snake Case refers to a naming convention where words are connected by underscores (`_`) instead of spaces.

This style gets its name because the connected words with underscores resemble the shape of a snake.

In Python, Snake Case is primarily used for naming variables and functions.

```python title="Example of snake_case"
my_name = "CodeFriends" # Variable name

def my_function_name(): # Function name
    print("Hello, world!")
```

<br />

Variable and function names typically start with lowercase letters, and multiple words are connected using underscores.

In the above example, the variable name that holds My Name is declared as `my_name` with an underscore between `my` and `name`.

Similarly, the function name, My Function Name, is declared as `my_function_name`.

<br />

## Camel Case

Camel Case connects words by capitalizing the first letter of each word and is commonly used in Python to name classes, which are user-defined data structures.

Classes are a fundamental concept in programming and will be thoroughly covered in future lessons.

Camel Case comes in two forms: `lowerCamelCase`, where the first letter is lowercase, and `UpperCamelCase` (or PascalCase), where the first letter is capitalized.

The naming convention resembles a camel, hence the name Camel Case.

```python title="Example of camelCase"
# Example of UpperCamelCase
class UserInfo: # Class name: UserInfo
    # Define a class with age and name attributes
    def __init__(self, name, age):
        self.name = name
        self.age = age


# Example of lowerCamelCase (rarely used in Python)
def myMethodName():
    ...
```

<br />

## Coding Exercise

Try entering the highlighted code `user_age = 25` in the exercise screen.

In this example, the value 25 stored in `user_age` will be used as the `age` attribute when creating an instance of the UserInfo class.

Detailed explanations about classes will be provided in subsequent lessons.

In Python, snake_case is commonly used for writing variable and function names. This approach connects words with underscores to improve readability. For example, it is typically written as `my_variable`.

What naming convention is primarily used for writing variable and function names in Python?