Python基礎

python屬於解釋性的高級語言

6個標準數據類型

1、Numbers（數字）

int：整數 eg：1，2，-3，4，……

float：小數 eg：0.1，1.0，……

2、String（字符串）

用雙引號、單引號、三引號界定。三引號界定可以跨行，一般用於説明註釋
eg：'a','"python"',"基礎"

3、List（列表）

列表由方括號界定，元素間用逗號分隔
eg：[0,'python','入門',['p','y','t']] 、 [1]

4、Tuple（元組）

元組由圓括號界定，元素間用逗號分隔，當只有一個元素時元素後逗號必須加上。
eg：(1,) 、(1,2,3)

5、Dictionary（字典）

字典由大括號界定，元素是鍵值對形式，逗號分隔.
eg:{'ID':'9527','name':'華安'}

6、Set（集合）(由於之前接觸較少，就稍微寫多了一點筆記)

與數學上的集合一樣，集合內每一個值都是唯一的。
eg：{1, 2, 3, 4, 5}

6.1集合的操作

6.1.1集合添加

　　集合的添加有兩種方式，分別是add和update。但是它們在添加元素時是由區別的：

add()方法

把要傳入的元素作為一個整體添加到集合中，如：

>>> s=set('one')
>>> s
{'e', 'o', 'n'}
>>> s.add('two')
>>> s
{'e', 'two', 'o', 'n'}

update()方法

是把要傳入的元素拆分成單個字符，存於集合中，並去掉重複的字符。可以一次添加多個值，如：

>>> s=set('one')
>>> s
{'e', 'o', 'n'}
>>> s.update('two')
>>> s
{'e', 'n', 't', 'w', 'o'}

6.1.2集合刪除

　　集合的刪除操作使用的方法跟列表是一樣的，使用的也是remove方法。如：

setVar.remove(element)

setVar :為一個set類型的變量
element :表示要查找並刪除的元素
函數作用：
在集合setVar中查找element元素，如果存在則刪除；如果沒找到，則報錯。

>>> s=set('one')
>>> s
{'e', 'o', 'n'}
>>> s.remove('e')
>>> s
{'n', 'o'}

setVar.discard(element)

setVar :為一個set類型的變量
element :表示要查找並刪除的元素
函數作用：
在集合setVar中查找element元素，如果存在則刪除；如果沒找到，則什麼也不做。

>>> sList
set([1, 2, 3, 4, 5])
>>> sList.discard(1)
>>> sList
set([2, 3, 4, 5])

s.pop()

s：為set類型的變量
函數作用：
刪除並返回set類型的s中的一個不確定的元素，如果為空引發KeyError錯誤。

>>> sList
set([2, 3, 4, 5])
>>> sList.pop()
2

s.clear()

s：set類型的變量
函數作用：
清空s集合中的所有元素

>>> sList
set([3, 4, 5])
>>> sList.clear()
>>> sList
set([])

6.1.3集合的遍歷

集合的遍歷跟序列的遍歷方法完全一樣。

>>> s=set('one')
>>> s
{'e', 'o', 'n'}
>>> for i in s:
    print(i)
... ... 
e
o
n
>>> 
另一種遍歷方式：

>>> s=set('one')
>>> s
{'e', 'o', 'n'}
>>> for idex,i in enumerate(s):
        print (idex,i)
... ... 
0 e
1 o
2 n
>>> 
變量idex表示集合中元素i的索引。

6.1.4集合其他方法

6.1.5集合的一些操作符

　　既然是集合，那就會遵循集合的一些操作方法，如求交集、並集、差集等。

交集

　　Python中求集合的交集使用的符號是“&”，返回連個集合的共同元素的集合，即集合的交集。

>>> st1 = set('python')
>>> st1
set(['h', 'o', 'n', 'p', 't', 'y'])
>>> st2 = set('htc')
>>> st2
set(['h', 'c', 't'])
>>> st1 & st2
set(['h', 't'])

並集（合集）

　　Python中求集合的並集用的是符號“|”，返回的是兩個集合所有的並去掉重複的元素的集合。

>>> st1
set(['h', 'o', 'n', 'p', 't', 'y'])
>>> st3 = set('two')
>>> st3
set(['o', 't', 'w'])
>>> st1 | st3
set(['p', 't', 'w', 'y', 'h', 'o', 'n'])

差集

　　Python中差集使用的符號是減號“-”。

>>> st1
set(['1', '3', '2', '5', '4', '7', '6'])
>>> st2 = set('4589')
>>> st2
set(['9', '8', '5', '4'])
>>> st1 - st2
set(['1', '3', '2', '7', '6'])

　　返回的結果是在集合st1中但不在集合st2中的元素的集合。

6.1.6集合的不同

　　查看兩個集合的不同之處，使用的difference函數，等價於差集。如：
s1.difference(s3)
　　這種不同指的是集合s3相對於集合s1，不同的地方，也就是所有在集合s1中，而不再集合s2中的的元素組成的新集合。

>>> s1
set([1, 2, 3, 4, 5])
>>> s2
set([1, 2, 3, 4])
>>> s1.difference(s2)
set([5])
>>> s3
set(['1', '8', '9', '5'])
>>> s1.difference(s3)
set([1, 2, 3, 4, 5])

6.1.7集合的範圍判斷

　　集合可以使用大於（>）、小於（<）、大於等於（>=）、小於等於（<=）、等於（==）、不等於（！=）來判斷某個集合是否完全包含於另一個集合，也可以使用子父集判斷函數。

　定義三個集合s1，s2，s3：

>>> s1＝set([1, 2, 3, 4, 5])
>>> s2＝set([1, 2, 3, 4])
>>> s3＝set(['1', '8', '9', '5'])
大於（>）或大於等於（>=）

>>> s1 > s2
True
>>> s1 > s3
False
>>> s1 >= s2
True
　　表示左邊集合是否完全包含右邊集合，如集合s1是否完全包含集合s2。

小於（<）或 小於等於（<=）

>>> s2 < s1
True
>>> s1 < s3
False
>>> s3 < s1
False
　　表示左邊的集合是否完全包含於右邊的集合，如集合s1是否完全包含於集合s2。

等於（==）、不等於（！=）

>>> s1 == s2
False
>>> s2 == s3
False
>>> s1 != s2
True
　　判斷兩個集合是否完全相同。

6.2不可變集合frozenset

　　Python中還有一種不可改變的集合，那就是frozenset，不像set集合，可以增加刪除集合中的元素，該集合中的內容是不可改變的，類似於字符串、元組。

>>> f = frozenset()
>>> f
frozenset([])
>>> f = frozenset('asdf')
>>> f
frozenset(['a', 's', 'd', 'f'])
>>> f = frozenset([1,2,3,4])
>>> f
frozenset([1, 2, 3, 4])
>>> f = frozenset((1,2,3,4))
>>> f
frozenset([1, 2, 3, 4])
>>> f = frozenset({1:2, 'a':2, 'c':3})
>>> f
frozenset(['a', 1, 'c'])

7.數據類型彙總

list、tuple、dict,set 這四種數據類型的元素可以是任意類型
有序序列：list、tuple、string，可以用索引
不可變類型：Numbers、String、tuple
set雖然是可變類型，但是不能更改set中不可變類型數據

循環

for

while

條件語句

==：恆等

!=：不等於

'>' :大於

‘<’ ：小於

'>=' ：大於等於

'<='：小於等於

not ：非

and ：與

or ：或

文件I/O

權限：r、w、a

open()：操作文件

異常

try：執行正常代碼

except：發生異常，執行此處代碼

else：（可不加），無異常，則執行此處代碼

導包

import…… 導入

from……import…… 從……導入

面向過程編程

定義方法：

def  func_name()：
    return                 # 可省略

​

面向對象編程

兩個概念：class（類）和 Instance（實例）

可以繼承多個基類

線程跟進程

進程間變量獨立互不影響。一個進程中的多個線程共用一套變量，因此需要引入線程鎖機制（Lock），保證線程間在操作過程中，不能同時對同一變量進行操作。

進程

進程池（Pool）

進程池默認參數是CPU核數

import random
import time
from multiprocessing import Pool


def random_time_task(name):
    print(f'執行任務-{name}')
    start_time = time.time()
    time.sleep(random.random() * 5)
    end_time = time.time()
    print(f'任務-{name} 執行時間：{end_time - start_time}')


if __name__ == '__main__':
    pool = Pool(4)
    for i in range(6):
        pool.map_async(random_time_task, (i,))

    pool.close()
    pool.join()
    print('所有進程完成')

線程

開啓一個新線程並返回其標識。 線程執行函數 function 並附帶參數列表 args (必須是元組)。 可選的 kwargs 參數指定一個關鍵字參數字典。

import random
import threading
import time

ls = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20]
balance = 10
lock = threading.Lock()


def operation2balance(money):
    global ls
    global balance
    ls.append(30)
    balance = balance + money
    balance = balance - money
    time.sleep(random.random())
    ls.remove(30)
    print(len(ls))


def new_thread(n):
    for i in range(20):
        # operation2balance(n)  # 驗證沒有加鎖兩個線程同時訪問一個變量的情況
        # 操作前先獲得鎖
        lock.acquire()
        try:
            operation2balance(n)
        finally:
            # 操作後釋放鎖
            lock.release()


if __name__ == '__main__':
    t1 = threading.Thread(target=new_thread, args=(29,))
    t2 = threading.Thread(target=new_thread, args=(18,))
    t1.start()
    t2.start()
    t1.join()
    t2.join()
    print(balance)

_thread

_thread.start_new_thread(function,args[kwargs])

# 新建線程並運行