Alican Dönmez’s Post

🐍 Did you know that Python closures capture variables, not values? This behavior is called late binding and it can cause surprising results. Example: funcs = [] for i in range(3): funcs.append(lambda: i) # tricky line print([f() for f in funcs]) # [2, 2, 2] Why does this happen? All the lambdas keep a reference to the same variable i. When the loop finishes, i equals 2, so every function returns 2. 💡 We can fix this by forcing early binding using default arguments: funcs.append(lambda i=i: i) This creates a new local variable i for each lambda and stores the current value at definition time. #Python #Closures #ProgrammingTips #LearningInPublic #SoftwareEngineering

🚀 Using `next()` with Generators (Python) The `next()` function is used to retrieve the next value from a generator. When `next()` is called on a generator object, the generator executes until it encounters a `yield` statement. The value yielded is returned by `next()`. If the generator has no more values to yield (e.g., it has reached the end of the function), `next()` raises a `StopIteration` exception. This exception signals that the generator has been exhausted. #Python #PythonDev #DataScience #WebDev #professional #career #development

Two numbers. Same math. Different answers. 🤯 Copy code Python x = 10**100 y = 10**100 + 1 print(x == y) Output: False Python handles this without blinking. No overflow. No precision loss. Now watch this: Python a = 1e16 b = a + 1 print(a == b) Output: True At this scale, adding 1 changes nothing. The value is already beyond what a float can accurately represent. Integers in Python grow as large as memory allows. Floats live within fixed precision and range boundaries. Same language. Same operator. Very different realities. Next time a number behaves “strangely”, remember — it’s not a bug, it’s a boundary. #Python #DataScience #ProgrammingInsights #NumericalComputing #TechThoughts

Today’s challenge was all about solving the classic Intersection Point in Y-Shaped Linked Lists problem using Python. This problem is a great reminder of how elegant the two-pointer technique can be — instead of brute force, we let the pointers sync naturally across both lists until they meet at the intersection node. Here’s the clean solution I implemented: python class Solution: def intersectPoint(self, head1, head2): temp1, temp2 = head1, head2 while temp1 != temp2: temp1 = head2 if temp1 is None else temp1.next temp2 = head1 if temp2 is None else temp2.next return temp1 # returns the intersection node or None ✨ Key takeaway: O(N+M) time, O(1) space No extra data structures needed Works seamlessly even when lists differ in length #Python #Geekstreak2025 #DataStructures #LinkedLists #CodingChallenge #LeetCode #GeeksforGeeksProblem Link : https://lnkd.in/dNmQ3dK9 Solution Link : https://lnkd.in/daP__sqA

Practised Python list manipulation methods to work with dynamic data efficiently. Used methods like append(), insert(), and extend() to add elements in different ways. Understood the difference between reference copy and shallow copy using copy(). Worked with pop() and remove() to delete elements by index and value. Implemented logic to remove duplicates, find item positions using index(), and frequency using count(). These exercises improved my understanding of list behavior, memory handling, and data operations. #Python #Lists #DataStructures #PythonBasics #ListMethods #LearningJourney

A "merge()" can explode your dataset if both tables contain multiple rows for each key (this refers to the many-to-many join situation). Result: millions of rows + memory error must aggregate first, then merge Great reminder on the importance of understanding data relationships versus actually writing code. #Python #Pandas #DataScience

Day 333: Why Lists aren't always enough (Deque) 🌀 Optimizing Queues Here is a computer science fact: Popping the first item of a standard Python list is slow ($O(n)$) because Python has to shift every other item in memory. If you are implementing a Queue, a Sliding Window algorithm, or BFS (Breadth-First Search), you need deque (Double Ended Queue). It allows you to add or remove items from both ends instantly (O(1)). from collections import deque # A list where popping from the left is fast queue = deque(["User1", "User2", "User3"]) queue.popleft() # "User1" leaves instantly queue.append("User4") # "User4" joins the back print(queue) Challenge: Try solving the "Sliding Window Maximum" problem on LeetCode using a list vs. a deque. The speed difference is massive. #Algorithms #DataStructures #Python #CodingInterviews

Stop choosing between [] and () at random. It’s the difference between a high-performance script and a MemoryError. 🐍 In Python, List Comprehensions and Generator Expressions might look similar, but under the hood, they handle your system's RAM very differently. I’ve put together a slide deck to break down: ✅ The 'Eager' vs. 'Lazy' evaluation model. ✅ Real-world memory benchmarks. ✅ When to prioritize Speed over Memory. Swipe through to see which one you should be using for your next data pipeline! 👇 What’s your go-to? Do you default to Lists for simplicity, or Generators for efficiency? Let’s discuss in the comments! #Python #Coding #SoftwareEngineering #DataScience #Backend #Performance

List comprehension is a clean and efficient way to work with lists in Python. Instead of writing multiple lines using loops and conditions, you can filter or transform data in a single readable line. In this example, we extract only high sales values from a list. This approach is widely used in data analysis because it makes the code shorter, faster to read, and easier to maintain once your datasets grow. #PythonProgramming #LearnPython #ListComprehension #PythonTips #DataAnalytics #CleanCode #AnalyticsByAdnan