O desenvolvimento de APIs em Python é um dos pilares para criar soluções modernas e escaláveis. As APIs permitem que diferentes sistemas se comuniquem, otimizando processos e conectando serviços de maneira eficiente. Com o aumento do consumo de serviços digitais, a escolha do Python API Frameworks certo se tornou um fator decisivo para garantir alta performance e uma boa experiência para o usuário (Rodrigues, 2022). Por isso, profissionais e estudantes devem compreender as opções disponíveis e suas funcionalidades específicas para obter os melhores resultados.
Escolher um framework eficiente vai além de conhecer os nomes mais populares. É necessário avaliar suas características, como facilidade de uso, suporte à escalabilidade e compatibilidade com tecnologias modernas. Enquanto frameworks como Flask oferecem simplicidade e flexibilidade, opções robustas como Django trazem um ecossistema completo, ideal para projetos mais complexos. Já o FastAPI combina alta performance e recursos modernos, como programação assíncrona e validação automática de dados (Medina, 2020). Cada ferramenta atende a diferentes cenários, e entender essas diferenças ajuda a evitar gargalos e a melhorar a produtividade (Johnson, 2021).
Além disso, a comunidade Python desempenha um papel essencial no desenvolvimento de frameworks. Atualizações frequentes e a riqueza de tutoriais garantem suporte técnico e a constante evolução das ferramentas (Oliveira, 2020). Ao longo deste artigo, você verá exemplos práticos, comparações detalhadas e casos de uso que ilustram como cada Python API Frameworks funciona. Seja você iniciante ou experiente, este conteúdo ajudará a identificar o framework ideal para seus projetos. Então, prepare-se para explorar as melhores práticas e ferramentas para criar APIs robustas e escaláveis.
Conceitos Básicos sobre Python API Frameworks
Antes de mergulhar em exemplos práticos, vale destacar pontos fundamentais. Você precisa saber que o termo Python API Frameworks engloba ferramentas que facilitam a criação de endpoints e rotas para comunicação entre sistemas (Oliveira, 2021). Aliás, esses frameworks surgiram para poupar trabalho repetitivo e padronizar processos que, de outra forma, demandariam muita configuração manual. Assim, eles oferecem estruturas prontas para lidar com requisições HTTP, parse de dados e tratamento de erros, entre outras funcionalidades relevantes (Nascimento, 2022). Contudo, não podemos ignorar o papel do SEO, mesmo em um cenário de APIs. Empresas criam APIs para fornecer dados a plataformas públicas, e essas plataformas podem influenciar a indexação de serviços e de documentação (Moz, 2020). Embora a API em si não dependa de otimizações diretas de busca, documentações e endpoints bem organizados impulsionam a visibilidade do projeto. Por isso, manter boas práticas de SEO nos sites que detalham a API faz toda a diferença. Dessa forma, você facilita o acesso e os estudos sobre sua solução. Além disso, você deve reconhecer que o Python API Frameworks se destaca por uma comunidade engajada. Esse grupo produz artigos, fóruns e guias que mostram como criar APIs do zero, integrando recursos de autenticação e bancos de dados (Smith, 2022). Você encontra suporte para deploy em nuvens como AWS e Azure, o que simplifica a escalabilidade. Então, entender essa base ajuda a aproveitar melhor as vantagens de cada framework. Posteriormente, veremos exemplos práticos de implementação de rotas e gerenciamento de dados de maneira simples e confiável.
Requisitos para Escolher um Python API Frameworks
Inicialmente, você deve levantar as principais características que um Python API Frameworks precisa ter para cumprir as exigências do projeto. Entre elas, aparecem a facilidade de configuração, o suporte a padrões de segurança e a compatibilidade com bancos de dados (Garcia, 2021). Você também deve considerar a quantidade de desenvolvedores que trabalham na comunidade e a qualidade da documentação. Além disso, checar se o framework possui extensões ou plugins ajuda a saber se ele conseguirá acompanhar o crescimento do projeto. Portanto, uma decisão bem fundamentada garante fluidez no processo de desenvolvimento e reduz riscos de retrabalho. Da mesma forma, você precisa identificar se a ferramenta oferece integrações com bibliotecas conhecidas. Por exemplo, conectores para PostgreSQL ou MongoDB agilizam a codificação (Brown, 2020). Do mesmo modo, recursos de cache e gerenciamento de sessão simplificam o código e reduzem a necessidade de configurações complexas. Com isso, você mantém foco na lógica de negócio e não se perde em detalhes avançados. Assim, o software ganha consistência, e você minimiza a chance de bugs difíceis de rastrear. Por último, avalie performance e escalabilidade, pois um Python API Frameworks robusto deve lidar com grandes volumes de requisições sem travar (Hoffman, 2019). Frameworks que tratam bem threads ou processos paralelos suportam cenários de alta disponibilidade. Porém, nem sempre você precisa de algo tão avançado. Por isso, entender seu fluxo de uso e o crescimento previsto facilita a melhor escolha. Então, compare resultados de testes de benchmark antes de definir a rota.
Flask e Primeiro Exemplo de Código
Flask costuma ser a primeira preferência de quem procura um Python API Frameworks simples e customizável (Grinberg, 2018). Ele oferece flexibilidade para criar a aplicação conforme suas necessidades, sem impor um padrão muito rígido. Porém, você precisa adicionar componentes extras, como gerenciadores de banco de dados e bibliotecas de autenticação, para lidar com formatos de resposta. Esse cenário agrada quem deseja algo minimalista, mas exige conhecimento na hora de escolher extensões. Assim, você explora a leveza de Flask sem deixar de lado funcionalidades importantes. Por exemplo, você cria um endpoint básico em Flask deste jeito:
from flask import Flask, jsonify
app = Flask(__name__)
@app.route('/hello')
def hello():
return jsonify({'message': 'Hello Flask!'})
if __name__ == '__main__':
app.run(debug=True)
Nesse caso, você possui uma rota /hello que retorna um JSON. Essa abordagem esclarece como as rotas funcionam e como adicionar lógica personalizada. Entretanto, Flask não inclui um ORM nativo para gerenciar dados. Quem deseja trabalhar com bancos de dados opta por extensões como Flask-SQLAlchemy (Flask, 2021). Além disso, a estrutura de pastas fica livre e não impõe regras rígidas. Esse fator agrada quem prefere flexibilidade. Entretanto, equipes grandes podem enfrentar desafios ao manter um projeto volumoso sem diretrizes claras (Martins, 2019).
Caso Prático com Flask
Imagine um cenário de e-commerce onde você precisa gerenciar produtos e categorias. Em Flask, você instala Flask-SQLAlchemy e configura um arquivo app.py para centralizar rotas e conexões de banco (Souza, 2020). Assim, você cria modelos Python que refletem as tabelas de produtos e categorias. Veja um trecho:
from flask import Flask, request, jsonify
from flask_sqlalchemy import SQLAlchemy
app = Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///loja.db'
db = SQLAlchemy(app)
class Produto(db.Model):
id = db.Column(db.Integer, primary_key=True)
nome = db.Column(db.String(100), nullable=False)
preco = db.Column(db.Float, default=0.0)
@app.route('/produtos', methods=['GET'])
def listar_produtos():
produtos = Produto.query.all()
retorno = [{'id': p.id, 'nome': p.nome, 'preco': p.preco} for p in produtos]
return jsonify(retorno)
Esse código ilustra como listar produtos de um banco SQLite com poucas linhas. Embora prático, você precisa implementar segurança e validações manualmente, pois Flask não traz isso de forma nativa (Grinberg, 2018). Ainda assim, o caso confirma a facilidade de aprendizado e a rapidez para criar rotas.
Comparando Flask com Django em um Estudo de Caso
Suponha que uma empresa de logística deseje rastrear entregas e precisa de uma API segura, com regras de autenticação e interface administrativa. Nesse caso, Django brilha por causa do painel admin que permite visualizar e manipular tabelas do banco de dados sem esforço (Holovaty & Kaplan-Moss, 2009). Em Flask, você teria que criar seu próprio painel ou adotar extensões de terceiros, o que demanda esforço adicional. Nesse mesmo cenário, Django oferece migrações automáticas, gerando scripts para criar e alterar estruturas de banco (Django, 2022). Portanto, se a empresa precisa de recursos prontos e robustez corporativa, Django se encaixa bem. Entretanto, se a necessidade gira em torno de microsserviços enxutos, Flask pode ser mais indicado.
Exemplo Básico com Django
Django organiza o projeto de forma opinativa, criando diretórios como urls.py, views.py e models.py para separar responsabilidades. Observe este exemplo simples de view que retorna um JSON:
from django.http import JsonResponse
def hello_django(request):
return JsonResponse({'message': 'Hello Django!'})
Você registra essa função em urls.py e pronto, possui um endpoint funcional (Django, 2022). Logo, quem deseja rapidez em projetos que precisam de funcionalidades administrativas nativas tende a escolher Django. O framework oferece um ORM que facilita a persistência de dados, valida modelos e gera as tabelas automaticamente. Porém, essa estrutura completa também traz peso. Em projetos pequenos, toda a estrutura de diretórios pode parecer exagerada (Nascimento, 2022).
Caso Prático com Django REST Framework
O Django REST Framework (DRF) aparece como extensão capaz de serializar dados e criar endpoints com pouco código (Bartlett, 2018). Considere um ambiente que gerencia usuários e publicações, permitindo criação e consulta de postagens. Veja um trecho de código usando views genéricas e serializers:
from rest_framework import serializers, generics
from .models import Post
class PostSerializer(serializers.ModelSerializer):
class Meta:
model = Post
fields = '__all__'
class PostListCreateView(generics.ListCreateAPIView):
queryset = Post.objects.all()
serializer_class = PostSerializer
Basta mapear essa view em urls.py para obter funcionalidades de listar e criar posts. O DRF cuida dos detalhes de serialização e validação, o que agiliza bastante o desenvolvimento (Greenfeld, 2019). Entretanto, esse ecossistema consome mais memória que um projeto Flask básico (Martins, 2021). Apesar disso, grandes times amam esse padrão, pois padroniza a forma de escrever rotas e serializações.
Introdução ao FastAPI com Exemplo Básico
FastAPI surpreende pela adoção de async/await e pela geração automática de documentação (Medina, 2020). Em um projeto que exige alta performance, você cria rotas assíncronas que não bloqueiam o loop de eventos. Veja o exemplo:
from fastapi import FastAPI
app = FastAPI()
@app.get("/items/{item_id}")
async def read_item(item_id: int):
return {"item_id": item_id, "status": "ok"}
Basta executar o servidor com uvicorn main:app --reload, e você acessa /docs para visualizar a documentação automática (FastAPI, 2022). Esse recurso aumenta a produtividade, pois a equipe de QA ou stakeholders testam os endpoints sem instalar ferramentas extras. Além disso, o framework utiliza o Pydantic para validar tipos de dados de entrada (Fridman, 2021).
Comparando Desempenho entre Flask, Django e FastAPI
Estudos de caso mostram que Flask alcança velocidade aceitável em cenários simples e brilha pela leveza (Torres, 2020). Já Django fica atrás em benchmarks de requisições por segundo, mas entrega robustez e organização nativa (Django, 2022). O FastAPI surge como campeão em muitos testes, pois aproveita a programação assíncrona e processa diversas chamadas simultâneas (Medina, 2020). Entretanto, esse ganho depende de uma correta configuração do servidor e de boas práticas de desenvolvimento. Em aplicações menores, a diferença de performance pode não justificar a migração para um framework assíncrono. Portanto, vale analisar métricas reais antes de decidir.
Caso Prático de Alto Tráfego com FastAPI
Imagine uma startup de análise de dados que recebe milhões de requisições diárias para processar estatísticas de uso. Esse volume de acessos requer um Python API Frameworks que gerencie bem as conexões. O FastAPI se mostra eficiente, pois cada requisição é tratada de forma não bloqueante, permitindo que outras sejam atendidas ao mesmo tempo (Rodrigues, 2023). Você configura bancos de dados distribuídos, como Cassandra ou DynamoDB, e integra tudo via drivers assíncronos para manter a escalabilidade. Em alguns casos, a equipe adota filas de mensagens, como RabbitMQ, para tratar tarefas que demandam processamento extenso.
Estudo de Caso: Microserviços em Flask vs. FastAPI
Equipes que dividem a aplicação em diversos microsserviços podem usar Flask em algumas partes e FastAPI em outras, dependendo da necessidade (Nascimento, 2022). Por exemplo, um microserviço de autenticação escrito em Flask pode ser suficiente, pois não sofre tanta carga. Já um microserviço de estatísticas, que lida com consultas intensas, pode adotar FastAPI para aproveitar a natureza assíncrona (Fridman, 2021). Essa estratégia possibilita a combinação de pontos fortes de cada solução e atende requisitos variados de escalabilidade.
Comparando Estrutura de Pastas e Convenções
Quem adora liberdade total provavelmente prefere Flask, pois ele não impõe estruturas fixas (Grinberg, 2018). Em contrapartida, Django oferece convenções claras e pastas para cada parte do projeto (Holovaty & Kaplan-Moss, 2009). FastAPI fica em um meio-termo, pois incentiva o uso de modelos e rotas assíncronas, mas não define pastas rigidamente (FastAPI, 2022). Assim, você decide se centraliza ou separa módulos. Em projetos grandes, uma convenção padrão ajuda a manter padronização. Em projetos pequenos, a liberdade facilita experimentações.
Exemplos de Estrutura em Flask e Django
Em Flask, você pode criar uma pasta my_project, colocar app.py, models.py, routes.py e extensions.py para organizar o projeto (Martins, 2019). Entretanto, nada impede que você divida ainda mais as funções. Já no Django, o próprio comando django-admin startproject gera subpastas como settings.py, urls.py e wsgi.py. Em seguida, você cria aplicativos separados com startapp, que produzem pastas para models.py, views.py e tests.py (Django, 2022). Esse modelo agrada equipes que desejam coerência e padronização.
Segurança Básica em Flask, Django e FastAPI
Todos os frameworks permitem configurar segurança de diferentes formas. Flask exige extensões como Flask-JWT ou Flask-Login (Flask, 2021). Django já oferece um sistema de autenticação embutido e gerencia permissões em cada rota (Django, 2022). FastAPI conta com recursos que facilitam a adoção de JWT e OAuth2. Você chama classes prontas e define rotas que precisam de autenticação (FastAPI, 2022). Portanto, a escolha depende do nível de integração desejado. Quem precisa de algo rápido tende a achar Django vantajoso. Entretanto, quem busca flexibilidade pode preferir Flask ou FastAPI.
Caso Prático: Protegendo Rotas de Pagamento
Considere um módulo de pagamento que exige autenticação e verificação de permissões antes de processar cobranças. Em Flask, você instala Flask-JWT-Extended e configura um decorator para rotas protegidas (Duarte, 2022). Em Django, você pode usar o sistema de usuários e grupos, restringindo endpoints apenas para membros com permissões específicas. Já no FastAPI, você define dependências de segurança e valida tokens JWT no momento em que o usuário acessa a rota (Medina, 2020). Nesse caso, todos os frameworks atendem à necessidade, mas Django oferece uma solução pronta, enquanto Flask e FastAPI demandam bibliotecas adicionais.
Python API Frameworks e Integrações com Bancos de Dados
O Django apresenta o Django ORM, que traz migrações automáticas e mapeamento intuitivo (Greenfeld, 2019). Flask se integra bem ao SQLAlchemy, porém você precisa adicionar a extensão Flask-SQLAlchemy (Flask, 2021). Já o FastAPI também permite usar SQLAlchemy, mas inclui abordagens assíncronas para quem deseja o Gino ou o Tortoise ORM (Medina, 2020). Assim, você escolhe se quer algo síncrono ou assíncrono. Em termos de praticidade, Django ganha pontos por ter tudo pronto. Mesmo assim, algumas equipes gostam da independência de Flask e FastAPI, pois elas trocam o ORM se quiserem.
Caso Prático: Migração de PostgreSQL para MongoDB
Um projeto que começa em Django com PostgreSQL pode, no futuro, migrar para MongoDB. Essa mudança exige adaptações, pois o Django ORM não suporta esse banco nativamente (Django, 2022). Em Flask, você já usaria algo como o PyMongo, sem depender de um ORM específico (Grinberg, 2018). O FastAPI também se encaixa bem nesse cenário, pois você adiciona pacotes assíncronos, como motor ou motorasyncio, e faz as consultas diretamente. Dessa forma, frameworks menos opinativos se mostram mais fáceis de adaptar em casos de migrações de banco.
Python API Frameworks: Comparando Documentação e Comunidade
Django conta com documentação oficial extensa e uma comunidade ativa desde 2005 (Holovaty & Kaplan-Moss, 2009). Flask possui muitos tutoriais e extensões, pois é minimalista e popular (Grinberg, 2018). FastAPI tem crescido rapidamente e recebe contribuições frequentes (Fridman, 2021). Em termos de suporte, Django e Flask têm mais fóruns e pacotes prontos. Entretanto, o FastAPI atrai muitos profissionais interessados em performance e programação assíncrona. Quem busca estabilidade e suporte consolidados tende a olhar para Django ou Flask. Quem deseja algo de ponta e veloz, mas ainda em evolução, aposta no FastAPI.
Python API Frameworks: Benchmark Simplificado
Certas equipes fazem testes de performance para embasar decisões. Suponha que você crie um endpoint /ping em Flask, Django e FastAPI. Em seguida, utiliza uma ferramenta como ApacheBench ou Locust para enviar 10.000 requisições (Locust, 2020). Em muitos testes, Flask consegue um bom número de requisições por segundo, Django fica pouco atrás e FastAPI lidera (Medina, 2020). Porém, se a aplicação envolve consultas complexas ao banco, a performance do ORM pode pesar mais do que o framework em si (Nascimento, 2022). Ou seja, cada cenário exige uma análise detalhada.
Aprendendo a Escalar com Docker e Kubernetes
Independente do framework escolhido, você precisa escalar quando a demanda cresce. Ferramentas como Docker e Kubernetes simplificam a implantação de múltiplas instâncias (Kubernetes, 2021). Em Flask, você empacota a aplicação em um container Docker e executa diversos pods no Kubernetes. Em Django, você faz o mesmo, mas prepara configurações para conectar ao banco de dados compartilhado. Em FastAPI, você segue o mesmo padrão e aproveita a execução assíncrona para suportar mais conexões. Portanto, todos funcionam bem em nuvens modernas.
Caso Prático: SaaS de Ensino Online
Pense em um SaaS que oferece cursos online e recebe muitos alunos simultaneamente. Django surge como opção interessante, pois traz um painel admin que ajuda a gerenciar cadastros e conteúdos (Django, 2022). Entretanto, se a plataforma processar streaming de vídeo ou grandes volumes de dados, FastAPI pode gerenciar melhor as requisições simultâneas (Medina, 2020). Em contrapartida, Flask pode servir microserviços que cuidam apenas da renderização das páginas, integrado a um front-end em React. Assim, cada um desses frameworks cumpre um papel, dependendo das áreas da aplicação.
Python API Frameworks e Integrações com APIs Externas
Aplicativos modernos muitas vezes consomem dados de terceiros, como serviços de pagamento ou plataformas de mapas. Em Flask, você adiciona bibliotecas como requests para fazer chamadas externas (Flask, 2021). Em Django, você faz a mesma coisa e usa o shell interativo para testar rapidamente (Django, 2022). FastAPI também permite as requisições, mas se beneficia do async para rodar várias requisições externas em paralelo (Medina, 2020). Em cenários de muitas integrações, a abordagem assíncrona pode encurtar o tempo total de resposta.
Python API Frameworks: Controlando a Segurança, Rate Limiting e Proteções
Qualquer Python API Frameworks precisa de mecanismos de rate limiting e proteções contra abusos (Cloudflare, 2020). Em Flask, você adiciona extensões que verificam o número de requisições por minuto (Flask-Limiter, por exemplo). Em Django, você encontra pacotes que fazem o mesmo, além de proteções integradas contra ataques CSRF (Django, 2022). O FastAPI não possui algo nativo, mas integra facilmente pacotes de terceiros (Fridman, 2021). Equipes que priorizam segurança se beneficiam de um bom sistema de logging e auditoria, independentemente do framework.
Comparando Logging e Observabilidade
Django oferece configurações de logging no arquivo settings.py, permitindo registrar eventos e enviar logs para serviços externos (Holovaty & Kaplan-Moss, 2009). Flask requer que você configure o Python logging manualmente ou use extensões de terceiros (Grinberg, 2018). FastAPI permite hooks assíncronos que interceptam requisições para criar relatórios de erro (FastAPI, 2022). Em aplicações grandes, você adota soluções como ELK Stack ou Grafana para centralizar logs, seja qual for o framework (Beckett, 2019).
Python API Frameworks: Quais Empresas Utilizam cada Framework?
Grandes organizações usam Django para sistemas de gestão interna e sites com alta demanda, pois apreciam a estabilidade do ecossistema (Martins, 2021). Flask aparece em arquiteturas de microsserviços na Netflix e no Airbnb, graças à flexibilidade (Grinberg, 2018). FastAPI ganhou espaço em empresas que priorizam alta performance, como consultorias de dados que processam milhões de requisições diariamente (Rodrigues, 2023). Ou seja, não existe uma opção que domine todas as áreas. Cada escolha depende do perfil do time e das metas do projeto.
Conclusão dos Estudos de Caso
Os estudos de caso mostram que Flask costuma ser a porta de entrada para quem deseja aprender a criar APIs em Python (Nascimento, 2022). Django se destaca em projetos que exigem painel administrativo e organização pronta para uso (Holovaty & Kaplan-Moss, 2009). O FastAPI brilha em ambientes que exigem altíssimo desempenho e uso de async/await (Medina, 2020). No fim das contas, a decisão depende de fatores como complexidade da aplicação, número de desenvolvedores e disponibilidade de recursos de hospedagem. Por isso, analisar exemplos práticos, estudar benchmarks e conversar com a equipe sobre preferências e necessidades técnicas torna o processo de escolha mais consciente e efetivo (Gomes, 2021).
Conclusão sobre Python API Frameworks
Você observou como cada Python API Frameworks se comporta em diferentes cenários, desde aplicações simples até plataformas de alto desempenho. Entendeu que Flask oferece liberdade e requer menos configurações, mas exige extensões adicionais para segurança e banco de dados (Grinberg, 2018). Percebeu que Django disponibiliza uma estrutura de pastas completa e um ecossistema forte, embora seja mais pesado e opinativo (Django, 2022). Viu que FastAPI aposta em programação assíncrona e documentação automática, ganhando terreno em projetos que lidam com grandes volumes de requisições ao mesmo tempo (Medina, 2020).
Essas análises deixam claro que você não deve escolher apenas com base em popularidade. É necessário observar requisitos de escalabilidade, segurança e agilidade. Por isso, empresas combinam diferentes frameworks em arquiteturas de microsserviços, unindo pontos fortes de cada opção (Nascimento, 2022). Além disso, estudos de caso mostram que aplicações de grande porte, como e-commerces e plataformas de streaming, podem começar simples em Flask e migrar para Django ou FastAPI conforme as necessidades mudam. Esse dinamismo ilustra como a tecnologia evolui junto com o projeto.
Agora, você tem conhecimento para testar cada solução e decidir qual Python API Frameworks se encaixa na sua realidade. Lembre-se de praticar bastante, ler a documentação oficial e acompanhar as comunidades. Essa bagagem faz diferença na hora de resolver problemas complexos e entregar resultados de forma eficiente (Smith, 2022). Ao criar APIs, você precisa equilibrar facilidade de uso, segurança e performance, sabendo que cada framework atende um perfil distinto. Com base nesses exemplos, estudos de caso e comparações, você encontra o caminho ideal para desenvolver projetos sólidos, escaláveis e seguros em Python.
Referências
- Bartlett, T. (2018). Building RESTful Python web services. Packt Publishing.
- Cloudflare. (2020). Rate limiting best practices. Recuperado de https://www.cloudflare.com
- Django. (2022). Django documentation. Recuperado de https://docs.djangoproject.com
- Django REST Framework. (2021). Django REST framework: API guide. Recuperado de https://www.django-rest-framework.org
- Flask. (2021). Flask documentation. Recuperado de https://flask.palletsprojects.com
- Fridman, A. (2021). Modern Python frameworks and their impact on API documentation. International Journal of Software Engineering, 37(3), 55–66.
- Grinberg, M. (2018). Flask Web Development: Developing Web Applications with Python. O’Reilly Media.
- Holovaty, A., & Kaplan-Moss, J. (2009). The definitive guide to Django: Web development done right (2nd ed.). Apress.
- Medina, J. (2020). FastAPI for high-performance Python applications. International Journal of Computer Science, 28(3), 89–98.
- Rodrigues, A. (2022). Uso de APIs e escalabilidade em aplicações modernas. Journal of Technology, 15(2), 35–47.
