序列结构：列表(list)、元组(tuple)、集合(set)、字典(dict)、字符串(str)

一.字符串(str)

1.创建

string1 = "字符串常量"
string2 = '字符串常量'

• 关于单双引号的使用

string1 = 'hello, "c"'
print(string1)
string2 = "hello, 'c'"
print(string2)

输出结果

2.访问元素

可通过索引值随机访问

string = "abcdef"
print(string[2])

输出结果

3.切片

切片：截取序列一部分的操作

对象名[起始值:终止值:步长]

[起始值，终止值)前闭后开
至少含一个冒号':'

对象名：要截取的对象
起始值：缺省默认为0
终止值：缺省默认取到最后一个元素
步长：缺省默认为1，若步长为负数，则反向截取

• 示例

string = 'abcdefg'
print("1."+string[0:3])        # 1.string[0]到string[2]
print("2."+string[2:])         # 2.string[2]到最后一个元素
print("3."+string[1:-1])       # 3.string[1]到倒数第二个个元素

print("4."+string[:])          # 4.遍历
print("5."+string[::-1])       # 5.反向遍历

print("6."+string[::2])        # 6.步长为2
print("7."+string[5:1])        # 7.默认步长为1
print("8."+string[5:1:-1])     # 8.string[5]到string[2]

输出结果

4.字符串常见操作

常用方法:find(),count(),replace(),split(),join(),strip()

检索与检查：find()、index()、count()、startswith()、endswith()
字符串分割为列表：split()、partition()、splitlines()
列表连接为字符串：join()
填充对齐：ljust()、rjust()、center()
删除对齐：lstrip()、rstrip、strip()
替换：replace()
类型判定：isX()

(1)字符串检索

find()、index()、count()、startswith()、endswith()

• 1.find()方法
  ①find()方法

主串.find("子串",起始索引值,终止索引值)

str.find(sub, _start, _end)

检查目标字符串中是否包含在主串中（查找子串）。如果在，返回开始的索引值；否则，返回-1。

起始索引值：缺省从头开始检索
终止索引值：缺省检索至尾

②rfind()方法

主串.rfind("子串",起始索引值,终止索引值)

从右端开始检查

• 2.index()方法
  ①index()方法

主串.index("子串",起始索引值,终止索引值)

str.index(sub, _start, _end)

与find()方法相同，只不过未找到目标字符串会抛出一个异常。

起始索引值：缺省从头开始检索
终止索引值：缺省检索至尾

②rindex()方法

主串.index("子串",起始索引值,终止索引值)

从右端开始检查

• 3.count()方法

主串.count("子串",起始索引值,终止索引值)

str.count(sub, _start, _end)

返回目标字符串在主串中出现的次数。

起始索引值：缺省从头开始检索
终止索引值：缺省检索至尾

• 4.startswith()方法

str.startswith(prefix,start,end)

检测目标字符串是否以prefix为开头，返回真值。

• 5.endswith()方法

str.endswith(suffix,start,end)

检测目标字符串是否以suffix为结尾，返回真值。

(2)字符串分割

split()、partition()、splitlines()

• 6.split()方法

主串.split("分隔符",分割个数)

str.split(sep, maxsplit)

以分隔符分割目标字符串，返回一个列表。如果maxsplit(分割个数)指定值，那么仅分割maxsplit(分割个数)个。
示例：

print("abcdefgabcdefgabcdefg".split("c", 2))

运行结果

• 7.partition()方法
  ①partition()

name.partition(sep)

把目标字符串以sep分割成3部分：sep前的所有字符组成的、sep中的所有字符、sep后的所有字符组成的三段字符串。
②rpartition()
右起分割。

• 8.splitlines()方法

line.splitlines([keepends])

返回由目标字符串中各行组成的列表，在行边界的位置拆分。
结果列表中不包含行边界(即\n)，除非给出了 keepends 且为真值。

(3)字符串合并

join()

• 9.join()方法

str.join(iterable)

返回一个由 iterable 中的字符串拼接而成的字符串。
如果 iterable 中存在任何非字符串值包括 bytes 对象则会引发 TypeError。
调用该方法的字符串将作为元素之间的分隔。

• 示例

list = ["hello","world"]
print("连接前：",list)
str = ",".join(list)
print("连接后：",str)

运行结果

(4)字符串转换

capitalize()、title()、upper()、lower()

①大写转换

• 10.capitalize()

str..capitalize()

返回原字符串的副本，其首个字符大写，其余为小写。

• 11.title()

str.title()

返回原字符串的标题版本，其中每个单词第一个字母为大写，其余字母为小写。

• 12.upper()

str.uppper()

返回原字符串的副本，其中所有区分大小写的字符均转换为大写。
注意：如果 str 包含不区分大小写的字符或者如果结果字符的 Unicode 类别不是 "Lu" (Letter, uppercase) 而是 "Lt" (Letter, titlecase) 则 str.upper().isupper() 有可能为 False。

②小写转换

• 13.lower()

str.lower()

返回原字符串的副本，其所有区分大小写的字符均转换为小写。

(5)填补与删除空格

ljust()、rjust()、center()
lstrip()、rstrip、strip()

①填充空格

• 14.ljust()

str.ljust(width,[fillchar])

返回长度为 width 的字符串，原字符串在其中靠左对齐。
如果 width 小于等于 len(str) 则返回原字符串的副本。
使用指定的 fillchar 填充空位 (默认使用 ASCII 空格符)。

• 15.rjust()

str.rjust(width,[fillchar])

返回长度为 width 的字符串，原字符串在其中靠右对齐。
如果 width 小于等于 len(str) 则返回原字符串的副本。
使用指定的 fillchar 填充空位 (默认使用 ASCII 空格符)。

• 16.center()

str.center(width,[fillchar])

返回长度为 width 的字符串，原字符串在其中居中对齐。
如果 width 小于等于 len(str) 则返回原字符串的副本。
使用指定的 fillchar 填充空位 (默认使用 ASCII 空格符)。

②删除空格

• 17.lstrip()

str.lstrip([chars])

返回原字符串的副本，移除其中的前导字符。
chars参数为指定要移除字符的字符串。如果省略或为None，则 chars 参数默认移除空格符。 实际上 chars 参数并非指定单个前缀，而是会移除参数值的所有组合。

• 18.rstrip()

str.rstrip([chars])

返回原字符串的副本，移除其中的末尾字符。
chars参数为指定要移除字符的字符串。如果省略或为None，则 chars 参数默认移除空格符。 实际上 chars 参数并非指定单个前缀，而是会移除参数值的所有组合。

• 19.strip()

str.strip([chars])

返回原字符串的副本，移除其中的前导和末尾字符。
chars参数为指定要移除字符的字符串。如果省略或为None，则 chars 参数默认移除空格符。 实际上 chars 参数并非指定单个前缀，而是会移除参数值的所有组合。

(6)字符串替换

replace()

• 20.replace()

str.replace(old, new, count)

返回字符串的副本，其中出现的所有子字符串 old 都将被替换为 new。
如果给出了可选参数 count，则只替换前 count 次出现。

(7).字符串判定（isX方法）

方法	说明
isalpha()	判断字符串是否是否只含字母，返回真值
isdigit()	判断字符串是否是否只含数字，返回真值
isalnum()	判断字符串是否是否只含字母或数字，返回真值
isspace()	判断字符串是否只含空格、制表符和换行符，返回真值
isupper()	判断字符串是否只含大写字母，返回真值
islower()	判断字符串是否只含小写字母，返回真值

二.列表(list)

1.创建

list = []    #创建空列表
list = [元素表列]

2.访问元素

可通过索引值随机访问

array = ["hello", 'world', 666, 1024]
print(array[2])

运行结果

3.遍历

• for循环

for x in list:
    print(x)

• while循环

i = 0
while i < len(list):
    print(list[i])
    i += 1

• 同时遍历多个列表
  zip()函数

zip([iterable, ...])

将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。

示例：

a = [1,2,3]
b = [4,5,6,7]
c = [4,5,6,7,8]
zipped = zip(a,b,c)       #对象地址
print(zipped)
print(list(zipped))

运行结果.png

4.增删查改

(1)添加元素

• append()方法

list.append(object)

表尾追加元素。

• insert()方法

list.insert(index, object)

在指定位置index(索引号)前插入元素object。

• extend()方法

list.extend(iterable)

将另外一个集合添加到列表中。

(2)删除元素

• del

del list[index]

根据下表进行删除。

• pop()

list.pop([index])

删除最后一个元素(无参数时)。

• remove()

list.remove(object)

根据元素值进行删除。

(3)查找元素

• in 和 not in
  判断元素是否在列表中，返回真值。
• index()

list.index(元素值)

按元素值查找元素，返回该元素的索引值。

(4)修改元素

可通过索引值随机访问修改。

5.排序

• sort()

list.sort(key, reverse)

对列表进行原地排序（原列表会被修改）。

key：指定带有一个参数的函数，用于从每个列表元素中提取比较键 (例如 key=str.lower)，默认值为 None （直接比较元素）。
reverse：reverse为一个布尔值。如果设为 True，则每个列表元素将按反向顺序比较进行排序。

注意：此方法异常不会被屏蔽（如果有任何比较操作失败，整个排序操作将失败，而列表可能会处于被部分修改的状态）。

• sorted()

sorted(iterable, key, reverse)

根据 iterable 中的项返回一个新的已排序列表。

.sort()与sorted()的区别

区别1
.sore()是对原来的列表进行修改排序。
sorted()是对原来的列表进行排序后返回一个新的列表，不修改原来的列表。
区别2
.sore()属于列表成员方法，调用形式list.sort()。
sorted()对所有可迭代对象都可进行操作，调用形式sorted(list)。

6.列表推导式

列表推导式即轻量级循环创建列表

list = [i for i in range(n) if 条件表达式]
list = [常量 for _ in range(n) if 条件表达式]

7.列表转化为字符串

使用str()方法

三.元组(tuple)

1.创建

tuple = ()    #创建空元组
tuple = (元素, ...)

注意：在通过赋值创建单元素元组时，该元素后必须加逗号。

b = (21122)
print(type(b))
c = (21122,)
print(type(c))

运行结果

2.访问元素

可通过索引值随机访问

t = ('ddd', 1024, 0.88)
print(t[2])

运行结果

3.遍历

• for循环
• while循环
• zip()函数
  zip() 函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。

4.不可变性

• 不允许添加
• 不允许修改
• 不允许删除

四.字典(dict)

1.创建

info = {}       # 创建空字典
info = {键:值,...}

2.访问元素

• 根据键进行访问

info = {'name': '刘强东', 'age': 45, 'id': 351281197303107845, 'addr': '北京'}
print(info['name'])

运行结果

访问不存在的键抛出KeyError。

• .get()方法

get(key[, default])

使用get()方法时，访问不存在的键返回None(不会抛出异常)，且能通过第二个参数制定默认值。
示例：

info = {'name': '刘强东', 'age': 45, 'id': 351281197303107845, 'addr': '北京'}
age = info.get('age', 36)
print(age)
mail = info.get('mail')
print(mail)
mail = info.get('mail', '123@jingdong.com')
print(mail)

运行结果

3.遍历

for key,value in dict.items():
    print(key,'->',value)

4.销毁与清空

• 销毁字典

del dict

• 清空字典

dict.clear()

5.增删查改

(1)添加元素

dict[键] = 值

若键在原字典中存在，此操作则为修改键值操作
若键在原字典中不存在，此操作则为键值对添加操作。

(2)删除元素

根据键进行删除。

del dict[键]

(3)查找元素

根据键进行查找。

(4)修改元素

dict[键] = 新值

6.字典常见操作

len(),.keys(),.values(),.items()

• len()
  返回字典中键值对的个数
• .keys()
  返回字典中所有的键
• .values()
  返回字典中所有的值
• .items()
  返回字典中所有的键值对
  示例：

info = {'name': '刘强东', 'age': 45, 'id': 351281197303107845, 'addr': '北京'}
print(len(info1))           # 返回字典中键值对的个数
keys = info.keys()          # 返回字典中所有的键
print('键：', keys)
values = info.values()      # 返回字典中所有的值
print('值：', values)
items = info.items()        # 返回字典中所有的键值对
print('键值对：', items)

运行结果

7.字典解析式

dict = {键:值 for i in range(n) if 条件表达式}
dict = {键:值 for _ in range(n) if 条件表达式}

五.集合(set)

1.创建

set = set()   
set = {元素,...}

2.访问元素

集合属于无序序列，元素唯一，一般用于列表元组元素去重。
不支持下标索引随机访问，只能一次输出集合中所有元素（输出元素顺序随机）。

3.遍历

for elem in set:
    print(elem)

4.增删查改

(1).添加元素

• .add()方法

set.add(element)

(2)删除元素

• .remove()方法
  删除指定值的元素，删除不存在的元素会报错。

set.remove(element)

• .discard()方法
  删除指定值的元素，删除不存在的元素不做任何操作，不会报错。

set.discard(element)

• .pop()方法
  随机删除集合中的元素（从左起删除元素，带有随机性）。

set.pop()

(3)查找元素

• in 和 not in
  判断元素是否在集合中，返回真值。

(4)修改元素

• update()方法
  修改当前集合，可以添加新的元素或集合到当前集合中，如果添加的元素在集合中已存在，则该元素只会出现一次，重复的会忽略。

set.update(iterable)

5.集合解析式

set = {i for i in range(n) if 条件表达式}
set = {随机数 for _ in range(n) if 条件表达式}