Python入門-基礎文法筆記

1.vi技巧：

中英切換：shift

wq = x

2.注釋

單行：#

多行：三個單引号或三個雙引号

"""
print("hello world")  
"""

3.編碼

檔案中有中文，不管是否為注釋，python2執行報錯。

解決：程式首行加 #coding=utf-8 或 #*-* coding:utf-8 *-*

4.輸入

5.輸出

print("name is %s"%name)   
print("name:%s, age:%d"%(name,age))  
print("name:{0}, age:{1}".format(name,age)) #(标号可不寫，為預設順序) 
print("name:{name}, age:{age}".format(name = "ss",age = 23)) 

import math
print('常量 PI 的值近似為 {0:.3f}。'.format(math.pi)) #常量 PI 的值近似為 3.142。

table = {'Google': 1, 'Runoob': 2, 'Taobao': 3}
print('Runoob: {0[Runoob]:d}; Google: {0[Google]:d}; Taobao: {0[Taobao]:d}'.format(table))
#Runoob: 2; Google: 1; Taobao: 3

table = {'Google': 1, 'Runoob': 2, 'Taobao': 3}
print('Runoob: {Runoob:d}; Google: {Google:d}; Taobao: {Taobao:d}'.format(**table))
#Runoob: 2; Google: 1; Taobao: 3

6.類型轉換

7.python2與python3

編碼。
python2中input的内容當做執行的内容，python3當做字元串。如a = input(""). python2中的raw_input相當于python3中的input。
python2 中支援 <> 是不等于的意思，python3不支援，應該 != 表示

8.運算符

"a" * 5 = "aaaaa"
2 ** 3 = 8
5 / 2 = 2.5
5 // 2 = 2 #(取商)
5 % 2 = 1 #（取餘）

9.邏輯運算符

and , or

10.流程

if 1 > 2:
    print("1")
elif 2 == 3:
    print("2")
else:
    print("3")
 

while 條件:  
    執行

for i int str:  
 執行
 
注: i++,++i在python中不允許使用。

11.字元串(不可變)

格式化

>>>'a: %s, b:%s' %s ('a', 'b')
'a: a, b: b'

>>> '{}, {} and {}'.format("first", "second", "third")
'first, second and third'

>>> '{3} {0} {2} {1} {3} {0}'.format('be', 'not', 'or', 'to')
'to be or not to be'

>>> "{name} is approximately {value:.2f}.".format(value=pi,name="π")
'π is approximately 3.14.'

#python3 中，同名可省略
>>> from math import e
>>> f"Euler's constant is roughly {e}."

>>> f"Euler's constant is roughly {e}.".format(e=e)

#格式
>>> 'the number is {num:f}'.format(num=2)
'the number is 2.000000'

類型轉換：

長度：

字元串連接配接:

a = b + c  #或者
a = "===%s==="%(b+c)  #或者
a = "==={}===".format(b+c)

切片：

str = "dasfaf"
str[2:4] #(取得2到3的),  
str[2:]  #(到最後),  
str[2:-1:2] #(步長2，隔一個取一個)

逆序:

str = "abcdefABCDEF"  
str[0:]  # out:"abcdefABCDEF"  
str[-1:]  # out:"F"  
str[-1:0]  # out:""  
str[-1:0:-1]  # out:"FEDCBAfedcb"  
str[-1::-1], str[::-1]  # out:"FEDCBAfedcba"

常見操作

find: str.find("abc") # 從左向右有傳回第一個比對字元串的起始下标，沒有傳回-1。rfind():從右向左。  
str.index("abc") #找到傳回起始下标，沒有抛出異常。 存在rindex().  
str.count("abc") #比對的個數。

str.replace("abc", "def") #把左邊的替換成右邊的同java，  
str.replace("abc", "def",1) #第三個參數是從左到右替換個數。  

str.split(" ") #字元串分割   
str.capitalize() #字元串的第一個字母大寫。  
str.title() #字元串的每個單詞的首字母大寫。  
str.startswith("abc"), str.endswith("abc") #是否以此字元串開頭或結尾.  
str.lower() str.uper() #所有的字母小寫和大寫。  
str.center(50) #居中顯示，行總長50 "     abc     " 
str.ljust(50), str.rjust(50) #左(右)對齊

str.lstrip() #删除左邊空格
str.rstrip() #右邊空格
str.strip() #删除兩端空格.

#center居中
>>> 'hello world'.center(20)
'    hello world     '
>>> 'hello world'.center(20, '*')
'****hello world*****'

12.清單 (類似數組，可變，針對自身的變化)

["zhangsan","lisi"]
#定義
names = ["zhangsan", "lisi", 3.14]  #清單中的資料可以是不同的資料類型。  可以下标，和切片。
#增
names.append("abc") #-->插入到最後;  
names.insert(0, "bcc") #-->插入指定位置。  

names = names1 + names2 #兩個清單用連接配接符
names1.extend(names2) #擴充

#删
names.pop() #-->删除最後一個；  
names.remove("lisi") #-->根據内容删除;  
del names[0] #-->下标删除  
#改
names[0] = "abc"  
#查
name[1:] # "lisi"
in, not in #是否存在 （if "zhangsan" in names:）  
#可以for... in 循環周遊

len(names) #元素個數

#注意：append添加的元素；extend連接配接的清單

# 其他
''.join(list) # 清單轉字元串
names.sort() #排序，改變原結構; names.sort(reverse=True) 反向順序

運算符

表達式	結果	描述
len([1, 2, 3])	3	計算元素個數
[1, 2, 3] + [4, 5, 6]	[1, 2, 3, 4, 5, 6]	連接配接
[‘Hi!’] * 4	[‘Hi!’, ‘Hi!’, ‘Hi!’, ‘Hi!’]	複制
3 in [1, 2, 3]	True	元素是否存在
for x in [1, 2, 3]: print(x, end=" ")	1 2 3	疊代

params = {"server":"mpilgrim", "database":"master", "uid":"sa", "pwd":"secret"}
["%s=%s" % (k, v) for k, v in params.items()]
['server=mpilgrim', 'uid=sa', 'database=master', 'pwd=secret']
";".join(["%s=%s" % (k, v) for k, v in params.items()])
'server=mpilgrim;uid=sa;database=master;pwd=secret'

13.字典（可變）

a = {"name":"yy", "age": 12}

#增
a["name"] = "yy" #直接寫key-value  
#删
del a["name"]
#改
a["name"] = "zz" #相同key的值覆寫。
#查：
a["name"], a.get("name")

for-else

#for中沒有break,則else一定會執行
for temp in strs:  
   print(temp)    
else:  
   print("")

const 修改變量為不可變。

字典常見操作

len(a) #鍵值對的個數

a.keys() #["name","age"] (pyhton2) #dict_keys(["name","age"])(pyhton3)傳回key的清單
if "abc" in a.keys(): #判斷是否存在某個key
    print("")
a.values() #傳回value的清單

14.元組(類似清單，不可變)

清單可以增删改，元組不能改

>>> tup1 = (50)
>>> type(tup1)     # 不加逗号，類型為整型
<class 'int'>

>>> tup1 = (50,)
>>> type(tup1)     # 加上逗号，類型為元組
<class 'tuple'>

通路：

tup1 = ('Google', 'Runoob', 1997, 2000)
tup2 = (1, 2, 3, 4, 5, 6, 7 )

print ("tup1[0]: ", tup1[0]) # Google
print ("tup2[1:5]: ", tup2[1:5]) #(2, 3, 4, 5)

修改：

tup1 = (12, 34.56);
tup2 = ('abc', 'xyz')

# 以下修改元組元素操作是非法的。
# tup1[0] = 100

# 建立一個新的元組
tup3 = tup1 + tup2;
print (tup3) #(12, 34.56, 'abc', 'xyz')

删除

tup = ('Google', 'Runoob', 1997, 2000)

print (tup)
del tup;

運算符

表達式	結果	描述
len((1, 2, 3))	3	計算元素個數
(1, 2, 3) + (4, 5, 6)	(1, 2, 3, 4, 5, 6)	連接配接
(‘Hi!’) * 4	(‘Hi!’, ‘Hi!’, ‘Hi!’, ‘Hi!’)	複制
3 in (1, 2, 3)	True	元素是否存在
for x in (1, 2, 3): print x,	1 2 3	疊代

類似拆包

a = (11,12)
b = a
b #out (11,12)
c,d = a #類似拆包
c #out 11
d #out 12

#例如
info = {"name":"ysw", "age":24}
for temp in info:
    print(temp)
#("name":"ysw")
#("age":24)
for temp in info.items():
    print("key=%s,value=%s"%(temp[0],temp[1]))
#or
for a,b in info.items():
    print("key=%s,value=%s"%(a,b))

周遊技巧：

#在字典中周遊時，關鍵字和對應的值可以使用 items() 方法同時解讀出來
knights = {'gallahad': 'the pure', 'robin': 'the brave'}
for k, v in knights.items():
          print(k, v)
          
  #gallahad the pure 
  #robin the brave

#在序列中周遊時，索引位置和對應值可以使用 enumerate() 函數同時得到
>>> for i, v in enumerate(['tic', 'tac', 'toe']):
...     print(i, v)
...
0 tic
1 tac
2 toe

#同時周遊兩個或更多的序列，可以使用 zip() 組合
>>> questions = ['name', 'quest', 'favorite color']
>>> answers = ['lancelot', 'the holy grail', 'blue']
>>> for q, a in zip(questions, answers):
...     print('What is your {0}?  It is {1}.'.format(q, a))
...
What is your name?  It is lancelot.
What is your quest?  It is the holy grail.
What is your favorite color?  It is blue.

#要反向周遊一個序列，首先指定這個序列，然後調用 reversed() 函數
>>> for i in reversed(range(1, 10, 2)):
...     print(i)
...
9
7
5
3
1

#要按順序周遊一個序列，使用 sorted() 函數傳回一個已排序的序列，并不修改原值
>>> basket = ['apple', 'orange', 'apple', 'pear', 'orange', 'banana']
>>> for f in sorted(set(basket)):
...     print(f)
...
apple
banana
orange
pear

15.函數

def abc():
    print("")
    
abc()
#注意： 函數的定義需要在函數的調用之前，否則報錯。

可更改與不可更改對象：

在python中，strings,tuples和numbers是不可更改對象，list.dict等則是可更改對象。

不可變類型：變量指派 a=5後在指派a=10,生成了新的對象，原對象丢棄。
可變類型：變量指派 la=[1,2,3,4] 後再指派 la[2]=5 則是将 list la 的第三個元素值更改，本身la沒有動，隻是其内部的一部分值被修改了。

python 函數的參數傳遞：

不可變類型:類似 c++ 的值傳遞，如整數、字元串、元組。如fun（a），傳遞的隻是a的值，沒有影響a對象本身。比如在 fun（a）内部修改 a 的值，隻是修改另一個複制的對象，不會影響 a 本身
可變類型：類似 c++ 的引用傳遞，如清單，字典。如 fun（la），則是将 la 真正的傳過去，修改後fun外部的la也會受影響

#預設函數參數

def printinfo( name, age = 35 ):
   "列印任何傳入的字元串"
   print ("名字: ", name);
   print ("年齡: ", age);
   return;
   
printinfo( age=50, name="runoob" );
print ("------------------------")
printinfo( name="runoob" );

#名字:  runoob
#年齡:  50
#------------------------
#名字:  runoob
#年齡:  35

#可變參數
def printinfo( *vartuple ):
   "列印任何傳入的參數"
   print ("輸出: ")
   for var in vartuple:
      print (var)
   return;

printinfo(10,32,22)

#匿名函數(lambda建立匿名函數)

sum = lambda arg1, arg2: arg1 + arg2;
 
print ("相加後的值為 : ", sum( 10, 20 ))
print ("相加後的值為 : ", sum( 20, 20 ))

#global關鍵字修改外部作用域變量
num = 1
def fun1():
    global num  # 需要使用 global 關鍵字聲明
    print(num) 
    num = 123
    print(num)
fun1()

#1
#123

#nonlocal 修改嵌套作用域變量
def outer():
    num = 10
    def inner():
        nonlocal num   # nonlocal關鍵字聲明
        num = 100
        print(num)
    inner()
    print(num)
outer()

#100
#100

16.疊代器和生成器

字元串，清單和元組對象都可用于建立疊代器。

list = [1,2,3,4]
it = iter(list)
print(next(it)) #1
print(next(it)) #2

#周遊
#1
for x in it:
    print(x, end = "") # 1 2 3 4
    
#2
while True:
    try:
        print(next(it))
    except StopIteration:
        sys.exit()

生成器(TODO: 待了解)

yield的函數，生成器是傳回疊代器的函數，隻能用于疊代操作。

import sys
 
def fibonacci(n): # 生成器函數 - 斐波那契
    a, b, counter = 0, 1, 0
    while True:
        if (counter > n): 
            return
        yield a
        a, b = b, a + b
        counter += 1
f = fibonacci(10) # f 是一個疊代器，由生成器傳回生成
 
while True:
    try:
        print (next(f), end=" ")
    except StopIteration:
        sys.exit()
# 0 1 1 2 3 5 8 13 21 34 55

17.子產品

為此 Python 提供了一個辦法，把這些定義存放在檔案中，為一些腳本或者互動式的解釋器執行個體使用，這個檔案被稱為子產品。

import語句，想使用 Python 源檔案，隻需在另一個源檔案裡執行 import 語句。

#!/usr/bin/python3
# Filename: support.py

def print_func( par ):
    print ("Hello : ", par)
    return

#!/usr/bin/python3
# Filename: test.py
 
# 導入子產品
import support #檔案名
 
# 現在可以調用子產品裡包含的函數了
support.print_func("Runoob")

from…import語句,從子產品中導入一個指定的部分到目前命名空間中。

#導入子產品 fibo 的 fib 函數
from fibo import fib, fib2
>>> fib(500)

From…import* 語句，把一個子產品的所有内容全都導入到目前的命名空間。
子產品除了方法定義，還可以包括可執行的代碼。這些代碼一般用來初始化這個子產品。這些代碼隻有在第一次被導入時才會被執行。
_name_屬性,一個子產品被另一個程式第一次引入時，其主程式将運作。如果我們想在子產品被引入時，子產品中的某一程式塊不執行,可以用__name__屬性。

#!/usr/bin/python3
# Filename: using_name.py

if __name__ == '__main__':
   print('程式自身在運作')
else:
   print('我來自另一子產品')

Python 會根據 sys.path 中的目錄來尋找這個包中包含的子目錄。
目錄隻有包含一個叫做 init.py 的檔案才會被認作是一個包，主要是為了避免一些濫俗的名字（比如叫做 string）不小心的影響搜尋路徑中的有效子產品。
推薦：from Package import specific_submodule

18.檔案

open()方法傳回檔案，第二個參數為檔案打開方式。預設隻讀r。w寫，a追加…

f = open("/tmp/test.txt","w")

f.write("人生苦短，我用python！")

f.close()

f.read(size) 讀取檔案内容，size為空或負數則全部傳回。
f.readline() f.readline() 會從檔案中讀取單獨的一行。換行符為 ‘\n’。f.readline() 如果傳回一個空字元串, 說明已經已經讀取到最後一行。
f.readlines() 讀取檔案所有行，并以清單傳回。
f.write(string) 将 string 寫入到檔案中, 然後傳回寫入的字元數。如果要寫入一些不是字元串的東西, 那麼将需要先進行轉換。

19.類

類方法

class MyClass:
    i = 12345
    #類方法必須有一個額外的第一個參數，慣例是self，不固定；代表的的類的執行個體而非類
    def f(self):
        return "hello world"

x = MyClass()
print("MyClass 類的屬性 i 為：", x.i)
print("MyClass 類的方法 f 輸出為：", x.f())

構造方法

class Complex:
    #構造方法
    def __init__(self, realpart, imagpart):
        self.r = realpart
        self.i = imagpart
x = Complex(3.0, -4.5)
print(x.r, x.i)   # 輸出結果：3.0 -4.5

#類定義
class people:
    #定義基本屬性
    name = ''
    age = 0
    #定義私有屬性,私有屬性在類外部無法直接進行通路
    __weight = 0
    #定義構造方法
    def __init__(self,n,a,w):
        self.name = n
        self.age = a
        self.__weight = w
    def speak(self):
        print("%s 說: 我 %d 歲。" %(self.name,self.age))
 
# 執行個體化類
p = people('runoob',10,30)
p.speak()

繼承

#類定義
class people:
    #定義基本屬性
    name = ''
    age = 0
    #定義私有屬性,私有屬性在類外部無法直接進行通路
    __weight = 0
    #定義構造方法
    def __init__(self,n,a,w):
        self.name = n
        self.age = a
        self.__weight = w
    def speak(self):
        print("%s 說: 我 %d 歲。" %(self.name,self.age))
 
#單繼承示例
class student(people):
    grade = ''
    def __init__(self,n,a,w,g):
        #調用父類的構函
        people.__init__(self,n,a,w)
        self.grade = g
    #覆寫父類的方法
    def speak(self):
        print("%s 說: 我 %d 歲了，我在讀 %d 年級"%(self.name,self.age,self.grade))
 
#另一個類，多重繼承之前的準備
class speaker():
    topic = ''
    name = ''
    def __init__(self,n,t):
        self.name = n
        self.topic = t
    def speak(self):
        print("我叫 %s，我是一個演說家，我演講的主題是 %s"%(self.name,self.topic))
 
#多重繼承
class sample(speaker,student):
    a =''
    def __init__(self,n,a,w,g,t):
        student.__init__(self,n,a,w,g)
        speaker.__init__(self,n,t)
 
test = sample("Tim",25,80,4,"Python")
test.speak()   #方法名同，預設調用的是在括号中排前地父類的方法

20.正規表達式

re.match與re.search的差別

re.match隻比對字元串的開始，如果字元串開始不符合正規表達式，則比對失敗，函數傳回None；而re.search比對整個字元串，直到找到一個比對。

import re

line = "Cats are smarter than dogs";

matchObj = re.match( r'dogs', line, re.M|re.I)
if matchObj:
   print ("match --> matchObj.group() : ", matchObj.group())
else:
   print ("No match!!")

matchObj = re.search( r'dogs', line, re.M|re.I)
if matchObj:
   print ("search --> matchObj.group() : ", matchObj.group())
else:
   print ("No match!!")
   
#No match!!
#search --> matchObj.group() :  dogs

檢索和替換

import re

phone = "2004-959-559 # 這是一個電話号碼"

# 删除注釋
num = re.sub(r'#.*$', "", phone)
print ("電話号碼 : ", num)

# 移除非數字的内容
num = re.sub(r'\D', "", phone)
print ("電話号碼 : ", num)

#電話号碼 :  2004-959-559 
#電話号碼 :  2004959559

Python入門-基礎文法筆記

1.vi技巧：

2.注釋

3.編碼

4.輸入

5.輸出

6.類型轉換

7.python2與python3

8.運算符

9.邏輯運算符

10.流程

11.字元串(不可變)

12.清單 (類似數組，可變，針對自身的變化)

13.字典（可變）

14.元組(類似清單，不可變)

15.函數

16.疊代器和生成器

17.子產品

18.檔案

19.類

20.正規表達式

繼續閱讀

來自python的【條件控制/語句循環/break/continue/else/pass】一、條件控制二、語句循環

無法解析的外部符号 wmain，該符号在函數 "void cdecl mainCRTStartupHelper(struct HINSTANCE *,unsigned short con......

TestLink導出用例轉換工具(XML2Excel)

YAML簡介和PyYAML安全操作YAML支援的類型YAML的優點：yaml的基本文法python操作

Small tricks

libsvm for python 安裝

學習軟體測試基礎測試第七天

Zeppelin 配置通路 REST APIApache Zeppelin Configuration REST API

【Torch】最簡潔logging使用指南

27. Remove Element(清單)題目代碼

Cloud Studio初體驗

使用 ctypes 進行 Python 和 C 的混合程式設計

【python】【資料處理】畫多元資料分布圖

【python】netconf協定對接管理裝置

「Python 網絡自動化」NETCONF —— Python 使用 NETCONF 管理配置 H3C 網絡裝置

在python中建立excel并寫入