883 lines
32 KiB
Markdown
883 lines
32 KiB
Markdown
# 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
|
||
```
|
||
- для перебора цифр и заключение их в список (генератор списка `[for]`)
|
||
```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))
|
||
```
|
||
|
||
#### Добавление библиотек
|
||
- Добавление предустановленных библиотек
|
||
```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()``
|
||
|
||
Виды:
|
||
- без возращаемого значения (без `return`, справочное)
|
||
- без параметров (`def():`)
|
||
- произвольные число параметров (`def min(*a)`)
|
||
```python
|
||
def min(*a):
|
||
m=a[0]
|
||
for x in a:
|
||
if m>x:
|
||
m=x
|
||
return m
|
||
```
|
||
- параметры со значениями по умолчанию (`print(a,end='')`)
|
||
- пример функции, которая показывает сколько эл-тов между числами
|
||
```python
|
||
def my_range(start,stop,step=1): # Знак равно - это необязательный пункт, тут шаг необязательно вводить
|
||
res=[]
|
||
if step >0:
|
||
x= start
|
||
while x<stop:
|
||
res+=[x]
|
||
x+=step
|
||
elif step <0:
|
||
x=start
|
||
while x>stop:
|
||
res+=[x]
|
||
x+=step
|
||
return res
|
||
```
|
||
### Различные функции и методы
|
||
---
|
||
- `min()` | `max()`
|
||
```python
|
||
print (min(1,2,3,4)) -> 1
|
||
```
|
||
- `min()` | `max()` работают также с листами по аскикоду
|
||
```python
|
||
print(max('Hello')) -> o # по аскикоду о = 111
|
||
```
|
||
---
|
||
- метод `.reverse()` и ф-я `reversed()` - нужны чтобы сделать обратный порядок эл-тов [::-1]
|
||
```python
|
||
list = [1,2,3,4,5]
|
||
print (list.reverse()) -> [5,4,3,2,1]
|
||
```
|
||
> метод `.reverse()`
|
||
- не возвращает новый списокб изменяет существующий
|
||
- применяется только к изменяемым посл-тям
|
||
> ф-я `reversed()`
|
||
- применяется ко всем посл-тям (строки, списки, кортежи(tuple) и диапазоны(range))
|
||
- возвращает обратный итератор, а не изменяет, т.е. чтобы вывести нужно сконвертировать в нужный тип
|
||
```python
|
||
# список
|
||
my_list = [1, 2, 3, 4, 5]
|
||
reversed_list = list(reversed(my_list))
|
||
print(reversed_list) -> [5, 4, 3, 2, 1]
|
||
# кортеж
|
||
my_tuple = (1, 2, 3, 4, 5)
|
||
reversed_tuple = tuple(reversed(my_tuple))
|
||
print(reversed_tuple) -> (5, 4, 3, 2, 1)
|
||
# строка
|
||
my_string = "Hello, world!"
|
||
reversed_string = ''.join(reversed(my_string))
|
||
print(reversed_string) -> !dlrow ,olleH
|
||
```
|
||
---
|
||
- Удаление эл-тов из списка ``del``, ``.pop()``, ``.remove()``
|
||
> `del` + `list [index]`
|
||
```python
|
||
users = ['Ваня', 'Коля', 'Маша']
|
||
del users [0] # удаляем ваню
|
||
print (users) -> ['Коля', 'Маша']
|
||
```
|
||
> метод `.pop()` - удаляет последний эл-т из списка, но возвращает его
|
||
- также можно удалять по индексу `.pop(index)`
|
||
> метод `.remove()` - удаление по значению (только первое которое нашел, чтобы удалить все - исп цикл)
|
||
- не возвращает
|
||
```python
|
||
users = ['Иванов', 'Сидоров', 'Петров', 'Иванов']
|
||
users.remove('Петров')
|
||
```
|
||
---
|
||
- Функция strip() - для возврата копии исходной строки путем удаления начальных и конечных пробелов, символов (в качестве аргументов), переданных в функцию strip().
|
||
`strip( 'characters' )`
|
||
- если не ставить параметр `chars` , то удалит начальные и конечные пробелы из строки
|
||
- если поставить, то удалит выбранные символы
|
||
- возвращает копию исходной строки
|
||
```python
|
||
strinput = " $$$$$ No. 1 Welcome to JAVATPOINT!! No. 1 $$$ "
|
||
# use strip() function to remove the set of characters
|
||
res = strinput.strip ( ' $No. 10 !' ) # store result into res variable
|
||
print ( " Given string is: ", strinput)
|
||
print ( " After removing the set of characters: ", res)
|
||
|
||
ИЛИ символы
|
||
|
||
str5 = '++++++Python Programming Tutorial****** $$$$$'
|
||
print ("n Given string is = ", str5)
|
||
# use strip function to remove the symbols from both ends
|
||
str6 = str5. strip ( ' $*+' )
|
||
print (" Stripping the '+', '*' and '$' symbols on both sides of the string is = ", str6)
|
||
```
|
||
|
||
|
||
|
||
### Создание функций
|
||
Синтаксис : `def` название фунц(аргументы)
|
||
- можно использовать рез-т функции в этой же функции:
|
||
```python
|
||
m = min2(42,30) # функция минимума 2 чисел
|
||
m = min2(min2(42,30),25)
|
||
```
|
||
```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 f(n):
|
||
return n * 10 + 5
|
||
print(f(f(f(10)))) -> 10555
|
||
# f(10) -> 100+5=105
|
||
#f(105) -> 1055
|
||
#f(1055) -> 10555
|
||
```
|
||
|
||
### Возвращенная функция
|
||
- сумма двух чисел
|
||
```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')
|
||
```
|
||
### Локальные переменные внутри функции
|
||
- параметры внутри функции __локальные__, мы не можем пользоваться ими вне функции
|
||
- изменение значений, например, списка
|
||
```python
|
||
def append_zero(xs):
|
||
xs.append(0)
|
||
# xs= [100]- новый список, поэтому не повлияет на a
|
||
a =[]
|
||
append_zero(a)
|
||
print(a) -> [0]
|
||
```
|
||
- также мы можем изменять данные из глобального списка внутри локального:
|
||
```python
|
||
l= [1, 3, 4, 5] # глобальная переменная l с сущ. списком
|
||
def modify_list(l):
|
||
for i in range(len(l))[::-1]: # делаем в обратном порядке, чтобы избежать ошибки IndexError: list index out of range, которая практически запрограммирована при удалении элементов из списка во время итерирования по нему.
|
||
# после удаления элемента длина списка уменьшается а кортеж созданный range по длине списка остается неизменным и когда i принимает значение больше чем оставшаяся длина вашего списка то и вылетает ошибка IndexError: list index out of range.
|
||
# for i in reversed(range(len(l))): --> есть еще такой вариант с функцией `reversed()`
|
||
if l[i] %2 !=0: # если i нечетное ,то
|
||
l.remove(l[i]) # удаляем его из списка l
|
||
else:
|
||
l[i] = l[i]//2 # иначе оно четное , значит делим его на 2
|
||
modify_list(l) # выдаст None, т.к. задачей было не возвращать никаких значений
|
||
print(l) # выдаст - > [2] , т.е. изменили глобальную переменную l
|
||
|
||
ИЛИ
|
||
|
||
l = [1,2,3,4]
|
||
def modify_list(l):
|
||
l[:] = [i//2 for i in l if not i % 2] # генератор списка с условием (есть в конспекте)
|
||
# not здесь говорит, что остатка НЕ будет. Т.е при деление на 2, число без остатка, добавляют в копию списка
|
||
# L[:] - срез списка от начала до конца , если без [:], то глоб. L будет ссылаться на новый обьект, при этом исчезнут старые значения
|
||
modify_list(l) # выдаст None, т.к. задачей было не возвращать никаких значений
|
||
print(l) # выдаст - > [1,2] , т.е. изменили глобальную переменную l
|
||
```
|
||
|
||
### Глобальные переменные
|
||
- переменные, которые обьявлены все всяких функций
|
||
```python
|
||
def print_value():
|
||
print(a) # не обьявлена внутри функции, т.е нет a= 5
|
||
a = 5
|
||
print_value() -> 5
|
||
```
|
||
```python
|
||
def print_value():
|
||
print
|
||
```
|
||
|
||
|
||
## Методы 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
|
||
```
|
||
|
||
## Лямбда выр.функции
|
||
- функция без имени, которая вызывается 1 раз
|
||
- `map` - обьекты записываются как mapobject exm: 0x105ba3610
|
||
```python
|
||
def sum_of_two_num(x):
|
||
return x + x
|
||
num_list = [1,2,3,4,5,6,7]
|
||
result = map(sum_of_two_num, num_list) # sum...- функция, num... - посл-ть
|
||
print (result) -> mapobject at 0x105ba3610
|
||
```
|
||
- чтобы распаковать объекты `map`:
|
||
```python
|
||
for item in result:
|
||
print(item) -> 2 (1+1)
|
||
4 (2+2)
|
||
6 (3+3)
|
||
...
|
||
14 (7+7)
|
||
```
|
||
```python
|
||
def cube(num):
|
||
return num **3
|
||
num_list = [1,2,3,4,5,6,7]
|
||
print (list(map(cube(num_list)))) -> [1,8,27,64,125,216,343]
|
||
```
|
||
- вариант решения задачи с `modify_list`, но с `lambda`
|
||
```python
|
||
def modify_list(l):
|
||
l[:] = [x // 2 for x in filter(lambda x: x & 1, l)]
|
||
|
||
l = [10, 5, 8, 3]
|
||
print(l)
|
||
modify_list(l)
|
||
print(l) # [2, 1]
|
||
```
|
||
## Конвертация одних типов в другие
|
||
> СПИСОК --->> СТРОКА
|
||
- распаковка списка с помощью `*list`:
|
||
```python
|
||
num = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
|
||
print(*num) -> 0 1 2 3 4 5 6 7 8 9 10
|
||
```
|
||
- список строк -> `.join()`
|
||
```python
|
||
my_list = ["....ru", "-", "хороший", "сайт"]
|
||
print(" ".join(my_list)) # " " - пустое место- это разделитель дря строк
|
||
-> ....ru - хороший сайт
|
||
```
|
||
- для списка чисел подойдет `.map()` для приведения всех цифр к строке и склеить их `.join()`
|
||
```python
|
||
my_list2 = [66, 77, 88, 99]
|
||
print(" ".join(map(str, my_list2))) -> 66 77 88 99
|
||
```
|
||
- чтобы делить с запятой shortcut кода
|
||
```python
|
||
my_list3 = [11, 22, 33, 44, 55]
|
||
print(str(my_list3).strip('[]')) # подробнее о .strip() в разделе функций
|
||
-> 11, 22, 33, 44, 55
|
||
```
|
||
> строку в список
|
||
```python
|
||
a = input().split(" ")
|
||
a = list(a)
|
||
|
||
ИЛИ
|
||
list(string)
|
||
|
||
ИЛИ
|
||
string.split()
|
||
```
|
||
> Записать так, чтобы регистр всех букв при вводе был `lower(or upper)`, а каждое отдельное слово было отдельным элементом:
|
||
```python
|
||
text = input().lower().split()
|
||
```
|
||
|
||
# Чтение из файла
|
||
``inf = open('file.txt')`` # сразу на чтение, но можно указать параметр ('file.txt', 'r')
|
||
```python
|
||
inf = open('file.txt')
|
||
s1 = inf.readline() #чтение одной строки
|
||
s2 = inf.readline()
|
||
inf.close() #после окончания
|
||
```
|
||
-> Эквивалент, сам закрывает без close
|
||
```python
|
||
with open('text.txt') as inf:
|
||
s1 = inf.readline()
|
||
s2 = inf.readline()
|
||
```
|
||
## Функции для чтения файлов
|
||
```s = inf.readline().strip()``` #убирает все служебные символы
|
||
`\t abc \n.strip()` -> 'abc'
|
||
----
|
||
os.path.join('.', 'dirname', 'filename.txt') -> `./dirname/filename.txt` # позволяет склеить части в путь для разных ОС, слеши в разные стороны
|
||
----
|
||
#чтение всех строк
|
||
```python
|
||
with open('input.txt') as inf:
|
||
for line in inf: # читает построчно
|
||
line=line.strip() #убирает символ \n в конце строки
|
||
print(line)
|
||
```
|
||
# Запись из файла
|
||
```python
|
||
ouf = open('file.txt', 'w')
|
||
ouf.write('Some text\n') #print, но нудно указывать \n чтобы еревести
|
||
ouf.write(str(25)) # чтобы вывести число 25 нужно преобразовать его в строку str()
|
||
ouf.close()
|
||
|
||
with open('text.txt', 'w') as ouf:
|
||
ouf.write('Some text\n')
|
||
ouf.write(str(25))
|
||
``` |