Здравствуй, Мир!
Python-очень простой язык и имеет очень простой синтаксис. Это побуждает программистов программировать без шаблонного (готового) кода. Самая простая директива в Python - это директива "печать" - она просто выводит строку (а также включает новую строку, в отличие от C).
Существуют две основные версии Python, Python 2 и Python 3. Python 2 и 3 совершенно разные. В этом руководстве используется Python 3, потому что он более семантически корректен и поддерживает новые функции.
Например, одно из различий между Python 2 и 3 заключается в printутверждении. В Python 2 оператор "print" не является функцией, и поэтому он вызывается без круглых скобок. Однако в Python 3 это функция, и она должна вызываться в круглых скобках.
Чтобы напечатать строку в Python 3, просто напишите:
print("This line will be printed.
Вдавливание
Python использует отступы для блоков вместо фигурных скобок. Поддерживаются как вкладки, так и пробелы, но стандартный отступ требует, чтобы стандартный код Python использовал четыре пробела. Например:
x = 1
if x == 1:
# indented four spaces
print("x is 1.")
Упражнение
Используйте функцию "print", чтобы напечатать строку "Hello, World!".
print("Goodbye, World!
Переменные и типы
Python полностью объектно-ориентирован, а не "статически типизирован". Вам не нужно объявлять переменные перед их использованием или объявлять их тип. Каждая переменная в Python является объектом.
В этом учебнике будет рассмотрено несколько основных типов переменных.
Числа
Python поддерживает два типа чисел - целые числа(целые числа) и числа с плавающей запятой(десятичные дроби). (Он также поддерживает комплексные числа, которые не будут объяснены в этом руководстве).
Чтобы определить целое число, используйте следующий синтаксис:
myint = 7
print(myint)
Чтобы определить число с плавающей запятой, вы можете использовать одно из следующих обозначений:
myfloat = 7.0
print(myfloat)
myfloat = float(7)
print(myfloat)
Строки
Строки определяются либо в одинарных, либо в двойных кавычках.
mystring = 'hello'
print(mystring)
mystring = "hello"
print(mystring)
Разница между ними заключается в том, что использование двойных кавычек облегчает включение апострофов (в то время как они завершали бы строку при использовании одинарных кавычек)
mystring = "Don't worry about apostrophes"
print(mystring)
Существуют дополнительные варианты определения строк, которые упрощают включение таких элементов, как возврат каретки, обратные косые черты и символы Юникода. Они выходят за рамки этого руководства, но рассматриваются в Документация на Python.
Простые операторы могут выполняться над числами и строками:
one = 1
two = 2
three = one + two
print(three)
hello = "hello"
world = "world"
helloworld = hello + " " + world
print(helloworld)
Назначения могут быть выполнены для более чем одной переменной "одновременно" в одной строке, как это
a, b = 3, 4
print(a,b)
Смешивание операторов между числами и строками не поддерживается:
# This will not work!
one = 1
two = 2
hello = "hello"
print(one + two + hello)
Упражнение
Цель этого упражнения-создать строку, целое число и число с плавающей запятой. Строка должна быть названа mystring и должно содержать слово "привет". Число с плавающей запятой должно быть названо myfloat и должно содержать число 10.0, а целое число должно быть названо myint и должен содержать цифру 20.
# change this code
mystring = None
myfloat = None
myint = None
# testing code
if mystring == "hello":
print("String: %s" % mystring)
if isinstance(myfloat, float) and myfloat == 10.0:
print("Float: %f" % myfloat)
if isinstance(myint, int) and myint == 20:
print("Integer: %d" % myint
Списки
Списки очень похожи на массивы. Они могут содержать переменные любого типа и могут содержать столько переменных, сколько вы пожелаете. Списки также можно перебирать очень простым способом. Вот пример того, как составить список.
mylist = []
mylist.append(1)
mylist.append(2)
mylist.append(3)
print(mylist[0]) # prints 1
print(mylist[1]) # prints 2
print(mylist[2]) # prints 3
# prints out 1,2,3
for x in mylist:
print(x)
Доступ к несуществующему индексу создает исключение (ошибку).
mylist = [1,2,3]
print(mylist[10])
Упражнение
В этом упражнении вам нужно будет добавить числа и строки в правильные списки с помощью метода "добавить" список. Вы должны добавить числа 1,2 и 3 в список "числа", а слова "привет" и "мир" в переменную strings.
Вам также нужно будет заполнить переменную second_name вторым именем в списке имен, используя оператор скобок []. Обратите внимание, что индекс основан на нуле, поэтому, если вы хотите получить доступ ко второму элементу в списке, его индекс будет равен 1.
numbers = []
strings = []
names = ["John", "Eric", "Jessica"]
# write your code here
second_name = None
# this code should write out the filled arrays and the second name in the names list (Eric).
print(numbers)
print(strings)
print("The second name on the names list is %s" % second_name)
Основные Операторы
В этом разделе объясняется, как использовать базовые операторы в Python.
Арифметические операторы
Как и любые другие языки программирования, операторы сложения, вычитания, умножения и деления могут использоваться с числами
number = 1 + 2 * 3 / 4.0
print(number)
Попробуйте предсказать, каким будет ответ. Следует ли python порядку операций?
Другим доступным оператором является оператор по модулю ( % ), который возвращает целочисленный остаток от деления. делитель дивидендов на % = остаток.
remainder = 11 % 3
print(remainder)
Использование двух символов умножения создает соотношение мощности.
squared = 7 ** 2
cubed = 2 ** 3
print(squared)
print(cubed)
Использование операторов со строками
Python поддерживает объединение строк с использованием оператора сложения:
helloworld = "hello" + " " + "world"
print(helloworld)
Python также поддерживает умножение строк для формирования строки с повторяющейся последовательностью:
lotsofhellos = "hello" * 10
print(lotsofhe
Использование операторов со списками
Списки могут быть объединены с помощью операторов добавления:
even_numbers = [2,4,6,8]
odd_numbers = [1,3,5,7]
all_numbers = odd_numbers + even_numbers
print(all_numbers)
Как и в строках, Python поддерживает формирование новых списков с повторяющейся последовательностью с использованием оператора умножения:
print([1,2,3] * 3)
Упражнение
Цель этого упражнения-создать два списка с именем x_listи y_list, которые содержат 10 экземпляров переменных xи yсоответственно. Вам также необходимо создать вызываемый список big_list, содержащий переменные xи yпо 10 раз каждую, путем объединения двух созданных вами списков.
x = object()
y = object()
# TODO: change this code
x_list = [x]
y_list = [y]
big_list = []
print("x_list contains %d objects" % len(x_list))
print("y_list contains %d objects" % len(y_list))
print("big_list contains %d objects" % len(big_list))
# testing code
if x_list.count(x) == 10 and y_list.count(y) == 10:
print("Almost there...")
if big_list.count(x) == 10 and big_list.count(y) == 10:
print("Great!")
Форматирование строк
Python использует форматирование строк в стиле C для создания новых отформатированных строк. Оператор "%" используется для форматирования набора переменных, заключенных в "кортеж" (список фиксированного размера), вместе со строкой форматирования, которая содержит обычный текст вместе со "спецификаторами аргументов", специальными символами, такими как "%s" и "%d".
Предположим, у вас есть переменная под названием "имя" с вашим именем пользователя в ней, и вы хотели бы распечатать(написать приветствие этому пользователю).
# This prints out "Hello, John!"
name = "John"
print("Hello, %s!" % name)
Чтобы использовать два или более спецификатора аргументов, используйте кортеж (круглые скобки).:
# This prints out "John is 23 years old."
name = "John"
age = 23
print("%s is %d years old." % (name,
Любой объект, который не является строкой, также может быть отформатирован с помощью оператора %s. Строка, возвращаемая методом "repr" этого объекта, отформатирована как строка. Например:
# This prints out: A list: [1, 2, 3]
mylist = [1,2,3]
print("A list: %s" % mylist)
Вот некоторые основные спецификаторы аргументов, которые вы должны знать:
%s - String (or any object with a string representation, like numbers)
%d - Integers
%f - Floating point numbers
%.<number of digits>f - Floating point numbers with a fixed amount of digits to the right of the dot.
%x/%X - Integers in hex representation (lowercase/uppercase)
Упражнение
Вам нужно будет написать строку формата, которая выводит данные, используя следующий синтаксис: Hello John Doe. Your current balance is $53.44.
data = ("John", "Doe", 53.44)
format_string = "Hello"
print(format_string % data)
Основные Строковые операции
Строки-это фрагменты текста. Их можно определить как что угодно между кавычками:
astring = "Hello world!"
astring2 = 'Hello world!'
Как видите, первое, чему вы научились, - это печатать простое предложение. Это предложение было сохранено Python в виде строки. Однако вместо того, чтобы немедленно распечатывать строки, мы рассмотрим различные вещи, которые вы можете с ними сделать. Вы также можете использовать одинарные кавычки для назначения строки. Однако вы столкнетесь с проблемами, если значение, которое будет присвоено, будет содержать одинарные кавычки. Например, чтобы назначить строку в этих скобках(одинарные кавычки -""), вам нужно использовать только двойные кавычки, как это
astring = "Hello world!"
print("single quotes are ' '")
print(len(astring))
Это выводит 12, потому что "Привет, мир!" состоит из 12 символов, включая знаки препинания и пробелы.
astring = "Hello world!"
print(astring.index("o"))
Это выводит 4, потому что место первого вхождения буквы "о" находится на расстоянии 4 символов от первого символа. Обратите внимание, как на самом деле во фразе есть два " о " - этот метод распознает только первое.
Но почему он не распечатал 5? Разве "о" не пятый символ в строке? Чтобы упростить задачу, Python (и большинство других языков программирования) начинают работу с 0 вместо 1. Таким образом, индекс "о" равен 4.
astring = "Hello world!"
print(astring.count("l"))
Для тех из вас, кто использует глупые шрифты, это строчная буква L, а не номер один. Это подсчитывает количество букв l в строке. Поэтому он должен вывести 3.
astring = "Hello world!"
print(astring[3:7])
При этом выводится фрагмент строки, начинающийся с индекса 3 и заканчивающийся индексом 6. Но почему 6, а не 7? Опять же, большинство языков программирования делают это - это облегчает выполнение математики внутри этих скобок.
Если у вас есть только одно число в скобках, это даст вам один символ с этим индексом. Если вы опустите первое число, но сохраните двоеточие, это даст вам срез с самого начала до числа, которое вы оставили. Если вы опустите второе число, оно даст вам кусочек от первого числа до конца.
Вы даже можете поместить отрицательные числа в квадратные скобки. Это простой способ начать с конца строки, а не с начала. Таким образом, -3 означает "3-й символ с конца".
astring = "Hello world!"
print(astring[3:7:2])
Это выводит символы строки от 3 до 7, пропуская один символ. Это расширенный синтаксис среза. Общая форма [начало:остановка:шаг].
astring = "Hello world!"
print(astring[3:7])
print(astring[3:7:1])
Обратите внимание, что оба они дают одинаковый результат
В C нет такой функции, как strrev, для реверсирования строки. Но с помощью вышеупомянутого типа синтаксиса среза вы можете легко изменить строку, подобную этой
astring = "Hello world!"
print(astring[::-1])
Это создает новую строку со всеми буквами, преобразованными в верхний и нижний регистры соответственно.
astring = "Hello world!"
print(astring.upper())
print(astring.lower())
Это используется для определения того, начинается ли строка с чего-то или заканчивается чем-то, соответственно. Первый из них выведет значение True, так как строка начинается с "Привет". Второе выведет False, так как строка, безусловно, не заканчивается на "asdfasdfasdf".
astring = "Hello world!"
afewwords = astring.split(" ")
Это разбивает строку на группу строк, сгруппированных вместе в список. Поскольку этот пример разделяется пробелом, первым пунктом в списке будет "Здравствуйте", а вторым - "мир!".
Упражнение
Попробуйте исправить код, чтобы распечатать правильную информацию, изменив строку.
s = "Hey there! what should this string be?"
# Length should be 20
print("Length of s = %d" % len(s))
# First occurrence of "a" should be at index 8
print("The first occurrence of the letter a = %d" % s.index("a"))
# Number of a's should be 2
print("a occurs %d times" % s.count("a"))
# Slicing the string into bits
print("The first five characters are '%s'" % s[:5]) # Start to 5
print("The next five characters are '%s'" % s[5:10]) # 5 to 10
print("The thirteenth character is '%s'" % s[12]) # Just number 12
print("The characters with odd index are '%s'" %s[1::2]) #(0-based indexing)
print("The last five characters are '%s'" % s[-5:]) # 5th-from-last to end
# Convert everything to uppercase
print("String in uppercase: %s" % s.upper())
# Convert everything to lowercase
print("String in lowercase: %s" % s.lower())
# Check how a string starts
if s.startswith("Str"):
print("String starts with 'Str'. Good!")
# Check how a string ends
if s.endswith("ome!"):
print("String ends with 'ome!'. Good!")
# Split the string into three separate strings,
# each containing only a word
print("Split the words of the string: %s" % s.split(" "))
Условия
Python использует логическую логику для оценки условий. Логические значения True и False возвращаются при сравнении или оценке выражения. Например:
x = 2
print(x == 2) # prints out True
print(x == 3) # prints out False
print(x < 3) # prints out True
Обратите внимание, что присвоение переменной выполняется с использованием одного оператора равенства"=", в то время как сравнение между двумя переменными выполняется с использованием оператора двойного равенства "==". Оператор "не равно" помечается как "!=".
Булевы операторы
Логические операторы "и" и "или" позволяют строить сложные логические выражения, например:
name = "John"
age = 23
if name == "John" and age == 23:
print("Your name is John, and you are also 23 years old.")
if name == "John" or name == "Rick":
print("Your name is either John or Rick.")
Оператор "в"
Оператор "в" можно использовать для проверки, существует ли указанный объект в контейнере повторяющихся объектов, например в списке:
name = "John"
if name in ["John", "Rick"]:
print("Your name is either John or Rick.")
Python использует отступы для определения блоков кода вместо скобок. Стандартный отступ Python составляет 4 пробела, хотя вкладки и любой другой размер пространства будут работать, если он согласован. Обратите внимание, что блоки кода не нуждаются в каком-либо завершении.
Вот пример использования оператора Python "if" с использованием блоков кода:
statement = False
another_statement = True
if statement is True:
# do something
pass
elif another_statement is True: # else if
# do something else
pass
else:
# do another thing
pass
Например:
x = 2
if x == 2:
print("x equals two!")
else:
print("x does not equal to two.")
Утверждение считается истинным, если верно одно из следующих действий: 1. "Истинная" логическая переменная задана или вычислена с использованием выражения, такого как арифметическое сравнение. 2. Передается объект, который не считается "пустым".
Вот несколько примеров объектов, которые считаются пустыми: 1. Пустая строка: "" 2. Пустой список: [] 3. Число ноль: 0 4. Логическая переменная false: False
Оператор "is"
В отличие от оператора double equals "==", оператор "is" не соответствует значениям переменных, но самим экземплярам. Например:
x = [1,2,3]
y = [1,2,3]
print(x == y) # Prints out True
print(x is y) # Prints out False
Оператор "не"
Использование "не" перед тем, как логическое выражение перевернет его:
print(not False) # Prints out True
print((not False) == (False)) # Prints
Упражнение
Измените переменные в первом разделе, чтобы каждое утверждение if разрешалось как True.
# change this code
number = 10
second_number = 10
first_array = []
second_array = [1,2,3]
if number > 15:
print("1")
if first_array:
print("2")
if len(second_array) == 2:
print("3")
if len(first_array) + len(second_array) == 5:
print("4")
if first_array and first_array[0] == 1:
print("5")
if not second_number:
print("6")
Функции
Что такое Функции?
Функции-это удобный способ разделить ваш код на полезные блоки, позволяющий нам упорядочить наш код, сделать его более читабельным, повторно использовать его и сэкономить некоторое время. Кроме того, функции являются ключевым способом определения интерфейсов, чтобы программисты могли делиться своим кодом.
Как вы пишете функции на Python?
Как мы видели в предыдущих руководствах, Python использует блоки.
Блок-это область кода, написанная в формате:
block_head:
1st block line
2nd block line
...
Где строка блока представляет собой больше кода Python (даже другой блок), а заголовок блока имеет следующий формат: block_keyword имя блока(аргумент 1,аргумент 2, ...) Ключевые слова блока, которые вы уже знаете, - "если", "для" и "пока".
Функции в python определяются с использованием ключевого слова блока "def", за которым следует имя функции в качестве имени блока. Например:
def my_function():
print("Hello From My Function!")
Функции также могут получать аргументы (переменные, передаваемые вызывающей функцией функции). Например
def my_function_with_args(username, greeting):
print("Hello, %s , From My Function!, I wish you %s"%(username, greeting))
Функции могут возвращать значение вызывающему объекту, используя ключевое слово - "return" . Например:
def sum_two_numbers(a, b):
return a + b
Как вы вызываете функции в Python?
Просто напишите имя функции, за которым следует (), заключив все необходимые аргументы в квадратные скобки. Например, давайте вызовем функции, написанные выше (в предыдущем примере):
# Define our 3 functions
def my_function():
print("Hello From My Function!")
def my_function_with_args(username, greeting):
print("Hello, %s, From My Function!, I wish you %s"%(username, greeting))
def sum_two_numbers(a, b):
return a + b
# print(a simple greeting)
my_function()
#prints - "Hello, John Doe, From My Function!, I wish you a great year!"
my_function_with_args("John Doe", "a great year!")
# after this line x will hold the value 3!
x = sum_two_numbers(1,2)
Упражнение
В этом упражнении вы будете использовать существующую функцию и при добавлении своей собственной создавать полностью функциональную программу.
Добавьте функцию с именемlist_benefits(), которая возвращает следующий список строк: "Более организованный код", "Более читаемый код", "Упрощенное повторное использование кода", "Позволяет программистам обмениваться и соединять код вместе".
Добавьте функцию с именемbuild_sentence(info), которая получает один аргумент, содержащий строку, и возвращает предложение, начинающееся с данной строки и заканчивающееся строкой " это преимущество функций!"
Запустите и посмотрите, как все функции работают вместе!
# Modify this function to return a list of strings as defined above
def list_benefits():
pass
# Modify this function to concatenate to each benefit - " is a benefit of functions!"
def build_sentence(benefit):
pass
def name_the_benefits_of_functions():
list_of_benefits = list_benefits()
for benefit in list_of_benefits:
print(build_sentence(benefit))
name_the_benefits_of_functions()
Классы и объекты
Объекты представляют собой инкапсуляцию переменных и функций в единую сущность. Объекты получают свои переменные и функции из классов. Классы-это, по сути, шаблон для создания ваших объектов.
Очень простой класс выглядел бы примерно так:
class MyClass:
variable = "blah"
def function(self):
print("This is a message inside the class."
Мы объясним, почему вы должны включить это "я" в качестве параметра чуть позже. Во-первых, чтобы назначить вышеуказанный класс(шаблон) объекту, вы должны выполнить следующее:
class MyClass:
variable = "blah"
def function(self):
print("This is a message inside the class.")
myobjectx = MyClass()
Теперь переменная "myobjectx" содержит объект класса "MyClass", содержащий переменную и функцию, определенные в классе под названием "MyClass".
Доступ к Переменным Объекта
Чтобы получить доступ к переменной внутри вновь созданного объекта "myobjectx", вы должны сделать следующее:
class MyClass:
variable = "blah"
def function(self):
print("This is a message inside the class.")
myobjectx = MyClass()
myobjectx.variable
Так, например, ниже будет выведена строка "blah":
class MyClass:
variable = "blah"
def function(self):
print("This is a message inside the class.")
myobjectx = MyClass()
print(myobjectx.variable)
Вы можете создать несколько различных объектов одного и того же класса(с одинаковыми переменными и определенными функциями). Однако каждый объект содержит независимые копии переменных, определенных в классе. Например, если бы мы определили другой объект с классом "MyClass", а затем изменили строку в переменной выше:
class MyClass:
variable = "blah"
def function(self):
print("This is a message inside the class.")
myobjectx = MyClass()
myobjecty = MyClass()
myobjecty.variable = "yackity"
# Then print out both values
print(myobjectx.variable)
print(myobjecty.variable)
Доступ к Функциям Объектов
Для доступа к функции внутри объекта вы используете обозначения, аналогичные доступу к переменной:
class MyClass:
variable = "blah"
def function(self):
print("This is a message inside the class.")
myobjectx = MyClass()
myobjectx.function()
Упражнение
У нас есть класс, определенный для транспортных средств. Создайте два новых автомобиля под названием car1 и car2. Установите автомобиль 1 в красный кабриолет стоимостью 60 000,00 долларов с именем Fer, а автомобиль 2 в синий фургон с именем Jump стоимостью 10 000,00 долларов.
# define the Vehicle class
class Vehicle:
name = ""
kind = "car"
color = ""
value = 100.00
def description(self):
desc_str = "%s is a %s %s worth $%.2f." % (self.name, self.color, self.kind, self.value)
return desc_str
# your code goes here
# test code
print(car1.description())
print(car2.description())
Словари
Словарь-это тип данных, аналогичный массивам, но работающий с ключами и значениями вместо индексов. К каждому значению, хранящемуся в словаре, можно получить доступ с помощью ключа, представляющего собой объект любого типа (строку, число, список и т.д.), Вместо того, чтобы использовать его индекс для его адресации.
Например, база данных телефонных номеров может быть сохранена с помощью такого словаря:
phonebook = {}
phonebook["John"] = 938477566
phonebook["Jack"] = 938377264
phonebook["Jill"] = 947662781
print(phonebook)
В качестве альтернативы словарь может быть инициализирован теми же значениями в следующей нотации:
phonebook = {
"John" : 938477566,
"Jack" : 938377264,
"Jill" : 947662781
}
print(phonebook)
Перебор словарей
Словари можно перебирать, как и список. Однако словарь, в отличие от списка, не сохраняет порядок хранящихся в нем значений. Для перебора пар ключ-значение используйте следующий синтаксис:
phonebook = {"John" : 938477566,"Jack" : 938377264,"Jill" : 947662781}
for name, number in phonebook.items():
print("Phone number of %s is %d" % (name, numbe
Удаление значения
Чтобы удалить указанный индекс, используйте одно из следующих обозначений:
phonebook = {
"John" : 938477566,
"Jack" : 938377264,
"Jill" : 947662781
}
del phonebook["John"]
print(phonebook)
или:
phonebook = {
"John" : 938477566,
"Jack" : 938377264,
"Jill" : 947662781
}
phonebook.pop("John")
print(phonebook)
Модули и пакеты
В программировании модуль - это часть программного обеспечения, которая обладает определенной функциональностью. Например, при построении игры в пинг-понг один модуль будет отвечать за логику игры, а
другой модуль будет отвечать за рисование игры на экране. Каждый модуль-это отдельный файл, который можно редактировать отдельно.
Написание модулей
Модули в Python-это просто файлы Python с расширением .py. Именем модуля будет имя файла. Модуль Python может иметь определенный и реализованный набор функций, классов или переменных. В приведенном выше примере у нас будет два файла, у нас будет:
mygame/
mygame/game.py
mygame/draw.py
Скрипт на Python game.py будет реализована игра. Он будет использовать функцию draw_game из файла draw.py, или другими словами, draw модуль, реализующий логику прорисовки игры на экране.
Модули импортируются из других модулей с помощью import команда. В этом примере game.py сценарий может выглядеть примерно так:
# game.py
# import the draw module
import draw
def play_game():
...
def main():
result = play_game()
draw.draw_game(result)
# this means that if this script is executed, then
# main() will be executed
if __name__ == '__main__':
main()
drawМодуль может выглядеть примерно так:
# draw.py
def draw_game():
...
def clear_screen(screen):
Импорт объектов модуля в текущее пространство имен
Мы также можем импортировать функцию draw_gameнепосредственно в пространство имен основного скрипта с помощью fromкоманды.
# game.py
# import the draw module
from draw import draw_game
def main():
result = play_game()
draw_game(result)
Возможно, вы заметили, что в этом примере draw_gameне предшествует имя модуля, из которого он импортируется, потому что мы указали имя модуля в importкоманде.
Преимущества использования этой записи заключаются в том, что функции проще использовать внутри текущего модуля, потому что вам не нужно указывать, из какого модуля исходит функция. Однако в любом пространстве имен не может быть двух объектов с одинаковым именем, поэтому importкоманда может заменить существующий объект в пространстве имен.
Импорт всех объектов из модуля
Мы также можем использовать import *команду для импорта всех объектов из определенного модуля, например:
# game.py
# import the draw module
from draw import *
def main():
result = play_game()
draw_game(result)
Пользовательское имя импорта
Мы также можем загружать модули под любым именем, которое захотим. Это полезно, когда мы хотим импортировать модуль условно, чтобы использовать то же имя в остальной части кода.
Например, если у вас есть два draw модули с разными именами - вы можете сделать следующее:
# game.py
# import the draw module
if visual_mode:
# in visual mode, we draw using graphics
import draw_visual as draw
else:
# in textual mode, we print out text
import draw_textual as draw
def main():
result = play_game()
# this can either be visual or textual depending on visual_mode
draw.draw_game(result)
Инициализация модуля
При первой загрузке модуля в запущенный скрипт Python он инициализируется путем однократного выполнения кода в модуле. Если другой модуль в вашем коде снова импортирует тот же модуль, он будет загружен не дважды, а только один раз - поэтому локальные переменные внутри модуля действуют как "синглтон" - они инициализируются только один раз.
Это полезно знать, потому что это означает, что вы можете полагаться на это поведение при инициализации объектов. Например:
# draw.py
def draw_game():
# when clearing the screen we can use the main screen object initialized in this module
clear_screen(main_screen)
...
def clear_screen(screen):
...
class Screen():
...
# initialize main_screen as a singleton
main_screen = Screen()
Расширение пути загрузки модуля
Есть несколько способов, которыми мы могли бы указать интерпретатору Python, где искать модули, помимо стандартного, который является локальным каталогом и встроенными модулями. Вы можете либо использовать переменную среды PYTHONPATH чтобы указать дополнительные каталоги для поиска модулей, например:
PYTHONPATH=/foo python game.py
Это приведет к выполнению game.pyи позволит сценарию загружать модули как из fooкаталога , так и из локального каталога.
Другой метод-это sys.path.appendфункция. Вы можете выполнить его перед выполнением importкоманды:
sys.path.append("/
Это fooтакже добавит каталог в список путей для поиска модулей.
Изучение встроенных модулей
Ознакомьтесь с полным списком встроенных модулей в стандартной библиотеке Python здесь.
Две очень важные функции пригодятся при изучении модулей в Python - функции dirи.help
Если мы хотим импортировать модуль urllib, который позволяет нам создавать данные для чтения из URL-адресов, мы просто importиспользуем модуль:
# import the library
import urllib
# use it
urllib.urlopen(...)
Мы можем найти, какие функции реализованы в каждом модуле, используя dirфункцию:
>>> import urllib
>>> dir(urllib)
['ContentTooShortError', 'FancyURLopener', 'MAXFTPCACHE', 'URLopener', '__all__', '__builtins__',
'__doc__', '__file__', '__name__', '__package__', '__version__', '_ftperrors', '_get_proxies',
'_get_proxy_settings', '_have_ssl', '_hexdig', '_hextochr', '_hostprog', '_is_unicode', '_localhost',
'_noheaders', '_nportprog', '_passwdprog', '_portprog', '_queryprog', '_safe_map', '_safe_quoters',
'_tagprog', '_thishost', '_typeprog', '_urlopener', '_userprog', '_valueprog', 'addbase', 'addclosehook',
'addinfo', 'addinfourl', 'always_safe', 'basejoin', 'c', 'ftpcache', 'ftperrors', 'ftpwrapper', 'getproxies',
'getproxies_environment', 'getproxies_macosx_sysconf', 'i', 'localhost', 'main', 'noheaders', 'os',
'pathname2url', 'proxy_bypass', 'proxy_bypass_environment', 'proxy_bypass_macosx_sysconf', 'quote',
'quote_plus', 'reporthook', 'socket', 'splitattr', 'splithost', 'splitnport', 'splitpasswd', 'splitport',
'splitquery', 'splittag', 'splittype', 'splituser', 'splitvalue', 'ssl', 'string', 'sys', 'test', 'test1',
'thishost', 'time', 'toBytes', 'unquote', 'unquote_plus', 'unwrap', 'url2pathname', 'urlcleanup', 'urlencode',
'urlopen', 'urlretrieve']
Когда мы находим функцию в модуле, который мы хотим использовать, мы можем прочитать о ней больше, используя helpфункцию внутри интерпретатора Python:
help(urllib.urlopen)
Написание пакетов
Пакеты-это пространства имен, которые содержат несколько пакетов и самих модулей. Это просто каталоги, но с изюминкой.
Каждый пакет в Python-это каталог, который ДОЛЖЕН содержит специальный файл под названием __init__.py. Этот файл может быть пустым, и это указывает на то, что каталог, который он содержит, является пакетом Python, поэтому его можно импортировать так же, как можно импортировать модуль.
Если мы создадим каталог под названием foo, который помечает имя пакета, затем мы можем создать модуль внутри этого пакета под названием bar. Мы также не должны забывать добавлять __init__.py файл внутри foo каталог.
Для использования модуля bar, мы можем импортировать его двумя способами:
import foo.bar
или:
from foo import bar
В первом методе мы должны использовать префикс foo всякий раз, когда мы обращаемся к панели модулей. Во втором методе мы этого не делаем, потому что мы импортируем модуль в пространство имен нашего модуля.
__init__.py:
__all__ = ["bar"]