python剛剛?cè)腴T，總結(jié)一下上網(wǎng)課 (小甲魚) 時(shí)學(xué)到的python基本語(yǔ)法。
有一點(diǎn)c的基礎(chǔ)，主要總結(jié)和c不太一樣的地方。

+++++++++++++++++
聲明📢 ：
文章是我個(gè)人的筆記，寫在這里和大家分享。里面的內(nèi)容都是看小甲魚python網(wǎng)課時(shí)自己總結(jié)的一些知識(shí)點(diǎn)。
有些內(nèi)容，可能是我自己百度了之后，看了別人的文章之后的筆記。具體的網(wǎng)址都在文章中標(biāo)記出來(lái)了。

++++++++++++++++
感謝支持。如果有什么建議，或者是文章內(nèi)容有什么錯(cuò)誤/問題，麻煩指出來(lái)，會(huì)及時(shí)改進(jìn)的

+++++++++++++++++
語(yǔ)法入門結(jié)束之后，開始刷面試題了。如果大佬們有什么，關(guān)于語(yǔ)法入門之后怎么練習(xí)的建議，麻煩評(píng)論區(qū)指點(diǎn)一下。謝謝！

文章里面可能有很多英文，主要是因?yàn)橐婚L(zhǎng)串中/英文讀起來(lái)容易找不到重點(diǎn)，將關(guān)鍵字用英語(yǔ)標(biāo)出來(lái), 對(duì)我個(gè)人讀起來(lái)有些幫助文章有些地方，不是順序來(lái)寫的。如果見到一些不認(rèn)識(shí)的函數(shù)或者用法，可以檢索一下文章，找到他們的定義

目錄

• 注意項(xiàng)
• print
• if else
• • else其他用法
• while
• for
• 運(yùn)算符
• 類Class
• 一切皆對(duì)象
• 數(shù)據(jù)類型
• • 序列sequence
  • • 列表list
    • range
    • 元組tuple
    • 字符串
    • • 字符串操作
  • 映射：字典dict
  • • 字典操作
  • 集合set
  • 不可變集合frozenset
• BIF/類
• • 類相關(guān)
• 魔法方法
• • 迭代
  • • 可迭代的對(duì)象 iterable
    • 迭代器 iterator
• 函數(shù)
• • 生成器 Generator
• 文件
• 模塊
• • 包package
• 異常exception

注意項(xiàng)

• 不需要semicolon ;
• indentation縮進(jìn) 代替{ }
• 變量不需要declare type，可以直接賦值。

print

• 不需要格式符號(hào)%d，%lf
• “” 或者’ '都可以用來(lái)標(biāo)注字符串
• 每次print執(zhí)行完了之后，都會(huì)默認(rèn)換行?？梢愿倪@一設(shè)定👇：

print("hello world", end='') print('hola') #end=規(guī)定每次打印結(jié)束以什么來(lái)結(jié)尾

• 一個(gè)print函數(shù)打印多個(gè)字符串

print(a, b, c) #默認(rèn)字符串用空格隔開 print("hello" * 3) #打印“”里面的內(nèi)容3次 結(jié)果：hellohellohello print("hello" + "world") 結(jié)果：helloworld

打印特殊符號(hào)

轉(zhuǎn)義符號(hào)

當(dāng)要打印字符串里面的 ', " ，\n, \t, 或者位于句末的\時(shí)

print("lower\\") 結(jié)果：lower\

加上r
這個(gè)語(yǔ)句會(huì)自動(dòng)給字符串中所有的 \ (不包括句末的\) 轉(zhuǎn)義

string = r'\n\t' print(string) \n\t

打印多行的字符串

使用三個(gè)“ 或者 ‘

print('''hello world''') #打印結(jié)果會(huì)自動(dòng)換行 hello world

if else

不要忘記冒號(hào)和indentation

if a == 1:print(' a == 1') elif a == 2:print(' a == 2') else:pass #什么都不寫的時(shí)候用

三元操作

string = a if a < b else b

或者

if a < b:string = a else:string = b

else其他用法

和while, for一起用

寫在else里面的code，只在循環(huán)全部結(jié)束之后才會(huì)執(zhí)行。也就是，如果中間break, 則不執(zhí)行。

for i in list1:if i == 6:breakprint(i) else:print('There is no 6 in the list')

如果 list1 = range(0, 10, 4)

0 4 8 There is no 6 in the list

如果list1 = range(0, 10, 3)

0 3

同理，else可以和try語(yǔ)句一起用。如果try語(yǔ)句中沒有出現(xiàn)exception，則執(zhí)行else里面的內(nèi)容

try:raise OSError except OSError:print('error') else:print('success')

while

不支持do while

a = 1 while a < 2:print(a)a += 1#??python不支持++,-- 1

for

主要適用于list或者tuple
??這里的i和j不是一個(gè)counter，而是這個(gè)list里面的一個(gè)元素element

for i in list1:for j in i:print(j)

運(yùn)算符

邏輯運(yùn)算符

&& and
|| or
! not

算數(shù)運(yùn)算符

/ 為數(shù)學(xué)意義上的除法，整數(shù)之間相除可以得到小數(shù)
// 為floor除法，即使operands是小數(shù)，結(jié)果依然為整數(shù)
** 冪

• 比左側(cè)的單目運(yùn)算符高，比右側(cè)的低

-3 ** 2 == -9 3 ** -2 == 0.11111

比較符

支持 3<4<5，相當(dāng)于 3<4 and 4<5

類Class

命名規(guī)則：ClassName

類包含一系列的變量（屬性attribute）和函數(shù)（方法）
避免變量與函數(shù)重名，否則變量會(huì)覆蓋函數(shù)。

class Car():#如果在定義的時(shí)候，把其他的類當(dāng)作參數(shù)放進(jìn)來(lái)，那么可以繼承這個(gè)類的所有變量或者函數(shù)#變量name = 'carro'color = 'red'#函數(shù)def calculate_speed(self, distance, time):speed = distance / timeprint('%s is travelling at %f m/s' % (self.name, speed))#?? 除了在定義變量的部分，使用變量的話，都需要明確是哪一個(gè)對(duì)象(e.g. self.name而不是name)

類理解為一個(gè)模版，對(duì)象object（或者實(shí)例）則是這個(gè)模版刻出來(lái)的一個(gè)物品。類在定義的時(shí)候，是類。定義結(jié)束，是類對(duì)象。

我們可以創(chuàng)建一個(gè)對(duì)象：

car1 = Car() print(car1.name) print(car1.calculate_speed(30, 10)) carro 3.0

解釋一下self：
當(dāng)通過(guò)實(shí)例對(duì)象調(diào)用函數(shù)的時(shí)候，會(huì)把實(shí)例當(dāng)作參數(shù)傳入到函數(shù)里面。這是python 的綁定機(jī)制，self就是用來(lái)接收這個(gè)對(duì)象的 （個(gè)人理解，如果有錯(cuò)誤，麻煩指出來(lái)，謝謝！ ）

繼承
使用繼承的方法，在前面有寫過(guò)。

如果子類在定義的過(guò)程中，定義了和父類同名的變量/函數(shù)，會(huì)覆蓋父類，但是并不會(huì)影響父類。
如果，想要保留父類同名的變量/函數(shù)，可以使用super

super(). 函數(shù)名()

init的定義，見魔法方法

class Parent:def __init__(self):print("I'm the parent") class Child(Parent):def __init__(self):super().__init__() #在重新定義的時(shí)候，保留一下父類的內(nèi)容print("I'm the child") parent = Parent()print('----分界線----') child = Child() I'm the parent ----分界線---- I'm the parent I'm the child

組合
在定義一個(gè)類的時(shí)候，創(chuàng)建另外一個(gè)類的object

class Female:def __init__(self, input):self.number = input class Male(Female):passclass Class:def __init__(self, inputF, inputM):self.female = Female(inputF)self.male = Male(inputM)def statement(self):print("We have %d female students & %d male students" % (self.female.number, self.male.number))class1 = Class(25, 24) class1.statement() We have 25 female students & 24 male students

類vs類對(duì)象vs實(shí)例對(duì)象
對(duì)類對(duì)象進(jìn)行操作，會(huì)對(duì)這個(gè)類的所有objects作出操作。如果，對(duì)類的一個(gè)object進(jìn)行操作，則只對(duì)這個(gè)object生效。

（原理是，這個(gè)object自己生成了一個(gè)變量，覆蓋了類里面定義的那個(gè)變量。從此之后，再更改類對(duì)象也不會(huì)影響這個(gè)object，因?yàn)橐呀?jīng)被覆蓋了）

一切皆對(duì)象

一開始看網(wǎng)課不是很明白，搜到了一個(gè)其他樓主的文章明白了一點(diǎn)。

下面總結(jié)一下我個(gè)人讀完這個(gè)文章之后的理解。原文：（鏈接：https://blog.csdn.net/hpu120623/article/details/90745739）?? 文章里面有具體的例子和流程圖，推薦讀！

所有所謂的數(shù)據(jù)類型（序列，字典，int，str）這些都是type這個(gè)類的對(duì)象。
那么具體的變量 (e.g. list1, dict1, 3, ‘hello’) 是相對(duì)應(yīng)的數(shù)據(jù)類型的對(duì)象。
最后，type本身就是type這個(gè)類的對(duì)象。

所以，都是對(duì)象。。。

如果想要有更深刻的理解，建議可以自己平時(shí)多試試打印某個(gè)東西的type是什么。極大的可能性返回的都是<class ‘something’>.

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

區(qū)分int & float

有無(wú)小數(shù)點(diǎn)

科學(xué)記數(shù)法

默認(rèn)為float

a = 1e-12

序列sequence

序列包括了list, tuple, 等等。這些類都具有一個(gè)特點(diǎn)就是有序。所以被統(tǒng)稱為序列。序列本身并不是一個(gè)類，只是一個(gè)名詞。

支持的操作：

• slice
• 重復(fù)操作（*），拼接（+），關(guān)系（in， not in）

其他操作：簡(jiǎn)述可能的操作，具體的函數(shù)不介紹

判斷序列里，是否含有另外一個(gè)序列

查找某一個(gè)element或者sequence，返回其index

查找index中存儲(chǔ)的element

查找最大/小值 （前提：所有elements為同一個(gè)類型）

查找某個(gè)element出現(xiàn)的次數(shù)

index支持負(fù)數(shù)，意為倒數(shù) (e.g. -1意思是倒數(shù)第一)

列表list

• 空列表：[]
• 可以更改，添加，刪除element

創(chuàng)建一個(gè)列表：

list1 = [1, 'hello', 2.0] #可以存放不同類型的元素

或者：

list1 = list([1, 'hello', 2.0]) #注意list()里面可傳入任何iterrable (e.g. tuple，set)

添加element

append(element)

list1.append(3) #追加一個(gè)element，一次只能添加一個(gè)

extend(list)

list1.extend([0, 2.4]) #輸入的list會(huì)與當(dāng)前的list合成一個(gè)list#或者 list2 = list1 + list2

insert(index, element)

list1.insert(0, 'hello') #將一個(gè)element放到指定的index

刪除element
remove(element)

list1.remove(0) #刪除輸入的element del list1[2] del list1 #刪除某一個(gè)element或者整個(gè)list

pop (index)

list1.pop(3) #刪除在這個(gè)index的element，并返回這個(gè)element #默認(rèn)為最后一個(gè)element

切片slice
[start : stop : step]
??不包括stop。[start, stop)

list1[1:3] #截取從index1到3（不包含3）的elements #第一個(gè)參數(shù)默認(rèn)為0，第二個(gè)為最后的index, 第三個(gè)為1list2 = list1[:] #copy整個(gè)list, 更改list1并不會(huì)影響list2, vice versalist2 = list1[1:9:2] #step為2

比較大小

list1 == list2 #只有當(dāng)所有element相同時(shí)為true list1 < list2 #比較第一個(gè)不相同的element

檢查是否存有一個(gè)element

if 'hello' in list2:print('yes') if 'hello' not in lsit2:print('no')

某個(gè)element出現(xiàn)次數(shù)
count ( element )

list2.count('hello')

某個(gè)element第一次出現(xiàn)index
index ( element, start index, stop index )

list2.index('hello', 3, 7) #返回這個(gè)element在[3, 7)內(nèi)第一次出現(xiàn)的index #如果沒有出現(xiàn)，會(huì)出現(xiàn)valueError

倒序

list1.reverse()

排序

list1.sort() #默認(rèn)從小到大排序，不同參數(shù)排序不同

推導(dǎo)式
[element + 表達(dá)式]

list1 = [i for i in range(0, 10) if i%2 == 0] [0, 2, 4, 6, 8]

生成器對(duì)象可以直接做某些函數(shù)的參數(shù)。

range

range (start, stop, step)
??不包括stop

默認(rèn)第一個(gè)參數(shù)為0，第三個(gè)為1

x = range(0, 10, 3) print(x) print(type(x)) range(0, 10, 3) <class 'range'>

可以理解為一個(gè)整數(shù)list。可以將它轉(zhuǎn)換成list，也可以直接在for循環(huán)中用

list1 = list(range(0, 10, 3)) print(type(list1)) print(list1) <class 'list'> [0, 3, 6, 9]

元組tuple

和list相似，但是不能改變

• 空元組 ()
• ??創(chuàng)建元組的標(biāo)志為逗號(hào)，而不是（）

tuple1 = (2, 3, 4) tuple2 = (2,) #必須要加逗號(hào)，否則tuple2會(huì)被認(rèn)為是整數(shù) tuple3 = tuple1 * 3 tuple4 = tuple1[:2] + ('hello',) + tuple3[:] tuple5 = tuple([1, 2, 3]) #可以傳入任何iterrabLe

字符串

• python沒有字符，只有字符串
• 不可以通過(guò)index直接修改element （類似元組，是不可以改變的），可以使用slice修改

str1 = 'hello!world' #或者 str1 = str('hello!world')str1 = str1[:5] + ' ' + str1[6:] print(str1) hello world

字符串操作

下面主要總結(jié)可以做什么，不介紹函數(shù)
??涉及查找的函數(shù)，支持從左或從右查找

• 改變大小寫
• 居中，左對(duì)齊，右對(duì)齊 字符串
• 判斷字符串是否以sub string結(jié)束/開始
• 判斷字符串里有無(wú)數(shù)字，字母，大小寫，title（首字母大寫）
• 用指定的字符串，分隔當(dāng)前字符串
• 去掉/替換 字符串中指定的sub string

格式化字符串：按照規(guī)定的格式輸出字符串

format
用{}來(lái)表示需要replacement的地方

未知參數(shù) non-keyword

statement = "{0} has {1} files" statement = statement.format("John", 10) #??format只是返回一個(gè)更新之后的字符串，并不是徹底更改statement John has 10 files

關(guān)鍵字參數(shù) keyword

statement = "{a} has  files" statement = statement.format(a = "John", b = 10) John has 10 files

可以混合使用未知&關(guān)鍵字參數(shù)，但是未知必須在關(guān)鍵字之前使用

如果想要打印 { }

a = '{{0.1}} is a {0}'.format('union') print(a) #{}用來(lái)轉(zhuǎn)義{}，相當(dāng)于上面的轉(zhuǎn)義符號(hào)，所以{0.1}會(huì)被當(dāng)作普通character打印 {0.1} is a union

格式化符號(hào)
%c

a = '%c %c %c' % (97, 99, 100) #??一定要加括號(hào) print(a) a c d

%s, %d

str1 = '%s += %d' % ('hello world!', 100) print(str1) hello world! += 100

%f, %e (%E), %g(%G)

%g 自動(dòng)判斷是使用小數(shù)還是科學(xué)記數(shù)法, 不支持指定精確到小數(shù)點(diǎn)后幾位

#10.1: 10表示輸出的結(jié)果至少為10位，如果不夠空格來(lái)湊，1表示小數(shù)點(diǎn)后1位 str1 = '%0.1f == %10.1e == %g' % (1000000, 1000000, 1000000) print(str1) 1000000.0 == 1.0e+06 == 1e+06

其他： 左右對(duì)齊，正數(shù)前面加+， 不同進(jìn)制，規(guī)定輸出width（可選用空格還是0來(lái)填充）,百分比

映射：字典dict

• 與上面的序列不同，dict是屬于映射類型的。
• 通過(guò)輸入key，來(lái)獲取，或者重新賦值，相對(duì)應(yīng)的某個(gè)value。這種key和value相對(duì)應(yīng)的關(guān)系就是映射。
• 可以使用in 和not in，但是??查找的是key，不是value。
• items沒有指定的順序
• 標(biāo)志：冒號(hào):, 如果沒有冒號(hào)，則被默認(rèn)為集合（下面）

dict1 = {'apple' : '🍎', 'banana' : '🍌', a : b, 1 : 2} #或者 dict1 = dict( ( ('apple', '🍎'), ('banana', '🍌'), (a, b), (1 , 2) ) )print(dict1['apple']) print(dict1[a]) print(dict1[1]) 🍎 b 2 dict1['apple'] = 蘋果 #重新賦值 #如果apple這個(gè)key不存在，python會(huì)自動(dòng)創(chuàng)建一個(gè)item

字典操作

下面列舉的,使用的時(shí)候需要明確是對(duì)哪一個(gè)dict操作：e.g. dict1.fromkeys()

• fromkeys()，創(chuàng)建一個(gè)新的dict?？梢杂迷谌绻谶@個(gè)字典里所有keys都對(duì)應(yīng)同樣的value時(shí)。
• keys(), 返回dict里面的所有keys。一般用在for里面。類似的還有values(), items()
• get()，可以自定義，當(dāng)access一個(gè)不存在的key時(shí)，返回的值。
• clear()，清空一個(gè)字典。徹底清除這一個(gè)指針(e.g. dict1)所指向的數(shù)據(jù)。
• pop(key)，返回，輸入的key所對(duì)應(yīng)的value，并且刪除整個(gè)item
• popitem(), 隨機(jī)刪除并返回一個(gè)item
• setdefault(key, value) 在這個(gè)字典里添加一個(gè)item
• update(dict)，用一個(gè)字典來(lái)更新另外一個(gè)。（只更新兩個(gè)字典中都有的key，所對(duì)應(yīng)的value）

推導(dǎo)式：
{key : value+表達(dá)式}

dict1 = {i:i % 2 == 0 for i in range(0, 10)} {0: True, 1: False, 2: True, 3: False, 4: True, 5: False, 6: True, 7: False, 8: True, 9: False}

集合set

• 無(wú)序
• 不支持index索引 e.g.不可以寫 set1[2]
• 支持in, not in
• 可以刪除/添加element

set1 = {1, 3, 4, 2, 5, 4} #沒有映射關(guān)系 #或者 set1 = set([1, 3, 4, 2, 5, 4]) #set()可以接收l(shuí)ist, tuple, stringprint(set1) {1, 2, 3, 4, 5}

??集合里面所有的elements都是唯一的

推導(dǎo)式
{element + 表達(dá)式}

set1 = {i for i in [0, 0, 0, 0, 0, 1, 2]} {0, 1, 2}

不可變集合frozenset

與set相似，但是創(chuàng)建的對(duì)象是不可以被更改的set

BIF/類

下面要介紹的有一些是BIF，有一些是<class ‘builtin_function_or_method’>的對(duì)象，有一些是類。不具體的進(jìn)行區(qū)分。

assert

assert condition

當(dāng)condition結(jié)果為true時(shí)，程序正常運(yùn)行。如果false，程序自動(dòng)退出，顯示assertion error
可以當(dāng)作"break point“使用

assert a = 0

input
返回用戶輸入的字符串 = input (輸出的字符串)

a = int(input("Please enter a number"))

len
返回一個(gè)序列的長(zhǎng)度（elements的數(shù)量）

max , min
返回一個(gè)序列中的最大/小值
??elements必須為同一個(gè)type

sum
??elements必須為同一個(gè)type
返回所有elements的總和

enumerate
其實(shí)例是將列表里的elements和其index組成一個(gè)個(gè)元組?？梢詫⑦@個(gè)實(shí)例轉(zhuǎn)化稱sequence

zip
其實(shí)例將幾個(gè)list合成一個(gè)。可以轉(zhuǎn)換稱sequence

filter
filter (function, sequence)

其實(shí)例是一個(gè)sequence中所有， 可以讓某一個(gè)函數(shù)返回True的, elements。

如果不輸入函數(shù)，其實(shí)例為所有為True的elements。可以轉(zhuǎn)換為sequence

list1 = list(filter(lambda x: x % 2, range(0, 10))) [1, 3, 5, 7, 9]

map
map (function, sequence)
其實(shí)例為所有elements傳入某個(gè)函數(shù)后所得的結(jié)果
可以轉(zhuǎn)換為sequence

list1 = list(map(lambda x: x + 1, range(-2, 3))) [-1, 0, 1, 2, 3]

類相關(guān)

issubclass
返回bool = issubclass(class, classinfo)
classinfo也是輸入一個(gè)類
判斷class是不是classinfo的子類

??

• object是所有類的父類，也就是如果classinfo輸入的是object，永遠(yuǎn)返回True
• classinfo可以輸入元組，但是如果任何一個(gè)element是class的父類，都會(huì)返回True
• 一個(gè)類是他自己的父類

isinstance

返回bool = isinstance(object, classinfo)
判斷object是不是classinfo的實(shí)例。
??

• classinfo可以輸入元組，但是如果object是任何一個(gè)element的實(shí)例，都會(huì)返回True
• 如果A類是B類的子類，那么A類的實(shí)例，也是B類的實(shí)例。

hasattr
返回bool = hasattr(object, name（字符串）)
判斷這個(gè)實(shí)例里面有沒有定義輸入的變量/屬性

getattr
返回name的值 = getattr(object, name[, default（字符串）])
返回這個(gè)實(shí)例中name這個(gè)變量的值
如果輸入的name不存在，可以通過(guò)輸入default的方法，來(lái)自定義程序返回的報(bào)錯(cuò)內(nèi)容。

setattr
setattr(object, name, value)
給name這個(gè)變量賦值，如果name不存在，則創(chuàng)建一個(gè)。

delattr
delattr(object, name)
刪除name這個(gè)變量，如果name不存在，則報(bào)錯(cuò)attribute error。

property
property(獲取屬性的方法，設(shè)置屬性的方法，刪除屬性的方法)
屬性=變量，方法=函數(shù)

使用property，可以直接對(duì)其實(shí)例進(jìn)行以上的操作（獲取，設(shè)置，改變）。不太好解釋，看例子👇

class Name:name = 'ch'def set_name(self, name):self.name = namedef get_name(self):return self.namedef del_name(self):del self.namen = property(get_name, set_name, del_name)

如果上面的代碼里，沒有寫最后一句（i.e.調(diào)用property）。想要設(shè)置，獲取，刪除需要：

name1 = Name()#獲取屬性 print(name1.name) #OR print(name1.get_name())#設(shè)置屬性 name1.set_name('lol') #OR name1.name = 'lol'#刪除 del name1.name #OR name1.del_name()

如果調(diào)用了property：更簡(jiǎn)便

#獲取 print(name1.n) #設(shè)置屬性 name1.n = 'lol' #刪除 del name1.n

魔法方法

• 可以自己定義
• 不需要手動(dòng)調(diào)用，會(huì)在特殊的情況或者使用某種特殊的運(yùn)算符時(shí)自動(dòng)被調(diào)用
• 主要是用來(lái)給complier調(diào)用的

__ init __(self)

方法名與下劃線之間沒有空格。

• 當(dāng)創(chuàng)建一個(gè)object 的時(shí)候，這個(gè)函數(shù)會(huì)自動(dòng)被調(diào)用。
• 可以自己定義init函數(shù)并且添加parameters，但是，在創(chuàng)建object的時(shí)候，要把init函數(shù)的所有parameters都輸入進(jìn)去

class Car():def __init__(self, name):self.name = namedef calculate_speed(self, distance, time):speed = distance / timeprint('%s is travelling at %f m/s' % (self.name, speed)) car1 = Car('carro') #傳入name car1.calculate_speed(30, 10) carro is travelling at 3.000000 m/s

可以對(duì)比之前的例子，來(lái)看一下不同的地方。

__ new __ (cls)

• 實(shí)例化過(guò)程中第一個(gè)被調(diào)用的方法。本身是進(jìn)行實(shí)例化的方法。這個(gè)函數(shù)返回一個(gè)實(shí)例。
• cls相當(dāng)于其他函數(shù)中的self。self指的是一個(gè)實(shí)例，cls是一個(gè)類。因?yàn)檫@個(gè)函數(shù)/方法就是為了創(chuàng)建這個(gè)類的實(shí)例，所以用cls不用self，因?yàn)閟elf不存在?？梢蕴砑悠渌暮瘮?shù)，但是必須在創(chuàng)建實(shí)例的時(shí)候，傳入。

什么時(shí)候需要改寫？
大部分時(shí)間不需要改寫。如果創(chuàng)建了一個(gè)類，并且這個(gè)類繼承了不可變的類（e.g. tuple，str，int）。如果想要對(duì)創(chuàng)建的實(shí)例，在創(chuàng)建的時(shí)候就作出改變（i.e. 不同于不可變的類的地方），那么就需要通過(guò)改寫new來(lái)實(shí)現(xiàn)。

??其他可變的類不可以通過(guò)改寫new來(lái)改變返回的實(shí)例。

例如，如果創(chuàng)建了一個(gè)類，這個(gè)類繼承了元組tuple這個(gè)類，但是和tuple()的不同之處在于，這個(gè)類的所有實(shí)例都會(huì)在最后加上一個(gè)’c’

class AppendElement(tuple):#繼承tupledef __new__(cls, input):input = input + ['c']return tuple.__new__(cls, input)#tuple默認(rèn)的__new__會(huì)把一個(gè)iterrable的參數(shù)轉(zhuǎn)化為元組。 #這里，對(duì)傳進(jìn)來(lái)的參數(shù)先操作，然后傳給tuple，讓tuple將參數(shù)變?yōu)樵M。tuple1 = AppendElement([2, 3, 4]) print(tuple1)tuple2 = tuple([2, 3, 4]) print(tuple2) (2, 3, 4, 'c') (2, 3, 4)

__del __(self)

• 垃圾回收機(jī)制：
  ??和del不一樣（del刪除變量/標(biāo)簽），也不是每次調(diào)用del都會(huì)調(diào)用__del__。當(dāng)所有標(biāo)簽被刪除時(shí)，系統(tǒng)就會(huì)執(zhí)行這個(gè)方法，回收該內(nèi)容。

class C:def __del__(self):print('調(diào)用__del__')c = C() c1 = c c2 = c del c2 print('---') del c1 print('===') del c --- === 調(diào)用__del__

__ getattr _(self, name)

• 當(dāng)用戶訪問一個(gè)在這個(gè)類中不存在的屬性/變量是被調(diào)用

__ getattribute _(self, name)

• 當(dāng)用戶訪問這個(gè)類的屬性時(shí)被調(diào)用

__ setattr _(self, name, value)

• 當(dāng)用戶設(shè)置這個(gè)類的一個(gè)屬性時(shí)被調(diào)用

__ delattr _(self, name, value)

• 當(dāng)這個(gè)類的一個(gè)屬性被刪除時(shí)被調(diào)用

其他
這些就不一一列舉了，感興趣的可以自己搜一下，已經(jīng)有很多人總結(jié)過(guò)了。

算數(shù)運(yùn)算符：add, sub, floordiv, etc.

反運(yùn)算：當(dāng)?shù)谝粋€(gè)參數(shù)不支持某種算數(shù)操作時(shí)，使用第二個(gè)參數(shù)的反運(yùn)算。radd, rsub, etc

增量賦值：iadd (+=), isub (-=)

單元操作符：neg (-負(fù)號(hào)), pos (+正號(hào))

描述符
描述符是一種特殊的類，其 實(shí)例object可以被賦值給另外一個(gè)類（為了方便下面的文章，簡(jiǎn)稱B類）的變量。然后通過(guò)對(duì)這個(gè)變量操作，就可以訪問，設(shè)置，刪除B類中的某個(gè)屬性。
在上一個(gè)section中的property就是一個(gè)描述符。

什么樣的類是描述符？
這個(gè)類必須實(shí)現(xiàn)/定義了下面三個(gè)方法中至少一個(gè)：

__ get __(self, instance, owner)
通過(guò)返回屬性來(lái)訪問屬性

__ set __ (self, instance,
value)
給屬性賦值

__ delete __ (self, instance)
刪除屬性

self需要傳入：描述符的對(duì)象
instance需要傳入：B類的對(duì)象
owner需要傳入：B類

迭代

可迭代的對(duì)象 iterable

一個(gè)實(shí)現(xiàn)了__ iter__魔法方法（下面會(huì)介紹）的對(duì)象
也就是說(shuō)，這個(gè)對(duì)象的類必須定義了__ iter__這個(gè)魔法方法。

迭代器 iterator

迭代器一定是可迭代對(duì)象，但是可迭代對(duì)象不全是迭代器。
因?yàn)?#xff0c;迭代器是一個(gè)實(shí)現(xiàn)了__ iter__()和__ next__() 兩個(gè)魔法方法的對(duì)象。

介紹兩個(gè)BIF和魔法方法：

返回迭代器 = iter(iterable)

這個(gè)BIF會(huì)調(diào)用輸入的iterable對(duì)象的__ iter__()方法。

__ iter__(self)
返回一個(gè)迭代器

如果，該類 實(shí)現(xiàn)了__ iter__和__ next__兩個(gè)魔法方法，__ iter__()可以直接返回self，因?yàn)槠鋵?duì)象本身就是一個(gè)iterator

返回下一個(gè)元素 = next(迭代器)

調(diào)用輸入的iterable對(duì)象的__ next__(self)這個(gè)魔法方法

__ next__(self)

return下一個(gè)元素
如果沒有元素可以輸出了（i.e. 已經(jīng)輸出了最后的元素），raise StopIteration異常。

👇 建立一個(gè)類，這個(gè)類的對(duì)象是一個(gè)Fibonacci斐波拉茲序列。并且利用這兩個(gè)BIF “實(shí)現(xiàn)” for循環(huán)：

class Fibonnacci:a = 0b = 1i = 0def __iter__(self):return selfdef __next__(self):self.i += 1if(self.i > 10):raise StopIterationelse:self.a, self.b = self.b, self.a + self.b return self.aFib1 = Fibonnacci() Fib1Iter = iter(Fib1) try:while(1):print(next(Fib1Iter)) except StopIteration:pass 1 1 2 3 5 8 13 21 34 55

函數(shù)

命名規(guī)則：function_name，parameter_name

def is_even(number):if number % 2 == 0:return Trueelse:return False

局部，全局變量

?? 如果嘗試在一個(gè)function里面對(duì)一個(gè)global variable重新賦值，需要明確某一個(gè)變量是global variable

def change():global global_v #這一句一定要有，否則結(jié)果為200global_v = 20global_v = 200 change() print(global_v) 20

如果沒有寫global：

def change():global_v = 20 #這里python重新創(chuàng)建了一個(gè)local variable，并且給它賦值20global_v = 200 change() print(global_v) 200

函數(shù)文檔
和注釋一樣，在調(diào)用函數(shù)的時(shí)候不會(huì)被執(zhí)行，但是可以幫助理解這個(gè)函數(shù)

def sum(num1, num2):'這是一個(gè)用來(lái)計(jì)算sum的函數(shù)‘ #👈 函數(shù)文檔return num1 + num2print(sum.__doc__) '這是一個(gè)用來(lái)計(jì)算sum的函數(shù)‘

參數(shù)

關(guān)鍵字參數(shù)&默認(rèn)參數(shù)

在沒有輸入?yún)?shù)時(shí)，使用默認(rèn)參數(shù)

def sum(num1 = 3, num2 = 6): #默認(rèn)參數(shù)return num1 + num2print(sum(num2 = 1, num1 = 2)) #關(guān)鍵字參數(shù) print(sum()) 3 9

收集參數(shù)
當(dāng)不確定有多少個(gè)參數(shù)時(shí)

格式： def function(*參數(shù)名):

def sum(*params):result = 0for i in params:result += iprint(result)sum(1,2,55,43) 101

??如果在收集參數(shù)之后，還想要添加別的參數(shù)。在調(diào)用的時(shí)候，要通過(guò)關(guān)鍵字參數(shù)的方法調(diào)用

print本身就有一個(gè)收集參數(shù)

內(nèi)嵌函數(shù) embedded function

內(nèi)部函數(shù)可以調(diào)用外部函數(shù)內(nèi)的variables，但是不可以重新賦值，除非使用"nonlocal"

def power(x):def helper():nonlocal xx *= xreturn xreturn helper() #這里是先調(diào)用helper，然后將helper返回的值返回；#如果寫return helper, 返回的將是一個(gè)functionprint(power(5)) 25 def multiply(num1):def helper(num2):return num1 * num2return helper #這里return一個(gè)函數(shù)，因?yàn)閙ultiply里面并沒有num2，所以無(wú)法調(diào)用helper，并返回helper的返回值print(multiply(2)(3)) 6

lambda表達(dá)式

簡(jiǎn)化函數(shù)代碼

def add(x, y):return x + y

返回函數(shù) = lambda parameters : return的expression

add = lambda x, y: x+y

生成器 Generator

個(gè)人理解：也是一種迭代器
和迭代器一樣可以被next調(diào)用，然后返回下一個(gè)返回值。

一個(gè)定義中含有yield的函數(shù)，就會(huì)返回一個(gè)生成器。

這個(gè)函數(shù)，在執(zhí)行到y(tǒng)ield（類似return）時(shí)，會(huì)返回yield后面的值，保存函數(shù)當(dāng)前運(yùn)行的位置。在下一次被調(diào)用的時(shí)候，會(huì)從上一次結(jié)束的位置繼續(xù)運(yùn)行，直到遇到下一個(gè)yield。

利用生成器實(shí)現(xiàn)一個(gè)斐波拉契序列，并將其一個(gè)個(gè)輸出。

def Fibonnacci():a = 0b = 1while 1:a, b = b, a +byield aFibGene = Fibonnacci() #生成器 for each in FibGene: #each是next(FibGene)的返回結(jié)果if each < 100:print(each)else:break 1 1 2 3 5 8 13 21 34 55 89

生成器推導(dǎo)式

?? 不是元組推導(dǎo)式，而是生成器推導(dǎo)式。
(yield的值 + 表達(dá)式)

evenNumbers = (i for i in range(0, 20) if not(i%2)) print(evenNumbers) for i in evenNumbers:print(i) <generator object <genexpr> at 0x10b78d9a8> evenNumbers是一個(gè)生成器👆 0 2 4 6 8 10 12 14 16 18

生成器推導(dǎo)式可以直接作為一些函數(shù)的參數(shù)，不需要括號(hào)。

list1 = list(i for i in range(0, 20) if not(i%2)) print(list1)maxinList1 = max(i for i in range(0, 20) if not(i%2)) print(maxinList1) [0, 2, 4, 6, 8, 10, 12, 14, 16, 18] 18

文件

打開一個(gè)文件

模式操作

‘w’	寫，如果文件已經(jīng)存在，刪除原有內(nèi)容，重新寫入；文件不存在，創(chuàng)建一個(gè)文件
‘r’	讀
‘x’	如果文件存在，返回異常
‘a(chǎn)’	如果文件不存在，寫入方式創(chuàng)建文件。如果文件存在，追加
	下面的模式可以與上面的模式組合使用(e.g. wb, rt, ab+)
‘t’	文本文件
‘b’	二進(jìn)制文件
‘+’	讀寫

open ('文件名‘ , ‘打開方式’)

file1 = open('test', 'w')#打開/創(chuàng)建一個(gè)文件

文件操作
簡(jiǎn)單敘述可能的操作：

.close() 關(guān)閉文件
要及時(shí)關(guān)閉文件，否則寫入的內(nèi)容會(huì)停留在緩沖區(qū)，并沒有真正的存入文件里面
.read() 按照字符個(gè)數(shù)讀取，返回文件內(nèi)容。默認(rèn)讀取全部?jī)?nèi)容。
.readline() 按照行數(shù)讀取
.tell() 返回文件指針的位置 in bytes！
.seek ()移動(dòng)文件指針
.list() 可以直接將文件的內(nèi)容變成一個(gè)list

??，在for里面，甚至可以直接將文件當(dāng)作一個(gè)sequence使用：

#假設(shè)有一個(gè)文本文件file1，已經(jīng)被打開 for line in file1:print(line)

.write() 寫入字符串
.writeline() 寫入字符串sequence

?? 從文件中寫入，讀取的數(shù)據(jù)都是字符串。如果要寫入/讀取的數(shù)據(jù)類型不是字符串，可以通過(guò)int, float等來(lái)轉(zhuǎn)換，或者如果數(shù)據(jù)類型不容易轉(zhuǎn)換的話，可以使用pickle模塊（見模塊）。

with語(yǔ)句
使用with語(yǔ)句，就不需要自己手動(dòng)來(lái)關(guān)閉文件。

with open('file name', '打開方式') as 變量名:執(zhí)行文件操作

模塊

• 模塊 == 寫的程序。

• 使用模塊可以將不同的程序接在一起 (import)，但是更簡(jiǎn)潔。

• 可以將一些數(shù)據(jù)（列表，字典），函數(shù)， 等保存到一個(gè)單獨(dú)的文件/模塊里，以后調(diào)用。

• 模塊可以被其他程序import，但要確保這個(gè)模塊的路徑，在sys.path這個(gè)列表里面。

import sys sys.path #這是一個(gè)列表，這個(gè)列表里面包含了一系列的文件。當(dāng)import的時(shí)候，系統(tǒng)會(huì)到這些文件里面里尋找某個(gè)模塊，如果沒有找到，報(bào)錯(cuò)。

• 如果要被import的模塊的路徑，不在這個(gè)列表里。我們可以通過(guò)append的方法，將該路徑添加進(jìn)去。
  ??， 使用\的時(shí)候要注意轉(zhuǎn)義。
• 通過(guò)import模塊，可以調(diào)用里面的程序。

import random random_num = random.randint(0, 10)#或者 import random as r random_num = r.randint(0, 10) from random import * #執(zhí)行這個(gè)操作，可以直接使用里面的所有變量/函數(shù)，不需要加上random.randint，可以直接使用randint from random import randint #可以直接使用randint

__ name__

如果在正在編寫的程序中，調(diào)用__ name__，會(huì)打印’__ main__’
如果是調(diào)用一個(gè)模塊中的__ name__ (e.g. moduleName.__ name__)則會(huì)打印模塊名。

用處：
在一些情況下，模塊中調(diào)用（不是定義）了一些函數(shù)。那么，在import這個(gè)模塊的時(shí)候，這些函數(shù)也會(huì)自動(dòng)被調(diào)用。
通過(guò)if __ name__ == ‘__ main__’，就可以只在run該文件的時(shí)候，調(diào)用這些函數(shù)。

OS 操作系統(tǒng)
使用這個(gè)模塊，可以進(jìn)行重命名文件，刪除創(chuàng)建文件及目錄等操作

pickle
方便不是字符串的數(shù)據(jù)，以二進(jìn)制的方式，讀取/寫入到文件。

寫入數(shù)據(jù)

import pickle student_file = open('student.pkl', 'wb') #??以二進(jìn)制的方式打開，文件后綴寫成pkl方便理解pickle.dump(list1, student_file) student_file.close()

讀取數(shù)據(jù)

import pickle student_file = open('student.pkl', 'rb')list2 = pickle.load(student_file) student_file.close()

包package

意義：

模塊通過(guò)import可以手動(dòng)導(dǎo)入一個(gè)個(gè)的文件/模塊。包則可以導(dǎo)入一個(gè)個(gè)的文件夾

更為有序?？梢酝ㄟ^(guò)不同類型，將模塊分類，組織在不同的文件夾下。

步驟：

創(chuàng)建文件夾。放入想要存放的模塊。可以在這個(gè)文件夾下，創(chuàng)建子文件夾。

在這個(gè)文件夾里面，創(chuàng)建一個(gè)__ init__.py文件。這個(gè)文件可以是空的，但是必須從在

?? 和模塊一樣，要確保包的路徑在sys.path這個(gè)列表里面。
導(dǎo)入方法：

#1. 導(dǎo)入整個(gè)包 import package1 #2. 導(dǎo)入某個(gè)特殊的文件（子文件夾的文件） #package1里面的package2中的test這個(gè)文件 import package1.package2.test

并且支持在模塊中介紹的其他導(dǎo)入方法。

異常exception

命名規(guī)則：ExceptionName

程序可能會(huì)出現(xiàn)很多種異常 (e.g. ValueError, OSError)，針對(duì)異常作出相應(yīng)的反應(yīng)，就會(huì)用到try語(yǔ)句

try語(yǔ)句

?? 如果出現(xiàn)了指定的異常，不會(huì)顯示原有的traceback語(yǔ)句，而是只會(huì)執(zhí)行except的代碼

try:要執(zhí)行的代碼 except 指定的異常 [as 變量]: #這個(gè)變量用來(lái)存放出錯(cuò)的具體原因如果出現(xiàn)指定的異常，需要執(zhí)行的代碼 [finally:不管出不出現(xiàn)異常，都必須執(zhí)行的代碼。（一旦出現(xiàn)異常，程序會(huì)自動(dòng)調(diào)到對(duì)應(yīng)的except語(yǔ)句中，try里面的一些代碼可能不會(huì)被執(zhí)行） ] try:with open('test.txt', 'r') as file1:str1 = file1.read(5) except OSError as reason:print('文件出錯(cuò)，具體原因?yàn)?#xff1a;' + str(reason)) finally:print('exiting...')

自己創(chuàng)造一個(gè)異常：

raise exception [( ‘注釋’ ) ]

raise OSError('要讀取的文件不存在')

總結(jié)

以上是生活随笔為你收集整理的python基本语法整理的全部?jī)?nèi)容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網(wǎng)站內(nèi)容還不錯(cuò)，歡迎將生活随笔推薦給好友。