python-数据容器

一、列表

1.列表的定义

mylist=["itheima","it","dfgf"]
print(mylist)
print(type(mylist))

2.列表中的元素中的数据类型是不受限制的

mylist=["dhfu",223,True]
print(mylist)
print(type(mylist))

3.定义嵌套列表

mylist=[[1,2,3],[4,5,6]]
print(mylist)
print(type(mylist))

4.列表下标索引
列表[下标索引]:
当下标索引为正数时，从前向后，从0开始，每次加1；
当下标索引为负数时，从后向前从-1开始，每次减1；

mylist=[[1,2,3],[4,5,6]]
#正向
print(mylist[0])
print(mylist[1])
print(mylist[2])
#负向
print(mylist[-1])
print(mylist[-2])
print(mylist[-3])

5.取出嵌套索引

mylist=[[1,2,3],[4,5,6]]
print(mylist[1][0])

6.列表的常用的操作

• 6.11在列表中查询下标索引：语法：列表名.index(“表中的元素”)

index=mylist.index("itcast")
print(index)

• 6.12如果查找不存在：

index=mylist.index("hello")
print(index)

报错：
        Traceback (most recent call last):
          File "D:\DeepLearning\pythonLearn\第六章\数据容器.py", line 43, in <module>
            index=mylist.index("hello")
        ValueError: 'hello' is not in list

• 6.2修改特定下标索引的值

mylist[0]="hello"
print(mylist[0])

• 6.3在指定的下标未知插入新元素

mylist.insert(1,0)
print(mylist)

• 6.4在列表尾部添加一个元素
  语法：列表.append(元素)，
  (单个元素)将指定元素追加到列表的尾部

mylist=[1,2,3]
mylist.append(4)
print(mylist)

• 6.5在列表尾部插入一批元素
  语法：列表名.extend()

mylist2=[1,2,3]
mylist.extend(mylist2)
print(mylist)

• 6.6删除指定下标索引元素（2种方式）

"""
    语法1：del 列表[下标]
    语法2：列表.pop(下标)
"""
#方法1：
mylist=["Tom","lily","rose"] 
del mylist[1]
#方法2：
mylist.pop(1)
print(mylist)

• 6.7删除某元素在列的第一个匹配项

"""
    语法：列表.remove(元素)
"""
mylist=["itcast","itema","itcast","python"]
mylist.remove("itcast")
print(mylist)

• 6.8清空列表

"""
    语法：列表.clear()
"""
mylist=[1,2,3,4,5]
mylist.clear()
print(mylist)

• 6.9统计列表中元素的数量

mylist=[1,2,3,4,5]
a=mylist.count(1)
print(a)

• 6.10统计列表中有多少元素

mylist=[1,2,3,4,5]
cout= len(mylist)
print(cout)

二、元组

1.定义元组

"""
    # 定义元组自变量
    （元素，元素，元素，元素）
    # 定义元组变量
    变量名称=（元素，元素，元素，元素） 
    # 定义空元组
    变量名称=（）
    变量名称=tuple（）     
"""
# 定义元组
t1=(1,"hello",True)
t2=()
t3=tuple()

print(f"t1的类型{type(t1)},内容是{t1}")
print(f"t1的类型{type(t2)},内容是{t2}")
print(f"t1的类型{type(t3)},内容是{t3}")

2.定义单个元素的元组

t4=("hello",)#注意  单个元素不加逗号则就不是元组而是字符串
print(f"元组的内容是：{t4}，元组的类型是{type(t4)}")

3.元组的嵌套

t5=((1,2,3),(4,5,6))
print(f"元组的内容是：{t5}，元组的类型是{type(t5)}")

# 下标索引去取出元素
num=t5[1][2]
print(f"从嵌套元组中取出的数据是：{num}")

4.元组的常用操作
4.1index查找方法

t6=("丝丝拉拉","我饿了","dhsfu",1,1,1,1)
index=t6.index("丝丝拉拉")
print(index)

4.2元组中的元素数量统计

num=t6.count(1)
print(num)

4.3统计元组元素的数量

t8=(2,1,2,3)
print(len(t8))

4.4元组的遍历

# 元组的遍历：while
index=0
while index < len(t8):
     print(f"元组中的元素有{t8[index]}")
     index+=1

# 元组的遍历： for
 for element in t8:
     print(f"元组中的元素有{element}")

4.5元组是只读的不可以修改的

"""元组是只读的不可以修改的"""
t8[1]="hello"
#会报错

三、字符串

1.定义字符串

   #演示以数据容器的角色，学习字符串的相关的操作
    #字符串是不可修改的
my_str="iteima and itcast"

2.通过下标索引取值

value=my_str[2]
value2=my_str[-2]
print(value)
print(value2)

3.修改字符串 （字符串不支持修改操作）

my_str[2]="H"
#会报错

4.字符串的常用操作方法
4.1index查找方法

value=my_str.index("and")
print(f"and在字符串的起始位置{value}")

4.2replace方法

"""
    字符串的替换
    语法：字符串.replace(字符串1，字符串2)
    功能：字符串内的全部：字符串1，替换为字符串2
    注意：不是修改字符串本身的内容，而是得到一个新的字符串
"""

new_str=my_str.replace("it","程序")
print(new_str)

4.3split方法

"""
    字符串的分割
    语法：字符串.split(分隔符字符串)
    功能：按照指定的分隔字符串，将字符串划分为多个字符串，并存入到列表对象中
    注意:字符串本身不变，而是得到一个列表对象
"""
my_str="iteima and itcast"
new_str=my_str.split()
print(my_str)
print(new_str)

4.4字符串的规整操作（去前后空格）

"""
    字符串的规整操作（去前后空格）
    语法：字符串.strip()
"""
my_str="   itheima and itcast"
new_mystr=my_str.strip()
print(new_mystr)

4.5字符串的规整操作（去前后指定字符串）

"""
    字符串的规整操作（去前后指定字符串）
    语法：字符串.strip(字符串)
         
"""
my_str="12itheima and itcast21"
""" 注意 传入的是 ”12“ 其实就是：”1“，”2“都会移除，是按照单个字符"""
print(my_str.strip("12"))

4.6统计字符串中某个字符串出现的次数

my_str="itheima and itcast"
cout=my_str.count("it")
print(f"字符串{my_str}中it出现的次数是：{cout}")

4.7统计字符串的长度

num=len(my_str)
print(f"字符串{my_str}的长度是：{num}")

四、序列切片操作

"""
    对序列进行切片操作
    语法：序列[起始下标：结束下标：步长]
    表示从序列中，从指定位置开始，依次取出元素。到指定位置结束，得到一个新序列
    ·起始下标表示从何处开始，可以留空。留空时，视作从头开始
    ·结束下标（不含）表示何处结束，可以留空。留空时，留空视作截取到结尾
    ·步长表示，依次取元素的间隔
        ·步长为1，表示一个个取元素
        ·步长为2，表示每次跳过1个元素取
        ·步长为N，表示每次跳过N-1个元素取
        ·步长为负数，表示反向取
"""

1.对list进行切片,从1开始，4结束，步长为1

my_list=[0,1,2,3,4,5,6]
print(my_list[1:4:1]) #步长默认为1，所以可以省略不写

2.对tuple进行切片，从头开始，到最后结束

my_tuple=(0,1,2,3,4,5,6)
print(my_tuple[:])

3.对字符串str进行切片，从头开始，到最后结束，步长为2

my_str="0123456789"
print(my_str[::2])

4.对str进行切片，从头开始，到最后结束，步长为-1

my_str="01234567"
print(my_str[::-1])

5.对列表进行切片，从3开始，到1结束，步长为-1

my_list=[0,1,2,3,4,5,6]
print(my_str[3:1:-1])

6.对元组进行切片，从头开始，到尾结束，步长为-2

my_tuple=(0,1,2,3,4,5,6)
print(my_tuple[::-2])

五、集合的定义

"""
    集合的定义
    #定义集合字面量
    {元素，元素，元素，元素}
    #定义集合变量
    变量名称={元素，元素，元素，元素}
    #定义空集合
    变量名称=set()    
    集合中没有重复的元素   自动去重哦
"""

1.定义集合

# 定义集合
my_set={"1","2","3","1","2","3"}
my_set_empty=set()
print(f"非空集合的中的参数为{my_set}，类型是{type(my_set)}")
print(f"空集合的中的参数为{my_set_empty},类型是{type(my_set_empty)}")

2.添加新元素

"""
    因为集合是无序的，所以集合是不支持：下标索引访问的
    但是集合和列表一样，是允许修改的
"""
#添加新元素
my_set.add("1")
my_set.add("2")
print(f"my_set添加元素后的结果是{my_set}")

3.移除元素

#方式1
my_set.remove("1")
print(f"输出结果{my_set}")

#方式2：
"""
    从集合中随机取出元素
    语法：集合.pop(),功能：从集合中随机取出一个元素
    结果：会得到一个元素的结果，同时集合本身被修改，元素被移除
"""
my_set={"hello","world","itheima"}
element=my_set.pop()
print(my_set)
print(element)

4.清空集合

"""
    清空集合
    语法：集合.clear() 功能：清空集合
    结果：集合本身被清空
"""
my_set={"hello","world","itheima"}
my_set.clear()
print(my_set)

5.集合的差集

""" 
    取出2个集合的差集
    语法：集合1.differenc(集合2)，功能：取出集合1和集合2的差集（集合1有而集合2没有）
    结果得到一个新的集合，集合1，2不变
"""

set1={1,2,3}
set2={1,5,6}
set3=set1.difference(set2)
set4=set2.difference(set1)
print(set3)
print(set4)
print(set1)
print(set2)

6.消除两个集合的差集

"""
    消除2个集合的差集
    语法：集合1.difference_update（集合2）
    功能:对比集合1和集合2，在集合1内，删除和集合2相同的元素
    结果：集合1被修改，集合2不变
"""
set1={1,2,3}
set2={1,5,6}
set1.difference_update(set2)
print(set1)
print(set2)

7.两个集合的合并

"""
    两个集合的合并
    语法：将集合1和集合2组成新集合
    结果：得到新集合，集合1和集合2不变
"""
set1={1,2,3}
set2={1,5,6}
set3=set1.union(set2)
print(set3)

8.统计集合元素数量len()

set1={1,2,3,4,5}
num=len(set1)
print(f"集合内的元素数量有{num}个")

9.集合的遍历

#集合不支持下标索引，不能用while循环
#可以用for循环
set1={1,2,3,4,5,6}
for element in set1:
    print(f"集合中的元素个数有{element}")

六、字典

"""
    字典的定义，同样使用{}，不过存储的元素是一个一个的：键值对
    # 定义字典的字面量
    {key：value,key:value,。。。。,key}
    #定义字典变量
    my_dict={key：value,key:value,。。。。,key}
    #定义空字典
    my_dict={}#定义方式1
    my_dict=dict()#定义方式2     
"""

1.定义字典

# 定义字典
my_dict1={"王力宏":99,"周杰伦":88,"林俊杰":77}
#定义空字典
my_dict2={}
my_dict3=dict()
print(f"字典1的内容是：{my_dict1}，类型{type(my_dict1)}")
print(f"字典2的内容是：{my_dict2}，类型{type(my_dict2)}")
print(f"字典3的内容是：{my_dict3}，类型{type(my_dict3)}")

2.定义重复key的字典

my_dict1={"王力宏":99,"王力宏":88,"林俊杰":77}
print(f"重复key的字典的内容是{my_dict1}")
#输出的结果 ：{"王力宏":88,"林俊杰":77}

3.数据字典的获取

"""
    字典数据的获取
    但是字典可以通过key值来获取对应的value
"""
# 语法，字典[key]可以取得对应的value
stu_score={"王力宏":99,"zhou":88,"林弟弟":11}
print(stu_score["王力宏"])
print(stu_score["zhou"])
print(stu_score["林弟弟"])

4.定义嵌套字典

# 定义嵌套字典
stu_score_dict={
    "王力宏":{
            "语文":77,
            "数学":44,
            "英语":88,
    },"周街路":{
            "语文":17,
            "数学":24,
            "英语":18,
    },"邻居":{
            "语文":12,
            "数学":21,
            "英语":10,

    }
}

print(stu_score_dict)

print(stu_score_dict["邻居"]["英语"])
print(stu_score_dict["王力宏"]["英语"])

5.数据字典的常用操作

"""
    字典的常用操作
    1.新增元素
        语法：字典[key]=value
        结果：字典被修改，新增了元素
    2.更新元素
        语法：字典[key]=value 
        结果：字典被修改，元素被更新
        注意：字典key不可被重复，所以对已存在的key执行上述的操作，就是更新value的值
    3.删除元素
        语法：字典.pop(key)
        结果：获得指定key的value，同时字典被修改，指定key的数据被删除
    4.清空字典
        语法：字典.clear()
        结果：字典被修改，元素无法被清空
    5.获取全部的key
        语法：字典.keys()
        结果：得到字典中的全部key
"""

5.1新增元素

my_dict={"林俊杰":99,"周杰伦":88,"张学友":11}
# 新增元素
my_dict["张稀哲"]=12
print(f"字典经过新增元素后，结果：{my_dict}")

5.2更新元素

my_dict["周杰伦"]=22
print(f"字典经过更新元素后，结果：{my_dict}")

5.3删除元素

score=my_dict.pop("周杰伦")
print(f"字典中移除了一个元素，结果：{my_dict}，周杰伦的考试分数是{score}")

5.4获取全部的key

my_dict={"周结论":99,"林进阶":88,"张雪有":77}
keys=my_dict.keys()
print(f"字典的全部key{keys}")

5.5遍历字典

#方式1 通过获取到全部的key来完成遍历
for key in keys:
    print(f"字典的key是{key}")
    print(f"字典的value是{my_dict[key]}")
#方式2 直接对字典进行for循环,每一次循环都是直接得到key
for key in my_dict:
    print(f"2字典的key是{key}")
    print(f"2字典的value是{my_dict[key]}")

5.6统计字典内的元素的数量

# 统计字典内的元素数量 len()函数
num=len(my_dict)
print(f"字典中的元素的数量有:{num}个")