當前位置：首頁 > 编程语言 > python >内容正文

python

Python基础知识点总结

發布時間：2024/8/26 python 62 豆豆

生活随笔收集整理的這篇文章主要介紹了 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(),在內存中將所有的數據重新建立一份。

變量的本質：在內存中開辟了一塊空間，其中存儲了指定類型的數據【實體（對象）存儲在堆中，變量（引用）存儲在棧空間中

2.2基本數據類型

Python中常用的數據類型有：整型（int）、浮點型（float）、字符串（string）、空值（None）、布爾值（True和False）、復數、類、函數等

Python中常量的命名規則使用變量名為全大寫為常量

變量的命名遵循標識符的命名規則

2.3關鍵字、標識符和內置函數

1、關鍵字：在Python中被賦予了特殊含義的英文單詞

Python中的關鍵字的查看使用keyword模塊

import keyword as key
key.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 sys
dir(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 的計算值?！?/span>
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。
>>	右移動運算符：把">>"左邊的運算數的各二進位全部右移若干位，">>"右邊的數指定移動的位數

# 位運算實例：x與y的數值的交換
# 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中的兩種結構為：

# 1
if 條件表達式：
代碼塊
?
# 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 += 1

break：直接跳出當前循環

continue：結束當前正在執行的循環，繼續下一次循環

三、Python內置數據結構：

Python中最基本的數據結構是序列（sequence），Python包含 6 中內建的序列，包括列表、元組、字符串、Unicode字符串、buffer對象和xrange對象。

3.1、String

3.1.1、字符串的創建

將文本放在單引號，雙引號和三引號之間

>>> str1 = ' hello, fanison ' >>> type(str1) str

3.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,拷貝 #直接賦值，淺拷貝，棧空間層面上的拷貝【引用】 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包含以下方法: