Python_基礎

alogy發表於2019-02-16
Python

Run

原始碼

Python原始碼的檔案以”py”為副檔名，由Python程式解釋，不需要編譯

命令：python 檔案

位元組程式碼

Python原始檔經過編譯後生成的副檔名為”pyc”的檔案
編譯方法：

import py_compile
py_compile.compile("url") # url編譯的檔案的路徑

編譯後的檔案為：xxx.cpython-36.pyc

優化程式碼

經過優化的原始檔，副檔名為”.pyo”
命令：pyhont -O -m py_comile 編譯的檔案

編譯後的檔案為：xxx.cpython-36.opt-1.pyc

Type

int, float, str, bool, NoneType

tuple, list, dict, set

Lists

list = []
list[i:j]  # 返回列表的子集
list[-1]   # 訪問的最後一個元素
list[:-1]  # 只返回最後一個元素

list[i] = val
list[i:j] = otherlist  # replace ith to jth element with otherlist
del list[i:j]

list.append(item)
list.extend(list)
list.insert(0, item)
list.pop()
list.remove(i)
list1 + list2     # 結合兩個列表
set(list)         # 從列表中刪除重複元素

list.reverse()
list.count(item)
sum(list)

list.sort()

zip(list1, list2)
sorted(list)
",".join(list)

Dict

dict.keys()
dict.values()
"key" in dict
dict["key"]   # throws KeyError
dict.get("key")
dict.setdefault("key", 1)

Iteration

for item in ["a", "b", "c"]:
for i in range(4):     # 0 到 3
for i in range(4, 8):  # 4 到 7
for key, val in dict.items():

String

str[0:4]
len(str)

string.replace("-", " ")
",".join(list)
"hi {0}".format(`j`)
str.find(",")
str.index(",") 
str.count(",")
str.split(",")

str.lower()
str.upper()
str.title()

str.lstrip()
str.rstrip()
str.strip()

str.islower()

len() # 求序列長度
+ # 連線2個序列
* # 重複序列元素
in # 判斷元素是否在序列中
max() # 返回最大值
min() # 返回最小值

Set

集合Set於列表，元組類似，可以儲存多個資料，但是，這些資料是不重複的。

集合物件支援union(聯合), intersection(交集), difference(差集)和sysmmetric_difference(對稱差集)等數學運算

>>> x = set(`abcd`)
>>> x
{`c`, `a`, `b`, `d`}
>>> type(x)
<class `set`>
>>> y = set([`h`,`e`,`l`,`l`,`o`])
>>> y
{`h`, `e`, `o`, `l`}
>>> z = set(`spam`)
>>> z
{`s`, `a`, `m`, `p`}
>>> y&z # 交集
set()
>>> x&z # 交集
{`a`}
>>> x|y # 並集
{`a`, `e`, `d`, `l`, `c`, `h`, `o`, `b`}
>>> x-y # 差集
{`c`, `a`, `b`, `d`}
>>> x^z # 對稱差集(在x或z中，但不會同時出現在二者中)
{`m`, `d`, `s`, `c`, `b`, `p`}

Casting

int(str)
float(str)
str(int)
str(float)
bool(1)

Comprehensions

[fn(i) for i in list]            # .map
map(fn, list)                    # .map, 返回的迭代

filter(fn, list)                 # .filter, 返回的迭代
[fn(i) for i in list if i > 0]   # .filter.map

Regex

import re

re.match(r`^[aeiou]`, str)
re.sub(r`^[aeiou]`, `?`, str)
re.sub(r`(xyz)`, r`1`, str)

expr = re.compile(r`^...$`)
expr.match(...)
expr.sub(...)

Function

定義函式

使用關鍵字:def。 依次寫出函式名, 括號, 引數, 語句結束符 :。然後，在縮排塊中編寫函式體，函式的返回值用return語句返回

def my_abs (x):
    if x >= 0:
        return x
    else:
        return -x

空函式

定義一個什麼也不做的空函式，使用pass語句

def nop ()
    pass

空函式的作用：提供佔位符

引數

預設引數一定要用不可變物件(基本變數型別和tuple), 如果是可變物件，程式執行時會有邏輯錯誤。

定義可變引數和關鍵字引數的使用：

  • *args是可變引數，args接收的是一個tuple
  • **kw是關鍵字引數，kw接收的是一個dict

呼叫函式時如何傳入可變引數和關鍵字引數：

  • 可變引數既可以直接傳入：func(1, 2, 3)，又可以先組裝list或tuple，再通過*args傳入：func(*(1, 2, 3))；
  • 關鍵字引數既可以直接傳入：func(a=1, b=2)，又可以先組裝dict，再通過**kw傳入：func(**{`a`: 1, `b`: 2})。

使用*args和**kw是Python的習慣寫法，當然也可以用其他引數名，但最好使用習慣用法。

命名的關鍵字引數作用：為了限制呼叫者可以傳入的引數名，同時可以提供預設值。

定義命名的關鍵字引數在沒有可變引數的情況下不要忘了寫分隔符*，否則定義的將是位置引數

返回值

函式執行完畢也沒有return語句時，自動return None
函式可以同時返回多個值，但其實就是一個tuple

匿名函式

lamdba 引數:函式體

匿名函式自動具有返回值

Characteristic

  1. 區分大小寫
  2. 語句結尾使用:
  3. Tab符

if的各種假

Flase: ``, None, 0, -0.0, 0.0 [], {}, (), Flase

==與is

is是比較兩個引用是否指向了同一個物件(引用比較)
==是比較兩個物件是否相等

a = 2
b = 2

a is b # True, 為True的原因是[-5, 256]

c = 500
d = 500
c is d # False

python直譯器為了優化速度，會把[-5, 256]之間的資料提前存放到小整數物件池中，程式中要使用到[-5, 256]之間範圍的資料，就不會重新建立一份，都是指向物件池中的同一份資料，除了這個區間之外的資料，每次使用時直譯器都會重新申請一塊記憶體，用來儲存資料。

深拷貝和淺拷貝

淺拷貝：對於一個物件的頂層拷貝(拷貝了引用，並沒有拷貝內容)
深拷貝：重新申請記憶體儲存複製的資料.

import copy
a = [1, 2, 3]

b = a # 淺拷貝
c = copy.deepcopy(a) # 深拷貝

區別copy和deepcopy:
deepcopy：所有的內容都重新申請記憶體，依次拷貝
copy: 外層重新申請記憶體

拷貝元組的特點：
都是相同引用地址(元組是不可變型別,拷貝之後還是相同地址)

相關文章