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)
