diff --git "a/C-\347\274\226\347\250\213\350\257\255\350\250\200/Cpp-A-\345\237\272\347\241\200\347\237\245\350\257\206.md" "b/C-\347\274\226\347\250\213\350\257\255\350\250\200/Cpp-A-\345\237\272\347\241\200\347\237\245\350\257\206.md"
index 428a6886..dd0c4ccc 100644
--- "a/C-\347\274\226\347\250\213\350\257\255\350\250\200/Cpp-A-\345\237\272\347\241\200\347\237\245\350\257\206.md"
+++ "b/C-\347\274\226\347\250\213\350\257\255\350\250\200/Cpp-A-\345\237\272\347\241\200\347\237\245\350\257\206.md"
@@ -34,10 +34,11 @@
 ## 指针与引用
 
 ### 左值引用与右值引用
-> [C++专题-左值与右值](./Cpp专题-左值与右值.md)
+> [C++专题-左值与右值](./Cpp-C-左值与右值.md)
 
 ## static 与 const
 > https://github.com/huihut/interview#const
+
 **static 作用**
 1. 修饰普通变量，修改变量的存储区域和生命周期，使变量存储在静态区，在 main 函数运行前就分配了空间，如果有初始值就用初始值初始化它，如果没有初始值系统用默认值初始化它。
 1. 修饰普通函数，表明函数的作用范围，仅在定义该函数的文件内才能使用。在多人开发项目时，为了防止与他人命令函数重名，可以将函数定位为 static。
diff --git "a/C-\347\274\226\347\250\213\350\257\255\350\250\200/Cpp-C-\345\267\246\345\200\274\344\270\216\345\217\263\345\200\274.md" "b/C-\347\274\226\347\250\213\350\257\255\350\250\200/Cpp-C-\345\267\246\345\200\274\344\270\216\345\217\263\345\200\274.md"
index 0831c603..d85e298b 100644
--- "a/C-\347\274\226\347\250\213\350\257\255\350\250\200/Cpp-C-\345\267\246\345\200\274\344\270\216\345\217\263\345\200\274.md"
+++ "b/C-\347\274\226\347\250\213\350\257\255\350\250\200/Cpp-C-\345\267\246\345\200\274\344\270\216\345\217\263\345\200\274.md"
@@ -13,29 +13,29 @@ Index
 <!-- TOC -->
 
 - [小结](#小结)
-  - [左值引用类型 与 右值引用类型](#左值引用类型-与-右值引用类型)
-  - [当发生自动类型推断时，`T&&` 也能绑定左值](#当发生自动类型推断时t-也能绑定左值)
-  - [如何快速判断左值与右值](#如何快速判断左值与右值)
-  - [引用折叠规则](#引用折叠规则)
-  - [`move()` 与 `forward()`](#move-与-forward)
+    - [左值引用类型 与 右值引用类型](#左值引用类型-与-右值引用类型)
+    - [当发生自动类型推断时，`T&&` 也能绑定左值](#当发生自动类型推断时t-也能绑定左值)
+    - [如何快速判断左值与右值](#如何快速判断左值与右值)
+    - [引用折叠规则](#引用折叠规则)
+    - [`move()` 与 `forward()`](#move-与-forward)
 - [左值与右值的本质](#左值与右值的本质)
-  - [左值、消亡值、纯右值](#左值消亡值纯右值)
+    - [左值、消亡值、纯右值](#左值消亡值纯右值)
 - [右值引用的特点](#右值引用的特点)
-  - [右值引用延长了临时对象的生命周期](#右值引用延长了临时对象的生命周期)
-  - [利用右值引用避免临时对象的拷贝和析构](#利用右值引用避免临时对象的拷贝和析构)
-  - [右值引用类型绑定的一定是右值，但 `T&&` 可能不是右值引用类型](#右值引用类型绑定的一定是右值但-t-可能不是右值引用类型)
-  - [当发生自动类型推断时，`T&&` 是未定的引用类型](#当发生自动类型推断时t-是未定的引用类型)
+    - [右值引用延长了临时对象的生命周期](#右值引用延长了临时对象的生命周期)
+    - [利用右值引用避免临时对象的拷贝和析构](#利用右值引用避免临时对象的拷贝和析构)
+    - [右值引用类型绑定的一定是右值，但 `T&&` 可能不是右值引用类型](#右值引用类型绑定的一定是右值但-t-可能不是右值引用类型)
+    - [当发生自动类型推断时，`T&&` 是未定的引用类型](#当发生自动类型推断时t-是未定的引用类型)
 - [常量（左值）引用](#常量左值引用)
 - [返回值优化 RVO](#返回值优化-rvo)
 - [移动语义](#移动语义)
-  - [深拷贝带来的问题](#深拷贝带来的问题)
-  - [移动构造函数](#移动构造函数)
-  - [移动语义 与 `move()`](#移动语义-与-move)
-  - [`move()` 的本质](#move-的本质)
-  - [`move()` 的原型 TODO](#move-的原型-todo)
+    - [深拷贝带来的问题](#深拷贝带来的问题)
+    - [移动构造函数](#移动构造函数)
+    - [移动语义 与 `move()`](#移动语义-与-move)
+    - [`move()` 的本质](#move-的本质)
+    - [`move()` 的原型 TODO](#move-的原型-todo)
 - [完美转发](#完美转发)
-  - [`forward<T>()` 实现完美转发](#forwardt-实现完美转发)
-  - [`forward<T>()`的原型 TODO](#forwardt的原型-todo)
+    - [`forward<T>()` 实现完美转发](#forwardt-实现完美转发)
+    - [`forward<T>()`的原型 TODO](#forwardt的原型-todo)
 - [Reference](#reference)
 
 <!-- /TOC -->
@@ -320,49 +320,49 @@ int&& v2 = v1;  // err: v2 是右值引用类型，但 v1 是左值
     construct: 1        // 构造局部变量 a，在编译的优化下，相当于直接将 a “改名” aa
     destruct: 1         // 程序结束，析构变量 aa
     ```
-  - 返回值优化并不是 C++ 的标志，是各编译器优化的结果，但是这项优化并不复杂，所以基本流行的编译器都提供
+  - 返回值优化并不是 C++ 的标准，是各编译器优化的结果，但是这项优化并不复杂，所以基本流行的编译器都提供
 
 
 ## 移动语义
 
 ### 深拷贝带来的问题
 - 带有**堆内存**的类，必须提供一个深拷贝构造函数，以避免“指针悬挂”问题
-  > 所谓指针悬挂，指的是两个对象内部的成员指针变量指向了同一块地址，析构时这块内存会因被删除两次而发生错误
-  ```Cpp
-  class A {
-  public:
-      A(): m_ptr(new int(0)) {                  // new 堆内存
-          cout << "construct" << endl;
-      }
-
-      A(const A& a):m_ptr(new int(*a.m_ptr)) {  // 深拷贝构造函数
-          cout << "copy construct" << endl;
-      }
-      
-      ~A(){
-          // cout << "destruct" << endl;
-          delete m_ptr;   // 析构函数，释放堆内存的资源
-      }
-  private:
-      int* m_ptr;         // 成员指针变量
-  };
-
-  A getA() {
-      return A();
-  }
-
-  int main() {
-      A a = getA();
-      return 0;
-  }
-  ```
-- 输出（关闭 RVO）
-  ```Cpp
-  construct
-  copy construct
-  copy construct
-  ```
-  > 如果不关闭 RVO，只会输出 `construct`
+    > 所谓指针悬挂，指的是两个对象内部的成员指针变量指向了同一块地址，析构时这块内存会因被删除两次而发生错误
+    ```Cpp
+    class A {
+    public:
+        A(): m_ptr(new int(0)) {                  // new 堆内存
+            cout << "construct" << endl;
+        }
+
+        A(const A& a):m_ptr(new int(*a.m_ptr)) {  // 深拷贝构造函数
+            cout << "copy construct" << endl;
+        }
+        
+        ~A(){
+            // cout << "destruct" << endl;
+            delete m_ptr;   // 析构函数，释放堆内存的资源
+        }
+    private:
+        int* m_ptr;         // 成员指针变量
+    };
+
+    A getA() {
+        return A();
+    }
+
+    int main() {
+        A a = getA();
+        return 0;
+    }
+    ```
+    - 输出（关闭 RVO）
+    ```Cpp
+    construct
+    copy construct
+    copy construct
+    ```
+    > 如果不关闭 RVO，只会输出 `construct`
 - 提供深拷贝能够保证程序的正确性，但会带来额外的性能损耗——临时对象也会申请一块内存，然后又马上被销毁了；如果堆内存很大的话，这个性能损耗是不可忽略的
 - 对于临时对象而言，深拷贝不是必须的
 - 利用右值引用可以避免无谓的深拷贝——移动拷贝构造函数
diff --git "a/C-\347\274\226\347\250\213\350\257\255\350\250\200/Python-A-\345\237\272\347\241\200\347\237\245\350\257\206.md" "b/C-\347\274\226\347\250\213\350\257\255\350\250\200/Python-A-\345\237\272\347\241\200\347\237\245\350\257\206.md"
new file mode 100644
index 00000000..300c4769
--- /dev/null
+++ "b/C-\347\274\226\347\250\213\350\257\255\350\250\200/Python-A-\345\237\272\347\241\200\347\237\245\350\257\206.md"
@@ -0,0 +1,14 @@
+Python-基础知识
+===
+
+
+Index
+---
+<!-- TOC -->
+
+- [Python 中的垃圾回收机制](#python-中的垃圾回收机制)
+
+<!-- /TOC -->
+
+## Python 中的垃圾回收机制
+> [Python垃圾回收机制详解 - Xjng](http://www.cnblogs.com/Xjng/p/5128269.html) - 博客园 
\ No newline at end of file