python自学 序列day02

元素的增加和删除

1. append()方法
   不创建新的对象，在原来的末尾加，速度最快

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

2. +运算符操作
   用这个创建新的对象

>>> a = [20,40]
>>> id(a)
2220727413256
>>> a = a + [20]
>>> a
[20, 40, 20, 20]
>>> id(a)
2220727412616

3. extend()方法
   将目标列表的所有元素添加到本列表尾部。不创建新对象，效率高

>>> a.extend([10,20,20])
>>> a
[20, 40, 20, 20, 30, 20, 10, 20, 20]
>>> 

insert()插入元素
将元素插入到任意位置，会让后面的所有元素移动，影响处理速度
6.乘法扩展

>>> a = [20,10]
>>> a*3
[20, 10, 20, 10, 20, 10]

列表元素的删除

1. del删除

删除指定元素
后面的拷贝到前面

>>> a
[20, 10, 20, 10, 20, 10]
>>> del a[2]
>>> a
[20, 10, 10, 20, 10]

2. pop()方法

删除并返回指定位置元素

3.rmove()方法

删除首次出现的元素，若不存在，抛出异常。直接搜的元素，不是索引

>>> a
[20, 10, 20]
>>> a.remove(10)
>>> a
[20, 20]

列表元素的访问和计数

1. 通过索引
   a[]
2. index()获得指定元素在列表中首次出现的索引
   a.index(value,start,end)，其中start和end指定了搜索的范围
3. count()获得指定元素在列表中出现的次数
4. len()返回列表的长度
5. 成员资格判断，
   判断是否存在，可以用in
   也可以count（）是否大于零，一般比较麻烦

切片操作
slice（）

列表排序
修改原列表，不建新

>>> a = [20,51,84,21]
#升序
>>> a.sort()
>>> a
[20, 21, 51, 84]
#降序
>>> a.sort(reverse=True)	
>>> a
[84, 51, 21, 20]
#乱序
>>> import random
>>> random.shuffle(a)
>>> a
[51, 21, 20, 84]

新建列表的排序
1.通过内置函数sorted()进行排序，返回新列表，不对原列表做修改
sorted（）默认升序
2.reversed()返回迭代器
只能使用一次，指针过一遍

max最大值
min最小值
sum求和

多维列表，相当多维数组

元祖
元祖属于不可变序列。不能修改元祖中的元素，列表是可变的序列
元祖的创建
1.通过（）创建元祖。小括号可以省略
如果只有一个，那必须后面加逗号。不然解释器会吧（1）当做整数，（1，）这为元祖
2.通过tuple()创建。（和列表的list一样）
元祖对象的删除del

元祖的访问和切片登内容个列表差不多
在排序的时候只能使用内置函数sorted（）

zip（列表1，列表2，…）将多个压到一起

生成器推导式创建元祖（和列表一样。只不过是用（），列表用[]）

移动指针__next__()调用指针移动

---

字典

---

字典是"键值对"的无序可变序列，每个元素都是一个键值对，包含：“键对象”和“值对象”。（和map相当）
1.字典的创建

1. 可以通过{},dict()来创建字典对象

>>> a = {"name":"angj","age":14}
>>> a
{'name': 'angj', 'age': 14}
>>> b = dict(name='ajfd',age = 14)
>>> b
{'name': 'ajfd', 'age': 14}
>>> b = dict([("name","yangj"),("age",14)])
>>> b
{'name': 'yangj', 'age': 14}

创建空的不填即可

2. 通过zip（）创建

>>> k=["a","b","c","d"]	#创建建
>>> v=[100,200,300,400]	#创建值
>>> d = dict(zip(k,v))	#顺序不能乱
>>> d
{'a': 100, 'b': 200, 'c': 300, 'd': 400}

3. 通过formkeys()创建值为空的字典

>>> a = dict.fromkeys(['name','age','job'])
>>> a
{'name': None, 'age': None, 'job': None}

键值对的访问

>>> d
{'a': 100, 'b': 200, 'c': 300, 'd': 400}
#访问键值
>>> d["a"]
100

#如果键值不存在，报错
>>> d["ddd"]
Traceback (most recent call last):
  File "<pyshell#36>", line 1, in <module>
    d["ddd"]
KeyError: 'ddd'

#get()方法获取
>>> d.get("a")
100

#不存在返回None
>>> print(d.get("dsds"))
None

#不存在。自定义返回值
>>> d.get("asdf","不存在")
'不存在'

#列出所有键值对
>>> d.items()
dict_items([('a', 100), ('b', 200), ('c', 300), ('d', 400)])

#列出所有的键，值
>>> d.keys()
dict_keys(['a', 'b', 'c', 'd'])
>>> d.values()
dict_values([100, 200, 300, 400])

#字典的个数
>>> len(d)
4

判断是否在字典
>>> "a" in d
True

字典元素的添加，修改，删除
1,给字典新增“键值对”，若存在，覆盖，不存在，新增

a = {“name”:“xiaoming”,“age”:“13”}
a
{‘name’: ‘xiaoming’, ‘age’: ‘13’}

a[“game”]=90
a
{‘name’: ‘xiaoming’, ‘age’: ‘13’, ‘game’: 90}

a[“name”]=“jie”
a
{‘name’: ‘jie’, ‘age’: ‘13’, ‘game’: 90}

2.使用update()将新字典所有键值对都添加到旧的上，如果有重复，则直接覆盖

a {“name”:“xiaoming”,“age”:“13”}
b = dict([(‘name’,‘xiao’),(‘a’,‘sdf’)])
b
{‘name’: ‘xiao’, ‘a’: ‘sdf’}

a.update(b)
a
{‘name’: ‘xiao’, ‘age’: ‘13’, ‘game’: 90, ‘a’: ‘sdf’}

3.字典元素的删除，

a
{‘name’: ‘xiao’, ‘age’: ‘13’, ‘game’: 90, ‘a’: ‘sdf’}

del(a[‘name’])#删除指定的对象
a
{‘age’: ‘13’, ‘game’: 90, ‘a’: ‘sdf’}

a.pop(‘age’)#删除并返回这个值
‘13’

a.clear()#清空元素
a
{}

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

b
{‘name’: ‘xiao’, ‘a’: ‘sdf’}

b.popitem()
(‘a’, ‘sdf’)

b.popitem()
(‘name’, ‘xiao’)

b.popitem()#没有时报错
Traceback (most recent call last):
File “<pyshell#25>”, line 1, in
b.popitem()
KeyError: ‘popitem(): dictionary is empty’

序列解包可以用于元祖，列表，字典

集合
集合是无序可变，元素不能重复。实际上集合的底层是字典的实现，集合所有的元素都是字典中的“键对象”，因此是不能重复的唯一的
1.使用{}创建对象
2.使用set()，将列表，元祖的可迭代对象转成集合，如果原来存在重复数据。则只保留一个

>>> a = [12,1,1,2,2,33]
>>> b = set(a)
>>> b
{1, 2, 12, 33}

3.remove()删除指定元素。clear()清空整个集合

集合的相关操作

>>> a = {'a','b','c',1,2,3}
>>> b = {'a','d','e',2,5,8}
#并集
>>> a|b
{1, 2, 3, 5, 8, 'd', 'b', 'a', 'c', 'e'}
>>> a.union(b)
{1, 2, 3, 5, 8, 'd', 'b', 'a', 'c', 'e'}
#交集
>>> a&b
{2, 'a'}
>>> a.intersection(b)
{2, 'a'}
#差集
>>> a - b
{'c', 1, 3, 'b'}
>>> a.difference(b)
{'c', 1, 3, 'b'}