Python基礎(chǔ)知識(shí)：1、引用和對(duì)象；2、可變數(shù)據(jù)類型和不可變數(shù)據(jù)類型；3、引用傳遞和值傳遞；4、深拷貝和淺拷貝；5、基本數(shù)據(jù)類型；6、關(guān)鍵字、標(biāo)識(shí)符和內(nèi)置函數(shù)；7、算術(shù)、賦值運(yùn)算符等等。

成都創(chuàng)新互聯(lián)長(zhǎng)期為1000+客戶提供的網(wǎng)站建設(shè)服務(wù)，團(tuán)隊(duì)從業(yè)經(jīng)驗(yàn)10年，關(guān)注不同地域、不同群體，并針對(duì)不同對(duì)象提供差異化的產(chǎn)品和服務(wù)；打造開(kāi)放共贏平臺(tái)，與合作伙伴共同營(yíng)造健康的互聯(lián)網(wǎng)生態(tài)環(huán)境。為沁縣企業(yè)提供專業(yè)的成都網(wǎng)站設(shè)計(jì)、網(wǎng)站制作，沁縣網(wǎng)站改版等技術(shù)服務(wù)。擁有10余年豐富建站經(jīng)驗(yàn)和眾多成功案例,為您定制開(kāi)發(fā)。

相關(guān)學(xué)習(xí)推薦：python教程

Python基礎(chǔ)知識(shí)總結(jié)一、Python概述：1.1、Python的特點(diǎn)：

1、Python是一門面向?qū)ο蟮恼Z(yǔ)言，在Python中一切皆對(duì)象

2、Python是一門解釋性語(yǔ)言

3、Python是一門交互式語(yǔ)言，即其在終端中進(jìn)行命令編程

4、Python是一門跨平臺(tái)的語(yǔ)言【沒(méi)有操作系統(tǒng)的限制，在任何操作系統(tǒng)上都可以運(yùn)行Python代碼】

5、Python擁有強(qiáng)大和豐富的庫(kù)，又被稱為膠水語(yǔ)言，能把其他語(yǔ)言（主要c/c++）寫的模塊很輕松的結(jié)合在一起

1.2、Python的優(yōu)缺點(diǎn)：

1、優(yōu)點(diǎn)：

a、易于維護(hù)和學(xué)習(xí)

b、廣泛的標(biāo)準(zhǔn)庫(kù)【提供了大量的工具】

c、可擴(kuò)展性

d、Python對(duì)于大多數(shù)據(jù)庫(kù)都有相應(yīng)的接口【Mysql、sqlites3、MongoDB、Redis等】

e、支持GUI編程【圖形化界面】

f、語(yǔ)法簡(jiǎn)單，易于學(xué)習(xí)

2、缺點(diǎn)：

a、和C語(yǔ)言相比較Python的代碼運(yùn)行速度慢

b、代碼無(wú)法加密

1.3、Python代碼的執(zhí)行過(guò)程：

大致流程：源碼編譯為字節(jié)碼（.pyc)----->Python虛擬機(jī)------->執(zhí)行編譯好的字節(jié)碼----->Python虛擬機(jī)將字節(jié)碼翻譯成相對(duì)應(yīng)的機(jī)器指令（機(jī)器碼）。

Python程序運(yùn)行時(shí)，先編譯字節(jié)碼并保存到內(nèi)存中，當(dāng)程序運(yùn)行結(jié)束后，Python解釋器將內(nèi)存中的字節(jié)碼對(duì)象寫到.pyc文件中。

第二次再運(yùn)行時(shí)，先從硬盤中尋找.pyc文件，如果找到，則直接載入，否則重復(fù)上面過(guò)程。

優(yōu)點(diǎn)：不重復(fù)編譯，提高執(zhí)行效率

二、Python中的基礎(chǔ)語(yǔ)法：2.1、Python中變量在內(nèi)存中的存儲(chǔ)2.1.1引用和對(duì)象：

對(duì)象：當(dāng)創(chuàng)建數(shù)據(jù)對(duì)象時(shí)，在內(nèi)存中會(huì)保存對(duì)象的值，這個(gè)值就是對(duì)象自己；

引用：對(duì)象保存在內(nèi)存空間，外部想要使用對(duì)象的值，就需要使用引用來(lái)操作對(duì)象。內(nèi)存中會(huì)保存對(duì)象引用的數(shù)量，當(dāng)某個(gè)對(duì)象的引用為0時(shí)，對(duì)象會(huì)被回收。

2.1.2可變數(shù)據(jù)類型和不可變數(shù)據(jù)類型

a、數(shù)據(jù)分類：

可變數(shù)據(jù)對(duì)象：列表（list）和字典（dict）

不可變數(shù)據(jù)對(duì)象：整型（int）、浮點(diǎn)型（float）、字符串（string）和元組類型（tuple）

注：此處的可變和不可變，是指內(nèi)存中的對(duì)象（Value）是否可以改變，對(duì)于不可變類型的對(duì)象，在對(duì)對(duì)象操作的時(shí)候，必須在內(nèi)存中重新申請(qǐng)一塊新的區(qū)域，即重新給一個(gè)新的地址用于存儲(chǔ)；對(duì)于可變類型的對(duì)象，在對(duì)對(duì)象操作的時(shí)候，并不會(huì)重新申請(qǐng)新的地址，而是在該對(duì)象的地址后面繼續(xù)申請(qǐng)即可，即address并不會(huì)改變，而是address的區(qū)域的大小會(huì)變長(zhǎng)或變短。

不可變數(shù)據(jù)類型：對(duì)象本身的值不可變，如果改變了變量的值，相當(dāng)于新建了一個(gè)對(duì)象，而對(duì)于相同值的對(duì)象，在內(nèi)存中只有一個(gè)對(duì)象。

可變數(shù)據(jù)類型：允許變量的值進(jìn)行改變，對(duì)于變量給值的過(guò)程中，只是改變了變量的值，而不會(huì)新建一個(gè)對(duì)象，所以可變數(shù)據(jù)類型的意思就是說(shuō)對(duì)一個(gè)變量進(jìn)行操作時(shí)，其值是可變的，值的變化并不會(huì)引起新建對(duì)象，即地址是不會(huì)變的，只是地址中的內(nèi)容變化了或者地址得到了擴(kuò)充。，不過(guò)對(duì)于相同的值的不同對(duì)象，在內(nèi)存中則會(huì)存在不同的對(duì)象，即每個(gè)對(duì)象都有自己的地址，相當(dāng)于內(nèi)存中對(duì)于同值的對(duì)象保存了多份，這里不存在引用計(jì)數(shù)，是實(shí)實(shí)在在的對(duì)象。

2.1.3引用傳遞和值傳遞（函數(shù)傳值）

說(shuō)明：可變對(duì)象為引用傳遞，不可變對(duì)象為值傳遞

引用傳遞：傳遞列表或者字典時(shí)，如果改變引用的值，就修改了原始的對(duì)象

def check(l):    print(l)    print(id(l))    l.append([1, 23, 2, 3, 4])    return ll = [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'''

值傳遞：當(dāng)傳遞不可變對(duì)象時(shí)，如果改變引用變量的值，只是創(chuàng)建了不同的對(duì)象，原始對(duì)象并沒(méi)有改變。

def check(s):  print(s)  print(id(s))  s = "i am test"  print(id(s))  return ss = "This is a test"print(check(s))print(s)'''This is a test24184240294242418424029488i am testThis is a test'''

2.1.4深拷貝和淺拷貝

淺拷貝：語(yǔ)法：copy.copy()，淺拷貝是創(chuàng)建了一個(gè)和原對(duì)象一樣的類型，但是其內(nèi)容是對(duì)原對(duì)象元素的引用。

深拷貝：語(yǔ)法：copy.deepcopy(),在內(nèi)存中將所有的數(shù)據(jù)重新建立一份。

變量的本質(zhì)：在內(nèi)存中開(kāi)辟了一塊空間，其中存儲(chǔ)了指定類型的數(shù)據(jù)【實(shí)體（對(duì)象）存儲(chǔ)在堆中，變量（引用）存儲(chǔ)在棧空間中

2.2基本數(shù)據(jù)類型

Python中常用的數(shù)據(jù)類型有：整型（int）、浮點(diǎn)型（float）、字符串（string）、空值（None）、布爾值（True和False）、復(fù)數(shù)、類、函數(shù)等

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

變量的命名遵循標(biāo)識(shí)符的命名規(guī)則

2.3關(guān)鍵字、標(biāo)識(shí)符和內(nèi)置函數(shù)

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

Python中的關(guān)鍵字的查看使用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、標(biāo)識(shí)符的命名規(guī)則：標(biāo)識(shí)符的命名構(gòu)成：數(shù)字、字母、下劃線，但不能以數(shù)字開(kāi)頭，在標(biāo)識(shí)符的命名中嚴(yán)格區(qū)分大小寫

命名規(guī)范：

Python官方：所有單詞全部小寫，不同單詞之間使用下劃線分割，普遍是用駝峰命名法（小駝峰與大駝峰）

3、內(nèi)置函數(shù)：

import sysdir(sys.modules['__builin__'])

內(nèi)置函數(shù)表;

內(nèi)置函數(shù)abs()dict()help()min()setattr()all()dir()hex()next()slice()any()pmod()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運(yùn)算符2.4.1算術(shù)、賦值運(yùn)算符：

**：求冪運(yùn)算

//：整除運(yùn)算或者成為地板除

%：取余運(yùn)算

常用算數(shù)運(yùn)算符的優(yōu)先級(jí)：** > * > / // % > + -

賦值運(yùn)算符：=

復(fù)合運(yùn)算符：+=、-= 、*= 、/=

關(guān)系比較：==、!=、>=、<=等

2.4.2邏輯運(yùn)算運(yùn)算符邏輯表達(dá)式描述andx and y布爾"與" - 如果 x 為 False，x and y 返回 False，否則它返回 y 的計(jì)算值?！緊rx or y布爾"或" - 如果 x 是 True，它返回 x 的值，否則它返回 y 的計(jì)算值。notnot x布爾"非" - 如果 x 為 True，返回 False 。如果 x 為 False，它返回 True。算符描述&按位與運(yùn)算符：參與運(yùn)算的兩個(gè)值,如果兩個(gè)相應(yīng)位都為1,則該位的結(jié)果為1,否則為0|按位或運(yùn)算符：只要對(duì)應(yīng)的二個(gè)二進(jìn)位有一個(gè)為1時(shí)，結(jié)果位就為1。^按位異或運(yùn)算符：當(dāng)兩對(duì)應(yīng)的二進(jìn)位相異時(shí)，結(jié)果為1~按位取反運(yùn)算符：對(duì)數(shù)據(jù)的每個(gè)二進(jìn)制位取反,即把1變?yōu)?,把0變?yōu)?。~x 類似于 -x-1。（運(yùn)算原理：計(jì)算補(bǔ)碼，按位取反，轉(zhuǎn)為原碼，末尾加1）<<左移動(dòng)運(yùn)算符：運(yùn)算數(shù)的各二進(jìn)位全部左移若干位，由"<<"右邊的數(shù)指定移動(dòng)的位數(shù)，高位丟棄，低位補(bǔ)0。>>右移動(dòng)運(yùn)算符：把">>"左邊的運(yùn)算數(shù)的各二進(jìn)位全部右移若干位，">>"右邊的數(shù)指定移動(dòng)的位數(shù)

# 位運(yùn)算實(shí)例：x與y的數(shù)值的交換# 1、交叉賦值x, y = y, x# 2、第三方變量temp = xx = yy = temp# 3、異或# 規(guī)律：一個(gè)數(shù)異或另一個(gè)數(shù)兩次之后的結(jié)果為該數(shù)本身x = x ^ yy = x ^ yx = x ^ y# 4、加減法x = x + yy = x - yx = x - y

2.4.3成員及身份運(yùn)算：

成員運(yùn)算符：in、 not in

身份運(yùn)算符：is、is not

2.5Python 中的語(yǔ)句2.5.1if語(yǔ)句

if語(yǔ)句在Python中的兩種結(jié)構(gòu)為：

# 1if 條件表達(dá)式：    代碼塊# 2if 條件表達(dá)式：    代碼塊elif 條件表達(dá)式：    代碼塊  # 3if 條件表達(dá)式：    代碼塊else：    代碼塊

2.5.2for語(yǔ)句

for 變量 in 數(shù)據(jù)結(jié)構(gòu)：    循環(huán)體

# 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語(yǔ)句

while 條件表達(dá)式：
		代碼塊

# 9*9乘法表
while line < 10:
    temp = 1
    while temp <= line:
        print("%d x %d = %d"%(temp, line, temp*line),end = " ")
        temp += 1
    print("")
    line += 1

break：直接跳出當(dāng)前循環(huán)

continue：結(jié)束當(dāng)前正在執(zhí)行的循環(huán)，繼續(xù)下一次循環(huán)

三、Python內(nèi)置數(shù)據(jù)結(jié)構(gòu)：

Python中最基本的數(shù)據(jù)結(jié)構(gòu)是序列（sequence），Python包含 6 中內(nèi)建的序列，包括列表、元組、字符串、Unicode字符串、buffer對(duì)象和xrange對(duì)象。

3.1、String3.1.1、字符串的創(chuàng)建

將文本放在單引號(hào)，雙引號(hào)和三引號(hào)之間

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

3.1.2、字符串的轉(zhuǎn)義：

字符串的轉(zhuǎn)義使用r

3.1.3、字符串的切片操作

索引運(yùn)算符 s[i] 返回一個(gè)序列的元素i

切片運(yùn)算符 s[i:j] 返回一個(gè)在字符串中從第i個(gè)元素開(kāi)始到j(luò)-1之間的元素

擴(kuò)展切片運(yùn)算符 s[i:j:step] 在字符串中以step的步長(zhǎng)從第i個(gè)到j(luò)-1個(gè)元素之間的元素，step為正數(shù)表示正著取，i<i或者說(shuō)s[i,-1]倒著取

len(s) s中的元素個(gè)數(shù)

min(s) s的最小值

max(s) s的值

3.1.4字符串的相關(guān)方法：

s.index(sub [,start [,end]]) 找到指定字符串sub首次出現(xiàn)的位置

s.find(str,beg=0,end=len(string)) 找到字符串sub首次出現(xiàn)位置，與index不同是不報(bào)錯(cuò)而返回-1

s.upper() 將一個(gè)字符串轉(zhuǎn)換為大寫形式

s.lower() 將一個(gè)字符串轉(zhuǎn)化為小寫形式

s.join(t) 使用s作為分隔符連接序列t中的字符串 s.strip() 將s兩邊不顯示的符號(hào)去掉之后返回（lstrip、rstrip）

s.split(t) 獲取以字符t將s切割的列表

s.encode() 獲取s的指定編碼的bytes值

bytes.decode() 獲取bytes的對(duì)應(yīng)編碼的字符串，在python2中使用decode函數(shù)

s.endswith(suffix,beg=0, end=len(string)) 檢查中是否以suffix字符串結(jié)尾

3.2list

變量：相當(dāng)于是一個(gè)容器，每次只能存儲(chǔ)一個(gè)數(shù)據(jù)

作用：相當(dāng)于是一個(gè)容器，可以同時(shí)存儲(chǔ)多個(gè)數(shù)據(jù)

本質(zhì)：一種有序的集合【有序：數(shù)據(jù)的存放順序和底層存儲(chǔ)的順序是相同】

列表中的元素本質(zhì)存儲(chǔ)的是一個(gè)變量【引用】，列表是可變的【一個(gè)列表一旦被定義，則在代碼運(yùn)行的過(guò)程中，其中的元素的值可以隨時(shí)發(fā)生改變】

num = 10

list1 = [43,5,45,46,5]

print(id(list1[0]))

list1[0] = 100

#1.創(chuàng)建【定義一個(gè)列表類型的變量】
#命名方式：lxx   listxxx,不建議直接使用list
#其中允許存放重復(fù)元素
list1 = [45,23,2,54,54,6]
print(list1)

#其中允許存放不同類型的數(shù)據(jù)
list2 = ["hello",4637,False]
print(list2)


#列表元素的訪問(wèn)
#索引/下標(biāo)/角標(biāo)：取值范圍：0~len(xx)  - 1    或者  -1~ - （len(xxx)）
print(list1[3])
print(list1[-1])
#print(list1[20])   #IndexError: list index out of range 列表下標(biāo)越界


#列表元素的替換/修改
list1[3] = 473
print(list1)

#組合:生成了一個(gè)新的列表
print(list1 + list2)
print(list1)

#列表元素的重復(fù)
print(list1 * 3)
print(list1)

#判斷某個(gè)元素是否在列表中
print(10 in list1)  #False
print(10 not in list1) #True
print(45 in list1)      #True
print(45 not in list1)  #False

#列表切片【截取】：根據(jù)指定的列表獲取子列表
list3 = [45, 23, 2, 473, 54, 6,5,6,56,5]
print(list3[2])
print(list3)
#格式：列表名[start：end：step]，包頭不包尾
#獲取從指定下標(biāo)開(kāi)始到結(jié)尾的元素組成的一個(gè)子列表
print(list3[2:])
#獲取從開(kāi)頭到指定下標(biāo)的元素。。。。
print(list3[:6])
#截取指定區(qū)間
print(list3[2:6])

#特殊情況1：如果end超出了下標(biāo)的范圍，則默認(rèn)獲取從指定下標(biāo)開(kāi)始到結(jié)尾的元素
print(list3[4:100])
#等價(jià)于
print(list3[4:])

#特殊情況2：step在默認(rèn)情況下為1
print(list3[1:6:2])  #1,3,5
print(list3[-1:-6])  #當(dāng)start和end都為負(fù)數(shù)，step為正數(shù)的時(shí)候，獲取的結(jié)果為[]

print(list3[-1:-6:-2])  #當(dāng)start，end和step都為負(fù)數(shù)的時(shí)候，表示倒序

#將列表倒序輸出
print(list3[-1::-1])
print(list3[::-1])

#列表系統(tǒng)功能
#1.添加元素
#1.1append，追加，在列表的末尾添加元素                  常用
l1 = [22,33,44,55]
print(l1)
#追加單個(gè)元素
l1.append(66)
print(l1)
#追加多個(gè)元素，不能直接追加，通過(guò)列表的形式追加，形成了一個(gè)二維列表
#l1.append(77,88)  #報(bào)錯(cuò)：TypeError: append() takes exactly one argument (2 given)
l1.append([77,88])
print(l1)      #結(jié)果：[22, 33, 44, 55, 66, [77, 88]]

#1.2extend，擴(kuò)展，在列表的末尾添加元素
l2 = [22,33,44,55]
#追加單個(gè)元素,不能直接添加，參數(shù)一定是可迭代的
#l2.extend(66)   #T報(bào)錯(cuò)：ypeError: 'int' object is not iterable

l2.extend([66])
print(l2)

l2.extend([77,88])
print(l2)    #結(jié)果：[22, 33, 44, 55, 66, 77, 88]

"""
總結(jié)：
列表名.功能名(xx)
append可以直接添加單個(gè)元素，而extend不能
append在添加多個(gè)元素的時(shí)候，是以列表的形式添加，而extend只添加元素【打碎加入】
"""

#1.3insert，插入，在指定索引處插入一個(gè)元素，后面的元素向后順延
#列表名.insert(索引，被插入的元素)
l3 = [22,33,44,55]
#插入單個(gè)元素
l3.insert(2,66)
print(l3)
#插入多個(gè)元素:和append類似，將整個(gè)列表直接插入
l3.insert(1,[77,88])
print(l3)

#2.刪除
#2.1pop,彈出,移除并獲取列表中指定索引處的元素    在棧中【列表的底層工作原理是棧】
list1 = [11,22,33,44,55]
#注意：pop在默認(rèn)情況下刪除的是最后一個(gè)元素
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   清除，將指定列表變?yōu)榭樟斜?     使用場(chǎng)景：循環(huán)中，每次需要清空【重置】列表
list2.clear()
print(list2)

#3.獲取
list1 = [54,6,57,5,57,7,6,7,57]
#3.1len(),獲取列表長(zhǎng)度
l = len(list1)

#3.2max(),獲取列表中的值
print(max(list1))
#3.3min()，獲取列表中的最小值
print(min(list1))

#練習(xí)：模擬max或者min的功能，求三個(gè)數(shù)中的值
#假設(shè)法
num1 = 43
num2 = 437
num3 = 2
#定義一個(gè)變量，用于記錄值
max1 = num1
if num2 > num1:
max1 = num2

if 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(),統(tǒng)計(jì)個(gè)數(shù)，統(tǒng)計(jì)指定元素在列表中出現(xiàn)的次數(shù)
c = list1.count(57)
print(c)

list1 = [54,6,57,5,57,7,6,7,57,57,57,436]
#練習(xí)：將list1中57給全部刪除
# list1.remove(57)
# list1.remove(57)
# list1.remove(57)
# print(list1)

#統(tǒng)計(jì)57在列表中出現(xiàn)的次數(shù)
num = 57
c = list1.count(num)
n = 1
while n <= c:
list1.remove(num)
n += 1

print(list1)

import  copy
#4.其他用法
#4.1.reverse,反轉(zhuǎn)
list1 = [35,4,5,4,654]

#print(list1[::-1])
# list1.reverse()
# print(list1)

#4.2.1sort,排序,默認(rèn)為升序,在列表內(nèi)部進(jìn)行排序
#列表名.sort()
#升序
# list1.sort()
# print(list1)
#降序
# list1.sort(reverse=True)
# print(list1)

#4.2.2sorted，排序,默認(rèn)為升序，生成了一個(gè)新的列表
#sorted(列表名)
#升序
newList = sorted(list1)
print(list1)
print(newList)
#降序
newList2 = sorted(list1,reverse=True)
print(newList2)

#根據(jù)元素的長(zhǎng)度進(jìn)行排序
list2 = ["gjsrghj","545","fhghg","ahjegrhkwjhgrke"]
#key關(guān)鍵字參數(shù)可以指定自定義的排序規(guī)則,格式：key=函數(shù)名
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，深拷貝，堆空間層面上的拷貝【實(shí)體】
list1 = [23,54,56]
list2 = list1.copy()
list2[1] = 100
print(list1)
print(list2)
print(id(list1) == id(list2))


#模塊copy ，copy(),deeepcopy()【面試題】
#內(nèi)容角度上的拷貝，copy只拷貝最外層，deepcopy可以拷貝內(nèi)層的內(nèi)容【二維列表中】
a = [1,2,3]
b = [4,5,6]
c = [a,b]
print(c)

d = copy.copy(c)
print(id(d) == id(c))   #False

e = copy.deepcopy(c)
print(id(e) == id(c))   #False

a.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轉(zhuǎn)換
#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

和列表類似，本質(zhì)是一種有序的集合

元組和列表的不同之處：

a.定義不同：列表[] 元組()

b.是否能夠修改：列表可以進(jìn)行增加或者刪除元素的操作，但是，元組一旦被定義之后，其中的元素將不能進(jìn)行任何的更改

#其中允許存儲(chǔ)重復(fù)元素
t1 = (23,53,54,53)
print(t1)

#其中允許存儲(chǔ)不同類型的數(shù)據(jù)
t2 = ("hello",47,19.0,False)
print(t2)

#特殊情況:當(dāng)一個(gè)元組中只有一個(gè)元素的之后，會(huì)被識(shí)別為一個(gè)普通變量
t3 = (10)
print(type(t3))
print(t3)

#為了消除歧義，當(dāng)元組中只有一個(gè)元素的時(shí)候，元組名 = (元素,)
t4 = (10,)
print(type(t4))
print(t4)

#元組元素的訪問(wèn)
#元組名[索引]
print(t2[1])
#t2[1] = 100    #報(bào)錯(cuò)：TypeError: 'tuple' object does not support item assignment【賦值】

#特殊情況：如果在元組中的元素是列表，則列表中的元素依舊可以修改
# 【依據(jù)：元組和列表中存儲(chǔ)都是變量的地址，元素不允許修改，只需要保證未發(fā)生改變即可其中的地址】
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])

#同時(shí)遍歷索引和元素
#需要將元組或者列表轉(zhuǎn)換為枚舉類型
#list(t5)
#注意：下面的i并不是元組或者列表的索引，而是枚舉中的編號(hào)
for i,element in enumerate(t5):
print(i,element)

3.4dict 常用

也是一種存儲(chǔ)數(shù)據(jù)的方式，但是字典是無(wú)序的，

類似于list或者tuple，但是，字典采用鍵-值對(duì)的方式存儲(chǔ)數(shù)據(jù)

age1 = 10

list1 = [10,4,35,46,6]

dict1 = {"zhangsan":10}

作用：具有極快的查找速度

鍵【key】相當(dāng)于list或者tuple中的索引

key的特點(diǎn)

a.字典的key是唯一的【key不允許重復(fù)】

b.key必須為不可變的數(shù)據(jù)

list是可變的，不能用來(lái)當(dāng)做key

tuple，數(shù)字型，字符串，布爾值都是不可變的，可以被充當(dāng)key

dict1 = {"zhangsan":10,"lisi":13,"zhaoliu":50}
#1.訪問(wèn)鍵值對(duì)
print(dict1["lisi"])

#訪問(wèn)一個(gè)不存在的key，則報(bào)錯(cuò)
#print(dict1["abc"])  #KeyError: 'abc'

#字典是可變的
dict1["zhaoliu"] = 100
result0 = dict1["zhaoliu"]
print(result0)

#字典名[key] = value
#注意：如果key存在，則表示修改value的值；如果key不存在，則表示在字典中添加一對(duì)新的鍵值對(duì)
dict1["abc"] = 20
print(dict1)

#get()
result1 = dict1.get("zhaoliu")
print(result1)
#如果key不存在，則不會(huì)報(bào)錯(cuò)，返回None，一般用于判斷
result2 = dict1.get("def")
print(result2)

#2.刪除，pop
#注意：刪除指定的key，對(duì)應(yīng)的value也會(huì)隨著刪除
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,遍歷的是鍵值對(duì)的編號(hào)和key
for i,element in enumerate(dict1):
print(i,element)

#3.4同時(shí)遍歷key和value               掌握
for key,value in dict1.items():
print(key,value)


"""
【面試題：dict和list之間的區(qū)別】
1.dict查找和插入的速度不會(huì)因?yàn)閗ey-value的增多而變慢，
  而list在每次查找的時(shí)候都是從頭到尾進(jìn)行遍歷，當(dāng)數(shù)據(jù)量大的時(shí)候，list速度肯定會(huì)變慢
2.dict需要占用大量的內(nèi)存空間，內(nèi)存浪費(fèi)多，
 而list只相當(dāng)于存儲(chǔ)了字典中的key或者value，并且list數(shù)據(jù)是緊密排列的
"""

練習(xí)：

""""
1.逐一顯示列表l1 = ["Sun","Mon","Tue","Wed","Thu","Fri","Sat"]中索引為奇數(shù)的元素
2.將屬于列表l1 = ["Sun","Mon","Tue","Wed","Thu","Fri","Sat"]，
但不屬于列表l2 = ["Sun","Mon","Thu","Fri","Sat"]的所有元素定義為一個(gè)新列表l3
3.已知列表namelist=['stu1','stu2','stu3','stu4','stu5','stu6','stu7']，刪除列表removelist=['stu3', 'stu7', 'stu9']；
請(qǐng)將屬于removelist列表中的每個(gè)元素從namelist中移除(屬于removelist，但不屬于namelist的忽略即可)；
4.有一個(gè)字符串是一句英文，統(tǒng)計(jì)每個(gè)單詞出現(xiàn)的次數(shù)，生成一個(gè)字典，單詞作為key，次數(shù)作為value生成一個(gè)字典dict1
5.已知列表list1 = [0,1,2,3,4,5,6],list2 = ["Sun","Mon","Tue","Wed","Thu","Fri","Sat"],
以list1中的元素作為key，list2中的元素作為value生成一個(gè)字典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中是否存在，如果不存在，則添加到一個(gè)新的列表中
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)
#遍歷列表，獲取其中的每個(gè)單詞
for word in list1:
#在字典中通過(guò)key獲取value
c = dict1.get(word)
if c == None:
    #不存在，添加鍵值對(duì)
    dict1[word] = 1
else:
    #存在，則將value的值遞增1
    dict1[word] += 1

print(dict1)

#5.
list1 = [0,1,2,3,4,5,6]
list2 = ["Sun","Mon","Tue","Wed","Thu","Fri","Sat"]
dict2 = {}
#定義一個(gè)變量，作為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 += 1

elif len(list1) > len(list2):
while index1 < len(list2):
    dict2[list1[index1]] = list2[index1]
    index1 += 1

else:
while index1 < len(list1):
    dict2[list1[index1]] = list2[index1]
    index1 += 1


# 優(yōu)化上面的代碼：封裝【抽取】
"""
def custom(num):
dict2[list1[num]] = list2[num]
num += 1
return num

#定義一個(gè)變量，作為list1和list2的索引
index1 = 0

if len(list1) == len(list2):
while index1 < len(list1):

    #dict2[key] = value =======>dict2[list1中的元素] = list2中的元素
    #list1[index1]   list2[index1]
    r = custom(index1)
    index1 = r

elif len(list1) > len(list2):
while index1 < len(list2):
    r = custom(index1)
    index1 = r

else:
while index1 < len(list1):
    r = custom(index1)
    index1 = r
"""

print(dict2)

3.4set

集合：不允許重復(fù)元素，而且進(jìn)行交集以及并集的運(yùn)算

表示：{}

和dict之間的關(guān)系：set中只是存儲(chǔ)了key

本質(zhì)：無(wú)序且無(wú)重復(fù)元素的集合

#1.創(chuàng)建
#set()
s1 = {23,45,6,7,89}
print(s1)
print(type(s1))

#掌握：去除列表中的重復(fù)元素
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}
#單個(gè)元素
set1.add(66)
print(set1)
#如果元素存在，則添加失敗，不報(bào)錯(cuò)
set1.add(55)
#多個(gè)元素
#s1.add([77,88])   #TypeError: unhashable type: 'list'
s1.add((77,88))
#s1.add({1:"a"})
#結(jié)論：在set中，使用add添加，則只能添加元組，不能添加list和dict
print(s1)

#update()，更新,update的參數(shù)只能是可迭代對(duì)象【打碎加入】
set2 = {11,22,33,44,55}
#set2.update(66)   #報(bào)錯(cuò)：TypeError: 'int' object is not iterable

set2.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的區(qū)別和聯(lián)系：

a、定義方式：list：[]、tuple：（）、dict：{}、set：{}

b、是否有序：list:有序，tuple：有序，dict：無(wú)序，set：無(wú)序

c、是否允許出現(xiàn)重復(fù)元素：list：允許，tuple：允許，dict：key鍵值不允許，但是value的值允許，set：不允許

d、都屬于可迭代對(duì)象

e、set相當(dāng)于存儲(chǔ)了字典中的key

f、可以向互轉(zhuǎn)化

4、附錄4.1 字符串轉(zhuǎn)義字符表

在需要在字符中使用特殊字符時(shí)，python用反斜杠()轉(zhuǎn)義字符。如下表：

轉(zhuǎn)義字符描述(在行尾時(shí))續(xù)行符\\反斜杠符號(hào)\\'單引號(hào)\\"雙引號(hào)\\a響鈴\\b退格(Backspace)\\e轉(zhuǎn)義\\000空\(chéng)\n換行\(zhòng)\v縱向制表符\\t橫向制表符\\r回車\\f換頁(yè)\\oyy八進(jìn)制數(shù)，yy代表的字符，例如：\\o12代表?yè)Q行\(zhòng)\xyy十六進(jìn)制數(shù)，yy代表的字符，例如：\\x0a代表?yè)Q行\(zhòng)\other其它的字符以普通格式輸出4.2 python字符串格式化符號(hào)表符 號(hào)描述%c格式化字符及其ASCII碼%s格式化字符串%d格式化整數(shù)%u格式化無(wú)符號(hào)整型%o格式化無(wú)符號(hào)八進(jìn)制數(shù)%x格式化無(wú)符號(hào)十六進(jìn)制數(shù)%X格式化無(wú)符號(hào)十六進(jìn)制數(shù)（大寫）%f格式化浮點(diǎn)數(shù)字，可指定小數(shù)點(diǎn)后的精度%e用科學(xué)計(jì)數(shù)法格式化浮點(diǎn)數(shù)%E作用同%e，用科學(xué)計(jì)數(shù)法格式化浮點(diǎn)數(shù)%g%f和%e的簡(jiǎn)寫%G%f 和 %E 的簡(jiǎn)寫%p用十六進(jìn)制數(shù)格式化變量的地址4.3 格式化操作符輔助指令表符號(hào)功能*定義寬度或者小數(shù)點(diǎn)精度-用做左對(duì)齊+在正數(shù)前面顯示加號(hào)( + )<sp>在正數(shù)前面顯示空格#在八進(jìn)制數(shù)前面顯示零('0')，在十六進(jìn)制前面顯示'0x'或者'0X'(取決于用的是'x'還是'X')0顯示的數(shù)字前面填充'0'而不是默認(rèn)的空格%'%%'輸出一個(gè)單一的'%'(var)映射變量(字典參數(shù))m.n.m 是顯示的最小總寬度,n 是小數(shù)點(diǎn)后的位數(shù)(如果可用的話)4.4 字符串內(nèi)建方法表序號(hào)方法描述1capitalize()將字符串的第一個(gè)字符轉(zhuǎn)換為大寫2center(width, fillchar)返回一個(gè)指定的寬度 width 居中的字符串，fillchar 為填充的字符，默認(rèn)為空格。3count(str, beg= 0,end=len(string))返回 str 在 string 里面出現(xiàn)的次數(shù)，如果 beg 或者 end 指定則返回指定范圍內(nèi) str 出現(xiàn)的次數(shù)**4bytes.decode(encoding="utf-8", errors="strict")Python3 中沒(méi)有 decode 方法，但我們可以使用 bytes 對(duì)象的 decode() 方法來(lái)解碼給定的 bytes 對(duì)象，這個(gè) bytes 對(duì)象可以由 str.encode() 來(lái)編碼返回。**5encode(encoding='UTF-8',errors='strict')以 encoding 指定的編碼格式編碼字符串，如果出錯(cuò)默認(rèn)報(bào)一個(gè)ValueError 的異常，除非 errors 指定的是'ignore'或者'replace'**6endswith(suffix, beg=0, end=len(string))檢查字符串是否以 obj 結(jié)束，如果beg 或者 end 指定則檢查指定的范圍內(nèi)是否以 obj 結(jié)束，如果是，返回 True,否則返回 False.7expandtabs(tabsize=8)把字符串 string 中的 tab 符號(hào)轉(zhuǎn)為空格，tab 符號(hào)默認(rèn)的空格數(shù)是 8 。**8find(str, beg=0 end=len(string))檢測(cè) str 是否包含在字符串中，如果指定范圍 beg 和 end ，則檢查是否包含在指定范圍內(nèi)，如果包含返回開(kāi)始的索引值，否則返回-19index(str, beg=0, end=len(string))跟find()方法一樣，只不過(guò)如果str不在字符串中會(huì)報(bào)一個(gè)異常.10isalnum()如果字符串至少有一個(gè)字符并且所有字符都是字母或數(shù)字則返 回 True,否則返回 False11isalpha()如果字符串至少有一個(gè)字符并且所有字符都是字母則返回 True, 否則返回 False12isdigit()如果字符串只包含數(shù)字則返回 True 否則返回 False..13islower()如果字符串中包含至少一個(gè)區(qū)分大小寫的字符，并且所有這些(區(qū)分大小寫的)字符都是小寫，則返回 True，否則返回 False14isnumeric()如果字符串中只包含數(shù)字字符，則返回 True，否則返回 False15isspace()如果字符串中只包含空白，則返回 True，否則返回 False.16istitle()如果字符串是標(biāo)題化的(見(jiàn) title())則返回 True，否則返回 False17isupper()如果字符串中包含至少一個(gè)區(qū)分大小寫的字符，并且所有這些(區(qū)分大小寫的)字符都是大寫，則返回 True，否則返回 False**18join(seq)以指定字符串作為分隔符，將 seq 中所有的元素(的字符串表示)合并為一個(gè)新的字符串*19len(string)返回字符串長(zhǎng)度20ljust(width[, fillchar])返回一個(gè)原字符串左對(duì)齊,并使用 fillchar 填充至長(zhǎng)度 width 的新字符串，fillchar 默認(rèn)為空格。21lower()轉(zhuǎn)換字符串中所有大寫字符為小寫.22lstrip()截掉字符串左邊的空格或指定字符。**23maketrans()創(chuàng)建字符映射的轉(zhuǎn)換表，對(duì)于接受兩個(gè)參數(shù)的最簡(jiǎn)單的調(diào)用方式，第一個(gè)參數(shù)是字符串，表示需要轉(zhuǎn)換的字符，第二個(gè)參數(shù)也是字符串表示轉(zhuǎn)換的目標(biāo)。*24max(str)返回字符串 str 中的字母。*25min(str)返回字符串 str 中最小的字母。**26replace(old, new [, max])把 將字符串中的 str1 替換成 str2,如果 max 指定，則替換不超過(guò) max 次。27rfind(str, beg=0,end=len(string))類似于 find()函數(shù)，不過(guò)是從右邊開(kāi)始查找.28rindex( str, beg=0, end=len(string))類似于 index()，不過(guò)是從右邊開(kāi)始.29rjust(width,[, fillchar])返回一個(gè)原字符串右對(duì)齊,并使用fillchar(默認(rèn)空格）填充至長(zhǎng)度 width 的新字符串30rstrip()刪除字符串字符串末尾的空格.**31split(str="", num=string.count(str))num=string.count(str)) 以 str 為分隔符截取字符串，如果 num 有指定值，則僅截取 num 個(gè)子字符串**32splitlines([keepends])按照行('\\r', '\\r\\n', \\n')分隔，返回一個(gè)包含各行作為元素的列表，如果參數(shù) keepends 為 False，不包含換行符，如果為 True，則保留換行符。**33startswith(str, beg=0,end=len(string))檢查字符串是否是以 obj 開(kāi)頭，是則返回 True，否則返回 False。如果beg 和 end 指定值，則在指定范圍內(nèi)檢查。**34strip([chars])在字符串上執(zhí)行 lstrip()和 rstrip()35swapcase()將字符串中大寫轉(zhuǎn)換為小寫，小寫轉(zhuǎn)換為大寫36title()返回"標(biāo)題化"的字符串,就是說(shuō)所有單詞都是以大寫開(kāi)始，其余字母均為小寫(見(jiàn) istitle())**37translate(table, deletechars="")根據(jù) str 給出的表(包含 256 個(gè)字符)轉(zhuǎn)換 string 的字符, 要過(guò)濾掉的字符放到 deletechars 參數(shù)中38upper()轉(zhuǎn)換字符串中的小寫字母為大寫39zfill (width)返回長(zhǎng)度為 width 的字符串，原字符串右對(duì)齊，前面填充040isdecimal()檢查字符串是否只包含十進(jìn)制字符，如果是返回 true，否則返回 false。

備注： *標(biāo)記為相關(guān)內(nèi)建函數(shù)，**標(biāo)記為常用方法。

4.5 Python列表函數(shù)&方法

Python包含以下函數(shù):

序號(hào)函數(shù)描述1[len(list)列表元素個(gè)數(shù)2[max(list)返回列表元素值3[min(list)返回列表元素最小值4[list(seq)將元組轉(zhuǎn)換為列表

Python包含以下方法:

序號(hào)方法描述1list.append(obj)在列表末尾添加新的對(duì)象2list.count(obj)統(tǒng)計(jì)某個(gè)元素在列表中出現(xiàn)的次數(shù)3list.extend(seq)在列表末尾一次性追加另一個(gè)序列中的多個(gè)值（用新列表擴(kuò)展原來(lái)的列表）4list.index(obj)從列表中找出某個(gè)值第一個(gè)匹配項(xiàng)的索引位置5list.insert(index, obj)將對(duì)象插入列表6list.pop([index=-1])移除列表中的一個(gè)元素（默認(rèn)最后一個(gè)元素），并且返回該元素的值7list.remove(obj)移除列表中某個(gè)值的第一個(gè)匹配項(xiàng)8list.reverse()反向列表中元素9list.sort(cmp=None, key=None, reverse=False)對(duì)原列表進(jìn)行排序10list.clear()清空列表11list.copy()復(fù)制列表

標(biāo)題名稱：Python有哪些基礎(chǔ)知識(shí)
轉(zhuǎn)載注明：http://www.rwnh.cn/article46/cjopeg.html

成都網(wǎng)站建設(shè)公司_創(chuàng)新互聯(lián)，為您提供品牌網(wǎng)站建設(shè)、手機(jī)網(wǎng)站建設(shè)、外貿(mào)建站、網(wǎng)站設(shè)計(jì)公司、營(yíng)銷型網(wǎng)站建設(shè)、企業(yè)建站

廣告

聲明：本網(wǎng)站發(fā)布的內(nèi)容（圖片、視頻和文字）以用戶投稿、用戶轉(zhuǎn)載內(nèi)容為主，如果涉及侵權(quán)請(qǐng)盡快告知，我們將會(huì)在第一時(shí)間刪除。文章觀點(diǎn)不代表本網(wǎng)站立場(chǎng)，如需處理請(qǐng)聯(lián)系客服。電話：028-86922220；郵箱：631063699@qq.com。內(nèi)容未經(jīng)允許不得轉(zhuǎn)載，或轉(zhuǎn)載時(shí)需注明來(lái)源： 創(chuàng)新互聯(lián)