python字符串內置函數

一、字符串python

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

二、字符串經常使用操做git

# 1字母處理:
.upper()    # 所有大寫
.lower()    # 所有小寫
.swapcase()    # 大小寫互換
.capitalize()    # 首字母大寫,其他小寫
.title()    # 首字母大寫
a='helLO'

print(a.upper())    # 所有大寫
print(a.lower())    # 所有小寫
print(a.swapcase()) # 大小寫互換
print(a.capitalize())   # 首字母大寫,其他小寫
print(a.title())    # 首字母大寫
View Code
# 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
View Code

 

# 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,傳遞值能多不能少
 

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

isdigit()
True: Unicode數字,byte數字(單字節),全角數字(雙字節),羅馬數字
False: 漢字數字
Error: 無

isdecimal()
True: Unicode數字,,全角數字(雙字節)
False: 羅馬數字,漢字數字
Error: byte數字(單字節)

isnumeric()
True: Unicode數字,全角數字(雙字節),羅馬數字,漢字數字
False: 無
Error: byte數字(單字節)

 四、內置函數數組

  •     數學運算(7個)
  •     類型轉換(24個)
  •     序列操做(8個)
  •     對象操做(7個)
  •     反射操做(8個)
  •     變量操做(2個)
  •     交互操做(2個)
  •     文件操做(1個)
  •     編譯執行(4個)
  •     裝飾器(3個)

數學運算ide

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

對象操做ui

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

變量操做spa

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」裝飾器也不會報錯。
"""
相關文章
相關標籤/搜索