当前位置：极客教程 > MySQL > MySQL 教程 > MySQL Ruby 教程

MySQL Ruby 教程

这是针对 MySQL 数据库的 Ruby 编程教程。 它涵盖了使用 Ruby 进行 MySQL 编程的基础。 它使用mysql模块。 这些示例是在 Ubuntu Linux 上创建和测试的。

如果您需要重新了解 Ruby 语言，可以在极客教程上找到完整的Ruby 教程。

MySQL & Ruby

_MySQL是领先的开源数据库管理系统。 它是一个多用户，多线程的数据库管理系统。 MySQL 在网络上特别流行。 它是由 Linux，Apache，MySQL 和 PHP 组成的非常流行的LAMP平台的一部分。 目前，MySQL 由 Oracle 拥有。 MySQL 数据库在最重要的 OS 平台上可用。Ruby_ 是一种动态的，反射性的，通用的面向对象的编程语言。 最近，它在 Web 编程中变得非常流行，这主要归功于 Ruby on Rails 框架的成功。

mysql 模块

mysql模块是 MySQL 服务器的 Ruby 接口。 它为 Ruby 程序提供的功能与 MySQL C API 为 C 程序提供的功能相同。

$ sudo gem1.9 install mysql
Ruby

在这里，我们为 MySQL 数据库安装 Ruby 模块。

开始之前

我们将创建一个新的数据库用户和一个新的数据库。 为此，我们使用mysql客户端程序。

$ mysql -u root -p
Enter password: 
Welcome to the MySQL monitor.  Commands end with ; or \g.
Your MySQL connection id is 30
Server version: 5.0.67-0ubuntu6 (Ubuntu)

Type 'help;' or '\h' for help. Type '\c' to clear the buffer.

mysql> SHOW DATABASES;
+--------------------+
| Database           |
+--------------------+
| information_schema | 
| mysql              | 
+--------------------+
2 rows in set (0.00 sec)
Ruby

我们使用 root 帐户连接到 MySQL 服务器。 我们用SHOW DATABASES语句显示所有可用的数据库。

mysql> CREATE DATABASE mydb;
Query OK, 1 row affected (0.02 sec)
Ruby

我们创建一个新的mydb数据库。 在整个教程中，我们将使用此数据库。

mysql> CREATE USER user12@localhost IDENTIFIED BY '34klq*';
Query OK, 0 rows affected (0.00 sec)

mysql> USE mydb;
Database changed

mysql> GRANT ALL ON mydb.* to user12@localhost;
Query OK, 0 rows affected (0.00 sec)

mysql> quit;
Bye
Ruby

我们创建一个新的数据库用户。 我们授予该用户mydb数据库所有表的所有特权。

MySQL 服务器版本

在第一个示例中，我们将获取 MySQL 数据库的版本。

#!/usr/bin/ruby

require 'mysql'

begin
    con = Mysql.new 'localhost', 'user12', '34klq*'
    puts con.get_server_info
    rs = con.query 'SELECT VERSION()'
    puts rs.fetch_row    

rescue Mysql::Error => e
    puts e.errno
    puts e.error

ensure
    con.close if con
end
Ruby

在此脚本中，我们获取服务器版本。 我们用两种不同的方式来做。

require 'mysql'
Ruby

我们导入mysql模块。 该模块具有用于 MySQL 数据库的类和方法。

con = Mysql.new 'localhost', 'user12', '34klq*'
Ruby

我们创建连接对象。 参数包括主机名，用户名和密码。 在我们的情况下，主机名是 localhost，例如 我们的电脑。

puts con.get_server_info
Ruby

我们创建的 Mysql 对象具有get_server_info方法。 它返回安装的 MySQL 服务器的版本。

rs = con.query 'SELECT VERSION()'
puts rs.fetch_row
Ruby

获取版本的另一种方法是执行SELECT VERSION() SQL 语句。 我们获取数据。 由于只检索一条记录，因此我们称为fetch_row方法。

rescue Mysql::Error => e
    puts e.errno
    puts e.error
Ruby

我们检查错误。 这很重要，因为使用数据库容易出错。

ensure
    con.close if con
end
Ruby

最后，我们释放资源。

$ ./version.rb
5.5.9
5.5.9
Ruby

输出可能类似于上面。

列出数据库

MySQL Ruby 模块具有list_dbs方法，该方法返回可用的数据库。

#!/usr/bin/ruby

require 'mysql'

begin
    con = Mysql.new 'localhost', 'user12', '34klq*'

    con.list_dbs.each do |db|
        puts db
    end

rescue Mysql::Error => e
    puts e.errno
    puts e.error

ensure
    con.close if con
end
Ruby

在此脚本中，我们在 MySQL 服务器上打印所有可用的数据库。

con.list_dbs.each do |db|
    puts db
end
Ruby

list_dbs方法返回可用数据库名称的数组。 使用数组的 each 方法，我们将数组的每个项目打印到控制台。

$ ./listdb.rb
information_schema
mydb
test
world
Ruby

在我的系统上，我创建了上述数据库。

创建并填充表

我们创建一个表，并用一些数据填充它。

#!/usr/bin/ruby

require 'mysql'

begin

    con = Mysql.new 'localhost', 'user12', '34klq*', 'mydb'

    con.query("CREATE TABLE IF NOT EXISTS \
        Writers(Id INT PRIMARY KEY AUTO_INCREMENT, Name VARCHAR(25))")
    con.query("INSERT INTO Writers(Name) VALUES('Jack London')")
    con.query("INSERT INTO Writers(Name) VALUES('Honore de Balzac')")
    con.query("INSERT INTO Writers(Name) VALUES('Lion Feuchtwanger')")
    con.query("INSERT INTO Writers(Name) VALUES('Emile Zola')")
    con.query("INSERT INTO Writers(Name) VALUES('Truman Capote')")   

rescue Mysql::Error => e
    puts e.errno
    puts e.error

ensure
    con.close if con
end
Ruby

我们创建一个 Writers 表，并向其中添加五个作者。

con.query("CREATE TABLE IF NOT EXISTS \
        Writers(Id INT PRIMARY KEY AUTO_INCREMENT, Name VARCHAR(25))")
Ruby

要执行 SQL 语句，我们使用query方法。 该 SQL 语句创建一个称为 Writers 的新数据库表。 它有两列。 ID 和名称。

con.query("INSERT INTO Writers(Name) VALUES('Jack London')")
con.query("INSERT INTO Writers(Name) VALUES('Honore de Balzac')")
...
Ruby

我们使用INSERT语句在表中插入作者。 在这里，我们添加两行。

mysql> SELECT * FROM Writers;
+----+-------------------+
| Id | Name              |
+----+-------------------+
|  1 | Jack London       |
|  2 | Honore de Balzac  |
|  3 | Lion Feuchtwanger |
|  4 | Emile Zola        |
|  5 | Truman Capote     |
+----+-------------------+
5 rows in set (0.00 sec)
Ruby

执行脚本后，我们使用mysql客户端工具从 Writers 表中选择所有数据。

检索数据

现在我们已经将一些数据插入数据库中，我们可以将其取回。

#!/usr/bin/ruby

require "mysql"

begin

    con = Mysql.new 'localhost', 'user12', '34klq*', 'mydb'

    rs = con.query("SELECT * FROM Writers")
    n_rows = rs.num_rows

    puts "There are #{n_rows} rows in the result set"

    n_rows.times do
        puts rs.fetch_row.join("\s")
    end

rescue Mysql::Error => e
    puts e.errno
    puts e.error

ensure
    con.close if con
end
Ruby

在此示例中，我们从 Writers 表中检索所有数据。

con = Mysql.new 'localhost', 'user12', '34klq*', 'mydb'
Ruby

构造函数的最后一个参数是我们要连接的数据库名称。

rs = con.query("SELECT * FROM Writers")
Ruby

该 SQL 语句从Writers表中选择所有数据。

n_rows = rs.num_rows
Ruby

我们使用结果集对象的num_rows方法获得结果集中的行数。

n_rows.times do
    puts rs.fetch_row.join("\s")
end
Ruby

在这里，我们使用fetch_row方法获取每一行。 它返回一行作为字段数组。 默认情况下，打印时这些字段用换行分隔。 使用join方法，我们将每一行打印在一行上。 字段由一个空格分隔。

$ ./retrieve1.rb
There are 5 rows in the result set
1 Jack London
2 Honore de Balzac
3 Lion Feuchtwanger
4 Emile Zola
5 Truman Capote
Ruby

接下来，我们介绍另一种从表中检索数据的方法。

#!/usr/bin/ruby

require "mysql"

begin
    con = Mysql.new 'localhost', 'user12', '34klq*', 'mydb'

    rs = con.query("SELECT * FROM Writers")

    rs.each do |row|
        puts row.join("\s")
    end

rescue Mysql::Error => e
    puts e.errno
    puts e.error

ensure
    con.close if con
end
Ruby

我们从Writers表中打印所有数据。 这次我们使用结果集的每种方法遍历数据。

rs.each do |row|
    puts row.join("\s")
end
Ruby

我们使用每种方法遍历结果集。

$ ./retrieve2.rb
1 Jack London
2 Honore de Balzac
3 Lion Feuchtwanger
4 Emile Zola
5 Truman Capote
Ruby

这是示例的输出。

我们可以以 Ruby 哈希的形式遍历数据。

#!/usr/bin/ruby

require 'mysql'

begin

    con = Mysql.new 'localhost', 'user12', '34klq*', 'mydb'    
    rs = con.query "SELECT * FROM Writers WHERE Id IN (1, 2, 3)"
    puts "We have #{rs.num_rows} row(s)"

    rs.each_hash do |row|
       puts row['Id'] + " " + row['Name']
    end      

rescue Mysql::Error => e
    puts e    
ensure
    con.close if con
end
Ruby

在示例中，我们使用each_hash迭代器。 可以通过列名称检索结果集中的记录。

rs.each_hash do |row|
    puts row['Id'] + " " + row['Name']
end
Ruby

我们使用each_hash方法查看结果集。 返回的每一行都是一个 Ruby 哈希； 键值对的集合。 键是列名。

$ ./retrieve3.rb
We have 3 row(s)
1 Jack London
2 Honore de Balzac
3 Lion Feuchtwanger
Ruby

示例的输出。

多个语句

MySQL 支持多条语句执行。 必须通过特殊选项启用它。

#!/usr/bin/ruby

require 'mysql'

begin

    con = Mysql.new 'localhost', 'user12', '34klq*', 'mydb'
    con.set_server_option Mysql::OPTION_MULTI_STATEMENTS_ON

    rs = con.query "SELECT Name FROM Writers WHERE Id=1;
                    SELECT Name FROM Writers WHERE Id=2;
                    SELECT Name FROM Writers WHERE Id=3"

    puts rs.fetch_row        

    while con.next_result
        rs = con.store_result    
        puts rs.fetch_row
    end       

rescue Mysql::Error => e
    puts e.errno
    puts e.error

ensure
    con.close if con
end
Ruby

在此示例中，我们在一个查询中具有三个SELECT语句。

con.set_server_option Mysql::OPTION_MULTI_STATEMENTS_ON
Ruby

首先，我们需要使用Mysql::OPTION_MULTI_STATEMENTS_ON启用多条语句处理。

rs = con.query "SELECT Name FROM Writers WHERE Id=1;
                SELECT Name FROM Writers WHERE Id=2;
                SELECT Name FROM Writers WHERE Id=3"
Ruby

在这里，我们定义了三个SELECT语句。 它们之间用分号分隔。

puts rs.fetch_row
Ruby

查询方法返回第一个结果集。 我们从该结果集中获取一行。

while con.next_result
    rs = con.store_result    
    puts rs.fetch_row
end
Ruby

我们将获得其他结果集，直到没有更多要处理的语句为止。

$ ./multiplest.rb
Jack London
Honore de Balzac
Lion Feuchtwanger
Ruby

运行示例。

元数据

元数据是有关数据库中数据的信息。 MySQL 系统中的元数据包含有关存储数据的表和列的信息。 受 SQL 语句影响的行数是元数据。 结果集中返回的行数和列数也属于元数据。

#!/usr/bin/ruby

require 'mysql'

begin

    con = Mysql.new 'localhost', 'user12', '34klq*', 'mydb'    
    rs = con.query "SELECT * FROM Writers WHERE Id IN (1, 2, 3)"
    puts "We have #{con.field_count} fields"
    puts "We have #{rs.num_rows} row(s)"
    puts rs.fetch_row.join("\s")

rescue Mysql::Error => e
    puts e    
ensure
    con.close if con
end
Ruby

在此脚本中，我们从 SQL 查询中找出行数和列数。

rs = con.query "SELECT * FROM Writers WHERE Id IN (1, 2, 3)"
Ruby

该 SQL 语句返回三行。 每行有两列。

puts "We have #{con.field_count} fields"
puts "We have #{rs.num_rows} row(s)"
Ruby

这两行返回结果集中的列数和行数。 请注意，此处的字段是列的同义词。 返回的数据是元数据。

puts rs.fetch_row.join("\s")
Ruby

在这里，我们从结果集中返回一行。 这是存储在我们数据库表中的原始数据。

对于INSERT，DELETE和UPDATE语句，有一种称为rows_affected的方法。 此方法返回受这三个语句影响的行数。

#!/usr/bin/ruby

require 'mysql'

begin

    con = Mysql.new 'localhost', 'user12', '34klq*', 'mydb'    
    con.query "DELETE FROM Writers WHERE Id IN (1, 2, 3)"

    puts "The query has affected #{con.affected_rows} rows"

rescue Mysql::Error => e
    puts e    
ensure
    con.close if con
end
Ruby

在我们的示例中，我们从Writers表中删除了前三行。

con.query "DELETE FROM Writers WHERE Id IN (1, 2, 3)"
Ruby

一个 SQL 语句，该语句删除Writers表的前三行。

puts "The query has affected #{con.affected_rows} rows"
Ruby

在这里，我们得到受上述 SQL 语句影响的行数。 该数字属于元数据。

$ ./affected.rb
The query has affected 3 rows

mysql> SELECT * FROM Writers;
+----+---------------+
| Id | Name          |
+----+---------------+
|  4 | Emile Zola    |
|  5 | Truman Capote |
+----+---------------+
2 rows in set (0.00 sec)
Ruby

我们执行受影响的.rb 脚本，并检查Writers表中的更改。 三行已被删除。

在下一个示例中，我们将检查有关字段的元数据。

#!/usr/bin/ruby

require 'mysql'

begin
    con = Mysql.new 'localhost', 'user12', '34klq*', 'mydb'
    rs = con.query "SELECT * FROM Writers WHERE Id=1"
    field = rs.fetch_field_direct 1

    puts "Table name: #{field.table}"
    puts "Field name: #{field.name}"
    puts "Field length: #{field.length}"
    puts "Field type: #{field.type}"

rescue Mysql::Error => e
    puts e

ensure
    con.close if con
end
Ruby

我们从数据库中获得一条记录。 我们得到字段的表名，列名，长度和类型。

rs = con.query "SELECT * FROM Writers WHERE Id=1"
Ruby

该查询返回一行。 它有两列。

field = rs.fetch_field_direct 1
Ruby

使用fetch_field_direct方法，我们得到了一条特定的记录。 更准确地说，记录来自第一行第二列的交集。

puts "Table name: #{field.table}"
puts "Field name: #{field.name}"
puts "Field length: #{field.length}"
puts "Field type: #{field.type}"
Ruby

我们使用字段对象的属性读取器获取元数据。

$ ./metadata.rb
Table name: Writers
Field name: Name
Field length: 25
Field type: 253
Ruby

这是示例的输出。

在与元数据有关的最后一个示例中，我们将打印表中的所有行及其列名。

#!/usr/bin/ruby

require 'mysql'

begin
    con = Mysql.new 'localhost', 'user12', '34klq*', 'mydb'
    rs = con.query "SELECT * FROM Writers"

    fields = rs.fetch_fields    
    puts "%3s %s" % [fields[0].name, fields[1].name]

    rs.each_hash do |row|
        puts "%3s %s" % [row['Id'], row['Name']]
    end

rescue Mysql::Error => e
    puts e

ensure
    con.close if con
end
Ruby

我们将Writers表的内容打印到控制台。 现在，我们也包括列的名称。

fields = rs.fetch_fields    
puts "%3s %s" % [fields[0].name, fields[1].name]
Ruby

第一步，我们获取列名。 它们使用标准的 Ruby 字符串格式化功能进行打印。

rs.each_hash do |row|
    puts "%3s %s" % [row['Id'], row['Name']]
end
Ruby

现在，将获取数据并将其打印到控制台。 我们也进行一些格式化。

$ ./columnheaders.rb
 Id Name
  1 Jack London
  2 Honore de Balzac
  3 Lion Feuchtwanger
  4 Emile Zola
  5 Truman Capote
Ruby

脚本的输出。

预备语句

现在，我们将以预备语句来关注自己。 在编写预备语句时，我们使用占位符，而不是直接将值写入语句中。 预准备的语句可提高安全性和性能。

#!/usr/bin/ruby

require 'mysql'

name = "Stefan Zweig"

begin

    con = Mysql.new 'localhost', 'user12', '34klq*', 'mydb'    
    pst = con.prepare "INSERT INTO Writers(Name) VALUES(?)"
    pst.execute name

rescue Mysql::Error => e
    puts e    

ensure
    con.close if con
    pst.close if pst
end
Ruby

在上面的示例中，我们将新行插入Writers表。 我们使用预备语句。

pst = con.prepare "INSERT INTO Writers(Name) VALUES(?)"
Ruby

prepare方法用于创建预备语句。 ?字符是一个占位符。 稍后，我们将一个值绑定到该占位符。

pst.execute name
Ruby

我们将名称变量中的值绑定到占位符，并执行预备语句。

pst.close if pst
Ruby

预备语句已关闭。

mysql> SELECT * FROM Writers;
+----+-------------------+
| Id | Name              |
+----+-------------------+
|  1 | Jack London       |
|  2 | Honore de Balzac  |
|  3 | Lion Feuchtwanger |
|  4 | Emile Zola        |
|  5 | Truman Capote     |
|  6 | Stefan Zweig      |
+----+-------------------+
6 rows in set (0.00 sec)
Ruby

脚本成功运行后，我们在 Writers 表中看到一个新作者。

写图像

有些人喜欢将其图像放入数据库中，有些人则希望将其保留在文件系统中以供其应用使用。 当我们处理大量图像时，会出现技术难题。 图像是二进制数据。 MySQL 数据库具有一种特殊的数据类型来存储称为BLOB（二进制大对象）的二进制数据。

mysql> CREATE TABLE Images(Id INT PRIMARY KEY AUTO_INCREMENT, Data MEDIUMBLOB);
Query OK, 0 rows affected (0.06 sec)
Ruby

对于此示例，我们创建一个名为Images的新表。

#!/usr/bin/ruby

require 'mysql'

begin

    fin = File.open("woman.jpg" , "rb")
    img = fin.read

rescue SystemCallError => e      
    puts e
ensure
    fin.close if fin 
end

begin

    con = Mysql.new 'localhost', 'user12', '34klq*', 'mydb'  
    pst = con.prepare("INSERT INTO Images SET Data='%s'" % img.unpack('H*'))
    pst.execute    

rescue Mysql::Error => e
    puts e

ensure
    con.close if con
    pst.close if pst
end
Ruby

在上面的脚本中，我们读取 JPG 图像并将其插入到Images表中。

fin = File.open("woman.jpg" , "rb")
img = fin.read
Ruby

我们打开并阅读图像。 read方法以字符串形式返回数据。

pst = con.prepare("INSERT INTO Images SET Data='%s'" % img.unpack('H*'))
Ruby

将该字符串数据放入预备语句中。 在这样做之前，使用 Ruby 字符串对象的unpack方法对其进行解码。 解码是必需的，因为图像对象具有许多无法正常处理的特殊字符。

读取图像

在前面的示例中，我们已将图像插入数据库表中。 现在，我们将从表中读取图像。

#!/usr/bin/ruby

require 'mysql'

begin

    con = Mysql.new 'localhost', 'user12', '34klq*', 'mydb'          
    rs = con.query "SELECT Data FROM Images LIMIT 1"    
    f = File.new "woman2.jpg", "wb"
    f.write rs.fetch_row.pack 'H*'

rescue Mysql::Error, SystemCallError => e
    puts e

ensure
    con.close if con
    f.close if f
end
Ruby

我们从图片表中读取了一张图片。

rs = con.query "SELECT Data FROM Images LIMIT 1"
Ruby

我们从表中选择一条记录。

f = File.new "woman2.jpg", "wb"
Ruby

我们创建一个可写的二进制文件。

f.write rs.fetch_row.pack 'H*'
Ruby

我们从先前的 SQL 语句中获取数据并将其写入文件。 fetch_row方法返回一个数组对象。 在将数据写入文件之前，使用数组的pack方法将其放回原始格式。 对于解码和反转这两种操作，我们使用相同的指令'H*'。 它代表十六进制字符串。

现在我们在当前目录中应该有一个名为woman2.jpg的映像。 我们可以检查它是否与我们插入表中的图像相同。

事务支持

transaction是针对一个或多个数据库中数据的数据库操作的基本单位。 事务中所有 SQL 语句的影响可以全部提交给数据库，也可以全部回滚。

默认情况下，MySQL 在自动提交模式下运行。 在这种模式下，对表的所有更改将立即生效。 为了防止这种情况，我们必须关闭自动提交模式。 禁用自动提交后，对事务感知表的更改不会立即永久更改。 要存储更改，我们必须调用COMMIT语句或ROLLBACK还原它们。 Ruby MySQL 为这些 SQL 语句commit和rollback提供了便捷的方法。

MySQL 数据库具有不同类型的存储引擎。 最常见的是 MyISAM 和 InnoDB 引擎。 在数据安全性和数据库速度之间需要权衡。 MyISAM 表的处理速度更快，并且不支持事务。 commit和rollback方法未实现。 他们什么都不做。 另一方面，InnoDB 表可以更安全地防止数据丢失。 他们支持事务。 它们处理较慢。

mysql> SELECT TABLE_NAME, ENGINE FROM information_schema.TABLES 
    -> where TABLE_SCHEMA = 'mydb' AND TABLE_NAME='Writers';
+------------+--------+
| TABLE_NAME | ENGINE |
+------------+--------+
| Writers    | InnoDB |
+------------+--------+
1 row in set (0.00 sec)
Ruby

Writers表的引擎是 InnoDB，它支持事务。

#!/usr/bin/ruby

require 'mysql'

begin
    con = Mysql.new 'localhost', 'user12', '34klq*', 'mydb'

    con.autocommit false

    pst = con.prepare "UPDATE Writers SET Name = ? WHERE Id = ?"
    pst.execute "Leo Tolstoy", "1"
    pst.execute "Boris Pasternak", "2"
    pst.execute "Leonid Leonov"

    con.commit

rescue Mysql::Error => e
    puts e
    con.rollback

ensure
    pst.close if pst
    con.close if con
end
Ruby

在此脚本中，我们尝试更新三行。

con.autocommit false
Ruby

自动提交模式被禁用。

pst = con.prepare "UPDATE Writers SET Name = ? WHERE Id = ?"
pst.execute "Leo Tolstoy", "1"
pst.execute "Boris Pasternak", "2"
pst.execute "Leonid Leonov"
Ruby

我们执行三个UPDATE语句。 最后一个不正确。 第二个参数丢失。

con.commit
Ruby

如果一切正常，则更改将提交到表中。

rescue Mysql::Error => e
    puts e
    con.rollback
Ruby

如果发生错误，则会回滚更改。

$ ./update.rb
execute: param_count(2) != number of argument(1)

mysql> SELECT * FROM Writers;
+----+-------------------+
| Id | Name              |
+----+-------------------+
|  1 | Jack London       |
|  2 | Honore de Balzac  |
|  3 | Lion Feuchtwanger |
|  4 | Emile Zola        |
|  5 | Truman Capote     |
|  6 | Stefan Zweig      |
+----+-------------------+
6 rows in set (0.00 sec)
Ruby

运行脚本会出现错误。 但是，该事务已回滚，并且前两行未更改。

您可能也对 MySQL Python 教程， MySQL Visual Basic 教程或 MySQL PHP 教程，MySQL Java 教程，MySQL Ruby 教程，MySQL C# 教程感兴趣。

Python教程

Python 教程

Python 教程
Tkinter 教程

Tkinter 教程
Pandas 教程

Pandas 教程
NumPy 教程

NumPy 教程
Flask 教程

Flask 教程
Django 教程

Django 教程
PySpark 教程

PySpark 教程
wxPython 教程

wxPython 教程
SymPy 教程

SymPy 教程
Seaborn 教程

Seaborn 教程
SciPy 教程

SciPy 教程
RxPY 教程

RxPY 教程
Pycharm 教程

Pycharm 教程
Pygame 教程

Pygame 教程
PyGTK 教程

PyGTK 教程
PyQt 教程

PyQt 教程
PyQt5 教程

PyQt5 教程
PyTorch 教程

PyTorch 教程
Matplotlib 教程

Matplotlib 教程
Web2py 教程

Web2py 教程
BeautifulSoup 教程

BeautifulSoup 教程

Java教程

Java 教程

Java 教程

Web教程

HTML 教程

HTML 教程
CSS 教程

CSS 教程
CSS3 教程

CSS3 教程
jQuery 教程

jQuery 教程
Ajax 教程

Ajax 教程
AngularJS 教程

AngularJS 教程
TypeScript 教程

TypeScript 教程
WordPress 教程

WordPress 教程
Laravel 教程

Laravel 教程
Next.js 教程

Next.js 教程
PhantomJS 教程

PhantomJS 教程
Three.js 教程

Three.js 教程
Underscore.JS 教程

Underscore.JS 教程
WebGL 教程

WebGL 教程
WebRTC 教程

WebRTC 教程
VueJS 教程

VueJS 教程

数据库教程

SQL 教程

SQL 教程
MySQL 教程

MySQL 教程
MongoDB 教程

MongoDB 教程
PostgreSQL 教程

PostgreSQL 教程
SQLite 教程

SQLite 教程
Redis 教程

Redis 教程
MariaDB 教程

MariaDB 教程

图形图像教程

Vulkan 教程

Vulkan 教程
OpenCV 教程

OpenCV 教程

大数据教程

R语言 教程

R语言 教程

开发工具教程

Git 教程

Git 教程
VSCode 教程

VSCode 教程
Docker 教程

Docker 教程
Gerrit 教程

Gerrit 教程
Excel 教程

Excel 教程

计算机教程

Go语言 教程

Go语言 教程
C++ 教程

C++ 教程

MySQL 教程

登录

找回密码？

注册