python 字符串函数

python 字符串函数

1、字符串

定义：它是一个有序的字符的集合，用于存储和表示基本的文本信息，‘’或“”或‘’‘ ’‘’中间包含的内容称之为字符串
特性：
1.只能存放一个值
2.不可变
3.按照从左到右的顺序定义字符集合，下标从0开始顺序访问，有序
补充：
　　1.字符串的单引号和双引号都无法取消特殊字符的含义，如果想让引号内所有字符均取消特殊意义，在引号前面加r，如name＝r'l hf'
　　2.unicode字符串与r连用必需在r前面，如name＝ur'l hf'

2、字符串常用操作

# 1字母处理：

# 1字母处理：

 

a='helLO'

 

print(a.upper())    # 全部大写

print(a.lower())    # 全部小写

print(a.swapcase()) # 大小写互换

print(a.capitalize())   # 首字母大写，其余小写

print(a.title())    # 首字母大写

 

# 2格式化相关

# 2格式化相关

 

 

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'xe4xb8xadxe6x96x87')

 

bytes：根据传入的参数创建一个新的不可变字节数组

bytes('中文','utf-8')

b'xe4xb8xadxe6x96x87'

 

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

<span style="font-size: 14pt;"><strong>序列操作</strong></span>

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”装饰器也不会报错。

"""

原文:https://www.cnblogs.com/shenbuer/p/7833953.html