050.集合.特点.创建和删除_交集并集差集运算

集合

集合是无序可变，元素不能重复。

集合底层是字典实现，集合的所有元素都是字典中的【键】对象，因此是不能重复且唯一的。

集合创建和删除

1、使用{}创建集合对象，使用add（）方法添加元素

>>> a={12,45,78}
>>> a
{12, 45, 78}
>>> a.add(456)
>>> a
{456, 12, 45, 78}

2、使用set（）将列表、元祖等可迭代的对象转换为集合

>>> a=['a','b','c','d']
>>> b=set(a)
>>> b
{'d', 'c', 'b', 'a'}

集合是无序的。

3、remove（）删除指定元素；clear（）清空整个集合

>>> a={12,45,78,20,6,4}
>>> a.remove(45)
>>> a
{4, 6, 12, 78, 20}
>>> a.clear()
>>> a
set()

集合相关操作

像数学一样，Python对集合提供了并集、交集、差集等运算。

并集

>>> a={'a','b','zhu',1,3}
>>> b={'yu','a',13,'c','b',567}
>>> #并集操作
>>> a|b
{1, 3, 'a', 13, 'b', 'yu', 'c', 567, 'zhu'}
>>> a.union(b)
{1, 3, 'a', 13, 'b', 'yu', 'c', 567, 'zhu'}

交集

>>> #交集操作
>>> a&b
{'b', 'a'}
>>> a.intersection(b)
{'b', 'a'}

差集

差集也可以称为绝对补集，也就是说a中所有不属于b的叫做差集。

>>> #差集操作
>>> a-b
{'zhu', 1, 3}
>>> a.difference(b)
{'zhu', 1, 3}

}

047.字典、复杂表格数据存储、列表和字典综合嵌套

表格数据使用字典和列表存储，并实现访问

所有的数据本质上都是表格。

r1={"name":"张三","age":18,"salary":3000,"city":"北京"}
r2={"name":"李四","age":15,"salary":2000,"city":"上海"}
r3={"name":"张三","age":20,"salary":10000,"city":"深圳"} #字典创建每行
​
tb=[r1,r2,r3] #列表创建
​
#获得第二行的薪资
print(tb[1].get("salary"))
​
#打印所有人的薪资
for i in range(len(tb)):  #i---->0,1,2
    a=tb[i].get("salary")
    print(a)
​
#打印所有整个表格
for i in range(len(tb)):
    print(tb[i].get('name'),tb[i].get('age'),tb[i].get('salary'),tb[i].get('city'))
   

================== RESTART: F:/python程序/047_biaogezidian.py ==================
2000
3000
2000
10000
张三 18 3000 北京
李四 15 2000 上海
张三 20 10000 深圳

045.字典、元素的添加、修改、删除

1、给字典新增“键值对”

如果“键”已经存在，则覆盖。

否则就新增。

>>> a={'name':'zhuyu','age':18,'job':'student'}
>>> a['address']='陕西西安' #新增操作
>>> a
{'name': 'zhuyu', 'age': 18, 'job': 'student', 'address': '陕西西安'}
>>> a['age']=20 #覆盖操作
>>> a
{'name': 'zhuyu', 'age': 20, 'job': 'student', 'address': '陕西西安'}

2、使用update()

使用update()将新字典中所有键值对全部添加到旧字典对象上。

如果key重复，则覆盖。

>>> a={'name':'zhuyu','age':18,'job':'student'}
>>> b={'name':'zhuzhu','age':18,'job':'student','sex':'女'}
>>> a.update(b)
>>> a
{'name': 'zhuzhu', 'age': 18, 'job': 'student', 'sex': '女'}

3、使用del（）删除字典中的元素、clear（）删除所有键值对、pop（）删除指定键值对，并返回对应的’值对象‘

>>> a={'name':'zhuyu','age':18,'job':'student'}
>>> del(a['name'])
>>> a
{'age': 18, 'job': 'student'}
>>> b=a.pop('age') #删除指定对象并返回
>>> b
18
>>> a
{'job': 'student'}
>>> a.clear() #全部删除
>>> a
{}

4、popitem():随机删除和返回该键值对

适用于想一个一个移除并处理项（不用首先获得建键的列表）

>>> a={'name':'zhuyu','age':18,'job':'student'}
>>> a.popitem()
('job', 'student')
>>> a.popitem()
('age', 18)
>>> a.popitem()
('name', 'zhuyu')
>>> a
{}

046.字典_序列解包用于列表元组字典

序列解包

序列解包可用于元组、列表、字典。序列解包可以让我们方便对多个变量赋值。

>>> x,y,z=(20,30,40)
>>> x
20
>>> y
30
>>> z
40
>>> (a,b,c)=(7,8,9)
>>> a
7
>>> b
8
>>> c
9
>>> [c,d,b]=[10,20,30]
>>> c
10
>>> b
30
>>> d
20

字典中【序列解包】

序列解包用于字典时，默认对【键】进行操作。

>>> a={'name':'zhuyu','age':18,'job':'student'}
>>> a,b,c=a
>>> a
'name'
>>> b
'age'
>>> c
'job'

若需要对【值】进行操作，用到values()。

>>> a={'name':'zhuyu','age':18,'job':'student'}
>>> e,d,f=a.values()
>>> e
'zhuyu'
>>> d
18
>>> f
'student'

若需要对【键值对】进行操作，用到item()。

>>> a={'name':'zhuyu','age':18,'job':'student'}
>>> h,i,j=a.items()
>>> h
('name', 'zhuyu')
>>> i
('age', 18)
>>> j
('job', 'student')

042.元组.生成器推导式创建元组_总结

生成器推导使用的是小括号。

通过生成器对象，转化成列表或者元祖。

使用测试如下：

>>> s=(x*2 for x in range(5))#x乘以2的操作，循环生成0到4这五个数
>>> s
<generator object <genexpr> at 0x02CE47B0>
>>> tuple(s)
(0, 2, 4, 6, 8)
>>> tuple(s)#生成器只能访问一次，在访问就空了，因为是指针原理
()

可以用_ _next _ _( )提取元素

>>> s=(x*2 for x in range(5))
>>> s.__next__()#前后各两个下划线
0
>>> s.__next__()
2
>>> s.__next__()
4
>>> s.__next__()
6
>>> s.__next__()
8
#指针依次移动

元祖的特点

1. 元祖的核心特点：不可变序列

2. 元祖的访问和处理速度比列表快

3. 与整数和字符串一样，元祖可以作为字典的键，列表永远不能作为字典的键使用。

041.元组.元素访问.计数方法.切片操作.成员资格判断

元祖的元素访问和记数

1、元祖的元素不能修改

>>> a=(20,10,30,9,8)
>>> a[3]
9
>>> a[3]=100 #元祖对象不可修改
Traceback (most recent call last):
  File "<pyshell#21>", line 1, in <module>
    a[3]=100 #元祖对象不可修改
TypeError: 'tuple' object does not support item assignment

2、元祖的元素访问和列表一样，但是返回的仍然是元祖对象。

>>>a=tuple("asdlkjlkdjflaskdjflaskjdlkasjdkljlkjf")
>>> a
('a', 's', 'd', 'l', 'k', 'j', 'l', 'k', 'd', 'j', 'f', 'l', 'a', 's', 'k', 'd', 'j', 'f', 'l', 'a', 's', 'k', 'j', 'd', 'l', 'k', 'a', 's', 'j', 'd', 'k', 'l', 'j', 'l', 'k', 'j', 'f')
>>> a[1:10] #切片
('s', 'd', 'l', 'k', 'j', 'l', 'k', 'd', 'j')
>>> a[::-1] #和列表的访问一样
('f', 'j', 'k', 'l', 'j', 'l', 'k', 'd', 'j', 's', 'a', 'k', 'l', 'd', 'j', 'k', 's', 'a', 'l', 'f', 'j', 'd', 'k', 's', 'a', 'l', 'f', 'j', 'd', 'k', 'l', 'j', 'k', 'l', 'd', 's', 'a')
>>> a[:4]
('a', 's', 'd', 'l')

3、元祖排序，只能用内置函数sorted(tupleObj)

>>> a=(20,10,30,9,8)
>>> sorted(a)
[8, 9, 10, 20, 30]
#sorted()方法生成的是列表对象

4、元祖其他操作

>>> a=1,20
>>> b=30,40
>>> a+b#元祖的拼接
(1, 20, 30, 40)
>>> len(a)
2
>>> sum(b)
70
>>> max(a+b)
40

zip用法

zip（列表1，列表2，...）可以将多个列表对应位置的元素组合成为元祖，并返回zip对象。

>>> a=[10,20,30]
>>> b=[40,50,60]
>>> c=[70,80,90]
>>> d=zip(a,b,c)
>>> list(d) #zip对象转化为列表
[(10, 40, 70), (20, 50, 80), (30, 60, 90)]
>>> d#zip操作后，返回的是一个zip对象
<zip object at 0x02D04238>

040.元组.特点.创建的两种方式.tuple()要点

列表属于可变序列，可以修改其中元素。

元祖属于不可变序列。

元祖的创建

1、通过（）创建元祖，小括号可以省略。

>>> a=(10,20,30)
>>> a
(10, 20, 30)
>>> a=10,20,30 #不加小括号也可以
>>> a
(10, 20, 30)
​
>>> b=(20)
>>> b
20
#如果元祖中只有一个数，后面必须要加逗号。不然会默认为一个int整数。
>>> b=(20,) 
>>> b
(20,)

2、通过tuple（）创建元祖

tuple（可迭代的对象）

例如：

>>> c=tuple()#创建一个空的元祖对象
>>> c
()
>>> c=tuple("abc")#把字符串转化为元祖
>>> c
('a', 'b', 'c')
>>> c=tuple(range(3))
>>> c
(0, 1, 2)
>>> c=tuple([2,3,4])#把列表转化为元祖
>>> c
(2, 3, 4)

3、元祖对象的删除

del（删除对象）

>>> del c  #删除元祖c
>>> c
Traceback (most recent call last):
  File "<pyshell#17>", line 1, in <module>
    c
NameError: name 'c' is not defined

总结

• tuple（）可以接受列表、字符串、其他序列类型、迭代器等生成元祖。

• list（）可以接收元祖、字符串、其他序列类型、迭代器等生成列表。

039.列表.二维列表.表格数据的存储和读取

多位列表

二维列表

• 一维列表可以帮助存储一维、线性的数据。[10,20,30,40]

• 二维列表可以存储二维的、表格的数据，如：

  姓名	年龄	薪资	城市
  张三	18	3000	北京
  李四	15	2000	上海
  王五	20	10000	深圳

  a=[
  ​
      ["张三",18,3000,"北京"],
      ["李四",15,2000,"上海"],
      ["王五",20,10000,"深圳"]
      
      ]#创建二维列表
  >>> a
  [['张三', 18, 3000, '北京'], ['李四', 15, 2000, '上海'], ['王五', 20, 10000, '深圳']]

   

• 嵌套循环打印二维列表的所有数据

  a=[
  ​
      ["张三",18,3000,"北京"],
      ["李四",15,2000,"上海"],
      ["王五",20,10000,"深圳"]
      
      ]#创建二维列表
  ​
  for m in range(3):#行数
      for n in range(4):#列数
          print(a[m][n],end='\t')
          #每打印完一行打个制表符
  ​
      print()#打印完一行，打一行空行，换行

  结果如下

================== RESTART: F:/python程序/嵌套循环打印二维列表的所有数据.py ==================
张三  18  3000    北京  
李四  15  2000    上海  
王五  20  10000   深圳  
>>> 

038.列表。排序。revered逆序。max。min。sum

列表排序

修改原列表，不建新列表

1、升序排列

>>> a=[10,30,20,40,50,0,80,55]
>>> id(a)
47161752
>>> a.sort()#默认升序排列
>>> a
[0, 10, 20, 30, 40, 50, 55, 80]
>>> id(a)
47161752

2、降序排列

>>> a=[10,30,20,40,50,0,80,55]
>>> a.sort(reverse=True)#降序排列
>>> a
[80, 55, 50, 40, 30, 20, 10, 0]

3、随机排序

需要导入随机模块。

>>> import random #引入随机模块
>>> random.shuffle(a) #随机打乱顺序，可以用做洗牌
>>> a
[10, 30, 40, 50, 80, 20, 55, 0]
>>> random.shuffle(a) #打乱顺序
>>> a

创建新列表的排序

可以通过内置函数sorted()进行排序，会生成新的列表对象，对原有列表不做修改。

>>> a=[10,30,20,40,50,0,80,55]
>>> id(a)
19855120
>>> a=sorted(a)#默认升序排列
>>> a
[0, 10, 20, 30, 40, 50, 55, 80]
>>> id(a)
19854600
>>> c=sorted(a,reverse=True)#加反转，变降序
>>> c
[80, 55, 50, 40, 30, 20, 10, 0]
​

reversed()返回迭代器

内置函数reversed()也支持逆序排列，不对原列表做修改，返回逆序排列的迭代器。

迭代器是一个指针，从屁股后面往前指。

>>> a=[10,30,20,40,50,0,80,55]
>>> c=reversed(a)#c是迭代器
>>> c
<list_reverseiterator object at 0x02CEAE10>
>>> list(c)#用list函数转成列表
[55, 80, 0, 50, 40, 20, 30, 10]
>>> list(c)#迭代器只能用一次
[]

列表相关其他内置函数汇总

max和min

用于返回最大值和最小值。

>>> a=[10,30,20,40,50,0,80,55]
>>> max(a)
80
>>> min(a)
0
>>> a

sum求和

对数值型列表所有元素进行求和，对非数值型列表运算会报错。

>>> a=[10,30,20,40,50,0,80,55]
>>> sum(a)
285
>>> b=['a','c','f']
>>> sum(b)#非数值型列表会报错
Traceback (most recent call last):
  File "<pyshell#123>", line 1, in <module>
    sum(b)#非数值型列表会报错
TypeError: unsupported operand type(s) for +: 'int' and 'str'

037.列表_切片slice操作

切片的格式：

[起始偏移量 start：终止偏移量 end[:步长 step]]

当步长省略时，可以省略第二个冒号

典型案例（三个数都是正数）

>>> a=[10,20,30,40,50,60]
>>> a[:]#提取整个列表
[10, 20, 30, 40, 50, 60]
>>> a[1:3:1]#起始位置是1，终止位置是3，步长为1，搜索结果包头不包尾。
[20, 30]
>>> a[1::2]#从1位置开始取，找到末尾，步长为2
[20, 40, 60]
>>> a[1:]#从1位置开始全部取。
[20, 30, 40, 50, 60]
>>> a[:2]#2位置前面所有的
[10, 20]

其他操作（三个量为负数）

>>> a=[10,20,30,40,50,60,70]
>>> a[-3:]#从-3的位置开始找
[50, 60, 70]
>>> a[-5:-3]#从-5的位置开始到-3位置，搜索结果包头不包尾
[30, 40]
>>> a[::-1]#步长为负，反向提取
[70, 60, 50, 40, 30, 20, 10]

036.列表.元素的访问.元素出现次数统计.成员资格判断

1、通过索引直接访问

索引的区间在0到列表长度-1这个范围。

>>> a=[1,2,3,4,5,6,7]
>>> a[2]
3

2、index（）获得指定元素在列表中出现的首次索引

index（）可以获得指定元素首次出现的索引位置。

语法：index(value,[start,[end]])

其中start和end指定了搜索的范围。

>>> a=[1,2,3,4,5,6,7,1,2,3]
>>> a.index(3)
2
>>> a.index(3,5)
9
>>> #以上意思是搜3这个元素，从5的位置开始

3、count（）获得指定元素在列表中出现的次数

count()返回指定元素在列表中出现的次数。

>>> a=[1,2,3,4,5,6,7,1,2,3]
>>> a=a*5
>>> a
[1, 2, 3, 4, 5, 6, 7, 1, 2, 3, 1, 2, 3, 4, 5, 6, 7, 1, 2, 3, 1, 2, 3, 4, 5, 6, 7, 1, 2, 3, 1, 2, 3, 4, 5, 6, 7, 1, 2, 3, 1, 2, 3, 4, 5, 6, 7, 1, 2, 3]
>>> a.count(3)
10

4、len()返回列表长度

len()返回列表长度，即列表中包含元素的个数。

>>> a
[1, 2, 3, 4, 5, 6, 7, 1, 2, 3, 1, 2, 3, 4, 5, 6, 7, 1, 2, 3, 1, 2, 3, 4, 5, 6, 7, 1, 2, 3, 1, 2, 3, 4, 5, 6, 7, 1, 2, 3, 1, 2, 3, 4, 5, 6, 7, 1, 2, 3]
>>> len(a)
50

成员资格的判断

判断列表中是否存在指定元素。一般用in关键字来判断，返回TRUE或FALSE.

>>> a=[10,20,30,40,50]
>>> 20 in a
True
>>> 80 in a
False
>>> 80 not in a
True

035.列表元素删除的三种方式删除本质是数组元素拷贝

1、del删除

删除指定位置的元素。实际上是后面的元素依次拷贝至前一个位置。

>>> A=[100,200,888,300,400,500]
>>> A
[100, 200, 888, 300, 400, 500]
>>> del A[2]
>>> A
[100, 200, 300, 400, 500]

2、pop()方法

pop（）删除并返回指定位置元素，未指定则默认操作列表最后一个元素。

>>> a=[10,20,30,40,50]
>>> b=a.pop()
>>> B
Traceback (most recent call last):
  File "<pyshell#31>", line 1, in <module>
    B
NameError: name 'B' is not defined
>>> b
50
>>> b=a.pop()
>>> b
40
>>> b=a.pop()
>>> b
30
>>> b=a.pop()
>>> b
20
>>> b=a.pop()
>>> b
10
>>> a
[]
#一直删除最后一个元素，直至返回为空
>>> a=[10,20,30,40,50]
>>> c=a.pop(1)
>>> c
20
>>> a
[10, 30, 40, 50]
#也可以指定位置删除元素

3、remove（）方法

是针对元素的方法。

删除首次出现的指定元素，若不存在该元素抛出异常。

>>> a=[10,20,30,40,50,20,30,40]
>>> a.remove(20)
>>> a
[10, 30, 40, 50, 20, 30, 40]
>>> a.remove(30)
>>> a
[10, 40, 50, 20, 30, 40]
>>> a.remove(0)#不存在这个元素就会报错
Traceback (most recent call last):
  File "<pyshell#52>", line 1, in <module>
    a.remove(0)
ValueError: list.remove(x): x not in list

034.列表元素的5种添加方式效率问题

1、append（）方法

一般只在尾部添加或删除元素，这会大大增加提高列表的效率。速度最快，推荐使用。

>>> a=[20,40]
>>> a.append(80)
>>> a
[20, 40, 80]

2、+运算符操作

做了一个列表的拼接。涉及大量的复制操作。

>>> a=[20,40,90]
>>> id(a)
19855280
>>> a=a+[50]
>>> a
[20, 40, 90, 50]
>>> id(a)
47086408
#彻底产生了一个新的对象

3、extend（）方法

属于原地操作，不创建新的列表对象。

>>> a=[20,40]
>>> id(a)
19854960
>>> a.extend([50,60])
>>> id(a)
19854960
#原有列表扩展

4、insert()插入

使用insert（）可以将指定元素插入到任意位置，会让插入位置后的元素向后移动。尽量在涉及大量元素时，避免使用。

>>> a=[10,20,40]
>>> a.insert(2,100)#在2的位置插入100
>>> a
[10, 20, 100, 40]

5、乘法扩展

会生成一个新的列表，重复原有的元素。

>>> a=[20,30]
>>> a
[20, 30]
>>> a*4
[20, 30, 20, 30, 20, 30, 20, 30]

可变字符串

在python中，字符串属于不可变对象，不支持原地修改。

所以使用io.StringIO对象或array模块。

>>> import io
>>> a="hello,world"
>>> sio=io.StringIO(a)
>>> sio
<_io.StringIO object at 0x02CAAE40>
>>> #sio是可变的对象，可以调用或者修改
>>> sio.getvalue()
'hello,world'
>>> #修改字符串如下
>>> sio.seek(5)#括号里定位
5
>>> sio.write("...~~~")#括号里修改定位的地方
6
>>> sio.getvalue()
'hello...~~~'#可改1个字符，也可从定位处改多个。

字符串修改频繁时，可以考虑用io.StringIO类。

填充与对齐

^居中

<左对齐

>右对齐

eg1:

>>> "{:*>8}".format("245")
'*****245'

• ：后面带的填充的字符，"{:*>8}".代表8位数字，填充*，245右对齐。
• ：后面若不跟字符，说明填充空格。

eg2:

>>> "{:<9}".format("3456")
'3456     '

eg3:

>>> "{:+^9}".format("zhu")
'+++zhu+++'

数字格式化

浮点数f，整数d-->进行格式化

eg4:

>>> a="我是{0},我的存款有{1:.2f}"
>>> a.format("朱雨",3888.4123654)
'我是朱雨,我的存款有3888.41'

• :.2f保存2位浮点数

eg5:

>>> "{:0>10d}".format(3)
'0000000003'