Python Native Data Types

-

 

1. Numbers

Python supports various numeric types:

  • Integers (int): Whole numbers (e.g., 10, -3)
  • Floating-point numbers (float): Decimal numbers (e.g., 3.14, -2.71)
  • Complex numbers (complex): Numbers with a real and imaginary part (e.g., 2+3j)

Operations on Numbers:

  1. Arithmetic: +, -, *, /, // (floor division), % (modulo), ** (power)

    a = 10
b = 3
print(a + b)  # 13
print(a / b)  # 3.333
print(a // b) # 3
print(a % b)  # 1
print(a ** b) # 1000

  2. Type Conversion:

    • int(), float(), complex()
    print(int(5.7))      # 5
print(float(3))      # 3.0
print(complex(2, 3)) # (2+3j)

  3. Built-in Functions:

    • abs(x): Returns absolute value.
    • pow(x, y): Power calculation (x^y).
    • round(x, n): Rounds to n decimal places.
    • divmod(x, y): Returns quotient and remainder.
    print(abs(-7))         # 7
print(pow(2, 3))       # 8
print(round(3.14159, 2)) # 3.14
print(divmod(10, 3))   # (3, 1)

2. Lists

A list is an ordered, mutable collection that can store heterogeneous items.

Operations on Lists:

  1. Creating Lists:

    lst = [1, 2, 3, 'a', 'b', 'c']

  2. Accessing Elements:

    • Indexing: lst[0] (first element)
    • Slicing: lst[1:4] (elements from index 1 to 3)

  3. List Methods:

    • append(x): Adds item at the end.
    • extend(iterable): Extends list with items.
    • insert(i, x): Inserts x at position i.
    • remove(x): Removes the first occurrence of x.
    • pop([i]): Removes item at position i (last by default).
    • index(x): Returns index of x.
    • count(x): Counts occurrences of x.
    • sort(): Sorts the list.
    • reverse(): Reverses the list.
    lst = [10, 20, 30]
lst.append(40)     # [10, 20, 30, 40]
lst.insert(1, 15)  # [10, 15, 20, 30, 40]
lst.pop()          # [10, 15, 20, 30]
lst.sort()         # [10, 15, 20, 30]

3. Tuples

A tuple is an ordered, immutable collection of items.

Characteristics:

  • Immutable: Once created, cannot be changed.
  • Faster than lists for iteration.

Creating and Accessing Tuples:

tup = (1, 2, 3, 'a')
print(tup[0])      # 1
print(tup[1:3])    # (2, 3)

Tuple Methods:

  • count(x): Counts occurrences of x.
  • index(x): Returns index of x.

4. Sets

A set is an unordered, mutable collection with unique elements.

Operations on Sets:

  1. Creating Sets:

    s = {1, 2, 3, 3}  # {1, 2, 3}

  2. Set Methods:

    • add(x): Adds element x.
    • update(iterable): Adds multiple elements.
    • remove(x): Removes x; raises an error if not found.
    • discard(x): Removes x; no error if not found.
    • pop(): Removes and returns an arbitrary element.
    • clear(): Clears the set.
    • union(): Combines sets.
    • intersection(): Finds common elements.
    • difference(): Finds differences.
    s1 = {1, 2, 3}
s2 = {3, 4, 5}
print(s1.union(s2))       # {1, 2, 3, 4, 5}
print(s1.intersection(s2)) # {3}

5. Dictionary

A dictionary is an unordered collection of key-value pairs.

Creating Dictionaries:

d = {'name': 'Alice', 'age': 25, 'city': 'NY'}

Dictionary Methods:

  • keys(): Returns keys.
  • values(): Returns values.
  • items(): Returns key-value pairs.
  • get(key): Returns value for key.
  • update(dict): Updates dictionary.
  • pop(key): Removes key and returns value.
  • clear(): Clears dictionary.
d = {'name': 'Alice', 'age': 25}
print(d.keys())           # dict_keys(['name', 'age'])
print(d.get('name'))      # Alice
d.update({'city': 'NY'})  # {'name': 'Alice', 'age': 25, 'city': 'NY'}
d.pop('age')              # Removes 'age'

6. Strings

A string is an immutable sequence of characters.

String Operations:

  • Concatenation: +
  • Repetition: *
  • Indexing and Slicing: 
    s = "hello"
print(s[0])       # h
print(s[1:4])     # ell

String Methods:

  1. Case Conversion:
    • upper(), lower(), capitalize(), title(), swapcase()
  2. Searching:
    • find(sub), index(sub), count(sub)
  3. Modification:
    • replace(old, new), strip(), lstrip(), rstrip()
  4. Splitting and Joining:
    • split(), join(iterable)
  5. Validation:
    • isalpha(), isdigit(), isspace(), isalnum()
    s = "hello world"
print(s.upper())            # HELLO WORLD
print(s.replace("world", "Python"))  # hello Python
print(s.split())            # ['hello', 'world']
print("-".join(['a', 'b'])) # a-b

This overview provides a clear understanding of Python's native data types, operations, and methods. Let me know if you need further explanations or code examples!

Comments

Post a Comment

Popular posts from this blog

Error Detection in Data Link Layer

-
Image
 Sure! Error control in the data link layer ensures that data is transmitted accurately over a network. It involves both error detection and error correction techniques. Here’s a detailed explanation with examples: Error Detection Error detection involves identifying errors in the transmitted data. Common techniques include: Sure! Let’s dive into the different error detection methods used in the data link layer: VRC, LRC, CRC, and Checksum. 1. Vertical Redundancy Check (VRC) VRC , also known as Parity Check , involves adding a parity bit to each data unit (byte). This parity bit ensures that the total number of 1s in the byte (including the parity bit) is even (even parity) or odd (odd parity). Example: Data to be sent: 1010001 Even parity: Add a parity bit 1 to make the total number of 1s even: 10100011 Odd parity: Add a parity bit 0 to keep the total number of 1s odd: 10100010 At the receiver’s end, the parity of the received data is checked. If it doesn’t match the expected pa...
Read more

Transmission impairments – Attenuation, Distortion, Noise. Multiplexing – Frequency division, Time division, Wavelength division

-
 Sure, let’s break down these concepts in an easy-to-understand way for your paper. Transmission Impairments Attenuation : Definition : Attenuation refers to the loss of signal strength as it travels through a medium. Cause : This happens due to the resistance of the medium, which absorbs some of the signal’s energy. Example : Imagine shouting across a large field. Your voice gets weaker the further it travels. Solution : Amplifiers are used to boost the signal strength at intervals to counteract attenuation. Distortion : Definition : Distortion occurs when the shape or form of the signal changes. Cause : Different frequency components of a signal travel at different speeds, causing them to arrive at different times. Example : Think of a band playing music. If the instruments are not synchronized, the music sounds distorted. Solution : Equalizers can be used to correct the timing differences between frequency components. Noise : Definition : Noise is any unwanted signal that interf...
Read more

DSA LAB 1 Program

-
 Program for using Dynamic Function (malloc(), calloc(), realloc(), free(0) function   // malloc() & free() function # include < stdio.h > # include < stdlib.h > int main () {     int n , i , * ptr , sum = 0 ;     printf ( " Enter number of elements: " ) ;     scanf ( " %d " , & n ) ;     ptr = ( int * ) malloc ( n * sizeof ( int )) ;     // if memory cannot be allocated     if ( ptr == NULL )     {         printf ( " Error! memory not allocated. " ) ;         exit ( 0 ) ;     }     for ( i = 0 ; i < n ; ++ i )     {         printf ( " Enter %d elements : " , i + 1 ) ;         scanf ( " %d " , ptr + i ) ;         sum += * ( ptr + i );     }     printf ( " Sum = %d " , sum ) ;     // deallocating the m...
Read more