Java、PHP、Python与MySQL交互的性能测试

最新推荐文章于 2022-10-10 15:57:40 发布
最新推荐文章于 2022-10-10 15:57:40 发布
阅读量253 收藏 1
点赞数
分类专栏： J2EE 文章标签： Python PHP Java MySQL SQL
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/binma85/article/details/83682940
版权
文章来源：http://www.keakon.cn/bbs/thread-1858-1-1.html
这几天看源码弄清了一件事：WEB服务器接收浏览器请求、将请求传给PHP/Python进程（FCGI等）、与数据库进行交互都是用socket（套接字）。
也就是说，这些行为都是进程间通信。一台WEB服务器在硬件、操作系统不变的情况下，它的性能主要取决于socket通信的速度。如果所有进程都在一台服务器上的话，这个速度就取决于通信的效率了。

例如与MySQL数据库交互时，程序会调用驱动程序来访问数据库，这个驱动程序主要做这几件事：


1.创建socket，连接到MySQL。

2.将程序调用的API翻译成SQL语句，通过socket发送给MySQL；MySQL执行后，将结果发送回来；驱动程序将结果（字符串）传给程序，如有需要，还可以自动翻译成程序能识别的变量类型（如整型）。

3.断开连接。


可见连接的速度、翻译的速度和接受响应的及时性是最主要的3个方面。

弄明白这点后就不难发现，与数据库的执行时间相比，这些只是很少的一部分；而且PHP和Python使用的都是C实现，而JDBC是用Java实现，所以根本不必担心PHP和Python的性能。
不过在翻译方面还存在算法和实现上的差异，客户端还可以缓存一些语句，所以仍然会出现一些性能上的差异。
为证明我的想法，我特意去测试了一番。

首先列出测试平台：
[quote]
CPU：Intel Core2 Duo T9400 @ 2.53GHz
内存：3GB
操作系统：Windows XP Pro SP2
MySQL：5.1.36
Java：1.6.0_17-b04
JDBC：MySQL Connector/J 5.1.10
PHP：5.2.11 (cli)
MySQLi：5.2.11.11
Python：2.6.4
MySQL-Python：1.2.3c1
[/quote]

所用的库都是最新版的，也都采用了最为推荐的库。
但数据库并没有使用最新的稳定版，因为我懒得重下了。5.4.3-beta测试版也试过，在连续插入时，性能比5.1快1～2个数量级，估计是服务器端缓存和设置的原因。

测试项目：


1.创建100万个随机数，并生成插入这些随机数的SQL语句。

2.连接本地数据库，如不成功，尝试创建数据库。

3.删除并创建数据库表，引擎类型为InnoDB，主键为自动递增的整数，此外有个浮点型的字段（无索引）。

4.分成100组，每次插入1万个随机数。（因为每组的执行量都很大，因此启用自动提交事务。）

5.用SELECT COUNT(*)统计小于0.1的随机数个数。（约10万个）

6.用SELECT *取出再统计大于0.9的随机数个数。（约10万个）

7.将所有0.4～0.5之间的随机数加1。（约10万个）

8.将所有0.5～0.6之间的行删除。（约20万个）

9.断开数据库连接。

10.再次连接数据库。


测试代码：

Java： 
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.Statement;
import java.sql.ResultSet;
import java.util.Random;


public final class Test {

	public static void main(String[] args) {
		final int SIZE1 = 10000;
		final int SIZE2 = 100;
		final String DB_ENGINE = "InnoDB"; // InnoDB Memory MyISAM
		final double NANO_TIME_PER_SEC = 1000000000.0;
		System.out.printf("测试数据量：%d\n", SIZE1 * SIZE2);
		System.out.printf("测试引擎：%s\n", DB_ENGINE);

		long t1 = System.nanoTime(), t2, t3 = 0, t4, t5, t6, t7, t8, t9, t10, t11;
		Connection conn = null;
		Statement stmt = null;
		ResultSet rs = null;

		Random r = new Random();
		String[] sqls = new String[SIZE2];
		for (int i = 0; i < SIZE2; ++i){
			StringBuilder buffer = new StringBuilder("INSERT INTO test (value) VALUES (");
			for (int j = 0; j < SIZE1; ++j){
				buffer.append(r.nextDouble()).append("),(");
			}
			sqls[i] = buffer.substring(0, buffer.length() -2);
		}
		t2 = System.nanoTime();

		try {
			conn = DriverManager.getConnection("jdbc:mysql://localhost/testdb?user=root&password=123456");
			t3 = System.nanoTime();
			stmt = conn.createStatement();
		} catch (SQLException e) {
			try {
				conn = DriverManager.getConnection("jdbc:mysql://localhost/?user=root&password=123456");
				t3 = System.nanoTime();
				stmt = conn.createStatement();
				stmt.execute("CREATE DATABASE testdb");
			} catch (SQLException ex) {
				System.out.println("SQLException: " + ex.getMessage());
				System.out.println("SQLState: " + ex.getSQLState());
				System.out.println("VendorError: " + ex.getErrorCode());
			}
		}

		try {
			stmt.execute("DROP TABLE test");
		} catch (SQLException e) {
		}
		try {
			stmt.execute("CREATE TABLE test (`id` INT AUTO_INCREMENT PRIMARY KEY, `value` REAL) ENGINE = " + DB_ENGINE);
		} catch (SQLException e) {
		}
		t4 = System.nanoTime();

		try {
			for (String sql: sqls){
				stmt.execute(sql);
			}
			t5 = System.nanoTime();

			rs = stmt.executeQuery("SELECT COUNT(*) FROM test WHERE value < 0.1");
			if (rs.next())
				System.out.printf("共有%d个小于0.1的随机数\n", rs.getInt(1));
			t6 = System.nanoTime();

			rs = stmt.executeQuery("SELECT * FROM test WHERE value > 0.9");
			if (rs.last())
				System.out.printf("共有%d个大于0.9的随机数\n", rs.getRow());
			t7 = System.nanoTime();

			stmt.executeUpdate("UPDATE test SET value = value + 0.1 WHERE value > 0.4 AND value < 0.5");
			t8 = System.nanoTime();

			stmt.execute("DELETE FROM test WHERE value > 0.5 AND value < 0.6");
			t9 = System.nanoTime();

			stmt.close();
			conn.close();
			t10 = System.nanoTime();

			conn = DriverManager.getConnection("jdbc:mysql://localhost/?user=root&password=123456");
			t11 = System.nanoTime();
			conn.close();

			System.out.printf("创建随机数：%f\n", (t2 - t1) / NANO_TIME_PER_SEC);
			System.out.printf("初次连接数据库：%f\n", (t3 - t2) / NANO_TIME_PER_SEC);
			System.out.printf("再次连接数据库：%f\n", (t11 - t10) / NANO_TIME_PER_SEC);
			System.out.printf("初始化数据库和表：%f\n", (t4 - t3) / NANO_TIME_PER_SEC);
			System.out.printf("插入：%f\n", (t5 - t4) / NANO_TIME_PER_SEC);
			System.out.printf("选择（COUNT）：%f\n", (t6 - t5) / NANO_TIME_PER_SEC);
			System.out.printf("选择：%f\n", (t7 - t6) / NANO_TIME_PER_SEC);
			System.out.printf("更新：%f\n", (t8 - t7) / NANO_TIME_PER_SEC);
			System.out.printf("删除：%f\n", (t9 - t8) / NANO_TIME_PER_SEC);
			System.out.printf("关闭连接：%f\n", (t10 - t9) / NANO_TIME_PER_SEC);
			System.out.printf("总时间：%f\n", (t10 - t1) / NANO_TIME_PER_SEC);

		} catch (SQLException ex) {
			System.out.println("SQLException: " + ex.getMessage());
			System.out.println("SQLState: " + ex.getSQLState());
			System.out.println("VendorError: " + ex.getErrorCode());
		}

	}

}

PHP： 
<?php
define('SIZE1', 10000);
define('SIZE2', 100);
define('DB_ENGINE', 'InnoDB'); // InnoDB Memory MyISAM

printf("测试数据量：%d\n", SIZE1 * SIZE2);
printf("测试引擎：%s\n", DB_ENGINE);

$t1 = microtime(true);
for ($i = 0; $i < SIZE2; ++$i){
	for ($j = 0; $j < SIZE1; ++$j){
		$buffer[] = lcg_value();
	}
	$sqls[$i] = 'INSERT INTO test (value) VALUES ('.join('),(', $buffer).')';
	unset($buffer);
}

$t2 = microtime(true);

$db = new mysqli('localhost', 'root', '123456', 'testdb');
$t3 = microtime(true);
if (mysqli_connect_errno()) {
	$db = new mysqli('localhost', 'root', '123456');
	$t3 = microtime(true);
	$db->query('CREATE DATABASE testdb');
	$db->select_db('testdb');
}

$db->query('DROP TABLE test');
$db->query('CREATE TABLE test (`id` INT AUTO_INCREMENT PRIMARY KEY, `value` REAL) ENGINE = '.DB_ENGINE);
$t4 = microtime(true);

foreach ($sqls as $key=>$sql) {
	$db->query($sql);
}
$t5 = microtime(true);

$result = $db->query('SELECT COUNT(*) FROM test WHERE value < 0.1')->fetch_row();
printf("共有%d个小于0.1的随机数\n", $result[0]);
$t6 = microtime(true);

$result = $db->query('SELECT * FROM test WHERE value > 0.9');
printf("共有%d个大于0.9的随机数\n", $result->num_rows);
$t7 = microtime(true);

$db->query('UPDATE test SET value = value + 0.1 WHERE value > 0.4 AND value < 0.5');
$t8 = microtime(true);

$db->query('DELETE FROM test WHERE value > 0.5 AND value < 0.6');
$t9 = microtime(true);

$db->close();
$t10 = microtime(true);

$db = new mysqli('localhost', 'root', '123456', 'testdb');
$t11 = microtime(true);
$db->close();

printf("创建随机数：%f\n", $t2 - $t1);
printf("初次连接数据库：%f\n", $t3 - $t2);
printf("再次连接数据库：%f\n", $t11 - $t10);
printf("初始化数据库和表：%f\n", $t4 - $t3);
printf("插入：%f\n", $t5 - $t4);
printf("选择（COUNT）：%f\n", $t6 - $t5);
printf("选择：%f\n", $t7 - $t6);
printf("更新：%f\n", $t8 - $t7);
printf("删除：%f\n", $t9 - $t8);
printf("关闭连接：%f\n", $t10 - $t9);
printf("总时间：%f\n", $t10 - $t1);
?>

Python： 

# -*- coding: gbk -*-

import MySQLdb
from random import random
from time import clock

SIZE1 = 10000
SIZE2 = 100
DB_ENGINE = 'InnoDB' # InnoDB Memory MyISAM
print '测试数据量：', SIZE1 * SIZE2
print '测试引擎：', DB_ENGINE

t1 = clock()

sqls = ['INSERT INTO test (value) VALUES (%s)' % '),('.join([`random()` for i in xrange(SIZE1)]) for j in xrange(SIZE2)]
t2 = clock()

try:
  con = MySQLdb.connect(user='root', passwd='123456', db='testdb')
  t3 = clock()
  cu = con.cursor()
except:
  con = MySQLdb.connect(user='root', passwd='123456')
  t3 = clock()
  cu = con.cursor()
  cu.execute('CREATE DATABASE testdb')
  con.select_db('testdb')

con.autocommit(True)

try:
  cu.execute('DROP TABLE test')
except:
  pass
cu.execute('''CREATE TABLE test (
`id` INT AUTO_INCREMENT PRIMARY KEY,
`value` REAL)
ENGINE = %s''' % DB_ENGINE)
t4 = clock()

for sql in sqls:
  cu.execute(sql)
t5 = clock()

cu.execute('SELECT COUNT(*) FROM test WHERE value < 0.1')
print '共有%d个小于0.1的随机数' % cu.fetchone()[0]
t6 = clock()

cu.execute('SELECT * FROM test WHERE value > 0.9')
print '共有%d个大于0.9的随机数' % len(cu.fetchall())
t7 = clock()

cu.execute('UPDATE test SET value = value + 0.1 WHERE value > 0.4 AND value < 0.5')
t8 = clock()

cu.execute('DELETE FROM test WHERE value > 0.5 AND value < 0.6')
t9 = clock()

cu.close()
con.close()
t10 = clock()

con = MySQLdb.connect(user='root', passwd='123456', db='testdb')
t11 = clock()
con.close()

print '创建随机数：', t2 - t1
print '初次连接数据库：', t3 - t2
print '再次连接数据库：', t11 - t10
print '初始化数据库：', t4 - t3
print '插入：', t5 - t4
print '选择（COUNT）', t6 - t5
print '选择：', t7 - t6
print '更新：', t8 - t7
print '删除：', t9 - t8
print '关闭连接：', t10 - t9
print '总时间：', t10 - t1


MySQL-Python还有个底层的模块，一并测试下： 
# -*- coding: gbk -*-

import _mysql
from MySQLdb.converters import conversions
from random import random
from time import clock

SIZE1 = 10000
SIZE2 = 100
DB_ENGINE = 'InnoDB' # InnoDB Memory MyISAM
print '测试数据量：', SIZE1 * SIZE2
print '测试引擎：', DB_ENGINE

t1 = clock()

sqls = ['INSERT INTO test (value) VALUES (%s)' % '),('.join([`random()` for i in xrange(SIZE1)]) for j in xrange(SIZE2)]
t2 = clock()

try:
  con = _mysql.connect(user='root', passwd='123456', db='testdb', conv=conversions)
  t3 = clock()
except:
  con = _mysql.connect(user='root', passwd='123456', conv=conversions)
  t3 = clock()
  con.query('CREATE DATABASE testdb')
  con.select_db('testdb')

con.autocommit(True)

try:
  con.query('DROP TABLE test')
except:
  pass
con.query('''CREATE TABLE test (
`id` INT AUTO_INCREMENT PRIMARY KEY,
`value` REAL)
ENGINE = %s''' % DB_ENGINE)
t4 = clock()

for sql in sqls:
  con.query(sql)
t5 = clock()

con.query('SELECT COUNT(*) FROM test WHERE value < 0.1')
print '共有%d个小于0.1的随机数' % con.store_result().fetch_row()[0]
t6 = clock()

con.query('SELECT * FROM test WHERE value > 0.9')
print '共有%d个大于0.9的随机数' % con.store_result().num_rows()
t7 = clock()

con.query('UPDATE test SET value = value + 0.1 WHERE value > 0.4 AND value < 0.5')
t8 = clock()

con.query('DELETE FROM test WHERE value > 0.5 AND value < 0.6')
t9 = clock()

con.close()
t10 = clock()

con = _mysql.connect(user='root', passwd='123456', db='testdb', conv=conversions)
t11 = clock()
con.close()

print '创建随机数：', t2 - t1
print '初次连接数据库：', t3 - t2
print '再次连接数据库：', t11 - t10
print '初始化数据库：', t4 - t3
print '插入：', t5 - t4
print '选择（COUNT）', t6 - t5
print '选择：', t7 - t6
print '更新：', t8 - t7
print '删除：', t9 - t8
print '关闭连接：', t10 - t9
print '总时间：', t10 - t1


每种测试3次（等硬盘灯无闪烁后才进行下一次测试），取最好的一次作为测试结果：
Java：
[quote]测试数据量：1000000
测试引擎：InnoDB
共有99465个小于0.1的随机数
共有99859个大于0.9的随机数
创建随机数：2.367840
初次连接数据库：0.220420
再次连接数据库：0.013174
初始化数据库和表：0.075140
插入：12.139346
选择（COUNT）：1.130345
选择：1.017769
更新：6.173245
删除：9.380070
关闭连接：0.002131
总时间：32.506307[/quote]

PHP：
[quote]测试数据量：1000000
测试引擎：InnoDB
共有99898个小于0.1的随机数
共有100152个大于0.9的随机数
创建随机数：1.506294
初次连接数据库：0.003146
再次连接数据库：0.001808
初始化数据库和表：0.131754
插入：12.046944
选择（COUNT）：1.236742
选择：1.238153
更新：6.115232
删除：8.145547
关闭连接：0.000125
总时间：30.423937[/quote]

Python（MySQLdb）：
[quote]测试数据量： 1000000
测试引擎： InnoDB
共有100040个小于0.1的随机数
共有100351个大于0.9的随机数
创建随机数： 1.6822107279
初次连接数据库： 0.0332120423126
再次连接数据库： 0.00221704155137
初始化数据库： 0.131054924578
插入： 11.7999030603
选择（COUNT） 1.27067266929
选择： 1.16714526567
更新： 6.29200638629
删除： 8.13660563005
关闭连接： 0.000131022238861
总时间： 30.5129417286[/quote]

Python（_mysql）：
[quote]测试数据量： 1000000
测试引擎： InnoDB
共有99745个小于0.1的随机数
共有99869个大于0.9的随机数
创建随机数： 1.68099074044
初次连接数据库： 0.0112056141213
再次连接数据库： 0.00159293988482
初始化数据库： 0.130169616529
插入： 12.1364623157
选择（COUNT） 1.125517908
选择： 0.968366649951
更新： 6.8042843434
删除： 8.9760508668
关闭连接： 9.61015995031e-05
总时间： 31.8331441566[/quote]

可以看到，在大批量数据测试中，Java是最慢的，而PHP是最快的。
不考虑IO性能的波动的话，Java主要慢在连接和关闭数据库。JDBC 4.0在第一次连接数据库时会动态加载驱动，非常耗时，因此使用Java要记住使用数据库连接池，避免连接浪费大量时间。当然，这也造成了数据库的负担，势必影响内存占用。而创建随机数的算法实现各不相同，所以不具备可比性；令我惊讶的是SELECT的翻译速度，将字符串转换成浮点数居然慢于Python，要知道后者的浮点数可是对象。
PHP连接数据库非常快，所以完全无需使用连接池，因为维护连接池会增加复杂性。
Python的表现和PHP差不多，但是第一次连接数据库比较慢（仍比Java快1个数量级）。如果不用连接池，则使用FCGI等方式来运行比较合适。_mysql模块的通信很快，但更新和删除操作却不太理想，也许是IO性能波动的原因。此外，我在连接数据库时使用了转换参数，实际上我用的语句都不需要翻译，不使用的话会更快一点。

接着试试小数据，改成最常用的MyISAM引擎，插入100条（1组）。一般的应用不可能一次插入那么多，所以足够满足平时的应用了；而且由于数据量很小，也基本不受IO影响。

测试结果：

Java：
[quote]测试数据量：100
测试引擎：MyISAM
共有9个小于0.1的随机数
共有10个大于0.9的随机数
创建随机数：0.001596
初次连接数据库：0.224135
再次连接数据库：0.018656
初始化数据库和表：0.055601
插入：0.001476
选择（COUNT）：0.000529
选择：0.000433
更新：0.000304
删除：0.000313
关闭连接：0.000927
总时间：0.285314[/quote]
PHP：
[quote]测试数据量：测试数据量：100
测试引擎：MyISAM
共有12个小于0.1的随机数
共有9个大于0.9的随机数
创建随机数：0.000649
初次连接数据库：0.008077
再次连接数据库：0.001609
初始化数据库和表：0.060421
插入：0.001860
选择（COUNT）：0.000580
选择：0.000465
更新：0.000326
删除：0.000373
关闭连接：0.000127
总时间：0.072878[/quote]
Python（MySQLdb）：
[quote]测试数据量： 100
测试引擎： MyISAM
共有14个小于0.1的随机数
共有9个大于0.9的随机数
创建随机数： 0.000198907961766
初次连接数据库： 0.0334640296462
再次连接数据库： 0.00150577796899
初始化数据库： 0.0123194428342
插入： 0.00125211444471
选择（COUNT） 0.000581079438867
选择： 0.000484139744018
更新： 0.000250311142897
删除： 0.000262323842835
关闭连接： 7.98984228442e-05
总时间： 0.0488922474784[/quote]

Python（_mysql）：
[quote]测试数据量： 100
测试引擎： MyISAM
共有12个小于0.1的随机数
共有10个大于0.9的随机数
创建随机数： 0.000214273043082
初次连接数据库： 0.0118774872225
再次连接数据库： 0.00123702872851
初始化数据库： 0.0315031659052
插入： 0.00120322554962
选择（COUNT） 0.000596165155069
选择： 0.000507327048549
更新： 0.0002447238406
删除： 0.00026148574749
关闭连接： 5.78285787719e-05
总时间： 0.0464656820909[/quote]

从结果可以看出，虽然差距都很小，但Python仍然稍微占优。不过Java的SELECT操作稍微胜出，而这也是实际应用中最常使用的操作。
再从语言方面来看，Python无疑是写得最欢畅的，生成随机数只用了1行代码；PHP的变量要写个$让我老是出错，不过数据库操作不需要处理异常，这点节省了很多代码；Java的代码量很大，而且不得不使用很多try...catch，我甚至懒得以安全的方式将close()放在finally块里面，因为它也会抛出我根本懒得去管的异常，且会提示我计时变量可能没有初始化。

总体上来看，Google放弃Python，只采用C++和Java是有点不明智。因为页面响应时间主要在于数据库通信和磁盘文件IO上，语言的影响基本忽略不计。

本贴来源：http://www.keakon.cn/bbs/thread-1858-1-1.html
Manny很忙
关注
专栏目录
【100天精通python】Day32：使用python操作数据库_MySQL下载、安装、配置、使用实战
qq_35831906的博客
08-12 1262
MySQL是一款互联网上广泛使用的开源关系型数据库管理系统。本文系统详细介绍使用python操作数据库，从MySQL下载、安装、配置到使用实战。
php和python性能-python、node、php、go、java性能对比测试
weixin_37988176的博客
11-01 490
python、node、php、go、java性能对比测试那随意了 • 2020 年 02 月 12 日python、node、php、go、java性能对比测试无意中看到了这篇文章突发奇想,我电脑环境那么多为什么不自己测一下呢开干电脑配置 i7 8700 ddr4 8g内存*4语言/运行次数100w1000w1亿版本java1429java8python909509305python 3.5ph...
Java、PHP、Python、Erlang、Golang 千万级内存数据插入、查询性能对比
2019想做自己的游戏的人加群95303036
09-14 5472
测试环境： centos 6.3 64bit php 7.2 java 1.86 python 3.4.8Erlang/OTP 19 [erts-8.1]golang 1.9.2 至强2.5G 4核 x 2 8 G内存 146g scsi x 2 raid 0+1 测试内容： 2000万数据，每条数据一个int id，一个string name 测试创建2000万数据的时间速度，再在这2000...
PHP与JAVA循环性能比较
动静之间
09-19 774
PHP/JAVA循环性能测试
Java与Python连接mysql比较
刘越洋子
11-02 1236
Java连接Mysql 栗子 Python连接Mysql 栗子
Java 与 Python 数据交互
LZW15082682930的博客
03-30 5万+
开发环境及工具： java 环境 ：JDK 1.8 Python环境：Python 3.7 (安装anaconda自带的python版本) Anaconda环境： conda 4.5.11 Maven环境： Maven 3.6.3 开发工具： IDEA 2020.3.2 Pycharm 2019.2 Postman 本文是以Spring Boot项目来完成Java与Python的数据操作的。 第一步：添加依赖 在pom.xml文件中加入以下内容 <!--Jython
c,c++,java,sql,php,mysql,python,javascrip等chm文档
10-14
PHP CHM文档将涵盖变量、数组、函数、类与对象、错误处理、文件操作、数据库交互（如MySQL）以及PHP与HTML的集成。 6. **MySQL**：MySQL是一种开源的关系型数据库管理系统，广泛应用于Web应用程序。MySQL CHM文档会...
C/C++/Java/android/PHP/iOS/Python期末试卷.rar
03-04
4. MySQLi 或 PDO_MySQL：与MySQL数据库交互。 5. Session 和 Cookie：用户状态管理。 6. PHP函数：内置函数、自定义函数。 7. MVC（Model-View-Controller）模式：Web应用架构设计。 8. PHP框架：如Laravel、...
Python 和 Java、PHP、C、C#、C++等其他语言的对比?
最新发布
澎湖Java架构师的博客
10-10 1575
’’1.C语言，它既有高级语言的特点，又具有汇编语言的特点，它是结构式语言。C语言应用指针：可以直接进行靠近硬件的操作，但是C的指针操作不做保护，也给它带来了很多不安全的因素。C++在这方面做了改进，在保留了指针操作的同时又增强了安全性，受到了一些用户的支持，但是，由于这些改进增加语言的复杂度，也为另一部分所诟病。Java则吸取了C++的教训，取消了指针操作，也取消了C++改进中一些备受争议的地方，在安全性和适合性方面均取得良好的效果，但其本身解释在虚拟机中运行，运行效率低于C++/C。
PHP MySql增删改查的简单实例
12-19
在Java中，JDBC接口可用于与MySQL交互；而在Node.js中，可以使用mysql2库进行数据库操作。无论使用哪种语言，确保熟悉其对应的数据库操作方法，并遵循最佳实践，如使用预编译语句，以提高代码的安全性和效率。
java php python erlang 千万级内存数据性能比较
09-14
java php python erlang 千万级内存数据性能比较,
【Java】使用Java调用Python的四种方法
热门推荐
为了远大的理想，冲锋！
07-30 7万+
写在前面 为啥一个好好的岗位是Java开发工程师要去做写python呢？因为产品经理安排的（突然多少有点明白为啥程序员和产品经理会一直开撕）。由于在选择企业的时候没看清企业性质，看了要求以为就是互联网企业，现在看看初为社畜的我还是太天真了。不过既然这几天已经在写python脚本了，那也不能浪费这段时间的经历了，毕竟python的闪光点也不少。于是想一下如何与老本行Java联系起来，就有了这篇博文。 文章目录写在前面一、在java类中直接执行python语句二、在java中直接调用python脚本三、★★★使
java交互式调用python程序
valark的博客
03-09 1766
我的上一篇文章 Java 运行python程序 中提到了我想用java调用python进行机器学习，至于为什么需要java来调用，主要是因为评估模型的一个开源库是采用java实现的。 但是这之中还存在一个问题，那就是每次加载模型都需要很多时间，除非为是批处理所有数据，才可以只加载一次模型。而实际上，模拟过程中的数据可能不会同时出现，那么就会反复调用python文件，而每次重新调用就会加载一次模型，最终可能会影响评估的结果。 String as[] = {"1,2,3", "1,2,3", "
java与python数据交互_使用python与java程序交互
weixin_36354965的博客
01-27 870
基本上，我要寻找的是，在java程序使用python运行时与它交互，这样我就可以访问它的输出并将输入传递给它。我用python运行了一个Java程序。我想知道我能否在python程序中访问java程序的输出。例如。在java程序中：System.out.println(“输入编号”)；在python中，我应该能够以字符串的形式获取“Enter no”，并将值从python传递给java程序我一直努...
网络编程之--socket实现python和java通信
日月
07-26 1万+
最近因为项目需求，要求能在python和java之间传输数据，所以了解了一下socket，通过使用socket在两种语言之间传输数据。期间遇见了不少坑，记录一下，算是给后来人一个借鉴（说起来都是泪啊 。。。。。） 1. 先说一下我要干什么，我通过base64编码将图片从前端传到了服务器（java写的网站），然后需要把图片数据传输到python中实现一些功能。其中使用python作为服务端，ja...
千万级数据快速查询，sql相同的情况下，PHP和python获取有效数据速度比较
kinghuahua
04-28 871
1、同样的sql查询，PHP请求时间比python稍微短。 2、PHP的返回数据比python要大。 索引已经尽可能利用，但是查询速度还是较慢。数据量级较高，其中牵扯量级等值的多表联合查询。 优化方案：根据主表的索引优势，快速定位主表满足条件的id数据集合。作为临时表，极大缩减联合查询行数，左查询。 thinkPHP5临时表查询： $aids = Db::name('ax')->...
php查询sqlite慢_Python和PHP哪一个更好，为什么？
weixin_35468857的博客
12-23 77
首先，定义“更好”？这是一个非常主观的术语，完全取决于你要找的是什么。你是说更快吗？更广泛的使用？容易吗？提供更好的就业前景？框架和库的更大可用性？我可以继续说下去。PYTHONPython和PHP哪一个更好，为什么？Python的优势是什么？大量的内置和第三方库/模块，专门用于web开发和服务器管理(服务器管理也适用于web开发)。这些第三方库设计良好，维护良好，易于安装，功能强大。易于开发。如...
php python 函数互相翻译的网站
长门有希的博客
06-13 344
http://www.php2python.com/wiki/function.gzinflate/
C++ Python PHP Java NodeJS性能大PK，结果PHP7是最……
weixin_45583158的博客
12-02 972
导读：语言性能基准测试历来都是硝烟弥漫的战场。本文作者对常用的几种语言进行了性能基准测试得出一些很有意思的结论。由高可用架构志愿者翻译整理如下。首先声明任何一个基准测试都...
Python与MySQL：DB-API接口下的数据库操作教程
本文档主要探讨了如何利用Python编程语言与MySQL数据库进行交互，特别是通过Python的DB-API接口实现数据库操作。作者是Paul DuBois，来自NuSphere Corporation，发表于2001年。文章详细介绍了以下几个关键知识点： ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值