列表、元组合字典
- 列表
- 列表的嵌套
- 元组
- 字典
- 字典的介绍
- 字典的常见操作
- 内置函数
- 内置方法
- dict.clear()删除字典内所有元素
- dict.copy()返回一个字典的浅复制
- dict2=dict.fromkeys(list) 创建一个新子典以序列的元素作为键,值作为字典的值
- dict.get('key',返回值)返回指定键的值,不存在则返回‘返回值’
- dict.items()返回可遍历
- dict.keys()返回一个字典的所有的键
- dict.setdefault(键名,值)如果键不存在字典,则添加键和值,如果在则输出字典的值
- dict.update(dict2)更新字典,重复的不更新
- dict.values()返回字典的所有值
- dict.pop('键','返回值')删除键,如果没有返回值
- dict.popitem()随机删除一对键值,并返回
- 字典的遍历
列表
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)