Создание классов и объектов. Урок 2

Методическая разработка урока
Элективный курс: Введение в объектно-ориентированное программирование на Python
Уровень: Программирование для начинающих

Итак, программа, написанная с использованием парадигмы объектно-ориентированного программирования, должна состоять из

  • объектов,
  • классов (описания объектов),
  • взаимодействий объектов между собой, в результате которых меняются их свойства.

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

Создание классов:

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

Схематично класс можно представить следующим образом:

class ИМЯКЛАССА:
     ПЕРЕМЕННАЯ = ЗНАЧЕНИЕ
     …
     def ИМЯМЕТОДА(self, ...):
          self.ПЕРЕМЕННАЯ = ЗНАЧЕНИЕ
          …
     … 

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

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

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

Создание объектов:

Объекты создаются так:

ПЕРЕМЕННАЯ = ИМЯКЛАССА()

Здесь скобки обязательны! После такой инструкции в программе появляется объект, доступ к которому можно получить по имени переменной, связанной с ним. При создании объект получает атрибуты его класса, т. е. объекты обладают характеристиками, определенными в их классах.

Количество объектов, которые можно создать на основе того или иного класса, не ограничено.

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

Self:

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

Методу необходимо "знать", данные какого объекта ему предстоит обрабатывать. Для этого ему в качестве первого (а иногда и единственного) аргумента передается имя переменной, связанной с объектом (можно сказать, передается сам объект). Чтобы в описании класса указать передаваемый в дальнейшем объект, используется параметр self. (Посмотрите на схему класса вверху.)

С другой стороны, вызов метода для конкретного объекта в основном блоке программы выглядит следующим образом:

ОБЪЕКТ.ИМЯМЕТОДА()

Здесь под словом ОБЪЕКТ имеется ввиду переменная, связанная с ним. Это выражение преобразуется в классе, к которому относится объект, в

ИМЯМЕТОДА(ОБЪЕКТ, …)

Т. е. конкретный объект подставляется вместо параметра self.

Первая ОО-программа:

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

class First:
     color = "red"
     def out(self):
          print (self.color + "!")

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

obj1 = First()
obj2 = First() 

Оба этих объекта (obj1 и obj2) имею два одинаковых атрибута: color (в виде свойства) и out (в виде метода). Это легко проверить:

print (obj1.color)
print (obj2.color)
obj1.out()
obj2.out() 

В результате выполнения данного скрипта получается вывод двух надписей red и двух red!. Первые две надписи red – это результат применения встроенной функции print по отношению к свойствам объектов. Вторые две надписи red! - результат применения метода out к объектам.

Усложняем программу:

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

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

class Second:
     color = "red"
     form = "circle"
     def changecolor(self,newcolor):
          self.color = newcolor
     def changeform(self,newform):
          self.form = newform
 
obj1 = Second()
obj2 = Second()
 
print (obj1.color, obj1.form) # вывод на экран "red circle"
print (obj2.color, obj2.form) # вывод на экран "red circle"
 
obj1.changecolor("green") # изменение цвета первого объекта
obj2.changecolor("blue")  # изменение цвет второго объекта
obj2.changeform("oval")   # изменение формы второго объекта
 
print (obj1.color, obj1.form) # вывод на экран "green circle"
print (obj2.color, obj2.form) # вывод на экран "blue oval"

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

Как же происходят изменения? Дело в том, что методы помимо параметра self, могут иметь и другие параметры, в которых передаются данные для обработки их этим методом. Так, в примере выше, метод changecolor имеет дополнительный параметр newcolor, с помощью которого в метод можно передать данные о желаемом цвете фигуры. Далее метод меняет цвет с помощью соответствующих инструкций.

Практическая работа:

  1. Напишите два скрипта представленных выше. Посмотрите, как они работают. Во второй программу добавьте еще одно свойство и один метод, позволяющий его менять. Создайте третий объект и измените все его свойства.
  2. Напишите программу в стиле ООП, удовлетворяющую следующим условиям: в программе должны быть два класса и два объекта, принадлежащих разным классам; один объект с помощью метода своего класса должен так или иначе изменять данные другого объекта.

# =)     class bug: color

# =)
 
 
class bug:
    color = 'black'
    life = True
 
 
class spider:
    color = 'red'
    life = True
 
    def kill(self, victim):
        victim.life = False
 
jack = bug()
chuck = spider()
 
chuck.kill(jack)
 
print(jack.life)

Надеюсь я всё правильно понял

Надеюсь я всё правильно понял :)

class car:
    types = "liftback"
    label = "skoda"
    color = "black"
    def equipment(self):
       print ("наша машина до:", self.types,self.label,self.color)
    def equipment2(self):
       if self.color == "black":
           print ("машина не изменилась")
       else:
           print ("наша машина после:", self.types,self.label,self.color)    
 
 
class paintshop:
    colorshop = ["pink","yellow","white"]
    def catalog(self):
        print ("каталог оттенков цвета:", self.colorshop[:])
 
 
    def changecolor(self,newcolor):
        for i in self.colorshop:
             if i == newcolor:
                 car.color = newcolor
                 break
             else:
                 print("такого цвета нет!")
                 break
 
obj1 = car()
obj2 = paintshop()
 
 
obj1.equipment()
obj2.catalog()
 
a = input("введи цвет:")
 
obj2.changecolor(a) 
obj1.equipment2()

Суть, нужно создать

Суть, нужно создать объект-массив(одномерный/двумерный) пренадлежащий классу First, а с помощью метода объекта класса Second удалить строки с максимальным элементов массива.
Привожу в пример код:
Вопрос: правильно ли я понял концепцию ООП, реализовав данную программу?

import random
class First:
    res = [0]
    def createms(self, elementov, strok=0):
        x = int(input('vvedite min elem: '))
        y = int(input('vvedite max elem: '))
        if strok > 0 and elementov > 0:
            self.res = [[random.randint(x, y) for j in range(elementov)] for i in range(strok)]
        elif strok == 0 and elementov > 0:
            self.res = [random.randint(x, y) for i in range(elementov)]
        else:
            print("Massiv ne mojet bit` sozdan, dannie vvedeni ne korektno")
        return self.res
    def outms(self):
        if len(str(self.res[0]))>1:
            for i in range(len(self.res)):
                for j in range(len(self.res[i])):
                    print(self.res[i][j], end=' ')
                print()
        else:
            for i in range(len(self.res)):
                print(self.res[i], end=' ')
            print()
class Second:
    def isklmax(self,obj):
        mas = obj.res
        elemax = 0
        k = 0
        for i in range(len(obj.res)):
            if max(obj.res[i]) > elemax:
                elemax = max(obj.res[i])
        while k < len(obj.res):
            if elemax == max(obj.res[k]):
                del obj.res[k]
            else:
                k += 1
 
obj1 = First()
obj2 = Second()
obj1.createms(5,5)
obj1.outms()
obj2.isklmax(obj1)
print()
obj1.outms()

class A(object): p_A =

class A(object):
    p_A = 0
 
 
class B(object):
    @staticmethod
    def change_prop(obj, prop, val):
        setattr(obj, "p_A", val)
 
 
a = A()
b = B()
 
b.change_prop(a, "p_A", 100)
print(a.p_A)

А подскажите пожалуйста, как

А подскажите пожалуйста, как написать что-то вроде игры "танки", где бы можно было управлять каким-нибудь кружочком, и он бы стрелял нажатием кнопки "пробел". С помощью библиотеки "TKinter".

Открой книгу Майкла Доусона

Открой книгу Майкла Доусона "Программируемый на питон".... Там похожую игру разбирают

class Figure: fill_color =

class Figure:
	fill_color = "white"
	name = ""
	def setName(self,name):
		self.name = name
	def showFigInfo(self):
		print "name =",self.name,
		print "fill_color =",self.fill_color
 
class Bucket:	
	color = "white"
	def pickColor(self,color):
		self.color = color	
	def fill(self,obj):
		obj.fill_color = self.color
 
 
buck = Bucket()
fig = Figure()
 
fig.name = "circle"
buck.color = "green"
 
buck.fill(fig)
fig.showFigInfo() # name = circle fill_color = green

Как-то так. Второй

Как-то так.
Второй пример:

class animal:                                 ##Создали класс животных. 
    types = "Dog"
    color = "Black"
    age =  "18"
    def feature(self):                        ##Функция вывода
        print(self.types,self.color,self.age)
 
a1 = animal()
a1.feature()
 
class new_animal:                             ##Новый класс 
    def new(self,types,color,age):            ##Создали функцию измениния характеристик.
        a1.types = types     
        a1.color = color
        a1.age = age
 
a2 = new_animal()                             ##Объявляем новый объект
new_types = input("Please input new type: ")  ##Присваиваем новый тип
new_color = input("Please input his color: ") ##Присваиваем новый цвет
new_age = input("Please input his age: ")     ##Присваиваем новый возраст
a2.new(new_types,new_color,new_age)           ##Присваиваем новые значение в метод new
a1.feature()                                  ## Смотрим результат

только у тебя получается что

только у тебя получается что объект второго класса (нью энимал) может изменить ТОЛЬКО ОДИН объект другого класса - его название должно быть именно а1.
а вот если ты добавишь в набор параметров неопределенное название изменяемого объекта (напр. obj) - то будет хорошо.

foo = "bar";
baz = "foz";
class new_animal:
     def new(self,obj,types,color,age):
         obj.types=types
         obj.color=color
         obj.age=age

А вообще - бессмыслица какая-то. Меняются параметры объекта абстрактным объектом.
Я вторым объектом у тебя сделал из класса Доктор. Этот доктор может производить операции над первым классом. Прости, но я кастрировал твою виртуальную собачку ((.
Конечно, для этого нужно прописать первому объекту свойство кастрированности.

class Rope: length =

class Rope:
    length = "long"
 
class Scissors:
    def cutrope(self, length, rope):
        rope.length = length
 
rope1 = Rope()
 
print("Rope length on start: " + rope1.length)
 
scissors1 = Scissors()
 
scissors1.cutrope("short", rope1)
 
print("Rope length on finish: " + rope1.length)

Не называйте имена методов и

Не называйте имена методов и переменных транслитом - это очень нехорошая практика!

Только начал изучать пайтон,

Только начал изучать пайтон, это мой первый ЯП. Подскажите, пожалуйста, кто разбирается, нормально ли всё...

class Fridge:
    temp = "cold"
    color = "white"
    def fridge_change(self, new_temp, new_color):
        self.temp = new_temp
        self.color = new_color
 
class Oven:
    temp = "hot"
    color = "black"
    def oven_change(self, new_temp, new_color, new_param):
        self.temp = new_temp
        self.color = new_color
 
fridgest = Fridge()
ovenest = Oven()
 
print(fridgest.temp)
print(fridgest.color)
print(ovenest.temp)
print(ovenest.color)
 
ovenest.new_param = fridgest.temp + " " + fridgest.color
print(ovenest.new_param)

все нормально. Только

все нормально. Только непонятно, чего ты добился. Аттрибуты объекта ovenest как были, temp='hot',color='black'. Можешь это проверить, набрав
ovenest.temp или(и) ovenest.color.
Предпоследней строчкой ты установил нигде не работающую переменную new_param.
Судя по выбранным объектам, ты не усвоил принципов ООП. Как холодильник может изменить печь и наоборот?
Выбери два объекта так, чтобы один мог реально изменять другой.
Например,

класс Лес:
    количество деревьев(n)
класс Лесник 
    метод посадка новых деревьев 
<code>Метод посадка(объект, количество)
          oбъект.n= oбъект.n+количество

Лесника будут звать Петя
А Лес будет Букингемский
Петя=Лесник()
Букингемкий=Лес()
Петя.посадка(Букингемский,50) - #видишь! переменная "объект" приняла конкретно объект "Букингемский". Методу Лесника по-барабану в какой объект "сажать". Лишь бы у того объекта был аттрибут n. Если, допустим, у класса Лесник окажется аттрибут-свойство n, то можно будет Пете посадить деревья в другого Лесника, и даже в себя))))

Рабочий пример class Chelovek

Рабочий пример

class Chelovek :
    sv1 = "Head"
    sv2 = "Hands"
    sv3 = "Legs"
    def changechel (self, newsv1) :
        self.sv1 = newsv1
        return self.sv1
class Robot :
    sv1 = "Metal Head"
    sv2 = "Metal Hands"
    sv3 = "Metal Legs"
chel = Chelovek()
rob = Robot()
print (chel.sv1)
chel.changechel("SuperHead")
print (chel.sv1)
print (rob.sv1)
rob.sv1 = chel.changechel("SuperMetalHeadRob")
print (rob.sv1)

class android1:

class android1:
    """Robot1"""
    weapon="Базука"
    hand=2
    def chweapon(self,newweapon):
        self.weapon=newweapon
    def chhand(self,newhand):
        self.hand=newhand
 
class android2:
    """Robot2"""
    weapon="пукалка"
    hand=4
    def chweapon(self,newweapon):
        self.weapon=newweapon
 
    def chhand(self,newhand):
        self.hand=newhand
 
robot1=android1()
robot2=android2()
 
print ("Имя-",robot1.__doc__,"Оружие=",robot1.weapon,"Рук-",robot1.hand)
print ("Имя-",robot2.__doc__,"Оружие=",robot2.weapon,"Рук-",robot2.hand)
 
robot2.chweapon("стингер")
print ("Имя-",robot1.__doc__,"Оружие=",robot1.weapon,"Рук-",robot1.hand)
print ("Имя-",robot2.__doc__,"Оружие=",robot2.weapon,"Рук-",robot2.hand)
 
robot2.chweapon(robot1.weapon)
print ("Имя-",robot1.__doc__,"Оружие=",robot1.weapon,"Рук-",robot1.hand)
print ("Имя-",robot2.__doc__,"Оружие=",robot2.weapon,"Рук-",robot2.hand)

Доброго времени суток,

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

class snake(object):
    hungry = True
    catch_mouse = False
    poison = 0
 
    def set_poison(self, newpoison):
        self.poison = newpoison
 
    def catch(self, flag_catch)
        self.catch_mouse = flag_catch
        if self.catch_mouse:
            self.hungry = False
 
    def atack_poison(self, mouse):
        if self.hungry == False:
            while mouse.health != 0:
                self.poison = self.poison - 10 - mouse.move_speed
                mouse.health =  mouse.health - 10
                print("Health:", mouse.health, "    ", "Poison:",
					self.poison)
 
 
 
class mouse(object):
    health = 0
    move_speed = 1
 
    def set_health(self, newhealth):
        health = newhealth
 
 
 
 
python = snake()
micky = mouse()
 
python.set_poison(120)
micky.set_health(100)
 
python.catch(True)
python.atack_poison(micky)

def set_health(self,

def set_health(self, newhealth):
        health = newhealth

Здесь забыто self во второй строке. Надо:

def set_health(self, newhealth):
        self.health = newhealth

Спасибо, всё заработало.

Спасибо, всё заработало. Скажите, а Вы будете писать ещё о Си, очень хочется? Сложные структуры данных какие-нибудь

В ближайшее время вряд ли

В ближайшее время вряд ли )
Могу порекомендовать книгу X. Дейтел, П. Дейтел. Как программировать на C. (можно найти pdf в интернете).

class apple: color =

class apple:
    color = 'red'
    form = 'sphere'
    taste = 'sour'
 
    def changecolor(self,newcolor):
        self.color = newcolor
    def changeform(self, newform):
        self.form = newform
    def changetaste(self, newtaste):
        self.taste = newtaste
apple1 = apple()
apple2 = apple()
 
answear = raw_input('How long is your apple been siting out?')
if answear > '7':
    answear == apple1
    print 'You can NOT eat that'
    apple1.changecolor('brown')
    apple1.changeform('pale')
    apple1.changetaste('like sh*t')
    print (apple1.color, apple1.form, apple1.taste)
 
elif answear <= '7':
    answear == apple2
    print 'You can eat that'
    apple2.changecolor('color is better than it ever been')
    apple2.changeform('form is better than it ever been')
    apple2.changetaste('taste is better than it ever been')

#!/usr/bin/python # -*-

#!/usr/bin/python
# -*- coding: utf-8 -*-
class WorldCup:
	sport = 'Biathlon'
	winner = {'name': 'Magdalena', 'lastname': 'Neuner'}
	def change_sport(self, new_sport):
		self.sport = sport
	def change_winner(self, winner_name, winner_lastname):
		self.winner['name'] = winner_name
		self.winner['lastname'] = winner_lastname
 
season2013 = WorldCup()
 
class Sportsman:
	name = 'Kaisa'
	lastname = 'Makarainen'
	sport = 'Biathlon'
	country = 'Finland'
	def win_world_cup(self, season):
		if self.sport == season.sport:
			season.change_winner(self.name, self.lastname)
 
kaisa = Sportsman()
kaisa.win_world_cup(season2013)
 
print(season2013.winner['name'] + ' ' + season2013.winner['lastname'] + ' win the ' + season2013.sport + ' World Cup 2013!')

У меня так получилось: class

У меня так получилось:

class man(object):
    is_father = False
 
    def make_a_child(self,girl):
        girl.is_pregnant = True
        girl.catcha(self)
 
class woman(object):
    is_pregnant = False
 
    def catcha(self,boy):
        if self.is_pregnant == True:
            boy.is_father = True
 
Vasya = man()
Olya = woman()
 
print Olya.is_pregnant
print Vasya.is_father
 
Vasya.make_a_child(Olya)
 
print Olya.is_pregnant
print Vasya.is_father

Надеюсь правильно понял, что

Надеюсь правильно понял, что всю работу надо увести в классы, а в теле оперировать объектами и методами.

class Sush:
    par1=""
    def inp(self):
        self.par1=input("Напишите существительное: \n")
##################################
class Glag:
    par2=""
    def change(self,obj):
        glag=["","","ползет","летит","плывет","стучит","гремит","жует","спит","сидит","орет","стоит","гуляет"]
        if len(obj.par1)>12:
            print("А я длиннее знаю!")
            return
        self.par2=glag[len(obj.par1)] # Глагол подбирается от количества букв в существительном
    def out(self):
        print(self.par2)
###################################
obj1=Sush()
obj2=Glag()
###################################
i=0
while i<5:
    obj1.inp()
    obj2.change(obj1)
    obj2.out()
    i=i+1

без примеров комментаторов не

без примеров комментаторов не разобрался бы, спасибо, вот мой вариант 2-го задания:

class First:
    color = 'red'
    def out(self):
        print(self.color + '!')
 
class Second:
    color = 'green'
    form = 'circle'
    size = 'big'
    def changecolor(self,newcolor):
        self.color = newcolor
    def changeform(self,newform):
        self.form = newform
    def changesize(self,newsize):
        self.size = newsize
    #метод меняет цвет объекту другого класса
    def change_other_obj_color(self,abc,newcolor):
        abc.color = newcolor
 
#Создаём 2 объекта разных классов
object1 = First()
object2 = Second()
 
print(object1.color) #до, цвет: red
 
#метод объекта класса Second() меняет цвет объекту класса First()
object2.change_other_obj_color(object1, 'white') 
 
print(object1.color) #после, цвет: white

вот моё решение второй

вот моё решение второй задачи

#!/usr/bin/python2.7 -tt
# -*- coding: utf-8 -*-
 
class First: #класс, в котором будем менять атрибут
     color = "red" #собственно сам атрибут
     def out(self): #метод, который выведет результат наших действий
        print (self.color + "!") #вывод
 
f = First() #объявляем первый объект
 
class change: #класс, методы которого изменят атрибут color в объекте f
	def change(self,color): #метод, делающий изменения
		f.color = color #в этой строке присваиваем новое значение атрибуту color в объекте f
 
c = change() #объявляем второй объект
f.out() #смотрим существующее значение атрибута color в объекте f
 
newcolor = raw_input("цвет?: ") #присваиваем новый цвет
c.change(newcolor) #передаём новое значение в метод change объекта c
f.out() #смотрим результат

По мотивам решения 2-го

По мотивам решения 2-го задания. Немного развивая представленное ниже, в комментариях, примерное решение автора сайта

##Заведем класс Chislo, объекты которого будут иметь лишь один атрибут
class Chislo:
	znach = 0
 
#Заведем класс STEPING, в нем будет параметр "шаг" (атрибут stepp), а также
#функции для прибавления к Числу этого шага, либо вычитания
 
class STEPING:
	stepp = 0
	def stepUP(self, ch):
		ch.znach = ch.znach + self.stepp 
	def stepDOWN(self, ch):
		ch.znach = ch.znach - self.stepp
 
#И теперь заводим класс, который будет нам заводить новое значение Числа
#и шага, и передавать объектам соответственно классов Chislo и STEPING.
#В данном классе при создании объекта атрибутов self.n_ch (новое число) и 
#self.n_st (новый шаг) нет, они появятся только после выполнения процедур
#set_new_ch и set_new_st
 
class Change:
	def set_new_ch(self, new_ch, ch):
		self.n_ch = new_ch
		ch.znach = self.n_ch
	def set_new_st(self, new_step, step):
		self.n_st = new_step
		step.stepp = self.n_st
 
#заводим объекты наших классов
 
>>> ch1 = Chislo()
>>> print (ch1.znach)
0
 
>>> step1 = STEPING()
>>> print (step1.stepp)
0
 
>>> changer1 = Change()
>>> print (changer1.n_ch)
Traceback (most recent call last):
  File "<pyshell#26>", line 1, in <module>
    print (changer1.n_ch)
AttributeError: 'Change' object has no attribute 'n_ch'
##это то, о чем было написано выше, пока атрибута n_ch нет, команде print 
#показать нечего
 
#заводим этот атрибут, назначаем ему значение 3 и передаем объекту ch1
>>> changer1.set_new_ch(3, ch1)
>>> print (changer1.n_ch)
3
>>> print (ch1.znach)
3
 
#теперь также заводим атрибут new_st, назначаем шаг и передаем его
>>> changer1.set_new_st(5, step1)
>>> print (step1.stepp)
5
 
#что же, произведем сложение Числа и Шага
>>> step1.stepUP(ch1)
>>> print (ch1.znach)
8
 
#назначим другой шаг и вычтем его
>>> changer1.set_new_st(10, step1)
>>> step1.stepDOWN(ch1)
>>> print (ch1.znach)
-2

не супер задача :), но видно взаимодействие классов на еще одном примере

Т.е. третий класс (Change)

Т.е. третий класс (Change) меняет свойства объектов других классов. Тогда он мог бы быть более универсальным и не зависеть от свойств конкретных объектов. Например:

class Change:
	def set_new(self, new_ch):
		self.n_ch = new_ch
		return self.n_ch

Тогда вызов метода для изменения свойства объекта выглядел бы так:

ch1.znach = changer1.set_new(7)
step1.stepp = changer1.set_new(7)

Однако здесь уже нет передачи объекта в качестве параметра. Сделать так, чтобы метод set_new принимал объекты разных классов и менял их свойства, сложнее, если вообще возможно. Первое что приходит в голову - это определение классов Chislo и Stepping таким образом, чтобы у них был похожий интерфейс. Т.е. свойство znach и stepp должны называться одинаково.

Решение вашей задачи с помощью двух классов может выглядеть так:

class Chislo:
    znach = 0
    def new_znach(self, n):
        self.znach = n
 
class Steping:
    stepp = 0
    def new_stepp(self, n):
        self.stepp = n
    def stepUp(self, obj):
        obj.znach = obj.znach + self.stepp
    def stepDown(self, obj):
        obj.znach = obj.znach - self.stepp

>>> ch1 = Chislo()
>>> step1 = Steping()
>>> print(ch1.znach, step1.stepp)
0 0
>>> ch1.new_znach(10)
>>> step1.new_stepp(3)
>>> print(ch1.znach, step1.stepp)
10 3
>>> step1.stepUp(ch1)
>>> print(ch1.znach)
13
>>> step1.new_stepp(5)
>>> print(ch1.znach, step1.stepp)
13 5
>>> step1.stepDown(ch1)
>>> print(ch1.znach)
8

Что можно из двух классов это

Что можно из двух классов это понятно, тут и в один можно все затолкать,тут для примера раскидано))

Про return спасибо за подсказку.

Одно не понятно, если можно сказать

ch1.znach = 7

зачем мы тут процедуры для назначения параметров внутри классов городим, делаем процедуру типа
def out(self):
		print (self.znach)

если можно просто:
>>>ch1.znach
7

(где тут удивленный смайлик)) )

Этим грешат все учебные

Этим грешат все учебные примеры. В них главное показать механизм (как это делается), а смысл (а нужно ли). Если делать более правдоподобный код, то может потеряться простота и наглядность.

Например, тело метода out может выглядеть более сложно, и результат его выполнения не будет таким же как просто вывод свойства znach.

##Создаем класс mebel, по

##Создаем класс mebel, по умолчанию все объекты этого класса это стул, ##черный, деревянный, в классе есть функция просмотра характеристики объекта (harakteristika(self)), второй класс меняет характеристики объекта predm1 класса mebel
 
class mebel:
	types = 'stul'
	color = 'black'
	material = 'forest'
	def harakteristika(self):
		print(self.types, self.color, self.material)
 
>>> predm1 = mebel()
>>> predm1.harakteristika()
stul black forest
 
class ch_pred:
	def ch_all(self, ch_types, ch_color, ch_material):
                predm1.types = ch_types
                predm1.color = ch_color
                predm1.material = ch_material
 
>>> ch_predm1 = ch_predm()
>>> ch_predm1.ch_all('stol', 'white', 'plastic')
>>> predm1.harakteristika()
stol white plastic

##Вот еще несколько примеров,

##Вот еще несколько примеров, как объекты одного класса могут воздействовать
##на объекты другого класса на примере списков
##
##Заведем класс, в нем переменную-список "а", и функцию, которой можно ее саму менять:

class A:
	a = [1,2,3]
	def izm_a(self, aa, bb, cc):
		self.a = [aa, bb ,cc]
	def znach_a(self):
		print ('znachenie a -', self.a)

##заводим объект, смотрим чему он равен и потом меняем его значение:
>>a1 = A()
>>a1.znach_a()
znachenie a - [1, 2, 3]
>>a1.izm_a(58, 69.9, 'www')
>>a1.znach_a()
znachenie a - [58, 69.9, 'www']

##теперь заведем класс В, который будет менять значение
##переменной "а" объекта а1
class B:
	def izm_a1(self, aa1, bb1, cc1):
		a1.a = [aa1, bb1, cc1]

##заводим объект b1 и меняем значение объекта a1 класса А:
>>b1 = B()
>>b1.izm_a1(85, 9.96, 'mmm')
>>a1.znach_a()
znachenie a - [85, 9.96, 'mmm']

##Теперь заведем класс С, значение переменной "с" объекта с1
##которого будет меняться в зависимости от значения
##переменной "а" объекта а1 класса А, также применим
##конструкцию IF (исключительно для примера):
class C:
	c = 'null'
	def izm_c(self):
		if len(a1.a[2]) > 4:
			self.c = 'BOLSHE 4'
		else:
			self.c = 'MENSHE 4'
	def znach_c(self):
		print (c)

##заводим объект, смотрим чему равно "а" объекта а1, "с" объекта с1,
##затем запускаем функцию изменения значения
##переменной "с" объекта с1, которое изменится в зависимости
##от длины третьего значения переменной "а":
>>c1 = C()
>>a1.znach_a()
znachenie a - [85, 9.96, 'mmm']
>>c1.znach_c()
null
>>c1.izm_c()
>>c1.znach_c()
MENSHE 4

##изменим длину третьего значения переменной "а" через объект b1:
>>b1.izm_a1(85, 9.96, 'python')
>>a1.znach_a()
znachenie a - [85, 9.96, 'python']
>>c1.izm_c()
>>c1.znach_c()
BOLSHE 4

##ну или вот такая зависимость, теперь пусть с1 примет
##значение в зависимости от величины первого значения
##переменной "а" в а1:
class C:
	c = 5
	def izm_c(self):
		if a1.a[0]) > 10:
			self.c = len(a1.a[2])
		else:
			self.c = len(a1.a[2]) +50
	def znach_c(self):
		print (c)
 
>>c1 = C()
>>c1.znach_c()
5

##меняем значения первого и второго символа символа через b1:
>>b1.izm_a1(2, 4, 'python')
>>a1.znach_a()
znachenie a - [2, 4, 'python']

##как видим а[0] = 2 и, следовательно, меньше 10,
##поэтому "с" должно принять значение - "длина а[2] + 50"
>>c1.izm_c()
>>c1.znach_c()
56

##или вот так вот

class C:
	c = 5
	def izm_c(self):
		if a1.a[0]) > 10:
			self.c = len(a1.a[2]) +50
		else:
			self.c = [a1.a[0]) +5, a1.a[1])/10]
	def znach_c(self):
		print (c)
 
>>c1 = C()
>>c1.znach_c()
[0, 0]
>>a1.znach_a()
znachenie a - [2, 4, 'python']
>>c1.izm_c()
>>c1.znach_c()
[7, 0.4]

##ну или вот так вот еще с индексами:
>>> class C:
	c = [0,0,0]
	def izm_c(self):
		if a1.a[0] > 10:
			self.c = [5, 5, 5]
		else:
			self.c = [a1.a[0]+(a1.a[0]/2), a1.a[1]+5, 'www']
	def znach_c(self):
		print(self.c)
 
 
>>> c1 = C()
>>> c1.znach_c()
[0, 0, 0]
>>> a1.znach_a()
[1, 2, 3]
>>> c1.izm_c()
>>> c1.znach_c()
[1.5, 7, 'www']

# -*- coding: cp1251

# -*- coding: cp1251 -*-
class Stul:
    color="Коричневый"
class Stol:
    form="Квадрат"
    def changecolor(self,color):
        self.color=color
        stul1.color=color
stul1=Stul()
stol1=Stol()
stol1.changecolor("Белый")
print (stol1.color)
print (stul1.color)

Замечания

Вот здесь кажется небольшая ошибка. Тестировал на python 2.7
print (obj1.color, obj1.form) # вывод на экран "red circle"
print (obj2.color, obj2.form) # вывод на экран "red circle"

А надо:
print obj1.color, obj1.form # вывод на экран "red circle"
print obj2.color, obj2.form # вывод на экран "red circle"

Тогда вроде бы правильно выводит:
red circle
red circle

Это для Python 3. В нем print

Это для Python 3. В нем print уже функция и без скобок не используется.

Напишите пожалуйста решение.

Напишите пожалуйста решение.

Примерное решение для второго задания

class First:
    def setcolor(self,newcolor):
        self.color = newcolor
 
class Second:
    shade = 'light'
    def colorL(self,obj):
        obj.color = self.shade + obj.color      
 
objF = First()
objF.setcolor('blue');
print(objF.color)
 
objS = Second()
objS.colorL(objF)
print(objF.color)

А ведь у класса First не было

А ведь у класса First не было свойства color! Оно что, "с лёта" устанавливается методом второго класса?

если можно, то поясните

если можно, то поясните пожалуйста эти строки:

def colorL(self,obj):
        obj.color = self.shade + obj.color 

и

objS.colorL(objF)
print(objF.color)

так как чуть чуть непонятно ;/

Метод colorL принимает в

Метод colorL принимает в качестве аргументов два объекта: сам объект, к которому применяется метод (параметр self) и любой другой объект (obj).
def colorL(self,obj):

В теле метода colorL изменяется значение свойства color объекта obj: к нему спереди добавляется значение, которое "хранится" в свойстве shade объекта self (т.е. того, к которому применяется метод). В shade "хранится" строка 'light'.
obj.color = self.shade + obj.color

В objF.color хранится значение 'blue'. objS.colorL меняет его на 'lightblue'.

Строку objS.colorL(objF) можно записать так: colorL(objS,objF), что понятней. Но поскольку это не просто функция, а метод объекта, то принято писать, как в первом случае.

А как ObjF

А как ObjF принимает свойство color оно не задано в классе?

Мы его задаем посредством

Мы его задаем посредством команды
objF.setcolor('blue')
но до этой команды objF не обладает атрибутом color.