07 字符串和常用的数据结构

字符串和常用的数据结构

  1. 字符串

    • 字符串的表示

      #字符串的表示
      s1 = 'hello, world!'
      s2 = "hello, world!"
      # 以三个双引号或单引号开头的字符串可以折行
      s3 = """
      hello, 
      world!
      """
      print(s1, s2, s3, end='')
      
      #转义字符
      s1 = '\'hello, world!\''
      s2 = '\n\\hello, world!\\\n'
      print(s1, s2, end='')
      
      #八进制和十六进制的表示
      s1 = '\141\142\143\x61\x62\x63'
      s2 = '\u9a86\u660a'
      print(s1, s2)
      
      #要不想转义,前面添加r
      s1 = r'\'hello, world!\''
      s2 = r'\n\\hello, world!\\\n'
      print(s1, s2, end='')
      
      
    • 字符串的运算

      s1 = 'hello ' * 3
      print(s1) # hello hello hello 
      s2 = 'world'
      s1 += s2
      print(s1) # hello hello hello world
      print('ll' in s1) # True
      print('good' in s1) # False
      str2 = 'abc123456'
      # 从字符串中取出指定位置的字符(下标运算)
      print(str2[2]) # c
      # 字符串切片(从指定的开始索引到指定的结束索引)
      print(str2[2:5]) # c12
      print(str2[2:]) # c123456
      print(str2[2::2]) # c246
      print(str2[::2]) # ac246
      print(str2[::-1]) # 654321cba,回文
      print(str2[-3:-1]) # 45
      
    • 字符串的处理

      #字符串的处理
      str1 = 'hello, world!'
      # 通过内置函数len计算字符串的长度
      print(len(str1)) # 13
      # 获得字符串首字母大写的拷贝
      print(str1.capitalize()) # Hello, world!
      # 获得字符串每个单词首字母大写的拷贝
      print(str1.title()) # Hello, World!
      # 获得字符串变大写后的拷贝
      print(str1.upper()) # HELLO, WORLD!
      # 从字符串中查找子串所在位置
      print(str1.find('or')) # 8
      print(str1.find('shit')) # -1
      # 与find类似但找不到子串时会引发异常
      # print(str1.index('or'))
      # print(str1.index('shit'))
      # 检查字符串是否以指定的字符串开头
      print(str1.startswith('He')) # False
      print(str1.startswith('hel')) # True
      # 检查字符串是否以指定的字符串结尾
      print(str1.endswith('!')) # True
      # 将字符串以指定的宽度居中并在两侧填充指定的字符
      print(str1.center(50, '*'))
      # 将字符串以指定的宽度靠右放置左侧填充指定的字符
      print(str1.rjust(50, ' '))
      str2 = 'abc123456'
      # 检查字符串是否由数字构成
      print(str2.isdigit())  # False
      # 检查字符串是否以字母构成
      print(str2.isalpha())  # False
      # 检查字符串是否以数字和字母构成
      print(str2.isalnum())  # True
      str3 = '  jackfrued@126.com '
      print(str3)
      # 获得字符串修剪左右两侧空格之后的拷贝
      print(str3.strip())
      
  2. 列表

    • 列表的遍历

      #列表的遍历
      # 通过循环用下标遍历列表元素
      for index in range(len(list1)):
          print(list1[index])
      # 通过for循环遍历列表元素
      for elem in list1:
          print(elem)
      # 通过enumerate函数处理列表之后再遍历可以同时获得元素索引和值
      for index, elem in enumerate(list1):
          print(index, elem)
      
    • 列表的操作

      #列表的操作
      list1 = [1, 3, 5, 7, 100]
      # 添加元素
      list1.append(200)#append是最后加上
      list1.insert(1, 400)#insert是在1的位置加上400
      #合并列表
      list1.extend([1000, 2000])
      list1 += [1000, 2000]
      # 先通过成员运算判断元素是否在列表中,如果存在就删除该元素
      if 3 in list1:
      	list1.remove(3)
      # 从指定的位置删除元素
      list1.pop(0)
      # 清空列表元素
      list1.clear()
      fruits = ['grape', 'apple', 'strawberry', 'waxberry']
      fruits += ['pitaya', 'pear', 'mango']
      # 列表切片
      fruits2 = fruits[1:4]
      print(fruits2) # apple strawberry waxberry
      # 可以通过完整切片操作来复制列表
      fruits3 = fruits[:]
      print(fruits3) # ['grape', 'apple', 'strawberry', 'waxberry', 'pitaya', 'pear', 'mango']
      fruits4 = fruits[-3:-1]
      print(fruits4) # ['pitaya', 'pear']
      # 可以通过反向切片操作来获得倒转后的列表的拷贝
      fruits5 = fruits[::-1]
      print(fruits5) # ['mango', 'pear', 'pitaya', 'waxberry', 'strawberry', 'apple', 'grape']
      
    • 列表的排序

      #列表的排序
      list1 = ['orange', 'apple', 'zoo', 'internationalization', 'blueberry']
      list2 = sorted(list1)
      # sorted函数返回列表排序后的拷贝不会修改传入的列表
      # 函数的设计就应该像sorted函数一样尽可能不产生副作用
      list3 = sorted(list1, reverse=True)
      # 通过key关键字参数指定根据字符串长度进行排序而不是默认的字母表顺序
      list4 = sorted(list1, key=len)
      print(list1)
      print(list2)
      print(list3)
      print(list4)
      # 给列表对象发出排序消息直接在列表对象上进行排序
      list1.sort(reverse=True)
      print(list1)
      
  3. 生成式/生成器/迭代器

    • 列表生成式、集合生成式、字典生成式

      # [结果 for循环 条件]
      [i for i in range(1,11) if i >5]
      #[三元运算 for循环 条件]
      [i if i>5 else '哈哈' for i in range(1,11) if i>1 if i>5]
      #两个for循环
      [em for i in range(3) for em in range(2)]
      
      #集合生成式
      {i for i in range(1,11)}
      
      #字典生成式
      {i:i for i in range(1,11)}
      
    • 迭代器

      可迭代对象是指具有__iter__()方法的对象,包括列表、字符串、字典等
      #迭代器
      list=[1,2,3,4]
      new_list=list.__iter__()
      #1
      print(new_list.next())
      #2
      print(new_list.next())
      
      #迭代器的优点
      节省空间--惰性机制
      #迭代器的缺点
      一次性、不可逆
      
      #for循环、文件的open的本质都是迭代器
      s="alex"
      #s=open('info','r',encoding='utf-8')
      s1=s.__iter__()
      #s1.__iter__()没有变化,因此迭代器可以被for循环循环
      while True:
        try:
          print(s1.next())
        except StopIteration:
          break
      
    • 生成器

      '''
      生成器本质就是一个迭代器:节省空间
      '''
      #定义生成器
      
      #基于函数
      def fun():
        print(123)
        yield 1 #将值返回,并记录位置
        print(456)
        yield 2
        
      g=fun()
      #next和yield数量要对应
      print(g.next())
      print(g.next())
      
      #下面的写法是无限的,每次都生成一个生成器
      print(fun().next())
      print(fun().next())
      print(fun().next())
      
      #加上循环生成器
      def fun():
        list=[]
        for i in range(10):
          list.append(i)
          yield list
      def fun2():
        list=[i for i in range(10000)]
        for i in list:
          yield i
        #yield from list:这是将可迭代对象逐个返回
      
      
  4. 元组

    占用空间小,不可修改

  5. 集合

    #创建一个集合
    set1={1,2,3,3,3,2}
    #往集合里面加元素
    set1.add(4)
    #往集合中添加多个元素
    set1.update([11, 12])
    #删除元素
    set1.discard(1)
    if 4 in set1:
        set1.remove(4)
        
    #集合的运算
    # 集合的交集、并集、差集、对称差运算
    print(set1 & set2)
    # print(set1.intersection(set2))
    print(set1 | set2)
    # print(set1.union(set2))
    print(set1 - set2)
    # print(set1.difference(set2))
    print(set1 ^ set2)
    # print(set1.symmetric_difference(set2))
    # 判断子集和超集
    print(set2 <= set1)
    # print(set2.issubset(set1))
    print(set3 <= set1)
    # print(set3.issubset(set1))
    print(set1 >= set2)
    # print(set1.issuperset(set2))
    print(set1 >= set3)
    # print(set1.issuperset(set3))
    
  6. 字典

    # 创建字典
    scores = {'骆昊': 95, '白元芳': 78, '狄仁杰': 82}
    item1=dict(one=1,two=2,three=3,four=4)
    item2=dict(zip(['a','b','c'],'123'))
    item3={num:num**2 for num in range(1,10)}
    #输出字典
    for key in scores:
    	print(f'{key}:{scores[key]}')
    for key,value in enumerate(scores):
    	print(f'{key}:{value}')
    #字典的更新
    scores['白元芳'] = 65
    scores['诸葛王朗'] = 71
    scores.update(冷面=67, 方启鹤=85)
    #get方法用来取值,没有的可以设定返回值
    if '武则天' in scores:
        print(scores['武则天'])
    print(scores.get('武则天',60))
    #删除项目
    print(scores.popitem())
    #弹出项目,返回value,可以设定默认值
    print(scores.pop('w',100))
    
  7. 脚本小练习

    • 在屏幕上跑马灯文字

      import time
      import os
      
      sentenc1='北京欢迎你'
      while True:
          os.system('cls')
          print(sentenc1)
          time.sleep(0.2)
          sentenc1=sentenc1[1:]+sentenc1[0]
      
    • 设计一个函数返回给定文件名的后缀

      import time
      import os
      
      sentenc1='北京欢迎你'
      while True:
          os.system('cls')
          print(sentenc1)
          time.sleep(0.2)
          sentenc1=sentenc1[1:]+sentenc1[0]
      
    • 设计一个函数返回传入的列表最大和第二大的元素的值

    • 随机产生验证码的函数

      import random
      def yanzhengma(num):
          '''
      
          :param num:验证码长度
          :return: 验证码
          '''
          letter_num='0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'
          #['','','','']
          list1=random.sample(letter_num,num)
          str1=''
          for i in list1:
              str1+=i
          return str1
      
      print(yanzhengma(10))
      
    • 设计一个函数返回传入的列表中最大和第二大的元素的值

      def max_min(list1):
          list2=sorted(list1,reverse=True)
          return list2[0],list2[1]
      print(max_min([2,3,5,7,1,8,9]))
      
    • 设计函数计算指定日期是这年的多少天

      def days(year,month,day):
          month_day=0
          months=[31,28,31,30,31,30,31,31,30,31,30,31]
          if (year%4==0 or year%400==0) and year%100!=0:
              months[1]=29
          for i in range(month):
              month_day+=months[i]
          days=month_day+day
          return print(days)
      
      days(1996,6,26)
      
    • 打印杨辉三角

      #制造空列表的方法是[None]*3,就会得到[None,None,None]
      #同理[[]]*3,得到[[],[],[]]
      def yanghui_tri(num):
          '''
      
          :param num:杨辉三角的层数
          :return: 杨辉三角
          '''
          list1=[[]]*num
          for i in range(num):
              list1[i]=[None]*(i+1)
              for j in range(i+1):
                  if j == 0 or j== i:
                      list1[i][j]=1
                  else:
                      list1[i][j]=list1[i-1][j-1]+list1[i-1][j]
                  print(list1[i][j],end='\t')
              print()
      
      if __name__ == '__main__':
          yanghui_tri(8)
      
    • 双色球选号

      from random import sample,randint
      
      def random_select():
          '''
          双色球选号
          :return:[a,b]
          '''
          red_balls=[x for x in range(1,34)]
          selected_balls=sample(red_balls,6)
          selected_balls.sort()
          selected_balls.append(randint(1,16))
          return selected_balls
      
      def show_balls(selected_balls):
          for i in range(len(selected_balls)):
              if i == len(selected_balls)-1:
                  print('|',end='')
              print(selected_balls[i],end=' ')
      
      if __name__ == '__main__':
          for i in range(10):
              show_balls(random_select())
              print()
      
    • 约瑟夫环问题

      """
      《幸运的基督徒》
      有15个基督徒和15个非基督徒在海上遇险,为了能让一部分人活下来不得不将其中15个人扔到海里面去,有个人想了个办法就是大家围成一个圈,由某个人开始从1报数,报到9的人就扔到海里面,他后面的人接着从1开始报数,报到9的人继续扔到海里面,直到扔掉15个人。由于上帝的保佑,15个基督徒都幸免于难,问这些人最开始是怎么站的,哪些位置是基督徒哪些位置是非基督徒。
      """
      duilie=[True]*30
      # print(duilie)
      #计数
      count=0
      dead_man=0
      while dead_man<15:
          for index,person in enumerate(duilie):
              if person:
                  count+=1
              if count==9:
                  duilie[index]=False
                  dead_man += 1
                  count=0
      for i in range(len(duilie)):
          if duilie[i]:
              duilie[i]='基督徒'
          else:
              duilie[i]='普通人'
      
      print(duilie)
      
      
    • 井字棋游戏

      from random import sample
      def print_board(board):
          print(board['TL'] + '|' + board['TM'] + '|' + board['TR'])
          print('-+-+-')
          print(board['ML'] + '|' + board['MM'] + '|' + board['MR'])
          print('-+-+-')
          print(board['BL'] + '|' + board['BM'] + '|' + board['BR'])
      
      def main():
          list1=[]
          counter=0
          init_board={'TL':' ','TM':' ','TR':' ',
                      'ML':' ','MM':' ','MR':' ',
                      'BL':' ','BM':' ','BR':' '}
          print_board(init_board)
          current_board = init_board.copy()
          while counter<9:
              person=input('请你落子:')
              current_board[person]='*'
              counter+=1
              print_board(current_board)
              #电脑下
              for key,value in current_board.items():
                  if value ==' ':
                      list1.append(key)
              computer=sample(list1,1)
              current_board[computer[0]]='o'
              counter+=1
              print_board(current_board)
              list1.clear()
      if __name__ == '__main__':
          main()
      
上一篇:Python 实现杨辉三角


下一篇:python数据类型