列表、元组和字典

列表

python最基本的数据结构、最常用的数据类型。
创建一个列表，将逗号分隔开的不同数据项包括在方括号中。

person=['Xiao','Male',18]

列表的介绍

三种基本操作

访问列表元素

顺序访问

>>> list_1=[1,4,9,16,25]
>>> list_1[0]
1
>>> list_1[1]
4
>>> list_1[2]
9

逆序访问

>>> list_1=[1,4,9,16,25]
>>>> list_1[-1]
25
>>> list_1[-2]
16

连续访问

>>> list_1=[1,4,9,16,25]
>>> list_1[1:3]
[4, 9]
>>> list_1[4:5:6] #6不存在，输出后位数
[25]
>>> list_1[0:] # ：以后都输出
[1, 4, 9, 16, 25]
>>> list_1[-3:4] # 顺序、逆序均可输出
[9, 16]
>>> list_1[-1:4] #同一个数输出不了
[]

更新列表

append()添加元素

>>> list_1.append('hello')
>>> list_1.append('word')
>>> list_1
[1, 4, 9, 16, 25, 'hello', 'word']

加法添加元素

>>> list_1=list_1+['Flume','Kafka']
>>> list_1
[1, 4, 9, 16, 25, 'hello', 'word', 'Flume', 'Kafka']

指定位置修改列表元素

>>> list_1[0]='A'
>>> list_1
['A', 4, 9, 16, 25, 'hello', 'word', 'Flume', 'Kafka']
>>> list_1[1]='B'
>>> list_1
['A', 'B', 9, 16, 25, 'hello', 'word', 'Flume', 'Kafka']

指定多个位置修改列表元素

>>> list_1[2:3]=['C','D']
>>> list_1
['A', 'B', 'C', 'D', 16, 25, 'hello', 'word', 'Flume', 'Kafka']
>>>

删除列表元素del

>>> del list_1[0]
>>> list_1
['B', 'C', 'D', 16, 25, 'hello', 'word', 'Flume', 'Kafka']
>>> del list_1[0:]
>>> list_1
[]

列表的循环遍历

创建list表

>>> list=['a','b','c','d','e','f']
>>> list
['a', 'b', 'c', 'd', 'e', 'f']

按元素遍历

>>> for abc in list:
...     print(abc)   #cmd命令也要缩进
...
a
b
c
d
e
f

按下标遍历

>>> for abc in range(len(list)): #len计算list的长度
...     print(list[abc])
...
a
b
c
d
e

使用enumerate遍历

>>> for abc,val in enumerate(list):# val值
...      print("序号：%s  值:%s"  % (abc+1,val))
...
序号：1  值:a
序号：2  值:b
序号：3  值:c
序号：4  值:d
序号：5  值:e
序号：6  值:f

列表常见的操作

python列表的函数

表达式	结果	描述
len[1,2,3]	3	长度
[1,2,3,]+[4,5,6]	[1,2,3,4,5,6]	组合
[1,2,3,]*3	[1,2,3,1,2,3,1,2,3,]	重复
3 in[1,2,3]	true	元素是否存在列表
for x in[1,2,3]:print x	1 2 3	迭代

python列表的方法

格式：list.方法

方法	描述
append（obj）	列表末尾添加新对象
count(obj)	出现次数
extend(seq)	末尾追加另一表的多个值
index(obj)	第一个匹配项的索引位置
insert(index,obj)	将对象插入指定列表的指定位置
pop[index=-1]	移除列表的一个元素（默认最后一个），返回该值
remove(obj)	移除列表中的某一个值的第一个匹配项
reverse()	反向列表元素
sort(cmp=None,key=None,reverse=Flase)	对原表进行排序

测试区

创建list表

>>> list=['a','b','c','d','e','f']
>>> list
['a', 'b', 'c', 'd', 'e', 'f']
>>> list_1=['1','2','3','4']
>>> list_1
['1', '2', '3', '4']

开始测试

list.append(obj)末尾添加新对象

>>> list.append('g')	
>>> list
['a', 'b', 'c', 'd', 'e', 'f', 'g']

list.count(obj)出现次数

>>> list.count('b')		
1

list.extend(表)末尾追加另一表的多个值

>>> list.extend(list_1)		
>>> list
['a', 'b', 'c', 'd', 'e', 'f', 'g', '1', '2', '3', '4']

list.index(obj)第一个匹配项的索引位置

>>> list.index('c')
2

list.insert(index，obj)将对象插入指定列表的指定位置

>>> list.insert(0,'99')
>>> list
['99', 'a', 'b', 'c', 'd', 'e', 'f', 'g', '1', '2', '3', '4']
>>> list.insert(0,'1')
>>> list
['1', '99', 'a', 'b', 'c', 'd', 'e', 'f', 'g', '1', '2', '3', '4']

list.pop()移除列表的一个元素（默认最后一个），返回该值

>>> list.pop()
'4'
>>> list
['1', '99', 'a', 'b', 'c', 'd', 'e', 'f', 'g', '1', '2', '3']
>>> list.pop(1)
'99'
>>> list
['1', 'a', 'b', 'c', 'd', 'e', 'f', 'g', '1', '2', '3']
>>> list.pop(-1)
'3'
>>> list
['1', 'a', 'b', 'c', 'd', 'e', 'f', 'g', '1', '2']

list.remove( )移除列表中的第一个匹配项

>>> list.remove('1')
>>> list
['a', 'b', 'c', 'd', 'e', 'f', 'g', '1', '2']

list.reverse( )反向列表元素

>>> list.reverse()
>>> list
['2', '1', 'g', 'f', 'e', 'd', 'c', 'b', 'a']
>>> list.reverse()
>>> list
['a', 'b', 'c', 'd', 'e', 'f', 'g', '1', '2']

sort( )排序

>>> list.sort()
>>> list
['1', '2', 'a', 'b', 'c', 'd', 'e', 'f', 'g']

列表的嵌套

列表的元素可以包含另一个列表

什么是列表嵌套

创建两个列表

>>> list_1=['I am a inner list']
>>>> list_2=['I am a outer list']
>>>> list_1, list_2
(['I am a inner list'], ['I am a outer list'])

简单嵌套

>>> list_2.append(list_1)
>>> list_2
['I am a outer list', ['I am a inner list']]

列表嵌套案例

# 导入随机数模块
import random
# 定义三个list
school_team=[[],[],[]]
# 建立学生list
student_names=["李小明","王华","吴小莉","张三","李四","牛二","王五","吴六"]
>>>for name in student_names:
>>>    # 下标0~2
>>>    team_number=random.randint(0,2)
>>>    school_team[team_number].append(name)
>>>for i in school_team:
>>>    print(i)
>

元组

元组介绍

元组元素不可修改，使用小括号。
主要作用：作为参数传递给函数调用，或是从函数调用处获得参数时，保护其内容不被外部修改。

元组的创建和访问

>>> tuple_1=(1,'physics',98)
>>> tuple_2=()
>>> tuple_3=(1,)
>>> tuple_1[0]
1
>>> tuple_1[1]
'physics'
>>> tuple_1[2]
98

元组内置函数

函数	描述
len(tuple)	计算元组个数
max(tuple)	返回元组中元素最大值
min(tuple)	返回元组中元素最小值
tuple(seq)	将列表转为元组

len(tuple) 计算元组个数

>>> len(tuple_1)
3

max(tuple) 返回元组中元素最大值

>>> max(tuple_3)
1

min(tuple) 返回元组中元素最小值

>>> min(tuple_3)
1

tuple(seq) 将列表转为元组

>>> list=[1,2,3]
>>> tuple(list)
(1, 2, 3）

字典

通过名字或关键字引用的数据结构。
键不重复出现，但是不同键对应的值可以相同。

字典的介绍

创建字典

>>> tel_book={'Alince':'2341','Beth':'9102','Cecil':'3258'}
>>> tel_book
{'Alince': '2341', 'Beth': '9102', 'Cecil': '3258'}

键名访问

>>> tel_book['Alince']
'2341'

修改已有属性

>>> tel_book['Beth']=tel_book['Beth']+'1000' # ‘这里面是字符串str’
>>> tel_book
{'Alince': '2341', 'Beth': '91021000', 'Cecil': '3258'}

添加、删除属性

>>> del tel_book['Alince']
>>> tel_book
{'Beth': '91021000', 'Cecil': '3258'}
>>> tel_book['Beth']=0000
>>> tel_book
{'Beth': 0, 'Cecil': '3258'}

字典的常见操作

内置函数

函数	描述
cmp(dict1,dict2)	比较两个字典元素
len(dict)	计算键的总数
str（dict）	输出字典字符串
type(variable)	返回输入的变量类型

测试

 >>> dict1={'a':1}
>>> dict1
{'a': 1}
>>> len(dict1)
1
>>> str(dict1)
"{'a': 1}"
>>> type(dict1)
<class 'dict'>

内置方法

创建字典

>>> dict={'a':1,'b':2,'c':3}
>>> dict
{'a': 1, 'b': 2, 'c': 3}

方法	描述
dict.clear()	删除字典内所有元素
dict.copy()	返回一个字典的浅复制
dict2=dict.fromkeys(list)	创建一个新子典以序列的元素作为键，值作为字典的值
dict.items()	返回可遍历
dict.keys()	返回一个字典的所有的键
dict.setdefault(key，val）	如果键不存在字典，则添加键和值，如果在则输出字典的值
dict.update(dict2)	更新字典，重复的不更新
dict.pop(‘键’，‘返回值’)	删除键，如果没有返回值
dict.popitem()	随机删除一对键值，并返回

dict.clear()删除字典内所有元素

>>> dict.clear()
>>> dict
{}

dict.copy()返回一个字典的浅复制

>>> dict.copy()
{'a': 1, 'b': 2, 'c': 3}

dict2=dict.fromkeys(list) 创建一个新子典以序列的元素作为键，值作为字典的值

>>> list=[4,5,6,7]
>>> list
[4, 5, 6, 7]
>>> dict2=dict.fromkeys(list)
>>> dict2
{4: None, 5: None, 6: None, 7: None}

>> dict2=dict.fromkeys(list,'val')
>>> dict2
{4: 'val', 5: 'val', 6: 'val', 7: 'val'}
>>> dict2=dict.fromkeys(list,'')
>>> dict2
{4: '', 5: '', 6: '', 7: ''}

dict.get(‘key’，返回值)返回指定键的值，不存在则返回‘返回值’

>>> dict.get('a')
1
>>> dict.get('b')
2
>>>> dict.get('h') #无返回值
>>> dict.get('h',1)
1

dict.items()返回可遍历

>>> dict.items()
dict_items([('a', 1), ('b', 2), ('c', 3)])

dict.keys()返回一个字典的所有的键

>>> dict.keys()
dict_keys(['a', 'b', 'c'])

dict.setdefault(键名，值)如果键不存在字典，则添加键和值，如果在则输出字典的值

>>> dict.setdefault('c','4')
3
>>> dict
{'a': 1, 'b': 2, 'c': 3}
>>> dict.setdefault('d','4')
'4'
>>> dict
{'a': 1, 'b': 2, 'c': 3, 'd': '4'}

dict.update(dict2)更新字典，重复的不更新

>>> dict2={'e':5}
>>> dict.update(dict2)
>>> dict
{'a': 1, 'b': 2, 'c': 3, 'd': '4', 'e': 5}
>>> dict2={'e':5,'f':6}
>>> dict.update(dict2)
>>> dict
{'a': 1, 'b': 2, 'c': 3, 'd': '4', 'e': 5, 'f': 6}

dict.values()返回字典的所有值

>>> dict.values()
dict_values([1, 2, 3, '4', 5, 6])

dict.pop(‘键’，‘返回值’)删除键，如果没有返回值

>>> dict.pop('f')
6
>>> dict
{'a': 1, 'b': 2, 'c': 3, 'd': '4', 'e': 5}
>>> dict.pop('f','no')
'no'
>>> dict
{'a': 1, 'b': 2, 'c': 3, 'd': '4', 'e': 5}

dict.popitem()随机删除一对键值，并返回

>>> dict.popitem()
('e', 5)
>>> dict
{'a': 1, 'b': 2, 'c': 3, 'd': '4'}
>>> dict.popitem()
('d', '4')
>>> dict
{'a': 1, 'b': 2, 'c': 3}

字典的遍历

>>> dict={'A':0,'B':1,'C':2,'D':3,'E':4}
>>> dict
{'A': 0, 'B': 1, 'C': 2, 'D': 3, 'E': 4}

键遍历

>>> for key in dict:
...     print(key,dict[key])
...
A 0
B 1
C 2
D 3
E 4

值遍历

>>> for value in dict.values():
...     print(value)
...
0
1
2
3
4

键、值遍历

>>> for item in dict.items():
...     print(item)
...
('A', 0)
('B', 1)
('C', 2)
('D', 3)
('E', 4)