【python学习笔记】day4

一.数据容器入门

1.数据容器是一种可以存储多个元素的python数据类型

2.python的数据容器有：list(列表）、tuple(元组）、str(字符串）、set(集合）、dict（字典）它们各有特点，但都满足可容纳多个元素的特性。

二.list列表

A.列表的定义语法

1.列表的定义语法：

[元素1，元素2，元素3············]

list(元素1，元素2，元素3············)

2.数据容器内的每一份数据，都称之为元素

3.元素数据类型没有任何限制，甚至元素也可以是列表，这样就定义了嵌套列表

B.列表的下标索引

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

    从前向后的方向，编号从0开始递增；从后往前的方向，编号从-1开始递减

2.如何通过下标索引取出对应位置的元素：  列表[下标]，即可取出

3.注意下标索引的取值范围，超出范围无法取出元素，并且会报错

# 通过下标索引去除对应位置的数据
my_list=["Tom","Lily","Rose"]
# 列表[下索引]， 从前向后从0开始，每次+1，      从后向前从-1开始，每次-1
print(my_list[0])
print(my_list[1])
print(my_list[2])

# 错误示范：通过下标索引取数据，一定不要超出范围
# print(my_list[3])

# 通过下标索引取出数据（倒叙取出）
print(my_list[-1])
print(my_list[-2])
print(my_list[-3])

# 取出嵌套列表的元素
my_list=[[1,2,3],[4,5,6]]
print(my_list[1][1])

C.列表的常用操作方法

"""
演示数据类型容器之:list列表的常用操作
"""
mylist=["itcast","itheima","python"]
# 1 查找某元素在列表内的下标索引
index=mylist.index("itheima")
print(f"itheima在列表中的下标索引值是：{index}")
# 2 修改特定下标索引的值
mylist[0]="博客"
print(f"列表被修改元素值后，结果时：{mylist}")
# 3 在指定下标位置插入新元素
mylist.insert(1,'best')
print(f"列表插入元素后，结果是：{mylist}")
# 4 在列表的尾部追加'''单个'''新元素
mylist.append("程序员")
print(f"在列表的尾部追加了元素后，结果是：{mylist}")
# 5 在列表的尾部追加'''一批'''新元素
mylist2=[1,2,3]
mylist.extend(mylist2)
print(f"在列表的尾部追加了一个新的列表后，结果是：{mylist}")
# 6 删除指定下标索引的元素（2种方式）
# 6.1 方式1 del 列表[下标]
del mylist[2]
print(f"列表删除元素后结果是：{mylist}")
# 6.2 方式2：列表.pop(下标）
mylist=["itcast","itheima","python"]
element=mylist.pop(2)
print(f"通过pop方法取出元素后结果是：{mylist}，取出的元素是：{element}")
# 7 删除某元素在列表中的第一个匹配项
mylist=["itcast","itheima","itcast","itheima","python"]
mylist.remove("itheima")
print(f"通过remove方法移除元素后，列表的结果是：{mylist}")
# 8 清空列表
mylist.clear()
print(f"列表被清空了，结果是：{mylist}")
# 9 统计列表内某元素数量
mylist=["itcast","itheima","itcast","itheima","python"]
count=mylist.count("itheima")
print(f"列表中itheima的数量是：{count}")
# 10 同济列表中全部元素的数量
mylist=["itcast","itheima","itcast","itheima","python"]
count=len(mylist)
print(f"列表的元素数量总共有：{count}个")

D.列表的循环遍历

1.遍历操作 是将容器内的元素依次取出，并处理

2.可以使用while或for循环 遍历列表的元素

3.for循环的语法：

for 临时变量 in 数据容器：

    对临时变量进行处理

4.for循环和while对比

for循环更简单，while更灵活

for用于从容器内依次取出元素并处理，while用以任何需要循环的场景

def list_while_func():
    """
    使用while循环遍历列表的演示函数
    :return: None
    """
    mylist=["博客","程序员","python"]
    # 循环变量通过下标索引来控制，默认0
    # 每一次循环将下标索引变量+1
    # 循环条件： 下标索引变量<列表的元素变量

    # 定义一个变量用来标记列表的下标
    index=0       #初始值为0
    while index<len(mylist):
        # 通过index变量取出对应下标的元素
        element=mylist[index]
        print(f"列表的元素：{element}")
        # 至关重要 将循环变量（index)每一次循环都+1
        index += 1
def list_for_func():
    """
    使用for循环遍历列表的演变函数
    :return: None
    """
    mylist=[1,2,3,4,5]
    # for 临时变量  in   数据容器：
    for element in mylist:
        print(f"列表的元素有：{element}")

list_while_func()
list_for_func()

eg:

list=[1,2,3,4,5,6,7,8,9,10]
# 定义一个空列表用于存储偶数
even_list_while=[]
index=0
while index<len(list):
    # 通过索引获取当前元素
    element=list[index]
    if element%2==0:
        even_list_while.append(element)
    index+=1
print(f"通过while循环，从列表：{list}中取出偶数，组成新列表：{even_list_while}")

even_list_for=[]
for element in list:
    if element%2==0:
        even_list_for.append(element)
print(f"通过for循环，从列表：{list}中取出偶数，组成新列表：{even_list_for}")

三.元组的定义和操作

1.元组定义方式：

（元素1，）（当元组中只有1个元素时 要加 逗号，）

（元素1，元素2，元素3··········）

  tuple(元素1，元素2，元素3····）

2.元组的操作方法：

index（）    查找某个数据，如果数据存在返回对应的下标，否则抱错

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

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

3.元组不可以修改内容（可以修改内部list的内部元素）

t1=(1,2,["itheima","itcast"])
print(f"t1的内容是：{t1}")
t1[2][0]="程序员"
t1[2][1]="博客"
print(f"t1的内容是：{t1}")

4.元组的特点：

和list基本相同（有序、任意数量元素、允许重复元素），唯一不同在于不可修改

3.支持for循环和while循环

t1=('周杰伦',11,['football','music'])
index=t1.index(11)
print(f"其年龄所在的下标位置是：{index}")
print(f"学生姓名为：{t1[0]}")
del t1[2][1]
print(f"新元组为：{t1}")
t1[2].append('coding')
print(f"新元组为：{t1}")

四.字符串的定义和操作

1.字符串之所以被称之为数据容器是因为字符串可以看作是字符的容器，支持下标索引等特性

2.字符串的常用操作方法：

3.字符串的特点：

只可以存储字符串

长度任意（取决于内存大小）

支持下标索引

允许重复字符串存在

不可以修改（增加或删除元素等）

支持for循环和while循环

eg:

a="itheima itcast boxuegu"
count=a.count("it")
print(f"字符串{a}内有{count}个it字符")
b=a.replace(" ","|")
print(f"字符串{a}，被替换空格后，结果：{b}")
a_list=b.split("|")
print(f"字符串{b}按照|分割后结果是：{a_list}")