Day 01——Task01:变量、运算符与数据类型
Day 02——Task02:条件与循环
Day 03——Task03:列表与元组(上)
Day 04——Task03:列表与元组(下)
Day 05——Task04:字符串与序列
Day 06——Task05:函数与Lambda表达式(上)
Day 07——Task05:函数与Lambda表达式(下)
Day 08——Task06:字典与集合
Day 09——Task07:文件与文件系统(上)
Day 10——Task07:文件与文件系统(下)
Day 11——Task08:异常处理
Day 12——Task09:else 与 with 语句
Day 13——Task10:类与对象(上)
Day 14——Task10:类与对象(下)
Day 15——Task11:魔法方法(上)
Day 16——Task11:魔法方法(下)
Day 17——Task12:模块
文章目录
- 1.字符串
- 1.1.字符串访问
- 1.2.字符串更新
- 1.3 del 语句删除字符串
- 1.4 字符串的转义字符
- 1.5 字符串的运算符
- 1.6 字符串的格式化
- 1.7 字符串的format 格式化函数
- 1.8 字符串的BIF
- 1.8.01 capitalize()
- 1.8.02 center(width, fillchar)
- 1.8.03 count(str, beg= 0,end=len(string))
- 1.8.04 endswith(suffix, beg=0, end=len(string))
- 1.8.05 expandtabs(tabsize=8)
- 1.8.06 find(str, beg=0, end=len(string))
- 1.8.07 index(str, beg=0, end=len(string))
- 1.8.08 isalnum()
- 1.8.09 isalpha()
- 1.8.10 isdigit()
- 1.8.11 islower()
- 1.8.12 isnumeric()
- 1.8.13 isspace()
- 1.8.14 istitle()
- 1.8.15 isupper()
- 1.8.16 join(seq)
- 1.8.17 len(string)
- 1.8.18 ljust(width[, fillchar])
- 1.8.19 lower()
- 1.8.20 lstrip()
- 1.8.21 maketrans()
- 1.8.22 max(str)
- 1.8.23 min(str)
- 1.8.24 replace(old, new [, max])
- 1.8.25 rfind(str, beg=0,end=len(string))
- 1.8.26 rindex( str, beg=0, end=len(string))
- 1.7.27 rjust(width,[, fillchar])
- 1.8.27 rjust(width,[, fillchar])
- 1.8.28 rstrip()
- 1.8.29 split(str="", num=string.count(str))
- 1.8.30 splitlines([keepends])
- 1.8.31 startswith(substr, beg=0,end=len(string))
- 1.8.32 strip([chars])
- 1.8.33 swapcase()
- 1.8.34 title()
- 1.8.35 translate(table, deletechars="")
- 1.8.36 upper()
- 1.8.37 zfill (width)
- 1.8.38 isdecimal()
- 2.序列
- 3.总结
今天,我们来一起了解下Python中最常用的数据类型——字符串,以及在序列中常用的BIF。
1.字符串
字符串是Python中最常用的数据类型,我们可以使用 引号( ’ 或 " ) 来创建字符串。
创建字符串很简单,如同我们在 Day01 中学习到给变量声明赋值。
标识符 + 赋值符 + 值
只要上式中的“值”为带引号的内容既可成功为字符串赋值。
str1 = 'Mive'
str2 = "-Vax"
注:若需要在字符串内容中出现引号( ’ 或 " ),可以使用 转义符号\ 对字符串中的符号进行转义。我会在下文对转义符号进行详细介绍
str1 = 'Mive\'Vax'
str2 = "Mive\'Vax"
print(str1)
print(str2)
# Mive'Vax
# Mive'Vax
其中,三引号允许一个字符串跨多行,字符串中可以包含换行符、制表符以及其他特殊字符。
para_str = """这是一个多行字符串的实例
多行字符串可以使用制表符
TAB ( \t )。
也可以使用换行符 [ \n ]。
"""
print (para_str)
'''
这是一个多行字符串的实例
多行字符串可以使用制表符
TAB ( )。
也可以使用换行符 [
]。
'''
1.1.字符串访问
Python 不支持单字符类型,单字符在 Python 中也是作为一个字符串使用。
Python 访问子字符串,可以使用方括号来截取字符串,如下实例:
str1 = 'Mive-Vax53'
sample = '123'
print ("sample[0]: ", sample[0])
print ("str1[-5:-2]: ", str1[-5:-2])
# sample[0]: 1
# str1[-5:-2]: Vax
1.2.字符串更新
由于字符串类似于元组由于不可修改,所以要对字符串更新必须采用与元组相同的方法,切片与拼接。
1.2.1 向字符串添加元素
str1 = 'Mive-Vax53'
sample = '123'
str1 = str1[:4] + sample + str1[4:]
print (str1)
# Mive123-Vax53
1.2.2 向字符串修改元素
需要定位到要修改元素的索引值,以及要被修改之后的值。
str1 = 'Mive-Vax53'
str1 = str1[:-2] + '8' + str1[-1:]
print (str1)
# Mive-Vax83
1.2.3 向字符串删除元素
需要定位到被删除元素的索引值。
str1 = 'Mive-Vax53'
str1 = str1[:8] + str1[9:]
print (str1)
# Mive-Vax3
1.3 del 语句删除字符串
我们可以使用del语句来删除整个字符串。
str1 = 'Mive-Vax53'
del str1
print (str1)
# NameError: name 'str1' is not defined
1.4 字符串的转义字符
在需要在字符中使用特殊字符时,python用反斜杠()转义字符。如下表:
转义字符 | 描述 |
---|---|
(在行尾时) | 续行符 |
\ | 反斜杠符号 |
’ | 单引号 |
" | 双引号 |
\a | 响铃 |
\b | 退格(Backspace) |
\000 | 空 |
\n | 换行 |
\v | 纵向制表符 |
\t | 横向制表符 |
\r | 回车 |
\f | 换页 |
\oyy | 八进制数,yy 代表的字符,例如:\o12 代表换行,其中 o 是字母,不是数字 0。 |
\xyy | 十六进制数,yy代表的字符,例如:\x0a代表换行 |
\other | 其它的字符以普通格式输出 |
1.5 字符串的运算符
下表实例变量a值为字符串 “Mive”,b变量值为 “-Vax”:
操作符 | 描述 | 实例 |
---|---|---|
+ | 字符串连接 | a + b 输出结果: Mive-Vax |
* | 重复输出字符串 | a*2 输出结果:MiveMive |
[] | 通过索引获取字符串中字符 | a[1] 输出结果 i |
[:] | 截取字符串中的一部分,遵循左闭右开原则,str[0,2] 是不包含第 3 个字符的。 | a[1:3] 输出结果 iv |
in | 成员运算符 - 如果字符串中包含给定的字符返回 True | ‘x’ in b 输出结果 True |
not in | 成员运算符 - 如果字符串中不包含给定的字符返回 True | ‘M’ not in a 输出结果 False |
r/R | 原始字符串:所有的字符串都是直接按照字面的意思来使用,没有转义特殊或不能打印的字符。 原始字符串除在字符串的第一个引号前加上字母 r(可以大小写)以外,与普通字符串有着几乎完全相同的语法。 | print( r’\n’ ) print( R’\n’ ) |
% | 格式字符串 | 请看下一节内容。 |
1.6 字符串的格式化
Python 支持格式化字符串的输出 。尽管这样可能会用到非常复杂的表达式,但最基本的用法是将一个值插入到一个有字符串格式符 %s 的字符串中。
在 Python 中,字符串格式化使用与 C 中 sprintf 函数一样的语法。
print ("我叫 %s 今年 %d 岁!" % ('小明', 10))
# 我叫 小明 今年 10 岁!
python字符串格式化符号:
符 号 | 描述 |
---|---|
%c | 格式化字符及其ASCII码 |
%s | 格式化字符串 |
%d | 格式化整数 |
%u | 格式化无符号整型 |
%o | 格式化无符号八进制数 |
%x | 格式化无符号十六进制数 |
%X | 格式化无符号十六进制数(大写) |
%f | 格式化浮点数字,可指定小数点后的精度 |
%e | 用科学计数法格式化浮点数 |
%E | 作用同%e |
%g | %f和%e的简写 |
%G | %f 和 %E 的简写 |
%p | 用十六进制数格式化变量的地址 |
格式化操作符辅助指令:
符号 | 功能 |
---|---|
* | 定义宽度或者小数点精度 |
- | 用做左对齐 |
+ | 在正数前面显示加号( + ) |
在正数前面显示空格 | |
# | 在八进制数前面显示零(‘0’),在十六进制前面显示’0x’或者’0X’(取决于用的是’x’还是’X’) |
0 | 显示的数字前面填充’0’而不是默认的空格 |
% | ‘%%‘输出一个单一的’%’ |
(var) | 映射变量(字典参数) |
m.n. | m 是显示的最小总宽度,n 是小数点后的位数(如果可用的话) |
1.7 字符串的format 格式化函数
Python2.6 开始,新增了一种格式化字符串的函数 str.format(),它增强了字符串格式化的功能。
基本语法是通过 {} 和 : 来代替以前的 % 。
format 函数可以接受不限个参数,位置可以不按顺序。
print("{} {}".format("hello", "world"))
# hello world
print("{0} {1}".format("hello", "world"))
# hello world
print("{1} {0} {1}".format("hello", "world"))
# world hello world
'world hello world'
也可以设置参数:
print("网站名:{name}, 地址 {url}".format(name="菜鸟教程", url="www.runoob.com"))
# 网站名:菜鸟教程, 地址 www.runoob.com
site = {"name": "菜鸟教程", "url": "www.runoob.com"} # 通过字典设置参数
print("网站名:{name}, 地址 {url}".format(**site))
# 网站名:菜鸟教程, 地址 www.runoob.com
my_list = ['菜鸟教程', 'www.runoob.com'] # 通过列表索引设置参数
print("网站名:{0[0]}, 地址 {0[1]}".format(my_list)) # "0" 是必须的
# 网站名:菜鸟教程, 地址 www.runoob.com
也可以向 str.format()
传入对象:
class AssignValue(object):
def __init__(self, value):
self.value = value
my_value = AssignValue(6)
print('value 为: {0.value}'.format(my_value))
# value 为: 6
1.7.1 数字格式化
下表展示了 str.format()
格式化数字的多种方法:
>>> print("{:.2f}".format(3.1415926));
3.14
数字 | 格式 | 输出 | 描述 |
---|---|---|---|
3.1415926 | {:.2f} | 3.14 | 保留小数点后两位 |
3.1415926 | {:+.2f} | +3.14 | 带符号保留小数点后两位 |
-1 | {:+.2f} | -1.00 | 带符号保留小数点后两位 |
2.71828 | {:.0f} | 3 | 不带小数 |
5 | {:0>2d} | 05 | 数字补零 (填充左边, 宽度为2) |
5 | {:x<4d} | 5xxx | 数字补x (填充右边, 宽度为4) |
10 | {:x<4d} | 10xx | 数字补x (填充右边, 宽度为4) |
1000000 | {:,} | 1,000,000 | 以逗号分隔的数字格式 |
0.25 | {:.2%} | 25.00% | 百分比格式 |
1000000000 | {:.2e} | 1.00e+09 | 指数记法 |
13 | {:>10d} | 13 | 右对齐 (默认, 宽度为10) |
13 | {:<10d} | 13 | 左对齐 (宽度为10) |
13 | {:^10d} | 13 | 中间对齐 (宽度为10) |
11 | {:b} | 1011 | 进制 |
11 | {:d} | 11 | 进制 |
11 | {: o} | 13 | 进制 |
11 | {:x} | b | 进制 |
11 | {:#x} | 0xb | 进制 |
11 | {:#X} | 0XB | 进制 |
^
, <
, >
分别是居中、左对齐、右对齐,后面带宽度, :
号后面带填充的字符,只能是一个字符,不指定则默认是用空格填充。
+
表示在正数前显示 +
,负数前显示 -
; (空格)表示在正数前加空格
b、d、o、x 分别是二进制、十进制、八进制、十六进制。
此外我们可以使用大括号 {}
来转义大括号,如下实例:
print ("{} 对应的位置是 {{0}}".format("runoob"))
# runoob 对应的位置是 {0}
1.8 字符串的BIF
1.8.01 capitalize()
将字符串的第一个字符转换为大写
str = "mive-Vax"
print ("str.capitalize() : ", str.capitalize())
# str.capitalize() : Mive-vax
1.8.02 center(width, fillchar)
返回一个指定的宽度 width 居中的字符串,fillchar 为填充的字符,默认为空格。
str = "mive-Vax"
print ("str.center(20, '-') : ", str.center(20, '-'))
# str.center(20, '-') : ----------------mive-Vax----------------
1.8.03 count(str, beg= 0,end=len(string))
返回 str 在 string 里面出现的次数,如果 beg 或者 end 指定则返回指定范围内 str 出现的次数
- sub – 搜索的子字符串
- start – 字符串开始搜索的位置。默认为第一个字符,第一个字符索引值为0。
- end – 字符串中结束搜索的位置。字符中第一个字符的索引为 0。默认为字符串的最后一个位置。
str = "mive-Vax"
sub='i'
print ("str.count('i') : ", str.count(sub))
# str.count('i') : 1
sub='-'
print ("str.count('-', 0, 5) : ", str.count(sub,0,10))
#str.count('-', 0, 5) : 1
1.8.04 endswith(suffix, beg=0, end=len(string))
检查字符串是否以 obj 结束,如果beg 或者 end 指定则检查指定的范围内是否以 obj 结束,如果是,返回 True,否则返回 False.
Str='Runoob example....wow!!!'
suffix='!!'
print (Str.endswith(suffix))
print (Str.endswith(suffix,20))
suffix='run'
print (Str.endswith(suffix))
print (Str.endswith(suffix, 0, 19))
# True
# True
# False
# False
1.8.05 expandtabs(tabsize=8)
把字符串 string 中的 tab 符号转为空格,tab 符号默认的空格数是 8 。
str = "this is\tstring example....wow!!!"
print ("原始字符串: " + str)
print ("替换 \\t 符号: " + str.expandtabs())
print ("使用16个空格替换 \\t 符号: " + str.expandtabs(16))
#原始字符串: this is string example....wow!!!
#替换 \t 符号: this is string example....wow!!!
#使用16个空格替换 \t 符号: this is string example....wow!!!
1.8.06 find(str, beg=0, end=len(string))
检测 str 是否包含在字符串中,如果指定范围 beg 和 end ,则检查是否包含在指定范围内,如果包含返回开始的索引值,否则返回-1
str1 = "Runoob example....wow!!!"
str2 = "exam";
print (str1.find(str2))
print (str1.find(str2, 5))
print (str1.find(str2, 10))
# 7
# 7
# -1
1.8.07 index(str, beg=0, end=len(string))
跟find()方法一样,只不过如果str不在字符串中会报一个异常.
str1 = "Runoob example....wow!!!"
str2 = "exam";
print (str1.index(str2))
print (str1.index(str2, 5))
print (str1.index(str2, 10))
# 7
# 7
# ValueError: substring not found
1.8.08 isalnum()
如果字符串至少有一个字符并且所有字符都是字母或数字则返 回 True,否则返回 False
str = "runoob2016" # 字符串没有空格
print (str.isalnum())
# True
str = "www.runoob.com"
print (str.isalnum())
# False
1.8.09 isalpha()
如果字符串至少有一个字符并且所有字符都是字母则返回 True, 否则返回 False
str = "runoob"
print (str.isalpha())
# True
# 字母和中文文字
str = "runoob菜鸟教程"
print (str.isalpha())
# True
str = "Runoob example....wow!!!"
print (str.isalpha())
# False
1.8.10 isdigit()
如果字符串只包含数字则返回 True 否则返回 False
str = "123456";
print (str.isdigit())
# True
str = "Runoob example....wow!!!"
print (str.isdigit())
# False
1.8.11 islower()
如果字符串中包含至少一个区分大小写的字符,并且所有这些(区分大小写的)字符都是小写,则返回 True,否则返回 False
str = "RUNOOB example....wow!!!"
print (str.islower())
# False
str = "runoob example....wow!!!"
print (str.islower())
# True
1.8.12 isnumeric()
如果字符串中只包含数字字符,则返回 True,否则返回 False
str = "runoob2016"
print (str.isnumeric())
str = "23443434"
print (str.isnumeric())
# True
1.8.13 isspace()
如果字符串中只包含空白,则返回 True,否则返回 False.
str = " "
print (str.isspace())
# True
str = "Runoob example....wow!!!"
print (str.isspace())
# False
1.8.14 istitle()
如果字符串是标题化的(见 title())则返回 True,否则返回 False
str = "This Is String Example...Wow!!!"
print (str.istitle())
# True
str = "This is string example....wow!!!"
print (str.istitle())
# False
1.8.15 isupper()
如果字符串中包含至少一个区分大小写的字符,并且所有这些(区分大小写的)字符都是大写,则返回 True,否则返回 False
str = "THIS IS STRING EXAMPLE....WOW!!!"
print (str.isupper())
# True
str = "THIS is string example....wow!!!"
print (str.isupper())
# False
1.8.16 join(seq)
以指定字符串作为分隔符,将 seq 中所有的元素(的字符串表示)合并为一个新的字符串
s1 = "-"
s2 = ""
seq = ("r", "u", "n", "o", "o", "b") # 字符串序列
print (s1.join( seq )) # r-u-n-o-o-b
print (s2.join( seq )) # runoob
1.8.17 len(string)
返回字符串长度
str = "runoob"
len(str)
# 6
l = [1,2,3,4,5]
len(l)
# 5
1.8.18 ljust(width[, fillchar])
返回一个原字符串左对齐,并使用 fillchar 填充至长度 width 的新字符串,fillchar 默认为空格。
str = "Runoob example....wow!!!"
print (str.ljust(50, '*'))
# Runoob example....wow!!!**************************
1.8.19 lower()
转换字符串中所有大写字符为小写.
str = "Runoob EXAMPLE....WOW!!!"
print( str.lower() )
# runoob example....wow!!!
1.8.20 lstrip()
截掉字符串左边的空格或指定字符。
str = " this is string example....wow!!! ";
print( str.lstrip() );
str = "88888888this is string example....wow!!!8888888";
print( str.lstrip('8') );
# this is string example....wow!!!
# this is string example....wow!!!8888888
1.8.21 maketrans()
创建字符映射的转换表,对于接受两个参数的最简单的调用方式,第一个参数是字符串,表示需要转换的字符,第二个参数也是字符串表示转换的目标。
intab = "aeiou"
outtab = "12345"
trantab = str.maketrans(intab, outtab)
str = "this is string example....wow!!!"
print (str.translate(trantab))
# th3s 3s str3ng 2x1mpl2....w4w!!!
1.8.22 max(str)
返回字符串 str 中最大的字母。
str = "runoob"
print ("最大字符: " + max(str))
# 最大字符: u
1.8.23 min(str)
返回字符串 str 中最小的字母。
str = "runoob";
print ("最小字符: " + min(str));
# 最小字符: b
1.8.24 replace(old, new [, max])
把 将字符串中的 str1 替换成 str2,如果 max 指定,则替换不超过 max 次。
str = "www.w3cschool.cc"
print ("菜鸟教程旧地址:", str)
print ("菜鸟教程新地址:", str.replace("w3cschool.cc", "runoob.com"))
str = "this is string example....wow!!!"
print (str.replace("is", "was", 3))
# 菜鸟教程旧地址: www.w3cschool.cc
# 菜鸟教程新地址: www.runoob.com
# thwas was string example....wow!!!
1.8.25 rfind(str, beg=0,end=len(string))
类似于 find()函数,不过是从右边开始查找.
str1 = "this is really a string example....wow!!!"
str2 = "is"
print (str1.rfind(str2))
print (str1.rfind(str2, 0, 10))
print (str1.rfind(str2, 10, 0))
print (str1.find(str2))
print (str1.find(str2, 0, 10))
print (str1.find(str2, 10, 0))
# 5
# 5
# -1
# 2
# 2
# -1
1.8.26 rindex( str, beg=0, end=len(string))
类似于 index(),不过是从右边开始.
str1 = "this is really a string example....wow!!!"
str2 = "is"
print (str1.rindex(str2))
print (str1.rindex(str2,10))
# 5
# ValueError: substring not found
1.7.27 rjust(width,[, fillchar])
返回一个原字符串右对齐,并使用fillchar(默认空格)填充至长度 width 的新字符串
str = "this is string example....wow!!!"
print (str.rjust(50, '*'))
# ******************this is string example....wow!!!
1.8.27 rjust(width,[, fillchar])
返回一个原字符串右对齐,并使用fillchar(默认空格)填充至长度 width 的新字符串
str = "this is string example....wow!!!"
print (str.rjust(50, '*'))
# ******************this is string example....wow!!!
1.8.28 rstrip()
删除字符串字符串末尾的空格.
str = " this is string example....wow!!! "
print (str.rstrip())
str = "*****this is string example....wow!!!*****"
print (str.rstrip('*'))
# this is string example....wow!!!
# *****this is string example....wow!!!
1.8.29 split(str="", num=string.count(str))
num=string.count(str)) 以 str 为分隔符截取字符串,如果 num 有指定值,则仅截取 num+1 个子字符串
str = "this is string example....wow!!!"
print (str.split( )) # 以空格为分隔符
print (str.split('i',1)) # 以 i 为分隔符
print (str.split('w')) # 以 w 为分隔符
# ['this', 'is', 'string', 'example....wow!!!']
# ['th', 's is string example....wow!!!']
# ['this is string example....', 'o', '!!!']
txt = "Google#Runoob#Taobao#Facebook"
# 第二个参数为 1,返回两个参数列表
x = txt.split("#", 1)
print(x)
# ['Google', 'Runoob#Taobao#Facebook']
1.8.30 splitlines([keepends])
按照行(’\r’, ‘\r\n’, \n’)分隔,返回一个包含各行作为元素的列表,如果参数 keepends 为 False,不包含换行符,如果为 True,则保留换行符。
>>> 'ab c\n\nde fg\rkl\r\n'.splitlines()
['ab c', '', 'de fg', 'kl']
>>> 'ab c\n\nde fg\rkl\r\n'.splitlines(True)
['ab c\n', '\n', 'de fg\r', 'kl\r\n']
1.8.31 startswith(substr, beg=0,end=len(string))
检查字符串是否是以指定子字符串 substr 开头,是则返回 True,否则返回 False。如果beg 和 end 指定值,则在指定范围内检查。
str = "this is string example....wow!!!"
print (str.startswith( 'this' )) # 字符串是否以 this 开头
print (str.startswith( 'string', 8 )) # 从第八个字符开始的字符串是否以 string 开头
print (str.startswith( 'this', 2, 4 )) # 从第2个字符开始到第四个字符结束的字符串是否以 this 开头
# True
# True
# False
1.8.32 strip([chars])
在字符串上执行 lstrip()和 rstrip()
str = "*****this is **string** example....wow!!!*****"
print (str.strip( '*' )) # 指定字符串 *
# this is **string** example....wow!!!
1.8.33 swapcase()
将字符串中大写转换为小写,小写转换为大写
str = "this is string example....wow!!!"
print (str.swapcase())
str = "This Is String Example....WOW!!!"
print (str.swapcase())
#THIS IS STRING EXAMPLE....WOW!!!
#tHIS iS sTRING eXAMPLE....wow!!!
1.8.34 title()
返回"标题化"的字符串,就是说所有单词都是以大写开始,其余字母均为小写(见 istitle())
str = "this is string example from runoob....wow!!!"
print (str.title())
# This Is String Example From Runoob....Wow!!!
txt = "hello b2b2b2 and 3g3g3g"
x = txt.title()
print(x)
# Hello B2B2B2 And 3G3G3G
1.8.35 translate(table, deletechars="")
根据 str 给出的表(包含 256 个字符)转换 string 的字符, 要过滤掉的字符放到 deletechars 参数中
- table – 翻译表,翻译表是通过 maketrans() 方法转换而来。
- deletechars – 字符串中要过滤的字符列表。
intab = "aeiou"
outtab = "12345"
trantab = str.maketrans(intab, outtab) # 制作翻译表
str = "this is string example....wow!!!"
print (str.translate(trantab))
# th3s 3s str3ng 2x1mpl2....w4w!!!
# 制作翻译表
bytes_tabtrans = bytes.maketrans(b'abcdefghijklmnopqrstuvwxyz', b'ABCDEFGHIJKLMNOPQRSTUVWXYZ')
# 转换为大写,并删除字母o
print(b'runoob'.translate(bytes_tabtrans, b'o'))
# b'RUNB'
1.8.36 upper()
转换字符串中的小写字母为大写
str = "this is string example from runoob....wow!!!";
print ("str.upper() : ", str.upper())
# str.upper() : THIS IS STRING EXAMPLE FROM RUNOOB....WOW!!!
1.8.37 zfill (width)
返回长度为 width 的字符串,原字符串右对齐,前面填充0
str = "this is string example from runoob....wow!!!"
print ("str.zfill : ",str.zfill(40))
print ("str.zfill : ",str.zfill(50))
# str.zfill : this is string example from runoob....wow!!!
# str.zfill : 000000this is string example from runoob....wow!!!
1.8.38 isdecimal()
检查字符串是否只包含十进制字符,如果是返回 true,否则返回 false。
str = "runoob2016"
print (str.isdecimal())
# False
str = "23443434"
print (str.isdecimal())
# True
2.序列
在Python中,序列包含字符串、列表、元组。
2.1序列的BIF
2.1.1 list(sub)
把一个可迭代对象转换为列表。
str1 = "mive-Vax"
str1 = list(str1)
print(str1)
# ['m', 'i', 'v', 'e', '-', 'V', 'a', 'x']
2.1.2 tuple(sub)
把一个可迭代对象转换为元组。
str1 = "mive-Vax"
str1 = tuple(str1)
print(str1)
# ('m', 'i', 'v', 'e', '-', 'V', 'a', 'x')
2.1.3 str(obj)
把obj对象转换为字符串。
num1 = 53
num1 = str(num1)
print(num1)
53
2.1.4 len(sub)
返回sub包含元素的个数
print(len(['m', 'i', 'v', 'e', '-', 'V', 'a', 'x']))
# 8
str1 = "mive-Vax"
print(len(str1))
# 8
2.1.5 max(sub)
返回序列或者参数集合中的最大值
print(max(['m', 'i', 'v', 'e', '-', 'V', 'a', 'x']))
# x
str1 = "mive-Vax"
print(max(str1))
# x
2.1.6 min(sub)
返回序列或参数集合中的最小值
print(min(['m', 'i', 'v', 'e', '-', 'V', 'a', 'x']))
# -
str1 = "mive-Vax"
print(min(str1))
# -
2.1.7 sum(iterable[, start=0])
返回序列iterable与可选参数start的总和。
print(sum([1, 3, 5, 7]))
# 16
print(sum([1, 3, 5, 7], 10))
# 26
print(sum((1, 3, 5, 7)))
# 16
print(sum((1, 3, 5, 7), 20))
# 36
2.1.8 sorted(iterable, key=None, reverse=False)
对所有可迭代的对象进行排序操作。
numbers = [-8, 1, 3, 7, 9]
print(sorted(numbers))
# [-8, 1, 3, 7, 9]
print(sorted(numbers, reverse=True))
# [9, 7, 3, 1, -8]
2.1.9 reversed()
用于反向列表中元素。
numbers = [-8, 1, 3, 7, 9]
print(list(reversed(numbers)))
# [83, 7, 3, 99, -8]
2.1.10 enumerate(sequence, [start=0])
用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列,同时列出数据和数据下标,一般用在 for 循环当中。
seasons = ['Spring', 'Summer', 'Fall', 'Winter']
a = list(enumerate(seasons))
print(a)
# [(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]
b = list(enumerate(seasons, 1))
print(b)
# [(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')]
for i, element in a:
print('{0},{1}'.format(i, element))
# 0,Spring
# 1,Summer
# 2,Fall
# 3,Winter
2.1.11 zip([iterable, …])
- 用于将可迭代的对象作为参数,将对象中对应的元素打包成一个个元组,然后返回由这些元组组成的对象,这样做的好处是节约了不少的内存。
- 我们可以使用 list() 转换来输出列表。
- 如果各个迭代器的元素个数不一致,则返回列表长度与最短的对象相同,利用 * 号操作符,可以将元组解压为列表。
a = [1, 2, 3]
b = [4, 5, 6]
c = [4, 5, 6, 7, 8]
zipped = zip(a, b)
print(zipped)
# <zip object at 0x000000C5D89EDD88>
print(list(zipped))
# [(1, 4), (2, 5), (3, 6)]
zipped = zip(a, c)
print(list(zipped))
# [(1, 4), (2, 5), (3, 6)]
a1, a2 = zip(*zip(a, b))
print(list(a1))
# [1, 2, 3]
print(list(a2))
# [4, 5, 6]
3.总结
目前,有关序列的知识就学习好了。接下来我们会进入新的环节。
参考文献:
- https://blog.csdn.net/LSGO_MYP/article/details/97755149
- https://www.runoob.com/python3/python3-string.html