Python学习笔记(6)--列表,元组,字符串,序列切片

传送门==>B站黑马python入门教程

---

目录

• 1.数据容器
• 2.列表
• • 2.1列表的定义
  • 2.2关于列表的下标索引
  • 2.3列表常用操作
  • 2.4列表练习
  • 2.5列表的循环遍历
• 3.元组
• 4.字符串
• 5.序列切片

---

1.数据容器

---

python中的数据容器:

可以容纳多份数据的数据类型,容纳的每一份数据称之为1个元素,

每个元素,可以是任意类型的数据,例如字符串,数字,布尔类型...

为什么学习数据容器?

为了批量存储或者使用多个数据;

根据不同的特性,可以分为不同的类型

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

• 是否支持重复元素
• 是否可以修改
• 是否有序
• ...

---

2.列表

---

2.1列表的定义

我们可以使用字符串变量在程序中存储姓名;

此时有多个同学,若要存储所有同学的姓名,此时如何书写程序?

还是直接声明多个字符串变量?

可以使用列表进行一次性存储

列表的基本语法
#字面量

元素1,元素2,元素3,元素4,元素5

#定义变量

变量名 = [元素1,元素2,元素3,元素4,元素5]
#定义空列表

变量名 = [ ]

变量名 = [list]

列表中的每一个数据,称为元素

• 以[]作为标识
• 列表中的每一个元素之间使用,分隔
• 元素的类型无限制

基础案例

# 案例
demo_list=["张三","李四","王五","赵六",123,False]

print(type(demo_list))
print(demo_list)

定义嵌套形式的列表

# 列表的嵌套
demo_list = [["张三","lisi"],["王五","赵六",123]]
print(type(demo_list))
print(demo_list)
print(demo_list[0])

---

2.2关于列表的下标索引

如何从列表中取到指定位置的数据?

可以使用下标索引获取

列表的下标索引从0开始,从左到右,索引递增

demo_list = [1,2,"元素3",3,4,5,6,7,8,9,10]
print(demo_list[0])
print(demo_list[2])

列表的下标索引从-1开始,从右到左,索引递减,

demo_list = [1,2,"元素3",3,4,5,6,7,8,9,10]
print(demo_list[-1])
print(demo_list[-3])
print(demo_list[-9])

那么关于嵌套的数据,例如二维列表,如何取出数据呢?

#嵌套列表如何获取数据
demo_list = [["张三","lisi"],["王五","赵六",123]]
# 获取其中列表2的第一个元素;
print(demo_list[1][0])

2.3列表常用操作

列表还有其他的操作方法

• 插入元素
• 删除元素
• 清空列表
• 修改元素
• 统计元素个数
• ...

函数作为封装的代码单元,可以提供一些特定的功能;

在Python中,如果将函数定义为class类型的成员,那么函数就是方法

方法和函数的功能一样,有入参,有返回值,只是方法的使用格式不同,

 示例:
 - 函数使用:num = add(1,2)
 - 方法使用: student = Student()
           num = student.add(1+2)

1.查询元素的下标

查询指定元素在列表中的下标索引位置,若找不到就会报错ValueError

语法使用:列表.index(元素)

# 示例:
list1 = ["1213",1,2,3,4,5,6,7,8,9]
# 查询元素"1213"的下标索引
print(list1.index("1213"))
# 查询元素1的下标索引
print(list1.index(1))
# 查询元素60的下标索引
print(list1.index(60))

2.修改指定下标索引的元素值
列表[下标] = 值

# 示例:
list1 = ["张三",1,2,3,4,5,6,7,8,9]
print(list1)
# 修改第一个元素;
list1[0] = "张三1"
print(list1)

3.插入元素

语法:列表.insert(下标,元素),在指定的下标位置加入元素

# 示例:
list1 = ["张三",1,2,3,4,5,6,7,8,9]
print(list1)
list1.insert(0,"张三1")
print(list1)

4.追加元素

语法:列表.append(元素),将元素直接追加到列表的尾部

# 示例:
list1 = ["张三",1,2,3,4,5,6,7,8,9]
print(list1)
list1.append("张三1")
print(list1)

5.追加元素方法2

语法:列表.extend(其他数据容器),将其他容器的元素依次追加到当前容器列表

# 示例:
list1 = ["张三",1,2,3,4,5,6,7,8,9]
list2 = ["张三1","张三2"]
print(list1)
list1.extend(list2)
print(list1)

6.删除元素

语法1:del列表[下标索引]

语法2:列表.pop(下标索引) [可以返回被删除的元素值是什么]

# 示例:
list1 = ["张三1",1,2,3,4,5,6,7,8,9]
print(list1)
del list1[0]
print(list1)

list2 = ["张三2",1,2,3,4,5,6,7,8,9]
print(list2)
list2.pop(0)
print(list2)

8.在列表中删除第一次匹配到的元素值

语法:列表.remove(元素)

# 示例:
list1 = ["张三1",1,"张三1",2,"张三1",3,4,5,6,7,8,9]
print(list1)
list1.remove("张三1")
print(list1)

9.清空列表全部元素

语法:列表.clear()

# 示例:
list1 = ["张三1",1,"张三1",2,"张三1",3,4,5,6,7,8,9]
print(list1)
print("清空列表list1")
list1.clear()
print(list1)

10.统计在列表中某个元素出现的次数

语法:列表.count(元素值)

# 示例:
list1 = ["张三1",1,"张三1",2,"张三1",3,4,5,6,7,8,9]
print(f"在列表中张三1出现的次数为:{list1.count('张三1')}")
print(f"在列表中1出现的次数为:{list1.count(1)}")
print(f"在列表中张三出现的次数为:{list1.count('张三')}")

11.统计列表的元素个数

语法:len(列表)

# 示例:
list1 = ["张三1",1,"张三1",2,"张三1",3,4,5,6,7,8,9]
print(f"列表list1的元素个数为:{len(list1)}")

2.4列表练习

有一个列表,内容为[21,25,21,23,22,20],

对于列表进行操作:

1.定义列表,使用变量接收;

2.追加数字31到尾部;

3.追加新列表[1,23,3]到尾部;

4.获取第一个元素;

5.获取最后一个元素;

6.查询元素31的索引位置;

list1 = [21,25,21,23,22,20]
print(list1)
list1.append(31)
print(list1)
list1.extend([1,23,3])
print(list1)
print(list1[0])
print(list1[-1])
print(list1.index(31))

2.5列表的循环遍历

---

既然数据容器可以存储多个元素,那么也可以从该容器中依次取出元素进行操作,

将容器中的元素依次取出进行处理的行为,就是遍历,迭代;
那么如何遍历列表中的元素呢?

• 可以使用while循环/for循环处理
  如何在循环中取出列表的元素?

• 可以根据列表的下标索引进行处理
  循环条件如何设置?

• 可以定义变量进行控制,注意该变量需要小于列表的元素数;

def while_list(list):
    """
    使用while循环遍历列表
    :param list: 列表
    :return: None
    """
    index = 0
    while index < len(list):
        data = list[index]
        print(f"列表元素:{data}")
        index += 1

list1 = [1,2,3,4,5]
while_list(list1)

def for_list(list):
    """
    使用for循环遍历列表
    :param list: 列表
    :return: None
    """
    for data in list:
        print(f"列表元素:{data}")

list1 = [1,2,3,4,5]
for_list(list1)

---

3.元组

---

为什么需要元组?

列表是可以修改的,但是若想要在数据传输时确保不被篡改,此时列表就不合适了
元组像列表一样,可以封装出来多个不同的元素在里面;

但是不同点就是,元组一旦定义之后就不可再修改了;

所以,若想要在程序内封装数据,又不希望封装的数据被篡改,那么元组就很适合

语法:使用小括号定义后使用,进行分隔,数据可以是不同类型的;

# 定义元组字面量
(元素1,元素2,...)

# 定义元组变量
变量名 = (元素1,元素2,...)

# 定义空元组
变量名 = ()
变量名 = tuple()

# 定义元组
tuple1 = ("张三",1,2,3,4,5,6,7,8,9)
print(tuple1)
print(type(tuple1))
print(tuple1[0])
# 空元组
tuple2 = ()
print(tuple2)
print(type(tuple2))

注若元组中只有一个数据时,这个数据后面要添加逗号

# 若元组中只有一个元素时,需要加上逗号,否则不是元组类型;
tuple3 = ("张三")
print(type(tuple3))

tuple4 = ("张三",)
print(type(tuple4))

像列表一样,元组也是可以嵌套的

# 元组嵌套;
tuple5 = (("张三",1),("张三1",2))
print(tuple5)
print(tuple5[0])

关于元组的操作方法:

1.获取指定元素的下标;
元组.index(元素)

# 获取元组的下标;
tuple = ("张三",1,2,3,4,5,6,7,8,9)
print(tuple1.index("张三"))

2.统计数据出现的次数
元组.count(元素)

# 记录数据出现的次数
tuple = ("张三",1,"张三",2,3,4,5,6,7,8,9)
print(f"数据1出现的次数为{tuple.count(1)}")
print(f"数据张三出现的次数为{tuple.count('张三')}")

3.记录元组内的元素个数
len(元组)

# 记录元组内的元素个数
tuple = ("张三",1,"张三",2,3,4,5,6,7,8,9)
print(f"元组的元素个数为{len(tuple)}")

---

4.字符串

---

尽管字符串看起来并不像列表/元组,存储多个数据的容器;

但是字符串同样也是数据容器;

字符串是字符的容器,一个字符串可以存入任意数量的字符;

方法

1.通过下标索引获取字符串中的字符;

#1.通过下标索引获取字符串中的字符;
str1 = "itpython"
print(f"获取第1位字符{str1[0]}")
print(f"获取第2位字符{str1[1]}")
print(f"获取最后1位字符{str1[-1]}")

2.根据索引范围获取字符串中的字符;

# 2.根据索引范围获取字符串中的字符;
str1 = "itpython"
print(f"获取第1位到第4位字符{str1[0:4]}")

3.获取元素的指定位置;

# 3.获取元素的指定位置;
str1 = "itpython"
print(str1.index("p"))
print(f"字符串'yth'的起始位置是:{str1.index('yth')}")

4.字符串的替换

# 4.字符串的替换
# 语法 字符串.replace(旧字符,新字符),将原字符串的所有旧字符替换成新字符,返回新字符串;
# 不是修改,而是得到新的字符串;
str1 = "itpythonpython"
print(str1.replace("p","P"))

5.字符串的分隔;

# 5.字符串的分隔;
# 语法:字符串.split(分隔符),将字符串以指定的分隔符进行分隔,且返回列表;
# 注意:字符串本身不变,而是得到了一个列表对象;
str1 = "itpython,python,java,c,c++"
print(str1.split(","))

6.字符串的规整操作;

# 6.字符串的规整操作;
# 语法1:字符串.strip(),去前后空格,返回一个新的字符串,去除字符串前后的空格;
str1 = "   itpython   "
print(str1.strip())
# 语法2:字符串.strip(字符串),可去除前后的指定字符;
str1 = "111111itpython 111234111"
print(str1.strip("111"))

7.统计字符串中字符出现的次数;

# 7.统计字符串中字符出现的次数;
# 语法:字符串.count(字符),返回字符出现的次数;
str1 = "itpythonpython"
print(f"itpythonpython出现p的次数为:{str1.count('p')}")

8.字符串的长度

# 8.字符串的长度 ;
# 语法:len(字符串),返回字符串的长度;
str1 = "itpython"
print(f"字符串itpython长度为:{len(str1)}")

案例练习

分割字符串

给定字符串 "qweqrqwr wqasd asda lkskdj asdl jgieao 1asd a2e3";

• 统计字符串内有多少个a字符;
• 将字符串中的空格,替换为字符'|';
• 按照'|'进行字符串分割,得到列表;
  (提示:可使用count(),replace(),split()方法)

str1 = "qweqrqwr wqasd asda lkskdj asdl jgieao 1asd a2e3"
# 统计字符串内有多少个a字符;
print(f"字符串中的a字符个数为{str1.count('a')}")
# 将字符串中的空格,替换为字符'|';
print(f"将字符串中的空格,替换为字符'|'后{str1.replace(' ', '|')}")
# 按照'|'进行字符串分割,得到列表;
print(f"按照'|'进行字符串分割,得到列表{str1.split('|')}")

---

5.序列切片

---

序列是指-内容连续,有序且可使用下标索引的一类数据容器;

列表,元组,字符串都是序列

序列的常用操作-切片

序列支持切片,即:列表,元组,字符串,均支持进行切片操作;
切片: 从一个序列中,取出一个子序列;

语法:序列[起始下标:结束下标:步长]

表示从序列中,从指定位置开始,依次取出元素,到指定的位置结束,得到一个新的序列;

• 起始下标表示从何处开始,可以留空,留空视作从头开始,
• 结束下标(不含)表示何处结束,可以留空,留空视作截取到结尾;
• 步长表示,依次取元素之间的间隔;
  • 步长1表示,一个一个地取元素;
  • 步长2表示,每次跳过一个元素取;
  • 步长N表示,每次跳过N-1个元素取;
  • 步长为负数表示,反向取(注意,起始下标和结束下标也要反向标记;

案例练习

# 对list 进行切片,从1开始,4结束,步长为1;
list_demo = [1,2,False,"张三",3,4,5,6,7,8,9,10]
print(f"取出的元素为:{list_demo[1:4]}")

# 对tuple进行切片,从头开始,到最后结束,步长为1;
tuple_demo = (1,2,False,"张三",3,4,5,6,7,8,9,10)
print(f"取出的元素为:{tuple_demo[:]}")

# 对str进行切片,从头开始,到最后结束,步长为2;
str_demo = "hello world asdasdadad sdadw1213 sdads"
print(f"取出的元素为:{str_demo[::2]}")

# 对列表进行切片,从3开始,到1结束,步长为-1;
list_demo = [1,2,False,"张三",3,4,5,6,7,8,9,10]
print(f"取出的元素为:{list_demo[3:1:-1]}")

# 对元组进行切片,从头开始,到尾结束,步长为-2;
tuple_demo = (1,2,False,"张三",3,4,5,6,7,8,9,10)
print(f"取出的元素为:{tuple_demo[::-2]}")

案例练习2

序列切片练习;

对于指定的字符串进行以下操作

• 倒序字符串,然后切片取出;
• 切片取出,然后进行倒序;
• split进行分隔",",然后replace替换"a"为空,再倒序字符串;

str = "awwewqeq,php,hello,world,helloa pythona,ahelloa java,hello c++"

# 1.倒序字符串,然后切片取出一部分;
print(f"倒序字符串,然后切片取出:{str[::-1][4:10]}")
# 2.切片取出,然后进行倒序;
print(f"切片取出,然后进行倒序:{str[4:10][::-1]}")
# 3.split进行分隔",",然后replace替换"a"为空,再倒序字符串;
str1 = str.split(",")
print(str1)
str2 = str1[0].replace("a"," ")
str3 = str2[::-1]
print(f"split进行分隔',',然后replace替换'a'为空,再倒序字符串:{str3}")

---