Python基础知识点总结
生活随笔
收集整理的這篇文章主要介紹了
Python基础知识点总结
小編覺得挺不錯的,現在分享給大家,幫大家做個參考.
一、Python概述：
1.1、Python的特點：
1、Python是一門面向對象的語言，在Python中一切皆對象
2、Python是一門解釋性語言
3、Python是一門交互式語言，即其在終端中進行命令編程
4、Python是一門跨平臺的語言【沒有操作系統的限制，在任何操作系統上都可以運行Python代碼】
5、Python擁有強大和豐富的庫，又被稱為膠水語言，能把其他語言（主要c/c++）寫的模塊很輕松的結合在一起
1.2、Python的優缺點：
1、優點：
a、易于維護和學習
b、廣泛的標準庫【提供了大量的工具】
c、可擴展性
d、Python對于大多數據庫都有相應的接口【Mysql、sqlites3、MongoDB、Redis等】
e、支持GUI編程【圖形化界面】
f、語法簡單，易于學習
2、缺點：
a、和C語言相比較Python的代碼運行速度慢
b、代碼無法加密
1.3、Python代碼的執行過程：
大致流程：源碼編譯為字節碼（.pyc)----->Python虛擬機------->執行編譯好的字節碼----->Python虛擬機將字節碼翻譯成相對應的機器指令（機器碼）。
Python程序運行時，先編譯字節碼并保存到內存中，當程序運行結束后，Python解釋器將內存中的字節碼對象寫到.pyc文件中。
第二次再運行時，先從硬盤中尋找.pyc文件，如果找到，則直接載入，否則重復上面過程。
二、Python中的基礎語法：
2.1、Python中變量在內存中的存儲
2.1.1引用和對象：
對象：當創建數據對象時，在內存中會保存對象的值，這個值就是對象自己；
引用：對象保存在內存空間，外部想要使用對象的值，就需要使用引用來操作對象。內存中會保存對象引用的數量，當某個對象的引用為0時，對象會被回收。
2.1.2可變數據類型和不可變數據類型
a、數據分類：
可變數據對象：列表（list）和字典（dict）
不可變數據對象：整型（int）、浮點型（float）、字符串（string）和元組類型（tuple）
注：此處的可變和不可變，是指內存中的對象（Value）是否可以改變，對于不可變類型的對象，在對對象操作的時候，必須在內存中重新申請一塊新的區域，即重新給一個新的地址用于存儲；對于可變類型的對象，在對對象操作的時候，并不會重新申請新的地址，而是在該對象的地址后面繼續申請即可，即address并不會改變，而是address的區域的大小會變長或變短。
不可變數據類型：對象本身的值不可變，如果改變了變量的值，相當于新建了一個對象，而對于相同值的對象，在內存中只有一個對象。
可變數據類型：允許變量的值進行改變，對于變量給值的過程中，只是改變了變量的值，而不會新建一個對象，所以可變數據類型的意思就是說對一個變量進行操作時，其值是可變的，值的變化并不會引起新建對象，即地址是不會變的，只是地址中的內容變化了或者地址得到了擴充。，不過對于相同的值的不同對象，在內存中則會存在不同的對象，即每個對象都有自己的地址，相當于內存中對于同值的對象保存了多份，這里不存在引用計數，是實實在在的對象。
2.1.3引用傳遞和值傳遞（函數傳值）
說明：可變對象為引用傳遞，不可變對象為值傳遞
引用傳遞：傳遞列表或者字典時，如果改變引用的值，就修改了原始的對象
def check(l):print(l)
print(id(l))
l.append([1, 23, 2, 3, 4])
return l
l = [1, 2, 3, 4]
print(check(l))
print(id(l))
?
'''
[1, 2, 3, 4]
2902500909320
[1, 2, 3, 4, [1, 23, 2, 3, 4]]
2902500909320
'''
值傳遞：當傳遞不可變對象時，如果改變引用變量的值，只是創建了不同的對象，原始對象并沒有改變。
def check(s):print(s)
print(id(s))
s = "i am test"
print(id(s))
return s
s = "This is a test"
print(check(s))
print(s)
?
'''
This is a test
2418424029424
2418424029488
i am test
This is a test
'''
2.1.4深拷貝和淺拷貝
淺拷貝：語法：copy.copy()，淺拷貝是創建了一個和原對象一樣的類型，但是其內容是對原對象元素的引用。
深拷貝：語法：copy.deepcopy(),在內存中將所有的數據重新建立一份。
變量的本質：在內存中開辟了一塊空間，其中存儲了指定類型的數據【實體（對象）存儲在堆中，變量（引用）存儲在?？臻g中
2.2基本數據類型
Python中常用的數據類型有：整型（int）、浮點型（float）、字符串（string）、空值（None）、布爾值（True和False）、復數、類、函數等
Python中常量的命名規則使用變量名為全大寫為常量
變量的命名遵循標識符的命名規則
2.3關鍵字、標識符和內置函數
1、關鍵字：在Python中被賦予了特殊含義的英文單詞
Python中的關鍵字的查看使用keyword模塊
import keyword as keykey.kwlist
'''
['False','None','True','and','as','assert','break','class','continue','def','del','elif','else','except','finally','for','from','global','if','import','in','is','lambda','nonlocal','not','or','pass','raise','return','try','while','with','yield']
'''
2、標識符的命名規則：標識符的命名構成：數字、字母、下劃線，但不能以數字開頭，在標識符的命名中嚴格區分大小寫
命名規范：
Python官方：所有單詞全部小寫，不同單詞之間使用下劃線分割，普遍是用駝峰命名法（小駝峰與大駝峰）
3、內置函數：
import sysdir(sys.modules['__builin__'])
內置函數表;
| abs() | dict() | help() | min() | setattr() |
| all() | dir() | hex() | next() | slice() |
| any() | divmod() | id() | object() | sorted() |
| ascii() | enumerate() | input() | oct() | staticmethod() |
| bin() | eval() | int() | open() | str() |
| bool() | exec() | isinstance() | ord() | sum() |
| bytearray() | filter() | issubclass() | pow() | super() |
| bytes() | float() | iter() | print() | tuple() |
| callable() | format() | len() | property() | type() |
| chr() | frozenset() | list() | range() | vars() |
| classmethod() | getattr() | locals() | repr() | zip() |
| compile() | globals() | map() | reversed() | import() |
| complex() | hasattr() | max() | round() | ? |
| delattr() | hash() | memoryview() | set() | ? |
2.4Python運算符
2.4.1算術、賦值運算符：
**：求冪運算
//：整除運算或者成為地板除
%：取余運算
常用算數運算符的優先級：** > * > / // % > + -
賦值運算符：=
復合運算符：+=、-= 、*= 、/=
關系比較：==、!=、>=、<=等
2.4.2邏輯運算
| and | x and y | 布爾"與" - 如果 x 為 False，x and y 返回 False，否則它返回 y 的計算值。【 |
| or | x or y | 布爾"或" - 如果 x 是 True，它返回 x 的值，否則它返回 y 的計算值。 |
| not | not x | 布爾"非" - 如果 x 為 True，返回 False 。如果 x 為 False，它返回 True。 |
| & | 按位與運算符：參與運算的兩個值,如果兩個相應位都為1,則該位的結果為1,否則為0 |
| | | 按位或運算符：只要對應的二個二進位有一個為1時，結果位就為1。 |
| ^ | 按位異或運算符：當兩對應的二進位相異時，結果為1 |
| ~ | 按位取反運算符：對數據的每個二進制位取反,即把1變為0,把0變為1。~x 類似于 -x-1。（運算原理：計算補碼，按位取反，轉為原碼，末尾加1） |
| << | 左移動運算符：運算數的各二進位全部左移若干位，由"<<"右邊的數指定移動的位數，高位丟棄，低位補0。 |
| >> | 右移動運算符：把">>"左邊的運算數的各二進位全部右移若干位，">>"右邊的數指定移動的位數 |
# 1、交叉賦值
x, y = y, x
# 2、第三方變量
temp = x
x = y
y = temp
# 3、異或
# 規律：一個數異或另一個數兩次之后的結果為該數本身
x = x ^ y
y = x ^ y
x = x ^ y
# 4、加減法
x = x + y
y = x - y
x = x - y
2.4.3成員及身份運算：
成員運算符：in、 not in
身份運算符：is、is not
2.5Python 中的語句
2.5.1if語句
if語句在Python中的兩種結構為：
# 1if 條件表達式：
代碼塊
?
# 2
if 條件表達式：
代碼塊
elif 條件表達式：
代碼塊
?
# 3
if 條件表達式：
代碼塊
else：
代碼塊
2.5.2for語句
for 變量 in 數據結構：循環體 # 9*9乘法表
for i in range(1,10):
for j in range(1,i + 1):
? ? print("%dx%d=%d" % (j,i,i * j),end=" ")
print("")
2.5.3while語句
while 條件表達式：代碼塊 # 9*9乘法表 while line < 10:temp = 1while temp <= line:print("%d x %d = %d"%(temp, line, temp*line),end = " ")temp += 1print("")line += 1break：直接跳出當前循環
continue：結束當前正在執行的循環，繼續下一次循環
三、Python內置數據結構：
Python中最基本的數據結構是序列（sequence），Python包含 6 中內建的序列，包括列表、元組、字符串、Unicode字符串、buffer對象和xrange對象。
3.1、String
3.1.1、字符串的創建
將文本放在單引號，雙引號和三引號之間
>>> str1 = ' hello, fanison ' >>> type(str1) str3.1.2、字符串的轉義：
字符串的轉義使用r
3.1.3、字符串的切片操作
-
索引運算符 s[i] 返回一個序列的元素i
-
切片運算符 s[i:j] 返回一個在字符串中從第i個元素開始到j-1之間的元素
-
擴展切片運算符 s[i:j:step] 在字符串中以step的步長從第i個到j-1個元素之間的元素，step為正數表示正著取，i<i或者說s[i,-1]倒著取
len(s) s中的元素個數
min(s) s的最小值
max(s) s的最大值
3.1.4字符串的相關方法：
s.index(sub [,start [,end]]) 找到指定字符串sub首次出現的位置
s.find(str,beg=0,end=len(string)) 找到字符串sub首次出現位置，與index不同是不報錯而返回-1
s.upper() 將一個字符串轉換為大寫形式
s.lower() 將一個字符串轉化為小寫形式
s.join(t) 使用s作為分隔符連接序列t中的字符串 s.strip() 將s兩邊不顯示的符號去掉之后返回（lstrip、rstrip）
s.split(t) 獲取以字符t將s切割的列表
s.encode() 獲取s的指定編碼的bytes值
bytes.decode() 獲取bytes的對應編碼的字符串，在python2中使用decode函數
s.endswith(suffix,beg=0, end=len(string)) 檢查中是否以suffix字符串結尾
3.2list
變量：相當于是一個容器，每次只能存儲一個數據
作用：相當于是一個容器，可以同時存儲多個數據
本質：一種有序的集合【有序：數據的存放順序和底層存儲的順序是相同】
列表中的元素本質存儲的是一個變量【引用】，列表是可變的【一個列表一旦被定義，則在代碼運行的過程中，其中的元素的值可以隨時發生改變】
num = 10
list1 = [43,5,45,46,5]
print(id(list1[0]))
list1[0] = 100
#1.創建【定義一個列表類型的變量】 #命名方式：lxx listxxx,不建議直接使用list #其中允許存放重復元素 list1 = [45,23,2,54,54,6] print(list1)#其中允許存放不同類型的數據 list2 = ["hello",4637,False] print(list2)#列表元素的訪問 #索引/下標/角標：取值范圍：0~len(xx) - 1 或者 -1~ - （len(xxx)） print(list1[3]) print(list1[-1]) #print(list1[20]) #IndexError: list index out of range 列表下標越界#列表元素的替換/修改 list1[3] = 473 print(list1)#組合:生成了一個新的列表 print(list1 + list2) print(list1)#列表元素的重復 print(list1 * 3) print(list1)#判斷某個元素是否在列表中 print(10 in list1) #False print(10 not in list1) #True print(45 in list1) #True print(45 not in list1) #False#列表切片【截取】：根據指定的列表獲取子列表 list3 = [45, 23, 2, 473, 54, 6,5,6,56,5] print(list3[2]) print(list3) #格式：列表名[start：end：step]，包頭不包尾 #獲取從指定下標開始到結尾的元素組成的一個子列表 print(list3[2:]) #獲取從開頭到指定下標的元素。。。。 print(list3[:6]) #截取指定區間 print(list3[2:6])#特殊情況1：如果end超出了下標的范圍，則默認獲取從指定下標開始到結尾的元素 print(list3[4:100]) #等價于 print(list3[4:])#特殊情況2：step在默認情況下為1 print(list3[1:6:2]) #1,3,5 print(list3[-1:-6]) #當start和end都為負數，step為正數的時候，獲取的結果為[]print(list3[-1:-6:-2]) #當start，end和step都為負數的時候，表示倒序#將列表倒序輸出 print(list3[-1::-1]) print(list3[::-1])#列表系統功能 #1.添加元素 #1.1append，追加，在列表的末尾添加元素 常用 l1 = [22,33,44,55] print(l1) #追加單個元素 l1.append(66) print(l1) #追加多個元素，不能直接追加，通過列表的形式追加，形成了一個二維列表 #l1.append(77,88) #報錯：TypeError: append() takes exactly one argument (2 given) l1.append([77,88]) print(l1) #結果：[22, 33, 44, 55, 66, [77, 88]]#1.2extend，擴展，在列表的末尾添加元素 l2 = [22,33,44,55] #追加單個元素,不能直接添加，參數一定是可迭代的 #l2.extend(66) #T報錯：ypeError: 'int' object is not iterablel2.extend([66]) print(l2)l2.extend([77,88]) print(l2) #結果：[22, 33, 44, 55, 66, 77, 88]""" 總結： 列表名.功能名(xx) append可以直接添加單個元素，而extend不能 append在添加多個元素的時候，是以列表的形式添加，而extend只添加元素【打碎加入】 """#1.3insert，插入，在指定索引處插入一個元素，后面的元素向后順延 #列表名.insert(索引，被插入的元素) l3 = [22,33,44,55] #插入單個元素 l3.insert(2,66) print(l3) #插入多個元素:和append類似，將整個列表直接插入 l3.insert(1,[77,88]) print(l3) #2.刪除 #2.1pop,彈出,移除并獲取列表中指定索引處的元素 在棧中【列表的底層工作原理是棧】 list1 = [11,22,33,44,55] #注意：pop在默認情況下刪除的是最后一個元素 result1 = list1.pop() print(list1) print(result1) result2 = list1.pop(2) print(list1)#2.2remove，移除，直接操作的是元素 list2 = [11,22,33,44,55,33,33,55] list2.remove(22) print(list2)#注意：移除指定元素在列表中第一次匹配到的元素【從左往右】 list2.remove(33) print(list2)#2.3clear 清除，將指定列表變為空列表 使用場景：循環中，每次需要清空【重置】列表 list2.clear() print(list2) #3.獲取 list1 = [54,6,57,5,57,7,6,7,57] #3.1len(),獲取列表長度 l = len(list1)#3.2max(),獲取列表中的最大值 print(max(list1)) #3.3min()，獲取列表中的最小值 print(min(list1))#練習：模擬max或者min的功能，求三個數中的最大值 #假設法 num1 = 43 num2 = 437 num3 = 2 #定義一個變量，用于記錄最大值 max1 = num1 if num2 > num1: max1 = num2if num3 > max1: max1 = num3#3.4index()，獲取指定元素在原列表中第一次匹配到的索引 print(list1.index(57))#模擬index的功能 for i in range(len(list1)): if list1[i] == 57:print(i)#3.5count(),統計個數，統計指定元素在列表中出現的次數 c = list1.count(57) print(c)list1 = [54,6,57,5,57,7,6,7,57,57,57,436] #練習：將list1中57給全部刪除 # list1.remove(57) # list1.remove(57) # list1.remove(57) # print(list1)#統計57在列表中出現的次數 num = 57 c = list1.count(num) n = 1 while n <= c: list1.remove(num) n += 1print(list1) import copy #4.其他用法 #4.1.reverse,反轉 list1 = [35,4,5,4,654]#print(list1[::-1]) # list1.reverse() # print(list1)#4.2.1sort,排序,默認為升序,在列表內部進行排序 #列表名.sort() #升序 # list1.sort() # print(list1) #降序 # list1.sort(reverse=True) # print(list1)#4.2.2sorted，排序,默認為升序，生成了一個新的列表 #sorted(列表名) #升序 newList = sorted(list1) print(list1) print(newList) #降序 newList2 = sorted(list1,reverse=True) print(newList2)#根據元素的長度進行排序 list2 = ["gjsrghj","545","fhghg","ahjegrhkwjhgrke"] #key關鍵字參數可以指定自定義的排序規則,格式：key=函數名 newList3 = sorted(list2,key=len,reverse=True) print(newList3)#4.3copy,拷貝 #直接賦值，淺拷貝，?？臻g層面上的拷貝【引用】 list1 = [23,54,56] list2 = list1 list2[1] = 100 print(list1) print(list2) print(id(list1) == id(list2))#copy，深拷貝，堆空間層面上的拷貝【實體】 list1 = [23,54,56] list2 = list1.copy() list2[1] = 100 print(list1) print(list2) print(id(list1) == id(list2))#模塊copy ，copy(),deeepcopy()【面試題】 #內容角度上的拷貝，copy只拷貝最外層，deepcopy可以拷貝內層的內容【二維列表中】 a = [1,2,3] b = [4,5,6] c = [a,b] print(c)d = copy.copy(c) print(id(d) == id(c)) #Falsee = copy.deepcopy(c) print(id(e) == id(c)) #Falsea.append(4) print(c) print(d) #[[1, 2, 3, 4], [4, 5, 6]] print(e) #[[1, 2, 3], [4, 5, 6]]""" d:[[1, 2, 3], [4, 5, 6]] [list1,list2]---->list1:[1,2,3] list2:[4,5,6] """#4.4轉換 #list(),tuple()#二維列表：遍歷 l1 = [[11, 22, 33, 44], [44, 55, 66]] print(l1[0]) #l1[0] = [11, 22, 33, 44] print(l1[0][2])for i in l1: for j in i:print(j)for n1 in range(len(l1)): for n2 in range(len(l1[n1])):print(l1[n1][n2])3.3tuple
和列表類似，本質是一種有序的集合
元組和列表的不同之處：
a.定義不同：列表[] 元組()
b.是否能夠修改：列表可以進行增加或者刪除元素的操作，但是，元組一旦被定義之后，其中的元素將不能進行任何的更改
#其中允許存儲重復元素 t1 = (23,53,54,53) print(t1)#其中允許存儲不同類型的數據 t2 = ("hello",47,19.0,False) print(t2)#特殊情況:當一個元組中只有一個元素的之后，會被識別為一個普通變量 t3 = (10) print(type(t3)) print(t3)#為了消除歧義，當元組中只有一個元素的時候，元組名 = (元素,) t4 = (10,) print(type(t4)) print(t4)#元組元素的訪問 #元組名[索引] print(t2[1]) #t2[1] = 100 #報錯：TypeError: 'tuple' object does not support item assignment【賦值】#特殊情況：如果在元組中的元素是列表，則列表中的元素依舊可以修改 # 【依據：元組和列表中存儲都是變量的地址，元素不允許修改，只需要保證未發生改變即可其中的地址】 t5 = (23,5,3,5,[235,345,5,45,4]) print(t5) print(t5[4]) #[235,345,5,45,4] t5[4][1] = 100 print(t5)#列表和元組的遍歷 #直接獲取元素 for element in t5: print(element)#獲取索引 for i in range(len(t5)): print(i,t5[i])#同時遍歷索引和元素 #需要將元組或者列表轉換為枚舉類型 #list(t5) #注意：下面的i并不是元組或者列表的索引，而是枚舉中的編號 for i,element in enumerate(t5): print(i,element)3.4dict 常用
也是一種存儲數據的方式，但是字典是無序的，
類似于list或者tuple，但是，字典采用鍵-值對的方式存儲數據
age1 = 10list1 = [10,4,35,46,6]dict1 = {"zhangsan":10}作用：具有極快的查找速度
鍵【key】相當于list或者tuple中的索引
key的特點
a.字典的key是唯一的【key不允許重復】
b.key必須為不可變的數據
list是可變的，不能用來當做key
tuple，數字型，字符串，布爾值都是不可變的，可以被充當key
dict1 = {"zhangsan":10,"lisi":13,"zhaoliu":50} #1.訪問鍵值對 print(dict1["lisi"])#訪問一個不存在的key，則報錯 #print(dict1["abc"]) #KeyError: 'abc'#字典是可變的 dict1["zhaoliu"] = 100 result0 = dict1["zhaoliu"] print(result0)#字典名[key] = value #注意：如果key存在，則表示修改value的值；如果key不存在，則表示在字典中添加一對新的鍵值對 dict1["abc"] = 20 print(dict1)#get() result1 = dict1.get("zhaoliu") print(result1) #如果key不存在，則不會報錯，返回None，一般用于判斷 result2 = dict1.get("def") print(result2)#2.刪除，pop #注意：刪除指定的key，對應的value也會隨著刪除 dict1.pop("lisi") print(dict1)#3.字典的遍歷 #3.1直接遍歷key 掌握 for key in dict1: print(key,dict1[key])# print(dict1.keys()) # print(type(dict1.keys())) #<class 'dict_keys'> for key in dict1.keys(): print(key,dict1[key])#3.2直接遍歷value for value in dict1.values(): print(value)#3.3,遍歷的是鍵值對的編號和key for i,element in enumerate(dict1): print(i,element)#3.4同時遍歷key和value 掌握 for key,value in dict1.items(): print(key,value)""" 【面試題：dict和list之間的區別】 1.dict查找和插入的速度不會因為key-value的增多而變慢，而list在每次查找的時候都是從頭到尾進行遍歷，當數據量大的時候，list速度肯定會變慢 2.dict需要占用大量的內存空間，內存浪費多，而list只相當于存儲了字典中的key或者value，并且list數據是緊密排列的 """練習：
"""" 1.逐一顯示列表l1 = ["Sun","Mon","Tue","Wed","Thu","Fri","Sat"]中索引為奇數的元素 2.將屬于列表l1 = ["Sun","Mon","Tue","Wed","Thu","Fri","Sat"]， 但不屬于列表l2 = ["Sun","Mon","Thu","Fri","Sat"]的所有元素定義為一個新列表l3 3.已知列表namelist=['stu1','stu2','stu3','stu4','stu5','stu6','stu7']，刪除列表removelist=['stu3', 'stu7', 'stu9']； 請將屬于removelist列表中的每個元素從namelist中移除(屬于removelist，但不屬于namelist的忽略即可)； 4.有一個字符串是一句英文，統計每個單詞出現的次數，生成一個字典，單詞作為key，次數作為value生成一個字典dict1 5.已知列表list1 = [0,1,2,3,4,5,6],list2 = ["Sun","Mon","Tue","Wed","Thu","Fri","Sat"], 以list1中的元素作為key，list2中的元素作為value生成一個字典dict2 """ #1. l1 = ["Sun","Mon","Tue","Wed","Thu","Fri","Sat"] for i in range(len(l1)): if i % 2 != 0:print(l1[i])#2. #思路：遍歷l1,獲取l1中的元素，判斷在l2中是否存在，如果不存在，則添加到一個新的列表中 l1 = ["Sun","Mon","Tue","Wed","Thu","Fri","Sat"] l2 = ["Sun","Mon","Thu","Fri","Sat"] l3 = [] for ele1 in l1: if ele1 not in l2:l3.append(ele1)#3 #思路：遍歷removelist,獲取其中的元素，判斷該元素在namelist中是否存在，如果存在，則刪除 namelist=['stu1','stu2','stu3','stu4','stu5','stu6','stu7'] removelist=['stu3', 'stu7', 'stu9']for ele2 in removelist: if ele2 in namelist:namelist.remove(ele2) print(namelist)#4 str1 = "today is a good day today is a bad day today is a nice day" dict1 = {} #使用空格切割字符串 list1 = str1.split(" ") print(list1) #遍歷列表，獲取其中的每個單詞 for word in list1: #在字典中通過key獲取value c = dict1.get(word) if c == None:#不存在，添加鍵值對dict1[word] = 1 else:#存在，則將value的值遞增1dict1[word] += 1print(dict1)#5. list1 = [0,1,2,3,4,5,6] list2 = ["Sun","Mon","Tue","Wed","Thu","Fri","Sat"] dict2 = {} #定義一個變量，作為list1和list2的索引 index1 = 0 if len(list1) == len(list2): while index1 < len(list1):#dict2[key] = value =======>dict2[list1中的元素] = list2中的元素#list1[index1] list2[index1]dict2[list1[index1]] = list2[index1]index1 += 1elif len(list1) > len(list2): while index1 < len(list2):dict2[list1[index1]] = list2[index1]index1 += 1else: while index1 < len(list1):dict2[list1[index1]] = list2[index1]index1 += 1# 優化上面的代碼：封裝【抽取】 """ def custom(num): dict2[list1[num]] = list2[num] num += 1 return num#定義一個變量，作為list1和list2的索引 index1 = 0if len(list1) == len(list2): while index1 < len(list1):#dict2[key] = value =======>dict2[list1中的元素] = list2中的元素#list1[index1] list2[index1]r = custom(index1)index1 = relif len(list1) > len(list2): while index1 < len(list2):r = custom(index1)index1 = relse: while index1 < len(list1):r = custom(index1)index1 = r """print(dict2)3.4set
集合：不允許重復元素，而且進行交集以及并集的運算
表示：{}
和dict之間的關系：set中只是存儲了key
本質：無序且無重復元素的集合
#1.創建 #set() s1 = {23,45,6,7,89} print(s1) print(type(s1))#掌握：去除列表中的重復元素 s2 = set([3,46,5,65,7,65,7]) print(s2)s3 = set((2,43,54,5,4,5)) print(s3)s4 = set({10:"a",20:"b"}) print(s4)#2.set是可變的 #2.1添加 #add(),添加， set1 = {11,22,33,44,55} #單個元素 set1.add(66) print(set1) #如果元素存在，則添加失敗，不報錯 set1.add(55) #多個元素 #s1.add([77,88]) #TypeError: unhashable type: 'list' s1.add((77,88)) #s1.add({1:"a"}) #結論：在set中，使用add添加，則只能添加元組，不能添加list和dict print(s1)#update()，更新,update的參數只能是可迭代對象【打碎加入】 set2 = {11,22,33,44,55} #set2.update(66) #報錯：TypeError: 'int' object is not iterableset2.update([66]) print(set2)set2.update((77,88)) print(set2)set2.update({"12":12,"13":13}) print(set2)set2.update("hgjhg") print(set2)#3.刪除 set2.remove(77) print(set2)#4.交集和并集 s1 = {3,54,4,5,7} s2 = {3,54,4,8,90} #交集：&【按位與】 print(s1 & s2)#并集：|【按位或】 print(s1 | s2)list、tuple、dict、set的區別和聯系：
a、定義方式：list：[]、tuple：（）、dict：{}、set：{}
b、是否有序：list:有序，tuple：有序，dict：無序，set：無序
c、是否允許出現重復元素：list：允許，tuple：允許，dict：key鍵值不允許，但是value的值允許，set：不允許
d、都屬于可迭代對象
e、set相當于存儲了字典中的key
f、可以向互轉化
4、附錄
4.1 字符串轉義字符表
在需要在字符中使用特殊字符時，python用反斜杠()轉義字符。如下表：
| (在行尾時) | 續行符 |
| \ | 反斜杠符號 |
| \' | 單引號 |
| \" | 雙引號 |
| \a | 響鈴 |
| \b | 退格(Backspace) |
| \e | 轉義 |
| \000 | 空 |
| \n | 換行 |
| \v | 縱向制表符 |
| \t | 橫向制表符 |
| \r | 回車 |
| \f | 換頁 |
| \oyy | 八進制數，yy代表的字符，例如：\o12代表換行 |
| \xyy | 十六進制數，yy代表的字符，例如：\x0a代表換行 |
| \other | 其它的字符以普通格式輸出 |
4.2 python字符串格式化符號表
| %c | 格式化字符及其ASCII碼 |
| %s | 格式化字符串 |
| %d | 格式化整數 |
| %u | 格式化無符號整型 |
| %o | 格式化無符號八進制數 |
| %x | 格式化無符號十六進制數 |
| %X | 格式化無符號十六進制數（大寫） |
| %f | 格式化浮點數字，可指定小數點后的精度 |
| %e | 用科學計數法格式化浮點數 |
| %E | 作用同%e，用科學計數法格式化浮點數 |
| %g | %f和%e的簡寫 |
| %G | %f 和 %E 的簡寫 |
| %p | 用十六進制數格式化變量的地址 |
4.3 格式化操作符輔助指令表
| * | 定義寬度或者小數點精度 |
| - | 用做左對齊 |
| + | 在正數前面顯示加號( + ) |
| <sp> | 在正數前面顯示空格 |
| # | 在八進制數前面顯示零('0')，在十六進制前面顯示'0x'或者'0X'(取決于用的是'x'還是'X') |
| 0 | 顯示的數字前面填充'0'而不是默認的空格 |
| % | '%%'輸出一個單一的'%' |
| (var) | 映射變量(字典參數) |
| m.n. | m 是顯示的最小總寬度,n 是小數點后的位數(如果可用的話) |
4.4 字符串內建方法表
| 1 | capitalize() | 將字符串的第一個字符轉換為大寫 |
| 2 | center(width, fillchar) | 返回一個指定的寬度 width 居中的字符串，fillchar 為填充的字符，默認為空格。 |
| 3 | count(str, beg= 0,end=len(string)) | 返回 str 在 string 里面出現的次數，如果 beg 或者 end 指定則返回指定范圍內 str 出現的次數 |
| **4 | bytes.decode(encoding="utf-8", errors="strict") | Python3 中沒有 decode 方法，但我們可以使用 bytes 對象的 decode() 方法來解碼給定的 bytes 對象，這個 bytes 對象可以由 str.encode() 來編碼返回。 |
| **5 | encode(encoding='UTF-8',errors='strict') | 以 encoding 指定的編碼格式編碼字符串，如果出錯默認報一個ValueError 的異常，除非 errors 指定的是'ignore'或者'replace' |
| **6 | endswith(suffix, beg=0, end=len(string)) | 檢查字符串是否以 obj 結束，如果beg 或者 end 指定則檢查指定的范圍內是否以 obj 結束，如果是，返回 True,否則返回 False. |
| 7 | expandtabs(tabsize=8) | 把字符串 string 中的 tab 符號轉為空格，tab 符號默認的空格數是 8 。 |
| **8 | find(str, beg=0 end=len(string)) | 檢測 str 是否包含在字符串中，如果指定范圍 beg 和 end ，則檢查是否包含在指定范圍內，如果包含返回開始的索引值，否則返回-1 |
| 9 | index(str, beg=0, end=len(string)) | 跟find()方法一樣，只不過如果str不在字符串中會報一個異常. |
| 10 | isalnum() | 如果字符串至少有一個字符并且所有字符都是字母或數字則返 回 True,否則返回 False |
| 11 | isalpha() | 如果字符串至少有一個字符并且所有字符都是字母則返回 True, 否則返回 False |
| 12 | isdigit() | 如果字符串只包含數字則返回 True 否則返回 False.. |
| 13 | islower() | 如果字符串中包含至少一個區分大小寫的字符，并且所有這些(區分大小寫的)字符都是小寫，則返回 True，否則返回 False |
| 14 | isnumeric() | 如果字符串中只包含數字字符，則返回 True，否則返回 False |
| 15 | isspace() | 如果字符串中只包含空白，則返回 True，否則返回 False. |
| 16 | istitle() | 如果字符串是標題化的(見 title())則返回 True，否則返回 False |
| 17 | isupper() | 如果字符串中包含至少一個區分大小寫的字符，并且所有這些(區分大小寫的)字符都是大寫，則返回 True，否則返回 False |
| **18 | join(seq) | 以指定字符串作為分隔符，將 seq 中所有的元素(的字符串表示)合并為一個新的字符串 |
| *19 | len(string) | 返回字符串長度 |
| 20 | ljust(width[, fillchar]) | 返回一個原字符串左對齊,并使用 fillchar 填充至長度 width 的新字符串，fillchar 默認為空格。 |
| 21 | lower() | 轉換字符串中所有大寫字符為小寫. |
| 22 | lstrip() | 截掉字符串左邊的空格或指定字符。 |
| **23 | maketrans() | 創建字符映射的轉換表，對于接受兩個參數的最簡單的調用方式，第一個參數是字符串，表示需要轉換的字符，第二個參數也是字符串表示轉換的目標。 |
| *24 | max(str) | 返回字符串 str 中最大的字母。 |
| *25 | min(str) | 返回字符串 str 中最小的字母。 |
| **26 | replace(old, new [, max]) | 把 將字符串中的 str1 替換成 str2,如果 max 指定，則替換不超過 max 次。 |
| 27 | rfind(str, beg=0,end=len(string)) | 類似于 find()函數，不過是從右邊開始查找. |
| 28 | rindex( str, beg=0, end=len(string)) | 類似于 index()，不過是從右邊開始. |
| 29 | rjust(width,[, fillchar]) | 返回一個原字符串右對齊,并使用fillchar(默認空格）填充至長度 width 的新字符串 |
| 30 | rstrip() | 刪除字符串字符串末尾的空格. |
| **31 | split(str="", num=string.count(str)) | num=string.count(str)) 以 str 為分隔符截取字符串，如果 num 有指定值，則僅截取 num 個子字符串 |
| **32 | splitlines([keepends]) | 按照行('\r', '\r\n', \n')分隔，返回一個包含各行作為元素的列表，如果參數 keepends 為 False，不包含換行符，如果為 True，則保留換行符。 |
| **33 | startswith(str, beg=0,end=len(string)) | 檢查字符串是否是以 obj 開頭，是則返回 True，否則返回 False。如果beg 和 end 指定值，則在指定范圍內檢查。 |
| **34 | strip([chars]) | 在字符串上執行 lstrip()和 rstrip() |
| 35 | swapcase() | 將字符串中大寫轉換為小寫，小寫轉換為大寫 |
| 36 | title() | 返回"標題化"的字符串,就是說所有單詞都是以大寫開始，其余字母均為小寫(見 istitle()) |
| **37 | translate(table, deletechars="") | 根據 str 給出的表(包含 256 個字符)轉換 string 的字符, 要過濾掉的字符放到 deletechars 參數中 |
| 38 | upper() | 轉換字符串中的小寫字母為大寫 |
| 39 | zfill (width) | 返回長度為 width 的字符串，原字符串右對齊，前面填充0 |
| 40 | isdecimal() | 檢查字符串是否只包含十進制字符，如果是返回 true，否則返回 false。 |
備注： *標記為相關內建函數，**標記為常用方法。
4.5 Python列表函數&方法
Python包含以下函數:
| 1 | [len(list) | 列表元素個數 |
| 2 | [max(list) | 返回列表元素最大值 |
| 3 | [min(list) | 返回列表元素最小值 |
| 4 | [list(seq) | 將元組轉換為列表 |
Python包含以下方法:
| 1 | list.append(obj) | 在列表末尾添加新的對象 |
| 2 | list.count(obj) | 統計某個元素在列表中出現的次數 |
| 3 | list.extend(seq) | 在列表末尾一次性追加另一個序列中的多個值（用新列表擴展原來的列表） |
| 4 | list.index(obj) | 從列表中找出某個值第一個匹配項的索引位置 |
| 5 | list.insert(index, obj) | 將對象插入列表 |
| 6 | list.pop([index=-1]) | 移除列表中的一個元素（默認最后一個元素），并且返回該元素的值 |
| 7 | list.remove(obj) | 移除列表中某個值的第一個匹配項 |
| 8 | list.reverse() | 反向列表中元素 |
| 9 | list.sort(cmp=None, key=None, reverse=False) | 對原列表進行排序 |
| 10 | list.clear() | 清空列表 |
| 11 | list.copy() | 復制列表 |
?
?
?
轉載于:https://www.cnblogs.com/skywlj1106/p/10296994.html
總結
以上是生活随笔為你收集整理的Python基础知识点总结的全部內容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： CString 操作函数
- 下一篇： websocket python爬虫_p