python--基礎知識點梳理（一）

可變數據類型和不可變數據類型有哪些？

# 可變數據類型：列表、字典、集合
# 不可變數據類型：數字、元祖、字符串

常見數據結構

# 棧(stack)--先進後出、 隊列(queue)-先進先出、鏈表(LinkedList)

可迭代對象

# 可迭代對象包括：列表、字典、集合、字符串等數據類型。
# 數字類型不可迭代

 

迭代：咱們把python中被for循環取值的操做過程能夠理解爲迭代

可迭代對象：把能夠被for循環遍歷的對象也叫可迭代對象。一個具備__iter__()方法的對象是可迭代的，具備__next__()方法的對象是迭代器。(__iter__()方法返回本身，__next__()返回for循環的下一個對象，for循環的本質就是不斷調用__next__()方法)

迭代器：訪問集合內元素的一種方式。是一個能夠記住遍歷的位置的對象。迭代器對象從集合的第一個元素開始訪問，直到全部的元素被訪問完結束。迭代器只能往前不能後退，分步驟的完成某個事情

# 迭代器實現斐波那契：                                     
class Fei(object):
    def __init__(self,n):
        self.n=n
        self.num1=0
        self.num2=1
        self.word_index=0
    def __iter__(self):
        return self
    def __next__(self):
        if self.word_index < self.n:
            num=self.num1
            self.num1,self.num2=self.num2,self.num1+self.num2
            self.word_index+=1
            return num
        else:
            raise StopIteration
a=Fei(10)
for i in a:
    print(i,end=" ")            # 0 1 1 2 3 5 8 13 21 34

 

 

判斷是不是可迭代對象

#經過isinstance 判斷是不是可迭代對象
from collections import Iterable
def test(name,obj):
#返回布爾值 true 或 false
    flag = isinstance(obj,Iterable)# isinstance 接收兩個參數 第一個是你要判斷的對象 第二個是固定的 Iterable
    print("%s 是不是可迭代對象%s"%(name,flag))
test("字符串","hello")            # True
test("列表",[2,3,5,7,9])           # True
test("數字",10)                  # False
test("range",range(10))          # True

自定義迭代器

# 自定義可迭代對象
class Userlist(object):
    def __init__(self):
        self.list_item = []
    def append_item(self,name):
        self.list_item.append(name)
    def func(self):
        #獲取Userlist對象的迭代器
        user_iter = iter(user)
        print(next(user_iter))
        print(next(user_iter))
        print(next(user_iter))
        print(next(user_iter))
        print(next(user_iter))
    # 經過iter 方法返回一個迭代器
    def __iter__(self):
        stu = StuIterable(self.list_item)
        return stu # 返回迭代器
# 自定義迭代器
#一個實現了__iter__方法和__next__方法的對象，就是迭代器。
class StuIterable(object):
    def __init__(self,list_item):
        self.list_item = list_item
        self.current_index = 0    #定義變量，記錄下標位置
    #重寫next 方法返回數據
    def __next__(self):
        if self.current_index<len(self.list_item):
            self.current_index+=1
            return self.list_item[self.current_index-1]
     # 自己是一個迭代器 因此返回本身就好
    def __iter__(self):
        return self
#建立Userlist對象
user = Userlist()
user.append_item("小花")
user.append_item("小明")
user.append_item("小紅")
user.append_item("小麗")
user.append_item("小強")
user.func()

 

生成器：生成器是一個特殊的迭代器，內部封裝了__iter__()方法。在python中一邊循環一邊計算的機制稱爲生成器。好比：列表推導式、yield關鍵字

# 普通列表推導式
print([i*2 for i in range(10)])        # [0, 2, 4, 6, 8, 10, 12, 14, 16, 18]
# 將列表推導式中的方括號改爲小括號就是一個生成器
print((i*2 for i in range(10)))        # <generator object <genexpr> at 0x02D65B30>

# yield生成器實現斐波那契：       沒有yield 他就是個普通的函數，有了yield 就是一個生成器      
def fi(n):
    current_index=0
    num1 = 0
    num2 = 1
    while current_index<n:
        num = num1
        num1,num2 = num2,num1+num2
        print("=======1")
        yield num
        print("=======2")
    return "done"
f = fi(10)
print(next(f))
print(next(f))
print(next(f))

"""
=======1
0
=======2
=======1
1
=======2
=======1
1
"""

yield和return的區別：

yield至關於 return 返回一個值，而且記住這個返回的位置，下次迭代時，代碼從yield的下一條語句開始執行。

return會終止當前函數，且不會記住當前位置，下次執行依然從新開始

 

閉包：

首先必須是嵌套函數，外層函數返回內層函數，內層函數應用了外層函數的變量。閉包的應用通常能夠用做裝飾器。

def lazy_sum(*args):
    def sum():
        ax = 0
        for n in args:
            ax = ax + n
        return ax
    return sum        #將定義的函數sum()做爲結果值返回
f = lazy_sum(1, 3, 5, 7, 9)
print(f())          # 25

 

裝飾器：

在不改變被裝飾函數源代碼、被裝飾函數的調用方式的狀況下。爲被裝飾函數增長功能的函數，用@符調用。

 

搜索變量名的優先級：

# LEGB原則：
# 局部做用域local > 嵌套做用域enclosing > 全局做用域global > 內置做用域 built-in

 

函數：是指將一組語句的集合經過一個名字(函數名)封裝起來，要想執行這個函數，只需調用其函數名便可

python函數的三種傳參方式

# 位置參數（name）
def stu_register(name,age,course):
# 關鍵字參數（指定參數名能夠不按順序傳參）
stu_register(age=22,name='alex',course="python",)
# 非固定參數（*args必須放在**kwargs前面，*args接收列表類型參數，**kwargs接收字典類型參數）
def stu_register(name,age,*args,**kwargs):

python函數的四種類型

# 1. 無參數，無返回值
# 2. 無參數，有返回值
# 3. 有參數，無返回值
# 4. 有參數，有返回值

遞歸：函數在內部調用自身自己，這個函數就是遞歸函數。遞歸的最大層數是998，根據電腦性能CPU決定。

遞歸函數的優勢是定義簡單，邏輯清晰。理論上，全部的遞歸函數均可以寫成循環的方式，但循環的邏輯不如遞歸清晰。 缺點是過深的調用會致使棧溢出

# 遞歸實現斐波那契：
def gui(num):
    if num > 0:
        if num == 1:
            return 0
        elif num == 2:
            return 1
        else:
            return gui(num-1)+gui(num-2)
    else:
        return False
for i in range(1,11):
    print(gui(i),end=" ")           # 0 1 1 2 3 5 8 13 21 34

 

python四大高階函數

 

 lambda匿名函數

res = map(lambda x:x**2,[1,5,7,4,8])
for i in res:
    print(i)