Python для обеспечения географических исследований Лекция 4

Python для обеспечения
географических исследований
Лекция 4
Сегодня на повестке дня:
Смотрим на решение домашних задачек
Функции и всё, что с ними связано (на самом деле не всё)
Основные аспекты работы с текстовыми файлами
2
import math
print "enter x1:"
x1 = input()
print "enter x2:"
x2 = input()
print "enter y1:"
y1 = input()
print "enter y2:"
y2 = input()
dx = x2 - x1
dy = y2 - y1
if (dx >= 0) and (dy > 0):
a=r
elif (dx >= 0) and (dy < 0):
a = 2*math.pi - r
elif (dx < 0) and (dy > 0):
a = math.pi - r
else:
a = math.pi + r
D = math.sqrt(dx*dx + dy*dy)
a = a * 180 / math.pi
print 'D = ' + str(D) + ' ; A = ' + str(a) + ' degrees'
r = math.atan(abs(dy)/abs(dx))
3
print 'Enter phrase:'
string = input ()
#ПРОБЕЛЫ
spaces = 0
for i in string:
if i == " ":
spaces = spaces + 1
print 'Number of spaces: ' + str(spaces)
#ВХОЖДЕНИЯ СИМВОЛОВ 'a' и 'c'
a = []
c = []
i=0
while i < len(string):
if string[i] == 'a':
a.append(i)
if string[i] == 'c':
c.append(i)
i=i+1
print 'a: ' + str(a) + ' ; b: ' + str(c)
4
import math
print 'Enter array'
list = input()
#СУММА
sum = 0.0
for i in list:
sum = sum + i
#СРЕДНЕЕ КВАДРАТИЧЕСКОЕ ОТКЛОНЕНИЕ
otklKvSum = 0.0
for i in otkl:
otklKvSum = otklKvSum + i*i
srKvOtkl = math.sqrt(otklKvSum/len(list))
print 'Standart deviation: ' + str(srKvOtkl)
print 'Summ is ' + str(sum)
#СРЕДНЕЕ
av = sum / len(list)
print 'average is ' + str(av)
#ОТКЛОНЕНИЯ
otkl = []
for i in list:
otkl.append(i-av)
print 'Deviations: ' + str(otkl)
5
i=1.0
while i <= 500.0:
if (i % 7 == 0):
print str(i) + '; '
i=i+1
6
print 'Enter list:'
list = input()
for i in list:
if not (i % 2 == 0):
print i*i
7
ФУНКЦИИ
Функция в python - объект, принимающий аргументы и возвращающий
значение.
Мы уже много сталкивались функциями:
math.sin(x)
print ‘No more mr. Nice Guy’
Функции легко ассоциировать с реальным миром.
Например, функция «Сварить кофе», в качестве параметра принимающая
кофейные зёрна и возвращающая 50 мл жидкости
8
Очень важно уметь создавать собственные функции, реализующие ту или
иную функциональность, которую потом придётся вызывать многократно.
Синтаксис создания простой функции очень прост:
def <имя функции>(<список формальных аргументов>):
<инструкции>
return <выражение>
Посмотрим на простейшую функцию
def add(x,y):
return x + y
9
Теперь в любом месте программы я могу вызвать её:
b = add(3,4) #В b запишется число 7
Давайте внимательно посмотрим на объявление функции и её вызов:
def add(x,y):
return x + y
Это формальные аргументы функции.
Функция запишет в переменные x и y те
значения, которые мы передадим ей при
вызове
b = add (3,4)
Это фактические аргументы функции
Ими могут быть любые выражения,
определенные ранее переменные,
константы, другие функции и т.д.,
всё, что имеет какое-либо значение
10
Имена формальных параметров никак не связаны с именами фактических.
Имя формальной переменной – это сущность, имеющая место исключительно внутри
функции. Она уничтожается сразу после исполнения функции.
def add(x,y):
return x + y
add (2,3)
Мы передаем функции два значения: 2 и 3. Функция при вызове записывает число 2 в
свою внутреннюю переменную x, а число 3 во внутреннюю переменную y. В теле функции
мы свободно оперируем этими переменными x и y, зная, что в них содержится именно то,
что мы ей передали при вызове.
Фактический параметр – это уже конкретное значение, которое мы хотим скормить
функции как исходное.
11
def add(x,y):
return x + y
Разные способы передачи фактических параметров:
c = add(2,2)
a= 2
b= 2
c = add (a,b)
c = add (add(2,2),add(2,2))
c = add (a, 2)
12
Внутри функции мы можем творить любые непотребства, лишь бы чтонибудь в конце концов вернули через return.
Внутри каждой функции может быть, по сути, отдельная сложная программа,
вызывающая другие функции и т.д.
#ЕВКЛИДОВО РАССТОЯНИЕ
def distance(x1,x2,y1,y2):
d = math.sqrt((x2 – x1)*(x2-x1) + (y2 – y1)*(y2 – y1))
return d
print ‘Введите координаты’
a = input ()
b = input ()
c = input ()
d = input ()
print distance (a,b,c,d)
13
В общем случае количество фактических и формальных аргументов должно
совпадать. Но есть варианты.
def summa (a,b,c=4):
return a + b +c
Здесь мы сказали, что есть три формальных аргумента: a, b, c. Но c по умолчанию
приравняли к трём.
Если мы теперь передадим функции два аргумента, она запишет их в a и в b,
а в c автоматически запишет число 3.
Если мы передадим функции три аргумента, то c перезапишется тем, что мы передали.
a = summa ( 1 , 2 , 5 ) # a == 8
a = summa ( 4, 0 ) # a == 7
14
Функция также может принимать переменное количество аргументов.
Тогда перед ними ставится символ *
def sum (*args):
s=0
for i in args:
s=s+i
return s
print sum (2,5,7,4,2,6,7,4)
Используется не очень часто, ведь с тем же успехом можно передать просто
одну переменную-список.
15
Функция может и не заканчиваться инструкцией return, при этом функция вернет
значение None. Такие функции обычно называют процедурами
Их обычно вызывают самостоятельно, а не присваивают переменным.
def func():
print ‘a’
print ‘b’
func()
16
def func():
def f2():
print 'c'
f2()
print 'a'
print 'b'
func()
17
Важная тема: области видимости переменных.
Вы уже обратили внимание на создающиеся внутри функций переменные,
которые уничтожаются после выполнения функции.
Область видимости - место где определяются переменные и выполняется
их поиск.
Всегда, когда в программе используется какое то имя, интерпретатор
создает, изменяет или отыскивает это имя в пространстве имен – в
области, где находятся имена. Когда мы говорим о поиске значения
имени применительно к программному коду, под термином
область видимости подразумевается пространство имен: то есть место в
программном коде, где имени было присвоено значение, определяет
область видимости этого имени для программного кода.
18
Основные для нас моменты:
• Имена, определяемые внутри инструкции def, видны только
программному коду внутри инструкции def. К этим именам нельзя обратиться
за пределами функции.
•Имена, определяемые внутри инструкции def, не вступают в конфликт с
именами, находящимися за пределами инструкции def, даже если и там и там
присутствуют одинаковые имена. Имя X, которому присвоено значение за
пределами данной инструкцииdef (например, в другой инструкции def или на
верхнем уровне модуля), полностью отлично от имени X, которому присвоено
значение внутри инструкции def.
19
def func(x,y):
a=x+4
b=y+1
x=x+1
return a*b
print a # ОШИБКА, Т.К. ПЕРЕМЕННАЯ a СУЩЕСТВУЕТ ТОЛЬКО ВНУТРИ ФУНКЦИИ
x=4
q = func (5,6)
print x # X == 4, т.к. этот X, и X внутри функции – разные сущности. X внутри
функции был уничтожен по её завершеню, а внешний x
в целости и не изменен
20
def func():
def f2():
print 'c'
f2()
print 'a'
print 'b'
func()
f2() # ОШИБКА, Т.К. СУЩНОСТЬ f2 ЖИВЕТ ТОЛЬКО ВНУТРИ ФУНКИИ func, И НИКТО
О НЕЙ БОЛЬШЕ НЕ ЗНАЕТ
21
Переменные и функции, объявленные вне подпрограмм, называются глобальными.
А те, которые объявлены в подпрограммах, называются локальными.
# Глобальная область видимости
X = 99
# X и func определены в модуле: глобальная область
def func(Y):
# Y и Z определены в функции: локальная область
# Локальная область видимости
Z=X+Y
# X – глобальная переменная
return Z
func(1)
# func в модуле: вернет число 100
22
Инструкция global
Инструкция global позволяет изменять переменные, находящиеся на верхнем
уровне модуля, внутри инструкции def.
X = 88
# Глобальная переменная X
def func():
global X #Вызвали глобальную переменную внутрь функции так, что её теперь
можно изменять именно как глобальную
X = 99 # Глобальная переменная X: внутри инструкции def
func()
print(X)
# Выведет 99
23
Попробуем без global
X = 88
# Глобальная переменная X
def func():
X = 99
print (X)
func()
print(X)
# Выведет 88
24
Так лучше не делать, а передавать всё, что может понадобиться внутри функции, как
аргументы, и не изменять при этом внешние переменные.
Функции – важный и мощный инструмент.
Можно создавать программы, состоящие из одних только функций, а затем подключать
их через import, также как мы это делали с math
25
Файл MyFunctions.py:
import math
def distance(x1,x2,y1,y2):
d = math.sqrt((x2 – x1)*(x2-x1) + (y2 – y1)*(y2 – y1))
return d
def circlePerimetr (r):
p = 2*math.pi*r
Файл Module.py:
import MyFunctions
a =MyFunctions.distance (1,2,3,4)
b = MyFuctions.circlePerimetr (5)
26
Самые основы работы с текстовыми файлами.
В основном данные получают в виде текстовых файлов.
В том же виде часто нужно вернуть результат.
Будем считать текстовым файлом любой файл в операционной системе, у
которого есть определенный путь и имя, и данные, записанные в нём, можно
интерпретировать как простой текст (т.е. открыть блокнотом и т.д.).
27
Работа с текстовым файлом начинается с выделения под него отдельной переменной
с помощью функции open.
f = open('text.txt', 'r')
У функции open много разных параметров, нас интересуют только два. Это путь до
файла и режим открытия.
<имя переменной> = open (<путь до файла>, <режим открытия>)
28
Нам интересны режимы ‘r’, ‘w’ и ‘a’
r – если мы хотим прочитать файл
w – если мы хотим создать или перезаписать файл
a – если мы хотим дописать что-то в конец существующего файла
Начнем с чтения.
Чтение можно осуществлять в переменные тремя способами
1. Прочитать определенное количество символов функцией read():
f = open (‘text.txt’,’r’)
a = f.read(4) #Читаем первые четыре символа и записываем в a
При этом указатель в файле смещается на эти 4 позиции, и если мы будем
продолжать читать, то уже начиная с 5го символа
29
f = open ('text.txt','r')
a = f.read(4)
b = f.read(4)
print a
print b
30
2. Чтение всего файла целиком той же функцией.
f = open (‘text.txt’,’r’)
a = f.read() #всё читаем, все строки за раз
print a
31
3. Чтение файла построчно циклом for
f = open (‘text.txt’,’r’)
for line in f:
print line
Добавим для наглядности счетчик:
f = open (‘text.txt’,’r’)
i=0
for line in f:
i=i+1
print str(i) + ‘:’ + line
32
Запись в файл:
Функция f.write (<что записываем>)
f = open (‘text.txt’,’w’)
f.write (‘Stairway to heaven’)
Для записи многострочных текстов используем уже знакомый символ \n
f.write (‘Stairway\nto\nHeaven’)
33
Так можно записывать любые данные. Например, запишем список построчно
f = open ('text.txt','w')
a = [1,7,9,5,3]
for i in a:
f.write(str(i) + '\n')
34
При открытии файла в режиме ‘w’ вся информация в нём уничтожается
Чтобы сохранить информацию в файле, можно использовать режим ‘a’, тогда
записываемая информация дописывается в конец.
После завершения работы с файлом нужно его обязательно закрыть функцией
f.close()
f = open ('text.txt','w')
a = [1,7,9,5,3]
for i in a:
f.write(str(i) + '\n')
f.close()
35
Спасибо за внимание!
e.kazakov@spbu.ru
ekazakov.info/students
36