Python （二）

目录

列表

range(start,end,step)创建整数列表

推导式生成列表

列表元素的增加和删除

append()方法

+运算符操作

extend()方法

insert()方法

乘法扩展

del删除

pop()方法

remove()方法

列表元素的访问和计数

通过索引直接访问元素

index()

count()

lenth()

成员资格判断

列表排序

sort()

sorted()

reversed()返回迭代器

元组tuple

元组的创建

1.通过（）创建元组，小括号可以省略

2.通过tuple()创建元组

3.生成器推导式创建元组

元组的元素访问和计数

sorted(tuple Obj)

zip()

元组总结

字典

字典的创建

1.通过{}或dict()

2.通过dict()和zip()

3.通过fromkeys创建值为空的字典

字典元素的访问

1.通过[键]获得值。

2.get()方法用键获得值

3.items()方法列出所有的键值对

4.keys() values()方法

5.in关键字检测一个“键”是否在字典中

字典元素添加、修改、删除

集合

集合的创建和删除

集合相关操作

---

列表

列表可以存储任意数目、任意类型的数据集合

Python的列表可变，根据需要随时增加或减（字符串和列表都是序列类型，一个是字符串一个是字符序列，一个列表是任何元素的序列。）

定义列表方式：[..........]

例子：[10,'abc',True]

range(start,end,step)创建整数列表

Python3中range()返回的是一个range对象，而不是列表。我们需要通过list()方法将其转换列表对象。

语法格式为：

range(start,end,step)

start：可选，表示起始数字

end：可选，表示结尾数字

step：可选，表示步长，默认为1

例子：

>>>list(range(3,15,2))

[3,5,7,9,11,13]

>>>list(range(15,3,-1))

[15,14,13,12,11,10,9,8,7,6,5,4]

推导式生成列表

>>>a=[x*2 for x in range(5)]#循环创建多个元素

>>>a

[0,2,4,6,8]

>>>a=[x*2 for x in range(100) if x%9==0] #通过if过滤元素

>>>a

[0,18,36,54,72,90,108,126,144,162,180,198]

列表元素的增加和删除

append()方法

原地修改列表对象，是真正的列表尾部添加新的元素，速度最快。

>>>a=[20,40]

>>>a.append(80)

>>>a

[20,40,80]

+运算符操作

并不是真正的尾部添加元素，而是创建新的列表对象；将原列表的元素和新列表的元素依次复制到新的列表对象中。这样，会涉及大量的复制操作，对于操作大量元素不建议使用。

>>>a=[20,40]

>>>id(a)

46016072

>>>a=a+[50]

>>>id(a)

46015432

extend()方法

将目标列表的所有元素添加到本列表的尾部，属于原地操作，不创建新的列表对象

>>>a=[20,40]

>>>id(a)

46016072

>>>a.extend([50,60])

>>>id(a)

46016072

insert()方法

在列表指定索引处加入指定元素

乘法扩展

使用乘法扩展列表，生成一个新列表，新列表元素时原列表元素的多次重复

>>>a=['wxx',100]

>>>b=a*3

>>>a

['wxx',100]

>>>b

['wxx',100,'wxx',100,'wxx',100]

del删除

删除指定索引处的元素

pop()方法

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

remove()方法

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

列表元素的访问和计数

通过索引直接访问元素

>>>a=[1,45,23,78]

>>>a[2]

23

index()

获得指定元素在列表中首次出现的索引

语法：index(value,start,end)

start和end指定了搜索的范围，可以不要，默认为全列表。

count()

获得指定元素在列表中出现的次数

lenth()

返回列表长度

成员资格判断

判断列表中是否存在指定的元素，我们可以使用count()方法，返回0则表示不存在，返回大于0则表示存在。但是，我们一般会使用更简洁的in（not in）关键字来判断，返回值是True或False

列表排序

sort()

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

>>>a=[20,10,30,40]

>>>a.sort()#默认是升序排列

>>>a

[10,20,30,40]

>>>a=[10,20,30,40]

>>>a.sort(reverse=True)#降序排列

>>>a

[40,30,20,10]

>>>import random

>>>random.shuffle(a)#打乱顺序

>>>a

[20,40,30,10]

sorted()

这个方法返回新列表，不对原列表做修改

>>>a=[20,10,30,40]

>>>id(a)

46016008

>>>a=sorted(a)#默认升序

>>>a

[10,20,30,40]

>>>id(a)

45907848

>>>a=[20,10,30,40]

>>>c=sorted(a,reverse=True)#降序

>>>c

[40,30,20,10]

reversed()返回迭代器

内置函数reversed()也支持进行逆序排列，与列表对象reverse()方法不用的是，内置函数reversed()不对原列表做任何修改，只是返回一个逆序排列的迭代器对象

>>>a=[20,10,30,40]

>>>c=reversed(a)

>>>c

<list_reverseiterator object at 0x0000000000002BCCEB8>

>>>list(c)

[40,30,10,20]

>>>list()

[]

元组tuple

元组属于不可变序列

元组支持以下操作

1. 索引访问
2. 切片操作
3. 连接操作
4. 成员关系操作
5. 比较运算操作
6. 计数：len()，max()，min()，sum()

元组的创建

1.通过（）创建元组，小括号可以省略

a=(10,20,30)或a=10,20,30

如果元组只有一个元素，则必须后面加逗号，这是因为解释器会把(1)解释为整数1，（1,）解释为元组。

>>>a=(1)

>>>type(a)

<class 'int'>

>>>a=(1,) #或者a=1,

 >>>type(a)

<class 'tuple'>

2.通过tuple()创建元组

tuple(可迭代的对象）

例如：

b=tuple() #创建一个空元组对象

b=tuple("Abc")

b=tuple(range(3))

b=tuple([2,3,4],[1,2,3])

tuple()可以接受列表，字符串，其他序列类型，迭代器等生成元组

list()可以接受元组，字符串，其他序列类型，迭代器等生成列表

3.生成器推导式创建元组

从形式上看，生成器推导式与列表推导式类似，只是生成器推导式使用小括号，列表推导式直接生成列表对象，生成器推导式生成的是生成器对象

我们可以通过生成器对象，转化成列表或者元组，也可以使用生成器对象的_next_()方法进行遍历，或者直接作为迭代器对象来使用，不管什么方式使用，元素访问结束后，如果需要重新访问其中的元素，必须重新创建改生成器对象

>>>s=(x*2 for x in range(5))

>>>s

<generator object <genexpr> at 0x0000000002BDEB48>

>>>tuple(s)

(0,2,4,6,8)

>>>list(s)     #只能访问一次元素，第二次就位空了。需要再生成一次

[]

>>>s=(x*2 for x in range(5))

>>>s._next_()

0

>>>s._next_()

2

>>>s._next_()

4

元组的元素访问和计数

元组的元素访问和列表一样，只不过返回的仍然是元组对象

sorted(tuple Obj)

并生成新的列表对象

>>>a=(20,10,30,9,8)

>>>sorted(a)

[8,9,10,20,30]

zip()

zip(列表1，列表2，列表3...)将多个列表对应位置的元素组合成为元组，并返回这个zip对象  

元组总结

1. 不可变
2. 访问和处理的速度要比列表快
3. 与整数和字符串一样，元组可以作为字典的键，列表则永远不能作为字典的键

字典

字典是键值对的无序、可变序列

“键”是任意的不可变数据，比如：整数、浮点数、字符串、元组。但是：列表、字典、集合这些可变对象，不能作为“键”，并且“键”不可重复

字典的创建

1.通过{}或dict()

>>>a={'name':'pcy','age':18,'job':'programmer'}

>>>b=dict(name='pcy',age=18,job='programmer'}

>>>c=dict([("name","pcy"),("age",18)])

2.通过dict()和zip()

>>>k=['name','age','job']

>>>v=['pcy',18,'singer']

>>>d=dict(zip(k,v))

>>>d

{'name':'pcy','age':18,'job':'singer'}

3.通过fromkeys创建值为空的字典

>>>a=dict.fromkeys(['name','age','job'])

>>>a

{'name':None,'age':None,'job':None}

字典元素的访问

1.通过[键]获得值。

若键不存在，则抛出异常

2.get()方法用键获得值

若键不存在则返回None；  但也可以设定指定键不存在时默认返回的对象

例如：

>>>a={'name':'pcy','age':18,'job':'singer'}

>>>a.get('sex','性别未知')

'性别未知'

3.items()方法列出所有的键值对

>>>a.items()

dict_items([('name','pcy'),('age',18),('job','singer')])

4.keys() values()方法

>>>a.keys()

dict_keys(['name','age','job'])

>>>a.values()

dict_values(['pcy',18,'singer'])

5.in关键字检测一个“键”是否在字典中

>>>a={''name'':''pcy'',''age'':18}

>>>"name" in a

字典元素添加、修改、删除

1.给字典新增“键值对”。如果“键” 已经存在则覆盖旧的键值对；如果“键”不存在，则新增“键值对”

2.使用updat()将新字典中所有键值对全部添加到旧字典对象上。如果有key重复，则直接覆盖

3.字典中元素的删除，可以使用del()方法；或者clear()删除所有键值对；pop()删除指定键值对，并返回对应的“值对象” 

 4.popitem()：随机删除和返回键值对。字典是“无序可变序列”，因此没有一个元素、最后一个元素的概念；popitem弹出随机的项，因为字典并没有“最后的元素”或者其他有关顺序的概念。若想一个接一个的移除并处理项，这个方法就非常有效（因为不用首先获取键的列表）

集合

集合是无序可变，元素不能重复。实际上，集合底层是字典实现，集合的所有元素都是字典中的“键对象”，因此是不能重复的且唯一的。

集合的创建和删除

1.使用集合对象，并使用add()方法添加新元素

 2.使用set()，将列表、元组等可迭代对象转成集合。如果原来数据存在重复数据，则只保留一个。

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

集合相关操作

像数学中概念一样，Python对集合也提供了并集，交集，差集等运算。我们给出示例：

并集：| 或 union()    交集：& 或 intersection()   差集：- 或 difference()

利用推导式创建元组，列表，字典，集合代码示例：