python常见容器操作：字符串的增删改查循环、列表的增删改查循环、元组的查循环、字典的的增删改查循环等常规操作

python中常见容器有如下几种: 字符串 列表 元组 字典

1、字符串

字符串：双引号或者单引号中的数据，就是字符串

#通过该下标取某一个字符
name = 'abcdef'
print(name[0])
print(name[1])
print(name[2])
#通过切片取一段字符串
name = 'abcdef'
print(name[0:3]) # 取 下标0~2 的字符
print(name[2:]) # 取 下标为2开始到最后的字符
print(name[1:-1]) # 取 下标为1开始 到 最后第2个  之间的字符

字符串常规操作

#find():检测某个子串是否包含在这个字符串中，如果在返回这个子串开始的位置下标，否则则返回-1
#字符串序列.find(子串, 开始位置下标, 结束位置下标)
mystr = "hello world and itcast and itheima and Python"

print(mystr.find('and'))  # 12
print(mystr.find('and', 15, 30))  # 23
print(mystr.find('ands'))  # -1

#index():检测某个子串是否包含在这个字符串中，如果在返回这个子串开始的位置下标，否则则报异常。
#字符串序列.index(子串, 开始位置下标, 结束位置下标)
mystr = "hello world and itcast and itheima and Python"
print(mystr.index('and'))  # 12
print(mystr.index('and', 15, 30))  # 23
print(mystr.index('ands'))  # 报错

#replace():字符串替换
#字符串序列.replace(旧子串, 新子串, 替换次数)
mystr = "hello world and itcast and itheima and Python"
# 结果：hello world he itcast he itheima he Python
print(mystr.replace('and', 'he'))
# 结果：hello world he itcast he itheima he Python
print(mystr.replace('and', 'he', 10))
# 结果：hello world and itcast and itheima and Python
print(mystr)

#split()按照指定字符分割字符串。
#字符串序列.split(分割字符, num)
mystr = "hello world and itcast and itheima and Python"

# 结果：['hello world ', ' itcast ', ' itheima ', ' Python']
print(mystr.split('and'))
# 结果：['hello world ', ' itcast ', ' itheima and Python']
print(mystr.split('and', 2))
# 结果：['hello', 'world', 'and', 'itcast', 'and', 'itheima', 'and', 'Python']
print(mystr.split(' '))
# 结果：['hello', 'world', 'and itcast and itheima and Python']
print(mystr.split(' ', 2))


# capitalize
#把字符串的第一个字符大写
mystr.capitalize()

# title
#把字符串的每个单词首字母大写
>>> a = "hello itcast"
>>> a.title()
'Hello Itcast'

# startswith
#检查字符串是否是以 hello 开头, 是则返回 True，否则返回 False
mystr.startswith(hello)

# endswith
#检查字符串是否以obj结束，如果是返回True,否则返回 False.
mystr.endswith(obj)

#lower
#转换 mystr 中所有大写字符为小写
mystr.lower()

#upper
#转换 mystr 中的小写字母为大写
mystr.upper()

#ljust
#返回一个原字符串左对齐,并使用空格填充至长度 width 的新字符串
mystr.ljust(width)

# rjust
#返回一个原字符串右对齐,并使用空格填充至长度 width 的新字符串
mystr.rjust(width)

#center
#返回一个原字符串居中,并使用空格填充至长度 width 的新字符串
mystr.center(width)

# lstrip
#删除 mystr 左边的空白字符
mystr.lstrip()

#rstrip
#删除 mystr 字符串末尾的空白字符
mystr.rstrip()

#strip
#删除mystr字符串两端的空白字符
>>> a = "\n\t itcast \t\n"
>>> a.strip()
'itcast'

# rfind
#类似于 find()函数，不过是从右边开始查找.
mystr.rfind(str, start=0,end=len(mystr) )

# rindex
#类似于 index()，不过是从右边开始.
mystr.rindex( str, start=0,end=len(mystr))

# partition
#把mystr以str分割成三部分,str前，str和str后
mystr.partition(str)

#rpartition
#类似于 partition()函数,不过是从右边开始.
mystr.rpartition(str)

#splitlines
#按照行分隔，返回一个包含各行作为元素的列表
mystr.splitlines()

#isalpha
#如果 mystr 所有字符都是字母 则返回 True,否则返回 False
mystr.isalpha()

#isdigit
#如果 mystr 只包含数字则返回 True 否则返回 False.
mystr.isdigit()

# isalnum
#如果 mystr 所有字符都是字母或数字则返回 True,否则返回 False
mystr.isalnum()

#isspace
#如果 mystr 中只包含空格，则返回 True，否则返回 False.
mystr.isspace()

列表常规操作

 namesList = ['xiaoWang','xiaoZhang','xiaoHua']
 print(namesList[0])
 print(namesList[1])
 print(namesList[2])
#列表循环
names_list = ['xiaoWang','xiaoZhang','xiaoHua']
length = len(names_list)
i = 0
while i<length:
    print(names_list[i])
    i+=1

#添加元素：append, extend, insert
#append:通过append可以向列表添加元素

#定义变量A，默认有3个元素
A = ['xiaoWang','xiaoZhang','xiaoHua']
print("-----添加之前，列表A的数据-----")
for temp_name in A:
    print(temp_name)
#提示、并添加元素
temp = input('请输入要添加的学生姓名:')
A.append(temp)
print("-----添加之后，列表A的数据-----")
for temp_name in A:
    print(temp_name)

    
#extend:通过extend可以将另一个集合中的元素逐一添加到列表中
a = [1, 2]
>>>b = [3, 4]
>>> a.append(b)
>>> a
[1, 2, [3, 4]]
>>> a.extend(b)
>>> a
[1, 2, [3, 4], 3, 4]

#insert:在指定位置index前插入元素
#insert(index, object) 在指定位置index前插入元素object
a = [0, 1, 2]
>>> a.insert(1, 3)
>>> a
[0, 3, 1, 2]


#修改列表元素
A = ['xiaoWang','xiaoZhang','xiaoHua']

print("-----修改之前，列表A的数据-----")
for temp_name in A:
    print(temp_name)

#修改元素
A[1] = 'xiaoLu'

print("-----修改之后，列表A的数据-----")
for temp_name in A:
    print(temp_name)
#结果:
 #   -----修改之前，列表A的数据-----
  #  xiaoWang
 #   xiaoZhang
   # xiaoHua
  #  -----修改之后，列表A的数据-----
  #  xiaoWang
  #  xiaoLu
   # xiaoHua

#列表查询：in not in index, count

#in,有true，没有false
#待查找的列表
name_list = ['xiaoWang','xiaoZhang','xiaoHua']

#获取用户要查找的名字
find_name = input('请输入要查找的姓名:')

#查找是否存在
if find_name in name_list:
    print('在字典中找到了相同的名字')
else:
    print('没有找到')
    
#index, count，两者用法一致
#列表名.index('查找的字符串'，查询起始位置，查询结束位置)
>>> a = ['a', 'b', 'c', 'a', 'b']
>>> a.index('a', 1, 3) # 注意是左闭右开区间
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: 'a' is not in list
>>> a.index('a', 1, 4)
3
>>> a.count('b')
2
>>> a.count('d')
0

#删除元素("删"del, pop, remove): * del：根据下标进行删除 * pop：删除最后一个元素 * remove：根据元素的值进行删除

#del
movie_name = ['加勒比海盗','骇客帝国','第一滴血','指环王','霍比特人','速度与激情']

print('------删除之前------')
for temp_name in movie_name:
    print(movie_name)

del movie_name[2]

print('------删除之后------')
for temp_name in movie_name:
    print(temp_name)
#结果:
 #   ------删除之前------
#加勒比海盗
 #   骇客帝国
 #   第一滴血
 #  霍比特人
 #   速度与激情
 #   ------删除之后------
 #   加勒比海盗
 #   骇客帝国
 #   指环王
 #   霍比特人
#   速度与激情


#pop:删除最后一个元素
movie_name = ['加勒比海盗','骇客帝国','第一滴血','指环王','霍比特人','速度与激情']
print('------删除之前------')
for temp_name in movie_name:
    print(temp_name)
movie_name.pop()
print('------删除之后------')
for temp_name in movie_name:
    print(temp_name)
#结果:
#------删除之前------
#加勒比海盗
#骇客帝国
#第一滴血
#指环王
#霍比特人
#速度与激情
#------删除之后------
#加勒比海盗
#骇客帝国
#第一滴血
#指环王
#霍比特人

# remove:根据元素的值进行删除
movie_name = ['加勒比海盗','骇客帝国','第一滴血','指环王','霍比特人','速度与激情']
print('------删除之前------')
for temp_name in movie_name:
    print(temp_name)
movie_name.remove('指环王')
print('------删除之后------')
for temp_name in movie_name:
    print(temp_name)
#结果:
#------删除之前------
#加勒比海盗
#骇客帝国
#第一滴血
#指环王
#霍比特人
#速度与激情
#------删除之后------
#加勒比海盗
#骇客帝国
#第一滴血
#霍比特人
#速度与激情


#排序(sort, reverse)
#sort:方法是将list按特定顺序重新排列，默认为由小到大，参数reverse=True可改为倒序，由大到小。
#reverse:方法是将list逆置
>>> a = [1, 4, 2, 3]
>>> a
[1, 4, 2, 3]
>>> a.reverse()
>>> a
[3, 2, 4, 1]
>>> a.sort()
>>> a
[1, 2, 3, 4]
>>> a.sort(reverse=True)
>>> a
[4, 3, 2, 1]
列表推导式:
作用：用一个表达式创建一个有规律的列表或控制一个有规律列表。
列表推导式又叫列表生成式。

#while循环实现
# 1. 准备一个空列表
list1 = []
# 2. 书写循环，依次追加数字到空列表list1中
i = 0
while i < 10:
    list1.append(i)
    i += 1
print(list1)

#for循环实现
list1 = []
for i in range(10):
    list1.append(i)
print(list1)

#》》》列表推导式实现
list1 = [i for i in range(10)]
print(list1)

##需求：创建0-10的偶数列表
#方法一：range()步长实现
list1 = [i for i in range(0, 10, 2)]
print(list1)
#方法二：if实现
list1 = [i for i in range(10) if i % 2 == 0]
print(list1)

#for循环
list1 = [(i, j) for i in range(1, 3) for j in range(3)]
print(list1)
#结果：[(1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2)]

元组

元组特点：定义元组使用小括号，且逗号隔开各个数据，数据可以是不同的数据类型。

# 多个数据元组
t1 = (10, 20, 30)

# 单个数据元组
t2 = (10,)

注意：如果定义的元组只有一个数据，那么这个数据后面也好添加逗号，否则数据类型为唯一的这个数据的数据类型

t2 = (10,)
print(type(t2))  # tuple

t3 = (20)
print(type(t3))  # int

t4 = ('hello')
print(type(t4))  # str

元组的常见操作

元组数据不支持修改，只支持查找，具体如下：

• 按下标查找数据

tuple1 = ('aa', 'bb', 'cc', 'bb')
print(tuple1[0])  # aa

• index()：查找某个数据，如果数据存在返回对应的下标，否则报错，语法和列表、字符串的index方法相同。

tuple1 = ('aa', 'bb', 'cc', 'bb')
print(tuple1.index('aa'))  # 0

• count()：统计某个数据在当前元组出现的次数。

```python
tuple1 = ('aa', 'bb', 'cc', 'bb')
print(tuple1.count('bb'))  # 2

- len()：统计元组中数据的个数。

tuple1 = ('aa', 'bb', 'cc', 'bb')
print(len(tuple1))  # 4

```python
> 注意：元组内的直接数据如果修改则立即报错



tuple1 = ('aa', 'bb', 'cc', 'bb')
tuple1[0] = 'aaa'


> 但是如果元组里面有列表，修改列表里面的数据则是支持的，故自觉很重要。


tuple2 = (10, 20, ['aa', 'bb', 'cc'], 50, 30)
print(tuple2[2])  # 访问到列表


# 结果：(10, 20, ['aaaaa', 'bb', 'cc'], 50, 30)
tuple2[2][0] = 'aaaaa'
print(tuple2)

4. 小结

• 定义元组

t1 = (10, 20, 30)

t2 = (10,)

• 常用操作方法
• index()
• len()

字典

字典的基本使用

```python
info = {'name':'班长', 'id':100, 'sex':'f', 'address':'地球亚洲中国北京'}
print(info['name'])
print(info['address'])

结果:

```python
班长
地球亚洲中国北京

若访问不存在的键，则会报错：

>>> info['age']
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'age'

在我们不确定字典中是否存在某个键而又想获取其值时，可以使用get方法，还可以设置默认值：

>>> age = info.get('age')
>>> age #'age'键不存在，所以age为None
>>> type(age)
<type 'NoneType'>
>>> age = info.get('age', 18) # 若info中不存在'age'这个键，就返回默认值18
>>> age
18

1. 查看元素

除了使用key查找数据，还可以使用get来获取数据

示例:

    info = {'name':'吴彦祖','age':18}

    print(info['age']) # 获取年龄

    # print(info['sex']) # 获取不存在的key，会发生异常

    print(info.get('sex')) # 获取不存在的key，获取到空的内容，不会出现异常

2. 修改元素

字典的每个元素中的数据是可以修改的，只要通过key找到，即可修改

示例:

    info = {'name':'班长', 'id':100, 'sex':'f', 'address':'地球亚洲中国北京'}

    new_id = input('请输入新的学号')

    info['id'] = int(new_id)

    print('修改之后的id为%d:'%info['id'])

结果:

3. 添加元素

示例:访问不存在的元素

    info = {'name':'班长', 'sex':'f', 'address':'地球亚洲中国北京'}

    print('id为:%d'%info['id'])

结果:

如果在使用 变量名['键'] = 数据时，这个“键”在字典中，不存在，那么就会新增这个元素

示例:添加新的元素

    info = {'name':'班长', 'sex':'f', 'address':'地球亚洲中国北京'}

    # print('id为:%d'%info['id'])#程序会终端运行，因为访问了不存在的键

    newId = input('请输入新的学号')

    info['id'] = newId

    print('添加之后的id为:%d'%info['id'])

结果:

    请输入新的学号188
    添加之后的id为: 188

4. 删除元素

对字典进行删除操作，有一下几种： * del * clear()

示例:

del删除指定的元素

    info = {'name':'班长', 'sex':'f', 'address':'地球亚洲中国北京'}

    print('删除前,%s'%info['name'])

    del info['name']

    print('删除后,%s'%info['name'])

结果

示例:

del删除整个字典

    info = {'name':'monitor', 'sex':'f', 'address':'China'}

    print('删除前,%s'%info)

    del info

    print('删除后,%s'%info)

结果

示例:

clear清空整个字典

    info = {'name':'monitor', 'sex':'f', 'address':'China'}

    print('清空前,%s'%info)

    info.clear()

    print('清空后,%s'%info)

结果

1.get()

• 语法

字典序列.get(key, 默认值)

注意：如果当前查找的key不存在则返回第二个参数(默认值)，如果省略第二个参数，则返回None。

• 快速体验

dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
print(dict1.get('name')) 
>> Tom

print(dict1.get('id', 110))
>>> 110

print(dict1.get('id'))
>>> None

2. keys()

显示所有的key值

dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
print(dict1.keys())
>>>dict_keys(['name', 'age', 'gender'])

3. values()

显示所有的value值

dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
print(dict1.values())
>>>dict_values(['Tom', 20, '男'])

4. items()

显示所有的键值对(key-value形式)

dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
print(dict1.items())
>>>dict_items([('name', 'Tom'), ('age', 20), ('gender', '男')])