大家好，我是紀(jì)寧。
文章將從C語言出發(fā)，深入介紹python的基礎(chǔ)知識，也包括很多python的新增知識點(diǎn)詳解。

1.python的輸入輸出，重新認(rèn)識 hello world，重回那個激情燃燒的歲月

在C語言中，在進(jìn)行輸入輸出的時候，通常要遵循一定的格式，如變量名必須與變量的類型嚴(yán)格對應(yīng)，輸出輸入的每一個變量都要在數(shù)量和格式上都要一一對應(yīng)，而 python 變得更加簡潔和方便

1.1 輸出函數(shù)print的規(guī)則

python 中的輸入函數(shù)是print，相比于C語言，少了一個f，但功能卻方便了很多。想輸出什么（變量或者直接輸出），就直接往 print 函數(shù)里面塞就行了，不用管什么格式，數(shù)據(jù)類型。但它的多組輸出還是會有一定的規(guī)則，否則使用者也難以很好的把握輸出的格式。
下面是 print 函數(shù)輸出不同于 C 的一些規(guī)則：

• 在同一個 print 函數(shù)的輸出中，通常會默認(rèn)每個數(shù)據(jù)之間以空格分開（C中卻是默認(rèn)不分開），而要去掉這以規(guī)則，可以在 print函數(shù)內(nèi)部加上 sep 參數(shù)。給 sep 參數(shù)賦值可以使一個 print 函數(shù)打印出的每個數(shù)據(jù)之間以任意方式隔開，如空字符，逗號等等。
• 而在多個 print 函數(shù)的輸出中，通常會默認(rèn)這些數(shù)據(jù)之間會自動換行，如果想去掉這一規(guī)則，可以在 print 函數(shù)內(nèi)部加上 end 參數(shù)，給 end 參數(shù)賦值，可以是每個 print 輸出的值以給 end 賦的值隔開。
  

為什么可以這樣呢？其實(shí)在python 的 print 函數(shù)內(nèi)部，是有 end 參數(shù)和 sep 參數(shù)的，只不過在不使用這兩個參數(shù)的情況下，系統(tǒng)會默認(rèn) end 參數(shù)的值為‘\n’，sep 參數(shù)的值為‘ ’（空格），所以就出現(xiàn)上述情況。

1.2 輸入函數(shù)input的規(guī)則

python 中的輸入函數(shù)是 input ，相對于C語言，input 函數(shù)也是比較方便。input函數(shù)可以直接讀取從終端（鍵盤）輸入的數(shù)據(jù)并存儲到變量中，也可以在給出提示后，將想要的答案通過鍵盤輸入并存儲到變量中。

上面代碼意思是從控制臺輸入一個值，再將這個值賦值給變量，其中input 括號里的文字提示在沒有的情況下，效果是一樣的，但有問題提示就比較人性化一點(diǎn)。
有個問題需要注意的是，因?yàn)?input 函數(shù)在輸入的時候沒有規(guī)定數(shù)據(jù)類型，所以輸入的數(shù)據(jù)默認(rèn)都是以字符串的形式返回并賦值給變量。如果要進(jìn)行計算，需要及時將輸入的數(shù)據(jù)進(jìn)行類型轉(zhuǎn)化，否則就會報錯。

需要什么類型的數(shù)據(jù)進(jìn)行計算就轉(zhuǎn)化為什么類型的數(shù)據(jù)。

1.3 用print將數(shù)據(jù)寫入文件

同C一樣，python 中如果要對文件進(jìn)行操作，也需要先打開文件，操作完關(guān)閉文件。python中打開文件的函數(shù)為 open 函，關(guān)閉文件的函數(shù)為 close 。

open 函數(shù)的第一個參數(shù)為要寫入文件的路徑，第二個參數(shù)為對文件進(jìn)行讀寫的模式。
print 函數(shù)的第一個參數(shù)是要寫入的數(shù)據(jù)內(nèi)容，第二個參數(shù)是要寫入的文件對象。
下表為文件操作的一些常用模式

如下圖，打開 D 盤中的 text.txt 文件，即可看到寫入的 hello world。

2.數(shù)據(jù)類型、基本操作符與注釋

2.1數(shù)據(jù)類型

python 中的數(shù)據(jù)類型分為 4 類，整型，浮點(diǎn)型，布爾型，字符串。

整型、浮點(diǎn)型就不必多說了，和C完全相同。而python的布爾類型則是對真假的判斷，True 為真，F(xiàn)alse 為假，并且他們True 的值默認(rèn)為1，F(xiàn)alse 的值默認(rèn)為0。
除了以下圖片里的布爾值為False，其余均為True

字符串類型是不可變類型，可以用單引號、雙引號，多引號來定義，其中單、雙引號定義的字符串都必須在同一行，三引號定義的字符串可以在一行或者多行，如下圖。

不同類型的數(shù)據(jù)如果要一起使用必須轉(zhuǎn)化為同一種類型，浮點(diǎn)數(shù)和整形會自動將結(jié)果轉(zhuǎn)化為浮點(diǎn)型數(shù)據(jù)，其他的類型在可轉(zhuǎn)化的前提下可以使用類型轉(zhuǎn)化函數(shù)將數(shù)據(jù)進(jìn)行類型轉(zhuǎn)化。

2.2 基本操作符

2.21 算數(shù)操作符

算數(shù)操作符中，最基本的加減乘、取模都與C相同。不同的是python中進(jìn)行了除法分類，并加入了冪運(yùn)算符。
python 將除法分為了整數(shù)除法（//）和普通除法（/），而整數(shù)除法就是向下取整，大家應(yīng)該懂的，和C一樣，而普通除法可以進(jìn)行正常的運(yùn)算，兩個整數(shù)相除也可以得到浮點(diǎn)數(shù)。
冪運(yùn)算符（**）前面的操作數(shù)是冪運(yùn)算的底數(shù)，后面的操作數(shù)是冪運(yùn)算的次數(shù)。

2.22 邏輯操作符

邏輯與and、邏輯或or、邏輯非not，分別對應(yīng)C語言中的&&，||，！運(yùn)算符。
而 in 則是用于判斷一個元素是否在一個容器中，具體來說，可以用于判斷元素是否在列表、字符串、元組、集合、字典中，not in 正好相反，是判斷元素是否不在容器中。

2.23 位操作符及操作符優(yōu)先級

python的位操作符與C是一樣的，有& 按位與 ，| 按位或， ^ 按位異或， ~ 按位取反，<< 左移， >>右移。具體方法與C中是一樣的，這里就不過多贅述。
操作符的優(yōu)先級
嚴(yán)格按照下面的優(yōu)先級進(jìn)行運(yùn)算，如果不確定或者要先計算優(yōu)先級低的運(yùn)算記得加括號。

2.3 注釋

python的注釋方式也進(jìn)行了改變，注釋方式改為在語句前加 # 號
在 PyCharm 中，對多段語句進(jìn)行整體注釋方式是 Ctrl+ /

3.數(shù)據(jù)的存儲

python中數(shù)據(jù)如何存儲

python存儲數(shù)據(jù)的邏輯圖

每個數(shù)據(jù)都有自己的 id，而變量中存儲的僅僅是這個數(shù)據(jù)的 id，編譯器通過這個 id 就找到了這塊的數(shù)據(jù)，進(jìn)而進(jìn)行一系列操作，這里的 id 類似于C中的地址，而這樣的訪問方式類似于指針。
可以用 is 來比較兩個變量的 id 時候相等

返回True，說明變量 a 和 b 訪問是同一塊內(nèi)存空間，完全相等。
在C中，數(shù)據(jù)會被存儲到多個區(qū)域中，如堆區(qū)，棧區(qū)等等，下圖為C中數(shù)據(jù)存儲的區(qū)域

python中也有大量的區(qū)域供使用者存儲數(shù)據(jù)

棧區(qū)：存儲基本數(shù)據(jù)類型及其對象（如int、float、bool等），以及函數(shù)調(diào)用時的參數(shù)、返回值和局部變量等。棧內(nèi)存自動分配和釋放，具有快速的存取速度。
堆區(qū)：存儲復(fù)雜對象（如列表、元組、字典等）及其對象。堆內(nèi)存的分配與釋放由Python解釋器自動進(jìn)行，可以通過Python中的垃圾回收機(jī)制自動釋放內(nèi)存。
數(shù)據(jù)區(qū)：存儲全局變量和靜態(tài)變量，以及常量等數(shù)據(jù)。
代碼區(qū)：存儲Python的字節(jié)碼，即轉(zhuǎn)換成機(jī)器碼之前的中間代碼。

在C中，需要手動分配和釋放動態(tài)內(nèi)存，而在Python中，內(nèi)存管理是自動的，Python解釋器會根據(jù)需要自動分配和釋放內(nèi)存。

4.分支和循環(huán)

分支和循環(huán)這里與C語言大同小異，邏輯上大同，語法規(guī)則上小異。

4.1 分支語句 if-else

python語法如下，與C相比，只是去掉了括號，如果if中包含多條語句，則可使用相同的縮進(jìn)來代替C中的大括號。

if condition:
    # code to be executed if condition is True
else:
    # code to be executed if condition is False

其中，condition是一個表達(dá)式，如果結(jié)果為True，代碼塊1就會被執(zhí)行，否則代碼塊2就會被執(zhí)行。
下面是一個示例：

a = 10
if a > 0:
    print("a is positive")
else:
    print("a is not positive")

python 將 else if改成了elif 語句，用于添加多個條件分支。
條件表達(dá)式
python中的條件表達(dá)式類似于C語言中的三目操作符
例如，以下代碼用條件表達(dá)式來檢查變量x是否大于5，如果是，則將變量y的值設(shè)置為10，否則將其設(shè)置為0：

x = 7
y = 10 if x > 5 else 0
print(y)  # 輸出 10

在這個例子中，條件表達(dá)式的條件是“x > 5”，如果為True，則返回值為10（即“y = 10”），否則返回值為0（即“y = 0”）。但這種條件表達(dá)式只適用于較為簡單的分支情況，更復(fù)雜的條件邏輯，應(yīng)該使用 if 語句來代替。

4.2 循環(huán)

while循環(huán)基本與C是一樣的，一直循環(huán)某種結(jié)構(gòu)，直到滿足特定的條件為止。

while 條件:
    循環(huán)體

代碼示例

i = 0
while i < 5:
    print(i)
    i += 1

Python中的for-in循環(huán)用于迭代遍歷序列或集合中的每個元素。

for 變量名 in 序列:
    循環(huán)體語句

其中，變量名是循環(huán)變量，用于在循環(huán)中引用每個元素，序列可以是列表、元組、字符串、集合或字典等可迭代對象，循環(huán)體語句是需要重復(fù)執(zhí)行的語句塊
示例代碼：

names = ['Alice', 'Bob', 'Charlie', 'David']
for name in names:
    print(name)

# 輸出結(jié)果：
# Alice
# Bob
# Charlie
# David

在循環(huán)體中可以結(jié)合條件語句，實(shí)現(xiàn)更加靈活的控制流程。

4.3 pass語句

pass是一個空語句，它不執(zhí)行任何操作。但它可以被用作占位符，表示"在這里不做任何事情"，通?？梢詭椭覀兇罱ㄕZ法結(jié)構(gòu)，因?yàn)镻ython需要在代碼塊中有至少一個語句。例如，當(dāng)你想要先寫下一些代碼的框架但還沒有想好實(shí)現(xiàn)時，可以在代碼塊中使用pass語句占位。

def my_function():
    pass

在上面的代碼中，my_function 函數(shù)中沒有任何操作，但由于使用了 pass 語句，它仍然可以正確地定義。如果沒有 pass 語句，代碼將會報錯。

5.python基礎(chǔ)數(shù)據(jù)結(jié)構(gòu)

python的基礎(chǔ)數(shù)據(jù)結(jié)構(gòu)有字符串、元組、列表、字典、集合五種。

元組、字符串是不可變序列，自身不能進(jìn)行增刪查改等操作。
有序數(shù)列是有下標(biāo)的
1.下標(biāo)及索引規(guī)則
下標(biāo)可以從前開始，也可以從后開始
從前開始的規(guī)則是從0 開始，依次遞增1
從后開始的規(guī)則是從-1開始，依次遞減1

5.1列表——python中的數(shù)組

在Python中，與C語言中的數(shù)組相對應(yīng)的數(shù)據(jù)類型是列表（list）。列表可以用于存儲多個元素，并且可以動態(tài)地增加或減少元素的個數(shù)。和數(shù)組類似，列表的元素可以通過索引訪問，也可以使用循環(huán)遍歷所有元素。但是，相比于數(shù)組，在Python中使用列表更為方便和靈活。
列表的創(chuàng)建
用一對方括號[]來表示一個空列表，或者在方括號內(nèi)添加逗號分隔的值列表即可創(chuàng)建一個有元素的列表；還可以使用list()函數(shù)來創(chuàng)建一個列表：在list函數(shù)內(nèi)放置多個值，如果是字符串，會將中每個字符單獨(dú)作為元素。

5.1.1 列表的增刪查改

列表中查詢元素
在列表中查詢列表元素有兩種方法：第一種是列表名[索引]，下標(biāo)從0開始，第一個元素的索引為0，最后一個元素的索引為列表元素總數(shù) sz-1；還可以‘倒著’索引：最后一個元素的索引為 -1，第一個元素的索引為sz，當(dāng)然這兩種索引的下標(biāo)都是從小到大。
第二種是index(列表元素)，可用于查找列表中某個元素第一次出現(xiàn)的位置，其基本語法如下：

list.index(x[, start[, end]])

其中，x 是需要查找的元素；start 和 end 是可選參數(shù)，表示查找的起始位置和結(jié)束位置，如果省略則默認(rèn)查找整個列表。
如果該元素不存在于列表中，則會引發(fā)ValueError異常，可以使用try-except語句來避免程序崩潰。例如下面代碼：

my_list = [1, 2, 3, 4, 5]
try:
    index = my_list.index(6)
    print(index)
except ValueError:
    print("Element not found in list")

增加元素
可以使用append()方法將一個元素添加到列表的末尾。也可以使用extend()方法將另一個列表的元素添加到當(dāng)前列表的末尾，或者使用insert()方法將元素插入到指定的位置。

my_list = [1, 2, 3]
my_list.append(4)  #將一個元素添加到列表的末尾
print(my_list)  # [1, 2, 3, 4]
my_list = [1, 2, 3]
my_list.extend([4, 5])  #另一個列表的元素添加到當(dāng)前列表的末尾
print(my_list)  # [1, 2, 3, 4, 5]
my_list = [1, 2, 3]
my_list.insert(1, 4)   #將元素插入到指定的位置
print(my_list)  # [1, 4, 2, 3]

刪除元素
可以使用remove()方法刪除指定的元素，還可以使用pop函數(shù)刪除列表中指定位置的元素，或者使用del語句刪除指定位置上的元素。

my_list = [1, 2, 3]
my_list.remove(2) #刪除列表中的 2 元素
print(my_list)  # [1, 3]
my_list = [1, 2, 3]
my_list.pop(0) # 刪除并返回1
print(my_list) # 輸出[2,3] 
my_list = [1, 2, 3]
del my_list[1] #刪除索引1位置的元素
print(my_list)  # [1, 3] 

修改元素
可以直接通過下標(biāo)來修改指定位置上的元素。

my_list = [1, 2, 3]
my_list[1] = 4  #將索引1位置處的元素改為4
print(my_list)  # [1, 4, 3]

5.1.2 對列表進(jìn)行其他操作

創(chuàng)建列表的副本

列表的副本是創(chuàng)建了一個新的列表，它包含與原始列表相同的元素，但實(shí)際上是一個不同的對象。因此，對副本所做的更改不會影響原始列表。 創(chuàng)建副本有下面幾種方法

1.使用切片操作符[:]。例如，如果原列表是my_list，可以使用my_list[:]來創(chuàng)建一個副本，如下所示：

my_list = [1, 2, 3]
my_list_copy = my_list[:]

2.使用copy()方法。例如，如果原列表是my_list，可以使用my_list.copy()來創(chuàng)建一個副本，如下所示：

my_list = [1, 2, 3]
my_list_copy = my_list.copy()

3.使用list()函數(shù)。例如，如果原列表是my_list，可以使用list(my_list)來創(chuàng)建一個副本，如下所示：

my_list = [1, 2, 3]
my_list_copy = list(my_list)

對列表進(jìn)行排序
在C語言中，如果我們要對數(shù)組元素進(jìn)行排序，可能要使用冒泡排序、qsort排序等方法，而在python列表中，有專門的函數(shù)對列表進(jìn)行排序。
降序排列

my_list = [3,1,4,1,5,9,2,6,5,3,5]
my_list.sort(reverse=True)
print(my_list)

升序排列

my_list = [3,1,4,1,5,9,2,6,5,3,5]
my_list.sort()
print(my_list)

求某元素在列表中出現(xiàn)的次數(shù)
第一種方法是對列表進(jìn)行遍歷，設(shè)立一個計數(shù)器，當(dāng)出現(xiàn)某元素的時候，count就加1。

count = lst.count(x)
print(count)

也可以使用python的內(nèi)置函數(shù)count來統(tǒng)計

count = lst.count(x)
print(count)

5.2 字典——python中的結(jié)構(gòu)體

Python字典是一種無序的集合數(shù)據(jù)類型，它由一系列鍵值對組成，每個鍵值對之間用逗號分隔。字典中的鍵必須是唯一的，而值可以是任何類型的數(shù)據(jù)。字典是Python語言中常用的一種數(shù)據(jù)結(jié)構(gòu)，可以直接使用，不需要定義或聲明，并且它提供了靈活的數(shù)據(jù)組織和訪問方式：直接通過鍵就可以訪問鍵對應(yīng)的值。
字典的創(chuàng)建方式：
1、使用花括號{}，用冒號分割鍵值： dict1 = {'key1': 'value1', 'key2': 'value2', ...}，key與value是一一對應(yīng)的。
2、使用內(nèi)置函數(shù)dict()函數(shù)創(chuàng)建：dict2 = dict(key1='value1', key2='value2', ...)
3、使用dict.fromkeys()方法創(chuàng)建，鍵可以輸入多種，而值只能是一種：dict3 =dict.fromkeys(['key1', 'key2', ...]，100)
4、創(chuàng)建空字典：直接使用花括號{}，里面不放值；使用dict()函數(shù)里面不放值。
字典定義示例：

person = {
    "name": "John",
    "age": 30,
    "city": "New York"
}

其中，鍵分別是"name"、“age"和"city”，對應(yīng)的值分別是"John"、30和"New York"?？梢酝ㄟ^鍵來訪問對應(yīng)的值。例如：

print(person["name"])  # 輸出：John
print(person["age"])   # 輸出：30

字典的內(nèi)存是由python解釋器自動管理內(nèi)存的，在使用過程中不需要考慮內(nèi)存分配和釋放的問題。

5.2.1 字典常用的操作

• 獲取字典中的值：通過鍵來獲取字典中的值，例如 dict[key]。

• 添加新鍵值對：使用 dict[key] = value，可以向字典中添加新的鍵值對。

• 修改鍵值對：通過鍵來修改字典中的值，例如 dict[key] = new_value。

• 刪除鍵值對：使用 del dict[key] 可以刪除字典中的鍵值對。

• 獲取字典的長度：使用 len(dict) 可以獲取字典中鍵值對的數(shù)量。

• 判斷鍵是否存在：可以使用 in 關(guān)鍵字判斷一個鍵是否存在于字典中，例如 key in dict。

• 獲取所有鍵或所有值：使用 dict.keys() 可以獲取字典中所有的鍵，使用 dict.values() 可以獲取字典中所有的值。

• 獲取所有鍵值對：使用 dict.items() 可以獲取字典中所有的鍵值對。

• 清空字典：使用 dict.clear() 可以清空整個字典。

• 復(fù)制字典：使用 dict.copy() 可以復(fù)制一個字典。

5.2.2 字典的特點(diǎn)

字典是無序的：字典中的條目沒有固定的順序，存儲的順序與定義時候的順序無關(guān)。
字典是可變的：可以添加、刪除或修改字典中的鍵值對。
字典中的鍵必須是不可變的類型，例如整數(shù)、浮點(diǎn)數(shù)、字符串或元組，而值可以是任何類型。
每個鍵只能在字典中出現(xiàn)一次，如果同一個鍵被多次賦值，則只有最后一個值被保留。
字典通常用于快速查找和檢索，可以根據(jù)鍵快速訪問值，時間復(fù)雜度為O(1)。
字典的存儲是’隨機(jī)的’，依靠鍵來找值，因此浪費(fèi)了大量的內(nèi)存，是一種以空間換時間的數(shù)據(jù)結(jié)構(gòu)。

5.3 元組

元組是python內(nèi)置的數(shù)據(jù)結(jié)構(gòu)之一，是一個不可變序列，可以包含任意類型的數(shù)據(jù)，如數(shù)字、字符串、列表、字典、元組等。
元組的創(chuàng)建
1、使用小括號()將元素括起來，用逗號分隔，例如：

(1,"hello",[3,4],5.6,{"紀(jì)寧":"赤明九天圖"})

2、使用內(nèi)置函數(shù) tuple()，將列表或者其他迭代對象轉(zhuǎn)化為元組，如 t=tuple([1,2,3])
3、可以省略小括號，逗號分隔的情況下直接創(chuàng)建元組，例如：t=1,“hello”,[3,4],5.6
4、只有一個元素是，加逗號以區(qū)分元組和表達(dá)式，例如：t=(1,)
5、空元組：()或者 t = tuple()

為什么要將元組設(shè)置為不可變序列？
元組被設(shè)計為不可變序列，因?yàn)樗鼈兛梢杂脕肀硎疽唤M不可變的數(shù)據(jù)，例如日期、時間、坐標(biāo)等。一旦元組被創(chuàng)建，它們的值就不能被修改，這使得它們比可變序列更安全，因?yàn)樗鼈儾荒鼙灰馔庑薷摹４送?，元組也比列表更加高效，因?yàn)樗鼈兊牟豢勺冃允沟迷谔幚泶罅繑?shù)據(jù)時，它們能夠更快速地被創(chuàng)建、操作和釋放。

5.4 集合

集合是一種python內(nèi)置的數(shù)據(jù)結(jié)構(gòu)，與列表、字典一樣都屬于可變類型的序列，并且集合里的元素是無序不重復(fù)的，所以集合相當(dāng)于沒有value的字典。
字典的創(chuàng)建

• 直接{}，例如s = {‘python’, ‘hello’ , 90}
• 使用內(nèi)置函數(shù)set()，括號里面可以包含多種數(shù)據(jù)類型的元素

創(chuàng)建空集合也需要使用set()函數(shù)，如果直接用大括號初始化空集合會被解釋器認(rèn)為是空字典。

5.4.1集合常用的操作

集合元素的新增

• add()：添加單個元素到集合中
• update()：添加多個元素到集合中

add()方法示例

# 定義一個空集合
my_set = set()
# 添加元素
my_set.add(1)
my_set.add(2)
my_set.add(3)
print(my_set)  # 輸出：{1, 2, 3}

update()方法示例

# 定義一個空集合
my_set = set()
# 添加元素
my_set.update([1, 2, 3])
my_set.update([4, 5, 6])
print(my_set)  # 輸出：{1, 2, 3, 4, 5, 6}

集合元素的刪除

• remove()：按照元素值刪除一個元素，如果元素不存在，就觸發(fā)KeyError
• discard()：按照元素值刪除一個元素，如果元素不存在，不報錯
• pop()：隨機(jī)刪除集合中一個元素，并返回該元素，集合為空則觸發(fā)KeyError
• clear()：刪除集合中所有元素

s=set(range(1,6))
print(s) #{1,2,3,4,5}
s.pop()  #隨機(jī)刪除一個
print(s) # {2,3,4,5}   
s.discard(3) #刪除集合元素 3
print(s)  #{2, 4, 5}
s.clear() #清空
print(s) #輸出空集合

判斷兩個集合的關(guān)系

• issubset()——s2.issubset(s1)，判斷s2是否是s1的子集
• issuperset()——s1.issuperset(s2)，判斷s1是否是s2的超集
• isdisjoint()——s1.isdisjoint(s2)，判斷s1和s2是否沒交集

求兩個集合交并集的方法

• intersection——s1.intersection(s2)，等價于 s1&s2，求s1與s2的交集
• union——s1.union(s2)，等價于 s1| s2，求s1與s2的并集
• difference——s1.difference(s2)，等價于s1-s2，求s1與s2的差集
• symmetric_difference——s1.symmetric_difference(s2)，等價于 s1^s2，求s1與s2的對稱差集（并集 - 交集）

5.5 字符串

5.51 字符串常用操作

字符串查詢

• index()，在字符串中查找指定字符串，返回首次出現(xiàn)時候的索引，找不到就報錯。
• find()，在字符串中查找指定字符串，返回首次出現(xiàn)時候的索引，找不到則返回-1
• rindex()，在字符串中查找指定字符串，返回最后一次出現(xiàn)時候的索引，找不到就報錯
• rfind()，在字符串中查找指定字符串，返回最后一次出現(xiàn)時候的索引，找不到就返回-1

字符串大小寫轉(zhuǎn)化

• upper()——將字符串中所有字符都轉(zhuǎn)化為大寫字母
• lower()——將字符串中所有字符都轉(zhuǎn)化為小寫字母
• swapcase()——把字符串所有的大寫轉(zhuǎn)化為小寫，小寫轉(zhuǎn)化為大寫
• capitalize()——把第一個字母轉(zhuǎn)化為大寫，其余字母轉(zhuǎn)為小寫
• title()——把每個單詞的第一個字母轉(zhuǎn)化為大寫，把每個單詞的剩余字符轉(zhuǎn)化為小寫。

字符串對齊
字符串內(nèi)容對齊是指將字符串中的內(nèi)容按照一定的方式對齊，使其更加美觀，易于閱讀，并且符合視覺習(xí)慣。常見的字符串內(nèi)容對齊操作包括左對齊、右對齊、居中對齊等。
若傳遞的字符串寬度 width 小于字符串長度，則返回字符串包本身

• ljust()——左對齊

txt = txt.ljust(width,fillchar)

其中，width表示字符串的總寬度；fillchar表示要填充的字符，默認(rèn)為空格。如果字符串長度小于width，則用fillchar在右側(cè)填充，直到達(dá)到width長度。

• rjust——右對齊

string.rjust(width, fillchar)

其中，width表示字符串的總寬度；fillchar表示要填充的字符，默認(rèn)為空格。如果字符串長度小于width，則用fillchar在左側(cè)填充，直到達(dá)到width長度

• zfill——右對齊（用0填充）

string.zfill(width)

右對齊，只接收一個參數(shù)，用于指定字符串對齊的寬度

• center——居中對齊

string.center(width,fillchar)

其中，width表示字符串的總寬度；fillchar表示要填充的字符，默認(rèn)為空格。如果字符串長度小于width，則用fillchar在左右兩側(cè)均勻填充，直到達(dá)到width長度
字符串劈分
字符串劈分操作是指根據(jù)指定的分隔符將一個字符串拆分成多個子字符串。

• splist(sep=,maxsplit)，從字符串左邊開始劈分，sep 是劈分字符，maxsplit 是劈分的最大次數(shù)
• rsplit(sep=,maxsplit)，從字符串右邊開始劈分，sep 是劈分字符，maxsplit 是劈分的最大次數(shù)

在經(jīng)過最大劈分次數(shù)后，剩余的子串將會單獨(dú)作為一部分。
判斷字符串的方法

• isidentifier()，判斷字符串是不是合法的標(biāo)識符
• isspace()，判斷字符串是否全部由空白字符組成（回車、換行、水平制表符等）
• isalpha()，判斷指定的字符串是否全部由字母組成（漢字也算字母）
• isdecimal()，判斷字符串是否全部由十進(jìn)制數(shù)字組成
• isnumeric()，判斷指定的字符串是否全部由數(shù)字組成（Unicode編碼中的數(shù)字字符）
• isalnum()，判斷指定字符串是否全部由字母和數(shù)字組成

isnumeric函數(shù)可以判斷Unicode編碼中的數(shù)字字符是否是數(shù)字，包括阿拉伯?dāng)?shù)字0-9、羅馬數(shù)字、中文數(shù)字、泰語數(shù)字、藏文數(shù)字等，但 isnumeric函數(shù) 不能判斷小數(shù)、負(fù)數(shù)、科學(xué)計數(shù)法等特殊的數(shù)字形式。
字符串替換

• replace()，第一個參數(shù)是被替換的字符串的子串，第二個參數(shù)是替換的字符串，第三個參數(shù)是最大替換次數(shù)，函數(shù)返回替換后的字符串，原字符串不變，如果未找到子串，則不進(jìn)行替換。
• join()，用于將一個可迭代對象（如list、tuple等）中的元素用某字符連接成一個字符串。

separator = ' '  # 連接符（可以為任意字符）
seq = ['apple', 'banana', 'cherry']   # 可迭代對象，如果只有一個字符串，就默認(rèn)字符串本身為可迭代對象
result = separator.join(seq)   # 將seq中每個元素用separator連接起來
print(result)  # 輸出 'apple banana cherry'

5.52 字符串的比較及字符的Unicode編碼

字符的Unicode編碼
每個字符都有對應(yīng)的Unicode編碼，類似于C語言中的ASCII碼，但更全面。Unicode編碼的前128個就是ASCII，并且Unicode編碼為所有字符都設(shè)立的編碼，更全面。

• ord()，ord函數(shù)可以將一個字符轉(zhuǎn)化為其對應(yīng)的 Unicode編碼。
• chr()，chr函數(shù)可以將Unicode編碼轉(zhuǎn)化為對應(yīng)的字符。

字符串的比較
先比較兩個字符串中的第一個字符的Unicode編碼，如果相等，則繼續(xù)比較下一個字符，依次比較下去，直到兩個字符不相等，其比較結(jié)果就是兩個字符串的比較結(jié)果，后續(xù)字符串中的字符將不再被比較。
字符串相等 is ，比較的是兩個字符串的地址（id）是否相等；而字符串相等 ==，比較的是兩個字符串的值（value）是否相等。

5.53 格式化字符串

為什么要格式化字符串？

如圖，這就是一種‘格式化’，需要改的地方只有 xxx 的部分，極大提高了工作效率。
格式化字符串的方式

例如：

5.54 字符串的編碼轉(zhuǎn)化

為什么要進(jìn)行字符串的編碼轉(zhuǎn)化

1. 傳輸數(shù)據(jù)：在網(wǎng)絡(luò)傳輸和存儲中，需要將字符串編碼轉(zhuǎn)換為字節(jié)流的形式。例如，使用 HTTP 請求和響應(yīng)傳輸數(shù)據(jù)時，需要將數(shù)據(jù)轉(zhuǎn)換為 UTF-8 或其他編碼格式的字節(jié)流。

2. 多語言支持：不同語言使用不同的編碼方式，進(jìn)行編碼轉(zhuǎn)換可以確保在不同語言之間傳輸數(shù)據(jù)時不會出現(xiàn)亂碼。

3. 安全性：某些字符可能被用于編寫惡意代碼或注入攻擊，進(jìn)行編碼轉(zhuǎn)換可以保障系統(tǒng)的安全性。

4. 數(shù)據(jù)庫操作：在將數(shù)據(jù)存儲到數(shù)據(jù)庫中時，可能需要將字符串進(jìn)行編碼轉(zhuǎn)換，以確保數(shù)據(jù)庫支持該編碼格式并且能正確存儲和檢索數(shù)據(jù)。

5. 業(yè)務(wù)需求：有時候，業(yè)務(wù)需求需要將字符串轉(zhuǎn)換為指定的編碼格式，以滿足特定場景的要求。例如在一些人工智能領(lǐng)域中，需要將文本進(jìn)行編碼轉(zhuǎn)換以方便進(jìn)行文本分析和處理。

• 編碼：s.encode(ending=‘GBK’) 或者 s.encode(ending=‘UFT-8’)，將字符串s轉(zhuǎn)化為二進(jìn)制數(shù)據(jù)
• 解碼：s.decode(ending=‘GBK’) 或者 s.decode(ending=‘UFT-8’)，將二進(jìn)制數(shù)據(jù)轉(zhuǎn)化為字符

編和解的字節(jié)流必須統(tǒng)一，如用’GBK’編碼，就必須使用’GBK’解碼，使用’UFT-8’編碼就必須使用’UFT-8’解碼。

5.6 生成式合集

5.6.1 字典生成式

內(nèi)置函數(shù)zip():用于將迭代對象作為參數(shù)，將對象中對應(yīng)的元素打包成一個元組，然后返回由這些元組組成的列表。
字典生成式語法格式：

{key: value for key, value in iterable}

其中，key表示字典的鍵，value表示字典的值，iterable表示可迭代對象，例如列表、元組、字典等。生成式會遍歷iterable中的每個元素，根據(jù)指定的規(guī)則創(chuàng)建一個新的字典。
假設(shè)我們有兩個列表，先使用 zip 函數(shù)將對應(yīng)元素打包為元組再返回

items=['Fruits','Book','Others']
prices=[96,78,85]
lst=zip(items,prices)

再使用字典生成式生成一個鍵值對應(yīng)的字典

d = {items:prices for items,prices in lst}

5.6.2 列表生成式

內(nèi)置函數(shù)range():range函數(shù)是一個內(nèi)置函數(shù)，用于生成一個整數(shù)序列。range函數(shù)有三種形式：

• range(stop) 生成一個從0開始到stop-1的整數(shù)序列，默認(rèn)步長為1。

• range(start, stop) 生成一個從start開始到stop-1的整數(shù)序列，默認(rèn)步長為1。

• range(start, stop, step) 生成一個從start開始到stop-1的整數(shù)序列，步長為step。

例如，range(5)將生成序列(0, 1, 2, 3, 4)，range(2, 7)將生成序列(2, 3, 4, 5, 6)，range(1, 10, 2)將生成序列(1, 3, 5, 7, 9)。

range函數(shù)一般被用在循環(huán)語句中，如for循環(huán)，來遍歷一個序列或執(zhí)行指定次數(shù)的循環(huán)。

5.6.3 集合生成式

集合生成式的基本語法為：

{expression for item in iterable}

expression通常是某個變量或表達(dá)式，item是可迭代對象中的元素，iterable是可迭代對象，例如列表、元組、字典等。
例如：

nums = [1, 2, 3, 4, 5]
squares = {x*x for x in nums}
print(squares)

集合表達(dá)式也支持添加條件表達(dá)式，例如：

nums = [1, 2, 3, 4, 5]
squares = {x*x for x in nums if x > 2}
print(squares)

添加條件 x>2 后，只有當(dāng)x.2時，才進(jìn)行迭代生成集合表達(dá)式。

5.7 切片

字符串、列表、元組等有序數(shù)據(jù)結(jié)構(gòu)中支持切片操作，切片可以獲取這些有序數(shù)據(jù)結(jié)構(gòu)的子序列。切片操作不會改變原序列，它會返回一個新序列，包含指定范圍的元素。
切片語法：

string=str[start:stop:step]

start為切片的起始位置，stop為切片的結(jié)束位置（不包括該位置對應(yīng)的元素），step為切片的步長。如果省略start，則默認(rèn)為0；如果省略stop，則默認(rèn)為序列的長度；如果省略step，則默認(rèn)為1。

6.函數(shù)——新瓶裝舊酒

同C語言一樣，在 Python 中，函數(shù)是一種可重用的代碼塊，用于執(zhí)行某些特定的任務(wù)。函數(shù)可以帶有參數(shù)或不帶參數(shù)，也可以返回值或不返回值。C語言函數(shù)詳解
函數(shù)定義的一般語法：

def add_numbers(num1, num2):
    """This function adds two numbers."""
    result = num1 + num2
    return result

• def：定義函數(shù)的關(guān)鍵字；
• function_name：函數(shù)名稱，應(yīng)以字母或下劃線開頭；
• parameters：函數(shù)參數(shù)，可以是一個或多個，也可以為空；
• docstring：函數(shù)文檔字符串，對函數(shù)的功能進(jìn)行描述，可選；
• statements：函數(shù)體，函數(shù)需要執(zhí)行的代碼語句。

下面用python實(shí)現(xiàn)一個簡易的計算器，幫助大家更好的理解函數(shù)

    # 加法
    def add(self, x, y):
        return x + y
    # 減法
    def subtract(self, x, y):
        return x - y
    # 乘法
    def multiply(self, x, y):
        return x * y
    # 除法
    def divide(self, x, y):
        if y == 0:
            return "除數(shù)不能為0"
        return x / y
# 獲取用戶輸入
print("請選擇運(yùn)算：")
print("1、加法")
print("2、減法")
print("3、乘法")
print("4、除法")
choice = input("請輸入需要進(jìn)行的運(yùn)算符號(1/2/3/4): ")
num1 = int(input("請輸入第一個數(shù)字: "))
num2 = int(input("請輸入第二個數(shù)字: "))
# 執(zhí)行計算，傳遞兩個參數(shù) num1和num2
if choice == '1':
    print(num1,"+",num2,"=", add(num1,num2))
elif choice == '2':
    print(num1,"-",num2,"=",subtract(num1,num2))
elif choice == '3':
    print(num1,"*",num2,"=", multiply(num1,num2))
elif choice == '4':
    print(num1,"/",num2,"=",divide(num1,num2))
else:
    print("請輸入正確的選項(xiàng)")

Python函數(shù)傳參的特點(diǎn)如下：

1. 位置參數(shù)：按照形參定義位置傳遞的參數(shù)；
2. 關(guān)鍵字參數(shù)：按照形參名稱傳遞的參數(shù)；
3. 默認(rèn)參數(shù)：在函數(shù)定義時給形參指定默認(rèn)值，如果沒有傳入對應(yīng)的實(shí)參，則使用默認(rèn)值；
4. 可變參數(shù)：*args，用來傳遞任意個參數(shù)，以元組的形式傳遞；
5. 關(guān)鍵字可變參數(shù)：**kwargs，用來傳遞任意個關(guān)鍵字參數(shù)，以字典的形式傳遞。

位置實(shí)參：和C語言函數(shù)傳參的規(guī)則相同，實(shí)參和形參一一對應(yīng)
將10傳給形參a，20傳給形參b
關(guān)鍵字實(shí)參
根據(jù)形參名進(jìn)行實(shí)參傳
關(guān)鍵字實(shí)參的傳參規(guī)則是，先在形參里找實(shí)參關(guān)鍵字，將找到的實(shí)參傳遞給對應(yīng)形參，剩余的則進(jìn)行依次傳參。
可變參數(shù)
將形參定義為 *args，可接受任意個實(shí)參傳遞，結(jié)果為一個元組。

關(guān)鍵字可變實(shí)參
將形參定義為**args，可接受任意個關(guān)鍵字實(shí)參，結(jié)果為一個字典。

函數(shù)傳參的內(nèi)存圖
例如下面的代碼

def fun(arg1,arg2):
    print("agr1=",arg1,"agr2=",arg2)
    arg1=100
    arg2.append(10)
    print("agr1=",arg1,"agr2=",arg2)
n1=10
n2=[22,33,44]
print("n1=",n1,"n2=",n2)
fun(n1,n2)
print("n1=",n1,"n2=",n2)

運(yùn)行結(jié)果：

說明同C語言一樣，C中形參是實(shí)參的一份臨時拷貝，對實(shí)參的改變不影響實(shí)參。在python程序中，實(shí)參是臨時定義的一個與實(shí)參指向相同的變量，改變形參的指向不能改變實(shí)參的指向，但在形參指向的首地址后面添加或刪除數(shù)據(jù)是可以的起到改變實(shí)參值的作用的，因?yàn)閷?shí)參也是指向這塊內(nèi)存的首地址，但絕對改變不了實(shí)參的指向。文章來源地址http://www.zghlxwxcb.cn/news/detail-654897.html

到了這里，關(guān)于沒學(xué)C++，如何從C語言絲滑過度到python【python基礎(chǔ)萬字詳解】的文章就介紹完了。如果您還想了解更多內(nèi)容，請在右上角搜索TOY模板網(wǎng)以前的文章或繼續(xù)瀏覽下面的相關(guān)文章，希望大家以后多多支持TOY模板網(wǎng)！