python语言最常见的括号有三种，分别是：小括号( )、中括号[ ]和大括号也叫做花括号{ }。其作用也各不相同，分别用来代表不同的python基本内置数据类型。
 
1.python中的小括号( )：代表tuple元组数据类型，元组是一种不可变序列。创建方法很简单，大多时候都是用小括号括起来的。
 
>>> tup = (1,2,3)
 
>>> tup
 
(1, 2, 3)
 
>>>
 
>>> ()#空元组
 
()
 
>>>
 
>>> 55,#一个值的元组
 
(55,)
 
定义元组(tuple)时，如果只含一个元素，要在后面加逗号。不然，定义的就不是元组tuple
 
元组的元素不可被修改，不能被增加或者删除，(只是针对元组的一级元素是不可以修改的，元组里面的二级列表元素是可以被修改的，就是元组里面嵌套着列表)可以被for循环，所以元组也是一个可迭代对象，元组也是有序的 ,例如：
 
tu = ("11", "22", ["33", ("ae", 66, "99",), 90])
 
tu[2][0] = "333"
 
print(tu)
 
out:('11', '22', ['333', ('ae', 66, '99'), 90])
 
2.python中的中括号[ ]：代表list列表数据类型，列表是一种可变的序列。其创建方法即简单又特别，像下面一样：
 
>>> list('python')
 
['p', 'y', 't', 'h', 'o', 'n']
 
3.python大括号{ }花括号：代表dict字典数据类型，字典是由键对值组组成。冒号':'分开键和值，逗号','隔开组。用大括号创建的方法如下：
 
>>> dic={'jon':'boy','lili':'girl'}
 
>>> dic
 
{'lili': 'girl', 'jon': 'boy'}
 
>>>
 
转载自百度知道：https://zhidao.baidu.com/question/484920124.html
 
在 python 中，strings, tuples, 和 numbers 是不可更改的对象，而 list,dict 等则是可以修改的对象。
 
不可变类型：
 
变量赋值 a=5 后再赋值 a=10，这里实际是新生成一个 int 值对象 10，再让 a 指向它，而 5 被丢弃，不是改变a的值，相当于新生成了a。
 
可变类型：
 
变量赋值 la=[1,2,3,4] 后再赋值 la[2]=5 则是将 list la 的第三个元素值更改，本身la没有动，只是其内部的一部分值被修改了。
 
总结
 
以上所述是小编给大家介绍的python 中大括号中括号小括号的区分,希望对大家有所帮助，如果大家有任何疑问请给我留言，小编会及时回复大家的。在此也非常感谢大家对聚米学院网站的支持！
 
如果你觉得本文对你有帮助，欢迎转载，烦请注明出处，谢谢！

 
c语言中，自增(++)和自减(–－)运算是很有c语言特色(恶心)的一种运算符。
 
可以按教科书那种记：
 
b = a++ 是先赋值后运算，即先 b=a，然后 a++。
 
b = ++a 是先运算后赋值，即先 ++a，然后 ++a。
 
例子：
 
 
 
好好想一下即可。
 
注意结合性，从右边到左边。
 
自增：后缀：同表达式中Turbo C的情况相同：先统一取值后依次自增，如：
 
int a,i=5; a=i+++i+++i++;a=15, i=8.
 
1、 在一般表达式中和在函数参数中计算的结果相同(这一点与TurboC环境不同)；
 
2、 后缀：同表达式中Turbo C的情况相同：先统一取值后依次自增，如：
 
int a,i=5; a=i+++i+++i++;a=15, i=8.
 
3、 前缀：前两个自增同Turbo C，即依次自增后统一取值，后面的每个自增后即
 
取值，如：
 
int a, i=5; a= ++i+(++i)+(++i); a=22, i=8.
 
4、 前后缀混合的情况：
 
(1) 一般情况：表达式中自左向右计算，参数自右向左运算。前缀自增后取值；后缀(或变量)取值依其所处位置而定，有连续多个将统一取值，其自增在语句结束前进行。
 
(2) 前后缀各有一个的情况：设int i=5; 由于i++++i应满足交换率与++ii++相同，规定按后者计算故为36。实验2内容4：int i=5;printf("%d,%d\n", --i, i++*++i ); 打印5，36。
 
(3) 若i++或++i或两者有多于一个的情况：++i有两个以上在一起时最左边的连续自增同3、，其余每个自增后取值，如：int i=5;
 
printf("%d\n%d\n",–i,(++i)+(i++)+(i++)+(++i));打印6和25
 
解释：i++的语句的加是在；后才加的
 
不妨再在下面打行(i)的输出代码，i是8！！！！
 
后缀(或变量)取值依其所处位置而定，有连续多个将统一取值，其自增在语句结束前进行。
 
printf("%d\n%d\n",–i,(++i)+(++i)+(++i)+(++i)+(i++));打印8和40
 
printf("%d\n%d\n",–i,(++i)+(++i)+(++i)+i+(++i)+(++i)); 打印9和49
 
(4) 函数参数中有括号时，括号参数优先计算，其余参数仍自右向左计算，如：
 
int i=9,j=8;printf("%d %d\n", (++i, j–), ++i); 打印8 11
 
printf("%d %d%d\n", (++i, j–), ++i, i); 打印8 11 10
 
(5) 最后i的值等于原值加总自增次数减自减的次数.

latex或tex中用\left(……\right)在多行公式中自动匹配括号大小的问题
 
注意事项
 
在用latex或tex编写英文pdf时，会遇到公式需要选择合适的括号大小问题，一般都会选择使用\left……\right加被选的括号，但是需要注意一下几点：
 
1.\left和\right一定要成对出现，而且要进行配对使用。不能出现前面使用"("，后面使用"]“相对，否则会报错。
 2.在多行公式中，如果使用left \right一行写不下，同时还其中还包含运算符号(+, -, *, /, =),需要额外注意，应该在前行的行末加”\right. “后行的开头加”\left."。
 3.使用\big，\Big，\bigg，\Bigg来配对括号时，也要注意一定要成对出现，而且要进行配对使用。\big，\Big，\bigg，\Bigg按着顺序，它们控制的括号不断变大。
 
错误展示及修正
 
1.没有注意使用括号类型的匹配
 
 2.\left与\right没有匹配使用
 
 3.公式跨行后使用错误
 上图里面，使用left \right跨行了，并且中间包含了运算符号，需要添加在前行的行末加"\right. “后行的开头加”\left."
 
正确操作：
 
 
\begin{equation*}
\begin{split}
&\frac{1-\alpha}{2(1-e^{-\rho})}\left[\mathcal{I}^{\alpha}_{a^+}F(b)+\mathcal{I}^{\alpha}_{b^-}F(a)\right]\\
&\quad=2\left\{\int^{2}_{0}e^{-(2-s)}\Big[e^{s},10-\frac{1}{2}s^{2}\Big]\mathrm{d}s\right.\\
&\left.\quad\quad+\int^{2}_{0}e^{-s}\Big[e^{s},10-\frac{1}{2}s^{2}\Big]\mathrm{d}s\right\}\\
&\quad=2\left\{\Big[\frac{1}{2}e^{2}-\frac{1}{2}e^{-2},9-9e^{-2}\Big]+\Big[2,9-5e^{-2}\Big]\right\}\\
&\quad=\left[4+e^{2}-e^{-2},36-28e^{-2}\right]\\
&\quad\approx[3.2538, 9.3130].
\end{split}
\end{equation*}
 
另外，除了用"\right. “和”\left."处理公式跨行的括号大小选择外，也可选择使用合适的\big，\Big，\bigg，\Bigg进行匹配。
 
例如\big，\Big，\bigg，\Bigg的大小比较。
 

 
在这里我想说的是几种shell里的小括号,大括号结构和有括号的变量，命令的用法，如下：
 
1.${var}
 
2.$(cmd)
 
3.()和{}
 
4.${var:-string},${var:+string},${var:=string},${var:?string}
 
5.$((exp))
 
6.$(var%pattern),$(var%%pattern),$(var#pattern),$(var##pattern)
 
现在分述如下：
 
1.Shell中变量的原形：${var}大家常见的变量形式都是$var,如
 
$ var=test
 
$ echo $var
 
test
 
但当你要显示变量值加随意的字符(我这里用AA)时，就会出错，如下：
 
$ echo $varAA
 
$
 
这时应该用变量的原形：${var}，即是加一个大括号来限定变量名称的范围，如下
 
$ echo ${var}AA
 
testAA
 
$
 
以这个特性，我们可以很方便地写一个批量改后缀名的程序，我把它命名为mymv，程序如下：
 
#!/bin/bash
 
tail=$1
 
for filename in `ls`
 
do
 
mv $filename ${filename}.$tail
 
done
 
程序需要提供一个后缀名，如c，表示改为后缀为c的C程序文件，看下面的测试：
 
$ ls
 
a b c
 
$ mymv c
 
$ ls
 
a.c b.c c.c
 
$
 
看样子程序运行的很好，但这是不完善的程序，有2个要注意的问题：
 
A,目录下没有子目录，如果有一个目录，假设为dir，则也会被改为dir.c，这显然不是我们想要的，应该修正这个程序能识别目录。
 
B,没有帮助对程序的参数进行处理，程序应该足够友好，在用户没有给定后缀名时应能处理，像上面的将直接给文件加上了一个点(.),这显然也不是我们想要的。
 
因为我们的目的是说明${var}，这样已经足够了，因此这里不会再对上面的程序进行修正。
 
2.命令替换$(cmd)命令替换$(cmd)和符号`cmd`(注意这不是单引号，在美式键盘上，`是ESC下面的那个键)有相同之处
 
$ ls
 
a b c
 
$ echo $(ls)
 
a b c
 
$ echo `ls`
 
a b c
 
我们来分析一下命令echo $(ls)，以便理解所谓命令替换是什么意思：
 
shell扫描一遍命令行，发现了$(cmd)结构，便将$(cmd)中的cmd执行一次，得到其标准输出，再将此输出放到原来命令echo $(ls)中的$(ls)位置，即替换了$(ls),再执行echo命令。
 
如下：
 
echo $(ls)被替换成了echo a b c
 
这里要注意的是$(cmd)中的命令的错误输出是不会被替换的，替换的只是标准输出：
 
$ var=$(cat d) ###文件d在当前目录不存在
 
cat: d: 没有那个文件或目录
 
$ echo $var
 
$ ###显然var变量的值是空的
 
3、一串的命令执行()和{}()和{}都是对一串的命令进行执行，但有所区别：
 
A,()只是对一串命令重新开一个子shell进行执行
 
B,{}对一串命令在当前shell执行
 
C,()和{}都是把一串的命令放在括号里面，并且命令之间用;号隔开
 
D,()最后一个命令可以不用分号
 
E,{}最后一个命令要用分号
 
F,{}的第一个命令和左括号之间必须要有一个空格
 
G,()里的各命令不必和括号有空格
 
H,()和{}中括号里面的某个命令的重定向只影响该命令，但括号外的重定向则影响到括号里的所有命令
 
我们来看几个例子：
 
$ var=test
 
$ (var=notest; echo $var) ###变量var值为notest，此是在子shell中有效
 
notest
 
$ echo $var ###父shell中值仍为test
 
test
 
$ { var=notest; echo $var;} ###注意左括号和var之间要有一个空格
 
notest
 
$ echo $var ###父shell中的var变量的值变为了notest
 
notest
 
$ { var1=test1;var2=test2;echo $var1>a;echo $var2;} ###输出test1被重定向到文件a中，
 
test2 ###而test2输出则仍输出到标准输出中。
 
$ cat a
 
test1
 
$ { var1=test1;var2=test2;echo $var1;echo $var2;}>a ###括号内命令的标准输出全部被重定向到文件a中
 
$ cat a
 
test1
 
test2
 
下面是一个脚步例子：
 
(
 
echo "1"
 
echo "2"
 
) | awk '{print NR,$0}'
 
4,几种特殊的替换结构：${var:-string},${var:+string},${var:=string},${var:?string}A,${var:-string}和${var:=string}
 
若变量var为空，则用在命令行中用string来替换${var:-string}，否则变量var不为空时，则用变量var的值来替换${var:-string}
 
如：
 
$ echo $newvar
 
$ echo ${newvar:-a}
 
a
 
$ echo $newvar ###变量newvar的值仍然是空，但上一命令行中${newvar:-a}被替换成了a
 
$ newvar=b
 
$ echo ${newvar:-a} ###变量newvar的值不为空时，此命令行中的${newvar:-b}被替换为$newvar，即b
 
b
 
$
 
对于${var:=string}的替换规则和${var:-string}是一样的，所不同之处是${var:=string}若var为空时，用string替换${var:=string}的同时，把string赋给变量var：
 
$ echo $newvar
 
$ echo ${newvar:=a}
 
a
 
$ echo $newvar ###变量newvar被赋值为a，同时${newvar:=a}被替换成a
 
a
 
$ echo ${newvar:=b} ###变量newvar不为空(其值已被赋为a)，则${newvar:=b}被替换为newvar的值(即b)
 
a
 
$ echo $newvar
 
a
 
${var:=string}很常用的一种用法是，判断某个变量是否赋值，没有的话则给它赋上一个默认值。
 
如设置默认的编辑器：
 
PHP 代码:
 
echo You use editor: ${EDITOR:=/bin/vi}
 
B,${var:+string}
 
${var:+string}的替换规则和上面的相反，即只有当var不是空的时候才替换成string，若var为空时则不替换或者说是替换成变量 var的值，即空值。(因为变量var此时为空，所以这两种说法是等价的)
 
$ echo $newvar
 
a
 
$ echo ${newvar:+b}
 
b
 
$ echo $newvar
 
a
 
$ newvar=
 
$ echo ${newvar:+b}
 
$
 
C,${var:?string}
 
替换规则为：若变量var不为空，则用变量var的值来替换${var:?string}；若变量var为空，则把string输出到标准错误中，并从脚本中退出。我们可利用此特性来检查是否设置了变量的值。
 
$ newvar=
 
$ echo ${newvar:?没有设置newvar的值}
 
bash: newvar: 没有设置newvar的值
 
$ newvar=a
 
$ echo ${newvar:?没有设置newvar的值}
 
a
 
$
 
补充扩展：在上面这五种替换结构中string不一定是常值的，可用另外一个变量的值或是一种命令的输出。
 
$ echo ${var:-`date`}
 
日 3月 6 02:10:39 CST 2005
 
$ echo ${var:-$(date)}
 
日 3月 6 02:11:46 CST 2005
 
$ a=test
 
$ echo ${var:-$a}
 
test
 
$
 
5.POSIX标准的扩展计算:$((exp))这种计算是符合C语言的运算符，也就是说只要符合C的运算符都可用在$((exp))，甚至是三目运算符。
 
注意：这种扩展计算是整数型的计算，不支持浮点型.若是逻辑判断，表达式exp为真则为1,假则为0。
 
$ echo $((3+2))
 
5
 
$ echo $((3>2))
 
1
 
$ echo $((25<3 ? 2:3))
 
3
 
$ echo $var
 
$ echo $((var=2+3))
 
5
 
$ echo $var
 
5
 
$ echo $((var++))
 
5
 
$ echo $var
 
6
 
$
 
好了，上面的例子足够了，这也表明了这种扩展运算是很强大的。
 
6.四种模式匹配替换结构：${var%pattern},${var%%pattern},${var#pattern},${var##pattern}这四种结构的意义是：${var%pattern}和${var%%pattern}表示从最右边(即结尾)匹配的，${var#pattern} 和${var##pattern}从最左边(即开头)匹配的。其中${var%pattern}和${var#pattern}是最短匹 配，${var%%pattern}和${var##pattern}是最长匹配。只有在pattern中使用了通配符才能有最长最短的匹配，否则没有最 长最短匹配之分。
 
结构中的pattern支持通配符，*表示零个或多个任意字符，?表示零个或一个任意字符，[...]表示匹配中括号里面的字符，[!...]表示不匹配中括号里面的字符。
 
$ var=aabbbccbbdbb
 
$ echo ${var%b}
 
aabbbccbbdb
 
$ echo ${var%%b}
 
aabbbccbbdb
 
$ echo ${var#a}
 
abbbccbbdbb
 
$ echo ${var##a}
 
abbbccbbdbb
 
$ echo ${var%*b}
 
aabbbccbbdb
 
$ echo ${var%%*b}
 
$ echo ${var#a*}
 
abbbccbbdbb
 
$ echo ${var##a*}
 
$
 
上面是简单的例举四种模式匹配替换结构的用法。
 
•其他(见man bash中的Parameter Expansion)
 
${parameter/pattern/string}
 
Pattern substitution.  The pattern is expanded to produce a pat‐
 
tern  just  as in pathname expansion.  Parameter is expanded and
 
the longest match of pattern against its value is replaced  with
 
string.   If  pattern  begins with /, all matches of pattern are
 
replaced  with  string.   Normally  only  the  first  match   is
 
replaced.  If pattern begins with #, it must match at the begin‐
 
ning of the expanded value of parameter.  If pattern begins with
 
%,  it must match at the end of the expanded value of parameter.
 
If string is null, matches of pattern are deleted and the / fol‐
 
lowing pattern may be omitted.  If parameter is @ or *, the sub‐
 
stitution operation is applied to each positional  parameter  in
 
turn,  and the expansion is the resultant list.  If parameter is
 
an array variable subscripted with  @  or  *,  the  substitution
 
operation  is  applied  to each member of the array in turn, and
 
the expansion is the resultant list.
 
(( )) ：一对圆括号有两个地方用到。
 
1，for循环，
 
for (( expr1 ; expr2 ; expr3 ))
 
这里一对双括号里边的表达式，GNU的文档指出，expr1支持 Shell Arithmetic；expr2不为0时，expr3被赋值且语句执行。说的很麻烦，还要花时间搞清楚什么是Shell Arithmetic。其实一言以蔽之，支持数字条件。比如：
 
for (( a=0 ; a<10 ; a++ )); do echo $a; done
 
会输出 0 1 2 3 (带换行哦~~~)
 
2，数学表达
 
(( )) 和 $(( ))
 
(( )) 的用法与let一样，就不用多解释了吧~~~
 
$(( ))就是把计算结果拿出来，可以用在双引号里边，比如：
 
echo "1+2=$(( 1 + 2 ))"
 
会输出 1+2=3
 
( )：一个圆括号
 
在for循环里，跟C语法一样一样的。
 
或者是子程序，返回整个里边表达的返回值。里边的变量都是局部的，修改不会带到外边。举例子
 
a=1
 
(a=3; echo $a)
 
echo a
 
结果是 3 1
 
还有个就是圈数组。。。这个就没神马意思了
 
[ ]：一个方括号，是bash的命令，查man手册是可以查到的，跟test一样，在手册里可以看到很多用法。比如-b -c -gt -eq 什么的很多，还有用-a表示与，-o表示或等等
 
[[ ]]：一对方括号是一个方括号的加强版，则是Shell的保留字，里边支持了 || && 等等这些符号。一般我喜欢用这个
 
还有相对复杂的 { }
 
几个用处，区分变量，如：
 
var=abcd; echo ${var}EFG;
 
这样，Bash就不会认为变量是varEFG了
 
还有用来截取字符串的 ${ }语法比较灵活多变，这里不做多解释，大家有兴趣可以自己去搜搜资料，一般我脚本用到的字符串处理，这个都能搞定了。
 
代码块。用来区分代码的，但是跟( )有个区别，就是在末尾要加上 ;
 
1．()
 
在子shell中运行
 
(a=1);echo $a，结果是空，因为a=1不是在当前shell中运行的(a=1);(echo $a)也是空的。不在同一个子shell中
 
数组的赋值，见最后的补充
 
2.(())
 
表达式计算
 
a=1;((a++)); echo $a，这时a就是2了。
 
3.()
 
进程代入，可以把命令的执行结果当成文件一样读入
 
比如comm前一般需要sort，那就可以这样comm 
 
或者是paste 
 
，和管道差不多，但是支持多个输入。
 
4.$()
 
$(cmd) 执行cmd的结果，比如cmd是echo ls，那么就是执行ls，比如file$(which bash)，which bash的结果是/bin/bash，所以file $(which bash)等于file /bin/bash。如果你$(ls)，而且你的当前目录下只有a b两个文件，那么就是执行a b，然后系统会提示，命令没找到。
 
5.$(())
 
表达式扩展，和(())很相似，但是这个是有点不同，$(())不能直接$((b++))，b=1;echo $((++b))这时b等于2，显示的也是2，b=1;echo $((b++))这时b等于2，显示的是1.
 
6.[]和[[]]
 
[]就是 test，[]和[[]]都是条件表达式，不过[[]]有比[]高的容错性，如果a为空，那么[ $a -eq 0 ]会报错，但是[[ $a -eq 0 ]]不会，所以一般都会使用[[]]或者是[ "$a" -eq 0 ]，[[]]支持的功能也比[]多，比如[[ aaa =~a{3} ]]，
 
[] 还有一种用途，如果你的当前目录下有a1-a9九个文件，你可以用a[1-9]来替代这九个文件。有点需要注意，你不能用a[1-20]来代替a1- a20，必须要a[1-9] a1[0-9] a20。
 
7.$[]
 
$(())的过去形式，现在已经不建议使用
 
8.{}
 
{1..30} 就是1-30，或者是/{,s}bin/表示/bin/和/sbin/，ab{c,d,e}表示abc、abd、abe
 
9.${}
 
变量，用法很多，可以查看man bash。
 
先写这些，以后想到再补充吧。
 
补充：()同时也是数组的赋值，比如a=(1 3 5)，那么${a[0]}=1;${a[1]}=3;${a[2]}=5，需要注意的是，下标是从0开始的
 
Shell中的括号有其特殊的用法, 现总结如下:
 
1. 符号$后的括号
 
${a} 变量a的值, 在不引起歧义的情况下可以省略大括号.
 
$(cmd) 命令替换, 结果为shell命令cmd的输出, 和`cmd`效果相同, 不过某些Shell版本不支持$()形式的命令替换, 如tcsh.
 
$((exp)) 和`expr exp`效果相同, 计算数学表达式exp的数值, 其中exp只要符合C语言的运算规则即可, 甚至三目运算符和逻辑表达式都可以计算.
 
2. 多条命令执行
 
(cmd1;cmd2;cmd3) 新开一个子shell顺序执行命令cmd1,cmd2,cmd3, 各命令之间用分号隔开, 最后一个命令后可以没有分号.
 
{ cmd1;cmd2;cmd3;} 在当前shell顺序执行命令cmd1,cmd2,cmd3, 各命令之间用分号隔开, 最后一个命令后必须有分号, 第一条命令和左括号之间必须用空格隔开.
 
对{}和()而言, 括号中的重定向符只影响该条命令, 而括号外的重定向符影响到括号中的所有命令.
 
3. 双括号的特殊用法
 
(()) 增强括号的用法, 常用于算术运算比较. 双括号中的变量可以不使用$符号前缀, 只要括号中的表达式符合C语言运算规则, 支持多个表达式用逗号分开.
 
比如可以直接使用for((i=0;i<5;i++)), 如果不使用双括号, 则为for i in `seq 0 4`或者for i in {0..4}.
 
再如可以直接使用if (($i<5)), 如果不使用双括号, 则为if [ $i -lt 5 ].
 
[[]] 增强方括号用法, 常用于字符串的比较. 主要用于条件测试, 双括号中的表达式可以使用&&, ||, 等C语言语法.
 
比如可以直接使用if [[ $a != 1 && $a != 2 ]], 如果不适用双括号, 则为if [ $a -ne 1] && [ $a != 2 ]或者if [ $a -ne 1 -a $a != 2 ].