O que o cursor é executado em python?
Podemos criar o objeto Cursor através do MySQL.
Crie um objeto de cursor:
#python cursor_object.py#import a biblioteca
importar mysql.conector
# criando conexão
Conn = mysql.conector.conectar(
host = "localhost",
usuário = "Sammy",
senha = "Senha"
)
#print a conexão
Imprimir (Conn)
# Importe o cursor da conexão (Conn)
mycursor = Conn.cursor()
#Print The Mycursor
Imprimir (MyCursor)
Saída: python cursor_object.py
Cmysqlcursor: (nada executado ainda)
Linha 4: Nós importamos a classe do conector do mysql.
Linha 7 a 11: Acessamos o método de conexão através da classe do conector, que já importamos para o nosso programa. Agora, estamos passando nossos parâmetros de conexão para o método de conexão. O nome de usuário e a senha serão diferentes de acordo com o seu processo de instalação.
Linha 16: Importamos o método cursor do objeto de conexão estabelecida (Conn) e criamos o objeto Cursor (MyCursor).
Linha 18: Agora, apenas imprimimos esse mycursor que criamos na linha 16, e a saída mostra que o CMYSQLCursor: (nada executado ainda).
Cursor do método.execute ():
O método Execute () nos ajuda a executar a consulta e retornar registros de acordo com a consulta. A sintaxe da função Execute () é:
execute (consulta, args = nenhum)Parâmetros:
- consulta: Este deve ser um tipo de string.
- Argumentos: Por padrão, os argumentos são Nenhum Porque às vezes podemos passar apenas uma consulta como um Selecione Consulta que busca os registros e não requer valores. Então essa é a razão do args = nenhum por padrão. Mas se queremos passar os valores no caso do INSERIR Consulta, então o tipo de argumento deve ser uma tupla, lista ou dicto apenas.
Retornos:
- Ele retornará a contagem do número de linhas afetadas durante a consulta.
Tipo de retorno:
- O tipo de retorno será um número inteiro (int).
Agora, vamos mostrar alguns exemplos.
Exemplo 1: Use o método Execute () apenas para consulta
#python simples_execute_function.py#import a biblioteca
importar mysql.conector
# criando conexão
Conn = mysql.conector.conectar(
host = "localhost",
usuário = "Sammy",
senha = "Senha",
Database = "DBTest"
)
# Importe o cursor da conexão (Conn)
mycursor = Conn.cursor()
mycursor.execute ("selecione * do filme")
# itera sobre o resultado
Para fila em Mycursor:
Imprimir (linha)
# nós fechamos o cursor e conn os dois
mycursor.fechar()
Conn.fechar()
Saída: python simples_execute_function.py
(1, 'Bruce Almighty', 2003)(2, 'Kung Fu Panda', 2014)
(3, 'kung fu panda', 2014)
(4, 'Frozen', 2014)
(5, 'Frozen2', 2020)
(6, 'Homem de Ferro', 2013)
Linha 11: Adicionamos mais um nome de parâmetro ao banco de dados. Agora, nosso código Python tentará se conectar apenas com este banco de dados MySQL (DBTest).
Linha 15: Criamos um objeto cursor (mycursor).
Linha 17: Executamos uma consulta simples selecionada através da função de execução.
Linha 20 a 21: Iteramos sobre os resultados obtidos pelo objeto Cursor e notamos que todos os registros são devolvidos em tuplas.
Exemplo_2: Use o método Execute () para inserção
#python insert_record_execute.py#import a biblioteca
importar mysql.conector
# Criando conexão com o banco de dados
Conn = mysql.conector.conectar(
host = "localhost",
usuário = "Sammy",
senha = "Senha",
Database = "DBTest"
)
mycursor = Conn.cursor()
# Execute a consulta com seu valor recorde
Query = 'inserir no filme (id, nome, ano) valores ( %s, %s, %s)'
Val = (7, "Merlin", 2001)
mycursor.executar (consulta, Val)
# Nós comprometemos (salve) os registros na tabela
Conn.comprometer-se()
Imprimir (MyCursor.Rowcount, "Record (s) inserido.")
Saída: python insert_record_execute.py
mysql> use dbtest;Leitura Informações da tabela para conclusão de nomes de tabela e colunas
Você pode desativar esse recurso para obter uma inicialização mais rápida com -a
Banco de dados alterado
mysql> selecione * do filme;
+----+----------------+------+
| id | nome | Ano |
+----+----------------+------+
| 1 | Bruce Todo -Poderoso | 2003 |
| 2 | Kung fu panda | 2014 |
| 3 | Kung fu panda | 2014 |
| 4 | Congelado | 2014 |
| 5 | Frozen2 | 2020 |
| 6 | Homem de Ferro | 2013 |
| 7 | Merlin | 2001 |
+----+----------------+------+
7 linhas no set (0.00 seg)
mysql>
Linha 11: Adicionamos mais um nome de parâmetro ao banco de dados. Agora, nosso código Python tentará se conectar apenas com este banco de dados MySQL (DBTest).
Linha 17: Criamos nossa consulta para os dados de inserção.
Linha 18: Criamos o valor para essa consulta inserir na tabela.
Linha 21: Usamos a função Execute () e passamos a consulta e Val como um parâmetro.
E a saída acima mostra que o registro foi inserido com sucesso na tabela.
| Método | Detalhes do método |
|---|---|
| FetchOne () | Isso retornará a linha única do resultado e, se não houver registro para retornar, ele retornará como nenhum. |
| FetchMany ([tamanho]) | Isso retornará o número de linhas conforme o tamanho especificado nos conjuntos de resultados e, se não houver registro para retornar, ele retornará []. O tamanho padrão é 1. |
| Fetchall () | Retorna as linhas todas ou restantes do conjunto de resultados. |
Vamos explicar os métodos acima usando um exemplo.
#python cursor_method.py#import a biblioteca
importar mysql.conector
# criando conexão
Conn = mysql.conector.conectar(
host = "localhost",
usuário = "Sammy",
senha = "Senha",
Database = "DBTest"
)
# Importe o cursor da conexão (Conn)
mycursor = Conn.cursor()
mycursor.execute ("selecione * do filme")
Imprimir (MyCursor.fetchOne ()) # busque a primeira linha
Imprimir (MyCursor.FetchMany (4)) # busca as próximas 2 linhas
Imprimir (MyCursor.fetchall ()) # busque todas as linhas restantes
Imprimir (MyCursor.FetchMany ()) # O conjunto de resultados agora está vazio
# nós fechamos o cursor e conn os dois
mycursor.fechar()
Conn.fechar()
Saída: python cursor_method.py
(1, 'Bruce Almighty', 2003)[(2, 'Kung Fu Panda', 2014), (3, 'Kung Fu Panda', 2014), (4, 'Frozen', 2014), (5, 'Frozen2', 2020)]
[(6, 'Iron Man', 2013), (7, 'Merlin', 2001)]
[(6, 'Iron Man', 2013)]
Linha 19: O método FetchOne () busca o primeiro registro dos conjuntos de resultados.
Linha 20: O método FetchMany (4) busca os quatro registros dos conjuntos de resultados.
Linha 21: O método fetchall () busca todos os registros restantes dos conjuntos de resultados.
Linha 22: O FetchMany () tem tamanho 1 padrão, então ele tenta novamente buscar um registro dos conjuntos de resultados. Mas como o método FetchMany (4) já acessa o método 4 registros e o método FetchOne () acesse o 1º registro, por isso tenta buscar a 6ª tupla dos conjuntos de registros.
Cursor do método.executemany ():
O método executemany () nos ajuda a inserir ou substituir vários registros de uma só vez. A sintaxe da função executemany () é:
Executemany (consulta, args)Parâmetros:
- consulta: Este deve ser um tipo de string.
- Argumentos: Por padrão, os argumentos são não nenhum, É por isso que não somos capazes de executar o Selecione Consulta nisso. Podemos passar os valores de tipos de tupla ou lista apenas.
Retornos:
- Ele retornará a contagem do número de linhas afetadas durante a consulta, se houver.
Tipo de retorno:
- O tipo de retorno será um número inteiro (int ou nenhum).
Agora, vamos mostrar um exemplo do método acima.
#python executemany.py#import a biblioteca
importar mysql.conector
# Criando conexão com o banco de dados
Conn = mysql.conector.conectar(
host = "localhost",
usuário = "Sammy",
senha = "Senha",
Database = "DBTest"
)
mycursor = Conn.cursor()
# Execute a consulta com seu valor recorde
Query = 'inserir no filme (id, nome, ano) valores ( %s, %s, %s)'
Val = [(2, "Kung Fu Panda", 2014),
(4, "Frozen", 2014),
(5, "Frozen2", 2020),
(6, "Homem de Ferro", 2013)
]
mycursor.Executemany (Query, Val)
# Nós comprometemos (salve) os registros na tabela
Conn.comprometer-se()
Imprimir (MyCursor.Rowcount, "Record (s) inserido.")
Linha 17: Criamos nossa consulta para os dados de inserção.
Linha 18: Criamos uma lista de valores que queremos inserir na tabela.
Linha 25: Usamos o método executemany () para inserir os vários registros.
Saída: Python Execememany.py
mysql> selecione * do filme;+----+----------------+------+
| id | nome | Ano |
+----+----------------+------+
| 1 | Bruce Todo -Poderoso | 2003 |
| 2 | Kung fu panda | 2014 |
| 3 | Kung fu panda | 2014 |
| 4 | Congelado | 2014 |
| 5 | Frozen2 | 2020 |
| 6 | Homem de Ferro | 2013 |
+----+----------------+------+
6 linhas no set (0.00 seg)
Execute muitas consultas usando uma única função execute ():
Também podemos executar várias consultas usando a função única execute (). A função Execute () aceita um parâmetro extra, Multi. O Multi = false por padrão. Se mantivermos multi = true, Em seguida, podemos executar uma consulta multi-sql usando o separador de semicolon (;).
# python execute_multi.py#import a biblioteca
importar mysql.conector
# criando conexão
Conn = mysql.conector.conectar(
host = "localhost",
usuário = "Sammy",
senha = "Senha",
Database = "DBTest"
)
# Importe o cursor da conexão (Conn)
mycursor = Conn.cursor()
# consulta com estilo de parâmetro de formato
Query_1 = "Selecione * do filme"
query_2 = 'inserir no filme (id, nome, ano) valores ( %s, %s, %s)'
Queries = [Query_1, Query_2]
val = (8, "série", 2001)
Multiresults = MyCursor.executar(";".junte -se (consultas), val, multi = true)
contagem = 1
Para resultar em multiresultos:
# O resultado é como um cursor, para que possamos acessar todos
# atributos do cursor
print ("Query_ 0 - 1:".formato (contagem, resultado.declaração))
se resultado.with_rows:
para linha em resultado:
Imprimir (linha)
contagem = contagem + 1
outro:
print ("sem resultado")
imprimir()
mycursor.fechar()
Conn.fechar()
Saída: python execute_multi.py
Query_1 - Selecione * do filme:(1, 'Bruce Almighty', 2003)
(2, 'Kung Fu Panda', 2014)
(3, 'kung fu panda', 2014)
(4, 'Frozen', 2014)
(5, 'Frozen2', 2020)
(6, 'Homem de Ferro', 2013)
(7, 'Merlin', 2001)
Query_2 - Inserir no filme (id, nome, ano) valores (8, 'série', 2001):
Nenhum resultado
Linha 23: Criamos uma lista de duas consultas.
Linha 28: Passamos a lista de consultas, Val e separador (;) para o método execute (). Nós também mudamos o valor de Multi de falso para verdadeiro.
Na saída acima, podemos ver nossos resultados do multi-médio.
Conclusão:
Neste artigo, estudamos o método Execute (). Também vimos diferentes tipos de métodos execute () como o método executemany (). Também estudamos como consultar o cursor. Método Execute () e diferentes parâmetros desse método. Por fim, também vimos como podemos fazer várias questões usando o método execute ().
O código deste artigo está disponível no link do GitHub:
https: // github.com/shekharpandey89/cursor-executo-python
- « Que hardware devo atualizar primeiro no meu computador para fazê -lo correr mais rápido?
- Função strstr em c »