我在这个问题上有一些困难.我需要删除波形括号中包含的所有数据.
像这样：
Hello {{world of the {{ crazy}} {{need {{ be}}}} sea }} there.
变为：
Hello there.
这是我第一次尝试(我知道这很可怕)：
while 1:
firstStartBracket = text.find('{{')
if (firstStartBracket == -1):
break;
firstEndBracket = text.find('}}')
if (firstEndBracket == -1):
break;
secondStartBracket = text.find('{{',firstStartBracket+2);
lastEndBracket = firstEndBracket;
if (secondStartBracket == -1 or secondStartBracket > firstEndBracket):
text = text[:firstStartBracket] + text[lastEndBracket+2:];
continue;
innerBrackets = 2;
position = secondStartBracket;
while innerBrackets:
print innerBrackets;
#everytime we find a next start bracket before the ending add 1 to inner brackets else remove 1
nextEndBracket = text.find('}}',position+2);
nextStartBracket = text.find('{{',position+2);
if (nextStartBracket != -1 and nextStartBracket < nextEndBracket):
innerBrackets += 1;
position = nextStartBracket;
# print text[position-2:position+4];
else:
innerBrackets -= 1;
position = nextEndBracket;
# print text[position-2:position+4];
# print nextStartBracket
# print lastEndBracket
lastEndBracket = nextEndBracket;
print 'pos',position;
text = text[:firstStartBracket] + text[lastEndBracket+2:];
它似乎工作,但内存不足很快.有没有更好的方式来做(希望与正则表达式)？
编辑：我不清楚,所以我再举一个例子.我需要允许多个顶级括号.
像这样：
Hello {{world of the {{ crazy}} {{need {{ be}}}} sea }} there {{my }} friend.
变为：
Hello there friend.

题目1 两数之和
给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。
你可以假设每种输入只会对应一个答案。但是，数组中同一个元素不能使用两遍。
示例:
给定 nums = [2, 7, 11, 15], target = 9

因为 nums[0] + nums[1] = 2 + 7 = 9
所以返回 [0, 1]

解法 1–双重循环遍历
class Solution:
    def twoSum(self, nums: List[int], target: int) -> List[int]:
        for i in range(len(nums)):
            if((target-nums[i] in nums) and (nums.index(target-nums[i]) != i)):
                return [i, nums.index(target-nums[i])]```

解法 2–字典保存value
这个解法有个地方很有意思,就是当你的列表为[6,6],12 时,你的 dict 实际上是会被重置一次key 为 6 时的 value 的,但是因为本题目明确说了只会有一个答案,所以这种情况也是被包含了.而[6,6,6],12 是不会出现在题目中的.
class Solution:
    def twoSum(self, nums: List[int], target: int) -> List[int]:
        hashmap = {}
        for index, value in enumerate(nums):
            hashmap[value] = index
        for i in range(len(nums)):
            j = hashmap.get(target-nums[i])
            if j is not None and j != i:
                return [i, j]

题目20 有效的括号
给定一个只包括 ‘(’，’)’，’{’，’}’，’[’，’]’ 的字符串，判断字符串是否有效。
有效字符串需满足：
左括号必须用相同类型的右括号闭合。

左括号必须以正确的顺序闭合。

注意空字符串可被认为是有效字符串。
示例 1:
输入: "()"
输出: true
示例 2:

输入: "()[]{}"
输出: true
示例 3:

输入: "(]"
输出: false
示例 4:

输入: "([)]"
输出: false
示例 5:

输入: "{[]}"
输出: true

解法–栈
栈是显而易见的解法,这里优化的地方是奇数长度的 s 必不满足,不需要考虑.
class Solution:
    def isValid(self, s: str) -> bool:
        if(len(s) % 2 == 1):
            return False
        stack = []
        for i in s:
            if len(stack) == 0:
                stack.append(i)
                continue
            if match(stack[-1], i):
                stack.pop()
            else:
                stack.append(i)
        if len(stack) == 0:
            return True
        else:
            return False


def match(s1: str, s2: str) -> bool:
    if (s1 == '(' and s2 == ')') or (s1 == '{' and s2 == '}')or (s1 == '[' and s2 == ']'):
        return True
    else:
        return False

新学到知识
1. 类型注解
def add(x:int, y:int) -> int:
    return x + y

用 : 类型 的形式指定函数的参数类型，用 -> 类型 的形式指定函数的返回值类型。
然后特别要强调的是，Python 解释器并不会因为这些注解而提供额外的校验，没有任何的类型检查工作。也就是说，这些类型注解加不加，对你的代码来说没有任何影响：
2. 迭代器
这些可以直接作用于for循环的对象统称为可迭代对象：Iterable。可以使用isinstance()判断一个对象是否是Iterable对象.

而生成器不但可以作用于for循环，还可以被next()函数不断调用并返回下一个值，直到最后抛出StopIteration错误表示无法继续返回下一个值了。
x = [1,2,3,4]
it = iter(x)# 初始化的it是空值的,不能直接访问
value = next(it) # it的类型是list_iterator object,next()和value的类型是int

3. 获取for循环中的index
enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中。
lists = [1,2,3,4]
for index,value in enumerate(lists):
    print("%s--%s" %(index,value))

4. 判断值是否在list中
nums=[1,2,3]
num = 5
if(num in nums):
    print(1111)

5. 返回list中给定值的下标
逻辑:从列表中找出某个值第一个匹配项的索引位置
list.index(obj)

6. python dict的底层实现是用hash表
7. python没有专门的stack结构,用list实现
入栈操作–>append()

出栈操作–>pop()
stack = [3,4,5]
stack.append(6)
stack.append(7)#[3,4,5,6,7]
stack.pop()#[3,4,5,6]
stack.pop()#[3,4,5]

更多不知道你感不感兴趣的信息，可以关注一下我的公众号

1、ng-app=" "  定义angularJS的使用范围；
2、ng-init=“变量=值;变量=‘值’”  初始化变量的值，有多个变量时，中间用分号隔开；
3、ng-model=“变量”  定义变量名；
4、ng-bind=“变量”  绑定变量名，获取该变量的数据。这里的变量就是第3条的变量名。但是一般都用双重花括号来获取变量的值，比如：{{变量}}。

这里写目录标题
一、循环嵌套
二、打印九九乘法表
三、break语句的使用
四、continue语句的使用
五、while(1)循环

一、循环嵌套
循环的嵌套，就是在一个循环的循环体中，又包含了另外的循环结构，也称为多重循环。

在多重循环中，最常用的是双重循环。

例1.双重循环示例。
#include <stdio.h>
int main()
{
int i,j;
for(i=0;i<2;i++)
//外循环
//在下面的括号里面的就是外循环的内容
{
for(j=0;j<3;j++)
printf("%d,%d\n",i,j);
printf("*****\n");
/*这条五个星号的在内内循环外面
在外循环里面
因为循环后面跟的是单条语句
所以有人就会在每个循环后面都加{}来表示区分
即便只有一条语句*/
}
return 0;
}

首先将外循环的循环体看作一个整体，然后将外循环展开（就是写写它能够运行几次跟跳出条件啊啥的）。

然后，依次执行内循环。
二、打印九九乘法表
直接打印自然很难啊

所以想办法拆分

拆着拆着就简单了

编程思路:

首先，只考虑1个等式(比如“19=9”)的打印。

最简单的方法，就是将这个等式，直接作为字符串常量打印。

printf("19=9\n");

这种方式相当于一种半人工方式，不能体现程序控制的优势。

为了体现程序控制的思想，定义两个整型变量，代表等式所处的行号、列号。用行号列号控制程序运行。

打印一个等式“1*9=9”的程序:
#include <stdio.h>
int main()
{
int i,j;
i=9; 	//行号
j=1; 	//列号
printf("%d*%d=%d\n",j,i,i*j);
return 0;
}

要打印整个第9行的9个等式，只需要让行号i=9保持不变，然后让列号j从1递增到9，并循环执行打印一个等式的printf语句即可。
打印乘法表一行的源程序:
#include <stdio.h>
int main()
{
int j,i=9;
for(j=1;j<=9;j++)
printf("%d*%d=%d\t",j,i,i*j);
//\t就是转义字符
//代表水平制表符、
//简单点就是tab键
//就为了等式之间能够有间隔
//看起来条理一些
printf("\n");
//换行
return 0;
}


在上面的程序中，变量i的值固定为9，因此只能打印第9行。

要打印所有的9行等式，只需让行号i从1递增到9，并循环执行打印一行的程序段即可。
#include <stdio.h>
int main()
{
int i,j;
for(i=1;i<=9;i++)
{
for(j=1;j<=9;j++)
printf( "%d*%d=%d\t",j,i,i*j);
printf("\n");
}
return 0;
}

//语句printf("\n");
必须位于外循环体之内
内循环体之外。

效果图

等式的行数，是由外循环的循环次数控制的。

每行中等式的个数，是由内循环的循环次数控制的。

内循环就是j那个循环

可以看到j就是9次

不管有几行（那是外循环的事情）

每行都有9个等式（这室内循环规定的）

这是改成五以后的效果图

要让各行的等式个数随行号而变化，只需让内循环的循环次数，跟随外循环变量的值而变化即可。

决定一个循环的循环次数的因素，是它的初值、终值和步长。

通常的实现方法，是将内循环变量的终值(或初值)，设置为包含外循环变量的表达式。
只需要将内循环变量j的终值
设置为与外循环变量i的值相等即可。
for(i=1;i<=9;i++ )
{
for(j=1;j<=i;j++)
printf("%d*%d=%d\t",i,j,i*j);
printf("\n");
这样，内循环的循环次数将变成i次，从而使得第i行输出i个等式。


修正之后的源程序:
#include <stdio.h>
int main()
{
int i,j;
for(i=1;i<=9;i++)
{
for(j=1;j<=i;j++)
printf("%d*%d=%d\t",j,i,i*j);
printf("\n");
}
return 0;
}

99乘法表的源代码其实并不长

总结：如果要编写双重循环结构的程序，可以先构造出内循环部分。以整个内循环部分作为循环体，加上外层循环语句，形成嵌套结构即可。
三、break语句的使用
break语句只能用于switch语句内部，或者循环体内部。

用于循环体内部时，其功能是从本层的循环体中跳出来，从而提前结束循环。
#include <stdio.h>
int main()
{
int i;
for(i=1;i<=5;i++)
{
if(i>=3)
break;
//这里就是i=3的时候跳出循环
printf( "%d,",i);
return 0;
}

break一般结合if语句执行，就是由if语句提供一个判断条件，决定是否执行break语句。
四、continue语句的使用
continue;

只能用于循环体内部，其功能是跳过continue之后的部分循环体，而继续进行下一次循环。
#include <stdio.h>
int main()
{
int i;
for(i=1;i<=5;i++)
{
if(i<=2)
continue;
//就是如果if表达式的值为真
//那么后面的printf("%d,",i);就不执行了
//就跳过了
//等到if语句为假的时候
//就可以跳过continue;了
printf("%d,",i);
}
return 0;
}

对于for循环，执行continue将转向表达式3（一般就是i++这一类）执行，然后转向循环条件的判断（表达式2，就是i<=5这种）

而对于while循环和do-while循环，执行continue将直接转向循环条件的判断。（因为他的i++通常在循环体里面如果排序的时候continue在i++之前，i++就会被跳过）
while（i<10）
{
printf("%d",i)
continue;
i++
}

五、while(1)循环
while(1)循环的循环条件永远为真

对循环条件进行判断的时机，是至关重要的。

一方面，要保证先给循环变量赋值、后判断循环条件;

另一方面，要保证先判断循环条件、后进行相应处理。
例：从键盘输入若干名学生某一门课程的成绩，然后求出他们的平均成绩。要求以任意负数作为输入结束标记。

编程思路:

要想求平均成绩，必须先求出这些成绩的总和。由于没有明确给出学生的人数，因此可以采用输入结束标记控制循环。
算法设计:

输入一个学生的成绩。如果是结束标记，那么就结束循环;否则，累加到总成绩中，并统计当前学生的人数，然后转向第1步。最后求出平均成绩并输出。
#include<stdio.h>
int main()
{
float g,sum=0,ave;
//sum=0注意
int n=0;
printf("请输入若干个成绩，以任意负数退出:\n");
while(g>=0)
{
scanf("%f",&g);
sum=sum+g;
n++;
}
ave=sum/n;
printf("平均成绩=%.2f\n",ave);
return 0;
}
这样是不对的
while(g>=0)
{
scanf("%f",&g);
sum=sum+g;
n++;
}
很明显while所判断的g一开始并没有被赋值
而且如果输入负数也是先执行循环体
也就是先加到sum中
在进行判断
不合适
所以用do-while

#include <stdio.h>
int main()
{
float g,sum=0, ave;
int n=0;
printf("请输入若干个成绩，以任意负数退出:\n");
{
scanf("%f",&g);
sum=sum+g ;
n++ ;
}
while(g>=0);
ave=sum/n;
printf("平均成绩=%.2f\n" ,ave);
return 0;
}
but
结束标记也是可以被加进去
因为在循环体里面


综上

用while（1）

直接用1作为循环的条件,即循环条件永远为真，从而成为无限循环。

可以通过有条件的break语句，选择适当的时机跳出循环。
#include<stdio.h>
int main()
{
float g,sum=0ave;
int n=0;
printf("请输入若干个成绩，以任意负数退出:\n");
while(1)
{
scanf("%f",&g);
if(g<0)
break;
sum=sum+g;
n++;
}

//这里break的位置美挺有意思的

ave=sum/n;
printf("平均成绩=%f\n" ,ave);
return 0;
}