Python’da range() Fonksiyonu: Kapsamlı Bir Rehber

Python programlama dilinde tekrarlayan görevler veya belirli bir sayı dizisi üzerinde işlem yapmak gerektiğinde aklınıza ilk gelen fonksiyonlardan biri range() olmalıdır. Peki, bu basit görünen fonksiyonun ardında yatan güç ve verimlilik mekanizmaları nelerdir? Geliştirdiğiniz uygulamalarda döngüleri daha etkin ve Pythonik bir şekilde nasıl kullanabilirsiniz? İşte bu kapsamlı rehberde, range() fonksiyonunun temelden ileri seviyeye tüm özelliklerini, gerçek dünya senaryolarıyla birlikte inceleyeceğiz.

Python’da range() fonksiyonu, belirli bir başlangıç noktasından başlayıp belirli bir bitiş noktasına kadar, isteğe bağlı olarak belirli bir adımla ilerleyen bir sayı dizisi oluşturmak için kullanılır. Ancak, bu fonksiyon bir liste (list) nesnesi döndürmez; bunun yerine bir “range object” (aralık nesnesi) döndürür. Bu nesne, bellekte yer kaplamadan, ihtiyaç duyulduğunda sayıları tek tek üreten bir tür “iterable” (yinelenebilir) yapıdır.

Programlamada sıklıkla karşılaşılan durumlar vardır: belirli bir kodu N kez çalıştırmak, bir listenin elemanlarını indekslerine göre işlemek veya belli aralıklardaki sayısal veriler üzerinde manipülasyon yapmak. İşte bu gibi durumlarda range() fonksiyonu devreye girer. Geleneksel olarak, birçok dilde bu tür işlemler için tam bir sayı dizisini belleğe yükleyen listeler oluşturulur. Ancak Python’ın range() fonksiyonu, özellikle büyük sayı dizileriyle çalışırken bu yaklaşımın getirdiği bellek ve performans maliyetini ortadan kaldırır. Sayıları anında (on-the-fly) üreterek, uygulamanızın daha hızlı ve daha az kaynak tüketerek çalışmasını sağlar.

Örneğin, 1 milyar sayıdan oluşan bir liste oluşturmak istediğinizi düşünün. Eğer bu listeyi doğrudan belleğe yüklerseniz, sisteminiz muhtemelen çökecektir. Ancak range(1_000_000_000) kullandığınızda, Python yalnızca bu dizinin nasıl üretileceğini bilir ve sayıları yalnızca erişim istendiğinde oluşturur. Bu durum, özellikle büyük veri işleme, bilimsel hesaplamalar ve performans kritik uygulamalar için vazgeçilmez bir özelliktir. Dolayısıyla, range() sadece bir döngü aracı değil, aynı zamanda Python’ın verimli bellek yönetiminin de bir göstergesidir.

range() fonksiyonunun temel yapısı oldukça basittir ve üç farklı şekilde kullanılabilir:

1. range(stop): 0’dan başlar ve stop-1‘e kadar sayılar üretir. Adım varsayılan olarak 1’dir.
2. range(start, stop): start değerinden başlar ve stop-1‘e kadar sayılar üretir. Adım yine varsayılan olarak 1’dir.
3. range(start, stop, step): start değerinden başlar, stop-1‘e kadar step adımıyla sayılar üretir. step pozitif veya negatif olabilir.

Bu esneklik, geliştiricilere ihtiyaçlarına göre özelleştirilmiş sayı dizileri oluşturma imkanı sunar. Örneğin, sadece çift sayıları veya belirli aralıktaki tek sayıları kolayca elde edebilirsiniz. Ayrıca, range() fonksiyonu ile oluşturulan nesneler, tamsayı (integer) değerleri içerir ve kayan noktalı (float) sayılar için doğrudan kullanılamaz. Ancak, range()‘in çıktısını float değerlere dönüştürerek veya döngü içinde hesaplamalar yaparak bu sınırlamayı aşmak mümkündür. Sonuç olarak, range() fonksiyonu, Python’da döngülerin ve sayısal dizilerin temel taşlarından biridir ve her Python geliştiricisinin ustalaşması gereken bir araçtır.

range() Fonksiyonu ile Temel Döngüler Nasıl Oluşturulur?

range() fonksiyonunun en yaygın kullanım alanı, Python’daki for döngüleriyle birlikte çalışmaktır. Bu kombinasyon, belirli bir sayıda tekrar edilmesi gereken işlemleri veya bir dizi elemanı indekslerine göre işleme ihtiyacını son derece basit ve okunabilir bir şekilde karşılar. İşte range()‘in farklı kullanımlarıyla temel döngülerin nasıl oluşturulacağına dair detaylı örnekler:

Sadece Bitiş Değeri ile Döngü Kurma: range(stop)

range(stop) formatı, 0’dan başlayarak belirtilen stop değerine kadar (bu değer dahil değil) 1’er 1’er artan bir sayı dizisi oluşturur. Bu, genellikle belirli bir işlemi N kez tekrarlamak istediğinizde veya bir listenin tüm elemanlarını indeksleyerek erişmek istediğinizde kullanılır.

# 5 kez 'Merhaba Dünya!' yazdıralım
for i in range(5):
    print(f"Merhaba Dünya! (Sıra: {i+1})")

# Çıktı:
# Merhaba Dünya! (Sıra: 1)
# Merhaba Dünya! (Sıra: 2)
# Merhaba Dünya! (Sıra: 3)
# Merhaba Dünya! (Sıra: 4)
# Merhaba Dünya! (Sıra: 5)
    

Bu örnekte, range(5) 0, 1, 2, 3, 4 sayılarını üretir. Döngü her bir sayı için bir kez çalışır.

Başlangıç ve Bitiş Değeri ile Döngü Kurma: range(start, stop)

range(start, stop) formatı, start değerinden başlayarak stop değerine kadar (bu değer dahil değil) 1'er 1'er artan bir sayı dizisi oluşturur. Bu, belirli bir aralıktaki sayılarla çalışmanız gerektiğinde çok kullanışlıdır.

# 3'ten 7'ye kadar (7 hariç) sayıları yazdıralım
for sayi in range(3, 7):
    print(f"Sayı: {sayi}")

# Çıktı:
# Sayı: 3
# Sayı: 4
# Sayı: 5
# Sayı: 6
    

Burada döngü 3 ile başlar ve 6'ya kadar devam eder. 7 dahil edilmez.

Başlangıç, Bitiş ve Adım Değeri ile Döngü Kurma: range(start, stop, step)

range(start, stop, step) formatı, start değerinden başlayıp stop değerine kadar (bu değer dahil değil) step değeri kadar artan veya azalan (eğer step negatifse) bir sayı dizisi oluşturur. Bu, özellikle çift sayılar, tek sayılar veya belirli bir aralıktaki atlamalı sayılar üzerinde çalışmak için idealdir.

# 0'dan 10'a kadar (10 hariç) çift sayıları yazdıralım
for cift_sayi in range(0, 10, 2):
    print(f"Çift Sayı: {cift_sayi}")

# Çıktı:
# Çift Sayı: 0
# Çift Sayı: 2
# Çift Sayı: 4
# Çift Sayı: 6
# Çift Sayı: 8
    

# 10'dan 0'a kadar (0 hariç) 2'şer azalan sayıları yazdıralım (Negatif adım)
for geri_sayim in range(10, 0, -2):
print(f"Geri Sayım: {geri_sayim}")

# Çıktı:
# Geri Sayım: 10
# Geri Sayım: 8
# Geri Sayım: 6
# Geri Sayım: 4
# Geri Sayım: 2

Negatif step değeri kullanıldığında, start değeri stop değerinden büyük olmalıdır. Aksi takdirde, boş bir dizi elde edersiniz. Örneğin, range(0, 10, -1) boş bir dizi döndürür çünkü 0'dan başlayıp geriye doğru sayarken 10'a ulaşmak mümkün değildir.

range() fonksiyonu, döngüleri kontrol etmek için Python'ın sunduğu en temel ve güçlü araçlardan biridir. Bu farklı kullanım biçimleri sayesinde, geliştiriciler hem basit hem de karmaşık döngü ihtiyaçlarını kolayca karşılayabilir, böylece kodlarını daha verimli ve okunabilir hale getirebilirler. Ayrıca, bu fonksiyonun "lazy" (tembel) doğası, yani sayıları yalnızca ihtiyaç duyulduğunda üretmesi, performans açısından da önemli avantajlar sağlar.

range() Fonksiyonunun Gelişmiş Kullanım Senaryoları Nelerdir?

range() fonksiyonu sadece basit döngüler kurmakla kalmaz, aynı zamanda Python'ın diğer güçlü özellikleriyle birleştiğinde çok daha karmaşık ve etkili senaryolarda kullanılabilir. Bu bölümde, range()'in list comprehension, enumerate() ve zip() gibi fonksiyonlarla nasıl entegre edilebileceğini ve gerçek dünya problemlerinde nasıl çözüm sunabileceğini inceleyeceğiz.

List Comprehension ile range() Kullanımı

Python'ın en sevilen özelliklerinden biri olan list comprehension (liste anlama), listeleri tek bir satırda, okunabilir ve verimli bir şekilde oluşturmanızı sağlar. range() ile birleştiğinde, belirli bir sayı dizisine dayalı olarak yeni listeler üretmek çok daha kolay hale gelir.

# 0'dan 9'a kadar olan sayıların karelerini içeren bir liste oluşturalım
kareler = [x**2 for x in range(10)]
print(f"Kareler Listesi: {kareler}")
# Çıktı: Kareler Listesi: [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

# Belirli bir koşulu sağlayan sayıları içeren bir liste oluşturalım
# Örneğin, 0-20 arasındaki çift sayılar
cift_sayilar = [num for num in range(21) if num % 2 == 0]
print(f"Çift Sayılar: {cift_sayilar}")
# Çıktı: Çift Sayılar: [0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20]
    

List comprehensions, bu tür listeleri oluşturmak için geleneksel for döngülerine göre hem daha kısa hem de genellikle daha performanslıdır. Ayrıca, kodun niyetini daha açık bir şekilde ifade eder.

enumerate() ve zip() ile range() Entegrasyonu

Bazen bir liste veya başka bir yinelenebilir nesne üzerinde döngü yaparken hem elemanın kendisine hem de onun indeksine aynı anda ihtiyacınız olabilir. İşte burada enumerate() fonksiyonu devreye girer. range() ile birleştiğinde, bu ikili daha da güçlenir.

urunler = ["Laptop", "Mouse", "Klavye", "Monitör"]

# enumerate() ile ürünleri indeksleriyle birlikte listeleyelim
for indeks, urun in enumerate(urunler):
    print(f"{indeks}. Ürün: {urun}")

# Çıktı:
# 0. Ürün: Laptop
# 1. Ürün: Mouse
# 2. Ürün: Klavye
# 3. Ürün: Monitör
    

Peki ya birden fazla yinelenebilir nesne üzerinde eş zamanlı olarak döngü yapmak isterseniz? zip() fonksiyonu, birden fazla yinelenebilir nesneyi birleştirerek elemanları karşılıklı olarak eşleştirir. range() ile bu, özellikle paralel listeleri belirli bir indeks aralığında işlerken veya veri kümelerini birleştirirken faydalı olabilir.

isimler = ["Ali", "Ayşe", "Mehmet"]
yaslar = [30, 24, 35]

# zip() ile isimleri ve yaşları eşleştirelim
for isim, yas in zip(isimler, yaslar):
    print(f"{isim} {yas} yaşındadır.")

# Çıktı:
# Ali 30 yaşındadır.
# Ayşe 24 yaşındadır.
# Mehmet 35 yaşındadır.
    

range(), enumerate() ve zip() gibi fonksiyonların bir araya gelmesi, Python'da veri işleme ve döngü yapılarını daha esnek ve güçlü hale getirir. Bu kombinasyonlar, özellikle veri analizinde ve karmaşık algoritma geliştirmede sıklıkla kullanılır.

Gerçek Dünya Uygulamaları: Birkaç Vaka Analizi

range() fonksiyonunun gücünü göstermek için birkaç gerçek dünya senaryosuna bakalım:

• Veri Temizleme ve Dönüştürme: Bir CSV dosyasından okunan ve başlık satırı ile toplam satırı içeren bir veri setiniz var. Gerçek veri satırları 1. indeksten başlayıp sondan bir önceki indekste bitiyor.

  
  veri_satirlari = [
      "Başlık1,Başlık2,Başlık3",
      "A,1,10.5",
      "B,2,20.0",
      "C,3,15.2",
      "Toplam,6,45.7"
  ]
  
  # Gerçek veri satırlarını işlemek için range() kullanalım
  # Başlangıç 1 (başlık atla), Bitiş len(veri_satirlari) - 1 (toplam satırı atla)
  print("İşlenen Veri Satırları:")
  for i in range(1, len(veri_satirlari) - 1):
      sutunlar = veri_satirlari[i].split(',')
      print(f"ID: {sutunlar[0]}, Miktar: {sutunlar[1]}, Değer: {float(sutunlar[2])}")
  
  # Çıktı:
  # İşlenen Veri Satırları:
  # ID: A, Miktar: 1, Değer: 10.5
  # ID: B, Miktar: 2, Değer: 20.0
  # ID: C, Miktar: 3, Değer: 15.2
              

• Simülasyon ve Oyun Geliştirme: Bir oyunda belirli sayıda tur veya seviye çalıştırmak istediğinizde.

  
  oyun_turu_sayisi = 10
  
  print("Oyun Başladı!")
  for tur in range(1, oyun_turu_sayisi + 1):
      print(f"--- Tur {tur} ---")
      # Tur içi oyun mantığı burada çalışır
      if tur == 5:
          print("Özel olay: Yarım yol ödülü!")
  print("Oyun Bitti!")
  
  # Çıktı:
  # Oyun Başladı!
  # --- Tur 1 ---
  # ...
  # --- Tur 5 ---
  # Özel olay: Yarım yol ödülü!
  # ...
  # --- Tur 10 ---
  # Oyun Bitti!
              

• Finansal Hesaplamalar: Belirli bir dönemdeki faiz hesaplamaları veya taksit ödemeleri.

  
  anapara = 1000
  faiz_orani = 0.05 # %5
  donem_sayisi = 3
  
  print("Yıl Sonu Faiz Hesaplamaları:")
  for yil in range(1, donem_sayisi + 1):
      faiz = anapara * faiz_orani
      anapara += faiz
      print(f"{yil}. Yıl Sonu: Anapara = {anapara:.2f}, Faiz = {faiz:.2f}")
  
  # Çıktı:
  # Yıl Sonu Faiz Hesaplamaları:
  # 1. Yıl Sonu: Anapara = 1050.00, Faiz = 50.00
  # 2. Yıl Sonu: Anapara = 1102.50, Faiz = 52.50
  # 3. Yıl Sonu: Anapara = 1157.62, Faiz = 55.12
              

Bu örnekler, range() fonksiyonunun sadece basit bir döngü aracı olmadığını, aynı zamanda Python'ın diğer güçlü yapılarıyla birleşerek gerçek dünya problemlerine zarif ve verimli çözümler sunabileceğini göstermektedir. Esnekliği ve bellek verimliliği sayesinde, Python projelerinde vazgeçilmez bir araç haline gelmiştir.

range() ve Performans: Bellek Verimliliği ve Büyük Veri İşleme

Python'da range() fonksiyonunun en önemli özelliklerinden biri, bellek verimliliğidir. Bu özelliği, özellikle büyük veri kümeleriyle çalışırken uygulamanızın performansını ve kaynak tüketimini doğrudan etkiler. Geleneksel olarak, birçok programlama dili belirli bir sayı dizisini oluşturmak için tüm sayıları belleğe yükleyen bir liste veya dizi yapısı kullanır. Ancak range(), Python'ın akıllı tasarımı sayesinde bu yaklaşımın getirdiği sınırlamaları ortadan kaldırır.

range(), bir "iterable" (yinelenebilir) nesne döndürür, "list" (liste) değil. Bu ne anlama geliyor? Bir range nesnesi, içerdiği tüm sayıları bellekte depolamaz. Bunun yerine, dizinin başlangıç, bitiş ve adım değerlerini (yani start, stop, step) saklar. Bir döngüde veya başka bir yinelenebilir bağlamda bu nesneye erişildiğinde, sayıları tek tek, anında (on-the-fly) üretir. Bu davranışa "lazy evaluation" (tembel değerlendirme) veya "yield-on-demand" (istendiğinde üretme) denir.

Bu tembel değerlendirme yaklaşımının bellek üzerindeki etkisi muazzamdır. Örneğin, 1 milyar elemanlık bir sayı dizisi oluşturmak istediğinizi düşünelim:

import sys

# range() ile 1 milyar elemanlık bir dizi
buyuk_range = range(1_000_000_000)
print(f"range() nesnesinin bellek boyutu: {sys.getsizeof(buyuk_range)} byte")

# Eğer aynı diziyi listeye dönüştürseydik (DENEMEYİN, BELLEĞİNİZ DOLAR!)
# buyuk_liste = list(range(1_000_000_000))
# print(f"list() nesnesinin bellek boyutu: {sys.getsizeof(buyuk_liste)} byte")

# Çıktı (yaklaşık değerler, Python sürümüne göre değişebilir):
# range() nesnesinin bellek boyutu: 48 byte
    

Gördüğünüz gibi, range() nesnesi ne kadar büyük bir sayı dizisini temsil ederse etsin, bellekte çok az yer kaplar (genellikle sabit bir boyut, çünkü sadece start, stop, step değerlerini tutar). Ancak aynı diziyi bir listeye dönüştürmeye kalkışsaydık, her bir tam sayı elemanı için bellek ayrılması gerekecekti ki bu da gigabaytlarca belleğe mal olurdu. 1 milyar tam sayı, 64-bit bir sistemde her biri 28 byte olsa (Python'da int nesnelerinin ortalama boyutu), yaklaşık 28 gigabayt bellek anlamına gelir. Bu da çoğu bilgisayar için imkansızdır.

Ne Zaman list(range()) Kullanmalıyız?

Peki, range() bu kadar verimliyse, neden bazen list(range()) kullanma ihtiyacı duyarız? Bazı senaryolarda, tüm sayı dizisinin bellekte hazır ve erişilebilir olması gerekebilir:

• Rastgele Erişim: Bir dizinin belirli bir indeksindeki elemana doğrudan ve tekrar tekrar erişmeniz gerekiyorsa. range() nesneleri indekslenebilir (my_range[5] gibi), ancak performans açısından bir liste kadar hızlı olmayabilir. Eğer sık sık rastgele erişim yapılacaksa, listeye dönüştürmek daha mantıklı olabilir.
• Tekrar Eden İterasyonlar: Aynı sayı dizisi üzerinde birden fazla kez döngü yapmanız gerekiyorsa. range() her döngüde sayıları yeniden üretir. Eğer dizi küçükse ve çok sayıda döngü olacaksa, bir kez listeye dönüştürüp bellekte tutmak bazen daha hızlı olabilir. Ancak bu senaryo oldukça nadirdir ve çoğu durumda range()'in kendisi yeterince hızlıdır.
• Fonksiyon Girişleri: Bazı fonksiyonlar veya kütüphaneler doğrudan bir liste bekleyebilir. Bu durumda, range() çıktısını bir listeye dönüştürmeniz gerekebilir.

Büyük veri işleme bağlamında, range()'in bu verimli yapısı, Python'ın daha büyük ölçekli ve bellek kısıtlı ortamlarda da etkili bir şekilde kullanılmasını sağlar. Veri bilimcileri, mühendisler ve yazılım geliştiricileri, bu özelliği sayesinde devasa veri kümeleri üzerinde bile döngüler kurabilir ve kompleks algoritmaları uygulayabilirler, tüm bunları sistem kaynaklarını zorlamadan yapabilirler. Sonuç olarak, range() Python'da sadece bir döngü kontrol mekanizması değil, aynı zamanda akıllı bellek yönetiminin ve performans optimizasyonunun da önemli bir örneğidir.

İpuçları ve En İyi Uygulamalar: range() Kullanımınızı Optimize Edin

range() fonksiyonunu daha etkin ve Pythonik bir şekilde kullanmak için bazı ipuçları ve en iyi uygulamalar mevcuttur. Bu teknikler, kodunuzu daha okunabilir, daha performanslı ve olası hatalara karşı daha dirençli hale getirecektir.

1. Anlamlı Değişken İsimleri Kullanın

Döngü değişkenleri için genellikle i veya j gibi tek harfli isimler kullanılır. Ancak, döngünün amacı daha karmaşıksa, daha açıklayıcı değişken isimleri kullanmak kodun okunabilirliğini artırır. Örneğin, bir "tur" sayısını ifade ediyorsa tur_sayisi, bir "indeks" ise eleman_indeksi gibi.

# Kötü örnek:
for i in range(10):
    # ...

# İyi örnek:
for tur_numarasi in range(1, 11): # 1'den başlayıp 10'a kadar tur numaraları
    print(f"{tur_numarasi}. Tur başladı.")
    

2. range() ile Ters Döngüler

Geriye doğru saymak için negatif bir adım değeri kullanabilirsiniz. Ancak start ve stop değerlerinin sırasına dikkat etmelisiniz.

# 10'dan 1'e kadar geri sayım
for i in range(10, 0, -1):
    print(i) # Çıktı: 10, 9, ..., 1
    

Eğer start değeri stop değerinden küçükse ve step negatifse, boş bir aralık oluşur. Örneğin, range(0, 10, -1) boş bir çıktı verir.

3. Boş Aralıkları Anlamak

range() fonksiyonu, başlangıç ve bitiş koşulları uygun olmadığında boş bir aralık nesnesi döndürebilir. Bu bir hata değildir, ancak kodunuzda bu durumu beklemelisiniz.

# start >= stop ve step pozitif olduğunda boş
bos_aralik_1 = range(5, 0)
print(f"Boş aralık 1 listesi: {list(bos_aralik_1)}") # Çıktı: []

# start <= stop ve step negatif olduğunda boş
bos_aralik_2 = range(0, 5, -1)
print(f"Boş aralık 2 listesi: {list(bos_aralik_2)}") # Çıktı: []
    

Bu durumları doğru bir şekilde ele almak, beklenmedik davranışların önüne geçer. Örneğin, bir döngüde hiçbir şeyin çalışmamasını bekliyorsanız bu normaldir.

4. Kayan Noktalı Sayılar (Floats) için range() Alternatifleri

range() fonksiyonu yalnızca tam sayılar (integers) ile çalışır. Kayan noktalı sayılarla (floats) bir dizi oluşturmanız gerekiyorsa, numpy.arange() veya kendi jeneratör fonksiyonunuzu kullanabilirsiniz.

import numpy as np

# NumPy ile kayan noktalı sayı dizisi
float_sayilar = np.arange(0.0, 1.0, 0.1)
print(f"Kayan noktalı sayılar (NumPy): {float_sayilar}")
# Çıktı: Kayan noktalı sayılar (NumPy): [0.  0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9]
    

Ya da kendi basit jeneratörünüzü yazabilirsiniz:

def float_range(start, stop, step):
    while start < stop:
        yield start
        start += step

print("Kayan noktalı sayılar (Custom):", list(float_range(0.0, 1.0, 0.1)))
# Çıktı: Kayan noktalı sayılar (Custom): [0.0, 0.1, 0.2, 0.30000000000000004, ..., 0.9]
    

NumPy'nin arange() fonksiyonu, kayan noktalı sayılarla çalışırken hassasiyet sorunları yaşayabileceği için dikkatli olunmalıdır. Kendi jeneratörünüzde de benzer hassasiyet sorunları ortaya çıkabilir. Bu tür durumlarda, ondalık hassasiyeti yönetmek için decimal modülünü kullanmak daha güvenli olabilir.

5. range() ile Slicing Benzetimi

Bir range nesnesi, listeler gibi dilimlenebilir (slicing). Bu, mevcut bir range'in bir bölümünü temsil eden yeni bir range nesnesi oluşturmanıza olanak tanır.

my_range = range(100) # 0'dan 99'a kadar
alt_aralik = my_range[10:20:2] # 10'dan başlayıp 18'e kadar 2'şer atlayarak
print(f"Alt aralık: {list(alt_aralik)}")
# Çıktı: Alt aralık: [10, 12, 14, 16, 18]
    

Bu özellik, özellikle büyük aralıklar üzerinde çalışırken ve bellekte yeni listeler oluşturmadan belirli alt kümeleri ele almanız gerektiğinde oldukça faydalıdır.

6. Mobil Uyumlu HTML İçin Dikkat Edilmesi Gerekenler

Makalenin kendisi gibi HTML içeriği hazırlarken, kod örnekleri veya tablolar gibi öğelerin mobil cihazlarda da düzgün görünmesini sağlamak önemlidir. Doğrudan CSS medya sorgusu kodunu içine eklemek yerine, bu tür öğelerin responsive olmasını sağlamanın genel prensiplerini ve bir örneğini açıklayalım. Örneğin, bu makaledeki kod blokları veya tablolar küçük ekranlarda taşabilir. Bunu engellemek için CSS medya sorguları ile belirli elementlerin boyutları veya görüntülenme şekilleri ayarlanır.

Örneğin, bir tablo için:

    

        

            

                
Başlık 1
                
Başlık 2
                
Başlık 3
                
Başlık 4
            
        
        

            

                
Veri A1
                
Veri A2
                
Veri A3
                
Veri A4
            
            

                
Veri B1
                
Veri B2
                
Veri B3
                
Veri B4
            
        
    

    

Bu tablo yapısı için, harici bir CSS dosyasında veya etiketindeki