fix(guide): simplify directory structure

guide/arabic/python/data-structures/dictionaries/index.md

@@ -0,0 +1,118 @@
+---
+title: The Python Dict
+localeTitle: بيثون ديكت
+---
+القاموس (المعروف أيضا باسم "dict") في python هو نوع بيانات مدمج يمكن استخدامه لتخزين أزواج **`key-value`** . يتيح لك ذلك التعامل مع نظام **`dict`** كما لو كان _قاعدة بيانات_ لتخزين البيانات وتنظيمها.
+
+الشيء الخاص حول القواميس هو الطريقة التي يتم تنفيذها بها. تجعل بنية تشبه جدول التجزئة من السهل التحقق وجود - وهذا يعني أنه يمكننا بسهولة تحديد ما إذا كان هناك مفتاح معين موجود في القاموس دون الحاجة إلى فحصه كل عنصر. يمكن لمترجم Python فقط الذهاب إلى مفتاح الموقع والتحقق من وجود المفتاح.
+
+يمكن للقواميس استخدام أي نوع من أنواع البيانات الاعتباطية ، مثل السلاسل والأعداد الصحيحة إلخ ، للمفاتيح. ومع ذلك ، القيم غير قابلة للغسل ، بمعنى أنه لا يمكن استخدام القيم التي تحتوي على قوائم أو قواميس أو أنواع أخرى قابلة للتغيير (والتي تتم مقارنتها بقيمة بدلاً من هوية الكائن) كمفاتيح. تخضع الأنواع الرقمية المستخدمة للمفاتيح للقواعد العادية للمقارنة الرقمية: إذا كان هناك مقارنة بين رقمين متساويين (مثل `1` و `1.0` ) ، فيمكن استخدامهما بشكل متبادل لفهرسة إدخال القاموس نفسه. (لاحظ مع ذلك أنه بما أن أجهزة الكمبيوتر تقوم بتخزين أرقام الفاصلة العائمة في شكل تقديرات ، فمن غير المعتاد عادة استخدامها كمفاتيح قاموس.)
+
+أحد أهم متطلبات القاموس هو أن المفاتيح **يجب أن** تكون فريدة.  
+لإنشاء قاموس فارغ ، استخدم زوجًا من الأقواس:
+
+ `    >>> teams = {} 
+    >>> type(teams) 
+    >>> <class 'dict'> 
+` 
+
+  
+لإنشاء قاموس غير فارغ يحتوي على بعض القيم المبدئية ، ضع قائمة مفصولة بفواصل من أزواج القيم الرئيسية:
+
+ `    >>> teams = {'barcelona': 1875, 'chelsea': 1910} 
+    >>> teams 
+    {'barcelona': 1875, 'chelsea': 1910} 
+` 
+
+من السهل إضافة أزواج قيمة رئيسية إلى قاموس حالي:
+
+ `    >>> teams['santos'] = 1787 
+    >>> teams 
+    {'chelsea': 1910, 'barcelona': 1875, 'santos': 1787} # Notice the order - Dictionaries are unordered ! 
+    >>> # extracting value - Just provide the key 
+    ... 
+    >>> teams['barcelona'] 
+    1875 
+` 
+
+  
+يتم استخدام المشغل **`del`** لحذف زوج قيمة مفتاح من dict. في السيناريوهات التي يتم فيها استخدام مفتاح قيد الاستخدام مرة أخرى لتخزين القيم ، يتم فقد القيمة القديمة المرتبطة بهذا المفتاح تمامًا. ضع في اعتبارك أيضًا أنه من الخطأ استخلاص القيمة باستخدام مفتاح غير موجود.
+
+ `    >>> del teams['santos'] 
+    >>> teams 
+    {'chelsea': 1910, 'barcelona': 1875} 
+    >>> teams['chelsea'] = 2017 # overwriting 
+    >>> teams 
+    {'chelsea': 2017, 'barcelona': 1875} 
+` 
+
+  
+**`in`** الكلمة الأساسية يمكن استخدامها للتحقق من وجود مفتاح في الأمر أم لا:
+
+ `    >>> 'sanots' in teams 
+    False 
+    >>> 'barcelona' in teams 
+    True 
+    >>> 'chelsea' not in teams 
+    False 
+` 
+
+  
+**`keys`** هي _طريقة_ المضمنة التي يمكن استخدامها للحصول على مفاتيح قاموس معين. لاستخراج المفاتيح الموجودة في dict كقوائم:
+
+ `    >>> club_names = list(teams.keys()) 
+    >>> club_names 
+    ['chelsea', 'barcelona'] 
+` 
+
+  
+هناك طريقة أخرى لإنشاء القاموس تستخدم طريقة **`dict()`** :
+
+ `    >>> players = dict( [('messi','argentina'), ('ronaldo','portugal'), ('kaka','brazil')] ) # sequence of key-value pair is passed 
+    >>> players 
+    {'ronaldo': 'portugal', 'kaka': 'brazil', 'messi': 'argentina'} 
+    >>> 
+    >>> # If keys are simple strings, it's quite easier to specify pairs using keyword arguments 
+    ... 
+    >>> dict( totti = 38, zidane = 43 ) 
+    {'zidane': 43, 'totti': 38} 
+` 
+
+يمكن استخدام اختبارات Dict أيضًا لإنشاء القواميس من تعبيرات المفاتيح والقيمة التعسفية:
+
+ `    >>> {x: x**2 for x in (2, 4, 6)} 
+    {2: 4, 4: 16, 6: 36} 
+` 
+
+**التكرار في القاموس**  
+للحلقة ببساطة فوق المفاتيح في القاموس ، بدلاً من المفاتيح والقيم:
+
+ `    >>> d = {'x': 1, 'y': 2, 'z': 3} 
+    >>> for key in d: 
+    ...     print(key) # do something 
+    ... 
+    x 
+    y 
+    z 
+` 
+
+للحلقة فوق كل من المفتاح والقيمة ، يمكنك استخدام ما يلي:  
+لبيثون 2.x:
+
+ `    >>> for key, item in d.iteritems(): 
+    ...     print items 
+    ... 
+    1 
+    2 
+    3 
+` 
+
+استخدام **`items()`** لـ Python 3.x:
+
+ `    >>> for key, item in d.items(): 
+    ...     print(key, items) 
+    ... 
+    x 1 
+    y 2 
+    z 3 
+`

guide/arabic/python/data-structures/floating-point-numbers/index.md

@@ -0,0 +1,117 @@
+---
+title: Python Floating Point Numbers
+localeTitle: بايثون العائمة نقطة أرقام
+---
+يمكن العثور [هنا على](https://docs.python.org/3/tutorial/floatingpoint.html) بعض المعلومات العامة حول أرقام النقاط العائمة وكيفية عملها في بايثون.
+
+تتبع جميع تطبيقات بايثون تقريبًا مواصفات IEEE 754: قياسي لحساب الحساب العائم الثنائي Binary Floating-Point Arithmetic. تم العثور على مزيد من المعلومات على [موقع IEEE](http://grouper.ieee.org/groups/754/) .
+
+يمكن إنشاء الكائنات [العائمة](https://docs.python.org/3/reference/lexical_analysis.html#floating-point-literals) باستخدام [القيم الحرفية العائمة](https://docs.python.org/3/reference/lexical_analysis.html#floating-point-literals) :
+
+ `>>> 3.14 
+ 3.14 
+ >>> 314\.    # Trailing zero(s) not required. 
+ 314.0 
+ >>> .314    # Leading zero(s) not required. 
+ 0.314 
+ >>> 3e0 
+ 3.0 
+ >>> 3E0     # 'e' or 'E' can be used. 
+ 3.0 
+ >>> 3e1     # Positive value after e moves the decimal to the right. 
+ 30.0 
+ >>> 3e-1    # Negative value after e moves the decimal to the left. 
+ 0.3 
+ >>> 3.14e+2 # '+' not required but can be used for exponent part. 
+ 314.0 
+` 
+
+لا تحتوي القيم الحرفية الرقمية على أي إشارة ، إلا أنه من الممكن إنشاء كائنات عائمة سلبية عن طريق البدء بمعامِل وحيد `-` (ناقص) بدون مساحة قبل الحرف
+
+ `>>> -3.141592653589793 
+ -3.141592653589793 
+ >>> type(-3.141592653589793) 
+ <class 'float'> 
+` 
+
+وبالمثل ، يمكن أن تبدأ مسبقات الأجسام الموجبة الإيجابية بعامل وحيد `+ (` زائد) بدون مساحة قبل الحرفية. عادةً ما يتم حذف `+` :
+
+ `>>> +3.141592653589793 
+ 3.141592653589793 
+` 
+
+ﻻﺣ Note أن اﻟﺼﻔﺮ (اﻟﺼﻔﺤﺎت) اﻟﻘﻴﺎدﻳﺔ واﻟﺰاﻣﻨﺔ ﺻﺎﻟﺤﺔ ﻟﻠﺤﺮوف اﻟﻔﺎرﻏﺔ
+
+ `>>> 0.0 
+ 0.0 
+ >>> 00.00 
+ 0.0 
+ >>> 00100.00100 
+ 100.001 
+ >>> 001e0010      # Same as 1e10 
+ 10000000000.0 
+` 
+
+إن [منشئ `float`](https://docs.python.org/3/library/functions.html#float) طريقة أخرى لإنشاء كائنات `float` .
+
+خلق `float` الأجسام العائمة مع الحرفية نقطة ويفضل عندما يكون ذلك ممكنا:
+
+ `>>> a = 3.14         # Prefer floating point literal when possible. 
+ >>> type(a) 
+ <class 'float'> 
+ >>> b = int(3.14)    # Works but unnecessary. 
+ >>> type(b) 
+ <class 'float'> 
+` 
+
+ومع ذلك ، يسمح منشئ floatctor إنشاء كائنات عائمة من أنواع الأعداد الأخرى:
+
+ `>>> a = 4 
+ >>> type(a) 
+ <class 'int'> 
+ >>> print(a) 
+ 4 
+ >>> b = float(4) 
+ >>> type(b) 
+ <class 'float'> 
+ >>> print(b) 
+ 4.0 
+ >>> float(400000000000000000000000000000000) 
+ 4e+32 
+ >>> float(.00000000000000000000000000000004) 
+ 4e-32 
+ >>> float(True) 
+ 1.0 
+ >>> float(False) 
+ 0.0 
+` 
+
+سيقوم منشئ `float` أيضًا بجعل الكائنات `float` من السلاسل التي تمثل القيم الحرفية العددية:
+
+ `>>> float('1') 
+ 1.0 
+ >>> float('.1') 
+ 0.1 
+ >>> float('3.') 
+ 3.0 
+ >>> float('1e-3') 
+ 0.001 
+ >>> float('3.14') 
+ 3.14 
+ >>> float('-.15e-2') 
+ -0.0015 
+` 
+
+يمكن أيضًا استخدام منشئ `float` لجعل التمثيل الرقمي لـ `NaN` (ليس رقمًا) ، `infinity` السالبة `infinity` (السلاسل الملاحظة لهؤلاء غير حساسة لحالة الأحرف):
+
+ `>>> float('nan') 
+ nan 
+ >>> float('inf') 
+ inf 
+ >>> float('-inf') 
+ -inf 
+ >>> float('infinity') 
+ inf 
+ >>> float('-infinity') 
+ -inf 
+`

guide/arabic/python/data-structures/index.md

@@ -0,0 +1,18 @@
+---
+title: The Python Data Structures
+localeTitle: هياكل بيانات بايثون
+---
+هيكل البيانات هو طريقة خاصة لتنظيم البيانات في الكمبيوتر بحيث يمكن استخدامها بكفاءة. بيثون تأتي مع مجموعة قوية من هياكل البيانات يحمل في ثناياه عوامل. بعض من الأكثر استخداما هي: -
+
+*   قوائم
+*   الصفوف
+*   قواميس
+
+بشكل كبير ، يمكن تقسيم هياكل البيانات إلى فئتين:
+
+*   Mutable: - بنية البيانات القابلة للتغيير هي بنية يمكن تعديل حالتها بعد إنشائها. بيثون القوائم والقواميس هي قابلة للتغيير.
+*   غير قابل للتغيير: - لا يمكن تعديل بنية البيانات غير القابلة للتغيير. مثال: - بمجرد إنشاء فئة ، لا يمكننا تحديث القيم بداخله.
+
+## مرجع:
+
+[بايثون هياكل البيانات](https://docs.python.org/3.7/tutorial/datastructures.html)

guide/arabic/python/data-structures/integers/index.md

@@ -0,0 +1,164 @@
+---
+title: Python Integers
+localeTitle: بايثون الاعداد الصحيحه
+---
+المجال النظري للأعداد الصحيحة في python هو إنفيني سلبي إلى ما لا نهاية. في الممارسة العملية ، يتم تحديد القيم الصحيحة بواسطة مقدار الذاكرة المتوفرة.
+
+في Python 2 ، كان هناك تمييز بين **`int`** ، والأرقام التي تتناسب مع 32 أو 64 بت _C_ **`long`** ، وأرقام **`long`** محدودة بالذاكرة المتوفرة. بيثون 3 توحد بين نوعين في **`int`** فقط ، مزيد من المعلومات في [PEP 237](https://www.python.org/dev/peps/pep-0237/) .
+
+**إنشاء `int` باستخدام حرفية عدد صحيح**
+
+[عدد صحيح](https://docs.python.org/3/reference/lexical_analysis.html#integer-literals)
+
+يمكن إنشاء _كائنات عدد صحيح_ باستخدام استخدام عدد صحيح من القيم الحرفية. الأرقام غير المزينة بدون الكسور العشرية هي عدد صحيح من القيم الحرفية:
+
+ `>>> 1234567890           # Unadorned numbers are integer literals 
+ 1234567890 
+ >>> type(1234567890) 
+ <class 'int'> 
+` 
+
+لا تحتوي القيم الحرفية الرقمية على إشارة ، ولكن إنشاء _كائنات صحيحة_ سالبة ممكن عن طريق البدء بمعامِل وحيد `-` (ناقص) بدون فراغ قبل الحرفية:
+
+ `>>> -1234567890 
+ -1234567890 
+ >>> type(-1234567890) 
+ <class 'int'> 
+` 
+
+وبالمثل ، يمكن إنشاء كائنات صحيحة موجبة عن طريق بدء تشغيل عامل `+` (زائد) أحادي بدون فراغ قبل الأرقام. عادة ما يكون `+` هو:
+
+ `>>> +1234 
+ 1234 
+` 
+
+يمكن إنشاء الأعداد الصحيحة ثنائية (قاعدة 2 ، البادئة: `0b` أو `0B` ) ، ثماني (قاعدة 8 ، البادئة: `0o` أو `0O` ) ، `0O` السداسية العشرية (الأساس 16 ، البادئة: `0x` أو `0X` ) باستخدام القيم الحرفية الصحيحة:
+
+ `>>> 0b1, 0b10, 0b11 
+ (1, 2, 3) 
+ >>> 0o1, 0o10, 0o11 
+ (1, 8, 9) 
+ >>> 0x1, 0x10, 0x11 
+ (1, 16, 17) 
+` 
+
+تجدر الإشارة إلى أنه **لا يُسمح بترك** 0 من القيم الحرفية الصحيحة غير الصفرية:
+
+ `>>> 0     # Zero by itself is okay. 
+ 0 
+ >>> 01    # Leading zero(s) cause SyntaxError. 
+  File "<stdin>", line 1 
+    01 
+     ^ 
+ SyntaxError: invalid token 
+` 
+
+[المنشئ](https://docs.python.org/3/library/functions.html#int) `int` طريقة أخرى لإنشاء _كائنات عدد صحيح_ .
+
+ `class int(x=0) 
+ class int(x, base=10) 
+` 
+
+يفضل إنشاء _كائنات صحيحة_ ذات قيم حرفية صحيحة عند الإمكان:
+
+ `>>> a = 1         # Prefer integer literal when possible. 
+ >>> type(a) 
+ <class 'int'> 
+ >>> b = int(1)    # Works but unnecessary. 
+ >>> type(b) 
+ <class 'int'> 
+` 
+
+ومع ذلك ، يسمح المُنشئ بإنشاء _كائنات صحيحة_ من أنواع الأعداد الأخرى:
+
+ `>>> a = 1.123 
+ >>> type(a) 
+ <class 'float'> 
+ >>> print(a) 
+ 1.123 
+ >>> b = int(1.123) 
+ >>> type(b) 
+ <class 'int'> 
+ >>> print(b) 
+ 1 
+` 
+
+باستخدام `int` المنشئ لأرقام النقطة العائمة سيتم اقتطاع الرقم باتجاه صفر:
+
+ `>>> int(-1.23) 
+ -1 
+ >>> int(1.23) 
+ 1 
+` 
+
+الثوابت `boolean` المضمنة هي مثيلات من فئة `bool` ، وهي فئات فرعية لفئة `int` ، مما يجعلها نوعًا من النوع العددي:
+
+ `>>> type(True) 
+ <class 'bool'> 
+ >>> issubclass(bool, int) 
+ True 
+` 
+
+إذا كان ذلك غير منطقي بالنسبة لك ، فلا تقلق. الآن فقط تذكر أن استدعاء منشئ int مع كائنات `boolean` سيتم إرجاع _كائنات عدد صحيح_ :
+
+ `>>> int(True) 
+ 1 
+ >>> int(False) 
+ 0 
+` 
+
+سيقوم منشئ `int` أيضًا بإنشاء _كائنات صحيحة_ من السلاسل:
+
+ `>>> a = "10" 
+ >>> type(a) 
+ <class 'str'> 
+ >>> b = int("10") 
+ >>> type(b) 
+ <class 'int'> 
+` 
+
+يجب أن تمثل _سلاسل_ منشئ `int` عددًا صحيحًا حرفيًا:
+
+المعلمة الثانية من `int` هي تحديد أساس (الافتراضي: 10). القواعد الصالحة هي 0 و236.
+
+إذا تم توفير قاعدة صريحة يجب أن تكون الوسيطة الأولى عبارة عن سلسلة.
+
+ `>>> int("111", 2) 
+ 7 
+ >>> int(111, 2) 
+ Traceback (most recent call last): 
+  File "<stdin>", line 1, in <module> 
+ TypeError: int() can't convert non-string with explicit base 
+` 
+
+يجب أن تكون السلسلة المستخدمة منشئ `int` مع قاعدة صريحة حاصية عدد صحيح صالحة لهذه القاعدة:
+
+ `>>> int('11', 2) 
+ 3 
+ >>> int('12', 2) 
+ Traceback (most recent call last): 
+  File "<stdin>", line 1, in <module> 
+ ValueError: invalid literal for int() with base 2: '12' 
+` 
+
+يمكن استخدام كل من السلاسل البادئة وغير المسبوقة من القيم الحرفية الصحيحة ، في حالة استخدامها ، يجب أن تتطابق البادئة مع القاعدة المقدمة.
+
+ `>>> int('1101', 2) 
+ 13 
+ >>> int('0b1101', 2) 
+ 13 
+ >>> int('0x1101', 2) 
+ Traceback (most recent call last): 
+  File "<stdin>", line 1, in <module> 
+ ValueError: invalid literal for int() with base 2: '0x1101' 
+` 
+
+إذا تم استخدام سلسلة مسبوقة والبقاعدة 0 ، فسيستخدم الكائن الصحيح الذي تم إنشاؤه الأساس المحدد بواسطة البادئة. إذا لم يتم استخدام البادئة ، فسيتم افتراض الأساس 10
+
+ `>>> int('100', 0) 
+ 100 
+ >>> int('0b100', 0) 
+ 4 
+ >>> int('0o100', 0) 
+ 64 
+`

guide/arabic/python/data-structures/objects/index.md

@@ -0,0 +1,109 @@
+---
+title: The Python Objects
+localeTitle: كائنات بايثون
+---
+> في بيثون ، كل شيء _كائن_ .
+
+تمثل _الكائنات_ مجموعة منطقية من السمات. السمات هي البيانات و / أو الوظائف. عندما يتم إنشاء كائن في Python يتم إنشاؤه _بهوية_ _ونوع_ _وقيمة_ .
+
+في اللغات الأخرى ، _الأوليات_ هي _قيم_ لا تحتوي على _خصائص_ (سمات). على سبيل المثال ، في javascript `undefined` ، `undefined` `null` ، `boolean` ، `string` ، `number` ، `symbol` (الجديد في ECMAScript 2015) هي مواد أولية.
+
+في بايثون ، لا توجد أوليات. `None` ، أو _منطقي_ ، أو _سلاسل_ ، أو _أرقام_ ، أو حتى _الدوال_ كلها _كائنات_ بغض النظر عن كيفية إنشائها.
+
+يمكننا توضيح ذلك باستخدام بعض الوظائف المدمجة:
+
+*   [`id`](https://docs.python.org/3/library/functions.html#id)
+*   [`type`](https://docs.python.org/3/library/functions.html#type)
+*   [`dir`](https://docs.python.org/3/library/functions.html#dir)
+*   [`issubclass`](https://docs.python.org/3/library/functions.html#issubclass)
+
+الثوابت المضمنة `None` و `True` و `False` هي _كائنات_ :
+
+نحن اختبار `None` كائن هنا.
+
+ `>>> id(None) 
+ 4550218168 
+ >>> type(None) 
+ <class 'NoneType'> 
+ >>> dir(None) 
+ [__bool__', '__class__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__le__', '__lt__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__'] 
+ >>> issubclass(type(None), object) 
+ True 
+` 
+
+بعد ذلك ، دعونا نفحص `True` .
+
+ `>>> id(True) 
+ 4550117616 
+ >>> type(True) 
+ <class 'bool'> 
+ >>> dir(True) 
+ ['__abs__', '__add__', '__and__', '__bool__', '__ceil__', '__class__', '__delattr__', '__dir__', '__divmod__', '__doc__', '__eq__', '__float__', '__floor__', '__floordiv__', '__format__', '__ge__', '__getattribute__', '__getnewargs__', '__gt__', '__hash__', '__index__', '__init__', '__int__', '__invert__', '__le__', '__lshift__', '__lt__', '__mod__', '__mul__', '__ne__', '__neg__', '__new__', '__or__', '__pos__', '__pow__', '__radd__', '__rand__', '__rdivmod__', '__reduce__', '__reduce_ex__', '__repr__', '__rfloordiv__', '__rlshift__', '__rmod__', '__rmul__', '__ror__', '__round__', '__rpow__', '__rrshift__', '__rshift__', '__rsub__', '__rtruediv__', '__rxor__', '__setattr__', '__sizeof__', '__str__', '__sub__', '__subclasshook__', '__truediv__', '__trunc__', '__xor__', 'bit_length', 'conjugate', 'denominator', 'from_bytes', 'imag', 'numerator', 'real', 'to_bytes'] 
+ >>> issubclass(type(True), object) 
+ True 
+` 
+
+لا يوجد سبب لترك خارج `False` !
+
+ `>>> id(False) 
+ 4550117584 
+ >>> type(False) 
+ <class 'bool'> 
+ >>> dir(False) 
+ ['__abs__', '__add__', '__and__', '__bool__', '__ceil__', '__class__', '__delattr__', '__dir__', '__divmod__', '__doc__', '__eq__', '__float__', '__floor__', '__floordiv__', '__format__', '__ge__', '__getattribute__', '__getnewargs__', '__gt__', '__hash__', '__index__', '__init__', '__int__', '__invert__', '__le__', '__lshift__', '__lt__', '__mod__', '__mul__', '__ne__', '__neg__', '__new__', '__or__', '__pos__', '__pow__', '__radd__', '__rand__', '__rdivmod__', '__reduce__', '__reduce_ex__', '__repr__', '__rfloordiv__', '__rlshift__', '__rmod__', '__rmul__', '__ror__', '__round__', '__rpow__', '__rrshift__', '__rshift__', '__rsub__', '__rtruediv__', '__rxor__', '__setattr__', '__sizeof__', '__str__', '__sub__', '__subclasshook__', '__truediv__', '__trunc__', '__xor__', 'bit_length', 'conjugate', 'denominator', 'from_bytes', 'imag', 'numerator', 'real', 'to_bytes'] 
+ >>> issubclass(type(False), object) 
+ True 
+` 
+
+_سلاسل_ ، حتى عندما تم إنشاؤها بواسطة القيم الحرفية سلسلة ، هي أيضا _الكائنات_ .
+
+ `>>> id("Hello campers!") 
+ 4570186864 
+ >>> type('Hello campers!') 
+ <class 'str'> 
+ >>> dir("Hello campers!") 
+ ['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__gt__', '__hash__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'capitalize', 'casefold', 'center', 'count', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'format_map', 'index', 'isalnum', 'isalpha', 'isdecimal', 'isdigit', 'isidentifier', 'islower', 'isnumeric', 'isprintable', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'maketrans', 'partition', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill'] 
+ >>> issubclass(type('Hello campers!'), object) 
+ True 
+` 
+
+الشيء نفسه مع _الأرقام_
+
+ `>>> id(42) 
+ 4550495728 
+ >>> type(42) 
+ <class 'int'> 
+ >>> dir(42) 
+ ['__abs__', '__add__', '__and__', '__bool__', '__ceil__', '__class__', '__delattr__', '__dir__', '__divmod__', '__doc__', '__eq__', '__float__', '__floor__', '__floordiv__', '__format__', '__ge__', '__getattribute__', '__getnewargs__', '__gt__', '__hash__', '__index__', '__init__', '__int__', '__invert__', '__le__', '__lshift__', '__lt__', '__mod__', '__mul__', '__ne__', '__neg__', '__new__', '__or__', '__pos__', '__pow__', '__radd__', '__rand__', '__rdivmod__', '__reduce__', '__reduce_ex__', '__repr__', '__rfloordiv__', '__rlshift__', '__rmod__', '__rmul__', '__ror__', '__round__', '__rpow__', '__rrshift__', '__rshift__', '__rsub__', '__rtruediv__', '__rxor__', '__setattr__', '__sizeof__', '__str__', '__sub__', '__subclasshook__', '__truediv__', '__trunc__', '__xor__', 'bit_length', 'conjugate', 'denominator', 'from_bytes', 'imag', 'numerator', 'real', 'to_bytes'] 
+ >>> issubclass(type(42), object) 
+ True 
+` 
+
+## وظائف هي كائنات أيضا
+
+> في بايثون ، تعتبر الدوال كائنات من الدرجة الأولى.
+
+_تعتبر الدوال_ في Python أيضًا _كائنات_ تم إنشاؤها باستخدام _هوية_ _ونوع_ _وقيمة_ . هم أيضا يمكن أن تنتقل إلى _وظائف_ أخرى:
+
+ `>>> id(dir) 
+ 4568035688 
+ >>> type(dir) 
+ <class 'builtin_function_or_method'> 
+ >>> dir(dir) 
+ ['__call__', '__class__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__le__', '__lt__', '__module__', '__name__', '__ne__', '__new__', '__qualname__', '__reduce__', '__reduce_ex__', '__repr__', '__self__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__text_signature__'] 
+ >>> issubclass(type(dir), object) 
+ True 
+` 
+
+من الممكن أيضًا ربط الدالات بالاسم وتسمى الدالة المندمجة باستخدام هذا الاسم:
+
+ `>>> a = dir 
+ >>> print(a) 
+ <built-in function dir> 
+ >>> a(a) 
+ ['__call__', '__class__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__le__', '__lt__', '__module__', '__name__', '__ne__', '__new__', '__qualname__', '__reduce__', '__reduce_ex__', '__repr__', '__self__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__text_signature__'] 
+` 
+
+مصادر:
+
+*   [انقر هنا](https://www.jeffknupp.com/blog/2014/06/18/improve-your-python-python-classes-and-object-oriented-programming/) لمعرفة المزيد.

guide/arabic/python/data-structures/ranges/index.md

@@ -0,0 +1,82 @@
+---
+title: The Python Range
+localeTitle: نطاق بايثون
+---
+## بايثون نطاقات
+
+بدلاً من كونه دالة ، فإن النطاق هو في الواقع [نوع متسلسل غير قابل للتغيير](https://docs.python.org/3/library/stdtypes.html#immutable-sequence-types) ويشيع استخدامه لحل عدد محدد من المرات في الحلقات.
+
+**خلق:**
+
+يتم إنشاء `ranges` باستخدام منشئ `range` . المعلمات منشئ هي:
+
+*   `start` : القيمة الأولى الشاملة للنطاق (عدد صحيح اختياري ، القيم الافتراضية إلى 0).
+*   `stop` : قيمة التوقف الحصرية ، يتوقف النطاق عند توفير هذه القيمة أو أكبر (العدد الصحيح المطلوب).
+*   `step` : القيمة المضافة إلى القيمة الحالية للحصول على القيمة التالية (عدد صحيح اختياري ، الإعداد الافتراضي إلى 1).
+
+ `>>> range(10)          # Only the stop parameter is required. 
+ range(0, 10) 
+ >>> range(0, 10)       # Default for start parameter is 0. 
+ range(0, 10) 
+ >>> range(0, 10, 1)    # Default for step is 1\. Start parameter is required if 
+ step is needed. 
+ range(0, 10) 
+` 
+
+**أمثلة:**
+
+ونظرًا لأن `ranges` متكررة ، يمكن تمريرها إلى `list` `tuple` لإنشاء هذه الأنواع من التسلسلات. باستخدام هذه الحقيقة ، يمكننا تصور بعض الأمثلة:
+
+ `>>> list(range(10))     # range as argument for list constructor. 
+ [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] 
+ >>> tuple(range(10))    # range as argument for tuple constructor. 
+ (0, 1, 2, 3, 4, 5, 6, 7, 8, 9) 
+` 
+
+`ranges` طول الصفر:
+
+ `>>> list(range(10, 0))        # start greater than stop with postive step. 
+ [] 
+ >>> list(range(10, 10))       # start equal to stop with postive step. 
+ [] 
+ >>> list(range(10, 10, -1))   # start equal to stop with negative step. 
+ [] 
+ >>> list(range(0, 10, -1))    # start less than stop with negative step. 
+ [] 
+` 
+
+`ranges` مع وسيطات الخطوة:
+
+ `>>> list(range(0, 10, 2))       # next value would be 10, stops at 8. 
+ [0, 2, 4, 6, 8] 
+ >>> list(range(0, 10, 3))       # next value would be 12, stops at 9. 
+ [0, 3, 6, 9] 
+ >>> list(range(0, 10, 4))       # next value would be 12, stops at 8. 
+ [0, 4, 8] 
+ >>> list(range(10, 0, -1))      # negative step makes decreasing ranges. 
+ [10, 9, 8, 7, 6, 5, 4, 3, 2, 1] 
+ >>> list(range(-5, -30, -3))    # negative integers are valid arguments. 
+ [-5, -8, -11, -14, -17, -20, -23, -26, -29] 
+` 
+
+**فوائد:**
+
+إن الفائدة من استخدام `range` هي أنه بغض النظر عن مدى نطاق معين ، فإن هناك حاجة إلى كمية صغيرة من الذاكرة لتخزين `range` ، وقيم البدء ، والتوقف ، والخطوة. يتم حساب القيم الفردية `ranges` عند التكرار.
+
+ `>>> import sys 
+ >>> a_range = range(1000000) 
+ >>> a_list = list(a_range) 
+ >>> a_tuple = tuple(a_range) 
+ >>> sys.getsizeof(a_range) 
+ 48 
+ >>> sys.getsizeof(a_list) 
+ 9000112 
+ >>> sys.getsizeof(a_tuple) 
+ 8000048 
+` 
+
+### مزيد من المعلومات:
+
+[بيثون دوك - النطاقات](https://docs.python.org/3/library/stdtypes.html#ranges)
+
+**TODO: `ranges` الطرق لا تنفذ ولا تنفذ**

guide/arabic/python/data-structures/scopes/index.md

@@ -0,0 +1,13 @@
+---
+title: The Python Scopes
+localeTitle: بيثون سكوبس
+---
+**قائمة: ملاحظة**
+
+*   هذا ينتمي إلى كتلة التعليمات البرمجية ومعلومات المسافة البادئة.
+*   ويرتبط ذلك أيضًا بالمتغيرات حيث أن البحث عن الأسماء والترابط يرتبطان بالنطاقات.
+
+**TODO: CONTENT**
+
+*   `global`
+*   `nonlocal`

guide/arabic/python/data-structures/strings/index.md

@@ -0,0 +1,32 @@
+---
+title: The Python Strings
+localeTitle: سلاسل بايثون
+---
+يسمح Python `str` كائنات `str` أو _سلاسل الأحرف_ بعدة طرق مختلفة:
+
+*   علامات التنصيص المفردة: `'Single quote strings can have "double" quotes inside.'` الاقتباس الأحادية على علامات `'Single quote strings can have "double" quotes inside.'`
+    
+*   علامات الاقتباس المزدوجة: `"Double quote strings can have 'single' quotes inside."` الاقتباس المزدوجة على علامات `"Double quote strings can have 'single' quotes inside."`
+    
+*   الثلاثي المقتبس:
+    
+     `"""Triple quoted strings can span multiple lines. 
+     Unescaped "double" and 'single' quotes in triple quoted strings are retained.""" 
+     
+     '''Triple quoted strings can be 'single'or "double" quotes. 
+     Unescaped newlines are also retained.''' 
+    ` 
+    
+*   غير قابل للتغيير: لا يمكنك تحرير / تغيير سلسلة Python مباشرة بعد إنشائها. على سبيل المثال ، إذا حاولت إعادة تعيين / تغيير الحرف الأول مباشرةً في سلسلة ، فسيتم طرح خطأ.
+    
+     `>>> foo = "my string" 
+     >>> foo[0] = "a" 
+     Traceback (most recent call last): 
+            File "<stdin>", line 1, in <module> 
+     TypeError: 'str' object does not support item assignment 
+    ` 
+    
+
+## مرجع:
+
+[نوع تسلسل النص _str_](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str)

guide/arabic/python/data-structures/tuples/index.md

@@ -0,0 +1,184 @@
+---
+title: The Tuples
+localeTitle: الصفوف
+---
+## الصفوف
+
+تعتبر المجموعة مجموعة من كائنات Python. الصفوف غير قابلة للتغيير ، مما يعني أنه لا يمكن تعديلها بعد الإنشاء ، على عكس القوائم.
+
+**خلق:**
+
+يتم إنشاء `tuple` فارغة باستخدام زوج من الأقواس المستديرة ، `()` :
+
+ `    >>> empty_tuple = () 
+    >>> print(empty_tuple) 
+    () 
+    >>> type(empty_tuple) 
+    <class 'tuple'> 
+    >>> len(empty_tuple) 
+    0 
+` 
+
+A `tuple` تم إنشاؤه باستخدام العناصر عن طريق فصل العناصر بفواصل (المحيطة الأقواس مستديرة، `()` ، اختيارية مع بعض الاستثناءات):
+
+ `    >>> tuple_1 = 1, 2, 3       # Create tuple without round brackets. 
+    >>> print(tuple_1) 
+    (1, 2, 3) 
+    >>> type(tuple_1) 
+    <class 'tuple'> 
+    >>> len(tuple_1) 
+    3 
+    >>> tuple_2 = (1, 2, 3)     # Create tuple with round brackets. 
+    >>> print(tuple_2) 
+    (1, 2, 3) 
+    >>> tuple_3 = 1, 2, 3,      # Trailing comma is optional. 
+    >>> print(tuple_3) 
+    (1, 2, 3) 
+    >>> tuple_4 = (1, 2, 3,)    # Trailing comma in round brackets is also optional. 
+    >>> print(tuple_4) 
+    (1, 2, 3) 
+` 
+
+A `tuple` يجب أن يكون مع وجود عنصر واحد الفاصلة زائدة (مع أو بدون أقواس جولة):
+
+ `    >>> not_tuple = (2)    # No trailing comma makes this not a tuple. 
+    >>> print(not_tuple) 
+    2 
+    >>> type(not_tuple) 
+    <class 'int'> 
+    >>> a_tuple = (2,)     # Single element tuple. Requires trailing comma. 
+    >>> print(a_tuple) 
+    (2,) 
+    >>> type(a_tuple) 
+    <class 'tuple'> 
+    >>> len(a_tuple) 
+    1 
+    >>> also_tuple = 2,    # Round brackets omitted. Requires trailing comma. 
+    >>> print(also_tuple) 
+    (2,) 
+    >>> type(also_tuple) 
+    <class 'tuple'> 
+` 
+
+مطلوبة الأقواس المستديرة في حالات الغموض (إذا كانت المجموعة جزءًا من تعبير أكبر):
+
+> لاحظ أنه في الواقع الفاصلة التي تجعل tuple ، وليس الأقواس. الأقواس اختيارية ، باستثناء حالة الطبقة الفارغة ، أو عندما تكون هناك حاجة لتجنب الغموض النحوي. على سبيل المثال ، `f(a, b, c)` عبارة عن استدعاء دالة بثلاث وسيطات ، بينما `f((a, b, c))` هي دالة استدعاء مع 3-tuple باعتبارها الوسيطة الوحيدة.
+
+ `    >>> print(1,2,3,4,)          # Calls print with 4 arguments: 1, 2, 3, and 4 
+    1 2 3 4 
+    >>> print((1,2,3,4,))        # Calls print with 1 argument: (1, 2, 3, 4,) 
+    (1, 2, 3, 4) 
+    >>> 1, 2, 3 == (1, 2, 3)     # Equivalent to 1, 2, (3 == (1, 2, 3)) 
+    (1, 2, False) 
+    >>> (1, 2, 3) == (1, 2, 3)   # Use surrounding round brackets when ambiguous. 
+    True 
+` 
+
+A `tuple` كما يمكن إنشاء مع `tuple` المنشئ:
+
+ `    >>> empty_tuple = tuple() 
+    >>> print(empty_tuple) 
+    () 
+    >>> tuple_from_list = tuple([1,2,3,4]) 
+    >>> print(tuple_from_list) 
+    (1, 2, 3, 4) 
+    >>> tuple_from_string = tuple("Hello campers!") 
+    >>> print(tuple_from_string) 
+    ('H', 'e', 'l', 'l', 'o', ' ', 'c', 'a', 'm', 'p', 'e', 'r', 's', '!') 
+    >>> a_tuple = 1, 2, 3 
+    >>> b_tuple = tuple(a_tuple)    # If the constructor is called with a tuple for 
+    the iterable, 
+    >>> a_tuple is b_tuple          # the tuple argument is returned. 
+    True 
+` 
+
+**الوصول إلى عناصر `tuple` :**
+
+يتم الوصول إلى عناصر `tuples` ويتم فهرستها بنفس الطريقة التي تكون بها `lists` .
+
+ `    >>> my_tuple = 1, 2, 9, 16, 25 
+    >>> print(my_tuple) 
+    (1, 2, 9, 16, 25) 
+` 
+
+_صفر مفهرسة_
+
+ `    >>> my_tuple[0] 
+    1 
+    >>> my_tuple[1] 
+    2 
+    >>> my_tuple[2] 
+    9 
+` 
+
+_التفاف حول الفهرسة_
+
+ `    >>> my_tuple[-1] 
+    25 
+    >>> my_tuple[-2] 
+    16 
+` 
+
+**التعبئة والتفريغ:**
+
+العبارة `t = 12345, 54321, 'hello!'` مثال على تعبئة المجموعة: القيم `12345` و `54321` و `'hello!'` هي معبأة معا في صف. العملية العكسية ممكنة أيضا:
+
+ `    >>> x, y, z = t 
+` 
+
+وهذا ما يسمى ، بشكل مناسب ، تسلسل التفريغ ويعمل لأي تسلسل على الجانب الأيمن. يتطلب تفريغ التسلسل وجود العديد من المتغيرات على الجانب الأيسر من علامة المساواة حيث توجد عناصر في التسلسل. لاحظ أن التعيين المتعدد هو في الحقيقة مجرد مجموعة من تعبئة المجموعة وتسلسل تفريغ.
+
+ `    >>> t = 1, 2, 3    # Tuple packing. 
+    >>> print(t) 
+    (1, 2, 3) 
+    >>> a, b, c = t    # Sequence unpacking. 
+    >>> print(a) 
+    1 
+    >>> print(b) 
+    2 
+    >>> print(c) 
+    3 
+    >>> d, e, f = 4, 5, 6    # Multiple assignment combines packing and unpacking. 
+    >>> print(d) 
+    4 
+    >>> print(e) 
+    5 
+    >>> print(f) 
+    6 
+    >>> a, b = 1, 2, 3       # Multiple assignment requires each variable (right) 
+    have a matching element (left). 
+    Traceback (most recent call last): 
+      File "<stdin>", line 1, in <module> 
+    ValueError: too many values to unpack (expected 2) 
+` 
+
+**ثابت:**
+
+`tuples` عبارة عن حاويات غير قابلة للتغيير ، **مما** يضمن عدم تغير الكائنات التي تحتوي عليها. أنه **لا** يضمن أن الكائنات التي يحتوي لن يتغير:
+
+ `    >>> a_list = [] 
+    >>> a_tuple = (a_list,)    # A tuple (immutable) with a list (mutable) element. 
+    >>> print(a_tuple) 
+    ([],) 
+ 
+    >>> a_list.append("Hello campers!") 
+    >>> print(a_tuple)         # Element of the immutable is mutated. 
+    (['Hello campers!'],) 
+` 
+
+**الاستخدامات:**
+
+وظائف لا يمكن إلا بإرجاع قيمة واحدة، ومع ذلك، heterogenuous `tuple` يمكن استخدامها لإرجاع القيم متعددة من دالة. أحد الأمثلة على ذلك هو دالة `enumerate` المضمنة التي تقوم بإرجاع متكرر من `tuples` غير المتجانسة:
+
+ `    >>> greeting = ["Hello", "campers!"] 
+    >>> enumerator = enumerate(greeting) 
+    >>> enumerator.next() 
+    >>> enumerator.__next__() 
+    (0, 'Hello') 
+    >>> enumerator.__next__() 
+    (1, 'campers!') 
+` 
+
+### مزيد من المعلومات:
+
+[Python Docs - Tuples](https://docs.python.org/3/library/stdtypes.html#tuples)