devbox
不正经
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

python 入门笔记[语法基础(下)]_l.append

作者：不正经 | 2024-03-07 23:17:22

赞

踩

l.append

前言：这部分是基本语法的重点，也是py入门的一小步而已

前瞻篇


目录

 1. 列表修改查找元素

  1. 修改查找元素   对列表的主要操作是增删改查
  2. a=[1,2,3,4,5,6]
  3. print(a.index(5))  输出4，表示5在这个列表中，第一次出现的下标为4，
  4. 对于index方法而言，如果要查找的元素在列表中出现了多次，就显示第一次出现的下标，并且查找时要保证查找元素在列表中，否则会报错
  5. value=a[1]
  6. print(value)
  7. print(a.count(2))# count 方法表示查找指定元素出现次数，与index方法不同的是，如果要查找的元素没有出现则输出零，不会报错
  8. 一个小技巧
  9. e.g a=["周一","周二","周三","周四","周六","周五","周日"]
  10. #很明显列表中周六和周五位置反了，我们现在要交换它们
  11. a[4],a[5]=a[5],a[4] #这样操作即可，和C语言表达有所差别
  12. 赋值也可这样
  13. a,b,c=1,2,3
  14. s="周一,周二,周三,周四,周六,周五,周日"
  15. a=s.split(",")
  16. print(a)# 形成的a是一个列表，这样就实现了字符串转列表
  17. #我们还可以将列表转成字符串
  18. a1="*".join(a) #前面可填连接的填充物，不填则“”，注意使用join方法必须保证a列表中所有元素是同一类型
  19. print(a1)


 2. 增添 删除元素

  1. 增加元素
  2. a=[1,2,3,4]
  3. a.append(5)#往列表末尾加入指定元素，但要注意只能支持尾插一个元素
  4. a.insert(3,2.45) #insert方法两个参数，第一个是插入的位置，第二个是插入的内容，插入成功后原来位置及以后的元素往后移动，
  5. 此外第一个参数也可以超过列表长度-1，这样的话系统默认插在尾部，比如-x,x>列表长度，就相当插在头部
  6. a.extend([5,6,7])#表示在尾部追加一个新列表[5,6,7]
  7. 比如b=[5,6,7]  a.extend(b)这样表达也行
  8. 也可以追加字符串s例如
  9. s="hello"
  10. a.extend(s)#此时尾部追加的是字符串被拆分开来的各个元素 输出结果[1, 2, 3, 4, 'h', 'e', 'l', 'l', 'o']
  11. 可以这样 ，如果不想这样想将hello作为一个独立元素插入到列表中
  12. a.extend([s])#输出[1, 2, 3, 4, 'hello']
  13. print(a)


 3. 元组简介

  1. 元组（Tuple）简介
  2. 元组和列表一样也是一种有序容器
  3. 也使用下标索引元素
  4. 也可以截取
  5. 但它是不可变类型
  6. a=(1,2,3)
  7. print(type(a))#<class 'tuple'>
  8. 但元组中只有一个元素是应这样表达
  9. b=1，
  10. 或b=(1,)#注意和b=(1)区分，后者系统会将括号看作是优先级的提高
  11. 以下是一些元组的常规操作：
  12. a1=a*3
  13. print(a1)
  14. print(len(a1))
  15. print(4 in a1)
  16. print(max(a))
  17. print(min(a))
  18. print(a1.count(3))
  19. 分别输出：
  20. (1, 2, 3, 1, 2, 3, 1, 2, 3)
  21. 9
  22. False
  23. 3
  24. 1
  25. 3
  26. 但是不允许a[x]=xx,a.append(),a.remove()之类操作
  27. 此外元组支持这种赋值操作
  28. t=(1,2,3)
  29. a,b,c=t
  30. print(f"t={t},a={a},b={b},c={c}")
  31. #输出：t=(1, 2, 3),a=1,b=2,c=3
  32. 回顾以前初学时两个变量赋值操作：
  33. a,b=b,a
  34. 对于列表类似有：
  35. t[0],t[1]=t[1],t[0]
  36. print(t)
  37. 但元组不支持这种操作


 4. 列表嵌套

  1. 列表嵌套
  2. 列表List中可以存放任意类型的元素
  3. 整型 小数 bool值 也可以是列表类型 相当于一个大箱子放几个小箱子
  4. e.g
  5. stu1=["小明",95]
  6. stu2=["小红",86]
  7. stu3=["小王",68]
  8. stu=[stu1,stu2,stu3]#[['小明', 95], ['小红', 86], ['小王', 68]]
  9. 或这样声明：：
  10. stu=[
  11.     ["小明",95],
  12.     ["小红",86],
  13.     ["小王",68]
  14. ]
  15. print(stu)
  16. print(stu[0][0])#小明
  17. print(f"{stu[0][0]}的分数为：{stu[0][1]}")#小明的分数为：95


 5. 列表简单练习

  1. 列表练习
  2. 1.创建一个有10个元素的列表，值是[30,31,30,31...]
  3. l=[30,31]*5
  4. 2.将下标为0的元素删除
  5. l.pop(0)
  6. 3.将下标为1的元素值改为28
  7. l[1]=28
  8. 4.在下标为7的位置插入一个元素31
  9. l.insert(7,31)
  10. 5.在列表末尾追加2个元素：30,31
  11. l.extend([30,31])
  12. 最终结果应该是[31,28,31,30,31,30,31,31,30,31,30,31]
  13. print(l)#[31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
  14. 提示用户输入一个1~12之间的整数值表示月份，然后在控制台显示用户输入的这个月份有多少天
  15. 比如用户输入的数是7，就显示“7 月份有 31 天”
  16. month=input("请输入一个1~12之间的整数值表示月份：")
  17. month=int(month)
  18. print(f"{month} 月份有 {l[month-1]} 天")
  19. 此题也可以用if elif语句


 6. Range方法

  1. Range方法
  2. l=list(range(x)) 表示生成从0开始到x-1的连续列表
  3. range(end)生成0-end之间的整数，不包含end
  4. range(start,end)生成start-end之间的整数，不包含end
  5. range(start,end,step)生成start-end之间的整数，不包含end,并且每隔step个数字生成一个数字
  6. l=list(range(1,101))
  7. t=tuple(l)
  8. print(f"l的类型是： {type(l)}\n{l}")
  9. print(f"t的类型是： {type(t)}\n{t}")
  10. l的类型是： <class 'list'>
  11. [1, 2, 3, 4, 5, 6, 7, 8, 9, ....,100]
  12. t的类型是： <class 'tuple'>
  13. (1, 2, 3, 4, 5, 6, 7, 8, 9, ....)
  14. l=list(range(1,100,2))#表示1-100的所有奇数


 7. 列表遍历

  1. 列表遍历
  2. 遍历：依次取出每个元素
  3. for...in..
  4. for item in l:
  5.     print(item)
  6. 元组，字符串，range()都可以使用for遍历
  7. l=list(range(101))
  8. for item in l:
  9.     print(item)#依次输出1-100
  10.     l=list(range(101))
  11. for item in "Python":
  12.     print(item)#依次输出P y t h o n


 8. For循环& For练习

  1. for 练习
  2. 1.提示用户输入5个数，组成一个列表
  3. l=[]
  4. for i in range(5):
  5.     num=input(f"请输入第{i+1}个数：")
  6.     num=int(num)
  7.     l.append(num)
  8. print(f"输入的五个数是：{l}")
  9. 输出：
  10. 请输入第1个数：1
  11. 请输入第2个数：2
  12. 请输入第3个数：3
  13. 请输入第4个数：4
  14. 请输入第5个数：5
  15. 输入的五个数是：[1, 2, 3, 4, 5]
  16. 将列表中各个元素的值*2
  17. for i in range(len(l)):
  18.     l[i]*=2
  19. print(f"各个元素的值*2组成的新列表：{l}")
  20. 计算新列表中所有元素的和
  21. sum=0
  22. for i in range(len(l)):
  23.     sum+=l[i]
  24. print(f"这个新列表中所有元素和为：{sum}")
  25. 2.找出100以内所有7的倍数以及包含7的数，将它们放在一个列表中
  26. l=[]
  27. for i in range(101):
  28.     if i%7==0:
  29.         l.append(i)
  30.     else:
  31.         temp=i
  32.         while(temp):
  33.             k=temp%10
  34.             if(k==7):
  35.                 l.append(i)
  36.                 break
  37.             temp/=10
  38. print(f"满足条件的元素放在列表{l}")
  39. 满足条件的元素放在列表[0, 7, 14, 17, 21, 27, 28, 35, 37, 42, 47, 49, 56, 57, 63, 67, 70, 77, 84, 87, 91, 97, 98]


 9. While循环 

  1. while循环
  2. 最简单的例子：
  3. i=0
  4. while i<10:
  5.     print("balabala")
  6.     i+=1
  7. l=[]
  8. i=''
  9. while  i!='q':
  10.     i=input("请输入待办事项（扣q退出）：")
  11.     l.append(i)
  12. l.pop()
  13. print(l)
  14. 或这样声明：
  15. while  1:
  16.     i=input("请输入待办事项（扣q退出）：")
  17.     if i=='q':
  18.         break
  19.     l.append(i)
  20. print(l)
  21. Python和C系列语言的一个重要区别：
  22. for i in range(4):
  23. 系统不能容忍你空循环，会报错，这点和C语言完全不同，但是我们如果只想留着这个循环（比如日后再添加啥的），需要这样做：
  24.     pass #可以保证代码完整性


 10. 列表推导式

  1. 列表推导式
  2. 列表推导式可以快速构建新的数据序列
  3. [表达式 for 变量 in 列表]
  4. [表达式 for 变量 in 列表 if 筛选条件]
  5. l1=[1,2,3,4,5]
  6. l2=[i*2 for i in l1]#输出[2, 4, 6, 8, 10] i*2是联系l1和l2之间的关系式，即l2中每一个元素是l1中每一个对应元素的2倍
  7. l2=[i for i in range(10)if not i%2 ]#输出[0, 2, 4, 6, 8]
  8. 也可以这样转换列表中的数据类型：
  9. l2=[str(i) for i in range(10)]#输出['0', '1', '2', '3', '4', '5', '6', '7', '8', '9']
  10. print(l2)
  11. 由于字符串也是一种序列结构，我们也可以遍历字符串
  12. l=[i for i in 'hello']#输出['h', 'e', 'l', 'l', 'o']
  13. l=[i.upper() for i in 'hello']#输出['H', 'E', 'L', 'L', 'O']
  14. l=[i.upper() for i in 'hello' if i!='h']#输出['E', 'L', 'L', 'O']
  15. print(l)


 11. 推导式练习

  1. 推导式练习
  2. 1.获取['Food','Moon','Loop']中每个元素的首字母，并将这三个首字母组成一个新的字符串
  3. l=['Food','Moon','Loop']
  4. l1=[i[0] for i in l]
  5. print(l1)
  6. s=''.join(l1)
  7. print(s)
  8. 运行结果：
  9. ['F', 'M', 'L']
  10. FML
  11. 2.找出同时出现在l1和l2中的元素
  12. l1=[2,4,6,8,10,12]
  13. l2=[3,6,9,12]
  14. l=[i for i in l1 if i in l2]
  15. print(l) #输出：[6, 12]
  16. 3.将[1,3,5,7,9]中所有元素打印在控制台上
  17. l3=[1,3,5,7,9]
  18. 解一：[print(i) for i in l3]
  19. 输出：
  20. 1
  21. 3
  22. 5
  23. 7
  24. 9
  25. 解二：
  26. for i in l3:
  27.     print(i)


 12. 循环嵌套

  1.  
  2. 循环嵌套
  3. 最简单的例子：
  4. for i in range(3):
  5.     for j in range(5):
  6.         print(f"i={i},j={j}")
  7. i=0,j=0 i=0,j=1 i=0,j=2 i=0,j=3 i=0,j=4 i=1,j=0 i=1,j=1 i=1,j=2 i=1,j=3 i=1,j=4
  8. i=2,j=0 i=2,j=1 i=2,j=2 i=2,j=3 i=2,j=4
  9. 创建二维列表
  10. l=[]
  11. for i in range(3):
  12.     item=[]
  13.     l.append(item)
  14.     for j in range(5):
  15.         item.append(j)
  16. print(l)#[[0, 1, 2, 3, 4], [0, 1, 2, 3, 4], [0, 1, 2, 3, 4]]
  17. #二维列表元素查找：
  18. for i in l:
  19.     for j in i:
  20.         print(j)#结果就是依次输出
  21. # 套路就是一层套一层
  22. #以上两种都可以用列表推导式各一行解决：
  23. l1=[[j for j in range(5)]for i in range(3)]
  24. print(l1)#[[0, 1, 2, 3, 4], [0, 1, 2, 3, 4], [0, 1, 2, 3, 4]]
  25. [[print(j) for j in i]for i in l]#0 1 2 3 4 0 1 2 3 4 0 1 2 3 4


 13. 循环练习

  1. 循环练习
  2. 1.找到100-1000内最小的水仙花数（水仙花数：每位上数字的3次幂之和等于本身）
  3. for i in range(100,1001):
  4.     a=i%10
  5.     b=i//10%10
  6.     c=i//100%10
  7.     if a**3+b**3+c**3==i:
  8.         print(f"{i}是100-1000内水仙花数")
  9. 输出：
  10. 153是100-1000内水仙花数
  11. 370是100-1000内水仙花数
  12. 371是100-1000内水仙花数
  13. 407是100-1000内水仙花数
  14.  
  15. 2.找出100以内的所有质数存放在列表中：
  16. l=[]
  17. for i in range(2,101):
  18.     is_prime=True
  19.     j=2
  20.     while(j*j<=i):
  21.         if i%j==0:
  22.             is_prime=False
  23.         j+=1
  24.     if(is_prime):
  25.         l.append(i)
  26. print(l)#[2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97]
  27.  
  28. 3.打印九九乘法表
  29. for i in range(1,10):
  30.     for j in range(1,10):
  31.         print(f"{i}*{j}={i*j:2d}",end=' ')#格式注意：隔一个空格，一个数字一行，并保证最终结果对齐,我们用：{i*j:2d}
  32.     print("")
  33. 1*1= 1 1*2= 2 1*3= 3 1*4= 4 1*5= 5 1*6= 6 1*7= 7 1*8= 8 1*9= 9
  34. 2*1= 2 2*2= 4 2*3= 6 2*4= 8 2*5=10 2*6=12 2*7=14 2*8=16 2*9=18
  35. 3*1= 3 3*2= 6 3*3= 9 3*4=12 3*5=15 3*6=18 3*7=21 3*8=24 3*9=27
  36. 4*1= 4 4*2= 8 4*3=12 4*4=16 4*5=20 4*6=24 4*7=28 4*8=32 4*9=36
  37. 5*1= 5 5*2=10 5*3=15 5*4=20 5*5=25 5*6=30 5*7=35 5*8=40 5*9=45
  38. 6*1= 6 6*2=12 6*3=18 6*4=24 6*5=30 6*6=36 6*7=42 6*8=48 6*9=54
  39. 7*1= 7 7*2=14 7*3=21 7*4=28 7*5=35 7*6=42 7*7=49 7*8=56 7*9=63
  40. 8*1= 8 8*2=16 8*3=24 8*4=32 8*5=40 8*6=48 8*7=56 8*8=64 8*9=72
  41. 9*1= 9 9*2=18 9*3=27 9*4=36 9*5=45 9*6=54 9*7=63 9*8=72 9*9=81


 14. 字典基础

  1. 字典基础 可变容器类型 以键值对方式存储 key——value 字典中的键必须是唯一的不能重复
  2. d={}
  3. print(d,type(d))#{} <class 'dict'>
  4. d={"北京":22,"上海":24}#正常声明
  5. d={"北京":22,"北京":24} #错误声明
  6. 字典中的键必须是不可变类型 # l=[0,1,2] a={l:22} 错误
  7. 查 print(d["北京"])#输出22
  8. 改 d["北京"]=20 
  9. 增 d["广州"]=23
  10. 删 d.pop("北京") 可以用变量来接收  
  11. value=d.pop("北京")
  12. value=key("北京")
  13. 查找字典某一键对应的值并不依赖所谓下标而是通过键来查找，因此在字典中并不存在所谓先后顺序之分
  14. 如果一次想往字典中添加多个元素，可以使用update方法
  15. d.update({"xx":"xx"}) #{'北京': 22, '上海': 24, 'xx': 'xx'}
  16. 如果update方法中要增添元素是已有的，那么顺带更新了所对应的值（即为update中的新值
  17. print(d)
  18. v=d.pop("aa",-1)
  19. print(v)#第二个参数意思是如果要删除的第一个参数不在字典中将第二个参数赋值给v 输出v=-1
  20. 同样的操作还有以下两种变式
  21. name=d.get("aa",-1)#第二个参数意思是如果要获取的第一个参数不在字典中将第二个参数赋值给name 输出name=-1
  22. 这样有什么好处？ 好处在于：如果要查找键不在字典中，程序运行不会崩溃
  23. 更进一步，我们还有：
  24. name=d.setdefault("aa",-1)#第二个参数意思是如果要删除的第一个参数不在字典中将第二个参数赋值给name 输出name=-1
  25. 且在字典中添加一个新的键值对：“aa”:-1#输出：{'北京': 22, '上海': 24, 'aa': -1}
  26. print(d)
  27. d.clear()
  28. print(d)#输出{}
  29. 可以将整个字典作为一个大字符串来看，有以下一种用法：
  30. print("aaa"+str(d))#输出：aaa{'北京': 22, '上海': 24}
  31. 可以判断某个键在不在该字典：
  32. print("aa"in d)#输出False，要注意这第一个参数“aa”只能是键
  33. 字典的初始化可以分行来写：
  34. c={
  35.     "aa":1,
  36.     "bb":2
  37. }#输出：{'aa': 1, 'bb': 2}
  38. print(c)
  39. 注意：之前说过列表的键一定是不可变类型，所以不能以列表作为字典的键，但是可以列表作为字典的值


 15. 字典遍历

  1. 字典遍历
  2. 可迭代对象的概念：允许每次只获取一个元素，可以用for遍历
  3. s=dict(a=1,b=2,c=3)
  4. for i in s:
  5.     print(f"key={i},value={s[i]}")
  6. 输出：
  7. key=a,value=1
  8. key=b,value=2
  9. key=c,value=3
  10. 还有以下三种方式：
  11. for i in s.keys():
  12.     print(f"key={i}")
  13. 输出：
  14. key=a
  15. key=b
  16. key=c
  17. for i in s.values():
  18.     print(f"value={i}")
  19. 输出：
  20. value=1
  21. value=2
  22. value=3
  23. #以上两种方式i表示s的key和s的value
  24. 第三种遍历方法：
  25. for k,v in s.items():
  26.     print(f"key={k},value={v}")
  27. 输出：
  28. key=a,value=1
  29. key=b,value=2
  30. key=c,value=3
  31. l=list(s.keys())
  32. print(l)
  33. t=tuple(s.values())
  34. print(t)
  35. 输出：
  36. ['a', 'b', 'c']
  37. (1, 2, 3)
  38. 字典和列表或字典嵌套的实例：
  39. s=dict(a=[1,2,3],b={"1":100,"2":200},c=3)
  40. print(s)#{'a': [1, 2, 3], 'b': {'1': 100, '2': 200}, 'c': 3}
  41. print(s["b"]["1"]) #输出100
  42. print(s["a"][2]) #输出3
  43. 注意：第一个下标是列表或字典的话要用""或''
  44. 第二个下标：
  45. 如果是列表的下标，则不用单引号或双引号
  46. 字典的话则要用
  47. 可参看我举的两个例子

最后献上全部源码

  1. import math
  2.  
  3.  
  4. # my_string="hello world!"
  5. # print(int (len(my_string)))  #输出字符串长度
  6. # index=my_string.find("888")
  7. # print(int (index))  #如果子串在原串中匹配，返回原串中子串第一个字符的下标，找不到系统则报错
  8. # c=my_string.count("l")
  9. # print(c)  #记录找到子串的次数，如果没出现则为零
  10. # new_string=my_string.replace("ello","*") #两个参数，第一个是要变换的字符，第二个是要换上去的字符
  11. # print(new_string)
  12. # print("h"in my_string) #in 可表示某个字符串是否包含在原串中，返回值为布尔值true false
  13. # print("h" not in my_string)  #同样还有not in
  14. # my_string="123,456,789"
  15. # sub_my_string=my_string.split(",")
  16. # print(sub_my_string) #split 意为分割，括号内参数含义是分割标志 sub_my_string=["123","456","789"],为列表类型
  17.  
  18.  
  19.  
  20. # F-String(python 3.6+)
  21. # name ='老王'
  22. # age=18
  23. # result="你好"+name+","+"你今年已经"+str(age)+"岁了！"
  24. # result=f"你好{name}，你今年已经{age}岁了！"  #python3.6版本以上才可使用
  25.  
  26. # format()
  27. # result="你好{0}，你今年已经{1}岁了！".format(name,age)
  28.  
  29. # %(已弃用)
  30. # result="你好%s,你今年已经%d岁了！" %(name,age)
  31. # [(填充)对齐] [符号] [宽度] [.精度] [类型] <左对齐，>右对齐,^ 居中对齐 
  32. # pi=255
  33. # 表示成百分制形式
  34. # result=f"圆周率{pi:#x}是一个无限不循环小数"
  35. # 表示成其他进制的数值
  36. # print(result)
  37.  
  38. #关系运算 结果为bool值
  39. '''
  40. a=1
  41. result=a==6
  42. print(result)
  43. '''
  44. #print(12=="12")
  45. # print('a'>'A')
  46. # 0 1 2 .....<A B C ......Z<a b c d ..... z
  47.  
  48.  
  49. #print(True or False)
  50. # print(not 2>1)
  51.  
  52. '''
  53. html="""
  54. <html>
  55. <head>
  56. </head>
  57. </html>"""
  58. print(html)
  59. '''
  60.  
  61. '''
  62. 优先级 
  63. 1.**
  64. 2.* / % //
  65. 3.+ -
  66. 4.> < >= <= == !=
  67. 5.and or not
  68. 6.=
  70. '''
  71.  
  72. #result= 1 + 2**2 * 3>=12 - 4 / 2 and 'Apple' >= 'Car' 
  73. #print(result)
  74. # false
  75.  
  76.  #  if  语句练习
  77. '''
  78. 要求实现，用户从终端输入一个数并接收，判断是不是偶数
  79. '''
  80. '''
  81. num=(input("请输入一个整数："))
  82. num=int (num)
  83. if num%2==0 :
  84.     print(f"你输入的数是{num}，它是一个偶数")
  85.     if num % 3 ==0 :
  86.         print(f"{num}还可以被3整除！")
  87.     else :
  88.      print(f"{num}不可以被3整除。")      
  89. else:
  90.     print(f"你输入的数是{num}，它是一个奇数")
  91. print("End")
  92. '''
  93.  
  94. # elif 语句练习
  95. # score=input("请输入分数(0-100)")
  96. # if  score.isdigit():  #判断字符串是否由数字构成，如果是，则返回true  else false
  97. #     score=int(score)
  98.  
  99. #     根据分数确定等级
  100. #     100 S
  101. #     90-99 A
  102. #     80-89 B
  103. #     70-79 C     
  104. #     60-69 D  
  105. #     0-60  E  
  106.  
  107. #     if 0<=score<=100:
  108. #         if score==100 :
  109. #             print("S")
  110. #         elif score>=90:
  111. #             print("A")
  112. #         elif score>=80:
  113. #             print("B")
  114. #         elif score>=70:
  115. #             print("C")
  116. #         elif score>=60:
  117. #             print("D")
  118. #         else:
  119. #             print("E")
  120. # else:
  121. #     print("你输入有误！")
  122.  
  123.  
  124. # #提示用户输入一个月份，判断这一年是不是闰年
  125. # year=input("请输入一个有效的年份：")
  126. # if year.isdigit():
  127. #     year=int(year)
  128. #     if(year%400==0 or(year%4==0 and year%100)):
  129. #         print(f"{year}是闰年！")
  130. #     else :
  131. #         print(f"{year}是平年！")
  132.  
  133. # #提示用户输入一个1-99999之间的整数，依次显示这个数各个数位上的数值(从小到大)
  134. # num=input("请输入一个有效的数字：")
  135. # if num.isdigit():
  136. #     num=int(num)
  137. #     while(num):
  138. #         print(num%10)
  139. #         num//=10
  140.  
  141.  
  142. #设计一个剪刀石头布的猜拳游戏
  143. # 1-石头
  144. # 2-剪刀
  145. # 3-布
  146. # import random #生成随机数
  147. # system_number=random.randint(1,3)
  148. # user_number=input("请输入一个有效数值：\n1.剪刀\n2.石头\n3.布")
  149. # user_number=int(user_number)
  150. # if(user_number==system_number):
  151. #     print(f"system_number是{system_number},your number是{user_number},平局")
  152. # else:
  153. #     if((user_number>system_number and  not (system_number==1 and user_number==3))or (system_number==3 and user_number==1)):
  154. #         print(f"system_number是{system_number},your number是{user_number},you win!")
  155. #     else :
  156. #         print(f"system_number是{system_number},your number是{user_number},you lose!")
  157.  
  158.  
  159. # a=[] #空列表，列表是python中最基础的数据结构
  160. # 列表下标从零开始，使用下标获取元素 my_list[x]
  161. # 也支持负数下标  my_list[-1]
  162. # 可以使用[start:end:step]对列表进行截取 my_list[1:4:1]表示对列表从一到四截取，步长为一
  163. # b=[1,3.14,"h",True] #布尔值True首字母要大写，False 同理
  164. # print(type(b))  #<class "list">
  165. # 明白字符串和列表的一个重大区别：字符串不可变，不支持修改操作，列表却能
  166. # eg.
  167. # c="hello"
  168. # c[0]="k"# 错误，字符串是不可变类型
  169. # b[0]="hi"
  170. # print(b) #控制台输出['hi', 3.14, 'h', True]
  171. # 倒序输出列表和倒序输出字符串的方法一样
  172. # print(b[::-1])
  173.  
  174. # a=[1,2,3,4]
  175. # if 5 in a:
  176. #     print(f"{a}里包含这个元素")
  177. # else:
  178. #     print(f"{a}里没有这个元素")
  179. # 列表中最后一个元素的正数下标：列表长度-1
  180. # count=len(a)
  181. # print(count)
  182. # b=["a","b","c"]  #列表合并操作
  183. # new_list=a+b
  184. # print(new_list)
  185. # c=a*3
  186. # print(c) #输出[1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4]
  187. # 列表反转操作：两种方法 
  188. # 1.可以print(a[::-1])
  189. # 2.a.reverse
  190. # e.g
  191. # a.reverse() #不是reverse(a)
  192. # print(a) #需注意a.reverse不需要新的变量来接收！
  193. # max_value=max(a),min_value=min(a)#获取列表中最大元素：当然前提是列表元素是同一类型的数值，如同整型，浮点型，当然全是字符串也可以比较
  194. # 对列表排序
  195. # a.sort() 
  196. # print(a) #对列表排序：当然前提是列表元素是同一类型的数值，如同整型，浮点型，当然全是字符串也可以比较
  197. # 诸如变量名.()我们习惯称为方法
  198. # 如a.sort(),a.reverse()
  199. # 另一类是 len(a),min(a),max(a)我们称为函数
  200.  
  201. # 修改查找元素   对列表的主要操作是增删改查
  202. # a=[1,2,3,4,5,6]
  203. # print(a.index(5))  输出4，表示5在这个列表中，第一次出现的下标为4，
  204. # 对于index方法而言，如果要查找的元素在列表中出现了多次，就显示第一次出现的下标，并且查找时要保证查找元素在列表中，否则会报错
  205. # value=a[1]
  206. # print(value)
  207. # print(a.count(2))# count 方法表示查找指定元素出现次数，与index方法不同的是，如果要查找的元素没有出现则输出零，不会报错
  208. # 一个小技巧
  209. # e.g a=["周一","周二","周三","周四","周六","周五","周日"]
  210. # #很明显列表中周六和周五位置反了，我们现在要交换它们
  211. # a[4],a[5]=a[5],a[4] #这样操作即可，和C语言表达有所差别
  212. # 赋值也可这样
  213. # a,b,c=1,2,3
  214. # s="周一,周二,周三,周四,周六,周五,周日"
  215. # a=s.split(",")
  216. # print(a)# 形成的a是一个列表，这样就实现了字符串转列表
  217. # #我们还可以将列表转成字符串
  218. # a1="*".join(a) #前面可填连接的填充物，不填则“”，注意使用join方法必须保证a列表中所有元素是同一类型
  219. # print(a1)
  220.  
  221. # 增加元素
  222. # a=[1,2,3,4]
  223. # a.append(5)#往列表末尾加入指定元素，但要注意只能支持尾插一个元素
  224. # a.insert(3,2.45) #insert方法两个参数，第一个是插入的位置，第二个是插入的内容，插入成功后原来位置及以后的元素往后移动，
  225. # 此外第一个参数也可以超过列表长度-1，这样的话系统默认插在尾部，比如-x,x>列表长度，就相当插在头部
  226. # a.extend([5,6,7])#表示在尾部追加一个新列表[5,6,7]
  227. # 比如b=[5,6,7]  a.extend(b)这样表达也行
  228. # 也可以追加字符串s例如
  229. # s="hello"
  230. # a.extend(s)#此时尾部追加的是字符串被拆分开来的各个元素 输出结果[1, 2, 3, 4, 'h', 'e', 'l', 'l', 'o']
  231. # 可以这样 ，如果不想这样想将hello作为一个独立元素插入到列表中
  232. # a.extend([s])#输出[1, 2, 3, 4, 'hello']
  233. # print(a)
  234.  
  235. #删除元素
  236. #a=[1,3,5,7,9]
  237. #a.pop() #输出[1, 3, 5, 7]，弹出最后一个元素，此操作也可以用变量来接收
  238. # value=a.pop() #输出9
  239. #value=a.pop(2) #表示弹出列表下标为2的指定元素
  240. # 也可以用变量接收弹出指定元素，
  241. # 但要注意几点：1.需要唯一参数下标，且你给出的下标不能越界，（可以使用负数下标，例如a.pop（-1）表示弹出最后一个元素）
  242. # print(value)
  243. # 删除元素也可以用del操作
  244. # del a[-2]#表示删除倒数第二个元素，但del操作不支持用变量接收
  245. # print(a)#输出[1, 3, 5, 9]
  246.  
  247. # 字典基础 可变容器类型 以键值对方式存储 key——value 字典中的键必须是唯一的不能重复
  248. # d={}
  249. # print(d,type(d))#{} <class 'dict'>
  250. # d={"北京":22,"上海":24}#正常声明
  251. # d={"北京":22,"北京":24} #错误声明
  252. # 字典中的键必须是不可变类型 # l=[0,1,2] a={l:22} 错误
  253. # 查 print(d["北京"])#输出22
  254. # 改 d["北京"]=20 
  255. # 增 d["广州"]=23
  256. # 删 d.pop("北京") 可以用变量来接收  
  257. # value=d.pop("北京")
  258. # value=key("北京")
  259. # 查找字典某一键对应的值并不依赖所谓下标而是通过键来查找，因此在字典中并不存在所谓先后顺序之分
  260. # 如果一次想往字典中添加多个元素，可以使用update方法
  261. # d.update({"xx":"xx"}) #{'北京': 22, '上海': 24, 'xx': 'xx'}
  262. # 如果update方法中要增添元素是已有的，那么顺带更新了所对应的值（即为update中的新值
  263. # print(d)
  264. # v=d.pop("aa",-1)
  265. # print(v)#第二个参数意思是如果要删除的第一个参数不在字典中将第二个参数赋值给v 输出v=-1
  266. # 同样的操作还有以下两种变式
  267. # name=d.get("aa",-1)#第二个参数意思是如果要获取的第一个参数不在字典中将第二个参数赋值给name 输出name=-1
  268. # 这样有什么好处？ 好处在于：如果要查找键不在字典中，程序运行不会崩溃
  269. # 更进一步，我们还有：
  270. # name=d.setdefault("aa",-1)#第二个参数意思是如果要删除的第一个参数不在字典中将第二个参数赋值给name 输出name=-1
  271. # 且在字典中添加一个新的键值对：“aa”:-1#输出：{'北京': 22, '上海': 24, 'aa': -1}
  272. # print(d)
  273. # d.clear()
  274. # print(d)#输出{}
  275. # 可以将整个字典作为一个大字符串来看，有以下一种用法：
  276. # print("aaa"+str(d))#输出：aaa{'北京': 22, '上海': 24}
  277. # 可以判断某个键在不在该字典：
  278. # print("aa"in d)#输出False，要注意这第一个参数“aa”只能是键
  279. # 字典的初始化可以分行来写：
  280. # c={
  281. #     "aa":1,
  282. #     "bb":2
  283. # }#输出：{'aa': 1, 'bb': 2}
  284. # print(c)
  285. # 注意：之前说过列表的键一定是不可变类型，所以不能以列表作为字典的键，但是可以列表作为字典的值
  286.  
  287.  
  288.  
  289.  
  290. # 字典遍历
  291. # 可迭代对象的概念：允许每次只获取一个元素，可以用for遍历
  292. # s=dict(a=1,b=2,c=3)
  293. # for i in s:
  294. #     print(f"key={i},value={s[i]}")
  295. # 输出：
  296. # key=a,value=1
  297. # key=b,value=2
  298. # key=c,value=3
  299. # 还有以下三种方式：
  300. # for i in s.keys():
  301. #     print(f"key={i}")
  302. # 输出：
  303. # key=a
  304. # key=b
  305. # key=c
  306. # for i in s.values():
  307. #     print(f"value={i}")
  308. # 输出：
  309. # value=1
  310. # value=2
  311. # value=3
  312. # #以上两种方式i表示s的key和s的value
  313. # 第三种遍历方法：
  314. # for k,v in s.items():
  315. #     print(f"key={k},value={v}")
  316. # 输出：
  317. # key=a,value=1
  318. # key=b,value=2
  319. # key=c,value=3
  320. # l=list(s.keys())
  321. # print(l)
  322. # t=tuple(s.values())
  323. # print(t)
  324. # 输出：
  325. # ['a', 'b', 'c']
  326. # (1, 2, 3)
  327. # 字典和列表或字典嵌套的实例：
  328. # s=dict(a=[1,2,3],b={"1":100,"2":200},c=3)
  329. # print(s)#{'a': [1, 2, 3], 'b': {'1': 100, '2': 200}, 'c': 3}
  330. # print(s["b"]["1"]) #输出100
  331. # print(s["a"][2]) #输出3
  332. # 注意：第一个下标是列表或字典的话要用""或''
  333. # 第二个下标：
  334. # 如果是列表的下标，则不用单引号或双引号
  335. # 字典的话则要用
  336. # 可参看我上面举的两个例子
  337.  
  338. # 列表推导式
  339. # 列表推导式可以快速构建新的数据序列
  340. # [表达式 for 变量 in 列表]
  341. # [表达式 for 变量 in 列表 if 筛选条件]
  342. # l1=[1,2,3,4,5]
  343. # l2=[i*2 for i in l1]#输出[2, 4, 6, 8, 10] i*2是联系l1和l2之间的关系式，即l2中每一个元素是l1中每一个对应元素的2倍
  344. # l2=[i for i in range(10)if not i%2 ]#输出[0, 2, 4, 6, 8]
  345. # 也可以这样转换列表中的数据类型：
  346. # l2=[str(i) for i in range(10)]#输出['0', '1', '2', '3', '4', '5', '6', '7', '8', '9']
  347. # print(l2)
  348. # 由于字符串也是一种序列结构，我们也可以遍历字符串
  349. # l=[i for i in 'hello']#输出['h', 'e', 'l', 'l', 'o']
  350. # l=[i.upper() for i in 'hello']#输出['H', 'E', 'L', 'L', 'O']
  351. # l=[i.upper() for i in 'hello' if i!='h']#输出['E', 'L', 'L', 'O']
  352. # print(l)
  353.  
  354.  
  355.  
  356.  
  357.  
  358. # 推导式练习
  359. # 1.获取['Food','Moon','Loop']中每个元素的首字母，并将这三个首字母组成一个新的字符串
  360. # l=['Food','Moon','Loop']
  361. # l1=[i[0] for i in l]
  362. # print(l1)
  363. # s=''.join(l1)
  364. # print(s)
  365. # 运行结果：
  366. # ['F', 'M', 'L']
  367. # FML
  368. # 2.找出同时出现在l1和l2中的元素
  369. # l1=[2,4,6,8,10,12]
  370. # l2=[3,6,9,12]
  371. # l=[i for i in l1 if i in l2]
  372. # print(l) #输出：[6, 12]
  373. # 3.将[1,3,5,7,9]中所有元素打印在控制台上
  374. # l3=[1,3,5,7,9]
  375. # 解一：[print(i) for i in l3]
  376. # 输出：
  377. # 1
  378. # 3
  379. # 5
  380. # 7
  381. # 9
  382. # 解二：
  383. # for i in l3:
  384. #     print(i)
  385.  
  386.  
  387.  
  388. # 元组（Tuple）简介
  389. # 元组和列表一样也是一种有序容器
  390. # 也使用下标索引元素
  391. # 也可以截取
  392. # 但它是不可变类型
  393. # a=(1,2,3)
  394. # print(type(a))#<class 'tuple'>
  395. # 但元组中只有一个元素是应这样表达
  396. # b=1，
  397. # 或b=(1,)#注意和b=(1)区分，后者系统会将括号看作是优先级的提高
  398. # 以下是一些元组的常规操作：
  399. # a1=a*3
  400. # print(a1)
  401. # print(len(a1))
  402. # print(4 in a1)
  403. # print(max(a))
  404. # print(min(a))
  405. # print(a1.count(3))
  406. # 分别输出：
  407. # (1, 2, 3, 1, 2, 3, 1, 2, 3)
  408. # 9
  409. # False
  410. # 3
  411. # 1
  412. # 3
  413. # 但是不允许a[x]=xx,a.append(),a.remove()之类操作
  414. # 此外元组支持这种赋值操作
  415. # t=(1,2,3)
  416. # a,b,c=t
  417. # print(f"t={t},a={a},b={b},c={c}")
  418. # #输出：t=(1, 2, 3),a=1,b=2,c=3
  419. # 回顾以前初学时两个变量赋值操作：
  420. # a,b=b,a
  421. # 对于列表类似有：
  422. # t[0],t[1]=t[1],t[0]
  423. # print(t)
  424. # 但元组不支持这种操作
  425.  
  426.  
  427.  
  428. # 列表嵌套
  429. # 列表List中可以存放任意类型的元素
  430. # 整型 小数 bool值 也可以是列表类型 相当于一个大箱子放几个小箱子
  431. # e.g
  432. # stu1=["小明",95]
  433. # stu2=["小红",86]
  434. # stu3=["小王",68]
  435. # stu=[stu1,stu2,stu3]#[['小明', 95], ['小红', 86], ['小王', 68]]
  436. # 或这样声明：：
  437. # stu=[
  438. #     ["小明",95],
  439. #     ["小红",86],
  440. #     ["小王",68]
  441. # ]
  442. # print(stu)
  443. # print(stu[0][0])#小明
  444. # print(f"{stu[0][0]}的分数为：{stu[0][1]}")#小明的分数为：95
  445.  
  446.  
  447.  
  448. # 列表练习
  449. # 1.创建一个有10个元素的列表，值是[30,31,30,31...]
  450. # l=[30,31]*5
  451. # 2.将下标为0的元素删除
  452. # l.pop(0)
  453. # 3.将下标为1的元素值改为28
  454. # l[1]=28
  455. # 4.在下标为7的位置插入一个元素31
  456. # l.insert(7,31)
  457. # 5.在列表末尾追加2个元素：30,31
  458. # l.extend([30,31])
  459. # 最终结果应该是[31,28,31,30,31,30,31,31,30,31,30,31]
  460. # print(l)#[31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
  461. # 提示用户输入一个1~12之间的整数值表示月份，然后在控制台显示用户输入的这个月份有多少天
  462. # 比如用户输入的数是7，就显示“7 月份有 31 天”
  463. # month=input("请输入一个1~12之间的整数值表示月份：")
  464. # month=int(month)
  465. # print(f"{month} 月份有 {l[month-1]} 天")
  466. # 此题也可以用if elif语句
  467.  
  468.  
  469.  
  470. # Range方法
  471. # l=list(range(x)) 表示生成从0开始到x-1的连续列表
  472. # range(end)生成0-end之间的整数，不包含end
  473. # range(start,end)生成start-end之间的整数，不包含end
  474. # range(start,end,step)生成start-end之间的整数，不包含end,并且每隔step个数字生成一个数字
  475. # l=list(range(1,101))
  476. # t=tuple(l)
  477. # print(f"l的类型是： {type(l)}\n{l}")
  478. # print(f"t的类型是： {type(t)}\n{t}")
  479. # l的类型是： <class 'list'>
  480. # [1, 2, 3, 4, 5, 6, 7, 8, 9, ....,100]
  481. # t的类型是： <class 'tuple'>
  482. # (1, 2, 3, 4, 5, 6, 7, 8, 9, ....)
  483. # l=list(range(1,100,2))#表示1-100的所有奇数
  484.  
  485. # 列表遍历
  486. # 遍历：依次取出每个元素
  487. # for...in..
  488. # for item in l:
  489. #     print(item)
  490. # 元组，字符串，range()都可以使用for遍历
  491. # l=list(range(101))#注：range里不可以有可变类型列表
  492. # for item in l:
  493. #     print(item)#依次输出1-100
  494. #     l=list(range(101))
  495. # for item in "Python":
  496. #     print(item)#依次输出P y t h o n 
  497.  
  498. # for循环
  499. # for in 循环遍历容器类型
  500. # 最简单的例子：
  501. # for item in range(100):
  502. #     print("hello,world!")
  503. # sum=0
  504. # for item in range(1,101):
  505. #     sum+=item
  506. # print(sum)#熟悉的5050
  507. # for item in range(1,101):
  508. #     if item %2==0:
  509. #         sum+=item
  510. # print(sum)#熟悉的2025
  511.  
  512.  
  513. # for 练习
  514. # 1.提示用户输入5个数，组成一个列表
  515. # l=[]
  516. # for i in range(5):
  517. #     num=input(f"请输入第{i+1}个数：")
  518. #     num=int(num)
  519. #     l.append(num)
  520. # print(f"输入的五个数是：{l}")
  521. # 输出：
  522. # 请输入第1个数：1
  523. # 请输入第2个数：2
  524. # 请输入第3个数：3
  525. # 请输入第4个数：4
  526. # 请输入第5个数：5
  527. # 输入的五个数是：[1, 2, 3, 4, 5]
  528. # 将列表中各个元素的值*2
  529. # for i in range(len(l)):
  530. #     l[i]*=2
  531. # print(f"各个元素的值*2组成的新列表：{l}")
  532. # 计算新列表中所有元素的和
  533. # sum=0
  534. # for i in range(len(l)):
  535. #     sum+=l[i]
  536. # print(f"这个新列表中所有元素和为：{sum}")
  537. # 2.找出100以内所有7的倍数以及包含7的数，将它们放在一个列表中
  538. # l=[]
  539. # for i in range(101):
  540. #     if i%7==0:
  541. #         l.append(i)
  542. #     else:
  543. #         temp=i
  544. #         while(temp):
  545. #             k=temp%10
  546. #             if(k==7):
  547. #                 l.append(i)
  548. #                 break
  549. #             temp/=10
  550. # print(f"满足条件的元素放在列表{l}")
  551. # 满足条件的元素放在列表[0, 7, 14, 17, 21, 27, 28, 35, 37, 42, 47, 49, 56, 57, 63, 67, 70, 77, 84, 87, 91, 97, 98]
  552.  
  553. # while循环
  554. # 最简单的例子：
  555. # i=0
  556. # while i<10:
  557. #     print("balabala")
  558. #     i+=1
  559. # l=[]
  560. # i=''
  561. # while  i!='q':
  562. #     i=input("请输入待办事项（扣q退出）：")
  563. #     l.append(i)
  564. # l.pop()
  565. # print(l)
  566. # 或这样声明：
  567. # while  1:
  568. #     i=input("请输入待办事项（扣q退出）：")
  569. #     if i=='q':
  570. #         break
  571. #     l.append(i)
  572. # print(l)
  573. # Python和C系列语言的一个重要区别：
  574. # for i in range(4):
  575. # 系统不能容忍你空循环，会报错，这点和C语言完全不同，但是我们如果只想留着这个循环（比如日后再添加啥的），需要这样做：
  576. #     pass #可以保证代码完整性
  577.  
  578.  
  579. # 循环嵌套
  580. # 最简单的例子：
  581. # for i in range(3):
  582. #     for j in range(5):
  583. #         print(f"i={i},j={j}")
  584. # i=0,j=0 i=0,j=1 i=0,j=2 i=0,j=3 i=0,j=4 i=1,j=0 i=1,j=1 i=1,j=2 i=1,j=3 i=1,j=4
  585. # i=2,j=0 i=2,j=1 i=2,j=2 i=2,j=3 i=2,j=4
  586. # 创建二维列表
  587. # l=[]
  588. # for i in range(3):
  589. #     item=[]
  590. #     l.append(item)
  591. #     for j in range(5):
  592. #         item.append(j)
  593. # print(l)#[[0, 1, 2, 3, 4], [0, 1, 2, 3, 4], [0, 1, 2, 3, 4]]
  594. # #二维列表元素查找：
  595. # for i in l:
  596. #     for j in i:
  597. #         print(j)#结果就是依次输出
  598. # # 套路就是一层套一层
  599. # #以上两种都可以用列表推导式各一行解决：
  600. # l1=[[j for j in range(5)]for i in range(3)]
  601. # print(l1)#[[0, 1, 2, 3, 4], [0, 1, 2, 3, 4], [0, 1, 2, 3, 4]]
  602. # [[print(j) for j in i]for i in l]#0 1 2 3 4 0 1 2 3 4 0 1 2 3 4
  603.  
  604.  
  605. # 循环练习
  606. # 1.找到100-1000内最小的水仙花数（水仙花数：每位上数字的3次幂之和等于本身）
  607. # for i in range(100,1001):
  608. #     a=i%10
  609. #     b=i//10%10
  610. #     c=i//100%10
  611. #     if a**3+b**3+c**3==i:
  612. #         print(f"{i}是100-1000内水仙花数")
  613. # 输出：
  614. # 153是100-1000内水仙花数
  615. # 370是100-1000内水仙花数
  616. # 371是100-1000内水仙花数
  617. # 407是100-1000内水仙花数
  618.  
  619. # 2.找出100以内的所有质数存放在列表中：
  620. # l=[]
  621. # for i in range(2,101):
  622. #     is_prime=True
  623. #     j=2
  624. #     while(j*j<=i):
  625. #         if i%j==0:
  626. #             is_prime=False
  627. #         j+=1
  628. #     if(is_prime):
  629. #         l.append(i)
  630. # print(l)#[2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97]
  631.  
  632. # 3.打印九九乘法表
  633. # for i in range(1,10):
  634. #     for j in range(1,10):
  635. #         print(f"{i}*{j}={i*j:2d}",end=' ')#格式注意：隔一个空格，一个数字一行，并保证最终结果对齐,我们用：{i*j:2d}
  636. #     print("")
  637. # 1*1= 1 1*2= 2 1*3= 3 1*4= 4 1*5= 5 1*6= 6 1*7= 7 1*8= 8 1*9= 9
  638. # 2*1= 2 2*2= 4 2*3= 6 2*4= 8 2*5=10 2*6=12 2*7=14 2*8=16 2*9=18
  639. # 3*1= 3 3*2= 6 3*3= 9 3*4=12 3*5=15 3*6=18 3*7=21 3*8=24 3*9=27
  640. # 4*1= 4 4*2= 8 4*3=12 4*4=16 4*5=20 4*6=24 4*7=28 4*8=32 4*9=36
  641. # 5*1= 5 5*2=10 5*3=15 5*4=20 5*5=25 5*6=30 5*7=35 5*8=40 5*9=45
  642. # 6*1= 6 6*2=12 6*3=18 6*4=24 6*5=30 6*6=36 6*7=42 6*8=48 6*9=54
  643. # 7*1= 7 7*2=14 7*3=21 7*4=28 7*5=35 7*6=42 7*7=49 7*8=56 7*9=63
  644. # 8*1= 8 8*2=16 8*3=24 8*4=32 8*5=40 8*6=48 8*7=56 8*8=64 8*9=72
  645. # 9*1= 9 9*2=18 9*3=27 9*4=36 9*5=45 9*6=54 9*7=63 9*8=72 9*9=81


Acknowledgement:

网易云课堂：

   波波课堂41学时之零基础学Python

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/不正经/article/detail/208039
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号