一、列表

1.无序和有序序列

无序:

  • 字典
  • 集合

有序:

  • 列表(可修改)
  • 元组(不可用)
  • 字符串

2.列表方法

extend、append、remove

注:reverse和sort是原地旋转,无返回值

3.extend()

将可迭代对象的元素加到列表后面。原地修改

x = [1, 2, 3]
x.extend([4, 5, 6])
print(x)
x = [1, 2, 3]
x.extend(range(4, 7))
print(x)

4.insert()元素添加到指定位置

如:list.insert(3,6),在list[3]位置插入元素6。

原地修改

注:insert()涉及插入位置后面元素的移动,会影响处理速度

5.list()转换其它类型为列表

可以转换的类型:可迭代对象(元组、字符串、range对象...)

6.列表元素添加:区别append()和+、extend()

+:不是真正为列表添加元素,内存变了

append():原地修改,内存不变

extend():内存也不变

7.用乘法扩展列表

1.内存变了

2.修改一个值后,相应的引用也变了

8.pop()和remove()

pop():按索引删除,默认删除最后一个元素,返回值为删除的值。

remove():按元素删除,删除首次出现的指定元素。返回值为空None。

共同点:pop()索引超出范围 或 remove()指定元素不存在 时,报异常

9.循环删除列表的同一元素,注意事项

remove()函数可以删除第一次出现的某个元素,但如果用循环remove()来删除列表中全部该元素,如下:

第二个错误的原因:存在连续的1,i对应的索引值是一开始的索引值,删了一个1后,python自动对列表内存进行搜索,之后的1的索引值就变了

10.列表元素的访问、index()

1.可以直接用下标来访问和修改列表中的某个元素

2.index():获取指定元素在指定范围首次出现的下标

index(元素,[start,stop])

列表、元组、字符串都能用index(),字典和集合不行。

注:start,stop是左闭右开;没找到则会报错。

比如:'a'在l[3]的位置

l = ['a','b','c','a','a']
print(l.index('a',3,4))
l = ['a','b','c','a','a']
print(l.index('a',2,3))

11.count()计数

适用于:可迭 适用于:列表、元组、字符串、range对象等,不适用于字典对象

l = ['a','b','c','a','a']
print(l.count('a'))

m = 'abcdaa'
print(m.count('a'))

12.in和not in

也可用于所有可迭代对象

13.切片

适用于:列表、元组、字符串、range对象等,不适用于字典对象

三个数字:起始位置(默认0),终止位置(默认最大长度),步长(默认为1)

l = [1,2,3,4,5]
print(l[::-1])
print(l[::2])
print(l[1:3])

注:

  • 下标越界不会报错,而是输出空列表
  • 切片不会改变内存(原地修改)

14.列表排序

列表函数 list.sort():原地排序,无返回值

  • 默认升序
  • 降序:list.sort(reverse=True)
  • 自定义排序:list.sort(key=lambda x:......)

python内置函数sorted(list):返回新列表,原列表不变

  • 降序:sorted(list,reverse=True)

专门的降序函数:

列表函数:list.reverse():原地

python内置函数:reversed(list):返回的是迭代对象

注:

系统内置的sorted()和reversed()区别:

不管是列表还是字符串等可迭代对象,sorted()返回的都是列表,reversed()返回的是可迭代对象。

这意味着a=sorted(list)能直接输出a,但 a=reversed(list)不能直接输出a,而是要输出list(a)或者tuple(a)....

l = [1,3,2,5,7,6]
a = sorted(l)
print(a)
b = reversed(l)
print(b)

15.zip()

将多个列表或元组 对应位置的元素 组合成 元组,返回 可迭代对象

长度取决于短的序列,如下:b列表中的7没了

a = [1,2,3]
b = [4,5,6,7]
m = zip(a,b)
print(list(m))

16.enumerate()

组合可迭代对象的(下标,元素值)的元组,返回 可迭代对象

a = ['a','b','c']
m = enumerate(a)
print(list(m))

17.列表推导式

a = [x * x for x in range(10)]
print(a)
#相当于
a = []
for x in range(10):
    a.append(x * x)
print(a)

二、元组

1.只包含一个元素的元组

不管是输出还是要创建 只含一个元素的元组,要在元素后面加一个","

a = (3)
b = (3,)
c = 1,2,3
print(type(a))
print(type(b))
print(type(c))
a = range(1)
print(tuple(a))
a = 3
print(tuple(a))

会报错,因为tuple()的参数要是一个可迭代对象,不能是int。

a = 3,
print(type(a))

“3,”这种格式是元组类型。

2.查找元组的元素

index():详见 一.10

列表、元组、字符串都能用index(),字典和集合不行。

2.del()

del命令能删除整个元组对象,不能删除元组的部分元素,因为元组不可变

3.元组和列表区别

  • 元组不能添加元素,因此没有append()、extend()、insert()等方法。
  • 元组不能删除元素,因此没有remove()、pop()方法
  • 元组也支持切片操作,但只能切片访问元素,不能修改元素。
  • 元组可以作为字典的key,列表不行。

4.元组中包含可变序列

虽然元组不能修改元素,但可以修改元组的可变序列元素里的元素

b = (3,[1,2,3])
b[1][0] = 100
print(b)

5.序列解包:同时对多个变量进行赋值

x, y = 1, 2

本质是元组的序列解包。

之前一直奇怪为什么这个式子会属于元组这一章节,之后了解到原来 x, y 以及 1, 2 这种形式属于元组类型。

而且列表和字典能序列解包

#列表的序列解包
[a,b,c] = 1,2,3
print(type(a),a)
print(type(b),b)
print(type(c),c)

但对字典序列解包时,默认对key操作,可用items()对键值对操作,values()对值操作。

调用函数时,实参前加星号*也能序列解包(将元素值依次传递给相同数量的形参),在第5章中有介绍。

6.生成器推导式

和列表推导式很像,只是生成器推导式使用的是"()"。

与列表推导式的区别:生成器推导式返回的是生成器对象,不是列表也不是元组。

对于生成器对象,可以转化为列表或元组,可以迭代,也可以用生成器对象的__next()__函数。

注:不管用哪种方法,生成器对象的数访问后就消失了,要想重新访问,需重新创建该生成器对象。

#元素访问后消失
a = (x for x in range(0,2))
print(tuple(a))
print(tuple(a))

生成器对象的__next()__函数,一次访问一个数,因为访问后元素会自动消失,所以每次调用的数都不同。

注:

  • 访问到最后为空时,继续next会报错
  • python3中是__next()__,python2中是next()。
#__next()__函数
a = (x for x in range(0,2))
print(a.__next__())
print(a.__next__())
print(a.__next__())

三.字典

1.字典的键

字典的键可以时任意 不可变数据,例如:数字,字符串,元组等。

不能用列表、集合、字典作为字典的键。

字典的键不允许重复,但值可以重复

2.globals()、locals()函数

  • globals():返回当前作用域下,所有 全局变量和值 的字典
  • locals() : 返回当前作用域下,所有 局部变量和值 的字典

3.字典创建与删除

a.直接赋值

a = {'q':1, 'w':2}

b.把已有的两个列表一 一对应结合成字典

使用zip()把两个列表组合在一起,因为返回的是zip对象,再用dict()把它转化为字典。

k = ['a','b']
v = [1,2]
c = dict(zip(k,v))

仔细看zip()返回和转化后的是啥。

#zip()相关
k = ['a','b']
v = [1,2]
c = zip(k,v)
print(c)
print(list(c))
c = zip(k,v)  #因为zip对象被访问后元素消失了,所以要重新生成一个zip对象
print(dict(c))

4.字典元素的读取

读取字典的值

  • 直接访问键:不存在时——报异常
  • get(键):不存在时——返回None

键和值

  • items():返回所有“键值对”的dict_items类型
  • keys():返回所有键 的dict_keys类型
  • values():返回所有值 的dict_values类型
x = {'a':1 , 'b':2}
print(x.items())
print(x.keys())
print(x.values())
x = {'a':1 , 'b':2}
for item in x.items():
    print(item)
for key, value in x.items():
    print(key, value)

5.字典元素添加

两种方法:指定“键”进行赋值;使用update()方法

  • 指定“键”进行赋值:若键存在,则修改对应的值;若不存在,则添加新的键值对
  • update():如 dict1.update(dict2),将dict2的键值对一次性加到dict1。(若dict1本身有该键,则其值会被dict2的值覆盖)

6.字典元素的删除

  • del命令:del dict[键],删除指定键的键值对
  • pop():dict.pop(键),删除指定键的键值对
  • clear():删除整个字典

四.集合

1. 是无序可变序列

2.列表不能作为集合的元素

和字典的“键”一样,集合的元素必须是不可变的,列表不能作为集合的元素

3.set()

将列表、元组等可迭代对象转换成集合,如果原数据有重复元素,会自动去重

注:set()也可以转换字典,生成只包含字典的键的集合。

dict1 = {'a':1 , 'b':2}
y = set(dict1)
print(y)

4.add()

集合特有的添加元素的方法,参数只有一个,因为集合无序,也就无所谓添加到哪个位置。

5.pop()

删除并返回集合中的一个元素。

注:集合无序,因此pop()不能指定位置,不能有参数。

6.remove()

删除集合指定元素。

7.集合的并交差、子集

a.并集

  • | :set1 | set2
  • union():set1.union(set2)

b.交集

  • & :set1 & set2
  • intersection():set1.intersection(set2)

c.差集

  • - :set1 - set2
  • difference():set1.difference(set2)

d.子集

issubset():set1.issubset(set2) 如果set1是set2的子集,返回True;否则返回False

8.用途——数据去重

python集合内部做了大量优化,因此去重操作使用集合能获得最高的执行效率。

9.集合推导式

和前面的列表推导式、生成器推导式、字典推导式 一样,集合推导式用的是"{}"

x = {x**2 for x in range(4)}
print(x)