Для хранения группы (и однородных) объектов используются списки. Они задаются тремя способами:
· Простое перечисление. Например
animal = ["Бобер", 1.2, 31]
· Преобразование строки в список. Например
b = list("help") # b=['h', 'e', 'l', 'p']
· Создание с помощью списковых включений. Например
c=[x**2 for x in range(20) if x%3==1]
# c=[1,16,49,100,169,256,361]
Операторы и функции работы со списками:
len(s) – длина последовательности s
x in s – проверка принадлежности элемента последовательности или принадлежность подстроки строке.
x not in s = not x in s
s + s1 – конкатенация последовательностей
s*n или n*s – последовательность из n раз повторенной s. Если n < 0, возвращается пустая последовательность.
s[i] –i-й элемент s или len(s)+i-й, если i < 0
s[i:j:d] Срез из последовательности s от i до j с шагом
min(s) Наименьший элемент s
max(s) Наибольший элемент s
s[i] = x i-й элемент списка s заменяется на x
s[i:j:d] = t Срез от i до j (с шагом d) заменяется на (список) t
del s[i:j:d] – Удаление элементов среза из последовательности
Кроме того, для списков определен ряд методов.
append(x) – Добавляет элемент в конец последовательности
count(x) – Считает количество элементов, равных x
extend(s) – Добавляет к концу последовательности последовательность s
index(x) – Возвращает наименьшее i, такое, что s[i] == x. Возбуждает исключение ValueError, если x не найден в s
insert(i, x) – Вставляет элемент x в i-й промежуток
pop(i) – Возвращает i-й элемент, удаляя его из последовательности
reverse() – Меняет порядок элементов s на обратный
sort([cmpfunc]) – Сортирует элементы s. Может быть указана своя функция сравнения cmpfunc.
Для преобразования кортежа в список есть функция list, для обратной операции – tuple.
Стеки
Стек – упорядоченная коллекция элементов, где добавление нового или удаление существующих всегда происходит только на одном из концов. Этот конец обычно называют “вершиной”, а противоположный ему - “основанием”.
Операции над стеком
· stack() создаёт новый пустой стек. Параметры не нужны, возвращает пустой стек.
· push(item) добавляет новый элемент на вершину стека. В качестве параметра выступает элемент; функция ничего не возвращает.
· pop() удаляет верхний элемент из стека. Параметры не требуются, функция возвращает элемент. Стек изменяется.
· peek() возвращает верхний элемент стека, но не удаляет его. Параметры не требуются, стек не модифицируется.
· isEmpty() проверяет стек на пустоту. Параметры не требуются, возвращает булево значение.
· size() возвращает количество элементов в стеке. Параметры не требуются, тип результата – целое число
| Операция над стеком | Содержание стека | Возвращаемое значение |
| s.isEmpty() | [] | True |
| s.push(2) | [2] | |
| s.push('эш') | [2,'эш'] | |
| s.peek() | [2,'эш'] | 'эш' |
| s.push(True) | [2,'эш',True] | |
| s.size() | [2,'эш',True] | |
| s.isEmpty() | [2,' эш ',True] | False |
| s.push(3.14) | s.push(3.14) | |
| s.pop() | [2,' эш ',True] | 3.14 |
| s.pop() | [2,' эш '] | True |
| s.size() | [2,' эш '] |
Пример реализации стека:
class Stack:
def __init__(self):
self.items=[]
def isEmpty(self):
return self.items=[]
def push(self,item):
self.items.append(item)
def pop(self):
return self.items.pop()
def peek(self):
return self.items[len(self.items)-1]
def size(self):
return len(self.items)
from python.basic.stack import Stack
s=Stack
print(s.isEmpty
s.push(4)
s.push(‘dog’)
print(s.speek())
s.push(True)
print(s.size())
print(s.isEmpty())
print(s.pop())
print(s.pop())
print(s.size())
Множества
Множество – структура данных из различных элементов, где порядок элементов не определён. Элементы можно добавлять и удалять, перебирать. Можно выполнять операции над множествами (объединение, пересечение, разность). Можно проверять принадлежность элемента множеству.
Элементами множества могут быть с неизменяемыми типами данных: числа, строки, кортежи (неизменяемые списки). Значения с изменяемым типом не могут быть элементами множества – список (но можно сделать кортеж) или другое множество. Это связано с особенностями представления множества в памяти компьютера.
Множество задается перечислением элементов в фигурных скобках. Например:
A={1,2,3}
Функция set() создает пустое множество. Функция set с параметрами в виде списка, строки или кортежа вернет множество, составленное из элементов списка, строки, кортежа. Например:
A = set('один')
print(A)
выведет {'д', 'и', 'н', 'о'}.
Каждый элемент может входить в множество только один раз, порядок задания элементов не важен. Например, программа:
A = set('абракадабра') # A={‘a’, ‘б’, ‘д’, ‘к’, ‘р’}
B = set('бардак') # В={‘a’, ‘б’, ‘д’, ‘к’, ‘р’}
print(A==B)
выдаст значение True.
Примеры присвоения значений:
a=set() # a – пусто
b = {‘б’, ‘e’, ‘р’}
c= set('хан') # с={‘х’, ‘а’, ‘н’}
d={2*i for i in range(5)} # d={0, 2, 4, 6, 8}
e=set([‘бер’, ‘один’, ‘один’, ‘one’, ‘one’, ‘ein’]) # е={‘бер’, ‘один’, ‘one’, ‘ein’}
Число элементов определяет функция len(a). Например:
print(len(set(‘четыре’))) # выведет число 5
Перебор вех элементов множества можно при помощи цикла for
f={1,3,4,7}
for san in f: print(san) # напечатает 7 1 4 3
Принадлежность элемента можно проверить с помощью опереации in.
print(3 in {1,3,4,7}) # напечатает True
Новый элемент добавляет метод add.
a={1,3,4,7}
a.add(6) # a= {1,3,4,6,7}
Метод pop удаляет из множества один случайный элемент, возвращая его значение. При пустом множестве генерируется исключение KeyError
Функция list из множества формирует список.
Операции с множествами:
len(s) – число элементов в множестве
x in s – принадлежность x s
s.isdisjoint(s1) – истина в случае пустого пересечения множеств
s==s1 – истина в случае совпадения множеств
s.issubset(s1) – s подмножество s1
s.issuperset(s1) – s1 подмножество s
s.union(s1,s2…) – объединение множеств
s.intersection(s1,s2,…) – пересечение s с остальными множествами
s.difference(s1,s2…) – вычитание из s подмножеств
s.simmetric_difference(s1) – исключающее или
s.copy(s1) – копирование.
Операции изменения множества:
s.update(s1,s2,…) – добавляет элементы в множестве
s.intersection_update(s1,s2,…) – пересечение в множестве оставляет
s.difference_update(s1,s2,…) – вычитает из множества
s.simmetric_difference_update(s1,s2,…) – оставляет элементы, встречающиеся только в одном множестве
s.add(b) – добавляет элемент
s.remove(b) – удаляет элемент. При удалении не существующего элемента формируется исключение KeyError.
s.discard(b) – удаляет элемент
s.pop() – удаляет случайный элемент
s.clear() – очищает множество
Компьютерная графика
Python работает с несколькими графическими библиотеками, обеспечивая создание сложных приложений с развитым графическим пользовательским интерфейсом. В этой презентации рассматриваются использование «черепашки» для создания графических примитивов и перемещения на плоскости.
Исполнитель «черепашка» управляется командами относительных («вперёд-назад» и «направо-налево») и абсолютных («перейти в точку с координатами...») перемещений. Исполнитель представляет собой «перо», оставляющее след на плоскости рисования. Перо можно поднять, тогда при перемещении след оставаться не будет. Кроме того, для пера можно установить толщину и цвет. Все эти функции исполнителя обеспечиваются модулем turtle («черепаха»).
Приведённая программа создаёт графическое окно и помещает перо («черепашку») в исходное положение:
import turtle # Инициализация
turtle.reset() # Здесь могут быть вычисления и команды рисования
turtle._root.mainloop() # Эта команда показывает окно, пока его не закроют
Рис. Окно рисования
Полученное окно имеет фиксированный размер, зависящий от версии Python, перо позиционируется в центре. Идея рисования заключается в перемещении пера («черепашки») в точки окна рисования с указанными координатами или в указанных направлениях на заданные расстояния, а также в проведении отрезков прямых, дуг и окружностей.
Команды управления «черепашкой»
Полный список команд управления «черепашкой» можно получить через help('turtle'). Вот некоторые из них:
Up() – поднятие пера, чтоб не оставалось следа перемещения
Down() – опускание пера, чтоб при перемещении оставался след
Goto(x,y) – перемещение пера в точку с координатами (x,y)
Color(‘строка цвета’) – изменение цвета пера
Width(n) – установка толщины пера в точках экрана
Forward (n) – перемещение пера вперёд на n точек
Backward (n) – перемещение пера назад на n точек
Right (k) – перемещение пера вправо на k точек
Left (k) – перемещение пера влево на k точек
Circle (r) – рисует окружность радиуса |r|
Write (‘строка’) – печатает текст в текущем положении “пера”
Clear () – очистка области рисования
#_*_coding: utf8_*_
import turtle
#
turtle.reset()
turtle.tracer(0)
turtle.width(2) #ширина пера
# лицо
turtle.up() #поднятие пера
x=0
y=100
turtle.goto(x,y) # установка пера в точку (0,100)
turtle.fill(1) # начало рисования закрашенной области
turtle.color('#ffaa00') # установка оранжевого цвета
turtle.down() # опускание пера
turtle.circle(100) # изображение окружности
turtle.fill(0) # завершение рисования закрашенной области
turtle.color('black')
turtle.circle(100)
turtle.up()
# глаза
x=45
y=50
turtle.goto(x,y)
turtle.down()
turtle.color('#0000aa')
turtle.fill(1)
turtle.circle(7)
turtle.up()
turtle.fill(0)
#
x=45
y=50
turtle.goto(x,y)
turtle.down()
turtle.color('#0000aa')
turtle.fill(1)
turtle.circle(7)
turtle.up()
turtle.fill(0)
#
x=-55
y=-50
turtle.goto(x,y)
turtle.right(45)
turtle.width(3)
turtle.down()
turtle.color('#aa0000')
turtle.circle(80,90)
turtle.up()
#
turtle.right(135)
x=0
y=50
turtle.goto(x,y)
turtle.width(2)
turtle.color('black')
turtle.down()
turtle.forward(100)
#
turtle._root.mainloop()
Пример рисунка
Рисование
turtle.color(color) – цвет курсора color;
turtle.penup() – Поднимаем курсор, что бы при перемещении курсора не происходило рисование линий;
turtle.pendown() – Опускаем курсор, что бы при перемещении курсора происходило рисование линий;
turtle.goto(x, y) – Перейти в точку с координатами x и y;
turtle.circle(radius) – Нарисовать круг с радиусом = radius;
turtle.right(degrees) – Повернуть курсор на право на degrees градусов;
turtle.left(degrees) – Повернуть курсор на лево на degrees градусов;
turtle.forward(length) – Нарисовать линий длиной = length;
turtle.done() – завершение программы, использующий turtle.
import turtle #подключить модуль turtle
Команды для перемещения курсора:
forward(n) #вперед на n пикселей
backward(n) #назад на n пикселей
left(n) #влево на n градусов
right(n) #вправо на n градусов
circle(r) #начертить окружность радиуса r, с центром кслева от курсора, если r>0, справа, если r<0
circle(r,n) #начертить дугу радиуса r, градусной мерой n против часовой стрелки, если r>0, по часовой стрелке, если r<0
goto(x,y) #переместить курсор в точку с координатами (x,y)
Команды рисования:
down() #опустить курсор для рисования
up() #поднять курсор
width(n) #ширина следа курсора в n пикселей
сolor(s) #где s #цвет рисования курсора пример: "red", "blue"
begin_fill(),end_fill() #рисует закрашенные области (начало и конец рисунка)
Дополнительно:
reset() #очищается экран, возвращает курсор
сlear() #очистить экран
write(s) #вывести строку s в точке нахождения курсора
radians() #мера измерения углов в радианы
degrees() #мера измерения углов в градусах
mainloop() #задержка окна
tracer(f) #режим отладки
Цвета, используемый в графике:
Aqua, blue, fuchsia, green, maroon, orange, pink, purple, red, yellow, violet, indigo, chartreuse, lime, import turtle # Импортируем библиотеку turtleturtle.color("black") # Устанавливаем цвет черепашкиturtle.penup() # Поднимаем курсорturtle.goto(-110, -25) # Переходим по нужным координатамturtle.pendown() # Опускаем курсорturtle.circle(45) # Рисуем круг с радиусом 45turtle.color("black")turtle.penup()turtle.goto(0, 80)turtle.pendown()turtle.write("ТҮГӘРӘК") # Вывод надписи " ТҮГӘРӘК"
color('orange', 'red')
width(3)
begin_fill()
while True:
forward(250)
left(144)
if abs(pos()) < 1:
break
end_fill()
done()
Упражнения:
- Нарисуйте на экране равносторонний треугольник.
- Нарисуйте на экране квадрат с диагоналями.
- Нарисуйте две касающиеся окружности.
- Нарисуйте две пересекающиеся окружности.
- Нарисуйте дом.
- Нарисуйте компьютер.
Canvas
Функции: сanvas(root,width=w,height=h,bg="blue", \ cursor="pencil") # холстcanv.create_line(0,0,30,50,width=3,fill="blue", \ arrow=LAST) # линияcanv.create_rectangle(x,y,x+8,y+5,fill="red", \ outline="red") # прямоугольникcanv.create_polygon([250,100],[200,150],[300,150], \ fill="red")canv.create_oval([20,200],[150,300],fill="gray50") # овал from math import *from tkinter import *
root = Tk()
canv = Canvas(root, width = 100, height = 100, \ bg = "lightblue", cursor = "pencil")
canv.create_line(50,100,50,0,width=2,arrow=LAST)
canv.create_line(0,50,100,50,width=2,arrow=LAST)
canv.pack()
root.mainloop()
Рассмотрим еще одну задачу
Canvas (холст) — объект библиотеки tkinter, позволяющий располагать на себе другие объекты. Это могут быть геометрические фигуры, узоры, вставленные изображения и другие видео объектов (например, метки, кнопки, текстовые поля). И это еще не все. Отображенные на холсте объекты можно изменять и перемещать (при желании) в процессе выполнения скрипта. Учитывая все это, canvas находит широкое применение при создании GUI-приложений c использованием tkinter (создание рисунков, оформление других ВО, реализация функций графических редакторов, программируемая анимация и др.).
Для создания объект-холст вызывается класс модуля tkinter и устанавливаются некоторые параметры. Например:
from tkinter import *root = Tk()
canv = Canvas(root,width=600,height=600,bg="white",cursor= "pencil")
Далее с помощью любого менеджера геометрии разместить на главном окне.
Нулевая точка (0,0) для объекта Canvas располагается в верхнем левом углу. Единицы измерения пиксели (точки экрана).
Чтобы нарисовать линию на холсте применяется метод create_line.
canv.create_line(200,50,300,50,width=3,fill="blue")canv.create_line(0,0,100,100,width=6,arrow=LAST,fill="orange")
Четыре числа — это пары координат начала и конца линии, т.е в примере первая линия начинается из точки (200,50), а заканчивается в точке (300,50). Вторая линия начинается в точке (0,0), заканчивается — в (100,100). Свойство fill позволяет задать цвет линии отличный от черного, а arrow – установить стрелку (в конце, начале или по обоим концам линии).
Так для изображения осей можно написать
canv.create_line(500,600,500,0,width=4,arrow=LAST)canv.create_line(0,500,600,500,width=4,arrow=LAST)Метод create_rectangle создает прямоугольник. Аналогично линии в скобках первыми аргументами прописываются четыре числа. Первые две координаты обозначают верхний левый угол прямоугольника, вторые — правый нижний.
x = 70y = 110canv.create_rectangle(x,y,x+80,y+50,fill="white",outline="blue")Опция outline определяет цвет границы прямоугольника.
Многоугольник определяется парами координат для каждой его точки.
canv.create_polygon([250,100],[200,150],[300,150],fill="red")Квадратные скобки при задании координат используются для удобочитаемости (их можно не использовать). Свойство smooth задает сглаживание.
canv.create_polygon(300,80,400,80,450,75,450,200,300,180,330, 160,outline="brown",smooth=0,width=4)canv.create_polygon(300,380,400,380,450,375,450,500,300,480,330, 460,outline="orange",smooth=1,width=4)При создании эллипса задаются координаты прямоугольника, описывающего данный эллипс.
canv.create_oval([20,200],[150,300],fill="pink")Более сложная фигура получается методом create_arc. В зависимости от значения опции style можно получить сектор (по умолчанию), сегмент (CHORD) или дугу (ARC). Координаты по-прежнему задают прямоугольник, в который вписана окружность, из которой «вырезают» сектор, сегмент или дугу. От опций start и extent зависит угол фигуры.
canv.create_arc(160,230,230,330,start=0,extent=240, fill="lightgreen")canv.create_arc(250,230,320,360,start=30,extent=300,style=CHORD, fill="green",width=5)canv.create_arc(340,230,410,330,start=0,extent=140,style=ARC, outline="darkgreen",width=2Последний метод объекта canvas, который будет рассмотрен в этом уроке — это метод создающий текстовую надпись.
canv.create_text(20,430,text="РӘСЕМНӘР",font="arial 36", anchor="w",justify=CENTER,fill="darkred")Трудность здесь может возникнуть с пониманием опции anchor (якорь). По умолчанию в заданной координате располагается центр текстовой надписи. Чтобы изменить это и, например, разместить по указанной координате левую границу текста, используется якорь со значением w (от англ. west – запад). Другие значения: n, ne, e, se, s, sw, w, nw. Если букв, задающих сторону привязки две, то вторая определяет вертикальную привязку (вверх или вниз «уйдет» текст от координаты). Свойство justify определяет выравнивание текста.
Часто требуется нарисовать повторяющиеся элементы, изображение которых обеспечивается через циклы. Например:
y=10while y<450: canv.create_rectangle(520,y,570,y+50,fill="lightgrey") canv.create_line(y,520,y+50,570,fill="green",width=10) canv.create_line(y+50,520,y,570,fill="darkgreen",width=10) y = y + 60Программа завершается
canv.pack()root.mainloop()
Приведенный код даст следующее изображение:
Упражнение 1.
Написать программу рисования графика функции
a) y=cos(x)
b) y=x2
c) y=abs(x)
Упражнение 2.
a) Написать программу рисования контура куба.
b) Написать программу рисование куба с ребрами черного өвета и окрашенными гранями.
Ошибки и исключения
Существуют два типа ошибок: синтаксические и семантические.
Синтаксические ошибки во время трансляции диагностируются и, указывая место ошибки, пишется пояснительный текст по смыслу ошибки.
Семантические ошибки определяются в процессе интерпретации программы. Они обнаруживаются, когда не возможности реализовать данную программную конструкцию или когда тестовые данные или при эксплуатации программы выдаются неправильные результаты. Первый тип ошибок и при тестировании находятся и исправляются в процессе отладки программы.
При решении некоторых задач возможна не корректная подача данных или не допустимая ситуация в этом случае предусматривается ситуация «исключения». Для работы ситуации исключения многие языки программирования предусматривают свои инструментальные средства.
Так для вычисления обратного значения Х можно написать следующий фрагмент программы
X=int(input())
print(1/X)
При вводе значения 2 программа выдаст следующие значения
При вводе 0 программа выдаст следующий фрагмент
Для работы с исключительными ситуациями используется конструкция
try:
# фрагмент программы
…
except: # except имя ошибки: - здесь определяется тип ошибки и реакция
# фрагмент программы, работающий в случае прерывания
…
else: #
# фрагмент программы, работающий в случае отсутствия прерываний
…
finally:
# фрагмент программы, работающий в любом
…
Пример решения задачи с обработкой прерывания
try:
X=int(input())
print(1/X)
except:
print(“Error dividing by zero”)
На экране появится следующее изображение
Инструкция raise позволяет программисту принудительно сгенерировать исключение, которое может использоваться при отладке программы.
Классы
Python ограничен в множественном наследовании в классах. Внутренние переменные и внутренние методы классов начинаются с двух знаков нижнего подчеркивания «__» (например «__myprivatevar»). Можно присвоить значение переменной класса извне. Пример:
class Myclass:
common = 10
def __init__(self):
self. myvariable = 3
def myfunction (self, arg1, arg2):
return self. myvariable
# Здесь объявили класс Myclass.
# Функция __init__ вызывается автоматически при инициализации классов.
classinstance = Myclass ()
# Инициализирован класс и переменная myvariable принимает значение 3 как заявлено в методе инициализации
classinstance.myfunction(1, 2)
#Метод myfunction класса Myclass возвращает значение переменной myvariable
3
# Переменная common объявлена во всех классах
classinstance2 = Myclass ()
classinstance.common # 10
classinstance2.common # 10
# Поэтому, если изменить ее значение в классе Myclass изменятся
# и ее значения в объектах, инициализированных классом Myclass
Myclass.common = 30
classinstance.common # 30
classinstance2.common # 30
# А здесь не изменяется переменная класса. Вместо этого объявляется
# в объекте и присваивается ей новое значение
classinstance.common = 10
classinstance.common # 10
classinstance2.common # 30
Myclass.common = 50
# Теперь изменение переменной класса не коснется переменных объектов
# этого класса
classinstance.common # 10
classinstance2.common # 50
# Следующий класс является наследником класса Myclass, наследуя его
# свойства и методы, к тому же класс может наследоваться из нескольких
# классов, в этом случае запись такая: class Otherclass(Myclass1, Myclass2,
# MyclassN)
class Otherclass (Myclass):
def __init__(self, arg1):
self.myvariable = 3
print arg1
classinstance = Otherclass("hello")
hello
classinstance.myfunction(1, 2) # 3
# Этот класс не имеет совйтсва test, но мы можем
# объявить такую переменную для объекта. Причем
# эта переменная будет членом только classinstance.
classinstance. test = 10 # classinstance.test – 10
Исключения в Python имеют структуру try-except [exceptionname]:
def somefunction():
try:
10 / 0 # Деление на ноль вызывает ошибку
Except ZeroDivisionError:
# Но программа не "Выполняет недопустимую операцию"
# А обрабатывает блок соответствующий ошибке «ZeroDivisionError»
Print "Oops, invalid."
fnexcept ()
Oops, invalid.
Литература
1. http://younglinux.info/book/export/html/48
2. http://younglinux.info/tkinter/canvas.php
3.
Приложения
-------------------------------------------------
Задача C4-0-1.
Решение на языке Python 3.
Автор: Константин Поляков, 2013
E-mail: kpolyakov@mail.ru
Web: kpolyakov.spb.ru
-------------------------------------------------
В первой строке сообщается количество учащихся N, каждая из следующих N строк имеет формат:
<Фамилия> <Инициалы> <номер школы>
где <Фамилия> – строка, состоящая не более чем из 20 символов,
<Инициалы> – строка, состоящая из 4-х символов (буква, точка, буква,
точка), <номер школы> – не более чем двузначный номер. <Фамилия> и
<Инициалы>, а также <Инициалы> и <номер школы> разделены одним пробелом. Пример входной строки:
Иванов П.С. 57
Требуется написать как можно более эффективную программу, которая будет выводить на экран информацию, из какой школы было меньше всего участников (таких школ может быть несколько). При этом необходимо вывести информацию только по школам, пославшим хотя бы одного участника. Следует учитывать, что N>=1000.
"""
import sys
save_stdin = sys.stdin
sys.stdin = open("in/0-1.in")
N = int(input())
schCount = {}
for i in range(N):
fam, io, school = input().split()
schCount[school] = schCount.get(school, 0) + 1
minCount = min(schCount.values())
schMin = [x[0] for x in list(schCount.items()) if x[1] == minCount]
for x in sorted(schMin):
print(x)
sys.stdin = save_stdin
Особенности
· «del» очищает переменные или элементы массива.
· Python имеет большие возможности для работы со списками. Можно использовать операторы объявлении структуры списка. Оператор for может задавать элементы списка в определенной последовательности, а if – может выбирать элементы по условию.
lst1 = [1, 2, 3]
lst2 = [3, 4, 5]
print [x * y for x in lst1 for y in lst2] # [3, 4, 5, 6, 8, 10, 9, 12, 15]
print [x for x in lst1 if 4 > x > 1] # [2, 3]
# Оператор «any» возвращает true, если хотя бы одно из условий, входящих
# в него, выполняется.
any (i % 3 for i in [3, 3, 4, 4, 3])
True
# Следующая процедура подсчитывает количество подходящих элементов
# в списке
sum(1 for i in [3, 3, 4, 4, 3] if i == 3) # 3
del lst1[0]
print lst1 # [2, 3]
del lst1
Сумма цифр числа
| N = int(input()) sum = 0 while N > 0: d = N%10 sum += d N = N // 10 print(sum) | N = int(input()) sum = 0 while N > 0: sum += N%10 N = N // 10 print(sum) |
Число разрядов числа в двоичной записи числа
x = int(input())
cnt = 0
while x > 0:
cnt += 1
x //= 10
print(cnt)
Число единиц в двоичной записи числа
x = int(input())
cnt = 0
while x > 0:
cnt += x % 2
x //= 2
print(cnt)
Максимальная цифра числа
| N = int(input()) maxD = N % 10 while N > 0: d = N % 10 if d > maxD: maxD = d N //= 10 print(maxD) | s= input() S=list(s) print(max(S)) | print(max(list(input()))) |
Сумма всех отрицательных чисел последовательности и максимальное число в последовательности
mx = s = 0
for i in range(1, 5):
x = int(input())
if x < 0: s += x
if x > mx: mx = x
print(s,mx)
1. Задан текст, завершающийся точкой. Написать программу вывода самого большого числа из цифр, использованных в тексте.
| x=input() A=[0,0,0,0,0,0,0,0,0,0] i=0 while(x[i]!='.'): if x[i]>='0' and x[i]<='9': A[int(x[i])]+=1: i+=1 for z in range(9,-1,-1): print(z*A[z],end='') | var a:array['0'..'9'] of integer; i,j,k:integer; c:char; begin for c:='0' to '9' do a[c]:=0; repeat read(c): if c in ['0'..'9'] then a[c]:=a[c]+1 // if (c>='0') and (c<='9') then a[c]:=a[c]+1 until c='.'; for c:='9' downto '0' do for i:=1 to a[c] do write(c) end. |
2. Задано число N и последовательность N натуральных чисел. В конце данных задается контрольное значение. Контрольное значение – максимальное произведение двух чисел из этой последовательности кратных 21.
N = int(input())
M3 = M7 = M21 = M = 0
for i in range(N):
x = int(input())
if x % 21!= 0:
if x % 3 == 0: M3 = max(M3, x)
if x % 7 == 0: M7 = max(M7, x)
if x % 21 == 0 and x > M21:
M = max(M21, M)
M21 = x
else:
M = max(M, x)
R = max(M3*M7, M21*M)
print("Контрольное значение - ", R)
R0 = int(input())
if R == R0: # if int(input()) == R0:
print("Контроль пройден")
else:
print("Контроль не пройден")
3. №11. Ниже записаны две рекурсивные процедуры: F и G:
def F(n):
if n > 0:
G(n - 1)
def G(n):
print('*')
if n > 1:
F(n - 2)
Сколько символов «звёздочка» будет напечатано на экране при выполнении вызова F(11)?
4. №20
x = int(input())
L = x-45
M = x+45
while L!= M:
if L > M: L –= M
else: M –= L
print(M)
http://pythonworld.ru/samouchitel-python
https://habrahabr.ru/post/29778/
[1] Граница с жирной линией считается заштрихованной.
[2] Граница с жирной линией считается заштрихованной. Проверка производится операцией in: X in A, которая принимает значение true в случае принадлежности Х множеству А, иначе принимает значение false.
[3] var x,y,z,i,j,n1,n2,n3:word; a,b,c:string;
begin
read(c);
a:=copy(c,1,pos(' ',c)-1);delete(c,1,pos(' ',c)); x:=length(a);
b:=copy(c,1,pos(' ',c)-1); delete(c,1,pos(' ',c)); y:=length(b);
z:=length(c);
if ((x>y) or (x=y) and (a>b)) and ((x>z) or (x=z) and (a>c)) then write(a)
else if (z>y) or (z=y) and (c>b) then write(c) else write(b)
end.
[4] Для данной задачи будет следующее решение
Var i,j,p:longint; a,b,c:string;
begin
readln(a); read(b); i:=length(a); j:=length(b);
c:=''; p:=0;
while (i>0) and (j>0) do begin
p:=p+ord(a[i])+ord(b[j])-96;
c:=chr(p mod 10+48)+c;
p:=p div 10;
i:=i-1; j:=j-1;
end;
if i=0 then
while j>0 do begin
p:=p+ord(b[j])-48;
c:=chr(p mod 10+48)+c;
p:=p div 10; j:=j-1;
end
else
if j=0 then
while i>0 do begin
p:=p+ord(a[i])-48;
c:=chr(p mod 10+48)+c;
p:=p div 10; i:=i-1;
end;
c:=chr(p+48)+c;
while (c[1]='0') and (length(c)>1) do delete(c,1,1);
write(c)
end.
