python容器

五、 数据容器

一个数据容器可以容纳多份数据

5.1、列表list

• 以 [ ] 作为标识，有序存储，存和取的顺序一样

• 列表内每一个元素之间用逗号隔开

• 允许重复数据存在

• 可以修改（增删改查）

# 字面量定义列表
[元素1,元素2,元素3,元素4,元素5，······]
​
# 变量定义列表
变量名称 = [元素1,元素2,元素3,元素4,元素5，······]
​
# 定义空列表
变量名称 = []
变量名称 = list()
​
# 嵌套列表的定义
变量名称 = [[元素1,元素2],元素3，[元素4,元素5,元素6]]
​
# 注意：变量名称相当于列表名

注意：列表可以存储多个数据，可以存储不同的数据类型，支持嵌套

列表的下标索引：列表中的每一个元素都有一个编号，称之为下标索引

• 从前向后：编号从0开始依次递增

• 从后向前：编号从-1开始依次递减

注意：下标索引不能超出范围，超出范围就会报错

语法：列表名称 [下标索引]

# 定义列表
my_list = ["python","java","c","c++"]
​
# 通过索引取出元素（可以使用变量接收，也可以直接打印）
value = my_list[0]
print(value)        # 结果为：python
print(my_list[2])     # 结果为：c
​
# 通过反向索引取出元素
print(my_list[-1])      # 结果为：c++
print(my_list[-3])      # 结果为：java
# 定义嵌套列表
my_list = [[1,2,3],4,5,[6,7,8,9]]
​
# 取出数字3
print(my_list[0][2])
​
# 取出列表中最后一个元素
print(my_list[-1])      # 结果为：[6,7,8,9]

5.2、列表常用方法

• 查找元素下标-->调用index()方法

  # 语法：列表名.index(查找的元素)
  mylist = ["java","python","c","c++"]
  ​
  # 查找元素C的下标
  index = mylist.index("c")
  print(index)      # 结果为：2

• 修改索引位置的元素值-->列表名[下标]

  # 语法：列表名[下标] = 值
  mylist = ["java","python","c","c++"]
  ​
  # 正向下标
  mylist[0] = "js" 
  print(mylist)     # 结果为：["js","python","c","c++"]
  ​
  # 反向下标
  mylist[-3] = "go"
  print(mylist)     # 结果为：["js","go","c","c++"]

• 插入元素---->调用insert()方法

  # 语法：列表名.insert(下标，元素)-->在指定下标位置插入指定元素
  mylist = ["java","python","c","c++"]
  ​
  # 插入元素
  mylist.insert(1,"go")
  print(mylist)     # 结果为：["java","go","python","c","c++"]

• 追加单个元素--->调用append()方法

  # 语法：列表名.append(元素)-->将指定元素追加到列表尾部
  mylist = ["java","python","c","c++"]
  ​
  # 追加元素
  mylist.append("go")
  print(mylist)     # 结果为：["java","python","c","c++","go"]

• 追加一批元素-->调用extend(其他数据容器)

  # 语法：列表名.extend(其他容器)-->将其他容器的内容取出，依次追加到列表尾部
  mylist_1 = ["java","python"]
  mylist_2 = ["go","c++","c"]
  ​
  # 追加一批元素
  mylist_1.extend(mylist_2)
  print(mylist_1)     # 结果是：["java","python","go","c++","c"]

• 删除元素-->调用pop()方法或者使用del关键字

  # 语法1：del 列表名[下标]
  # 语法2：列表名.pop(下标)-->不仅可以删除，还可以返回被删除的元素
  mylist = ["java","python","c","c++","go"]
  ​
  # 方式1
  del mylist[2]
  print(mylist)     # 结果为：["java","python","c++","go"]
  ​
  # 方式2
  mylist.pop(0)
  print(mylist)     # 结果为：["python","c++","go"]
  

• 删除元素第一匹配项-->调用remove()方法

  # 语法：列表名.remove(要删除的元素)
  mylist = ["java","python","java","c","c++","go"]
  ​
  # 删除元素java
  mylist.remove("java")
  print(mylist)     # 结果为：["python","java","c","c++","go"]

• 清空列表-->调用clear()方法

  # 语法：列表名.clear()
  mylist = ["java","python","java","c","c++","go"]
  ​
  # 清空列表
  mylist.clear()
  print(mylist)     # 结果为：[]

• 统计指定元素在列表中的数量-->调用count()方法

  # 语法:列表名.count(要统计的元素)
  mylist = ["java","python","java","c","c++","go"]
  ​
  #统计java的个数
  count = mylist.count("java")
  print(count)      # 结果为：2

• 统计列表内总共的元素个数-->使用len()函数

  # 语法：len(列表名)
  mylist = ["java","python","java","c","c++","go"]
  ​
  # 统计总数
  num = len(mylist)
  print(num)        # 结果为：6

5.3、列表的遍历

1）while循环遍历-->结束条件为：下标值小于列表的元素数量

# 定义变量表示下标
index = 0
while index < len(列表名称):
    # 依次取出列表元素
    变量名 = 列表[index]
    index += 1

2）for循环遍历

"""语法：
  for 临时变量 in 数据容器:
      对临时变量进行处理
"""
# 定义数据容器
mylist  = [1,2,3,4,5]
# 遍历
for i in mylist:
    print(i)

3）enumerate遍历

# 与for遍历相同，不同的就是可以操作下标和元素----enumerate(容器名)
mylist  = [1,2,3,4,5]
# 遍历
for index,value in enumerate(mylist):
    print(f'下标为{index}的元素为{value}')

5.4、元组tuple

元组和列表一样，都可以封装多个，不同类型的元素在内，但最大的不同点在于：元组一旦定义完成，就不能修改

1）元组的定义：定义元组使用小括号，数据用逗号隔开，数据可以是不同类型的，也支持嵌套和列表用法相同

# 定义元组字面量
(元素1,元素2,元素3,······,元素n)
​
#定义元组变量
变量名称 = (元素1,元素2,元素3,······,元素n)
​
# 定义空元组
变量名称 = ()
变量名称 = tuple()

• 注意1：元组只有一个数据时，这个数据后面要有逗号，否则不是元组类型，是字符串

• 注意2：元组的遍历和列表的遍历相同

• 注意3：不能改变元组中的数据，否则会报错（assignment）

• 注意4：如果元组中嵌套列表，可以修改列表中的内容

5.5、元组的常用方法

和列表的方法相同，只是元组不能修改数据，所以没有修改的方法

1）查找元素下标-->通过index()方法

# 语法：元组名.index(要查找的元素)
my_tuple = ("java","python","java","c","c++","go")
​
# 查找元素c的下标
print(my_tuple.index("c"))    # 结果为：3

2）统计元组中指定元素个数-->调用count()方法

# 语法：元组名.count(要统计的元素)
my_tuple = ("java","python","java","c","c++","java","go")
​
# 统计元素java的个数
count = my_tuple.count("java")
print(count)    # 结果为：3

3）统计总个数-->使用len()函数

# 语法：len(元组名称)
my_tuple = ("java","python","java","c","c++","java","go")
​
# 统计总个数
print(len(my_tuple))    # 结果为：7

5.6、字符串常用方法

注意：字符串和元组一样也是一个无法修改的数据容器

1）通过下标索引取值

# 定义字符串
my_str = "irjifhi"
​
# 通过下标索引取值
value = my_str[1]
print(value)    # 结果为：r

2）查找下标索引-->调用index()方法

# 语法：字符串名.index(要查找的字符串)
my_str = "iuyr and jipr"
print(my_str.index("and"))    # 结果为：5

3）字符串的替换-->调用replace()方法

# 语法：字符串名.replace(字符串1,字符串2)-->将字符串1替换为字符串2
my_str = "iuyr and jipr and koj"
print(my_str.replace("and","or")) # 结果为：iuyr or jipr or koj

注意：replace方法不是修改字符串本身，而是得到了一个新的字符串

4）字符串的分割-->调用split()方法

注意：字符串本身不变，而是得到了一个列表对象

# 语法：字符串名.split(分割符字符串)
# 功能：按照指定的分割符字符串，将字符串分为多个字符串，并存入列表对象中
my_str = "iuyr and jipr and koj"

# 按照空格进行分割
my_str_list = my_str.split(" ")
print(my_str_list)    # 结果为：['iuyr', 'and', 'jipr', 'and', 'koj']

5）字符串的规整-->调用strip()方法，得到一个新的字符串

• 语法1：字符串名.strip()--->空参表示去前后空格和换行符

• 语法2：字符串名.strip(字符串)--->表示去前后指定字符串

# 去前后空格
my_str = " jidj and joej "
print(my_str.strip())   # 结果为：jidj and joej
​
# 去前后指定字符串
my_str = "12jiajo and jokerk21"
print(my_str.strip("12"))   # 结果为：jiajo and jokerk
## 注意：传入的是"12"其实就是"1"和"2"都会移除，是按单个字符移除

注意：去前后指定字符串时，传入的字符串是按照单个字符移除

6）统计指定字符串个数-->调用count()方法

7）统计字符串长度-->调用len(字符串名)函数

8）字符串的遍历---->和元组、列表相同

• 内置函数遍历：iter()方法

my_str = " jidj and joej "
for x in iter(my_str):
    print(x)

• enumerate()方法遍历----可以获取到下标和值

for index 值 in enumerate(容器名)：

9）判断字符串是否全由数字组成---->str.isdigit(名称)方法

my_str = " 243343 and joej "
print(str.isdigit(my_str))          # 结果为;False

10）判断字符串是否全由字母组成----->str.isalpha(名称)

my_str = " eref and joej "
print(str.isalpha(my_str))          # 结果为;True

11）忽略大小写-----忽略大写：str.upper()，忽略小写：str.lower()

5.7、序列的切片

序列指：内容连续，有序，可使用下标索引的一类数据容器，列表，元组，字符串均可以认为是序列，序列支持切片操作

切片语法：序列名[起始下标：结束下标：步长]--->表示从序列中指定位置开始，到指定位置结束，得到一个新序列

• 起始下标可以留空，表示从头开始

• 结束下标（不含）可以留空，表示截取到结尾

• 步长表示依次取元素的间隔

  • 步长1表示：一个个取元素

  • 步长2表示：每次跳过一个元素取

  • 步长n表示：每次跳过n-1个元素取

  • 步长为负值：表示反向取（起始下标和结束下标也要反向标记）

注意：切片操作不影响序列本身，而是产生一个新的序列

# 语法：序列名[起始下标：结束下标：步长]--->包前不包后，步长为1可以省略
​
# 定义列表序列
my_list = [1,2,3,4,5,6,7]
​
# 取出子序列[2,3,4,5,6]
new_my_list = my_list[1:6:1]
print(new_my_list)      # 结果为：[2,3,4,5,6]
​
# 从头到尾步长为2取出元素
print(my_list[::2])     # 结果为：[1,2,3,7]
​
# 反向切片（翻转）
print(my_list[::-1])    # 结果为：[7,6,5,4,3,2,1]
​
# 反向取出[5,4,3]---》起始下标 > 结束下标
print(my_list[4:1:-1])    # 结果为：[5,4,3]

5.8、集合set

序列都支持重复元素且有序，而集合主要的特点是：不支持重复元素（自带去重功能）并且内容无序(存和取的顺序不一样)

• 列表使用：[ ]

• 元组使用：( )

• 集合使用：{ }

# 定义集合字面量
{元素1,元素2,元素3,······,元素n}
​
# 定义集合变量
变量名称 = {元素1,元素2,元素3,······,元素n}
​
# 定义空集合
变量名称 = set()

注意：集合是无序的，不支持下标索引访问，但集合(不是序列)和列表一样支持修改元素

5.9、集合的常用操作

1）添加元素-->调用add()方法

# 语法：集合名.add(要添加的元素)--->将指定元素添加到集合中
my_set = {"jijri","虾米",12}
​
# 添加元素（集合本身被修改）
my_set.add("python")
print(my_set)     # 结果为：{'虾米', 'python', 12, 'jijri'}

2）移除元素-->调用remove()方法

# 语法：集合名.remove(要移除的元素)--->将指定的元素从集合中移除
my_set = {'虾米', 'python', 12, 'jijri'}
​
# 移除元素
my_set.remove(12)
print(my_set)     # 结果为：{'虾米', 'python', 'jijri'}

3）从集合中随机取出一个元素 -->调用pop()方法

# 语法：集合名.pop()--->从集合中随机取出一个元素
# 注意：pop()方法在序列中是删除下标索引元素，并且返回删除的元素，这里是取出，同时集合本身被修改，元素被移除
my_set = {'虾米', 'python', 12, 'jijri'}
​
# 取出元素
element = my_set.pop()
print(element)    # 结果为：集合中的随机一个元素
print(my_set)   # 结果为：去除集合中随机一个元素，剩余的全部元素

4）清空集合--->调用clear()方法

5）取出两个集合的差集-->调用difference()方法

• 取出集合1和集合2的差集（集合1有而集合2没有的）得到一个新集合，集合1和集合2不变

# 语法：集合1.difference(集合2)
set_1 = {1,2,3,4,5,6}
set_2 = {2,4,5,6}
​
# 取差集
new_set = set_1.difference(set_2)
print(new_set)      # 结果为：{1, 3}

6）消除集合的差集-->调用difference_update()方法

• 在集合1内，删除和集合2相同的元素，集合1被修改，集合2不变

# 语法：集合1.difference_update(集合2)
set_1 = {1,2,3,4,5,6}
set_2 = {2,4,5,6}
​
# 消除差集
set_1.difference_update(set_2)
print(set_1)      # 结果为：{1,3}
print(set_2)      # 结果为：{2, 4, 5, 6}

7）合并两个集合-->调用union()方法

• 将集合1和集合2合并，得到一个新集合，集合1和集合2不变

# 语法：集合1.union(集合2)
set_1 = {1,2,3,6}
set_2 = {2,4,5,6}
​
# 合并集合
new_set = set_1.union(set_2)
print(new_set)      # 结果为：{1,2,3,4,5,6}

8）统计集合中元素数量-->使用len(集合名)

9）集合的遍历--->集合不支持下标索引，不能使用while循环，可以使用for循环

5.10、字典dict

1）字典的定义：使用{ }，存储的元素是一个个的键值对

• 字典的key不能重复---key重复时value会被新的覆盖

• key和value之间用冒号隔开

# 定义字典字面量
{key:value,key:value,······,key:value}
​
# 定义字典变量
my_dict = {key:value,key:value,······,key:value}
​
# 定义空字典
my_dict = {}
my_dict = dict()

2）字典数据的获取--->无下标索引

# 语法：字典名[key]-----》可以获取到对应的value
stu_age = {"小明":23,"小张":20,"虾米":18}
​
# 获取数据
age = stu_age["小明"]
print(age)          # 结果为：23
print(stu_age["虾米"])    # 结果为：18

3）字典可以嵌套

字典可以存储任意类型的数据，但是key值不能嵌套字典

# 定义字典，嵌套其他数据容器
my_score_dict = {"小明":{"语文":90,"英语":60,"数学":88},
                 "虾米":{"语文":89,"英语":70,"数学":85}}
​
# 取出虾米的英语成绩
english_score = my_score_dict["虾米"]["英语"]
print(english_score)    # 结果为：70

5.11、字典的常用操作

1）新增元素

注意：如果新添加的元素的key值在字典中存在，就是更新元素（更新value值）

# 语法：字典名[key] = value
stu_age = {"小明":23,"小张":20,"虾米":18}
​
# 添加元素
stu_age["张三"] = 19
print(stu_age)      # 结果为：{'小明': 23, '小张': 20, '虾米': 18, '张三': 19}
​
# 更新元素
stu_age["小明"] = 20    
print(stu_age)      # 结果为：{'小明': 20, '小张': 20, '虾米': 18, '张三': 19}

2）删除元素--->返回对应的value值

# 语法：字典名.pop(key)
stu_age = {"小明":23,"小张":20,"虾米":18}
​
# 删除
age = stu_age.pop("小明")
print(age)        # 结果为：23
print(stu_age)      # 结果为：{"小张":20,"虾米":18}

3）清空字典

# 语法：字典名.clear()
stu_age = {"小明":23,"小张":20,"虾米":18}
​
# 清空字典
stu_age.clear()
print(stu_age)      # 结果为：{}

4）获取全部key

# 语法：字典名.keys()--->得到字典中的全部key
stu_age = {"小明":23,"小张":20,"虾米":18}
​
# 获取key
keys = stu_age.keys()
print(keys)     # 结果为：dict_keys(['小明', '小张', '虾米'])

5）字典的遍历-->无下标索引不能使用while循环

# 方法1：通过获取全部key进行遍历
stu_age = {"小明":23,"小张":20,"虾米":18}
# 获取key
keys = stu_age.keys()
for key in keys:
    print(f"字典的key是：{key},对应值为{stu_age[key]}")
​
# 方法2：直接通过for循环遍历
for key in stu_age:
    print(f"字典的key是：{key},对应值为{stu_age[key]}")
    
# 方法3：使用items()方法获取每一对key和value
for key,value in stu_age.items():
    print(f"key是{key},值为{value}")

6）获取字典中元素数量---->len(字典名)

7）去掉字符串格式：eval(str))

print(eval('[*"123"]'))         # 结果为：['1', '2', '3']
print(eval('["123"]'))          # 结果为：['123']
print(eval('{"a":1}'))          # 结果为：{'a': 1}
print(eval('{"a":1,"b":"2"}'))  # 结果为：{'a': 1, 'b': '2'}
print(eval("[{'id': '12', 'name': '张三'}]")) # [{'id': '12', 'name': '张三'}]

8）获取键对应的值：get('key')

# 方法1：值 = 字典名["键"]-------没有对应的键会报错
value = 字典名["key"]
# 方法2：字典名.get('key')-----key不存在返回None
value = 字典名.get('key')

5.12、容器的通用操作

• max（容器名）显示容器中最大的值

• min（容器名）显示容器中最小的值

• 将给定容器转换为列表：list(容器名)

• 将给定容器转换为字符串：str(容器名)或空字符串.join(容器名)

• 将给定容器转换为元组：tuple(容器名)

• 将给定容器转换为集合：set(容器名)

通用排序功能：sorted(容器名,[reverse = False])--->reverse默认为False，从小到大，如果需要翻转就传入True，从大到小，注意：排序之后会转为列表

# 定义容器
my_tupe = (2,4,5,7,1,3)
​
# 从小到大
print(sorted(my_tupe))      # 结果为：[1, 2, 3, 4, 5, 7]
​
# 从大到小
print(sorted(my_tupe,reverse=True))   # 结果为：[7, 5, 4, 3, 2, 1]

列表sort方法：列表名.sort(key=选择排序依据的函数（方法），reverse = True或False)

• 注意：sorted方法无法指定排序规则，的列表嵌套是就无法使用

• 参数key，是要求传入一个函数，表示将列表的每一个元素都传入函数中，返回排序的依据，参数reverse，表示是否翻转排序结果

# 定义嵌套列表
my_list = [["a",11],["c",44],["b",22],["d",33]]
​
# 定义排序方法
def 方法名(element):
    # 拿到每一个元素，按照元素嵌套中的下标1为比较对象
    return element[1]
​
# 调用sort方法排序
my_list.sort(key = 方法名,reverse=True)

zip()联合方法：将两个容器对应的值联合起来，返回一个迭代器，遍历出来的格式为元组

mylist  = [1,2,3,4,5]
mytroup = ("ni",'er','wre','ere','wew')
# 使用zip将对应下标的值组成元组
a = zip(mylist,mytroup)
for i in a:
    print(i)