# 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 xstop: 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() ```