導航:首頁 > 編程語言 > python常用函數中文

python常用函數中文

發布時間:2023-02-05 20:55:31

A. python 函數的中文名稱

python函數名都是英文單詞,既然自學,准備一份英語字典。
count,英文動詞,數個數
len 英文名詞縮寫 length 長度
list 列表
int 整數

等等,編程語言和自然語言-英文相通。學好英文。

B. Python字典中幾個常用函數總結

1、get() 返回指定鍵的值,如果值不在字典中返回default值。
語法:dict.get(key,default=None)
參數:
key 字典中要查找的鍵。
default 如果指定鍵的值不存在時,返回該默認值值。
例:
dict={'Name':'alex','Age':21}
print("Name is:%s"% dict.get('Name')+"\n"+ "Age is:%d"% dict.get('Age'))
顯示結果為:
Name is:alex
Age is:21

2、update() 將一個字典中的值更新到另一個字典中。
語法:dict.update(dict2)
參數:
dict2 添加到指定字典dict里的字典。
例:
dict={'Name':'alex','Age':21}
dict2={'Sex':'female'}
dict.update(dict2)
print("Value is %s" % dict)
顯示結果為:
Value is {'Name': 'alex', 'Age': 21, 'Sex': 'female'}

C. Python中冷門但非常好用的內置函數

Python中有許多內置函數,不像print、len那麼廣為人知,但它們的功能卻異常強大,用好了可以大大提高代碼效率,同時提升代碼的簡潔度,增強可閱讀性

Counter

collections在python官方文檔中的解釋是High-performance container datatypes,直接的中文翻譯解釋高性能容量數據類型。這個模塊實現了特定目標的容器,以提供Python標准內建容器 dict , list , set , 和 tuple 的替代選擇。在python3.10.1中它總共包含以下幾種數據類型:

容器名簡介

namedtuple() 創建命名元組子類的工廠函數

deque 類似列表(list)的容器,實現了在兩端快速添加(append)和彈出(pop)

ChainMap 類似字典(dict)的容器類,將多個映射集合到一個視圖裡面

Counter 字典的子類,提供了可哈希對象的計數功能

OrderedDict 字典的子類,保存了他們被添加的順序

defaultdict 字典的子類,提供了一個工廠函數,為字典查詢提供一個默認值

UserDict 封裝了字典對象,簡化了字典子類化

UserList 封裝了列表對象,簡化了列表子類化

UserString 封裝了字元串對象,簡化了字元串子類化

其中Counter中文意思是計數器,也就是我們常用於統計的一種數據類型,在使用Counter之後可以讓我們的代碼更加簡單易讀。Counter類繼承dict類,所以它能使用dict類裡面的方法

舉例

#統計詞頻

fruits = ['apple', 'peach', 'apple', 'lemon', 'peach', 'peach']

result = {}

for fruit in fruits:

if not result.get(fruit):

result[fruit] = 1

else:

result[fruit] += 1

print(result)

#{'apple': 2, 'peach': 3, 'lemon': 1}下面我們看用Counter怎麼實現:

from collections import Counter

fruits = ['apple', 'peach', 'apple', 'lemon', 'peach', 'peach']

c = Counter(fruits)

print(dict(c))

#{'apple': 2, 'peach': 3, 'lemon': 1}顯然代碼更加簡單了,也更容易閱讀和維護了。

elements()

返回一個迭代器,其中每個元素將重復出現計數值所指定次。元素會按首次出現的順序返回。如果一個元素的計數值小於1,elements()將會忽略它。

>>> c = Counter(a=4, b=2, c=0, d=-2)

>>> sorted(c.elements())

['a', 'a', 'a', 'a', 'b', 'b']most_common([n])

返回一個列表,其中包含n個最常見的元素及出現次數,按常見程度由高到低排序。如果n被省略或為None,most_common()將返回計數器中的所有元素。計數值相等的元素按首次出現的順序排序:

>>> Counter('abracadabra').most_common(3)

[('a', 5), ('b', 2), ('r', 2)]這兩個方法是Counter中最常用的方法,其他方法可以參考 python3.10.1官方文檔

實戰

Leetcode 1002.查找共用字元

給你一個字元串數組words,請你找出所有在words的每個字元串中都出現的共用字元(包括重復字元),並以數組形式返回。你可以按任意順序返回答案。

輸入:words = ["bella", "label", "roller"]

輸出:["e", "l", "l"]

輸入:words = ["cool", "lock", "cook"]

輸出:["c", "o"]看到統計字元,典型的可以用Counter完美解決。這道題是找出字元串列表裡面每個元素都包含的字元,首先可以用Counter計算出每個元素每個字元出現的次數,依次取交集最後得出所有元素共同存在的字元,然後利用elements輸出共用字元出現的次數

class Solution:

def commonChars(self, words: List[str]) -> List[str]:

from collections import Counter

ans = Counter(words[0])

for i in words[1:]:

ans &= Counter(i)

return list(ans.elements())提交一下,發現83個測試用例耗時48ms,速度還是不錯的

sorted

在處理數據過程中,我們經常會用到排序操作,比如將列表、字典、元組裡面的元素正/倒排序。這時候就需要用到sorted(),它可以對任何可迭代對象進行排序,並返回列表

對列表升序操作:

a = sorted([2, 4, 3, 7, 1, 9])

print(a)

# 輸出:[1, 2, 3, 4, 7, 9]對元組倒序操作:

sorted((4,1,9,6),reverse=True)

print(a)

# 輸出:[9, 6, 4, 1]使用參數:key,根據自定義規則,按字元串長度來排序:

fruits = ['apple', 'watermelon', 'pear', 'banana']

a = sorted(fruits, key = lambda x : len(x))

print(a)

# 輸出:['pear', 'apple', 'banana', 'watermelon']all

all() 函數用於判斷給定的可迭代參數iterable中的所有元素是否都為 TRUE,如果是返回 True,否則返回 False。元素除了是 0、空、None、False外都算True。注意:空元組、空列表返回值為True。

>>> all(['a', 'b', 'c', 'd']) # 列表list,元素都不為空或0

True

>>> all(['a', 'b', '', 'd']) # 列表list,存在一個為空的元素

False

>>> all([0, 1,2, 3]) # 列表list,存在一個為0的元素

False

>>> all(('a', 'b', 'c', 'd')) # 元組tuple,元素都不為空或0

True

>>> all(('a', 'b', '', 'd')) # 元組tuple,存在一個為空的元素

False

>>> all((0, 1, 2, 3)) # 元組tuple,存在一個為0的元素

False

>>> all([]) # 空列表

True

>>> all(()) # 空元組

Trueany函數正好和all函數相反:判斷一個tuple或者list是否全為空,0,False。如果全為空,0,False,則返回False;如果不全為空,則返回True。

F-strings

在python3.6.2版本中,PEP 498提出一種新型字元串格式化機制,被稱為 「字元串插值」 或者更常見的一種稱呼是F-strings,F-strings提供了一種明確且方便的方式將python表達式嵌入到字元串中來進行格式化:

s1='Hello'

s2='World'

print(f'{s1} {s2}!')

# Hello World!在F-strings中我們也可以執行函數:

def power(x):

return x*x

x=4

print(f'{x} * {x} = {power(x)}')

# 4 * 4 = 16而且F-strings的運行速度很快,比傳統的%-string和str.format()這兩種格式化方法都快得多,書寫起來也更加簡單。

本文主要講解了python幾種冷門但好用的函數,更多內容以後會陸陸續續更新~

D. Python 幾個重要的內置函數

在學習Python的過程中,有幾個比較重要的內置函數:help()函數、dir()函數、input()與raw_input()函數、print()函數、type()函數。
第一、help()函數
Help()函數的參數分為兩種:如果傳一個字元串做參數的話,它會自動搜索以這個字元串命名的模塊、方法等;如果傳入的是一個對象,就會顯示這個對象的類型的幫助。比如輸入help(『print』),它就會尋找以『print』為名的模塊、類等,找不到就會看到提示信息;而print在Python里是一個保留字,和pass、return同等,而非對象,所以help(print)也會報錯。
第二、dir()函數
dir()函數返回任意對象的屬性和方法列表,包含模塊對象、函數對象、字元串對象、列表對象、字典對象等。盡管查找和導入模塊相對容易,但是記住每個模塊包含什麼卻不是這么簡單,您並不希望總是必須查看源代碼來找出答案。Python提供了一種方法,可以使用內置的dir()函數來檢查模塊的內容,當你為dir()提供一個模塊名的時候,它返回模塊定義的屬性列表。dir()函數適用於所有對象的類型,包含字元串、整數、列表、元組、字典、函數、定製類、類實例和類方法。
第三、input與raw_input函數
都是用於讀取用戶輸入的,不同的是input()函數期望用戶輸入的是一個有效的表達式,而raw_input()函數是將用戶的輸入包裝成一個字元串。
第四、Print()函數
Print在Python3版本之間是作為Python語句使用的,在Python3里print是作為函數使用的。
第五、type()函數
Type()函數返回任意對象的數據類型。在types模塊中列出了可能的數據類型,這對於處理多種數據類型的函數非常有用,它通過返回類型對象來做到這一點,可以將這個類型對象與types模塊中定義類型相比較。

E. python裡面有哪些自帶函數

python系統提供了下面常用的函數:
1. 數學庫模塊(math)提供了很多數學運算函數;
2.復數模塊(cmath)提供了用於復數運算的函數;
3.隨機數模塊(random)提供了用來生成隨機數的函數;
4.時間(time)和日歷(calendar)模塊提供了能處理日期和時間的函數。
注意:在調用系統函數之前,先要使用import 語句導入 相應的模塊
該語句將模塊中定義的函數代碼復制到自己的程 序中,然後就可以訪問模塊中的任何函數,其方 法是在函數名前面加上「模塊名.」。
希望能幫到你。

F. 太全了!Python3常用內置函數總結

數學相關

abs(a) : 求取絕對值。abs(-1)

max(list) : 求取list最大值。max([1,2,3])

min(list) : 求取list最小值。min([1,2,3])

sum(list) : 求取list元素的和。 sum([1,2,3]) >>> 6

sorted(list) : 排序,返回排序後的list。

len(list) : list長度,len([1,2,3])

divmod(a,b): 獲取商和余數。 divmod(5,2) >>> (2,1)

pow(a,b) : 獲取乘方數。pow(2,3) >>> 8

round(a,b) : 獲取指定位數的小數。a代表浮點數,b代表要保留的位數。round(3.1415926,2) >>> 3.14

range(a[,b]) : 生成一個a到b的數組,左閉右開。range(1,10) >>> [1,2,3,4,5,6,7,8,9]

類型轉換

int(str) : 轉換為int型。int('1') >>> 1

float(int/str) : 將int型或字元型轉換為浮點型。float('1') >>> 1.0

str(int) : 轉換為字元型。str(1) >>> '1'

bool(int) : 轉換為布爾類型。 str(0) >>> False str(None) >>> False

bytes(str,code) : 接收一個字元串,與所要編碼的格式,返回一個位元組流類型。bytes('abc', 'utf-8') >>> b'abc' bytes(u'爬蟲', 'utf-8') >>> b'xe7x88xacxe8x99xab'

list(iterable) : 轉換為list。 list((1,2,3)) >>> [1,2,3]

iter(iterable): 返回一個可迭代的對象。 iter([1,2,3]) >>> <list_iterator object at 0x0000000003813B00>

dict(iterable) : 轉換為dict。 dict([('a', 1), ('b', 2), ('c', 3)]) >>> {'a':1, 'b':2, 'c':3}

enumerate(iterable) : 返回一個枚舉對象。

tuple(iterable) : 轉換為tuple。 tuple([1,2,3]) >>>(1,2,3)

set(iterable) : 轉換為set。 set([1,4,2,4,3,5]) >>> {1,2,3,4,5} set({1:'a',2:'b',3:'c'}) >>> {1,2,3}

hex(int) : 轉換為16進制。hex(1024) >>> '0x400'

oct(int) : 轉換為8進制。 oct(1024) >>> '0o2000'

bin(int) : 轉換為2進制。 bin(1024) >>> '0b10000000000'

chr(int) : 轉換數字為相應ASCI碼字元。 chr(65) >>> 'A'

ord(str) : 轉換ASCI字元為相應的數字。 ord('A') >>> 65

相關操作

eval****() : 執行一個表達式,或字元串作為運算。 eval('1+1') >>> 2

exec() : 執行python語句。 exec('print("Python")') >>> Python

filter(func, iterable) : 通過判斷函數fun,篩選符合條件的元素。 filter(lambda x: x>3, [1,2,3,4,5,6]) >>> <filter object at 0x0000000003813828>

map(func, *iterable) : 將func用於每個iterable對象。 map(lambda a,b: a+b, [1,2,3,4], [5,6,7]) >>> [6,8,10]

zip(*iterable) : 將iterable分組合並。返回一個zip對象。 list(zip([1,2,3],[4,5,6])) >>> [(1, 4), (2, 5), (3, 6)]

type():返回一個對象的類型。

id(): 返回一個對象的唯一標識值。

hash(object):返回一個對象的hash值,具有相同值的object具有相同的hash值。 hash('python') >>> 7070808359261009780

help():調用系統內置的幫助系統。

isinstance():判斷一個對象是否為該類的一個實例。

issubclass():判斷一個類是否為另一個類的子類。

globals() : 返回當前全局變數的字典。

next(iterator[, default]) : 接收一個迭代器,返回迭代器中的數值,如果設置了default,則當迭代器中的元素遍歷後,輸出default內容。

reversed(sequence) : 生成一個反轉序列的迭代器。 reversed('abc') >>> ['c','b','a']

G. Python的函數都有哪些

【常見的內置函數】

1、enumerate(iterable,start=0)

是python的內置函數,是枚舉、列舉的意思,對於一個可迭代的(iterable)/可遍歷的對象(如列表、字元串),enumerate將其組成一個索引序列,利用它可以同時獲得索引和值。

2、zip(*iterables,strict=False)

用於將可迭代的對象作為參數,將對象中對應的元素打包成一個個元組,然後返回由這些元組組成的列表。如果各個迭代器的元素個數不一致,則返回列表長度與最短的對象相同,利用*號操作符,可以將元組解壓為列表。

3、filter(function,iterable)

filter是將一個序列進行過濾,返回迭代器的對象,去除不滿足條件的序列。

4、isinstance(object,classinfo)

是用來判斷某一個變數或者是對象是不是屬於某種類型的一個函數,如果參數object是classinfo的實例,或者object是classinfo類的子類的一個實例,
返回True。如果object不是一個給定類型的的對象, 則返回結果總是False

5、eval(expression[,globals[,locals]])

用來將字元串str當成有效的表達式來求值並返回計算結果,表達式解析參數expression並作為Python表達式進行求值(從技術上說是一個條件列表),採用globals和locals字典作為全局和局部命名空間。

【常用的句式】

1、format字元串格式化

format把字元串當成一個模板,通過傳入的參數進行格式化,非常實用且強大。

2、連接字元串

常使用+連接兩個字元串。

3、if...else條件語句

Python條件語句是通過一條或多條語句的執行結果(True或者False)來決定執行的代碼塊。其中if...else語句用來執行需要判斷的情形。

4、for...in、while循環語句

循環語句就是遍歷一個序列,循環去執行某個操作,Python中的循環語句有for和while。

5、import導入其他腳本的功能

有時需要使用另一個python文件中的腳本,這其實很簡單,就像使用import關鍵字導入任何模塊一樣。

H. python常用列表函數

1

len(list)

列表元素個數

2

max(list)

返回列表元素最大值

3

min(list)

返回列表元素最小值

4

list(seq)

將元組轉換為列表

序號

方法

1

list.append(obj)

在列表末尾添加新的對象

2

list.count(obj)

統計某個元素在列表中出現的次數

3

list.extend(seq)

在列表末尾一次性追加另一個序列中的多個值(用新列表擴展原來的列表)

4

list.index(obj)

從列表中找出某個值第一個匹配項的索引位置

5

list.insert(index, obj)

將對象插入列表

6

list.pop([index=-1])

移除列表中的一個元素(默認最後一個元素),並且返回該元素的值

7

list.remove(obj)

移除列表中某個值的第一個匹配項

8

list.reverse()

反向列表中元素

9

list.sort( key=None, reverse=False)

對原列表進行排序

10

list.clear()

清空列表

11

list.()

復制列表

I. 一文秒懂python正則表達式常用函數

01 Re概覽
Re模塊是python的內置模塊,提供了正則表達式在python中的所有用法,默認安裝位置在python根目錄下的Lib文件夾(如 ..\Python\Python37\Lib)。主要提供了3大類字元串操作方法:

字元查找/匹配

字元替換

字元分割

由於是面向字元串類型的模塊,就不得不提到字元串編碼類型。re模塊中,模式串和搜索串既可以是 Unicode 字元串 (常用str類型) ,也可以是8位位元組串 (bytes,2位16進制數字,例如\xe5) , 但要求二者必須是同類型字元串。
02 字元串查找/匹配
編譯:compile

在介紹查找和匹配函數前,首先需要知道re的compile函數,該函數可以將一個模式串編譯成正則表達式類型,以便後續快速匹配和復用
import re pattern = re.compile(r'[a-z]{2,5}') type(pattern) #re.Pattern
此例創建了一個正則表達式式對象 (re.pattern) ,命名為pattern,用於匹配2-5位小寫字母的模式串。後續在使用其他正則表達式函數時,即可使用pattern進行方法調用。

匹配:match

match函數用於從文本串的起始位置開始匹配,若匹配成功,則返回相應的匹配對象,此時可調用group()方法返回匹配結果,也可用span()方法返回匹配起止下標區間;否則返回None
import re pattern = re.compile(r'[a-z]{2,5}') text1 = 'this is a re test' res = pattern.match(text1) print(res) # if res:  print(res.group()) #this  print(res.span()) #(0, 4) text2 = '是的, this is a re test' print(pattern.match(text2))#None
match函數還有一個變形函數fullmatch,當且僅當模式串與文本串剛好全部匹配時,返回一個匹配對象,否則返回None

搜索:search

match只提供了從文本串起始位置匹配的結果,如果想從任意位置匹配,則可調用search方法,與match方法類似,當任意位置匹配成功,則立即返回一個匹配對象,也可調用span()方法獲取起止區間、調用group方法獲得匹配文本串
import re pattern = re.compile(r'\s[a-z]{2}') text1 = 'this is a re test' res = pattern.search(text1) print(res) # if res:  print(res.group()) #is  print(res.span()) #(4, 7) pattern2 = re.compile(r'\s[a-z]{5}') text2 = '是的,this is a re test' print(pattern2.search(text2))#None
match和search均用於匹配單個結果,唯一區別在於前者是從起始位置開始匹配,而後者從任意位置匹配,匹配成功則返回一個match對象。

全搜索:findall/finditer

幾乎是最常用的正則表達式函數,用於尋找所有匹配的結果,例如在爬蟲信息提取中,可非常方便地提取所有匹配欄位
import re pattern = re.compile(r'\s[a-z]{2,5}') text1 = 'this is a re test' res = pattern.findall(text1) print(res) #[' is', ' re', ' test']
findall返回的是一個列表對象類型,當無匹配對象時,返回一個空列表。為了避免因同時返回大量匹配結果佔用過多內存,可以調用finditer函數返回一個迭代器類型,其中每個迭代元素是一個match對象,可繼續調用group和span方法獲取相應結果
import re pattern = re.compile(r'\s[a-z]{2,5}') text1 = 'this is a re test' res = pattern.finditer(text1) for r in res:  print(r.group()) """  is  re  test """
當匹配模式串較為簡單或者僅需單詞調用時,上述所有方法也可直接調用re類函數,而無需事先編譯。此時各方法的第一個參數為模式串。
import re pattern = re.compile(r'\d{2,5}') text = 'this is re test' re.findall('[a-z]+', text) #['this', 'is', 're', 'test'] 03 字元串替換/分割
替換:sub/subn

當需要對文本串進行條件替換時,可調用re.sub實現 (當然也可先編譯後再用調用實例方法) ,相應參數分別為模式串、替換格式、文本串,還可以通過增加預設參數限定替換次數和匹配模式。通過在模式串進行分組,可實現字元串的格式化替換(類似字元串的format方法),以實現特定任務。
import re text = 'today is 2020-03-05' print(re.sub('-', '', text)) #'today is 20200305' print(re.sub('-', '', text, 1)) #'today is 202003-05' print(re.sub('(\d{4})-(\d{2})-(\d{2})', r'\2/\3/\1', text)) #'today is 03/05/2020'
re.sub的一個變形方法是re.subn,區別是返回一個2元素的元組,其中第一個元素為替換結果,第二個為替換次數
import re text = 'today is 2020-03-05' print(re.subn('-', '', text)) #('today is 20200305', 2)
分割:split

還可以調用正則表達式實現字元串的特定分割,相當於.split()方法的一個加強版,實現特定模式的分割,返回一個切割後的結果列表
import re text = 'today is a re test, what do you mind?' print(re.split(',', text)) #['today is a re test', ' what do you mind?'] 04 總結
python中的re模塊提供了正則表達式的常用方法,每種方法都包括類方法調用(如re.match)或模式串的實例調用(pattern.match)2種形式

常用的匹配函數:match/fullmatch

常用的搜索函數:search/findall/finditer

常用的替換函數:sub/subn

常用的切割函數:split

還有其他很多方法,但不是很常用,具體可參考官方文檔

另外,python還有第三方正則表達式庫regex可供選擇

到此這篇關於一文秒懂python正則表達式常用函數的文章就介紹到這了,希望大家以後多多支持!

J. python 常用的系統函數有哪些

1.常用內置函數:(不用import就可以直接使用)
help(obj) 在線幫助, obj可是任何類型
callable(obj) 查看一個obj是不是可以像函數一樣調用
repr(obj) 得到obj的表示字元串,可以利用這個字元串eval重建該對象的一個拷貝
eval_r(str) 表示合法的python表達式,返回這個表達式
dir(obj) 查看obj的name space中可見的name
hasattr(obj,name) 查看一個obj的name space中是否有name
getattr(obj,name) 得到一個obj的name space中的一個name
setattr(obj,name,value) 為一個obj的name space中的一個name指向vale這個object
delattr(obj,name) 從obj的name space中刪除一個name
vars(obj) 返回一個object的name space。用dictionary表示
locals() 返回一個局部name space,用dictionary表示
globals() 返回一個全局name space,用dictionary表示
type(obj) 查看一個obj的類型
isinstance(obj,cls) 查看obj是不是cls的instance
issubclass(subcls,supcls) 查看subcls是不是supcls的子類

類型轉換函數
chr(i) 把一個ASCII數值,變成字元
ord(i) 把一個字元或者unicode字元,變成ASCII數值
oct(x) 把整數x變成八進製表示的字元串
hex(x) 把整數x變成十六進製表示的字元串
str(obj) 得到obj的字元串描述
list(seq) 把一個sequence轉換成一個list
tuple(seq) 把一個sequence轉換成一個tuple
dict(),dict(list) 轉換成一個dictionary
int(x) 轉換成一個integer
long(x) 轉換成一個long interger
float(x) 轉換成一個浮點數
complex(x) 轉換成復數
max(...) 求最大值
min(...) 求最小值
用於執行程序的內置函數
complie 如果一段代碼經常要使用,那麼先編譯,再運行會更快。

2.和操作系統相關的調用
系統相關的信息模塊 import sys
sys.argv是一個list,包含所有的命令行參數.
sys.stdout sys.stdin sys.stderr 分別表示標准輸入輸出,錯誤輸出的文件對象.
sys.stdin.readline() 從標准輸入讀一行 sys.stdout.write("a") 屏幕輸出a
sys.exit(exit_code) 退出程序
sys.moles 是一個dictionary,表示系統中所有可用的mole
sys.platform 得到運行的操作系統環境
sys.path 是一個list,指明所有查找mole,package的路徑.

操作系統相關的調用和操作 import os
os.environ 一個dictionary 包含環境變數的映射關系 os.environ["HOME"] 可以得到環境變數HOME的值
os.chdir(dir) 改變當前目錄 os.chdir('d:\\outlook') 注意windows下用到轉義
os.getcwd() 得到當前目錄
os.getegid() 得到有效組id os.getgid() 得到組id
os.getuid() 得到用戶id os.geteuid() 得到有效用戶id
os.setegid os.setegid() os.seteuid() os.setuid()
os.getgruops() 得到用戶組名稱列表
os.getlogin() 得到用戶登錄名稱
os.getenv 得到環境變數
os.putenv 設置環境變數
os.umask 設置umask
os.system(cmd) 利用系統調用,運行cmd命令
操作舉例:
os.mkdir('/tmp/xx') os.system("echo 'hello' > /tmp/xx/a.txt") os.listdir('/tmp/xx')
os.rename('/tmp/xx/a.txt','/tmp/xx/b.txt') os.remove('/tmp/xx/b.txt') os.rmdir('/tmp/xx')
用python編寫一個簡單的shell
#!/usr/bin/python
import os, sys
cmd = sys.stdin.readline()
while cmd:
os.system(cmd)
cmd = sys.stdin.readline()

用os.path編寫平台無關的程序
os.path.abspath("1.txt") == os.path.join(os.getcwd(), "1.txt")
os.path.split(os.getcwd()) 用於分開一個目錄名稱中的目錄部分和文件名稱部分。
os.path.join(os.getcwd(), os.pardir, 'a', 'a.doc') 全成路徑名稱.
os.pardir 表示當前平台下上一級目錄的字元 ..
os.path.getctime("/root/1.txt") 返回1.txt的ctime(創建時間)時間戳
os.path.exists(os.getcwd()) 判斷文件是否存在
os.path.expanser('~/dir') 把~擴展成用戶根目錄
os.path.expandvars('$PATH') 擴展環境變數PATH
os.path.isfile(os.getcwd()) 判斷是否是文件名,1是0否
os.path.isdir('c:\Python26\temp') 判斷是否是目錄,1是0否
os.path.islink('/home/huaying/111.sql') 是否是符號連接 windows下不可用
os.path.ismout(os.getcwd()) 是否是文件系統安裝點 windows下不可用
os.path.samefile(os.getcwd(), '/home/huaying') 看看兩個文件名是不是指的是同一個文件
os.path.walk('/home/huaying', test_fun, "a.c")
遍歷/home/huaying下所有子目錄包括本目錄,對於每個目錄都會調用函數test_fun.
例:在某個目錄中,和他所有的子目錄中查找名稱是a.c的文件或目錄。
def test_fun(filename, dirname, names): //filename即是walk中的a.c dirname是訪問的目錄名稱
if filename in names: //names是一個list,包含dirname目錄下的所有內容
print os.path.join(dirname, filename)
os.path.walk('/home/huaying', test_fun, "a.c")

文件操作
打開文件
f = open("filename", "r") r只讀 w寫 rw讀寫 rb讀二進制 wb寫二進制 w+寫追加
讀寫文件
f.write("a") f.write(str) 寫一字元串 f.writeline() f.readlines() 與下read類同
f.read() 全讀出來 f.read(size) 表示從文件中讀取size個字元
f.readline() 讀一行,到文件結尾,返回空串. f.readlines() 讀取全部,返回一個list. list每個元素表示一行,包含"\n"\
f.tell() 返回當前文件讀取位置
f.seek(off, where) 定位文件讀寫位置. off表示偏移量,正數向文件尾移動,負數表示向開頭移動。
where為0表示從開始算起,1表示從當前位置算,2表示從結尾算.
f.flush() 刷新緩存
關閉文件
f.close()

regular expression 正則表達式 import re
簡單的regexp
p = re.compile("abc") if p.match("abc") : print "match"
上例中首先生成一個pattern(模式),如果和某個字元串匹配,就返回一個match object
除某些特殊字元metacharacter元字元,大多數字元都和自身匹配。
這些特殊字元是 。^ $ * + ? { [ ] \ | ( )
字元集合(用[]表示)
列出字元,如[abc]表示匹配a或b或c,大多數metacharacter在[]中只表示和本身匹配。例:
a = ".^$*+?{\\|()" 大多數metachar在[]中都和本身匹配,但"^[]\"不同
p = re.compile("["+a+"]")
for i in a:
if p.match(i):
print "[%s] is match" %i
else:
print "[%s] is not match" %i
在[]中包含[]本身,表示"["或者"]"匹配.用

表示.
^出現在[]的開頭,表示取反.[^abc]表示除了a,b,c之外的所有字元。^沒有出現在開頭,即於身身匹配。
-可表示範圍.[a-zA-Z]匹配任何一個英文字母。[0-9]匹配任何數字。
\在[]中的妙用。
\d [0-9]
\D [^0-9]
\s [ \t\n\r\f\v]
\S [^ \t\n\r\f\v]
\w [a-zA-Z0-9_]
\W [^a-zA-Z0-9_]
\t 表示和tab匹配, 其他的都和字元串的表示法一致
\x20 表示和十六進制ascii 0x20匹配
有了\,可以在[]中表示任何字元。註:單獨的一個"."如果沒有出現[]中,表示出了換行\n以外的匹配任何字元,類似[^\n].
regexp的重復
{m,n}表示出現m個以上(含m個),n個以下(含n個). 如ab{1,3}c和abc,abbc,abbbc匹配,不會與ac,abbbc匹配。
m是下界,n是上界。m省略表下界是0,n省略,表上界無限大。
*表示{,} +表示{1,} ?表示{0,1}
最大匹配和最小匹配 python都是最大匹配,如果要最小匹配,在*,+,?,{m,n}後面加一個?.
match object的end可以得到匹配的最後一個字元的位置。
re.compile("a*").match('aaaa').end() 4 最大匹配
re.compile("a*?").match('aaaa').end() 0 最小匹配
使用原始字元串
字元串表示方法中用\\表示字元\.大量使用影響可讀性。
解決方法:在字元串前面加一個r表示raw格式。
a = r"\a" print a 結果是\a
a = r"\"a" print a 結果是\"a
使用re模塊
先用re.compile得到一個RegexObject 表示一個regexp
後用pattern的match,search的方法,得到MatchObject
再用match object得到匹配的位置,匹配的字元串等信息
RegxObject常用函數:
>>> re.compile("a").match("abab") 如果abab的開頭和re.compile("a")匹配,得到MatchObject
<_sre.SRE_Match object at 0x81d43c8>
>>> print re.compile("a").match("bbab")
None 註:從str的開頭開始匹配
>>> re.compile("a").search("abab") 在abab中搜索第一個和re_obj匹配的部分
<_sre.SRE_Match object at 0x81d43c8>
>>> print re.compile("a").search("bbab")
<_sre.SRE_Match object at 0x8184e18> 和match()不同,不必從開頭匹配
re_obj.findall(str) 返回str中搜索所有和re_obj匹配的部分.
返回一個tuple,其中元素是匹配的字元串.
MatchObject的常用函數
m.start() 返回起始位置,m.end()返回結束位置(不包含該位置的字元).
m.span() 返回一個tuple表示(m.start(), m.end())
m.pos(), m.endpos(), m.re(), m.string()
m.re().search(m.string(), m.pos(), m.endpos()) 會得到m本身
m.finditer()可以返回一個iterator,用來遍歷所有找到的MatchObject.
for m in re.compile("[ab]").finditer("tatbxaxb"):
print m.span()
高級regexp
| 表示聯合多個regexp. A B兩個regexp,A|B表示和A匹配或者跟B匹配.
^ 表示只匹配一行的開始行首,^只有在開頭才有此特殊意義。
$ 表示只匹配一行的結尾
\A 表示只匹配第一行字元串的開頭 ^匹配每一行的行首
\Z 表示只匹配行一行字元串的結尾 $匹配第一行的行尾
\b 只匹配詞的邊界 例:\binfo\b 只會匹配"info" 不會匹配information
\B 表示匹配非單詞邊界
示例如下:
>>> print re.compile(r"\binfo\b").match("info ") #使用raw格式 \b表示單詞邊界
<_sre.SRE_Match object at 0x817aa98>
>>> print re.compile("\binfo\b").match("info ") #沒有使用raw \b表示退格符號
None
>>> print re.compile("\binfo\b").match("\binfo\b ")
<_sre.SRE_Match object at 0x8174948>
分組(Group) 示例:re.compile("(a(b)c)d").match("abcd").groups() ('abc', 'b')
#!/usr/local/bin/python
import re
x = """
name: Charles
Address: BUPT

name: Ann
Address: BUPT
"""
#p = re.compile(r"^name:(.*)\n^Address:(.*)\n", re.M)
p = re.compile(r"^name:(?P.*)\n^Address:(?P.*)\n", re.M)
for m in p.finditer(x):
print m.span()
print "here is your friends list"
print "%s, %s"%m.groups()
Compile Flag
用re.compile得到RegxObject時,可以有一些flag用來調整RegxObject的詳細特徵.
DOTALL, S 讓.匹配任意字元,包括換行符\n
IGNORECASE, I 忽略大小寫
LOCALES, L 讓\w \W \b \B和當前的locale一致
MULTILINE, M 多行模式,隻影響^和$(參見上例)
VERBOSE, X verbose模式

閱讀全文

與python常用函數中文相關的資料

熱點內容
linux安裝離線gcc 瀏覽:209
解壓縮英文版 瀏覽:580
麻將機命令 瀏覽:868
軟體安全與編譯器體系結構書籍 瀏覽:915
壓縮空氣釋放的風速變化 瀏覽:85
linuxjdk安裝路徑rpm 瀏覽:256
簡歷上的程序員面試 瀏覽:629
linuxcurl參數 瀏覽:772
編輯貓少兒編程靠譜嗎 瀏覽:840
阿里java編程規范 瀏覽:158
哪個網有編程課 瀏覽:402
程序員初學者如何自學編程 瀏覽:406
手機在線解壓縮 瀏覽:136
編譯器分配不可用地址 瀏覽:358
內網郵件伺服器是什麼 瀏覽:139
u盤加密電腦不認識了 瀏覽:402
壓縮機粗管是迴流管 瀏覽:280
javastring逗號 瀏覽:283
程序員寫什麼類型代碼 瀏覽:372
怎麼和俄羅斯人交朋友app 瀏覽:537