python入门篇06-数据容器(列表 元组 字符串)基础(上)

---

1.前言简介

1.1 上文传送

—⇒传送门: python入门篇04-循环(while与for),变量,函数基础

1.2 python专栏传送

—⇒ 传送门: python基础专栏

1.2 数据容器种类与区别

字典注意一下{k-v}:
key不可以重复 但是value随意
key重复了也不会报错(警告), 而是直接覆盖上个key

容器类型	容器名称	符号	是否修改	是否有序	是否重复
列表	list	[]	是	是	是
集合	set	{}	是	否	否
字符串	str	“”	否	是	是
元组	tuple	()	否	是	是
字典	dict	{“k”:“v”}	是	否	k否 v是

---

2. python基础使用

2.1 list列表<class ‘list’>

列表元素类型不受限制 (与java的list不同,操作也不太相似)

• 列表容量 上限 2**63-1
• 可 储存不同类型的元素
• 数据是有序存储
• 允许重复数据存在
• 可修改

2.1.1 列表的定义

不同列表定义方式介绍:

-> (1) 相同类型(列表元素类型)

lists = ["a", "b", "c"]
print(lists)
# print(type(lists))

-> (2) 不同类型(列表元素类型)

lists = ["a", 1, True]
print(lists)
# print(type(lists))

-> (3) 嵌套列表(列表元素类型)

lists = [["a", 1, True], ["a", 2, False]]
print(lists)
# print(type(lists))

2.1.2 列表的下标索引

根据下标进行搜索及相关操作

-> (1) 单层列表(正向下标)

看异常情况:
print(lists[3]) # Error报错: list index out of rangeIndex
下标超出范围了(java叫数组下标越界)

lists = ["a", "b", "c"]

print(lists[0])
print(lists[1])
print(lists[2])

-> (2) 单层列表(反向下标)

lists = ["a", "b", "c"]

print(lists[-1])
print(lists[-2])
print(lists[-3])

-> (3) 嵌套列表(正向下标组)

lists1 = [["a", "b", "c"], ["1", "2", "3"]]

print(lists1[0][0])  # a
print(lists1[1][1])  # 2
print(lists1[1][2])  # 3

-> (4) 嵌套列表(反向下标组)

lists1 = [["a", "b", "c"], ["1", "2", "3"]]

print(lists1[-1][-1])  # 3
print(lists1[-2][-2])  # b
print(lists1[-2][-3])  # a

2.1.3 列表list的常用api

示例list, 请先创建list 在进行下面操作

lists = ["a", "b", "c"]

->(1) 查找元素对应的下标 不存在会报错

# 查找下表索引 不存在报错
index = lists.index("b")
print(f"b的位置是: {
      
      index}")  # 1

->(2) 修改元素

lists[0] = "a1"
print(lists)

->(3) 插入元素

lists.insert(1, "b1")
print(lists)

->(4) 追加元素(一个)

lists.append("d")
print(lists)

->(5) 追加一堆元素

lists2 = [99, 999, 9999]
lists.extend(lists2)
print(lists)

->(6) 删除元素(四种方式)

# 6.1 仅删除元素(根据下标)
del lists[1]
print(lists)

# 6.2 删除元素(等同于 取出下标元素并返回)
lists.pop(0)
print(lists)

# 6.3 删除元素(根据内容 找到第一个元素 删除) 只删除一个
lists.remove("b")
print(lists)

# 6.4 清空列表
lists.clear()
print(lists)

->(7) 统计指定元素数量

lists = ['a', 'a', 'b', 'b', 'c', 'd', 99, 999, 9999]
print(lists.count("a"))  # 2

->(8) 列表的全部元素数量统计

print(len(lists))

->(9) 循环遍历列表元素

while/for循环遍历输出
定义两个方法

def func_list_while(lists1):
    index = 0
    while index < len(lists1):
        print(lists1[index])
        index += 1


def func_list_for(lists1):
    for index in lists1:
        print(index)

代码测试并输出结果

lists = [1, 2, 3, 4, 5, 6, 7, 8, 9]
func_list_while(lists)
print("上面while循环 下面for循环")
func_list_for(lists)

2.2 元组

首先看看元组与list的区别

• list 列表 是可以修改的 用:[]表示
• 元组 定义后 不可以修改 用: ()表示 tuple()

应用元组场景

• 程序内封装数据,并且不希望被篡改
• 有点类似java的final修饰符修饰的意思

2.2.1 定义元组

-> (1) 正常情况下创建

# 1. 任意类型元素 创建
t1 = (1, "hello", True)
# 2. 空元组定义1
t2 = ()
# 3. 空元组定义2
t3 = tuple()
# 4. 定义一个元素
t4 = tuple("hello")

-> (2) 特殊情况

t6 = ("hello")  

注意: 这里表示的是一个字符串 ,
给出提示: 让删除括号
正确写法如下(两种方法)

方法一:

t5 = tuple("hello")

方法二:

t7 = ("hello",)

整体类型查询

print(type(t4))
print(type(t5))
print(type(t6))  # <class 'str'> 不加tuple就必须加','
print(type(t7))

-> (3) 嵌套元组定义

t8 = ((1, 2, 3), (4, 5, 6))
print(type(t8))
# 输出结果: 6 写法
print(f"嵌套元组下标1,2 的 值是: {
      
      t8[1][2]}")

2.2.2 元组常用api方法

先定义一个t9元组

t9 = (1, 2, 3, 3, 5, 6)

-> (1) index() 查找下标

print(t9.index(2))  # 2元素位置下标是1

-> (2) count() 查询指定元素数量

print(t9.count(3))  # 查看3有几个 2

-> (3) len(元素) 查询元组长度

print(len(t9))  # 查看元组长度 6

2.2.3 元组循环遍历

-> (1) while循环

print("\n上面元组语法基础  下面循环 ")
index = 0
while index < len(t9):
    print(t9[index])
    index += 1

-> (2) for循环

for index in t9:
    print(index)

2.2.4 元组可修改的特殊情况

-> (1)测试元组是否真的能被修改(报错)

t10 = (1, 2, 3, 3, 5, 6)
t10[0] = 999  # TypeError: 'tuple' object does not support item assignment

-> (2) 如果里面放列表是否可修改(可以)

注意: 元组本身不可以修改
但是: 里面元素是列表[], 列表可以修改

t10 = (1, 2, [40, 50, 60])
t10[2][0] = 80
print(t10)  # (1, 2, [80, 50, 60]) 修改成功 元组嵌套的list可修改

2.3 字符串

字符串的容器视角解释

• 支持下标索引
• 字符串 是字符的容器, 一个字符串可以存放任意数量的字符
• 只能存字符串 并且不可修改

2.3.1 字符串容器定义

# 一个字符是一个元素
str1 = "zhangSan is a good boy"

2.3.2 字符串容器常用api

->(1) index() 找到字符串的开始位置

value = str1.index("is")
print(value)  # 9

->(2) replace() 字符串替换

str是不可修改的 会生成一个新的对象

str2 = str1.replace("a", "***")
print(str2)  # zh***ngS***n is *** good boy

->(3) split() 字符串分割

str2 = str1.split(" ")
print(str1)  # zhangSan is a good boy
print(str2)  # ['zhangSan', 'is', 'a', 'good', 'boy']

->(4) strip() 字符串规范

去掉前后空格
strip(元素) 从前到后 去掉空格并删除第一个元素
java是trim()

str0 = " a b c "
print(str0.strip())  # a b c
print(str0.strip("a "))  # b c 去除空格并删除输入的值(从前到后)

->(5) count() 查询出现的次数

str1 = "zhangSan is a good boy"
print(str1.count("o"))  # 3

->(6) len() 查询字符串长度

str1 = "zhangSan is a good boy"
print(len(str1))  # 22

3. 基础语法总结案例

3.1 list的基础案例

3.1.1 案例详情

案例详情

1. 声明一个学生年龄的list
2. 添加一个元素
3. 添加一堆元素
4. 取出一个年龄下标并输出
5. 倒着取出一个年龄下标并输出
6. 查找一个年龄对应的下标 注意报错
7. 输出任意下标的年龄
8. 清空年龄list

3.1.2 代码实现

students_age_list = [10, 20, 30, 31, 31, 20]
print(students_age_list)
students_age_list.append(50)
print(students_age_list)
students_age_list.extend([29, 50, 60])
print(students_age_list)
print(students_age_list.pop(0))
print(students_age_list.pop(-1))
print(students_age_list.index(20))
print(students_age_list[0])
print(students_age_list.clear())  # None

4. 文章的总结与预告

4.1 本文总结:

• 列表list定义 常用操作
• 元组与列表区别 常用操作
• 字符串容器视角常用操作

4.2 下文预告:

4.2.0 传送门: python专栏地址

4.2.1 基础07-数据容器-(序列切片, 集合,字典)

4.2.2 数据容器的综合案例

---

作者pingzhuyan 感谢观看