风之小云天
When your dreams come alive you're unstoppable
Python 高级编程笔记
模块间循环导入，A导入B，B导入A
is 和 == 区别
is比较内存地址，== 比较值
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21In [34]: a=1
In [35]: b=1
In [36]: a==b
Out[36]: True
In [37]: a is b
Out[37]: True
In [38]: list = [1,2,3]
In [39]: list2 = [1,2,3]
In [40]: list is list2
Out[40]: False
In [41]: list==list2
Out[41]: True
In [42]: id(list)
Out[42]: 140116611518152
In [43]: id(list2)
Out[43]: 140116636517064深拷贝、浅拷贝
浅拷贝内存共享，变量修改后浅拷贝的变量都跟着改变，深拷贝会新建内存区把数据复制进去，和原来变量是独立的
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30In [10]: a = [1,2,3]
In [11]: b= a
In [12]: id(a)
Out[12]: 139967263031624
In [13]: id(b)
Out[13]: 139967263031624 浅拷贝内存地址相同
In [14]: import copy
In [15]: c = copy.deepcopy(a)
In [16]: id(a)
Out[16]: 139967263031624
In [17]: id(c)
Out[17]: 139967348141896 深拷贝内存地址不同
In [18]: a.append(4)
In [19]: a
Out[19]: [1, 2, 3, 4]
In [20]: c
Out[20]: [1, 2, 3] 深拷贝的值未变，因为在新的内存区
In [21]: b
Out[21]: [1, 2, 3, 4]深拷贝时候，如果遇到内存地址，会进行递归拷贝。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35In [23]: a = [1,2,3]
In [24]: b = [4,5,6]
In [25]: c = [a,b] c里面存储a、b的引用
In [26]: d=c
In [27]: id(c)
Out[27]: 139967287746376
In [28]: id(d)
Out[28]: 139967287746376
In [29]: e = copy.deepcopy(c) e 进行深拷贝
In [30]: id(e)
Out[30]: 139967264133832
In [31]: e
Out[31]: [[1, 2, 3], [4, 5, 6]]
In [32]: e[0]
Out[32]: [1, 2, 3]
In [33]: a.append(5)
In [34]: c
Out[34]: [[1, 2, 3, 5], [4, 5, 6]]
In [35]: d
Out[35]: [[1, 2, 3, 5], [4, 5, 6]]
In [36]: e
Out[36]: [[1, 2, 3], [4, 5, 6]]copy.copy 只复制第一层，不会递归复制数据
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21In [30]: a = [1,2,3]
In [31]: b = [4,5,6]
In [32]: c= [a,b]
In [33]: e = copy.copy(c)
In [34]: a.append(7)
In [35]: c
Out[35]: [[1, 2, 3, 7], [4, 5, 6]]
In [36]: e
Out[36]: [[1, 2, 3, 7], [4, 5, 6]]
In [37]: id(c)
Out[37]: 140219958952584
In [38]: id(e)
Out[38]: 140219974150984copy.copy 复制不可变类型时候，直接是浅拷贝，将对应内存地址赋值过去，不会进行递归复制数据。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17In [2]: a = [1,2,3]
In [3]: b= [4,5,6]
In [4]: c = [a,b]
In [5]: import copy
In [6]: c = (a,b)
In [7]: e = copy.copy(c)
In [8]: id(c)
Out[8]: 140327472307016
In [9]: id(e)
Out[9]: 140327472307016
原码、反码、补码
正数： 原码 = 反码 = 补码
负数: 反码 = 符号位不变，其他位数取反
补码 = 反码 +1
进制转换
1
2
3
4
5
6
7
8
9
10In [28]: bin(10)
Out[28]: '0b1010'
In [29]: oct(10)
Out[29]: '0o12'
In [30]: hex(10)
Out[30]: '0xa'
In [32]: int('100',2)
Out[32]: 4位运算
& 按位与
| 按位或
^ 按位异或 不相同为1 ，相同为 0
~ 按位取反
<< 按位左移 >> 按位右移
用途: 直接操作二进制数据，省内存，效率高
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18In [38]: 1<<10
Out[38]: 1024
In [39]: 512>>6
Out[39]: 8
In [40]: 100&99
Out[40]: 96
In [41]: 0b1010101 & 0b0101101
Out[41]: 5
In [42]: 0b1011101 | 0b0101100
Out[42]: 125
In [44]: 0b1011101 ^ 0b0101100
Out[44]: 113
In [49]: ~0b10101010111
Out[49]: -1368
私有化
1
2
3
4
5
6
7
8xx: 共有变量
_x: 单前置下划线，私有化属性或方法，from somemodule import * 禁止导入，类对象和子类可以访问。
__xx: 双前置下划线，避免与子类中的属性命名冲突，无法在外部直接访问（名字重整所以访问不到）
__xx__: 双前后下划线，用户名字空间的魔法对象或属性。例如: __init__ ,__不要自己发明这样的名字
xx_: 单后置下划线，用于避免与Python关键词的冲突 通过 name mangling （名字重整(目的就是防止子类意外重写基类的方法或属性) 如：_Class__object 机制就可以访问 private 了。
私有属性添加 getter setter 方法
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25In [9]: class Money(object):
...: def __int__(self):
...: self.__money = 0
...: def getMoney(self):
...: return self.__money
...: def setMoney(self,value):
...: if isinstance(value,int):
...: self.__money = value
...: else:
...: print("error: 不是整型数字")
...:
In [12]: m = Money()
In [13]: m.setMoney(100)
In [14]: m.getMoney()
Out[14]: 100
In [15]: m.__money
---------------------------------------------------------------------------
AttributeError Traceback (most recent call last)
<ipython-input-15-9159f1107225> in <module>
----> 1 m.__money
AttributeError: 'Money' object has no attribute '__money'
property 属性
property 属性可以用来给属性添加约束，比如温度属性，我们不允许低于 - 273 度；成绩属性，我们不允许 0 分以下等等。而且使用 property 属性，将来修改约束条件的时候也很方便，可以在代码的调用方式不变的情况下改变结果。
python 中使用 property 属性有两种方法。使用 @property 装饰器和使用 property () 函数
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59In [25]: class Employee(object):
...: def __init__(self,salary):
...: self._salary = salary
...: def get_score(self):
...: print("getting score")
...: return self._salary
...: def set_score(self,salary):
...: print("setting score")
...: if not isinstance(salary,int):
...: raise ValueError("not a int value")
...: if salary<0 or salary>100000:
...: raise ValueError("salary value error")
...: self._salary= salary
...: def del_score(self):
...: print("deleting salary")
...: del self._score
...: salary = property(get_score,set_score,del_score,"-- salary --")
...:
In [26]: e = Employee(100)
In [27]: e.score
---------------------------------------------------------------------------
AttributeError Traceback (most recent call last)
<ipython-input-27-2630057808b6> in <module>
----> 1 e.score
AttributeError: 'Employee' object has no attribute 'score'
getting score
In [28]: e.salary
getting score
Out[28]: 100
getting score
In [29]: e.salary = 10099
setting score
getting score
In [30]: e.salary
getting score
Out[30]: 10099
getting score
In [31]: del e.salary
deleting salary
---------------------------------------------------------------------------
AttributeError Traceback (most recent call last)
<ipython-input-31-584b1f8ddf2c> in <module>
----> 1 del e.salary
<ipython-input-25-1d9e8b7ec464> in del_score(self)
14 def del_score(self):
15 print("deleting salary")
---> 16 del self._score
17 salary = property(get_score,set_score,del_score,"-- salary --")
18
AttributeError: _score@property 装饰器方式实现
python 源码中的介绍如下
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25property(fget=None, fset=None, fdel=None, doc=None) -> property attribute
fget is a function to be used for getting an attribute value, and likewise
fset is a function for setting, and fdel a function for del'ing, an
attribute. Typical use is to define a managed attribute x:
class C(object):
def getx(self): return self._x
def setx(self, value): self._x = value
def delx(self): del self._x
x = property(getx, setx, delx, "I'm the 'x' property.")
Decorators make defining new properties or modifying existing ones easy:
class C(object):
@property
def x(self):
"I am the 'x' property."
return self._x
@x.setter
def x(self, value):
self._x = value
@x.deleter
def x(self):
del self._x用 property、@num.setter 实现
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23In [38]: class Student(object):
...: def __init__(self):
...: self.__num = 100
...: @property
...: def num(self):
...: print("----getter-----")
...: return self.__num
...: @num.setter
...: def num(self,newNum):
...: print('----setter----')
...: self.__num = newNum
...:
In [39]:
In [39]: t = Test()
In [40]: t.num
-----getter---
Out[40]: 100
In [41]: t.num = 123
-----setter----
迭代器
可迭代对象
以直接作用于 for 循环的数据类型有以下几种:
- 集合数据类型：list 、tuple、dict、set、str 等
- generator，报考生成器 和带yield 的generator function
这些可以直接作用于 for 循环的对象统称为可迭代对象: Iterable
判断是否可迭代
用 isinstance() 判断是否是 Iterable 对象
- 凡是可作用于 for 循环的对象都是 Iterable 类型；
- 凡是可作用于 next() 函数的对象都是 Iterator 类型
- 集合数据类型如 list 、 dict 、 str 等是 Iterable 但不是 Iterator ，不过可以通过 iter() 函数获得一个 Iterator 对象。
迭代器 Iterator
可以被next()函数调用并不断返回下一个值的对象称为迭代器：Iterator。
可以使用 isinstance() 判断一个对象是否是 Iterator 对象：
闭包 外部函数的返回值是内部函数的引用
1
2
3
4
5
6
7
8def line_conf(a,b):
def line(x):
return a*x + b
return line
line1 = line_conf(1,1)
line2 = line_conf(4,5)
print(line1(5))
print(line2(5))
- 装饰器
slots
动态语言：可以在运行的过程中，修改代码
静态语言：编译时已经确定好代码，运行过程中不能修改
如果我们想要限制实例的属性怎么办？比如，只允许对Person实例添加name和age属性。
为了达到限制的目的，Python允许在定义class的时候，定义一个特殊的slots变量，来限制该class实例能添加的属性：
1
2
3
4
5
6
7
8
9
10
11class Person(object):
__slots__ = ("name", "age")
P = Person()
P.name = "老王"
P.age = 20
P.score = 100
Traceback (most recent call last):
File "<pyshell#3>", line 1, in <module>
AttributeError: Person instance has no attribute 'score'
>>>注意:
- 使用slots要注意，slots定义的属性仅对当前类实例起作用，对继承的子类是不起作用的
1
2
3
4
5
6
7In [67]: class Test(Person):
...: pass
...:
In [68]: t = Test()
In [69]: t.score = 100
循环队列 Java实现
一般的队列通常用数组实现，队头出队，队尾入队，入队在数组头部插入元素，然后把头部空出来插进去，头部以后的元素都需要向后移动，时间复杂度是O(n),出队删除队尾部元素，时间复杂度是O(1)。
循环队列其实是在普通队列基础上加了指向头部和尾部的指针，入队时候，尾指针+1，因为可能出现头部以前有空位，需要对队列的长度求余，即tail=(tail+1)/array.length,队列长度+1， 出队时候,头指针向后移动一个位置，同理，头指针也需要对队列长度求余，即front=(front+1)/array.length,队列长度-1，为了节省空间，一般会对循环队列的数组进行动态扩容和缩容，其实就是新建个数组，把原来数组的引用指向新的数组就好了，具体实现如下。
队列的抽象定义
1 | public interface Queue<E> { |
循环队列实现队列的接口的方式实现循环队列
1 | public class LoopQueue<E> implements Queue<E> { |
测试下结果
1 | LoopQueue : size = 1 , capacity = 10 |
linux基础
linux 文件系统 与 常用命令
•Filesystem Hierarchy Standard（文件系统层次化标准）
–/boot: 系统启动相关的文件，如内核、initrd，以及grub(bootloader)
–/dev: 设备文件
–/etc：配置文件
–/home：用户的家目录，每一个用户的家目录通常默认为/home/USERNAME
–/root：管理员的家目录；
–/lib：库文件
–/media：挂载点目录，移动设备
–/mnt：挂载点目录，额外的临时文件系统
–/opt：可选目录，第三方程序的安装目录
–/proc：伪文件系统，内核映射文件
–/sys：伪文件系统，跟硬件设备相关的属性映射文件
–/tmp：临时文件, /var/tmp
–/var：可变化的文件
–/bin: 可执行文件, 用户命令
–/sbin：管理命令
Linux中swap与memory介绍
1. 背景介绍
这篇文章介绍一下 Linux 中 swap 与 memory。memory 就是机器的物理内存ram，读写速度低于 cpu 一个量级，但是高于磁盘不止一个量级。所以，程序和数据如果在内存的话，会有非常快的读写速度。但是，内存的造价是要高于磁盘的，虽然相对来说价格一直在降低。除此之外，内存的断电丢失数据也是一个原因，因此不能把所有数据和程序都保存在内存中。既然不能全部使用内存，那数据还有程序肯定不可能一直霸占在内存中。当内存没有可用的，就必须要把内存中不经常运行的程序给踢出去。但是踢到哪里去，这时候 swap 就出现了。swap 全称为 swap place，即交换区，当内存不够的时候，被踢出的进程数据被暂时存储到交换区。当需要这条被踢出的进程的时候，就从交换区重新加载到内存，否则它不会主动交换到真实内存中。
more >>Redis基础
Redis 简介
Redis 是一个高性能的key-value形式的内存数据库
Redis 支持数据的持久化，可以将内存中的数据保持在磁盘中，重启的时候可以再次加载进行使用。
Redis 不仅仅支持简单的 key-value 类型的数据，同时还提供 list，set，zset，hash 等数据结构的存储。
Redis 支持数据的备份，即 master-slave 模式的数据备份。
Redis 优势
性能极高 – Redis 能读的速度是 110000 次 /s, 写的速度是 81000 次 /s 。
丰富的数据类型 – Redis 支持二进制案例的 Strings, Lists, Hashes, Sets 及 Ordered Sets 数据类型操作。
原子 – Redis 的所有操作都是原子性的，同时 Redis 还支持对几个操作全并后的原子性执行。
丰富的特性 – Redis 还支持 publish/subscribe, 通知，key 过期等等特性。
Redis 与其他 key-value 存储有什么不同？
Redis 有着更为复杂的数据结构并且提供对他们的原子性操作，这是一个不同于其他数据库的进化路径。
Redis 的数据类型都是基于基本数据结构的同时对程序员透明，无需进行额外的抽象。
Redis 运行在内存中但是可以持久化到磁盘，所以在对不同数据集进行高速读写时需要权衡内存，
应为数据量不能大于硬件内存。在内存数据库方面的另一个优点是， 相比在磁盘上相同的复杂的数据结构，在内存中操作起来非常简单，
这样 Redis 可以做很多内部复杂性很强的事情。 同时，在磁盘格式方面他们是紧凑的以追加的方式产生的，因为他们并不需要进行随机访问。
消息推送简介
在互联网业务中，有很多场景，都需要向用户推送消息，例如，一个论坛系统中，当用户发帖后，其他用户进行回复，需要对发帖者进行消息通知，在电商业务中，当用户下单后，管理后台需要通知用户下单成功；在一些秒杀和购物场景中，当用户提交订单未付款时候，一般会有一个截止时间，当即将到达截止时间时候，需要通知用户及时付款，在这些场景中，如何对用户实现消息通知呢?
简单消息推送
传统的开发模式，一般是前端轮询，例如在论坛系统中，在用户个人页面，前端轮询后端接口，后端返回对应的消息数据，这种方式需要每隔几秒就向后台发请求，对于实时性要求比较高的系统，轮询频率会更高，之前参与维护迭代的pc端消息推送，采用的是这种方式，前端轮询后端接口，后端通过查询数据库，判断是否有新消息，有的话就将数据返回给前端，前端进行弹窗或者其它方式进行展示，数据库设计大概如下：
| user_token | message | add_time | is_read |
|---|---|---|---|
| 张三 | hello | 1551671111 | 0 |
| 李四 | world | 1561561789 | 1 |
| 王五 | yes | 1781567177 | 1 |
当需要对某个用户，或者某些业务进行消息推送时候，在消息记录表，插入一条数据，以及消息的阅读状态，已读和未读，然后根据前端需求，返回该用户的全部消息，或者全部未读消息，当用户点击消息后，前端发请求，后端修改消息的阅读状态。
这种方式的实现比较简单无脑，基本上只需要查询修改下基本上就可以完成，适合用户量较少，对于实时性要求不高的业务场景，当用户量较大时候，查询和插入效率很低，需要加缓存或者对数据库进行分库分表，从而提高业务的稳定性和可用性，目前在一些小公司和简单的论坛一类的业务，该方式的消息推送可能还在使用，在未来的开发中，这种方式不推荐使用，因为效率低下，前端频繁轮询查接口，会对后端数据库造成很大压力，而且当有多个场景的消息推送时候，这种方式会让用户客户端的网页异常卡顿，加载速度慢，用户体验很差。
多场景消息推送
在电商业务中，很多消息类型，需要向用户发送短信，例如用户下单，退款，下单未付款，快递配送进度等等，这一类消息，通常需要根据不同的业务场景，有些需要给客户发送短信通知，在小程序端，可能需要调用微信开发平台的接口，进行小程序或者公众号消息推送，这一类相对来说比较容易实现，在需要消息推送时候，直接调用发送短信接口，或者微信平台接口进行消息推送，当数据量比较大时候，可以暂时把这些推送服务加入一个异步队列，进行分批次推送，这些适用于对时效性较低的场景，例如微信的每日运动排行。
对于这类消息推送，一般需要在业务执行时候，添加到异步队列中，通过倒计时一类的方式进行触发，常用的有 Redis 的发布与订阅，WebSocket 全双工通信，服务器端可以向浏览器发送消息，或者通过 Celery 执行异步队列，从而实现消息推送，下面简单介绍下 Celery。
Celery 任务队列一般用于线程或计算机之间分配工作的一种机制。
任务队列的输入是一个称为任务的工作单元，有专门的工作进行不断的监视任务队列，进行执行新的任务工作。
Celery 通过消息机制进行通信，通常使用中间人（Broker）作为客户端和职程（Worker）调节。启动一个任务，客户端向消息队列发送一条消息，然后中间人（Broker）将消息传递给一个职程（Worker），最后由职程（Worker）进行执行中间人（Broker）分配的任务。
Celery 可以有多个职程（Worker）和中间人（Broker），用来提高 Celery 的高可用性以及横向扩展能力。
Celery 需要消息中间件来进行发送和接收消息。 RabbitMQ 和 Redis 中间人的功能比较齐全，但也支持其它的实验性的解决方案，其中包括 SQLite 进行本地开发。
Celery 可以在一台机器上运行，也可以在多台机器上运行，甚至可以跨数据中心运行。
首先我们创建一个简单的task。
1 | from celery import Celery |
对于中间人，如果是Rabbitmq的话，可以使用 amqp://user:123456@localhost/test，Redis的话可以用 redis://localhost ，然后启动下任务队列:
1 | celery -A tasks worker --loglevel=info |
1 | [root@aliyun amqp]# celery -A tasks worker --loglevel=info |
可以看到 Celery 已经启动，通过 python shell 可以调用对应的任务，Celery默认的并发数为 CPU 核心数。
调用下试试。
1 | In [5]: add.delay(4, 4) |
1 | Celery可以通过 rate_limit 方向进行频率限制，例如，以下方式限制每分钟不超过10次 |
Celery 通过 EventLet 方式实现并发，使用 epoll 或 libevent 实现非阻塞 IO ,这样可以充分提高执行的任务数.
通过 celery worker -P 的方式可以指定工作方式
1 | celery -A proj worker -P eventlet -c 1000 // 1000个线程并发执行 |
Celery 可以 通过配置backend 来保存任务执行结果，我这里使用 Redis 。
Celerys.py
1 | #!/usr/bin/env python |
tasks.py
1 | #!/usr/bin/env python |
查看下 Redis 中是否有结果
可以查看到容器内的redis中已经有了 task的执行结果，我们可以查看下结果
1 | 127.0.0.1:6379> get celery-task-meta-8b3818f8-ebd0-443f-bbf8-5dadb536fcaa |
可以看到配置 Redis 为backend后，task的执行结果已经保存到 Redis中，以后开发中，可以通过读取 对应的task_id为 key的 数据，就可以得到每个任务的最终执行结果。
Mysql必知必会笔记
概念
数据库是一个以某种方式有组织的形式存储的数据集合
数据库(database) 保存有组织的数据的容器。（一个文件或者一组文件）
数据库表特性: 定义数据如何存储，存储什么数据，数据如何分解。
模式(scheme): 关于数据库和表布局以及特性的信息
列(column): 表中一个字段
行(row): 表中的一个记录
主键(primary key) : 一列(或者一组列 ，其值能够唯一区分表中每一行
成为主键条件：
任意两行都不具有相同主键值
每行都必须有一个主键值(主键列不允许NULL值)
docker学习笔记
什么是docker
docker包括一个命令行程序、一个后台守护进程、以及一组远程服务。它解决了常见的软件问题，并建华路安装、运行、发布和删除软件。这一切能够实现是使用一项Unix技术，称为容器。
容器不是虚拟化
在没有docker时代，使用硬件虚拟化(虚拟机),以提供隔离，虚拟机提供虚拟硬件，可安装一个os和其他程序，需要很长时间创建，资源开销打，因为除了要执行你需要的软件，还需要运行整个操作系统的副本。
docker容器不使用硬件虚拟化，运行在docker容器中的程序接口和逐渐的Linux内核直接打交道，容器中运行的程序与计算机操作系统直接没有额外的中间层，没有资源被冗余软件的运行或者虚拟硬件模拟而浪费掉，docker不是虚拟化技术，相反，它可以帮助使用已经内置到操作系统中的容器技术。
缺失模块。
1、请确保node版本大于6.2
2、在博客根目录（注意不是yilia根目录）执行以下命令：
npm i hexo-generator-json-content --save
3、在根目录_config.yml里添加配置：
jsonContent:
meta: false
pages: false
posts:
title: true
date: true
path: true
text: false
raw: false
content: false
slug: false
updated: false
comments: false
link: false
permalink: false
excerpt: false
categories: false
tags: true