Python Notes 🌟🌟🌟🌟🌟

#python

https://t.me/addlist/8_rRW2scgfRhOTc0 ⚡️

🐍 PyTorch for Beginners: All the Basics on Tensors in One Place

A collection of basic techniques for working with tensors in PyTorch — for those who are starting to get acquainted with the framework and want to quickly master its fundamentals.

What's inside:

▶️ What tensors are and why they are needed

▶️ Tensor initialization: zeros, ones, random, similar size

▶️ Type conversion and switching between NumPy and PyTorch

▶️ Arithmetic, logical operations, tensor comparison

▶️ Matrix multiplication and batch computations

▶️ Broadcasting, view(), reshape(), changing dimensions

▶️ Indexing and slicing: how to access parts of a tensor

▶️ Notebook with code examples

A good starting material to understand the mechanics of tensors before moving on to models and training.

⛓ GitHub link

tags: #useful

➡ @codeprogrammer

In Python, you can unpack sequences using *, to work with a variable number of elements. The * can be placed anywhere and it will collect all the extra elements into a separate variable.

a, b, c = 10, 2, 3      # Standard unpacking

a, *b = 10, 2, 3        # b = [2, 3]

a, *b, c = 10, 2, 3, 4  # b = [2, 3]

*a, b, c = 10, 2, 3, 4  # a = [10, 2]

👉  @DataScience4

In Python, enhanced for loops with enumerate() provide both the index and value of items in an iterable, making it ideal for tasks needing positional awareness without manual counters. This is more Pythonic and efficient than using range(len()) for list traversals.

fruits = ['apple', 'banana', 'cherry']
for index, fruit in enumerate(fruits):
    print(f"{index}: {fruit}")

# Output:
# 0: apple
# 1: banana
# 2: cherry

# With start offset:
for index, fruit in enumerate(fruits, start=1):
    print(f"{index}: {fruit}")
# 1: apple
# 2: banana
# 3: cherry

#python #forloops #enumerate #bestpractices

✉️ @DataScience4

In Python, lists are versatile mutable sequences with built-in methods for adding, removing, searching, sorting, and more—covering all common scenarios like dynamic data manipulation, queues, or stacks. Below is a complete breakdown of all list methods, each with syntax, an example, and output, plus key built-in functions for comprehensive use.

📚 Adding Elements
⦁ append(x): Adds a single element to the end.

  lst = [1, 2]
  lst.append(3)
  print(lst)  # Output: [1, 2, 3]
  

⦁ extend(iterable): Adds all elements from an iterable to the end.

  lst = [1, 2]
  lst.extend([3, 4])
  print(lst)  # Output: [1, 2, 3, 4]
  

⦁ insert(i, x): Inserts x at index i (shifts elements right).

  lst = [1, 3]
  lst.insert(1, 2)
  print(lst)  # Output: [1, 2, 3]
  

📚 Removing Elements
⦁ remove(x): Removes the first occurrence of x (raises ValueError if not found).

  lst = [1, 2, 2]
  lst.remove(2)
  print(lst)  # Output: [1, 2]
  

⦁ pop(i=-1): Removes and returns the element at index i (default: last).

  lst = [1, 2, 3]
  item = lst.pop(1)
  print(item, lst)  # Output: 2 [1, 3]
  

⦁ clear(): Removes all elements.

  lst = [1, 2, 3]
  lst.clear()
  print(lst)  # Output: []
  

📚 Searching and Counting
⦁ count(x): Returns the number of occurrences of x.

  lst = [1, 2, 2, 3]
  print(lst.count(2))  # Output: 2
  

⦁ index(x[, start[, end]]): Returns the lowest index of x in the slice (raises ValueError if not found).

  lst = [1, 2, 3, 2]
  print(lst.index(2))  # Output: 1
  

📚 Ordering and Copying
⦁ sort(key=None, reverse=False): Sorts the list in place (ascending by default; stable sort).

  lst = [3, 1, 2]
  lst.sort()
  print(lst)  # Output: [1, 2, 3]
  

⦁ reverse(): Reverses the elements in place.

  lst = [1, 2, 3]
  lst.reverse()
  print(lst)  # Output: [3, 2, 1]
  

⦁ copy(): Returns a shallow copy of the list.

  lst = [1, 2]
  new_lst = lst.copy()
  print(new_lst)  # Output: [1, 2]
  

📚 Built-in Functions for Lists (Common Cases)
⦁ len(lst): Returns the number of elements.

  lst = [1, 2, 3]
  print(len(lst))  # Output: 3
  

⦁ min(lst): Returns the smallest element (raises ValueError if empty).

  lst = [3, 1, 2]
  print(min(lst))  # Output: 1
  

⦁ max(lst): Returns the largest element.

  lst = [3, 1, 2]
  print(max(lst))  # Output: 3
  

⦁ sum(lst[, start=0]): Sums the elements (start adds an offset).

  lst = [1, 2, 3]
  print(sum(lst))  # Output: 6
  

⦁ sorted(lst, key=None, reverse=False): Returns a new sorted list (non-destructive).

  lst = [3, 1, 2]
  print(sorted(lst))  # Output: [1, 2, 3]
  

These cover all standard operations (O(1) for append/pop from end, O(n) for most others). Use slicing lst[start:end:step] for advanced extraction, like lst[1:3] outputs ``.

#python #lists #datastructures #methods #examples #programming

⭐ @DataScience4