python基本操作

• Print
• 數字運算符
• 自變量
• while
• for
• if,ifelse
• def
• 函數參數
• 函數默認參數
• 函數輸出
• 全局局部變量
• 模塊安裝
• 文件讀寫
• 類
• 類init
• input
• 元組和列表
• 多維列表
• 字典
• 載入模塊
• continue&break
• 錯誤處理
• zip,lambda,map
• copy&deepcopy
• pickle
• set
• 正則表達式
• • 匹配的規則
  • 多行匹配
  • 重復使用
  • 分組
  • findall
  • replace
  • split
  • compile

Print

3的版本print要加(),2.7及以下版本不用

輸出string要用’'單引號或雙引號 print(‘helllo’)

string+string可以，string+數字不行，要將數字引起來或者str(4)#

數字運算符

平方要用** 。 2**2=4 2^2=0

取余%

取整// 9//4=2

自變量

存儲自變量不用定義類型 a=4

while

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

True False為大寫

Ctrl+C結束內容

注意要用:結束

for

重視程序結構的語言

example_list=[1,1,2,3,4,5,6]//list
for i in example_list:
print(i)

ctrl+[ 或ctrl+]進行縮進

range電腦自動生成的迭代器注意包含頭不含尾

range(1,3) 輸出[1,2]

range(1,10,2) 1-9步長為2

if,ifelse

x=1;y=2;z=3
if x<y:#結果輸出
print('x<y')
if x<y<z:#結果輸出
print('x<y<z')

if x<y:
print('x<y')
else:
print('x>y')

if x<y:
print('x<y')
elif:
print('x>y')
else:
print('x>y')

def

定義方程,不運行，調用才是考驗

def wpc():
print('this is a test-')
wpc()#函數的調用

函數參數

def wpc(a,b):
c=a+b
print('this is a test-'+str(c))#this is a test-3
print('this is a test-',c)#this is a test- 3
wpc(1,2)#函數的調用

當你使用含參數的函數時候呀，一定要傳參不然報錯呦！

函數默認參數

為解決參數過長問題，需要分行寫

def sale_car(price,color='red',brand='camy',is_second_hand='true'):#默認參數
print('price',price,
'color', color,
'brand', brand,
'is_second_hand', is_second_hand,)
sale_car(1000,'red','camy',True)#覆蓋
sale_car(13100)

注意：未被定義的函數參數放一塊，定義的函數參數放一塊

函數輸出

def wpc(a,b):
c=a+b
return c
wpc(1,2)#函數的調用
print(wpc(2,4))#函數值的輸出

全局局部變量

一般用大寫

APPLE=100#全局變量
def fun():
global b#全局變量
b=50
a=APPLE#局部變量
return a+100
print(APPLE)
print(fun())
print(b)
#print(a) 會報錯因為a是一個局部變量

APPLE=100#全局變量
a=None
def fun():
a=20
return a+100
print(APPLE)
print('a past=',a)#None因為還是指第二行全局變量
print(fun())#120
print('a now =',a)#None因為還是指第二行全局變量，區別於fun中的局部變量a

模塊安裝

sudo pip3 install numpy //安裝

sudo pip3 uninstall numpy //卸載

sudo pip3 install -U numpy //升級numpy

sudo是升級為管理員

文件讀寫

寫操作

text = " this is my first test.\n this is next line .\n this is last line"
print(text)
my_file = open('myfile.txt','w')#第一個是文件名，第二個是怎麼樣的形式
my_file.write(text)#寫什麼東西
my_file.close()#記得關閉文件

附加操作

text = " this is my first test.\n this is next line .\n this is last line"
append_text='\n this is appended file'
print(text)
my_file = open('myfile.txt','a')#a是追加的意思
my_file.write(append_text)
my_file.close()

讀操作

file=open('myfile.txt','r')#將文件保存到file中
content=file.read()#content才是內容
print(content)

file=open('myfile.txt','r')
content=file.readline()#逐行逐行的讀
second=file.readline()
all=file.readlines()#將剩余的一次讀出，以list形式存儲 列表形式
print(content,second,all)
運行結果
this is my first test.
this is next line .
[' this is last line\n', ' this is appended file']

類

和函數類似，變量以大寫開頭

class Calculator:#屬性和方法
name = 'good calculator'
price =18
def add(self,x,y):#self是自身即本類
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 divid(self,x,y):
print(x/y)
calcul =Calculator()#創建一個類
calcul.add(5,4)#使用類的方法

類init

類自己功能,經常用到

class Calculator:#屬性和方法
name = 'good calculator'
price =18#共有屬性
def __init__(self,name,price,hight=3,width=4,weight=5):#初始化，定義的時候一定要輸入參數，這裡有默認參數
self.name=name#給定的初始化
self.price=price
self.h=hight
self.w=width
self.we=weight
def add(self,x,y):#self是自身即本類
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 divid(self,x,y):
print(x/y)
calcul =Calculator()#創建一個類
calcul.add(5,4)#使用類的方法

input

a_input =input('give a number')
print('this number is:',a_input)

用戶輸入的是一個string類型哦！！

解決方法是int(input())

元組和列表

有序的數列

#tupe元組 list列表 都是一連串有順序的數字
a_tuple=(12,3,5,15,6)#用括號,或者把括號去掉
another_tuple=2,4,7,6
a_list=[12,3,4,5]
for content in a_tuple:
print(content)
for content in a_list:
print(content)

#tupe元組 list列表 都是一連串有順序的數字
a_tuple=(12,3,5,15,6)#用括號,或者把括號去掉
another_tuple=2,4,7,6
a_list=[12,3,4,5]
for index in range(len(a_list)):#range(5)生成0,1,2,3,4的值,len()長度
print(index)#0,1，2,3
print(a_list[index])#list起始位0

a=[1,2,3,4,1,2,3,4]#列表
a.append(0)#.append可以添加值
print(a)#打印出列表
a.insert(1,0)#在1的位置添加一個0不是修改
print(a)#打印出列表
a.remove(2)#移除第一個出現的2
print(a)#打印出列表
print(a[-1])#從後往前是第一個為-1
print(a[0:3])#打印0,1,2為數字
print(a[:3])#省略0
print(a[-3:])#打印-3到最後一位 也就是-3，-2，-1位
print(a)
print(a.index(0))#打印第一次出現2的索引 index裡面是值
print(a.count(1))#打印統計的值為1的數字有多少個？
a.sort()#從小到大進行排序，並覆蓋原來的list
print(a)
a.sort(reverse=True)#從大到小進行排序，並覆蓋原來的list
print(a)

多維列表

多維list，更高級的用numpy，pandas

a=[1,2,3,4,5]
mutil_dim_a=[ [1,2,3],
[2,3,4],
[3,4,5]]
print(a[1])#輸出單list的第2個值2
print(mutil_dim_a[0][1])#輸出2

字典

列表是按順序的輸出內容，字典是無序的

a_list=[1,2,3,4,5,5,4]
d1={
'apple':1,'pear':2,'orange':3}#需要一對鍵值
d2={
1:'a','c':'d'}
print(d1['apple'])#輸出Apple對應的值
print(d1)#輸出d1這個字典
del d1['apple']#刪除d1中的'apple'這個鍵值對
print(d1)#輸出d1這個字典
d1['apple']=1#向字典加入一個鍵值對
print(d1)#輸出d1這個字典
def fun():
print('hello')
d3={
'apple':[1,2,3],#字典裡面加list
'pear': {
'a':1,'b':2 },#字典裡面加字典
'orange':fun}#字典裡面加函數
print(d3)
print(d3['pear']['a'])#取出字典中的東西

載入模塊

官方的模塊

#第1種方法
#import time
#print(time.localtime())
#第2種方法
#import time as t#以後time都用t來代替了
#print(t.localtime())
#第3種方法
from time import *#引入time的所有功能
print(localtime())

自己模塊

import m1
m1.printdata('hello!!')

continue&break

a=True
while a:
b=input('type')
if b=='1':
# a=False
#break
continue
else:
pass#什麼都不做
print('still in run')
print('fininsh run')

錯誤處理

try:
#file=open('eee','r')#出錯的地方，進入Exception
file=open('eee','r+')#進入else無錯誤的情況，r+是讀寫操作
except Exception as e:#將錯誤存在e這個變量中，下面進行錯誤處理
print('there is no file named eee')#打印錯誤信息
response = input('do you want to create a new file?')
if response=='y':
file=open('eee','w')
else:
pass
else:#如果沒有錯誤那就在這裡處理
file.write('sss')
file.close()

zip,lambda,map

map就是功能+參數，lambda是簡化功能，zip是為迭代器做的東西

zip

a=[1,3,4]
b=[0,7,8,9]
print(zip(a,b))
print(list(zip(a,b)))#輸出[(1, 0), (3, 7), (4, 8)]
#進行迭代器的輸出
for i,j in zip(a,b):
print(i/2,j*2)
print(list(zip(a,a,b)))#可以輸出更多的東西

lambda

def fun1(x,y):
return (x+y)
print(fun1(2,3))
fun2=lambda x,y:x+y#用lambda定義一個簡單的方程
print(fun2(2,3))

map

def fun1(x,y):
return (x+y)
print(fun1(2,3))
fun2=lambda x,y:x+y#用lambda定義一個簡單的方程
print(fun2(2,3))
print(map(fun1,[1],[2]))#輸出一個對象,map(函數，輸入的參數)
print(list(map(fun1,[1],[2])))
print(list(map(fun1,[1,3],[2,5])))#[1,3]表示x1,x2,[2,5]表示y1,y2

copy&deepcopy

import copy
a=[1,2,3]
b=a#指向同一個空間
print(id(a))#查a的索引
print(id(b))#查b的索引
b[0]=11#改變b，同時改變a
print(a)
print(id(a)==id(b))#返回true
c=copy.copy(a)#copy淺的copy，第一次不同，第二層以後的又指向同一個空間
print(id(a)==id(c))#返回false
c[1]=0
print(a)#不改變
print(c)
d=[1,2,[3,4]]
e=copy.copy(d)
print(id(d)==id(e))#返回false
print(id(e[2])==id(d[2]))#但是當list套list中時，卻出現id相同
d[0]=11
print(e)#改變第一位
d[2][0]=666
print(e)#改變d中list中第一位，同時改變了e
#若想完完全全的copy
f=copy.deepcopy(d)#完全不會改變。兩個完全不一樣
print(id(f[2])==id(d[2]))

pickle

保存和提取功能

import pickle
a_dict= {
'da':111,
2:[23,1,4],
'23':{
1:2,'d':'sad'}}#字典
file=open('pickle_example.pickle','wb')#文件名的後綴為pickle，wb是用二進制
pickle.dump(a_dict,file)#像一個挖土車，把a_dict倒到file中
file.close()

import pickle
a_dict= {
'da':111,
2:[23,1,4],
'23':{
1:2,'d':'sad'}}#字典
# file=open('pickle_example.pickle','wb')#文件名的後綴為pickle，wb是用二進制
# pickle.dump(a_dict,file)#像一個挖土車，把a_dict倒到file中
# file.close()
#第一種方法
# file= open('pickle_example.pickle','rb')#讀
# a_dict1 = pickle.load(file)#裝載文件
# file.close()
#第二種方法
#未解決可能忘記關文件的問題
with open('pickle_example.pickle','rb') as file:#自動幫你關文件
a_dict1 = pickle.load(file) # 裝載文件
print(a_dict1)#內容完全一樣

set

幫你找不同

char_list = ['a','b','c','c','d','d','d']
print(set(char_list))#結果{'d', 'a', 'c', 'b'}不是字典，沒有鍵值對

char_list = ['a','b','c','c','d','d','d']
print(set(char_list))#結果{'d', 'a', 'c', 'b'}不是字典，沒有鍵值對
sentence='Welcome to world!'
print(set(sentence))#結果{'d', 'c', ' ', 'w', 'm', '!', 'W', 't', 'o', 'l', 'r', 'e'}
#區分空格和大小寫
#只能傳列表或者元組的單一形式，不能列表+列表

char_list = ['a','b','c','c','d','d','d']
print(set(char_list))#結果{'d', 'a', 'c', 'b'}不是字典，沒有鍵值對
sentence='Welcome to world!'
print(set(sentence))#結果{'d', 'c', ' ', 'w', 'm', '!', 'W', 't', 'o', 'l', 'r', 'e'}
#區分空格和大小寫
#只能傳列表或者元組的單一形式，不能列表+列表
unique_char=set(char_list)
unique_char.add('x')#加入一個東西
# unique_char.clear()#清除set
unique_char.remove('x')#刪除某一個特定值，沒有東西會報錯
unique_char.discard('z')#刪除值，沒有東西不報錯
print(unique_char)

char_list = ['a','b','c','c','d','d','d']
print(set(char_list))#結果{'d', 'a', 'c', 'b'}不是字典，沒有鍵值對
sentence='Welcome to world!'
print(set(sentence))#結果{'d', 'c', ' ', 'w', 'm', '!', 'W', 't', 'o', 'l', 'r', 'e'}
#區分空格和大小寫
#只能傳列表或者元組的單一形式，不能列表+列表
unique_char=set(char_list)
unique_char.add('x')#加入一個東西
# # unique_char.clear()#清除set
# unique_char.remove('x')#刪除某一個特定值，沒有東西會報錯
# unique_char.discard('z')#刪除值，沒有東西不報錯
set1=unique_char
set2={
'a','e','i'}
print(set1.difference(set2))#輸出它有他沒有東西 輸出{'d', 'x', 'b', 'c'}
print(set1.intersection(set2))#輸出它共有的東西

正則表達式

為以後爬蟲用

import re
# matching string
pattern1 = "cat"
pattern2 = "bird"
string = "dog runs to cat"
print(pattern1 in string) # True
print(pattern2 in string) # False
# regular expression
pattern1 = "cat"
pattern2 = "bird"
string = "dog runs to cat"
# 可以看出, 如果 re.search() 找到了結果, 它會返回一個 match 的 object.
# 如果沒有匹配到, 它會返回 None. 這個 re.search() 只是 re 中的一個功能
print(re.search(pattern1, string)) # <_sre.SRE_Match object; span=(12, 15), match='cat'>
print(re.search(pattern2, string)) # None
print('\n')
# multiple patterns ("run" or "ran")
ptn = r"r[au]n" # [表示有兩個情況],前面需要加上一個 r 用來表示這是正則表達式, 而不是普通字符串
print(re.search(ptn, "dog runs to cat")) # <_sre.SRE_Match object; span=(4, 7), match='run'>
#同樣, 中括號 [] 中還可以是以下這些或者是這些的組合.
# 比如 [A-Z] 表示的就是所有大寫的英文字母. [0-9a-z] 表示可以是數字也可以是任何小寫字母.
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'>

匹配的規則

除了自己定義規則, 還有很多匹配的規則時提前就給你定義好了的. 下面有一些特殊的匹配類型給大家先總結一下, 然後再上一些例子.

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

print(re.search(r"r\dn", "run r4n"))
print(re.search(r"r\Dn", "run r4n"))
print(re.search(r"r\sn", "r\nn r4n"))
print(re.search(r"r\Sn", "r\nn r4n"))
print(re.search(r"r\wn", "r\nn r4n"))
print(re.search(r"r\Wn", "r\nn r4n"))
print(re.search(r"\bruns\b", "dog runs to cat"))
print(re.search(r"\B runs \B", "dog runs to cat"))
print(re.search(r"runs\\", "runs\ to me"))
print(re.search(r"r.n", "r[ns to me"))
print(re.search(r"^dog", "dog runs to cat"))
print(re.search(r"cat$", "dog runs to cat"))
print(re.search(r"Mon(day)?", "Monday"))
print(re.search(r"Mon(day)?", "Mon"))

多行匹配

如果一個字符串有很多行, 我們想使用 ^ 形式來匹配行開頭的字符, 如果用通常的形式是不成功的. 比如下面的 “I” 出現在第二行開頭, 但是使用 r"^I" 卻匹配不到第二行, 這時候, 我們要使用 另外一個參數, 讓 re.search() 可以對每一行單獨處理. 這個參數就是 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'>

重復使用

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

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

舉例如下:

# * : occur 0 or more times
print(re.search(r"ab*", "a"))
print(re.search(r"ab*", "abbbbb"))
# + : occur 1 or more times
print(re.search(r"ab+", "a"))
print(re.search(r"ab+", "abbbbb"))
# {n, m} : occur n to m times
print(re.search(r"ab{2,10}", "a"))
print(re.search(r"ab{2,10}", "abbbbb"))

分組

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

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

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

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

我們還能通過正則表達式匹配上一些形式的字符串然後再替代掉這些字符串. 使用這種匹配 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(" "), 這樣它就會產生一個列表來保存所有單詞. 但是在正則中, 這種普通的分割也可以做的淋漓精致.

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

compile

最後, 我們還能使用 compile 過後的正則, 來對這個正則重復使用. 先將正則 compile 進一個變量, 比如 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'>