1-8-1-MySQL与Python交互

发表于 2017-09-15 |

1. 安装引入模块

python

安装mysql模块
sudo apt-get install python-mysql
在文件中引入模块
import Mysqldb

python3

安装mysql模块
sudo apt-get install pymysql
在文件中引入模块
import pymysql

2. 使用

#!/usr/bin/python

import pymysql


def main():
    try:
        # 与数据库建立连接
        conn = pymysql.connect(
            host='127.0.0.1', port=3306, user='root', passwd=None, db='python3',charset='utf8'
        )
        # 执行sql语句（二把手）
        cur = conn.cursor()

        # 添加数据
        sql = 'insert into stus(name) values("小二")'
        cur.execute(sql)
        # 修改数据需要提交
        conn.commit()

        # 查询数据
        cur.execute("SELECT * FROM stus")
        
        for r in cur:
            print(r)
        cur.close()
        conn.close()
    except Exception:
        print("error")

if __name__ == "__main__":
    main()

1-7-4-MySQL数据库高级语法

发表于 2017-09-14 |

1. 外键

create table scores(
id int primary key auto_increment,
stuid int,
subid int,
score decimal(5,2),
foreign key(stuid) references students(id),
foreign key(subid) references subjects(id)
);

1-7-3-MySQL数据库备份与恢复

发表于 2017-09-13 |

数据备份

进入超级管理员
1
sudo -s
进入mysql库目录
1
cd /var/lib/mysql

运行mysqldump命令

1	mysqldump –uroot –p 数据库名 > ~/Desktop/备份文件.sql;

按提示输入mysql的密码

数据恢复

连接mysql，创建数据库
退出连接，执行如下命令

1	mysql -uroot –p 数据库名 < ~/Desktop/备份文件.sql

根据提示输入mysql密码

1-7-2-MySQL数据库增删改查学习

发表于 2017-09-12 |

1. 增

添加一整条数据

1	insert into my_test values(0,'小明',0,'1999-1-1',0);

添加不完整数据

1	insert into my_students(name) values('小家电');

添加多条数据

1	insert into my_test(name) values('阿姨'),('神雕'),('郭襄');

2. 删

物理删除
1
delete from stus where id=5;

3. 改

修改某条数据

1	update students set birthday='1990-2-2' where id=2

4. 查

查看列表所有数据
1
select * from my_test;
筛选数据
1
select * from stus where isdelete=0;

逻辑与运算与或非 and , or , not

1	select * from stus where name='小米' and isdelete=0;

模糊查询

1 2	# %表示任意多个字符 select * from stus where name like '小%';

1 2	# 下划线数量表示占位符数量 select * from stus where name like '小_'；

范围查询

1	select * from stus where id in (1,4,6);

1 2	# 编号3-8的男生 select * from stus where id between 3 and 8 and gender=1;

空判断

1
2
3

# null 与 ‘’ 是不同的
select * from stus where birthday is null;
select * from stus where birthday is not null;

优先级

1 2	# 小括号>not>比较运算符>逻辑运算符 # and > or

4.1 聚合

求总数 count()

1	select count(*) from stus where isDelete=0;

最大值 max()
1
select max(id) from stus;
最大值 min()
1
select min(id) from stus;
平均值 avg()
1
select avg(id) from stus;

求和 sum()

1	select sum(id) from stus where gender=1;

4.2 分组

统计男女生人数

1	select gender,count(*) from stus group by gender;

分组后筛选

1
2
3

select gender,count(*) from stus group by gender having gender=0;
select gender,count(*) from stus group by gender having count(*)>2;
select gender,count(*) as rs from stus group by gender having rs>2;

4.3 排序 `select * from 表 order by 列1 asc|desc,列2 asc|desc,...`

默认由小到大

1 2	# 男生按id降序排列 select * from stus where isDelete=0 and gender=1 order by id desc;

4.4 分页

语法 select * from 表 limit start,count; 从start开始，获取count条数据，start索引从0开始
1
select * from stus where isDelete=0 limit 1,3;

每页显示m条数据，当前是n页，n从1开始

1	select * from stus where idDelete=0 limit (n-1)*m,m;

1-7-1-MySQL数据库学习

发表于 2017-09-11 |

1. 数据库命令行学习

进入数据库
1
mysql -uroot -p
创建数据库
1
create database my_test charset=utf8;
查看数据库列表
1
show databases;
删除数据库
1
drop database my_test;
使用数据库
1
use my_test
查看当前数据库
1
select database();

2. 表命令行学习

查看当前数据库所有表

1	show tables;

创建表

# create table students(id int auto_increment primary key not null,name varchar(10) not null,gender bit default 1,birthday datetime);
create table students(
id int auto_increment primary key not null,
name varchar(10) not null,
gender bit default 1,
birthday datetime);

查看表信息
1
desc my_test;

添加列

1	alter table students add isDelete bit default 0;

重命名表
1
rename table my_test to my_test2;

1-6-1-Python线程使用----threading

发表于 2017-09-10 |

多线程-threading

python的thread模块是比较底层的模块，python的threading模块是对thread做了一些包装的，可以更加方便的被使用

1. 使用threading模块

单线程执行

#coding=utf-8
import time

def saySorry():
    print("亲爱的，我错了，我能吃饭了吗？")
    time.sleep(1)

if __name__ == "__main__":
    for i in range(5):
        saySorry()

多线程执行

#coding=utf-8
import threading
import time

def saySorry():
    print("亲爱的，我错了，我能吃饭了吗？")
    time.sleep(1)

if __name__ == "__main__":
    for i in range(5):
        t = threading.Thread(target=saySorry)
        t.start() #启动线程，即让线程开始执行

说明

可以明显看出使用了多线程并发的操作，花费时间要短很多
创建好的线程，需要调用start()方法来启动

2. 主线程会等待所有的子线程结束后才结束

#coding=utf-8
import threading
from time import sleep,ctime

def sing():
    for i in range(3):
        print("正在唱歌...%d"%i)
        sleep(1)

def dance():
    for i in range(3):
        print("正在跳舞...%d"%i)
        sleep(1)

if __name__ == '__main__':
    print('---开始---:%s'%ctime())

    t1 = threading.Thread(target=sing)
    t2 = threading.Thread(target=dance)

    t1.start()
    t2.start()

    #sleep(5) # 屏蔽此行代码，试试看，程序是否会立马结束？
    print('---结束---:%s'%ctime())

3. 查看线程数量

#coding=utf-8
import threading
from time import sleep,ctime

def sing():
    for i in range(3):
        print("正在唱歌...%d"%i)
        sleep(1)

def dance():
    for i in range(3):
        print("正在跳舞...%d"%i)
        sleep(1)

if __name__ == '__main__':
    print('---开始---:%s'%ctime())

    t1 = threading.Thread(target=sing)
    t2 = threading.Thread(target=dance)

    t1.start()
    t2.start()

    while True:
        length = len(threading.enumerate())
        print('当前运行的线程数为：%d'%length)
        if length<=1:
            break

        sleep(0.5)

electron指令-md

发表于 2017-09-10 |

1. 主进程向渲染进程发送指令

主进程代码

const electron = require('electron');
// 控制应用生命周期的模块
const {app} = electron;
// 创建本地浏览器窗口的模块
const {BrowserWindow} = electron;
ipc.on('sy-show',function() {
    var  win = new BrowserWindow({  fullscreen:true,useContentSize:true,resizable:false,autoHideMenuBar:true,frame: false,webPreferences: {plugins: true}});
    // console.log('http://'+HTTP._getIPAddress()+':'+CONFIG.port+'/'+defaultUrl)
    win.loadURL(`file://${__dirname}/index.html`+'?http://'+HTTP._getIPAddress()+':'+CONFIG.port+'/'+defaultUrl );//指定渲染的页面
    
    win.webContents.on('did-finish-load', () => {
      win.webContents.send('ping', 'whoooooooh!')
    })
      // 打开开发工具页面
      // win.webContents.openDevTools();
})

渲染进程代码

var ipc = electron.ipcRenderer;
var BrowserWindow = electron.remote.BrowserWindow;
         ipc.on('ping', (event, message) => {
       console.log(message)  // Prints 'whoooooooh!'
   })

2. 渲染进程向主进程发送指令

渲染进程代码

1	ipc.send('dianPing','点屏要传的参数') //向主线程发送点屏指令

主进程代码

  ipc.on('dianPing',function(event, arg) {
    console.log(arg)
    var  win = new BrowserWindow({ fullscreen:true,useContentSize:true,resizable:false,autoHideMenuBar:true,frame: false,webPreferences: {plugins: true}});
     win.loadURL(`file://${__dirname}/dianPing.html`);//指定渲染的页面
      // 打开开发工具页面
      // win.webContents.openDevTools();
})

1-5-3-Python进程使用----进程池Pool

发表于 2017-09-09 |

当需要创建的子进程数量不多时，可以直接利用multiprocessing中的Process动态成生多个进程，但如果是上百甚至上千个目标，手动的去创建进程的工作量巨大，此时就可以用到multiprocessing模块提供的Pool方法。

初始化Pool时，可以指定一个最大进程数，当有新的请求提交到Pool中时，如果池还没有满，那么就会创建一个新的进程用来执行该请求；但如果池中的进程数已经达到指定的最大值，那么该请求就会等待，直到池中有进程结束，才会创建新的进程来执行，请看下面的实例：

from multiprocessing import Pool
import os,time,random

def worker(msg):
    t_start = time.time()
    print("%s开始执行,进程号为%d"%(msg,os.getpid()))
    #random.random()随机生成0~1之间的浮点数
    time.sleep(random.random()*2) 
    t_stop = time.time()
    print(msg,"执行完毕，耗时%0.2f"%(t_stop-t_start))

po=Pool(3) #定义一个进程池，最大进程数3
for i in range(0,10):
    #Pool.apply_async(要调用的目标,(传递给目标的参数元祖,))
    #每次循环将会用空闲出来的子进程去调用目标
    po.apply_async(worker,(i,))

print("----start----")
po.close() #关闭进程池，关闭后po不再接收新的请求
po.join() #等待po中所有子进程执行完成，必须放在close语句之后
print("-----end-----")

运行结果:

----start----
0开始执行,进程号为21466
1开始执行,进程号为21468
2开始执行,进程号为21467
0 执行完毕，耗时1.01
3开始执行,进程号为21466
2 执行完毕，耗时1.24
4开始执行,进程号为21467
3 执行完毕，耗时0.56
5开始执行,进程号为21466
1 执行完毕，耗时1.68
6开始执行,进程号为21468
4 执行完毕，耗时0.67
7开始执行,进程号为21467
5 执行完毕，耗时0.83
8开始执行,进程号为21466
6 执行完毕，耗时0.75
9开始执行,进程号为21468
7 执行完毕，耗时1.03
8 执行完毕，耗时1.05
9 执行完毕，耗时1.69
-----end-----

multiprocessing.Pool常用函数解析：

apply_async(func[, args[, kwds]]) ：使用非阻塞方式调用func（并行执行，堵塞方式必须等待上一个进程退出才能执行下一个进程），
args为传递给func的参数列表，kwds为传递给func的关键字参数列表；

apply(func[, args[, kwds]])：使用阻塞方式调用func

close()：关闭Pool，使其不再接受新的任务；

terminate()：不管任务是否完成，立即终止；

join()：主进程阻塞，等待子进程的退出， 必须在close或terminate之后使用；

apply堵塞式

from multiprocessing import Pool
import os,time,random

def worker(msg):
    t_start = time.time()
    print("%s开始执行,进程号为%d"%(msg,os.getpid()))
    #random.random()随机生成0~1之间的浮点数
    time.sleep(random.random()*2) 
    t_stop = time.time()
    print(msg,"执行完毕，耗时%0.2f"%(t_stop-t_start))

po=Pool(3) #定义一个进程池，最大进程数3
for i in range(0,10):
    po.apply(worker,(i,))

print("----start----")
po.close() #关闭进程池，关闭后po不再接收新的请求
po.join() #等待po中所有子进程执行完成，必须放在close语句之后
print("-----end-----")

运行结果:

0开始执行,进程号为21532
0 执行完毕，耗时1.91
1开始执行,进程号为21534
1 执行完毕，耗时1.72
2开始执行,进程号为21533
2 执行完毕，耗时0.50
3开始执行,进程号为21532
3 执行完毕，耗时1.27
4开始执行,进程号为21534
4 执行完毕，耗时1.05
5开始执行,进程号为21533
5 执行完毕，耗时1.60
6开始执行,进程号为21532
6 执行完毕，耗时0.25
7开始执行,进程号为21534
7 执行完毕，耗时0.63
8开始执行,进程号为21533
8 执行完毕，耗时1.21
9开始执行,进程号为21532
9 执行完毕，耗时0.60
----start----
-----end-----

electron与其他程序之间进行通讯

发表于 2017-09-08 |

安装依赖包
npm install messenger

使用

var messenger = require('messenger');

// here we have 4 servers listening on 4 different ports
var server1 = messenger.createListener(8001);
var server2 = messenger.createListener(8002);
var server3 = messenger.createListener(8003);
var server4 = messenger.createListener('127.0.0.1:8004');

server1.on('a message came', function(m, data){
  // note that m.data and data are equivalent
  console.log('server 1 got data', data);
});

server2.on('a message came', function(m, data){
  console.log('server 2 got data', data);
});

server3.on('a message came', function(m, data){
  console.log('server 3 got data', data);
});

server4.on('a message came', function(m, data){
  console.log('server 4 got data', data);
});

// a client that can be used to emit to all the servers
var client = messenger.createSpeaker(8001, 8002, 8003, 8004);

setInterval(function(){
  client.shout('a message came', {some: data});
}, 1000);

参考
github

1-5-3-Python进程使用----Queue

发表于 2017-09-08 |

进程间通信-Queue

Process之间有时需要通信，操作系统提供了很多机制来实现进程间的通信。

1. Queue的使用

可以使用multiprocessing模块的Queue实现多进程之间的数据传递，Queue本身是一个消息列队程序，首先用一个小实例来演示一下Queue的工作原理：


#coding=utf-8
from multiprocessing import Queue
q=Queue(3) #初始化一个Queue对象，最多可接收三条put消息
q.put("消息1") 
q.put("消息2")
print(q.full())  #False
q.put("消息3")
print(q.full()) #True

#因为消息列队已满下面的try都会抛出异常，第一个try会等待2秒后再抛出异常，第二个Try会立刻抛出异常
try:
    q.put("消息4",True,2)
except:
    print("消息列队已满，现有消息数量:%s"%q.qsize())

try:
    q.put_nowait("消息4")
except:
    print("消息列队已满，现有消息数量:%s"%q.qsize())

#推荐的方式，先判断消息列队是否已满，再写入
if not q.full():
    q.put_nowait("消息4")

#读取消息时，先判断消息列队是否为空，再读取
if not q.empty():
    for i in range(q.qsize()):
        print(q.get_nowait())

运行结果:


False
True
消息列队已满，现有消息数量:3
消息列队已满，现有消息数量:3
消息1
消息2
消息3

说明

初始化Queue()对象时（例如：q=Queue()），若括号中没有指定最大可接收的消息数量，或数量为负值，那么就代表可接受的消息数量没有上限（直到内存的尽头）；

Queue.qsize()：返回当前队列包含的消息数量；
Queue.empty()：如果队列为空，返回True，反之False ；
Queue.full()：如果队列满了，返回True,反之False；
Queue.get([block[, timeout]])：获取队列中的一条消息，然后将其从列队中移除，block默认值为True；

1）如果block使用默认值，且没有设置timeout（单位秒），消息列队如果为空，此时程序将被阻塞（停在读取状态），直到从消息列队读到消息为止，如果设置了timeout，则会等待timeout秒，若还没读取到任何消息，则抛出”Queue.Empty”异常；

2）如果block值为False，消息列队如果为空，则会立刻抛出”Queue.Empty”异常；

Queue.get_nowait()：相当Queue.get(False)；
Queue.put(item,[block[, timeout]])：将item消息写入队列，block默认值为True；

1）如果block使用默认值，且没有设置timeout（单位秒），消息列队如果已经没有空间可写入，此时程序将被阻塞（停在写入状态），直到从消息列队腾出空间为止，如果设置了timeout，则会等待timeout秒，若还没空间，则抛出”Queue.Full”异常；

2）如果block值为False，消息列队如果没有空间可写入，则会立刻抛出”Queue.Full”异常；

Queue.put_nowait(item)：相当Queue.put(item, False)；

2. Queue实例

我们以Queue为例，在父进程中创建两个子进程，一个往Queue里写数据，一个从Queue里读数据：

from multiprocessing import Process, Queue
import os, time, random

# 写数据进程执行的代码:
def write(q):
    for value in ['A', 'B', 'C']:
        print 'Put %s to queue...' % value
        q.put(value)
        time.sleep(random.random())

# 读数据进程执行的代码:
def read(q):
    while True:
        if not q.empty():
            value = q.get(True)
            print 'Get %s from queue.' % value
            time.sleep(random.random())
        else:
            break

if __name__=='__main__':
    # 父进程创建Queue，并传给各个子进程：
    q = Queue()
    pw = Process(target=write, args=(q,))
    pr = Process(target=read, args=(q,))
    # 启动子进程pw，写入:
    pw.start()    
    # 等待pw结束:
    pw.join()
    # 启动子进程pr，读取:
    pr.start()
    pr.join()
    # pr进程里是死循环，无法等待其结束，只能强行终止:
    print ''
    print '所有数据都写入并且读完'

运行结果：

[图片上传失败…(image-c93ffd-1529046683003)]

3. 进程池中的Queue

如果要使用Pool创建进程，就需要使用multiprocessing.Manager()中的Queue()，而不是multiprocessing.Queue()，否则会得到一条如下的错误信息：

RuntimeError: Queue objects should only be shared between processes through inheritance.

下面的实例演示了进程池中的进程如何通信：


#coding=utf-8

#修改import中的Queue为Manager
from multiprocessing import Manager,Pool
import os,time,random

def reader(q):
    print("reader启动(%s),父进程为(%s)"%(os.getpid(),os.getppid()))
    for i in range(q.qsize()):
        print("reader从Queue获取到消息：%s"%q.get(True))

def writer(q):
    print("writer启动(%s),父进程为(%s)"%(os.getpid(),os.getppid()))
    for i in "dongGe":
        q.put(i)

if __name__=="__main__":
    print("(%s) start"%os.getpid())
    q=Manager().Queue() #使用Manager中的Queue来初始化
    po=Pool()
    #使用阻塞模式创建进程，这样就不需要在reader中使用死循环了，可以让writer完全执行完成后，再用reader去读取
    po.apply(writer,(q,))
    po.apply(reader,(q,))
    po.close()
    po.join()
    print("(%s) End"%os.getpid())

运行结果:


(21156) start
writer启动(21162),父进程为(21156)
reader启动(21162),父进程为(21156)
reader从Queue获取到消息：d
reader从Queue获取到消息：o
reader从Queue获取到消息：n
reader从Queue获取到消息：g
reader从Queue获取到消息：G
reader从Queue获取到消息：e
(21156) End

1. 安装引入模块

2. 使用

1. 外键

数据备份

数据恢复

1. 增

2. 删

3. 改

4. 查

4.1 聚合

4.2 分组

4.3 排序 select * from 表 order by 列1 asc|desc,列2 asc|desc,...

4.4 分页

1. 数据库命令行学习

2. 表 命令行学习

多线程-threading

1. 使用threading模块

单线程执行

多线程执行

说明

2. 主线程会等待所有的子线程结束后才结束

3. 查看线程数量

1. 主进程向渲染进程发送指令

2. 渲染进程向主进程发送指令

multiprocessing.Pool常用函数解析：

进程间通信-Queue

1. Queue的使用

说明

2. Queue实例

3. 进程池中的Queue

4.3 排序 `select * from 表 order by 列1 asc|desc,列2 asc|desc,...`

2. 表命令行学习