目录
str.split（sep=None,maxsplit=-1） 从左到右分割。
str.rsplit（sep=None,maxsplit=-1） 从右到左分割。
学习资料来自：鱼Ｃ论坛，菜鸟教程，Ｃ语言中文网
字符串
1.利用字符串判断一个数是否是回文数。
str=input("请输入一个数：")
print("是回文数")if str==str[::-1] else print("不是回文数")2.有关字母大小写的字符串函数
| 方法 | 描述 |
| str.capitalize() | 将字符串的首字母大写，其他小写。 |
| str.casefold() | 将字符串所有的字母小写。（除了英文外，还可以处理其他语言） |
| str.lower() | 将字符串所有的字母小写。（只能处理英文字母） |
| str.swapcase() | 将字符串中字母大小写进行翻转。 |
| str.upper() | 将字符串所有的字母大写。 |
| str.title() | 将字符串中每个单词的首字母大写，其他小写。 |
>>> str="I love Python"
>>> str.capitalize()
'I love python'
>>> str.casefold()
'i love python'
>>> str.swapcase()
'i LOVE pYTHON'
>>> str.upper()
'I LOVE PYTHON'
>>> str.title()
'I Love Python'
>>> a='&'
>>> a.casefold()
'&'
>>> str.lower()
'i love python'3.字符串的左中右对齐
width:指定字符串的宽度。指定宽度小于等于原字符串，直接输出原字符串。
fillchar：表示填充空格的字符。
| 方法 | 描述 |
| str.center（width,fillchar=''） | 将字符串居中对齐 |
| str.ljust（width,fillchar=''） | 将字符串左对齐 |
| str.rjust（width,fillchar=''） | 将字符串右对齐 |
| str.zfill(width) | 将字符串用0填充左侧 |
>>> str="你没事吧？"
>>> str.center(5)
'你没事吧？'
>>> str.center(10)
' 你没事吧？ '
>>> str.center(10,"-")
'--你没事吧？---'
>>> str.rjust(10,'#')
'#####你没事吧？'
>>> str.rjust(10)
' 你没事吧？'
>>> str.ljust(10)
'你没事吧？ '
>>> str.zfill(10)
'00000你没事吧？'4.字符串的查找功能
start，end:表示查找的起点和终点。start闭区间，end开区间。
| 方法 | 描述 |
| str.count(sub[,start[,end]]) | sub:计算子字符串出现的次数。 |
| str.find(sub[,start[,end]]) | sub:定位子字符串的索引下标值。从左往右查找。 只能找到一个值。如果不存在字符串会返回-1. |
| str.rfind(sub[,start[,end]]) | sub:定位子字符串的索引下标值。从右往左查找。 只能找到一个值。如果不存在字符串会返回-1. |
| str.index(sub[,start[,end]]) | sub:定位子字符串的索引下标值。从左往右查找。只能找到一个值。如果不存在字符串会报错。 |
| str.rindex(sub[,start[,end]]) | sub:定位子字符串的索引下标值。从右往左查找。只能找到一个值。如果不存在字符串会报错。 |
>>> a='牛奶奶不买刘奶奶的牛奶'
>>> a.count("奶奶",0)
2
>>> a.count("奶",0)
5
>>> a.find("奶",0)
1
>>> a.rfind("奶",0)
10
>>> a.rfind("奶",11,5)
-1
>>> a.rfind("奶",10,5)
-1
>>> a.rfind("奶",5,10)
7
>>> a.rfind("奶",11)#下标超过
-1
>>> a.rfind("你",10)#不存在子字符串
-1
>>> a.count("你",10)#不存在子字符串
0
>>> a.index("你",10)#不存在子字符串
Traceback (most recent call last):
File "<pyshell#38>", line 1, in <module>
a.index("你",10)#不存在子字符串
ValueError: substring not found
>>> a.index("奶",5,10)
6
>>> a.rindex("奶",5,10)
75.字符串的替换
| 方法 | 描述 |
| str.replace(old,new,count=-1) | 返回一个将old子字符串替换成new新子字符串的字符串。count表示替换次数，默认值是-1，未设置表示替换全部。 |
| str.translate(table) | 返回一个根据table参数转化的新字符串。table用于指定一个转换规则的表格。 |
str.replace(old,new,count=-1)
>>> "在吗，你没事吧？你没事吧？没事就吃溜溜梅。".replace("你没事吧？","你有事吗？")
'在吗，你有事吗？你有事吗？没事就吃溜溜梅。'
>>> "在吗，你没事吧？你没事吧？没事就吃溜溜梅。".replace("你没事吧？","你有事吗？",1)
'在吗，你有事吗？你没事吧？没事就吃溜溜梅。'str.translate(table)
>>> table=str.maketrans("ABCD","1234")#字符串的静态方法
>>> "A C yibB".translate(table)
'1 3 yib2'
>>> "A C yibB".translate(str.maketrans("ABCD","1234"))
'1 3 yib2'
>>> "A C yibBD".translate(str.maketrans("ABC","1234"))#替换的新旧子字符串长度要一致
Traceback (most recent call last):
File "<pyshell#56>", line 1, in <module>
"A C yibBD".translate(str.maketrans("ABC","1234"))
ValueError: the first two maketrans arguments must have equal length补充：
str.maketrans()支持将指定字符串忽略。
>>> "A C yibB".translate(str.maketrans("ABCD","1234"))
'1 3 yib2'
>>> "A C yCbB".translate(str.maketrans("ABCD","1234","yCbB"))
'1 '
>>> "A C yCbB".translate(str.maketrans("ABCD","1234","ycbb"))
'1 3 32'6.字符串的判断和检测
各个函数的返回值都是布尔类型（True 和 False）。
| 方法 | 描述 |
| str.startswith(prefix[,start[,end]]) | 判断参数指定的子字符串，是否出现在字符串的起始位置。 |
| str.startswith(prefix[,start[,end]]) | 判断参数指定的子字符串，是否出现在字符串的末尾位置。 |
| str.isupper() | 判断字符串是否所有的字母大写。 |
| str.islower() | 判断字符串是否所有的字母小写。 |
| str.istitle() | 判断字符串中每个单词的首字母大写，其他小写。 |
| str.isalpha() | 判断整个字符串是否都是字母。 |
| str.isspace() | 判断整个字符串是否都是空白。 |
| str.isprintable() | 判断整个字符串是否都是可以打印的。转移字符不可以被打印。 |
| str.isdecimal() | 判断字符串是否为数字。不能判断2²，不能判断罗马数字，不能判断中文数字。 |
| str.isdigit() | 判断字符串是否为数字。不能判断罗马数字,不能判断中文数字. |
| str.isnumeric() | 判断字符串是否为数字。 |
| str.isalnum() | str.isalpha() str.isdecimal() str.isdecimal() str.isdigit()任意一个能返回True, str.isalnum()返回True. |
| str.isidentifier() | 判断字符串是否为一个合法的Python标识（zhi）符。 合法标识符： 1、标识符由英文字母、数字和下划线组成，但第一个字符不能是数字；2、标识符不能和python中的保留字相同；3、标识符中不能包含空格、@等特殊字符。 |
str.startswith(prefix[,start[,end]])
>>> #判断字符串起始位置startswith(prefix[,start[,end]])
>>> str="I love Python"
>>> str.startswith("I")
True
>>> str.startswith("P",7,9)
Truestr.startswith(prefix[,start[,end]]) 第一个参数可以以元组形式导入多个字符串。
>>> x="我爱Python"
>>> x.endswith("on",-1)
False
>>> x.endswith("n",-1)
True
>>> x.endswith(("你","我",1))
Traceback (most recent call last):
File "<pyshell#3>", line 1, in <module>
x.endswith(("你","我",1))
TypeError: tuple for endswith must only contain str, not int
>>> x.endswith(("你","我","1"))
False
>>> x.startswith(("你","我","1"))
True上文已经提到过str.upper() str.lower() str.title() ，不对str.isupper() str.islower() str.istitle()进行演示。
补充：
在一个语句中连续调用多个方法，Python会从左往右一次进行调用。
>>> x="I love Python"
>>> x.lower().islower()
True
>>> str.isspace()
空白除了空格还包括Tab和一些转义字符。
换页符：\f 换行符：\n 回车键：\r 水平制表符：\t 垂直制表符：\v
>>> "\f".isspace()
True
>>> "\n".isspace()
True
>>> "\r".isspace()
True
>>> "\t".isspace()
True
>>> "\v".isspace()
Truestr.isprintable() 转移字符不可以被打印。
>>> "\n".isprintable()
False
>>> str.isdecimal() str.isdigit() str.isnumeric() str.isalnum()
a="12"
>>> a.isdecimal()
True
>>> a.isdigit()
True
>>> a.isnumeric()
True
>>> b="一四"
>>> b.isdigit()
False
>>> b.isdecimal()
False
>>> b.isnumeric()
Truestr.isidentifier()
>>> "3".isidentifier()
False
>>> "a3".isidentifier()
True补充：
判断一个字符串是否为Python的保留标识符。（if while 之类）
>>> import keyword
>>> keyword.iskeyword("while")
True7.字符串的截取
| 方法 | 描述 |
| str.lstrip(char==None) | 去除字符串左侧留白。 |
| str.rstrip(char==None) | 去除字符串右侧留白。 |
| str.strip(char==None) | 去除字符串左右留白。 |
| str.removeprefix(prefix) | prefix前缀，去除字符串指定前缀。 |
| str.removesuffix(suffix) | suffix后缀，去除字符串指定后缀。 |
str.lstrip(char==None) str.rstrip(char==None) str.strip(char==None)
>>> " 12".lstrip()
'12'
>>> " 12 ".rstrip()
' 12'
>>> " 12 ".strip()
'12'char==None参数未设置默认空格，也可以添加字符串。
>>> "wwww12".lstrip("www")
'12'
>>> "wwww12".lstrip("w")
'12'
>>> "wwww12".rstrip("w")
'wwww12'
>>> "wwww12www".rstrip("w")
'wwww12'
>>> "wwww12www".strip("w")
'12'removeprefix(prefix) removesuffix(suffix)
py.3.9版本可用
>>> 'TestHook'.removeprefix('Test')
'Hook'
>>> 'BaseTestCase'.removeprefix('Test')
'BaseTestCase'8.字符串的分割和拼接
| 方法 | 描述 |
| str.partition（sep） | 将字符串以参数指定的分割符为依据进行切割，将切割后的结果返回一个三元组（三个元素的元组）。从左到右分割。 |
| str.rpartition（sep） | 将字符串以参数指定的分割符为依据进行切割，将切割后的结果返回一个三元组（三个元素的元组）。从右到左分割。 |
| str.split（sep=None,maxsplit=-1） | 使用split方法可以根据分割符把字符串任意分割。从左到右分割。 |
| str.rsplit（sep=None,maxsplit=-1） | 使用rsplit方法可以根据分割符把字符串任意分割。从右到左分割。 |
| str.join（[]）/str.join（()） | 实现字符串的拼接 |
partition（sep）从左到右分割.。
rpartition（sep）从右到左分割。
将字符串以参数指定的分割符为依据进行切割，将切割后的结果返回一个三元组（三个元素的元组）
>>> "wwww12www".partition("w")
('', 'w', 'www12www')
>>> "wwww12www".rpartition("w")
('wwww12ww', 'w', '')
>>> str.split（sep=None,maxsplit=-1） 从左到右分割。
str.rsplit（sep=None,maxsplit=-1） 从右到左分割。
使用split方法可以根据分割符把字符串任意分割,sep参数表示分割符，未设置时默认“，”；maxsplit参数表示分割次数，未设置时默认全部分割。
>>> "ahf|dihfisl|hgis".split("|")
['ahf', 'dihfisl', 'hgis']
>>> "ahf|dihfisl|hgis".split("|",1)
['ahf', 'dihfisl|hgis']
>>> "ahf|dihfisl|hgis".rsplit("|",1)
['ahf|dihfisl', 'hgis']str.join（[]）
str.join（()）实现字符串的拼接。str表示拼接符号，（[]）表示用于拼接的字符串，彼此之间用，连接。
>>> "+".join(["3","hik","ddd"])
'3+hik+ddd'
>>> s="cndik"
>>> s+=s
>>> a
'12'
>>> s
'cndikcndik'
>>> "".join(("cndik","cndik"))
'cndikcndik'9.字符串格式化
format()
format() 方法的语法格式如下：(来自C语言中文网)
str.format(args)
args 用于指定要进行格式转换的项，如果有多项，之间有逗号进行分割。
其完整的语法格式为：
{ [index][ : [ [fill] align] [sign] [#] [width] [.precision] [type] ] }
>>> "{:{fill}{align}{width}.{prec}{typ}}".format(3.1415,fill="*",align="^",width=12,prec=4,typ='f')
'***3.1415***'
注意，格式中用 [] 括起来的参数都是可选参数，即可以使用，也可以不使用。各个参数的含义如下：
- index：指定：后边设置的格式要作用到 args 中第几个数据，数据的索引值从 0 开始。如果省略此选项，则会根据 args 中数据的先后顺序自动分配。
-
>>> "{0}{2}{1}".format("ahdk","hfilasd","ids") 'ahdkidshfilasd' >>> "{} {}".format("ahdk","hfilasd","ids") 'ahdk hfilasd' - fill：指定空白处填充的字符。注意，当填充字符为逗号(,)且作用于整数或浮点数时，该整数（或浮点数）会以逗号分隔的形式输出，例如（1000000会输出 1,000,000）。
-
>>> "{:,}".format(100000) '100,000' >>> "{:,}".format(123.1234) '123.1234' >>> "{:,}".format(123740813294089.1234) '123,740,813,294,089.12' >>> "{:,}".format(1237408132940.1234) '1,237,408,132,940.1233' - align：指定数据的对齐方式，具体的对齐方式如表 1 所示。
表 1 align 参数及含义 align 含义 < 数据左对齐。 > 数据右对齐。 = 数据右对齐，同时将符号放置在填充内容的最左侧，该选项只对数字类型有效。 ^ 数据居中，此选项需和 width 参数一起使用。 - width：指定输出数据时所占的宽度。
-
>>> "{0:*>10}{2:&^10}{1}".format("ahdk","hfilasd","ids") '******ahdk&&&ids&&&&hfilasd' >>> "{0:>10}{2:^10}{1}".format("ahdk","hfilasd","ids") ' ahdk ids hfilasd' >>> "{1:=}".format("ahdk","hfilasd","ids") Traceback (most recent call last): File "<pyshell#10>", line 1, in <module> "{1:=}".format("ahdk","hfilasd","ids") ValueError: '=' alignment not allowed in string format specifier >>> "{:=10}".format(3.245) ' 3.245' - sign：指定有无符号数，此参数的值以及对应的含义如表 2 所示。
表 2 sign 参数以含义 sign参数 含义 + 正数前加正号，负数前加负号。 - 正数前不加正号，负数前加负号。 空格 正数前加空格，负数前加负号。 # 对于二进制数、八进制数和十六进制数，使用此参数，各进制数前会分别显示 0b、0o、0x前缀；反之则不显示前缀。 -
>>> "{:+}".format(2.3) '+2.3' >>> "{:+}".format(-2.3) '-2.3' >>> "{:-}".format(-2.3) '-2.3' >>> "{:-}".format(2.3) '2.3' >>> "{: }".format(2.3) ' 2.3' >>> "{: }".format(-2.3) '-2.3' - .precision：指定保留的小数位数。
- type：指定输出数据的具体类型，如表 3 所示。
表 3 type 占位符类型及含义 type类型值 含义 s 对字符串类型格式化。 d 十进制整数。 c 将十进制整数自动转换成对应的 Unicode 字符。 e 或者 E 转换成科学计数法后，再格式化输出。 g 或 G 自动在 e 和 f（或 E 和 F）中切换。 b 将十进制数自动转换成二进制表示，再格式化输出。 o 将十进制数自动转换成八进制表示，再格式化输出。 x 或者 X 将十进制数自动转换成十六进制表示，再格式化输出。 f 或者 F 转换为浮点数（默认小数点后保留 6 位），再格式化输出。 % 显示百分比（默认显示小数点后 6 位）。
>>> "{:d}".format(1234)#输出十进制整数
'1234'
>>> "{:}".format(1234)
'1234'
>>> "{:c}".format(1234)#将十进制数转换成对应的Unicode字符
'Ӓ'
>>> "{:b}".format(20)#将十进制转换成二进制
'10100'
>>> "{:o}".format(20)#将十进制转换成八进制
'24'
>>> "{:x}".format(20)#将十进制转换成十六进制
'14'
>>> "{:%}".format(20)#显示百分比
'2000.000000%'
>>> "{:f}".format(20)#转换成浮点数
'20.000000'
>>> "{:#o}".format(20)# 加上#,转化后或输出标志0
'0o24'
precision参数的应用：
对于数字类型f和g的区别，对于非数字类型precision参数的应用。
>>> "{:.2f}".format(-3)
'-3.00'
>>> #负号不加也行，限定小数点后的数位
>>> "{:.3g}".format(3)
'3'
>>> "{:.3g}".format(3.0)
'3'
>>> "{:.3g}".format(3.04)
'3.04'
>>> #限定小数点前后的数位
>>> "{:.3g}".format(3.04123134)
'3.04'
>>> "{:.6}".format("hfwioaug9p i9ofpw")
'hfwioa'
>>> #对于非数字类型，限定的是字段的长度
>>> "{:.2}".format(45667)
Traceback (most recent call last):
File "<pyshell#97>", line 1, in <module>
"{:.2}".format(45667)
ValueError: Precision not allowed in integer format specifier
>>> #对于整数型，会报错。f-字符串
f-字符串使字符串格式化更加方便。
>>> #f-字符串
>>> f"{80:x}"
'50'
>>> f"{1234:d}"
'1234'序列
iterable可迭代对象
可变序列和不可变序列
1.对于Python定义变量时，存储了变量的值所在的内存地址，并不是存储该变量的值本身。
变量的每一次初始化，都开辟了一个新的空间，将新内容的地址赋值给变量。
可以用is is not 检验是否是同一个对象。
id()函数的作用：返回一个代表指定对象的唯一标志的整数值。可以用id函数获取对象的内存地址。
2.字符串，元组，列表属于序列。
相同点：
1.都可以通过索引找到元素，索引值都是从0开始，
2.都可以使用切片语法
3.有很多共同的运算符
序列可以分为：可变和不可变两种。
想要详细了解可变和不可变可以查看这篇博客：http://t.csdn.cn/MOClC
可变序列：列表和字符串
不可变序列：元组
可变数据类型：列表list和字典dict
不可变数据类型：整型int、浮点型float、字符串型string和元组tuple
3.可变和不可变指的是内存中的值是否可以被改变。
对于不可变的数据类型：#当值被修改时，变量的地址也会变化。#值相同，引用地址相同（id相同），就是同一个对象（is判断为True）
>>> i=23
>>> id(i)
1943826592
>>> i+=2
>>> id(i) #当值被修改时，变量的地址也会变化。
1943826656
>>> t=23
>>> id(t)
1943826592
>>> m=23
>>> id(m)
1943826592
>>> #当值被修改时，变量的地址也会变化。
>>> m is t
True
>>> #当值被修改时，变量的地址也会变化。
对于可变的数据类型:
对于可变数据列表：允许仅仅改变了变量的值，不会新建一个对象。
对列表而言：
增，删，改（以赋值方式更改影响地址）本身地址不变；（增，删，改相关操作查看我的上一篇博客http://t.csdn.cn/h99NW）
>>> s=[1,2]#增
>>> id(s)
2144956717448
>>> s.append("a")
>>> s
[1, 2, 'a']
>>> id(s)
2144956717448
>>> s[len(s):]='n'
>>> s
[1, 2, 'a', 'n']
>>> id(s)
2144956717448
>>> s.remove(3)#删
Traceback (most recent call last):
File "<pyshell#136>", line 1, in <module>
s.remove(3)
ValueError: list.remove(x): x not in list
>>> s.remove(2)
>>> s
[1, 'a', 'n']
>>> id(s)
2144956717448
>>> s.clear()
>>> s
[]
>>> id(s)
2144956717448
>>> s=[1,2]
>>> id(s)
2144956651592
>>> #重新赋值影响地址
拼接和重复不改变地址：
>>> s=[1,2,3]
>>> id(s)
2646421392904
>>> s+=s
>>> id(s)
2646421392904
>>> s
[1, 2, 3, 1, 2, 3]
>>> s*=2
>>> id(s)
2646421392904
>>> s
[1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3]
>>> in in not
用来判断序列中是否包含指定元素，返回值是布尔类型。用法示例：
>>> "12"in"1432"
False
>>> "12"in"1232"
True
>>> "12"not in"1232"
False序列常用函数
del
1.用于删除一个或多个指定的对象。
s=[1,2,3]
>>> del s
>>> s
Traceback (most recent call last):
File "<pyshell#15>", line 1, in <module>
s
NameError: name 's' is not defined2。用于删除可变序列中的指定的一个或多个元素。
del[起：终：步长]
注意：它和切片的区别。想要删除下标为0，2的元素，切片操作x=[0:3:2]=[]会报错，del不会。
>>> x=[1,2,3,4]
>>> del x[0:2]
>>> x
[3, 4]
>>> x=[1,2,3,4]
>>> x[0:2]=[]
>>> x
[3, 4]
>>> x=[1,2,3,4]
>>> del x[0:3:2]
>>> x
[2, 4]
>>> x=[1,2,3,4]
>>> x[0:3:2]=[]
Traceback (most recent call last):
File "<pyshell#29>", line 1, in <module>
x[0:3:2]=[]
ValueError: attempt to assign sequence of size 0 to extended slice of size 23.清除所有元素：
>>> x=[1,2,3,4]
>>> del x[:]
>>> x
[]
>>> x=[1,2,3,4]
>>> x.clear()
>>> x
[]列表，元组，字符串的相互转换
list() 转换成列表。
tuple() 转换成元组。
str() 转换成字符串。
>>> list("hcfsdio")
['h', 'c', 'f', 's', 'd', 'i', 'o']
>>> tuple([1,2,3])
(1, 2, 3)
>>> str([1,4,5,6])
'[1, 4, 5, 6]'min()和max()
min(interable,*[,key,default]) 对比可迭代对象中的元素，并返回最小值。
max(interable,*[,key,default]) 对比可迭代对象中的元素，并返回最大v值。
*[,key,default]：当函数查找不到元素时，打印default设置的值，避免报错。
>>> min([1,2,3,4,11,2,3,0],default="没有")#对比传入的可迭代对象
0
>>> s=[]
>>> min(s,default="没有")#当函数查找不到元素是，打印default引用的值
'没有'
>>> min(s)
Traceback (most recent call last):
File "<pyshell#43>", line 1, in <module>
min(s)
ValueError: min() arg is an empty sequence
>>> max((1,2,3,4))
4
>>> max(1,23,4,2,9,24)#对比传入的多个参数
24
>>> max("ahfiow")#传入字符串，比较的是字符串中的编码值
'w'
len()和sum()
len()求序列的长度
sum()求和（不可以处理字符串）
>>> len([1,2,3])
3
>>> len("ciasd")
5
>>> sum((1,2,34))
37sorted()和reversed()
sorted (cmp=None, key=None, reverse=False) 和reverse()在列表里可以用于排序。
sort 让原列表内元素按从小到大排序。sorted()让原序列内元素按从小到大排序，返回一个全新的序列，原来的序列并不会受影响。
>>> s=[1,3,5,2,3,8,4,8,7,9,3]
>>> sorted(s)
[1, 2, 3, 3, 3, 4, 5, 7, 8, 8, 9]
>>> s
[1, 3, 5, 2, 3, 8, 4, 8, 7, 9, 3]
>>> a=[1,5,6,3,6,34,2,0]
>>> a.sort() #原列表被改变了
>>> a
[0, 1, 2, 3, 5, 6, 6, 34]
>>> sorted(s,reverse=True)#和sort()一样，可以通过reverse参数实现从大到小的排序
[9, 8, 8, 7, 5, 4, 3, 3, 3, 2, 1]
key是一个可以指定一个干预排序算法的函数。
>>> sorted(["hfsi","asd","dwssf","a"],key=len)#按照字符的长度
['a', 'asd', 'hfsi', 'dwssf']
>>> sorted(["hfsi","asd","dwssf","a"])#按照编码方式
['a', 'asd', 'dwssf', 'hfsi']reverse()将原列表的元素按下标，从大到小排列。
reversed()返回一个反向的迭代器，我们可以使用 list() 转换来输出列表。
>>> reversed(s)
<list_reverseiterator object at 0x000002682AFB8710>
>>> tuple(reversed(s))
(3, 9, 7, 8, 4, 8, 3, 2, 5, 3, 1)
>>> reversed(s)
<list_reverseiterator object at 0x000002682B030B38>
>>> list(reversed(s))
[3, 9, 7, 8, 4, 8, 3, 2, 5, 3, 1]
>>> s="hfsi"
>>> tuple(reversed(s))
('i', 's', 'f', 'h')
>>> all()和any()
all() 函数用于判断给定的可迭代参数 iterable （可以用元组，列表和字符串）中的所有元素是否都为 真，如果是返回 True，否则返回 False。
元素除了是 0、空、None、False 外都算 True。
注意：空元组、空列表，空字符串返回值为True。
any() 函数用于判断给定的可迭代参数 iterable （可以用元组，列表和字符串）是否全部为 假，则返回 False，如果有一个为 True，则返回 True。
元素除了是 0、空、FALSE 外都算 TRUE。
注意：空元组、空列表，空字符串返回值为 False。
>>> #all()
>>> x=[1,2,0]
>>> all(x)
False
>>> #0不是真
>>> x=[1,2,0]
>>> any(x)
True
>>> x=[]
>>> all(x)
True
>>> #空列表或空元组返回值是True
>>> x=[1,2,'']
>>> all(x)
False
>>> #有空元素返回False
>>> x=(1,2,'')
>>> any(x)
True
>>> #有元素为真返回True
>>> x=(0,'')
>>> any(x)
False
>>> #有元素为空，0返回True
>>> x=()
>>> any(x)
False
>>> #空列表或空元组，返回False
>>> x="N"
>>> any(x)
True
>>> all(x)
True
>>> x=""
>>> all(x)
True
>>> #空列表，空元组或空字符串，返回True
>>> any(x)
False
>>> #空列表，空元组或空字符串，返回False
enumerate（）
enumerate（sequence，start）函数用于返回一个枚举对象，功能是将可迭代对象的每个元素及从０开始的序号共同构成一个二元组列表。
sequence：序列。 start：设置下标起始位置的值。
返回值是一个枚举对象，我们可以使用 list() 转换来输出列表。
>>> season=("Spring","Summer","Fall","Winter")
>>> enumerate(season)
<enumerate object at 0x0000026C2423C900>
>>> list(enumerate(season))
[(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]
>>> list(enumerate(season,2))
[(2, 'Spring'), (3, 'Summer'), (4, 'Fall'), (5, 'Winter')]zip()
zip(iterable，．．) 函数用于将可迭代的对象（序列）作为参数，返回一个迭代器，我们可以使用 list() 转换来输出列表。
如果各个序列的元素个数不一致，则返回列表长度与最短的对象相同。
>>> x=[1,2,3]
>>> y='acd'
>>> z=zip(y,x)
>>> list(z)
[('a', 1), ('c', 2), ('d', 3)]
>>> list(zip(x,y))
[(1, 'a'), (2, 'c'), (3, 'd')]
>>> a="fhcnieo"
>>> list(zip(x,y,a))
[(1, 'a', 'f'), (2, 'c', 'h'), (3, 'd', 'c')]
>>> #a,x,y三个迭代对象长度不一致，返回列表的长度与最短的x，y的长度相同补充：
使用zip_longest(x,y,a)，使所有的对象都输出。
>>> x=[1,2,3]
>>> y='acd'
>>> a="fhcnieo"
>>> import itertools
>>> list(itertools.zip_longest(x,y,a))
[(1, 'a', 'f'), (2, 'c', 'h'), (3, 'd', 'c'), (None, None, 'n'), (None, None, 'i'), (None, None, 'e'), (None, None, 'o')]
>>> map()
map(function，iterable) 会根据提供的函数对指定序列（可迭代对象）做映射，返回一个迭代器。
映射：指定的可迭代对象的每个元素进行运算。
>>> #map()
>>> zip(y,x)
<zip object at 0x0000026C2425F4C8>
>>> map(ord,"fhis")#ord求编码值
<map object at 0x0000026C24265048>
>>> list(map(ord,"fhis"))
[102, 104, 105, 115]每次从"fhis"中调用一个元素，根据ord计算每个元素的编码值，返回一个迭代器，我们可以使用 list() 转换来输出列表。
>>> list(map(max,[1,2,3],[4,3,8],[2,4,9,10]))
[4, 4, 9]根据max函数，从后面三个指定序列中依次比较１，４，２；２，３，４；３，８，９的大小，并将找到的最大值返回，我们可以使用 list() 转换来输出列表。如果各个序列的元素个数不一致，则返回列表长度与最短的对象相同，不输出１０。
filter()
filter(function，iterable) ：function是有判断作用的函数：比如 islower（），isupper（）等，根据function的函数可以过滤掉不符合条件的元素，返回一个迭代器对象，如果要转换为列表，我们可以使用 list() 转换来输出列表。
过滤：序列的每个元素作为参数传递给函数进行判断，然后返回 True 或 False，最后将返回 True 的元素放到新列表中。
>>> filter(str.islower,"AjdiHd")
<filter object at 0x0000026C242652B0>
>>> list(filter(str.islower,"AjdiHd"))
['j', 'd', 'i', 'd']
3万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
