python基礎之——語法(from 莫煩python)

1.print

字符串不可以直接和數字相加
print(float(‘1.2’)+3) #float()是浮點型，可以把字符串轉換成小數
print(int(‘2’)+3) #int爲定義整數型
print(int(1.9)) #當int一個浮點型數時，int會保留整數部分

2.基礎數學運算

在python中，^用兩個**表示，如3的平方爲3**2 , **3表示立方，**4表示4次方，依次類推

3.變量

可以將一個數值，或者字符串串附值給自變量，如apple=1，apple=‘iphone7 plus’
需要加下劃線，如apple_2016=‘iphone 7 plus’
一次定義多個自變量 a,b,c=1,2,3

4.循環

while condition:
expressions
要停止程序，使用 ctrl + c 終止程序。
整數和浮點數也能進行 Boolean 數據操作, 具體規則，如果該值等於 0 或者 0.0 將會返回 False 其餘的返回 True；數據類型 None, 將會返回 False。
在 Python 中集合類型有 list、 tuple 、dict 和 set 等，如果該集合對象作爲 while 判斷語句， 如果集合中的元素數量爲 0，那麼將會返回 False, 否則返回 True，比如：
a = range(10) #range() 函數可創建一個整數列表
while a: #判斷是否爲空
print(a[-1]) #打印最後一個內容
a = a[:len(a)-1] #切片操作去掉最後一個元素
#打印 9 8 7 6 5 4 3 2 1 0
語法：range(start, stop[, step])
start默認0，step默認1，range(5)等價於range(0,5)等價於range(0,5,1)

5.判斷

if condition:
expressions
判斷條件： x < y < z，（相當於 x < y and y < z）但不鼓勵這種風格

if condition:
true_expressions
else:
false_expressions
python 可以通過 if-else 的行內表達式完成類似三目運算符的功能。
var = var1 if condition else var2 #如果條件爲true,var=var1否則var=var2

#一旦某個條件爲 True，那麼將執行對應的 expression。 並在之代碼執行完畢後跳出該 if-elif-else 語句塊，往下執行,與c中類似
if condition1:
true1_expressions
elif condition2:
true2_expressions
elif condtion3:
true3_expressions
elif …
…
else:
else_expressions

6.def函數

def function_name(parameters):
expressions #可用return返回
#上述兩行代碼只定義了函數並未執行函數，在命令提示符中輸入function_name(參數)，會執行函數。若在腳本中調用腳本，在腳本最後添加function_name()

7.函數默認參數

def function_name(para_1,…,para_n=defau_n,…, para_m=defau_m):
expressions
函數聲明只需要在需要默認參數的地方用 = 號給定即可, 但是要注意所有的默認參數都不能出現在非默認參數的前面。當然也可以在函數調用過程中傳入特定的參數用來修改默認參數。通過默認參數可以減輕我們函數調用的複雜度。
函數自調用:
如果想要在執行腳本的時候執行一些代碼，比如單元測試，可以在腳本最後加上單元測試 代碼，當該腳本作爲一個模塊對外提供功能的時候單元測試代碼也會執行，這些往往我們不想要的，我們可以把這些代碼放入腳本最後：
if __name__ == '__main__':
#code_here
如果執行該腳本的時候，該 if 判斷語句將會是 True,那麼內部的代碼將會執行。 如果外部調用該腳本，if 判斷語句則爲 False,內部代碼將不會執行。

可變參數 （1個，2個到任意個）
#* 修飾，表明該參數是一個可變參數，這是一個可迭代的對象
def report(name, *grades):
total_grade = 0
for grade in grades:
total_grade += grade
print(name, 'total grade is ', total_grade)
注意可變參數在函數定義不能出現在特定參數和默認參數前面，因爲可變參數會吞噬掉這些參數（和c++很像，就是可變參數放在形參最右面）

關鍵字參數
關鍵字參數可以傳入0個或者任意個含參數名的參數，這些參數名在函數定義中並沒有出現，這些參數在函數內部自動封裝成一個字典(dict).
#使用了 ** 修飾。表明該參數是關鍵字參數，通常來講關鍵字參數是放在函數參數列表的最後
def portrait(name, **kw):
print(‘name is’, name)
for k,v in kw.items():
print(k, v)
如果調用參數 portrait(‘Mike’, age=24, country=‘China’, education=‘bachelor’) 輸出:
name is Mike
age 24
country China
education bachelor
通過可變參數和關鍵字參數，任何函數都可以用 universal_func(*args, **kw) 表達

8.全局&局部變量

在外部定義一個全局變量 a=None, 然後再 fun() 中聲明 這個 a 是來自外部的 a. 聲明方式就是 global a. 然後對這個外部的 a 修改後, 修改的效果會被施加到外部的 a 上.
APPLY = 100 # 全局變量
a = None
def fun():
global a # 使用之前在全局裏定義的 a
a = 20 # 現在的 a 是全局變量了
return a+100

print(APPLE) # 100
print(‘a past:’, a) # None
fun()
print(‘a now:’, a) # 20

9.模塊安裝

#Numpy 和 matplotlib 都是外部模塊, 需要安裝以後纔會有的.
import numpy as np
import matplotlib.pyplot as plt
更新外部模塊 -U的意思是update
$ pip install -U numpy # 這是 python2+ 版本的用法
$ pip3 install -U numpy # 這是 python3+ 版本的用法

10.文件讀取

text=‘This is my first test\n ’ #\n換行 \t tab對齊
my_file=open(‘my file.txt’,‘w’) #用法: open(‘文件名’,‘形式’), 其中形式有’w’:write;‘r’:read. ‘a’:append 以增加內容的形式打開
my_file.write(text) #該語句會寫入先前定義好的 text
my_file.close() #關閉文件
按行讀取：
file= open(‘my file.txt’,‘r’)
content=file.readline() # 讀取第一行
print(content)

讀取所有行，將每一行的結果存在list中
file= open(‘my file.txt’,‘r’)
content=file.readlines() # python_list 形式
print(content）#輸出[‘This is my first test.\n’, ‘This is the second line.\n’, ‘This the third line.\n’, ‘This is appended file.’]
#或者for迭代輸出
for item in content:
print(item)
輸出:This is my first test.

This is the second line.

This the third line.

This is appended file

11.class類

class Calculator: #首字母要大寫，冒號不能缺
name=‘Good Calculator’ #該行爲class的屬性
price=18
def add(self,x,y):
print(self.name)
result = x + y
print(result)
def minus(self,x,y):
result=x-y
print(result)
調用：

cal=Calculator() #注意這裏運行class的時候要加"()",否則調用下面函數的時候會出現錯誤,導致無法調用.
cal.name
‘Good Calculator’

cal.price
18

class類init功能
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’

設置屬性的默認值
def init(self,name,price,height=10,width=14,weight=16)

c=Calculator(‘bad calculator’,18)
c.h
10

12.input輸入

#variable=input() 表示運行後，可以在屏幕中輸入一個數字，該數字會賦值給自變量。
a_input=input(‘please input a number:’)
print(‘this number is:’,a_input)

‘’’’
please input a number:12 #12 是我在硬盤中輸入的數字
this number is: 12
‘’’’
input應用在if語句中
a_input=int(input(‘please input a number:’))#注意這裏要定義一個整數型
if a_input==1:
print(‘This is a good one’)
elif a_input>=2:
print(‘See you next time’)
else:
print(‘Good luck’)

13.元組

13.1 tuple(cpp11也有tuple)
#用小括號、或者無括號來表述，是一連串有順序的數字。
a_tuple = (12, 3, 5, 15 , 6)
another_tuple = 12, 3, 5, 15 , 6
for content in a_list:
print(content)
13.2
#list是以中括號來命名的:
a_list = [12, 3, 67, 7, 82]
for content_tuple in a_tuple:
print(content_tuple)

依次輸出a_tuple和a_list中的各個元素：
for index in range(len(a_list)):
print("index = ", index, “, number in list = “, a_list[index])
“””
index = 0 , number in list = 12
index = 1 , number in list = 3
index = 2 , number in list = 67
index = 3 , number in list = 7
index = 4 , number in list = 82
“””

for index in range(len(a_tuple)):
print("index = ", index, “, number in tuple = “, a_tuple[index])
“””
index = 0 , number in tuple = 12
index = 1 , number in tuple = 3
index = 2 , number in tuple = 5
index = 3 , number in tuple = 15
index = 4 , number in tuple = 6
“””

list添加：
a = [1,2,3,4,1,1,-1]
a.append(0) # 在a的最後面追加
a.insert(1,0) # 在位置1處添加0
print(a)
#[1, 0，2, 3, 4, 1, 1, -1, 0]
a.remove(2) # 刪除列表中第一個出現的值爲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的倒數第3位及以後的所有項的值

a = [1,2,3,4,1,1,-1]
print(a.index(2)) # 顯示列表a中第一次出現的值爲2的項的索引
print(a.count(-1)) #統計列表中某值出現的次數
a.sort() # 默認從小到大排序
a.sort(reverse=True) # 從大到小排序

14.多維列表

一個一維的List是線性的List，多維List是一個平面的List，可以2維及更多的維度。
a = [1,2,3,4,5] # 一行五列

multi_dim_a = [[1,2,3],
[2,3,4],
[3,4,5]] # 三行三列
print(multi_dim_a[0][1])

15.dictionary字典

List是有順序地輸出輸入的話，那麼字典的存檔形式則是無需順序的。
在字典中，有key和 value兩種元素，每一個key對應一個value, key是名字, value是內容。數字和字符串都可以當做key或者value， 在同一個字典中, 並不需要所有的key或value有相同的形式。 這樣說, List 可以說是一種key爲有序數列的字典。
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, ‘pear’: 2, ‘apple’: 1}說明字典是無序的
字典還可以以更多樣的形式出現，例如字典的元素可以是一個List，或者再是一個列表，再或者是一個function。索引需要的項目時，只需要正確指定對應的key就可以了
def func():
return 0

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

16.import

import time
print(time.localtime()) #這樣就可以print 當地時間了

import time as t
print(t.localtime()) # 需要加t.前綴來引出功能

from time import time, localtime #只import自己想要的功能.
print(localtime())
print(time())

from time import * # 輸入模塊的所有功能

• import自建的模塊
  #自建的模塊爲 balance.py,保存在默認文件夾
  import balance

17.continue & break

18.try錯誤處理

try:
file=open(‘eeee.txt’,‘r’) #會報錯的代碼
except Exception as e: # 將報錯存儲在 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()

19. zip lambda map

zip函數接受任意多個（包括0個和1個）序列作爲參數，合併後返回一個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=int(input(‘x=’)) #這裏要定義int整數，否則會默認爲字符串
y=int(input(‘y=’))
print(fun(x,y))

“”"
x=6
y=6
12
“”"

map把函數和參數綁定在一起

def fun(x,y):
return (x+y)

list(map(fun,[1],[2]))
“”"
[3]
“”"

list(map(fun,[1,2],[3,4]))
“”"
[4,6] #[1+3,2+4]
“”"

20.淺拷貝 深拷貝

一個對象的id值在CPython解釋器裏就代表它在內存中的`地址

import copy
a=[1,2,3]
b=a #深拷貝，
id(a)==id(b) #附值後，兩者的id相同，爲true。
True

b[0]=222222 #此時，改變b的第一個值，也會導致a值改變。
print(a,b)
[222222, 2, 3] [222222, 2, 3] #a,b值同時改變

淺拷貝.copy()：只是拷貝了最【外圍】的對象本身，【內部的元素】都只是拷貝了一個引用而已

import copy
a=[1,2,3]
c=copy.copy(a) #拷貝了a的外圍對象本身,淺拷貝
print(id(a)==id©) #id 改變 爲false
False

c[1]=22222 #此時，我去改變c的第二個值時，a不會被改變。
print(a,c)
[1, 2, 3] [1, 22222, 3] #a值不變,c的第二個值變了，這就是copy和‘==’的不同

深拷貝.deepcopy()，對【外圍和內部元素】都進行了拷貝對象本身，而不是對象的引用。所以原來的對象與拷貝後是兩回事。

e=copy.deepcopy(a) #e爲深拷貝了a
a[2][0]=333 #改變a中內部元素列表第一個的值
e
[1, 2, [3333, 4]] #因爲是深拷貝，這時e中內部元素[]列表的值不會因爲a中的值改變而改變

21.多線程threading

import threading

def thread_job():
print(‘T1 start’)
for i in range(10):
time.sleep(0.1)
print(‘T1 finish\n’)

def t2_job():
print(‘T2 start’)
print(‘T2 finish\n’)

def main():
added_thread=threading.Thread(target=thread_job,name=‘T’) #添加線程及其工作、名字
thread2=threading.Thread(target=t2_job,name=‘T2’)
added_thread.start() #運行線程
added_thread.join()
print(‘all done’)
#print(threading.active_count()) #當前激活的線程數目
#print(threading.enumerate()) #當前激活的線程名稱
#print(threading.current_thread())#當前正在運行的程序 的線程

if name==‘main’

輸出結果(不加join時)：T1 start
all done

過了一會 T1 finish

加join時：T1 start
T1 finish
all done
join作用：等線程運行完成後才運行後面的語句

added_thread.start()
t2.start()
t2.join()
打印：t1 start
t2 start

      t2 finish

      all done
     
      t1.finish

added_thread.start()
t2.start()
t1.join()
t2.join()
打印：
t1 start
t2 start

      t2 finish

      t1.finish

      all done

多線程無法返回，可以把結果放進一個queue
GIL不一定有效率，在不停地切換線程，讀寫的時間可以運行下一個線程，時間少一點點
加鎖lock= threading.lock()
lock.acquire()
// 操作
lock.release()

22.多進程multiprocessing

import multiprocessing as mp
#與創建線程類似

多進程必須在main下調用
if name==‘main’
q=mp.Queue() #q.get()一次會少一次
p1=mp.multiprocessing(target=t2_job,args=(q,)) #注意這裏job沒括號，是引用，不是調用;args只有一個參數時後面要加，說明它是一個可以迭代的東西
p1.start()
p1.join()

用queue存儲多進程的運算結果，job與多進程同樣不能有return ,將queue作爲參數傳入job函數

進程池pool裏面job函數可以return
pool=mp.Pool(process=2)# 指定cpu核數爲2，空參默認全部核數
res=pool.map(job,range(10))#將job返回值綁定到res，自己分進程
print res
pool.apply_asyc(job,(i,)) for i in range(10) #一次只會把任務推給一個進程

23.Tkinter

Tkinter 是使用 python 進行窗口視窗設計的模塊.

import tkinter as tk

window=tk.Tk()
window.title(’ xxx’)
window.geometry(‘200x100’)

24.pickle

pickle 是一個 python 中, 壓縮/保存/提取 文件的模塊. 最一般的使用方式非常簡單. 比如下面就是壓縮並保存一個字典的方式. 字典和列表都是能被保存的.

—>待續