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

全文目录, 一步到位

  • 1.前言简介
    • 1.1 上文传送
    • 1.2 python专栏传送
    • 1.2 数据容器种类与区别
  • 2. python基础使用
    • 2.1 list列表
      • 2.1.1 列表的定义
        • -> (1) 相同类型(`列表元素`类型)
        • -> (2) 不同类型(`列表元素`类型)
        • -> (3) 嵌套列表(`列表元素`类型)
      • 2.1.2 列表的下标索引
        • -> (1) 单层列表(正向下标)
        • -> (2) 单层列表(反向下标)
        • -> (3) 嵌套列表(正向下标组)
        • -> (4) 嵌套列表(反向下标组)
      • 2.1.3 列表list的常用api
        • ->(1) 查找元素对应的下标 不存在会报错
        • ->(2) 修改元素
        • ->(3) 插入元素
        • ->(4) 追加元素(一个)
        • ->(5) 追加`一堆`元素
        • ->(6) 删除元素(`四种`方式)
        • ->(7) 统计指定元素数量
        • ->(8) 列表的全部元素数量统计
      • ->(9) 循环遍历列表元素
    • 2.2 元组
      • 2.2.1 定义元组
        • -> (1) 正常情况下创建
        • -> (2) 特殊情况
          • 方法一:
          • 方法二:
          • 整体类型查询
      • -> (3) 嵌套元组定义
      • 2.2.2 元组常用api方法
      • -> (1) index() 查找下标
      • -> (2) count() 查询指定元素数量
      • -> (3) len(元素) 查询元组长度
      • 2.2.3 元组循环遍历
        • -> (1) while循环
        • -> (2) for循环
      • 2.2.4 元组可修改的特殊情况
        • -> (1)测试元组是否真的能被修改(`报错`)
        • -> (2) 如果里面放列表是否可修改(`可以`)
    • 2.3 字符串
      • 2.3.1 字符串容器定义
      • 2.3.2 字符串容器常用api
        • ->(1) index() 找到字符串的开始位置
        • ->(2) replace() 字符串替换
        • ->(3) split() 字符串分割
        • ->(4) strip() 字符串规范
        • ->(5) count() 查询出现的次数
        • ->(6) len() 查询字符串长度
  • 3. 基础语法总结案例
    • 3.1 list的基础案例
      • 3.1.1 案例详情
      • 3.1.2 代码实现
  • 4. 文章的总结与预告
    • 4.1 本文总结:
    • 4.2 下文预告:
      • 4.2.0 [传送门: python专栏地址](https://blog.csdn.net/pingzhuyan/category_12403650.html)
      • 4.2.1 基础07-数据容器-(序列切片, 集合,字典)
      • 4.2.2 数据容器的综合案例


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列表

列表元素类型不受限制 (与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))  #  不加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 感谢观看

你可能感兴趣的:(python,python,开发语言,pycharm,idea)