Python基礎(chǔ)知識的總結(jié)

小編給大家分享一下Python基礎(chǔ)知識的總結(jié)，相信大部分人都還不怎么了解，因此分享這篇文章給大家參考一下，希望大家閱讀完這篇文章后大有收獲，下面讓我們一起去了解一下吧！

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

Python基礎(chǔ)知識總結(jié)

一、Python概述：

1.1、Python的特點：

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

2、Python是一門解釋性語言

3、Python是一門交互式語言，即其在終端中進行命令編程

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

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

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

1、優(yōu)點：

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

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

c、可擴展性

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

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

f、語法簡單，易于學(xué)習(xí)

2、缺點：

a、和C語言相比較Python的代碼運行速度慢

b、代碼無法加密

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

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

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

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

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

二、Python中的基礎(chǔ)語法：

2.1、Python中變量在內(nèi)存中的存儲

2.1.1引用和對象：

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

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

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

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

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

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

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

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

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

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

說明：可變對象為引用傳遞，不可變對象為值傳遞

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

  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)傳遞不可變對象時，如果改變引用變量的值，只是創(chuàng)建了不同的對象，原始對象并沒有改變。

  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深拷貝和淺拷貝

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

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

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

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

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

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

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

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

命名規(guī)范：

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

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

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

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

2.4Python運算符

2.4.1算術(shù)、賦值運算符：

**：求冪運算

//：整除運算或者成為地板除

%：取余運算

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

賦值運算符：=

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

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

2.4.2邏輯運算

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

2.4.3成員及身份運算：

成員運算符：in、 not in

身份運算符：is、is not

2.5Python 中的語句

2.5.1if語句

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

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

2.5.2for語句

  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語句

while 條件表達式：
		代碼塊

# 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對象和xrange對象。

3.1、String

3.1.1、字符串的創(chuàng)建

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

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

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

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

3.1.3、字符串的切片操作

• 索引運算符 s[i] 返回一個序列的元素i

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

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

  len(s) s中的元素個數(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不同是不報錯而返回-1

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

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

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

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

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

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

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

3.2list

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

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

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

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

num = 10

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

print(id(list1[0]))

list1[0] = 100

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

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


#列表元素的訪問
#索引/下標(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)

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

#列表元素的重復(fù)
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

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

#特殊情況1：如果end超出了下標(biāo)的范圍，則默認(rèn)獲取從指定下標(biāo)開始到結(jié)尾的元素
print(list3[4:100])
#等價于
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ù)的時候，獲取的結(jié)果為[]

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

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

#列表系統(tǒng)功能
#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)      #結(jié)果：[22, 33, 44, 55, 66, [77, 88]]

#1.2extend，擴展，在列表的末尾添加元素
l2 = [22,33,44,55]
#追加單個元素,不能直接添加，參數(shù)一定是可迭代的
#l2.extend(66)   #T報錯：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可以直接添加單個元素，而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在默認(rèn)情況下刪除的是最后一個元素
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)榭樟斜?     使用場景：循環(huán)中，每次需要清空【重置】列表
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))

#練習(xí)：模擬max或者min的功能，求三個數(shù)中的最大值
#假設(shè)法
num1 = 43
num2 = 437
num3 = 2
#定義一個變量，用于記錄最大值
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)計個數(shù)，統(tǒng)計指定元素在列表中出現(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)計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)部進行排序
#列表名.sort()
#升序
# list1.sort()
# print(list1)
#降序
# list1.sort(reverse=True)
# print(list1)

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

#根據(jù)元素的長度進行排序
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，深拷貝，堆空間層面上的拷貝【實體】
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.是否能夠修改：列表可以進行增加或者刪除元素的操作，但是，元組一旦被定義之后，其中的元素將不能進行任何的更改

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

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

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

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

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

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

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

3.4dict 常用

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

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

age1 = 10

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

dict1 = {"zhangsan":10}

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

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

key的特點

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

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

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

tuple，數(shù)字型，字符串，布爾值都是不可變的，可以被充當(dāng)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，對應(yīng)的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之間的區(qū)別】
1.dict查找和插入的速度不會因為key-value的增多而變慢，
  而list在每次查找的時候都是從頭到尾進行遍歷，當(dāng)數(shù)據(jù)量大的時候，list速度肯定會變慢
2.dict需要占用大量的內(nèi)存空間，內(nèi)存浪費多，
 而list只相當(dāng)于存儲了字典中的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"]的所有元素定義為一個新列表l3
3.已知列表namelist=['stu1','stu2','stu3','stu4','stu5','stu6','stu7']，刪除列表removelist=['stu3', 'stu7', 'stu9']；
請將屬于removelist列表中的每個元素從namelist中移除(屬于removelist，但不屬于namelist的忽略即可)；
4.有一個字符串是一句英文，統(tǒng)計每個單詞出現(xiàn)的次數(shù)，生成一個字典，單詞作為key，次數(shù)作為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的值遞增1
    dict1[word] += 1

print(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 += 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

#定義一個變量，作為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ù)元素，而且進行交集以及并集的運算

表示：{}

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

本質(zhì)：無序且無重復(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}
#單個元素
set1.add(66)
print(set1)
#如果元素存在，則添加失敗，不報錯
set1.add(55)
#多個元素
#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ù)只能是可迭代對象【打碎加入】
set2 = {11,22,33,44,55}
#set2.update(66)   #報錯：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：無序，set：無序

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

d、都屬于可迭代對象

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

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

4、附錄

4.1 字符串轉(zhuǎn)義字符表

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

4.2 python字符串格式化符號表

4.3 格式化操作符輔助指令表

4.4 字符串內(nèi)建方法表

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

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

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

Python包含以下方法:

以上是Python基礎(chǔ)知識的總結(jié)的所有內(nèi)容，感謝各位的閱讀！相信大家都有了一定的了解，希望分享的內(nèi)容對大家有所幫助，如果還想學(xué)習(xí)更多知識，歡迎關(guān)注億速云行業(yè)資訊頻道！