Python 基礎(chǔ)

僅供個人學(xué)習(xí)
來源于 莫凡Python：https://mofanpy.com/tutorials/python-basic/basic/ 侵刪

基本使用

print 功能

>>> print(1)
1
>>> print("we're going to do something")
we're going to do something
>>> print('apple' + 'car')
applecar
>>> print('apple' + str(4))
apple4
>>> print(1+2)
3
>>> print(int('1') + 2)
3
>>> print(float('1.2') + 2)
3.2

基本數(shù)學(xué)運算

• 加減乘除
• ^ 與 **
  • python用**代表平方
• 取余數(shù) %
  • 余數(shù)取整 //

變量variable

>>> a, b, c = 1, 2, 3

while 和 for 循環(huán)

while 循環(huán)

condition = 1
while condition < 10:
    print(condition)
    condition = condition + 1

# 死循環(huán) Ctrl + C 終止程序
while True:
    print(condition)

for 循環(huán)

# 輸出1-9
for i in range(1, 10):
    print(i)

range(start, stop, step)

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

• list

  列表 list = [1, 2, 3]

• tuple

  元組 tup = ('python', 1.7, 64)

• dict

  dictionary 字典 迭代過程中將key作為迭代的對象返回从撼。字典中的key是亂序的。

  順序一致的字典：collections模塊中的OrderedDict對象

  dic{}
  dic['lan'] = 'python'
  dic['version'] = 3.7
  dic['platform'] = 64
  for key in dic:
      print(key, dic[key])
  

• set

  set 集合會去除重復(fù)項拘悦，輸出結(jié)果不是按照輸入的順序邻吞。

  s = set(['python', 'python2', 'python3','python'])

if 判斷語句

if 判斷

if x==y:
    print('x is equal to y')
# 判斷相等用==组题，賦值用=

if else 判斷

if condition:
    true
else:
    false

python 中沒有 ? : : 三目表達(dá)式〕孕疲可通過 if-else的行內(nèi)表達(dá)式完成類似的功能往踢。

var = var1 if condition else var2

如果 condition 的值為 True, 那么將 var1 的值賦給 var;如果為 False 則將 var2 的值賦給 var

if elif else 判斷

if condition1:
    true1_expressions
elif condition2:
    true2_expressions
elif condtion3:
    true3_expressions
elif ...
    ...
else:
    else_expressions

函數(shù)

def函數(shù)

def function():
    a = 1
    return a

函數(shù)參數(shù)

def function(a, b):
    c = a + b
    return c
print(function(1, 2))

默認(rèn)參數(shù)

def function(a = 1, b)  # 錯誤寫法
def function(b, a = 1)  # 正確寫法
# 在需要默認(rèn)參數(shù)的地方用 `=` 號給定即可
# 注意所有的默認(rèn)參數(shù)都不能出現(xiàn)在非默認(rèn)函數(shù)的前面

可變參數(shù)

def report(name, *grades):
    total_grade = 0
    for grade in grades:
        total_grade += grade
    return total_grade

可將參數(shù)封裝成一個list或tuple傳入

這里使用可變參數(shù)用*號修飾，可變參數(shù)不能出現(xiàn)在特定參數(shù)和默認(rèn)參數(shù)前面徘层，因為可變參數(shù)會吞噬掉這些參數(shù)峻呕。

關(guān)鍵字參數(shù)

def func(name, **kw):
    print('name is', name)
    for k,v in kw.items(): 
        print(k, v)
func('Mike', age=24, country='China', education='bachelor')
# 這些參數(shù)在函數(shù)內(nèi)部自動封裝成一個字典(dict)

全局 & 局部 變量

模塊安裝

安裝：pip install numpy

更新：pip install -U numpy

讀寫文件

換行

\n

open 讀文件方式

myFile = open('file.txt', 'w')  # w寫，r讀趣效，a追加
myFile.write(text)              # 將text寫入文件
myFile.close()                  # 關(guān)閉文件

tab 對齊

\t 達(dá)到tab對齊效果

讀文件

file.read()

讀取文本的所有內(nèi)容

file.readline()

讀取一行

file.readlines()

讀取所有行瘦癌，返回list

Class 類

Class類

class Calculator:       #首字母要大寫，冒號不能缺
    name='Good Calculator'  #該行為class的屬性
    price=18
    def add(self,x,y):      # self為默認(rèn)值
        print(self.name)
        result = x + y
        print(result)
    def minus(self,x,y):
        result=x-y
        print(result)
    def times(self,x,y):
        print(x*y)
    def divide(self,x,y):
        print(x/y)

""""
>>> cal=Calculator()  #注意這里運行class的時候要加"()",否則調(diào)用下面函數(shù)的時候會出現(xiàn)錯誤,導(dǎo)致無法調(diào)用.
>>> cal.name
'Good Calculator'
>>> cal.price
18
>>> cal.add(10,20)
Good Calculator
30
>>> cal.minus(10,20)
-10
>>> cal.times(10,20)
200
>>> cal.divide(10,20)
0.5
>>>
""""

class 類 init 功能

__init__可以理解成初始化class的變量跷敬，取自英文中initial 最初的意思.可以在運行時讯私，給初始值附值，

運行c=Calculator('bad calculator',18,17,16,15),然后調(diào)出每個初始值的值西傀〗锟埽看如下代碼。

這里的下劃線是雙下劃線

class Calculator:
    name='good calculator'
    price=18
    def __init__(self,name,price,height,width,weight):   # 注意拥褂，這里的下劃線是雙下劃線
        self.name=name
        self.price=price
        self.h=height
        self.wi=width
        self.we=weight
""""
>>> c=Calculator('bad calculator',18,17,16,15)
>>> c.name
'bad calculator'
>>> c.price
18
>>> c.h
17
>>> c.wi
16
>>> c.we
15
>>>
""""

input 輸入

input()

score = int(input('please input your scor:\n'))

元組, 列表, 字典

元組娘锁、列表

Tuple

用小括號、或無括號來表述饺鹃，是一連串有順序的數(shù)字

Tuple定義后不可變莫秆，可嵌套

a_tuple = (1, 2, 3)
b_tuple = 1, 2, 3

List

同Tuple，但List是以中括號命名

可變悔详，可嵌套

a_list = [1, 2, 3]
a_list.append(0) # 最后面追加
a_list.insert(1, 0) # 在位置1處追加0
a_list.remove(2) # 刪除列表中第一個出現(xiàn)值為2的項
print(a[0])  # 顯示列表a的第0位的值
print(a[-1]) # 顯示列表a的最末位的值
print(a[0:3]) # 顯示列表a的從第0位 到 第2位(第3位之前) 的所有項的值
print(a[5:])  # 顯示列表a的第5位及以后的所有項的值
print(a[-3:]) # 顯示列表a的倒數(shù)第3位及以后的所有項的值
print(a.index(2)) # 顯示列表a中第一次出現(xiàn)的值為2的項的索引
a.count(-1) # 統(tǒng)計列表中某值出現(xiàn)的次數(shù)
a.sort() # 默認(rèn)從小到大排序
a.sort(reverse=True) # 從大到小排序

多維列表

a = [1,2,3,4,5] # 一行五列

multi_dim_a = [[1,2,3],
               [2,3,4],
               [3,4,5]] # 三行三列

print(a[1])
# 2

print(multi_dim_a[0][1])
# 2

dictionary 字典

a_list = [1,2,3,4,5,6,7,8]

d1 = {'apple':1, 'pear':2, 'orange':3} # 字典是無序容器
d2 = {1:'a', 2:'b', 3:'c'}
d3 = {1:'a', 'b':2, 'c':3}

print(d1['apple'])  # 1
print(a_list[0])    # 1

del d1['pear']
print(d1)   # {'orange': 3, 'apple': 1}

d1['b'] = 20
print(d1)   # {'orange': 3, 'b': 20, 'apple': 1}

def func():
    return 0

d4 = {'apple':[1,2,3], 'pear':{1:3, 3:'a'}, 'orange':func}
print(d4['pear'][3])    # a

模塊

import 模塊

import time as t    # 需要加t.前綴來引出功能
from time import time, localtime    # 只import自己想要的功能.
from time import *  #輸入模塊的所有功能

其他

continue & break

• break：直接跳出循環(huán)
• continue：跳出本次循環(huán)

try 錯誤處理

try:
    file=open('eeee.txt','r')  #會報錯的代碼
except Exception as e:  # 將報錯存儲在 e 中
    print(e)
    
    
try:
    file=open('eeee.txt','r+')
except Exception as e:
    print(e)
    response = input('do you want to create a new file:')
    if response=='y':
        file=open('eeee.txt','w')
    else:
        pass    # 空語句
else:
    file.write('ssss')
    file.close()
"""
[Errno 2] No such file or directory: 'eeee.txt'
do you want to create a new file:y

ssss  #eeee.txt中會寫入'ssss'

zip

zip 接受任意多個（包括0個和1個）序列作為參數(shù)镊屎，合并后返回Tuple列表

a=[1,2,3]
b=[4,5,6]
ab=zip(a,b)
print(list(ab))  #需要加list來可視化這個功能
"""
[(1, 4), (2, 5), (3, 6)]
"""


for i,j in zip(a,b):
     print(i/2,j*2)
"""
0.5 8
1.0 10
1.5 12
"""

lambda

fun = lambda x,y : x+y, 冒號前的x,y為自變量，冒號后x+y為具體運算茄螃。

fun= lambda x,y:x+y
x=int(input('x='))    #這里要定義int整數(shù)缝驳，否則會默認(rèn)為字符串
y=int(input('y='))
print(fun(x,y))

"""
x=6
y=6
12
"""

map

map是把函數(shù)和參數(shù)綁定在一起。

>>> def fun(x,y):
    return (x+y)
>>> list(map(fun,[1],[2]))
"""
[3]
"""
>>> list(map(fun,[1,2],[3,4]))
"""
[4,6]
"""

深拷貝 & 淺拷貝

1.賦值: 只是復(fù)制了新對象的引用，不會開辟新的內(nèi)存空間党巾。

并不會產(chǎn)生一個獨立的對象單獨存在萎庭，只是將原有的數(shù)據(jù)塊打上一個新標(biāo)簽，所以當(dāng)其中一個標(biāo)簽被改變的時候齿拂，數(shù)據(jù)塊就會發(fā)生變化，另一個標(biāo)簽也會隨之改變肴敛。

import copy
a = [1,2]
b = a
a.append(3)
print(a)
print(b)

2.淺拷貝: 創(chuàng)建新對象署海，其內(nèi)容是原對象的引用。

3.深拷貝：和淺拷貝對應(yīng)医男，深拷貝拷貝了對象的所有元素砸狞，包括多層嵌套的元素。深拷貝出來的對象是一個全新的對象镀梭，不再與原來的對象有任何關(guān)聯(lián)刀森。

多線程

多線程 Threading 是一種讓程序擁有分身效果. 能同時處理多件事情. 一般的程序只能從上到下一行行執(zhí)行代碼, 不過 多線程 (Threading) 就能打破這種限制. 讓你的程序鮮活起來.

多進(jìn)程

多進(jìn)程 Multiprocessing 能讓電腦更有效率的分配任務(wù)給每一個處理器, 這種做法解決了多線程的弊端. 也能很好的提升效率.

Tkinter 窗口視窗

GUI 設(shè)計模塊.

pickle 保存數(shù)據(jù)

保存

import pickle

a_dict = {'da': 111, 2: [23,1,4], '23': {1:2,'d':'sad'}}

# pickle 是一個變量到一個文件
file = open('pickle_example.pickle', 'wb')
pickle.dump(a_dict, file)
file.close()

提取

# 需要close()
file = open('pickle_example.pickle', 'rb')
a_dict1 = pickle.load(file)
file.close()

# 無需close()
with open('pickle_example.pickle', 'rb') as file:
    a_dict1 =pickle.load(file)

print(a_dict1)

set

set 最主要的功能就是尋找一個句子或者一個list當(dāng)中不同的元素

char_list = ['a', 'b', 'c', 'c', 'd', 'd', 'd']

sentence = 'Welcome Back to This Tutorial'

print(set(char_list))
>>> {'b', 'd', 'a', 'c'}

print(set(sentence))
>>> {'l', 'm', 'a', 'c', 't', 'r', 's', ' ', 'o', 'W', 'T', 'B', 'i', 'e', 'u', 'h', 'k'}

print(set(char_list+ list(sentence)))
>>> {'l', 'm', 'a', 'c', 't', 'r', 's', ' ', 'd', 'o', 'W', 'T', 'B', 'i', 'e', 'k', 'h', 'u', 'b'}

添加元素

add添加某個元素，但不是所有元素都能添加的报账，比如一個列表研底。

unique_char = set(char_list)
unique_char.add('x')
# unique_char.add(['y', 'z']) this is wrong
print(unique_char)

# {'x', 'b', 'd', 'c', 'a'}

清除元素或 set

清除一個元素用 remove 或 discard

清除全部用 clear

unique_char.remove('x')
print(unique_char)
# {'b', 'd', 'c', 'a'}

unique_char.discard('d')
print(unique_char)
# {'b', 'c', 'a'}

unique_char.clear()
print(unique_char)
# set()

篩選

我們還能進(jìn)行一些篩選操作, 比如對比另一個東西, 看看原來的 set 里有沒有和他不同的 (difference). 或者對比另一個東西, 看看 set 里有沒有相同的 (intersection).

unique_char = set(char_list)
print(unique_char.difference({'a', 'e', 'i'}))
# {'b', 'd', 'c'}   不同

print(unique_char.intersection({'a', 'e', 'i'}))
# {'a'}             相同

正則表達(dá)式

簡單的匹配

pattern1 = "cat"
pattern2 = "bird"
string = "dog runs to cat"
print(pattern1 in string)    # True
print(pattern2 in string)    # False

python 中的 re 模塊 。re.search() ：沒找到返回None透罢， 找到返回match的object

import re

# regular expression
pattern1 = "cat"
pattern2 = "bird"
string = "dog runs to cat"
print(re.search(pattern1, string))  # <_sre.SRE_Match object; span=(12, 15), match='cat'>
print(re.search(pattern2, string))  # None

靈活匹配

使用特殊的 pattern 來靈活匹配需要找的文字.

如果需要找到潛在的多個可能性文字, 我們可以使用 [] 將可能的字符囊括進(jìn)來. 比如 [ab] 就說明我想要找的字符可以是 a 也可以是 b. 這里我們還需要注意的是, 建立一個正則的規(guī)則, 我們在 pattern 的 "前面需要加上一個 r 用來表示這是正則表達(dá)式, 而不是普通字符串. 通過下面這種形式, 如果字符串中出現(xiàn)run或者是ran", 它都能找到.

# multiple patterns ("run" or "ran")
ptn = r"r[au]n"       # start with "r" means raw string
print(re.search(ptn, "dog runs to cat"))    # <_sre.SRE_Match object; span=(4, 7), match='run'>

同樣, 中括號 [] 中還可以是以下這些或者是這些的組合. 比如 [A-Z] 表示的就是所有大寫的英文字母. [0-9a-z] 表示可以是數(shù)字也可以是任何小寫字母.

print(re.search(r"r[A-Z]n", "dog runs to cat"))     # None
print(re.search(r"r[a-z]n", "dog runs to cat"))     # <_sre.SRE_Match object; span=(4, 7), match='run'>
print(re.search(r"r[0-9]n", "dog r2ns to cat"))     # <_sre.SRE_Match object; span=(4, 7), match='r2n'>
print(re.search(r"r[0-9a-z]n", "dog runs to cat"))  # <_sre.SRE_Match object; span=(4, 7), match='run'>

按類型匹配

除了自己定義規(guī)則, 還有很多匹配的規(guī)則時提前就給你定義好了的. 下面有一些特殊的匹配類型給大家先總結(jié)一下.

• \d : 任何數(shù)字
• \D : 不是數(shù)字
• \s : 任何 white space, 如 [\t\n\r\f\v]
• \S : 不是 white space
• \w : 任何大小寫字母, 數(shù)字和 _ [a-zA-Z0-9_]
• \W : 不是 \w
• \b : 空白字符 (只在某個字的開頭或結(jié)尾)
• \B : 空白字符 (不在某個字的開頭或結(jié)尾)
• \ : 匹配 \
• . : 匹配任何字符 (除了 \n)
• ^ : 匹配開頭
• $ : 匹配結(jié)尾
• ? : 前面的字符可有可無

# \d : decimal digit
print(re.search(r"r\dn", "run r4n"))           # <_sre.SRE_Match object; span=(4, 7), match='r4n'>
# \D : any non-decimal digit
print(re.search(r"r\Dn", "run r4n"))           # <_sre.SRE_Match object; span=(0, 3), match='run'>
# \s : any white space [\t\n\r\f\v]
print(re.search(r"r\sn", "r\nn r4n"))          # <_sre.SRE_Match object; span=(0, 3), match='r\nn'>
# \S : opposite to \s, any non-white space
print(re.search(r"r\Sn", "r\nn r4n"))          # <_sre.SRE_Match object; span=(4, 7), match='r4n'>
# \w : [a-zA-Z0-9_]
print(re.search(r"r\wn", "r\nn r4n"))          # <_sre.SRE_Match object; span=(4, 7), match='r4n'>
# \W : opposite to \w
print(re.search(r"r\Wn", "r\nn r4n"))          # <_sre.SRE_Match object; span=(0, 3), match='r\nn'>
# \b : empty string (only at the start or end of the word)
print(re.search(r"\bruns\b", "dog runs to cat"))    # <_sre.SRE_Match object; span=(4, 8), match='runs'>
# \B : empty string (but not at the start or end of a word)
print(re.search(r"\B runs \B", "dog   runs  to cat"))  # <_sre.SRE_Match object; span=(8, 14), match=' runs '>
# \\ : match \
print(re.search(r"runs\\", "runs\ to me"))     # <_sre.SRE_Match object; span=(0, 5), match='runs\\'>
# . : match anything (except \n)
print(re.search(r"r.n", "r[ns to me"))         # <_sre.SRE_Match object; span=(0, 3), match='r[n'>
# ^ : match line beginning
print(re.search(r"^dog", "dog runs to cat"))   # <_sre.SRE_Match object; span=(0, 3), match='dog'>
# $ : match line ending
print(re.search(r"cat$", "dog runs to cat"))   # <_sre.SRE_Match object; span=(12, 15), match='cat'>
# ? : may or may not occur
print(re.search(r"Mon(day)?", "Monday"))       # <_sre.SRE_Match object; span=(0, 6), match='Monday'>
print(re.search(r"Mon(day)?", "Mon"))          # <_sre.SRE_Match object; span=(0, 3), match='Mon'>

如果一個字符串有很多行, 我們想使用 ^ 形式來匹配行開頭的字符, 如果用通常的形式是不成功的. 比如下面的 I 出現(xiàn)在第二行開頭, 但是使用 r"^I" 卻匹配不到第二行, 這時候, 我們要使用 另外一個參數(shù), 讓 re.search() 可以對每一行單獨處理. 這個參數(shù)就是 flags=re.M, 或者這樣寫也行 flags=re.MULTILINE.

string = """
dog runs to cat.
I run to dog.
"""
print(re.search(r"^I", string))                 # None
print(re.search(r"^I", string, flags=re.M))     # <_sre.SRE_Match object; span=(18, 19), match='I'>

重復(fù)匹配

如果我們想讓某個規(guī)律被重復(fù)使用, 在正則里面也是可以實現(xiàn)的, 而且實現(xiàn)的方式還有很多. 具體可以分為這三種:

• * : 重復(fù)零次或多次
• + : 重復(fù)一次或多次
• {n, m} : 重復(fù) n 至 m 次
• {n} : 重復(fù) n 次

# * : occur 0 or more times
print(re.search(r"ab*", "a"))             # <_sre.SRE_Match object; span=(0, 1), match='a'>
print(re.search(r"ab*", "abbbbb"))        # <_sre.SRE_Match object; span=(0, 6), match='abbbbb'>

# + : occur 1 or more times
print(re.search(r"ab+", "a"))             # None
print(re.search(r"ab+", "abbbbb"))        # <_sre.SRE_Match object; span=(0, 6), match='abbbbb'>

# {n, m} : occur n to m times
print(re.search(r"ab{2,10}", "a"))        # None
print(re.search(r"ab{2,10}", "abbbbb"))   # <_sre.SRE_Match object; span=(0, 6), match='abbbbb'>

分組

我們甚至可以為找到的內(nèi)容分組, 使用 () 能輕松實現(xiàn)這件事. 通過分組, 我們能輕松定位所找到的內(nèi)容. 比如在這個 (\d+) 組里, 需要找到的是一些數(shù)字, 在 (.+) 這個組里, 我們會找到 Date: 后面的所有內(nèi)容. 當(dāng)使用 match.group() 時, 他會返回所有組里的內(nèi)容, 而如果給 .group(2) 里加一個數(shù), 它就能定位你需要返回哪個組里的信息.

match = re.search(r"(\d+), Date: (.+)", "ID: 021523, Date: Feb/12/2017")
print(match.group())                   # 021523, Date: Feb/12/2017
print(match.group(1))                  # 021523
print(match.group(2))                  # Date: Feb/12/2017

有時候, 組會很多, 光用數(shù)字可能比較難找到自己想要的組, 這時候, 如果有一個名字當(dāng)做索引, 會是一件很容易的事. 我們字需要在括號的開頭寫上這樣的形式 ?P<名字> 就給這個組定義了一個名字. 然后就能用這個名字找到這個組的內(nèi)容.

match = re.search(r"(?P<id>\d+), Date: (?P<date>.+)", "ID: 021523, Date: Feb/12/2017")
print(match.group('id'))                # 021523
print(match.group('date'))              # Date: Feb/12/2017

findall

前面我們說的都是只找到了最開始匹配上的一項而已, 如果需要找到全部的匹配項, 我們可以使用 findall 功能. 然后返回一個列表. 注意下面還有一個新的知識點, | 是 or 的意思, 要不是前者要不是后者.

# findall
print(re.findall(r"r[ua]n", "run ran ren"))    # ['run', 'ran']

# | : or
print(re.findall(r"(run|ran)", "run ran ren")) # ['run', 'ran']

replace

我們還能通過正則表達(dá)式匹配上一些形式的字符串然后再替代掉這些字符串. 使用這種匹配 re.sub(), 將會比 python 自帶的 string.replace() 要靈活多變.

print(re.sub(r"r[au]ns", "catches", "dog runs to cat"))     # dog catches to cat

split

再來我們 Python 中有個字符串的分割功能, 比如想獲取一句話中所有的單詞. 比如 "a is b".split(" "), 這樣它就會產(chǎn)生一個列表來保存所有單詞. 但是在正則中, 這種普通的分割也可以做的淋漓精致.

print(re.split(r"[,;\.]", "a;b,c.d;e"))             # ['a', 'b', 'c', 'd', 'e']

compile

最后, 我們還能使用 compile 過后的正則, 來對這個正則重復(fù)使用. 先將正則 compile 進(jìn)一個變量, 比如 compiled_re, 然后直接使用這個 compiled_re 來搜索.

compiled_re = re.compile(r"r[ua]n")
print(compiled_re.search("dog ran to cat"))  # <_sre.SRE_Match object; span=(4, 7), match='ran'>

13-10-01.png