有关python&&c++的散碎的一些知识点_随时更新

#————————1、range()函数————————#

range函数原型：range（start， end， scan)

参数含义：

           start:计数的开始位置，默认是从0开始。

           end: 计数的结束位置

           scan：每次跳跃的间距，默认为1。

当range(a)参数中只有一个参数时，系统会默认从0开始计数，直到a结束

当range(a,b)有两个参数时，系统会从a开始计数，直到b结束

当range(a,b,c)有三个参数时，系统会从a开始计数，步进为c，直到b结束，其中c可以为负值，表示递减；c也可以为正值，表示递增

           比如range(1,10,2)表示1,3,5,7,9

           比如range(4,-4,-2)表示4,2,0，-2，-4

#————————2、len(lst)  #如果lst是一个列表，那么len(lst)表示这个列表的长度————————#

#————————3、生成器调用法则————————#

   定义生成器的另一种方法：如果一个函数定义中包含yield关键字，那么这个函数就不再是一个普通函数，而是一个生成器函数

#生成器要懂的东西
# 这里，最难理解的就是生成器和函数的执行流程不一样。函数是顺序执行，
# 遇到return语句或者最后一行函数语句就返回。而变成生成器函数，在每次调用next()的时候执行，
# 遇到yield语句返回，再次执行时从上次返回的yield语句处继续执行。

#————————4、正则模块re中findall和research的区别————————#

# 1、findall():所有结果都返回到一个列表里
# 2、search():返回匹配到第一个对象，改对象可以调用group方法
例：

# ret13 = re.findall('[^t]','12tYas') #匹配除了t意外的元素
# print(ret13) #打印['1', '2', 'Y', 'a', 's']

# ret = re.search('haijing','fjakslebhaijing') #ret为一个对象
# print(ret.group())  #打印haijing

5、pycharm中将TAB键改为4个空格键方法：
  file--->setting,选择Editor--->python，如下图所示：

 #————————6、自己写的python代码如何让被人也能用————————#

import os
import sys
BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) #将bin.py的爷爷级目录赋给BASR_DIR
sys.path.append(BASE_DIR) #把bin.py的爷爷级目录添加到python解释器的搜索路径中
#加上以上四行代码，这个程序移植到任何人的电脑上都可以执行
相关解释：

# import sys
# print(sys.path.append('D:\PyCharmPro\pro02\week03\day20\ATM'))
# print(__file__) #打印D:/PyCharmPro/pro02/week03/day20/ATM/bin/bin.py 这个为相对路径
# import os
# import sys
# print(os.path.abspath(__file__)) #把相对路径(D:/PyCharmPro/pro02/week03/day20/ATM/bin/bin.py)改为绝对路径(D:/PyCharmPro/pro02/week03/day20/ATM/bin/bin.py)
# print(os.path.dirname(os.path.abspath(__file__))) #找到bin.py的父亲级目录D:PyCharmPropro02week03day20ATMin
# print(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))#找到bin.py的爷爷级目录D:PyCharmPropro02week03day20ATM
# BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) #将bin.py的爷爷级目录赋给BASR_DIR
# sys.path.append(BASE_DIR) #把bin.py的爷爷级目录添加到python解释器的搜索路径中

#————————7、输出高亮显示————————#
   print("33[31;Hello world!33[0m")#将Hello world！高亮显示

#————————8、ATM中一些知识点(python中没有switch函数)，左边可以用右边代替————————#
 choice=input('>>')           menu_dic={'1':'accout','2':'repay','3':'witharaw','4':'transfer'}
 if choice=='1':              #字典中的account、repay、withdraw、transfer都是函数
    account_info()            flag = 0
 elif choice=='2':            while not flag:
    repay()                       choice = input('>>').strp #.strp表示去掉输入的所有空格
elif choice=='3':                 if choice in menu_dic:
    withdraw()                        menu_dic[choice](acc_data)  #acc_data是用户的信息,比如menu_dic[1](acc_data)=acccount(acc_data),此时用户的输入choice当做了字典的键,menu_dic[choice]即表示字典的值,而字典的值又全都是函数。
elif choice=='4':                 else:
    transfer()                        print('option doesn't exist)  #或print('33[31;option doesn't exist33[om')

#--------------9、有时候会加一个r的作用------------#
f=shelve.open(r'SHELVE_txt') #加r是保持单引号内的字母为原生字符串
f=shelve.open(r'D:\test.txt') #此处加r是为了防止	出现歧义

#--------------10、字典的get方法，以及用字典的键修改字典的值的方法------------#
d={'name': 'haijing', 'age': '18'}
print(d['name']) #打印haijing
d['name']='min' #修改键name对应的值
print(d.get('name'))  #打印min
print(d.get('sex','male')) #在字典d中如果没有键sex，则返回后面的male

#-----------11、目录的拼接-----------#

log_file = "%s/log/%s" %(settings.BASE_DIR,settings.LOG_TYPES[log_type])
#上一句中第一个%s是一个占位符，用后面的settings.BASE_DIR代替,第二个%s也是一个占位符,用后面的settings.LOG_TYPES[log_type]代替
#其中BASE_DIR是settings.py模块下的一个变量,LOG_TYPES是settings.py模块中的一个字典
#BASE_DIR对应atm_haijing级目录
#两个占位符之间的log对应atm_haijing下级目录log包
#LOG_TYPES字典中分别是两个.log文件
#所以第十九句就是要创建 atm_haijinglog	ransaction.log或atm_haijinglogaccess.log,到底创建哪个，取决于参数log_type
#log_type是函数的形参
#这样就可以随时在字典LOG_TYPES中添加别的函数类型，比如可以添加键为TXT,值为test.txt类型的文件,这样就可以了。

setting.py中的部分内容：

BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) #表示当前目录下的前两级目录

LOG_TYPES = {
    'transaction':'transaction.log',
    'accesss':'access.log'
}

#----------12目录的拼接（2）----------#

# import os
# base_dir = os.path.dirname(__file__) #将当前文件的路径赋值给base_dir
#path = os.path.join(base_dir,'123.txt')  #路径的拼接
# 获取文件拼接后的路径</code>

#----------类_方法_对象的基本知识----------#

class Foo:          #Foo是类名
       country = '中国'  #静态字段 可在最下面用Foo.country 调用
    def bar(self,name):  #普通方法 self是对象
        self.name=name  #普通字段  可用self.name或obj.name调用
        print('bar')

    @staticmethod  #只要加这一句装饰器，下班的sta就是静态方法
    def sta1():  #静态方法中可以不加self,调用时也不加参数，可以用Foo.sta()方法调用
        print('sta')
    @staticmethod  #只要加这一句装饰器，下班的sta就是静态方法
    def sta2(a1,a2):  #静态方法中可以不加self,调用时也不能加参数，可以用Foo.sta()方法调用
        print(a1,a2)
obj = Foo()  #obj也是对象，或者中间人
obj.bar()  #调用普通方法
Foo.sta1()  #调用不含参数的静态方法
Foo.sta2(1,2) #调用含有参数的静态方法
#调用字段，不加括号；调用方法，必须加括号。不如self.name或obj.name  obj.bar()

#----------pycharm最初设置方法----------#
1、设置字体大小


2、pycharm中自动写上日期和姓名的方法


3、pycharm中设置代码自动补全方法

#————————————对列表进行索引和切片取值————————————#  *****

li = [11,22,33,44,55,66,77,88,99,1010]

li[3]  #取出第四个值

li[0:3]    #取出前四个值

#----------------------------迭代器和可迭代对象 以及for循环----------------------------------#

i = iter([11,22,33])  #i就是迭代器
li=[11,22,33]  #li是可迭代对象 
# print(i.next())
# print(i.next())  #注意 i.next是在python2中才有的,而目前用的是python3，所以会出错的
# print(next(i))  #这样才会正确的打印11 in python3
# print(next(i))  #打印22
# for r in i:  #如果i是可迭代对象,那么先对i进行iter()方法,再进行for循环；如果i本身就是迭代器了,那么就直接执行for循环
#     print(r)  #这样也可以打印11 22 33 代替next()方法

#----------lambda 函数的应用 传参数用的----------#  *****

a = lambda x,y,z:x+y+z
print(a(1,2,3))  #打印6

#----------回顾__call()__方法 ----------#
# class Foo:
#     def __init__(self):
#         pass
#     def __call__(self, *args, **kwargs):
#         pass
# obj = Foo() #默认去执行__init__(self)方法
# obj()   #默认去执行__call__(self, *args, **kwargs)方法

#回顾 (*)会把接收到的参数形成一个元组，而（**）则会把接收到的参数存入一个字典,区别就是传参数时**必须有名字

#----------普通方法和静态方法@staticthod,静态类@classmethod----------#
# class Foo:
#     def bar(self):  #普通方法 self是对象
#         print('bar')
#
#     @staticmethod  #只要加这一句装饰器，下班的sta1就是静态方法
#     def sta1():  #静态方法中可以不加self,调用时也不能加参数，可以用Foo.sta()方法调用
#         print('sta')
#     @staticmethod  #只要加这一句装饰器，下班的sta就是静态方法
#     def sta2(a1,a2):  #静态方法中可以不加self,调用时也不能加参数，可以用Foo.sta()方法调用
#         print(a1,a2)
#
#     @classmethod
#     def classmd(cls):   #用 @classmethod 创建静态类，注意cls不是self了，cls是当前类名
#         print('classmd')
# obj = Foo()
# obj.bar()
#
# Foo.sta1()  #打印sta  所以静态方法就可以不用创建对象用于那些不用创建对象的函数
# Foo.sta2(1,2)  #打印1 2

# Foo.classmd()  #打印 classmd 静态类可以这样直接用Foo调用，而不用去创建对象了

#--------------将一个类的对象，作为另一个类的参数--------------------#  *****

class F1():
    def __init__(self):
        self.name = 'haijing&min'
class F2():
    def __init__(self,a):
        self.ff = a
class F3():
    def __init__(self,b):
        self.dd = b
f1 = F1()
f2 = F2(f1)  #将F1()的对象作为F2中的参数，此时类F2中的__init__(self,a)方法的a就等于f1对象
print(f2.ff.name) #一个对象只能调用自己对应的类中的方法,所以f2只能后跟ff,即f2.ff = f1  f2.ff.name = f1.name
f3 = F3(f2)
print(f3.dd.ff.name) #因为上一行是定义的对象是f3,所以必须是f3.dd,而b=f2 self.dd=b,f3=self,所以有f3.dd=f2;再去找F2中的方法或字段,即f2.ff 即f3.dd.ff
#由上可知f2.ff=f1 所以f3.dd.ff=f1 所以f3.dd.ff.name='haijing&min'

#---------os命令之basename和stat命令-------------#
假如path是一个路径，path = pythonPro/day26/post.jpg

 file_name = os.path.basename(path) #basename的作用是取到path最后的文件名字 例此时filename=post.jpg
 file_size = os.stat(path).st_size  #拿到文件的大小，例post.jpg文件的大小
 当然在这之前要import os

#----------网络通信三要素：协议、ip地址、端口号---------------#

import socket
sk = socket.socket()  #创建一个socket对象s  默认参数为family=AE_INET即ipv4协议、type=SOCK_STRAM即TCP协议 此句即创建了通信协议
#还有type=SOCK_Dgram即UDP协议，family=AE_INET6  对应的是ipv6，family=AE_UNIX   Unix不同进程之间的通信

address = ('127.0.0.1',8000)   #设置一个元组,元组内放的是ip和端口号:8000

sk.bind(address)  #绑定ip和端口号,bind方法后跟的必须是一个元组
sk.listen(3)  #3表示服务端最多和三个客户端同时建立通信,但是传送信息的话只能是一个一个的来

#--------------if __name__ == '__main__'-------------------#

#比如在Foo.py中的最后有一句
# if __name__ == '__main__':
#     hello()           #其中hello是Foo.py中的一个方法，其中hello做测试用
在另一个文件中调用Foo这个模块时候
# import Foo 如果不加上if __name__ == '__main__': 那么import Foo就会去执行测试用的语句hello方法

#--------------time模块的使用-----------------#

import time
begin = time.time()
def foo():
    print('foo')
    time.sleep(1)  #睡1秒钟

end = time.time()
print(end-begin)  #打印程序执行的时间

import  datetime
print(datetime.datetime.now())  #2018-10-04 20:36:44.426046  常用*****

#-----------------类中参数传入时，要加self的原因------------------

class f1:
    def __init__(self,num):
        self.num = num  #执行t1=f1(1)时,这个self等于t1,将参数1传到t1的存储空间中去;执行t2=f1(2)时,这个self等于t2,将参数2传到t2的存储空间中去;故要加self,把变量不同对象的变量传入对应的空间中去
    def run(self):    
　　　　 print('running on number is:%s' %self.num)
        
t1 = f1(1)  #加上self之后，self就对应t1，所以此时1这个参数就会传入t1对应的存储空间中去
t2 = f1(2)  #加上self之后，self就对应t2，所以此时2这个参数就会传入t2对应的存储空间中去
t1.run()    #类中的run方法必须这样调用才会被执行，而类中的__init__方法不用调用就会被直接执行
t2.run()

#-----------------python中的pow函数和-----------------#
1、pow(x,y) 表示x的y次幂
2、pow(x,y,z)  表示x的y次幂再除以z的余数

#-----------------python读取图片方法-----------------#

#----------python && opencv &&matplotlib版本问题-----------#
python3.7.0和matplotlib2.2.3版本是兼容的
python3.5.1和opencv3.4.2是兼容的

#----------C++中cin输入返回值的问题-----------#

int golf[];  //定义一个int型数组
while(!(cin>>golf[i]))  //如果输入的是一个数字,cin表达式将为true,且会将该数字放入数组中；
                       //如果输入的为字母或符号,则cin表达式的返回值将为false,且不会将该字母或符号放入数组中
                       //cin返回值是true或false取决于接收的数组或变量的类型，如果数组或变量的类型为int，那么输入数字，返回true；否则返回false    
cin.clear();      //清空输入流中的字符
#------------c++接收键盘输入错误的处理方法----------#

while (!(cin >> golf[i])) //由于数组golf是int型数组，如果输入的是数字，cin>>golf[i]会返回true,并将该数字加入数组中
        { 　　　　　　　　　    //如果输入的是字母或符号，cin>>golf[i]会返回false,且不会将输入的字母或符号放入数组中
          cin.clear(); //如果输入了字母或符号,那么cin流中就会设置一个错误标志(failbit被置1)
                //cin.clear()就是让failbit位置为0，使cin可以正常使用
          while (cin.get() != '
') //假如输入的是123abc456，cin>>golf[i]会一个一个的接收,把123存入前三个位置还是没错的,
            continue; //但是当轮到输入流中的a输入到数组时,就会执行cin.clear(),由于此时还没有执行到换行符,
                  //那么继续去判断输入流中的东西是否为数字,如果不是，那么继续去执行cin.clear(),并判断是否
                  //到了输入流中的换行符(回车)，如果没有，那么继续去判断输入流中的东西是否为数字，一直循环
                  //直到遇到了换行符,那么去执行cout << "Please enter a number：";
          cout << "Please enter a number：";
        }

#------break和continue的用法：都是相对他们上一个while循环来说的------#

#----------------c++中的换行符 和回车符 --------------------------#

换行符 是使光标转到下一行，进行输入输出

回车符 是擦除本行所有内容，光标回到本行第一个字符开始输出

#------------------cin、cin.get()和cin.get(ch)的区别---------------------#

• cin

        cin接收输入时，会忽略掉空格和换行符

　　 cin输入结束的条件：Enter、Space、Tab。cin对这些结束符的处理：丢弃缓冲区中这些字符。

• cin.get()

　　不会忽略掉空格和换行符

• cin.get(数组名)

　　不会忽略掉空格和换行符

• cin.getline(char* str,int n)

　　 接收一行输入,并输入到str为地址的数组中，接收的数目为 n

 #-------------c++指针相关----------------#

01.常规变量和指针都是常规的，改变任何一个的值，其余一个的值也会相应的改变

#include <iostream>
void main()
{
    using namespace std;

    int age = 20;  //定义一个常规变量
    int* pt = &age;  //定义一个指针，并使该指针指向age的地址

    age = age + 1;
    cout << "修改age的值,显示*pt，结果是：" << *pt << endl;  //显示21
    *pt = *pt + 1;
    cout << "修改*pt的值,显示age,结果是：" << age << endl;  //显示22

    system("pause");
}

执行结果为：

02.变量是常规的，指针是静态的(const)，则指针的值不能修改(即*pt=*pt+1是不合法的),此时修改age的值 *pt的值也是相应的改变的

      虽然不能修改pt所指向的值(这里为20)，但是不能防止修改pt的值，也就是说可以将一个新地址赋给pt，此时仍然不能修改pt所指向的值

#include <iostream>
void main()
{
    using namespace std;

    int age = 20;  //定义一个常规变量
    const int* pt = &age;  //定义一个指针，并使该指针指向age的地址

    age = age + 1;
    cout << "修改age的值,显示*pt，结果是：" << *pt << endl;  //显示21

    system("pause");
}

执行结果：

03.变量和指针都是静态的，此时二者均不可修改数据，此处就不再添加代码

04.注意：变量是静态的(const),而指针是常规的，是不合法的！！

 #-------------------cout输出指针字符串------------------#

char flower[10] = "rose";
cout<<flower<<"s are beautiful "; //打印roses are beautiful
//注意在cout和多数c++中，char数组名、char指针以及用引号括起来的字符串常量都被解释为字符串第一个字符的地址*****
//如果给cout一个 字符 的地址，那么cout将从该字符开始打印，直到遇到空字符，而不是打印一个地址

//但是上述代码并不会吧真个字符串的地址发给cout，而只是发送第一个字符的地址给cout，这意味着对于数组中的字符串、用引号括起来的
//字符常量以及指针所描述的字符串。处理的方式都是一样的，都将传送第一个字符的地址

#-----------字符串的几种声明方法---------------#

/*
表示字符串的方式有三种：
01)char数组 char cat[4] = {'a','s','d',''}; 注意必须是以空字符结尾，否则不是字符串
02)用引号括起来的字符串常量(也称字符串字面值) char ghost[15] = "galloping";
03)设置为字符串地址的char指针 char* str = ghost; 将ghost数组的第一个元素的地址赋给指针str
    字符串指针的使用方法和使用数组是一样的

    注意类似的指针字符串的定义是不被允许的：char* str = "matlan";  可以修改为const char* str = "matlan";

04)用string定义的字符串 string str2 = "matlab"; 使用方法和使用数组是一样的

*/

 /*--------------------  指针和const  ------------------*/
//01)常规变量地址赋给const指针
//既可以使用age来修改age的值,指针pt也可以修改值(指向其他变量)，但是不可以通过*pt来修改值
　　int age = 20;
　　const int* pt = &age;  //valid
　　*pt = 19;  //invalid
　　age = 19;  //valid
//02)将const变量的地址赋给const指针
//变量或者是指针都不可以修改值
　　const int age = 20;
　　const int* pt = &age;  //valid

//03)将const变量的地址赋给常规指针----不被允许的！！
//如：
　　const float g_earth = 1.63;
　　float* pm = &g_earth;  //invalid
//假如将g_earth的地址赋给常规指针，那么可以使用指针pm来修改g_earth的值,
//则使定义g_earth时使用的const很荒谬

 #--------------------递增和递减运算符----------------------#

int x = 5;
int y = ++x; //x=6,y=6 修改后使用

int a = 5;
int b = a++; //b=5,a=6 使用后修改

int i = 5;
while(i-- >0)
01)由于i--是先使用后修改，即先判断i=5大于0，然后再将i减1，最后进入循环
02)最后i=1，还是先去判断i>0，成立，再将i减1，并进入循环

#------------------直接成员运算符(句点)和间接成员运算符(->)------------#

//间接成员运算符与指向结构(sturct)或联合(union)的指针一起使用 *****
struct stable
{
int year;
double price;
};
stable sta1,sta2; //声明两个结构
sta1.year = 1994; //使用直接成员运算符进行赋值

stable* pa = &sta2;  //pa指向结构sta2
pa->year = 1995;   //使用间接成员运算符进行赋值

 #-----子函数没有返回值，但是子函数可以返回该子函数执行信息的一个很好的例子-----#

用到了结构和指针，子函数有两个形参，一个形参用来存放要使用的数据的地址，另外一个形参用来存储子函数执行后修改了的数据的地址

因此可以在转函数中直接使用第二个形参(此例程第二个形参都一个结构的地址)

另外i如果一个指针指向了一个结构，那么用该指针访问结构中的成员的时候，此时应该用间接成员运算符(->),而不是直接成员运算符(句点)

#include <iostream>
#include <cmath>

using namespace std;
struct polar    //定义新结构类型,可以用该结构类型去定义子函数、变量和子函数中的参数
{
    double distance;
    double angle;
};
struct rect  //垂直坐标系
{
    double x;
    double y;
};

void rect_to_polar(const rect* pxy,polar* pda);
//第一个指向rect的指针存储直角坐标系的数据
//第二个指针指向存储角坐标系的数据  
//该子函数的目的是要将直角坐标系的数据转换为角坐标系的数据,因此要将直角坐标系的数据设置为const
//且该子函数没有返回值,是修改pda指向的存储区域,在主函数中可以直接使用传给pda的那个结构
//使用指针,使函数能够对原始指针进行操作

void show_polar(const polar* pda);  //声明一个无返回值的子函数,该函数的参数为polar型结构

int main()
{

    rect rplace; //用新的结构类型rect去定义一个结构rplace
    polar pplace;  //用新的结构类型polar去定义一个结构rplace

    cout << "请输入直角坐标系的x和y值：";
    while (cin >> rplace.x >> rplace.y)  //由于结构中的x和y都是double型变量,所以输入除数字以为的都会退出循环
    {
        rect_to_polar(&rplace, &pplace);  //传入两个结构的地址进去,在主函数中可以直接使用pplace结构
        //&rplace是对rplace结构中的数据进行使用,然后存储在&pplace处;
        //所以在主函数中可以直接使用pplace结构
        show_polar(&pplace);  //再将返回的结构传入show_polar()子函数中去
        cout << "请再次输入垂直坐标系中的x和y的值(按除数字以外的字符退出该程序)：";
    }
    cout << "程序执行完毕" << endl;
    system("pause");
    return 0;
}

void rect_to_polar(const rect* pxy, polar* pda)
{
    pda->distance= sqrt(pxy->x * pxy->x + pxy->y * pxy->y);  //sqrt()求根号
    //polar_return.angle = atan2(xypos.x, xypos.y);  //atan2()求坐标x和y的角度
    pda->angle = atan2(pxy->y, pxy->x);  //这样求出的角度才对

}
void show_polar(const polar* pda)  //polar新结构类型定义的函数参数dapos
{
    const double rad_to_deg = 57.29577951;  //即 180°/Π

    cout << "您输入的点和原点之间的距离是：" << pda->distance << endl;  //使用间接成员运算符修改结构中的值
    cout << "您输入的点和x正半轴之间的角度是：" << pda->angle * rad_to_deg << endl;
}

 #------cin.getline(charr,20)和getline(cin,str)-----------#

01）相同点：都是读取行输入

02）不同点：cin.getline(charr,20)是c风格输入行，charr是一个char数组，20是可以接收输入的最多字符数

          getline(cin,str)是c++输入行，cin表示到哪里去查找输入,str是一个string类字符串

#-----char字符串数组和string类字符串计算字符个数的方法----------#

01)使用size()来计算string类字符串中字符的多少 如str2是一个string类字符串 str2.size()返回str2中字符的多少
02)使用strlen来计算char类字符串数组中字符的多少  如str1是一个char类字符串数组 strlen(str1)返回str1中字符的多少 

 #-----字符串特有的性质-------#

01)c风格字符串具有一种特殊的性质：以空字符结尾，空字符被写作，cout在遇到空字符则停止显示
02)在确定存储字符串所需的最短数组时，别忘了将结尾的空字符计算在内
03) char str1='S'; //表示字符S，'S'只是83的另一种写法
04)char str2="S";  //会自动在S的后面加上空字符，表示字符S和，且"S"表示的是字符串所在的内存地址

05)字符串数组作为函数参数时，直接将字符串数组的名字写入子函数的括号内作为子函数的实参即可 

      在主函数调用如：subdivide(str,20,40,6);    //其中str是一个字符串数组,直接写字符串数组的名字就可以

06)用字符串数组作为形参的子函数声明的时候，就必须写全了 如：void subdivide(char ar[], int low, int high, int level); //声明一个递归函数

 #----------指针和数组，注意：[]的优先级比*高-----------#

*pd[3];   //  []的优先级比*高，所以c++编译器会认为该句的意思为: 创建创建一个数组，该数组包含了三个指针
(*pd)[3]; //  创建一个指针，该指针指向一个包含3个元素的数组

解析：对于(*pd)[3]，既然pd是一个指针，该指针指向数组，所以(*pd)[i]就是数组中的元素

          还要注意pa(它是一个数组名，表示数组内第一个元素的地址)和&pa的区别，&pa表示的是整个数组的地址

          即pa等价于&pa[0],是一个元素的地址，而&pa是整个数组的地址      **&pa == *pa == pa[0]

 

#-----------c++中的setf()和precision()-----------#

1.方法setf()让你能够设置各种格式化状态，

　eg1:   setf(ios_base::fixed)将对象置于使用定点表示法模式；  ios_base写成ios也可以

　eg2：setf(ios_base::showpoint)将对象置于显示小数点模式，即小数部分为0.

　eg3:  ios_base::floatfield是设置输出时按浮点格式，小数点后有6位数字

2.方法precision()指定显示多少位小数（假定对象处于定点模式下）

 　eg1:cout.precision(2)显示2位小数

3.fixed标志是以定点形式显示浮点数showpoint标志是强制显示小数点precision就是精度，表示输出多少小数位。

下面有些书中列出来的其他标志, 希望对你有用
showpos    正数前面加上+号
fixed 使用小数计数法
scientific 使用科学计数法
uppercase 使用大写字符
showbase  显示数字的进制
boolalpha    bool值使用字符表示 , true或者false
noboolalpha     bool使用0和1表示
left   靠左对齐
right  靠右对齐
internal 字符靠左对齐, 数字卡右对齐
#-------右值引用------#

C++11新增了另一种引用——右值引用。这种引用可以指向右值，是使用&&声明的：

double && rref = sqrt(36.0);
double && jref = 2.0*j + 18.5;

#----------typedef的用法-------------#
typedef double real;  //real为double的别名

 #--------两个const用法-----------#

01)如果全部使用全局变，那么会使程序不可靠，数据有可能会被破坏，为了保持数据数据完整性，可以使用const运算符
02)例如：
　　const char* const months[12] = //由于[]的优先级比*高，所以此句的意思是新建一个数组,该数组内包含12个指针
　　{
　　　　"January","February","March","April,"May",
　　　　"June","July","August","September","October",
　　　　"Novermber","December"
　　};
　　第一个const是防止字符串被修改，第二个const是确保数组中每个指针始终指向它最初指向的字符串

#---C++中的一些使用准则------#

 01)应尽可能的const引用和指针作为函数的形参

02)只要类方法(在类中定义的函数)不修改调用对象，就应该讲其声明为const
    声明方法为(假如有类Stock)：
　void show() const; //声明show()函数，保证不会修改调用对象
　同样函数的定义应该是这样的：
　void Stock::show() const //定义show()函数，保证不会修改调用对象
　{
　　　...
　}

#---------返回值是引用和非引用的问题-----------#

如果返回的参数是全局变量，那么返回值可以是引用

如果返回值是局部变量，那么返回值就不能是引用了

例如：

21 Time Time::Sum(Time & T)
22 {
23     Time s;  //新建一个TIme对象，用于作为该函数的返回值
24     s.minitue = minitue + T.minitue;
25     s.hour = hour + T.hour + s.minitue / 60; 
26     //hour是调用Sum()方法的对象中的数据,T.hour是作为实参传入的对象中的数据
27     //最后再加上调用对象的分钟数，和，作为实参传入的分钟数的和，然后取整
28     s.minitue = s.minitue % 60;  //对两个对象中数据的分钟数取余
29 
30     return s;
31 }
32 注意:Sum()函数的返回值不能是Time & (指向Time对象的引用),这是由于返回的对象是s，而s是一个在Sum()
33 中定义的局部变量，Sum()函数执行完毕后，s将会消失，返回一个消失的引用是不合适的
34 所以这里返回s对象的副本，之后在主函数中可以使用它 
35 以前函数的返回值可以为引用，是因为返回的对象均为从主函数中传入的对象，这些对象都是在主函数中定义的
36 所以可以返回，比如this指针那里，传入一个对象和this指针指向的调用类方法的对象
函数返回值的问题（变量生存期）：
1、子函数中定义的变量，生存期仅仅是在该函数内，是不可以作为返回值的，如：

//下面代码会出现什么问题？
char *GetMemory( void )
{ 
 char p[] = "hello world"; 
 return p; 
}
void Test( void )
{ 
 char *str = NULL; 
 str = GetMemory(); 
 printf( str ); 
}

//解析：对于如下语句
char p[] = "hello world"; 
return p; 
p[]数组为函数内的局部自动变量，在函数返回后，内存已经被释放。这是许多程序员常犯的错误，其根源在于不理解变量的生存期。  

2、在子函数中新疆的对象时可以作为返回值的，如图：

3、返回值为对象引用的情况，只能是在主函数中作为实参输入的对象，才可以作为引用返回

 #C++中的#include <new>

        在new的头文件中只包含6个重载的new和delete，和一些new的声明。iostream是C++中特定的输入输出流操作以及一些其他常用函数和操作符的声明。里面其实就是包含了new头文件的内容，一般只需要在C++程序开头加上"#include<iostream>"和 using namespace std;这两句代码就可以了。不需要再另外加上new。

       另外在C++中包含iostream头文件的做法有些微妙：带.h的和不带.h的iostream在使用时也是不一致的，带.h的一般作用域属于全局的，可以直接引用，但是不带.h的作用域属于std名字空间。建议直接使用不带.h的iostream并使用标准名字空间。这样比较符合标准而且少敲几个字。方便！

       C++作为C语言的更上一层，所以在很多方面都采取了兼容C语言的方式，这一点就属于其一。
但是如果只写#include<new>,当程序中出现输入输出的操作时，就会出现错误！

# anaconda+pycharm 安装新模块的方法和在pycharm中的配置方法

1、在开始中找到Anaconda Navigator并打开

2、创建新的环境并安装相应的模

3、在Anaconda Navigator安装相应的模块的具体方法

4、在pycharm中配置python编译器(对应与刚刚配置完毕的新环境)方法


URL
URL是Uniform Resource Location的缩写，译为“统一资源定位符”。通俗地说，URL是Internet上用来描述信息资源的字符串，主要用在各种WWW客户程序和服务器程序上，特别是著名的Mosaic。采用URL可以用一种统一的格式来描述各种信息资源，包括文件、服务器的地址和目录等。
URL的格式URL的格式由下列三部分组成：
第一部分是协议（或称为服务方式）；
第二部分是存有该资源的主机IP地址（有时也包括端口号）；
第三部分是主机资源的具体地址。，如目录和文件名等。
第一部分和第二部分之间用“：//”符号隔开，第二部分和第三部分用“/”符号隔开。第一部分和第二部分是不可缺少的，第三部分有时可以省略。