python3 数据类型之 列表、字典、元组

数据类型

列表

• 组成元素 中括号 和 逗号
• 列表内的元素可以是不同类型
• 列表元素可改变，字符串不可以改变
  创建一个列表，只需要用逗号分隔不同的数据项，使用方括号括起来即可。列表内的数据类型可以不一样。

更新、删除列表元素

list[Number] = obj
del list[number]
del list
可以使用 加法 乘法 运算符拼接列表

>>> list1 = [1991,'alex','tom',2000]
>>> list1[2] = 2001
>>> list1
[1991, 'alex', 2001, 2000]

>>> del list1[2]
>>> list1
[1991, 'alex', 2000]

列表方法

1. 增加元素

   append() 方法一次只能添加一个元素,参数为具体值
   extend 方法的参数为列表

2. 删除元素

   pop() 方法，参数为下标 index
   remove() 方法，参数为元素的具体值

3. 排序、清空、复制

   reverse() 反向排序
   sort() 排序
   可以组合使用 list.sort(reverse=true)

   list.append(obj) 在列表末尾添加新的对象，只能添加一个

   list.count(obj) 统计某个元素在列表中出现的次数

   list.extend(seq) 在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）

   list.index(obj[start,end]) 从列表中找出某个值第一个匹配项的索引位置,start 表示起始索引值、end 表示结尾索引值

   list.insert(index,obj) 将对象插入列表,index索引，obj元素

   list.pop(index) 移除列表中的一个元素（默认最后一个），并且返回该元素的值。index 索引号 可选参数。

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

   list.reverse() 反向列表中的元素并保存

   list.sort([func,key,reverse]) 对原列表进行排序并保存，list.sort(reverse=true)

   list.clear() 清空列表

   list.copy() 复制列表

4. 列表分片 slice

语法： 列表名[索引:索引]   不包括后面的索引
member[1:3]
member[:3]   从索引 0 开始到索引 2
member[2:]   从索引 2 开始到结束
member[:]    拷贝一个列表，member2 = member[:]

赋值和分片复制的区别

list2 = list1[:]
list3 = list1

这两种情况，list2 是相对独立的一个列表，list3 是和 list1 同步的列表，也就是，如果修改 list3，list1 也会改变，而 list2 不变。

列表遍历

元素的索引值和对应值可以使用 enumerate() 同事得到

>>> list1 = ['wangbin','jianghang','wangqi','chenfeng']
>>> for i,v in enumerate(list1):
    print(i,v)


0 wangbin
1 jianghang
2 wangqi
3 chenfeng

按顺序遍历序列，使用 sorted 返回一个已排序的序列，不修改原值

>>> basket = ['apple', 'orange', 'apple', 'pear', 'orange', 'banana']
>>> for f in sorted(set(basket)):
...     print(f)
...
apple
banana
orange
pear

列表常用操作符

比较操作符

以第一个大小不同的数字进行比较，后面的不考虑。
>>> list = [123,999]
>>> list2 = [123,111]
>>> list < list2
False

逻辑操作符

>>> list3 = list[:]
>>> ( list < list2 ) and ( list == list3)
True

连接操作符

# 相加符号 + 左右两边的数据类型必须一致
>>> list4 = list + list2
>>> list4
[123, 456, 234, 234]

元组 tuple

• 关键成分小括号（可以没有），逗号（关键）
• 元组与列表类似，可以使用索引访问
• 不同之处在于元组内的元素不可改变！！！列表内的元素可以任意修改。
• 单个元素的元组，逗号必不可少

元组方法

元组只有 count 和 index 两个方法

tuple1.count(obj)  统计 obj 的个数
tuple1.index(obj)  返回 obj 的索引值

利用 split 更新删除元组的元素

更新元素
>>> tmp = ('laowang','gebi','wangdaye','wangshushu')
>>> tmp = tmp[:2] + ('uncle',) + tmp[2:]
>>> tmp
('laowang', 'gebi', 'uncle', 'wangdaye', 'wangshushu')

删除元素
>>> tuple2
(2, 123, 3, 'aaa')
>>> tuple2 = tuple2[0:1] + tuple2[3:]
>>> tuple2
(2, 'aaa')

元组运算符

下列运算符同样适用于列表

Python 表达式	结果	描述
len((1, 2, 3))	3	长度
(1, 2, 3 + (4, 5, 6)	(1, 2, 3, 4, 5, 6)	组合
(‘Hi!’) * 4	(‘Hi!’, ‘Hi!’, ‘Hi!’, ‘Hi!’)	重复
3 in (1, 2, 3)	True	元素是否存在于列表中
for x in [1, 2, 3]: print(x, end=” “)	1 2 3	迭代

>>> 5 * (8,)
(8, 8, 8, 8, 8)

字典

• 字典可存储任意类型
• 字典是 python 中唯一的映射类型。没有顺序概念，一个键对应一个值。字典不是序列类型，是映射类型
• 关键字可以是任意不可变类型，通常为字符串或数值
• 键 key 值 value 对用冒号隔开，不同的对用逗号分隔，整个字典用花括号。可以理解为无序的键值对的集合

dic_name = {'Name':'Bill','Age':'26','marriage':'single'}

• 键 可以是字符串、数字或元组，且必须不可变，键不可以是列表
• 同一个字典内不允许一个键出现两次，如果出现两次，前面的失效，后面的有效。
• 值 可以是任何数据类型，没有限制，可以是标准的对象、也可是是自定义的。

更新、删除、添加字典内元素

访问
dic_name['Name']

修改
dic_name['Name'] = 'Alex'

更新
dic_name['sex'] = 'Male'

删除
del dic_name['Sex']

dict() 函数直接构造字典

可以推导有固定模式的列表、字符串或元组到字典。

> dict([('sape', 4139), ('guido', 4127), ('jack', 4098)])

{'sape': 4139, 'jack': 4098, 'guido': 4127}

>>> dict(sape=4139, guido=4127, jack=4098)
{'sape': 4139, 'jack': 4098, 'guido': 4127}

字典推导还可以用来创建任意键值对的表达式字典

>>> {x: x**2 for x in (2, 4, 6)}
{2: 4, 4: 16, 6: 36}

字典常用方法

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

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

dict.get(key, default=None)   返回指定键的值，如果值不在字典中返回default值

dict.setdefault(key, default=None) 和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default，位置随机

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

dict.values()    以列表返回字典中的所有值

dict.items()   以列表的形式，返回可遍历的(键, 值) 元组数组

dict.update(dict2)   把字典dict2的键/值对更新到dict里

dict.pop(key[,default])    删除字典给定键 key 所对应的值，返回值为被删除的值。key值必须给出。 否则，返回default值。

get 方法寻找的 key 如果不存在，不会保存，会返回一个空值

pop() 方法会直接删除给定的键值对，popiterm() 方法会随机删除一个键值对

重点方法 =大师兄python
- dict.fromkeys(seq[, value]))

以 seq 中的元素做字典的键 key，value 做字典中的值 value
seq 字典中 键值 的列表
value 可选参数，设置键序列 seq 的值，value 值只能有一个

>>> dic1.fromkeys((1,2,3,4))
{1: None, 2: None, 3: None, 4: None}

# 后面只能有一个参数，如果是多个参数，并不会和前面的一一对应，而是认为是一个参数。

>>> dic1.fromkeys((1,2,3,4),'number')
{1: 'number', 2: 'number', 3: 'number', 4: 'number'}

seq = ('name', 'age', 'sex')

dict = dict.fromkeys(seq)
print ("新的字典为 : %s" %  str(dict))

dict = dict.fromkeys(seq, 10)
print ("新的字典为 : %s" %  str(dict))

结果

新的字典为 : {‘age’: None, ‘name’: None, ‘sex’: None}
新的字典为 : {‘age’: 10, ‘name’: 10, ‘sex’: 10}

• 
  
• dict.update(dict2)
  

把 dict2 里面的键值对添加到 dict1 里面

dict = {'Name': 'Runoob', 'Age': 7}
dict2 = {'Sex': 'female' }

dict.update(dict2)

字典遍历

参考字典方法 iterms()，关键字和对应的值，可以使用 iterms() 方法同事解读出来。

>>> for a, b in dic_test.items():
        print(a,b)

Name Bill
Age 26
marriage single
name laowang