Python語法基礎

時間 2019-11-17

標籤 python 語法基礎欄目 Python 简体版

原文原文鏈接

設置環境變量python

Linux：
$ PATH=$PATH:/usr/local/python3/bin/python3    # 設置環境變量
$ python3 --version
Python 3.4.0

Windows:
set path=%path%;C:\python34

一、在Linux下使用下面的代碼能夠直接./xxx.py執行腳本，在Windows下不能夠：#!/usr/bin/python3express

二、執行腳本：$ python3 hello.pyjson

三、字符編碼，須要寫在文件的開頭，好比支持中文編碼：
# -*- coding: UTF-8 -*- 或者 #coding=utf-8，函數

#coding=utf-8

import json  

student = {}
student['Name'] = '張三'
student['Age'] = 18
student[12] = True

print json.dumps(student, ensure_ascii=False, encoding='utf-8')

注意：#coding=utf-8 的 = 號兩邊不要空格，且utf-8必須爲小寫。工具

四、關鍵字：>>> import keyword，>>> keyword.kwlist
['False', 'None', 'True', 'and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']測試

五、代碼註釋：#!/usr/bin/python3，也可使用''' XXX'''和"""XXX"""，即連續的3個單引號或雙引號ui

#單引號註釋
#!/usr/bin/python3 
'''
這是多行註釋，用三個單引號
這是多行註釋，用三個單引號 
這是多行註釋，用三個單引號
'''
print("Hello, World!") 

#雙引號註釋
#!/usr/bin/python3 
"""
這是多行註釋，用三個單引號
這是多行註釋，用三個單引號 
這是多行註釋，用三個單引號
"""
print("Hello, World!")

六、代碼塊：python最具特點的就是使用縮進來表示代碼塊，不須要使用大括號({})。縮進的空格數是可變的，可是同一個代碼塊的語句必須包含相同的縮進空格數，縮進不一致，會致使運行錯誤。this

七、多行語句：使用反斜槓(\)來實現多行語句，在 [], {}, 或 () 中的多行語句，不須要使用反斜槓(\)：編碼

total = item_one + \
        item_two + \
        item_three
在 [], {}, 或 () 中的多行語句，不須要使用反斜槓(\)，例如：
total = ['item_one', 'item_two', 'item_three',
        'item_four', 'item_five']

注意！多行的內容都屬於同一塊，所以縮進必定要一致。.net

八、數據類型：python中數有四種類型：整數、長整數、浮點數和複數。
整數，如 1
長整數是比較大的整數
浮點數如 1.2三、3E-2
複數如 1 + 2j、 1.1 + 2.2j

九、字符串：python中單引號和雙引號使用徹底相同。使用三引號('''或""")能夠指定一個多行字符串。
轉義符 '\'天然字符串，經過在字符串前加r或R。如 r"this is a line with \n" 則\n會顯示，並非換行。
python容許處理unicode字符串，加前綴u或U，如 u"this is an unicode string"。
字符串是不可變的。按字面意義級聯字符串，如"this " "is " "string"會被自動轉換爲this is string。
word = '字符串'
sentence = "這是一個句子。"
paragraph = """這是一個段落，
能夠由多行組成"""

十、代碼組：

if expression : 
   suite
elif expression : 
   suite 
else : 
   suite

十一、換行輸出：print("xxx")，
不換行輸出：print( x, end=" " )或
print( y, end="END" )
print(a, b, c, d, e, sep='+')，輸出abcde並使用+號鏈接。

十二、導入模塊：

將整個模塊(somemodule)導入，格式爲： import somemodule
從某個模塊中導入某個函數,格式爲： from somemodule import somefunction
從某個模塊中導入多個函數,格式爲： from somemodule import firstfunc, secondfunc, thirdfunc
將某個模塊中的所有函數導入，格式爲： from somemodule import *

1三、help() 函數：調用 python 的 help() 函數能夠打印輸出一個函數的文檔字符串，按下 : q 兩個按鍵即退出說明文檔

1四、多個變量同時賦值：a, b, c = 1, 2, "runoob"

1五、Python3 中有六個標準的數據類型：
        Number（數字）
        String（字符串）
        List（列表）
        Tuple（元組）
        Sets（集合）
        Dictionary（字典）

1六、Python3 支持 int、float、bool、complex。內置的 type() 函數能夠用來查詢變量所指的對象類型：

type()來判斷數據的類型：
>>> a, b, c, d = 20, 5.5, True, 4+3j
>>> print(type(a), type(b), type(c), type(d))
<class 'int'> <class 'float'> <class 'bool'> <class 'complex'>
能夠用 isinstance 來判斷：
>>>a = 111
>>> isinstance(a, int)
True
>>>
isinstance 和 type 的區別在於：
class A:
    pass

class B(A):
    pass

isinstance(A(), A)  # returns True
type(A()) == A      # returns True
isinstance(B(), A)    # returns True
type(B()) == A        # returns False
區別就是:
type()不會認爲子類是一種父類類型。
isinstance()會認爲子類是一種父類類型。

1七、字符串：Python中的字符串用單引號(')或雙引號(")括起來，同時使用反斜槓(\)轉義特殊字符：

str = 'Runoob'
print (str)          # 輸出字符串
print (str[0:-1])    # 輸出第一個到倒數第二個的全部字符
print (str[0])       # 輸出字符串第一個字符
print (str[2:5])     # 輸出從第三個開始到第五個的字符
print (str[2:])      # 輸出從第三個開始的後的全部字符
print (str * 2)      # 輸出字符串兩次
print (str + "TEST") # 鏈接字符串

字符串的這種輸出方式一樣適用於列表等其餘集合數據類型。與 C 字符串不一樣的是，Python 字符串不能被改變。向一個索引位置賦值，好比word[0] = 'm'會致使錯誤。

1八、列表：列表支持使用不一樣的數據類型組成同一個列表：

#!/usr/bin/python3
 
list = [ 'abcd', 786 , 2.23, 'runoob', 70.2 ]
tinylist = [123, 'runoob']
 
print (list)            # 輸出完整列表
print (list[0])         # 輸出列表第一個元素
print (list[1:3])       # 從第二個開始輸出到第三個元素
print (list[2:])        # 輸出從第三個元素開始的全部元素
print (tinylist * 2)    # 輸出兩次列表
print (list + tinylist) # 鏈接列表

與Python字符串不同的是，列表中的元素是能夠改變的：

1九、元組：元組與列表相似，不一樣之處在於元組的元素不能修改：

#!/usr/bin/python3
 
tuple = ( 'abcd', 786 , 2.23, 'runoob', 70.2  )
tinytuple = (123, 'runoob')
 
print (tuple)             # 輸出完整元組
print (tuple[0])          # 輸出元組的第一個元素
print (tuple[1:3])        # 輸出從第二個元素開始到第三個元素
print (tuple[2:])         # 輸出從第三個元素開始的全部元素
print (tinytuple * 2)     # 輸出兩次元組
print (tuple + tinytuple) # 鏈接元組

20、集合：是一個無序不重複元素的序列：

#!/usr/bin/python3
 
student = {'Tom', 'Jim', 'Mary', 'Tom', 'Jack', 'Rose'}
 
print(student)   # 輸出集合，重複的元素被自動去掉
 
# 成員測試
if('Rose' in student) :
    print('Rose 在集合中')
else :
    print('Rose 不在集合中')
 
 
# set能夠進行集合運算
a = set('abracadabra')
b = set('alacazam')
 
print(a)
 
print(a - b)     # a和b的差集
 
print(a | b)     # a和b的並集
 
print(a & b)     # a和b的交集
 
print(a ^ b)     # a和b中不一樣時存在的元素

注意：建立一個空集合必須用 set() 而不是 { }，由於 { } 是用來建立一個空字典。

2一、字典：是經過key-value來存取數據：

#!/usr/bin/python3
 
dict = {}
dict['one'] = "1 - 菜鳥教程"
dict[2]     = "2 - 菜鳥工具"
 
tinydict = {'name': 'runoob','code':1, 'site': 'www.runoob.com'}
 
 
print (dict['one'])       # 輸出鍵爲 'one' 的值
print (dict[2])           # 輸出鍵爲 2 的值
print (tinydict)          # 輸出完整的字典
print (tinydict.keys())   # 輸出全部鍵
print (tinydict.values()) # 輸出全部值

輸出結果：

1 - 菜鳥教程
2 - 菜鳥工具
{'name': 'runoob', 'site': 'www.runoob.com', 'code': 1}
dict_keys(['name', 'site', 'code'])
dict_values(['runoob', 'www.runoob.com', 1])

注意：

一、字典是一種映射類型，它的元素是鍵值對。

二、字典的關鍵字必須爲不可變類型，且不能重複。

三、建立空字典使用 { }。

四、不容許同一個鍵出現兩次。建立時若是同一個鍵被賦值兩次，後一個值會被記住

五、鍵必須不可變，因此能夠用數字，字符串或元組充當，而用列表就不行

字典是支持無限極嵌套的，以下面代碼：

citys={
    '北京':{
        '朝陽':['國貿','CBD','天階','我愛我家','連接地產'],
        '海淀':['圓明園','蘇州街','中關村','北京大學'],
        '昌平':['沙河','南口','小湯山',],
        '懷柔':['桃花','梅花','大山'],
        '密雲':['密雲A','密雲B','密雲C']
    },
    '河北':{
        '石家莊':['石家莊A','石家莊B','石家莊C','石家莊D','石家莊E'],
        '張家口':['張家口A','張家口B','張家口C'],
        '承德':['承德A','承德B','承德C','承德D']
    }
}

可使用以下方法進行列出:

for i in citys['北京']:
    print(i)

將列出以下結果：

朝陽
海淀
昌平
懷柔
密雲

for i in citys['北京']['海淀']:
    print(i)

輸出以下結果：

圓明園
蘇州街
中關村
北京大學

2二、數據類型轉換：

int(x [,base])將x轉換爲一個整數
float(x)將x轉換到一個浮點數
complex(real [,imag])建立一個複數
str(x)將對象 x 轉換爲字符串
repr(x)將對象 x 轉換爲表達式字符串
eval(str)用來計算在字符串中的有效Python表達式,並返回一個對象
tuple(s)將序列 s 轉換爲一個元組
list(s)將序列 s 轉換爲一個列表
set(s)轉換爲可變集合
dict(d)建立一個字典。d 必須是一個序列 (key,value)元組。
frozenset(s)轉換爲不可變集合
chr(x)將一個整數轉換爲一個字符
ord(x)將一個字符轉換爲它的整數值
hex(x)將一個整數轉換爲一個十六進制字符串
oct(x)將一個整數轉換爲一個八進制字符串

2三、python 使用 lambda 來建立匿名函數。

所謂匿名，意即再也不使用 def 語句這樣標準的形式定義一個函數。

lambda 只是一個表達式，函數體比 def 簡單不少。
lambda的主體是一個表達式，而不是一個代碼塊。僅僅能在lambda表達式中封裝有限的邏輯進去。
lambda 函數擁有本身的命名空間，且不能訪問本身參數列表以外或全局命名空間裏的參數。
雖然lambda函數看起來只能寫一行，卻不等同於C或C++的內聯函數，後者的目的是調用小函數時不佔用棧內存從而增長運行效率。

#!/usr/bin/python3
 
# 可寫函數說明
sum = lambda arg1, arg2: arg1 + arg2;
 
# 調用sum函數
print ("相加後的值爲 : ", sum( 10, 20 ))
print ("相加後的值爲 : ", sum( 20, 20 ))

2四、Python做用域：
Python 中只有模塊（module），類（class）以及函數（def、lambda）纔會引入新的做用域，其它的代碼塊（如 if/elif/else/、try/except、for/while等）是不會引入新的做用域的，也就是說這這些語句內定義的變量，外部也能夠訪問，以下代碼：

>>> def test():
...     msg_inner = 'I am from Runoob'

>>> if True:
...  msg = 'I am from Runoob'
... 
>>> msg
'I am from Runoob'
>>>

在if中定義的變量msg能夠在外部繼續訪問，而定義在函數test()內的msg_inner變量只能在函數內訪問。

2五、遍歷字典和列表

#字典遍歷
knights = {'gallahad': 'the pure', 'robin': 'the brave'}
#遍歷keys
for a in knights.keys():
	print(a)
#遍歷values
for a in knights.values():
	print(a)
#同時遍歷keys和values
for k, v in knights.items():
	print(k, v, sep=':')
	
#列表遍歷
mylst = ['tic', 'tac', 'toe']
for a in mylst :
	print(a)
#遍歷列表和索引
for i, v in enumerate(mylst):
	print(i, v, sep=':')
#反向遍歷列表
for v in reversed(mylst):
	print(v)
#遍歷排序後的列表
for v in sorted(mylst):
	print(v)

2六、文件讀寫

cities = {
	'北京':{
		'海淀區',
		'朝陽區'
	},
	'廣州':{
		'番禺區',
		'海珠區'
	}
}

# 打開一個文件
f = open("temp.txt", "w")
s = str(cities)

#寫入數據到文件
f.write(s)

# 關閉打開的文件
f.close()

#打開讀取文件
f2 = open("temp.txt", "r")

#讀取所有行
print(f2.readlines())

#關閉讀取文件
f2.close()

2七、對象序列化和反序列化

#對象序列化
import pickle

# 使用pickle模塊將數據對象保存到文件
data1 = {'a': [1, 2.0, 3, 4+6j],
         'b': ('string', u'Unicode string'),
         'c': None}

selfref_list = [1, 2, 3]

output = open('data.pkl', 'wb')

# Pickle dictionary using protocol 0.
pickle.dump(data1, output)

# Pickle the list using the highest protocol available.
pickle.dump(selfref_list, output, -1)

output.close()


#對象反序列化，使用pprint和print好像同樣？
import pprint, pickle

#使用pickle模塊從文件中重構python對象
pkl_file = open('data.pkl', 'rb')

data1 = pickle.load(pkl_file)
pprint.pprint(data1)
print(data1)

data2 = pickle.load(pkl_file)
pprint.pprint(data2)
print(data2)

pkl_file.close()

2八、異常處理try..exception..finally

import sys

#自定義異常處理類
class MyError(Exception):
	def __init__(self, value):
		self.value = value
	def __str__(self):
		return repr(self.value)
			
#產生異常的除法函數
def DivNum(x, y):
	if y == 0:
		raise NameError('除數不能爲零') #除數爲零拋出異常
	elif y < 0:
		raise MyError("除數不能小於零")
	else:
		return x / y;

try:
	f = DivNum(10, -1)
	print(f)
except NameError as err:
	print("OS error: {0}".format(err))
except ValueError:
    print("Could not convert data to an integer.")
except:  #或者使用else:
	print("Unexpected error:", sys.exc_info()[0], sys.exc_info()[1])
finally: #最後都會執行的代碼
	print("到此一遊！")
	
#除了可使用finally進行異常清理
#還可使用with語句進行預處理清理
with open("myfile.txt") as f:
    for line in f:
        print(line, end="")

2九、類的定義和使用

#類定義
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)
    def __add(self):  #類的私有方法和私有變量同樣使用兩根下劃線命名
        print("add")
 
test = sample("Tim",25,80,4,"Python")
test.speak()   #方法名同，默認調用的是在括號中排前地父類的方法
#test.__add()  #類的私有方法不能在類的外部調用

30、類的專有方法和運算符重載，參考：http://www.jb51.net/article/59691.htm

__init__ : 構造函數，在生成對象時調用
__del__ : 析構函數，釋放對象時使用
__repr__ : 打印，轉換
__str__：打印類自身
__setitem__ : 按照索引賦值
__getitem__: 按照索引獲取值
__len__: 得到長度
__cmp__: 比較運算
__call__: 函數調用
__add__: 加運算
__sub__: 減運算
__mul__: 乘運算
__div__: 除運算
__mod__: 求餘運算
__pow__: 乘方


#重載操做符至關於重寫上面的專有方法
class Vector:
   def __init__(self, a, b):
      self.a = a
      self.b = b
 
   def __str__(self):
      return 'Vector (%d, %d)' % (self.a, self.b)
   
   def __add__(self,other):
      return Vector(self.a + other.a, self.b + other.b)
 
v1 = Vector(2,10)
v2 = Vector(5,-2)
print (v1 + v2)

相關標籤/搜索

每日一句

每一个你不满意的现在，都有一个你没有努力的曾经。