python基礎知識

1 python概述

1.1優點

1.開源，易于維護，

2.可移植，

3.易于使用，簡單優雅，

4.廣闊的標準庫，功能強大，

5.可擴展，可嵌入，

1.12劣勢

1.運行速度慢，(解釋型語言，翻譯為機器碼耗時)

2.代碼不能加密，(發布程式為源代碼)

2 python語法

2.1注釋

1. 單行注釋：

   #這是一個單行注釋
   

2. 多行注釋：

   '''
   這是一個多行注釋
   這是一個多行注釋
   '''
   

3 基礎陳述句

3.1 輸出print陳述句

print(“具體的字符”)
print(變數名)

print(“xxxxx %變數型別縮寫” %變數名)

#具體輸出
print("具體的字符")
#變數輸出
int a=10
print(a)
#格式化輸出
print("輸出%d具體字符"%a)
#連接符
print("具體字符","具體字符","具體字符",sep="分隔符(默認為空格)")
print("",end="")#直接連接后方字串
print("",end="\t")#空格后鏈接后方字串
print("",end="\n")#換行后鏈接后方字串

3.2 輸入input陳述句

接受輸入的變數名 = input("提示資訊")

4 變數及型別

變數名可以是任意資料型別，在程式中用一個變數名表示

變數名必須有 大小寫英文，數字，和下劃線(_)組成

賦值(a=“ABC”)時，python解釋器執行了兩個操作:

1. 在記憶體中創建了一個"ABC"的字串
2. 在記憶體中創建了一個名為a的變數，并把它指向了"ABC"

5 運算子

5.1 算數運算子

5.2 比較運算子

5.3 賦值運算子

5.4 位運算子

5.5 邏輯運算子

5.6 成員運算子

5.7 運算子的優先級

6 條件判斷陳述句

python 指定任何非0和非空值為true ，0或者None為falst

條件判斷陳述句以縮進控制范圍

if 判斷陳述句：#縮進必須同級相同，要不不識別 

	執行陳述句1

elif 判斷陳述句2：
	執行陳述句2
else：
	執行陳述句3

7 回圈陳述句

7.1 for回圈

for i in range(5)：#從0開始五個數的陣列
	回圈陳述句
for i in range(0,10,3)：#從0開始到10為止，步進值為3
	回圈陳述句
a = ["1","2","3"]
for i in range(len(a))
	print(i,a[i])

for i,x in enumerste(串列)
	print(i,x)  					#列舉函式，i為索引，x為串列值

7.2 while回圈

i = 0
while i < 5:
    回圈陳述句
    i = i++
else:
    回圈陳述句

7.3回圈控制 break continue pass

#break 退出回圈陳述句
#continue 跳過當前回圈
#pass 占位符

8 字串，串列，元組，字典

8.1 字串

python 中的字串可以使用單引號，雙引號和三引號括起來，使用反斜杠\轉義特殊字符

python3原始碼檔案默認以UTF-8編碼，所有字串都是unicode字串

支持字符拼接，截取等多種運算

字串中出現單引號和雙引號時需要前加\轉義

word = '字串'
word1 = "字串"
word2 = """
		字符段落
"""

8.1.1 str[x,y,z]

str = "字串"
print(str[x:y:z])  #@x為起始值，從零開始，y為結束值，不列印結束值，z為步進值，

8.1.2字串連接

str1 = "字串"
str2 = "字串"
print(str1 + str2)

8.1.3字串的常見操作

8.2 串列(list)

串列可以完成大多數集合類的資料結構實作，串列中的元素的型別可以不相同，它支持數字，字串，甚至可以包含串列(所謂嵌套)，

串列是寫在方括號[]之間,用逗號分隔開的元素串列，

串列索引值以0為開始值，-1為末尾的開始位置，

串列可以使用+運算子進行拼接，使用*運算子進行重復，

支持 in count 方法

list = ["字串",0,[]]  #@可以存在混合型別

8.2.1 串列方法

8.2.2 串列方法介紹

1. 增：

   list = [1,2]
   
   #在末尾追加元素 append()方法--串列名.append(要添加的字符)         
   list.append("要增加的字符")
   

!!! list.append([1,2]) ---------- list = [ 1 , 2 , [1 , 2]]

#在末尾追加元素 extend()方法–串列名.extend(要追加的元素)
list.extend([元組元素，元組元素])
!!! list.extend([3,4]) ---------- list = [ 1 , 2 , 3 , 4]

#在指定位置插入 insert()方法–串列名.insert(要插入位置的下標，插入的元素)
list.insert(插入索引，插入元素)

2.刪：

```python
list = [0,1,2,3]

#在指定位置洗掉元素 del方法--del 串列名[要洗掉元素的索引]
del list[索引]

#彈出最后一個元素 pop方法--串列名,pop()
list.pop()

#洗掉指定內容的元素 remove()方法--串列名.remove("要洗掉元素的具體內容")
list.remove("指定內容")   #從前開始遍歷，優先洗掉最前方的，

3.改：

list = [1,2,3]

#指定元素進行修改 無具體方法--串列名[修改元素索引] = "具體內容"
list[索引] = ""

4.查：

list = [1,2]
 
#查詢指定元素是否在串列中 if判斷-if 元素 in 串列：
if 1 in list:
    反饋陳述句

#查詢指定范圍內是否存在 index()方法--串列名.index(指定元素，開始元素，結束元素) ！！！左包含右不包含
list.index(指定元素,開始，結束(不包含))  #@存在回傳索引，不存在報錯

#查詢某個元素出現幾次 count()方法--串列名.count(元素具體值)
list.count("元素具體值")

5.排：

list = [1,2,3,4]

#反轉排序 reverse()方法--串列名.reverse()
list.reverse()         #@反轉串列順序

#從小到大排序 sort()方法--串列名.sort()
list.sort()           #@從大到小排序

#從大到小排序 sort(reverse=True)方法--串列.sort(reverse=True)
list = sort(reverse=True) #@從大到小排序

 

8.2.3 串列的嵌套

list = [[1,2],[3,4],[5,6]]

串列名[索引][索引] list[索引][索引]

###8.3 元組(tuple)

元組(Tuple)與串列相似，不同之處是元組中的元素不能修改，寫在小括號中，元素之間用逗號隔開，

元組的元素不可變，但是可以包含可變物件，如串列

！！！tuple = (0)時，type(tuple) 時int型的，只有tuple = (0,)時type(tuple) 時tuple型的

支持 in count 方法

8.3.1 元組方法

8.3.2 元組方法介紹

1.增：

tuple = (1,2,3,4)

#并不是在某一個上增加了，而是新建了，
tup2 = (元素) 
tup1 =（元素）
tup = tup1 + tup2

2.刪：

tuple = (1,2,3,4)

#洗掉整個元組  del 元組名
del tuple

3.查：

tuple = (1,2,3,4)
#查找具體元素  元組名[索引]
tuple[索引]

8.4 字典(dict)

字典時無序的物件的集合，使用鍵值對存盤(key-value)，具有極快的查找速度，

鍵(key)必須使用不可變的型別，

同一字典中，鍵(key)必須唯一，

8.4.1方法

8.4.2字典的具體操作

1.查：

info = {"key":"value","key1":"value"}

#查找指定鍵的值  字典名["字典中具體的鍵"]
info["key"]				#如果訪問不存在的鍵會報錯

#查找指定鍵的值  get()方法--字典名.get("字典中具體的鍵","如果未查詢到，回傳的值")
info.get("key")			#如果不存在回傳None
info.get("key","設定默認值")			#如果不存在回傳設定的值，如果找到默認值不發揮作用，

#查找所有鍵  keys()方法--字典名.keys()
info.keys()                #回傳所有鍵(串列)

#查找所有值  values()方法--字典名.values()
info.values()                #回傳所有值(串列)

#查找所有鍵值  items()方法--字典名.items()
info.items()                #回傳所有鍵值(串列)---[(鍵，值),(),()]
for key,value in 字典名,items():
    print("key=%s,value=%s",%(key,value))

2.增：

info = {"key":"value","key1":"value"}

#增加新的鍵值對  字典名["鍵"] = 值
info["key2"] = "value"

3.刪：

info = {"key":"value","key1":"value"}

#洗掉指定鍵值對， del方法 --del 字典名["指定值"]
del info["key"]          #洗掉整個鍵值對，洗掉后再訪問報錯，
del info                 #洗掉字典，再訪問報錯，

#清空字典  clear()方法 --字典名.clear()
info.clear()

4.改：

info = {"key":"value","key1":"value"}

#更改鍵對應的值    字典名["鍵"] = ”值“
info["key"] = "值"

8.5集合(set)

集合和字典類似，也是一組key的集合，但是不存在存盤value，由于key不能重復，所以，再set中，沒有重復的key，

set是無序的，重復元素再set中自動被過濾，

8.5.1方法

8.6 總結

9 轉義字符

有些字符無法在陳述句中直接使用，需要轉義后才能使用，

print("字串")#@字串中的\為轉義字符，進行轉義，
print(r"字串")#@要列印的字串前加 r 表示字串其中轉義\不進行轉義，直接輸出，

10 函式

10.1 概念

1.開發程式時，需要某塊代碼多次，但是為了提高撰寫效率以及代碼的重用，所以把具有獨立功能的代碼塊組織為一個小模塊，這就是函式，

2.函式可以有多個return 但是只要執行一個return就算函式呼叫完成，

3.函式名不能重復，

4.帶參函式，如果在定義時有形參，那么在呼叫時就應該傳遞引數

5.呼叫時，實參的個數和先后順序應該和定義函式中的要求一致，

#不帶引數
del 函式名():
    函式體(pass)

#帶引數
del 函式名(引數1,引數2):
    函式體(pass)

#帶回傳值-------只有有return才有回傳值
del 函式名(引數1,引數2):
    函式體(pass)
	return 引數
變數名 = 函式名()    		   #接收單回傳值
del 函式名(引數1,引數2):
    函式體(pass)
	return 引數,引數
變數名,變數名 = 函式名()     #接收多個回傳值

10.2 全域變數和區域變數

全域變數：在整體函式上宣告的變數，可以在所有函式上使用，

區域變數：在函式體中宣告的變數，只能在本函式上使用，

在函式中，全域變數和區域變數同名時，優先使用的是區域變數，要使用全域變數需要在宣告之前加 global 關鍵字

a = 1			##全域變數
del 函式名（）：
	a = 2		##區域變數，會被優先修改
print(a)		##結果為1

a = 1			##全域變數
del 函式名（）：
	global a = 2		##宣告使用全域變數
print(a)		##結果為2

11 檔案

11.1 檔案操作

1.打開

##打開指定路徑，檔案名的檔案，使用設定的模式，
變數名1 = open("檔案名","打開模式")

2.關閉

變數名1 = open("檔案名","打開模式")

#關閉已經打開的檔案，
變數名1.close()

3.讀

變數名1 = open("檔案名","打開模式")

#讀取打開檔案指定字符的內容	read()方法--打開檔案的變數名.read(讀取字符個數)
#read()方法開始定位在檔案頭，每執行一次向后移動指定字符，
變數名1.read(5)    	#讀取五個字符
變數名1.read(5)		#會繼續往后讀取5個字符，與上一句代碼讀取不相同 ！！！！！！

#讀取打開檔案所有行的內容 readlines()方法--打開檔案的變數名.readlines()
變數名1.readlines() 		#回傳每行一個元素的串列

#讀取打開檔案指定行的內容 readline()方法--打開檔案的變數名.readline()
#readline()方法開始定位在檔案頭，每執行一次向后移動指定行，
變數名1.readline() 		#回傳每行一個元素的串列

4.檔案重命名

引入os模塊，使用os中的rename()進行檔案重命名，

import os

#檔案重命名  rename()方法--os.rename("需要修改的檔案名","新的檔案名")
os.rename("舊檔案名","新檔案名")

5.洗掉檔案

引入os模塊，使用os中的remove()進行檔案洗掉，

import os

#檔案洗掉  remove()方法--os.remove("要洗掉的檔案名")
os.remove("要洗掉的檔案名")

11.2打開模式

12 例外

例外指的是在程式運行程序中發生的例外事件，通常是由外部問題（如硬體錯誤、輸入錯誤）所導致的，在Java等面向物件的編程語言中例外屬于物件，

捕獲例外：try: #@可能出現例外的代碼放在try中

處理例外:except 捕獲例外型別： #@處理例外的代碼放在except中

try 可以嵌套

例外處理的常用操作：

#捕獲單個例外
try:
    可能發生例外的代碼塊
except 可能發生的例外型別 ：
	若發生例外時執行的陳述句
    
#捕獲多個例外
try:
    可能發生例外的代碼塊
except （例外1，例外2）：		#將可能出現的例外填寫在小括號中
	若發生例外時執行的陳述句

#捕獲多個例外
try:
    可能發生例外的代碼塊
except （例外1，例外2）as result：			#result 錯誤資訊
	若發生例外時執行的陳述句
    print(result)				#列印錯誤資訊，錯誤資訊以字串形式被列印

#捕獲通用例外
try:
    可能發生例外的代碼塊
except Exception as result：		# Exception可以承接任何例外，可以列印result錯誤資訊，也可以不列印錯誤資訊，
	若發生例外時執行的陳述句
    print(result)
    
#try------finally  finally:后的代碼不論例外是否發生，都會執行
try:
    可能發生例外的代碼塊
except 可能發生的例外型別 ：
	若發生例外時執行的陳述句
finally:
    不論是否例外都執行的代碼

常用方法

random.randint(起始值，結束值) 隨機生成int型數