目錄

• 一、python
• • 1.python的基礎語法
  • • 1.python的介紹
    • 2.python的注釋方法
    • • 1.單行注釋：#
      • 2.多行注釋：三個單引號（’’’）或者三個雙引號（”””）
    • 3.python的數據類型
    • 4.面向對象
  • 2.python的構造函數
  • • 1.python中構造函數的格式為：`__init__()`
    • 2.python查看變量內存地址：id
    • 3.顯式調用構造函數，會變成普通函數
    • 4.構造函數的返回值
    • 5.self保存不同對象的特征值
    • 6.類變量和實例變量具體區別
    • 7.動態添加與修改變量
    • 8.__name__在Python中的作用
    • 9.構造方法也可以看作特殊實例方法
  • 3.裝飾器
  • • [email protected]：類方法
    • [email protected]：靜態方法
  • 3.公開，保護與私有
  • 4.子類給父類傳值，需要使用super關鍵字
  • 5.閉包
  • 6.列表生成式
  • 7.生成器generator
  • 8.迭代器
  • 9.高階函數
  • • 1）匿名函數
    • 2）map(__func, __iter1)
    • 3）reduce(__func, __iter1)
    • 4）filter(__function,__iterable)
    • 5）sorted(__iterable,key,reverse)

一、python

1.python的基礎語法

1.python的介紹

概述
Python 是一個高層次的結合了解釋性、編譯性、互動性和面向對象的腳本語言。

Python 的設計具有很強的可讀性，相比其他語言經常使用英文關鍵字，其他語言的一些標點符號，它具有比其他語言更有特色語法結構。

Python 是一種解釋型語言： 這意味著開發過程中沒有了編譯這個環節。類似於PHP和Perl語言。
Python 是交互式語言： 這意味著，你可以在一個Python提示符，直接互動執行寫你的程序。
Python 是面向對象語言: 這意味著Python支持面向對象的風格或代碼封裝在對象的編程技術。
Python 是初學者的語言：Python 對初級程序員而言，是一種偉大的語言，它支持廣泛的應用程序開發，從簡單的文字處理到 WWW 浏覽器再到游戲

2.python的注釋方法

1.單行注釋：#

單行注釋常以#開頭
windows的快捷鍵是 Ctrl + /
實例：

# -太棒了
print ("hello world!"); #您好，世界

2.多行注釋：三個單引號（’’’）或者三個雙引號（”””）

注釋使用三個單引號（’’’）或者三個雙引號（”””）來標記，而實際上這是多行字符串的書寫方式，並不是Python本身提倡的多行注釋方法
實例：

'''
這是多行注釋，使用單引號。
這是多行注釋，使用單引號。
'''
"""
這是多行注釋，使用雙引號。
這是多行注釋，使用雙引號。
"""

3.python的數據類型

# int
a = 3
#float
a = 3.3
# str
a = 'str'
# bytes
a = b'4'
# complex
a = 2 + 3j
# bool
a = True
# None
a = None

Python語法比較松散，語句的最後不強制要求加’;’，在定義變量時，不需要聲明變量的數據類型，Python會根據變量的賦值自動給定數據類型

如果在定義一個變量時不確定他的類型，可以使用None來進行賦值，此時的類型也是None Type

4.面向對象

面向對象編程是一種封裝代碼的方法；代碼封裝就是隱藏實現功能的具體代碼，僅留給用戶使用的接口。
Python中也支持面向對象的三大特征：封裝、繼承、多態。

面向對象的相關術語
類：可以理解是一個模板，通過它來創建出無數個具體的實例；類是抽象一類事物的總稱，
對象：類時不可以直接使用的，需要通過類創建的實例才能使用，這個實例也就是對象。
屬性：類中的所有變量稱為屬性
方法：類中的所有函數通常叫做方法

這裡的重點就是類和對象。
類的命名規則首字母最好大寫，可以采用駝峰寫法，例如：StudentName
python中的類也是通過用class來定義，並且他也可以下成“class student(object)”的方式來定義，括號內的是class所繼承的父類，如果不知道又想寫的話寫object就行。

2.python的構造函數

1.python中構造函數的格式為：__init__()

想讓類定義不同對象，我們需要構造函數。不同的構造函數能賦予不同的屬性

#c9_1.cy
class Array1:
'''
類裡面的變量我們稱做
類變量
'''
data = 'ring01'
size = 1
# def __init__(self):
def __init__(self):
'''
構造函數,基本是通用的，包括php，java都有構造函數
'''
print('Array1')
def get_size(self):
print('get_size')

1.上述中class Array1後面的父類是默認跟object。class Array1(父類）:
2.其中python當中的self如同java等其他語言的this，可以進行修改但是不建議這樣做。
3.python中類實例化後一瞬間自動執行

實例化後自動執行例如：

from c9_1 import Array1, Array2
arr = Array1()

結果

在運行python後我們發現它自動打出了Array1，但是我們沒有進行print的顯示語句

2.python查看變量內存地址：id

如果實例化對象是相同的，這裡的相同只是內部變量值，方法相同但計算機中但內存地址不同。

from c9_1 import Array1, Array2
arr = Array1()
arr1 = Array1()
arr2 = Array1()
#
print(id(arr), id(arr1), id(arr2))

結果：三個內存地址不同

3.顯式調用構造函數，會變成普通函數

from c9_1 import Array1, Array2
arr = Array1()
arr.__init__()

結果：雖然這裡顯示了，但是這個構造函數已經變成了普通函數。【顯示兩次，一次實例化顯示一次print調用構造函數顯示】

為什麼打印出了兩次
構造函數的特性：
1.構造函數在類實例化的同時，就已經自動運行了
2.構造函數能不能顯式調用，明顯是可以的 但在編程中不要這樣調用

4.構造函數的返回值

from c9_1 import Array1, Array2
arr = Array1()
a = arr.__init__()
print(a)
print(type(a))

結果：

結果中兩個 Array1 已經解釋過了，但是為什麼有None的數據類型

解釋：
1.沒有return ？

2.構造函數應該返回none而不是int。

根本原因；本身是構造函數，在對其進行調用的時候使它變為普通函數。而普通函數需要返回值，構造函數不需要。但是我們沒有返回return
value所以函數默認返回None。

重點：構造函數不能，也不需要返回任何值

5.self保存不同對象的特征值

定義實例方法時，需要有self這個參數。調用時候不需要對self傳參。

class Array2:
'''
類裡面的變量我們稱做
類變量
'''
data = 'ring02'
size = 2
def __init__(self, data, size):
'''
構造函數,基本是通用的，包括php，java都有構造函數
構造函數作用，初始化對象屬性
對象中的變量，方法都屬於屬性
data,size都是實例變量
'''
data = data
size = size
def get_size(self):
print('get_size')

from c9_1 import Array1, Array2
arr2 = Array2([1,2,3,4,5], 5)
print(Array2.data)

結果：這裡沒有顯示值

首先我們可以看值有沒有傳出，添加print查看

再次運行【打印出來值的，所有傳出值了的】

造成上述情況原因；沒有使用self保存傳遞的值
為此：

from c9_1 import Array2,Array3,Array4
arr3 = Array3([1,2,3,4], 4)
arr3.get_size()
arr3 = Array3([1,2,3,4,5,6], 6)

class Array3:
data = 'ring03'
size = 2
age = 11
def __init__(self, data1, size1):
self.data = data1
self.size = size1
"""
打印對象的屬性
"""
def get_size(self):
print('data is {}'.format(self.data))
print('size is %d' % self.size)
def get_data(self):
print(self.data)

結果：

既然我們在類實例化的時候 傳遞進來不同對象的特征值
那麼我們就需要保存不同對象的特征值
使用self保存對象的屬性
self只和對象有關
誰調用了這個方法，self就與誰有關
self只和對象有關
和類無關

6.類變量和實例變量具體區別

from c9_1 import Array2,Array3,Array4
arr3 = Array3([1,2,3,4,5,6], 6)
print(arr3.__dict__)
print(arr3.size)
print(arr3.data)

class Array3:
data = 'ring03'
size = 2
age = 11
def __init__(self, data1, size1):
self.data = data1
self.size = size1
def get_size(self):
print('data is {}'.format(self.data))
print('size is %d' % self.size)
def get_data(self):
print(self.data)

dict：顯示對象保存的所有屬性

思考
在我們Array3數組類中定義，一個data和size是否合適？
我們Array3是一個類，這是一個模版
一個大而空的東西
在大而空的東西裡面定義具體的data和size
這樣明顯是不合適的

7.動態添加與修改變量

class Array2:
'''
類裡面的變量我們稱做
類變量
'''
data = 'ring02'
size = 2
def __init__(self, data, size):
'''
構造函數,基本是通用的，包括php，java都有構造函數
構造函數作用，初始化對象屬性
對象中的變量，方法都屬於屬性
data,size都是實例變量
'''
data = data
size = size
def get_size(self):
print('get_size')

from c9_1 import Array2,Array3,Array4
arr2 = Array3([1,2,3], 3)
# arr2對象動態添加lens變量
arr2.lens = 3
Array3.data = 'ring033'
print(arr2.__dict__)
print(Array3.__dict__)
print(arr2.data,arr2.size,arr2.lens, Array3.data)

結果：

發現對象屬性本身是沒有lens的變量的，但是添加了
另外Array3.data的值手動更改了後，顯示的值也發送改變了
上述中 data = 'ring02’與size = 2 ；這兩個屬性與變量關系小時可以定義到類中，對象關系比較緊密就最好在構造函數中。

補充
想在對象裡面（構造函數也算）訪問類變量可以：print(self.class.data)

8.__name__在Python中的作用

python程序中一般都會有一個if條件句

if __name__ == '__main__':

當在有這個if條件句的模塊中時，該程序會作為程序的入口，name__會強制改為__main

當在其他模塊調用該模塊時，__name__的值是該模塊的文件名

9.構造方法也可以看作特殊實例方法

調用構造方法直接在類的實例化時候就可以調用，而調用實例方法，是通過（對象.方法）進行點用
arr.get_size

思考下在構造函數裡面打印
實例變量self.data與data
結果是相同的嗎

解釋：
self.data與data真的是打印的同一個變量嗎
嘗試將形參data改為data1，再次進行嘗試
self.data打印的對象中的實例變量 data打印的只是我們的形參

3.裝飾器

lass Array5:
# 統計數組中所有元素的和
"""
AOP思想
"""
sum = 1
# 類變量，實例變量
def __init__(self, data, size):
'''
self.__class__.sum
Array5.sum
:param data:
:param size:
'''
self.data = data
self.size = size
@classmethod
def class_arr(cls):
cls.sum += 1
# print(self.data)
print(cls.sum)
"""
裝飾器
"""
@staticmethod
def static_func1():
print('static')
def get_size(self):
# print(self.__class__.sum)
print('data is %s' % self.data)
print('size is %d' % self.size)

[email protected]：類方法

傳遞類：cls

from c9_1 import Array5
arr = Array5([1,2,3],3)
arr.get_size()
Array5.class_arr()

類方法
1.在實例方法中操作類變量
2.定義類方法(classmethod)
3.類方法作用顧名思義就是操作類變量 類方法中cls可以更改，但並不建議
4.類方法關聯我們類本身，實例方法關聯我們對象

各類方法

1. __ new ()方法：是一種負責創建類實例的靜態方法，他不需要使用staticmethod裝飾器修飾，並且它優點於 init __ ()初始化方法被調用。
   2. repr __()方法：顯示屬性
2. __ del __()方法：銷毀對象
3. __ dir ()用法：列出地所有屬性名
   5. dict __()屬性：查看對象內部所有屬性名和屬性值組成的字典

[email protected]：靜態方法

和類與對象關聯小，基本為單個方法。【使用比較少】

3.公開，保護與私有

protected：保護，可以被子類進行調用
private：私有方法，只可以被自己調用，子類也不行。
public：公有的

保護與私有區別： 保護被子類調用 私有只能自己用
__【兩個下劃線默認為私有屬性】】

class Array6:
'''
類裡面的變量我們稱做
類變量
'''
data = 'ring02'
size = 2
def __init__(self, data, size):
'''
構造函數,基本是通用的，包括php，java都有構造函數
構造函數作用，初始化對象屬性
對象中的變量，方法都屬於屬性
data,size都是實例變量
'''
self.data = data
self.size = size
self.__price = 0
# self.price = 0
# desc我不希望別人在外部直接更改
def __modify_price(self, index):
if index < 0 or index > 100:
raise ValueError('range index error')
self.__price = index
print(self.__price)
def get_size(self):
print('data is %s' % self.data)
print('size is %d' % self.size)
def get_capacity(self):
print('capacity')

訪問私有變量調用函數

from c9_1 import Array6
arr6 = Array6([1,2,3], 3)
print(arr6.__dict__)
print(Array6.__dict__)
arr6._Array6__price = 2
print(arr6.__dict__)

錯誤的修改方式
print(arr6.price)
arr6.get_size()
print(arr6.dict)
print(Array6.dict)
正確的修改方式
arr6.modify_price(2)
arr6.get_size()
私有方法，無法直接調用
print(arr6.dict)
print(Array6.dict)
arr6._Array6__modify_price(3)

4.子類給父類傳值，需要使用super關鍵字

class Student1(Person):
def __init__(self, organization, name, skill):
self.organization = organization
"""
子類給父類傳值，需要使用super關鍵字
"""
super().__init__(name, skill)
# def __init__(self, organization, name, skill):
# self.organization = organization
# super().__init__(name, skill)
def do_kill_monster(self):
pass
stu1 = Student1('英雄', 'king', '心髒引擎')
print(stu1.name)
print(stu1.skill)
print(stu1.organization)

如果我們子類完全繼承父類 那麼子類存在沒任何意義
我們子類需要有一些不同於父類的變量，方法 這樣才能最大程度發揮好繼承作用

5.閉包

定義了函數和外部環境變量的結構為閉包，環境變量必須在函數外，且不可是全局變量，且外面一個函數的返回值是裡面一個函數。它記住了自由變量的狀態

閉包 = 函數+環境變量(函數定義時候)
注意：環境變量一定要在定義函數的外部，而且不能是全局變量

def demo1():
a = 3
def demo2(x):
return a*x*x
return demo2
a = 10
d = demo1()

上述函數d = demo1()，其實是用demo1()函數，把demo2(x)賦給d

添加函數print(d.__closure__)閉包返回的是一個對象object，是將函數和環境變量都返回了

查看是否是閉包，還可以通過a.closure[index].cell_contents查看閉包中每個元組的值
添加函數print(d.__closure__[0].cell_contents)返回的閉包的環境變量a = 3

對d賦值，
以下格式就是閉包：有外部環境變量，自由變量，內部的函數，引用自由變量，返回內部函數名稱

def demo1():
a = 3
def demo2(x):
return a*x*x
return demo2
a = 10
d = demo1()
print(d(2))

6.列表生成式

列表常用的方法
1.append()方法：用於在列表末尾添加型的對象—語法：list.appandd()
2.count()方法：用於統計某個元素在列表中出現的次數—語法：list.count()
3.extend()方法：用於在列表末尾異性追加另一個序列中的多個值—語法:list.extend(seq)
4.index()方法：用於從列表中找出某個值第一個匹配項的索引位置—語法：list.index(x[, start[, end]])-----x:查找的對象；start：開始位置，end：結束位置
5.pop()方法：用於移除列表中的一個元素，默認為列表中的最後一個元素，並且返回該元素的值—語法：list.pop([index=-1])
6.remove()方法：用於移除李彪中某個值的第一個匹配項----語法：list.remove(obj)
7.reverse()方法：將元素倒序排列

列表生成式本質上就是for循環

aa = [i * i for i in range(1,5)]
print(aa)

遇見if else不能把if x % 2 == 0 else -x放後面只能放前面

fff = [x if x % 2 == 0 else -x for x in range(1,10)]
print(fff)

7.生成器generator

將列表[]改為()即可稱為生成器
只要把一個列表生成式的[]改成()，就創建了一個generator

generator保存的是算法 每次調用next(g)，就計算出g的下一個元素的值，
直到計算到最後一個元素，沒有更多的元素時，拋出StopIteration的錯誤
一直用next調用【一步一步的調用】，一定不是一個好辦法,我們需要用for來調用 for可以將StopIteration處理 因為生成器也是一個可迭代對象，它進行惰性匹配

惰性匹配，循環一次算一次。這樣循環時開始計算節省內部空間

ll = (x * x for x in range(10))
print(next(ll))
print(next(ll))
print(next(ll))
print(next(ll))

上述表達可以改為for循環

ll = (x * x for x in range(10))
for i in ll:
print(i)

使用循環好處在，它會在范圍超過的時候會捕獲錯誤不會報錯會直接輸出。
報錯實例：

ll = (x * x for x in range(3))
print(next(ll))
print(next(ll))
print(next(ll))
print(next(ll)

yield命令：可以將正常數列變成生成器，他可以從中斷的位置繼續運行。

generator函數和普通函數的執行流程不同，普通函數遇到return語句或者最後一行函數語句就直接返回，但是generator函數再用next()調用執行的時候，遇到yield語句也會返回，但是再次執行的時候會從上此次返回的yield語句處執行。

對於yield的理解，可以理解為是特殊的return關鍵字
當執行到yield i時，返回了i的值，並保存了此時函數的狀態，當使用next調用這個生成器函數時，就會從剛剛返回值的時候繼續函數的執行

8.迭代器

迭代對象和迭代器next
可迭代對象，可以被for循環的數據-----迭代器iter(),iter(),-------生成器 yield [] ()
可迭代對象：字符串、元組、列表、字典、set（在定義中最好放一個數組；set最主要的功能是可以去重）
生成器就是一種迭代器，可以被next調用並不斷返回下一個值的對象稱為迭代器：iterator。
優先級：generator生成器 > itertor > iterable

9.高階函數

1）匿名函數

使用lambda關鍵字修飾的簡單函數

lambda x,y: x>y?x:y

def add_demo(x,y):
return x + y
def print_str(x):
return x
f = lambda x, y : x + y
print(f(2,3))

2）map(__func, __iter1)

__func函數：傳入函數值與函數名
__iter1函數：處理
map傳入第一個參數式接受一個函數，第二個參數式一個可迭代對象，結果返回一個迭代器。
即：使用__iter1迭代器執行__func函數

3）reduce(__func, __iter1)

與map相似都是使用__iter1迭代器執行__func函數
不同與map：將上一次計算的結果作為下一次計算的參數

4）filter(__function,__iterable)

用__function函數過濾，__iterable中的元素

5）sorted(__iterable,key,reverse)

依據key的值排序__iterable中的元素，reverse決定是否逆序