目录
str.split(sep=None,maxsplit=-1) 从左到右分割。
str.rsplit(sep=None,maxsplit=-1) 从右到左分割。
学习资料来自:鱼C论坛,菜鸟教程,C语言中文网
字符串
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)
7
5.字符串的替换
方法 | 描述 |
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)
True
str.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()
True
str.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()
True
str.isidentifier()
>>> "3".isidentifier()
False
>>> "a3".isidentifier()
True
补充:
判断一个字符串是否为Python的保留标识符。(if while 之类)
>>> import keyword
>>> keyword.iskeyword("while")
True
7.字符串的截取
方法 | 描述 |
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 defined
2。用于删除可变序列中的指定的一个或多个元素。
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 2
3.清除所有元素:
>>> 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))
37
sorted()和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)函数用于返回一个枚举对象,功能是将可迭代对象的每个元素及从0开始的序号共同构成一个二元组列表。
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函数,从后面三个指定序列中依次比较1,4,2;2,3,4;3,8,9的大小,并将找到的最大值返回,我们可以使用 list() 转换来输出列表。如果各个序列的元素个数不一致,则返回列表长度与最短的对象相同,不输出10。
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']