2023-10-12 21:32:13 +03:00
|
|
|
|
# Python
|
2023-10-13 13:12:24 +03:00
|
|
|
|
Интерпретированный обьектно-ориентированный ЯП
|
2023-10-12 21:32:13 +03:00
|
|
|
|
- Строго тиризированные данные
|
|
|
|
|
- Динамично типизирован
|
|
|
|
|
|
|
|
|
|
| Имя | Тип | Описание |
|
|
|
|
|
| ------------- |------------------:| :-----|
|
|
|
|
|
| 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__ - заменяет пробел в строке
|
|
|
|
|
|
|
|
|
|
__""" _ """__ - игнорируют любые символы внутри
|
2023-10-23 15:35:16 +03:00
|
|
|
|
- из списка подряд цифры через пробел
|
|
|
|
|
```python
|
|
|
|
|
L = [1, 2, 3, 4, 5]
|
|
|
|
|
print(*L)
|
|
|
|
|
```
|
2023-10-12 21:32:13 +03:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
## Строки в 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`
|
2023-10-13 13:12:24 +03:00
|
|
|
|
```python
|
|
|
|
|
list = ['+' if number > 0 else '-' for number in number_list]
|
|
|
|
|
```
|
2023-10-12 21:32:13 +03:00
|
|
|
|
|
2023-10-23 16:12:35 +03:00
|
|
|
|
## Функции
|
|
|
|
|
- код, кот. вып. фун-цию и назван именем
|
|
|
|
|
ВИД: ``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!
|
|
|
|
|
```
|
|
|
|
|
|
|
|
|
|
## Методы build-in method
|
|
|
|
|
ВИД: ``x.append()``
|
|
|
|
|
|
|
|
|
|
|
2023-10-12 21:32:13 +03:00
|
|
|
|
|