定义python中的容器型变量

  • 字符串

    可使用单引号、双引号、三引号定义

    1
    2
    3
    4
    5
    6
    my_str = 'Hello world'
    my_str = "Hello world"
    my_str = """Hello
          world"""  # 使用三引号可定义多行字符串变量
    my_str = '"Hello" "world"'  # 引号必须成对使用，如字符串内有双引号，可使用单引号包裹
    my_str = "'Hello' 'world'"  # 如字符串内有单引号，则使用双引号包裹

  • 列表

    使用中括号[]定义

    列表是有序的

    列表中的元素可以是不同类型

    1
    2
    my_list = []  # 定义一个空列表
    my_list = [1, 0.5, 'a', True]

  • 元组

    使用小括号()定义

    元组是不可修改的

    元组是有序的

    元组中的元素可以是不同类型

    1
    2
    3
    my_tuple = ()
    my_tuple = (1, 0.5, 'a', True, ['A', 'B'])
    my_tuple = (1, )  # 当元组中只有一个元素时，需要加一个逗号

  • 集合

    使用大括号{}定义

    集合是无序的

    集合内的元素不可重复

    集合中的元素可以是不同类型，但是不可存储列表

    1
    2
    my_set = set()  # 不可使用{}定义空集合
    my_set = {1, 0.5, 'a', False}

  • 字典

    使用大括号{}定义，每个元素是一个键值对

    键是唯一的

    可存储任意类型的对象

    1
    2
    my_dict = {}  # 定义一个空字典
    my_dict = {'apple': 5, 'banana': 'yellow'}

容器型变量的常见操作

索引和切片

索引从0开始

切片语法：[start:end:stride]

字符串、列表、元组 可进行切片操作

字符串的常用操作

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
my_str = 'this is a string'
print(len(my_str))  # 统计字符串长度

print(my_str[0:3])  # 默认步长为1
print(my_str[5:])  # 取到最后一个字符
print(my_str[1:-1])  # 取第二个到倒数第二个字符
print(my_str[::-2])  # 从后往前取，步长为2

print(my_str.find('is'))  # 查找指定字符，若存在则返回索引值，若不存在返回-1
print(my_str.find('is', 0, 5))  # 在指定索引范围内(0-5)查找指定字符
print(my_str.rfind('is'))  # 从右端开始查找

print(my_str.index('is', 0, len(my_str)))  # 查找指定字符的索引，若不存在则报错
print(my_str.rindex('is'))  # 从右端开始索引

print(my_str.count('a', 0, len(my_str)))  # 统计指定字符在指定索引范围内出现的次数

print(my_str.replace('a', 'b', 1))  # 替换指定字符，替换不超过`1`次

print(my_str.split('is', 2))  # 以指定字符为分隔符进行切片，分割成`2`个子串
print(my_str.partition('a'))  # 根据指定字符将字符串分割成三部分
print(my_str.rpartition('is'))  # 从右端开始分割

print(my_str.capitalize())  # 字符串首字母大写
print(my_str.title())  # 字符串中每个单词的首字母大写

print(my_str.startswith('this'))  # 判断字符串是否以指定字符开头
print(my_str.endswith('str'))  # 判断字符串是否以指定字符结尾

print(my_str.lower())  # 将所有字符转换为小写
print(my_str.upper())  #将所有字符转换为大写

print(my_str.ljust(20))  # 左对齐，使用空格填充至指定长度
print(my_str.rjust(20))  # 右对齐，使用空格填充至指定长度
print(my_str.center(20))  # 居中对齐，使用空格填充至指定长度

my_str = my_str.center(20)
print(my_str.strip())  # 删除字符串两端的空字符
print(my_str.rstrip())  # 删除字符串右端的空字符
print(my_str.lstrip())  # 删除字符串左端的空字符

print(my_str.splitlines())  # 将字符串按行分隔，返回一个列表

'*'.join(my_str)  # 用*连接my_str中的每一个字符

列表的常用操作

  • 添加元素

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    my_list = ['apple', 'orange', 'banana']
    print(my_list)
    my_list.append('pear')  # 向列表添加元素
    print(my_list)

    my_list_1 = [1, 2, 3]
    my_list.extend(my_list_1)  # 将另一列表中的元素逐一添加到列表
    print(my_list)

    my_list.insert(1, 'a')  # 在指定位置插入元素
    print(my_list)

  • 删除元素

    1
    2
    3
    4
    5
    6
    7
    8
    my_list = ['apple', 'orange', 'banana']
    del my_list[1]  # 删除指定索引位置的元素
    print(my_list)

    print(my_list.pop(), my_list)  # 删除最后一个元素，并返回删除的元素

    my_list.remove('apple')  # 删除指定元素
    print(my_list)

  • 修改元素

    1
    2
    3
    my_list = ['apple', 'orange', 'banana']
    my_list[1] = 'a'
    print(my_list)

  • 查找元素

    1
    2
    3
    my_list = ['apple', 'orange', 'banana']
    print('a' in my_list)
    print('apple' not in my_list)

  • 排序

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    my_list = [1, 4, 2, 8, 5]
    print(my_list)

    my_list.reverse()  # 逆序排列
    print(my_list)

    my_list.sort()  # 由小到大重拍
    print(my_list)

    my_list.sort(reverse=True)  # 由大到小重排
    print(my_list)

  • 遍历

    1
    2
    3
    my_list = ['apple', 'orange', 'banana', 1, 2, 3]
    for i in my_list:
        print(i)

字典的常用操作

  • 添加元素

    1
    2
    3
    4
    my_dict = {'Bob': 78, 'John': 85}
    print(my_dict)
    my_dict['Mary'] = 95
    print(my_dict)

  • 删除元素

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    my_dict = {'Bob': 78, 'John': 85, 'Mary': 95}
    print(my_dict)

    del my_dict['Mary']  # 删除指定键值对
    print(my_dict)

    my_dict.clear()  # 清空字典
    print(my_dict)

    del my_dict  # 删除字典
    print(my_dict)

  • 修改元素

    1
    2
    3
    4
    my_dict = {'Bob': 78, 'John': 85, 'Mary': 95}
    print(my_dict)
    my_dict['John'] = 90
    print(my_dict)

  • 遍历

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    my_dict = {'Bob': 78, 'John': 85, 'Mary': 95}
    for key in my_dict.keys():  # 遍历所有的键
        print(key)

    for value in my_dict.values():  # 遍历所有的值
        print(value)

    for item in my_dict.items():  # 遍历所有的键值对，返回一个个元组
        print(item)

    for k, v in my_dict.items():  # 同时遍历键和值
        print(k, v)

集合的常用操作

  • 对其它容器型变量的去重

    1
    2
    3
    4
    5
    6
    my_list = [1, 2, 5, 3, 2, 8]
    print(my_list)
    my_set = set(my_list)
    print(my_set)
    my_list = list(my_set)
    print(my_list)

  • 遍历和枚举

    1
    2
    3
    4
    5
    6
    my_set = {1, 4, 'a'}
    for value in my_set:
        print(value)

    for index, value in enumerate(my_set):
        print(index, value)