备案控制台
探索云世界
开发者社区 数据库 文章 正文

python字符串常用的方法解析

2017-06-09 683
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 这是本人在学习python过程中总结的一些关于字符串的常用的方法.文中引用了python3.5版本内置的帮助文档,大致进行翻译,并添加了几个小实验.isalnumS.isalnum() -> bool #字符串里所有的字符都是字母或者数字时返回True,否则返回FalseReturn Tr...

这是本人在学习python过程中总结的一些关于字符串的常用的方法.
文中引用了python3.5版本内置的帮助文档,大致进行翻译,并添加了几个小实验.

isalnum

S.isalnum() -> bool #字符串里所有的字符都是字母或者数字时返回True,否则返回False

Return True if all characters in S are alphanumeric and there is
at least one character in S, False otherwise.

>>> str1="hello world"
>>> str2="hello555 world"
>>> str3="66666"
>>> str4="hello"
>>> str1.isalnum()
False
>>> str2.isalnum()
False
>>> str3.isalnum()
True
>>> str4.isalnum()
True

isalpha

S.isalpha() -> bool #字符串里所有的字符都是字母时返回True,否则返回False

Return True if all characters in S are alphabetic and there is
at least one character in S, False otherwise.

>>> str1="hello world"
>>> str2="hello555 world"
>>> str3="66666"
>>> str4="hello"
>>> str1.isalpha()
False
>>> str2.isalpha()
False
>>> str3.isalpha()
False
>>> str4.isalpha()
True

isdigit

S.isdigit() -> bool #字符串里所有字符都是数字则返回True,否则返回False

Return True if all characters in S are digits and there is at
least one character in S, False otherwise.

>>> str1="hello world"
>>> str2="hello555 world"
>>> str3="66666"
>>> str1.isdigit()
False
>>> str2.isdigit()
False
>>> str3.isdigit()
True

islower

S.islower() -> bool #字符串所有的字符都是小写字母时返回True,否则返回False

Return True if all cased characters in S are lowercase and there is
at least one cased character in S, False otherwise.

>>> str1="hello world"
>>> str2="66666"
>>> str3="HELLO WORLD"
>>> str1.islower()
True
>>> str2.islower()
False
>>> str3.islower()
False

istitle

S.istitle() -> bool #每个单词的首字母大写时返回True,否则返回False

Return True if S is a titlecased string and there is at least one
character in S, i.e. upper- and titlecase characters may only
follow uncased characters and lowercase characters only cased ones.
Return False otherwise.

>>> str1="hello world"
>>> str2="Hello World"
>>> str3="HELLO WORLD"
>>> str1.istitle()
False
>>> str2.istitle()
True
>>> str3.istitle()
False

isupper

S.isupper() -> bool #字符串里所有的字符都是大写字母时返回True,否则返回False

Return True if all cased characters in S are uppercase and there is
at least one cased character in S, False otherwise.

>>> str1="hello world"
>>> str2="66666"
>>> str3="HELLO WORLD"
>>> str1.isupper()
False
>>> str2.isupper()
False
>>> str3.isupper()
True

lower

S.lower() -> str #把字符串里所有的字符都转换为小写字母

Return a copy of the string S converted to lowercase.

>>> str3="HELLO WORLD"
>>> str3.lower()
'hello world'

upper

S.upper() -> str #把字符串里所有的字符都转换为大写字母

Return a copy of S converted to uppercase.

>>> str1="hello world"
>>> str1.upper()
'HELLO WORLD'

strip

S.strip([chars]) -> str #去除字符串里的空格

Return a copy of the string S with leading and trailing whitespace removed.
If chars is given and not None, remove characters in chars instead.

>>> str1="     hello world      "
>>> str2="hello world       "
>>> str1.strip()
'hello world'
>>> str2.strip()
'hello world'

isspace

S.isspace() -> bool #字符串里所有的字符都为空格时返回True,否则返回False

Return True if all characters in S are whitespace
and there is at least one character in S, False otherwise.

>>> str1="             "
>>> str2="hello world"
>>> str1.isspace()
True
>>> str2.isspace()
False

replace

S.replace(old, new[, count]) -> str #把字符串里指定的字符替换成新的字符

Return a copy of S with all occurrences of substring
old replaced by new. If the optional argument count is
given, only the first count occurrences are replaced.

>>> str1="hello world"
>>> str1.replace("l","L")
'heLLo worLd'
>>> str2="abababababababab"
>>> str2.replace("a","c")
'cbcbcbcbcbcbcbcb'

index

S.index(sub[, start[, end]]) -> int #返回字符串里的子字符串的索引

Like S.find() but raise ValueError when the substring is not found.

>>> str1="abcdefg"
>>> str1.index("a")
0
>>> str1.index("f")
5

find

S.find(sub[, start[, end]]) -> int #在字符串里查找指定的子串,未找到时返回-1,找到则返回子串在字符串中的索引值

Return the lowest index in S where substring sub is found,
such that sub is contained within S[start:end]. Optional
arguments start and end are interpreted as in slice notation.
Return -1 on failure.

>>> str1="abcdefg"
>>> str2="ababab"
>>> str1.find("bc")
1
>>> str2.find("b")
1
>>> str1.find("f")
5

split

S.split(sep=None, maxsplit=-1) -> list of strings #根据指定的符号分隔字符串

Return a list of the words in S, using sep as the
delimiter string. If maxsplit is given, at most maxsplit
splits are done. If sep is not specified or is None, any
whitespace string is a separator and empty strings are
removed from the result.

>>> str1="/etc/sysconfig/selinux"
>>> str1.split("/")
['', 'etc', 'sysconfig', 'selinux']
>>> str2="abc|mnt|xyz"
>>> str2.split("|")
['abc', 'mnt', 'xyz']

startswith

S.startswith(prefix[, start[, end]]) -> bool #字符串以指定的字符开头时返回True,否则返回False

Return True if S starts with the specified prefix, False otherwise.
With optional start, test S beginning at that position.
With optional end, stop comparing S at that position.
prefix can also be a tuple of strings to try.

>>> str1="hello world"
>>> str2="abcdefg"
>>> str1.startswith("hello")
True
>>> str2.startswith("abc")
True

endswith

S.endswith(suffix[, start[, end]]) -> bool #字符串以指定的字符结尾时返回True,否则返回False

Return True if S ends with the specified suffix, False otherwise.
With optional start, test S beginning at that position.
With optional end, stop comparing S at that position.
suffix can also be a tuple of strings to try.

>>> str1="hello world"
>>> str2="abcdefg"
>>> str1.startswith("hello")
True
>>> str2.startswith("abc")
True
>>> str1.endswith("ld")
True
>>> str2.endswith("fg")
True

lstrip

S.lstrip([chars]) -> str #仅去除字符串左边的空格

Return a copy of the string S with leading whitespace removed.
If chars is given and not None, remove characters in chars instead.

>>> str1="           hello world         "
>>> str2="            hello world"
>>> str3="hello world            "
>>> str1.lstrip()
'hello world         '
>>> str2.lstrip()
'hello world'
>>> str3.lstrip()
'hello world            '

rstrip

S.rstrip([chars]) -> str #仅去除字符串右边的空格

Return a copy of the string S with trailing whitespace removed.
If chars is given and not None, remove characters in chars instead.

>>> str1="           hello world         "
>>> str2="            hello world"
>>> str3="hello world            "
>>> str1.rstrip()
'           hello world'
>>> str2.rstrip()
'            hello world'
>>> str3.rstrip()
'hello world'

rfind

S.rfind(sub[, start[, end]]) -> int #返回子串在字符串中的索引值

Return the highest index in S where substring sub is found,
such that sub is contained within S[start:end]. Optional
arguments start and end are interpreted as in slice notation.

>>> str1="hello world"
>>> str2="abcdefg"
>>> str1.rfind("world")
6
>>> str1.rfind("r")
8
>>> str2.rfind("e")
4
>>> str2.rfind("g")
6

format

S.format(*args, **kwargs) -> str #格式化输出指定的字符串

Return a formatted version of S, using substitutions from args and kwargs.
The substitutions are identified by braces ('{' and '}').

>>> print("{name}======>{age}".format(name="tom",age=22))
tom=========>22
>>> print("{name}======>{age}".format(age=22,name="tom"))
tom=========>22

swapcase

S.swapcase() -> str #把字符串中的小写字母变成大写,大写字母变成小写

Return a copy of S with uppercase characters converted to lowercase
and vice versa.

>>> str1="HELLO world"
>>> str1.swapcase()
'hello WORLD'
>>> str2="hello WORLD"
>>> str2.swapcase()
'HELLO world'

title

S.title() -> str #把字符串中的每个单词变成大写字母开头

Return a titlecased version of S, i.e. words start with title case
characters, all remaining cased characters have lower case.

>>> str1="hello world"
>>> str1.title()
'Hello World'
>>> str2="this is a test string"
>>> str2.title()
'This Is A Test String'

join

S.join(iterable) -> str #把字符串混合插入到一个迭代器中

Return a string which is the concatenation of the strings in the
iterable. The separator between elements is S.

>>> str1="abcd"
>>> str2="xyz"
>>> str1.join(str2)
'xabcdyabcdz'

capitalize

S.capitalize() -> str #把字符串中的首字母变成大写

Return a capitalized version of S, i.e. make the first character
have upper case and the rest lower case.

>>> str1="hello world"
>>> str1.capitalize()
'Hello world'
>>> str1="linux"
>>> str1.capitalize()
'Linux'

center

S.center(width[, fillchar]) -> str #扩充字符串到指定长度,不够则用第二个参数的字符填充,默认为空格

Return S centered in a string of length width. Padding is
done using the specified fill character (default is a space)

>>> str1="hello world"
>>> str1.center(30,"#")
'############linux#############'
>>> str2="linux"
>>> str2.center(16,"*")
'*****linux******'

count

S.count(sub[, start[, end]]) -> int #判断子串在字符串中出现的次数

Return the number of non-overlapping occurrences of substring sub in
string S[start:end]. Optional arguments start and end are
interpreted as in slice notation.

>>> str1="hello world"
>>> str1.count("l")
3
>>> str2="aaaaaaaaaaaa"
>>> str2.count("a")
12

ljust

S.ljust(width[, fillchar]) -> str #扩充字符串到指定长度,不足则由第二个参数从右边填充,默认为空格

Return S left-justified in a Unicode string of length width. Padding is
done using the specified fill character (default is a space).

>>> str1="hello world"
>>> str1.ljust(20,"@")
'hello world@@@@@@@@@'
>>> str2="linux"
>>> str2.ljust(18,"&")
'linux&&&&&&&&&&&&&'

rjust

S.rjust(width[, fillchar]) -> str #扩充字符串到指定长度,不足由第二个参数从左边填充,默认为空格

Return S right-justified in a string of length width. Padding is
done using the specified fill character (default is a space).

>>> str1="hello world"
>>> str2="linux"
>>> str1.rjust(30,"#")
'###################hello world'
>>> str2.rjust(14,"$")
'$$$$$$$$$linux'

rsplit

S.rsplit(sep=None, maxsplit=-1) -> list of strings #从文件尾部开始按指定的分隔符切分字符串

Return a list of the words in S, using sep as the
delimiter string, starting at the end of the string and
working to the front. If maxsplit is given, at most maxsplit
splits are done. If sep is not specified, any whitespace string
is a separator.

>>> str1="hello/world/people"
>>> str1.rsplit("/")
['hello', 'world', 'people']
>>> str2="/etc/sysconfig/selinux"
>>> str2.rsplit("/")
['', 'etc', 'sysconfig', 'selinux']

expandtabs

S.expandtabs(tabsize=8) -> str #按照所给的参数把一个制表符转换成指定的空格,默认为转换为8个空格

Return a copy of S where all tab characters are expanded using spaces.
If tabsize is not given, a tab size of 8 characters is assumed.

>>> str1="hello\tworld"
>>> print(str1)
hello   world
>>> str1.expandtabs()
'hello   world'
>>> str1.expandtabs(8)
'hello   world'
>>> str1.expandtabs(2)
'hello world'
>>> str1.expandtabs(12)
'hello       world'

rindex

S.rindex(sub[, start[, end]]) -> int #返回子串在字符串中的索引值,未找到则抛出异常

Like S.rfind() but raise ValueError when the substring is not found.

>>> str1="abcdefghijklmn"
>>> str1.rindex("abc")
0
>>> str1.rindex("efg")
4
>>> str1.rindex("g")
6
>>> str1.rindex("m")
12

isprintable

S.isprintable() -> bool #字符里所有的字符都为可打印字符时返回True,否则返回False

Return True if all characters in S are considered
printable in repr() or S is empty, False otherwise.

>>> str1="              "
>>> str2="hello world"
>>> str1.isprintable()
True
>>> str2.isprintable()
True
>>> str3="\t"
>>> print(str3)
>>> str3.isprintable()
False

splitlines

S.splitlines([keepends]) -> list of strings #按照换行符分隔字符串,返回分隔后的列表

Return a list of the lines in S, breaking at line boundaries.
Line breaks are not included in the resulting list unless keepends
is given and true.

>>> str1="hello \e world"
>>> print(str1)
hello \e world
>>> str1.splitlines()
['hello \\e world']
>>> type(str1.splitlines())
<class 'list'>
>>> str2="hello world"
>>> str2.splitlines()
['hello world']

format_map

S.format_map(mapping) -> str #格式化输出字符串

Return a formatted version of S, using substitutions from mapping.
The substitutions are identified by braces ('{' and '}').

>>> str1="hello world {lang}"
>>> lang="python"
>>> print(str1.format_map(vars()))
hello world python
>>> str2="{os} {database} {webserver} python"
>>> os="linux"
>>> database="mysql"
>>> webserver="apache"
>>> print(str2.format_map(vars()))
linux mysql apache python

isnumeric

S.isnumeric() -> bool #字符串里所有的字符都是数字时返回True,否则返回False

Return True if there are only numeric characters in S,
False otherwise.

>>> str1="123456"
>>> str2="123.456"
>>> str3="hello world"
>>> str1.isnumeric()
True
>>> str2.isnumeric()
False
>>> str3.isnumeric()
False

partition

S.partition(sep) -> (head, sep, tail) #按照给定的字符分隔字符串,返回一个元组,如果给定的字符串有多个,则以第一个索引为准

Search for the separator sep in S, and return the part before it,
the separator itself, and the part after it. If the separator is not
found, return S and two empty strings.

>>> str1="hello world"
>>> str1.partition(" ")
('hello', ' ', 'world')
>>> str1.partition("l")
('he', 'l', 'lo world')
>>> str1.partition("w")
('hello ', 'w', 'orld')

rpartition

S.rpartition(sep) -> (head, sep, tail) #按照给定的字符分隔字符串,返回一个元组

Search for the separator sep in S, starting at the end of S, and return
the part before it, the separator itself, and the part after it. If the
separator is not found, return two empty strings and S.

>>> str1="abcdefg"
>>> str1.rpartition("b")
('a', 'b', 'cdefg')
>>> str1.rpartition("d")
('abc', 'd', 'efg')
>>> str1.rpartition("g")
('abcdef', 'g', '')
文章标签：
云解析DNS
Python
Linux
索引
关系型数据库
网络架构
MySQL
Apache
关键词：
方法云解析DNS
Python解析
python云解析DNS
云解析DNS python
Python方法
任平生78
目录
相关文章
阿里开发者
|
1天前
|
SQL 分布式计算 资源调度
一文解析 ODPS SQL 任务优化方法原理
本文重点尝试从ODPS SQL的逻辑执行计划和Logview中的执行计划出发，分析日常数据研发过程中各种优化方法背后的原理，覆盖了部分调优方法的分析，从知道怎么优化，到为什么这样优化，以及还能怎样优化。
阿里开发者
14 0
东北赵四
|
1天前
并发编程之Callable方法的详细解析(带小案例)
并发编程之Callable方法的详细解析(带小案例)
东北赵四
9 0
长梦
|
4天前
|
数据采集 机器学习/深度学习 数据挖掘
Python数据清洗与预处理面试题解析
【4月更文挑战第17天】本文介绍了Python数据清洗与预处理在面试中的常见问题，包括Pandas基础操作、异常值处理和特征工程。通过示例代码展示了数据读取、筛选、合并、分组统计、离群点检测、缺失值和重复值处理、特征缩放、编码、转换和降维。强调了易错点，如忽视数据质量检查、盲目处理数据、数据隐私保护、过度简化特征关系和忽视模型输入要求。掌握这些技能和策略将有助于在面试中脱颖而出。
长梦
23 8
阿文没烦恼
|
5天前
|
存储 关系型数据库 MySQL
Python搭建代理IP池实现存储IP的方法
Python搭建代理IP池实现存储IP的方法
阿文没烦恼
27 2
阿文没烦恼
|
5天前
|
Python
Python动态IP代理防止被封的方法
Python动态IP代理防止被封的方法
阿文没烦恼
26 3
阿文没烦恼
|
5天前
|
数据采集 存储 安全
python检测代理ip是否可用的方法
python检测代理ip是否可用的方法
阿文没烦恼
15 0
长梦
|
6天前
|
调度 Python
Python多线程、多进程与协程面试题解析
【4月更文挑战第14天】Python并发编程涉及多线程、多进程和协程。面试中，对这些概念的理解和应用是评估候选人的重要标准。本文介绍了它们的基础知识、常见问题和应对策略。多线程在同一进程中并发执行，多进程通过进程间通信实现并发，协程则使用`asyncio`进行轻量级线程控制。面试常遇到的问题包括并发并行混淆、GIL影响多线程性能、进程间通信不当和协程异步IO理解不清。要掌握并发模型，需明确其适用场景，理解GIL、进程间通信和协程调度机制。
长梦
24 0
长梦
|
6天前
|
API Python
Python模块化编程：面试题深度解析
【4月更文挑战第14天】了解Python模块化编程对于构建大型项目至关重要，它涉及代码组织、复用和维护。本文深入探讨了模块、包、导入机制、命名空间和作用域等基础概念，并列举了面试中常见的模块导入混乱、不适当星号导入等问题，强调了避免循环依赖、合理使用`__init__.py`以及理解模块作用域的重要性。掌握这些知识将有助于在面试中自信应对模块化编程的相关挑战。
长梦
19 0
4as3qn2go3ure
|
7天前
|
数据可视化 测试技术 Python
在Python和R中使用交叉验证方法提高模型性能
在Python和R中使用交叉验证方法提高模型性能
4as3qn2go3ure
13 0
cuicuicuic
|
7天前
|
存储 监控 开发工具
对象存储OSS产品常见问题之python sdk中的append_object方法支持追加上传xls文件如何解决
对象存储OSS是基于互联网的数据存储服务模式，让用户可以安全、可靠地存储大量非结构化数据，如图片、音频、视频、文档等任意类型文件，并通过简单的基于HTTP/HTTPS协议的RESTful API接口进行访问和管理。本帖梳理了用户在实际使用中可能遇到的各种常见问题，涵盖了基础操作、性能优化、安全设置、费用管理、数据备份与恢复、跨区域同步、API接口调用等多个方面。
cuicuicuic
38 9

热门文章

最新文章

  • 1
    阿里云 MaxCompute MaxFrame 开启免费邀测，统一 Python 开发生态
  • 2
    使用Python实现DBSCAN聚类算法
  • 3
    在Python Web开发过程中：数据库与缓存，MySQL和NoSQL数据库的主要差异是什么？
  • 4
    Pandas基本操作：Series和DataFrame（Python）
  • 5
    【Python】python天气数据抓取与数据分析（源码+论文）【独一无二】
  • 6
    Python 学习之路 01基础入门---【Python安装，Python程序基本组成】
  • 7
    流畅的 Python 第二版（GPT 重译）（十一）(1)
  • 8
    流畅的 Python 第二版（GPT 重译）（一）(1)
  • 9
    Python速成篇（基础语法）上
  • 10
    Python函数使用(四)
  • 1
    一文解析 ODPS SQL 任务优化方法原理
    14
  • 2
    并发编程之线程池的底层原理的详细解析
    9
  • 3
    并发编程之线程池的详细解析
    5
  • 4
    并发编程之读写锁ReadWriteLock的详细解析(带小案例)
    6
  • 5
    并发编程之的HashSet和HashMap的详细解析
    5
  • 6
    Redis 实现延迟任务的深度解析
    15
  • 7
    并发编程之的ArrayList安全性的详细解析
    6
  • 8
    并发编程之的虚假唤醒和精准唤醒的详细解析
    11
  • 9
    并发编程之synchronized的详细解析
    10
  • 10
    并发编程之线程池的应用以及一些小细节的详细解析
    13

    • 相关课程

    更多
  • Python网络编程
  • Python Web 框架 Flask 快速入门
  • Python Web 框架 Django 快速入门
  • Java面试疑难点解析 - 面试技巧及语言基础
  • Java面试疑难点解析 - Java Web开发
  • Java面试疑难点解析 - 系统架构及项目设计

    • 相关电子书

    更多
  • 神龙云服务器产品及技术深度解析
  • 弹性创造价值：基于ECS的最佳性价比实践解析
  • 又快又稳：阿里云下一代虚拟交换机解析

    • 相关实验场景

    更多
  • 用Python画圣诞树
  • 使用Python完成RDS数据开发及分析
  • 通过云拨测对指定服务器进行Ping/DNS监测
  • Python选择及循环结构
  • 云端Python及基本操作
  • Python网络通信程序典型应用

    • 推荐镜像

    更多
  • DNS
  • NTP
  • kali-security
    • 下一篇
    部署LAMP环境（Alibaba Cloud Linux 3）