Python Basics: Values, Variables, and Expressions

A program is a sequence of instructions. The Python interpreter reads Python code and carries out those instructions. Use Python 3, where a call such as print("Hello") has parentheses.

Try a line in the shell

The interactive shell, or REPL (read–evaluate–print loop), shows >>> when it is ready for Python code. Type a statement after the prompt and press Enter. You do not type the >>> yourself.

>>> 3 + 4
7
>>> "hi"
'hi'

The shell shows an expression's value automatically. It puts quotes around a string to identify it as text. A ... prompt means a statement is unfinished and Python is waiting for more. For example, an opening parenthesis may still need its closing partner. Type exit() at a ready prompt to leave the shell.

The shell is useful for testing one expression. It can keep a command history, but that history is not a saved program. Put instructions you want to run together again in a script.

Save and run a script

A script is a plain-text file of code with the .py extension. Use a code editor such as IDLE, Thonny, or VS Code. IDLE comes with the standard Python distribution. A word processor can change straight quotes into curly quotes; those curly marks cannot delimit Python strings.

Enter these lines in the editor and save the script:

print("Hello, world!")
print("Welcome to Python.")

In IDLE, choose Run → Run Module, or press F5. The output is:

Hello, world!
Welcome to Python.

Python runs these statements from top to bottom. Each print() displays its text and moves to a new line. Reversing the statements reverses the output.

You can also run a saved script from a terminal. Open the folder containing your script, then enter the interpreter command followed by its saved name. On macOS or Linux, the command is usually python3 followed by the script name; Windows commonly uses python or py. The terminal's command starts the interpreter and tells it which script to run. That command belongs at the terminal prompt, not after Python's >>>. An online editor may provide a Run button instead.

Decide what needs printing

A script containing just 3 + 4 calculates a value but displays nothing. Write print(3 + 4) to show 7. Similarly, print("hi") displays the text without its surrounding quotes. The quotes belong to the code; they mark the start and end of the text.

Python is case-sensitive. print and Print are different names, so Print("hi") produces a NameError unless that separate name has been defined. Keep the spelling and capitalization of built-in names exactly as shown.

Leading spaces also have meaning. For these simple sequences of statements, start each statement at the left margin. A stray indentation before print("hi") can cause IndentationError: unexpected indent. Spaces inside the quoted text are different: Python prints those as part of the message.

A mistake in a program is a bug. Finding and fixing it is debugging. First identify what kind of problem you have: code Python cannot read, an operation that fails while running, or a result that is simply wrong.

Three kinds of problem

Python checks the syntax of the whole script before running it. A syntax error near the end prevents even the first line from running. A runtime error is different: earlier statements have already run, and their printed output stays visible.

For the average, division happens before addition. Python calculates 92 / 2 as 46.0, then adds 88 to get 134.0. The intended expression is (88 + 92) / 2, which gives 90.0. There is no error message because both expressions are legal. A hand calculation gives you something to compare with the program.

Read a traceback from the bottom

Suppose the code is:

name = "Ada"
print("Hello", nme)

The traceback ends with a message like NameError: name 'nme' is not defined. The last line names the error and explains what failed. Above it, Python shows the location, line number, and code. Compare nme with the name assigned earlier: name. Correcting that spelling makes the output Hello Ada.

The reported location is where Python noticed the problem. If a line looks correct, check the line before it too. An earlier missing quote or parenthesis can leave Python unable to understand what follows. Recent versions often point directly to the unmatched opening parenthesis.

Let the error type guide your search

• NameError: Python cannot find a name, as with pirnt, Print, or a variable used before assignment. Check spelling, capitalization, and line order.
• TypeError: the operation does not work with those types. "5" + 5 tries to join text and a number.
• ValueError: a conversion receives unusable content. int("abc") receives text, but the text does not describe an integer.
• ZeroDivisionError: a divisor is zero. Inspect the value used after /, //, or %.

For a SyntaxError, match every opening quote and parenthesis with a closing one. print('It's late') closes the string at the apostrophe in "It's"; use print("It's late"). Python 2 code such as print "hi" needs Python 3 parentheses: print("hi"). Retype curly quotation marks as straight ones. For unexpected indentation, remove the stray leading spaces.

Fix one problem, then run again. The first failure may have prevented Python from reaching a second one. Build a program a few lines at a time so each new failure has a small area to inspect.

Code tells Python what to do. A comment tells a person why the code does it or what a value means. Python ignores a comment when it runs the program.

Mark the comment clearly

A comment begins with # outside a string and continues to the end of that line. It can stand on its own or follow a statement:

# Convert a temperature from Fahrenheit to Celsius.
fahrenheit = 68
celsius = (fahrenheit - 32) * 5 / 9
print(celsius)  # Show the converted temperature.

The full-line comment explains the program's purpose. The inline comment follows code on the same line. PEP 8, Python's style guide, recommends at least two spaces before an inline # and one space after it. That spacing makes the boundary easy to see.

A hash mark inside quotes is ordinary text:

print("#1 is not a comment")  # This part is a comment.

The output is #1 is not a comment. Python reads the entire quoted string, including its hash mark, as data. It ignores the text after the later # because that mark is outside the quotes.

Explain meaning, not obvious steps

Compare these comments:

count = count + 1  # Add 1 to count.
attempts = attempts + 1  # One more failed login.

The first comment repeats an operation already visible in the code. The second adds a reason for the change. A reader now knows what an attempt counts. A clear name such as attempts also does some of the work that a vague name would leave to comments.

Useful comments explain a unit, a choice, or a purpose that the code alone does not make clear. For example, tax_rate = 0.08 # 8% sales tax connects a decimal rate with its meaning. If you later change that rate, check the comment too. A stale comment can send a reader in the wrong direction even when the code works.

Temporarily stop a line from running

To comment out a statement, put # in front of it:

print("Start")
# print("Checking this step")
print("Finish")

Only Start and Finish appear. Commenting out a line keeps it available while you test the program without it. Remove old disabled code when it no longer helps; otherwise a later reader has to guess whether it is still needed.

For a note spanning several lines, start each line with #:

# Read the temperature in degrees Fahrenheit.
# Keep the calculation in Celsius for the next step.

Triple-quoted text is different. A line such as """Convert a temperature.""" is a string expression, not a comment. Such strings can serve as documentation called docstrings in particular positions. Use # when you mean an ordinary comment. A string that nothing uses can remain invisible in a script, which can make it look like a comment even though Python reads it as a value.

A value is a piece of data, such as 42, 3.5, or "Ada". Every value has a type, which tells Python what kind of data it is. A literal is a value written directly in code. Its spelling matters: 7, 7.0, and "7" have different types.

Four basic types

A decimal point makes 2.0 a float even though its numerical value equals the integer 2. Quotes make "42" text even though the characters look like a number. The type follows the written value, not what a reader might use it for.

Boolean literals have a capital first letter and no quotes. True is a Boolean; "True" is a string. Lowercase true is a name, and using it without defining it gives NameError. A comparison can produce a Boolean: 3 < 5 evaluates to True.

Ask Python for the type

The built-in function type() reports the type of its argument. In the shell, these calls show:

>>> type(7)
<class 'int'>
>>> type(7.0)
<class 'float'>
>>> type("7")
<class 'str'>
>>> type(True)
<class 'bool'>

In a script, use print() to see those results:

print(type(42), type("42"))

This prints <class 'int'> <class 'str'>. The word class is part of Python's report; the names int and str identify the types.

Types change what operators mean

With numbers, + adds. With two strings, it joins text:

print(5 + 3)
print("5" + "3")

The first line prints 8. The second prints 53. The second expression has two text values, so Python joins their characters. It does not inspect the digit characters and decide to add them.

"5" + 5 raises TypeError: one operand is text and the other is an integer. Check types when an operation behaves differently from what you expect. In particular, the appearance of digits on the screen does not establish that the stored value is numeric.

Choose a type for the meaning

Use an integer for a count and a float for a measurement that can include a fraction. Keep an identifier such as a ZIP code as text. The string "02134" preserves the initial zero; that zero is part of the code's identity, not part of a calculation. Phone numbers can also contain punctuation worth preserving.

The shell may show 'Ada', while print("Ada") shows Ada. Both refer to the same text. The shell's quotes identify a string; print() presents the characters for a reader. Neither display changes the stored type.

Python has separate types for whole numbers and floating-point numbers. Writing them clearly prevents both syntax mistakes and less obvious changes to the data.

Write counts as integers

An integer has no fractional part. Write an int without a decimal point, as in 42, 0, or -7. Python's integers can grow as large as available memory allows, with no fixed-width limit. Integer addition, subtraction, and multiplication are exact. For example, 2 ** 100 gives the exact integer 1267650600228229401496703205376.

Do not use commas to group thousands. Write 1000000 or use underscores for readability: 1_000_000. The underscores do not change the value.

A nonzero decimal integer literal cannot begin with a zero. Writing 02134 is a syntax error. If those digits are an identifier whose first zero matters, write "02134" as text.

Write fractional quantities as floats

A float uses a decimal point or exponent notation. 3.5, 2.0, and -0.25 are floats. Python also accepts .5 and 5., meaning 0.5 and 5.0; writing the extra zero often makes them easier to read. Use floats for measurements such as temperature or distance and for introductory calculations with fractional prices.

Python code uses a decimal point. A comma separates values; it never marks the fractional part. For example:

x = 3.5
print(x)

prints 3.5, while x = 3,5 makes a pair of values, displayed as (3, 5). Likewise, x = 1,000 makes (1, 0), not one thousand. These statements can run, so the absence of an error message does not mean the number was written correctly.

Use scientific notation

The letter e means "times ten to the power of" in a number literal:

An exponent literal is a float even when its value is a whole number. The negative sign after e makes a negative exponent, so 2.5e-3 means 2.5 divided by 1,000.

Expect limited precision

Floats store numbers in binary with limited precision, typically about 15–17 significant decimal digits. Many decimal fractions, including 0.1, have no exact representation in that storage. As a result:

print(0.1 + 0.2)
print(round(0.1 + 0.2, 2))

prints 0.30000000000000004 and then 0.3. The tiny difference comes from the stored approximations. round(..., 2) rounds the result to two decimal places for display; it does not change how floats store values. Keep the original calculation until the end, then round the displayed result.

A sign can also be an operator. Unary minus changes the sign of one value: -7 is negative seven. In 5 - -3, the first minus subtracts and the second makes negative three, so the result is 8. Distinguish this sign from the negative exponent in a literal such as 2.5e-3.

A string is a sequence of characters: letters, digits, spaces, punctuation, and other symbols. Quotes tell Python where that sequence starts and ends. The characters inside are data, even if they look like Python code.

Choose matching quotes

Single quotes and double quotes make the same type, str. Both 'Ada' and "Ada" contain the same three characters. Start and finish a string with the same kind of quote.

Choose the outer quotes to make an inner quote easy to write:

print("It's late")
print('She said "hi"')

The output is:

It's late
She said "hi"

In print('It's late'), the apostrophe after It closes the string too early. Python then cannot read the rest of the statement. Using double outer quotes keeps the apostrophe inside the text.

Use an escape sequence

A backslash begins an escape sequence. These common sequences each stand for one character:

For example, print("Line 1\nLine 2") prints two lines. The backslash and n in the code together stand for a line break, not a visible letter n. Similarly, print('It\'s late') prints It's late: the escaped quote becomes a character without ending the string.

To print a literal backslash followed by a letter, write the doubled backslash. print("A\\B") displays A\B. The first backslash signals that the next backslash should be a character.

Keep line breaks or no characters

Triple quotes let one string span several physical lines. The line breaks become part of its value:

print("""Line one
Line two""")

This prints Line one and Line two on separate lines. Triple single quotes work too. Triple quotes still create a string; they do not make a # comment.

The empty string, "", has no characters. It differs from " ", which contains one space. That space may be hard to see in output, but it remains part of the data.

Tell text from an expression or name

Compare these statements:

name = "Ada"
print("3 + 4")
print(3 + 4)
print("name")
print(name)

The output is 3 + 4, then 7, then name, then Ada. Quotes make the first and third arguments literal text. Without quotes, Python evaluates a calculation or looks up a variable.

Forgetting quotes around a message such as Hello makes Python search for a name. If Hello has not been defined, print(Hello) raises NameError. Write print("Hello") when you want that word.

Strings can contain characters from many languages and symbols such as "café", "naïve", and "°F". Digits can appear alongside them: "Room 101" is text throughout. A digit character inside quotes does not become an integer.

A variable is a name that refers to a value in memory. An assignment statement connects a name on the left of = with the value of an expression on the right.

Read the right side first

In age = 30, Python evaluates 30, then makes age refer to that integer. The left side must be a valid place to assign a value. 30 = age is a syntax error: you cannot assign a new value to the literal 30.

The = sign means "assign." It does not ask whether two values are equal. Equality testing uses ==. Reading assignment as a direction of work makes statements such as x = x + 1 understandable: use the old x on the right, calculate the new value, then assign it to x on the left.

Consider a rectangle:

width = 4
height = 2.5
area = width * height
print(area)

After the first line, width refers to 4. After the second, height refers to 2.5. For the third line, Python looks up both current values and evaluates 4 * 2.5, producing 10.0. It assigns that result to area. The last line prints 10.0.

Assignment itself does not print the value. Use the name in a later print() call when you want to display it.

Assign before using a name

Python follows statement order. This code fails on the first line:

print(total)
total = 10

At that point, total has no value. The later assignment cannot supply a value to an earlier statement. Move total = 10 before print(total).

A shell can retain names from earlier experiments. A saved program should provide the assignments it needs in its own execution order, so its result does not depend on remembering what you typed earlier.

Reassign an existing name

Reassignment makes a name refer to a new value:

score = 10
score = 15

Now score is 15; the earlier 10 is no longer reachable through that name. For an update based on the old value:

x = 3
x = x + 1

The second line evaluates 3 + 1, then assigns 4 to x. There is no equation to solve and no contradiction.

A type belongs to the value, not permanently to the variable name. Python allows temp = 3 followed by temp = "three"; after that, type(temp) reports str. Keeping a name's meaning and expected type consistent usually makes a program easier to follow.

A copied value is not a future link

a = 5
b = a
a = 10
print(a, b)

This prints 10 5. At b = a, both names refer to the current integer 5. Reassigning a changes which value a refers to; it leaves b referring to 5. Likewise, storing width * height saves its result, not a formula that updates itself when width changes.

One statement can assign several names. a = b = 0 gives both names the value 0. In x, y = 1, 2, the values match the names by position, making x equal to 1 and y equal to 2.

A name needs to satisfy Python's grammar and help a person understand the program. These are separate tests: Python can accept a name that still makes the code hard to read.

Follow the naming rules

A variable name can contain letters, digits, and underscores. It cannot start with a digit, contain a space, or use punctuation such as a hyphen.

Python accepts letters from other alphabets too. English letters are a common choice for identifiers. Whatever letters you choose, keep the spelling consistent: age, Age, and AGE are three different names. Assigning age = 30 does not define Age.

Keep keywords and built-ins distinct

A keyword is reserved for Python's grammar. You cannot use it as a variable name. The hard keywords are:

False None True and as assert async await break class
continue def del elif else except finally for from
global if import in is lambda nonlocal not or pass
raise return try while with yield

You do not need to memorize the list before writing a program. For now, recognize that a name such as class is unavailable: class = 3 is a syntax error. Editors often show keywords in a special color.

Names of built-in functions, including print, input, int, str, type, sum, and max, are not keywords. Python allows you to assign to them, but that assignment hides the original function:

print = 5
print("hi")

The second line tries to call the integer 5 and raises TypeError. Choose a name describing your data, such as total, so the built-in stays available. Restarting a shell clears accidental replacements made during experiments.

Write names in a consistent style

PEP 8 recommends snake_case for variable names: lowercase words joined by underscores, as in hourly_rate and first_name. The underscore keeps a multiword name together without spaces.

A constant is a value you intend to keep unchanged. By convention, its name uses capital letters:

SALES_TAX_RATE = 0.08

Python does not lock that name. A later assignment can change it; the capitals communicate an intention to the reader.

Include meaning and units

hours_worked = 38 tells you more than h = 38. A name such as distance_miles or temp_f also identifies the unit, reducing the chance of using miles as if they were kilometers or Fahrenheit as if it were Celsius. Short names such as x and y work well for coordinates or a brief formula where their meanings are already clear.

Avoid nearly identical names such as total and totl. A typo may produce a NameError, or it may accidentally use a different existing variable. PEP 8 also discourages the single letters l, O, and I, which can look like digits. A few extra letters can make a calculation much easier to inspect.

An update uses a variable's current value to calculate its next one. Following each update in order lets you predict output and find logic errors before running the program.

Start a value before updating it

count = count + 1 adds one to the old count. That change is an increment. A variable collecting a running total is an accumulator; give it a starting value such as total = 0 before adding amounts.

Augmented assignment combines an operation with assignment. For numbers, x += 3 has the same effect as x = x + 3. The available forms include +=, -=, *=, /=, //=, %=, and **=.

score = 10
score -= 3
score **= 2
print(score)

The subtraction changes score to 7. The power then changes it to 49, which is printed. Without the starting assignment, an update would try to use an undefined name and raise NameError.

The chosen operator also affects type. Starting with n = 7, n /= 2 produces the float 3.5. Starting again with n = 7, n //= 2 produces the integer 3. Python has no ++ increment operator: x++ is invalid. Writing ++x applies unary plus twice and does not update x; use x += 1.

Trace one statement at a time

A trace table records variable values after each statement. Write one column per variable and one row per step:

price = 20
quantity = 3
total = price * quantity
price = 25
total += 5
print(total, price)

The output is 65 25. Changing price did not repeat the earlier multiplication. The variable total held the computed value 60; it was not a spreadsheet formula linked to price. Only its own later update changed it to 65.

For a hand trace, evaluate the right side using the row immediately above, then update the assigned name. Leave all other columns unchanged. Compare the prediction with the program's real output.

Preserve both values in a swap

Suppose a = 1 and b = 2. The attempt a = b followed by b = a gives 2 2. The first assignment loses access to the original a through that name, so the second line copies the new value back.

A temporary variable keeps the original value available:

a = 1
b = 2
temp = a
a = b
b = temp
print(a, b)

This prints 2 1. You can also write a, b = b, a. Python evaluates both values on the right before assigning either name on the left, so the original values are both available for the swap. Trace the temporary-variable version when you want to see exactly where each original value is preserved.

An expression evaluates to one value. It can be a single literal, a variable, or a combination such as 2 + 3. The + is an operator; the values it acts on are its operands.

Choose the operator

Python's arithmetic operators work as follows:

Write multiplication explicitly with *. Math notation such as 2x does not work as Python multiplication. Write 2 * x or 2 * (x + 1). With x = 1, 2(x + 1) tries to call the integer 2 as if it were a function and raises TypeError.

The power operator is **, not ^. For example, 7 ** 2 is 49, while 7 ^ 2 is 5 because the caret performs a different operation. A program can therefore run while calculating a result you did not intend.

Predict the type as well as the number

Division with / gives a float for integer operands even when the division is exact: 6 / 2 is 3.0. For an integer whole-group count, use //: 6 // 2 is 3.

With two integer operands, addition, subtraction, multiplication, floor division, and remainder give integer results. Nonnegative integer powers do too: 2 ** 10 gives the exact integer 1024. A negative exponent changes this: 2 ** -1 gives the float 0.5.

In ordinary arithmetic with an integer and a float, the calculation uses floating-point values. 3 + 4.0 gives 7.0; 7.0 // 2 gives 3.0. Floor division describes how the quotient is rounded, not a promise that its type is always int.

A fractional power can calculate a root of a positive number. 4 ** 0.5 gives 2.0, and 2 ** 0.5 gives approximately 1.4142135623730951.

Build a calculation from named values

A car travels 287 miles using 10.25 gallons:

miles = 287
gallons = 10.25
mpg = miles / gallons
print("Miles per gallon:", mpg)

The division calculates 28.0, so the output is Miles per gallon: 28.0. The names identify the quantities, and the printed label identifies the result's unit. Multiplying 28.0 * 10.25 recovers 287 miles, providing a check on the division.

A zero divisor fails for /, //, and %. For example, 10 / 0 raises ZeroDivisionError. Inspect a variable used as the divisor when that error occurs.

Spaces around operators do not change their meaning: 2+3 and 2 + 3 both give 5. Spaces around = and most operators make the parts easier to read. They cannot replace an operator; 2 x still does not mean multiplication.

Python does not simply calculate an expression from its left edge to its right edge. Precedence sets which operations happen first. Parentheses let you choose a different grouping or make the intended grouping clear.

Apply the levels in order

For the operators introduced here, use this order:

1. Parenthesized expressions.
2. Powers, **.
3. Unary signs, such as the minus in -x.
4. Multiplication and division operations: *, /, //, %.
5. Addition and subtraction: +, -.

For 3 + 4 * 2 ** 2, evaluate 2 ** 2 to get 4. The expression becomes 3 + 4 * 4. Multiplication gives 16, and addition gives 19. With (3 + 4) * 2 ** 2, the parenthesized sum is 7; the power is 4; the product is 28.

Operators on the multiplication/division level have equal priority. Work from left to right: 8 / 2 * 4 means (8 / 2) * 4, giving 16.0. Multiplication does not jump ahead of division. Likewise, 100 / 10 / 5 gives 2.0, and 10 - 4 - 3 gives 3.

Handle powers and signs carefully

Repeated powers group from right to left. 2 ** 3 ** 2 means 2 ** (3 ** 2). First 3 ** 2 gives 9; then 2 ** 9 gives 512. Grouping from the left would give 64, a different result.

A leading minus sign is applied after a following power: -2 ** 2 means -(2 ** 2) and gives -4. In (-2) ** 2, parentheses make negative two the base, so the result is 4. A minus after ** can belong to the exponent: 2 ** -1 gives 0.5.

Translate the whole grouping of a formula

An average requires adding both values before dividing by two:

average = (88 + 92) / 2

The sum is 180, then division gives 90.0. Without parentheses, 88 + 92 / 2 divides only 92 and gives 134.0.

A fraction bar also groups everything above and below it. A numerator containing a + b and a denominator containing c + d become (a + b) / (c + d). Leaving out either pair can change which terms are divided.

The same issue appears in a temperature conversion:

celsius = (98.6 - 32) * 5 / 9

The subtraction gives 66.6, multiplication gives 333.0, and division gives 37.0. Without the grouping, 98.6 - 32 * 5 / 9 gives 80.82222222222222.

Use the right grouping marks

Round parentheses group an expression. Square brackets and curly braces have other meanings in Python. For example, [2 + 3] * 4 produces [5, 5, 5, 5], not 20.

Parentheses around an operation that would happen first anyway leave the result unchanged: (2 * 3) + 1 and 2 * 3 + 1 both give 7. Parentheses that change the grouping can change the value: 2 * (3 + 1) gives 8. Add grouping where it makes the calculation's meaning easier to see.

Floor division and remainder answer two related questions: how many whole groups fit, and what remains after taking those groups. For nonnegative integer quantities, the pair is useful for time, money, packing, and digits.

Find the quotient and remainder together

17 // 5 gives 3, the number of full groups of five. 17 % 5 gives 2, the amount left over. The two results reconstruct the starting quantity:

print((17 // 5) * 5 + 17 % 5)

The expression gives 17: three groups of five plus two. More generally, for integers and a nonzero divisor, (a // b) * b + a % b equals a. Use that relationship to check both answers.

Split real quantities

For 135 minutes:

hours = 135 // 60
minutes = 135 % 60

There are 2 whole hours and 15 minutes left. The divisor is 60 because one hour contains 60 minutes. Dividing with / gives 2.25, which expresses fractional hours; it does not separately give the minutes left over.

The same structure works with a different group size:

The carton count is the number of full cartons. If you need a container for the leftover eggs too, that is a different question from how many full groups fit.

Use place value and parity

For a positive integer, dividing by ten separates its last digit. 1234 % 10 gives 4, and 1234 // 10 gives 123. Recombining 123 * 10 + 4 recovers 1234.

For any integer n, n % 2 is 0 when it is even and 1 when it is odd. This also works for negatives: -7 % 2 is 1. For integers and a positive divisor b, the remainder is in the range from 0 through b - 1.

Understand negative division

Floor division rounds down toward negative infinity, not toward zero. Since negative seven divided by two is negative 3.5, -7 // 2 gives -4. The remainder is then 1, because -4 * 2 + 1 equals -7.

A nonzero remainder has the divisor's sign. With a negative divisor, 7 % -2 gives -1, and 7 // -2 gives -4. These still reconstruct the original: -4 * -2 + -1 is 7.

This differs from converting a quotient with int(): int(-7 / 2) gives -3 because conversion truncates toward zero.

Both operators also accept floats. 7.5 // 2 is 3.0, and 7.5 % 2 is 1.5. They share the precedence level of * and /, so 5 * 3 + 17 % 5 gives 17. The % operator here means remainder, not percent: calculate 8 percent of a price with price * 0.08 or price * 8 / 100.

An operator's symbol is only part of its meaning. Python also uses the types of its operands. The + and * operators work with strings, but they perform text operations there.

Join strings with plus

Concatenation joins one string to the end of another:

print("ab" + "cd")
print("Hello" + "Ada")
print("Hello " + "Ada")

These lines print abcd, HelloAda, and Hello Ada. Concatenation adds no space by itself. The space in the third result comes from the final character of "Hello ".

Digit characters follow the same rule: "5" + "3" gives the string "53". Without quotes, 5 + 3 gives the integer 8. Choose numeric values when you mean arithmetic and strings when you mean text.

Repeat a string with multiplication

A string multiplied by an integer repeats its characters. "3" * 2 gives "33", while 3 * 2 gives 6. The repetition count can go on either side: 3 * "ab" gives "ababab". Repeating zero times gives the empty string, so "ab" * 0 is "".

A repetition count must be an integer. "ab" * 2.5 raises TypeError, as does "ab" * "cd". There is no fractional number of copies in this operation.

Combine operations in order

Multiplication has higher precedence than addition for these expressions too:

print("-" * 4 + "Menu" + "-" * 4)

First, each repetition creates "----". Then the additions join the three strings, producing ----Menu----. The order of the joins preserves the order of their characters.

For a calculation that becomes part of a string:

print("7" + str(3 * 2))

The inner arithmetic gives the integer 6. str(6) creates the string "6". Finally, concatenation produces "76". It does not produce 13, because the final + has two strings as operands.

Resolve incompatible types deliberately

"Age: " + 30 raises TypeError. Convert the integer before concatenating:

print("Age: " + str(30))

This produces Age: 30. Alternatively, print("Age:", 30) displays the two values with a space between them. That is the behavior of print() with separate arguments, not text addition.

Integers and floats can mix in ordinary arithmetic: 2 * 3.0 gives the float 6.0. Python does not similarly turn a numeric string into a number during +. If you need to calculate with "30", convert it to a numeric type first.

Subtraction does not work on these string operands. "10" - 3 raises TypeError, even though the characters 10 could describe a number. To predict a mixed expression, identify each operand's type, evaluate the higher-priority operations, and check the types again at the next operation. A conversion can change which rule the next operator follows.

Type conversion, also called casting, creates a value of a different type. The functions int(), float(), and str() let you choose the form needed by the next operation.

Keep the converted result

x = "42"
int(x)
print(type(x))

This still prints <class 'str'>. The conversion created an integer, but no assignment kept it. Write x = int(x) to make x refer to that integer, or assign it to a different name when you want to keep both forms.

Choose a numeric conversion

int() accepts a whole-number string, including an optional sign and surrounding spaces. int("42"), int("-12"), and int(" 42 ") produce 42, -12, and 42.

A decimal point in a string prevents direct integer conversion. int("3.5") and int("4.0") raise ValueError; so do int("abc") and int(""). The fact that 4.0 is mathematically whole does not make "4.0" an integer-form string.

float() accepts decimal text and exponent notation. float("3.5") gives 3.5, float("3") gives 3.0, and float("1e3") gives 1000.0. It also converts integers: float(7) gives 7.0. A decimal comma fails: float("3,5") raises ValueError.

Truncate or round on purpose

Converting a float to int drops its fractional part toward zero. int(3.99) gives 3, and int(-3.99) gives -3. It does not choose the nearest integer. To convert decimal text and then truncate, use int(float("3.5")), which gives 3.

round() chooses a nearest value. round(3.7) gives the integer 4; round(3.14159, 2) gives the float 3.14. The second argument sets the decimal places.

At an exact halfway point, Python chooses the even neighbor: round(2.5) gives 2, while round(3.5) gives 4. Decimal fractions stored as floats may not be exact halfway values. round(2.675, 2) gives 2.67 because of its binary representation.

These operations answer different questions. Pick the operation that matches the intended result, especially when negative values are possible.

Convert to text for joining

str(42) produces "42", and str(3.0) produces "3.0". After conversion, + joins their characters:

print("7" + "3")
print(int("7") + int("3"))
print(str(7) + str(3))
print(float("7") + 3)

The outputs are 73, 10, 73, and 10.0. The conversions decide whether the final + receives text or numbers.

A ValueError points to unsuitable content for a conversion, such as int("abc"). A TypeError points to an operation incompatible with its operands, such as "5" + 5. Use that difference to decide whether to inspect the input text or change the operation.

print() displays values for a person to read. Its arguments are the values or expressions inside its parentheses. Commas separate the arguments; Python evaluates them before displaying their results.

Display values with useful labels

print("Total:", 5)
print(3 + 4)
print("3 + 4")

The lines show Total: 5, 7, and 3 + 4. A label tells the reader what a value means. An unquoted calculation is evaluated; a quoted expression is displayed as text.

By default, print() puts one space between arguments and finishes with a newline. It converts each value for display, so print("Total:", 5) can mix text and an integer without an explicit str().

Compare print("Total:" + str(5)), which prints Total:5. Here the + builds one string before print() receives it. Concatenation supplies no automatic space, and there is only one argument to display.

Set the separator

The named argument sep sets the text placed between arguments:

print("a", "b", sep="-")
print(1, 2, 3, sep=", ")
print("A", 12, sep="")

The output is:

a-b
1, 2, 3
A12

Use the name sep. Writing print("a", "b", "-") supplies a third value, so the result is a b -. An empty separator joins the displayed arguments directly; it does not remove spaces already inside their strings.

Set the ending

The named argument end changes what follows the last value. It is a newline by default. An empty ending keeps the next output on the same line:

print("a", end="")
print("b")

This shows ab on one line. You can include punctuation and a newline together:

print("Hello,", "Ada", end="!\n")

The output is Hello, Ada! followed by a new line. sep applies between arguments within one call; end applies after that call's final argument. They control different locations.

Add line breaks and choose displayed precision

Calling print() with no arguments prints an empty line. A \n inside a string creates a line break within that string, as in print("Line 1\nLine 2"). Repeated text can form a separator: print("=" * 20) displays twenty equals signs.

Python displays a float in a short form that represents its stored value. print(1 / 3) shows 0.3333333333333333. To display a rounded value, calculate it first inside the call: print(round(1 / 3, 2)) shows 0.33.

Rounding does not promise a fixed number of visible decimal places. round(2.50, 2) displays as 2.5, because the float does not store trailing zeros as a display instruction. Use the output exactly as Python produces it when checking a program.

input() displays a prompt, waits for someone to type and press Enter, then returns the typed text as a string without the Enter. A complete short program reads the needed data, processes it, and displays a result.

Read text and convert numbers

name = input("What is your name? ")
print("Hello", name)

The space at the end of the prompt separates the typed answer from the question. The variable stores text exactly as text, even when the user types digits. Typing 30 into input() produces "30", not the integer 30.

Choose a conversion before arithmetic:

age = int(input("Age in whole years: "))
print("Next year:", age + 1)

The inner input() runs first. If the user types 30, it returns "30"; int() converts that to 30; the assignment keeps the integer. The addition then produces 31.

Use float(input(...)) when fractional values are allowed. A prompt should say what kind of answer is expected. Entering 2.5 or thirty for an int() conversion raises ValueError. Entering 98,6 for a float() conversion also fails; the decimal separator must be a point.

Missing conversion does not always raise an error. If two input calls receive 5 and 3, their unconverted values add as strings and produce 53. Both operands have a type that supports +, but it is the wrong operation for adding quantities.

Work through a complete calculation

The input–process–output pattern keeps the main stages easy to inspect:

# Convert a temperature from Fahrenheit to Celsius.
fahrenheit = float(input("Temperature in °F: "))
celsius = (fahrenheit - 32) * 5 / 9
print(fahrenheit, "°F is", round(celsius, 1), "°C")

With input 98.6, the program reads the float 98.6. It subtracts 32 to get 66.6, multiplies by 5 to get 333.0, and divides by 9 to get 37.0. The displayed line is 98.6 °F is 37.0 °C. Input 50 becomes 50.0, so the line is 50.0 °F is 10.0 °C.

Here is a program with integer data:

total_minutes = int(input("Enter a whole number of minutes: "))
hours = total_minutes // 60
minutes = total_minutes % 60
print("Hours:", hours, "Minutes:", minutes)

Input 135 produces Hours: 2 Minutes: 15. The labels work for zero, one, and larger results without changing the wording. The two processing lines use the same original total; assigning hours does not remove anything from total_minutes.

Test ordinary and boundary values

Choose inputs with answers you can calculate by hand. For the temperature program, 32 should produce 0.0 °C and 212 should produce 100.0 °C. For minutes, test 0, 59, and 60: these check the starting value and the change from no full hour to one full hour.

Also test a typical value such as 135. Compare the exact labels, spacing, numerical results, and types with your prediction. If the code runs but the result is wrong, trace the stored values and the order of operations. If a conversion fails, inspect the typed text and the type your prompt requests.