精华内容
下载资源
问答
  • python字符串内置函数

    2020-06-03 14:02:24
    python字符串内置函数1、字符串2、字符串常用操作1、字母大小写:2、对齐方式3、搜索相关4、字符串替换5、字符串去空格及去指定字符6、字符串判断相关 is补充python中str函数isdigit、isdecimal、isnumeric的区别...

    1、字符串

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

    >>> a=r'abc'
    >>> a
    'abc'
    

    2、字符串常用操作

    1、字母大小写:

    .upper()    # 全部大写
    .lower()    # 全部小写
    .swapcase()    # 大小写互换
    .capitalize()    # 首字母大写,其余小写
    .title()    # 首字母大写
    

    2、对齐方式

    .ljust(width)     # 获取固定长度,左对齐,右边不够用空格补齐
    .rjust(width)     # 获取固定长度,右对齐,左边不够用空格补齐
    .center(width)  # 获取固定长度,中间对齐,两边不够用空格补齐
    .zfill(width)      # 获取固定长度,右对齐,左边不足用0补齐
    

    3、搜索相关

    .find()    # 搜索指定字符串,没有返回-1
    .index()    # 同上,但是找不到会报错
    .rfind()    # 从右边开始查找
    .count()    # 统计指定的字符串出现的次数
    上面所有方法都可以用index代替,不同的是使用index查找不到会抛异常,而find返回-1
    

    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、字符串判断相关 is

    .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的区别

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

    数学运算(7个)

    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:字符串 (给用户)

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

    ange:根据传入的参数创建一个新的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:聚合传入的每个迭代器中相同位置的元素,返回一个新的元组类型迭代器
    对象操作

    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
    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
    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(‘222’)) # 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”装饰器也不会报错。
    “”"
    复制代码

    展开全文
  • python字符串内置函数 Python中的内置字符串函数 (Built-in String Functions in Python) For the final portion, we will see some really useful string functions to work with strings in python. Below we ...

    python字符串内置函数

    For the final portion, we will see some really useful string functions to work with strings in python. Below we have mentioned a few useful string functions.

    对于最后一部分,我们将看到一些非常有用的字符串函数,可用于python中的字符串。 下面我们提到了一些有用的字符串函数。

    len(字符串) (len(string))

    len or length function is used to find the character length of any string. len returns a number and it takes a string as an argument. For Example,

    len或length函数用于查找任何字符串的字符长度。 len返回一个数字,并使用字符串作为参数。 例如,

    >>> s = "Hello"
    >>> print (len(s))

    5

    5

    Live Example →

    现场示例→

    查找(子字符串) (find(subString))

    In case you want to find the position of any character or of a subString within any given string, you can use the find function. It's implementation is a little different than a normal function but it's not tough to understand. Obviously to find a subString in a string, we will have to provide both the main string and the subString to be found, to the funtion. For Example,

    如果要查找任何字符或子字符串在给定字符串中的位置,可以使用find函数。 它的实现与普通函数有些不同,但并不难理解。 显然,要在字符串中查找subString,我们必须将主要字符串和要找到的subString提供给该功能。 例如,

    >>> s = "Hello"
    >>> ss = "He"
    >>> print (s.find(ss))

    0

    0

    Since, He is present at the beginning of the string Hello, hence index 0 is returned as the result. It can be directly implemented/used as follows(in case you hate useless typing; which every programmer do):

    由于He存在于字符串Hello的开头,因此返回索引0 。 它可以按以下方式直接实现/使用(以防万一您讨厌无用的输入;每个程序员都可以这样做):

    >>> print ("Hello".find("He"))

    0

    0

    Live Example →

    现场示例→

    string_name.lower() (string_name.lower())

    lower() function is used to convert all the uppercase characters present in a string into lowercase. It takes a string as the function input, however the string is not passed as argument. This function returns a string as well.

    lower()函数用于将字符串中存在的所有大写字符转换为小写。 它使用字符串作为函数输入,但是不会将字符串作为参数传递。 此函数也返回一个字符串。

    >>> print ("Hello, World".lower());

    hello, world

    你好,世界

    Live Example →

    现场示例→

    string_name.upper() (string_name.upper())

    upper() is used to turn all the characters in a string to uppercase.

    upper()用于将字符串中的所有字符变为大写。

    >>> print ("Hello, World".upper());

    HELLO, WORLD

    你好,世界

    Live Example →

    现场示例→

    string_name.islower() (string_name.islower())

    islower() is used to check if string_name string is in lowercase or not. This functions returns a boolean value as result, either True or False.

    islower()用于检查string_name字符串是否小写。 该函数返回一个布尔值TrueFalse

    >>> print ("hello, world".islower())

    True

    真正

    Live Example →

    现场示例→

    >>> print ("Hello, World".islower());

    False

    string_name.isupper() (string_name.isupper())

    isupper() is used to check if the given string is in uppercase or not. This function also returns a boolean value as result, either True or False.

    isupper()用于检查给定的字符串是否为大写。 此函数还返回布尔值TrueFalse

    >>> print ("HELLO, WORLD".isupper());

    True

    真正

    >>> print ("Hello, World".isupper());

    False

    Live Example →

    现场示例→

    string_name.replace(old_string,new_string) (string_name.replace(old_string, new_string))

    replace() function will first of all take a string as input, and ask for some subString within it as the first argument and ask for another string to replace that subString as the second argument. For Example,

    replace()函数首先将一个字符串作为输入,并要求其中包含一些subString作为第一个参数,并要求另一个字符串替换该subString作为第二个参数。 例如,

    >>> print ("Hello, World".replace("World", "India"));

    Hello, India

    你好,印度

    Live Example →

    现场示例→

    string_name.split(字符,整数) (string_name.split(character, integer))

    Suppose you're having a string say,

    假设您说的是一个字符串,

    >>> mystring = "Hello World! Welcome to the Python tutorial"

    Now we can use the split() function to split the above declared string.

    现在我们可以使用split()函数拆分上面声明的字符串。

    If we choose to split the string into two substring from the exclamation mark !. We can do that by putting an exclamation mark ! in the character argument. It will basically split the string into different parts depending upon the number of exclamation marks ! in the string. All the sub-pieces of the string will be stored in a list. Like,

    如果我们选择从感叹号将字符串分成两个子字符串! 。 我们可以通过添加感叹号来做到这一点! 在字符参数中。 基本上会根据感叹号的数量将字符串分成不同的部分! 在字符串中。 字符串的所有子片段都将存储在列表中。 喜欢,

    >>> print (mystring.split("!"))

    ['Hello World', ' Welcome to the Python tutorial']

    ['Hello World','欢迎使用Python教程']

    You can store these values to another variable and access each element of it like this:

    您可以将这些值存储到另一个变量,并按如下方式访问它的每个元素:

    >>> myNEWstring = mystring.split("!")
    >>> print (myNEWstring[0]);
    >>> print (myNEWstring[1]);

    Hello World Welcome to the Python tutorial

    Hello World欢迎使用Python教程

    Live Example →

    现场示例→

    翻译自: https://www.studytonight.com/python/string-functions

    python字符串内置函数

    展开全文
  • python字符串内置函数For the final portion, we will see some really useful string functions to work with strings in python. Below we have mentioned a few useful string functions.对于最后一部分,我们将...

    python字符串内置函数

    For the final portion, we will see some really useful string functions to work with strings in python. Below we have mentioned a few useful string functions.

    对于最后一部分,我们将看到一些非常有用的字符串函数,可用于python中的字符串。 下面我们提到了一些有用的字符串函数。

    len(字符串) (len(string))

    len or length function is used to find the character length of any string. len returns a number and it takes a string as an argument. For Example,

    len或length函数用于查找任何字符串的字符长度。 len返回一个数字,并使用字符串作为参数。 例如,

    >>> s = "Hello"

    >>> print (len(s))

    5

    5

    Live Example →

    现场示例→

    查找(子字符串) (find(subString))

    In case you want to find the position of any character or of a subString within any given string, you can use the find function. It's implementation is a little different than a normal function but it's not tough to understand. Obviously to find a subString in a string, we will have to provide both the main string and the subString to be found, to the funtion. For Example,

    如果要查找任何字符或子字符串在给定字符串中的位置,可以使用find函数。 它的实现与普通函数有些不同,但并不难理解。 显然,要在字符串中查找subString,我们必须将主要字符串和要找到的subString提供给该功能。 例如,

    >>> s = "Hello"

    >>> ss = "He"

    >>> print (s.find(ss))

    0

    0

    Since, He is present at the beginning of the string Hello, hence index 0 is returned as the result. It can be directly implemented/used as follows(in case you hate useless typing; which every programmer do):

    由于He存在于字符串Hello的开头,因此返回索引0 。 它可以按以下方式直接实现/使用(以防万一您讨厌无用的输入;每个程序员都可以这样做):

    >>> print ("Hello".find("He"))

    0

    0

    Live Example →

    现场示例→

    string_name.lower() (string_name.lower())

    lower() function is used to convert all the uppercase characters present in a string into lowercase. It takes a string as the function input, however the string is not passed as argument. This function returns a string as well.

    lower()函数用于将字符串中存在的所有大写字符转换为小写。 它使用字符串作为函数输入,但是不会将字符串作为参数传递。 此函数也返回一个字符串。

    >>> print ("Hello, World".lower());

    hello, world

    你好,世界

    Live Example →

    现场示例→

    string_name.upper() (string_name.upper())

    upper() is used to turn all the characters in a string to uppercase.

    upper()用于将字符串中的所有字符变为大写。

    >>> print ("Hello, World".upper());

    HELLO, WORLD

    你好,世界

    Live Example →

    现场示例→

    string_name.islower() (string_name.islower())

    islower() is used to check if string_name string is in lowercase or not. This functions returns a boolean value as result, either True or False.

    islower()用于检查string_name字符串是否小写。 该函数返回一个布尔值True或False 。

    >>> print ("hello, world".islower())

    True

    真正

    Live Example →

    现场示例→

    >>> print ("Hello, World".islower());

    False

    string_name.isupper() (string_name.isupper())

    isupper() is used to check if the given string is in uppercase or not. This function also returns a boolean value as result, either True or False.

    isupper()用于检查给定的字符串是否为大写。 此函数还返回布尔值True或False 。

    >>> print ("HELLO, WORLD".isupper());

    True

    真正

    >>> print ("Hello, World".isupper());

    False

    Live Example →

    现场示例→

    string_name.replace(old_string,new_string) (string_name.replace(old_string, new_string))

    replace() function will first of all take a string as input, and ask for some subString within it as the first argument and ask for another string to replace that subString as the second argument. For Example,

    replace()函数首先将一个字符串作为输入,并要求其中包含一些subString作为第一个参数,并要求另一个字符串替换该subString作为第二个参数。 例如,

    >>> print ("Hello, World".replace("World", "India"));

    Hello, India

    你好,印度

    Live Example →

    现场示例→

    string_name.split(字符,整数) (string_name.split(character, integer))

    Suppose you're having a string say,

    假设您说的是一个字符串,

    >>> mystring = "Hello World! Welcome to the Python tutorial"

    Now we can use the split() function to split the above declared string.

    现在我们可以使用split()函数拆分上面声明的字符串。

    If we choose to split the string into two substring from the exclamation mark !. We can do that by putting an exclamation mark ! in the character argument. It will basically split the string into different parts depending upon the number of exclamation marks ! in the string. All the sub-pieces of the string will be stored in a list. Like,

    如果我们选择从感叹号将字符串分成两个子字符串! 。 我们可以通过添加感叹号来做到这一点! 在字符参数中。 基本上会根据感叹号的数量将字符串分成不同的部分! 在字符串中。 字符串的所有子片段都将存储在列表中。 喜欢,

    >>> print (mystring.split("!"))

    ['Hello World', ' Welcome to the Python tutorial']

    ['Hello World','欢迎使用Python教程']

    You can store these values to another variable and access each element of it like this:

    您可以将这些值存储到另一个变量,并按如下方式访问它的每个元素:

    >>> myNEWstring = mystring.split("!")

    >>> print (myNEWstring[0]);

    >>> print (myNEWstring[1]);

    Hello World Welcome to the Python tutorial

    Hello World欢迎使用Python教程

    Live Example →

    现场示例→

    翻译自: https://www.studytonight.com/python/string-functions

    python字符串内置函数

    展开全文
  • 主要介绍了Python字符串内置函数功能与用法,结合实例形式总结分析了Python常见字符串操作函数的功能、分类、使用方法及相关操作注意事项,需要的朋友可以参考下
  • Python字符串内置函数

    千次阅读 2018-04-19 19:16:33
    转自:点击打开链接1、字符串定义:它是一个有序的字符的集合,用于存储和表示基本的文本信息,‘’或“”或‘’‘ ’‘’中间包含的内容称之为字符串特性:1.只能存放一个值2.不可变3.按照从左到右的顺序定义字符...

    转自:点击打开链接

    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()
    TrueUnicode数字,byte数字(单字节),全角数字(双字节),罗马数字
    False: 汉字数字
    Error: 无
     
    isdecimal()
    TrueUnicode数字,,全角数字(双字节)
    False: 罗马数字,汉字数字
    Error: byte数字(单字节)
     
    isnumeric()
    TrueUnicode数字,全角数字(双字节),罗马数字,汉字数字
    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 30in <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 50in <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”装饰器也不会报错。
    """
    复制代码

     

    展开全文

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 5,780
精华内容 2,312
关键字:

python字符串内置函数

python 订阅