【Python】字符串內置函數

轉載自：https://www.cnblogs.com/shenbuer/p/7833953.html

1、字符串

定義：它是一個有序的字符的集合，用於存儲和表示基本的文本信息，‘’或“”或‘’‘ ’‘’中間包含的內容稱之爲字符串
特性：
1.只能存放一個值
2.不可變
3.按照從左到右的順序定義字符集合，下標從0開始順序訪問，有序
補充：
　　1.字符串的單引號和雙引號都無法取消特殊字符的含義，如果想讓引號內所有字符均取消特殊意義，在引號前面加r，如name＝r'l\thf'
　　2.unicode字符串與r連用必需在r前面，如name＝ur'l\thf' 

2、字符串常用操作

1 2 3 4 5 6

# 1字母處理： .upper()    # 全部大寫 .lower()    # 全部小寫 .swapcase()    # 大小寫互換 .capitalize()    # 首字母大寫，其餘小寫 .title()    # 首字母大寫

 View Code

1 2 3 4 5 6

# 2格式化相關   .ljust(width)     # 獲取固定長度，左對齊，右邊不夠用空格補齊 .rjust(width)     # 獲取固定長度，右對齊，左邊不夠用空格補齊 .center(width)  # 獲取固定長度，中間對齊，兩邊不夠用空格補齊 .zfill(width)      # 獲取固定長度，右對齊，左邊不足用0補齊

 View Code

 

1 2 3 4 5 6 7 8

# 3 字符串搜索相關   .find()    # 搜索指定字符串，沒有返回-1 .index()    # 同上，但是找不到會報錯 .rfind()    # 從右邊開始查找 .count()    # 統計指定的字符串出現的次數   # 上面所有方法都可以用index代替，不同的是使用index查找不到會拋異常，而find返回-1

s='hello world'
print(s.find('e'))  # 搜索指定字符串,沒有返回-1
print(s.find('w',1,2))  # 顧頭不顧尾，找不到則返回-1不會報錯，找到了則顯示索引
print(s.index('w',1,2)) # 同上，但是找不到會報錯
print(s.count('o')) # 統計指定的字符串出現的次數
print(s.rfind('l')) # 從右邊開始查找

 

# 4字符串替換

.replace('old','new')    # 替換old爲new
.replace('old','new',次數)    # 替換指定次數的old爲new


s='hello world'
print(s.replace('world','python'))
print(s.replace('l','p',2))
print(s.replace('l','p',5))

執行結果：
hello python
heppo world
heppo worpd

 

# 5字符串去空格及去指定字符

.strip()    # 去兩邊空格
.lstrip()    # 去左邊空格
.rstrip()    # 去右邊空格

.split()    # 默認按空格分隔
.split('指定字符')    # 按指定字符分割字符串爲數組


s='   h e-l lo   '
print(s)
print(s.strip())
print(s.lstrip())
print(s.rstrip())
print(s.split('-'))
print(s.split())

 

# 6字符串判斷相關

.startswith('start')    # 是否以start開頭
.endswith('end')    # 是否以end結尾
.isalnum()    # 是否全爲字母或數字
.isalpha()    # 是否全字母
.isdigit()    # 是否全數字
.islower()    # 是否全小寫
.isupper()    # 是否全大寫
.istitle()    # 判斷首字母是否爲大寫
.isspace()    # 判斷字符是否爲空格

# 補充

bin()    # 十進制數轉八進制
hex()    # 十進制數轉十六進制
range()    # 函數：可以生成一個整數序列
type()    # 查看數據類型
len()    # 計算字符串長度
format()    # 格式化字符串，類似%s，傳遞值能多不能少

 3、python中str函數isdigit、isdecimal、isnumeric的區別

1 2 3 4 5 6 7 8 9 10 11 12 13 14

isdigit() True: Unicode數字，byte數字（單字節），全角數字（雙字節），羅馬數字 False: 漢字數字 Error: 無   isdecimal() True: Unicode數字，，全角數字（雙字節） False: 羅馬數字，漢字數字 Error: byte數字（單字節）   isnumeric() True: Unicode數字，全角數字（雙字節），羅馬數字，漢字數字 False: 無 Error: byte數字（單字節）

　4、內置函數

•     數學運算(7個)

•     類型轉換(24個)

•     序列操作(8個)

•     對象操作(7個)

•     反射操作(8個)

•     變量操作(2個)

•     交互操作(2個)

•     文件操作(1個)

•     編譯執行(4個)

•     裝飾器(3個)

數學運算

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25

abs：求數值的絕對值 abs(-2)   divmod：返回兩個數值的商和餘數 divmod(5,2) divmod(5.5,2)   max：返回迭代對象中的元素的最大值或者所有參數的最大值 max(1,2,3)    # 傳入3個參數 取3箇中較大者 max('1234')    # 傳入1個可迭代對象，取其最大元素值 max(-1,0,key=abs)    # 傳入了求絕對值函數，則參數都會進行求絕對值後再取較大者   min：返回可迭代對象中的元素的最小值或者所有參數的最小值 min(1,2,3)　　# 傳入3個參數 取3箇中較小者 min('1234')    # 傳入1個可迭代對象，取其最小元素值 min(-1,-2,key=abs)    # 傳入了求絕對值函數，則參數都會進行求絕對值後再取較小者   pow：返回兩個數值的冪運算值或其餘指定整數的模值 pow(2,3)   round：對浮點數進行四捨五入求值 round(1.1111,1)   sum：對元素類型是數值的可迭代對象中的每個元素求和 sum((1,2,3,4))    # 傳入可迭代對象、元素類型必須是數值型

類型轉換

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91

bool：根據傳入的參數的邏輯值創建一個新的布爾值 bool()或bool(0)     # 數值0、空值爲False   int：根據傳入的參數創建一個新的整數 int()     # 不傳入參數時，得到結果0   float：根據傳入的參數創建一個新的浮點數 float()    # 不提供參數的時候，返回0.0   complex：根據傳入參數創建一個新的複數 complex()    # 當兩個參數都不提供時，返回複數 0j   str：返回一個對象的字符串表現形式(給用戶)   bytearray：根據傳入的參數創建一個新的字節數組 bytearray('中文','utf-8')  bytearray(b'\xe4\xb8\xad\xe6\x96\x87')   bytes：根據傳入的參數創建一個新的不可變字節數組 bytes('中文','utf-8') b'\xe4\xb8\xad\xe6\x96\x87'   memoryview：根據傳入的參數創建一個新的內存查看對象 v=memoryview(b'asdf') print(v[0])    # 97 print(v[-1])    # 102   ord：返回Unicode字符對應的整數 print(ord('a'))   chr：返回整數所對應的Unicode字符 print(chr(97))   bin：將整數轉換成2進制字符串 oct：將整數轉化成8進制數字符串 hex：將整數轉換成16進制字符串   tuple：根據傳入的參數創建一個新的元組 list：根據傳入的參數創建一個新的列表 dict：根據傳入的參數創建一個新的字典 set：根據傳入的參數創建一個新的集合   frozenset：根據傳入的參數創建一個新的不可變集合 a=frozenset(range(10)) print(a) # frozenset({0, 1, 2, 3, 4, 5, 6, 7, 8, 9})   enumerate：根據可迭代對象創建枚舉對象 l1=['one','two','three','five'] print(list(enumerate(l1))) # [(0, 'one'), (1, 'two'), (2, 'three'), (3, 'five')] print(list(enumerate(l1,start=1)))  # 指定起始值 # [(1, 'one'), (2, 'two'), (3, 'three'), (4, 'five')]   range：根據傳入的參數創建一個新的range對象 iter：根據傳入的參數創建一個新的可迭代對象 a=iter('asdf') print(a)    # <str_iterator object at 0x00000190B4D99668> print(next(a))  # a print(next(a))  # s print(next(a))  # d print(next(a))  # f print(next(a))  # 報錯StopIteration   slice：根據傳入的參數創建一個新的切片對象 c1=slice(5) print(c1)   # slice(None, 5, None) c1=slice(2,5) print(c1)   # slice(2, 5, None) c1=slice(1,4,7) print(c1)   # slice(1, 4, 7)   super：根據傳入的參數創建一個新的子類和父類關係的代理對象 # 定義父類A類 class A(object):     def __init__(self):         print(A.__init__)   # 定義子類，繼承A class B(A):     def __init__(self):         print(B.__init__)         super().__init__()   # super調用父類方法 b=B() print(b) <function B.__init__ at 0x0000023DB0CA76A8> <function A.__init__ at 0x0000023DB0CA7620>   object：創建一個新的object對象

1

序列操作

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

all：判斷可迭代對象的每個元素是否都爲True值 print(all([1,2]))    # 列表中每個元素邏輯值均爲True，返回True print(all([0,2]))     # 列表中0的邏輯值爲False，返回False   any：判斷可迭代對象的元素是否有爲True值的元素 # 列表元素有一個爲True，則返回True # 列表元素全部爲False，則返回False   filter：使用指定方法過濾可迭代對象的元素   map：使用指定方法去作用傳入的每個可迭代對象的元素，生成新的可迭代對象   next：返回可迭代對象中的下一個元素值 # 傳入default參數後，如果可迭代對象還有元素沒有返回，則依次返回其元素值，如果所有元素已經返回，則返回default指定的默認值而不拋出StopIteration 異常    reversed：反轉序列生成新的可迭代對象   sorted：對可迭代對象進行排序，返回一個新的列表   zip：聚合傳入的每個迭代器中相同位置的元素，返回一個新的元組類型迭代器

對象操作

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

help：返回對象的幫助信息 dir：返回對象或者當前作用域內的屬性列表 id：返回對象的唯一標識符 hash：獲取對象的哈希值 type：返回對象的類型，或者根據傳入的參數創建一個新的類型 len：返回對象的長度 ascii：返回對象的可打印表字符串表現方式 format：格式化顯示值   vars：返回當前作用域內的局部變量和其值組成的字典，或者返回對象的屬性列表 class A(object):     pass   a=A() print(a.__dict__)   # {} print(vars(a))      # {} a.name='buer' print(a.__dict__)   # {'name': 'buer'} print(vars(a))      # {'name': 'buer'}

反射操作

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65

__import__：動態導入模塊 print(__import__('os')) print(__import__('time'))   # <module 'os' from 'D:\\Python36\\lib\\os.py'> # <module 'time' (built-in)>   isinstance：判斷對象是否是類或者類型元組中任意類元素的實例 issubclass：判斷類是否是另外一個類或者類型元組中任意類元素的子類   hasattr：檢查對象是否含有屬性 class Student:     def __init__(self,name):         self.name=name   s=Student('Ethan') print(hasattr(s,'name'))    # 含有name屬性爲True print(hasattr(s,'age'))     # 不含有age屬性爲False   getattr：獲取對象的屬性值 print(getattr(s,'name'))    # 存在屬性name，Ethan print(getattr(s,'age',20))  # 不存在屬性age，但提供了默認值，返回默認值 print(getattr(s,'age'))     # 不存在屬性age，未提供默認值，調用報錯 報錯如下： Traceback (most recent call last):   File "D:/test.py", line 30, in <module>     print(getattr(s,'age')) AttributeError: 'Student' object has no attribute 'age'   setattr：設置對象的屬性值 print(s.name)   # Ethan setattr(s,'name','Tom')   # name屬性存在，做賦值操作 setattr(s,'age',18)     # age屬性不存在，創建這個屬性 print(s.name)   # Tom print(s.age)    # 18   delattr：刪除對象的屬性 class Student:     def __init__(self,name):         self.name=name     def foo(self):         print('hello %s' % self.name)   a=Student('Ethan')   print(a.name)   # Ethan print(a.foo())  # hello Ethan   print(delattr(a,'name'))    # name屬性被刪除 print(a.name)   # 調用報錯 Traceback (most recent call last):   File "D:/test.py", line 50, in <module>     print(a.name)   # 調用報錯 AttributeError: 'Student' object has no attribute 'name'   callable：檢測對象是否可被調用 class B:     def __call__(self, *args, **kwargs):         print('instances are callable now')   print(callable(B))  # 類B是可調用對象 b=B()   # 調用類B print(callable(b))  # 實例b是可調用對象 print(b())  # 調用實例b成功 # instances are callable now

變量操作

1 2	globals：返回當前作用域內的全局變量和其值組成的字典 locals：返回當前作用域內的局部變量和其值組成的字典

交互操作

1 2 3

print：向標準輸出對象打印輸出 input：讀取用戶輸入值 user=input('please input your name:')

文件操作

1 2 3 4 5 6 7 8 9

open：使用指定的模式和編碼打開文件，返回文件讀寫對象 # 寫入文件 a= open('a.text','w') a.write('124sdgadgahg ggadh')   # 讀取文件 a= open('a.text','rt') print(a.read()) a.close()

編譯執行

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31

compile：將字符串編譯爲代碼或者AST對象，使之能夠通過exec語句來執行或者eval進行求值 # 流程語句使用exec code1='for i in range(5):print(i)' compile1=compile(code1,'','exec') exec (compile1) # 0 # 1 # 2 # 3 # 4   # 簡單求值表達式用eval code2='1+2+3+4' compile2=compile(code2,'','eval') print(eval(compile2))   # 10   eval：執行動態表達式求值 print(eval('1+2+3+4'))  # 10 print(eval('2*2*2'))    # 8 print(eval('10/2+2*2')) # 9.0   exec：執行動態語句塊 exec ('a=1+2') print(a)    # 3 exec ('b=4*3/2-1') print(b)    # 5.0   repr：返回一個對象的字符串表現形式(給解釋器) a='hello world' print(str(a))   # hello world print(repr(a))  # 'hello world'

裝飾器

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36

property：標示屬性的裝飾器 class A:     def __init__(self):         pass     @property     def foo(self):         print('1111111111') a=A() print(a.foo)    # 訪問屬性，不需要加()執行foo   classmethod：標示方法爲類方法的裝飾器 class B(object):     def __init__(self):         pass       @classmethod     def foo(cls):         print(cls)           print(B.foo())  # 類對象調用類方法 # <class '__main__.B'> b=B() print(b.foo())  # 類實例對象調用類方法 # <class '__main__.B'>   staticmethod：標示方法爲靜態方法的裝飾器 class C(object):     def __init__(self):         pass     @staticmethod     def f1():         print('hahahha')           print(C.f1())   # 類調用 c=C() print(c.f1())   # 類實例對象調用

　補充：

"""
python內置裝飾器
在python中有三個內置的裝飾器，都是跟class相關的：staticmethod、classmethod、property.
    @staticmethod 是類的靜態方法，其跟成員方法的區別是沒有self參數，並且可以在類不進行實例化的情況下調用
    @classmethod 與成員方法的區別在於所接收的第一個參數不是self（類實例的指針），而是cls（當前類的具體類型）
    @property 是屬性的意思，表示可以通過類實例直接訪問的信息
"""

class Foo(object):
    def __init__(self,var):
        super(Foo,self).__init__()
        self._var=var

    @property
    def var(self):
        return self._var

    @var.setter
    def var(self,var):
        self._var=var

f=Foo('var1')
print(f.var)
f.var='var2'
print(f.var)

"""
注意，對於Python新式類（new-style class），如果將上面的 “@var.setter” 裝飾器所裝飾的成員函數去掉，
則Foo.var 屬性爲只讀屬性，使用 “foo.var = ‘var 2′” 進行賦值時會拋出異常。
但是，對於Python classic class，所聲明的屬性不是 read-only的，所以即使去掉”@var.setter”裝飾器也不會報錯。
"""