list tuple dict set

 

List（列表）

列表可以进行截取、组合。

列表的数据项不需要具有相同的类型。

1、操作列表

创建一个列表，只要把逗号分隔的不同的数据项使用方括号括起来即可。如下所示：

list1 = ['physics', 'chemistry', 1997, 2000]
list2 = [1, 2, 3, 4, 5 ]
list3 = ["a", "b", "c", "d"]

（1）增

① 使用 append() 方法

list = [1,"alex"]          ## 空列表
list.append('Google')   ## 使用 append() 添加元素
list.append('Runoob')
print(list)

以上实例输出结果：

[1,"alex",'Google', 'Runoob']

② 使用 insert() 方法

li = ['alex',[1,2,3],'wusir','egon','女神','taibai']
li.insert(4,'chunge')    #在下标位4的位置插入
print(li)

以上实例输出结果：
['alex', [1, 2, 3], 'wusir', 'egon', 'chunge', '女神', 'taibai']

③ 使用 extend() 方法：在最后位置，分解插入

错误示例：
li = ['alex',[1,2,3],'wusir','egon','女神','taibai']
li.extend(123) 
print(li)

输出结果：
li.extend(123)  #int不可迭代
TypeError: 'int' object is not iterable

正确示例：
li = ['alex',[1,2,3],'wusir','egon','女神','taibai']
li.extend('dage') 
print(li)

输出结果：
['alex', [1, 2, 3], 'wusir', 'egon', '女神', 'taibai', 'd', 'a', 'g', 'e']

（2）删

① pop()：按索引删除【默认删除最后一个】，有返回值：返回删除的值。

li = ['alex',[1,2,3],'wusir','egon','女神','taibai']
print("原始列表：",li)
print("pop掉的数据：",li.pop(1))
print("pop后的列表：",li)

运行结果：
原始列表： ['alex', [1, 2, 3], 'wusir', 'egon', '女神', 'taibai']
pop掉的数据： [1, 2, 3]
pop后的列表： ['alex', 'wusir', 'egon', '女神', 'taibai']

② remove()：按元素删除，无返回值

li = ['alex',[1,2,3],'wusir','egon','女神','taibai']

print("原始列表：",li)
li.remove('taibai')  
print("remove后的列表：",li)

运行结果： 
原始列表： ['alex', [1, 2, 3], 'wusir', 'egon', '女神', 'taibai'] 
remove后的列表： ['alex', [1, 2, 3], 'wusir', 'egon', '女神']

③ clear()：清空

li = ['alex',[1,2,3],'wusir','egon','女神','taibai']
print("原始列表：",li)
li.clear()  
print("clear后的列表：",li)

运行结果：
原始列表： ['alex', [1, 2, 3], 'wusir', 'egon', '女神', 'taibai']
clear后的列表： []

④ del：删除列表

li = ['alex',[1,2,3],'wusir','egon','女神','taibai']
print("原始列表：",li)
del li   
print("del后的列表：",li)

运行结果：
原始列表： ['alex', [1, 2, 3], 'wusir', 'egon', '女神', 'taibai']
NameError: name 'li' is not defined

# 切片删除

li = ['alex',[1,2,3],'wusir','egon','女神','taibai']
print("原始列表：",li)
del li[2:] 
print("del切片删除后的列表：",li)

运行结果：
原始列表： ['alex', [1, 2, 3], 'wusir', 'egon', '女神', 'taibai']
del切片删除后的列表： ['alex', [1, 2, 3]]

（3）改：

li = ['alex',[1,2,3],'wusir','egon','女神','taibai']
print("原始列表：",li)
li[0:3] = [1,2,34,'春哥']
print("修改后的：",li)

运行结果：
原始列表： ['alex', [1, 2, 3], 'wusir', 'egon', '女神', 'taibai']
修改后的： [1, 2, 34, '春哥', 'egon', '女神', 'taibai']

（4）查

# 切片查找
list1 = ['physics', 'chemistry', 1997, 2000]
list2 = [1, 2, 3, 4, 5, 6, 7]

print("list1[0]: ", list1[0])
print("list2[1:5]: ", list2[1:5])   #顾头不顾尾

运行结果：
list1[0]:  physics
list2[1:5]:  [2, 3, 4, 5]

# 遍历
li = ['alex',[1,2,3],'wusir','egon','女神','taibai']
for i in li:
    print(i,end=' -- ')

运行结果：
alex -- [1, 2, 3] -- wusir -- egon -- 女神 -- taibai -- 

2、列表排序

li = [1,5,4,8,0,2,3]
print("原始列表：",li)
#正序排序【最快】
li.sort()
print("正序排序: ",li)

# 倒序排序
li.sort(reverse = True)
print("倒序排序: ",li)

# 反转
li.reverse()
print("对列表进行反转",li)

运行结果：
原始列表： [1, 5, 4, 8, 0, 2, 3]
正序排序:  [0, 1, 2, 3, 4, 5, 8]
倒序排序:  [8, 5, 4, 3, 2, 1, 0]
对列表进行反转 [0, 1, 2, 3, 4, 5, 8]

3、列表嵌套

def each_list(list_name):
    for yuansu in list_name:
        if isinstance(yuansu,list):
            each_list(yuansu)        # 嵌套
        else:
            print(yuansu)

li = [1,2,3,5,'alex',[2,3,4,'taibai'],'afds']
each_list(li)

运行结果：
1
2
3
5
alex
2
3
4
taibai
afds

4、列表函数 & 方法

Python包含以下函数:

li = ['taibai','武藤兰','sunxiansen','女神',['alex',2,3]]
print("原始列表：",li)
print("取第二个元素的第二个字符：",li[1][1])
print()

name = li[0].capitalize()   #只是找到,然后做了一些操作，就是“看戏”
print("使第一个元素的首字母大写：",name)
print("做了capitalize操作后li并没有发生改变：",li)
li[0] = name               # 真正修改了列表的值，开始“唱戏”
print("做了capitalize操作后,发生改变的li：",li)
print()

li[2] = li[2].replace('sen','生')      # replace(old, new)
print("做了replace操作后,发生改变的li：",li)

运行结果：
原始列表： ['taibai', '武藤兰', 'sunxiansen', '女神', ['alex', 2, 3]]
取第二个元素的第二个字符： 藤

使第一个元素的首字母大写： Taibai
做了capitalize操作后li并没有发生改变： ['taibai', '武藤兰', 'sunxiansen', '女神', ['alex', 2, 3]]
做了capitalize操作后,发生改变的li： ['Taibai', '武藤兰', 'sunxiansen', '女神', ['alex', 2, 3]]

做了replace操作后,发生改变的li： ['Taibai', '武藤兰', 'sunxian生', '女神', ['alex', 2, 3]]

====================================================================================================================================================================

 

Tuple（元组）

另一种有序列表叫元组：tuple。tuple和list非常类似，但是tuple一旦初始化就不能修改。

不可变的tuple有什么意义？因为tuple不可变，所以代码更安全。如果可能，能用tuple代替list就尽量用tuple。

# 只读列表：可循环查询，可切片，可连接
# 儿子不能改，孙子可能可以改

1、tuple的陷阱

（1）当定义一个tuple时，在定义的时候，tuple的元素就必须被确定下来：

>>> t = (1, 2)
>>> t
(1, 2)

（2）如果要定义一个空的tuple，可以写成：

>>> t = ()
>>> t
()

（3）如果要定义一个只有1个元素的tuple，必须这样写：

# 错误示例
>>> t = (1)
>>> t
1
#定义的不是tuple，是1这个数！这是因为括号()既可以表示tuple，又可以表示数学公式中的小括号，这就产生了歧义，因此，Python规定，这种情况下，按小括号进行计算，计算结果自然是1。

# 正确示例
# 只有1个元素的tuple定义时必须加一个逗号,，来消除歧义：
>>> t = (1,)
>>> t
(1,)

2、“可变的” tuple

# 儿子不能改，孙子可能可以改

>>> t = ('a', 'b', ['A', 'B'])
>>> t[2][0] = 'X'
>>> t[2][1] = 'Y'
>>> t
('a', 'b', ['X', 'Y'])

　　当我们把list的元素'A'和'B'修改为'X'和'Y'后，tuple变为：

 

　　表面上看，tuple的元素确实变了，但其实变的不是tuple的元素，而是list的元素。tuple一开始指向的list并没有改成别的list，所以，tuple所谓的“不变”是说，tuple的每个元素，指向永远不变。即指向'a'，就不能改成指向'b'，指向一个list，就不能改成指向其他对象，但指向的这个list本身是可变的！

3、访问tuple

tup1 = ('physics', 'chemistry', 1997, 2000)
tup2 = (1, 2, 3, 4, 5, 6, 7 )
 
print("tup1[0]: ", tup1[0])
print("tup2[1:5]: ", tup2[1:5])

运行结果：
tup1[0]:  physics
tup2[1:5]:  (2, 3, 4, 5)

4、连接（“修改”）tuple

tup1 = (12, 34.56)
tup2 = ('abc', 'xyz')
 
# 以下修改元组元素操作是非法的。
# tup1[0] = 100
 
# 创建一个新的元组
tup3 = tup1 + tup2
print(tup3)

运行结果：
(12, 34.56, 'abc', 'xyz')

5、删除 tuple

元组中的元素值是不允许删除的，但可以使用del语句来删除整个元组，如下实例:

tup = ('physics', 'chemistry', 1997, 2000)
 
print(tup)
del tup
print("After deleting tup : ")
print(tup)

运行结果：（输出变量会有异常信息）

('physics', 'chemistry', 1997, 2000)
After deleting tup :
Traceback (most recent call last):
  File "test.py", line 9, in <module>
    print tup
NameError: name 'tup' is not defined

6、tuple 运算符

7、tuple 内置函数

8、range() 函数

for i in range(3,10,2):
    print(i)
print('+++++++')
for j in range(10,0,-2):
    print(j)
print('='*8)
for k in range(0,10,-1):   #不会报错，没有运行结果
    print(k)

运行结果：
3
5
7
9
+++++++
10
8
6
4
2
========

====================================================================================================================================================================

 

Dict（字典）

字典是另一种可变容器模型，且可存储任意类型对象，是无序的。

字典的每个键值 key=>value 对用冒号 : 分割，每个键值对之间用逗号 , 分割，整个字典包括在花括号 {}

# 和list比较，dict有以下几个特点：
# 查找和插入的速度极快，不会随着key的增加而变慢（二分查找）；
# 需要占用大量的内存，内存浪费多。

# list相反：
# 查找和插入的时间随着元素的增加而增加；
# 占用空间小，浪费内存很少。

#所以，dict是用空间来换取时间的一种方法。

# 需要知道：
# 不可变数据类型（可哈希）：元组，bool，int，str ——  key
# 可变数据类型（不可哈希）：list，dict   ——  value

1、访问字典里的值

dic = {
    'name':['大梦','xiaomeng'],
    'py9':[{'人数':71,'age':18}],
    (1,2,3):'ergge'
}
print(dic["name"])
print(dic[(1,2,3)])

运行结果：
['大梦', 'xiaomeng']
ergge

dic1 = {'age':18,'name':'xiaohong','sex':'男'}
print(dic1)
print(dic1.keys(),type(dic1.keys()))
print(dic1.values(),type(dic1.values()))
print(dic1.items())          # 里边是元组，元组里边是“键，值”

运行结果：
{'age': 18, 'name': 'xiaohong', 'sex': '男'}
dict_keys(['age', 'name', 'sex']) <class 'dict_keys'>
dict_values([18, 'xiaohong', '男']) <class 'dict_values'>
dict_items([('age', 18), ('name', 'xiaohong'), ('sex', '男')])

如果用字典里没有的键访问数据，会输出错误如下：

dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'}
 
print "dict['Alice']: ", dict['Alice']

运行结果：
dict['Alice']: 
Traceback (most recent call last):
  File "test.py", line 5, in <module>
    print "dict['Alice']: ", dict['Alice']
KeyError: 'Alice'

# 要避免key不存在的错误，有两种办法

# 一是通过in判断key是否存在：
>>> 'Thomas' in dic
False

# 二是通过dict提供的get()方法，如果key不存在，可以返回None，或者自己指定的value【首选】：
# 注意：返回None的时候Python的交互环境不显示结果。
>>> dic.get('Thomas')
>>> dic.get('Thomas', -1)
-1

2、修改字典里的值

向字典添加新内容的方法是：增加新的键/值对，修改或删除已有键/值对

dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'}
dict['Age'] = 8 # 更新
dict['School'] = "RUNOOB" # 添加
 
print("dict['Age']: ", dict['Age'])
print("dict['School']: ", dict['School'])

运行结果：
dict['Age']:  8
dict['School']:  RUNOOB

3、删除字典元素

要删除一个key，用pop(key)方法，对应的value也会从dict中删除

# pop(key)方法


dic1 = {'age':18,'name':'xiaohong','sex':'男'}
dic1.pop('sex')
print(dic1.pop('sex','无此键'))   #可设置返回值
print(dic1)

运行结果：
无此键
{'age': 18, 'name': 'xiaohong'}

# popitem()方法：随机删除

dic1 = {'age':18,'name':'xiaohong','sex':'男'}
dic1.popitem()   # 有返回值，元组里面删除的是键值
print(dic1)

运行结果：
{'age': 18, 'name': 'xiaohong'}

# del 方法

del dic1['name']
print(dic1)
print()
del dic1
print(dic1)

运行结果：
{'age': 18, 'sex': '男'}

Traceback (most recent call last):
  File "F:/Python/Project/All_Stacks/01 基础/day5/dict.py", line 42, in <module>
    print(dic1)
NameError: name 'dic1' is not defined

# clear() 方法

dic1.clear()
print(dic1)

运行结果：
{}

===========================================================================================================================================

 

Set（集合）

set和dict类似，也是一组key的集合，但不存储value，{ }。

由于key不能重复，所以，在set中，没有重复的key，且没有顺序。

>>> s = set([1, 1, 2, 2, 3, 3])
>>> s
{1, 2, 3}

1、set基础操作

（1）增

set1 = {'alex','wusir','ritan','egon'}
set1.add('alex')    #不重复
set1.add('nvshen')  #无序
print(set1)

运行结果：
{'alex', 'egon', 'ritan', 'wusir', 'nvshen'}

（2）删

# pop()

set1 = {'alex','wusir','ritan','egon'}
print("pop前的集合：",set1)
set1.pop()                        #随机删除，返回删除的元素
print("pop后的集合：",set1)

运行结果：
pop前的集合： {'alex', 'egon', 'wusir', 'ritan'}
pop后的集合： {'egon', 'wusir', 'ritan'}

# remove()

print("remove前的集合：",set1)
set1.remove('alex')        #按元素删除，要删除的元素没有的话 报错
print("remove后的集合：",set1)

运行结果：
remove前的集合： {'wusir', 'alex', 'ritan', 'egon'}
remove后的集合： {'wusir', 'ritan', 'egon'}

# del

del set1
print(set1)

运行结果：
NameError: name 'set1' is not defined

（3）改

# 集合的"改"不存在，原因如下：①无序的 ②虽然集合是可变类型，但是集合中的元素(key)是不可变类型

（4）查

set1 = {'alex','wusir','ritan','egon'}
for i in set1:
    print(i)

运行结果：
wusir
ritan
alex
egon

2、做数学意义上的交集、并集等操作# set1 = {1,2,3}

# set2 = {1,2,3,4,5}
#--------------------(1)交集
# print(set1 & set2)
# print(set1.intersection(set2))

#--------------------(2)并集
# print(set1 | set2)
# print(set1.union(set2))

#--------------------(3)差集  【set1 - set2：set1独有的】
# print(set1 - set2)
# print(set1.difference(set2))

#--------------------(4)反交集
# print(set1 ^ set2)
# print(set1.symmetric_difference(set2))

#--------------------(5)子集与超集
# print(set1 < set2)
# print(set1.issubset(set2))   #这两个相同，说明set1是set2的子集

# print(set2 > set1)
# print(set2.issuperset(set1))  #这两个相同，说明set1是set2的超集

#--------------------(6)frozenset：变成不可变的数据类型

s1 = {1,2,3}
print(s1,type(s1))
s = frozenset('barry')   #只能”查“，不能”增 删 改“
print(s,type(s))
for i in s:
    print(i)

运行结果：

{1, 2, 3} <class 'set'>
frozenset({'r', 'b', 'a', 'y'}) <class 'frozenset'>
r
b
a
y

3、功能：去重

li = [1,2,3,5,6,33,5,6,2,1,33,4]
set1 = set(li)
print(set1)

运行结果：
{1, 2, 3, 33, 5, 6, 4}

补充：

1、slice()函数

• start -- 起始位置
• stop -- 结束位置
• step -- 间距

slice() 函数实现切片对象，主要用在切片操作函数里的参数传递。

>>>myslice = slice(5)    # 设置截取5个元素的切片
>>> myslice
slice(None, 5, None)
>>> arr = range(10)
>>> arr
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> arr[myslice]         # 截取 5 个元素
[0, 1, 2, 3, 4]

2、[ ] () {} set() 转换成bool值全是Null