Python - Basic Concepts

This page illustrates the basic concepts associated with Python Programming Language.

Variables

In Python, variables are fundamental for storing and manipulating data. A variable is a reserved memory location that holds a value, and each value in Python has a data type, such as numbers, strings, lists, etc.

Defining Variables:

• Variables are declared by assigning a value to a name using the assignment operator =

  variable_name = value

• Here, variable_name is the name you choose for the variable, and value is the data you want to store in it. For example:

  age = 25
  name = "Izabela Gautfrid"

• In the above code, age, and name are variable names. The values 25 and "Izabela Gautfrid" are assigned to these variables, respectively.

Data Types:

• Python automatically determines the data type of a variable based on the assigned value.

• Common data types include numbers (integers and floats) and strings (text).

• To create a string variable, enclose the text in double quotes "".

  city = "Boulder"

Naming Rules:

• Variable names must begin with a letter or an underscore _.

• Subsequent characters can be letters, numbers, or underscores.

• Variable names are case-sensitive.

• Certain names are invalid, for example names that begin with a number or contain hyphens or symbols.

Reassigning Variables:

• Python allows you to reassign variables to new values, even after they have been declared.

  age = 25 # Initial assignment
  print("Age:", age)
  age = 35 # Reassignment
  print("Updated Age:", age)

• It is best practice to use clear and distinct names to avoid accidentally overwriting variable values.

Variable Scope:

• Variables can be either global or local in scope.

• A global variable can be used throughout the program, while a local variable is limited to a specific function or method.

Assigning Multiple Values:

• Multiple variables can be assigned in a single line:

  x, y, z = 5, 10, 5

• The same value can be assigned to multiple variables:

  x = y = z = 1

Legal form of defining Variables

myvar = "Sai"
my_var = "Sai"
_my_var = "Sai"
myVar = "Sai"
MYVAR = "Sai"
myvar2 = "Sai"

Illegal form of defining Variables

-myvar = "John"
my-var = "John"
my var = "John"

Datatypes

In Python, data types classify the type of value a variable holds, influencing the operations that can be performed on it. Python's data types are implemented as classes, with variables being instances of these classes. Knowing data types is important because it helps to efficiently write code since the data type determines the values you can assign to a variable and the operations you can perform on it. There are several built-in data types in Python. Here's a list of common data types:

• Numeric: These represent numerical values.

  • int: Represents integers, which are whole numbers without a decimal point (e.g., 5, -10, 0)

  • float: Represents floating-point numbers, which are real numbers with a decimal point (e.g., 3.14, -0.001). They are accurate up to 15 decimal places

  • complex: Represents complex numbers, with both real and imaginary parts

• Text: Represents sequences of characters

  • str (String): Used for text or symbols (e.g., "Hello", "Python"). Strings are created using double quotes "" or single quotes ''

• Sequence: Represents ordered collections of items

  • list: Ordered and mutable (changeable) sequences of elements (e.g., [1, 2, "apple"])

  • tuple: Ordered and immutable (unchangeable) sequences (e.g., (1, 2, "apple")).

  • range: Represents a sequence of numbers, often used for iterations

• Mapping: Represents collections of key-value pairs

  • dict (Dictionary): Unordered collections of key-value pairs (e.g., {"name": "John", "age": 30})

• Set: Represents unordered collections of unique items

  • set: Unordered collections of unique elements (e.g., {1, 2, 3})

  • frozenset: Immutable sets

• Boolean: Represents truth values

  • bool: Represents either True or False, used for logical operations and decision-making

• Binary Types: Represents sequences of bytes

  • bytes: Immutable sequences of single bytes

  • bytearray: Mutable sequences of bytes

  • memoryview: Provides a view of the internal data of an object without copying

• None Type:

  • None: Represents the absence of a value or a null value1.

You can determine the data type of a variable using the type() function. Also, you can use constructor functions such as str(), int(), float(), etc. to specify the data type of a variable

Casting Variable Datatypes

Python has many built-in data types, and it also allows you to convert variables from one type to another through a process called type casting or type conversion. Casting can be implicit or explicit.

Implicit Casting:

• The Python interpreter automatically performs implicit type conversion without any user involvement.

• To avoid data loss, Python generally converts from a lower data type to a higher data type. For example, when you add an integer to a float, the integer is automatically converted to a float:

  y = 7 + 2.2
  print(y)
  # Output: 9.2
  print(type(y))
  # Output: <class 'float'>

Explicit Casting:

• Explicit type casting uses built-in functions to convert a variable's data type.

• int(): Converts a variable to an integer. It can convert a float to an integer by removing the decimals, or a string to an integer if the string represents a whole number.

  x = int(2.8) # Results in 2
  y = int("3") # Results in 3

• float(): Converts a variable to a floating-point number. It can convert an integer or a string (if the string represents a float or integer) to a float.

  x = float(1)   # Results in 1.0
  y = float("3") # Results in 3.0
  w = float("4.2") # Results in 4.2

• str(): Converts a variable to a string. It can convert various data types, including integers and floats, to strings.

  x = str("s1") # Results in 's1'
  y = str(2)   # Results in '2'
  z = str(3.0) # Results in '3.0'

When performing explicit type casting, data loss may occur because the object is forced to a specific data type.

Numbers in Python

Python supports three main numeric data types: integers (int), floating-point numbers (float), and complex numbers (complex)

• Integers (int): Represent whole numbers without a decimal point and can be positive or negative. In Python 3.x, integers have unlimited length.

  num1 = 5
  print(num1, 'is of type', type(num1))  
  # Output: 5 is of type <class 'int'>

• Floating-point numbers (float): Represent real numbers with a decimal point. They are accurate up to 15 decimal places.

  num2 = 5.42
  print(num2, 'is of type', type(num2))  
  # Output: 5.42 is of type <class 'float'>

• Complex numbers (complex): Represent numbers with a real and an imaginary part. The imaginary part is written with a j suffix.

  num3 = 8+2j
  print(num3, 'is of type', type(num3))  
  # Output: (8+2j) is of type <class 'complex'>

  You can also create complex numbers using the complex() function1. The first argument is the real part, and the second argument is the imaginary part.

  x = complex(1, 2)
  print(x)  # Output: (1+2j)

Type Conversion:

• int(): Converts a number or string to an integer. When converting a float to an integer, the decimal part is truncated.

  num1 = int(2.3)
  print(num1)  # Output: 2

• float(): Converts a number or string to a floating-point number.

  num3 = float(5)
  print(num3)  # Output: 5.0

• complex(): Converts a number or string to a complex number. If only one argument is passed, the imaginary part is 0j.

  c = complex(2)
  print(c)  # Output: (2+0j)
  num4 = complex('3+5j')
  print(num4)  # prints (3 + 5j)

  Note that when converting a string to a complex number, there should be no whitespace between the real and imaginary parts.

Python automatically converts between numeric types in certain operations, generally "up casting" in the order int to float to complex. However, you cannot directly convert a complex number to an int or float

Strings

In Python, a string is a sequence of characters that represents text and is a fundamental data type used for manipulating textual data. Strings are enclosed within single quotes ('...'), double quotes ("..."), or triple quotes ("""...""" or '''...''')

Basic examples:

string1 = "Python programming"
string2 = 'Python programming'

Multiline Strings:

• Multiline strings can be assigned to a variable using three quotes (""" or ''').

• Line breaks are included at the same position as in the code.

  a = """Lorem ipsum dolor sit amet,
  consectetur adipiscing elit,
  sed do eiusmod tempor incididunt
  ut labore et dolore magna aliqua."""
  print(a)

Strings are Arrays:

• Strings in Python are arrays of bytes representing Unicode characters.

• You can access elements of a string using square brackets [].

• Python does not have a character data type; a single character is simply a string with a length of 11.

  a = "Hello, World!"
  print(a[1]) #output: e

Looping Through a String:

• Strings are arrays, so you can loop through the characters using a for loop.

  for x in "banana":
      print(x)

Checking String Contents:

• You can check if a certain phrase or character is present in a string using the keyword in.

  txt = "The best things in life are free!"
  print("free" in txt) # Output: True

• The keyword not in can check if a phrase or character is NOT present in a string.

  txt = "The best things in life are free!"
  print("expensive" not in txt) # Output: True

Because strings are immutable, they cannot be changed after they are created. Operations on strings create new strings rather than modifying the existing ones