# Python
 Интерпретированный обьектно-ориентированный ЯП
- Строго тиризированные данные 
- Динамично типизирован
                
| Имя      | Тип              | Описание |
| ------------- |------------------:| :-----|
| integer    | int   |  Числовой ТД для __*целых*__ чисел (3, 79, -90)|
| floating point    | float | Может премещаться по числу (7.8, -0.09) |
| string  | str       |    __Упорядоченная__ пос-ть символов (буквы/цифры) - __immutable__  | 
| List  |     list  |  Упорядоченная пос-ть обьектов [] = структура данных |    
| [dictionary](dictionaries.md)  |   dict    |   Неупорядоченная пос-ть пар ключей и значений {("ключ": "77", "ключ2": "88",)}   |   
|tuple |   tup    |   Упорядоченная неизмен. пос-ть ("9", "10") - __immutable__ |   
| set  |    set   |  Неупорядоченная коллекция уник. обьектов ("привет", 99), не может менять обьекты внутри   |   
| boolean |    bool   |    True/False |   

## Основные хоткеи

__"Ctrl + /"__ - комментарий

__" \ "__ - перенос кода на след строку, перед знаками внутри строки "I \ 'm"

__\n__ - перенос фразы на след. строку

__\t__ - заменяет пробел в строке

__""" _ """__ - игнорируют любые символы внутри 
- из списка подряд цифры через пробел
```python
L = [1, 2, 3, 4, 5]
print(*L)
```


## Строки в Python 

### Свойства и методы строк

#### __Св-ва:__ \
 1) Immutable - неизменяемые. Если созд. строку, то через терм не можем менять  
```python    
a1 = 'ABcd' 
print (1[1]) -> b
```
```python
a1[1] = 2 -> (FAIL)
```
2) Concate - можем скреплять строки
3) Muttyplication - усножение
```python
yummy = 'yum'
print(yummy*2) -> yumyum
```
__Методы:__ \
`yummy.upper()` - делает все буквы заглавные (НОВАЯ строка)\
`yummy.lower()` - наоборот (НОВАЯ строка) 

## Форматирование строк 
```python
name = 'Jack'
age = 23
name_and_age = 'My name is {0}. I\'m {1} years old'.format(name,age)' #можно сразу переменные без цифр
```
-> Можно {} в разном порядке, можно без цифр сразу переменные писать \

## Таблица
```python
print ('''{}{}{}
{}{}{}
{}{}{}'''.format(ввести числа в кол-ве {}))
```
-> `{0:1.3f}` 3f - кол-во знаков после запятой в float, `{0:10.3f}` 10 - будет пробел - подставить вместо {} в таблице

## Boolean
| True | False | 
- comparison operators
- равентсво `n==n` -> True
- `'Hello' == 'hello'` -> False (H != h)
- `n > m` / `n < m`
- `n >= m ` / `n <= m`
- `x=x+n` = `x+=n`
- __ASCII code__  
```python
print(ord('a')) -> 97
print(ord('b')) -> 98
print(ord('a' > 'b')) -> Falseа
print('hi'>'hello') -> True # Отличие в первых отличающихся знаках ('i'= 105 'e'= 101)
```
- Программа вывода `True`, если ввести 18 и более лет
```python
age = int(input('input your age'))
print('Your age is' + str(age))
print('Access is permitted' + str(age >= 18)) -> True
```
```python
name = input(('input your name'))
age = int(input('input your age'))
is_married = False
if age > 18 and is_married == False:
print('Hi {}! You are {}'.format(name,age)) 
```
#### __Bollean операции с помощью `print()`__
---
- строки
```python
print ('a' in "Jack") -> True  # такая буква есть в слове, по сути не вводим переменные и списки/листы
```
- списки
```python
list = ['a','b','c']
    print ('a' in list) -> True  # такая буква есть в спискe
```
- словари
```python
dict = {1:'a', 2: 'b', 3:'c'}
    print (1 in dict) -> True  # есть такой ключ
    print (1 in dict.keys()) -> True  # есть такой ключ
    print (4 in dict.keys()) -> False   # такого ключа нет 
    print ('c' in dict.values()) -> True  # есть такое значение
```
### Логические операторы
---
- `and` \ `or` \ `not`
```python
x = 1
y = 2
x>1 and y>1 -> False
x>1 or y>1 -> True
not x>1 -> True
```
### Условный оператор if, elif, else
---
- Пример:
```python
x = 3 
if x>3:
    print('x>3')
elif x<3:
    print('x<3')
else:
    print('x == 3') -> x==3
```
- Четное / Нечетное
```python
x = 45
if x%2 == 0:
    print('x is even') # четное 
else:
    print('x is odd') # нечетное 
```
- Особенности работы `if` 

|  False |  True | 
| ------------- |------------------:| 
| if 0:  | if n: #n!=0| 
|if ' ':|if 'ab':|
|if None:||
|if[] :|if [1,2] :|

## Цикл for
- Посл-ти: строки, списки, словари, мн-ва и др. - для перебора используется цикл
```python
list = [1,2,3,4,5]
for number(любое значение) in list:
    print(number) -> 1
                     2
                     3
                     4
                     5
    print('Hi') #выдаст столько раз сколько эл-тов в списке
```
- Для подсчета суммы значений в списке
```python
sum = 0
for num in list:
    sum = sum + num
print (sum) -> 10
```
- цикл `for` для tuple 
```python
tuple = [('a','b'),('c','d'),('e','f')]
for item im tuple:
    print (item) -> ('a','b')
                    ('c','d')
                    ('e','f')
```
```python
for let1, let2 in tuple:
    print(let1, let2) -> ab
                         cd
                         ef
for let1, let2 in tuple:
    print(let1) # первые буквы каждого tuple эл-та
    print(let2) -> a
                   c
                   e
                   b
                   d
                   f            
```
- цикл `for` для dictionaries \
__`.items()`__ - и ключ и значения

```python         
for items in dict.items():
    print(item) -> ('key1','value1')
                   ('key2','value2')
```
 __`.keys()`__ - только ключи
```python
dict = {'key1':'value1','key2':'value2'}
for item in dict.keys():
    print(key) -> key1
                  key2 
```
 __`.values()`__ - только значения
```python
dict = {'key1':'value1','key2':'value2'}
for item in dict.values():
    print(values) -> value1
                     value2 
```

## Цикл while
Выполняется до тех пор, пока какое-то условие не станет True
```python
x = 5
while x>=1:
    print(x)
    x = x-1 -> 5 # 5>= 1 ... print()
               4 # 4>= 1 ... print()
               3 # 3>= 1 ... print()
               2 # 2>= 1 ... print()
               1 # 1>= 1 ... print()
                 # 0>= 1 .False. break
```
#### Операторы `pass`,`break`,`continue` 
`pass`  - (ничего не делать)
```python
list = [1,2,3]
for i on list:
    pass     # ничего не делать
```
- `break` - если True - выход из цикла
```python
list = [1,2,3]
for i on list:
    if i ==2:
        break  # если True - выход из цикла
    print(i) -> 1 
```
`continue` - если True - переход в начало цикла 
```python
list = [1,2,3]
for i on list:
    if i ==2:
        continue  # если True - переход в начало цикла 
    print(i) -> 1 # пропустили эл-т 2
                3
```
## Range()
Функция `range()` - часто используется для повторения опр. действий несколько раз
```python
for x in range(n): # n не включено
    print(n) -> 0
                1
                2 # n не включено
```
- диапазон `range(k,n)`
```python
for x in range(k,n): # n не включено
    print(n) -> k
                k+1
                k+2
                ... # n не включено
```
- диапазон `range(k,n)` + шаги `range(k,n,l)`
```python
for x in range(k,n,l):  # n не включено 3,11,2
    print(n) -> k       # 3
                k+l     # 3+2 = 5
                (k+l)+l # 5+2 = 7
                ...     # n не включено, 9 stop
```
- для перебора цифр и заключение их в список
```python
list = [num for num in range(0,10)] # первый num можно опустить
print (list) -> [0,1,2,3...9] # 10 не вкл
```
- для операций типа степеней\корней и пр.
```python
list = [num**2 for num in range(0,10)] 
print (list) -> [0,1,4,9...81] # 10 не вкл
list = [(num-3/2)**2 for num in range(0,10)] 
```
## Индексы
__len()__ - длина строки 

[а:с] - а(вкл), с(не вкл) \
[:] - от начала до конца \
[а:] - от начала до конца \
[::с] - от начала до конца с шагом 2 __Пример__ : Hello - H (~~e~~) l (~~l~~) o = Hlo \
[1::2] - Hello - eo
[::-1] - наоборот слово 

#### Различные операции с индексами
- указать индекс каждого эл-та в списке/строке
```python
index = 0
my_str = 'agdjfh'
for letters in my_str:
    print (letter + 'is at index' + str(index))
    index += 1
```
- `enumerate()` указать индекс каждого эл-та в списке/строке 
```python
index = 0
my_str = 'agdjfh'
for letters in enumerate(my_str):
    print (letter) -> (0, 'a')
                      (1, 'g')
                      ...

```
- (распаковка) `enumerate()` 
```python
index = 0
my_str = 'agdjfh'
for index, letters in enumerate(my_str):
    print (letter + 'is at index' + str(index)) 
```

### Различные функции
---
- `min()` | `max()` 
```python
print (min(1,2,3,4)) -> 1
```
- `min()` | `max()` работают также с листами по аскикоду
```python
print(max('Hello')) -> o # по аскикоду о = 111
```
#### Добавление библиотек
- Добавление предустановленных библиотек
```python
import pandas as pd
```
- Пример использования
```python
from random import shuffle
list = [1,3,56,4]
print(shuffle(list)) -> [4,3,56,1] # Рандомно перемешивает
from random import randint
randint (1,10) -> 6 # Выбирает любое число по диапазону (1,10)
```
## List Comprehension
#### Создание списка из посл-тей
- разделяем слово на буквы и помещаем в список ['','']
    - способ №1
  ```python
    str = 'Hello'
    list = []
    for i in str:
        list.append(letter) # добавляет эл-т в конец списка (в данном случае добавляем с 1 эл-та)
    print(list) -> ['h','e','l',,...]
  ```
    - способ №2
    ```python
    str = 'Hello'
    list = []
    list = [for i in str]
    print (list) -> ['h','e','l',,...]
    ```
    - для перебора цифр и заключение их в список
    ```python
    list = [num for num in range(0,10)] # первый num можно опустить
    print (list) -> [0,1,2,3...9] # 10 не вкл
    ```
    - для операций типа степеней\корней и пр.
    ```python
    list = [num**2 for num in range(0,10)] 
    print (list) -> [0,1,4,9...81] # 10 не вкл
    list = [(num-3/2)**2 for num in range(0,10)] 
    ```  
    -  `if` в операции с `for...in`
    ```python
    list = [6,43,-2,11,-55,-12,3,345]
    new_list = [num for num in list if num > 0] 
    # первый "num" - помещаем в список, можно добавлять к нему условия типа "num **3/2"
    # второй "num" - из последовательностей list 
    # "if"  в конце, т.к нет других операторов
    # "num > 0" - только положительные числа 
    print (new_list) -> [6,43,11,3,345] 
    ```
    -  `if...else` в операции с `for...in`
    ```python
    list = ['+' if number > 0 else '-' for number in number_list]
    ```

    ## Функции 
    - код, кот. вып. фун-цию и назван именем 
    ВИД:  ``set()``
    ### Создание функций
    ```python
    def print_greeting():
        ''' # доксрин
        print 'Hello' text 
        :return: None
        '''
        print ('Hello')
    print_greeting() -> Hello 
    ```
    -  ``help``
    ```python
    help(print_greeting) # вызов докскрина
    ```
    - функция с параметрами
    ```python
    def print_greeting_with_name(name): # чтобы вызвать без параметра, можно просто написать имя 'Jack' , но тогда и вывод с принтом будет выглядеть иначе
        '''
        :param name
        :return: None
        '''
        print ('Hello' + name + '!')
    print (greeting ... ('Jack')) -> Hello Jack!
    ```
    ### Возвращенная функция 
    - сумма двух чисел 
    ```python
    def sum_two_num (a,b):
        return a+b
    x = sum_two_num (1,1)
    print (x) -> 2
    ```
    - Поиск слова в тексте
    ```python
    def is_hello_in_text (text):
        if 'hello' in text.lower():
            return True
        else: 
            return False
    print (is_hello_in_text('Say hello'))

    ИЛИ

    def is_hello_in_text('Say hello'):
        return 'hello' in text lower()
    print (is_hello_in_text ('Hello everyone!'))
    ```
    - Поиск (сочетания) букв в тексте
    ```python
    def is_string_in_text (string, text):
        return string in text
    print (is_string_in_text('he','The apple')) -> True 
    ```
    ```python
    def greeting_depends_on_gender(name, gender):
        if gender == 'male':
            print ('Hello '+ name + '! You are look great!')
            return gender # return пишем в конце цикла, после него ничего в текущ. цикле не ставим
        elif gender == 'female':
            print ('Hello ' + name + '! You are so nice!')
            return gender
        else:
            print ('Hello ' + name + "! I've never see the creture like you!")
    return_value = greeting_depends_on_gender ('Jack', 'male')
    ```
    ## Методы build-in method
    ВИД:  ``x.append()``

    ## *Args, **kwargs
    
    ### Позиционные (positional) и именованные (keyword) аргументы 
    - Здесь каждый параметр относится к каждому аргументу
    ```python
    def printThese(a,b,c): # это параметры
        print(a, "is stored in a")
        print(b, "is stored in b")
        print(c, "is stored in c")
    printThese(1,2,3) # это аргументы
                      
                      # для вывода нужно записать все аргументы, иначе eror, но если задать в параметрах c=None, то можно не писать аргумент, параметр становится опциональным
    """
    1 is stored in a
    2 is stored in b
    3 is stored in c
    """
    ```
    - Опциональные параметры можно использовать для назначения аргументов
    ```python
    def printThese(a=None,b=None,c=None):
        print(a, "is stored in a")
        print(b, "is stored in b")
        print(c, "is stored in c")
    printThese(c=3, a=1) # Порядок можно ставить как угодно, но вывод все равно последовательный
    """
    1 is stored in a
    None is stored in b      #Ничего не указали, поэтому None
    3 is stored in c
    """
    ```
    ```python
    def func_kwargs(**kwargs):
        print(kwargs)
    func_kwargs(first=1,second=2,third=3) -> {'first':1,'second':2,'third':3}
    ```
    
    ### Оператор '*'
    Этот оператор позволяет «распаковывать» объекты, внутри которых хранятся некие элементы. Пример:
    ```python
    a = [1,2,3]
    b = [*a,4,5,6]
    print(b) -> [1,2,3,4,5,6]
    ```
    ### Использование *args, **kwargs
    - __*args__ — это сокращение от «arguments» (аргументы),
    - __**kwargs__ — сокращение от «keyword arguments» (именованные аргументы)
    
    Каждая из этих конструкций используется для распаковки аргументов соответствующего типа, позволяя вызывать функции со списком аргументов переменной длины. 

    - Например — функция, которая умеет выводить результаты, набранные учеником в тесте:
```python
def printScores(student, *scores): 
   print(f"Student Name: {student}")
   for score in scores:
      print(score)
printScores("Jonathan",100, 95, 88, 92, 99) # 'student'- аргумент, 'scores' - именной аргумент
"""
Student Name: Jonathan
100
95
88
92
99
"""
```
- Для **kwargs аргументов создается словарь, в котором содержатся именованные аргументы
```python
def printPetNames(owner, **pets):
   print(f"Owner Name: {owner}")
   for pet,name in pets.items():
      print(f"{pet}: {name}")
printPetNames("Jonathan", dog="Brock", fish=["Larry", "Curly", "Moe"], turtle="Shelldon")
"""
Owner Name: Jonathan
dog: Brock
fish: ['Larry', 'Curly', 'Moe']
turtle: Shelldon
"""
```
- Конструкцию **kwargs нельзя располагать до *args. Если это сделать — будет выдано сообщение об ошибке.
- *x в списке формальных аргументов — обозначает, что принимается произвольное число аргументов, которые в теле процедуры будут доступны в кортеже под именем x. (slurp)
- *x в вызове процедуры — обозначает, что коллекция x распаковывается подставляется как отдельные аргументы. (splat)
Пример: 
```python
first, *rest = 1, 2, 3, 4
print(rest)  
# [2, 3, 4]

ИЛИ списки

first, *rest = [1, 2, 3, 4] 
print(rest)  
# [2, 3, 4]
```
- Нахождение 10 проуентов от произведения параметров обычным образом
```python
def ten_perc(x,y)
    return (x*y) * 0,1 # 10 процентов от произведения x и y
ten_perc(10,20) -> 20.0
```
- 
```python
def ten_perc(*args):
    print(args)
ten_percent (10,20,7,2) -> (10,20,7,2) # tuple
```
```python
def ten_perc (*args):
    product=1
    for num in args:
        product=product*num
    return product*(0.1)
print(ten_perc(10,20))
```
- использование {} .format c kwargs
```python
def hello_kwargs(**kwargs):
    if name is kwargs:
        print('Hello! Nice to meet you, {}'.format(kwargs['name'])) # ключ 'name' должен быть str
    else:
        print('Hello! What is your name?')
hello_kwargs (gender = male, age = 24, name ='Jack') -> Hello! Nice to meet you, Jack 
```
```python
def hello_kwargs(greeting,**kwargs):
    if 'name' in kwargs:
        print('{}! Nice to meet you, {}'.format(greeting, kwargs,['name'])) # на первом месте позиционный пар-р (greeting)
    else:
        print ('{}! What is your name?'.format(greeting))
hello_kwargs('Hi', gender = 'male', name = 'Jack')
```
```python
def func_args_kwargs (*args,**kwargs):
    print(args)
    print(kwargs)
func_args_kwargs('one','two', drink = 'coffee', food = 'sandwich')
print ('i would like to {}{}'.format(args[0],kwargs['food'])) -> I would like one sandwich 
```

## Лямбда выр.функции

```python
def sum_of_two_num(x):
    return x + x
```