在Python程序中，你有时可以看到三个连续的双引号，那么它的作用是什么，在什么场景下使用呢？
 
作用一：进行多行注释
 
我们都知道Python中注释是井号 #，但是如果你需要描述多行注释的时候，就需要每行都写一个 #，或者，你可以采用连续的三个双引号，如下：
 
# 这是单行注释

"""
这是多行注释第一行
这是多行注释第二行
这是多行注释第三行
"""
 
作用二：定义多行字符串
 
为避免使用转义换行符 \n，通常会用在定义SQL语句的表达式中没有变量的时候，例如：
 
import pymysql
 
try:
    # 建立连接
    db = pymysql.connect(host='localhost', user='root', passwd='root', db='scraping')
    # 创建游标对象
    cur = db.cursor()
 
    # SQL建表语句
    sql_create_table = """CREATE TABLE CUSTOMER (
             FULL_NAME  CHAR(20) NOT NULL,
             AGE INT,
             SEX CHAR(1),
             BALANCE FLOAT )"""

    cur.execute(sql_create_table)

    # SQL 插入语句
    sql_insert = """INSERT INTO CUSTOMER (FULL_NAME,
             AGE, SEX, BALANCE)
             VALUES ('Mac Mohan', 20, 'M', 2000)"""
 
    try:
        # 执行sql语句
        cur.execute(sql_insert)
        # 提交到数据库执行
        db.commit()
    except:
        # 如果发生错误则回滚
        db.rollback()
 
finally:
    # 关闭数据库连接
    cur.close()
 
以上述建表语句为例，如果不使用三个双引号，则需要用换行符进行定义，如下：
 
    # SQL建表语句
    sql_create_table = "CREATE TABLE CUSTOMER (\nFULL_NAME  CHAR(20) NOT NULL,\nAGE INT,\nSEX CHAR(1),\nBALANCE FLOAT )"
 
是不是可以明显感觉到采用多行字符串定义可以让程序更加清晰，规整，可读性更好！

一, 相同点:
 单引号和三引号 , 双引号都可以表示字符串,但三者又有其他不同的用处.
 
二, 不同点:
 1,单引号和三引号可以和"#"一样表示注释,但单引号只能注释一行
 
 eg1:'你好
 		我也好'  (是错误的,因为单引号不能注释两行)
 eg2:'''你好
 	    我也好'''(正确,因为单引号可以注释多行)
 
2,双引号"“中可以嵌套单引号 ‘’ ,三引号’’’ ‘’'中可以嵌套双引号”"和单引号 ‘’ ,
 也即引号多的可以嵌套少的,但引号少的不可以嵌套多的,如单引号中无法嵌套双引号.
 
eg:''' 你好 "帅啊" , '你说是吗?', 是的 '''
就是一个三引号中嵌套双引号与单引号的例子

 
 
 C++ 双冒号开头的语法是什么意思？
 
 
 
  2015-01-15 14:30
  sapient_82 
  |
   浏览 229 次
 
 
 
 
   
  编程语言软件
 
 
 
namespace IceDelegateM
{

namespace Demo
{

class Hello : virtual public ::IceDelegate::Demo::Hello,
              virtual public ::IceDelegateM::Ice::Object
{
public:

    virtual void sayHello(const ::Ice::Context*, ::IceInternal::InvocationObserver&);
};

}

}

我知道：：开头可以代表全局的意思，但我理解是可以在方法和变量的前面，表示是全局方法或是全局变量。但上面的代码里，：：是在命名空间或类名前，后面并不是跟方法或变量。例如：“class Hello : virtual public ::IceDelegate::Demo::Hello”
 
 我有更好的答案 
 
 
 
 
  
 
   
 
    分享到： 
    
 
     
     
     
     
    
 
   
 
  
 
 
 
 
 
 

  
  举报| 2015-01-15 14:41
  
  网友采纳
 
 
 
 
  
 
  
 
  
 
   
命名空间限定。
std::string 
表示std命名空间下的 string类。
直接::开始，表示顶层命名空间（全局变量）std::string -> ::std::string 这样也可以。
::和 文件路径的 / 可以对照理解。

linux下面没有盘符之分。  只有一个盘，所以也就没有C,D,E,F这种了。
/usr/share/abc.txt            abc.txt 位于 /usr/share目录下
/abc.txt                           abc.txt直接位于硬盘下。第一个/就代表硬盘根目录。
 
   
 
    

      追问：
    
 
    
 
     
：：开头如果是全局变量或函数的话，后面应该跟着变量或函数。但是上面的例子后面跟的是域名或类名，我觉得不应该是全局的意思。
你说的代表着根目录，到是有些像，可以这样理解吗？
 
    
 
   
 
   
 
    

      追答：
    
 
    
 
     
如果函数放在全局，就是全局函数
如果变量定义在全局，就是全局变量
如果一个命名空间放在全局，就是全局命名空间。

std是一个全局命名空间  ios是一个内部命名空间（位于std下）
所以引用方式如下
::std::ios::ostream
::std::string

当没有冲突的时候，全局的::（也就是第一个）可以省略






C++11 tuple
      

      

       

        
tuple元组定义了一个有固定数目元素的容器,其中的每个元素类型都可以不相同,这与其他容器有着本质的区别.是对pair的泛化。
        
首先来介绍元组的创建和元组元素的访问。通过make_tuple()创建元组，通过get<>()来访问元组的元素。通过下面这段程序来认识这两个函数的用法：
        
#include <iostream>
        
#include <tuple>
        
#include <functional>
        
 
        
int main()
        
{
        
    auto t1 = std::make_tuple(10, "Test", 3.14);
        
    std::cout << "The value of t1 is "
        
              << "(" << std::get<0>(t1) << ", " << std::get<1>(t1)
        
              << ", " << std::get<2>(t1) << ")\n";
        
 
        
    int n = 1;
        
    auto t2 = std::make_tuple(std::ref(n), n);//ref表示引用
        
    n = 7;
        
    std::cout << "The value of t2 is "
        
              << "(" << std::get<0>(t2) << ", " << std::get<1>(t2) << ")\n";
        
}
        
运行结果为：
        
The value of t1 is (10, Test, 3.14)
        
The value of t2 is (7, 1)
        
 
        
接下来介绍tie()函数。 tie()函数可以将变量连接到一个给定的tuple上，生成一个元素类型全是引用的tuple,相当于make_tuple(ref(a),ref(b),…)。可以通过tie()函数的使用方便的对tuple进行“解包”操作。看下面的代码：
        
#include <iostream>
        
#include <tuple>
        
 
        
int main ()
        
{
        
  int myint;
        
  char mychar;
        
  float myfloat;
        
 
        
  std::tuple<int,float,char> mytuple;
        
 
        
  mytuple = std::make_tuple (10, 2.6, 'a');          // packing values into tuple
        
 
        
  //std::tie (myint, std::ignore, mychar) = mytuple;   // unpacking tuple into variables  【1】
        
  std::tie (myint,myfloat, mychar) = mytuple;
        
 
        
  std::cout << "myint contains: " << myint << std::endl;
        
  std::cout << "mychar contains: " << mychar << std::endl;
        
  std::cout << "myfloat contains: "<< myfloat <<std::endl;
        
 
        
  std::get<0>(mytuple) = 100;//修改tuple的值
        
 
        
  std::cout <<"After assignment myint contains: "<< std::get<0>(mytuple) << std::endl;
        
 
        
  return 0;
        
}
        
运行结果：
        
myint contains: 10
        
mychar contains: a
        
myfloat contains: 2.6
        
After assignment myint contains: 100
        
注：正如【1】处我们可以使用std::ignore,从而不用关联tuple中的第二个元素.
        
 
        
最后介绍一个tuple_cat()函数，通过该函数可以将多个tuple连接起来形成一个tuple（注：在VC11中只能连接两个tuple并不是真正的多个tuple）。
        
#include <iostream>
        
#include <utility>
        
#include <string>
        
#include <tuple>
        
 
        
int main ()
        
{
        
 
        
  std::tuple<float,std::string> mytuple (3.14,"pi");
        
  std::pair<int,char> mypair (10,'a');
        
 
        
  auto myauto = std::tuple_cat ( mytuple, mypair );
        
 
        
  std::cout << "myauto contains: " << std::endl;
        
  std::cout << std::get<0>(myauto) << std::endl;
        
  std::cout << std::get<1>(myauto) << std::endl;
        
  std::cout << std::get<2>(myauto) << std::endl;
        
  std::cout << std::get<3>(myauto) << std::endl;
        
 
        
  return 0;
        
}
        
运行结果：
        
 
        
myauto contains:
        
3.14
        
pi
        
10
        
a
       
       

        make it simple, make it happen
       
      
1、

 

作用域符号::的前面一般是类名称，后面一般是该类的成员名称，C++为例避免不同的类有名称相同的成员而采用作用域的方式进行区分
如：A,B表示两个类，在A,B中都有成员member。那么
      A::member就表示类A中的成员member
      B::member就表示类B中的成员member

 

2、

 

全局作用域符号：当全局变量在局部函数中与其中某个变量重名，那么就可以用::来区分如：

char    zhou;    //全局变量

void    sleep（）

｛

      char    zhou;    //局部变量

      char(局部变量) = char(局部变量) *char(局部变量) ; 

     ::char(全局变量) =::char(全局变量) *char(局部变量);

｝

 

3、

 

::是C++里的“作用域分解运算符”。比如声明了一个类A，类A里声明了一个成员函数voidf()，但没有在类的声明里给出f的定义，那么在类外定义f时，就要写成voidA::f()，表示这个f()函数是类A的成员函数。例如

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
class CA { 
public: 
  int ca_var; 
  int add(int a, int b); 
  int add(int a); 
};
 
//那么在实现这个函数时，必须这样书写： 
int CA::add(int a, int b) 
{ 
  return a + b; 
} 
 
//另外，双冒号也常常用于在类变量内部作为当前类实例的元素进行表示，比如: 
int CA::add(int a) 
{ 
  return a + ::ca_var; 
}
 
//表示当前类实例中的变量ca_var。
 
    
 
   
 
  
 
 
 

      刚开始学习C语言时没有注意过这个问题，最近看了狄泰软件的唐老师C进阶视频时发现这里面还有东西需要注意的，下面我讲下，希望对新人有所帮助(这里面讲的内容主要参考狄泰软件的唐老师C进阶教程中的单引号和双引号课题)
      单引号：单引号实际就是字符字面量，字符字面量就是字符(就是ASCII对应字符)，就是整数
     双引号：双引号实际就是字符串字面量，字符串字面量就是字符指针，就是字符首地址
下面通过几个代码来加深印象(感觉很多概念都必须通过代码反应，不然印象不深刻，时间一长就忘了)
平台：ubuntu10  gcc编译器
#include <stdio.h>
int main()
{
    char* p1 =  1 ;
    char* p2 = '1';
    char* p3 = "1";
    printf("%s, %s, %s", p1, p2, p3);
    printf('\n');
    printf("\n");

    return 0;
}
编译过程会出现警告，执行时会出现段错误，就是打印p1，p2，p3导致段错误
首先分析原因：p1 = 1，这样p1指针就指向内存0x00000001地址，p2 = '1' ,'1'字符值是0x31，所以p2指针就指向内存0x00000031地址，而p3 = “1”,“1”是字符串，所以p3就指向"1"字符串内存首地址
这里我们知道内存地址不是所有的地址都可以访问的，比如内存0x00000000首地址，就不能访问，所以p1和p2指针都是不对的，执行会报段错误，而p3指向保存"1"字符串首地址是正确的，因为"1"字符串是保存在内存允许访问的内存地址处的

printf("%s, %s, %s", p1, p2, p3);
我们把上面这一行屏蔽掉，再进行编译，执行，发现还是段错误
这会是

printf('\n');
这行段错误，这是因为printf函数，第一参数是字符串指针，只能接收字符串首地址，而这里传输的'1'字符是0x00000031,但是这里在内存地址是不允许访问的，所以又出现段错误，其实画成图片就很好理解了






从上面图片可以看出，只有从0x08048000内存地址开始之后才可以存储变量，访问变量，而上面地址是不允许访问的，访问就会出现段错误
现在看下下面代码有什么问题


从上面分析得出结论，C语言编译器允许字符串对字符进行赋值，但是没有任何意义，因为是把内存首地址赋给了字符了
下面再来分析一个程序
#include <stdio.h>
int main()
{
    char c = " ";
    while( (c == "\t") || (c == " ") || (c == "\n") )
    {
        scanf("%c", &c);
    }
    return 0;
}


发现没有输入，执行完了，什么都没有，来我们分析下
char c = "";字符串赋给了1个字符变量，相当于内存地址赋给了1个字符变量

while( (c == "\t") || (c == " ") || (c == "\n") )
这行是判断c字符是否等于" "字符串首地址，显然两个" "字符串是不会相等的，肯定存在不同的内存地址，肯定不会相同的，所以while括号里面执行为假，所以不会执行，那这里考察是什么知识点，实际它是把字符和字符串搞混了，理论程序应该是这样的
char c = ' ';
while((c == '\t') || (c == ' ')||(c == '\n'))
{
       scanf("%c",&c);
}
所以我们这会总结下：
1、C语言中单引号用来表示字符字面量的，字符字面量就是字符就是整数
2、C语言中双引号用来表示字符串字面量的，字符字面量就是字符指针，就是字符串首地址，是个地址
3、C编译器允许字符串对字符变量赋值，只能得到字符串首地址，没有任何意思
4、printf()函数的第一个参数是接收字符串首地址
5、内存的低地址空间不能在程序中随意访问