python字符串內置函數

1、字符串

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

2、字符串常用操作

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

a='helLO'

print(a.upper())    # 全部大寫
print(a.lower())    # 全部小寫
print(a.swapcase()) # 大小寫互換
print(a.capitalize())   # 首字母大寫，其余小寫
print(a.title())    # 首字母大寫

# 2格式化相關

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

a='1 2'
print(a.ljust(10))  # 獲取固定長度，左對齊，右邊不夠用空格補齊
print(a.rjust(10))  # 獲取固定長度，右對齊，左邊不夠用空格補齊
print(a.center(10)) # 獲取固定長度，中間對齊，兩邊不夠用空格補齊
print(a.zfill(10))  # 獲取固定長度，右對齊，左邊不足用0補齊


執行結果：
1 2       
       1 2
   1 2    
00000001 2

 

# 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的區別

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個)

數學運算

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))    # 傳入可迭代對象、元素類型必須是數值型

類型轉換

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對象 

序列操作

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：聚合傳入的每個迭代器中相同位置的元素，返回一個新的元組類型迭代器

對象操作

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'}

反射操作

__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

變量操作

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

交互操作

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

文件操作

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

# 讀取文件
a= open('a.text','rt')
print(a.read())
a.close()

編譯執行

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'

裝飾器

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”裝飾器也不會報錯。
"""