4 - Data Types

The Way To Python 4 … Data types …. ‫ الطريق إلى لغة البايثون‬..
… Author , Eng/ Mahmoud Soliman 1

‫جذول انًحتويات‬
‫انفصم األول ‪ :‬يقذية في أَواع انبياَات ‪3.................................... Introduction to Data types‬‬
‫انفصم انثاَي ‪ :‬انتحول بيٍ أَواع انبياَات ‪13....................... Type Conversion & Type Casting‬‬
‫انفصم انثانث ‪ :‬األرقاو ‪11................. ................................ ................................ Numbers‬‬
‫انفصم انزابع ‪ :‬انسالسم ‪22.................. ................................ ................................ Strings‬‬
‫انفصم انخايس ‪ :‬انقوائى ‪31..................... ................................ ................................ Lists‬‬
‫انفصم انسادس ‪ :‬انتعذيذ أو انًجًوعات ‪44................................. ................................ Tuples‬‬
‫انفصم انسابع ‪ :‬انتشكيالت أو انًجًوعات ‪66................................... ................................ Sets‬‬
‫انفصم انثايٍ ‪ :‬انقايوس ‪22............................................ ................................ Dictionary‬‬
‫انفصم انثانث ‪ :‬انقيى انًُطقية ‪13......................................... ................................ Booleans‬‬
‫انخاتًة ‪12 ................................................................................................‬‬
‫‪The Way To Python 4 … Data types ….‬‬ ‫‪ ..… Author , Eng/ Mahmoud Soliman‬الطريق إلى لغة البايثون‬ ‫‪2‬‬
‫ميحرلا نمحرلا هللا‬ ‫بسم‬
‫انطزيق إنى انبزيجة بهغة انبايثوٌ‬
‫‪The Way to Python programming‬‬
‫انذرس األول ‪ :‬يقذية في أَواع انبياَات‬

‫)‪(Introduction to Data types‬‬
‫‪ ‬لجً اٌجذأ ف‪ ٟ‬أٔ‪ٛ‬اع اٌج‪١‬بٔبد ‪٠‬غت أْ ٕٔ‪ ٖٛ‬أْ أ‪ٚ‬ي دسع‪ ٓ١‬ف‪٘ ٟ‬ذزا اٌغذضت رذُ دساعذز‪ ُٙ‬فذ‪ ٟ‬اٌغذضت ا ‪ٚ‬ي‬
‫‪ٌٚ‬ىٓ ِٓ ثبة االعززوبس ع‪١‬زُ عشدُ٘ ِشح أخش‪ ٜ‬ف‪٘ ٟ‬زا اٌغضت صُ ٔم‪ َٛ‬ثذساعخ وً ٔ‪ٛ‬ع ثبٌزفص‪. ً١‬‬
‫‪ ‬ف‪٘ ٟ‬زا اٌذسط عززؼشف ػٍ‪ ٝ‬أٔ‪ٛ‬اع اٌج‪١‬بٔبد اٌّخزٍفخ اٌز‪ّ٠ ٟ‬ىٕه اعزخذاِ‪ٙ‬ب ف‪.Python ٟ‬‬
‫طب ٌٍغب‪٠‬خ ‪ٌٚ‬ىٕٗ ِ‪ ُٙ‬عذًا ِزبػ فذ‪ ٟ‬عّ‪١‬ذغ ٌغذبد اٌجشِغذخ رمش‪٠‬جًذب ‪٘ٚ‬ذ‪ِ ٛ‬ذب ‪٠‬غذّ‪ٝ‬‬ ‫دػ‪ٔٛ‬ب ٕٔبلش ِف‪ًِ ٛٙ‬ب ثغ‪ً ١‬‬
‫ػذذب ِذذٓ اٌج‪١‬بٔذذبد اٌزذذ‪ّ٠ ٟ‬ىٕذذه‬
‫أٔذذ‪ٛ‬اع اٌج‪١‬بٔذذبد ‪ٚ data types‬وّذذب ‪٠‬شذذ‪١‬ش اعذذّٗ ‪ّ٠‬ضذذً ٔذذ‪ٛ‬ع اٌج‪١‬بٔذذبد ٔ‪ً ٛ‬‬
‫ِؼبٌغز‪ٙ‬ب ثبعزخذاَ ثشٔذبِظ اٌىّج‪١‬ذ‪ٛ‬رش اٌخذب ثذه‪ .‬فمذذ ‪٠‬ىذ‪ٔ ْٛ‬ذ‪ٛ‬ع اٌج‪١‬بٔذبد سلّ‪ً١‬ذب ‪ numeric‬أ‪ٔ ٚ‬صذ‪١‬ب ً‬
‫‪ Strings‬أ‪ ٚ‬أثغذذذ‪ً٠‬ب ‪ alphanumeric‬أ‪ ٚ‬ػشذذش‪ً٠‬ب ‪ decimal‬ئٌ ذ ‪ .‬دػٕذذب ٔذذذع ثشِغذذخ اٌىّج‪١‬ذذ‪ٛ‬رش عبٔج ذب ً‬
‫ٌجؼط اٌ‪ٛ‬لذ ‪ٔٚ‬أخز ثؼط ا ِضٍخ اٌغ‪ٍٙ‬خ ‪:‬‬
‫‪ِ ‬ضبي ‪ 1‬إلظبفخ ػذد‪ ٓ٠‬صؾ‪١‬ؾ‪ّ٠ 20 & 10 ٓ١‬ىٓ اٌم‪١‬بَ ثٗ ثجغبغخ ػٍ‪ ٝ‬إٌؾ‪ ٛ‬اٌزبٌ‪: ٟ‬‬
‫‪10 + 10‬‬
‫اٌّضبي ا ‪ٚ‬ي ‪٠‬زؼبًِ ِغ ا ػذاد اٌصؾ‪١‬ؾخ ‪. whole numbers‬‬
‫‪ِ ‬ضبي ‪ 2‬إلظبفخ ػذد‪ ٓ٠‬ػشش‪ّ٠ 10.50 & 20.50 ٓ١٠‬ىٓ اٌم‪١‬بَ ثٗ ثجغبغخ ػٍ‪ ٝ‬إٌؾ‪ ٛ‬اٌزبٌ‪: ٟ‬‬
‫‪10.50 + 20.50‬‬
‫اٌّضبي اٌضبٔ‪٠ ٟ‬زؼبًِ ِغ ا ػذاد اٌؼشش‪٠‬خ ‪. decimal numbers‬‬
‫‪ِ ‬ضبي ‪ٌ 3‬زغغ‪ِ ً١‬ؼٍ‪ِٛ‬بد اٌطبٌت ف‪ ٟ‬دفزش ِالؽظبد ا‪٢‬ر‪ٕ٘ ٟ‬ب ٔ‪ٛ‬د رغغ‪ ً١‬اٌّؼٍ‪ِٛ‬بد اٌزبٌ‪١‬خ ‪:‬‬
‫‪Name:‬‬
‫‪Class:‬‬
‫‪Section:‬‬
‫‪Age:‬‬
‫‪Sex:‬‬
‫ً‬
‫عغال ‪ٚ record‬اؽذًا ٌٍطبٌت ‪ٚ‬فمًب ٌٍّزطٍجبد اٌّؾذدح ف‪ ٟ‬اٌغذ‪ٚ‬ي اٌغبثك ‪:‬‬ ‫دػٕب ٔعغ‬
‫‪Name: Zara Ali‬‬
‫‪Class: 6th‬‬
‫‪Section: J‬‬
‫‪Age: 13‬‬
‫‪Sex: F‬‬
‫‪ ‬اٌّضبي اٌضبٌش ‪٠‬زؼبًِ ِغ ِض‪٠‬ظ ِٓ اٌج‪١‬بٔبد اٌّخزٍفخ ‪ّ٠‬ىٓ أْ ٔ‪ٛ‬ظؾ‪ٙ‬ب ػٍ‪ ٝ‬إٌؾ‪ ٛ‬اٌزبٌ‪: ٟ‬‬
‫عب عٍغٍخ ٔص‪١‬خ ‪. String‬‬ ‫‪ o‬اعُ اٌطبٌجخ "‪ ٛ٘ "Zara Ali‬عٍغٍخ ِٓ ا ؽشف رغّ‪ ٝ‬أ‪ً ٠‬‬
‫‪ o‬فصذً اٌطذالة "‪٠ "6th‬زىذ‪ِ ْٛ‬ذٓ ِذض‪٠‬ظ ِذٓ ػذذد صذؾ‪١‬ؼ ‪ٚ whole number‬عٍغذٍخ ‪ِ string‬ذٓ‬
‫ؽشف‪٠ٚ ٓ١‬غّ‪٘ ٝ‬زا اٌّض‪٠‬ظ ا ثغذ‪ ٞ‬اٌشلّ‪. alphanumeric ٟ‬‬
‫‪ o‬لغُ اٌطالة "‪ ٛ٘ "J‬ؽشف ‪ٚ‬اؽذ ‪. single character‬‬
‫‪ o‬ػّش اٌطالة "‪ ٛ٘ "13‬سلُ ‪ٚ‬اؽذ صؾ‪١‬ؼ ‪. whole number‬‬
‫‪ٛٔ o‬ع اٌطالة "‪ ٛ٘ "F‬ؽشف ‪ٚ‬اؽذ ‪. single character‬‬
‫‪ ‬ث‪ٙ‬زٖ اٌطش‪٠‬مخ أدسوٕب أٔٗ ف‪ ٟ‬ؽ‪١‬برٕب اٌ‪١ِٛ١‬خ إٔٔب ٕٔزؼبًِ ِغ أٔ‪ٛ‬اع ِخزٍفخ ِٓ اٌج‪١‬بٔبد ِضً ‪:‬‬
‫‪ o‬اٌغالعً ‪. strings‬‬
‫‪ o‬ا ؽشف ‪. characters‬‬
‫‪ o‬ا سلبَ اٌصؾ‪١‬ؾخ ‪ whole numbers‬أ‪ ٚ‬ا ػذاد اٌصؾ‪١‬ؾخ )‪. (integers‬‬
‫‪ o‬ا سلبَ اٌؼشش‪٠‬خ ‪ decimal numbers‬أ‪ ٚ‬أسلبَ اٌفبصٍخ اٌؼبئّخ )‪.(floating point numbers‬‬
‫‪ٚ‬ثبٌّضذً وذذً ل‪ّ١‬ذذخ ‪ value‬فذذ‪ٌٙ python ٟ‬ذذب ٔذذ‪ٛ‬ع ث‪١‬بٔذذبد ‪ٔٚ‬ظذ ًذشا ْ وذذً شذذ‪ٟ‬ت فذذ‪ ٟ‬ثشِغذذخ ‪Python‬‬
‫ػجبسح ػٓ وبئٓ ‪ object‬فذاْ أٔذ‪ٛ‬اع اٌج‪١‬بٔذبد ٘ذ‪ ٟ‬فذ‪ ٟ‬اٌ‪ٛ‬الذغ فئذبد ‪ٚ classes‬اٌّزغ‪١‬ذشاد ‪variables‬‬
‫اٌز‪ٔ ٟ‬غزخذِ‪ٙ‬ب ٘‪ ٟ‬ػجبسح ػٓ ِض‪ ً١‬أ‪ّٛٔ ٚ‬صط ‪( instance‬وبئٓ ‪٘ ِٓ ) object‬زٖ اٌفئبد ‪. classes‬‬
‫ػٕذِب ٔىزت ثشٔبِظ وّج‪ٛ١‬رش ٌّؼبٌغخ أٔ‪ٛ‬اع ِخزٍفخ ِٓ اٌج‪١‬بٔبد ٔؾزبط ئٌ‪ ٝ‬رؾذ‪٠‬ذذ ٔذ‪ٛ‬ع اٌج‪١‬بٔذبد اٌّذشاد‬
‫رخض‪ٕ٠‬ذذٗ ث‪ٛ‬ظذذ‪ٛ‬ػ ؛ ‪ٚ‬ئال فذذاْ اٌىّج‪١‬ذذ‪ٛ‬رش ال ‪٠‬ف‪ٙ‬ذذُ و‪ ١‬ذ ‪ّ٠‬ىذذٓ ئعذذشات ػٍّ‪١‬ذذبد ِخزٍفذذخ ػٍذذ‪ ٝ‬رٍذذه اٌج‪١‬بٔذذبد‬
‫اٌّؾذدح ‪ٚ‬رغذزخذَ ٌغذبد اٌجشِغذخ اٌّخزٍفذخ وٍّذبد سئ‪١‬غذ‪١‬خ ‪ِ keywords‬خزٍفذخ ٌزؾذ‪٠‬ذذ أٔذ‪ٛ‬اع ث‪١‬بٔذبد‬
‫ِخزٍفذذذخ‪ .‬فىذذذً ٌغذذذخ ثشِغ‪١‬ذذذخ ٌ‪ٙ‬ذذذب ‪ syntax‬خذذذب ث‪ٙ‬ذذذب ‪ٌٙٚ‬ذذذب وٍّذذذبد ِؾغذذذ‪ٛ‬صح ‪ٚ‬سئ‪١‬غذذذ‪١‬خ خبصذذذخ ث‪ٙ‬ذذذب‬
‫‪ٚ keywords‬سغُ ٘زا ف‪ٕٙ‬ذبن ٌغذبد ِضذً ٌغذخ ‪ٌ python‬غذخ رو‪١‬ذخ ال رؾزذبط ئٌذ‪ ٝ‬رؾذ‪٠‬ذذ ٔذ‪ٛ‬ع اٌج‪١‬بٔذبد‬
‫‪. data types‬‬
‫‪ٕ٘ ‬بن فئبد ِٓ أٔ‪ٛ‬اع اٌج‪١‬بٔبد داخً ٌغخ ثب‪٠‬ض‪٘ ِٓ ْٛ‬زٖ ا ٔ‪ٛ‬اع ا‪٢‬ر‪: ٟ‬‬
‫‪ : Python Numbers )1‬ا سلبَ داخً ٌغخ ثب‪٠‬ض‪ٚ ْٛ‬رىزت ِجبششح ‪.‬‬
‫‪ : Python Strings )2‬اٌغالعً داخً ٌغخ ثب‪٠‬ض‪ٚ ْٛ‬رىزت ث‪ ' ' ٓ١‬أ‪ " " ٚ‬أ‪''' ''' ٚ‬‬
‫‪ : Python List )3‬اٌم‪ٛ‬ائُ داخً ٌغخ ثب‪٠‬ض‪ٚ ْٛ‬رىزت ث‪[ , , , ] ٓ١‬‬
‫‪ : Python Tuple )4‬اٌزؼذ‪٠‬ذ داخً ٌغخ ثب‪٠‬ض‪ٚ ْٛ‬رىزت ث‪) , , , ( ٓ١‬‬
‫‪ : Python Set )5‬اٌّغّ‪ٛ‬ػخ داخً ٌغخ ثب‪٠‬ض‪ٚ ْٛ‬رىزت ث‪{ , , , } ٓ١‬‬
‫‪ : Python Dictionary )6‬اٌم‪ٛ‬ائُ داخً ٌغخ ثب‪٠‬ض‪ٚ ْٛ‬رىزت ث‪{key:"value", key:"value",… } ٓ١‬‬
‫‪ : Python boolean )7‬اٌم‪ ُ١‬إٌّطم‪١‬خ داخً ٌغخ ثب‪٠‬ض‪ ٝ٘ٚ ْٛ‬ئِب ‪ True‬أ‪. False ٚ‬‬
‫عٕم‪ َٛ‬ثأخز ٔظشح عذش‪٠‬ؼخ ػٍذ‪ ٝ‬وذً ٔذ‪ٛ‬ع صذُ عذٕم‪ َٛ‬ثشذشػ وذً ٔذ‪ٛ‬ع فذ‪ ٟ‬دسط ِغذزمً ٌذٗ ‪ٚ‬عذٕزؼّك فذ‪ٟ‬‬
‫خصبئص ‪ٚ‬د‪ٚ‬اي وً ٔ‪ٛ‬ع ِٓ أٔ‪ٛ‬اع اٌج‪١‬بٔبد ‪.‬‬
: ْٛ‫ض‬٠‫ ا سلبَ داخً ٌغخ ثب‬: Python Numbers ً‫ال‬ٚ‫أ‬
: ٟ‫ر‬٢‫ْ ا‬ٛ‫ض‬٠‫دح داخً اٌجب‬ٛ‫ع‬ٌّٛ‫رٕذسط رؾذ فئخ أسلبَ ا‬
. int class ‫رُؼشف ثـ‬ٚ Integers numbers ‫ؾخ‬١‫ أسلبَ ا ػذاد اٌصؾ‬
.float class ‫رُؼشف ثـ‬ٚ floating point numbers ‫ أسلبَ اٌفبصٍخ اٌؼبئّخ‬/ ‫خ‬٠‫ ا سلبَ اٌؼشش‬
. complex class ‫رُؼشف ثـ‬ٚ complex numbers ‫ا سلبَ اٌّشوجخ‬ٚ 
.‫ّخ‬١‫ اٌم‬ٚ‫ش أ‬١‫ب اٌّزغ‬ٙ١ٌ‫ ئ‬ّٟ‫ٕز‬٠ ٟ‫ اٌز‬class ‫ اٌـ‬ٚ‫ ٌّؼشفخ اٌفئخ أ‬type)( ‫ّىٕٕب اعزخذاَ داٌخ‬٠ 
.ٓ١‫ ِؼ‬class ٌٝ‫ ئ‬ّٟ‫ٕز‬٠ object ٓ‫ ٌٍزؾمك ِّب ئرا وبْ اٌىبئ‬isinstance)( ‫زُ اعزخذاَ اٌذاٌخ‬٠ 
a = 5
print(a, "is of type", type(a))
a = 2.0
print(a, "is of type", type(a))
a = 1+2j
print(a, "is complex number?", isinstance(1+2j,complex))
Output
5 is of type <class 'int'>
2.0 is of type <class 'float'>
(1+2j) is complex number? True
.‫دح فمػ ثبٌزاوشح اٌّزبؽخ‬ٚ‫ ِؾذ‬ٟٙ‫ي ف‬ٛ‫ غ‬ٞ‫ْ ِٓ أ‬ٛ‫ّىٓ أْ رى‬٠ Integers ‫ؾخ‬١‫ ا ػذاد اٌصؾ‬
َ‫ا سلذب‬ٚ ‫ؼ‬١‫اٌؼذد صؾ‬ٚ .ٞ‫ سلُ ػشش‬15 ٝ‫أخز ؽز‬٠ floating-point number ‫ سلُ اٌفبصٍخ اٌؼبئّخ‬
. ٞ‫ سلُ ػشش‬ٛ٘ 1.0 ‫ّٕب‬١‫ؼ ث‬١‫ ػذد صؾ‬ٛ٘ 1 ً‫خ فّضال‬٠‫ٌخ ثٕمبغ ػشش‬ٛ‫ْ ِفص‬ٛ‫خ رى‬٠‫اٌؼشش‬
real ٟ‫مذ‬١‫ اٌغذضت اٌؾم‬ٛ‫ ٘ذ‬x ‫ذش‬١‫ ؽ‬x + yj ‫غخ‬١‫ثذخ ثبٌصذ‬ٛ‫ ِىز‬complex numbers ‫ ا ػذاد اٌّشوجذخ‬
. imaginary part ٍٟ١‫ اٌغضت اٌزخ‬y ٚ part
: ‫ ِضبي‬
>>> a = 1234567890123456789
>>> a
1234567890123456789
>>> b = 0.1234567890123456789123456789
>>> b
0.12345678901234568
>>> c = 1+2j
>>> c
(1+2j)
. ‫خ‬٠‫ ثؼذ اٌؼالِخ اٌؼشش‬ٞ‫ سلُ ػشش‬15 ِٓ ‫أخز أوزش‬٠ ‫ ٔٗ ال‬b ٞ‫ش اٌؼشش‬١‫ الؽع أٔٗ رُ لطغ اٌّزغ‬
The Way To Python 4 … Data types …. ‫ الطريق إلى لغة البايثون‬..… Author , Eng/ Mahmoud Soliman 5
‫صبٔ‪١‬ب ً ‪ : Python Strings‬اٌغالعً داخً ٌغخ ثب‪٠‬ض‪: ْٛ‬‬
‫اٌغٍغٍخ ‪ ٝ٘ String‬ػجبسح ػٓ عٍغٍخ ِٓ أؽشف اٌزشِ‪١‬ض ‪٠ٚ Unicode‬زُ رّض‪ٍٙ١‬ب وب‪٢‬ر‪: ٟ‬‬
‫‪ٌ ‬زّض‪ ً١‬اٌغالعً إٌص‪١‬خ ٌغطش ‪ٚ‬اؽذ ٔغذزخذَ ػالِذبد االلزجذبط اٌّفذشدح ‪ٚ single quotes‬سِض٘ذب‬
‫٘‪ ( ' ' ) ٛ‬أ‪ ٚ‬ػالِبد االلزجبط اٌّضد‪ٚ‬عخ ‪ٚ double quotes‬سِض٘ب ٘‪. ( " " ) ٛ‬‬
‫‪ٌ ‬زّض‪١‬ذذً اٌغالعذذً إٌصذذ‪١‬خ ِزؼذذذادح ا عذذطش ٔغذذزخذَ ػالِذذبد االلزجذذبط اٌضالص‪١‬ذذخ ‪triple quotes‬‬
‫‪ٚ‬سِض٘ب ٘‪ ( """ """ ) ٛ‬أ‪. ( ''' ''' ) ٚ‬‬
‫‪#Single-line strings‬‬
‫"‪s = "This is a string‬‬
‫)‪print(s‬‬
‫‪#Multi-line strings‬‬
‫‪s = '''A multiline‬‬
‫'''‪string‬‬
‫)‪print(s‬‬
‫‪Output‬‬
‫‪This is a string‬‬
‫‪A multiline‬‬
‫‪string‬‬
‫‪ّ٠ ‬ىٓ اعزخذاَ ػبًِ اٌزمط‪١‬غ ‪ِ slicing operator‬غ اٌغالعً ‪ٚ strings‬سِض٘ب ٘ذ‪ ] [ ٛ‬العذزخشاط‬
‫ػٕصش أ‪ِ ٚ‬غّ‪ٛ‬ػخ ِٓ اٌؼٕبصش ِٓ اٌغٍغٍخ ‪. string‬‬
‫'!‪s = 'Hello world‬‬
‫'‪# s[4] = 'o‬‬

‫)]‪print("s[4] = ", s[4‬‬
‫'‪# s[6:11] = 'world‬‬

‫)]‪print("s[6:11] = ", s[6:11‬‬
‫‪Output‬‬
‫‪s[4] = o‬‬
‫= ]‪s[6:11‬‬ ‫‪world‬‬
‫‪ ‬اٌف‪ٙ‬شط ] ‪ : [ index‬اٌم‪ّ١‬خ اٌز‪ٔ ٟ‬عؼ‪ٙ‬ب داخً ] [ ‪ ٝ٘ٚ‬ػجبسح ػٓ سلذُ اٌف‪ٙ‬ذشط اٌذز‪٠ ٞ‬ؼجذش ػذٓ ل‪ّ١‬ذخ‬
‫ِ‪ٛ‬ظغ أ‪ِ ٚ‬ىبْ اٌؾشف ‪ .‬فّضالً ]‪ ٛ٘ [4‬ػجبسح ػٓ ل‪ّ١‬خ اٌشلُ ‪ 4‬اٌّ‪ٛ‬ع‪ٛ‬د ف‪ ٟ‬اٌغٍغٍخ ‪.‬‬
‫‪٠ : index ‬جذأ ِٓ ‪ٌ zero‬زٌه ِ‪ٛ‬ظغ ؽشف '‪ٚ 0 ٛ٘ 'h‬ؽشف '‪٘ٚ 1 ٛ٘ 'e‬ىزا ‪.‬‬
‫‪ ‬اٌغالعذذً ‪ strings‬غ‪١‬ذذش لبثذذً ٌٍزغ‪١١‬ذذش ‪ immutable‬ثّؼٕذذ‪ ٝ‬أٔذذٗ ال ‪ّ٠‬ىذذٓ رغ‪١١‬ذذش ل‪ّ١‬ذذخ ػٕبصذذش اٌغٍغذذٍخ‬
‫الؽع اٌّضبي اٌزبٌ‪: ٟ‬‬
‫'!‪s = 'Hello world‬‬
‫‪# Generates error‬‬
‫‪# Strings are immutable in Python‬‬
‫'‪s[5] ='d‬‬
‫‪Output‬‬
‫‪Traceback (most recent call last):‬‬
‫>‪File "<string>", line 11, in <module‬‬
‫‪TypeError: 'str' object does not support item assignment‬‬
‫صبٌضب ً ‪ : Python Lists‬اٌم‪ٛ‬ائُ داخً ٌغخ ثب‪٠‬ض‪: ْٛ‬‬

‫اٌمبئّذذخ ‪ : list‬اٌمبئّذذخ ٘ذذ‪ ٟ‬عٍغذذٍخ ِشرجذذخ ِذذٓ اٌؼٕبصذذش‪ .‬ئٔذذٗ أؽذذذ أٔذذ‪ٛ‬اع اٌج‪١‬بٔذذبد ا وضذذش اعذذزخذا ًِب فذذ‪ٟ‬‬
‫‪ِ ٛ٘ٚ Python‬شْ ٌٍغب‪٠‬خ‪ .‬ال ‪ٍ٠‬ضَ أْ رى‪ ْٛ‬وبفخ اٌؼٕبصش اٌّ‪ٛ‬ع‪ٛ‬دح ف‪ ٟ‬اٌمبئّخ ِٓ ٔفظ إٌ‪ٛ‬ع ‪.‬‬
‫ٌإلػذذالْ ػذذٓ لبئّذذخ ‪ list‬أِذذش عذذ‪ِٚ ًٙ‬جبشذذش ‪٠‬ذذزُ رٌذذه ػذذٓ غش‪٠‬ذذك ‪ٚ‬ظذذغ اٌؼٕبصذذش داخذذً ألذذ‪ٛ‬اط [ ]‬
‫‪ِٚ‬فص‪ٛ‬ي ث‪ّٕٙ١‬ب ثفبصٍخ ‪ٚ Comma‬سِض٘ب ( ‪ ) ,‬وب‪٢‬ر‪: ٟ‬‬
‫]'‪a = [1, 2.2, 'python‬‬
‫‪ّ٠ ‬ىذذٓ اعذذزخذاَ ػبِذذً اٌزمط‪١‬ذذغ ‪ِ slicing operator‬ذذغ اٌمذذ‪ٛ‬ائُ ‪ٚ lists‬سِض٘ذذب ٘ذذ‪ ] [ ٛ‬العذذزخشاط‬
‫ػٕصش أ‪ِ ٚ‬غّ‪ٛ‬ػخ ِٓ اٌؼٕبصش ِٓ اٌمبئّخ ‪. list‬‬
‫]‪a = [5,10,15,20,25,30,35,40‬‬
‫‪# a[2] = 15‬‬

‫)]‪print("a[2] = ", a[2‬‬
‫]‪# a[0:3] = [5, 10, 15‬‬

‫)]‪print("a[0:3] = ", a[0:3‬‬
‫]‪# a[5:] = [30, 35, 40‬‬

‫)]‪print("a[5:] = ", a[5:‬‬
‫‪Output‬‬
‫‪a[2] = 15‬‬
‫]‪a[0:3] = [5, 10, 15‬‬
‫]‪a[5:] = [30, 35, 40‬‬
‫‪ ‬اٌم‪ٛ‬ائُ ‪ lists‬لبثٍخ ٌٍزغ‪١١‬ش ثّؼٕ‪ ٝ‬أٔٗ ‪ّ٠‬ىٓ رغ‪١١‬ش ل‪ّ١‬خ ػٕبصش اٌمبئّخ الؽع اٌّضبي اٌزبٌ‪: ٟ‬‬
‫]‪a = [1, 2, 3‬‬
‫‪a[2] = 4‬‬
‫)‪print(a‬‬
‫‪Output‬‬
‫]‪[1, 2, 4‬‬
‫ساثؼب ً ‪ : Python Tuples‬اٌم‪ٛ‬ائُ داخً ٌغخ ثب‪٠‬ض‪: ْٛ‬‬

‫اٌّغّ‪ٛ‬ػذذذخ ‪٘ Tuple‬ذذذ‪ ٛ‬رغٍغذذذً ِشرذذذت ِذذذٓ اٌؼٕبصذذذش ِضذذذً اٌمبئّذذذخ ‪ . list‬االخذذذزالف اٌ‪ٛ‬ؽ‪١‬ذذذذ ٘ذذذ‪ ٛ‬أْ‬
‫اٌّغّ‪ٛ‬ػبد رٍه غ‪١‬ش لبثٍخ ٌٍزغ‪١١‬ش ال ‪ّ٠‬ىٓ رؼذ‪ ً٠‬اٌّغّ‪ٛ‬ػبد ‪ tuples‬اٌز‪ ٟ‬رُ ئٔشبؤ٘ب ِشح ‪ٚ‬اؽذح‪.‬‬
‫رُغذذزخذَ ‪ Tuples‬فذذ‪ ٟ‬ؽّب‪٠‬ذذخ اٌج‪١‬بٔذذبد ِذذٓ اٌىزبثذذخ ‪ٚ write-protect data‬ػذذبدح ً ِذذب رىذذ‪ ْٛ‬أعذذشع ِذذٓ‬
‫اٌم‪ٛ‬ائُ ‪ lists‬ؽ‪١‬ش ال ‪ّ٠‬ىٓ رغ‪١١‬ش٘ب د‪ٕ٠‬بِ‪١‬ى‪ً١‬ب‪.‬‬
‫ٌإلػالْ ػٓ اٌّغّ‪ٛ‬ػخ ‪ Tuple‬أِش ع‪ِٚ ًٙ‬جبشش ‪٠‬زُ رٌه ػٓ غش‪٠‬ك ‪ٚ‬ظغ اٌؼٕبصش داخً ألذ‪ٛ‬اط (‬
‫) ‪ِٚ‬فص‪ٛ‬ي ث‪ّٕٙ١‬ب ثفبصٍخ ‪ٚ Comma‬سِض٘ب ( ‪ ) ,‬وب‪٢‬ر‪: ٟ‬‬
‫)‪t = (5,'program', 1+3j‬‬
‫‪ّ٠ ‬ىذذٓ اعذذزخذاَ ػبِذذً اٌزمط‪١‬ذذغ ‪ِ slicing operator‬ذذغ اٌمذذ‪ٛ‬ائُ ‪ٚ lists‬سِض٘ذذب ٘ذذ‪ ] [ ٛ‬العذذزخشاط‬
‫ػٕصش أ‪ِ ٚ‬غّ‪ٛ‬ػخ ِٓ اٌؼٕبصش ِٓ اٌّغّ‪ٛ‬ػخ ‪. tuple‬‬
‫)‪t = (5,'program', 1+3j‬‬
‫'‪# t[1] = 'program‬‬

‫)]‪print("t[1] = ", t[1‬‬
‫))‪# t[0:3] = (5, 'program', (1+3j‬‬

‫)]‪print("t[0:3] = ", t[0:3‬‬
‫‪Output‬‬
‫‪t[1] = program‬‬
‫))‪t[0:3] = (5, 'program', (1+3j‬‬
: ٍٟ٠ ‫ػخ وّب‬ّٛ‫ّخ ػٕبصش اٌّغ‬١‫ش ل‬١١‫ّىٓ رغ‬٠ ٗٔ‫ أ‬ٕٝ‫ش ثّؼ‬١١‫ش لبثٍٗ ٌٍزغ‬١‫ غ‬tuple ‫ػخ‬ّٛ‫ اٌّغ‬
t = (5,'program', 1+3j)
# Generates error - Tuples are immutable
t[0] = 10
Output
Traceback (most recent call last):
File "test.py", line 11, in <module>
t[0] = 10
TypeError: 'tuple' object does not support item assignment
: ْٛ‫ض‬٠‫ػخ داخً ٌغخ ثب‬ّٛ‫ ِغ‬ٚ‫ٍخ أ‬١‫ رشى‬: Python Set ً ‫خبِغب‬
‫ذذذت‬١‫شذذذزشغ رشر‬٠ ‫ال‬ٚ ‫ذذذذح‬٠‫ذذذش ِشرجذذذخ ِذذذٓ اٌؼٕبصذذذش اٌفش‬١‫ػذذذخ غ‬ّٛ‫ ِغ‬ٟ‫ ٘ذذذ‬Set ‫ػذذذخ‬ّٛ‫ اٌّغ‬ٚ‫ٍخ أ‬١‫اٌزشذذذى‬
. Set ‫ػخ‬ّٛ‫ ِغ‬ٟ‫دح ف‬ٛ‫ع‬ٌّٛ‫اٌؼٕبصش ا‬
{ } ‫اط‬ٛ‫ظغ اٌؼٕبصش داخذً ألذ‬ٚ ‫ك‬٠‫زُ رٌه ػٓ غش‬٠ ‫ِجبشش‬ٚ ًٙ‫ أِش ع‬Set ‫ػخ‬ّٛ‫ٌإلػالْ ػٓ اٌّغ‬
: ٟ‫ر‬٢‫ ) وب‬, ( ‫سِض٘ب‬ٚ Comma ‫ّب ثفبصٍخ‬ٕٙ١‫ي ث‬ٛ‫ِفص‬ٚ
a = {5,2,3,1,4}
# printing set variable

print("a = ", a)
# data type of variable a

print(type(a))
Output
a = {1, 2, 3, 4, 5}
<class 'set'>
. sets ٓ١‫ػز‬ّٛ‫ ِغ‬ٍٝ‫ػ‬intersection ‫اٌزمبغغ‬ٚ union ‫بد ِؾذدح ِضً االرؾبد‬١ٍّ‫ّىٕٕب ئعشات ػ‬٠ 
: ٍٟ٠ ‫زُ ؽزف اٌزىشاساد وّب‬٠ ‫ ؽبٌخ اٌزىشاس‬ٟ‫ف‬ٚ unique values ‫ذح‬٠‫ُ فش‬١‫ب ل‬ٌٙ ‫ػبد‬ّٛ‫ اٌّغ‬
a = {1,2,2,3,3,3}
print("a = ",a)
Output
a = {1, 2, 3}
‫‪ ‬ال ‪ّ٠‬ىذٓ اعذزخذاَ ػبِذً اٌزمط‪١‬ذغ [ ] ‪ِ slicing operator‬ذغ اٌمذ‪ٛ‬ائُ ‪ ْ sets‬اٌّغّ‪ٛ‬ػذخ ‪٘ set‬ذ‪ٟ‬‬
‫ِغّ‪ٛ‬ػخ غ‪١‬ش ِشرجخ فٍ‪١‬ظ ٌٍف‪ٙ‬شعخ ‪ indexing‬أ‪ِ ٞ‬ؼٕ‪ ٝ‬فٍزٌه ػبًِ اٌزمط‪١‬غ [] ال ‪٠‬ؼًّ وّب ‪: ٍٟ٠‬‬
‫}‪>>> a = {1,2,3‬‬
‫]‪>>> a[1‬‬
‫‪File "<string>", line 301, in runcode‬‬
‫>‪File "<interactive input>", line 1, in <module‬‬
‫‪TypeError: 'set' object does not support indexing‬‬
‫عبدعب ً ‪ :Python dictionary‬اٌمبِ‪ٛ‬ط داخً ٌغخ ثب‪٠‬ض‪: ْٛ‬‬

‫اٌمذذبِ‪ٛ‬ط ‪٘ dictionary‬ذذ‪ ٟ‬ػجذذبسح ػذذٓ ِغّ‪ٛ‬ػذذخ غ‪١‬ذذش ِشرجذذخ ِذذٓ ص‪ٚ‬عذذ‪ِ ٓ١‬ذذشرج‪ّ٘ ٓ١‬ذذب ص‪ٚ‬ط اٌّفزذذبػ‬
‫‪ٚ‬اٌم‪ّ١‬خ ا‪ِ ٚ‬ب ‪٠‬ؼشف ثـ ‪. key-value pairs‬‬
‫‪٠‬ذذزُ اعذذزخذاِٗ ثشذذىً ػذذبَ ػٕذذذِب ِذذغ اٌىّ‪١‬ذذخ اٌ‪ٙ‬بئٍذذخ ِذذٓ اٌج‪١‬بٔذذبد رذذُ رؾغذذ‪ ٓ١‬اٌمذذ‪ٛ‬اِ‪١‬ظ‪dictionary‬‬
‫العذذزشعبع اٌج‪١‬بٔذذبد ثغذذ‪ٌٛٙ‬خ ‪ٚ‬ثطش‪٠‬مذذخ عذذش‪٠‬ؼخ ‪ٌٚ‬ذذزٌه ‪٠‬غذذت أْ ٔؼذذشف اٌّفزذذبػ ‪ key‬العذذزشداد اٌم‪ّ١‬ذذخ‬
‫‪ٌٚ value‬ىٓ ٌ‪١‬ظ اٌؼىظ ‪.‬‬
‫‪ّ٠‬ىٓ أْ ‪٠‬ى‪ ْٛ‬اٌّفزبػ ‪ٚ‬اٌم‪ّ١‬خ ِٓ أ‪ٛٔ ٞ‬ع ِٓ أٔ‪ٛ‬اع اٌج‪١‬بٔبد ا‪٢‬خش‪. ٜ‬‬
‫ٌإلػالْ ػٓ اٌمذ‪ٛ‬اِ‪١‬ظ ‪ dictionary‬أِذش عذ‪ِٚ ًٙ‬جبشذش ‪٠‬ذزُ رٌذه ػذٓ غش‪٠‬ذك ‪ٚ‬ظذغ اٌؼٕبصذش داخذً‬
‫ألذذذ‪ٛ‬اط } { ‪ِٚ‬فصذذذ‪ٛ‬ي ث‪ّٕٙ١‬ذذذب ثفبصذذذٍخ ‪ٚ Comma‬سِض٘ذذذب ( ‪ٔٚ ) ,‬فصذذذً ثذذذ‪ ٓ١‬وذذذً ‪key-value‬‬
‫ثبٌٕمطز‪ ٓ١‬اٌشئغ‪١‬ز‪ٚ colon ٓ١‬سِض٘ب ( ‪ ) :‬وب‪٢‬ر‪: ٟ‬‬
‫}‪d = {1:'value','key':2‬‬
‫))‪print(type(d‬‬
‫;)]‪print("d[1] = ", d[1‬‬
‫;)]'‪print("d['key'] = ", d['key‬‬
‫‪Output‬‬
‫>'‪<class 'dict‬‬
‫‪d[1] = value‬‬
‫‪d['key'] = 2‬‬
‫ٔغزخذَ اٌّفزبػ العزشداد اٌم‪ّ١‬خ اٌّؼٕ‪١‬خ‪ٌٚ .‬ىٓ ٌ‪١‬ظ اٌؼىظ الؽع ِب ‪: ٍٝ٠‬‬
‫}‪d = {1:'value','key':2‬‬
‫‪# Generates error‬‬

‫;)]‪print("d[2] = ", d[2‬‬
‫‪Output‬‬
‫>‪File "<string>", line 9, in <module‬‬
‫‪KeyError: 2‬‬
‫عبثؼب ً ‪ :Python boolean‬اٌم‪ ُ١‬إٌّطم‪١‬خ داخً ٌغخ ثب‪٠‬ض‪: ْٛ‬‬

‫اٌم‪ ُ١‬إٌّطم‪١‬خ ‪ ٟ٘ boolean‬ػجبسح ل‪ ُ١‬رغزخذَ ٌٍزؾمك ِٓ ل‪ّ١‬خ اٌزؼج‪١‬ش ‪٠ٚ expression‬ى‪ ْٛ‬إٌذبرظ‬
‫ئؽذ‪ ٜ‬ل‪ّ١‬ز‪ ٓ١‬ئِب ل‪ّ١‬خ ‪ True‬أ‪ ٚ‬ل‪ّ١‬خ ‪. False‬‬
‫‪٠‬ى‪ ْٛ‬اٌزؼج‪١‬ش صؾ‪١‬ؾب ً ‪ True‬ف‪ ٟ‬ؽبٌخ رؾمك اٌششغ أ‪ ٚ‬اٌزؼج‪١‬ش ‪.‬‬
‫‪٠‬ى‪ ْٛ‬اٌزؼج‪١‬ش خطأ ‪ False‬ف‪ ٟ‬ؽبٌخ ػذَ رؾمك اٌششغ أ‪ ٚ‬اٌزؼج‪١‬ش ‪.‬‬
‫)‪print(10 > 9‬‬
‫)‪print(10 == 9‬‬
‫)‪print(10 < 9‬‬
‫‪Output‬‬
‫‪True‬‬
‫‪False‬‬
‫‪False‬‬
‫رً‬ ‫إلى هنا نكون قد أخذنا نظرة سرٌعة على أنواع البٌانات ‪ ،‬وسوف نقوم بشرر للرا اونرواع باللل رٌ‬
‫الدروس القادمة ‪ ،‬سنقوم اآلن بأخذ نظرة سرٌعة على اللحوٌ بٌن أنواع البٌانات ‪.‬‬
Conversion between data types ‫بٔبد‬١‫اع اٌج‬ٛٔ‫ٓ أ‬١‫ً ث‬٠ٛ‫اٌزؾ‬
str() ٚ float() ٚ int() ً‫ع ِضذ‬ٌٕٛ‫ً ا‬٠ٛ‫اي رؾ‬ٚ‫بٔبد اٌّخزٍفخ ثبعزخذاَ د‬١‫اع اٌج‬ٛٔ‫ٓ أ‬١‫ً ث‬٠ٛ‫ّىٕٕب اٌزؾ‬٠
. ‫ّخ‬ٌّٙ‫اي ا‬ٚ‫ رٌه ِٓ اٌذ‬ٌٝ‫ِب ئ‬ٚ
: float ٌٝ‫ ئ‬integer ‫بٔبد‬١‫ع ث‬ٛٔ ِٓ ً٠ٛ‫ ِضبي رؾ‬

>>> float(5)
5.0
.‫ؼ‬١‫ت لشة سلُ صؾ‬٠‫زُ اٌزمش‬٠ : integer ٌٝ‫ ئ‬float ‫بٔبد‬١‫ع ث‬ٛٔ ِٓ ً٠ٛ‫ ِضبي رؾ‬
>>> float(10.6)
10
. ‫ اٌصفش‬ٌٝ‫غؼٍٗ ألشة ئ‬٠ٚ ‫ّخ‬١‫مطغ اٌم‬١‫ ع‬
. compatible values ‫افمخ‬ٛ‫ُ ِز‬١‫ ل‬ٍٝ‫ آخش٘ب ػ‬ٌٝ‫ ئ‬string ِٓ ً٠ٛ‫ اٌزؾ‬ٞٛ‫ؾز‬٠ ْ‫غت أ‬٠ ‫ ِضبي‬
>>> float('2.5')
2.5
>>> str(25)
'25'
>>> int('1p')
File "<string>", line 301, in runcode
File "<interactive input>", line 1, in <module>
ValueError: invalid literal for int() with base 10: '1p'
. ٜ‫ أخش‬ٌٝ‫ ئ‬sequence ‫خ‬١ٌ‫ً ِٓ ِززب‬٠ٛ‫ّىٕٕب رؾ‬٠ ‫ ِضبي‬

>>> set([1,2,3])
{1, 2, 3}
>>> tuple({5,6,7})
(5, 6, 7)
>>> list('hello')
['h', 'e', 'l', 'l', 'o']
.‫ ًعب‬ٚ‫ْ وً ػٕصش ص‬ٛ‫ى‬٠ ْ‫غت أ‬٠ ٓ‫ٌى‬ٚ dictionary ‫ط‬ِٛ‫ً ِٓ لب‬٠ٛ‫ّىٕٕب رؾ‬٠ ‫ ِضبي‬
>>> dict([[1,2],[3,4]])
{1: 2, 3: 4}
>>> dict([(3,26),(4,44)])
{3: 26, 4: 44}
‫ انتحول بيٍ أَواع انبياَات‬: ‫انذرس انثاَي‬
( Type Conversion & Type Casting )
ً‫ذ‬٠ٛ‫اعذزخذاِبد رؾ‬ٚ Type Conversion ‫ع‬ٛ‫ذً إٌذ‬٠ٛ‫ رؾ‬ٝ‫ عذززؼشف ػٍذ‬ٟ‫ّذ‬١ٍ‫ ٘ذزا اٌجشٔذبِظ اٌزؼ‬ٟ‫ فذ‬
.Python ٟ‫ع ف‬ٌٕٛ‫ا‬
. ‫اع‬ٛٔ ‫ٓ ٘زٖ ا‬١‫ً ث‬٠ٛ‫خ اٌزؾ‬١‫ف‬١‫ اٌزؼشف و‬ٍٝ‫ْ ٌٍزؼشف ػ‬٢‫ ا‬ٟ‫بٔبد ٔأر‬١‫اع اٌج‬ٛٔ‫ أ‬ٍٝ‫ثؼذ أْ رؼشفٕب ػ‬
‫ع‬ٌٕٛ‫ً ا‬٠ٛ‫ رؾ‬: Type Conversion 

‫بٔذبد آخذش‬١‫ع ث‬ٛٔ ٌٝ‫ ئٌ ) ئ‬integer , string , float( ً‫اؽذ ِض‬ٚ ‫بٔبد‬١‫ع ث‬ٛٔ ‫ّخ‬١‫ً ل‬٠ٛ‫خ رؾ‬١ٍّ‫ ػ‬ٛ٘
: ‫ع‬ٌٕٛ‫ً ا‬٠ٛ‫ػبْ ِٓ رؾ‬ٛٔ Python ٟ‫عذ ف‬ٛ٠ٚ
ّٟٕ‫ً اٌع‬٠ٛ‫ اٌزؾ‬ٚ‫ أ‬ّٟٕ‫ع اٌع‬ٌٕٛ‫ً ا‬٠ٛ‫ رؾ‬: Implicit Type Conversion ‫ي‬ٚ ‫ع ا‬ٌٕٛ‫ ا‬
‫بٔذبد آخذش‬١‫ع ث‬ٛ‫ ٔذ‬ٌٝ‫اؽذ ئ‬ٚ ‫بٔبد‬١‫ع ث‬ٛٔ ً٠ٛ‫ًب ثزؾ‬١‫ رٍمبئ‬Python َٛ‫ رم‬ّٟٕ‫ع اٌع‬ٌٕٛ‫ً ا‬٠ٛ‫ رؾ‬ٟ‫ف‬
.َ‫ رذخً ِٓ اٌّغزخذ‬ٞ‫ أ‬ٌٝ‫خ ال رؾزبط ئ‬١ٍّ‫٘زٖ اٌؼ‬ٚ
ٝ‫بٔذبد ا ػٍذ‬١‫ع اٌج‬ٛ‫ ٔذ‬ٝ‫ ئٌذ‬int ً‫بٔذبد ا لذ‬١‫ع اٌج‬ٛ‫ذً ٔذ‬٠ٛ‫ ثزؾ‬Python َٛ‫ذش رمذ‬١‫ ِضبالً ؽ‬ٜ‫ٔب ٔش‬ٛ‫ دػ‬
.‫بٔبد‬١‫ ٌزغٕت فمذاْ اٌج‬float
num_int = 123
num_flo = 1.23
num_new = num_int + num_flo
print("datatype of num_int:",type(num_int))
print("datatype of num_flo:",type(num_flo))
print("Value of num_new:",num_new)
print("datatype of num_new:",type(num_new))
Output
datatype of num_int: <class 'int'>
datatype of num_flo: <class 'float'>
Value of num_new: 124.23

datatype of num_new: <class 'float'>
ٟ‫ُ فذ‬ٙ‫ٔعذؼ‬ٚ float ‫ع‬ٛ‫ذش ِذٓ ٔذ‬١‫ِزغ‬ٚ int ‫ع‬ٛ‫ذش ِذٓ ٔذ‬١‫ٓ ِزغ‬٠‫ش‬١‫ اٌّضبي اٌغبثك ٔالؽع ػٕذ عّغ ِزغ‬ٟ‫ ف‬
َٛ‫ رمذ‬Python ْ flaot ‫بٔذبد‬١‫ع ث‬ٛ‫ ٔذ‬ٝ‫ ػٍذ‬ٞٛ‫ؾزذ‬٠ num_new ‫ذذ‬٠‫ش اٌغذ‬١‫ّخ اٌّزغ‬١‫ذ فاْ ل‬٠‫ش عذ‬١‫ِزغ‬
. ‫بٔبد‬١‫بٔبد أوجش ٌزغٕت فمذاْ اٌج‬١‫اع ث‬ٛٔ‫ أ‬ٌٝ‫بٔبد ا صغش ئ‬١‫اع اٌج‬ٛٔ‫ً أ‬٠ٛ‫ثزؾ‬
ْ ‫بٔذبد‬١‫ اٌج‬ٟ‫ْ ٕ٘بن فمذ ف‬ٛ‫ى‬١‫ فغ‬integer ‫ع‬ٛٔ ِٓ ْ‫وب‬ٚ float ‫ذ‬٠‫ش اٌغذ‬١‫ع اٌّزغ‬ٛٔ ْٛ‫ى‬٠ ُ‫ز‬٠ ٌُ ‫ ئرا‬
. ‫ؾخ‬١‫ّخ صؾ‬١‫ ألشة ل‬ٌٝ‫ؾخ عزمشة اٌشلُ ئ‬١‫ّخ اٌصؾ‬١‫اٌم‬
: ‫ب‬ٙ‫خ اٌزؼبًِ ِؼ‬١‫ف‬١‫و‬ٚ Python ً‫ داخ‬int ٚ string ‫ ِضبالً ئظبفخ‬ٜ‫ٔب ٔش‬ٛ‫ دػ‬
num_int = 123
num_str = "456"
print("Data type of num_int:",type(num_int))

print("Data type of num_str:",type(num_str))
print(num_int+num_str)
Output
Data type of num_int: <class 'int'>
Data type of num_str: <class 'str'>

File "python", line 7, in <module>
TypeError: unsupported operand type(s) for +: 'int' and 'str'
‫ ِذٓ اإلخذشاط ؽصذٍٕب‬ٜ‫ وّذب ٔذش‬.num_str ٚ num_int ٓ٠‫ذش‬١‫ ِزغ‬١‫ اٌّضذبي اٌغذبثك ػٕذذِب ٔعذ‬ٟ‫ ف‬
.‫ف‬ٚ‫ ِضذً ٘ذزٖ اٌظذش‬ٟ‫ ف‬ّٟٕ‫ً اٌع‬٠ٛ‫ اعزخذاَ اٌزؾ‬ٍٝ‫غذ لبدسح ػ‬١ٌ ْٛ‫ض‬٠‫ ْ ٌغخ ثب‬TypeError ٍٝ‫ػ‬
.‫ؼ‬٠‫ً اٌصش‬٠ٛ‫فخ ثبعُ اٌزؾ‬ٚ‫ال اٌّؼش‬ٌّٛ‫اع ِٓ ا‬ٛٔ ‫زٖ ا‬ٌٙ ً‫ب ؽ‬ٙ٠‫ ٌذ‬Python ْ‫ِغ رٌه فا‬ٚ
‫ؼ‬٠‫ً اٌصش‬٠ٛ‫ اٌزؾ‬ٚ‫ؼ أ‬٠‫ع اٌصش‬ٌٕٛ‫ً ا‬٠ٛ‫ رؾ‬: Explicit Type Conversion ٟٔ‫ع اٌضب‬ٌٕٛ‫ ا‬
‫بٔذذبد‬١‫ع اٌج‬ٛ‫ ٔذذ‬ٝ‫بٔذذبد اٌىذذبئٓ ئٌذذ‬١‫ع ث‬ٛ‫ذذً ٔذذ‬٠ٛ‫ْ ثزؾ‬ِٛ‫َ اٌّغذذزخذ‬ٛ‫مذذ‬٠ ‫ؼ‬٠‫ع اٌصذذش‬ٛ‫ذذً إٌذذ‬٠ٛ‫ رؾ‬ٟ‫فذذ‬
‫ رٌذه إلعذشات‬ٝ‫ِذب ئٌذ‬ٚ str)( ٚ float)( ٚ int)( ً‫ظبئ اٌّؾذدح ِغجمًب ِض‬ٌٛ‫ ٔغزخذَ ا‬.‫ة‬ٍٛ‫اٌّط‬
. ‫بٔبد‬١‫ع اٌج‬ٌٕٛ ‫ؼ‬٠‫ً صش‬٠ٛ‫رؾ‬
‫ذش‬١١‫ رغ‬ٟ‫ٍمذ‬٠ َ‫" ْ اٌّغذزخذ‬typecasting" ‫ظ‬١‫عذب اعذُ اٌزٍجذ‬

ً ٠‫ً أ‬٠ٛ‫ع ِٓ اٌزؾ‬ٌٕٛ‫ ٘زا ا‬ٍٝ‫ُطٍك ػ‬٠
.‫بٔبد اٌىبئٕبد‬١‫ع ث‬ٛٔ ٍٝ‫ ػ‬casts changes
: ٟ‫ر‬٢‫ع وب‬ٌٕٛ‫ العزخذاَ ٘زا ا‬Syntax ‫ شىً ثٕبت اٌغٍّخ‬

<required_datatype>(expression)
.expression ‫ش‬١‫ثخ ثذاخً اٌزؼج‬ٍٛ‫بٔبد اٌّط‬١‫ع اٌج‬ٛٔ ‫ٓ داٌخ‬١١‫ك رؼ‬٠‫ ػٓ غش‬Typecasting ًّ‫ّىٓ ػ‬٠ 
: ‫ؼ‬٠‫ً اٌصش‬٠ٛ‫ك اٌزؾ‬٠‫ ػٓ غش‬int ٚ string ‫ ئظبفخ‬ٍٝ‫ ِضبي ػ‬

num_int = 123
num_str = "456"
print("Data type of num_int:",type(num_int))

print("Data type of num_str before Type Casting:",type(num_str))
num_str = int(num_str)
print("Data type of num_str after Type Casting:",type(num_str))
num_sum = num_int + num_str
print("Sum of num_int and num_str:",num_sum)

print("Data type of the sum:",type(num_sum))
Output
Data type of num_int: <class 'int'>
Data type of num_str before Type Casting: <class 'str'>
Data type of num_str after Type Casting: <class 'int'>
Sum of num_int and num_str: 579

Data type of the sum: <class 'int'>
‫ذخ‬١ٍّ‫ إلعذشات ػ‬int)( ‫ (ألذً) ثبعذزخذاَ داٌذخ‬int ‫ع‬ٛٔ ٌٝ‫) ئ‬ٍٝ‫ (أػ‬string ِٓ num_str ً٠ٛ‫ لّٕب ثزؾ‬
ٓ٠‫ ئظذذذبفخ ٘ذذذز‬Python ‫غ‬١‫ رغذذذزط‬int ‫ؼ‬١‫ّذذذخ ػذذذذد صذذذؾ‬١‫ ل‬ٝ‫ ئٌذذذ‬num_str ً‫ذذذ‬٠ٛ‫ثؼذذذذ رؾ‬ٚ ‫اٌغّذذذغ‬
.ٓ٠‫ش‬١‫اٌّزغ‬
ً‫ذ‬٠ٛ‫ذب فّذضال ئرا أسدٔذب رؾ‬ٙ‫ذً اٌخبصذخ ث‬٠ٛ‫ذب داٌذخ اٌزؾ‬ٌٙ َ‫ب ٔغذزخذ‬ٙ١ٌ‫ً ئ‬٠ٛ‫ّخ اٌّشاد اٌزؾ‬١‫ أْ اٌم‬ٝ‫ ال رٕغ‬
‫ثبٌّضذذً ئرا أسدٔذذب‬ٚ int)( ‫ داٌذذخ‬ٝ‫٘ذذ‬ٚ ‫ذذب‬ٙ١ٌ‫ذذً ئ‬٠ٛ‫ة اٌزؾ‬ٛ‫ فإٔذذب ٔغذذزخذَ داٌذذخ اٌّطٍذذ‬int ٝ‫ ئٌذذ‬string ٓ‫ِذذ‬
. ... ‫٘ىزا‬ٚ str)( ‫ داٌخ‬ٝ٘ٚ ‫ب‬ٙ١ٌ‫ً ئ‬٠ٛ‫ة اٌزؾ‬ٍٛ‫ فإٔب ٔغزخذَ داٌخ اٌّط‬string ٌٝ‫ ئ‬int ِٓ ً٠ٛ‫رؾ‬
.‫بٔبد آخش‬١‫ع ث‬ٛٔ ٌٝ‫بٔبد ئ‬١‫ع ث‬ٛٔ ِٓ object ٓ‫ً اٌىبئ‬٠ٛ‫ رؾ‬ٛ٘ Type Conversion ً٠ٛ‫ع اٌزؾ‬ٛٔ 
ٟ‫بٔبد فذ‬١‫ فمذاْ اٌج‬Python ‫رزغٕت ٌغخ‬ٚ ْٛ‫ض‬٠‫اعطخ ِزشعُ ثب‬ٛ‫ًب ث‬١‫ رٍمبئ‬ّٟٕ‫ع اٌع‬ٌٕٛ‫ً ا‬٠ٛ‫زُ ئعشات رؾ‬٠ 
. ّٟٕ‫ً اٌع‬٠ٛ‫اٌزؾ‬
‫عب اعُ ‪ Type Casting‬ؽ‪١‬ش ‪٠‬زُ رؾ‪ ً٠ٛ‬أٔ‪ٛ‬اع ث‪١‬بٔبد اٌىبئٕذبد‬‫‪ُ٠ ‬طٍك ػٍ‪ ٝ‬رؾ‪ ً٠ٛ‬إٌ‪ٛ‬ع اٌصش‪٠‬ؼ أ‪ً ٠‬‬
‫ثبعزخذاَ ‪ٚ‬ظبئ ِؾذدح ِغجمًب ث‪ٛ‬اعطخ اٌّغذزخذَ ‪ٚ‬فذ‪ Type Casting ٟ‬لذذ ‪٠‬ؾذذس فمذذاْ ٌٍج‪١‬بٔذبد‬
‫ٕٔب ٔفشض ‪ٔٚ‬غجش اٌىبئٓ ػٍ‪ٛٔ ٝ‬ع ث‪١‬بٔبد ِؼ‪.ٓ١‬‬
‫‪ٛٔ : Data Type & class Type ‬ع اٌج‪١‬بٔبد ‪ٛٔٚ‬ع اٌفئخ‬
‫وذً ٔذ‪ٛ‬ع ِذذٓ ٘ذزٖ ا ٔذذ‪ٛ‬اع ‪ٕ٠‬زّذ‪ ٟ‬ئٌذذ‪ ٝ‬فئذخ ‪ class‬رخصذذ‪ٙ‬ب ؽ‪١‬ذش ‪٠‬ذذزُ رؼش‪٠‬ذ وذذً ٔذ‪ٛ‬ع ػذذٓ غش‪٠‬ذك اٌفئذذخ‬
‫‪ class‬اٌخب ثٗ فّضالً ‪:‬‬
‫‪ٛٔ ‬ع اٌج‪١‬بٔبد ‪ٕ٠ int‬زّ‪ ٟ‬ئٌ‪ int class ٝ‬أ‪٠ ٞ‬زُ رؼش‪٠‬ف‪ٙ‬ب ِٓ خالي ‪.int class‬‬
‫‪ٛٔ ‬ع اٌج‪١‬بٔبد ‪ٕ٠ float‬زّ‪ ٟ‬ئٌ‪ float class ٝ‬أ‪٠ ٞ‬زُ رؼش‪٠‬ف‪ٙ‬ب ِٓ خالي ‪.float class‬‬
‫‪ٛٔ ‬ع اٌج‪١‬بٔبد ‪ٕ٠ complex‬زّ‪ ٟ‬ئٌ‪ complex class ٝ‬أ‪٠ ٞ‬زُ رؼش‪٠‬ف‪ٙ‬ب ِٓ خالي ‪.complex class‬‬
‫‪ ‬و‪١‬ف‪١‬خ ِؼشفخ ٔ‪ٛ‬ع اٌىبئٓ ف‪ٕ٘ : Python ٟ‬بن داٌز‪ّ٘ ٓ١‬ب‬

‫‪: type)( function ‬‬
‫داٌخ ثزشعغ ٔ‪ٛ‬ع اٌىبئٓ ‪ object type‬اٌ ُّؾذد ‪.‬‬
‫‪ Synax :‬‬ ‫)‪type(object, bases, dict‬‬
‫‪ : Parameter Values ‬ل‪ ُ١‬اٌّؼبِالد اٌز‪ّ٠ ٟ‬ىٓ رّش‪٠‬ش٘ب‬

‫‪ : object‬اٌىبئٓ اٌّطٍ‪ٛ‬ة اٌزؾمك ِٕٗ ‪.‬‬ ‫‪‬‬
‫‪٠ : bases‬ؾذد اٌفئبد ا عبع‪١‬خ (‪. )Optional‬‬ ‫‪‬‬
‫‪٠ : dict‬ؾذد ‪ِ namespace‬غ رؼش‪ ٠‬اٌفئخ (‪. )Optional‬‬ ‫‪‬‬
‫>'‪<class 'int‬‬
‫‪: isinstance)( function ‬‬
‫داٌخ ٌٍزؾمك ِّب ئرا وبْ اٌىبئٓ ‪ٕ٠ object‬زّ‪ ٟ‬ئٌ‪ ٝ‬فئخ ‪ِ class‬ؼ‪ٚ ٓ١‬ئال ٘زشعغ ‪. False‬‬
‫‪ Synax :‬‬ ‫)‪isinstance(object , type‬‬
‫‪ : Parameter Values ‬ل‪ ُ١‬اٌّؼبِالد اٌز‪ّ٠ ٟ‬ىٓ رّش‪٠‬ش٘ب‬

‫‪ : object ‬اٌىبئٓ اٌّطٍ‪ٛ‬ة اٌزؾمك ِٕٗ ‪.‬‬
‫‪ٛٔ : type ‬ع اٌفئخ اٌز‪٠ ٟ‬زُ اٌزؾمك ػٍ‪ٙ١‬ب ‪ّ٠ٚ‬ىٓ أْ ‪٠‬ى‪ِ ْٛ‬غّ‪ٛ‬ػخ ِٓ أٔ‪ٛ‬اع اٌفئبد ‪tuple of types classes‬‬
‫‪ٚ‬ئرا وبٔذ اٌّؼبًِ اٌضبٔ‪ tuple ٟ‬فغزؼ‪١‬ذ ٘زٖ اٌذاٌخ ‪ True‬ئرا وبْ اٌىبئٓ أؽذ ا ٔ‪ٛ‬اع اٌّ‪ٛ‬ع‪ٛ‬دح ف‪. tuple ٟ‬‬
‫ثؼط ا ِضٍخ ػٍ‪ ٝ‬داٌخ )(‪ٚ type‬داٌخ )(‪isinstance‬‬
a=30 #integer
b=30.4 #float
c=5j #complex
d= True #boolean
e="Mahmoud Soliman" #String
f='M' #String
g=["mahmoud","Mohammed","Abd El-Atty" ,"Soliman"] #list
h=("mahmoud","Mohammed","Abd El-Atty" ,"Soliman") #tuple
i={"mahmoud","Mohammed","Abd El-Atty" ,"Soliman"} #set
j={"firstName" :"Mahmoud" ,"secondName":"Mohammed" ,"lastName" : "Soliman"} #dictionary
print("This is Exmples of type() function ")

print(type(a))
print(type(b))
print(type(c))
print(type(d))
print(type(e))
print(type(f))
print(type(g))
print(type(h))
print(type(i))
print(type(j))
print("\n" + "This is Exmples of isinstance() function ")

print(isinstance(a,int))
print(isinstance(b,int))
print(isinstance(c,(int,str,bool)))
print(isinstance(c,(int,str,bool,complex)))
output
This is Exmples of type() function
<class 'int'>
<class 'float'>
<class 'complex'>
<class 'str'>
<class 'str'>
<class 'bool'>
<class 'list'>
<class 'tuple'>
<class 'set'>
<class 'dict'>
This is Exmples of isinstance() function

True
False
False
True
‫انذرس انثانث ‪ :‬األرقاو‬
‫) ‪( Numbers‬‬
‫‪ ‬فذذ‪٘ ٟ‬ذذزا اٌجشٔذذبِظ اٌزؼٍ‪ّ١‬ذذ‪ ٟ‬عذذززؼشف ػٍذذ‪ ٝ‬ا سلذذبَ ‪ numbers‬اٌّخزٍفذذخ اٌّغذذزخذِخ فذذ‪Python ٟ‬‬
‫‪ٚ‬و‪١‬ف‪١‬ذذذذخ اٌزؾ‪٠ٛ‬ذذذذً ‪ِ conversion‬ذذذذٓ ٔذذذذ‪ٛ‬ع ئٌذذذذ‪ ٝ‬آخذذذذش ‪ٚ‬اٌؼٍّ‪١‬ذذذذبد اٌؾغذذذذبث‪١‬خ ‪mathematical‬‬
‫‪ operations‬اٌّذػ‪ِٛ‬خ ف‪ٌ ٟ‬غخ ‪. Python‬‬
‫‪ : Numbers‬ا سلبَ‬
‫ٕ٘بن صالصخ أٔ‪ٛ‬اع سلّ‪١‬خ ف‪ ٟ‬ثب‪٠‬ض‪: ْٛ‬‬
‫‪ : int ‬ا سلبَ اٌصؾ‪١‬ؾخ ‪ِ Integers numbers‬ضً ‪ 5‬أ‪. -5 ٚ‬‬
‫٘‪ ٛ‬أ‪ ٞ‬ػذد صؾ‪١‬ؼ ِ‪ٛ‬عت أ‪ ٚ‬عبٌت ثذ‪ ْٚ‬وغ‪ٛ‬س ػشش‪٠‬خ ثط‪ٛ‬ي غ‪١‬ش ِؾذ‪ٚ‬د ‪.‬‬
‫)"‪print("integer data types‬‬
‫‪x1=5 ; y1=-5 ; z1= 36783902987463562‬‬
‫))‪print(type(x1‬‬
‫))‪print(type(y1‬‬
‫))‪print(type(z1‬‬
‫‪output‬‬
‫‪integer data types‬‬
‫‪ : float ‬ا سلبَ اٌؼشش‪٠‬خ ‪ِ floating numbers‬ضً ‪ 5.4‬أ‪-5.4 ٚ‬‬

‫٘‪ ٛ‬أ‪ ٞ‬سلُ ػشش‪ِٛ ٞ‬عت أ‪ ٚ‬عبٌت ‪٠ٚ‬أخذز ِذٓ سلذُ ‪ 1‬ئٌذ‪ 15 ٟ‬سلذُ ػشذش‪ٚ ٞ‬ئرا رذُ ئدخذبي أوضذش‬
‫ِٓ ‪ 15‬سلُ ػشش‪ ٞ‬ع‪١‬زُ ؽزف اٌم‪ ُ١‬اٌؼشش‪٠‬خ اٌضائذح ‪.‬‬
‫)"‪print( "float data types‬‬
‫‪x2= 1.10 ; y2 = 1.0 ; z2 = -35.59‬‬
‫))‪print(type(x2‬‬
‫))‪print(type(y2‬‬
‫))‪print(type(z2‬‬
‫‪output‬‬
‫‪float data types‬‬
‫>'‪<class 'float‬‬
‫‪ ‬ث‪ّٕ١‬ب ‪ّ٠‬ىٓ أْ رى‪ ْٛ‬ا ػذاد اٌصؾ‪١‬ؾخ ثأ‪ ٞ‬غ‪ٛ‬ي فاْ االسلبَ اٌؼشش‪٠‬خ رى‪ ْٛ‬ل‪ ُ١‬دل‪١‬مخ فمػ ؽز‪ٝ‬‬
‫‪ 15‬سلُ ػشش‪ ٞ‬ثؼذ اٌؼالِخ (اٌّىبْ اٌغبدط ػشش غ‪١‬ش دل‪١‬ك)‪.‬‬
.10 ‫ح‬ٛ‫ ل‬ٌٝ‫" ٌإلشبسح ئ‬e" ‫خ ثؾشف‬١ٍّ‫ أسلب ًِب ػ‬Float ْٛ‫عب أْ رى‬
ً ٠‫ّىٓ أ‬٠ٚ
print("float data types in values e ")
x3 = 35e3 ; y3 = 12E4 ; z3 = -87.7e100
print(type(x3))
print(type(y3))
print(type(z3))
output
float data types in values e
<class 'float'>
<class 'float'>
<class 'float'>
-2-5j ٚ‫ أ‬2+5j ً‫ ِض‬complex numbers ‫ ا سلبَ اٌّشوجخ‬: complex 

‫ش‬١‫ ؽ‬x + yj ٌٟ‫ب ثبٌشىً اٌزب‬ٙ‫غز‬١‫زُ وزبثخ ص‬٠ٚ ٍٟ١‫" وغضت رخ‬j" ‫ؼجش ػٕٗ ثؾشف‬٠ ُ‫ سل‬ٞ‫ أ‬ٛ٘
. imaginary part ٍٟ١‫ اٌغضت اٌزخ‬y ٚ real part ٟ‫م‬١‫ اٌغضت اٌؾم‬ٛ٘ x
print("complex data types")

x4 = 3+5j ; y4 = 5j ; z4 = -5j
print(type(x4))
print(type(y4))
print(type(z4))
output
complex data types
<class 'complex'>
<class 'complex'>
<class 'complex'>
: ‫خ‬١‫ر‬٢‫اي ا‬ٚ‫ آخش ثبعزخذاَ اٌذ‬ٌٝ‫ع ئ‬ٛٔ ِٓ ً٠ٛ‫ّىٕه اٌزؾ‬٠ : Type Conversion
. int ‫ع‬ٛٔ ٌٝ‫ ئ‬object ‫ع‬ٛٔ ٞ‫ً ِٓ أ‬٠ٛ‫ ٌٍزؾ‬: int(object) ‫داٌخ‬ 
. float ‫ع‬ٛٔ ٌٝ‫ ئ‬object ‫ع‬ٛٔ ٞ‫ً ِٓ أ‬٠ٛ‫ ٌٍزؾ‬: float(object) ‫داٌخ‬ 
. complex ‫ع‬ٛٔ ٌٝ‫ ئ‬object ‫ع‬ٛٔ ٞ‫ً ِٓ أ‬٠ٛ‫ ٌٍزؾ‬: complex(object) ‫داٌخ‬ 
. string ‫ع‬ٛٔ ٌٝ‫ ئ‬object ‫ع‬ٛٔ ٞ‫ً ِٓ أ‬٠ٛ‫ ٌٍزؾ‬: str(object) ‫داٌخ‬ 
‫ّذخ‬١‫ ل‬ٟ‫ ئٌذ‬5.9 ‫ّذخ‬١‫ذً اٌم‬٠ٛ‫بٔذبد فّذضالً ػٕذذ رؾ‬١‫ اٌج‬ٟ‫ؾذس فمذذ فذ‬٠ ْ‫ فا‬int ٌٝ‫ ئ‬float ِٓ ً٠ٛ‫ ػٕذ اٌزؾ‬
. 0.9 ‫ّخ‬١‫زُ رغبً٘ ل‬٠ ٗٔ ‫ش‬١‫س ؽ‬ٛ‫ّخ اٌىغ‬١‫زُ فمذ ل‬٠ٚ 5 ‫ْ إٌبرظ‬ٛ‫ى‬١‫ ع‬int ‫ؾخ‬١‫صؾ‬
. ‫ع سلُ آخش‬ٛٔ ٌٝ‫ ئ‬complex ‫ً ا سلبَ اٌّشوجخ‬٠ٛ‫ّىٕه رؾ‬٠ ‫ ال‬
x = 1 # int
y = 2.8 # float
z = 1j # complex
#convert from int to float:

print("convert from int to float:")
a = float(x)
print(a)
print(type(a))
#convert from float to int:

print("\n"+"convert from float to int:")
b = int(y)
print(b)
print(type(b))
#convert from int to complex:

print("\n"+"convert from int to complex:")
c = complex(x)
print(c)
print(type(c))
#convert from int to complex:

print("\n"+"convert from int to string:")
c = str(x)
print(c)
print(type(c))
output
convert from int to float:
1.0
<class 'float'>
convert from float to int:

2
<class 'int'>
convert from int to complex:

(1+0j)
<class 'complex'>
convert from int to string:
1
<class 'str'>
ٟ‫مذ‬١‫ّخ اٌغضت اٌؾم‬١‫ب ٌم‬ٙ‫ص‬١‫زُ رخص‬١‫ ع‬int ُ‫ّخ اٌشل‬١‫ فاْ اٌم‬complex ٌٝ‫ ئ‬int ِٓ ً٠ٛ‫ الؽع ػٕذ اٌزؾ‬
ٞٚ‫ رغذب‬ٟ‫ٍذ‬١‫ّذخ اٌغذضت اٌزخ‬١‫صذجؼ ل‬٠ ٌٟ‫ثبٌزب‬ٚ )0j) ‫ّخ‬١‫ ثبٌم‬ٍٟ١‫عغ اٌغضت اٌزخ‬١‫ع‬ٚ real number
. 1 + 0j ‫ْ إٌبرظ‬ٛ‫ى‬١‫ ع‬complex ‫ّخ‬١‫ ل‬ٌٟ‫ ئ‬1 ‫ّخ‬١‫ً اٌم‬٠ٛ‫صفش فّضالً ػٕذ رؾ‬
‫‪ : Python Decimal‬اٌزؼبًِ ِغ ا سلبَ اٌؼشش‪٠‬خ داخً ٌغخ اٌجبص‪ْٛ‬‬
‫رم‪ َٛ‬فئخ ا سلذبَ اٌؼشذش‪٠‬خ ‪ class float‬اٌّذذِظ فذ‪ Python ٟ‬ثذجؼط اٌؾغذبثبد اٌزذ‪ ٟ‬لذذ رذ٘شذٕب‪ٔ .‬ؼٍذُ‬
‫عّ‪١‬ؼًب أْ ِغّ‪ٛ‬ع ‪٠ 2.2 ٚ 1.1‬غب‪ٌ 3.3 ٞٚ‬ىٓ ٌغخ اٌجب‪٠‬ض‪ ْٛ‬غ‪١‬ش ِ‪ٛ‬افك ٌ‪ٙ‬زا إٌبرظ ‪.‬‬
‫‪x= (1.1 + 2.2) == 3.3‬‬
‫)‪print (x‬‬
‫‪output‬‬
‫‪False‬‬
‫‪ِ ‬ب اٌز‪ ٞ‬ؽذس ؟‬

‫‪ ‬ارعؼ أْ ا سلبَ اٌؼشش‪٠‬خ ‪٠ float‬زُ رٕف‪١‬ز٘ب ف‪ ٟ‬أع‪ٙ‬ذضح اٌىّج‪١‬ذ‪ٛ‬رش وىغذ‪ٛ‬س صٕبئ‪١‬ذخ ‪binary fractions‬‬
‫ْ اٌىّج‪ٛ١‬رش ال ‪٠‬ف‪ ُٙ‬ع‪ ٜٛ‬إٌظبَ اٌضٕبئ‪ٌٙ binary (0 and 1) ٟ‬زا اٌغجت ال ‪ّ٠‬ىٓ رخذض‪ِ ٓ٠‬ؼظذُ‬
‫اٌىغ‪ٛ‬س اٌؼشش‪٠‬خ ‪ decimal fractions‬اٌز‪ٔ ٟ‬ؼشف‪ٙ‬ب ثذلخ ف‪ ٟ‬ع‪ٙ‬بص اٌىّج‪ٛ١‬رش اٌخب ثٕب‪.‬‬
‫وشلُ ػشش‪ ٞ‬ع‪١‬ؼط‪٘ ٟ‬زا ‪٘ٚ 0.33333333...‬ذ‪ ٛ‬لذ‪ ُ١‬غ‪٠ٛ‬ذً ثذال‬ ‫‪ٌٕ ‬أخز ِضبال ال ‪ّ٠‬ىٕٕب رّض‪ ً١‬اٌىغش‬
‫ؽذ‪ٚ‬د ‪ّ٠ٚ infinitely long‬ىٕٕب فمػ رمش‪٠‬جٗ‪.‬‬
‫‪ ‬ارعذذذذذذذؼ أْ اٌىغذذذذذذذش اٌؼشذذذذذذذش‪ 0.1 ٞ‬عذذذذذذذ‪ٕ١‬زظ ػٕذذذذذذذٗ وغذذذذذذذش صٕذذذذذذذبئ‪ ٟ‬غ‪٠ٛ‬ذذذذذذذً ثذذذذذذذال ؽذذذذذذذذ‪ٚ‬د ٌذذذذذذذـ‬
‫‪٠ٚ 0.000110011001100110011...‬خذذضْ ع‪ٙ‬ذذبص اٌىّج‪١‬ذذ‪ٛ‬رش ٌذذذ‪ٕ٠‬ب ػذذذدًا ِؾذذذ‪ٚ‬دًا ِٕذذٗ فمذذػ‪٘ٚ .‬ذذزا‬
‫ع‪١‬مبسة ‪ 0.1‬فمػ ‪ٌٚ‬ىٕٗ ٌٓ ‪٠‬ى‪ِ ْٛ‬زغب‪ً٠ٚ‬ب أثذًا‪ ِٓٚ .‬صُ فاْ ٘زا ٘ذ‪ ٛ‬اٌؾذذ ِذٓ أع‪ٙ‬ذضح اٌىّج‪١‬ذ‪ٛ‬رش ٌذذ‪ٕ٠‬ب‬
‫‪١ٌٚ‬ظ خطأ ف‪.Python ٟ‬‬
‫‪x= 1.1 + 2.2‬‬
‫)‪print (x‬‬
‫‪output‬‬
‫‪3.3000000000000003‬‬
‫لللغل ر علررى هررذ المشرركلة ‪ٌ ،‬مكننررا اسررلخدام ‪ decimal module‬اللررً لررألً م ر ‪ . Python‬بٌنمررا‬
‫إلى ‪ 51‬رقم عشرًٌا ‪ ،‬رنن ‪decimal module‬‬ ‫لحلوي ‪floating-point numbers‬على دقة ل‬
‫للمل بدقة ٌمكن للمسلخدم ضبطها‪.‬‬
‫‪import decimal‬‬
‫)‪print(0.1‬‬
‫))‪print(decimal.Decimal(0.1‬‬
‫‪output‬‬
‫‪0.1‬‬
‫‪0.1000000000000000055511151231257827021181583404541015625‬‬
‫‪ ‬رُغزخذَ ٘زٖ ‪ module‬ػٕذذِب ٔش‪٠‬ذذ ئعذشات ؽغذبثبد ػشذش‪٠‬خ وّذب رؼٍّٕذب فذ‪ ٟ‬اٌّذسعذخ‪ .‬وّذب أٔذٗ ‪٠‬ؾذبفع‬
‫ػٍ‪ ٝ‬اٌّغض‪ٔ . significance ٜ‬ؼٍُ أْ ‪ 25.50‬وغُ ٘‪ ٟ‬أوضش دلخ ِذٓ ‪ 25.5‬وغذُ ٔ‪ٙ‬ذب رؾزذ‪ ٞٛ‬ػٍذ‪ٝ‬‬
‫سلّ‪ ٓ١‬ػشش‪ِ ٓ١ِّٙ ٓ١٠‬مبسٔخ ثشلُ ػشش‪ٚ ٞ‬اؽذ ‪.‬‬
‫‪from decimal import Decimal as D‬‬
‫))'‪print(D('1.1') + D('2.2‬‬
‫))'‪print(D('1.2') * D('2.50‬‬
‫‪output‬‬
‫‪3.3‬‬
‫‪3.000‬‬
‫‪ ‬الؽع ا صفبس ‪ zeros‬اٌالؽمخ ف‪ ٟ‬اٌّضبي اٌغبثك ‪.‬‬
‫‪ ‬لذ ٔزغبتي ٌّبرا ال ٔطجك ‪ Decimal‬وً ِشح ثذالً ِٓ ‪ float‬؟ اٌغذجت اٌشئ‪١‬غذ‪٘ ٟ‬ذ‪ ٛ‬اٌىفذبتح ‪٠‬غذت أْ‬
‫‪٠‬زُ رٕف‪١‬ز ػٍّ‪١‬بد ‪ Floating point‬ثشىً أعشع ِٓ ػٍّ‪١‬بد ‪.Decimal‬‬
‫‪ِ ‬ز‪٠ ٝ‬زُ اعزخذاَ ‪ Decimal‬ثذالً ِٓ ‪ float‬؟ ٔغزخذَ ثشىً ػبَ ‪ Decimal‬ف‪ ٟ‬اٌؾبالد اٌزبٌ‪١‬خ ‪:‬‬
‫‪ o‬ػٕذِب ٔغش‪ ٞ‬رطج‪١‬مبد ِبٌ‪١‬خ ‪ financial applications‬رؾزبط ئٌ‪ ٝ‬رّض‪ decimal ً١‬دل‪١‬ك‪.‬‬
‫‪ o‬ػٕذِب ٔش‪٠‬ذ اٌزؾىُ ف‪ِ ٟ‬غز‪ ٜٛ‬اٌذلخ اٌّطٍ‪ٛ‬ثخ ‪. control the level of precision‬‬
‫‪ o‬ػٕذِب ٔش‪٠‬ذ رطج‪١‬ك ِف‪ِٛ َٛٙ‬اظغ ‪ٚ‬أِبوٓ اٌؼالِخ اٌؼشش‪٠‬خ اٌّ‪ّٙ‬خ‪.‬‬
‫‪ : Python Fractions‬اٌزؼبًِ ِغ اٌىغ‪ٛ‬س اٌؼشش‪٠‬خ داخً ٌغخ اٌجبص‪ْٛ‬‬

‫ر‪ٛ‬فش ٌغخ ‪ Python‬ػٍّ‪١‬بد رزعذّٓ أػذذادًا وغذش‪٠‬خ ‪ِ fractional numbers‬ذٓ خذالي ‪ٚ‬ؽذذح اٌىغذ‪ٛ‬س‬
‫اٌخبصخ ث‪ٙ‬ب ‪ . fractions module‬وّب ٔؼٍُ أْ اٌىغذش ‪٘ fraction‬ذ‪ ٛ‬ػجذبسح ػذٓ ثغذػ ‪numerator‬‬
‫‪ِٚ‬مبَ ‪ٚ denominator‬والّ٘ب ػذد صؾ‪١‬ؼ‪ .‬رؾز‪٘ ٞٛ‬زٖ اٌ‪ٛ‬ؽذح ػٍذ‪ ٝ‬دػذُ ٌؾغذبة اٌؼذذد إٌّطمذ‪ٟ‬‬
‫‪.rational number arithmetic‬‬
‫‪ّ٠ ‬ىٕٕب ئٔشبت ‪ Fraction objects‬ثطشق ِخزٍفخ‪ .‬دػ‪ٔٛ‬ب ٍٔم‪ٔ ٟ‬ظشح ػٍ‪.ُٙ١‬‬
‫‪import fractions‬‬
‫))‪print(fractions.Fraction(1.5‬‬
‫))‪print(fractions.Fraction(5‬‬
‫))‪print(fractions.Fraction(1,3‬‬
‫‪output‬‬
‫‪3/2‬‬
‫‪5‬‬
‫‪1/3‬‬
ٝ‫شعغ رٌذه ئٌذ‬٠ٚ .‫خ‬٠‫ش اٌؼبد‬١‫ ثؼط إٌزبئظ غ‬ٍٝ‫ لذ ٔؾصً ػ‬float ‫خ‬٠‫ أصٕبت ئٔشبت اٌىغش ِٓ أسلبَ ػشش‬
. ً ‫ وّب رّذ ِٕبلشزٗ عبثمب‬ٟ‫خ اٌضٕبئ‬٠‫ش اٌىبًِ ٌالسلبَ اٌؼشش‬١‫ً غ‬١‫اٌزّض‬
ً ٠‫ أ‬string ‫ وذذبئٓ ثغٍغذذٍخ‬ٚ‫ذذً أ‬١‫ ثأشذذبت ِض‬Fraction ‫غذذّؼ ٌٕذذب‬٠ ‫ ٌؾغذذٓ اٌؾذذع‬
‫ذذبس‬١‫ اٌخ‬ٛ‫٘ذذزا ٘ذذ‬ٚ .‫عذذب‬
. decimal numbers ‫خ‬٠‫اٌّفعً ػٕذ اعزخذاَ ا سلبَ اٌؼشش‬
import fractions
# As float
# Output: 2476979795053773/2251799813685248
print(fractions.Fraction(1.1))
# As string
# Output: 11/10
print(fractions.Fraction('1.1'))
output
2476979795053773/2251799813685248
11/10
.‫ رٌه‬ٍٝ‫ ثؼط ا ِضٍخ ػ‬ٍٟ٠ ‫ّب‬١‫ف‬ٚ .‫خ‬١‫بد ا عبع‬١ٍّ‫غ اٌؼ‬١ّ‫بٔبد ع‬١‫ع اٌج‬ٛٔ ‫ذػُ ٘زا‬٠ٚ 
from fractions import Fraction as F
print(F(1, 3) + F(1, 3))

print(1 / F(5, 6))
print(F(-3, 10) > 0)
print(F(-3, 10) < 0)
output
2/3
6/5
False
True
‫‪ :Python Mathematics‬اٌزؼبًِ ِغ اٌؾغبثبد أ‪ ٚ‬اٌش‪٠‬بظ‪١‬بد داخً ٌغخ اٌجبص‪ْٛ‬‬
‫رذذذ‪ٛ‬فش ٌغذذذخ ‪ٚ Python‬ؽذذذذاد ‪ِ modules‬ضذذذً اٌش‪٠‬بظذذذ‪١‬بد ‪ٚ math‬اٌؼشذذذ‪ٛ‬ائ‪١‬خ ‪ٌ random‬زٕف‪١‬ذذذز‬
‫ؽغذذذذبثبد س‪٠‬بظذذذذ‪١‬خ ِخزٍفذذذذخ ِضذذذذً ػٍذذذذُ ؽغذذذذبة اٌّضٍضذذذذبد ‪ٚ trigonometry‬ػٍذذذذُ اٌٍ‪ٛ‬غبس‪٠‬زّذذذذبد‬
‫‪ٚ logarithms‬ػٍُ االؽزّبالد ‪ٚ probability‬ػٍُ اإلؽصبت ‪ statistics‬ئٌ ‪.‬‬
‫‪ٕ٘ ‬ذذبن اٌىض‪١‬ذذش ِذذٓ اٌذذذ‪ٚ‬اي ‪ٚ‬اٌخذذ‪ٛ‬ا اٌزذذ‪ّ٠ ٟ‬ىٕٕذذب اعذذزخذاِ‪ٙ‬ب داخذذً ‪ٚ‬ؽذذذح ‪ٌٍٚ math‬زؼذذشف ػٍذذ‪٘ ٝ‬ذذزٖ‬
‫اٌذ‪ٚ‬اي ‪ٚ‬اٌخ‪ٛ‬ا ‪ّ٠‬ىٕه اٌذخ‪ٛ‬ي ػٍ‪٘ ٝ‬زا اٌشاثػ ‪. www.programiz.com‬‬
‫‪import math‬‬
‫)‪print(math.pi‬‬
‫))‪print(math.cos(math.pi‬‬
‫))‪print(math.exp(10‬‬
‫))‪print(math.log10(1000‬‬
‫))‪print(math.sinh(1‬‬
‫))‪print(math.factorial(6‬‬
‫‪output‬‬
‫‪3.141592653589793‬‬
‫‪-1.0‬‬
‫‪22026.465794806718‬‬
‫‪3.0‬‬
‫‪1.1752011936438014‬‬
‫‪720‬‬
ٟ‫ائ‬ٛ‫ اٌشلُ اٌؼش‬:Random Number
‫ ٌىذٓ ٌغذخ‬random number ٟ‫ائ‬ٛ‫ إلٔشذبت سلذُ ػشذ‬random() ‫ داٌذخ‬ٝ‫ ػٍذ‬Python ‫ ٌغذخ‬ٞٛ‫ال رؾز‬
َ‫ب إلٔشذبت أسلذب‬ِٙ‫ّىٓ اعزخذا‬٠ random ّٝ‫ رغ‬built-in module ‫خ ِذِغخ‬١‫ؽذح ّٔط‬ٚ ‫ب‬ٙ‫ ث‬Python
: random number ‫خ‬١‫ائ‬ٛ‫ػش‬
. ‫ب‬ِٙ‫ لجً اعزخذا‬import ‫شاد‬١‫ب اعز‬ٌٙ ًّ‫غت أْ ٔؼ‬٠ module ‫ؽذح‬ٚ ٞ‫ العزخذاَ أ‬
:randrange)( function 
. ‫ اٌ ُّؾذد‬object type ٓ‫ع اٌىبئ‬ٛٔ ‫داٌخ ثزشعغ‬
 Synax : randrange(start, stop, step)
‫ش٘ب‬٠‫ّىٓ رّش‬٠ ٟ‫ُ اٌّؼبِالد اٌز‬١‫ ل‬: Parameter Values 

. )Optional ‫خ‬٠‫بس‬١‫ّخ اخز‬١‫ ل‬ٝ٘ٚ( 0 ٝ٘ ‫خ‬١‫ّخ االفزشاظ‬١‫اٌم‬ٚ ‫ظغ ٌٍجذت‬ِٛ ‫ؾذد‬٠ ‫ؼ‬١‫ ػذد صؾ‬: start 
. )Required( ‫خ‬٠‫ب‬ٌٕٙ‫ظغ ا‬ِٛ ‫ؾذد‬٠ ‫ؼ‬١‫ ػذد صؾ‬: stop 
. )Optional ‫خ‬٠‫بس‬١‫ّخ اخز‬١‫ ل‬ٝ٘ٚ( 1 ٝ٘ ‫خ‬١‫ّخ االفزشاظ‬١‫اٌم‬ٚ ‫بدح‬٠‫ؾذد ِمذاس اٌض‬٠ ‫ؼ‬١‫ ػذد صؾ‬: step 
import random
x=random.randrange(1,10,1)
print("The random number is : ", x)
output
The random number is : 6
. ‫خ ِخزٍفخ‬١‫ائ‬ٛ‫ذ أسلبَ ػش‬١ٌٛ‫زُ ر‬٠ ‫ وً ِشح‬ٟ‫ الؽع ف‬

ٓ‫ذش ِذ‬١‫ اٌىض‬ٝ‫ٌٍزؼذشف ػٍذ‬ٚ ‫خ‬١‫ائ‬ٛ‫ذ أسلبَ ػش‬١ٌٛ‫ ٌز‬random module ً‫ داخ‬ٜ‫شح آخش‬١‫اي وض‬ٚ‫ ٕ٘بن د‬
. www.w3schools.com/ ‫ ٘زا اٌشاثػ‬ٍٝ‫ي ػ‬ٛ‫ّىٕه اٌذخ‬٠ ‫اي‬ٚ‫٘زٖ اٌذ‬
َ‫ أٔظّخ ا سلب‬: number systems
: َ‫ٕ٘بن أوضش ِٓ ٔظبَ ٌٍزؼبًِ ِغ ا سلب‬
ٞ‫ ٔظبَ ا سلبَ اٌؼشش‬: decimal number system 
. 10 ٜٚ‫ ٘زا إٌظبَ رغب‬ٟ‫ ف‬base ‫ّخ ا عبط‬١‫ل‬ٚ َٛ٠ ً‫ب و‬ٙ‫ ٔزؼبًِ ِؼ‬ٟ‫٘زا ٔظبَ ا سلبَ اٌز‬
ٟ‫ ٔظبَ ا سلبَ اٌضٕبئ‬: binary number system 

. 2 ٜٚ‫ ٘زا إٌظبَ رغب‬ٟ‫ ف‬base ‫ّخ ا عبط‬١‫ل‬ٚ ْٛ‫زؼبًِ ِؼٗ اٌّجشِغ‬٠ ٞ‫٘زا ٔظبَ ا سلبَ اٌز‬
‫ ػشش‬ٟ‫ ٔظبَ اٌغذاع‬: hexadecimal number system 

ٟٔ‫ ٔظبَ ا سلبَ اٌضّب‬: octal number system 

: ٟ‫ر‬٢‫ظغ ثبدئخ لجً ٘زا اٌشلُ وب‬ٚ ‫ً ٘زٖ ا سلبَ ِٓ خالي‬١‫ّىٕٕب رّض‬٠ ْٛ‫ض‬٠‫ ثب‬ٟ‫ ف‬
Number System Prefix
Binary '0b' or '0B'
Octal '0o' or '0O'
Hexadecimal '0x' or '0X'
# Output: 107
print(0b1101011)
# Output: 253 (251 + 2)

print(0xFB + 0b10)
# Output: 13
print(0o15)
output
107
253
13
‫انذرس انزابع ‪ :‬انسالسم (انُصوص)‬
‫) ‪( Strings‬‬
‫‪ ‬عذذززؼٍُ فذذ‪٘ ٟ‬ذذزا اٌجشٔذذبِظ اٌزؼٍ‪ّ١‬ذذ‪ ٟ‬ئٔشذذبت عالعذذً فذذ‪ٚ Python ٟ‬رٕغذذ‪١‬م‪ٙ‬ب ‪ٚ‬رؼذذذ‪ٍٙ٠‬ب ‪ٚ‬ؽذذزف‪ٙ‬ب ‪ٚ‬عذذ‪ٛ‬ف‬
‫رزؼشف ‪ٚ‬أ‪٠‬عب ػٍ‪ ٝ‬ػٍّ‪١‬بد ‪ٚٚ‬ظبئ اٌغٍغٍخ اٌّخزٍفخ‪.‬‬
‫‪ : Strings‬اٌغالعً أ‪ ٚ‬اٌغالعً إٌص‪١‬خ‬

‫٘ذذ‪ ٝ‬ػجذذبسح ػذذٓ عٍغذذٍخ ِذذٓ اٌؾذذش‪ٚ‬ف أ‪ ٚ‬أؽذذشف اٌزشِ‪١‬ذذض ‪ٚ Unicode‬اٌزذذ‪ ٟ‬رُؾذذبق ثؼالِذذبد االلزجذذبط‬
‫اٌّفذشدح ‪ٚ single quotes‬سِض٘ذب ٘ذ‪ ( ' ' ) ٛ‬أ‪ ٚ‬ػالِذبد االلزجذبط اٌّضد‪ٚ‬عذخ ‪double quotes‬‬
‫‪ٚ‬سِض٘ب ٘‪ ( " " ) ٛ‬أ‪ ٚ‬ػالِبد االلزجبط اٌضالص‪١‬خ ‪ triple quotes‬فذ‪ ٟ‬ؽبٌذخ وزبثذخ اٌغٍغذٍخ وضذش ِذٓ‬
‫عطش ‪ٚ‬سِض٘ب ٘‪ ( """ """ ) ٛ‬أ‪. ( ''' ''' ) ٚ‬‬
‫)"‪print("Hello‬‬
‫)'‪print('Hello‬‬
‫)'''‪print('''Hello‬‬
‫)"""‪print("""Hello‬‬
‫‪name = """Hello‬‬
‫""" ‪Mahmoud‬‬
‫)‪print(name‬‬
‫‪output‬‬
‫‪Hello‬‬
‫‪Hello‬‬
‫‪Hello‬‬
‫‪Hello‬‬
‫‪Hello‬‬
‫‪Mahmoud‬‬
‫‪ : Strings are Arrays‬اٌغالعً رزؼبًِ ِبٍِخ اٌّصف‪ٛ‬فبد‬

‫ِضً ٌغبد اٌجشِغخ اٌشبئؼخ ا خش‪ ٜ‬فاْ اٌغالعً ‪ strings‬داخً ٌغخ ‪ Python‬ػجبسح ػٓ ِصف‪ٛ‬فبد‬
‫‪ِ arrays‬ذذٓ اٌجب‪٠‬ذذذ ‪ bytes‬رّضذذً أؽذذشف ‪ِٚ Unicode‬ذذغ رٌذذه ال رؾزذذ‪ٌ ٞٛ‬غذذخ ‪ Python‬ػٍذذ‪ٔ ٝ‬ذذ‪ٛ‬ع‬
‫ث‪١‬بٔذذبد ؽشفذ‪ٌٚ character data type ٟ‬ىٕ‪ٙ‬ذذب رزؼبِذذً ِذذغ اٌؾذذشف اٌفذذشد‪single character ٞ‬‬
‫وغٍغٍخ ‪ِ string‬مذاس غ‪ٌٙٛ‬ب ‪. 1‬‬
‫‪ ‬و‪١‬ف‪١‬خ اٌ‪ٛ‬ص‪ٛ‬ي ئٌ‪ ٝ‬ا ؽشف أ‪ ٚ‬اٌؼٕبصش اٌّ‪ٛ‬ع‪ٛ‬دح داخً عٍغٍخ؟‬

‫‪ّ٠ ‬ىٕٕذذب اٌ‪ٛ‬صذذ‪ٛ‬ي ئٌذذ‪ ٝ‬ا ؽذذشف اٌفشد‪٠‬ذذخ أ‪ِ ٚ‬غّ‪ٛ‬ػذذخ ِذذٓ ا ؽذذشف ثبعذذزخذاَ اٌف‪ٙ‬شعذذخ ‪ٚ index‬ػبِذذً‬
‫اٌزمط‪١‬غ ( ‪٠ ) :‬جذأ اٌف‪ٙ‬شط ِٓ ‪. 0‬‬
‫ِ‪ٛ‬ظغ أ‪ِ ٚ‬ىبْ اٌؾشف فّضالً ]‪ ٛ٘ [4‬ػجبسح ػٓ ل‪ّ١‬خ اٌشلُ ‪ 4‬اٌّ‪ٛ‬ع‪ٛ‬د ف‪ ٟ‬اٌغٍغٍخ ‪.‬‬
‫ش‬١‫شذذ‬٠ ‫ذذش‬١‫ ؽ‬string ‫ داخذذً اٌغٍغذذٍخ‬negative indexing ‫خ‬١‫شعذذخ اٌغذذٍج‬ٙ‫ ثبٌف‬Python ‫ رغذذّؼ ٌغذذخ‬
‫اٌؼٕصذذذذذذذذذذذش‬ ٝ‫ ] ئٌذ‬-1 [ ‫شط‬ٙ‫اٌف‬
-2 [ ‫ش‬١‫ش‬٠ٚ ‫ذذذذش ٌٍغٍغذذذذٍخ‬١‫ا خ‬
‫ذذذذذذذذذذذذذذش‬١‫خ‬٢‫ا‬ ً‫ اٌؼٕصذذش لجذذ‬ٝ‫] ئٌذذ‬
. ‫٘ىزا‬ٚ
‫ ػٕبصذش اٌغٍغذٍخ‬ٝ‫ي ئٌذ‬ٛ‫صذ‬ٌٍٛ ] [ ٛ‫سِض٘ذب ٘ذ‬ٚ Square brackets ‫اط اٌّشثؼذخ‬ٛ‫ذزُ اعذزخذاَ ا لذ‬٠ 
‫ ] العذزخشاط‬: [ ٛ٘ ‫سِض٘ب‬ٚ slicing operator ‫غ‬١‫اط اٌّشثؼخ ِغ ػبًِ اٌزمط‬ٛ‫ّىٓ اعزخذاَ ا ل‬٠ٚ
. string ‫ػخ ِٓ اٌؼٕبصش ِٓ داخً اٌغٍغٍخ‬ّٛ‫ِغ‬
#Accessing string characters in Python
str = 'programiz'
print('str = ', str)
#first character
print('str[0] = ', str[0])
#last character
print('str[-1] = ', str[-1])
#slicing 2nd to 5th character

print('str[1:5] = ', str[1:5])
#Negative Indexing
print('str[-5:-2] = ', str[-5:-2])
#slicing 6th to 2nd last character

print('str[5:-2] = ', str[5:-2])
#slicing From the Start

print('str[:5] = ', str[:5])
#slicing to the End

print('str[2:] = ', str[2:])
output
str = programiz
str[0] = p
str[-1] = z
str[1:5] = rogr
str[-5:-2] = ram
str[5:-2] = am
str[:5] = progr
str[2:] = ogramiz
ّٝ‫غذ‬٠ ‫س خطذأ‬ٚ‫ ؽذذ‬ٝ‫ رٌذه ئٌذ‬ٞ‫إد‬١‫ عذ‬index ‫ذشط‬ٙ‫ ؽشف خذبسط ٔطذبق اٌف‬ٌٝ‫ي ئ‬ٛ‫ص‬ٌٛ‫ٌخ ا‬ٚ‫ ػٕذ ِؾب‬
.‫ ًؾب‬١‫ ػذدًا صؾ‬index ْٛ‫ى‬٠ ْ‫غت أ‬٠ ٌٟ‫ثبٌزب‬ٚ IndexError
my_string = 'programiz'
# index must be in range
my_string[15]
output
File "c:\Users\Hoda_PC\Desktop\example.py", line 4, in <module>
my_string[15]
IndexError: string index out of range
.TypeError ٌٝ‫ رٌه ئ‬ٞ‫إد‬١‫ ع‬ٜ‫اع أخش‬ٛٔ‫ أ‬ٚ‫ أ‬floats َ‫ٌخ اعزخذا‬ٚ‫ ػٕذ ِؾب‬
# index must be in range
my_string[15]
output
my_string[5.4]
TypeError: string indices must be integers
‫ّذخ ػٕبصذش اٌغٍغذٍخ ثؼذذ‬١‫ش ل‬١١‫ّىٓ رغ‬٠ ‫ أٔٗ ال‬ٕٝ‫ ثّؼ‬immutable ‫ش‬١١‫ش لبثً ٌٍزغ‬١‫ غ‬strings ً‫ اٌغالع‬
: ٌٟ‫ ِخزٍفخ ٌٕفظ االعُ الؽع اٌّضبي اٌزب‬string ٓ١١‫ّىٕٕب ئػبدح رؼ‬٠ ‫ٌىٕٕب ثجغبغخ‬ٚ ‫ٓ اٌغٍغٍخ‬١١‫رؼ‬
my_string[5] = 'a'
output
my_string[5] = 'a'
TypeError: 'str' object does not support item assignment
. ً ‫ٕٗ ِغجمب‬١‫خ رغزخذَ ٌؾزف وبئٓ رُ رؼ‬١‫ وٍّخ أعبع‬ٝ٘ : del keyword 
string ‫ ئصاٌخ ا ؽشف ِٓ عٍغٍخ‬ٚ‫ّىٕٕب ؽزف أ‬٠ ‫ ال‬

del my_string[5]
output
del my_string[5]
TypeError: 'str' object doesn't support item deletion
. del ‫خ‬١‫ّىٓ ؽزف اٌغٍغٍخ ثبٌىبًِ ثبعزخذاَ اٌىٍّخ ا عبع‬٠ ٓ‫ ٌى‬
del my_string
print(my_string)
output
print(my_string)
NameError: name 'my_string' is not defined
ْٛ‫ض‬٠‫ اٌغٍغٍخ داخً ٌغخ اٌجب‬ٍٝ‫بد ػ‬١ٍّ‫ ػ‬: Python String Operations
‫اؽذذح‬ٚ ‫ب‬ٍٙ‫غؼ‬٠ ‫ ِّب‬String ً‫ اٌغالع‬ٍٝ‫ّىٓ ئعشاؤ٘ب ػ‬٠ ٟ‫ اٌز‬Operations ‫بد‬١ٍّ‫ذ ِٓ اٌؼ‬٠‫ٕ٘بن اٌؼذ‬
. ٍٟ٠ ‫ّب‬١‫ب ف‬ٙ١ٍ‫ عٕزؼشف ػ‬Python ٟ‫بٔبد اعزخذا ًِب ف‬١‫اع اٌج‬ٛٔ‫ِٓ أوضش أ‬
ً‫خ عّغ اٌغالع‬١ٍّ‫ ػ‬: Strings Concatenation : ً‫ال‬ٚ‫ أ‬

: ْ‫غزخذِب‬٠ ٓ١ٍِ‫ٕ٘بن ِؼب‬ٚ ‫اؽذح‬ٚ ‫ عٍغٍخ‬ٟ‫ أوضش ف‬ٚ‫ٓ أ‬١‫ظُ عٍغٍز‬ٚ ‫ب عّغ‬ٙ١‫زُ ف‬٠ ‫خ‬١ٍّ‫ ػ‬ٝ٘
. ً ‫ٓ ِؼب‬١‫عّغ عٍغٍز‬ٚ ‫ ٌذِظ‬: ) + ( ‫ ِؼبًِ اٌغّغ‬o
. ‫ ٌزىشاس اٌغٍغٍخ ػذد ِٓ اٌّشاد‬: ) * ( ‫ ِؼبًِ اٌعشة‬o
# Python String Operations
str1 = 'Hello'
str2 ='World!'
# using +
print('str1 + str2 = ', str1 + str2)
# using *
print('str1 * 3 =', str1 * 3)
output
str1 + str2 = HelloWorld!
str1 * 3 = HelloHelloHello
: ) ( ‫اط‬ٛ‫ّىٕٕب اعزخذاَ ا ل‬١‫س ِخزٍفخ ف‬ٛ‫ عط‬ٟ‫ ئرا أسدٔب سثػ اٌغالعً ف‬
# two string literals together
str1= 'Hello ''World!1'
print(str1)
# using parentheses
str2 = ('Hello '
'World!2')
print(str2)
output
Hello World!1
Hello World!2
ً‫خ رىشاس اٌغالع‬١ٍّ‫ ػ‬: Strings Iterating : ً ‫ب‬١ٔ‫ صب‬
ً‫س ػجذذش ا ؽذذشف داخذذ‬ٚ‫ّىٕٕذذب اٌّذذش‬١‫ ف‬arrays ‫فبد‬ٛ‫ ػجذذبسح ػذذٓ ِصذذف‬Strings ً‫ٔظذ ًذشا ْ اٌغالعذذ‬
. for ‫ ِضً ؽٍمخ‬Looping ‫خ‬٠‫اٌغٍغٍخ ثبعزخذاَ اٌؾٍمخ اٌزىشاس‬
# Iterating through a string
count = 0
for letter in 'Hello World':
if(letter == 'l'):
count += 1
print(count,'letters found')
output
3 letters found
strings ً‫ داخً اٌغالع‬looping ٍٟ‫ ِضبي آخش ػ‬

for x in "banana":
print(x)
output
b
a
n
a
n
a
ً‫ داخً اٌغالع‬ٛ‫خ اخزجبس ػع‬١ٍّ‫ ػ‬: Strings Membership Test : ً ‫ صبٌضب‬

‫دح‬ٛ‫عذ‬ِٛ ‫ذخ‬١‫خ داخذً اٌغٍغذٍخ ٌؼّذً اخزجذبس ِذب ئرا وبٔذذ اٌغٍغذٍخ اٌفشػ‬٠ٛ‫ّىٓ اعزخذاَ ِؼذبِالد اٌؼعذ‬٠
: ‫ٓ الخزجبس ػٕصش داخً عٍغٍخ ّ٘ب‬١‫ٕ٘بن وٍّز‬ٚ ‫ أَ ال ؟‬string ‫داخً عٍغٍخ‬
.‫ اٌغٍغٍخ‬ٟ‫ٓ ف‬١‫ ؽشف ِؼ‬ٚ‫د ػجبسح أ‬ٛ‫ع‬ٚ ِٓ ‫خ رغزخذَ ٌٍزؾمك‬١‫ وٍّخ أعبع‬ٝ٘ : in keyword 
.‫ اٌغٍغٍخ‬ٟ‫ٓ ف‬١‫د ؽشف ِؼ‬ٛ‫ع‬ٚ َ‫خ رغزخذَ ٌٍزؾمك ِٓ ػذ‬١‫ وٍّخ أعبع‬ٝ٘ : not in keyword 
txt1 = "The best things in life are free!"
print("free" in txt1)
print("Mahmoud" not in txt1)
output
True
True
‫خ‬٠ٛ‫ ِغ ِؼبِالد اٌؼع‬if ‫ّىٓ اعزخذاَ عٍّخ‬٠ 
if "Mahmoud" not in txt1:
print("Mahmoud is not Found.")

if "free" in txt2:
print("Yes, 'free' is present.")
output
Mahmoud is not Found.
Yes, 'free' is present.
ْٛ‫ض‬٠‫اي ٌٍزؼبًِ ِغ اٌغٍغٍخ داخً ٌغخ اٌجب‬ٚ‫ اٌذ‬: Python String Functions
: ‫ب‬ِٕٙ String ً‫ اٌغالع‬ٍٝ‫ّىٓ ئعشاؤ٘ب ػ‬٠ ٟ‫ اٌز‬Functions ‫اي‬ٚ‫ذ ِٓ اٌذ‬٠‫ٕ٘بن اٌؼذ‬
. )ٓ‫ ثزشعغ ػذد أؽشف اٌغٍغٍخ (اٌىبئ‬ٞ‫ي اٌغٍغٍخ أ‬ٛ‫ي ؛ ٌّؼشفخ غ‬ٛ‫ داٌخ اٌط‬: Len() function 
a = "Hello, World!"
print("Length of string is : ",len(a))
output
Length of string is : 13
‫ذذغ‬١ّ‫ّذذخ ع‬١‫ل‬ٚ index ‫ذذشط‬ٙ‫ ف‬ٝ‫ ػٍذذ‬ٞٛ‫ؾزذذ‬٠ ‫ داٌذذخ اٌؼذذذد؛ إلسع ذبع رؼذذذاد‬: enumerate() function 
. iteration ‫ذًا ٌٍزىشاس‬١‫ْ ٘زا ِف‬ٛ‫ى‬٠ ْ‫ّىٓ أ‬٠ٚ . pairs ‫اط‬ٚ‫ اٌغٍغٍخ وأص‬ٟ‫اٌؼٕبصش ف‬
str = 'cold'
# enumerate()
list_enumerate = list(enumerate(str))
print('list(enumerate(str) = ', list_enumerate)
output
list(enumerate(str) = [(0, 'c'), (1, 'o'), (2, 'l'), (3, 'd')]
len(str) = 4
. upper case ‫شح‬١‫ف وج‬ٚ‫ ؛ ٌغؼً اٌغٍغٍخ ؽش‬ٍٞٛ‫ داٌخ اٌؼ‬: upper() function 
. lower case ‫شح‬١‫ف صغ‬ٚ‫ ؛ ٌغؼً اٌغٍغٍخ ؽش‬ٍٟ‫ داٌخ اٌغف‬: lower() function 
.upper case ‫شح‬١‫ف وج‬ٚ‫ اٌغٍغٍخ ؽش‬ٟ‫ي ؽشف ِٓ وٍّخ ف‬ٚ‫ داٌخ اٌّمبي؛ ٌغؼً أ‬: title() function 
a = "my name is mahmoud soliman"
print(a.upper())
print(a.lower())
print(a.title())
output
MY NAME IS MAHMOUD SOLIMAN
my name is mahmoud soliman
My Name Is Mahmoud Soliman
‫خ‬٠‫ ثذا‬ٟ‫دح ف‬ٛ‫ع‬ٌّٛ‫ ا‬Whitespace ‫عبت‬١‫ئصاٌخ اٌّغبفخ اٌج‬ٚ ‫ذ ؛ ٌؾزف‬٠‫ داٌخ اٌزغش‬: strip() function 
. ‫ب‬ٙ‫ز‬٠‫ب‬ٙٔ ٟ‫ ف‬ٚ‫اٌغٍغٍخ أ‬
a = " Hello, World! "
print(a.strip()) # returns "Hello, World!"
output
Hello, World!
. ٖ‫ ثؼذ‬ٚ‫ أ‬ٍٟ‫دح لجً إٌص اٌفؼ‬ٛ‫ع‬ٌّٛ‫ اٌّغبفخ ا‬ٟ٘ ‫عبت‬١‫ اٌّغبفخ اٌج‬: Whitespace 
Whitespace ‫عذذبت‬١‫ذذً اٌّغذذبفخ اٌج‬٠‫رض‬ٚ ‫ داٌذذخ ثزؾذذزف‬ٝ‫ داٌذذخ االعذذزجذاي ؛ ٘ذذ‬: replace() function 
. ‫ب‬ٙ‫ز‬٠‫ب‬ٙٔ ٟ‫ ف‬ٚ‫خ اٌغٍغٍخ أ‬٠‫ ثذا‬ٟ‫دح ف‬ٛ‫ع‬ٌّٛ‫ا‬
a = "Hello, World!"
print(a.replace("H", "J"))
output
Jello, World!
‫ّخ اٌ ُّشاد‬١‫ ( اٌم‬old value ‫ّخ‬٠‫ّخ اٌمذ‬١‫ اٌم‬ٝ٘ٚ ‫ي‬ٚ ‫ٓ اٌّؼبًِ ا‬١ٍِ‫ب ِؼب‬ٌٙ‫ ثّٕشس خال‬replace ‫ داٌخ‬
. ) ‫ب‬ٌٙ‫زُ اعزجذا‬١‫ ع‬ٟ‫ّخ اٌز‬١‫ ( اٌم‬new value ‫ذح‬٠‫ّخ اٌغذ‬١‫ اٌم‬ٝ٘ٚ ٟٔ‫اٌّؼبًِ اٌضب‬ٚ ) ‫ب‬ٌٙ‫اعزجذا‬
‫ االٔشطبس‬ٚ‫ داٌخ االٔمغبَ أ‬: split() function 

. separator ً‫ً ٌٍفبص‬١‫ ِض‬ٍٝ‫خ ئرا ػضشد ػ‬١‫ عالعً فشػ‬ٌٝ‫خ ئ‬١‫ داٌخ رمغُ اٌغٍغٍخ ا عبع‬ٝ٘
a = "Hello, World!"
print(a.split(",")) # returns ['Hello', ' World!']
output
['Hello', ' World!']
. ) - ( ٚ‫ ) أ‬, ( ٚ‫ ) أ‬. ( ْٛ‫ى‬٠ ‫فّضالً لذ‬ ٛ‫ٓ إٌص‬١‫فصً ث‬٠ ‫ شئ‬ٞ‫ْ أ‬ٛ‫ى‬٠ ‫ اٌفبصً لذ‬: separator 
ْٛ‫ض‬٠‫ك اٌغٍغٍخ داخً ٌغخ اٌجب‬١‫ رٕغ‬:Python String Formatting
: ٟ‫ر‬٢‫ ا‬ٍٝ‫عٕزؼشف ػ‬ٚ ْٛ‫ض‬٠‫ اٌّخزٍفخ داخً ٌغخ اٌجب‬Formatting ‫ك‬١‫ذ ِٓ أشىبي اٌزٕغ‬٠‫ٕ٘بن اٌؼذ‬
. format() function ‫ك‬١‫ داٌخ اٌزٕغ‬: ً‫ال‬ٚ‫ أ‬
. Escape Sequence ‫ة‬ٚ‫ش‬ٌٙ‫ رغٍغً ا‬ٚ‫ف أ‬ٚ‫ ؽش‬: ً ‫ب‬١ٔ‫ صب‬
. Raw String sequence َ‫ عٍغٍخ اٌخب‬ٚ‫ ؽشف اٌخبَ أ‬: ً ‫ صبٌضب‬
. Old style formatting ُ٠‫ك إٌّػ اٌمذ‬١‫ رٕغ‬: ً ‫ ساثؼب‬
. ً‫ اٌغالع‬ٟ‫ك ؛ إلدساط ا سلبَ ف‬١‫ داٌخ اٌزٕغ‬: format() function : ً‫ال‬ٚ‫ أ‬
age = 36
txt = "My name is John, and I am {}"
print(txt.format(age))
output
My name is John, and I am 36
ْٛ‫ش رى‬١‫ اٌغٍغٍخ ؽ‬ٟ‫ب ف‬ٙ‫رعؼ‬ٚ ‫ب‬ٙ‫م‬١‫رٕغ‬ٚ ‫ش٘ب‬٠‫ رُ رّش‬ٟ‫ُ اٌّؼبِالد اٌز‬١‫ ل‬format() ‫ رأخز اٌذاٌخ‬
. } { ‫ اٌشِض‬ٝ٘ placeholders ‫اٌؼٕبصش إٌبئجخ‬
‫ب‬ٌٙ‫زُ اعزجذا‬٠ ‫ٍخ‬٠‫ي ثذ‬ٛ‫ ؽم‬ٚ‫فخ {} وؼٕبصش ٔبئجخ أ‬ٛ‫اط ِؼم‬ٛ‫ أل‬ٍٝ‫ك ػ‬١‫ عالعً اٌزٕغ‬ٞٛ‫ رؾز‬
: ‫ اٌؼٕبصش إٌبئجخ‬ٟ‫ب ف‬ٙ‫ظؼ‬ٚ ُ‫ز‬٠ٚ ‫د ِٓ اٌّؼبِالد‬ٚ‫ش ِؾذ‬١‫ ػذدًا غ‬format() ‫ رأخز اٌذاٌخ‬
quantity = 3
itemno = 567
price = 49.95
myorder = "I want {} pieces of item {} for {} dollars."
print(myorder.format(quantity, itemno, price))
output
I want 3 pieces of item 567 for 49.95 dollars.
: ‫ؾخ‬١‫ اٌؼٕبصش إٌبئجخ اٌصؾ‬ٟ‫ظغ اٌّؼبِالد ف‬ٚ ِٓ ‫} ٌٍزأوذ‬0{ ‫شط‬ٙ‫ّىٕه اعزخذاَ أسلبَ اٌف‬٠ 
quantity = 3
itemno = 567
price = 49.95
myorder = "I want to pay {2} dollars for {0} pieces of item {1}."
print(myorder.format(quantity, itemno, price))
output
I want to pay 49.95 dollars for 3 pieces of item 567.
. Escape Sequence ‫ة‬ٚ‫ش‬ٌٙ‫ رغٍغً ا‬ٚ‫ف أ‬ٚ‫ ؽش‬: ً ‫ب‬١ٔ‫ صب‬
. ‫ عٍغٍخ‬ٟ‫خ ف‬١ٔٛٔ‫ش لب‬١‫ف رغزخذَ إلدساط أؽشف غ‬ٚ‫ ؽش‬ٝ٘
) ' ' ) ‫ّىٕٕب اعزخذاَ ػالِذبد االلزجذبط اٌّفذشدح‬٠ ‫ " فال‬What's there ‫ ئرا أسدٔب غجبػخ ٔص ِضً " ؟‬
ٗ‫ذش أْ اٌذٕص ٔفغذ‬١‫ ثٕذبت اٌغٍّذخ ؽ‬ٟ‫ٕزظ خطذأ فذ‬١‫عذخ ) " " ( ْ ٘ذزا عذ‬ٚ‫ ػالِذبد االلزجذبط اٌّضد‬ٚ‫أ‬
. ‫عخ‬ٚ‫ِضد‬ٚ ‫ ػالِبد الزجبط ِفشدح‬ٍٝ‫ ػ‬ٞٛ‫ؾز‬٠
print("He said, "What's there?"")
output
C:\Users\Hoda_PC>python c:/Users/Hoda_PC/Desktop/example.py
File "c:\Users\Hoda_PC\Desktop\example.py", line 1
print("He said, "What's there?"")
^
SyntaxError: invalid syntax
ِٓ ً‫ ثذال‬ٚ‫ ) ''' ''' ( أ‬ٚ‫خ ) """ """ ( أ‬١‫ّىٓ اعزخذاَ ػالِبد االلزجبط اٌضالص‬٠ ‫ ٘زٖ اٌّشىٍخ‬ٍٝ‫ ٌٍزغٍت ػ‬
. Escape Sequence ‫ة‬ٚ‫ش‬ٌٙ‫ّىٕٕب اعزخذاَ رغٍغالد ا‬٠ ‫رٌه‬
( \ ) ٛ‫سِض٘ذب ٘ذ‬ٚ backslash ‫ ثشذشغخ ِبئٍذخ ٌٍخٍذ‬Escape Sequence ‫ة‬ٚ‫ذش‬ٌٙ‫جذذأ رغٍغذً ا‬٠ 
‫خ‬١‫ذً عٍغذٍخ ٔصذ‬١‫اؽذذح ٌزّض‬ٚ ‫ فّذضالً ئرا اعذزخذِٕب ػالِذخ الزجذبط‬. ٗ‫ذذ ئدساعذ‬٠‫ رش‬ٞ‫ػخ ثبٌؾشف اٌز‬ٛ‫ِزج‬
‫ اٌؾذبي ِذغ ػالِذبد االلزجذبط‬ٛ‫وّذب ٘ذ‬ٚ ‫غ ػالِبد االلزجبط اٌّفذشدح داخذً اٌغٍغذٍخ‬١ّ‫ ع‬ٟ‫غت رخط‬١‫ف‬
. ‫ً إٌص اٌغبثك‬١‫بَ ثزٌه ٌزّض‬١‫خ اٌم‬١‫ف‬١‫عخ الؽع و‬ٚ‫اٌّضد‬
print('''He said, "What's there?"''') # using triple quotes
print('He said, "What\'s there?"') # escaping single quotes
print("He said, \"What's there?\"") # escaping double quotes
output
He said, "What's there?"
Python ‫ب ٌغخ‬ّٙ‫ رذػ‬ٟ‫ اٌز‬Escape Sequence ‫ة‬ٚ‫ش‬ٌٙ‫غ رغٍغالد ا‬١ّ‫ لبئّخ ثغ‬ٍٟ٠ ‫ّب‬١‫ ف‬
Escape Sequence Description

\\ Backslash
\' Single quote
\" Double quote
\a ASCII Bell
\b ASCII Backspace
\f ASCII Formfeed
\n ASCII Linefeed - newline
\r ASCII Carriage Return
\t ASCII Horizontal Tab
\v ASCII Vertical Tab
\ooo Character with octal value ooo
\xHH Character with hexadecimal value HH
print("C:\\Python32\\Lib")
print('It\'s alright.')
print("He said, \"What's there?\"")
print("Hello\nWorld!")
print("Hello\fWorld!")
print("Hello\rWorld!")
print("Hello\tWorld!")
print("Hello \bWorld!")
print("\110\145\154\154\157")
print("\x48\x65\x6c\x6c\x6f")
output
It's alright.
Hello
World!
Hello♀World!
World!
Hello World!
HelloWorld!
Hello
Hello?"
. Raw String sequence َ‫ عٍغٍخ اٌخب‬ٚ‫ ؽشف اٌخبَ أ‬: ً ‫ صبٌضب‬
. Escape Sequence ‫ة‬ٚ‫ش‬ٌٙ‫ف ا‬ٚ‫ف رغزخذَ ٌزغبً٘ ؽش‬ٚ‫ ؽش‬ٝ٘
َ‫ذب‬١‫ ٌٍم‬.‫ داخذً عٍغذٍخ‬Escape Sequence ‫ة‬ٚ‫ش‬ٌٙ‫ رغبً٘ رغٍغالد ا‬ٟ‫بْ لذ ٔشغت ف‬١‫ ثؼط ا ؽ‬ٟ‫ ف‬
ٞ‫زُ رغب٘ذً أ‬١‫عذ‬ٚ raw string َ‫ أٔذٗ عٍغذٍخ خذب‬ٟ‫ؼٕذ‬٠ ‫ ٘ذزا‬.‫ أِذبَ اٌغٍغذٍخ‬R ٚ‫ أ‬r ‫ظذغ‬ٚ ‫ّىٕٕذب‬٠ ‫ثذزٌه‬
.ٍٗ‫ة ثذاخ‬ٚ‫رغٍغً ٘ش‬
print("This is \x61 \ngood example")
print("\n")
print(r"This is \x61 \ngood example")
output
This is a
good example
This is \x61 \ngood example
. Old style formatting ُ٠‫ك إٌّػ اٌمذ‬١‫ رٕغ‬: ً ‫ ساثؼب‬

‫ذزا‬ٙ‫ذبَ ث‬١‫ ٌٍم‬% ً‫غذزخذَ ػبِذ‬٠ ‫ش‬١‫ ؽ‬C ‫ ٌغخ‬ٟ‫ اٌّغزخذَ ف‬sprintf() ‫ك اٌذاٌخ‬١‫شجٗ رٕغ‬٠ ُ٠‫ك لذ‬١‫ رٕغ‬ٛ٘
. ‫ك‬١‫ع ِٓ اٌزٕغ‬ٌٕٛ‫ا‬
َ‫ذب‬١‫ ٌٍم‬.‫ داخذً عٍغذٍخ‬Escape Sequence ‫ة‬ٚ‫ش‬ٌٙ‫ رغبً٘ رغٍغالد ا‬ٟ‫بْ لذ ٔشغت ف‬١‫ ثؼط ا ؽ‬ٟ‫ ف‬
ٞ‫زُ رغب٘ذً أ‬١‫عذ‬ٚ raw string َ‫ أٔذٗ عٍغذٍخ خذب‬ٟ‫ؼٕذ‬٠ ‫ ٘ذزا‬.‫ أِذبَ اٌغٍغذٍخ‬R ٚ‫ أ‬r ‫ظذغ‬ٚ ‫ّىٕٕذب‬٠ ‫ثذزٌه‬
.ٍٗ‫ة ثذاخ‬ٚ‫رغٍغً ٘ش‬
x = 12.3456789
print('The value of x is %3.2f' %x)
output
The value of x is 12.35
‫انذرس انخايس ‪ :‬انقوائى (انًصفوفات ‪)Arrays‬‬
‫) ‪( Lists‬‬
‫‪ ‬عززؼٍُ فذ‪٘ ٟ‬ذزا اٌجشٔذبِظ اٌزؼٍ‪ّ١‬ذ‪ ٟ‬ئٔشذبت اٌمذ‪ٛ‬ائُ فذ‪ٚ Python ٟ‬رمغذ‪ ُ١‬اٌمبئّذخ ‪ٚ‬ئظذبفخ اٌؼٕبصذش أ‪ٚ‬‬
‫ئصاٌز‪ٙ‬ب ِٕ‪ٙ‬ب ‪ِٚ‬ب ئٌ‪ ٝ‬رٌه ‪.‬‬
‫‪ : lists‬اٌم‪ٛ‬ائُ أ‪ ٚ‬اٌّصف‪ٛ‬فبد ‪( Arrays‬وّب ف‪ٌ ٟ‬غبد اٌجشِغخ ا‪٢‬خش‪)ٜ‬‬

‫٘‪ ٝ‬ػجبسح ػٓ عٍغٍخ ِشرجخ ِٓ اٌؼٕبصش ؽ‪١‬ش رُغزخذَ ٌزخض‪ ٓ٠‬ػٕبصش ِزؼذدح ف‪ِ ٟ‬زغ‪١‬ش ‪ٚ‬اؽذ‪.‬‬
‫رمذَ ‪ِ Python‬غّ‪ٛ‬ػخ ِٓ أٔ‪ٛ‬اع اٌج‪١‬بٔذبد اٌّشوجذخ اٌزذ‪٠ ٟ‬شذبس ئٌ‪ٙ١‬ذب غبٌجًذب ثبٌزغٍغذالد ‪. sequences‬‬
‫ػب عذًا اٌّغزخذِخ ف‪ٚ .Python ٟ‬رزّ‪١‬ذض‬ ‫‪ٚ‬اٌمبئّخ ‪ٚ ٟ٘ list‬اؽذح ِٓ أوضش أٔ‪ٛ‬اع اٌج‪١‬بٔبد اعزخذا ًِب ‪ٚ‬رٕ‪ً ٛ‬‬
‫اٌم‪ٛ‬ائُ ثأٔ‪ٙ‬ب ِشٔخ ٌٍغب‪٠‬خ وّب ال ‪ٍ٠‬ضَ أْ رى‪ ْٛ‬وبفخ اٌؼٕبصش اٌّ‪ٛ‬ع‪ٛ‬دح ف‪ ٟ‬اٌمبئّخ ِٓ ٔفظ إٌ‪ٛ‬ع ‪.‬‬
‫اٌم‪ٛ‬ائُ ‪ٚ ٟ٘ lists‬اؽذح ِٓ ‪ 4‬أٔ‪ٛ‬اع ث‪١‬بٔبد ِعّٕخ ف‪ٚ Python ٟ‬اٌز‪ ٟ‬رُغذزخذَ ٌزخذض‪ِ ٓ٠‬غّ‪ٛ‬ػذخ ِذٓ‬
‫اٌج‪١‬بٔبد ‪ٚ‬اٌضالصخ ا خذش‪٘ ٜ‬ذ‪ٚ Dictionary ٚ Set ٚ Tuple ٟ‬وٍ‪ٙ‬ذب راد خصذبئص ‪ٚ‬اعذزخذاِبد‬
‫ِخزٍفخ ‪٠ٚ‬شبس ئٌ‪٘ ٝ‬زٖ ا ٔ‪ٛ‬اع ا سثؼخ ثبعُ اٌزغٍغالد ‪. sequences‬‬
‫‪ّ٠‬ىٓ أْ رؾز‪ ٞٛ‬ػٍ‪ ٝ‬أ‪ ٞ‬ػذد ِٓ اٌؼٕبصش ‪ٚ‬لذ رى‪ ِٓ ْٛ‬أٔذ‪ٛ‬اع ِخزٍفذخ (‪ integer‬أ‪ floatٚ‬أ‪string ٚ‬‬
‫عذب ػٍذ‪ ٝ‬لبئّذخ ‪ list‬أخذش‪ ٜ‬وؼٕصذش ‪ٚ‬رغذّ‪ٝ‬‬‫أ‪ ٚ‬أ‪ٛٔ ٞ‬ع آخش ) وّب ‪ّ٠‬ىذٓ أْ رؾزذ‪ ٞٛ‬اٌمبئّذخ ‪ list‬أ‪ً ٠‬‬
‫لبئّخ ِزذاخٍخ ‪. nested list‬‬
‫ٌإلػذذالْ ػذذٓ لبئّذذخ ‪ list‬أِذذش عذذ‪ِٚ ًٙ‬جبشذذش ‪٠‬ذذزُ رٌذذه ػذذٓ غش‪٠‬ذذك ‪ٚ‬ظذذغ اٌؼٕبصذذش داخذذً ألذذ‪ٛ‬اط [ ]‬
‫‪# empty list‬‬
‫][ = ‪my_list‬‬
‫)‪print(my_list‬‬
‫‪# list of integers‬‬

‫]‪my_list = [1, 2, 3‬‬
‫‪# list with mixed data types‬‬

‫]‪my_list = [1, "Hello", 3.4‬‬
‫‪# nested list‬‬

‫]]'‪my_list = ["mouse", [8, 4, 6], ['a‬‬
‫‪output‬‬
‫][‬
‫]‪[1, 2, 3‬‬
‫]‪[1, 'Hello', 3.4‬‬
‫]]'‪['mouse', [8, 4, 6], ['a‬‬
‫‪ٚ : List Items‬ؽذاد اٌمبئّخ أ‪ ٚ‬ػٕبصش اٌمبئّخ‬
‫ػٕبصش اٌمبئّخ ٌ‪ٙ‬ب صالس خصبئص ‪:‬‬
‫‪ o‬ػٕبصش ِف‪ٙ‬شعخ ‪indexing‬‬
‫‪٘ٚ‬زا ‪٠‬ؼٕ‪ ٟ‬أْ اٌؼٕصش ا ‪ٚ‬ي ثٗ ف‪ٙ‬شط [‪ ]0‬اٌؼٕصش اٌضبٔ‪ ٟ‬ثٗ ف‪ٙ‬شط [‪٘ٚ ]1‬ىزا ‪.‬‬
‫‪ o‬ػٕبصش ِشرجخ ‪ordered‬‬

‫‪٘ٚ‬زا ‪٠‬ؼٕ‪ ٟ‬أْ اٌؼٕبصش ٌ‪ٙ‬ب رشر‪١‬ت ِؾذد ‪ٌٚ‬ذٓ ‪٠‬زغ‪١‬ذش ٘ذزا اٌزشر‪١‬ذت‪ٚ .‬ئرا لّذذ ثاظذبفخ ػٕبصذش‬
‫عذ‪٠‬ذح ئٌ‪ ٝ‬اٌمبئّخ فغ‪١‬زُ ‪ٚ‬ظغ اٌؼٕبصش اٌغذ‪٠‬ذح ف‪ٙٔ ٟ‬ب‪٠‬خ اٌمبئّخ‪.‬‬
‫‪ِ ‬الؽظخ ‪ٕ٘ :‬بن ثؼط د‪ٚ‬اي ٌٍمبئّخ عزغ‪١‬ش اٌزشر‪١‬ت ‪ٌٚ‬ىٓ ثشىً ػبَ ٌٓ ‪٠‬زغ‪١‬ش رشر‪١‬ت اٌؼٕبصش‪.‬‬
‫‪ o‬ػٕبصش لبثٍخ ٌٍزغ‪١١‬ش ‪changeable‬‬

‫‪٘ٚ‬زا ‪٠‬ؼٕ‪ ٟ‬أٔٗ ‪ّ٠‬ىٓ رغ‪١١‬ش ‪ٚ‬ئظبفخ ‪ٚ‬ئصاٌخ اٌؼٕبصش ف‪ ٟ‬اٌمبئّخ ثؼذ ئٔشبئ‪ٙ‬ب ‪.‬‬
‫‪ o‬ػٕبصش رغّؼ ثم‪ِ ُ١‬ىشسح ‪duplicate values‬‬

‫‪٘ٚ‬زا ‪٠‬ؼٕ‪ ٟ‬أٔٗ ‪ّ٠‬ىٓ أْ رؾز‪ ٞٛ‬اٌم‪ٛ‬ائُ ػٍ‪ ٝ‬ػٕبصش ثٕفظ اٌم‪ّ١‬خ ٔ‪ٙ‬ب ػٕبصش ِف‪ٙ‬شعخ ‪.‬‬
‫‪ ‬و‪١‬ف‪١‬خ اٌ‪ٛ‬ص‪ٛ‬ي ئٌ‪ ٝ‬ا ؽشف أ‪ ٚ‬اٌؼٕبصش اٌّ‪ٛ‬ع‪ٛ‬دح داخً عٍغٍخ؟‬

‫‪ ‬رغّؼ ٌغخ ‪ Python‬ثبٌف‪ٙ‬شعخ اٌغٍج‪١‬خ ‪ negative indexing‬داخً اٌمبئّخ ‪ list‬ؽ‪١‬ذش ‪٠‬شذ‪١‬ش اٌف‪ٙ‬ذشط‬
‫[ ‪ ] -1‬ئٌ‪ ٝ‬اٌؼٕصش ا خ‪١‬ش ٌٍغٍغٍخ ‪٠ٚ‬ش‪١‬ش [ ‪ ] -2‬ئٌ‪ ٝ‬اٌؼٕصش لجً ا‪٢‬خ‪١‬ش ‪٘ٚ‬ىزا ‪.‬‬
‫‪٠ ‬ذزُ اعذزخذاَ ا لذ‪ٛ‬اط اٌّشثؼذخ ‪ٚ Square brackets‬سِض٘ذب ٘ذ‪ٌٍٛ ] [ ٛ‬صذ‪ٛ‬ي ئٌذ‪ ٝ‬ػٕبصذش اٌمبئّذخ‬
‫‪ّ٠ٚ‬ىٓ اعزخذاَ ا ل‪ٛ‬اط اٌّشثؼخ ِغ ػبًِ اٌزمط‪١‬غ ‪ٚ slicing operator‬سِض٘ب ٘‪ ] : [ ٛ‬العذزخشاط‬
‫ِغّ‪ٛ‬ػخ ِٓ اٌؼٕبصش ِٓ داخً اٌمبئّخ ‪. list‬‬
# List indexing
my_list = ['p', 'r', 'o', 'b', 'e']
# Output: p
print("my_list[0] is : " , my_list[0])
# Output: o
# Output: e
# Output: b
print("my_list[-2] is : " , my_list[-2])
# Nested List
n_list = ["Happy", [2, 0, 1, 5]]
# Nested indexing
print("n_list[0][1] is : " , n_list[0][1])
print("n_list[1][3] is : ",n_list[1][3])
# List slicing in Python
my_list = ['p','r','o','g','r','a','m','i','z']
# elements 3rd to 5th

print(my_list[2:5])
# elements beginning to 4th

print(my_list[:-5])
# elements 6th to end

print(my_list[5:])
# elements beginning to end

print(my_list[:])
output
my_list[0] is : p
my_list[2] is : o
my_list[4] is : e
my_list[-2] is : b
n_list[0][1] is : a
n_list[1][3] is : 5
['o', 'g', 'r']
['p', 'r', 'o', 'g']
['a', 'm', 'i', 'z']
['p', 'r', 'o', 'g', 'r', 'a', 'm', 'i', 'z']
my_list = ['p', 'r', 'o', 'b', 'e']

# Error! Only integer can be used for indexing
print(my_list[7])
output
print(my_list[7])
IndexError: list index out of range
my_list = ['p', 'r', 'o', 'b', 'e']

# Error! Only integer can be used for indexing
print(my_list[4.0])
output
print(my_list[4.0])
TypeError: list indices must be integers or slices, not float
‫ً ػٕبصش اٌمبئّخ‬٠‫ رؼذ‬: Modify list Items

‫ػذخ‬ّٛ‫ اٌّغ‬ٚ‫ أ‬string ‫ ػىذظ اٌغٍغذٍخ‬ٝ‫ذش ػٕبصذش٘ب ػٍذ‬١١‫ّىذٓ رغ‬٠ ٗ‫ أٔذ‬ٟٕ‫ؼ‬٠ ‫ش ِّب‬١١‫ائُ لبثٍخ ٌٍزغ‬ٛ‫اٌم‬
.) = ( ‫ص‬١‫ػخ ِٓ اٌؼٕبصش ٔغزخذَ ػبًِ اٌزخص‬ّٛ‫ ِغ‬ٚ‫ش ػٕصش أ‬١١‫ٌزغ‬ٚ tuple
# Correcting mistake values in a list
odd = [2, 4, 6, 8]
# change the 1st item

odd[0] = 1
print(odd)
# change 2nd to 4th items

odd[1:4] = [3, 5, 7]
print(odd)
output
[1, 4, 6, 8]
[1, 3, 5, 7]
‫ ئظبفخ ػٕبصش اٌمبئّخ‬: add list Items
. ‫ػخ ِٓ اٌؼٕبصش ٌٍمبئّخ‬ّٛ‫ ِغ‬ٚ‫اي رغزخذَ إلظبفخ ػٕصش أ‬ٚ‫ د‬3 ‫ٕ٘بن‬
. ‫خ اٌمبئّخ‬٠‫ب‬ٙٔ ٌٝ‫ داٌخ اإلٌؾبق ؛ إلظبفخ ػٕصش ئ‬: append () function 
. ‫شط ِؾذد‬ٙ‫ ف‬ٟ‫ داٌخ اإلدخبي ؛ إلدساط ػٕصش لبئّخ ف‬: insert() function 
. ‫خ‬١ٌ‫ اٌمبئّخ اٌؾب‬ٌٝ‫ ئ‬ٜ‫ داٌخ اإلِذاد ؛ إلٌؾبق ػٕبصش ِٓ لبئّخ أخش‬: extend() function 
‫ وذذبئٓ لبثذذً ٌٍزىذذشاس‬ٞ‫ّىٕذذه ئظذذبفخ أ‬٠ ٓ‫ٌىذذ‬ٚ ‫ائُ فمذذػ‬ٛ‫ ثذذبٌم‬extend)( ‫ أْ رٍؾذذك‬ٞ‫س‬ٚ‫ظ ِذذٓ اٌعذذش‬١‫ ٌذذ‬
.) dictionaries sets tuples(
thislist = ["apple", "banana", "cherry"]
thislist.append("orange")
print(thislist)

thislist.insert(1, "orange")
print(thislist)

tropical = ["mango", "pineapple", "papaya"]
thislist.extend(tropical)
print(thislist)

thistuple = ("kiwi", "orange")
thislist.extend(thistuple)
print(thislist)
output
['apple', 'banana', 'cherry', 'orange']
['apple', 'orange', 'banana', 'cherry']
['apple', 'banana', 'cherry', 'mango', 'pineapple', 'papaya']
['apple', 'banana', 'cherry', 'kiwi', 'orange']
‫ ئصاٌخ ػٕبصش اٌمبئّخ‬: remove list Items

. ‫ػخ ِٓ اٌؼٕبصش ِٓ اٌمبئّخ‬ّٛ‫ ِغ‬ٚ‫ئصاٌخ ػٕصش أ‬ٚ ‫اي رغزخذَ ٌؾزف‬ٚ‫ د‬3 ‫ٕ٘بن‬
.‫ داٌخ اإلصاٌخ ؛ إلصاٌخ اٌؼٕصش اٌّؾذد‬: remove() function 
.‫شط اٌّؾذد‬ٙ‫ داٌخ اإلصاٌخ ؛ إلصاٌخ اٌف‬: pop() function 
. ‫ داٌخ اٌّغؼ ؛ ٌّغؼ ػٕبصش اٌمبئّخ‬: clear() function 
.‫ش‬١‫ً اٌؼٕصش ا خ‬٠‫ب عزض‬ٙٔ‫ فا‬pop() ‫ ٌٍذاٌخ‬index ‫شط‬ٙ‫ ئرا ٌُ رؾذد اٌف‬
.ٜٛ‫ ِؾز‬ٍٝ‫ ػ‬ٞٛ‫ب ال رؾز‬ٕٙ‫دح ٌى‬ٛ‫ع‬ِٛ ‫ رظً اٌمبئّخ‬ٌٟ‫ثبٌزب‬ٚ ‫غ اٌمبئّخ‬٠‫َ ثزفش‬ٛ‫ رم‬clear() ‫ اٌذاٌخ‬
.ًِ‫ الصاٌخ اٌمبئّخ ثبٌىب‬ٚ‫ أ‬pop() ‫شط اٌّؾذد ِضً داٌخ‬ٙ‫ ٌؾزف اٌف‬del ‫خ‬١‫ّىٓ اعزخذاَ اٌىٍّخ ا عبع‬٠ 
. ً ‫ٕٗ ِغجمب‬١‫خ رغزخذَ ٌؾزف وبئٓ رُ رؼ‬١‫ وٍّخ أعبع‬ٝ٘ : del keyword 
my_list = ['p','r','o','b','l','e','m']
my_list.remove('p')
print(my_list) # Output: ['r', 'o', 'b', 'l', 'e', 'm']
# Output: 'o'
print(my_list.pop(1))
print(my_list) # Output: ['r', 'b', 'l', 'e', 'm']
# Output: 'm'
print(my_list.pop())
print(my_list) # Output: ['r', 'b', 'l', 'e']
my_list.clear()
print(my_list) # Output: []
# Deleting list items

my_list = ['p', 'r', 'o', 'b', 'l', 'e', 'm']
del my_list[2] # delete one item
print(my_list)
# delete multiple items

del my_list[1:5]
print(my_list)
del my_list # delete entire list
output
['r', 'o', 'b', 'l', 'e', 'm']
o
['r', 'b', 'l', 'e', 'm']
m
['r', 'b', 'l', 'e']
[]
['p', 'r', 'b', 'l', 'e', 'm']
['p', 'm']
: ٟ‫ر‬٢‫ خطأ وب‬ٟ‫ؼط‬١‫ب ع‬ٙ‫ الؽع ػٕذ غجبػخ اٌذاٌخ ثؼذ ؽزف‬
my_list = ['p','r','o','b','l','e','m']
del my_list # delete entire list
print(my_list) # Error: List not defined
output
print(my_list)
NameError: name 'my_list' is not defined
ْٛ‫ض‬٠‫ اٌمبئّخ داخً ٌغخ اٌجب‬ٍٝ‫بد ػ‬١ٍّ‫ ػ‬: Python List Operations
: ٟ‫ر‬٢‫ب ا‬ِٕٙ List ‫ اٌمبئّخ‬ٍٝ‫ّىٓ ئعشاؤ٘ب ػ‬٠ ٟ‫ اٌز‬Operations ‫بد‬١ٍّ‫ذ ِٓ اٌؼ‬٠‫ٕ٘بن اٌؼذ‬
ُ‫ائ‬ٛ‫خ عّغ اٌم‬١ٍّ‫ ػ‬: Lists Concatenation : ً‫ال‬ٚ‫ أ‬

: ْ‫غزخذِب‬٠ ٓ١ٍِ‫ٕ٘بن ِؼب‬ٚ ‫اؽذح‬ٚ ‫ لبئّخ‬ٟ‫ أوضش ف‬ٚ‫ٓ أ‬١‫ظُ لبئّز‬ٚ ‫ب عّغ‬ٙ١‫زُ ف‬٠ ‫خ‬١ٍّ‫ ػ‬ٝ٘
. ً ‫ٓ ِؼب‬١‫عّغ لبئّز‬ٚ ‫ ٌذِظ‬: ) + ( ‫ ِؼبًِ اٌغّغ‬o
. ‫ ٌزىشاس لبئّخ ػذد ِٓ اٌّشاد‬: ) * ( ‫ ِؼبًِ اٌعشة‬o
# Concatenating and repeating lists
odd = [1, 3, 5]
print(odd + [9, 7, 5])
print(["re"] * 3)
output
[1, 3, 5, 9, 7, 5]
['re', 're', 're']
ُ‫ائ‬ٛ‫خ رىشاس اٌم‬١ٍّ‫ ػ‬: Lists Iterating : ً ‫ب‬١ٔ‫ صب‬

‫س ػجذش اٌؼٕبصذش داخذً اٌمبئّذخ‬ٚ‫ّىٕٕذب اٌّذش‬١‫ ف‬arrays ‫فبد‬ٛ‫ ػجبسح ػٓ ِصف‬Lists ُ‫ائ‬ٛ‫ظشا ْ اٌم‬ ً ٔ
. for ‫ ِضً ؽٍمخ‬Looping ‫خ‬٠‫ثبعزخذاَ اٌؾٍمخ اٌزىشاس‬
for x in thislist:
print(x)
output
apple
banana
cherry
index ‫شط‬ٙ‫ك اٌف‬٠‫ ػٓ غش‬looping ًّ‫ّىٓ ػ‬٠ 

for i in range(len(thislist)):
print(thislist[i])
output
apple
banana
cherry
.‫لبثً ٌٍزىشاس ِٕبعت‬ ٍِ ‫ إلٔشبت‬len)( ‫ اٌذاٌخ‬ٚ range)( ‫زُ اعزخذَ اٌذاٌخ‬٠ ‫ الؽع‬
‫‪ِ ‬ضبي ػٍ‪While Loop ٝ‬‬
‫]"‪thislist = ["apple", "banana", "cherry‬‬
‫‪i = 0‬‬
‫‪while i < len(thislist):‬‬
‫)]‪print(thislist[i‬‬
‫‪i = i + 1‬‬
‫‪output‬‬
‫‪apple‬‬
‫‪banana‬‬
‫‪cherry‬‬
‫‪ّ٠ ‬ىٕه رىشاس ػٕبصش اٌمبئّخ ثبعزخذاَ ؽٍمخ ‪.while‬‬

‫‪ ‬اعزخذَ اٌذاٌخ ()‪ٌ len‬زؾذ‪٠‬ذ غ‪ٛ‬ي اٌمبئّخ ‪.‬‬
‫‪٠ ‬جذأ اٌؼذ ِٓ اٌف‪ٙ‬شط ‪٠ٚ 0‬غزّش ثبٌّش‪ٚ‬س ػٍ‪ ٝ‬وً ػٕبصش اٌمبئّخ‪.‬‬
‫‪ ‬رزوش ص‪٠‬بدح اٌف‪ٙ‬شط ثّمذاس ‪ 1‬ثؼذ وً رىشاس‪.‬‬
‫‪ ‬صبٌضب ً ‪ : Looping Using List Comprehension :‬اٌزىشاس ثبعزخذاَ ف‪ ُٙ‬اٌمبئّخ‬

‫‪ٛ٠‬فش ‪ List Comprehension‬ألصش ص‪١‬غخ ٌٍزىشاس ػجش اٌم‪ٛ‬ائُ ‪:‬‬
‫]"‪thislist = ["apple", "banana", "cherry‬‬
‫]‪[print(x) for x in thislist‬‬
‫‪output‬‬
‫‪apple‬‬
‫‪banana‬‬
‫‪cherry‬‬
‫‪ : Python List Comprehension‬لبئّخ اٌف‪ ُٙ‬داخً ٌغخ اٌجب‪٠‬ض‪ْٛ‬‬

‫٘‪ ٝ‬غش‪٠‬مخ ر‪ٛ‬فش ألصش ‪ syntax‬ػٕذِب رش‪٠‬ذ ئٔشبت لبئّخ عذ‪٠‬ذح ثٕب ًت ػٍ‪ ٝ‬ل‪ ُ١‬لبئّخ ِ‪ٛ‬ع‪ٛ‬دح‪.‬‬
‫‪ Synax :‬‬ ‫]‪newlist = [expression for item in iterable if condition == True‬‬
‫‪ :expression ‬اٌزؼج‪١‬ش ٘‪ ٛ‬اٌؼٕصش اٌؾبٌ‪ ٟ‬ف‪ ٟ‬اٌزىشاس ‪ٌٚ‬ىٕٗ أ‪ً ٠‬‬

‫عب إٌز‪١‬غخ ‪ٚ‬اٌز‪ّ٠ ٟ‬ىٕه ِؼبٌغز‪ٙ‬ب لجً أْ ‪ٕ٠‬ز‪ٟٙ‬‬
‫ث‪ٙ‬ب ا ِش وؼٕصش لبئّخ ف‪ ٟ‬اٌمبئّخ اٌغذ‪٠‬ذح ‪.‬‬
‫‪ : iterable ‬اٌم‪ّ١‬خ اٌمبثٍخ ٌٍزىشاس ‪ّ٠‬ىٓ أْ ‪٠‬ى‪ ْٛ‬اٌؼٕصش اٌمبثً ٌٍزىشاس أ‪ ٞ‬وبئٓ لبثً ٌٍزىشاس ِضً ‪ list‬أ‪ٚ‬‬
‫‪ tuple‬أ‪ set ٚ‬ئٌ ِٓ اٌزغٍغالد ‪.‬‬
‫‪ : condition ‬اٌششغ ‪٠‬شجٗ ػبًِ اٌزصف‪١‬خ ‪ filter‬اٌز‪ ٞ‬ال ‪٠‬مجً ع‪ ٜٛ‬اٌؼٕبصش اٌز‪٠ ٟ‬زُ رم‪ّٙ١١‬ب ئٌ‪.True ٝ‬‬
‫‪ٕ٘ ‬فشض أْ ٌذ‪ٕ٠‬ب ِغّ‪ٛ‬ػخ ِذٓ اٌف‪ٛ‬اوذٗ داخذً لبئّذخ ‪ٔٚ list‬ش‪٠‬ذذ لبئّذخ عذ‪٠‬ذذح رؾزذ‪ ٞٛ‬فمذػ ػٍذ‪ ٝ‬اٌفبو‪ٙ‬ذخ‬
‫اٌز‪٠ ٟ‬ؾز‪ ٞٛ‬اعّ‪ٙ‬ب ػٍ‪ ٝ‬ؽشف "‪."a‬‬
‫ ِذغ اخزجذبس اٌشذشغ‬for ‫ذه وزبثذخ ػجذبسح‬١ٍ‫ٓ ػ‬١‫زؼ‬١‫ عذ‬List Comprehension َ‫ ؽبٌذخ ػذذَ اعذزخذا‬ٟ‫ ف‬
: ٟ‫ر‬٢‫ب وب‬ٍٙ‫ ثذاخ‬condition
fruits = ["apple", "banana", "cherry", "kiwi", "mango"]

newlist = []
for x in fruits:
if "a" in x:
newlist.append(x)
print(newlist)
output
['apple', 'banana', 'mango']
: ٟ‫ر‬٢‫اؽذ فمػ وب‬ٚ ‫بَ ثىً رٌه ثغطش‬١‫ّىٕه اٌم‬٠ List Comprehension َ‫ ؽبٌخ اعزخذا‬ٟ‫ ف‬
newlist = [x for x in fruits if "a" in x]
print(newlist)
output
['apple', 'banana', 'mango']
: Condition List Comprehension ٍٝ‫ ػ‬1 ‫ ِضبي‬
#Condition The condition is like a filter that only accepts the items that valuate to
True.
newlist = [x for x in fruits if x != "apple"]
print(newlist)
#The condition is optional and can be omitted:

newlist = [x for x in fruits]
print(newlist)
output
['banana', 'cherry', 'kiwi', 'mango']
['apple', 'banana', 'cherry', 'kiwi', 'mango']
: iterable List Comprehension ٍٝ‫ ػ‬2 ‫ ِضبي‬
#The iterable can be any iterable object, like a list, tuple, set etc.
newlist = [x for x in range(10)]
print(newlist)
#Same example, but with a condition:

newlist = [x for x in range(10) if x < 5]
print(newlist)
output
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
[0, 1, 2, 3, 4]
: expression List Comprehension ٍٝ‫ ػ‬3 ‫ ِضبي‬
#The expression is the current item in the iteration, but it is also the outcome,
#which you can manipulate before it ends up like a list item in the new list:
newlist = [x.upper() for x in fruits]
print(newlist)
#Set all values in the new list to 'hello':

newlist = ['hello' for x in fruits]
print(newlist)
#The expression can also contain conditions, not like a filter,

# but as a way to manipulate the outcome:
newlist = [x if x != "banana" else "orange" for x in fruits]
print(newlist)
output
['APPLE', 'BANANA', 'CHERRY', 'KIWI', 'MANGO']
['hello', 'hello', 'hello', 'hello', 'hello']
['apple', 'orange', 'cherry', 'kiwi', 'mango']
ْٛ‫ض‬٠‫ائُ داخً ٌغخ اٌجب‬ٛ‫اي اٌم‬ٚ‫ د‬: Python list methods
‫اي‬ٚ‫ػذذخ ِذذٓ اٌذذذ‬ّٛ‫ع ذب ً ِغ‬٠‫ٕ٘ذذبن أ‬ٚ list ‫ رزؼبِذذً ِذذغ اٌمبئّذذخ‬ٟ‫اي اٌزذذ‬ٚ‫ػذذخ ِذذٓ اٌذذذ‬ّٛ‫ ِغ‬ٝ‫رؼشفٕذذب ػٍذذ‬
Python ‫فشح ِغ وبئٕبد اٌمبئّخ داخً ٌغخ ثشِغخ‬ٛ‫ اٌّز‬methods ‫ؼشف ثبٌطشق‬٠ ‫ ِب‬ٚ‫ أ‬functions
list.method() ‫ذذك‬٠‫ذذب ػذذٓ غش‬ٙ١ٌ‫ي ئ‬ٛ‫صذذ‬ٌٛ‫ّىٕذذه ا‬٠ٚ lists ُ‫ائ‬ٛ‫ اٌمذذ‬ٝ‫ّىذذٓ ئعشاؤ٘ذذب ػٍذذ‬٠ ٟ‫اٌزذذ‬
: ٍٟ٠ ‫ّب‬١‫ب ف‬ٙ‫ أغٍج‬ٍٝ‫عٕزؼشف ػ‬
. )ٓ‫ي ػٕبصش اٌمبئّخ (اٌىبئ‬ٛ‫ي ؛ ٌّؼشفخ غ‬ٛ‫ داٌخ اٌط‬: len() function 
.‫ اٌمبئّخ‬ٟ‫شط اٌؼٕصش اٌّؾذد ف‬ٙ‫شط ؛ ٌّؼشفخ ف‬ٙ‫ داٌخ اٌف‬: index() function 
.‫ اٌمبئّخ‬ٟ‫ب اٌؼٕصش اٌّؾذد ف‬ٙ١‫ش ف‬ٙ‫ظ‬٠ ٟ‫ داٌخ اٌؼذد ؛ ٌّؼشفخ ػذد اٌّشاد اٌز‬: count() function 
.ٌٟ‫ رٕبص‬ٚ‫ أ‬ٞ‫ت رصبػذ‬١‫ت ػٕبصش اٌمبئّخ ثزشر‬١‫ داٌخ اٌفشص ؛ ٌزشر‬: sort() function 
. ‫ػىظ ػٕبصش اٌمبئّخ‬ٚ ‫ داٌخ اٌؼىظ ؛ ٌمٍت‬: reverse() function 
.‫ ِٓ اٌمبئّخ‬ٜ‫ داٌخ إٌغ ؛ ٌؼًّ ٔغخخ آخش‬: copy() function 
# Python list methods
my_list = [3, 8, 1, 6, 0, 8, 4]
print(len(my_list))
print(my_list.index(8))
print(my_list.count(8))
my_list.sort()
print(my_list)
my_list.reverse()
print(my_list)
# shallow copy using the slicing syntax
# mixed list
list = ['cat', 0, 6.7]
# copying a list using slicing
new_list = list[:]
# Adding an element to the new list
new_list.append('dog')
# Printing new and old list

print('Old List:', list)
print('New List:', new_list)
output
7
1
2
[0, 1, 3, 4, 6, 8, 8]
[8, 8, 6, 4, 3, 1, 0]
Old List: ['cat', 0, 6.7]
New List: ['cat', 0, 6.7, 'dog']
‫انذرس انسادس ‪ :‬انًجًوعات (انتعذيذ)‬
‫)‪(Tuples‬‬
‫‪ ‬عذذززؼٍُ فذذ‪٘ ٟ‬ذذزا اٌجشٔذذبِظ اٌزؼٍ‪ّ١‬ذذ‪ِ ٟ‬ذذب ٘ذذ‪ ٛ‬اٌزؼذ‪٠‬ذذذ ‪ Tuples‬فذذ‪ٚ Python ٟ‬و‪١‬ف‪١‬ذذخ ئٔشذذبئ‪ٙ‬ب ‪ِٚ‬زذذ‪ٝ‬‬
‫رغزخذِ‪ٙ‬ب ‪ٚ‬اٌذ‪ٚ‬اي اٌّخزٍفخ اٌز‪٠ ٟ‬غت أْ رى‪ ْٛ‬ػٍ‪ ٝ‬دسا‪٠‬خ ث‪ٙ‬ب‪.‬‬
‫‪ : Tuples‬اٌّغّ‪ٛ‬ػبد أ‪ ٚ‬اٌزؼذ‪٠‬ذ (وّب ‪٠‬طٍك ػٍ‪ٙ١‬ب ف‪ ٟ‬اٌؾغبة)‬

‫٘‪ ٝ‬ػجبسح ػٓ عٍغٍخ ِشرجخ ِٓ اٌؼٕبصش ؽ‪١‬ش رُغزخذَ ٌزخض‪ ٓ٠‬ػٕبصش ِزؼذدح ف‪ِ ٟ‬زغ‪١‬ش ‪ٚ‬اؽذ‪.‬‬
‫‪ٚ‬اٌّغّ‪ٛ‬ػذذخ ‪٘ tuple‬ذذ‪ٚ ٟ‬اؽذذذح ِذذٓ أٔذذ‪ٛ‬اع اٌج‪١‬بٔذذبد اٌّغذذزخذِخ فذذ‪ٚ .Python ٟ‬رزّ‪١‬ذذض اٌّغّ‪ٛ‬ػذذخ ثأٔ‪ٙ‬ذذب‬
‫ِشٔخ ٌٍغب‪٠‬خ وّب ال ‪ٍ٠‬ضَ أْ رى‪ ْٛ‬وبفخ اٌؼٕبصش اٌّ‪ٛ‬ع‪ٛ‬دح ف‪ ٟ‬اٌمبئّخ ِٓ ٔفظ إٌ‪ٛ‬ع ‪.‬‬
‫اٌّغّ‪ٛ‬ػخ ‪ٚ ٟ٘ tuple‬اؽذح ِٓ ‪ 4‬أٔ‪ٛ‬اع ث‪١‬بٔبد ِعّٕخ ف‪ٚ Python ٟ‬اٌز‪ ٟ‬رُغزخذَ ٌزخض‪ِ ٓ٠‬غّ‪ٛ‬ػذخ‬
‫ِٓ اٌج‪١‬بٔبد ‪ٚ‬اٌضالصخ ا خش‪ٚ Dictionary ٚ Set ٚ lists ٟ٘ ٜ‬وٍ‪ٙ‬ب راد خصبئص ‪ٚ‬اعذزخذاِبد‬
‫عذذذب ػٍذذذ‪ِ ٝ‬غّ‪ٛ‬ػذذذخ ‪ tuple‬أخذذذش‪ٜ‬‬
‫أ‪ ٚ‬أ‪ٔ ٞ‬ذذذ‪ٛ‬ع آخذذذش ) وّذذذب ‪ّ٠‬ىذذذٓ أْ رؾزذذذ‪ ٞٛ‬اٌّغّ‪ٛ‬ػذذذخ ‪ tuple‬أ‪ً ٠‬‬
‫وؼٕصش ‪ٚ‬رغّ‪ِ ٝ‬غّ‪ٛ‬ػخ ِزذاخٍخ ‪. nested tuple‬‬
‫ٌإلػالْ ػٓ ِغّ‪ٛ‬ػخ ‪ tuple‬أِش ع‪ِٚ ًٙ‬جبشش ‪٠‬زُ رٌه ػٓ غش‪٠‬ك ‪ٚ‬ظغ اٌؼٕبصش داخذً ألذ‪ٛ‬اط ( )‬
‫‪# Empty tuple‬‬
‫)( = ‪my_tuple‬‬
‫)‪print(my_tuple‬‬
‫‪# Tuple having integers‬‬

‫)‪my_tuple = (1, 2, 3‬‬
‫‪# tuple with mixed datatypes‬‬

‫)‪my_tuple = (1, "Hello", 3.4‬‬
‫‪# nested tuple‬‬

‫))‪my_tuple = ("mouse", [8, 4, 6], (1, 2, 3‬‬
‫‪output‬‬
‫)(‬
‫)‪(1, 2, 3‬‬
‫)‪(1, 'Hello', 3.4‬‬
‫))‪('mouse', [8, 4, 6], (1, 2, 3‬‬
ً ٠‫ّىٓ أ‬٠ 
.tuple packing ‫ػخ‬ّٛ‫ُؼشف ثبعُ رؼجئخ اٌّغ‬٠ٚ ‫اط‬ٛ‫ْ اعزخذاَ ا ل‬ٚ‫ػخ ثذ‬ّٛ‫عب ئٔشبت ِغ‬
my_tuple = 3, 4.6, "dog"
print(my_tuple)
# tuple unpacking is also possible

a, b, c = my_tuple
print(a) # 3
print(b) # 4.6
print(c) # dog
output
(3, 4.6, 'dog')
3
4.6
dog
ً ‫اؽذذ‬ٚ ‫ػخ ثؼٕصذش‬ّٛ‫ؼذ ئٔشبت ِغ‬٠ 

‫ٓ ال‬١‫عذ‬ٛ‫ٓ ل‬١‫اؽذذ ثذ‬ٚ ‫د ػٕصذش‬ٛ‫عذ‬ٚ ْ ‫ت ؛‬ٟ‫أِذشا صذؼجًب ثؼذط اٌشذ‬
‫ي ػٕصذش ٌإلشذبسح‬ٚ‫ ) ثؼذذ أ‬, ( ‫ فبصٍخ‬ٌٝ‫ٌزٌه عٕؾزبط ئ‬ٚ tuple ‫ظ‬١ٌٚ string ٓ‫ؼجش ػ‬٠ ‫ف‬ٛ‫ع‬ٚ ٟ‫ىف‬٠
.tuple ‫ػخ‬ّٛ‫ب ِغ‬ٙٔ‫ أ‬ٌٝ‫ئ‬
my_tuple = ("hello")
print(type(my_tuple)) # <class 'str'>
# Creating a tuple having one element

my_tuple = ("hello",)
print(type(my_tuple)) # <class 'tuple'>
# Parentheses is optional
my_tuple = "hello",
print(type(my_tuple)) # <class 'tuple'>
output
<class 'str'>
<class 'tuple'>
<class 'tuple'>
ً ٠‫ّىٓ أ‬٠ 
‫ إلٔشذبت‬tuple)( ‫ ثذـ‬ّٝ‫غذ‬٠ ٞ‫اٌز‬ٚ constructor ‫ اٌ ُّٕشئ‬ٚ‫ أ‬constructor ‫ذ‬١‫عب اعزخذاَ اٌ ُّش‬
. ‫ذ٘ب‬٠‫ ٔش‬ٞ‫ػخ اٌز‬ّٛ‫ٓ اٌّغ‬١‫ع‬ٛ‫ٓ ل‬١‫ب ث‬ٍٙ‫ٔىزت ثذاخ‬ٚ tuple)( ‫ش ٔىزت‬١‫ ؽ‬tuple ‫ػخ‬ّٛ‫ِغ‬
thistuple = tuple(("apple", "banana", "cherry"))
print(thistuple)
output
('apple', 'banana', 'cherry')
‫‪ٚ : Tuple Items‬ؽذاد اٌّغّ‪ٛ‬ػخ أ‪ ٚ‬ػٕبصش اٌّغّ‪ٛ‬ػخ‬
‫‪ o‬ػٕبصش ِف‪ٙ‬شعخ ‪indexing‬‬
‫‪٘ٚ‬زا ‪٠‬ؼٕ‪ ٟ‬أْ اٌؼٕصش ا ‪ٚ‬ي ثٗ ف‪ٙ‬شط [‪ ]0‬اٌؼٕصش اٌضبٔ‪ ٟ‬ثٗ ف‪ٙ‬شط [‪٘ٚ ]1‬ىزا ‪.‬‬
‫‪ o‬ػٕبصش ِشرجخ ‪ordered‬‬

‫‪٘ٚ‬زا ‪٠‬ؼٕ‪ ٟ‬أْ اٌؼٕبصش ٌ‪ٙ‬ب رشر‪١‬ت ِؾذد ‪ٌٚ‬ذٓ ‪٠‬زغ‪١‬ذش ٘ذزا اٌزشر‪١‬ذت‪ٚ .‬ئرا لّذذ ثاظذبفخ ػٕبصذش‬
‫عذ‪٠‬ذح ئٌ‪ ٝ‬اٌمبئّخ فغ‪١‬زُ ‪ٚ‬ظغ اٌؼٕبصش اٌغذ‪٠‬ذح ف‪ٙٔ ٟ‬ب‪٠‬خ اٌمبئّخ‪.‬‬
‫‪ِ ‬الؽظخ ‪ٕ٘ :‬بن ثؼط د‪ٚ‬اي ٌٍمبئّخ عزغ‪١‬ش اٌزشر‪١‬ت ‪ٌٚ‬ىٓ ثشىً ػبَ ٌٓ ‪٠‬زغ‪١‬ش رشر‪١‬ت اٌؼٕبصش‪.‬‬
‫‪ o‬ػٕبصش غ‪١‬ش لبثٍخ ٌٍزغ‪١١‬ش ‪unchangeable‬‬

‫‪٘ٚ‬زا ‪٠‬ؼٕ‪ ٟ‬أٔٗ ال ‪ّ٠‬ىٓ رغ‪١١‬ش ‪ٚ‬ئظبفخ ‪ٚ‬ئصاٌخ اٌؼٕبصش ف‪ ٟ‬اٌّغّ‪ٛ‬ػخ ثؼذ ئٔشبئ‪ٙ‬ب ‪.‬‬
‫‪ o‬ػٕبصش رغّؼ ثم‪ِ ُ١‬ىشسح ‪duplicate values‬‬

‫‪٘ٚ‬زا ‪٠‬ؼٕ‪ ٟ‬أٔٗ ‪ّ٠‬ىٓ أْ رؾز‪ ٞٛ‬اٌّغّ‪ٛ‬ػخ ػٍ‪ ٝ‬ػٕبصش ثٕفظ اٌم‪ّ١‬خ ٔ‪ٙ‬ب ػٕبصش ِف‪ٙ‬شعخ ‪.‬‬
‫‪ ‬و‪١‬ف‪١‬خ اٌ‪ٛ‬ص‪ٛ‬ي ئٌ‪ ٝ‬ا ؽشف أ‪ ٚ‬اٌؼٕبصش اٌّ‪ٛ‬ع‪ٛ‬دح داخً اٌّغّ‪ٛ‬ػخ ‪ Tuple‬؟‬
‫‪ ‬رغّؼ ٌغخ ‪ Python‬ثبٌف‪ٙ‬شعذخ اٌغذٍج‪١‬خ ‪ negative indexing‬داخذً اٌّغّ‪ٛ‬ػذخ ‪ Tuple‬ؽ‪١‬ذش ‪٠‬شذ‪١‬ش‬

‫اٌف‪ٙ‬شط [ ‪ ] -1‬ئٌ‪ ٝ‬اٌؼٕصش ا خ‪١‬ش ٌٍغٍغٍخ ‪٠ٚ‬ش‪١‬ش [ ‪ ] -2‬ئٌ‪ ٝ‬اٌؼٕصش لجً ا‪٢‬خ‪١‬ش ‪٘ٚ‬ىزا ‪.‬‬
‫‪٠ ‬زُ اعزخذاَ ا ل‪ٛ‬اط اٌّشثؼخ ‪ٚ Square brackets‬سِض٘ب ٘‪ٌٍٛ ] [ ٛ‬صذ‪ٛ‬ي ئٌذ‪ ٝ‬ػٕبصذش اٌّغّ‪ٛ‬ػذخ‬
‫‪ّ٠ٚ‬ىذذذٓ اعذذذزخذاَ ا لذذذ‪ٛ‬اط اٌّشثؼذذذخ ِذذذغ ػبِذذذً اٌزمط‪١‬ذذذغ ‪ٚ slicing operator‬سِض٘ذذذب ٘ذذذ‪] : [ ٛ‬‬
‫العزخشاط ِغّ‪ٛ‬ػخ ِٓ اٌؼٕبصش ِٓ داخً اٌّغّ‪ٛ‬ػخ ‪.Tuple‬‬
# Accessing tuple elements using indexing
my_tuple = ('p','e','r','m','i','t')
print(my_tuple[0]) # 'p'
print(my_tuple[5]) # 't'
# nested tuple
n_tuple = ("mouse", [8, 4, 6], (1, 2, 3))
# nested index
print(n_tuple[0][3]) # 's'
print(n_tuple[1][1]) # 4
# Accessing tuple elements using slicing
my_tuple = ('p','r','o','g','r','a','m','i','z')
# elements 2nd to 4th
# Output: ('r', 'o', 'g')

print(my_tuple[1:4])
# elements beginning to 2nd
# Output: ('p', 'r')

print(my_tuple[:-7])
# elements 8th to end
# Output: ('i', 'z')

print(my_tuple[7:])
# elements beginning to end
# Output: ('p', 'r', 'o', 'g', 'r', 'a', 'm', 'i', 'z')
print(my_tuple[:])
output
p
t
s
4
('r', 'o', 'g')
('p', 'r')
('i', 'z')
('p', 'r', 'o', 'g', 'r', 'a', 'm', 'i', 'z')
my_tuple = ('p','e','r','m','i','t')
# TypeError: list indices must be integers, not float
my_tuple[2.0]
output
my_tuple[2.0]
TypeError: tuple indices must be integers or slices, not float
my_tuple = ('p','e','r','m','i','t')
# IndexError: list index out of range
print(my_tuple[6])
output
print(my_tuple[6])
IndexError: tuple index out of range
‫ػخ‬ّٛ‫ً ػٕبصش اٌّغ‬٠‫ رؼذ‬: Modify Tuple Items

‫ذش ػٕبصذش٘ب ثّغذشد‬١١‫ّىذٓ رغ‬٠ ‫ أٔذٗ ال‬ٟ‫ؼٕذ‬٠ ‫ ِّذب‬list ‫ ػىظ اٌمبئّخ‬ٍٝ‫ش ػ‬١١‫ش لبثٍخ ٌٍزغ‬١‫ػخ غ‬ّٛ‫اٌّغ‬
.‫ب‬ٙ‫ص‬١‫رخص‬
# Changing tuple values
my_tuple = (4, 2, 3, [6, 5])
# TypeError: 'tuple' object does not support item assignment

my_tuple[1] = 9
output
my_tuple[1] = 9
TypeError: 'tuple' object does not support item assignment
ٖ‫ذذش ػٕبصذذش‬١١‫ّىٓ رغ‬١‫ فذذ‬list ‫ذذش ِضذذً اٌمبئّذذخ‬١١‫بٔذذبد لبثذذً ٌٍزغ‬١‫ع ث‬ٛ‫ ٔفغذذٗ ٔذذ‬ٛ‫ٌىذذٓ ئرا وذذبْ اٌؼٕصذذش ٘ذذ‬ٚ 
.)ٓ١١‫ُ ِخزٍفخ (ئػبدح اٌزؼ‬١‫ػخ ٌم‬ّٛ‫ٓ ِغ‬١١‫عب رؼ‬ ً ٠‫ّىٕٕب أ‬٠ ‫ وّب‬.‫اٌّزذاخٍخ‬
# Changing tuple values
my_tuple = (4, 2, 3, [6, 5])
# However, item of mutable element can be changed

my_tuple[3][0] = 9 # Output: (4, 2, 3, [9, 5])
print(my_tuple)
# Tuples can be reassigned

my_tuple = ('p', 'r', 'o', 'g', 'r', 'a', 'm', 'i', 'z')
# Output: ('p', 'r', 'o', 'g', 'r', 'a', 'm', 'i', 'z')
print(my_tuple)
output
(4, 2, 3, [9, 5])
('p', 'r', 'o', 'g', 'r', 'a', 'm', 'i', 'z')
‫ لبئّذخ‬ٝ‫ػذخ ئٌذ‬ّٛ‫ذً اٌّغ‬٠ٛ‫ذك رؾ‬٠‫ ػذٓ غش‬ٛ٘ٚ tuple ‫ػخ‬ّٛ‫ اٌّغ‬ٍٝ‫ُ ػ‬١‫ً اٌم‬٠‫ّىٕه ِٓ رؼذ‬٠ ً٠‫ ٕ٘بن ثذ‬
.‫ػخ‬ّٛ‫ ِغ‬ٌٝ‫ً اٌمبئّخ ئ‬٠ٛ‫ئػبدح رؾ‬ٚ ‫ش اٌمبئّخ‬١١‫رغ‬ٚ
#this is a tuple
x = ("apple", "banana", "cherry")
#convert tuple to list

y = list(x)
#modify list
y[1] = "kiwi"
#convert list to tuple

x = tuple(y)
#print the new tuple

print(x)
output
('apple', 'kiwi', 'cherry')
‫ػخ‬ّٛ‫ ئظبفخ ػٕبصش اٌّغ‬: add tuple Items

ٝ‫ذش ػٍذ‬١١‫ش لبثٍخ ٌٍزغ‬١‫ػخ غ‬ّٛ‫ب ؛ ْ اٌّغ‬ٙ١ٌ‫ّىٕه ئظبفخ ػٕبصش ئ‬٠ ‫ ال‬tuple ‫ػخ‬ّٛ‫ثّغشد ئٔشبت اٌّغ‬
.‫ب‬ٙ‫ص‬١‫ش ػٕبصش٘ب ثّغشد رخص‬١١‫ّىٓ رغ‬٠ ‫ أٔٗ ال‬ٟٕ‫ؼ‬٠ ‫ ِّب‬list ‫ػىظ اٌمبئّخ‬
‫)"‪thistuple = ("apple", "banana", "cherry‬‬
‫‪thistuple.append("orange") # This will raise an error‬‬
‫)‪print(thistuple‬‬
‫‪output‬‬
‫>‪File "c:\Users\Hoda_PC\Desktop\example.py", line 2, in <module‬‬
‫‪thistuple.append("orange") # This will raise an error‬‬
‫'‪AttributeError: 'tuple' object has no attribute 'append‬‬
‫‪ٕ٘ ‬بن ثذ‪ّ٠ ً٠‬ىٕه ِٓ ئظبفخ اٌم‪ ُ١‬ػٍ‪ ٝ‬اٌّغّ‪ٛ‬ػخ ‪ ٛ٘ٚ tuple‬رّب ًِب ِضً اٌؾً اٌجذ‪ٌ ً٠‬زغ‪١١‬ذش اٌّغّ‪ٛ‬ػذخ‬
‫‪ّ٠‬ىٕه رؾ‪ٍٙ٠ٛ‬ب ئٌذ‪ ٝ‬لبئّذخ ‪ٚ‬ئظذبفخ اٌؼٕبصذش ػذٓ غش‪٠‬ذك د‪ٚ‬اي ئظذبفخ اٌؼٕبصذش ػٍذ‪ ٝ‬اٌمبئّذخ اٌزذ‪ ٟ‬رذُ‬
‫دساعز‪ٙ‬ب ف‪ ٟ‬اٌفصً اٌغبثك ‪ٚ‬رؾ‪ٍٙ٠ٛ‬ب ِشح أخش‪ ٜ‬ئٌ‪ِ ٝ‬غّ‪ٛ‬ػخ‪.‬‬
‫‪ : append () function ‬داٌخ اإلٌؾبق ؛ إلظبفخ ػٕصش ئٌ‪ٙٔ ٝ‬ب‪٠‬خ اٌمبئّخ ‪.‬‬
‫‪ : insert() function ‬داٌخ اإلدخبي ؛ إلدساط ػٕصش لبئّخ ف‪ ٟ‬ف‪ٙ‬شط ِؾذد ‪.‬‬
‫‪ : extend() function ‬داٌخ اإلِذاد ؛ إلٌؾبق ػٕبصش ِٓ لبئّخ أخش‪ ٜ‬ئٌ‪ ٝ‬اٌمبئّخ اٌؾبٌ‪١‬خ ‪.‬‬
‫)"‪thistuple = ("apple", "banana", "cherry‬‬
‫)‪y = list(thistuple‬‬
‫)"‪y.append("orange‬‬
‫)‪thistuple = tuple(y‬‬
‫)‪print(thistuple‬‬
‫‪output‬‬
‫)'‪('apple', 'banana', 'cherry', 'orange‬‬
‫‪ : remove tuple Items‬ئصاٌخ ػٕبصش اٌّغّ‪ٛ‬ػخ‬

‫اٌّغّ‪ٛ‬ػبد غ‪١‬ش لبثٍخ ٌٍزغ‪١١‬ش ٌذزا ال ‪ّ٠‬ىٕذه ئصاٌذخ اٌؼٕبصذش ِٕ‪ٙ‬ذب ‪ٌٚ‬ىذٓ ‪ّ٠‬ىٕذه اعذزخذاَ ٔفذظ اٌؾذً‬
‫اٌجذذذ‪ ً٠‬اٌذذز‪ ٞ‬اعذذزخذِٕبٖ ٌزغ‪١١‬ذذش ػٕبصذذش اٌّغّ‪ٛ‬ػذذخ ‪ٚ‬ئظذذبفز‪ٙ‬ب ‪ٚ‬ال رٕغذذ‪ ٝ‬أْ رغذذزخذَ د‪ٚ‬اي اٌخبصذذخ‬
‫ثبٌؾزف اٌمبئّخ اٌز‪ ٟ‬رُ دساعز‪ٙ‬ب ف‪ ٟ‬اٌفصً اٌغبثك ‪.‬‬
‫‪ : remove () function ‬داٌخ اإلصاٌخ ؛ إلصاٌخ اٌؼٕصش اٌّؾذد‪.‬‬
‫‪ : pop() function ‬داٌخ اإلصاٌخ ؛ إلصاٌخ اٌف‪ٙ‬شط اٌّؾذد‪.‬‬
‫‪ : clear() function ‬داٌخ اٌّغؼ ؛ ٌّغؼ ػٕبصش اٌمبئّخ ‪.‬‬
‫‪ ‬ئرا ٌُ رؾذد اٌف‪ٙ‬شط ‪ٌٍ index‬ذاٌخ )(‪ pop‬فأ‪ٙ‬ب عزض‪ ً٠‬اٌؼٕصش ا خ‪١‬ش‪.‬‬
‫‪ ‬اٌذاٌخ )(‪ clear‬رم‪ َٛ‬ثزفش‪٠‬غ اٌمبئّخ ‪ٚ‬ثبٌزبٌ‪ ٟ‬رظً اٌمبئّخ ِ‪ٛ‬ع‪ٛ‬دح ٌىٕ‪ٙ‬ب ال رؾز‪ ٞٛ‬ػٍ‪ِ ٝ‬ؾز‪.ٜٛ‬‬
.ًِ‫ الصاٌخ اٌمبئّخ ثبٌىب‬ٚ‫ أ‬pop() ‫شط اٌّؾذد ِضً داٌخ‬ٙ‫ ٌؾزف اٌف‬del ‫خ‬١‫ّىٓ اعزخذاَ اٌىٍّخ ا عبع‬٠ 
#Convert the tuple into a list, remove "apple", and convert it back into a tuple:
thistuple = ("apple", "banana", "cherry")
y = list(thistuple)
y.remove("apple")
thistuple = tuple(y)
print(thistuple)
output
('banana', 'cherry')
: ٟ‫ر‬٢‫ خطأ وب‬ٟ‫ؼط‬١‫ب ع‬ٙ‫ الؽع ػٕذ غجبػخ اٌذاٌخ ثؼذ ؽزف‬
#The del keyword can delete the tuple completely:
del thistuple
print(thistuple) #this will raise an error because the tuple no longer exists
output
print(thistuple) #this will raise an error because the tuple no longer exists
NameError: name 'thistuple' is not defined
ْٛ‫ض‬٠‫ػخ داخً ٌغخ اٌجب‬ّٛ‫ اٌّغ‬ٍٝ‫بد ػ‬١ٍّ‫ ػ‬: Python Tuple Operations
: ٟ‫ر‬٢‫ب ا‬ِٕٙ Tuple ‫ػخ‬ّٛ‫ اٌّغ‬ٍٝ‫ّىٓ ئعشاؤ٘ب ػ‬٠ ٟ‫ اٌز‬Operations ‫بد‬١ٍّ‫ذ ِٓ اٌؼ‬٠‫ٕ٘بن اٌؼذ‬
ٓ١‫ػز‬ّٛ‫خ عّغ ِغ‬١ٍّ‫ ػ‬: Tuple Concatenation : ً‫ال‬ٚ‫ أ‬

: ْ‫غزخذِب‬٠ ٓ١ٍِ‫ٕ٘بن ِؼب‬ٚ ‫اؽذح‬ٚ ‫ػخ‬ّٛ‫ ِغ‬ٟ‫ أوضش ف‬ٚ‫ٓ أ‬١‫ػز‬ّٛ‫ظُ ِغ‬ٚ ‫ب عّغ‬ٙ١‫زُ ف‬٠ ‫خ‬١ٍّ‫ ػ‬ٝ٘
. ً ‫ٓ ِؼب‬١‫ػز‬ّٛ‫عّغ ِغ‬ٚ ‫ ٌذِظ‬: ) + ( ‫ ِؼبًِ اٌغّغ‬o
. ‫ػخ ػذد ِٓ اٌّشاد‬ّٛ‫ ٌزىشاس ِغ‬: ) * ( ‫ ِؼبًِ اٌعشة‬o
# Concatenation
# Output: (1, 2, 3, 4, 5, 6)
print((1, 2, 3) + (4, 5, 6))
# Repeat
# Output: ('Repeat', 'Repeat', 'Repeat')
print(("Repeat",) * 3)
output
(1, 2, 3, 4, 5, 6)
('Repeat', 'Repeat', 'Repeat')
‫ػخ‬ّٛ‫خ رىشاس اٌّغ‬١ٍّ‫ ػ‬: Tuple Iterating : ً ‫ب‬١ٔ‫ صب‬
ً‫س ػجذذش اٌؼٕبصذذش داخذذ‬ٚ‫ّىٕٕذذب اٌّذذش‬١‫ ف‬arrays ‫فبد‬ٛ‫ػجذذبسح ػذذٓ ِصذذف‬Tuple ‫ػذذخ‬ّٛ‫ٔظذ ًذشا ْ اٌّغ‬
. for ‫ ِضً ؽٍمخ‬Looping ‫خ‬٠‫ػخ ثبعزخذاَ اٌؾٍمخ اٌزىشاس‬ّٛ‫اٌّغ‬
for x in thistuple:
print(x)
output
apple
banana
cherry
index ‫شط‬ٙ‫ك اٌف‬٠‫ ػٓ غش‬looping ًّ‫ّىٓ ػ‬٠ 

for i in range(len(thistuple)):
print(thistuple[i])
output
apple
banana
cherry
.‫لبثً ٌٍزىشاس ِٕبعت‬ ٍِ ‫ إلٔشبت‬len)( ‫ اٌذاٌخ‬ٚ range)( ‫زُ اعزخذَ اٌذاٌخ‬٠ ‫ الؽع‬
While Loop ٍٝ‫ ِضبي ػ‬

i = 0
while i < len(thistuple):
print(thistuple[i])
i = i + 1
output
apple
banana
cherry
.while ‫ّىٕه رىشاس ػٕبصش اٌمبئّخ ثبعزخذاَ ؽٍمخ‬٠ 

. ‫ي اٌمبئّخ‬ٛ‫ذ غ‬٠‫ ٌزؾذ‬len)( ‫ اعزخذَ اٌذاٌخ‬
.‫ وً ػٕبصش اٌمبئّخ‬ٍٝ‫س ػ‬ٚ‫غزّش ثبٌّش‬٠ٚ 0 ‫شط‬ٙ‫جذأ اٌؼذ ِٓ اٌف‬٠ 
.‫ ثؼذ وً رىشاس‬1 ‫شط ثّمذاس‬ٙ‫بدح اٌف‬٠‫ رزوش ص‬
‫ػخ‬ّٛ‫ داخً ِغ‬ٛ‫خ اخزجبس ػع‬١ٍّ‫ ػ‬: Tuple Membership Test : ً ‫ صبٌضب‬
‫ذذخ‬١‫ػذذخ اٌفشػ‬ّٛ‫ػذذخ ٌؼّذذً اخزجذذبس ِذذب ئرا وبٔذذذ اٌّغ‬ّٛ‫خ داخذذً اٌّغ‬٠ٛ‫ّىذذٓ اعذذزخذاَ ِؼذذبِالد اٌؼعذذ‬٠
: ‫ػخ ّ٘ب‬ّٛ‫ٓ الخزجبس ػٕصش داخً ِغ‬١‫ٕ٘بن وٍّز‬ٚ ‫ أَ ال ؟‬Tuple ‫ػخ‬ّٛ‫دح داخً ِغ‬ٛ‫ع‬ِٛ
. ‫ػخ‬ّٛ‫ اٌّغ‬ٟ‫ٓ ف‬١‫د ؽشف ِؼ‬ٛ‫ع‬ٚ ِٓ ‫خ رغزخذَ ٌٍزؾمك‬١‫ وٍّخ أعبع‬: in keyword 
. ‫ػخ‬ّٛ‫ اٌّغ‬ٟ‫ٓ ف‬١‫د ؽشف ِؼ‬ٛ‫ع‬ٚ َ‫خ رغزخذَ ٌٍزؾمك ِٓ ػذ‬١‫ وٍّخ أعبع‬: not in keyword 
# Membership test in tuple
my_tuple = ('a', 'p', 'p', 'l', 'e',)
# In operation
print('a' in my_tuple)
print('b' in my_tuple)
# Not in operation
print('g' not in my_tuple)
output
True
False
True
ْٛ‫ض‬٠‫ػخ داخً ٌغخ اٌجب‬ّٛ‫اي اٌّغ‬ٚ‫ د‬: Python tuple methods

: ُ٘ tuple ‫ػخ‬ّٛ‫ رزؼبًِ ِغ اٌّغ‬ٟ‫اي اٌز‬ٚ‫ػخ ِٓ اٌذ‬ّٛ‫ٕ٘بن ِغ‬
. )ٓ‫ػخ (اٌىبئ‬ّٛ‫ي ػٕبصش اٌّغ‬ٛ‫ي ؛ ٌّؼشفخ غ‬ٛ‫ داٌخ اٌط‬: len() function 
.‫ػخ‬ّٛ‫ اٌّغ‬ٟ‫شط اٌؼٕصش اٌّؾذد ف‬ٙ‫شط ؛ ٌّؼشفخ ف‬ٙ‫ داٌخ اٌف‬: index() function 
.‫ػخ‬ّٛ‫ اٌّغ‬ٟ‫ب اٌؼٕصش اٌّؾذد ف‬ٙ١‫ش ف‬ٙ‫ظ‬٠ ٟ‫ داٌخ اٌؼذد؛ ٌّؼشفخ ػذد اٌّشاد اٌز‬: count() function 
my_tuple = ('a', 'p', 'p', 'l', 'e',)
print(len(my_tuple)) # Output: 5
print(my_tuple.count('p')) # Output: 2
print(my_tuple.index('l')) # Output: 3
output
5
2
3
‫‪١ِّ : Advantages of Tuple over List‬ضاد اٌّغّ‪ٛ‬ػخ ػٓ اٌمبئّخ داخً ٌغخ اٌجب‪٠‬ض‪ْٛ‬‬
‫ٔظشا ْ ‪ tuple‬رشجٗ اٌم‪ٛ‬ائُ ‪ lists‬رّب ًِب ‪٠‬ذزُ اعذزخذاَ والّ٘ذب فذ‪ِٛ ٟ‬الذ ِّبصٍذخ‪ِٚ .‬ذغ رٌذه ٕ٘ذبن‬‫ً‬
‫ِّ‪١‬ضاد ِؼ‪ٕ١‬خ ػٕذ رطج‪١‬ك اٌّغّ‪ٛ‬ػخ ‪ tuple‬ثخالف اٌمبئّخ ‪ list‬ف‪ّ١‬ب ‪ ٍٟ٠‬ثؼط اٌّضا‪٠‬ب اٌشئ‪١‬غ‪١‬خ ‪:‬‬
‫‪ٔ ‬غزخذَ ثشىً ػبَ اٌّغّ‪ٛ‬ػبد ٔ‪ٛ‬اع اٌج‪١‬بٔبد غ‪١‬ش اٌّزغبٔغخ (اٌّخزٍفخ) ‪ٚ‬اٌم‪ٛ‬ائُ ٔ‪ٛ‬اع اٌج‪١‬بٔبد‬
‫اٌّزغبٔغخ (اٌّزشبث‪ٙ‬خ)‪.‬‬
‫ٔظشا ْ ‪ tuple‬غ‪١‬ش لبثٍخ ٌٍزغ‪١١‬ش فاْ اٌزىشاس ػجش ‪٠ tuple‬ى‪ ْٛ‬أعشع ِٕٗ ِغ ‪ٌٚ list‬زٌه‬
‫ً‬ ‫‪‬‬
‫ٕ٘بن رؾغٓ غف‪ ١‬ف‪ ٟ‬ا دات‪.‬‬
‫‪ّ٠ ‬ىٓ اعزخذاَ اٌّغّ‪ٛ‬ػبد اٌز‪ ٟ‬رؾز‪ ٞٛ‬ػٍ‪ ٝ‬ػٕبصش غ‪١‬ش لبثٍخ ٌٍزغ‪١١‬ش وّفزبػ ‪ٌٕٛ key‬ع اٌج‪١‬بٔبد‬
‫اٌمبِ‪ٛ‬ط ‪ٌٚ dictionary‬ىٓ ٘زا غ‪١‬ش ِّىٓ ِغ اٌم‪ٛ‬ائُ‪.‬‬
‫‪ ‬ئرا وبٔذ ٌذ‪٠‬ه ث‪١‬بٔبد ال رزغ‪١‬ش فاْ رٕف‪١‬ز٘ب ثصفز‪ٙ‬ب ‪ tuple‬ع‪١‬عّٓ أٔ‪ٙ‬ب رظً ِؾّ‪١‬خ ظذ اٌىزبثخ‪.‬‬
‫انذرس انسابع ‪ :‬انتشكيهة (انًجًوعة)‬
‫)‪(Sets‬‬
‫‪ ‬عذذززؼٍُ فذذ‪٘ ٟ‬ذذزا اٌجشٔذذبِظ اٌزؼٍ‪ّ١‬ذذ‪ ٟ‬عذذززؼٍُ وذذً شذذ‪ٟ‬ت ػذذٓ رشذذى‪١‬الد أ‪ِ ٚ‬غّ‪ٛ‬ػذذبد ‪ sets‬داخذذً ٌغذذخ‬
‫اٌجب‪٠‬ض‪ ْٛ‬؛ عززؼٍُ و‪٠ ١‬زُ ئٔشبؤ٘ب ‪ٚ‬و‪١‬ف‪١‬خ ئظبفخ أ‪ ٚ‬ئصاٌخ اٌؼٕبصش ِٕ‪ٙ‬ذب ‪ٚ‬عّ‪١‬ذغ اٌؼٍّ‪١‬ذبد اٌزذ‪٠ ٟ‬ذزُ‬
‫ئعشاؤ٘ب ػٍ‪ ٝ‬رشى‪١‬الد ‪ sets‬ف‪.Python ٟ‬‬
‫‪ : Sets‬اٌزشى‪١‬الد (اٌّغّ‪ٛ‬ػبد)‬
‫٘‪ ٝ‬ػجبسح ػٓ عٍغٍخ غ‪١‬ش ِشرجخ ِٓ اٌؼٕبصش ؽ‪١‬ش رُغزخذَ ٌزخض‪ ٓ٠‬ػٕبصش ِزؼذدح ف‪ِ ٟ‬زغ‪١‬ش ‪ٚ‬اؽذ‪.‬‬
‫‪ٚ‬اٌزشى‪ٍ١‬خ ‪ٚ ٟ٘ set‬اؽذح ِٓ أٔ‪ٛ‬اع اٌج‪١‬بٔبد اٌّغزخذِخ فذ‪ٚ .Python ٟ‬رزّ‪١‬ذض اٌّغّ‪ٛ‬ػذخ ثأٔ‪ٙ‬ذب ِشٔذخ‬
‫وّب ال ‪ٍ٠‬ضَ أْ رى‪ ْٛ‬وبفخ اٌؼٕبصش اٌّ‪ٛ‬ع‪ٛ‬دح ف‪ ٟ‬اٌمبئّخ ِٓ ٔفظ إٌ‪ٛ‬ع ‪.‬‬
‫اٌزشى‪ٍ١‬خ ‪ٚ ٟ٘ Set‬اؽذح ِٓ ‪ 4‬أٔ‪ٛ‬اع ث‪١‬بٔبد ِعّٕخ ف‪ٚ Python ٟ‬اٌز‪ ٟ‬رُغزخذَ ٌزخذض‪ِ ٓ٠‬غّ‪ٛ‬ػذخ ِذٓ‬
‫اٌج‪١‬بٔبد ‪ٚ‬اٌضالصخ ا خذش‪٘ ٜ‬ذ‪ٚ Dictionary ٚ Set ٚ Tuple ٟ‬وٍ‪ٙ‬ذب راد خصذبئص ‪ٚ‬اعذزخذاِبد‬
‫أ‪ ٚ‬أ‪ٔ ٞ‬ذذ‪ٛ‬ع آخذذش ) ٌىذذٓ ال ‪ّ٠‬ىذذٓ أْ رؾزذذ‪ sets ٞٛ‬ػٍذذ‪ ٝ‬ػٕبصذذش لبثٍذذخ ٌٍزغ‪١١‬ذذش ِضذذً اٌمذذ‪ٛ‬ائُ ‪ lists‬أ‪ٚ‬‬
‫اٌزشذذى‪١‬الد ‪ sets‬أ‪ ٚ‬اٌمذذ‪ٛ‬اِ‪١‬ظ ‪ dictionaries‬وؼٕبصذذش ثذذذاخٍ‪ٙ‬ب ‪ٌٚ‬ىذذٓ ‪ّ٠‬ىذذٓ أْ رمجذذً ثذذذاخٍ‪ٙ‬ب ػٍذذ‪ٝ‬‬
‫ِغّ‪ٛ‬ػخ ‪ tuple‬وؼٕصش ‪.‬‬
‫ٌإلػالْ ػٓ اٌزشى‪ٍ١‬خ ‪ Set‬أِش ع‪ِٚ ًٙ‬جبشش ‪٠‬زُ رٌذه ػذٓ غش‪٠‬ذك ‪ٚ‬ظذغ اٌؼٕبصذش داخذً ألذ‪ٛ‬اط } {‬
‫‪ِٚ‬فص‪ٛ‬ي ث‪ّٕٙ١‬ب ثفبصٍخ ‪ٚ Comma‬سِض٘ب ( ‪ ) ,‬أ‪ ٚ‬ػٓ غش‪٠‬ك اٌ ُّش‪١‬ذ )(‪ set‬وب‪٢‬ر‪: ٟ‬‬
‫‪# Different types of sets in Python‬‬
‫‪# set of integers‬‬
‫}‪my_set = {1, 2, 3‬‬
‫)‪print(my_set‬‬
‫‪# set of mixed datatypes‬‬

‫}‪my_set = {1.0, (1, 3), "Hello", (1, 2, 3) , True‬‬
‫)‪print(my_set‬‬
‫‪output‬‬
‫}‪{1, 2, 3‬‬
‫}'‪{1.0, (1, 2, 3), (1, 3), 'Hello‬‬
: ٟ‫ر‬٢‫ وب‬set() ‫ذ‬١‫ك اٌ ُّش‬٠‫ ػٓ غش‬set ‫ٍخ‬١‫ وؼجبسح ػٓ رشى‬list ‫ص لبئّخ‬١‫ّىٓ رخص‬٠ 
# set cannot have duplicates
# Output: {1, 2, 3, 4}
my_set = {1, 2, 3, 4, 3, 2}
print(my_set)
# we can make set from a list

# Output: {1, 2, 3}
my_set = set([1, 2, 3, 2])
print(my_set)
output
{1, 2, 3, 4}
{1, 2, 3}
‫ٓ } { ال‬٠‫ٓ ٘ذز‬١‫اؽذذ ثذ‬ٚ ‫د ػٕصش‬ٛ‫ع‬ٚ ْ ‫ت ؛‬ٟ‫أِشا صؼجًب ثؼط اٌش‬ ً ‫اؽذ‬ٚ ‫ػخ ثؼٕصش‬ّٛ‫ؼذ ئٔشبت ِغ‬٠ 
َ‫ اعذذذذزخذا‬ٝ‫ٌذذذذزٌه عذذذذٕؾزبط ئٌذذذذ‬ٚ set ‫ظ‬١‫ٌذذذذ‬ٚ dictionary ‫بٔذذذذبد‬١‫ع اٌج‬ٛ‫ؼجذذذذش ػذذذذٓ ٔذذذذ‬٠ ‫ف‬ٛ‫عذذذذ‬ٚ ٟ‫ىفذذذذ‬٠
. set ‫ٍخ فبسغخ‬١‫ش ػٓ رشى‬١‫ذٌٍزؼج‬١‫اٌ ُّش‬
# Distinguish set and dictionary while creating empty set
# initialize a with {}
a = {}
# check data type of a

print(type(a))
# initialize a with set()

a = set()
# check data type of a

print(type(a))
output
<class 'dict'>
<class 'set'>
ً ٠‫ّىذذٓ أ‬٠ 
‫ إلٔشذذبت‬set)( ‫ ثذذـ‬ّٝ‫غذذ‬٠ ٞ‫اٌذذز‬ٚ constructor ‫ اٌ ُّٕشذذئ‬ٚ‫ أ‬constructor ‫ذ‬١‫عذذب اعذذزخذاَ اٌ ُّشذذ‬
. ‫ذ٘ب‬٠‫ ٔش‬ٞ‫ اٌز‬set ‫ٍخ‬١‫ٓ اٌزشى‬١‫ع‬ٛ‫ٓ ل‬١‫ب ث‬ٍٙ‫ٔىزت ثذاخ‬ٚ set)( ‫ش ٔىزت‬١‫ ؽ‬set ‫ٍخ‬١‫رشى‬
thisset = set({"apple", "banana", "cherry"})
print(thisset)
output
{'banana', 'apple', 'cherry'}
‫‪ٚ : Set Items‬ؽذاد اٌزشى‪ٍ١‬خ أ‪ ٚ‬ػٕبصش اٌزشى‪ٍ١‬خ‬
‫‪ o‬ػٕبصش غ‪١‬ش ِف‪ٙ‬شعخ ‪unindexed‬‬
‫‪٘ٚ‬زا ‪٠‬ؼٕ‪ ٟ‬أٔٗ ال ‪ّ٠‬ىٓ اٌ‪ٛ‬ص‪ٛ‬ي ئٌ‪ ٝ‬ػٕبصش ‪ set‬ثبٌشع‪ٛ‬ع ئٌ‪ ٝ‬ف‪ٙ‬شط ‪ index‬أ‪ ٚ‬اٌّفزبػ ‪.key‬‬
‫‪ o‬ػٕبصش غ‪١‬ش ِشرجخ ‪unordered‬‬

‫‪٘ٚ‬ذذزا ‪٠‬ؼٕذذ‪ ٟ‬أْ اٌؼٕبصذذش اٌّ‪ٛ‬عذذ‪ٛ‬دح فذذ‪ ٟ‬اٌزشذذى‪ٍ١‬خ ‪ٌ set‬ذذ‪١‬ظ ٌ‪ٙ‬ذذب رشر‪١‬ذذت ِؾذذذد‪ّ٠ٚ .‬ىذذٓ أْ رظ‪ٙ‬ذذش‬
‫ػٕبصذذش اٌّغّ‪ٛ‬ػذذخ ثزشر‪١‬ذذت ِخزٍذذ فذذ‪ ٟ‬وذذً ِذذشح رغذذزخذِ‪ٙ‬ب ‪ٌٚ‬ذذزٌه ال ‪ّ٠‬ىذذٓ اإلشذذبسح ئٌ‪ٙ١‬ذذب‬
‫ثبٌف‪ٙ‬شط ‪ index‬أ‪ ٚ‬اٌّفزبػ ‪.key‬‬
‫‪ o‬ػٕبصش غ‪١‬ش لبثٍخ ٌٍزغ‪١١‬ش ‪unchangeable‬‬

‫‪٘ٚ‬زا ‪٠‬ؼٕ‪ ٟ‬أٔٗ ال ‪ّ٠‬ىٓ رغ‪١١‬ش اٌؼٕبصش ثؼذ ئٔشبت اٌّغّ‪ٛ‬ػخ‪.‬‬
‫‪ِ ‬الؽظخ ‪ :‬ثّغشد ئٔشبت ‪ set‬ال ‪ّ٠‬ىٕه رغ‪١١‬ش ػٕبصش٘ب ‪ٌٚ‬ىٓ ‪ّ٠‬ىٕه ئظبفخ ػٕبصش عذ‪٠‬ذح‪.‬‬
‫‪ o‬ػٕبصش ال رغّؼ ثم‪ِ ُ١‬ىشسح ‪unduplicated values‬‬

‫‪٘ٚ‬زا ‪٠‬ؼٕ‪ ٟ‬أٔٗ ال ‪ّ٠‬ىٓ أْ رؾز‪ ٞٛ‬اٌزشى‪ٍ١‬خ ػٍ‪ ٝ‬ػٕبصش‪ ٓ٠‬ثٕفظ اٌم‪ّ١‬خ ‪.‬‬
‫‪ ‬و‪١‬ف‪١‬خ اٌ‪ٛ‬ص‪ٛ‬ي ئٌ‪ ٝ‬ا ؽشف أ‪ ٚ‬اٌؼٕبصش اٌّ‪ٛ‬ع‪ٛ‬دح داخً اٌّغّ‪ٛ‬ػخ ‪ Tuple‬؟‬
‫‪ ‬ال ‪ّ٠‬ىٕٕب اٌ‪ٛ‬ص‪ٛ‬ي ئٌ‪ ٝ‬ػٕبصش اٌزشى‪ٍ١‬خ ‪ set‬ثذبٌشع‪ٛ‬ع ئٌذ‪ ٝ‬اٌف‪ٙ‬شعذخ ‪ٚ index‬ػبِذً اٌزمط‪١‬ذغ ( ‪٠ ) :‬جذذأ‬
‫اٌف‪ٙ‬ذذشط ِذذٓ ‪ 0‬وّذذب دسعذذٕب فذذ‪ ٟ‬اٌّغّ‪ٛ‬ػذذبد ا‪٢‬خذذش‪ٌٚ . ٜ‬ىذذٓ ‪ّ٠‬ىٕذذه ئعذذشات رىذذشاس خذذالي ػٕبصذذش‬
‫اٌّغّ‪ٛ‬ػخ ثبعزخذاَ ؽٍمخ ‪. for‬‬
‫}"‪thisset = {"apple", "banana", "cherry‬‬
‫‪for x in thisset:‬‬
‫)‪print(x‬‬
‫‪output‬‬
‫‪banana‬‬
‫‪apple‬‬
‫‪cherry‬‬
‫‪ّ٠ ‬ىٕه اخزجبس ِب ئرا وبٔذ ٕ٘بن ل‪ّ١‬خ ِؾذدح ِ‪ٛ‬ع‪ٛ‬دح ف‪ set ٟ‬ثبعزخذاَ اٌىٍّخ ا عبع‪١‬خ ‪.in‬‬
‫}"‪thisset = {"apple", "banana", "cherry‬‬

‫)‪print("banana" in thisset‬‬
‫‪output‬‬
‫‪True‬‬
ّٝ‫غذ‬٠ ‫س خطذأ‬ٚ‫ ؽذذ‬ٝ‫ رٌذه ئٌذ‬ٞ‫إد‬١‫ عذ‬index ‫ذشط‬ٙ‫ذك اٌف‬٠‫ ػٕصذش ػذٓ غش‬ٝ‫ي ئٌذ‬ٛ‫ص‬ٌٛ‫ٌخ ا‬ٚ‫ ػٕذ ِؾب‬
. ‫ش ِشرجخ‬١‫غ‬ٚ ‫شعخ‬ٙ‫ش ِف‬١‫ب ػٕبصش غ‬ٙٔ ‫ ؛‬TypeError
thisset = {"apple", "banana", "cherry"}

print(thisset[1])
output
print(thisset[1])
TypeError: 'set' object is not subscriptable
‫ٍخ‬١‫ً ػٕبصش اٌزشى‬٠‫ رؼذ‬: Modify Set Items

.‫ب‬ٙ‫ص‬١‫ش ػٕبصش٘ب ثّغشد رخص‬١١‫ّىٓ رغ‬٠ ‫ أٔٗ ال‬ٟٕ‫ؼ‬٠ ‫ش ِّب‬١١‫ش لبثٍخ ٌٍزغ‬١‫ٍخ غ‬١‫اٌزشى‬
print(thisset[1]=="Grape")
output
print(thisset[1]=="Grape")
TypeError: 'set' object is not subscriptable
‫ٍخ‬١‫ ئظبفخ ػٕبصش ٌٍزشى‬: add set Items

: ٓ١‫ك اٌذاٌز‬٠‫ػخ ِٓ اٌؼٕبصش ػٓ غش‬ّٛ‫ ِغ‬ٚ‫ّىٕٕب ئظبفخ ػٕصش أ‬٠
. ‫ٍخ‬١‫ اٌزشى‬ٌٝ‫اؽذ ئ‬ٚ ‫ داٌخ اإلظبفخ ؛ إلظبفخ ػٕصش‬: add() function 
. ‫ٍخ‬١‫ اٌزشى‬ٌٝ‫ش ؛ إلظبفخ ػذح ػٕبصش ئ‬٠‫ داٌخ اٌزؾذ‬: update() function 
#To add one item to a set
thisset.add("orange")
print(thisset)
#To add items from another set into the current set
tropical = {"pineapple", "mango", "papaya"}
thisset.update(tropical)
print(thisset)
output
{'banana', 'orange', 'cherry', 'apple'}
{'papaya', 'mango', 'banana', 'pineapple', 'cherry', 'apple'}
dictionaries ٚ‫ أ‬tuples ٚ‫ أ‬lists ً‫ وذذبئٓ لبثذذً ٌٍزىذذشاس ِضذذ‬ٞ‫ أ‬update() ‫ّىذذٓ أْ رأخذذز اٌذاٌذذخ‬٠ 
.‫زُ رغٕت اٌزىشاساد‬٠ ‫غ اٌؾبالد‬١ّ‫ ع‬ٟ‫ٌىٓ ف‬ٚ ‫ب‬ٌٙ ‫وّؼبِالد‬
# add list to set
mylist = ["kiwi", "orange"]
thisset.update(mylist)
print(thisset)
# add list and set

my_set = {1, 3}
my_set.update([4, 5], {1, 6, 8})
print(my_set)
output
{'cherry', 'kiwi', 'apple', 'orange', 'banana'}
{1, 3, 4, 5, 6, 8}
‫ٍخ‬١‫ ئصاٌخ ػٕبصش اٌزشى‬: remove set Items

: ٓ١‫ك اٌذاٌز‬٠‫ػخ ِٓ اٌؼٕبصش ػٓ غش‬ّٛ‫ ِغ‬ٚ‫ّىٕٕب ؽزف ػٕصش أ‬٠
.‫ داٌخ اإلصاٌخ ؛ إلصاٌخ اٌؼٕصش اٌّؾذد‬: remove() function 
.‫رغبً٘ اٌؼٕصش اٌّؾذد‬ٚ ‫ داٌخ اٌزغبً٘ ؛ إلصاٌخ‬: discard() function 
. ‫ٍخ‬١‫ اٌزشى‬ٟ‫ش ف‬١‫خ‬٢‫ داٌخ اإلصاٌخ ؛ إلصاٌخ اٌؼٕصش ا‬: pop() function 
. ‫ٍخ‬١‫ داٌخ اٌّغؼ ؛ ٌّغؼ ػٕبصش اٌزشى‬: clear() function 
. ‫ٍخ وبٍِخ‬١‫ داٌخ اٌؾزف ؛ ٌؾزف اٌزشى‬: del() function 
# initialize my_set
my_set = {1, 3, 4, 5, 6}
print(my_set)
# discard an element
my_set.discard(4) # Output: {1, 3, 5, 6}
print(my_set)
# remove an element
my_set.remove(6) # Output: {1, 3, 5}
print(my_set)
# clear my_set
my_set.clear() # Output: set()
print(my_set)
output
{1, 3, 4, 5, 6}
{1, 3, 5, 6}
{1, 3, 5}
set()
ٓ‫ذش ِشرجذخ ٌذزٌه ٌذ‬١‫ػذخ غ‬ّٛ‫ ِغ‬ٝ‫ ٘ذ‬set ‫ٍخ‬١‫ٌىٓ رزوش أْ اٌزشى‬ٚ ‫ش‬١‫ً اٌؼٕصش ا خ‬٠‫ عزض‬pop() ‫ اٌذاٌخ‬
ْ‫ف الؽذع أ‬ٚ‫ش اٌؼٕصش اٌّؾز‬١١‫زُ رغ‬١‫د ع‬ٛ‫ز اٌى‬١‫زُ رٕف‬٠ ‫ وً ِشح‬ٟ‫ف‬ٚ ٗ‫ رزُ ئصاٌز‬ٞ‫رؼشف اٌؼٕصش اٌز‬
.ٗ‫ رّذ ئصاٌز‬ٞ‫ اٌؼٕصش اٌز‬ٟ٘ pop)( ‫ّخ ئسعبع اٌذاٌخ‬١‫ل‬
# initialize my_set
my_set = {1, 3, 4, 5, 6}
print(my_set)
# pop an element
print("the removed element is : ",my_set.pop())
# initialize my_set
# Output: set of unique elements
my_set = set("HelloWorld")
print(my_set)
# pop an element
print("the removed element is : ",my_set.pop())
output
{1, 3, 4, 5, 6}
the removed element is : 1
{'o', 'l', 'd', 'H', 'W', 'r', 'e'}
the removed element is : o
: ٟ‫ر‬٢‫ ا‬ٛ٘ discard() ‫اٌذاٌخ‬ٚ remove() ‫ٓ اٌذاٌخ‬١‫ اٌفشق ث‬

. ‫د‬ٛ‫ع‬ِٛ ‫ش‬١‫س خطأ ئرا وبْ اٌؼٕصش اٌّشاد ئصاٌزٗ غ‬ٛٙ‫ ظ‬ٌٝ‫ ئ‬ٞ‫ فغزإد‬remove() ‫ اٌذاٌخ‬
# remove my_set
my_set = {1, 3, 4, 5, 6}
my_set.remove(2)
print(my_set)
output
my_set.remove(2)
KeyError: 2
. ‫د‬ٛ‫ع‬ِٛ ‫ش‬١‫س خطأ ئرا وبْ اٌؼٕصش اٌّشاد ئصاٌزٗ غ‬ٛٙ‫ ظ‬ٌٝ‫ ئ‬ٞ‫ ال رإد‬discard() ‫ اٌذاٌخ‬
# discard my_set
my_set = {1, 3, 4, 5, 6}
my_set.discard(2)
print(my_set)

output
{1, 3, 4, 5, 6}
: ٟ‫ر‬٢‫ خطأ وب‬ٟ‫ؼط‬١‫ب ع‬ٙ‫ ثؼذ ؽزف‬set ‫ الؽع ػٕذ غجبػخ‬
#this will raise an error because the set no longer exists
del thisset
print(thisset)
output
print(thisset)
NameError: name 'thisset' is not defined
ْٛ‫ض‬٠‫ٍخ داخً ٌغخ اٌجب‬١‫ اٌزشى‬ٍٝ‫بد ػ‬١ٍّ‫ ػ‬: Python Set Operations
‫اٌزمذذبغغ‬ٚ union ‫خ ِضذذً االرؾذذبد‬١‫بظذذ‬٠‫ػذذخ س‬ّٛ‫ذذبد ِغ‬١ٍّ‫ إلعذذشات ػ‬Sets ‫الد‬١‫ّىذذٓ اعذذزخذاَ اٌزشذذى‬٠
‫ّىٕٕذذب‬٠ٚ symmetric difference ً‫اٌفذذشق اٌّزّبصذذ‬ٚ difference ‫االخذذزالف‬ٚ intersection
. ‫خ‬١‫ر‬٢‫اي ا‬ٚ‫ اٌذ‬ٚ‫اًِ أ‬ٛ‫ك اٌؼ‬٠‫بَ ثزٌه ػٓ غش‬١‫اٌم‬
ٓ١‫ رشىٍز‬ٚ‫ٓ أ‬١‫ػز‬ّٛ‫خ ارؾبد ِغ‬١ٍّ‫ ػ‬: Set Union : ً‫ال‬ٚ‫ أ‬
ً‫دح داخذذذ‬ٛ‫عذذذ‬ٌّٛ‫ذذذغ اٌؼٕبصذذذش ا‬١ّ‫ ع‬ٝ‫ي ػٍذذذ‬ٛ‫ذذذخ ٌٍؾصذذذ‬١ٍّ‫ ػ‬ٝ‫٘ذذذ‬
: ‫ك‬٠‫زُ رٌه ػٓ غش‬٠ٚ sets ٓ١‫ػز‬ّٛ‫ِغ‬
: ) | ( ‫ ِؼبًِ االرؾبد‬o
.ٓ١‫ػز‬ّٛ‫غ اٌؼٕبصش داخً اٌّغ‬١ّ‫ ع‬ٍٟ‫ ػ‬ٜٛ‫ذح رؾز‬٠‫ عذ‬set ‫ ثزشعغ‬: union() ‫ داٌخ‬o
.1 ‫ػخ‬ّٛ‫ داخً اٌّغ‬2 ‫ػخ‬ّٛ‫ اٌّغ‬ٟ‫دح ف‬ٛ‫ع‬ٌّٛ‫ ثزُذسط اٌؼٕبصش ا‬: update() ‫ داٌخ‬o
# Set union method

set1 = {1, 2, 3, 4, 5} o
set2 = {4, 5, 6, 7, 8}
# use | operator
print(set1 | set2)
# use union() method

set3 = set1.union(set2)
print(set3)
# use update() method

set1.update(set2)
print(set1)
output
{1, 2, 3, 4, 5, 6, 7, 8}
{1, 2, 3, 4, 5, 6, 7, 8}
{1, 2, 3, 4, 5, 6, 7, 8}
‫‪ ‬صبٔ‪١‬ب ً ‪ : Set Intersection :‬ػٍّ‪١‬خ رمبغغ ِغّ‪ٛ‬ػز‪ ٓ١‬أ‪ ٚ‬رشىٍز‪ٓ١‬‬
‫٘‪ ٝ‬ػٍّ‪١‬خ ٌٍؾص‪ٛ‬ي ػٍ‪ ٝ‬اٌؼٕبصذش اٌّشذزشوخ ثذ‪ِ ٓ١‬غّذ‪ٛ‬ػز‪sets ٓ١‬‬
‫‪٠ٚ‬زُ رٌه ػٓ غش‪٠‬ك ‪:‬‬
‫‪ِ o‬ؼبًِ اٌزمبغغ ( & ) ‪:‬‬
‫‪ o‬داٌخ )( ‪ : intersection‬ثزشعغ ‪ set‬عذ‪٠‬ذح رؾز‪ ٜٛ‬ػٍ‪ ٟ‬اٌؼٕبصش اٌّشزشوخ ث‪ِ ٓ١‬غّ‪ٛ‬ػز‪.ٓ١‬‬
‫‪ o‬داٌخ )( ‪ : intersection_update‬ثزؾزفع ثبٌؼٕبصش اٌّىشسح اٌّ‪ٛ‬ع‪ٛ‬دح ف‪ ٟ‬وال اٌّغّ‪ٛ‬ػز‪. ٓ١‬‬
‫‪# Set union method‬‬
‫‪‬‬
‫}‪set1 = {1, 2, 3, 4, 5‬‬ ‫‪o‬‬
‫}‪set2 = {4, 5, 6, 7, 8‬‬
‫‪# use & operator‬‬

‫)‪print(set1 & set2‬‬
‫‪# use intersection() method‬‬

‫)‪set3 = set1.intersection(set2‬‬
‫)‪print(set3‬‬
‫‪# use intersection_update() method‬‬

‫)‪set1.intersection_update(set2‬‬
‫)‪print(set1‬‬
‫‪output‬‬
‫}‪{4, 5‬‬
‫}‪{4, 5‬‬
‫}‪{4, 5‬‬
‫‪ ‬صبٌضب ً ‪ : Set Difference :‬ػٍّ‪١‬خ اٌفشق ث‪ِ ٓ١‬غّ‪ٛ‬ػز‪ ٓ١‬أ‪ ٚ‬رشى‪١‬ز‪ٓ١‬‬

‫٘ذذذذ‪ ٝ‬ػٍّ‪١‬ذذذذخ اٌؾصذذذذ‪ٛ‬ي ػٍذذذذ‪ِ ٝ‬غّ‪ٛ‬ػذذذذخ ِذذذذٓ اٌؼٕبصذذذذش اٌّ‪ٛ‬عذذذذ‪ٛ‬دح أؽذذذذذ‬
‫اٌّغّ‪ٛ‬ػز‪١ٌٚ ٓ١‬غذ ِ‪ٛ‬ع‪ٛ‬دح ف‪ ٟ‬اٌّغّ‪ٛ‬ػخ ا‪٢‬خش‪٠ٚ ٜ‬زُ رٌه ػٓ غش‪٠‬ك ‪:‬‬
‫‪ِ o‬ؼبًِ اٌفشق ( ‪: ) -‬‬
‫‪ o‬داٌخ االرؾبد )(‪ : difference‬ثزشعغ ‪ set‬عذ‪٠‬ذح رؾز‪ ٜٛ‬ػٍ‪ ٟ‬اٌفشق ث‪ ٓ١‬اٌّغّ‪ٛ‬ػز‪.ٓ١‬‬
‫‪ o‬داٌذذخ االرؾذذبد )(‪ : difference_update‬ثزؾصذذً ػٍذذ‪ ٝ‬اٌؼٕبصذذش اٌّ‪ٛ‬عذذ‪ٛ‬دح فذذ‪ ٟ‬أؽذذذ اٌّغّذذ‪ٛ‬ػز‪ٓ١‬‬
‫‪١ٌٚ‬غذ ِ‪ٛ‬ع‪ٛ‬دح ف‪ ٟ‬اٌّغّ‪ٛ‬ػخ ا‪٢‬خش‪.ٜ‬‬
‫‪ٔ ‬غزخذَ ٘ذزٖ اٌؼجذبسح اٌش‪٠‬بظذ‪١‬خ (‪ٌٍ A)A-B‬ؾصذ‪ٛ‬ي ػٍذ‪ِ ٝ‬غّ‪ٛ‬ػذخ اٌؼٕبصذش اٌّ‪ٛ‬عذ‪ٛ‬دح فمذػ فذ‪A ٟ‬‬
‫‪١ٌٚ‬غذ ِ‪ٛ‬ع‪ٛ‬دح ‪. B‬‬
‫‪ٔ ‬غذزخذَ ٘ذزٖ اٌؼجذذبسح اٌش‪٠‬بظذ‪١‬خ (‪ٌٍ B)B-A‬ؾصذذ‪ٛ‬ي ػٍذ‪ِ ٝ‬غّ‪ٛ‬ػذذخ اٌؼٕبصذش اٌّ‪ٛ‬عذذ‪ٛ‬دح فمذػ فذذ‪B ٟ‬‬
‫‪١ٌٚ‬غذ ِ‪ٛ‬ع‪ٛ‬دح ‪. A‬‬
# Set union method
set1 = {1, 2, 3, 4, 5}
set2 = {4, 5, 6, 7, 8} o
# set of elements that are only in set1 but not in set2
print(set1 - set2) # use - operator
set3 = set1.difference(set2) # use difference() method
print(set3)
set1.difference_update(set2) # use difference_update() method
print(set1)
# set of elements that are only in set2 but not in set1

print(set2 - set1) # use - operator
set3 = set2.difference(set1) # use difference() method
print(set3)
set2.difference_update(set1) # use difference_update() method
print(set2)
output
{1, 2, 3}
{1, 2, 3}
{1, 2, 3}
{4, 5, 6, 7, 8}
{4, 5, 6, 7, 8}
{4, 5, 6, 7, 8}
ٓ١‫ رشىٍز‬ٚ‫ٓ أ‬١‫ػز‬ّٛ‫خ اٌفشق اٌّّبصً ٌّغ‬١ٍّ‫ ػ‬: Set Symmetric Difference : ً ‫ ساثؼب‬
sets ٓ١‫ػز‬ٛ‫ ِغّذ‬ٟ‫دح فذ‬ٛ‫عذ‬ِٛ ‫ذش‬١‫غ اٌؼٕبصذش اٌغ‬١ّ‫ ع‬ٍٝ‫ي ػ‬ٛ‫خ ٌٍؾص‬١ٍّ‫ ػ‬ٝ٘
: ‫ك‬٠‫زُ رٌه ػٓ غش‬٠ٚ .)‫ّب (ثبعزضٕبت اٌزمبغغ‬ٙ١ٍ‫ و‬ٟ‫ظ ف‬١ٌ ٓ‫ٌى‬ٚ
: ) ^ ( ‫ ِؼبًِ االرؾبد‬o
.ٓ١‫ػز‬ّٛ‫ اٌّغ‬ٟ‫دح ف‬ٛ‫ع‬ِٛ ‫ش‬١‫ رؾزفع ثبٌؼٕبصش اٌغ‬: symmetric_difference() ‫ داٌخ‬o
.ٓ١‫ػز‬ّٛ‫ اٌّغ‬ٟ‫دح ف‬ٛ‫ع‬ِٛ ‫ش‬١‫ رؾزفع ثبٌؼٕبصش اٌغ‬: symmetric_difference_update () ‫ داٌخ‬o
# Set symmetric_difference method

set1 = {1, 2, 3, 4, 5}
set2 = {4, 5, 6, 7, 8}
# use | operator
print(set1 ^ set2)
# use symmetric_difference() method
set3 = set1.symmetric_difference(set2)
print(set3)
# use symmetric_difference update() method
set1.symmetric_difference_update(set2)
print(set1)
output
{1, 2, 3, 6, 7, 8}
{1, 2, 3, 6, 7, 8}
{1, 2, 3, 6, 7, 8}
‫‪ ‬خبِغب ً ‪ : Set Iterating :‬ػٍّ‪١‬خ رىشاس اٌزشى‪ٍ١‬خ أ‪ ٚ‬اٌّغّ‪ٛ‬ػخ‬
‫ظشا ْ اٌزشى‪ٍ١‬خ أ‪ ٚ‬اٌّغّ‪ٛ‬ػخ ‪ Set‬ػجذبسح ػذٓ ِصذف‪ٛ‬فبد ‪ arrays‬ف‪ّ١‬ىٕٕذب اٌّذش‪ٚ‬س ػجذش اٌؼٕبصذش‬ ‫ٔ ً‬
‫داخً اٌّغّ‪ٛ‬ػخ ثبعزخذاَ اٌؾٍمخ اٌزىشاس‪٠‬خ ‪ِ Looping‬ضً ؽٍمخ ‪. for‬‬
‫‪for letter in set("apple"):‬‬
‫)‪print(letter‬‬
‫‪output‬‬
‫‪p‬‬
‫‪a‬‬
‫‪e‬‬
‫‪l‬‬
‫‪ ‬ال ‪ّ٠‬ىٓ ػًّ ؽٍمخ رىشاس‪٠‬خ ػٓ غش‪٠‬ك ‪ ْ while‬اٌّغّ‪ٛ‬ػخ ‪ set‬ال رذػُ اٌف‪ٙ‬شعخ ‪. index‬‬
‫‪ ‬عبدعب ً ‪ : Set Membership Test :‬ػٍّ‪١‬خ اخزجبس ػع‪ ٛ‬داخً اٌزشى‪ٍ١‬خ أ‪ ٚ‬اٌّغّ‪ٛ‬ػخ ‪set‬‬
‫‪ّ٠‬ىذذٓ اعذذزخذاَ ِؼذذبِالد اٌؼعذذ‪٠ٛ‬خ داخذذً اٌّغّ‪ٛ‬ػذذخ ٌؼّذذً اخزجذذبس ِذذب ئرا وبٔذذذ اٌّغّ‪ٛ‬ػذذخ اٌفشػ‪١‬ذذخ‬
‫ِ‪ٛ‬ع‪ٛ‬دح داخً ِغّ‪ٛ‬ػخ ‪ Set‬أَ ال ؟ ‪ٕ٘ٚ‬بن وٍّز‪ ٓ١‬الخزجبس ػٕصش داخً رشى‪ٍ١‬خ ّ٘ب ‪:‬‬
‫‪ : in keyword ‬وٍّخ أعبع‪١‬خ رغزخذَ ٌٍزؾمك ِٓ ‪ٚ‬ع‪ٛ‬د ػٕصش ِؼ‪ ٓ١‬ف‪ ٟ‬اٌّغّ‪ٛ‬ػخ‪.‬‬
‫‪ : not in keyword ‬وٍّخ أعبع‪١‬خ رغزخذَ ٌٍزؾمك ِٓ ػذَ ‪ٚ‬ع‪ٛ‬د ػٕصش ِؼ‪ ٓ١‬ف‪ ٟ‬اٌّغّ‪ٛ‬ػخ‪.‬‬
‫‪# in keyword in a set‬‬
‫‪# initialize my_set‬‬
‫)"‪my_set = set("apple‬‬
‫‪# check if 'a' is present‬‬

‫‪# Output: True‬‬
‫)‪print('a' in my_set‬‬
‫‪# check if 'p' is present‬‬

‫‪# Output: False‬‬
‫)‪print('p' not in my_set‬‬
‫‪output‬‬
‫‪True‬‬
‫‪False‬‬
ْٛ‫ض‬٠‫ داخً ٌغخ اٌجب‬set ‫ػخ‬ّٛ‫اي خبصخ ثبٌّغ‬ٚ‫ د‬: Python Set methods
: ‫ٕخ‬١‫بَ ِؼ‬ِٙ ‫ز‬١‫ ٌزٕف‬Set ‫ػخ‬ّٛ‫ اٌّغ‬ٚ‫ٍخ أ‬١‫ رزؼبًِ ِغ اٌزشى‬ٟ‫اي اٌز‬ٚ‫ػخ ِٓ اٌذ‬ّٛ‫ٕ٘بن ِغ‬
. ٓ‫ ثزشعغ ػذد ػٕبصش اٌىبئ‬ٞ‫ػخ أ‬ّٛ‫ي اٌّغ‬ٛ‫ي ؛ ٌّؼشفخ غ‬ٛ‫ داٌخ اٌط‬: len() function 
. set ‫ػخ‬ّٛ‫ ؛ ٌّؼشفخ أوجش ػٕصش داخً اٌّغ‬ٜ‫ّخ اٌىجش‬١‫ داٌخ اٌم‬: max() function 
. set ‫ػخ‬ّٛ‫ ؛ ٌّؼشفخ أصغش ػٕصش داخً اٌّغ‬ٜ‫ّخ اٌصغش‬١‫ داٌخ اٌم‬: min() function 
. set ‫ػخ‬ّٛ‫ع وً اٌؼٕبصش داخً اٌّغ‬ّٛ‫ داٌخ اٌغّغ ؛ ٌّؼشفخ ِغ‬: sum() function 
‫ػذذخ (ال رفذذشص‬ّٛ‫ذذذح ِذذٓ ػٕبصذذش اٌّغ‬٠‫ذذت ؛ رُشعذذغ لبئّذذخ ِشرجذذخ عذ‬١‫ داٌذذخ اٌزشر‬: sorted() function 
.) ‫ب‬ٙ‫ػخ ٔفغ‬ّٛ‫اٌّغ‬
number = {3, 2, 8, 5, 10, 6}
print("The length of set is:", len(number))

print("The largest number is:", max(number))
print("The smallest number is:", min(number))
print("The Sum of set is:", sum(number))
print("The Sorted set is:", sorted(number))
output
The length of set is: 6
The largest number is: 10
The smallest number is: 2
The Sum of set is: 34
The Sorted set is: [2, 3, 5, 6, 8, 10]
https://www.w3schools.com ‫ ٘زا اٌشاثػ‬ٍٝ‫اي ثبٌظغػ ػ‬ٚ‫ذ ِٓ اٌذ‬٠‫ اٌّض‬ٍٝ‫ّىٕه اٌزؼشف ػ‬٠ 

. https://www.programiz.com ‫ ٘زا اٌشاثػ‬ٚ‫أ‬
‫ػخ اٌ ُّغّذح‬ّٛ‫ اٌّغ‬: Python Frozenset

unchangeable ‫ذذش ػٕبصذذش٘ب‬١١‫ّىذذٓ رغ‬٠ ‫ٌىذذٓ ال‬ٚ set ‫ػذذخ‬ّٛ‫ذذب خصذذبئص اٌّغ‬ٌٙ ‫ذذذح‬٠‫ فئذذخ عذ‬ٟ‫٘ذذ‬
ٟ‫ ٘ذ‬frozensets ْ‫ فا‬immutable lists ‫ائُ صبثزخ‬ٛ‫ ػجبسح ػٓ ل‬tuple ْ‫ٓ أ‬١‫ ؽ‬ٟ‫ب ف‬ٕٙ١١‫ثّغشد رؼ‬
. immutable sets ‫ش‬١١‫ش لبثٍخ ٌٍزغ‬١‫ػبد غ‬ّٛ‫ِغ‬
unhashable ‫ذش لبثٍذخ ٌٍزغضئذخ‬١‫ْ غ‬ٛ‫ذب رىذ‬ٙٔ‫ فا‬mutable ‫ذش‬١١‫ْ لبثٍخ ٌٍزغ‬ٛ‫ رى‬ٟ‫ اٌز‬sets ‫ػبد‬ّٛ‫اٌّغ‬
‫ لبثٍذخ‬frozensets ْ‫ فا‬ٜ‫خ أخش‬١‫ ِٓ ٔبؽ‬.dictionary keys ‫ط‬ِٛ‫ؼ لب‬١‫ب وّفبر‬ِٙ‫ّىٓ اعزخذا‬٠ ‫ٌزا ال‬
. dictionary keys ‫ط‬ِٛ‫ؼ ٌٍمب‬١‫ب وّفبر‬ِٙ‫ّىٓ اعزخذا‬٠ ‫ٌزا‬ٚ hashable ‫ٌٍزغضئخ‬
isdisjoint() ٚ intersection() ٚ difference() ٚ copy() ‫اي وذـ‬ٚ‫ذ ِٓ اٌذذ‬٠‫ع اٌؼذ‬ٌٕٛ‫ذػُ ٘زا ا‬٠
ُ‫ذذب ال رذذذػ‬ٕٙ‫ٌى‬ٚ union)( ٚ symmetric_difference() ٚ issuperset() ٚ issubset() ٚ
. immutable ‫ش‬١١‫ش لبثٍخ ٌٍزغ‬١‫ب غ‬ٙٔ add() ‫ئظبفخ اٌؼٕبصش ِضً اٌذاٌخ‬ٚ ‫اي ؽزف‬ٚ‫د‬
frozenset)( ‫ ثبعزخذاَ اٌذاٌخ‬Frozensets ‫ػبد‬ّٛ‫ّىٓ ئٔشبت ِغ‬٠ 
# Frozensets
# initialize A and B
A = frozenset([1, 2, 3, 4])
B = frozenset([3, 4, 5, 6])
print(A)
print(A | B)
print(A & B)
print(A - B)
print(A ^ B)
output
frozenset({1, 2, 3, 4})
frozenset({1, 2, 3, 4, 5, 6})
frozenset({3, 4})
frozenset({1, 2})
frozenset({1, 2, 5, 6})
Frozensets ‫ اٌؾزف ِغ‬ٚ‫اي اإلظبفخ أ‬ٚ‫ّىٓ اعزخذاَ د‬٠ ‫ ال‬
# Frozensets
# initialize A and B
A = frozenset([1, 2, 3, 4])
B = frozenset([3, 4, 5, 6])
C=A.add(3)
print(C)
output
C=A.add(3)
AttributeError: 'frozenset' object has no attribute 'add'
‫انذرس انثايٍ ‪ :‬انقايوس‬
‫)‪(Dictionary‬‬
‫‪ ‬عززؼٍُ ف‪٘ ٟ‬زا اٌجشٔبِظ اٌزؼٍ‪ِ ّٟ١‬ب ٘‪ ٛ‬اٌمبِ‪ٛ‬ط ‪ Dictionary‬فذ‪ٚ Python ٟ‬و‪١‬ف‪١‬ذخ ئٔشذبئٗ ‪ٚ‬و‪١‬ف‪١‬ذخ‬
‫اٌ‪ٛ‬ص‪ٛ‬ي ئٌ‪ٚ ٗ١‬ئظبفزٗ ‪ٚ‬ئصاٌزٗ ِٓ اٌؼٕبصش ‪ٚ‬اٌذ‪ٚ‬اي اٌّخزٍفخ اٌز‪٠ ٟ‬غت أْ رى‪ ْٛ‬ػٍ‪ ٝ‬دسا‪٠‬خ ث‪ٙ‬ب‪.‬‬
‫‪ : Dictionary‬اٌمبِ‪ٛ‬ط‬
‫٘‪ ٝ‬ػجبسح ػٓ عٍغٍخ غ‪١‬ش غ‪١‬ش ِشرجخ ِٓ ص‪ٚ‬ع‪ِ ٓ١‬شرج‪ّ٘ ٓ١‬ب ص‪ٚ‬ط اٌّفزبػ ‪ٚ‬اٌم‪ّ١‬خ أ‪ِ ٚ‬ب ‪٠‬ؼذشف ثذـبعُ‬
‫‪. key-value pairs‬‬
‫‪ٚ‬اٌمبِ‪ٛ‬ط ‪٘ dictionary‬ذ‪ٚ ٟ‬اؽذذح ِذٓ أٔذ‪ٛ‬اع اٌج‪١‬بٔذبد اٌّغذزخذِخ فذ‪ٚ .Python ٟ‬رغذزخذَ اٌمذ‪ٛ‬اِ‪١‬ظ‬
‫ثشىً ػبَ ِذغ اٌىّ‪١‬ذخ اٌ‪ٙ‬بئٍذخ ِذٓ اٌج‪١‬بٔذبد ‪ٚ‬رذُ رؾغذ‪ ٓ١‬اٌمذ‪ٛ‬اِ‪١‬ظ ‪ dictionary‬العذزشعبع اٌج‪١‬بٔذبد‬
‫ثغ‪ٌٛٙ‬خ ‪ٚ‬ثطش‪٠‬مخ عش‪٠‬ؼخ ‪.‬‬
‫‪٠‬غذذت أْ ٔؼذذشف اٌّفزذذبػ ‪ key‬العذذزشداد اٌم‪ّ١‬ذذخ ‪ٌٚ value‬ىذذٓ ٌذذ‪١‬ظ اٌؼىذذظ ‪ّ٠ٚ‬ىذذٓ أْ ‪٠‬ىذذ‪ ْٛ‬اٌّفزذذبػ‬
‫‪ٚ‬اٌم‪ّ١‬خ ِٓ أ‪ٛٔ ٞ‬ع ‪.‬‬
‫اٌمذذبِ‪ٛ‬ط ‪٘ dictionary‬ذذ‪ٚ ٟ‬اؽذذذح ِذذٓ ‪ 4‬أٔذذ‪ٛ‬اع ث‪١‬بٔذذبد ِعذذّٕخ فذذ‪ٚ Python ٟ‬اٌزذذ‪ ٟ‬رُغذذزخذَ ٌزخذذض‪ٓ٠‬‬
‫ِغّ‪ٛ‬ػذذذذخ ِذذذذٓ اٌج‪١‬بٔذذذذبد ‪ٚ‬اٌضالصذذذذخ ا خذذذذش‪٘ ٜ‬ذذذذ‪ٚ tuple ٚ Set ٚ lists ٟ‬وٍ‪ٙ‬ذذذذب راد خصذذذذبئص‬
‫‪ٚ‬اعزخذاِبد ِخزٍفخ ‪٠ٚ‬شبس ئٌ‪٘ ٝ‬زٖ ا ٔ‪ٛ‬اع ا سثؼخ ثبعُ اٌزغٍغالد ‪. sequences‬‬
‫عذب‬
‫أ‪ ٚ‬أ‪ٛٔ ٞ‬ع آخش ) وّب ‪ّ٠‬ىٓ أْ ‪٠‬ؾز‪ ٞٛ‬اٌمبِ‪ٛ‬ط ‪ dictionary‬ػٍ‪ ٝ‬لبِ‪ٛ‬ط ‪ dictionary‬آخش أ‪ً ٠‬‬
‫‪٠ٚ‬غّ‪ ٝ‬ف‪٘ ٟ‬زٖ اٌؾبٌخ ثبعُ ‪. nested dictionary‬‬
‫ث‪ّٕ١‬ب ‪ّ٠‬ىٓ أْ رى‪ ْٛ‬اٌم‪ ِٓ values ُ١‬أ‪ٛٔ ٞ‬ع ث‪١‬بٔبد وّب ‪ّ٠‬ىذٓ رىشاس٘ذب فذاْ اٌّفزذبػ ‪٠ key‬غذت أْ‬
‫‪٠‬ىذذ‪ِ ْٛ‬ذذٓ إٌذذ‪ٛ‬ع اٌضبثذذذ ‪ِ immutable type‬ضذذً (عٍغذذٍخ ‪ string‬أ‪ ٚ‬سلذذُ ‪ number‬أ‪ِ ٚ‬غّ‪ٛ‬ػذذخ‬
‫‪ِ tuple‬غ ػٕبصش غ‪١‬ش لبثٍخ ٌٍزغ‪١١‬ش ) ‪٠ٚ‬غت أْ رى‪ ْٛ‬ل‪ ُ١‬اٌّفزبػ ‪ key‬فش‪٠‬ذح ‪.‬‬
‫ٌإلػالْ ػٓ اٌمذ‪ٛ‬اِ‪١‬ظ ‪ dictionary‬أِذش عذ‪ِٚ ًٙ‬جبشذش ‪٠‬ذزُ رٌذه ػذٓ غش‪٠‬ذك ‪ٚ‬ظذغ اٌؼٕبصذش داخذً‬
‫ألذذذ‪ٛ‬اط } { ‪ِٚ‬فصذذذ‪ٛ‬ي ث‪ّٕٙ١‬ذذذب ثفبصذذذٍخ ‪ٚ Comma‬سِض٘ذذذب ( ‪ٔٚ ) ,‬فصذذذً ثذذذ‪ ٓ١‬وذذذً ‪key-value‬‬
‫ثبٌٕمطز‪ ٓ١‬اٌشئغ‪١‬ز‪ٚ colon ٓ١‬سِض٘ب ( ‪ ) :‬وب‪٢‬ر‪: ٟ‬‬
# empty dictionary
my_dict = {}
print(my_dict)
# dictionary with integer keys

my_dict = {1: 'apple', 2: 'ball'}
print(my_dict)
# dictionary with nested dictionary

my_dict = {
'fruit': 'apple',
'number':{'one':1 ,'two':2}
}
print(my_dict)
# dictionary with mixed keys

my_dict = {'name': 'John', 1: [2, 4, 3]}
print(my_dict)
print("\n")
#nested dictionary
myfamily = {"child1" : {"name" : "Emil","year" : 2004},
"child2" : {"name" : "Tobias", "year" : 2007},
"child3" : { "name" : "Linus", "year" : 2011 }
output
{}
{1: 'apple', 2: 'ball'}
{'fruit': 'apple', 'number': {'one': 1, 'two': 2}}
{'name': 'John', 1: [2, 4, 3]}
{'child1': {'name': 'Emil', 'year': 2004}, 'child2': {'name': 'Tobias', 'year': 2007},
'child3': {'name': 'Linus', 'year': 2011}}
ً ٠‫ّىٓ أ‬٠ 
‫ إلٔشذبت‬dict)( ‫ ثذـ‬ّٝ‫غذ‬٠ ٞ‫اٌذز‬ٚ constructor ‫ اٌ ُّٕشذئ‬ٚ‫ أ‬constructor ‫ذ‬١‫عب اعذزخذاَ اٌ ُّشذ‬
. ‫ذ٘ب‬٠‫ ٔش‬ٞ‫ػخ اٌز‬ّٛ‫ٓ اٌّغ‬١‫ع‬ٛ‫ٓ ل‬١‫ب ث‬ٍٙ‫ٔىزت ثذاخ‬ٚ dict)( ‫ش ٔىزت‬١‫ ؽ‬dictionary ‫ط‬ِٛ‫لب‬
# using dict()
my_dict = dict({1:'apple', 2:'ball'})
print(my_dict)
# from sequence having each item as a pair

my_dict = dict([(1,'apple'), (2,'ball')])
print(my_dict)
output
{1: 'apple', 2: 'ball'}
{1: 'apple', 2: 'ball'}
‫‪ٚ : dictionary Items‬ؽذاد اٌمبِ‪ٛ‬ط أ‪ ٚ‬ػٕبصش اٌمبِ‪ٛ‬ط‬
‫‪ o‬ػٕبصش غ‪١‬ش ِف‪ٙ‬شعخ ‪unindexed‬‬
‫‪٘ٚ‬زا ‪٠‬ؼٕ‪ ٟ‬أْ ال ‪ّ٠‬ىٓ اٌ‪ٛ‬ص‪ٛ‬ي ٌٍؼٕبصش ػٓ غش‪٠‬ك اٌف‪ٙ‬شط ‪. index‬‬
‫‪ o‬ػٕبصش غ‪١‬ش ِشرجخ ‪unordered‬‬

‫‪٘ٚ‬زا ‪٠‬ؼٕ‪ ٟ‬أْ اٌؼٕبصش ٌ‪١‬ظ ٌ‪ٙ‬ب رشر‪١‬ت ِؾذد ‪ٚ‬ال ‪ّ٠‬ىٕه اٌشع‪ٛ‬ع ئٌ‪ ٝ‬ػٕصش ثبعزخذاَ ف‪ٙ‬شط‪.‬‬
‫‪ o‬ػٕبصش لبثٍخ ٌٍزغ‪١١‬ش ‪changeable‬‬

‫‪٘ٚ‬زا ‪٠‬ؼٕ‪ ٟ‬أٔٗ ‪ّ٠‬ىٓ رغ‪١١‬ش ‪ٚ‬ئظبفخ ‪ٚ‬ئصاٌخ اٌؼٕبصش ف‪ ٟ‬اٌمبِ‪ٛ‬ط ثؼذ ئٔشبئ‪ٙ‬ب ‪.‬‬
‫‪ o‬ػٕبصش ال رغّؼ ثم‪ِ ُ١‬ىشسح ‪unduplicate values‬‬

‫‪٘ٚ‬زا ‪٠‬ؼٕ‪ ٟ‬أٔٗ ال ‪ّ٠‬ىٓ أْ رؾز‪ ٞٛ‬اٌّغّ‪ٛ‬ػخ ػٍ‪ِ ٝ‬فزبؽ‪ ٓ١‬ثٕفظ االعُ‪.‬‬
‫‪ : Access Dictionary Items‬اٌ‪ٛ‬ص‪ٛ‬ي ئٌ‪ ٝ‬ػٕبصش اٌمبِ‪ٛ‬ط‬

‫‪ّ٠‬ىٕه اٌ‪ٛ‬ص‪ٛ‬ي ئٌ‪ ٝ‬ػٕبصش اٌمبِ‪ٛ‬ط ثأوضش ِٓ غش‪٠‬مخ وب‪٢‬ر‪: ٟ‬‬
‫‪ ‬ػٓ غش‪٠‬ك ا ل‪ٛ‬اط اٌّشثؼخ ‪ٔٚ Square brackets‬ىزت ثذاخٍ‪ٙ‬ب اعُ اٌّفزبػ وب‪٢‬ر‪. ]key [ ٟ‬‬
‫‪ ‬ػٓ غش‪٠‬ك اٌذاٌخ )(‪ٔٚ get‬ىزت ثذاخٍ‪ٙ‬ب اعُ اٌّفزبػ وب‪٢‬ر‪. get(key) ٟ‬‬
‫‪# get vs [] for retrieving elements‬‬
‫}‪my_dict = {'name': 'Jack', 'age': 26‬‬
‫)]'‪print(my_dict['name‬‬ ‫‪# Output: Jack‬‬
‫))'‪print(my_dict.get('age‬‬ ‫‪# Output: 26‬‬
‫‪output‬‬
‫‪Jack‬‬
‫‪26‬‬
‫‪ ‬ئرا اعزخذِٕب اٌذاٌخ )(‪ get‬فغزشعغ اٌم‪ّ١‬خ ‪ None‬ئرا ٌُ ‪٠‬زُ اٌؼض‪ٛ‬س ػٍ‪ ٝ‬اٌّفزبػ‪.‬‬
‫‪# get vs [] for retrieving elements‬‬
‫}‪my_dict = {'name': 'Jack', 'age': 26‬‬
‫))'‪print(my_dict.get('address‬‬
‫‪output‬‬
‫‪None‬‬
‫‪ ‬ال ‪ّ٠‬ىٕٕب اٌ‪ٛ‬ص‪ٛ‬ي ئٌ‪ ٝ‬اٌؼٕبصش ثبعزخذاَ اٌف‪ٙ‬شعخ ‪ٚ index‬ػبِذً اٌزمط‪١‬ذغ ( ‪ ْ ) :‬اٌمذبِ‪ٛ‬ط ال ‪٠‬ذذػُ‬
‫اٌف‪ٙ‬شط ‪. index‬‬
.‫ط‬ِٛ‫ اٌمب‬ٟ‫د ِفزبػ ف‬ٛ‫ع‬ٚ َ‫ ؽبٌخ ػذ‬ٟ‫ ف‬KeyError ‫زُ سفغ‬١‫اط اٌّشثؼخ [ ] فغ‬ٛ‫ ئرا اعزخذِٕب ا ل‬
my_dict = {'name': 'Jack', 'age': 26}
print(my_dict['address'])
output
print(my_dict['address'])
KeyError: 'address'
. dictionary ‫ط‬ِٛ‫ داخً اٌمب‬keys ‫ؼ‬١‫غ اٌّفبر‬١ّ‫ؼ ؛ ٌّؼشفخ ع‬١‫ داٌخ اٌّفبر‬: keys() function 
. dictionary ‫ط‬ِٛ‫ داخً اٌمب‬values ُ١‫غ اٌم‬١ّ‫ُ ؛ ٌّؼشفخ ع‬١‫ داٌخ اٌم‬: values() function 
. dictionary ‫ط‬ِٛ‫ داخذً اٌمذب‬items ‫ذغ اٌؼٕبصذش‬١ّ‫ داٌخ اٌؼٕبصش ؛ ٌّؼشفخ ع‬: items() function 
. list ‫ لبئّخ‬ٟ‫ ف‬tuples ‫ػبد‬ّٛ‫ شىً ِغ‬ٟ‫ش ف‬ٙ‫ظ‬٠ dictionary ‫ط‬ِٛ‫ اٌمب‬ٟ‫ ف‬item ‫وً ػٕصش‬
thisdict = {
"brand": "Ford",
"model": "Mustang",
"year": 1964
}
# return a list of all the keys in the dictionary.

x = thisdict.keys()
print(x)
# return a list of all the values in the dictionary.

x = thisdict.values()
print(x)
# return each item in a dictionary, as tuples in a list.

x = thisdict.items()
print(x)
output
dict_keys(['brand', 'model', 'year'])
dict_values(['Ford', 'Mustang', 1964])
dict_items([('brand', 'Ford'), ('model', 'Mustang'), ('year', 1964)])
‫ط‬ِٛ‫ً ػٕبصش اٌمب‬٠‫ رؼذ‬: Modify dictionary Items
َ‫دح ثبعذذزخذا‬ٛ‫عذذ‬ٌّٛ‫ّذذخ اٌؼٕبصذذش ا‬١‫ذذش ل‬١١‫ رغ‬ٚ‫ذذذح أ‬٠‫ّىٕٕذذب ئظذذبفخ ػٕبصذذش عذ‬٠ ٞ‫ذذش أ‬١١‫ظ لبثٍذذخ ٌٍزغ‬١ِ‫ا‬ٛ‫اٌمذذ‬
.‫ذخ‬١ٌ‫ّذخ اٌؾب‬١‫ش اٌم‬٠‫زُ رؾذذ‬١‫دًا ثبٌفؼذً فغذ‬ٛ‫عذ‬ِٛ key ‫الػ أٔٗ ئرا وذبْ اٌّفزذبػ‬ٚ .)=( ‫ص‬١‫ػبًِ اٌزخص‬
.‫ط‬ِٛ‫ اٌمب‬ٌٝ‫) ئ‬key : value( ‫ذ‬٠‫ط عذ‬ٚ‫زُ ئظبفخ ص‬١‫ فغ‬key ‫د اٌّفزبػ‬ٛ‫ع‬ٚ َ‫ ؽبٌخ ػذ‬ٟ‫ف‬ٚ
# Changing and adding Dictionary Elements
my_dict = {'name': 'Jack', 'age': 26}
# update value
my_dict['age'] = 27
#Output: {'age': 27, 'name': 'Jack'}

print(my_dict)
# add item
my_dict['address'] = 'Downtown'
# Output: {'address': 'Downtown', 'age': 27, 'name': 'Jack'}

print(my_dict)
output
{'name': 'Jack', 'age': 27}
{'name': 'Jack', 'age': 27, 'address': 'Downtown'}
‫ط‬ِٛ‫ ئظبفخ ػٕبصش ٌٍمب‬: add dictionary Items

‫ذذك اٌذاٌذذخ‬٠‫ػذذٓ غش‬ٚ‫ّذذخ ٌذذٗ أ‬١‫ٓ ل‬١‫ذذ‬١‫رؼ‬ٚ ‫ذذذ‬٠‫ذذشط ِفزذذبػ عذ‬ٙ‫ط ثبعذذزخذاَ ف‬ِٛ‫ اٌمذذب‬ٝ‫ذذزُ ئظذذبفخ ػٕصذذش ئٌذذ‬٠
‫ ؽبٌذخ‬ٟ‫ فذ‬. ‫ش٘ذب وّؼذبِالد ٌٍذاٌذخ‬٠‫ذزُ رّش‬٠ ٟ‫ط ثبٌؼٕبصذش اٌزذ‬ِٛ‫ش اٌمذب‬٠‫ رؾذ‬ٍٝ‫ رؼًّ ػ‬ٟ‫ اٌز‬update()
‫ط‬ِٛ‫شٖ ػجبسح ػذٓ لذب‬٠‫زُ رّش‬٠ ٞ‫ْ اٌّؼبًِ اٌز‬ٛ‫غت أْ رى‬٠ .‫د اٌؼٕصش عززُ ئظبفخ اٌؼٕصش‬ٛ‫ع‬ٚ َ‫ػذ‬
. )key : value) ‫اط‬ٚ‫لبثال ٌٍزىشاس ِغ أص‬ ً ‫ وبئًٕب‬ٚ‫ أ‬dictionary
thisdict = {
"brand": "Ford",
"model": "Mustang",
"year": 1964
}
thisdict["color"] = "red"
print(thisdict)
thisdict.update({"color": "'blue"})
print(thisdict)
output
{'brand': 'Ford', 'model': 'Mustang', 'year': 1964, 'color': 'red'}
{'brand': 'Ford', 'model': 'Mustang', 'year': 1964, 'color': 'blue'}
‫ط‬ِٛ‫ ئصاٌخ ػٕبصش اٌمب‬: remove dictionary Items
: ‫ط‬ِٛ‫ٕ٘بن ػذح غشق إلصاٌخ اٌؼٕبصش ِٓ اٌمب‬
. ‫ داٌخ اإلصاٌخ ؛ إلصاٌخ اٌؼٕصش ثبعُ اٌّفزبػ اٌ ُّؾذد‬: pop() function 
. ‫ داٌخ ئصاٌخ اٌؼٕصش ؛ إلصاٌخ آخش ػٕصش ُِذسط‬: popitem() function 
. ‫ط‬ِٛ‫ داٌخ اٌّغؼ ؛ ٌّغؼ ػٕبصش اٌمب‬: clear() function 
. TypeError ٟ‫ب عزؼط‬ٙٔ‫ فا‬pop() ‫ ٌٍذاٌخ‬index ‫شط‬ٙ‫ ئرا ٌُ رؾذد اٌف‬

.ٜٛ‫ ِؾز‬ٍٝ‫ ػ‬ٞٛ‫ؾز‬٠ ‫دح ٌىٕٗ ال‬ٛ‫ع‬ِٛ ‫ط‬ِٛ‫ظً اٌمب‬٠ ٌٟ‫ثبٌزب‬ٚ ‫ط‬ِٛ‫غ اٌمب‬٠‫َ ثزفش‬ٛ‫ رم‬clear() ‫ اٌذاٌخ‬
.ًِ‫ط ثبٌىب‬ِٛ‫ الصاٌخ اٌمب‬ٚ‫ً اٌؼٕصش ثبعُ اٌّفزبػ اٌّؾذد أ‬٠‫ ٌزض‬del ‫خ‬١‫ّىٓ اعزخذاَ اٌىٍّخ ا عبع‬٠ 
# Removing elements from a dictionary
# create a dictionary
squares = {1: 1, 2: 4, 3: 9, 4: 16, 5: 25}
# remove a particular item, returns its value

print(squares.pop(4)) # Output: 16
print(squares) # Output: {1: 1, 2: 4, 3: 9, 5: 25}
# remove an arbitrary item, return (key,value)

print(squares.popitem()) # Output: (5, 25)
print(squares) # Output: {1: 1, 2: 4, 3: 9}
# remove all items

squares.clear()
print(squares) # Output: {}
output
16
{1: 1, 2: 4, 3: 9, 5: 25}
(5, 25)
{1: 1, 2: 4, 3: 9}
{}
: ٟ‫ر‬٢‫ خطأ وب‬ٟ‫ؼط‬١‫ب ع‬ٙ‫ط ثؼذ ؽزف‬ِٛ‫ الؽع ػٕذ غجبػخ اٌمب‬
thisdict = {"brand": "Ford","model": "Mustang","year": 1964}
del thisdict
print(thisdict) #this will cause an error because "thisdict" no longer exists.
output
print(thisdict) #this will cause an error because "thisdict" no longer exists.
NameError: name 'thisdict' is not defined
ْٛ‫ض‬٠‫ط داخً ٌغخ اٌجب‬ِٛ‫ اٌمب‬ٍٝ‫بد ػ‬١ٍّ‫ ػ‬: Python dictionary Operations
: ٟ‫ر‬٢‫ ا‬dictionary ‫ط‬ِٛ‫ اٌمب‬ٍٝ‫ّىٓ ئعشاؤ٘ب ػ‬٠ ٟ‫ اٌز‬Operations ‫بد‬١ٍّ‫ذ ِٓ اٌؼ‬٠‫ٕ٘بن اٌؼذ‬
‫ػخ‬ّٛ‫خ رىشاس اٌّغ‬١ٍّ‫ ػ‬: Tuple Iterating : ً‫ال‬ٚ‫ أ‬

ً‫س ػجذذش اٌؼٕبصذذش داخذذ‬ٚ‫ّىٕٕذذب اٌّذذش‬١‫ ف‬arrays ‫فبد‬ٛ‫ػجذذبسح ػذذٓ ِصذذف‬Tuple ‫ػذذخ‬ّٛ‫ٔظذ ًذشا ْ اٌّغ‬
. for ‫ ِضً ؽٍمخ‬Looping ‫خ‬٠‫ػخ ثبعزخذاَ اٌؾٍمخ اٌزىشاس‬ّٛ‫اٌّغ‬
# Iterating through a Dictionary
squares = {1: 1, 3: 9, 5: 25, 7: 49, 9: 81}
for i in squares:
print(squares[i])
output
1
9
25
49
81
‫ط‬ِٛ‫ داخً لب‬ٛ‫خ اخزجبس ػع‬١ٍّ‫ ػ‬: dictionary Membership Test : ً ‫ب‬١ٔ‫ صب‬
‫دح‬ٛ‫عذ‬ِٛ key ‫ّذخ ِفزذبػ‬١‫ط ٌؼًّ اخزجذبس ِذب ئرا وبٔذذ ل‬ِٛ‫خ داخً اٌمب‬٠ٛ‫ّىٓ اعزخذاَ ِؼبِالد اٌؼع‬٠
: ‫ػخ ّ٘ب‬ّٛ‫ٓ الخزجبس ػٕصش داخً ِغ‬١‫ٕ٘بن وٍّز‬ٚ ‫ أَ ال ؟‬dictionary ‫ط‬ِٛ‫داخً اٌمب‬
. ‫ط‬ِٛ‫ اٌمب‬ٟ‫ٓ ف‬١‫ ِؼ‬key ‫د‬ٛ‫ع‬ٚ ِٓ ‫خ رغزخذَ ٌٍزؾمك‬١‫ وٍّخ أعبع‬: in keyword 
.‫ط‬ِٛ‫ اٌمب‬ٟ‫ٓ ف‬١‫ ِؼ‬key ‫د‬ٛ‫ع‬ٚ َ‫خ رغزخذَ ٌٍزؾمك ِٓ ػذ‬١‫ وٍّخ أعبع‬: not in keyword 
# Membership Test for Dictionary Keys
squares = {1: 1, 3: 9, 5: 25, 7: 49, 9: 81}
print(1 in squares) # Output: True
print(2 not in squares) # Output: True
# membership tests for key only not value

print(49 in squares) # Output: False
# Membership Test for Dictionary Keys
squares = {1: 1, 3: 9, 5: 25, 7: 49, 9: 81}
print(1 in squares) # Output: True
print(2 not in squares) # Output: True
# membership tests for key only not value

print(49 in squares) # Output: False
output
True
True
False
True
True
False
ْٛ‫ض‬٠‫ط داخً ٌغخ اٌجب‬ِٛ‫اي اٌمب‬ٚ‫ د‬: Python dictionary methods
: ُ٘ dictionary ‫ط‬ِٛ‫ رزؼبًِ ِغ اٌمب‬ٟ‫اي اٌز‬ٚ‫ػخ ِٓ اٌذ‬ّٛ‫ٕ٘بن ِغ‬
. )ٓ‫ط (اٌىبئ‬ِٛ‫ي ػٕبصش اٌمب‬ٛ‫ي ؛ ٌّؼشفخ غ‬ٛ‫ داٌخ اٌط‬: len() function 
.‫ط‬ِٛ‫ اٌمب‬ٟ‫ذح ف‬٠‫ ِشرجخ عذ‬keys ‫ؼ‬١‫َ ثبسعبع لبئّخ ِفبر‬ٛ‫ت؛ رم‬١‫ داٌخ اٌزشر‬: sorted() function 
# Dictionary Built-in Functions

squares = {0: 0, 1: 1, 3: 9, 5: 25, 7: 49, 9: 81}
# Output: 6
print(len(squares))
output
6
[0, 1, 3, 5, 7, 9]
www.programiz.com ‫ ٘زا اٌشاثػ‬ٍٝ‫ّىٕه اٌعغػ ػ‬٠ ‫اي‬ٚ‫ذ ِٓ اٌذ‬٠‫ اٌّض‬ٍٝ‫ ٌٍزؼشف ػ‬
ْٛ‫ض‬٠‫ط داخً ٌغخ اٌجب‬ِٛ‫ُ اٌمب‬ٙ‫ ف‬: Python Dictionary Comprehension

‫ط لبثذً ٌٍزىذشاس‬ِٛ‫ذ ِٓ لب‬٠‫ط عذ‬ِٛ‫ِخزصشح إلٔشبت لب‬ٚ ‫مخ‬١ٔ‫مخ أ‬٠‫ غش‬dictionary ‫ط‬ِٛ‫ُ اٌمب‬ٙ‫ؼزجش ف‬٠
)key: value( ‫ذذش‬١‫ط ِذذٓ اٌزؼج‬ٚ‫ ِذذٓ ص‬Dictionary Comprehension ْٛ‫زىذذ‬٠ ٚ Python ٟ‫فذذ‬
.}{ ‫اط اٌّزؼشعخ‬ٛ‫ داخً ا ل‬for ‫ػب ثؼجبسح‬
ً ٛ‫ِزج‬
: dictionary = {key: value for vars in iterable}
. value ً‫ّض‬٠ٚ ُ‫ِشثغ اٌشل‬ٚ key ً‫ّض‬٠ٚ ُ‫ٓ ّ٘ب اٌشل‬١‫ع‬ٚ‫ط ػجبسح ػٓ ص‬ِٛ‫ ِضبي ٌؼًّ لب‬
# Dictionary Comprehension
squares = {x: x*x for x in range(6)}
print(squares)
#This code is equivalent to

squares = {}
for x in range(6):
squares[x] = x*x
print(squares)
output
{0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25}
{0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25}
. ‫اٌّضبي اٌغبثك‬ٚ Dictionary Comprehension ‫ٓ ثٕبت عٍّخ‬١‫ؼ ِمبسٔخ ث‬١‫ظ‬ٛ‫سح ٌز‬ٛ‫ ص‬
.‫ط آخش‬ِٛ‫بٔبد ِٓ لب‬١‫ط ثبعزخذاَ ث‬ِٛ‫ُ اٌمب‬ٙ‫ّىٕٕب اعزخذاَ ف‬٠ ١‫ الؽع و‬
#item price in dollars
old_price = {'milk': 1.02, 'coffee': 2.5, 'bread': 2.5}
dollar_to_pound = 0.76
new_price = {item: value*dollar_to_pound for (item, value) in old_price.items()}
print(new_price)
output
{'milk': 0.7752, 'coffee': 1.9, 'bread': 1.9}
ُٙ‫ اعزخذاَ ف‬.‫بد‬ٙ١ٕ‫ اٌغ‬ٌٝ‫ب ئ‬ٍٙ٠ٛ‫لّٕب ثزؾ‬ٚ ‫الس‬ٚ‫ إٔٔب اعزشعؼٕب أعؼبس ا صٕبف ثبٌذ‬ٜ‫ّىٕٕب أْ ٔش‬٠ 
.‫ش‬١‫ألصش ثىض‬ٚ ‫ّخ أثغػ‬ٌّٙ‫غؼً ٘زٖ ا‬٠ ‫ط‬ِٛ‫اٌمب‬
: ٟ‫ر‬٢‫ٗ وب‬١ٌ‫ ئ‬condition ‫ك اعزخذاَ ششغ‬٠‫ط ػٓ غش‬ِٛ‫ُ اٌمب‬ٙ‫ ف‬

#If Conditional Dictionary Comprehension
original_dict = {'jack': 38, 'michael': 48, 'guido': 57, 'john': 33}
even_dict = {k: v for (k, v) in original_dict.items() if v % 2 == 0}

print(even_dict)
output
{'jack': 38, 'michael': 48}
.‫ط‬ِٛ‫ُ اٌمب‬ٙ‫ ف‬ٟ‫ ف‬if ‫خ فمػ ثغجت عٍّخ‬١‫ع‬ٚ‫ّخ اٌض‬١‫ رّذ ئظبفخ اٌؼٕبصش راد اٌم‬ٜ‫ وّب ٔش‬
: ٟ‫ر‬٢‫ٗ وب‬١ٌ‫ ئ‬condition ‫ك اعزخذاَ أوضش ِٓ ششغ‬٠‫ط ػٓ غش‬ِٛ‫ُ اٌمب‬ٙ‫ ف‬
#Multiple if Conditional Dictionary Comprehension

original_dict = {'jack': 38, 'michael': 48, 'guido': 57, 'john': 33}
new_dict = {k: v for (k, v) in original_dict.items() if v % 2 != 0 if v < 40}

print(new_dict)
output
{'john': 33}
‫‪ ‬ف‪٘ ٟ‬زٖ اٌؾبٌخ رّذ ئظبفخ اٌؼٕبصش راد اٌم‪ّ١‬خ اٌفشد‪٠‬خ ا لً ِٓ ‪ 44‬فمػ ئٌ‪ ٝ‬اٌمبِ‪ٛ‬ط اٌغذ‪٠‬ذ ثغجت‬
‫عًّ ‪ if‬اٌّزؼذدح ف‪ ٟ‬ف‪ ُٙ‬اٌمبِ‪ٛ‬ط‪ .‬ئٔ‪ٙ‬ب رىبفئ ‪ٚ‬رؼًّ ؽ‪١‬ش ‪٠‬غت أْ ‪٠‬ى‪ ْٛ‬وال اٌششغ‪ ٓ١‬صؾ‪١‬ؾ‪.ٓ١‬‬
‫‪ ‬ف‪ ُٙ‬اٌمبِ‪ٛ‬ط ػٓ غش‪٠‬ك اعزخذاَ اٌغًّ اٌششغ‪١‬خ ‪ if-else‬وب‪٢‬ر‪: ٟ‬‬
‫}‪original_dict = {'jack': 38, 'michael': 48, 'guido': 57, 'john': 33‬‬
‫)'‪new_dict_1 = {k: ('old' if v > 40 else 'young‬‬

‫})(‪for (k, v) in original_dict.items‬‬
‫)‪print(new_dict_1‬‬
‫‪output‬‬
‫}'‪{'jack': 'young', 'michael': 'old', 'guido': 'old', 'john': 'young‬‬
‫‪ ‬ف‪٘ ٟ‬زٖ اٌؾبٌخ ‪٠‬زُ ئٔشبت لبِ‪ٛ‬ط عذ‪٠‬ذ ػجش ف‪ ُٙ‬اٌمبِ‪ٛ‬ط‪ٚ .‬اٌؼٕبصش اٌز‪ ٟ‬رجٍغ ل‪ّ١‬ز‪ٙ‬ب ‪ 44‬أ‪ ٚ‬أوضش ٌ‪ٙ‬ب‬
‫ل‪ّ١‬خ "‪ " old‬ف‪ ٟ‬ؽ‪ ٓ١‬أْ اٌؼٕبصش ا خش‪ٌٙ ٜ‬ب ل‪ّ١‬خ "‪." young‬‬
‫‪ ‬ف‪ ُٙ‬اٌمبِ‪ٛ‬ط ػٓ غش‪٠‬ك ف‪ ُٙ‬اٌم‪ٛ‬اِ‪١‬ظ اٌّزذاخٍخ ‪: Nested Dictionary Comprehension‬‬
‫{ = ‪dictionary‬‬
‫)‪k1: {k2: k1 * k2 for k2 in range(1, 6)} for k1 in range(2, 5‬‬
‫}‬
‫)‪print(dictionary‬‬
‫‪output‬‬
‫{‬
‫‪2: {1: 2, 2: 4, 3: 6, 4: 8, 5: 10},‬‬
‫‪3: {1: 3, 2: 6, 3: 9, 4: 12, 5: 15},‬‬
‫}‪4: {1: 4, 2: 8, 3: 12, 4: 16, 5: 20‬‬
‫}‬
‫‪ ‬ف‪٘ ٟ‬زٖ اٌؾبٌخ ‪٠‬زُ ئٔشبت لبِ‪ٛ‬ط عذ‪٠‬ذ ػجش ف‪ ُٙ‬اٌمبِ‪ٛ‬ط‪ٚ .‬اٌؼٕبصش اٌز‪ ٟ‬رجٍغ ل‪ّ١‬ز‪ٙ‬ب ‪ 44‬أ‪ ٚ‬أوضش ٌ‪ٙ‬ب‬
‫ل‪ّ١‬خ "‪ " old‬ف‪ ٟ‬ؽ‪ ٓ١‬أْ اٌؼٕبصش ا خش‪ٌٙ ٜ‬ب ل‪ّ١‬خ "‪." young‬‬
‫‪ ‬وّب رش‪ ٜ‬لّٕب ثجٕبت عذ‪ٚ‬ي اٌعشة ف‪ ٟ‬لبِ‪ٛ‬ط ِزذاخً ٌألسلبَ ِٓ ‪ 2‬ئٌ‪ .4 ٝ‬وٍّب رُ اعزخذاَ ف‪ُٙ‬‬
‫اٌمبِ‪ٛ‬ط اٌّزذاخً رجذأ ٌغخ ‪ Python‬أ‪ٚ‬الً ِٓ اٌؾٍمخ اٌخبسع‪١‬خ صُ رٕزمً ئٌ‪ ٝ‬اٌؾٍمخ اٌذاخٍ‪١‬خ‪.‬‬
‫‪ٕ٘ ‬بن ثشاِظ آخش‪ِ ٜ‬ىبفئخ ٌ‪ٙ‬زا إٌ‪ٛ‬ع اٌّضبٌ‪ ٓ١‬ا‪٢‬ر‪ّ٘ ٓ١١‬ب ِضبٌ‪ِ ٓ١‬ىبفئ‪ٌٍ ٓ١‬جشٔبِظ اٌغبثك ‪.‬‬
#the base program
dictionary = {
k1: {k2: k1 * k2 for k2 in range(1, 6)} for k1 in range(2, 5)
}
print(dictionary)
#the first program. So, the above code would be equivalent to:
dictionary = dict()
for k1 in range(2, 5):
dictionary[k1] = {k2: k1*k2 for k2 in range(1, 6)}
print(dictionary)
#the second program. It can further be unfolded:

dictionary = dict()
dictionary[k1] = dict()
dictionary[k1][k2] = k1*k2
print(dictionary)
output
{2: {1: 2, 2: 4, 3: 6, 4: 8, 5: 10}, 3: {1: 3, 2: 6, 3: 9, 4: 12, 5: 15}, 4: {1: 4, 2: 8, 3: 12, 4: 16, 5: 20}}
{2: {1: 2, 2: 4, 3: 6, 4: 8, 5: 10}, 3: {1: 3, 2: 6, 3: 9, 4: 12, 5: 15}, 4: {1: 4, 2: 8, 3: 12, 4: 16, 5: 20}}
{2: {1: 2, 2: 4, 3: 6, 4: 8, 5: 10}, 3: {1: 3, 2: 6, 3: 9, 4: 12, 5: 15}, 4: {1: 4, 2: 8, 3: 12, 4: 16, 5: 20}}
‫ظ‬١ِ‫ا‬ٛ‫ُ اٌم‬ٙ‫ضاد ف‬١ِّ : Advantages of Using Dictionary Comprehension 

ُٙ‫ اعزخذاَ ف‬ٞ‫إد‬٠ ْ‫ّىٓ أ‬٠ ‫شا‬١‫وض‬ً ‫ط‬ِٛ‫ئخ اٌمب‬١ٙ‫خ ر‬١ٍّ‫مًٍ ِٓ ػ‬٠ ‫ط‬ِٛ‫ُ اٌمب‬ٙ‫ فاْ ف‬ٜ‫وّب ٔش‬
.‫ ًّب‬١ٍ‫ إٌّطك ع‬ٍٝ‫د ِغ اٌؾفبظ ػ‬ٛ‫س اٌى‬ٛ‫ش عط‬١‫ رمص‬ٌٝ‫د اٌخب ثٕب ئ‬ٛ‫ اٌى‬ٟ‫ط ف‬ِٛ‫اٌمب‬
‫ط‬ِٛ‫ُ اٌمب‬ٙ‫ي اعزخذاَ ف‬ٛ‫شاد ؽ‬٠‫ رؾز‬: Warnings on Using Dictionary Comprehension 
‫غذ دائ ًّب‬١ٌ ‫ب‬ٙٔ‫ب ئال أ‬ٙ‫ً لشاتر‬ٙ‫غ‬٠ ‫مخ‬١ٔ‫خ أ‬١‫ّبد ثشِغ‬١ٍ‫ط سائغ ٌىزبثخ رؼ‬ِٛ‫ُ اٌمب‬ٙ‫ اٌشغُ ِٓ أْ ف‬ٍٝ‫ػ‬
:ٌٟ‫ اٌزب‬ٛ‫ إٌؾ‬ٍٝ‫ب ػ‬ِٙ‫ٓ أصٕبت اعزخذا‬٠‫ْ ؽزس‬ٛ‫غت أْ ٔى‬٠ ‫ش‬١‫ؼ ؽ‬١‫بس اٌصؾ‬١‫االخز‬
.‫ذ ِٓ اٌزاوشح‬٠‫ٍه اٌّض‬ٙ‫رغز‬ٚ ‫بًٔب عؼً اٌشفشح رؼًّ ثشىً أثطأ‬١‫ُ أؽ‬ٕٙ‫ّى‬٠ o
.‫د‬ٛ‫خ لشاتح اٌى‬١ٍ‫ً لبث‬١ٍ‫عب رم‬
ً ٠‫ُ أ‬ٕٙ‫ّى‬٠ o
ً ‫ ػذدًا‬ٚ‫ي أْ ٔالئُ ِٕطمًب صؼجًب أ‬ٚ‫غت أال ٔؾب‬٠ 

ً‫ُ فمػ ِٓ أعً عؼ‬ٍٙ‫ط ثذاخ‬ِٛ‫ُ اٌمب‬ٙ‫شا ِٓ اٌف‬١‫وج‬
.‫ ِضً اٌؾٍمبد‬ٜ‫بس ثذائً أخش‬١‫ ٘زٖ اٌؾبالد ِٓ ا فعً اخز‬ٟ‫ ف‬.‫د ِفشدًا‬ٛ‫اٌى‬
‫انذرس انتاسع ‪ :‬انقيى انًُطقية‬
‫)‪(boolean‬‬
‫‪٠‬ذذزُ ‪ّ٠‬ض‪ٍٙ١‬ذذب ‪ٚ‬أّ٘‪١‬ز‪ٙ‬ذذب‬ ‫‪ ‬عذذززؼٍُ فذذ‪٘ ٟ‬ذذزا اٌجشٔذذبِظ اٌزؼٍ‪ّ١‬ذذ‪ِ ٟ‬ذذب ٘ذذ‪ ٟ‬اٌمذذ‪ ُ١‬إٌّطم‪١‬ذذخ ‪ٚ Boolean‬و‪١‬ذ‬
‫داخً ٌغخ ‪. python‬‬
‫‪ : boolean‬اٌم‪ ُ١‬إٌّطم‪١‬خ‬
‫٘‪ ٝ‬ػجبسح ػٓ ل‪ّ١‬ز‪٠ ٓ١‬زُ اعزخذاِ‪ٌ ُٙ‬ج‪١‬بْ ؽبٌخ اٌغٍّخ أ ٌزم‪١‬ذ‪ ُ١‬رؼج‪١‬ذش ثٕذب ًت ػٍذ‪ ٝ‬شذشغ ِؼذ‪ ٓ١‬داخذً ٌغذخ‬
‫اٌجب‪٠‬ض‪٠ٚ ْٛ‬زُ رّض‪ ً١‬اٌم‪ ُ١‬إٌّطم‪١‬خ ثأؽذ اٌم‪ّ١‬ز‪ ٓ١‬ا‪٢‬ر‪١‬ز‪: ٓ١‬‬
‫‪ : True ‬صؾ‪١‬ؼ ‪٠ٚ‬ؼجش ػٕ‪ٙ‬ب ف‪ ٟ‬اٌجشٔبِظ ثبٌشلُ ‪ِٚ 1‬ؼٕب٘ب رؾمك اٌششغ ‪.‬‬
‫‪ : False ‬خطأ ‪٠ٚ‬ؼجش ػٕ‪ٙ‬ب ف‪ ٟ‬اٌجشٔبِظ ثبٌشلُ ‪ِٚ 0‬ؼٕب٘ب ػذَ رؾمك اٌششغ ‪.‬‬
‫غبٌجًب ِب رؾزبط ف‪ ٟ‬اٌجشِغذخ ئٌذ‪ِ ٝ‬ؼشفذخ ِذب ئرا وذبْ اٌزؼج‪١‬ذش ‪ expresion‬رؼج‪١‬ذش صذؾ‪١‬ؼ أَ رؼج‪١‬ذش خطذأ‪.‬‬
‫‪ّ٠‬ىٕه رم‪ ُ١١‬أ‪ ٞ‬رؼج‪١‬ش ف‪ ٟ‬ثب‪٠‬ض‪ٚ ْٛ‬اٌؾص‪ٛ‬ي ػٍ‪ ٝ‬ئؽذ‪ ٜ‬ئعبثز‪ True ٓ١‬أ‪. False ٚ‬‬
‫ٌإلػالْ ػٓ ل‪ّ١‬خ ِٕطم‪١‬خ ‪ Boolean‬أِش ع‪ِٚ ًٙ‬جبشش ‪٠‬زُ رٌه ػٓ غش‪٠‬ك رخص‪١‬ص ئؽذ‪ ٜ‬ل‪١ّ١‬زذ‪ٓ١‬‬
‫ٌٍّزغ‪١‬ش ئِب ٔخصص اٌم‪ّ١‬خ ‪ Tue‬أ‪ ٚ‬اٌم‪ّ١‬خ ‪ False‬وب‪٢‬ر‪: ٟ‬‬
‫‪a=True‬‬
‫‪b=False‬‬
‫)‪print(a‬‬
‫)‪print(b‬‬
‫‪output‬‬
‫‪True‬‬
‫‪False‬‬
‫ػٕذذ ِمبسٔذخ ل‪ّ١‬زذ‪٠ ٓ١‬ذزُ رم‪١‬ذ‪ ُ١‬اٌزؼج‪١‬ذش ‪ٚ‬رشعذغ ‪ Python‬اإلعبثذخ إٌّطم‪١‬ذخ ‪ Boolean‬أ‪ ٞ‬ثزشعذغ ئِذب‬
‫‪ True‬أ‪. False ٚ‬‬
‫)‪print(10 > 9‬‬
‫)‪print(10 == 9‬‬
‫)‪print(10 < 9‬‬
‫‪output‬‬
‫‪True‬‬
‫‪False‬‬
‫‪False‬‬
‫شاد‬١‫اٌّزغ‬ٚ ُ١‫ُ اٌم‬١١‫ رم‬: Evaluate Values and Variables
‫ذخ‬١‫ّذخ ِٕطم‬١‫ ل‬ٝ‫ذش ئٌذ‬١‫ ِزغ‬ٚ‫ّذخ أ‬١‫ ل‬ٞ‫ذً أ‬٠ٛ‫ْ ثزؾ‬ٛ‫ض‬٠‫َ ٌغخ اٌجب‬ٛ‫ش رم‬١‫ش ؽ‬١‫ ِزغ‬ٞ‫ أ‬ٚ‫ّخ أ‬١‫ ل‬ٞ‫ُ أ‬١١‫ّىٓ رم‬٠
ُ‫ذز‬٠ٚ standard truth testing procedure ٟ‫بعذ‬١‫مذخ اٌم‬١‫ ثبعزخذاَ ئعشات اخزجذبس اٌؾم‬Boolean
ً‫ اٌّمبثذ‬ٟ‫ذه فذ‬١‫رؼط‬ٚ ‫ّذخ‬١‫ ل‬ٞ‫ُ أ‬١١‫ش رغّؼ ٌه ٘زٖ اٌذاٌخ ثزم‬١‫ ؽ‬bool() ‫ك اعزخذاَ اٌذاٌخ‬٠‫رٌه ػٓ غش‬
. False ٚ‫ أ‬True
.)False ٚ‫ أ‬True( ‫خ‬١‫ّخ ِٕطم‬١‫ ل‬ٌٝ‫ّخ ئ‬١‫ً اٌم‬٠ٛ‫خ ؛ ٌزؾ‬١‫ُ إٌّطم‬١‫ داٌخ اٌم‬: bool() function 
: bool([value])
‫ش٘ب‬٠‫ّىٓ رّش‬٠ ٟ‫ُ اٌّؼبِالد اٌز‬١‫ ل‬: Parameter Values 

. ِٕٗ ‫ة اٌزؾمك‬ٍٛ‫ اٌىبئٓ اٌّط‬: value 
bool)( ‫ّذذخ فذذاْ اٌذاٌذذخ‬١‫ذذش ل‬٠‫ ؽبٌذذخ ػذذذَ رّش‬ٟ‫فذذ‬ٚ bool)( ٝ‫ّذذخ ئٌذذ‬١‫ذذش ل‬٠‫ رّش‬ٞ‫س‬ٚ‫ظ ِذذٓ اٌعذذش‬١‫ٌذذ‬
. False ‫ّخ‬١‫عزشعغ اٌم‬
#Evaluate values
print(bool("Hello"))
print(bool(15))
#Evaluate variables
x = "Hello"
y = 15
print(bool(x))
print(bool(y))
output
True
True
True
True
True ٟ‫ رؼط‬ٟ‫ُ اٌز‬١‫ اٌم‬: True Values 

: ً‫ ِض‬ٜٛ‫ع ِٓ اٌّؾز‬ٛٔ ٍٝ‫ ػ‬ٞٛ‫ ئرا وبٔذ رؾز‬True ٌٝ‫جًب ئ‬٠‫ّخ رمش‬١‫ ل‬ٞ‫ُ أ‬١١‫زُ رم‬٠
. empty strings ‫ ِبػذا اٌغالعً اٌفبسغخ‬True ْٛ‫ رى‬strings ً‫ اٌغالع‬o
. 0 ‫ّخ‬١‫ ِبػذا اٌم‬True ْٛ‫ى‬٠ numbers َ‫ ا سلب‬o
‫ ثبعزضٕبت‬True ْٛ‫ رى‬Dictionary ٚ set ٚ tuple ٚ list ً‫ ِض‬sequences ‫ اٌّزغٍغالد‬o
. empty object ‫اٌىبئٕبد اٌفبسغخ‬
. True ‫ّخ‬١‫ اٌم‬ٚ‫ أ‬1 ‫ّخ‬١‫ اٌم‬o
False ٟ‫ رؼط‬ٟ‫ُ اٌز‬١‫ اٌم‬: False Values 
: empty values ‫ُ اٌفبسغخ‬١‫ ثبعزضٕبت اٌم‬False ٌٝ‫ب ئ‬ّٙ١١‫زُ رم‬٠ ‫شح‬١‫ُ وض‬١‫عذ ل‬ٛ‫الغ ال ر‬ٌٛ‫ ا‬ٟ‫ف‬
. ''' ''' ٚ‫ """ """ أ‬ٚ‫ ' ' أ‬ٚ‫ اٌغالعً اٌفبسغخ ِضً " " أ‬o
. 0j ٚ‫ أ‬0.0 ٚ‫ أ‬0 ً‫ ا سلبَ اٌفبسغخ ِض‬o
. } { ٚ ] [ ٚ ) ( : ً‫ اٌّزغٍغالد اٌفبسغخ ِض‬o
. False ‫ّخ‬١‫اٌم‬ٚ None ‫ّخ‬١‫ اٌم‬o
. False ٚ‫ أ‬0 ‫ رُشعغ‬ٟ‫__ اٌز‬len__() ٚ‫ __ أ‬bool)(__ ٍٝ‫ ػ‬ٞٛ‫ رؾز‬ٟ‫ وبئٕبد اٌفئبد اٌز‬o
test = []
print(test,'is',bool(test))
test = [0]
test = 0.0
test = None
test = True
test = 'Easy string'

output
[] is False
[0] is True
0.0 is False
None is False
True is True
Easy string is True
‫ْ ِٓ فئخ راد‬ٛ‫ه وبئٓ ِى‬٠‫رٌه ئرا وبْ ٌذ‬ٚ False ٌٝ‫ ٘زٖ اٌؾبٌخ ئ‬ٟ‫ وبئٓ آخش ف‬ٚ‫ّخ أ‬١‫ُ ل‬١١‫زُ رم‬٠ 
. False ٚ‫ أ‬0 ‫ رُشعغ‬ٚ‫__ أ‬len__() ‫ داٌخ‬ٚ‫ __ أ‬bool)(__ ‫داٌخ‬
class myclass():
def __len__(self):
return 0
myobj = myclass()
print(bool(myobj))
output
False
‫خ‬١‫ّخ ِٕطم‬١‫ رُشعغ ل‬ٟ‫اي اٌز‬ٚ‫ اٌذ‬: Functions can Return a Boolean
‫خ‬١‫ّخ ِٕطم‬١‫ رُشعغ ل‬ٟ‫ اٌز‬functions ‫اي‬ٚ‫ّىٓ ئٔشبت د‬٠
# create functions that returns a Boolean Value:

def myFunction() :
return True
print(myFunction())
# execute code based on the Boolean answer of a function:

def myFunction() :
return True
if myFunction():
print("YES!")
else:
print("NO!")
output
True
YES!
Boolean ‫ذخ‬١‫ّذخ ِٕطم‬١‫ رُشعذغ ل‬ٟ‫اي اٌ ُّعذّٕخ اٌزذ‬ٚ‫ذ ِٓ اٌذ‬٠‫ اٌؼذ‬ٍٝ‫عب ػ‬

ً ٠‫ أ‬Python ‫ ٌغخ‬ٞٛ‫ رؾز‬
.ٓ١‫بٔبد ِؼ‬١‫ع ث‬ٛٔ ِٓ ٓ‫ذ ِب ئرا وبْ اٌىبئ‬٠‫ب ٌزؾذ‬ِٙ‫ّىٓ اعزخذا‬٠ ٟ‫اٌز‬ٚ isinstance() ‫ِضً اٌذاٌخ‬
x = 200
print(isinstance(x, int))
output
True
‫انخاتًة‬
‫ئٌذذ‪ٕ٘ ٝ‬ذذب ٔىذذ‪ ْٛ‬لذذذ أز‪ٕ١ٙ‬ذذب ِذذٓ اٌغذذضت اٌشاثذذغ ‪٘ٚ‬ذذ‪ِ ٛ‬ذذب اخذذزص ثذاسعذذخ أٔذذ‪ٛ‬اع اٌج‪١‬بٔذذبد اٌزذذ‪ ٟ‬رذذذػّ‪ٙ‬ب ٌغذذخ‬
‫اٌجذب‪٠‬ض‪ٚ ْٛ‬اٌّؼذش‪ٚ‬ف ثبعذُ ‪ٚ Python data types‬فذ‪ ٟ‬اٌذذس‪ٚ‬ط اٌمبدِذخ عذ‪ٛ‬ف ٔزؼذشف ػٍذ‪ ٝ‬و‪١‬ف‪١‬ذخ‬
‫اٌزؼبًِ ِغ اٌٍّفبد ‪ files‬داخً ٌغخ اٌجب‪٠‬ض‪ٚ ْٛ‬اٌّؼش‪ٚ‬فخ ثبعُ ‪. Python File I/O‬‬
‫ِذذذذذذٓ ثذذذذذذبة ا ِبٔذذذذذذخ اٌؼٍّ‪١‬ذذذذذذخ ف‪ٙ‬ذذذذذذزا اٌىزذذذذذذبة ٘ذذذذذذ‪ ٛ‬ؽصذذذذذذ‪ٍ١‬خ ‪ٚ‬رغّ‪١‬ؼذذذذذذخ ِؼٍ‪ِٛ‬ذذذذذذبد ِذذذذذذٓ ِ‪ٛ‬لذذذذذذغ‬
‫‪ٚ /https://www.programiz.com‬رُ عشد وذً دس‪ٚ‬ط ٘ذزٖ اٌغٍغذٍخ ثذٕفظ رغٍغذً ٘ذزا اٌّ‪ٛ‬لذغ ‪.‬‬
‫وّب االعزؼبٔخ ثّ‪ٛ‬لغ ‪. https://www.w3schools.com‬‬
‫٘ذذذزا اٌىزذذذبة ٘ذذذ‪ ٛ‬صذذذذلخ عبس‪٠‬ذذذخ ػذذذٓ ٔفغذذذ‪ٚ ٟ‬أ٘ذذذً ث‪١‬زذذذ‪ٚ ٟ‬أؽجذذذبث‪ٚ ٟ‬أعذذذأي أْ ‪٠‬زمجذذذً ٘ذذذزا اٌؼّذذذً‬
‫‪٠ٚ‬غٍؼذذذٗ خبٌصذذذب ً ٌ‪ٛ‬ع‪ٙ‬ذذذٗ اٌىذذذش‪ٚ . ُ٠‬وّذذذب ‪ٚ‬ظذذذؼزٗ ثذذذ‪ ٓ١‬أ‪٠‬ذذذذوُ ٌزٕذذذبٌ‪ٛ‬ا ِٕذذذٗ ػٍّذذذب ً ‪ٌٚ‬ذذذ‪ ٛ‬وذذذبْ ‪٠‬غذذذ‪١‬شا ً‬
‫ف‪ّ١‬ىذذذٕىُ أ‪٠‬عذذذب ً ٔشذذذشٖ ػٍذذذ‪ ٝ‬أ‪ِٛ ٞ‬لذذذغ ‪ٚ‬رؼذذذذ‪ِ ً٠‬ؾزذذذ‪ٛ‬اٖ ثّذذذب ‪٠‬خذذذذَ إٌذذذبط ‪ٚ‬االلزجذذذبط ِٕذذذٗ أ‪٠‬عذذذب ً وّذذذب‬
‫رشبت‪ ْٚ‬ثذ‪ ْٚ‬اعزئزاْ‪.‬‬
‫‪٠ ِٓٚ‬شغت ف‪ٔ ٟ‬غخخ ‪٘ ِٓ Word‬زا اٌىزبة ف‪ّ١‬ىٕٗ أْ ‪٠‬شاعٍٕ‪ ٝ‬ػٍ‪ ٝ‬اإل‪١ّ٠‬الد ‪.‬‬
‫سؽذذذُ سعذذذالً أ٘ذذذذ‪ٌ ٜ‬ذذذ‪ ٟ‬ػ‪١‬ذذذ‪ٛ‬ث‪ ٟ‬أسعذذذ‪ِ ٛ‬ذذذٓ وذذذً شذذذخص ‪٠‬مذذذشأ ٘ذذذزا اٌىزذذذبة ئرا ‪ٚ‬لذذذ ػٕذذذذ خطذذذأ‬
‫ػٍّذذذ‪ ٝ‬أ‪ ٚ‬خطذذذأ ئِالئذذذ‪ ٟ‬أ‪ِ ٚ‬ؼٍ‪ِٛ‬ذذذخ لذذذذ ‪٠‬غذذذبت ف‪ّٙٙ‬ذذذب أْ ‪٠‬شاعذذذٍٕ‪ ٟ‬ػٍذذذ‪ ٝ‬اإل‪ّ٠‬ذذذ‪١‬الد ا‪٢‬ر‪١‬ذذذخ ٌىذذذ‪ ٝ‬ألذذذ‪َٛ‬‬
‫ثاصالؽٗ ف‪ ٟ‬اٌطجؼبد ا‪٢‬خش‪ ٜ‬وّب أسع‪ ٛ‬أال رٕغ‪ٔٛ‬ب ِٓ صبٌؼ دػ‪ٛ‬ارىُ ‪.‬‬
‫‪E-mail : mmasoliman19962020@gmail.com‬‬
‫‪E-FaceBook : Mahmoud Soliman‬‬
‫‪Youtube : https://www.youtube.com/channel/UCfZvWjnYnfxI55v4LNhBekA‬‬
‫نتحًيم جًيع انكتب انخاصة بُا يًكٍ يتابعة قُاتي عهى انتيهيجزاو يٍ خالل هذا انزابط ‪:‬‬
‫‪Telegram Channel : https://t.me/joinchat/-aC4Ps0pna5lY2M0‬‬
‫نتحًيم جًيع انكتب انخاصة بُا يًكٍ يتابعة صفحتي عهى انفيس بوك يٍ خالل هذا انزابط ‪:‬‬
‫‪Public Page: Help-me-page‬‬
‫‪Mahmoud Soliman‬‬
The Way To Python 4 … Data types …. ‫ الطريق إلى برمجة بلغة البايثون‬..… Author , Eng/ Mahmoud 11

4 - Data Types

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

4 - Data Types

Uploaded by

Copyright:

Available Formats

The Way To Python 4 … Data types …. ‫ الطريق إلى لغة البايثون‬..

… Author , Eng/ Mahmoud Soliman 1

‫انفصم األول ‪ :‬يقذية في أَواع انبياَات ‪3.................................... Introduction to Data types‬‬

‫انفصم انثانث ‪ :‬األرقاو ‪11................. ................................ ................................ Numbers‬‬

‫انفصم انزابع ‪ :‬انسالسم ‪22.................. ................................ ................................ Strings‬‬

‫انفصم انخايس ‪ :‬انقوائى ‪31..................... ................................ ................................ Lists‬‬

‫انفصم انسادس ‪ :‬انتعذيذ أو انًجًوعات ‪44................................. ................................ Tuples‬‬

‫انفصم انسابع ‪ :‬انتشكيالت أو انًجًوعات ‪66................................... ................................ Sets‬‬

‫انفصم انثايٍ ‪ :‬انقايوس ‪22............................................ ................................ Dictionary‬‬

‫انفصم انثانث ‪ :‬انقيى انًُطقية ‪13......................................... ................................ Booleans‬‬

‫انخاتًة ‪12 ................................................................................................‬‬

‫انذرس األول ‪ :‬يقذية في أَواع انبياَات‬

‫'!‪s = 'Hello world‬‬

‫'‪# s[4] = 'o‬‬

‫'‪# s[6:11] = 'world‬‬

‫صبٌضب ً ‪ : Python Lists‬اٌم‪ٛ‬ائُ داخً ٌغخ ثب‪٠‬ض‪: ْٛ‬‬

‫‪# a[2] = 15‬‬

‫]‪# a[0:3] = [5, 10, 15‬‬

‫]‪# a[5:] = [30, 35, 40‬‬

‫ساثؼب ً ‪ : Python Tuples‬اٌم‪ٛ‬ائُ داخً ٌغخ ثب‪٠‬ض‪: ْٛ‬‬

‫)‪t = (5,'program', 1+3j‬‬

‫)‪t = (5,'program', 1+3j‬‬

‫'‪# t[1] = 'program‬‬

‫))‪# t[0:3] = (5, 'program', (1+3j‬‬

# printing set variable

# data type of variable a

‫عبدعب ً ‪ :Python dictionary‬اٌمبِ‪ٛ‬ط داخً ٌغخ ثب‪٠‬ض‪: ْٛ‬‬

‫;)]‪print("d[1] = ", d[1‬‬

‫;)]'‪print("d['key'] = ", d['key‬‬

‫‪# Generates error‬‬

‫عبثؼب ً ‪ :Python boolean‬اٌم‪ ُ١‬إٌّطم‪١‬خ داخً ٌغخ ثب‪٠‬ض‪: ْٛ‬‬

‫‪٠‬ى‪ ْٛ‬اٌزؼج‪١‬ش صؾ‪١‬ؾب ً ‪ True‬ف‪ ٟ‬ؽبٌخ رؾمك اٌششغ أ‪ ٚ‬اٌزؼج‪١‬ش ‪.‬‬

‫)‪print(10 > 9‬‬

‫)‪print(10 < 9‬‬

: float ٌٝ‫ ئ‬integer ‫بٔبد‬١‫ع ث‬ٛٔ ِٓ ً٠ٛ‫ ِضبي رؾ‬

. ‫ اٌصفش‬ٌٝ‫غؼٍٗ ألشة ئ‬٠ٚ ‫ّخ‬١‫مطغ اٌم‬١‫ ع‬

. ٜ‫ أخش‬ٌٝ‫ ئ‬sequence ‫خ‬١ٌ‫ً ِٓ ِززب‬٠ٛ‫ّىٕٕب رؾ‬٠ ‫ ِضبي‬

‫ع‬ٌٕٛ‫ً ا‬٠ٛ‫ رؾ‬: Type Conversion 

num_new = num_int + num_flo

Value of num_new: 124.23

print("Data type of num_int:",type(num_int))

Traceback (most recent call last):

‫ذش‬١١‫ رغ‬ٟ‫ٍمذ‬٠ َ‫" ْ اٌّغذزخذ‬typecasting" ‫ظ‬١‫عذب اعذُ اٌزٍجذ‬

: ٟ‫ر‬٢‫ع وب‬ٌٕٛ‫ العزخذاَ ٘زا ا‬Syntax ‫ شىً ثٕبت اٌغٍّخ‬

: ‫ؼ‬٠‫ً اٌصش‬٠ٛ‫ك اٌزؾ‬٠‫ ػٓ غش‬int ٚ string ‫ ئظبفخ‬ٍٝ‫ ِضبي ػ‬

print("Data type of num_int:",type(num_int))

num_sum = num_int + num_str

print("Sum of num_int and num_str:",num_sum)

Data type of num_str after Type Casting: <class 'int'>

Sum of num_int and num_str: 579

‫‪ ‬و‪١‬ف‪١‬خ ِؼشفخ ٔ‪ٛ‬ع اٌىبئٓ ف‪ٕ٘ : Python ٟ‬بن داٌز‪ّ٘ ٓ١‬ب‬

‫‪ : Parameter Values ‬ل‪ ُ١‬اٌّؼبِالد اٌز‪ّ٠ ٟ‬ىٓ رّش‪٠‬ش٘ب‬

‫‪ : Parameter Values ‬ل‪ ُ١‬اٌّؼبِالد اٌز‪ّ٠ ٟ‬ىٓ رّش‪٠‬ش٘ب‬

‫ثؼط ا ِضٍخ ػٍ‪ ٝ‬داٌخ )(‪ٚ type‬داٌخ )(‪isinstance‬‬

print("This is Exmples of type() function ")

print("\n" + "This is Exmples of isinstance() function ")

This is Exmples of isinstance() function

‫‪ : float ‬ا سلبَ اٌؼشش‪٠‬خ ‪ِ floating numbers‬ضً ‪ 5.4‬أ‪-5.4 ٚ‬‬

-2-5j ٚ‫ أ‬2+5j ً‫ ِض‬complex numbers ‫ ا سلبَ اٌّشوجخ‬: complex 

print("complex data types")

#convert from int to float:

#convert from float to int:

#convert from int to complex: