Nesta aula veremos um exemplo prático de como fazer um sistema simples de dia e noite.
O sistema basicamente consiste em um ciclo de horas de 0 a 24 onde o tom da tela é alterado em função das horas.
- Introdução
Primeiro temos que saber onde fazer esta modificação, o script é a class Scene_Map, é lá onde é atualizado todo o mapa. Quando falo em atualizar, lembre-se do método update, e é ele que iremos modificar.
Como há momentos em que não desejamos ligar o sistema, temos que fazer uma condição para que ele só funcione se a switch estiver ligada.
Então vamos criar as variáveis globais:
$secs = 0
$mins = 0
$hours = 0
$hours_var = 1
$dn_on = 1
As três primeiras são as variáveis do tempo. A penúltima é a variável que armazena a hora, é a mesma que $hours, porém para que fique melhor utilizar em eventos, por condições fica melhor associá-la a uma variável do jogo. E a última é a switch que liga e desliga o sistema.
- Modificando o método update
Antes de modificar o método precisamos criar uma variável de velocidade do tempo, poderíamos deixar o valor 1 como velocidade assim os segundos passariam normalmente, porém como é apenas um exemplo vamos colocar um valor alto para vermos o tempo passar mais rápido.
$time_speed = 35
Crie um novo script e escreva a classe Scene_Map, não se esqueça de por a classe mãe Scene_Base por meio de herança e
copie o método update.
Agora antes do end cole o código:
if $game_switches[$dn_on]
$secs += $time_speed
if $secs >= 60
$secs = 0
$mins += 1
end
if $mins >= 60
$mins = 0
$hours += 1
end
if $hours >= 24
$hours = 0
$game_variables[$hours_var] = $hours
end
update_screen
end
Aqui são feitas as três condições do tempo, os segundos serão incrementados pela velocidade e ao atingirem 60 ou mais serão
zerados e os minutos serão incrementados em 1, repetindo o ciclo até que os minutos sejam igual a 60, zerando-os e incrementando as horas, que por sua vez será incrementada até chegar a 24, onde voltará a ser 0.
Chamamos o método update_screen então que é o que irá fazer a tela mudar de tonalidade.
- O método da tonalidade
Crie o método:
def update_screen
case $hours
when 0,1,2,3,4
$game_map.screen.start_tone_change(Tone.new(-102,-102,-102),140)
when 5,6,7
$game_map.screen.start_tone_change(Tone.new(-34,-34,-34),140)
when 8,9,10,11,12,13,14,15,16,17
$game_map.screen.start_tone_change(Tone.new(20,10,10),140)
when 18,19,20,21,22,23
$game_map.screen.start_tone_change(Tone.new(-68,-68,-68),140)
end
end
Aqui são feitas condições também para verificar qual é a hora e em sua função mudar a tonalidade. Usamos a classe Game_Map que tem uma instância da Game_Screen ($game_map.screen) a qual é a responsável pela tela do jogo, e nela há o método start_tone_change que muda a tonalidade da tela. Os argumentos são o tom e a velocidade. O tom é uma classe também, portanto temos que iniciá-la com o new e os argumentos são as cores RGB (vermelho, verde, azul) que vão de 0 a 255.
Para fazermos a condição, eu utilizei o comando case, poderíamos escrever 24 if + eslsif porém esta maneira é muito mais eficiente.
Aqui está o script completo. Para testá-lo, lembre-se de ativar a switch 1.
$secs = $mins = $hours = 0
$time_speed = 35
$hours_var = 1
$dn_on = 1
class Scene_Map < Scene_Base
def update
super
$game_map.update(true)
$game_player.update
$game_timer.update
@spriteset.update
update_scene if scene_change_ok?
if $game_switches[$dn_on]
$secs += $time_speed
if $secs >= 60
$secs = 0
$mins += 1
end
if $mins >= 60
$mins = 0
$hours += 1
end
if $hours >= 24
$hours = 0
$game_variables[$hours_var] = $hours
end
update_screen
end
end
def update_screen
case $hours
when 0,1,2,3,4
$game_map.screen.start_tone_change(Tone.new(-102,-102,-102),140)
when 5,6,7
$game_map.screen.start_tone_change(Tone.new(-34,-34,-34),140)
when 8,9,10,11,12,13,14,15,16,17
$game_map.screen.start_tone_change(Tone.new(20,10,10),140)
when 18,19,20,21,22,23
$game_map.screen.start_tone_change(Tone.new(-68,-68,-68),140)
end
end
end
sexta-feira, 19 de abril de 2013
segunda-feira, 15 de abril de 2013
Aprendendo RGSS do zero - Aula 09
Nesta aula finalmente aprenderemos algo prático, na verdade será um pouco de tudo
que vimos em todas as aulas, apesar de não ter uma utilidade em si, mas é um ótimo
exemplo de como funcionam as coisas na prática.
- Introdução
A Scene que criaremos consiste em uma janela com entrada para comandos, são as setas direcionais.
Primeiro criamos um módulo com os caracteres desejados.
module Commands
Commands = {'u' => '↑', 'd' => '↓', 'l' => '←', 'r' => '→'}
end
Utilizamos uma hash para associar cada comando a um caractere.
Os comandos ou chaves são u,d,l,r respectivamente up, down, left e right.
- Criando a janela
class Window_Commands < Window_Selectable
def initialize(x,y,w,h)
super(x,y,w,h)
@commands = []
refresh
end
def refresh
contents.clear
draw_commands
end
def commands
return @commands
end
def draw_commands
x = 0
for c in @commands
draw_text(x, 0, contents.width, 30, Commands::Commands[c])
x += 20
end
end
def pop
return if @commands.size == 0
@commands.pop
refresh
end
def push(c)
return if @commands.size == 14
@commands << c
refresh
end
end
Vamos dividir a explicação em cada método.
No primeiro método criamos uma variável lista que armazenará os comandos u,d,l,r e chamamos o método
que escreverá eles.
No segundo, apagaremos todo o conteúdo e em seguida escreveremos novamente.
No terceiro, criamos um método que retorna a própria lista dos comandos.
No quarto, escrevemos os caracteres um a um utilizando o for, perceba que para não sobrepor cada seta,
cria-se uma variável x que será incrementada a cada repetição, assim cada vez que tiver uma seta, terá um espaço de 20 pixels.
Usamos a hash para dizer qual caractere será impresso, por exemplo se for o u, ficaria assim:
Commands::Commands['u'] # => ↑
No quinto e sexto os métodos são respectivamente de remoção e adição de comandos, como visto na aula 6.
Veja a condição em cada método, o comando só será executado caso a condição seja realizada. Não será possível remover
um comando se a lista estiver vazia e não será possível adicionar se a lista tiver 14 elementos.
- Criando a scene
class Scene_Commands < Scene_Base
def start
super
draw_windows
end
def draw_windows
@command_window = Window_Commands.new(10,10,310,50)
end
def update
super
return_scene if Input.trigger?(:B) and @command_window.commands.size == 0
@command_window.pop if Input.repeat?(:B)
@command_window.push('u') if Input.repeat?(:UP)
@command_window.push('d') if Input.repeat?(:DOWN)
@command_window.push('l') if Input.repeat?(:LEFT)
@command_window.push('r') if Input.repeat?(:RIGHT)
end
def terminate
super
@command_window.dispose
end
end
Novamente a explicação por métodos.
No primeiro, criamos o método principal e chamamos o método de criação da janela.
No segundo, criamos a janela. Perceba que o método start só é chamado uma vez, que é quando chamamos a scene, bem como este
método, pois só é preciso criar a janela uma vez!
No terceiro, fazemos várias condições de checagem de teclas. Perceba na primeira linha que retornamos a scene anterior somente se
a lista estiver vazia, isso serve para não voltar a scene simplesmente ao pressionar ESC, pois pode conter comandos ainda na
lista. Caso tenha, usamos o método pop para remover o último elemento. Em seguida criamos as quatro condições para cada tecla e
adicionamos a lista o comando respectivo.
No quarto simplesmente destruimos a janela ao sair.
- Finalizando
Copie todos os códigos e cole num script novo e teste o jogo chamando o código:
SceneManager.call(Scene_Commands)
Pronto, agora é só teclar as setas direcionais e pressionar ESC para remover o último comando ou sair.
que vimos em todas as aulas, apesar de não ter uma utilidade em si, mas é um ótimo
exemplo de como funcionam as coisas na prática.
- Introdução
A Scene que criaremos consiste em uma janela com entrada para comandos, são as setas direcionais.
Primeiro criamos um módulo com os caracteres desejados.
module Commands
Commands = {'u' => '↑', 'd' => '↓', 'l' => '←', 'r' => '→'}
end
Utilizamos uma hash para associar cada comando a um caractere.
Os comandos ou chaves são u,d,l,r respectivamente up, down, left e right.
- Criando a janela
class Window_Commands < Window_Selectable
def initialize(x,y,w,h)
super(x,y,w,h)
@commands = []
refresh
end
def refresh
contents.clear
draw_commands
end
def commands
return @commands
end
def draw_commands
x = 0
for c in @commands
draw_text(x, 0, contents.width, 30, Commands::Commands[c])
x += 20
end
end
def pop
return if @commands.size == 0
@commands.pop
refresh
end
def push(c)
return if @commands.size == 14
@commands << c
refresh
end
end
Vamos dividir a explicação em cada método.
No primeiro método criamos uma variável lista que armazenará os comandos u,d,l,r e chamamos o método
que escreverá eles.
No segundo, apagaremos todo o conteúdo e em seguida escreveremos novamente.
No terceiro, criamos um método que retorna a própria lista dos comandos.
No quarto, escrevemos os caracteres um a um utilizando o for, perceba que para não sobrepor cada seta,
cria-se uma variável x que será incrementada a cada repetição, assim cada vez que tiver uma seta, terá um espaço de 20 pixels.
Usamos a hash para dizer qual caractere será impresso, por exemplo se for o u, ficaria assim:
Commands::Commands['u'] # => ↑
No quinto e sexto os métodos são respectivamente de remoção e adição de comandos, como visto na aula 6.
Veja a condição em cada método, o comando só será executado caso a condição seja realizada. Não será possível remover
um comando se a lista estiver vazia e não será possível adicionar se a lista tiver 14 elementos.
- Criando a scene
class Scene_Commands < Scene_Base
def start
super
draw_windows
end
def draw_windows
@command_window = Window_Commands.new(10,10,310,50)
end
def update
super
return_scene if Input.trigger?(:B) and @command_window.commands.size == 0
@command_window.pop if Input.repeat?(:B)
@command_window.push('u') if Input.repeat?(:UP)
@command_window.push('d') if Input.repeat?(:DOWN)
@command_window.push('l') if Input.repeat?(:LEFT)
@command_window.push('r') if Input.repeat?(:RIGHT)
end
def terminate
super
@command_window.dispose
end
end
Novamente a explicação por métodos.
No primeiro, criamos o método principal e chamamos o método de criação da janela.
No segundo, criamos a janela. Perceba que o método start só é chamado uma vez, que é quando chamamos a scene, bem como este
método, pois só é preciso criar a janela uma vez!
No terceiro, fazemos várias condições de checagem de teclas. Perceba na primeira linha que retornamos a scene anterior somente se
a lista estiver vazia, isso serve para não voltar a scene simplesmente ao pressionar ESC, pois pode conter comandos ainda na
lista. Caso tenha, usamos o método pop para remover o último elemento. Em seguida criamos as quatro condições para cada tecla e
adicionamos a lista o comando respectivo.
No quarto simplesmente destruimos a janela ao sair.
- Finalizando
Copie todos os códigos e cole num script novo e teste o jogo chamando o código:
SceneManager.call(Scene_Commands)
Pronto, agora é só teclar as setas direcionais e pressionar ESC para remover o último comando ou sair.
domingo, 14 de abril de 2013
Aprendendo RGSS do zero - Aula 08
Nesta aula iremos aprender a criar Scenes. Scenes são classes que possuem uma interação com o jogador, eu costumo dizer que são a alma dos jogos, a ideia delas está amplamente ligada à janelas, pois somente as janelas não fazem a interação.
- Introdução
Antes de mais nada saiba que o nome Scene é uma convenção, você pode por qualquer nome que quiser na sua classe, porém quando se põe Scene fica mais claro o que ela é.
No RGSS3 há a classe mãe Scene_Base, que facilita muito a nossa vida, pois precisamos apenas chamar os métodos básicos e não criá-los do zero.
class Scene_Teste < Scene_Base
def start
super
end
end
O método obrigatório é o start, ele faz rodar toda a janela.
Chama-se uma Scene da seguinte forma:
SceneManager.call(Nome_Da_Scene)
Note que não há necessidade de por .new pois o programa se encarrega disso.
Obviamente se você chamar o script acima verá apenas uma tela preta permanente.
Vamos adicionar um comando de voltar ao pressionar ESC:
class Scene_Teste < Scene_Base
def start
super
end
def update
super
return_scene if Input.trigger?(:B)
end
end
Sempre que precisar checar se algo é cumprido ou algo do tipo, que será necessário repetir várias vezes, ou um valor atingir certo número, usa-se o método update.
Neste, tudo será repetido em um determinado tempo, no caso será sempre checada a condição de pressionada a tecla ESC (usa-se o símbolo :B) e chamamos e método return_scene que retorna a scene anterior.
- Adicionando uma janela
Para adicionarmos uma janela usamos o método start, pois será criada apenas uma vez e não várias!
class Scene_Teste < Scene_Base
def start
super
@window = Window_Teste.new(0,0,200,200)
end
def update
super
return_scene if Input.trigger?(:B)
end
end
Agora vamos adicionar um método para apagar a janela quando sairmos da Scene.
class Scene_Teste < Scene_Base
def start
super
@window = Window_Teste.new(0,0,200,200)
end
def update
super
return_scene if Input.trigger?(:B)
end
def terminate
super
@window.dispose
end
end
Este método é chamado terminate. O comando dispose é o que apaga a janela.
Por enquanto é isso, na próxima aula vamos usar um exemplo envolvendo tudo que aprendemos nas últimas aulas!
- Introdução
Antes de mais nada saiba que o nome Scene é uma convenção, você pode por qualquer nome que quiser na sua classe, porém quando se põe Scene fica mais claro o que ela é.
No RGSS3 há a classe mãe Scene_Base, que facilita muito a nossa vida, pois precisamos apenas chamar os métodos básicos e não criá-los do zero.
class Scene_Teste < Scene_Base
def start
super
end
end
O método obrigatório é o start, ele faz rodar toda a janela.
Chama-se uma Scene da seguinte forma:
SceneManager.call(Nome_Da_Scene)
Note que não há necessidade de por .new pois o programa se encarrega disso.
Obviamente se você chamar o script acima verá apenas uma tela preta permanente.
Vamos adicionar um comando de voltar ao pressionar ESC:
class Scene_Teste < Scene_Base
def start
super
end
def update
super
return_scene if Input.trigger?(:B)
end
end
Sempre que precisar checar se algo é cumprido ou algo do tipo, que será necessário repetir várias vezes, ou um valor atingir certo número, usa-se o método update.
Neste, tudo será repetido em um determinado tempo, no caso será sempre checada a condição de pressionada a tecla ESC (usa-se o símbolo :B) e chamamos e método return_scene que retorna a scene anterior.
- Adicionando uma janela
Para adicionarmos uma janela usamos o método start, pois será criada apenas uma vez e não várias!
class Scene_Teste < Scene_Base
def start
super
@window = Window_Teste.new(0,0,200,200)
end
def update
super
return_scene if Input.trigger?(:B)
end
end
Agora vamos adicionar um método para apagar a janela quando sairmos da Scene.
class Scene_Teste < Scene_Base
def start
super
@window = Window_Teste.new(0,0,200,200)
end
def update
super
return_scene if Input.trigger?(:B)
end
def terminate
super
@window.dispose
end
end
Este método é chamado terminate. O comando dispose é o que apaga a janela.
Por enquanto é isso, na próxima aula vamos usar um exemplo envolvendo tudo que aprendemos nas últimas aulas!
sábado, 13 de abril de 2013
Aprendendo RGSS do zero - Aula 07
Nesta aula vamos aprender um pouco sobre Windows, que são as janelas do jogo.
Uma Window é uma classe, logo toda janela é um objeto, elas são um ótimo exemplo de porque utilizar classes, visto que há dezenas de janelas, e como elas têm muito em comum, é viável usar o conceito de orientação a objeto.
- Introdução
Definimos uma janela assim:
class Window_Teste < Window_Base
end
A classe mãe é a Window_Base, herdamos todos os métodos dela.
Agora vamos utilizar o método de início.
class Window_Teste < Window_Base
def initialize(x,y,w,h)
super(x,y,w,h)
end
end
O método initialize requer quatro argumentos, que são respectivamente posição x, posição y, largura e altura.
A palavra reservada super chama o método da classe mãe, nesse caso chamará o método initialize da classe Window_Base com os argumentos dados.
Crie um evento e chame o script
Window_Teste.new(10,10,200,200)
- Escrevendo textos
Agora vamos escrever um texto na nossa janela.
class Window_Teste < Window_Base
def initialize(x,y,w,h)
super(x,y,w,h)
draw_text(0,0,140,30,"Hello World")
end
end
Usa-se o método draw_text para escrever um texto. Os argumentos são os seguintes: posição x, posição y, largura do retângulo, altura do retângulo, texto
O retângulo é a área do texto.
Para fazer a janela ficar permanente e também ter interações utiliza-se as Scenes, conteúdo que veremos adiante.
- Mudando a cor
Para mudarmos a cor do texto, usa-se o método change_color
change_color(text_color(2))
change_color(Color.new(200,0,0))
O método text_color(n) retorna uma cor pré definida de acordo com a Windowskin, caso queira uma cor que não esteja disponível, use a classe Color e coloque os três argumentos RGB, de 0 a 255.
- Exemplo
Vamos colocar uma imagem na nossa janela.
class Window_Teste < Window_Base
def initialize(x,y,w,h)
super(x,y,w,h)
bitmap = Cache.battler("Assassin",0)
rect = Rect.new(0,0,bitmap.width,bitmap.height)
contents.blt(0,0,bitmap,rect)
end
end
Na quarta linha criamos uma Bitmap (classe das imagens e textos em geral) com o método battler do módulo Cache. O primeiro argumento é o nome do arquivo e o segundo a tonalidade.
Na quinta linha criamos um retângulo, que será a delimitação da imagem, a imagem fica dentro do retângulo. Os argumentos são os mesmos das janela, a diferença é que quando colocamos bitmap.width, bitmap.height não nos restrigimos a um valor número, o próprio programa se encarrega de pegar os valores.
Na sexta linha pegamos esse retângulo com a imagem e jogamos na janela. Os argumentos são posição x e y, imagem e o retângulo.
Você pode modificar os valores dos argumentos para entender melhor o que cada um faz.
Uma Window é uma classe, logo toda janela é um objeto, elas são um ótimo exemplo de porque utilizar classes, visto que há dezenas de janelas, e como elas têm muito em comum, é viável usar o conceito de orientação a objeto.
- Introdução
Definimos uma janela assim:
class Window_Teste < Window_Base
end
A classe mãe é a Window_Base, herdamos todos os métodos dela.
Agora vamos utilizar o método de início.
class Window_Teste < Window_Base
def initialize(x,y,w,h)
super(x,y,w,h)
end
end
O método initialize requer quatro argumentos, que são respectivamente posição x, posição y, largura e altura.
A palavra reservada super chama o método da classe mãe, nesse caso chamará o método initialize da classe Window_Base com os argumentos dados.
Crie um evento e chame o script
Window_Teste.new(10,10,200,200)
- Escrevendo textos
Agora vamos escrever um texto na nossa janela.
class Window_Teste < Window_Base
def initialize(x,y,w,h)
super(x,y,w,h)
draw_text(0,0,140,30,"Hello World")
end
end
Usa-se o método draw_text para escrever um texto. Os argumentos são os seguintes: posição x, posição y, largura do retângulo, altura do retângulo, texto
O retângulo é a área do texto.
Para fazer a janela ficar permanente e também ter interações utiliza-se as Scenes, conteúdo que veremos adiante.
- Mudando a cor
Para mudarmos a cor do texto, usa-se o método change_color
change_color(text_color(2))
change_color(Color.new(200,0,0))
O método text_color(n) retorna uma cor pré definida de acordo com a Windowskin, caso queira uma cor que não esteja disponível, use a classe Color e coloque os três argumentos RGB, de 0 a 255.
- Exemplo
Vamos colocar uma imagem na nossa janela.
class Window_Teste < Window_Base
def initialize(x,y,w,h)
super(x,y,w,h)
bitmap = Cache.battler("Assassin",0)
rect = Rect.new(0,0,bitmap.width,bitmap.height)
contents.blt(0,0,bitmap,rect)
end
end
Na quarta linha criamos uma Bitmap (classe das imagens e textos em geral) com o método battler do módulo Cache. O primeiro argumento é o nome do arquivo e o segundo a tonalidade.
Na quinta linha criamos um retângulo, que será a delimitação da imagem, a imagem fica dentro do retângulo. Os argumentos são os mesmos das janela, a diferença é que quando colocamos bitmap.width, bitmap.height não nos restrigimos a um valor número, o próprio programa se encarrega de pegar os valores.
Na sexta linha pegamos esse retângulo com a imagem e jogamos na janela. Os argumentos são posição x e y, imagem e o retângulo.
Você pode modificar os valores dos argumentos para entender melhor o que cada um faz.
quinta-feira, 11 de abril de 2013
Aprendendo RGSS do zero - Aula 06
Neste módulo intermediário aprederemos um pouco mais de algumas coisas que não foram vistas. É altamente recomendando que você tenha lido e entendido o módulo básico.
- Hashes
Hashes ou dicionários são váriaveis que armazenam valores, diferente das listas (arrays) hashes não se referem ao valores por índices, e sim por chaves. Declara-se hashes assim:
var = {}
Podemos também já definir os valores na declaração.
var = {1 => "um"}
var2 = {2 => 'dois'}
Para colocar vários conjuntos numa mesma variável, use o operador vírgula:
var = {"au au" => "cachorro", "miau" => "gato"}
O operador => tem a função de associar os valores relacionados, veja como se usa as hashes:
var["au au"] # cachorro
var["miau"] # gato
Os termos do lado esquerdo (antes do =>) são chamados chaves e os do lado direito, valores.
Perceba que se chama as hashes com o operador de array também (colchetes), porém usa-se as chaves para fazer a referência.
Pode-se usar números e símbolos e outros objetos nas chaves.
var = {1=>'um',:s="string"}
- Exemplo
Um exemplo para pegar todos os valores:
hash = {1=>"um",2=>"dois",3=>"três"}
for i in hash.keys # 1,2,3
msgbox hash[i]
end
O método keys retorna um array das chaves [1,2,3], e em seguida são passados ao for, que neste caso não tem o operador de ponto, pois ele já sabe quantos elementos ler.
- Um pouco mais sobre arrays
Vamos aprender mais dois métodos úteis das arrays, o push e pop.
O push serve para adicionar um elemento a fila, colocando-o em último lugar.
a = [1,2,3]
a.push(4) # a = [1,2,3,4]
Podemos também utilizar o operador <<
a = [4,5,6]
a << 7 # a = [4,5,6,7]
O pop serve para remover o último elemento da lista.
a = [1,2,3,5]
a.pop() # a = [1,2,3]
Bom, pessoal por enquanto é isso, gostaria que postassem nos comentários que tipos de aula vocês gostariam. Nas próximas irei falar sobre windows.
- Hashes
Hashes ou dicionários são váriaveis que armazenam valores, diferente das listas (arrays) hashes não se referem ao valores por índices, e sim por chaves. Declara-se hashes assim:
var = {}
Podemos também já definir os valores na declaração.
var = {1 => "um"}
var2 = {2 => 'dois'}
Para colocar vários conjuntos numa mesma variável, use o operador vírgula:
var = {"au au" => "cachorro", "miau" => "gato"}
O operador => tem a função de associar os valores relacionados, veja como se usa as hashes:
var["au au"] # cachorro
var["miau"] # gato
Os termos do lado esquerdo (antes do =>) são chamados chaves e os do lado direito, valores.
Perceba que se chama as hashes com o operador de array também (colchetes), porém usa-se as chaves para fazer a referência.
Pode-se usar números e símbolos e outros objetos nas chaves.
var = {1=>'um',:s="string"}
- Exemplo
Um exemplo para pegar todos os valores:
hash = {1=>"um",2=>"dois",3=>"três"}
for i in hash.keys # 1,2,3
msgbox hash[i]
end
O método keys retorna um array das chaves [1,2,3], e em seguida são passados ao for, que neste caso não tem o operador de ponto, pois ele já sabe quantos elementos ler.
- Um pouco mais sobre arrays
Vamos aprender mais dois métodos úteis das arrays, o push e pop.
O push serve para adicionar um elemento a fila, colocando-o em último lugar.
a = [1,2,3]
a.push(4) # a = [1,2,3,4]
Podemos também utilizar o operador <<
a = [4,5,6]
a << 7 # a = [4,5,6,7]
O pop serve para remover o último elemento da lista.
a = [1,2,3,5]
a.pop() # a = [1,2,3]
Bom, pessoal por enquanto é isso, gostaria que postassem nos comentários que tipos de aula vocês gostariam. Nas próximas irei falar sobre windows.
Assinar:
Postagens (Atom)