python学习笔记（八）序列、字符串、字符串操作
1、序列（sequence）：序列就是计算机中的一种数据结构，在序列中可以存储一组有序的数据，序列中的每一个数据都会又一个对应的序列号，这个序号我们称为索引（index），索引是从0开始的整数
序列分为两大类：
（1）可变序列：list列表、
（2）不可变序列：str字符串、tuple元祖
~~~序列的操作（通用操作，这些操作都不对元对象产生影响）、
- s [ i ]
--通过索引来获取序列中的元素
---索引不能超过序列的最大索引，如果超过会报错
---索引可以是负数，如果是负数，则从向前计算
- s[起始：结束：步长]
--截取序列中的一部分（切片）
--起始：表示截取开始的位置，截取后会包含该元素
~~起始位置可以省略；省略后则从头开始
--结束：表示截取的结束的位置，截取后不会包含该元素
~~结束也可以省略，如果省略则会一直截取到最后
--步长：截取的间隔，默认1，可以是负数，如果是负数 ，则从后往前截取
---反转序列：s[：：-1]
- in 和 not in
-- in ：检查元素是否存在与序列中，存在返回True，否则返回False
-- not in 检查元素是否不存在于序列中，不存在返回True，否则返回False
- +
-- +：可以用来拼接两个序列
- *
-- * ：可以讲序列重复指定次数
- len()
-- len() :获取序列的长度
- max()
--max():获取序列中的最大元素
- min()
--min():获取序列中最小的元素
- s.index(元素，起点，结束)
--- 获取指定元素在序列中第一次出现位置
---如果没有元素会报错
- s.count()
---统计指定的元素在序列中出现的次数
1.2：字符串在内存中的存储
（1）计算机中的存储单位：
python在sys模块中提供函数 getsizeof 来计算python 对象的大小。
sys.getsizeof(object[,default])
以字节（byte）为单位返回对象大小
数据存储是以10进制表示，数据传输是以2进制表示的，多以1KB不等于1000B。
注意：同样是int类型的同一个值，在python2和python3的长度是不一样的。
python 中 len()方法的返回对象（字符、列表、元祖、字典）长度或是项目个数
2、字符串
字符串是 Python 中最常用的数据类型。我们可以使用引号( ' 或 " )来创建字符串。
（1）创建字符串很简单，只要为变量分配一个值即可。
例如：
如果是字符串a="100" b="200"a+b="100200"
如果是数字 a=100 b=200 a+b=300
注意点：python中“+”相加的话，必须类型一样，若是类型不一样需要转化
如：
a=10
b=20
c="abc"
d="q"
print(str(a)+c)#把数字类型a使用 str 转化为字符串之后在相加
- 跟数字类型一样，字符串类型也是不可变的，所以改变一个字符串就必须通过创建一个新串的方式来实现。可以通过给一个变量赋值（或者重赋值）的方式“更新”一个已有的字符串，新的值可能与原有值差不多，也可能跟原有串完全不同
- 字符串是不可变的，不能仅仅删除一个字符串里的某个字符，你能做的是清空一个空字符串，或者是把提出了不需要的部分的字符串组合起来形成一个新串，假设你想要从“Hello World”里面删除小写的”l".
astring="Hello World" astring=astring[:3]+astring[4:] print('astring')
运行结果：
‘Helo World'
- 通过赋一个空字符串或者使用del语句来清空或者删除一个字符串
astring=' ' print('astring')
运行结果：
' '
在大部分应用程序里，没有必要显示的删除字符串。定义这个字符串的代码最终会结束，但是python会自动释放这个字符串
（2）
字符串可以存任意类型的字符串，比如名字，一句话等等。
字符串还有很多内置方法，对字符串进行操作，常用的方法如下：
name1='hello world' print(name.capitalize())#首写字母大写 print(name1.capitalize())#首写字母大写Hello world print(name1.center(50,'-'))#50个-，把name1放中间-------------------hello world-------------------- print(name.endswith('u'))#是否以x结尾 False print(name1.endswith('d'))#是否以x结尾 True print(name.expandtabs(30))#补入\t的次数my name is {name},age is{age}. print(name1.find('n'))#查找字符串的索引5(\t代表3个字符) print(name.format(name='niuniu',age=18))#这个是格式字符串my name is niuniu,age is18. print(name.format_map({'name':'niuniu','age':19}))#这个也是格式化字符串，后面跟的是一个字典，字典在后面也会写 #my name is niuniu,age is19. print('abA123'.isalnum())#是否包含数字和字母 True print('abA'.isalpha())#是否有英文字母True
name = 'My \t name is {name},age is{age}.' print('122'.isdigit())#是否有数字True print('aa'.isidentifier())#是否是一个合法的变量名True print('aa'.islower())#是否是小写字母True print('AA'.isupper())#是否是大写字母True print('Loadrunner Book'.istitle())#是不是一个标题，判断首字母是否大写True print('+'.join(['hehe','haha','ee']))#拼接字符串 hehe+haha+ee print(name.lower())#变成小写my name is {name},age is{age}. print(name.upper())#变成大写MY NAME IS {NAME},AGE IS{AGE}. print('\nmysql \n'.lstrip())#默认去掉左边的空格和换行 print('\nmysql \n'.rstrip())#默认去掉右边的空格和换行 print('\nmysql \n'.strip())#默认去掉两边的空格和换行 p=str.maketrans('abcdefg','1234567')#前面的字符串和后面的字符串做映射 print('cc ae gg'.translate(p))#输出按照上面maketrans做映射后的字符串33 15 77
new_p=str.maketrans('1234567','abcdefg') print('cc ae gg'.translate(new_p)) print('mysql is db.'.replace('mysql','oracle',1))#替换字符串oracle is db. print('mysql is db.mysql is db.mysql is db.'.replace('mysql','oracle',2))#替换字符串oracle is db.oracle is db.mysql is db. print('mysql is is db'.rfind('is'))#返回最右边字符的下标 9 print('1+2+3+4'.split('+'))#切割字符串，返回一个list ['1', '2', '3', '4'] print('1+2+3\n1+2+3+4'.splitlines())#按照换行符分割['1+2+3', '1+2+3+4'] print('Abcdef'.swapcase())#大小写反转aBCDEF
(3）访问字符串中的值
*python不支持单字符串类型，单字符在python中也是座位一个字符串使用。
*python访问子字符串，可以使用 '[ ]'方括号来截取字符串，如下实例：
var1='Hello World' var2="Runoo" print('var1[0]:',var1[0]) print('var2[1:5]:',var2[1:5])
执行结果：
var1[0]: H
var2[1:5]: unoo
（4））字符串更新 拼接
可以截取字符串的一部分并与其他字段拼接，使用“+”拼接，如下实例
var1='Hello World' print('已更新字符串：‘，var1[:6]+'Runoob!')
执行结果：
已更新字符串： Hello Runoob!
（5）字符串转义
需要字符串使用特殊字符时，python用反斜杠（\）转义字符。如下：
| 转义字符 |
描述 |
| \ （在行尾时） | 续行符 |
| \\ | 反斜杠符号 |
| \' | 单引号 |
| \" | 双引号 |
| \a | 响铃 |
| \b | 退格（Backspace） |
| \000 | 空 |
| \n | 换行 |
| \v | 纵向制表符 |
| \t | 横向制表符 |
| \r | 回车 |
| \f | 换页 |
| \oyy | 八进制，yy代表的字符，例如：\o12代表换行，其中 o 是字母，不是数字 |
| \xyy | 十六进制，yy代表字符，例如：\x0a代表换行 |
| \other |
其他的字符一普通格式输出 |
（6）字符串运算符
下表实例变量a制为字符串'Hello',b变量值为'Python'
| 操作符 |
描述 |
实例 |
| + | 字符串连接 |
a+b输出结果为： HelloPython |
| * | 重复输出字符串 |
a*2输出结果为： HelloHello |
| [] | 通过索引获取字符串中的字符 |
a[1]输出结果为：e |
| [:] | 截取字符串中的一部分，遵循左闭右开原则，str[0:2]是不包含第3个字符的 |
a[1:4]输出结果为：ell |
| in | 成员运算符-如果字符串中包含给定的字符返回True |
"H"in a输出结果为： True（因为a字符串中包含“H”） |
| not in | 成员运算符-如果字符串中不包含给定的字符返回True |
“M”not in a 输出结果为： True（因为a字符串不包含“M”） |
| r/R |
原始字符串-原始字符串：所有的字符串都是直接按照字面的意思来使用， 没有转义特殊或不能打印的字符。原始字符串除在字符串的第一个引号前面加上一个字母r (可以大小写）以外，与普通字符串有着几乎完全相同的语法 |
print（r'\n') print(R'\n') |
| % | 格式字符串 |
字符串运算实例：
a='Hello' b='Python' print('a+b输出结果为：',a+b) print('a*2输出结果为：',a*2) print('a[1]输出结果为：',a[1]) print('a[1:4]输出结果为：',a[1:4]) if ('H' in a): print('H 在变量a中') else: print('H 在不变量a中') if ('M' not in a): print('M 不在变量a中') else: print('M 在变量a中') print(r'\n') print(R'\n')
运行结果：
a+b输出结果为： HelloPython a*2输出结果为： HelloHello a[1]输出结果为： e a[1:4]输出结果为： ell H 在变量a中 M 不在变量a中 \n \n Process finished with exit code 0
（7）字符串格式化
Python支持格式化字符串的输出。尽管这样可能会用到非常复杂的表达式，但最基本的用法是将一个值插入到一个又字符串格式符%s的字符串中。
在Python中，字符串格式化使用与C中sprintf函数一样的语法。
name='Amy' age=4 print("我叫%s今年%d岁！" %(name,age)) #%s和%d在这个里面就是占位符
运行结果：
我叫Amy今年4岁！
Python字符串格式化符号：
| 符号 |
描述 |
| %c | 格式化字符及其ASCII吗 |
| %s | 格式化字符串 |
| %d | 格式化整数 |
| %u | 格式化无符号整数 |
| %o | 格式化无符号八进制 |
|
%x |
格式化无符号十六进制 |
| %X | 格式化无符号十六进制（大写） |
| %f | 格式化浮点数字，课指定小数点后的进度 |
| %e | 用科学计数法格式化浮点数 |
| %E | 作用同%e，用科学计数法格式化浮点数 |
| %g | %f 和%e的简写 |
| %G | %f 和%E 的简写 |
| %p |
用十六进制数格式化变量的地址 |
格式化操作辅助指令：
| 符号 |
功能 |
| * | 定义宽度或者小数点精度 |
| - | 用做左对齐 |
| + | 在正数前面显示加号（+） |
| <sp> | 在正数前面显示空格 |
| # | 在八进制数前面显示（'0'），在十六进制前面显示（'0x'或者‘0X'）（取决于用的是'x'还是'X'） |
| 0 | 显示的数字前面填充'0'二不是默认的空格 |
| % | '%%'输出一个单一的'%' |
| (var) | 映射变量（字典参数） |
| m.n. | m是显示的最小总宽度；n是小数点后的位数（如果可用的话） |
- python2.6之后就新增了一个字符串格式化函数 str.format()；
它增强了字符串格式化的功能，
基本语法是通过 {} 和 ： 来代替以前的 %
format 函数可以接受不限个参数，位置可以不按顺序
不限参数实例：
print('{} {}'.format('Hello','World')) #不设置指定位置，按默认顺序 print('{0} {1}'.format('Hello','World'))#设置指定位置 print('{1} {0}{1}'.format('Hello','World'))#设置指定位置
运用结果：
Hello World
Hello World
World Hello World
设置参数实例：
#设置参数 print('姓名：{name}，年龄：{age}' .format(name="Amy",age="18")) #通过字典设置参数 site={"name":"Amy","age":"18"} print('姓名：{name}，年龄：{age}' .format(**site)) #通过列表索引设置参数 my_list=['Amy','18'] print('姓名：{0[0]},年龄：{0[1]}'.format(my_list)) #"0"是必须的
运行结果：
姓名：Amy，年龄：18 姓名：Amy，年龄：18 姓名：Amy,年龄：18
也可以向str.format()传入对象
class AssignValue(object): def __init__(self, value): self.value = value my_value = AssignValue(6) print('value 为: {0.value}'.format(my_value)) # "0" 是可选的
运行结果：
value 为: 6
- 数字格式化
下面战士了str.format() 格式化数字的多种方法
print("{:.2f}".format(3.1415926)) #输出打印保留小数点后2位
运用结果：
3.14
| 数字 |
格式 |
输出 |
描述 |
| 3.1415926 | {:.2f} | 3.14 | 保留小数点后两位 |
| 3.1415926 | {:+.2f} | +3.14 | 带符号保留小数点后两位 |
| -1 | {:+.2f} | -1.00 | 带符号保留小数点后两位 |
| 2.71828 | {:.0f} | 3 | 不带小数(数字会自动四舍五入），若是2.41828，输出结果为：2. |
| 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}'.format(11) '{:d}'.format(11) '{:o}'.format(11) '{:x}'.format(11) '{:#x}'.format(11) '{:#X}'.format(11
|
1011
11
13
b
0xb
0XB
|
进制 |
^ ,< , > 分别是居中、左对齐、右对齐，后面带宽度， ： 号后面带填充的字符，只能是一个字符，不指定则默认使用空格填充
+ 表示在整数前面显示 +，负数前面显示 - ； （空格）表示在整数前面加空格
b 、 d、o、 x 分别是二进制、十进制、八进制、十六进制
此外，可以使用{}大括号来转义大括号，如下实例：
print ("{} 对应的位置是 {{0}}".format("Amy"))
运用结果：
Amy 对应的位置是 {0}
（8）python 三个引号
三个引号允许一个字符串跨多行显示，字符串中可以包含换行符、制表符以及其他特殊字符。
para_str='''这是一个多行字符串的实例 多行字符串可以使用制表符 TAB(\t). 也可以使用换行符[\n]. ''' print(para_str)
运行结果：
这是一个多行字符串的实例
多行字符串可以使用制表符
TAB( ).
也可以使用换行符[
].
（9）f-string
f-string 是在python3.6之后版本添加的，称之为字面量格式化字符串。是新的格式化字符串的语法。
我们习惯使用百分号（%）：
name="Amy" print("Hello %s" %name)
运行结果：
Hello Amy
f-string 格式化字符串以f 开头，后面跟着字符串，字符串中的表达式用大括号{}包起来，它会将变量或表达式计算后面的值替换进去。实例如下：
name="Amy" print(f'hello{name}') #替换变量
运用结果：
