• 編程是一種技能和工具，是理解計算機的有效途徑，是一種新的思考方式。

特點

• 語法簡潔
• 類庫豐富
• 跨平臺
• 可拓展
• 開源

歷史

• 1990，誕生
• 2000，2.0發(fā)布
• 2008，3.0發(fā)布
• 2010，2的最后一個版本2.7

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

1. 整型：int 8
2. 浮點型：float 8.5
3. 字符：str "6"
4. 布爾型：bool true false

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

• type()：查看數(shù)據(jù)類型
• 相同數(shù)據(jù)類型的數(shù)據(jù)才可以一起操作，例："6"必須先轉(zhuǎn)換成整型或浮點型才可以進行計算

序列

定義

它的成員都是有序排列，并且可以通過下標偏移量訪問它的成員。

范圍

1. 字符串 "abc"
2. 列表 [4,6,7] 成員可以變更
3. 元組 ("234", "hi") 成員不可變更

序列基本操作

• 成員關系操作符：對象(in, not in)序列
• 連接操作符：序列 + 序列
• 重復操作符：序列 * 整數(shù)
• 切片操作符：序列[開始下標:結(jié)束下標]

# 下標從0開始，包含開頭，不包含結(jié)尾
# 格式：序列[開始下標:結(jié)束下標]

a = [4,6,7]
a[1]  # 結(jié)果為：6
a[1:2]  # 結(jié)果為：[6]

列表基本操作

• 添加元素，添加到最后面
  list.append("x")
• 刪除元素，刪除最前面的一個元素
  list.remove("x")

字典{}

• 以鍵值對的形式出現(xiàn)，key會被進行hash運算存起來所以key不能重復，
• 類型int float string tuple都可以進行hash運算可以作為key。
• 查詢使用 get，如果查詢的值不存在，我們也可以給一個默認值，比如 score.get(‘yase’,99)。

集合{}

• 集合（set）是一個無序的不重復元素序列。
• 可以使用大括號 { } 或者 set() 函數(shù)創(chuàng)建集合，注意：創(chuàng)建一個空集合必須用 set() 而不是 { }，因為 { } 是用來創(chuàng)建一個空字典。
• s = set(['a', 'b', 'c'])

條件語句if

if 條件:
  執(zhí)行語句
elif 條件:
  執(zhí)行語句
else:
  執(zhí)行語句

循環(huán)語句while

while 條件:
  執(zhí)行語句

循環(huán)語句for

for 迭代變量 in 可迭代對象:
  執(zhí)行語句

映射類型：字典{}

• 以鍵值對的形式出現(xiàn)

文件操作

錯誤≠異常

迭代器

• 迭代是Python最強大的功能之一，是訪問集合元素的一種方式。
• 迭代器是一個可以記住遍歷的位置的對象。
• 迭代器對象從集合的第一個元素開始訪問，直到所有的元素被訪問完結(jié)束。迭代器只能往前不會后退。
• 迭代器有兩個基本的方法：iter() 和 next()。
• 字符串，列表或元組對象都可用于創(chuàng)建迭代器：

生成器

• 跟普通函數(shù)不同的是，生成器是一個返回迭代器的函數(shù)，只能用于迭代操作，更簡單點理解生成器就是一個迭代器。
• 在調(diào)用生成器運行的過程中，每次遇到 yield 時函數(shù)會暫停并保存當前所有的運行信息，返回 yield 的值, 并在下一次執(zhí)行 next() 方法時從當前位置繼續(xù)運行。
  調(diào)用一個生成器函數(shù)，返回的是一個迭代器對象。
  在 Python 中，使用了 yield 的函數(shù)被稱為生成器（generator）。

a,b=b,a+b 和 a=b b=a+b 的區(qū)別

a,b=0,1
a, b = b, a+b
# 這種賦值，先計算等值 右邊 就是 b=1 a+b=1
# 再賦值給a和b，那么 a=1, b=1
#然后就是依次這樣

a = b
# 此時 b=1, 那么a=1
b = a+b
# 那么 b=2

匿名函數(shù)lambda

• lambda 只是一個表達式，函數(shù)體比 def 簡單很多。
• lambda的主體是一個表達式，而不是一個代碼塊。僅僅能在lambda表達式中封裝有限的邏輯進去。
• lambda 函數(shù)擁有自己的命名空間，且不能訪問自己參數(shù)列表之外或全局命名空間里的參數(shù)。
• 雖然lambda函數(shù)看起來只能寫一行，卻不等同于C或C++的內(nèi)聯(lián)函數(shù)，后者的目的是調(diào)用小函數(shù)時不占用棧內(nèi)存從而增加運行效率。

一個語法

• lambda的語法是唯一的

 lambda argument_list: expression

三個特性

1. lambda函數(shù)是匿名的：所謂匿名函數(shù)，通俗地說就是沒有名字的函數(shù)。lambda函數(shù)沒有名字。
2. lambda函數(shù)有輸入和輸出：輸入是傳入到參數(shù)列表argument_list的值，輸出是根據(jù)表達式expression計算得到的值。
3. lambda函數(shù)一般功能簡單：單行expression決定了lambda函數(shù)不可能完成復雜的邏輯，只能完成非常簡單的功能。由于其實現(xiàn)的功能一目了然，甚至不需要專門的名字來說明。

四個用法

1. 將lambda函數(shù)賦值給一個變量，通過這個變量間接調(diào)用該lambda函數(shù)。
2. 將lambda函數(shù)賦值給其他函數(shù)，從而將其他函數(shù)用該lambda函數(shù)替換。
3. 將lambda函數(shù)作為其他函數(shù)的返回值，返回給調(diào)用者。
4. 將lambda函數(shù)作為參數(shù)傳遞給其他函數(shù)。

一個爭議

• 關于lambda在Python社區(qū)是存在爭議的
• 支持方認為使用lambda編寫的代碼更緊湊，更“pythonic”。
• 反對方認為，lambda函數(shù)能夠支持的功能十分有限，其不支持多分支程序if...elif...else...和異常處理程序try ...except...。并且，lambda函數(shù)的功能被隱藏，對于編寫代碼之外的人員來說，理解lambda代碼需要耗費一定的理解成本。他們認為，使用for循環(huán)等來替代lambda是一種更加直白的編碼風格。

內(nèi)建函數(shù)

filter()

• filter() 函數(shù)用于過濾序列，過濾掉不符合條件的元素，返回一個迭代器對象，如果要轉(zhuǎn)換為列表，可以使用 list() 來轉(zhuǎn)換。
• 該接收兩個參數(shù)，第一個為函數(shù)，第二個為序列，序列的每個元素作為參數(shù)傳遞給函數(shù)進行判，然后返回 True 或 False，最后將返回 True 的元素放到新列表中。

filter(function, iterable)
# function -- 判斷函數(shù)。
# iterable -- 可迭代對象。
# 返回一個迭代器對象

def is_odd(n):
    return n % 2 == 1
 
tmplist = filter(is_odd, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
newlist = list(tmplist)
print(newlist)
# 結(jié)果為：[1, 3, 5, 7, 9]

map()

• map() 會根據(jù)提供的函數(shù)對指定序列做映射。
• 第一個參數(shù) function 以參數(shù)序列中的每一個元素調(diào)用 function 函數(shù)，返回包含每次 function 函數(shù)返回值的新列表。

map(function, iterable, ...)
# function -- 函數(shù)
# iterable -- 一個或多個序列
# Python 2.x 返回列表。
# Python 3.x 返回迭代器。

# 使用 lambda 匿名函數(shù)
map(lambda x: x ** 2, [1, 2, 3, 4, 5])  
# [1, 4, 9, 16, 25]
# 提供了兩個列表，對相同位置的列表數(shù)據(jù)進行相加
map(lambda x, y: x + y, [1, 3, 5, 7, 9], [2, 4, 6, 8, 10])
# [3, 7, 11, 15, 19]

reduce()

• reduce() 函數(shù)會對參數(shù)序列中元素進行累積。
• 函數(shù)將一個數(shù)據(jù)集合（鏈表，元組等）中的所有數(shù)據(jù)進行下列操作：用傳給 reduce 中的函數(shù) function（有兩個參數(shù)）先對集合中的第 1、2 個元素進行操作，得到的結(jié)果再與第三個數(shù)據(jù)用 function 函數(shù)運算，最后得到一個結(jié)果。
• 在 Python3 中，reduce() 函數(shù)已經(jīng)被從全局名字空間里移除了，它現(xiàn)在被放置在 functools 模塊里，如果想要使用它，則需要通過引入 functools 模塊來調(diào)用 reduce() 函數(shù)：

reduce(function, iterable[, initializer])
# function -- 函數(shù)，有兩個參數(shù)
# iterable -- 可迭代對象
# initializer -- 可選，初始參數(shù)

from functools import reduce
def add(x,y):
    return x + y
print (reduce(add, range(1, 3)), 4)
# 10

zip()

• zip() 函數(shù)用于將可迭代的對象作為參數(shù)，將對象中對應的元素打包成一個個元組，然后返回由這些元組組成的對象，這樣做的好處是節(jié)約了不少的內(nèi)存。
• 我們可以使用 list() 轉(zhuǎn)換來輸出列表。
• 如果各個迭代器的元素個數(shù)不一致，則返回列表長度與最短的對象相同，利用 * 號操作符，可以將元組解壓為列表。

zip([iterable, ...])
# iterabl -- 一個或多個迭代器;
# python3返回的是對象，python2返回的是列表

z = zip([1,2,3],[4,5,6])
print(list(z))
# [(1, 4), (2, 5), (3, 6)]

閉包

• 形成閉包的條件

1. 必須要有一個內(nèi)嵌函數(shù)
2. 內(nèi)嵌函數(shù)中要對自由變量的引用
3. 外部函數(shù)必須返回內(nèi)嵌函數(shù)

# a * x + b = y
def line(a,b):
    def arg_x(x):
        return a * x + b
    return arg_x

a_line = line(2,5)
print(a_line(1))
# 7

裝飾器

• 從字面上理解，就是裝飾對象的器件。可以在不修改原有代碼的情況下，為被裝飾的對象增加新的功能或者附加限制條件或者幫助輸出。裝飾器有很多種，有函數(shù)的裝飾器，也有類的裝飾器。裝飾器在很多語言中的名字也不盡相同，它體現(xiàn)的是設計模式中的裝飾模式，強調(diào)的是開放封閉原則。裝飾器的語法是將@裝飾器名，放在被裝飾對象上面。

import time

def timer(func):
    def wrapper():
        start_time  = time.time()
        func()
        stop_time  = time.time()
        print(stop_time-start_time)
    return wrapper
# 裝飾器
@timer 
def i_can_sleep():
    time.sleep(2)

i_can_sleep()

函數(shù)的基本概念

• 函數(shù)名：foo、outer、inner
• 函數(shù)體：函數(shù)的整個代碼結(jié)構(gòu)
• 返回值：return后面的表達式
• 函數(shù)的內(nèi)存地址：id(foo)、id(outer)等
• 函數(shù)名加括號：對函數(shù)進行調(diào)用，如foo()、outer(foo)
• 函數(shù)名作為參數(shù)：outer(foo)中foo本身是一個函數(shù)，但作為參數(shù)傳遞給了outer函數(shù)
• 函數(shù)名加括號作為參數(shù)：先調(diào)用函數(shù)，再將它的返回值當做別的函數(shù)的參數(shù)，例如outer(foo())
• 返回函數(shù)名：return inner
• 返回函數(shù)名加括號：return inner()，其實就是先執(zhí)行inner()函數(shù)，再將其返回值作為別的函數(shù)的返回值。

上下文管理器

• 用于規(guī)定某個對象的使用范圍。一旦進入或者離開該使用范圍，會有特殊操作被調(diào)用 (比如為對象分配或者釋放內(nèi)存)。它的語法形式是with...as...
• 上下文管理器協(xié)議：是指類需要實現(xiàn) __ enter __ 和 __ exit __ 方法。
• 就跟迭代器有迭代器協(xié)議一樣，迭代器協(xié)議需要實現(xiàn) __ iter __ 和 __ next __ 方法。
• 上下文管理器，也就是支持上下文管理協(xié)議的對象，簡單點講就是，實現(xiàn)了 __ enter __ 和 __ exit __兩個方法的類。這個類也叫做，上下文管理器的類。

class Resource():
    def __enter__(self):
        print('===connect to resource===')
        return self
    def __exit__(self, exc_type, exc_val, exc_tb):
        print('===close resource connection===')
        
    def operate(self):
        print('===in operation===')
        
with Resource() as res:
    res.operate()

輸出：
===connect to resource===
===in operation===
===close resource connection===

面向?qū)ο?/h4>

• 類(Class): 用來描述具有相同的屬性和方法的對象的集合。它定義了該集合中每個對象所共有的屬性和方法。對象是類的實例。

• 方法：類中定義的函數(shù)。

• 類變量：類變量在整個實例化的對象中是公用的。類變量定義在類中且在函數(shù)體之外。類變量通常不作為實例變量使用。

• 數(shù)據(jù)成員：類變量或者實例變量用于處理類及其實例對象的相關的數(shù)據(jù)。

• 方法重寫：如果從父類繼承的方法不能滿足子類的需求，可以對其進行改寫，這個過程叫方法的覆蓋（override），也稱為方法的重寫。

• 局部變量：定義在方法中的變量，只作用于當前實例的類。

• 實例變量：在類的聲明中，屬性是用變量來表示的，這種變量就稱為實例變量，實例變量就是一個用 self 修飾的變量。

• 繼承：即一個派生類（derived class）繼承基類（base class）的字段和方法。繼承也允許把一個派生類的對象作為一個基類對象對待。例如，有這樣一個設計：一個Dog類型的對象派生自Animal類，這是模擬"是一個（is-a）"關系（例圖，Dog是一個Animal）。

• 實例化：創(chuàng)建一個類的實例，類的具體對象。

• 對象：通過類定義的數(shù)據(jù)結(jié)構(gòu)實例。對象包括兩個數(shù)據(jù)成員（類變量和實例變量）和方法。

• 兩個下劃線“__”開頭的屬性和方法是私有的

• __init__ 是 構(gòu)造方法

繼承

• 子類繼承父類的屬性和方法，可以繼承多個，當多個父類有相同方法時，默認從左向右取第一個父類的方法

class Test:
    def prt(self):
        print(1)


class Test2:
    def prt(self):
        print(2)


class Test3(Test, Test2):
    def __init__(self):
        print(3)


t = Test3()
t.prt()

# 3  1

多線程

• 每個獨立的線程有一個程序運行的入口、順序執(zhí)行序列和程序的出口。但是線程不能夠獨立執(zhí)行，必須依存在應用程序中，由應用程序提供多個線程執(zhí)行控制。
• 每個線程都有他自己的一組CPU寄存器，稱為線程的上下文，該上下文反映了線程上次運行該線程的CPU寄存器的狀態(tài)。
• 指令指針和堆棧指針寄存器是線程上下文中兩個最重要的寄存器，線程總是在進程得到上下文中運行的，這些地址都用于標志擁有線程的進程地址空間中的內(nèi)存。

import threading
import time
from threading import current_thread


def my_thread(arg1, arg2):
    print(current_thread().getName(), "start")
    print("%s %s" % (arg1, arg2))
    time.sleep(2)
    print(current_thread().getName(), "stop")


for i in range(1,6,1):
    t1 = threading.Thread(target=my_thread, args=(i, i+1))
    t1.start()


print(current_thread().getName(), "end")

Thread-1 start
# 1 2
# Thread-2 start
# 2 3
# Thread-3 start
# 3 4
# Thread-4 start
# 4 5
# Thread-5 start
# MainThread end
# 5 6
# Thread-4 stop
# Thread-3 stop
# Thread-1 stop
# Thread-2 stop
# Thread-5 stop

正則表達式

• 正則前面加上 r 表示規(guī)則不被轉(zhuǎn)譯
• re.compile() 設置匹配規(guī)則
• re.match()是從開頭開始匹配，開頭不符合直接返回None
• re.search()是匹配整個字符串，有一個符合的就返回，沒有一個符合的返回None
• re.findall()是匹配整個字符串，返回所有符合的字符串組成的列表
• re.sub()是替換字符串

Python是如何進行內(nèi)存管理的

1. 對象的引用計數(shù)機制

• Python內(nèi)部使用引用計數(shù)，來保持追蹤內(nèi)存中的對象，所有對象都有引用計數(shù)。
  引用計數(shù)增加的情況：
• 一個對象分配一個新名稱
• 將其放入一個容器中（如列表、元組或字典）
  引用計數(shù)減少的情況：
• 使用del語句對對象別名顯示的銷毀
• 引用超出作用域或被重新賦值

2. 垃圾回收
   當一個對象的引用計數(shù)歸零時，它將被垃圾收集機制處理掉。

3. 內(nèi)存池機制

• Python提供了對內(nèi)存的垃圾收集機制，但是它將不用的內(nèi)存放到內(nèi)存池而不是返回給操作系統(tǒng):
• Pymalloc機制：為了加速Python的執(zhí)行效率，Python引入了一個內(nèi)存池機制，用于管理對小塊內(nèi)存的申請和釋放。
• 對于Python對象，如整數(shù)，浮點數(shù)和List，都有其獨立的私有內(nèi)存池，對象間不共享他們的內(nèi)存池。也就是說如果你分配又釋放了大量的整數(shù)，用于緩存這些整數(shù)的內(nèi)存就不能再分配給浮點數(shù)。

Numpy

• NumPy 數(shù)組存儲在一個均勻連續(xù)的內(nèi)存塊中，不需要對內(nèi)存地址進行查找；而列表 list 的元素在系統(tǒng)內(nèi)存中是分散存儲的，需要對內(nèi)存地址進行查找。
• 在內(nèi)存訪問模式中，緩存會直接把字節(jié)塊從 RAM 加載到 CPU 寄存器中。因為數(shù)據(jù)連續(xù)的存儲在內(nèi)存中，NumPy 直接利用現(xiàn)代 CPU 的矢量化指令計算，加載寄存器中的多個連續(xù)浮點數(shù)。
• NumPy 中的矩陣計算可以采用多線程的方式，充分利用多核 CPU 計算資源，大大提升了計算效率。
• 提升內(nèi)存和提高計算資源的利用率：避免采用隱式拷貝，而是采用就地操作的方式。