Функция в int python: Функции int() | Python

Функции int() | Python

В языке программирования Python встроенная функция int() возвращает целое число в десятичной системе счисления (класс int).

Если вызвать функцию int() без аргументов, она вернет 0.

Чаще всего функции int() передают только один аргумент, который может быть либо строкой, либо числом. Строки должны быть символьными представлениями целого числа, иначе будет сгенерирована ошибка ValueError.

>>> int('4')
4
>>> int('3a')
Traceback (most recent call last):
  File "<pyshell#29>", line 1, in <module>
    int('3a')
ValueError: invalid literal for int() with base 10: '3a'

Если передать функции целое число, то она вернет его же. Если передать вещественное число, то оно будет округлено до целого в сторону нуля (т. е. дробная часть будет отброшена).

>>> int(87)
87
>>> int(-103)
-103
>>> int(234.879)
234
>>> int(-0.3)
0
>>> int(-0.9)
0

Попытка преобразовать строку, содержащую вещественное число, в целое число с помощью функции int() вызывает ошибку.

>>> int('101.1')
Traceback (most recent call last):
  File "<pyshell#37>", line 1, in <module>
    int('101.1')
ValueError: invalid literal for int() with base 10: '101.1'

Отсюда следует, что если требуется преобразовать дробное число в строковом представлении в целое число, сначала надо использовать функцию float(), а затем int().

>>> a = '15.76'
>>> a = float(a)
>>> a
15.76
>>> a = int(a)
>>> a
15

В случае, когда указывается второй аргумент для функции int(), первый всегда должен быть строкой. С помощью второго аргумента функции int() сообщается, в какой системе счисления находится число, указанное в строке первого аргумента. Функция int() возвращает его значение в десятичной системе счисления.

>>> int('12',8)
10
>>> int('13h',20)
477
>>> int('111001',2)
57

Для двоичной, восьмеричной и шестнадцатеричной систем счисления можно использовать префиксы. Если такое представление числа заключается в кавычки, то второй аргумент обязателен.

>>> int(0b11)
3
>>> int('0b11')
Traceback (most recent call last):
  File "<pyshell#48>", line 1, in <module>
    int('0b11')
ValueError: invalid literal for int() with base 10: '0b11'
>>> int('0b11',2)
3
>>> int(0o10)
8
>>> int(0x15)
21
>>> int(0xA5)
165

Итак, функция int() всегда возвращает десятичное целое число. Если преобразовать первый аргумент в десятичное число не удается, то генерируется ошибка.

Python | функция int ()

Функция int () в Python и Python3 преобразует число в данной базе в десятичное.

Синтаксис:

int(string, base)

Параметр:

string : consists of 1's and 0's
base : (integer value) base of the number.

Возвращает:

Returns an integer value, which is equivalent 
of binary string in the given base. 

Ошибки:

TypeError : Returns TypeError when any data type other 
than string or integer is passed in its equivalent position.

Код № 1:

Выход :

int('187') + 13 =  200 

int('100') with base 2 =  4
int('100') with base 4 =  16
int('100') with base 8 =  64
int('100') with base 16 =  256

Код № 2:

Выход :

Decimal equivalent of binary 111 is 7
Octal equivalent of binary 101 is 65

Код № 3: Программа для демонстрации ошибки TypeError.

Выход :

Traceback (most recent call last):
  File "/home/d87cec4c0c33aad3bb6187858b40b734.py", line 8, in 
    decimal = int(binaryString, 2)  
TypeError: int() can't convert non-string with explicit base

,

Заявка :
Используется во всех стандартных конверсиях . Например, преобразование двоичного в десятичное, двоичное в восьмеричное, двоичное в шестнадцатеричное.

Рекомендуемые посты:

Python | функция int ()

0.00 (0%) 0 votes

Про Python — Справочник — int

Тип представляет целое число.

Целые имеют неограниченную точность.

Целые литералы (не важно в шестнадцатеричном, восьмеричном или двоичном представлении) создают целый тип.
Создать экземпляр типа также можно при помощи конструктора int().

    int(x, base=10)

Если первый аргумент является строкой, то должен представлять число. Такая строка может содержать знак числа, а также пробельные символы (как ведущие так и заключительные).
Если передано целое, «длинное» целое, либо число с плавающей запятой) будет возвращено целое с тем же значением.
Приведение числа с плавающей запятой к целому усекает его в сторону нуля.

Основание, передаваемое аргументом base, может быть указано только если первый аргумент является строкой, иначе поднимается TypeError.

    my_int = 1
my_int = 0x1  # Шестнадцатеричный вид
my_int = 0o1  # Восьмеричный вид
my_int = 0b1  # Двоичный вид
my_int = int('1')
my_int = int(1.1)  # 1
my_int = int(' 1')  # 1
my_int = int()  # 0
my_int = int(10, 2)  # TypeError: int() can't convert non-string with explicit base
my_int = int('10', 2)  # 2

Объекты целых от -5 по 256 создаются автоматические при старте интерпретатора — кешируются как часто используемые.

Python 2

Обычные целые (или просто «целые») реализованы при помощи типа long из Си, что даёт им не менее 32 бит точности (sys.maxint всегда установлен в максимум для обычных целых на данной платформе; минимальное значение — -sys.maxint - 1). «Длинные» — long — целые имеют неограниченную точность (в Python 3 все целые являются «длинными»).Логический Булев тип является подтипом целого.

7 примеров функций Python с параметрами, возвратом и типом данных

Функции – это фрагменты кода в блоке, которому назначено имя. Они принимают ввод, выполняют вычисления или действие и возвращает вывод.

Функции улучшают возможность повторного использования кода.

В этой статье мы обсудим следующие примеры:

1. Пример базовой функции Python
2. Встроенные функции Python
3. Пользовательские функции Python
4. Параметры функции Python
5. Функция Python. Неизвестное количество параметров
6. Возвращаемое значение функции Python
7. Тип данных для параметра s и возвращаемого значения

1. Пример базовой функции Python

Ниже приведен пример функции Python, которая принимает два параметра, вычисляет сумму и возвращает вычисленное значение.

# определение и объявление функции
def calculate_sum(a,b):
  sum = a+b
  return sum

# Приведенная ниже инструкция называется вызовом функции
print(calculate_sum(2,3)) # 5

В Python есть две широкие категории функций: встроенные функции и пользовательские функции.

2. Встроенные функции Python

Есть много функций, которые идут вместе с Python, когда он установлен. Пользователю не нужно беспокоиться об определениях функций. print () – одна из наиболее часто используемых встроенных функций в Python.

print("Привет мир")
print(len("Меня зовут AndreyEx"))

Еще несколько примеров таких функций: len(), str(), int(), abs(), sum() и т. д.

Все встроенные функции, поддерживаемые Python3, здесь.

3. Пользовательские функции Python

Пользовательские функции объявляются с использованием ключевого слова def. Ключевое слово должно сопровождаться именем функции.

def calculate_si_amount(principal, rate, time):
  interest =  (principal*rate*time)/100
  return principal+interest

В этой функции окончательная сумма рассчитывается путем применения простого процента к основной сумме. Calculate_si_amount является именем функции. principal, rate и time являются параметрами, и функция возвращает рассчитанные данные.

Для функции не обязательно принимать параметры и возвращаемые значения. Это может сделать либо оба, либо один из них, либо ни одного. Ниже приведен пример функции, которая не принимает никаких параметров, но возвращает данные.

from random import seed, random
from random import random

def generate_random_number():
  seed(10)
  return random()

4. Параметры функции Python

Функция может иметь параметры по умолчанию.

def multiply(a, b=10):
  return a*b

multiply(12) # 120
multiply(2, 3) # 6
multiply(b=9) # Ошибка: None*9 недопустимо

В этой функции, если пользователь не задает второй параметр b, он предполагает, что он равен 10, но необходимо предоставить первый параметр.

5. Функция Python. Неизвестное количество параметров

Примечание

Если в функции, скажем, 4 параметра и для 2-го параметра определено значение по умолчанию, то 3-му и 4-му параметрам также следует присвоить значение по умолчанию.

Если число параметров, которые должна ожидать функция, неизвестно, тогда * args добавляется в определение функции в качестве одного из параметров. Этот параметр ожидает кортеж. Звездочка (*) здесь важна. Название args – это просто соглашение. Ему можно дать любое другое имя.

def calculate_sum(a, *args):
  sum = a
  for i in args:
    sum += i
  return sum

calculate_sum(10) # 10
calculate_sum(10, 11, 12) # 33
calculate_sum(1, 2, 94, 6, 2, 8, 9, 20, 43, 2) # 187

Точно так же ** kwargs ожидает словарь в качестве параметра.

def print_names(f1, l1, **kwargs):
  print(f1, l1, end=' ')
  for key in kwargs:
    print(key, kwargs[key], end=' ')

print_names("andreyex", "master")
print_names("andreyex", "master", alex="john", leon="milene")
# andreyex master andreyex master alex john leon milene

Приведенный выше фрагмент кода имеет ссылку на цикл for. Обратитесь к этому для получения более подробной информации: 12 незаменимых примеров команды Loop в Python

6. Возвращаемое значение функции Python

Python позволяет функции возвращать несколько значений.

def prime_numbers(x):
  l=[]
  for i in range(x+1):
    if checkPrime(i):
      l.append(i)
  return len(l), l

no_of_primes, primes_list = prime_numbers(100)

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

Примечание

Если функция ничего не возвращает, она неявно возвращает None.

7. Тип данных для параметров и возвращаемого значения

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

def prime_numbers(x:int) -> (int, list):
  l=[]
  for i in range(x+1):
    if checkPrime(i):
      l.append(i)
  return len(l), l

Определение функции указывает, что ей нужен один параметр типа int и вернет два значения типа int и list соответственно.

На этом все. Удачи в программировании.

Если у вас есть какие-либо вопросы или предложения, дайте мне знать в разделе комментариев.

Если вы нашли ошибку, пожалуйста, выделите фрагмент текста и нажмите Ctrl+Enter.

Встроенные функции. Урок 14 курса «Python. Введение в программирование»

Язык Python включает много уже определенных, т. е. встроенных в него, функций. Программист не видит их определений, они скрыты где-то в «недрах» языка. Достаточно знать, что эти функции принимают и что возвращают, то есть их интерфейс.

Ряд встроенных функций, касающихся ввода-вывода и типов данных, мы уже использовали. Это print(), input(), int(), float(), str(), bool(), type(). Перечень всех встроенных в Python функций можно найти в официальной документации по языку: https://docs.python.org/3/library/functions.html . В переводе на русский можно посмотреть здесь: https://pythoner.name/documentation/library/functions .

В этом уроке рассмотрим следующие встроенные функции, условно разбив их на группы:

• функции для работы с символами – ord(), chr(), len()

• математические функции – abs(), round(), divmod(), pow(), max(), min(), sum()

Функция ord() позволяет получить номер символа по таблице Unicode. Соответственно, принимает она в качестве аргумента одиночный символ, заключенный в кавычки:

>>> ord('z')
122
>>> ord('ф')
1092
>>> ord('@')
64

Функция chr() выполняет обратное действие. Она позволяет получить символ по его номеру:

>>> chr(87)
'W'
>>> chr(1049)
'Й'
>>> chr(10045)
'✽'

Чтобы не путать ord() и chr(), помните, что функция – это действие. Ее имя как бы отвечает на вопрос «Что сделать?». Order – это порядок. Значит, мы хотим получить порядковый номер элемента в ряду. А чтобы получить номер, должны передать символ. Character – это символ. Значит, мы хотим получить символ. Поэтому должны передать порядковый номер.

Функция len() в качестве аргумента принимает объект, который состоит из более простых объектов, количество которых она подсчитывает. Числа – это простые объекты, их нельзя передавать в len(). Строки можно:

>>> len('abc')
3
>>> s1 = '------'
>>> s2 = '_______'
>>> len(s1) > len(s2)
False
>>> len(s1)
6
>>> len(s2)
7

Кроме строк в len() можно передавать другие, еще не изученные нами, структуры данных.

Функция abs() возвращает абсолютное значение числа:

>>> abs(-2.2)
2.2
>>> abs(9)
9

Если требуется округлить вещественное число до определенного знака после запятой, то следует воспользоваться функцией round():

>>> a = 10/3
>>> a
3.3333333333333335
>>> round(a,2)
3.33
>>> round(a)
3

Если второй аргумент не задан, то округление идет до целого числа. Есть одна специфическая особенность этой функции. Второй аргумент может быть отрицательным числом. В этом случае округляться начинают единицы, десятки, сотни и т. д., то есть целая часть:

>>> round(5321, -1)
5320
>>> round(5321, -3)
5000
>>> round(5321, -4)
10000

Функция именно округляет согласно правилу округления из математики, а не отбрасывает. Поэтому 5 тысяч неожиданно округляются до десяти.

>>> round(3.76, 1)
3.8
>>> round(3.72, 1)
3.7
>>> round(3.72)
4
>>> round(3.22)
3

Если нужно просто избавиться от дробной части без округления, следует воспользоваться функцией int():

>>> int(3.78)
3

Нередко функцию round() используют совместно с функцией print(), избегая форматирования вывода:

>>> a = 3.45673
>>> print("Number: %.2f" % a)
Number: 3.46
>>> print("Number:", round(a,2))
Number: 3.46

В последнем случае код выглядит более ясным.

Функция divmod() выполняет одновременно деление нацело и нахождение остатка от деления:

>>> divmod(10, 3)
(3, 1)
>>> divmod(20, 7)
(2, 6)

Возвращает она кортеж, извлечение данных из которого мы пока не изучали. В других языках нередко встречаются две отдельные функции: div() и mod(). Первая делит нацело, вторая находит остаток от целочисленного деления (деления по модулю). В Python и многих других языках для этого используются специальные символы-операнды:

>>> 10 // 3
3
>>> 10 % 3
1

Функция pow() возводит в степень. Первое число – основание, второе – показатель:

>>> pow(3, 2)
9
>>> pow(2, 4)
16

То же самое можно проделать так:

>>> 3**2
9
>>> 2**4
16

Однако pow() может принимать третий необязательный аргумент. Это число, на которое делится по модулю результат возведения в степень:

>>> pow(2, 4, 4)
0
>>> 2**4 % 4
0

Преимуществом первого способа является его более быстрое выполнение.

Функции max(), min() и sum() находят соответственно максимальный, минимальный элемент и сумму элементов аргумента:

>>> max(10, 12, 3)
12
>>> min(10, 12, 3, 9)
3
>>> a = (10, 12, 3, 10)
>>> sum(a)
35

В sum() нельзя передать перечень элементов, должна быть структура данных, например, кортеж. В min() и max() также чаще передают один так называемый итерируемый объект:

>>> max(a)
12

Практическая работа

1. Напишите программу, которая циклично запрашивает у пользователя номера символов по таблице Unicode и выводит соответствующие им символы. Завершает работу при вводе нуля.

2. Напишите программу, которая измеряет длину введенной строки. Если строка длиннее десяти символов, то выносится предупреждение. Если короче, то к строке добавляется столько символов *, чтобы ее длина составляла десять символов, после чего новая строка должна выводиться на экран.

3. Напишите программу, которая запрашивает у пользователя шесть вещественных чисел. На экран выводит минимальное и максимальное из них, округленные до двух знаков после запятой. Выполните задание без использования встроенных функций min() и max().

Примеры решения и дополнительные уроки в android-приложении и pdf-версии курса

Интроспекция в Python

Многие языки программирования поддерживают интроспекцию, и Python не является исключением. В общем, в контексте объектно-ориентированных языков программирования, интроспекция — это способность объекта во время выполнения получить тип, доступные атрибуты и методы, а также другую информацию, необходимую для выполнения дополнительных операций с объектом.

В этой статье мы рассмотрим пять самых полезных функций интроспекции в Python.

dir()

Первая функция — это функция dir(). Она предоставляет список атрибутов и методов, доступных для указанного объекта, который может быть объявленной переменной или функцией.

>>> a = [1, 2, 3]
>>> dir(a)
['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']

Как вы можете заметить, значение, которое вернула функция dir() — это отсортированный в алфавитном порядке список. Это подразумевает, что мы можем проверить существование определенного атрибута или метода, чтобы увидеть, может ли объект выполнить эту операцию. Пример приведен ниже.

>>> b = [1, 2, 3]
>>> b_dir = dir(b)
>>> 'index' in b_dir
True
>>> 'pop' in b_dir
True

При вызове функции dir() без аргумента она возвращает имена, доступные в локальной области видимости, как показано ниже. Это может быть полезно, если вы хотите проверить, что было определено и использовано в вашей программе.

>>> dir()
['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'a', 'b', 'b_dir']

type()

Другой часто используемой функцией интроспекции является функция type(). Как видно из названия, эта функция возвращает тип объекта, который может быть примитивным типом данных, объектом, классом или модулем. Давайте посмотрим на примеры ниже:

>>> type(1.2)
<class 'float'>
>>> type([1, 2, 3])
<class 'list'>
>>> type((3, 'Three'))
<class 'tuple'>
>>> def do_something():
... pass
... 
>>> type(do_something)
<class 'function'>
>>> class Fruit:
... pass
... 
>>> type(Fruit)
<class 'type'>
>>> type(Fruit())
<class '__main__.Fruit'>
>>> import os
>>> type(os)
<class 'module'>

Что мы можем сделать с возвращаемыми значениями из функции type()? Мы можем напрямую сравнить возвращаемое значение с типом, который мы хотим проверить, используя == или is. Ниже приведено несколько примеров.

>>> type(1.2) == int
False
>>> type(1.2) == float
True
>>> type([1,2]) == list
True
>>> type((1,2)) is tuple
True

isinstance()

Еще одной из функций интроспекции, которая особенно полезна, является функция isinstance(). Используя эту функцию, мы можем определить, является ли определенный объект экземпляром указанного класса. Простой пример приведен ниже.

>>> isinstance([1,2], list)
True
>>> isinstance([1,2], tuple)
False
>>> isinstance((1,2), tuple)
True

Следует также отметить, что функция isinstance() может принимать кортеж в качестве второго аргумента, как показано ниже.

>>> isinstance(1, (int, float, tuple))
True
>>> isinstance(1, int) or isinstance(1, float) or isinstance(1, tuple)

Рассмотрим более практический пример использования, который включает в себя пользовательский класс:

>>> class Fruit:
... pass
... 
>>> apple = Fruit()
>>> isinstance(apple, Fruit)
True

Возможно, вы заметили, что и type(), и isinstance() могут быть использованы для определения того, принадлежит ли указанный объект определенному типу. Тем не менее, они не одинаковы.

Когда мы используем type(), чтобы определить, принадлежит ли объект определенному типу, мы проводим сравнение один к одному. По сути, мы сравниваем тип объекта с типом, который мы указали, чтобы проверить, совпадают ли они.

А вот isinstance() является более гибкой функцией. Фактически она определяет, является ли объект экземпляром указанного класса (классов) или его подкласса.  Для isinstance() экземпляр подкласса также является экземпляром базового класса. Другими словами, она сравнивает объект со списком потенциально релевантных классов, что является своего рода сравнением один к нескольким. На рисунке ниже приведен пример работы функции.

hasattr()

Иногда, прежде чем получить доступ к атрибуту объекта, мы можем захотеть проверить, есть ли у него этот атрибут. Мы не хотим видеть следующую ошибку:

>>> class Fruit:
... pass
... 
>>> Fruit().tasty
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: 'Fruit' object has no attribute 'tasty'

Чтобы подобного не произошло, мы можем с помощью функции hasattr() проверить, есть ли у объекта такой атрибут, прежде чем обращаться к нему.

>>> class Fruit:
... tasty = True
... 
>>> fruit = Fruit()
>>> if hasattr(fruit, 'tasty'):
... print('The fruit is tasty')
... else:
... print('The fruit is not tasty')
... 
The fruit is tasty

Возможно, вы не обратили на это внимание, но мы можем использовать функцию dir() для достижения того же самого результата.

Как вы помните, функция dir() возвращает доступные атрибуты и методы для указанного объекта, так что мы можем напрямую сравнить, является ли атрибут одним из элементов возвращаемого списка. Ниже приведен обновленный код.

>>> class Fruit:
... tasty = True
... 
>>> fruit = Fruit()
>>> if 'tasty' in dir(fruit):
... print('The fruit is tasty')
... else:
... print('The fruit is not tasty')
... 
The fruit is tasty

id()

И последняя, но не менее важная функция интроспекции в Python — это функция id(). Она возвращает идентификатор указанного объекта. В CPython идентификатор объекта — это адрес объекта в памяти, который является уникальным для всех существующих объектов. Объекты могут иметь одинаковый идентификатор, если периоды их существования не пересекаются. Ниже приведен простой пример этой функции.

a = 2
b = 1
id(a)
140339209865072
id(b)
140339209865096

Один из распространенных примеров кода в Python — это обмен значений двух переменных. Этого можно добиться, просто выполнив следующий код a, b = b, a. Давайте посмотрим, что происходит после обмена.

id(a)
140339209865096
id(b)
140339209865072
a, b
(1, 2)

Как мы можем заметить, эти две переменные успешно поменялись местами, что видно из их адресов в памяти и значений.

Выводы

Проводить интроспекцию в Python очень удобно.

Если вы хотите узнать о более продвинутых  методах интроспекции в Python, то можете изучить модуль inspect.

Пять функций, которые были рассмотрены в этой статье, являются наиболее распространенными. Вы смело можете использовать их в своих проектах на Python.

Некоторые возможности Python о которых вы возможно не знали / Хабр

Предисловие

Я очень полюбил Python после того, как прочитал книгу Марка Лутца «Изучаем Python». Язык очень красив, на нем приятно писать и выражать собственные идеи. Большое количество интерпретаторов и компиляторов, расширений, модулей и фреймворков говорит о том, что сообщество очень активно и язык развивается. В процессе изучения языка у меня появилось много вопросов, которые я тщательно гуглил и старался понять каждую непонятую мной конструкцию. Об этом мы и поговорим с вами в этой статье, статья ориентирована на начинающего Python разработчика.

Немного о терминах

Начну пожалуй с терминов, которые часто путают начинающих Python программистов.

List comprehensions или генераторы списков возвращают список. Я всегда путал генераторы списков и выражения — генераторы (но не генераторы выражений!). Согласитесь, по русский звучит очень похоже. Выражения — генераторы это generator expressions, специальные выражения, которые возвращают итератор, а не список. Давайте сравним:

f = (x for x in xrange(100)) # выражение - генератор
c = [x for x in xrange(100)] # генератор списков

Это две совершенно разные конструкции. Первый возвращает генератор (то есть итератор), второй обычный список.

Generators или генераторы это специальные функции, которые возвращают итератор. Что бы получить генератор нужно возвратить функции значение через yield:

def prime(lst):
    for i in lst:
        if i % 2 == 0:
            yield i

>>> f = prime([1,2,3,4,5,6,7])
>>> list(f)
[2, 4, 6]
>>> next(f)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
StopIteration
>>>

Кстати, в Python 3.3 появилась новая конструкция yield from. Совместное использование yield и for используется настолько часто, что эти две конструкции решили объединить.

def generator_range(first, last):
    for i in xrange(first, last):
        yield i

def generator_range(first, last):
    yield from range(first, last)

Что такое контекстные менеджеры и для чего они нужны?

Контекстные менеджеры это специальные конструкции, которые представляют из себя блоки кода, заключенные в инструкцию with. Инструкция with создает блок используя протокол контекстного менеджера, о котором мы поговорим далее в этой статье. Простейшей функцией, использующей данный протокол является функция open(). Каждый раз, как мы открываем файл нам необходимо его закрыть, что бы вытолкнуть выходные данные на диск (на самом деле Python вызывает метод close() автоматически, но явное его использование является хорошим тоном). Например:

fp = open("./file.txt", "w")
fp.write("Hello, World")
fp.close()

Что бы каждый раз не вызывать метод close() мы можем воспользоваться контекстным менеджером функции open(), который автоматически закроет файл после выхода из блока:

with open("./file.txt", "w") as fp:
    fp.write("Hello, World")

Здесь нам не нужно каждый раз вызывать метод close, что бы вытолкнуть данные в файл. Из этого следует, что контекстный менеджер используется для выполнения каких либо действий до входа в блок и после выхода из него. Но функциональность контекстных менеджеров на этом не заканчивается. Во многих языках программирования для подобных задач используются деструкторы. Но в Python если объект используется где то еще то нет гарантии, что деструктор будет вызван, так как метод __del__ вызывается только в том случае, если все ссылки на объект были исчерпаны:

In [4]: class Hello:
   ...:     def __del__(self):
   ...:         print 'destructor'
   ...:

In [5]: f = Hello()

In [6]: c = Hello()

In [7]: e = Hello()

In [8]: del e
destructor

In [9]: del c
destructor

In [10]: c = f

In [11]: e = f

In [12]: del f # <- деструктор не вызывается

Решим эту задачу через контекстные менеджеры:

In [1]: class Hello:
   ...:     def __del__(self):
   ...:         print u'деструктор'
   ...:     def __enter__(self):
   ...:         print u'вход в блок'
   ...:     def __exit__(self, exp_type, exp_value, traceback):
   ...:         print u'выход из блока'
   ...:

In [2]: f = Hello()

In [3]: c = f

In [4]: e = f

In [5]: d = f

In [6]: del d

In [7]: del e

In [8]: del c

In [9]: del f # <- деструктор вызвался тогда когда все ссылки на объект были удалены
деструктор

Теперь попробуем вызвать менеджер контекста:

In [10]: with Hello():
   ....:     print u'мой код'
   ....:
вход в блок
мой код
выход из блока
деструктор

Мы увидели, что произошел гарантированный выход из блока после выполнения нашего кода.

Протокол контекстного менеджера

Мы уже кратко рассмотрели протокол контекстного менеджера написав небольшой класс Hello. Давайте теперь разберемся в протоколе более подробно. Что бы объект стал контекстным менеджером в его класс обязательно нужно включить два метода: __enter__ и __exit__. Первый метод выполняется до входа в блок. Методу можно возвратить текущий экземпляр класса, что бы к нему можно было обращаться через инструкцию as.

Метод __exit__ выполняется после выхода из блока with, и он содержит три параметра — exp_type, exp_value и exp_tr. Контекстный менеджер может вылавливать исключения, которые были возбуждены в блоке with. Мы можем вылавливать только нужные нам исключения или подавлять ненужные.

class Open(object):
    def __init__(self, file, flag):
        self.file = file
        self.flag = flag

    def __enter__(self):
        try:
            self.fp = open(self.file, self.flag)
        except IOError:
            self.fp = open(self.file, "w")
        return self.fp

    def __exit__(self, exp_type, exp_value, exp_tr):
        """ подавляем все исключения IOError """
        if exp_type is IOError:
            self.fp.close() # закрываем файл
            return True
        self.fp.close() # закрываем файл

with Open("asd.txt", "w") as fp:
    fp.write("Hello, World\n")

Переменная exp_type содержит в себе класс исключения, которое было возбуждено, exp_value — сообщение исключения. В примере мы закрываем файл и подавляем исключение IOError посредством возврата True методу __exit__. Все остальные исключения в блоке мы разрешаем. Как только наш код подходит к концу и блок заканчивается вызывается метод self.fp.close(), не зависимо от того, какое исключение было возбуждено. Кстати, внутри блока with можно подавлять и такие исключения как NameError, SyntaxError, но этого делать не стоит.

Протоколы контекстных менеджеров очень просты в использовании, но для обычных задач есть еще более простой способ, который поставляется вместе со стандартной библиотекой питона. Далее мы рассмотрим пакет contextlib.

Пакет contextlib

Создание контекстных менеджеров традиционным способом, то есть написанием классов с методами __enter__ и __exit__ не одна из сложных задач. Но для тривиального кода написание подобных классов требует больше возьни. Для этих целей был придуман декоратор contextmanager(), входящий в состав пакета contextlib. Используя декоратор contextmanager() мы можем из обычной функции сделать контекстный менеджер:

import contextlib
@contextlib.contextmanager
def context():
    print u'вход в блок'
    try:
        yield {}
    except RuntimeError, err:
        print 'error: ', err
    finally:
        print u'выход из блока'

Проверим работоспособность кода:

In [8]: with context() as fp:
   ...:     print u'блок'
   ...:
вход в блок
блок
выход из блока

Попробуем возбудить исключение внутри блока.

In [14]: with context() as value:
   ....:     raise RuntimeError, 'Error'
   ....:
вход в блок
error:  Error
выход из блока

In [15]:

Как видно из примера, реализация с использованием классов практически ничем не отличается по функциональности от реализации с использованием декоратора contextmanager(), но использование декоратора намного упрощает наш код.

Еще один интересный пример использования декоратора contextmanager():

import contextlib
@contextlib.contextmanager
def bold_text():
    print '<b>'
    yield # код из блока with выполнится тут
    print '</b>'

with bold_text():
    print "Hello, World"

Результат:

<b>Hello, World</b>

Похоже на блоки в руби не так ли?

И напоследок поговорим о вложенных контекстах. Вложенные контексты позволяют управлять несколькими контекстами одновременно. Например:

import contextlib
@contextlib.contextmanager
def context(name):
    print u'вход в контекст %s' % (name)
    yield name # наш блок
    print u'выход из контекста %s' % (name)

with contextlib.nested(context('first'), context('second')) as (first, second):
    print u'внутри блока %s %s' % (first, second)

Результат:

вход в контекст first

вход в контекст second

внутри блока first second

выход из контекста second

выход из контекста first

Аналогичный код без использования функции nested:

first, second = context('first'), context('second')
with first as first:
    with second as second:
        print u'внутри блока %s %s' % (first, second)

Этот код хоть и похож на предыдущий, в некоторых ситуациях он будет работать не так как нам хотелось бы. Объекты context(‘first’) и context(‘second’) вызываются до входа в блок, поэтому мы не сможем перехватывать исключения, которые были возбуждены в этих объектах. Согласитесь, первый вариант намного компактнее и выглядит красивее. А вот в Python 2.7 и 3.1 функция nested устарела и была добавлена новая синтаксическая конструкция для вложенных контекстов:

with context('first') as first, context('second') as second:
    print u'внутри блока %s %s' % (first, second)

range и xrange в Python 2.7 и Python 3

Известно, что Python 2.7 range возвращает список. Думаю все согласятся, что хранить большие объемы данных в памяти нецелесообразно, поэтому мы используем функцию xrange, возвращающий объект xrange который ведет себя почти так же как и список, но не хранит в памяти все выдаваемые элементы. Но меня немного удивило поведение xrange в Python 2.x, когда функции передаются большие значения. Давайте посмотрим на пример:

>>> f = xrange(1000000000000000000000)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
OverflowError: Python int too large to convert to C long
>>>

Python нам говорит о том, что int слишком длинный и он не может быть переконвертирован в C long. Оказывается у Python 2.x есть ограничения на целое число, в этом мы можем убедиться просмотрев константу sys.maxsize:

>>> import sys
>>> sys.maxsize
9223372036854775807
>>>

Вот оно максимальное значение целого числа:

>>> import sys
>>> sys.maxsize+1
9223372036854775808L
>>>

Python аккуратно переконвертировал наше число в long int. Не удивляйтесь, если xrange в Python 2.x будет вести себя иначе при больших значениях.

В Python 3.3 целое число может быть бесконечно большим, давайте проверим:

>>> import sys
>>> sys.maxsize
9223372036854775807
>>> range(sys.maxsize+1)
range(0, 9223372036854775808)
>>>

Конвертирование в long int не произошло. Вот еще пример:

>>> import sys
>>> sys.maxsize + 1
9223372036854775808
>>> f = sys.maxsize + 1
>>> type(f)
<class 'int'>
>>>

В Python 2.7

>>> import sys
>>> type(sys.maxsize + 1)
<type 'long'>
>>>

Не очевидное поведение некоторых конструкций

Думаю все согласятся, что простота питона заключена не в легкости его изучении, а в простоте самого языка. Питон красив, гибок и на нем можно писать не только в объектно ориентированном стиле, но и в функциональном. Но о поведении некоторых конструкций, который на первый взгляд кажутся странными необходимо знать. Для начала рассмотрим первый пример.

>>> f = [[]] * 3
>>> f[0].append('a')
>>> f[1].append('b')
>>> f[2].append('c')
>>>

Каков будет результат выполнения данной конструкции? Неподготовленный разработчик сообщит о результате: [[‘a’], [b’], [c’]]. Но на самом деле мы получаем:

>>> print f
[['a', 'b', 'c'], ['a', 'b', 'c'], ['a', 'b', 'c']]
>>>

Почему в каждом списке результат дублируется? Дело в том, что оператор умножения создает ссылки внутри нашего списка на один и тот же список. В этом легко убедиться немного дополнив наш пример:

>>> c = [[], [], []]
>>> hex(id(c[0])), hex(id(c[1])), hex(id(c[2]))
('0x104ede7e8', '0x104ede7a0', '0x104ede908')
>>>

>>> hex(id(f[0])), hex(id(f[1])), hex(id(f[2]))
('0x104ede710', '0x104ede710', '0x104ede710')
>>>

В первом случае все нормально и ссылки на списки разные, а во втором примере мы ссылаемся на один и тот же объект. Из этого следует, что изменение в первом списке повлечет за собой изменение в последующих, так что будьте внимательны.

Второй пример уже рассматривался на хабре, но мне захотелось включить его в статью. Посмотрим на lambda — функцию, которую мы будет прогонять через цикл for, и помещать каждую функцию в словарь:

>>> tmp = {}
>>> for i in range(10):
...     tmp[i] = lambda: i
>>> tmp[0]()
9
>>> tmp[1]()
9
>>>

В пределах lambda функции переменная i замыкается и как бы создается экземпляр еще одной переменной i в блоке lambda — функции, которая является ссылкой на переменную i в цикле for. Каждый раз когда счетчик цикла for меняется, меняются и значения во всех lambda функциях, поэтому мы получаем значение i-1 во всех функциях. Исправить это легко, явно передав lambda функции в качестве первого параметра значение по умолчанию — переменную i:

>>> tmp = {}
>>> for i in range(10):
...     tmp[i] = lambda i = i: i
>>> tmp[0]()
0

>>> tmp[1]()
1
>>>

Функция

python int () — qaru

Переполнение стека

1. Около

2. Продукты

3. Для команд

1. Переполнение стека
   Общественные вопросы и ответы

2. Переполнение стека для команд
   Где разработчики и технологи делятся частными знаниями с коллегами

3. Вакансии
   Программирование и связанные с ним технические возможности карьерного роста

4. Талант
   Нанимайте технических специалистов и создавайте свой бренд работодателя

5. Реклама
   Обратитесь к разработчикам и технологам со всего мира

6. О компании

.

Python int ()

Синтаксис метода int () :

int (x = 0, основание = 10) 

---

int () Параметры

int () метод принимает два аргумента:

• x — Число или строка, которые нужно преобразовать в целочисленный объект.
  Аргумент по умолчанию — ноль .
• base — Основание числа x .
  Может быть 0 (буквальный код) или 2-36.

---

Возвращаемое значение из int ()

int () метод возвращает:

• целочисленный объект из данного числа или строки обрабатывает базу по умолчанию как 10
• (без параметров) возвращает 0
• (если задано основание) обрабатывает строку с заданным основанием (0, 2, 8, 10, 16)

---

Пример 1. Как int () работает в Python?

  # целое число
print ("int (123) is:", int (123))

# float
print ("int (123.23) это: ", int (123.23))

# строка
print ("int ('123') is:", int ('123'))  

Выход

  int (123): 123
int (123.23): 123
int ('123'): 123 
 

---

Пример 2: Как int () работает для десятичных, восьмеричных и шестнадцатеричных чисел?

  # двоичный 0b или 0B
print ("Для 1010 int равно:", int ('1010', 2))
print ("Для 0b1010 int равно:", int ('0b1010', 2))

# восьмеричный 0o или 0O
print ("Для 12 int равно:", int ('12 ', 8))
print ("Для 0o12 int равно:", int ('0o12', 8))

# шестнадцатеричный
print ("Для A int равно:", int ('A', 16))
print ("Для 0xA int равно:", int ('0xA', 16))  

Выход

  Для 1010 int: 10
Для 0b1010 int: 10
Для 12 int равно: 10
Для 0o12 int: 10
Для A int равно: 10
Для 0xA int: 10 
 

---

Пример 3: int () для настраиваемых объектов

Внутренне метод int () вызывает метод объекта __int __ () .

Итак, даже если объект не является числом, вы можете преобразовать объект в целочисленный объект.

Вы можете сделать это, переопределив методы __index __ () и __int __ () класса, чтобы они возвращали число.

Эти два метода должны возвращать то же значение, поскольку более старые версии Python используют __int __ () , а более новые используют метод __index __ () .

  класс Человек:
    возраст = 23

    def __index __ (сам):
        вернуть себя.возраст
    
    def __int __ (сам):
        вернуть self.age

person = Человек ()
print ('int (человек) is:', int (человек))  

Выход

  int (человек): 23 
 

.

HOWTO по функциональному программированию — документация Python 2.7.18

Автор

Кучлинг А.М.

Выпуск

0,31

В этом документе мы познакомимся с функциями Python, подходящими для
реализация программ в функциональном стиле. После знакомства с
концепции функционального программирования, мы рассмотрим особенности языка, такие как
итераторы и генераторы и соответствующие библиотечные модули, такие как
itertools и functools .

Введение

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

Языки программирования поддерживают декомпозицию задач несколькими способами:

• Большинство языков программирования процедурные : программы — это списки
  инструкции, которые говорят компьютеру, что делать с вводом программы. C,
  Паскаль и даже оболочки Unix — это процедурные языки.

• На декларативных языках вы пишете спецификацию, описывающую
  проблема, которую нужно решить, и реализация языка выясняет, как
  выполнять вычисления эффективно. SQL — это декларативный язык, на котором вы
  скорее всего, знаком с; SQL-запрос описывает нужный набор данных
  для извлечения, и механизм SQL решает, сканировать ли таблицы или использовать индексы,
  какие подпункты выполнить в первую очередь и т. д.

• Объектно-ориентированные программы манипулируют коллекциями объектов.Объекты имеют
  внутреннее состояние и методы поддержки, которые запрашивают или изменяют это внутреннее состояние в
  каким-то образом. Smalltalk и Java — объектно-ориентированные языки. C ++ и Python
  языки, которые поддерживают объектно-ориентированное программирование, но не заставляют
  использование объектно-ориентированных функций.

• Функциональное программирование разбивает проблему на набор функций.
  В идеале функции принимают только входные данные и производят выходные данные и не имеют никаких
  внутреннее состояние, которое влияет на вывод, произведенный для данного ввода.Хорошо известный
  функциональные языки включают семейство ML (Standard ML, OCaml и другие
  варианты) и Haskell.

Разработчики некоторых компьютерных языков предпочитают выделять один конкретный
подход к программированию. Это часто затрудняет написание программ, которые
u

.Функция Python

в функции — qaru

Переполнение стека

1. Около

2. Продукты

3. Для команд

1. Переполнение стека
   Общественные вопросы и ответы

2. Переполнение стека для команд
   Где разработчики и технологи делятся частными знаниями с коллегами

3. Вакансии
   Программирование и связанные с ним технические возможности карьерного роста

4. Талант
   Нанимайте технических специалистов и создавайте свой бренд работодателя

5. Реклама
   Обратитесь к разработчикам и технологам со всего мира

6. О компании

Загрузка…

2. Авторизоваться
   зарегистрироваться

3. текущее сообщество
   

.

No related posts.