#1. append 用于在列表末尾追加新的对象
a = [1,2,3]
a.append(4) #the result : [1, 2, 3, 4]
#2. count 方法统计某个元素在列表中出现的次数
a = ['aa','bb','cc','aa','aa']
print(a.count('aa')) #the result : 3
#3. extend 方法可以在列表的末尾一次性追加另一个序列中的多个值
a = [1,2,3]
b = [4,5,6]
a.extend(b) #the result :[1, 2, 3, 4, 5, 6]
#4. index 函数用于从列表中找出某个值第一个匹配项的索引位置
a = [1,2,3,1]
print(a.index(1)) #the result : 0
#5. insert 方法用于将对象插入到列表中
a = [1,2,3]
a.insert(0,'aa') #the result : ['aa', 1, 2, 3]
#6. pop 方法会移除列表中的一个元素(默认是最后一个),并且返回该元素的值
a = [1,2,3]
a.pop() #the result : [1, 2] a.pop(0)
#7. remove 方法用于移除列表中某个值的第一个匹配项
a = ['aa','bb','cc','aa']
a.remove('aa') #the result : ['bb', 'cc', 'aa']
#8. reverse 方法将列表中的元素反向存放
a = ['a','b','c']
a.reverse() #the result : ['c', 'b', 'a']
#9. sort 方法用于在原位置对列表进行排序,意味着改变原来的列表,让其中的元素按一定顺序排列
a = ['a','b','c',1,2,3]
a.sort() #the result :[1, 2, 3, 'a', 'b', 'c']
#10. enumrate
li = [11,22,33]
for k,v in enumerate(li, 1):
print(k,v)
#1. find 方法可以在一个较长的字符串中查找子串,他返回子串所在位置的最左端索引,如果没有找到则返回-1
a = 'abcdefghijk'
print(a.find('abc')) #the result : 0
print(a.find('abc',10,100)) #the result : 11 指定查找的起始和结束查找位置
#2. join 方法是非常重要的字符串方法,他是 split 方法的逆方法,用来连接序列中的元素,并且需要被连接的元素都 必须是字符串。
a = ['1','2','3']
print('+'.join(a)) #the result : 1+2+3
#3. split 方法,是一个非常重要的字符串,它是 join 的逆方法,用来将字符串分割成序列
print('1+2+3+4'.split('+')) #the result : ['1', '2', '3', '4']
#4. strip 方法返回去除首位空格(不包括内部)的字符串
print(" test test ".strip()) #the result :“test test”
#5. replace 方法返回某字符串所有匹配项均被替换之后得到字符串
print("This is a test".replace('is','is_test')) #the result : This_test is_test a test
#1. clear 方法清除字典中所有的项,这是一个原地操作,所以无返回值(或则说返回 None)
d = {'name':"tom"}
d.clear() print(d) #the result : {}
#2. fromkeys 方法使用给定的键建立新的字典,每个键都对应一个默认的值 None
print({}.fromkeys(['name','age'])) #the result : {'age': None, 'name': None}
#3. get 方法是个更宽松的访问字典项的方法,如果试图访问字典中不存在的项时不会报错仅会 返回:None
d = {'Tom':8777,'Jack':8888,'Fly':6666}
print(d.get('Tom')) #the result : 8777
print(d.get('not_exist')) #the result : None
#4. for 循环字典的三种方法
d = {'Tom':8777,'Jack':8888,'Fly':6666}
for k,v in d.items():
print(k,v)
for k in d.values():
print(k)
for k in d.keys():
print(k)
#5. pop 方法用于获得对应与给定键的值,然后将这个”键-值”对从字典中移除
d = {'Tom':8777,'Jack':8888,'Fly':6666}
v = d.pop('Tom')
print(v) #8777
#6. setdefault 方法在某种程度上类似于 get 方法,能够获得与给定键相关联的值,除此之外,setdefault 还能在字典 中不含有给定键的情况下设定相应的键值
d = {'Tom':8777,'Jack':8888,'Fly':6666}
d.setdefault('Tom') #the result : 8777
print(d.setdefault('Test')) #the result : None
print(d) #{'Fly': 6666, 'Jack': 8888, 'Tom': 8777, 'Test': None}
#7. update 方法可以利用一个字典项更新另一个字典,提供的字典中的项会被添加到旧的字典中,如有相同的键则会被 覆盖
d = {'Tom':8777,'Jack':8888,'Fly':6666}
a = {'Tom':110,'Test':119}
d.update(a) print(d) #the result :{'Fly': 6666, 'Test': 119, 'Jack': 8888, 'Tom': 110}
#8. 将两个列表组合成字典
keys = ['a', 'b']
values = [1, 2]
print(dict(zip(keys,values))) # {'a': 1, 'b': 2}
list_1 = [1,2,3,4,5,1,2]
#1、去重(去除 list_1 中重复元素 1,2)
list_1 = set(list_1) #去重: {1, 2, 3, 4, 5}
print(list_1)
list_2 = set([4,5,6,7,8])
#2、交集(在 list_1 和 list_2 中都有的元素 4,5)
print(list_1.intersection(list_2)) #交集: {4, 5}
#3、并集(在 list_1 和 list_2 中的元素全部打印出来,重复元素仅打印一次)
print(list_1.union(list_2)) #并集: {1, 2, 3, 4, 5, 6, 7, 8}
#4、差集
print(list_1.difference(list_2)) #差集:在 list_1 中有在 list_2 中没有: {1, 2, 3}
print(list_2.difference(list_1)) #差集:在 list_1 中有在 list_2 中没有: {8, 6, 7}
from multiprocessing import Process,Pool
import time,os
def foo(i):
time.sleep(2)
print("in the process",os.getpid()) #打印子进程的 pid
return i+100
def call(arg):
print('-->exec done:',arg,os.getpid())
if __name__ == '__main__':
pool = Pool(3) #进程池最多允许 5 个进程放入进程池
print("主进程 pid:",os.getpid()) #打印父进程的 pid
for i in range(10):
#用法 1 callback 作用是指定只有当 Foo 运行结束后就执行 callback 调用的函数,父进程调用的 callback 函数
pool.apply_async(func=foo, args=(i,),callback=call)
#用法 2 串行 启动进程不在用 Process 而是直接用
pool.apply() # pool.apply(func=foo, args=(i,))
print('end')
pool.close() #关闭
pool pool.join() #进程池中进程执行完毕后再关闭,如果注释,那么程序直接关闭。
import threading
import time
def sayhi(num): #定义每个线程要运行的函数
print("running on number:%s" %num)
time.sleep(3)
for i in range(50):
t = threading.Thread(target=sayhi,args=('t-%s'%i,))
t.start()
import threading
import time
start_time = time.time()
def sayhi(num): #定义每个线程要运行的函数
print("running on number:%s" %num)
time.sleep(3)
t_objs = []
#将进程实例对象存储在这个列表中
for i in range(50):
t = threading.Thread(target=sayhi,args=('t-%s'%i,))
t.start()
#启动一个线程,程序不会阻塞
t_objs.append(t)
print(threading.active_count())
#打印当前活跃进程数量
for t in t_objs: #利用 for 循环等待上面 50 个进程全部结束
t.join()
#阻塞某个程序
print(threading.current_thread())
#打印执行这个命令进程
print("----------------all threads has finished.....")
print(threading.active_count())
print('cost time:',time.time() - start_time)
import threading
import time
start_time = time.time()
def sayhi(num): #定义每个线程要运行的函数
print("running on number:%s" %num)time.sleep(3)
for i in range(50):
t = threading.Thread(target=sayhi,args=('t-%s'%i,))
t.setDaemon(True)
#把当前线程变成守护线程,必须在 t.start()前设置
t.start()
#启动一个线程,程序不会阻塞
print('cost time:',time.time() - start_time)
# 用户锁使用举例
import time
import threading
lock = threading.Lock()
#1 生成全局锁
def addNum():
global num
#2 在每个线程中都获取这个全局变量
print('--get num:',num )
time.sleep(1)
lock.acquire()
#3 修改数据前加锁
num
-= 1
#4 对此公共变量进行-1 操作
lock.release()
#5 修改后释放
import requests
from concurrent.futures import ThreadPoolExecutor
def fetch_request(url):
result = requests.get(url)
print(result.text)
url_list = [
'https://www.baidu.com',
'https://www.google.com/',
#google 页面会卡住,知道页面超时后这个进程才结束'http://dig.chouti.com/',
#chouti 页面内容会直接返回,不会等待 Google 页面的返回
]
pool = ThreadPoolExecutor(10)
# 创建一个线程池,最多开 10 个线程
for url in url_list:
pool.submit(fetch_request,url)
# 去线程池中获取一个线程,线程去执行 fetch_request 方法
pool.shutdown(True)
# 主线程自己关闭,让子线程自己拿任务执行
# 注:Gevent 只用起一个线程,当请求发出去后 gevent 就不管,永远就只有一个线程工作,谁先回来先处理
import gevent
import requests
from gevent import monkey
monkey.patch_all()
# 这些请求谁先回来就先处理谁
def fetch_async(method, url, req_kwargs):
response = requests.request(method=method, url=url, **req_kwargs)
print(response.url, response.content)# ##### 发送请求 #####
gevent.joinall([
gevent.spawn(fetch_async, method='get', url='https://www.python.org/', req_kwargs={}),
gevent.spawn(fetch_async, method='get', url='https://www.google.com/', req_kwargs={}),
gevent.spawn(fetch_async, method='get', url='https://github.com/', req_kwargs={}),
])
#! /usr/bin/env python
# -*- coding: utf-8 -*-
import time
def timer(func):
start_time = time.time()func()
print '函数执行时间为', time.time() - start_time
def test():
print '开始执行 test'
time.sleep(3)
print 'test 执行结束'
timer(test)
'''
开始执行 test
test 执行结束
函数执行时间为 3.00332999229
'''
import time
def timer(func):
#timer(test1) func=test1
def deco(*args,**kwargs):
start_time = time.time()
func(*args,**kwargs)
#run test1
stop_time = time.time()
print("running time is %s"%(stop_time-start_time))
return deco
@timer
# test1=timer(test1)
def test1():
time.sleep(3)
print("in the test1")
test1()
def fib(max_num):
a,b = 1,1
while a < max_num:
yield b
a,b=b,a+b
g = fib(10)
#生成一个生成器:[1,2, 3, 5, 8, 13]
print(g.__next__())
#第一次调用返回:1
print(list(g))
#把剩下元素变成列表:[2, 3, 5, 8, 13]
a = iter([1,2,])
#生成一个迭代器
print(a.__next__())
print(a.__next__())
print(a.__next__())
#在这一步会引发
“StopIteration” 的异常
class Dog(object):
def __init__(self,name):
self.name = name
@staticmethod
def eat():
print("I am a static method")
d = Dog("ChenRonghua")
d.eat()
#方法 1:使用实例调用Dog.eat()
#方法 2:使用类直接调用
class Dog(object):
name = '类变量' #在这里如果不定义类变量仅定义实例变量依然报错
def __init__(self,name):
self.name = '实例变量'
self.name = name
@classmethod
def eat(self,food):
print("%s is eating %s"%(self.name,food))
Dog.eat('baozi')
#方法 1:使用类直接调用
d = Dog("ChenRonghua")
d.eat("包子")
#方法 2:使用实例 d 调用
class Dog(object):
def __init__(self, name):
self.name = name
@property
def eat(self):
print(" %s is eating" % self.name)
d = Dog("ChenRonghua")
d.eat()
# 调用会出以下错误, 说 NoneType is not callable, 因为 eat 此时已经变成一个静态属性了,
# 不是方法了, 想调用已经不需要加()号了,直接 d.eat 就可以了
class Student(object):
def __new__(cls, *args, **kwargs):
print('__new__')
return object.__new__(cls)
# 必须返回父类的__new__方法,否则不不执行__init__方法,无法创建实例def __init__(self,name):
print('__init__')
self.name = name
def __str__(self):
# 作用:打印实例时显示指定字符串,而不是内存地址
print('__str__')
return self.name
def __call__(self, *args, **kwargs):
# 当执行 C()(*args) 或者 s1(*args) 就会执行__call__
print('__call__',*args)
def __del__(self):
# 作用:清除无用的实例对内存的暂用
print('__del__')
#1、实例化时机会执行__new__、__init__
s1 = Student('tom')
#2、执行 实例() 就会执行__call__ 方法,并将参数传递给__call__函数
s1('call01')
#3、当打印实例时就会执行 __str__ 方法下返回的字符串(默认返回的实例地址)
print(s1)
#4、析构方法:当删除实例时就会调用 __del__ 方法
del s1
# 析构方法作用:在程序结束后会自动执行析构方法删除所有实例
# 但是在程序运行时有很多实例是无用的,但是 python 内存回收机制却不会自动删除他们,这样就浪费内存
# 我们可以执行 del s1 ,那么在程序运行时,python 内存回收机制会检测到这些实例时无用的,才会删除
# 其实我们执行 del s1,并没有回收内存,只不过是摘除门牌号,python 内存回收机制发现没有门牌号后会自动回收内存
class Dog(object):
def eat(self,food):
print("eat method!!!")
d = Dog()
#hasattr 判断对象 d 是否有 eat 方法,有返回 True,没有返回 False
print(hasattr(d,'eat'))
#True
print(hasattr(d,'cat'))
#False
class Dog(object):
def eat(self):
print("eat method!!!")
d = Dog()if hasattr(d,'eat'):
# hasattr 判断实例是否有 eat 方法
func = getattr(d, 'eat')
# getattr 获取实例 d 的 eat 方法内存地址
func()
# 执行实例 d 的 eat 方法
#运行结果:
eat method!!!
import copy
sourceList = [1,2,3,[4,5,6]]
copyList = copy.copy(sourceList)
deepcopyList = copy.deepcopy(sourceList)
sourceList[3][0]=100
print(sourceList) # [1, 2, 3, [100, 5, 6]]
print(copyList) # [1, 2, 3, [100, 5, 6]]
print(deepcopyList) # [1, 2, 3, [4, 5, 6]]
with open('/etc/passwd') as f:
for line in f:print(line)
# 这段代码的作用:打开一个文件,如果一切正常,把文件对象赋值给 f,然后用迭代器遍历文件中每一行,当完成时,关闭文件;
# 而无论在这段代码的任何地方,如果发生异常,此时文件仍会被关闭。
f = lambda x,y,z:x+y+z
print(f(1,2,3))
# 6
my_lambda = lambda arg : arg + 1
print(my_lambda(10))
# 11
name = 'Tom' if 1 == 1 else 'fly'
print(name)
# 运行结果: Tom
f = lambda x:x if x % 2 != 0 else x + 100
print(f(10))
# 110
l1= [11,22,33,44,55]
a = filter(lambda x: x<33, l1)
print(list(a))
# 利用 map,lambda 表达式将所有偶数元素加 100
l1= [11,22,33,44,55]
ret = map(lambda x:x if x % 2 != 0 else x + 100,l1)
print(list(ret))
# 运行结果: [11, 122, 33, 144, 55]
from functools import reduce
def f(x, y):
return x + y
print(reduce(f, [1, 3, 5, 7, 9])) # 25
# 1、先计算头两个元素:f(1, 3),结果为 4;
# 2、再把结果和第 3 个元素计算:f(4, 5),结果为 9;
# 3、再把结果和第 4 个元素计算:f(9, 7),结果为 16;
# 4、再把结果和第 5 个元素计算:f(16, 9),结果为 25;
# 5、由于没有更多的元素了,计算结束,返回结果 25。
print( reduce(lambda x, y: x + y, [1, 3, 5, 7, 9])
)
# 25
d = {'k1':1, 'k3': 3, 'k2':2}
# d.items() = [('k1', 1), ('k3', 3), ('k2', 2)]
a = sorted(d.items(), key=lambda x: x[1])
print(a)
# [('k1', 1), ('k2', 2), ('k3', 3)]
#### 乐观锁实现加一操作代码
# 我们可以看到,只有当对数量-1 操作时才会加锁,只有当程序中值和数据库中的值相等时才正真执行。
'''
//不加锁
select id,name,stock where id=1;
//业务处理
begin;
update shop set stock=stock-1 where id=1 and stock=stock;
commit;
'''
#### 悲观锁实现加一操作代码
# 我们可以看到,首先通过 begin 开启一个事物,在获得 shop 信息和修改数据的整个过程中都对数据加锁,
保证了数据的一致性。
'''
begin;
select id,name,stock as old_stock from shop
where id=1 for update;
update shop set stock=stock-1 where id=1 and stock=old_stock;
commit
'''
'''模拟查找关键字 29 的过程:'''
# 根据根节点找到磁盘块 1,读入内存。【磁盘 I/O 操作第 1 次】
# 比较关键字 29 在区间(17,35),找到磁盘块 1 的指针 P2。
# 根据 P2 指针找到磁盘块 3,读入内存。【磁盘 I/O 操作第 2 次】
# 比较关键字 29 在区间(26,30),找到磁盘块 3 的指针 P2。
# 根据 P2 指针找到磁盘块 8,读入内存。【磁盘 I/O 操作第 3 次】
# 在磁盘块 8 中的关键字列表中找到关键字 29。
slow_query_log 的值来开启,如下所示:
show variables like '%slow_query_log%';
+----------------------+-----------------------------------------------+
| Variable_name | Value
|
+----------------------+-----------------------------------------------+
| slow_query_log | OFF
|
| slow_query_log_file | /home/WDPM/MysqlData/mysql/DB-Server-slow.log |
+----------------------+------------------------------------------------+
2 rows in set (0.00 sec)
set global slow_query_log=1;
slow_query_log = 1
slow_query_log_file = /tmp/mysql_slow.log
show variables like 'slow_query_log_file';
+---------------------+-----------------------------------------------+
| Variable_name
| Value
|
+---------------------+-----------------------------------------------+
| slow_query_log_file | /home/WDPM/MysqlData/mysql/DB-Server-slow.log |
+---------------------+-----------------------------------------------+
1 row in set (0.00 sec)
long_query_time 的值为 10 秒,可以使用命令修改,也可以在 my.cnf 参数里面修改。
show variables like 'long_query_time%';
# 查看当前 long_query_time 时间
+-----------------+-----------+
| Variable_name | Value
|
+-----------------+-----------+
| long_query_time | 10.000000 |
+-----------------+-----------+
set global long_query_time=4;
# 设置当前 long_query_time 时间
show variables like 'long_query_time';
# 再次查看 long_query_time 时间
show variables like '%log_output%';
+---------------+-------+
| Variable_name | Value |
+---------------+-------+
| log_output
| FILE |
+---------------+-------+
set global log_output='TABLE';
show variables like '%log_output%';
+---------------+-------+
| Variable_name | Value |
+---------------+-------+
| log_output
| TABLE |
+---------------+-------+
select sleep(5) ;
+----------+
| sleep(5) |
+----------+
|
0 |
+----------+
mysql> select * from mysql.slow_log;
+---------------------+---------------------------+------------+-----------+-----------+---------------+----+----------------+--------
---+-----------+-----------------+-----------+
| start_time
| user_host
| query_time | lock_time | rows_sent | rows_examined | db | last_insert_id | insert_id |
server_id | sql_text
| thread_id |
+---------------------+---------------------------+------------+-----------+-----------+---------------+----+----------------+--------
---+-----------+-----------------+-----------+
| 2016-06-16 17:37:53 | root[root] @ localhost [] | 00:00:03 | 00:00:00 |1 |0 ||0 |0 |1 |
select sleep(3) |5 |
| 2016-06-16 21:45:23 | root[root] @ localhost [] | 00:00:05 | 00:00:00 |1 |0 ||0 |0 |1 |
select sleep(5) |2 |
+---------------------+---------------------------+------------+-----------+-----------+---------------+----+----------------+--------
---+-----------+-----------------+-----------+
set global log_queries_not_using_indexes=1;
# 开启该选项
mysql> show global status like '%Slow_queries%';
+---------------+-------+
| Variable_name | Value |
+---------------+-------+
| Slow_queries | 2104 |
+---------------+-------+
1 row in set (0.00 sec)
[root@MySQL-01 ~]# wget http://www.percona.com/get/percona-toolkit.tar.gz
[root@MySQL-01 ~]# yum install perl perl-devel perl-Time-HiRes perl-DBI perl-DBD-MySQL
perl-Compress-Raw-Bzip2
perl-Compress-Raw-Zlib
perl-Digest
perl-Digest-MD5
perl-IO-Compress
perl-IO-Socket-IP
perl-IO-Socket-SSL
perl-Mozilla-CA
perl-Net-Daemon
perl-Net-LibIDN
perl-Net-SSLeay
...
[root@MySQL-01 ~]# tar zxf percona-toolkit-2.2.13.tar.gz
[root@MySQL-01 ~]# cd percona-toolkit-2.2.13
[root@MySQL-01 ~]# perl Makefile.PL
[root@MySQL-01 ~]# make && make install
root@node1 12:28: [pt_check]> GRANT CREATE,INSERT,SELECT,DELETE,UPDATE,LOCK
TABLES,PROCESS,SUPER,REPLICATION SLAVE ON *.* TO 'root'@'47.97.218.145' IDENTIFIED BY
'123456';
Query OK, 0 rows affected (0.00 sec)
root@node1 12:29: [pt_check]> flush privileges;
Query OK, 0 rows affected (0.00 sec)
root@node1 12:29: [pt_check]> select Host,User from mysql.user;+----------------+---------------+
| Host| User|
+---------------------+--------------------+
| localhost| root|
| localhost| mysql.session |
| localhost| mysql.sys|
| 172.16.156.%| rep|
| %| java|
| 192.168.1.101| ptuser|
+----------------------+---------------------+
MariaDB [(none)]> GRANT SELECT, PROCESS, SUPER, REPLICATION SLAVE ON *.* TO
'root'@'9.106.84.122' IDENTIFIED BY '123456';
Query OK, 0 rows affected (0.00 sec)
MariaDB [(none)]> flush privileges;
Query OK, 0 rows affected (0.00 sec)
# 现在有一主库,数据如下:
mysql> select * from yayun.t1;
+----+-------+
| id | name |
+----+-------+
| 1 | yayun|
| 2 | atlas |
| 3 | mysql |
+----+-------+
3 rows in set (0.00 sec)
# 主库有三条数据
mysql> select * from yayun.t1;
+----+----------+
| id | name |
+----+----------+
| 1 | yayun |
| 2 | atlas |
| 3 | mysql |
| 4 | dengyy |
| 5 | love sql |
+----+----------+
5 rows in set (0.00 sec)
# 从库有五条数据,多了俩条不一样的:4、5
[root@MySQL-01 ~]# pt-table-checksum --nocheck-binlog-format
--nocheck-replication-filters --replicate=pt.checksums --databases test -u'root' -p'123456'
-h127.0.0.1 -P3306
TS ERRORS DIFFS ROWS CHUNKS SKIPPED TIME TABLE
04-13T15:59:31 0 1 3 1 0 0.080 yayun.t1
TS # 完成检查的时间
ERRORS # 检查时候发生错误和警告的数量
DIFFS # 0 表示一致,1 表示不一致
ROWS # 表的行数
CHUNKS # 被划分到表中的块的数目
SKIPPED # 由于错误或警告或过大,则跳过块的数目
TIME # 执行的时间
TABLE # 被检查的表名
--nocheck-replication-filters: # 不检查复制过滤器,建议启用。后面可以用--databases 来指定需要检查的数据库。
--no-check-binlog-format:# 不检查复制的 binlog 模式,要是 binlog 模式是 ROW,则会报错。
--replicate-check-only :# 只显示不同步的信息。
--replicate=:# 把 checksum 的信息写入到指定表中,建议直接写到被检查的数据库当中。
--databases=:# 指定需要被检查的数据库,多个则用逗号隔开。
--tables=:# 指定需要被检查的表,多个用逗号隔开
h=127.0.0.1:# Master 的地址
u=root:# 用户名
p=123456:# 密码
P=3306:# 端口
mysql> select * from checksums\G
*************************** 1. row ***************************
db: yayun
tbl: t1
chunk: 1
chunk_time: 0.010735
chunk_index: NULL
lower_boundary: NULL
upper_boundary: NULL
this_crc: babf1dc0#slave
this_cnt: 5#slave
master_crc: 8727436a#master
master_cnt: 3#master
# 可以发现表 t1 中从库比主库多 2 条记录
ts: 2014-04-13 16:05:16
1 row in set (0.00 sec)
[root@MySQL-01 ~]# pt-table-sync --replicate=pt.checksums
h=47.97.218.145,u=root,p=123456 h=39.106.84.122,u=root,p=123456 --print
DELETE FROM `yayun`.`t1` WHERE `id`='4' LIMIT 1 /*percona-toolkit src_db:yayun src_tbl:t1
src_dsn:h=127.0.0.1,p=...,u=root dst_db:yayun dst_tbl:t1 dst_dsn:h=192.168.0.20,p=...,u=root
lock:1 transaction:1 changing_src:yayun.checksums replicate:yayun.checksums bidirectional:0
pid:2190 user:root host:MySQL-01*/;
DELETE FROM `yayun`.`t1` WHERE `id`='5' LIMIT 1 /*percona-toolkit src_db:yayun src_tbl:t1
src_dsn:h=127.0.0.1,p=...,u=root dst_db:yayun dst_tbl:t1 dst_dsn:h=192.168.0.20,p=...,u=root
lock:1 transaction:1 changing_src:yayun.checksums replicate:yayun.checksums bidirectional:0
pid:2190 user:root host:MySQL-01*/;
--replicate= : # 指定通过 pt-table-checksum 得到的表,这 2 个工具差不多都会一直用。
--databases= : # 指定执行同步的数据库,多个用逗号隔开。
--tables= :# 指定执行同步的表,多个用逗号隔开。
--sync-to-master :# 指定一个 DSN,即从的 IP,他会通过 show processlist 或 show slave status 去
自动的找主。
h=127.0.0.1:# 服务器地址,命令里有 2 个 ip,第一次出现的是 Master 的地址,第 2 次是 Slave 的地址。
u=root:# 帐号。
p=123456:# 密码。
--print:# 打印,但不执行命令。
--execute:# 执行命令。
[root@MySQL-01 ~]# pt-table-sync --replicate=pt.checksums
h=47.97.218.145,u=root,p=123456
h=39.106.84.122,u=root,p=123456 --execute
[root@MySQL-01 ~]# pt-table-checksum --nocheck-binlog-format --nocheck-plan
--nocheck-replication-filters --replicate=pt.checksums --set-vars
innodb_lock_wait_timeout=120 --databases test -u'root' -p'123456' -h47.97.218.145 -P3306
TS ERRORS DIFFS ROWS CHUNKS SKIPPED TIME TABLE
04-13T16:27:28 0 0 3 1 0 0.097 yayun.t1
# 主库
mysql> select * from t1;
+----+-------+
| id | name |
+----+-------+
| 1 | yayun |
| 2 | atlas |
| 3 | mysql |
+----+-------+
3 rows in set (0.00 sec)
mysql>
# 从库会丢失掉之前多余的两条数据
mysql> select * from t1;
+----+-------+
| id | name |
+----+-------+
| 1 | yayun |
| 2 | atlas |
| 3 | mysql |
+----+-------+
3 rows in set (0.00 sec)
Can't make changes on the master because no unique index exists at
/usr/local/bin/pt-table-sync line 10591.
docker pull mysql:5.7
docker run -p 3339:3306 --name mymysql –e MYSQL_ROOT_PASSWORD=123456 -d
mysql:5.7 # 主
docker run -p 3340:3306 --name mymysql -e MYSQL_ROOT_PASSWORD=123456 -d mysql:5.7
# 从
docker exec -it 627a2368c865 /bin/bash # 进入容器,627a2368c865 是容器的 id,而
mysql-master 是容器的名称
apt-get update
apt-get install vim # 在容器中手动安装 vim
[mysqld]
server-id = 100
log-bin = mysql-bin
service mysql restart # 重启 mysql
docker start mysql-master # 启动容器
CREATE USER 'slave'@'%' IDENTIFIED BY '123456' # 创建用户
GRANT REPLICATION SLAVE, REPLICATION CLIENT ON *.* TO 'slave'@'%' # 设置权限
[mysqld]
server-id = 101
service mysql restart # 重启 mysql
docker start mysql-master # 启动容器
change master to master_host='172.17.0.2', master_user='slave',
master_password='123456', master_port=3306, master_log_file='mysql-bin.000001',
master_log_pos= 254, master_connect_retry=30;
> multi(开始一个 redis 事物)
incr books
incr books
> exec (执行事物)
> discard (丢弃事物)
> setnx lock:codehole true
.... do something critical ....
> del lock:codehole
> expire lock:codehole 5
.... do something critical ....
> del lock:codehole
> set lock:codehole true ex 5 nx
''' do something '''
> del lock:codehole
# sentinel.conf 配置说明
sentinel monitor mymaster 127.0.0.1 6379 2
sentinel down-after-milliseconds mymaster 60000
sentinel failover-timeout mymaster 180000
sentinel parallel-syncs mymaster 1
l = list(range(1,101))
def bin_search(data_set,val):
low = 0
high = len(data_set) - 1
while low <= high:
mid = (low+high)//2
if data_set[mid] == val:
return mid
elif data_set[mid] < val:
low = mid + 1
else:
high = mid - 1
return
n = bin_search(l,11)
print(n) # 返回结果是: 10
#! /usr/bin/env pythonf
# -*- coding: utf-8 -*-
def bubble_sort(li):
for i in range(len(li)-1):
for j in range(len(li)-i-1):
if li[j] > li[j+1]:
li[j],li[j+1]=li[j+1],li[j]
li = [1,5,2,6,3,7,4,8,9,0]
bubble_sort(li)
print(li) # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
#! /usr/bin/env python
# -*- coding: utf-8 -*-
def quick(list):
if len(list) < 2:
return list
tmp = list[0] # 临时变量 可以取随机值
left = [x for x in list[1:] if x <= tmp] # 左列表
right = [x for x in list[1:] if x > tmp] # 右列表
return quick(left) + [tmp] + quick(right)
li = [4,3,7,5,8,2]
print quick(li) # [2, 3, 4, 5, 7, 8]
#### 对[4,3,7,5,8,2]排序
'''
[3, 2] + [4] + [7, 5, 8] # tmp = [4]
[2] + [3] + [4] + [7, 5, 8] # tmp = [3] 此时对[3, 2]这个列表进行排序
[2] + [3] + [4] + [5] + [7] + [8] # tmp = [7] 此时对[7, 5, 8]这个列表进行排序 '''
# 注:快排代码实现(类似于二叉树 递归调用)----右手左手一个慢动作,右手左手一个慢动作重播
def fun(i):
if i == 0:
return 0
elif i == 1:
return 1
else:
return fun(i-2) + fei(i-1)
if __name__ == '__main__':
for i in range(10):
print(fun(i),end=" ")
# 一只青蛙一次可以跳上 1 级台阶,也可以跳上 2 级……它也可以跳上 n 级。求该青蛙跳上一个 n 级的台阶
总共有多少种跳法。
fib = lambda n: n if n < 2 else 2 * fib(n - 1)
# 编辑进程管理配置文件
[root@sandboxmp ~]$ touch /etc/supervisord.d/celery_worker.ini
[root@sandboxmp ~]$ vim /etc/supervisord.d/celery_worker.ini
# 将以下内容写入配置文件保存并退出
[program:celery-worker]
command=/root/.virtualenvs/sandboxMP/bin/celery worker -A sandboxMP -l INFO
directory=/opt/app/sandboxMP
environment=PATH="/root/.virtualenvs/sandboxMP/bin/"
stdout_logfile=/opt/app/sandboxMP/slogs/celery_worker.log
stderr_logfile=/opt/app/sandboxMP/slogs/celery_worker.log
autostart=true
autorestart=true
priority=901
[program:celery-flower]
command=/root/.virtualenvs/sandboxMP/bin/celery flower --broker=redis://localhost:6379/0
directory=/opt/app/sandboxMP
environment=PATH="/root/.virtualenvs/sandboxMP/bin/"
stdout_logfile=/opt/app/sandboxMP/slogs/celery_flower.log
stderr_logfile=/opt/app/sandboxMP/slogs/celery_flower.logautostart=true
autorestart=true
priority=900
systemctl start supervisord # 启动 supervisord
systemctl enable supervisord # 加到开机启动
1、系统命令 runlevel # 查看当前的运行级别
systemctl status firewalld # 开启网络服务功能
stop # 关闭
restart # 重启
reload # 重载
reboot # 重启
halt # 关机
poweroff # 关机
2、查看文件常用指令
cat # 在命令提示符下查看文件内容
more # 在命令提示符中分页查看文件内容
less # 命令行中查看文件可以上下翻页反复浏览
head # 命令行中查看文件头几行
tail # 命令行中查看文件尾几行
wc # 统计文件的单词数 行数等信息
3、目录管理常用指令
pwd # 查看你当前所在的目录
cd # 切换目录
ls # 查看显示目录的内容
du # 统计目录和文件空间的占用情况
mkdir # 创建新目录
rmdir # 删除空目录
touch # 创建文件
rm # 删除文件
ln # 创建硬链接
ln -s # 创建软链接
cp # 复制文件或目录
mv # 移动文件或目录
which # 查看 linux 命令所在的目录 复制代码
4、账号与权限
'''1.组管理'''
groupadd group_name # 创建一个新用户组
groupdel group_name # 删除一个用户组
groupmod -n new_group_name old_group_name # 重命名一个用户组
'''2.用户管理'''
useradd zhangsan # 创建账户张三
passwd zhangsan # 给用户设置密码
userdel -r zhangsan # 删除张三及他的宿主目录
'''3.用户组管理'''
gpasswd -a zhangsan root # 将张三用户加入 root 组
groups zhangsan # 确认 zhangsan 用户在 root 组
gpasswd -d lisi root # 将李 zhangsan 户从 root 组中删除
'''4.权限管理'''
chown -R zhangsan /aaa # 将文件夹/aaa 的多有者修改为 zhangsan
chown root:root /aaa # 将/aaa 文件夹的属主和属组都改成 root
chmod 777 /aaa # 给文件夹文件/aaa 设置权限为 777