Convert single backtick code sections to triple backtick code sections for Arabic Guide articles (13 of 15) (#36240)
* fix: converted single to triple backticks13 * fix: added prefix Co-Authored-By: Tom <20648924+moT01@users.noreply.github.com> * fix: removed language in wrong place Co-Authored-By: Tom <20648924+moT01@users.noreply.github.com> * fix: add language postfix Co-Authored-By: Tom <20648924+moT01@users.noreply.github.com> * fix: removed language in wrong place Co-Authored-By: Tom <20648924+moT01@users.noreply.github.com>
This commit is contained in:
Randell Dawson
Tom
@ -12,8 +12,9 @@ localeTitle: PHP بناء الجملة نظرة عامة
|
||||
|
||||
نمط علامة PHP الأكثر فعالية عالميًا -
|
||||
|
||||
`<?php...?>
|
||||
`
|
||||
```
|
||||
<?php...?>
|
||||
```
|
||||
|
||||
إذا كنت تستخدم هذا النمط ، فيمكنك أن تكون إيجابيًا أن يتم دائمًا تفسير علاماتك بشكل صحيح.
|
||||
|
||||
@ -21,8 +22,9 @@ localeTitle: PHP بناء الجملة نظرة عامة
|
||||
|
||||
تبدو العلامات قصيرة أو قصيرة مفتوحة مثل هذا -
|
||||
|
||||
`<?...?>
|
||||
`
|
||||
```
|
||||
<?...?>
|
||||
```
|
||||
|
||||
العلامات القصيرة هي ، كما قد يتوقع المرء ، أقصر خيار يجب عليك القيام بأحد الأمرين لتمكين PHP من التعرف على العلامات -
|
||||
|
||||
@ -34,8 +36,9 @@ localeTitle: PHP بناء الجملة نظرة عامة
|
||||
|
||||
تحاكي علامات ASP النمط العلامات التي تستخدمها صفحات الخادم النشطة لتمييز الكتل البرمجية. تبدو العلامات على غرار ASP مثل هذا -
|
||||
|
||||
`<%...%>
|
||||
`
|
||||
```
|
||||
<%...%>
|
||||
```
|
||||
|
||||
لاستخدام علامات نمط ASP ، ستحتاج إلى تعيين خيار التكوين في ملف php.ini الخاص بك.
|
||||
|
||||
@ -43,8 +46,9 @@ localeTitle: PHP بناء الجملة نظرة عامة
|
||||
|
||||
تبدو علامات نص HTML مثل هذا -
|
||||
|
||||
`<script language="PHP">...</script>
|
||||
`
|
||||
```
|
||||
<script language="PHP">...</script>
|
||||
```
|
||||
|
||||
### تعليق كود PHP
|
||||
|
||||
@ -101,12 +105,13 @@ localeTitle: PHP بناء الجملة نظرة عامة
|
||||
|
||||
على سبيل المثال ، كل من عبارات PHP التالية التي تعين مجموع 2 + 2 للمتغير $ أربعة يعادل -
|
||||
|
||||
`$four = 2 + 2; // single spaces
|
||||
$four <tab>=<tab2<tab>+<tab>2 ; // spaces and tabs
|
||||
$four =
|
||||
2+
|
||||
2; // multiple lines
|
||||
`
|
||||
```
|
||||
$four = 2 + 2; // single spaces
|
||||
$four <tab>=<tab2<tab>+<tab>2 ; // spaces and tabs
|
||||
$four =
|
||||
2+
|
||||
2; // multiple lines
|
||||
```
|
||||
|
||||
### PHP حساس لحالة الأحرف
|
||||
|
||||
@ -127,16 +132,18 @@ localeTitle: PHP بناء الجملة نظرة عامة
|
||||
|
||||
سيؤدي ذلك إلى النتيجة التالية -
|
||||
|
||||
`Variable capital is 67
|
||||
Variable CaPiTaL is
|
||||
`
|
||||
```
|
||||
Variable capital is 67
|
||||
Variable CaPiTaL is
|
||||
```
|
||||
|
||||
### العبارات عبارة عن تعبيرات منتهية بفواصل منقوطة
|
||||
|
||||
بيان في PHP هو أي تعبير متبوع بفاصلة منقوطة (؛) أي تسلسل من عبارات PHP الصالحة التي يتم تضمينها بواسطة علامات PHP هو برنامج PHP صالح. هنا بيان نموذجي في PHP ، والذي يقوم في هذه الحالة بتعيين سلسلة من الأحرف لمتغير يسمى تحية $ -
|
||||
|
||||
`$greeting = "Welcome to PHP!";
|
||||
`
|
||||
```
|
||||
$greeting = "Welcome to PHP!";
|
||||
```
|
||||
|
||||
### التعبيرات عبارة عن مجموعة من الرموز المميزة
|
||||
|
||||
@ -161,19 +168,22 @@ localeTitle: PHP بناء الجملة نظرة عامة
|
||||
|
||||
نعم يمكنك تشغيل البرنامج النصي PHP الخاص بك في موجه الأوامر. بافتراض أنك تتابع المحتوى في ملف test.php
|
||||
|
||||
`<?php
|
||||
```
|
||||
<?php
|
||||
echo "Hello PHP!!!!!";
|
||||
?>
|
||||
`
|
||||
?>
|
||||
```
|
||||
|
||||
الآن قم بتشغيل هذا البرنامج النصي كموجه الأوامر كما يلي -
|
||||
|
||||
`$ php test.php
|
||||
`
|
||||
```
|
||||
$ php test.php
|
||||
```
|
||||
|
||||
سوف ينتج النتيجة التالية -
|
||||
|
||||
`Hello PHP!!!!!
|
||||
`
|
||||
```
|
||||
Hello PHP!!!!!
|
||||
```
|
||||
|
||||
نأمل الآن أن يكون لديك معرفة أساسية من PHP بناء الجملة.
|
||||
@ -8,12 +8,13 @@ localeTitle: حائط اللوب
|
||||
|
||||
### بناء الجملة:
|
||||
|
||||
`$x = 0;
|
||||
while ($x < 11) {
|
||||
```php
|
||||
$x = 0;
|
||||
while ($x < 11) {
|
||||
statement1;
|
||||
$x++;
|
||||
}
|
||||
`
|
||||
}
|
||||
```
|
||||
|
||||
**ملاحظة:** يجب أن تحتوي شفرة الكتل على بيان يغير أو يزيد من الشرط. وإلا فقد ينتج عن حلقة لا نهائية.
|
||||
|
||||
|
||||
@ -14,16 +14,17 @@ localeTitle: العمل مع واجهات برمجة التطبيقات JSON
|
||||
|
||||
يمكن تحويل الكائنات في PHP إلى JSON باستخدام وظيفة PHP `json_encode()` :
|
||||
|
||||
`<?php
|
||||
$myObj->name = "John";
|
||||
$myObj->age = 30;
|
||||
$myObj->city = "New York";
|
||||
```php
|
||||
<?php
|
||||
$myObj->name = "John";
|
||||
$myObj->age = 30;
|
||||
$myObj->city = "New York";
|
||||
|
||||
$myJSON = json_encode($myObj);
|
||||
$myJSON = json_encode($myObj);
|
||||
|
||||
echo $myJSON;
|
||||
?>
|
||||
`
|
||||
echo $myJSON;
|
||||
?>
|
||||
```
|
||||
|
||||
[جربها](https://www.w3schools.com/js/showphp.asp?filename=demo_file)
|
||||
|
||||
@ -35,16 +36,17 @@ localeTitle: العمل مع واجهات برمجة التطبيقات JSON
|
||||
|
||||
استخدم JSON.parse () لتحويل النتيجة إلى كائن JavaScript:
|
||||
|
||||
`var xmlhttp = new XMLHttpRequest();
|
||||
xmlhttp.onreadystatechange = function() {
|
||||
```js
|
||||
var xmlhttp = new XMLHttpRequest();
|
||||
xmlhttp.onreadystatechange = function() {
|
||||
if (this.readyState == 4 && this.status == 200) {
|
||||
var myObj = JSON.parse(this.responseText);
|
||||
document.getElementById("demo").innerHTML = myObj.name;
|
||||
}
|
||||
};
|
||||
xmlhttp.open("GET", "demo_file.php", true);
|
||||
xmlhttp.send();
|
||||
`
|
||||
};
|
||||
xmlhttp.open("GET", "demo_file.php", true);
|
||||
xmlhttp.send();
|
||||
```
|
||||
|
||||
[جربها](https://www.w3schools.com/js/tryit.asp?filename=tryjson_php_simple)
|
||||
|
||||
|
||||
@ -34,7 +34,8 @@ localeTitle: أضف إلى الشاشة الرئيسية
|
||||
|
||||
#### الملف manifest.json
|
||||
|
||||
`{
|
||||
```json
|
||||
{
|
||||
"name": "FreeCodeCamp",
|
||||
"short_name": "FreeCodeCamp",
|
||||
"theme_color": "#00FF00",
|
||||
@ -85,8 +86,8 @@ localeTitle: أضف إلى الشاشة الرئيسية
|
||||
}
|
||||
],
|
||||
"splash_pages": null
|
||||
}
|
||||
`
|
||||
}
|
||||
```
|
||||
|
||||
* `name` هو اسم تطبيق الويب. (سيتم عرضه في شاشة الإطلاق)
|
||||
* `short name` هو `short name` القصير لتطبيق الويب. (سيتم عرضه أسفل رمز قائمة الهاتف)
|
||||
@ -104,28 +105,28 @@ localeTitle: أضف إلى الشاشة الرئيسية
|
||||
|
||||
على نظام التشغيل iOS ، يجب إضافة زر "إضافة إلى الشاشة الرئيسية" يدويًا. أضف علامات meta tag التالية إلى قسم الرأس في HTML لدعم رمز تطبيق iOS على الويب.
|
||||
|
||||
`
|
||||
```html
|
||||
<meta name="apple-mobile-web-app-capable" content="yes">
|
||||
<meta name="apple-mobile-web-app-status-bar-style" content="green">
|
||||
<meta name="apple-mobile-web-app-title" content="FreeCodeCamp">
|
||||
<link rel="apple-touch-icon" href="/assets/images/icons/icon-72x72.png" sizes="72x72">
|
||||
<link rel="apple-touch-icon" href="/assets/images/icons/icon-96x96.png" sizes="96x96">
|
||||
<link rel="apple-touch-icon" href="/assets/images/icons/icon-128x128.png" sizes="128x128">
|
||||
<link rel="apple-touch-icon" href="/assets/images/icons/icon-144x144.png" sizes="144x144">
|
||||
<link rel="apple-touch-icon" href="/assets/images/icons/icon-152x152.png" sizes="152x152">
|
||||
<link rel="apple-touch-icon" href="/assets/images/icons/icon-192x192.png" sizes="192x192">
|
||||
<link rel="apple-touch-icon" href="/assets/images/icons/icon-384x384.png" sizes="384x384">
|
||||
<link rel="apple-touch-icon" href="/assets/images/icons/icon-512x512.png" sizes="512x512">
|
||||
`
|
||||
<meta name="apple-mobile-web-app-status-bar-style" content="green">
|
||||
<meta name="apple-mobile-web-app-title" content="FreeCodeCamp">
|
||||
<link rel="apple-touch-icon" href="/assets/images/icons/icon-72x72.png" sizes="72x72">
|
||||
<link rel="apple-touch-icon" href="/assets/images/icons/icon-96x96.png" sizes="96x96">
|
||||
<link rel="apple-touch-icon" href="/assets/images/icons/icon-128x128.png" sizes="128x128">
|
||||
<link rel="apple-touch-icon" href="/assets/images/icons/icon-144x144.png" sizes="144x144">
|
||||
<link rel="apple-touch-icon" href="/assets/images/icons/icon-152x152.png" sizes="152x152">
|
||||
<link rel="apple-touch-icon" href="/assets/images/icons/icon-192x192.png" sizes="192x192">
|
||||
<link rel="apple-touch-icon" href="/assets/images/icons/icon-384x384.png" sizes="384x384">
|
||||
<link rel="apple-touch-icon" href="/assets/images/icons/icon-512x512.png" sizes="512x512">
|
||||
```
|
||||
|
||||
**شبابيك**
|
||||
|
||||
على هاتف Windows ، أضف علامات meta التالية إلى قسم الرأس في HTML:
|
||||
|
||||
`
|
||||
```html
|
||||
<meta name="msapplication-TileImage" content="/assets/images/icons/icon-144x144.png">
|
||||
<meta name="msapplication-TileColor" content="green">
|
||||
`
|
||||
<meta name="msapplication-TileColor" content="green">
|
||||
```
|
||||
|
||||
### المراجع
|
||||
|
||||
|
||||
@ -34,10 +34,11 @@ localeTitle: عمال الخدمة
|
||||
|
||||
قبل تثبيت عامل خدمة ، تحتاج إلى تسجيل واحد من ملف جافا سكريبت الرئيسي. يمكن القيام بذلك بفضل الطريقة navigator.serviceWorker.register على النحو التالي:
|
||||
|
||||
`if ('serviceWorker' in navigator) {
|
||||
navigator.serviceWorker.register('/serviceWorkerArticles.js', { scope: '/' }):
|
||||
}
|
||||
`
|
||||
```javascript
|
||||
if ('serviceWorker' in navigator) {
|
||||
navigator.serviceWorker.register('/serviceWorkerArticles.js', { scope: '/' }):
|
||||
}
|
||||
```
|
||||
|
||||
هذه الطريقة تأخذ معلمتين:
|
||||
|
||||
@ -51,7 +52,8 @@ localeTitle: عمال الخدمة
|
||||
|
||||
بالنسبة إلى معظم الإجراءات ، تحتاج فقط إلى إجراء بعض addEventListener ، حيث إن لدى عمال الخدمة بالفعل الكثير من الأحداث المفيدة للاستماع إليها!
|
||||
|
||||
`self.addEventListener('install', cach => {
|
||||
```javascript
|
||||
self.addEventListener('install', cach => {
|
||||
event.waitUntil(
|
||||
caches.open('v1').then(cache => {
|
||||
return cache.addAll([
|
||||
@ -64,7 +66,7 @@ localeTitle: عمال الخدمة
|
||||
})
|
||||
);
|
||||
});
|
||||
`
|
||||
```
|
||||
|
||||
لدينا 3 طرق مثيرة للاهتمام هنا! دعونا نلقي نظرة سريعة على كل منهم:
|
||||
|
||||
|
||||
@ -14,10 +14,11 @@ localeTitle: بيثون عبس وظيفة
|
||||
|
||||
## عينة الكود
|
||||
|
||||
`print(abs(3.4)) # prints 3.4
|
||||
print(abs(-6)) # prints 6
|
||||
print(abs(3 + 4j)) # prints 5, because |3 + 4j| = 5
|
||||
`
|
||||
```python
|
||||
print(abs(3.4)) # prints 3.4
|
||||
print(abs(-6)) # prints 6
|
||||
print(abs(3 + 4j)) # prints 5, because |3 + 4j| = 5
|
||||
```
|
||||
|
||||
[🚀 تشغيل الكود](https://repl.it/CL8k/0)
|
||||
|
||||
|
||||
@ -4,42 +4,43 @@ localeTitle: العلاقات بين * و args
|
||||
---
|
||||
## وجود \* في تعريف الوظيفة
|
||||
|
||||
`# How does *args work in a function definition
|
||||
```Python
|
||||
# How does *args work in a function definition
|
||||
|
||||
def hardFunc(arg1, arg2):
|
||||
def hardFunc(arg1, arg2):
|
||||
# create a tuple and pollute it with arguments passed to hardFunc
|
||||
args=(arg1, arg2)
|
||||
# print out results
|
||||
print(args[0])
|
||||
print(args[1])
|
||||
|
||||
hardFunc('hard_one', 'hard_two')
|
||||
# output — Try it yourself now and in sequential snippets!
|
||||
hardFunc('hard_one', 'hard_two')
|
||||
# output — Try it yourself now and in sequential snippets!
|
||||
|
||||
def softFunc(*args):
|
||||
def softFunc(*args):
|
||||
# at this point after calling softFunc a tuple with a name of a word
|
||||
# followed by * is created automatically (in this case the name is args)
|
||||
# print out results
|
||||
print(args[0])
|
||||
print(args[1])
|
||||
|
||||
softFunc('soft_one', 'soft_two')
|
||||
softFunc('soft_one', 'soft_two')
|
||||
|
||||
# Now try to do something illegal
|
||||
hardFunc('one', 'two', 'three')
|
||||
# Now try to do something illegal
|
||||
hardFunc('one', 'two', 'three')
|
||||
|
||||
# Now do things legally
|
||||
softFunc('one', 'two', 'three')
|
||||
# Now do things legally
|
||||
softFunc('one', 'two', 'three')
|
||||
|
||||
# or even
|
||||
softFunc('one', 'two', 'three', 'infinity')
|
||||
# or even
|
||||
softFunc('one', 'two', 'three', 'infinity')
|
||||
|
||||
# softFunc handles arbitrary amount of arguments easily by virtue of * syntax
|
||||
# So using a single variable name in conjuction with * we gained the ability
|
||||
# to invoke a function with arbitrary amount of arguments.
|
||||
# softFunc handles arbitrary amount of arguments easily by virtue of * syntax
|
||||
# So using a single variable name in conjuction with * we gained the ability
|
||||
# to invoke a function with arbitrary amount of arguments.
|
||||
|
||||
# Once again when softFunc is called the newly args
|
||||
# tuple filled with provided arguments is created
|
||||
# Once again when softFunc is called the newly args
|
||||
# tuple filled with provided arguments is created
|
||||
|
||||
# Conclusion softFunc is a more flexible/dynamic verson of a hardFunc
|
||||
`
|
||||
# Conclusion softFunc is a more flexible/dynamic verson of a hardFunc
|
||||
```
|
||||
@ -43,12 +43,13 @@ localeTitle: صف دراسي
|
||||
|
||||
الثعبان x = MyClass ()
|
||||
|
||||
`Creates a new instance of the class and assigns this object to the local variable x.
|
||||
```
|
||||
Creates a new instance of the class and assigns this object to the local variable x.
|
||||
|
||||
The instantiation operation (“calling” a class object) creates an empty object.
|
||||
Many classes like to create objects with instances customized to a specific initial state.
|
||||
Therefore a class may define a special method named __init__(), like this:
|
||||
`
|
||||
The instantiation operation (“calling” a class object) creates an empty object.
|
||||
Many classes like to create objects with instances customized to a specific initial state.
|
||||
Therefore a class may define a special method named __init__(), like this:
|
||||
```
|
||||
|
||||
الثعبان def **init** (الذاتية): self.data = \[\]
|
||||
|
||||
|
||||
@ -12,17 +12,18 @@ localeTitle: كتل بيثون كود و المسافة البادئة
|
||||
|
||||
طباعة ("كل ذلك!")
|
||||
|
||||
`The lines print('Logging on ...') and print('Incorrect password.') are two separate code blocks. These ones happen to be only a single line long, but Python lets you write code blocks consisting of any number of statements.
|
||||
```
|
||||
The lines print('Logging on ...') and print('Incorrect password.') are two separate code blocks. These ones happen to be only a single line long, but Python lets you write code blocks consisting of any number of statements.
|
||||
|
||||
To indicate a block of code in Python, you must indent each line of the block by the same amount. The two blocks of code in our example if-statement are both indented four spaces, which is a typical amount of indentation for Python.
|
||||
To indicate a block of code in Python, you must indent each line of the block by the same amount. The two blocks of code in our example if-statement are both indented four spaces, which is a typical amount of indentation for Python.
|
||||
|
||||
In most other programming languages, indentation is used only to help make the code look pretty. But in Python, it is required for indicating what block of code a statement belongs to. For instance, the final print('All done!') is not indented, and so is not part of the else-block.
|
||||
In most other programming languages, indentation is used only to help make the code look pretty. But in Python, it is required for indicating what block of code a statement belongs to. For instance, the final print('All done!') is not indented, and so is not part of the else-block.
|
||||
|
||||
Programmers familiar with other languages often bristle at the thought that indentation matters: Many programmers like the freedom to format their code how they please. However, Python indentation rules are quite simple, and most programmers already use indentation to make their code readable. Python simply takes this idea one step further and gives meaning to the indentation.
|
||||
Programmers familiar with other languages often bristle at the thought that indentation matters: Many programmers like the freedom to format their code how they please. However, Python indentation rules are quite simple, and most programmers already use indentation to make their code readable. Python simply takes this idea one step further and gives meaning to the indentation.
|
||||
|
||||
#### If/elif-statements
|
||||
An if/elif-statement is a generalized if-statement with more than one condition. It is used for making complex decisions. For example, suppose an airline has the following “child” ticket rates: Kids 2 years old or younger fly for free, kids older than 2 but younger than 13 pay a discounted child fare, and anyone 13 years or older pays a regular adult fare. The following program determines how much a passenger should pay:
|
||||
`
|
||||
#### If/elif-statements
|
||||
An if/elif-statement is a generalized if-statement with more than one condition. It is used for making complex decisions. For example, suppose an airline has the following “child” ticket rates: Kids 2 years old or younger fly for free, kids older than 2 but younger than 13 pay a discounted child fare, and anyone 13 years or older pays a regular adult fare. The following program determines how much a passenger should pay:
|
||||
```
|
||||
|
||||
الثعبان
|
||||
|
||||
|
||||
@ -37,40 +37,46 @@ localeTitle: مقارنات بايثون
|
||||
|
||||
أولا ، إنشاء قائمة في بيثون.
|
||||
|
||||
`myListA = [1,2,3]
|
||||
`
|
||||
```python
|
||||
myListA = [1,2,3]
|
||||
```
|
||||
|
||||
بعد ذلك ، قم بإنشاء نسخة من تلك القائمة.
|
||||
|
||||
`myListB = myListA
|
||||
`
|
||||
```python
|
||||
myListB = myListA
|
||||
```
|
||||
|
||||
إذا استخدمنا عامل التشغيل "==" أو عامل التشغيل "is" ، فسيؤدي كلاهما إلى إخراج **صحيح** .
|
||||
|
||||
`>>> myListA == myListB # both lists contains similar elements
|
||||
True
|
||||
>>> myListB is myListA # myListB contains the same elements
|
||||
True
|
||||
`
|
||||
```python
|
||||
>>> myListA == myListB # both lists contains similar elements
|
||||
True
|
||||
>>> myListB is myListA # myListB contains the same elements
|
||||
True
|
||||
```
|
||||
|
||||
هذا لأن myListA و myListB يشيران إلى نفس متغير القائمة ، الذي عرّفته في بداية برنامج Python الخاص بي. كلا القائمتين متطابقتان تمامًا ، سواء في الهوية أو في المحتوى.
|
||||
|
||||
ومع ذلك ، ماذا لو أنشأت الآن قائمة جديدة؟
|
||||
|
||||
`myListC = [1,2,3]
|
||||
`
|
||||
```python
|
||||
myListC = [1,2,3]
|
||||
```
|
||||
|
||||
لا يزال أداء عامل `==` يشير إلى أن كلا القائمتين متماثلتين ، من حيث المحتوى.
|
||||
|
||||
`>>> myListA == myListC
|
||||
True
|
||||
`
|
||||
```python
|
||||
>>> myListA == myListC
|
||||
True
|
||||
```
|
||||
|
||||
ومع ذلك، أداء `is` مشغل والآن تنتج `False` الانتاج. هذا لأن myListA و myListC هما متغيرين مختلفين ، بالرغم من احتوائهما على نفس البيانات. على الرغم من أنها تبدو متشابهة ، إلا أنها **مختلفة** .
|
||||
|
||||
`>>> myListA is myListC
|
||||
False # both lists have different reference
|
||||
`
|
||||
```python
|
||||
>>> myListA is myListC
|
||||
False # both lists have different reference
|
||||
```
|
||||
|
||||
لنلخص:
|
||||
|
||||
|
||||
@ -6,51 +6,56 @@ localeTitle: أرقام بيثون معقدة
|
||||
|
||||
يمكن إنشاء الجزء التخيلي من رقم مركب باستخدام حرفي تخيلي ، وينتج عن ذلك رقمًا معقدًا بجزء حقيقي من `0.0` :
|
||||
|
||||
`>>> a = 3.5j
|
||||
>>> type(a)
|
||||
<class 'complex'>
|
||||
>>> print(a)
|
||||
3.5j
|
||||
>>> a.real
|
||||
0.0
|
||||
>>> a.imag
|
||||
3.5
|
||||
`
|
||||
```python
|
||||
>>> a = 3.5j
|
||||
>>> type(a)
|
||||
<class 'complex'>
|
||||
>>> print(a)
|
||||
3.5j
|
||||
>>> a.real
|
||||
0.0
|
||||
>>> a.imag
|
||||
3.5
|
||||
```
|
||||
|
||||
لا يوجد حرفي لإنشاء رقم مركب بأجزاء حقيقية وغير وهمية. لإنشاء رقم مجمع حقيقي غير صفري ، أضف حرفيًا خياليًا إلى رقم نقطة عائمة:
|
||||
|
||||
`>>> a = 1.1 + 3.5j
|
||||
>>> type(a)
|
||||
<class 'complex'>
|
||||
>>> print(a)
|
||||
(1.1+3.5j)
|
||||
>>> a.real
|
||||
1.1
|
||||
>>> a.imag
|
||||
3.5
|
||||
`
|
||||
```python
|
||||
>>> a = 1.1 + 3.5j
|
||||
>>> type(a)
|
||||
<class 'complex'>
|
||||
>>> print(a)
|
||||
(1.1+3.5j)
|
||||
>>> a.real
|
||||
1.1
|
||||
>>> a.imag
|
||||
3.5
|
||||
```
|
||||
|
||||
أو استخدام [منشئ المعقد](https://docs.python.org/3/library/functions.html#complex) .
|
||||
|
||||
`class complex([real[, imag]])
|
||||
`
|
||||
```python
|
||||
class complex([real[, imag]])
|
||||
```
|
||||
|
||||
يمكن أن تكون الوسيطات المستخدمة في استدعاء المُنشئ المعقد من نوع رقمي (بما في ذلك `complex` ) لأي من المعلمتين:
|
||||
|
||||
`>>> complex(1, 1)
|
||||
(1+1j)
|
||||
>>> complex(1j, 1j)
|
||||
(-1+1j)
|
||||
>>> complex(1.1, 3.5)
|
||||
(1.1+3.5j)
|
||||
>>> complex(1.1)
|
||||
(1.1+0j)
|
||||
>>> complex(0, 3.5)
|
||||
3.5j
|
||||
`
|
||||
```python
|
||||
>>> complex(1, 1)
|
||||
(1+1j)
|
||||
>>> complex(1j, 1j)
|
||||
(-1+1j)
|
||||
>>> complex(1.1, 3.5)
|
||||
(1.1+3.5j)
|
||||
>>> complex(1.1)
|
||||
(1.1+0j)
|
||||
>>> complex(0, 3.5)
|
||||
3.5j
|
||||
```
|
||||
|
||||
A `string` يمكن أن تستخدم أيضا حجة. لا يُسمح بوسيطة ثانية إذا تم استخدام سلسلة كوسيطة
|
||||
|
||||
`>>> complex("1.1+3.5j")
|
||||
(1.1+3.5j)
|
||||
`
|
||||
```python
|
||||
>>> complex("1.1+3.5j")
|
||||
(1.1+3.5j)
|
||||
```
|
||||
@ -10,19 +10,21 @@ localeTitle: تحويل عدد صحيح الى سلسلة في بايثون
|
||||
|
||||
قد يحاول المبرمجون القادمون من لغات أخرى تنفيذ سلسلة السلاسل التالية التي تنتج خطأ:
|
||||
|
||||
`age = 18
|
||||
```py
|
||||
age = 18
|
||||
|
||||
string = "Hello, I am " + age + " years old"
|
||||
`
|
||||
string = "Hello, I am " + age + " years old"
|
||||
```
|
||||
|
||||
[تشغيل الكود على repl.it](https://repl.it/JyYH/0)
|
||||
|
||||
الخطأ الذي يظهر هو
|
||||
|
||||
`Traceback (most recent call last):
|
||||
```
|
||||
Traceback (most recent call last):
|
||||
File "python", line 3, in <module>
|
||||
TypeError: must be str, not int
|
||||
`
|
||||
TypeError: must be str, not int
|
||||
```
|
||||
|
||||
`TypeError: must be str, not int` يشير إلى أنه يجب أولاً تحويل العدد الصحيح إلى سلسلة ليتم توصيله.
|
||||
|
||||
@ -30,28 +32,30 @@ localeTitle: تحويل عدد صحيح الى سلسلة في بايثون
|
||||
|
||||
مثال سلسلتي بسيط:
|
||||
|
||||
`age = 18
|
||||
```py
|
||||
age = 18
|
||||
|
||||
print("Hello, I am " + str(age) + " years old")
|
||||
print("Hello, I am " + str(age) + " years old")
|
||||
|
||||
# Output
|
||||
# Hello, I am 18 years old
|
||||
`
|
||||
# Output
|
||||
# Hello, I am 18 years old
|
||||
```
|
||||
|
||||
[تشغيل الكود على repl.it](https://repl.it/Jz8Q/0)
|
||||
|
||||
اطبع `1 2 3 4 5 6 7 8 9 10` باستخدام جملة واحدة
|
||||
|
||||
`result = ""
|
||||
```py
|
||||
result = ""
|
||||
|
||||
for i in range(1, 11):
|
||||
for i in range(1, 11):
|
||||
result += str(i) + " "
|
||||
|
||||
print(result)
|
||||
print(result)
|
||||
|
||||
# Output
|
||||
# 1 2 3 4 5 6 7 8 9 10
|
||||
`
|
||||
# Output
|
||||
# 1 2 3 4 5 6 7 8 9 10
|
||||
```
|
||||
|
||||
[تشغيل الكود على repl.it](https://repl.it/KBLB/0)
|
||||
|
||||
|
||||
@ -21,63 +21,68 @@ localeTitle: كائنات بايثون
|
||||
|
||||
نحن اختبار `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
|
||||
`
|
||||
```python
|
||||
>>> 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
|
||||
`
|
||||
```python
|
||||
>>> 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
|
||||
`
|
||||
```python
|
||||
>>> 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
|
||||
`
|
||||
```python
|
||||
>>> 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(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
|
||||
```
|
||||
|
||||
## وظائف هي كائنات أيضا
|
||||
|
||||
@ -85,24 +90,26 @@ _سلاسل_ ، حتى عندما تم إنشاؤها بواسطة القيم ا
|
||||
|
||||
_تعتبر الدوال_ في 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
|
||||
`
|
||||
```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__']
|
||||
`
|
||||
```python
|
||||
>>> 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__']
|
||||
```
|
||||
|
||||
مصادر:
|
||||
|
||||
|
||||
@ -14,66 +14,71 @@ localeTitle: نطاق بايثون
|
||||
* `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)
|
||||
`
|
||||
```python
|
||||
>>> 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)
|
||||
`
|
||||
```python
|
||||
>>> 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.
|
||||
[]
|
||||
`
|
||||
```python
|
||||
>>> 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]
|
||||
`
|
||||
```python
|
||||
>>> 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
|
||||
`
|
||||
```python
|
||||
>>> 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
|
||||
```
|
||||
|
||||
### مزيد من المعلومات:
|
||||
|
||||
|
||||
@ -6,22 +6,23 @@ localeTitle: Python defaultdict
|
||||
|
||||
القاموس هو واحد من أكثر هياكل البيانات المستخدمة في بايثون. القاموس هو مجموعة غير مرتبة من العناصر وعادة ما يكون لدينا مفاتيح وقيم مخزنة في القاموس. دعونا نلقي نظرة على بعض الأمثلة لكيفية استخدام القاموس عادة.
|
||||
|
||||
`# dictionary declaration 1
|
||||
dict1 = dict()
|
||||
```python
|
||||
# dictionary declaration 1
|
||||
dict1 = dict()
|
||||
|
||||
# dictionary declaration 2
|
||||
dict2 = {}
|
||||
# dictionary declaration 2
|
||||
dict2 = {}
|
||||
|
||||
# Add items to the dictionary
|
||||
# The syntax to add and retrieve items is same for either of the two objects we defined above.
|
||||
key = "X"
|
||||
value = "Y"
|
||||
dict1[key] = value
|
||||
# Add items to the dictionary
|
||||
# The syntax to add and retrieve items is same for either of the two objects we defined above.
|
||||
key = "X"
|
||||
value = "Y"
|
||||
dict1[key] = value
|
||||
|
||||
# The dictionary doesn't have any specific data-type.
|
||||
# So, the values can be pretty diverse.
|
||||
dict1[key] = dict2
|
||||
`
|
||||
# The dictionary doesn't have any specific data-type.
|
||||
# So, the values can be pretty diverse.
|
||||
dict1[key] = dict2
|
||||
```
|
||||
|
||||
دعونا ننظر الآن في بعض طرق الاسترجاع.
|
||||
|
||||
@ -37,92 +38,98 @@ localeTitle: Python defaultdict
|
||||
|
||||
في حالة عدم وجود المفتاح المحدد في القاموس ، فإن Python `KeyError` . هناك حل بسيط لهذا. دعونا ننظر في كيف يمكننا تجنب `KeyError` باستخدام مدمج وظيفة `.get` .
|
||||
|
||||
`dict_ = {}
|
||||
```python
|
||||
dict_ = {}
|
||||
|
||||
# Some random key
|
||||
random_key = "random"
|
||||
# Some random key
|
||||
random_key = "random"
|
||||
|
||||
# The most basic way of doing this is to check if the key
|
||||
# exists in the dictionary or not and only retrieve if the
|
||||
# key exists. Otherwise not.
|
||||
if random_key in dict_:
|
||||
# The most basic way of doing this is to check if the key
|
||||
# exists in the dictionary or not and only retrieve if the
|
||||
# key exists. Otherwise not.
|
||||
if random_key in dict_:
|
||||
print(dict_[random_key])
|
||||
else:
|
||||
else:
|
||||
print("Key = {} doesn't exist in the dictionary".format(dict_))
|
||||
`
|
||||
```
|
||||
|
||||
في كثير من الأحيان ، نوافق على الحصول على قيمة افتراضية عندما لا يكون المفتاح موجودًا. على سبيل المثال عندما بناء عداد. هناك طريقة أفضل للحصول على القيم الافتراضية من القاموس في حالة مفاتيح مفقودة بدلاً من الاعتماد على معيار `if-else` .
|
||||
|
||||
`# Let's say we want to build a frequency counter for items in the following array
|
||||
arr = [1,2,3,1,2,3,4,1,2,1,4,1,2,3,1]
|
||||
```python
|
||||
# Let's say we want to build a frequency counter for items in the following array
|
||||
arr = [1,2,3,1,2,3,4,1,2,1,4,1,2,3,1]
|
||||
|
||||
freq = {}
|
||||
freq = {}
|
||||
|
||||
for item in arr:
|
||||
for item in arr:
|
||||
# Fetch a value of 0 in case the key doesn't exist. Otherwise, fetch the stored value
|
||||
freq[item] = freq.get(item, 0) + 1
|
||||
`
|
||||
```
|
||||
|
||||
لذا ، تعد عملية `get(<key>, <defaultval>)` عملية سهلة لاسترجاع القيمة الافتراضية لأي مفتاح محدد من القاموس. تأتي مشكلة هذه الطريقة عندما نريد التعامل مع هياكل البيانات القابلة للتغيير مثل القيم على سبيل المثال `list` أو `set` .
|
||||
|
||||
`dict_ = {}
|
||||
```python
|
||||
dict_ = {}
|
||||
|
||||
# Some random key
|
||||
random_key = "random"
|
||||
# Some random key
|
||||
random_key = "random"
|
||||
|
||||
dict_[random_key] = dict_.get(random_key, []).append("Hello World!")
|
||||
print(dict_) # {'random': None}
|
||||
dict_[random_key] = dict_.get(random_key, []).append("Hello World!")
|
||||
print(dict_) # {'random': None}
|
||||
|
||||
dict_ = {}
|
||||
dict_[random_key] = dict_.get(random_key, set()).add("Hello World!")
|
||||
print(dict_) # {'random': None}
|
||||
`
|
||||
dict_ = {}
|
||||
dict_[random_key] = dict_.get(random_key, set()).add("Hello World!")
|
||||
print(dict_) # {'random': None}
|
||||
```
|
||||
|
||||
هل رأيت المشكلة؟
|
||||
|
||||
لا يتم `set` الجديدة أو `list` الجديدة لمفتاح القاموس. يجب علينا تعيين `list` جديدة أو `set` إلى المفتاح في حالة القيمة المفقودة ثم `append` أو `add` على التوالي. نظرة لي على سبيل المثال لهذا.
|
||||
|
||||
`dict_ = {}
|
||||
dict_[random_key] = dict_.get(random_key, set())
|
||||
dict_[random_key].add("Hello World!")
|
||||
print(dict_) # {'random': set(['Hello World!'])}. Yay!
|
||||
`
|
||||
```python
|
||||
dict_ = {}
|
||||
dict_[random_key] = dict_.get(random_key, set())
|
||||
dict_[random_key].add("Hello World!")
|
||||
print(dict_) # {'random': set(['Hello World!'])}. Yay!
|
||||
```
|
||||
|
||||
### تجنب KeyError: استخدم defaultdict
|
||||
|
||||
هذا يعمل أكثر من مرة. ومع ذلك ، هناك طريقة أفضل للقيام بذلك. طريقة أكثر `pythonic` . `defaultdict` هو فئة فرعية للفئة dict المضمنة. يقوم `defaultdict` ببساطة بتعيين القيمة الافتراضية التي `defaultdict` في حالة وجود مفتاح مفقود. لذا ، فإن الخطوتين:
|
||||
|
||||
`dict_[random_key] = dict_.get(random_key, set())
|
||||
dict_[random_key].add("Hello World!")
|
||||
`
|
||||
```python
|
||||
dict_[random_key] = dict_.get(random_key, set())
|
||||
dict_[random_key].add("Hello World!")
|
||||
```
|
||||
|
||||
يمكن الآن دمجها في خطوة واحدة. على سبيل المثال
|
||||
|
||||
`from collections import defaultdict
|
||||
```python
|
||||
from collections import defaultdict
|
||||
|
||||
# Yet another random key
|
||||
random_key = "random_key"
|
||||
# Yet another random key
|
||||
random_key = "random_key"
|
||||
|
||||
# list defaultdict
|
||||
list_dict_ = defaultdict(list)
|
||||
# list defaultdict
|
||||
list_dict_ = defaultdict(list)
|
||||
|
||||
# set defaultdict
|
||||
set_dict_ = defaultdict(set)
|
||||
# set defaultdict
|
||||
set_dict_ = defaultdict(set)
|
||||
|
||||
# integer defaultdict
|
||||
int_dict_ = defaultdict(int)
|
||||
# integer defaultdict
|
||||
int_dict_ = defaultdict(int)
|
||||
|
||||
list_dict_[random_key].append("Hello World!")
|
||||
set_dict_[random_key].add("Hello World!")
|
||||
int_dict_[random_key] += 1
|
||||
list_dict_[random_key].append("Hello World!")
|
||||
set_dict_[random_key].add("Hello World!")
|
||||
int_dict_[random_key] += 1
|
||||
|
||||
"""
|
||||
"""
|
||||
defaultdict(<class 'list'>, {'random_key': ['Hello World!']})
|
||||
defaultdict(<class 'set'>, {'random_key': {'Hello World!'}})
|
||||
defaultdict(<class 'int'>, {'random_key': 1})
|
||||
"""
|
||||
print(list_dict_, set_dict_, int_dict_)
|
||||
`
|
||||
"""
|
||||
print(list_dict_, set_dict_, int_dict_)
|
||||
```
|
||||
|
||||
* * *
|
||||
|
||||
|
||||
@ -43,7 +43,8 @@ Docstring هو وسيلة للمطورين لتوصيل الغرض ، والمع
|
||||
|
||||
## مثال 1
|
||||
|
||||
`def is_less_than_five(some_number):
|
||||
```python
|
||||
def is_less_than_five(some_number):
|
||||
'''(int) -> bool
|
||||
Returns True if the given number is less than 5, and False is the given number is greater than 5.
|
||||
REQ: some_number != 5
|
||||
@ -55,7 +56,7 @@ Docstring هو وسيلة للمطورين لتوصيل الغرض ، والمع
|
||||
False
|
||||
'''
|
||||
# Your code goes here
|
||||
`
|
||||
```
|
||||
|
||||
### بعض الروابط المفيدة:
|
||||
|
||||
|
||||
@ -8,22 +8,24 @@ localeTitle: الاستثناءات ومعالجة الأخطاء
|
||||
|
||||
مثال:
|
||||
|
||||
`>>> try:
|
||||
>>> . . . print "this is not a string "+1
|
||||
>>> except:
|
||||
>>> . . . print "error"
|
||||
error
|
||||
`
|
||||
```shell
|
||||
>>> try:
|
||||
>>> . . . print "this is not a string "+1
|
||||
>>> except:
|
||||
>>> . . . print "error"
|
||||
error
|
||||
```
|
||||
|
||||
وإذا كنت ترغب في الحصول على رسائل خطأ بمزيد من التفاصيل من التعليمات البرمجية ، فيمكنك إضافة وسائط `except Exception as err`
|
||||
|
||||
`>>> try:
|
||||
>>> . . . print "this is not a string "+1
|
||||
>>> except Exception as err:
|
||||
>>> . . . print "error:\n"+str(err)
|
||||
error:
|
||||
cannot concatenate 'str' and 'int' objects
|
||||
`
|
||||
```shell
|
||||
>>> try:
|
||||
>>> . . . print "this is not a string "+1
|
||||
>>> except Exception as err:
|
||||
>>> . . . print "error:\n"+str(err)
|
||||
error:
|
||||
cannot concatenate 'str' and 'int' objects
|
||||
```
|
||||
|
||||
معلومات اكثر:
|
||||
|
||||
|
||||
@ -16,13 +16,15 @@ localeTitle: الملفات و IO
|
||||
|
||||
يوفر Python أبسط طريقة لإنتاج الإخراج على الشاشة.
|
||||
|
||||
`print "Python is a powerful language.","It is easy to learn."
|
||||
`
|
||||
```python
|
||||
print "Python is a powerful language.","It is easy to learn."
|
||||
```
|
||||
|
||||
انتاج:
|
||||
|
||||
`Python is a powerful language.It is easy to learn.
|
||||
`
|
||||
```
|
||||
Python is a powerful language.It is easy to learn.
|
||||
```
|
||||
|
||||
### المدخلات من المستخدم
|
||||
|
||||
@ -32,29 +34,33 @@ raw\_input (\[موجه\])
|
||||
|
||||
تستخدم لقراءة سطر واحد من الإدخال القياسي وإعادته كسلسلة
|
||||
|
||||
`str = raw_input("Enter your name: ")
|
||||
print "Welcome ", str
|
||||
`
|
||||
```python
|
||||
str = raw_input("Enter your name: ")
|
||||
print "Welcome ", str
|
||||
```
|
||||
|
||||
انتاج:
|
||||
|
||||
`Enter your name: John Doe
|
||||
Welcome John Doe
|
||||
`
|
||||
```
|
||||
Enter your name: John Doe
|
||||
Welcome John Doe
|
||||
```
|
||||
|
||||
المدخلات (موجه)
|
||||
|
||||
وظيفة مشابهة لـ raw\_input () ، ولكن يفترض أن الإدخال عبارة عن تعبير بايثون صالح
|
||||
|
||||
`str = input("Enter input: ")
|
||||
print "Input: ", str
|
||||
`
|
||||
```python
|
||||
str = input("Enter input: ")
|
||||
print "Input: ", str
|
||||
```
|
||||
|
||||
انتاج:
|
||||
|
||||
`Enter input: [x*5 for x in range(2,10,2)]
|
||||
Input: [10,20,30,40]
|
||||
`
|
||||
```
|
||||
Enter input: [x*5 for x in range(2,10,2)]
|
||||
Input: [10,20,30,40]
|
||||
```
|
||||
|
||||
### التفاعل مع الملفات في بايثون
|
||||
|
||||
@ -76,9 +82,10 @@ raw\_input (\[موجه\])
|
||||
|
||||
انتاج:
|
||||
|
||||
`First 15 characters are:
|
||||
Python is a pow
|
||||
`
|
||||
```
|
||||
First 15 characters are:
|
||||
Python is a pow
|
||||
```
|
||||
|
||||
#### فتح الملفات
|
||||
|
||||
|
||||
@ -10,66 +10,74 @@ localeTitle: للحصول على بيانات حلقة
|
||||
|
||||
البنية الأساسية هي:
|
||||
|
||||
`for value in list_of_values:
|
||||
```python
|
||||
for value in list_of_values:
|
||||
# use value inside this block
|
||||
`
|
||||
```
|
||||
|
||||
بشكل عام ، يمكنك استخدام أي شيء كقيمة المكرر ، حيث يمكن تعيين إدخالات من iterable. على سبيل المثال ، يمكنك فك مجموعة الصفوف من قائمة الصفوف (tuples):
|
||||
|
||||
`list_of_tuples = [(1,2), (3,4)]
|
||||
```python
|
||||
list_of_tuples = [(1,2), (3,4)]
|
||||
|
||||
for a, b in list_of_tuples:
|
||||
for a, b in list_of_tuples:
|
||||
print("a:", a, "b:", b)
|
||||
`
|
||||
```
|
||||
|
||||
من ناحية أخرى ، يمكنك تكرار حلقة فوق أي شيء يمكن تثبيته. يمكنك استدعاء وظيفة أو استخدام قائمة حرفية.
|
||||
|
||||
`for person in load_persons():
|
||||
```python
|
||||
for person in load_persons():
|
||||
print("The name is:", person.name)
|
||||
`
|
||||
```
|
||||
|
||||
`for character in ["P", "y", "t", "h", "o", "n"]:
|
||||
```python
|
||||
for character in ["P", "y", "t", "h", "o", "n"]:
|
||||
print("Give me a '{}'!".format(character))
|
||||
`
|
||||
```
|
||||
|
||||
بعض الطرق التي يتم بها استخدام الحلقات For Forops:
|
||||
|
||||
**تكرار عبر الدالة range ()**
|
||||
|
||||
`for i in range(10):
|
||||
```python
|
||||
for i in range(10):
|
||||
print(i)
|
||||
`
|
||||
```
|
||||
|
||||
بدلاً من كونه دالة ، فإن النطاق هو في الواقع نوع تسلسل ثابت. سيحتوي الناتج على نتائج من الحد الأدنى أي 0 إلى الحد الأعلى أي 10 ولكن باستثناء 10.By افتراضي ، يتم تعيين الحد الأدنى أو مؤشر البداية إلى الصفر. انتاج:
|
||||
|
||||
`>
|
||||
0
|
||||
1
|
||||
2
|
||||
3
|
||||
4
|
||||
5
|
||||
6
|
||||
7
|
||||
8
|
||||
9
|
||||
>
|
||||
`
|
||||
```
|
||||
>
|
||||
0
|
||||
1
|
||||
2
|
||||
3
|
||||
4
|
||||
5
|
||||
6
|
||||
7
|
||||
8
|
||||
9
|
||||
>
|
||||
```
|
||||
|
||||
بالإضافة إلى ذلك ، يمكن تحديد الحد الأدنى للتسلسل وحتى خطوة التسلسل بإضافة معلمة ثانية وثانية.
|
||||
|
||||
`for i in range(4,10,2): #From 4 to 9 using a step of two
|
||||
```python
|
||||
for i in range(4,10,2): #From 4 to 9 using a step of two
|
||||
print(i)
|
||||
`
|
||||
```
|
||||
|
||||
انتاج:
|
||||
|
||||
`>
|
||||
4
|
||||
6
|
||||
8
|
||||
>
|
||||
`
|
||||
```
|
||||
>
|
||||
4
|
||||
6
|
||||
8
|
||||
>
|
||||
```
|
||||
|
||||
**وظيفة xrange ()**
|
||||
|
||||
@ -79,40 +87,44 @@ localeTitle: للحصول على بيانات حلقة
|
||||
|
||||
**يتكرر فوق القيم في قائمة أو مجموعة**
|
||||
|
||||
`A = ["hello", 1, 65, "thank you", [2, 3]]
|
||||
for value in A:
|
||||
```python
|
||||
A = ["hello", 1, 65, "thank you", [2, 3]]
|
||||
for value in A:
|
||||
print(value)
|
||||
`
|
||||
```
|
||||
|
||||
انتاج:
|
||||
|
||||
`>
|
||||
hello
|
||||
1
|
||||
65
|
||||
thank you
|
||||
[2, 3]
|
||||
>
|
||||
`
|
||||
```
|
||||
>
|
||||
hello
|
||||
1
|
||||
65
|
||||
thank you
|
||||
[2, 3]
|
||||
>
|
||||
```
|
||||
|
||||
**تكرار فوق مفاتيح في قاموس (aka hashmap)**
|
||||
|
||||
`fruits_to_colors = {"apple": "#ff0000",
|
||||
```python
|
||||
fruits_to_colors = {"apple": "#ff0000",
|
||||
"lemon": "#ffff00",
|
||||
"orange": "#ffa500"}
|
||||
|
||||
for key in fruits_to_colors:
|
||||
for key in fruits_to_colors:
|
||||
print(key, fruits_to_colors[key])
|
||||
`
|
||||
```
|
||||
|
||||
انتاج:
|
||||
|
||||
`>
|
||||
apple #ff0000
|
||||
lemon #ffff00
|
||||
orange #ffa500
|
||||
>
|
||||
`
|
||||
```
|
||||
>
|
||||
apple #ff0000
|
||||
lemon #ffff00
|
||||
orange #ffa500
|
||||
>
|
||||
```
|
||||
|
||||
**يتكرر أكثر من قائمتين من نفس الحجم في حلقة واحدة مع وظيفة zip ()**
|
||||
|
||||
@ -120,25 +132,29 @@ localeTitle: للحصول على بيانات حلقة
|
||||
|
||||
a، b in zip (A، B): print a، b، a == b
|
||||
|
||||
`Output:
|
||||
`
|
||||
```
|
||||
Output:
|
||||
```
|
||||
|
||||
\> أأ صحيح bd خطأ م كاذبة >
|
||||
|
||||
`**Iterate over a list and get the corresponding index with the enumerate() function**
|
||||
`
|
||||
```
|
||||
**Iterate over a list and get the corresponding index with the enumerate() function**
|
||||
```
|
||||
|
||||
الثعبان A = \["this"، "is"، "something"، "fun"\]
|
||||
|
||||
للفهرس ، كلمة في التعداد (A): طباعة (فهرس ، كلمة)
|
||||
|
||||
`Output:
|
||||
`
|
||||
```
|
||||
Output:
|
||||
```
|
||||
|
||||
\> 0 هذا 1 هو 2 شيء 3 مرح >
|
||||
|
||||
`A common use case is iterating over a dictionary:
|
||||
`
|
||||
```
|
||||
A common use case is iterating over a dictionary:
|
||||
```
|
||||
|
||||
الثعبان للاسم ، phonenumber في contacts.items (): print (الاسم ، "يمكن الوصول إليه تحت" ، phonenumber)
|
||||
|
||||
@ -164,8 +180,9 @@ a، b in zip (A، B): print a، b، a == b
|
||||
|
||||
UPPERCASE = \[word.upper () للكلمة في A\] طباعة (UPPERCASE)
|
||||
|
||||
`Output:
|
||||
`
|
||||
```
|
||||
Output:
|
||||
```
|
||||
|
||||
\> \['THIS'، 'IS'، 'AWESOME'، 'SHINNING'، 'STAR'\] > \`\` \`
|
||||
|
||||
|
||||
@ -23,24 +23,25 @@ localeTitle: المهام
|
||||
5. بعض كتلة من التعليمات البرمجية للتنفيذ
|
||||
6. بيان الإرجاع (اختياري)
|
||||
|
||||
`# a function with no parameters or returned values
|
||||
def sayHello():
|
||||
```python
|
||||
# a function with no parameters or returned values
|
||||
def sayHello():
|
||||
print("Hello!")
|
||||
|
||||
sayHello() # calls the function, 'Hello!' is printed to the console
|
||||
sayHello() # calls the function, 'Hello!' is printed to the console
|
||||
|
||||
# a function with a parameter
|
||||
def helloWithName(name):
|
||||
# a function with a parameter
|
||||
def helloWithName(name):
|
||||
print("Hello " + name + "!")
|
||||
|
||||
helloWithName("Ada") # calls the function, 'Hello Ada!' is printed to the console
|
||||
helloWithName("Ada") # calls the function, 'Hello Ada!' is printed to the console
|
||||
|
||||
# a function with multiple parameters with a return statement
|
||||
def multiply(val1, val2):
|
||||
# a function with multiple parameters with a return statement
|
||||
def multiply(val1, val2):
|
||||
return val1 * val2
|
||||
|
||||
multiply(3, 5) # prints 15 to the console
|
||||
`
|
||||
multiply(3, 5) # prints 15 to the console
|
||||
```
|
||||
|
||||
دالات هي كتل من التعليمات البرمجية التي يمكن إعادة استخدامها ببساطة عن طريق استدعاء الدالة. ويتيح ذلك إعادة استخدام الشفرة البسيطة والأنيقة دون إعادة كتابة أجزاء من التعليمات البرمجية بشكل صريح. هذا يجعل التعليمات البرمجية أكثر قابلية للقراءة ، مما يجعل تصحيح الأخطاء أسهل ، ويحد من أخطاء الكتابة.
|
||||
|
||||
@ -50,43 +51,48 @@ localeTitle: المهام
|
||||
|
||||
يتم استخدام اسم الدالة لاستدعاء الدالة ، تمرير المعلمات المطلوبة داخل الأقواس.
|
||||
|
||||
`# this is a basic sum function
|
||||
def sum(a, b):
|
||||
```python
|
||||
# this is a basic sum function
|
||||
def sum(a, b):
|
||||
return a + b
|
||||
|
||||
result = sum(1, 2)
|
||||
# result = 3
|
||||
`
|
||||
result = sum(1, 2)
|
||||
# result = 3
|
||||
```
|
||||
|
||||
يمكنك تعريف القيم الافتراضية للمعلمات ، وبهذه الطريقة سوف تفسر بايثون أن قيمة هذه المعلمة هي القيمة الافتراضية إذا لم يتم تحديد أي منها.
|
||||
|
||||
`def sum(a, b=3):
|
||||
```python
|
||||
def sum(a, b=3):
|
||||
return a + b
|
||||
|
||||
result = sum(1)
|
||||
# result = 4
|
||||
`
|
||||
result = sum(1)
|
||||
# result = 4
|
||||
```
|
||||
|
||||
يمكنك تمرير المعلمات بالترتيب الذي تريده ، باستخدام اسم المعلمة.
|
||||
|
||||
`result = sum(b=2, a=2)
|
||||
# result = 4
|
||||
`
|
||||
```python
|
||||
result = sum(b=2, a=2)
|
||||
# result = 4
|
||||
```
|
||||
|
||||
ومع ذلك ، لا يمكن تمرير وسيطة الكلمات الرئيسية قبل كلمة غير أساسية
|
||||
|
||||
`result = sum(3, b=2)
|
||||
#result = 5
|
||||
result2 = sum(b=2, 3)
|
||||
#Will raise SyntaxError
|
||||
`
|
||||
```Python
|
||||
result = sum(3, b=2)
|
||||
#result = 5
|
||||
result2 = sum(b=2, 3)
|
||||
#Will raise SyntaxError
|
||||
```
|
||||
|
||||
وظائف هي أيضا كائنات ، لذلك يمكنك تعيينها لمتغير ، واستخدام هذا المتغير مثل وظيفة.
|
||||
|
||||
`s = sum
|
||||
result = s(1, 2)
|
||||
# result = 3
|
||||
`
|
||||
```python
|
||||
s = sum
|
||||
result = s(1, 2)
|
||||
# result = 3
|
||||
```
|
||||
|
||||
### ملاحظات
|
||||
|
||||
|
||||
@ -8,47 +8,50 @@ localeTitle: مولدات كهرباء
|
||||
|
||||
المولدات قابلة للتكرار حتى يمكن استخدامها بشكل نظيف مع الحلقات أو أي شيء آخر يتكرر.
|
||||
|
||||
`def my_generator():
|
||||
```python
|
||||
def my_generator():
|
||||
yield 'hello'
|
||||
yield 'world'
|
||||
yield '!'
|
||||
|
||||
for item in my_generator():
|
||||
for item in my_generator():
|
||||
print(item)
|
||||
|
||||
# output:
|
||||
# hello
|
||||
# world
|
||||
# !
|
||||
`
|
||||
# output:
|
||||
# hello
|
||||
# world
|
||||
# !
|
||||
```
|
||||
|
||||
مثل المكررات الأخرى ، يمكن تمرير المولدات إلى الوظيفة `next` لاسترداد العنصر التالي. عندما لا يحتوي المولّد على قيم أكثر `StopIteration` ، `StopIteration` خطأ `StopIteration` .
|
||||
|
||||
`g = my_generator()
|
||||
print(next(g))
|
||||
# 'hello'
|
||||
print(next(g))
|
||||
# 'world'
|
||||
print(next(g))
|
||||
# '!'
|
||||
print(next(g))
|
||||
# Traceback (most recent call last):
|
||||
# File "<stdin>", line 1, in <module>
|
||||
# StopIteration
|
||||
`
|
||||
```python
|
||||
g = my_generator()
|
||||
print(next(g))
|
||||
# 'hello'
|
||||
print(next(g))
|
||||
# 'world'
|
||||
print(next(g))
|
||||
# '!'
|
||||
print(next(g))
|
||||
# Traceback (most recent call last):
|
||||
# File "<stdin>", line 1, in <module>
|
||||
# StopIteration
|
||||
```
|
||||
|
||||
تعد المولدات مفيدة بشكل خاص عندما تحتاج إلى إنشاء مجموعة كبيرة من القيم ولكن لا تحتاج إلى الاحتفاظ بها كلها في الذاكرة في نفس الوقت. على سبيل المثال ، إذا كنت بحاجة إلى طباعة أول مليون مليون فيبوناتشي ، فيجب عليك عادة إرجاع قائمة بقيمة مليون وتكرارها على القائمة لطباعة كل قيمة. ومع ذلك ، مع مولد ، يمكنك إرجاع كل قيمة واحدة في كل مرة:
|
||||
|
||||
`def fib(n):
|
||||
```python
|
||||
def fib(n):
|
||||
a = 1
|
||||
b = 1
|
||||
for i in range(n):
|
||||
yield a
|
||||
a, b = b, a + b
|
||||
|
||||
for x in fib(1000000):
|
||||
for x in fib(1000000):
|
||||
print(x)
|
||||
`
|
||||
```
|
||||
|
||||
### معلومات اكثر
|
||||
|
||||
|
||||
@ -8,44 +8,50 @@ localeTitle: كيفية تحويل السلاسل إلى أعداد صحيحة
|
||||
|
||||
#### مثال للاستخدام:
|
||||
|
||||
`# Here age is a string object
|
||||
age = "18"
|
||||
print(age)
|
||||
# Converting string to integer
|
||||
int_age = int(age)
|
||||
print(int_age)
|
||||
`
|
||||
```py
|
||||
# Here age is a string object
|
||||
age = "18"
|
||||
print(age)
|
||||
# Converting string to integer
|
||||
int_age = int(age)
|
||||
print(int_age)
|
||||
```
|
||||
|
||||
انتاج |
|
||||
|
||||
`18
|
||||
18
|
||||
`
|
||||
```py
|
||||
18
|
||||
18
|
||||
```
|
||||
|
||||
على الرغم من أن المخرجات متشابهة بصريًا ، إلا أنه يجب أن تضع في اعتبارك أن السطر الأول يطبع كائن سلسلة بينما يقوم السطر الموجود بجواره بطباعة كائن صحيح يتضح أكثر في المثال التالي:
|
||||
|
||||
`age = "18"
|
||||
print(age+2)
|
||||
`
|
||||
```py
|
||||
age = "18"
|
||||
print(age+2)
|
||||
```
|
||||
|
||||
انتاج:
|
||||
|
||||
`Traceback (most recent call last):
|
||||
```py
|
||||
Traceback (most recent call last):
|
||||
File "<stdin>", line 1, in <module>
|
||||
TypeError: cannot concatenate 'str' and 'int' objects
|
||||
`
|
||||
TypeError: cannot concatenate 'str' and 'int' objects
|
||||
```
|
||||
|
||||
`The error should make it clear to you that you need to convert the` الكائن age إلى عدد صحيح قبل إضافة شيء إليه.
|
||||
|
||||
`age = "18"
|
||||
age_int = int(age)
|
||||
print(age_int+2)
|
||||
`
|
||||
```py
|
||||
age = "18"
|
||||
age_int = int(age)
|
||||
print(age_int+2)
|
||||
```
|
||||
|
||||
انتاج:
|
||||
|
||||
`20
|
||||
`
|
||||
```py
|
||||
20
|
||||
```
|
||||
|
||||
لكن يجب أن تضع في اعتبارك بعض الحالات الخاصة:
|
||||
|
||||
|
||||
@ -6,49 +6,54 @@ localeTitle: إذا كانت بيانات Elif Else
|
||||
|
||||
تعد بنية `if` / `elif` / `else` طريقة شائعة للتحكم في تدفق البرنامج ، مما يسمح لك بتنفيذ مقاطع محددة من الكود بناءً على قيمة بعض البيانات. إذا كانت الحالة التالية للكلمة الرئيسية في `if` تقييمها `true` ، فسيتم تنفيذ كتلة الرمز: لاحظ أنه لا يتم استخدام الأقواس قبل وبعد التحقق من الشروط كما هو الحال في اللغات الأخرى.
|
||||
|
||||
`if True:
|
||||
```python
|
||||
if True:
|
||||
print('If block will execute!')
|
||||
`
|
||||
```
|
||||
|
||||
`x = 5
|
||||
```python
|
||||
x = 5
|
||||
|
||||
if x > 4:
|
||||
if x > 4:
|
||||
print("The condition was true!") #this statement executes
|
||||
`
|
||||
```
|
||||
|
||||
يمكنك إضافة اختياريا `else` ردا على ذلك سيتم تنفيذ إذا كان الشرط `false` :
|
||||
|
||||
`if not True:
|
||||
```python
|
||||
if not True:
|
||||
print('If statement will execute!')
|
||||
else:
|
||||
else:
|
||||
print('Else statement will execute!')
|
||||
`
|
||||
```
|
||||
|
||||
أو يمكنك أيضًا مشاهدة هذا المثال
|
||||
|
||||
`y = 3
|
||||
```python
|
||||
y = 3
|
||||
|
||||
if y > 4:
|
||||
if y > 4:
|
||||
print("I won't print!") #this statement does not execute
|
||||
else:
|
||||
else:
|
||||
print("The condition wasn't true!") #this statement executes
|
||||
`
|
||||
```
|
||||
|
||||
_لاحظ أنه لا يوجد شرط يتبع الكلمة الأساسية `else` - فإنه يضبط جميع الحالات التي يكون فيها الشرط `false`_
|
||||
|
||||
يمكن التحقق من الشروط المتعددة من خلال تضمين واحد أو أكثر من شيكات `elif` بعد العبارة الأولية `if` تنفيذ شرط واحد فقط:
|
||||
|
||||
`z = 7
|
||||
```python
|
||||
z = 7
|
||||
|
||||
if z > 8:
|
||||
if z > 8:
|
||||
print("I won't print!") #this statement does not execute
|
||||
elif z > 5:
|
||||
elif z > 5:
|
||||
print("I will!") #this statement will execute
|
||||
elif z > 6:
|
||||
elif z > 6:
|
||||
print("I also won't print!") #this statement does not execute
|
||||
else:
|
||||
else:
|
||||
print("Neither will I!") #this statement does not execute
|
||||
`
|
||||
```
|
||||
|
||||
_ملاحظة فقط الشرط الأول أن يقيم كما `true` سيتم تنفيذ. على الرغم من أن `z > 6` `true` ، فإن كتلة `if/elif/else` تنتهي بعد أول شرط حقيقي. هذا يعني أنه سيتم تنفيذ أمر `else` فقط إذا لم تكن أي من الشروط `true` ._
|
||||
|
||||
@ -56,16 +61,16 @@ _ملاحظة فقط الشرط الأول أن يقيم كما `true` سيتم
|
||||
|
||||
لنأخذ مثالاً على العثور على رقم أكبر من "10"
|
||||
|
||||
`python
|
||||
x = 34
|
||||
if x % 2 == 0: # this is how you create a comment and now, checking for even.
|
||||
```python
|
||||
x = 34
|
||||
if x % 2 == 0: # this is how you create a comment and now, checking for even.
|
||||
if x > 10:
|
||||
print("This number is even and is greater than 10")
|
||||
else:
|
||||
print("This number is even, but not greater 10")
|
||||
else:
|
||||
else:
|
||||
print ("The number is not even. So point checking further.")
|
||||
`
|
||||
```
|
||||
|
||||
كان هذا مجرد مثال بسيط للتداخل. لا تتردد في استكشاف المزيد عبر الإنترنت.
|
||||
|
||||
@ -75,16 +80,17 @@ _ملاحظة فقط الشرط الأول أن يقيم كما `true` سيتم
|
||||
|
||||
يمكننا أيضًا استخدام عبارات if-else في وظائف python المضمنة يجب أن يتحقق المثال التالي إذا كان الرقم أكبر من أو يساوي 50 ، إذا كانت الإجابة نعم صحيح:
|
||||
|
||||
`python
|
||||
x = 89
|
||||
is_greater = True if x >= 50 else False
|
||||
```python
|
||||
x = 89
|
||||
is_greater = True if x >= 50 else False
|
||||
|
||||
print(is_greater)
|
||||
`
|
||||
print(is_greater)
|
||||
```
|
||||
|
||||
انتاج |
|
||||
|
||||
`>
|
||||
True
|
||||
>
|
||||
`
|
||||
```
|
||||
>
|
||||
True
|
||||
>
|
||||
```
|
||||
|
||||
@ -34,8 +34,9 @@ localeTitle: الثعبان
|
||||
|
||||
`hello_campers.py`
|
||||
|
||||
`print('Hello campers!')
|
||||
`
|
||||
```python
|
||||
print('Hello campers!')
|
||||
```
|
||||
|
||||
من المحطة:
|
||||
|
||||
|
||||
@ -8,8 +8,9 @@ localeTitle: هل هناك طريقة لتدبير سلسلة في بايثون
|
||||
|
||||
يتبع هذا القالب:
|
||||
|
||||
`string[start: end: step]
|
||||
`
|
||||
```python
|
||||
string[start: end: step]
|
||||
```
|
||||
|
||||
أين،
|
||||
|
||||
@ -33,62 +34,72 @@ localeTitle: هل هناك طريقة لتدبير سلسلة في بايثون
|
||||
|
||||
* **احصل على أول 5 حروف من السلسلة**
|
||||
|
||||
`string = "freeCodeCamp"
|
||||
print(string[0:5])
|
||||
`
|
||||
```python
|
||||
string = "freeCodeCamp"
|
||||
print(string[0:5])
|
||||
```
|
||||
|
||||
انتاج:
|
||||
|
||||
`> freeC
|
||||
`
|
||||
```shell
|
||||
> freeC
|
||||
```
|
||||
|
||||
ملاحظة: تقوم `print(string[:5])` بإرجاع نفس نتيجة `print(string[0:5])`
|
||||
|
||||
* **الحصول على سلسلة فرعية من طول 4 من الحرف الثالث للسلسلة**
|
||||
|
||||
`string = "freeCodeCamp"
|
||||
print(string[2:6])
|
||||
`
|
||||
```python
|
||||
string = "freeCodeCamp"
|
||||
print(string[2:6])
|
||||
```
|
||||
|
||||
انتاج:
|
||||
|
||||
`> eeCo
|
||||
`
|
||||
```shell
|
||||
> eeCo
|
||||
```
|
||||
|
||||
يرجى ملاحظة أن مؤشر البداية أو النهاية قد يكون رقمًا سالبًا. الفهرس السالب يعني أن تبدأ العد من نهاية السلسلة بدلاً من البداية (أي من اليمين إلى اليسار). يمثل الفهرس -1 الحرف الأخير في السلسلة ، حيث يمثل -2 الحرف الثاني إلى الأخير وما إلى ذلك ...
|
||||
|
||||
* **الحصول على الحرف الأخير من السلسلة**
|
||||
|
||||
`string = "freeCodeCamp"
|
||||
print(string[-1])
|
||||
`
|
||||
```python
|
||||
string = "freeCodeCamp"
|
||||
print(string[-1])
|
||||
```
|
||||
|
||||
انتاج:
|
||||
|
||||
`> p
|
||||
`
|
||||
```shell
|
||||
> p
|
||||
```
|
||||
|
||||
* **احصل على آخر 5 حروف من السلسلة**
|
||||
|
||||
`string = "freeCodeCamp"
|
||||
print(string[-5:])
|
||||
`
|
||||
```python
|
||||
string = "freeCodeCamp"
|
||||
print(string[-5:])
|
||||
```
|
||||
|
||||
انتاج:
|
||||
|
||||
`> eCamp
|
||||
`
|
||||
```shell
|
||||
> eCamp
|
||||
```
|
||||
|
||||
* **الحصول على سلسلة فرعية تحتوي على جميع الحروف ما عدا آخر 4 أحرف والحرف الأول**
|
||||
|
||||
`string = "freeCodeCamp"
|
||||
print(string[1:-4])
|
||||
`
|
||||
```python
|
||||
string = "freeCodeCamp"
|
||||
print(string[1:-4])
|
||||
```
|
||||
|
||||
انتاج:
|
||||
|
||||
`> reeCode
|
||||
`
|
||||
```shell
|
||||
> reeCode
|
||||
```
|
||||
|
||||
#### مزيد من الأمثلة
|
||||
|
||||
@ -100,11 +111,13 @@ localeTitle: هل هناك طريقة لتدبير سلسلة في بايثون
|
||||
|
||||
* **الحصول على كل شخصية أخرى من سلسلة**
|
||||
|
||||
`string = "freeCodeCamp"
|
||||
print(string[::2])
|
||||
`
|
||||
```python
|
||||
string = "freeCodeCamp"
|
||||
print(string[::2])
|
||||
```
|
||||
|
||||
انتاج:
|
||||
|
||||
`> feCdCm
|
||||
`
|
||||
```shell
|
||||
> feCdCm
|
||||
```
|
||||
@ -8,34 +8,37 @@ Itertools هو وحدة بيثون من الوظائف التي تعيد الم
|
||||
|
||||
تأخذ الدالة chain () عدة متكررات كوسيطة وتعطي مكررًا واحدًا ينتج محتوياتها كلها كما لو أنها جاءت من تسلسل واحد.
|
||||
|
||||
`import itertools
|
||||
list(itertools.chain([1, 2], [3, 4]))
|
||||
```py
|
||||
import itertools
|
||||
list(itertools.chain([1, 2], [3, 4]))
|
||||
|
||||
# Output
|
||||
# [1, 2, 3, 4]
|
||||
`
|
||||
# Output
|
||||
# [1, 2, 3, 4]
|
||||
```
|
||||
|
||||
### islice ()
|
||||
|
||||
ترجع الدالة islice () إلى تكرار الذي يعيد العناصر المحددة من مدخلات الإدخال ، حسب الفهرس. يأخذ نفس الوسيطات مثل عامل تشغيل الشرائح للقوائم: البدء والتوقف والخطوة. بدء وإيقاف اختيارية.
|
||||
|
||||
`import itertools
|
||||
list(itertools.islice(count(), 5))
|
||||
```py
|
||||
import itertools
|
||||
list(itertools.islice(count(), 5))
|
||||
|
||||
# Output
|
||||
# [0,1, 2, 3, 4]
|
||||
`
|
||||
# Output
|
||||
# [0,1, 2, 3, 4]
|
||||
```
|
||||
|
||||
### izip ()
|
||||
|
||||
تُرجع izip () أداة تكرار تجمع عناصر عدة وحدات تكرارية في مجموعات. يعمل مثل zip () وظيفة مدمجة ، إلا أنه يعيد مكررًا بدلاً من قائمة.
|
||||
|
||||
`import itertools
|
||||
list(izip([1, 2, 3], ['a', 'b', 'c']))
|
||||
```py
|
||||
import itertools
|
||||
list(izip([1, 2, 3], ['a', 'b', 'c']))
|
||||
|
||||
# Output
|
||||
# [(1, 'a'),(2, 'b'),(3, 'c')]
|
||||
`
|
||||
# Output
|
||||
# [(1, 'a'),(2, 'b'),(3, 'c')]
|
||||
```
|
||||
|
||||
تكرارات Combinatoric:
|
||||
|
||||
|
||||
@ -16,15 +16,16 @@ localeTitle: تعبيرات لامدا
|
||||
|
||||
#### كود المثال
|
||||
|
||||
`# Lambda function to calculate square of a number
|
||||
square = lambda x: x ** 2
|
||||
print(square(3)) # Output: 9
|
||||
```py
|
||||
# Lambda function to calculate square of a number
|
||||
square = lambda x: x ** 2
|
||||
print(square(3)) # Output: 9
|
||||
|
||||
# Traditional function to calculate square of a number
|
||||
def square1(num):
|
||||
# Traditional function to calculate square of a number
|
||||
def square1(num):
|
||||
return num ** 2
|
||||
print(square(5)) # Output: 25
|
||||
`
|
||||
print(square(5)) # Output: 25
|
||||
```
|
||||
|
||||
في المثال lambda أعلاه lambda `lambda x: x ** 2` ينتج كائن دالة مجهول يمكن ربطه بأي اسم. لذا ، قمنا بربط كائن الدالة مع `square` وبالتالي من الآن فصاعداً يمكننا استدعاء الكائن `square` مثل أي وظيفة تقليدية. مثل `square(10)`
|
||||
|
||||
@ -32,22 +33,25 @@ localeTitle: تعبيرات لامدا
|
||||
|
||||
### مبتدئ
|
||||
|
||||
`lambda_func = lambda x: x**2 # Function that takes an integer and returns its square
|
||||
lambda_func(3) # Returns 9
|
||||
`
|
||||
```py
|
||||
lambda_func = lambda x: x**2 # Function that takes an integer and returns its square
|
||||
lambda_func(3) # Returns 9
|
||||
```
|
||||
|
||||
### متوسط
|
||||
|
||||
`lambda_func = lambda x: True if x**2 >= 10 else False
|
||||
lambda_func(3) # Returns False
|
||||
lambda_func(4) # Returns True
|
||||
`
|
||||
```py
|
||||
lambda_func = lambda x: True if x**2 >= 10 else False
|
||||
lambda_func(3) # Returns False
|
||||
lambda_func(4) # Returns True
|
||||
```
|
||||
|
||||
### مركب
|
||||
|
||||
`my_dict = {"A": 1, "B": 2, "C": 3}
|
||||
sorted(my_dict, key=lambda x: my_dict[x]%3) # Returns ['C', 'A', 'B']
|
||||
`
|
||||
```py
|
||||
my_dict = {"A": 1, "B": 2, "C": 3}
|
||||
sorted(my_dict, key=lambda x: my_dict[x]%3) # Returns ['C', 'A', 'B']
|
||||
```
|
||||
|
||||
### حالة الاستخدام
|
||||
|
||||
|
||||
@ -10,23 +10,26 @@ localeTitle: تعرف على مجموعات بايثون
|
||||
|
||||
_لا_ يمكن استخدام الأقواس المتعرجة ، `{}` ، لإنشاء مجموعة فارغة:
|
||||
|
||||
`>>> not_set = {} # set constructor must be used to make empty sets.
|
||||
>>> type(not_set) # Empty curly brackets create empty dictionaries.
|
||||
<class 'dict'>
|
||||
`
|
||||
```python
|
||||
>>> not_set = {} # set constructor must be used to make empty sets.
|
||||
>>> type(not_set) # Empty curly brackets create empty dictionaries.
|
||||
<class 'dict'>
|
||||
```
|
||||
|
||||
يمكنك فقط إنشاء مجموعة فارغة باستخدام طريقة `set()` .
|
||||
|
||||
`>>> example_set = set()
|
||||
>>> type(example_set)
|
||||
<class 'set'>
|
||||
`
|
||||
```python
|
||||
>>> example_set = set()
|
||||
>>> type(example_set)
|
||||
<class 'set'>
|
||||
```
|
||||
|
||||
ومع ذلك ، إذا تم تضمين العناصر داخل الأقواس المتعرجة ، فسيكون بناء الجملة مقبولًا لإنشاء مجموعة.
|
||||
|
||||
`>>> example_set_2 = {1, 2, 3}
|
||||
>>> type(example_set_2)
|
||||
<class 'set'>
|
||||
`
|
||||
```python
|
||||
>>> example_set_2 = {1, 2, 3}
|
||||
>>> type(example_set_2)
|
||||
<class 'set'>
|
||||
```
|
||||
|
||||
\`
|
||||
@ -10,21 +10,23 @@ localeTitle: و
|
||||
|
||||
#### مثال للاستخدام
|
||||
|
||||
`from collections import deque
|
||||
queue = deque(["January", "February", "March", "April"] )
|
||||
```py
|
||||
from collections import deque
|
||||
queue = deque(["January", "February", "March", "April"] )
|
||||
|
||||
queue.append("May")
|
||||
queue.append("May")
|
||||
|
||||
queue.popleft()
|
||||
queue.popleft()
|
||||
queue.popleft()
|
||||
queue.popleft()
|
||||
|
||||
print "Spring months in the list: ", queue
|
||||
`
|
||||
print "Spring months in the list: ", queue
|
||||
```
|
||||
|
||||
#### انتاج |
|
||||
|
||||
`Spring months in the list: deque(['March', 'April', 'May'])
|
||||
`
|
||||
```
|
||||
Spring months in the list: deque(['March', 'April', 'May'])
|
||||
```
|
||||
|
||||
#### معلومات اكثر:
|
||||
|
||||
|
||||
@ -10,69 +10,76 @@ localeTitle: قوائم
|
||||
|
||||
يتم إنشاء `list` فارغة باستخدام زوج من الأقواس المربعة:
|
||||
|
||||
`>>> empty_list = []
|
||||
>>> type(empty_list)
|
||||
<class 'list'>
|
||||
>>> len(empty_list)
|
||||
0
|
||||
`
|
||||
```shell
|
||||
>>> empty_list = []
|
||||
>>> type(empty_list)
|
||||
<class 'list'>
|
||||
>>> len(empty_list)
|
||||
0
|
||||
```
|
||||
|
||||
يمكن إنشاء `list` بعناصر من خلال تضمين قائمة عناصر مفصولة بفواصل مع أقواس مربعة. تسمح القوائم بأن تكون العناصر من أنواع مختلفة (غير متجانسة) ولكنها الأكثر شيوعًا من نوع واحد (متجانس):
|
||||
|
||||
`>>> homogeneous_list = [1, 1, 2, 3, 5, 8]
|
||||
>>> type(homogeneous_list)
|
||||
<class 'list'>
|
||||
>>> print(homogeneous_list)
|
||||
[1, 1, 2, 3, 5, 8]
|
||||
>>> len(homogeneous_list)
|
||||
6
|
||||
>>> heterogeneous_list = [1, "Hello Campers!"]
|
||||
>>> print(heterogeneous_list)
|
||||
[1, "Hello Campers!"]
|
||||
>>> len(heterogeneous_list)
|
||||
2
|
||||
`
|
||||
```shell
|
||||
>>> homogeneous_list = [1, 1, 2, 3, 5, 8]
|
||||
>>> type(homogeneous_list)
|
||||
<class 'list'>
|
||||
>>> print(homogeneous_list)
|
||||
[1, 1, 2, 3, 5, 8]
|
||||
>>> len(homogeneous_list)
|
||||
6
|
||||
>>> heterogeneous_list = [1, "Hello Campers!"]
|
||||
>>> print(heterogeneous_list)
|
||||
[1, "Hello Campers!"]
|
||||
>>> len(heterogeneous_list)
|
||||
2
|
||||
```
|
||||
|
||||
يمكن أيضًا استخدام مُنشئ `list` لإنشاء `list` :
|
||||
|
||||
`>>> empty_list = list() # Creates an empty list
|
||||
>>> print(empty_list)
|
||||
[]
|
||||
>>> list_from_iterable = list("Hello campers!") # Creates a list from an iterable.
|
||||
>>> print(list_from_iterable)
|
||||
['H', 'e', 'l', 'l', 'o', ' ', 'c', 'a', 'm', 'p', 'e', 'r', 's', '!']
|
||||
`
|
||||
```shell
|
||||
>>> empty_list = list() # Creates an empty list
|
||||
>>> print(empty_list)
|
||||
[]
|
||||
>>> list_from_iterable = list("Hello campers!") # Creates a list from an iterable.
|
||||
>>> print(list_from_iterable)
|
||||
['H', 'e', 'l', 'l', 'o', ' ', 'c', 'a', 'm', 'p', 'e', 'r', 's', '!']
|
||||
```
|
||||
|
||||
**الوصول إلى عناصر `list` :**
|
||||
|
||||
`>>> my_list = [1, 2, 9, 16, 25]
|
||||
>>> print(my_list)
|
||||
[1, 2, 9, 16, 25]
|
||||
`
|
||||
```shell
|
||||
>>> my_list = [1, 2, 9, 16, 25]
|
||||
>>> print(my_list)
|
||||
[1, 2, 9, 16, 25]
|
||||
```
|
||||
|
||||
_صفر مفهرسة_
|
||||
|
||||
`>>> my_list[0]
|
||||
1
|
||||
>>> my_list[1]
|
||||
2
|
||||
>>> my_list[2]
|
||||
9
|
||||
`
|
||||
```shell
|
||||
>>> my_list[0]
|
||||
1
|
||||
>>> my_list[1]
|
||||
2
|
||||
>>> my_list[2]
|
||||
9
|
||||
```
|
||||
|
||||
_التفاف حول الفهرسة_
|
||||
|
||||
`>>> my_list[-1]
|
||||
25
|
||||
>>> my_list[-2]
|
||||
16
|
||||
`
|
||||
```shell
|
||||
>>> my_list[-1]
|
||||
25
|
||||
>>> my_list[-2]
|
||||
16
|
||||
```
|
||||
|
||||
_تفريغ قوائم python-3_
|
||||
|
||||
`>>> print(*my_list)
|
||||
1 2 9 16 25
|
||||
`
|
||||
```shell
|
||||
>>> print(*my_list)
|
||||
1 2 9 16 25
|
||||
```
|
||||
|
||||
**متقلب:**
|
||||
|
||||
@ -82,12 +89,13 @@ _إعادة ترتيب العناصر في قائمة_
|
||||
|
||||
يمكن استخراج عناصر من `list` وإعادة ترتيبها باستخدام `list` أخرى كمؤشر.
|
||||
|
||||
`>>> my_list = [1, 2, 9, 16, 25, 34, 53, 21]
|
||||
>>> my_index = [5, 2, 0]
|
||||
>>> my_new_list = [my_list[i] for i in my_index]
|
||||
>>> print(my_new_list)
|
||||
[34, 9, 1]
|
||||
`
|
||||
```shell
|
||||
>>> my_list = [1, 2, 9, 16, 25, 34, 53, 21]
|
||||
>>> my_index = [5, 2, 0]
|
||||
>>> my_new_list = [my_list[i] for i in my_index]
|
||||
>>> print(my_new_list)
|
||||
[34, 9, 1]
|
||||
```
|
||||
|
||||
**TODO: أي من هذه الأسئلة يجب مناقشته هنا:**
|
||||
|
||||
|
||||
@ -8,15 +8,17 @@ localeTitle: قائمة طريقة إلحاق
|
||||
|
||||
#### مثال للاستخدام
|
||||
|
||||
`words = ["I", "love", "Python"]
|
||||
words.append("very much")
|
||||
print(words)
|
||||
`
|
||||
```py
|
||||
words = ["I", "love", "Python"]
|
||||
words.append("very much")
|
||||
print(words)
|
||||
```
|
||||
|
||||
#### انتاج |
|
||||
|
||||
`["I", "love", "Python", "very much"]
|
||||
`
|
||||
```
|
||||
["I", "love", "Python", "very much"]
|
||||
```
|
||||
|
||||
كما قد تلاحظ أن العنصر `"very much"` يتم إلحاقه بالقائمة.
|
||||
|
||||
|
||||
@ -8,49 +8,53 @@ localeTitle: قائمة الفهم
|
||||
|
||||
الخطوة الأولى في تعلم كيفية استخدام فهم القائمة هي النظر إلى الطريقة التقليدية للتكرار من خلال قائمة. فيما يلي مثال بسيط يقوم بإرجاع قائمة جديدة بالأرقام الزوجية.
|
||||
|
||||
`# Example list for demonstration
|
||||
some_list = [1, 2, 5, 7, 8, 10]
|
||||
```python
|
||||
# Example list for demonstration
|
||||
some_list = [1, 2, 5, 7, 8, 10]
|
||||
|
||||
# Empty list that will be populate with a loop
|
||||
even_list = []
|
||||
# Empty list that will be populate with a loop
|
||||
even_list = []
|
||||
|
||||
for number in some_list:
|
||||
for number in some_list:
|
||||
if number % 2 == 0:
|
||||
even_list.append(number)
|
||||
|
||||
# even_list now equals [2, 8, 10]
|
||||
`
|
||||
# even_list now equals [2, 8, 10]
|
||||
```
|
||||
|
||||
أولا يتم إنشاء قائمة مع بعض الأرقام. تقوم بعد ذلك بإنشاء قائمة فارغة ستحمل نتائجك من الحلقة. في الحلقة ، تحقق مما إذا كان كل رقم قابل للقسمة على 2 ، وفي هذه الحالة ، يمكنك إضافته إلى even\_list. استغرق هذا خمسة أسطر من الشفرة لا تشمل التعليقات والمساحة البيضاء التي ليست كثيرة في هذا المثال.
|
||||
|
||||
الآن على سبيل المثال فهم القائمة.
|
||||
|
||||
`# Example list for demonstration
|
||||
some_list = [1, 2, 5, 7, 8, 10]
|
||||
```python
|
||||
# Example list for demonstration
|
||||
some_list = [1, 2, 5, 7, 8, 10]
|
||||
|
||||
# List Comprehension
|
||||
even_list = [number for number in some_list if number % 2 == 0]
|
||||
# List Comprehension
|
||||
even_list = [number for number in some_list if number % 2 == 0]
|
||||
|
||||
# even_list now equals [2, 8, 10]
|
||||
`
|
||||
# even_list now equals [2, 8, 10]
|
||||
```
|
||||
|
||||
مثال آخر ، مع نفس الخطوتين: سيؤدي ما يلي إلى إنشاء قائمة بالأرقام التي تتوافق مع الأرقام الموجودة في `my_starting_list` مضروبة في 7.
|
||||
|
||||
`my_starting_list = [1, 2, 3, 4, 5, 6, 7, 8]
|
||||
my_new_list = []
|
||||
```py
|
||||
my_starting_list = [1, 2, 3, 4, 5, 6, 7, 8]
|
||||
my_new_list = []
|
||||
|
||||
for item in my_starting_list:
|
||||
my_new_list.append(item * 7)
|
||||
`
|
||||
for item in my_starting_list:
|
||||
my_new_list.append(item * 7)
|
||||
```
|
||||
|
||||
عند تشغيل هذا الرمز ، تكون القيمة النهائية لـ `my_new_list` هي: `[7, 14, 21, 28, 35, 42, 49, 56]`
|
||||
|
||||
يمكن لمطوّر البرامج الذي يستخدم فهم القوائم تحقيق النتيجة نفسها باستخدام فهم القائمة التالي ، مما يؤدي إلى نفس `my_new_list` .
|
||||
|
||||
`my_starting_list = [1, 2, 3, 4, 5, 6, 7, 8]
|
||||
```py
|
||||
my_starting_list = [1, 2, 3, 4, 5, 6, 7, 8]
|
||||
|
||||
my_new_list = [item * 7 for item in my_starting_list]
|
||||
`
|
||||
my_new_list = [item * 7 for item in my_starting_list]
|
||||
```
|
||||
|
||||
هناك صيغة بسيطة للكتابة بطريقة فهم قائمة هي:
|
||||
|
||||
@ -66,35 +70,40 @@ localeTitle: قائمة الفهم
|
||||
|
||||
يمكن التحكم في تدفق السيطرة في فهم القوائم باستخدام الشروط الشرطية. ل exmaple:
|
||||
|
||||
`only_even_list = [i for i in range(13) if i%2==0]
|
||||
`
|
||||
```py
|
||||
only_even_list = [i for i in range(13) if i%2==0]
|
||||
```
|
||||
|
||||
هذا يكافئ الحلقة التالية:
|
||||
|
||||
`only_even_list = list()
|
||||
for i in range(13):
|
||||
```py
|
||||
only_even_list = list()
|
||||
for i in range(13):
|
||||
if i%2 == 0:
|
||||
only_even_list.append(i)
|
||||
`
|
||||
```
|
||||
|
||||
يمكن للفهم قائمة تحتوي أيضا متداخلة إذا كانت الظروف. خذ بعين الاعتبار الحلقة التالية:
|
||||
|
||||
`divisible = list()
|
||||
for i in range(50):
|
||||
```py
|
||||
divisible = list()
|
||||
for i in range(50):
|
||||
if i%2 == 0:
|
||||
if i%3 == 0:
|
||||
divisible.append(i)
|
||||
`
|
||||
```
|
||||
|
||||
باستخدام فهرسة القوائم ، يمكن كتابة هذا على النحو التالي:
|
||||
|
||||
`divisible = [i for i in range(50) if i%2==0 if i%3==0]
|
||||
`
|
||||
```py
|
||||
divisible = [i for i in range(50) if i%2==0 if i%3==0]
|
||||
```
|
||||
|
||||
يمكن استخدام عبارة If-Else أيضًا مع فهم القائمة.
|
||||
|
||||
`list_1 = [i if i%2==0 else i*-1 for i in range(10)]
|
||||
`
|
||||
```py
|
||||
list_1 = [i if i%2==0 else i*-1 for i in range(10)]
|
||||
```
|
||||
|
||||
#### معلومات اكثر:
|
||||
|
||||
|
||||
@ -8,16 +8,18 @@ localeTitle: قائمة تمديد الأسلوب
|
||||
|
||||
#### مثال للاستخدام
|
||||
|
||||
`cities = ["San Francisco", "Los Angeles", "New York"]
|
||||
cities_in_texas = ["San Antonio", "Austin", "Dallas"]
|
||||
cities.extend(cities_in_texas)
|
||||
print(cities)
|
||||
`
|
||||
```py
|
||||
cities = ["San Francisco", "Los Angeles", "New York"]
|
||||
cities_in_texas = ["San Antonio", "Austin", "Dallas"]
|
||||
cities.extend(cities_in_texas)
|
||||
print(cities)
|
||||
```
|
||||
|
||||
#### انتاج |
|
||||
|
||||
`["San Francisco", "Los Angeles", "New York", "San Antonio", "Austin", "Dallas"]
|
||||
`
|
||||
```
|
||||
["San Francisco", "Los Angeles", "New York", "San Antonio", "Austin", "Dallas"]
|
||||
```
|
||||
|
||||
#### معلومات اكثر:
|
||||
|
||||
|
||||
@ -12,24 +12,26 @@ localeTitle: طريقة قائمة الفهرس
|
||||
|
||||
#### مثال للاستخدام:
|
||||
|
||||
`numbers = [1, 2, 2, 3, 9, 5, 6, 10]
|
||||
words = ["I", "love", "Python", "I", "love"]
|
||||
```py
|
||||
numbers = [1, 2, 2, 3, 9, 5, 6, 10]
|
||||
words = ["I", "love", "Python", "I", "love"]
|
||||
|
||||
print(numbers.index(9))
|
||||
print(numbers.index(2))
|
||||
print(words.index("I"))
|
||||
print(words.index("am"))
|
||||
`
|
||||
print(numbers.index(9))
|
||||
print(numbers.index(2))
|
||||
print(words.index("I"))
|
||||
print(words.index("am"))
|
||||
```
|
||||
|
||||
##### انتاج:
|
||||
|
||||
`4
|
||||
1
|
||||
0
|
||||
Traceback (most recent call last):
|
||||
```py
|
||||
4
|
||||
1
|
||||
0
|
||||
Traceback (most recent call last):
|
||||
File "<stdin>", line 1, in <module>
|
||||
ValueError: 'am' is not in list
|
||||
`
|
||||
ValueError: 'am' is not in list
|
||||
```
|
||||
|
||||
هنا يكون الناتج الأول واضحًا جدًا ، ولكن قد يبدو الثاني والثالث محيكين في البداية. لكن تذكر أن `index()` يعرض التواجد الأول للعنصر ، ومن ثم في هذه الحالة ، يكون `1` و `0` هما المؤشرين حيث `2` و `"I"` تحدثان أولاً في القوائم على التوالي.
|
||||
|
||||
@ -39,15 +41,17 @@ localeTitle: طريقة قائمة الفهرس
|
||||
|
||||
يمكنك أيضًا استخدام وسيطات اختيارية لتقييد بحثك على نسبة معينة من القائمة كما هو موضح في هذا المثال:
|
||||
|
||||
`words = ["I","am", "a", "I", "am", "Pythonista"]
|
||||
```py
|
||||
words = ["I","am", "a", "I", "am", "Pythonista"]
|
||||
|
||||
print(words.index("am",2,5))
|
||||
`
|
||||
print(words.index("am",2,5))
|
||||
```
|
||||
|
||||
##### انتاج:
|
||||
|
||||
`4
|
||||
`
|
||||
```
|
||||
4
|
||||
```
|
||||
|
||||
على الرغم من أنه يتم البحث عن العنصر بين الفهرس 2 (ضمنا) و 5 (غير شامل) ولكن يتم حساب الفهرس المرتجع بالنسبة لبداية القائمة الكاملة بدلاً من وسيطة البدء.
|
||||
|
||||
|
||||
@ -18,13 +18,14 @@ print "مدينة برزت هي:"، cities.pop () print "City at index 2 is:"،
|
||||
|
||||
يتم استخدام أسلوب `pop()` غالبًا بالتزامن مع `append()` لتنفيذ وظائف مكدس أساسية في تطبيق Python.
|
||||
|
||||
`stack = []
|
||||
```py
|
||||
stack = []
|
||||
|
||||
for i in range(5):
|
||||
for i in range(5):
|
||||
stack.append(i)
|
||||
|
||||
while len(stack):
|
||||
while len(stack):
|
||||
print(stack.pop())
|
||||
`
|
||||
```
|
||||
|
||||
\#### معلومات اكثر: يمكن العثور على الوثائق الرسمية لـ `pop()` [هنا](https://docs.python.org/3.6/tutorial/datastructures.html)
|
||||
@ -8,29 +8,33 @@ localeTitle: طريقة إزالة القائمة
|
||||
|
||||
#### مثال للاستخدام
|
||||
|
||||
`words = ["I", "love", "Python"]
|
||||
words.remove("I")
|
||||
print(words)
|
||||
`
|
||||
```py
|
||||
words = ["I", "love", "Python"]
|
||||
words.remove("I")
|
||||
print(words)
|
||||
```
|
||||
|
||||
#### انتاج |
|
||||
|
||||
`["love","Python"]
|
||||
`
|
||||
```py
|
||||
["love","Python"]
|
||||
```
|
||||
|
||||
لاحظ أنه يقوم بإرجاع خطأ إذا لم يتم العثور على العنصر المراد إزالته في القائمة كما هو موضح في المثال أدناه.
|
||||
|
||||
`kiss = ["keep", "it", "simple", "stupid"]
|
||||
kiss.remove("complex")
|
||||
print(kiss)
|
||||
`
|
||||
```py
|
||||
kiss = ["keep", "it", "simple", "stupid"]
|
||||
kiss.remove("complex")
|
||||
print(kiss)
|
||||
```
|
||||
|
||||
#### انتاج |
|
||||
|
||||
`Traceback (most recent call last):
|
||||
```
|
||||
Traceback (most recent call last):
|
||||
File "<stdin>", line 1, in <module>
|
||||
ValueError: list.remove(x): x not in list
|
||||
`
|
||||
ValueError: list.remove(x): x not in list
|
||||
```
|
||||
|
||||
#### معلومات اكثر:
|
||||
|
||||
|
||||
@ -14,71 +14,78 @@ list.sort (مفتاح = ... ، عكس = \[صواب / خطأ\])
|
||||
|
||||
### مثال للاستخدام
|
||||
|
||||
`a = [4, 2, 5, 3, 1]
|
||||
a.sort()
|
||||
print a # prints [1, 2, 3, 4, 5]
|
||||
```py
|
||||
a = [4, 2, 5, 3, 1]
|
||||
a.sort()
|
||||
print a # prints [1, 2, 3, 4, 5]
|
||||
|
||||
b = ['free', 'code', 'camp']
|
||||
b.sort()
|
||||
print b # prints ['camp', 'code', 'free']
|
||||
`
|
||||
b = ['free', 'code', 'camp']
|
||||
b.sort()
|
||||
print b # prints ['camp', 'code', 'free']
|
||||
```
|
||||
|
||||
النظر في مثال مع المعلمة **العكسية**
|
||||
|
||||
`a = [4, 2, 5, 3, 1]
|
||||
```py
|
||||
a = [4, 2, 5, 3, 1]
|
||||
|
||||
#Sorts the list in descending order
|
||||
a.sort(reverse=True)
|
||||
#Sorts the list in descending order
|
||||
a.sort(reverse=True)
|
||||
|
||||
print a # prints [5, 4, 3, 2, 1]
|
||||
`
|
||||
print a # prints [5, 4, 3, 2, 1]
|
||||
```
|
||||
|
||||
إذا كنت تريد فرز القائمة بناءً على وظيفتك الخاصة ، فاستخدم المعلمة **الرئيسية** . في ما يلي مثال لفرز السلاسل في القائمة حسب الطول ، بترتيب تصاعدي
|
||||
|
||||
`a = ["hello", "hi", "hey"]
|
||||
```py
|
||||
a = ["hello", "hi", "hey"]
|
||||
|
||||
#The built-in len() function is given as an input to key parameter to sort the strings by length
|
||||
a.sort(key = len)
|
||||
#The built-in len() function is given as an input to key parameter to sort the strings by length
|
||||
a.sort(key = len)
|
||||
|
||||
print a # prints ['hi', 'hey', 'hello']
|
||||
`
|
||||
print a # prints ['hi', 'hey', 'hello']
|
||||
```
|
||||
|
||||
في ما يلي مثال آخر ، حيث تحتوي القائمة على مجموعات (الاسم والعمر). يوضح الاستخدام أدناه كيفية فرز القائمة حسب العمر ، بترتيب تصاعدي.
|
||||
|
||||
`#Consider the second element in the tuple for sorting
|
||||
>>> def compareByAge(element):
|
||||
... return element[1]
|
||||
```py
|
||||
#Consider the second element in the tuple for sorting
|
||||
>>> def compareByAge(element):
|
||||
... return element[1]
|
||||
|
||||
b = [('Adam', 20), ('Rahman', 30), ('Rahul', 25)]
|
||||
b = [('Adam', 20), ('Rahman', 30), ('Rahul', 25)]
|
||||
|
||||
#Sort the list by age
|
||||
b.sort(key = compareByAge)
|
||||
#Sort the list by age
|
||||
b.sort(key = compareByAge)
|
||||
|
||||
#Output
|
||||
print b # prints [('Adam', 20), ('Rahul', 25), ('Rahman', 30)]
|
||||
`
|
||||
#Output
|
||||
print b # prints [('Adam', 20), ('Rahul', 25), ('Rahman', 30)]
|
||||
```
|
||||
|
||||
### أساسيات الفرز
|
||||
|
||||
إن الفرز التصاعدي البسيط سهل للغاية - ما عليك سوى استدعاء الدالة sort (). تقوم بإرجاع قائمة تم فرزها:
|
||||
|
||||
`>>> sorted([5, 2, 3, 1, 4])
|
||||
[1, 2, 3, 4, 5]
|
||||
`
|
||||
```python
|
||||
>>> sorted([5, 2, 3, 1, 4])
|
||||
[1, 2, 3, 4, 5]
|
||||
```
|
||||
|
||||
يمكنك أيضا استخدام طريقة list.sort () من القائمة. يقوم بتعديل القائمة في المكان (ويعود بلا لتفادي الخلط). عادة ما يكون أقل ملاءمة من sorted () - ولكن إذا لم تكن في حاجة إلى القائمة الأصلية ، فستكون أكثر كفاءة.
|
||||
|
||||
`>>> a = [5, 2, 3, 1, 4]
|
||||
>>> a.sort()
|
||||
>>> a
|
||||
[1, 2, 3, 4, 5]
|
||||
`
|
||||
```python
|
||||
>>> a = [5, 2, 3, 1, 4]
|
||||
>>> a.sort()
|
||||
>>> a
|
||||
[1, 2, 3, 4, 5]
|
||||
```
|
||||
|
||||
اختلاف آخر هو أن طريقة list.sort () محددة فقط للقوائم. في المقابل ، تقبل الدالة sorted () أي أمر ممكن.
|
||||
|
||||
`>>> sorted({1: 'D', 2: 'B', 3: 'B', 4: 'E', 5: 'A'})
|
||||
[1, 2, 3, 4, 5]
|
||||
`
|
||||
```python
|
||||
>>> sorted({1: 'D', 2: 'B', 3: 'B', 4: 'E', 5: 'A'})
|
||||
[1, 2, 3, 4, 5]
|
||||
```
|
||||
|
||||
#### تفاصيل التنفيذ
|
||||
|
||||
|
||||
@ -8,20 +8,22 @@ localeTitle: بايثون أنواع رقمية
|
||||
|
||||
#### أمثلة:
|
||||
|
||||
`print(1)
|
||||
print(100)
|
||||
print(8435367)
|
||||
`
|
||||
```py
|
||||
print(1)
|
||||
print(100)
|
||||
print(8435367)
|
||||
```
|
||||
|
||||
* أرقام النقطة العائمة ( `float` )
|
||||
* [البناء](https://docs.python.org/3/library/functions.html#float)
|
||||
|
||||
#### أمثلة:
|
||||
|
||||
`print(1.5)
|
||||
print(46.84)
|
||||
print(84357.435)
|
||||
`
|
||||
```py
|
||||
print(1.5)
|
||||
print(46.84)
|
||||
print(84357.435)
|
||||
```
|
||||
|
||||
* ارقام مركبة
|
||||
* [البناء](https://docs.python.org/3/library/functions.html#complex)
|
||||
|
||||
@ -8,11 +8,12 @@ localeTitle: بيثون اورد وظيفة
|
||||
|
||||
#### أمثلة:
|
||||
|
||||
`>>> ord('d')
|
||||
100
|
||||
>>> ord('1')
|
||||
49
|
||||
`
|
||||
```
|
||||
>>> ord('d')
|
||||
100
|
||||
>>> ord('1')
|
||||
49
|
||||
```
|
||||
|
||||
## وظيفة chr
|
||||
|
||||
@ -20,15 +21,17 @@ localeTitle: بيثون اورد وظيفة
|
||||
|
||||
#### أمثلة:
|
||||
|
||||
`>>> chr(49)
|
||||
'1'
|
||||
`
|
||||
```
|
||||
>>> chr(49)
|
||||
'1'
|
||||
```
|
||||
|
||||
هناك أمر واحد يمكن ملاحظته ، إذا كانت قيمة العدد الصحيح التي تم تمريرها إلى `chr()` خارج النطاق ، فسيتم رفع قيمة ValueError.
|
||||
|
||||
`>>> chr(-10)
|
||||
'Traceback (most recent call last):
|
||||
```
|
||||
>>> chr(-10)
|
||||
'Traceback (most recent call last):
|
||||
File "<pyshell#24>", line 1, in <module>
|
||||
chr(-1)
|
||||
ValueError: chr() arg not in range(0x110000)'
|
||||
`
|
||||
ValueError: chr() arg not in range(0x110000)'
|
||||
```
|
||||
@ -14,10 +14,11 @@ localeTitle: بايثون بوكسي
|
||||
|
||||
## مثال
|
||||
|
||||
`print(pow(2,4)) # prints 16
|
||||
print(pow(10,-2)) # prints 0.01
|
||||
print(pow(4,3,5)) # prints 4
|
||||
`
|
||||
```python
|
||||
print(pow(2,4)) # prints 16
|
||||
print(pow(10,-2)) # prints 0.01
|
||||
print(pow(4,3,5)) # prints 4
|
||||
```
|
||||
|
||||
[كود ران](https://repl.it/CTGi)
|
||||
|
||||
|
||||
@ -8,8 +8,9 @@ localeTitle: Python 2 vs Python 3
|
||||
|
||||
ما يلي هو عبارة `print` صالحة في Python 2 ، ولكنها لا تعمل على Python 3:
|
||||
|
||||
`print "Hello World"
|
||||
`
|
||||
```py
|
||||
print "Hello World"
|
||||
```
|
||||
|
||||
في Python 3 ، يلقي نفس العبارة خطأ كالتالي:
|
||||
|
||||
@ -24,8 +25,9 @@ localeTitle: Python 2 vs Python 3
|
||||
|
||||
يعد استخدام وظيفة `print()` 'آمن' في كل من Python 2 و 3:
|
||||
|
||||
`print("Hello World")
|
||||
`
|
||||
```python
|
||||
print("Hello World")
|
||||
```
|
||||
|
||||
هناك فرق آخر بين Python 2 و Python 3 وهو بنية البيانات التي يتم إرجاعها عند استدعاء الدالة `map()` .
|
||||
|
||||
|
||||
@ -22,8 +22,9 @@ localeTitle: معايير الترميز
|
||||
|
||||
إليك كيفية التحقق مما إذا كان رمز python الخاص بك يتوافق مع المعايير.
|
||||
|
||||
`:~$ pip install pep8
|
||||
:~$ pep8 --first myCode.py
|
||||
`
|
||||
```console
|
||||
:~$ pip install pep8
|
||||
:~$ pep8 --first myCode.py
|
||||
```
|
||||
|
||||
سيعطي هذا كل تلك الخطوط التي تنتهك المعايير ، إلى جانب وصف قصير للإصلاحات.
|
||||
@ -27,8 +27,9 @@ localeTitle: واجهات برمجة التطبيقات REST مع Falcon
|
||||
|
||||
فكر في مورد ككيان تحتاج إليه واجهة برمجة التطبيقات. في حالتنا ، سيكون أفضل مورد هو `Timestamp` . عادةً ما يكون توجيهنا شيئًا كالتالي:
|
||||
|
||||
`GET /timestamp
|
||||
`
|
||||
```
|
||||
GET /timestamp
|
||||
```
|
||||
|
||||
هنا ، `GET` هو فعل HTTP المستخدم لاستدعاء نقطة النهاية هذه ، و `/timestamp` هو عنوان URL نفسه. الآن بعد أن حصلنا على هذا الجزء من الطريق ، دعنا ننشئ وحدة نمطية!
|
||||
|
||||
@ -36,12 +37,13 @@ localeTitle: واجهات برمجة التطبيقات REST مع Falcon
|
||||
|
||||
الوقت لاستيراد مكتبة الصقر:
|
||||
|
||||
`import json
|
||||
```python
|
||||
import json
|
||||
|
||||
import falcon
|
||||
import falcon
|
||||
|
||||
import arrow
|
||||
`
|
||||
import arrow
|
||||
```
|
||||
|
||||
لاحظ أننا قمنا أيضًا باستيراد حزمة `json` ومكتبة `arrow` . الآن ، دعنا نحدد فئة لموردنا:
|
||||
|
||||
@ -64,16 +66,17 @@ localeTitle: واجهات برمجة التطبيقات REST مع Falcon
|
||||
|
||||
الآن ، أضف الرمز أدناه:
|
||||
|
||||
`import falcon
|
||||
```python
|
||||
import falcon
|
||||
|
||||
from timestamp import Timestamp
|
||||
from timestamp import Timestamp
|
||||
|
||||
api = application = falcon.API()
|
||||
api = application = falcon.API()
|
||||
|
||||
timestamp = Timestamp()
|
||||
timestamp = Timestamp()
|
||||
|
||||
api.add_route('/timestamp', timestamp)
|
||||
`
|
||||
api.add_route('/timestamp', timestamp)
|
||||
```
|
||||
|
||||
هنا ، قمنا بتعريف واجهة برمجة تطبيقات Falcon ، وقمنا بتهيئة مثيل لفئة الموارد التي أنشأناها في وقت سابق. بعد ذلك ، قمنا `/timestamp` نقطة النهاية `/timestamp` مع مثيل الفصل - والآن نحن جاهزون للنجاح! لاختبار هذا API تثبيت `gunicorn` ( `pip install gunicorn` ) ، وتشغيل `gunicorn app` . استخدم Postman أو `cURL` بسيط لاختبار ذلك:
|
||||
|
||||
|
||||
@ -22,15 +22,17 @@ localeTitle: إعداد Python Web Framework Django وقارورة
|
||||
|
||||
إذا كنت قد قمت بالفعل بتثبيت برنامج `pip` فببساطة:
|
||||
|
||||
`$ pip install django
|
||||
`
|
||||
```
|
||||
$ pip install django
|
||||
```
|
||||
|
||||
بعد اكتمال التثبيت ، يمكننا إنشاء مشروع جديد:
|
||||
|
||||
`$ django-admin startproject myproject
|
||||
$ cd myproject
|
||||
$ python manage.py runserver
|
||||
`
|
||||
```
|
||||
$ django-admin startproject myproject
|
||||
$ cd myproject
|
||||
$ python manage.py runserver
|
||||
```
|
||||
|
||||
انتقل إلى `http://localhost:8000` ! :صاروخ:
|
||||
|
||||
|
||||
@ -8,12 +8,13 @@ localeTitle: النوم كيف يمكنني جعل التأخير في الوق
|
||||
|
||||
مثال:
|
||||
|
||||
`import time
|
||||
```
|
||||
import time
|
||||
|
||||
for letter in 'hello, world!':
|
||||
for letter in 'hello, world!':
|
||||
print(letter)
|
||||
time.sleep(2) # sleep 2 seconds between each print
|
||||
`
|
||||
```
|
||||
|
||||
يمكن إعطاء أرقام النقطة العائمة كوسيطة `sleep()` للحصول على أوقات نوم أكثر دقة.
|
||||
|
||||
|
||||
@ -10,12 +10,13 @@ localeTitle: طرق سلسلة
|
||||
|
||||
يتم إنشاء `string` فارغة باستخدام زوج من علامات الاقتباس أو apostrophes:
|
||||
|
||||
`>>> new_string = ''
|
||||
>>> type(new_string)
|
||||
<class 'string'>
|
||||
>>> len(new_string)
|
||||
0
|
||||
`
|
||||
```shell
|
||||
>>> new_string = ''
|
||||
>>> type(new_string)
|
||||
<class 'string'>
|
||||
>>> len(new_string)
|
||||
0
|
||||
```
|
||||
|
||||
[Python Docs - المزيد على سلاسل](https://docs.python.org/3/tutorial/datastructures.html#more-on-strings)
|
||||
|
||||
|
||||
@ -12,19 +12,21 @@ localeTitle: طريقة البحث عن سلسلة
|
||||
|
||||
مثال:
|
||||
|
||||
`>>> string = "Don't you call me a mindless philosopher, you overweight glob of grease!"
|
||||
>>> string.find('you')
|
||||
6
|
||||
>>> string.rfind('you')
|
||||
42
|
||||
`
|
||||
```shell
|
||||
>>> string = "Don't you call me a mindless philosopher, you overweight glob of grease!"
|
||||
>>> string.find('you')
|
||||
6
|
||||
>>> string.rfind('you')
|
||||
42
|
||||
```
|
||||
|
||||
إذا لم يتم العثور على السلسلة الفرعية ، يتم إرجاع -1.
|
||||
|
||||
`>>> string = "Don't you call me a mindless philosopher, you overweight glob of grease!"
|
||||
>>> string.find('you', 43) # find 'you' in string anywhere from position 43 to the end of the string
|
||||
-1
|
||||
`
|
||||
```shell
|
||||
>>> string = "Don't you call me a mindless philosopher, you overweight glob of grease!"
|
||||
>>> string.find('you', 43) # find 'you' in string anywhere from position 43 to the end of the string
|
||||
-1
|
||||
```
|
||||
|
||||
معلومات اكثر:
|
||||
|
||||
|
||||
@ -12,28 +12,33 @@ localeTitle: طريقة الانضمام إلى سلسلة
|
||||
|
||||
1) الانضمام إلى ist من السلاسل مع `":"`
|
||||
|
||||
`print ":".join(["freeCodeCamp", "is", "fun"])
|
||||
`
|
||||
```python
|
||||
print ":".join(["freeCodeCamp", "is", "fun"])
|
||||
```
|
||||
|
||||
انتاج |
|
||||
|
||||
`freeCodeCamp:is:fun
|
||||
`
|
||||
```shell
|
||||
freeCodeCamp:is:fun
|
||||
```
|
||||
|
||||
2) الانضمام إلى مجموعة من الأوتار مع `" and "`
|
||||
|
||||
`print " and ".join(["A", "B", "C"])
|
||||
`
|
||||
```python
|
||||
print " and ".join(["A", "B", "C"])
|
||||
```
|
||||
|
||||
انتاج |
|
||||
|
||||
`A and B and C
|
||||
`
|
||||
```shell
|
||||
A and B and C
|
||||
```
|
||||
|
||||
3) أدخل `" "` بعد كل حرف في سلسلة
|
||||
|
||||
`print " ".join("freeCodeCamp")
|
||||
`
|
||||
```python
|
||||
print " ".join("freeCodeCamp")
|
||||
```
|
||||
|
||||
انتاج:
|
||||
|
||||
@ -48,20 +53,23 @@ localeTitle: طريقة الانضمام إلى سلسلة
|
||||
|
||||
انتاج:
|
||||
|
||||
`program
|
||||
`
|
||||
```shell
|
||||
program
|
||||
```
|
||||
|
||||
5) الانضمام مع مجموعات.
|
||||
|
||||
`test = {'2', '1', '3'}
|
||||
s = ', '
|
||||
print(s.join(test))
|
||||
`
|
||||
```python
|
||||
test = {'2', '1', '3'}
|
||||
s = ', '
|
||||
print(s.join(test))
|
||||
```
|
||||
|
||||
انتاج:
|
||||
|
||||
`2, 3, 1
|
||||
`
|
||||
```shell
|
||||
2, 3, 1
|
||||
```
|
||||
|
||||
#### معلومات اكثر:
|
||||
|
||||
|
||||
@ -10,27 +10,31 @@ localeTitle: طريقة استبدال السلاسل
|
||||
|
||||
1. استبدال كافة تكرارات `"is"` بـ `"WAS"`
|
||||
|
||||
`string = "This is nice. This is good."
|
||||
newString = string.replace("is","WAS")
|
||||
print(newString)
|
||||
`
|
||||
```python
|
||||
string = "This is nice. This is good."
|
||||
newString = string.replace("is","WAS")
|
||||
print(newString)
|
||||
```
|
||||
|
||||
انتاج |
|
||||
|
||||
`ThWAS WAS nice. ThWAS WAS good.
|
||||
`
|
||||
```python
|
||||
ThWAS WAS nice. ThWAS WAS good.
|
||||
```
|
||||
|
||||
2. استبدال أول تكرارين لـ `"is"` بـ `"WAS"`
|
||||
|
||||
`string = "This is nice. This is good."
|
||||
newString = string.replace("is","WAS", 2)
|
||||
print(newString)
|
||||
`
|
||||
```python
|
||||
string = "This is nice. This is good."
|
||||
newString = string.replace("is","WAS", 2)
|
||||
print(newString)
|
||||
```
|
||||
|
||||
انتاج |
|
||||
|
||||
`ThWAS WAS nice. This is good.
|
||||
`
|
||||
```python
|
||||
ThWAS WAS nice. This is good.
|
||||
```
|
||||
|
||||
#### معلومات اكثر:
|
||||
|
||||
|
||||
@ -18,58 +18,68 @@ localeTitle: طريقة تقسيم السلسلة
|
||||
|
||||
1) سلسلة الانقسام في الفضاء: ""
|
||||
|
||||
`string = "freeCodeCamp is fun."
|
||||
print(string.split(" "))
|
||||
`
|
||||
```python
|
||||
string = "freeCodeCamp is fun."
|
||||
print(string.split(" "))
|
||||
```
|
||||
|
||||
انتاج:
|
||||
|
||||
`['freeCodeCamp', 'is', 'fun.']
|
||||
`
|
||||
```python
|
||||
['freeCodeCamp', 'is', 'fun.']
|
||||
```
|
||||
|
||||
2) سلسلة الانقسام في الفاصلة: "،"
|
||||
|
||||
`string = "freeCodeCamp,is fun, and informative"
|
||||
print(string.split(","))
|
||||
`
|
||||
```python
|
||||
string = "freeCodeCamp,is fun, and informative"
|
||||
print(string.split(","))
|
||||
```
|
||||
|
||||
انتاج:
|
||||
|
||||
`['freeCodeCamp', 'is fun', ' and informative']
|
||||
`
|
||||
```python
|
||||
['freeCodeCamp', 'is fun', ' and informative']
|
||||
```
|
||||
|
||||
3) لا يوجد `separator` محدد
|
||||
|
||||
`string = "freeCodeCamp is fun and informative"
|
||||
print(string.split())
|
||||
`
|
||||
```python
|
||||
string = "freeCodeCamp is fun and informative"
|
||||
print(string.split())
|
||||
```
|
||||
|
||||
انتاج:
|
||||
|
||||
`['freeCodeCamp', 'is', 'fun', 'and', 'informative']
|
||||
`
|
||||
```python
|
||||
['freeCodeCamp', 'is', 'fun', 'and', 'informative']
|
||||
```
|
||||
|
||||
ملاحظة: إذا لم يتم تحديد `separator` ، فسيتم تجريد السلسلة من **جميع** المسافات البيضاء
|
||||
|
||||
`string = "freeCodeCamp is fun and informative"
|
||||
print(string.split())
|
||||
`
|
||||
```python
|
||||
string = "freeCodeCamp is fun and informative"
|
||||
print(string.split())
|
||||
```
|
||||
|
||||
انتاج:
|
||||
|
||||
`['freeCodeCamp', 'is', 'fun', 'and', 'informative']
|
||||
`
|
||||
```python
|
||||
['freeCodeCamp', 'is', 'fun', 'and', 'informative']
|
||||
```
|
||||
|
||||
3) تقسيم السلسلة باستخدام `maxsplit` . هنا نقسم السلسلة على "" مرتين:
|
||||
|
||||
`string = "freeCodeCamp is fun and informative"
|
||||
print(string.split(" ", 2))
|
||||
`
|
||||
```python
|
||||
string = "freeCodeCamp is fun and informative"
|
||||
print(string.split(" ", 2))
|
||||
```
|
||||
|
||||
انتاج:
|
||||
|
||||
`['freeCodeCamp', 'is', 'fun and informative']
|
||||
`
|
||||
```python
|
||||
['freeCodeCamp', 'is', 'fun and informative']
|
||||
```
|
||||
|
||||
#### معلومات اكثر
|
||||
|
||||
|
||||
@ -10,24 +10,26 @@ localeTitle: طريقة قطاع سترينج
|
||||
|
||||
مثال:
|
||||
|
||||
`>>> string = ' Hello, World! '
|
||||
>>> strip_beginning = string.lstrip()
|
||||
>>> strip_beginning
|
||||
'Hello, World! '
|
||||
>>> strip_end = string.rstrip()
|
||||
>>> strip_end
|
||||
' Hello, World!'
|
||||
>>> strip_both = string.strip()
|
||||
>>> strip_both
|
||||
'Hello, World!'
|
||||
`
|
||||
```py
|
||||
>>> string = ' Hello, World! '
|
||||
>>> strip_beginning = string.lstrip()
|
||||
>>> strip_beginning
|
||||
'Hello, World! '
|
||||
>>> strip_end = string.rstrip()
|
||||
>>> strip_end
|
||||
' Hello, World!'
|
||||
>>> strip_both = string.strip()
|
||||
>>> strip_both
|
||||
'Hello, World!'
|
||||
```
|
||||
|
||||
يمكن تقديم وسيطة اختيارية كسلسلة تحتوي على كل الحروف التي ترغب في تجريدها.
|
||||
|
||||
`>>> url = 'www.example.com/'
|
||||
>>> url.strip('w./')
|
||||
'example.com'
|
||||
`
|
||||
```py
|
||||
>>> url = 'www.example.com/'
|
||||
>>> url.strip('w./')
|
||||
'example.com'
|
||||
```
|
||||
|
||||
ومع ذلك ، هل لاحظ أن الأول فقط `.` جردت من الخيط ويرجع ذلك إلى أن وظيفة `strip` فقط بتمييز أحرف الوسيطة الموجودة على اليسار أو أقصى اليمين. منذ w يأتي قبل الأول `.` يتم تجريدهم معا، بينما "com" موجود في النهاية الصحيحة قبل `.` بعد تجريد `/`
|
||||
|
||||
|
||||
@ -14,24 +14,26 @@ localeTitle: Python Ternary Operater
|
||||
|
||||
#### إدخال
|
||||
|
||||
`for val in range(1, 11):
|
||||
```python
|
||||
for val in range(1, 11):
|
||||
is_even = "Even" if val % 2 == 0 else "Odd"
|
||||
print(val, is_even, sep=' = ')
|
||||
`
|
||||
```
|
||||
|
||||
#### انتاج |
|
||||
|
||||
`1 = Odd
|
||||
2 = Even
|
||||
3 = Odd
|
||||
4 = Even
|
||||
5 = Odd
|
||||
6 = Even
|
||||
7 = Odd
|
||||
8 = Even
|
||||
9 = Odd
|
||||
10 = Even
|
||||
`
|
||||
```
|
||||
1 = Odd
|
||||
2 = Even
|
||||
3 = Odd
|
||||
4 = Even
|
||||
5 = Odd
|
||||
6 = Even
|
||||
7 = Odd
|
||||
8 = Even
|
||||
9 = Odd
|
||||
10 = Even
|
||||
```
|
||||
|
||||
### مصادر
|
||||
|
||||
|
||||
@ -21,41 +21,47 @@ localeTitle: البيئات الافتراضية
|
||||
|
||||
يمكنك تثبيته مع `pip` :
|
||||
|
||||
`pip install virtualenv
|
||||
`
|
||||
```
|
||||
pip install virtualenv
|
||||
```
|
||||
|
||||
تحقق من التثبيت باستخدام الأمر التالي:
|
||||
|
||||
`virtualenv --version
|
||||
`
|
||||
```
|
||||
virtualenv --version
|
||||
```
|
||||
|
||||
### إنشاء environemnt
|
||||
|
||||
لإنشاء استخدام بيئة افتراضية:
|
||||
|
||||
`virtualenv --no-site-packages my-env
|
||||
`
|
||||
```
|
||||
virtualenv --no-site-packages my-env
|
||||
```
|
||||
|
||||
يؤدي هذا إلى إنشاء مجلد في الدليل الحالي باسم البيئة ( `my-env/` ). يحتوي هذا المجلد على الدلائل لتثبيت الوحدات النمطية والملفات التنفيذية Python.
|
||||
|
||||
يمكنك أيضًا تحديد إصدار Python الذي تريد العمل به. ما عليك `--python=/path/to/python/version` استخدام الوسيطة `--python=/path/to/python/version` . على سبيل المثال ، `python2.7` :
|
||||
|
||||
`virtualenv --python=/usr/bin/python2.7 my-env
|
||||
`
|
||||
```
|
||||
virtualenv --python=/usr/bin/python2.7 my-env
|
||||
```
|
||||
|
||||
### قائمة البيئات
|
||||
|
||||
يمكنك إدراج البيئات المتاحة مع:
|
||||
|
||||
`lsvirtualenv
|
||||
`
|
||||
```
|
||||
lsvirtualenv
|
||||
```
|
||||
|
||||
### تفعيل بيئة
|
||||
|
||||
قبل أن تتمكن من البدء في استخدام البيئة ، يلزمك تنشيطها:
|
||||
|
||||
`source my-env/bin/activate
|
||||
`
|
||||
```
|
||||
source my-env/bin/activate
|
||||
```
|
||||
|
||||
هذا يضمن أن يتم استخدام حزم فقط تحت `my-env/` .
|
||||
|
||||
@ -65,14 +71,16 @@ localeTitle: البيئات الافتراضية
|
||||
|
||||
يمكنك تثبيت الحزم واحدة تلو الأخرى ، أو عن طريق تعيين ملف `requirements.txt` لمشروعك.
|
||||
|
||||
`pip install some-package
|
||||
pip install -r requirements.txt
|
||||
`
|
||||
```
|
||||
pip install some-package
|
||||
pip install -r requirements.txt
|
||||
```
|
||||
|
||||
إذا كنت تريد إنشاء ملف `requirements.txt` من الحزم المثبتة بالفعل ، فقم بتشغيل الأمر التالي:
|
||||
|
||||
`pip freeze > requirements.txt
|
||||
`
|
||||
```
|
||||
pip freeze > requirements.txt
|
||||
```
|
||||
|
||||
سيحتوي الملف على قائمة بجميع الحزم المثبتة في البيئة الحالية ، والإصدارات الخاصة بها. سيساعدك هذا على إطلاق مشروعك باستخدام الوحدات التابعة الخاصة به.
|
||||
|
||||
@ -80,8 +88,9 @@ localeTitle: البيئات الافتراضية
|
||||
|
||||
إذا انتهيت من العمل مع البيئة الافتراضية ، يمكنك إلغاء تنشيطها باستخدام:
|
||||
|
||||
`deactivate
|
||||
`
|
||||
```
|
||||
deactivate
|
||||
```
|
||||
|
||||
هذا يعيدك إلى مترجم Python الافتراضي الخاص بالنظام مع كافة المكتبات المثبتة به.
|
||||
|
||||
@ -99,29 +108,33 @@ localeTitle: البيئات الافتراضية
|
||||
|
||||
لإنشاء استخدام بيئة افتراضية:
|
||||
|
||||
`conda create --name my-env
|
||||
`
|
||||
```
|
||||
conda create --name my-env
|
||||
```
|
||||
|
||||
سوف Conda إنشاء مجلد المقابلة داخل دليل التثبيت كوندا.
|
||||
|
||||
يمكنك أيضًا تحديد إصدار Python الذي تريد العمل معه:
|
||||
|
||||
`conda create --name my-env python=3.6
|
||||
`
|
||||
```
|
||||
conda create --name my-env python=3.6
|
||||
```
|
||||
|
||||
### قائمة البيئات
|
||||
|
||||
يمكنك سرد جميع البيئات المتاحة مع:
|
||||
|
||||
`conda info --envs
|
||||
`
|
||||
```
|
||||
conda info --envs
|
||||
```
|
||||
|
||||
### تفعيل بيئة
|
||||
|
||||
قبل أن تتمكن من البدء في استخدام البيئة ، يلزمك تنشيطها:
|
||||
|
||||
`source activate my-env
|
||||
`
|
||||
```
|
||||
source activate my-env
|
||||
```
|
||||
|
||||
### تثبيت الحزم
|
||||
|
||||
@ -131,15 +144,17 @@ localeTitle: البيئات الافتراضية
|
||||
|
||||
إذا انتهيت من العمل مع البيئة الافتراضية ، يمكنك إلغاء تنشيطها باستخدام:
|
||||
|
||||
`source deactivate
|
||||
`
|
||||
```
|
||||
source deactivate
|
||||
```
|
||||
|
||||
### قم بإزالة بيئة
|
||||
|
||||
إذا كنت تريد إزالة بيئة من استخدام Conda:
|
||||
|
||||
`conda remove --name my-env
|
||||
`
|
||||
```
|
||||
conda remove --name my-env
|
||||
```
|
||||
|
||||
#### معلومات اكثر:
|
||||
|
||||
|
||||
@ -8,11 +8,12 @@ localeTitle: في حين لووب البيانات
|
||||
|
||||
البنية الأساسية هي:
|
||||
|
||||
`counter = 0
|
||||
while counter < 10:
|
||||
```python
|
||||
counter = 0
|
||||
while counter < 10:
|
||||
# Execute the block of code here as
|
||||
# long as counter is less than 10
|
||||
`
|
||||
```
|
||||
|
||||
ويرد أدناه مثال على ذلك:
|
||||
|
||||
@ -25,14 +26,15 @@ localeTitle: في حين لووب البيانات
|
||||
|
||||
انتاج:
|
||||
|
||||
`Today is Monday
|
||||
Today is Tuesday
|
||||
Today is Wednesday
|
||||
Today is Thursday
|
||||
Today is Friday
|
||||
Today is Saturday
|
||||
Today is Sunday
|
||||
`
|
||||
```
|
||||
Today is Monday
|
||||
Today is Tuesday
|
||||
Today is Wednesday
|
||||
Today is Thursday
|
||||
Today is Friday
|
||||
Today is Saturday
|
||||
Today is Sunday
|
||||
```
|
||||
|
||||
شرح سطر بواسطة سطر التعليمات البرمجية أعلاه:
|
||||
|
||||
|
||||
@ -131,35 +131,38 @@ localeTitle: وظائف في R
|
||||
* على سبيل المثال ، يمكنك تقريب رقم مع `round()` أو حسابه مع عامل به مع `factorial()` .
|
||||
|
||||
|
||||
`> round(4.147)
|
||||
[1] 4
|
||||
> factorial(3)
|
||||
[1] 6
|
||||
> round(mean(1:6))
|
||||
[1] 4
|
||||
`
|
||||
```r
|
||||
> round(4.147)
|
||||
[1] 4
|
||||
> factorial(3)
|
||||
[1] 6
|
||||
> round(mean(1:6))
|
||||
[1] 4
|
||||
```
|
||||
|
||||
* تسمى البيانات التي تمررها إلى الدالة وسيطة الدالة.
|
||||
|
||||
* يمكنك محاكاة لفة من الموت مع الدالة R `sample()` . تأخذ الدالة `sample()` الوسيطتين: المتجه المسمى x ورقم المسمى بالحجم. فمثلا:
|
||||
|
||||
|
||||
`> sample(x = 1:4, size = 2)
|
||||
[] 4 2
|
||||
> sample(x = die, size = 1)
|
||||
[] 3
|
||||
>dice <- sample(die, size = 2, replace = TRUE)
|
||||
>dice
|
||||
[1] 2 4
|
||||
>sum(dice)
|
||||
[1] 6
|
||||
`
|
||||
```r
|
||||
> sample(x = 1:4, size = 2)
|
||||
[] 4 2
|
||||
> sample(x = die, size = 1)
|
||||
[] 3
|
||||
>dice <- sample(die, size = 2, replace = TRUE)
|
||||
>dice
|
||||
[1] 2 4
|
||||
>sum(dice)
|
||||
[1] 6
|
||||
```
|
||||
|
||||
* إذا لم تكن متأكدًا من الأسماء التي ستستخدمها مع إحدى الوظائف ، فيمكنك البحث عن الوظيفة الحجج مع args.
|
||||
|
||||
`> args(round)
|
||||
[1] function(x, digits=0)
|
||||
`
|
||||
```r
|
||||
> args(round)
|
||||
[1] function(x, digits=0)
|
||||
```
|
||||
|
||||
## مصادر
|
||||
|
||||
|
||||
@ -10,45 +10,51 @@ localeTitle: الأوامر الأساسية
|
||||
|
||||
هناك طرق مختلفة يمكنك بها تشغيل تطبيق أصلي متفاعل. يمكنك استخدام **Expo** أو `create-react-native-app` (والذي يستخدم بدوره Expo-Cli) لبدء مشروعك الجديد ، ولكن مع هذا الأسلوب فإنك تكون في سيطرة أكبر على ما حدث في مشروعك ويمكنه التواصل والتأقلم والكتابة وحدات خاصة بها مع المكتبات الأصلية لنظامي تشغيل iOS و Android.
|
||||
|
||||
`react-native init [PROJECT-NAME]
|
||||
cd [PROJECT-NAME]
|
||||
`
|
||||
```
|
||||
react-native init [PROJECT-NAME]
|
||||
cd [PROJECT-NAME]
|
||||
```
|
||||
|
||||
**تشغيل التطبيق في محاكي الأندرويد**
|
||||
|
||||
هذا الأمر توضيحي ذاتي ، كما يقول أنه سيبدأ محاكي Android ويثبّت التطبيق الذي أنشأته للتو. يجب أن تكون في جذر المشروع لتشغيل هذا الأمر.
|
||||
|
||||
`react-native run-android
|
||||
`
|
||||
```
|
||||
react-native run-android
|
||||
```
|
||||
|
||||
**تشغيل التطبيق في محاكي iOS**
|
||||
|
||||
يعمل هذا الأمر تمامًا مثل `react-native run-android` ولكن بدلاً من محاكي Android ، فإنه يفتح محاكي iPhone.
|
||||
|
||||
`react-native run-ios
|
||||
`
|
||||
```
|
||||
react-native run-ios
|
||||
```
|
||||
|
||||
**ربط التبعيات بالمشروعات المحلية**
|
||||
|
||||
تحتوي بعض المكتبات على تبعيات يلزم ربطها في الشفرة الأصلية التي تم إنشاؤها لـ React Native. إذا لم ينجح شيء ما بعد تثبيت مكتبة جديدة ، فربما يرجع السبب في ذلك إلى تخطي هذه الخطوة.
|
||||
|
||||
`react-native link [LIBRARY-NAME]
|
||||
`
|
||||
```
|
||||
react-native link [LIBRARY-NAME]
|
||||
```
|
||||
|
||||
**مسح الحزمة**
|
||||
|
||||
إذا لم يتم تشغيل شيء كما هو متوقع ، فربما تحتاج إلى مسح وإنشاء حزمة جديدة باستخدام هذا الأمر.
|
||||
|
||||
`watchman watch-del-all
|
||||
`
|
||||
```
|
||||
watchman watch-del-all
|
||||
```
|
||||
|
||||
**دعم الديكور**
|
||||
|
||||
لا تدعم JSX الديكورات بشكل افتراضي حتى تحتاج إلى تثبيت المكوِّن الإضافي **Babel** لجعله يعمل.
|
||||
|
||||
`npm install babel-plugin-transform-decorators-legacy --save
|
||||
npm install babel-plugin-transform-class-properties --save
|
||||
`
|
||||
```
|
||||
npm install babel-plugin-transform-decorators-legacy --save
|
||||
npm install babel-plugin-transform-class-properties --save
|
||||
```
|
||||
|
||||
### تصدير APK للتشغيل في الجهاز
|
||||
|
||||
@ -56,11 +62,13 @@ localeTitle: الأوامر الأساسية
|
||||
|
||||
**1\. بناء التصحيح التصحيح**
|
||||
|
||||
`react-native bundle --dev false --platform android --entry-file index.android.js --bundle-output ./android/app/build/intermediates/assets/debug/index.android.bundle --assets-dest ./android/app/build/intermediates/res/merged/debug
|
||||
`
|
||||
```
|
||||
react-native bundle --dev false --platform android --entry-file index.android.js --bundle-output ./android/app/build/intermediates/assets/debug/index.android.bundle --assets-dest ./android/app/build/intermediates/res/merged/debug
|
||||
```
|
||||
|
||||
**2\. إنشاء بناء التصحيح**
|
||||
|
||||
`cd android
|
||||
./gradlew assembleDebug
|
||||
`
|
||||
```
|
||||
cd android
|
||||
./gradlew assembleDebug
|
||||
```
|
||||
@ -10,14 +10,15 @@ localeTitle: مكونات وظيفية مقابل فئة
|
||||
|
||||
مكونات الفئة هي فئات JavaScript ES2015 التي توسع فئة أساسية من React تسمى `Component` .
|
||||
|
||||
`class App extends Component {
|
||||
```js
|
||||
class App extends Component {
|
||||
render () {
|
||||
return (
|
||||
<Text>Hello World!</Text>
|
||||
)
|
||||
}
|
||||
}
|
||||
`
|
||||
}
|
||||
```
|
||||
|
||||
يتيح ذلك الوصول إلى فئة `App` إلى أساليب دورة حياة React مثل `render` بالإضافة إلى وظيفة الحالة / الدعائم من الأصل.
|
||||
|
||||
@ -25,12 +26,13 @@ localeTitle: مكونات وظيفية مقابل فئة
|
||||
|
||||
المكونات الوظيفية هي أبسط. فهم لا يديرون حالتهم الخاصة أو يمكنهم الوصول إلى أساليب دورة الحياة التي يقدمها React Native. هم حرفيا وظائف جافا سكريبت عادي حرفيا. وهي تعرف أيضًا باسم المكونات عديمة الحالة.
|
||||
|
||||
`const PageOne = () => {
|
||||
```js
|
||||
const PageOne = () => {
|
||||
return (
|
||||
<h1>Page One</h1>
|
||||
);
|
||||
}
|
||||
`
|
||||
}
|
||||
```
|
||||
|
||||
### ملخص
|
||||
|
||||
|
||||
@ -6,17 +6,17 @@ localeTitle: مرحبا بالعالم
|
||||
|
||||
في صفحة الويب التقليدية ، يمكنك بسهولة تقديم `Hello World!` على الشاشة عن طريق كتابة بعض HTML مثل هذا:
|
||||
|
||||
`
|
||||
```html
|
||||
<!DOCTYPE html>
|
||||
<html>
|
||||
<html>
|
||||
<head>
|
||||
<title>Test Page</title>
|
||||
</head>
|
||||
<body>
|
||||
<p>Hello World!</p>
|
||||
</body>
|
||||
</html>
|
||||
`
|
||||
</html>
|
||||
```
|
||||
|
||||
في React Native ، لا يوجد DOM أو مستعرض ، لذلك يجب عليك عرض الأشياء على الشاشة من واجهة برمجة تطبيقات الجوال التي يقدمها React Native. على سبيل المثال ، بدلاً من استخدام علامة `<p>` كملف للنص كما لو كنت على الويب ، يمكنك استخدام `<Text>` ؛ بدلاً من علامات حاوية `<div>` ، يمكنك استخدام `<View>` .
|
||||
|
||||
|
||||
@ -8,23 +8,24 @@ localeTitle: الدعائم
|
||||
|
||||
في React ، يستطيع المكون الفرعي الوصول إلى المعلومات من أحد الوالدين عبر الدعائم:
|
||||
|
||||
`// the child Header component receives the text prop and can access it via this.props.text
|
||||
class Header extends Component {
|
||||
```jsx
|
||||
// the child Header component receives the text prop and can access it via this.props.text
|
||||
class Header extends Component {
|
||||
render () {
|
||||
return (
|
||||
<Text>{this.props.text}</Text>
|
||||
)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
class App extends Component {
|
||||
class App extends Component {
|
||||
render () {
|
||||
return (
|
||||
<Header text="Welcome!" />
|
||||
);
|
||||
}
|
||||
}
|
||||
`
|
||||
}
|
||||
```
|
||||
|
||||
هذا أيضا يعمل بنفس الطريقة في المكونات الوظيفية:
|
||||
|
||||
|
||||
@ -10,15 +10,17 @@ localeTitle: أبعاد الشاشة
|
||||
|
||||
للحصول على النافذة أو ارتفاع الشاشة / عرض جهاز المستخدم ، يحتوي React Native على واجهة برمجة تطبيقات تسمى `Dimensions` .
|
||||
|
||||
`import { Dimensions } from 'react-native';
|
||||
`
|
||||
```js
|
||||
import { Dimensions } from 'react-native';
|
||||
```
|
||||
|
||||
في ما يلي الطرق التي توفرها `Dimensions` API:
|
||||
|
||||
`Dimensions.get('window').height;
|
||||
Dimensions.get('window').width;
|
||||
Dimensions.get('screen').height;
|
||||
Dimensions.get('screen').width;
|
||||
`
|
||||
```js
|
||||
Dimensions.get('window').height;
|
||||
Dimensions.get('window').width;
|
||||
Dimensions.get('screen').height;
|
||||
Dimensions.get('screen').width;
|
||||
```
|
||||
|
||||
**ملاحظة: كانت هناك بعض المشكلات المعروفة في الماضي باستخدام Dimensions API مثل عدم إرجاع المعلومات الصحيحة عند تدوير المستخدم لجهازه. من الأفضل التأكد من اختبار ذلك على الأجهزة الفعلية قبل نشر التطبيق.**
|
||||
@ -6,7 +6,8 @@ localeTitle: حالة المكون
|
||||
|
||||
في مكونات `Class` ، توجد طريقة لتخزين وإدارة الحالة المدمجة في React Native.
|
||||
|
||||
`class App extends Component {
|
||||
```javascript
|
||||
class App extends Component {
|
||||
constructor () {
|
||||
super();
|
||||
this.state = {
|
||||
@ -32,25 +33,28 @@ localeTitle: حالة المكون
|
||||
</View>
|
||||
);
|
||||
}
|
||||
}
|
||||
`
|
||||
}
|
||||
```
|
||||
|
||||
الحالة مشابهة للدعائم ، ولكنها خاصة ويتم التحكم فيها بالكامل بواسطة المكون. هنا ، يتم استدعاء الأسلوب `constructor()` فئة الأصل "المنشئ `super();` - **`Component`** هو الفئة الرئيسية `App` لأننا نستخدم الكلمة الرئيسية `extends` . تقوم أداة `constructor()` أيضًا بتهيئة كائن حالة المكون:
|
||||
|
||||
`this.state = {
|
||||
```
|
||||
this.state = {
|
||||
counter: 0
|
||||
};
|
||||
`
|
||||
};
|
||||
```
|
||||
|
||||
يمكن عرض الحالة داخل المكون:
|
||||
|
||||
`{this.state.counter}
|
||||
`
|
||||
```js
|
||||
{this.state.counter}
|
||||
```
|
||||
|
||||
أو تحديثه عن طريق الاتصال:
|
||||
|
||||
`this.setState({});
|
||||
`
|
||||
```js
|
||||
this.setState({});
|
||||
```
|
||||
|
||||
**ملاحظة:** بصرف النظر عن الإنشاء المبدئي في طريقة `constructor()` المكون `constructor()` ، يجب ألا تقوم أبدًا بتعديل حالة المكوّن مباشرةً بهذا `this.state =` . يجب استخدام هذا `this.setState` كما يمكن رؤيته في الدالتين `incrementCount` و `decrementCount` أعلاه.
|
||||
|
||||
@ -58,7 +62,8 @@ localeTitle: حالة المكون
|
||||
|
||||
_بصيغة ASIDE: في المثال الأول ، يعد `<Button>` مكونًا مخصصًا ؛ إنه مزيج من `<TouchableOpacity>` و `<Text>` من واجهة برمجة التطبيقات React Native API:_
|
||||
|
||||
`const Button = ({ onPress, children, buttonProps, textProps }) => {
|
||||
```js
|
||||
const Button = ({ onPress, children, buttonProps, textProps }) => {
|
||||
const { buttonStyle, textStyle } = styles;
|
||||
return (
|
||||
<TouchableOpacity onPress={onPress} style={[buttonStyle, buttonProps]}>
|
||||
@ -67,5 +72,5 @@ _بصيغة ASIDE: في المثال الأول ، يعد `<Button>` مكونً
|
||||
</Text>
|
||||
</TouchableOpacity>
|
||||
);
|
||||
};
|
||||
`
|
||||
};
|
||||
```
|
||||
@ -6,10 +6,11 @@ localeTitle: تصميم
|
||||
|
||||
يوفر React Native واجهة برمجة تطبيقات لإنشاء أوراق الأنماط وتصميم [مكوناتك](https://facebook.github.io/react-native/docs/stylesheet) : [StyleSheet](https://facebook.github.io/react-native/docs/stylesheet) .
|
||||
|
||||
`import React, { Component } from 'react';
|
||||
import { StyleSheet, View, Text } from 'react-native';
|
||||
```jsx
|
||||
import React, { Component } from 'react';
|
||||
import { StyleSheet, View, Text } from 'react-native';
|
||||
|
||||
export default class App extends Component {
|
||||
export default class App extends Component {
|
||||
render () {
|
||||
return (
|
||||
<View>
|
||||
@ -18,17 +19,17 @@ localeTitle: تصميم
|
||||
</View>
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
const styles = StyleSheet.create({
|
||||
const styles = StyleSheet.create({
|
||||
header: {
|
||||
fontSize: 20
|
||||
},
|
||||
text: {
|
||||
color: 'blue'
|
||||
}
|
||||
});
|
||||
`
|
||||
});
|
||||
```
|
||||
|
||||
في حين أن أنماط صفحات الأنماط المتتالية من CSS غير صالحة ، فإن مجموعة الروابط المتداخلة لـ CSS الخاصة بـ Native تشبه إلى حد كبير CSS التقليدية. تكون العديد من خصائص CSS (مثل `color` ، `height` ، `top` ، `right` ، `bottom` ، `left` ) هي نفسها في StyleSheet. يجب تغيير أي خصائص CSS لها واصلات (مثل `font-size` ، `background-color` ) إلى camelCase (مثل `fontSize` ، `backgroundColor` ).
|
||||
|
||||
@ -52,10 +53,11 @@ localeTitle: تصميم
|
||||
|
||||
على سبيل المثال ، يمكن استخدام مكون زر في أماكن متعددة عبر تطبيق ما. لن يكون نسخ كائن النمط ولصقه مع كل نسخة زر غير فعال. بدلاً من ذلك ، قم بإنشاء مكون زر يمكن استخدامه وإعادة استخدامه:
|
||||
|
||||
`import React from 'react';
|
||||
import { Text, TouchableOpacity } from 'react-native';
|
||||
```jsx
|
||||
import React from 'react';
|
||||
import { Text, TouchableOpacity } from 'react-native';
|
||||
|
||||
const Button = ({ onPress, children }) => {
|
||||
const Button = ({ onPress, children }) => {
|
||||
const { buttonStyle, textStyle } = styles;
|
||||
return (
|
||||
<TouchableOpacity onPress={onPress} style={buttonStyle}>
|
||||
@ -64,11 +66,11 @@ localeTitle: تصميم
|
||||
</Text>
|
||||
</TouchableOpacity>
|
||||
);
|
||||
};
|
||||
};
|
||||
|
||||
export default Button;
|
||||
export default Button;
|
||||
|
||||
const styles = {
|
||||
const styles = {
|
||||
textStyle: {
|
||||
alignSelf: 'center',
|
||||
color: '#336633',
|
||||
@ -88,16 +90,17 @@ localeTitle: تصميم
|
||||
marginTop: 10,
|
||||
width: 300
|
||||
}
|
||||
};
|
||||
`
|
||||
};
|
||||
```
|
||||
|
||||
يمكن بسهولة استيراد واستخدام مكون الزر عبر التطبيق دون الإعلان عن كائن النمط بشكل متكرر:
|
||||
|
||||
`import React, { Component } from 'react';
|
||||
import { TextInput, View } from 'react-native';
|
||||
import Button from './styling/Button';
|
||||
```jsx
|
||||
import React, { Component } from 'react';
|
||||
import { TextInput, View } from 'react-native';
|
||||
import Button from './styling/Button';
|
||||
|
||||
export default class Login extends Component {
|
||||
export default class Login extends Component {
|
||||
render() {
|
||||
return (
|
||||
<View>
|
||||
@ -107,8 +110,8 @@ localeTitle: تصميم
|
||||
</View>
|
||||
);
|
||||
}
|
||||
}
|
||||
`
|
||||
}
|
||||
```
|
||||
|
||||
### مكتبات لتصميم
|
||||
|
||||
|
||||
@ -6,16 +6,17 @@ localeTitle: رد الفعل - مكونات
|
||||
|
||||
مكونات قابلة لإعادة الاستخدام في react.js. يمكنك ضخ القيمة في الدعائم كما هو موضح أدناه:
|
||||
|
||||
`function Welcome(props) {
|
||||
```jsx
|
||||
function Welcome(props) {
|
||||
return <h1>Hello, {props.name}</h1>;
|
||||
}
|
||||
}
|
||||
|
||||
const element = <Welcome name="Faisal Arkan" />;
|
||||
ReactDOM.render(
|
||||
const element = <Welcome name="Faisal Arkan" />;
|
||||
ReactDOM.render(
|
||||
element,
|
||||
document.getElementById('root')
|
||||
);
|
||||
`
|
||||
);
|
||||
```
|
||||
|
||||
`name="Faisal Arkan"` سيعطي قيمة في `{props.name}` من `function Welcome(props)` `{props.name}` المكونة التي أعطيت القيمة `name="Faisal Arkan"` ، بعد أن تتفاعل ستجعل العنصر في html.
|
||||
|
||||
@ -27,7 +28,8 @@ localeTitle: رد الفعل - مكونات
|
||||
|
||||
#### مكونات نوع الطبقة
|
||||
|
||||
`class Cat extends React.Component {
|
||||
```jsx
|
||||
class Cat extends React.Component {
|
||||
constructor(props) {
|
||||
super(props);
|
||||
|
||||
@ -45,8 +47,8 @@ localeTitle: رد الفعل - مكونات
|
||||
</div>
|
||||
);
|
||||
}
|
||||
}
|
||||
`
|
||||
}
|
||||
```
|
||||
|
||||
### مكونات عديمة الحالة
|
||||
|
||||
@ -64,9 +66,10 @@ localeTitle: رد الفعل - مكونات
|
||||
|
||||
#### مكونات العودة الضمنية
|
||||
|
||||
`const Cat = props =>
|
||||
```jsx
|
||||
const Cat = props =>
|
||||
<div>
|
||||
<h1>{props.name}</h1>
|
||||
<p>{props.color}</p>
|
||||
</div>;
|
||||
`
|
||||
```
|
||||
@ -8,9 +8,10 @@ localeTitle: الشظايا
|
||||
|
||||
تعمل `Fragment` جزءًا بدون إضافة أقسام غير ضرورية إلى DOM. يمكنك استخدامه مباشرة من استيراد React أو تفكيكه:
|
||||
|
||||
`import React from 'react';
|
||||
```jsx
|
||||
import React from 'react';
|
||||
|
||||
class MyComponent extends React.Component {
|
||||
class MyComponent extends React.Component {
|
||||
render(){
|
||||
return (
|
||||
<React.Fragment>
|
||||
@ -19,15 +20,16 @@ localeTitle: الشظايا
|
||||
</React.Fragment>
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
export default MyComponent;
|
||||
`
|
||||
export default MyComponent;
|
||||
```
|
||||
|
||||
`// Deconstructed
|
||||
import React, { Component, Fragment } from 'react';
|
||||
```jsx
|
||||
// Deconstructed
|
||||
import React, { Component, Fragment } from 'react';
|
||||
|
||||
class MyComponent extends Component {
|
||||
class MyComponent extends Component {
|
||||
render(){
|
||||
return (
|
||||
<Fragment>
|
||||
@ -36,20 +38,21 @@ localeTitle: الشظايا
|
||||
</Fragment>
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
export default MyComponent;
|
||||
`
|
||||
export default MyComponent;
|
||||
```
|
||||
|
||||
نجح الإصدار 16.2 من React في تبسيط هذه العملية بشكل أكبر ، مما يسمح بوضع علامات JSX فارغة في شكل أجزاء:
|
||||
|
||||
`return (
|
||||
```jsx
|
||||
return (
|
||||
<>
|
||||
<div>I am an element!</div>
|
||||
<button>I am another element</button>
|
||||
</>
|
||||
);
|
||||
`
|
||||
);
|
||||
```
|
||||
|
||||
#### معلومات اكثر:
|
||||
|
||||
|
||||
@ -19,16 +19,17 @@ localeTitle: المكونات الوظيفية مقابل مكونات Class
|
||||
* يمكن للمكونات الوظيفية قبول الدعائم واستخدامها.
|
||||
* يجب تفضيل المكونات الوظيفية إذا لم تكن بحاجة إلى استخدام حالة React.
|
||||
|
||||
`import React from "react";
|
||||
```js
|
||||
import React from "react";
|
||||
|
||||
const Person = props => (
|
||||
const Person = props => (
|
||||
<div>
|
||||
<h1>Hello, {props.name}</h1>
|
||||
</div>
|
||||
);
|
||||
);
|
||||
|
||||
export default Person;
|
||||
`
|
||||
export default Person;
|
||||
```
|
||||
|
||||
## مكونات الطبقة
|
||||
|
||||
|
||||
@ -8,15 +8,17 @@ localeTitle: التعامل مع البيانات مع الدعائم في رد
|
||||
|
||||
يتم تمرير البيانات إلى مكونات React كصفة في JSX.
|
||||
|
||||
`<MyComponent someAttribute={data.value} />
|
||||
`
|
||||
```javascript
|
||||
<MyComponent someAttribute={data.value} />
|
||||
```
|
||||
|
||||
في JSX ، تشير الأقواس المتعرجة إلى تعبير JavaScript والذي يجب أن يعرض قيمة. يتم الوصول إلى البيانات التي تم تمريرها عبر الدعائم في المكون المحدد.
|
||||
|
||||
`const MyComponent = props => {
|
||||
```javascript
|
||||
const MyComponent = props => {
|
||||
<p>{props.someAttribute}</p>
|
||||
};
|
||||
`
|
||||
};
|
||||
```
|
||||
|
||||
الآن دعونا نمشي على سبيل المثال في CodePen.
|
||||
|
||||
@ -36,45 +38,49 @@ localeTitle: التعامل مع البيانات مع الدعائم في رد
|
||||
|
||||
أولاً ، دعنا نحدد بعض البيانات الوهمية في ملف جافا سكريبت الخاص بنا.
|
||||
|
||||
`const blogData = {
|
||||
```javascript
|
||||
const blogData = {
|
||||
title: 'My blog title',
|
||||
body: 'Arcu viverra dolor eros interdum, quis nonummy accusantium at lorem luctus iaculis.'
|
||||
};
|
||||
`
|
||||
};
|
||||
```
|
||||
|
||||
بعد ذلك ، دعنا نحدد مكونات مدونتنا.
|
||||
|
||||
`const Heading = () => {
|
||||
```javascript
|
||||
const Heading = () => {
|
||||
return (
|
||||
<h1>My Blog</h1>
|
||||
);
|
||||
};
|
||||
};
|
||||
|
||||
const Blog = props => {
|
||||
const Blog = props => {
|
||||
return (
|
||||
<div>
|
||||
<h2>{props.title}</h2>
|
||||
<p>{props.body}</p>
|
||||
</div>
|
||||
);
|
||||
};
|
||||
`
|
||||
};
|
||||
```
|
||||
|
||||
لاحظنا كيف استخدمنا الكائن المرخص لتقديم قيم العنوان والجسد التي سيتم تمريرها إلى مكون المدونة. الدعائم للقراءة فقط أو غير قابلة للتغيير ، لذلك لا داعي للقلق بشأن تغيير قيم الدعائم.
|
||||
|
||||
قبل أن نكتب مكوّن التطبيق لدينا ، نحتاج إلى حماية المكون الذي نستخدمه لتحديد نوع المتغير الذي سينتقل إلى كل دعم. سنحدد ذلك باستخدام React.PropTypes. أضف ما يلي إلى ملف JavaScript الخاص بك.
|
||||
|
||||
`Blog.propTypes = {
|
||||
```javascript
|
||||
Blog.propTypes = {
|
||||
title: React.PropTypes.string,
|
||||
body: React.PropTypes.string
|
||||
};
|
||||
`
|
||||
};
|
||||
```
|
||||
|
||||
هنا نقوم بتعريف أن البيانات التي يتم تمريرها إلى مكون المدونة ستكون سلاسل لكل من العنوان والجسم. تحقق من [وثائق](https://reactjs.org/docs/typechecking-with-proptypes.html) React للحصول على قائمة بجميع propTypes.
|
||||
|
||||
الآن ، دعنا نضع هذا معًا في أحد مكونات التطبيق وننزل بياناتنا.
|
||||
|
||||
`const App = props => {
|
||||
```javascript
|
||||
const App = props => {
|
||||
return (
|
||||
<div>
|
||||
<Heading />
|
||||
@ -83,16 +89,17 @@ localeTitle: التعامل مع البيانات مع الدعائم في رد
|
||||
<Blog title={blogData.title} body={blogData.body} />
|
||||
</div>
|
||||
);
|
||||
};
|
||||
`
|
||||
};
|
||||
```
|
||||
|
||||
أخيرًا ، دعنا نعرض تطبيقنا (تأكد من إضافة علامة `<div>` جذر إلى ملف HTML):
|
||||
|
||||
`ReactDOM.render(
|
||||
```javascript
|
||||
ReactDOM.render(
|
||||
<App />,
|
||||
document.getElementById('root')
|
||||
);
|
||||
`
|
||||
);
|
||||
```
|
||||
|
||||
الآن يجب أن تشاهد مكونات المدونة الخاصة بنا مصحوبة ببيانات وهمية يتم تمريرها عبر الدعائم.
|
||||
|
||||
|
||||
@ -10,8 +10,9 @@ localeTitle: مكونات الترتيب الأعلى
|
||||
|
||||
الفكرة الأساسية هي:
|
||||
|
||||
`const EnhancedComponent = enhance(WrappedComponent);
|
||||
`
|
||||
```jsx
|
||||
const EnhancedComponent = enhance(WrappedComponent);
|
||||
```
|
||||
|
||||
أين:
|
||||
|
||||
@ -21,7 +22,8 @@ localeTitle: مكونات الترتيب الأعلى
|
||||
|
||||
هذا يمكن أن يكون الجسم من `enhance` HOC:
|
||||
|
||||
`function enhance(WrappedComponent) {
|
||||
```jsx
|
||||
function enhance(WrappedComponent) {
|
||||
return class extends React.Component {
|
||||
render() {
|
||||
const extraProp = 'This is an injected prop!';
|
||||
@ -35,8 +37,8 @@ localeTitle: مكونات الترتيب الأعلى
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
`
|
||||
}
|
||||
```
|
||||
|
||||
في هذه الحالة ، `enhance` إرجاع **فئة المجهول** التي تمتد `React.Component` . يقوم هذا المكون الجديد بثلاثة أشياء بسيطة:
|
||||
|
||||
|
||||
@ -18,30 +18,31 @@ React هي مكتبة جافا سكريبت وتطبيقات React المبني
|
||||
|
||||
1. React يشمل التركيب الذي هو الكثير من المكونات لف الوظائف في وعاء مغلف. تستخدم العديد من مواقع الويب الشائعة React لتنفيذ النمط المعماري MVC. Facebook (جزئيًا) ، Instagram (تمامًا) ، Khan Academy (جزئيًا) ، Codecademy (جزئيًا) ، New York Times (جزئيًا) ، Yahoo Mail (تمامًا) ، التطبيق الجديد للصور والفيديو لمنتدى Dropbox Carousel (تمامًا) هي المواقع الشهيرة المعروفة ليتم استخدام React. كيف يتم بناء هذه التطبيقات الكبيرة باستخدام React؟ الإجابة البسيطة هي عن طريق بناء تطبيقات أو مكونات صغيرة. مثال:
|
||||
|
||||
`const Component2 = () => {
|
||||
```jsx
|
||||
const Component2 = () => {
|
||||
return (
|
||||
<div></div>
|
||||
);
|
||||
};
|
||||
const Component3 = () => {
|
||||
};
|
||||
const Component3 = () => {
|
||||
return (
|
||||
<div></div>
|
||||
);
|
||||
};
|
||||
const Component1 = () => {
|
||||
};
|
||||
const Component1 = () => {
|
||||
return (
|
||||
<div>
|
||||
<Component2 />
|
||||
<Component3 />
|
||||
</div>
|
||||
);
|
||||
};
|
||||
};
|
||||
|
||||
ReactDOM.render(
|
||||
ReactDOM.render(
|
||||
<Component1 />,
|
||||
document.getElementById("app")
|
||||
);
|
||||
`
|
||||
);
|
||||
```
|
||||
|
||||
2. رد الفعل هو التصريح بالنسبة للجزء الأكبر الذي نشعر بالقلق أكثر مع ما يجب القيام به بدلا من كيفية القيام بمهمة محددة. البرمجة التعميمية هي نموذج برمجي يعبر عن منطق الحساب دون وصف تدفق التحكم الخاص به. تأتي البرمجة التعويضية بمزايا معينة مثل الآثار الجانبية المخفضة (تحدث عندما نقوم بتعديل أي حالة أو تحوير شيء ما أو تقديم طلب API) ، وتقليل التحلل (كما هو مستخلص من الكثير) ، والقابلية المحسنة ، وأخطاء أقل.
|
||||
|
||||
@ -83,24 +84,26 @@ React هي مكتبة جافا سكريبت وتطبيقات React المبني
|
||||
|
||||
لنبدأ بالخطوة 1. سنبدأ بملف في متصفحنا يسمى "index.html". سنبدأ برمز HTML لرمز المرجل. لبداية سريعة ، أوصي باستخدام Emmet مع أي محرر نصوص لديك وعلى السطر الأول كتابة في `html:5` ثم الضغط على مفتاح shift للحصول على الكود أدناه. أو يمكنك المضي قدمًا ونسخ الشفرة من الأسفل والصقها.
|
||||
|
||||
`html:5
|
||||
`
|
||||
```javascript
|
||||
html:5
|
||||
```
|
||||
|
||||
سيؤدي هذا إلى التعليمة البرمجية التالية:
|
||||
|
||||
`<!DOCTYPE html>
|
||||
<html lang="en">
|
||||
<head>
|
||||
```javascript
|
||||
<!DOCTYPE html>
|
||||
<html lang="en">
|
||||
<head>
|
||||
<meta charset="UTF-8">
|
||||
<meta name="viewport" content="width=device-width, initial-scale=1.0">
|
||||
<meta http-equiv="X-UA-Compatible" content="ie=edge">
|
||||
<title>Document</title>
|
||||
</head>
|
||||
<body>
|
||||
</head>
|
||||
<body>
|
||||
|
||||
</body>
|
||||
</html>
|
||||
`
|
||||
</body>
|
||||
</html>
|
||||
```
|
||||
|
||||
يمكننا ملء عنوان "وقت الرد!"
|
||||
|
||||
@ -110,7 +113,8 @@ React هي مكتبة جافا سكريبت وتطبيقات React المبني
|
||||
|
||||
حسنًا ، يتم فحص العنصر الأول من قائمتنا. دعونا ننظر في البند الثاني. سنقوم بإعداد بيئة مطورنا عن طريق استخدام علامات النص لجلب React و Babel. هذه ليست بيئة مطور الحياة الحقيقية. من شأنه أن يكون تماما الإعداد معقدة. كما أنه سيترك لنا الكثير من رمز لوحة المرجل والمكتبات التي ستخرجنا عن موضوع تعلم أساسيات React. الهدف من هذه السلسلة هو الذهاب إلى بناء الجملة الأساسي لـ React والحصول على الحق في الترميز. سنستخدم علامات `<script>` لإدخال مكتبة React ومكتبة React DOM (لماذا) ومكتبة بابل.
|
||||
|
||||
`<head>
|
||||
```javascript
|
||||
<head>
|
||||
...
|
||||
<!-- REACT LIBRARY -->
|
||||
<script src="https://unpkg.com/react@15.5.4/dist/react.js"></script>
|
||||
@ -120,8 +124,8 @@ React هي مكتبة جافا سكريبت وتطبيقات React المبني
|
||||
<script src="https://cdnjs.cloudflare.com/ajax/libs/babel-standalone/6.25.0/babel.min.js"></script>
|
||||
...
|
||||
<title>Time to React!</title>
|
||||
</head>
|
||||
`
|
||||
</head>
|
||||
```
|
||||
|
||||
أنت حر في استخدام إصدارات أكثر محدثة من هذه المكتبات لأنها تخرج. يجب ألا ينشئوا أي تغييرات مفاجئة للمحتوى الذي نغطيه.
|
||||
|
||||
@ -131,42 +135,46 @@ React هي مكتبة جافا سكريبت وتطبيقات React المبني
|
||||
|
||||
ستتمثل خطوتنا التالية في اختيار موقعنا ضمن DOM الذي نرغب في عرض محتوى التفاعل فيه. واستخدام علامة نصية أخرى لمحتوى React الخاص بنا داخل الجسم. بشكل عام ، كعمل فصل جيد للمخاوف ، سيكون هذا في ملفه الخاص ثم يرتبط بوثيقة html هذه. سنفعل ذلك لاحقًا في الدروس القادمة. في الوقت الحالي ، سنترك هذا يسكن داخل نص مستند html الذي نحن فيه حاليا. الآن سننظر في مدى سهولة اختيار مكان على DOM لتقديم محتوى React. سنذهب داخل الجسم. وأفضل الممارسات ليست مجرد إلقاء ردود الفعل في علامة النص التي سيتم عرضها ولكن لإنشاء عنصر منفصل ، غالباً ما يكون div ، يمكنك التعامل معه كعنصر جذر لإدخال محتوى React الخاص بك.
|
||||
|
||||
`<body>
|
||||
```javascript
|
||||
<body>
|
||||
<div id="app">React has not rendered yet</div>
|
||||
</body>
|
||||
`
|
||||
</body>
|
||||
```
|
||||
|
||||
`<div>` عنصر `<div>` بسيطًا `<div>` معرفًا بـ "التطبيق". سنتمكن من استهداف هذا الموقع لإدراج محتوى React بطريقة تشبه إلى حد كبير الطريقة التي تستخدم بها CSS لاستهداف معرف لتصميم من اختيارك. سيتم عرض أي محتوى متفاعل ضمن علامات div مع معرف التطبيق. في هذه الأثناء ، سنترك بعض النصوص ونقول "لم يظهر رد الفعل بعد" إذا رأينا ذلك عندما نعاين صفحتنا ، فهذا يعني أنه في مكان نفتقد فيه رد الفعل. الآن ، دعونا نمضي قدمًا وننشئ علامة نصيّة داخل جسمنا حيث سننشئها برد فعل لأول مرة. الصيغة التي نحتاج إليها لعلامة النص البرمجي هي إضافة سمة "type". هذا يحدد نوع الوسائط للبرنامج النصي. في رأينا استخدمنا خاصية src التي تشير إلى ملفات البرامج النصية الخارجية لمكتبة React ومكتبة Reactdom ومكتبة بابل.
|
||||
|
||||
`<body>
|
||||
```javascript
|
||||
<body>
|
||||
<div id="app">React has not rendered yet</div>
|
||||
<script type="text/babel">
|
||||
</script>
|
||||
</body>
|
||||
`
|
||||
</body>
|
||||
```
|
||||
|
||||
"نوع" البرنامج النصي الذي نستخدمه سنقوم بلفه بين علامتي اقتباس وضبطه على `"text/babel"` . سنحتاج إلى هذه القدرة لاستخدام babel على الفور ونحن نعمل مع JSX. أولاً ، سوف نعرض React على DOM. `ReactDOM.render()` الأسلوب `ReactDOM.render()` للقيام بذلك. ستكون هذه طريقة ، وتذكر أن الطريقة هي مجرد وظيفة مرتبطة بجسم ما. هذه الطريقة سوف تأخذ اثنين من الحجج.
|
||||
|
||||
`<body>
|
||||
```javascript
|
||||
<body>
|
||||
<div id="app">React has not rendered yet</div>
|
||||
<script type="text/babel">
|
||||
ReactDOM.render(React What, React Where);
|
||||
</script>
|
||||
</body>
|
||||
`
|
||||
</script>
|
||||
</body>
|
||||
```
|
||||
|
||||
الحجة الأولى هي "ماذا" من رد الفعل. الوسيطة الثانية هي "المكان" للموقع الذي تريد وضعه في DOM. لنبدأ من خلال استدعاء طريقة ReactDOM.render () الخاصة بنا. أول حجة لدينا ستكون JSX لدينا.
|
||||
|
||||
`<body>
|
||||
```javascript
|
||||
<body>
|
||||
<div id="app">React has not rendered yet</div>
|
||||
<script type="text/babel">
|
||||
ReactDOM.render(
|
||||
<h1>Hello World</h1>,
|
||||
React Where
|
||||
);
|
||||
</script>
|
||||
</body>
|
||||
`](http://www.youtube.com/watch?feature=player_embedded&v=100pKUE3OPI)
|
||||
</script>
|
||||
</body>
|
||||
```](http://www.youtube.com/watch?feature=player_embedded&v=100pKUE3OPI)
|
||||
|
||||
[](http://www.youtube.com/watch?feature=player_embedded&v=100pKUE3OPI)[حالة رد فعل المستندات الرسمية](https://reactjs.org/docs/introducing-jsx.html) : "بنية صيغة مضحكة هذه ليست سلسلة ولا HTML. يطلق عليه JSX ، وهو امتداد لغوي ل JavaScript. نوصي باستخدامها مع React لوصف ما ينبغي أن تبدو عليه واجهة المستخدم. قد تذكرك JSX بلغة القالب ، ولكنها تأتي مع القوة الكاملة لجافا سكريبت. JSX تنتج React "elements". "
|
||||
|
||||
@ -176,7 +184,8 @@ React هي مكتبة جافا سكريبت وتطبيقات React المبني
|
||||
|
||||
و JSX هو مجرد حقا بديهية. ربما يمكنك قراءة هذا الرمز بسهولة تامة ورؤية أن هذه العلامة ستكون أكبر علامة نصية تعرض النص "Hello World". لا غموض وجميل وواضح. الآن ، دعونا نلقي نظرة على ما ستكون عليه حجتنا الثانية.
|
||||
|
||||
`<body>
|
||||
```javascript
|
||||
<body>
|
||||
<div id="app">React has not rendered yet</div>
|
||||
<script type="text/babel">
|
||||
ReactDOM.render(
|
||||
@ -184,8 +193,8 @@ React هي مكتبة جافا سكريبت وتطبيقات React المبني
|
||||
document.getElementById("app")
|
||||
);
|
||||
</script>
|
||||
</body>
|
||||
`
|
||||
</body>
|
||||
```
|
||||
|
||||
هذا هو المكان الذي نريد تقديم محتوى رد فعلنا إلى dom. من المحتمل أنك فعلت هذا عدة مرات في الماضي. سنكتب فقط في `document.getElementById()` . وسننتقل إلى حجة معرف التطبيق. وهذا هو عليه. سنستهدف الآن div بمعرّف التطبيق لإدخال محتوى رد فعلنا.
|
||||
|
||||
|
||||
@ -8,18 +8,19 @@ localeTitle: التركيب
|
||||
|
||||
يمكنك ببساطة تضمين مكتبة React في صفحتك على الويب مثل 2 :
|
||||
|
||||
`
|
||||
```html
|
||||
<script src="https://cdnjs.cloudflare.com/ajax/libs/react/16.0.0/cjs/react.production.min.js"></script>
|
||||
`
|
||||
```
|
||||
|
||||
يريد المبرمجون الأذكياء توفير طريقة أكثر عملية وإنتاجية: [إنشاء تطبيق React](https://github.com/facebookincubator/create-react-app)
|
||||
|
||||
`npm install -g create-react-app
|
||||
create-react-app my-app
|
||||
```bash
|
||||
npm install -g create-react-app
|
||||
create-react-app my-app
|
||||
|
||||
cd my-app
|
||||
npm start
|
||||
`
|
||||
cd my-app
|
||||
npm start
|
||||
```
|
||||
|
||||
سيؤدي ذلك إلى تجهيز بيئة التطوير الخاصة بك محلياً بحيث يمكنك استخدام أحدث ميزات JavaScript ، وتوفير تجربة رائعة للمطورين ، وتحسين إنتاجيتك.
|
||||
|
||||
|
||||
@ -12,62 +12,68 @@ JSX هو تعبير يستخدم عبارات HTML صالحة داخل JavaScrip
|
||||
|
||||
تعبير في سطر مفرد سهل الاستخدام.
|
||||
|
||||
`const one = <h1>Hello World!</h1>;
|
||||
`
|
||||
```jsx
|
||||
const one = <h1>Hello World!</h1>;
|
||||
```
|
||||
|
||||
عندما تحتاج إلى استخدام أسطر متعددة في تعبير JSX واحد ، اكتب شفرتك داخل قوس واحد.
|
||||
|
||||
`const two = (
|
||||
```jsx
|
||||
const two = (
|
||||
<ul>
|
||||
<li>Once</li>
|
||||
<li>Twice</li>
|
||||
</ul>
|
||||
);
|
||||
`
|
||||
);
|
||||
```
|
||||
|
||||
### بإمكانك استخدام علامات HTML فقط
|
||||
|
||||
`const greet = <h1>Hello World!</h1>;
|
||||
`
|
||||
```jsx
|
||||
const greet = <h1>Hello World!</h1>;
|
||||
```
|
||||
|
||||
### الجمع بين تعبير JavaScript مع علامات HTML
|
||||
|
||||
يمكننا استخدام متغيرات JavaScript في الأقواس.
|
||||
|
||||
`const who = "Quincy Larson";
|
||||
const greet = <h1>Hello {who}!</h1>;
|
||||
`
|
||||
```jsx
|
||||
const who = "Quincy Larson";
|
||||
const greet = <h1>Hello {who}!</h1>;
|
||||
```
|
||||
|
||||
يمكننا أيضًا استدعاء وظائف JavaScript الأخرى داخل الأقواس.
|
||||
|
||||
`function who() {
|
||||
```jsx
|
||||
function who() {
|
||||
return "World";
|
||||
}
|
||||
const greet = <h1>Hello {who()}!</h1>;
|
||||
`
|
||||
}
|
||||
const greet = <h1>Hello {who()}!</h1>;
|
||||
```
|
||||
|
||||
### يُسمح فقط بعلامة أصل واحدة
|
||||
|
||||
يجب أن يحيط تعبير JSX على عنصر رئيسي واحد فقط. يمكننا إضافة عدة علامات متداخلة داخل العنصر الأصل فقط.
|
||||
|
||||
`// This is valid.
|
||||
const tags = (
|
||||
```jsx
|
||||
// This is valid.
|
||||
const tags = (
|
||||
<ul>
|
||||
<li>Once</li>
|
||||
<li>Twice</li>
|
||||
</ul>
|
||||
);
|
||||
);
|
||||
|
||||
// This is not valid.
|
||||
const tags = (
|
||||
// This is not valid.
|
||||
const tags = (
|
||||
<h1>Hello World!</h1>
|
||||
<h3>This is my special list:</h3>
|
||||
<ul>
|
||||
<li>Once</li>
|
||||
<li>Twice</li>
|
||||
</ul>
|
||||
);
|
||||
`
|
||||
);
|
||||
```
|
||||
|
||||
### معلومات اكثر
|
||||
|
||||
|
||||
@ -12,36 +12,39 @@ localeTitle: رد فعل الدعائم والدولة
|
||||
|
||||
يمكن للمكونات الخاصة بك أيضا استخدام الدعائم. يتيح لك ذلك إنشاء مكون واحد يتم استخدامه في العديد من الأماكن المختلفة في تطبيقك ، مع خصائص مختلفة قليلاً في كل مكان. ارجع إلى `this.props` في وظيفة العرض:
|
||||
|
||||
`class Welcome extends React.Component {
|
||||
```
|
||||
class Welcome extends React.Component {
|
||||
render() {
|
||||
return <h1>Hello {this.props.name}</h1>;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
const element = <Welcome name="neel" />;
|
||||
`
|
||||
const element = <Welcome name="neel" />;
|
||||
```
|
||||
|
||||
ينشئ السطر `<Welcome name="neel" />` اسم خاصية بقيمة `"neel"` .
|
||||
|
||||
يتم تمرير الخاصية إلى المكون ، تشبه كيفية تمرير وسيطة إلى دالة. في الواقع ، يمكننا حتى إعادة كتابة المكون ليكون أكثر بساطة:
|
||||
|
||||
`function Welcome(props) {
|
||||
```
|
||||
function Welcome(props) {
|
||||
return <h1>Hello {props.name}</h1>;
|
||||
}
|
||||
`
|
||||
}
|
||||
```
|
||||
|
||||
يمكننا جعل خاصية الاسم اختيارية بإضافة defaultProps إلى فئة الترحيب:
|
||||
|
||||
`class Welcome extends React.Component {
|
||||
```
|
||||
class Welcome extends React.Component {
|
||||
render() {
|
||||
return <h1>Hello {this.props.name}</h1>;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
Welcome.defaultProps = {
|
||||
Welcome.defaultProps = {
|
||||
name: "world",
|
||||
};
|
||||
`
|
||||
};
|
||||
```
|
||||
|
||||
إذا تم استدعاء Welcome بدون اسم ، فسيتم عرض `<h1> Hello world</h1>` .
|
||||
|
||||
@ -57,10 +60,11 @@ localeTitle: رد فعل الدعائم والدولة
|
||||
|
||||
بشكل افتراضي ، لا يحتوي أي مكون على حالة. عنصر `Welcome` من الأعلى عديم الحالة:
|
||||
|
||||
`function Welcome(props) {
|
||||
```
|
||||
function Welcome(props) {
|
||||
return <h1>Hello {props.name}</h1>;
|
||||
}
|
||||
`
|
||||
}
|
||||
```
|
||||
|
||||
عندما يحتاج أحد المكونات إلى تتبع المعلومات بين عمليات العرض ، يمكن للمكون نفسه إنشاء وتحديث واستخدام الحالة.
|
||||
|
||||
@ -68,7 +72,8 @@ localeTitle: رد فعل الدعائم والدولة
|
||||
|
||||
هنا الرمز:
|
||||
|
||||
`class Button extends React.Component {
|
||||
```
|
||||
class Button extends React.Component {
|
||||
constructor() {
|
||||
super();
|
||||
this.state = {
|
||||
@ -89,20 +94,21 @@ localeTitle: رد فعل الدعائم والدولة
|
||||
Clicked {this.state.count} times
|
||||
</button>);
|
||||
}
|
||||
}
|
||||
`
|
||||
}
|
||||
```
|
||||
|
||||
### يتم إنشاء الحالة في المكون
|
||||
|
||||
دعونا ننظر إلى طريقة `constructor` :
|
||||
|
||||
`constructor() {
|
||||
```
|
||||
constructor() {
|
||||
super();
|
||||
this.state = {
|
||||
count: 0,
|
||||
};
|
||||
}
|
||||
`
|
||||
}
|
||||
```
|
||||
|
||||
هذا هو المكان الذي تحصل فيه الدولة على بياناتها الأولية. يمكن أن تكون البيانات الشفوية مشفرة بشكل صارم (على النحو الوارد أعلاه) ، ولكنها يمكن أن تأتي أيضًا من `props` .
|
||||
|
||||
@ -110,12 +116,13 @@ localeTitle: رد فعل الدعائم والدولة
|
||||
|
||||
إليك طريقة `updateCount` :
|
||||
|
||||
`updateCount() {
|
||||
```
|
||||
updateCount() {
|
||||
this.setState((prevState, props) => {
|
||||
return { count: prevState.count + 1 }
|
||||
});
|
||||
}
|
||||
`
|
||||
}
|
||||
```
|
||||
|
||||
نقوم بتغيير الحالة لتتبع إجمالي عدد النقرات. الشيء المهم هو setState. أولا ، لاحظ أن setState يأخذ وظيفة ، وهذا لأنه يمكن تشغيل setState بشكل غير متزامن. يجب أن تأخذ وظيفة رد اتصال بدلاً من تحديث الحالة مباشرة. يمكنك أن ترى أن لدينا إمكانية الوصول إلى prevState داخل معاودة الاتصال ، سيحتوي ذلك على الحالة السابقة ، حتى إذا كانت الولاية قد تم تحديثها بالفعل في مكان آخر.
|
||||
|
||||
@ -129,11 +136,12 @@ localeTitle: رد فعل الدعائم والدولة
|
||||
|
||||
قد يكون من المغري أيضًا كتابة شيء كهذا:
|
||||
|
||||
`// DO NOT USE
|
||||
this.setState({
|
||||
```
|
||||
// DO NOT USE
|
||||
this.setState({
|
||||
count: this.state.count + 1
|
||||
});
|
||||
`
|
||||
});
|
||||
```
|
||||
|
||||
على الرغم من أن هذا قد يبدو معقولاً ، إلا أنه لا يرمي الأخطاء ، وقد تجد أمثلة تستخدم هذه الصيغة على الإنترنت ، إلا أنها خاطئة. هذا لا يأخذ في الاعتبار الطبيعة `setState` التي يمكن أن `setState` وقد يسبب أخطاء مع بيانات حالة التزامن.
|
||||
|
||||
@ -141,14 +149,15 @@ localeTitle: رد فعل الدعائم والدولة
|
||||
|
||||
وأخيرا ، `render`
|
||||
|
||||
`render() {
|
||||
```
|
||||
render() {
|
||||
return (<button
|
||||
onClick={() => this.updateCount()}
|
||||
>
|
||||
Clicked {this.state.count} times
|
||||
</button>);
|
||||
}
|
||||
`
|
||||
}
|
||||
```
|
||||
|
||||
`onClick={() => this.updateCount()}` يعني أنه عند النقر فوق الزر سيتم استدعاء أسلوب updateCount. نحتاج إلى استخدام **وظيفة السهم** ES6 حتى يتمكن updateCount من الوصول إلى حالة هذا المثيل.
|
||||
|
||||
|
||||
@ -24,8 +24,9 @@ localeTitle: React Router
|
||||
|
||||
# بيان الاستيراد
|
||||
|
||||
`import { BrowserRouter as Router, Switch, Route, Link } from 'react-router-dom';
|
||||
`
|
||||
```javascript
|
||||
import { BrowserRouter as Router, Switch, Route, Link } from 'react-router-dom';
|
||||
```
|
||||
|
||||
## IndexRoute والروابط
|
||||
|
||||
@ -37,10 +38,11 @@ localeTitle: React Router
|
||||
|
||||
الطريقة الأساسية للسماح للمستخدمين بالتنقل حول تطبيقك. سيجعل علامة ارتساء يمكن الوصول إليها بالكامل مع href الصحيح. للقيام بذلك ، دعنا أولاً إنشاء مكون Nav. سيحتوي مكون Nav الخاص بنا على مكونات `<Link>` ، وسيبدو كما يلي:
|
||||
|
||||
`const Nav = () => (
|
||||
```javascript
|
||||
const Nav = () => (
|
||||
<div>
|
||||
<Link to='/'>Home</Link>
|
||||
<Link to='/address'>Address</Link>
|
||||
</div>
|
||||
)
|
||||
`
|
||||
)
|
||||
```
|
||||
@ -10,9 +10,10 @@ localeTitle: تقديم الدعائم مكون
|
||||
|
||||
هذا مثال على كيفية استخدام تقديم دعم لوظيفة تبديل.
|
||||
|
||||
`import React, { PureComponent } from "react";
|
||||
```jsx
|
||||
import React, { PureComponent } from "react";
|
||||
|
||||
class Toggle extends PureComponent {
|
||||
class Toggle extends PureComponent {
|
||||
state = {
|
||||
on: false
|
||||
};
|
||||
@ -30,24 +31,25 @@ localeTitle: تقديم الدعائم مكون
|
||||
toggle: this.toggle
|
||||
});
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
export default Toggle;
|
||||
`
|
||||
export default Toggle;
|
||||
```
|
||||
|
||||
هذا المكون تبديل سيعود انها الأطفال `state.on` وتبديل وظيفة. والتي يمكن استخدامها في مكونات الطفل.
|
||||
|
||||
يمكن استخدام Toggle كالتالي:
|
||||
|
||||
`<Toggle>
|
||||
```jsx
|
||||
<Toggle>
|
||||
{({ on, toggle }) => (
|
||||
<Fragment>
|
||||
<button onClick={toggle}>Show / Hide</button>
|
||||
{on && <h1>I can be toggled on or off!</h1>}
|
||||
</Fragment>
|
||||
)}
|
||||
</Toggle>
|
||||
`
|
||||
</Toggle>
|
||||
```
|
||||
|
||||
كما ترى ، يمكن استخدام وظيفة التبديل من خلال زر الطفل لتبديل بعض المحتوى. إذا كان صحيحًا ، فسيتم عرض علامة h1 بخلاف ذلك.
|
||||
|
||||
|
||||
@ -71,48 +71,55 @@ localeTitle: حالة
|
||||
|
||||
يمكنك تغيير البيانات المخزنة في حالة التطبيق الخاص بك باستخدام طريقة `setState` على المكون الخاص بك.
|
||||
|
||||
`this.setState({ value: 1 });
|
||||
`
|
||||
```js
|
||||
this.setState({ value: 1 });
|
||||
```
|
||||
|
||||
ضع في اعتبارك أن `setState` غير متزامن لذا يجب توخي الحذر عند استخدام الحالة الحالية لتعيين حالة جديدة. مثال جيد لهذا سيكون إذا كنت ترغب في زيادة قيمة في ولايتك.
|
||||
|
||||
#### الطريق الخطأ
|
||||
|
||||
`this.setState({ value: this.state.value + 1 });
|
||||
`
|
||||
```js
|
||||
this.setState({ value: this.state.value + 1 });
|
||||
```
|
||||
|
||||
يمكن أن يؤدي ذلك إلى سلوك غير متوقع في تطبيقك إذا كان الرمز أعلاه يُسمى عدة مرات في نفس دورة التحديث. لتجنب هذا يمكنك تمرير دالة رد اتصال محدث إلى `setState` بدلاً من كائن.
|
||||
|
||||
#### الطريق الصحيح
|
||||
|
||||
`this.setState(prevState => ({ value: prevState.value + 1 }));
|
||||
`
|
||||
```js
|
||||
this.setState(prevState => ({ value: prevState.value + 1 }));
|
||||
```
|
||||
|
||||
## تحديث الدولة
|
||||
|
||||
يمكنك تغيير البيانات المخزنة في حالة التطبيق الخاص بك باستخدام طريقة `setState` على المكون الخاص بك.
|
||||
|
||||
`this.setState({value: 1});
|
||||
`
|
||||
```js
|
||||
this.setState({value: 1});
|
||||
```
|
||||
|
||||
ضع في اعتبارك أن `setState` قد تكون غير متزامنة لذا يجب توخي الحذر عند استخدام الحالة الحالية لتعيين حالة جديدة. مثال جيد لهذا سيكون إذا كنت ترغب في زيادة قيمة في ولايتك.
|
||||
|
||||
##### الطريق الخطأ
|
||||
|
||||
`this.setState({value: this.state.value + 1});
|
||||
`
|
||||
```js
|
||||
this.setState({value: this.state.value + 1});
|
||||
```
|
||||
|
||||
يمكن أن يؤدي ذلك إلى سلوك غير متوقع في تطبيقك إذا كان الرمز أعلاه يُسمى عدة مرات في نفس دورة التحديث. لتجنب هذا يمكنك تمرير دالة رد اتصال محدث إلى `setState` بدلاً من كائن.
|
||||
|
||||
##### الطريق الصحيح
|
||||
|
||||
`this.setState(prevState => ({value: prevState.value + 1}));
|
||||
`
|
||||
```js
|
||||
this.setState(prevState => ({value: prevState.value + 1}));
|
||||
```
|
||||
|
||||
##### الطريق الأنظف
|
||||
|
||||
`this.setState(({ value }) => ({ value: value + 1 }));
|
||||
`
|
||||
```
|
||||
this.setState(({ value }) => ({ value: value + 1 }));
|
||||
```
|
||||
|
||||
عندما تكون هناك حاجة لعدد محدود من الحقول في كائن الحالة ، يمكن استخدام تدمير الكائن لرمز أنظف.
|
||||
|
||||
|
||||
@ -8,12 +8,13 @@ localeTitle: لديك أول رد فعل التطبيق
|
||||
|
||||
كما هو محدد في الأداة السابقة (التثبيت) ، قم بتشغيل أداة `Create React App` React. بعد الانتهاء من كل شيء ، أدخل `cd` في مجلد التطبيق الخاص بك وقم بتشغيل `npm start` . سيؤدي هذا إلى بدء خادم تطوير وستكون جاهزًا للبدء في تطوير تطبيقك!
|
||||
|
||||
`npm install -g react-create-app
|
||||
create-react-app my-first-app
|
||||
```bash
|
||||
npm install -g react-create-app
|
||||
create-react-app my-first-app
|
||||
|
||||
cd my-first-app
|
||||
npm start
|
||||
`
|
||||
cd my-first-app
|
||||
npm start
|
||||
```
|
||||
|
||||
### تحرير الرمز
|
||||
|
||||
@ -23,16 +24,18 @@ localeTitle: لديك أول رد فعل التطبيق
|
||||
|
||||
#### واردات
|
||||
|
||||
`import React, { Component } from 'react';
|
||||
import logo from './logo.svg';
|
||||
import './App.css';
|
||||
`
|
||||
```JavaScript
|
||||
import React, { Component } from 'react';
|
||||
import logo from './logo.svg';
|
||||
import './App.css';
|
||||
```
|
||||
|
||||
يتم استخدام هذا من خلال [webpack](https://webpack.js.org/) لاستيراد جميع الوحدات المطلوبة بحيث يمكن أن تستخدمها الكود. هذا الرمز يستورد 3 وحدات: 1) `React` `Component` ، مما يسمح لنا باستخدام React كما ينبغي استخدامه. (مع المكونات) 2) `logo` ، والذي يسمح لنا باستخدام `logo.svg` في هذا الملف. 3) `./App.css` ، التي تستورد ورقة الأنماط لهذا الملف.
|
||||
|
||||
#### فصول / المكونات
|
||||
|
||||
`class App extends Component {
|
||||
```JavaScript
|
||||
class App extends Component {
|
||||
render() {
|
||||
return (
|
||||
<div className="App">
|
||||
@ -46,8 +49,8 @@ localeTitle: لديك أول رد فعل التطبيق
|
||||
</div>
|
||||
);
|
||||
}
|
||||
}
|
||||
`
|
||||
}
|
||||
```
|
||||
|
||||
React هي مكتبة تستخدم المكونات ، والتي تتيح لك تقسيم واجهة المستخدم إلى أجزاء مستقلة يمكن إعادة استخدامها والتفكير في كل قطعة بمعزل عن غيرها. يوجد بالفعل مكون واحد مكون ، مكون `App` . إذا كنت تستخدم أداة `create-react-app` ، فإن هذا المكون هو المكون الرئيسي في المشروع ويجب أن تبني حول هذه الطبقة المركزية.
|
||||
|
||||
@ -57,8 +60,9 @@ React هي مكتبة تستخدم المكونات ، والتي تتيح لك
|
||||
|
||||
عند إنشاء فئة في الاستجابة ، يجب عليك تصديرها بعد التصريح ، والذي يسمح لك باستخدام المكون في ملف آخر باستخدام الكلمة الأساسية `import` . يمكنك استخدام `default` بعد الكلمة الأساسية `export` لإعلام React أن هذه هي الفئة الرئيسية من هذا الملف.
|
||||
|
||||
`export default App;
|
||||
`
|
||||
```JavaScript
|
||||
export default App;
|
||||
```
|
||||
|
||||
### عرض النتائج!
|
||||
|
||||
|
||||
Reference in New Issue
Block a user