字符串类型常用方法

类型转换

str()

可以将任意类型数据，转换为字符串。

例如：test=str({"a":1})

统计字符串长度

len(str)

按照索引切片 (取值)

只能按照索引取，不能按照索引改。

# 正反向取单个字符。
test[0]
test[-1]

# 取指定范围。
test[0:5]

# 按步长切片。
test[0:5:2]

# 取指定位置之后的字符串。
test[2:]

# 取指定位置之前的字符串。
test[:3]

# 反向步长切片 (了解即可)，倒着取时，索引0取不到。
test[5:0:-1]

# 反向步长倒序切片，取出来的会是倒序的。
test[::-1]

切分

split()

将字符串按照指定分隔符进行切分，得到一个列表。

默认按照空白符号切分。

str.split()

按照指定符号进行切分。

str.split("分隔符")

指定分割次数 (了解)。

str.split("分隔符",分割次数)

按行切分

splitlines() 可以将文本以行分隔作为迭代对象。

同等于.split("\n")，与split()的区别是，split默认是按空白符切分，而splitlines()只按换行符切分。

移除左右两侧符号

strip()

默认去掉左右两侧的空白符号。

str.strip()

指定去掉的左右两侧符号。

str.strip("符号")

也可以指定多个分隔符号。

str.strip("符号1符号2符号3...")

只去除左边或右边的字符。

str.lstrip() 只去左边。

str.rstrip() 只去右边。

字母大小写转换

全部字母转换为大写。

str.upper()

全部字母转换为小写。

str.lower()

判断是否以指定字符串开头或结尾

判断是否以指定字符串开头，返回bool值。

str.startswith("判断的字符串")

判断是否以指定字符串结尾。

str.endswith("判断的字符串")

替换指定字符串

从左往右进行字符串替换。

默认替换匹配所有的字符串。

str.replace("原字符串","目标字符串")

指定替换匹配的字符串的个数。

str.replace("原字符串","目标字符串",替换个数)

判断字符串是否由纯数字组成

str.isdigit()

只能是纯数字，小数点的也不行。

查找字符串索引位置

str.find()

查找字符串起始位置索引，没有则返回-1。

统计字符串

str.count()

统计指定字符串出现的次数。

拼接列表

join()

将列表元素拼接成字符串，且列表中的元素必须都是字符串。

"拼接用的分隔符".join(列表名)

列表类型方法

类型转换

但凡能够被作为迭代对象的类型，都可以被当做list()方法转换成列表。

字符串转换为列表。

res = list("hello")
> ["h","e","l","l","o"]

字典转换为列表。

res = list({"key1":1, "key2":2})
> ["key1","key2"]

按照索引取值

可以取也可以改，但如果索引不存在会报错。

# 正向取。
print(list[0])
# 反向取。
print(list[-1])
# 修改，索引存在则修改对应的值。
list[0] = "one"

按照索引切片

list[起始:结尾:步长]

可以取出指定范围的值，也可以指定步长。

切片相当于浅拷贝行为，不会动原列表。

切片取值

# 取出列表指定范围的元素。
print(list[0:10])
print(list[0:])
print(list[:3])

# 按步长取出范围元素。
print(list[0:10:2])

切片赋值

a[0:3] = ["a","b","c"]

切片拷贝

可以通过a[:]切片来进行完全拷贝。

可变类型的[:]切片，会拷贝到新的内存空间，相当于浅拷贝。

不可变类型的[:]切片，由于不可变类型不会改，所以python会直接使用原来的内存空间。

切片替换

name = ["a", "b", "cde", "fgh"]
name[2:] = ["c", "d", "e"]
print(name)
> ["a", "b", "c", "d", "e"]

切片插入

num = [1, 2, 6]
# 2:2表示索引1和2之间的位置
num[2:2] = [3, 4, 5]
print(num)
> [1, 2, 3, 4, 5, 6]

列表末尾追加元素

list.append(值)

在列表的末尾追加元素。

a = ["one","two"]
a.append("three")
print(a)
输出 ['one', 'two', 'three']

列表指定位置插入元素

list.insert(指定索引位置,值)

在列表任意地方插入元素，会在指定索引位置插入值，索引原值及其后面的值会向后移。

a = ["one","three"]
a.insert(1,"two")
print(a)
>> 输出 ['one', 'two', 'three'] 

插入迭代对象的值作为元素

list.extend(可迭代对象)

将可迭代对象的值，插入列表作为元素，如插入另一个列表的值等。

a = [1,2,3]
b = [6,7,8]
a.extend(b)
print(a)
>> 输出 [1, 2, 3, 6, 7, 8]

删除元素

del list[索引]

del是一个通用的删除方法，可以删除变量、字典等等，也可以删除列表，或列表中的某个元素。

没有返回值，不支持复制语法，只是单纯的删除。

a = [1,2,3]
del a[2]
print(a)
>> 输出 [1, 2]

删除指定元素并返回其值

list.pop(索引)

用于删除指定元素，同时返回删除的元素的值。

a = [1,2,3]
test = a.pop(1)
print(a) # 输出 [1,3]
print(test) # 输出 2

根据元素的值删除元素

list.remove(元素值)

remove()可以根据元素的值进行删除，删除后会返回None，也就是没有返回值。

a = ["aaa","bbb","ccc"]
a.remove("aaa")
print(a)
>> 输出 ['bbb', 'ccc']

统计元素的值出现的次数

list.count(元素值)

a = [1,2,3,4,1]
print(a.count(1))
>> 输出 2

通过元素值查找元素的索引

list.index(元素值)

查找指定元素值的索引，查找到一个就会停止查找，并返回索引位置，找不到则报错。

a = [1,2,3,4,1]
print(a.index(1))
>> 输出 0

清空列表中所有的元素

list.clear()

清空列表中所有的元素。

a = [1,2,3,4,1]
a.clear()
print(a)
>> 输出 []

将列表元素位置实际反转

list.reverse()

a = [1,2,3]
a.reverse()
print(a)
>> 输出 []

将列表元素进行排序

list.sort()

默认从小到大排序，称为升序。只能针对元素值全是一种类型的列表进行排序。

list.sort(reverse=True)

可指定reverse参数为Ture，进行降序排序

注意：

字符串的排序会通过asci码表的先后顺序区别字符的大小，以进行排序。

列表的排序，会对两个列表，对应位置的值，进行大小比对，直到其中一个元素分出胜负位置。如果两个列表同一索引值的元素值，类型不相同，则会报错。

列表实现队列与堆栈

• 队列：先进先出 FIFO (first in first out)

  • 入队操作

    • list.append("值")

  • 出队操作

    • value = list.pop(0)

• 堆栈：后进先出 LIFO (last in first out)

  • 入栈操作

    • list.append("值")

  • 出栈操作

    • value = list.pop()

元组类型方法

除了类型转换，其他读或统计相关的方法和列表的方法一致。

注意：列表的删改方法在元组中没有，因为元组是不可变的。

类型转换

• tuple(可迭代对象)

  • 和列表的类型转换一样，只能选取可迭代对象进行转换，如列表、字典、字符串等

  • 例子：

a = [1,2,3]
b = tuple(a)
type(b)
>> 结果 <class 'tuple'>

字典类型方法

类型转换

dict()

可以将嵌套了两个值列表的列表，转换为字典。

例如：dict([(1,2),(5,6)])

dict.fromkeys(键列表,初始值)

将列表不可变类型的值作为键名，初始化字典。

例如：d={}.fromkeys(keys,None)

按key进行取值

print(dict[key])

赋值操作

dict["key1"] = 123

key已存在，会修改key对应的值。

key不存在，会创建一个key并对应赋的值。

统计字典长度

len()

统计key元素个数。

成员运算

key in dict

对字典进行成员运算时，是根据key进行判断的。

del删除

del dict[key]

pop删除

ret = dict.pop(key)

根据key进行删除，同时返回删除的key对应的值.

popitem随机删除

dict.popitem()

popitem会随机删除，然后返回一个元组，其中包含删除的key和value。

获得字典所有的键名

dict.keys()

可用于将字典的key作为可迭代对象。

例如：for i in dict.keys(): ...

获得字典所有的值

dict.values()

可用于将字典的value作为可迭代对象。

例如：for i in dict.values(): ......

获得字典的键值对

dict.items()

将字典的key/value作为可迭代对象。

例如：for k,v in dict.items(): ...

清空字典所有的键值对

dict.clear()

清空字典所有的键值对。

更新字典

old_dict.update(new_dict)

用一个新字典，更新老字典。

会将新字典当中新的、有的，而老字典中老的或没有的键值对，更新到老字典中。

也就是新字典有的，老字典也要一样，老字典原来有的，但是新字典没有的，仍然保留。

例如：

a = {1:1,2:2}
b = {1:2,2:2,3:3}
b.update(a)
>> 输出 {1: 1, 2: 2, 3: 3}

取值

dict.get(key)

容错性更好，建议使用这种方式取值。

比起直接使用[key]进行取值，这种方式取值如果没有key会返回none，而不会直接报错。

不存在则赋值

dict.setdefault(键名,值)

key不存在则进行创建并赋值，key存在则不修改，另外他会返回字典中key对应的值。

集合类型方法

类型转换

set()

set()可将没有可变类型的迭代对象转换为集合，并将其中的元素去重，然后返回一个无序的集合。

例如：

s = set("heelllooo")
>> 输出  {'l', 'e', 'h', 'o'}

取出交集

ret = set1 & set2

集合1 & 集合2，会取出两个集合共同的部分，也就是交集。

例如：

a = {1,2,6,7}
b = {1,2,8,9}
print(a & b)
>> 输出 {1, 2}

取出并集(合集)

ret = set1 | set2

集合1 | 集合2，取出两个集合所有的部分合并，然后去重。

例如：

a = {1,2,6,7}
b = {1,2,8,9}
print(a | b)
>> 输出 {1, 2, 6, 7, 8, 9}

取出差集

ret = set1 - set2

在两个集合中，取出运算符左边集合独有的部分。

集合1 - 集合2，左边减去右边有的部分。

例如：

a = {1,2,6,7}
b = {1,2,8,9}
print(a - b)
>> 输出 {6, 7}

取出对称差集

ret = set1 ^ set2

取出两个集合独有的部分，去掉共同的部分。

同等于 (set1 - set2) | (set2 - set1)

• 例如:

a = {1,2,6,7}
b = {1,2,8,9}
print(a ^ b)
>> 输出 {6, 7, 8, 9}

更新集合

set1.update(set2)

将另一个集合加入这个集合，并去重。

删除元素

s.discard(元素值)

删除的元素如果不存在也不会报错。

例子

s = {1,2,3}
s.discard(3)
print(s)
>> 输出 {1, 2}

添加新元素

s.add(值)

添加新元素添加到集合。

去重

s = set(list)

直接 set() 将需要去重的列表等转换。

但是无法保证顺序，如果顺序比较重要，可以使用循环+成员运算解决。

例如：

li = [4,2,3,1,3,4,5]
e = []
for i in li:
    if i not in e:
    e.append(i)

父子集运算 (包含的关系)

介绍

如果集合1完全包含集合2，那么集合1就是集合2的父集。

如果两个集合相同，则他们互为父子集。

如果集合1和集合2有不同的部分，那么他们就不是包含关系。

父子集运算

set1 > set2 当set1包含set2时，则返回True。

set1 == set2 当set1等于set2时，则返回True。

set1 < set2 当set2包含set1时，则返回True。

例如：

a = {1,2,6,7}
b = {1,2}
print(a > b)
>> 输出 True