Найти в Дзене
Влад Пальчевский

Изучение основы в Python

Здравствуй, Мир!

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

Рекомендуем почитать
Документы, вакансии и контакты