【Python基础】7.高级数据类型（列表，元组，字典，字符串）

高级变量类型

对python高级变量,需要掌握以下知识点：

• 列表
• 元组
• 字典
• 字符串
• 公共方法

在python中，所有的非数字型变量都有支持以下特点

• 都是一个序列 sequence ,也可以理解为 容器
• 取值 [ ]
• 遍历 for item in xxx
• 计算长度、最大/最小值、比较、删除
• 连接 + ，重复 *(字典不支持重复操作)
• 切片 slice (字典不支持切片操作)

列表

列表的定义

• 列表List是Python中使用最频繁的数据类型，其他编程语言中通常叫做数组
• 专门存储一串数据
• 列表用 [ ] 定义，数据之间使用逗号 , 分割
• 列表的索引（下标）从0开始

name_list = ["ZhangSan","LiSi","WangWu"]

列表的操作

name_list = ["ZhangSan", "LiSi", "WangWu"]
# 1. 取值使用索引获取数据
# 同时需要考虑到下标越界的问题
zhangman_name = name_list[0]
print(zhangman_name)  # 结果 "ZhangSan"
# 使用 index方法需要注意，如果传递的数据不在列表中，程序会报错
print(name_list.index(zhangman_name))  # 结果 0

# 2.修改
name_list[1] = "LiSiGuang"
# name_list[3] = "ZhaoLiu"  # 会抛出下标越界异常

# 3.增加
# append 方法在列表末尾添加数据
name_list.append("ZhaoLiu")
# insert 方法在列表指定索引位置添加数据
name_list.insert(1, "LaoZhang")
# extend 方法将另外一个列表的完整内容追加到当前列表的末尾
ext_list = ["TOM", "JERRY", "MICKY", "NINI", ]
name_list.extend(ext_list)
print(name_list)
# 使用 len() 方法获得列表的长度
print(len(name_list))
# 使用count 方法统计某一数据出现的次数
name_list.count(zhangman_name)

# 4.排序
# 升序排序
name_list.sort()
num_list = [1, 3, 6, 32, 4, 8, 10]
num_list.sort()
# 降序排序
name_list.sort(reverse=True)
num_list.sort(reverse=True)
# 反转
name_list.reverse()
num_list.reverse()

# 5.删除
# remove 可以从列表中删除第一次出现指定的数据
# Remove first occurrence of value.
# Raises ValueError if the value is not present.
name_list.remove(hangman_name)
print(name_list)
# pop 将列表看作一个Stack，默认删除列表中最后一个数据
pop_str = name_list.pop()
print(pop_str)
print(name_list)
# pop 删除指定索引的数据
name_list.pop(3)
# del 关键字（不推荐使用）
# 删除列表元素,本质上是将一个变量从内存中删除
# 如果使用del 关键字，后续代码不能使用这个变量了
del name_list[1]
# clear  清空整个列表
name_list.clear()

extend 方法和 append 方法的区别

1. extend 扩展，是将对象以拆分元素的形式合并到原列表中
2. append 追加，是将对象以一个元素的形式添加到原列表中

Tips:关键字、函数、方法的区别

• 关键字是Python内置的，具有特殊意义的标识符
• 函数封装了独立的功能，可以直接使用
• 方法需要通过对象来调用，表示针对这个对象要做的操作

列表的循环遍历

• 遍历 就是从头到尾，依次从列表中获取数据
• 在python中为了提高列表的遍历效率，提供了迭代iteration遍历
• 使用for关键字实现迭代遍历

# for 循环内部使用的变量 in 列表
for var in 列表：
    ······

name_list = ["ZhangSan", "LiSi", "WangWu"]
ext_list = ["TOM", "JERRY", "MICKY", "NINI"]
name_list.extend(ext_list)
for name in name_list:
    print("My name is %s" % name)

应用场景

• python 列表中，可以存储不同类型的数据
• 但是在一般情况下
  1. 列表存储相同的数据
  2. 通过迭代遍历，逐一获取列表中的数据，执行对应的操作

元组

元组的定义

• 元组Tuple与列表List相似，不同之处在于元素不能修改
• 专门存储一串数据
• 元组用 ( ) 定义，数据之间使用 , 分割
• 元组的索引（下标）从 0 开始

name_tuple = ("ZhangSan",10,175)

创建空元组

temp_tuple = ()
# 空元组只有两个方法
info.count
info.index

元组中只有一个元素的时候，需要在元素后面加 ,
用来区分基础数据类型或字符串

one_tuple = (5,)

元组的操作

info_tuple = ("zhangsan", 18, 175)
# 取值和取索引
print(info_tuple[0])
print(info_tuple.index("zhangsan"))

# 统计
print(info_tuple.count("zhangsan"))
# 统计元组中元素的个数
print(len(info_tuple))

元组的遍历

与列表一致，但实际开发过程中不常遍历元组

元组的应用场景

• 作为函数的参数和返回值，一个函数可以接收任意多个参数，或者一次返回多个数据
• 格式化字符串，格式化字符串%后面的（ ）,本质上就是一个元组
• 将列表转化成元组，可以保护列表数据不被修改

元组和列表之间的相互转换

• 元组转换成列表

list(xx_tuple)
# 举例
info_arr = list(info_tuple)
print(type(info_arr))

• 列表转换成元组

tuple(xx_list)

字典

字典的定义

• 字典 dictionary 是除了列表外，python中常用并最灵活的数据类型
• 字典可以存储多个数据，通常是描述某个对象的相关信息
• 和列表的区别
  1. 列表是有序的对象集合
  2. 字典是无序的对象集合
• 字典用 { } 定义
• 字典用键值对存储数据，键值对之间用,分割
  1. 键 key 为索引
  2. 值 value 为数据
  3. 键 与 值 之间用 ：分割
  4. 键 必须唯一,并且只能是字符串、数字或者元组
  5. 值 可以是任意类型数据

xiaoming = {"name": "xiaoming", 
            "age": 18, 
            "height": 188, 
        "weight": 85}

字典的操作

xiaoming = {"name": "xiaoming", 
            "age": 18, 
            "height": 188, 
        "weight": 85}
# 因为字典是无序的，所以打印输出的内容不一定是定义的内容
print(xiaoming)

# 1.取值
print(xiaoming["name"])
# 在取值的时候，如果指定的key不存在，会有KeyError错误
# 2.修改/增加
xiaoming["name"] = "李晓明"
xiaoming["school"] = "Tsinghua"
# 3.删除
# D. pop(k[,d]) -> v, remove specified key and return the corresponding value.
# If the key is not found, return the default if given; otherwise, raise a KeyError.
xiaoming.pop("name")
# 4.统计键值对的数量
print(len(xiaoming))
# 5.合并字典，相同键值对会被覆盖
score_dict = {"age":20,"math": 100, "chinese": 88, "english": 100}
xiaoming.update(score_dict)
# 6.清空dict
xiaoming.clear()
print(xiaoming)

字典的遍历

for k in xiaoming:
    print("%s %s" % (k, xiaoming[k]))

应用场景

• 字典可以存储多个数据，通常是描述某个对象的相关信息
• 将多个字典值放在一个列表中，进行遍历处理

字符串

字符串的定义

• 字符串就是一串字符，是编程语言中，表示文本的数据类型
• 在Python中，可以使用一对 " ，或者一对 ’ 定义字符串
  • 可以使用转义字符 ’ 或者 " 在字符串中使用引号
  • 如果在字符串中有双引号，可以使用单引号’'来定义字符串

  str = '我喜欢"python"这门编程语言'
  

  • 如果在字符串中有单引号，可以使用双引号’'来定义字符串

  str = "我喜欢'python'这门编程语言"
  

• 可以使用 索引 获取一个字符串中指定位置的字符，索引从 0 开始计数
• 可以使用for循环来获取一个字符串中的单个字符

字符串变量常用的操作

string_init = 'hello, I am a python coder,this is my first "hello python" file'
# 统计字符串的长度
print(len(string_init))
# 获取子字符串出现的次数
# Return the number of non-overlapping occurrences of substring sub in string S[start:end].
# Optional arguments start and end are interpreted as in slice notation.
print(string_init.count("hello"))  # 2
print(string_init.count("java"))  # 0
# 某一个子字符串出现的位置
# Return the lowest index in S where substring sub is found,
# such that sub is contained within S[start:end].
# Optional arguments start and end are interpreted as in slice notation.
# Raises ValueError when the substring is not found.
print(string_init.index("hello"))

字符串常用方法和分类

判断类型

序号	方法	说明
1	isspace()	如果字符串中只包含空格1，则返回True
2	isalnum()	如果字符串至少有一个字符，并且所有字符均为字母或者数字，则返回True
3	isalpha()	如果字符串至少有一个字符，并且所有字符均为字母，则返回True
4	isdecimal()	如果字符串只包含数字，则返回True,全角数字
5	isdigit()	如果字符串只包含数字，则返回True,全角数字、(1)、\u00b2
6	isnumeric()	如果字符串只包含数字，则返回True,全角数字、汉字数字
7	istitle()	如果字符串是标题化的（每个单词的首字母均为大写），则返回True
8	islower()	如果字符串中，至少包含一个区分大小写的字符，并且所有字符都是小写的，则返回True
9	isupper()	如果字符串中，至少包含一个区分大小写的字符，并且所有字符都是大写的，则返回True

# 判断字符串中是否只包含数字
# 以下三种方法均不可判断小数,执行结果均为True
num_str = "1"
print(num_str)
print(num_str.isdecimal())
num_str = "\u00b2"
print(num_str.isdigit())
num_str = "壹万玖仟"
print(num_str.isnumeric())

查找和替换

序号	方法	说明
1	startwith(str)	如果字符串以str开头，则返回True
2	endwith(str)	如果字符串以str结尾，则返回True
3	find(str,start=0,end=len(string))	如果str包含在string中，也可以指定开始检索start和结束检索end的范围，如果包含，返回开始的索引值，否则返回-1
4	rfind(str,start=0,end=len(string))	与find方法类似，但是为倒叙查找
5	index(str,start=0,end=len(string))	与find方法类似，但是str不在string中时会报错
6	rindex(str,start=0,end=len(string))	与index方法类似，但是为倒叙查找
7	replace(old_str,new_str,num=string.count(old))	把string中的old_str替换成new_str,如果num指定，则替换不超过num次

replace_str = "hello python"
# 1.判断replace_str是否以“hello"开始
print(replace_str.startswith("hello "))
# 2.判断是否以指定字符串结束
print(replace_str.endswith(" python"))
# 3.查找指定字符串
print(replace_str.find("llo"))  # 2
print(replace_str.find("abc"))  # -1
# 4.替换字符串
# 会返回一个新的字符串，原有字符串内容不做修改
print(replace_str.replace("python", "Python"))

文本对齐

序号	方法	说明
1	ljust(width)	返回一个原字符串左对齐，并且使用空格填充至长度width的新字符串
2	rjust(width)	返回一个原字符串右对齐，并且使用空格填充至长度width的新字符串
3	center(width)	返回一个原字符串居中对齐，并且使用空格填充至长度width的新字符串

# 新建一个列表，里面存放不爱我就拉倒的部分歌词用于测试
lyrics = ["不爱我就拉倒", 
            "离开之前", 
            "不要爱的抱抱", 
            "反正我又不是没有人要", 
            "哥练的胸肌", 
            "如果你还想靠"]
for lyric in lyrics:
    print(lyric.center(20, "-")) #不足部分使用“-”填充

执行结果如下

-------不爱我就拉倒-------
--------离开之前--------
-------不要爱的抱抱-------
-----反正我又不是没有人要-----
-------哥练的胸肌--------
-------如果你还想靠-------

去除空白字符

序号	方法	说明
1	lstrip()	裁掉字符串左边开始的空白字符串
2	rstrip()	裁掉字符串右边开始的空白字符串
3	strip()	裁掉字符串两边的空白字符串

lyrics = ["\t\n不爱我就拉倒","离开之前","不要爱的抱抱","反正我又不是没有人要","哥练的胸肌","\t\t如果你还想靠"]
for lyric in  lyrics:
    print(lyric.strip())
    print(lyric.strip().center(20,"-"))

执行结果如下

不爱我就拉倒
-------不爱我就拉倒-------
离开之前
--------离开之前--------
不要爱的抱抱
-------不要爱的抱抱-------
反正我又不是没有人要
-----反正我又不是没有人要-----
哥练的胸肌
-------哥练的胸肌--------
如果你还想靠
-------如果你还想靠-------

拆分和连接

序号	方法	说明
1	partition(str)	将字符串切分为一个三元素的元组（str前面,str,str后面）
2	rpartition(str)	partition(str)的翻转执行
3	split(str=“”,num)	以str为分隔符拆分字符串，如果num有指定值，则仅分割num+1个字符串，str默认值包含’\r’、‘\t’、'\n’和空格
3	splitlines()	按照（‘\r’、‘\n’、‘\r\n’）分割，返回一个包含各行作为元素的列表
4	join(seq)	以字符串作为分隔符，将seq中所有的元素（转化为字符串）合并为一个新的字符串

lyrics = "不爱我就拉倒\t \n ,离开之前\r\t,不要爱的抱抱\t,反正我又不是没有人要\n,哥练的胸肌\t,如果你还想靠\t"
# 将原来歌词根据空格转化成列表
lyric_list = lyrics.split()
print(lyric_list)
#" ".join(lyric_list).split(",") 用于将原来歌词中的逗号替换，转化成列表
#" ".join方法将列表转化为字符串并输出
# 此处代码没有实际意义，只作方法调用的演示
result = " ".join(" ".join(lyric_list).split(","))
print(result)

运行结果如下

['不爱我就拉倒', ',离开之前', ',不要爱的抱抱', ',反正我又不是没有人要', ',哥练的胸肌', ',如果你还想靠']
不爱我就拉倒  离开之前  不要爱的抱抱  反正我又不是没有人要  哥练的胸肌  如果你还想靠

切片 slice

• 切片方法适用于字符串、列表、元组
  • 切片使用索引值来限定范围，用于在给定字符串中获取切出的小字符串
  • 列表和元组都是一个有序集合，能够通过索引值获取数据
  • 字典是一个无序集合，无法使用切片方法

目标字符串 = 源字符串[开始索引:结束索引:步长]

注意

• 切片操作遵循左闭右开原则，即 开始索引<=目标范围<结束索引
• 从头开始，开始索引 数字 可以省略，: 不可以省略
• 到末尾结束，结束索引 数字 可以省略，: 不可以省略
• 步长默认为1，使用默认步长时，数字和冒号都可以省略
• 步长为正，代表从左往右，步长为负，代表从右往左

num_str = ("abcdefghijklmnopqrstuvwxyz")
# 1.截取从2~5的字符串
print(num_str[2:6])
# 2.截取从2到末尾的字符串
print(num_str[2:])
# 3.截取从开始到f的字符串
print(num_str[:6])
# 4.截取完整的字符串
print(num_str[:])
# 5.从开始位置，每隔一个字符截取字符串
print(num_str[::2])
# 6.从索引1开始，每隔一个取一个
print(num_str[1::2])
# 7.截取从2~末尾-1的字符串
print(num_str[2:-1:])
# 8.截取字符串末尾两个字符
print(num_str[-2:])
# 9.字符串的逆序输出
print(num_str[::-1])

公共方法

Python包含了以下内置函数：

序号	方法	说明	备注
1	len(item)	计算容器中的个数	如果是字典，则计算键值对的个数
2	del(item)	删除变量	del有两种方式，既是关键字，也是函数 del item 和 del(item) 作用一致
3	max(item)	返回容器中的最大值	如果是字典，只针对key值作比较
4	min(item)	返回容器中的最小值	如果是字典，只针对key值作比较
5	cmp(item1,item2)	比较两个值，小于为-1，等于为0，大于为1	Python3.x已经取消这个函数,使用比较运算符进行比较，字典不能进行比较

比较函数是使用字符的ascii值进行比较，即’0’<‘A’<‘a’

for 循环的完全体

for item in item：
    todo()
else:
    # 如果没有遇到break,那么就会执行当前语句
    if_not_break()

list_num = [1, 2, 3]
for num in list_num:
    print(num)
else:
    list_num.extend([4, 5])
list_num.append([6, 7])
print(list_num)

执行结果如下：

1
2
3
[1, 2, 3, 4, 5, [6, 7]]

应用场景

• 在迭代遍历嵌套数据类型时，例如列表中存放字典数据
• 如果希望在搜索列表时，遍历后未找到对应的数据，需要对这种情况做统一处理时，就可以用到for-else循环

---

1. 也可能是\t ,\n 这样的转义字符 ↩︎