## 查看包的所有方法
```python
import bottle
print(dir(bottle))

```



## from __future__ import with_statement
关于__future__的作用：
* 为了避免混淆现有工具，分析import 语句和期望找到他们要导入的模块
* 确保2.1之前的版本导入__future__产生运行时异常，因为2.1之前没有这个模块
* 记录何时引入了不兼容的更改，以及何时将其强制执行。这是一种可执行文档，可以通过导入__future__进行可编程式检查。

换句话说：
	
	python在新版本会引入新的功能特性，但是有的时候有些改动是不兼容旧版本的，举个例子来说
	
	比如说你的项目是用的py2.7，现在你需要迁移到3.x版本，直接升级到3.x肯定是不行的，那怎么办呢？这个时候就需要使用__future__了。
	
	我们可以通过__future__导入新版本某些模块，测试新版本的新功能，等测试成功后，再升级到新的版本上。
	
例子：
print,使用过py2.7和py3.x的小伙伴肯定都知道，在3.x的时候，print成了一个函数，那么让我们在py2.7通过__future__感受一下：
```python
>>from __future__ import print_function
>>print
<built-in function print>
```

除了print还有其他不少类似的，详情可以查看官网：

|feature|effect|中文解释|
|:--|:--|:--|
|nested_scopes|Statically Nested Scopes|嵌套域|
|generators|Simple Generators||
|division|Changing the Division Operator||
|absolute_import| Imports:Multi-line and Absolute/Relative||
|with_statement|The "with" statement|通过某种方式简化异常处理|
|print_function|Make print a function||
|unicode_literals|Bytes literals in Python 3000||
|generator_stop|StopIteration Handing insure generators||

	
## print中的f的作用
f开头表示在字符串内支持大括号内的python表达式，例如：
```python
port = 8888
print(f'Serving HTTP on port {PORT} ...')
# 输出结果
Serving HTTP port 8888.....
```	

# waitress
部署框架的优点
* 单文件启动，python3 pss_waitress.py
* 入口文件可以多次启动，比如多次运行python3 pss_waitress.py,这样的好处是可以把python3 pss_waitress.py加到定时任务，每一分钟运行一次，那么如果进程挂掉了，就会自己启动起来了。
* 包含日志打印模块，打印到文件，并且会滚动删除

## flask的代码
```python
import logging
from flask import Flask

app = Flask(__name__)


@app.route('/')
def index():
  # 这样写日志
  logging.info("myendpoint We are computering now")
  return 'We are computering now'


@app.route('/server_status_code')
def server_status_code():
  """用于探活"""
  return "ok"
```

### 启动入口代码
```python
import logging.handlers

LOG_FILE = "test_log.log"
log_format = "[%(levelname)s] %(asctime)s [%(filename)s:%(lineno)d, %(funcName)s] %(message)s"
logging.basicConfig(filename=LOG_FILE,
                    filemode="a",
                    format=log_format,
                    level=logging.INFO)
time_hdls = logging.handlers.TimedRotatingFileHandler(LOG_FILE, when='D', interval=1, backupCount=7)
logging.getLogger().addHandler(time_hdls)

logging.info("begin service")

import requests
from pss_app import app
from waitress import serve

DEPLOY_PORT = 8889


def process_is_alive():
  """检测本地进程是否存在"""
  try:
    r = requests.get(f"http://127.0.0.1:{DEPLOY_PORT}/server_status_code")
    if r.status_code == 200 and r.text == "ok":
      return True
    return False
  except Exception as e:
    return False


if __name__ == "__main__":
  logging.info("try check and start app, begin")
  if process_is_alive():
    logging.info("process_is_alive_noneed_begin")
  else:
    logging.info("process_is_not_alive_begin_new")
    serve(app, host='0.0.0.0', port=DEPLOY_PORT, threads=30)  # WAITRESS!

  logging.info("try check and start app, end")

```

### 安装依赖包
```bash
pip install -i https://pypi.tuna.tsinghua.edu.cn/simple flask waitress requests
```
### 启动方式
```bash
python3 pss_waitress.py
```



## 列表的赋值
```python
a=['1','2']
frst,secon = a 
# 输出结果
frst为1
secon为2
```

## __import__的使用
```python
module, application = app_path.split(':')
module = __import__(module)
```
__import__()函数用于动态加载类和函数
如果一个模块经常变化就可以使用__import__()来动态载入,主要用于反射或者延迟加载模块（例如：只在某些时候用模块，所以使用的时候，再导入。）
__import__(module)相当于import module
### 返回值
返回元组列表
### 例子：
a.py文件代码
```python
#!/usr/bin/env python    
#encoding: utf-8  
 
import os  
 
print ('在 a.py 文件中 %s' % id(os))
```
test.py 文件代码：
```python
#!/usr/bin/env python    
#encoding: utf-8  
 
import sys  
__import__('a')        # 导入 a.py 模块
```
输出结果为
```
在 a.py 文件中 4394716136
```


## python getattr()函数 
用于返回一个对象属性值
语法：
	
	getattr(object,name[,default])

参数：
* object --对象
* name  -- 字符串，对象属性
* default --默认返回值，如果不提供该参数，在没有对应属性时，将出发Attribute Error
```python
>>>class A(object):
...     bar = 1
... 
>>> a = A()
>>> getattr(a, 'bar')        # 获取属性 bar 值
1
>>> getattr(a, 'bar2')       # 属性 bar2 不存在，触发异常
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'A' object has no attribute 'bar2'
>>> getattr(a, 'bar2', 3)    # 属性 bar2 不存在，但设置了默认值
3
>>>
```

第一天源码学习

## __all__的使用
python模块中的__all__，用于模块导入限制，如：from module import *
此时被导入模块若定义了__all__属性，则只有__all__内指定的属性、方法、类可被导入；若没定义，则导入模块内的所有公有属性（不包含__开头的），方法和类



**bb.py**
```python
class A():
    def __init__(self,name,age):
        self.name=name
        self.age=age
class B():
    def __init__(self,name,id):
        self.name=name
        self.id=id
def fun():
    print "func() is run!"
def fun1():
    print "func1() is run!"
```

**test_bb.py**
```python
from bb import *
a=A('zhansan','18')
print a.name,a.age
b=B("lisi",1001)
print b.name,b.id
fun()
fun1()

运行结果：
zhansan 18
lisi 1001
func() is run!
func1() is run!
```
> 由于bb.py中没有定义__all__属性，所以导入了bb.py中所有的公有属性（不包括__开头的私有属性）

**bb2.py**
```python
__all__=('A','func')
class A():
    def __init__(self,name,age):
        self.name=name
        self.age=age
class B():
    def __init__(self,name,id):
        self.name=name
        self.id=id
def func():
    print "func() is run!"
def func1():
    print "func1() is run!"
```
**test_bb2.py**
```python
from bb import *
a=A('zhansan','18')
print a.name,a.age
func()
```
> 由于bb.py中使用了__all__=('A','func')，所以在别的模块导入该模块时，只能导入__all__中的变量、方法、类


## __slots__的使用
### 摘要
当一个类需要创建大量实例时，可以通过__slots__声明实例所需要的属性
例如：class Foo(obejct):__slots__= ['foo']。这样可以带来以下优点：
* 更快的属性访问速度
* 较少内存消耗

### slots的实现
我们首先来看看纯python是如何实现__slots__：
```python
# coding:utf-8
class Member(object):
    # 定义描述器实现slots属性的查找
    def __init__(self, i):
        self.i = i

    def __get__(self, obj, type=None):
        return obj._slotvalues[self.i]

    def __set__(self, obj, value):
        obj._values[self.i] = value


class Type(type):
    # 使用元类实现slots
    def __new__(self, name, bases, namespaces):
        slots = namespaces.get('_slots_')
        if slots:
            for i, slot in enumerate(slots):
                namespaces[slot] = Member(i)
            original_init = namespaces.get('__init__')

            def __init__(self, *args, **kwargs):
                # 创建_slotvalues列表和调用原来的__init__
                self._slotvalues = [None] * len(slots)
                if original_init(self, *args, **kwargs):
                    original_init(self, *args, **kwargs)

            namespaces['__init__'] = __init__
        return type.__new__(self, name, bases, namespaces)


try:
    class Object(object):
        __metaclass__ = Type
except:
    class Object(metaclass=Type):
        pass


class A(Object):
    _slots_ = 'x', 'y'


a = A()
a.x = 10
print(a.x)		
```
在Cpython中，当一个A类定义了_slots_ = {'x','y'},A.x就是一个有__get__和__set__方法的member_descriptor,并且在每个实例中可以通过直接访问内存获得。
在上面的例子中，我们用纯Python实现了一个等价的slots。当一个元类看到_slots_定义了x和y，它会创建两个的类变量，x = Member(0)和y=member(1)。然后，装饰__init__方法让新的实例创建一个_slotvalues列表。


例子中的实现和Cpython不同的是：
* 例子中，_slotvalues是一个存储在类对象外部的列表，而在Cpython中它与实例对象存储在一起，可以通过直接访问内存获得。相应地，member decriptor也不是存在外部列表中，而同样可以通过直接访问内存获得。
*　默认情况下，__new__方法会为每个实例创建一个字典__dict__来存储实例的属性。但如果定义了__slots__，__new__方法就不会再创建这个字典。
* 由于不存在__dict__来存储新的属性，所以使用一个不在__slots__中的属性时，程序会报错。

### 关于slots的继承问题
为了正确使用__slots__，最好直接继承object。如有需要用到其他父类，则父类和子类都要定义slots，还要记得子类的slots会覆盖父类的slots。
除非所有父类的slots都为空，否则不要使用多继承。

### namedtuple
利用内置的namedtuple不可变的特性，结合slots，能创建出一个轻量不可变的实例。(约等于一个元组的大小)
```python
>>> from collections import namedtuple
>>> class MyNt(namedtupele('MyNt', 'bar baz')): __slots__ = ()
>>> nt = MyNt('r', 'z')
>>> nt.bar
'r'
>>> nt.baz
'z'
```

__slots__

# 简单理解套接字

在任何类型的通信开始之前，网络应用程序都必须创建套接字
> 套接字最初是为同一主机上的应用程序所创建，使得主机上运行的一个程序（又名一个进程）与另一个运行的程序进行通信。这就是所谓的进程间的通信

有两种类型的套接字：基于文件和面向网络的：

1. 基于文件的  家族名:AF_UNIX

	它代表地址家族(addressfamily)：unix。其他比较旧的系统可能会将地址家族表示成域(domain)或协议家族(protocolfamily)
	
2. 面向网络的  家族名:AF_INET

	它代表地址家族(addressfamily)：因特网。另一个地址家族AF_INET6用于第6版因特网协议寻址。在所有的地址家族之中，目前AF_INET是使用最广泛的。
	
# 套接字地址：主机-端口对
做个比喻，套接字就像一个电话插孔，主机名和端口号就像区号和号码。当程序之间需要通信时，需要知道对端的主机名(IP)和端口号。有效的端口号范围为0~65535

# 面向连接的套接字与无连接的套接字
1. 面向连接的套接字
	
	TCP套接字的SOCK_STREAM
	特点：可靠，开销大
	> 在进行通信之前必须先建立一个连接，该连接的通信提供序列化的、可靠的和不重复的数据交付，而没有记录边界。这种类型的通信也称为虚拟电路或流套接字。
实现这种连接类型的主要协议是传输控制协议（缩写 TCP）
为了创建 TCP套接字，必须使用 SOCK_STREAM 作为套接字类型。

2. 无连接的套接字
	
	UDP套接字的名字SOCK_DGRAM
	特点:不可靠（局域网内还是比较可靠的）,开销小
	> 与虚拟电路形成鲜明对比的是数据报类型的套接字，它是一种无连接的套接字。
在通信开始之前并不需要建立连接。此时，在数据传输过程中并无法保证它的顺序性、可靠性或重复性。数据报确实保存了记录边界，这就意味着消息是以整体发送的，而并非首先分成多个片段。
实现这种连接类型的主要协议是用户数据报协议（缩写 UDP）。为
了创建UDP套接字，必须使用SOCK_DGRAM作为套接字类型。
UDP套接字的SOCK_DGRAM名字来自于单词“datagram”（数据报）。


简单理解套接字

1. 获取mongoDB中数据库的大小命令
```bash
use databasename
db.stats()
显示信息如下
> db.stats()
{ "collections" : 3, "objects" : 80614, "dataSize" : 21069700, "storageSize" : 39845376, "numExtents" : 9, "indexes" : 2, "indexSize" : 6012928, "ok" : 1}
```



其中storage表示的就是数据库的大小，显示出的数字的单位是字节，因此如果需要转换单位为KB需要除以1024  

2. 获取MongoDB中collection
```bash
db.collection.dataSize()
//collection中的数据大小
db.collection.storageSize()
//为collection分配的空间大小，包括未使用的空间
db.collection.totalIndexSize()
```
collection中索引数据大小
```bash
db.collection.totalSize()
```
collection中索引+data所占空间

获得mongodb数据表的大小

# MongoDB 设置账号和密码
##  一、安装MongoDB
1. 环境配置：
    * 操作系统：CentOS release 6.8 (Final) 

    ```bash
    [root@iZ2ze2pbbffhmn53ao4tuaZ bin]# cat /etc/redhat-release
    ```
    * 计算机类型：x86_64


    ```bash
    [root@iZ2ze2pbbffhmn53ao4tuaZ bin]# uname -m
    ```
    


2. 下载对应的MongoDB 版本
```bash
[root@iZ2ze2pbbffhmn53ao4tuaZ bin]# wget https://fastdl.mongodb.org/linux/mongodb-linux-x86_64-rhel62-3.6.4.tgz
```
3. 解压MongoDB 数据库
```bash
[root@iZ2ze2pbbffhmn53ao4tuaZ opt]# tar -zxvf mongodb-linux-x86_64-rhel62-3.6.4.tgz
```
4. 启动MongoDB
```bash
[root@iZ2ze2pbbffhmn53ao4tuaZ bin]# mkdir -p /data/db # 创建数据库数据存放目录
[root@iZ2ze2pbbffhmn53ao4tuaZ opt]# cd /opt/mongodb/bin

[root@iZ2ze2pbbffhmn53ao4tuaZ bin]# ./mongod # 启动Mongo Server服务，默认端口:27017，默认允许本地连接
```
## 二、配置账号和密码
1. 开启认证

    MongoDB 默认安装完成以后，只允许本地连接，同时不需要使用任何账号密码就可以直接连接MongoDB，这样就容易被黑，让支付一些比特币，所以为了避免这些不

    必要的麻烦，所以我们需要给Mongo设置一个账号密码；
```bash
[root@iZ2ze2pbbffhmn53ao4tuaZ bin]# ./mongod --auth # 启用认证
```
2. 创建管理员用户
```bash
> use admin
switched to db admin
> db.createUser({user:"admin",pwd:"password",roles:["root"]})
Successfully added user: { "user" : "admin", "roles" : [ "root" ] }
```
3. 认证登录
```bash
> db.auth("admin", "password")
```
4. MongoDB role 类型
* 数据库用户角色（Database User Roles）
    
    read：授予User只读数据的权限
    
    readWrite：授予User读写数据的权限

* 数据库管理角色（Database Administration Roles）：

    dbAdmin：在当前dB中执行管理操作
    
    dbOwner：在当前DB中执行任意操作
    
    userAdmin：在当前DB中管理User
* 备份和还原角色（Backup and Restoration Roles）：
    
    backup

    restore
* 跨库角色（All-Database Roles）：

    readAnyDatabase：授予在所有数据库上读取数据的权限
    readWriteAnyDatabase：授予在所有数据库上读写数据的权限userAdminAnyDatabase：授予在所有数据库上管理User的权限dbAdminAnyDatabase：授予管理所有数据库的权限
* 集群管理角色（Cluster Administration Roles）

    clusterAdmin：授予管理集群的最高权限

    clusterManager：授予管理和监控集群的权限，A user with this role can access the config and local databases, which are used in sharding and replication, respectively.
    
    clusterMonitor：授予监控集群的权限，对监控工具具有readonly的权限
    
    hostManager：管理Server
5. 添加数据库用户
```bash
> use flowpp
switched to db flowpp
> db.createUser({user: "flowpp", pwd: "flopww", roles: [{ role: "dbOwner", db: "flowpp" }]}) # 创建用户flowpp,设置密码flopww，设置角色dbOwner
```
6. 查看系统用户
```bash
> use admin
switched to db admin
> db.system.users.find() # 显示当前系统用户
{ "_id" : "admin.admin", "user" : "admin", "db" : "admin", "credentials" : { "SCRAM-SHA-1" : { "iterationCount" : 10000, "salt" : "9jXmylyRAK22TZmzv1Thig==", "storedKey" : "z76cVrBjX/CTFmn5RujtU+dz7Nw=", "serverKey" : "JQGonM84iDMI1nIXW7FdyOE55ig=" } }, "roles" : [ { "role" : "root", "db" : "admin" } ] }
{ "_id" : "flowpp.flowpp", "user" : "flowpp", "db" : "flowpp", "credentials" : { "SCRAM-SHA-1" : { "iterationCount" : 10000, "salt" : "KvocqWZA9E2tXBHpKpdAeQ==", "storedKey" : "50Kxc3LEgCSVN1z16S8g4A6jVp8=", "serverKey" : "0RSnsxd/7Yzmqro/YOHf/kfbHCk=" } }, "roles" : [ { "role" : "dbOwner", "db" : "flowpp" } ] }
```
7. 删除用户
```bash
1.切换admin ，删除用户flowpp ，删除失败
> use admin
switched to db admin
> db.dropUser("flowpp")
false
2.切换flowpp ，删除用户flowpp，删除成功
> use flowpp
switched to db flowpp
> db.dropUser("flowpp")
true
```
说明：删除用户的时候需要切换到用户管理的数据库才可以删除；