python 数据类型

字符串

定义

# 1. 使用 单引号 定义
str1 = 'hello'
# 2. 使用 双引号 定义
str2 = "hello"
# 3. 使用 三引号 定义
str3 = """hello"""
str4 = '''hello'''

下标（索引）

下标从0开始，逆序从-1开始

str1 = 'abcdefg'
# 需求: 打印输出字符串中的 a 字符
print(str1[0])
print(str1[-7])
# 需求: 打印输出字符串中 最后一个字符(-1)
print(str1[-1])
# 需求: 打印输出 下标为 3 的位置的字符
print(str1[3])

切片

切取字符串中的某一段，str[start, end, step]，开头start，结尾end不包含，步长（间隔）step

my_str = 'abcdefg'
print(my_str[0:3:1]) # abc
# 如果步长是 1, 可以省略不写
print(my_str[0:3]) # abc
# 如果 start 开始位置的下标为 0, 可以不写,但是冒号不能少
print(my_str[:3]) # abc
print(my_str[4: 7]) # efg
print(my_str[4:]) # efg
print(my_str[::2]) # aceg
# 步长为-1，反转字符串
print(my_str[::-1]) # gfedcba

字符串查找方法 find()

在字符串中查找某些字符。如果存在，返回其第一次出现的下标；如果不存在，返回 -1

str_name = 'hello,world!hello'
result_llo = str_name.find('llo')
result_ab = str_name.find('ab')
print(result_llo) # 2
print(result_ab) # -1

字符串的替换 replace()

字符串.replace(old, new, count)　　# 将字符串中的 old 字符串 替换为 new 字符串

• old：原字符串，被替换的字符串
• new：新字符串，要替换为的字符串
• count：一般不写，默认表示全部替换；可以指定替换的次数
• 返回：会返回一个替换后的完整的字符串
• 注意：原字符串不会改变的

my_str = 'good good study'

# 需求, 将 good 变为 GOOD
my_str1 = my_str.replace('good', 'GOOD')
print(my_str) # good good study
print(my_str1) # GOOD GOOD study

# 将第一个 good 替换为 Good
my_str2 = my_str.replace('good', 'Good', 1)
print(my_str2) # Good good study

# 将第二个 good 替换为 Good
# 先整体替换为 Good, 再将替换后的 第一个Good 替换为 good
my_str3 = my_str.replace('good', 'Good').replace('Good', 'good', 1)
print(my_str3) # good Good study

字符串拆分 split()

字符串.split(sep)　　# 将字符串按照指定的字符串 sep 进行分隔

• sep：按照 sep 分隔，可以不写，默认按照空白字符(空格 \t \n)分隔
• 返回：列表，列表中的每个数据就是分隔后的字符串

str1 = 'hello Python\tand itcast and\nitheima'
# 1. 默认 按照 空白字符 分隔
list1 = str1.split()
print(list1) # ['hello', 'Python', 'and', 'itcast', 'and', 'itheima']
# 2. 按照 空格 分隔
list2 = str1.split(' ')
print(list2) # ['hello', 'Python\tand', 'itcast', 'and\nitheima']
# 3. 按照 and 分隔
list3 = str1.split('and')
print(list3) # ['hello Python\t', ' itcast ', '\nitheima']

字符串的连接 join()

字符串.join(容器)　　# 容器一般是列表，将字符串插入到列表相邻的两个数据之间，组成新的字符串

注意点：列表中的数据 必须都是字符串才可以

list1 = ['hello', 'Python', 'and', 'itcast', 'and', 'itheima']
# 将 列表中数据使用 空格 组成新的字符串
str1 = ' '.join(list1)
print(str1) # hello Python and itcast and itheima
# 使用 逗号 连接
str2 = ','.join(list1)
print(str2) # hello,Python,and,itcast,and,itheima
# 使用 _*_ 连接
str3 = '_*_'.join(list1)
print(str3) # hello_*_Python_*_and_*_itcast_*_and_*_itheima

 列表 list

定义

• 列表 list，使用 [ ]
• 列表可以存放任意多个数据
• 列表中可以存放任意类型的数据
• 列表中数据之间使用 逗号 隔开

# 方式1, 使用类实例化的方式
# 1.1 定义空列表 变量 = list()
list1 = list()
# 1.2 定义非空列表
# 将容器中的 每个数据 都作为列表中一个数据进行保存
list2 = list('abcd')
print(list2) # ['a', 'b', 'c', 'd']

# 方式2, 直接使用 [] 进行定义(使用较多)
# 2.1 定义空列表
list3 = []
# 2.2 定义非空列表
list4 = [1, 3.14, 'hello', False]

下标和切片

列表的切片得到是 新的列表；字符串的切片得到是 新的字符串

如果下标不存在，会报错

list4 = [1, 3.14, 'hello', False]
# 获取 列表中 第一个数据
print(list4[0]) # 1
# 获取列表中最后一个数据
print(list4[-1]) # False
# 获取中间两个数据即 3.14 和 'hello' (1 和 2)
print(list4[1: 3]) # [3.14, 'hello']

列表查询 index()、count()

index() 方法

• 这个方法的作用和 字符串中的 find() 的作用是一样
• 列表中是没有 find() 方法的，只有 index() 方法。字符串中同时存在 find() 和 index() 方法
• 找到，返回下标
• 没有找到，无返回结果

count() 方法

列表.count(数据)　　# 统计 指定数据在列表中出现的次数

list1 = ['hello', 2, 3, 2, 3, 4]
# 查找 2 第一次出现的下标
num = list1.index(2)
print(num) # 1
# 统计数据 3 出现的次数
num1 = list1.count(3)
print(num1) # 2
# 统计数据 20 出现的次数
num2 = list1.count(20)
print(num2) # 0

添加数据 append()  [重点]

• 列表.append(数据)　　# 向列表的尾部添加数据
• 返回：None，所以不用使用 变量 = 列表.append()
• 直接在原列表尾部添加数据，不会生成新的列表，如果想要查看添加后的数据，直接 print() 打印原列表

删除数据 pop()

• 列表.pop(index)　　# 根据下标删除列表中的数据
• index 下标可以不写，默认删除列表最后一个
• 返回：删除的数据

# 定义空列表
list1 = []
# 添加数据
list1.append('张三')
print(list1)    # ['张三']
# 添加数据
list1.append('李四')
print(list1)    # ['张三', '李四']
list1.append('王五')
list1.append('赵六')
print(list1)    # ['张三', '李四', '王五', '赵六']
# 删除最后一个数据
list1.pop()
print(list1)    # ['张三', '李四', '王五']
# 删除第二个数据，即下标 1
name = list1.pop(1)
print('删除的对象为:', name)  # 删除的对象为: 李四
print(list1)    #['张三', '王五']

修改数据

• 想要修改列表中的数据，直接是所有下标即可
• 列表[下标] = 新数据

my_list = [1, 2]
my_list[0] = 10
print(my_list)  # [10, 2]
my_list[-1] = 200
print(my_list)  # [10, 200]

列表的反转 reverse()

• 字符串 反转 字符串[::-1]
• 列表 反转
  • 列表[::-1]　得到一个新的列表, 原列表不会改动

• • 列表.reverse()　直接修改原列表的数据

my_list = ['a', 'b', 'c', 'd', 'e']
my_list1 = my_list[::-1]
print('my_list1:', my_list1)    # my_list : ['e', 'd', 'c', 'b', 'a']
print('my_list :', my_list)     # my_list : ['a', 'b', 'c', 'd', 'e']
# 对原列表反转
my_list.reverse()
print('my_list :', my_list)  # my_list : ['e', 'd', 'c', 'b', 'a']

列表的排序 sort()

• 前提：列表中的数据类型要一样
• 列表.sort()　　# 默认 升序，从小到大，直接在原列表中进行排序
• 列表.sort(reverse=True)　　# 降序，从大到下，直接在原列表中进行排序

my_list = [1, 4, 7, 2, 5, 8, 3, 6, 9]
# 排序 升序
my_list.sort()
print(my_list)    # [1, 2, 3, 4, 5, 6, 7, 8, 9]
# 降序
my_list.sort(reverse=True)
print(my_list)    # [9, 8, 7, 6, 5, 4, 3, 2, 1]

列表的嵌套

# 列表的嵌套 就是指 列表中数据都是列表
student_list = [["张三", "18", "功能测试"], ["李四", "20", "自动化测试"], ["王五", "21", "自动化测试"]]

print(student_list[0][0])    # 张三
print(student_list[1][0])    # 李四
# 张三 的信息添加一个 性别 男 ---> 向张三所在的列表 添加数据
student_list[0].append('男')
print(student_list[0])    # ["张三", "18", "功能测试", "男"]
# 删除 性别
student_list[0].pop()
print(student_list[0])
# 打印 所有人员的年龄
for i in student_list:
    print(i[1])

元组 tuple

定义

• 元组 tuple, 使用 ()
• 元组和列表非常相似, 都可以存储多个数据, 都可以存储任意类型的数据
• 区别就是 元组中的数据不能修改，列表中可以修改
• 因为元组中的数据不能修改，所以只能 查询方法，如 index, count，支持下标和切片
• 元组，主要用于传参和返回值

# 定义空元组
tuple1 = ()
# 非空元组
tuple2 = (1, 2, 'hello', 3.14, True)

# 根据 下标 查询
print(tuple2[2])    # hello

# 定义只有一个数据的元组, 数据后必须有一个逗号
tuple3 = (10)
print(type(tuple3))     # <class 'int'>
tuple4 = (10,)
print(type(tuple4))     # <class 'tuple'>
print(tuple4)   # (10,)

组包、解包、交换

• 1, 在定义元组的时候, 小括号可以省略不写
• 2, 组包(pack)，将多个数据值组成元组的过程 a = 1, 2 # a = (1, 2)
• 3, 拆包(解包 unpack)，将容器中多个数据 分别给到多个变量，需要保证容器中元素的个数和变量的个数保持一致

a = 10
b = 20
# 组包
c = b, a
print(c)   # (20, 10)
# 拆包
e, f = c
print(e, f)    # 20 10
x, y, z = 'abc'
print(y)    # b
# 交换
a, b = b, a
print(a, b)    # 20 10

字典 dict

定义

• 1, 字典 dict, 使用 {} 表示
• 2, 字典是由 键值对 组成的，key: value
• 3, 一个键值对是一组数据，多个键值对之间使用 逗号 隔开
• 4, 在一个字典中, 字典的键是不能重复的
• 5, 字典中的键 主要使用 字符串类型, 可以是数字
• 6, 字典中没有下标

# 1, 类实例化的方式
my_dict1 = dict()
print(type(my_dict1), my_dict1)    # <class 'dict'> {}
# 2, 直接使用 {} 定义
# 定义空字典
my_dict2 = {}
# 定义非空字典
my_dict = {"name": "小明", "age": 18, "height": 1.78, "isMen": True}

增加和修改

• 字典['键'] = 值
• # 1, 键 存在，修改
• # 2, 键 不存在，添加

# 定义非空字典, 姓名, 年龄, 身高, 性别
my_dict = {"name": "小明", "age": 18, "height": 1.78, "isMen": True}
print(my_dict)    # {'name': '小明', 'age': 18, 'height': 1.78, 'isMen': True}
# 将年龄改为 20
my_dict['age'] = 20
print(my_dict)    # {'name': '小明', 'age': 20, 'height': 1.78, 'isMen': True}
# 添加 体重 weight
my_dict['weight'] = 65
print(my_dict)    # {'name': '小明', 'age': 20, 'height': 1.78, 'isMen': True, 'weight': 65}

删除 pop('key')

根据 ‘键’ 删除 键值对

my_dict = {'name': '小明', 'age': 20, 'height': 1.78, 'isMen': True, 'weight': 65}
my_dict.pop('weight')
print(my_dict)    # {'name': '小明', 'age': 20, 'height': 1.78, 'isMen': True}

查询 get('key')

根据字典的 键，获取对应的 值

• 1，字典['key']　  # 键不存在，会报错
• 2，字典.get('key')    # 键不存在，返回 None

my_dict = {'name': '小明', 'age': 20}
# 获取 name 值
print(my_dict['name'])    # 小明
print(my_dict.get('name'))    # 小明
# 获取 性别 sex
# print(my_dict['sex']) # 会报错, 因为 键不存在
print(my_dict.get('sex'))     # None

遍历 keys()、values()、items()

遍历键 keys()

# 方式一
for 变量 in 字典:
    print(变量)
# 方式二
# 字典.keys() 可以获取字典中所有的 键
for 变量 in 字典.keys():
    print(变量)

 示例：

my_dict = {'name': '小明', 'age': 18, 'sex': '男'}
# 方式一
for k in my_dict:
    print(k)
# 方式二
for k in my_dict.keys():
    print(k)

遍历值 values()

# 字典.values() 可以获取字典中所有的 值
for 变量 in 字典.values():
    print(变量)

示例：

my_dict = {'name': '小明', 'age': 18, 'sex': '男'}
for v in my_dict.values():
    print(v)

遍历键值对 items()

# 变量1 就是键, 变量2 就是值
# 字典.items() 获取的是字典的 键值对
for 变量1, 变量2 in 字典.items():
    print(变量1, 变量2)

 示例：

my_dict = {'name': '小明', 'age': 18, 'sex': '男'}for k, v in my_dict.items():
    print(k, v)