4.8

A revisão lição

Programação ideias: uma idéia, para não ir para a aula e programação objeto
1. orientada para o processo: o núcleo do processo, o processo refere-se aos passos para resolver o problema, o programa irá simplificar, simplificar. pobre escalabilidade
2. -Objeto orientado: o núcleo do objecto, o objecto é um recipiente para conter dados e funções. O programa é altamente integrado. Dissociação e melhorar os programas de graduação, aumentando assim a escalabilidade do programa. O projeto do complexo, propenso a problemas de excesso de projeto
  
  Extensibilidade não é o único critério de um programa é bom ou ruim, a idéia de orientada a objeto e processar cada utilização
Programação Orientada a Objetos
1. Categorias: integração de dados e funções, é em si um objeto. Objectos têm as mesmas propriedades ou funções, que podem ser da mesma categoria
  
  Distinção é baseado no mesmo nome atributo de propriedade, não o nome do atributo
2. objetos
3. Primeiro defina a classe, depois de chamar gera uma classe de objeto, em oposição ao pensamento de ordem vida. chamada de procedimento é chamado de instanciação
sistema eletivo

objetos
- Os estudantes objeto
  - nome, idade, classe do aluno
  - características do curso
- Público-alvo
  - nome do curso, período
Chamar a classe o que aconteceu
1. Gera um objecto vazia
2. python automaticamente acionar o init, inicialização completa
3. O objeto é atribuído para produzir o nome do objeto
Nota de inicialização
1. inicialização auto deve receber como primeiro argumento
2. Não deve haver nenhum valor de retorno
Ver o nome do objeto __dict__para obter um dicionário, o dicionário pode ser operado com ou acesso Modificar
Usando o ponto de destino, apontam-como modificação

 stu.name = 'deimos'
 # 若对象中有名字，则修改
 stu.xxx = 30
 # 若没有，则在对象名称空间新增
 stu.school = '111'
 # 如果在类中有school，对象中没有，则此操作是在对象中新增属性，而不是改了类属性

método dentro de usar o tempo de aula para colocar seus objetos como parâmetro
Classe usando a classe de funções e dados que, quando utilizado em estrita conformidade com o método da função de função, o método da classe que vai passar automaticamente parâmetros
classe python3 é gerado em um tipo de dados , pode ser visto pelo nome da classe do tipo de objecto (objecto)
Variáveis definidas no atributo de classe de dados de classe, é compartilhado por todos os objetos, apontando para o mesmo endereço de memória
```
print(id(Student.school)) # 4301108704
print(id(stu1.school)) # 4301108704
print(id(stu2.school)) # 4301108704
print(id(stu3.school)) # 4301108704
```
Todos os pontos são o mesmo objeto funcional, mas o objeto está vinculado a diferentes métodos de ligação diferentes, endereços de memória não são os mesmos
```
print(id(Student.choose)) # 4335426280
print(id(stu1.choose)) # 4300433608
print(id(stu2.choose)) # 4300433608
print(id(stu3.choose)) # 4300433608
```

trabalho

análise

Um claro, corresponde a uma classe, uma classe que corresponde a um campus

class School:
    # 公共数据：学校名，关联班级
    school_name = 'zjnu'


    def __init__(self, nickname, addr):
        self.addr = addr
        self.nickname = nickname
        self.classes = []  # 往列表里加值，代表新建班级


    def related(self, class_name):
        # 关联班级
        self.classes.append(class_name)


    def show_class(self):
        for class_name in self.classes:
            print(self.school_name,self.addr,self.nickname,class_name)


school_obj1 = School('数计学院', '20幢')
school_obj2 = School('音乐学院', '18幢')

school_obj1.related('14班')
school_obj2.related('15班')
school_obj1.show_class()
school_obj2.show_class()

class Class:
    def __init__(self, name):
        self.name = name
        self.course = None

    def related_course(self, course):
        self.course = course


class_obj1 = Class('14期')
class_obj2 = Class('13班')
class_obj1.related_course('python')
class_obj2.related_course('linux')

demanda

Após escolas e classe classes construídas, as aulas quer cursos de vista: o nome não for operado, o destino da operação, métodos tão relacionados associado ao objeto

revisão:

class School:
	def related_class(self,class_obj):
		self.classes.append(class_obj)
        # 原来传的是班级的名字，现在改传班级对象
		
	def tell_class(self):
		print(self.nickname)
		for class_obj in self.classes:
            class_obj.show_info()
            # 得到对象，可以使用对象下的方法
            
class Class:
    def __init__(self, name):
        self.name = name
        self.course = None

    def related_course(self, course):
        self.course = course

    def show_info(self):
        print(self.__dict__)

class Course:
	def __init__(self,name,period,price):
        self.name = name
        self.period = period
        self.price = price
    
    def tell_info(self):
        print(self.name,self.period,self.price)
        
course_obj1 = Course('python开发','6mon','2000')

resumo

Na definição da classe, quando utilizando os dados associados com, o objecto referido, não um nome de referência, de modo que ele método do objecto classe associada pode ser referenciado na classe

Enquanto o objeto passado no passado, e, consequentemente, têm

Requisitos: Use picles, arquivos de objetos serializados guardado para PKL

Faça o nome do arquivo único, com o módulo uuid, init, a inicialização de cada objeto para o objeto quando um UUID, como um ID de objeto

import uuid
uuid.uuid4()

pacote

pacote orientado para o objecto é uma característica do núcleo, os meios de integração que o pacote pode ser adicionalmente processado atributo classe, um atributo da operação de embalagem que esconde

Embalagem atributos de classe

Em atributos de classe, funções e dados, precedido por __possível atributo oculto

class Foo:
	__x = 1
	def __f1(self):
		print('from f1')
    def

Foo.f1
# 报错，被隐藏，不能直接访问到了
print(Foo.__dict__)
# _Foo__f1,_Foo__x

Esta é uma operação de modificação atributo oculto pode não diretamente acesso às propriedades da classe, mas ainda ser capaz de _类名__属性名acesso a
acesso estrangeiro efetivamente escondido, normal a partir de dentro da classe
Irá sublinhar o atributo escondido estágio unificada deformado a verificação de sintaxe definição de classe , não vai propriedades de deformação começando com sublinhado após verificar gramática

Na fase de inicialização, init Propriedades Esconder

def __init__(self,name,age):
	self.__name = name
	self.__age = age

Por que esconder

O objetivo da definição é para uso, não diretamente com o mundo exterior depois que as propriedades ocultas da classe, só para deixar o mundo exterior usando o modo especificado: fornece uma interface

def __init__(self,name,age):
	self.__name = name
	self.__age = age

def get_name(self):
	print(self.__name)
# get_name就是一个接口，只能通过接口访问到属性，可以在接口内添加其他逻辑，控制使用者对属性的操作
def set_name(self,new_name):
    if not isinstance(new_name,str):
        print('修改非法')
        return
    self.__name = new_name
    # 提供了一个修改名字的接口，判断

Rede epidemia de notas de estudo ambiental python sob 4.8

4.8