3.3-dars: O'qish va yozish (CSV/Excel)

3-QISM — PANDAS · 3-dars

1. Kirish va motivatsiya

Hozirgacha DataFrame'ni kod ichida (dict dan) yaratdik. Lekin real ma'lumot fayllarda yashaydi: CSV fayllar, Excel jadvallar, ma'lumotlar bazasi, JSON. Data Science ishi deyarli doim faylni o'qishdan boshlanadi — mijozlar ro'yxati CSV'da, savdo Excel'da. Pandas buni bir qatorda qiladi: pd.read_csv("fayl.csv") — CSV'ni DataFrame'ga o'qiydi. Va aksincha — natijani saqlash: df.to_csv("natija.csv"). Bu dars real fayllar bilan ishlashni o'rgatadi. Nega muhim? (1) Boshlanish nuqtasi — har Data Science loyihasi fayl o'qishdan boshlanadi; (2) Formatlar — CSV (eng ko'p), Excel, JSON; (3) Parametrlar — ajratuvchi, sarlavha, kodlash (real fayllar turlicha). CSV eng ko'p uchraydigan format, shuning uchun unga alohida e'tibor beramiz. Bu dars o'qish va yozishni o'rgatadi — real ma'lumot bilan ishlashning birinchi qadami.

O'qish va yozish — fayl bilan ishlash: read_csv (CSV → DataFrame — eng ko'p), to_csv (DataFrame → CSV), Excel (read_excel/to_excel), parametrlar (sep ajratuvchi, header sarlavha, encoding kodlash, index_col), JSON (read_json), ko'rish (head — o'qiqandan keyin tekshir). Foydalanish: real fayl o'qish, natija saqlash, formatlar. Bu 3.2 (DataFrame), 6-qism (tozalash) bilan bog'liq. O'qish — read_csv. Yozish — to_csv. Real fayl.

Real vaziyat. Data Scientist do'kon savdo ma'lumotini CSV faylda oldi (savdo.csv — sana, mahsulot, miqdor, narx — 10000 qator). pd.read_csv("savdo.csv") — bir qatorda DataFrame'ga o'qidi (10000 qator, 4 ustun). df.head() (birinchi 5 — tekshir: to'g'ri o'qildimi), df.info() (ustunlar, turlar, NaN). Ba'zan fayl nuqta-vergul bilan (sep=";" — Yevropa CSV) yoki kodlash muammosi (encoding="utf-8" — o'zbekcha harflar). Tahlil qilgach, natijani saqladi: df.to_csv("natija.csv", index=False) (indekssiz — toza). O'qish/yozish Data Science birinchi va oxirgi qadam (fayl → tahlil → fayl). read_csv — har loyiha boshi.

Bu darsda o'qish va yozishni o'rganamiz.

Bu darsda:

• read_csv (CSV o'qish)
• to_csv (CSV yozish)
• read_csv parametrlari
• Excel va JSON
• O'qigandan keyin tekshirish
• O'qish amaliyoti
• O'qish tuzoqlari
• Amaliy: fayl modeli

ℹ Misollar real pandas bilan (deterministik — vaqtinchalik fayl) ishlaydi.

2. Nazariya — chuqur tushuntirish

2.1. read_csv (CSV o'qish)

CSV → DataFrame:

import pandas as pd

# CSV o'qish (eng ko'p ishlatiladigan)
df = pd.read_csv("savdo.csv")

# CSV nima: vergul bilan ajratilgan qiymatlar
#   sana,mahsulot,narx
#   2024-01-01,olma,100
#   2024-01-02,non,50

# birinchi qator — sarlavha (ustun nomlari)
# qolgan qatorlar — ma'lumot

read_csv (CSV o'qish) — CSV → DataFrame: pd.read_csv("fayl.csv") (eng ko'p ishlatiladi). CSV (Comma-Separated Values — vergul bilan ajratilgan qiymatlar): matn fayl, har qator — bir yozuv, vergul — ustun ajratuvchi; birinchi qator — sarlavha (ustun nomlari), qolgan — ma'lumot. Sabab: real ma'lumot fayllarda (CSV — eng keng tarqalgan; oddiy matn, universal — Excel/DB export); read_csv bir qatorda o'qiydi (fayl → DataFrame). Pandas avtomatik turni aniqlaydi (son — int/float, matn — object). read_csv — CSV o'qish (fayl → DataFrame). Eng ko'p. Universal.

2.2. to_csv (CSV yozish)

DataFrame → CSV:

df = pd.DataFrame({"ism": ["Ali", "Vali"], "yosh": [25, 30]})

# CSV yozish
df.to_csv("natija.csv", index=False)
# index=False — indeks ustunini yozmaslik (toza)

# index=True (standart) — indeks ham yoziladi:
#   ,ism,yosh
#   0,Ali,25

to_csv (CSV yozish) — DataFrame → CSV: df.to_csv("natija.csv", index=False). Sabab: natijani saqlash (tahlil/tozalangan ma'lumot — keyin ishlatish, boshqaga berish; Excel ochadi); to_csv DataFrame'ni faylga yozadi. index=False (muhim — indeks ustunini yozmaslik; aks holda 0,1,2 qo'shiladi — keraksiz, toza emas); standart index=True (indeks ham). CSV universal (Excel, boshqa dastur o'qiydi). to_csv — CSV yozish (index=False toza). Saqlash. Universal.

2.3. read_csv parametrlari

Real fayllar turlicha:

# AJRATUVCHI (sep) — nuqta-vergul (Yevropa)
pd.read_csv("fayl.csv", sep=";")

# SARLAVHA yo'q (header=None)
pd.read_csv("fayl.csv", header=None)

# KODLASH (encoding) — o'zbekcha/maxsus harflar
pd.read_csv("fayl.csv", encoding="utf-8")

# INDEKS ustuni (index_col)
pd.read_csv("fayl.csv", index_col=0)

# faqat ba'zi ustunlar
pd.read_csv("fayl.csv", usecols=["sana", "narx"])

read_csv parametrlari — real fayllar turlicha: sep (ajratuvchi — vergul standart, sep=";" nuqta-vergul Yevropa CSV, sep="\t" tab), header (sarlavha — header=None sarlavha yo'q), encoding (kodlash — utf-8 o'zbekcha/maxsus harflar), index_col (qaysi ustun indeks), usecols (faqat ba'zi ustunlar). Sabab: real fayllar har xil (ajratuvchi — vergul/nuqta-vergul/tab; kodlash — utf-8/boshqa; sarlavha bor/yo'q); parametrlar moslashtiradi (fayl formatiga). Eng ko'p muammo: kodlash (o'zbekcha harflar — utf-8), ajratuvchi (; — Yevropa). Parametrlar — sep, header, encoding, index_col. Moslashtirish. Real fayl.

2.4. Excel va JSON

Boshqa formatlar:

# EXCEL (.xlsx)
df = pd.read_excel("hisobot.xlsx")
df = pd.read_excel("hisobot.xlsx", sheet_name="Savdo")  # varaq
df.to_excel("natija.xlsx", index=False)

# JSON
df = pd.read_json("malumot.json")
df.to_json("natija.json")

# har format uchun read_* va to_*

Excel va JSON — boshqa formatlar: Excel (read_excel — .xlsx; sheet_name= — qaysi varaq; to_excel — yozish), JSON (read_json/to_json — veb API, ichma-ich tuzilma). Sabab: ma'lumot turli formatda (CSV eng ko'p, lekin Excel — biznes; JSON — veb/API); Pandas har format uchun read_*/to_* (bir xil g'oya — fayl → DataFrame). Excel varaqlar (sheet_name — bir fayl ko'p jadval), JSON ichma-ich (tuzilma — tekislaydi). CSV afzal (oddiy, universal), lekin Excel/JSON ham kerak. Excel/JSON — read_excel/read_json (formatlar). Turli manba. read_*/to_*.

2.5. O'qigandan keyin tekshirish

O'qiqandan keyin tekshirish — doim o'qiqach tekshir: (1) head() (birinchi qatorlar — to'g'ri o'qildimi, ustunlar joyidami); (2) shape (qator/ustun soni — kutilganchami; kam bo'lsa — ajratuvchi xato); (3) info() (ustun turlari, NaN soni — noto'g'ri tur/yo'q qiymat); (4) dtypes (son ustun object-mi — noto'g'ri o'qildi, tozalash kerak); (5) columns (ustun nomlari — to'g'rimi, bo'sh joy bor-mi). Sabab: o'qish jim xato berishi mumkin (ajratuvchi noto'g'ri — bir ustun; kodlash — buziq harf; tur — son matn bo'lib o'qildi); tekshirmasa — keyin xato (jim). Doim o'qiqach head/info (birinchi qadam). O'qiqandan keyin — head/shape/info/dtypes tekshir. Jim xato oldini. Doim.

2.6. O'qish amaliyoti

O'qish/yozish amaliyoti: read_csv (CSV — eng ko'p); to_csv(index=False) (yozish — toza); parametrlar (sep/encoding/header — real fayl); Excel/JSON (read_excel/read_json); tekshirish (head/info/dtypes — o'qiqach); yo'l (fayl yo'li — nisbiy/absolut); NaN (yo'q qiymat — 3.7); tur (son object — astype, 6-qism). Tuzoqlar: kodlash (o'zbekcha — utf-8), ajratuvchi (; Yevropa — sep), fayl yo'l (mavjud emas — xato), index yozish (index=False unut — keraksiz ustun), tur (son matn — tekshir). Amaliyot — read_csv, to_csv, parametrlar, tekshirish. Real fayl. Tekshir.

2.7. O'qish tuzoqlari

O'qish/yozish asosiy tuzoqlari: kodlash (encoding) (o'zbekcha/maxsus harflar — buziq belgilar; encoding="utf-8" yoki "cp1251"; eng ko'p muammo); ajratuvchi (sep) (Yevropa CSV nuqta-vergul — sep=";"; vergul deb o'qisa bir ustun — barchasi birga, xato); index=False unutish (to_csv — indeks ustuni yoziladi 0,1,2; qayta o'qiqanda keraksiz ustun; index=False); fayl yo'li (read_csv("yoq.csv") — fayl mavjud emas, FileNotFoundError; yo'l tekshir — nisbiy/absolut); tur avtomatik (son ustun object — bo'sh joy/matn aralash; dtype= yoki astype 6-qism); NaN belgisi (yo'q qiymat — bo'sh, NA, -; na_values= bilan aniqla); katta fayl (million qator — chunksize bo'laklab o'qish, xotira); sarlavha (header=None — sarlavha yo'q, aks holda birinchi qator ustun bo'ladi). Sabab: real fayl turli/iflos (kodlash, ajratuvchi, tur, NaN — jim xato yoki buziq o'qish). Yechim: encoding, sep, tekshir (head/info), index=False. Tuzoqlar — kodlash, ajratuvchi, index, yo'l, tur.

2.8. O'qish/yozish — Data Science birinchi qadam

O'qish/yozish asosiy g'oyasi — Data Science birinchi qadam: real ma'lumot fayllarda (CSV, Excel, JSON, DB); har Data Science loyiha fayl o'qishdan boshlanadi (dict — o'rganish; real — read_csv) va fayl yozish bilan tugaydi (natija saqlash — to_csv). read_csv (CSV → DataFrame — eng ko'p; CSV universal, oddiy), to_csv(index=False) (yozish — toza), parametrlar (sep/encoding — real fayl turlicha), Excel/JSON (read_excel/read_json). Doim tekshir (head/info/dtypes — jim xato oldini; ajratuvchi/kodlash/tur). Data Science oqimi: fayl → DataFrame → tahlil/tozalash → fayl (CRISP-DM — 1.4; ma'lumot tushunish boshi). Bu 3.2 (DataFrame) davomi va 6-qism (tozalash — real fayl iflos), butun Data Science uchun boshlanish. O'qish/yozish — Data Science birinchi qadam (read_csv/to_csv). Real fayl. Boshlanish.

3. Tez ma'lumotnoma

import pandas as pd

# O'QISH (CSV — eng ko'p):
df = pd.read_csv("fayl.csv")

# read_csv PARAMETRLARI (real fayl):
pd.read_csv("f.csv", sep=";")          # ajratuvchi (Yevropa)
pd.read_csv("f.csv", encoding="utf-8") # kodlash (o'zbekcha)
pd.read_csv("f.csv", header=None)      # sarlavha yo'q
pd.read_csv("f.csv", index_col=0)      # indeks ustuni
pd.read_csv("f.csv", usecols=["a","b"])# faqat ba'zi ustun

# YOZISH (index=False — toza):
df.to_csv("natija.csv", index=False)

# EXCEL / JSON:
pd.read_excel("f.xlsx", sheet_name="Savdo")
pd.read_json("f.json")

# TEKSHIRISH (DOIM o'qigach):
df.head()      # birinchi qatorlar
df.shape       # qator/ustun soni
df.info()      # turlar, NaN
df.dtypes      # ustun turlari

QOIDA: read_csv o'qi · head/info tekshir · to_csv index=False · encoding utf-8

O'qish xulosasi

O'qish/yozish — Data Science birinchi qadam (fayl → DataFrame → fayl)
read_csv — CSV o'qish (eng ko'p, universal)
to_csv(index=False) — CSV yozish (toza)
Parametrlar — sep, encoding, header (real fayl turlicha)
Tekshir — head/info/dtypes (jim xato oldini) DOIM

4. Batafsil misollar

Misollar real pandas bilan (vaqtinchalik fayl — deterministik) ishlaydi.

Misol 1 — O'qish va yozish

"""O'qish va yozish (real pandas — vaqtinchalik fayl)."""

import os
import tempfile
import pandas as pd


def main() -> None:
    papka = tempfile.mkdtemp()
    yol = os.path.join(papka, "savdo.csv")

    print("=== 1. DataFrame yozish ===")
    df = pd.DataFrame({
        "mahsulot": ["olma", "non", "sut"],
        "narx": [100, 50, 80],
    })
    df.to_csv(yol, index=False)
    print(f"  yozildi: {os.path.basename(yol)}")

    print("\n=== 2. O'qish ===")
    o_qilgan = pd.read_csv(yol)
    print(f"  shape: {o_qilgan.shape}")

    print("\n=== 3. Tekshirish (head) ===")
    print(f"  mahsulotlar: {list(o_qilgan['mahsulot'])}")

    print("\n=== 4. Bir xil ===")
    print(f"  asl bilan bir xil: {df.equals(o_qilgan)}")
    print("  ⭐ read_csv / to_csv — fayl bilan ishlash")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

=== 1. DataFrame yozish ===
  yozildi: savdo.csv

=== 2. O'qish ===
  shape: (3, 2)

=== 3. Tekshirish (head) ===
  mahsulotlar: ['olma', 'non', 'sut']

=== 4. Bir xil ===
  asl bilan bir xil: True
  ⭐ read_csv / to_csv — fayl bilan ishlash

Nima ko'rsatdi: 2.1, 2.2-bo'limlar.

Misol 2 — Parametrlar (sep, index)

"""read_csv parametrlari (real pandas)."""

import os
import tempfile
import pandas as pd


def main() -> None:
    papka = tempfile.mkdtemp()
    df = pd.DataFrame({"a": [1, 2], "b": [3, 4]})

    print("=== 1. Nuqta-vergul (sep=';') ===")
    yol1 = os.path.join(papka, "yevropa.csv")
    df.to_csv(yol1, sep=";", index=False)
    o1 = pd.read_csv(yol1, sep=";")
    print(f"  ustunlar: {list(o1.columns)}")

    print("\n=== 2. index=False vs True ===")
    yol2 = os.path.join(papka, "indeksli.csv")
    df.to_csv(yol2, index=True)
    o2 = pd.read_csv(yol2)
    print(f"  index=True ustunlari: {list(o2.columns)} (Unnamed qo'shildi)")

    print("\n=== 3. index=False (toza) ===")
    yol3 = os.path.join(papka, "toza.csv")
    df.to_csv(yol3, index=False)
    o3 = pd.read_csv(yol3)
    print(f"  index=False ustunlari: {list(o3.columns)}")

    print("\n=== 4. usecols ===")
    o4 = pd.read_csv(yol3, usecols=["a"])
    print(f"  faqat 'a': {list(o4.columns)}")
    print("  ⭐ Parametrlar — sep, index, usecols")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

=== 1. Nuqta-vergul (sep=';') ===
  ustunlar: ['a', 'b']

=== 2. index=False vs True ===
  index=True ustunlari: ['Unnamed: 0', 'a', 'b'] (Unnamed qo'shildi)

=== 3. index=False (toza) ===
  index=False ustunlari: ['a', 'b']

=== 4. usecols ===
  faqat 'a': ['a']
  ⭐ Parametrlar — sep, index, usecols

Nima ko'rsatdi: 2.3-bo'lim.

Misol 3 — O'qigandan keyin tekshirish

"""O'qigandan keyin tekshirish (real pandas)."""

import os
import tempfile
import pandas as pd


def main() -> None:
    papka = tempfile.mkdtemp()
    yol = os.path.join(papka, "mijoz.csv")
    pd.DataFrame({
        "ism": ["Ali", "Vali", "Guli"],
        "yosh": [25, 30, 28],
        "maosh": [500.0, 700.0, 600.0],
    }).to_csv(yol, index=False)

    df = pd.read_csv(yol)

    print("=== 1. head ===")
    print(f"  birinchi ism: {df.head(1)['ism'].iloc[0]}")

    print("\n=== 2. shape ===")
    print(f"  shape: {df.shape}")

    print("\n=== 3. dtypes ===")
    for u, t in df.dtypes.items():
        print(f"  {u}: {t}")

    print("\n=== 4. NaN tekshirish ===")
    print(f"  jami NaN: {df.isna().sum().sum()}")
    print("  ⭐ O'qigandan keyin DOIM tekshir (head/shape/dtypes)")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

=== 1. head ===
  birinchi ism: Ali

=== 2. shape ===
  shape: (3, 3)

=== 3. dtypes ===
  ism: str
  yosh: int64
  maosh: float64

=== 4. NaN tekshirish ===
  jami NaN: 0
  ⭐ O'qigandan keyin DOIM tekshir (head/shape/dtypes)

Nima ko'rsatdi: 2.5-bo'lim.

Misol 4 — To'liq oqim (fayl → tahlil → fayl)

"""To'liq oqim: fayl → tahlil → fayl (real pandas)."""

import os
import tempfile
import pandas as pd


def main() -> None:
    papka = tempfile.mkdtemp()
    kirish = os.path.join(papka, "savdo.csv")

    # tayyorlash
    pd.DataFrame({
        "mahsulot": ["olma", "non", "sut", "choy"],
        "narx": [100, 50, 80, 120],
        "miqdor": [10, 20, 15, 5],
    }).to_csv(kirish, index=False)

    print("=== 1. O'qish ===")
    df = pd.read_csv(kirish)
    print(f"  {df.shape[0]} qator o'qildi")

    print("\n=== 2. Tahlil (yangi ustun) ===")
    df["summa"] = df["narx"] * df["miqdor"]
    print(f"  summalar: {list(df['summa'])}")

    print("\n=== 3. Xulosa ===")
    print(f"  jami savdo: {df['summa'].sum()}")

    print("\n=== 4. Natijani saqlash ===")
    chiqish = os.path.join(papka, "natija.csv")
    df.to_csv(chiqish, index=False)
    print(f"  saqlandi (ustunlar: {len(df.columns)})")
    print("  ⭐ Oqim — fayl → tahlil → fayl")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

=== 1. O'qish ===
  4 qator o'qildi

=== 2. Tahlil (yangi ustun) ===
  summalar: [1000, 1000, 1200, 600]

=== 3. Xulosa ===
  jami savdo: 3800

=== 4. Natijani saqlash ===
  saqlandi (ustunlar: 4)
  ⭐ Oqim — fayl → tahlil → fayl

Nima ko'rsatdi: 2.8-bo'lim.

5. To'g'ri va noto'g'ri tushunishlar

6. Keng tarqalgan xatolar va yechimlari

1. Kodlash

pd.read_csv("f.csv")   # o'zbekcha buzilishi mumkin           # ⚠️
pd.read_csv("f.csv", encoding="utf-8")   # to'g'ri            # ✅

2. Ajratuvchi

pd.read_csv("yevropa.csv")   # ; — bir ustun bo'ladi         # ⚠️
pd.read_csv("yevropa.csv", sep=";")   # to'g'ri               # ✅

3. index=False unutish

df.to_csv("f.csv")   # keraksiz indeks ustuni                # ⚠️
df.to_csv("f.csv", index=False)   # toza                      # ✅

4. Fayl yo'li

pd.read_csv("yoq.csv")   # FileNotFoundError                 # ⚠️
# yo'lni tekshir (os.path.exists)                             # ✅

5. Tur avtomatik

# son ustun object (bo'sh joy/matn)                          # ⚠️
df["narx"] = df["narx"].astype(float)   # tur tuzatish        # ✅

6. Tekshirmaslik

df = pd.read_csv("f.csv")   # to'g'ridan ishlatish            # ⚠️
df.head(); df.info()   # avval tekshir                        # ✅

7. NaN belgisi

pd.read_csv("f.csv")   # '-' NaN deb tanilmaydi              # ⚠️
pd.read_csv("f.csv", na_values=["-", "NA"])   # aniqlash      # ✅

7. Integratsiya — bu bilim qayerda kerak bo'ladi

• 3.2-dars (o'tilgan): DataFrame
• 3.7-dars: Yo'q qiymatlar (o'qigandan keyin NaN)
• 6-qism: Tozalash (real fayl iflos)
• 4-qism: Statistika (o'qilgan ma'lumot tahlili)
• 20-qism: ML (ma'lumotni fayldan o'qish)

8. Eng yaxshi amaliyotlar

1. read_csv — CSV o'qish (eng ko'p).

2. to_csv(index=False) — toza yozish.

3. encoding="utf-8" — o'zbekcha harflar.

4. sep=";" — Yevropa CSV.

5. O'qigach head/info tekshir (doim).

6. dtypes tekshir (son object emasmi).

7. Yo'lni tekshir (FileNotFoundError).

8. O'qish/yozish — Data Science birinchi qadam.

9. Amaliy topshiriq

Vazifa 1: Bashorat qiling

1.  # read_csv nima?
2.  # CSV nima?
3.  # to_csv nima?
4.  # index=False nima uchun?
5.  # sep nima?
6.  # encoding nima uchun?
7.  # Excel qanday?
8.  # o'qigach nima qilamiz?
9.  # head nima ko'rsatadi?
10. # dtypes nima uchun?
11. # kodlash muammosi?
12. # nega o'qish birinchi qadam?

Vazifa 2: Xatolarni tuzating

1.  pd.read_csv("f.csv")   # o'zbekcha

2.  pd.read_csv("yevropa.csv")   # ;

3.  df.to_csv("f.csv")   # toza

4.  df = pd.read_csv("f.csv")   # tekshirmasdan

5.  # son ustun object

1.  encoding="utf-8"

2.  sep=";"

3.  index=False

4.  df.head(); df.info()

5.  df["narx"].astype(float)

Vazifa 3: O'qish

Modellang:

1. read_csv
2. CSV
3. Sarlavha
4. Turlar

Vazifa 4: Yozish

Modellang:

1. to_csv
2. index=False
3. Toza
4. Saqlash

Vazifa 5: Parametrlar

Modellang:

1. sep
2. encoding
3. header
4. usecols

Vazifa 6: Tekshirish

Modellang:

1. head
2. shape
3. info
4. dtypes

Vazifa 7: O'ylash

CSV (vergul bilan ajratilgan oddiy matn) — Data Science'da ma'lumot almashishning eng keng tarqalgan formati, garchi Excel yoki ma'lumotlar bazasi "boyroq" bo'lsa ham. Nima uchun oddiy matn formati (CSV) bu qadar mashhur, va uning oddiy tabiati qanday qilib ham kuch (universal), ham zaiflik (tur/kodlash muammolari) bo'lishi mumkin?

Nimani mustahkamlaydi: 2.3, 2.7-bo'limlar.

Xulosa

Bu darsda o'qish va yozishni o'rgandik.

Eng muhim uch fikr:

1. read_csv va to_csv. read_csv — CSV → DataFrame (eng ko'p ishlatiladi); CSV — vergul bilan ajratilgan oddiy matn (birinchi qator sarlavha, qolgan ma'lumot); Pandas turni avtomatik aniqlaydi. to_csv — DataFrame → CSV; index=False (muhim — indeks ustuni yozmaslik, toza). CSV universal (Excel, boshqa dastur o'qiydi).

2. Parametrlar va formatlar. read_csv parametrlari (real fayl turlicha): sep (ajratuvchi — sep=";" Yevropa), encoding (utf-8 — o'zbekcha harflar), header (None — sarlavha yo'q), index_col, usecols. Excel/JSON — read_excel (sheet_name — varaq), read_json (veb/ichma-ich); har format read_*/to_*.

3. Birinchi qadam. O'qiqandan keyin tekshirish — doim head (birinchi qatorlar — to'g'ri o'qildimi), shape (qator/ustun soni), info (turlar, NaN), dtypes (son object-mi); jim xato oldini (ajratuvchi/kodlash/tur). O'qish/yozish — Data Science birinchi qadam (real ma'lumot fayllarda; loyiha fayl o'qishdan boshlanadi, yozish bilan tugaydi; fayl → DataFrame → tahlil → fayl). CSV oddiy matn — universal (kuch) lekin tur/kodlash muammosi (zaiflik). Tuzoqlar: kodlash (utf-8), ajratuvchi (sep), index=False unutish, fayl yo'l, tur (son object — astype).

Keyingi darsda tanlash (.loc/.iloc)ni o'rganamiz: DataFrame'dan qator/ustun aniq tanlash — nom bo'yicha (.loc) va pozitsiya bo'yicha (.iloc), ma'lumotga aniq kirish.