• python对数据的操作

    切片

    对操作的对象截取其中一部分的操作。字符串、列表、元组都支持切片操作。
    格式：序列名[开始位置的下标：结束位置的下标:步长]

    注意：

    如果不写开始，默认从0下标开始
    不写结束，默认选取到最后
    不写步长，默认从1开始
    如果开始和结尾都不写，表示选取所有

    注意：

    分片操作 只包含位于 起始索引号位置的元素， 不包含位于终止索引号位置的元素;
    同时，起始和终止的意义都是针对于从 左向右的顺序来定义的
    #使用切片获取多个元素
    In [1]: s="abcdefg"
    In [2]: s[0:3]
    Out[2]: 'abc'

    使用步长

    • 步长就是每数几个取一个的意思——（如果步长为2，每数两个取一个）
    • 步长是正数时，是从左向右开始操作
    • 步长是负数时，是从右向左操作

    查找

    find()：检测某个子串是否包含在这个字符中，如果在返回这个子串开始的位置下标，否则返回-1。
    1、语法
    字符串序列.find(子串，开始位置下标，结束位置下标)
    注意：开始和结束下标可以省略，表示在整个字符串序列中查找。
    index(): 检测某个子串是否包含在这个字符中，如果在返回这个子串开始的位置下标，否则报错
    2、语法
    字符串序列.index(子串，开始位置下标，结束位置下标)
    count(): 返回某个子串在字符中出现的次数
    3、语法 
    1. 字符串序列.count(子串，开始位置下标，结束位置下标)
    2.  
    3. name = 'gyq123456'
    4. print(name.find('2',3,6)) #4 不存在返回-1
    5.  
    6. print(name.index('5')) #7    不存在报错
    7.  
    8. print(name.count('2')) #1    返回0

    替换

    replace() 
    1. name = 'my name is gyq gyq gyq'
    2. # 将gyq替换为GG
    3. rename = name.replace('gyq','GG')
    4. print(rename)
    5.  
    6. # 还可以加长替换的数量 默认全部替换
    7. rename = name.replace('gyq','GG',3)
    8. print(rename)

    分割

    split() ——返回一个列表，丢失分隔符 
    1. list = name.split()    #括号选取什么字符作为分隔符
    2. print(list)

    合并

    join() ——合并列表里面的字符串数据为一个大字符串
      
    1. mylist = ['aa','bb','cc']
    2.  
    3. #aa...bb...cc
    4. new_str = '-'.join(mylist)    #连接符'_'可以换成其他任意字符
    5. print(new_str)

    大小写转换

    capitalize(): 将字符串第一个字符转换成大写，其余都是小写 
    1. mystr = "gyq is Bu Ti fou"
    2. print(mystr.capitalize()) #Gyq is bu ti fou
    title(): 将字符串每个单词首字母转换成大写 
    1. mystr = "gyq is tu ti fou"
    2. print(mystr.title())    #Gyq Is U Ti Fou
    lower(): 将字符串中大写转小写 
    1. mystr = "gyQ Is bu ti ASD"
    2.  
    3. print(mystr.lower())    #gyq is bu ti asd
    upper(): 将字符串中小写转大写 
    1. mystr = "gyq is bu ti asd"
    2.  
    3. print(mystr.upper())    #GYQ IS BU TI ASD

    删除空白字符

    lstrip()：删除左侧空白字符 
    1. mystr = " gyq "
    2. print("这是原始的",mystr)
    3. new_str = mystr.lstrip()
    4. print(f"这是删除左侧空白字符的{new_str}")
    rstrip()：删除右侧空白字符
      
    1. new_str1 = mystr.rstrip()
    2. print(f"这是删除左侧空白字符的{new_str1}")

    strip()：删除左右两侧空白字符
      
    1. new_str2 = mystr.strip()
    2. print(f"这是删除左侧空白字符的{new_str2}")

    字符串对齐

    格式：字符串序列. 左或右或居中对其(长度，填充字符) 
    1. mystr = 'hello'
    2.  
    3. mystr.ljust(10,'.')    #左对齐，定义长度，以点填充
    4. 'hello.....'
    5. mystr.rjust(10,'.')    #右对齐，定义长度， 以点填充
    6. '.....hello' 
    7. mystr.center(10,'.')    #居中对其， 定义长度，以点填充
    8. '..hello...'

    判断：

    返回的结果是布尔型数据类型：True或False
    startwith(): 检查字符串 是否以指定子串开头，如果设置开始和结束位置下标，则在指定范围内检查。
    语法
    字符串序列.startswith(子串，开始位置下标，结束位置下标)
      
    1. mystr = "HEeel worlsd and acabnv"
    2.  
    3. print(mystr.startswith('HEeel'))
    endswith(): 检查字符串 是否以指定子串结尾，如果设置开始和结束位置下标，则在指定范围内检查。
    语法
    字符串序列.endswith(子串，开始位置下标，结束位置下标) 
    1. mystr = "HEeel worlsd and acabnv"
    2.  
    3. print(mystr.endswith('v'))
    isalpha(): 判断字符串中是否 都是字母 
    1. print(mystr.isalpha())    #字符串中全部都是字母则返回True。
    2. mystr = "HEeelworlsdandacabnv"
    3. print(mystr.isalpha())
    isdigit(): 判断字符串中是否 都是数字 
    1. print(mystr.isalpha())    #字符串中全部都是数字则返回True。
    2. mystr = "HEeelworlsdandacabnv1"
    3.  
    4. print(mystr.isdigit())
    isalnum(): 判断字符串中都是字母或者数字，也可以是数字和字符组合。 
    1. print(mystr.isalnum())
    2. mystr = "HEeelworlsdandac123abnv"
    3.  
    4. print(mystr.isalnum())
    isspace (): 判断字符串中只包含空白 
    1. print(mystr.isspace())
    2. mystr = " "
    3.  
    4. print(mystr.isspace())

    列表中的函数

    1.语法 
    1. 列表序列.index(数据，开始位置下标，结束位置下标)
    2. index(): 返回指定数据所在位置的下标——如果查找的数据不存在则报错。
    3. name_list = ['TOM','gyq','GGG']
    4. print(name_list.index('TOM'))
    5.  
    6. count(): 统计指定数据在当前列表中出现的次数
    7. name_list = ['TOM','gyq','GGG','TOM','TOM']
    8. print(name_list.count('TOM'))
    9.  
    10. len(): 访问列表长度，即列表中数据的个数
    11. name_list = ['TOM','gyq','GGG','TOM','TOM']
    12. print(len(name_list))

    判断是否存在

    in:  判断指定数据在某个列表序列，如果在返回True, 否则返回False 
    1. name_list = ['Tom','Lily','Rose']
    2.  
    3. print('Tom' in name_list) #True
    4.  
    5. #结果：False
    6. print('gyq' in name_list) #False
    还可以使用 not in:  判断指定数据不在某个列表序列，如果不在在返回True, 否则返回False
      
    1. name_list = ['Tom','List','ROSE']
    2.  
    3. name = input('请输入您要注册的用户名：')
    4.  
    5. if name in name_list:
    6. print("您输入的用户名已存在，请重新输入")
    7. else:
    8. print("用户名可用")
    列表增加数据到结尾——append()
    如果追加的是一个序列，则会将整个序列添加到列表中。 
    1. name_list = ['Tom','Lily','ROSE']
    2.  
    3. print("原始数据",name_list)
    4.  
    5. name_list.append(['xiaoming'])
    6. print("增加数据",name_list)

    列表为可变数据类型

    extend()—如果数据是一个序列，则将这个序列的数据逐一添加到列表中。 
    1. name_list = ['Tom','Lily','ROSE']
    2.  
    3. name_list.extend(['xiaoming','123'])
    4. print("增加数据",name_list)
    insert():指定位置新增数据 
    1. name_list = ['Tom','Lily','ROSE']
    2. name_list.insert(0,['xiaoming','123'])
    3. print("增加数据",name_list)

    删除

    1、语法：
    del 目标
    2、快速体验
        2.1 删除列表 
    1. name_list = ['Tom','Lily','Rose']
    2.  
    3. del name_list #或者del (name_list)
    4. print(name_list) #name 'name_list' is not defined

    3、删除指定的数据

    1. name_list = ['Tom','Lily','Rose']
    2.  
    3. del name_list[0] #或者del (name_list)
    4. print(name_list)

    pop() -- 删除指定下标的数据，如果不指定下标，默认删除最后一个数据

    返回被删除的数据 
    1. name_list = ['Tom','Lily','Rose']
    2.  
    3. del_name=name_list.pop()
    4. print(del_name)

    remove(数据) #括号里面需要添加要删除的数据

    1. name_list = ['Tom','Lily','Rose']
    2.  
    3. name_list.remove('Tom')
    4. print(name_list)

    修改列表数据

    # 1. 修改指定下标是的数据 
    1. name_list = ['Tom','Lily','Rose']
    2.  
    3. # 1.修改指定下标是的数据-先找到下标元素然后重新赋值
    4. name_list[0] = 'aaa'
    5. print(name_list)

    将列表元素逆序显示

    1. # 2.逆序
    2. list = [1,3,2,5,6,8,]
    3. list.reverse()
    4. print(list)

    排序

    sort()

    语法：列表序列.sort(key=None,reverse=False)
    注意：reverse表示排序规则，reverse=True降序，reverse=False升序（默认）
    将列表元素排好序——默认升序排序 
    1. # 3.sort
    2. list = [1,3,2,5,6,8,]
    3. list.sort()
    4. print(list)

    降序——sort(reverse=True)

    1. list = [1,3,2,5,6,8,]
    2. list.sort(reverse=True)
    3. print(list)

    复制

    copy() 
    1. name_list = ['TOM','LILY','ROSE']
    2.  
    3. list1 = name_list.copy()
    4.  
    5. print(list1)
    6. print(name_list)

    列表循环遍历

    while 
    1. list = ['gyq','gyq1','gyq2']
    2.  
    3. i = 0
    4.  
    5. while i < len(list):
    6. print(list[i])
    7. i += 1
    for 
    1. list = ['gyq','gyq1','gyq2']
    2.  
    3. for i in list:
    4. print(i)

    嵌套列表

    1. list = [['gyq','GGG','ggg'],['历经','娜扎','仙女'],['小红','小明','小路']]
    2.  
    3. print(list[0][0]) #list[0]相当于普通列表的序列名

    嵌套案例

    1. import random
    2.  
    3. teachers = ['A','B','C','D','E','F','G','H']
    4. offices = [[],[],[]]
    5.  
    6. for name in teachers:
    7. num = random.randint(0,2)
    8. offices[num].append(name)
    9.  
    10. i = 1
    11.  
    12. for office in offices:
    13. print(f'办公室{i}的人数是{len(office)}，老师分别是：')
    14.  
    15. for name in office:
    16. print(name)
    17.  
    18. i += 1

    元组

    使用场景：存储多个数据，并且不能修改数据。—— 列表可以修改数据 
    1. # 定义多个数据的元组
    2. t1 = (10,20,30)
    3. print(t1)
    4. print(type(t1))
    5.  
    6. # 单个数据的元组
    7. t2 = (1.2,)
    8. print(type(t2))
    9.  
    10. # 如果单个数据的元组不加逗号，则数据类型是它本身
    11. t2 = (1.2)
    12. print(type(t2))
    注意 ： # 如果单个数据的元组不加逗号，则数据类型是它本身
    index()——查找某个数据，如果存在则返回下标，否则报错
      
    1. t = (1,'aa','yy','qq')
    2. print(t.index('aa'))
    count() 统计某个数据在当前元组出现的次数 
    1. t = (1,'aa','yy','qq')
    2. print(t.count('aa'))
    len() 统计元组中数据的个数 
    1. t = (1,'aa','yy','qq')
    2. print(len(t))
    修改元组里的列表数据—— 尽可能不修改元组里的列表数据 
    1. t = ('aa','yy','qq',['cc'])
    2. t[3][0] = 'gyqgyqgyq'
    3. print(t)

  • 相关阅读:
    第一个 Shell 脚本
    java-异常
    初探亚马逊 AI 编程助手 CodeWhisperer
    ansible中常用模块
    剑指 Offer 06. 从尾到头打印链表
    vue2时间处理插件——dayjs
    proteus入门教程
    手把手教你用Nodejs 实现一个简单的 Redis客户端
    雪花雪花雪花
    Mybatis-plus插件的一次完美实践
  • 原文地址：https://blog.csdn.net/gyqailxj/article/details/126671022