python第六章 数据容器

01 数据容器概念

一种可以容纳多份数据的数据类型，，每一个元素，可以是任意类型的数据

一种可以存储多个元素的python数据类型

02 有那些数字容器

list tuple(元组)    str(字符串)         set(集合)      dict(字典)

03 list(列表)

（1）列表的定义格式

#字面量
[元素1，元素2，元素3，元素4.....]

#定义变量
变量名称 = [元素1，元素2，元素3，元素4，。。。。]


#定义空列表
变量名称 = []
变量名称 = list()

列表内的每一个数据，称之为元素，用逗号隔开

#定义一个列表:元素类型不受限制
my_list=["itheima",666,True]
print(my_list)
print(type(my_list))

#定义一个嵌套列表
my_list1=[ [1,2,3],[4,5,6]]
print(my_list1)

（2）列表的下标（索引）

2.1列表中的每一个元素，都有下表索引，从前向后，从0开始，依次递增

2.2反向索引，从后向前，从-1开始，依次递减（-1，-2，-3.。。。。。）

2.3嵌套列表，同样支持下标索引

2.4   列表【下标】

2.5 超出取值范围无法取出元素

04 列表的常用操作

（1）方法

如果将函数定义为class(类)的成员，那么函数会称为：方法

class student:
    
    def add(self,x,y):

        return x+y


num=add(1,2)
student = student()
num = student.add(1,2)

 (2) 列表的功能

2.1 语法        列表.index(元素)         功能是查找元素的索引是多少 

2.2 修改特定位置的元素值      语法：  列表[下标]=值

2.3 插入元素           语法：  列表.insert(下标，元素）  用于在指定的下标位置，插入指定元素

2.4 追加一个元素           语法： 列表.append(元素)

2.5 追加多个元素           语法：列表.extend(其他数据容器）

2.6 删除元素              语法： del 列表[下标 ]       列表.pop(下标)

2.7 删除某元素在列表中的一个匹配项            语法： 列表.remove(元素)

2.8 清空列表        列表.clear()

2.9 统计某元素在列表内的数量        语法：列表.count(元素)

2.10 统计列表中元素的数量              语法：len(列表)

#修改下标
my_list[0]="爱好"
print(f"修改后的列表为：{my_list}")

my_list.insert(1,"better")
print(f"修改后的列表为：{my_list}")

#追加元素
my_list.append("论文")
print(f"追加后的列表为：{my_list}")

my_list1=[2,3,4]
my_list.extend(my_list1)
print(f"列表在追加后为：{my_list}")

#删除元素
my_list2=["it","my","some"]
del my_list2[2]
print(f"列表元素为：{my_list2}")
element=my_list2.pop(1)
print(f"列表取出的元素为{element},列表为{my_list2}")

mylist = ["1","2","3","4","5"]
mylist.remove("2")
print(f"最终元素结果是：{mylist}")

mylist.clear()
print(f"最终元素结果是：{mylist}")

mylist=["1","1","1","2","2"]
print(mylist.count("1"))

num = len(mylist)
print(f"数量为：{num}")

list=[21,25,21,23,22,20]
#追加数字31，用变量接收
list.append(31) #追加单个元素
print(f"列表元素为：{list}")

#追加新列表
list2 = [29,33,30]
list.extend(list2) #追加多个元素
print(f"列表元素为：{list}")

#取出第一个元素
print(f"第一个元素为：{list[0]}")
#取出最后一个元素
print(f"最后一个元素为：{list[-1]}")

(3）列表的循环遍历

3.1 while循环 遍历列表元素，可以自定循环条件

3.2 for循环，不可以自定循环条件    

for 临时变量 in数据容器：

        对临时变量进行处理

from logging.config import listen
def list_while():
    list1=[1,2,3,4,5]
    index = 0
    while index<len(list1):
        elment=list1[index]
        print(f"列表的元素为：{elment}")
        index+=1

list_while()

#取出列表中的偶数
#定义一个列表
list1=[1,2,3,4,5,6,7,8,9,10]
list2=[]
for elment in list1:
    if elment%2==0:
        list2.append(elment)
print(f"for循环，遍历列表，找到的偶数为{list2}")

list3=[]
index = 0
while index<len(list1):
    elment=list1[index]
    if elment%2==0:
        list3.append(elment)
    index+=1
print(f"for循环，遍历列表，找到的偶数为{list3}")

（4）元组操作

index()    查找某个数据

count（）统计某个数据在元组中出现的次数

len()      统计元组内的元素个数

05 字符串的定义和操作

（1）字符串也可以通过下标进行索引

（2）字符串只读，不能修改

（3）字符串的替换

语法：字符串.replace（字符串1，字符串2）

作用：将字符串内的全部：字符串1，替换为字符串2，得到一个新字符

（4）字符串的分割

语法：字符串.split（分隔符字符串）

功能：按照指定的分隔符字符串，将字符串划分为多个字符串，并存入列表对象中

作用：得到一个新的列表对象

（5）去前后空格

语法：字符串.strip()

去前后指定字符串

语法：字符串.strip（字符串）

my_str = "itheima and itcast"
#通过下标索引取值
value = my_str[0]
value2 = my_str[-1]

#所取数值为
print(value,value2)

#字符串index,查找起始下标
value3 =my_str.index("th")
print(value3)

new_my_str= my_str.replace("th","程序")
print(new_my_str)

my_str="hello python itheima itcast"
my_list = my_str.split(" ")
print(my_list)

#strip方法
my_str1 = "   itheima   and   "
new1 = my_str1.strip()
print(f"字符串被strip后，结果为{new1}")
#strip字符串方法
my_str1 = "12itheima   and21"
new1 = my_str1.strip("12")
print(f"字符串被strip后，结果为{new1}")

#统计字符串出现的次数：count
my_mine = "itheima and itcast"
count = my_mine.count("it")
print(f"字符串{my_mine}中it出现的次数是：{count}")
#统计字符串长度
num = len(my_mine)
print(f"长度为{num}")

06 数据容器的切片

（1）序列是指，内容连续、有序，可以使用下标索引的一类数据容器

（2）列表、元组、字符串，均可以看做序列

（3） 语法：序列[起始下标：结束下标：步长]

步长可以为负数，可以反向标记

（4）如果要从头到尾进行切片，则不需要把头和尾写出来

（5）pop()取出元素

element = my_list.pop()

（6）取差集

语法：集合1.difference(集合2)     功能：取出集合1和集合2的差集（集合1有而集合2没有的）

（7）消除两个集合的差集

语法：  集合1.difference_update(集合2)   功能：在集合1内，删除和集合2相同的元素

结果：集合1被修改，集合2不变

（8）合并 union 

语法：集合1.union(集合2)

06 字典

（1）定义

使用{}，存储的元素是一个个的键值对

定义空字典    my_dict = {}     my_dict = dict()

定义字典变量  my_dict = {key:value,key:value     ,key:value}

字典通过key值来取得对应的value

#倒序字符串，切片取出
new_list1=list1[::-1][9:14]  #第一个【】表示倒序，第二个【】表示切片从9-14
print(new_list1)

set1 = {1,2,3}
set2 = {2,5,7}
set3 = set1.difference(set2)
print(f"取出差集的结果是{set3}")
set4 = set2.difference_update(set1)
print(f"消除差集后，结果为{set4}")

my_list = ['黑马','博客','程序','itheima','best']
#定义一个空集合
my_set = set()
#通过for循环遍历列表,并将元素放入新列表中
for element in my_list :
    my_set.add(element)

print(f"列表的内容是{my_set}")

#定义字典
my_dict = {"王李":99 ,"小红":89 ,"小明":90}
#定义空字典
my_dict2 = {}
print(f"字典1的内容是：{my_dict},类型：{type(my_dict)}")
print(f"字典2的内容是：{my_dict2},类型：{type(my_dict2)}")
score = my_dict["王李"]
print(f"王李的分数是：{score}")
"""
#定义嵌套字典
my_dict={
    "王":{
        "语文":90,
        "数学":100
    },"李":{
        "语文":90,
        "数学":100
    },"林":{
        "语文":90,
        "数学":100
    }
}
print(f"{my_dict}")
score = my_dict["李"]["数学"]
print(f"取出的信息是{score}")