import Büyüksünlean.Büyük
1 Beğeni
sağol abi haklısın yani
Python da 2 de True’dur diye biliyorum.
Ellerine sağlık. Ama bence daha fazla durumu kapsaman lazım. Mesela listeler ve nesneler. Bunun için bool gömülü fonksiyonunu kullanabilirsin. Ayrıca bu yazdığın fonksiyonda hata fırlatmaya gerek olduğunu sanmıyorum. Ya True ya da False döner her durumda sadece.
sağol, bu arada anca böyle yaptım yani bunun benzeri gibi:
ornek = True
# Normal boolean
class boolean:
@staticmethod
def boolean(value):
if value == 1 or value == "true":
return "true"
elif value == 0 or value == "false":
return "false"
else:
raise boolean.BoolError("Value must be 0, 1, true or false.")
class BoolError(Exception):
pass
a_bool = boolean.boolean(0) #false
print(a_bool)
c_bool = boolean.boolean("true") #true
print(c_bool)
b_bool = boolean.boolean(2) #BoolError: raise boolean.BoolError("Value must be 0, 1, true or false.")
print(b_bool)
# Alternatif boolean(boolean'in benzeri)
0 yazacakmışım 2 yazmışım. kodda doğru da yazıda hata yapmışım 
ya 0 ya da 1 yazacaksın, ya da "true" ya da "false" yazacaksın, diğerleri ise hata verir.
Peki Fatih baba. Şöyle yazınca neden hata vermiyor:
b_bool = boolean.boolean(-1&1) #BoolError: raise boolean.BoolError(“Value must be 0, 1, true or false.”)
print(b_bool)
Neticede “-1&1” ifadesi bir işlem, boolean sayı değil.
Ne olacak bu boolean işleri Fatih baba…
Olay bu kadar basit değil.
Öncelikle bool bir builtin sınıf.
Yani python da yerleşik bir tanım.
Ve birden çok nesneye uygulanabilir şekild geniş tanımalamadan oluşuyor.
Yani olay bir ve sıfır da, nesneler çeşitli.
cpython/Objects/boolobject.c at main · python/cpython · GitHub
Burada bool tipinin tanımlandığı modülü göreceksin.
Hatta psikopatlık olsun, satır satır üzerinde konuşmak isteyen varsa diye kodu alıntılayım.
/* Boolean type, a subtype of int */
#include "Python.h"
#include "pycore_long.h" // FALSE_TAG TRUE_TAG
#include "pycore_modsupport.h" // _PyArg_NoKwnames()
#include "pycore_object.h" // _Py_FatalRefcountError()
#include "pycore_runtime.h" // _Py_ID()
#include <stddef.h>
/* We define bool_repr to return "False" or "True" */
static PyObject *
bool_repr(PyObject *self)
{
return self == Py_True ? &_Py_ID(True) : &_Py_ID(False);
}
/* Function to return a bool from a C long */
PyObject *PyBool_FromLong(long ok)
{
return ok ? Py_True : Py_False;
}
/* We define bool_new to always return either Py_True or Py_False */
static PyObject *
bool_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
{
PyObject *x = Py_False;
long ok;
if (!_PyArg_NoKeywords("bool", kwds))
return NULL;
if (!PyArg_UnpackTuple(args, "bool", 0, 1, &x))
return NULL;
ok = PyObject_IsTrue(x);
if (ok < 0)
return NULL;
return PyBool_FromLong(ok);
}
static PyObject *
bool_vectorcall(PyObject *type, PyObject * const*args,
size_t nargsf, PyObject *kwnames)
{
long ok = 0;
if (!_PyArg_NoKwnames("bool", kwnames)) {
return NULL;
}
Py_ssize_t nargs = PyVectorcall_NARGS(nargsf);
if (!_PyArg_CheckPositional("bool", nargs, 0, 1)) {
return NULL;
}
assert(PyType_Check(type));
if (nargs) {
ok = PyObject_IsTrue(args[0]);
if (ok < 0) {
return NULL;
}
}
return PyBool_FromLong(ok);
}
/* Arithmetic operations redefined to return bool if both args are bool. */
static PyObject *
bool_invert(PyObject *v)
{
if (PyErr_WarnEx(PyExc_DeprecationWarning,
"Bitwise inversion '~' on bool is deprecated and will be removed in "
"Python 3.16. This returns the bitwise inversion of the underlying int "
"object and is usually not what you expect from negating "
"a bool. Use the 'not' operator for boolean negation or "
"~int(x) if you really want the bitwise inversion of the "
"underlying int.",
1) < 0) {
return NULL;
}
return PyLong_Type.tp_as_number->nb_invert(v);
}
static PyObject *
bool_and(PyObject *a, PyObject *b)
{
if (!PyBool_Check(a) || !PyBool_Check(b))
return PyLong_Type.tp_as_number->nb_and(a, b);
return PyBool_FromLong((a == Py_True) & (b == Py_True));
}
static PyObject *
bool_or(PyObject *a, PyObject *b)
{
if (!PyBool_Check(a) || !PyBool_Check(b))
return PyLong_Type.tp_as_number->nb_or(a, b);
return PyBool_FromLong((a == Py_True) | (b == Py_True));
}
static PyObject *
bool_xor(PyObject *a, PyObject *b)
{
if (!PyBool_Check(a) || !PyBool_Check(b))
return PyLong_Type.tp_as_number->nb_xor(a, b);
return PyBool_FromLong((a == Py_True) ^ (b == Py_True));
}
/* Doc string */
PyDoc_STRVAR(bool_doc,
"bool(object=False, /)\n\
--\n\
\n\
Returns True when the argument is true, False otherwise.\n\
The builtins True and False are the only two instances of the class bool.\n\
The class bool is a subclass of the class int, and cannot be subclassed.");
/* Arithmetic methods -- only so we can override &, |, ^. */
static PyNumberMethods bool_as_number = {
0, /* nb_add */
0, /* nb_subtract */
0, /* nb_multiply */
0, /* nb_remainder */
0, /* nb_divmod */
0, /* nb_power */
0, /* nb_negative */
0, /* nb_positive */
0, /* nb_absolute */
0, /* nb_bool */
bool_invert, /* nb_invert */
0, /* nb_lshift */
0, /* nb_rshift */
bool_and, /* nb_and */
bool_xor, /* nb_xor */
bool_or, /* nb_or */
0, /* nb_int */
0, /* nb_reserved */
0, /* nb_float */
0, /* nb_inplace_add */
0, /* nb_inplace_subtract */
0, /* nb_inplace_multiply */
0, /* nb_inplace_remainder */
0, /* nb_inplace_power */
0, /* nb_inplace_lshift */
0, /* nb_inplace_rshift */
0, /* nb_inplace_and */
0, /* nb_inplace_xor */
0, /* nb_inplace_or */
0, /* nb_floor_divide */
0, /* nb_true_divide */
0, /* nb_inplace_floor_divide */
0, /* nb_inplace_true_divide */
0, /* nb_index */
};
static void
bool_dealloc(PyObject *boolean)
{
/* This should never get called, but we also don't want to SEGV if
* we accidentally decref Booleans out of existence. Instead,
* since bools are immortal, re-set the reference count.
*/
_Py_SetImmortal(boolean);
}
/* The type object for bool. Note that this cannot be subclassed! */
PyTypeObject PyBool_Type = {
PyVarObject_HEAD_INIT(&PyType_Type, 0)
"bool",
offsetof(struct _longobject, long_value.ob_digit), /* tp_basicsize */
sizeof(digit), /* tp_itemsize */
bool_dealloc, /* tp_dealloc */
0, /* tp_vectorcall_offset */
0, /* tp_getattr */
0, /* tp_setattr */
0, /* tp_as_async */
bool_repr, /* tp_repr */
&bool_as_number, /* tp_as_number */
0, /* tp_as_sequence */
0, /* tp_as_mapping */
0, /* tp_hash */
0, /* tp_call */
0, /* tp_str */
0, /* tp_getattro */
0, /* tp_setattro */
0, /* tp_as_buffer */
Py_TPFLAGS_DEFAULT, /* tp_flags */
bool_doc, /* tp_doc */
0, /* tp_traverse */
0, /* tp_clear */
0, /* tp_richcompare */
0, /* tp_weaklistoffset */
0, /* tp_iter */
0, /* tp_iternext */
0, /* tp_methods */
0, /* tp_members */
0, /* tp_getset */
&PyLong_Type, /* tp_base */
0, /* tp_dict */
0, /* tp_descr_get */
0, /* tp_descr_set */
0, /* tp_dictoffset */
0, /* tp_init */
0, /* tp_alloc */
bool_new, /* tp_new */
.tp_vectorcall = bool_vectorcall,
};
/* The objects representing bool values False and True */
struct _longobject _Py_FalseStruct = {
PyObject_HEAD_INIT(&PyBool_Type)
{ .lv_tag = _PyLong_FALSE_TAG,
{ 0 }
}
};
struct _longobject _Py_TrueStruct = {
PyObject_HEAD_INIT(&PyBool_Type)
{ .lv_tag = _PyLong_TRUE_TAG,
{ 1 }
}
};
Buyur.
Burada sadece .c dosyası, bunun header vs ve windows bool uyumu için vs bir kaç dosyası daha var.
Yani bool bool değil aslında. Hatta pythonda int int bile olmayabilir. Çünkü nesne yönelimli programlamada nesneler farklı olabilir ve metodlar farklı nesnelere uygulanabilir olduğu için her farklı nesneye uyumlu kod içermelidir.
Kolay gelsin.
Pythonu yaparken her şeyi bir nesne olarak düşünmek istedik, demiş G.V.R.
Ama Fatih baba’yı yapanlar bunu nasıl düşünecek abi.
Fatih baba azmetti, yol aldı, iz sürdü…
Çözecek bu işi de Fatih baba…
Yürü be Fatih baba…
Fatih baba henüz 10 yaşında…
Henüz Fatih’in İstanbul’u fethettiği yaşta bile değil…
Hatta bunu konuşurken 11 oldu bile… Zaman ne kadar da hızlı geçiyor…
3 Beğeni
import os
def yazdır(yazı):
os.system(f"echo {yazı}")
yazdır("'kolay gelsin' demene gerek yok hoca değilim") #kendim yaptım bunu bu arada
sadece çıktısını oku
Sadece çıktısı…
Kanalize kanalize…
Yürü be Fatih baba…
1 Beğeni
kanalize kanalize derken?
Aklıma geldi birden Fatih baba…
Sadece oku, boşver…
1 Beğeni
Merhaba;
Kendi başına böyle bir boolean sınıfı yazmak çok güzel bir keşif denemesi. Bir geliştiricinin temel tipleri sorgulaması ve custom bir tip dönüştürücü yazması, öğrenmenin en etkili yollarından biridir. Ayrıca bu yaklaşım nesnel programlamanın temelidir.
Ancak Python’da bool zaten dil seviyesinde yerleşik (primitive) bir tip olduğu için, bu tarz manuel dönüştürücüler gerçek projelerde nadiren tercih edilir ve çoğu durumda fazladan karmaşıklık (over-engineering) ya da bir anti-pattern olarak kabul edilir.*
Buna ek olarak Python, kendi sınıflarımızı Python’un yerleşik türleri gibi davranan gerçek nesnelere dönüştürebilmemiz için gerekli tüm mekanizmaları sağlar. Bir sınıfın “mantıksal olarak doğru/yanlış kabul edilmesi”, başka bir nesneyle “eşit sayılması” veya ekrana “belli bir formatta yazdırılması” gibi davranışları tamamen bizim belirlememize izin verir.
Bu özel davranışları tanımlamak için Python bize dahili bazı yöntemler sunar. Bunlara magic method veya dunder method (çift alt çizgi yöntemi) denir. Bu isim, büyük çoğunluğunun __örnek__ şeklinde yazılmasından gelir.
Yaygın kullanılan magic method’lar
| Magic Method | Ne işe yarar | Kullanım örneği |
|---|---|---|
__bool__ |
Nesnenin True veya False olarak değerlendirilmesini sağlar |
if obj: |
__eq__ |
İki nesnenin nasıl karşılaştırılacağını belirler | obj1 == obj2 |
__str__ |
Karmaşık bir nesnenin string yansımasını belirler |
print(...) |
__repr__ |
Debug için temsilini belirler | repr(obj) |
Yine de bu denemeyi biraz geliştirerek daha gerçekçi bir senaryoya taşıyabiliriz. Örneğin iki farklı nesnenin mantıksal olarak (doğru/yanlış şeklinde) değerlendirilip karşılaştırılması gibi. Python nesneleri, tasarımlarına göre bu tür mantıksal değerlendirmelere izin verebilecek şekilde yazılabilir. Böylece daha anlamlı ve gerçek dünyaya yakın bir value object modeli oluşturabiliriz.
Senin bool sınıfını gerçek bir “value object” sınıfına çevirelim
class BooleanValue:
class BooleanConversionError(ValueError):
"""Geçersiz boolean değeri atıldığında fırlatılan hata."""
pass
def __init__(self, value):
# Kabul edilen değerler
if value in (1, "true", "True", True):
self._value = True
elif value in (0, "false", "False", False):
self._value = False
else:
raise BooleanValue.BooleanConversionError(
"Değer 0, 1, true veya false olmalıdır."
)
def __bool__(self):
"""Nesne, tıpkı gerçek bir boolean gibi değerlendirilebilir."""
return self._value
def __eq__(self, other):
"""Karşılaştırma boolean seviyesinde yapılır."""
if isinstance(other, BooleanValue):
return self._value == other._value
return NotImplemented
def __repr__(self):
"""Debug için güvenli gösterim."""
return f"BooleanValue({self._value})"
def __str__(self):
"""Ekrana yazdırılabilir (ör. print(obj))"""
return "true" if self._value else "false"
# Kullanım örnekleri
a = BooleanValue(1)
b = BooleanValue("true")
c = BooleanValue(0)
print(bool(a)) # True
print(a == b) # True
print(a == c) # False
print(a) # "true"
print(repr(a)) # BooleanValue(True)
Ama şu anda bu sınıf yalnızca True/False tutan basit bir sarmalayıcı gibi çalışıyor. Bu durumda hem hafızada (heap) ek yük oluşturuyor hem de sade bir bool kullanmak varken ek bir soyutlama katmanı ekliyoruz — yani maliyet getiriyoruz ama henüz gerçek bir fayda elde etmiş değiliz.
O halde bu sınıfı gerçekten bu fazladan karmaşıklığa değer hale getirelim. Hedefimiz:
- Hem Python’un yerleşik
booltipi gibi davranabilmesi, - Hem de gerektiğinde ek davranış ve anlam taşıyabilen “karmaşık bir domain nesnesine dönüşmesi”.**
-
Şimdi bir login sistemi tasarladığını hayal et. Kullanıcıdan bir id ve password istiyorsun. Kullanıcı sana kullanıcı adını ve plain text olarak şifresini veriyor.
-
Bu şifreyi doğrulamak için veritabanından aldığın hash’lenmiş sürümü ile karşılaştırıp bu iki şifrenin aynı olup olmadığını öğrenmek istiyorsun.
import hashlib
class Password:
class PasswordError(Exception):
pass
def __init__(self, value: str, *, already_hashed: bool = False):
if not isinstance(value, str):
raise TypeError("Password must be a string.")
self._is_hashed = already_hashed
self._hash = (
value if already_hashed
else hashlib.sha256(value.encode()).hexdigest()
)
def __eq__(self, other):
"""Şu davranışları destekler:
- Password == Password → hash karşılaştırması
- Password == "plain" → plain string hash’lenerek karşılaştırma
"""
if isinstance(other, Password):
return self._hash == other._hash
elif isinstance(other, str):
return hashlib.sha256(other.encode()).hexdigest() == self._hash
return NotImplemented
def __bool__(self):
"""Hash’lenmiş parola güvenilir kabul edilir."""
return self._is_hashed
def __repr__(self):
return f"Password(**{'HASHED' if self._is_hashed else 'PLAIN'}**)"
def __str__(self):
return "********"
Password sınıfımızı burada aslında dolaylı yoldan bir boolean gibi davranmaya zorlamış olduk.
plain = Password("Secret123")
stored = Password(hashlib.sha256("Secret123".encode()).hexdigest(), already_hashed=True)
print(stored == plain) # True
print(stored == "Secret123") # True
print(stored == "WrongPass") # False
print(bool(stored)) # True (hash’lenmiş)
print(bool(plain)) # False (plain oluşturulmuş)
print(repr(plain)) # Password(**PLAIN**)
print(repr(stored)) # Password(**HASHED**)
Umarım bir şeyler katabilmişimdir, saygılar;
1 Beğeni
mantıklı olabilir aslında
merhaba ; Konuyla alakasız ama su ufak örneği incelemeni tavsiye ederim. Bool’a bakış açını değiştireceğine eminim 
a = √–2
b = √–2
Sence bu durumda a == b ifadesi bize true mu yoksa false mu vermeli?
Çoğu programlama dilinde bu eşleştirmeyi matematiksel olarak değerlendirdiğinde bu ifade ne true ne de false olacaktır. Hatta bu iki değerin birbirleriyle karşılaştırılamaz olduğunu söylemek daha doğrudur. Çünkü “Bool, Gerçek dünyadaki ‘evet’ ya da ‘hayır’ın bilgisayardaki 2¹’lik (tek bitlik) yansımasıdır. Matematikte true ya da false olarak ifade edilemeyen hiçbir şey boolean olarak ifade edilemez.”
Neden “√–2” Boolean (true/false) Olarak Değerlendirilemez?
Bir ifadenin true / false (yani boolean) olarak değerlendirilebilmesi için:
- Öncelikle ifadenin anlamlı olması,
- Yani bulunduğumuz sayı kümesinde (örneğin gerçek sayılar kümesi ℝ) tanımlı olması gerekir.
√–2 ifadesinde problem tam da burada başlıyor.
İzah edeyim:
a = \sqrt{x} \iff a \times a = x
Yani: “√x, karesi x olan sayıdır.”
Şimdi bunu √–2 için uygulayalım.
Dört işlem mantığıyla incelersek
| Sayı tipi | İşlem | Sonuç |
|---|---|---|
| (+sayı) | (+) × (+) | + |
| (–sayı) | (–) × (–) | + |
| 0 | 0 × 0 | 0 |
Yani hiçbir gerçek sayıyı kendiyle çarpıldığında sonuç olarak kendisnin negatifini (-2) vermez
Bu nedenle:
\sqrt{-2} \notin \mathbb{R}
Gerçek sayılar kümesinde “√–2” diye bir sayı yoktur.
Dolayısıyla şu ifade:
\sqrt{-2} = \sqrt{-2}
gerçek sayılar için “2 = 2” gibi geçerli bir eşitlik değildir,
çünkü sol ve sağ tarafta aslında var olmayan bir değer vardır.
Işte tamda bu sebepten dolayı “Bu eşitlik doğru mu, yanlış mı?” diyemiyoruz,
çünkü ifadenin kendisi geçersizdir.
Bu gibi durumlarda kendi bool sınıfımızı yazarak, bu tür matamatik olarak anlamsız ifadeleri mantıklı hale cevirebiliriz. 2 > \sqrt{-2} gibi bir karşılaştırmayı bile sağlayabiliriz
√–2 ifadesini karmaşık sayı olarak düşünüp karşılaştırma yapamaz mıyız? 
Merhaba;
Tabiki karşılaştırılabilir. Sadece reel sayılar üzerinden basit bir örnek olarak booleanin sadece mantıksal evet yada hayırdan ibaret olmadığını vurgulamak için vermiştim.