Python之路（三）：基本数据类型（下）

元祖tuple

　　　是对列表的二次加工，书写格式为括号（），里面放元素

　　　元组的一级元素不可被修改，且不能被增加和删除

　　　一般写元组的时候，推荐在最后加入逗号, 　　能加则加

创建元组

1
tu = (111,"alex",(11,22),[(33,44)],True,33,44,)

索引

1
2
3
tu = (111,"alex",(11,22),[(33,44)],True,33,44,)　　　　# 索引找值
v = tu[1]
print(v)<br><br>alex

切片

1
2
3
tu = (111,"alex",(11,22),[(33,44)],True,33,44,)　　　　# 切片，区间内找值
v = tu[0:3]
print(v)<br><br>(111, 'alex', (11, 22))

可以被for循环（可迭代对象）

1
2
3
4
5
6
7
8
9
10
tu = (111,"alex",(11,22),[(33,44)],True,33,44,)
for item in tu:
    print(item)
 
111
alex
(11,22)
[(33,44)]
True
44

有序的，排列的时候有顺序

  • 转换(字符串，列表，元祖之间的转换)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
s = "asd"
li = ["asdf",123]
tu = (123,321,"asdf")
v = tuple(s)
print(v)
v1 = tuple(li)
print(v1)
v2 = list(tu)
print(v2)
 
# 输出结果
('a', 's', 'd')
('asdf', 123)
[123, 321, 'asdf']

元组运算符

与字符串一样，元组之间可以使用 + 号和 * 号进行运算。这就意味着他们可以组合和复制，运算后会生成一个新的元组。

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, 1 2 3 迭代

tuple的方法（魔法）

序号方法及描述实例
1 len(tuple)
计算元组元素个数。		 
>>> tuple1 = ('Google', 'Baidu', 'Taobao')
>>> len(tuple1)
3
>>>
2 max(tuple)
返回元组中元素最大值。		 
>>> tuple2 = ('5', '4', '8')
>>> max(tuple2)
'8'
>>>
3 min(tuple)
返回元组中元素最小值。		 
>>> tuple2 = ('5', '4', '8')
>>> min(tuple2)
'4'
>>>
4 tuple(seq)
将列表转换为元组。		 
>>> list1= ['Google', 'Taobao', 'JD', 'Baidu']
>>> tuple1=tuple(list1)
>>> tuple1
('Google', 'Taobao', 'Runoob', 'Baidu')

 　　　　

字典dict

是一个键（key）值（value）对，结构为{}，大括号

创建字典

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
info = {　　　　　　　　　　　　　　　　# k1 k2 k3 k4为键　　　　　　　　　　　　　　　　　　　　　　
    "k1": 18,　　　　　　　　　　　　　# ：后面分别为值　　　　逗号为分隔符
    "k2": True,                     # 数字，布尔值也可以作为键
    "k3": [
        11,
        [],
        (),
        22,
        33,
        {
            'kk1': 'vv1',
            'kk2': 'vv2',
            'kk3': (11,22),
        }
    ],
    "k4": (11,22,33,44)
 
}

字典的值可以是任何值

  • 列表，字典不能作为字典的key
  • 字典是无序的
  • 字典不能被切片，因为它是无序的；可根据索引取值，查找，找到元素
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
info = {
    "k1": 18,
    "k2": True,
    "k3": [
        11,
        [],
        (),
        22,
        33,
        {
            'kk1': 'vv1',
            'kk2': 'vv2',
            'kk3': (11,22),
        }
    ],
    "k4": (11,22,33,44)
 
}
v = info['k1']
print(v)
 
$ 18

字典是支持del 删除的

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
info = {
    "k1": 18,
    "k2": True,
    "k3": [
        11,
        [],
        (),
        22,
        33,
        {
            'kk1': 'vv1',
            'kk2': 'vv2',
            'kk3': (11,22),
        }
    ],
    "k4": (11,22,33,44)
 
}
del info['k1']
print(info)
 
 
$ {'k4': (11, 22, 33, 44), 'k3': [11, [], (), 22, 33, {'kk1': 'vv1', 'kk3': (11, 22), 'kk2': 'vv2'}], 'k2': True}

支持for循环

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
info = {
    "k1": 18,
    "k2": True,
    "k3": [
        11,
        [],
        (),
        22,
        33,
        {
            'kk1': 'vv1',
            'kk2': 'vv2',
            'kk3': (11,22),
        }
    ],
    "k4": (11,22,33,44)
 
}
for item in info:
    print(item)
 
 
$ k4
$ k2　　　　　　　　　info是字典类型
$ k1    　　　　　　　默认for循环只有key
$ k3                但是输出结果键每次排序都不同，因为字典是无序的

用for循环获取值values

1
2
3
4
5
6
7
8
9
代码接上
for item in info.values():
    print(item)
 
 
$ (11, 22, 33, 44)
$ [11, [], (), 22, 33, {'kk3': (11, 22), 'kk2': 'vv2', 'kk1': 'vv1'}]
$ True
$ 18                           

既想获取key又想获取value则用items

1
2
3
4
5
6
7
8
9
代码接上
for item in info.items():
    print(item)
 
                                     # keys和values都可以获得
$ ('k1', 18)
$ ('k4', (11, 22, 33, 44))
$ ('k2', True)
$ ('k3', [11, [], (), 22, 33, {'kk2': 'vv2', 'kk3': (11, 22), 'kk1': 'vv1'}])                   

字典的方法（魔法）

 

序号函数及描述
1 dict.clear()
删除字典内所有元素
2 dict.copy()
返回一个字典的浅复制
3 dict.fromkeys()
创建一个新字典，以序列seq中元素做字典的键，val为字典所有键对应的初始值
4 dict.get(key, default=None)
返回指定键的值，如果值不在字典中返回default值
5 key in dict
如果键在字典dict里返回true，否则返回false
6 dict.items()
以列表返回可遍历的(键, 值) 元组数组
7 dict.keys()
以列表返回一个字典所有的键
8 dict.setdefault(key, default=None)
和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default
9 dict.update({'k1':'v1'} OR k1=v1)
把字典dict2的键/值对更新到dict里
10 dict.values()
以列表返回字典中的所有值
11

dict.popitem()

随机删除，并获取删除的键值以元组形式返回

集合set

基本数据类型特点（可变：列表，字典 　　不可变：字符串，数字，元组）

  • 不同的元素组成
  • 无序
  • 集合中的元素必须是不可变类型，加入可变的类型会报错
复制代码
#!/usr/bin/python3
 
student = {'Tom', 'Jim', 'Mary', 'Tom', 'Jack', 'Rose'}
 
print(student)   # 输出集合，重复的元素被自动去掉
 
# 成员测试
if('Rose' in student) :
    print('Rose 在集合中')
else :
    print('Rose 不在集合中')
 
 
# set可以进行集合运算
a = set('abracadabra')
b = set('alacazam')
 
print(a)
 
print(a - b)     # a和b的差集
 
print(a | b)     # a和b的并集
 
print(a & b)     # a和b的交集
 
print(a ^ b)     # a和b中不同时存在的元素
复制代码

方法：

　　A、add　　添加，添加可变的数据类型也是会报错的

1
2
3
s = {1,2,5,5,'g','h'}
s.add(3)
print(s)

　　执行结果

1
{1, 2, 3, 5, 'h', 'g'}

　　B、clear　  清空集合

　　C、intersection　　交集，相当于&

1
2
3
4
5
6
7
s = {1,7,9}
s1 = {1,9,5}
print(s&s1)
print(s.intersection(s1))
 
{9, 1}
{9, 1}

 　　D、union　　并集，相当于 |

1
2
3
4
s = {1,7,9}
s1 = {1,9,5}
print(s|s1)
print(s.union(s1))<br><br>{1,5,7,9}<br>{1,5,7,9}

　　E、difference　　差集，相当于-

1
2
3
4
5
6
7
s = {1,7,9}
s1 = {1,9,5}
print(s-s1)
print(s.difference(s1))
 
{7}
{7}

　　F、symmetric_difference　　交叉补集，相当于^

1
2
3
4
5
6
7
s = {1,7,9}
s1 = {1,9,5}
print(s^s1)
print(s.symmetric_difference(s1))
 
{5, 7}
{5, 7}

　　G、difference-update　　 差集更新

　　H、isdisjoint　　　　　　  判断是否有交集

　　I、issubset　　　　　　　 判断是否为子集

1
2
3
4
5
6
7
s1={1,2}
s2={1,2,3}
print(s1.issubset(s2))
print(s2.issubset(s1))
 
True
False

　　J、issuperset　　　　　　 判断是否为父集

1
2
3
4
5
s1={1,2}
s2={1,2,3}
print(s2.issuperset(s1))
 
True

　　k、update　　更新多个值，可迭代都可传

　　L、pop,remove,discard　　均为删除

1
2
3
4
5
6
7
8
9
s = {9, 'sb', 1, 2, 3, 4, 5, 6}
s.pop()                           # pop不能指定删除，只可以随机删除
print(s)
s = {9, 'sb', 1, 2, 3, 4, 5, 6}  # 指定删除元素，当删除的元素不存在时，删除会报错
s.remove(4)
print(s)
s = {9, 'sb', 1, 2, 3, 4, 5, 6}
s.discard(5)
print(s)                          # 指定元素删除；和remove唯一的区别删除不存在不会报错
posted @ 2018-11-16 11:33  __Miracle  阅读(203)  评论(0)  编辑  收藏  举报