Python – Variable Types

Course Curriculum

Python – Variable Types

Variables are nothing but reserved memory locations to store values. This means that when you create a variable you reserve some space in memory.
Based on the data type of a variable, the interpreter allocates memory and decides what can be stored in the reserved memory. Therefore, by assigning different data types to variables, you can store integers, decimals or characters in these variables.

Assigning Values to Variables

Python variables do not need explicit declaration to reserve memory space. The declaration happens automatically when you assign a value to a variable. The equal sign (=) is used to assign values to variables.
The operand to the left of the = operator is the name of the variable and the operand to the right of the = operator is the value stored in the variable. For example −

number_value = 900          # An integer assignment
floating_value   = 22.7      # A floating point
string_value   = "Prutor"       # A string
print (number_value)
print (floating_value)
print (string_value)

Here, 900, 22.7 and "Prutor" are the values assigned to counter, miles, and name variables, respectively. This produces the following result −

900
22.7
Prutor

Multiple Assignment

Python allows you to assign a single value to several variables simultaneously. For example −

x=y=z=100
print(z)

Here, an integer object is created with the value 100, and all three variables are assigned to the same memory location. You can also assign multiple objects to multiple variables. For example −

x,y,z=100,300,"Prutor"
print(z)
output: Prutor

Standard Data Types

The data stored in memory can be of many types. For example, a person's age is stored as a numeric value and his or her address is stored as alphanumeric characters. Python has various standard data types that are used to define the operations possible on them and the storage method for each of them.
Python has five standard data types −

  • Numbers
  • String
  • List
  • Tuple
  • Dictionary

    Python Numbers

    Number data types store numeric values. Number objects are created when you assign a value to them. For example −

    num1 = 100
    num2 = 200.222
  • Python supports four different numerical types −
  • int (signed integers)
  • long (long integers, they can also be represented in octal and hexadecimal)
  • float (floating point real values)
  • complex (complex numbers)

    Examples

    Here are some examples of numbers −

    int long float complex
    10 51924361L 0.0 3.14j
    100 -0x19323L 15.20 45.j
    -786 0122L -21.9 9.322e-36j
    080 0xDEFABCECBDAECBFBAEl 32.3+e18 .876j
    -0490 535633629843L -90. -.6545+0J
    -0x260 -052318172735L -32.54e100 3e+26J
    0x69 -4721885298529L 70.2-E12 4.53e-7j
  • Python allows you to use a lowercase l with long, but it is recommended that you use only an uppercase L to avoid confusion with the number 1. Python displays long integers with an uppercase L.
  • A complex number consists of an ordered pair of real floating-point numbers denoted by x + yj, where x and y are the real numbers and j is the imaginary unit.

    Python Strings

    Strings in Python are identified as a contiguous set of characters represented in the quotation marks. Python allows for either pairs of single or double quotes. Subsets of strings can be taken using the slice operator ([ ] and [:] ) with indexes starting at 0 in the beginning of the string and working their way from -1 at the end.
    The plus (+) sign is the string concatenation operator and the asterisk (*) is the repetition operator. For example −

    str = 'Hello World!'
    print str          # Prints complete string
    print str[0]       # Prints first character of the string
    print str[2:5]     # Prints characters starting from 3rd to 5th
    print str[2:]      # Prints string starting from 3rd character
    print str * 2      # Prints string two times
    print str + "TEST" # Prints concatenated string

    This will produce the following result −

    Hello World!
    H
    llo
    llo World!
    Hello World!Hello World!
    Hello World!TEST

    Python Lists

    Lists are the most versatile of Python's compound data types. A list contains items separated by commas and enclosed within square brackets ([]). To some extent, lists are similar to arrays in C. One difference between them is that all the items belonging to a list can be of different data type.
    The values stored in a list can be accessed using the slice operator ([ ] and [:]) with indexes starting at 0 in the beginning of the list and working their way to end -1. The plus (+) sign is the list concatenation operator, and the asterisk (*) is the repetition operator. For example −

    list = ['demo',567,3.6,'prutor',570.7]
    smallList = ['786','prutor.ai']
    print (list)          # Prints complete list
    print (list[0])       # Prints first element of the list
    print (list[1:3])     # Prints elements starting from 2nd till 3rd
    print (list[2:] )     # Prints elements starting from 3rd element
    print (smallList * 2)  # Prints list two times
    print (list + smallList) # Prints concatenated lists

    This produce the following result −

    ['demo', 567, 3.6, 'prutor', 570.7]
    demo
    [567, 3.6]
    [3.6, 'prutor', 570.7]
    ['786', 'prutor.ai', '786', 'prutor.ai']
    ['demo', 567, 3.6, 'prutor', 570.7, '786', 'prutor.ai']
    Value available at index 2 :
    3.6

    Python Tuples

    A tuple is another sequence data type that is similar to the list. A tuple consists of a number of values separated by commas. Unlike lists, however, tuples are enclosed within parentheses.
    The main differences between lists and tuples are: Lists are enclosed in brackets ( [ ] ) and their elements and size can be changed, while tuples are enclosed in parentheses ( ( ) ) and cannot be updated. Tuples can be thought of as read-only lists. For example −

    tuple = ('demo',567,3.6,'prutor',570.7)
    smallTuple = ('786','prutor.ai')
    tuple = ('demo',567,3.6,'prutor',570.7)
    smallTuple = ('786','prutor.ai')
    print (tuple)          # Prints complete tuple
    print (tuple[0])       # Prints first element of the tuple
    print (tuple[1:3])     # Prints elements starting from 2nd till 3rd
    print (tuple[2:] )     # Prints elements starting from 3rd element
    print (smallTuple * 2)  # Prints tuple two times
    print (tuple + smallTuple) # Prints concatenated tuples

    This produce the following result −

    ('demo', 567, 3.6, 'prutor', 570.7)
    demo
    (567, 3.6)
    (3.6, 'prutor', 570.7)
    ('786', 'prutor.ai', '786', 'prutor.ai')
    ('demo', 567, 3.6, 'prutor', 570.7, '786', 'prutor.ai')

    The following code is invalid with tuple, because we attempted to update a tuple, which is not allowed. Similar case is possible with lists −

    tuple = ('demo',567,3.6,'prutor',570.7)
    smallTuple = ('786','prutor.ai')
    tuple[2] = 1000    # Invalid syntax with tuple
    list[2] = 1000     # Valid syntax with list

    Python Dictionary

    Python's dictionaries are kind of hash table type. They work like associative arrays or hashes found in Perl and consist of key-value pairs. A dictionary key can be almost any Python type, but are usually numbers or strings. Values, on the other hand, can be any arbitrary Python object.
    Dictionaries are enclosed by curly braces ({ }) and values can be assigned and accessed using square braces ([]). For example −

    dictionary = {}
    dictionary['one'] = "This is one"
    dictionary[2]     = "This is two"
    tinydictionary = {'name': 'Prutor.ai','code':12345, 'dept': 'Tech'}
    print (dictionary['one'])       # Prints value for 'one' key
    print( dictionary[2])           # Prints value for 2 key
    print (tinydictionary)          # Prints complete dictionary
    print (tinydictionary.keys())   # Prints all the keys
    print (tinydictionary.values()) # Prints all the values

    This produce the following result −

    This is one
    This is two
    {'name': 'Prutor.ai', 'code': 12345, 'dept': 'Tech'}
    dict_keys(['name', 'code', 'dept'])
    dict_values(['Prutor.ai', 12345, 'Tech'])

    Dictionaries have no concept of order among elements. It is incorrect to say that the elements are "out of order"; they are simply unordered.

    Data Type Conversion

    Sometimes, you may need to perform conversions between the built-in types. To convert between types, you simply use the type name as a function.
    There are several built-in functions to perform conversion from one data type to another. These functions return a new object representing the converted value.

    Sr.No. Function & Description
    1 int(x [,base])

    Converts x to an integer. base specifies the base if x is a string.

    2 long(x [,base] )

    Converts x to a long integer. base specifies the base if x is a string.

    3 float(x)

    Converts x to a floating-point number.

    4 complex(real [,imag])

    Creates a complex number.

    5 str(x)

    Converts object x to a string representation.

    6 repr(x)

    Converts object x to an expression string.

    7 eval(str)

    Evaluates a string and returns an object.

    8 tuple(s)

    Converts s to a tuple.

    9 list(s)

    Converts s to a list.

    10 set(s)

    Converts s to a set.

    11 dict(d)

    Creates a dictionary. d must be a sequence of (key,value) tuples.

    12 frozenset(s)

    Converts s to a frozen set.

    13 chr(x)

    Converts an integer to a character.

    14 unichr(x)

    Converts an integer to a Unicode character.

    15 ord(x)

    Converts a single character to its integer value.

    16 hex(x)

    Converts an integer to a hexadecimal string.

    17 oct(x)

    Converts an integer to an octal string.

    https://prutor.ai/python/python_basic_operators.htm

    Python - Basic Operators

    Operators are the constructs which can manipulate the value of operands.
    Consider the expression 2010=200. Here, 20 and 10 are called operands and is called operator.

    Types of Operator

    Python language supports the following types of operators.

  • Arithmetic Operators
  • Comparison (Relational) Operators
  • Assignment Operators
  • Logical Operators
  • Bitwise Operators
  • Membership Operators
  • Identity Operators
    Let us have a look on all operators one by one.

    Python Arithmetic Operators

    Assume variable a holds 20 and variable b holds 30, then −

    Operator Description Example
    + Addition Adds values on either side of the operator. a + b = 50
    - Subtraction Subtracts right hand operand from left hand operand. a – b = -10
    * Multiplication Multiplies values on either side of the operator a * b = 600
    / Division Divides left hand operand by right hand operand b / a = 1.5
    % Modulus Divides left hand operand by right hand operand and returns remainder b % a =10
    ** Exponent Performs exponential (power) calculation on operators a**b =20 to the power 30
    // Floor Division - The division of operands where the result is the quotient in which the digits after the decimal point are removed. But if one of the operands is negative, the result is floored, i.e., rounded away from zero (towards negative infinity) − 9//2 = 4 and 9.0//2.0 = 4.0, -11//3 = -4, -11.0//3 = -4.0

    Python Comparison Operators

    These operators compare the values on either sides of them and decide the relation among them. They are also called Relational operators.
    Assume variable a holds 20 and variable b holds 30, then −

    Operator Description Example
    == If the values of two operands are equal, then the condition becomes true. (a == b) is not true.
    != If values of two operands are not equal, then condition becomes true. (a != b) is true.
    If values of two operands are not equal, then condition becomes true. (a b) is true. This is similar to != operator.
    > If the value of left operand is greater than the value of right operand, then condition becomes true. (a > b) is not true.
    < If the value of left operand is less than the value of right operand, then condition becomes true. (a < b) is true.
    >= If the value of left operand is greater than or equal to the value of right operand, then condition becomes true. (a >= b) is not true.
    <= If the value of left operand is less than or equal to the value of right operand, then condition becomes true. (a <= b) is true.

    Python Assignment Operators

    Assume variable a holds 10 and variable b holds 20, then −

    Operator Description Example
    = Assigns values from right side operands to left side operand c = a + b assigns value of a + b into c
    += Add AND It adds right operand to the left operand and assign the result to left operand c += a is equivalent to c = c + a
    -= Subtract AND It subtracts right operand from the left operand and assign the result to left operand c -= a is equivalent to c = c - a
    *= Multiply AND It multiplies right operand with the left operand and assign the result to left operand c *= a is equivalent to c = c * a
    /= Divide AND It divides left operand with the right operand and assign the result to left operand c /= a is equivalent to c = c / a
    %= Modulus AND It takes modulus using two operands and assign the result to left operand c %= a is equivalent to c = c % a
    **= Exponent AND Performs exponential (power) calculation on operators and assign value to the left operand c **= a is equivalent to c = c ** a
    //= Floor Division It performs floor division on operators and assign value to the left operand c //= a is equivalent to c = c // a

    Python Bitwise Operators

    Bitwise operator works on bits and performs bit by bit operation. Assume if a = 60; and b = 13; Now in the binary format their values will be 0011 1100 and 0000 1101 respectively. Following table lists out the bitwise operators supported by Python language with an example each in those, we use the above two variables (a and b) as operands −
    a = 0011 1100
    b = 0000 1101

    a&b = 0000 1100
    a|b = 0011 1101
    a^b = 0011 0001
    ~a = 1100 0011
    There are following Bitwise operators supported by Python language

    Operator Description Example
    & Binary AND Operator copies a bit to the result if it exists in both operands (a & b) (means 0000 1100)
    | Binary OR It copies a bit if it exists in either operand. (a | b) = 61 (means 0011 1101)
    ^ Binary XOR It copies the bit if it is set in one operand but not both. (a ^ b) = 49 (means 0011 0001)
    ~ Binary Ones Complement It is unary and has the effect of 'flipping' bits. (~a ) = -61 (means 1100 0011 in 2's complement form due to a signed binary number.
    << Binary Left Shift The left operands value is moved left by the number of bits specified by the right operand. a << 2 = 240 (means 1111 0000)
    >> Binary Right Shift The left operands value is moved right by the number of bits specified by the right operand. a >> 2 = 15 (means 0000 1111)

    Python Logical Operators

    There are following logical operators supported by Python language. Assume variable a holds 10 and variable b holds 20 then

    Operator Description Example
    and Logical AND If both the operands are true then condition becomes true. (a and b) is true.
    or Logical OR If any of the two operands are non-zero then condition becomes true. (a or b) is true.
    not Logical NOT Used to reverse the logical state of its operand. Not(a and b) is false.

    Python Membership Operators

    Python’s membership operators test for membership in a sequence, such as strings, lists, or tuples. There are two membership operators as explained below −

    Operator Description Example
    in Evaluates to true if it finds a variable in the specified sequence and false otherwise. x in y, here in results in a 1 if x is a member of sequence y.
    not in Evaluates to true if it does not finds a variable in the specified sequence and false otherwise. x not in y, here not in results in a 1 if x is not a member of sequence y.

    Python Identity Operators

    Identity operators compare the memory locations of two objects. There are two Identity operators explained below −

    Operator Description Example
    is Evaluates to true if the variables on either side of the operator point to the same object and false otherwise. x is y, here is results in 1 if id(x) equals id(y).
    is not Evaluates to false if the variables on either side of the operator point to the same object and true otherwise. x is not y, here is not results in 1 if id(x) is not equal to id(y).

    Python Operators Precedence

    The following table lists all operators from highest precedence to lowest.

    Sr.No. Operator & Description
    1 **

    Exponentiation (raise to the power)

    2 ~ + -

    Complement, unary plus and minus (method names for the last two are +@ and -@)

    3 * / % //

    Multiply, divide, modulo and floor division

    4 + -

    Addition and subtraction

    5 >> <<

    Right and left bitwise shift

    6 &

    Bitwise 'AND'

    7 ^ |

    Bitwise exclusive `OR' and regular `OR'

    8 =

    Comparison operators

    9 == !=

    Equality operators

    10 = %= /= //= -= += *= **=

    Assignment operators

    11 is is not

    Identity operators

    12 in not in

    Membership operators

    13 not or and

    Logical operators

    https://prutor.ai/python/python_decision_making.htm

    Python - Decision Making

    Decision making is anticipation of conditions occurring while execution of the program and specifying actions taken according to the conditions.
    Decision structures evaluate multiple expressions which produce TRUE or FALSE as outcome. You need to determine which action to take and which statements to execute if outcome is TRUE or FALSE otherwise.
    Following is the general form of a typical decision making structure found in most of the programming languages −
    Python programming language assumes any non-zero and non-null values as TRUE, and if it is either zero or null, then it is assumed as FALSE value.
    Python programming language provides following types of decision making statements. Click the following links to check their detail.

    Sr.No. Statement & Description
    1 if statements

    An if statement consists of a boolean expression followed by one or more statements.

    2 if...else statements

    An if statement can be followed by an optional else statement, which executes when the boolean expression is FALSE.

    3 nested if statements

    You can use one if or else if statement inside another if or else if statement(s).

    Let us go through each decision making briefly −

    Single Statement Suites

    If the suite of an if clause consists only of a single line, it may go on the same line as the header statement.
    Here is an example of a one-line if clause −

    age = 19
    if(age>18) : print("you are an adult!")

    When the above code is executed, it produces the following result −

    you are an adult!
Python – Basic Syntax (Prev Lesson)
(Next Lesson) Python – Loops
', { 'anonymize_ip': true });