python_math_stat/docs/python/defolt_python.md

Python

Интерпретированный обьектно-ориентированный ЯП

• Строго тиризированные данные
• Динамично типизирован

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

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

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

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

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

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

""" _ """ - игнорируют любые символы внутри

• из списка подряд цифры через пробел

L = [1, 2, 3, 4, 5]
print(*L)

Строки в Python

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

Св-ва: \

1. Immutable - неизменяемые. Если созд. строку, то через терм не можем менять

a1 = 'ABcd' 
print (1[1]) -> b

a1[1] = 2 -> (FAIL)

2. Concate - можем скреплять строки
3. Muttyplication - усножение

yummy = 'yum'
print(yummy*2) -> yumyum

Методы:
yummy.upper() - делает все буквы заглавные (НОВАЯ строка)
yummy.lower() - наоборот (НОВАЯ строка)

Форматирование строк

name = 'Jack'
age = 23
name_and_age = 'My name is {0}. I\'m {1} years old'.format(name,age)' #можно сразу переменные без цифр

-> Можно {} в разном порядке, можно без цифр сразу переменные писать \

Таблица

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

print(ord('a')) -> 97
print(ord('b')) -> 98
print(ord('a' > 'b')) -> Falseа
print('hi'>'hello') -> True # Отличие в первых отличающихся знаках ('i'= 105 'e'= 101)

• Программа вывода True, если ввести 18 и более лет

age = int(input('input your age'))
print('Your age is' + str(age))
print('Access is permitted' + str(age >= 18)) -> True

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()

---

• строки

print ('a' in "Jack") -> True  # такая буква есть в слове, по сути не вводим переменные и списки/листы

• списки

list = ['a','b','c']
    print ('a' in list) -> True  # такая буква есть в спискe

• словари

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

x = 1
y = 2
x>1 and y>1 -> False
x>1 or y>1 -> True
not x>1 -> True

Условный оператор if, elif, else

---

• Пример:

x = 3 
if x>3:
    print('x>3')
elif x<3:
    print('x<3')
else:
    print('x == 3') -> x==3

• Четное / Нечетное

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

• Посл-ти: строки, списки, словари, мн-ва и др. - для перебора используется цикл

list = [1,2,3,4,5]
for number(любое значение) in list:
    print(number) -> 1
                     2
                     3
                     4
                     5
    print('Hi') #выдаст столько раз сколько эл-тов в списке

• Для подсчета суммы значений в списке

sum = 0
for num in list:
    sum = sum + num
print (sum) -> 10

• цикл for для tuple

tuple = [('a','b'),('c','d'),('e','f')]
for item im tuple:
    print (item) -> ('a','b')
                    ('c','d')
                    ('e','f')

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() - и ключ и значения

for items in dict.items():
    print(item) -> ('key1','value1')
                   ('key2','value2')

.keys() - только ключи

dict = {'key1':'value1','key2':'value2'}
for item in dict.keys():
    print(key) -> key1
                  key2 

.values() - только значения

dict = {'key1':'value1','key2':'value2'}
for item in dict.values():
    print(values) -> value1
                     value2 

Цикл while

Выполняется до тех пор, пока какое-то условие не станет True

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 - (ничего не делать)

list = [1,2,3]
for i on list:
    pass     # ничего не делать

• break - если True - выход из цикла

list = [1,2,3]
for i on list:
    if i ==2:
        break  # если True - выход из цикла
    print(i) -> 1 

continue - если True - переход в начало цикла

list = [1,2,3]
for i on list:
    if i ==2:
        continue  # если True - переход в начало цикла 
    print(i) -> 1 # пропустили эл-т 2
                3

Range()

Функция range() - часто используется для повторения опр. действий несколько раз

for x in range(n): # n не включено
    print(n) -> 0
                1
                2 # n не включено

• диапазон range(k,n)

for x in range(k,n): # n не включено
    print(n) -> k
                k+1
                k+2
                ... # n не включено

• диапазон range(k,n) + шаги range(k,n,l)

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])

list = [num for num in range(0,10)] # первый num можно опустить
print (list) -> [0,1,2,3...9] # 10 не вкл

• для операций типа степеней\корней и пр.

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] - наоборот слово

Различные операции с индексами

• указать индекс каждого эл-та в списке/строке

index = 0
my_str = 'agdjfh'
for letters in my_str:
    print (letter + 'is at index' + str(index))
    index += 1

• enumerate() указать индекс каждого эл-та в списке/строке

index = 0
my_str = 'agdjfh'
for letters in enumerate(my_str):
    print (letter) -> (0, 'a')
                      (1, 'g')
                      ...

• (распаковка) enumerate()

index = 0
my_str = 'agdjfh'
for index, letters in enumerate(my_str):
    print (letter + 'is at index' + str(index)) 

Добавление библиотек

• Добавление предустановленных библиотек

import pandas as pd

• Пример использования

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

    str = 'Hello'
    list = []
    for i in str:
        list.append(letter) # добавляет эл-т в конец списка (в данном случае добавляем с 1 эл-та)
    print(list) -> ['h','e','l',,...]
  

  • способ №2

  str = 'Hello'
  list = []
  list = [for i in str]
  print (list) -> ['h','e','l',,...]
  

  • для перебора цифр и заключение их в список

  list = [num for num in range(0,10)] # первый num можно опустить
  print (list) -> [0,1,2,3...9] # 10 не вкл
  

  • для операций типа степеней\корней и пр.

  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

  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

  list = ['+' if number > 0 else '-' for number in number_list]
  

  Функции

  • код, кот. вып. фун-цию и назван именем ВИД: set()

  Виды:

  • без возращаемого значения (без return, справочное)
  • без параметров (def():)
  • произвольные число параметров (def min(*a))

  def min(*a):
      m=a[0]
      for x in a:
          if m>x:
              m=x
      return m
  

  • параметры со значениями по умолчанию (print(a,end=''))
  • пример функции, которая показывает сколько эл-тов между числами

  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()

  print (min(1,2,3,4)) -> 1
  

  • min() | max() работают также с листами по аскикоду

  print(max('Hello')) -> o # по аскикоду о = 111
  

  ---

  • метод .reverse() и ф-я reversed() - нужны чтобы сделать обратный порядок эл-тов [::-1]

  list = [1,2,3,4,5]
  print (list.reverse()) -> [5,4,3,2,1]
  

  метод .reverse()

  • не возвращает новый списокб изменяет существующий
  • применяется только к изменяемым посл-тям

  ф-я reversed()

  • применяется ко всем посл-тям (строки, списки, кортежи(tuple) и диапазоны(range))
  • возвращает обратный итератор, а не изменяет, т.е. чтобы вывести нужно сконвертировать в нужный тип

  # список
  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]

  users = ['Ваня', 'Коля', 'Маша']
  del users [0] # удаляем ваню
  print (users) -> ['Коля', 'Маша']
  

  метод .pop() - удаляет последний эл-т из списка, но возвращает его

  • также можно удалять по индексу .pop(index)

  метод .remove() - удаление по значению (только первое которое нашел, чтобы удалить все - исп цикл)

  • не возвращает

  users = ['Иванов', 'Сидоров', 'Петров', 'Иванов']
  users.remove('Петров')
  

  ---

  • Функция strip() - для возврата копии исходной строки путем удаления начальных и конечных пробелов, символов (в качестве аргументов), переданных в функцию strip(). strip( 'characters' )
    • если не ставить параметр chars , то удалит начальные и конечные пробелы из строки
    • если поставить, то удалит выбранные символы
    • возвращает копию исходной строки

  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 название фунц(аргументы)

  • можно использовать рез-т функции в этой же функции:

  m = min2(42,30) # функция минимума 2 чисел
  m = min2(min2(42,30),25)
  

  def print_greeting():
      ''' # доксрин
      print 'Hello' text 
      :return: None
      '''
      print ('Hello')
  print_greeting() -> Hello 
  

  • help

  help(print_greeting) # вызов докскрина
  

  • функция с параметрами

  def print_greeting_with_name(name): # чтобы вызвать без параметра, можно просто написать имя 'Jack' , но тогда и вывод с принтом будет выглядеть иначе
      '''
      :param name
      :return: None
      '''
      print ('Hello' + name + '!')
  print (greeting ... ('Jack')) -> Hello Jack!
  

  def f(n):
      return n * 10 + 5
      print(f(f(f(10)))) -> 10555
      # f(10) -> 100+5=105
      #f(105) -> 1055
      #f(1055) -> 10555
  

  Возвращенная функция

  • сумма двух чисел

  def sum_two_num (a,b):
      return a+b
  x = sum_two_num (1,1)
  print (x) -> 2
  

  • Поиск слова в тексте

  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!'))
  

  • Поиск (сочетания) букв в тексте

  def is_string_in_text (string, text):
      return string in text
  print (is_string_in_text('he','The apple')) -> True 
  

  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')
  

  Локальные переменные внутри функции

  • параметры внутри функции локальные, мы не можем пользоваться ими вне функции
  • изменение значений, например, списка

  def append_zero(xs):
      xs.append(0)
      # xs= [100]- новый список, поэтому не повлияет на a
  a =[]
  append_zero(a)
  print(a) -> [0]
  

  • также мы можем изменять данные из глобального списка внутри локального:

  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
  

  Глобальные переменные

  • переменные, которые обьявлены все всяких функций

  def print_value():
      print(a) # не обьявлена внутри функции, т.е нет a= 5
  a = 5
  print_value() -> 5
  

  def print_value():
      print
  

  Методы build-in method

  ВИД: x.append()

  *Args, **kwargs

  Позиционные (positional) и именованные (keyword) аргументы

  • Здесь каждый параметр относится к каждому аргументу

  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
  """
  

  • Опциональные параметры можно использовать для назначения аргументов

  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
  """
  

  def func_kwargs(**kwargs):
      print(kwargs)
  func_kwargs(first=1,second=2,third=3) -> {'first':1,'second':2,'third':3}
  

  Оператор '*'

  Этот оператор позволяет «распаковывать» объекты, внутри которых хранятся некие элементы. Пример:

  a = [1,2,3]
  b = [*a,4,5,6]
  print(b) -> [1,2,3,4,5,6]
  

  Использование *args, **kwargs

  • *args — это сокращение от «arguments» (аргументы),
  • **kwargs — сокращение от «keyword arguments» (именованные аргументы)

  Каждая из этих конструкций используется для распаковки аргументов соответствующего типа, позволяя вызывать функции со списком аргументов переменной длины.

  • Например — функция, которая умеет выводить результаты, набранные учеником в тесте:

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 аргументов создается словарь, в котором содержатся именованные аргументы

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) Пример:

first, *rest = 1, 2, 3, 4
print(rest)  
# [2, 3, 4]

ИЛИ списки

first, *rest = [1, 2, 3, 4] 
print(rest)  
# [2, 3, 4]

• Нахождение 10 проуентов от произведения параметров обычным образом

def ten_perc(x,y)
    return (x*y) * 0,1 # 10 процентов от произведения x и y
ten_perc(10,20) -> 20.0

def ten_perc(*args):
    print(args)
ten_percent (10,20,7,2) -> (10,20,7,2) # tuple

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

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 

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')

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

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:

for item in result:
    print(item) -> 2 (1+1)
                   4 (2+2)
                   6 (3+3)
                   ...
                   14 (7+7)

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

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:

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()

my_list = ["....ru", "-", "хороший", "сайт"]
print(" ".join(my_list)) # " " - пустое место- это разделитель дря строк 
->  ....ru - хороший сайт

• для списка чисел подойдет .map() для приведения всех цифр к строке и склеить их .join()

my_list2 = [66, 77, 88, 99]
print(" ".join(map(str, my_list2))) -> 66 77 88 99

• чтобы делить с запятой shortcut кода

my_list3 = [11, 22, 33, 44, 55]
print(str(my_list3).strip('[]')) # подробнее о .strip() в разделе функций
-> 11, 22, 33, 44, 55

строку в список

a = input().split(" ")
a = list(a)

ИЛИ
list(string)

ИЛИ 
string.split()

Записать так, чтобы регистр всех букв при вводе был lower(or upper), а каждое отдельное слово было отдельным элементом:

text = input().lower().split()

Чтение из файла

inf = open('file.txt') # сразу на чтение, но можно указать параметр ('file.txt', 'r')

  inf = open('file.txt')
  s1 = inf.readline() #чтение одной строки
  s2 = inf.readline()
  inf.close() #после окончания 

-> Эквивалент, сам закрывает без close

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 # позволяет склеить части в путь для разных ОС, слеши в разные стороны

#чтение всех строк

with open('input.txt') as inf:
    for line in inf: # читает построчно
        line=line.strip() #убирает символ \n в конце строки
        print(line)

Запись из файла

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))