Python基础数据类型-列表（list）、元组（tuple）、字典（dict）和集合（set）

1. 序列和索引

• 序列
  

• 示例 1

s = 'hello'

for i in range(0,len(s)):
    print(i,s[i],end='\t\t')
结果：0 h		1 e		2 l		3 l		4 o	

• 示例 索引

#正向递增索引
s1 = 'helloworld'
for i in range(0,len(s1)):
    print(i,s1[i],end='\t\t')
print('\n-------------------------')
#逆向递减索引
s2 = "helloworld"
for i in range(-len(s2),0):
    print(i,s2[i],end='\t\t')
print('\n-------------------------')
print(s1[9],s2[-1])
结果：
0 h		1 e		2 l		3 l		4 o		5 w		6 o		7 r		8 l		9 d		
-------------------------
-10 h		-9 e		-8 l		-7 l		-6 o		-5 w		-4 o		-3 r		-2 l		-1 d		
-------------------------
d d

2.列表（list）

• 列表：可变数据类型：具有增删改查方法，在进行增删改查时，列表的内存地址不变
• 元素个数可变，但内存地址不变
• 示例 1：插入

# 1.1  插入append()
num = [1,2,3,4,5,6]
print("原列表：",num,id(num))
   结果：原列表： [1, 2, 3, 4, 5, 6] 2969153957248

num.append(7)
print("新列表：",num,id(num))
   结果：新列表： [1, 2, 3, 4, 5, 6, 7] 2969153957248

num.append(('hello','world'))# 添加元组
print(num)
    结果：[1, 2, 3, 4, 5, 6, 7, ('hello', 'world')]
    解释：向列表中添加元组， 元组会以一个整体元素添加倒列表中

lst = [2008,2022]
lst.append(2035)
lst.append(['2025',2025]) #作为整体添加
print(lst)  # [2008, 2022, 2035, ['2025', 2025]]
------------------------------------------------------------------
# 1.2  插入insert()
num = [1,2,3,4,5,6]
num.insert(num[0],0)
print(num)
    结果：[1, 0, 2, 3, 4, 5, 6] 
    解释：num[0] = 1,所以在地址为1处插入0

num.insert(0,0)
print(num)
    结果：[0, 1, 0, 2, 3, 4, 5, 6]
    解释：num已经是新列表，在新列表地址为0出插入0

num.extend([8,9])
print(num)
    结果：[0, 1, 0, 2, 3, 4, 5, 6, 8, 9]
    解释：在末尾插入多个数据，以列表形式插入

• 示例 2：删除

# 2.1 删除remove()
eggs = ["鸡蛋","鸭蛋","鹅蛋","鸟蛋"]
eggs[1],eggs[3] = eggs[3],eggs[1] # 交换位置
print(eggs)  # 结果：['鸡蛋', '鸟蛋', '鹅蛋', '鸭蛋']
eggs.remove("鸡蛋") #删除
print(eggs)  # 结果：['鸟蛋', '鹅蛋', '鸭蛋']
---------------
# 2.2 删除pop()
eggs.pop(0)  # 删除位置0元素
print(eggs)  # 结果：['鹅蛋', '鸭蛋']
---------------
# 2.3 删除del
del eggs[0]  # 删除位置0元素
print(eggs)  # 结果：['鸭蛋']
eggs.pop()   # 默认删除位置0元素
print(eggs)  # 结果：[]
---------------
# 2.4 删除clear
eggs = ["鸡蛋","鸭蛋","鹅蛋","鸟蛋"]
eggs[1],eggs[3] = eggs[3],eggs[1] # 交换位置
print(eggs,id(eggs)) # 结果：['鸡蛋', '鸟蛋', '鹅蛋', '鸭蛋'] 1461112697984
eggs.clear()
print(eggs,id(eggs)) # 结果：[] 1461112697984

• 示例3：修改

# 3.1 reverse() 翻转输出
eggs = ["鸡蛋","鸭蛋","鹅蛋","鸟蛋"]
eggs.reverse()  # 结果：['鸟蛋', '鹅蛋', '鸭蛋', '鸡蛋'
print(eggs)     # 在原列表的基础上修改，不会产生新表
print(eggs.reverse())  #None  reverse()方法没有返回值
-------------------
# 3.2 copy() 复制
list2 = eggs.copy() #复制 内存地址会改变 新表
print(list2) # 结果：['鸟蛋', '鹅蛋', '鸭蛋', '鸡蛋']

• 示例4：排序

# 4.1 sort()
#字母排序 -> 根据ASCII码排序，先排大写，在排小写
lst = ["Cat","Apple","Banana","Dog"]
lst.sort()   
print(lst)  #结果：['Apple', 'Banana', 'Cat', 'Dog']
lst.sort(reverse=True)
print(lst)  #结果：['Dog', 'Cat', 'Banana', 'Apple']
----------------
# 4.2 自己指定规则排序
lst = ["cat","Apple","banana","Dog"]
lst.sort()  # 先排大写，再排小写
print(lst)  #结果：['Apple', 'Dog', 'banana', 'cat']
# 忽略大小写排序
lst.sort(key=str.lower) # str.lower 都转化为小写，再排序，参数不加(),调用才加括号
print(lst)  #结果：['Apple', 'banana', 'cat', 'Dog']
lst.sort(key=str.upper)  #str.upper都转化为大写
print(lst)  #结果：['Apple', 'banana', 'cat', 'Dog']

• 示例5：列表生成式

import random
lst = [item for item in range(1,11)]
print(lst)

lst = [item*item for item in range(1,11)]
print(lst)

lst = [random.randint(1,100) for _ in range(10)]  # 1,100的随机数
print(lst)

#从列表中选择符合条件的元素组成新列表
lst = [i for i in range(10) if i % 2 ==0]
print(lst)

• 示例6：二维列表：

# 二维列表 表格数据
lst = [
    ["城市","环比","同比","定基"],
    ["北京",10,20,30],
    ["上海",20,30,40]
]
print(lst)
# 遍历二维列表使用双层for循环
for i in lst:  #行
    for j in i: #列
        print(j,end="\t")
    print()
# 在第一次迭代时，row 将会是 ["城市","环比","同比","定基"]；在第二次迭代时，row 将会是  ["北京",10,20,30]；依此类推。
-----------------------
# 列表生成式，生成一个4行5列的二维表
lst2 = [[ j for j in range(5)]  for i in range(4)]
  >解释：for i in range(4)  四行，
      列表当中元素为 列表[ j for j in range(5)]
      for j in range(5) 五列
      列表[ j for j in range(5)]当中元素为 j
print(lst2)
for i in lst2:
    for j in i:
        print(j,end="\t")
    print()
# 结果：
[[0, 1, 2, 3, 4], [0, 1, 2, 3, 4], [0, 1, 2, 3, 4], [0, 1, 2, 3, 4]]
0	1	2	3	4	
0	1	2	3	4	
0	1	2	3	4	
0	1	2	3	4

3.元组 （tuple）

3.1 含义及使用：

• 是Python中内置的不可变序列

• 在Python中使用()定义元组，元素与元素之间使用英文的逗号分隔⭐⭐

• 元组中只有一个元素的时候，逗号也不能省略⭐⭐

3.2 创建方式：

• 1. 使用()直接创建元组
  • 语法结构：元组名=(element1,element2,element3,...elementN)
• 2. 使用内置函数tuple()创建元组
  • 语法结构：元组名=tuple(序列)

3.3 创建应用：

t0 = ("hello")
print(t0,type(t0))  #结果：hello <class 'str'>

t1 = ("hello",)# 注意逗号，如果元组中只有一个元素，逗号不能省⭐⭐
print(t1,type(t1))    #结果：('hello',) <class 'tuple'>

t2 = tuple("world")
print(t2,type(t2))    #结果：('w', 'o', 'r', 'l', 'd') <class 'tuple'>

t3 = tuple([2,3,4,5])
print(t3,type(t3))  #结果：(2, 3, 4, 5) <class 'tuple'>

3.4 元组操作

t = tuple([2, 3, 4, 5])
print(t, type(t))
print("3是否在t中：",(3 in t))
print("1是否在t中：",(1 in t))
print("1是否不在t中：",(1 not in t))
print("元组t中的最大值：",max(t))
print("元组t中的最小值：",min(t))
print("t.index：",t.index(5))
print("t.count：",t.count(2))
---
结果：
(2, 3, 4, 5) <class 'tuple'>
3是否在t中： True
1是否在t中： False
1是否不在t中： True
元组t中的最大值： 5
元组t中的最小值： 2
t.index： 3
t.count： 1

3.5 删除元组

del 元组名  

3.6 元组元素遍历与访问

- 访问：
t = tuple([2, 3, 4, 5])
print(t)        #结果：(2, 3, 4, 5)
print(t[0])     #结果：2
t1 = t[0:3] #元组支持切片
print(t1)       #结果：(2, 3, 4)
t2 = t[0:4:2]
print(t2)       #结果：(2, 4)
t3 = t[:]
print(t3)       #结果：(2, 3, 4, 5)

- 遍历：
》一：for
t = tuple([2, 3, 4, 5])
for i in t:
    print(i,end="\t")
  结果：2	3	4	5	
----------------
》二：#for + range() +len()
t = tuple([2, 3, 4, 5])
for j in range(len(t)):
    print(j,t[j],sep="-->",end="\t")
  结果：0-->2	1-->3	2-->4	3-->5
-----------------
》三：#enumerate  枚举
for index,item in enumerate(t):
    print(index,item,sep="-->",end="\t")
  结果：0-->2	1-->3	2-->4	3-->5

3.7 元组生成表达式

# 元组
t = (i for i in range(1,4))
print(t)
# t = tuple(t)
# print(t)
#遍历
# for item in t:
#     print(item,end="\t")
----
结果：
<generator object <genexpr> at 0x000001CD375A4E80>
(1, 2, 3)
1	2	3
------
#__next__方法  用于返回迭代器的下一个元素。
t = (i for i in range(1,4))
print(t)
print(t.__next__())
print(t.__next__())
print(t.__next__())  
------
结果：
1
2
3

3.8 元组与列表区别

4.字典 （dict）

4.1 含义

• 可变数据类型

• 字典类型是根据一个信息查找另一个信息的方式构成了“键值对”，它表示索引用的键和对应的值构成的成对关系

• 不可变字符序列作为键⭐⭐⭐⭐⭐

4.2 创建方式

• 使用{}直接创建字典
  • d ={key1:value1,key2:value2...}.
• 通过映射函数dict()创建字典

  • zip(lst1,lst2)
    

  • dict(key1:value1,key2:value2...)

4.3 字典的创建与删除

#（1）创建字典
d = {10:"cat",20:"dog",10:"pet"} # 字典默认去重，key相同时候，value值进行了覆盖
print(d)
  结果：{10: 'pet', 20: 'dog'}

#（2）zip函数
lst1 = [1,2,3]
lst2 = ["cat","dog","pig"]
d1 = zip(lst1,lst2)
print(d1) # <zip object at 0x000001D7B0C73EC0>  #映射结果是一个zip对象
print(dict(d1)) # 结果：{1: 'cat', 2: 'dog', 3: 'pig'}
---------------
lst1 = (1,2,3)
lst2 = ("cat","dog","pig")
d1 = zip(lst1,lst2)
print(d1)
d = dict(d1)
print(d)

#（3）使用参数创建字典
d = dict(cat=10,dog=20) # 左边cat为key，右边为value
print(d) # 结果：{'cat': 10, 'dog': 20}

t = (1,2,3)
t2 = ["cat","dog"]
print({t:10})
print(t2:20) # 结果：SyntaxError: invalid syntax
# 总结：列表不能作为字典的键值，可变数据类型不可作为字典当中的键⭐⭐

#（4）键值对的列表初始化
d = dict([(10, "cat"), (20, "dog")])
print(d)
  结果：{10: 'cat', 20: 'dog'}
----------------------------------------------------------------------

> 问题：
d0 = dict(cat=40,dog=30) #正确
print(d0)
d = dict(10=cat,20=dog)  #错误
print(d)
d1 = dict(cat:10,dog:20) #错误
print(d1)
> 原因：
  1.  键不能直接用数字
在 Python 中，dict() 构造函数的键值对语法（如 key=value）要求键必须是合法的标识符（变量名）。数字（如 10 和 20）不能直接用作标识符，因此会引发语法错误。
------------
  2. 键值对语法：dict() 构造函数需要使用等号 = 来指定键值对

# 注意：
字典中的key是无序的，
Python3.5及其之前的版本字典的key在输出时无序，但是从
Python3.6版本之后Python解释器进行了处理，所以才会看到输出的顺序与添加的顺序“一致”

4.4 字典的操作符

# 字典属于序列
d0 = {10:"banana",20:"apple"}
d1 = dict(cat=10,dog=20)
print(d0)       # {10: 'banana', 20: 'apple'}
print(max(d0))  # 20
print("-"*30)
print(d1)       # {'cat': 10, 'dog': 20}
print(max(d1))  # dog
# 最大,最小值输出的为键值，
print(min(d0))  # 10
print(min(d1))  # cat
print(len(d0))  # 2
print(len(d1))  # 2

4.5 字典的删除

d = {10:"cat",20:"dog"}
print(d)    # {10: 'cat', 20: 'dog'}
del d
print(d)    # NameError: name 'd' is not defined. Did you mean: 'id'?

4.6 字典元素的取值

# d[key]或者d.get(key) #d为字典名称
d = {10:"cat",20:"dog"}
print(d)    # {10: 'cat', 20: 'dog'}
print(d[10])     # cat
print(d.get(20)) # dog

# d[key]或者d.get(key)二者之间的区别
# 如果key不存在，d[key]报错，而d.get(key)可以指定默认值
d = {10:"cat",20:"dog"}
# print(d[30])     # KeyError: 30
print(d.get(30,"不存在")) # 不存在
print(d.get(10,"不存在")) # cat

4.7 字典元素的遍历

• items()方法

# 1)遍历出key与value的元组
d = {10:"cat",20:"dog"}
print(d)    # {10: 'cat', 20: 'dog'}
for i in d.items():
    print(i)
结果：
(10, 'cat')
(20, 'dog')
# 2)分别遍历出key与value
d = {10:"cat",20:"dog"}
print(d)    # {10: 'cat', 20: 'dog'}
for key,value in d.items():
    print(key,value,sep="-->",end="\t")
结果：10-->cat	20-->dog	

4.8 字典的i相关操作方法

• 应用

d = {10:"cat",20:"dog"}
print(d.keys()) # 结果：dict_keys([10, 20])
print(d.values()) # 结果：dict_values(['cat', 'dog'])
# print(d.pop(10)) # 结果：cat
# print(d.pop(20)) # 结果：dog
print(d.pop(30,"no")) # 结果：no
# print(d.popitem()) # 结果：(20, 'dog')
print(d)           # 结果：{10: 'cat'}
print(d.clear()) # 结果：None
# python中一切皆对象，每个对象都有一个布尔值
print(bool(d))   #结果：False ,现在字典为空

4.9 字典生成式

# d={ key:value for item in range(1,4)}
d = {i:i*i for i in range(1,4)}
print(d)

# d={ key:value for key,value in zip(lst1,lst2)}
lst1 = [1,5,7]
lst2 = ["a","b","c"]
d = { key:value for key,value in zip(lst1,lst2)}
print(d)

5.集合 （set）

5.1 含义

• Python中的集合与数学中集合的概念一致

• Python中的集合是一个无序的不重复元素序列

• 集合中只能存储不可变数据类型 # 不能存储字典，不能存储列表

• 在Python中集合使用{}定义

• 与列表、字典一样，都是Python中的可变数据类型

5.2 集合的创建

# 1) 直接使用{}创建集合
- 语法结构：
   - s={element1,element2,...elementN}

s = {1,2,3}
print(s,type(s))
# 结果：{1, 2, 3} <class 'set'>
----------------------------------------------------------
# 2）使用内置函数set()创建集合
- 语法结构：
  - s=set(可迭代对象)

s = set()  # 空集合

s = {}     #创建的是字典

s = set(range(5,9))
print(s)   # 结果：{8, 5, 6, 7} #集合无序

s = set("hello")
print(s)   # {'h', 'e', 'l', 'o'} #集合不重复

5.3 集合的操作

# 集合属于序列中的一种
s = set(range(10))
print(s)        # {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
print(max(s))   # 9
print(min(s))   # 0
print(len(s))   # 10
print("9在集合s中嘛？",9 in s) # 9在集合s中嘛？ True
print("9不在集合s中嘛？",9 not in s) # 9不在集合s中嘛？ False

5.4 集合的删除

del s
print(s) # NameError: name 's' is not defined

5.5 集合的操作符

s0 = set(range(3))
s1 = set(range(5))
print("s0:",s0,"s1:",s1)
print(s0 & s1)  #交集：{0, 1, 2}
print(s0 | s1)  #并集：{0, 1, 2, 3, 4}
print(s1 - s0)  #差集：{3, 4}
print(s0 - s1)  #差集：set()
print(s0 ^ s1)  #补集：{3, 4}
print(s1 ^ s0)  #补集：{3, 4}

5.6 集合相应的操作方法

s = set(range(3))
print(s)    # {0, 1, 2}
s.add(3)
print(s)    # {0, 1, 2, 3}
s.remove(0)
print(s)    # {1, 2, 3}
s.clear()
print(s)    # set()

5.6 集合遍历操作

s = set(range(5))
print(s)
for i in s:
    print(i)
#结果：
{0, 1, 2, 3, 4}
0
1
2
3
4
-----------------
s = set(range(1,5))
print(s)
for i in enumerate(s):
    print(i)
# 结果：
(0, 1)
(1, 2)
(2, 3)
(3, 4)
-------------
s = set(range(5))
for index,item in enumerate(s): # index是序号不是索引
    print(index,"-->",item)
# 结果：
0 --> 0
1 --> 1
2 --> 2
3 --> 3
4 --> 4

5.6 集合的生成式

s = {item  for item in range(5)}
print(s)    # {0, 1, 2, 3, 4}
s = {i for i in range(10) if i %2 == 0}
print(s)    # {0, 2, 4, 6, 8}

6. 列表，元组，字典，集合区别

7. 总结

• 序列结构主要有列表、元组、集合、字典和字符串

• 正向递增索引取值范围[0,N-1]，反向递减索引取值范围[-1,-N]

• 切片操作语法结构:序列名[start: end :step]

• 创建列表的方式:1)使用“直接创建 2)使用内置函数list()创建

  • 列表的相关操作方法

    • 添加方法:append()和insert()

    • 删除方法:clear()、remove()、pop()

    • 列表元素的排序:sort()和内置函数sorted()

    • 其它方法:reverse()和copy()

• 创建元组的方式:1)使用()直接创建 2)使用内置函数tuple()创建

• 创建字典的方式:1)使用{}直接创建 2)使用内置函数dict()

  • 使用内置函数dict()创建字典的两种方式

    • 通过映射函数zip(lst1,lst2)创建字典

    • 通过给定关键字创建字典dict(key1=value1,key2=value2.....)

  • 字典的相关操作方法!

    • 查询方法:get()、keys()、values()和items()

    • 删除方法:pop()、popitem()和clear()

• 创建集合的方式:1)使用{}直接创建2)使用内置函数set()创建

  • 集合的相关操作方法

    • 添加方法:add()

    • 删除方法:remove()和clear()

• 列表、字典、集合都是Python中的可变数据类型，元组是Python中的不可变数据类型

• 列表、元组、字典和集合的遍历都可以通过for循环实现

• 列表、元组、字典和集合的删除都可以使用语句 del来实现

8.练习

• 《一》

  d={'a':10}
  d2=d
  d['a']=100
  print(d['a']+d2['a'])
  这个的输出结果？
  

  点击查看代码

  d={'a':10}
  d2=d
  d['a']=100
  print(d['a']+d2['a'])    # 200
  d3 = d.copy()
  d['a']=200
  print(d['a'] + d3['a'])  # 300
  
  # 这里d2 = d并不是创建了一个新的字典对象，而是让d2和d指向了同一个字典对象。换句话说，d和d2是同一个字典的两个引用。
  d['a'] = 100
  这一步修改了字典对象中键'a'对应的值为100。由于d和d2指向的是同一个字典对象，所以d2['a']也会被修改为100。
  print(d['a'] + d2['a'])
  此时d['a']和d2['a']的值都是100，因此d['a'] + d2['a']的结果是200。
  
  d = {'a': 10}
  d2 = d.copy()  copy方法来创建一个浅拷贝
  d['a'] = 100
  print(d['a'] + d2['a'])
  这样d2就不会受到d的修改影响，结果将是110。
  

---

• 《二》

  需求:已知一个列表中存储的是员工的出生年份[88,89,90,98,00,99]，由于时间比较久，出生的年份均为2位整数，现需要2位年份前加19，如果年份是00，将需要加上200

  点击查看代码

    years = [88,89,90,98,00,99]
  
    for index in range(len(years)):
        if str(years[index]) != '0':
            years[index] = "19"+str(years[index])
        else:
            years[index] = "20"+str(years[index])
    print(years)
  --------------
  years = [88,89,90,98,00,99]
  
  for index,value in enumerate(years):
    if str(value) != '0':
        years[index] = "19" + str(value)
    else:
        years[index] = "200" + str(value)
  print(years)
  

---

• 《三》 模拟京东购物流程

  需求:从键盘录入5个商品信息(1001手机)添加到商品列表中，展示商品信息，提示用户选择商品，用户选中的商品添加到购物车中(购物车中的商品要逆序)用户选中的商品不存在需要有相应提示当用户输入“q”时循环结束，显示购物车中的商品。

  点击查看代码

  lst = []
  stor = []
  for i in range(5):
      goods = input("请输入商品编号及商品名称，进行入库，每次只能输入一尖商品：")
      lst.append(goods)
  
  for j in range(len(lst)):
      print(lst[j])
  
  while True:
      flag = 0
      a = input("请输入商品编号:")
      for item in lst:
          if a==item[0:4]:
              flag=1
              print("succeed")
              stor.append(item)
              break #退出for循环
      if flag==0  and a!='q':
          print('商品没找到')
      if a =="q":
          break
  print("-"*50)
  
  print("您选择的商品有：")
  stor.reverse()
  for item in stor:
      print(item)
  

---

• 《四》 模拟12306火车票订票流程

  需求:假设北京到天津有4个车次可供选择，用户选择所要购买的车次，进行购票进站。

  点击查看代码

  d = {
      'G1569':['北京南-天津南','18:06','18:39','00:33'],
      'G1567':['北京南-天津南','18:15','18:49','00:34'],
      'G8917':['北京南-天津西', '18:20', '19:19', '00:59'],
      'G203':['北京南-天津南', '18:35', '19:09', '00:34']
  }
  print('车次   ',' 出发站-到达站','出发时间','到达时间','历时时长')
  for key in d.keys():
      print(key,end='\t')
      for item in d.get(key):
          print(item,end='\t')
      print()
  
  car= input("请输入购票车次：")
  info = d.get(car,"不存在")
  
  if info != "不存在":
      name = input("请输入乘车人，如果是多个乘车人请使用逗号分隔：")
      s = info[0] +" " +info[1]
      print("您购买的车次:" + car ,s+"开，请" + name + "尽快取票。【铁路客服】")
  else:
      print("车次不存在")
  

---

• 《五》 模拟手机通讯录
  需求:从键盘录入5位好友的姓名和电话，由于通讯录是无序的所以可以使用集合来实现，

  点击查看代码

  s = set()
  for i in range(1,6):
  #   info = input("请输入第%d位好友的姓名及手机号:"% i)
  #   info = input(f"请输入第{i}位好友的姓名及手机号:")
      info = input("请输入第{0}位好友的姓名及手机号:".format(i))
      s.add(info)
  for item in s:
      print(item)
  ----
  结果：
  请输入第1位好友的姓名及手机号:a1
  请输入第2位好友的姓名及手机号:b2
  请输入第3位好友的姓名及手机号:c3
  请输入第4位好友的姓名及手机号:d4
  请输入第5位好友的姓名及手机号:e5
  e5
  b2
  a1
  d4
  c3