Python-04-数据结构

一、数字

整数

　　Python可以处理任意大小的整数，当然包括负整数，在程序中的表示方法和数学上的写法一模一样，例如：1，100，-8080，0，等等。

　　计算机由于使用二进制，所以，有时候用十六进制表示整数比较方便，十六进制用0x前缀和0-9，a-f表示，例如：0xff00，0xa5b4c3d2，等等。

浮点数

　　浮点数也就是小数，之所以称为浮点数，是因为按照科学记数法表示时，一个浮点数的小数点位置是可变的，比如，1.23x109和12.3x108是完全相等的。浮点数可以用数学写法，如1.23，3.14，-9.01，等等。但是对于很大或很小的浮点数，就必须用科学计数法表示，把10用e替代，1.23x109就是1.23e9，或者12.3e8，0.000012可以写成1.2e-5，等等。

　　整数和浮点数在计算机内部存储的方式是不同的，整数运算永远是精确的（除法难道也是精确的？是的！），而浮点数运算则可能会有四舍五入的误差。

常用方法：

  • int    将字符串转化为数字
#!/usr/bin/env python
# -*- coding:utf-8 -*-
a = ‘123‘
print(type(a), a)
a = int(a)
print(type(a), a)

#输出
<class ‘str‘> 123
<class ‘int‘> 123
  • bit_length   当前数字的二进制至少用几位表示
#!/usr/bin/env python
# -*- coding:utf-8 -*-
age = 10
r = age.bit_length()
print(r)

#输出
4

二、字符串

1. 常用方法

  • capitalize    把字符串的第一个字符大写

　　　　mystr.capitalize()

  • casefold     lower    转换 mystr 中所有大写字符为小写    casefold可以识别特殊字符

　　　　mystr.lower()

  • upper    转换 mystr 中的小写字母为大写

　　　　mystr.upper()

  • swapcase    大小写切换

　　　　mystr.swapcase()

test = ‘sFHVahKHJss‘
v = test.swapcase()
print(v)

#输出
SfhvAHkhjSS
  • center    返回一个原字符串居中,并使用fillchar填充至长度 width 的新字符串

　　　　mystr.center(width, fillchar=” ”)

  • count    返回str在start和end之间 在 mystr里面出现的次数

　　　　mystr.count(str, start=0, end=len(mystr))

  • endswith    检查字符串是否以obj结束，如果是返回True,否则返回 False.

　　　　mystr.endswith(obj)

  • startwith    检查字符串是否是以 obj 开头, 是则返回 True，否则返回 False

　　　　mystr.startswith(obj)

  • find    检测str是否包含在 mystr中，如果包含返回开始的索引值，否则返回-1

　　　　mystr.find(str, start=0, end=len(mystr))

  • index    跟find()方法一样，只不过如果str不在 mystr中会报一个异常

　　　　mystr.index(str, start=0, end=len(mystr))

  • format    字符串格式化
#!/usr/bin/env python
# -*- coding:utf-8 -*-
test = ‘my name is {name},age is {age}‘
print(test)
mstr = test.format(name=‘Tom‘, age=15)
print(mstr)

#输出
my name is {name},age is {age}
my name is Tom,age is 15

# format的三种玩法
res1 = ‘{} {} {}‘.format(‘egon‘, 18, ‘male‘)
res2 = ‘{1} {0} {1}‘.format(‘egon‘, 18, ‘male‘)
res3 = ‘{name} {age} {sex}‘.format(sex=‘male‘, name=‘egon‘, age=18)
print(res1)
print(res2)
print(res3)

#输出
egon 18 male
18 egon 18
egon 18 male
  • format_map    类似于format，但传入的参数是一个字典
#!/usr/bin/env python
# -*- coding:utf-8 -*-
test = ‘my name is {name},age is {age}‘
print(test)
mstr = test.format_map({"name":"Tom", "age":"15"})
print(mstr)

#输出
my name is {name},age is {age}
my name is Tom,age is 15
  • replace    把 mystr 中的 str1 替换成 str2,如果 count 指定，则替换不超过 count 次

　　　　mystr.replace(str1, str2,  mystr.count(str1))

name = ‘alex say :i have one tesla,my name is alex‘
print(name.replace(‘alex‘, ‘SB‘, 1))

#输出
SB say :i have one tesla,my name is alex
  • split    以 str 为分隔符切片 mystr，如果 maxsplit有指定值，则仅分隔 maxsplit 个子字符串

　　　　mystr.split(str=" ", maxsplit)

name = ‘root:x:0:0::/root:/bin/bash‘
print(name.split(‘:‘))  # 默认分隔符为空格
name = ‘C:/a/b/c/d.txt‘  # 只想拿到顶级目录
print(name.split(‘/‘, 1))

#输出
[‘root‘, ‘x‘, ‘0‘, ‘0‘, ‘‘, ‘/root‘, ‘/bin/bash‘]
[‘C:‘, ‘a/b/c/d.txt‘]
  • rsplit    类似split，但从右边开始
  • title    把字符串的每个单词首字母大写

　　　　mystr.title()

  • ljust    返回一个原字符串左对齐,并使用fillchar填充至长度 width 的新字符串

　　　　mystr.ljust(width, fillchar=” ”)

  • rjust    返回一个原字符串右对齐,并使用fillchar填充至长度 width 的新字符串

　　　　mystr.rjust(width, fillchar=” ”)

  • zfill    返回指定长度的字符串，原字符串右对齐，前面填充0

　　　　mystr.zfill(width)

  • lstrip    删除 mystr 左边的空白字符   也可以去除指定的字符

　　　　mystr.lstrip()

#!/usr/bin/env python
# -*- encoding:utf-8 -*-
test = ‘asdfghh‘
v = test.lstrip(‘8assdf‘) # 消除所有匹配到的字符
print(v)

#输出
ghh
  • rstrip    删除 mystr 右边的空白字符   也可以去除指定的字符

　　　　mystr.rstrip()

  • strip    删除mystr字符串两端的空白字符   也可以去除指定的字符

　　　　mystr.strip()

  • rfind    类似于 find()函数，不过是从右边开始查找

　　　　mystr.rfind(str, start=0,end=len(mystr) )

  • rindex   类似于 index()，不过是从右边开始.

　　　　mystr.rindex( str, start=0,end=len(mystr))

  • partition    把mystr以str分割成三部分,str前，str和str后

　　　　mystr.partition(str)

test = ‘ahjsyklsuiyska‘
v = test.partition(‘s‘)
print(v)

#输出
(‘ahj‘, ‘s‘, ‘yklsuiyska‘)
  • rpartition    类似于 partition()函数,不过是从右边开始.

　　　　mystr.rpartition(str）

  • splitlines    按照行分隔，返回一个包含各行作为元素的列表

　　　　mystr.splitlines()

test = ‘ahjsykls\nuiyska\nvjshgk\ndhvgks‘
v1 = test.splitlines(True)
print(v1)
v2 = test.splitlines(False)
print(v2)

#输出
[‘ahjsykls\n‘, ‘uiyska\n‘, ‘vjshgk\n‘, ‘dhvgks‘]
[‘ahjsykls‘, ‘uiyska‘, ‘vjshgk‘, ‘dhvgks‘]
  • isupper    判断字符串否全是大写字母

　　　　mystr.isupper()

  • islower    判断字符串否全是小写字母

　　　　mystr.islower()

  • isalpha    如果 mystr 所有字符都是字母 则返回 True,否则返回 False

　　　　mystr.isalpha()

  • isdigit    isdecimal    isnumeric    如果 mystr 只包含数字则返回 True 否则返回 False。isdigit可以判断一些特殊字符例如②。 isnumeric可以判断中文数字例如二。

　　　　mystr.isdigit()

#!/usr/bin/env python
# -*- encoding:utf-8 -*-
test = ‘②‘
v1 = test.isdecimal()
v2 = test.isdigit()
print(v1, v2)

#输出
False True
test = ‘二‘
v1 = test.isdecimal()
v2 = test.isdigit()
v3 = test.isnumeric()
print(v1, v2, v3)

#输出
False False True
  • isalnum    如果 mystr 所有字符都是字母或数字则返回 True,否则返回 False

　　　　mystr.isalnum()

  • isspace    如果 mystr 中只包含空格，则返回 True，否则返回 False

　　　　mystr.isspace()

  • istitle    如果字符串的每个单词的首字母都是大写，则返回True，否则返回False

　　　　mystr.istitle()

  • isprintable    判断字符串是否能够被打印

　　　　mystr.isprintable()

test = ‘\n‘
v = test.isprintable()
print(v)

#输出
False
  • join    将字符串、元组、列表中的元素以mystr连接生成一个新的字符串

　　　　mystr.join(str)

mystr = ‘ ‘
print(mystr.join(["haha", "hehe", "heihei"]))
mystr = ‘-‘
print(mystr.join(["haha", "hehe", "heihei"]))

# 运行结果：
haha hehe heihei
haha-hehe-heihei
  • expandtabs 方法把字符串中的 tab 符号(‘\t‘)转为空格，tab 符号(‘\t‘)默认的空格数是 8。从头开始数，数到第一个\t正好为8个空格，不足则补空格，如果还有\t，接着从第一个\t数到第二个\t仍然为8个空格，以此类推直到最后一个\t结束。

　　　　S.expandtabs([tabsize=8])

#!/usr/bin/python3

S = "this is\tstring example....wow!!!"
print ("原始字符串: " + S)
print ("替换 \\t 符号: " +  S.expandtabs())
print ("使用16个空格替换 \\t 符号: " +  S.expandtabs(16))
"""
以上实例输出结果如下：
原始字符串: this is     string example....wow!!!
替换 \t 符号: this is string example....wow!!!
使用16个空格替换 \t 符号: this is         string example....wow!!!
"""

#!/usr/bin/env python
#-*- encoding:utf-8 -*-

S = "username\temail\tpassword\nlaiying\[email protected]\t123\nlaiying\[email protected]\t123\nlaiying\[email protected]\t123"
v = S.expandtabs(20)
print(v)

  • translate   替换字符串中指定的字符
test = ‘ahjsykliuiyjka‘
m = str.maketrans(‘aeiou‘,‘12345‘)
v = test.translate(m)
print(v)

#输出
1hjsykl353yjk1

 重点：

　　1、strip,lstrip,rstrip

　　2、lower,upper

　　3、startswith,endswith

　　4、format的三种玩法

　　5、split,rsplit

　　6、join

　　7、replace

　　8、isdigit

2. 下标切片

字符串中"下标"的使用

字符串实际上就是字符的数组，所以支持下标索引。

如果有字符串:name = ‘abcdef‘，在内存中的实际存储如下:

如果想取出部分字符，那么可以通过下标的方法，（注意python中下标从 0 开始）

name = ‘abcdef‘
print(name[0])
print(name[1])
print(name[2])

运行结果：
a
b
c

切片

切片是指对操作的对象截取其中一部分的操作。

切片的语法：变量名[起始:结束:步长]

注意：选取的区间属于左闭右开型，即从"起始"位开始，到"结束"位的前一位结束（包含起始位本身但不包含结束位本身)。结束位可以不写，那么默认按照步长一直到末尾。

如果取出一部分，则可以在中括号[]中

示例1：
name = ‘abcdef‘
print(name[0:3])  # 取下标0~2 的字符
运行结果：
abc

示例2：
name = ‘abcdef‘
print(name[2:])  # 取下标为2开始到最后的字符
运行结果：
cdef

示例3：
name = ‘abcdef‘
print(name[len(name)-1])  # 取下标为字符长度-1的字符
print(name[-1])  # 取下标为倒数第一个的字符
运行结果：
f
f

示例4：
name = ‘abcdef‘
print(name[1:-1])  # 取第2个到倒数第2个字符切片
print(name[0::2])  # 从第一个字符开始每次步长为2取切片
运行结果：
bcde
ace

示例5：
name = ‘abcdef‘
print(name[-1:-5:-1])  # 逆向取倒数第一个到倒数第4个字符切片
print(name[-1::-1])  # 逆向取倒数第一个到末尾的字符切片
print(name[::-1])  # 倒序字符的切片
运行结果：
fedc
fedcba
fedcba

三、列表

1. 添加元素("增"append, extend, insert)

append：通过append可以向列表添加元素，并且默认添加在列表末尾。

示例：

namesList = [‘tom‘, ‘jerry‘, ‘jhon‘]
print("----添加之前，列表中的元素----")
print(namesList)
print("----添加之后，列表中的元素----")
namesList.append("james")
print(namesList)
运行结果：
----添加之前，列表中的元素----
[‘tom‘, ‘jerry‘, ‘jhon‘]
----添加之后，列表中的元素----
[‘tom‘, ‘jerry‘, ‘jhon‘, ‘james‘]

extend：通过extend可以将另一个集合中的元素逐一添加到列表中

示例：

print("----使用append添加----")
a = [‘a‘, ‘b‘, ‘c‘]
b = [‘1‘, ‘2‘, ‘3‘]
a.append(b)
print(a)
print("----使用extend添加----")
a = [‘a‘, ‘b‘, ‘c‘]
b = [‘1‘, ‘2‘, ‘3‘]
a.extend(b)
print(a)

运行结果：
----使用append添加----
[‘a‘, ‘b‘, ‘c‘, [‘1‘, ‘2‘, ‘3‘]]
----使用extend添加----
[‘a‘, ‘b‘, ‘c‘, ‘1‘, ‘2‘, ‘3‘]

insert：insert(index, object) 在指定位置index前插入元素object

示例：

a = [‘a‘, ‘b‘, ‘c‘]
a.insert(1, "haha")
print(a)

运行结果：
[‘a‘, ‘haha‘, ‘b‘, ‘c‘]

2. 删除元素("删"del, pop, remove,clear)

del：根据下标进行删除

示例：

movieName = [‘绿巨人‘, ‘钢铁侠‘, ‘超人‘, ‘雷神‘, ‘洛基‘]
print(‘------删除之前------‘)
print(movieName)
print(‘------删除之后------‘)
del movieName[2]
print(movieName)

运行结果：
------删除之前------
[‘绿巨人‘, ‘钢铁侠‘, ‘超人‘, ‘雷神‘, ‘洛基‘]
------删除之后------
[‘绿巨人‘, ‘钢铁侠‘, ‘雷神‘, ‘洛基‘]

pop：删除最后一个元素

示例：

movieName = [‘绿巨人‘, ‘钢铁侠‘, ‘超人‘, ‘雷神‘, ‘洛基‘]
print(‘------删除之前------‘)
print(movieName)
print(‘------删除之后------‘)
movieName.pop()  # 也可以传入下标作为参数，删除该下标的元素
print(movieName)

运行结果：
------删除之前------
[‘绿巨人‘, ‘钢铁侠‘, ‘超人‘, ‘雷神‘, ‘洛基‘]
------删除之后------
[‘绿巨人‘, ‘钢铁侠‘, ‘超人‘, ‘雷神‘]

remove：根据元素的值进行删除

示例：

movieName = [‘绿巨人‘, ‘钢铁侠‘, ‘超人‘, ‘雷神‘, ‘洛基‘]
print(‘------删除之前------‘)
print(movieName)
print(‘------删除之后------‘)
movieName.remove(‘超人‘)
print(movieName)

运行结果：
------删除之前------
[‘绿巨人‘, ‘钢铁侠‘, ‘超人‘, ‘雷神‘, ‘洛基‘]
------删除之后------
[‘绿巨人‘, ‘钢铁侠‘, ‘雷神‘, ‘洛基‘]

clear:清空所有元素

mlist = [1, 2, 3, 4, 5, 6, 7]
mlist.clear()
print(mlist)

运行结果：
[]

3. 修改元素("改")

修改元素的时候，要通过下标来确定要修改的是哪个元素，然后对其重新赋值

示例：

movieName = [‘绿巨人‘, ‘钢铁侠‘, ‘超人‘, ‘雷神‘, ‘洛基‘]
print(‘------修改之前------‘)
print(movieName)
print(‘------修改之后------‘)
movieName[2] = ‘美国队长‘
print(movieName)

运行结果：
------修改之前------
[‘绿巨人‘, ‘钢铁侠‘, ‘超人‘, ‘雷神‘, ‘洛基‘]
------修改之后------
[‘绿巨人‘, ‘钢铁侠‘, ‘美国队长‘, ‘雷神‘, ‘洛基‘]

4. 查找元素("查"in, not in, index, count)

in, not in

示例：

name_list = [‘tom‘, ‘jerry‘, ‘alice‘, ‘james‘]
print(‘tom‘ in name_list)
print(‘tom‘ not in name_list)

运行结果：
True
False

index, count

示例：

name_list = [‘tom‘, ‘jerry‘, ‘alice‘, ‘james‘, ‘jerry‘]
print(name_list.index(‘jerry‘, 1, 3))
print(name_list.index(‘jerry‘, 4, 6))
print(name_list.count(‘jerry‘))

运行结果：
1
4
2

5. 排序(sort, reverse)

  • sort方法是将list按特定顺序重新排列，默认为由小到大，参数reverse=True可改为倒序，由大到小。
  • reverse方法是将list逆置。

示例：

a = [1, 4, 2, 3, 6, 5, 9, 8, 7]
print(‘----原列表----‘)
print(a)
print(‘----reverse----‘)
a.reverse()
print(a)
print(‘----sort----‘)
a.sort()
print(a)
print(‘----sort(reverse=True)----‘)
a.sort(reverse=True)
print(a)

运行结果：
----原列表----
[1, 4, 2, 3, 6, 5, 9, 8, 7]
----reverse----
[7, 8, 9, 5, 6, 3, 2, 4, 1]
----sort----
[1, 2, 3, 4, 5, 6, 7, 8, 9]
----sort(reverse=True)----
[9, 8, 7, 6, 5, 4, 3, 2, 1]

四、元组

python的元组与列表类似，不同之处在于元组的元素不能修改。元组使用小括号，列表使用方括号。

tuple = (1, 2, 3, 4)

1. 访问元组

tuple = (1, 2, 3, 4)
print(tuple[0])
print(tuple[2])

运行结果：
1
3

2. 元组的内置函数count, index

tuple = (‘tom‘, ‘jerry‘, ‘alice‘, ‘james‘)
print(tuple.index(‘alice‘, 1, 3))
print(tuple.count(‘jerry‘))

运行结果：
2
1

五、字典

字典的创建
person = {"name": "sb", ‘age‘: 18}
或
person = dict(name=‘sb‘, age=18)
person = dict({"name": "sb", ‘age‘: 18})
person = dict(([‘name‘,‘sb‘],[‘age‘,18]))

{}.fromkeys(seq,100) #不指定100默认为None
注意：

>>> dic={}.fromkeys([‘k1‘,‘k2‘],[])
>>> dic
{‘k1‘: [], ‘k2‘: []}
>>> dic[‘k1‘].append(1)
>>> dic
{‘k1‘: [1], ‘k2‘: [1]}

变量info为字典类型：

info = {‘name‘:‘孙悟空‘, ‘id‘:100, ‘sex‘:‘男‘, ‘address‘:‘花果山‘}

说明：

  • 字典和列表一样，也能够存储多个数据
  • 列表中找某个元素时，是根据下标进行的。字典中找某个元素时，是根据‘名字‘（就是冒号:前面的那个值，例如上面代码中的‘name‘、‘id‘、‘sex‘）
  • 字典的每个元素由2部分组成，键:值。例如 ‘name‘:‘孙悟空‘ ,‘name‘为键，‘孙悟空‘为值

1. 根据键访问值

info = {‘name‘: ‘孙悟空‘, ‘id‘: 100, ‘sex‘: ‘男‘, ‘address‘: ‘花果山‘}
print(info[‘name‘])
print(info[‘address‘])

运行结果：
孙悟空
花果山

若访问不存在的键，则会报错：
info = {‘name‘: ‘孙悟空‘, ‘id‘: 100, ‘sex‘: ‘男‘, ‘address‘: ‘花果山‘}
print(info[‘haha‘])

运行结果：
Traceback (most recent call last):
  File "X:/xxx/xxx/xxx.py", line 2, in <module>
    print(info[‘haha‘])
KeyError: ‘haha‘

在我们不确定字典中是否存在某个键而又想获取其值时，可以使用get方法，还可以设置默认值：
info = {‘name‘: ‘孙悟空‘, ‘id‘: 100, ‘sex‘: ‘男‘, ‘address‘: ‘花果山‘}
print(info.get(‘name‘))
print(info.get(‘haha‘))
print(info.get(‘haha‘, ‘haha‘))

运行结果：
孙悟空
None
haha

2. 修改元素

字典的每个元素中的数据是可以修改的，只要通过key找到，即可修改

info = {‘name‘: ‘孙悟空‘, ‘id‘: 100, ‘sex‘: ‘男‘, ‘address‘: ‘花果山‘}
print(‘----修改前----‘)
print(info)
print(‘----修改后----‘)
info[‘name‘] = "齐天大圣"
print(info)

运行结果：
----修改前----
{‘name‘: ‘孙悟空‘, ‘id‘: 100, ‘sex‘: ‘男‘, ‘address‘: ‘花果山‘}
----修改后----
{‘name‘: ‘齐天大圣‘, ‘id‘: 100, ‘sex‘: ‘男‘, ‘address‘: ‘花果山‘}

3. 添加元素

如果在使用变量名[‘键‘] = 数据时，这个“键”在字典中，不存在，那么就会新增这个元素

info = {‘name‘: ‘孙悟空‘, ‘id‘: 100, ‘sex‘: ‘男‘, ‘address‘: ‘花果山‘}
print(‘----修改前----‘)
print(info)
print(‘----修改后----‘)
info[‘age‘] = 500
print(info)

运行结果：
----修改前----
{‘name‘: ‘孙悟空‘, ‘id‘: 100, ‘sex‘: ‘男‘, ‘address‘: ‘花果山‘}
----修改后----
{‘name‘: ‘孙悟空‘, ‘id‘: 100, ‘sex‘: ‘男‘, ‘address‘: ‘花果山‘, ‘age‘: 500}

4. 删除元素

del删除指定的元素

info = {‘name‘: ‘孙悟空‘, ‘id‘: 100, ‘sex‘: ‘男‘, ‘address‘: ‘花果山‘}
print(‘----删除前----‘)
print(info)
print(‘----删除后----‘)
del info[‘sex‘]
print(info)

运行结果：
----删除前----
{‘name‘: ‘孙悟空‘, ‘id‘: 100, ‘sex‘: ‘男‘, ‘address‘: ‘花果山‘}
----删除后----
{‘name‘: ‘孙悟空‘, ‘id‘: 100, ‘address‘: ‘花果山‘}

clear清空整个字典

info = {‘name‘: ‘孙悟空‘, ‘id‘: 100, ‘sex‘: ‘男‘, ‘address‘: ‘花果山‘}
print(‘----清空前----‘)
print(info)
print(‘----清空后----‘)
info.clear()
print(info)

运行结果：
----清空前----
{‘name‘: ‘孙悟空‘, ‘id‘: 100, ‘sex‘: ‘男‘, ‘address‘: ‘花果山‘}
----清空后----
{}

pop删除指定元素，若删除的元素不存在，可以指定返回值

dic = {
    ‘k1‘: ‘v1‘,
    ‘k2‘: ‘v2‘
}
v = dic.pop(‘k1‘)
print(dic, v)
# 运行结果
{‘k2‘: ‘v2‘} v1

dic = {
    ‘k1‘: ‘v1‘,
    ‘k2‘: ‘v2‘
}
v = dic.pop(‘k111‘, 1)
print(dic, v)
# 运行结果
{‘k1‘: ‘v1‘, ‘k2‘: ‘v2‘} 1

5. keys

返回一个包含字典所有KEY的列表

>>> info = {‘name‘: ‘孙悟空‘, ‘id‘: 100, ‘sex‘: ‘男‘, ‘address‘: ‘花果山‘}

>>> info.keys()

dict_keys([‘name‘, ‘id‘, ‘sex‘, ‘address‘])

>>>

6. values

返回一个包含字典所有value的列表

>>> info = {‘name‘: ‘孙悟空‘, ‘id‘: 100, ‘sex‘: ‘男‘, ‘address‘: ‘花果山‘}

>>> info.values()

dict_values([‘孙悟空‘, 100, ‘男‘, ‘花果山‘])

>>>

7. items

返回一个包含所有（键，值）元组的列表

>>> info = {‘name‘: ‘孙悟空‘, ‘address‘: ‘花果山‘}

>>> info.items()

dict_items([(‘name‘, ‘孙悟空‘), (‘address‘, ‘花果山‘)])

>>>

8. has_key和in

python3去除了has _key替换为in

如果key在字典中，返回True，否则返回False

>>> info = {‘name‘: ‘孙悟空‘, ‘address‘: ‘花果山‘}

>>> ‘name‘ in info

True

>>> ‘age‘ in info

False

>>>

看看python2中的has_key，当然python2中in也可以使用

>>> info = {‘name‘: ‘孙悟空‘, ‘address‘: ‘花果山‘}

>>> ‘name‘ in info

True

>>> info.has_key(‘name‘)

True

>>> info.has_key(‘age‘)

False

>>>

9. update

dic = {
    ‘k1‘: ‘v1‘,
    ‘k2‘: ‘v2‘
}
dic.update({‘k1‘: 123, ‘k3‘: 456})
print(dic)
# 运行结果
{‘k1‘: 123, ‘k2‘: ‘v2‘, ‘k3‘: 456}

10. 字典遍历

info = {‘name‘: ‘孙悟空‘, ‘address‘: ‘花果山‘}
print(‘----遍历字典的key（键）----‘)
for key in info.keys():
    print(key, end=‘\t‘)
print()
print(‘----遍历字典的value（值）----‘)
for value in info.values():
    print(value, end=‘\t‘)
print()
print(‘----遍历字典的项（元素）----‘)
for item in info.items():
    print(item, end=‘\t‘)

运行结果：
----遍历字典的key（键）----
name    address
----遍历字典的value（值）----
孙悟空   花果山
----遍历字典的项（元素）----
(‘name‘, ‘孙悟空‘)  (‘address‘, ‘花果山‘)

六、集合

1. 定义

　　定义：由不同元素组成的集合，集合中是一组无序排列的可hash值，可以作为字典的key

　　特点：

    • 不同元素组成
    • 无序
    • 每个元素必须是不可变类型

2. 集合的创建

　　{1,2,3,1}
　　或
　　定义可变集合set
　　>>> set_test=set(‘hello‘)
　　>>> set_test
　　{‘l‘, ‘o‘, ‘e‘, ‘h‘}
　　改为不可变集合frozenset
　　>>> f_set_test=frozenset(set_test)
　　>>> f_set_test
　　frozenset({‘l‘, ‘e‘, ‘h‘, ‘o‘})

3.  常用操作

add    添加元素

s = {1, 2, 3}
s.add(4)
print(s)

运行结果
{1，2，3，4}

pop    随机删除一个元素

s = {‘b‘, 123, 2, 3, ‘a‘}
s.pop()
print(s)

#运行结果
{3, ‘b‘, ‘a‘, 123}
 

remove    删除指定元素，删除不存在的元素时会报错

s = {‘b‘, 123, 2, 3, ‘a‘}
s.remove(‘a‘)
print(s)

# 运行结果
{2, 3, ‘b‘, 123}

discard    删除指定元素，删除不存在的元素时不会报错

intersection  或  &     交集

s = {‘b‘, 123, 2, 3, ‘a‘}
b = {‘a‘, 2, 5, 123}
sb = s.intersection(b)
print(sb)
print(s & b)
# 运行结果
{2, 123, ‘a‘}{2, 123, ‘a‘}

union  或  |    并集 

s = {‘b‘, 123, 2, 3, ‘a‘}
b = {‘a‘, 2, 5, 123}
sb = s.union(b)
print(sb)
print(s | b)

# 运行结果
{2, 3, ‘a‘, 5, ‘b‘, 123}
{2, 3, ‘a‘, 5, ‘b‘, 123}

difference  或  -    差集

s = {‘b‘, 123, 2, 3, ‘a‘}
b = {‘a‘, 2, 5, 123}
sb = s - b
bs = b - s
print(sb, bs)

# 运行结果
{3, ‘b‘} {5}

symmetric_difference   或  ^     交叉补集（两个集合不共有的部分）

s = {‘b‘, 123, 2, 3, ‘a‘}
b = {‘a‘, 2, 5, 123}
sb = s.symmetric_difference(b)
print(sb)

# 运行结果
{3, 5, ‘b‘}

difference_update     返回两集合的差集

s = {‘b‘, 123, 2, 3, ‘a‘}
b = {‘a‘, 2, 5, 123}
s.difference_update(b) # 将两集合的差集返回给s
print(s)

# 运行结果
{3, ‘b‘}

isdisjoint     如果两集合的交集为空集，返回True

s = {‘b‘, 2, 3, }
b = {‘a‘, 5, 123}
v = s.isdisjoint(b)
print(v)

# 运行结果
True

issubset    如果s1是s2的子集，返回True

s1 = {1, 2}
s2 = {1, 2, 3}
v = s1.issubset(s2)
print(v)

#运行结果
True

issuperset    如果s1包含s2父集，返回True

s1 = {1, 2}
s2 = {1, 2, 3}
v = s1.issuperset(s2)
print(v)

# 运行结果 False

update    更新

s1 = {1, 2}
s2 = {1, 2, 3}
s1.update(s2)
print(s1)

# 运行结果
{1，2，3}

原文地址：https://www.cnblogs.com/lsf123456/p/11132809.html

时间： 2024-10-24 18:17:38

Python-04-数据结构的相关文章

python 常用数据结构使用

python 字典排序 http://www.cnblogs.com/kaituorensheng/archive/2012/08/07/2627386.html 函数原型 sorted(dic,value,reverse) dic为比较函数,value 为排序的对象(这里指键或键值), reverse:注明升序还是降序,True--降序,False--升序(默认) 案例 dic = {'a':3 , 'b':2 , 'c': 1} 注意 排序之后原字典没有变,顺序依旧 python 常用数据结

python基本数据结构序列

python基本数据结构序列 ,六种内建序列类型:列表 元组字符串  Unicode字符串  buff对象和xrange对象 序列通用操作: 索引:元素的编号是从 0开始的 到索引号为负数时 查找方式是从右到左的 索引写在[]中 分片:类似索引的操作可以指定范围,当为一个对象创造副本时可以用 b = a[:] 这样的形式创建,这样 当 a被操作时不会影响 b  因为他们指向的不是同一块区域 相加:表示连接操作,列表连接后是新的列表不能改变列表原有的结构,序列相加时候要同种类型  进行,否则会报

用Python实现数据结构之二叉搜索树

二叉搜索树 二叉搜索树是一种特殊的二叉树,它的特点是: 对于任意一个节点p,存储在p的左子树的中的所有节点中的值都小于p中的值 对于任意一个节点p,存储在p的右子树的中的所有节点中的值都大于p中的值 一个图例: 基于二叉搜索树的这种关系,我们可以用它来实现有序映射 遍历二叉搜索树 基于二叉搜索树的特性,采用中序遍历的方式可以使得遍历结果是按照从小到大的顺序排列的.了解中序遍历可以参考用Python实现数据结构之树 这里还需要思考的一个内容是在基于中序遍历的前提下,如何求一个节点的后继节点或前驱节

python实现数据结构单链表

#python实现数据结构单链表 # -*- coding: utf-8 -*- class Node(object): """节点""" def __init__(self, elem): self.elem = elem self.next = None # 节点一开始初始化的时候并不知道下一个元素的地址,所以先设置为空 class SingLinkList(object): """单链表""

Python之‘数据结构’

简介 数据结构基本上就是--它们是可以处理一些数据的结构.或者说,它们是用来存储一组相关数据的.在Python里面有三种内建的数据结构--列表.元组和字典. 一.列表 list是处理一组有序项目的数据结构,即你可以在一个列表中存储一个序列的项目.假象你有一个购物列表,上面记载着你想买的东西,就容易理解列表了.只不过在你的购物列表上,可能每样东西都独自占有一行,而在Python中,你在每个项目之间用逗号分隔. 列表中的项目应该包含在方括号中,这样Python就知道你在指明一个列表.一旦你创建一个列

python常见数据结构整理

Python中常见的数据结构可以统称为容器(container).序列(如列表和元组).映射(如字典)以及集合(set)是三类主要的容器. 一.序列(列表.元组和字符串) 序列中的每个元素都有自己的编号.Python中有6种内建的序列.其中列表和元组是最常见的类型.其他包括字符串.Unicode字符串.buffer对象和xrange对象.下面重点介绍下列表.元组和字符串. 1.列表 列表是可变的,这是它区别于字符串和元组的最重要的特点,一句话概括即:列表可以修改,而字符串和元组不能. (1).创

[0x01 用Python讲解数据结构与算法] 关于数据结构和算法还有编程

忍耐和坚持虽是痛苦的事情,但却能渐渐地为你带来好处. ——奥维德 一.学习目标 · 回顾在计算机科学.编程和问题解决过程中的基本知识: · 理解“抽象”在问题解决过程中的重要作用: · 理解并实现抽象数据结构: · 复习Python编程语言 二.写在前面 自第一台电子计算机使用线路和开关传达人类的指令以来,我们编程的思考方式有了很大的改变,在很多方面,计算机技术的发展为计算机科学家提供了众多的工具和平台去实现他们的想法.高性能理器,高速网络和大内存使得计算机研究者必须掌握在这样复杂的螺旋式通道中

python常用数据结构

python中有四种最常用的数据结构,分别是列表(list),字典(dict),集合(set)和元组(tuple) 下面简单描述下它们的区别和联系 1.初始化 不得不说,python数据结构的初始化比java是简单的多了. list=[] dict={} tuple=(1,2,) set=([1,2,3]) 初始化之后,print set 结果是:{1,2,3},可以发现,其实set就是没有value的dict 2.是否有序 list和tuple是有序的,dict和set是无序的 3.是否可变

python 5 数据结构

转载: http://www.cnblogs.com/known/archive/2010/09/03/1817499.html python中有三个内建的数据结构, 列表, 元组, 和 字典 1. 列表 (List) 列表用一堆方括号[] 表示, 没想数据之间用 逗号 隔开, 一旦你建立了一个列表, 你可以对它进行添加, 删除, 或搜索. 所以列表是可以改变的 2. 元组 元组和列表相似,但是 元组是不可以改变的!元组是用() 表示的, 每项数据之间也是用逗号隔开, 元组通常用在使语句或者用户

python和数据结构

在紧张的备考日语的过程中抽时间刷一下北京大学的python数据结构.查缺补漏. /整除 >>>divmod(9,5) (1,4) /复数 >>>import cmath >>>(1+2j)*(1+3j) (-5+5j) >>>(1+4j).imag 4.0 >>>(1+4j).real 1.0 早就已经知道的C语言要想使用一个变量必须先初始化,Python的变量机制是引用数据对象,例如赋值语句'a = 0'是创建a这