字符串 列表 字典 元组 集合常用方法

1 字符串操作

1.字符串的索引取值: 字符串[index]

# 正向取值从0编号，反向取值从-1编号
res = '12345'
print(res[0])  # 1
res = '1,2 ,3, 4, 5'
print(res[0])  # 1
res = '1,2 ,3, 4, 5'
print(res[-1])  # 5

2.字符串拼接

ls1 = '1,2345'
ls2 = 'abcde'
res = ls1 + ls2
print(res)  # 1,2345abcde
# 拼接其他类型
s1 = 10
s2 = 'abc'
s3 = True
#res = s1+s2+s3
#print(res)  # 报错 不是同类型
res = str(s1) + s2 + str(s3)  # 正确 10abcTrue  这种情况只能转化为字符串 不能‘abc’转化为整数类型

res = '%s%s%s' % (s1, s2, s3)  # %s 万能占位符 位置一一对应

3.字符串长度

res = '10abcTrue'
print(len(res))  # 9  字符串长度为9
print(len(res[0]))  # 1 

4 字符串切片:

res = '123456abc'
print(res[0::])  # 表示从0号位开始到结束 123456abc
print(res[0:6:])  # 123456  表示从0号位开始到6号位结束 则是 123456
print(res[3:7:])  # 456a
print(res[::-1])  # cba654321  # 符号表示倒叙取值
print(res[::-2])  # ca531  # 倒叙2步取值
print(res[-1:-6:-1])  # cba65 倒叙 取五位值

5.成员运算：

判断某字符串是否在该字符串中 （in 和 not in）

res = '123456呵呵'
ls5 = '呵呵'
print(ls5 in res)  # True
print(ls5 not in res)  # False

6 字符串循环。涉及for循环

res = '123456呵呵'
for i in res:
    print(i)  # 1 2 3 4 5 6 呵 呵  打印出来每个都是一行　

7 字符串重要方法

1.索引(目标字符串的索引位置)

s1 = '123abc呵呵'
print(s1.index('b'))  # 4    表示b对应的位置是从0到4的位置

res2 = '1213wsx741wsx'
print(res2.index('1')) # 0
print(res2.index('w')) # 4
# 索引默认只取第一个值的位置

　　

2.去留白(默认去两端留白，两端没有空格时也可以去两端指定字符)  res.strip()

res = '   ***anc * 789***   '
print(res.strip())  # ***anc*789***  把两端的空格去掉了
res = '  ***anc * 789***   '
print(res.strip('*'))  #   ***anc * 789***     当两端有空格时，还是只能去空格

res = '***anc * 789***'
print(res.strip('*'))  # anc * 789  两端无空格的情况下 去掉两端的*字符

　　

3.判断字符串是否是正整数  res.isdigit

res = '12345'
print(res.isdigit())  # True
# 判断是否是负数  首先判定首字母是-号，在判断后面是不是正整数
res = '-12345'
res = '-12345'

if res.startswith("-") and res[1::].isdigit(): # 首先判断是否是负数 然后在判断-号后面的数就好 ，
    print("res是负数")
else:
    print("res是正数")

　　

　

 4.大小写转换  res.lower() 转化为小写   |  res.upper() 转为大写

res = 'aBCdEFf'
print(res.lower())  # 转化为全小写 abcdeff
print(res.upper())  # ABCDEFF

# 补充  res.islower()  判断是不是小写   |    res.isupper()判断是不是大写
print(res.islower())  # False
print(res.isupper())  # False

　　

 5.以某某开头或结尾

res = '12345wsx345'
print(res.startswith("123"))  # True
res = 'wsx1234edc789'
print(res.endswith('78'))   # False

　　

6.替换 res.replace('y','x',数字) 表示x将替换y, 数字表示将替换几次

res = 'egon say he is 逗比,egon egon egon!'
print(res.replace('egon', 'lxx'))   # lxx 替换egon  默认替换所有   lxx say he is 逗比,lxx lxx lxx!
print(res.replace('egon', 'lxx', 3))  # lxx 替换egon三次   lxx say he is 逗比,lxx lxx egon!

　　

7.格式化 只能格式化掉{}的内容

s8 = 'name：{}，age：{}'
print(s8.format('owen', 18))  # name：owen，age：18   # 默认按位置去掉空字典

print('name：{1}，age：{0}, height：{1}'.format('Owen', 18))  # name：18，age：Owen, height：18
# 指定位置   name：{1}指的是被format（）里的索引1的位置值18代替  age：{0}指的是被format（）后面索引的0位置的owen代替

print('name：{n}，age：{a}, height：{a}'.format(a=18, n="Zero"))  # name：Zero，age：18, height：18
# 指名道姓

　　

其他格式

s7 = '123wsx'
print(s7.isalnum())  # True 由字母和数字组成的
s9 = '1234'
print(s9.isalnum())  # True  由字母和数字组成的

s10 = '123qaz' # .isalpha判断是否是字母组成
print(s10.isalpha())  # False

　　

8 其他方法

# 1. find | rfind：查找子字符串索引，无结果返回-1
# 2. lstrip：去左留白
# 3. rstrip：去右留白
# 4. center | ljust | rjust | zfill：按位填充
# 语法：center(所占位数, '填充符号')
# 5. expandtabs：规定	所占空格数
# 6. captialize | title | swapcase：首字母大写 | 单词首字母大写 | 大小写反转
# 7. isdigit | isdecimal | isnumeric：数字判断
# 8. isalnum | isalpha：是否由字母数字组成 | 由字母组成
# 9. isidentifier：是否是合法标识符
# 10. islower | isupper：是否全小 | 大写
# 11. isspace：是否是空白字符
# 12. istitle：是否为单词首字母大写格式

　　

2 列表操作

 列表：

names = ['a','b','c','d']

　

1、追加：names.append()

names.append('e')
print(names)
['a', 'b', 'c', 'd', 'e']

　　

2、删除：pop，remove，del

1）pop()

如果没有指定下标，则默认会删除最后一个元素

print(names.pop())   # e

指定下标时，就会删除下标所对应的元素

print(names.pop(2))  # c

　

2）remove()

>>> names.remove('e')
>>> names
['a', 'b', 'c', 'd']

　　

 3）del

>>> del names[4]
>>> names
['a', 'b', 'c', 'd']

　

3、查找元素所在位置：index()

>>> names.index('c')
2

　　

4、统计元素的次数：count()

>>> names.append('d')
>>> names.count('d')
2

　　

5、反转：reverse()

list5 = [1,2,1,'c',1]
# 反转的返回值为none
list5.reverse()
print(list5.reverse())# none
print(list5) # [1, 'c', 1, 2, 1]

　　

　　

　　

6、清空：clear()

>>> names.clear()
>>> names
[]

　　

7、插入：insert()

list7 = [1,2,1,'c',1]
list7.insert(3,"888")  # 在索引为3的位置插入
print(list7) # [1, 2, 1, '888', 'c', 1]

　　

　　

还有其他的插入方法：

>>> names[3] = 'lebron'
>>> names
['a', 'b', 'devilf', 'lebron', 'd']

　　

8、排序：list.sort() 和sorted(list)

# 升序

# sort
s2 = [2,1,9,3,2]
s2.sort()
print(s2) # [1, 2, 2, 3, 9]

# sorted
s3 = [2,1,9,3,2]
# 调用sorted()方法。它返回一个新的list，新的list的元素基于小于运算符(__lt__)来排序
s4 = sorted(s3)
print(s4) # [1, 2, 2, 3, 9]
print(s3) # [2, 1, 9, 3, 2]


# 降序 参数reverse默认为False,升序  如果为True,则为降序
s5 = [2,1,9,3,2]
s5.sort(reverse=True) #
print(s5) # [9, 3, 2, 2, 1]

s6 = [2,1,9,3,2]
s7 = sorted(s6,reverse=True)
print(s7) # [9, 3, 2, 2, 1]

　　

　　

9、列表拼接：extend()

s8 = [1,3,5]
print(id(s8)) # 2373059530376
s9 = [2,4,6]

# 调用extend()时不会改变列表的id 
s8.extend(s9)
print(s8,id(s8)) # [1, 3, 5, 2, 4, 6]  2373059530376

　　

　　

10、列表切片

1）列出所有的元素

>>> names[::]
['&&', 'a', 'b', 'd', 'devilf', 'lebron', 'beijing', 'shandong', 'usa']

　

2）列出最后一个元素，从中间位置开始，列出后面所有的元素

>>> names[-1]
'usa'

　　

>>> a = int(len(names)/2)
>>> names[a:]
['devilf', 'lebron', 'beijing', 'shandong', 'usa'

　　

11、复制：copy()

>>> names.copy()
['&&', 'a', 'b', 'd', 'devilf', 'lebron', 'beijing', 'shandong', 'usa']

　　

另外的几种复制的方法：

import copy
info = ['name',['a',100]]
n1 = copy.copy(info)
print(n1) # ['name', ['a', 100]]

n2 = info[:]
print(n2) # ['name', ['a', 100]]

n3 = list(info)
print(n3) # ['name', ['a', 100]]

　　

在使用copy.copy()时，需要导入copy模块

这些均是浅copy

 

import copy
info = ['name',['a',100]]


n1 = info[:]
n2 = copy.copy(info)
print(n1) # ['name', ['a', 100]]
print(n2) # ['name', ['a', 100]]


n1[0] = 'devilf'
n2[0] = 'lebron'
print(n1,n2)

# ['devilf', ['a', 100]]
# ['lebron', ['a', 100]]


n1[1][1] = 80
print(n1) # ['devilf', ['a', 80]]

print(n2)  # ['lebron', ['a', 80]]

这里可以看到修改n1列表中的值，n2中的值也会跟着改变，这就是浅copy,也就是说，浅copy会复制原列表的内存地址，

也就是说，我们修改了n1和n2，就是修改了指向同一内存地址的对象，所以info列表会变化，n1和n2都会变化，例如：

print(info)  # ['name', ['a', 80]]

　　

　

3 字典操作

类型

容器(集合)：存放多个值的变量

单列容器(系统中的单列容器很多)：list | tuple

双列容器(map)：只有dict，存放数据 成对出现，dict存放数据采用 key-value键值对方式

 

字典中的key可以为什么类型：key必须为不可变类型

-- key是取value的唯一依据，key一旦被确定，就需要唯一确定(不能被改变)

 

字典中的value可以为什么类型：value可以为任意类型

-- value是用来存放世间所有存在的数据

key要确保唯一性，不能重复，值可以重复，并且可以被改变 => 字典为可变类型

 

 字典常规操作

1 增

字典名["key"] = 值 => key已存在就是修改值，不存在就是新增值
dic = {'a': 1, 'b': 2}
dic['c'] = 3
print(dic) # {'a': 1, 'b': 2, 'c': 3}

2 改

dic =  {'a': 1, 'b': 2, 'c': 3}
dic['c'] = 30
print(dic)   # {'a': 1, 'b': 2, 'c': 30}

3 查:字典名[key]

dic =  {'a': 1, 'b': 2, 'c': 30}

print(dic['c'])  # 只能查找已有的key30

#有默认值的查询：有key取出对应value，没有返还默认值，默认值可以自定义

print(dic.get('d', 'http://www.baidu.com'))  # http://www.baidu.com

　　

4 删除

 清空  dict.clear()

dic =  {'a': 1, 'b': 2, 'c': 30}
dic.clear()
print(dic)  # {}

　

删除　pop()

pop(k)删除指定key的value并返还删除的value

dic = {'a': 1, 'b': 2, 'c': 30}
print(dic.pop("c")) # 30

从末尾删除  popitem()

dic =  {'a': 1, 'b': 2, 'c': 30}
res = dic.popitem()
print(dic, res)   # {'a': 1, 'b': 2} ('c', 30)

　　

 5 更新

a有值覆盖，c没被新操作，带下来，b为新增，增加并赋值

dic = {'a': 1, 'c': 2}
d = {'a': 10, 'b': 20}
dic.update(d)
print(dic)  # {'a': 10, 'c': 2, 'b': 20}

　　

带默认值的新增: 新增key，key已有，啥事不干，没有添加key，值就是第二个参数

dic.setdefault('z', 100)
print(dic)  #  {'a': 10, 'c': 2, 'b': 20, 'z': 100}

 

 6 字典的循环

1.直接循环，就是循环得到key

 

dic = {'a': 1, 'c': 2}

for k in dic:
    print(k)  # a c 

　　

2.循环keys（效果和1 一致）

print(dic.keys())

for k in dic.keys():

    print(k)  # a c

3.循环values

print(dic.values())

for k in dic.values():

    print(k)

'''
dict_values([1, 2])
1
2
'''

　　

同时循环key和value (key, value)

dic = {'a': 1, 'c': 2}
print(dic.items())

a, b = (1, 2)

print(a, b)

for res in dic.items():

    print(res)

'''
dict_items([('a', 3), ('c', 2)])
1 2
('a', 3)
('c', 2)
'''

　　

 7 重点解压赋值

dic = {'a': 3, 'c': 2}

for k, v in dic.items():
　　print(k,v)  #  a 3 c 2 

　　

　　

 4 元组(tuple)操作

元组：可以理解为不可变的列表

# 1.值可以为任意类型

# 2.可以存放多个值 - 可以进行成员运算

# 3.可以存放重复的值 - 可以计算成员出现的次数

# 4.有序存储 - 可以通过索引取值，可以切片

　　

t1 = ('physics', 'chemistry', 1997, 2000)
t2 = (1, 2, 3, 4, 5, 6, 7 )

1 　索引取值　

print(t1[1], type(t1[1]))
print(t1[-3])
# chemistry <class 'str'>
# chemistry

2 运算拼接

print((1, 2) + (2, 3))

# (1, 2, 2, 3)

3.长度

print(len(t1))　

4 切片

print((2, 1, 3)[::-1])   # (3, 1, 2)

5 成员运算　

print(True in t1)  # 
print(False in t1)  # False == 0， t1中如果有0或False，该结果都是True

6 循环　

for obj in t1:
    print(obj, end=" ")  # physics chemistry 1997 2000 

7 计数

print(t1.count(0))  # 对象0在元组中出现的次数
 
print(t1.index(123, 4, len(t1))) # 对象0在区间4~末尾第一次出现的索引

　　

5 集合(set)操作

# 概念：
# 1.set为可变类型 - 可增可删
# 2.set为去重存储 - set中不能存放重复数据
# 3.set为无序存储 - 不能索引取值
# 4.set为单列容器 - 没有取值的key
# 总结：set不能取值

　　

 增

s = set()

s.add('1')
s.add('2')
s.add('1')
print(s)  #  {'2', '1'} 去重 数字会乱序排列
s.update({'2', '3'})
print(s) # {'3', '1', '2'}

删

c1 = {3,1,2,6,-1,"c"}
c2 = c1.pop()
print(c2) # 0 # 有0默认删除0  没有 默认删除1 依次2 ...

　　

　　

s = {3,1,2}
s.remove(1)
print(s)  # {2，3}

　

s = {3,1,2}
s.clear()
print(s)  # set()

　　

set运算

# 交集：两个都有 &
py = {'a', 'b', 'c', 'egon'}
lx = {'x', 'y', 'z', 'egon'}
print(py & lx)
print(py.intersection(lx))
# 合集：两个的合体 |
print(py | lx)
print(py.union(lx))
# 对称交集：抛出共有的办法的合体 ^
print(py ^ lx)
print(py.symmetric_difference(lx))
# 差集：独有的
print(py - lx)
print(py.difference(lx))
# 比较：前提一定是包含关系
s1 = {'1', '2'}
s2 = {'2'}
print(s1 < s2)