Python-04-数据结构

2020-12-13 05:26

阅读：249

标签：alice join union 支持 font api LLC tom 添加元素

一、数字

整数

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

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

浮点数

　　浮点数也就是小数，之所以称为浮点数，是因为按照科学记数法表示时，一个浮点数的小数点位置是可变的，比如，1.23x10⁹和12.3x10⁸是完全相等的。浮点数可以用数学写法，如1.23，3.14，-9.01，等等。但是对于很大或很小的浮点数，就必须用科学计数法表示，把10用e替代，1.23x10⁹就是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)

#输出
 123
 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\tying@q.com\t123\nlaiying\tying@q.com\t123\nlaiying\tying@q.com\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 
    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}

Python-04-数据结构

标签：alice join union 支持 font api LLC tom 添加元素

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

上一篇：PHP中生成验证码

下一篇：（2）window.load和ready的区别

文章来自：搜素材网的编程语言模块，转载请注明文章出处。
文章标题：Python-04-数据结构
文章链接：http://soscw.com/essay/31012.html

亲，登录后才可以留言！

Python-04-数据结构

一、数字

二、字符串

1. 常用方法

2. 下标切片

三、列表

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

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

3. 修改元素("改")

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

5. 排序(sort, reverse)

四、元组

1. 访问元组

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

五、字典

1. 根据键访问值

2. 修改元素

3. 添加元素

4. 删除元素

5. keys

6. values

7. items

8. has_key和in

9. update

10. 字典遍历

六、集合

1. 定义

2. 集合的创建

3. 常用操作

评论

热门文章

推荐文章

最新文章

置顶文章