python语法基础知识案例_Python 语法速览与实战清单
本文是對(duì)于 現(xiàn)代 Python 開(kāi)發(fā)：語(yǔ)法基礎(chǔ)與工程實(shí)踐的總結(jié)，更多 Python 相關(guān)資料參考 Python 學(xué)習(xí)與實(shí)踐資料索引；本文參考了 Python Crash Course - Cheat Sheets，pysheeet 等。本文僅包含筆者在日常工作中經(jīng)常使用的，并且認(rèn)為較為關(guān)鍵的知識(shí)點(diǎn)與語(yǔ)法，如果想要進(jìn)一步學(xué)習(xí) Python 相關(guān)內(nèi)容或者對(duì)于機(jī)器學(xué)習(xí)與數(shù)據(jù)挖掘方向感興趣，可以參考程序猿的數(shù)據(jù)科學(xué)與機(jī)器學(xué)習(xí)實(shí)戰(zhàn)手冊(cè)。
基礎(chǔ)語(yǔ)法
Python 是一門高階、動(dòng)態(tài)類型的多范式編程語(yǔ)言；定義 Python 文件的時(shí)候我們往往會(huì)先聲明文件編碼方式:
# 指定腳本調(diào)用方式
#!/usr/bin/env python
# 配置 utf-8 編碼
# -*- coding: utf-8 -*-
# 配置其他編碼
# -*- coding: -*-
# Vim 中還可以使用如下方式
# vim:fileencoding=
人生苦短，請(qǐng)用 Python，大量功能強(qiáng)大的語(yǔ)法糖的同時(shí)讓很多時(shí)候 Python 代碼看上去有點(diǎn)像偽代碼。譬如我們用 Python 實(shí)現(xiàn)的簡(jiǎn)易的快排相較于 Java 會(huì)顯得很短小精悍:
def quicksort(arr):
if len(arr) <= 1:
return arr
pivot = arr[len(arr) / 2]
left = [x for x in arr if x < pivot]
middle = [x for x in arr if x == pivot]
right = [x for x in arr if x > pivot]
return quicksort(left) + middle + quicksort(right)
print quicksort([3,6,8,10,1,2,1])
# Prints "[1, 1, 2, 3, 6, 8, 10]"
控制臺(tái)交互
可以根據(jù) __name__ 關(guān)鍵字來(lái)判斷是否是直接使用 python 命令執(zhí)行某個(gè)腳本，還是外部引用；Google 開(kāi)源的 fire 也是不錯(cuò)的快速將某個(gè)類封裝為命令行工具的框架：
import fire
class Calculator(object):
"""A simple calculator class."""
def double(self, number):
return 2 * number
if __name__ == '__main__':
fire.Fire(Calculator)
# python calculator.py double 10 # 20
# python calculator.py double --number=15 # 30
Python 2 中 print 是表達(dá)式，而 Python 3 中 print 是函數(shù)；如果希望在 Python 2 中將 print 以函數(shù)方式使用，則需要自定義引入:
from __future__ import print_function
我們也可以使用 pprint 來(lái)美化控制臺(tái)輸出內(nèi)容：
import pprint
stuff = ['spam', 'eggs', 'lumberjack', 'knights', 'ni']
pprint.pprint(stuff)
# 自定義參數(shù)
pp = pprint.PrettyPrinter(depth=6)
tup = ('spam', ('eggs', ('lumberjack', ('knights', ('ni', ('dead',('parrot', ('fresh fruit',))))))))
pp.pprint(tup)
模塊
Python 中的模塊（Module）即是 Python 源碼文件，其可以導(dǎo)出類、函數(shù)與全局變量；當(dāng)我們從某個(gè)模塊導(dǎo)入變量時(shí)，函數(shù)名往往就是命名空間（Namespace）。而 Python 中的包（Package）則是模塊的文件夾，往往由 __init__.py 指明某個(gè)文件夾為包:
# 文件目錄
someDir/
main.py
siblingModule.py
# siblingModule.py
def siblingModuleFun():
print('Hello from siblingModuleFun')
def siblingModuleFunTwo():
print('Hello from siblingModuleFunTwo')
import siblingModule
import siblingModule as sibMod
sibMod.siblingModuleFun()
from siblingModule import siblingModuleFun
siblingModuleFun()
try:
# Import 'someModuleA' that is only available in Windows
import someModuleA
except ImportError:
try:
# Import 'someModuleB' that is only available in Linux
import someModuleB
except ImportError:
Package 可以為某個(gè)目錄下所有的文件設(shè)置統(tǒng)一入口:
someDir/
main.py
subModules/
__init__.py
subA.py
subSubModules/
__init__.py
subSubA.py
# subA.py
def subAFun():
print('Hello from subAFun')
def subAFunTwo():
print('Hello from subAFunTwo')
# subSubA.py
def subSubAFun():
print('Hello from subSubAFun')
def subSubAFunTwo():
print('Hello from subSubAFunTwo')
# __init__.py from subDir
# Adds 'subAFun()' and 'subAFunTwo()' to the 'subDir' namespace
from .subA import *
# The following two import statement do the same thing, they add 'subSubAFun()' and 'subSubAFunTwo()' to the 'subDir' namespace. The first one assumes '__init__.py' is empty in 'subSubDir', and the second one, assumes '__init__.py' in 'subSubDir' contains 'from .subSubA import *'.
# Assumes '__init__.py' is empty in 'subSubDir'
# Adds 'subSubAFun()' and 'subSubAFunTwo()' to the 'subDir' namespace
from .subSubDir.subSubA import *
# Assumes '__init__.py' in 'subSubDir' has 'from .subSubA import *'
# Adds 'subSubAFun()' and 'subSubAFunTwo()' to the 'subDir' namespace
from .subSubDir import *
# __init__.py from subSubDir
# Adds 'subSubAFun()' and 'subSubAFunTwo()' to the 'subSubDir' namespace
from .subSubA import *
# main.py
import subDir
subDir.subAFun() # Hello from subAFun
subDir.subAFunTwo() # Hello from subAFunTwo
subDir.subSubAFun() # Hello from subSubAFun
subDir.subSubAFunTwo() # Hello from subSubAFunTwo
表達(dá)式與控制流
條件選擇
Python 中使用 if、elif、else 來(lái)進(jìn)行基礎(chǔ)的條件選擇操作：
if x < 0:
x = 0
print('Negative changed to zero')
elif x == 0:
print('Zero')
else:
print('More')
Python 同樣支持 ternary conditional operator:
a if condition else b
也可以使用 Tuple 來(lái)實(shí)現(xiàn)類似的效果：
# test 需要返回 True 或者 False
(falseValue, trueValue)[test]
# 更安全的做法是進(jìn)行強(qiáng)制判斷
(falseValue, trueValue)[test == True]
# 或者使用 bool 類型轉(zhuǎn)換函數(shù)
(falseValue, trueValue)[bool()]
循環(huán)遍歷
for-in 可以用來(lái)遍歷數(shù)組與字典：
words = ['cat', 'window', 'defenestrate']
for w in words:
print(w, len(w))
# 使用數(shù)組訪問(wèn)操作符，能夠迅速地生成數(shù)組的副本
for w in words[:]:
if len(w) > 6:
words.insert(0, w)
# words -> ['defenestrate', 'cat', 'window', 'defenestrate']
如果我們希望使用數(shù)字序列進(jìn)行遍歷，可以使用 Python 內(nèi)置的 range 函數(shù)：
a = ['Mary', 'had', 'a', 'little', 'lamb']
for i in range(len(a)):
print(i, a[i])
基本數(shù)據(jù)類型
可以使用內(nèi)建函數(shù)進(jìn)行強(qiáng)制類型轉(zhuǎn)換（Casting）:
int(str)
float(str)
str(int)
str(float)
Number: 數(shù)值類型
x = 3
print type(x) # Prints ""
print x # Prints "3"
print x + 1 # Addition; prints "4"
print x - 1 # Subtraction; prints "2"
print x * 2 # Multiplication; prints "6"
print x ** 2 # Exponentiation; prints "9"
x += 1
print x # Prints "4"
x *= 2
print x # Prints "8"
y = 2.5
print type(y) # Prints ""
print y, y + 1, y * 2, y ** 2 # Prints "2.5 3.5 5.0 6.25"
布爾類型
Python 提供了常見(jiàn)的邏輯操作符，不過(guò)需要注意的是 Python 中并沒(méi)有使用 &&、|| 等，而是直接使用了英文單詞。
t = True
f = False
print type(t) # Prints ""
print t and f # Logical AND; prints "False"
print t or f # Logical OR; prints "True"
print not t # Logical NOT; prints "False"
print t != f # Logical XOR; prints "True"
String: 字符串
Python 2 中支持 Ascii 碼的 str() 類型，獨(dú)立的 unicode() 類型，沒(méi)有 byte 類型；而 Python 3 中默認(rèn)的字符串為 utf-8 類型，并且包含了 byte 與 bytearray 兩個(gè)字節(jié)類型：
type("Guido") # string type is str in python2
#
# 使用 __future__ 中提供的模塊來(lái)降級(jí)使用 Unicode
from __future__ import unicode_literals
type("Guido") # string type become unicode
#
Python 字符串支持分片、模板字符串等常見(jiàn)操作:
var1 = 'Hello World!'
var2 = "Python Programming"
print "var1[0]: ", var1[0]
print "var2[1:5]: ", var2[1:5]
# var1[0]: H
# var2[1:5]: ytho
print "My name is %s and weight is %d kg!" % ('Zara', 21)
# My name is Zara and weight is 21 kg!
str[0:4]
len(str)
string.replace("-", " ")
",".join(list)
"hi {0}".format('j')
str.find(",")
str.index(",") # same, but raises IndexError
str.count(",")
str.split(",")
str.lower()
str.upper()
str.title()
str.lstrip()
str.rstrip()
str.strip()
str.islower()
# 移除所有的特殊字符
re.sub('[^A-Za-z0-9]+', '', mystring)
如果需要判斷是否包含某個(gè)子字符串，或者搜索某個(gè)字符串的下標(biāo):
# in 操作符可以判斷字符串
if "blah" not in somestring:
continue
# find 可以搜索下標(biāo)
s = "This be a string"
if s.find("is") == -1:
print "No 'is' here!"
else:
print "Found 'is' in the string."
Regex: 正則表達(dá)式
import re
# 判斷是否匹配
re.match(r'^[aeiou]', str)
# 以第二個(gè)參數(shù)指定的字符替換原字符串中內(nèi)容
re.sub(r'^[aeiou]', '?', str)
re.sub(r'(xyz)', r'\1', str)
# 編譯生成獨(dú)立的正則表達(dá)式對(duì)象
expr = re.compile(r'^...$')
expr.match(...)
expr.sub(...)
下面列舉了常見(jiàn)的表達(dá)式使用場(chǎng)景:
# 檢測(cè)是否為 HTML 標(biāo)簽
re.search('<[^/>][^>]*>', '')
# 常見(jiàn)的用戶名密碼
re.match('^[a-zA-Z0-9-_]{3,16}$', 'Foo') is not None
re.match('^\w|[-_]{3,16}$', 'Foo') is not None
re.match('^([a-z0-9_\.-]+)@([\da-z\.-]+)\.([a-z\.]{2,6})$', 'hello.world@example.com')
# Url
exp = re.compile(r'''^(https?:\/\/)? # match http or https
([\da-z\.-]+) # match domain
\.([a-z\.]{2,6}) # match domain
([\/\w \.-]*)\/?$ # match api or file
''', re.X)
exp.match('www.google.com')
# IP 地址
exp = re.compile(r'''^(?:(?:25[0-5]
|2[0-4][0-9]
|[1]?[0-9][0-9]?)\.){3}
(?:25[0-5]
|2[0-4][0-9]
|[1]?[0-9][0-9]?)$''', re.X)
exp.match('192.168.1.1')
集合類型
List: 列表
Operation: 創(chuàng)建增刪
list 是基礎(chǔ)的序列類型：
l = []
l = list()
# 使用字符串的 split 方法，可以將字符串轉(zhuǎn)化為列表
str.split(".")
# 如果需要將數(shù)組拼裝為字符串，則可以使用 join
list1 = ['1', '2', '3']
str1 = ''.join(list1)
# 如果是數(shù)值數(shù)組，則需要先進(jìn)行轉(zhuǎn)換
list1 = [1, 2, 3]
str1 = ''.join(str(e) for e in list1)
可以使用 append 與 extend 向數(shù)組中插入元素或者進(jìn)行數(shù)組連接
x = [1, 2, 3]
x.append([4, 5]) # [1, 2, 3, [4, 5]]
x.extend([4, 5]) # [1, 2, 3, 4, 5]，注意 extend 返回值為 None
可以使用 pop、slices、del、remove 等移除列表中元素：
myList = [10,20,30,40,50]
# 彈出第二個(gè)元素
myList.pop(1) # 20
# myList: myList.pop(1)
# 如果不加任何參數(shù)，則默認(rèn)彈出最后一個(gè)元素
myList.pop()
# 使用 slices 來(lái)刪除某個(gè)元素
a = [ 1, 2, 3, 4, 5, 6 ]
index = 3 # Only Positive index
a = a[:index] + a[index+1 :]
# 根據(jù)下標(biāo)刪除元素
myList = [10,20,30,40,50]
rmovIndxNo = 3
del myList[rmovIndxNo] # myList: [10, 20, 30, 50]
# 使用 remove 方法，直接根據(jù)元素刪除
letters = ["a", "b", "c", "d", "e"]
numbers.remove(numbers[1])
print(*letters) # used a * to make it unpack you don't have to
Iteration: 索引遍歷
你可以使用基本的 for 循環(huán)來(lái)遍歷數(shù)組中的元素，就像下面介個(gè)樣紙:
animals = ['cat', 'dog', 'monkey']
for animal in animals:
print animal
# Prints "cat", "dog", "monkey", each on its own line.
如果你在循環(huán)的同時(shí)也希望能夠獲取到當(dāng)前元素下標(biāo)，可以使用 enumerate 函數(shù):
animals = ['cat', 'dog', 'monkey']
for idx, animal in enumerate(animals):
print '#%d: %s' % (idx + 1, animal)
# Prints "#1: cat", "#2: dog", "#3: monkey", each on its own line
Python 也支持切片（Slices）:
nums = range(5) # range is a built-in function that creates a list of integers
print nums # Prints "[0, 1, 2, 3, 4]"
print nums[2:4] # Get a slice from index 2 to 4 (exclusive); prints "[2, 3]"
print nums[2:] # Get a slice from index 2 to the end; prints "[2, 3, 4]"
print nums[:2] # Get a slice from the start to index 2 (exclusive); prints "[0, 1]"
print nums[:] # Get a slice of the whole list; prints ["0, 1, 2, 3, 4]"
print nums[:-1] # Slice indices can be negative; prints ["0, 1, 2, 3]"
nums[2:4] = [8, 9] # Assign a new sublist to a slice
print nums # Prints "[0, 1, 8, 9, 4]"
Comprehensions: 變換
Python 中同樣可以使用 map、reduce、filter，map 用于變換數(shù)組:
# 使用 map 對(duì)數(shù)組中的每個(gè)元素計(jì)算平方
items = [1, 2, 3, 4, 5]
squared = list(map(lambda x: x**2, items))
# map 支持函數(shù)以數(shù)組方式連接使用
def multiply(x):
return (x*x)
def add(x):
return (x+x)
funcs = [multiply, add]
for i in range(5):
value = list(map(lambda x: x(i), funcs))
print(value)
reduce 用于進(jìn)行歸納計(jì)算:
# reduce 將數(shù)組中的值進(jìn)行歸納
from functools import reduce
product = reduce((lambda x, y: x * y), [1, 2, 3, 4])
# Output: 24
filter 則可以對(duì)數(shù)組進(jìn)行過(guò)濾:
number_list = range(-5, 5)
less_than_zero = list(filter(lambda x: x < 0, number_list))
print(less_than_zero)
# Output: [-5, -4, -3, -2, -1]
字典類型
創(chuàng)建增刪
d = {'cat': 'cute', 'dog': 'furry'} # 創(chuàng)建新的字典
print d['cat'] # 字典不支持點(diǎn)（Dot）運(yùn)算符取值
如果需要合并兩個(gè)或者多個(gè)字典類型：
# python 3.5
z = {**x, **y}
# python 2.7
def merge_dicts(*dict_args):
"""
Given any number of dicts, shallow copy and merge into a new dict,
precedence goes to key value pairs in latter dicts.
"""
result = {}
for dictionary in dict_args:
result.update(dictionary)
return result
索引遍歷
可以根據(jù)鍵來(lái)直接進(jìn)行元素訪問(wèn):
# Python 中對(duì)于訪問(wèn)不存在的鍵會(huì)拋出 KeyError 異常，需要先行判斷或者使用 get
print 'cat' in d # Check if a dictionary has a given key; prints "True"
# 如果直接使用 [] 來(lái)取值，需要先確定鍵的存在，否則會(huì)拋出異常
print d['monkey'] # KeyError: 'monkey' not a key of d
# 使用 get 函數(shù)則可以設(shè)置默認(rèn)值
print d.get('monkey', 'N/A') # Get an element with a default; prints "N/A"
print d.get('fish', 'N/A') # Get an element with a default; prints "wet"
d.keys() # 使用 keys 方法可以獲取所有的鍵
可以使用 for-in 來(lái)遍歷數(shù)組:
# 遍歷鍵
for key in d:
# 比前一種方式慢
for k in dict.keys(): ...
# 直接遍歷值
for value in dict.itervalues(): ...
# Python 2.x 中遍歷鍵值
for key, value in d.iteritems():
# Python 3.x 中遍歷鍵值
for key, value in d.items():
其他序列類型
集合
# Same as {"a", "b","c"}
normal_set = set(["a", "b","c"])
# Adding an element to normal set is fine
normal_set.add("d")
print("Normal Set")
print(normal_set)
# A frozen set
frozen_set = frozenset(["e", "f", "g"])
print("Frozen Set")
print(frozen_set)
# Uncommenting below line would cause error as
# we are trying to add element to a frozen set
# frozen_set.add("h")
函數(shù)
函數(shù)定義
Python 中的函數(shù)使用 def 關(guān)鍵字進(jìn)行定義，譬如:
def sign(x):
if x > 0:
return 'positive'
elif x < 0:
return 'negative'
else:
return 'zero'
for x in [-1, 0, 1]:
print sign(x)
# Prints "negative", "zero", "positive"
Python 支持運(yùn)行時(shí)創(chuàng)建動(dòng)態(tài)函數(shù)，也即是所謂的 lambda 函數(shù)：
def f(x): return x**2
# 等價(jià)于
g = lambda x: x**2
參數(shù)
Option Arguments: 不定參數(shù)
def example(a, b=None, *args, **kwargs):
print a, b
print args
print kwargs
example(1, "var", 2, 3, word="hello")
# 1 var
# (2, 3)
# {'word': 'hello'}
a_tuple = (1, 2, 3, 4, 5)
a_dict = {"1":1, "2":2, "3":3}
example(1, "var", *a_tuple, **a_dict)
# 1 var
# (1, 2, 3, 4, 5)
# {'1': 1, '2': 2, '3': 3}
生成器
def simple_generator_function():
yield 1
yield 2
yield 3
for value in simple_generator_function():
print(value)
# 輸出結(jié)果
# 1
# 2
# 3
our_generator = simple_generator_function()
next(our_generator)
# 1
next(our_generator)
# 2
next(our_generator)
#3
# 生成器典型的使用場(chǎng)景譬如無(wú)限數(shù)組的迭代
def get_primes(number):
while True:
if is_prime(number):
yield number
number += 1
裝飾器
裝飾器是非常有用的設(shè)計(jì)模式:
# 簡(jiǎn)單裝飾器
from functools import wraps
def decorator(func):
@wraps(func)
def wrapper(*args, **kwargs):
print('wrap function')
return func(*args, **kwargs)
return wrapper
@decorator
def example(*a, **kw):
pass
example.__name__ # attr of function preserve
# 'example'
# Decorator
# 帶輸入值的裝飾器
from functools import wraps
def decorator_with_argument(val):
def decorator(func):
@wraps(func)
def wrapper(*args, **kwargs):
print "Val is {0}".format(val)
return func(*args, **kwargs)
return wrapper
return decorator
@decorator_with_argument(10)
def example():
print "This is example function."
example()
# Val is 10
# This is example function.
# 等價(jià)于
def example():
print "This is example function."
example = decorator_with_argument(10)(example)
example()
# Val is 10
# This is example function.
類與對(duì)象
類定義
Python 中對(duì)于類的定義也很直接:
class Greeter(object):
# Constructor
def __init__(self, name):
self.name = name # Create an instance variable
# Instance method
def greet(self, loud=False):
if loud:
print 'HELLO, %s!' % self.name.upper()
else:
print 'Hello, %s' % self.name
g = Greeter('Fred') # Construct an instance of the Greeter class
g.greet() # Call an instance method; prints "Hello, Fred"
g.greet(loud=True) # Call an instance method; prints "HELLO, FRED!"
# isinstance 方法用于判斷某個(gè)對(duì)象是否源自某個(gè)類
ex = 10
isinstance(ex,int)
Managed Attributes: 受控屬性
# property、setter、deleter 可以用于復(fù)寫(xiě)點(diǎn)方法
class Example(object):
def __init__(self, value):
self._val = value
@property
def val(self):
return self._val
@val.setter
def val(self, value):
if not isintance(value, int):
raise TypeError("Expected int")
self._val = value
@val.deleter
def val(self):
del self._val
@property
def square3(self):
return 2**3
ex = Example(123)
ex.val = "str"
# Traceback (most recent call last):
# File "", line 1, in
# File "test.py", line 12, in val
# raise TypeError("Expected int")
# TypeError: Expected int
類方法與靜態(tài)方法
class example(object):
@classmethod
def clsmethod(cls):
print "I am classmethod"
@staticmethod
def stmethod():
print "I am staticmethod"
def instmethod(self):
print "I am instancemethod"
ex = example()
ex.clsmethod()
# I am classmethod
ex.stmethod()
# I am staticmethod
ex.instmethod()
# I am instancemethod
example.clsmethod()
# I am classmethod
example.stmethod()
# I am staticmethod
example.instmethod()
# Traceback (most recent call last):
# File "", line 1, in
# TypeError: unbound method instmethod() ...
對(duì)象
實(shí)例化
屬性操作
Python 中對(duì)象的屬性不同于字典鍵，可以使用點(diǎn)運(yùn)算符取值，直接使用 in 判斷會(huì)存在問(wèn)題:
class A(object):
@property
def prop(self):
return 3
a = A()
print "'prop' in a.__dict__ =", 'prop' in a.__dict__
print "hasattr(a, 'prop') =", hasattr(a, 'prop')
print "a.prop =", a.prop
# 'prop' in a.__dict__ = False
# hasattr(a, 'prop') = True
# a.prop = 3
建議使用 hasattr、getattr、setattr 這種方式對(duì)于對(duì)象屬性進(jìn)行操作:
class Example(object):
def __init__(self):
self.name = "ex"
def printex(self):
print "This is an example"
# Check object has attributes
# hasattr(obj, 'attr')
ex = Example()
hasattr(ex,"name")
# True
hasattr(ex,"printex")
# True
hasattr(ex,"print")
# False
# Get object attribute
# getattr(obj, 'attr')
getattr(ex,'name')
# 'ex'
# Set object attribute
# setattr(obj, 'attr', value)
setattr(ex,'name','example')
ex.name
# 'example'
異常與測(cè)試
異常處理
Context Manager - with
with 常用于打開(kāi)或者關(guān)閉某些資源:
host = 'localhost'
port = 5566
with Socket(host, port) as s:
while True:
conn, addr = s.accept()
msg = conn.recv(1024)
print msg
conn.send(msg)
conn.close()
單元測(cè)試
from __future__ import print_function
import unittest
def fib(n):
return 1 if n<=2 else fib(n-1)+fib(n-2)
def setUpModule():
print("setup module")
def tearDownModule():
print("teardown module")
class TestFib(unittest.TestCase):
def setUp(self):
print("setUp")
self.n = 10
def tearDown(self):
print("tearDown")
del self.n
@classmethod
def setUpClass(cls):
print("setUpClass")
@classmethod
def tearDownClass(cls):
print("tearDownClass")
def test_fib_assert_equal(self):
self.assertEqual(fib(self.n), 55)
def test_fib_assert_true(self):
self.assertTrue(fib(self.n) == 55)
if __name__ == "__main__":
unittest.main()
存儲(chǔ)
文件讀寫(xiě)
路徑處理
Python 內(nèi)置的 __file__ 關(guān)鍵字會(huì)指向當(dāng)前文件的相對(duì)路徑，可以根據(jù)它來(lái)構(gòu)造絕對(duì)路徑，或者索引其他文件:
# 獲取當(dāng)前文件的相對(duì)目錄
dir = os.path.dirname(__file__) # src\app
## once you're at the directory level you want, with the desired directory as the final path node:
dirname1 = os.path.basename(dir)
dirname2 = os.path.split(dir)[1] ## if you look at the documentation, this is exactly what os.path.basename does.
# 獲取當(dāng)前代碼文件的絕對(duì)路徑，abspath 會(huì)自動(dòng)根據(jù)相對(duì)路徑與當(dāng)前工作空間進(jìn)行路徑補(bǔ)全
os.path.abspath(os.path.dirname(__file__)) # D:\WorkSpace\OWS\tool\ui-tool-svn\python\src\app
# 獲取當(dāng)前文件的真實(shí)路徑
os.path.dirname(os.path.realpath(__file__)) # D:\WorkSpace\OWS\tool\ui-tool-svn\python\src\app
# 獲取當(dāng)前執(zhí)行路徑
os.getcwd()
可以使用 listdir、walk、glob 模塊來(lái)進(jìn)行文件枚舉與檢索：
# 僅列舉所有的文件
from os import listdir
from os.path import isfile, join
onlyfiles = [f for f in listdir(mypath) if isfile(join(mypath, f))]
# 使用 walk 遞歸搜索
from os import walk
f = []
for (dirpath, dirnames, filenames) in walk(mypath):
f.extend(filenames)
break
# 使用 glob 進(jìn)行復(fù)雜模式匹配
import glob
print(glob.glob("/home/adam/*.txt"))
# ['/home/adam/file1.txt', '/home/adam/file2.txt', .... ]
簡(jiǎn)單文件讀寫(xiě)
# 可以根據(jù)文件是否存在選擇寫(xiě)入模式
mode = 'a' if os.path.exists(writepath) else 'w'
# 使用 with 方法能夠自動(dòng)處理異常
with open("file.dat",mode) as f:
f.write(...)
...
# 操作完畢之后記得關(guān)閉文件
f.close()
# 讀取文件內(nèi)容
message = f.read()
復(fù)雜格式文件
JSON
import json
# Writing JSON data
with open('data.json', 'w') as f:
json.dump(data, f)
# Reading data back
with open('data.json', 'r') as f:
data = json.load(f)
XML
我們可以使用 lxml 來(lái)解析與處理 XML 文件，本部分即對(duì)其常用操作進(jìn)行介紹。lxml 支持從字符串或者文件中創(chuàng)建 Element 對(duì)象：
from lxml import etree
# 可以從字符串開(kāi)始構(gòu)造
xml = ''
root = etree.fromstring(xml)
etree.tostring(root)
# b''
# 也可以從某個(gè)文件開(kāi)始構(gòu)造
tree = etree.parse("doc/test.xml")
# 或者指定某個(gè) baseURL
root = etree.fromstring(xml, base_url="http://where.it/is/from.xml")
其提供了迭代器以對(duì)所有元素進(jìn)行遍歷：
# 遍歷所有的節(jié)點(diǎn)
for tag in tree.iter():
if not len(tag):
print tag.keys() # 獲取所有自定義屬性
print (tag.tag, tag.text) # text 即文本子元素值
# 獲取 XPath
for e in root.iter():
print tree.getpath(e)
lxml 支持以 XPath 查找元素，不過(guò)需要注意的是，XPath 查找的結(jié)果是數(shù)組，并且在包含命名空間的情況下，需要指定命名空間：
root.xpath('//page/text/text()',ns={prefix:url})
# 可以使用 getparent 遞歸查找父元素
el.getparent()
lxml 提供了 insert、append 等方法進(jìn)行元素操作：
# append 方法默認(rèn)追加到尾部
st = etree.Element("state", name="New Mexico")
co = etree.Element("county", name="Socorro")
st.append(co)
# insert 方法可以指定位置
node.insert(0, newKid)
Excel
可以使用 [xlrd]() 來(lái)讀取 Excel 文件，使用 xlsxwriter 來(lái)寫(xiě)入與操作 Excel 文件。
# 讀取某個(gè) Cell 的原始值
sh.cell(rx, col).value
# 創(chuàng)建新的文件
workbook = xlsxwriter.Workbook(outputFile)
worksheet = workbook.add_worksheet()
# 設(shè)置從第 0 行開(kāi)始寫(xiě)入
row = 0
# 遍歷二維數(shù)組，并且將其寫(xiě)入到 Excel 中
for rowData in array:
for col, data in enumerate(rowData):
worksheet.write(row, col, data)
row = row + 1
workbook.close()
文件系統(tǒng)
對(duì)于高級(jí)的文件操作，我們可以使用 Python 內(nèi)置的 shutil
# 遞歸刪除 appName 下面的所有的文件夾
shutil.rmtree(appName)
網(wǎng)絡(luò)交互
Requests
Requests 是優(yōu)雅而易用的 Python 網(wǎng)絡(luò)請(qǐng)求庫(kù):
import requests
r = requests.get('https://api.github.com/events')
r = requests.get('https://api.github.com/user', auth=('user', 'pass'))
r.status_code
# 200
r.headers['content-type']
# 'application/json; charset=utf8'
r.encoding
# 'utf-8'
r.text
# u'{"type":"User"...'
r.json()
# {u'private_gists': 419, u'total_private_repos': 77, ...}
r = requests.put('http://httpbin.org/put', data = {'key':'value'})
r = requests.delete('http://httpbin.org/delete')
r = requests.head('http://httpbin.org/get')
r = requests.options('http://httpbin.org/get')
數(shù)據(jù)存儲(chǔ)
MySQL
import pymysql.cursors
# Connect to the database
connection = pymysql.connect(host='localhost',
user='user',
password='passwd',
db='db',
charset='utf8mb4',
cursorclass=pymysql.cursors.DictCursor)
try:
with connection.cursor() as cursor:
# Create a new record
sql = "INSERT INTO `users` (`email`, `password`) VALUES (%s, %s)"
cursor.execute(sql, ('webmaster@python.org', 'very-secret'))
# connection is not autocommit by default. So you must commit to save
# your changes.
connection.commit()
with connection.cursor() as cursor:
# Read a single record
sql = "SELECT `id`, `password` FROM `users` WHERE `email`=%s"
cursor.execute(sql, ('webmaster@python.org',))
result = cursor.fetchone()
print(result)
finally:
connection.close()
總結(jié)
以上是生活随笔為你收集整理的python语法基础知识案例_Python 语法速览与实战清单的全部?jī)?nèi)容，希望文章能夠幫你解決所遇到的問(wèn)題。
- 上一篇： java的沙盒安全模式_Java沙箱机制
- 下一篇： 海量url mysql_海量数据mysq