Рубрики
Без рубрики

Лучшие примеры кода Python

Автор оригинала: FreeCodeCapm Team.

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

FreeCodeCamp имеет один из самых популярных курсов на Python. Это совершенно бесплатно (и даже не имеет никаких рекламных объявлений). Вы можете Смотрите это на YouTube здесь Отказ

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

Почти все реализации Python следуют спецификации IEEE 754: стандартный для бинарной арифметики с плавающей точкой. Больше информации найдено на IEEE сайт Отказ

Сплавные объекты могут быть созданы с использованием Плавучие точечные литералы :

>>> 3.14
3.14
>>> 314\.    # Trailing zero(s) not required.
314.0
>>> .314    # Leading zero(s) not required.
0.314
>>> 3e0
3.0
>>> 3E0     # 'e' or 'E' can be used.
3.0
>>> 3e1     # Positive value after e moves the decimal to the right.
30.0
>>> 3e-1    # Negative value after e moves the decimal to the left.
0.3
>>> 3.14e+2 # '+' not required but can be used for exponent part.
314.0

Числовые литералы не содержат знака, однако создание отрицательных объектов поплавлению возможна путем префикса с одинарным - (минус) оператор без места перед литералом:

>>> -3.141592653589793
-3.141592653589793
>>> type(-3.141592653589793)

Аналогично, положительные поплавные объекты могут быть префиксированы с одинарным + (плюс) оператор без места до буквального. Обычно + опущен:

>>> +3.141592653589793
3.141592653589793

Обратите внимание, что ведущие и тянущиеся ноль (ы) действительны для плавающих точек.

Аналогично, положительные поплавные объекты могут быть префиксированы с одинарным + (плюс) оператор без места до буквального. Обычно + опущен:

>>> +3.141592653589793
3.141592653589793

Обратите внимание, что ведущие и тянущиеся ноль (ы) действительны для плавающих точек.

>>> 0.0
0.0
>>> 00.00
0.0
>>> 00100.00100
100.001
>>> 001e0010      # Same as 1e10
10000000000.0

плавать Конструктор другой способ создать плавать объекты.

Создание плавать Объекты с плавающей точкой литералы предпочтителен, когда это возможно:

>>> a = 3.14         # Prefer floating point literal when possible.
>>> type(a)

>>> b = int(3.14)    # Works but unnecessary.
>>> type(b)

Однако поплавок конструктор позволяет создавать объекты поплавка от других типов чисел:

>>> a = 4
>>> type(a)

>>> print(a)
4
>>> b = float(4)
>>> type(b)

>>> print(b)
4.0
>>> float(400000000000000000000000000000000)
4e+32
>>> float(.00000000000000000000000000000004)
4e-32
>>> float(True)
1.0
>>> float(False)
0.0

плавать Конструктор также сделает плавать Объекты из строк, которые представляют числивые литералы:

>>> float('1')
1.0
>>> float('.1')
0.1
>>> float('3.')
3.0
>>> float('1e-3')
0.001
>>> float('3.14')
3.14
>>> float('-.15e-2')
-0.0015

плавать Конструктор также можно использовать для создания числовых представлений Нан (Не число), отрицательный Бесконечность и Бесконечность (Обратите внимание, что строки для них нечувствительны к регистру):

>>> float('nan')
nan
>>> float('inf')
inf
>>> float('-inf')
-inf
>>> float('infinity')
inf
>>> float('-infinity')
-inf

Комплексные числа

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

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

>>> a = 3.5j
>>> type(a)

>>> print(a)
3.5j
>>> a.real
0.0
>>> a.imag
3.5

Не существует литерала для создания сложного числа с ненулевыми реальными и воображаемыми частями. Чтобы создать номер ненулевой реальной части, добавьте воображаемую литературу на номер с плавающей запятой:

>>> a = 1.1 + 3.5j
>>> type(a)

>>> print(a)
(1.1+3.5j)
>>> a.real
1.1
>>> a.imag
3.5

Или использовать сложный конструктор Отказ

class complex([real[, imag]])

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

>>> complex(1, 1)
(1+1j)
>>> complex(1j, 1j)
(-1+1j)
>>> complex(1.1, 3.5)
(1.1+3.5j)
>>> complex(1.1)
(1.1+0j)
>>> complex(0, 3.5)
3.5j

А строка Также можно использовать в качестве аргумента. Ни один второй аргумент не допускается, если строка используется в качестве аргумента

>>> complex("1.1+3.5j")
(1.1+3.5j)

Bool () Встроенная функция в Python 3. Эта функция возвращает логическое значение, то есть true или false. Требуется один аргумент, х Отказ

Аргументы

Требуется один аргумент, х Отказ х преобразуется с использованием стандарта Процедура тестирования правды Отказ

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

Если х это ложь или опущена, это возвращает Ложь ; В противном случае это возвращает Правда Отказ

Образец кода

print(bool(4 > 2)) # Returns True as 4 is greater than 2
print(bool(4 < 2)) # Returns False as 4 is not less than 2
print(bool(4 == 4)) # Returns True as 4 is equal to 4
print(bool(4 != 4)) # Returns False as 4 is equal to 4 so inequality doesn't holds
print(bool(4)) # Returns True as 4 is a non-zero value
print(bool(-4)) # Returns True as -4 is a non-zero value
print(bool(0)) # Returns False as it is a zero value
print(bool('dskl')) # Returns True as the string is a non-zero value
print(bool([1, 2, 3])) # Returns True as the list is a non-zero value
print(bool((2,3,4))) # Returns True as tuple is a non-zero value
print(bool([])) # Returns False as list is empty and equal to 0 according to truth value testing

и , или , нет

Python Docs – Булевые операции

Это логические операции, заказанные по возрастанию приоритета:

ExpartmentResultnotes x или y, если x неверно, то y, else x (1) x и y, если x – false, то x, else y (2), а не х, если x ложный, то true, outs left (3).

Заметки:

  1. Это оператор короткого замыкания, поэтому он оценивает только второй аргумент, если первый является ложным.
  2. Это оператор короткого замыкания, поэтому он оценивает только второй аргумент, если первый верно.
  3. Не имеет более низкого приоритета, чем не-логические операторы, поэтому не интерпретируется как не (а), и A B – это синтаксическая ошибка.

Примеры:

нет:

>>> not True
False
>>> not False
True

а также:

>>> True and False    # Short-circuited at first argument.
False
>>> False and True    # Second argument is evaluated.
False
>>> True and True     # Second argument is evaluated.
True

или же:

>>> True or False    # Short-circuited at first argument.
True
>>> False or True    # Second argument is evaluated.
True
>>> False or False   # Second argument is evaluated.
False

Три широко используемые встроенные константы:

  • Правда : Истинное значение Bool тип. Назначения для Правда поднять SyntaxError Отказ
  • Ложь : Ложное значение Bool тип. Назначения для Ложь поднять SyntaxError Отказ
  • Нет : Единственное значение типа Неточный Отказ Ни один часто используется для представления отсутствия значения, так как при функции не передаются аргументы по умолчанию. Назначения для Нет поднять SyntaxError Отказ

Другие встроенные константы:

  • Утомленный : Специальное значение, которое должно быть возвращено бинарными специальными методами, такими как __eg __ () , __add __ () , __rsub __ () и т. Д.) Чтобы указать, что операция не реализована в отношении другого типа.
  • Эллипсис : Специальное значение, используемое в основном в сочетании с расширенными синтаксисом нарезки для пользовательских типов данных контейнера.
  • __debug__ : True, если Python не начался с опции-o.

Константы добавляют модуль сайта. Модуль сайта (который автоматически импортируется во время запуска, за исключением случаев, если задана параметр командной строки -s -s) добавляет несколько постоянных в встроенное пространство имен. Они полезны для оболочки интерактивного интерпретатора и не должны использоваться в программах.

Объекты, которые, когда напечатаны, напечатайте сообщение, такое как «Использовать Quit () или Ctrl-D (I.E. EOF), чтобы выйти из«, а также при вызове, повысить системуExit с указанным кодом выхода:

  • Quit (код = нет)
  • Выход (код = нет)

Объекты, которые, когда напечатаны, распечатайте сообщение, такую как «Тип лицензии (), чтобы увидеть полный текст лицензии», и при вызове, отобразите соответствующий текст в моде Pager (один экран одновременно):

  • Авторские права
  • лицензия
  • кредиты

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

>>> def say_hello():
...     print('Hello')
...
>>> say_hello()
Hello

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

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

>>> a = 1
>>> b = 10
>>> def fn():
...     print(a)    # local a is not assigned, no enclosing function, global a referenced.
...     b = 20      # local b is assigned in the local symbol table for the function.
...     print(b)    # local b is referenced.
...
>>> fn()
1
20
>>> b               # global b is not changed by the function call.
10

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

>>> def greet(s):
...     s = "Hello " + s    # s in local symbol table is reassigned.
...     print(s)
...
>>> person = "Bob"
>>> greet(person)
Hello Bob
>>> person                  # person used to call remains bound to original object, 'Bob'.
'Bob'

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

>>> def fn(arg):
...     arg.append(1)
...
>>> a = [1, 2, 3]
>>> fn(a)
>>> a
[1, 2, 3, 1]

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

По сравнению с другими языками программирования, класс класса Python добавляет классы с минимумом нового синтаксиса и семантики. Это смесь механизмов классов, найденных в C ++.

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

Объекты могут содержать произвольные количества и виды данных. Как и верно для модулей, классы, принимают участие в динамической природе Python: они созданы во время выполнения и могут быть изменены дальше после создания.

Синтаксис определения класса:

Самая простая форма определения класса выглядит так:

class ClassName:
    
        ...
        ...
        ...
    

Объекты класса:

Объекты класса поддерживают два вида операций: атрибуты ссылки и создания института.

Ссылки атрибутов Используйте стандартный синтаксис, используемый для всех употреблений атрибутов в Python: obj.name Отказ Допустимые имена атрибутов – это все имена, которые были в пространстве имен класса, когда был создан объект класса. Итак, если определение класса выглядело так:

class MyClass:
    """ A simple example class """
    i = 12345

    def f(self):
        return 'hello world'

Тогда Myclass.i и Myclass.f являются действительными ссылками атрибутов, возвращая целое число и объект функции соответственно. Атрибуты класса также могут быть назначены, чтобы вы могли изменить значение Myclass.i по заданию. __doc__ Также является действительным атрибутом, возвращая DOCSTRING, принадлежащую к классу: «Простой пример класса» Отказ

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

x = MyClass()

Создает новый экземпляр класса и присваивает этот объект локальной переменной X.

Операция по созданию инсультации («Вызов» объект класса) создает пустой объект. Многие классы любят создавать объекты с экземплярами, настроенными на определенное начальное состояние. Поэтому класс может определить специальный метод, названный init (), как это:

def __init__(self):
    self.data = []

Когда класс определяет __init __ () Метод, экземпляр классов автоматически вызывает __init __ () Для вновь созданного экземпляра класса. Таким образом, в этом примере новый инициализированный экземпляр может быть получен:

x = MyClass()

Конечно, __init __ () Метод может иметь аргументы для большей гибкости. В этом случае аргументы, приведенные оператору класса Asmentiation, передаются на __init __ () Отказ Например,

class Complex:
    def __init__(self, realpart, imagpart):
        self.r = realpart
        self.i = imagpart
              ...

x = Complex(3.0, -4.5)
>>> x.r, x.i
(3.0, -4.5)

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

Кодовые блоки и отступ

Одной из самых отличительных особенностей Python является использование вдавливания для отметки блоков кода. Рассмотрим if-stail из нашей простой программы проверки паролей:

if pwd == 'apple':
    print('Logging on ...')
else:
    print('Incorrect password.')

print('All done!')

Линии печатают («вход в систему …») и печать («Неверный пароль».) – два отдельных блока кода. Это происходит только одна строка, но Python позволяет писать блоки кода, состоящие из любого количества утверждений.

Чтобы указать блок кода в Python, вы должны отступить для каждой строки блока по той же сумме. Две блоки кода в нашем примере IF-оператора являются из-за четырех пробелов, что является типичным количеством отступа для Python.

На большинстве других языков программирования отступа используется только для того, чтобы помочь заставить код выглядеть красиво. Но в Python требуется для указания того, к какому блоку к коду следует относится оператор. Например, окончательная печать («все готово!») Не является отступом, и поэтому не является частью другого блока.

Программисты, знакомые с другими языками, часто щетины, мысль, что вдавливается, что имеет значение вдавливания: многие программисты, как свобода форматирования их кода, как они, пожалуйста. Тем не менее, правила вдавливания Python довольно просты, и большинство программистов уже используют вдавливание, чтобы сделать их код для чтения. Python просто делает эту идею еще один шаг вперед и дает смысл вдавливание.

Если/Элиф-заявления

ELIF-оператор IF/ELIF является обобщенным if-заявлением с более чем одним условием. Он используется для создания сложных решений. Например, предположим, что авиакомпания имеет следующий «ребенок». Отказ Следующая программа определяет, насколько пассажир должен оплатить:

# airfare.py
age = int(input('How old are you? '))
if age <= 2:
    print(' free')
elif 2 < age < 13:
    print(' child fare)
else:
    print('adult fare')

После того, как Python получает возраст от пользователя, он входит в действие IF/ELIF-оператор и проверяет каждое условие один за другим в том порядке, которому они даны.

Поэтому сначала он проверяет, если возраст меньше 2, и если да, то указывает, что летание свободно и выпрыгивает из Элифа-Состояния. Если возраст не менее 2, то он проверяет следующее ELIF-условию, чтобы увидеть, от возраста от 2 до 13. Если это так, он печатает соответствующее сообщение и выпрыгивает из оператора IF/ELIF. Если ни IF-условие, ни элиф-условие не верно, то он выполняет код в другом блоке.

Условные выражения

У Python есть еще один логический оператор, который вроде некоторых программистов (а некоторые не!). По сути, это означает, что сокращение обозначения для IF-утверждений, которые могут быть использованы непосредственно в пределах выражений. Рассмотрим этот код:

food = input("What's your favorite food? ")
reply = 'yuck' if food == 'lamb' else 'yum'

Выражение на правой стороне вторая строка называется условным выражением, и он оценивает либо «Yuck», либо «yum». Это эквивалентно следующим:

food = input("What's your favorite food? ")
if food == 'lamb':
   reply = 'yuck'
else:
   reply = 'yum'

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

Пример оператора сравнения Python

В Python есть восемь операций сравнения. Все они имеют одинаковый приоритет (что выше, чем у логических операций). Сравнения могут быть произвольно привязаны; Например, х эквивалентно х , кроме этого y оценивается только один раз (но в обоих случаях z не оценивается вообще, когда x найден ложь).

Следующие суммируют операции сравнения:

строго меньше, чем <
меньше или равно <=
строго больше, чем >
больше или равно > =
равно ==.
не равно знак равно
идентичность объекта является
Отрицательная идентичность объекта не является

Объекты разных типов, кроме разных числовых типов, никогда не сравните равное. Кроме того, некоторые типы (например, объекты функции) поддерживают только вырожденное понятие сравнения, где любые два объекта этого типа неравны. < , <= , > и > = Операторы будут поднимать Типеррор Исключение при сравнении сложного числа с другим встроенным числовым типом, когда объекты имеют различные типы, которые нельзя сравнить, или в других случаях, когда нет определенного упорядочения.

Неидентические экземпляры класса обычно сравниваются как неравные, если в классе не определяет __eq __ () метод.

Экземпляры класса не могут быть заказаны в отношении других случаев одного класса или других типов объектов, если только класс не определяет достаточно методов __LT __ () , __le __ () , __GT __ () и __ge __ () (В общем, __lt __ () и __eq __ () достаточны, если вы хотите, чтобы обычные знаки операторов сравнения).

Поведение это и не операторы не могут быть настроены; Также они могут быть применены к любым двум объектам и никогда не повышать исключение.

Мы также можем цепи < и > операторы вместе. Например, 3 <4 <5 вернется Правда , но 3 <4> 5 не буду. Мы также можем получить оператор равенства. Например, 3 <5 вернется Правда Но 3 <5 не буду.

Сравнение равенства – “это” против “==”

В Python есть два оператора сравнения, которые позволяют нам проверить, будут ли равны два объекта. это Оператор и == оператор. Однако между ними есть ключевое различие!

Ключевое различие между ‘is “и’ == ‘можно суммировать как:

  • это используется для сравнения личность
  • == используется для сравнения равенство

Пример

Во-первых, создайте список в Python.

myListA = [1,2,3]

Далее создайте копию этого списка.

myListB = myListA

Если мы используем оператор TheIS, оба приведут к Правда выход.

>>> myListA == myListB # both lists contains similar elements
True
>>> myListB is myListA # myListB contains the same elements
True

Это потому, что как MyLista, так и MyListb указывают на один и тот же переменную списка, которые я определил в начале моей программы Python. Обе списки точно такие же, как в идентичности, так и в контенте.

Однако, что если я сейчас создаю новый список?

myListC = [1,2,3]

Выполнение == Оператор по-прежнему показывает, что оба списка одинаковы, с точки зрения контента.

>>> myListA == myListC
True

Однако, выполняя это Оператор теперь будет производить Ложь выход. Это связано с тем, что MyLista и MyListc – это две разные переменные, несмотря на то же самое данные. Хотя они выглядят одинаково, они являются разные Отказ

>>> myListA is myListC
False # both lists have different reference

Подводить итоги:

  • это Выходные выходы Правда Если обе переменные указывают на одинаковую ссылку
  • == Выходные выходы Правда Если обе переменные содержат те же данные

Словарь (A.k.a «Dict») в Python является встроенным типом данных, который можно использовать для хранения Ключевое значение Пары. Это позволяет вам лечить Диктовать Как будто это база данных хранить и организовывать данные.

Особые вещи о словарях так, как они реализованы. Хэш-столовая структура позволяет легко проверить наличие – это означает, что мы можем легко определить, присутствует ли определенный ключ в словаре без необходимости изучения каждого элемента. Переводчик Python может просто перейти к клавишу местоположения и проверить, есть ли ключ.

Словари могут использовать практически любые произвольные типы данных, такие как строки, целые числа и т. Д., Для ключей. Тем не менее, значения, которые не являются одновременно, то есть значения, содержащие списки, словари или другие смежные типы (сравниваются по значению, а не идентичностью объекта), могут не использоваться в качестве клавиш. Числовые типы, используемые для ключей, подчиняются нормальным правилам для численного сравнения: если два числа сравнивают равные (такие как 1 и 1.0 ), тогда их можно использовать взаимозаменяемо, чтобы индексировать одну и ту же словарную запись. (Обратите внимание, что, поскольку, поскольку компьютеры хранят числа плавающих точек в качестве приближений, обычно неразумно использовать их в качестве списных клавиш.)

Одним из важнейших требований словаря является то, что ключи Должен быть уникальный.

Чтобы создать пустой словарь, просто используйте пару брекетов:

    >>> teams = {}
    >>> type(teams)
    >>> 

Чтобы создать непустой словарь с некоторыми начальными значениями, поместите разделенный запятыми список пар клавишных пар:

    >>> teams = {'barcelona': 1875, 'chelsea': 1910}
    >>> teams
    {'barcelona': 1875, 'chelsea': 1910}

Легко добавить пары клавишных пар в существующий словарь:

    >>> teams['santos'] = 1787
    >>> teams
    {'chelsea': 1910, 'barcelona': 1875, 'santos': 1787} # Notice the order - Dictionaries are unordered !
    >>> # extracting value - Just provide the key
    ...
    >>> teams['barcelona']
    1875

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

    >>> del teams['santos']
    >>> teams
    {'chelsea': 1910, 'barcelona': 1875}
    >>> teams['chelsea'] = 2017 # overwriting    
    >>> teams
    {'chelsea': 2017, 'barcelona': 1875}

в Ключевое слово может быть использовано для проверки того, существует ли ключ в Dict или нет:

    >>> 'sanots' in teams
    False    
    >>> 'barcelona' in teams
    True
    >>> 'chelsea' not in teams
    False

Ключи это встроенный Метод Это можно использовать для получения ключей данного словаря. Чтобы извлечь ключи, присутствующие в Око, как списки:

    >>> club_names = list(teams.keys())    
    >>> club_names
    ['chelsea', 'barcelona']

Еще один способ создания словаря использует Dict () Метод:

    >>> players = dict( [('messi','argentina'), ('ronaldo','portugal'), ('kaka','brazil')] ) # sequence of key-value pair is passed  
    >>> players
    {'ronaldo': 'portugal', 'kaka': 'brazil', 'messi': 'argentina'}
    >>> 
    >>> # If keys are simple strings, it's quite easier to specify pairs using keyword arguments
    ...
    >>> dict( totti = 38, zidane = 43 )
    {'zidane': 43, 'totti': 38}

Должен быть использован, также могут быть использованы для создания словарей из произвольных клавиш и выражений стоимости:

    >>> {x: x**2 for x in (2, 4, 6)}
    {2: 4, 4: 16, 6: 36}

Зацикливаться в словаре Просто петлю по клавишам в словаре, а не клавиши и значения:

    >>> d = {'x': 1, 'y': 2, 'z': 3} 
    >>> for key in d:
    ...     print(key) # do something
    ...
    x
    y
    z

Чтобы закрутить оба клавиши и значения, вы можете использовать следующее: для Python 2.x:

    >>> for key, item in d.iteritems():
    ...     print items
    ...
    1
    2
    3

Использовать Предметы () Для Python 3.x:

    >>> for key, item in d.items():
    ...     print(key, items)
    ...
    x 1
    y 2
    z 3

В Python все это объект Отказ

Объекты представляют логическую группу атрибутов. Атрибуты – это данные и/или функции. Когда объект создан в Python, он создан с помощью личность , Тип и ценность Отказ

На других языках Примитивы являются Значения у этого нет свойства (атрибуты). Например, в JavaScript undefined , null , логический , строка , Номер и Символ (Новое в Ecmascript 2015) являются примитивы.

В Python нет примитивов. Нет , Логины , Строки , Числа и даже Функции все …| Объекты Независимо от того, как они созданы.

Мы можем продемонстрировать это, используя некоторые встроенные функции:

Встроенные константы Нет , Правда и Ложь являются Объекты :

Мы проверяем Нет Объект здесь.

>>> id(None)
4550218168
>>> type(None)

>>> dir(None)
[__bool__', '__class__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__le__', '__lt__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__']
>>> issubclass(type(None), object)
True

Далее давайте проверим Правда Отказ

>>> id(True)
4550117616
>>> type(True)

>>> dir(True)
['__abs__', '__add__', '__and__', '__bool__', '__ceil__', '__class__', '__delattr__', '__dir__', '__divmod__', '__doc__', '__eq__', '__float__', '__floor__', '__floordiv__', '__format__', '__ge__', '__getattribute__', '__getnewargs__', '__gt__', '__hash__', '__index__', '__init__', '__int__', '__invert__', '__le__', '__lshift__', '__lt__', '__mod__', '__mul__', '__ne__', '__neg__', '__new__', '__or__', '__pos__', '__pow__', '__radd__', '__rand__', '__rdivmod__', '__reduce__', '__reduce_ex__', '__repr__', '__rfloordiv__', '__rlshift__', '__rmod__', '__rmul__', '__ror__', '__round__', '__rpow__', '__rrshift__', '__rshift__', '__rsub__', '__rtruediv__', '__rxor__', '__setattr__', '__sizeof__', '__str__', '__sub__', '__subclasshook__', '__truediv__', '__trunc__', '__xor__', 'bit_length', 'conjugate', 'denominator', 'from_bytes', 'imag', 'numerator', 'real', 'to_bytes']
>>> issubclass(type(True), object)
True

Нет причин уходить Ложь !

>>> id(False)
4550117584
>>> type(False)

>>> dir(False)
['__abs__', '__add__', '__and__', '__bool__', '__ceil__', '__class__', '__delattr__', '__dir__', '__divmod__', '__doc__', '__eq__', '__float__', '__floor__', '__floordiv__', '__format__', '__ge__', '__getattribute__', '__getnewargs__', '__gt__', '__hash__', '__index__', '__init__', '__int__', '__invert__', '__le__', '__lshift__', '__lt__', '__mod__', '__mul__', '__ne__', '__neg__', '__new__', '__or__', '__pos__', '__pow__', '__radd__', '__rand__', '__rdivmod__', '__reduce__', '__reduce_ex__', '__repr__', '__rfloordiv__', '__rlshift__', '__rmod__', '__rmul__', '__ror__', '__round__', '__rpow__', '__rrshift__', '__rshift__', '__rsub__', '__rtruediv__', '__rxor__', '__setattr__', '__sizeof__', '__str__', '__sub__', '__subclasshook__', '__truediv__', '__trunc__', '__xor__', 'bit_length', 'conjugate', 'denominator', 'from_bytes', 'imag', 'numerator', 'real', 'to_bytes']
>>> issubclass(type(False), object)
True

Строки даже при создании строковых литералов, также Объекты Отказ

>>> id("Hello campers!")
4570186864
>>> type('Hello campers!')

>>> dir("Hello campers!")
['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__gt__', '__hash__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'capitalize', 'casefold', 'center', 'count', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'format_map', 'index', 'isalnum', 'isalpha', 'isdecimal', 'isdigit', 'isidentifier', 'islower', 'isnumeric', 'isprintable', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'maketrans', 'partition', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']
>>> issubclass(type('Hello campers!'), object)
True

То же самое с числа.

>>> id(42)
4550495728
>>> type(42)

>>> dir(42)
['__abs__', '__add__', '__and__', '__bool__', '__ceil__', '__class__', '__delattr__', '__dir__', '__divmod__', '__doc__', '__eq__', '__float__', '__floor__', '__floordiv__', '__format__', '__ge__', '__getattribute__', '__getnewargs__', '__gt__', '__hash__', '__index__', '__init__', '__int__', '__invert__', '__le__', '__lshift__', '__lt__', '__mod__', '__mul__', '__ne__', '__neg__', '__new__', '__or__', '__pos__', '__pow__', '__radd__', '__rand__', '__rdivmod__', '__reduce__', '__reduce_ex__', '__repr__', '__rfloordiv__', '__rlshift__', '__rmod__', '__rmul__', '__ror__', '__round__', '__rpow__', '__rrshift__', '__rshift__', '__rsub__', '__rtruediv__', '__rxor__', '__setattr__', '__sizeof__', '__str__', '__sub__', '__subclasshook__', '__truediv__', '__trunc__', '__xor__', 'bit_length', 'conjugate', 'denominator', 'from_bytes', 'imag', 'numerator', 'real', 'to_bytes']
>>> issubclass(type(42), object)
True

Функции тоже объекты

В Python функциями являются объектами первого класса.

Функции в Python также Объекты , созданный с личность , Тип и ценность Отказ Они тоже могут быть переданы в другие Функции :

>>> id(dir)
4568035688
>>> type(dir)

>>> dir(dir)
['__call__', '__class__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__le__', '__lt__', '__module__', '__name__', '__ne__', '__new__', '__qualname__', '__reduce__', '__reduce_ex__', '__repr__', '__self__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__text_signature__']
>>> issubclass(type(dir), object)
True

Также возможно связывать функции имени и вызовите связанную функцию, используя это имя:

>>> a = dir
>>> print(a)

>>> a(a)
['__call__', '__class__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__le__', '__lt__', '__module__', '__name__', '__ne__', '__new__', '__qualname__', '__reduce__', '__reduce_ex__', '__repr__', '__self__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__text_signature__']

Функции связывания и псевдонима

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

>>> something = 1
>>> type(something)


>>> def something():
...     pass
...
>>> type(something)


>>> something = []
>>> type(something)

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

>>> def something(n):
...     print(n)
...
>>> type(something)


>>> s = something
>>> s(100)
100

Кортеж – это последовательность объектов Python. Кортеры неизменяются, что означает, что они не могут быть изменены после создания, в отличие от списков.

Создание:

Пустой кортеж создается с использованием пары круглых скобок, () :

    >>> empty_tuple = ()
    >>> print(empty_tuple)
    ()
    >>> type(empty_tuple)
    
    >>> len(empty_tuple)
    0

А кортеж С элементами создается путем отделения элементов с запятыми (окружающие круглые кронштейны, () , необязательны с исключениями):

    >>> tuple_1 = 1, 2, 3       # Create tuple without round brackets.
    >>> print(tuple_1)
    (1, 2, 3)
    >>> type(tuple_1)
    
    >>> len(tuple_1)
    3
    >>> tuple_2 = (1, 2, 3)     # Create tuple with round brackets.
    >>> print(tuple_2)
    (1, 2, 3)
    >>> tuple_3 = 1, 2, 3,      # Trailing comma is optional.
    >>> print(tuple_3)
    (1, 2, 3)
    >>> tuple_4 = (1, 2, 3,)    # Trailing comma in round brackets is also optional.
    >>> print(tuple_4)
    (1, 2, 3)

А кортеж С одним элементом должна быть конечная запятая (с круглыми кронштейнами или без):

>>> not_tuple = (2)    # No trailing comma makes this not a tuple.
>>> print(not_tuple)
2
>>> type(not_tuple)

>>> a_tuple = (2,)     # Single element tuple. Requires trailing comma.
>>> print(a_tuple)
(2,)
>>> type(a_tuple)

>>> len(a_tuple)
1
>>> also_tuple = 2,    # Round brackets omitted. Requires trailing comma.
>>> print(also_tuple)
(2,)
>>> type(also_tuple)

Круглые скобки требуются в случаях двусмысленности (если кортеж является частью большего выражения):

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

Например, F (A, B, C) Является ли функция вызова с тремя аргументами, а f ((a, b, c)) Является ли функциональный вызов с 3-корпусом в качестве единственного аргумента.

    >>> print(1,2,3,4,)          # Calls print with 4 arguments: 1, 2, 3, and 4
    1 2 3 4
    >>> print((1,2,3,4,))        # Calls print with 1 argument: (1, 2, 3, 4,)
    (1, 2, 3, 4)
    >>> 1, 2, 3 == (1, 2, 3)     # Equivalent to 1, 2, (3 == (1, 2, 3))
    (1, 2, False)
    >>> (1, 2, 3) == (1, 2, 3)   # Use surrounding round brackets when ambiguous.
    True

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

    >>> empty_tuple = tuple()
    >>> print(empty_tuple)
    ()
    >>> tuple_from_list = tuple([1,2,3,4])
    >>> print(tuple_from_list)
    (1, 2, 3, 4)
    >>> tuple_from_string = tuple("Hello campers!")
    >>> print(tuple_from_string)
    ('H', 'e', 'l', 'l', 'o', ' ', 'c', 'a', 'm', 'p', 'e', 'r', 's', '!')
    >>> a_tuple = 1, 2, 3
    >>> b_tuple = tuple(a_tuple)    # If the constructor is called with a tuple for
    the iterable,
    >>> a_tuple is b_tuple          # the tuple argument is returned.
    True

Доступ к элементам корпус :

Элементы кортежи доступны и проиндексированы так же, как Списки находятся.

>>> my_tuple = 1, 2, 9, 16, 25
>>> print(my_tuple)
(1, 2, 9, 16, 25)

Ноль индексирован

    >>> my_tuple[0]
    1
    >>> my_tuple[1]
    2
    >>> my_tuple[2]
    9

Обернуть вокруг индексации

    >>> my_tuple[-1]
    25
    >>> my_tuple[-2]
    16

Упаковка и распаковка:

Утверждение T, 54321, «Привет!» является примером упаковки кортежей: значения 12345 , 54321 и 'Привет!' упакованы вместе в кортеже. Обратная работа также возможна:

    >>> x, y, z = t

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

    >>> t = 1, 2, 3    # Tuple packing.
    >>> print(t)
    (1, 2, 3)
    >>> a, b, c = t    # Sequence unpacking.
    >>> print(a)
    1
    >>> print(b)
    2
    >>> print(c)
    3
    >>> d, e, f = 4, 5, 6    # Multiple assignment combines packing and unpacking.
    >>> print(d)
    4
    >>> print(e)
    5
    >>> print(f)
    6
    >>> a, b = 1, 2, 3       # Multiple assignment requires each variable (right)
    have a matching element (left).
    Traceback (most recent call last):
      File "", line 1, in 
    ValueError: too many values to unpack (expected 2)

Неизменный:

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

    >>> a_list = []
    >>> a_tuple = (a_list,)    # A tuple (immutable) with a list (mutable) element.
    >>> print(a_tuple)
    ([],)

    >>> a_list.append("Hello campers!")
    >>> print(a_tuple)         # Element of the immutable is mutated.
    (['Hello campers!'],)

Использует:

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

    >>> greeting = ["Hello", "campers!"]
    >>> enumerator = enumerate(greeting)
    >>> enumerator.next()
    >>> enumerator.__next__()
    (0, 'Hello')
    >>> enumerator.__next__()
    (1, 'campers!')

Python использует петлю для итерации по поводу перечень элементов. Это в отличие от C или Java, которая использует цикл для изменения значения в шагах и получить доступ к чему-тому, как массив, использующий это значение.

Для циклов итерации по поводу структур данных на основе сбора, как списки, кортежи и словари.

Основной синтаксис:

for value in list_of_values:
  # use value inside this block

В общем, вы можете использовать что-либо в качестве значения итератора, где могут быть назначены записи ITERable. Например. Вы можете распаковывать кортежи из списка кортежей:

list_of_tuples = [(1,2), (3,4)]

for a, b in list_of_tuples:
  print("a:", a, "b:", b)

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

for person in load_persons():
  print("The name is:", person.name)
for character in ["P", "y", "t", "h", "o", "n"]:
  print("Give me a '{}'!".format(character))

Некоторые способы, которыми используются петли:

Итерация по диапазону () функции

for i in range(10):
    print(i)

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

>
0
1
2
3
4
5
6
7
8
9
>

Кроме того, можно указать нижнюю границу последовательности и даже шаг последовательности путем добавления второго и третьего параметра.

for i in range(4,10,2): #From 4 to 9 using a step of two
    print(i)

Выход:

>
4
6
8
>

Функция xrange ()

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

Еще одна вещь, чтобы добавить. В Python 3.x функция Xrange больше не существует. Функция диапазона теперь делает то, что делает xrange в Python 2.x

Итайте за ценности в списке или кортеж

A = ["hello", 1, 65, "thank you", [2, 3]]
for value in A:
    print(value)

Выход:

>
hello
1
65
thank you
[2, 3]
>

Итайте по ключам в словаре (aka hashmap)

fruits_to_colors = {"apple": "#ff0000",
                    "lemon": "#ffff00",
                    "orange": "#ffa500"}

for key in fruits_to_colors:
    print(key, fruits_to_colors[key])

Выход:

>
apple #ff0000
lemon #ffff00
orange #ffa500
>

Итайте в течение двух списков одного размера в одной петле с функцией ZIP ()

A = ["a", "b", "c"]
B = ["a", "d", "e"]

for a, b in zip(A, B):
  print a, b, a == b
  

Выход:

>
a a True
b d False
c e False
>

Итайте переписывают список и получите соответствующий индекс с функцией перечисления ()

A = ["this", "is", "something", "fun"]

for index,word in enumerate(A):
    print(index, word)

Выход:

>
0 this
1 is
2 something
3 fun
>

Общий корпус использования итерация по поводу словаря:

for name, phonenumber in contacts.items():
  print(name, "is reachable under", phonenumber)

Если вам абсолютно необходимо получить доступ к текущему индексу вашей итерации, сделать Не использовать Диапазон (Len (потенциал)) ! Это чрезвычайно плохая практика и доставит вам множество смесь от старших разработчиков Python. Используйте встроенные функции перечислять () вместо:

for index, item in enumerate(shopping_basket):
  print("Item", index, "is a", item)

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

week_days = ['Monday','Tuesday','Wednesday','Thursday','Friday']
today = 'Saturday'
for day in week_days:
  if day == today:
    print('today is a week day')
    break
else:
  print('today is not a week day')

В приведенном выше случае выход будет Сегодня не выходной день Так как перерыв в цикле никогда не будет выполнен.

Итайте через список, используя функцию inline Loop

Мы также могли бы итерации линейки с помощью Python. Например, если нам нужно прописные все слова в списке из списка, мы могли бы просто сделать следующее:

A = ["this", "is", "awesome", "shinning", "star"]

UPPERCASE = [word.upper() for word in A]
print (UPPERCASE)

Выход:

>
['THIS', 'IS', 'AWESOME', 'SHINNING', 'STAR']

Функция позволяет определить многоразовый блок кода, который может быть выполнен много раз в вашей программе.

Функции позволяют создавать более модульные и Сухой решения сложных проблем.

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

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

Синтаксис

В Python определение функции имеет следующие функции:

  1. Ключевое слово . деф
  2. Название функции
  3. скобки ‘()’ и в скобках входные параметры входных скобок, хотя входные параметры являются необязательными.
  4. толстая кишка:
  5. какой-то блок кода для выполнения
  6. Оператор возврата (необязательно)
# a function with no parameters or returned values
def sayHello():
  print("Hello!")

sayHello()  # calls the function, 'Hello!' is printed to the console

# a function with a parameter
def helloWithName(name):
  print("Hello " + name + "!")

helloWithName("Ada")  # calls the function, 'Hello Ada!' is printed to the console

# a function with multiple parameters with a return statement
def multiply(val1, val2):
  return val1 * val2

multiply(3, 5)  # prints 15 to the console

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

Функции в Python создаются с помощью def Ключевое слово, сопровождаемое имя функции и параметры функции внутри скобок.

Функция всегда возвращает значение. Возвращение Ключевое слово используется функцией для возврата значения. Если вы не хотите возвращать какое-либо значение, значение по умолчанию Нет будет возвращено.

Имя функции используется для вызова функции, передавая необходимые параметры внутри скобок.

# this is a basic sum function
def sum(a, b):
  return a + b

result = sum(1, 2)
# result = 3

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

def sum(a, b=3):
  return a + b

result = sum(1)
# result = 4

Вы можете передавать параметры в хоте желаемого заказа, используя имя параметра.

result = sum(b=2, a=2)
# result = 4

Тем не менее, невозможно пройти аргумент ключевых слов до однозначного ключевого слова.

result = sum(3, b=2)
#result = 5
result2 = sum(b=2, 3)
#Will raise SyntaxError

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

s = sum
result = s(1, 2)
# result = 3

Заметки

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

print(multiply(3))  # TypeError: multiply() takes exactly 2 arguments (0 given)

print(multiply('a', 5))  # 'aaaaa' printed to the console

print(multiply('a', 'b'))  # TypeError: Python can't multiply two strings

Блок кода, который выполняется функция, включает в себя все утверждения, отступив в функции.

def myFunc():
print('this will print')
print('so will this')

x = 7
# the assignment of x is not a part of the function since it is not indented

Переменные, определенные внутри функции, существуют только в объеме этой функции.

def double(num):
x = num * 2
return x

print(x)  # error - x is not defined
print(double(4))  # prints 8

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

Генераторы – это специальный тип функции, которая позволяет вам возвращать значения без окончания функции. Это делает это с помощью доходность ключевое слово. Похоже на Возвращение , доходность Выражение вернет значение звонящему. Ключевая разница между ними в том, что доходность приостановит функцию, позволяющую возвращать больше ценностей в будущем.

Генераторы являются неразмерными, поэтому их можно использовать чисто для петель или что-то еще, что итерат.

def my_generator():
    yield 'hello'
    yield 'world'
    yield '!'

for item in my_generator():
    print(item)

# output:
# hello
# world
# !

Как и другие итераторы, генераторы могут быть переданы на Следующий функция для получения следующего элемента. Когда генератор не имеет больше ценностей для давления, A Заставка Ошибка поднимается.

g = my_generator()
print(next(g))
# 'hello'
print(next(g))
# 'world'
print(next(g))
# '!'
print(next(g))
# Traceback (most recent call last):
#   File "", line 1, in 
# StopIteration

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

def fib(n):
    a = 1
    b = 1
    for i in range(n):
        yield a
        a, b = b, a + b

for x in fib(1000000):
    print(x)

Python поддерживает концепцию итерации над контейнерами. Это реализуется с использованием двух различных методов; Они используются для разрешения пользовательских классов для поддержки итерации.

Python Docs – Типы итератора

Итерация – это процесс программно повторения шага в заданном количестве раз. Программист может использовать итерацию для выполнения той же операции на каждом элементе в коллекции данных, например, печатаю каждый элемент в списке.

  • Объекты могут реализовать __er __ () Метод, который возвращает объект iTerator для поддержки итерации.

Предметы итератора должны реализовать:

  • __er __ () : возвращает объект итератора.
  • __Next __ () : возвращает следующий объект контейнера. объект. ИТЕР () Печать (ITERATOR Object) Print (ID (ITERATOR Object)) Печать (ID (ITERATOR объект. iTer ())) # возвращает сам итератор. Печать (итератор объект. Next ()) # Возвращает 1-й объект и достигает итератора. Печать (итератор объект. Next ()) # Возвращает 2-й объект и достигает итератора. Печать (итератор объект. Next ()) # возвращает 3-й объект и достигает итератора. Печать (итератор объект. Next ()) # поднимает исключение задержания.

Выход:


4343305888
4343305888
a
b
c
---------------------------------------------------------------------------
StopIteration                             Traceback (most recent call last)
 in ()
      6 print(iterator_object.__next__())     # Returns 2nd object and advances iterator.
      7 print(iterator_object.__next__())     # Returns 3rd object and advances iterator.
----> 8 print(iterator_object.__next__())     # Raises StopIteration Exception.

StopIteration:

Темные операции в Python, часто упоминаются как условные выражения, позволяют программисту выполнять оценку и вернуть значение, основанное на истине данного состояния.

Темнарный оператор отличается от стандарта Если , еще , Элиф Структура в том смысле, что это не контрольная структура потока, а ведет себя больше, как другие операторы, такие как == или ! = на языке Python.

Пример

В этом примере строка Даже возвращается, если валь Переменная даже, в противном случае строка Странные возвращается. Возвращенная строка затем назначается на IS_EVEN Переменная и напечатана на консоль.

Вход

for val in range(1, 11):
    is_even = "Even" if val % 2 == 0 else "Odd"
    print(val, is_even, sep=' = ')

Выход

1 = Odd
2 = Even
3 = Odd
4 = Even
5 = Odd
6 = Even
7 = Odd
8 = Even
9 = Odd
10 = Even

Python использует в то время как петля аналогично другим популярным языкам. в то время как Цикл оценивает условие, затем выполняет блок кода, если условие верно. Блок кода выполняется несколько раз, пока состояние не станет ложным.

Основной синтаксис:

counter = 0
while counter < 10:
   # Execute the block of code here as
   # long as counter is less than 10

Пример показан ниже:

days = 0    
week = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday']
while days < 7:
   print("Today is " + week[days])
   days += 1

Выход:

Today is Monday
Today is Tuesday
Today is Wednesday
Today is Thursday
Today is Friday
Today is Saturday
Today is Sunday

Линейное объяснение вышеуказанного кода:

  1. Переменные «дни» устанавливаются на значение 0.
  2. Переменная неделя назначена в список, содержащее все дни недели.
  3. в то время как цикл начинается
  4. Блок кода будет выполнен, пока состояние не возвращается «True».
  5. Условие – это «дни <7», которые примерно говорят, запустите цикл While до тех пор, пока момент переменной дни не менее 7
  6. Таким образом, когда цикл тока останавливается на выполнении.
  7. Переменная дня обновляется на каждой итерации.
  8. Когда цикл Whicle работает в первую очередь, линия «сегодня в понедельник» напечатана на консоли, а дни переменные становится равными 1.
  9. Поскольку дни переменные равны 1, что составляет менее 7, цикл WHE WHERE снова выполняется.
  10. Он снова и снова и снова, и когда принты консоли «сегодня – воскресенье». Переменные дни сейчас равны 7 и то время, когда петля останавливается.

F-струны в Python

В Python версии 3.6 был реализован новый метод форматирования строк. Новый метод называется буквальной струнной интерполяцией (хотя обычно называется F-String).

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

Для выполнения этих динамических поведений в F-строке мы обертываем их внутри вьющихся скобок в строке, и добавьте нижний регистр f к началу строки (до открытия цитата.

Примеры

Динамически вставляя переменную в строку во время выполнения:

name = 'Jon Snow'
greeting = f'Hello! {name}'
print(greeting)

Оцените выражение в строке:

val1 = 2
val2 = 3
expr = f'The sum of {val1} + {val2} is {val1 + val2}'
print(expr)

Вызов функции и вставьте выходные данные в строке:

def sum(*args):
    result = 0
    for arg in args:
        result += arg
    return result

func = f'The sum of 3 + 5 is {sum(3, 5)}'
print(func)

Присоединение к содержимому коллекции в строке:

fruits = ['Apple', 'Banana', 'Pear']

list_str = f'List of fruits: {", ".join(fruits)}'
print(list_str)

Вы можете скачать Python из этого официального ссылка Отказ Основываясь на вашей ОС (Windows или Linux или OSX), вы можете установить Python 3, следуя Эти инструкции Отказ

Используя виртуальные среды

Это всегда отличная идея для песочница Ваша установка Python и держать его отдельным от вашего Система Python Отказ Система Python Путь к интерпретатору Python, который используется другими модулями, установленными вместе с вашей ОС.

Это Не безопасно Чтобы установить Python Web-Frameworks или библиотеки, напрямую использую Система Python Отказ Вместо этого вы можете использовать Виртуальский Чтобы создать и порождать отдельный процесс Python, когда вы разрабатываете приложения Python.

Virtualenvwrapper.

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

Конечно, большинство облачных состоятельных сред разработки, такие как Азота или Cloud9 Также приходите с этими предварительно установленными и готовыми к вам, чтобы получить кодирование! Вы можете быстро выбрать коробку с вашей приборной панели и начать кодирование после активации среды Python 3.

В Cloud9 , вам нужно выбрать коробку Django при создании новой среды разработки.

Следуйте несколько примеров команд Shell. Если вы хотите скопировать-вставить, отметьте, что $ Знак – это сокращение для приглашения терминала, это не является частью команды. Мой терминальный подсказке выглядит что-то подобное:

alayek:~/workspace (master) $

И, Ls будет выглядеть так

alayek:~/workspace (master) $ ls

Но, пишешь то же самое в этой документации, я бы пишешь это как

$ ls

Возвращаясь к нашему обсуждению, вы можете создать Sandbox Python 3 InterQuoter, включенный в Sandbox на Cloud9, работая на вашем облачном терминале:

$ mkvirtualenv py3 --python=/usr/bin/python3

Вы должны запустить его только один раз после создания новой коробки для вашего проекта. После выполнения эта команда создаст новый Workualenv Workualenv для использования, с именем PY3 Отказ

Для просмотра доступных виртуальных сред, вы можете использовать

$ workon

Активировать PY3 , вы можете использовать Работание Команда с именем окружающей среды:

$ workon py3

Все три команда терминалов выше будут работать на местных машинах Linux или MACHINES. Это VirtualenVwrapper команды; Поэтому, если вы планируете использовать их, убедитесь, что у вас установлен этот модуль и добавлен в Путь Переменная.

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

Например, когда я внутри PY3 Окружающая среда, я буду видеть это как мой терминальный запрос:

(py3)alayek:~/workspace (master) $

Обратите внимание на (PY3) В брекетах! Если по какой-то причине вы не видите это, даже если вы находитесь внутри виртуальной ENV; Вы можете попробовать сделать одну из вещей упоминается здесь Отказ

Чтобы выйти из виртуальной среды или деактивировать одно – используйте эту команду:

$ deactivate

Опять же, это работает только с модулем VirtualenVwrapper.

Пипнв

Альтернатива использования VirtualenVWrapper – Пипенв Отказ Он автоматически создает виртуальные среды для ваших проектов и поддерживает Pipfile который содержит зависимости. Использование Pipenv означает, что вам больше не нужно использовать PIP и Virtualenv отдельно или управлять своими собственными требования .txt файл. Для тех, кто знаком с JavaScript, Pipenv аналогичен использованию инструмента для упаковки, как NPM Отказ

Чтобы начать работу с Pipenv, вы можете следовать этому очень подробному Руководство Отказ Pipenv позволяет легко Укажите, какую версию Python Вы хотите использовать для каждого проекта, Импорт из существующего требования .txt Файл и График ваши зависимости.