Variabel dan Tipe Data Dasar Python

# Membuat variabel sederhana
nama = "Budi"
umur = 25
tinggi = 170.5

# Menampilkan nilai variabel
print(nama)
print(umur)
print(tinggi)

Budi
25
170.5

nama_lengkap = "Budi Santoso"
umur = 25
_kode_rahasia = "xyz123"
nilaiUjian = 90
nilai2 = 85

print(nama_lengkap, umur, _kode_rahasia, nilaiUjian, nilai2)

Budi Santoso 25 xyz123 90 85

2nilai = 85  # Tidak boleh dimulai dengan angka
nama-lengkap = "Budi"  # Tidak boleh menggunakan tanda hubung
if = "kondisi"  # Tidak boleh menggunakan kata kunci Python

# Konvensi yang baik
nama_pengguna = "budisantoso"
jumlah_produk = 15
harga_total = 250000

# Kurang direkomendasikan
nmpeg = "budisantoso"  # Tidak deskriptif
x = 15  # Terlalu singkat
HargaTotal = 250000  # Tidak mengikuti snake_case

print(f"Username: {nama_pengguna}")
print(f"Jumlah produk: {jumlah_produk}")
print(f"Total harga: Rp {harga_total}")

Username: budisantoso
Jumlah produk: 15
Total harga: Rp 250000

# Membuat variabel
skor = 0
print(f"Skor awal: {skor}")

# Mengubah nilai variabel
skor = 10
print(f"Skor setelah level 1: {skor}")

# Mengubah nilai lagi
skor = 25
print(f"Skor setelah level 2: {skor}")

# Menambah nilai ke variabel yang sudah ada
skor = skor + 15
print(f"Skor setelah bonus: {skor}")

# Cara singkat menambah nilai
skor += 5
print(f"Skor final: {skor}")

Skor awal: 0
Skor setelah level 1: 10
Skor setelah level 2: 25
Skor setelah bonus: 40
Skor final: 45

# Menetapkan nilai yang sama ke beberapa variabel
x = y = z = 0
print(x, y, z)

# Menetapkan beberapa nilai ke beberapa variabel
nama, umur, kota = "Ani", 22, "Jakarta"
print(f"{nama} berumur {umur} tahun dan tinggal di {kota}")

# Swap nilai variabel dengan mudah
a = 5
b = 10
print(f"Sebelum swap: a = {a}, b = {b}")

a, b = b, a
print(f"Setelah swap: a = {a}, b = {b}")

0 0 0
Ani berumur 22 tahun dan tinggal di Jakarta
Sebelum swap: a = 5, b = 10
Setelah swap: a = 10, b = 5

# Contoh integer
umur = 25
tahun_lahir = 1998
suhu_minus = -5
angka_besar = 1_000_000  # Underscore untuk memudahkan pembacaan

print(umur)
print(tahun_lahir)
print(suhu_minus)
print(angka_besar)

# Cek tipe data
print(type(umur))

25
1998
-5
1000000
<class 'int'>

# Contoh float
berat = 65.5
tinggi = 170.2
pi = 3.14159
nilai_scientific = 1.5e6  # 1.5 × 10^6

print(berat)
print(tinggi)
print(pi)
print(nilai_scientific)

# Cek tipe data
print(type(berat))

65.5
170.2
3.14159
1500000.0
<class 'float'>

# Contoh bilangan kompleks
bilangan_kompleks = 2 + 3j
print(bilangan_kompleks)
print(bilangan_kompleks.real)  # Bagian real
print(bilangan_kompleks.imag)  # Bagian imajiner
print(type(bilangan_kompleks))

(2+3j)
2.0
3.0
<class 'complex'>

# Contoh string
nama = "Budi Santoso"
pesan = 'Halo, apa kabar?'
alamat = "Jl. Merdeka No. 123"

print(nama)
print(pesan)
print(alamat)
print(type(nama))

Budi Santoso
Halo, apa kabar?
Jl. Merdeka No. 123
<class 'str'>

# String multiline
deskripsi = """Python adalah bahasa pemrograman yang mudah dipelajari.
Bahasa ini memiliki sintaks yang sederhana dan mudah dibaca.
Python sering digunakan untuk data science, web development, dan automation."""

print(deskripsi)

Python adalah bahasa pemrograman yang mudah dipelajari.
Bahasa ini memiliki sintaks yang sederhana dan mudah dibaca.
Python sering digunakan untuk data science, web development, dan automation.

# Concatenation (Penggabungan)
nama_depan = "Budi"
nama_belakang = "Santoso"
nama_lengkap = nama_depan + " " + nama_belakang
print(nama_lengkap)

# String repetition (Pengulangan)
pattern = "-+" * 10
print(pattern)

# Indexing (Mengakses karakter berdasarkan indeks)
kata = "Python"
print(kata[0])  # Karakter pertama (indeks dimulai dari 0)
print(kata[5])  # Karakter terakhir
print(kata[-1])  # Cara lain mengakses karakter terakhir

# Slicing (Mengambil substring)
kalimat = "Belajar Python itu menyenangkan"
print(kalimat[8:14])  # Mengambil kata "Python"
print(kalimat[:7])    # Dari awal hingga indeks 6
print(kalimat[15:])   # Dari indeks 15 hingga akhir
print(kalimat[-13:])  # 13 karakter terakhir

# String methods (Metode string)
teks = "halo, dunia python!"
print(teks.upper())        # Mengubah ke huruf besar
print(teks.capitalize())   # Kapitalisasi huruf pertama
print(teks.title())        # Kapitalisasi setiap kata
print(teks.replace("python", "Java"))  # Mengganti substring
print(teks.split(", "))    # Memisahkan string menjadi list

Budi Santoso
-+-+-+-+-+-+-+-+-+-+
P
n
n
Python
Belajar
itu menyenangkan
menyenangkan!
HALO, DUNIA PYTHON!
Halo, dunia python!
Halo, Dunia Python!
halo, dunia Java!
['halo', 'dunia python!']

nama = "Budi"
umur = 25

# Menggunakan + operator
print("Nama: " + nama + ", Umur: " + str(umur))

# Menggunakan format() method
print("Nama: {}, Umur: {}".format(nama, umur))

# Menggunakan f-string (Python 3.6+)
print(f"Nama: {nama}, Umur: {umur}")

# Formatting angka dengan f-string
harga = 1250000
print(f"Harga produk: Rp {harga:,}")  # Menambahkan pemisah ribuan
print(f"Suhu: {36.7:.1f}°C")  # Satu angka di belakang koma

Nama: Budi, Umur: 25
Nama: Budi, Umur: 25
Nama: Budi, Umur: 25
Harga produk: Rp 1,250,000
Suhu: 36.7°C

# Contoh nilai boolean
sedang_hujan = True
liburan = False

print(sedang_hujan)
print(liburan)
print(type(sedang_hujan))

# Boolean dari operasi perbandingan
umur = 18
dewasa = umur >= 17
print(f"Apakah sudah dewasa? {dewasa}")

nilai = 75
lulus = nilai >= 60
print(f"Apakah lulus? {lulus}")

True
False
<class 'bool'>
Apakah sudah dewasa? True
Apakah lulus? True

a = True
b = False

# Operasi AND
print(f"a AND b: {a and b}")

# Operasi OR
print(f"a OR b: {a or b}")

# Operasi NOT
print(f"NOT a: {not a}")
print(f"NOT b: {not b}")

# Kombinasi operasi logika
c = True
hasil = (a and c) or b
print(f"(a AND c) OR b: {hasil}")

# Contoh penggunaan pada kondisi
umur = 20
memiliki_sim = True

boleh_mengemudi = umur >= 17 and memiliki_sim
print(f"Boleh mengemudi? {boleh_mengemudi}")

a AND b: False
a OR b: True
NOT a: False
NOT b: True
(a AND c) OR b: True
Boleh mengemudi? True

# Contoh list
buah = ["apel", "jeruk", "mangga", "pisang"]
nilai = [85, 90, 75, 95]
campuran = ["Python", 3.9, True, [1, 2, 3]]

print(buah)
print(nilai)
print(campuran)
print(type(buah))

['apel', 'jeruk', 'mangga', 'pisang']
[85, 90, 75, 95]
['Python', 3.9, True, [1, 2, 3]]
<class 'list'>

buah = ["apel", "jeruk", "mangga", "pisang", "anggur"]

# Mengakses dengan indeks
print(buah[0])  # Elemen pertama
print(buah[2])  # Elemen ketiga
print(buah[-1])  # Elemen terakhir

# Slicing list
print(buah[1:4])  # Elemen indeks 1, 2, 3
print(buah[:3])   # Dari awal hingga indeks 2
print(buah[2:])   # Dari indeks 2 hingga akhir

# List dalam list (nested list)
matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
print(matrix[1])     # Baris kedua
print(matrix[1][2])  # Elemen di baris ke-2, kolom ke-3

apel
mangga
anggur
['jeruk', 'mangga', 'pisang']
['apel', 'jeruk', 'mangga']
['mangga', 'pisang', 'anggur']
[4, 5, 6]
6

buah = ["apel", "jeruk", "mangga"]
print(f"List awal: {buah}")

# Menambah elemen
buah.append("pisang")
print(f"Setelah append: {buah}")

buah.insert(1, "strawberry")
print(f"Setelah insert: {buah}")

# Menggabungkan list
buah.extend(["anggur", "kiwi"])
print(f"Setelah extend: {buah}")

# Menghapus elemen
buah.remove("jeruk")
print(f"Setelah remove: {buah}")

buah_terakhir = buah.pop()
print(f"Item yang di-pop: {buah_terakhir}")
print(f"Setelah pop: {buah}")

del buah[1]
print(f"Setelah del: {buah}")

# Mencari elemen
posisi = buah.index("mangga")
print(f"Posisi 'mangga': {posisi}")

# Menghitung jumlah kemunculan
new_list = [1, 2, 3, 2, 2, 4, 5]
print(f"Jumlah angka 2: {new_list.count(2)}")

# Mengurutkan list
angka = [5, 2, 8, 1, 9]
angka.sort()
print(f"List setelah diurutkan: {angka}")

buah.sort(reverse=True)  # Mengurutkan secara terbalik
print(f"Buah diurutkan terbalik: {buah}")

# Membalik urutan list
angka.reverse()
print(f"List setelah direverse: {angka}")

# Membuat salinan list
buah_copy = buah.copy()
print(f"Salinan list buah: {buah_copy}")

List awal: ['apel', 'jeruk', 'mangga']
Setelah append: ['apel', 'jeruk', 'mangga', 'pisang']
Setelah insert: ['apel', 'strawberry', 'jeruk', 'mangga', 'pisang']
Setelah extend: ['apel', 'strawberry', 'jeruk', 'mangga', 'pisang', 'anggur', 'kiwi']
Setelah remove: ['apel', 'strawberry', 'mangga', 'pisang', 'anggur', 'kiwi']
Item yang di-pop: kiwi
Setelah pop: ['apel', 'strawberry', 'mangga', 'pisang', 'anggur']
Setelah del: ['apel', 'mangga', 'pisang', 'anggur']
Posisi 'mangga': 1
Jumlah angka 2: 3
List setelah diurutkan: [1, 2, 5, 8, 9]
Buah diurutkan terbalik: ['pisang', 'mangga', 'anggur', 'apel']
List setelah direverse: [9, 8, 5, 2, 1]
Salinan list buah: ['pisang', 'mangga', 'anggur', 'apel']

# Tanpa list comprehension
kuadrat = []
for i in range(1, 6):
    kuadrat.append(i ** 2)
print(f"Kuadrat (cara biasa): {kuadrat}")

# Dengan list comprehension
kuadrat_lc = [i ** 2 for i in range(1, 6)]
print(f"Kuadrat (list comprehension): {kuadrat_lc}")

# List comprehension dengan kondisi
genap = [x for x in range(1, 11) if x % 2 == 0]
print(f"Bilangan genap 1-10: {genap}")

# List comprehension lebih kompleks
nama_buah = ["apel", "jeruk", "mangga", "pisang"]
buah_panjang = [buah.upper() for buah in nama_buah if len(buah) > 5]
print(f"Buah dengan nama >5 huruf: {buah_panjang}")

Kuadrat (cara biasa): [1, 4, 9, 16, 25]
Kuadrat (list comprehension): [1, 4, 9, 16, 25]
Bilangan genap 1-10: [2, 4, 6, 8, 10]
Buah dengan nama >5 huruf: ['MANGGA', 'PISANG']

# Contoh tuple
warna = ("merah", "hijau", "biru")
koordinat = (10.5, 15.2)
campuran = ("Python", 3.9, True, (1, 2, 3))

print(warna)
print(koordinat)
print(campuran)
print(type(warna))

# Tuple dengan satu elemen
single_tuple = (42,)  # Tanda koma wajib untuk single element
print(single_tuple)
print(type(single_tuple))

('merah', 'hijau', 'biru')
(10.5, 15.2)
('Python', 3.9, True, (1, 2, 3))
<class 'tuple'>
(42,)
<class 'tuple'>

warna = ("merah", "hijau", "biru", "kuning", "ungu")

# Mengakses dengan indeks
print(warna[0])  # Elemen pertama
print(warna[2])  # Elemen ketiga
print(warna[-1])  # Elemen terakhir

# Slicing tuple
print(warna[1:4])  # Elemen indeks 1, 2, 3
print(warna[:3])   # Dari awal hingga indeks 2
print(warna[2:])   # Dari indeks 2 hingga akhir

# Coba ubah tuple (akan error)
try:
    warna[0] = "hitam"
except TypeError as e:
    print(f"Error: {e}")

merah
biru
ungu
('hijau', 'biru', 'kuning')
('merah', 'hijau', 'biru')
('biru', 'kuning', 'ungu')
Error: 'tuple' object does not support item assignment

# Menggabungkan tuple
tuple1 = (1, 2, 3)
tuple2 = (4, 5, 6)
gabungan = tuple1 + tuple2
print(f"Gabungan tuple: {gabungan}")

# Mengulang tuple
ulang = tuple1 * 3
print(f"Tuple diulang 3x: {ulang}")

# Menghitung elemen
angka = (1, 2, 3, 2, 2, 4, 5)
print(f"Jumlah angka 2: {angka.count(2)}")

# Mencari indeks elemen
print(f"Indeks pertama angka 3: {angka.index(3)}")

# Packing dan unpacking tuple
info = ("Budi", 25, "Jakarta")
nama, umur, kota = info  # Unpacking

print(f"Nama: {nama}")
print(f"Umur: {umur}")
print(f"Kota: {kota}")

# Swap dengan tuple packing/unpacking
a = 5
b = 10
print(f"Sebelum swap: a = {a}, b = {b}")

a, b = b, a  # Swap menggunakan tuple
print(f"Setelah swap: a = {a}, b = {b}")

Gabungan tuple: (1, 2, 3, 4, 5, 6)
Tuple diulang 3x: (1, 2, 3, 1, 2, 3, 1, 2, 3)
Jumlah angka 2: 3
Indeks pertama angka 3: 2
Nama: Budi
Umur: 25
Kota: Jakarta
Sebelum swap: a = 5, b = 10
Setelah swap: a = 10, b = 5

# Contoh dictionary
mahasiswa = {
    "nama": "Budi",
    "umur": 20,
    "jurusan": "Teknik Informatika",
    "aktif": True
}

print(mahasiswa)
print(type(mahasiswa))

# Dictionary dengan tipe key dan value yang berbeda
campuran = {
    "string": "nilai",
    10: "sepuluh",
    (1, 2): "tuple sebagai key",
    True: "boolean key"
}

print(campuran)

{'nama': 'Budi', 'umur': 20, 'jurusan': 'Teknik Informatika', 'aktif': True}
<class 'dict'>
{'string': 'nilai', 10: 'sepuluh', (1, 2): 'tuple sebagai key', True: 'boolean key'}

mahasiswa = {
    "nama": "Budi",
    "umur": 20,
    "jurusan": "Teknik Informatika",
    "nilai": [85, 90, 78]
}

# Mengakses value dengan key
print(f"Nama: {mahasiswa['nama']}")
print(f"Umur: {mahasiswa['umur']}")
print(f"Nilai pertama: {mahasiswa['nilai'][0]}")

# Menggunakan method get() (lebih aman)
print(f"Jurusan: {mahasiswa.get('jurusan')}")
print(f"Alamat: {mahasiswa.get('alamat', 'Tidak ada')}")  # Default jika key tidak ada

# Mengubah value
mahasiswa["umur"] = 21
print(f"Umur baru: {mahasiswa['umur']}")

# Menambah key-value baru
mahasiswa["alamat"] = "Jakarta"
print(f"Dictionary setelah ditambah: {mahasiswa}")

# Menghapus key-value
del mahasiswa["nilai"]
print(f"Dictionary setelah nilai dihapus: {mahasiswa}")

# Pop method (menghapus dan mengembalikan value)
jurusan = mahasiswa.pop("jurusan")
print(f"Jurusan yang dihapus: {jurusan}")
print(f"Dictionary setelah pop: {mahasiswa}")

Nama: Budi
Umur: 20
Nilai pertama: 85
Jurusan: Teknik Informatika
Alamat: Tidak ada
Umur baru: 21
Dictionary setelah ditambah: {'nama': 'Budi', 'umur': 21, 'jurusan': 'Teknik Informatika', 'nilai': [85, 90, 78], 'alamat': 'Jakarta'}
Dictionary setelah nilai dihapus: {'nama': 'Budi', 'umur': 21, 'jurusan': 'Teknik Informatika', 'alamat': 'Jakarta'}
Jurusan yang dihapus: Teknik Informatika
Dictionary setelah pop: {'nama': 'Budi', 'umur': 21, 'alamat': 'Jakarta'}

mahasiswa = {
    "nama": "Budi",
    "umur": 21,
    "jurusan": "Teknik Informatika"
}

# Mendapatkan semua key
keys = mahasiswa.keys()
print(f"Semua key: {keys}")

# Mendapatkan semua value
values = mahasiswa.values()
print(f"Semua value: {values}")

# Mendapatkan semua pasangan key-value
items = mahasiswa.items()
print(f"Semua items: {items}")

# Menggabungkan dictionary
info_tambahan = {
    "semester": 4,
    "ipk": 3.75
}

mahasiswa.update(info_tambahan)
print(f"Dictionary setelah update: {mahasiswa}")

# Menghapus semua items
mahasiswa_copy = mahasiswa.copy()  # Membuat salinan
mahasiswa_copy.clear()
print(f"Dictionary setelah clear: {mahasiswa_copy}")

# Dictionary comprehension
kuadrat = {x: x**2 for x in range(1, 6)}
print(f"Dictionary kuadrat: {kuadrat}")

Semua key: dict_keys(['nama', 'umur', 'jurusan'])
Semua value: dict_values(['Budi', 21, 'Teknik Informatika'])
Semua items: dict_items([('nama', 'Budi'), ('umur', 21), ('jurusan', 'Teknik Informatika')])
Dictionary setelah update: {'nama': 'Budi', 'umur': 21, 'jurusan': 'Teknik Informatika', 'semester': 4, 'ipk': 3.75}
Dictionary setelah clear: {}
Dictionary kuadrat: {1: 1, 2: 4, 3: 9, 4: 16, 5: 25}

# Nested dictionary
mahasiswa = {
    "101": {
        "nama": "Budi",
        "umur": 21,
        "jurusan": "Informatika",
        "nilai": {"matematika": 85, "pemrograman": 90}
    },
    "102": {
        "nama": "Ani",
        "umur": 20,
        "jurusan": "Sistem Informasi",
        "nilai": {"matematika": 80, "pemrograman": 95}
    }
}

# Mengakses nested dictionary
print(f"Nama mahasiswa 101: {mahasiswa['101']['nama']}")
print(f"Nilai pemrograman Ani: {mahasiswa['102']['nilai']['pemrograman']}")

# Menambah data
mahasiswa["101"]["nilai"]["database"] = 88
print(f"Nilai baru Budi: {mahasiswa['101']['nilai']}")

# Loop nested dictionary
for id, info in mahasiswa.items():
    print(f"\nID: {id}")
    print(f"Nama: {info['nama']}")
    print(f"Jurusan: {info['jurusan']}")
    print("Nilai:")
    for mata_kuliah, nilai in info['nilai'].items():
        print(f"  - {mata_kuliah}: {nilai}")

Nama mahasiswa 101: Budi
Nilai pemrograman Ani: 95
Nilai baru Budi: {'matematika': 85, 'pemrograman': 90, 'database': 88}

ID: 101
Nama: Budi
Jurusan: Informatika
Nilai:
  - matematika: 85
  - pemrograman: 90
  - database: 88

ID: 102
Nama: Ani
Jurusan: Sistem Informasi
Nilai:
  - matematika: 80
  - pemrograman: 95

# Contoh set
buah = {"apel", "jeruk", "mangga", "apel"}  # Duplikat akan dihapus
print(buah)
print(type(buah))

# Membuat set dari list
angka = set([1, 2, 3, 2, 1, 4, 5])
print(f"Set dari list: {angka}")

# Set kosong (harus menggunakan constructor set())
kosong = set()  # {} akan membuat empty dictionary
print(type(kosong))

{'jeruk', 'apel', 'mangga'}
<class 'set'>
Set dari list: {1, 2, 3, 4, 5}
<class 'set'>

# Menambah dan menghapus elemen
buah = {"apel", "jeruk", "mangga"}
print(f"Set awal: {buah}")

buah.add("pisang")
print(f"Setelah add: {buah}")

buah.update(["anggur", "kiwi"])
print(f"Setelah update: {buah}")

buah.remove("jeruk")
print(f"Setelah remove: {buah}")

buah.discard("tidak ada")  # Tidak error jika elemen tidak ada
print(f"Setelah discard: {buah}")

buah_pop = buah.pop()  # Menghapus elemen acak
print(f"Item yang di-pop: {buah_pop}")
print(f"Setelah pop: {buah}")

# Set comprehension
kuadrat = {x**2 for x in range(1, 6)}
print(f"Set kuadrat: {kuadrat}")

Set awal: {'jeruk', 'apel', 'mangga'}
Setelah add: {'jeruk', 'pisang', 'apel', 'mangga'}
Setelah update: {'jeruk', 'pisang', 'kiwi', 'anggur', 'apel', 'mangga'}
Setelah remove: {'pisang', 'kiwi', 'anggur', 'apel', 'mangga'}
Setelah discard: {'pisang', 'kiwi', 'anggur', 'apel', 'mangga'}
Item yang di-pop: pisang
Setelah pop: {'kiwi', 'anggur', 'apel', 'mangga'}
Set kuadrat: {1, 4, 9, 16, 25}

# Operasi himpunan
A = {1, 2, 3, 4, 5}
B = {4, 5, 6, 7, 8}

# Union (gabungan)
print(f"A ∪ B: {A | B}")  # Atau A.union(B)

# Intersection (irisan)
print(f"A ∩ B: {A & B}")  # Atau A.intersection(B)

# Difference (selisih)
print(f"A - B: {A - B}")  # Atau A.difference(B)
print(f"B - A: {B - A}")  # Atau B.difference(A)

# Symmetric difference (elemen di A atau B tapi tidak di keduanya)
print(f"A △ B: {A ^ B}")  # Atau A.symmetric_difference(B)

# Subset dan superset
C = {1, 2}
print(f"Apakah C subset dari A? {C.issubset(A)}")
print(f"Apakah A superset dari C? {A.issuperset(C)}")
print(f"Apakah A dan B disjoint? {A.isdisjoint(B)}")  # False karena ada irisan

A ∪ B: {1, 2, 3, 4, 5, 6, 7, 8}
A ∩ B: {4, 5}
A - B: {1, 2, 3}
B - A: {8, 6, 7}
A △ B: {1, 2, 3, 6, 7, 8}
Apakah C subset dari A? True
Apakah A superset dari C? True
Apakah A dan B disjoint? False

# Contoh penggunaan None
variabel = None
print(variabel)
print(type(variabel))

# Cek apakah nilai None
print(f"Apakah variabel None? {variabel is None}")

# Menggunakan None sebagai default argument
def fungsi(x=None):
    if x is None:
        return "Tidak ada nilai"
    return f"Nilai: {x}"

print(fungsi())
print(fungsi(10))

# None dalam conditional statements
nilai = None
if nilai is None:
    print("Nilai belum diatur")
else:
    print(f"Nilai adalah {nilai}")

None
<class 'NoneType'>
Apakah variabel None? True
Tidak ada nilai
Nilai: 10
Nilai belum diatur

# Integer ke tipe lain
angka = 10
print(f"Integer: {angka}, tipe: {type(angka)}")

float_dari_int = float(angka)
print(f"Float dari integer: {float_dari_int}, tipe: {type(float_dari_int)}")

str_dari_int = str(angka)
print(f"String dari integer: {str_dari_int}, tipe: {type(str_dari_int)}")

# Float ke tipe lain
desimal = 10.5
print(f"Float: {desimal}, tipe: {type(desimal)}")

int_dari_float = int(desimal)  # Memotong desimal, bukan pembulatan
print(f"Integer dari float: {int_dari_float}, tipe: {type(int_dari_float)}")

# String ke numerik
angka_str = "25"
print(f"String: {angka_str}, tipe: {type(angka_str)}")

int_dari_str = int(angka_str)
print(f"Integer dari string: {int_dari_str}, tipe: {type(int_dari_str)}")

float_dari_str = float(angka_str)
print(f"Float dari string: {float_dari_str}, tipe: {type(float_dari_str)}")

# String ke list
kalimat = "Hello, World"
list_dari_str = list(kalimat)
print(f"List dari string: {list_dari_str}")

# List/tuple ke set (menghilangkan duplikat)
angka_duplikat = [1, 2, 3, 2, 1, 4, 5]
set_dari_list = set(angka_duplikat)
print(f"Set dari list: {set_dari_list}")

# List/tuple ke dictionary
pasangan = [('a', 1), ('b', 2), ('c', 3)]
dict_dari_list = dict(pasangan)
print(f"Dictionary dari list pasangan: {dict_dari_list}")

Integer: 10, tipe: <class 'int'>
Float dari integer: 10.0, tipe: <class 'float'>
String dari integer: 10, tipe: <class 'str'>
Float: 10.5, tipe: <class 'float'>
Integer dari float: 10, tipe: <class 'int'>
String: 25, tipe: <class 'str'>
Integer dari string: 25, tipe: <class 'int'>
Float dari string: 25.0, tipe: <class 'float'>
List dari string: ['H', 'e', 'l', 'l', 'o', ',', ' ', 'W', 'o', 'r', 'l', 'd']
Set dari list: {1, 2, 3, 4, 5}
Dictionary dari list pasangan: {'a': 1, 'b': 2, 'c': 3}

# Menggunakan fungsi type()
x = 10
y = "Hello"
z = [1, 2, 3]

print(f"Tipe x: {type(x)}")
print(f"Tipe y: {type(y)}")
print(f"Tipe z: {type(z)}")

# Menggunakan isinstance()
print(f"Apakah x integer? {isinstance(x, int)}")
print(f"Apakah y string? {isinstance(y, str)}")
print(f"Apakah z list? {isinstance(z, list)}")
print(f"Apakah z tuple? {isinstance(z, tuple)}")

# Cek multiple types
print(f"Apakah x integer atau float? {isinstance(x, (int, float))}")

Tipe x: <class 'int'>
Tipe y: <class 'str'>
Tipe z: <class 'list'>
Apakah x integer? True
Apakah y string? True
Apakah z list? True
Apakah z tuple? False
Apakah x integer atau float? True

# Data mahasiswa
nama = "Budi Santoso"
nim = "123456789"
nilai_tugas = 85
nilai_uts = 78
nilai_uas = 90

# Menghitung nilai akhir (30% tugas, 30% UTS, 40% UAS)
nilai_akhir = (nilai_tugas * 0.3) + (nilai_uts * 0.3) + (nilai_uas * 0.4)

# Menentukan grade
if nilai_akhir >= 85:
    grade = "A"
elif nilai_akhir >= 75:
    grade = "B"
elif nilai_akhir >= 65:
    grade = "C"
elif nilai_akhir >= 55:
    grade = "D"
else:
    grade = "E"

# Output
print("============ Hasil Nilai ============")
print(f"Nama: {nama}")
print(f"NIM: {nim}")
print(f"Nilai Tugas: {nilai_tugas}")
print(f"Nilai UTS: {nilai_uts}")
print(f"Nilai UAS: {nilai_uas}")
print(f"Nilai Akhir: {nilai_akhir:.2f}")
print(f"Grade: {grade}")
print("====================================")

============ Hasil Nilai ============
Nama: Budi Santoso
NIM: 123456789
Nilai Tugas: 85
Nilai UTS: 78
Nilai UAS: 90
Nilai Akhir: 84.90
Grade: B
====================================

# Aplikasi manajemen kontak sederhana
kontak = {
    "Budi": {
        "telepon": "08123456789",
        "email": "[email protected]",
        "alamat": "Jakarta"
    },
    "Ani": {
        "telepon": "08234567890",
        "email": "[email protected]",
        "alamat": "Bandung"
    }
}

# Fungsi untuk menampilkan semua kontak
def tampilkan_semua_kontak():
    print("\n=== Daftar Kontak ===")
    if not kontak:
        print("Tidak ada kontak tersimpan")
        return
    
    for nama, info in kontak.items():
        print(f"\nNama: {nama}")
        print(f"Telepon: {info['telepon']}")
        print(f"Email: {info['email']}")
        print(f"Alamat: {info['alamat']}")
    print("=====================")

# Fungsi untuk menambah kontak
def tambah_kontak(nama, telepon, email, alamat):
    if nama in kontak:
        print(f"Kontak dengan nama {nama} sudah ada!")
        return False
    
    kontak[nama] = {
        "telepon": telepon,
        "email": email,
        "alamat": alamat
    }
    print(f"Kontak {nama} berhasil ditambahkan!")
    return True

# Fungsi untuk mencari kontak
def cari_kontak(nama):
    if nama in kontak:
        info = kontak[nama]
        print(f"\n=== Kontak Ditemukan ===")
        print(f"Nama: {nama}")
        print(f"Telepon: {info['telepon']}")
        print(f"Email: {info['email']}")
        print(f"Alamat: {info['alamat']}")
        print("========================")
        return True
    else:
        print(f"Kontak dengan nama {nama} tidak ditemukan!")
        return False

# Demonstrasi program
tampilkan_semua_kontak()

# Tambah kontak baru
tambah_kontak("Citra", "08345678901", "[email protected]", "Surabaya")

# Tampilkan setelah penambahan
tampilkan_semua_kontak()

# Cari kontak
cari_kontak("Ani")
cari_kontak("Dodi")  # Tidak ada

=== Daftar Kontak ===

Nama: Budi
Telepon: 08123456789
Email: [email protected]
Alamat: Jakarta

Nama: Ani
Telepon: 08234567890
Email: [email protected]
Alamat: Bandung
=====================
Kontak Citra berhasil ditambahkan!

=== Daftar Kontak ===

Nama: Budi
Telepon: 08123456789
Email: [email protected]
Alamat: Jakarta

Nama: Ani
Telepon: 08234567890
Email: [email protected]
Alamat: Bandung

Nama: Citra
Telepon: 08345678901
Email: [email protected]
Alamat: Surabaya
=====================

=== Kontak Ditemukan ===
Nama: Ani
Telepon: 08234567890
Email: [email protected]
Alamat: Bandung
========================
Kontak dengan nama Dodi tidak ditemukan!

# Data penjualan produk
data_penjualan = [
    {"produk": "Laptop", "unit": 5, "harga": 12000000},
    {"produk": "Smartphone", "unit": 10, "harga": 5000000},
    {"produk": "Tablet", "unit": 7, "harga": 3500000},
    {"produk": "Headphone", "unit": 15, "harga": 500000}
]

# Fungsi untuk menghitung total penjualan
def hitung_total_penjualan():
    total = 0
    for item in data_penjualan:
        total += item["unit"] * item["harga"]
    return total

# Fungsi untuk mencari produk terlaris
def produk_terlaris():
    terlaris = data_penjualan[0]
    for item in data_penjualan:
        if item["unit"] > terlaris["unit"]:
            terlaris = item
    return terlaris

# Fungsi untuk mencari produk dengan pendapatan tertinggi
def pendapatan_tertinggi():
    tertinggi = data_penjualan[0]
    pendapatan_tertinggi = tertinggi["unit"] * tertinggi["harga"]
    
    for item in data_penjualan:
        pendapatan = item["unit"] * item["harga"]
        if pendapatan > pendapatan_tertinggi:
            tertinggi = item
            pendapatan_tertinggi = pendapatan
    
    return tertinggi, pendapatan_tertinggi

# Analisis data
total_penjualan = hitung_total_penjualan()
produk_laris = produk_terlaris()
pdt_tertinggi, nilai_pendapatan = pendapatan_tertinggi()

# Tampilkan hasil analisis
print("===== Laporan Analisis Penjualan =====")
print(f"Total penjualan: Rp {total_penjualan:,}")
print(f"\nProduk terlaris: {produk_laris['produk']}")
print(f"Unit terjual: {produk_laris['unit']}")

print(f"\nProduk dengan pendapatan tertinggi: {pdt_tertinggi['produk']}")
print(f"Pendapatan: Rp {nilai_pendapatan:,}")

# Rata-rata penjualan per unit
total_unit = sum(item["unit"] for item in data_penjualan)
print(f"\nTotal unit terjual: {total_unit}")
print(f"Rata-rata pendapatan per unit: Rp {total_penjualan / total_unit:,.2f}")

===== Laporan Analisis Penjualan =====
Total penjualan: Rp 134,500,000
Produk terlaris: Headphone
Unit terjual: 15

Produk dengan pendapatan tertinggi: Laptop
Pendapatan: Rp 60,000,000

Total unit terjual: 37
Rata-rata pendapatan per unit: Rp 3,635,135.14