• 中文
  • 注册
    • 查看作者
    • python(列表,字典,元组,字符串,枚举enumerate)

      一、列表相关知识

      1.1 什么是列表?

      #列表/序列/数组

      #容器类型,一般是用来存储数据

      #列表,可以用来存储各种各样的数据,列表存储的数据有顺序

      #列表数据都有索引 第一条数据的索引为0,以此类推12345.。

      1.2 添加数据

      #1.使用append()函数,向列表中追加数据,会把添加的数据放在列表的最后
      #object:对象,要添加到列表中的数据
      list_1.append('2018-1-23')
      print(list_1)
      #2.使用insert(index,object) 函数,向列表中插入一条数据
      # index 索引 object 要插入的数据 如果超出最大索引,会将数据放在列表最后。若index为负值,位置会从后向前查找,最后一条数据索引为-1
      list_1.insert(4,'oppo')
      print(list_1)
      #3.使用extend()函数,可以将一个可迭代对象的所有数据追加到该列表中
      #extend(iterable)
      #可迭代对象   例如: 列表 字符串 字典 元组
      list_2 =['a','b','c','e','f']
      list_1.extend(list_2)
      print(list_1)

      1.3 修改数据

      #index()函数 可以根据数据,查找数据的索引
      #1.数据 2. 开始搜索的位置3.结束搜索的位置
      #如果数据不在列表中(或不在指定范围),会出现异常错误
      # 'hello' is not in list 原因1:列表中确实没有该元素 原因2:指定的范围没有该元素
      index = list_1.index('oppo',0,5)
      print(index)
      list_1[3] = True
      print(list_1)
      #根据索引修改数据
      list_1[index] = 'vivo'
      print(list_1)

      1.4 删除数据

      #1.根据索引删除数据
      #delete: 删除
      del list_1[4]
      print(list_1)
      # 2.pop(index) 从列表中将数据移出,移出之后列表中就不存在数据了
      # index 可以指定取出数据的索引,如果不指定的话,默认取出最后一条数据
      s = list_1.pop(2)
      print(s)
      print(list_1)
      # 3.remove(object) 根据数据内容 从列表中移除数据
      # object 要删除的数据
      # list.remove(x): x not in list  要删除的数据不在列表中
      # 判断数据是否在列表
      # object in list 如果object在列表中,返回True,不在 返回False
      # object not in list  如果object不在列表中 返回True  在 返回False
      if 'ssss'  in list_1:
          list_1.remove('ssss')
      else:
          print('ssss不在列表中,无法执行删除操作!')
      #4.移除列表中所有的数据
      #clear:清除
      # list_1.clear()
      # print(list_1)

      1.5 查询数据

      # 1.根据索引取出列表中数据,取出之后列表中还有数据
      s = list_1[2]
      print(s)
      print(list_1)
      # 2.使用pop()函数,取出列表中数据,取出之后列表中的数据就会移除
      s = list_1.pop(2)
      print(s)
      print(list_1)
       
      # 3.列表切片,切片之后会得到一个新列表
      # start:stop   包含start 不包含stop
      # start开始位置,一定要小于stop结束位置,否则截取出来就是一个空列表
      result = list_1[3:5]
      print(result)
       
      #[:结束位置]  从第0个位置开始切片,一直到结束位置(不包含结束位置)
      result = list_1[:5]
      print(result)
       
      #[开始位置:] 从开始位置开始切片,知道列表中最后一个元素
      result = list_1[3:]
      print(result)
       
      #开始位置一定要小于结束位置,否则会出现结果为空列表的情况
      result = list_1[4:2]
      print(result)
       
      #填写负值
      result = list_1[-5:-1]
      print(result)
      # 4.取出列表中的所有数据
      # 使用for循环,遍历列表
      # range(start,stop,step)
      # start 范围的开始位置  stop 范围结束的位置  step x的增量 默认为1
      # range范围 包含start 不包含stop
      # 遍历列表:将列表中的所有数据一个一个取出来
      # len() 获取列表中存放的数据个数
      length = len(list_1)
      print('列表中存放数据的个数为:%s' % length)
      for x in range(0, len(list_1)):
          # 把x的值作为索引,取出列表中的数据
          s = list_1[x]
          print(s)
      # 泛型遍历
      for s in list_1:
          print(s)

      1.6 其他函数

      #列表的其他函数
      list_3 = [4,5,11,88,44,33.4,67,28,1,1,1,1,1,1,1,1]
      #sort() 排序函数 默认升序排列
      #指定降序排列
      list_3.sort(reverse=True)
      #默认升序
      # list_3.sort()
      print(list_3)
      #reverse()反向排序
      list_3.reverse()
      print(list_3)
      #count()函数 统计某条数据在列表中出现的次数
      count = list_3.count(1)
      print('出现的次数:', count)

      1.7 自己实现一个count函数

      def COUNT(list_1,object):
          count = 0
          for content in list_1:
              if content == object:
                  count +=1
          return count
          # 如果有返回object在list_1中出现的次数
          # 如果没有 返回0
      list_1 =[1,1,1,2,'hello',False,3.14,'world']
      count = COUNT(list_1,1)
      print(count)

      1.8 自己实现一个index函数

      def INDEX(list_1,object):
          index_list = []
          if object in list_1:
              #enumerate 枚举
              #  拿到之后 一个一个的小元组,小元组中放的是数据索引和数据
              for item in enumerate(list_1):
                  # item[1] 取出小元组中的数据
                  if item[1] == object:
                      # item[0] 数据对应的索引
                      index_list.append(item[0])
              # 如果有元素返回object在list_1中的索引
              # 如果没有返回-1
              return index_list
       
      index_list = INDEX(list_1,1)
      print(index_list)

      二、字典

      2.1 什么是字典?

      # 字典用法
      # 字典:python 中一个内置的容器类,具有增添改查的操作
      # 字典中存储数据的特点
      # 1.字典存数数据 遵循ket:value(键值对)形式进行数据存储,一个key(键)对应一个值(value),使用键来替代列表中的索引,所有的增删改查都是通过key(键)完成的
      # 2.字典中存储的数据是无序的
      # 3. key(键)必须是惟一的,必须是不可变
      # PEP8 编码规范 标点符号后面跟个空白格(空格)
      dict1 = {'name': '张三', 'age': 22, 'phone': 110}
      print(dict1)

      2.2 添加数据

      # 添加数据,如果字典中没有这个key,做添加数据操作
      dict1['sex'] = '男'
      print(dict1)
      #如果字典中有这个key,做修改数据操作
      dict1['sex'] = '女'
      print(dict1)

      2.3 删除数据

      # 1.根据key删除字典中的数据
      del dict1['sex']
      print(dict1)
      #2.使用pop(key)移出字典中对应key的元素
      name = dict1.pop('name')
      print(name)
      # 3.随机从字典中取出一堆键值对,取出的是小元组
      rs = dict1.popitem()
      print(rs)
      #4.清空字典中所有键值对
      # dict1.clear()

      2.4 获取数据

      #1.获取字典中所有的key
      keys = dict1.keys()
      #for 循环遍历key,根据key取出对应的value
      for key in keys:
          value = dict1[key]
       
      #2.获取字典中所有的value值
      values = dict1.values()
      for value in values:
          print(value)
      #3.获取字典中所有key和值(key,value)元组
      items = dict1.items()
      #for 循环遍历items
      for key,value in items:
          print(key,value)
       
      # 4.判断字典中是否拥有某个key
      # python2 直接使用 dict1.has_key(key)  如果key存在,返回True 不存在 返回False
      # python3 使用 key in  dict1.keys 如果存在返回True 不存在 返回False
      # key not in dict1.keys()  如果存在返回False  不存在返回True
      if 'name' in dict1.keys():
          print('字典中有name这个key')
      else:
          print('字典中没有name这个key')

      三、元组

      3.1 什么是元组?

      # 1.tuple元组的用法
      # 元组也是python 内置的一个容器类,
      # 元组中的数据一旦确定就不可更改,不能进行添加、删除、 修改的操作
      # 可以认为元组就是一个不可变的列表(list)
      # 声明元组,如果元组中只有一个元素,在python2 中,必须在元素后添加一个,逗号,python3中可以不用加
      tuple_1 = (3.14,'hello','world',3,4,6,7)
      print(tuple_1)
      # 声明一个元组时,可以省略小括号,这种方式也可以生成一个元祖
      tuple_2 = 1,2,3,4,5,6,7,8
      print(type(tuple_2))

      3.2 获取元组数据

      # 1.根据索引取出元组中的数据
      num = tuple_1[0]
      print(num)
      # 2.元组也支持切片操作,切片之后返回一个新的元组
      result = tuple_1[1:3]
      print(result)
      # 元组支持for循环遍历
      for x in range(0,len(tuple_1)):
          # 把x的值作为索引,取出数据
          content = tuple_1[x]
          print(content)
      # for 循环遍历
      for content in tuple_1:
          print(content)
      # 3.使用枚举
      rs = enumerate(tuple_1)
      # for循环遍历枚举对象
      # for item in rs:
          # print(item)
      for index,value in rs:
          # index就是小元组中的索引,value就是小元组中的数据
          print(index,value)

      3.3 列表元祖嵌套

      # 列表元组嵌套
      list1 = [['张三',22,110],['李四',22,239],(1,2,3),(3,2,1)]
      # 元组嵌套列表,元组不可修改,但是元组中的列表可以进行修改
      tuple1 = (1,2,['张三',22,112],(3,2,1))
      tuple1[2].append('hello')
      print(tuple1)
      # 列表和元组中间可以互相转换
      list2 = [1,2,3,4]
      # 把列表转换为元组
      tuple2 = tuple(list2)
      print(type(tuple2))
      # 把元组转换为列表
      list2 = list(tuple2)
      print(type(list2))

      3.4 其他函数

      # index(x,start,end)查找某个元素在元祖中的位置
      # x 指要查找索引的元素 start 开始查找的位置 end结束查找的位置
      # 查找位置 如果不指定 从开始位置到末尾查找 指定位置从start开始到end之前,不包含end
      index = tuple2.index(3,0,3)
      print(index)
      # count(x)统计某个元素在元祖中出现的次数
      # x 要查找出现次数的元素
      count = tuple2.count(1)
      print(count)

      四、字符串

      4.1字符串用法

      # 字符串的用法
      string1='abcd'
      string2="abcd"
      # ''' '''三个单引号对,声明的字符串,会保留其格式
      string3='''
              1.猜猜看
              2.就不猜
              3.猜不猜
              4.拜拜 
              '''
      print(string3)
      string4="""
              1....
              2....
              3....
              4....
              """
      print(string4)
      print([string4])
      #r'' 原样字符串,不会将字符串中的转义字符进行转义,会原样的输出
      print(r'1\n2')

      4.2 字符串的拼接

      #1. 使用占位符拼接字符串
      a = 100
      b = 200
      # %d 整数占位符,在字符串中,如果只有一个占位符,不需要在后面加(),只需要%变量名,如果有两个以上占位符,就需要将变量放在()小括号中%(a,b)
      string5 = 'a的值为:%d,b的值为:%d'%(a,b)
      print(string5)
      # %f 小数类型占位符
      # %.2f 保留小数点后两位
      a = 1.1111
      b = 2.9999
      string6 = 'a的值为:%.2f,b的值为:%f'%(a,b)
      print(string6)
       
      # %s 通用占位符,字符串、整数、小数、字典、元组、列表。。。都可以使用这个占位符
      list1 = ['张三',22,120]
      print('这个列表的内容为:%s'%list1)
      #2.使用+号,拼接字符串
      name = '张三'
      age = '22'
      phone = '110'
      result = '姓名:' + name + '\n年龄:' + age + '\n手机:' + phone
      print(result)
      #字符串的乘法运算
      name= name * 10
      print(name)
       
      # 3.format()函数 格式化字符串
      string7 = '再过{}天该放假了!'.format(8)
      print(string7)
      # {}大括号中如果不填索引的话,默认从0开始取值,然后依次向后取值
      string8 = '今天是周{2},明天是周{1},后天是周{0}'.format('一','二','三')
      print(string8)
      #{}大括号中内容是后面format中的索引,默认从0开始,依次向后加1,也可以在{}中指定取出的数据索引
      string9 = '姓名:{2} 年龄:{0} 性别:{1} 电话:{3}'.format('22','男','张三','110')
      print(string9)

      4.3 字符串和数字之间的转换

      #字符串和数字之间的转换
      string10 = '1234523456'
      #使用int()把一个纯数字的字符串转换为整数
      # ValueError: invalid literal for int() with base 10: '1234abcd890'
      numbers1 = int(string10)
      print(numbers1)
      print(type(numbers1))
      string11 = '3.1415'
      # 使用float()转换为浮点类型的数据,也要求要转字符串必须为纯数字
      numbers2 = float(string11)
      print(type(numbers2))
      print(numbers2)
      #把float或int转换为字符串
      string12 = str(numbers2)
      print(type(string12))

      4.4 练习

      找到qwer的位置:

      老师的方法:
      string13 = 'dweqgfyufyrqwerhfiahfvjdqwerlvjfdlv'
      #找到qwer的位置,使用find函数,如果找到返回的是小字符串开始的位置,如果没找到返回的是-1
      # sub 要查找位置的字符串 start开始查找的位置 end结束查找的位置
      # index = string13.find('qwer',3,60)
      # print(index)
       
      def FIND(string,sub,start=0,stop=-1):
          '''
          1.for 循环遍历字符串,根据小字符串的长度对大字符串进行截取,并且截取出的字符串必须跟小字符串长度一致
          2.如果截取的字符串和小字符串长度一致,判断俩个字符是否一致,如果一致说明该字符串就是要查找的字符串,直接return x的值(开始位置)
          3.如果for循环执行完毕 meiyoufanhui9一个结果,直接返回-1 表示没找到
          '''
          if stop == -1:
              stop = len(string)
          for x in range(start,stop):
              #x可以作为截取字符串的开始位
              #end= x+len(sub)作为截取的结束位置
              end= x + len(sub)
              #截取字符串
              sub_str = string[x:end]
              #判断字符串是否一致
              if len(sub_str) == len(sub):
                  #如果截取的字符串也等于小字符串,说明找到了
                  if sub_str == sub:
                      print('找到{}的位置为{}'.format(sub,x))
                      return x
              else:
                  break
          #没有找到字符串,返回-1
          return -1
      print(FIND(string13,'qwer'))
      #我的查找qwerde 位置
          # for x in range(0, len(string)):
          #     if string13[x] == 'q':
          #         s = string13[x:x+4]
          #         if s == 'qwer':
          #             print('qwer的位置:',x)

      4.5 其他函数

      list1 = [1,2,3,4,5,6,7]
      #len(列表) 获取列表中存放数据的个数
      print(len(list1))
      string = 'hfwhrfuigbdfhasfgvbahguyweg'
      #len(字符串) 获取字符串的长度
      print(len(string))
      #字符串中的每一个字符都是有索引的 第一个索引为0,第二个为1,以此类推。
      content= string[3]
      print(content)
      #字符串支持切片特性
      rs= string[:4]
      print(rs)
      rs = string[4:8]
      print(rs)
      rs = string[4:]
      print(rs)

      4.6 常用函数

      #1.find(sub,start,end) 查找第一个匹配的子字符串的起始位置
      #sub 要查找的位置的子字符串 start开始位置 end结束查找位置
      #如果找到返回位置,找不到返回-1
      index= string.find('a')
      print(index)
      #2.index() 查找子字符串在大字符串中的位置,如果找到返回起始位置,找不到抛出异常
      # 没有找到 抛出异常:ValueError: substring not found
      ##sub 要查找的位置的子字符串 start开始位置 end结束查找位置
      index =string.index('a')
      #3. count(x,start,end) 函数 统计某个字符串在大字符串中出现的次数
      #x 要查找的次数的字符串 start开始位置 end结束查找位置
      count = string.count('b')
      print(count)
       
      #4.转换大小写
      #upper()把字符串全部转换为大写,会把转换之后的字符串返回
      upper_str = string.upper()
      print(upper_str)
       
      #5,大小写字符全部转化为小写字符
      lower_str = upper_str.lower()
      print(lower_str)
      #6.strip(chars) 去除字符串首尾两端的指定字符,不指定默认去除空格
      #chars 要去除的字符
      string= '\n张\n\n\n\n三\n'
      strip_str = string.strip('\n')
      print(strip_str)
      #7.replace()函数 可以将字符串中的字符进行替换
      #old 要替换的字符串 new替换后的字符串 count替换的次数
      replace_str = strip_str.replace('\n','==',7)
      print(replace_str)
      #8.split(seq,maxsplit) 函数 可以根据指定的字符对字符串进行分割,分割之后得到的是一个列表
      string = '1;2;3;4;5;6;7;8;9'
      #seq 指定的分割字符 maxsplit最大的分割次数 不指定就是全部分割
      rs = string.split(';')
      print(rs)
      #9.join()函数
      #iterable 可迭代对象
      string = '*'.join(rs)
      print(string)
      #10. startswitch()函数  判断某个字符串是否以某个字符串开头
      #如果以某个字符串开头,返回True 否则 返回false
      print(string.startswith('1'))
      #11. endswitch() 判断某个字符串是否以某个字符串结束
      #如果以某个字符串结束,返回true 否则返回false
      print(string.endswith('10'))

      五、枚举enumerate()

      # enumerate 使用场景:对一个列表或者数组既要遍历索引又要遍历元素时使用
      # 例如:
      #     比如:
      # for index,value in enumerate(list):
      #       print index,value
      # 当然也可以
      # for i in range(0,len(list)):
      #       print i,list[i]
      # enumerate 的参数为可遍历的变量,如字符串,列表等;返回值为enumerate类

    • 0
    • 0
    • 0
    • 59
    • 请登录之后再进行评论

      登录
    • 做任务
    • 发表内容
    • 实时动态

    • 关于伊迪派 | 联系我们 | 免责声明 | 侵权投诉 | 小黑屋

      本站资源来源于互联网,仅供个人学习参考研究之用,请于下载后24小时内删除。
      如有侵犯您的权益,可通过邮件(admin@idepy.com)、站内通道等方式反馈,本网站将在第一时间处理。
      Copyright © 2019 - 2020 伊迪派(IDEPY), All Rights Reserved · 粤ICP备12030819号-6 · 粤公网安备 44132202100185号