diff --git a/modules/10-basics/10-hello-world/en/EXERCISE.md b/modules/10-basics/10-hello-world/en/EXERCISE.md new file mode 100644 index 00000000..491bc9fe --- /dev/null +++ b/modules/10-basics/10-hello-world/en/EXERCISE.md @@ -0,0 +1,7 @@ +Copy the exact code from the instructions into the editor and run it by clicking “Run”. + +```python +print('Hello, World!') +``` + +Note: if you write `heLLo, woRld!` instead of `Hello, World!`, it will be considered different text, because upper and lower case letters are different characters and different _registers_. In programming, the register almost always matters, so get used to always paying attention to it! diff --git a/modules/10-basics/10-hello-world/en/README.md b/modules/10-basics/10-hello-world/en/README.md new file mode 100644 index 00000000..deb7544f --- /dev/null +++ b/modules/10-basics/10-hello-world/en/README.md @@ -0,0 +1,7 @@ +Learning a new programming language traditionally begins with 'Hello, world!'. It is a simple program that both displays a greeting on the screen, and introduces the new language, showing its syntax and its program structure. + +
+  Hello, World!
+
+ +This tradition is over forty years old, so we're not thinking of breaking it any time soon. In the first lesson, we'll write a program called `Hello, world!`. To do this, you have to give the computer a special command. In Python, it's: `print()`. diff --git a/modules/10-basics/10-hello-world/en/data.yml b/modules/10-basics/10-hello-world/en/data.yml new file mode 100644 index 00000000..d714c29e --- /dev/null +++ b/modules/10-basics/10-hello-world/en/data.yml @@ -0,0 +1 @@ +name: Hello, world! diff --git a/modules/10-basics/10-hello-world/es/EXERCISE.md b/modules/10-basics/10-hello-world/es/EXERCISE.md new file mode 100644 index 00000000..d5e95213 --- /dev/null +++ b/modules/10-basics/10-hello-world/es/EXERCISE.md @@ -0,0 +1,7 @@ +Escribe en el editor el código del ejercicio, carácter por carácter, y luego haz clic en "Verificar". + +```python +print('Hello, World!') +``` + +Atención: si escribes `heLLo, woRld!` en lugar de `Hello, World!`, el sistema lo considerará un texto diferente, ya que el tamaño de la letra implica el uso de caracteres diferentes que difieren en _mayúsculas y minúsculas_. En programación, la capitalización casi siempre importa, así que acostúmbrate a prestarle siempre atención a esos pequeños detalles. diff --git a/modules/10-basics/10-hello-world/es/README.md b/modules/10-basics/10-hello-world/es/README.md new file mode 100644 index 00000000..8dcf5fd1 --- /dev/null +++ b/modules/10-basics/10-hello-world/es/README.md @@ -0,0 +1,7 @@ +Por lo general, el aprendizaje de un nuevo lenguaje de programación comienza con 'Hello, World!'. Este es un programa simple que muestra un saludo en la pantalla, y al mismo tiempo, familiariza al usuario con el nuevo lenguaje, así como con su sintaxis y la estructura del programa. + +
+  Hello, World!
+
+ +Esta tradición tiene más de cuarenta años, por lo cual no la romperemos. En la primera lección escribiremos el programa `Hello, World!`. Para hacerlo, debemos darle al ordenador un comando especial. En Python, este comando se llama `print()`. diff --git a/modules/10-basics/10-hello-world/es/data.yml b/modules/10-basics/10-hello-world/es/data.yml new file mode 100644 index 00000000..745da738 --- /dev/null +++ b/modules/10-basics/10-hello-world/es/data.yml @@ -0,0 +1,5 @@ +name: ¡Hola, Mundo! +tips: + - > + [Un poco sobre 'Hello, + World!'](https://codica.la/blog/mi-gente-me-entiende-la-historia-de-la-frase-hello-world-y-sus-analogos) diff --git a/modules/10-basics/10-hello-world/ru/EXERCISE.md b/modules/10-basics/10-hello-world/ru/EXERCISE.md new file mode 100644 index 00000000..655fe0bc --- /dev/null +++ b/modules/10-basics/10-hello-world/ru/EXERCISE.md @@ -0,0 +1,7 @@ +Наберите в редакторе код из задания символ в символ и нажмите «Проверить». + +```python +print('Hello, World!') +``` + +Внимание: если вы напишете `heLLo, woRld!` вместо `Hello, World!`, то это будет считаться другим текстом, потому что заглавные и строчные буквы — это разные символы, отличающиеся _регистром_. В программировании регистр практически всегда имеет значение, поэтому привыкайте всегда обращать на него внимание! diff --git a/modules/10-basics/10-hello-world/ru/README.md b/modules/10-basics/10-hello-world/ru/README.md new file mode 100644 index 00000000..1a9fc3ed --- /dev/null +++ b/modules/10-basics/10-hello-world/ru/README.md @@ -0,0 +1,7 @@ +Изучение нового языка программирования традиционно начинается с 'Hello, World!'. Это простая программа, которая выводит приветствие на экран и заодно знакомит с новым языком — его синтаксисом и структурой программы. + +
+  Hello, World!
+
+ +Этой традиции уже больше сорока лет, поэтому и мы не будем нарушать ее. В первом уроке мы напишем программу `Hello, World!`. Чтобы сделать это, нужно дать компьютеру специальную команду. В языке Python это — `print()`. diff --git a/modules/10-basics/10-hello-world/ru/data.yml b/modules/10-basics/10-hello-world/ru/data.yml new file mode 100644 index 00000000..1a060c77 --- /dev/null +++ b/modules/10-basics/10-hello-world/ru/data.yml @@ -0,0 +1,5 @@ +name: Привет, Мир! +tips: + - > + [Немного о 'Hello, + World!'](https://ru.hexlet.io/blog/posts/moy-chelovek-menya-ponimaet-istoriya-frazy-hello-world-i-ee-analogov) diff --git a/modules/10-basics/20-comments/en/EXERCISE.md b/modules/10-basics/20-comments/en/EXERCISE.md new file mode 100644 index 00000000..1eacaab6 --- /dev/null +++ b/modules/10-basics/20-comments/en/EXERCISE.md @@ -0,0 +1,2 @@ + +Create a one-line comment with the text: `You know nothing, Jon Snow!` diff --git a/modules/10-basics/20-comments/en/README.md b/modules/10-basics/20-comments/en/README.md new file mode 100644 index 00000000..b4b31f4d --- /dev/null +++ b/modules/10-basics/20-comments/en/README.md @@ -0,0 +1,22 @@ + +Almost all programming languages allow you to leave comments in your code. The interpreter ignores them. They're only for people; they let the programmer leave notes for themselves and other programmers. + +They allow you to add explanations of how the code works, what errors need to be corrected, or what you need to remember to add later: + +```python +# Delete the line below after the registration task is done +print(10) +``` + +Comments in Python begin with the `#` sign and can appear anywhere in the program. They can take up an entire line. If one line is not enough, you can create several comments: + +```python +# For Winterfell! +# For Lanisters! +``` + +The comment can be on the line after the code: + +```python +print('I am the King') # For Lannisters! +``` diff --git a/modules/10-basics/20-comments/en/data.yml b/modules/10-basics/20-comments/en/data.yml new file mode 100644 index 00000000..6839eb4b --- /dev/null +++ b/modules/10-basics/20-comments/en/data.yml @@ -0,0 +1,7 @@ +name: Comments +tips: [] +definitions: + - name: Comments + description: > + text in the program code that does not affect the functionality and is + added by programmers for themselves and their colleagues. diff --git a/modules/10-basics/20-comments/es/EXERCISE.md b/modules/10-basics/20-comments/es/EXERCISE.md new file mode 100644 index 00000000..5474cebc --- /dev/null +++ b/modules/10-basics/20-comments/es/EXERCISE.md @@ -0,0 +1,2 @@ + +Crea un comentario de una línea con el texto: `You know nothing, Jon Snow!` diff --git a/modules/10-basics/20-comments/es/README.md b/modules/10-basics/20-comments/es/README.md new file mode 100644 index 00000000..bf33837f --- /dev/null +++ b/modules/10-basics/20-comments/es/README.md @@ -0,0 +1,22 @@ + +Casi todos los lenguajes de programación permiten dejar comentarios en el código. Estos comentarios no son utilizados por el sistema intérprete. Son útiles únicamente para las personas que usan estas herramientas; para que los programadores puedan dejar notas para ellos mismos y también para otros programadores. + +A través de estos comentarios, se agregan explicaciones sobre cómo funciona el código, qué errores corregir o qué agregar más adelante. + +```python +# Eliminar la línea de abajo después de implementar la tarea de registro +print(10) +``` + +Los comentarios en Python comienzan con el signo `#` y pueden aparecer en cualquier lugar del programa. Pueden ocupar toda una línea. Si una línea no es suficiente, se pueden crear varios comentarios: + +```python +# ¡For Winterfell! +# ¡For Lannisters! +``` + +Un comentario puede estar en la línea después del código: + +```python +print('I am the King') # ¡For Lannisters! +``` diff --git a/modules/10-basics/20-comments/es/data.yml b/modules/10-basics/20-comments/es/data.yml new file mode 100644 index 00000000..ec72e1dc --- /dev/null +++ b/modules/10-basics/20-comments/es/data.yml @@ -0,0 +1,11 @@ +name: Comentarios +tips: + - > + [Más información sobre + comentarios](https://www.w3schools.com/python/python_comments.asp) +definitions: + - name: Comentario + description: > + se trata de un texto en el código de un programa que no afecta su + funcionalidad y lo agregan los programadores para su propio uso y/o el de + sus colegas. diff --git a/modules/10-basics/20-comments/ru/EXERCISE.md b/modules/10-basics/20-comments/ru/EXERCISE.md new file mode 100644 index 00000000..fd980da0 --- /dev/null +++ b/modules/10-basics/20-comments/ru/EXERCISE.md @@ -0,0 +1,2 @@ + +Создайте однострочный комментарий с текстом: `You know nothing, Jon Snow!` diff --git a/modules/10-basics/20-comments/ru/README.md b/modules/10-basics/20-comments/ru/README.md new file mode 100644 index 00000000..98a48fb1 --- /dev/null +++ b/modules/10-basics/20-comments/ru/README.md @@ -0,0 +1,22 @@ + +Практически все языки программирования позволяют оставлять в коде комментарии. Они никак не используются интерпретатором. Они нужны исключительно для людей, чтобы программист оставлял пометки для себя и для других программистов. + +С их помощью добавляют пояснения, как работает код, какие ошибки нужно поправить или не забыть что-то добавить позже: + +```python +# Удалить строку ниже после реализации задачи по регистрации +print(10) +``` + +Комментарии в Python начинаются со знака `#` и могут появляться в любом месте программы. Они могут занимать всю строку. Если одной строки мало, то создается несколько комментариев: + +```python +# For Winterfell! +# For Lanisters! +``` + +Комментарий может находиться на строке после кода: + +```python +print('I am the King') # For Lannisters! +``` diff --git a/modules/10-basics/20-comments/ru/data.yml b/modules/10-basics/20-comments/ru/data.yml new file mode 100644 index 00000000..e60a0923 --- /dev/null +++ b/modules/10-basics/20-comments/ru/data.yml @@ -0,0 +1,10 @@ +name: Комментарии +tips: + - > + [Подробнее о + комментариях](https://www.w3schools.com/python/python_comments.asp) +definitions: + - name: Комментарий + description: > + текст в коде программы, который не влияет на функциональность и + добавляется программистами для себя и своих коллег. diff --git a/modules/10-basics/30-instructions/en/EXERCISE.md b/modules/10-basics/30-instructions/en/EXERCISE.md new file mode 100644 index 00000000..78ff7def --- /dev/null +++ b/modules/10-basics/30-instructions/en/EXERCISE.md @@ -0,0 +1,9 @@ +Display three names, one after another: _Robert_, _Stannis_, _Renly_. The result should be that the following is shown on the screen: + +
+Robert
+Stannis
+Renly
+
+ +For each name, use Python's own `print()` call. diff --git a/modules/10-basics/30-instructions/en/README.md b/modules/10-basics/30-instructions/en/README.md new file mode 100644 index 00000000..670040d9 --- /dev/null +++ b/modules/10-basics/30-instructions/en/README.md @@ -0,0 +1,26 @@ +When we're making a dish, we follow the recipe carefully. Otherwise, the food won't turn out as expected. The same rule applies to programming. + +If you want to see the expected result onscreen, the computer needs to have clear, step-by-step directions. This can be done using instructions. An instruction is a command to the computer, a unit of execution. Python code in this case is a set of instructions. It can be presented as a step-by-step recipe. + +Python code is run by an **interpreter**, a program that executes instructions strictly, line by line. Like the steps in a recipe, the instructions for the interpreter are written in order and are separated from each other by skipping to the next line. + +Developers must understand the order of operations in the code, and be able to mentally divide the program into independent parts that are convenient for analysis. + + Let's look at an example of some code with two instructions. When it's started, two sentences are displayed sequentially on the screen: + +```python +print('Mother of Dragons.') +print('Dracarys!') +# => Mother of Dragons. +# => Dracarys! +``` + +We said above that instructions are separated from each other by a line break. But there is another way; they can be separated by a semicolon — `;`: + +```python +print('Mother of Dragons.'); print('Drakarys!') +``` + + There is no technical difference between the first and second version; the interpreter will understand the instructions the same way. The only difference is that it's inconvenient, physically, to read the second version. + +It's better to place the instructions under each other. This makes it easier for colleagues to read your code, maintain it, and make changes. diff --git a/modules/10-basics/30-instructions/en/data.yml b/modules/10-basics/30-instructions/en/data.yml new file mode 100644 index 00000000..b01af3de --- /dev/null +++ b/modules/10-basics/30-instructions/en/data.yml @@ -0,0 +1,13 @@ +name: Statements +tips: + - > + [A little bit about + interpreters](https://en.wikipedia.org/wiki/Interpreter_(computing)) +definitions: + - name: Interpreter + description: | + a program that runs code in Python. + - name: Statement + description: >- + a command for the computer written in a programming language. Python code + is a set of instructions, most often separated by a line break. diff --git a/modules/10-basics/30-instructions/es/EXERCISE.md b/modules/10-basics/30-instructions/es/EXERCISE.md new file mode 100644 index 00000000..e39280c6 --- /dev/null +++ b/modules/10-basics/30-instructions/es/EXERCISE.md @@ -0,0 +1,9 @@ +Imprime en la pantalla uno tras otro tres nombres: *Robert*, *Stannis*, *Renly*. Como resultado, se debe mostrar en la pantalla: + +
+Robert
+Stannis
+Renly
+
+ +Por cada nombre o designación, usa nuevamente la orden de `print()`. diff --git a/modules/10-basics/30-instructions/es/README.md b/modules/10-basics/30-instructions/es/README.md new file mode 100644 index 00000000..50e86f7d --- /dev/null +++ b/modules/10-basics/30-instructions/es/README.md @@ -0,0 +1,28 @@ +Cuando preparamos una comida, seguimos la receta al pie de la letra. De lo contrario, la comida no saldrá como esperábamos. Esta regla también se aplica a la programación. + +Para ver el resultado esperado en la pantalla, es necesario darle al ordenador instrucciones claras, paso a paso. Una instrucción es un comando para el ordenador; una unidad de ejecución. En este caso, el código en Python es un conjunto de instrucciones. Se puede representar como una receta de cocina paso a paso. + +El código en Python es ejecutado por un **intérprete** - es decir, un programa que ejecuta las instrucciones recibidas en orden. Al igual que los pasos en una receta, el conjunto de instrucciones para el intérprete se escriben en orden y se separan por saltos de línea. + +Los desarrolladores deben entender el orden de las acciones en el código y ser capaces de dividir mentalmente el programa en partes independientes, fáciles de analizar. + +Veamos un ejemplo de código con dos instrucciones. Al ejecutarlo, se mostrarán en la pantalla dos frases en secuencia: + +```python +print('Mother of Dragons.') +print('Dracarys!') +# => Mother of Dragons. +# => Dracarys! +``` + +https://replit.com/@hexlet/python-basics-instructions + +Anteriormente hemos señalado que las instrucciones se separan por saltos de línea. Pero también hay otra forma: se pueden separar por punto y coma (`;`): + +```python +print('Mother of Dragons.'); print('Drakarys!') +``` + +No hay diferencia técnica alguna entre la primera y la segunda opción: el intérprete entenderá las instrucciones de la misma manera. La única diferencia es que la segunda opción puede ser incómoda de leer para los humanos. + +Es mejor colocar las instrucciones una debajo de la otra. De esta manera, será más fácil para tus colegas leer tu código, mantenerlo y realizar cambios en él. diff --git a/modules/10-basics/30-instructions/es/data.yml b/modules/10-basics/30-instructions/es/data.yml new file mode 100644 index 00000000..bde89ea3 --- /dev/null +++ b/modules/10-basics/30-instructions/es/data.yml @@ -0,0 +1,14 @@ +name: Instrucciones +tips: + - > + [Más información sobre los + intérpretes](https://es.wikipedia.org/wiki/Int%C3%A9rprete) +definitions: + - name: Intérprete + description: | + un programa que ejecuta código en Python. + - name: Instrucción + description: >- + un comando para el ordenador escrito en un lenguaje de programación. El + código en Python es un conjunto de instrucciones separadas (generalmente) + por saltos de línea. diff --git a/modules/10-basics/30-instructions/ru/EXERCISE.md b/modules/10-basics/30-instructions/ru/EXERCISE.md new file mode 100644 index 00000000..6d612229 --- /dev/null +++ b/modules/10-basics/30-instructions/ru/EXERCISE.md @@ -0,0 +1,9 @@ +Выведите на экран друг за другом три имени: *Robert*, *Stannis*, *Renly*. В результате на экране должно отобразиться: + +
+Robert
+Stannis
+Renly
+
+ +Для каждого имени используйте свой собственный вызов `print()`. diff --git a/modules/10-basics/30-instructions/ru/README.md b/modules/10-basics/30-instructions/ru/README.md new file mode 100644 index 00000000..278c9b5b --- /dev/null +++ b/modules/10-basics/30-instructions/ru/README.md @@ -0,0 +1,28 @@ +Когда мы готовим блюдо, то четко следуем рецепту. Иначе еда окажется не такой, как ожидали. Это же правило действует и в программировании. + +Чтобы увидеть на экране ожидаемый результат, нужно дать компьютеру четкие и пошаговые указания. Это можно сделать с помощью инструкций. Инструкция — это команда для компьютера, единица выполнения. Код на Python в этом случае — это набор инструкций. Его можно представить в виде пошагового рецепта. + +Код на Python запускает **интерпретатор** — программу, которая выполняет инструкции строго по очереди. Как и шаги в рецепте, набор инструкций для интерпретатора пишутся по порядку и отделяются друг от друга переходом на следующую строку. + +Разработчики должны понимать порядок действий в коде и уметь мысленно разделять программу на независимые части, удобные для анализа. + +Посмотрим на пример кода с двумя инструкциями. При его запуске на экран последовательно выводятся два предложения: + +```python +print('Mother of Dragons.') +print('Dracarys!') +# => Mother of Dragons. +# => Dracarys! +``` + +https://replit.com/@hexlet/python-basics-instructions + +Выше мы говорили, что инструкции отделяются друг от друга переходом на новую строку. Но есть и другой способ: их можно разделить точкой с запятой — `;`: + +```python +print('Mother of Dragons.'); print('Drakarys!') +``` + +Технической разницы между первым и вторым вариантом нет — интерпретатор поймет инструкции одинаково. Разница только в том, что человеку будет неудобно читать второй вариант. + +Лучше инструкции располагать друг под другом. Так коллегам будет удобнее читать ваш код, обслуживать его и вносить изменения. diff --git a/modules/10-basics/30-instructions/ru/data.yml b/modules/10-basics/30-instructions/ru/data.yml new file mode 100644 index 00000000..54357d96 --- /dev/null +++ b/modules/10-basics/30-instructions/ru/data.yml @@ -0,0 +1,12 @@ +name: Инструкции (Statements) +tips: + - | + [Немного об интерпретаторах](https://ru.wikipedia.org/wiki/Интерпретатор) +definitions: + - name: Интерпретатор + description: | + программа, выполняющая код на Python. + - name: Инструкция (statement) + description: >- + команда для компьютера, написанная на языке программирования. Код на + Python — это набор инструкций, разделенных (чаще всего) переводом строки. diff --git a/modules/10-basics/40-testing/en/EXERCISE.md b/modules/10-basics/40-testing/en/EXERCISE.md new file mode 100644 index 00000000..6770f271 --- /dev/null +++ b/modules/10-basics/40-testing/en/EXERCISE.md @@ -0,0 +1 @@ +Display `9780262531962`. diff --git a/modules/10-basics/40-testing/en/README.md b/modules/10-basics/40-testing/en/README.md new file mode 100644 index 00000000..f903d67c --- /dev/null +++ b/modules/10-basics/40-testing/en/README.md @@ -0,0 +1,26 @@ + +Our site automatically checks your decisions. How does it work? + +In the simplest case, the system just runs your code and looks at what's on the screen. And then it checks against what we "expected" from the job. + +In the next, more complicated lessons, you will write functions, mini-programs that take information from the outside world and perform some operations. Checking your decisions in such cases looks a little more complicated: the system runs your decision and sends some information. The system also knows - "expects" - exactly what answer the correct function should give with this input. + +For example, if your task is to write a function for adding two numbers, then the checking system will pass it different combinations of numbers and check the answer of your function against the real sums. If in all cases the answers are the same, then the solution is considered correct. + +This approach is called testing, and it is used in real everyday development. Usually the programmer first writes a test, a test program, and then the program he wants to write. In the process, he is constantly running tests and seeing if he has come close to a solution. + +That's why our site says "Tests passed" when you solve the problem correctly. + +Here is a simple example: in a future lesson, you will need to write a function that performs calculations and gives the answer. Suppose you make a small mistake and the function gives you the wrong number. The system will answer something like this: + +
AssertionError: '10' != '35'
+ +The most important thing begins after the colon: "the value of '10' is not equal to the expected value of '35'". That is, the correct function should have produced 35, but the current solution does not work correctly and produces 10. + +It is also worth noting that if you see that there is already some code in the editor, and along with it the comments `BEGIN` and `END`, it usually means that you have to write your code between these very BEGIN and END! The code given to you beforehand should not be touched: it may affect the validation of the solution. To put it simply: you see lines with comments `BEGIN` and `END` — write your code between them! + +--- + +Sometimes it will seem that you have done everything correctly, but the system is "capricious" and does not make a decision. Such behavior is practically excluded. Non-working tests simply can not get to the site, they automatically run after each change. In the vast majority of such cases, (and all of our projects have done millions of tests in total over many years), the error is contained in the solution code. It can be very subtle, instead of English letters accidentally entered the Russian, instead of upper case used lower case or forgot to display the comma. Other cases are more complicated. Your solution may work for one set of input data, but not for another. So always read the problem statement and test output carefully. There is almost certainly an error indication there. + +However, if you are sure of an error or find some inaccuracy, you can always point it out. At the end of each theory, there is a link to the contents of the lesson on the githab (this project is completely open source!). By going there you can write an issue, look at the contents of the tests (you can see how your code is called) and even send a pullrequest. If this is still a dark forest for you, join our [Slack community](https://slack.hexlet.io/), _#hexlet-feedback_ we are always there for you. diff --git a/modules/10-basics/40-testing/en/data.yml b/modules/10-basics/40-testing/en/data.yml new file mode 100644 index 00000000..b7e0269c --- /dev/null +++ b/modules/10-basics/40-testing/en/data.yml @@ -0,0 +1,10 @@ +name: How we check your solutions +definitions: + - name: Tests + description: >- + a special code that checks programs for correctness by comparing the + result obtained during the execution of the program with the expected + result. +tips: + - | + [TDD](https://en.wikipedia.org/wiki/Test-driven_development) diff --git a/modules/10-basics/40-testing/es/EXERCISE.md b/modules/10-basics/40-testing/es/EXERCISE.md new file mode 100644 index 00000000..7431f3f6 --- /dev/null +++ b/modules/10-basics/40-testing/es/EXERCISE.md @@ -0,0 +1 @@ +Muestra en la pantalla `9780262531962`. diff --git a/modules/10-basics/40-testing/es/README.md b/modules/10-basics/40-testing/es/README.md new file mode 100644 index 00000000..cd9e128e --- /dev/null +++ b/modules/10-basics/40-testing/es/README.md @@ -0,0 +1,26 @@ + +Nuestro sitio web verifica automáticamente tus soluciones (uso específico del término en programación). ¿Cómo funciona? + +En los casos más simples, el sistema simplemente ejecuta tu código y verifica lo que se muestra en la pantalla. Luego lo compara con lo que "esperábamos" según la tarea. + +En las lecciones más avanzadas, escribirás funciones, que son pequeños programas que toman información del mundo exterior y realizan operaciones con base en esta información. La verificación de tus soluciones en estos casos es un poco más complicada: el sistema ejecuta tu solución y le pasa cierta información. El sistema también sabe qué respuesta debería dar la función correcta con esos datos de entrada. + +Por ejemplo, si tu tarea es escribir una función que sume dos números, el sistema de verificación le pasará diferentes combinaciones de números y comparará la respuesta de tu función con las sumas reales. Si las respuestas coinciden en todos los casos, se considera que la solución es correcta. + +Este enfoque se llama pruebas y se utiliza en el desarrollo diario real. Por lo general, el programador primero escribe una prueba, que es un programa de verificación, y luego escribe el programa que quería escribir. Durante el proceso, ejecuta las pruebas constantemente y verifica si se acerca a la solución. + +Es por eso que nuestro sitio web indica "Pruebas aprobadas" cuando resuelves correctamente un problema. + +Aquí tienes un ejemplo sencillo: en una de las futuras lecciones, tendrás que escribir una función que realice cálculos y devuelva una respuesta. Supongamos que cometiste un pequeño error y la función devolvió un número incorrecto. El sistema responderá algo así: + +
AssertionError: '10' != '35'
+ +Lo más importante sigue después de los dos puntos: "el valor '10' no es igual al valor esperado '35'". Es decir, la función correcta debería haber devuelto 35, pero la solución actual no funciona correctamente y devuelve 10. + +También vale la pena mencionar que si ves que en el editor ya hay algún código junto con los comentarios `BEGIN` y `END`, generalmente significa que debes escribir tu código entre estos comentarios. No debes modificar de antemano el código que se te proporciona, ya que esto puede afectar la verificación de la solución. En resumen, si ves líneas con los comentarios `BEGIN` y `END`, ¡escribe tu código en el espacio que se encuentra entre estos! + +--- + +A veces, durante el proceso de resolución, puede parecer que has hecho todo correctamente, pero el sistema se comporta de manera "caprichosa" y no acepta la solución. Este comportamiento es prácticamente imposible. Las pruebas no funcionales simplemente no pueden llegar al sitio web; se ejecutan automáticamente después de cada cambio. En la gran mayoría de estos casos (y todos nuestros proyectos en conjunto han realizado millones de verificaciones a lo largo de los años), el error se encuentra en el código de la solución. Puede ser muy sutil, como haber ingresado accidentalmente una letra rusa en lugar de una letra en inglés; usar minúsculas en lugar de mayúsculas; o olvidar poner una coma, por ejemplo. Otros casos son más complicados. Es posible que tu solución funcione para un conjunto de datos de entrada, pero no funcione para otro. Por lo tanto, siempre lee atentamente la descripción del problema y los resultados de las pruebas. Casi seguro que habrá alguna indicación sobre el error. + +Sin embargo, si estás seguro de que hay un error o has encontrado alguna imprecisión, siempre puedes señalarlo. Al final de cada teoría hay un enlace al contenido de la lección en GitHub (¡este proyecto es completamente abierto!). Al ir allí, puedes escribir un issue, ver el contenido de las pruebas (donde se muestra cómo se llama tu código) e incluso enviar un pull request. Si esto aún te resulta confuso, únete a nuestra [comunidad en Telegram](https://t.me/hexletcommunity/3), allí en el canal *'Feedback'* siempre estaremos dispuestos a ayudar. diff --git a/modules/10-basics/40-testing/es/data.yml b/modules/10-basics/40-testing/es/data.yml new file mode 100644 index 00000000..fd6410bf --- /dev/null +++ b/modules/10-basics/40-testing/es/data.yml @@ -0,0 +1,12 @@ +name: Cómo verificamos tus soluciones +definitions: + - name: Pruebas + description: >- + códigos especiales que verifican la veracidad y nivel de corrección de los + programas comparando el resultado obtenido al ejecutar el programa con el + resultado esperado. +tips: + - | + [TDD](https://es.wikipedia.org/wiki/Desarrollo_guiado_por_pruebas) + - | + [Comunidad de Hexlet en Telegram](https://t.me/hexletcommunity) diff --git a/modules/10-basics/40-testing/ru/EXERCISE.md b/modules/10-basics/40-testing/ru/EXERCISE.md new file mode 100644 index 00000000..f2b2063b --- /dev/null +++ b/modules/10-basics/40-testing/ru/EXERCISE.md @@ -0,0 +1 @@ +Выведите на экран `9780262531962`. diff --git a/modules/10-basics/40-testing/ru/README.md b/modules/10-basics/40-testing/ru/README.md new file mode 100644 index 00000000..62b47a7d --- /dev/null +++ b/modules/10-basics/40-testing/ru/README.md @@ -0,0 +1,26 @@ + +Наш сайт автоматически проверяет ваши решения. Как это работает? + +В самом простом случае система просто запускает ваш код и смотрит на то, что вывелось на экран. А потом сверяет с тем, что мы «ожидали» по заданию. + +В следующих, более сложных уроках вы будете писать функции — некие мини-программы, принимающие информацию из внешнего мира и производящие какие-то операции. Проверка ваших решений в таких случаях выглядит немного сложнее: система запускает ваше решение и передаёт какую-то информацию. Система также знает — «ожидает» — какой именно ответ должна дать правильная функция при таких входных данных. + +Например, если ваша задача — написать функцию сложения двух чисел, то проверочная система будет передавать ей разные комбинации чисел и сверять ответ вашей функции с реальными суммами. Если во всех случаях ответы совпадут, то решение считается верным. + +Такой подход называется тестированием, и он используется в реальной повседневной разработке. Обычно программист сначала пишет тест — проверочную программу, а потом уже ту программу, которую хотел написать. В процессе он постоянно запускает тесты и смотрит, приблизился ли он к решению. + +Именно поэтому наш сайт говорит «Тесты пройдены», когда вы правильно решили задачу. + +Вот простой пример: в одном из будущих уроков вам нужно будет написать функцию, которая производит вычисления и выдаёт ответ. Допустим, вы допустили небольшую ошибку, и функция выдала неправильное число. Система ответит примерно так: + +
AssertionError: '10' != '35'
+ +Самое главное начинается после двоеточия: «значение "10" не равно ожидаемому значению "35"». То есть правильная функция должна была выдать 35, но текущее решение работает неправильно и выдаёт 10. + +Ещё стоит отметить, что если вы видите, что в редакторе уже присутствует какой-то код, а вместе с ним комментарии `BEGIN` и `END`, то обычно это подразумевает, что вам нужно писать ваш код между этими самыми BEGIN и END! Код, данный вам заранее, трогать не стоит: это может повлиять на проверку правильности решения. Проще говоря: видите строчки с комментариями `BEGIN` и `END` — пишите свой код между ними! + +--- + +Иногда в процессе решения будет казаться, что вы сделали все правильно, но система "капризничает" и не принимает решение. Подобное поведение практически исключено. Нерабочие тесты просто не могут попасть на сайт, они автоматически запускаются после каждого изменения. В подавляющем большинстве таких случаев, (а все наши проекты в сумме провели миллионы проверок за много лет), ошибка содержится в коде решения. Она может быть очень незаметной, вместо английской буквы случайно ввели русскую, вместо верхнего регистра использовали нижний или забыли вывести запятую. Другие случаи сложнее. Возможно ваше решение работает для одного набора входных данных, но не работает для другого. Поэтому всегда внимательно читайте условие задачи и вывод тестов. Там почти наверняка есть указание на ошибку. + +Однако, если вы уверены в ошибке или нашли какую-то неточность, то вы всегда можете указать на нее. В конце каждой теории есть ссылка на содержимое урока на гитхабе (этот проект полностью открытый!). Перейдя туда, вы можете написать issue, посмотреть содержимое тестов (там видно, как вызывается ваш код) и даже отправить pullrequest. Если для вас это пока темный лес, то подключитесь в наше [сообщество в Telegram](https://t.me/hexletcommunity/3), там в канале *'Обратная связь'* мы всегда поможем. diff --git a/modules/10-basics/40-testing/ru/data.yml b/modules/10-basics/40-testing/ru/data.yml new file mode 100644 index 00000000..416e2124 --- /dev/null +++ b/modules/10-basics/40-testing/ru/data.yml @@ -0,0 +1,11 @@ +name: Как мы проверяем ваши решения +definitions: + - name: Тесты + description: >- + специальный код, проверяющий программы на корректность путём сравнения + полученного при выполнении программы результата с ожидаемым. +tips: + - | + [TDD](https://ru.wikipedia.org/wiki/Разработка_через_тестирование) + - | + [Сообщество Хекслета в Telegram](https://t.me/hexletcommunity) diff --git a/modules/10-basics/50-syntax-errors/en/EXERCISE.md b/modules/10-basics/50-syntax-errors/en/EXERCISE.md new file mode 100644 index 00000000..7c2fdebf --- /dev/null +++ b/modules/10-basics/50-syntax-errors/en/EXERCISE.md @@ -0,0 +1,6 @@ + +This assignment is not directly related to the lesson. But it will be useful to practice with the output on the screen. + +Display: + +
What Is Dead May Never Die
diff --git a/modules/10-basics/50-syntax-errors/en/README.md b/modules/10-basics/50-syntax-errors/en/README.md new file mode 100644 index 00000000..2f5d4e07 --- /dev/null +++ b/modules/10-basics/50-syntax-errors/en/README.md @@ -0,0 +1,22 @@ + +If a Python program is written syntactically incorrectly, the interpreter displays a message. It also points to the file and line where the error occurred. + +**A syntactic error occurs when code is written in violation of grammatical rules. In natural languages, grammar is important, but text with errors can usually be understood and read. In programming everything is strict. The slightest violation and the program will not even run. An example would be the forgotten `;`, incorrectly placed brackets and other details. + +Here is a sample code with a syntax error: + +```python +print('Hodor) +``` + +If we run the code above, we see the following message: + +```bash +$ python index.py +File "index.py", line 1 + print('Hodor) + ^ +SyntaxError: EOL while scanning string literal +``` + +On the one hand, syntax errors are the easiest, because they are related to the grammatical rules of writing code, not to the meaning of the code. They are easy to fix: you just need to find a violation in the writing. On the other hand, the interpreter is not always able to clearly indicate this violation. Therefore it happens that a forgotten parenthesis must be placed in the wrong place, where the error message indicates. diff --git a/modules/10-basics/50-syntax-errors/en/data.yml b/modules/10-basics/50-syntax-errors/en/data.yml new file mode 100644 index 00000000..22f50413 --- /dev/null +++ b/modules/10-basics/50-syntax-errors/en/data.yml @@ -0,0 +1,9 @@ +name: Syntax errors +tips: [] +definitions: + - name: Syntax errors + description: violation of the grammatical rules of the programming language. + - name: SyntaxError (parsing error) + description: >- + the type of errors in Python that occur when there are syntax errors in + the code. diff --git a/modules/10-basics/50-syntax-errors/es/EXERCISE.md b/modules/10-basics/50-syntax-errors/es/EXERCISE.md new file mode 100644 index 00000000..4afca9a8 --- /dev/null +++ b/modules/10-basics/50-syntax-errors/es/EXERCISE.md @@ -0,0 +1,6 @@ + +Esta tarea no está directamente relacionada con la lección. Pero será útil practicar la impresión en la pantalla. + +Imprime en la pantalla: + +
What Is Dead May Never Die
diff --git a/modules/10-basics/50-syntax-errors/es/README.md b/modules/10-basics/50-syntax-errors/es/README.md new file mode 100644 index 00000000..77de380b --- /dev/null +++ b/modules/10-basics/50-syntax-errors/es/README.md @@ -0,0 +1,24 @@ + +Si un programa escrito en Python tiene errores de sintaxis, el intérprete mostrará un mensaje correspondiente en la pantalla. También indicará el archivo y la línea donde se produjo el error. + +Un **error de sintaxis** ocurre cuando el código se ha escrito con violación de las reglas gramaticales. En los lenguajes naturales, la gramática es importante, pero generalmente se puede entender y leer el texto con errores. En la programación, todo es estricto. El más mínimo error y el programa ni siquiera se ejecutará. Un ejemplo puede ser un punto y coma olvidado, paréntesis mal colocados y otros detalles. + +Aquí hay un ejemplo de código con un error de sintaxis: + +```python +print('Hodor) +``` + +https://replit.com/@hexlet/python-basics-syntax-errors + +Si ejecutamos el código anterior, veremos el siguiente mensaje: + +```bash +$ python index.py +File "index.py", line 1 + print('Hodor) + ^ +SyntaxError: EOL while scanning string literal +``` + +Por un lado, los errores de sintaxis son los más simples, porque están relacionados con las reglas gramaticales de escribir código, no con el significado del código. Son fáciles de corregir: solo necesitas encontrar la violación en la escritura. Por otro lado, el intérprete no siempre puede señalar claramente esta violación. Por lo tanto, a veces es necesario colocar el paréntesis olvidado no donde indica el mensaje de error. diff --git a/modules/10-basics/50-syntax-errors/es/data.yml b/modules/10-basics/50-syntax-errors/es/data.yml new file mode 100644 index 00000000..cda0b6d1 --- /dev/null +++ b/modules/10-basics/50-syntax-errors/es/data.yml @@ -0,0 +1,12 @@ +name: Errores de sintaxis +tips: + - > + [Tipos de errores en + Python](https://docs.python.org/3/library/exceptions.html#exception-hierarchy) +definitions: + - name: Error de sintaxis + description: violación de las reglas gramaticales del lenguaje de programación. + - name: SyntaxError (error de análisis) + description: >- + tipo de errores en Python que ocurren cuando hay errores de sintaxis en el + código. diff --git a/modules/10-basics/50-syntax-errors/ru/EXERCISE.md b/modules/10-basics/50-syntax-errors/ru/EXERCISE.md new file mode 100644 index 00000000..ce6357ee --- /dev/null +++ b/modules/10-basics/50-syntax-errors/ru/EXERCISE.md @@ -0,0 +1,6 @@ + +Это задание не связано с уроком напрямую. Но будет полезным потренироваться с выводом на экран. + +Выведите на экран: + +
What Is Dead May Never Die
diff --git a/modules/10-basics/50-syntax-errors/ru/README.md b/modules/10-basics/50-syntax-errors/ru/README.md new file mode 100644 index 00000000..e2fb9ea1 --- /dev/null +++ b/modules/10-basics/50-syntax-errors/ru/README.md @@ -0,0 +1,24 @@ + +Если программа на Python написана синтаксически некорректно, то интерпретатор выводит на экран соответствующее сообщение. Также он указывает на файл и строчку, где произошла ошибка. + +**Синтаксическая ошибка** возникает в том случае, когда код записали с нарушением грамматических правил. В естественных языках грамматика важна, но текст с ошибками обычно можно понять и прочитать. В программировании все строго. Мельчайшее нарушение — и программа даже не запустится. Примером может быть забытая `;`, неправильно расставленные скобки и другие детали. + +Вот пример кода с синтаксической ошибкой: + +```python +print('Hodor) +``` + +https://replit.com/@hexlet/python-basics-syntax-errors + +Если запустить код выше, то мы увидим следующее сообщение: + +```bash +$ python index.py +File "index.py", line 1 + print('Hodor) + ^ +SyntaxError: EOL while scanning string literal +``` + +С одной стороны, ошибки синтаксиса — самые простые, потому что они связаны с грамматическими правилами написания кода, а не со смыслом кода. Их легко исправить: нужно лишь найти нарушение в записи. С другой стороны, интерпретатор не всегда может четко указать на это нарушение. Поэтому бывает, что забытую скобку нужно поставить не туда, куда указывает сообщение об ошибке. diff --git a/modules/10-basics/50-syntax-errors/ru/data.yml b/modules/10-basics/50-syntax-errors/ru/data.yml new file mode 100644 index 00000000..0aa4f4fa --- /dev/null +++ b/modules/10-basics/50-syntax-errors/ru/data.yml @@ -0,0 +1,10 @@ +name: Синтаксические ошибки +tips: + - > + [Виды ошибок в + Python](https://docs.python.org/3/library/exceptions.html#exception-hierarchy) +definitions: + - name: Синтаксическая ошибка + description: нарушение грамматических правил языка программирования. + - name: SyntaxError (ошибка парсинга) + description: тип ошибок в Python, возникающих при наличии синтаксических ошибок в коде. diff --git a/modules/20-arithmetics/20-basic/en/EXERCISE.md b/modules/20-arithmetics/20-basic/en/EXERCISE.md new file mode 100644 index 00000000..a75e3dd9 --- /dev/null +++ b/modules/20-arithmetics/20-basic/en/EXERCISE.md @@ -0,0 +1,2 @@ + +Print the result of dividing `81` by `9`. diff --git a/modules/20-arithmetics/20-basic/en/README.md b/modules/20-arithmetics/20-basic/en/README.md new file mode 100644 index 00000000..22007c6e --- /dev/null +++ b/modules/20-arithmetics/20-basic/en/README.md @@ -0,0 +1,47 @@ +At the most basic level, computers only use numbers. Even in high-level language applications, there are many numbers and operations with them. But knowing basic arithmetic is enough for now, and that's where we'll start. + +For example, to add two numbers in math, we write: `3 + 4`. The same goes for programming. Here's a program that adds up two numbers: + +```python +3 + 4 +``` + +Arithmetic in programming is virtually the same as in school arithmetic. + +The code `3 + 4` will make the interpreter add the numbers and find the result. This program will work, but it makes no sense. In fact, we're not really giving the interpreter a command, we're just saying “oi, what's three plus four?” In real life, you need to do more than just tell the interpreter about the mathematical expression on its own. + +For example, if you're creating an online store, you can't just ask the interpreter to calculate the cost of items in the shopping cart. You have to ask it to calculate the cost **И** show the price to the buyer. + +We need to ask the interpreter to calculate `3 + 4` **AND** give it an order to do something with the result. For example, print it: + +```python +# First, the amount is calculated, +# it's then passed to the print function +print(3 + 4) +``` + +After launching, the result will appear on the screen: + +
+7
+
+ +In addition to addition, the following operations are available: + +* `-` — subtraction +* `*` — multiplication +* `**` — exponentiation (e.g. 2 to the power of 4, 2^4) +* `/` — division +* `//` — [integer division](https://en.wikipedia.org/wiki/Euclidean_division) +* `%` — [modulus operation](https://en.wikipedia.org/wiki/Euclidean_division) + +Now let's print the result of division and then the result of exponentiation: + +```python +print(8 / 2) # => 4.0 (Dividing two numbers produces the float data type) +print(3 ** 2) # => 9 +``` + +Sometimes, for convenience, we'll show in the result of running lines of code in the comments like this: `=> RESULT`. For example, `# => 4`. + +The first instruction will display `4` (because 8 / 2 equals 4), and the second instruction will display 9 (because 32 equals 9). diff --git a/modules/20-arithmetics/20-basic/en/data.yml b/modules/20-arithmetics/20-basic/en/data.yml new file mode 100644 index 00000000..642adca9 --- /dev/null +++ b/modules/20-arithmetics/20-basic/en/data.yml @@ -0,0 +1,7 @@ +name: Arithmetic operations +tips: + - > + Always indent arithmetic operators with spaces between the numbers + (operands) – it's good form when programming. Therefore, in our examples, we + have `print(3 + 4)` rather than `print(3+4)`. + - Division by zero generates an error. diff --git a/modules/20-arithmetics/20-basic/es/EXERCISE.md b/modules/20-arithmetics/20-basic/es/EXERCISE.md new file mode 100644 index 00000000..0c7a40b6 --- /dev/null +++ b/modules/20-arithmetics/20-basic/es/EXERCISE.md @@ -0,0 +1,2 @@ + +Muestra en pantalla el resultado de dividir el número `81` entre `9`. diff --git a/modules/20-arithmetics/20-basic/es/README.md b/modules/20-arithmetics/20-basic/es/README.md new file mode 100644 index 00000000..01f41607 --- /dev/null +++ b/modules/20-arithmetics/20-basic/es/README.md @@ -0,0 +1,49 @@ +A nivel básico, las computadoras operan solo con números. Incluso en aplicaciones de alto nivel, hay muchos números y operaciones dentro de ellas. Pero para empezar, es suficiente conocer la aritmética básica, y eso es lo que haremos. + +Por ejemplo, en matemáticas, escribimos la suma de dos números como: `3 + 4`. En programación, es lo mismo. Aquí hay un programa que suma dos números: + +```python +3 + 4 +``` + +La aritmética en programación es prácticamente igual a la aritmética escolar. + +La línea de código `3 + 4` hace que el intérprete sume los números y obtenga el resultado. Este programa funcionará, pero no tiene sentido. Básicamente, no le estamos dando una instrucción al intérprete, simplemente le estamos diciendo: "mira, esta es la suma de tres y cuatro". En un trabajo real, no es suficiente informar al intérprete sobre una expresión matemática. + +Por ejemplo, si estás creando una tienda en línea, no es suficiente pedirle al intérprete que calcule el costo de los productos en el carrito. Necesitas pedirle que calcule el costo **Y** mostrarle el precio al comprador. + +Necesitamos pedirle al intérprete que sume `3 + 4` **Y** además darle una instrucción para hacer algo con el resultado. Por ejemplo, mostrarlo en la pantalla: + +```python +# Primero se calcula la suma, +# luego, se pasa a la función de impresión +print(3 + 4) +``` + +Después de ejecutarlo, aparecerá el resultado en la pantalla: + +
+7
+
+ +Además de la suma, están disponibles las siguientes operaciones: + +* `-` — resta +* `*` — multiplicación +* `**` — exponente +* `/` — división +* `//` — [división entera](https://es.wikipedia.org/wiki/División_euclídea) +* `%` — [resto de la división](https://es.wikipedia.org/wiki/División_euclídea) + +Ahora vamos a mostrar en pantalla el resultado de una división y luego el resultado de elevar un número a una potencia: + +```python +print(8 / 2) # => 4.0 (Al dividir dos números, el tipo de dato resultante es float) +print(3 ** 2) # => 9 +``` + +https://replit.com/@hexlet/python-basics-arithmetics-basics + +A veces, para mayor comodidad, mostraremos el resultado de ejecutar líneas de código de esta manera en los comentarios: `=> RESULTADO`. Por ejemplo, `# => 4`. + +La primera instrucción mostrará `4` en la pantalla (porque 8 / 2 es igual a 4), y la segunda instrucción mostrará 9 en la pantalla (porque 32 es igual a 9). diff --git a/modules/20-arithmetics/20-basic/es/data.yml b/modules/20-arithmetics/20-basic/es/data.yml new file mode 100644 index 00000000..07895cf4 --- /dev/null +++ b/modules/20-arithmetics/20-basic/es/data.yml @@ -0,0 +1,15 @@ +name: Operaciones aritméticas +tips: + - > + Siempre deja espacios entre los operadores aritméticos y los números + (operandos). Esto es una buena práctica de programación. Por lo tanto, en + nuestros ejemplos es `print(3 + 4)`, no `print(3+4)`. + - La división por cero genera un error. + - | + [División entera](https://es.wikipedia.org/wiki/Divisi%C3%B3n_entera) +definitions: + - name: Instrucción + description: > + la unidad más pequeña e independiente de un lenguaje de programación; una + orden o conjunto de órdenes. Un programa generalmente consiste en una + secuencia de instrucciones. diff --git a/modules/20-arithmetics/20-basic/ru/EXERCISE.md b/modules/20-arithmetics/20-basic/ru/EXERCISE.md new file mode 100644 index 00000000..c6e757d6 --- /dev/null +++ b/modules/20-arithmetics/20-basic/ru/EXERCISE.md @@ -0,0 +1,2 @@ + +Выведите на экран результат деления числа `81` на `9`. diff --git a/modules/20-arithmetics/20-basic/ru/README.md b/modules/20-arithmetics/20-basic/ru/README.md new file mode 100644 index 00000000..92944ca2 --- /dev/null +++ b/modules/20-arithmetics/20-basic/ru/README.md @@ -0,0 +1,49 @@ +На базовом уровне компьютеры оперируют только числами. Даже в прикладных программах на высокоуровневых языках внутри много чисел и операций над ними. Но для старта достаточно знать обычную арифметику — с нее и начнем. + +Например, для сложения двух чисел в математике мы пишем: `3 + 4`. В программировании — то же самое. Вот программа, которая складывает два числа: + +```python +3 + 4 +``` + +Арифметика в программировании практически не отличается от школьной арифметики. + +Строчка кода `3 + 4` заставит интерпретатор сложить числа и узнать результат. Эта программа будет работать, но в ней нет смысла. По сути, мы не даем команду интерпретатору, мы просто говорим ему: «смотри, сумма трех и четырех». В реальной работе недостаточно сообщать интерпретатору о математическом выражении. + +Например, если создавать интернет-магазин, недостаточно просить интерпретатор посчитать стоимость товаров в корзине. Нужно просить посчитать стоимость **И** показать цену покупателю. + +Нам нужно попросить интерпретатор сложить `3 + 4` **И** дать команду сделать что-то с результатом. Например, вывести его на экран: + +```python +# Сначала вычисляется сумма, +# затем она передается в функцию печати +print(3 + 4) +``` + +После запуска на экране появится результат: + +
+7
+
+ +Кроме сложения доступны следующие операции: + +* `-` — вычитание +* `*` — умножение +* `**` — возведение в степень +* `/` — деление +* `//` — [целочисленное деление](https://ru.wikipedia.org/wiki/Деление_с_остатком#В_программировании) +* `%` — [остаток от деления](https://ru.wikipedia.org/wiki/Деление_с_остатком) + +Теперь выведем на экран результат деления, а потом результат возведения в степень: + +```python +print(8 / 2) # => 4.0 (При делении двух чисел получается тип данных float) +print(3 ** 2) # => 9 +``` + +https://replit.com/@hexlet/python-basics-arithmetics-basics + +Иногда для удобства мы будем показывать в комментариях результат запуска строчек кода вот так: `=> РЕЗУЛЬТАТ`. Например, `# => 4`. + +Первая инструкция выведет на экран `4` (потому что 8 / 2 равно 4), а вторая инструкция выведет на экран 9 (потому что 32 равно 9). diff --git a/modules/20-arithmetics/20-basic/ru/data.yml b/modules/20-arithmetics/20-basic/ru/data.yml new file mode 100644 index 00000000..48e49419 --- /dev/null +++ b/modules/20-arithmetics/20-basic/ru/data.yml @@ -0,0 +1,14 @@ +name: Арифметические операции +tips: + - > + Всегда отбивайте арифметические операторы пробелами от самих чисел + (операндов) – это хороший стиль программирования. Поэтому в наших примерах + `print(3 + 4)`, а не `print(3+4)`. + - Деление на ноль — порождает ошибку. + - | + [Деление с остатком](https://ru.wikipedia.org/wiki/Деление_с_остатком) +definitions: + - name: Инструкция + description: > + наименьшая автономная часть языка программирования; команда или набор + команд. Программа обычно представляет собой последовательность инструкций. diff --git a/modules/20-arithmetics/25-operator/en/EXERCISE.md b/modules/20-arithmetics/25-operator/en/EXERCISE.md new file mode 100644 index 00000000..be9514aa --- /dev/null +++ b/modules/20-arithmetics/25-operator/en/EXERCISE.md @@ -0,0 +1,2 @@ + +Write a program that calculates the difference between the numbers `6` and `-81` and displays the answer on the screen. diff --git a/modules/20-arithmetics/25-operator/en/README.md b/modules/20-arithmetics/25-operator/en/README.md new file mode 100644 index 00000000..244a72b0 --- /dev/null +++ b/modules/20-arithmetics/25-operator/en/README.md @@ -0,0 +1,18 @@ + +An operation character, such as `+`, is called an **operator**. Operators perform operations on certain values, which are called **operands**. The operators themselves are usually one or more characters. On occasion it can also be a word. Most of the operators are identical to those you'll have seen in math class. + +```python +print(8 + 2) +``` + +In this example `+` — s the operator, and the numbers `8` and `2` — are **operands**. + +When we add up, we have two operands: one to the left of the `+` sign, and one to the right. Operations that require two operands are called **binary**. operations. If at least one operand is omitted, e.g., `3 +`, the program will end with a syntax error. + +Operations can be more than just binary, they can also be unary (one operand), and ternary (three operands). Moreover, operators may look the same but denote different operations. The symbols `+` and `-` are not only used as operators. When it comes to negative numbers, the minus sign becomes part of the number: + +```python +print(-3) # => -3 +``` + +Above is an example of applying a unary operation to the number `3`. The minus operator before the three tells the interpreter to take the number `3` and find the opposite, i.e., `-3`. This can be confusing because `-3` is both a number in itself and an operator with an operand. But this is the structure programming languages have. diff --git a/modules/20-arithmetics/25-operator/en/data.yml b/modules/20-arithmetics/25-operator/en/data.yml new file mode 100644 index 00000000..98ca9dc6 --- /dev/null +++ b/modules/20-arithmetics/25-operator/en/data.yml @@ -0,0 +1,22 @@ +name: Operators +tips: + - >- + Always space out arithmetic operators from your operands - this is good + programming style. +definitions: + - name: Arithmetic operation + description: “addition, subtraction, multiplication, and division.” + - name: Operator + description: >- + “a special symbol that creates an operation. For example, `+` is for + addition.” + - name: Operand + description: >- + “an object that participates in an operation. E.g., in `3 * 6`, 3 and 6 + are operands.” + - name: Unary Operation + description: >- + “a single operand operation. For example, `-3' is a unary operation to get + the opposite of three.” + - name: Binary Operation + description: “an operation with two operands. For example, `3 + 9'.” diff --git a/modules/20-arithmetics/25-operator/es/EXERCISE.md b/modules/20-arithmetics/25-operator/es/EXERCISE.md new file mode 100644 index 00000000..ad7f1423 --- /dev/null +++ b/modules/20-arithmetics/25-operator/es/EXERCISE.md @@ -0,0 +1,2 @@ + +Escribe un programa que calcule la diferencia entre los números `6` y `-81` y muestre la respuesta en pantalla. diff --git a/modules/20-arithmetics/25-operator/es/README.md b/modules/20-arithmetics/25-operator/es/README.md new file mode 100644 index 00000000..f5edd1f1 --- /dev/null +++ b/modules/20-arithmetics/25-operator/es/README.md @@ -0,0 +1,18 @@ + +Un **operador** es un símbolo de operación, como `+`. Los operadores realizan operaciones en función de valores específicos, llamados **operandos**. Los operadores en sí suelen ser uno o varios caracteres, aunque en ocasiones pueden ser también una palabra. La gran mayoría de los operadores corresponden a operaciones matemáticas. + +```python +print(8 + 2) +``` + +En este ejemplo, `+` es el operador y los números `8` y `2` son los **operandos**. + +Cuando sumamos, tenemos dos operandos: uno a la izquierda y otro a la derecha del signo `+`. Las operaciones que requieren dos operandos se llaman **binarias**. Si falta al menos un operando, por ejemplo, `3 +`, el programa dará un error de sintaxis. + +Las operaciones no sólo pueden ser binarias; también pueden ser unarias, con un solo operando, o ternarias, con tres operandos. Además, los operadores pueden tener la misma apariencia pero representar operaciones diferentes. Los símbolos `+` y `-` no solo se utilizan como operadores. Cuando se trata de números negativos, el signo menos forma parte del número: + +```python +print(-3) # => -3 +``` + +En el ejemplo anterior, se aplica una operación unaria al número `3`. El operador menos antes del tres le indica al intérprete que tome el número `3` y encuentre su opuesto, es decir, `-3`. Esto puede resultar confuso, ya que `-3` es tanto un número en sí mismo como un operador con un operando. Sin embargo, esta es la estructura que tienen los lenguajes de programación. diff --git a/modules/20-arithmetics/25-operator/es/data.yml b/modules/20-arithmetics/25-operator/es/data.yml new file mode 100644 index 00000000..ed22d4fe --- /dev/null +++ b/modules/20-arithmetics/25-operator/es/data.yml @@ -0,0 +1,22 @@ +name: Operadores +tips: + - >- + Siempre deja espacios entre los operadores aritméticos y sus operandos, esto + es una buena práctica de programación. +definitions: + - name: Operación aritmética + description: suma, resta, multiplicación y división. + - name: Operador + description: >- + un símbolo especial que crea una operación. Por ejemplo, `+` crea una + operación de suma. + - name: Operando + description: >- + un objeto que participa en una operación. En `3 * 6`, los números 3 y 6 + son operandos. + - name: Operación unaria + description: >- + una operación con un solo operando. Por ejemplo, `-3` es una operación + unaria para obtener el número opuesto al número tres. + - name: Operación binaria + description: una operación con dos operandos. Por ejemplo, `3 + 9`. diff --git a/modules/20-arithmetics/25-operator/ru/EXERCISE.md b/modules/20-arithmetics/25-operator/ru/EXERCISE.md new file mode 100644 index 00000000..06cfd474 --- /dev/null +++ b/modules/20-arithmetics/25-operator/ru/EXERCISE.md @@ -0,0 +1,2 @@ + +Напишите программу, которая посчитает разность между числами `6` и `-81` и выведет ответ на экран. diff --git a/modules/20-arithmetics/25-operator/ru/README.md b/modules/20-arithmetics/25-operator/ru/README.md new file mode 100644 index 00000000..859aff7c --- /dev/null +++ b/modules/20-arithmetics/25-operator/ru/README.md @@ -0,0 +1,20 @@ + +Знак операции, такой как `+`, называют **оператором**. Операторы выполняют операции над определенными значениями, которые называются **операндами**. Сами операторы — это обычно один или несколько символов. Реже — слово. Подавляющее большинство операторов соответствуют математическим операциям. + +```python +print(8 + 2) +``` + +https://replit.com/@hexlet/python-basics-arithmetics-operators + +В этом примере `+` — это оператор, а числа `8` и `2` — это **операнды**. + +Когда мы складываем, у нас есть два операнда: один слева, другой справа от знака `+`. Операции, которые требуют наличия двух операндов, называются **бинарными**. Если пропустить хотя бы один операнд, например, `3 +`, то программа завершится с синтаксической ошибкой. + +Операции бывают не только бинарными, но и унарными — с одним операндом, и тернарными — с тремя операндами. Причем операторы могут выглядеть одинаково, но обозначать разные операции. Символы `+` и `-` используются не только как операторы. Когда речь идет про отрицательные числа, то знак минуса становится частью числа: + +```python +print(-3) # => -3 +``` + +Выше пример применения унарной операции к числу `3`. Оператор минус перед тройкой говорит интерпретатору взять число `3` и найти противоположное, то есть `-3`. Это может сбить с толку, потому что `-3` — это одновременно и число само по себе, и оператор с операндом. Но у языков программирования такая структура. diff --git a/modules/20-arithmetics/25-operator/ru/data.yml b/modules/20-arithmetics/25-operator/ru/data.yml new file mode 100644 index 00000000..7377dc8e --- /dev/null +++ b/modules/20-arithmetics/25-operator/ru/data.yml @@ -0,0 +1,20 @@ +name: Операторы +tips: + - >- + Всегда отбивайте арифметические операторы пробелами от своих операндов – это + хороший стиль программирования. +definitions: + - name: Арифметическая операция + description: сложение, вычитание, умножение и деление. + - name: Оператор + description: >- + специальный символ, создающий операцию. Например, `+` создает операцию + сложения. + - name: Операнд + description: 'объект, который участвует в операции. `3 * 6`: здесь 3 и 6 — операнды.' + - name: Унарная операция + description: >- + операция с одним операндом. Например, `-3` — унарная операция для + получения числа, противоположного числу три. + - name: Бинарная операция + description: операция с двумя операндами. Например, `3 + 9`. diff --git a/modules/20-arithmetics/27-commutativity/en/EXERCISE.md b/modules/20-arithmetics/27-commutativity/en/EXERCISE.md new file mode 100644 index 00000000..659ea74a --- /dev/null +++ b/modules/20-arithmetics/27-commutativity/en/EXERCISE.md @@ -0,0 +1,2 @@ + +Write a program that calculates and displays sequentially (one value per line) the values of the following mathematical expressions: "3 to the power of 5" and "-8 divided by -4". diff --git a/modules/20-arithmetics/27-commutativity/en/README.md b/modules/20-arithmetics/27-commutativity/en/README.md new file mode 100644 index 00000000..7bcc6974 --- /dev/null +++ b/modules/20-arithmetics/27-commutativity/en/README.md @@ -0,0 +1,3 @@ +"An operation will not change if the operands are moved” is one of the basic laws of arithmetic, also called **the commutative law**. A binary operation is considered commutative if you get the same result even if you swap the operands. In this case, addition is a commutative operation: `3 + 2 = 2 + 3'. + +But subtraction is not a commutative operation: `2 - 3 ≠ 3 - 2'. In programming, this law applies just like it does in arithmetic. Moreover, most of the operations we encounter in real life are not commutative. Here's the takeaway: always pay attention to the order of things you work with. diff --git a/modules/20-arithmetics/27-commutativity/en/data.yml b/modules/20-arithmetics/27-commutativity/en/data.yml new file mode 100644 index 00000000..a4d0f0a4 --- /dev/null +++ b/modules/20-arithmetics/27-commutativity/en/data.yml @@ -0,0 +1,8 @@ +name: Commutative operation +tips: [] +definitions: + - name: Commutativity + description: > + the property of an operation where changing the order of operands does not + affect the result. For example, addition is a commutative operation: + changing the order of the numbers we are adding doesn't change the result. diff --git a/modules/20-arithmetics/27-commutativity/es/EXERCISE.md b/modules/20-arithmetics/27-commutativity/es/EXERCISE.md new file mode 100644 index 00000000..3295034e --- /dev/null +++ b/modules/20-arithmetics/27-commutativity/es/EXERCISE.md @@ -0,0 +1,2 @@ + +Escriba un programa que calcule y muestre en pantalla, de forma secuencial (un valor por línea), los resultados de las siguientes expresiones matemáticas: "3 elevado a la 5" y "-8 dividido por -4". diff --git a/modules/20-arithmetics/27-commutativity/es/README.md b/modules/20-arithmetics/27-commutativity/es/README.md new file mode 100644 index 00000000..1951a5da --- /dev/null +++ b/modules/20-arithmetics/27-commutativity/es/README.md @@ -0,0 +1,3 @@ +"La suma no cambia al cambiar el orden de los sumandos" es una de las leyes básicas de la aritmética, también conocida como **ley conmutativa**. Una operación binaria se considera conmutativa si se obtiene el mismo resultado al intercambiar los operandos. En este caso, la suma es una operación conmutativa: `3 + 2 = 2 + 3`. + +Sin embargo, la resta no es una operación conmutativa: `2 - 3 ≠ 3 - 2`. En programación, esta ley funciona de la misma manera que en aritmética. Además, la mayoría de las operaciones con las que nos encontramos en la vida real no son conmutativas. Por lo tanto, siempre preste atención al orden con el que estás trabajando. diff --git a/modules/20-arithmetics/27-commutativity/es/data.yml b/modules/20-arithmetics/27-commutativity/es/data.yml new file mode 100644 index 00000000..7e31eaf0 --- /dev/null +++ b/modules/20-arithmetics/27-commutativity/es/data.yml @@ -0,0 +1,11 @@ +name: Operación conmutativa +tips: + - > + [Más información sobre la + conmutatividad](https://es.wikipedia.org/wiki/Conmutatividad) +definitions: + - name: Conmutatividad + description: > + propiedad de una operación en la que el cambio de orden de los operandos + no afecta al resultado. Por ejemplo, la suma es una operación conmutativa: + la suma no cambia al cambiar el orden de los sumandos. diff --git a/modules/20-arithmetics/27-commutativity/ru/EXERCISE.md b/modules/20-arithmetics/27-commutativity/ru/EXERCISE.md new file mode 100644 index 00000000..2daa5549 --- /dev/null +++ b/modules/20-arithmetics/27-commutativity/ru/EXERCISE.md @@ -0,0 +1,2 @@ + +Напишите программу, которая считает и выводит на экран последовательно (по одному значению в каждой строчке) значения следующих математических выражений: «3 в степени 5» и «-8 разделить на -4». diff --git a/modules/20-arithmetics/27-commutativity/ru/README.md b/modules/20-arithmetics/27-commutativity/ru/README.md new file mode 100644 index 00000000..9d67fc8d --- /dev/null +++ b/modules/20-arithmetics/27-commutativity/ru/README.md @@ -0,0 +1,3 @@ +«От перемены мест слагаемых сумма не меняется» — это один из базовых законов арифметики, который также называется **коммутативным законом**. Бинарная операция считается коммутативной, если вы получаете тот же самый результат, поменяв местами операнды. В этом случае сложение — это коммутативная операция: `3 + 2 = 2 + 3`. + +Но вычитание — это не коммутативная операция: `2 - 3 ≠ 3 - 2`. В программировании этот закон работает точно так же, как в арифметике. Более того, большинство операций, с которыми мы сталкиваемся в реальной жизни, не являются коммутативными. Отсюда вывод: всегда обращайте внимание на порядок того, с чем работаете. diff --git a/modules/20-arithmetics/27-commutativity/ru/data.yml b/modules/20-arithmetics/27-commutativity/ru/data.yml new file mode 100644 index 00000000..ba4caf0b --- /dev/null +++ b/modules/20-arithmetics/27-commutativity/ru/data.yml @@ -0,0 +1,11 @@ +name: Коммутативная операция +tips: + - > + [Подробнее про + коммутативность](https://ru.wikipedia.org/wiki/Коммутативность) +definitions: + - name: Коммутативность + description: > + свойство операции, когда изменение порядка операндов не влияет на + результат. Например, сложение — коммутативная операция: от перемены мест + слагаемых сумма не меняется. diff --git a/modules/20-arithmetics/30-composition/en/EXERCISE.md b/modules/20-arithmetics/30-composition/en/EXERCISE.md new file mode 100644 index 00000000..be1ff967 --- /dev/null +++ b/modules/20-arithmetics/30-composition/en/EXERCISE.md @@ -0,0 +1,8 @@ + +Write a program that calculates and prints the value of this expression: + +``` +8 / 2 + 5 - -3 / 2 +``` + +Don't calculate anything manually, your program should do all the calculations on its own. diff --git a/modules/20-arithmetics/30-composition/en/README.md b/modules/20-arithmetics/30-composition/en/README.md new file mode 100644 index 00000000..b129bdb8 --- /dev/null +++ b/modules/20-arithmetics/30-composition/en/README.md @@ -0,0 +1,13 @@ +Let's look at an example: + +```python +print(2 * 4 * 5 * 10) +``` + +The operations can be combined with each other to calculate increasingly complex compound expressions. To give you an idea of how calculations are done inside the interpreter, let's look at an example: `2 * 4 * 5 * 10`. + +1. First, we calculate `2 * 4` and get the expression `8 * 5 * 10` +2. Then `8 * 5`. The result is `40 * 10` +3. Then, we get the last multiplication, which gives us `400` + +Operations may contain different operators, which raises the question of their priority. diff --git a/modules/20-arithmetics/30-composition/en/data.yml b/modules/20-arithmetics/30-composition/en/data.yml new file mode 100644 index 00000000..c424b9f5 --- /dev/null +++ b/modules/20-arithmetics/30-composition/en/data.yml @@ -0,0 +1,2 @@ +name: Composition of operations +tips: [] diff --git a/modules/20-arithmetics/30-composition/es/EXERCISE.md b/modules/20-arithmetics/30-composition/es/EXERCISE.md new file mode 100644 index 00000000..d4075f3e --- /dev/null +++ b/modules/20-arithmetics/30-composition/es/EXERCISE.md @@ -0,0 +1,8 @@ + +Implementa un programa que calcule y muestre en pantalla el valor de la expresión: + +``` +8 / 2 + 5 - -3 / 2 +``` + +No calcules nada por tu cuenta, tu programa debe realizar todos los cálculos por sí mismo. diff --git a/modules/20-arithmetics/30-composition/es/README.md b/modules/20-arithmetics/30-composition/es/README.md new file mode 100644 index 00000000..65b4bfd4 --- /dev/null +++ b/modules/20-arithmetics/30-composition/es/README.md @@ -0,0 +1,15 @@ +Veamos un ejemplo: + +```python +print(2 * 4 * 5 * 10) +``` + +https://replit.com/@hexlet/python-basics-arithmetics-composition + +Las operaciones se pueden combinar entre sí y calcular expresiones compuestas más complejas. Para comprender cómo se realizan los cálculos dentro del intérprete, analicemos el ejemplo: `2 * 4 * 5 * 10`. + +1. Primero se calcula `2 * 4` y se obtiene la expresión `8 * 5 * 10` +2. Luego `8 * 5`. Al final, tenemos `40 * 10` +3. Finalmente, se realiza la última multiplicación y se obtiene el resultado `400` + +Las operaciones pueden contener diferentes operadores, lo que plantea la cuestión de su prioridad. diff --git a/modules/20-arithmetics/30-composition/es/data.yml b/modules/20-arithmetics/30-composition/es/data.yml new file mode 100644 index 00000000..ce79bc8a --- /dev/null +++ b/modules/20-arithmetics/30-composition/es/data.yml @@ -0,0 +1,7 @@ +name: Composición de operaciones +tips: [] +definitions: + - name: Composición + description: > + método de combinar varias operaciones simples en una sola operación + compleja. diff --git a/modules/20-arithmetics/30-composition/ru/EXERCISE.md b/modules/20-arithmetics/30-composition/ru/EXERCISE.md new file mode 100644 index 00000000..a12d8c8a --- /dev/null +++ b/modules/20-arithmetics/30-composition/ru/EXERCISE.md @@ -0,0 +1,8 @@ + +Реализуйте программу, которая вычисляет и выводит на экран значение выражения: + +``` +8 / 2 + 5 - -3 / 2 +``` + +Не вычисляйте ничего самостоятельно, ваша программа должна производить все вычисления сама. diff --git a/modules/20-arithmetics/30-composition/ru/README.md b/modules/20-arithmetics/30-composition/ru/README.md new file mode 100644 index 00000000..0c85baaa --- /dev/null +++ b/modules/20-arithmetics/30-composition/ru/README.md @@ -0,0 +1,15 @@ +Рассмотрим пример: + +```python +print(2 * 4 * 5 * 10) +``` + +https://replit.com/@hexlet/python-basics-arithmetics-composition + +Операции можно соединять друг с другом и вычислять все более сложные составные выражения. Чтобы представить, как происходят вычисления внутри интерпретатора, разберем пример: `2 * 4 * 5 * 10`. + +1. Сначала вычисляется `2 * 4` и получается выражение `8 * 5 * 10` +2. Затем `8 * 5`. В итоге имеем `40 * 10` +3. В итоге происходит последнее умножение, и получается результат `400` + +Операции могут содержать разные операторы, из-за чего появляется вопрос об их приоритете. diff --git a/modules/20-arithmetics/30-composition/ru/data.yml b/modules/20-arithmetics/30-composition/ru/data.yml new file mode 100644 index 00000000..3dda1ff2 --- /dev/null +++ b/modules/20-arithmetics/30-composition/ru/data.yml @@ -0,0 +1,6 @@ +name: Композиция операций +tips: [] +definitions: + - name: Композиция + description: | + метод объединения нескольких простых операций в одну сложную. diff --git a/modules/20-arithmetics/40-priority/en/EXERCISE.md b/modules/20-arithmetics/40-priority/en/EXERCISE.md new file mode 100644 index 00000000..ef9c3cce --- /dev/null +++ b/modules/20-arithmetics/40-priority/en/EXERCISE.md @@ -0,0 +1,4 @@ + +The calculation is given `70 * 3 + 4 / 8 + 2`. + +Place parentheses so that both additions (`3 + 4`) и (`8 + 2`) were calculated in the first place. Print the result on the screen. diff --git a/modules/20-arithmetics/40-priority/en/README.md b/modules/20-arithmetics/40-priority/en/README.md new file mode 100644 index 00000000..5f47ed6c --- /dev/null +++ b/modules/20-arithmetics/40-priority/en/README.md @@ -0,0 +1,28 @@ +Let us imagine that we need to calculate such an expression: `2 + 2 * 2`. That's exactly what we'll write down: + +```python +print(2 + 2 * 2) # => 6 +``` + +In school mathematics there is a concept of "operation priority". The priority determines in what order the operations should be performed. Multiplication and division have a higher priority than addition and subtraction, and the priority of exponentiation is higher than all other arithmetic operations. For example: `2 ** 3 * 2` will be calculated in `16`. + +But often the calculations must take place in an order different from the standard priority. Then the priority must be set with parentheses. This was also the case at school, for example: `(2 + 2) * 2`. Brackets can be placed around any operation. They can fit into each other as many times as you like. Here are examples: + +```python +print(3 ** (4 - 2)) # => 9 +print(7 * 3 + (4 / 2) - (8 + (2 - 1))) # => 14 +``` + +The main thing is to observe pairing - to close brackets in the correct order. This is often the cause of errors not only for beginners, but for experienced programmers as well. For convenience, put the opening and closing parentheses at once, and then write the inner part. The editor on our site (and most other code editors) do this automatically: you write `(`, and the editor immediately adds `)`. This also applies to other paired characters, such as quotation marks. We'll talk about them in future lessons. + +Sometimes an expression is hard to perceive visually. Then you can place brackets without affecting the priority: + +```python +# Was +print(8 / 2 + 5 - -3 / 2) # => 10.5 + +# Became +print(((8 / 2) + 5) - (-3 / 2)) # => 10.5 +``` + +The important thing to remember is that code is written for people. People will read the code and machines will only execute it. For machines the code is correct or incorrect. There is no "more" understandable or "less" understandable code for them. diff --git a/modules/20-arithmetics/40-priority/en/data.yml b/modules/20-arithmetics/40-priority/en/data.yml new file mode 100644 index 00000000..4cb52f94 --- /dev/null +++ b/modules/20-arithmetics/40-priority/en/data.yml @@ -0,0 +1,2 @@ +name: Priority +tips: [] diff --git a/modules/20-arithmetics/40-priority/es/EXERCISE.md b/modules/20-arithmetics/40-priority/es/EXERCISE.md new file mode 100644 index 00000000..8a16be6e --- /dev/null +++ b/modules/20-arithmetics/40-priority/es/EXERCISE.md @@ -0,0 +1,4 @@ + +Dada la expresión `70 * 3 + 4 / 8 + 2`. + +Coloca paréntesis de manera que ambas sumas (`3 + 4`) y (`8 + 2`) se calculen primero. Imprime el resultado en pantalla. diff --git a/modules/20-arithmetics/40-priority/es/README.md b/modules/20-arithmetics/40-priority/es/README.md new file mode 100644 index 00000000..d5885c65 --- /dev/null +++ b/modules/20-arithmetics/40-priority/es/README.md @@ -0,0 +1,30 @@ +Supongamos que necesitamos calcular la siguiente expresión: `2 + 2 * 2`. Así es como se escribe: + +```python +print(2 + 2 * 2) # => 6 +``` + +En las matemáticas escolares, existe el concepto de "prioridad de operación". La prioridad determina el orden en el que se deben realizar las operaciones. La multiplicación y la división tienen mayor prioridad que la suma y la resta, y la potenciación tiene la mayor prioridad de todas las operaciones aritméticas. Por ejemplo: `2 ** 3 * 2` se calculará como `16`. + +Sin embargo, a menudo los cálculos deben realizarse en un orden diferente al de la prioridad estándar. En ese caso, se deben utilizar paréntesis para establecer la prioridad. Así se hacía en la escuela, por ejemplo: `(2 + 2) * 2`. Los paréntesis se pueden colocar alrededor de cualquier operación y pueden anidarse tantas veces como sea necesario. Aquí tienes algunos ejemplos: + +```python +print(3 ** (4 - 2)) # => 9 +print(7 * 3 + (4 / 2) - (8 + (2 - 1))) # => 14 +``` + +Lo más importante es asegurarse de que los paréntesis estén correctamente emparejados. Esto, a menudo, es la causa de errores no sólo para principiantes, sino también para programadores experimentados. Para mayor comodidad, coloca el paréntesis de apertura y cierre de inmediato, y luego escribe la parte interna. El editor en nuestro sitio web (y la mayoría de los otros editores de código) lo hacen automáticamente: escribes `(` y el editor agrega automáticamente `)`. Esto también se aplica a otros caracteres emparejados, como comillas. Hablaremos de ellos en futuras lecciones. + +A veces, una expresión puede ser difícil de entender visualmente. En ese caso, se pueden colocar paréntesis sin afectar la prioridad: + +```python +# Antes +print(8 / 2 + 5 - -3 / 2) # => 10.5 + +# Después +print(((8 / 2) + 5) - (-3 / 2)) # => 10.5 +``` + +https://replit.com/@hexlet/python-basics-arithmetics-priority + +Es importante recordar que el código se escribe para ser entendido por personas. Las personas leerán el código y las máquinas solamente lo ejecutarán. Para las máquinas, el código es correcto o incorrecto. No hay código "más" o "menos" comprensible para ellas. diff --git a/modules/20-arithmetics/40-priority/es/data.yml b/modules/20-arithmetics/40-priority/es/data.yml new file mode 100644 index 00000000..420df456 --- /dev/null +++ b/modules/20-arithmetics/40-priority/es/data.yml @@ -0,0 +1,7 @@ +name: Prioridad +tips: [] +definitions: + - name: Expresión + description: > + una secuencia de acciones sobre datos que conduce a algún resultado que se + puede utilizar. diff --git a/modules/20-arithmetics/40-priority/ru/EXERCISE.md b/modules/20-arithmetics/40-priority/ru/EXERCISE.md new file mode 100644 index 00000000..65a9b8e3 --- /dev/null +++ b/modules/20-arithmetics/40-priority/ru/EXERCISE.md @@ -0,0 +1,4 @@ + +Дано вычисление `70 * 3 + 4 / 8 + 2`. + +Расставьте скобки так, чтобы оба сложения (`3 + 4`) и (`8 + 2`) высчитывались в первую очередь. Выведите на экран результат. diff --git a/modules/20-arithmetics/40-priority/ru/README.md b/modules/20-arithmetics/40-priority/ru/README.md new file mode 100644 index 00000000..6311a04a --- /dev/null +++ b/modules/20-arithmetics/40-priority/ru/README.md @@ -0,0 +1,30 @@ +Представим, что нужно вычислить такое выражение: `2 + 2 * 2`. Именно так и запишем: + +```python +print(2 + 2 * 2) # => 6 +``` + +В школьной математике есть понятие «приоритет операции». Приоритет определяет, в какой последовательности должны выполняться операции. Умножение и деление имеют больший приоритет, чем сложение и вычитание, а приоритет возведения в степень выше всех остальных арифметических операций. Например: `2 ** 3 * 2` вычислится в `16`. + +Но нередко вычисления должны происходить в порядке, отличном от стандартного приоритета. Тогда приоритет нужно задавать круглыми скобками. Так было и в школе, например: `(2 + 2) * 2`. Скобки можно ставить вокруг любой операции. Они могут вкладываться друг в друга сколько угодно раз. Вот примеры: + +```python +print(3 ** (4 - 2)) # => 9 +print(7 * 3 + (4 / 2) - (8 + (2 - 1))) # => 14 +``` + +Главное при этом соблюдать парность — закрывать скобки в правильном порядке. Это часто становится причиной ошибок не только у новичков, но и у опытных программистов. Для удобства ставьте сразу открывающую и закрывающую скобку, а потом пишите внутреннюю часть. Редактор на нашем сайте (и большинство других редакторов кода) делают это автоматически: вы пишете `(`, а редактор сразу добавляет `)`. Это касается и других парных символов, например, кавычек. О них поговорим в будущих уроках. + +Иногда выражение сложно воспринимать визуально. Тогда можно расставить скобки, не повлияв на приоритет: + +```python +# Было +print(8 / 2 + 5 - -3 / 2) # => 10.5 + +# Стало +print(((8 / 2) + 5) - (-3 / 2)) # => 10.5 +``` + +https://replit.com/@hexlet/python-basics-arithmetics-priority + +Важно запомнить: код пишется для людей. Код будут читать люди, а машины будут только исполнять его. Для машин код — корректный или некорректный. Для них нет «более» понятного или «менее» понятного кода. diff --git a/modules/20-arithmetics/40-priority/ru/data.yml b/modules/20-arithmetics/40-priority/ru/data.yml new file mode 100644 index 00000000..0a42eac2 --- /dev/null +++ b/modules/20-arithmetics/40-priority/ru/data.yml @@ -0,0 +1,7 @@ +name: Приоритет +tips: [] +definitions: + - name: Выражение + description: > + последовательность действий над данными, приводящая к каком-то результату, + который можно использовать. diff --git a/modules/20-arithmetics/43-float/en/EXERCISE.md b/modules/20-arithmetics/43-float/en/EXERCISE.md new file mode 100644 index 00000000..f886aa95 --- /dev/null +++ b/modules/20-arithmetics/43-float/en/EXERCISE.md @@ -0,0 +1,2 @@ + +Calculate and display the product of two numbers: *0.39* and *0.22* diff --git a/modules/20-arithmetics/43-float/en/README.md b/modules/20-arithmetics/43-float/en/README.md new file mode 100644 index 00000000..f34fad8d --- /dev/null +++ b/modules/20-arithmetics/43-float/en/README.md @@ -0,0 +1,12 @@ + +In mathematics there are different kinds of numbers, for example, natural numbers are integers from one and up, or rational numbers are numbers with a point, such as 0.5. From the point of view of computers, there is a chasm between these types of numbers. Try answering the simple question of how much would *0.2 + 0.1*? Now let's see what Python has to say about it: + +```python +0.2 + 0.1 # 0.30000000000000004 +``` + +The operation of adding two rational numbers suddenly results in an inaccurate calculation. The same result will be given by other programming languages. Such behavior is due to limitations of computing power. The memory capacity, unlike numbers, is finite (an infinite number of numbers requires an infinite amount of memory to store them). + +Rational numbers are not lined up in a continuous chain, between *0.1* и *0.2* an infinite set of numbers. Accordingly, a serious problem arises, but how to store rational numbers? This is an interesting question in itself. There are many articles on the Internet devoted to organizing memory in such cases. Moreover, there is a standard which describes how to do this correctly, and an overwhelming number of languages rely on it. + +For us, as developers, it is important to understand that operations with floating numbers are inaccurate (this accuracy can be adjusted), which means that when solving problems involving such numbers, it is necessary to resort to special tricks that allow to achieve the necessary accuracy. diff --git a/modules/20-arithmetics/43-float/en/data.yml b/modules/20-arithmetics/43-float/en/data.yml new file mode 100644 index 00000000..f2d19b25 --- /dev/null +++ b/modules/20-arithmetics/43-float/en/data.yml @@ -0,0 +1,5 @@ +name: Floating point numbers +tips: + - > + [What you need to know about floating point + arithmetic](https://www.validlab.com/goldberg/paper.pdf) diff --git a/modules/20-arithmetics/43-float/es/EXERCISE.md b/modules/20-arithmetics/43-float/es/EXERCISE.md new file mode 100644 index 00000000..d7059da9 --- /dev/null +++ b/modules/20-arithmetics/43-float/es/EXERCISE.md @@ -0,0 +1,2 @@ + +Calcula y muestra en pantalla el producto (multiplicación) de dos números: *0.39* y *0.22* diff --git a/modules/20-arithmetics/43-float/es/README.md b/modules/20-arithmetics/43-float/es/README.md new file mode 100644 index 00000000..be1dabde --- /dev/null +++ b/modules/20-arithmetics/43-float/es/README.md @@ -0,0 +1,12 @@ + +En matemáticas existen diferentes tipos de números, por ejemplo, los números naturales son enteros mayores o iguales a uno, o los números racionales son números con decimales, como 0.5. Desde el punto de vista de los dispositivos informáticos, hay una brecha entre estos tipos de números. Intenta responder a la siguiente pregunta, ¿cuánto es *0.2 + 0.1*? Y ahora veamos qué dice Python al respecto: + +```python +0.2 + 0.1 # 0.30000000000000004 +``` + +La operación de suma de dos números racionales resultó en un cálculo inexacto del resultado. Otros lenguajes de programación también darán el mismo resultado. Este comportamiento se debe a las limitaciones de la capacidad de cálculo. A diferencia de los números, la cantidad de memoria es finita (un número infinito de números requiere una cantidad infinita de memoria para almacenarlos). + +Los números racionales no están dispuestos en una secuencia continua, entre *0.1* y *0.2* hay un conjunto infinito de números. Por lo tanto, surge un problema importante: ¿cómo almacenar números racionales? Esta es una pregunta interesante en sí misma. En Internet hay muchos artículos dedicados a la organización de la memoria en estos casos. Además, existe un estándar que describe cómo hacerlo correctamente, y la mayoría de los lenguajes se basan en él. + +Para nosotros, como desarrolladores, es importante entender que las operaciones con números de punto flotante no son precisas (se puede ajustar esta precisión), por lo que al resolver problemas relacionados con este tipo de números, es necesario recurrir a trucos especiales que permitan lograr la precisión necesaria. diff --git a/modules/20-arithmetics/43-float/es/data.yml b/modules/20-arithmetics/43-float/es/data.yml new file mode 100644 index 00000000..13f72965 --- /dev/null +++ b/modules/20-arithmetics/43-float/es/data.yml @@ -0,0 +1,9 @@ +name: Números de punto flotante +tips: + - > + [Qué debes saber sobre los números o constantes de punto + flotante](https://academia-lab.com/enciclopedia/aritmetica-de-punto-flotante/) +definitions: + - name: Número racional + description: | + número que se puede representar como una fracción común. diff --git a/modules/20-arithmetics/43-float/ru/EXERCISE.md b/modules/20-arithmetics/43-float/ru/EXERCISE.md new file mode 100644 index 00000000..6b472cb1 --- /dev/null +++ b/modules/20-arithmetics/43-float/ru/EXERCISE.md @@ -0,0 +1,2 @@ + +Вычислите и выведите на экран произведение двух чисел: *0.39* и *0.22* diff --git a/modules/20-arithmetics/43-float/ru/README.md b/modules/20-arithmetics/43-float/ru/README.md new file mode 100644 index 00000000..bb0520c8 --- /dev/null +++ b/modules/20-arithmetics/43-float/ru/README.md @@ -0,0 +1,12 @@ + +В математике существуют разные виды чисел, например, натуральные - это целые числа от одного и больше, или рациональные - это числа с точкой, например 0.5. С точки зрения устройства компьютеров, между этими видами чисел пропасть. Попробуйте ответить на простой вопрос, сколько будет *0.2 + 0.1*? А теперь посмотрим, что на это скажет Python: + +```python +0.2 + 0.1 # 0.30000000000000004 +``` + +Операция сложения двух рациональных чисел внезапно привела к неточному вычислению результата. Тот же самый результат выдадут и другие языки программирования. Такое поведение обуславливается ограничениями вычислительных мощностей. Объём памяти, в отличие от чисел, конечен (бесконечное количество чисел требует бесконечного количества памяти для своего хранения). + +Рациональные числа не выстроены в непрерывную цепочку, между *0.1* и *0.2* бесконечное множество чисел. Соответственно возникает серьезная проблема, а как хранить рациональные числа? Это интересный вопрос сам по себе. В интернете множество статей, посвященных организации памяти в таких случаях. Более того, существует стандарт, в котором описано, как это делать правильно, и подавляющее число языков на него опирается. + +Для нас, как для разработчиков, важно понимать, что операции с плавающими числами неточны (эту точность можно регулировать), а значит при решении задач, связанных с подобными числами, необходимо прибегать к специальным трюкам, которые позволяют добиться необходимой точности. diff --git a/modules/20-arithmetics/43-float/ru/data.yml b/modules/20-arithmetics/43-float/ru/data.yml new file mode 100644 index 00000000..841c2922 --- /dev/null +++ b/modules/20-arithmetics/43-float/ru/data.yml @@ -0,0 +1,9 @@ +name: Числа с плавающей точкой +tips: + - > + [Что нужно знать про арифметику с плавающей + запятой](https://habr.com/ru/articles/112953/) +definitions: + - name: Рациональное число + description: | + число, которое можно представить в виде обыкновенной дроби. diff --git a/modules/20-arithmetics/45-linting/en/EXERCISE.md b/modules/20-arithmetics/45-linting/en/EXERCISE.md new file mode 100644 index 00000000..7aae0203 --- /dev/null +++ b/modules/20-arithmetics/45-linting/en/EXERCISE.md @@ -0,0 +1,2 @@ + +Print the result of the following calculation: "the difference between five squared and the product of three and seven". Write the code so that each operator is separated from the operands by spaces. diff --git a/modules/20-arithmetics/45-linting/en/README.md b/modules/20-arithmetics/45-linting/en/README.md new file mode 100644 index 00000000..889d4c0c --- /dev/null +++ b/modules/20-arithmetics/45-linting/en/README.md @@ -0,0 +1,17 @@ +We have already learned how to write simple programs, so we can talk a little bit about how to write them correctly. + +The code needs to be written in a certain way so that it is understandable and easy to maintain. There are special sets of rules that describe different aspects of writing code - they are called **coding standards**. The standard in Python is one - [PEP8](https://peps.python.org/pep-0008/). It answers practically all the questions about how to design this or that part of the code. This document has all the rules you need to follow. We advise newcomers to get in the habit of looking at the PEP8 standard and writing code according to it. + +Today you don't need to remember all the rules from the standard because there are special programs that check the code automatically and report violations. Such programs are called **linters**. They check the code for standards compliance. In Python there are quite a few of them, and the most popular one is — [flake8](https://flake8.pycqa.org/en/latest/). + +Take a look at an example: + +```python +result = 1+ 3 +``` + +Linter will swear for breaking the rule: _E225 missing whitespace around operator_. By standard, the `+` operator must always be separated by spaces from the operands. + +Above we saw the rule [E225](https://www.flake8rules.com/rules/E225.html) — is one of a large number of rules. Other rules describe indents, names, brackets, mathematical operations, line lengths, and a host of other aspects. Each individual rule seems unimportant and shallow, but together they form the basis of good code. A list of all the flake8 rules is available [on a documentation page](https://www.flake8rules.com/). + +You are already familiar with the linter because the Hexlet platform uses it to check your code in hands-on assignments. Soon you will start using it outside of Hexlet as well, when you implement training projects. You'll set up the linter, and it will check your code already in real development and tell you about irregularities. diff --git a/modules/20-arithmetics/45-linting/en/data.yml b/modules/20-arithmetics/45-linting/en/data.yml new file mode 100644 index 00000000..d14182b1 --- /dev/null +++ b/modules/20-arithmetics/45-linting/en/data.yml @@ -0,0 +1,2 @@ +name: Linter +tips: [] diff --git a/modules/20-arithmetics/45-linting/es/EXERCISE.md b/modules/20-arithmetics/45-linting/es/EXERCISE.md new file mode 100644 index 00000000..51a81eca --- /dev/null +++ b/modules/20-arithmetics/45-linting/es/EXERCISE.md @@ -0,0 +1,2 @@ + +Imprime en pantalla el resultado de la siguiente operación: "la diferencia entre cinco al cuadrado y el producto de tres por siete". Escribe el código de manera que cada operador esté separado de los operandos por espacios. diff --git a/modules/20-arithmetics/45-linting/es/README.md b/modules/20-arithmetics/45-linting/es/README.md new file mode 100644 index 00000000..1185651d --- /dev/null +++ b/modules/20-arithmetics/45-linting/es/README.md @@ -0,0 +1,17 @@ +Ya hemos aprendido a escribir programas simples, por lo que ahora podemos hablar un poco sobre cómo escribirlos correctamente. + +El código debe ser formateado de una manera específica para que sea comprensible y fácil de mantener en el tiempo. Existen conjuntos de reglas especiales que describen varios aspectos de la escritura de código, llamadas **convenciones de codificación**. En Python, hay una convención estándar: [PEP8](https://peps.python.org/pep-0008/). Este documento estándar responde prácticamente todas las preguntas sobre cómo formatear una parte específica del código. Este documento contiene todas las reglas que se deben seguir. Recomendamos a los principiantes que se acostumbren a consultar el estándar PEP8 y escribir cualquier código siguiendo sus pautas. + +Hoy en día no es necesario recordar todas las reglas de la convención estándar, ya que existen programas especiales que verifican automáticamente el código y señalan las violaciones. Estos programas se llaman **linters**. Verifican el código para asegurarse del cumplimiento de los estándares. En Python, hay muchos linters, y el más popular de ellos es [flake8](https://flake8.pycqa.org/en/latest/). + +Echemos un vistazo a un ejemplo: + +```python +result = 1+ 3 +``` + +El linter mostrará un error por violar la regla: *E225 missing whitespace around operator*. Según el estándar, el operador `+` siempre debe estar separado por espacios de los operandos. + +En el ejemplo anterior, vimos la regla [E225](https://pep8.readthedocs.io/en/release-1.7.x/intro.html#error-codes), que es apenas una sola de la larga lista de reglas. Otras reglas describen la indentación, los nombres, los paréntesis, las operaciones matemáticas, la longitud de las líneas y muchos otros aspectos. Cada regla individual puede parecer insignificante y pequeña, pero juntas forman la base de un buen código. La lista completa de reglas de flake8 está disponible en [esta documentación](https://flake8.pycqa.org/en/latest/user/error-codes.html). + +Ya estás familiarizado con el linter, ya que la plataforma de Hexlet verifica tu código utilizando uno. Pronto comenzarás a usarlo fuera de Hexlet, cuando implementes proyectos educativos. Configurarás el linter y verificará el código en tiempo real, informándote sobre las violaciones. diff --git a/modules/20-arithmetics/45-linting/es/data.yml b/modules/20-arithmetics/45-linting/es/data.yml new file mode 100644 index 00000000..f1e3ebf2 --- /dev/null +++ b/modules/20-arithmetics/45-linting/es/data.yml @@ -0,0 +1,6 @@ +name: Linter +tips: + - | + [PEP8](https://peps.python.org/pep-0008/) + - | + [flake8](https://flake8.pycqa.org/en/latest/) diff --git a/modules/20-arithmetics/45-linting/ru/EXERCISE.md b/modules/20-arithmetics/45-linting/ru/EXERCISE.md new file mode 100644 index 00000000..5ed000b2 --- /dev/null +++ b/modules/20-arithmetics/45-linting/ru/EXERCISE.md @@ -0,0 +1,2 @@ + +Выведите на экран результат следующего вычисления: «разница между пятью в квадрате и произведением трёх и семи». Напишите код так, чтобы каждый оператор отделялся от операндов пробелами. diff --git a/modules/20-arithmetics/45-linting/ru/README.md b/modules/20-arithmetics/45-linting/ru/README.md new file mode 100644 index 00000000..4d492e44 --- /dev/null +++ b/modules/20-arithmetics/45-linting/ru/README.md @@ -0,0 +1,17 @@ +Мы уже научились писать простые программы, и поэтому можно немного поговорить о том, как писать их правильно. + +Код нужно оформлять определенным образом, чтобы он был понятным и простым в поддержке. Существуют специальные наборы правил, которые описывают различные аспекты написания кода — их называют **стандартами кодирования**. В Python стандарт один — [PEP8](https://peps.python.org/pep-0008/). Он отвечает практически на все вопросы о том, как оформлять ту или иную часть кода. Этот документ содержит все правила, которых нужно придерживаться. Новичкам мы советуем завести привычку заглядывать в стандарт PEP8 и писать код по нему. + +Сегодня не нужно помнить все правила из стандарта, потому что существуют специальные программы, которые проверяют код автоматически и сообщают о нарушениях. Такие программы называются **линтерами**. Они проверяют код на соответствие стандартам. В Python их достаточно много, и наиболее популярный из них — [flake8](https://flake8.pycqa.org/en/latest/). + +Взгляните на пример: + +```python +result = 1+ 3 +``` + +Линтер будет ругаться на нарушение правила: *E225 missing whitespace around operator*. По стандарту, оператор `+` всегда должен отделяться пробелами от операндов. + +Выше мы увидели правило [E225](https://pep8.readthedocs.io/en/release-1.7.x/intro.html#error-codes) — это одно из большого количества правил. Другие правила описывают отступы, названия, скобки, математические операции, длину строчек и множество иных аспектов. Каждое отдельное правило кажется неважным и мелким, но вместе они составляют основу хорошего кода. Список всех правил flake8 доступен [в этой документации](https://flake8.pycqa.org/en/latest/user/error-codes.html). + +Вы уже знакомы с линтером, потому что в практических заданиях платформа Хекслета проверяет ваш код с помощью него. Скоро вы начнете использовать его и за пределами Хекслета, когда будете реализовывать учебные проекты. Вы настроите линтер, и он будет проверять код уже в реальной разработке и сообщать вам о нарушениях. diff --git a/modules/20-arithmetics/45-linting/ru/data.yml b/modules/20-arithmetics/45-linting/ru/data.yml new file mode 100644 index 00000000..fd136b9a --- /dev/null +++ b/modules/20-arithmetics/45-linting/ru/data.yml @@ -0,0 +1,6 @@ +name: Линтер +tips: + - | + [PEP8](https://peps.python.org/pep-0008/) + - | + [flake8](https://flake8.pycqa.org/en/latest/) diff --git a/modules/25-strings/10-quotes/en/EXERCISE.md b/modules/25-strings/10-quotes/en/EXERCISE.md new file mode 100644 index 00000000..425e1904 --- /dev/null +++ b/modules/25-strings/10-quotes/en/EXERCISE.md @@ -0,0 +1,12 @@ + +Write a program that prints: + +``` +"Khal Drogo's favorite word is "athjahakar"" +``` + +The program should display this exact phrase on the screen. Note the quotes at the beginning and the end of the phrase: + +
+"Khal Drogo's favorite word is "athjahakar""
+
diff --git a/modules/25-strings/10-quotes/en/README.md b/modules/25-strings/10-quotes/en/README.md new file mode 100644 index 00000000..c9fd34ea --- /dev/null +++ b/modules/25-strings/10-quotes/en/README.md @@ -0,0 +1,71 @@ + +In this lesson, we'll learn what a string is and what role quotation marks play in code. + +The definition of a string is quite simple; it's a set of characters. Let us imagine that we have these entries: + +```python +'Hello' +'Goodbye' +'G' +' ' +'' +``` + +Which of these are strings? In fact, all five of them are: + +* С `'Hello'` and `'Goodbye'` everything is obvious, we've already worked with similar constructions and called them strings +* `'G'` and `' '` — are also strings, but they only have one character each +* `''` — is an empty string, so it has zero characters + +We consider anything inside quotation marks a string; even if it's just a space, a single character, or no characters at all. + +Above we wrote the strings in single quotes, but this is not the only way. You can also use double quotes: + +```python +print("Dracarys!") +``` + +Now imagine you want to type the string _Dragon's mother_. The apostrophe before the letter **s** — is the same symbol as the single quote. Let's print it: + +```python +print('Dragon's mother') +# SyntaxError: invalid syntax +``` + +This program won't work. From Python's point of view, the line started with a single quote and then ended after the word **dragon**. Next were the characters `s mother` without quotation marks, so it's not a string. And then there was a one line-opening quotation mark that was never closed: ``)`. This code contains a syntax error – you can even tell by the way the code is highlighted. + +To avoid this error, we use double quotes. This version of the program will work correctly: + +```python +print("Dragon's mother") +``` + +Now the interpreter knows that the string started with a double quotation mark and must end with a double quotation mark. And the single quote inside has become the part of the string. + +It works the other way too. If you want to use double quotes inside a string, you should enclose the string in single quotes. And the number of quotation marks inside the string itself doesn't matter. + +Now imagine we want to create this string: + +```python +Dragon's mother said "No" +``` + +It has both single and double quotes. We need to somehow tell the interpreter that the quotation marks are one of the characters inside the string, not the beginning or the end of the string. + +The **escape character** is used for this: `\` — a backslash. If we put `\` in front of a quotation mark (single or double), the interpreter will recognize the quotation mark as an ordinary character inside the string, not the beginning or the end of the string: + +```python +# We escape the quotation marks around No so that the interpreter +# can recognize them as part of the string +print("Dragon's mother said \"No\"") +# => Dragon's mother said "No" +``` + +Note that in the example above we didn't have to escape the single quote ('s) because the string itself was created with double quotes. If the string were written in single quotes, the escape character would be used before the apostrophe, not before the double quotes. + +If you need to put a backlash in the string, this rule still works. Like any other special character, it must be escaped: + +```python +print("\\") +# => \ +``` diff --git a/modules/25-strings/10-quotes/en/data.yml b/modules/25-strings/10-quotes/en/data.yml new file mode 100644 index 00000000..7ce908f5 --- /dev/null +++ b/modules/25-strings/10-quotes/en/data.yml @@ -0,0 +1,2 @@ +name: Quotes +tips: [] diff --git a/modules/25-strings/10-quotes/es/EXERCISE.md b/modules/25-strings/10-quotes/es/EXERCISE.md new file mode 100644 index 00000000..d406383f --- /dev/null +++ b/modules/25-strings/10-quotes/es/EXERCISE.md @@ -0,0 +1,12 @@ + +Escribe un programa que imprima en la pantalla: + +``` +"Khal Drogo's favorite word is "athjahakar"" +``` + +El programa debe imprimir exactamente esa frase. Presta atención a las comillas al principio y al final de la frase: + +
+"Khal Drogo's favorite word is "athjahakar""
+
diff --git a/modules/25-strings/10-quotes/es/README.md b/modules/25-strings/10-quotes/es/README.md new file mode 100644 index 00000000..08f3b5d3 --- /dev/null +++ b/modules/25-strings/10-quotes/es/README.md @@ -0,0 +1,71 @@ + +En esta lección vamos a entender qué es una cadena de texto y qué papel juegan las comillas en el código. + +Definir una cadena de texto es bastante fácil: es un conjunto de caracteres. Imaginemos que tenemos las siguientes instrucciones: + +```python +'Hello' +'Goodbye' +'G' +' ' +'' +``` + +¿Cuáles de estas opciones son cadenas de texto? En realidad, todas las cinco opciones previas son válidas: + +* Con `'Hello'` y `'Goodbye'` es bastante obvio el asunto, ya que previamente hemos trabajado con construcciones similares y las hemos llamado cadenas de texto. +* `'G'` y `' '` también son cadenas de texto; simplemente contienen un solo carácter. +* `''` es una cadena de texto vacía, ya que no contiene ningún carácter. + +Consideramos como cadena de texto todo lo que está dentro de comillas, ya sea si se trata de un espacio, un solo carácter, o incluso, la ausencia de caracteres. + +Hasta ahora hemos estado escribiendo cadenas de texto entre comillas simples, pero esa no es la única forma. También podemos usar comillas dobles: + +```python +print("Dracarys!") +``` + +Ahora, imaginemos que queremos imprimir la frase *La madre de los dragones*. El apóstrofe antes de la letra **s** es un carácter igual que una comilla simple. Intentemos esto: + + ```python +print('Dragon's mother') +# SyntaxError: invalid syntax +``` + +Este programa no funcionará. Desde el punto de vista de Python, la cadena de texto comenzó con una comilla simple y terminó después de la palabra **dragon**. Luego hubo caracteres `s madre` sin comillas, lo que significa que no es una cadena de texto. Y luego hubo una comilla de apertura de cadena que nunca se cerró: `')`. Este código contiene un error de sintaxis, incluso se puede ver por cómo se resalta el código. + +Para evitar este error, usamos comillas dobles. Este programa funcionará correctamente: + +```python +print("Dragon's mother") +``` + +Ahora el intérprete sabe que la cadena de texto comenzó con una comilla doble y también debe terminar con una comilla doble. Y la comilla simple dentro se convirtió en parte de la cadena de texto. + +Lo contrario también es cierto. Si queremos usar comillas dobles dentro de una cadena de texto, debemos hacer la cadena de texto con comillas simples. Y la cantidad de comillas dentro de la cadena de texto no importa. + +Ahora imaginemos que queremos crear la siguiente cadena de texto: + +```python +Dragon's mother said "No" +``` + +En ella hay comillas simples y comillas dobles. Necesitamos indicarle al intérprete de alguna manera que las comillas son uno de los caracteres dentro de la cadena de texto, no el comienzo o el final de la cadena de texto. + +Para esto se utiliza el **carácter de escape**: `\` - barra invertida. Si colocamos `\` antes de una comilla (simple o doble), el intérprete reconocerá la comilla como un carácter normal dentro de la cadena de texto, no como el comienzo o el final de la cadena de texto: + +```python +# Escapamos las comillas alrededor de No para que el intérprete +# las reconozca como parte de la cadena de texto +print("Dragon's mother said \"No\"") +# => Dragon's mother said "No" +``` + +Observa que en el ejemplo anterior no tuvimos que escapar la comilla simple (apóstrofe 's), porque la cadena de texto en sí se creó con comillas dobles. Si la cadena de texto se hubiera creado con comillas simples, entonces el carácter de escape sería necesario antes del apóstrofe, pero no antes de las comillas dobles. + +Si queremos imprimir la barra invertida en sí, se aplica la misma regla. Como cualquier otro carácter especial, debe ser escapado, en el sentido de programación: + +```python +print("\\") +# => \ +``` diff --git a/modules/25-strings/10-quotes/es/data.yml b/modules/25-strings/10-quotes/es/data.yml new file mode 100644 index 00000000..42417e25 --- /dev/null +++ b/modules/25-strings/10-quotes/es/data.yml @@ -0,0 +1,4 @@ +name: Comillas +tips: + - > + [f-strings](https://docs.python.org/3/tutorial/inputoutput.html#fancier-output-formatting) diff --git a/modules/25-strings/10-quotes/ru/EXERCISE.md b/modules/25-strings/10-quotes/ru/EXERCISE.md new file mode 100644 index 00000000..b503a4f6 --- /dev/null +++ b/modules/25-strings/10-quotes/ru/EXERCISE.md @@ -0,0 +1,12 @@ + +Напишите программу, которая выведет на экран: + +``` +"Khal Drogo's favorite word is "athjahakar"" +``` + +Программа должна вывести на экран эту фразу в точности. Обратите внимание на кавычки в начале и в конце фразы: + +
+"Khal Drogo's favorite word is "athjahakar""
+
diff --git a/modules/25-strings/10-quotes/ru/README.md b/modules/25-strings/10-quotes/ru/README.md new file mode 100644 index 00000000..bfd8b17b --- /dev/null +++ b/modules/25-strings/10-quotes/ru/README.md @@ -0,0 +1,71 @@ + +В этом уроке мы разберемся, что такое строка и какую роль в коде играют кавычки. + +Определить строку довольно просто — это некий набор символов. Представим, что у нас есть такие записи: + +```python +'Hello' +'Goodbye' +'G' +' ' +'' +``` + +Какие из этих вариантов — строки? На самом деле, все пять вариантов подходят: + +* С `'Hello'` и `'Goodbye'` все очевидно — мы уже работали с подобными конструкциями и называли их строками +* `'G'` и `' '` — тоже строки, просто в них всего по одному символу +* `''` — это пустая строка, потому в ней ноль символов + +Строкой мы считаем все, что находится внутри кавычек: даже если это пробел, один символ или вообще отсутствие символов. + +Выше мы записывали строки в одинарных кавычках, но это не единственный способ. Можно использовать и двойные: + +```python +print("Dracarys!") +``` + +Теперь представьте, что вы хотите напечатать строчку *Dragon's mother*. Апостроф перед буквой **s** — это такой же символ, как одинарная кавычка. Попробуем: + +```python +print('Dragon's mother') +# SyntaxError: invalid syntax +``` + +Такая программа не будет работать. С точки зрения Python строчка началась с одинарной кавычки, а потом закончилась после слова **dragon**. Дальше были символы `s mother` без кавычек — значит, это не строка. А потом была одна открывающая строку кавычка, которая так и не закрылась: `')`. Этот код содержит синтаксическую ошибку — это видно даже по тому, как подсвечен код. + +Чтобы избежать этой ошибки, мы используем двойные кавычки. Такой вариант программы сработает верно: + +```python +print("Dragon's mother") +``` + +Теперь интерпретатор знает, что строка началась с двойной кавычки и закончиться должна тоже на двойной кавычке. А одинарная кавычка внутри стала частью строки. + +Верно и обратное. Если внутри строки мы хотим использовать двойные кавычки, то саму строку надо делать в одинарных. Причем количество кавычек внутри самой строки неважно. + +Теперь представим, что мы хотим создать такую строку: + +```python +Dragon's mother said "No" +``` + +В ней есть и одинарные, и двойные кавычки. Нам нужно каким-то образом указать интерпретатору, что кавычки — это один из символов внутри строки, а не начало или конец строки. + +Для этого используют **символ экранирования**: `\` — обратный слэш. Если мы поставим `\` перед кавычкой (одинарной или двойной), то интерпретатор распознает кавычку как обычный символ внутри строки, а не начало или конец строки: + +```python +# Экранируем кавычки вокруг No, чтобы интерпретатор +# распознал их как часть строки +print("Dragon's mother said \"No\"") +# => Dragon's mother said "No" +``` + +Обратите внимание, что в примере выше нам не пришлось экранировать одинарную кавычку (апостроф 's), потому что сама строка создана с двойными кавычками. Если бы строка создавалась с одинарными кавычками, то символ экранирования нужен был бы перед апострофом, но не перед двойными кавычками. + +Если нужно вывести сам обратный слеш, то работает такое же правило. Как и любой другой специальный символ, его надо экранировать: + +```python +print("\\") +# => \ +``` diff --git a/modules/25-strings/10-quotes/ru/data.yml b/modules/25-strings/10-quotes/ru/data.yml new file mode 100644 index 00000000..ac6a8a07 --- /dev/null +++ b/modules/25-strings/10-quotes/ru/data.yml @@ -0,0 +1,4 @@ +name: Кавычки +tips: + - > + [f-строки](https://docs.python.org/3/tutorial/inputoutput.html#fancier-output-formatting) diff --git a/modules/25-strings/15-escape-characters/en/EXERCISE.md b/modules/25-strings/15-escape-characters/en/EXERCISE.md new file mode 100644 index 00000000..dce11024 --- /dev/null +++ b/modules/25-strings/15-escape-characters/en/EXERCISE.md @@ -0,0 +1,7 @@ + +Write a program that displays on this the screen: + + - Did Joffrey agree? + - He did. He also said "I love using \n". + +This program should have only one `print()`, but the result on the screen should look exactly like the one shown above. diff --git a/modules/25-strings/15-escape-characters/en/README.md b/modules/25-strings/15-escape-characters/en/README.md new file mode 100644 index 00000000..af7ed363 --- /dev/null +++ b/modules/25-strings/15-escape-characters/en/README.md @@ -0,0 +1,90 @@ + +Here's some dialog we want to show: + +``` +- Are you hungry? +- Aaaarrrgh! +``` + +Let's try to display a string with this text: + +```python +print("- Are you hungry?- Aaaarrrgh!") +# => - Are you hungry?- Aaaarrrgh! +``` + +As you can see, the result was not what we wanted. The lines are arranged one after the other, not one below the other. We need to somehow tell the interpreter to "press Enter" - to start a new line after the question mark. This can be done with the symbol `\n`: + +```python +print("- Are you hungry?\n- Aaaarrrgh!") +# => - Are you hungry? +# => - Aaaarrrgh! +``` + +`\n` — is an example of an **escape sequence**. These sequences are also called control constructions. They can't be displayed in the same way as how they're typed. + +When you type text in Word, you press Enter at the end of a line. The editor puts a special invisible character at the end of the line called LINE FEED (LF). In some editors, you can actually display the invisible characters. Then the text will look something like this: + +``` +- Hey!¶ +- Oh, hey!¶ +- How's it going? +``` + +The device that outputs the corresponding text takes this character into account. For example, the printer drags the paper up one line when it encounters the LF, and the text editor drags all subsequent text below, also by one line. + +There are several dozen such invisible characters, but in programming there are usually only a few. In addition to the line feed, there can also be: + +* tab `\t` — the gap that you get when you press Tab +* carriage return `\r` — only works in Windows + +You can recognize these control constructions in the text by the `\`. symbol. Programmers often use the line feed `\n` to properly format text. For example, if we write this code: + +```python +print("Gregor Clegane\nDunsen\nPolliver\nChiswyck") +``` + +This will appear on the screen: + +``` +Gregor Clegane +Dunsen +Polliver +Chiswyck +``` + +When working with the line feed symbol, consider the following points: + +1. It doesn't matter what comes before or after `\n`: a character or an empty string. The line feed will be detected and executed in any case + +2. A string can contain only `\n` and nothing else: + + ```python + print('Gregor Clegane') # String with text + print("\n") # String with an invisible line feed character + print('Dunsen') # String with text + ``` + + The program will display this on the screen: + + ``` + Gregor Clegane + + + Dunsen + ``` + +3. In the code, the escape sequence `\n` looks like two characters, but from the interpreter's perspective, it's just one special character + +4. If you want to output `\n` as text (two separate printable characters), you can use escaping - adding another `\` at the beginning. The sequence `\\n` will be displayed as the characters `\` and `n`, one after the other. + +```python +print("Joffrey loves using \\n") +# => Joffrey loves using \n +``` + +Windows uses `\r\n` by default to start a new line. This combination works well on Windows, but creates problems when transferring to other systems. For example, when there are Linux users in the development team. + +The point is that the sequence `\r\n` has a different interpretation depending on the chosen encoding, which we is something we'll talk about later. For this reason, it's customary among developers to always use `\n` without `\r`. + + In this case, the line feed is always treated the same and works fine in any system. Remember to configure your editor to use `\n`. diff --git a/modules/25-strings/15-escape-characters/en/data.yml b/modules/25-strings/15-escape-characters/en/data.yml new file mode 100644 index 00000000..a6072aae --- /dev/null +++ b/modules/25-strings/15-escape-characters/en/data.yml @@ -0,0 +1,11 @@ +name: Escape sequences +definitions: + - name: Escape sequence + description: >- + a special combination of characters in text. For example, \n — is a line + feed. +tips: + - >- + Be sure to experiment with printing different strings on the site + [https://replit.com/languages/python3](https://replit.com/languages/python3) + - '[Line feed history](https://en.wikipedia.org/wiki/Newline)' diff --git a/modules/25-strings/15-escape-characters/es/EXERCISE.md b/modules/25-strings/15-escape-characters/es/EXERCISE.md new file mode 100644 index 00000000..da2f2127 --- /dev/null +++ b/modules/25-strings/15-escape-characters/es/EXERCISE.md @@ -0,0 +1,7 @@ + +Escribe un programa que muestre en pantalla: + + - Did Joffrey agree? + - He did. He also said "I love using \n". + +El programa debe utilizar solo una llamada a `print()`, pero el resultado en pantalla debe ser exactamente como se muestra arriba. diff --git a/modules/25-strings/15-escape-characters/es/README.md b/modules/25-strings/15-escape-characters/es/README.md new file mode 100644 index 00000000..81422342 --- /dev/null +++ b/modules/25-strings/15-escape-characters/es/README.md @@ -0,0 +1,90 @@ + +Queremos mostrar el siguiente diálogo: + +``` +- Are you hungry? +- Aaaarrrgh! +``` + +Intentemos imprimir en pantalla una cadena de texto con este contenido: + + ```python +print("- Are you hungry?- Aaaarrrgh!") +# => - Are you hungry?- Aaaarrrgh! +``` + +Como puedes ver, el resultado no es el que esperábamos. Las cadenas de texto se han colocado una al lado de la otra en lugar de una debajo de la otra. Necesitamos decirle al intérprete "presiona Enter" - y que haga un salto de línea después del signo de interrogación. Esto se puede hacer utilizando el carácter `\n`: + +```python +print("- Are you hungry?\n- Aaaarrrgh!") +# => - Are you hungry? +# => - Aaaarrrgh! +``` + +`\n` es un ejemplo de una **secuencia de escape**. Estas secuencias también se conocen como construcciones de control. No se pueden ver en la forma en que se escriben. + +Cuando escribes algún texto en Word, presionas Enter al final de la línea. El editor agrega un carácter especial invisible al final de la línea, que se llama LINE FEED (LF, salto de línea). En algunos editores incluso puedes habilitar la visualización de caracteres invisibles. Entonces el texto se verá más o menos así: + +``` +- ¡Hola!¶ +- ¡Oh, hola!¶ +- ¿Cómo estás? +``` + +El dispositivo que muestra el texto correspondiente tiene en cuenta este carácter. Por ejemplo, una impresora, al encontrar un LF, avanza el papel hacia arriba una línea, y un editor de texto mueve todo el texto siguiente hacia abajo, también una línea. + +Hay varias docenas de estos caracteres invisibles, pero en programación sólo se encuentran algunos. Además del salto de línea, estos caracteres incluyen: + +* tabulación `\t` - la ruptura que se produce al presionar la tecla Tab +* retorno de carro `\r` - solo funciona en Windows + +Puedes reconocer estas construcciones de control en el texto por el carácter `\`. Los programadores a menudo usan el salto de línea `\n` para formatear correctamente el texto. Por ejemplo, escribamos este código: + +```python +print("Gregor Clegane\nDunsen\nPolliver\nChiswyck") +``` + +Entonces se mostrará en pantalla: + +``` +Gregor Clegane +Dunsen +Polliver +Chiswyck +``` + +Al trabajar con el carácter de salto de línea, ten en cuenta los siguientes puntos: + +1. No importa lo que haya antes o después de `\n`: un carácter o una cadena vacía. El salto se detectará y se realizará de todos modos. + +2. Una cadena puede contener solo `\n`: + + ```python + print('Gregor Clegane') # Cadena de texto + print("\n") # Cadena con un carácter de salto de línea invisible + print('Dunsen') # Cadena de texto + ``` + + El programa mostrará en pantalla: + + ``` + Gregor Clegane + + + Dunsen + ``` + +3. En el código, la secuencia `\n` se ve como dos caracteres, pero para el intérprete es un solo carácter especial. + +4. Si deseas mostrar `\n` como texto (dos caracteres separados), puedes usar la técnica de escape: agregar otro `\` al principio. La secuencia `\\n` se mostrará como los caracteres `\` y `n`, que van uno tras otro: + + ```python +print("Joffrey loves using \\n") +# => Joffrey loves using \n +``` + +En Windows, por defecto se utiliza `\r\n` para los saltos de línea. Esta combinación funciona bien solo en Windows, pero causa problemas al transferir a otros sistemas. Por ejemplo, cuando en un equipo de desarrollo hay usuarios de Linux. + +El problema es que la secuencia `\r\n` se interpreta de manera diferente según la codificación seleccionada, de lo cual hablaremos más adelante. Por esta razón, en entornos de desarrollo se recomienda siempre usar `\n` sin `\r`. + +En este caso, el salto de línea siempre se interpreta de la misma manera y funciona perfectamente en cualquier sistema. No olvides configurar tu editor para usar `\n`. diff --git a/modules/25-strings/15-escape-characters/es/data.yml b/modules/25-strings/15-escape-characters/es/data.yml new file mode 100644 index 00000000..141ea1f3 --- /dev/null +++ b/modules/25-strings/15-escape-characters/es/data.yml @@ -0,0 +1,13 @@ +name: Secuencias de escape +definitions: + - name: Secuencia de escape + description: >- + una combinación especial de caracteres en un texto. Por ejemplo, \n es un + salto de línea. +tips: + - >- + Asegúrate de experimentar con la impresión de diferentes cadenas en el sitio + [https://replit.com/languages/python3](https://replit.com/languages/python3) + - >- + [Historia del salto de + línea](https://es.wikipedia.org/wiki/Salto_de_l%C3%ADnea#Historia) diff --git a/modules/25-strings/15-escape-characters/ru/EXERCISE.md b/modules/25-strings/15-escape-characters/ru/EXERCISE.md new file mode 100644 index 00000000..78469f37 --- /dev/null +++ b/modules/25-strings/15-escape-characters/ru/EXERCISE.md @@ -0,0 +1,7 @@ + +Напишите программу, которая выводит на экран: + + - Did Joffrey agree? + - He did. He also said "I love using \n". + +При этом программа использует только один `print()`, но результат на экране должен выглядеть в точности, как показано выше. diff --git a/modules/25-strings/15-escape-characters/ru/README.md b/modules/25-strings/15-escape-characters/ru/README.md new file mode 100644 index 00000000..3b773429 --- /dev/null +++ b/modules/25-strings/15-escape-characters/ru/README.md @@ -0,0 +1,90 @@ + +Мы хотим показать вот такой диалог: + +``` +- Are you hungry? +- Aaaarrrgh! +``` + +Попробуем вывести на экран строку с таким текстом: + +```python +print("- Are you hungry?- Aaaarrrgh!") +# => - Are you hungry?- Aaaarrrgh! +``` + +Как видите, результат получился не такой, как мы хотели. Строки расположились друг за другом, а не одна ниже другой. Нам нужно как-то сказать интерпретатору «нажать на Enter» — сделать перевод строки после вопросительного знака. Это можно сделать с помощью символа `\n`: + +```python +print("- Are you hungry?\n- Aaaarrrgh!") +# => - Are you hungry? +# => - Aaaarrrgh! +``` + +`\n` — это пример **экранированной последовательности** (escape sequence). Такие последовательности еще называют управляющими конструкциями. Их нельзя увидеть в том же виде, в котором их набрали. + +Набирая текст в Word, вы нажимаете на Enter в конце строчки. Редактор при этом ставит в конец строчки специальный невидимый символ, который называется LINE FEED (LF, перевод строчки). В некоторых редакторах можно даже включить отображение невидимых символов. Тогда текст будет выглядеть примерно так: + +``` +- Привет!¶ +- О, привет!¶ +- Как дела? +``` + +Устройство, которое выводит соответствующий текст, учитывает этот символ. Например, принтер при встрече с LF протаскивает бумагу вверх на одну строку, а текстовый редактор переносит весь последующий текст ниже, также на одну строку. + +Существует несколько десятков таких невидимых символов, но в программировании часто встречаются всего несколько. Кроме перевода строки, к таким символам относятся: + +* табуляция `\t` — разрыв, который получается при нажатии на кнопку Tab +* возврат каретки `\r` — работает только в Windows + +Распознать такую управляющую конструкцию в тексте можно по символу `\`. Программисты часто используют перевод строки `\n`, чтобы правильно форматировать текст. Например, напишем такой код: + +```python +print("Gregor Clegane\nDunsen\nPolliver\nChiswyck") +``` + +Тогда на экран выведется: + +``` +Gregor Clegane +Dunsen +Polliver +Chiswyck +``` + +Когда работаете с символом перевода, учитывайте следующие моменты: + +1. Не важно, что стоит перед или после `\n`: символ или пустая строка. Перевод обнаружится и выполнится в любом случае + +2. Строка может содержать только `\n`: + + ```python + print('Gregor Clegane') # Строка с текстом + print("\n") # Строка с невидимым символом перевода строки + print('Dunsen') # Строка с текстом + ``` + + Программа выведет на экран: + + ``` + Gregor Clegane + + + Dunsen + ``` + +3. В коде последовательность `\n` выглядит как два символа, но с точки зрения интерпретатора — это один специальный символ + +4. Если нужно вывести `\n` как текст (два отдельных печатных символа), то можно воспользоваться экранированием — добавить еще один `\` в начале. Последовательность `\\n` отобразится как символы `\` и `n`, которые идут друг за другом: + +```python +print("Joffrey loves using \\n") +# => Joffrey loves using \n +``` + +В Windows для перевода строк по умолчанию используется `\r\n`. Такая комбинация хорошо работает только в Windows, но создает проблемы при переносе в другие системы. Например, когда в команде разработчиков есть пользователи Linux. + +Дело в том, что последовательность `\r\n` имеет разную трактовку в зависимости от выбранной кодировки, о чем мы поговорим позже. По этой причине в среде разработчиков принято всегда использовать `\n` без `\r`. + +В таком случае перевод строки всегда трактуется одинаково и отлично работает в любой системе. Не забудьте настроить ваш редактор на использование `\n`. diff --git a/modules/25-strings/15-escape-characters/ru/data.yml b/modules/25-strings/15-escape-characters/ru/data.yml new file mode 100644 index 00000000..8742fd19 --- /dev/null +++ b/modules/25-strings/15-escape-characters/ru/data.yml @@ -0,0 +1,13 @@ +name: Экранированные последовательности +definitions: + - name: Экранированная последовательность + description: >- + специальная комбинация символов в тексте. Например, \n — это перевод + строки. +tips: + - >- + Обязательно поэкспериментируйте с выводом разных строк на сайте + [https://replit.com/languages/python3](https://replit.com/languages/python3) + - >- + [История перевода + строки](https://ru.wikipedia.org/wiki/Перевод_строки#История) diff --git a/modules/25-strings/20-string-concatenation/en/EXERCISE.md b/modules/25-strings/20-string-concatenation/en/EXERCISE.md new file mode 100644 index 00000000..64a2d3a7 --- /dev/null +++ b/modules/25-strings/20-string-concatenation/en/EXERCISE.md @@ -0,0 +1,8 @@ + +Display + +``` +Winter came for the House of Frey. +``` + +using concatenation. diff --git a/modules/25-strings/20-string-concatenation/en/README.md b/modules/25-strings/20-string-concatenation/en/README.md new file mode 100644 index 00000000..5fcd71f2 --- /dev/null +++ b/modules/25-strings/20-string-concatenation/en/README.md @@ -0,0 +1,30 @@ + +In web development, programs use strings all the time. Everything we see on websites, in one way or another, is presented as text. This text is most often dynamic, i.e., it comes from different parts that are joined together. + +To combine strings, you have to perform **concatenation**: + +```python +# The operator is the same as for adding numbers, +# but here it has a different meaning (semantics) +print('Dragon' + 'stone') # => Dragonstone +``` + +Strings are always concatenated in the order in which the operands are written. The left operand becomes the left part of the string, and the right one becomes the right part. Here are a few more examples: + +```python +print('Kings' + 'wood') # => Kingswood +print('Kings' + 'road') # => Kingsroad +print("King's" + 'Landing') # => King'sLanding +``` + +As you can see, strings can be concatenated even if they're written with different quotes. + +Spaces are a character like any other, so how many spaces you put in a string is how many you get in the final string: + +```python +# Put a space in the left part +print("King's " + 'Landing') # => King's Landing + +# Put a space in the right part +print("King's" + ' Landing') # => King's Landing +``` diff --git a/modules/25-strings/20-string-concatenation/en/data.yml b/modules/25-strings/20-string-concatenation/en/data.yml new file mode 100644 index 00000000..2a780416 --- /dev/null +++ b/modules/25-strings/20-string-concatenation/en/data.yml @@ -0,0 +1,6 @@ +name: Concatenation +definitions: + - name: Concatenation + description: > + the operation of joining two strings. For example, `print("King's " + ' + Landing')` diff --git a/modules/25-strings/20-string-concatenation/es/EXERCISE.md b/modules/25-strings/20-string-concatenation/es/EXERCISE.md new file mode 100644 index 00000000..48b0727f --- /dev/null +++ b/modules/25-strings/20-string-concatenation/es/EXERCISE.md @@ -0,0 +1,8 @@ + +Imprime en pantalla + +```text +Winter came for the House of Frey. +``` + +utilizando la concatenación de palabras. diff --git a/modules/25-strings/20-string-concatenation/es/README.md b/modules/25-strings/20-string-concatenation/es/README.md new file mode 100644 index 00000000..569626b8 --- /dev/null +++ b/modules/25-strings/20-string-concatenation/es/README.md @@ -0,0 +1,32 @@ + +En el desarrollo web, los programas operan constantemente con cadenas de texto. Todo lo que vemos en los sitios web está representado de alguna manera como texto. Este texto, en su mayoría, es dinámico, es decir, se obtiene a partir de diferentes partes que se unen. + +Para unir cadenas de texto, es necesario realizar una **concatenación**: + +```python +# El operador es el mismo que se utiliza para sumar números, +# pero aquí tiene un significado diferente (semántica) +print('Dragon' + 'stone') # => Dragonstone +``` + +La concatenación de cadenas siempre se realiza en el mismo orden en el que se escriben los operandos. El operando izquierdo se convierte en la parte izquierda de la cadena, y el operando derecho en la parte derecha. Aquí hay algunos ejemplos adicionales: + +```python +print('Kings' + 'wood') # => Kingswood +print('Kings' + 'road') # => Kingsroad +print("King's" + 'Landing') # => King'sLanding +``` + +Como puedes ver, puedes concatenar cadenas incluso si se escriben con diferentes tipos de comillas. + +Un espacio en blanco es un carácter igual que los demás, por lo que la cantidad de espacios en blanco que coloques en una cadena será la misma en la cadena resultante: + +```python +# Colocamos un espacio en blanco en la parte izquierda +print("King's " + 'Landing') # => King's Landing + +# Colocamos un espacio en blanco en la parte derecha +print("King's" + ' Landing') # => King's Landing +``` + +https://replit.com/@hexlet/python-basics-string-concatenation diff --git a/modules/25-strings/20-string-concatenation/es/data.yml b/modules/25-strings/20-string-concatenation/es/data.yml new file mode 100644 index 00000000..ab2d92d6 --- /dev/null +++ b/modules/25-strings/20-string-concatenation/es/data.yml @@ -0,0 +1,10 @@ +name: Concatenación +tips: + - > + Si hay una línea `# BEGIN` y `# END` en el editor, el código debe escribirse + entre esas líneas. +definitions: + - name: Concatenación + description: > + operación que une dos cadenas de texto. Por ejemplo, `print("King's " + ' + Landing')` diff --git a/modules/25-strings/20-string-concatenation/ru/EXERCISE.md b/modules/25-strings/20-string-concatenation/ru/EXERCISE.md new file mode 100644 index 00000000..7a956ddc --- /dev/null +++ b/modules/25-strings/20-string-concatenation/ru/EXERCISE.md @@ -0,0 +1,8 @@ + +Выведите на экран + +```text +Winter came for the House of Frey. +``` + +используя конкатенацию слов. diff --git a/modules/25-strings/20-string-concatenation/ru/README.md b/modules/25-strings/20-string-concatenation/ru/README.md new file mode 100644 index 00000000..f7d63f62 --- /dev/null +++ b/modules/25-strings/20-string-concatenation/ru/README.md @@ -0,0 +1,32 @@ + +В веб-разработке программы постоянно оперируют строками. Все, что мы видим на сайтах, так или иначе представлено в виде текста. Этот текст чаще всего динамический — то есть он получается из разных частей, которые соединяются вместе. + +Чтобы соединить строки, нужно выполнить **конкатенацию**: + +```python +# Оператор такой же, как и при сложении чисел, +# но здесь он имеет другой смысл (семантику) +print('Dragon' + 'stone') # => Dragonstone +``` + +Склеивание строк всегда происходит в том же порядке, в котором записаны операнды. Левый операнд становится левой частью строки, а правый — правой. Вот еще несколько примеров: + +```python +print('Kings' + 'wood') # => Kingswood +print('Kings' + 'road') # => Kingsroad +print("King's" + 'Landing') # => King'sLanding +``` + +Как видите, строки можно склеивать, даже если их записали с разными кавычками. + +Пробел — такой же символ, как и другие, поэтому сколько пробелов поставите в строке, столько и получится в итоговой строке: + +```python +# Ставим пробел в левой части +print("King's " + 'Landing') # => King's Landing + +# Ставим пробел в правой части +print("King's" + ' Landing') # => King's Landing +``` + +https://replit.com/@hexlet/python-basics-string-concatenation diff --git a/modules/25-strings/20-string-concatenation/ru/data.yml b/modules/25-strings/20-string-concatenation/ru/data.yml new file mode 100644 index 00000000..76327e9a --- /dev/null +++ b/modules/25-strings/20-string-concatenation/ru/data.yml @@ -0,0 +1,9 @@ +name: Конкатенация +tips: + - > + Если в редакторе есть запись `# BEGIN` и `# END`, то код нужно писать между + этими строчками. +definitions: + - name: Конкатенация + description: | + операция соединения двух строк. Например, `print("King's " + ' Landing')` diff --git a/modules/25-strings/30-encoding/en/EXERCISE.md b/modules/25-strings/30-encoding/en/EXERCISE.md new file mode 100644 index 00000000..0fd577f2 --- /dev/null +++ b/modules/25-strings/30-encoding/en/EXERCISE.md @@ -0,0 +1,14 @@ + +In Python, you can query and display any ASCII character. The function `chr()` is used for this. For example: + +```python +print(chr(63)) +``` + +Symbol no. 63 - the question mark `?`. You can print any character this way. + +Use the [ASCII code table](https://www.cs.cmu.edu/~pattis/15-1XX/common/handouts/ascii.html). In this table, want to know about the decimal code (*dec* or *decimal*) with which the characters are encoded. + +Using the example above and the table, display the following (each on its own line): `~`, `^` and `%`. + +(Of course, you could be sneaky and cheat the tests by just doing `print('~')` etc., but that would be no fun at all :) diff --git a/modules/25-strings/30-encoding/en/README.md b/modules/25-strings/30-encoding/en/README.md new file mode 100644 index 00000000..2429f754 --- /dev/null +++ b/modules/25-strings/30-encoding/en/README.md @@ -0,0 +1,37 @@ + +At the deepest level, computers operate exclusively using the numbers `0` and `1`. This is what's known as [binary code](https://en.wikipedia.org/wiki/Binary_code), and the ones and zeros are called bits, from “binary digit”. + +The numbers from the decimal system that we know and love are encoded using binary numbers: + +- 0 ← 0 +- 1 ← 1 +- 2 ← 10 +- 3 ← 11 +- 4 ← 100 +- 5 ← 101 + +But does it deal with text? Computers don't know about letters, punctuation, or any other text characters. All these symbols are also encoded with numbers. + +We can take the English alphabet and give each letter a number, starting with one: + +- a ← 1 +- b ← 2 +- c ← 3 +- d ← 4 +- ... +- z ← 26 + +This is the essence of **encoding**. + +When they're working, programs use encodings to convert numbers into characters and vice versa. And the program itself has no idea about the meaning of these characters. + +- `hello` → `8` `5` `12` `12` `15` +- `7` `15` `15` `4` → `good` + +These tables that match letters and numbers are called encodings. Besides letters of the alphabet, encoding tables include punctuation marks and other useful characters. You have probably encountered encodings such as [ASCII](https://en.wikipedia.org/wiki/ASCII) and [UTF-8](https://en.wikipedia.org/wiki/UTF-8). + +Different encodings contain different numbers of characters. At first, small tables like ASCII were enough for programmers. But it has only Latin letters, a few simple characters like `%` and `?` and special control characters like line feeds. + +As computers spread further and further, countries needed their own comprehensive tables. This included Cyrillic letters, Chinese and Japanese characters, Arabic script, additional mathematical and typographic symbols, and later on emojis. + +Today, it's usually [Unicode] variants that are used most often [Unicode](https://en.wikipedia.org/wiki/Unicode). It includes characters from almost all the written languages of the world. diff --git a/modules/25-strings/30-encoding/en/data.yml b/modules/25-strings/30-encoding/en/data.yml new file mode 100644 index 00000000..b170905f --- /dev/null +++ b/modules/25-strings/30-encoding/en/data.yml @@ -0,0 +1,7 @@ +name: Encoding +tips: + - | + [What are encodings?](https://guides.hexlet.io/en/encoding/) +definitions: + - name: Encoding + description: a set of characters encoded with numbers to represent text electronically. diff --git a/modules/25-strings/30-encoding/es/EXERCISE.md b/modules/25-strings/30-encoding/es/EXERCISE.md new file mode 100644 index 00000000..d87a357e --- /dev/null +++ b/modules/25-strings/30-encoding/es/EXERCISE.md @@ -0,0 +1,16 @@ + +En Python, puedes "solicitar" y mostrar en pantalla cualquier carácter de la codificación ASCII. Para hacer esto, se utiliza la función `chr()`. Por ejemplo: + +```python +print(chr(63)) +``` + +https://replit.com/@hexlet/python-basics-string-encoding + +Se mostrará en pantalla el carácter con el número 63, que es el signo de interrogación `?`. De esta manera, puedes mostrar cualquier carácter. + +Utiliza la [tabla de códigos ASCII](https://www.cs.cmu.edu/~pattis/15-1XX/common/handouts/ascii.html). En esta tabla, nos interesa el código decimal (*dec* o *decimal*) con el que se codifican los caracteres. + +Utilizando el ejemplo anterior y la tabla, muestra en pantalla (cada uno en su propia línea) `~`, `^` y `%`. + +(Por supuesto, podrías "engañar" a las pruebas y simplemente hacer `print('~')`, etc., pero eso sería muy aburrido :) diff --git a/modules/25-strings/30-encoding/es/README.md b/modules/25-strings/30-encoding/es/README.md new file mode 100644 index 00000000..f0677482 --- /dev/null +++ b/modules/25-strings/30-encoding/es/README.md @@ -0,0 +1,37 @@ + +En su nivel más profundo, una computadora opera exclusivamente con los dígitos `0` y `1`. Esto se conoce como [código binario](https://es.wikipedia.org/wiki/C%C3%B3digo_binario), y los unos y ceros se llaman bits, abreviatura de "binary digit" (dígito binario). + +Los números que estamos acostumbrados a utilizar en el sistema decimal se codifican utilizando números binarios: + +- 0 ← 0 +- 1 ← 1 +- 2 ← 10 +- 3 ← 11 +- 4 ← 100 +- 5 ← 101 + +Pero, ¿qué pasa con el texto? En realidad, la computadora no sabe nada acerca de las letras, signos de puntuación y otros caracteres de texto. Todos estos caracteres también se codifican con números. + +Podemos tomar el alfabeto inglés y asignar un número a cada letra, comenzando desde uno en orden: + +- a ← 1 +- b ← 2 +- c ← 3 +- d ← 4 +- ... +- z ← 26 + +Esto es lo que se conoce como **codificación**. + +Durante el proceso de funcionamiento, los programas utilizan codificaciones para convertir números en caracteres y viceversa. Sin embargo, el programa en sí no tiene conocimiento del significado de estos caracteres. + +- `hello` → `8` `5` `12` `12` `15` +- `7` `15` `15` `4` → `good` + +Estas tablas que relacionan letras y números se llaman tablas de codificación. Además de las letras del alfabeto, las tablas de codificación incluyen signos de puntuación y otros caracteres útiles. Seguramente has encontrado tablas de codificación como [ASCII](https://es.wikipedia.org/wiki/ASCII) o [UTF-8](https://es.wikipedia.org/wiki/UTF-8). + +Las distintas codificaciones contienen diferentes conjuntos de caracteres. Inicialmente, tablas pequeñas como ASCII eran suficientes para la realización de la mayoría de las tareas. Sin embargo, sólo incluían letras latinas, algunos caracteres simples como `%` y `?`, y caracteres de control especiales como el salto de línea. + +Con la proliferación de las computadoras, diferentes países necesitaron elaborar propias tablas más amplias. Esto incluía letras cirílicas, caracteres chinos, árabe, matemáticos y tipográficos adicionales, y más tarde incluso emojis. + +Hoy en día, en la mayoría de los casos se utiliza una de las variantes de [Unicode](https://es.wikipedia.org/wiki/Unicode), que incluye caracteres de casi todos los idiomas escritos del mundo. diff --git a/modules/25-strings/30-encoding/es/data.yml b/modules/25-strings/30-encoding/es/data.yml new file mode 100644 index 00000000..3d858214 --- /dev/null +++ b/modules/25-strings/30-encoding/es/data.yml @@ -0,0 +1,9 @@ +name: Codificación +tips: + - | + [¿Qué son las codificaciones?](https://codica.la/guides/encoding) +definitions: + - name: Codificación + description: >- + conjunto de caracteres codificados con números para representar texto en + formato electrónico. diff --git a/modules/25-strings/30-encoding/ru/EXERCISE.md b/modules/25-strings/30-encoding/ru/EXERCISE.md new file mode 100644 index 00000000..991e7dec --- /dev/null +++ b/modules/25-strings/30-encoding/ru/EXERCISE.md @@ -0,0 +1,16 @@ + +В Python можно «запросить» и вывести на экран любой символ из кодировки ASCII. Для этого используется функция `chr()`. Например: + +```python +print(chr(63)) +``` + +https://replit.com/@hexlet/python-basics-string-encoding + +На экран выведется символ с номером 63 — вопросительный знак `?`. Таким способом можно выводить любой символ. + +Воспользуйтесь [таблицей кодов ASCII](https://www.cs.cmu.edu/~pattis/15-1XX/common/handouts/ascii.html). В этой таблице нас интересует десятичный код (*dec* или *decimal*), которыми кодируются символы. + +Используя пример выше и таблицу, выведите на экран (каждый на своей собственной строке) `~`, `^` и `%`. + +(Конечно, можно «обмануть» тесты и просто сделать `print('~')` и т.д., но так будет совсем неинтересно :) diff --git a/modules/25-strings/30-encoding/ru/README.md b/modules/25-strings/30-encoding/ru/README.md new file mode 100644 index 00000000..d4e48569 --- /dev/null +++ b/modules/25-strings/30-encoding/ru/README.md @@ -0,0 +1,37 @@ + +На самом глубоком уровне компьютер оперирует исключительно цифрами `0` и `1`. Это так называемый [двоичный код](https://ru.wikipedia.org/wiki/Двоичный_код), а единички и нули называются битами, от "binary digit" — «двоичная цифра». + +Обычные, привычные нам числа в десятичной системе исчисления, закодированы с помощью двоичных чисел: + +- 0 ← 0 +- 1 ← 1 +- 2 ← 10 +- 3 ← 11 +- 4 ← 100 +- 5 ← 101 + +Но как быть с текстом? Компьютер на самом деле не знает ничего о буквах, знаках пунктуации и прочих текстовых символах. Все эти символы так же закодированы числами. + +Можно взять английский алфавит и дать каждой букве число, начиная с единицы по порядку: + +- a ← 1 +- b ← 2 +- c ← 3 +- d ← 4 +- ... +- z ← 26 + +В этом заключается суть **кодировок**. + +Во время своей работы, программы используют кодировки для преобразования чисел в символы и наоборот. Причём сама программа не имеет представления о смысле этих символов. + +- `hello` → `8` `5` `12` `12` `15` +- `7` `15` `15` `4` → `good` + +Подобные таблицы, в которых сопоставляются буквы и числа, называются кодировками. Кроме букв алфавита, в таблицы кодировок входят знаки препинания и другие полезные символы. Вы наверняка сталкивались с кодировками, например, [ASCII](https://ru.wikipedia.org/wiki/ASCII) или [UTF-8](https://ru.wikipedia.org/wiki/UTF-8). + +Разные кодировки содержат разное количество символов. Изначально небольших таблиц вроде ASCII было достаточно для большинства задач. Но в ней только латинские буквы, несколько простых символов вроде `%` и `?` и специальные управляющие символы типа перевода строки. + +С распространением компьютеров, разным странам понадобились свои, более широкие таблицы. В том числе для кириллических букв, восточных иероглифов, арабской вязи, дополнительных математических и типографских символов, а впоследствии даже для эмодзи-смайликов. + +Сегодня в большинстве случаев используется один из вариантов [юникода](https://ru.wikipedia.org/wiki/Юникод), включающий в себя знаки почти всех письменных языков мира. diff --git a/modules/25-strings/30-encoding/ru/data.yml b/modules/25-strings/30-encoding/ru/data.yml new file mode 100644 index 00000000..a0ce3ed3 --- /dev/null +++ b/modules/25-strings/30-encoding/ru/data.yml @@ -0,0 +1,9 @@ +name: Кодировка +tips: + - | + [Что такое кодировки?](https://guides.hexlet.io/ru/encoding/) +definitions: + - name: Кодировка + description: >- + набор символов, закодированных с помощью чисел для представления текста в + электронном виде. diff --git a/modules/30-variables/10-definition/en/EXERCISE.md b/modules/30-variables/10-definition/en/EXERCISE.md new file mode 100644 index 00000000..c550f216 --- /dev/null +++ b/modules/30-variables/10-definition/en/EXERCISE.md @@ -0,0 +1,2 @@ + +Create a variable named `motto` with the contents `What Is Dead May Never Die!`. Print its contents. diff --git a/modules/30-variables/10-definition/en/README.md b/modules/30-variables/10-definition/en/README.md new file mode 100644 index 00000000..014ffd39 --- /dev/null +++ b/modules/30-variables/10-definition/en/README.md @@ -0,0 +1,40 @@ + +Imagine that we need to print the phrase _Father!_ on the screen twice. This can be done like so + +```python +print('Father!') +print('Father!') +``` + +In the simplest case, that's what you should do. But if the phrase _Father!_ is used more than twice, or even in different parts of the program, you have to repeat it everywhere; it's a little inconvenient. The problems with this approach will begin when you need to change the phrase, and this happens quite often. We'll have to find all the places this phrase is located and make the required changes lots of times. + +There is one other way to do it. In order not to copy the expression, you just need to create a variable with it. + +```python +# greeting - translates as greeting +greeting = 'Father!' +print(greeting) +print(greeting) +# => Father! +# => Father! +``` + +In the line `greeting = 'Father!'` we take a variable named `greeting` and assign it the value `'Father!'` The variable points to the data that was written to it. In this way, the data can be used repeatedly and not be duplicated constantly. + +Once you've created the variable, you can use it. You put it in the places where we originally had our phrase written out in full. When the code runs, the interpreter reaches the line `print(greeting)`, substitutes the contents of the variable, and then executes the code. + +Any set of valid characters can be used for the variable name, which includes letters of the English alphabet, numbers and the `_` sign. Note that you can't place a digit at the beginning of a name. Variable names are case-sensitive, i.e., the name `hello` and the name `HELLO` are two different names for two different variables. Case is important in Python, never forget it. + +The number of variables you can create is unlimited. Large programs contain tens or hundreds of thousands of variable names. This is what two variables look like inside one program: + +```python +greeting1 = 'Father!' +print(greeting1) +print(greeting1) + +greeting2 = 'Mother!' +print(greeting2) +print(greeting2) +``` + +To make the program easy to read, it's customary among programmers to create variables as close as possible to where they are used. Now we have to figure out how to change them. diff --git a/modules/30-variables/10-definition/en/data.yml b/modules/30-variables/10-definition/en/data.yml new file mode 100644 index 00000000..ade57339 --- /dev/null +++ b/modules/30-variables/10-definition/en/data.yml @@ -0,0 +1,8 @@ +name: What is a variable +tips: + - > + [Naming in + Programming](https://hexlet.io/blog/posts/code-complete-naming-in-programming) +definitions: + - name: Variable + description: a way to save information and name it for later use in code. diff --git a/modules/30-variables/10-definition/es/EXERCISE.md b/modules/30-variables/10-definition/es/EXERCISE.md new file mode 100644 index 00000000..44e85681 --- /dev/null +++ b/modules/30-variables/10-definition/es/EXERCISE.md @@ -0,0 +1,2 @@ + +Crea una variable llamada `motto` con el contenido `What Is Dead May Never Die!`. Imprime el contenido de la variable. diff --git a/modules/30-variables/10-definition/es/README.md b/modules/30-variables/10-definition/es/README.md new file mode 100644 index 00000000..3c585e1a --- /dev/null +++ b/modules/30-variables/10-definition/es/README.md @@ -0,0 +1,42 @@ + +Imagina que necesitamos imprimir en pantalla la frase *¡Father!* dos veces. Podemos resolver esta tarea de la siguiente manera: + + ```python +print('Father!') +print('Father!') +``` + +En el caso más simple, esto funciona bien. Pero si la frase *Father!* se utiliza más de dos veces, y además en diferentes partes del programa, tendríamos que repetirla en todos los lugares, lo cual es incómodo. Los problemas con este enfoque comienzan cuando necesitamos cambiar la frase, lo cual ocurre con bastante frecuencia. Tendríamos que encontrar todos los lugares en donde se usa esta frase y realizar el reemplazo necesario. + +Pero hay otra forma de hacerlo. Para evitar copiar la expresión, simplemente creamos una variable con ella: + +```python +# greeting - se traduce como saludo + greeting = 'Father!' +print(greeting) +print(greeting) +# => Father! +# => Father! +``` + +En la línea `greeting = 'Father!'` tomamos una variable con el nombre `greeting` y le asignamos el valor `'Father!'`. La variable apunta a los datos que hemos almacenado en ella. Gracias a esto, los datos se pueden utilizar múltiples veces sin duplicarlos constantemente. + +Una vez que se ha creado la variable, se puede utilizar. Se inserta en los lugares donde solía estar nuestra frase. Cuando se ejecuta el código, el intérprete llega a la línea `print(greeting)` y reemplaza el contenido de la variable, y luego ejecuta el código. + +Para el nombre de la variable se puede utilizar cualquier conjunto de caracteres válidos, que incluyen letras del alfabeto inglés, números y el guión bajo `_`. Sin embargo, no se puede colocar un número al principio. Los nombres de las variables son sensibles a mayúsculas y minúsculas, es decir, `hola` y `HOLA` son dos nombres diferentes para dos variables diferentes. En Python, la capitulación de letras es importante, nunca lo olvides. + +El número de variables que se pueden crear es ilimitado. Los programas grandes contienen decenas y cientos de miles de nombres de variables. Así es como se ven dos variables dentro de un mismo programa: + + ```python +greeting1 = 'Father!' +print(greeting1) +print(greeting1) + +greeting2 = 'Mother!' +print(greeting2) +print(greeting2) +``` + +https://replit.com/@hexlet/python-basics-variables-definition + +Para que el programa sea fácil de leer, los programadores suelen crear variables lo más cerca posible del lugar donde se utilizan. Ahora necesitamos entender cómo modificarlas. diff --git a/modules/30-variables/10-definition/es/data.yml b/modules/30-variables/10-definition/es/data.yml new file mode 100644 index 00000000..208e762e --- /dev/null +++ b/modules/30-variables/10-definition/es/data.yml @@ -0,0 +1,9 @@ +name: ¿Qué es una variable? +tips: + - | + [Nomenclatura en programación](https://codica.la/blog/naming-in-programming) +definitions: + - name: Variable + description: >- + una forma de almacenar información y darle un nombre para su uso posterior + en el código. diff --git a/modules/30-variables/10-definition/ru/EXERCISE.md b/modules/30-variables/10-definition/ru/EXERCISE.md new file mode 100644 index 00000000..a112dab3 --- /dev/null +++ b/modules/30-variables/10-definition/ru/EXERCISE.md @@ -0,0 +1,2 @@ + +Создайте переменную с именем `motto` и содержимым `What Is Dead May Never Die!`. Распечатайте содержимое переменной. diff --git a/modules/30-variables/10-definition/ru/README.md b/modules/30-variables/10-definition/ru/README.md new file mode 100644 index 00000000..03730ed9 --- /dev/null +++ b/modules/30-variables/10-definition/ru/README.md @@ -0,0 +1,42 @@ + +Представьте, что нам нужно напечатать на экран фразу *Father!* два раза. Эту задачу можно решить так: + +```python +print('Father!') +print('Father!') +``` + +В простейшем случае так и стоит поступить. Но если фраза *Father!* будет использоваться чаще двух раз, да еще и в разных частях программы, то придется ее везде повторять — это неудобно. Проблемы с таким подходом начнутся, когда понадобится изменить фразу, а такое происходит довольно часто. Нам придется найти все места с этой фразой и выполнить необходимую замену. + +А можно поступить по-другому. Чтобы не копировать выражение, достаточно создать с ней переменную: + +```python +# greeting - переводится как приветствие +greeting = 'Father!' +print(greeting) +print(greeting) +# => Father! +# => Father! +``` + +В строчке `greeting = 'Father!'` мы берем переменную с именем `greeting` и присваиваем ей значение `'Father!'`. Переменная указывает на данные, которые в нее записали. Благодаря этому, данные можно использовать многократно и не дублировать их постоянно. + +Когда переменная создана, можно ее использовать. Она подставляется в те места, где раньше стояла наша фраза. Когда код выполняется, интерпретатор доходит до строчки `print(greeting)` и подставляет содержимое переменной, а затем выполняет код. + +Для имени переменной используется любой набор допустимых символов, к которым относятся буквы английского алфавита, цифры и знак `_`. При этом цифру нельзя ставить в начале. Имена переменных регистрозависимы, то есть имя `hello` и имя `HELLO` — это два разных имени для двух разных переменных. Регистр в Python имеет важное значение, никогда не забывайте про него. + +Количество создаваемых переменных неограниченно. Большие программы содержат десятки и сотни тысяч имен переменных. Вот как выглядят две переменные внутри одной программы: + +```python +greeting1 = 'Father!' +print(greeting1) +print(greeting1) + +greeting2 = 'Mother!' +print(greeting2) +print(greeting2) +``` + +https://replit.com/@hexlet/python-basics-variables-definition + +Чтобы программу было удобно читать, среди программистов принято создавать переменные как можно ближе к тому месту, где они используются. Теперь нужно разобраться, как их изменять. diff --git a/modules/30-variables/10-definition/ru/data.yml b/modules/30-variables/10-definition/ru/data.yml new file mode 100644 index 00000000..1bc84fbd --- /dev/null +++ b/modules/30-variables/10-definition/ru/data.yml @@ -0,0 +1,10 @@ +name: Что такое переменная +tips: + - > + [Именование в + программировании](https://ru.hexlet.io/blog/posts/naming-in-programming) +definitions: + - name: Переменная + description: >- + способ сохранить информацию и дать ей имя для последующего использования в + коде. diff --git a/modules/30-variables/12-change/en/EXERCISE.md b/modules/30-variables/12-change/en/EXERCISE.md new file mode 100644 index 00000000..fa87dca3 --- /dev/null +++ b/modules/30-variables/12-change/en/EXERCISE.md @@ -0,0 +1,4 @@ + +In the exercise, a variable is defined with a string inside it. Override the value of this variable and assign it a string in which the characters of the original string are arranged in reverse order. + +Note: in this assignment, you'll have to write code between lines with comments `# BEGIN` and `# END` (we mentioned it before, but this is the first time you've come across this format). diff --git a/modules/30-variables/12-change/en/README.md b/modules/30-variables/12-change/en/README.md new file mode 100644 index 00000000..3ddda403 --- /dev/null +++ b/modules/30-variables/12-change/en/README.md @@ -0,0 +1,17 @@ + +The word “variable” itself suggests that it can be changed. And indeed, the values of variables can change over time within the program. + +For example: + +```python +# greeting +greeting = 'Father!' +print(greeting) # => Father! + +greeting = 'Mother!' +print(greeting) # => Mother! +``` + +The name remained the same, but there were different data inside. Note that variables in Python require no special declaration. Instead, a variable is declared when it is first used in a program. + +Variables are a powerful yet risky thing. You can't be sure right away what'll be inside it - first you have to analyze the code that comes before the variable. This is what developers do during debugging, when they try to figure out why the program doesn't work as intended. diff --git a/modules/30-variables/12-change/en/data.yml b/modules/30-variables/12-change/en/data.yml new file mode 100644 index 00000000..cf9775a8 --- /dev/null +++ b/modules/30-variables/12-change/en/data.yml @@ -0,0 +1,5 @@ +name: Changing variables +tips: [] +definitions: + - name: Variable + description: a way to save information and name it for later use in code. diff --git a/modules/30-variables/12-change/es/EXERCISE.md b/modules/30-variables/12-change/es/EXERCISE.md new file mode 100644 index 00000000..f78c7d6c --- /dev/null +++ b/modules/30-variables/12-change/es/EXERCISE.md @@ -0,0 +1,4 @@ + +En este ejercicio se define una variable que contiene una cadena de texto. Reasigne el valor de esta variable y asígnele una cadena de texto en la que los caracteres de la cadena original estén en orden inverso. + +Tenga en cuenta: en este ejercicio, deberá escribir código entre las líneas de comentarios `# BEGIN` y `# END` (esto se mencionó anteriormente, pero esta es la primera vez que se encuentra con este formato). diff --git a/modules/30-variables/12-change/es/README.md b/modules/30-variables/12-change/es/README.md new file mode 100644 index 00000000..1676d3f7 --- /dev/null +++ b/modules/30-variables/12-change/es/README.md @@ -0,0 +1,19 @@ + +La palabra "variable" en sí misma sugiere que se puede cambiar. Y de hecho, dentro de un programa, los valores de las variables pueden cambiar con el tiempo. + +Por ejemplo: + +```python +# greeting - se traduce como saludo +greeting = 'Father!' +print(greeting) # => Father! + +greeting = 'Mother!' +print(greeting) # => Mother! +``` + +https://replit.com/@hexlet/python-basics-variables-change + +El nombre se mantiene igual, pero los datos internos han cambiado. Es importante destacar que en Python no es necesario declarar explícitamente las variables. En su lugar, una variable se declara cuando se utiliza por primera vez en el programa. + +Las variables son poderosas pero también pueden ser arriesgadas. No se puede afirmar con certeza qué hay dentro de ellas de inmediato; primero es necesario analizar el código que se encuentra antes de la variable. Esto es lo que los desarrolladores hacen durante el proceso de depuración, cuando intentan entender por qué el programa no funciona como se esperaba. diff --git a/modules/30-variables/12-change/es/data.yml b/modules/30-variables/12-change/es/data.yml new file mode 100644 index 00000000..3f30791c --- /dev/null +++ b/modules/30-variables/12-change/es/data.yml @@ -0,0 +1,7 @@ +name: Cambio de variable +tips: [] +definitions: + - name: Variable + description: >- + una forma de almacenar información y darle un nombre para su uso posterior + en el código. diff --git a/modules/30-variables/12-change/ru/EXERCISE.md b/modules/30-variables/12-change/ru/EXERCISE.md new file mode 100644 index 00000000..cd8aa893 --- /dev/null +++ b/modules/30-variables/12-change/ru/EXERCISE.md @@ -0,0 +1,4 @@ + +В упражнении определена переменная, внутри которой содержится строка. Переопределите значение этой переменной и присвойте ей строку, в которой расположите символы первоначальной строки в обратном порядке. + +Обратите внимание: в данном задании вам предстоит писать код между строчками с комментариями `# BEGIN` и `# END` (об этом говорилось ранее, но это первый раз, когда вы встречаетесь с таким форматом). diff --git a/modules/30-variables/12-change/ru/README.md b/modules/30-variables/12-change/ru/README.md new file mode 100644 index 00000000..d0dec8e7 --- /dev/null +++ b/modules/30-variables/12-change/ru/README.md @@ -0,0 +1,19 @@ + +Само слово «переменная» подсказывает, что ее можно менять. И действительно, со временем внутри программы значения переменных могут изменяться. + +Например: + +```python +# greeting - переводится как приветствие +greeting = 'Father!' +print(greeting) # => Father! + +greeting = 'Mother!' +print(greeting) # => Mother! +``` + +https://replit.com/@hexlet/python-basics-variables-change + +Имя осталось тем же, но внутри появились другие данные. Отметим, что переменные в Python не требуют специального объявления. Вместо этого переменная объявляется, когда ее впервые используют в программе. + +Переменные — мощная и в то же время рисковая вещь. Нельзя сразу с уверенностью сказать, что внутри нее записано — сначала надо проанализировать код, который находится перед переменной. Именно этим занимаются разработчики во время отладки, когда пытаются разобраться, почему программа работает не так, как задумано. diff --git a/modules/30-variables/12-change/ru/data.yml b/modules/30-variables/12-change/ru/data.yml new file mode 100644 index 00000000..2e3a7c2a --- /dev/null +++ b/modules/30-variables/12-change/ru/data.yml @@ -0,0 +1,7 @@ +name: Изменение переменной +tips: [] +definitions: + - name: Переменная + description: >- + способ сохранить информацию и дать ей имя для последующего использования в + коде. diff --git a/modules/30-variables/13-variables-naming/en/EXERCISE.md b/modules/30-variables/13-variables-naming/en/EXERCISE.md new file mode 100644 index 00000000..c976c779 --- /dev/null +++ b/modules/30-variables/13-variables-naming/en/EXERCISE.md @@ -0,0 +1,2 @@ + +Create a variable that describes the number of your brothers and assign it the value *2*. Print its contents. Then compare your name with the name used in the teacher's solution. diff --git a/modules/30-variables/13-variables-naming/en/README.md b/modules/30-variables/13-variables-naming/en/README.md new file mode 100644 index 00000000..6434b953 --- /dev/null +++ b/modules/30-variables/13-variables-naming/en/README.md @@ -0,0 +1,23 @@ + +Imagine we've set the following program: + +```python +x = 'Father!' +print(x) +``` + +We've worked with a similar program before, but now it's changed the variable name to `x`. + +The computer doesn't care what we call a variable. Names are only important to people. Programmers usually read other people's code much more often than they write their own. To make it easy for your colleagues to read and analyze your code, you need to name your variables clearly. + +It's important to come up with a clear name that reflects the idea of the variable. It's important to give names that can be understood without context and without examining the surrounding code. + +There is a general rule: Do not use transliteration for names - only English. If you have difficulty with English, use a translator. Over time, by poking around in other people's code, you'll learn how to properly name variables. + +There's a joke among developers that naming variables is one of the hardest things in programming. It's really hard to come up with names. For example, it's difficult to name a variable that stores the _number of unpaid orders from customers in arrears in the previous quarter._ + +Try this task to test yourself: + +> Think of a name for the variable that will store _"the number of the king's siblings"_. +> +> Write it down in a notebook or email it to yourself. Don't put anything in there except the name of the variable. And in a few lessons, we'll come back to this topic. diff --git a/modules/30-variables/13-variables-naming/en/data.yml b/modules/30-variables/13-variables-naming/en/data.yml new file mode 100644 index 00000000..23d23dd2 --- /dev/null +++ b/modules/30-variables/13-variables-naming/en/data.yml @@ -0,0 +1,8 @@ +name: Choosing a variable's name +tips: + - > + [Naming in + Programming](https://hexlet.io/blog/posts/code-complete-naming-in-programming) + - > + [Naming Mistakes to Avoid in Programming + I](https://hexlet.io/blog/posts/perfect-code-naming-mistakes-to-avoid-in-programming-i) diff --git a/modules/30-variables/13-variables-naming/es/EXERCISE.md b/modules/30-variables/13-variables-naming/es/EXERCISE.md new file mode 100644 index 00000000..6928c461 --- /dev/null +++ b/modules/30-variables/13-variables-naming/es/EXERCISE.md @@ -0,0 +1,2 @@ + +Crea una variable que describa la cantidad de hermanos que tienes y asígnale el valor *2*. Imprime el contenido de la variable. Luego, compara tu nombre con el nombre que se utiliza en la solución del profesor. diff --git a/modules/30-variables/13-variables-naming/es/README.md b/modules/30-variables/13-variables-naming/es/README.md new file mode 100644 index 00000000..b3a17a16 --- /dev/null +++ b/modules/30-variables/13-variables-naming/es/README.md @@ -0,0 +1,23 @@ + +Imagina que hemos creado el siguiente programa: + +```python +x = 'Father!' +print(x) +``` + +Ya hemos trabajado previamente con un programa similar, pero ahora hemos cambiado el nombre de la variable a `x`. + +Al ordenador no le importa cómo llamemos a una variable u otra. Los nombres solamente son importantes para las personas. Por lo general, los programadores leen el código de otros con mucha más frecuencia que las veces que escriben el suyo propio. Para que tus colegas puedan leer y analizar tu código fácilmente, es importante dar nombres claros a las variables. + +Es importante pensar en un nombre comprensible que refleje el significado de la variable. Al mismo tiempo, es importante dar nombres que se puedan entender sin contexto; sin tener que estudiar el código circundante. + +Existe una regla generalmente aceptada: no uses transliteraciones para los nombres; solamente usa el idioma inglés. Si tienes dificultades con el inglés, utiliza un traductor. Con el tiempo, al investigar el código de otros, aprenderás a nombrar correctamente las variables. + +Entre los desarrolladores hay un chiste: "Los nombres de las variables son una de las cosas más difíciles en la programación". Es cierto que es difícil inventarse nombres. Por ejemplo, es difícil nombrar una variable que almacena "la cantidad de pedidos impagados de clientes con deudas del trimestre anterior". + +Para poner a prueba tus habilidades, intenta hacer esta tarea: + +> Piensa en un nombre para una variable que almacene "la cantidad de hermanos y hermanas del rey". +> +> Escribe el nombre en un bloc de notas o envíatelo por correo electrónico. No incluyas nada más que el nombre de la variable. Volveremos a este tema en unas lecciones. diff --git a/modules/30-variables/13-variables-naming/es/data.yml b/modules/30-variables/13-variables-naming/es/data.yml new file mode 100644 index 00000000..260a25a7 --- /dev/null +++ b/modules/30-variables/13-variables-naming/es/data.yml @@ -0,0 +1,12 @@ +name: Elección del nombre de la variable +tips: + - | + [Nomenclatura en programación](https://codica.la/blog/naming-in-programming) + - > + [Errores en la nomenclatura de + variables](https://codica.la/blog/naming-errors-1) +definitions: + - name: Variable + description: >- + una forma de almacenar información y darle un nombre para su uso posterior + en el código. diff --git a/modules/30-variables/13-variables-naming/ru/EXERCISE.md b/modules/30-variables/13-variables-naming/ru/EXERCISE.md new file mode 100644 index 00000000..c36b38a1 --- /dev/null +++ b/modules/30-variables/13-variables-naming/ru/EXERCISE.md @@ -0,0 +1,2 @@ + +Создайте переменную, описывающую количество своих братьев, и присвойте ей значение *2*. Распечатайте содержимое переменной. Затем сравните свое имя с именем, которое используется в учительском решении. diff --git a/modules/30-variables/13-variables-naming/ru/README.md b/modules/30-variables/13-variables-naming/ru/README.md new file mode 100644 index 00000000..09b616e8 --- /dev/null +++ b/modules/30-variables/13-variables-naming/ru/README.md @@ -0,0 +1,23 @@ + +Представьте, что мы задали следующую программу: + +```python +x = 'Father!' +print(x) +``` + +С подобной программой мы уже работали, но сейчас в ней изменилось имя переменной на `x`. + +Компьютеру без разницы, как мы именуем ту или иную переменную. Названия важны только людям. Обычно программисты гораздо чаще читают чужой код, чем пишут свой. Чтобы коллеги смогли с легкостью прочитать и проанализировать ваш код, нужно понятно называть переменные. + +Важно придумать понятное название, которое отражает смысл переменной. При этом важно давать такие имена, которые будут понимать без контекста, без изучения окружающего кода. + +Существует общепринятое правило: не используйте транслит для имен — только английский язык. Если вы испытываете сложности с английским, то пользуйтесь переводчиком. Со временем, копаясь в чужом коде, вы научитесь правильно именовать переменные. + +Среди разработчиков есть шутка: «Названия переменных — это одна из самых сложных вещей в программировании». Придумывать названия и правда сложно. Например, сложно назвать переменную, в которой хранится _количество неоплаченных заказов от клиентов с задолженностью в предыдущем квартале._ + +Чтобы проверить себя, попробуйте сделать такое задание: + +> Придумайте название для переменной, в которой будет храниться *«количество братьев и сестер короля»*. +> +> Запишите его в блокноте или отправьте себе на почту. Не указывайте там ничего, кроме названия переменной. А через несколько уроков мы вернемся к этой теме. diff --git a/modules/30-variables/13-variables-naming/ru/data.yml b/modules/30-variables/13-variables-naming/ru/data.yml new file mode 100644 index 00000000..2bf9b426 --- /dev/null +++ b/modules/30-variables/13-variables-naming/ru/data.yml @@ -0,0 +1,13 @@ +name: Выбор имени переменной +tips: + - > + [Именование в + программировании](https://ru.hexlet.io/blog/posts/naming-in-programming) + - > + [Ошибки в именовании + переменных](https://ru.hexlet.io/blog/posts/naming-errors-1) +definitions: + - name: Переменная + description: >- + способ сохранить информацию и дать ей имя для последующего использования в + коде. diff --git a/modules/30-variables/14-errors/en/EXERCISE.md b/modules/30-variables/14-errors/en/EXERCISE.md new file mode 100644 index 00000000..69299538 --- /dev/null +++ b/modules/30-variables/14-errors/en/EXERCISE.md @@ -0,0 +1,10 @@ + +Find an undeclared variable in the program and declare it by assigning the value 'Dragon' to it. + +After running the program, the result on the screen should look like this: + +
+Targaryen
+ and
+Dragon
+
diff --git a/modules/30-variables/14-errors/en/README.md b/modules/30-variables/14-errors/en/README.md new file mode 100644 index 00000000..09c713ef --- /dev/null +++ b/modules/30-variables/14-errors/en/README.md @@ -0,0 +1,11 @@ + +The order of instructions in code with variables is of great importance. That's why the variable must be defined before you use it for the first time. Below is an example of a mistake often made by beginners: + +```python +print(greeting) +greeting = 'Father!' +``` + +Running the program above ends with the error `NameError: name 'greeting' is not defined` - this is a reference error. This means that the code uses a name (identifier) that hasn't yet been defined. This is stated in the text of the error itself: `'greeting' is not defined`. In addition to incorrect ordering, when working with Python, you can also come across simple typos in the name of the variable. This happens both when the variable is used and when it's declared. + +You can reduce the number of such errors if you use a properly configured editor. It warns of possible problems and highlights variables that are used without being declared. diff --git a/modules/30-variables/14-errors/en/data.yml b/modules/30-variables/14-errors/en/data.yml new file mode 100644 index 00000000..a1f994df --- /dev/null +++ b/modules/30-variables/14-errors/en/data.yml @@ -0,0 +1,5 @@ +name: Errors when working with variables +tips: [] +definitions: + - name: Variable + description: a way to save information and name it for later use in code. diff --git a/modules/30-variables/14-errors/es/EXERCISE.md b/modules/30-variables/14-errors/es/EXERCISE.md new file mode 100644 index 00000000..3e050cae --- /dev/null +++ b/modules/30-variables/14-errors/es/EXERCISE.md @@ -0,0 +1,10 @@ + +Encuentra la variable no declarada en el programa y declárala asignándole el valor 'Dragon'. + +Después de ejecutar el programa, el resultado en la pantalla debería verse así: + +
+Targaryen
+ and
+Dragon
+
diff --git a/modules/30-variables/14-errors/es/README.md b/modules/30-variables/14-errors/es/README.md new file mode 100644 index 00000000..e904cd36 --- /dev/null +++ b/modules/30-variables/14-errors/es/README.md @@ -0,0 +1,11 @@ + +El orden de las instrucciones en el código con variables es de gran importancia. Por lo tanto, la variable debe ser definida antes de su primer uso. A continuación, se muestra un ejemplo de error que cometen con frecuencia los principiantes: + +```python +print(greeting) +greeting = 'Father!' +``` + +La ejecución del programa anterior termina con el error `NameError: name 'greeting' is not defined` — este es un error de referencia. Esto significa que en el código se está utilizando un nombre (identificador) que aún no ha sido definido. Esto se indica en el propio texto del error: `'greeting' is not defined`. Además del orden incorrecto de las acciones, en Python también se encuentran errores tipográficos en el nombre de la variable. Esto ocurre tanto cuando se utiliza la variable como cuando se la declara. + +La cantidad de errores similares se puede reducir si se utiliza un editor correctamente configurado. Este editor advierte sobre posibles problemas y resalta las variables que se utilizan sin ser declaradas. diff --git a/modules/30-variables/14-errors/es/data.yml b/modules/30-variables/14-errors/es/data.yml new file mode 100644 index 00000000..8ba9c3df --- /dev/null +++ b/modules/30-variables/14-errors/es/data.yml @@ -0,0 +1,9 @@ +name: Errores al trabajar con variables +tips: + - > + [NameError](https://docs.python.org/3/library/exceptions.html?highlight=nameerror#NameError) +definitions: + - name: Variable + description: >- + una forma de almacenar información y darle un nombre para su uso posterior + en el código. diff --git a/modules/30-variables/14-errors/ru/EXERCISE.md b/modules/30-variables/14-errors/ru/EXERCISE.md new file mode 100644 index 00000000..3b943935 --- /dev/null +++ b/modules/30-variables/14-errors/ru/EXERCISE.md @@ -0,0 +1,10 @@ + +Найдите в программе необъявленную переменную и объявите ее, присвоив ей значение 'Dragon'. + +После выполнения программы результат на экране должен выглядеть так: + +
+Targaryen
+ and
+Dragon
+
diff --git a/modules/30-variables/14-errors/ru/README.md b/modules/30-variables/14-errors/ru/README.md new file mode 100644 index 00000000..aeca2c0c --- /dev/null +++ b/modules/30-variables/14-errors/ru/README.md @@ -0,0 +1,11 @@ + +Порядок инструкций в коде с переменными имеет огромное значение. Поэтому переменную нужно определить до первого использования. Ниже пример ошибки, которую часто допускают новички: + +```python +print(greeting) +greeting = 'Father!' +``` + +Запуск программы выше завершается с ошибкой `NameError: name 'greeting' is not defined` — это ошибка обращения. Это значит, что в коде используется имя (идентификатор), которое пока не определено. Это говорится в самом тексте ошибки: `'greeting' is not defined`. Кроме неправильного порядка действий, в Python встречаются банальные опечатки в имени переменной. Это происходит и когда переменная используется, и когда ее объявляют. + +Количество подобных ошибок можно уменьшить, если использовать правильно настроенный редактор. Он предупреждает о возможных проблемах и подсвечивает переменные, которые используются без объявления. diff --git a/modules/30-variables/14-errors/ru/data.yml b/modules/30-variables/14-errors/ru/data.yml new file mode 100644 index 00000000..90bc4da2 --- /dev/null +++ b/modules/30-variables/14-errors/ru/data.yml @@ -0,0 +1,9 @@ +name: Ошибки при работе с переменными +tips: + - > + [NameError](https://docs.python.org/3/library/exceptions.html?highlight=nameerror#NameError) +definitions: + - name: Переменная + description: >- + способ сохранить информацию и дать ей имя для последующего использования в + коде. diff --git a/modules/30-variables/15-variables-expressions/en/EXERCISE.md b/modules/30-variables/15-variables-expressions/en/EXERCISE.md new file mode 100644 index 00000000..e92d1160 --- /dev/null +++ b/modules/30-variables/15-variables-expressions/en/EXERCISE.md @@ -0,0 +1,13 @@ + +Write a program that takes the original number of euros written in the variable `euros_count`, converts euros to dollars, and prints it to the screen. Then, it should convert the result to yuans and print it on a new line. + +Example output for 100 euros: + +``` +125.0 +863.75 +``` + +For the purposes of the exercise, we'll say that: +- 1 euro = $1.25 +- 1 dollar = 4,50 zl diff --git a/modules/30-variables/15-variables-expressions/en/README.md b/modules/30-variables/15-variables-expressions/en/README.md new file mode 100644 index 00000000..0fb43c13 --- /dev/null +++ b/modules/30-variables/15-variables-expressions/en/README.md @@ -0,0 +1,67 @@ + +We've already figured out how to work with variables to store and reuse information. But they also help simplify complex calculations. For example, currency conversion or making up a new word. Let's look at how to do it in practice. + +Let us imagine that we need to convert euros into yuans via dollars. Banks often do this kind of conversion via an intermediate currency when shopping abroad. + +First, convert 50 euros into dollars. Suppose that one euro is $1.25: + +```python +dollars_count = 50 * 1.25 +print(dollars_count) # => 62.5 +``` + +Here we write **expression** into the variable `dollars_count = 50 * 1.25` to the right of the equals sign. The interpreter will calculate the result (`62.5`) and write it to a variable. The interpreter doesn't care what form the data is written in: `62.5` or `50 * 1.25`. From its perspective, both are expressions to be calculated. It does the calculations and comes up with the same value, `62.5`. + +Any string is an expression. String concatenation (concatenation of variable values) is also an expression. When the interpreter sees an expression, it processes it and generates a result, the **value of the expression**. + +Here are some examples of an expression. We've written the total values in the comments to the right of each expression: + +```python +62.5 # 62.5 +50 * 1.25 # 62.5 +120 / 10 * 2 # 24.0 +int('100') # 100 + +'hello' # hello +'Good' + 'will' # Goodwill +``` + +In the places where an expression is expected, you can put any calculation. It can be not only mathematical, but also string-like concatenation. The program will remain functional. + +Programs consist of many combinations of expressions. Based on the above, consider whether this code would work: + +```python +who = "dragon's " + 'mother' +print(who) +``` + +This code will display the string `dragon's mother`. If you want to check it yourself, run the code on [repl.it](https://replit.com/languages/python3) and experiment with it. + +Variables can be used to write even more complex calculations. Now, back to our currency program. Let's write the dollar value in yuans as a separate variable. Let's calculate the value of 50 euros in dollars by multiplying it by `1.25`. Suppose that 1 dollar is 6.91 yuans: + +```python +yuans_per_dollar = 6.91 +dollars_count = 50 * 1.25 # 62.5 +yuans_count = dollars_count * yuans_per_dollar # 431.875.0 + +print(yuans_count) +``` + +Now let's add text to the output using concatenation: + +```python +yuans_per_dollar = 6.91 +dollars_count = 50 * 1.25 # 62.5 +yuans_count = dollars_count * yuans_per_dollar # 431.875.0 + +# The str() function turns a number into a string. +# There will be a separate lesson about these transformations. +print('The price is ' + str(yuans_count) + ' yuans') +# => The price is 431.875.0 yuans +``` + +Any variable can be part of any expression. At the moment of calculation, the name of the variable will be replaced by its value. + +The interpreter calculates the value of `dollars_count` before this variable is used in other expressions. When it comes time to use a variable, Python already knows the value because it's calculated it. + +Variables can be used to perform complex calculations and to provide a detailed output with the resulting value. But you can also get new expressions by combining two or more variable values. Concatenation is responsible for this. diff --git a/modules/30-variables/15-variables-expressions/en/data.yml b/modules/30-variables/15-variables-expressions/en/data.yml new file mode 100644 index 00000000..06dfca03 --- /dev/null +++ b/modules/30-variables/15-variables-expressions/en/data.yml @@ -0,0 +1 @@ +name: Expressions in definitions diff --git a/modules/30-variables/15-variables-expressions/es/EXERCISE.md b/modules/30-variables/15-variables-expressions/es/EXERCISE.md new file mode 100644 index 00000000..02e71879 --- /dev/null +++ b/modules/30-variables/15-variables-expressions/es/EXERCISE.md @@ -0,0 +1,14 @@ + +Escribe un programa que tome una cantidad inicial de euros, almacenada en la variable `euros_count`, convierta los euros a dólares y los muestre en pantalla. Luego, convierte el valor obtenido a yuanes y lo muestra en una nueva línea. + +Ejemplo de salida para 100 euros: + + +``` +125.0 +863.75 +``` + +Supongamos que: +- 1 euro = 1.25 dólares +- 1 dólar = 6.91 yuanes diff --git a/modules/30-variables/15-variables-expressions/es/README.md b/modules/30-variables/15-variables-expressions/es/README.md new file mode 100644 index 00000000..6fd2acb7 --- /dev/null +++ b/modules/30-variables/15-variables-expressions/es/README.md @@ -0,0 +1,67 @@ + +Ya hemos aprendido cómo trabajar con variables para almacenar y reutilizar información. Pero también nos ayudan a simplificar cálculos complejos. Por ejemplo, convertir monedas o formar nuevas palabras. Veamos cómo hacerlo en la práctica. + +Supongamos que necesitamos convertir euros a yuanes a través de dólares. Estas conversiones a través de una moneda intermedia son comunes en los bancos al realizar compras en el extranjero. + +Primero, convirtamos 50 euros a dólares. Supongamos que un euro equivale a 1.25 dólares: + +```python +dollars_count = 50 * 1.25 +print(dollars_count) # => 62.5 +``` + +Aquí, en la variable `cantidad_dolares = 50 * 1.25`, a la derecha del signo igual, escribimos una **expresión**. El intérprete calculará el resultado (`62.5`) y lo asignará a la variable. Al intérprete no le importa cómo se escriben los datos: `62.5` o `50 * 1.25`. Ambas son expresiones que deben calcularse. Realiza los cálculos y llega al mismo valor: `62.5`. + +Cualquier cadena de texto es una expresión. La concatenación de cadenas (unir los valores de las variables) también es una expresión. Cuando el intérprete encuentra una expresión, la procesa y genera un resultado: el **valor de la expresión**. + +Aquí tienes algunos ejemplos de expresiones. A la derecha de cada expresión se muestran los valores resultantes: + +```python +62.5 # 62.5 +50 * 1.25 # 62.5 +120 / 10 * 2 # 24.0 +int('100') # 100 + +'hello' # hello +'Good' + 'will' # Goodwill +``` + +En los lugares donde se espera una expresión, puedes colocar cualquier cálculo. No solo puede ser matemático, también puede ser una cadena de texto, como la concatenación. El programa seguirá funcionando correctamente. + +Los programas están compuestos por muchas combinaciones de expresiones. Basándonos en lo que se ha dicho anteriormente, piensa si este código funcionará: + +```python +who = "dragon's " + 'mother' +print(who) +``` + +Este código mostrará en pantalla la cadena de texto `dragon's mother`. Si quieres comprobarlo por ti mismo, ejecuta el código en [repl.it](https://replit.com/languages/python3) y experimenta. + +Con variables, puedes realizar cálculos más complejos. Volvamos a nuestro programa de conversión de moneda. Guardemos el valor del dólar en yuanes como una variable separada. Calculemos el precio de 50 euros en dólares multiplicándolos por `1.25`. Supongamos que 1 dólar equivale a 6.91 yuanes: + +```python +yuans_per_dollar = 6.91 +dollars_count = 50 * 1.25 # 62.5 +yuans_count = dollars_count * yuans_per_dollar # 431.875 + +print(yuans_count) +``` + +Ahora agreguemos texto a la salida utilizando la concatenación: + +```python +yuans_per_dollar = 6.91 +dollars_count = 50 * 1.25 # 62.5 +yuans_count = dollars_count * yuans_per_dollar # 431.875 + +# La función str() convierte un número en una cadena de texto. +# Habrá una lección separada sobre estas conversiones. +print('The price is ' + str(yuans_count) + ' yuans') +# => The price is 431.875 yuans +``` + +Cualquier variable puede formar parte de cualquier expresión. En el momento de la evaluación, el valor de la variable se sustituye en lugar de su nombre. + +El intérprete calcula el valor de `dollars_count` antes de que se utilice en otras expresiones. Cuando llega el momento de usar la variable, Python ya conoce su valor porque lo ha calculado. + +Con variables, puedes realizar cálculos complejos y también generar una salida detallada con el valor resultante. Pero también puedes obtener nuevas expresiones al combinar dos o más valores de variables. Esto se logra mediante la concatenación. diff --git a/modules/30-variables/15-variables-expressions/es/data.yml b/modules/30-variables/15-variables-expressions/es/data.yml new file mode 100644 index 00000000..941929f4 --- /dev/null +++ b/modules/30-variables/15-variables-expressions/es/data.yml @@ -0,0 +1,9 @@ +name: Expresiones en definiciones +tips: + - | + [Expresión](https://es.wikipedia.org/wiki/Expresión_(informática)) +definitions: + - name: Variable + description: >- + una forma de almacenar información y darle un nombre para su posterior uso + en el código. diff --git a/modules/30-variables/15-variables-expressions/ru/EXERCISE.md b/modules/30-variables/15-variables-expressions/ru/EXERCISE.md new file mode 100644 index 00000000..d63e3317 --- /dev/null +++ b/modules/30-variables/15-variables-expressions/ru/EXERCISE.md @@ -0,0 +1,13 @@ + +Напишите программу, которая берет исходное количество евро, записанное в переменную `euros_count`, переводит евро в доллары и выводит на экран. Затем полученное значение переводит в юани и выводит на новой строчке. + +Пример вывода для 100 евро: + +``` +125.0 +863.75 +``` + +Считаем, что: +- 1 евро = 1.25 долларов +- 1 доллар = 6.91 юаней diff --git a/modules/30-variables/15-variables-expressions/ru/README.md b/modules/30-variables/15-variables-expressions/ru/README.md new file mode 100644 index 00000000..bb8c02d0 --- /dev/null +++ b/modules/30-variables/15-variables-expressions/ru/README.md @@ -0,0 +1,67 @@ + +Мы уже разобрались, как работать с переменными, чтобы хранить и переиспользовать информацию. Но еще они помогают упрощать сложные вычисления. Например, конвертация валюты или составление нового слова. Рассмотрим, как это делать на практике. + +Представим, что нам нужно перевести евро в юани через доллары. Подобные конвертации через промежуточную валюту часто делают банки при покупках за рубежом. + +Для начала переведем 50 евро в доллары. Допустим, что один евро — 1.25 долларов: + +```python +dollars_count = 50 * 1.25 +print(dollars_count) # => 62.5 +``` + +Здесь в переменную `dollars_count = 50 * 1.25` справа от знака «равно» мы записываем **выражение**. Интерпретатор вычислит результат (`62.5`) и запишет его в переменную. Интерпретатору не важно, в каком виде записаны данные: `62.5` или `50 * 1.25`. Для него оба варианта — выражения, которые надо вычислить. Он проводит вычисления и приходит к одному и тому же значению — `62.5`. + +Любая строка — выражение. Конкатенация строк (склеивание значений переменных) — это тоже выражение. Когда интерпретатор видит выражение, он обрабатывает его и генерирует результат — **значение выражения**. + +Вот несколько примеров выражения. В комментариях справа от каждого выражения записаны итоговые значения: + +```python +62.5 # 62.5 +50 * 1.25 # 62.5 +120 / 10 * 2 # 24.0 +int('100') # 100 + +'hello' # hello +'Good' + 'will' # Goodwill +``` + +В тех местах, где ожидается выражение, можно поставить любое вычисление. Оно может быть не только математическим, но и строковым — как конкатенация. Программа все равно останется работоспособной. + +Программы состоят из множества комбинаций выражений. Основываясь на сказанном выше, подумайте, сработает ли такой код: + +```python +who = "dragon's " + 'mother' +print(who) +``` + +Такой код выведет на экран строку `dragon's mother`. Если хотите проверить самостоятельно, запустите код на [repl.it](https://replit.com/languages/python3) и поэкспериментируйте. + +С помощью переменных можно записывать еще более сложные вычисления. Вернемся к нашей валютной программе. Запишем стоимость доллара в юанях, как отдельную переменную. Вычислим цену 50 евро в долларах, умножив их на `1.25`. Допустим, что 1 доллар — 6.91 юаней: + +```python +yuans_per_dollar = 6.91 +dollars_count = 50 * 1.25 # 62.5 +yuans_count = dollars_count * yuans_per_dollar # 431.875 + +print(yuans_count) +``` + +Теперь добавим к выводу текст с помощью конкатенации: + +```python +yuans_per_dollar = 6.91 +dollars_count = 50 * 1.25 # 62.5 +yuans_count = dollars_count * yuans_per_dollar # 431.875 + +# Функция str() превращает число в строку. +# О таких превращениях будет отдельный урок. +print('The price is ' + str(yuans_count) + ' yuans') +# => The price is 431.875 yuans +``` + +Любая переменная может быть частью любого выражения. В момент вычисления вместо имени переменной подставляется ее значение. + +Интерпретатор вычисляет значение `dollars_count` до того, как эта переменная начнет использоваться в других выражениях. Когда подходит момент использования переменной, Python уже знает значение, потому что вычислил его. + +С помощью переменных можно проводить сложные вычисления, а также делать подробный вывод с получившимся значением. Но еще можно получать новые выражения посредством склеивания двух и более значений переменных. За это отвечает конкатенация. diff --git a/modules/30-variables/15-variables-expressions/ru/data.yml b/modules/30-variables/15-variables-expressions/ru/data.yml new file mode 100644 index 00000000..3d1fc4b6 --- /dev/null +++ b/modules/30-variables/15-variables-expressions/ru/data.yml @@ -0,0 +1,9 @@ +name: Выражения в определениях +tips: + - | + [Выражение](https://ru.wikipedia.org/wiki/Выражение_(информатика)) +definitions: + - name: Переменная + description: >- + способ сохранить информацию и дать ей имя для последующего использования в + коде. diff --git a/modules/30-variables/18-variable-concatenation/en/EXERCISE.md b/modules/30-variables/18-variable-concatenation/en/EXERCISE.md new file mode 100644 index 00000000..7c43af5e --- /dev/null +++ b/modules/30-variables/18-variable-concatenation/en/EXERCISE.md @@ -0,0 +1,18 @@ + +Websites are constantly sending emails to their users. A common task is to automatically send a personalized email with the user's name in the header. If a database stores people's names, the task of generating the header boils down to concatenation: for example, you want to glue the string `Hello` with a string containing a user's name. + +Write a program that will create the header and body of an email using ready-made variables and print the resulting strings. + +Use the `first_name` and `greeting`, variables, a comma, and an exclamation point for the header. Print it in the correct order. + +Use the variables `info` and `intro` for the body of the message, with the second sentence on a new line. + +The result should look like this: + +
+Hello, Joffrey!
+Here is important information about your account security.
+We couldn't verify your mother's maiden name.
+
+ +Perform the task using only two `print()` statements. diff --git a/modules/30-variables/18-variable-concatenation/en/README.md b/modules/30-variables/18-variable-concatenation/en/README.md new file mode 100644 index 00000000..954c2201 --- /dev/null +++ b/modules/30-variables/18-variable-concatenation/en/README.md @@ -0,0 +1,28 @@ + +Let's try using variables with concatenation. Nothing will change syntactically. We know how to concatenate two lines: + +```python +what = "Kings" + "road" +print(what) # => Kingsroad +``` + +So we're able to glue together a string and one variable in which a string is written: + +```python +first = "Kings" +what = first + "road" + +print(what) # => Kingsroad +``` + +You can also concatenate two variables with strings in them: + +```python +first = "Kings" +last = 'road' + +what = first + last +print(what) # => Kingsroad +``` + +Variables are an important tool in programming. They simplify complex calculations and thus make development easier. But to work successfully with variables, you must not only use them correctly, but also call them correctly. We'll talk about this in the next lesson. diff --git a/modules/30-variables/18-variable-concatenation/en/data.yml b/modules/30-variables/18-variable-concatenation/en/data.yml new file mode 100644 index 00000000..1a69e82c --- /dev/null +++ b/modules/30-variables/18-variable-concatenation/en/data.yml @@ -0,0 +1,9 @@ +name: Variables and concatenation +tips: + - > + Consider how you should concatenate the variables to get the two-line output + of the email body. + - > + Remember that you can create a string that contains only the control + sequence `\n`. You can concatenate this string with variables to get proper + text formatting. diff --git a/modules/30-variables/18-variable-concatenation/es/EXERCISE.md b/modules/30-variables/18-variable-concatenation/es/EXERCISE.md new file mode 100644 index 00000000..20826454 --- /dev/null +++ b/modules/30-variables/18-variable-concatenation/es/EXERCISE.md @@ -0,0 +1,18 @@ + +Los sitios web envían constantemente correos electrónicos a sus usuarios. Una tarea típica es enviar automáticamente un correo electrónico personalizado, donde el nombre del usuario estará en el encabezado. Si el nombre de la persona se almacena en algún lugar de la base de datos del sitio como una cadena, la tarea de generar el encabezado se reduce a la concatenación: por ejemplo, es necesario unir la cadena `Hola` con la cadena que contiene el nombre. + +Escriba un programa que genere el encabezado y el cuerpo del correo electrónico, utilizando variables ya definidas, y muestre las cadenas resultantes en la pantalla. + +Para el encabezado, use las variables `first_name` y `greeting`, seguidas de una coma y un signo de exclamación. Muestre esto en la pantalla en el orden correcto. + +Para el cuerpo del correo electrónico, use las variables `info` e `intro`, y asegúrese de que la segunda oración esté en una nueva línea. + +El resultado en la pantalla se verá así: + +
+Hello, Joffrey!
+Here is important information about your account security.
+We couldn't verify your mother's maiden name.
+
+ +Complete la tarea utilizando solo dos `print()`. diff --git a/modules/30-variables/18-variable-concatenation/es/README.md b/modules/30-variables/18-variable-concatenation/es/README.md new file mode 100644 index 00000000..40dc657e --- /dev/null +++ b/modules/30-variables/18-variable-concatenation/es/README.md @@ -0,0 +1,30 @@ + +Intentemos usar variables con concatenación, sin cambiar la sintaxis. Sabemos cómo concatenar dos cadenas: + +```python +what = "Kings" + "road" +print(what) # => Kingsroad +``` + +Esto significa que podemos unir una cadena y una variable que contiene una cadena: + +```python +first = "Kings" +what = first + "road" + +print(what) # => Kingsroad +``` + +También podemos concatenar dos variables que contienen cadenas: + +```python +first = "Kings" +last = 'road' + +what = first + last +print(what) # => Kingsroad +``` + +https://replit.com/@hexlet/python-basics-variables-concatenation + +Las variables son una herramienta importante en la programación. Simplifican cálculos complejos y, por lo tanto, facilitan el desarrollo. Pero para trabajar con variables de manera efectiva, no solo es necesario usarlas correctamente, sino también nombrarlas correctamente. Hablaremos de esto en la próxima lección. diff --git a/modules/30-variables/18-variable-concatenation/es/data.yml b/modules/30-variables/18-variable-concatenation/es/data.yml new file mode 100644 index 00000000..21f24f98 --- /dev/null +++ b/modules/30-variables/18-variable-concatenation/es/data.yml @@ -0,0 +1,15 @@ +name: Variables y concatenación +tips: + - > + Piense en qué cadena y en qué orden debe concatenar las variables para + obtener una salida de correo electrónico de dos líneas como la que se + muestra. + - > + Recuerde que puede crear una cadena que contenga solo una secuencia de + escape `\n`. Puede concatenar esta cadena con las variables para formatear + correctamente el texto. +definitions: + - name: Concatenación + description: > + la operación de unir dos cadenas. Por ejemplo, `console.log("King's " + ' + Landing');` diff --git a/modules/30-variables/18-variable-concatenation/ru/EXERCISE.md b/modules/30-variables/18-variable-concatenation/ru/EXERCISE.md new file mode 100644 index 00000000..03979074 --- /dev/null +++ b/modules/30-variables/18-variable-concatenation/ru/EXERCISE.md @@ -0,0 +1,18 @@ + +Сайты постоянно посылают письма своим пользователям. Типичная задача — сделать автоматическую отправку персонального письма, где в заголовке будет имя пользователя. Если где-то в базе сайта хранится имя человека в виде строки, то задача генерации заголовка сводится к конкатенации: например, нужно склеить строку `Здравствуйте` со строкой, где записано имя. + +Напишите программу, которая будет генерировать заголовок и тело письма, используя уже готовые переменные, и выводить получившиеся строки на экран. + +Для заголовка используйте переменные `first_name` и `greeting`, запятую и восклицательный знак. Выведите это на экран в правильном порядке. + +Для тела письма используйте переменные `info` и `intro`, при этом второе предложение должно быть на новой строке. + +Результат на экране будет выглядеть так: + +
+Hello, Joffrey!
+Here is important information about your account security.
+We couldn't verify your mother's maiden name.
+
+ +Выполните задание, используя только два `print()`. diff --git a/modules/30-variables/18-variable-concatenation/ru/README.md b/modules/30-variables/18-variable-concatenation/ru/README.md new file mode 100644 index 00000000..25ce64ef --- /dev/null +++ b/modules/30-variables/18-variable-concatenation/ru/README.md @@ -0,0 +1,30 @@ + +Попробуем использовать переменные с конкатенацией, при этом синтаксически ничего не поменяется. Мы умеем конкатенировать две строки: + +```python +what = "Kings" + "road" +print(what) # => Kingsroad +``` + +Значит, мы сумеем склеить строку и одну переменную, в которой записана строка: + +```python +first = "Kings" +what = first + "road" + +print(what) # => Kingsroad +``` + +А еще можно конкатенировать две переменные, в которых записаны строки: + +```python +first = "Kings" +last = 'road' + +what = first + last +print(what) # => Kingsroad +``` + +https://replit.com/@hexlet/python-basics-variables-concatenation + +Переменные — важный инструмент в программировании. Они упрощают сложные вычисления и таким образом облегчают разработку. Но чтобы успешно работать с переменными, надо не только правильно использовать их, но и правильно называть. Об этом поговорим уже в следующем уроке. diff --git a/modules/30-variables/18-variable-concatenation/ru/data.yml b/modules/30-variables/18-variable-concatenation/ru/data.yml new file mode 100644 index 00000000..5c0a6760 --- /dev/null +++ b/modules/30-variables/18-variable-concatenation/ru/data.yml @@ -0,0 +1,14 @@ +name: Переменные и конкатенация +tips: + - > + Подумайте, с какой строкой и в каком порядке нужно склеивать переменные, + чтобы получить такой двухстрочный вывод тела письма. + - > + Помните, что можно создать строку, которая содержит только управляющую + последовательность `\n`. Вы можете конкатенировать эту строку с переменными + для правильного форматирования текста. +definitions: + - name: Конкатенация + description: > + операция соединения двух строк. Например, `console.log("King's " + ' + Landing');` diff --git a/modules/30-variables/19-naming-style/en/EXERCISE.md b/modules/30-variables/19-naming-style/en/EXERCISE.md new file mode 100644 index 00000000..1cf4523c --- /dev/null +++ b/modules/30-variables/19-naming-style/en/EXERCISE.md @@ -0,0 +1,4 @@ + +Create two variables named «first number» and «second number» in English using snake_case. Write `20` into the first variable and `-100` into the second variable. Print the product of the numbers written in the resulting variables. + +The code will work with any name, and we only check the printed result, so the task is up to you. diff --git a/modules/30-variables/19-naming-style/en/README.md b/modules/30-variables/19-naming-style/en/README.md new file mode 100644 index 00000000..8cac09a8 --- /dev/null +++ b/modules/30-variables/19-naming-style/en/README.md @@ -0,0 +1,14 @@ + +`greeting` is an example of a simple name, but not all names are that simple. Often they include several words: for example, «username». Different languages have different naming styles for variables. + +Three main variable naming conventions are sometimes combined. These conventions apply to variable names consisting of several words: + +* **kebab-case** — the constituent words of the variable are separated by a hyphen (`my-super-var`) +* **snake\_case** — underscores (`my_super_var`) are used to separate the parts +* **CamelCase** — each word in the variable is capitalized (`MySuperVar`) + +Variables in Python are generally named in the `snake_case` style; words are written in lowercase letters and separated by an underscore `_`. For more details, you can study the section [«How to name variables»](https://peps.python.org/pep-0008/#naming-conventions) in the PEP8 standard. + +At [Hexlet](https://hexlet.io/) we start with linters nigh on straight away. + +Next, let's look at an example of bad practices and consider why they should be avoided. diff --git a/modules/30-variables/19-naming-style/en/data.yml b/modules/30-variables/19-naming-style/en/data.yml new file mode 100644 index 00000000..51eb2318 --- /dev/null +++ b/modules/30-variables/19-naming-style/en/data.yml @@ -0,0 +1,5 @@ +name: Variable naming +tips: [] +definitions: + - name: Coding standard + description: a set of syntactic and stylistic rules for writing code. diff --git a/modules/30-variables/19-naming-style/es/EXERCISE.md b/modules/30-variables/19-naming-style/es/EXERCISE.md new file mode 100644 index 00000000..400e8146 --- /dev/null +++ b/modules/30-variables/19-naming-style/es/EXERCISE.md @@ -0,0 +1,4 @@ + +Crea dos variables con los nombres "primer número" y "segundo número" en inglés utilizando snake_case. Asigna el número `20` a la primera variable y `-100` a la segunda. Imprime en pantalla el producto de los números almacenados en las variables resultantes. + +El código funcionará con cualquier nombre, y nuestro sistema siempre verifica solamente el resultado en pantalla, por lo que completar esta tarea es tu responsabilidad. diff --git a/modules/30-variables/19-naming-style/es/README.md b/modules/30-variables/19-naming-style/es/README.md new file mode 100644 index 00000000..eb3b552c --- /dev/null +++ b/modules/30-variables/19-naming-style/es/README.md @@ -0,0 +1,14 @@ + +`greeting` - es un ejemplo de nombre simple, pero no todos los nombres son tan simples como ese. A menudo, incluyen varias palabras, como "nombre de usuario". En los distintos lenguajes de programación se utilizan diferentes convenciones de codificación, por lo que el nombre de la variable será diferente. + +En la nomenclatura de variables, se pueden identificar tres enfoques principales que a veces se combinan entre sí. Todos estos enfoques se aplican cuando el nombre de la variable consta de varias palabras: + +* **kebab-case** - las partes de la variable se separan con guiones (`my-super-var`) +* **snake\_case** - se utiliza un guión bajo para separar (`my_super_var`) +* **CamelCase** - cada palabra en la variable se escribe con mayúscula (`MySuperVar`) + +En Python, las variables se nombran en estilo `snake_case`: las palabras se escriben en minúsculas y se separan con el carácter de guión bajo `_`. Para obtener más información, puedes consultar la sección [«Cómo nombrar variables»](https://peps.python.org/pep-0008/#naming-conventions) en el estándar PEP8. + +En [Hexlet](https://ru.hexlet.io/), comenzamos a trabajar con linters casi desde el principio. + +A continuación, veremos ejemplos de malas prácticas y analizaremos por qué se deben evitar. diff --git a/modules/30-variables/19-naming-style/es/data.yml b/modules/30-variables/19-naming-style/es/data.yml new file mode 100644 index 00000000..0ea1cfdc --- /dev/null +++ b/modules/30-variables/19-naming-style/es/data.yml @@ -0,0 +1,7 @@ +name: Nomenclatura de variables +tips: + - | + [Snake case](https://es.wikipedia.org/wiki/Snake_case) +definitions: + - name: Estándar de codificación + description: conjunto de reglas sintácticas y estilísticas para escribir código. diff --git a/modules/30-variables/19-naming-style/ru/EXERCISE.md b/modules/30-variables/19-naming-style/ru/EXERCISE.md new file mode 100644 index 00000000..a7f94e34 --- /dev/null +++ b/modules/30-variables/19-naming-style/ru/EXERCISE.md @@ -0,0 +1,4 @@ + +Создайте две переменные с именами «первое число» и «второе число» на английском языке используя snake_case. Запишите в первую переменную число `20`, во вторую — `-100`. Выведите на экран произведение чисел, записанных в получившиеся переменные. + +Код будет работать с любыми названиями, а наша система всегда проверяет только результат на экране, поэтому выполнение этого задания — под вашу ответственность. diff --git a/modules/30-variables/19-naming-style/ru/README.md b/modules/30-variables/19-naming-style/ru/README.md new file mode 100644 index 00000000..ea0b670e --- /dev/null +++ b/modules/30-variables/19-naming-style/ru/README.md @@ -0,0 +1,14 @@ + +`greeting` — пример простого имени, но не все имена так просты. Часто они включают в себя несколько слов: например, «имя пользователя». В разных языках применяются разные стили кодирования, и имя переменной будет отличаться. + +В именовании переменных можно выделить три основных подхода, которые иногда комбинируют друг с другом. Все эти подходы проявляют себя, когда имя переменной состоит из нескольких слов: + +* **kebab-case** — составные части переменной разделяются дефисом (`my-super-var`) +* **snake\_case** — для разделения используется подчеркивание (`my_super_var`) +* **CamelCase** — каждое слово в переменной пишется с заглавной буквы (`MySuperVar`) + +Переменные в Python именуются в стиле `snake_case`: слова записываются строчными буквами и разделяются символом подчеркивания `_`. Чтобы разобраться подробнее, можете изучить раздел [«Как называть переменные»](https://peps.python.org/pep-0008/#naming-conventions) в стандарте PEP8. + +На [Хекслете](https://ru.hexlet.io/) мы начинаем работать с линтерами почти с самого начала. + +Далее посмотрим пример плохих практик и разберем, почему их стоит избегать. diff --git a/modules/30-variables/19-naming-style/ru/data.yml b/modules/30-variables/19-naming-style/ru/data.yml new file mode 100644 index 00000000..3505bc6d --- /dev/null +++ b/modules/30-variables/19-naming-style/ru/data.yml @@ -0,0 +1,7 @@ +name: Именование переменных +tips: + - | + [Snake case](https://ru.wikipedia.org/wiki/Snake_case) +definitions: + - name: Стандарт кодирования + description: набор синтаксических и стилистических правил написания кода. diff --git a/modules/30-variables/20-magic-numbers/en/EXERCISE.md b/modules/30-variables/20-magic-numbers/en/EXERCISE.md new file mode 100644 index 00000000..0dcf04ea --- /dev/null +++ b/modules/30-variables/20-magic-numbers/en/EXERCISE.md @@ -0,0 +1,25 @@ + +You've come across this code, which prints the total number of rooms owned by the present king: + +```python +king = "Rooms in King Balon's Castle:" +print(king) +print(6 * 17) +``` + +As you can see, there are some magic numbers here: it's unclear what 6 is and what 17 is. If you know the history of the royal family, you can guess: each new king inherits all his ancestors 'castles and builds a new one, an exact copy of his parents'. + +This strange dynasty simply breeds identical castles... + +Get rid of the magic numbers by creating new variables and then displaying the text on the screen. + +You'll get this: + +
+Rooms in King Balon's Castle:
+102
+
+ +The variable names should give the meaning of the numbers, but should also be short and succinct enough to be readable. + +Note: The code will work with any name, and we only check the printed result, so the task is up to you. diff --git a/modules/30-variables/20-magic-numbers/en/README.md b/modules/30-variables/20-magic-numbers/en/README.md new file mode 100644 index 00000000..23ebd02b --- /dev/null +++ b/modules/30-variables/20-magic-numbers/en/README.md @@ -0,0 +1,41 @@ + +Let's look at our example of the program that calculates exchange rates: + +```python +euros_count = 1000 +dollars_count = euros_count * 1.25 # 1250.0 +rubles_count = dollars_count * 60 # 75000.0 + +print(rubles_count) +``` + +From professional development's perspective, such code doesn't correspond with the best practices. + +In this example, it's difficult to understand what the numbers `60` and `1.25` mean. Imagine having to deal with that code a month or a year from now – it's going to be difficult. It'll also be difficult for a programmer who hasn't seen the code before. + +In our example, the context is easy to put together because the variables are named correctly. But in real projects, code is much more complicated, so it's often impossible to guess the meaning of the numbers. + +The problem lies in magic numbers. These are numbers whose origin is impossible to understand at a glance – you have to dig deep into what's going on in the code. + +To prevent this problem, you need to create variables with the right names. That way, everything will fall into place: + +```python +dollars_per_euro = 1.25 +rubles_per_dollar = 60 + +euros_count = 1000 +dollars_count = euros_count * dollars_per_euro # 1250.0 +rubles_count = dollars_count * rubles_per_dollar # 75000.0 + +print(rubles_count) +``` + +In this program: + +* Snake_case naming is used +* The two new variables are separated from the subsequent calculations by a blank line. These variables make sense without calculations, so this separation is appropriate because it increases readability +* The resulting code is well named and structured, but it's longer than the previous version. This is often the case, but this is fine because the code must be readable + +Magic numbers and obscure variable names don't break the code, but make it less readable. + +It's important to understand that in any case, the computer will carry out the calculation you give it. However, another programmer reading the code won't understand, thus complicating your work. Naming the variables properly is half the battle when it comes to code analysis. diff --git a/modules/30-variables/20-magic-numbers/en/data.yml b/modules/30-variables/20-magic-numbers/en/data.yml new file mode 100644 index 00000000..8c3edd6e --- /dev/null +++ b/modules/30-variables/20-magic-numbers/en/data.yml @@ -0,0 +1,2 @@ +name: Magic numbers +tips: [] diff --git a/modules/30-variables/20-magic-numbers/es/EXERCISE.md b/modules/30-variables/20-magic-numbers/es/EXERCISE.md new file mode 100644 index 00000000..073917ba --- /dev/null +++ b/modules/30-variables/20-magic-numbers/es/EXERCISE.md @@ -0,0 +1,25 @@ + +Te has encontrado con este código que muestra en pantalla la cantidad total de habitaciones en posesión del actual rey: + +```python +king = "Rooms in King Balon's Castle:" +print(king) +print(6 * 17) +``` + +Como puedes ver, estos son números mágicos: no está claro qué significa el 6 y qué significa el 17. Se puede adivinar si se conoce la historia de la familia real: cada nuevo rey hereda todos los castillos de sus antepasados y construye un nuevo castillo, que es una copia exacta del castillo de sus padres. + +Esta extraña dinastía simplemente reproduce castillos idénticos... + +Elimina los números mágicos creando nuevas variables y luego muestra el texto en pantalla. + +El resultado debería ser: + +
+Rooms in King Balon's Castle:
+102
+
+ +Los nombres de las variables deben transmitir el significado de los números, pero al mismo tiempo deben ser lo suficientemente cortos y concisos para una lectura cómoda. + +Recuerda: el código funcionará con cualquier nombre, y nuestro sistema siempre verifica solamente el resultado en pantalla, por lo que completar esta tarea es tu responsabilidad. diff --git a/modules/30-variables/20-magic-numbers/es/README.md b/modules/30-variables/20-magic-numbers/es/README.md new file mode 100644 index 00000000..8d16d187 --- /dev/null +++ b/modules/30-variables/20-magic-numbers/es/README.md @@ -0,0 +1,41 @@ + +Tomemos como ejemplo un programa que calcula el tipo de cambio de divisas: + +```python +euros_count = 1000 +dollars_count = euros_count * 1.25 # 1250.0 +rubles_count = dollars_count * 60 # 75000.0 + +print(rubles_count) +``` + +Desde el punto de vista del desarrollo profesional, este código no cumple con las "mejores prácticas". + +En este ejemplo, es difícil entender qué significan los números `60` y `1.25`. Imagina que tienes que trabajar con este código después de un mes o un año, será complicado. También será difícil para otros programadores que no hayan visto el código antes. + +En nuestro ejemplo, es fácil deducir el contexto porque las variables están nombradas correctamente. Pero en proyectos reales, el código es mucho más complejo, por lo que a menudo es imposible adivinar el significado de los números. + +El problema radica en los "números mágicos" — magic numbers. Estos son números cuyo origen no se puede entender a simple vista, es necesario profundizar en lo que sucede en el código. + +Para evitar este problema, es necesario crear variables con nombres adecuados. Así todo encajará en su lugar: + + ```python +dollars_per_euro = 1.25 +rubles_per_dollar = 60 + +euros_count = 1000 +dollars_count = euros_count * dollars_per_euro # 1250.0 +rubles_count = dollars_count * rubles_per_dollar # 75000.0 + +print(rubles_count) +``` + +En este programa: + +* Se utiliza la convención de nombres snake_case +* Las dos nuevas variables se separan de los cálculos posteriores con una línea en blanco. Estas variables tienen sentido incluso sin los cálculos, por lo que esta separación es apropiada ya que mejora la legibilidad. +* El código resultante está bien nombrado y estructurado, pero es más largo que la versión anterior. Esto ocurre a menudo y es normal, ya que el código debe ser legible. + +Los números mágicos y los nombres de variables confusos no rompen el código, pero lo hacen menos legible. + +Es importante entender que la computadora ejecutará el cálculo especificado de todas formas. Sin embargo, otro programador que lea el código no entenderá nada, lo que dificultará el trabajo. Nombrar adecuadamente las variables es la mitad del éxito en el análisis del código. diff --git a/modules/30-variables/20-magic-numbers/es/data.yml b/modules/30-variables/20-magic-numbers/es/data.yml new file mode 100644 index 00000000..e2945f2d --- /dev/null +++ b/modules/30-variables/20-magic-numbers/es/data.yml @@ -0,0 +1,4 @@ +name: Números mágicos +tips: + - | + [Números mágicos](https://es.wikipedia.org/wiki/Número_mágico_(informática)) diff --git a/modules/30-variables/20-magic-numbers/ru/EXERCISE.md b/modules/30-variables/20-magic-numbers/ru/EXERCISE.md new file mode 100644 index 00000000..f9c47d46 --- /dev/null +++ b/modules/30-variables/20-magic-numbers/ru/EXERCISE.md @@ -0,0 +1,25 @@ + +Вы столкнулись с таким кодом, который выводит на экран общее количество комнат во владении нынешнего короля: + +```python +king = "Rooms in King Balon's Castle:" +print(king) +print(6 * 17) +``` + +Как видите, это магические числа: непонятно, что такое 6 и что такое 17. Можно догадаться, если знать историю королевской семьи: каждый новый король получает в наследство все замки от предков и строит новый замок — точную копию родительского. + +Эта странная династия просто плодит одинаковые замки… + +Избавьтесь от магических чисел, создав новые переменные, а затем выведите текст на экран. + +Получится так: + +
+Rooms in King Balon's Castle:
+102
+
+ +Названия переменных должны передавать смысл чисел, но должны при этом оставаться достаточно короткими и ёмкими для комфортного чтения. + +Помните: код будет работать с любыми названиями, а наша система всегда проверяет только результат на экране, поэтому выполнение этого задания — под вашу ответственность. diff --git a/modules/30-variables/20-magic-numbers/ru/README.md b/modules/30-variables/20-magic-numbers/ru/README.md new file mode 100644 index 00000000..352466cc --- /dev/null +++ b/modules/30-variables/20-magic-numbers/ru/README.md @@ -0,0 +1,41 @@ + +Возьмем пример программы, которая считает курс валют: + +```python +euros_count = 1000 +dollars_count = euros_count * 1.25 # 1250.0 +rubles_count = dollars_count * 60 # 75000.0 + +print(rubles_count) +``` + +С точки зрения профессиональной разработки, такой код не соответствует «лучшим практикам» — best practices. + +В этом примере сложно понять, что значат числа `60` и `1.25`. Представьте, что вам придется разбираться в этом коде через месяц или через год — это будет сложно. Также сложно будет программисту, который не видел код ранее. + +В нашем примере контекст легко восстановить, потому что переменные названы грамотно. Но в реальных проектах код значительно сложнее, поэтому догадаться до смысла чисел зачастую невозможно. + +Проблема кроется в «магических числах» — magic numbers. Это числа, происхождение которых невозможно понять с первого взгляда — приходится глубоко вникать в то, что происходит в коде. + +Чтобы предотвратить проблему, нужно создавать переменные с правильными именами. Так все встанет на свои места: + +```python +dollars_per_euro = 1.25 +rubles_per_dollar = 60 + +euros_count = 1000 +dollars_count = euros_count * dollars_per_euro # 1250.0 +rubles_count = dollars_count * rubles_per_dollar # 75000.0 + +print(rubles_count) +``` + +В этой программе: + +* Используется именование snake_case +* Две новые переменные отделяются от последующих вычислений пустой строчкой. Эти переменные имеют смысл и без вычислений, поэтому такое отделение уместно, потому что повышает читаемость +* Получился хорошо именованный и структурированный код, но он длиннее прошлой версии. Так часто бывает — это нормально, ведь код должен быть читабельным + +Магические числа и непонятные именования переменных не ломают код, но делают его менее читабельным. + +Нужно понимать, что компьютер в любом случае выполнит заданное вычисление. Однако другой программист будет читать код и ничего не поймет — это усложнит работу. Правильное именование переменных — половина успеха анализа кода. diff --git a/modules/30-variables/20-magic-numbers/ru/data.yml b/modules/30-variables/20-magic-numbers/ru/data.yml new file mode 100644 index 00000000..37265ec4 --- /dev/null +++ b/modules/30-variables/20-magic-numbers/ru/data.yml @@ -0,0 +1,5 @@ +name: Магические числа +tips: + - > + [Магические + числа](https://ru.wikipedia.org/wiki/Магическое_число_(программирование)) diff --git a/modules/30-variables/23-constants/en/EXERCISE.md b/modules/30-variables/23-constants/en/EXERCISE.md new file mode 100644 index 00000000..3d59d3af --- /dev/null +++ b/modules/30-variables/23-constants/en/EXERCISE.md @@ -0,0 +1,2 @@ + +Create a constant `DRAGONS_BORN_COUNT` and write the number 3 in it, which is the number of dragons born to Daenerys. diff --git a/modules/30-variables/23-constants/en/README.md b/modules/30-variables/23-constants/en/README.md new file mode 100644 index 00000000..2b89bfb0 --- /dev/null +++ b/modules/30-variables/23-constants/en/README.md @@ -0,0 +1,9 @@ + +Some data never change - for example, mathematical constants. Take π as an example. It is always 3.14 and cannot change. Python uses constants to refer to this kind of data: + +```python +PI = 3.14 +print(PI) # => 3.14 +``` + +A constant is created in the same way as a variable. The only difference is that constants are usually named with capital letters have and `_` as a separator between words. A constant, like a variable, can be used in any expression. diff --git a/modules/30-variables/23-constants/en/data.yml b/modules/30-variables/23-constants/en/data.yml new file mode 100644 index 00000000..bec3a778 --- /dev/null +++ b/modules/30-variables/23-constants/en/data.yml @@ -0,0 +1,7 @@ +name: Constants +tips: [] +definitions: + - name: Constant + description: >- + a way to store information and name it for later use in code; constants + cannot be changed, unlike variables. diff --git a/modules/30-variables/23-constants/es/EXERCISE.md b/modules/30-variables/23-constants/es/EXERCISE.md new file mode 100644 index 00000000..164eb1d9 --- /dev/null +++ b/modules/30-variables/23-constants/es/EXERCISE.md @@ -0,0 +1,2 @@ + +Crea la constante `DRAGONS_BORN_COUNT` y asígnale el valor de 3, que es la cantidad de dragones nacidos de Daenerys. diff --git a/modules/30-variables/23-constants/es/README.md b/modules/30-variables/23-constants/es/README.md new file mode 100644 index 00000000..474cfaed --- /dev/null +++ b/modules/30-variables/23-constants/es/README.md @@ -0,0 +1,9 @@ + +Algunos datos nunca cambian, como las constantes matemáticas. Tomemos como ejemplo el número π. Siempre es igual a 3.14 y no puede cambiar. Para acceder a este tipo de datos, en Python se utilizan constantes: + +```python +PI = 3.14 +print(PI) # => 3.14 +``` + +Una constante se crea de la misma manera que una variable. La única diferencia es que las constantes se suelen nombrar con letras mayúsculas y se usa `_` como separador entre palabras. Una constante, al igual que una variable, se puede utilizar en cualquier expresión. diff --git a/modules/30-variables/23-constants/es/data.yml b/modules/30-variables/23-constants/es/data.yml new file mode 100644 index 00000000..ee9cf18b --- /dev/null +++ b/modules/30-variables/23-constants/es/data.yml @@ -0,0 +1,8 @@ +name: Constantes +tips: [] +definitions: + - name: Constante + description: >- + una forma de almacenar información y darle un nombre para su uso posterior + en el código; las constantes no se pueden modificar, a diferencia de las + variables. diff --git a/modules/30-variables/23-constants/ru/EXERCISE.md b/modules/30-variables/23-constants/ru/EXERCISE.md new file mode 100644 index 00000000..35880469 --- /dev/null +++ b/modules/30-variables/23-constants/ru/EXERCISE.md @@ -0,0 +1,2 @@ + +Создайте константу `DRAGONS_BORN_COUNT` и запишите в неё число 3 — это количество драконов, родившихся у Дайенерис. diff --git a/modules/30-variables/23-constants/ru/README.md b/modules/30-variables/23-constants/ru/README.md new file mode 100644 index 00000000..f5869281 --- /dev/null +++ b/modules/30-variables/23-constants/ru/README.md @@ -0,0 +1,9 @@ + +Некоторые данные никогда не меняются — например, математические постоянные. Возьмем для примера число π. Оно всегда равно 3.14 и не может измениться. Чтобы обратиться к подобным данным, в Python используют константы: + +```python +PI = 3.14 +print(PI) # => 3.14 +``` + +Константа создается так же, как переменная. Разница только в том, что константы принято именовать заглавными буквами и с `_` в качестве разделителя между словами. Константа, как и переменная, может использоваться в любом выражении. diff --git a/modules/30-variables/23-constants/ru/data.yml b/modules/30-variables/23-constants/ru/data.yml new file mode 100644 index 00000000..dd2539e2 --- /dev/null +++ b/modules/30-variables/23-constants/ru/data.yml @@ -0,0 +1,7 @@ +name: Константы +tips: [] +definitions: + - name: Константа + description: >- + способ сохранить информацию и дать ей имя для последующего использования в + коде; константы нельзя изменять, в отличие от переменных. diff --git a/modules/31-advanced-strings/25-interpolation/en/EXERCISE.md b/modules/31-advanced-strings/25-interpolation/en/EXERCISE.md new file mode 100644 index 00000000..050b464a --- /dev/null +++ b/modules/31-advanced-strings/25-interpolation/en/EXERCISE.md @@ -0,0 +1,6 @@ + +Print the string, `Do you want to eat, ? Where the variable `stark` should be used instead of ``. The output should look like this: + +
+Do you want to eat, Arya?
+
diff --git a/modules/31-advanced-strings/25-interpolation/en/README.md b/modules/31-advanced-strings/25-interpolation/en/README.md new file mode 100644 index 00000000..3fbd5b0f --- /dev/null +++ b/modules/31-advanced-strings/25-interpolation/en/README.md @@ -0,0 +1,37 @@ + +You already know how to move a string or glue several strings together to get a new expression. But there are alternatives to these operations in programming. They make the code more readable and easier to maintain. + +The basic way to join strings is **concatenation**. Using concatenation, the strings are added to each other, as in the example below: + +```python +first_name = 'Joffrey' +greeting = 'Hello' + +print(greeting + ", " + first_name + "!") +# => Hello, Joffrey! +``` + +Concatenation works simply, but doesn't always look so visually clear. The quotation marks make it difficult to see what the end result will be. And the more complex the string is, the more confusing it will start to look. Concatenation has an alternative: **interpolation**. This is what it looks like: + +```python +first_name = 'Joffrey' +greeting = 'Hello' + +print(f'{greeting}, {first_name}!') +# => Hello, Joffrey! +``` + +The letter `f` indicates that we are creating an **f-string**, a pattern into which the value of variables is substituted with the help of curly brackets. The output is a normal string. + +Consider this example: + +```python +school = 'Hexlet' + +what_is_it = f'{school} - online courses' +print(what_is_it) # => Hexlet - online courses +``` + +In almost all languages, interpolation is preferable to concatenation for combining strings. This produces strings that are stuck together, and spaces and characters are visible inside it. + +Interpolation helps make code clearer to developers. But that's not the only useful alternative we want to talk about. Later in the course, we'll look at how to declare a multiline string without using `\n`. diff --git a/modules/31-advanced-strings/25-interpolation/en/data.yml b/modules/31-advanced-strings/25-interpolation/en/data.yml new file mode 100644 index 00000000..4d9451fe --- /dev/null +++ b/modules/31-advanced-strings/25-interpolation/en/data.yml @@ -0,0 +1,7 @@ +name: Interpolation +tips: [] +definitions: + - name: Interpolation + description: >- + a method for obtaining a complex string from several simple ones using + special templates diff --git a/modules/31-advanced-strings/25-interpolation/es/EXERCISE.md b/modules/31-advanced-strings/25-interpolation/es/EXERCISE.md new file mode 100644 index 00000000..da1c0e3f --- /dev/null +++ b/modules/31-advanced-strings/25-interpolation/es/EXERCISE.md @@ -0,0 +1,6 @@ + +Imprime en pantalla la cadena `Do you want to eat, ?`, donde en lugar de `` se debe utilizar la variable `stark`. La salida debe ser la siguiente: + +
+Do you want to eat, Arya?
+
diff --git a/modules/31-advanced-strings/25-interpolation/es/README.md b/modules/31-advanced-strings/25-interpolation/es/README.md new file mode 100644 index 00000000..58f0b2a3 --- /dev/null +++ b/modules/31-advanced-strings/25-interpolation/es/README.md @@ -0,0 +1,39 @@ + +Ya sabes cómo concatenar cadenas de texto o "unir" varias cadenas para obtener una nueva expresión. Pero en programación, hay alternativas a estas operaciones. Estas mejoran la legibilidad del código y lo hacen más fácil de mantener. + +El método básico para unir cadenas es la **concatenación**. Con la concatenación, las cadenas se "suman" entre sí, como se muestra en el siguiente ejemplo: + +```python +first_name = 'Joffrey' +greeting = 'Hello' + +print(greeting + ", " + first_name + "!") +# => Hello, Joffrey! +``` + +La concatenación funciona de manera sencilla, pero no siempre es visualmente clara. Debido a las comillas, es difícil ver cómo será el resultado final. Y cuanto más compleja sea la cadena, más confusa se volverá. La interpolación es una alternativa a la concatenación. Así es como se ve: + +```python +first_name = 'Joffrey' +greeting = 'Hello' + +print(f'{greeting}, {first_name}!') +# => Hello, Joffrey! +``` + +La letra `f` indica que estamos creando una **f-string** (cadena f) - una plantilla en la que los valores de las variables se insertan mediante llaves. El resultado es una cadena normal. + +Veamos este ejemplo: + +```python +school = 'Hexlet' + +what_is_it = f'{school} - online courses' +print(what_is_it) # => Hexlet - online courses +``` + +https://replit.com/@hexlet/python-basics-advanced-strings-interpolation + +En casi todos los lenguajes de programación, la interpolación es preferible a la concatenación para unir cadenas. La cadena resultante se muestra como una sola unidad, y los espacios y otros caracteres son fácilmente distinguibles dentro de ella. + +La interpolación ayuda a que el código sea más comprensible para los desarrolladores. Pero esta no es la única alternativa útil que queríamos mencionar. En el próximo tema, aprenderemos cómo declarar cadenas de varias líneas sin usar `\n`. diff --git a/modules/31-advanced-strings/25-interpolation/es/data.yml b/modules/31-advanced-strings/25-interpolation/es/data.yml new file mode 100644 index 00000000..56a8faef --- /dev/null +++ b/modules/31-advanced-strings/25-interpolation/es/data.yml @@ -0,0 +1,9 @@ +name: Interpolación +tips: + - > + [f-strings](https://docs.python.org/3/tutorial/inputoutput.html#fancier-output-formatting) +definitions: + - name: Interpolación + description: >- + una forma de obtener una cadena compleja a partir de varias cadenas + simples utilizando plantillas especiales. diff --git a/modules/31-advanced-strings/25-interpolation/ru/EXERCISE.md b/modules/31-advanced-strings/25-interpolation/ru/EXERCISE.md new file mode 100644 index 00000000..f8b2eb45 --- /dev/null +++ b/modules/31-advanced-strings/25-interpolation/ru/EXERCISE.md @@ -0,0 +1,6 @@ + +Выведите на экран строку `Do you want to eat, ?`. Где вместо `` должна использоваться переменная `stark`. Вывод должен получиться таким: + +
+Do you want to eat, Arya?
+
diff --git a/modules/31-advanced-strings/25-interpolation/ru/README.md b/modules/31-advanced-strings/25-interpolation/ru/README.md new file mode 100644 index 00000000..96a87d00 --- /dev/null +++ b/modules/31-advanced-strings/25-interpolation/ru/README.md @@ -0,0 +1,39 @@ + +Вы уже знаете, как перенести строку или «слепить» несколько строк, чтобы получить новое выражение. Но в программировании есть альтернативы этих операций. Они повышают читаемость кода и делают его проще в поддержке. + +Базовый способ соединения строк — **конкатенация**. С помощью конкатенации строки «суммируются» друг с другом, как в примере ниже: + +```python +first_name = 'Joffrey' +greeting = 'Hello' + +print(greeting + ", " + first_name + "!") +# => Hello, Joffrey! +``` + +Конкатенация работает просто, но выглядит не всегда наглядно. Из-за кавычек сложно разглядеть то, каким будет конечный результат. И чем сложнее устроена строка, тем запутаннее она начнет выглядеть. У конкатенации есть альтернатива — **интерполяция**. Вот как это выглядит: + +```python +first_name = 'Joffrey' +greeting = 'Hello' + +print(f'{greeting}, {first_name}!') +# => Hello, Joffrey! +``` + +Буква `f` указывает на то, что мы создаем **f-строку** — шаблон, в который с помощью фигурных скобок подставляются значения переменных. На выходе получается обычная строка. + +Рассмотрим такой пример: + +```python +school = 'Hexlet' + +what_is_it = f'{school} - online courses' +print(what_is_it) # => Hexlet - online courses +``` + +https://replit.com/@hexlet/python-basics-advanced-strings-interpolation + +Почти во всех языках для объединения строк интерполяция предпочтительнее конкатенации. Строка при этом получается склеенная, и внутри нее хорошо просматриваются пробелы и другие символы. + +Интерполяция помогает сделать код более понятным для разработчиков. Но это не единственная полезная альтернатива, о которой мы хотели рассказать. Далее в курсе мы разберемся, как объявлять многострочную строку и не использовать `\n`. diff --git a/modules/31-advanced-strings/25-interpolation/ru/data.yml b/modules/31-advanced-strings/25-interpolation/ru/data.yml new file mode 100644 index 00000000..d6c6c856 --- /dev/null +++ b/modules/31-advanced-strings/25-interpolation/ru/data.yml @@ -0,0 +1,9 @@ +name: Интерполяция +tips: + - > + [f-строки](https://docs.python.org/3/tutorial/inputoutput.html#fancier-output-formatting) +definitions: + - name: Интерполяция + description: >- + способ получения сложной строки из нескольких простых с использованием + специальных шаблонов diff --git a/modules/31-advanced-strings/30-symbols/en/EXERCISE.md b/modules/31-advanced-strings/30-symbols/en/EXERCISE.md new file mode 100644 index 00000000..cf8e3929 --- /dev/null +++ b/modules/31-advanced-strings/30-symbols/en/EXERCISE.md @@ -0,0 +1,2 @@ + +Display the last character of the string in the `name` variable diff --git a/modules/31-advanced-strings/30-symbols/en/README.md b/modules/31-advanced-strings/30-symbols/en/README.md new file mode 100644 index 00000000..f9153aa8 --- /dev/null +++ b/modules/31-advanced-strings/30-symbols/en/README.md @@ -0,0 +1,50 @@ + +Sometimes, you have to get a single character from a string. For example, if a site knows users' first and last names, and at some point you want it to output this information in a format like *J. Smith*. To do this, the computer will need to take the first character from the name. Python has a suitable operation, which is what we'll study today. + +Suppose you want to display only the first letter of the name Alexander. It looks like this: + +```python +first_name = 'Alexander' + +print(first_name[0]) # => A +``` + +The operation with square brackets with a digit extracts an element by **index** - the position of the character inside the string. Indexes start with 0 in almost all programming languages. Therefore, to get the first character, you must specify the index `0`. The index of the last element is equal to the string length minus one. Accessing an index outside the string will cause an error: + +```python +# The string length is 9, so the last index is 8 +first_name = 'Alexander' + +print(first_name[8]) # => r + +print(first_name[9]) +IndexError: string index out of range +``` + +To better consolidate your new knowledge, look at the code below and think about what it produces: + +```python +magic = '\nyou' +print(magic[1]) # => ? +``` + +There are, of course, non-standard situations. For example, you need to output an element from the end, and it's from an expression with a large number of characters. In this case, you can use the negative index, which will make your life much easier. + +You're allowed to use negative indices. In this case, we access characters starting from the end of the string. `-1` is the index of the last character, `-2` is the penultimate, and so on. Unlike direct indexing, the countdown is from `-1`: + +```python +first_name = 'Alexander' + +print(first_name[-1]) # => r +``` + +You can use variables as well as numbers as an index. Look at the example below. Here we have an index inside the square brackets, but it's not a number, it's a variable. This code will cause the same result it'll output *A*: + +```python +first_name = 'Alexander' +index = 0 + +print(first_name[index]) # => A +``` + +If you only want to get a few characters from an expression, you don't need to write a large number of lines of code, just extract the element using an index. You can also use a negative index to make it easier to output characters from the end of an expression. Next, let's see how this knowledge can be used to extract a substring from a string. diff --git a/modules/31-advanced-strings/30-symbols/en/data.yml b/modules/31-advanced-strings/30-symbols/en/data.yml new file mode 100644 index 00000000..31b5922a --- /dev/null +++ b/modules/31-advanced-strings/30-symbols/en/data.yml @@ -0,0 +1,2 @@ +name: Extracting characters from a string +tips: [] diff --git a/modules/31-advanced-strings/30-symbols/es/EXERCISE.md b/modules/31-advanced-strings/30-symbols/es/EXERCISE.md new file mode 100644 index 00000000..ca0a1bc2 --- /dev/null +++ b/modules/31-advanced-strings/30-symbols/es/EXERCISE.md @@ -0,0 +1,2 @@ + +Imprime en pantalla el último carácter de la cadena que se encuentra en la variable `name`. diff --git a/modules/31-advanced-strings/30-symbols/es/README.md b/modules/31-advanced-strings/30-symbols/es/README.md new file mode 100644 index 00000000..ccfefcd1 --- /dev/null +++ b/modules/31-advanced-strings/30-symbols/es/README.md @@ -0,0 +1,52 @@ + +A veces es necesario obtener un solo carácter de una cadena. Por ejemplo, si un sitio web conoce el nombre y apellido del usuario, y en algún momento se requiere mostrar esta información en el formato *A. Ivanov*. Para lograr esto, la computadora necesita tomar el primer carácter del nombre. En Python, hay una operación adecuada que estudiaremos hoy. + +Supongamos que queremos mostrar en pantalla solo la primera letra del nombre "Alexander". Se vería así: + +```python +first_name = 'Alexander' + +print(first_name[0]) # => A +``` + +La operación con corchetes y un número extrae el elemento por su **índice** - la posición del carácter dentro de la cadena. Los índices comienzan en 0 en casi todos los lenguajes de programación. Por lo tanto, para obtener el primer carácter, debemos especificar el índice `0`. El índice del último elemento es igual a la longitud de la cadena menos uno. Acceder a un índice fuera de los límites de la cadena resultará en un error: + +```python +# La longitud de la cadena es 9, por lo que el último índice es 8 +first_name = 'Alexander' + +print(first_name[8]) # => r + +print(first_name[9]) +IndexError: string index out of range +``` + +Para reforzar los nuevos conocimientos, eche un vistazo al siguiente código y piense en qué imprimirá: + +```python +magic = '\nyou' +print(magic[1]) # => ? +``` + +También hay situaciones que no son estándares o comunes. Por ejemplo, es posible que necesitemos mostrar un elemento desde el final, y además, desde una expresión con un gran número de caracteres. En este caso, podemos usar un índice negativo, que facilitará el trabajo del programador. + +Se pueden usar índices negativos. En este caso, se accede a los caracteres desde el final de la cadena. `-1` es el índice del último carácter, `-2` es el penúltimo, y así sucesivamente. A diferencia de la indexación directa, el recuento inverso comienza desde `-1`: + +```python +first_name = 'Alexander' + +print(first_name[-1]) # => r +``` + +El índice puede ser no solo un número específico, sino también el valor de una variable. Mire el siguiente ejemplo. Aquí hemos escrito el índice dentro de los corchetes como una variable. Este código dará el mismo resultado, es decir, mostrará en pantalla el carácter *A*: + +```python +first_name = 'Alexander' +index = 0 + +print(first_name[index]) # => A +``` + +https://replit.com/@hexlet/python-basics-advanced-strings-symbols + +Para mostrar solamente algunos caracteres de una expresión, no es necesario escribir una gran cantidad de líneas de código, simplemente extraiga el elemento utilizando un índice. También puede usar un índice negativo para facilitar la extracción de caracteres desde el final de la expresión. A continuación, veremos cómo usar estos conocimientos para extraer subcadenas de una cadena. diff --git a/modules/31-advanced-strings/30-symbols/es/data.yml b/modules/31-advanced-strings/30-symbols/es/data.yml new file mode 100644 index 00000000..776dd718 --- /dev/null +++ b/modules/31-advanced-strings/30-symbols/es/data.yml @@ -0,0 +1,5 @@ +name: Extracción de caracteres de una cadena +tips: [] +definitions: + - name: Índice + description: La posición del carácter dentro de una cadena. diff --git a/modules/31-advanced-strings/30-symbols/ru/EXERCISE.md b/modules/31-advanced-strings/30-symbols/ru/EXERCISE.md new file mode 100644 index 00000000..a60b46a4 --- /dev/null +++ b/modules/31-advanced-strings/30-symbols/ru/EXERCISE.md @@ -0,0 +1,2 @@ + +Выведите на экран последний символ строки, находящейся в переменной `name` diff --git a/modules/31-advanced-strings/30-symbols/ru/README.md b/modules/31-advanced-strings/30-symbols/ru/README.md new file mode 100644 index 00000000..90fa2719 --- /dev/null +++ b/modules/31-advanced-strings/30-symbols/ru/README.md @@ -0,0 +1,52 @@ + +Иногда нужно получить один символ из строки. Например, если сайт знает имя и фамилию пользователя, и в какой-то момент требуется вывести эту информацию в формате *A. Ivanov*. Для этого компьютеру потребуется взять первый символ из имени. В Python есть подходящая операция, которую мы изучим сегодня. + +Представим, что из имени Alexander нужно вывести на экран только первую букву. Это выглядит так: + +```python +first_name = 'Alexander' + +print(first_name[0]) # => A +``` + +Операция с квадратными скобками с цифрой извлекает элемент по **индексу** — позицией символа внутри строки. Индексы начинаются с 0 почти во всех языках программирования. Поэтому, чтобы получить первый символ, нужно указать индекс `0`. Индекс последнего элемента равен длине строки минус единица. Обращение к индексу за пределами строки приведет к ошибке: + +```python +# Длина строки 9, поэтому последний индекс — это 8 +first_name = 'Alexander' + +print(first_name[8]) # => r + +print(first_name[9]) +IndexError: string index out of range +``` + +Чтобы лучше закрепить новые знания, посмотрите на код ниже и подумайте, что он выдаст: + +```python +magic = '\nyou' +print(magic[1]) # => ? +``` + +Бывают и нестандартные ситуации. Например, нужно вывести элемент из конца, причем из выражения с большим количеством символов. В этом случае можно воспользоваться отрицательным индексом, который облегчит работу программиста. + +Допустимо использовать отрицательные индексы. В этом случае идет обращение к символам, начиная с конца строки. `-1` — индекс последнего символа, `-2` — предпоследнего и так далее. В отличие от прямой индексации, обратный отсчет идет от `-1`: + +```python +first_name = 'Alexander' + +print(first_name[-1]) # => r +``` + +Индексом может быть не только конкретное число, но и значение переменной. Посмотрите на пример ниже. Здесь мы записали индекс внутри квадратных скобок не числом, а переменной. Такой код приведет к тому же результату — выводу на экран символа *A*: + +```python +first_name = 'Alexander' +index = 0 + +print(first_name[index]) # => A +``` + +https://replit.com/@hexlet/python-basics-advanced-strings-symbols + +Чтобы выводить из выражения лишь некоторые символы, не нужно писать большое количество строк кода — достаточно извлечь элемент с помощью индекса. Также можно пользоваться отрицательным индексом, чтобы легче выводить символы с конца выражения. Далее разберемся, как с помощью этих знаний можно извлекать подстроки из строки. diff --git a/modules/31-advanced-strings/30-symbols/ru/data.yml b/modules/31-advanced-strings/30-symbols/ru/data.yml new file mode 100644 index 00000000..d3d721b9 --- /dev/null +++ b/modules/31-advanced-strings/30-symbols/ru/data.yml @@ -0,0 +1,5 @@ +name: Извлечение символов из строки +tips: [] +definitions: + - name: Индекс + description: позиция символа внутри строки. diff --git a/modules/31-advanced-strings/70-slices/en/EXERCISE.md b/modules/31-advanced-strings/70-slices/en/EXERCISE.md new file mode 100644 index 00000000..1b390ae6 --- /dev/null +++ b/modules/31-advanced-strings/70-slices/en/EXERCISE.md @@ -0,0 +1,2 @@ + +The variable `value` contains the value `Hexlet`. Extract from it and display the slice that gets the substring `xle`. This task can be done in different ways. diff --git a/modules/31-advanced-strings/70-slices/en/README.md b/modules/31-advanced-strings/70-slices/en/README.md new file mode 100644 index 00000000..f9b5edad --- /dev/null +++ b/modules/31-advanced-strings/70-slices/en/README.md @@ -0,0 +1,102 @@ + +When we work with strings in programming, we regularly have to extract some part of them. For example, we need to figure out if a smaller string is present inside a larger one. In this lesson, we will figure out how to do that. + +**Substring** is some part of the string to be found and extracted. + +Suppose we have a date in this format: *12-08-2034*. We need to extract from it a substring, which includes only the year. + +If you think logically, you need to count the index of the character with which the year begins, and then extract the four characters. The indexes in the string start from zero, so the first character of the year is available by index 6, and the last character by index 9. Check: + +```python +value = '12-08-2034' + +print(value[6]) # => 2 +print(value[9]) # => 4 +``` + +Knowing these indices, we can use slices and get the desired substring: + +```python +value = '12-08-2034' + +year = value[6:10] +print(year) # => 2034 +``` + +**String Slices** in Python is a mechanism by which you extract a substring by specified parameters. In the example above, we took the substring from index 6 through index 10, not including, that is, 6 through 9 inclusive. The formula looks like this: + +```python +str[start index:end index] + +# A couple of examples +value = '01-12-9873' + +# A line cut is always a line, +# even if there was a number inside the string. +value[1:2] # '1' +value[3:5] # '12' +``` + +Cuts are a mechanism with many variations. For example, if you do not specify the second boundary, the extraction will happen before the end of the string. It is the same with the first boundary - the beginning of the string: + +```python +value = 'Hexlet' +value[3:] # 'let' +value[:3] # 'Hex' +``` + +You can even specify negative indices. In this case the counting goes from the reverse side: + +```python +value = 'Hexlet' +# The right boundary is negative. Count -1 from the end of the line +value[3:-1] # 'le' +# The left boundary is negative. We count -5 from the end of the line +value[-5:3] # 'ex' +``` + +Slices have two mandatory parameters, but sometimes a third is used. + +Slices have a third optional parameter - **extraction step**. By default it is one, but we can change it: + +```python +value = 'Hexlet' +value[1:5:2] # el +# 1:5 это 'exle' +# step 2 is every second, that is, 'e' and 'l' +``` + +All of these can be combined with open boundaries, that is, without specifying the beginning or end: + +```python +value = 'Hexlet' +value[:5:2] # 'Hxe' +value[1::2] # 'elt' +``` + +The step can be negative, in which case it is taken from the end. From this follows the most popular way to use the step - **reverse the string**: + +```python +value = 'Hexlet' +# Skipping both borders +value[::-1] # 'telxeH' +``` + +If a negative step is used, and the slice elements are extracted in reverse order, then the slice boundaries should also be specified in reverse order. The right slice boundary is specified first, and the left one is specified second: + +```python +value = 'Hexlet' +# The character with index 1 will not be included in the substring +value[4:1:-1] # 'elx' +``` + +The cuts can be specified not only through numbers, but also using variables: + +```python +value = 'Hexlet' +start = 1 +end = 5 +value[start:end] # 'exle' +``` + +As you can see, slices can do a lot. Don't worry if you don't memorize all these combinations right now-it's okay. Over time, you'll learn how to use them without having to peek at the documentation. diff --git a/modules/31-advanced-strings/70-slices/en/data.yml b/modules/31-advanced-strings/70-slices/en/data.yml new file mode 100644 index 00000000..8d015399 --- /dev/null +++ b/modules/31-advanced-strings/70-slices/en/data.yml @@ -0,0 +1,2 @@ +name: Line slices +tips: [] diff --git a/modules/31-advanced-strings/70-slices/es/EXERCISE.md b/modules/31-advanced-strings/70-slices/es/EXERCISE.md new file mode 100644 index 00000000..e12fbcc0 --- /dev/null +++ b/modules/31-advanced-strings/70-slices/es/EXERCISE.md @@ -0,0 +1,2 @@ + +La variable `value` contiene el valor `Hexlet`. Extrae y muestra en pantalla un recorte que obtenga la subcadena `xle` de ella. Puedes hacer esto de diferentes maneras. diff --git a/modules/31-advanced-strings/70-slices/es/README.md b/modules/31-advanced-strings/70-slices/es/README.md new file mode 100644 index 00000000..2d190afe --- /dev/null +++ b/modules/31-advanced-strings/70-slices/es/README.md @@ -0,0 +1,118 @@ + +Cuando trabajamos con cadenas en programación, a menudo necesitamos extraer una parte de ellas. Por ejemplo, necesitamos determinar si una subcadena está presente dentro de una cadena más grande. En esta lección aprenderemos cómo hacerlo. + +Una **subcadena** es una parte de una cadena que se debe encontrar y extraer. + +Supongamos que tenemos una fecha en el siguiente formato: *12-08-2034*. Necesitamos extraer de ella la subcadena que contiene solo el año. + +Si pensamos lógicamente, debemos calcular el índice del carácter donde comienza el año y luego extraer cuatro caracteres. Los índices en una cadena comienzan desde cero, lo que significa que el primer carácter del año está disponible en el índice 6, y el último carácter está disponible en el índice 9. Verifiquemos: + +```python +value = '12-08-2034' + +print(value[6]) # => 2 +print(value[9]) # => 4 +``` + +Conociendo estos índices, podemos usar recortes para obtener la subcadena deseada: + +```python +value = '12-08-2034' + +year = value[6:10] +print(year) # => 2034 +``` + +Los **recortes de cadenas** en Python son un mecanismo mediante el cual se extrae una subcadena según los parámetros especificados. En el ejemplo anterior, tomamos una subcadena desde el índice 6 hasta el índice 10, sin incluirlo, es decir, desde el 6 hasta el 9 inclusive. La fórmula se ve así: + +```python +str[inicio:fin] + +# Algunos ejemplos +value = '01-12-9873' + +# Un recorte de cadena siempre es una cadena, +# incluso si el contenido original era un número. +value[1:2] # '1' +value[3:5] # '12' +``` + +Los recortes tienen muchas variaciones. Por ejemplo, si no se especifica el límite final, se extraerá hasta el final de la cadena. Lo mismo ocurre con el límite inicial, que es el comienzo de la cadena: + +```python +value = 'Hexlet' +value[3:] # 'let' +value[:3] # 'Hex' +``` + +Incluso se pueden usar índices negativos. En este caso, el conteo se realiza desde el final: + +```python +value = 'Hexlet' +# El límite derecho es negativo. Restamos 1 desde el final de la cadena +value[3:-1] # 'le' +# El límite izquierdo es negativo. Restamos 5 desde el final de la cadena +value[-5:3] # 'ex' +``` + +Los recortes tienen dos parámetros obligatorios, pero a veces se usa un tercer parámetro. + +Los recortes tienen un tercer parámetro opcional llamado **paso de extracción**. Por defecto, es igual a uno, pero podemos cambiarlo: + +```python +value = 'Hexlet' +value[1:5:2] # el +# 1:5 es 'exle' +# paso 2 significa cada segundo, es decir, 'e' y 'l' +``` + +Todo esto se puede combinar con límites abiertos, es decir, sin especificar el inicio o el final: + +```python +value = 'Hexlet' +value[:5:2] # 'Hxe' +value[1::2] # 'elt' +``` + +El paso puede ser negativo, en cuyo caso se toma desde el final. Esto lleva al uso más común del paso: **invertir una cadena**: + +```python +value = 'Hexlet' +# Omitimos ambos límites +value[::-1] # 'telxeH' +``` + +Si se utiliza un paso negativo y los elementos del recorte se extraen en orden inverso, entonces los límites del recorte también deben especificarse en orden inverso. El límite derecho se especifica primero, seguido del límite izquierdo: + +```python +value = 'Hexlet' +# El carácter con índice 1 no se incluirá en la subcadena +value[4:1:-1] # 'elx' +``` + +Los recortes se pueden especificar no sólo con números, sino también con variables: + +```python +value = 'Hexlet' +start = 1 +end = 5 +value[start:end] # 'exle' +``` + +https://replit.com/@hexlet/python-basics-advanced-strings-slices + +Resumiendo todo: + +```python +value = 'Hexlet' +value[::] = 'Hexlet' # Toda la cadena +value[:] = 'Hexlet' # Toda la cadena +value[::2] = 'Hxe' # Caracteres en posiciones pares +value[1::2] = 'elt' # Caracteres en posiciones impares +value[::-1] = 'telxeH' # Toda la cadena en orden inverso +value[5:] = 't' # Cadena a partir del sexto carácter +value[:5] = 'Hexle' # Cadena hasta el sexto carácter +value[-2:1:-1] = 'elx' # Todos los caracteres desde el penúltimo hasta el tercero en orden inverso. En todos los casos, al seleccionar desde un índice mayor a uno menor, se debe especificar el paso +``` + +Como puedes ver, los recortes pueden hacer muchas cosas. No te preocupes si no recuerdas todas estas combinaciones en este momento, es normal. Con el tiempo aprenderás a usarlos sin consultar la documentación. diff --git a/modules/31-advanced-strings/70-slices/es/data.yml b/modules/31-advanced-strings/70-slices/es/data.yml new file mode 100644 index 00000000..521568df --- /dev/null +++ b/modules/31-advanced-strings/70-slices/es/data.yml @@ -0,0 +1,10 @@ +name: Recortes de cadenas +tips: + - > + [Más información sobre recortes en + Python](https://www.w3schools.com/python/python_strings_slicing.asp) +definitions: + - name: Recortes de cadenas + description: >- + mecanismo mediante el cual se extrae una subcadena según los parámetros + especificados. diff --git a/modules/31-advanced-strings/70-slices/ru/EXERCISE.md b/modules/31-advanced-strings/70-slices/ru/EXERCISE.md new file mode 100644 index 00000000..f016b2e5 --- /dev/null +++ b/modules/31-advanced-strings/70-slices/ru/EXERCISE.md @@ -0,0 +1,2 @@ + +В переменной `value` лежит значение `Hexlet`. Извлеките из него и выведите на экран срез, который получит подстроку `xle`. Это задание можно сделать разными способами. diff --git a/modules/31-advanced-strings/70-slices/ru/README.md b/modules/31-advanced-strings/70-slices/ru/README.md new file mode 100644 index 00000000..702d9bdf --- /dev/null +++ b/modules/31-advanced-strings/70-slices/ru/README.md @@ -0,0 +1,118 @@ + +Когда мы работаем со строками в программировании, из них регулярно приходится извлекать некую часть. Например, нам нужно выяснить, присутствует ли меньшая строка внутри большей. В этом уроке мы разберемся, как это сделать. + +**Подстрока** — это некоторая часть строки, которую нужно найти и извлечь. + +Представим, что у нас есть дата в таком формате: *12-08-2034*. Нам нужно извлечь из нее подстроку, в которую входит только год. + +Если подумать логически, то нужно посчитать индекс символа, с которого начинается год, и затем извлечь четыре символа. Индексы в строке начинаются с нуля, значит, первый символ года доступен по индексу 6, а последний символ — по индексу 9. Проверим: + +```python +value = '12-08-2034' + +print(value[6]) # => 2 +print(value[9]) # => 4 +``` + +Зная эти индексы, мы можем воспользоваться срезами и получить нужную подстроку: + +```python +value = '12-08-2034' + +year = value[6:10] +print(year) # => 2034 +``` + +**Срезы для строк** в Python — это механизм, с помощью которого извлекается подстрока по указанным параметрам. В примере выше мы взяли подстроку с 6 индекса по 10 индекс, не включая, то есть с 6 по 9 включительно. Формула выглядит так: + +```python +str[начальный индекс:конечный индекс] + +# Пара примеров +value = '01-12-9873' + +# Срез строки это всегда строка, +# даже если внутри строки было число. +value[1:2] # '1' +value[3:5] # '12' +``` + +Срезы — механизм с большим количеством вариаций. Например, если не указать вторую границу, то извлечение произойдет до конца строки. То же самое с первой границей — началом строки: + +```python +value = 'Hexlet' +value[3:] # 'let' +value[:3] # 'Hex' +``` + +Можно указать даже отрицательные индексы. В таком случае отсчет идет с обратной стороны: + +```python +value = 'Hexlet' +# Правая граница отрицательная. Считаем -1 от конца строки +value[3:-1] # 'le' +# Левая граница отрицательная. Считаем -5 от конца строки +value[-5:3] # 'ex' +``` + +У срезов два обязательных параметра, но иногда используется и третий. + +У срезов есть третий необязательный параметр — **шаг извлечения**. По умолчанию он равен единице, но мы можем его изменить: + +```python +value = 'Hexlet' +value[1:5:2] # el +# 1:5 это 'exle' +# шаг 2 это каждый второй, то есть 'e' и 'l' +``` + +Все это можно комбинировать с открытыми границами, то есть без указания начала или конца: + +```python +value = 'Hexlet' +value[:5:2] # 'Hxe' +value[1::2] # 'elt' +``` + +Шаг может быть отрицательным, в таком случае он берется с конца. Из этого вытекает самый популярный способ использования шага — **переворот строки**: + +```python +value = 'Hexlet' +# Пропускаем обе границы +value[::-1] # 'telxeH' +``` + +Если используется отрицательный шаг, и элементы среза извлекаются в обратном порядке — тогда и границы среза тоже нужно указывать в обратном порядке. Первой указывается правая граница среза, второй — левая: + +```python +value = 'Hexlet' +# Символ с индексом 1 не будет включен в подстроку +value[4:1:-1] # 'elx' +``` + +Срезы можно указывать не только через числа, но и с использованием переменных: + +```python +value = 'Hexlet' +start = 1 +end = 5 +value[start:end] # 'exle' +``` + +https://replit.com/@hexlet/python-basics-advanced-strings-slices + +Соберем все вместе: + +```python +value = 'Hexlet' +value[::] = 'Hexlet' # Вся строка +value[:] = 'Hexlet' # Вся строка +value[::2] = 'Hxe' # Четные по порядку символы +value[1::2] = 'elt' # Нечетные по порядку символы +value[::-1] = 'telxeH' # Вся строка в обратном порядке +value[5:] = 't' # Строка, начиная с шестого символа +value[:5] = 'Hexle' # Строка до шестого символа +value[-2:1:-1] = 'elx' # Все символы с предпоследнего до третьего в обратном порядке. Во всех случаях выборки от большего индекса к меньшему нужно указывать шаг +``` + +Как видите, срезы способны на многое. Не переживайте, если прямо сейчас не запомните все эти комбинации — это нормально. Со временем вы научитесь их использовать, не подглядывая в документацию. diff --git a/modules/31-advanced-strings/70-slices/ru/data.yml b/modules/31-advanced-strings/70-slices/ru/data.yml new file mode 100644 index 00000000..704b30d8 --- /dev/null +++ b/modules/31-advanced-strings/70-slices/ru/data.yml @@ -0,0 +1,10 @@ +name: Срезы строк +tips: + - > + [Подробнее о срезах в + Python](https://www.w3schools.com/python/python_strings_slicing.asp) +definitions: + - name: Срезы для строк + description: >- + механизм, с помощью которого извлекается подстрока по указанным + параметрам. diff --git a/modules/31-advanced-strings/90-multiline-strings/en/EXERCISE.md b/modules/31-advanced-strings/90-multiline-strings/en/EXERCISE.md new file mode 100644 index 00000000..390fd696 --- /dev/null +++ b/modules/31-advanced-strings/90-multiline-strings/en/EXERCISE.md @@ -0,0 +1,9 @@ + +Write the text below into the `text` variable. Use triple quotes. + +``` +Lannister, Targaryen, Baratheon, Stark, Tyrell... +they're all just spokes on a wheel. +This one's on top, then that one's on top, and on and on it spins, +crushing those on the ground. +``` diff --git a/modules/31-advanced-strings/90-multiline-strings/en/README.md b/modules/31-advanced-strings/90-multiline-strings/en/README.md new file mode 100644 index 00000000..066242a1 --- /dev/null +++ b/modules/31-advanced-strings/90-multiline-strings/en/README.md @@ -0,0 +1,70 @@ + +Imagine that we need to define a string that consists of several lines - that is, there are string translations `\n` inside. For example, it would look like this: + +```python +text = 'Example of a text,\nconsisting of\nfew lines' +``` + +The line will look very different in print: + +```bash +Example text, +consisting of +several lines +``` + +For such situations Python has another way of creating strings called **multi-line strings**. To describe such a «multi-line string», you need to put it in triple quotes — `"""` or `'''`. Inside the multi-line you can transfer the text and not use a line break `\n`: + +```python +text = ''' Example text, +consisting of +several lines +''' +``` + +```bash +Example text, +consisting of +several lines + +``` + +Notice that there is a blank line at the end of the text. It appears in the text because we put closing quotes `'''` on a new line. If you don't move the closing quotation marks to a new line, there will be no empty line in the text: + +```python +text = ''' Example text, +consisting of +several lines''' +``` + +```bash +Example text, +consisting of +several lines +``` + +Because of the triple quotes, multi-line strings allow you not to escape quotes within a string: + +```bash +There is no need to escape the 'single' and 'double' quotes +``` + +Even multi-line strings can become f-string for interpolation: + +```python +a = 'A' +b = 'B' + +# On the left was added f +text = f'''{a} и {b} +sitting on a pipe +''' +``` + +```bash +А and B +sitting on a pipe + +``` + +The computer doesn't care what kind of linking and line feeds you use. It will still do the calculations and give you the result you want. Interpolation and multi-line strings are used to make it easier for developers to read code. diff --git a/modules/31-advanced-strings/90-multiline-strings/en/data.yml b/modules/31-advanced-strings/90-multiline-strings/en/data.yml new file mode 100644 index 00000000..b9d0ccc0 --- /dev/null +++ b/modules/31-advanced-strings/90-multiline-strings/en/data.yml @@ -0,0 +1,3 @@ +name: Multi-line strings +definitions: [] +tips: [] diff --git a/modules/31-advanced-strings/90-multiline-strings/es/EXERCISE.md b/modules/31-advanced-strings/90-multiline-strings/es/EXERCISE.md new file mode 100644 index 00000000..dd1e01f4 --- /dev/null +++ b/modules/31-advanced-strings/90-multiline-strings/es/EXERCISE.md @@ -0,0 +1,9 @@ + +Asigna el siguiente texto a la variable `text` utilizando triples comillas. + +``` +Lannister, Targaryen, Baratheon, Stark, Tyrell... +they're all just spokes on a wheel. +This one's on top, then that one's on top, and on and on it spins, +crushing those on the ground. +``` diff --git a/modules/31-advanced-strings/90-multiline-strings/es/README.md b/modules/31-advanced-strings/90-multiline-strings/es/README.md new file mode 100644 index 00000000..98ad755c --- /dev/null +++ b/modules/31-advanced-strings/90-multiline-strings/es/README.md @@ -0,0 +1,70 @@ + +Imagina que necesitamos definir una cadena que consta de varias líneas, es decir, que contiene saltos de línea `\n`. Por ejemplo, se vería así: + +```python +text = 'Ejemplo de texto,\ncompuesto por\nvarias líneas' +``` + +Al imprimir la cadena, se mostrará de la siguiente manera: + +```bash +Ejemplo de texto, +compuesto por +varias líneas +``` + +Para este tipo de situaciones, en Python existe otra forma de crear cadenas llamada **cadenas de varias líneas**. Para definir una cadena de varias líneas, debemos encerrarla entre triples comillas `"""` o `'''`. Dentro de una cadena de varias líneas, podemos agregar texto sin necesidad de utilizar saltos de línea `\n`: + +```python +text = '''Ejemplo de texto, +compuesto por +varias líneas +''' +``` + +```bash +Ejemplo de texto, +compuesto por +varias líneas + +``` + +Observa que al final del texto hay una línea vacía. Esto se debe a que colocamos las comillas de cierre `'''` en una nueva línea. Si no colocamos las comillas de cierre en una nueva línea, la cadena no tendrá una línea vacía: + +```python +text = '''Ejemplo de texto, +compuesto por +varias líneas''' +``` + +```bash +Ejemplo de texto, +compuesto por +varias líneas +``` + +Gracias a las triples comillas, no es necesario escapar las comillas dentro de la cadena: + +```bash +Aquí no es necesario escapar las comillas 'simples' o "dobles" +``` + +Además, las cadenas de varias líneas pueden ser utilizadas como f-strings para interpolación: + +```python +a = 'A' +b = 'B' + +# Se agregó una f al inicio +text = f'''{a} y {b} +se sentaron en un tubo +''' +``` + +```bash +A y B +se sentaron en un tubo + +``` + +Para la computadora no importa qué método de concatenación y saltos de línea utilices. De todas formas, realizará los cálculos y mostrará el resultado correcto. La interpolación y las cadenas de varias líneas se utilizan para facilitar la lectura del código por parte de los desarrolladores. diff --git a/modules/31-advanced-strings/90-multiline-strings/es/data.yml b/modules/31-advanced-strings/90-multiline-strings/es/data.yml new file mode 100644 index 00000000..fa768c90 --- /dev/null +++ b/modules/31-advanced-strings/90-multiline-strings/es/data.yml @@ -0,0 +1,6 @@ +name: Cadenas de varias líneas +definitions: [] +tips: + - > + [Cadenas de varias + líneas](https://www.w3schools.com/python/gloss_python_multi_line_strings.asp) diff --git a/modules/31-advanced-strings/90-multiline-strings/ru/EXERCISE.md b/modules/31-advanced-strings/90-multiline-strings/ru/EXERCISE.md new file mode 100644 index 00000000..2e658ad9 --- /dev/null +++ b/modules/31-advanced-strings/90-multiline-strings/ru/EXERCISE.md @@ -0,0 +1,9 @@ + +Запишите в переменную `text` текст, который приведен ниже. Используйте тройные кавычки. + +``` +Lannister, Targaryen, Baratheon, Stark, Tyrell... +they're all just spokes on a wheel. +This one's on top, then that one's on top, and on and on it spins, +crushing those on the ground. +``` diff --git a/modules/31-advanced-strings/90-multiline-strings/ru/README.md b/modules/31-advanced-strings/90-multiline-strings/ru/README.md new file mode 100644 index 00000000..a89f9730 --- /dev/null +++ b/modules/31-advanced-strings/90-multiline-strings/ru/README.md @@ -0,0 +1,70 @@ + +Представьте, что нам нужно определить строку, которая состоит из нескольких строчек — то есть внутри есть переводы строки `\n`. Например, она будет выглядеть так: + +```python +text = 'Пример текста,\nсостоящего из\nнескольких строк' +``` + +На печати строка примет совсем другой вид: + +```bash +Пример текста, +состоящего из +нескольких строк +``` + +Для таких ситуаций в Python есть еще один способ создания строк, который называется **multi-line строки**. Чтобы описать такую «многострочную строку», нужно заключить ее в тройные кавычки — `"""` или `'''`. Внутри multi-line строки можно переносить текст и не использовать перевод строки `\n`: + +```python +text = '''Пример текста, +состоящего из +нескольких строк +''' +``` + +```bash +Пример текста, +состоящего из +нескольких строк + +``` + +Обратите внимание, что в конце текста есть пустая строка. Она появилась в тексте потому, что мы поставили закрывающие кавычки `'''` на новой строке. Если не переносить закрывающие кавычки на новую строку, то пустая строка в тексте не появится: + +```python +text = '''Пример текста, +состоящего из +нескольких строк''' +``` + +```bash +Пример текста, +состоящего из +нескольких строк +``` + +Из-за тройных кавычек multi-line строки позволяют не экранировать кавычки внутри строки: + +```bash +Здесь не нужно экранировать 'одинарные' и "двойные" кавычки +``` + +Еще multi-line строки могут становиться f-строками для интерполяции: + +```python +a = 'A' +b = 'B' + +# Слева добавился f +text = f'''{a} и {b} +сидели на трубе +''' +``` + +```bash +А и B +сидели на трубе + +``` + +Для компьютера неважно, какие способы соединения и переноса строк вы будете использовать. Он все равно произведет вычисления и выдаст нужный результат. Интерполяция и multi-line строки используются для удобства разработчиков, чтобы им было проще читать код. diff --git a/modules/31-advanced-strings/90-multiline-strings/ru/data.yml b/modules/31-advanced-strings/90-multiline-strings/ru/data.yml new file mode 100644 index 00000000..80c528cf --- /dev/null +++ b/modules/31-advanced-strings/90-multiline-strings/ru/data.yml @@ -0,0 +1,6 @@ +name: Multi-line строки +definitions: [] +tips: + - > + [Multi-line + строки](https://www.w3schools.com/python/gloss_python_multi_line_strings.asp) diff --git a/modules/33-data-types/40-primitive-data-types/en/EXERCISE.md b/modules/33-data-types/40-primitive-data-types/en/EXERCISE.md new file mode 100644 index 00000000..a4eaba0e --- /dev/null +++ b/modules/33-data-types/40-primitive-data-types/en/EXERCISE.md @@ -0,0 +1 @@ +Display the number `-0.304`. diff --git a/modules/33-data-types/40-primitive-data-types/en/README.md b/modules/33-data-types/40-primitive-data-types/en/README.md new file mode 100644 index 00000000..1473d0e2 --- /dev/null +++ b/modules/33-data-types/40-primitive-data-types/en/README.md @@ -0,0 +1,24 @@ + +There are different ways to represent data in programs. There are **strings** - sets of characters in quotes like `"Hello, World!"`. There are **integers** - for example, `7`, `-198`, `0`. These are two different categories of information - two different **types of data**. The multiplication operation makes sense for the “integers” category, but not for the “strings” category: it makes no sense to multiply the word “mom” by the word “notepad”. + +The data type determines what can be done with the elements of a particular set of information. In this lesson we'll learn about data types and how typing works in Python. + +The programming language recognizes data types, so Python won't let us multiply a string by another string - you can't multiply text by text. You can multiply an integer by another integer. The existence of types and these restrictions in the language protects programs from accidental errors. + +Unlike strings, numbers don't need to be wrapped in quotes. To print the number 5, all you have to do is write: + +```python +print(5) # => 5 +``` + +The number `5` and the string `'5'` are completely different things, although the output given by `print()` for this data is identical. Whole numbers (`1`, `34`, `-19`, etc.) and rational numbers (`1.3`, `1.0`, `14.324`, etc.) are two separate **types of data**. This division is due to the peculiarities of how computers are set up. There are other types, which we'll get to know later. + +Here's another example, but with a rational number: + +```python +print(10.234) # => 10.234 +``` + +The data types “string”, “integer” and “rational number” are *primitive types*, i.e., they're built into the Python language itself. Some composite types are also built into the language, but for now, we'll only be working with the primitive ones. Programmers can also create their own data types. + +In English, strings in programming are called strings, and lines in text files are called lines. For example, in the code above there is a line, but no strings. In Russian there can sometimes be confusion, so in all the lessons we will say **string** to indicate the data type "string", and **string** to indicate lines in the code (lines) in the files. diff --git a/modules/33-data-types/40-primitive-data-types/en/data.yml b/modules/33-data-types/40-primitive-data-types/en/data.yml new file mode 100644 index 00000000..a5c89364 --- /dev/null +++ b/modules/33-data-types/40-primitive-data-types/en/data.yml @@ -0,0 +1,16 @@ +name: Data types +tips: + - | + [Literal](https://en.wikipedia.org/wiki/Literal_(computer_programming)) +definitions: + - name: Data type + description: >- + a set of data in a code (a kind of information). A type determines what + you can do with the elements of a particular set. For example, integers, + rational numbers, and strings are different types of data. + - name: Primitive data types + description: simple types built into the programming language itself. + - name: String + description: > + a data type that describes a character set (in other words, text) such as + `'text'` or `"text"`. diff --git a/modules/33-data-types/40-primitive-data-types/es/EXERCISE.md b/modules/33-data-types/40-primitive-data-types/es/EXERCISE.md new file mode 100644 index 00000000..50494b22 --- /dev/null +++ b/modules/33-data-types/40-primitive-data-types/es/EXERCISE.md @@ -0,0 +1 @@ +Imprime en pantalla el número `-0.304`. diff --git a/modules/33-data-types/40-primitive-data-types/es/README.md b/modules/33-data-types/40-primitive-data-types/es/README.md new file mode 100644 index 00000000..9f602cf2 --- /dev/null +++ b/modules/33-data-types/40-primitive-data-types/es/README.md @@ -0,0 +1,24 @@ + +Hay diferentes formas de representar datos en los programas. También hay **cadenas de texto** - conjuntos de caracteres entre comillas como `"Hello, World!"`. Hay **números enteros** - por ejemplo, `7`, `-198`, `0`. Estas son dos categorías diferentes de información, dos **tipos de datos** diferentes. La operación de multiplicación tiene sentido para la categoría de "números enteros", pero no para la categoría de "cadenas de texto": no tiene sentido multiplicar la palabra "mamá" por la palabra "cuaderno". + +El tipo de datos determina qué se puede hacer con los elementos de un conjunto de información específico. En esta lección, aprenderemos sobre los tipos de datos y cómo funciona la tipificación en Python. + +El lenguaje de programación reconoce los tipos de datos, por lo que Python no nos permitirá multiplicar una cadena de texto por otra cadena de texto; no se puede multiplicar texto por texto. Sin embargo, se puede multiplicar un número entero por otro número entero. La presencia de tipos y de tales restricciones en el lenguaje protege a los programas de errores accidentales. + +A diferencia de las cadenas de texto, los números no necesitan estar entre comillas. Para imprimir el número 5, simplemente escriba: + +```python +print(5) # => 5 +``` + +El número `5` y la cadena de texto `'5'` son cosas completamente diferentes, aunque la salida de `print()` para estos datos es idéntica. Los números enteros (`1`, `34`, `-19`, etc.) y los números racionales (`1.3`, `1.0`, `-14.324`, etc.) son dos tipos de datos diferentes. Esta división está relacionada con las características de los ordenadores. Hay otros tipos, los conoceremos más adelante. + +Aquí hay otro ejemplo, pero esta vez con un número racional: + +```python +print(10.234) # => 10.234 +``` + +Los tipos de datos "cadena de texto", "número entero" y "número racional" son *tipos primitivos*, es decir, están incorporados en el propio lenguaje Python. El lenguaje también tiene algunos tipos compuestos incorporados, pero por ahora sólo trabajaremos con los primitivos. Los programadores también pueden crear sus propios tipos de datos. + +En inglés, las cadenas de texto en programación se llaman strings, y las líneas de texto en archivos se llaman lines. Por ejemplo, en el código anterior hay una línea (line), pero no hay cadenas de texto (strings). En el español, a veces puede haber confusión, por lo tanto, en todas las lecciones usaremos **cadena de texto** para referirnos al tipo de datos "cadena de texto", y **línea** para referirnos a las líneas de código (lines) en los archivos. diff --git a/modules/33-data-types/40-primitive-data-types/es/data.yml b/modules/33-data-types/40-primitive-data-types/es/data.yml new file mode 100644 index 00000000..00bcf466 --- /dev/null +++ b/modules/33-data-types/40-primitive-data-types/es/data.yml @@ -0,0 +1,22 @@ +name: Tipos de datos +tips: + - | + [Literal](https://en.wikipedia.org/wiki/Literal_(computer_programming)) + - > + [Artículo sobre números + decimales](https://es.wikipedia.org/wiki/N%C3%BAmero_decimal) +definitions: + - name: Tipo de datos + description: >- + un conjunto de datos en el código (una variedad de información). El tipo + determina qué se puede hacer con los elementos de un conjunto específico. + Por ejemplo, los números enteros, los números racionales, las cadenas de + texto son diferentes tipos de datos. + - name: Tipos de datos primitivos + description: >- + tipos de datos simples, incorporados en el propio lenguaje de + programación. + - name: Cadena de texto (string) + description: > + un tipo de datos que describe un conjunto de caracteres (es decir, texto), + por ejemplo, `'texto'` o `"texto"` diff --git a/modules/33-data-types/40-primitive-data-types/ru/EXERCISE.md b/modules/33-data-types/40-primitive-data-types/ru/EXERCISE.md new file mode 100644 index 00000000..f795f618 --- /dev/null +++ b/modules/33-data-types/40-primitive-data-types/ru/EXERCISE.md @@ -0,0 +1 @@ +Выведите на экран число `-0.304`. diff --git a/modules/33-data-types/40-primitive-data-types/ru/README.md b/modules/33-data-types/40-primitive-data-types/ru/README.md new file mode 100644 index 00000000..f4208f9e --- /dev/null +++ b/modules/33-data-types/40-primitive-data-types/ru/README.md @@ -0,0 +1,24 @@ + +Бывают разные способы представлять данные в программах. Есть **строки** — наборы символов в кавычках вроде `"Hello, World!"`. Есть **целые числа** — например, `7`, `-198`, `0`. Это две разные категории информации — два разных **типа данных**. Операция умножения имеет смысл для категории «целые числа», но не для категории «строки»: нет смысла умножать слово «мама» на слово «блокнот». + +Тип данных определяет, что можно делать с элементами конкретного множества информации. В этом уроке мы изучим типы данных и узнаем, как работает типизация в Python. + +Язык программирования распознает типы данных, поэтому Python не позволит нам умножать строку на строку — нельзя умножать текст на текст. При этом можно умножать целое число на другое целое число. Наличие типов и таких ограничений в языке защищает программы от случайных ошибок. + +В отличие от строк, числа оборачивать в кавычки не нужно. Чтобы напечатать число 5, достаточно написать: + +```python +print(5) # => 5 +``` + +Число `5` и строка `'5'` — совершенно разные вещи, хотя вывод у `print()` для этих данных идентичный. Целые числа (`1`, `34`, `-19` и т.д.) и рациональные числа (`1.3`, `1.0`, `-14.324` и т.д.) — это два отдельных **типа данных**. Такое разделение связано с особенностями устройства компьютеров. Есть и другие типы, с ними мы познакомимся позже. + +Вот еще один пример, но уже с рациональным числом: + +```python +print(10.234) # => 10.234 +``` + +Типы данных «строка», «целое число» и «рациональное число» — это *примитивные типы*, то есть они встроены в сам язык Python. В язык встроены также и некоторые составные типы, но пока мы будем работать только с примитивными. Программисты также могут создавать собственные типы данных. + +По-английски строки в программировании называются strings, а строчки текстовых файлов — lines. Например, в коде кода выше есть строчка (line), но нет никаких строк (strings). В русском иногда может быть путаница, поэтому во всех уроках мы будем говорить **строка** для обозначения типа данных «строка», и **строчка** для обозначения строчек кода (lines) в файлах. diff --git a/modules/33-data-types/40-primitive-data-types/ru/data.yml b/modules/33-data-types/40-primitive-data-types/ru/data.yml new file mode 100644 index 00000000..9b0c8896 --- /dev/null +++ b/modules/33-data-types/40-primitive-data-types/ru/data.yml @@ -0,0 +1,18 @@ +name: Типы данных +tips: + - > + [Литерал](https://ru.wikipedia.org/wiki/%D0%9B%D0%B8%D1%82%D0%B5%D1%80%D0%B0%D0%BB_(%D0%B8%D0%BD%D1%84%D0%BE%D1%80%D0%BC%D0%B0%D1%82%D0%B8%D0%BA%D0%B0)) + - | + [Статья о дробных числах](https://habr.com/ru/articles/112953/) +definitions: + - name: Тип данных + description: >- + множество данных в коде (разновидность информации). Тип определяет, что + можно делать с элементами конкретного множества. Например, целые числа, + рациональные числа, строки — это разные типы данных. + - name: Примитивные типы данных + description: простые типы, встроенные в сам язык программирования. + - name: Строка (string) + description: > + тип данных, описывающий набор символов (иными словами — текст) например, + `'text'` или `"text"` diff --git a/modules/33-data-types/50-strong-typing/en/EXERCISE.md b/modules/33-data-types/50-strong-typing/en/EXERCISE.md new file mode 100644 index 00000000..00a70240 --- /dev/null +++ b/modules/33-data-types/50-strong-typing/en/EXERCISE.md @@ -0,0 +1,2 @@ + +Print the result of the expression: `7 - (-8 - -2)`. Try to make the number 7 a string instead of a number. Experiment with other numbers too. diff --git a/modules/33-data-types/50-strong-typing/en/README.md b/modules/33-data-types/50-strong-typing/en/README.md new file mode 100644 index 00000000..ced542d5 --- /dev/null +++ b/modules/33-data-types/50-strong-typing/en/README.md @@ -0,0 +1,22 @@ + +Python is one of the languages that is strict about data types. So it will respond to any type incompatibility with an error. It is all about strong typing. + +We know about two different types of data: numbers and strings. For example, we could add numbers, because the addition operation is an operation for the "numbers" type. But what if we applied this operation not to two numbers, but to a number and a string? + +```python +print(1 + '7') # TypeError: unsupported operand type(s)... +``` + +Python will not allow adding the number `1` and the string `'7'`, because they are of different types. You have to first either make the string a number or the number a string. We'll talk about how to do that later. + +This pedantic attitude towards type compatibility is called **strict typing** or **strong typing**. Python is a language with strict typing. + +Not all languages do this. For example, PHP is a language with **weak typing**. It is aware of the existence of different types, but is not very strict about their use. PHP tries to convert information when it makes sense. The same goes for JavaScript: + +```javascript +// What do you think of that, Elon Musk? +// Number 1 + Line 7 = Line 17 +1 + '7'; // '17' +``` + +On the one hand, automatic implicit type conversion does seem convenient. But in practice this language's property creates a lot of errors and problems that are hard to find. The code may sometimes work and sometimes not work, depending on whether you have "luck" with automatic conversion or not. The programmer will not notice this immediately and will spend a lot of time on debugging. diff --git a/modules/33-data-types/50-strong-typing/en/data.yml b/modules/33-data-types/50-strong-typing/en/data.yml new file mode 100644 index 00000000..c4a4feae --- /dev/null +++ b/modules/33-data-types/50-strong-typing/en/data.yml @@ -0,0 +1,2 @@ +name: Strong (or Strict) Typing +tips: [] diff --git a/modules/33-data-types/50-strong-typing/es/EXERCISE.md b/modules/33-data-types/50-strong-typing/es/EXERCISE.md new file mode 100644 index 00000000..d8961e11 --- /dev/null +++ b/modules/33-data-types/50-strong-typing/es/EXERCISE.md @@ -0,0 +1,2 @@ + +Muestre en pantalla el resultado de la expresión: `7 - (-8 - -2)`. Intente hacer que el número 7 sea una cadena de texto en lugar de un número. ¿Funcionará este código? Experimente también con otros números. diff --git a/modules/33-data-types/50-strong-typing/es/README.md b/modules/33-data-types/50-strong-typing/es/README.md new file mode 100644 index 00000000..35724efb --- /dev/null +++ b/modules/33-data-types/50-strong-typing/es/README.md @@ -0,0 +1,22 @@ + +Python es uno de los lenguajes que se adhiere estrictamente a los tipos de datos. Por lo tanto, cualquier incompatibilidad de tipos será respondida con un error. Todo esto se debe al tipado fuerte. + +Conocemos dos tipos de datos diferentes: números y cadenas de texto. Por ejemplo, podemos sumar números porque la operación de suma es una operación para el tipo "número". Pero, ¿qué sucede si aplicamos esta operación a un número y una cadena de texto? + +```python +print(1 + '7') # TypeError: unsupported operand type(s)... +``` + +Python no permitirá sumar el número `1` y la cadena de texto `'7'`, ya que son valores de tipos diferentes. Primero debemos convertir la cadena de texto en un número o el número en una cadena de texto. Hablaremos sobre cómo hacer esto más adelante. + +Este enfoque meticuloso hacia la compatibilidad de tipos se llama **tipado estricto** o **tipado fuerte**. Python es un lenguaje con tipado fuerte. + +No todos los lenguajes funcionan de esta manera. Por ejemplo, PHP es un lenguaje con **tipado débil**. Conoce la existencia de diferentes tipos, pero no se adhiere a su uso de manera estricta. PHP intenta convertir la información cuando parece razonable. Lo mismo ocurre con JavaScript: + +```javascript +// ¿Qué te parece, Elon Musk? +// Número 1 + Cadena de texto 7 = Cadena de texto 17 +1 + '7'; // '17' +``` + +Por un lado, la conversión automática e implícita de tipos puede parecer conveniente. Pero en la práctica, esta característica del lenguaje crea muchos errores y problemas difíciles de encontrar. El código puede funcionar a veces y otras veces no, dependiendo de si la conversión automática tuvo "suerte". El programador no se dará cuenta de esto de inmediato y perderá mucho tiempo depurando. diff --git a/modules/33-data-types/50-strong-typing/es/data.yml b/modules/33-data-types/50-strong-typing/es/data.yml new file mode 100644 index 00000000..caec09d7 --- /dev/null +++ b/modules/33-data-types/50-strong-typing/es/data.yml @@ -0,0 +1,4 @@ +name: Tipado fuerte (o estricto) +tips: + - | + [Tipado](https://en.wikipedia.org/wiki/Strong_and_weak_typing) diff --git a/modules/33-data-types/50-strong-typing/ru/EXERCISE.md b/modules/33-data-types/50-strong-typing/ru/EXERCISE.md new file mode 100644 index 00000000..d5e2d6b3 --- /dev/null +++ b/modules/33-data-types/50-strong-typing/ru/EXERCISE.md @@ -0,0 +1,2 @@ + +Выведите на экран результат выражения: `7 - (-8 - -2)`. Попробуйте сделать число 7 не числом, а строкой. Сработает ли такой код? Поэкспериментируйте с другими числами тоже. diff --git a/modules/33-data-types/50-strong-typing/ru/README.md b/modules/33-data-types/50-strong-typing/ru/README.md new file mode 100644 index 00000000..469046d1 --- /dev/null +++ b/modules/33-data-types/50-strong-typing/ru/README.md @@ -0,0 +1,22 @@ + +Python — один из языков, который строго относится к типам данных. Поэтому на любую несовместимость типов он ответит ошибкой. Все дело в сильной типизации. + +Нам известно про два разных типа данных: числа и строки. Например, мы могли складывать числа, потому что операция сложения — это операция для типа «числа». А что, если применить эту операцию не к двум числам, а к числу и строке? + +```python +print(1 + '7') # TypeError: unsupported operand type(s)... +``` + +Python не разрешит сложить число `1` и строку `'7'`, потому что это значения разных типов. Нужно сначала либо сделать строку числом, либо число строкой. Как это сделать, мы поговорим позже. + +Такое педантичное отношение к совместимости типов называется **строгой типизацией** или **сильной типизацией**. Python — язык со строгой типизацией. + +Не все языки так делают. Например, PHP — это язык со **слабой типизацией**. Он знает о существовании разных типов, но относится к их использованию не очень строго. PHP пытается преобразовывать информацию, когда это кажется разумным. То же самое относится к JavaScript: + +```javascript +// Как тебе такое, Илон Маск? +// Число 1 + Строка 7 = Строка 17 +1 + '7'; // '17' +``` + +С одной стороны, автоматическое неявное преобразование типов и правда кажется удобным. Но на практике это свойство языка создает множество ошибок и проблем, которые трудно найти. Код может иногда работать, а иногда не работать — в зависимости от того, «повезло» ли с автоматическим преобразованием. Программист это заметит не сразу и потратит много времени на отладку. diff --git a/modules/33-data-types/50-strong-typing/ru/data.yml b/modules/33-data-types/50-strong-typing/ru/data.yml new file mode 100644 index 00000000..147db092 --- /dev/null +++ b/modules/33-data-types/50-strong-typing/ru/data.yml @@ -0,0 +1,4 @@ +name: Сильная (или Строгая) типизация +tips: + - | + [Типизация](https://ru.wikipedia.org/wiki/Сильная_и_слабая_типизация) diff --git a/modules/33-data-types/52-data-types-immutability/en/EXERCISE.md b/modules/33-data-types/52-data-types-immutability/en/EXERCISE.md new file mode 100644 index 00000000..3d563d37 --- /dev/null +++ b/modules/33-data-types/52-data-types-immutability/en/EXERCISE.md @@ -0,0 +1,9 @@ +You are given three variables with the names of different people. Make and display a word of characters in this order: + +1. The third character from the first line +2. The second character from the second line +3. The fourth character from the third line +4. The fifth character of the second line +5. The third character from the second line + +Try using interpolation: not only whole variables can be placed inside curly brackets, but also individual characters using square brackets. diff --git a/modules/33-data-types/52-data-types-immutability/en/README.md b/modules/33-data-types/52-data-types-immutability/en/README.md new file mode 100644 index 00000000..3c57f1b2 --- /dev/null +++ b/modules/33-data-types/52-data-types-immutability/en/README.md @@ -0,0 +1,20 @@ + +Imagine that we need to change a character in a string. This is what will come out of it: + +```python +first_name = 'Alexander' +first_name[0] = 'B' +# Error: TypeError: 'str' object does not support item assignment +``` + +This happens because of the immutability of primitive types in Python - the language does not give any physical possibility to change the string. The immutability of primitive types is important for many reasons. The key reason is performance. + +But sometimes we need to change a string. That's what variables are for: + +```python +first_name = 'Alexander' +first_name = 'Blexander' +print(first_name) # => Blexander +``` + +There is a big difference between *changing the value of a variable* and *changing the value itself*. You can't change primitive types in Python, but you can change composite types. You can also change the value of a variable without any problem. diff --git a/modules/33-data-types/52-data-types-immutability/en/data.yml b/modules/33-data-types/52-data-types-immutability/en/data.yml new file mode 100644 index 00000000..5ac42264 --- /dev/null +++ b/modules/33-data-types/52-data-types-immutability/en/data.yml @@ -0,0 +1,4 @@ +name: | + The immutability of primitive types +tips: [] +definitions: [] diff --git a/modules/33-data-types/52-data-types-immutability/es/EXERCISE.md b/modules/33-data-types/52-data-types-immutability/es/EXERCISE.md new file mode 100644 index 00000000..f7aa1b76 --- /dev/null +++ b/modules/33-data-types/52-data-types-immutability/es/EXERCISE.md @@ -0,0 +1,9 @@ +Se te han dado tres variables con los apellidos de diferentes personas. Crea y muestra en pantalla una palabra con los caracteres en el siguiente orden: + +1. El tercer carácter de la primera cadena de texto +2. El segundo carácter de la segunda cadena de texto +3. El cuarto carácter de la tercera cadena de texto +4. El quinto carácter de la segunda cadena de texto +5. El tercer carácter de la segunda cadena de texto + +Intenta usar interpolación: dentro de las llaves puedes colocar no solo variables enteras, sino también caracteres individuales usando corchetes. diff --git a/modules/33-data-types/52-data-types-immutability/es/README.md b/modules/33-data-types/52-data-types-immutability/es/README.md new file mode 100644 index 00000000..f144bf47 --- /dev/null +++ b/modules/33-data-types/52-data-types-immutability/es/README.md @@ -0,0 +1,20 @@ + +Supongamos que queremos cambiar un carácter en una cadena de texto. Esto es lo que sucede: + +```python +first_name = 'Alexander' +first_name[0] = 'B' +# Error: TypeError: 'str' object does not support item assignment +``` + +Esto ocurre debido a la inmutabilidad de los tipos primitivos en Python: el lenguaje no permite cambiar una cadena de texto físicamente. La inmutabilidad de los tipos primitivos es importante por varias razones. La razón principal es el rendimiento. + +Pero a veces necesitamos cambiar una cadena de texto. Para eso existen las variables: + +```python +first_name = 'Alexander' +first_name = 'Blexander' +print(first_name) # => Blexander +``` + +Hay una gran diferencia entre *cambiar el valor de una variable* y *cambiar el valor en sí*. No se puede cambiar un tipo primitivo en Python, pero se puede cambiar un tipo compuesto. También se puede reemplazar el valor de una variable sin problemas. diff --git a/modules/33-data-types/52-data-types-immutability/es/data.yml b/modules/33-data-types/52-data-types-immutability/es/data.yml new file mode 100644 index 00000000..56b30e6c --- /dev/null +++ b/modules/33-data-types/52-data-types-immutability/es/data.yml @@ -0,0 +1,8 @@ +name: | + Inmutabilidad de los tipos de datos primitivos +tips: [] +definitions: + - name: Inmutabilidad + description: > + estado en el que un objeto o variable no puede ser cambiado después de su + creación diff --git a/modules/33-data-types/52-data-types-immutability/ru/EXERCISE.md b/modules/33-data-types/52-data-types-immutability/ru/EXERCISE.md new file mode 100644 index 00000000..84a74e82 --- /dev/null +++ b/modules/33-data-types/52-data-types-immutability/ru/EXERCISE.md @@ -0,0 +1,9 @@ +Вам даны три переменные с фамилиями разных людей. Составьте и выведите на экран слово из символов в таком порядке: + +1. Третий символ из первой строки +2. Второй символ из второй строки +3. Четвертый символ из третьей строки +4. Пятый символ из второй строки +5. Третий символ из второй строки + +Попробуйте использовать интерполяцию: внутри фигурных скобок можно помещать не только целые переменные, но и отдельные символы с помощью квадратных скобок. diff --git a/modules/33-data-types/52-data-types-immutability/ru/README.md b/modules/33-data-types/52-data-types-immutability/ru/README.md new file mode 100644 index 00000000..c4f360ac --- /dev/null +++ b/modules/33-data-types/52-data-types-immutability/ru/README.md @@ -0,0 +1,20 @@ + +Представим, что нам нужно изменить символ в строке. Вот, что из этого выйдет: + +```python +first_name = 'Alexander' +first_name[0] = 'B' +# Ошибка: TypeError: 'str' object does not support item assignment +``` + +Такое происходит из-за неизменяемости примитивных типов в Python — язык не дает никакой физической возможности поменять строку. Неизменяемость примитивных типов важна по многим причинам. Ключевая причина — производительность. + +Но иногда нам нужно изменить строку. Для этого и существуют переменные: + +```python +first_name = 'Alexander' +first_name = 'Blexander' +print(first_name) # => Blexander +``` + +Есть большая разница между *изменением значения переменной* и *изменением самого значения*. Примитивные типы в Python поменять нельзя, а составные — можно. Также можно без проблем заменить значение переменной. diff --git a/modules/33-data-types/52-data-types-immutability/ru/data.yml b/modules/33-data-types/52-data-types-immutability/ru/data.yml new file mode 100644 index 00000000..44476606 --- /dev/null +++ b/modules/33-data-types/52-data-types-immutability/ru/data.yml @@ -0,0 +1,8 @@ +name: | + Неизменяемость примитивных типов +tips: [] +definitions: + - name: Неизменяемость + description: > + состояние, при котором объект, переменная не могут быть изменены после + создания diff --git a/modules/33-data-types/55-data-types-casting/en/EXERCISE.md b/modules/33-data-types/55-data-types-casting/en/EXERCISE.md new file mode 100644 index 00000000..13355f1c --- /dev/null +++ b/modules/33-data-types/55-data-types-casting/en/EXERCISE.md @@ -0,0 +1,6 @@ + +Output the string `2 times` obtained from the number 2.9 (stored in the variable `value`) and the string `times` using type conversions and concatenation. To do this, perform two conversions: first to an integer and then to a string + +
+2 times
+
diff --git a/modules/33-data-types/55-data-types-casting/en/README.md b/modules/33-data-types/55-data-types-casting/en/README.md new file mode 100644 index 00000000..e33abe52 --- /dev/null +++ b/modules/33-data-types/55-data-types-casting/en/README.md @@ -0,0 +1,53 @@ + +In programming, there are regularly tasks where one type of data needs to be converted to another - for example, when working with forms on websites. Form data always comes in text form, even if the value is a number. Here's how it can be converted: + +```python +# str becomes int +number = int('345') +print(number) # => 345 +``` + +`int()` is a function into which a value is passed in order to convert it. The function behaves similarly to arithmetic operations, but does special actions. Here are a few more examples: + +```python +value = '0' +# Inside the brackets you can specify a variable +converted_value = int(value) +print(converted_value) # => 0 + +# Or a specific value +converted_value2 = int('10') +print(converted_value2) # => 10 + +converted_value3 = int(False) +print(converted_value3) # => 0 + +converted_value4 = int(True) +print(converted_value4) # => 1 + +# If a floating point number is converted +# then all the fractional part is discarded +converted_value5 = int(3.5) +print(converted_value5) # => 3 +``` + +Similarly, you can convert data into strings `str()` and floating point numbers `float()`: + +```python +value = str(10) +print(value) # '10' + +value2 = str(True) +print(value2) # 'True' + +value3 = float(5) +print(value3) # 5.0 +``` + +Python performs some conversions automatically. For example, in operations where an integer and a floating-point number occur at the same time. Python automatically converts everything to **float**, a floating-point number: + +```python +# Implicitly the code float(3) + 1.2 is executed +value = 3 + 1.2 +print(value) # => 4.2 +``` diff --git a/modules/33-data-types/55-data-types-casting/en/data.yml b/modules/33-data-types/55-data-types-casting/en/data.yml new file mode 100644 index 00000000..aa6b08c4 --- /dev/null +++ b/modules/33-data-types/55-data-types-casting/en/data.yml @@ -0,0 +1 @@ +name: Explicit type conversion diff --git a/modules/33-data-types/55-data-types-casting/es/EXERCISE.md b/modules/33-data-types/55-data-types-casting/es/EXERCISE.md new file mode 100644 index 00000000..cb648649 --- /dev/null +++ b/modules/33-data-types/55-data-types-casting/es/EXERCISE.md @@ -0,0 +1,6 @@ + +Imprime en la pantalla la cadena de texto `2 times`, obtenida a partir del número 2.9 (almacenado en la variable `value`) y la cadena de texto `times`, utilizando conversiones de tipos y concatenación. Para lograrlo, debes realizar dos conversiones: primero a un número entero y luego a una cadena de texto. + +
+2 times
+
diff --git a/modules/33-data-types/55-data-types-casting/es/README.md b/modules/33-data-types/55-data-types-casting/es/README.md new file mode 100644 index 00000000..c4d85bff --- /dev/null +++ b/modules/33-data-types/55-data-types-casting/es/README.md @@ -0,0 +1,55 @@ + +En programación, a menudo nos encontramos con situaciones en las que es necesario convertir un tipo de dato en otro, por ejemplo, al trabajar con formularios en sitios web. Los datos de los formularios siempre llegan en formato de texto, incluso si el valor es un número. Así como vemos a continuación, se puede realizar la conversión: + +```python +# str se convierte en int +number = int('345') +print(number) # => 345 +``` + +`int()` es una función a la que se le pasa un valor para convertirlo. La función se comporta de manera similar a las operaciones aritméticas, pero realiza acciones especiales. Aquí hay algunos ejemplos más: + +```python +value = '0' +# Dentro de los paréntesis se puede especificar una variable +converted_value = int(value) +print(converted_value) # => 0 + +# O un valor específico +converted_value2 = int('10') +print(converted_value2) # => 10 + +converted_value3 = int(False) +print(converted_value3) # => 0 + +converted_value4 = int(True) +print(converted_value4) # => 1 + +# Si se convierte un número de punto flotante +# se descarta la parte decimal +converted_value5 = int(3.5) +print(converted_value5) # => 3 +``` + +https://replit.com/@hexlet/python-basics-data-types-casting + +De la misma manera, se pueden convertir datos a cadenas de texto con `str()` y a números de punto flotante con `float()`: + +```python +value = str(10) +print(value) # '10' + +value2 = str(True) +print(value2) # 'True' + +value3 = float(5) +print(value3) # 5.0 +``` + +Python realiza algunas conversiones automáticamente. Por ejemplo, en operaciones donde se encuentran simultáneamente un número entero y un número de punto flotante, Python los convierte automáticamente a **float**: + +```python +# El código float(3) + 1.2 se ejecuta implícitamente +value = 3 + 1.2 +print(value) # => 4.2 +``` diff --git a/modules/33-data-types/55-data-types-casting/es/data.yml b/modules/33-data-types/55-data-types-casting/es/data.yml new file mode 100644 index 00000000..6e267f8f --- /dev/null +++ b/modules/33-data-types/55-data-types-casting/es/data.yml @@ -0,0 +1,4 @@ +name: Conversión explícita de tipos +tips: + - | + [Tipado](https://es.wikipedia.org/wiki/Tipado) diff --git a/modules/33-data-types/55-data-types-casting/ru/EXERCISE.md b/modules/33-data-types/55-data-types-casting/ru/EXERCISE.md new file mode 100644 index 00000000..3d66cb81 --- /dev/null +++ b/modules/33-data-types/55-data-types-casting/ru/EXERCISE.md @@ -0,0 +1,6 @@ + +Выведите на экран строку `2 times`, полученную из числа 2.9 (хранится в переменной `value`) и строки `times`, используя преобразования типов и конкатенацию. Для этого нужно выполнить два преобразования: сначала в целое число, а затем в строку + +
+2 times
+
diff --git a/modules/33-data-types/55-data-types-casting/ru/README.md b/modules/33-data-types/55-data-types-casting/ru/README.md new file mode 100644 index 00000000..acfc594d --- /dev/null +++ b/modules/33-data-types/55-data-types-casting/ru/README.md @@ -0,0 +1,55 @@ + +В программировании регулярно встречаются задачи, когда один тип данных нужно преобразовать в другой — например, при работе с формами на сайтах. Данные формы всегда приходят в текстовом виде, даже если значение — число. Вот как его можно преобразовать: + +```python +# str станет int +number = int('345') +print(number) # => 345 +``` + +`int()` — это функция, в которую передается значение, чтобы его преобразовать. Функция ведет себя подобно арифметическим операциям, но делает особые действия. Вот еще несколько примеров: + +```python +value = '0' +# Внутри скобок можно указывать переменную +converted_value = int(value) +print(converted_value) # => 0 + +# Или конкретное значение +converted_value2 = int('10') +print(converted_value2) # => 10 + +converted_value3 = int(False) +print(converted_value3) # => 0 + +converted_value4 = int(True) +print(converted_value4) # => 1 + +# Если преобразуется число с плавающей точкой +# то отбрасывается вся дробная часть +converted_value5 = int(3.5) +print(converted_value5) # => 3 +``` + +https://replit.com/@hexlet/python-basics-data-types-casting + +Точно так же можно преобразовать данные в строки `str()` и число с плавающей точкой `float()`: + +```python +value = str(10) +print(value) # '10' + +value2 = str(True) +print(value2) # 'True' + +value3 = float(5) +print(value3) # 5.0 +``` + +Некоторые преобразования Python выполняет автоматически. Например, в операциях, где встречается одновременно целое число и число с плавающей точкой. Python автоматически все приводит к **float** — числу с плавающей точкой: + +```python +# Неявно выполняется код float(3) + 1.2 +value = 3 + 1.2 +print(value) # => 4.2 +``` diff --git a/modules/33-data-types/55-data-types-casting/ru/data.yml b/modules/33-data-types/55-data-types-casting/ru/data.yml new file mode 100644 index 00000000..5be5413e --- /dev/null +++ b/modules/33-data-types/55-data-types-casting/ru/data.yml @@ -0,0 +1,4 @@ +name: Явное преобразование типов +tips: + - | + [Типизация](https://ru.wikipedia.org/wiki/Сильная_и_слабая_типизация) diff --git a/modules/35-calling-functions/100-call/en/EXERCISE.md b/modules/35-calling-functions/100-call/en/EXERCISE.md new file mode 100644 index 00000000..94555f33 --- /dev/null +++ b/modules/35-calling-functions/100-call/en/EXERCISE.md @@ -0,0 +1,2 @@ + +There are two variables defined in the program code that contain the names of companies. Calculate their total character length and print it. diff --git a/modules/35-calling-functions/100-call/en/README.md b/modules/35-calling-functions/100-call/en/README.md new file mode 100644 index 00000000..c3e53f43 --- /dev/null +++ b/modules/35-calling-functions/100-call/en/README.md @@ -0,0 +1,33 @@ + +Addition, concatenation, finding the remainder of a division, and the other operations discussed are basic features of programming languages. Mathematics is not limited to arithmetic, there are other sections with their own operations ⎯ e.g., geometry. The same goes for strings: you can flip them, change a letter's case, delete extra characters – and that's just the tip of the iceberg. + +And at higher levels, there's application-specific logic. Programs withdraw money, calculate taxes, and generate reports. The number of these operations is endless and different for each program. And you have to be able to express them in code. + +For expressing other operations, we have a feature in programming called **functions**. Functions can be built-in or added by the programmer. We're already familiar with one built-in function ⎯ `print()`. + +Functions are one of the key constructs in programming. Without them, it's impossible to do almost anything. It's important to get to know them as early as possible, since everything after this is going to be very function-heavy. First we'll learn how to use the functions we've already created, and then we'll learn how to create our own. + +We'll start with basic functions that handle strings. + +The `len()` function counts the number of characters in a string. Below is an example of it being called: + +```python +# Calling the function len with the parameter 'Hello! +result = len('Hello!') +print(result) # => 6 +``` + +**Parameters or arguments** are the information the function receives when it is called. Based on this information, the function usually calculates and outputs a result. + +We created a variable called `result` and gave the interpreter a specific action: we have to write into it the result returned by the `len()` function when it's called. In this sense, functions are like operations - they always return the result of their work. The entry `len('Hello!')` means that a function named *len* is called, to which the parameter `'Hello!'` is passed. The `len()` function counts the length of the string that was passed to it. + +A function call is always indicated by parentheses `()`, which come immediately after the function name. There can be any number of parameters in brackets, and sometimes none at all. The number of parameters depends on the function used. + +Take for example the `pow()` function, which increments a given number to the correct power. It takes two parameters as input: the first parameter is expanded by the degree set in the second parameter: + +```python +result = pow(2, 3) # 2 * 2 * 2 +print(result) # => 8 +``` + +We've figured out how to use the simple built-in functions. But that's not all of them. You'll learn more about functions in future lessons diff --git a/modules/35-calling-functions/100-call/en/data.yml b/modules/35-calling-functions/100-call/en/data.yml new file mode 100644 index 00000000..6b7cc82a --- /dev/null +++ b/modules/35-calling-functions/100-call/en/data.yml @@ -0,0 +1,2 @@ +name: Functions +tips: [] diff --git a/modules/35-calling-functions/100-call/es/EXERCISE.md b/modules/35-calling-functions/100-call/es/EXERCISE.md new file mode 100644 index 00000000..788c7de7 --- /dev/null +++ b/modules/35-calling-functions/100-call/es/EXERCISE.md @@ -0,0 +1,2 @@ + +En el código del programa se han definido dos variables que contienen nombres de empresas. Calcula la longitud total de los nombres en caracteres y muéstrala en pantalla. diff --git a/modules/35-calling-functions/100-call/es/README.md b/modules/35-calling-functions/100-call/es/README.md new file mode 100644 index 00000000..7130054a --- /dev/null +++ b/modules/35-calling-functions/100-call/es/README.md @@ -0,0 +1,33 @@ + +La suma, la concatenación, el cálculo del resto de la división y otras operaciones que hemos visto son capacidades básicas de los lenguajes de programación. Las matemáticas no se limitan a la aritmética; también hay otras ramas con sus propias operaciones, como la geometría. Lo mismo ocurre con las cadenas de texto: se pueden invertir, cambiar la capitulación de las letras, eliminar caracteres innecesarios, y eso es sólo lo más básico. + +Además, a un nivel más alto y profundo, existe la lógica aplicada a una aplicación específica. Los programas pueden realizar transacciones monetarias, calcular impuestos, generar informes. La cantidad de operaciones similares es infinita y depende de cada programa en particular. Y es necesario saber cómo expresarlas en código. + +Para expresar cualquier operación arbitraria, en programación existe el concepto de **función**. Las funciones pueden ser incorporadas o creadas por el programador. Ya estamos familiarizados con una función incorporada: `print()`. + +Las funciones son una de las construcciones clave en programación. Sin ellas, prácticamente no se puede hacer nada. Es importante familiarizarse con ellas lo antes posible, ya que el resto del material se basa en el uso de funciones al máximo. Primero aprenderemos a utilizar las funciones ya creadas y luego aprenderemos a crear nuestras propias funciones. + +Comenzaremos con funciones sencillas para trabajar con cadenas de texto. + +La función `len()` cuenta la cantidad de caracteres en una cadena de texto. A continuación, se muestra un ejemplo de su llamado: + +```python +# Ejecución de la función len con el parámetro 'Hello!' +result = len('Hello!') +print(result) # => 6 +``` + +**Parámetros o argumentos** son la información que una función recibe al ser ejecutada. Con base en esta información, la función generalmente realiza un cálculo y devuelve un resultado. + +Hemos creado la variable `resultado` y le hemos indicado al intérprete la acción específica: guardar en ella el resultado que devuelve la función `len()` al ser llamada. En este sentido, las funciones son similares a las operaciones, ya que siempre devuelven un resultado de su trabajo. La expresión `len('Hello!')` significa que se ejecuta la función con el nombre *len*, y se le pasa el parámetro `'Hello!'`. La función `len()` cuenta la longitud de la cadena de texto que se le ha pasado. + +La ejecución de una función siempre se indica con paréntesis `()`, que van justo después del nombre de la función. Entre los paréntesis puede haber cualquier cantidad de parámetros, o incluso ninguno. La cantidad depende de la función que se esté utilizando. + +Tomemos como ejemplo la función `pow()`, que eleva un número dado a una potencia determinada. Esta función recibe dos parámetros: toma el primer parámetro y lo eleva a la potencia que se pasa como segundo parámetro: + +```python +result = pow(2, 3) # 2 * 2 * 2 +print(result) # => 8 +``` + +Hemos aprendido cómo utilizar funciones incorporadas sencillas. Pero esta no es una lista exhaustiva de funciones. Aprenderán más sobre funciones en las próximas lecciones. diff --git a/modules/35-calling-functions/100-call/es/data.yml b/modules/35-calling-functions/100-call/es/data.yml new file mode 100644 index 00000000..55d3edf4 --- /dev/null +++ b/modules/35-calling-functions/100-call/es/data.yml @@ -0,0 +1,11 @@ +name: Funciones y su ejecución +tips: [] +definitions: + - name: Función + description: >- + operación que puede recibir datos y devolver un resultado; se llama a una + función de esta manera: `foo()`. + - name: Argumento + description: >- + información que una función recibe al ser ejecutada. Por ejemplo, + `foo(42)` es pasar el argumento `42` a la función `foo()`. diff --git a/modules/35-calling-functions/100-call/ru/EXERCISE.md b/modules/35-calling-functions/100-call/ru/EXERCISE.md new file mode 100644 index 00000000..a0576ed5 --- /dev/null +++ b/modules/35-calling-functions/100-call/ru/EXERCISE.md @@ -0,0 +1,2 @@ + +В коде программы определены две переменные, содержащие имена компаний. Посчитайте их общую длину в символах и выведите ее на экран. diff --git a/modules/35-calling-functions/100-call/ru/README.md b/modules/35-calling-functions/100-call/ru/README.md new file mode 100644 index 00000000..269188a7 --- /dev/null +++ b/modules/35-calling-functions/100-call/ru/README.md @@ -0,0 +1,33 @@ + +Сложение, конкатенация, нахождение остатка от деления и остальные рассмотренные операции — это базовые возможности языков программирования. Математика не ограничена арифметикой, кроме нее есть и другие разделы со своими операциями ⎯ например, геометрия. То же самое касается и строк: их можно переворачивать, менять регистр букв, удалять лишние символы — и это только самое простое. + +Еще на более высоком уровне есть прикладная логика конкретного приложения. Программы списывают деньги, считают налоги, формируют отчеты. Количество подобных операций бесконечно и индивидуально для каждой программы. И их нужно уметь выражать в коде. + +Чтобы выразить любую произвольную операцию, в программировании существует понятие **функция**. Функции бывают встроенные и добавленные программистом. С одной встроенной функцией мы уже знакомы ⎯ это `print()`. + +Функции — одна из ключевых конструкций в программировании. Без них невозможно сделать практически ничего. Знакомство с ними нужно начинать как можно раньше, так как весь дальнейший материал оперирует функциями по максимуму. Сначала мы научимся пользоваться уже созданными функциями, а потом научимся создавать собственные. + +Начнем с простых функций для работы над строками. + +Функция `len()` считает количество символов в строке. Ниже пример ее вызова: + +```python +# Вызов функции len с параметром 'Hello!' +result = len('Hello!') +print(result) # => 6 +``` + +**Параметры или аргументы** — это информация, которую функция получает при вызове. На основе этой информации функция обычно вычисляет и выдает результат. + +Мы создали переменную `result` и указали интерпретатору конкретное действие: надо записать в нее результат, который возвращается функцией `len()` при ее вызове. В этом смысле функции подобны операциям — они всегда возвращают результат своей работы. Запись `len('Hello!')` означает, что вызывается функция с именем *len*, в которую передали параметр `'Hello!'`. Функция `len()` считает длину той строки, которую ей передали. + +Вызов функции всегда обозначается скобками `()`, которые идут сразу за именем функции. В скобках может быть любое количество параметров, а иногда ни одного. Количество зависит от используемой функции. + +Возьмем для примера функцию `pow()`, которая возводит указанное число в нужную степень. Она принимает на вход два параметра: берет первый параметр и возводит его в степень, переданную вторым параметром: + +```python +result = pow(2, 3) # 2 * 2 * 2 +print(result) # => 8 +``` + +Мы разобрались, как пользоваться простыми встроенными функциями. Но это не весь их перечень. Больше о функциях вы узнаете в следующих уроках diff --git a/modules/35-calling-functions/100-call/ru/data.yml b/modules/35-calling-functions/100-call/ru/data.yml new file mode 100644 index 00000000..7579f514 --- /dev/null +++ b/modules/35-calling-functions/100-call/ru/data.yml @@ -0,0 +1,11 @@ +name: Функции и их вызов +tips: [] +definitions: + - name: Функция + description: >- + операция, способная принимать данные и возвращать результат; функция + вызывается так: `foo()`. + - name: Аргумент + description: >- + информация, которую функция получает при вызове. Например, `foo(42)` — + передача аргумента `42` функции `foo()` diff --git a/modules/35-calling-functions/120-function-signature/en/EXERCISE.md b/modules/35-calling-functions/120-function-signature/en/EXERCISE.md new file mode 100644 index 00000000..3c1e6ba1 --- /dev/null +++ b/modules/35-calling-functions/120-function-signature/en/EXERCISE.md @@ -0,0 +1,6 @@ + +Now it's your turn, look at the signature of a function in the documentation and work out how to use it. + +Python has a function called `hex()`. Study its signature [here](https://docs-python.ru/tutorial/vstroennye-funktsii-interpretatora-python/funktsija-hex/). + +Write a program that uses the `hex()` function with the variable `number` and displays the result on the screen. diff --git a/modules/35-calling-functions/120-function-signature/en/README.md b/modules/35-calling-functions/120-function-signature/en/README.md new file mode 100644 index 00000000..6e6b5303 --- /dev/null +++ b/modules/35-calling-functions/120-function-signature/en/README.md @@ -0,0 +1,18 @@ + +The `pow()` function calculates a number to a given power. It takes two parameters: **the number** and **the power**. If you call `pow()` without parameters, Python outputs the following: `"TypeError: pow expected at least 2 arguments, got 0. The interpreter tells you that the function expects two parameters and you called it without them. + +The `pow()` function always has two mandatory parameters, so it cannot be called with any other number of parameters. + +Moreover, the parameters of `pow()` can only be numbers. For example, if you pass a couple of lines into it, it will result in the following error: `"TypeError: unsupported operand type(s) for ** or pow(): 'str' and 'str'"`. The result of a function call is also always a number. + +Other functions can have different amounts and types of parameters. For example, there may be a function that takes three parameters: a number, a string, and another number. + +To know these details about a particular function, you have to look at its **signature**. It defines the input parameters and their types, as well as the output parameter and its type. You can read about the `pow()` function in the [official Python documentation](https://docs.python.org/3/library/functions.html?highlight=pow#pow). Usually the documentation for a function looks like this: + +``` +pow(x, y[, z]) + +Returns x to the power of y; if z is present, returns x to the power of y, modulus z +``` + +The first line here is the function signature. The function has two mandatory parameters, `x` and `y`. The optional parameter `z` is given in square brackets. Next, the purpose of the function is explained. The documentation lets you know how many arguments the function has and what type they are. It also describes what the function returns and what type the return value will be. diff --git a/modules/35-calling-functions/120-function-signature/en/data.yml b/modules/35-calling-functions/120-function-signature/en/data.yml new file mode 100644 index 00000000..61bf2fb6 --- /dev/null +++ b/modules/35-calling-functions/120-function-signature/en/data.yml @@ -0,0 +1,7 @@ +name: Function Signature +tips: [] +definitions: + - name: Function Signature + description: >- + a formal description of the types of arguments and the type of the + function's return value. diff --git a/modules/35-calling-functions/120-function-signature/es/EXERCISE.md b/modules/35-calling-functions/120-function-signature/es/EXERCISE.md new file mode 100644 index 00000000..6e305c1a --- /dev/null +++ b/modules/35-calling-functions/120-function-signature/es/EXERCISE.md @@ -0,0 +1,6 @@ + +Ahora es tu turno de revisar la firma de una función en la documentación y comprender cómo usarla. + +En Python, hay una función llamada `hex()`. Estudia su firma en la [página de documentación](https://docs.python.org/3/library/functions.html#hex). + +Escribe un programa que muestre en pantalla el resultado de llamar a la función `hex()` con la variable `number` como parámetro. diff --git a/modules/35-calling-functions/120-function-signature/es/README.md b/modules/35-calling-functions/120-function-signature/es/README.md new file mode 100644 index 00000000..2ae2f039 --- /dev/null +++ b/modules/35-calling-functions/120-function-signature/es/README.md @@ -0,0 +1,18 @@ + +La función `pow()` eleva un número a una potencia. Toma dos parámetros: **el número a elevar** y **la potencia a la que se debe elevar**. Si se llama a `pow()` sin parámetros, Python mostrará el siguiente mensaje de error: `"TypeError: pow expected at least 2 arguments, got 0"`. El intérprete indica que la función espera dos parámetros, pero la ejecutaste sin parámetros. + +La función `pow()` siempre tiene dos parámetros obligatorios, por lo que no se puede ejecutar con una cantidad diferente de parámetros. + +Además, los parámetros de `pow()` solo pueden ser números. Por ejemplo, si se le pasa un par de cadenas, se producirá el siguiente error: `"TypeError: unsupported operand type(s) for ** or pow(): 'str' and 'str'"`. El resultado de ejecutar la función siempre es un número. + +Otra función puede tener una cantidad diferente de parámetros y diferentes tipos de parámetros. Por ejemplo, puede existir una función que tome tres parámetros: un número, una cadena y otro número. + +Para conocer estos detalles específicos de una función, es necesario estudiar su **firma**. Esta define los parámetros de entrada y sus tipos, así como el parámetro de salida y su tipo. Puedes leer sobre la función `pow()` en la [documentación oficial de Python](https://docs.python.org/3/library/functions.html?highlight=pow#pow). Por lo general, la documentación de una función se ve así: + +``` +pow(x, y[, z]) + +Devuelve x elevado a la potencia y; si z está presente, devuelve x elevado a la potencia y módulo z +``` + +La primera línea aquí es la firma de la función. La función tiene dos parámetros obligatorios: `x` e `y`. El parámetro opcional `z` se indica entre corchetes. Luego se explica para qué se utiliza la función. La documentación indica cuántos argumentos tiene la función y de qué tipo son. También describe qué devuelve la función y de qué tipo es el valor devuelto. diff --git a/modules/35-calling-functions/120-function-signature/es/data.yml b/modules/35-calling-functions/120-function-signature/es/data.yml new file mode 100644 index 00000000..8f17e578 --- /dev/null +++ b/modules/35-calling-functions/120-function-signature/es/data.yml @@ -0,0 +1,10 @@ +name: Firma de la función +tips: + - > + [Función + pow()](https://docs.python.org/3/library/functions.html?highlight=pow#pow) +definitions: + - name: Firma de la función + description: >- + descripción formal de los tipos de argumentos y el tipo de valor devuelto + por una función. diff --git a/modules/35-calling-functions/120-function-signature/ru/EXERCISE.md b/modules/35-calling-functions/120-function-signature/ru/EXERCISE.md new file mode 100644 index 00000000..75d2d956 --- /dev/null +++ b/modules/35-calling-functions/120-function-signature/ru/EXERCISE.md @@ -0,0 +1,6 @@ + +Теперь ваша очередь посмотреть на сигнатуру функции в документации и разобраться, как её использовать. + +В Python есть функция `hex()`. Изучите её сигнатуру на [странице документации](https://docs-python.ru/tutorial/vstroennye-funktsii-interpretatora-python/funktsija-hex/). + +Напишите программу, которая выведет на экран результат работы функции `hex()` с переменной `number` в качестве параметра. diff --git a/modules/35-calling-functions/120-function-signature/ru/README.md b/modules/35-calling-functions/120-function-signature/ru/README.md new file mode 100644 index 00000000..8691b274 --- /dev/null +++ b/modules/35-calling-functions/120-function-signature/ru/README.md @@ -0,0 +1,18 @@ + +Функция `pow()` возводит число в степень. Она принимает два параметра: **какое число возводить** и **в какую степень возводить**. Если вызывать `pow()` без параметров, то Python выдаст следующее: `"TypeError: pow expected at least 2 arguments, got 0"`. Интерпретатор сообщает, что функция ожидает два параметра, а вы вызвали ее без них. + +Функция `pow()` всегда имеет два обязательных параметра, поэтому ее невозможно вызвать с другим количеством параметров. + +Более того, параметрами `pow()` могут быть только числа. Например, если передать в нее пару строк, это приведет к следующей ошибке: `"TypeError: unsupported operand type(s) for ** or pow(): 'str' and 'str'"`. Результат вызова функции — тоже всегда число. + +Другая функция может иметь другое число параметров и другие типы параметров. Например, может существовать функция, которая принимает три параметра: число, строку и еще одно число. + +Чтобы знать такие подробности о конкретной функции, нужно изучать ее **сигнатуру**. Она определяет входные параметры и их типы, а также выходной параметр и его тип. Про функцию `pow()` можно почитать в [официальной документации Python](https://docs.python.org/3/library/functions.html?highlight=pow#pow) или в [неофициальной документации на русском языке](https://docs-python.ru/tutorial/vstroennye-funktsii-interpretatora-python/funktsija-pow/). Обычно документация для функции выглядит так: + +``` +pow(x, y[, z]) + +Возвращает x в степени y; если z присутствует, возвращает x в степени y, по модулю z +``` + +Первая строка здесь — это сигнатура функции. У функции два обязательных параметра — `x` и `y`. Необязательный параметр `z` указан в квадратных скобках. Следом поясняется, для чего функция нужна. Документация дает понять, сколько аргументов у функции и какого они типа. Также она описывает, что возвращает функция и какого типа будет возвращаемое значение. diff --git a/modules/35-calling-functions/120-function-signature/ru/data.yml b/modules/35-calling-functions/120-function-signature/ru/data.yml new file mode 100644 index 00000000..7877b754 --- /dev/null +++ b/modules/35-calling-functions/120-function-signature/ru/data.yml @@ -0,0 +1,10 @@ +name: Сигнатура функции +tips: + - > + [Функция + pow()](https://docs.python.org/3/library/functions.html?highlight=pow#pow) +definitions: + - name: Сигнатура функции + description: >- + формальное описание типов аргументов и типа возвращаемого значения + функции. diff --git a/modules/35-calling-functions/135-calling-functions-default-arguments/en/EXERCISE.md b/modules/35-calling-functions/135-calling-functions-default-arguments/en/EXERCISE.md new file mode 100644 index 00000000..bd19cc26 --- /dev/null +++ b/modules/35-calling-functions/135-calling-functions-default-arguments/en/EXERCISE.md @@ -0,0 +1,2 @@ + +Round up the number written in the `number` variable to two decimal places and print the result on the screen. diff --git a/modules/35-calling-functions/135-calling-functions-default-arguments/en/README.md b/modules/35-calling-functions/135-calling-functions-default-arguments/en/README.md new file mode 100644 index 00000000..3564bdb4 --- /dev/null +++ b/modules/35-calling-functions/135-calling-functions-default-arguments/en/README.md @@ -0,0 +1,26 @@ + +Let's look at the `round()` function, which rounds the number passed to it: + +```python +result = round(10.25, 0) # 10.0 +``` + +We passed two parameters to it: + +* Number to be rounded +* Rounding accuracy + +`0` means that the rounding will be to an integer value. More often than not, you need to round to a whole number, not to two, three, four etc. decimal places. So the creators of the `round` function made the second parameter **unnecessary** and gave it a **default value of `0`** inside the function. So, you can choose to not specify the second parameter and the result will be the same: + +```python +result = round(10.25) # 10.0 +``` + +And if you need a different precision, you can pass a parameter: + +```python +# rounding to one decimal place +result = round(10.25, 1) # 10.2 +``` + +If a function in Python accepts optional arguments, they always come after the mandatory ones. There can be any number of them. It depends on the function itself, but they always go next to and at the end of the list of arguments. diff --git a/modules/35-calling-functions/135-calling-functions-default-arguments/en/data.yml b/modules/35-calling-functions/135-calling-functions-default-arguments/en/data.yml new file mode 100644 index 00000000..1b332563 --- /dev/null +++ b/modules/35-calling-functions/135-calling-functions-default-arguments/en/data.yml @@ -0,0 +1,5 @@ +name: Default Arguments +tips: [] +definitions: + - name: Default setting + description: optional function parameter diff --git a/modules/35-calling-functions/135-calling-functions-default-arguments/es/EXERCISE.md b/modules/35-calling-functions/135-calling-functions-default-arguments/es/EXERCISE.md new file mode 100644 index 00000000..30bdb35e --- /dev/null +++ b/modules/35-calling-functions/135-calling-functions-default-arguments/es/EXERCISE.md @@ -0,0 +1,2 @@ + +Redondea el número almacenado en la variable `number` a dos decimales y muestra el resultado en pantalla. diff --git a/modules/35-calling-functions/135-calling-functions-default-arguments/es/README.md b/modules/35-calling-functions/135-calling-functions-default-arguments/es/README.md new file mode 100644 index 00000000..38363d45 --- /dev/null +++ b/modules/35-calling-functions/135-calling-functions-default-arguments/es/README.md @@ -0,0 +1,26 @@ + +Veamos la función `round()`, que redondea un número que se le pasa como argumento: + +```python +result = round(10.25, 0) # 10.0 +``` + +Le pasamos dos parámetros: + +* El número que queremos redondear +* La precisión de redondeo + +El valor `0` significa que se redondeará al número entero más cercano. En la mayoría de los casos, queremos redondear al número entero y no a los decimales. Por eso, los creadores de la función `round` hicieron el segundo parámetro **opcional** y le dieron un **valor por defecto de `0`**. Esto significa que podemos no especificar el segundo parámetro y el resultado será el mismo: + +```python +result = round(10.25) # 10.0 +``` + +Y si queremos una precisión diferente, podemos pasar el parámetro: + +```python +# redondeo a un decimal +result = round(10.25, 1) # 10.2 +``` + +Si una función en Python tiene argumentos opcionales, siempre se colocan después de los argumentos obligatorios. Pueden ser cualquier cantidad. Esto depende de la función en sí, pero siempre van juntos y al final de la lista de argumentos. diff --git a/modules/35-calling-functions/135-calling-functions-default-arguments/es/data.yml b/modules/35-calling-functions/135-calling-functions-default-arguments/es/data.yml new file mode 100644 index 00000000..9e24bc18 --- /dev/null +++ b/modules/35-calling-functions/135-calling-functions-default-arguments/es/data.yml @@ -0,0 +1,5 @@ +name: Argumentos por defecto +tips: [] +definitions: + - name: Parámetro por defecto + description: parámetro opcional de una función diff --git a/modules/35-calling-functions/135-calling-functions-default-arguments/ru/EXERCISE.md b/modules/35-calling-functions/135-calling-functions-default-arguments/ru/EXERCISE.md new file mode 100644 index 00000000..281f14c8 --- /dev/null +++ b/modules/35-calling-functions/135-calling-functions-default-arguments/ru/EXERCISE.md @@ -0,0 +1,2 @@ + +Округлите число, записанное в переменную `number`, до двух знаков после запятой и выведите результат на экран. diff --git a/modules/35-calling-functions/135-calling-functions-default-arguments/ru/README.md b/modules/35-calling-functions/135-calling-functions-default-arguments/ru/README.md new file mode 100644 index 00000000..b4f2c512 --- /dev/null +++ b/modules/35-calling-functions/135-calling-functions-default-arguments/ru/README.md @@ -0,0 +1,26 @@ + +Рассмотрим функцию `round()`, которая округляет переданное ей число: + +```python +result = round(10.25, 0) # 10.0 +``` + +Мы передали в нее два параметра: + +* Число, которое нужно округлить +* Точность округления + +`0` означает, что округление будет до целого значения. Чаще всего нужно округлять именно до целого числа, а не до десятых. Поэтому создатели функции `round` сделали второй параметр **необязательным** и задали ему внутри функции **значение по умолчанию `0`**. Значит, можно не указывать второй параметр, а результат будет тем же: + +```python +result = round(10.25) # 10.0 +``` + +А если нужна другая точность, то можно передать параметр: + +```python +# округление до одного знака после запятой +result = round(10.25, 1) # 10.2 +``` + +Если функция в Python принимает необязательные аргументы, то они всегда стоят после обязательных. Их количество может быть любым. Это зависит от самой функции, но они всегда идут рядом и в конце списка аргументов. diff --git a/modules/35-calling-functions/135-calling-functions-default-arguments/ru/data.yml b/modules/35-calling-functions/135-calling-functions-default-arguments/ru/data.yml new file mode 100644 index 00000000..cb17dd94 --- /dev/null +++ b/modules/35-calling-functions/135-calling-functions-default-arguments/ru/data.yml @@ -0,0 +1,5 @@ +name: Аргументы по умолчанию +tips: [] +definitions: + - name: Параметр по умолчанию + description: необязательный параметр функции diff --git a/modules/35-calling-functions/150-calling-funcitons-expression/en/EXERCISE.md b/modules/35-calling-functions/150-calling-funcitons-expression/en/EXERCISE.md new file mode 100644 index 00000000..84152702 --- /dev/null +++ b/modules/35-calling-functions/150-calling-funcitons-expression/en/EXERCISE.md @@ -0,0 +1,9 @@ + +Display the first and last letters of the sentence written in the `text` variable in the following format: + +
+First: N
+Last: t
+
+ +Try to create only one variable to be assigned to the text to before you print it. In this lesson, we're practicing building a compound expression. diff --git a/modules/35-calling-functions/150-calling-funcitons-expression/en/README.md b/modules/35-calling-functions/150-calling-funcitons-expression/en/README.md new file mode 100644 index 00000000..0ae51699 --- /dev/null +++ b/modules/35-calling-functions/150-calling-funcitons-expression/en/README.md @@ -0,0 +1,55 @@ + +Let's continue to look at functions and their components. Today, it's time to look at expressions. Let's consider what it is and whether a function call can be mistaken for an expression. + +An expression in programming returns a result that can be used. You probably already know a lot about expressions and the principles by which they're constructed. For example, mathematical operations like addition and subtraction, string operations like concatenation are all expressions: + +```python +1 + 5 * 3 +'He' + 'Let' +# Variables can be part of an expression +rate * 5 +``` + +The peculiarity of expressions is that they return a result that can be used again: for example, they can be assigned to a variable or printed. This is what it looks like in the code: + +```python +# Here the expression is 1 + 5 +sum = 1 + 5 +print(1 + 5) +``` + +But not everything in programming is an expression. The definition of a variable is an instruction, which means it cannot be part of an expression. In other words, this code will lead to an error: + +```python +# Meaningless code that won't work +10 + sum = 1 + 5 +``` + +Now let's see if a function call can be taken as an expression. + +We know that functions return results, therefore they're expressions. This leads to a lot of interesting possibilities. For example, we can use a function call directly in mathematical operations. This is how we can get the last character index in a word: + +```python +name = 'python' +# Indexes start with zero +# Function call and subtraction together! +last_index = len(name) - 1 +print(last_index) # => 5 +``` + +This code has no new syntax. We have merely connected parts we already know, we're relying on their nature. We could go even further: + +```python +print(len(name) - 1) # => 5 +``` + +All of this applies for any function, e.g., string functions: + +```python +name = 'python' +# Interpolation is used +print(f'Last character: {name[len(name) - 1]}') +# 'Last character: n' +``` + +As you will see next, expressions can be combined to produce increasingly complex behavior in different places and in any way. The more you learn and practice Python, the better you will understand expressions. Over time, you'll learn how to connect the pieces of code to get the results you want. diff --git a/modules/35-calling-functions/150-calling-funcitons-expression/en/data.yml b/modules/35-calling-functions/150-calling-funcitons-expression/en/data.yml new file mode 100644 index 00000000..32d6dbf5 --- /dev/null +++ b/modules/35-calling-functions/150-calling-funcitons-expression/en/data.yml @@ -0,0 +1 @@ +name: Function call - expressions diff --git a/modules/35-calling-functions/150-calling-funcitons-expression/es/EXERCISE.md b/modules/35-calling-functions/150-calling-funcitons-expression/es/EXERCISE.md new file mode 100644 index 00000000..e57a00f2 --- /dev/null +++ b/modules/35-calling-functions/150-calling-funcitons-expression/es/EXERCISE.md @@ -0,0 +1,9 @@ + +Imprime en pantalla la primera y la última letra de la oración almacenada en la variable `texto`, en el siguiente formato: + +
+First: N
+Last: t
+
+ +Intenta crear solo una variable en la que se almacene el texto necesario antes de imprimirlo en pantalla. En esta lección, estamos practicando cómo construir una expresión compuesta. diff --git a/modules/35-calling-functions/150-calling-funcitons-expression/es/README.md b/modules/35-calling-functions/150-calling-funcitons-expression/es/README.md new file mode 100644 index 00000000..7917842e --- /dev/null +++ b/modules/35-calling-functions/150-calling-funcitons-expression/es/README.md @@ -0,0 +1,55 @@ + +Continuamos entendiendo las funciones y sus componentes. Hoy hablaremos sobre las expresiones y si una llamada a una función puede considerarse una expresión. + +En programación, una expresión devuelve un resultado que se puede utilizar. Probablemente ya sepas mucho sobre expresiones y los principios en los que se basan. Por ejemplo, operaciones matemáticas como la suma y la resta, operaciones de cadenas como la concatenación, todas estas son expresiones: + +```python +1 + 5 * 3 +'He' + 'Let' +# Las variables pueden ser parte de una expresión +rate * 5 +``` + +La característica de las expresiones es que devuelven un resultado que se puede utilizar posteriormente, como asignarlo a una variable o imprimirlo en pantalla. Así es como se ve en el código: + +```python +# Aquí la expresión es 1 + 5 +sum = 1 + 5 +print(1 + 5) +``` + +Pero no todo en programación es una expresión. La declaración de una variable es una instrucción y, por lo tanto, no puede ser parte de una expresión. Es decir, este código dará un error: + +```python +# Código sin sentido que no funcionará +10 + sum = 1 + 5 +``` + +Ahora veamos si una ejecución de una función se considera una expresión. + +Sabemos que las funciones devuelven un resultado, lo que significa que son expresiones. De esto se deduce automáticamente muchas cosas interesantes. Por ejemplo, podemos usar una llamada a una función directamente en operaciones matemáticas. Así es como podemos obtener el índice del último carácter en una palabra: + +```python +name = 'python' +# Los índices comienzan en cero +# ¡Ejecución de una función y resta juntas! +last_index = len(name) - 1 +print(last_index) # => 5 +``` + +En este código no hay una nueva sintaxis. Simplemente hemos combinado partes conocidas basándonos en su naturaleza. Podemos ir aún más lejos: + +```python +print(len(name) - 1) # => 5 +``` + +Todo esto es válido para cualquier función, por ejemplo, las funciones de cadenas: + +```python +name = 'python' +# Se utiliza interpolación +print(f'Último carácter: {name[len(name) - 1]}') +# 'Último carácter: n' +``` + +Como verás más adelante, las expresiones se pueden combinar para obtener comportamientos más complejos en diferentes lugares y de cualquier manera. Cuanto más profundices en el estudio de Python y practiques, mejor entenderás cómo trabajar con expresiones. Con el tiempo, aprenderás cómo combinar partes de código para obtener el resultado deseado. diff --git a/modules/35-calling-functions/150-calling-funcitons-expression/es/data.yml b/modules/35-calling-functions/150-calling-funcitons-expression/es/data.yml new file mode 100644 index 00000000..7d89e1f8 --- /dev/null +++ b/modules/35-calling-functions/150-calling-funcitons-expression/es/data.yml @@ -0,0 +1,6 @@ +name: Llamada a una función - expresión +definitions: + - name: Expresión + description: > + una secuencia de acciones sobre datos que conduce a un resultado que se + puede utilizar. diff --git a/modules/35-calling-functions/150-calling-funcitons-expression/ru/EXERCISE.md b/modules/35-calling-functions/150-calling-funcitons-expression/ru/EXERCISE.md new file mode 100644 index 00000000..6f5608bc --- /dev/null +++ b/modules/35-calling-functions/150-calling-funcitons-expression/ru/EXERCISE.md @@ -0,0 +1,9 @@ + +Выведите на экран первую и последнюю буквы предложения, записанного в переменную `text`, в следующем формате: + +
+First: N
+Last: t
+
+ +Постарайтесь создать только одну переменную, в которую сразу запишется нужный текст перед печатью на экран. В этом уроке мы отрабатываем умение собирать составное выражение. diff --git a/modules/35-calling-functions/150-calling-funcitons-expression/ru/README.md b/modules/35-calling-functions/150-calling-funcitons-expression/ru/README.md new file mode 100644 index 00000000..e02afa99 --- /dev/null +++ b/modules/35-calling-functions/150-calling-funcitons-expression/ru/README.md @@ -0,0 +1,55 @@ + +Продолжаем разбираться с функцией и ее составляющими. Сегодня на очереди выражение. Рассмотрим, что это такое и можно ли вызов функции принять за выражение. + +Выражение в программировании возвращает результат, который можно использовать. Скорее всего, вы уже знаете многое о выражениях и принципах, по которым они строятся. Например, такие математические операции, как сложение и вычитание, строковые операции, как конкатенация — все это выражения: + +```python +1 + 5 * 3 +'He' + 'Let' +# Переменные могут быть частью выражения +rate * 5 +``` + +Особенность выражений в том, что они возвращают результат, который можно использовать дальше: например, присвоить переменной или вывести на экран. Так это выглядит в коде: + +```python +# Тут выражение это 1 + 5 +sum = 1 + 5 +print(1 + 5) +``` + +Но не все в программировании выражение. Определение переменной — это инструкция, а значит она не может быть частью выражения. То есть такой код выдаст ошибку: + +```python +# Бессмысленный код, который не сработает +10 + sum = 1 + 5 +``` + +Теперь разберемся, принимается ли за выражение вызов функции. + +Мы знаем, что функции возвращают результат — значит, они выражения. Из этого автоматически следует много интересного. Например, мы можем использовать вызов функции прямо в математических операциях. Вот как можно получить индекс последнего символа в слове: + +```python +name = 'python' +# Индексы начинаются с нуля +# Вызов функции и вычитание вместе! +last_index = len(name) - 1 +print(last_index) # => 5 +``` + +В этом коде нет нового синтаксиса. Мы всего лишь соединили уже известные части, опираясь на их природу. Можно пойти еще дальше: + +```python +print(len(name) - 1) # => 5 +``` + +Все это справедливо для любых функций, например строковых: + +```python +name = 'python' +# Используется интерполяция +print(f'Последний символ: {name[len(name) - 1]}') +# 'Последний символ: n' +``` + +Как вы увидите дальше, выражения можно комбинировать, получая все более сложное поведение в разных местах и любым образом. Чем глубже вы будете изучать Python и практиковаться в нем, тем лучше вы будете понимать работу с выражениями. Со временем вы поймете, как соединять части кода, чтобы получить нужный результат. diff --git a/modules/35-calling-functions/150-calling-funcitons-expression/ru/data.yml b/modules/35-calling-functions/150-calling-funcitons-expression/ru/data.yml new file mode 100644 index 00000000..bad91348 --- /dev/null +++ b/modules/35-calling-functions/150-calling-funcitons-expression/ru/data.yml @@ -0,0 +1,6 @@ +name: Вызов функции — выражение +definitions: + - name: Выражение + description: > + последовательность действий над данными, приводящая к каком-то результату, + который можно использовать. diff --git a/modules/35-calling-functions/180-variadic-parameters/en/EXERCISE.md b/modules/35-calling-functions/180-variadic-parameters/en/EXERCISE.md new file mode 100644 index 00000000..e6ad7511 --- /dev/null +++ b/modules/35-calling-functions/180-variadic-parameters/en/EXERCISE.md @@ -0,0 +1,2 @@ + +Calculate the minimum number (not mentally) from 3, 10, 22, -3, 0 - and display it. Use the `min()` function, which works in the same way as `max()`. diff --git a/modules/35-calling-functions/180-variadic-parameters/en/README.md b/modules/35-calling-functions/180-variadic-parameters/en/README.md new file mode 100644 index 00000000..601e7965 --- /dev/null +++ b/modules/35-calling-functions/180-variadic-parameters/en/README.md @@ -0,0 +1,22 @@ + +In this lesson, we'll take a look at the `max()` function and see how it works in Python. + +Some functions are a little different in that they take a variable number of parameters. And we're not talking about default values. Check out this example: + +```python +max(1, 10, 3) # 10 +``` + +In the above example, the `max()` function finds the maximum value among the passed parameters. To find out how many parameters can be passed to the input, you need to look at the [documentation](https://docs.python.org/3/library/functions.html?highlight=pow#max) этой функции. Там мы увидим такую конструкцию: + +``` +max(arg1, arg2, *args[, key]) +``` + +This means that `max()` takes two or more parameters as input: + +```python +max(1, -3, 2, 3, 2) # 3 +``` + +If the function finds several parameters with the maximum value, then it'll return the very first one. diff --git a/modules/35-calling-functions/180-variadic-parameters/en/data.yml b/modules/35-calling-functions/180-variadic-parameters/en/data.yml new file mode 100644 index 00000000..127b35fd --- /dev/null +++ b/modules/35-calling-functions/180-variadic-parameters/en/data.yml @@ -0,0 +1,2 @@ +name: Functions With Varying Numbers of Parameters +tips: [] diff --git a/modules/35-calling-functions/180-variadic-parameters/es/EXERCISE.md b/modules/35-calling-functions/180-variadic-parameters/es/EXERCISE.md new file mode 100644 index 00000000..03cee9a9 --- /dev/null +++ b/modules/35-calling-functions/180-variadic-parameters/es/EXERCISE.md @@ -0,0 +1,2 @@ + +Calcule programáticamente (no mentalmente) el número mínimo entre 3, 10, 22, -3, 0, y muéstrelo en pantalla. Utilice la función `min()`, que funciona de manera similar a `max()`. diff --git a/modules/35-calling-functions/180-variadic-parameters/es/README.md b/modules/35-calling-functions/180-variadic-parameters/es/README.md new file mode 100644 index 00000000..d78e72f4 --- /dev/null +++ b/modules/35-calling-functions/180-variadic-parameters/es/README.md @@ -0,0 +1,22 @@ + +En esta lección vamos a analizar la función `max()`, y veremos cómo funciona en Python. + +Algunas funciones tienen la particularidad de aceptar un número variable de parámetros. Y no nos referimos a los valores por defecto. Mira este ejemplo: + +```python +max(1, 10, 3) # 10 +``` + +En el ejemplo anterior, la función `max()` encuentra el valor máximo entre los parámetros proporcionados. Para saber cuántos parámetros se pueden pasar como entrada, debemos consultar la [documentación](https://docs.python.org/3/library/functions.html?highlight=pow#max) de esta función. Allí veremos esta construcción: + +``` +max(arg1, arg2, *args[, key]) +``` + +Esto significa que `max()` acepta dos o más parámetros: + +```python +max(1, -3, 2, 3, 2) # 3 +``` + +Si la función encuentra varios parámetros con el valor máximo, devolverá el primero de estos. diff --git a/modules/35-calling-functions/180-variadic-parameters/es/data.yml b/modules/35-calling-functions/180-variadic-parameters/es/data.yml new file mode 100644 index 00000000..d3fd5891 --- /dev/null +++ b/modules/35-calling-functions/180-variadic-parameters/es/data.yml @@ -0,0 +1,8 @@ +name: Funciones con número variable de parámetros +tips: + - > + [Ejemplo de función con número variable de + parámetros](https://docs.python.org/3/library/functions.html?highlight=pow#max) +definitions: + - name: Argumento por defecto + description: argumento opcional de una función. diff --git a/modules/35-calling-functions/180-variadic-parameters/ru/EXERCISE.md b/modules/35-calling-functions/180-variadic-parameters/ru/EXERCISE.md new file mode 100644 index 00000000..31d37083 --- /dev/null +++ b/modules/35-calling-functions/180-variadic-parameters/ru/EXERCISE.md @@ -0,0 +1,2 @@ + +Посчитайте программно (а не в голове) минимальное число среди 3, 10, 22, -3, 0 — и выведите его на экран. Воспользуйтесь функцией `min()`, которая работает аналогично `max()`. diff --git a/modules/35-calling-functions/180-variadic-parameters/ru/README.md b/modules/35-calling-functions/180-variadic-parameters/ru/README.md new file mode 100644 index 00000000..31080ab0 --- /dev/null +++ b/modules/35-calling-functions/180-variadic-parameters/ru/README.md @@ -0,0 +1,22 @@ + +В этом уроке мы разберем функцию `max()`, а также посмотрим, как она работает в Python. + +У некоторых функций есть особенность — они принимают переменное число параметров. И мы говорим не о значениях по умолчанию. Посмотрите на этот пример: + +```python +max(1, 10, 3) # 10 +``` + +В примере выше функция `max()` находит максимальное значение среди переданных параметров. Чтобы узнать, сколько параметров можно передавать на вход, нужно изучить [документацию](https://docs.python.org/3/library/functions.html?highlight=pow#max) этой функции. Там мы увидим такую конструкцию: + +``` +max(arg1, arg2, *args[, key]) +``` + +Это значит, что `max()` принимает на вход два параметра и больше: + +```python +max(1, -3, 2, 3, 2) # 3 +``` + +Если функция найдет несколько параметров с максимальным значением, значит, она вернет самый первый из них. diff --git a/modules/35-calling-functions/180-variadic-parameters/ru/data.yml b/modules/35-calling-functions/180-variadic-parameters/ru/data.yml new file mode 100644 index 00000000..94817e39 --- /dev/null +++ b/modules/35-calling-functions/180-variadic-parameters/ru/data.yml @@ -0,0 +1,8 @@ +name: Функции с переменным числом параметров +tips: + - > + [Пример функции с переменным числом + параметров](https://docs.python.org/3/library/functions.html?highlight=pow#max) +definitions: + - name: Аргумент по умолчанию + description: необязательный аргумент функции. diff --git a/modules/35-calling-functions/270-deterministic/en/EXERCISE.md b/modules/35-calling-functions/270-deterministic/en/EXERCISE.md new file mode 100644 index 00000000..76785612 --- /dev/null +++ b/modules/35-calling-functions/270-deterministic/en/EXERCISE.md @@ -0,0 +1,11 @@ + +The `random()` function returns a random number from 0 to 1 with many decimal places. Implement code that displays a random integer between 0 and 10. For this task, you need the `random()` function and the [round()](https://docs.python.org/3/library/functions.html#round), function, which rounds the value passed to it + +```python +round(2.320000789855705) # 2 +``` + +Try to solve this task using only 1 line + +## Algorithm +Since `random()` returns numbers between 0 and 1, we need to multiply by 10 to get numbers between 0 and 10. Then we round the result to get what we need. diff --git a/modules/35-calling-functions/270-deterministic/en/README.md b/modules/35-calling-functions/270-deterministic/en/README.md new file mode 100644 index 00000000..6e857b27 --- /dev/null +++ b/modules/35-calling-functions/270-deterministic/en/README.md @@ -0,0 +1,27 @@ + +Functions in every programming language have fundamental properties. These properties help predict the behavior of functions, how to test them, and where to use them. These properties include determinacy. + +A deterministic function returns the same result every time if the input parameters are the same. For example, a function that counts the number of characters can be called deterministic: + +```python +len('hexlet') # 6 +len('hexlet') # 6 + +len('wow') # 3 +len('wow') # 3 +``` + +You can call this function and pass the value `'hexlet'` as many times as you want, and it will always return `6`. + +Let's also look at the reverse case: nondeterministic functions. For example, a function that returns a random number belongs to this category: we will always get different results even if we use the same input. If at least one in a million calls to a function returns a different result, it is considered nondeterministic. This applies even if it doesn't take parameters: + +```python +# Import syntax will be studied later in Hexlet +from random import random + +# A function that returns a random number +random() # 0.09856613113197676 +random() # 0.8839904367241888 +``` + +Determinism is an important property of a function, as it affects many aspects. For example, deterministic functions are convenient to work with, as they're easy to optimize and test. If possible, it's better to make the function deterministic. diff --git a/modules/35-calling-functions/270-deterministic/en/data.yml b/modules/35-calling-functions/270-deterministic/en/data.yml new file mode 100644 index 00000000..e38fa107 --- /dev/null +++ b/modules/35-calling-functions/270-deterministic/en/data.yml @@ -0,0 +1,4 @@ +name: Determinacy +tips: + - | + [Pure function](https://en.wikipedia.org/wiki/Pure_function) diff --git a/modules/35-calling-functions/270-deterministic/es/EXERCISE.md b/modules/35-calling-functions/270-deterministic/es/EXERCISE.md new file mode 100644 index 00000000..8bf707ef --- /dev/null +++ b/modules/35-calling-functions/270-deterministic/es/EXERCISE.md @@ -0,0 +1,11 @@ + +La función `random()` devuelve un número aleatorio entre 0 y 1 con varios decimales. Implementa un código que muestre en pantalla un número entero aleatorio en el rango de 0 a 10. Para este ejercicio, necesitarás la función `random()` y la función [round()](https://docs.python.org/3/library/functions.html#round), que redondea el valor que se le pasa. + +```python +round(2.320000789855705) # 2 +``` + +Intenta resolver este ejercicio en una sola línea. + +## Algoritmo +Dado que la función `random()` devuelve números en el rango de 0 a 1, para obtener números en el rango de 0 a 10, debemos multiplicar por 10. Luego, se redondea el número resultante y así obtenemos lo que necesitamos. diff --git a/modules/35-calling-functions/270-deterministic/es/README.md b/modules/35-calling-functions/270-deterministic/es/README.md new file mode 100644 index 00000000..38f63a26 --- /dev/null +++ b/modules/35-calling-functions/270-deterministic/es/README.md @@ -0,0 +1,27 @@ + +Las funciones en cada lenguaje de programación tienen propiedades fundamentales. Estas propiedades ayudan a predecir el comportamiento de las funciones, las formas de probarlas y dónde utilizarlas. Una de estas propiedades es el determinismo. + +Una función determinista devuelve el mismo resultado para los mismos parámetros de entrada. Por ejemplo, se puede considerar determinista una función que cuenta la cantidad de caracteres: + +```python +len('hexlet') # 6 +len('hexlet') # 6 + +len('wow') # 3 +len('wow') # 3 +``` + +Se puede ejecutar esta función infinitamente y pasarle el valor `'hexlet'` - siempre devolverá `6`. + +Veamos ahora el caso contrario: las funciones no deterministas. Por ejemplo, una función que devuelve un número aleatorio pertenece a esta categoría: para una misma entrada, siempre obtendremos un resultado diferente. Si al menos una de cada millón de llamadas a la función devuelve un resultado diferente, se considera no determinista. Esto también se aplica cuando no se toman parámetros: + +```python +# La sintaxis de las importaciones se estudiará más adelante en Hexlet +from random import random + +# Función que devuelve un número aleatorio +random() # 0.09856613113197676 +random() # 0.8839904367241888 +``` + +El determinismo es una propiedad importante de una función, ya que afecta a muchos aspectos. Por ejemplo, las funciones deterministas son convenientes para trabajar, ya que son fáciles de optimizar y probar. Si es posible, es mejor hacer que una función sea determinista. diff --git a/modules/35-calling-functions/270-deterministic/es/data.yml b/modules/35-calling-functions/270-deterministic/es/data.yml new file mode 100644 index 00000000..49e22bd1 --- /dev/null +++ b/modules/35-calling-functions/270-deterministic/es/data.yml @@ -0,0 +1,9 @@ +name: Determinismo +tips: + - | + [Funciones deterministas](https://en.wikipedia.org/wiki/Pure_function) +definitions: + - name: Efecto secundario + description: >- + una acción que modifica el entorno externo (el entorno de ejecución). Por + ejemplo, la impresión en pantalla o el envío de un correo electrónico. diff --git a/modules/35-calling-functions/270-deterministic/ru/EXERCISE.md b/modules/35-calling-functions/270-deterministic/ru/EXERCISE.md new file mode 100644 index 00000000..934a8aa0 --- /dev/null +++ b/modules/35-calling-functions/270-deterministic/ru/EXERCISE.md @@ -0,0 +1,11 @@ + +Функция `random()` возвращает случайное число от 0 до 1 с большим количеством знаков после запятой. Реализуйте код, который выводит на экран случайное целое число в диапазоне от 0 до 10. Для этой задачи вам понадобится функция `random()` и функция [round()](https://docs.python.org/3/library/functions.html#round), которая округляет переданное ей значение + +```python +round(2.320000789855705) # 2 +``` + +Попробуйте решить это задание в одну строчку + +## Алгоритм +Так как функция `random()` возвращает числа в диапазоне от 0 до 1, то чтобы получить числа от 0 до 10, нам нужно выполнить умножение на 10. Затем получившиеся число округляется и так мы получаем то, что нужно. diff --git a/modules/35-calling-functions/270-deterministic/ru/README.md b/modules/35-calling-functions/270-deterministic/ru/README.md new file mode 100644 index 00000000..7c39b9c9 --- /dev/null +++ b/modules/35-calling-functions/270-deterministic/ru/README.md @@ -0,0 +1,27 @@ + +У функций внутри каждого языка программирования есть фундаментальные свойства. Эти свойства помогают прогнозировать поведение функций, способы их тестирования и место использования. К таким свойствам относится детерминированность. + +Детерминированная функция возвращает один и тот же результат для одинаковых входных параметров. Например, детерминированной можно назвать функцию, которая считает количество символов: + +```python +len('hexlet') # 6 +len('hexlet') # 6 + +len('wow') # 3 +len('wow') # 3 +``` + +Можно бесконечно вызывать эту функцию и передавать туда значение `'hexlet'` — она всегда вернет `6`. + +Посмотрим и обратный случай — недетерминированные функции. Например, к этой категории относится функция, которая возвращает случайное число: у одного и того же входа мы получим всегда разный результат. Если хотя бы один из миллиона вызовов функция вернет другой результат, она считается недетерминированной. Это работает и в том случае, если параметры не принимаются: + +```python +# Синтаксис импортов будет изучаться позже на Хекслете +from random import random + +# Функция, которая возвращает случайное число +random() # 0.09856613113197676 +random() # 0.8839904367241888 +``` + +Детерминированность — это важное свойство функции, так как она влияет на многие аспекты. Например, детерминированные функции удобны в работе — их легко оптимизировать и тестировать. Если возможно, то лучше сделать функцию детерминированной. diff --git a/modules/35-calling-functions/270-deterministic/ru/data.yml b/modules/35-calling-functions/270-deterministic/ru/data.yml new file mode 100644 index 00000000..f8638257 --- /dev/null +++ b/modules/35-calling-functions/270-deterministic/ru/data.yml @@ -0,0 +1,10 @@ +name: Детерминированность +tips: + - > + [Детерминированные + функции](https://ru.wikipedia.org/wiki/Чистота_функции#Детерминированность_функции) +definitions: + - name: Побочный эффект + description: >- + действие, которое изменяет внешнее окружение (среду выполнения). Например, + вывод на экран или отправка письма. diff --git a/modules/35-calling-functions/900-stdlib/en/EXERCISE.md b/modules/35-calling-functions/900-stdlib/en/EXERCISE.md new file mode 100644 index 00000000..a5629735 --- /dev/null +++ b/modules/35-calling-functions/900-stdlib/en/EXERCISE.md @@ -0,0 +1,8 @@ + +The `type()` function allows you to define the type of the passed argument. The type name is returned as a string. For example, calling `type(10)` will return the string `` (int, short for integer). + +```python +print(type('wow')) # +``` + +Display the type of the variable `motto` value. diff --git a/modules/35-calling-functions/900-stdlib/en/README.md b/modules/35-calling-functions/900-stdlib/en/README.md new file mode 100644 index 00000000..94d321f6 --- /dev/null +++ b/modules/35-calling-functions/900-stdlib/en/README.md @@ -0,0 +1,14 @@ + +Python comes with a set of useful functions that make up the **standard library**. It usually includes thousands of functions that are impossible to remember. So the programmer needs to know where to find documentation on these functions, as well as have an idea of the result he or she wants to get. For these reasons, it is difficult to program without the Internet. + +Beginners often do not understand how and where to find out about the functions to be used. There is no way to solve this problem. As they work, developers become more experienced and add to their knowledge and practice. Gradually they become familiar with more interesting features that solve their problems differently. + +Here are tips to help increase professionalism: + +* Always keep track of which data type you are working with. That way, you will find the function you need in the appropriate section of the documentation. For example, to work with strings, you have to learn string functions + +* Periodically open a section with standard features on your topic, learn the signatures and how to use them + +* Read other people's code on GitHub more often. Pay special attention to the code of the libraries you use + +If you follow these tips and pay close attention to detail, you will soon notice how you develop and grow as a professional. diff --git a/modules/35-calling-functions/900-stdlib/en/data.yml b/modules/35-calling-functions/900-stdlib/en/data.yml new file mode 100644 index 00000000..ea08a6b5 --- /dev/null +++ b/modules/35-calling-functions/900-stdlib/en/data.yml @@ -0,0 +1,4 @@ +name: Standard Library +definitions: + - name: Standard Library + description: a set of useful features included with the programming language. diff --git a/modules/35-calling-functions/900-stdlib/es/EXERCISE.md b/modules/35-calling-functions/900-stdlib/es/EXERCISE.md new file mode 100644 index 00000000..9a89095b --- /dev/null +++ b/modules/35-calling-functions/900-stdlib/es/EXERCISE.md @@ -0,0 +1,8 @@ + +La función `type()` permite determinar el tipo del argumento pasado. El nombre del tipo se devuelve como una cadena de texto. Por ejemplo, ejecutar `type(10)` devolverá la cadena de texto `` (int es la abreviatura de integer, que significa número entero). + +```python +print(type('wow')) # +``` + +Muestra en pantalla el tipo del valor de la variable `motto`. diff --git a/modules/35-calling-functions/900-stdlib/es/README.md b/modules/35-calling-functions/900-stdlib/es/README.md new file mode 100644 index 00000000..cb601dde --- /dev/null +++ b/modules/35-calling-functions/900-stdlib/es/README.md @@ -0,0 +1,14 @@ + +Python viene con un conjunto de funciones útiles que conforman la **biblioteca estándar**. Por lo general, incluye miles de funciones que son imposibles de recordar. Por lo tanto, el programador debe saber dónde encontrar la documentación de estas funciones, así como tener una idea del resultado que desea obtener. Por estas razones, programar sin conexión a Internet es difícil. + +Los principiantes a menudo no entienden cómo y dónde obtener información sobre las funciones que deben utilizar. No hay una forma única de resolver este problema. A medida que los desarrolladores adquieren experiencia, van acumulando conocimientos y prácticas. Poco a poco, se familiarizan con funciones más interesantes que resuelven sus problemas de manera diferente. + +Aquí hay algunos consejos que te ayudarán a mejorar tu nivel de profesionalismo: + +* Siempre sigue la pista del tipo de datos con el que estás trabajando. De esta manera, encontrarás la función necesaria en la sección correspondiente de la documentación. Por ejemplo, para trabajar con cadenas de texto, debes estudiar las funciones de cadenas. + +* Abre periódicamente la sección de funciones estándar relacionadas con tu tema, estudia las firmas y formas de uso. + +* Lee el código de otras personas en GitHub con más frecuencia. Presta especial atención al código de las bibliotecas que estás utilizando. + +Si sigues estos consejos y prestas atención a los detalles, pronto notarás cómo te desarrollas y creces como profesional. diff --git a/modules/35-calling-functions/900-stdlib/es/data.yml b/modules/35-calling-functions/900-stdlib/es/data.yml new file mode 100644 index 00000000..20f7d3ba --- /dev/null +++ b/modules/35-calling-functions/900-stdlib/es/data.yml @@ -0,0 +1,12 @@ +name: Biblioteca estándar +tips: + - > + [Referencia de funciones de + Python](https://docs.python.org/3/library/index.html) + - | + [Cómo buscar información técnica](https://codica.la/guides/how-to-search/) +definitions: + - name: Biblioteca estándar + description: >- + conjunto de funciones útiles que se incluyen en el lenguaje de + programación. diff --git a/modules/35-calling-functions/900-stdlib/ru/EXERCISE.md b/modules/35-calling-functions/900-stdlib/ru/EXERCISE.md new file mode 100644 index 00000000..2f9116bc --- /dev/null +++ b/modules/35-calling-functions/900-stdlib/ru/EXERCISE.md @@ -0,0 +1,8 @@ + +Функция `type()` позволяет определить тип передаваемого аргумента. Название типа возвращается в виде строки. Например, вызов `type(10)` вернёт строку `` (int, это сокращение от integer — целое число). + +```python +print(type('wow')) # +``` + +Выведите на экран тип значения переменной `motto`. diff --git a/modules/35-calling-functions/900-stdlib/ru/README.md b/modules/35-calling-functions/900-stdlib/ru/README.md new file mode 100644 index 00000000..db5cc0d4 --- /dev/null +++ b/modules/35-calling-functions/900-stdlib/ru/README.md @@ -0,0 +1,14 @@ + +Python поставляется с набором полезных функций, которые составляют **стандартную библиотеку**. Обычно в нее входят тысячи функций, которые невозможно запомнить. Поэтому программист должен знать, где найти документацию по этим функциям, а также представлять результат, который хочет получить. По этим причинам программировать без интернета сложно. + +Новички часто не понимают, как и где узнавать про функции, которые нужно использовать. При этом нет способа, который поможет решить эту проблему. По мере работы разработчики становятся опытнее, пополняют свой багаж знаний и практик. Постепенно они знакомятся с более интересными функциями, которые решают их задачи по-другому. + +Вот советы, которые помогут повысить уровень профессионализма: + +* Всегда отслеживайте, с каким типом данных вы работаете. Так вы найдете необходимую функцию в соответствующем разделе документации. Например, для работы со строками нужно изучать строковые функции + +* Периодически открывайте раздел со стандартными функциями по вашей тематике, изучайте сигнатуры и способы использования. + +* Чаще читайте чужой код на GitHub. Особенное внимание обращайте на код библиотек, которые используете + +Если следовать этим советам и внимательно относиться к деталям, то уже скоро вы заметите, как развиваетесь и растете как профессионал. diff --git a/modules/35-calling-functions/900-stdlib/ru/data.yml b/modules/35-calling-functions/900-stdlib/ru/data.yml new file mode 100644 index 00000000..109ca9e4 --- /dev/null +++ b/modules/35-calling-functions/900-stdlib/ru/data.yml @@ -0,0 +1,12 @@ +name: Стандартная библиотека +tips: + - | + [Справочник функций Python](https://docs-python.ru/standart-library/) + - > + [Как искать техническую + информацию](https://guides.hexlet.io/ru/how-to-search/) +definitions: + - name: Стандартная библиотека + description: >- + набор полезных функций, входящий в комплект поставки языка + программирования. diff --git a/modules/38-objects/100-objects/en/EXERCISE.md b/modules/38-objects/100-objects/en/EXERCISE.md new file mode 100644 index 00000000..8f18274c --- /dev/null +++ b/modules/38-objects/100-objects/en/EXERCISE.md @@ -0,0 +1,2 @@ + +Make the string `text` lowercase and print it on the screen. An example of a method that performs this task is given in the theory. diff --git a/modules/38-objects/100-objects/en/README.md b/modules/38-objects/100-objects/en/README.md new file mode 100644 index 00000000..b3db1921 --- /dev/null +++ b/modules/38-objects/100-objects/en/README.md @@ -0,0 +1,83 @@ + +The data we work with in programs have important attributes. In Python, they're built right into the language. Data also have methods - functions within properties. Properties and methods are expressions, just like variables or function calls. All of these can be combined in different ways. We'll look at the basics of them in this lesson. + +In programming, we operate with data, create numbers and strings, perform various operations on them and use their results. To perform an operation, we apply either operators or functions: + +```python +# Adding with the + operator +1 + 3 # 4 + +# Counting the length with the len() function +name = 'Hexlet' +len(name) # 6 +``` + +In the example above, there is a clear division: the data and functions are separated from each other. But this is not the only way to organize code. In Python, there's another approached used alongside this separation, the **Object Oriented (OO)** approach. + +Object-oriented code is based on combining data and functions into one entity, an **object**. Data in this case are called attributes, and functions are called methods. + +This is what it looks like: + +```python +name = 'Hexlet' +# upper() method +upper_name = name.upper() +print(upper_name) # => 'HEXLET' +``` + +Strings in Python are objects. In the example above, we call a method, which is, a function associated with a string. The call is made using a period that comes right after the variable name. Otherwise, the methods work like normal functions. + +The call can also be made directly: + +```python +'Hexlet'.upper() # 'HEXLET' +``` + +There are many methods built into strings which developers need all the time. You can see a list of them in the [documentation](https://python.readthedocs.io/en/latest/library/stdtypes.html#string-methods). Here are some useful examples: + +```python +name = 'Python' + +# Returns the index of the first occurrence of a letter in a string +name.find('t') # 2 + +# Changes to lower case +name.lower() # 'python' + +# Replaces one substring with another +name.replace('on', 'off') # 'Pythoff' +``` + +The same goes for numbers and other data types that we've not looked at. You could say that in Python almost everything is an object: + +```python +x = -5 +# Returns the modulus of a number +# The name looks strange, but it really is the name of the method +x.__abs__() +``` + +In the example above, there is a method name with two underscores at the beginning and at the end. In Python, this is the name given to methods that aren't intended to be called directly. Functions have been created for them that call methods themselves: + +```python +x = -5 +abs(x) # calls x.__abs__() +# -5 to the power of 3 +pow(x, 3) # calls x.__pow__(3) +``` + +The creator of Python [decided](https://stackoverflow.com/questions/83983/why-isnt-the-len-function-inherited-by-dictionaries-and-lists-in-python) that it would be clearer if mathematical operations and operations similar to mathematic ones were expressed in functions. He wanted such functions to be thought of as operations like addition or subtraction. This is more familiar to those who have studied mathematics. + +This is also how the `len()` function works: + +```python +len('Hexlet') # Calls 'Hexlet'.__len__() +``` + +In addition to methods, objects have attributes, but Python's built-in objects don't have many of them. For example, the attribute `__doc__`, which returns the documentation of the function. Therefore, functions are also considered objects: + +```python +len.__doc__ # 'Return the number of items in a container.' +``` + +Attributes work and look like variables, only they need to be entered like this: `[object].[attribute]`. diff --git a/modules/38-objects/100-objects/en/data.yml b/modules/38-objects/100-objects/en/data.yml new file mode 100644 index 00000000..7c756fde --- /dev/null +++ b/modules/38-objects/100-objects/en/data.yml @@ -0,0 +1 @@ +name: Objects diff --git a/modules/38-objects/100-objects/es/EXERCISE.md b/modules/38-objects/100-objects/es/EXERCISE.md new file mode 100644 index 00000000..82ff56bf --- /dev/null +++ b/modules/38-objects/100-objects/es/EXERCISE.md @@ -0,0 +1,2 @@ + +Convierte la cadena `text` a minúsculas e imprímela en la pantalla. En la teoría se muestra un ejemplo de un método que realiza esta tarea. diff --git a/modules/38-objects/100-objects/es/README.md b/modules/38-objects/100-objects/es/README.md new file mode 100644 index 00000000..ae719048 --- /dev/null +++ b/modules/38-objects/100-objects/es/README.md @@ -0,0 +1,83 @@ + +Los datos con los que operamos en los programas tienen atributos importantes. En Python, estos atributos están incorporados en el lenguaje. Además, los datos tienen métodos, que son funciones dentro de las propiedades. Las propiedades y los métodos son expresiones similares a las variables o ejecuciones de funciones. Todo esto se puede combinar de diferentes maneras. En esta lección, aprenderemos los fundamentos. + +En programación, operamos con datos, creamos números y cadenas, realizamos diversas operaciones sobre ellos y utilizamos el resultado obtenido. Para realizar una operación, aplicamos operadores o funciones: + +```python +# Suma utilizando el operador + +1 + 3 # 4 + +# Contar la longitud utilizando la función len() +name = 'Hexlet' +len(name) # 6 +``` + +En el ejemplo anterior, hay una clara separación entre los datos y las funciones. Pero esta no es la única forma de organizar el código. En Python, además de esta separación, se utiliza otro enfoque: **orientado a objetos (OO)**. + +El código orientado a objetos se basa en combinar datos y funciones en una sola entidad: un **objeto**. En este caso, los datos se llaman atributos y las funciones se llaman métodos. + +Así es como se ve: + +```python +name = 'Hexlet' +# Método upper() +upper_name = name.upper() +print(upper_name) # => 'HEXLET' +``` + +Las cadenas en Python son objetos. En el ejemplo anterior, ejecutamos un método, es decir, a una función que está asociada con la cadena. La llamada se realiza utilizando un punto que va inmediatamente después del nombre de la variable. En todo lo demás, los métodos funcionan como funciones normales. + +También se puede hacer la llamada directamente: + +```python +'Hexlet'.upper() # 'HEXLET' +``` + +Las cadenas tienen muchos métodos incorporados que son constantemente útiles para los desarrolladores. Puede ver una lista de ellos en la [documentación](https://python.readthedocs.io/en/latest/library/stdtypes.html#string-methods). Aquí hay algunos ejemplos útiles: + +```python +name = 'Python' + +# Devuelve el índice de la primera aparición de una letra en una cadena +name.find('t') # 2 + +# Convierte a minúsculas +name.lower() # 'python' + +# Reemplaza una subcadena por otra +name.replace('on', 'off') # 'Pythoff' +``` + +Lo mismo se aplica a los números y otros tipos de datos que aún no hemos estudiado. Se puede decir que en Python casi todo es un objeto: + +```python +x = -5 +# Devuelve el valor absoluto del número +# El nombre parece extraño, pero es el nombre real del método +x.__abs__() +``` + +En el ejemplo anterior, hay un nombre de método con dos guiones bajos al principio y al final. En Python, se llaman métodos que no están destinados a ser ejecutados directamente. Para ellos, se crearon funciones que, dentro de sí mismas, ejecutan los métodos: + +```python +x = -5 +abs(x) # ejecuta a x.__abs__() +# -5 elevado a la potencia 3 +pow(x, 3) # ejecuta a x.__pow__(3) +``` + +El creador de Python [decidió](https://stackoverflow.com/questions/83983/why-isnt-the-len-function-inherited-by-dictionaries-and-lists-in-python) que sería más claro expresar las operaciones matemáticas o similares a las matemáticas mediante funciones. Quería que estas funciones se percibieran como operaciones, como la suma o la resta. Esto es más familiar para aquellos que han estudiado matemáticas. + +Lo mismo ocurre con la función `len()`: + +```python +len('Hexlet') # Llama a 'Hexlet'.__len__() +``` + +Además de los métodos, los objetos también tienen atributos, pero los objetos incorporados en Python tienen pocos atributos. Por ejemplo, el atributo `__doc__` devuelve la documentación de una función. Por lo tanto, las funciones también se consideran objetos: + +```python +len.__doc__ # 'Return the number of items in a container.' +``` + +Los atributos funcionan y se ven como variables, pero se especifican con un punto después del objeto. diff --git a/modules/38-objects/100-objects/es/data.yml b/modules/38-objects/100-objects/es/data.yml new file mode 100644 index 00000000..49d12ac3 --- /dev/null +++ b/modules/38-objects/100-objects/es/data.yml @@ -0,0 +1,5 @@ +name: Objetos +tips: + - > + [Métodos de + cadenas](https://python.readthedocs.io/en/latest/library/stdtypes.html#string-methods) diff --git a/modules/38-objects/100-objects/ru/EXERCISE.md b/modules/38-objects/100-objects/ru/EXERCISE.md new file mode 100644 index 00000000..63ad3359 --- /dev/null +++ b/modules/38-objects/100-objects/ru/EXERCISE.md @@ -0,0 +1,2 @@ + +Приведите строку `text` к нижнему регистру и напечатайте её на экран. Пример метода, выполняющего эту задачу приведен в теории. diff --git a/modules/38-objects/100-objects/ru/README.md b/modules/38-objects/100-objects/ru/README.md new file mode 100644 index 00000000..2e23d206 --- /dev/null +++ b/modules/38-objects/100-objects/ru/README.md @@ -0,0 +1,83 @@ + +У данных, которыми мы оперируем в программах, есть важные атрибуты. В Python они встроены прямо в язык. Еще у данных есть методы — функции внутри свойств. Свойства и методы — такие же выражения, как переменные или вызовы функции. Все это можно по-разному комбинировать. В этом уроке изучим их основы. + +В программировании мы оперируем данными, создаем числа и строки, выполняем над ними различные операции и используем полученный результат. Чтобы выполнить операцию, мы применяем либо операторы, либо функции: + +```python +# Сложение с помощью оператора + +1 + 3 # 4 + +# Подсчет длины с помощью функции len() +name = 'Hexlet' +len(name) # 6 +``` + +В примере выше есть четкое разделение: данные отдельно, функции отдельно. Но это не единственный способ организации кода. В Python наравне с таким разделением, используется и другой подход — **объектно-ориентированный (ОО)**. + +Объектно-ориентированный код строится на объединении данных и функций в одну сущность — **объект**. Данные в таком случае называются атрибутами, а функции — методами. + +Так это выглядит: + +```python +name = 'Hexlet' +# Метод upper() +upper_name = name.upper() +print(upper_name) # => 'HEXLET' +``` + +Строки в Python — это объекты. В примере выше мы вызываем метод, то есть функцию, которая связана со строкой. Вызов происходит через точку, которая идет сразу за именем переменной. В остальном методы работают как обычные функции. + +Также вызов можно делать и напрямую: + +```python +'Hexlet'.upper() # 'HEXLET' +``` + +В строки встроено много методов, которые постоянно нужны разработчику. Посмотреть их список можно в [документации](https://python.readthedocs.io/en/latest/library/stdtypes.html#string-methods). Вот несколько полезных примеров: + +```python +name = 'Python' + +# Возвращает индекс первого вхождения буквы в строку +name.find('t') # 2 + +# Переводит в нижний регистр +name.lower() # 'python' + +# Заменяет одну подстроку другой +name.replace('on', 'off') # 'Pythoff' +``` + +То же самое касается чисел и остальных типов данных, которые мы пока не изучали. Можно сказать, что в Python почти все — объекты: + +```python +x = -5 +# Возвращает модуль числа +# Имя выглядит странно, но это действительно имя метода +x.__abs__() +``` + +В примере выше есть имя метода с двумя подчеркиваниями в начале и в конце. В Python так называют методы, которые не предназначены для прямого вызова. Для них создали функции, которые внутри себя уже сами вызывают методы: + +```python +x = -5 +abs(x) # вызывает x.__abs__() +# -5 в 3 степени +pow(x, 3) # вызывает x.__pow__(3) +``` + +Создатель Python [решил](https://stackoverflow.com/questions/83983/why-isnt-the-len-function-inherited-by-dictionaries-and-lists-in-python), что будет нагляднее, если математические или похожие на математические операции выразить функциями. Он хотел, чтобы такие функции воспринимались как операции, типа сложения или вычитания. Так привычнее для тех, кто изучал математику. + +Так же работает и функция `len()`: + +```python +len('Hexlet') # Вызывает 'Hexlet'.__len__() +``` + +Кроме методов у объектов есть атрибуты, но у встроенных в Python объектов их мало. Например, атрибут `__doc__`, который возвращает документацию функции. Поэтому функции тоже считаются объектами: + +```python +len.__doc__ # 'Return the number of items in a container.' +``` + +Атрибуты работают и выглядят как переменные, только указываются через точку после объекта. diff --git a/modules/38-objects/100-objects/ru/data.yml b/modules/38-objects/100-objects/ru/data.yml new file mode 100644 index 00000000..a8dfde5c --- /dev/null +++ b/modules/38-objects/100-objects/ru/data.yml @@ -0,0 +1,5 @@ +name: Объекты +tips: + - > + [Методы + строк](https://python.readthedocs.io/en/latest/library/stdtypes.html#string-methods) diff --git a/modules/38-objects/200-methods-immutability/en/EXERCISE.md b/modules/38-objects/200-methods-immutability/en/EXERCISE.md new file mode 100644 index 00000000..ca35d647 --- /dev/null +++ b/modules/38-objects/200-methods-immutability/en/EXERCISE.md @@ -0,0 +1,4 @@ + +User input data often contains extra spaces at the end or beginning of a string. They're usually cut out using a method [.strip()](https://docs.python.org/3/library/stdtypes.html), for example, it was ``hello\n'`` and now it's ``hello'``. + +Update the `first_name` variable by writing the same value to it, but this time processed by the `.strip()` method. Print the result. diff --git a/modules/38-objects/200-methods-immutability/en/README.md b/modules/38-objects/200-methods-immutability/en/README.md new file mode 100644 index 00000000..fbe92004 --- /dev/null +++ b/modules/38-objects/200-methods-immutability/en/README.md @@ -0,0 +1,19 @@ + +Imagine we have this call: + +```python +name = 'Tirion' +print(name.upper()) # => TIRION +# What will this call print on the screen? +print(name) # => ? +``` + +Calling the `.upper()` method returns a new value with all letters converted to upper case, but it does not change the original string. So inside the variable will be the old value: `'Tyrion'`. This logic holds true for methods of all primitive types. + +Instead of changing the value, you can **replace** it. This requires variables: + +```python +name = 'Tirion' +name = name.upper() +print(name) # => TIRION +``` diff --git a/modules/38-objects/200-methods-immutability/en/data.yml b/modules/38-objects/200-methods-immutability/en/data.yml new file mode 100644 index 00000000..b278cdcd --- /dev/null +++ b/modules/38-objects/200-methods-immutability/en/data.yml @@ -0,0 +1,2 @@ +name: Immutability +tips: [] diff --git a/modules/38-objects/200-methods-immutability/es/EXERCISE.md b/modules/38-objects/200-methods-immutability/es/EXERCISE.md new file mode 100644 index 00000000..cac8a2a5 --- /dev/null +++ b/modules/38-objects/200-methods-immutability/es/EXERCISE.md @@ -0,0 +1,4 @@ + +Los datos ingresados por los usuarios a menudo contienen espacios en blanco adicionales al principio o al final de la cadena. Por lo general, se eliminan utilizando el método [.strip()](https://docs.python.org/3/library/stdtypes.html). Por ejemplo, si teníamos: `' hello\n '`, ahora tenemos: `'hello'`. + +Actualiza la variable `first_name`, asignándole el mismo valor pero procesado con el método `.strip()`. Imprime en pantalla el resultado obtenido. diff --git a/modules/38-objects/200-methods-immutability/es/README.md b/modules/38-objects/200-methods-immutability/es/README.md new file mode 100644 index 00000000..a6171c7b --- /dev/null +++ b/modules/38-objects/200-methods-immutability/es/README.md @@ -0,0 +1,21 @@ + +Supongamos que tenemos la siguiente ejecución: + +```python +name = 'Tirion' +print(name.upper()) # => TIRION +# ¿Qué imprimirá esta ejecución? +print(name) # => ? +``` + +La llamada al método `.upper()` devuelve un nuevo valor en el que todas las letras están convertidas a mayúsculas, pero no modifica la cadena original. Por lo tanto, el valor dentro de la variable seguirá siendo el antiguo: `'Tirion'`. Esta lógica se aplica a los métodos de todos los tipos primitivos. + +En lugar de modificar los valores, se pueden **reemplazar** los valores. Para ello, se necesitan variables: + +```python +name = 'Tirion' +name = name.upper() +print(name) # => TIRION +``` + +https://replit.com/@hexlet/python-basics-objects-methods-immutability diff --git a/modules/38-objects/200-methods-immutability/es/data.yml b/modules/38-objects/200-methods-immutability/es/data.yml new file mode 100644 index 00000000..ddb4d24c --- /dev/null +++ b/modules/38-objects/200-methods-immutability/es/data.yml @@ -0,0 +1,5 @@ +name: Inmutabilidad +definitions: + - name: Método + description: | + es una función o procedimiento que pertenece a una clase u objeto. diff --git a/modules/38-objects/200-methods-immutability/ru/EXERCISE.md b/modules/38-objects/200-methods-immutability/ru/EXERCISE.md new file mode 100644 index 00000000..f9277322 --- /dev/null +++ b/modules/38-objects/200-methods-immutability/ru/EXERCISE.md @@ -0,0 +1,4 @@ + +Данные, вводимые пользователями, часто содержат лишние пробельные символы в конце или начале строки. Обычно их вырезают с помощью метода [.strip()](https://docs.python.org/3/library/stdtypes.html), например, было: `' hello\n '`, стало: `'hello'`. + +Обновите переменную `first_name`, записав в неё то же самое значение, но обработанное методом `.strip()`. Распечатайте то, что получилось, на экран. diff --git a/modules/38-objects/200-methods-immutability/ru/README.md b/modules/38-objects/200-methods-immutability/ru/README.md new file mode 100644 index 00000000..0e1c2415 --- /dev/null +++ b/modules/38-objects/200-methods-immutability/ru/README.md @@ -0,0 +1,21 @@ + +Допустим, у нас есть такой вызов: + +```python +name = 'Tirion' +print(name.upper()) # => TIRION +# Что напечатает на экран этот вызов? +print(name) # => ? +``` + +Вызов метода `.upper()` возвращает новое значение, в котором все буквы преобразованы в верхний регистр, но он не меняет исходную строку. Поэтому внутри переменной окажется старое значение: `'Tirion'`. Эта логика справедлива для методов всех примитивных типов. + +Вместо того чтобы изменять значения, можно **заменить** значение. Для этого понадобятся переменные: + +```python +name = 'Tirion' +name = name.upper() +print(name) # => TIRION +``` + +https://replit.com/@hexlet/python-basics-objects-methods-immutability diff --git a/modules/38-objects/200-methods-immutability/ru/data.yml b/modules/38-objects/200-methods-immutability/ru/data.yml new file mode 100644 index 00000000..b0024173 --- /dev/null +++ b/modules/38-objects/200-methods-immutability/ru/data.yml @@ -0,0 +1,5 @@ +name: Неизменяемость +definitions: + - name: Метод + description: | + это функция или процедура, принадлежащая какому-то классу или объекту. diff --git a/modules/38-objects/300-method-expressions/en/EXERCISE.md b/modules/38-objects/300-method-expressions/en/EXERCISE.md new file mode 100644 index 00000000..b2a6523b --- /dev/null +++ b/modules/38-objects/300-method-expressions/en/EXERCISE.md @@ -0,0 +1,9 @@ + +Find the characters *N* and *,* (comma) inside the text in the `text` variable. Print their indices on the screen. Expected output from the tests: + +
+Index Of N: 0
+Index Of ,: 25
+
+ +Your task is to find these indices in the string using the `.find()` method and put them in `print()` without using intermediate variables. If you want to split the output into two lines, you may need `\n`. diff --git a/modules/38-objects/300-method-expressions/en/README.md b/modules/38-objects/300-method-expressions/en/README.md new file mode 100644 index 00000000..c809f1ff --- /dev/null +++ b/modules/38-objects/300-method-expressions/en/README.md @@ -0,0 +1,20 @@ + +Methods are expressions, like variables or function calls, which means they can be combined in different ways. + +For example, you can use them in operations: + +```python +name = 'Shaya' +'hi, ' + name.upper() + '!' # hi, SHAYA! +``` + +Or in function parameters: + +```python +name = 'robb' +print(name.lower()) # => robb +num1 = 5 +num2 = 30 +# bit_length() - calculates the number of bits needed to represent a number in binary form +print(num1.bit_length() + num2.bit_length()) # => 8 +``` diff --git a/modules/38-objects/300-method-expressions/en/data.yml b/modules/38-objects/300-method-expressions/en/data.yml new file mode 100644 index 00000000..385cb4e3 --- /dev/null +++ b/modules/38-objects/300-method-expressions/en/data.yml @@ -0,0 +1,2 @@ +name: Methods as expressions +tips: [] diff --git a/modules/38-objects/300-method-expressions/es/EXERCISE.md b/modules/38-objects/300-method-expressions/es/EXERCISE.md new file mode 100644 index 00000000..336ab359 --- /dev/null +++ b/modules/38-objects/300-method-expressions/es/EXERCISE.md @@ -0,0 +1,9 @@ + +Encuentra los caracteres *N* y *,* (coma) dentro del texto en la variable `text`. Imprime sus índices en la pantalla. Resultado esperado de las pruebas: + +
+Index Of N: 0
+Index Of ,: 25
+
+ +Tu tarea es encontrar estos índices en la cadena utilizando el método `.find()` y colocarlos en `print()`, sin utilizar variables intermedias. Este ejercicio se puede resolver tanto con interpolación como con concatenación. Si utilizas concatenación, el resultado obtenido debe convertirse a tipo de cadena. Para dividir la salida en dos líneas, puedes utilizar `\n`. diff --git a/modules/38-objects/300-method-expressions/es/README.md b/modules/38-objects/300-method-expressions/es/README.md new file mode 100644 index 00000000..66f18189 --- /dev/null +++ b/modules/38-objects/300-method-expressions/es/README.md @@ -0,0 +1,22 @@ + +Los métodos son expresiones al igual que las variables o las llamadas a funciones, por lo tanto, se pueden combinar de diferentes maneras. + +Por ejemplo, se pueden utilizar en operaciones: + +```python +name = 'Shaya' +'hi, ' + name.upper() + '!' # hi, SHAYA! +``` + +O se pueden utilizar como parámetros de funciones: + +```python +name = 'robb' +print(name.lower()) # => robb +num1 = 5 +num2 = 30 +# bit_length() calcula la cantidad de bits necesarios para representar un número en binario +print(num1.bit_length() + num2.bit_length()) # => 8 +``` + +https://replit.com/@hexlet/python-basics-objects-method-expression diff --git a/modules/38-objects/300-method-expressions/es/data.yml b/modules/38-objects/300-method-expressions/es/data.yml new file mode 100644 index 00000000..d1bc8766 --- /dev/null +++ b/modules/38-objects/300-method-expressions/es/data.yml @@ -0,0 +1,5 @@ +name: Métodos como expresiones +definitions: + - name: Método + description: | + es una función o procedimiento que pertenece a una clase u objeto. diff --git a/modules/38-objects/300-method-expressions/ru/EXERCISE.md b/modules/38-objects/300-method-expressions/ru/EXERCISE.md new file mode 100644 index 00000000..fbeb7933 --- /dev/null +++ b/modules/38-objects/300-method-expressions/ru/EXERCISE.md @@ -0,0 +1,9 @@ + +Найдите символы *N* и *,* (запятая) внутри текста в переменной `text`. Выведите на экран их индексы. Ожидаемый тестами вывод: + +
+Index Of N: 0
+Index Of ,: 25
+
+ +Ваша задача найти эти индексы в строке с помощью метода `.find()` и вставить в `print()`, не используя промежуточные переменные. Это упражнение можно решить как при помощи интерполяции, так и при помощи конкатенации. Если вы используете конкатенацию, то полученный результат необходимо привести к строковому типу. Для разбиения вывода на две строки, вам может понадобится `\n`. diff --git a/modules/38-objects/300-method-expressions/ru/README.md b/modules/38-objects/300-method-expressions/ru/README.md new file mode 100644 index 00000000..a9cb0c99 --- /dev/null +++ b/modules/38-objects/300-method-expressions/ru/README.md @@ -0,0 +1,22 @@ + +Методы — такие же выражения, как переменные или вызовы функции, значит, их можно по-разному комбинировать. + +Например, использовать в операциях: + +```python +name = 'Shaya' +'hi, ' + name.upper() + '!' # hi, SHAYA! +``` + +Или использовать в параметрах функций: + +```python +name = 'robb' +print(name.lower()) # => robb +num1 = 5 +num2 = 30 +# bit_length() — вычисляет количество бит, необходимых для представления числа в двоичном виде +print(num1.bit_length() + num2.bit_length()) # => 8 +``` + +https://replit.com/@hexlet/python-basics-objects-method-expression diff --git a/modules/38-objects/300-method-expressions/ru/data.yml b/modules/38-objects/300-method-expressions/ru/data.yml new file mode 100644 index 00000000..dec15af8 --- /dev/null +++ b/modules/38-objects/300-method-expressions/ru/data.yml @@ -0,0 +1,5 @@ +name: Методы как выражения +definitions: + - name: Метод + description: | + это функция или процедура, принадлежащая какому-то классу или объекту. diff --git a/modules/38-objects/500-method-chain/en/EXERCISE.md b/modules/38-objects/500-method-chain/en/EXERCISE.md new file mode 100644 index 00000000..48b16a42 --- /dev/null +++ b/modules/38-objects/500-method-chain/en/EXERCISE.md @@ -0,0 +1,2 @@ + +Use the string cutter to get part of the sentence written in the `text` variable, from `5` to `15` characters inclusive. Process the resulting substring using the `.strip()` method and display the length of the resulting substring. Perform these operations in a chain without creating intermediate variables. diff --git a/modules/38-objects/500-method-chain/en/README.md b/modules/38-objects/500-method-chain/en/README.md new file mode 100644 index 00000000..30369494 --- /dev/null +++ b/modules/38-objects/500-method-chain/en/README.md @@ -0,0 +1,49 @@ + +In this lesson, we'll look at how to combine different approaches when writing code, and we'll also look at common beginner mistakes. + +We have the following code: + +```python +name = 'Tirion' +print(name.upper().lower()) # => `tirion` +``` + +He typed `tirion' on the screen. + +This is the first time we have seen the syntax of several consecutive dots, but all the operations we encounter here are familiar. This code combines known features of the language. + +This happens a lot in programming. If you don't know the syntax, you can still try combining different approaches, and chances are they will work. + +To understand how this code works, you need to break down the chain into separate operations: + +```python +name = 'Tirion' +upper_name = name.upper() # 'TIRION' +print(upper_name.lower()) # 'tirion' +``` + +The first and second examples are equivalent. We can perform operations sequentially with intermediate creation of variables, or we can build a continuous chain of attributes and methods. In chains, calculations always go from left to right. + +One more example to reinforce: + +```python +name = 'Tirion' +print(name.replace('Ti', 'Ki').lower()) # => ? +``` + +This code needs a lot of thought. `.lower()` applies to the result of the method call, which is on the left. And the `replace()` method returns a string. Newbies often make mistakes in method chains and forget to place a call: + +```python +name = 'Tirion' +# This code will not work correctly! +print(name.upper.lower()) +``` + +It is also possible to build infinitely long and useless chains that include slices: + +```python +# What is the result of such a call? +print(name[1:5].upper().find('I')) +``` + +This will not work with functions, since they are usually nested inside each other - `f(f(f())))`. This makes the analysis much worse. But that doesn't mean it can't be done nicely. In other languages, this is implemented through a composition of functions or a pipelining operator. diff --git a/modules/38-objects/500-method-chain/en/data.yml b/modules/38-objects/500-method-chain/en/data.yml new file mode 100644 index 00000000..556fa417 --- /dev/null +++ b/modules/38-objects/500-method-chain/en/data.yml @@ -0,0 +1,2 @@ +name: The call chain +tips: [] diff --git a/modules/38-objects/500-method-chain/es/EXERCISE.md b/modules/38-objects/500-method-chain/es/EXERCISE.md new file mode 100644 index 00000000..65ce9eab --- /dev/null +++ b/modules/38-objects/500-method-chain/es/EXERCISE.md @@ -0,0 +1,2 @@ + +Usando el corte de cadenas, obtén una parte de la oración almacenada en la variable `text`, desde el carácter `5` hasta el carácter `15`, inclusive. Luego, procesa la subcadena obtenida con el método `.strip()` y muestra en pantalla la longitud de la subcadena resultante. Realiza estas operaciones en cadena sin crear variables intermedias. diff --git a/modules/38-objects/500-method-chain/es/README.md b/modules/38-objects/500-method-chain/es/README.md new file mode 100644 index 00000000..b8b98710 --- /dev/null +++ b/modules/38-objects/500-method-chain/es/README.md @@ -0,0 +1,50 @@ + +En esta lección veremos cómo combinar diferentes enfoques al escribir código, así como también analizaremos los errores típicos de los principiantes. + +Tenemos el siguiente código: + +```python +name = 'Tirion' +print(name.upper().lower()) # => `tirion` +``` + +Imprime en la pantalla `tirion`. + +Es la primera vez que vemos la sintaxis de varios puntos seguidos, pero todas las operaciones que aparecen aquí nos son familiares. En este código se combinan las capacidades conocidas hasta el momento del lenguaje estudiado. + +Esto ocurre a menudo en la programación. Si no conoces la sintaxis, aún puedes intentar combinar diferentes enfoques y existe la posibilidad de que funcionen. + +Para entender cómo funciona este código, debemos descomponer la cadena de llamadas en operaciones individuales: + +```python +name = 'Tirion' +upper_name = name.upper() # 'TIRION' +print(upper_name.lower()) # 'tirion' +``` + +Los primeros dos ejemplos son equivalentes. Podemos realizar operaciones secuencialmente con la creación intermedia de variables, o podemos construir una cadena continua de atributos y métodos. En las cadenas de llamadas, los cálculos siempre se realizan de izquierda a derecha. + +Otro ejemplo para reforzar el concepto: + +```python +name = 'Tirion' +print(name.replace('Ti', 'Ki').lower()) # => ? +``` + +Necesitamos pensar bien en este código. `.lower()` se aplica al resultado de la llamada al método que está a la izquierda. Y el método `replace()` devuelve una cadena. Los principiantes a menudo cometen errores en las cadenas de llamadas y olvidan hacer la ejecución: + +```python +name = 'Tirion' +# ¡Este código no funcionará correctamente! +print(name.upper.lower()) +``` + +También es posible construir cadenas infinitamente largas e inútiles que incluyen listas o slices: + +```python +name = 'Tirion' +# ¿Cuál es el resultado de esta ejecución? +print(name[1:5].upper().find('I')) +``` + +Esto no funciona con las funciones, ya que generalmente se anidan unas dentro de otras: `f(f(f()))`. Esto dificulta mucho el análisis. Pero esto no significa que no se pueda hacer de manera elegante. En otros lenguajes, esto se logra a través de la composición de funciones o el operador de canalización. diff --git a/modules/38-objects/500-method-chain/es/data.yml b/modules/38-objects/500-method-chain/es/data.yml new file mode 100644 index 00000000..14597eb0 --- /dev/null +++ b/modules/38-objects/500-method-chain/es/data.yml @@ -0,0 +1,5 @@ +name: Cadena de llamadas +definitions: + - name: Método + description: | + es una función o procedimiento que pertenece a una clase u objeto. diff --git a/modules/38-objects/500-method-chain/ru/EXERCISE.md b/modules/38-objects/500-method-chain/ru/EXERCISE.md new file mode 100644 index 00000000..90aa1df2 --- /dev/null +++ b/modules/38-objects/500-method-chain/ru/EXERCISE.md @@ -0,0 +1,2 @@ + +С помощью среза строк получите часть предложения, записанного в переменную `text`, c `5` по `15` символы включительно. Полученную подстроку обработайте методом `.strip()` и выведите на экран длину итоговой подстроки. Выполните эти операции подряд в цепочке без создания промежуточных переменных. diff --git a/modules/38-objects/500-method-chain/ru/README.md b/modules/38-objects/500-method-chain/ru/README.md new file mode 100644 index 00000000..7a390bd5 --- /dev/null +++ b/modules/38-objects/500-method-chain/ru/README.md @@ -0,0 +1,50 @@ + +В этом уроке мы рассмотрим, как комбинировать различные подходы, когда пишем код, а также разберем типичные ошибки новичков. + +У нас есть следующий код: + +```python +name = 'Tirion' +print(name.upper().lower()) # => `tirion` +``` + +Он напечатал на экране `tirion`. + +Синтаксис нескольких подряд идущих точек мы видим впервые, но все операции, которые здесь встречаются, нам знакомы. В этом коде объединились известные возможности языка. + +Такое в программировании происходит часто. Если вы не знаете синтаксис, то можно все равно пробовать комбинировать различные подходы, и есть вероятность, что они заработают. + +Чтобы понять, как работает этот код, нужно разбить цепочку на отдельные операции: + +```python +name = 'Tirion' +upper_name = name.upper() # 'TIRION' +print(upper_name.lower()) # 'tirion' +``` + +Первый и второй примеры эквивалентны. Мы можем выполнять операции последовательно с промежуточным созданием переменных, а можем строить непрерывную цепочку из атрибутов и методов. В цепочках вычисления всегда идут слева направо. + +Еще один пример для закрепления: + +```python +name = 'Tirion' +print(name.replace('Ti', 'Ki').lower()) # => ? +``` + +Над этим кодом нужно хорошо подумать. `.lower()` применяется к результату вызова метода, который находится левее. А метод `replace()` возвращает строку. Новички часто делают ошибки в цепочках с методами и забывают ставить вызов: + +```python +name = 'Tirion' +# Этот код отработает неверно! +print(name.upper.lower()) +``` + +Также возможно строить бесконечно длинные и бесполезные цепочки, которые включают в себя срезы: + +```python +name = 'Tirion' +# Чему равен результат такого вызова? +print(name[1:5].upper().find('I')) +``` + +С функциями это не сработает, так как обычно они вкладываются друг в друга — `f(f(f()))`. Это значительно ухудшает анализ. Но это не значит, что нельзя сделать красиво. В других языках это реализуется через композицию функций или пайплайн-оператор. diff --git a/modules/38-objects/500-method-chain/ru/data.yml b/modules/38-objects/500-method-chain/ru/data.yml new file mode 100644 index 00000000..f979016c --- /dev/null +++ b/modules/38-objects/500-method-chain/ru/data.yml @@ -0,0 +1,5 @@ +name: Цепочка вызовов +definitions: + - name: Метод + description: | + это функция или процедура, принадлежащая какому-то классу или объекту. diff --git a/modules/40-define-functions/100-define-function/en/EXERCISE.md b/modules/40-define-functions/100-define-function/en/EXERCISE.md new file mode 100644 index 00000000..c97d4286 --- /dev/null +++ b/modules/40-define-functions/100-define-function/en/EXERCISE.md @@ -0,0 +1,8 @@ + +Implement a function named `print_motto()` that displays the phrase *Winter is coming*. + +```python +print_motto() # => Winter is coming +``` + +In tasks where you have to implement a function, you don't need to call it. Automated tests will call this function to check if it works. The example call above is shown just to give you an idea of how your function will be used. diff --git a/modules/40-define-functions/100-define-function/en/README.md b/modules/40-define-functions/100-define-function/en/README.md new file mode 100644 index 00000000..22f00b6c --- /dev/null +++ b/modules/40-define-functions/100-define-function/en/README.md @@ -0,0 +1,56 @@ + +It is easier to write and maintain programs if you define your own functions. They allow you to combine compound operations into one. So in this lesson, we'll talk about how to create your own functions. + +Let's say we want to send emails on a website. This is quite a complicated process that involves interaction with external systems. But if you define a function, all the complexity can be hidden behind one simple function: + +```python +# Hypothetical example +# Where the function comes from +from emails import send + +email = 'support@hexlet.io' +title = 'Help' +body = 'I wrote a success story, how can I get a discount?' + +# There's just one call, but it's got a lot of logic inside +send(email, title, body) +``` + +Internally, this call does a lot; it connects to the mail server, forms a valid request based on the message header and body, and then sends everything out without forgetting to close the connection. + +Let's create our first function. Its task is to display a greeting: + +```bash +Hello, Hexlet! +``` + +```python +# Function definition +# Defining a function does not invoke or execute it +# We're only saying that this function now exists +def show_greeting(): + # Indent four spaces inside the body + text = 'Hello, Hexlet!' + print(text) + +# Function call +show_greeting() # => 'Hello, Hexlet!' +``` + +Unlike ordinary data, functions perform actions. Therefore, their names should be specified through verbs: “build something,” “draw something,” “open something”. + +The information that's indented below the function name is called the **function body**. Any code can be entered within the body. It's like a small independent program, with whatever instructions you put in + +The body is executed the moment the function is started. In this case, each function call launches the body independently of the other calls. + +The body of the function can be empty. In that case, the keyword `pass` is used inside it: + +```python +# Minimum function definition +def noop(): + pass + +noop() +``` + +The term “create a function” has many synonyms, you can also implement a function, or define it. These can often be found when working the real world. By creating your own function, you can make complex operations and development easier. diff --git a/modules/40-define-functions/100-define-function/en/data.yml b/modules/40-define-functions/100-define-function/en/data.yml new file mode 100644 index 00000000..b68d57a4 --- /dev/null +++ b/modules/40-define-functions/100-define-function/en/data.yml @@ -0,0 +1,5 @@ +name: Creating (defining) functions +tips: + - > + [Naming in + programming](https://hexlet.io/blog/posts/code-complete-naming-in-programming) diff --git a/modules/40-define-functions/100-define-function/es/EXERCISE.md b/modules/40-define-functions/100-define-function/es/EXERCISE.md new file mode 100644 index 00000000..98fc3875 --- /dev/null +++ b/modules/40-define-functions/100-define-function/es/EXERCISE.md @@ -0,0 +1,8 @@ + +Implementa una función llamada `print_motto()` que mostrará en la pantalla la frase *Winter is coming*. + +```python +print_motto() # => Winter is coming +``` + +En los ejercicios en los que se requiere implementar una función, no es necesario llamar a esa función. Las pruebas automatizadas se encargarán de llamarla y verificar su funcionalidad. El ejemplo de llamada anterior se muestra solo para que comprendas cómo se utilizará tu función. diff --git a/modules/40-define-functions/100-define-function/es/README.md b/modules/40-define-functions/100-define-function/es/README.md new file mode 100644 index 00000000..8e531140 --- /dev/null +++ b/modules/40-define-functions/100-define-function/es/README.md @@ -0,0 +1,58 @@ + +Es más fácil escribir y mantener programas utilizando funciones propias. Permiten combinar operaciones compuestas en una sola. Por lo tanto, en esta lección hablaremos sobre cómo crear funciones propias. + +Supongamos que queremos enviar correos electrónicos en un sitio web, esto es un proceso bastante complejo que implica interactuar con sistemas externos. Pero si definimos una función, toda la complejidad se ocultará detrás de una función simple: + +```python +# Ejemplo hipotético +# Lugar donde se encuentra la función +from emails import send + +email = 'support@hexlet.io' +title = 'Ayuda' +body = 'Escribí una historia de éxito, ¿cómo puedo obtener un descuento?' + +# Una pequeña ejecución - mucha lógica interna +send(email, title, body) +``` + +Esta ejecución realiza acciones de gran lógica interna: se conecta al servidor de correo, forma una solicitud correcta basada en el título y el cuerpo del mensaje, y luego lo envía todo, sin olvidar cerrar la conexión. + +Creemos nuestra primera función. Su tarea es mostrar un saludo en la pantalla: + +```bash +Hello, Hexlet! +``` + +```python +# Definición de la función +# La definición no llama ni ejecuta la función +# Solo decimos que ahora existe esta función +def show_greeting(): + # Dentro del cuerpo, hay una sangría de cuatro espacios + text = 'Hello, Hexlet!' + print(text) + +# Llamada a la función +show_greeting() # => '¡Hola, Hexlet!' +``` + +https://replit.com/@hexlet/python-basics-define-function + +A diferencia de los datos normales, las funciones realizan acciones. Por lo tanto, sus nombres deben indicarse con verbos: "construir algo", "dibujar algo", "abrir algo". + +La descripción que se encuentra debajo del nombre de la función con sangría se llama **cuerpo de la función**. Dentro del cuerpo se puede describir cualquier código. Es como un pequeño programa independiente, un conjunto de instrucciones arbitrarias. + +El cuerpo se ejecuta cuando se ejecuta la función. Cada llamada a la función ejecuta el cuerpo de forma independiente de otras llamadas. + +El cuerpo de la función puede estar vacío, en ese caso se utiliza la palabra clave `pass`: + +```python +# Definición mínima de una función +def noop(): + pass + +noop() +``` + +El concepto de "crear una función" tiene muchos sinónimos: "implementar", "definir" e incluso "declarar". Se encuentran con frecuencia en la práctica. Al crear su propia función, facilitará las operaciones complejas y hará que el desarrollo sea más sencillo. diff --git a/modules/40-define-functions/100-define-function/es/data.yml b/modules/40-define-functions/100-define-function/es/data.yml new file mode 100644 index 00000000..6de0d604 --- /dev/null +++ b/modules/40-define-functions/100-define-function/es/data.yml @@ -0,0 +1,4 @@ +name: Creación (definición) de funciones +tips: + - | + [Naming en programación](https://codica.la/blog/naming-in-programming) diff --git a/modules/40-define-functions/100-define-function/ru/EXERCISE.md b/modules/40-define-functions/100-define-function/ru/EXERCISE.md new file mode 100644 index 00000000..392461b0 --- /dev/null +++ b/modules/40-define-functions/100-define-function/ru/EXERCISE.md @@ -0,0 +1,8 @@ + +Реализуйте функцию с именем `print_motto()`, которая выведет на экран фразу *Winter is coming*. + +```python +print_motto() # => Winter is coming +``` + +В задачах, в которых нужно реализовать функцию, эту функцию вызывать не нужно. Вызывать функцию будут автоматизированные тесты, которые проверяют его работоспособность. Пример с вызовом выше показан только для того, чтобы вы понимали, как ваша функция будет использоваться. diff --git a/modules/40-define-functions/100-define-function/ru/README.md b/modules/40-define-functions/100-define-function/ru/README.md new file mode 100644 index 00000000..fb13162b --- /dev/null +++ b/modules/40-define-functions/100-define-function/ru/README.md @@ -0,0 +1,58 @@ + +С помощью определения собственных функций писать и поддерживать программы проще. Они позволяют объединять составные операции в одну. Поэтому в этом уроке поговорим, как создавать собственные функции. + +Допустим, мы хотим отправить письма на сайте — это достаточно сложный процесс, который включает взаимодействие с внешними системами. Но если определить функцию, вся сложность скроется за одной простой функцией: + +```python +# Гипотетический пример +# Место откуда берется функция +from emails import send + +email = 'support@hexlet.io' +title = 'Помогите' +body = 'Я написал историю успеха, как я могу получить скидку?' + +# Один маленький вызов — много логики внутри +send(email, title, body) +``` + +Внутри себя этот вызов выполняет много логики: соединяется с почтовым сервером, формирует правильный запрос на основе заголовка и тела сообщения, а затем все отправляет, не забыв закрыть соединение. + +Создадим нашу первую функцию. Ее задача — вывести на экран приветствие: + +```bash +Hello, Hexlet! +``` + +```python +# Определение функции +# Определение не вызывает и не выполняет функцию +# Мы лишь говорим, что теперь такая функция существует +def show_greeting(): + # Внутри тела отступ четыре пробела + text = 'Hello, Hexlet!' + print(text) + +# Вызов функции +show_greeting() # => 'Hello, Hexlet!' +``` + +https://replit.com/@hexlet/python-basics-define-function + +В отличие от обычных данных, функции выполняют действия. Поэтому их имена нужно указывать через глаголы: «построить что-то», «нарисовать что-то», «открыть что-то». + +Описание, которое находится ниже имени функции с отступом, называется **телом функции**. Внутри тела можно описывать любой код. Это как небольшая самостоятельная программа — набор произвольных инструкций. + +Тело выполняется в тот момент, когда запускается функция. При этом каждый вызов функции запускает тело независимо от других вызовов. + +Тело функции может быть пустым, тогда внутри него используется ключевое слово `pass`: + +```python +# Минимальное определение функции +def noop(): + pass + +noop() +``` + +У понятия «создать функцию» много синонимов: «реализовать», «определить» и даже «заимплементить». Они часто встречаются на практике. Создавая свою функцию, вы облегчите сложные операции и сделаете разработку проще. diff --git a/modules/40-define-functions/100-define-function/ru/data.yml b/modules/40-define-functions/100-define-function/ru/data.yml new file mode 100644 index 00000000..22876b2f --- /dev/null +++ b/modules/40-define-functions/100-define-function/ru/data.yml @@ -0,0 +1,5 @@ +name: Создание (определение) функций +tips: + - > + [Именование в + программировании](https://ru.hexlet.io/blog/posts/naming-in-programming) diff --git a/modules/40-define-functions/200-return/en/EXERCISE.md b/modules/40-define-functions/200-return/en/EXERCISE.md new file mode 100644 index 00000000..6b22545b --- /dev/null +++ b/modules/40-define-functions/200-return/en/EXERCISE.md @@ -0,0 +1,7 @@ + +Implement the `say_hurray_three_times()` function, which returns the string 'hurray! hurray! hurray!'. + +```python +hurray = say_hurray_three_times() +print(hurray) # => hurray! hurray! hurray! +``` diff --git a/modules/40-define-functions/200-return/en/README.md b/modules/40-define-functions/200-return/en/README.md new file mode 100644 index 00000000..96271158 --- /dev/null +++ b/modules/40-define-functions/200-return/en/README.md @@ -0,0 +1,105 @@ + +In this lesson, we'll take a closer look at how to work with functions we've created to make them useful. + +When we define a function, it prints data on the screen: + +```python +def greeting(): + print('Hello, Hexlet!') +``` + +These functions are of little use, because the result can't be used within the program. Let's look at an example. + +Let's say we're processing an email address. When a user registers on the site, they can enter their email address in any way they wants: + +* Add random spaces at the beginning or at the end: `_support@hexlet.io__` +* Use letters in different cases: `SUPPORT@hexlet.io` + +If we save it that way in the database, the user won't be able to log in. To avoid this, the email must be prepared to be written to the database, we need to convert it to lower case and trim the spaces around the edges of the string. This problem can be solved in a couple of lines: + +```python +def save_email(): + # Email comes from the form + email = ' SuppORT@hexlet.IO' + # Trim whitespace characters + trimmed_email = email.strip() + prepared_email = trimmed_email.lower() + print(prepared_email) + # Here will be the entry in the database +``` + +This code was made possible because the value was returned. The `strip()` and `lower()` methods do not print anything on the screen, they **return** the result of their work. This means we can write it to variables. If they were printed to the screen, we wouldn't be able to assign the result to a variable. For example, we can't do that with the `greeting()` function: + +```python +message = greeting() +# in actual fact, print() returns None +# None is a special object used to represent no value +print(message) # => None +``` + +Now change the `greeting()` function so that it returns data. To do this, let's perform a return instead of printing to the screen: + +```python +def greeting(): + return 'Hello, Hexlet!' +``` + +`return' is an instruction. It takes the expression written to the right and gives it to the code that called the method. This is where the function ends. + +```python +# Now we can use the result of the function +message = greeting() +print(message) # => Hello, Hexlet! +# And even perform some actions on the result +print(message.upper()) # => HELLO, HEXLET! +``` + +Any code after `return` is not executed: + +```python +def greeting_with_code_after_return(): + return 'Hello, Hexlet!' + print('I will never be executed') +``` + +Even if the function returns data, this doesn't limit what it prints. In addition to returning data, we can also print: + +```python +def greeting_with_return_and_printing(): + print('I will appear in the console') + return 'Hello, Hexlet!' + + +# And it'll print the text on the screen and return the value +message = greeting_with_return_and_printing() +``` + +You can print more than just a specific value. Since `return` works with expressions, it can have anything to the right of it. Here we should keep to the principles of code readability: + +```python +def greeting(): + message = 'Hello, Hexlet!' + return message +``` + +Here we don't return a variable. The value in this variable is always returned. Below is an example with calculations: + +```python +def double_five(): + # или return 5 + 5 + result = 5 + 5 + return result +``` + +It's not enough to just define a function. It's also important for it to be useful, and that the result is used. Now think about what the call to the `run()` function defined below will return? + +```python +# Definition +def run(): + return 5 + return 10 + + +# What will be displayed? +print(run()) +``` diff --git a/modules/40-define-functions/200-return/en/data.yml b/modules/40-define-functions/200-return/en/data.yml new file mode 100644 index 00000000..f7488f6f --- /dev/null +++ b/modules/40-define-functions/200-return/en/data.yml @@ -0,0 +1 @@ +name: Return values diff --git a/modules/40-define-functions/200-return/es/EXERCISE.md b/modules/40-define-functions/200-return/es/EXERCISE.md new file mode 100644 index 00000000..7772a9fb --- /dev/null +++ b/modules/40-define-functions/200-return/es/EXERCISE.md @@ -0,0 +1,7 @@ + +Implementa la función `say_hurray_three_times()`, que devuelve la cadena 'hurray! hurray! hurray!'. + +```python +hurray = say_hurray_three_times() +print(hurray) # => hurray! hurray! hurray! +``` diff --git a/modules/40-define-functions/200-return/es/README.md b/modules/40-define-functions/200-return/es/README.md new file mode 100644 index 00000000..876a25d5 --- /dev/null +++ b/modules/40-define-functions/200-return/es/README.md @@ -0,0 +1,107 @@ + +En esta lección vamos a profundizar en cómo trabajar con las funciones creadas para que sean útiles. + +Cuando definimos una función, esta imprime algunos datos en la pantalla: + +```python +def greeting(): + print('Hello, Hexlet!') +``` + +Estas funciones tienen poca utilidad, ya que no se puede utilizar su resultado dentro del programa. Veámoslo en un ejemplo. + +Tomemos el caso de procesar un correo electrónico. Cuando un usuario se registra en un sitio web, puede ingresar su correo electrónico de diferentes maneras: + +* Agregar espacios en blanco al principio o al final: `_support@hexlet.io__` +* Usar letras en diferentes casos: `SUPPORT@hexlet.io` + +Si lo guardamos en la base de datos en ese formato, el usuario no podrá iniciar sesión en el sitio web. Para evitar esto, es necesario preparar el correo electrónico antes de guardarlo en la base de datos: convertirlo a minúsculas y eliminar los espacios en blanco alrededor del texto. Esta tarea se puede resolver en un par de líneas: + +```python +def save_email(): + # El correo electrónico viene del formulario + correo = ' SoPoRtE@hexlet.IO' + # Eliminamos los espacios en blanco + trimmed_email = email.strip() + prepared_email = trimmed_email.lower() + print(prepared_email) + # Aquí se realizaría el guardado en la base de datos +``` + +Este código es posible gracias a que se devuelve un valor. Los métodos `strip()` y `lower()` no imprimen nada en la pantalla, sino que **devuelven** el resultado de su trabajo. Por eso podemos asignar ese resultado a variables. Si imprimieran en la pantalla, no podríamos asignar el resultado a una variable. Por ejemplo, no podemos hacer esto con la función `greeting()`: + +```python +message = greeting() +# en realidad, la función print() devuelve None +# None es un objeto especial que se utiliza para representar la ausencia de valor +print(message) # => None +``` + +Ahora vamos a modificar la función `saludo()` para que devuelva datos. Para ello, en lugar de imprimir en la pantalla, utilizaremos la instrucción `return`: + +```python +def greeting(): + return 'Hello, Hexlet!' +``` + +`return` es una instrucción que toma la expresión que se encuentra a su derecha y la devuelve al código que llamó al método. Aquí finaliza la ejecución de la función. + +```python +# Ahora podemos utilizar el resultado de la función +message = greeting() +print(message) # => Hello, Hexlet! +# Incluso podemos realizar acciones con el resultado +print(mesagge.upper()) # => HELLO, HEXLET! +``` + +Cualquier código después de `return` no se ejecuta: + +```python +def greeting_with_code_after_return(): + return 'Hello, Hexlet!' + print('Nunca me ejecutaré') +``` + +Incluso si una función devuelve datos, eso no limita la posibilidad de imprimir en la pantalla. Además de devolver datos, también podemos imprimir: + +```python +def greeting_with_return_and_printing(): + print('Apareceré en la consola') + return 'Hello, Hexlet!' + + +# Esto imprimirá el texto en la pantalla y devolverá un valor +message = greeting_with_return_and_printing() +``` + +No solo se puede devolver un valor específico. Dado que `return` funciona con expresiones, puede haber cualquier cosa a la derecha de él. En este caso, debemos seguir los principios de legibilidad del código: + +```python +def greeting(): + message = 'Hello, Hexlet!' + return message +``` + +Aquí no estamos devolviendo la variable en sí, sino el valor que se encuentra en esa variable. A continuación, un ejemplo con cálculos: + +```python +def double_five(): + # или return 5 + 5 + result = 5 + 5 + return result +``` + +No es suficiente con definir una función. También es importante que sea útil y que se pueda utilizar su resultado. Ahora, piensa qué devolverá la llamada a la función `run()` que se define a continuación. + +```python +# Definición +def run(): + return 5 + return 10 + + +# ¿Qué se imprimirá en la pantalla? +print(run()) +``` + +https://replit.com/@hexlet/python-basics-define-functions-return diff --git a/modules/40-define-functions/200-return/es/data.yml b/modules/40-define-functions/200-return/es/data.yml new file mode 100644 index 00000000..ed9f4ae7 --- /dev/null +++ b/modules/40-define-functions/200-return/es/data.yml @@ -0,0 +1,4 @@ +name: Devolución de valores +tips: + - | + [return](https://www.w3schools.com/python/ref_keyword_return.asp) diff --git a/modules/40-define-functions/200-return/ru/EXERCISE.md b/modules/40-define-functions/200-return/ru/EXERCISE.md new file mode 100644 index 00000000..8ee76015 --- /dev/null +++ b/modules/40-define-functions/200-return/ru/EXERCISE.md @@ -0,0 +1,7 @@ + +Реализуйте функцию `say_hurray_three_times()`, которая возвращает строку 'hurray! hurray! hurray!'. + +```python +hurray = say_hurray_three_times() +print(hurray) # => hurray! hurray! hurray! +``` diff --git a/modules/40-define-functions/200-return/ru/README.md b/modules/40-define-functions/200-return/ru/README.md new file mode 100644 index 00000000..3c2d2d55 --- /dev/null +++ b/modules/40-define-functions/200-return/ru/README.md @@ -0,0 +1,107 @@ + +В этом уроке подробнее разберем, как работать с созданными функциями, чтобы они были полезны. + +Когда мы определяем функцию, она печатает на экран какие-то данные: + +```python +def greeting(): + print('Hello, Hexlet!') +``` + +Пользы от таких функций немного, так как результатом нельзя воспользоваться внутри программы. Рассмотрим на примере. + +Возьмем задачу обработки электронной почты. Когда пользователь регистрируется на сайте, то он может ввести email любым способом: + +* Добавить случайно пробелы в начале или в конце: `_support@hexlet.io__` +* Использовать буквы в разном регистре: `SUPPORT@hexlet.io` + +Если мы сохраним его в таком виде в базу данных, то пользователь не войдет на сайт. Чтобы этого не произошло, email нужно подготовить к записи в базу: привести его к нижнему регистру и обрезать пробелы по краям строки. Такая задача решается в пару строчек: + +```python +def save_email(): + # Email приходит из формы + email = ' SuppORT@hexlet.IO' + # Обрезаем пробельные символы + trimmed_email = email.strip() + prepared_email = trimmed_email.lower() + print(prepared_email) + # Здесь будет запись в базу данных +``` + +Этот код стал возможен благодаря тому, что значение вернулось. Методы `strip()` и `lower()` ничего не печатают на экран, они **возвращают** результат своей работы. Поэтому мы можем записать его в переменные. Если бы они печатали на экран, мы бы не могли присвоить результат переменной. Например, так мы не можем сделать с функцией `greeting()`: + +```python +message = greeting() +# в действительности, функция print() возвращает None +# None — специальный объект, используемый для представления отсутствия значения +print(message) # => None +``` + +Теперь изменим функцию `greeting()` так, чтобы она возвращала данные. Для этого выполним возврат вместо печати на экран: + +```python +def greeting(): + return 'Hello, Hexlet!' +``` + +`return` — это инструкция. Она берет записанное справа выражение и отдает его тому коду, который вызвал метод. Здесь выполнение функции завершается. + +```python +# Теперь мы можем использовать результат работы функции +message = greeting() +print(message) # => Hello, Hexlet! +# И даже выполнить какие-то действия над результатом +print(message.upper()) # => HELLO, HEXLET! +``` + +Любой код после `return` не выполняется: + +```python +def greeting_with_code_after_return(): + return 'Hello, Hexlet!' + print('Я никогда не выполнюсь') +``` + +Даже если функция возвращает данные, это не ограничивает ее в том, что она печатает. Кроме возврата данных мы можем и печатать: + +```python +def greeting_with_return_and_printing(): + print('Я появлюсь в консоли') + return 'Hello, Hexlet!' + + +# И напечатает текст на экран, и вернет значение +message = greeting_with_return_and_printing() +``` + +Возвращать можно не только конкретное значение. Так как `return` работает с выражениями, то справа от него может быть что угодно. Здесь нужно руководствоваться принципами читаемости кода: + +```python +def greeting(): + message = 'Hello, Hexlet!' + return message +``` + +Здесь мы не возвращаем переменную. Возвращается всегда значение, которое находится в этой переменной. Ниже пример с вычислениями: + +```python +def double_five(): + # или return 5 + 5 + result = 5 + 5 + return result +``` + +Определить функцию мало. Еще важно, чтобы она была полезна, и результатом можно было воспользоваться. А теперь подумайте, что вернет вызов, определенной ниже функции `run()`? + +```python +# Определение +def run(): + return 5 + return 10 + + +# Что будет выведено на экран? +print(run()) +``` + +https://replit.com/@hexlet/python-basics-define-functions-return diff --git a/modules/40-define-functions/200-return/ru/data.yml b/modules/40-define-functions/200-return/ru/data.yml new file mode 100644 index 00000000..56dc66a7 --- /dev/null +++ b/modules/40-define-functions/200-return/ru/data.yml @@ -0,0 +1,4 @@ +name: Возврат значений +tips: + - | + [return](https://www.w3schools.com/python/ref_keyword_return.asp) diff --git a/modules/40-define-functions/300-parameters/en/EXERCISE.md b/modules/40-define-functions/300-parameters/en/EXERCISE.md new file mode 100644 index 00000000..c885d102 --- /dev/null +++ b/modules/40-define-functions/300-parameters/en/EXERCISE.md @@ -0,0 +1,28 @@ + +Create a function called `truncate()` that truncates a string passed to it to a specified number of characters, adds an ellipsis at the end, and returns the resulting string. This kind of logic is often used on websites to display long text in shortened form. + +The function takes two parameters: + +1. The string to be trimmed +2. Number of characters to leave + +An example of how the function you wrote should work: + +```python +# Pass text directly +# Truncate the text, leaving two characters +truncate('hexlet', 2) # 'he...' + +# Via a variable +text = 'it works!' +# Truncate the text, leaving 4 characters +truncate(text, 4) # 'it w...' +``` + +There are lots of ways you can do this task, we'll tell you just one of them. To solve it this way, you need to take a substring from the string passed as the first parameter to the function. Use string slices to do this. Think, based on the assignment, from which index and by which one do you need to extract the substring? + +```python +word = 'welcome!' +index = 3 +word[:index] # wel +``` diff --git a/modules/40-define-functions/300-parameters/en/README.md b/modules/40-define-functions/300-parameters/en/README.md new file mode 100644 index 00000000..a2fb2187 --- /dev/null +++ b/modules/40-define-functions/300-parameters/en/README.md @@ -0,0 +1,108 @@ + +Functions can also also accept parameters as well as return parameters. In this lesson, we'll learn how to create these functions. + +Remember we've already encountered function parameters: + +```python +# Accepts one parameter of any type as input +print('я параметр') +# Takes two string parameters as input +# one - what we're looking for, two - what we're replacing it with +'google'.replace('go', 'mo') # moogle +# Takes two numeric parameters as input +# the first is the number to be rounded, the second is the number of decimal places that should be left over +round(10.23456, 3) # 10.235 +``` + +Now imagine that we need to implement a function called `get_last_char()`, which returns the last character in the string that's passed to it as a parameter. + +Here's what using this function would look like: + +```python +# Passing parameters directly without variables +get_last_char("Hexlet") # t +# Passing parameters through variables +name1 = 'Hexlet' +get_last_char(name1) # t +name2 = 'Goo' +get_last_char(name2) # o +``` + +The following conclusions can be drawn from this example: + +* We need to define the function `get_last_char()` +* The function must accept a single string parameter +* The function must return a string + +Defining the function: + +```python +def get_last_char(text): + return text[-1] +``` + +The name of the `text` variable that serves as a parameter is given in parentheses. The parameter name can be anything. The main thing is that it reflects the meaning of the value it contains. For example: + +```python +def get_last_char(string): + return string[-1] +``` + +The value of the parameter will depend on how the function is called: + +```python +# Inside this function, the string will be 'hexlet' +get_last_char('hexlet') # t + +# Inside this function, the string will be 'code' +get_last_char('code') # e + +# Inside this function, the string will be 'Winter is coming' +# The variable name outside the function is not related to the variable name in the function definition +text = 'Winter is coming' +get_last_char(text) # g +``` + +The parameter must be specified. If you call a function without it, the interpreter will give an error: + +```python +get_last_char() # This code doesn't make sense + +TypeError: get_last_char() missing 1 required positional argument: 'string' +``` + +Many functions work simultaneously with several parameters. For example, to round numbers, you must specify not only the number itself, but also the number of decimal places: + +```python +round(10.23456, 3) # 10.235 +``` + +The same is true with methods. They can require any number of parameters to work: + +```python +# The first parameter is what we are looking for +# The second is what we're changing it to +'google'.replace('go', 'mo') # moogle +```` + +To create such functions and methods, you need to specify the required number of parameters, separated by commas, in the definition. They also need to be given clear names. + +Below is an example of the definition of a function called `replace()`, which replaces one part of a string with another: + +```python +def replace(text, from, to): + # Here is the body of the function, but we've + # omitted it so you don't get distracted + +replace('google', 'go', 'mo') # moogle +``` + +When there are two or more parameters, the order in which the parameters are passed is important for almost all functions. If you change it, the function will work differently: + +```python +# Nothing has been replaced, +# since there is no mo inside google +replace('google', 'mo', 'go') # google +``` + +You now know how to create functions that can take parameters as input. diff --git a/modules/40-define-functions/300-parameters/en/data.yml b/modules/40-define-functions/300-parameters/en/data.yml new file mode 100644 index 00000000..9189b6e6 --- /dev/null +++ b/modules/40-define-functions/300-parameters/en/data.yml @@ -0,0 +1 @@ +name: Function Parameters diff --git a/modules/40-define-functions/300-parameters/es/EXERCISE.md b/modules/40-define-functions/300-parameters/es/EXERCISE.md new file mode 100644 index 00000000..ff22c21b --- /dev/null +++ b/modules/40-define-functions/300-parameters/es/EXERCISE.md @@ -0,0 +1,28 @@ + +Completa la función `truncate()`, que recorta una cadena pasada como parámetro hasta un número determinado de caracteres, agrega puntos suspensivos al final y devuelve la cadena resultante. Esta lógica se utiliza a menudo en sitios web para mostrar texto largo de forma abreviada. + +La función recibe dos parámetros: + +1. La cadena que se debe recortar +2. El número de caracteres que se deben mantener + +Aquí tienes un ejemplo de cómo debería funcionar la función que escribas: + +```python +# Pasando el texto directamente +# Recortamos el texto dejando 2 caracteres +recortar('hexlet', 2) # 'he...' + +# A través de una variable +text = 'it works!!' +# Recortamos el texto dejando 4 caracteres +truncate(text, 4) # '¡it w...' +``` + +Puedes resolver este ejercicio de diferentes maneras, pero te daremos una pista. Para resolverlo de esta manera, tendrás que tomar una subcadena de la cadena que se pasa como primer parámetro a la función. Utiliza segmentos de cadenas para hacerlo. Piensa, en función del enunciado, desde qué índice y hasta qué índice debes extraer la subcadena. + +```python +word = 'welcome!' +index = 3 +word[:index] # wel +``` diff --git a/modules/40-define-functions/300-parameters/es/README.md b/modules/40-define-functions/300-parameters/es/README.md new file mode 100644 index 00000000..2a7fcb3b --- /dev/null +++ b/modules/40-define-functions/300-parameters/es/README.md @@ -0,0 +1,110 @@ + +Las funciones no solamente pueden devolver valores, sino también recibir parámetros. En esta lección aprenderemos a crear funciones que acepten parámetros. + +Recordemos que ya nos hemos encontrado con funciones que tienen parámetros: + +```python +# Recibe un parámetro de cualquier tipo +print('soy un parámetro') +# Recibe dos parámetros de tipo cadena +# el primero es lo que buscamos, el segundo es por qué lo reemplazamos +'google'.replace('go', 'mo') # moogle +# Recibe dos parámetros numéricos +# el primero es el número a redondear, el segundo es la cantidad de decimales que queremos mantener +round(10.23456, 3) # 10.235 +``` + +Ahora imaginemos que necesitamos implementar la función `get_last_char()`, que devuelve el último carácter de una cadena que se le pasa como parámetro. + +Así es como se usaría esta función: + +```python +# Pasando los parámetros directamente sin variables +get_last_char("Hexlet") # t +# Pasando los parámetros a través de variables +name1 = 'Hexlet' +get_last_char(name1) # t +name2 = 'Goo' +get_last_char(name2) # o +``` + +De este ejemplo podemos sacar las siguientes conclusiones: + +* Necesitamos definir la función `get_last_char()` +* La función debe recibir un parámetro de tipo cadena +* La función debe devolver un valor de tipo cadena + +Definimos la función: + +```python +def get_last_char(text): + return text[-1] +``` + +Entre paréntesis se especifica el nombre de la variable `text`, que es el parámetro. El nombre del parámetro puede ser cualquier cosa, lo importante es que refleje el significado del valor que contiene. Por ejemplo: + +```python +def get_last_char(string): + return string[-1] +``` + +El valor del parámetro dependerá de cómo se llame a esta función: + +```python +# Dentro de la función, string será igual a 'hexlet' +get_last_char('hexlet') # t + +# Dentro de la función, string será igual a 'code' +get_last_char('code') # e + +# Dentro de la función, cadena o string será igual a 'Winter is coming' +# El nombre de la variable fuera de la función no está relacionado con el nombre de la variable en la definición de la función +text = 'Winter is coming' +get_last_char(text) # g +``` + +https://replit.com/@hexlet/python-basics-define-functions-parameters + +Es obligatorio especificar el parámetro. Si se llama a la función sin él, el intérprete mostrará un error: + +```python +get_last_char() # Este código no tiene sentido + +TypeError: get_last_char() missing 1 required positional argument: 'string' +``` + +Muchas funciones trabajan con varios parámetros al mismo tiempo. Por ejemplo, para redondear números, es necesario especificar tanto el número en sí como la cantidad de decimales: + +```python +round(10.23456, 3) # 10.235 +``` + +Lo mismo ocurre con los métodos. Pueden requerir cualquier cantidad de parámetros para funcionar: + +```python +# El primer parámetro es lo que buscamos +# El segundo parámetro es por qué lo reemplazamos +'google'.replace('go', 'mo') # moogle +``` + +Para crear funciones y métodos de este tipo, es necesario especificar la cantidad necesaria de parámetros separados por comas. También es importante darles nombres descriptivos. + +A continuación se muestra un ejemplo de definición de la función `replace()`, que reemplaza una parte de una cadena por otra: + +```python +def replace(text, from, to): + # Aquí va el cuerpo de la función + # pero lo omitimos para no distraernos + +replace('google', 'go', 'mo') # moogle +``` + +Cuando hay dos o más parámetros, el orden en que se pasan a la función es casi siempre importante. Si se cambia el orden, la función se comportará de manera diferente: + +```python +# No se reemplaza nada, +# ya que no hay 'mo' en 'google' +replace('google', 'mo', 'go') # google +``` + +Ahora sabes cómo crear funciones que pueden recibir parámetros. diff --git a/modules/40-define-functions/300-parameters/es/data.yml b/modules/40-define-functions/300-parameters/es/data.yml new file mode 100644 index 00000000..2ce19d4a --- /dev/null +++ b/modules/40-define-functions/300-parameters/es/data.yml @@ -0,0 +1,5 @@ +name: Parámetros de las funciones +tips: + - > + [Parámetros de la + función](https://es.wikipedia.org/wiki/Argumento_(informática)) diff --git a/modules/40-define-functions/300-parameters/ru/EXERCISE.md b/modules/40-define-functions/300-parameters/ru/EXERCISE.md new file mode 100644 index 00000000..9765e25a --- /dev/null +++ b/modules/40-define-functions/300-parameters/ru/EXERCISE.md @@ -0,0 +1,28 @@ + +Допишите функцию `truncate()`, которая обрезает переданную строку до указанного количества символов, добавляет в конце троеточие и возвращает получившуюся строку. Подобная логика часто используется на сайтах, чтобы отобразить длинный текст в сокращенном виде. + +Функция принимает два параметра: + +1. Строка, которую нужно обрезать +2. Число символов, которые нужно оставить + +Пример того, как должна работать написанная вами функция: + +```python +# Передаём текст напрямую +# Обрезаем текст, оставляя 2 символа +truncate('hexlet', 2) # 'he...' + +# Через переменную +text = 'it works!' +# Обрезаем текст, оставляя 4 символа +truncate(text, 4) # 'it w...' +``` + +Выполнить задание можно различными способами, подскажем лишь один из них. Для решения этим способом вам понадобится взять подстроку из строки, переданной первым параметром в функцию. Используйте для этого срезы строк. Подумайте, исходя из задания, с какого индекса и по какой вам надо извлечь подстроку? + +```python +word = 'welcome!' +index = 3 +word[:index] # wel +``` diff --git a/modules/40-define-functions/300-parameters/ru/README.md b/modules/40-define-functions/300-parameters/ru/README.md new file mode 100644 index 00000000..90343317 --- /dev/null +++ b/modules/40-define-functions/300-parameters/ru/README.md @@ -0,0 +1,110 @@ + +Функции могут не только возвращать значения, но и принимать параметры. В этом уроке мы научимся создавать такие функции. + +Напомним, что с параметрами функций мы уже сталкивались: + +```python +# Принимает на вход один параметр любого типа +print('я параметр') +# Принимает на вход два строковых параметра +# первый — что ищем, второй — на что меняем +'google'.replace('go', 'mo') # moogle +# Принимает на вход два числовых параметра +# первый — округляемое число, второй — число знаков после запятой, которые нужно оставить +round(10.23456, 3) # 10.235 +``` + +А теперь представим, что нам нужно реализовать функцию `get_last_char()`, которая возвращает последний символ в строке, переданной ему на вход как параметр. + +Вот как будет выглядеть использование этой функции: + +```python +# Передача параметров напрямую без переменных +get_last_char("Hexlet") # t +# Передача параметров через переменные +name1 = 'Hexlet' +get_last_char(name1) # t +name2 = 'Goo' +get_last_char(name2) # o +``` + +Из этого примера можно сделать следующие выводы: + +* Нам нужно определить функцию `get_last_char()` +* Функция должна принимать на вход один параметр строкового типа +* Функция должна возвращать значение строкового типа + +Определяем функцию: + +```python +def get_last_char(text): + return text[-1] +``` + +В скобках указывается имя переменной `text`, которая служит параметром. Имя параметра может быть любым. Главное, чтобы оно отражало смысл значения, которое содержится внутри. Например: + +```python +def get_last_char(string): + return string[-1] +``` + +Значение параметра будет зависеть от вызова этой функции: + +```python +# Внутри функции string будет равна 'hexlet' +get_last_char('hexlet') # t + +# Внутри функции string будет равна 'code' +get_last_char('code') # e + +# Внутри функции string будет равна 'Winter is coming' +# Имя переменной снаружи не связанно с именем переменной в определении функции +text = 'Winter is coming' +get_last_char(text) # g +``` + +https://replit.com/@hexlet/python-basics-define-functions-parameters + +Параметр нужно обязательно указывать. Если вызвать функцию без него, то интерпретатор выдаст ошибку: + +```python +get_last_char() # У такого кода нет смысла + +TypeError: get_last_char() missing 1 required positional argument: 'string' +``` + +Многие функции работают одновременно с несколькими параметрами. Например, чтобы округлить числа, нужно указать не только само число, но и количество знаков после запятой: + +```python +round(10.23456, 3) # 10.235 +``` + +То же самое относится и к методам. Они могут требовать на вход любое количество параметров, которое им нужно для работы: + +```python +# Первый параметр — что ищем +# Второй параметр — на что меняем +'google'.replace('go', 'mo') # moogle +```` + +Чтобы создать такие функции и методы, в определении нужно указать необходимое количество параметров через запятую. Еще им нужно дать понятные имена. + +Ниже пример определения функции `replace()`, которая заменяет в слове одну часть строки на другую: + +```python +def replace(text, from, to): + # Здесь тело функции, но мы его + # опускаем, чтобы не отвлекаться + +replace('google', 'go', 'mo') # moogle +``` + +Когда параметров два и более, то практически для всех функций важен порядок передачи этих параметров. Если его поменять, то функция отработает по-другому: + +```python +# Ничего не заменилось, +# так как внутри google нет mo +replace('google', 'mo', 'go') # google +``` + +Теперь вы знаете, как создавать функции, которые могут принимать на вход параметры. diff --git a/modules/40-define-functions/300-parameters/ru/data.yml b/modules/40-define-functions/300-parameters/ru/data.yml new file mode 100644 index 00000000..1a3a7edb --- /dev/null +++ b/modules/40-define-functions/300-parameters/ru/data.yml @@ -0,0 +1,5 @@ +name: Параметры функций +tips: + - > + [Параметры + функции](https://ru.wikipedia.org/wiki/Параметр_(программирование)) diff --git a/modules/40-define-functions/400-default-parameters/en/EXERCISE.md b/modules/40-define-functions/400-default-parameters/en/EXERCISE.md new file mode 100644 index 00000000..5d643d99 --- /dev/null +++ b/modules/40-define-functions/400-default-parameters/en/EXERCISE.md @@ -0,0 +1,24 @@ + +Implement a function `get_hidden_card()` that takes a credit card number (consisting of 16 digits) as a string and returns its hidden version, which can be used on the site for display. If the original card had the number *2034399002125581*, then the hidden version looks like *\*\*\*\*5581*. In other words, the function replaces the first 12 characters with asterisks. The number of asterisks is controlled by a second, optional parameter. The default value is 4. + +```python +# The credit card is passed inside as a string +# The second parameter is not passed, so there will be 4 stars +get_hidden_card('1234567812345678') # ****5678 + +get_hidden_card('1234567812345678', 2) # **5678 +get_hidden_card('1234567812345678', 3) # ***5678 + +# Or using variables + +card_number = '2034399002121100' +get_hidden_card(card_number) # ****1100 +get_hidden_card(card_number, 1) # *1100 +``` + +To perform the task, you will need a string repetition mechanism that repeats a string a specified number of times. To do this, just multiply the string by the number of repetitions: + +```python +'+' * 5 # +++++ +'o' * 3 # ooo +``` diff --git a/modules/40-define-functions/400-default-parameters/en/README.md b/modules/40-define-functions/400-default-parameters/en/README.md new file mode 100644 index 00000000..d06fe4c6 --- /dev/null +++ b/modules/40-define-functions/400-default-parameters/en/README.md @@ -0,0 +1,53 @@ + +In programming, many functions and methods have parameters that are rarely changed. In such cases, these parameters are given default values that can be changed as needed. This reduces the amount of identical code. Let's see how it looks like in practice. + +Let's look at an example: + +```python +# The function of degree increase +# The second parameter has a default value of two +def pow(x, base=2): + return x ** base + +# Three to the second power (two is the default setting) +pow(3) # 3 * 3 = 9 +# Three to the Third Degree +pow(3, 3) # 3 * 3 * 3 = 27 +``` + +The default value looks like a normal assignment in the definition. It only works if the parameter is not passed. + +Imagine that you didn't bring the parts for your car with you to the car service. Then the car mechanic will offer you to put the ones he has - the default ones. + +The default value can be even when there is only one parameter: + +```python +def my_print(text='nothing'): + print(text) + +my_print() # => "nothing" +my_print("Hexlet") # => "Hexlet" +``` + +There can be any number of parameters with default values: + +```python +def f(a=5, b=10, c=100): +``` + +The default values have one limitation. They must go at the very end of the parameter list. From the syntax point of view, it is impossible to create a function with an optional parameter followed by a mandatory one: + +```python +# Такой код завершится с ошибкой +def f(a=5, b=10, c=100, x): +# And such a +def f(a=5, b=10, x, c=100): + +# This code will work +def f(x, a=5, b=10, c=100): + +# This one will work, too. +def f(x, y, a=5, b=10, c=100): +``` + +Now you know how to work with the default values of the parameters. You can have them for several parameters, or for one parameter. And remember that the default values should be at the very end of the parameter list. This knowledge will help to reduce the amount of identical code. diff --git a/modules/40-define-functions/400-default-parameters/en/data.yml b/modules/40-define-functions/400-default-parameters/en/data.yml new file mode 100644 index 00000000..df687fd0 --- /dev/null +++ b/modules/40-define-functions/400-default-parameters/en/data.yml @@ -0,0 +1 @@ +name: Optional function parameters diff --git a/modules/40-define-functions/400-default-parameters/es/EXERCISE.md b/modules/40-define-functions/400-default-parameters/es/EXERCISE.md new file mode 100644 index 00000000..ee723b0d --- /dev/null +++ b/modules/40-define-functions/400-default-parameters/es/EXERCISE.md @@ -0,0 +1,24 @@ + +Implementa la función `get_hidden_card()`, que recibe como entrada el número de una tarjeta de crédito (compuesto por 16 dígitos) como una cadena y devuelve su versión oculta, que se puede utilizar en el sitio web para su visualización. Si la tarjeta original tenía el número *2034399002125581*, entonces la versión oculta se verá así *\*\*\*\*5581*. En otras palabras, la función reemplaza los primeros 12 caracteres por asteriscos. El número de asteriscos se controla mediante el segundo parámetro, que es opcional. El valor predeterminado es 4. + +```python +# La tarjeta de crédito se pasa como una cadena +# El segundo parámetro no se pasa, por lo que habrá 4 asteriscos +get_hidden_card('1234567812345678') # ****5678 + +get_hidden_card('1234567812345678', 2) # **5678 +get_hidden_card('1234567812345678', 3) # ***5678 + +# O usando variables + +card_number = '2034399002121100' +get_hidden_card(card_number) # ****1100 +get_hidden_card(card_number, 1) # *1100 +``` + +Para completar la tarea, necesitarás el mecanismo de repetición de cadenas, que repite una cadena un número determinado de veces. Para hacer esto, simplemente multiplica la cadena por el número de repeticiones: + +```python +'+' * 5 # +++++ +'o' * 3 # ooo +``` diff --git a/modules/40-define-functions/400-default-parameters/es/README.md b/modules/40-define-functions/400-default-parameters/es/README.md new file mode 100644 index 00000000..13dd96d3 --- /dev/null +++ b/modules/40-define-functions/400-default-parameters/es/README.md @@ -0,0 +1,55 @@ + +En programación, muchas funciones y métodos tienen parámetros que rara vez cambian. En estos casos, se les asignan valores predeterminados que se pueden cambiar según sea necesario. Esto reduce la cantidad de código repetitivo. Veamos cómo se ve esto en la práctica. + +Veamos un ejemplo: + +```python +# Función de potencia +# El segundo parámetro tiene un valor predeterminado de dos +def pow(x, base=2): + return x ** base + +# Tres al cuadrado (dos es el valor predeterminado) +pow(3) # 3 * 3 = 9 +# Tres al cubo +pow(3, 3) # 3 * 3 * 3 = 27 +``` + +https://replit.com/@hexlet/python-basics-define-functions-default-parameters + +El valor predeterminado se ve como una asignación normal en la definición. Solo se activa si no se pasa el parámetro. + +Imagina que no llevaste las piezas de repuesto para tu automóvil al taller. Entonces el mecánico te ofrecerá poner las que él tiene, por defecto. + +Incluso puede haber un valor predeterminado cuando solo hay un parámetro: + +```python +def my_print(text='nothing'): + print(text) + +my_print() # => "nothing" +my_print("Hexlet") # => "Hexlet" +``` + +Puede haber cualquier cantidad de parámetros con valores predeterminados: + +```python +def f(a=5, b=10, c=100): +``` + +Los valores predeterminados tienen una restricción. Deben ir al final de la lista de parámetros. Desde el punto de vista de la sintaxis, no es posible crear una función en la que haya un parámetro opcional seguido de uno obligatorio: + +```python +# Este código dará un error +def f(a=5, b=10, c=100, x): +# Y este también +def f(a=5, b=10, x, c=100): + +# Este código funcionará +def f(x, a=5, b=10, c=100): + +# Este también funcionará +def f(x, y, a=5, b=10, c=100): +``` + +Ahora sabes cómo trabajar con valores predeterminados de los parámetros. Pueden estar presentes en varios parámetros o en uno solo. Y recuerda que los valores predeterminados deben estar al final de la lista de parámetros. Este conocimiento te ayudará a reducir la cantidad de código repetitivo. diff --git a/modules/40-define-functions/400-default-parameters/es/data.yml b/modules/40-define-functions/400-default-parameters/es/data.yml new file mode 100644 index 00000000..aa1146b5 --- /dev/null +++ b/modules/40-define-functions/400-default-parameters/es/data.yml @@ -0,0 +1,8 @@ +name: Parámetros opcionales de las funciones +tips: + - > + [Parámetros por + defecto](https://developer.mozilla.org/es/docs/Web/JavaScript/Reference/Functions/Default_parameters) +definitions: + - name: Parámetro por defecto + description: parámetro opcional de una función diff --git a/modules/40-define-functions/400-default-parameters/ru/EXERCISE.md b/modules/40-define-functions/400-default-parameters/ru/EXERCISE.md new file mode 100644 index 00000000..0b114447 --- /dev/null +++ b/modules/40-define-functions/400-default-parameters/ru/EXERCISE.md @@ -0,0 +1,24 @@ + +Реализуйте функцию `get_hidden_card()`, который принимает на вход номер кредитки (состоящий из 16 цифр) в виде строки и возвращает его скрытую версию, которая может использоваться на сайте для отображения. Если исходная карта имела номер *2034399002125581*, то скрытая версия выглядит так *\*\*\*\*5581*. Другими словами, функция заменяет первые 12 символов, на звездочки. Количество звездочек регулируется вторым, необязательным, параметром. Значение по умолчанию — 4. + +```python +# Кредитка передается внутрь как строка +# Второй параметр не передается, значит звездочек будет 4 +get_hidden_card('1234567812345678') # ****5678 + +get_hidden_card('1234567812345678', 2) # **5678 +get_hidden_card('1234567812345678', 3) # ***5678 + +# Или используя переменные + +card_number = '2034399002121100' +get_hidden_card(card_number) # ****1100 +get_hidden_card(card_number, 1) # *1100 +``` + +Для выполнения задания вам понадобится механизм повторения строк, который повторяет строку указанное количество раз. Для этого достаточно умножить строку на число повторений: + +```python +'+' * 5 # +++++ +'o' * 3 # ooo +``` diff --git a/modules/40-define-functions/400-default-parameters/ru/README.md b/modules/40-define-functions/400-default-parameters/ru/README.md new file mode 100644 index 00000000..4b84b9d6 --- /dev/null +++ b/modules/40-define-functions/400-default-parameters/ru/README.md @@ -0,0 +1,55 @@ + +В программировании у многих функций и методов есть параметры, которые редко меняются. В таких случаях этим параметрам задают значения по умолчанию, которые можно поменять по необходимости. С помощью этого сокращается количество одинакового кода. Рассмотрим, как это выглядит на практике. + +Разберем пример: + +```python +# Функция возведения в степень +# Второй параметр имеет значение по умолчанию два +def pow(x, base=2): + return x ** base + +# Три во второй степени (двойка задана по умолчанию) +pow(3) # 3 * 3 = 9 +# Три в третьей степени +pow(3, 3) # 3 * 3 * 3 = 27 +``` + +https://replit.com/@hexlet/python-basics-define-functions-default-parameters + +Значение по умолчанию выглядит как обычное присваивание в определении. Оно срабатывает только в том случае, если параметр не передали. + +Представьте, что вы не привезли с собой в автосервис запчасти для вашего автомобиля. Тогда автомеханик предложит вам поставить те, которые есть у него — по умолчанию. + +Значение по умолчанию может быть даже в том случае, когда параметр один: + +```python +def my_print(text='nothing'): + print(text) + +my_print() # => "nothing" +my_print("Hexlet") # => "Hexlet" +``` + +Параметров со значениями по умолчанию может быть любое количество: + +```python +def f(a=5, b=10, c=100): +``` + +У значений по умолчанию есть одно ограничение. Они должны идти в самом конце списка параметров. С точки зрения синтаксиса, невозможно создать функцию, у которой после необязательного параметра идет обязательный: + +```python +# Такой код завершится с ошибкой +def f(a=5, b=10, c=100, x): +# И такой +def f(a=5, b=10, x, c=100): + +# Этот код сработает +def f(x, a=5, b=10, c=100): + +# Этот тоже сработает +def f(x, y, a=5, b=10, c=100): +``` + +Теперь вы умеете работать со значениями параметров по умолчанию. Они могут быть как у нескольких параметров, так и у одного. И помните, что значения по умолчанию должны быть в самом конце списка параметров. Эти знания помогут сократить количество одинакового кода. diff --git a/modules/40-define-functions/400-default-parameters/ru/data.yml b/modules/40-define-functions/400-default-parameters/ru/data.yml new file mode 100644 index 00000000..a3b3de4d --- /dev/null +++ b/modules/40-define-functions/400-default-parameters/ru/data.yml @@ -0,0 +1,8 @@ +name: Необязательные параметры функций +tips: + - > + [Параметры по + умолчанию](https://developer.mozilla.org/ru/docs/Web/JavaScript/Reference/Functions/Default_parameters) +definitions: + - name: Параметр по умолчанию + description: необязательный параметр функции diff --git a/modules/40-define-functions/500-named-arguments/en/EXERCISE.md b/modules/40-define-functions/500-named-arguments/en/EXERCISE.md new file mode 100644 index 00000000..56f5ad58 --- /dev/null +++ b/modules/40-define-functions/500-named-arguments/en/EXERCISE.md @@ -0,0 +1,10 @@ + +Implement a function `trim_and_repeat()` that takes three parameters: the string, `offset` - the number of characters by which to trim the string to the left and `repetitions` - the number of times it needs to be repeated, and returns the resulting string. +The default number of characters to cut is 0, and the number of repetitions is 1. + +```python +text = 'python' +print(trim_and_repeat(text, offset=3, repetitions=2)) # => honhon +print(trim_and_repeat(text, repetitions=3)) # => pythonpythonpython +print(trim_and_repeat(text)) # => python +``` diff --git a/modules/40-define-functions/500-named-arguments/en/README.md b/modules/40-define-functions/500-named-arguments/en/README.md new file mode 100644 index 00000000..a7c105e5 --- /dev/null +++ b/modules/40-define-functions/500-named-arguments/en/README.md @@ -0,0 +1,51 @@ + +In this lesson, we'll look at what parameters exist, how they differ, and when to apply them. + +**Arguments** are data that are passed to a function call. They come in two types: + +The first type is **positional arguments**. They are passed in the same order as the function parameters are defined: + +```python +# (text, length) +truncate('My Text', 3) +``` + +The second type is **named arguments**. They are passed not just as values, but as a pair "name=value". So you can pass them in any order: + +```python +# Arguments are passed in a different order +truncate(length=3, text='My Text') +``` + +If you look carefully at the two examples above, you can see that they are two identical functions. + +Now let's see when to apply these types of arguments. + +The type of parameter you choose depends on who is calling the function. + +There are two reasons to use named arguments: + +* They increase readability because you can see the names at a glance + +* You can leave out all the intermediate parameters that we don't need right now + +The latter is useful if the function has many optional parameters. Let's look at an example: + +```python +def print_params(a=1, b=2, c=None, d=4): + print(a, b, c, d) + +# You only need to pass d, but you have to pass all +f(1, 2, 3, 8) + +# Named arguments allow you to pass only d +# Default values are used for the other arguments +f(d=8) +``` + +Named arguments can be passed at the same time as positional arguments. Then positional arguments must go at the beginning: + +```python +# Transmit only a (positional) and d (as named) +f(3, d=3) +``` diff --git a/modules/40-define-functions/500-named-arguments/en/data.yml b/modules/40-define-functions/500-named-arguments/en/data.yml new file mode 100644 index 00000000..4242eae1 --- /dev/null +++ b/modules/40-define-functions/500-named-arguments/en/data.yml @@ -0,0 +1 @@ +name: Named arguments diff --git a/modules/40-define-functions/500-named-arguments/es/EXERCISE.md b/modules/40-define-functions/500-named-arguments/es/EXERCISE.md new file mode 100644 index 00000000..32eed1b3 --- /dev/null +++ b/modules/40-define-functions/500-named-arguments/es/EXERCISE.md @@ -0,0 +1,10 @@ + +Crea la función trim_and_repeat() con tres parámetros: una cadena de texto, offset (el número de caracteres a eliminar desde la izquierda) y repetitions (la cantidad de veces que se debe repetir la cadena recortada). Esta función recorta la cadena y repite la parte recortada tantas veces como sea necesario para alcanzar el número total de repeticiones especificado. +El valor predeterminado para offset es 0, y el valor predeterminado para repetitions es 1. La función debe combinar todas las repeticiones en una sola cadena y devolverla como resultado. + +```python +text = 'python' +print(trim_and_repeat(text, offset=3, repetitions=2)) # => honhon +print(trim_and_repeat(text, repetitions=3)) # => pythonpythonpython +print(trim_and_repeat(text)) # => python +``` diff --git a/modules/40-define-functions/500-named-arguments/es/README.md b/modules/40-define-functions/500-named-arguments/es/README.md new file mode 100644 index 00000000..63af0ea1 --- /dev/null +++ b/modules/40-define-functions/500-named-arguments/es/README.md @@ -0,0 +1,51 @@ + +En esta lección, vamos a analizar qué parámetros existen, cómo se diferencian y en qué casos se aplican. + +**Argumentos** son los datos que se pasan a una función cuando se la llama. Hay dos tipos de argumentos: + +El primer tipo son los **argumentos posicionales**. Se pasan en el mismo orden en el que se definen los parámetros de la función: + +```python +# (text, length) +truncate('My Text', 3) +``` + +El segundo tipo son los **argumentos nombrados**. Se pasan no sólo como valores, sino como pares "nombre=valor". Por lo tanto, se pueden pasar en cualquier orden: + +```python +# Los argumentos se pasan en un orden diferente +truncate(length=3, text='My Text') +``` + +Si observamos cuidadosamente los dos ejemplos anteriores, podemos entender que son dos funciones idénticas. + +Ahora vamos a entender en qué casos se deben utilizar estos tipos de argumentos. + +La elección del tipo de parámetro depende de quién llama a la función. + +Hay dos razones para usar argumentos nombrados: + +* Mejoran la legibilidad, ya que los nombres son visibles de inmediato. + +* No es necesario especificar todos los parámetros intermedios que no necesitamos en este momento. + +Esto último es útil cuando una función tiene muchos parámetros opcionales. Veamos un ejemplo: + +```python +def print_params(a=1, b=2, c=None, d=4): + print(a, b, c, d) + +# Solo necesitamos pasar d, pero tenemos que pasar todos los demás +f(1, 2, 3, 8) + +# Los argumentos nombrados nos permiten pasar solo d +# Los valores predeterminados se utilizan para los demás argumentos +f(d=8) +``` + +Los argumentos nombrados se pueden pasar junto con los posicionales. En ese caso, los posicionales deben ir al principio: + +```python +# Pasamos solo a (posicional) y d (nombrado) +f(3, d=3) +``` diff --git a/modules/40-define-functions/500-named-arguments/es/data.yml b/modules/40-define-functions/500-named-arguments/es/data.yml new file mode 100644 index 00000000..334d9c03 --- /dev/null +++ b/modules/40-define-functions/500-named-arguments/es/data.yml @@ -0,0 +1 @@ +name: Argumentos Nombrados diff --git a/modules/40-define-functions/500-named-arguments/ru/EXERCISE.md b/modules/40-define-functions/500-named-arguments/ru/EXERCISE.md new file mode 100644 index 00000000..0624f8d1 --- /dev/null +++ b/modules/40-define-functions/500-named-arguments/ru/EXERCISE.md @@ -0,0 +1,10 @@ + +Реализуйте функцию `trim_and_repeat()`, которая принимает три параметра: строку, `offset` — число символов, на которое нужно обрезать строку слева и `repetitions` — количество обрезанных строк, которые нужно вывести. Функция обрезает строку и повторяет ее столько раз, чтобы общее количество обрезанных строк равнялось `repetitions`. Функция должна записать результат в одну строку и вернуть его. +Число символов для среза по умолчанию равно 0, а повторений — 1. + +```python +text = 'python' +print(trim_and_repeat(text, offset=3, repetitions=2)) # => honhon +print(trim_and_repeat(text, repetitions=3)) # => pythonpythonpython +print(trim_and_repeat(text)) # => python +``` diff --git a/modules/40-define-functions/500-named-arguments/ru/README.md b/modules/40-define-functions/500-named-arguments/ru/README.md new file mode 100644 index 00000000..a54f2efe --- /dev/null +++ b/modules/40-define-functions/500-named-arguments/ru/README.md @@ -0,0 +1,51 @@ + +В этом уроке разберем, какие параметры существуют, чем они отличаются и в каких случаях их применять. + +**Аргументы** — это данные, которые передаются в вызов функции. Они бывают двух типов: + +Первый тип — **позиционные аргументы**. Они передаются в том же порядке, в котором определены параметры функции: + +```python +# (text, length) +truncate('My Text', 3) +``` + +Второй тип — **именованные аргументы**. Они передаются не просто как значения, а как пара «имя=значение». Поэтому их можно передавать в любом порядке: + +```python +# Аргументы переданы в другом порядке +truncate(length=3, text='My Text') +``` + +Если внимательно посмотреть на два примера выше, то можно понять, что это две одинаковые функции. + +Теперь разберемся, в каких случаях нужно применять эти типы аргументов. + +Выбор типа параметра зависит от того, кто вызывает функцию. + +Есть две причины использовать именованные аргументы: + +* Они повышают читаемость, так как сразу видно имена + +* Можно не указывать все промежуточные параметры, которые нам сейчас не нужны + +Последнее полезно, если у функции много необязательных параметров. Посмотрим на примере: + +```python +def print_params(a=1, b=2, c=None, d=4): + print(a, b, c, d) + +# Нужно передать только d, но приходится передавать все +f(1, 2, 3, 8) + +# Именованные аргументы позволяют передавать только d +# Для остальных аргументов используются значения по умолчанию +f(d=8) +``` + +Именованные аргументы можно передавать одновременно с позиционными. Тогда позиционные должны идти в самом начале: + +```python +# Передаем только a (позиционно) и d (как именованный) +f(3, d=3) +``` diff --git a/modules/40-define-functions/500-named-arguments/ru/data.yml b/modules/40-define-functions/500-named-arguments/ru/data.yml new file mode 100644 index 00000000..b85ebf34 --- /dev/null +++ b/modules/40-define-functions/500-named-arguments/ru/data.yml @@ -0,0 +1 @@ +name: Именованные аргументы diff --git a/modules/40-define-functions/600-type-annotations/en/EXERCISE.md b/modules/40-define-functions/600-type-annotations/en/EXERCISE.md new file mode 100644 index 00000000..87636e60 --- /dev/null +++ b/modules/40-define-functions/600-type-annotations/en/EXERCISE.md @@ -0,0 +1,13 @@ + +Implement a function, `word_multiply()`. It should accept two parameters: + +* A word +* A number representing how many times to repeat the word + +```python +text = 'python' +print(word_multiply(text, 2)) # => pythonpython +print(word_multiply(text, 0)) # => +``` + +Specify type annotations when declaring a function. diff --git a/modules/40-define-functions/600-type-annotations/en/README.md b/modules/40-define-functions/600-type-annotations/en/README.md new file mode 100644 index 00000000..c9590314 --- /dev/null +++ b/modules/40-define-functions/600-type-annotations/en/README.md @@ -0,0 +1,34 @@ + +**Type annotations** are an ability to specify parameter types and return values for functions in Python. This is not a mandatorType annotations allow programmers to specify parameter types and return values for functions in Python. It is not a mandatory requirement of the language, but it can help programmers in further development, improve the readability of the code and increase its reliability. + +Let's look at a simple example of a function without type annotations: + +```python +def concat(first, second): + return first + second +``` + +This function concatenates two strings into one. At first glance, it is hard to understand what is going on in the code: what types the arguments have, why the function works with strings and not adding, for example, two numbers. + +If we use it further in the code, we should check the types of arguments before passing them to the function. It increases the size of the code and makes it harder to understand. + +Now let's add type annotations to the function: + +```python +def concat(first: str, second: str) -> str: + return first + second +``` + +Here we have specified that the arguments first and second must be of string type (str). The return value will also be of string type. When we use this function in code, it will be easier to understand what argument types we can pass and what return value type we expect. + +We also can use type annotations to define variable types within a function. For example:: + +```python +def double(n: int) -> int: + result: int = n * 2 + return result +``` + +In this example, we have defined the type of the `result` variable as `int` using type annotation. + +Type annotations are not strict type-checking in Python. They do not guarantee that we will call a function with arguments and return values of the specified types. After all, Python is still a dynamically typed language. Type annotations in Python do not affect the ability to pass different argument types or to return values of different types. However, their use helps to track down errors and makes the code more readable. diff --git a/modules/40-define-functions/600-type-annotations/en/data.yml b/modules/40-define-functions/600-type-annotations/en/data.yml new file mode 100644 index 00000000..cc05d5e0 --- /dev/null +++ b/modules/40-define-functions/600-type-annotations/en/data.yml @@ -0,0 +1 @@ +name: Type Annotations diff --git a/modules/40-define-functions/600-type-annotations/es/EXERCISE.md b/modules/40-define-functions/600-type-annotations/es/EXERCISE.md new file mode 100644 index 00000000..66dd265f --- /dev/null +++ b/modules/40-define-functions/600-type-annotations/es/EXERCISE.md @@ -0,0 +1,13 @@ + +Implementa la función `word_multiply()`. Debe aceptar dos parámetros: + +* Una cadena de texto +* Un número que indica cuántas veces se debe repetir la cadena + +```python +text = 'python' +print(word_multiply(text, 2)) # => pythonpython +print(word_multiply(text, 0)) # => +``` + +Especifica las anotaciones de tipos al declarar la función. diff --git a/modules/40-define-functions/600-type-annotations/es/README.md b/modules/40-define-functions/600-type-annotations/es/README.md new file mode 100644 index 00000000..7072de71 --- /dev/null +++ b/modules/40-define-functions/600-type-annotations/es/README.md @@ -0,0 +1,34 @@ + +Las **Anotaciones de tipos** son una forma de especificar los tipos de los parámetros y el valor de retorno de una función en Python. No es un requisito obligatorio del lenguaje, pero puede ayudar a los programadores en el desarrollo posterior, así como mejorar la legibilidad del código y aumentar su confiabilidad. + +Veamos un ejemplo simple de una función sin anotaciones de tipos: + +```python +def concat(first, second): + return first + second +``` + +Esta función concatena dos cadenas en una sola. A simple vista, es difícil entender qué está sucediendo en el código: qué tipos tienen los argumentos, por qué la función trabaja con cadenas en lugar de sumar, por ejemplo, dos números. + +Si más adelante utilizamos esta función en el código, puede ser necesario verificar los tipos de los argumentos antes de pasarlos a la función, lo que aumenta la cantidad de código y dificulta su comprensión. + +Ahora agreguemos anotaciones de tipos a la función: + +```python +def concat(first: str, second: str) -> str: + return first + second +``` + +Aquí hemos especificado que los argumentos `first` y `second` deben ser de tipo cadena (`str`). El valor de retorno también será una cadena. Cuando usemos esta función en el código, será más fácil entender qué tipos de argumentos se pueden pasar y qué tipo de valor de retorno se espera. + +Las anotaciones de tipos también se pueden utilizar para definir los tipos de las variables dentro de una función. Por ejemplo: + +```python +def double(n: int) -> int: + result: int = n * 2 + return result +``` + +En este ejemplo, hemos definido el tipo de la variable `result` como `int`, utilizando una anotación de tipo. + +Las anotaciones de tipos no son una verificación estricta de tipos en Python. Su uso no garantiza que la función se llame con argumentos y un valor de retorno de los tipos especificados. Después de todo, Python sigue siendo un lenguaje de tipado dinámico. Las anotaciones de tipos no afectan la capacidad de pasar argumentos de diferentes tipos o devolver valores de otros tipos. Sin embargo, su uso facilita la lectura y comprensión del código, y ayuda a detectar errores. diff --git a/modules/40-define-functions/600-type-annotations/es/data.yml b/modules/40-define-functions/600-type-annotations/es/data.yml new file mode 100644 index 00000000..e29fc900 --- /dev/null +++ b/modules/40-define-functions/600-type-annotations/es/data.yml @@ -0,0 +1 @@ +name: Anotaciones de tipos diff --git a/modules/40-define-functions/600-type-annotations/ru/EXERCISE.md b/modules/40-define-functions/600-type-annotations/ru/EXERCISE.md new file mode 100644 index 00000000..095c2bb7 --- /dev/null +++ b/modules/40-define-functions/600-type-annotations/ru/EXERCISE.md @@ -0,0 +1,13 @@ + +Реализуйте функцию `word_multiply()`. Она должна принимать два параметра: + +* Строку +* Число, которое обозначает, сколько раз нужно повторить строку + +```python +text = 'python' +print(word_multiply(text, 2)) # => pythonpython +print(word_multiply(text, 0)) # => +``` + +Укажите аннотации типов при объявлении функции. diff --git a/modules/40-define-functions/600-type-annotations/ru/README.md b/modules/40-define-functions/600-type-annotations/ru/README.md new file mode 100644 index 00000000..7105c14b --- /dev/null +++ b/modules/40-define-functions/600-type-annotations/ru/README.md @@ -0,0 +1,34 @@ + +**Аннотации типов** — это возможность указать типы параметров и возвращаемое значение у функции в Python. Это не является обязательным требованием языка, но может помочь программистам в дальнейшей разработке, улучшить читаемость кода и повысить его надежность. + +Давайте рассмотрим простой пример функции без аннотаций типов: + +```python +def concat(first, second): + return first + second +``` + +Эта функция конкатенирует две строки в одну. При этом с первого взгляда на код сложно понять, что происходит в нем: какие типы у аргументов, почему функция работает со строками, а не складывает, например, два числа. + +Если в дальнейшем использовать эту функцию в коде, то может возникнуть необходимость проверять типы аргументов перед передачей их в функцию, что увеличивает объем кода и затрудняет его понимание. + +Теперь давайте добавим аннотации типов к функции: + +```python +def concat(first: str, second: str) -> str: + return first + second +``` + +Здесь мы указали, что аргументы `first` и `second` должны быть строкового типа (`str`). Возвращаемое значение тоже будет строковым. Когда мы будем использовать эту функцию в коде, нам будет проще понять, какие типы аргументов можно передавать и какой тип возвращаемого значения ожидается. + +Аннотации типов также могут быть использованы для определения типов переменных внутри функции. Например: + +```python +def double(n: int) -> int: + result: int = n * 2 + return result +``` + +В этом примере мы определили тип переменной `result` как `int`, используя аннотацию типа. + +Аннотации типов — это не строгая проверка типов в Python. Их использование не гарантирует, что функция будет вызвана с аргументами и возвращаемым значением указанных типов. Все таки Python остается динамически типизированным языком. В нем аннотации типов не влияют на возможность передачи аргументов различных типов или возвращения значений других типов. Тем не менее их использование упрощает чтение и понимание кода и помогает отслеживать ошибки. diff --git a/modules/40-define-functions/600-type-annotations/ru/data.yml b/modules/40-define-functions/600-type-annotations/ru/data.yml new file mode 100644 index 00000000..4698a5a9 --- /dev/null +++ b/modules/40-define-functions/600-type-annotations/ru/data.yml @@ -0,0 +1 @@ +name: Аннотации типов diff --git a/modules/45-logic/10-bool-type/en/EXERCISE.md b/modules/45-logic/10-bool-type/en/EXERCISE.md new file mode 100644 index 00000000..41c2740b --- /dev/null +++ b/modules/45-logic/10-bool-type/en/EXERCISE.md @@ -0,0 +1,9 @@ + +Write a function `is_pensioner()` that takes someone's age as a single argument and checks whether that person is at retirement age. For the purposes of this exercise, retirement age is considered to be 60 years or over. + +Call examples: + +```python +is_pensioner(75) # True +is_pensioner(18) # False +``` diff --git a/modules/45-logic/10-bool-type/en/README.md b/modules/45-logic/10-bool-type/en/README.md new file mode 100644 index 00000000..4b493499 --- /dev/null +++ b/modules/45-logic/10-bool-type/en/README.md @@ -0,0 +1,46 @@ + +In addition to arithmetic operations, there are also comparison operations in mathematics, such as `5 > 4` or `3 < 1`. They also exist in programming. For example, when we go to a website, the username and password are compared with those in the database. If they are, they let us in; they authenticate us. In this lesson, we'll get to know more about comparison operations. + +Programming languages have adapted all mathematical comparison operations unchanged, except for the equality and inequality operators. In mathematics, we use the `=` sign, but in programming, this is quite rare. + +In many languages, the symbol `=` is used to assign values to variables. That's why in Python, we use `==` for comparison. + +List of comparison operations: + +* `<` — less than +* `<=` — less than or equal to +* `>` — more than +* `>=` — greater than or equal to +* `==` — equal to +* `!=` — not equal to + +These operations apply not only to numbers. For example, you can use the equality operator to compare strings: `password == text` is a comparison of the value of strings that are written in different variables. + +A logical operation like `5 > 4` or `password == text` is an expression. Its result is the special value `True` or `False`. This is a new data type for us - `bool`. + +```python +result = 5 > 4 +print(result) # => True +print('one' != 'one') # => False +``` + +Along with strings (`str`) and integers and rational numbers, the **`bool` type** is one of Python's primitive data types. + +Let's try to write a simple function that takes the age of a child as input and determines whether the child is a baby or not. Babies are defined as children under one year old: + +```python +def is_infant(age): + return age < 1 + +print(is_infant(3)) # => False +``` + +Any operation is an expression, so the only line of the function we write is “return the value that results from the comparison `age < 1`”. Depending on the argument passed, the comparison will be `True` or `False`, and `return` will return that result. + +Now, perform the check on a child who's six months old: + +```python +print(is_infant(0.5)) # => True +``` + +The result of the `True` operation. So the child is definitely a baby. diff --git a/modules/45-logic/10-bool-type/en/data.yml b/modules/45-logic/10-bool-type/en/data.yml new file mode 100644 index 00000000..de533e05 --- /dev/null +++ b/modules/45-logic/10-bool-type/en/data.yml @@ -0,0 +1,4 @@ +name: Logic type +definitions: + - name: “Logic type (bool)” + description: 'a data type with two possible values: `True` or `False`' diff --git a/modules/45-logic/10-bool-type/es/EXERCISE.md b/modules/45-logic/10-bool-type/es/EXERCISE.md new file mode 100644 index 00000000..ded57273 --- /dev/null +++ b/modules/45-logic/10-bool-type/es/EXERCISE.md @@ -0,0 +1,9 @@ + +Escriba una función `is_pensioner()` que tome la edad como único argumento y verifique si esa edad corresponde a la jubilación. Se considera jubilación a partir de los 60 años. + +Ejemplos de llamadas: + +```python +is_pensioner(75) # True +is_pensioner(18) # False +``` diff --git a/modules/45-logic/10-bool-type/es/README.md b/modules/45-logic/10-bool-type/es/README.md new file mode 100644 index 00000000..d2d1643d --- /dev/null +++ b/modules/45-logic/10-bool-type/es/README.md @@ -0,0 +1,48 @@ + +Además de las operaciones aritméticas en matemáticas, existen operaciones de comparación, como `5 > 4` o `3 < 1`. También existen en programación. Por ejemplo, cuando ingresamos a un sitio web, se comparan el nombre de usuario y la contraseña ingresados con los que están en la base de datos. Si coinciden, se nos permite ingresar, es decir, se autentica. En esta lección, aprenderemos sobre las operaciones de comparación. + +Los lenguajes de programación han adaptado todas las operaciones de comparación matemáticas sin cambios, excepto los operadores de igualdad y desigualdad. En matemáticas, se utiliza el signo de igual `=`, pero en programación esto rara vez se encuentra. + +En muchos lenguajes, el símbolo `=` se utiliza para asignar valores a variables. Por lo tanto, en Python se compara con `==`. + +Lista de operaciones de comparación: + +* `<` — menor que +* `<=` — menor o igual que +* `>` — mayor que +* `>=` — mayor o igual que +* `==` — igual que +* `!=` — no igual que + +Estas operaciones no solo se aplican a números. Por ejemplo, con el operador de igualdad se pueden comparar cadenas de texto: `password == text` es una comparación de identidad entre cadenas de texto que están almacenadas en diferentes variables. + +Una operación lógica como `5 > 4` o `password == text` es una expresión. Su resultado es un valor especial, `True` (verdadero) o `False` (falso). Este es un nuevo tipo de dato para nosotros, el tipo `bool`. + +```python +result = 5 > 4 +print(result) # => True +print('one' != 'one') # => False +``` + +Junto con las cadenas de texto (`str`) y los números enteros y racionales, el **tipo `bool` (booleano)** es uno de los tipos de datos primitivos en Python. + +Intentemos escribir una función simple que tome la edad de un niño y determine si es un bebé. Se considera bebé a los niños menores de un año: + +```python +def is_infant(age): + return age < 1 + +print(is_infant(3)) # => False +``` + +https://replit.com/@hexlet/python-basics-logic-bool-type + +Cualquier operación es una expresión, por lo que en una sola línea de la función escribimos "devolver el valor que resulte de la comparación `age < 1`". Dependiendo del argumento que se pase, la comparación será verdadera (`True`) o falsa (`False`), y `return` devolverá ese resultado. + +Ahora probemos con un niño de seis meses: + +```python +print(is_infant(0.5)) # => True +``` + +El resultado de la operación es `True`. Por lo tanto, el niño es realmente un bebé. diff --git a/modules/45-logic/10-bool-type/es/data.yml b/modules/45-logic/10-bool-type/es/data.yml new file mode 100644 index 00000000..33a54d1b --- /dev/null +++ b/modules/45-logic/10-bool-type/es/data.yml @@ -0,0 +1,10 @@ +name: Tipo lógico +tips: + - > + [Booleanos en + Python](https://docs.python.org/3/library/stdtypes.html#boolean-values) +definitions: + - name: Tipo lógico (bool) + description: >- + un tipo de dato con dos posibles valores: `True` (verdadero) y `False` + (falso). diff --git a/modules/45-logic/10-bool-type/ru/EXERCISE.md b/modules/45-logic/10-bool-type/ru/EXERCISE.md new file mode 100644 index 00000000..aebc559e --- /dev/null +++ b/modules/45-logic/10-bool-type/ru/EXERCISE.md @@ -0,0 +1,9 @@ + +Напишите функцию `is_pensioner()`, которая принимает возраст в качестве единственного аргумента и проверяет, является ли этот возраст пенсионным. Пенсионным считается возраст 60 лет и больше. + +Примеры вызова: + +```python +is_pensioner(75) # True +is_pensioner(18) # False +``` diff --git a/modules/45-logic/10-bool-type/ru/README.md b/modules/45-logic/10-bool-type/ru/README.md new file mode 100644 index 00000000..310504b7 --- /dev/null +++ b/modules/45-logic/10-bool-type/ru/README.md @@ -0,0 +1,48 @@ + +Кроме арифметических операций в математике есть операции сравнения, например, `5 > 4` или `3 < 1`. Они есть и в программировании. Допустим, когда мы заходим на сайт, введенные логин и пароль сравниваются с теми, какие есть в базе. Если они есть, нас пускают внутрь — аутентифицируют. В этом уроке разберем операции сравнения. + +Языки программирования адаптировали все математические операции сравнения в неизменном виде, кроме операторов равенства и неравенства. В математике для этого используется обычное равно `=`, но в программировании такое встречается редко. + +Во многих языках символ `=` используется, чтобы присвоить переменным значения. Поэтому в Python сравнивают с помощью `==`. + +Список операций сравнения: + +* `<` — меньше +* `<=` — меньше или равно +* `>` — больше +* `>=` — больше или равно +* `==` — равно +* `!=` — не равно + +Эти операции применяются не только к числам. Например, с помощью оператора равенства можно сравнить строки: `password == text` — это сравнение идентичности строк, которые записаны в разных переменных. + +Логическая операция типа `5 > 4` или `password == text` — это выражение. Его результат — специальное значение `True` («истина») или `False` («ложь»). Это новый для нас тип данных — `bool`. + +```python +result = 5 > 4 +print(result) # => True +print('one' != 'one') # => False +``` + +Наряду со строками (`str`) и целыми и рациональными числами, **тип `bool` (булев)** — это один из примитивных типов данных в Python. + +Попробуем написать простую функцию, которая принимает на вход возраст ребенка и определяет, младенец ли он. Младенцами считаются дети до года: + +```python +def is_infant(age): + return age < 1 + +print(is_infant(3)) # => False +``` + +https://replit.com/@hexlet/python-basics-logic-bool-type + +Любая операция — это выражение, поэтому единственной строчкой функции пишем «вернуть то значение, которое получится в результате сравнения `age < 1`». В зависимости от того, какой аргумент пришел, сравнение будет истинным (`True`) или ложным (`False`), а `return` вернет этот результат. + +А теперь проверим ребенка, которому полгода: + +```python +print(is_infant(0.5)) # => True +``` + +Результат операции `True`. Значит, ребенок действительно младенец. diff --git a/modules/45-logic/10-bool-type/ru/data.yml b/modules/45-logic/10-bool-type/ru/data.yml new file mode 100644 index 00000000..19a13e64 --- /dev/null +++ b/modules/45-logic/10-bool-type/ru/data.yml @@ -0,0 +1,10 @@ +name: Логический тип +tips: + - > + [Boolean в + Python](https://docs.python.org/3/library/stdtypes.html#boolean-values) +definitions: + - name: Логический тип (bool) + description: >- + тип данных с двумя возможными значениями: `True` (истина) и `False` + (ложь). diff --git a/modules/45-logic/15-predicates/en/EXERCISE.md b/modules/45-logic/15-predicates/en/EXERCISE.md new file mode 100644 index 00000000..48aa55c9 --- /dev/null +++ b/modules/45-logic/15-predicates/en/EXERCISE.md @@ -0,0 +1,7 @@ + +Write a function `is_mister()` that accepts a string and checks if it is the word `'Mister'`. + +```python +is_mister('Mister') # True +is_mister('Missis') # False +``` diff --git a/modules/45-logic/15-predicates/en/README.md b/modules/45-logic/15-predicates/en/README.md new file mode 100644 index 00000000..3e1afa39 --- /dev/null +++ b/modules/45-logic/15-predicates/en/README.md @@ -0,0 +1,18 @@ + +The `is_infant()` function is a **predicate** or question function. A predicate answers a “yes or no” question by returning a boolean value Predicates usually have handy names in every language to make them easy to analyze. In Python, predicates begin with the prefix `is`, `are`, or `has`: + +* `is_infant()` — "is it a baby?" +* `has_children()` — "are there children?" +* `is_empty()` — "is it empty?" +* `has_errors()` — "are there mistakes?" + +A function is considered a predicate if it returns the boolean values `True` or `False`. + +Let's write another predicate function. It takes a string and checks if it is the word `'Castle'`: + +```python +def is_castle(string): + return string == 'Castle' + +print(is_castle('Sea')) # False +``` diff --git a/modules/45-logic/15-predicates/en/data.yml b/modules/45-logic/15-predicates/en/data.yml new file mode 100644 index 00000000..7ce1dceb --- /dev/null +++ b/modules/45-logic/15-predicates/en/data.yml @@ -0,0 +1,8 @@ +name: Predicates +tips: + - > + [Naming in + Programming](https://hexlet.io/blog/posts/code-complete-naming-in-programming) +definitions: + - name: Predicate + description: выражение, отвечающее на вопрос «да» или «нет» с помощью типа bool. diff --git a/modules/45-logic/15-predicates/es/EXERCISE.md b/modules/45-logic/15-predicates/es/EXERCISE.md new file mode 100644 index 00000000..83540da3 --- /dev/null +++ b/modules/45-logic/15-predicates/es/EXERCISE.md @@ -0,0 +1,7 @@ + +Escriba la función `is_mister()`, que toma una cadena y verifica si es la palabra `'Mister'`. + +```python +is_mister('Mister') # True +is_mister('Missis') # False +``` diff --git a/modules/45-logic/15-predicates/es/README.md b/modules/45-logic/15-predicates/es/README.md new file mode 100644 index 00000000..2f2c5731 --- /dev/null +++ b/modules/45-logic/15-predicates/es/README.md @@ -0,0 +1,18 @@ + +La función `is_infant()` es una **función booleana** o función de pregunta. Un predicado responde a una pregunta afirmativa "sí" o "no", devolviendo un valor booleano. Los predicados se nombran de manera especial para facilitar el análisis en todos los lenguajes. En Python, los predicados comienzan con el prefijo `is` o `has`: + +* `is_infant()` - "¿es un bebé?" +* `has_children()` - "¿tiene hijos?" +* `is_empty()` - "¿está vacío?" +* `has_errors()` - "¿tiene errores?" + +Una función se considera un predicado si devuelve los valores booleanos `True` o `False`. + +Escribamos otra función booleana. Toma una cadena y verifica si es la palabra `'Castle'`: + +```python +def is_castle(string): + return string == 'Castle' + +print(is_castle('Sea')) # False +``` diff --git a/modules/45-logic/15-predicates/es/data.yml b/modules/45-logic/15-predicates/es/data.yml new file mode 100644 index 00000000..2477ba17 --- /dev/null +++ b/modules/45-logic/15-predicates/es/data.yml @@ -0,0 +1,9 @@ +name: Predicados +tips: + - | + [Naming in Programming](https://codica.la/blog/naming-in-programming) +definitions: + - name: Predicado + description: >- + una expresión que responde a una pregunta afirmativa "sí" o "no" + utilizando el tipo bool. diff --git a/modules/45-logic/15-predicates/ru/EXERCISE.md b/modules/45-logic/15-predicates/ru/EXERCISE.md new file mode 100644 index 00000000..9be1847e --- /dev/null +++ b/modules/45-logic/15-predicates/ru/EXERCISE.md @@ -0,0 +1,7 @@ + +Напишите функцию `is_mister()`, которая принимает строку и проверяет, является ли она словом `'Mister'`. + +```python +is_mister('Mister') # True +is_mister('Missis') # False +``` diff --git a/modules/45-logic/15-predicates/ru/README.md b/modules/45-logic/15-predicates/ru/README.md new file mode 100644 index 00000000..7b39795d --- /dev/null +++ b/modules/45-logic/15-predicates/ru/README.md @@ -0,0 +1,18 @@ + +Функция `is_infant()` — это **функция-предикат** или функция-вопрос. Предикат отвечает на утвердительный вопрос «да» или «нет», возвращая значение типа bool. Предикаты во всех языках принято именовать особым образом для простоты анализа. В Python предикаты начинаются с префикса `is` или `has`: + +* `is_infant()` — «младенец ли?» +* `has_children()` — «есть ли дети?» +* `is_empty()` — «пустой ли?» +* `has_errors()` — «есть ли ошибки?» + +Функция считается предикатом, если она возвращает булевы значения `True` или `False`. + +Напишем еще одну функцию-предикат. Она принимает строку и проверяет, является ли она словом `'Castle'`: + +```python +def is_castle(string): + return string == 'Castle' + +print(is_castle('Sea')) # False +``` diff --git a/modules/45-logic/15-predicates/ru/data.yml b/modules/45-logic/15-predicates/ru/data.yml new file mode 100644 index 00000000..11196247 --- /dev/null +++ b/modules/45-logic/15-predicates/ru/data.yml @@ -0,0 +1,8 @@ +name: Предикаты +tips: + - > + [Именование в + программировании](https://ru.hexlet.io/blog/posts/naming-in-programming) +definitions: + - name: Предикат + description: выражение, отвечающее на вопрос «да» или «нет» с помощью типа bool. diff --git a/modules/45-logic/20-logic-combine-expressions/en/EXERCISE.md b/modules/45-logic/20-logic-combine-expressions/en/EXERCISE.md new file mode 100644 index 00000000..5256e7bd --- /dev/null +++ b/modules/45-logic/20-logic-combine-expressions/en/EXERCISE.md @@ -0,0 +1,7 @@ + +Implement a function called `is_international_phone()` function that checks the format of a given phone number. If the phone number starts with *+*, then it's in the international format. + +```python +is_international_phone('89602223423') # False +is_international_phone('+79602223423') # True +``` diff --git a/modules/45-logic/20-logic-combine-expressions/en/README.md b/modules/45-logic/20-logic-combine-expressions/en/README.md new file mode 100644 index 00000000..0a82e829 --- /dev/null +++ b/modules/45-logic/20-logic-combine-expressions/en/README.md @@ -0,0 +1,52 @@ + +**Logical operations** are expressions, which means they can be combined with other expressions. For example, if we want to check if a number is odd or even. The approach used in programming is to check the remainder of a division by two: + +* if the remainder is `0`, it's an even number +* if the remainder isn't `0`, it's an odd number + +The remainder of division is a simple but important concept in arithmetic, algebra, number theory, and cryptography. You need to divide the number into several equal groups, and if there's something left over at the end, it's the remainder of the division. + +Split some candies equally among individuals: + +* 7 candies, 2 people: 2 x 3 + a remainder of 1 - 7 is not a multiple of 2 +* 21 candy, 3 people: 3 x 7 + a remainder of 0 - 21 is a multiple of 3 +* 19 candies, 5 people: 5 x 3 + a remainder of 4 - 19 is not a multiple of 5 + +The `%` operator calculates the remainder of the division: + +* `7 % 2` → `1` +* `21 % 3` → `0` +* `19 % 5` → `4` + +Let's combine the equality check `==` and the arithmetic operator `%` into one expression and write a function that checks if a number is odd or even: + +```python +def is_even(number): + return number % 2 == 0 + +print(is_even(10)) # => True +print(is_even(3)) # => False +``` + +Arithmetic operators have higher priority than logical ones. So, first the arithmetic expression `number % 2` is calculated and the result is compared to zero, then the result of the equality check is returned. + +Now write a function that takes a string and checks if the string starts with the letter `a`. + +Algorithm: + +1. Get the first character of the argument string, and write it to the variable +2. Compare whether the symbol is equal to the letter `a`. +3. Return the result + +```python +def is_first_letter_an_a(string): + first_letter = string[0] + return first_letter == 'a' + +print(is_first_letter_an_a('orange')) # => False +print(is_first_letter_an_a('apple')) # => True +``` + +To make it clear what's going on here, try saying what's going on in the same way as we decoded the process in the `is_even()` example. + +You now know that comparison operations are used in programming alongside arithmetic operations. But remember that equality is indicated using this symbol: `==`. This way, you won't confuse this operation with assigning a value to a variable. diff --git a/modules/45-logic/20-logic-combine-expressions/en/data.yml b/modules/45-logic/20-logic-combine-expressions/en/data.yml new file mode 100644 index 00000000..63ea4019 --- /dev/null +++ b/modules/45-logic/20-logic-combine-expressions/en/data.yml @@ -0,0 +1,2 @@ +name: Combining Operations and Functions +tips: [] diff --git a/modules/45-logic/20-logic-combine-expressions/es/EXERCISE.md b/modules/45-logic/20-logic-combine-expressions/es/EXERCISE.md new file mode 100644 index 00000000..f24ce59c --- /dev/null +++ b/modules/45-logic/20-logic-combine-expressions/es/EXERCISE.md @@ -0,0 +1,7 @@ + +Implementa la función `is_international_phone()`, que verifica el formato de un número de teléfono especificado. Si el teléfono comienza con un `+`, significa que está en formato internacional. + +```python +is_international_phone('89602223423') # False +is_international_phone('+79602223423') # True +``` diff --git a/modules/45-logic/20-logic-combine-expressions/es/README.md b/modules/45-logic/20-logic-combine-expressions/es/README.md new file mode 100644 index 00000000..57bf76cc --- /dev/null +++ b/modules/45-logic/20-logic-combine-expressions/es/README.md @@ -0,0 +1,54 @@ + +**Las operaciones lógicas** son expresiones, por lo tanto, se pueden combinar con otras expresiones. Por ejemplo, queremos verificar si un número es par, es decir, si es divisible por dos. En programación, se utiliza el siguiente enfoque: se verifica el residuo de la división por dos: + +* si el residuo es `0`, el número es par +* si el residuo no es `0`, el número es impar + +El residuo de la división es un concepto simple pero importante en aritmética, álgebra, teoría de números y criptografía. Consiste en dividir un número en grupos iguales y si queda algo al final, ese es el residuo de la división. + +Por ejemplo, repartimos caramelos equitativamente entre personas: + +* 7 caramelos, 2 personas: 2 x 3 + residuo 1 — 7 no es divisible por 2 +* 21 caramelos, 3 personas: 3 x 7 + residuo 0 — 21 es divisible por 3 +* 19 caramelos, 5 personas: 5 x 3 + residuo 4 — 19 no es divisible por 5 + +El operador `%` calcula el residuo de la división: + +* `7 % 2` → `1` +* `21 % 3` → `0` +* `19 % 5` → `4` + +Vamos a combinar el operador lógico "igualdad" `==` y el operador aritmético `%` en una sola expresión y escribiremos una función para verificar si un número es par: + +```python +def is_even(number): + return number % 2 == 0 + +print(is_even(10)) # => True +print(is_even(3)) # => False +``` + +Las operaciones aritméticas tienen mayor prioridad que las operaciones lógicas. Esto significa que primero se calcula la expresión aritmética `numero % 2` y luego se compara el resultado con cero para verificar la igualdad. + +Ahora vamos a escribir una función que recibe una cadena de texto y verifica si esa cadena comienza con la letra `a` en minúscula. + +Algoritmo: + +1. Obtener y guardar el primer carácter de la cadena de texto argumento +2. Comparar si el carácter es igual a la letra `a` +3. Devolver el resultado + +```python +def is_first_letter_an_a(string): + first_letter = string[0] + return first_letter == 'a' + +print(is_first_letter_an_a('orange')) # => False +print(is_first_letter_an_a('apple')) # => True +``` + +https://replit.com/@hexlet/python-basics-logic-combine-expression + +Para comprender lo que está sucediendo aquí, intente explicar el proceso de manera similar a cómo desglosamos el ejemplo de `is_even()`. + +Ahora sabes que las operaciones de comparación se utilizan en programación junto con las operaciones aritméticas. Pero recuerda que la igualdad se representa con `==`. De esta manera, no confundirás esta operación con la asignación de un valor a una variable. diff --git a/modules/45-logic/20-logic-combine-expressions/es/data.yml b/modules/45-logic/20-logic-combine-expressions/es/data.yml new file mode 100644 index 00000000..e09b3362 --- /dev/null +++ b/modules/45-logic/20-logic-combine-expressions/es/data.yml @@ -0,0 +1,9 @@ +name: Combinación de operaciones y funciones +tips: + - | + [Expresión](https://es.wikipedia.org/wiki/Expresión_(informática)) +definitions: + - name: Expresión + description: > + una secuencia de acciones sobre datos que produce un resultado que se + puede utilizar. diff --git a/modules/45-logic/20-logic-combine-expressions/ru/EXERCISE.md b/modules/45-logic/20-logic-combine-expressions/ru/EXERCISE.md new file mode 100644 index 00000000..d05cdb8d --- /dev/null +++ b/modules/45-logic/20-logic-combine-expressions/ru/EXERCISE.md @@ -0,0 +1,7 @@ + +Реализуйте функцию `is_international_phone()`, которая принимает на вход строку - номер телефона и проверяет его формат. Если телефон начинается с *+*, значит это международный формат. + +```python +is_international_phone('89602223423') # False +is_international_phone('+79602223423') # True +``` diff --git a/modules/45-logic/20-logic-combine-expressions/ru/README.md b/modules/45-logic/20-logic-combine-expressions/ru/README.md new file mode 100644 index 00000000..9bab15e2 --- /dev/null +++ b/modules/45-logic/20-logic-combine-expressions/ru/README.md @@ -0,0 +1,54 @@ + +**Логические операции** — это выражения, значит, их можно комбинировать с другими выражениями. Например, мы хотим проверить четность числа — кратность двум. В программировании используют такой подход: проверяют остаток от деления на два: + +* если остаток `0` — число четное +* если остаток не `0` — число нечетное + +Остаток от деления — простая, но важная концепция в арифметике, алгебре, в теории чисел и криптографии. Нужно разделить число на несколько равных групп, и если в конце что-то останется — это остаток от деления. + +Делим конфеты поровну между людьми: + +* 7 конфет, 2 человека: 2 x 3 + остаток 1 — 7 не кратно 2 +* 21 конфету, 3 человека: 3 x 7 + остаток 0 — 21 кратно 3 +* 19 конфет, 5 человек: 5 x 3 + остаток 4 — 19 не кратно 5 + +Оператор `%` вычисляет остаток от деления: + +* `7 % 2` → `1` +* `21 % 3` → `0` +* `19 % 5` → `4` + +Скомбинируем в одном выражении логический оператор «проверка равенства» `==` и арифметический оператор `%` и напишем функцию проверки четности: + +```python +def is_even(number): + return number % 2 == 0 + +print(is_even(10)) # => True +print(is_even(3)) # => False +``` + +Приоритет арифметических операций выше логических. Значит, сначала вычисляется арифметическое выражение `number % 2`, а затем результат сравнивается с нулем и возвращается результат проверки равенства. + +Теперь напишем функцию, которая принимает строку и проверяет, начинается ли эта строка с латинской буквы `a`. + +Алгоритм: + +1. Получим и запишем в переменную первый символ из строки-аргумента +2. Сравним, равен ли символ латинской букве `a` +3. Вернем результат + +```python +def is_first_letter_an_a(string): + first_letter = string[0] + return first_letter == 'a' + +print(is_first_letter_an_a('orange')) # => False +print(is_first_letter_an_a('apple')) # => True +``` + +https://replit.com/@hexlet/python-basics-logic-combine-expression + +Чтобы было понятно, что тут происходит, попробуйте проговорить происходящее аналогично тому, как мы расшифровывали процесс в примере с `is_even()`. + +Теперь вы знаете, что операции сравнения применяются в программировании наравне с арифметическими. Но помните, что равенство обозначается `==`. Так вы не спутаете эту операцию с присваиванием значения переменной. diff --git a/modules/45-logic/20-logic-combine-expressions/ru/data.yml b/modules/45-logic/20-logic-combine-expressions/ru/data.yml new file mode 100644 index 00000000..a40d1441 --- /dev/null +++ b/modules/45-logic/20-logic-combine-expressions/ru/data.yml @@ -0,0 +1,9 @@ +name: Комбинирование операций и функций +tips: + - | + [Выражение](https://ru.wikipedia.org/wiki/Выражение_(информатика)) +definitions: + - name: Выражение + description: > + последовательность действий над данными, приводящая к каком-то результату, + который можно использовать. diff --git a/modules/45-logic/25-logical-operators/en/EXERCISE.md b/modules/45-logic/25-logical-operators/en/EXERCISE.md new file mode 100644 index 00000000..79d3cf14 --- /dev/null +++ b/modules/45-logic/25-logical-operators/en/EXERCISE.md @@ -0,0 +1,19 @@ + +Implement a method `is_leap_year()` that determines whether a year is a leap year or not. A year will be a leap year if it is a multiple of 400 (i.e. divisible without a remainder), or if it is both a multiple of 4 and not a multiple of 100. As you can see, the definition already contains all the necessary logic, all we need to do is to translate it into code: + +```python +is_leap_year(2018) # false +is_leap_year(2017) # false +is_leap_year(2016) # true +``` + +The multiplicity can be checked as follows: + +```python +# % - returns the remainder of the left operand divided by the right operand +# Check that the number is a multiple of 10 +number % 10 == 0 + +# Check that the number is not a multiple of 10 +number % 10 != 0 +``` diff --git a/modules/45-logic/25-logical-operators/en/README.md b/modules/45-logic/25-logical-operators/en/README.md new file mode 100644 index 00000000..1a7afd8b --- /dev/null +++ b/modules/45-logic/25-logical-operators/en/README.md @@ -0,0 +1,77 @@ + +We already know how to write functions that check single conditions. And in this lesson we will learn how to build compound conditions. + +Suppose that the registration site requires that the password be longer than eight characters and contain at least one capital letter. Let's try to write two separate logical expressions and connect them with the special operator "AND": + +> Password is longer than 8 characters **And** password contains at least one capital letter + +Here is a function that takes the password and tells you whether it meets the conditions (`True`) or not (`False`): + +```python +def has_capital_letter(str): + # Checks the content of a capital letter in the string + + def is_correct_password(password): + length = len(password) + return length > 8 and has_capital_letter(password) + +print(is_correct_password('Qwerty')) # => False +print(is_correct_password('Qwerty1234')) # => True +print(is_correct_password('qwerty1234')) # => False +``` + +`and` means "AND". In mathematical logic this is called a conjunction. The whole expression is true if every **operand** - each of the compound expressions - is true. In other words, `and` means both. The priority of this operator is lower than that of comparison operators. Therefore, the expression `has_capital_letter(password) and length > 8` works correctly without brackets. + +In addition to `and`, the operator "OR" (disjunction) - is often used. It means "either or both". The expression `a or b` is true if at least one of the operands or all of them simultaneously are true. Otherwise, the expression is false. + +Operators can be combined in any number and in any sequence. If `and` and `or` occur simultaneously in the code, the priority is given by parentheses. Below is an example of an extended function that determines the correctness of a password: + +```python +def has_capital_letter(str): + # Checks the content of a capital letter in the string + +def has_special_chars(str): + # Checks the content of special characters in the string + +def is_strong_password(password): + length = len(password) + # The brackets set the priority. It is clear what relates to what. + return (length > 8 and as_capital_letter(password)) and has_special_chars(password) +``` + +Now let's imagine that we want to buy an apartment that meets these conditions: an area of 100 square meters or more on any street **OR** an area of 80 square meters or more, but on Main Street. + +Let's write a function that will check the apartment. It takes two arguments: the area is a number and the street name is a string: + +```python +def is_good_apartment(area, street): + return area >= 100 or (area >= 80 and street == 'Main Street') + +print(is_good_apartment(91, 'Queens Street')) # => False +print(is_good_apartment(78, 'Queens Street')) # => False +print(is_good_apartment(70, 'Main Street')) # => False + +print(is_good_apartment(120, 'Queens Street')) # => True +print(is_good_apartment(120, 'Main Street')) # => True +print(is_good_apartment(80, 'Main Street')) # => True +``` + +The area of mathematics in which logical operators are studied is called Boolean algebra. Below you will see **true tables** - you can use them to determine what the result will be if you apply the operator: + +#### `and` + +| A | B | A and B | +| ----- | ----- | ------- | +| True | True | **True** | +| True | False | False | +| False | True | False | +| False | False | False | + +#### `or` + +| A | B | A or B | +| ----- | ----- | -------- | +| True | True | **True** | +| True | False | **True** | +| False | True | **True** | +| False | False | False | diff --git a/modules/45-logic/25-logical-operators/en/data.yml b/modules/45-logic/25-logical-operators/en/data.yml new file mode 100644 index 00000000..2fec828e --- /dev/null +++ b/modules/45-logic/25-logical-operators/en/data.yml @@ -0,0 +1,13 @@ +name: Logical operators +tips: + - | + [Boolean algebra](https://en.wikipedia.org/wiki/Boolean_algebra_(structure)) + - | + [Logical conjunction](https://en.wikipedia.org/wiki/Logical_conjunction) + - | + [Logical disjunction](https://en.wikipedia.org/wiki/Logical_disjunction) +definitions: + - name: Logical operators. + description: >- + the AND (`and`), OR (`or`) operators, which allow you to create compound + logical conditions. diff --git a/modules/45-logic/25-logical-operators/es/EXERCISE.md b/modules/45-logic/25-logical-operators/es/EXERCISE.md new file mode 100644 index 00000000..b626272e --- /dev/null +++ b/modules/45-logic/25-logical-operators/es/EXERCISE.md @@ -0,0 +1,19 @@ + +Implementa el método `is_leap_year()`, que determina si un año es bisiesto o no. Un año es bisiesto si es divisible (es decir, no tiene residuo) por 400 o si es divisible por 4 y no es divisible por 100 al mismo tiempo. Como puedes ver, toda la lógica necesaria ya está incluida en la definición, solamente falta trasladarla al código: + +```python +is_leap_year(2018) # false +is_leap_year(2017) # false +is_leap_year(2016) # true +``` + +Puedes verificar la divisibilidad de la siguiente manera: + +```python +# % - devuelve el residuo de la división del operando izquierdo por el operando derecho +# Verifica si number es divisible por 10 +number % 10 == 0 + +# Verifica si number no es divisible por 10 +number % 10 != 0 +``` diff --git a/modules/45-logic/25-logical-operators/es/README.md b/modules/45-logic/25-logical-operators/es/README.md new file mode 100644 index 00000000..33fa54e1 --- /dev/null +++ b/modules/45-logic/25-logical-operators/es/README.md @@ -0,0 +1,79 @@ + +Ya sabemos cómo escribir funciones que verifican condiciones individuales. En esta lección aprenderemos a construir condiciones compuestas. + +Supongamos que un sitio web requiere que la contraseña tenga más de ocho caracteres y al menos una letra mayúscula al registrarse. Intentemos escribir dos expresiones lógicas separadas y combinarlas con el operador especial "Y": + +> La contraseña tiene más de 8 caracteres **Y** la contraseña contiene al menos una letra mayúscula + +Aquí hay una función que toma una contraseña y devuelve si cumple con las condiciones (`True`) o no (`False`): + +```python +def has_capital_letter(string): + # Verifica si hay al menos una letra mayúscula en la cadena + +def is_correct_password(password): + length = len(password) + return length > 8 and has_capital_letter(password) + +print(is_correct_password('Qwerty')) # => False +print(is_correct_password('Qwerty1234')) # => True +print(is_correct_password('qwerty1234')) # => False +``` + +`and` significa "Y". En lógica matemática, esto se llama conjunción. La expresión completa se considera verdadera si cada **operando** es verdadero, es decir, cada una de las expresiones compuestas. En otras palabras, `and` significa "y esto, y aquello". La prioridad de este operador es menor que la de los operadores de comparación. Por lo tanto, la expresión `has_capital_letter(password) and length > 8` también funciona correctamente sin paréntesis. + +Además de `and`, se utiliza frecuentemente el operador `or` - "O" (disyunción). Significa "o esto, o aquello, o ambos". La expresión `a or b` se considera verdadera si al menos uno de los operandos o todos ellos son verdaderos. En caso contrario, la expresión es falsa. + +Los operadores se pueden combinar en cualquier cantidad y en cualquier secuencia. Si en el código se encuentran `and` y `or` al mismo tiempo, se establece la prioridad mediante paréntesis. A continuación se muestra un ejemplo de una función extendida que determina la corrección de una contraseña: + +```python +def has_capital_letter(string): + # Verifica si hay al menos una letra mayúscula en la cadena + +def has_special_chars(string): + # Verifica si hay caracteres especiales en la cadena + +def is_strong_password(password): + length = len(password) + # Los paréntesis establecen la prioridad. Es claro a qué se refiere cada uno. + return (length > 8 and has_capital_letter(password)) and has_special_chars(password) +``` + +Ahora, imaginemos que queremos comprar un apartamento que cumpla con las siguientes condiciones: un área de al menos 100 metros cuadrados en cualquier calle **O** un área de al menos 80 metros cuadrados, pero en la calle principal `Main Street`. + +Escribamos una función que verifique el apartamento. Toma dos argumentos: el área - un número y el nombre de la calle - una cadena: + +```python +def is_good_apartment(area, street): + return area >= 100 or (area >= 80 and street == 'Main Street') + +print(is_good_apartment(91, 'Queens Street')) # => False +print(is_good_apartment(78, 'Queens Street')) # => False +print(is_good_apartment(70, 'Main Street')) # => False + +print(is_good_apartment(120, 'Queens Street')) # => True +print(is_good_apartment(120, 'Main Street')) # => True +print(is_good_apartment(80, 'Main Street')) # => True +``` + +https://replit.com/@hexlet/python-basics-logic-logical-operators + +El área de las matemáticas que estudia los operadores lógicos se llama álgebra booleana. A continuación, verás las **tablas de verdad** - con ellas puedes determinar el resultado al aplicar los operadores: + +#### Y `and` + +| A | B | A and B | +| ----- | ----- | ------- | +| True | True | **True** | +| True | False | False | +| False | True | False | +| False | False | False | + +#### O `or` + +| A | B | A or B | +| ----- | ----- | -------- | +| True | True | **True** | +| True | False | **True** | +| False | True | **True** | +| False | False | False | diff --git a/modules/45-logic/25-logical-operators/es/data.yml b/modules/45-logic/25-logical-operators/es/data.yml new file mode 100644 index 00000000..70489a64 --- /dev/null +++ b/modules/45-logic/25-logical-operators/es/data.yml @@ -0,0 +1,15 @@ +name: Operadores lógicos +tips: + - | + [Álgebra booleana](https://es.wikipedia.org/wiki/%C3%81lgebra_booleana) + - > + [Conjunción + lógica](https://es.wikipedia.org/wiki/Conjunci%C3%B3n_l%C3%B3gica) + - > + [Disyunción + lógica](https://es.wikipedia.org/wiki/Disyunci%C3%B3n_l%C3%B3gica) +definitions: + - name: Operadores lógicos + description: >- + operadores 'Y' (`and`), 'O' (`or`), que permiten crear condiciones lógicas + compuestas. diff --git a/modules/45-logic/25-logical-operators/ru/EXERCISE.md b/modules/45-logic/25-logical-operators/ru/EXERCISE.md new file mode 100644 index 00000000..db562ae0 --- /dev/null +++ b/modules/45-logic/25-logical-operators/ru/EXERCISE.md @@ -0,0 +1,19 @@ + +Реализуйте функцию `is_leap_year()`, которая принимает год в форме числа и определяет является ли он високосным или нет. Год будет високосным, если он кратен (то есть делится без остатка) 400 или он одновременно кратен 4 и не кратен 100. Как видите, в определении уже заложена вся необходимая логика, осталось только переложить её на код: + +```python +is_leap_year(2018) # false +is_leap_year(2017) # false +is_leap_year(2016) # true +``` + +Кратность можно проверять так: + +```python +# % - возвращает остаток от деления левого операнда на правый +# Проверяем что number кратен 10 +number % 10 == 0 + +# Проверяем что number не кратен 10 +number % 10 != 0 +``` diff --git a/modules/45-logic/25-logical-operators/ru/README.md b/modules/45-logic/25-logical-operators/ru/README.md new file mode 100644 index 00000000..951f32b3 --- /dev/null +++ b/modules/45-logic/25-logical-operators/ru/README.md @@ -0,0 +1,78 @@ + +Мы уже умеем писать функции, которые проверяют одиночные условия. А в этом уроке научимся строить составные условия. + +Предположим, что сайт при регистрации требует, чтобы пароль был длиннее восьми символов и содержал хотя бы одну заглавную букву. Попробуем написать два отдельных логических выражения и соединим их специальным оператором «И»: + +> Пароль длиннее 8 символов **И** пароль содержит хотя бы одну заглавную букву + +Вот функция, которая принимает пароль и говорит, соответствует ли он условиям (`True`) или не соответствует (`False`): + +```python +def has_capital_letter(string): + # Проверяет наличие хотя бы одной заглавной буквы в строке + +def is_correct_password(password): + length = len(password) + return length > 8 and has_capital_letter(password) + +print(is_correct_password('Qwerty')) # => False +print(is_correct_password('Qwerty1234')) # => True +print(is_correct_password('qwerty1234')) # => False +``` + +`and` — означает «И». В математической логике это называют конъюнкцией. Все выражение считается истинным, если истинен каждый **операнд** — каждое из составных выражений. Иными словами, `and` означает «и то, и другое». Приоритет этого оператора ниже, чем приоритет операторов сравнения. Поэтому выражение `has_capital_letter(password) and length > 8` тоже правильно отрабатывает без скобок. + +Кроме `and` часто используется оператор `or` — «ИЛИ» (дизъюнкция). Он означает «или то, или другое, или оба». Выражение `a or b` считается истинным, если хотя бы один из операндов или одновременно все — истинные. В другом случае выражение ложное. + +Операторы можно комбинировать в любом количестве и любой последовательности. Если в коде одновременно встречаются `and` и `or`, то приоритет задают скобками. Ниже пример расширенной функции, которая определяет корректность пароля: + +```python +def has_capital_letter(string): + # Проверяет наличие хотя бы одной заглавной буквы в строке +def has_special_chars(string): + # Проверяет содержание специальных символов в строке + +def is_strong_password(password): + length = len(password) + # Скобки задают приоритет. Понятно, что к чему относится. + return (length > 8 and has_capital_letter(password)) and has_special_chars(password) +``` + +Теперь представим, что мы хотим купить квартиру, которая удовлетворяет таким условиям: площадь от 100 квадратных метров и больше на любой улице **ИЛИ** площадь от 80 квадратных метров и больше, но на центральной улице `Main Street`. + +Напишем функцию, которая проверит квартиру. Она принимает два аргумента: площадь — число и название улицы — строку: + +```python +def is_good_apartment(area, street): + return area >= 100 or (area >= 80 and street == 'Main Street') + +print(is_good_apartment(91, 'Queens Street')) # => False +print(is_good_apartment(78, 'Queens Street')) # => False +print(is_good_apartment(70, 'Main Street')) # => False + +print(is_good_apartment(120, 'Queens Street')) # => True +print(is_good_apartment(120, 'Main Street')) # => True +print(is_good_apartment(80, 'Main Street')) # => True +``` + +https://replit.com/@hexlet/python-basics-logic-logical-operators + +Область математики, в которой изучаются логические операторы, называется булевой алгеброй. Ниже увидите **таблицы истинности** — по ним можно определить, каким будет результат, если применить оператора: + +#### И `and` + +| A | B | A and B | +| ----- | ----- | ------- | +| True | True | **True** | +| True | False | False | +| False | True | False | +| False | False | False | + +#### ИЛИ `or` + +| A | B | A or B | +| ----- | ----- | -------- | +| True | True | **True** | +| True | False | **True** | +| False | True | **True** | +| False | False | False | diff --git a/modules/45-logic/25-logical-operators/ru/data.yml b/modules/45-logic/25-logical-operators/ru/data.yml new file mode 100644 index 00000000..195ad678 --- /dev/null +++ b/modules/45-logic/25-logical-operators/ru/data.yml @@ -0,0 +1,13 @@ +name: Логические операторы +tips: + - | + [Булева алгебра](https://ru.wikipedia.org/wiki/Булева_алгебра) + - | + [Логическое «И»](https://ru.wikipedia.org/wiki/Конъюнкция) + - | + [Логическое «ИЛИ»](https://ru.wikipedia.org/wiki/Дизъюнкция) +definitions: + - name: Логические операторы + description: >- + операторы «И» (`and`), ИЛИ (`or`), позволяющие создавать составные + логические условия. diff --git a/modules/45-logic/28-logical-negation/en/EXERCISE.md b/modules/45-logic/28-logical-negation/en/EXERCISE.md new file mode 100644 index 00000000..8070aaea --- /dev/null +++ b/modules/45-logic/28-logical-negation/en/EXERCISE.md @@ -0,0 +1,19 @@ + +1. Implement a function called `is_palindrome()` that determines whether a word is a palindrome or not. A palindrome is a word that reads the same way in both directions. Words may be passed to the function in any case, so you must first convert the word to lowercase: `word.lower()`. + + ```python + is_palindrome('hut') # true + is_palindrome('hexlet') # false + is_palindrome('Argument') # true + is_palindrome('Function') # false + ``` + +2. Implement a function called `is_not_palindrome()` which checks if a word is NOT a palindrome: + + ```python + is_not_palindrome('шалаш') # false + is_not_palindrome('Ага') # false + is_not_palindrome('хекслет') # true + ``` + + To do this, call `is_palindrome()` inside `is_not_palindrome()` and apply negation. diff --git a/modules/45-logic/28-logical-negation/en/README.md b/modules/45-logic/28-logical-negation/en/README.md new file mode 100644 index 00000000..e29de7fe --- /dev/null +++ b/modules/45-logic/28-logical-negation/en/README.md @@ -0,0 +1,39 @@ + +Along with the logical operators **AND** and **OR**, there is also an operation called “**negation**” It changes the logical meaning to the opposite. In programming, negation corresponds to the unary operator `not`: + +```python +not True # False +not False # True +``` + +For example, if there's a function that checks if a number is even, then you can use negation to check if a number is odd: + +```python +def is_even(number): + return number % 2 == 0 + +print(is_even(10)) # => True +print(not is_even(10)) # => False +``` + +In the example above, we added `not` to the left of the function call and got the opposite action. + +Negation is a tool with which you can express intended rules in code without writing new functions. + +If you write `not is_even(10)`, the code will still work: + +```python +print(not not is_even(10)) # => True +``` + +In logic, double negation means positive: + +```python +not not True # True +not not False # False + +print(not not is_even(10)) # => True +print(not not is_even(11)) # => False +``` + +Now you know what the operators **AND**, **OR** and `not` mean. They allow you to specify compound conditions with two or more logical expressions. diff --git a/modules/45-logic/28-logical-negation/en/data.yml b/modules/45-logic/28-logical-negation/en/data.yml new file mode 100644 index 00000000..2bcad81c --- /dev/null +++ b/modules/45-logic/28-logical-negation/en/data.yml @@ -0,0 +1,4 @@ +name: Negation +tips: + - | + [De Morgan's laws](https://en.wikipedia.org/wiki/De_Morgan%27s_laws) diff --git a/modules/45-logic/28-logical-negation/es/EXERCISE.md b/modules/45-logic/28-logical-negation/es/EXERCISE.md new file mode 100644 index 00000000..8da0dc06 --- /dev/null +++ b/modules/45-logic/28-logical-negation/es/EXERCISE.md @@ -0,0 +1,21 @@ + +En esta lección, deberás implementar dos funciones: is_palindrome()` y `is_not_palindrome()` + +1. Implementa la función `is_palindrome()`, que determina si una palabra es un palíndromo o no. Un palíndromo es una palabra que se lee igual en ambos sentidos. Las palabras pueden estar en cualquier caso, por lo que primero debes convertir la palabra a minúsculas: `word.lower()`. + + ```python + is_palindrome('ala') # true + is_palindrome('hexlet') # false + is_palindrome('radar') # true + is_palindrome('función') # false + ``` + +2. Implementa la función `is_not_palindrome()`, que verifica que una palabra NO sea un palíndromo: + + ```python + is_not_palindrome('radar') # false + is_not_palindrome('ala') # false + is_not_palindrome('hexlet') # true + ``` + + Para hacer esto, llama a la función `is_palindrome()` dentro de `is_not_palindrome()` y aplica la negación. diff --git a/modules/45-logic/28-logical-negation/es/README.md b/modules/45-logic/28-logical-negation/es/README.md new file mode 100644 index 00000000..69f56188 --- /dev/null +++ b/modules/45-logic/28-logical-negation/es/README.md @@ -0,0 +1,41 @@ + +Junto con los operadores lógicos **Y** y **O**, a menudo se utiliza la operación de "**negación**". Esta operación cambia el valor lógico al opuesto. En programación, la negación se representa con el operador unario `not`: + +```python +not True # False +not False # True +``` + +Por ejemplo, si tenemos una función que verifica si un número es par, podemos utilizar la negación para verificar si es impar: + +```python +def is_even(number): + return number % 2 == 0 + +print(is_even(10)) # => True +print(not is_even(10)) # => False +``` + +En el ejemplo anterior, agregamos `not` antes de llamar a la función y obtuvimos el resultado opuesto. + +La negación es una herramienta que nos permite expresar reglas deseadas en el código sin tener que escribir nuevas funciones. + +Incluso si escribimos `not not is_even`, el código funcionará de la siguiente manera: + +```python +print(not not is_even(10)) # => True +``` + +https://replit.com/@hexlet/python-basics-logic-logical-negation + +En lógica, la doble negación es equivalente a la ausencia de negación: + +```python +not not True # True +not not False # False + +print(not not is_even(10)) # => True +print(not not is_even(11)) # => False +``` + +Ahora sabes lo que significan los operadores **Y**, **O** y `not`. Con ellos, podrás crear condiciones compuestas a partir de dos o más expresiones lógicas. diff --git a/modules/45-logic/28-logical-negation/es/data.yml b/modules/45-logic/28-logical-negation/es/data.yml new file mode 100644 index 00000000..49e2d71b --- /dev/null +++ b/modules/45-logic/28-logical-negation/es/data.yml @@ -0,0 +1,8 @@ +name: Negación +tips: + - | + [Leyes de De Morgan](https://es.wikipedia.org/wiki/Leyes_de_De_Morgan) +definitions: + - name: Negación + description: | + operación lógica que cambia el valor lógico al opuesto. diff --git a/modules/45-logic/28-logical-negation/ru/EXERCISE.md b/modules/45-logic/28-logical-negation/ru/EXERCISE.md new file mode 100644 index 00000000..c1ac7038 --- /dev/null +++ b/modules/45-logic/28-logical-negation/ru/EXERCISE.md @@ -0,0 +1,21 @@ + +В этом уроке вам нужно будет реализовать две функции `is_palindrome()` и `is_not_palindrome()`, принимающие строку на вход + +1. Реализуйте функцию `is_palindrome()`, которая определяет, является ли слово палиндромом или нет. Палиндром - это слово, которое читается одинаково в обоих направлениях. Слова в функцию могут быть переданы в любом регистре, поэтому сначала нужно привести слово к нижнему регистру: `word.lower()`. + + ```python + is_palindrome('шалаш') # true + is_palindrome('хекслет') # false + is_palindrome('Довод') # true + is_palindrome('Функция') # false + ``` + +2. Реализуйте функцию `is_not_palindrome()`, которая проверяет что слово НЕ является палиндромом: + + ```python + is_not_palindrome('шалаш') # false + is_not_palindrome('Ага') # false + is_not_palindrome('хекслет') # true + ``` + + Для этого, вызовите функцию `is_palindrome()` внутри `is_not_palindrome()` и примените отрицание. diff --git a/modules/45-logic/28-logical-negation/ru/README.md b/modules/45-logic/28-logical-negation/ru/README.md new file mode 100644 index 00000000..65bcac26 --- /dev/null +++ b/modules/45-logic/28-logical-negation/ru/README.md @@ -0,0 +1,41 @@ + +Наряду с логическими операторами **И** и **ИЛИ**, часто используется операция «**отрицание**». Она меняет логическое значение на противоположное. В программировании отрицанию соответствует унарный оператор `not`: + +```python +not True # False +not False # True +``` + +Например, если есть функция, которая проверяет четность числа, то с помощью отрицания можно выполнить проверку нечетности: + +```python +def is_even(number): + return number % 2 == 0 + +print(is_even(10)) # => True +print(not is_even(10)) # => False +``` + +В примере выше мы добавили `not` слева от вызова функции и получили обратное действие. + +Отрицание — инструмент, с которым можно выражать задуманные правила в коде и не писать новые функции. + +Если написать `not not is_even(10)`, то код сработает даже в таком случае: + +```python +print(not not is_even(10)) # => True +``` + +https://replit.com/@hexlet/python-basics-logic-logical-negation + +В логике двойное отрицание — это отсутствие отрицания: + +```python +not not True # True +not not False # False + +print(not not is_even(10)) # => True +print(not not is_even(11)) # => False +``` + +Теперь вы знаете, что означают операторы **И**, **ИЛИ** и `not`. С их помощью вы сможете задавать составные условия из двух и более логических выражений. diff --git a/modules/45-logic/28-logical-negation/ru/data.yml b/modules/45-logic/28-logical-negation/ru/data.yml new file mode 100644 index 00000000..b892f6db --- /dev/null +++ b/modules/45-logic/28-logical-negation/ru/data.yml @@ -0,0 +1,9 @@ +name: Отрицание +tips: + - | + [Законы Де Моргана](https://ru.wikipedia.org/wiki/Законы_де_Моргана) +definitions: + - name: Отрицание + description: > + логическая операция, которая меняет логическое значение на + противоположное. diff --git a/modules/45-logic/90-logical-expressions/en/EXERCISE.md b/modules/45-logic/90-logical-expressions/en/EXERCISE.md new file mode 100644 index 00000000..920c2f1e --- /dev/null +++ b/modules/45-logic/90-logical-expressions/en/EXERCISE.md @@ -0,0 +1,18 @@ + +Implement a function `string_or_not()` that checks if the passed parameter is a string. If yes, it returns `'yes'` otherwise `'no'`. + +```python +string_or_not('Hexlet') # 'yes' +string_or_not(10) # 'no' +string_or_not('') # 'yes' +string_or_not(False) # 'no' +``` + +You can check if the passed parameter is a string with the function [isinstance()](https://docs.python.org/3/library/functions.html#isinstance): + +```python +isinstance(3, str) # False +isinstance('Hexlet', str) # True +``` + +Experiment with the code in the interactive replay https://replit.com/@hexlet/python-basics-logical-expressions diff --git a/modules/45-logic/90-logical-expressions/en/README.md b/modules/45-logic/90-logical-expressions/en/README.md new file mode 100644 index 00000000..21cbc193 --- /dev/null +++ b/modules/45-logic/90-logical-expressions/en/README.md @@ -0,0 +1,158 @@ + +In this lesson we will learn the rules for transforming an argument and how to work with compound expressions and double negation. + +## Rules of Conversion + +Look at the example: + +```python +print(0 or 1) +``` + +```bash +1 +``` + +The way the **ORI** operator works is that its execution from left to right is interrupted and the result of the first argument that can be converted to `True` is returned. If there is no such argument, the last one, the right one, is returned. + +Example with operator **AND**: + +```python +print(0 and 1) +``` + +```bash +0 +``` + +The way the **AND** operator works is that its execution from left to right is interrupted and the result of the first argument, which can be converted to `False`, is returned. If there is no such argument, the last one - the right one - is returned. + +There are two conversion rules in Python: + +* `0`, `0.0`, ``'` and `None` are cast to `False`. These values are called **falsy**. This includes other data types that we will study in Hexslet +* Everything else is reduced to `True`. + +These rules are used in development, for example, to define a default value: + +```python +value = name or '' +# Examples +234 or '' # 234 +'hexlet' or '' # 'hexlet' +None or '' # '' +``` + +If `name` takes one of the falsy values, the variable `value` will be assigned an empty string. In this case, in the following code we will be able to handle `value` as a string. + +But there is a potential bug here. If `name` contains a falsy value, and the variable `value` can be assigned values like `0`, `False`, `None`, the code above will not work correctly: + +```python +# The significance is actually there, +# but it is Falsy, so it is not selected on the OR condition +False or '' # '' +0 or '' # '' +None or '' # '' +``` + +## Compound expressions + +If you combine logical expressions with each other, you can get some pretty interesting ways of solving problems with code. + +Suppose we need to implement code in which a variable is written: + +* String `yes` if the number is even +* String `no` if odd + +This can be done by using the knowledge gained above: + +```python +# even number +result = 10 % 2 == 0 and 'yes' or 'no' # 'yes' +# or print directly to the screen +print(10 % 2 == 0 and 'yes' or 'no') # => 'yes' +# odd number +print(11 % 2 == 0 and 'yes' or 'no') # => 'no' +``` + +These expressions work according to order and priority. The priority of assignment is the lowest, so it happens at the end. The priority of comparison `==` is higher than the priority of the logical operators `and` and `or`, so the comparison occurs earlier. Further the code is executed from left to right, because the priority of `and` is higher than the priority of `or`. Let's look at it step by step: + +```python +# For an even +# 1 step +10 % 2 == 0 # True +# 2 step +True and 'yes' # The result is true +# The or check is done, but the right part is not executed, because it immediately returns 'yes'. + +# For an odd +# 1 step +11 % 2 == 0 # False +# 2 step +False and 'yes' # The result is false. +# 3 step +False or 'no' # Selects and returns 'no' +``` + +The same scheme can be used with any expression at the beginning: + +```python +print(somefunc() and 'yes' or 'no') +``` + +You can check yourself and experiment with the code in [Replit](https://replit.com/@hexlet/python-basics-logical-expressions). + +## Double Negation + +Recall what the operation of negation looks like: + +```python +answer = True +print(not answer) # => False +``` + +With double negation, the final value is equal to the initial value: + +```python +answer = True +print(not not answer) # => True +``` + +The `not` operator always returns a Boolean value, regardless of the type of the passed argument, rather than replacing the value with the opposite. Therefore, a double negation will also return a boolean True/False. + +```python +answer = 'python' +print(not answer) # => False +print(not not answer) # => True +``` + +## Selection error + +Imagine that we need to check whether a value is equal to one or the other. For example, the variable `value` must contain one of two values: `first` or ``second`. Beginner developers sometimes write this expression this way: + +```python +value == ('first' or 'second') +``` + +However, such a code will lead to the wrong result. It is necessary to remember the priority of operations. The first thing is to calculate everything specified in brackets - `'first' or ` second'`. If you execute this code in Replit, the output will be as follows: + +```bash +python +Python 3.8.2 (default, Apr 12 2020, 15:53:37) +>>> 'first' or 'second' +'first' +>>> +``` + +Now replace the original expression with a partially calculated one: + +```python +value == 'first' +``` + +Not at all what we expected. Now let's go back to the beginning and write the test correctly: + +```python +# It is not necessary to put parentheses, +# because the priority == is higher than the priority of or +value == 'first' or value == 'second' +``` diff --git a/modules/45-logic/90-logical-expressions/en/data.yml b/modules/45-logic/90-logical-expressions/en/data.yml new file mode 100644 index 00000000..61cafbe0 --- /dev/null +++ b/modules/45-logic/90-logical-expressions/en/data.yml @@ -0,0 +1 @@ +name: The result of logical expressions diff --git a/modules/45-logic/90-logical-expressions/es/EXERCISE.md b/modules/45-logic/90-logical-expressions/es/EXERCISE.md new file mode 100644 index 00000000..ad353401 --- /dev/null +++ b/modules/45-logic/90-logical-expressions/es/EXERCISE.md @@ -0,0 +1,18 @@ + +Implementa la función `string_or_not()` que verifica si el parámetro proporcionado es una cadena correcta. Si lo es, devolverá como resultado `'yes'`, de lo contrario, devuelve `'no'` + +```python +string_or_not('Hexlet') # 'yes' +string_or_not(10) # 'no' +string_or_not('') # 'yes' +string_or_not(False) # 'no' +``` + +Puedes verificar si el parámetro proporcionado es una cadena utilizando la función [isinstance()](https://docs.python.org/3/library/functions.html#isinstance): + +```python +isinstance(3, str) # False +isinstance('Hexlet', str) # True +``` + +Experimenta con el código en la ventana interactiva REPL https://replit.com/@hexlet/python-basics-logical-expressions diff --git a/modules/45-logic/90-logical-expressions/es/README.md b/modules/45-logic/90-logical-expressions/es/README.md new file mode 100644 index 00000000..7b3eb0db --- /dev/null +++ b/modules/45-logic/90-logical-expressions/es/README.md @@ -0,0 +1,181 @@ + +En esta lección aprenderemos las reglas de transformación de argumentos y cómo trabajar con expresiones compuestas y doble negación. + +## Reglas de transformación + +El operador **OR** funciona de tal manera que se interrumpe la ejecución de izquierda a derecha y se devuelve el resultado del primer argumento que se pueda transformar en `True`. Si no hay ningún argumento que cumpla esta condición, se devuelve el último argumento, el de la derecha. + +Veamos un ejemplo: + +```python +print(0 or 1) ## 1 +``` + +En este caso, el número `0` es equivalente a `False`, y el número `1` es equivalente a `True`. Por lo tanto, el operador **OR** devuelve `1`, ya que es el primer argumento que se puede transformar en `True`. + +Veamos un ejemplo más complejo: + +```python +print(0 or False or '' or [] or 42 or "Hello") ## 42 +``` + +En este caso: + +- El número `0` es equivalente a `False` +- El valor `False` ya es `False` +- La cadena vacía (`''`) es equivalente a `False` +- La lista vacía (`[]`) es equivalente a `False` +- El número `42` es equivalente a `True` +- La cadena `"Hello"` también es equivalente a `True` + +El operador **OR** verifica los valores de izquierda a derecha y devuelve el primer argumento que se pueda transformar en `True`. En este ejemplo, ese valor es el número `42`. + +Ejemplo con el operador **AND**: + +```python +print(0 and 1) ## 0 +``` + +El operador **AND** funciona de tal manera que se interrumpe la ejecución de izquierda a derecha y se devuelve el resultado del primer argumento que se pueda transformar en `False`. Si no hay ningún argumento que cumpla esta condición, se devuelve el último argumento, el de la derecha. + +```python +print(42 and "Hello" and [] and 0) ## [] +``` +En este caso: + +- El número `42` es equivalente a `True` +- La cadena `"Hello"` es equivalente a `True` +- La lista vacía (`[]`) es equivalente a `False` +- El número `0` es equivalente a `False` + +El operador **AND** verifica los valores de izquierda a derecha y devuelve el primer argumento que se pueda transformar en `False`. En este ejemplo, ese valor es la lista vacía (`[]`). + +En Python hay dos reglas de transformación: + +* `0`, `0.0`, `''` y `None` se convierten en `False`. Estos valores se llaman **falsy**. También hay otros tipos de datos que aprenderemos en Hexlet. +* Todo lo demás se convierte en `True` + +Estas reglas se utilizan en el desarrollo, por ejemplo, para definir un valor por defecto: + +```python +value = name or '' +# Ejemplos +234 or '' # 234 +'hexlet' or '' # 'hexlet' +None or '' # '' +``` + +Si `nombre` tiene uno de los valores falsy, se asignará una cadena vacía a la variable `valor`. En este caso, en el código posterior podremos trabajar con `valor` como si fuera una cadena. + +Pero aquí hay un posible error. Si `nombre` contiene un valor falsy y se puede asignar a la variable `valor` un valor como `0`, `False`, `None`, entonces el código anterior no funcionará correctamente: + +```python +# El valor realmente existe, +# pero es Falsy, por lo que no se selecciona en la condición OR +False or '' # '' +0 or '' # '' +None or '' # '' +``` + +## Expresiones compuestas + +Si se combinan expresiones lógicas entre sí, se pueden obtener formas interesantes de resolver problemas con código. + +Supongamos que queremos implementar un código en el que una variable se asigna: + +* La cadena `yes` si el número es par +* La cadena `no` si el número es impar + +Esto se puede hacer utilizando los conocimientos que hemos adquirido anteriormente: + +```python +# el número es par +resultado = 10 % 2 == 0 and 'yes' or 'no' # 'yes' +# o imprimir directamente en la pantalla +print(10 % 2 == 0 and 'yes' or 'no') # => 'yes' +# el número es impar +print(11 % 2 == 0 and 'yes' or 'no') # => 'no' +``` + +Estas expresiones funcionan según el orden y la prioridad. La asignación tiene la prioridad más baja, por lo que ocurre al final. La comparación `==` tiene una prioridad más alta que los operadores lógicos `and` y `or`, por lo que se realiza antes. Luego, el código se ejecuta de izquierda a derecha, ya que la prioridad de `and` es mayor que la de `or`. Veamos los pasos: + +```python +# Para un número par +# 1 paso +10 % 2 == 0 # True +# 2 paso +True and 'yes' # Resultado: verdadero +# La comprobación de or se realiza, pero la parte derecha no se ejecuta, ya que se devuelve inmediatamente 'yes' + +# Para un número impar +# 1 paso +11 % 2 == 0 # False +# 2 paso +False and 'yes' # Resultado: falso, se sigue comprobando +# 3 paso +False or 'no' # Se selecciona y devuelve 'no' +``` + +Se puede utilizar el mismo esquema con cualquier expresión al principio: + +```python +print(somefunc() and 'yes' or 'no') +``` + +Puedes probar y experimentar con el código en https://replit.com/@hexlet/python-basics-logical-expressions). + +## Doble Negación + +Recordemos cómo se ve una operación de negación: + +```python +answer = True +print(not answer) # => False +``` + +Con una doble negación, el valor final es igual al valor inicial: + +```python +answer = True +print(not not answer) # => True +``` + +El operador `not` siempre devuelve un valor booleano, independientemente del tipo de argumento proporcionado, y no cambia el valor al opuesto. Por lo tanto, la doble negación también devolverá un Verdadero/Falso booleano. + +```python +answer = 'python' +print(not answer) # => False +print(not not answer) # => True +``` + +## Error de Elección + +Imagina que necesitamos comprobar si el valor es igual a uno u otro. Por ejemplo, la variable `value` debe contener uno de dos valores: `first` o `second`. Los desarrolladores novatos a veces escriben esta expresión de esta manera: + +```python +value == ('first' or 'second') +``` + +Sin embargo, este código dará un resultado incorrecto. Debes recordar la prioridad de las operaciones. Primero, se evalúa todo lo que está dentro de los paréntesis: `'first' or 'second'`. Si ejecutas este código en Replit, la salida será la siguiente: + +```bash +python +Python 3.8.2 (default, Apr 12 2020, 15:53:37) +>>> 'first' or 'second' +'first' +>>> +``` + +Ahora reemplacemos la expresión original con la expresión parcialmente evaluada: + +```python +value == 'first' +``` + +No es en absoluto lo que esperábamos. Y ahora volvamos al inicio y escribamos la verificación correctamente: + +```python +# No es necesario colocar paréntesis, +# porque la prioridad de == es mayor que la de or +value == 'first' or value == 'second' +``` diff --git a/modules/45-logic/90-logical-expressions/es/data.yml b/modules/45-logic/90-logical-expressions/es/data.yml new file mode 100644 index 00000000..d15980b2 --- /dev/null +++ b/modules/45-logic/90-logical-expressions/es/data.yml @@ -0,0 +1,4 @@ +name: Resultados de expresiones lógicas +tips: + - | + [Booleano](https://es.wikipedia.org/wiki/Tipo_de_dato_l%C3%B3gico) diff --git a/modules/45-logic/90-logical-expressions/ru/EXERCISE.md b/modules/45-logic/90-logical-expressions/ru/EXERCISE.md new file mode 100644 index 00000000..27ee259d --- /dev/null +++ b/modules/45-logic/90-logical-expressions/ru/EXERCISE.md @@ -0,0 +1,18 @@ + +Реализуйте функцию `string_or_not()`, которая проверяет является ли переданный параметр строкой. Если да, то возвращается `'yes'` иначе `'no'` + +```python +string_or_not('Hexlet') # 'yes' +string_or_not(10) # 'no' +string_or_not('') # 'yes' +string_or_not(False) # 'no' +``` + +Проверить то, является ли переданный параметр строкой, можно при помощи функции [isinstance()](https://docs.python.org/3/library/functions.html#isinstance): + +```python +isinstance(3, str) # False +isinstance('Hexlet', str) # True +``` + +Поэкспериментируйте с кодом в интерактивном репле https://replit.com/@hexlet/python-basics-logical-expressions diff --git a/modules/45-logic/90-logical-expressions/ru/README.md b/modules/45-logic/90-logical-expressions/ru/README.md new file mode 100644 index 00000000..d742c882 --- /dev/null +++ b/modules/45-logic/90-logical-expressions/ru/README.md @@ -0,0 +1,181 @@ + +В этом уроке познакомимся с правилами преобразования аргумента и узнаем, как работать с составными выражениями и двойным отрицанием. + +## Правила преобразования + +Оператор **ИЛИ** работает так, что его выполнение слева направо прерывается и возвращается результат первого аргумента, который можно преобразовать в `True`. Если такого аргумента нет, возвращается последний — правый. + +Посмотрите на пример: + +```python +print(0 or 1) ## 1 +``` + +В данном случае, число `0` эквивалентно `False`, а число `1` эквивалентно `True`. Таким образом, оператор **ИЛИ** вернет `1`, так как это первый аргумент, который может быть преобразован в `True`. + +Возьмем пример посложнее: + +```python +print(0 or False or '' or [] or 42 or "Hello") ## 42 +``` + +В данном случае: + +- Число `0` эквивалентно `False` +- Значение `False` уже является `False` +- Пустая строка (`''`) эквивалентна `False` +- Пустой список (`[]`) эквивалентен `False` +- Число `42` эквивалентно `True` +- Строка `"Hello"` также эквивалентна `True` + +Оператор **ИЛИ** будет проверять значения слева направо, и возвращает первый аргумент, который может быть преобразован в `True`. В данном примере это число `42`. + +Пример с оператором **И**: + +```python +print(0 and 1) ## 0 +``` + +Оператор **И** работает так, что его выполнение слева направо прерывается и возвращается результат первого аргумента, который можно преобразовать в `False`. Если такого аргумента нет, возвращается последний — правый. + +```python +print(42 and "Hello" and [] and 0) ## [] +``` +В данном случае: + +- Число `42` эквивалентно `True` +- Строка `"Hello"` эквивалентна `True` +- Пустой список (`[]`) эквивалентен `False` +- Число `0` эквивалентно `False` + +Оператор **И** будет проверять значения слева направо и возвращать первый аргумент, который может быть преобразован в `False`. В данном примере это пустой список (`[]`). + +В Python есть два правила преобразования: + +* `0`, `0.0`, `''` и `None` приводятся к `False`. Эти значения называют **falsy**. Сюда входят еще другие типы данных, которые мы будем изучать на Хекслете +* Все остальное приводится к `True` + +Этими правилами пользуются в разработке, например, чтобы определить значение по умолчанию: + +```python +value = name or '' +# Примеры +234 or '' # 234 +'hexlet' or '' # 'hexlet' +None or '' # '' +``` + +Если `name` примет одно из falsy-значений, переменной `value` будет присвоена пустая строка. В этом случае в последующем коде мы сможем работать с `value` как со строкой. + +Но здесь есть потенциальный баг. Если `name` содержит falsy значение, а переменной `value` можно присвоить значения типа `0`, `False`, `None`, то код выше заработает неверно: + +```python +# Значение на самом деле есть, +# но оно Falsy, поэтому не выбирается на условии OR +False or '' # '' +0 or '' # '' +None or '' # '' +``` + +## Составные выражения + +Если соединить логические выражения между собой, можно получать довольно интересные способы решения задач с кодом. + +Допустим, нам нужно реализовать код, в котором в переменную записывается: + +* Строка `yes`, если число четное +* Строка `no`, если нечетное + +Это можно сделать, если использовать знания, полученные выше: + +```python +# число четное +result = 10 % 2 == 0 and 'yes' or 'no' # 'yes' +# или сразу печатаем на экран +print(10 % 2 == 0 and 'yes' or 'no') # => 'yes' +# число нечетное +print(11 % 2 == 0 and 'yes' or 'no') # => 'no' +``` + +Эти выражения работают согласно порядку и приоритетам. Приоритет присваивания самый низкий, поэтому оно происходит в конце. Приоритет сравнения `==` выше, чем приоритет логических операторов `and` и `or`, поэтому сравнение происходит раньше. Дальше код выполняется слева направо, так как приоритет `and` выше, чем приоритет `or`. Рассмотрим по шагам: + +```python +# Для четного +# 1 шаг +10 % 2 == 0 # True +# 2 шаг +True and 'yes' # Результат — истина +# Проверка на or выполняется, но правая часть не исполняется, так как сразу возвращается 'yes' + +# Для нечетного +# 1 шаг +11 % 2 == 0 # False +# 2 шаг +False and 'yes' # Результат — ложь, проверяем дальше +# 3 шаг +False or 'no' # Выбирается и возвращается 'no' +``` + +Такую же схему можно использовать с любым выражением в начале: + +```python +print(somefunc() and 'yes' or 'no') +``` + +Можете проверить себя и поэкспериментировать с кодом в [Replit](https://replit.com/@hexlet/python-basics-logical-expressions). + +## Двойное отрицание + +Напомним, как выглядит операция отрицания: + +```python +answer = True +print(not answer) # => False +``` + +При двойном отрицании итоговое значение равно начальному: + +```python +answer = True +print(not not answer) # => True +``` + +Оператор `not` всегда возвращает булевое значение, независимо от типа переданного аргумента, а не заменяет значение на противоположное. Поэтому двойное отрицание тоже вернет булевое True/False. + +```python +answer = 'python' +print(not answer) # => False +print(not not answer) # => True +``` + +## Ошибка выбора + +Представьте, что нам нужно проверить — значение равно одному или другому. Например, переменная `value` должна содержать одно из двух значений: `first` или `second`. Начинающие разработчики иногда записывают это выражение так: + +```python +value == ('first' or 'second') +``` + +Однако такой код приведет к неверному результату. Необходимо вспомнить приоритет выполнения операций. Первым делом вычисляется все, что указано в скобках — `'first' or 'second'`. Если выполнить этот код в Replit, то вывод будет таким: + +```bash +python +Python 3.8.2 (default, Apr 12 2020, 15:53:37) +>>> 'first' or 'second' +'first' +>>> +``` + +Теперь заменим исходное выражение на частично вычисленное: + +```python +value == 'first' +``` + +Совсем не то, что мы ожидали. А теперь вернемся к началу и напишем проверку правильно: + +```python +# Скобки ставить не обязательно, +# потому что приоритет == выше чем приоритет or +value == 'first' or value == 'second' +``` diff --git a/modules/45-logic/90-logical-expressions/ru/data.yml b/modules/45-logic/90-logical-expressions/ru/data.yml new file mode 100644 index 00000000..fd28dd44 --- /dev/null +++ b/modules/45-logic/90-logical-expressions/ru/data.yml @@ -0,0 +1,4 @@ +name: Результат логических выражений +tips: + - | + [Boolean](https://ru.wikipedia.org/wiki/Логический_тип) diff --git a/modules/48-conditionals/30-if/en/EXERCISE.md b/modules/48-conditionals/30-if/en/EXERCISE.md new file mode 100644 index 00000000..f3eb8bbc --- /dev/null +++ b/modules/48-conditionals/30-if/en/EXERCISE.md @@ -0,0 +1,7 @@ + +Implement a function called `guess_number()` that takes a number and checks if the number is equal to a given number (let's say 42). If it's equal, the function should return the string `'You win!'`, otherwise it should return the string `'Try again!'`. + +```python +guess_number(42) # You win! +guess_number(61) # Try again! +``` diff --git a/modules/48-conditionals/30-if/en/README.md b/modules/48-conditionals/30-if/en/README.md new file mode 100644 index 00000000..355007e7 --- /dev/null +++ b/modules/48-conditionals/30-if/en/README.md @@ -0,0 +1,21 @@ + +In this lesson, we'll look at how you can use conditional constructs to change the behavior of a program, which can be made to act based on the result of a condition it checks. This allows you to write complex programs that behave depending on the situation. + +As an example, consider a function that determines the type of sentence passed to it. First, it'll distinguish between normal sentences and questions: + +```python +def get_type_of_sentence(sentence): + last_char = sentence[-1] + if last_char == '?': + return 'question' + return 'normal' + +print(get_type_of_sentence('Hodor')) # => normal +print(get_type_of_sentence('Hodor?')) # => question +``` + +`if` is a language construct that controls the procedure of how instructions are executed. After the word `if` it passes a predicate expression, followed by a colon at the end. Next, we pass a block of code. It will execute if the predicate is true. + +If the predicate is false, the code block is skipped and the function continues to be executed. In our case, the next line of code, `return 'normal'`, will make the function return a string and terminate. + +`return` can be anywhere in a function, even inside a code block with a condition. diff --git a/modules/48-conditionals/30-if/en/data.yml b/modules/48-conditionals/30-if/en/data.yml new file mode 100644 index 00000000..043085a9 --- /dev/null +++ b/modules/48-conditionals/30-if/en/data.yml @@ -0,0 +1,7 @@ +name: Conditional Constructions (if) +tips: [] +definitions: + - name: Conditional Design. + description: >- + the way to set a condition for code execution. For example, `if x > 10: . + ` diff --git a/modules/48-conditionals/30-if/es/EXERCISE.md b/modules/48-conditionals/30-if/es/EXERCISE.md new file mode 100644 index 00000000..5aa22ba6 --- /dev/null +++ b/modules/48-conditionals/30-if/es/EXERCISE.md @@ -0,0 +1,7 @@ + +Implementa la función `guess_number()`, que toma un número y verifica si es igual al número dado (supongamos que es 42). Si es igual, la función debe devolver la cadena `'You win!'`, de lo contrario, debe devolver la cadena `'Try again!'`. + +```python +guess_number(42) # You win! +guess_number(61) # Try again! +``` diff --git a/modules/48-conditionals/30-if/es/README.md b/modules/48-conditionals/30-if/es/README.md new file mode 100644 index 00000000..b83fa0b0 --- /dev/null +++ b/modules/48-conditionals/30-if/es/README.md @@ -0,0 +1,23 @@ + +En esta lección aprenderás que con las estructuras condicionales puedes cambiar el comportamiento de un programa dependiendo de las condiciones que se evalúen. Esto te permitirá escribir programas complejos que se comporten de manera diferente según la situación. + +Como ejemplo, consideremos una función que determina el tipo de una oración dada. Al principio, esta distinguirá entre oraciones normales y preguntas: + +```python +def get_type_of_sentence(sentence): + last_char = sentence[-1] + if last_char == '?': + return 'question' + return 'normal' + +print(get_type_of_sentence('Hodor')) # => normal +print(get_type_of_sentence('Hodor?')) # => pregunta +``` + +https://replit.com/@hexlet/python-basics-conditionals-if + +`if` es una estructura del lenguaje que controla el orden de ejecución de las instrucciones. Después de la palabra `if`, se le pasa una expresión booleana y se coloca dos puntos al final. Luego se describe un bloque de código. Este se ejecutará si el predicado es verdadero. + +Si el predicado es falso, se omitirá el bloque de código y la función continuará su ejecución. En nuestro caso, la siguiente línea de código, `return 'normal'`, hará que la función devuelva la cadena y termine. + +`return` puede estar en cualquier lugar de la función, incluso dentro de un bloque de código con una condición. diff --git a/modules/48-conditionals/30-if/es/data.yml b/modules/48-conditionals/30-if/es/data.yml new file mode 100644 index 00000000..2cda03c9 --- /dev/null +++ b/modules/48-conditionals/30-if/es/data.yml @@ -0,0 +1,7 @@ +name: Estructura condicional (if) +tips: [] +definitions: + - name: Estructura condicional + description: >- + forma de establecer una condición para ejecutar código. Por ejemplo, `if x + > 10: ... ` diff --git a/modules/48-conditionals/30-if/ru/EXERCISE.md b/modules/48-conditionals/30-if/ru/EXERCISE.md new file mode 100644 index 00000000..560600f5 --- /dev/null +++ b/modules/48-conditionals/30-if/ru/EXERCISE.md @@ -0,0 +1,7 @@ + +Реализуйте функцию `guess_number()`, которая принимает число и проверяет, равно ли число заданному (пусть это будет 42). Если равно, то функция должна вернуть строку `'You win!'`, в противном случае нужно вернуть строку `'Try again!'`. + +```python +guess_number(42) # You win! +guess_number(61) # Try again! +``` diff --git a/modules/48-conditionals/30-if/ru/README.md b/modules/48-conditionals/30-if/ru/README.md new file mode 100644 index 00000000..5eea0e2a --- /dev/null +++ b/modules/48-conditionals/30-if/ru/README.md @@ -0,0 +1,23 @@ + +В этом уроке вы узнаете, что с помощью условных конструкций можно изменить поведение программы, что будет зависеть от проверяемых условий. Благодаря этому вы сможете писать сложные программы, которые ведут себя в зависимости от ситуации. + +Для примера рассмотрим функцию, которая определяет тип переданного предложения. Для начала она будет отличать обычные предложения от вопросительных: + +```python +def get_type_of_sentence(sentence): + last_char = sentence[-1] + if last_char == '?': + return 'question' + return 'normal' + +print(get_type_of_sentence('Hodor')) # => normal +print(get_type_of_sentence('Hodor?')) # => question +``` + +https://replit.com/@hexlet/python-basics-conditionals-if + +`if` — конструкция языка, которая управляет порядком выполнения инструкций. После слова `if` ей передается выражение-предикат, и в конце ставится двоеточие. После этого описывается блок кода. Он выполнится, если предикат — истина. + +Если предикат — ложь, то блок кода пропускается, и функция продолжает свое выполнение дальше. В нашем случае следующая строчка кода — `return 'normal'` — заставит функцию вернуть строку и завершиться. + +`return` может находиться в любом месте функции — даже внутри блока кода с условием. diff --git a/modules/48-conditionals/30-if/ru/data.yml b/modules/48-conditionals/30-if/ru/data.yml new file mode 100644 index 00000000..989203ab --- /dev/null +++ b/modules/48-conditionals/30-if/ru/data.yml @@ -0,0 +1,5 @@ +name: Условная конструкция (if) +tips: [] +definitions: + - name: Условная конструкция + description: 'способ задать условие для выполнения кода. Например, `if x > 10: ... `' diff --git a/modules/48-conditionals/40-if-else/en/EXERCISE.md b/modules/48-conditionals/40-if-else/en/EXERCISE.md new file mode 100644 index 00000000..59aaa7f7 --- /dev/null +++ b/modules/48-conditionals/40-if-else/en/EXERCISE.md @@ -0,0 +1,28 @@ + +Implement a function called `normalize_url()` function, which normalizes data. It takes a site address and returns it with `https://` at the beginning. + +The function accepts addresses as `ADDRESS` or `http://ADDRESS`, but always returns the address as `https://ADDRESS`. You can also pass fully normalized data, e.g., `https://ADDRESS`, in which case you don't need to change anything. + +Call examples: + +```python +print(normalize_url('https://yahoo.com/')) # => 'https://yahoo.com/' +print(normalize_url('google.com')) # => 'https://google.com' +print(normalize_url('http://ai.fi')) # => 'https://ai.fi' +``` + +There are several ways to do this task. One of them is to compare the first 7 characters of the argument string with the string `http://` and then decide whether to `http://` or not based on that. + +You'll also most likely need to discard the unnecessary part at the beginning of the string. Remember when we looked at the way to get part of a string using string slices? If not, here's a quick reminder + +```python +# Take 6 characters from the beginning +print('Winterfell'[:6]) # => 'Winter' +``` + +So, with slicing, you can also discard a certain number of characters: + +```python +# Discard the first 6 characters +print('Winterfell'[6:]) # => 'fell' +``` diff --git a/modules/48-conditionals/40-if-else/en/README.md b/modules/48-conditionals/40-if-else/en/README.md new file mode 100644 index 00000000..d8793ce1 --- /dev/null +++ b/modules/48-conditionals/40-if-else/en/README.md @@ -0,0 +1,35 @@ + +Now let's modify the function from the previous lesson so that it returns the whole string `Normal sentence` or `Question` instead of just the sentence type: + +```python +def get_type_of_sentence(sentence): + last_char = sentence[-1] + + if last_char == '?': + sentence_type = 'question' + else: + sentence_type = 'normal' + + return "Sentence is " + sentence_type + +print(get_type_of_sentence('Hodor')) # => 'Sentence is normal' +print(get_type_of_sentence('Hodor?')) # => 'Sentence is question' +``` + +We added `else` and a new block. It'll execute if the condition in `if` is false. You can also put other `if` conditions in the `else` block. + +`if-else' constructions can be arranged in two ways. Negation allows you to change the order of the blocks: + +```python +def get_type_of_sentence(sentence): + last_char = sentence[-1] + + if last_char != '?': + sentence_type = 'normal' + else: + sentence_type = 'question' + + return "Sentence is " + sentence_type +``` + +To make it easier, try choosing non-negative checks and adjust the contents of the blocks to suit it. diff --git a/modules/48-conditionals/40-if-else/en/data.yml b/modules/48-conditionals/40-if-else/en/data.yml new file mode 100644 index 00000000..b38db284 --- /dev/null +++ b/modules/48-conditionals/40-if-else/en/data.yml @@ -0,0 +1,7 @@ +name: else +tips: [] +definitions: + - name: else + description: >- + a way to specify the block of code that'll be executed if an `if` + condition is not satisfied. diff --git a/modules/48-conditionals/40-if-else/es/EXERCISE.md b/modules/48-conditionals/40-if-else/es/EXERCISE.md new file mode 100644 index 00000000..5537e50a --- /dev/null +++ b/modules/48-conditionals/40-if-else/es/EXERCISE.md @@ -0,0 +1,28 @@ + +Implementa la función `normalize_url()`, que realiza la normalización de los datos. Recibe una dirección web y devuelve la misma con `https://` al principio. + +La función acepta direcciones en forma de `DIRECCIÓN` o `http://DIRECCIÓN`, pero siempre devuelve la dirección en forma de `https://DIRECCIÓN`. También puede recibir una dirección ya normalizada `https://DIRECCIÓN`, en cuyo caso no se debe hacer ningún cambio. + +Ejemplos de uso: + +```python +print(normalize_url('https://ya.ru')) # => 'https://ya.ru' +print(normalize_url('google.com')) # => 'https://google.com' +print(normalize_url('http://ai.fi')) # => 'https://ai.fi' +``` + +Hay varias formas de resolver este problema. Una de ellas es comparar los primeros 7 caracteres de la cadena de argumento con la cadena `http://` y luego agregar o no agregar `https://` en base a eso. + +También es probable que necesites descartar la parte innecesaria al principio de la cadena. Recuerda que vimos cómo obtener una parte de una cadena usando el slicing. Si no lo recuerdas, aquí tienes un recordatorio: + +```python +# Tomamos los primeros 6 caracteres +print('Invernalia'[:6]) # => 'Inver' +``` + +Así es, con el slicing también puedes descartar un número determinado de caracteres: + +```python +# Descartamos los primeros 6 caracteres +print('Winterfell'[6:]) # => 'Winter' +``` diff --git a/modules/48-conditionals/40-if-else/es/README.md b/modules/48-conditionals/40-if-else/es/README.md new file mode 100644 index 00000000..afb746d6 --- /dev/null +++ b/modules/48-conditionals/40-if-else/es/README.md @@ -0,0 +1,51 @@ + +Ahora vamos a modificar la función del tema anterior para que no solo devuelva el tipo de oración, sino toda la cadena "La oración es normal" o "La oración es una pregunta": + +```python +def get_type_of_sentence(sentence): + last_char = sentence[-1] + + if last_char == '?': + sentence_type = 'question' + else: + sentence_type = 'normal' + + return "Sentence is " + sentence_type + +print(get_type_of_sentence('Hodor')) # => 'Sentence is normal' +print(get_type_of_sentence('Hodor?')) # => 'Sentence is question' +``` + +https://replit.com/@hexlet/python-basics-conditionals-if-else + +Hemos añadido un `else` y un nuevo bloque. Se ejecutará si la condición en el `if` es falsa. También se pueden anidar otras condiciones `if` dentro del bloque `else`. "Else" se traduce como "en otro caso" o "de lo contrario". + +Ejemplo de bloques anidados: + +```python +number = 10 + +if number > 10: + print("Number is greater than 10") +else: + if number == 10: + print("Number is exactly 10") + else: + print("Number is less than 10") +``` + +Se pueden estructurar las construcciones `if-else` de dos formas. Usando la negación se puede cambiar el orden de los bloques: + +```python +def get_type_of_sentence(sentence): + last_char = sentence[-1] + + if last_char != '?': + sentence_type = 'normal' + else: + sentence_type = 'question' + + return "Sentence is " + sentence_type +``` + +Para facilitar la estructura de la construcción, intenta elegir una comprobación sin negación y ajusta el contenido de los bloques en consecuencia. diff --git a/modules/48-conditionals/40-if-else/es/data.yml b/modules/48-conditionals/40-if-else/es/data.yml new file mode 100644 index 00000000..ea14ee4c --- /dev/null +++ b/modules/48-conditionals/40-if-else/es/data.yml @@ -0,0 +1,7 @@ +name: Estructura condicional else +tips: [] +definitions: + - name: else + description: >- + forma de especificar un bloque de código que se ejecutará si la condición + del `if` no se cumple. diff --git a/modules/48-conditionals/40-if-else/ru/EXERCISE.md b/modules/48-conditionals/40-if-else/ru/EXERCISE.md new file mode 100644 index 00000000..b3729e20 --- /dev/null +++ b/modules/48-conditionals/40-if-else/ru/EXERCISE.md @@ -0,0 +1,28 @@ + +Реализуйте функцию `normalize_url()`, которая выполняет нормализацию данных. Она принимает адрес сайта и возвращает его с `https://` в начале. + +Функция принимает адреса в виде `АДРЕС` или `http://АДРЕС`, но всегда возвращает адрес в виде `https://АДРЕС`. На вход функции также может поступить адрес в уже нормализованном виде `https://АДРЕС`, в этом случае ничего менять не надо. + +Примеры вызова: + +```python +print(normalize_url('https://ya.ru')) # => 'https://ya.ru' +print(normalize_url('google.com')) # => 'https://google.com' +print(normalize_url('http://ai.fi')) # => 'https://ai.fi' +``` + +Есть несколько способов решить задачу. Один из них — сравнивать первые 7 символов строки-аргумента со строкой `http://`, а потом на основе этого добавлять или не добавлять к ней `https://`. + +Также вам скорее всего потребуется отбросить ненужную часть в начале строки. Помните, мы рассматривали способ получения кусочка от строки с помощью среза? Если нет, напоминаю: + +```python +# Берём 6 символов от начала +print('Winterfell'[:6]) # => 'Winter' +``` + +Так вот, с помощью срезов можно также отбросить определённое количество символов: + +```python +# Отбрасываем первые 6 символов +print('Winterfell'[6:]) # => 'fell' +``` diff --git a/modules/48-conditionals/40-if-else/ru/README.md b/modules/48-conditionals/40-if-else/ru/README.md new file mode 100644 index 00000000..6bc75662 --- /dev/null +++ b/modules/48-conditionals/40-if-else/ru/README.md @@ -0,0 +1,51 @@ + +Теперь изменим функцию из предыдущего урока так, чтобы она возвращала не просто тип предложения, а целую строку `Sentence is normal` или `Sentence is question`: + +```python +def get_type_of_sentence(sentence): + last_char = sentence[-1] + + if last_char == '?': + sentence_type = 'question' + else: + sentence_type = 'normal' + + return "Sentence is " + sentence_type + +print(get_type_of_sentence('Hodor')) # => 'Sentence is normal' +print(get_type_of_sentence('Hodor?')) # => 'Sentence is question' +``` + +https://replit.com/@hexlet/python-basics-conditionals-if-else + +Мы добавили `else` и новый блок. Он выполнится, если условие в `if` — ложь. Еще в блок `else` можно вкладывать другие условия `if`. Else переводится «иначе», «в ином случае». + +Пример вложенных блоков: + +```python +number = 10 + +if number > 10: + print("Number is greater than 10") +else: + if number == 10: + print("Number is exactly 10") + else: + print("Number is less than 10") +``` + +Оформить конструкцию `if-else` можно двумя способами. С помощью отрицания можно изменить порядок блоков: + +```python +def get_type_of_sentence(sentence): + last_char = sentence[-1] + + if last_char != '?': + sentence_type = 'normal' + else: + sentence_type = 'question' + + return "Sentence is " + sentence_type +``` + +Чтобы конструкцию было легче оформлять, старайтесь выбирать проверку без отрицаний и подстраивайте содержимое блоков под нее. diff --git a/modules/48-conditionals/40-if-else/ru/data.yml b/modules/48-conditionals/40-if-else/ru/data.yml new file mode 100644 index 00000000..7057cb6d --- /dev/null +++ b/modules/48-conditionals/40-if-else/ru/data.yml @@ -0,0 +1,7 @@ +name: Условная конструкция else +tips: [] +definitions: + - name: else + description: >- + способ задать блок кода, который будет выполнен, если условие с `if` не + удовлетворено. diff --git a/modules/48-conditionals/50-else-if/en/EXERCISE.md b/modules/48-conditionals/50-else-if/en/EXERCISE.md new file mode 100644 index 00000000..756fcdb4 --- /dev/null +++ b/modules/48-conditionals/50-else-if/en/EXERCISE.md @@ -0,0 +1,19 @@ + +The electronic map of Westeros that Sam implemented shows Stark allies in green circles, enemies in red, and neutral families in gray. + +Write a function `who_is_this_house_to_starks()` for Sam that takes the family name as input and returns one of three values: `'friend'`, `'enemy'`, `'neutral'`. + +Rules of Determination: + + * Friends (`'friend'`): `'Karstark'`, `'Tully'` + * Enemies (`'enemy'`): `'Lannister'`, `'Frey'` + * Any other families are considered `neutral'`. + +Examples of calls: + +```python +print(who_is_this_house_to_starks('Karstark')) # => 'friend' +print(who_is_this_house_to_starks('Frey')) # => 'enemy' +print(who_is_this_house_to_starks('Joar')) # => 'neutral' +print(who_is_this_house_to_starks('Ivanov')) # => 'neutral' +``` diff --git a/modules/48-conditionals/50-else-if/en/README.md b/modules/48-conditionals/50-else-if/en/README.md new file mode 100644 index 00000000..6e265231 --- /dev/null +++ b/modules/48-conditionals/50-else-if/en/README.md @@ -0,0 +1,54 @@ + +The function `get_type_of_sentence()` only distinguishes between question and normal sentences. Let's add support for exclamatory sentences to it: + +```python +def get_type_of_sentence(sentence): + last_char = sentence[-1] + + if last_char == '?': + sentence_type = 'question' + + if last_char == '!': + sentence_type = 'exclamation' + else: + sentence_type = 'normal' + + return 'Sentence is ' + sentence_type + +print(get_type_of_sentence('Who?')) # => 'Sentence is normal' +print(get_type_of_sentence('No')) # => 'Sentence is normal' +print(get_type_of_sentence('No!')) # => 'Sentence is exclamation' +``` + +We have added an exclamation checker for exclamation sentences. Technically this feature works, but it treats question sentences incorrectly. There are also problems with it in terms of semantics: + +* The exclamation point is checked in any case, even if there is already a question mark +* The `else` branch is described for the second condition, but not for the first. Therefore the question sentence becomes `normal'`. + +To remedy the situation, let's take another possibility of conditional construction: + +```python +def get_type_of_sentence(sentence): + last_char = sentence[-1] + + if last_char == '?': + sentence_type = 'question' + elif last_char == '!': + sentence_type = 'exclamation' + else: + sentence_type = 'normal' + + return 'Sentence is ' + sentence_type + +print(get_type_of_sentence('Who?')) # => 'Sentence is question' +print(get_type_of_sentence('No')) # => 'Sentence is normal' +print(get_type_of_sentence('No!')) # => 'Sentence is exclamation' +``` + +Now all the conditions are lined up in a single construction. The `elif` means "if the previous condition is not satisfied, but the current condition is satisfied". This is the scheme: + +* If the last letter is `? then `'question'` +* if the last letter is `!`, then `'exclamation'` +* other options are `` normal'``. + +Only one of the code blocks that refers to the whole `if` construct will be executed. diff --git a/modules/48-conditionals/50-else-if/en/data.yml b/modules/48-conditionals/50-else-if/en/data.yml new file mode 100644 index 00000000..37347a9d --- /dev/null +++ b/modules/48-conditionals/50-else-if/en/data.yml @@ -0,0 +1,5 @@ +name: The construct else + if = elif +tips: [] +definitions: + - name: else + if = elif + description: a way of setting several alternative conditions. diff --git a/modules/48-conditionals/50-else-if/es/EXERCISE.md b/modules/48-conditionals/50-else-if/es/EXERCISE.md new file mode 100644 index 00000000..3c62f0cd --- /dev/null +++ b/modules/48-conditionals/50-else-if/es/EXERCISE.md @@ -0,0 +1,19 @@ + +En el mapa electrónico de Westeros implementado por Sam, los aliados de los Stark se representan con un círculo verde, los enemigos con un círculo rojo y las familias neutrales con un círculo gris. + +Escribe una función para Sam llamada `who_is_this_house_to_starks()` que reciba el apellido de una familia y devuelva uno de los tres valores: `'friend'`, `'enemy'`, `'neutral'`. + +Reglas de determinación: + + * Amigos (`'friend'`): `'Karstark'`, `'Tully'` + * Enemigos (`'enemy'`): `'Lannister'`, `'Frey'` + * Todas las demás familias se consideran neutrales (`'neutral'`) + +Ejemplos de llamadas: + +```python +print(who_is_this_house_to_starks('Karstark')) # => 'friend' +print(who_is_this_house_to_starks('Frey')) # => 'enemy' +print(who_is_this_house_to_starks('Joar')) # => 'neutral' +print(who_is_this_house_to_starks('Ivanov')) # => 'neutral' +``` diff --git a/modules/48-conditionals/50-else-if/es/README.md b/modules/48-conditionals/50-else-if/es/README.md new file mode 100644 index 00000000..16ac6dec --- /dev/null +++ b/modules/48-conditionals/50-else-if/es/README.md @@ -0,0 +1,56 @@ + +La función `get_type_of_sentence()` solo distingue entre oraciones interrogativas y oraciones normales. Agregaremos soporte para oraciones exclamativas: + +```python +def get_type_of_sentence(sentence): + last_char = sentence[-1] + + if last_char == '?': + sentence_type = 'question' + + if last_char == '!': + sentence_type = 'exclamation' + else: + sentence_type = 'normal' + + return 'La oración es ' + sentence_type + +print(get_type_of_sentence('¿Quién?')) # => 'La oración es pregunta' +print(get_type_of_sentence('No')) # => 'La oración es normal' +print(get_type_of_sentence('¡No!')) # => 'La oración es exclamación' +``` + +https://replit.com/@hexlet/python-basics-conditionals-elif + +Hemos agregado la verificación de oraciones exclamativas: 'exclamación'. Técnicamente, esta función funciona, pero interpreta incorrectamente las oraciones interrogativas. También tiene problemas desde el punto de vista semántico: + +* Se verifica la presencia del signo de exclamación de todos modos, incluso si ya se ha detectado el signo de interrogación. +* La rama `else` está descrita para la segunda condición, pero no para la primera. Por lo tanto, la oración interrogativa se convierte en "normal". + +Para corregir la situación, utilizaremos otra posibilidad de la construcción condicional: + +```python +def get_type_of_sentence(sentence): + last_char = sentence[-1] + + if last_char == '?': + sentence_type = 'question' + elif last_char == '!': + sentence_type = 'exclamation' + else: + sentence_type = 'normal' + + return 'La oración es ' + sentence_type + +print(get_type_of_sentence('¿Quién?')) # => 'La oración es pregunta' +print(get_type_of_sentence('No')) # => 'La oración es normal' +print(get_type_of_sentence('¡No!')) # => 'La oración es exclamación' +``` + +Ahora todas las condiciones se han unificado en una sola construcción. `elif` significa "si la condición anterior no se cumple, pero la actual sí". La estructura resultante es la siguiente: + +* si la última letra es `?`, entonces `'pregunta'` +* si la última letra es `!`, entonces `'exclamación'` +* para cualquier otro caso, `'normal'` + +Solo se ejecutará uno de los bloques de código que pertenezca a toda la construcción `if`. diff --git a/modules/48-conditionals/50-else-if/es/data.yml b/modules/48-conditionals/50-else-if/es/data.yml new file mode 100644 index 00000000..bf62d388 --- /dev/null +++ b/modules/48-conditionals/50-else-if/es/data.yml @@ -0,0 +1,5 @@ +name: Construcción else + if = elif +tips: [] +definitions: + - name: Condicionales else + if = elif + description: Un recurso para especificar condiciones alternativas, según sea el caso diff --git a/modules/48-conditionals/50-else-if/ru/EXERCISE.md b/modules/48-conditionals/50-else-if/ru/EXERCISE.md new file mode 100644 index 00000000..ab259052 --- /dev/null +++ b/modules/48-conditionals/50-else-if/ru/EXERCISE.md @@ -0,0 +1,19 @@ + +На электронной карте Вестероса, которую реализовал Сэм, союзники Старков отображены зелёным кружком, враги — красным, а нейтральные семьи — серым. + +Напишите для Сэма функцию `who_is_this_house_to_starks()`, которая принимает на вход фамилию семьи и возвращает одно из трёх значений: `'friend'`, `'enemy'`, `'neutral'`. + +Правила определения: + + * Друзья (`'friend'`): `'Karstark'`, `'Tully'` + * Враги (`'enemy'`): `'Lannister'`, `'Frey'` + * Любые другие семьи считаются нейтральными (`'neutral'`) + +Примеры вызова: + +```python +print(who_is_this_house_to_starks('Karstark')) # => 'friend' +print(who_is_this_house_to_starks('Frey')) # => 'enemy' +print(who_is_this_house_to_starks('Joar')) # => 'neutral' +print(who_is_this_house_to_starks('Ivanov')) # => 'neutral' +``` diff --git a/modules/48-conditionals/50-else-if/ru/README.md b/modules/48-conditionals/50-else-if/ru/README.md new file mode 100644 index 00000000..651d3f36 --- /dev/null +++ b/modules/48-conditionals/50-else-if/ru/README.md @@ -0,0 +1,56 @@ + +Функция `get_type_of_sentence()` различает только вопросительные и обычные предложения. Добавим в нее поддержку восклицательных предложений: + +```python +def get_type_of_sentence(sentence): + last_char = sentence[-1] + + if last_char == '?': + sentence_type = 'question' + + if last_char == '!': + sentence_type = 'exclamation' + else: + sentence_type = 'normal' + + return 'Sentence is ' + sentence_type + +print(get_type_of_sentence('Who?')) # => 'Sentence is normal' +print(get_type_of_sentence('No')) # => 'Sentence is normal' +print(get_type_of_sentence('No!')) # => 'Sentence is exclamation' +``` + +https://replit.com/@hexlet/python-basics-conditionals-elif + +Мы добавили проверку восклицательных предложений — exclamation. Технически эта функция работает, но вопросительные предложения трактует неверно. Еще в ней есть проблемы с точки зрения семантики: + +* Наличие восклицательного знака проверяется в любом случае, даже если уже обнаружился вопросительный знак +* Ветка `else` описана для второго условия, но не для первого. Поэтому вопросительное предложение становится `"normal"` + +Чтобы исправить ситуацию, воспользуемся еще одной возможностью условной конструкции: + +```python +def get_type_of_sentence(sentence): + last_char = sentence[-1] + + if last_char == '?': + sentence_type = 'question' + elif last_char == '!': + sentence_type = 'exclamation' + else: + sentence_type = 'normal' + + return 'Sentence is ' + sentence_type + +print(get_type_of_sentence('Who?')) # => 'Sentence is question' +print(get_type_of_sentence('No')) # => 'Sentence is normal' +print(get_type_of_sentence('No!')) # => 'Sentence is exclamation' +``` + +Теперь все условия выстроились в единую конструкцию. `elif` означает — «если не выполнено предыдущее условие, но выполнено текущее». Получается такая схема: + +* если последняя буква `?`, то `'question'` +* если последняя буква `!`, то `'exclamation'` +* остальные варианты — `'normal'` + +Выполнится только один из блоков кода, который относится ко всей конструкции `if`. diff --git a/modules/48-conditionals/50-else-if/ru/data.yml b/modules/48-conditionals/50-else-if/ru/data.yml new file mode 100644 index 00000000..edd4635a --- /dev/null +++ b/modules/48-conditionals/50-else-if/ru/data.yml @@ -0,0 +1,5 @@ +name: Конструкция else + if = elif +tips: [] +definitions: + - name: else + if = elif + description: способ задать несколько альтернативных условий. diff --git a/modules/48-conditionals/60-ternary-operator/en/EXERCISE.md b/modules/48-conditionals/60-ternary-operator/en/EXERCISE.md new file mode 100644 index 00000000..005b7446 --- /dev/null +++ b/modules/48-conditionals/60-ternary-operator/en/EXERCISE.md @@ -0,0 +1,11 @@ + +Implement a function `flip_flop()` that takes a string as input and, if that string is `'flip'`, returns the string `'flop'`. Otherwise, the function should return `'flip'`. + +Examples of calls: + +```python +print(flip_flop('flip')) # => 'flop' +print(flip_flop('flop')) # => 'flip' +``` + +Try writing two versions of the function: with the usual if-else, and with the ternary operator. diff --git a/modules/48-conditionals/60-ternary-operator/en/README.md b/modules/48-conditionals/60-ternary-operator/en/README.md new file mode 100644 index 00000000..66ca4b7a --- /dev/null +++ b/modules/48-conditionals/60-ternary-operator/en/README.md @@ -0,0 +1,43 @@ + +Look at the definition of the function that returns the modulus of the number passed: + +```python +def abs(number): + if number >= 0: + return number + return -number +``` + +But you can write it more succinctly. To do this, there must be an expression to the right of `return`, but `if` is an instruction, not an expression. In Python there is a construction that works like `if-else` but is considered an expression. It is called the **tern operator** - the only operator in Python that requires three operands: + +```python +def abs(number): + return number if number >= 0 else -number +``` + +The general pattern looks like this: ` if else '. + +Let's rewrite the initial version of `get_type_of_sentence()` in the same way. + +It was : + +```python +def get_type_of_sentence(sentence): + last_char = sentence[-1] + if last_char == '?': + return 'question' + return 'normal' +``` + +Became: + +```python +def get_type_of_sentence(sentence): + last_char = sentence[-1] + return 'question' if last_char == '?' else 'normal' + +print(get_type_of_sentence('Hodor')) # => normal +print(get_type_of_sentence('Hodor?')) # => question +``` + +You can put a ternary operator into a ternary operator. But you shouldn't do it that way because such code is hard to read and debug. diff --git a/modules/48-conditionals/60-ternary-operator/en/data.yml b/modules/48-conditionals/60-ternary-operator/en/data.yml new file mode 100644 index 00000000..e3383dd2 --- /dev/null +++ b/modules/48-conditionals/60-ternary-operator/en/data.yml @@ -0,0 +1,7 @@ +name: Ternary operator +tips: [] +definitions: + - name: Ternary operator + description: > + a way to turn a simple conditional instruction into an expression, such as + `number if number >= 0 else -number`. diff --git a/modules/48-conditionals/60-ternary-operator/es/EXERCISE.md b/modules/48-conditionals/60-ternary-operator/es/EXERCISE.md new file mode 100644 index 00000000..da48cc57 --- /dev/null +++ b/modules/48-conditionals/60-ternary-operator/es/EXERCISE.md @@ -0,0 +1,11 @@ + +Implemente la función `flip_flop()`, que recibe una cadena como entrada y, si esa cadena es igual a `'flip'`, devuelve la cadena `'flop'`. De lo contrario, la función debe devolver `'flip'`. + +Ejemplos de llamadas: + +```python +print(flip_flop('flip')) # => 'flop' +print(flip_flop('flop')) # => 'flip' +``` + +Intente escribir dos versiones de la función: una con un if-else normal y otra con un operador ternario. diff --git a/modules/48-conditionals/60-ternary-operator/es/README.md b/modules/48-conditionals/60-ternary-operator/es/README.md new file mode 100644 index 00000000..a6bc633b --- /dev/null +++ b/modules/48-conditionals/60-ternary-operator/es/README.md @@ -0,0 +1,45 @@ + +Eche un vistazo a la definición de una función que devuelve el módulo de un número dado: + +```python +def abs(number): + if number >= 0: + return number + return -number +``` + +Pero se puede escribir de manera más concisa. Para ello, a la derecha de `return` debe haber una expresión, pero `if` es una instrucción y no una expresión. En Python existe una construcción que funciona como un `if-else`, pero se considera una expresión. Se llama **operador ternario** y es el único operador en Python que requiere tres operandos: + +```python +def abs(number): + return number if number >= 0 else -number +``` + +El patrón general se ve así: ` if else `. + +Vamos a reescribir la versión inicial de `get_type_of_sentence()` de manera similar. + +Antes: + +```python +def get_type_of_sentence(sentence): + last_char = sentence[-1] + if last_char == '?': + return 'question' + return 'normal' +``` + +Después: + +```python +def get_type_of_sentence(sentence): + last_char = sentence[-1] + return 'question' if last_char == '?' else 'normal' + +print(get_type_of_sentence('Hodor')) # => normal +print(get_type_of_sentence('Hodor?')) # => question +``` + +https://replit.com/@hexlet/python-basics-conditionals-ternary-operator + +Se puede anidar un operador ternario dentro de otro operador ternario. Pero no se recomienda hacerlo, ya que ese código es difícil de leer y depurar. diff --git a/modules/48-conditionals/60-ternary-operator/es/data.yml b/modules/48-conditionals/60-ternary-operator/es/data.yml new file mode 100644 index 00000000..3908e7de --- /dev/null +++ b/modules/48-conditionals/60-ternary-operator/es/data.yml @@ -0,0 +1,7 @@ +name: Operador ternario +tips: [] +definitions: + - name: Operador ternario + description: > + una forma de convertir una instrucción condicional simple en una + expresión, por ejemplo, `number if number >= 0 else -number`. diff --git a/modules/48-conditionals/60-ternary-operator/ru/EXERCISE.md b/modules/48-conditionals/60-ternary-operator/ru/EXERCISE.md new file mode 100644 index 00000000..d8529336 --- /dev/null +++ b/modules/48-conditionals/60-ternary-operator/ru/EXERCISE.md @@ -0,0 +1,11 @@ + +Реализуйте функцию `flip_flop()`, которая принимает на вход строку и, если эта строка равна `'flip'`, возвращает строку `'flop'`. В противном случае функция должна вернуть `'flip'`. + +Примеры вызова: + +```python +print(flip_flop('flip')) # => 'flop' +print(flip_flop('flop')) # => 'flip' +``` + +Попробуйте написать два варианта функции: с обычным if-else, и с тернарным оператором. diff --git a/modules/48-conditionals/60-ternary-operator/ru/README.md b/modules/48-conditionals/60-ternary-operator/ru/README.md new file mode 100644 index 00000000..3286e64d --- /dev/null +++ b/modules/48-conditionals/60-ternary-operator/ru/README.md @@ -0,0 +1,45 @@ + +Посмотрите на определение функции, которая возвращает модуль переданного числа: + +```python +def abs(number): + if number >= 0: + return number + return -number +``` + +Но можно записать более лаконично. Для этого справа от `return` должно быть выражение, но `if` — это инструкция, а не выражение. В Python есть конструкция, которая работает как `if-else`, но считается выражением. Она называется **тернарный оператор** — единственный оператор в Python, который требует три операнда: + +```python +def abs(number): + return number if number >= 0 else -number +``` + +Общий паттерн выглядит так: ` if else `. + +Давайте перепишем начальный вариант `get_type_of_sentence()` аналогично. + +Было: + +```python +def get_type_of_sentence(sentence): + last_char = sentence[-1] + if last_char == '?': + return 'question' + return 'normal' +``` + +Стало: + +```python +def get_type_of_sentence(sentence): + last_char = sentence[-1] + return 'question' if last_char == '?' else 'normal' + +print(get_type_of_sentence('Hodor')) # => normal +print(get_type_of_sentence('Hodor?')) # => question +``` + +https://replit.com/@hexlet/python-basics-conditionals-ternary-operator + +Тернарный оператор можно вкладывать в тернарный оператор. Но не нужно так делать, так как такой код тяжело читать и отлаживать. diff --git a/modules/48-conditionals/60-ternary-operator/ru/data.yml b/modules/48-conditionals/60-ternary-operator/ru/data.yml new file mode 100644 index 00000000..f203ec81 --- /dev/null +++ b/modules/48-conditionals/60-ternary-operator/ru/data.yml @@ -0,0 +1,7 @@ +name: Тернарный оператор +tips: [] +definitions: + - name: Тернарный оператор + description: > + способ превратить простую условную инструкцию в выражение, например, + `number if number >= 0 else -number`. diff --git a/modules/48-conditionals/65-match/en/EXERCISE.md b/modules/48-conditionals/65-match/en/EXERCISE.md new file mode 100644 index 00000000..3258332a --- /dev/null +++ b/modules/48-conditionals/65-match/en/EXERCISE.md @@ -0,0 +1,15 @@ + +Implement the function `get_number_explanation()`, which takes a number as input and returns an explanation for that number. If there is no explanation for the number, return `just a number`. Explanations are available only for the following numbers: + + * 666 - devil number + * 42 - answer for everything + * 7 - prime number + +Function call examples: + +```python +get_number_explanation(8) # just a number +get_number_explanation(666) # devil number +get_number_explanation(42) # answer for everything +get_number_explanation(7) # prime number +``` diff --git a/modules/48-conditionals/65-match/en/README.md b/modules/48-conditionals/65-match/en/README.md new file mode 100644 index 00000000..c507a248 --- /dev/null +++ b/modules/48-conditionals/65-match/en/README.md @@ -0,0 +1,83 @@ + +Many programming languages, in addition to the `if` conditional statement, include a `switch` construct. With the release of Python 3.10, a similar functionality was introduced called the `match` operator. In this lesson, we will explore this operator. + +The `match` operator is a specialized version of `if`, designed for specific situations. For instance, it is useful when dealing with a chain of `if else` statements that check for equality: + +```python +if status == 'processing': + # Do something for 'processing' +elif status == 'paid': + # Do something for 'paid' +elif status == 'new': + # Do something for 'new' +else: + # Do something for everything else +``` + +The distinguishing feature of this composite check is that each branch corresponds to a check on the variable `status`. The `match` operator allows us to express this code more succinctly: + +```python +match status: + case 'processing': # status == 'processing' + # Do something for 'processing' + case 'paid': # status == 'paid' + # Do something for 'paid' + case 'new': # status == 'new' + # Do something for 'new' + case _: # else + # Do something for everything else +``` + +In terms of elements, the `match` operator is a complex construct. It consists of the following: + +* The outer description, which includes the keyword `match`. This represents the variable whose values will determine the behavior chosen by `match`. +* `case` constructs inside, where we describe the behavior for different values of the considered variable. Each `case` corresponds to an `if` in the example above. The `case _` is a special situation that corresponds to the `else` branch in conditional statements. Specifying `case _` is optional, similar to using `else`. + +Inside `match`, only the syntax shown above is permitted. In other words, we can use `case`. However, inside each `case`, the situation is different. Here, we can execute any arbitrary code: + +```python +match count: + case 1: + # Do something useful + case 2: + # Do something useful + case _: + # Do something +``` + +Sometimes, the result obtained inside a `case` leads to the end of the function containing the `match`. In such cases, it needs to be returned somehow. There are two ways to handle this: + +The first approach involves creating a variable before the `match`, filling it in `case`, and then returning the value of that variable at the end: + +```python +def count_items(count): + # Declare a variable + result = '' + + # Fill it + match count: + case 1: + result = 'one' + case 2: + result = 'two' + case _: + result = None + + # Return it + return result +``` + +The second and simpler approach is to directly return from the function while working with `case`: + +```python +def count_items(count): + match count: + case 1: + return 'one' + case 2: + return 'two' + case _: + return None +``` + +While the `match` operator is not strictly necessary in Python, it offers the advantage of better expressing the programmer's intent when checking specific variable values. Though the code may grow slightly in size, it becomes more readable compared to using `elif` blocks. diff --git a/modules/48-conditionals/65-match/en/data.yml b/modules/48-conditionals/65-match/en/data.yml new file mode 100644 index 00000000..56c352b7 --- /dev/null +++ b/modules/48-conditionals/65-match/en/data.yml @@ -0,0 +1,5 @@ +name: Match Operator +tips: + - > + [Match](https://docs.python.org/3/reference/compound_stmts.html#the-match-statement) +definitions: [] diff --git a/modules/48-conditionals/65-match/es/EXERCISE.md b/modules/48-conditionals/65-match/es/EXERCISE.md new file mode 100644 index 00000000..48532168 --- /dev/null +++ b/modules/48-conditionals/65-match/es/EXERCISE.md @@ -0,0 +1,15 @@ + +Implementa la función `get_number_explanation()`, que recibe un número como entrada y devuelve una explicación para ese número. Si no hay una explicación para el número, se devuelve `just a number`. Las explicaciones solamente existen para los siguientes números: + + * 666 - devil number + * 42 - answer for everything + * 7 - prime number + +Ejemplos de llamadas a la función: + +```python +get_number_explanation(8) # just a number +get_number_explanation(666) # devil number +get_number_explanation(42) # answer for everything +get_number_explanation(7) # prime number +``` diff --git a/modules/48-conditionals/65-match/es/README.md b/modules/48-conditionals/65-match/es/README.md new file mode 100644 index 00000000..74b388f1 --- /dev/null +++ b/modules/48-conditionals/65-match/es/README.md @@ -0,0 +1,83 @@ + +Muchos lenguajes, además de la estructura condicional `if`, incluyen `switch`. Con la versión 3.10 de Python, se agregó el operador `match` con funcionalidad similar. En esta lección, aprenderemos sobre este operador. + +El operador `match` es una versión especializada de `if` creada para situaciones específicas. Por ejemplo, se debe utilizar cuando hay una cadena de `if else` con comprobaciones de igualdad: + +```python +if status == 'processing': + # Hacer algo +elif status == 'paid': + # Hacer algo más +elif status == 'new': + # Hacer algo diferente +else: + # Hacer algo más +``` + +Esta comprobación compuesta tiene una característica distintiva: cada rama es una comprobación del valor de la variable `status`. El operador `match` permite escribir este código de forma más corta y expresiva: + +```python +match status: + case 'processing': # status == 'processing' + # Hacer algo + case 'paid': # status == 'paid' + # Hacer algo más + case 'new': # status == 'new' + # Hacer algo diferente + case _: # else + # Hacer algo más +``` + +En términos de cantidad de elementos, `match` es una construcción compleja. Está compuesta por los siguientes elementos: + +* Una descripción externa que incluye la palabra clave `match`. Esta es la variable cuyos valores determinarán el comportamiento del `match`. +* Las construcciones `case`, dentro de las cuales se describe el comportamiento para diferentes valores de la variable considerada. Cada `case` corresponde a un `if` en el ejemplo anterior. Además, `case _` es una situación especial que corresponde a la rama `else` en las estructuras condicionales. Al igual que `else`, no es obligatorio especificar `case _`. + +Dentro de `match`, solo se permite la sintaxis mostrada anteriormente. En otras palabras, se pueden utilizar `case`. Sin embargo, dentro de cada `case`, la situación es diferente. Aquí se puede ejecutar cualquier código arbitrario: + +```python +match count: + case 1: + # Hacer algo útil + case 2: + # Hacer algo útil + case _: + # Hacer algo +``` + +A veces, el resultado obtenido dentro de `case` es el final de la ejecución de la función que contiene el `match`. En ese caso, es necesario devolverlo de alguna manera. Hay dos formas de resolver este problema: + +Primera forma: crear una variable antes del `match`, asignarle un valor dentro de `case` y luego devolver el valor de esa variable al final: + +```python +def count_items(count): + # Declarar una variable + result = '' + + # Llenar el espacio + match count: + case 1: + result = 'one' + case 2: + result = 'two' + case _: + result = None + + # Devolver el valor + return result +``` + +La segunda forma es más simple y corta. En lugar de crear una variable al trabajar con `case`, se puede hacer un retorno normal de la función: + +```python +def count_items(count): + match count: + case 1: + return 'one' + case 2: + return 'two' + case _: + return None +``` + +Aunque el operador `match` se encuentra en el código, técnicamente siempre se puede prescindir de él. La ventaja clave de su uso es que expresa mejor la intención del programador cuando se necesitan comprobar valores específicos de una variable. Aunque el código es un poco más largo físicamente, es más fácil de leer en comparación con los bloques `elif`. diff --git a/modules/48-conditionals/65-match/es/data.yml b/modules/48-conditionals/65-match/es/data.yml new file mode 100644 index 00000000..5863bbde --- /dev/null +++ b/modules/48-conditionals/65-match/es/data.yml @@ -0,0 +1,5 @@ +name: Operador Match +tips: + - > + [Match](https://docs.python.org/3/reference/compound_stmts.html#the-match-statement) +definitions: [] diff --git a/modules/48-conditionals/65-match/ru/EXERCISE.md b/modules/48-conditionals/65-match/ru/EXERCISE.md new file mode 100644 index 00000000..9dfd60da --- /dev/null +++ b/modules/48-conditionals/65-match/ru/EXERCISE.md @@ -0,0 +1,15 @@ + +Реализуйте функцию `get_number_explanation()`, которая принимает на вход число и возвращает объяснение этого числа. Если для числа нет объяснения, то возвращается `just a number`. Объяснения есть только для следующих чисел: + + * 666 - devil number + * 42 - answer for everything + * 7 - prime number + +Примеры вызова функции: + +```python +get_number_explanation(8) # just a number +get_number_explanation(666) # devil number +get_number_explanation(42) # answer for everything +get_number_explanation(7) # prime number +``` diff --git a/modules/48-conditionals/65-match/ru/README.md b/modules/48-conditionals/65-match/ru/README.md new file mode 100644 index 00000000..61c44483 --- /dev/null +++ b/modules/48-conditionals/65-match/ru/README.md @@ -0,0 +1,83 @@ + +Многие языки в дополнение к условной конструкции `if` включают в себя `switch`. С выходом версии Python 3.10 также был добавлен оператор с аналогичной функциональностью — `match`. В этом уроке мы познакомимся с этим оператором. + +Оператор `match` — это специализированная версия `if`, которую создали для особых ситуаций. Например, ее нужно использовать там, где есть цепочка `if else` с проверками на равенство: + +```python +if status == 'processing': + # Делаем раз +elif status == 'paid': + # Делаем два +elif status == 'new': + # Делаем три +else: + # Делаем четыре +``` + +У этой составной проверки есть одна отличительная черта: каждая ветка здесь — это проверка значения переменной `status`. Оператор `match` позволяет записать этот код короче и выразительнее: + +```python +match status: + case 'processing': # status == 'processing' + # Делаем раз + case 'paid': # status == 'paid' + # Делаем два + case 'new': # status == 'new' + # Делаем три + case _: # else + # Делаем четыре +``` + +С точки зрения количества элементов `match` — это сложная конструкция. Она состоит из таких элементов: + +* Внешнее описание, в которое входит ключевое слово `match`. Это переменная, по значениям которой `match` будет выбирать поведение +* Конструкции `case`, внутри которой описывается поведение для разных значений рассматриваемой переменной. Каждый `case` соответствует `if` в примере выше. При этом `case _` — это особая ситуация, которая соответствует ветке `else` в условных конструкциях. Как и `else`, указывать `case _` необязательно + +Внутри `match` допустим только тот синтаксис, который показан выше. Другими словами, там можно использовать `case`. А вот внутри каждого `case` ситуация другая. Здесь можно выполнять любой произвольный код: + +```python +match count: + case 1: + # Делаем что-то полезное + case 2: + # Делаем что-то полезное + case _: + # Что-то делаем +``` + +Иногда результат, полученный внутри `case` — это конец выполнения функции, которая содержит `match`. В таком случае его нужно как-то вернуть наружу. Для решения этой задачи есть два способа: + +Первый. Создать переменную перед `match`, заполнить ее в `case` и затем в конце вернуть значение этой переменной наружу: + +```python +def count_items(count): + # Объявляем переменную + result = '' + + # Заполняем + match count: + case 1: + result = 'one' + case 2: + result = 'two' + case _: + result = None + + # Возвращаем + return result +``` + +Второй способ проще и короче. Вместо создания переменной при работе с `case` можно делать обычный возврат из функции: + +```python +def count_items(count): + match count: + case 1: + return 'one' + case 2: + return 'two' + case _: + return None +``` + +Оператор `match` хоть и встречается в коде, но технически всегда можно обойтись без него. Ключевая польза при его использовании в том, что он лучше выражает намерение программиста, когда нужно проверять конкретные значения переменной. Хотя кода и стало физически чуть больше, читать его легче, в отличие от блоков `elif`. diff --git a/modules/48-conditionals/65-match/ru/data.yml b/modules/48-conditionals/65-match/ru/data.yml new file mode 100644 index 00000000..6ec3a07f --- /dev/null +++ b/modules/48-conditionals/65-match/ru/data.yml @@ -0,0 +1,5 @@ +name: Оператор Match +tips: + - > + [Match](https://docs.python.org/3/reference/compound_stmts.html#the-match-statement) +definitions: [] diff --git a/modules/50-loops/10-while/en/EXERCISE.md b/modules/50-loops/10-while/en/EXERCISE.md new file mode 100644 index 00000000..726195f5 --- /dev/null +++ b/modules/50-loops/10-while/en/EXERCISE.md @@ -0,0 +1,10 @@ + +Modify the function `print_numbers()` so that it prints the numbers in reverse order. To do this, go from the upper bound to the lower bound. In other words, you should initialize the counter with the maximum value, and in the loop body, you should iterate it backwards down to the lower limit. + +Example call and output: + +```python +print_numbers(4) +``` + +
4
3
2
1
finished!
diff --git a/modules/50-loops/10-while/en/README.md b/modules/50-loops/10-while/en/README.md new file mode 100644 index 00000000..702c9de0 --- /dev/null +++ b/modules/50-loops/10-while/en/README.md @@ -0,0 +1,119 @@ + +The programs we're writing in this course are becoming more complex and more extensive. They're still a long way from real programs, but we're not making it easy for you. + +In this lesson, we'll be moving on to one of the most difficult of the basic topics in programming: **loops**. + +Applications can help manage employees, control your finances, and provide entertainment. Despite their differences, they all execute the algorithms embedded in them, which bear a lot of similarities. An **algorithm** is a sequence of actions that leads to an expected result. + +Let's imagine we have a book and we want to find a specific phrase in it. We remember the phrase itself, but we don't know what page it is on. We'll have to go through the pages one by one until we find the right one. This process is an example of an algorithm. + +This algorithm includes logical checks and page lookups. The number of pages you'll have to look at isn't known to us in advance. But the viewing process itself is repeated in the same way. To perform repetitive actions, you need loops. Each repetition is called an **iteration**. + +Let's write a function with a simple loop that will display the string `'Hello!'` `n` times: + +```python +def print_hello(n): + counter = 0 + while counter < n: + print('Hello!') + counter = counter + 1 + +print_hello(2) +# => Hello! +# => Hello! +``` + +Now let's analyze an example function with a loop that displays numbers from one to `n`, where `n` is passed to the funciton as an argument: + +```python +print_numbers(3) +# => 1 +# => 2 +# => 3 +``` + +You can't implement this function with the tools you've already learned, because we don't know the number of outputs in advance. But this isn't a problem for loops: + +```python +def print_numbers(last_number): + # i is short for index (ordinal number) + # this is a generally agreed way of expressing the iteration number + # as a loop counter + i = 1 + while i <= last_number: + print(i) + i = i + 1 + print('finished!') + +print_numbers(3) +# => 1 +# => 2 +# => 3 +# => finished! +``` + +A `while' loop consists of three elements: + +* The keyword `while' +* Predicate - a condition that comes after `while` and is calculated at each iteration +* Code block - loop body + +Each execution of the body is called an **iteration**. In the example above, `print_numbers(3)` called three iterations, each one displaying the variable `i`. What we're basically saying is this: “do what's specified in the body of the loop as long as the condition `i <= last_number` is true”. + +Let's look at how this code works when you call `print_numbers(3)`: + +```python +# i is initialised +i = 1 + +# The predicate returns true, so the body of the loop is executed +while 1 <= 3 +# print(1) +# i = 1 + 1 + +# The loop body has ended, so it goes back to the beginning +while 2 <= 3 +# print(2) +# i = 2 + 1 + +# The loop body has ended, so it goes back to the beginning +while 3 <= 3 +# print(3) +# i = 3 + 1 + +# The predicate returns false, so the loop is executed again +while 4 <= 3 + +# print('finished!'); +# At this point, i is equal to 4, but we don't need it anymore +# Function ends +``` + +You need to make sure that the process that generates the loop is stopped. + +Usually, the problem comes down to introducing a variable - **cycle counter**. First, it's initialized - an initial value is given to it. In our example, it's the line `i = 1`. The loop condition then checks if the counter hasn't reached its limit value. + +The limit value in the example is determined by the argument of the function. If the loop condition isn't met, the body won't be executed and the interpreter will move on and start working with the instructions after the loop. + +If the loop condition is true, the body in which the stop element is located will be executed. In this case, it's the changing of the counter. It's usually done at the end of the body, and you can't have the counter change without a variable. In the example above, the line `i = i + 1` is responsible for the change. + +At this point, beginners make a lot of mistakes. For example, you may forget to increment the counter or check it incorrectly in the predicate. This will cause the loop to run indefinitely and the program will never stop. In this case, you need to force it to stop. + +```python +def print_numbers(last_number): + i = 1 + # This loop will never stop + # and will always print the same value + while i <= last_number: + print(i) + print('finished!') +``` + +In some cases, infinite loops are useful. We won't look at these situations right now, but we can show you what this code looks like: + +```python +while True: + # Doing something +``` + +You can't do without loops when an algorithm for completing a task requires actions to be repeated and we don't know how many times these actions need to be repeated. diff --git a/modules/50-loops/10-while/en/data.yml b/modules/50-loops/10-while/en/data.yml new file mode 100644 index 00000000..b773f18e --- /dev/null +++ b/modules/50-loops/10-while/en/data.yml @@ -0,0 +1,5 @@ +name: While Loop +tips: [] +definitions: + - name: While Loop + description: an instruction to repeat the code as long as a given condition is met diff --git a/modules/50-loops/10-while/es/EXERCISE.md b/modules/50-loops/10-while/es/EXERCISE.md new file mode 100644 index 00000000..03585c1e --- /dev/null +++ b/modules/50-loops/10-while/es/EXERCISE.md @@ -0,0 +1,10 @@ + +Modifica la función `print_numbers()` para que imprima los números en orden inverso. Para ello, debes ir desde el límite superior hasta el límite inferior. Es decir, el contador debe inicializarse con el valor máximo y, en el cuerpo del ciclo, debe disminuir hasta el límite inferior. + +Ejemplo de llamada y salida: + +```python +print_numbers(4) +``` + +
4
3
2
1
¡finished!
diff --git a/modules/50-loops/10-while/es/README.md b/modules/50-loops/10-while/es/README.md new file mode 100644 index 00000000..199d5949 --- /dev/null +++ b/modules/50-loops/10-while/es/README.md @@ -0,0 +1,121 @@ + +Los programas que escribimos en el curso se vuelven más complejos y extensos. Aunque todavía están lejos de ser programas reales, ya nos hacen esforzarnos un poco más. + +En esta lección, nos adentraremos en uno de los temas básicos más difíciles de la programación: los **ciclos**. + +Las aplicaciones de software ayudan a gestionar empleados, finanzas y pueden ser entretenidas. A pesar de las diferencias, todas ellas ejecutan algoritmos incorporados en ellas, que son similares. Un **algoritmo** es una secuencia de acciones que conduce a un resultado esperado. + +Imaginemos que tenemos un libro y queremos encontrar una frase específica en él. Recordamos la frase, pero no sabemos en qué página está. Tendremos que revisar las páginas secuencialmente hasta encontrarla. Este proceso se llama algoritmo. + +Un algoritmo implica comprobaciones lógicas y recorrer las páginas. No se sabe de antemano cuántas páginas habrá que revisar, pero el proceso de revisión se repite de la misma manera. Para realizar acciones repetitivas, se necesitan ciclos. Cada repetición se llama **iteración**. + +Escribamos una función con un ciclo simple que imprima la cadena `'Hello!'` `n` veces en la pantalla: + +```python +def print_hello(n): + counter = 0 + while counter < n: + print('Hello!') + counter = counter + 1 + +print_hello(2) +# => Hello! +# => Hello! +``` + +Ahora analicemos un ejemplo de una función con un ciclo que imprime los números del 1 al número pasado como argumento: + +```python +print_numbers(3) +# => 1 +# => 2 +# => 3 +``` + +No se puede implementar esta función con los medios que ya hemos aprendido, ya que no se conoce de antemano la cantidad de impresiones en pantalla. Pero con los ciclos no hay problemas: + +```python +def print_numbers(last_number): + # i es una abreviatura de índice + # se utiliza por convención en muchos lenguajes + # como contador del ciclo + i = 1 + while i <= last_number: + print(i) + i = i + 1 + print('finished!') + +print_numbers(3) +# => 1 +# => 2 +# => 3 +# => finished! +``` + +https://replit.com/@hexlet/python-basics-loops-while + +El ciclo `while` consta de tres elementos: + +* La palabra clave `while` +* El predicado: una condición que se especifica después de `while` y se evalúa en cada iteración +* El bloque de código: el cuerpo del ciclo + +Cada ejecución del cuerpo se llama **iteración**. En el ejemplo anterior, `print_numbers(3)` provocó tres iteraciones, en cada una de las cuales se imprimió la variable `i` en la pantalla. La construcción se lee así: "haz lo que se especifica en el cuerpo del ciclo mientras la condición `i <= last_number` sea verdadera". + +Analicemos cómo funciona este código para la llamada `print_numbers(3)`: + +```python +# Se inicializa i +i = 1 + +# El predicado es verdadero, por lo que se ejecuta el cuerpo del ciclo +while 1 <= 3 +# print(1) +# i = 1 + 1 + +# Se ha completado el cuerpo del ciclo, por lo que se vuelve al principio +while 2 <= 3 +# print(2) +# i = 2 + 1 + +# Se ha completado el cuerpo del ciclo, por lo que se vuelve al principio +while 3 <= 3 +# print(3) +# i = 3 + 1 + +# El predicado es falso, por lo que la ejecución pasa después del ciclo +while 4 <= 3 + +# print('¡finished!'); +# En este punto, i es igual a 4, pero ya no lo necesitamos +# La función finaliza +``` + +El proceso que genera el ciclo debe detenerse. Eso es responsabilidad del programador. + +Por lo general, la tarea se reduce a introducir una variable: el **contador del ciclo**. Primero se inicializa, es decir, se le asigna un valor inicial. En nuestro ejemplo, esto se hace con la línea `i = 1`. Luego, en la condición del ciclo, se verifica si el contador ha alcanzado su valor límite. + +El valor límite en el ejemplo se determina mediante el argumento de la función. Si la condición del ciclo no se cumple, el cuerpo no se ejecuta y el intérprete pasa a trabajar con las instrucciones después del ciclo. + +Si la condición del ciclo es verdadera, se ejecuta el cuerpo, que contiene el elemento de parada: el cambio del contador. Por lo general, esto se hace al final del cuerpo y es el lugar donde no se puede prescindir de una variable. En el ejemplo anterior, el cambio se realiza con la línea `i = i + 1`. + +En este punto, los principiantes cometen muchos errores. Por ejemplo, se puede olvidar de incrementar el contador o verificarlo incorrectamente en el predicado. Esto conducirá a un bucle infinito, donde el ciclo se ejecutará indefinidamente y el programa nunca se detendrá. En ese caso, es necesario terminarlo forzosamente. + +```python +def print_numbers(last_number): + i = 1 + # Este ciclo nunca se detendrá + # y siempre imprimirá el mismo valor + while i <= last_number: + print(i) + print('finished!') +``` + +En algunos casos, los bucles infinitos son útiles. No vamos a considerar tales situaciones, pero mostraremos cómo se ve este código: + +```python +while True: + # Hacer algo +``` + +Los ciclos son indispensables cuando el algoritmo para resolver un problema requiere repetir ciertas acciones y la cantidad de estas operaciones no se conoce de antemano. diff --git a/modules/50-loops/10-while/es/data.yml b/modules/50-loops/10-while/es/data.yml new file mode 100644 index 00000000..85846564 --- /dev/null +++ b/modules/50-loops/10-while/es/data.yml @@ -0,0 +1,7 @@ +name: Ciclo While +tips: + - | + [Ciclo while](https://www.w3schools.com/python/python_while_loops.asp) +definitions: + - name: Ciclo While + description: una instrucción para repetir código mientras se cumpla una condición. diff --git a/modules/50-loops/10-while/ru/EXERCISE.md b/modules/50-loops/10-while/ru/EXERCISE.md new file mode 100644 index 00000000..ea2ed98e --- /dev/null +++ b/modules/50-loops/10-while/ru/EXERCISE.md @@ -0,0 +1,10 @@ + +Модифицируйте функцию `print_numbers()` так, чтобы она выводила числа в обратном порядке. Для этого нужно идти от верхней границы к нижней. То есть счётчик должен быть инициализирован максимальным значением, а в теле цикла его нужно уменьшать до нижней границы. + +Пример вызова и вывода: + +```python +print_numbers(4) +``` + +
4
3
2
1
finished!
diff --git a/modules/50-loops/10-while/ru/README.md b/modules/50-loops/10-while/ru/README.md new file mode 100644 index 00000000..c5228dd6 --- /dev/null +++ b/modules/50-loops/10-while/ru/README.md @@ -0,0 +1,121 @@ + +Программы, которые мы пишем на курсе, становятся сложнее и объемнее. Они еще далеки от реальных программ, хотя уже заставляют напрячься. + +В этом уроке мы переходим к одной из самых сложных базовых тем в программировании — **циклам**. + +Прикладные программы помогают управлять сотрудниками, финансами и могут развлекать. Несмотря на различия, они выполняют заложенные в них алгоритмы, которые похожи. **Алгоритм** — это последовательность действий, которая приводит к ожидаемому результату. + +Представим, что у нас есть книга, и мы хотим найти в ней конкретную фразу. Саму фразу мы помним, но не знаем, на какой она странице. Нам придется последовательно просматривать страницы до тех пор, пока не найдем нужную. Этот процесс и называется алгоритмом. + +Алгоритм включает логические проверки и перебор страниц. Количество страниц, которое придется посмотреть, заранее неизвестно. Но сам процесс просмотра повторяется одинаковым образом. Чтобы выполнять повторяющиеся действия, нужны циклы. Каждый повтор называется **итерацией**. + +Напишем функцию с простым циклом, который будет `n` раз выводить на экран строку `'Hello!'`: + +```python +def print_hello(n): + counter = 0 + while counter < n: + print('Hello!') + counter = counter + 1 + +print_hello(2) +# => Hello! +# => Hello! +``` + +Теперь проанализируем пример функции с циклом, который выводит на экран числа от одного до числа-аргумента: + +```python +print_numbers(3) +# => 1 +# => 2 +# => 3 +``` + +Эту функцию невозможно реализовать уже изученными средствами, так как количество выводов на экран заранее неизвестно. А с циклами проблем не будет: + +```python +def print_numbers(last_number): + # i сокращение от index (порядковый номер) + # используется по общему соглашению во множестве языков + # как счетчик цикла + i = 1 + while i <= last_number: + print(i) + i = i + 1 + print('finished!') + +print_numbers(3) +# => 1 +# => 2 +# => 3 +# => finished! +``` + +https://replit.com/@hexlet/python-basics-loops-while + +Цикл `while` состоит из трех элементов: + +* Ключевое слово `while` +* Предикат — условие, которое указывается после `while` и вычисляется на каждой итерации +* Блок кода — тело цикла + +Каждое выполнение тела называется **итерацией**. В примере выше `print_numbers(3)` вызвал три итерации, на каждой из которых была выведена на экран переменная `i`. Конструкция читается так: «делать то, что указано в теле цикла, пока истинно условие `i <= last_number`». + +Разберем работу этого кода для вызова `print_numbers(3)`: + +```python +# Инициализируется i +i = 1 + +# Предикат возвращает true, поэтому выполняется тело цикла +while 1 <= 3 +# print(1) +# i = 1 + 1 + +# Закончилось тело цикла, поэтому происходит возврат в начало +while 2 <= 3 +# print(2) +# i = 2 + 1 + +# Закончилось тело цикла, поэтому происходит возврат в начало +while 3 <= 3 +# print(3) +# i = 3 + 1 + +# Предикат возвращает false, поэтому выполнение переходит за цикл +while 4 <= 3 + +# print('finished!'); +# На этом этапе i равен 4, но он нам уже не нужен +# Функция завершается +``` + +Процесс, который порождает цикл, должен остановиться. За это отвечает программист. + +Обычно задача сводится к введению переменной — **счетчику цикла**. Сначала он инициализируется — ему задается начальное значение. В нашем примере это строчка `i = 1`. Затем в условии цикла проверяется, не достиг ли счетчик своего предельного значения. + +Предельное значение в примере определяется аргументом функции. Если условие цикла не выполнено, то тело не выполняется и интерпретатор двигается дальше — работает с инструкциями после цикла. + +Если условие цикла истинно, то выполняется тело, в котором находится элемент остановки — изменение счетчика. Обычно его делают в конце тела, и это изменение — место, где нельзя обойтись без переменной. В примере выше за изменение отвечает строчка `i = i + 1`. + +На этом моменте новички много ошибаются. Например, можно забыть увеличить счетчик или неправильно проверить его в предикате. Это приведет к зацикливанию — цикл будет работать бесконечно и программа никогда не остановится. В таком случае ее нужно завершить принудительно. + +```python +def print_numbers(last_number): + i = 1 + # Этот цикл никогда не остановится + # и будет печатать всегда одно значение + while i <= last_number: + print(i) + print('finished!') +``` + +В некоторых случаях бесконечные циклы полезны. Мы не будем рассматривать такие ситуации, но покажем, как выглядит этот код: + +```python +while True: + # Что-то делаем +``` + +Без циклов невозможно обойтись, когда алгоритм решения задачи требует повторения каких-то действий и количество этих операций заранее неизвестно. diff --git a/modules/50-loops/10-while/ru/data.yml b/modules/50-loops/10-while/ru/data.yml new file mode 100644 index 00000000..5fb7dbb4 --- /dev/null +++ b/modules/50-loops/10-while/ru/data.yml @@ -0,0 +1,7 @@ +name: Цикл While +tips: + - | + [Цикл while](https://www.w3schools.com/python/python_while_loops.asp) +definitions: + - name: Цикл While + description: инструкция для повторения кода, пока удовлетворяется какое-то условие. diff --git a/modules/50-loops/20-aggregation-numbers/en/EXERCISE.md b/modules/50-loops/20-aggregation-numbers/en/EXERCISE.md new file mode 100644 index 00000000..ad8ae885 --- /dev/null +++ b/modules/50-loops/20-aggregation-numbers/en/EXERCISE.md @@ -0,0 +1,8 @@ + +Implement a function called `multiply_numbers_from_range()` that multiplies numbers in a specified range, including range boundaries. Call example: + +```python +multiply_numbers_from_range(1, 5) # 1 * 2 * 3 * 4 * 5 = 120 +multiply_numbers_from_range(2, 3) # 2 * 3 = 6 +multiply_numbers_from_range(6, 6) # 6 +``` diff --git a/modules/50-loops/20-aggregation-numbers/en/README.md b/modules/50-loops/20-aggregation-numbers/en/README.md new file mode 100644 index 00000000..279a88c6 --- /dev/null +++ b/modules/50-loops/20-aggregation-numbers/en/README.md @@ -0,0 +1,58 @@ + +Another type of task that needs loops is ones that involve **aggregating data**. These tasks include: finding the maximum or minimum value, finding the sum of something, or finding the mean. With these tasks, the result depends on the whole data set. + +To calculate the sum, you have to add up all the numbers, and to calculate the maximum, you have to compare them. Accountants and marketers will be familiar with such tasks. They work in Microsoft Excel or Google Tables. + +In this lesson, we'll look at how aggregation applies to numbers and strings. + +Suppose we need to find the sum of a set of numbers. Let's implement a function that adds numbers in a specified range, including boundaries. A **range** is a set of numbers with an upper and lower limit. For example, the range [1, 10] includes the integers from one to ten. + +Example: + +```python +sum_numbers_from_range(5, 7) # 5 + 6 + 7 = 18 +sum_numbers_from_range(1, 2) # 1 + 2 = 3 + +# [1, 1] - a range with the same beginning and end is also a range +# It includes one number, which is the range boundary itself +sum_numbers_from_range(1, 1) # 1 +sum_numbers_from_range(100, 100) # 100 +``` + +To implement this code, you need a loop, because adding numbers is an iterative process, i.e., it's repeated for every number. The number of iterations depends on the size of the range. + +Check out the code below: + +```python +def sum_numbers_from_range(start, finish): + # It is technically possible to change the start + # But the input arguments must be left at their original value + # This will make the code easier to analyze + i = start + sum = 0 # Initializing the amount + while i <= finish: # Moving to the end of the range + sum = sum + i # Calculate the sum for each number + i = i + 1 # Move to the next number in the range + # Return the result + return sum +``` + +The structure of the loop here is standard: there's a counter, which is initialized with the initial value of the range, a loop which has a condition requiring you to stop at the end of the range, and the counter changes at the end of the loop body. The number of iterations in such a loop is equal to `finish - start + 1`. For the range [5, 7], it's 7 - 5 + 1, which is three iterations. + +The main difference from the usual way of processing is the logic of calculating the result. In aggregation tasks, there's always a variable that stores the result of the loop. In the code above, it's `sum`. It changes at each iteration of the loop: the next number in the range is added: `sum = sum + i`. + +The process looks like this: + +```python +# To call sum_numbers_from_range(2, 5) +sum = 0 +sum = sum + 2 # 2 +sum = sum + 3 # 5 +sum = sum + 4 # 9 +sum = sum + 5 # 14 +# 14 is the result of adding numbers in the range [2, 5] +``` + +The `sum` variable has an initial value, any repeating operation will begin with it. In the example above, it's `0`. + +In math, we have the concept of a **neutral element**, and each operation has a different one. An operation with this element doesn't change the value it's working on. For example, in addition, any number plus zero gives the number itself. It's the same for subtraction. Concatenation also has a neutral element, which is an empty string: `''` + `'one'` will be `'one'`. diff --git a/modules/50-loops/20-aggregation-numbers/en/data.yml b/modules/50-loops/20-aggregation-numbers/en/data.yml new file mode 100644 index 00000000..13bc9666 --- /dev/null +++ b/modules/50-loops/20-aggregation-numbers/en/data.yml @@ -0,0 +1,2 @@ +name: Data Aggregation (Numbers) +tips: [] diff --git a/modules/50-loops/20-aggregation-numbers/es/EXERCISE.md b/modules/50-loops/20-aggregation-numbers/es/EXERCISE.md new file mode 100644 index 00000000..86e1cd8d --- /dev/null +++ b/modules/50-loops/20-aggregation-numbers/es/EXERCISE.md @@ -0,0 +1,8 @@ + +Implementa la función `multiply_numbers_from_range()`, que multiplica los números en el rango especificado, incluyendo los límites del rango. Ejemplo de llamada: + +```python +multiply_numbers_from_range(1, 5) # 1 * 2 * 3 * 4 * 5 = 120 +multiply_numbers_from_range(2, 3) # 2 * 3 = 6 +multiply_numbers_from_range(6, 6) # 6 +``` diff --git a/modules/50-loops/20-aggregation-numbers/es/README.md b/modules/50-loops/20-aggregation-numbers/es/README.md new file mode 100644 index 00000000..b80efd44 --- /dev/null +++ b/modules/50-loops/20-aggregation-numbers/es/README.md @@ -0,0 +1,60 @@ + +Una clase de tareas que no se puede resolver sin bucles se llama **agregación de datos**. Estos problemas incluyen la búsqueda del valor máximo o mínimo, la suma y el promedio aritmético. En estos casos, el resultado depende de todo el conjunto de datos. + +Para calcular la suma, es necesario sumar todos los números, y para calcular el máximo, es necesario compararlos. Los contadores o los especialistas en marketing están familiarizados con este tipo de problemas. Trabajan con tablas en Microsoft Excel o Google Sheets. + +En esta lección, veremos cómo se aplica la agregación a los números y las cadenas de texto. + +Supongamos que necesitamos encontrar la suma de un conjunto de números. Implementaremos una función que sume los números en un rango especificado, incluyendo los límites. Un **rango** es una serie de números desde un punto de inicio hasta un punto final específicos. Por ejemplo, el rango [1, 10] incluye todos los números enteros del uno al diez. + +Ejemplo: + +```python +sum_numbers_from_range(5, 7) # 5 + 6 + 7 = 18 +sum_numbers_from_range(1, 2) # 1 + 2 = 3 + +# [1, 1] es un rango con el mismo inicio y fin, también es un rango +# Incluye un solo número, que es el límite del rango +sum_numbers_from_range(1, 1) # 1 +sum_numbers_from_range(100, 100) # 100 +``` + +Para implementar este código, necesitaremos un bucle, ya que la suma de números es un proceso iterativo, es decir, se repite para cada número. El número de iteraciones depende del tamaño del rango. + +Echa un vistazo al siguiente código: + +```python +def sum_numbers_from_range(start, finish): + # Técnicamente, se puede cambiar el valor de inicio + # Pero los argumentos de entrada deben mantenerse en su valor original + # Esto hace que el código sea más fácil de analizar + i = start + sum = 0 # Inicialización de la suma + while i <= end: # Avanzamos hasta el final del rango + suma = sum + i # Calculamos la suma para cada número + i = i + 1 # Pasamos al siguiente número en el rango + # Devolvemos el resultado obtenido + return sum +``` + +https://replit.com/@hexlet/python-basics-loops-aggregation-numbers + +La estructura del bucle es estándar: hay un contador que se inicializa con el valor inicial del rango, un bucle con una condición de finalización cuando se alcanza el final del rango y una modificación del contador al final del cuerpo del bucle. El número de iteraciones en este tipo de bucle es igual a `fin - inicio + 1`. Para el rango [5, 7], esto es 7 - 5 + 1, es decir, tres iteraciones. + +Las principales diferencias con el procesamiento normal son la lógica de cálculo del resultado. En los problemas de agregación, siempre hay una variable que almacena el resultado del bucle. En el código anterior, esta variable es `suma`. Se modifica en cada iteración del bucle, sumando el siguiente número del rango: `suma = suma + i`. + +Este proceso se ve así: + +```python +# para la llamada y ejecución sum_numbers_from_range(2, 5) +sum = 0 +sum = sum + 2 # 2 +sum = sum + 3 # 5 +sum = sum + 4 # 9 +sum = sum + 5 # 14 +# 14 es el resultado de sumar los números en el rango [2, 5] +``` + +La variable `sum` tiene un valor inicial, desde el cual comienza cualquier operación repetitiva. En el ejemplo anterior, ese valor es `0`. + +En matemáticas, hay un concepto de **elemento neutro** y cada operación tiene el suyo. La operación con este elemento no cambia el valor con el que se está trabajando. Por ejemplo, en la suma, cualquier número más cero es igual al número original. Lo mismo ocurre con la resta. La concatenación también tiene un elemento neutro, que es la cadena vacía: `'' + 'one'` será 'one'. diff --git a/modules/50-loops/20-aggregation-numbers/es/data.yml b/modules/50-loops/20-aggregation-numbers/es/data.yml new file mode 100644 index 00000000..867bbadb --- /dev/null +++ b/modules/50-loops/20-aggregation-numbers/es/data.yml @@ -0,0 +1,9 @@ +name: Agregación de datos (Números) +tips: + - | + [Iteración](https://es.wikipedia.org/wiki/Iteración) +definitions: + - name: Agregación + description: >- + Acumulación del resultado durante las iteraciones y trabajo con él después + del bucle. diff --git a/modules/50-loops/20-aggregation-numbers/ru/EXERCISE.md b/modules/50-loops/20-aggregation-numbers/ru/EXERCISE.md new file mode 100644 index 00000000..a140b17d --- /dev/null +++ b/modules/50-loops/20-aggregation-numbers/ru/EXERCISE.md @@ -0,0 +1,8 @@ + +Реализуйте функцию `multiply_numbers_from_range()`, которая принимает два числа, границы диапазона, и перемножает числа в нем, включая границы диапазона. Пример вызова: + +```python +multiply_numbers_from_range(1, 5) # 1 * 2 * 3 * 4 * 5 = 120 +multiply_numbers_from_range(2, 3) # 2 * 3 = 6 +multiply_numbers_from_range(6, 6) # 6 +``` diff --git a/modules/50-loops/20-aggregation-numbers/ru/README.md b/modules/50-loops/20-aggregation-numbers/ru/README.md new file mode 100644 index 00000000..3430c8c9 --- /dev/null +++ b/modules/50-loops/20-aggregation-numbers/ru/README.md @@ -0,0 +1,60 @@ + +Отдельный класс задач, который не обходится без циклов, называется **агрегированием данных**. К таким задачам относятся: поиск максимального или минимального значения, суммы, среднего арифметического. В их случае результат зависит от всего набора данных. + +Чтобы рассчитать сумму, нужно сложить все числа, а чтобы вычислить максимальное, нужно их сравнить. С такими задачами хорошо знакомы бухгалтеры или маркетологи. Они работают в таблицах Microsoft Excel или Google Tables. + +В этом уроке разберем, как агрегация применяется к числам и строкам. + +Допустим, нам нужно найти суммы набора чисел. Реализуем функцию, которая складывает числа в указанном диапазоне, включая границы. **Диапазон** — ряд чисел от конкретного начала до определенного конца. Например, диапазон [1, 10] включает целые числа от одного до десяти. + +Пример: + +```python +sum_numbers_from_range(5, 7) # 5 + 6 + 7 = 18 +sum_numbers_from_range(1, 2) # 1 + 2 = 3 + +# [1, 1] диапазон с одинаковым началом и концом — тоже диапазон +# Он включает одно число — саму границу диапазона +sum_numbers_from_range(1, 1) # 1 +sum_numbers_from_range(100, 100) # 100 +``` + +Чтобы реализовать такой код, понадобится цикл, так как сложение чисел — это итеративный процесс, то есть повторяется для каждого числа. Количество итераций зависит от размера диапазона. + +Посмотрите код ниже: + +```python +def sum_numbers_from_range(start, finish): + # Технически можно менять start + # Но входные аргументы нужно оставлять в исходном значении + # Это сделает код проще для анализа + i = start + sum = 0 # Инициализация суммы + while i <= finish: # Двигаемся до конца диапазона + sum = sum + i # Считаем сумму для каждого числа + i = i + 1 # Переходим к следующему числу в диапазоне + # Возвращаем получившийся результат + return sum +``` + +https://replit.com/@hexlet/python-basics-loops-aggregation-numbers + +Структура цикла здесь стандартная: есть счетчик, который инициализируется начальным значением диапазона, цикл с условием остановки при достижении конца диапазона и изменение счетчика в конце тела цикла. Количество итераций в таком цикле равно `finish - start + 1`. Для диапазона [5, 7] — это 7 - 5 + 1, то есть три итерации. + +Главные отличия от обычной обработки — логика вычислений результата. В задачах на агрегацию всегда есть переменная, которая хранит внутри себя результат работы цикла. В коде выше это `sum`. Она изменяется на каждой итерации цикла — прибавляется следующее число в диапазоне: `sum = sum + i`. + +Этот процесс выглядит так: + +```python +# Для вызова sum_numbers_from_range(2, 5) +sum = 0 +sum = sum + 2 # 2 +sum = sum + 3 # 5 +sum = sum + 4 # 9 +sum = sum + 5 # 14 +# 14 – результат сложения чисел в диапазоне [2, 5] +``` + +У переменной `sum` есть начальное значение — с него начинается любая повторяющаяся операция. В примере выше — это `0`. + +В математике есть понятие **нейтральный элемент**, и у каждой операции он свой. Операция с этим элементом не изменяет то значение, над которым работает. Например, в сложении любое число плюс ноль дает само число. При вычитании — то же самое. У конкатенации тоже есть нейтральный элемент — это пустая строка: `'' + 'one'` будет 'one'. diff --git a/modules/50-loops/20-aggregation-numbers/ru/data.yml b/modules/50-loops/20-aggregation-numbers/ru/data.yml new file mode 100644 index 00000000..eafd735e --- /dev/null +++ b/modules/50-loops/20-aggregation-numbers/ru/data.yml @@ -0,0 +1,7 @@ +name: Агрегация данных (Числа) +tips: + - | + [Итерация](https://ru.wikipedia.org/wiki/Итерация_(программирование)) +definitions: + - name: Агрегация + description: Накопление результата во время итераций и работа с ним после цикла. diff --git a/modules/50-loops/23-aggregation-strings/en/EXERCISE.md b/modules/50-loops/23-aggregation-strings/en/EXERCISE.md new file mode 100644 index 00000000..1488af00 --- /dev/null +++ b/modules/50-loops/23-aggregation-strings/en/EXERCISE.md @@ -0,0 +1,8 @@ + +Implement a function called `join_numbers_from_range()` that combines all the numbers from a range into a string: + +```python +join_numbers_from_range(1, 1) # '1' +join_numbers_from_range(2, 3) # '23' +join_numbers_from_range(5, 10) # '5678910' +``` diff --git a/modules/50-loops/23-aggregation-strings/en/README.md b/modules/50-loops/23-aggregation-strings/en/README.md new file mode 100644 index 00000000..f3a0c2ff --- /dev/null +++ b/modules/50-loops/23-aggregation-strings/en/README.md @@ -0,0 +1,34 @@ + +Like with number aggregation, string aggregation involves not knowing what the strings contain and how big they are. + +Imagine a function that knows how to multiply a string; it repeats it a specified number of times: + +```python +repeat('hexlet', 3) # 'hexlethexlethexlet' +``` + +The principle of how this function works is that in the loop, the string is “incremented” a specified number of times: + +```python +def repeat(text, times): + # The neutral element for strings is an empty string + result = '' + i = 1 + + while i <= times: + # Each time we add the string to the result + result = result + text + i = i + 1 + + return result +``` + +Let's break down the code's execution into steps: + +```python +# To call repeat('hexlet', 3) +result = '' +result = result + 'hexlet' # hexlet +result = result + 'hexlet' # hexlethexlet +result = result + 'hexlet' # hexlethexlethexlet +``` diff --git a/modules/50-loops/23-aggregation-strings/en/data.yml b/modules/50-loops/23-aggregation-strings/en/data.yml new file mode 100644 index 00000000..bf8c0294 --- /dev/null +++ b/modules/50-loops/23-aggregation-strings/en/data.yml @@ -0,0 +1,2 @@ +name: Data Aggregation (Strings) +tips: [] diff --git a/modules/50-loops/23-aggregation-strings/es/EXERCISE.md b/modules/50-loops/23-aggregation-strings/es/EXERCISE.md new file mode 100644 index 00000000..1e30d9b0 --- /dev/null +++ b/modules/50-loops/23-aggregation-strings/es/EXERCISE.md @@ -0,0 +1,8 @@ + +Implementa la función `join_numbers_from_range()`, que une todos los números de un rango en una cadena: + +```python +join_numbers_from_range(1, 1) # '1' +join_numbers_from_range(2, 3) # '23' +join_numbers_from_range(5, 10) # '5678910' +``` diff --git a/modules/50-loops/23-aggregation-strings/es/README.md b/modules/50-loops/23-aggregation-strings/es/README.md new file mode 100644 index 00000000..9bf0365c --- /dev/null +++ b/modules/50-loops/23-aggregation-strings/es/README.md @@ -0,0 +1,36 @@ + +La agregación de cadenas es cuando no se sabe de antemano qué contienen las cadenas y cuál es su tamaño. + +Imagina una función que pueda multiplicar una cadena, repitiéndola un número fijo o determinado de veces: + +```python +repeat('hexlet', 3) # 'hexlethexlethexlet' +``` + +El principio de funcionamiento de esta función es que en un bucle se va "acumulando" la cadena un número determinado de veces: + +```python +def repeat(text, times): + # El elemento neutro para las cadenas es una cadena vacía + result = '' + i = 1 + + while i <= times: + # En cada iteración, se agrega la cadena al resultado + result = result + text + i = i + 1 + + return result +``` + +https://replit.com/@hexlet/python-basics-loops-aggregation-strings + +Veamos cómo se ejecuta este código paso a paso: + +```python +# Para llamar a repeat('hexlet', 3) +result = '' +result = result + 'hexlet' # hexlet +result = result + 'hexlet' # hexlethexlet +result = result + 'hexlet' # hexlethexlethexlet +``` diff --git a/modules/50-loops/23-aggregation-strings/es/data.yml b/modules/50-loops/23-aggregation-strings/es/data.yml new file mode 100644 index 00000000..efde9106 --- /dev/null +++ b/modules/50-loops/23-aggregation-strings/es/data.yml @@ -0,0 +1,9 @@ +name: Agregación de datos (Cadenas) +tips: + - | + [Iteración](https://es.wikipedia.org/wiki/Iteraci%C3%B3n) +definitions: + - name: Agregación + description: >- + Acumulación de resultados durante las iteraciones y manejo de estos + después del bucle. diff --git a/modules/50-loops/23-aggregation-strings/ru/EXERCISE.md b/modules/50-loops/23-aggregation-strings/ru/EXERCISE.md new file mode 100644 index 00000000..b0eeb2b7 --- /dev/null +++ b/modules/50-loops/23-aggregation-strings/ru/EXERCISE.md @@ -0,0 +1,8 @@ + +Реализуйте функцию `join_numbers_from_range()`, которая объединяет все числа из переданного диапазона в строку: + +```python +join_numbers_from_range(1, 1) # '1' +join_numbers_from_range(2, 3) # '23' +join_numbers_from_range(5, 10) # '5678910' +``` diff --git a/modules/50-loops/23-aggregation-strings/ru/README.md b/modules/50-loops/23-aggregation-strings/ru/README.md new file mode 100644 index 00000000..be61f385 --- /dev/null +++ b/modules/50-loops/23-aggregation-strings/ru/README.md @@ -0,0 +1,36 @@ + +Агрегация строк — это такие задачи, в которых заранее неизвестно, что содержат строки и какой у них размер. + +Представьте функцию, которая умеет умножать строку — повторяет ее указанное количество раз: + +```python +repeat('hexlet', 3) # 'hexlethexlethexlet' +``` + +Принцип работы этой функции — в цикле происходит «наращивание» строки указанное количество раз: + +```python +def repeat(text, times): + # Нейтральный элемент для строк — пустая строка + result = '' + i = 1 + + while i <= times: + # Каждый раз добавляем строку к результату + result = result + text + i = i + 1 + + return result +``` + +https://replit.com/@hexlet/python-basics-loops-aggregation-strings + +Распишем выполнение этого кода по шагам: + +```python +# Для вызова repeat('hexlet', 3) +result = '' +result = result + 'hexlet' # hexlet +result = result + 'hexlet' # hexlethexlet +result = result + 'hexlet' # hexlethexlethexlet +``` diff --git a/modules/50-loops/23-aggregation-strings/ru/data.yml b/modules/50-loops/23-aggregation-strings/ru/data.yml new file mode 100644 index 00000000..aca9f42d --- /dev/null +++ b/modules/50-loops/23-aggregation-strings/ru/data.yml @@ -0,0 +1,7 @@ +name: Агрегация данных (Строки) +tips: + - | + [Итерация](https://ru.wikipedia.org/wiki/Итерация_(программирование)) +definitions: + - name: Агрегация + description: Накопление результата во время итераций и работа с ним после цикла. diff --git a/modules/50-loops/25-iteration-over-string/en/EXERCISE.md b/modules/50-loops/25-iteration-over-string/en/EXERCISE.md new file mode 100644 index 00000000..c71c5394 --- /dev/null +++ b/modules/50-loops/25-iteration-over-string/en/EXERCISE.md @@ -0,0 +1,14 @@ + +Implement a function called `print_reversed_word_by_symbol()` that prints a word passed to it character by character, as in the example from the theory, but in reverse order. + +```python +word = 'Hexlet' + +print_reversed_word_by_symbol(word) +# => 't' +# => 'e' +# => 'l' +# => 'x' +# => 'e' +# => 'H' +``` diff --git a/modules/50-loops/25-iteration-over-string/en/README.md b/modules/50-loops/25-iteration-over-string/en/README.md new file mode 100644 index 00000000..5648d03c --- /dev/null +++ b/modules/50-loops/25-iteration-over-string/en/README.md @@ -0,0 +1,24 @@ + +Loops are used to work with strings as well as numbers. For example, you can get a specific character by its index, and also form strings in loops. + +Below is some sample code that prints the letters of each word on a separate line: + +```python +def print_name_by_symbol(name): + i = 0 + # This check will run until the end of the string, + # including the last character. Its index is `length - 1`. + while i < len(name): + # Accessing the symbol by its index + print(name[i]) + i += 1 + +name = 'Arya' +print_name_by_symbol(name) +# => 'A' +# => 'r' +# => 'y' +# => 'a' +``` + +The main thing in this code is to put the proper condition in `while`. This can be done in two ways: `i < len(name)` or `i <= len(name) - 1` - they'll both give the same result. diff --git a/modules/50-loops/25-iteration-over-string/en/data.yml b/modules/50-loops/25-iteration-over-string/en/data.yml new file mode 100644 index 00000000..0874d4f4 --- /dev/null +++ b/modules/50-loops/25-iteration-over-string/en/data.yml @@ -0,0 +1,2 @@ +name: Traversing Strings +tips: [] diff --git a/modules/50-loops/25-iteration-over-string/es/EXERCISE.md b/modules/50-loops/25-iteration-over-string/es/EXERCISE.md new file mode 100644 index 00000000..ed69e52c --- /dev/null +++ b/modules/50-loops/25-iteration-over-string/es/EXERCISE.md @@ -0,0 +1,14 @@ + +Implementa la función `print_reversed_word_by_symbol()`, que imprime la palabra pasada como argumento carácter por carácter, como se muestra en el ejemplo de la teoría, pero en orden inverso. + +```python +word = 'Hexlet' + +print_reversed_word_by_symbol(word) +# => 't' +# => 'e' +# => 'l' +# => 'x' +# => 'e' +# => 'H' +``` diff --git a/modules/50-loops/25-iteration-over-string/es/README.md b/modules/50-loops/25-iteration-over-string/es/README.md new file mode 100644 index 00000000..a2cfd26d --- /dev/null +++ b/modules/50-loops/25-iteration-over-string/es/README.md @@ -0,0 +1,26 @@ + +Con la ayuda de los bucles, no sólo se pueden procesar números, sino también cadenas de texto. Por ejemplo, se puede obtener un carácter específico por su índice, así como formar cadenas de texto en bucles. + +A continuación se muestra un ejemplo de código que imprime las letras de cada palabra en una línea separada: + +```python +def print_name_by_symbol(name): + i = 0 + # Esta condición se cumplirá hasta el final de la cadena, + # incluyendo el último carácter. Su índice es `length - 1`. + while i < len(name): + # Accedemos al carácter por su índice + print(name[i]) + i = i + 1 + +name = 'Arya' +print_name_by_symbol(name) +# => 'A' +# => 'r' +# => 'y' +# => 'a' +``` + +https://replit.com/@hexlet/python-basics-loops-iteration-over-string + +Lo más importante en este código es establecer la condición correcta en `while`. Esto se puede hacer de dos formas: `i < len(name)` o `i <= len(name) - 1` - ambas conducirán al mismo resultado. diff --git a/modules/50-loops/25-iteration-over-string/es/data.yml b/modules/50-loops/25-iteration-over-string/es/data.yml new file mode 100644 index 00000000..dae80b6c --- /dev/null +++ b/modules/50-loops/25-iteration-over-string/es/data.yml @@ -0,0 +1,4 @@ +name: Recorrido de cadenas +tips: + - | + [Iteración](https://es.wikipedia.org/wiki/Iteración) diff --git a/modules/50-loops/25-iteration-over-string/ru/EXERCISE.md b/modules/50-loops/25-iteration-over-string/ru/EXERCISE.md new file mode 100644 index 00000000..6df1ba19 --- /dev/null +++ b/modules/50-loops/25-iteration-over-string/ru/EXERCISE.md @@ -0,0 +1,14 @@ + +Реализуйте функцию `print_reversed_word_by_symbol()`, которая печатает переданное слово посимвольно, как в примере из теории, но делает это в обратном порядке. + +```python +word = 'Hexlet' + +print_reversed_word_by_symbol(word) +# => 't' +# => 'e' +# => 'l' +# => 'x' +# => 'e' +# => 'H' +``` diff --git a/modules/50-loops/25-iteration-over-string/ru/README.md b/modules/50-loops/25-iteration-over-string/ru/README.md new file mode 100644 index 00000000..821e4092 --- /dev/null +++ b/modules/50-loops/25-iteration-over-string/ru/README.md @@ -0,0 +1,26 @@ + +С помощью циклов не только обрабатывают числа, но работают и со строками. Например, можно получить конкретный символ по его индексу, а также формировать строки в циклах. + +Ниже пример кода, который печатает буквы каждого слова на отдельной строке: + +```python +def print_name_by_symbol(name): + i = 0 + # Такая проверка будет выполняться до конца строки, + # включая последний символ. Его индекс `length - 1`. + while i < len(name): + # Обращаемся к символу по индексу + print(name[i]) + i = i + 1 + +name = 'Arya' +print_name_by_symbol(name) +# => 'A' +# => 'r' +# => 'y' +# => 'a' +``` + +https://replit.com/@hexlet/python-basics-loops-iteration-over-string + +Главное в этом коде — поставить правильное условие в `while`. Это можно сделать двумя способами: `i < len(name)` или `i <= len(name) - 1` — они приведут к одному результату. diff --git a/modules/50-loops/25-iteration-over-string/ru/data.yml b/modules/50-loops/25-iteration-over-string/ru/data.yml new file mode 100644 index 00000000..70738d54 --- /dev/null +++ b/modules/50-loops/25-iteration-over-string/ru/data.yml @@ -0,0 +1,4 @@ +name: Обход строк +tips: + - | + [Итерация](https://ru.wikipedia.org/wiki/Итерация_(программирование)) diff --git a/modules/50-loops/26-conditions-inside-loops/en/EXERCISE.md b/modules/50-loops/26-conditions-inside-loops/en/EXERCISE.md new file mode 100644 index 00000000..ac8619b2 --- /dev/null +++ b/modules/50-loops/26-conditions-inside-loops/en/EXERCISE.md @@ -0,0 +1,7 @@ + +The function from the theory is case-sensitive. I.e., `A' and `a' are different characters from its point of view. Write a version of this function that isn't case-sensitive: + +```python +count_chars('HexlEt', 'e') # 2 +count_chars('HexlEt', 'E') # 2 +``` diff --git a/modules/50-loops/26-conditions-inside-loops/en/README.md b/modules/50-loops/26-conditions-inside-loops/en/README.md new file mode 100644 index 00000000..d1c3c9fa --- /dev/null +++ b/modules/50-loops/26-conditions-inside-loops/en/README.md @@ -0,0 +1,32 @@ + +You can execute instructions in the bodies of loops like you can in functions. This means you can use everything you learned before inside loops, such as conditional constructions. + +Imagine a function that counts how many times a letter occurs in a sentence. Example of how it works: + +```python +count_chars('Fear cuts deeper than swords.', 'e') # 4 +# If nothing is found, the result is 0 matches +count_chars('Sansa', 'y') # 0 +``` + +Before you look at the contents of a function, think about this: + +* Is this an aggregation operation? +* How will it check if a character occurs in a sentence? + +```python +def count_chars(string, char): + index = 0 + count = 0 + while index < len(string): + if string[index] == char: + # We only count the matching characters + count = count + 1 + # The counter is incremented anyway + index = index + 1 + return count +``` + +This is an aggregation task. Although it doesn't count all the characters to calculate the amount, you still have to analyze each character. The key difference between this loop and the ones we looked at before is that there's a condition inside the body. + +The `count` variable is incremented only when the character in question is the same as the expected one. Otherwise, it's a typical aggregate function that returns the number of characters you want. diff --git a/modules/50-loops/26-conditions-inside-loops/en/data.yml b/modules/50-loops/26-conditions-inside-loops/en/data.yml new file mode 100644 index 00000000..77a1dd6d --- /dev/null +++ b/modules/50-loops/26-conditions-inside-loops/en/data.yml @@ -0,0 +1,2 @@ +name: Conditions Inside the Body of the Loop +tips: [] diff --git a/modules/50-loops/26-conditions-inside-loops/es/EXERCISE.md b/modules/50-loops/26-conditions-inside-loops/es/EXERCISE.md new file mode 100644 index 00000000..230ce826 --- /dev/null +++ b/modules/50-loops/26-conditions-inside-loops/es/EXERCISE.md @@ -0,0 +1,7 @@ + +La función de la teoría tiene en cuenta el caso de las letras. Es decir, `A` y `a` son considerados caracteres diferentes. Implementa una versión de esta misma función en la que no importe el caso de las letras: + +```python +count_chars('HexlEt', 'e') # 2 +count_chars('HexlEt', 'E') # 2 +``` diff --git a/modules/50-loops/26-conditions-inside-loops/es/README.md b/modules/50-loops/26-conditions-inside-loops/es/README.md new file mode 100644 index 00000000..f0a64c43 --- /dev/null +++ b/modules/50-loops/26-conditions-inside-loops/es/README.md @@ -0,0 +1,34 @@ + +Dentro de un bucle, al igual que dentro de una función, se pueden ejecutar instrucciones. Por lo tanto, dentro de un bucle se puede utilizar todo lo aprendido anteriormente, como por ejemplo, estructuras condicionales. + +Imagina una función que cuenta cuántas veces aparece una letra en una oración. Aquí tienes un ejemplo de cómo funcion un bucle de esta forma: + +```python +count_chars('El miedo corta más profundo que las espadas.', 'e') # 4 +# Si no se encuentra ninguna coincidencia, el resultado es 0 +count_chars('Sansa', 'y') # 0 +``` + +Antes de ver el contenido de la función, piensa en lo siguiente: + +* ¿Es esta operación una agregación? +* ¿Cuál será la condición para verificar la aparición de un carácter? + +```python +def count_chars(string, char): + index = 0 + count = 0 + while index < len(string): + if string[index] == char: + # Solamente contamos los caracteres que coinciden + count = count + 1 + # El contador se incrementa en cualquier caso + index = index + 1 + return count +``` + +https://replit.com/@hexlet/python-basics-loops-conditions-inside-loops + +Esta es una tarea de agregación. Aunque no cuenta todos los caracteres para calcular la suma, es necesario analizar cada carácter. La diferencia clave de este bucle con los que se han visto anteriormente es que contiene una condición en su cuerpo. + +La variable `count` solo se incrementa cuando el carácter actual coincide con el carácter esperado. De lo contrario, esta función es típicamente una función agregada que devuelve la cantidad de caracteres necesarios. diff --git a/modules/50-loops/26-conditions-inside-loops/es/data.yml b/modules/50-loops/26-conditions-inside-loops/es/data.yml new file mode 100644 index 00000000..acbcd652 --- /dev/null +++ b/modules/50-loops/26-conditions-inside-loops/es/data.yml @@ -0,0 +1,2 @@ +name: Condiciones dentro de un bucle +tips: [] diff --git a/modules/50-loops/26-conditions-inside-loops/ru/EXERCISE.md b/modules/50-loops/26-conditions-inside-loops/ru/EXERCISE.md new file mode 100644 index 00000000..9c7b3924 --- /dev/null +++ b/modules/50-loops/26-conditions-inside-loops/ru/EXERCISE.md @@ -0,0 +1,7 @@ + +Функция из теории учитывает регистр букв. То есть `A` и `a` с её точки зрения разные символы. Реализуйте вариант этой же функции, так чтобы регистр букв был не важен: + +```python +count_chars('HexlEt', 'e') # 2 +count_chars('HexlEt', 'E') # 2 +``` diff --git a/modules/50-loops/26-conditions-inside-loops/ru/README.md b/modules/50-loops/26-conditions-inside-loops/ru/README.md new file mode 100644 index 00000000..6095f457 --- /dev/null +++ b/modules/50-loops/26-conditions-inside-loops/ru/README.md @@ -0,0 +1,34 @@ + +В теле цикла, как и в теле функции, можно выполнять инструкции. Поэтому внутри цикла можно использовать всё изученное ранее, например — условные конструкции. + +Представьте функцию, которая считает, сколько раз входит буква в предложение. Пример ее работы: + +```python +count_chars('Fear cuts deeper than swords.', 'e') # 4 +# Если вы ничего не нашли, то результат — 0 совпадений +count_chars('Sansa', 'y') # 0 +``` + +Перед тем как посмотреть содержимое функции, подумайте: + +* Является ли эта операция агрегацией? +* Какой будет проверка на вхождение символа? + +```python +def count_chars(string, char): + index = 0 + count = 0 + while index < len(string): + if string[index] == char: + # Считаем только подходящие символы + count = count + 1 + # Счетчик увеличивается в любом случае + index = index + 1 + return count +``` + +https://replit.com/@hexlet/python-basics-loops-conditions-inside-loops + +Это агрегирующая задача. Несмотря на то, что она считает не все символы, чтобы подсчитать сумму, приходится анализировать каждый символ. Ключевое отличие этого цикла от рассмотренных — внутри тела есть условие. + +Переменная `count` увеличивается только в том случае, когда рассматриваемый символ совпадает с ожидаемым. В остальном — это типичная агрегатная функция, которая возвращает количество нужных символов. diff --git a/modules/50-loops/26-conditions-inside-loops/ru/data.yml b/modules/50-loops/26-conditions-inside-loops/ru/data.yml new file mode 100644 index 00000000..20450e80 --- /dev/null +++ b/modules/50-loops/26-conditions-inside-loops/ru/data.yml @@ -0,0 +1,2 @@ +name: Условия внутри тела цикла +tips: [] diff --git a/modules/50-loops/28-build-string/en/EXERCISE.md b/modules/50-loops/28-build-string/en/EXERCISE.md new file mode 100644 index 00000000..9556f048 --- /dev/null +++ b/modules/50-loops/28-build-string/en/EXERCISE.md @@ -0,0 +1,14 @@ + +Implement a function called `my_substr()` that extracts a substring of a specified length from a string. It takes two arguments as input: a string and a length, and returns a substring starting from the first character: + +Call example: + +```python +string = 'If I look back I am lost' +print(my_substr(string, 1)) # => 'I' +print(my_substr(string, 7)) # => 'If I lo' +``` + +Use the same approach as in the function to flip the string from the lesson: assemble the resulting string with a loop by looping over the initial string to a certain point. + +This problem can be solved using slicing. But in this exercise, we want to practice using loops, so we'll implement this functionality ourselves. Slice syntax essentially uses loops anyway. diff --git a/modules/50-loops/28-build-string/en/README.md b/modules/50-loops/28-build-string/en/README.md new file mode 100644 index 00000000..b6eb50e1 --- /dev/null +++ b/modules/50-loops/28-build-string/en/README.md @@ -0,0 +1,45 @@ + +You can also use loops to form strings. This is often needed during web programming. It all comes down to the usual aggregation when interpolation or concatenation is applied. + +You'll often be asked to write a program to reverse a string in interviews. The correct way to flip a string is to use a function from the standard library. But it's important to know how to actually implement it yourself. + +One of the algorithms looks like this: + +1. Build a new string + +2. Go through the characters of the original string in reverse order + +```python +def reverse_string(string): + index = len(string) - 1 + reversed_string = '' + + while index >= 0: + current_char = string[index] + reversed_string = reversed_string + current_char + # The same through interpolation + # reversed_string = f'{reversed_string}{current_char}' + index = index - 1 + + return reversed_string + +reverse_string('Game Of Thrones') # 'senorhT fO emaG' +# Neutral element check +reverse_string('') # '' +``` + +Let's analyze the function line by line: + +* `index = len(string) - 1` - we write the index of the last character of the string into a new variable (remember indexes start with zero) +* `reversed_string = ''` - initialize the string that we'll write the result to +* `while index >= 0:` - condition: repeat the body of the loop until the current index reaches `0` - (the first character) +* `current_char = string[index]` - take the character at the current index from the string +* `reversed_string = reversed_string + current_char` - write the new value to the string with the result: current string is the result + the new character +* `index = index - 1` - update the counter +* `return reversed_string` - when the loop is done, return the result string + +We advise you to copy this function into the REPL [https://replit.com/languages/python3](https://replit.com/languages/python3) and experiment with it a little. + +When working with strings, programmers often make the mistake of going past string boundaries. If a wrong initial counter value is chosen or a mistake is made in a loop predicate, the function may access a character that doesn't exist. + +It's also extremely often forgotten that the index of the last element is always one less than the size of the string. In strings, the initial index is `0`, so the index of the last element is `len(str) - 1`. diff --git a/modules/50-loops/28-build-string/en/data.yml b/modules/50-loops/28-build-string/en/data.yml new file mode 100644 index 00000000..3b4493aa --- /dev/null +++ b/modules/50-loops/28-build-string/en/data.yml @@ -0,0 +1,2 @@ +name: Forming Strings in Loops +tips: [] diff --git a/modules/50-loops/28-build-string/es/EXERCISE.md b/modules/50-loops/28-build-string/es/EXERCISE.md new file mode 100644 index 00000000..29463434 --- /dev/null +++ b/modules/50-loops/28-build-string/es/EXERCISE.md @@ -0,0 +1,14 @@ + +Implementa la función `my_substr()`, que extrae una subcadena de una cadena de longitud especificada. Recibe dos argumentos de entrada: la cadena y la longitud, y devuelve la subcadena comenzando desde el primer carácter: + +Ejemplo de llamada: + +```python +string = 'If I look back I am lost' +print(my_substr(string, 1)) # => 'I' +print(my_substr(string, 7)) # => 'If I lo' +``` + +Utiliza el mismo enfoque que en la función para invertir una cadena del tutorial: construye la cadena resultado en un bucle, recorriendo la cadena original hasta un punto determinado. + +Esta tarea se puede resolver utilizando listas (slices). Pero en este ejercicio queremos practicar el uso de bucles, por lo que implementaremos esta funcionalidad por nuestra cuenta. Es así como funcionan internamente las listas. diff --git a/modules/50-loops/28-build-string/es/README.md b/modules/50-loops/28-build-string/es/README.md new file mode 100644 index 00000000..7adb8949 --- /dev/null +++ b/modules/50-loops/28-build-string/es/README.md @@ -0,0 +1,45 @@ + +Los bucles también se pueden utilizar para formar cadenas. Este tipo de tarea es común en la programación web. Se reduce a una simple agregación, ya sea mediante interpolación o concatenación. + +La inversión de una cadena es un problema algorítmico que se plantea en las entrevistas. La forma correcta de invertir una cadena es utilizar una función de la biblioteca estándar. Sin embargo, es importante saber cómo implementarla. + +Uno de los algoritmos se ve así: + +1. Construimos una nueva cadena. + +2. Recorremos los caracteres de la cadena original en orden inverso. + +```python +def reverse_string(string): + index = len(string) - 1 + reversed_string = '' + + while index >= 0: + current_char = string[index] + reversed_string = reversed_string + current_char + # Lo mismo ocurre usando la interpolación + # reversed_string = f'{reversed_string}{current_char}' + index = index - 1 + + return reversed_string + +reverse_string('Game Of Thrones') # 'senorhT fO emaG' +# Comprobación del elemento neutro +reverse_string('') # '' +``` + +Vamos a analizar la función línea por línea: + +* `index = len(string) - 1` — guardamos en una nueva variable el índice del último carácter de la cadena (los índices comienzan en cero). +* `reversed_string = ''` — inicializamos una cadena donde se guardará el resultado. +* `while index >= 0:` — condición: repetimos el cuerpo del bucle mientras el índice actual no llegue a `0`, es decir, hasta el primer carácter. +* `current_char = string[index]` — tomamos el carácter de la cadena según el índice actual. +* `reversed_string = reversed_string + current_char` — añadimos al resultado el nuevo valor: la cadena resultado actual más el nuevo carácter. +* `index = index - 1` — actualizamos el contador. +* `return reversed_string` — cuando el bucle termina, devolvemos la cadena resultado. + +Recomendamos copiar esta función en [https://replit.com/languages/python3](https://replit.com/languages/python3) y experimentar con ella. + +Al trabajar con cadenas, los programadores a menudo cometen un error: salirse de los límites de la cadena. Si el valor inicial del contador no se elige correctamente o se comete un error en el predicado del bucle, la función puede acceder a un carácter inexistente. + +A menudo se olvida que el índice del último elemento siempre es menor en uno que el tamaño de la cadena. En las cadenas, el índice inicial es `0`, lo que significa que el índice del último elemento es `len(str) - 1`. diff --git a/modules/50-loops/28-build-string/es/data.yml b/modules/50-loops/28-build-string/es/data.yml new file mode 100644 index 00000000..f4068321 --- /dev/null +++ b/modules/50-loops/28-build-string/es/data.yml @@ -0,0 +1,4 @@ +name: Formación de cadenas en bucles +tips: + - | + [Iteración](https://es.wikipedia.org/wiki/Iteraci%C3%B3n) diff --git a/modules/50-loops/28-build-string/ru/EXERCISE.md b/modules/50-loops/28-build-string/ru/EXERCISE.md new file mode 100644 index 00000000..02a0bd18 --- /dev/null +++ b/modules/50-loops/28-build-string/ru/EXERCISE.md @@ -0,0 +1,14 @@ + +Реализуйте функцию `my_substr()`, которая извлекает из переданной строки подстроку указанной длины. Она принимает на вход два аргумента: строку и длину, и возвращает подстроку, начиная с первого символа: + +Пример вызова: + +```python +string = 'If I look back I am lost' +print(my_substr(string, 1)) # => 'I' +print(my_substr(string, 7)) # => 'If I lo' +``` + +Используйте тот же подход, что в функции для переворота строки из урока: собирайте строку-результат в цикле, перебирая начальную строку до определённого момента. + +Эту задачу можно решить при помощи слайсов. Но в этом упражнении мы хотим потренироваться в использовании циклов и поэтому реализуем эту функциональность самостоятельно. Именно так внутри и работают слайсы. diff --git a/modules/50-loops/28-build-string/ru/README.md b/modules/50-loops/28-build-string/ru/README.md new file mode 100644 index 00000000..22820ca5 --- /dev/null +++ b/modules/50-loops/28-build-string/ru/README.md @@ -0,0 +1,45 @@ + +Еще циклы можно использовать, чтобы формировать строки. Подобная задача часто встречается в веб-программировании. Она сводится к обычной агрегации, когда применяется интерполяция или конкатенация. + +Переворот строки — алгоритмическая задача, которую задают на собеседованиях. Правильный способ перевернуть строку — использовать функцию из стандартной библиотеки. Но важно знать, как ее реализовать. + +Один из алгоритмов выглядит так: + +1. Строим новую строку + +2. Перебираем символы исходной строки в обратном порядке + +```python +def reverse_string(string): + index = len(string) - 1 + reversed_string = '' + + while index >= 0: + current_char = string[index] + reversed_string = reversed_string + current_char + # То же самое через интерполяцию + # reversed_string = f'{reversed_string}{current_char}' + index = index - 1 + + return reversed_string + +reverse_string('Game Of Thrones') # 'senorhT fO emaG' +# Проверка нейтрального элемента +reverse_string('') # '' +``` + +Разберем функцию построчно: + +* `index = len(string) - 1` — записываем в новую переменную индекс последнего символа строки (индексы начинаются с нуля) +* `reversed_string = ''` — инициализируем строку, куда будем записывать результат +* `while index >= 0:` — условие: повторяем тело цикла, пока текущий индекс не дошел до `0` — до первого символа +* `current_char = string[index]` — берем из строки символ по текущему индексу +* `reversed_string = reversed_string + current_char` — записываем в строку-результат новое значение: текущая строка-результат + новый символ +* `index = index - 1` — обновляем счетчик +* `return reversed_string` — когда цикл завершился, возвращаем строку-результат + +Советуем скопировать эту функцию в [https://replit.com/languages/python3](https://replit.com/languages/python3) и поэкспериментировать с ней. + +Работая со строками, программисты часто допускают ошибку — выходят за границы строки. Если неправильно подобрать начальное значение счетчика или допустить ошибку в предикате цикла, функция может обращаться к несуществующему символу. + +Особенно часто забывают, что индекс последнего элемента всегда меньше на единицу размера строки. В строках начальный индекс равен `0`, значит, индекс последнего элемента — `len(str) - 1`. diff --git a/modules/50-loops/28-build-string/ru/data.yml b/modules/50-loops/28-build-string/ru/data.yml new file mode 100644 index 00000000..be855503 --- /dev/null +++ b/modules/50-loops/28-build-string/ru/data.yml @@ -0,0 +1,4 @@ +name: Формирование строк в циклах +tips: + - | + [Итерация](https://ru.wikipedia.org/wiki/Итерация_(программирование)) diff --git a/modules/50-loops/29-edge-cases/en/EXERCISE.md b/modules/50-loops/29-edge-cases/en/EXERCISE.md new file mode 100644 index 00000000..0f44357f --- /dev/null +++ b/modules/50-loops/29-edge-cases/en/EXERCISE.md @@ -0,0 +1,30 @@ + +Implement a predicate function called `is_arguments_for_substr_correct()` that takes three arguments: + +1. the string +2. the index from where the extraction will begin +3. the length of the substring to be extracted + +The function returns `False` if at least one of the conditions is true: + +* The extracted substring has a negative length +* The index given is negative +* The index given exceeds the boundary of the entire string +* The substring length together with the given index exceeds the boundary of the whole string + +Otherwise, the function returns `True`. + +Don't forget that indices start with `0`, so the index of the last element is “string length minus 1”. + +Call example: + +```python +string = 'Sansa Stark' +print(is_arguments_for_substr_correct(string, 2, -3)) # => False +print(is_arguments_for_substr_correct(string, -1, 3)) # => False +print(is_arguments_for_substr_correct(string, 4, 100)) # => False +print(is_arguments_for_substr_correct(string, 10, 10)) # => False +print(is_arguments_for_substr_correct(string, 11, 1)) # => False +print(is_arguments_for_substr_correct(string, 3, 3)) # => True +print(is_arguments_for_substr_correct(string, 0, 5)) # => True +``` diff --git a/modules/50-loops/29-edge-cases/en/README.md b/modules/50-loops/29-edge-cases/en/README.md new file mode 100644 index 00000000..ce2a5604 --- /dev/null +++ b/modules/50-loops/29-edge-cases/en/README.md @@ -0,0 +1,33 @@ + +The `my_substr()` function you implemented in the last lesson contains quite a few errors. It passed the test because it had no **edge cases**. The function worked with normal arguments. Now let's imagine we passed it these length options: + +* `0` +* Negative number +* A number that exceeds the actual size of the string + +The `my_substr()` function isn't designed for this. The code will run in different situations with different combinations of conditions and data. You can't be sure that the arguments passed to it will always be correct, so you have to consider all cases. + +Edge cases are a common cause of logic errors in programs. There's always something that programmers forget to take into account. These errors often don't manifest themselves immediately and may not lead to visible problems for a long time. + +The program may continue to work, but at some point someone might notice an error in the results. It can some time be a result of Python having dynamic typing. + +As you gain more experience, you'll learn to deal with these errors. + +Here's an extended version of the `my_substr()` function. It takes three arguments: a string, an index, and the length of the substring to be extracted. The function returns a substring of the specified length, starting from the index passed. Call examples: + +```python +string = 'If I look back I am lost' +print(my_substr(string, 0, 1)) # => 'I' +print(my_substr(string, 3, 6)) # => 'I look' +``` + +What **edge cases** to consider: + +* If the extracted substring has a negative length +* The index given is negative +* The index given exceeds the boundary of the entire string +* The substring length together with the given index exceeds the boundary of the whole string + +When the function is implemented, each edge case will be a separate piece of code. It'll most likely be implemented with `if`. + +If you want to write `my_substr()` in a way that's protected against these cases, it's worth implementing a separate function that the arguments are valid diff --git a/modules/50-loops/29-edge-cases/en/data.yml b/modules/50-loops/29-edge-cases/en/data.yml new file mode 100644 index 00000000..aded9f06 --- /dev/null +++ b/modules/50-loops/29-edge-cases/en/data.yml @@ -0,0 +1,2 @@ +name: Edge cases +tips: [] diff --git a/modules/50-loops/29-edge-cases/es/EXERCISE.md b/modules/50-loops/29-edge-cases/es/EXERCISE.md new file mode 100644 index 00000000..9dc4b120 --- /dev/null +++ b/modules/50-loops/29-edge-cases/es/EXERCISE.md @@ -0,0 +1,30 @@ + +Implementa la función predicado `is_arguments_for_substr_correct()`, que toma tres argumentos: + +1. Una cadena. +2. Un índice desde el cual comenzar la extracción. +3. La longitud de la subcadena a extraer. + +La función devuelve `False` si al menos una de las siguientes condiciones es verdadera: + +* La longitud de la subcadena a extraer es negativa. +* El índice especificado es negativo. +* El índice especificado está fuera de los límites de toda la cadena. +* La longitud de la subcadena, sumada al índice especificado, está fuera de los límites de toda la cadena. + +De lo contrario, la función devuelve `True`. + +No olvides que los índices comienzan en `0`, por lo que el índice del último elemento es "longitud de la cadena menos 1". + +Ejemplo de llamada: + +```python +string = 'Sansa Stark' +print(is_arguments_for_substr_correct(string, 2, -3)) # => False +print(is_arguments_for_substr_correct(string, -1, 3)) # => False +print(is_arguments_for_substr_correct(string, 4, 100)) # => False +print(is_arguments_for_substr_correct(string, 10, 10)) # => False +print(is_arguments_for_substr_correct(string, 11, 1)) # => False +print(is_arguments_for_substr_correct(string, 3, 3)) # => True +print(is_arguments_for_substr_correct(string, 0, 5)) # => True +``` diff --git a/modules/50-loops/29-edge-cases/es/README.md b/modules/50-loops/29-edge-cases/es/README.md new file mode 100644 index 00000000..4106ba67 --- /dev/null +++ b/modules/50-loops/29-edge-cases/es/README.md @@ -0,0 +1,33 @@ + +La función `my_substr()`, que implementaste en la lección anterior, contiene muchos errores. Pasó la prueba porque no había **casos límite**. La función funcionaba con argumentos normales. Pero ahora imaginemos que se le pasan estas longitudes: + +* `0` +* Un número negativo +* Un número que excede la longitud real de la cadena + +La función `my_substr()` no está preparada para estos casos. El código se ejecutará en diferentes situaciones, con diferentes combinaciones de condiciones y datos. No se puede estar seguro de que los argumentos siempre serán correctos, por lo que es necesario tener en cuenta todos los casos. + +Los errores en los casos límite son una causa común de errores lógicos en los programas. Los programadores siempre olvidan algo. Estos errores a menudo no se manifiestan de inmediato y pueden no causar problemas visibles durante mucho tiempo. + +El programa sigue funcionando, pero en algún momento se descubre que hay errores en los resultados. A menudo, la causa es la tipificación dinámica de Python. + +Aprenderás a lidiar con estos errores con la experiencia. + +Imaginemos una función extendida `my_substr()`. Toma tres argumentos: una cadena, un índice y la longitud de la subcadena a extraer. La función devuelve la subcadena de la longitud especificada, comenzando desde el índice especificado. Ejemplos de llamadas: + +```python +string = 'If I look back, I am lost' +print(my_substr(string, 0, 1)) # => 'I' +print(my_substr(string, 3, 6)) # => 'I look' +``` + +Los siguientes **casos límite** deben tenerse en cuenta: + +* Longitud negativa de la subcadena a extraer. +* Índice especificado negativo. +* El índice especificado está fuera de los límites de toda la cadena. +* La longitud de la subcadena, sumada al índice especificado, está fuera de los límites de toda la cadena. + +Cuando se implementa la función, cada caso límite será un fragmento de código separado. Probablemente se implementará utilizando `if`. + +Para escribir la función `my_substr()` y protegerse contra estos casos, es recomendable implementar una función separada que verifique la corrección de los argumentos. diff --git a/modules/50-loops/29-edge-cases/es/data.yml b/modules/50-loops/29-edge-cases/es/data.yml new file mode 100644 index 00000000..69eb3c2e --- /dev/null +++ b/modules/50-loops/29-edge-cases/es/data.yml @@ -0,0 +1,2 @@ +name: Casos límite +tips: [] diff --git a/modules/50-loops/29-edge-cases/ru/EXERCISE.md b/modules/50-loops/29-edge-cases/ru/EXERCISE.md new file mode 100644 index 00000000..4962c344 --- /dev/null +++ b/modules/50-loops/29-edge-cases/ru/EXERCISE.md @@ -0,0 +1,30 @@ + +Реализуйте функцию-предикат `is_arguments_for_substr_correct()`, которая принимает три аргумента: + +1. строку; +2. индекс, с которого начинать извлечение; +3. длину извлекаемой подстроки. + +Функция возвращает `False`, если хотя бы одно из условий истинно: + +* Отрицательная длина извлекаемой подстроки. +* Отрицательный заданный индекс. +* Заданный индекс выходит за границу всей строки. +* Длина подстроки в сумме с заданным индексом выходит за границу всей строки. + +В ином случае функция возвращает `True`. + +Не забывайте, что индексы начинаются с `0`, поэтому индекс последнего элемента — это «длина строки минус 1». + +Пример вызова: + +```python +string = 'Sansa Stark' +print(is_arguments_for_substr_correct(string, 2, -3)) # => False +print(is_arguments_for_substr_correct(string, -1, 3)) # => False +print(is_arguments_for_substr_correct(string, 4, 100)) # => False +print(is_arguments_for_substr_correct(string, 10, 10)) # => False +print(is_arguments_for_substr_correct(string, 11, 1)) # => False +print(is_arguments_for_substr_correct(string, 3, 3)) # => True +print(is_arguments_for_substr_correct(string, 0, 5)) # => True +``` diff --git a/modules/50-loops/29-edge-cases/ru/README.md b/modules/50-loops/29-edge-cases/ru/README.md new file mode 100644 index 00000000..801a4b98 --- /dev/null +++ b/modules/50-loops/29-edge-cases/ru/README.md @@ -0,0 +1,33 @@ + +Функция `my_substr()`, которую вы реализовали в прошлом уроке, содержит много ошибок. Она прошла проверку, так как в ней не было **пограничных случаев**. Функция работала с нормальными аргументами. А теперь представим, что ей передали такие варианты длины: + +* `0` +* Отрицательное число +* Число, которое превышает реальный размер строки + +Функция `my_substr()` не рассчитана на такие варианты. Код будет запускаться в разных ситуациях, с разными комбинациями условий и данных. Нельзя быть уверенным, что аргументы всегда будут корректными, поэтому нужно учитывать все случаи. + +Ошибки в пограничных случаях — частая причина логических ошибок в программах. Программисты всегда забывают что-нибудь учесть. Такие ошибки часто проявляются не сразу и могут долго не приводить к видимым проблемам. + +Программа продолжает работать, но в какой-то момент обнаруживается, что в результатах есть ошибки. Часто причина в динамической типизации Python. + +Вы научитесь справляться с такими ошибками с опытом. + +Представим расширенную функцию `my_substr()`. Она принимает три аргумента: строку, индекс и длину извлекаемой подстроки. Функция возвращает подстроку указанной длины, начиная с указанного индекса. Примеры вызова: + +```python +string = 'If I look back I am lost' +print(my_substr(string, 0, 1)) # => 'I' +print(my_substr(string, 3, 6)) # => 'I look' +``` + +Какие **пограничные случаи** стоит учитывать: + +* Отрицательная длина извлекаемой подстроки +* Отрицательный заданный индекс +* Заданный индекс выходит за границу всей строки +* Длина подстроки в сумме с заданным индексом выходит за границу всей строки + +Когда функция реализуется, каждый пограничный случай будет отдельным куском кода. Скорее всего, он будет реализовываться с помощью `if`. + +Чтобы написать функцию `my_substr()` и защититься от этих случаев, стоит реализовать отдельную функцию, которая будет проверять аргументы на корректность. diff --git a/modules/50-loops/29-edge-cases/ru/data.yml b/modules/50-loops/29-edge-cases/ru/data.yml new file mode 100644 index 00000000..3db7b501 --- /dev/null +++ b/modules/50-loops/29-edge-cases/ru/data.yml @@ -0,0 +1,2 @@ +name: Пограничные случаи +tips: [] diff --git a/modules/50-loops/30-syntactic-sugar/en/EXERCISE.md b/modules/50-loops/30-syntactic-sugar/en/EXERCISE.md new file mode 100644 index 00000000..33c19ea9 --- /dev/null +++ b/modules/50-loops/30-syntactic-sugar/en/EXERCISE.md @@ -0,0 +1,8 @@ + +Implement a function called `filter_string()` that takes a string and a character as input, and returns a new string with the character removed from every point in the string. Try not to use the built-in methods for working with the string in your solution. + +```python +text = 'If I look back I am lost' +filter_string(text, 'I') # 'f look back am lost' +filter_string(text, 'o') # 'If I lk back I am lst' +``` diff --git a/modules/50-loops/30-syntactic-sugar/en/README.md b/modules/50-loops/30-syntactic-sugar/en/README.md new file mode 100644 index 00000000..cdb029c7 --- /dev/null +++ b/modules/50-loops/30-syntactic-sugar/en/README.md @@ -0,0 +1,13 @@ + +Constructions like `index = index + 1` are often found in Python, so the creators of the language added an abbreviated version: `index += 1`. + +The only difference is how they're written. The interpreter will turn an abbreviated construction into its expanded form. + +These abbreviations are called **syntactic sugar** because they make the process of writing code a little easier and more pleasant. + +There are abbreviated forms for all arithmetic operations and for string concatenation: + +* `a = a + 1` → `a += 1` +* `a = a - 1` → `a -= 1` +* `a = a * 2` → `a *= 2` +* `a = a / 1` → `a /= 1` diff --git a/modules/50-loops/30-syntactic-sugar/en/data.yml b/modules/50-loops/30-syntactic-sugar/en/data.yml new file mode 100644 index 00000000..1943859c --- /dev/null +++ b/modules/50-loops/30-syntactic-sugar/en/data.yml @@ -0,0 +1,2 @@ +name: Syntactic Sugar +tips: [] diff --git a/modules/50-loops/30-syntactic-sugar/es/EXERCISE.md b/modules/50-loops/30-syntactic-sugar/es/EXERCISE.md new file mode 100644 index 00000000..6ea61a07 --- /dev/null +++ b/modules/50-loops/30-syntactic-sugar/es/EXERCISE.md @@ -0,0 +1,8 @@ + +Implementa la función `filter_string()`, que recibe una cadena y un carácter, y devuelve una nueva cadena en la que se elimina el carácter pasado en todas sus posiciones. Intenta no utilizar métodos incorporados para trabajar con cadenas en tu solución. + +```python +text = 'If I look back I am lost' +filter_string(text, 'I') # 'f look back am lost' +filter_string(text, 'o') # 'If I lk back I am lst' +``` diff --git a/modules/50-loops/30-syntactic-sugar/es/README.md b/modules/50-loops/30-syntactic-sugar/es/README.md new file mode 100644 index 00000000..ee0d818a --- /dev/null +++ b/modules/50-loops/30-syntactic-sugar/es/README.md @@ -0,0 +1,13 @@ + +Construcciones como `index = index + 1` se utilizan frecuentemente en Python, por lo que los creadores del lenguaje agregaron una forma abreviada: `index += 1`. + +Solamente difieren en la forma de escribirlos. El intérprete convertirá la construcción abreviada en la expandida. + +Estas abreviaturas se llaman **azúcar sintáctico**, porque hacen que el proceso de escribir código sea un poco más fácil y agradable. + +Existen formas abreviadas para todas las operaciones aritméticas y para la concatenación de cadenas: + +* `a = a + 1` → `a += 1` +* `a = a - 1` → `a -= 1` +* `a = a * 2` → `a *= 2` +* `a = a / 1` → `a /= 1` diff --git a/modules/50-loops/30-syntactic-sugar/es/data.yml b/modules/50-loops/30-syntactic-sugar/es/data.yml new file mode 100644 index 00000000..b7dbda3b --- /dev/null +++ b/modules/50-loops/30-syntactic-sugar/es/data.yml @@ -0,0 +1,10 @@ +name: Azúcar sintáctico +tips: + - | + [Azúcar sintáctico](https://es.wikipedia.org/wiki/Azúcar_sintáctico) +definitions: + - name: Azúcar sintáctico + description: > + son características sintácticas que no afectan el comportamiento en sí del + programa, pero hacen que el uso del lenguaje sea más conveniente para los + humanos. diff --git a/modules/50-loops/30-syntactic-sugar/ru/EXERCISE.md b/modules/50-loops/30-syntactic-sugar/ru/EXERCISE.md new file mode 100644 index 00000000..1bbac1fd --- /dev/null +++ b/modules/50-loops/30-syntactic-sugar/ru/EXERCISE.md @@ -0,0 +1,8 @@ + +Реализуйте функцию `filter_string()`, принимающую на вход строку и символ, и возвращающую новую строку, в которой удален переданный символ во всех его позициях. Старайтесь не использовать встроенные методы работы со строкой в своем решении. + +```python +text = 'If I look back I am lost' +filter_string(text, 'I') # 'f look back am lost' +filter_string(text, 'o') # 'If I lk back I am lst' +``` diff --git a/modules/50-loops/30-syntactic-sugar/ru/README.md b/modules/50-loops/30-syntactic-sugar/ru/README.md new file mode 100644 index 00000000..9f93dbf5 --- /dev/null +++ b/modules/50-loops/30-syntactic-sugar/ru/README.md @@ -0,0 +1,13 @@ + +Подобные конструкции `index = index + 1` часто используются в Python, поэтому создатели языка добавили ее сокращенный вариант: `index += 1`. + +Они отличаются только способом записи. Интерпретатор превратит сокращенную конструкцию в развернутую. + +Такие сокращения называют **синтаксическим сахаром**, потому что они делают процесс написания кода немного проще и приятнее. + +Существуют сокращенные формы для всех арифметических операций и для конкатенации строк: + +* `a = a + 1` → `a += 1` +* `a = a - 1` → `a -= 1` +* `a = a * 2` → `a *= 2` +* `a = a / 1` → `a /= 1` diff --git a/modules/50-loops/30-syntactic-sugar/ru/data.yml b/modules/50-loops/30-syntactic-sugar/ru/data.yml new file mode 100644 index 00000000..17df6138 --- /dev/null +++ b/modules/50-loops/30-syntactic-sugar/ru/data.yml @@ -0,0 +1,9 @@ +name: Синтаксический сахар +tips: + - | + [Синтаксический сахар](https://ru.wikipedia.org/wiki/Синтаксический_сахар) +definitions: + - name: Синтаксический сахар + description: > + это синтаксические возможности, применение которых не влияет на поведение + программы, но делает использование языка более удобным для человека. diff --git a/modules/50-loops/55-return-from-loops/en/EXERCISE.md b/modules/50-loops/55-return-from-loops/en/EXERCISE.md new file mode 100644 index 00000000..2c1dfb12 --- /dev/null +++ b/modules/50-loops/55-return-from-loops/en/EXERCISE.md @@ -0,0 +1,12 @@ + +Implement a function `is_contains_char()` that checks case-sensitively if a string contains a specified letter. The function takes two parameters: + +* The line +* Search letter + +```python +print(is_contains_char('Hexlet', 'H')) # => True +print(is_contains_char('Hexlet', 'h')) # => False +print(is_contains_char('Awesomeness', 'm')) # => True +print(is_contains_char('Awesomeness', 'd')) # => False +``` diff --git a/modules/50-loops/55-return-from-loops/en/README.md b/modules/50-loops/55-return-from-loops/en/README.md new file mode 100644 index 00000000..b6e3788f --- /dev/null +++ b/modules/50-loops/55-return-from-loops/en/README.md @@ -0,0 +1,34 @@ + +Working with loops usually comes down to two scenarios: + +1. Aggregation. Accumulation of result during iterations and working with it after the cycle. Line reversal refers to this variant. +2. Executing the loop until the desired result is achieved and exiting. For example, the problem of searching for prime numbers - which are divided without remainder by themselves and by one + +Consider the algorithm for checking the simplicity of a number. We will divide the sought number `x` by all numbers in the range from two to `x - 1` and see the remainder. If no divisor is found in this range, which divides the number `x` without a remainder, then we have a prime number. + +In this case it is enough to check the numbers not up to `x - 1`, but up to half a number. For example, 11 is not divisible by 2, 3, 4, 5. But further will not divide by numbers greater than its half. So, we can optimize the algorithm and check the division only up to `x / 2`: + +```python +def is_prime(number): + if number < 2: + return False + + divider = 2 + + while divider <= number / 2: + if number % divider == 0: + return False + + divider += 1 + + return True + +print(is_prime(1)) # => False +print(is_prime(2)) # => True +print(is_prime(3)) # => True +print(is_prime(4)) # => False +``` + +Imagine that the algorithm of consecutive division by numbers up to `x / 2` has found one that divides without a remainder. So the argument passed is not a prime number, and further calculations do not make sense. At this point it returns `False`. + +If the whole cycle worked and no number was found that divides without a remainder, it means that the number is prime. diff --git a/modules/50-loops/55-return-from-loops/en/data.yml b/modules/50-loops/55-return-from-loops/en/data.yml new file mode 100644 index 00000000..03465754 --- /dev/null +++ b/modules/50-loops/55-return-from-loops/en/data.yml @@ -0,0 +1,3 @@ +name: Return from cycles +tips: + - '[List of prime numbers](https://en.wikipedia.org/wiki/List_of_prime_numbers)' diff --git a/modules/50-loops/55-return-from-loops/es/EXERCISE.md b/modules/50-loops/55-return-from-loops/es/EXERCISE.md new file mode 100644 index 00000000..cac97047 --- /dev/null +++ b/modules/50-loops/55-return-from-loops/es/EXERCISE.md @@ -0,0 +1,12 @@ + +Implementa la función `is_contains_char()`, que verifica, considerando mayúsculas y minúsculas, si una cadena contiene una letra específica. La función recibe dos parámetros: + +* La cadena +* La letra a buscar + +```python +print(is_contains_char('Hexlet', 'H')) # => True +print(is_contains_char('Hexlet', 'h')) # => False +print(is_contains_char('Awesomeness', 'm')) # => True +print(is_contains_char('Awesomeness', 'd')) # => False +``` diff --git a/modules/50-loops/55-return-from-loops/es/README.md b/modules/50-loops/55-return-from-loops/es/README.md new file mode 100644 index 00000000..c19c4947 --- /dev/null +++ b/modules/50-loops/55-return-from-loops/es/README.md @@ -0,0 +1,38 @@ + +Trabajar con bucles generalmente se reduce a dos escenarios: + +1. Agregación. Acumular resultados durante las iteraciones y trabajar con ellos después del bucle. Voltear una cadena es un ejemplo de este caso. +2. Ejecutar el bucle hasta que se alcance un resultado deseado y luego salir. Por ejemplo, la tarea de encontrar números primos, que solo son divisibles exactamente por sí mismos y por uno. + +Veamos el algoritmo para comprobar si un número es primo. Dividiremos el número buscado `x` entre todos los números en el rango desde dos hasta `x - 1` y observaremos el residuo. Si no encontramos ningún divisor en este rango que divida al número `x` sin residuo, entonces estamos ante un número primo. + +En este caso, solo es necesario verificar los números hasta `x / 2`, en lugar de hasta `x - 1`. Por ejemplo, 11 no es divisible por 2, 3, 4, 5. Pero tampoco será divisible por números mayores que la mitad de sí mismo. Por lo tanto, podemos optimizar el algoritmo y verificar la división solo hasta `x / 2`: + +```python +def is_prime(number): + if number < 2: + return False + + divider = 2 + + while divider <= number / 2: + if number % divider == 0: + return False + + divider += 1 + + return True + +print(is_prime(1)) # => False +print(is_prime(2)) # => True +print(is_prime(3)) # => True +print(is_prime(4)) # => False +``` + +https://replit.com/@hexlet/python-basics-loops-return-from-loops + +*Siendo completamente honestos, para resolver el problema es suficiente verificar los números hasta la raíz cuadrada de `numero`, pero en nuestro caso es importante concentrarse en comprender las condiciones dentro del bucle.* + +Imaginemos que en el algoritmo de división secuencial de números hasta `x / 2` encontramos uno que divide sin residuo. Entonces, el argumento proporcionado no es un número primo y no tiene sentido continuar con los cálculos. En este punto, deberíamos retornar `False`. + +Si el bucle se ejecuta por completo y no encontramos ningún número que divida sin residuo, entonces el número es primo. diff --git a/modules/50-loops/55-return-from-loops/es/data.yml b/modules/50-loops/55-return-from-loops/es/data.yml new file mode 100644 index 00000000..079528df --- /dev/null +++ b/modules/50-loops/55-return-from-loops/es/data.yml @@ -0,0 +1,10 @@ +name: Vuelta desde bucles +tips: + - >- + [Lista de números + primos](https://es.wikipedia.org/wiki/Anexo:Números_primos) +definitions: + - name: Agregación + description: >- + Acumular resultados durante las iteraciones y trabajar con ellos después + del bucle. diff --git a/modules/50-loops/55-return-from-loops/ru/EXERCISE.md b/modules/50-loops/55-return-from-loops/ru/EXERCISE.md new file mode 100644 index 00000000..bec62bd0 --- /dev/null +++ b/modules/50-loops/55-return-from-loops/ru/EXERCISE.md @@ -0,0 +1,12 @@ + +Реализуйте функцию `is_contains_char()`, которая проверяет с учётом регистра, содержит ли переданная строка указанную букву. Функция принимает два параметра: + +* Строка +* Буква для поиска + +```python +print(is_contains_char('Hexlet', 'H')) # => True +print(is_contains_char('Hexlet', 'h')) # => False +print(is_contains_char('Awesomeness', 'm')) # => True +print(is_contains_char('Awesomeness', 'd')) # => False +``` diff --git a/modules/50-loops/55-return-from-loops/ru/README.md b/modules/50-loops/55-return-from-loops/ru/README.md new file mode 100644 index 00000000..35921d9e --- /dev/null +++ b/modules/50-loops/55-return-from-loops/ru/README.md @@ -0,0 +1,38 @@ + +Работа с циклами обычно сводится к двум сценариям: + +1. Агрегация. Накопление результата во время итераций и работа с ним после цикла. Переворот строки относится к такому варианту +2. Выполнение цикла до достижения необходимого результата и выход. Например, задача поиска простых чисел — которые делятся без остатка только на себя и на единицу + +Рассмотрим алгоритм проверки простоты числа. Будем делить искомое число `x` на все числа из диапазона от двух до `x - 1` и смотреть остаток. Если в этом диапазоне не найден делитель, который делит число `x` без остатка, значит, перед нами простое число. + +В этом случае достаточно проверять числа не до `x - 1`, а до половины числа. Например, 11 не делится на 2, 3, 4, 5. Но и дальше не будет делиться на числа больше своей половины. Значит, можно оптимизировать алгоритм и проверять деление только до `x / 2`: + +```python +def is_prime(number): + if number < 2: + return False + + divider = 2 + + while divider <= number / 2: + if number % divider == 0: + return False + + divider += 1 + + return True + +print(is_prime(1)) # => False +print(is_prime(2)) # => True +print(is_prime(3)) # => True +print(is_prime(4)) # => False +``` + +https://replit.com/@hexlet/python-basics-loops-return-from-loops + +*Если быть честными до конца, то для решения задачи хватит проверки чисел до значения квадратного корня `number`, но в нашем случае важно сосредоточиться на понимании работы с условиями внутри цикла* + +Представим, что по алгоритму последовательного деления на числа до `x / 2` нашлось одно, которое делит без остатка. Значит, переданный аргумент — не простое число, и дальнейшие вычисления не имеют смысла. В этом месте стоит возврат `False`. + +Если цикл отработал целиком, и не нашлось число, которое делит без остатка, значит, число — простое. diff --git a/modules/50-loops/55-return-from-loops/ru/data.yml b/modules/50-loops/55-return-from-loops/ru/data.yml new file mode 100644 index 00000000..be81f4df --- /dev/null +++ b/modules/50-loops/55-return-from-loops/ru/data.yml @@ -0,0 +1,6 @@ +name: Возврат из циклов +tips: + - '[Список простых чисел](https://ru.wikipedia.org/wiki/Список_простых_чисел)' +definitions: + - name: Агрегация + description: Накопление результата во время итераций и работа с ним после цикла. diff --git a/modules/50-loops/70-for/en/EXERCISE.md b/modules/50-loops/70-for/en/EXERCISE.md new file mode 100644 index 00000000..5d265928 --- /dev/null +++ b/modules/50-loops/70-for/en/EXERCISE.md @@ -0,0 +1,10 @@ + +In a previous lesson, we already wrote the `filter_string()` function. Recall that it takes a string and a character as input and returns a new string in which the passed character at all its positions is removed. This time, implement this function using the `for` loop. An additional condition: the case of the character to be eliminated does not matter. + +An example of a call: + +```python +text = 'If I look forward I win' +filter_string(text, 'i') # 'f look forward wn' +filter_string(text, 'O') # 'If I lk frward I win' +``` diff --git a/modules/50-loops/70-for/en/README.md b/modules/50-loops/70-for/en/README.md new file mode 100644 index 00000000..92c1fc25 --- /dev/null +++ b/modules/50-loops/70-for/en/README.md @@ -0,0 +1,61 @@ + +The `while' loop can be used to solve any item search problem, but it is notable for being verbose. For `while` it is necessary to set a stopping condition and enter a counter. When there are few loops, this is fine, but in real code loops occur at every step. It is therefore tedious to manage the conditions manually, especially when the stopping condition is obvious. + +For example, if we want to go through the characters in a string, the computer can figure out by itself when the string ends. For such situations, Python introduced the `for` loop. It knows itself when to stop, because it only works with collections - sets of elements that need to be searched. + +A string is a collection because it consists of a set of characters. The other types of collections are studied in detail in another course. + +Example: + +```python +text = 'code' +for symbol in text: + print(symbol) + +# => c +# => o +# => d +# => e +``` + +In the code above, `for` goes through each character in the string, writes it in a variable `symbol` and calls the internal code block where that variable is used. The name of this variable can be anything. The general structure of the `for' loop looks like this: `for in '. + +Let's see how to implement the string flip function through the `for` loop: + +```python +def reverse_string(text): + # Initial value + result = '' + # char - a variable in which the current character is written + for char in text: + # Connect in reverse order + result = char + result + # The cycle ends when the whole line is passed + return result + + +reverse_string('go!') # => '!og' +``` + +Now let's calculate the number of mentions of a character in the string, not case-sensitive: + +```python +# text - any text +# char - a symbol to consider +def chars_count(text, char): + # Since we are looking for the sum, the initial value is 0 + result = 0 + for current_char in text: + # We convert everything to lower case, + # so as not to depend on the current register + if current_char.lower() == char.lower(): + result += 1 + return result + + +chars_count('hexlet!', 'e') # 2 +chars_count('hExlet!', 'e') # 2 +chars_count('hExlet!', 'E') # 2 + +chars_count('hexlet!', 'a') # 0 +``` diff --git a/modules/50-loops/70-for/en/data.yml b/modules/50-loops/70-for/en/data.yml new file mode 100644 index 00000000..8795ce1f --- /dev/null +++ b/modules/50-loops/70-for/en/data.yml @@ -0,0 +1,2 @@ +name: Cycle For +tips: [] diff --git a/modules/50-loops/70-for/es/EXERCISE.md b/modules/50-loops/70-for/es/EXERCISE.md new file mode 100644 index 00000000..dba998f1 --- /dev/null +++ b/modules/50-loops/70-for/es/EXERCISE.md @@ -0,0 +1,10 @@ + +En una de las lecciones anteriores, ya escribimos la función `filter_string()`. Recordemos que esta función recibe una cadena y un carácter, y devuelve una nueva cadena en la que se ha eliminado el carácter en todas sus posiciones. Esta vez, implementa esta función utilizando el ciclo `for`. Un requisito adicional es que el carácter a excluir no distingue entre mayúsculas y minúsculas. + +Ejemplo de llamada: + +```python +text = 'If I look forward I win' +filter_string(text, 'i') # 'f look forward wn' +filter_string(text, 'O') # 'If I lk frward I win' +``` diff --git a/modules/50-loops/70-for/es/README.md b/modules/50-loops/70-for/es/README.md new file mode 100644 index 00000000..9e6182b1 --- /dev/null +++ b/modules/50-loops/70-for/es/README.md @@ -0,0 +1,69 @@ + +El ciclo `while` se utiliza para resolver cualquier problema de iteración, pero es bastante extenso y verboso. Con `while`, es necesario establecer una condición de finalización y un contador. Cuando hay pocos ciclos, esto no es un problema, pero en el código real, los ciclos están presentes en cada paso. Por lo tanto, controlar las condiciones manualmente puede resultar tedioso, especialmente cuando la condición de finalización es obvia. + +Por ejemplo, si queremos iterar sobre los caracteres de una cadena, la computadora puede entender automáticamente cuándo la cadena termina. Para este tipo de situaciones, en Python se introdujo el ciclo `for`. Este ciclo sabe automáticamente cuándo detenerse, ya que solo trabaja con colecciones, es decir, conjuntos de elementos que deben ser iterados. + +Una cadena es una colección, ya que está compuesta por un conjunto de caracteres. Otros tipos de colecciones se estudian en otro curso. + +Ejemplo: + +```python +text = 'code' +for symbol in text: + print(symbol) + +# => c +# => o +# => d +# => e +``` + +En el código anterior, el ciclo `for` recorre cada carácter de la cadena, lo guarda en la variable `símbolo` y ejecuta el bloque de código interno donde se utiliza esta variable. El nombre de esta variable puede ser cualquier cosa. La estructura general del ciclo `for` es: `for in `. + +Veamos cómo implementar una función para invertir una cadena utilizando el ciclo `for`: + +```python +def reverse_string(text): + # Valor inicial + result = '' + # char - variable donde se guarda el carácter actual + for char in text: + # Concatenamos en orden inverso + result = char + result + # El ciclo termina cuando se ha recorrido toda la cadena + print(result) + + +reverse_string('go!') # => '!og' +``` + +Analicemos detalladamente cómo funciona el ciclo en el ejemplo anterior en cada iteración: + +1. En la primera iteración, en el ciclo `result` hay una cadena vacía y `char` es igual al primer carácter '¡'. Por lo tanto, en `resultado` se asigna el carácter '¡' más la cadena vacía, lo que resulta en '¡'. +2. En la segunda iteración, `result` ya contiene el carácter '¡' y `char` es igual al siguiente carácter 'v'. En `result` se guarda `char + result`, es decir, `'v' + '¡'`. +3. En la última iteración, `result` contiene la cadena '¡v' y `char` es igual al último carácter '!'. En `result` se guarda `'¡v' + '!'`. + +Ahora contemos la cantidad de veces que aparece un carácter en una cadena sin tener en cuenta el caso: + +```python +# text - texto arbitrario +# char - carácter que se debe contar +def chars_count(text, char): + # Como estamos buscando la suma, el valor inicial es 0 + result = 0 + for current_char in text: + # convertimos todo a minúsculas + # para no depender del caso actual + if current_char.lower() == char.lower(): + result += 1 + return result + + +chars_count('hexlet!', 'e') # 2 +chars_count('hExlet!', 'e') # 2 +chars_count('hExlet!', 'E') # 2 + +chars_count('hexlet!', 'a') # 0 +``` + +Te recomendamos experimentar con los ejemplos anteriores en el [Replit](https://replit.com/@hexlet/python-basics-for-loop#main.py) interactivo. diff --git a/modules/50-loops/70-for/es/data.yml b/modules/50-loops/70-for/es/data.yml new file mode 100644 index 00000000..6bfbe9b5 --- /dev/null +++ b/modules/50-loops/70-for/es/data.yml @@ -0,0 +1,7 @@ +name: Ciclo For +tips: [] +definitions: + - name: Agregación + description: >- + Acumulación de resultados durante las iteraciones y manejo de estos + después del ciclo. diff --git a/modules/50-loops/70-for/ru/EXERCISE.md b/modules/50-loops/70-for/ru/EXERCISE.md new file mode 100644 index 00000000..c967d5dd --- /dev/null +++ b/modules/50-loops/70-for/ru/EXERCISE.md @@ -0,0 +1,10 @@ + +В одном из предыдущих уроков мы уже написали функцию `filter_string()`. Напомним, она принимает на вход строку и символ и возвращает новую строку, в которой удалён переданный символ во всех его позициях. На этот раз реализуйте эту функцию с помощью цикла `for`. Дополнительное условие: регистр исключаемого символа не имеет значения. + +Пример вызова: + +```python +text = 'If I look forward I win' +filter_string(text, 'i') # 'f look forward wn' +filter_string(text, 'O') # 'If I lk frward I win' +``` diff --git a/modules/50-loops/70-for/ru/README.md b/modules/50-loops/70-for/ru/README.md new file mode 100644 index 00000000..025e4a39 --- /dev/null +++ b/modules/50-loops/70-for/ru/README.md @@ -0,0 +1,69 @@ + +С помощью цикла `while` решают любую задачу перебора элементов, но его отличает многословность. Для `while` нужно задавать условие остановки и вводить счетчик. Когда циклов немного, то это нормально, но в реальном коде циклы встречаются на каждом шагу. Поэтому управлять условиями вручную утомительно, особенно когда условие остановки очевидно. + +Например, если мы хотим перебрать символы в строке, то компьютер сам может понять, когда строка заканчивается. Для таких ситуаций в Python ввели цикл `for`. Он сам знает, когда нужно остановиться, так как работает только с коллекциями — наборами элементов, которые нужно перебрать. + +Строка — это коллекция, так как состоит из набора символов. Остальные виды коллекций подробно изучаются в другом курсе. + +Пример: + +```python +text = 'code' +for symbol in text: + print(symbol) + +# => c +# => o +# => d +# => e +``` + +В коде выше `for` проходит по каждому символу в строке, записывает его в переменную `symbol` и вызывает внутренний блок кода, где эта переменная используется. Имя этой переменной может быть любым. Общая структура цикла `for` выглядит так: `for <переменная> in <коллекция>`. + +Посмотрим, как реализовать функцию переворота строки через цикл `for`: + +```python +def reverse_string(text): + # Начальное значение + result = '' + # char - переменная, в которую записывается текущий символ + for char in text: + # Соединяем в обратном порядке + result = char + result + # Цикл заканчивается, когда пройдена вся строка + return result + + +reverse_string('go!') # => '!og' +``` + +Разберем подробно как отрабатывает цикл в примере выше на каждом шаге итераций: + +1. В первой итерации в цикле `result` равен пустой строке, `char` равен первому символу 'g'. Поэтому в `result` присваивается символ 'g' плюс пустая строка, в итоге сохраняется только символ 'g' +2. На второй итерации `result` уже хранит символ 'g', а `char` равен следующему символу 'o'. В `result` записывается `char + result`, то есть `'o' + 'g'` +3. На последней итерации в `result` хранится строка 'og', а `char` равен последнему символу '!'. В `result` теперь сохраняется `'og' + '!'` + +Теперь посчитаем количество упоминаний символа в строке без учета регистра: + +```python +# text - произвольный текст +# char - символ, который нужно учитывать +def chars_count(text, char): + # Так как ищем сумму, то начальное значение 0 + result = 0 + for current_char in text: + # приводим все к нижнему регистру, + # чтобы не зависеть от текущего регистра + if current_char.lower() == char.lower(): + result += 1 + return result + + +chars_count('hexlet!', 'e') # 2 +chars_count('hExlet!', 'e') # 2 +chars_count('hExlet!', 'E') # 2 + +chars_count('hexlet!', 'a') # 0 +``` + +Советуем поэкспериментировать с примерами выше в интерактивном [Replit](https://replit.com/@hexlet/python-basics-for-loop#main.py). diff --git a/modules/50-loops/70-for/ru/data.yml b/modules/50-loops/70-for/ru/data.yml new file mode 100644 index 00000000..ed2d2e79 --- /dev/null +++ b/modules/50-loops/70-for/ru/data.yml @@ -0,0 +1,5 @@ +name: Цикл For +tips: [] +definitions: + - name: Агрегация + description: Накопление результата во время итераций и работа с ним после цикла. diff --git a/modules/50-loops/80-for-in-range/ru/EXERCISE.md b/modules/50-loops/80-for-in-range/ru/EXERCISE.md new file mode 100644 index 00000000..c748f251 --- /dev/null +++ b/modules/50-loops/80-for-in-range/ru/EXERCISE.md @@ -0,0 +1,11 @@ + +Реализуйте функцию `print_table_of_squares(from, to)`, которая печатает на экран квадраты чисел. Она первое `from` и последнее `to` число печатает строку `square of <число> is <результат>` + +Примеры вызова: + +```python +print_table_of_squares(1, 3) +# => square of 1 is 1 +# => square of 2 is 4 +# => square of 3 is 9 +``` diff --git a/modules/50-loops/80-for-in-range/ru/README.md b/modules/50-loops/80-for-in-range/ru/README.md new file mode 100644 index 00000000..c83087fc --- /dev/null +++ b/modules/50-loops/80-for-in-range/ru/README.md @@ -0,0 +1,64 @@ + +Представьте, что у нас есть ряд чисел от 0 до 9. Мы хотим сложить эти числа. Мы могли бы сделать это так: + +```python +sum = 0 +i = 0 + +while i < 10: + sum += i + i += 1 + +print(sum) # => 45 +``` + +Сначала мы устанавливаем начальную сумму 0. Далее запускается цикл, в котором переменная `i` начинает принимать значения начиная с 0 и доходя до 10. На каждом шаге мы прибавляем значение `i` к нашей сумме и увеличиваем `i` на 1. Как только `i` становится равным 10, цикл заканчивается и программа выдаёт нам сумму всех чисел от 0 до 9 равную 45. + +Такой код мы можем переписать на цикл `for` + +```python +sum = 0 + +for i in range(10): + sum += i + +print(sum) # => 45 +``` + +Первый пример использует `while`, который продолжает работать пока `i < 10`. Второй использует `for` и выполняет итерацию от 0 до 9 с помощью функции `range()`. Оба выполняют одно и то же: складывают числа от 0 до 9 в переменную `sum`, но используют разные способы выполнения итераций. + + +## Функция `range()` + +Функция range в Python является встроенной функцией, которая создает последовательность чисел внутри определенного диапазона. Ее можно использовать в цикле for для контроля количества итераций. + +У `range()` есть несколько вариантов использования: + +* `range(stop)` создает последовательность от 0 до `stop - 1` +* `range(start, stop)` создает последовательность от start до `stop - 1` +* `range(start, stop, step)` создает последовательность из чисел от start до `stop - 1`, с шагом `step` + +Пример с одним конечным значением мы рассмотрели выше. Рассмотрим другой - распечатаем на экран числа от 1 до 3: + +```python + +for i in range(1, 4): + print(i) + +# => 1 +# => 2 +# => 3 +``` + +Теперь попробуем вывести числа в обратном порядке + +```python +for i in range(3, 0, -1): + print(i) + +# => 3 +# => 2 +# => 1 +``` + +На примерах выше мы видим, что итерация завершается до конечного значения diff --git a/modules/50-loops/80-for-in-range/ru/data.yml b/modules/50-loops/80-for-in-range/ru/data.yml new file mode 100644 index 00000000..23d32f0d --- /dev/null +++ b/modules/50-loops/80-for-in-range/ru/data.yml @@ -0,0 +1,3 @@ +name: Цикл for и функция range +tips: [] +definitions: []