python字符串内置函数

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	<span style = "font-size: 14pt" ><strong>序列操作< / strong>< / span>

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