Python入门非常简单，精通却很难，不过我只需要其中某个功能而已。现学现用，下面代码方便快速回忆：

# coding: utf-8 
# 井号是单行注释
# 数据类型、控制结构、功能、I/O文件
''' 
多行注释是三个单引号 
'''

import os #引入外部库的语句
from math import cos 

#动态类型语言
s = 0   
s = "shit" 

'''Python自带数据结构'''

#list是一种有序的集合，可以随时添加和删除其中的元素。
names = ['Michael', 'Bob', 'Tracy']    
names[-1] = "Jake"   #Tracy
names.pop(0)    #删除Michael
names.insert(1, "Jack")
names.sort()    #排序
L = ["隋辨", 20, 125.5] #不同的数据类型
#嵌套 len(sheet) = 4    sheet[2][1] = 5
sheet = [1, 2, [3, 5], 4]   

#tuple一旦初始化就不能修改
classmates = ('Michael', 'Bob', 'Tracy')
tmp = ()    #定义空tuple
t1 = (5)    #定义变量t1 = 1
t2 = (5,)    #定义只有1个元素的tuple
t3 = (1, 2, [3, 4]) #由于list可变所以tuple看上去可变
t3[2][0] = 4

#dict，在C++叫map
d = {'Michael': 95, 'Bob': 75, 'Tracy': 85}
print(d["Bob"])  #75
print('Bob' in d)   #判断key是否存在
#key必须是不可变对象，如list就不可以作为key

#set
set1 = set([1, 2, 3])   #利用list作为输入
set2 = set([2, 3, 4])
set1.add(4) #添加
set1.remove(1)  #删除
set1 & set2 #2, 3
set1 | set2 #1, 2, 3, 4



'''循环'''
#range(5)相当于[0, 1, 2, 3, 4]
a = 0
for x in range(5):
    a = a + 1
    print(x)
#利用list循环
for name in names:
    print(name)
while(True):
    a = a - 1
    if(a % 2 == 0):
        break

#判断
if a < 0:
    print("负数")
elif a == 0:
    print("零")
else:
    print("正数")

if s:
    print("s是非零数值、非空字符串或非空list")

#输出
print("%.2f" %a)    #类C的输出方法
print("hhh" * 10)   #重复十个hhh
print('{0}成绩提升了{1:.1f}%'.format('小明', 17.125))   #正宗输出方法

#函数
def my_power(x, n = 0):
    s = 1
    while n > 0:
        n = n - 1
        s = s * x
    return s
print(my_power(2, 10))

#定义一个什么事也不做的空函数
def nop():
    pass    

#返回多个值其实就是返回一个tuple
def mul_return():
    return 1, 2, 3

//求割点
int dfs(int u, int fa)
{
    int lowu = pre[u] = ++dfs_clock;
    int child = 0;
    for(int i = 0; i < G[u].size(); i++)
    {
        int v = G[u][i];
        if(!pre[v])
        {
            child++;
            int lowv = dfs(v, u);
            lowu = min(lowu, lowv);
            //如果lowu==pre[v],光凭这一条u仍然是割点
            //>就更加了

            //lowv ,v及其后代能返回的最小祖先pre值，没有则返回自己 即lowv > pre[u] 则(u,v)是割边
            //而且还知道了u是割点
            if(lowv >= pre[u])
            {
                iscut[u] = true;
            }
        }
        else if(pre[v] < pre[u] && fa != v)//如果访问过就判断是不是后向边，
        {
            lowu = min(pre[v], lowu);
        }
    }
    //if(fa == -1 && child > 1) iscut[u] = true; 不这样判断是因为lowu一开始等于pre[u]
    if(fa < 0 && child == 1) iscut[u] = false;
    //如果是叶子结点，一开始是memset(iscut, 0, sizeof(iscut))

    low[u] = lowu;
    return lowu;
}



//求点双连通分量
struct Edge
{
    int u, v;
};

int pre[maxn], iscut[maxn], bccno[maxn], dfs_clock, bcc_cnt;//bccno记录每个点的bcc编号
vector  G[maxn], bcc[maxn];//bcc储存双连通分量的点
stack S;

int dfs(int u, int fa)
{
    int lowu = pre[u] = ++dfs_clock;
    int child = 0;
    for(int i = 0; i < G[u].size(); i++)
    {
        int v = G[u][i];
        Edge e = (Edge){u, v};
        /*栈中存储的是边而不是点!!!*/
        /*因为割顶明显不可能属于任何一个点双，所以割顶的bccno无意义。*/
        if(!pre[v])
        {
            S.push(e);//没有访问过的，就压栈，把沿途遍历到的边都加入栈（也就是第一次遍历所有的点）
            child++;
            int lowv = dfs(v, u);
            lowu = min(lowu, lowv);
            if(lowv >= pre[u])//必存在割点  若大于则还存在割边(u, v)
            {
                //若发现了一个割点，说明当前栈中已经保存了点双的所有边。
                iscut[u] = true;
                bcc_cnt++;//从1开始
                bcc[bcc_cnt].clear();//清空准备储存
                for(;;)
                {
                    Edge x = S.top(); S.pop();
                    if(bccno[x.u] != bcc_cnt)
                    {
                        bcc[bcc_cnt].push_back(x.u);//第bcc_cnt个连通分量有点加入
                        bccno[x.u] = bcc_cnt;
                    }
                    if(bccno[x.v] != bcc_cnt)
                    {
                        bcc[bcc_cnt].push_back(x.v);
                        bccno[x.v] = bcc_cnt;
                    }
                    if(x.u == u && x.v == v) break;
                }//把边集中涉及到的点全部取出来，把他们的bccno[]设置成当前的bcc_cnt
            }
        }
        else if(pre[v] < pre[u] && v != fa)//反向边
        {
            S.push(e);//也许割点v此时被push
            lowu = min(lowu, pre[v]);//反向边更新
        }
    }
    if( fa < 0 && child == 1)   iscut[u] = 0;
    return lowu;
}

void find_bcc(int n)
{
    memset(pre, 0, sizeof(pre));
    memset(iscut, 0, sizeof(iscut));
    memset(bccno, 0, sizeof(bccno));
    dfs_clock = bcc_cnt = 0;
    for(int i = 0; i < n; i++)
        if(!pre[i]) dfs(i, -1);//怕万一有些点是孤立的
}