有關python&&c++的散碎的一些知識點_隨時更新
#————————一、range()函數————————#python
range函數原型：range（start， end， scan)ios
參數含義：c++
start:計數的開始位置，默認是從0開始。程序員
end: 計數的結束位置數組
scan：每次跳躍的間距，默認爲1。服務器
當range(a)參數中只有一個參數時，系統會默認從0開始計數，直到a結束網絡
當range(a,b)有兩個參數時，系統會從a開始計數，直到b結束app
當range(a,b,c)有三個參數時，系統會從a開始計數，步進爲c，直到b結束，其中c能夠爲負值，表示遞減；c也能夠爲正值，表示遞增socket
好比range(1,10,2)表示1,3,5,7,9ide
好比range(4,-4,-2)表示4,2,0，-2，-4
#————————二、len(lst) #若是lst是一個列表，那麼len(lst)表示這個列表的長度————————#
#————————三、生成器調用法則————————#
定義生成器的另外一種方法：若是一個函數定義中包含yield關鍵字，那麼這個函數就再也不是一個普通函數，而是一個生成器函數
#生成器要懂的東西
# 這裏，最難理解的就是生成器和函數的執行流程不同。函數是順序執行，
# 遇到return語句或者最後一行函數語句就返回。而變成生成器函數，在每次調用next()的時候執行，
# 遇到yield語句返回，再次執行時從上次返回的yield語句處繼續執行。
#————————四、正則模塊re中findall和research的區別————————#
# 一、findall():全部結果都返回到一個列表裏
# 二、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
五、pycharm中將TAB鍵改成4個空格鍵方法：
file--->setting,選擇Editor--->python，以下圖所示：
#————————六、本身寫的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:\PyCharmPro\pro02\week03\day20\ATM\bin
# print(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))#找到bin.py的爺爺級目錄D:\PyCharmPro\pro02\week03\day20\ATM
# BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) #將bin.py的爺爺級目錄賦給BASR_DIR
# sys.path.append(BASE_DIR) #把bin.py的爺爺級目錄添加到python解釋器的搜索路徑中
#————————七、輸出高亮顯示————————#
print("\033[31;Hello world!\033[0m")#將Hello world！高亮顯示
#————————八、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('\033[31;option doesn't exist\033[om')
#--------------九、有時候會加一個r的做用------------#
f=shelve.open(r'SHELVE_txt') #加r是保持單引號內的字母爲原生字符串
f=shelve.open(r'D:\\test.txt') #此處加r是爲了防止\t出現歧義
#--------------十、字典的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
#-----------十一、目錄的拼接-----------#
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_haijing\log\transaction.log或atm_haijing\log\access.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最初設置方法----------#
一、設置字體大小
二、pycharm中自動寫上日期和姓名的方法
三、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函數和-----------------#
一、pow(x,y) 表示x的y次冪
二、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++接收鍵盤輸入錯誤的處理方法----------#
1 while (!(cin >> golf[i])) //因爲數組golf是int型數組，若是輸入的是數字，cin>>golf[i]會返回true,並將該數字加入數組中 2 { //若是輸入的是字母或符號，cin>>golf[i]會返回false,且不會將輸入的字母或符號放入數組中 3 cin.clear(); //若是輸入了字母或符號,那麼cin流中就會設置一個錯誤標誌(failbit被置1) 4 //cin.clear()就是讓failbit位置爲0，使cin能夠正常使用 5 while (cin.get() != '\n') //假如輸入的是123abc456，cin>>golf[i]會一個一個的接收,把123存入前三個位置仍是沒錯的, 6 continue; //可是當輪到輸入流中的a輸入到數組時,就會執行cin.clear(),因爲此時尚未執行到換行符, 7 //那麼繼續去判斷輸入流中的東西是否爲數字,若是不是，那麼繼續去執行cin.clear(),並判斷是否 8 //到了輸入流中的換行符(回車)，若是沒有，那麼繼續去判斷輸入流中的東西是否爲數字，一直循環 9 //直到遇到了換行符,那麼去執行cout << "Please enter a number："; 10 cout << "Please enter a number："; 11 }
#------break和continue的用法：都是相對他們上一個while循環來講的------#
#----------------c++中的換行符\n和回車符\r--------------------------#
換行符\n是使光標轉到下一行，進行輸入輸出
回車符\r是擦除本行全部內容，光標回到本行第一個字符開始輸出
#------------------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.常規變量和指針都是常規的，改變任何一個的值，其他一個的值也會相應的改變
1 #include <iostream> 2 void main() 3 { 4 using namespace std; 5 6 int age = 20; //定義一個常規變量 7 int* pt = &age; //定義一個指針，並使該指針指向age的地址 8 9 age = age + 1; 10 cout << "修改age的值,顯示*pt，結果是：" << *pt << endl; //顯示21 11 *pt = *pt + 1; 12 cout << "修改*pt的值,顯示age,結果是：" << age << endl; //顯示22 13 14 system("pause"); 15 }
執行結果爲：
02.變量是常規的，指針是靜態的(const)，則指針的值不能修改(即*pt=*pt+1是不合法的),此時修改age的值 *pt的值也是相應的改變的
雖然不能修改pt所指向的值(這裏爲20)，可是不能防止修改pt的值，也就是說能夠將一個新地址賦給pt，此時仍然不能修改pt所指向的值
1 #include <iostream> 2 void main() 3 { 4 using namespace std; 5 6 int age = 20; //定義一個常規變量 7 const int* pt = &age; //定義一個指針，並使該指針指向age的地址 8 9 age = age + 1; 10 cout << "修改age的值,顯示*pt，結果是：" << *pt << endl; //顯示21 11 12 system("pause"); 13 }
執行結果：
03.變量和指針都是靜態的，此時兩者均不可修改數據，此處就再也不添加代碼
04.注意：變量是靜態的(const),而指針是常規的，是不合法的！！
#-------------------cout輸出指針字符串------------------#
char flower[10] = "rose";
cout<<flower<<"s are beautiful\n"; //打印roses are beautiful\n
//注意在cout和多數c++中，char數組名、char指針以及用引號括起來的字符串常量都被解釋爲字符串第一個字符的地址*****
//若是給cout一個 字符 的地址，那麼cout將從該字符開始打印，直到遇到空字符\0，而不是打印一個地址
//可是上述代碼並不會吧真個字符串的地址發給cout，而只是發送第一個字符的地址給cout，這意味着對於數組中的字符串、用引號括起來的
//字符常量以及指針所描述的字符串。處理的方式都是同樣的，都將傳送第一個字符的地址
#-----------字符串的幾種聲明方法---------------#
/*
表示字符串的方式有三種：
01)char數組 char cat[4] = {'a','s','d','\0'}; 注意必須是以空字符結尾，不然不是字符串
02)用引號括起來的字符串常量(也稱字符串字面值) char ghost[15] = "galloping";
03)設置爲字符串地址的char指針 char* str = ghost; 將ghost數組的第一個元素的地址賦給指針str
字符串指針的使用方法和使用數組是同樣的
注意相似的指針字符串的定義是不被容許的：char* str = "matlan"; 能夠修改成const char* str = "matlan";
04)用string定義的字符串 string str2 = "matlab"; 使用方法和使用數組是同樣的
*/
//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若是一個指針指向了一個結構，那麼用該指針訪問結構中的成員的時候，此時應該用間接成員運算符(->),而不是直接成員運算符(句點)
1 #include <iostream> 2 #include <cmath> 3 4 using namespace std; 5 struct polar //定義新結構類型,能夠用該結構類型去定義子函數、變量和子函數中的參數 6 { 7 double distance; 8 double angle; 9 }; 10 struct rect //垂直座標系 11 { 12 double x; 13 double y; 14 }; 15 16 void rect_to_polar(const rect* pxy,polar* pda); 17 //第一個指向rect的指針存儲直角座標系的數據 18 //第二個指針指向存儲角座標系的數據 19 //該子函數的目的是要將直角座標系的數據轉換爲角座標系的數據,所以要將直角座標系的數據設置爲const 20 //且該子函數沒有返回值,是修改pda指向的存儲區域,在主函數中能夠直接使用傳給pda的那個結構 21 //使用指針,使函數可以對原始指針進行操做 22 23 void show_polar(const polar* pda); //聲明一個無返回值的子函數,該函數的參數爲polar型結構 24 25 int main() 26 { 27 28 rect rplace; //用新的結構類型rect去定義一個結構rplace 29 polar pplace; //用新的結構類型polar去定義一個結構rplace 30 31 cout << "請輸入直角座標系的x和y值："; 32 while (cin >> rplace.x >> rplace.y) //因爲結構中的x和y都是double型變量,因此輸入除數字覺得的都會退出循環 33 { 34 rect_to_polar(&rplace, &pplace); //傳入兩個結構的地址進去,在主函數中能夠直接使用pplace結構 35 //&rplace是對rplace結構中的數據進行使用,而後存儲在&pplace處; 36 //因此在主函數中能夠直接使用pplace結構 37 show_polar(&pplace); //再將返回的結構傳入show_polar()子函數中去 38 cout << "請再次輸入垂直座標系中的x和y的值(按除數字之外的字符退出該程序)："; 39 } 40 cout << "程序執行完畢" << endl; 41 system("pause"); 42 return 0; 43 } 44 45 void rect_to_polar(const rect* pxy, polar* pda) 46 { 47 pda->distance= sqrt(pxy->x * pxy->x + pxy->y * pxy->y); //sqrt()求根號 48 //polar_return.angle = atan2(xypos.x, xypos.y); //atan2()求座標x和y的角度 49 pda->angle = atan2(pxy->y, pxy->x); //這樣求出的角度纔對 50 51 } 52 void show_polar(const polar* pda) //polar新結構類型定義的函數參數dapos 53 { 54 const double rad_to_deg = 57.29577951; //即 180°/Π 55 56 cout << "您輸入的點和原點之間的距離是：" << pda->distance << endl; //使用間接成員運算符修改結構中的值 57 cout << "您輸入的點和x正半軸之間的角度是：" << pda->angle * rad_to_deg << endl; 58 }
#------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類字符串計算字符個數的方法----------#
02)使用strlen來計算char類字符串數組中字符的多少 如str1是一個char類字符串數組 strlen(str1)返回str1中字符的多少
#-----字符串特有的性質-------#
01)c風格字符串具備一種特殊的性質：以空字符結尾，空字符被寫做\0，cout在遇到空字符則中止顯示
02)在肯定存儲字符串所需的最短數組時，別忘了將結尾的空字符計算在內
03) char str1='S'; //表示字符S，'S'只是83的另外一種寫法
04)char str2="S"; //會自動在S的後面加上空字符，表示字符S和\0，且"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 //下面代碼會出現什麼問題？ 2 char *GetMemory( void ) 3 { 4 char p[] = "hello world"; 5 return p; 6 } 7 void Test( void ) 8 { 9 char *str = NULL; 10 str = GetMemory(); 11 printf( str ); 12 } 13 14 //解析：對於以下語句 15 char p[] = "hello world"; 16 return p; 17 p[]數組爲函數內的局部自動變量，在函數返回後，內存已經被釋放。這是許多程序員常犯的錯誤，其根源在於不理解變量的生存期。
二、在子函數中新疆的對象時能夠做爲返回值的，如圖：
三、返回值爲對象引用的狀況，只能是在主函數中做爲實參輸入的對象，才能夠做爲引用返回
#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中的配置方法
一、在開始中找到Anaconda Navigator並打開
二、建立新的環境並安裝相應的模
三、在Anaconda Navigator安裝相應的模塊的具體方法
四、在pycharm中配置python編譯器(對應與剛剛配置完畢的新環境)方法
URL
URL是Uniform Resource Location的縮寫，譯爲「統一資源定位符」。通俗地說，URL是Internet上用來描述信息資源的字符串，主要用在各類WWW客戶程序和服務器程序上，特別是著名的Mosaic。採用URL能夠用一種統一的格式來描述各類信息資源，包括文件、服務器的地址和目錄等。
URL的格式URL的格式由下列三部分組成：
第一部分是協議（或稱爲服務方式）；第二部分是存有該資源的主機IP地址（有時也包括端口號）；第三部分是主機資源的具體地址。，如目錄和文件名等。第一部分和第二部分之間用「：//」符號隔開，第二部分和第三部分用「/」符號隔開。第一部分和第二部分是不可缺乏的，第三部分有時能夠省略。