数据结构python版答案_「Python」 - 内部数据结构

àì夳堔傛蜴生んèń 2022-11-19 09:47 228阅读 0赞

一、python内置数据结构练习

A、过滤列表中的负数

\# filter版本

\# 生成随机列表

rand\_list = \[random.randint(-100,100) for x in range(1,10)\]

print(rand\_list)

\# filter配合lambda过滤

rs = filter(lambda x: x >= 0, rand\_list)

print(list(rs))

\`\`\`

\`\`\`python

\# 推导式版本

\# 生成随机列表

rand\_list = \[random.randint(-100, 100) for x in range(1, 10)\]

\# 重新打乱列表

random.shuffle(rand\_list)

print(rand\_list)

\# 列表推导式

rs = \[x for x in rand\_list if x >= 0\]

print(rs)

B、使用timeit查看表达式执行时间Python3中的timeit模块可以用来测试小段代码的运行时间。

stmt：用于传入要测试时间的代码，可以直接接受字符串的表达式，也可以接受单个变量，也可以接受函数。

传入函数时要把函数申明在当前文件中，然后在stmt = 'func()'执行函数，使用setup = 'from \_\_main\_\_ import func'。

setup：传入stmt的运行环境，比如stmt中使用到的参数、变量，要导入的模块等。

可以写成一行语句，也可以写多行语句，多行语句时要用分号隔开语句。

number：要测试的代码的运行次数，默认100000次。

ipython环境。

import timeit

timeit.timeit(stmt = 'filter(lambda x: x >= 0, rand\_list)', setup='rand\_list = \[92, 7, -5, 59, -90, 14, -63, 50, -74\]')

Out\[24\]: 0.3463938022929085

timeit.timeit(stmt = '\[x for x in rand\_list if x >= 0\]', setup='rand\_list = \[92, 7, -5, 59, -90, 14, -63, 50, -74\]')

Out\[25\]: 0.8586269034875329

C、过滤出字典中value大于60的item

\# ALL\_ENG\_NAMES = \['fAaliyah', 'mAaron', 'fAarushi', ....\]

from englishname import ALL\_ENG\_NAMES

end\_index = len(ALL\_ENG\_NAMES)-1

\# 生成随机字典

rand\_dict = \{ALL\_ENG\_NAMES\[random.randint(0, end\_index)\]: random.randint(0, 100) for x in range(1, 10)\}

print(rand\_dict)

\# 字典推导式

rs = \{key: value for key, value in rand\_dict.items() if value > 60\}

print(rs)

D、过滤出集合中能被3整除的元素

\# 生成随机集合

rand\_set = \{random.randint(0, 10) for x in range(1, 10)\}

print(rand\_set)

\# 集合推导式

rs = \{x for x in rand\_set if x % 3 == 0\}

print(rs)

E、元组推导式

使用元组推导式，结果为generator类型，需要转化为list，一般也不使用。

rand\_tuple = (random.randint(-100,100) for x in range(1,10))

print(rand\_tuple) \# at 0x000000ACAB18B150>

print(type(rand\_tuple)) \#

print(list(rand\_tuple)) \# \[44, -72, 58, -58, -34, 53, 81, -67, -39\]

F、有名元组

元组有序，可以使用索引进行元素访问，但是使用数字下标(magic number)，程序可读性不好。

可以使用常量(但也能被修改)，或者枚举做到见到名知意。

\# 使用Enum

from enum import Enum

class Point(Enum):

X = 0

Y = 1

p1 = (10, 10)

p2 = (20, 20)

print(p1\[Point.X.value\], p1\[Point.Y.value\])

不过collections包中有一个namedtuple，相当于创建一种类型，直接使用.进行成员访问。

\# collections中的namedtuple

from collections import namedtuple

Point = namedtuple('Ponit', \['x', 'y'\])

p1 = Point(x=10, y=10)

p2 = Point(x=20, y=20)

print(p1.x, p1.y) \#10 10

G、统计序列中元素出现频度(前N名)

通过map遍历，增加value值。

list\_data = \[random.randint(1,5) for x in range(1,30)\]

\# 统计结果map，根据data生成key，value设置为0

rs\_dict = dict.fromkeys(list\_data, 0)

for x in list\_data:

rs\_dict\[x\] += 1

print(rs\_dict)

\# \{5: 5, 4: 5, 1: 6, 2: 9, 3: 4\}

H、通过collections下Counter统计

from collections import Counter

data\_list = \[random.randint(1,5) for x in range(1,30)\]

\# 使用map保存key出现的次数(Count)

rs = Counter(data\_list)

print(rs)

\# Counter(\{5: 8, 2: 8, 4: 6, 1: 6, 3: 1\})

\# 获取前N

rs = rs.most\_common(3)

print(rs)

\# \[(5, 9), (3, 8), (4, 6)\]

I、统计文件中出现频度最高的10个单词

韭菜大神李笑来，在《托福核心词汇》中用了个办法统计高频词汇，把历年托福真题的单词全部扫出来，统计出现频度，取出常用词，留下高频托福词汇。

用python可以很容易搞定。

import re

from collections import Counter

file = open('CET.txt', encoding='utf-8')

data = file.read()

list = re.split(r'\\W+', data)

rs = Counter(list).most\_common(10)

print(rs)

\# \[('the', 252), ('to', 126), ('of', 101), ('a', 98), ('in', 76), ('and', 63), ('you', 48), ('on', 47), ('s', 44), ('is', 39)\]

J、使用字典实现switch

def func1():

print("func1() called")

def func2():

print("func2() called")

def func3():

print("func3() called")

func\_dict = \{1: func1, 2: func2, 3:func3\}

func = func\_dict.get(3)

func()

K、根据key对字典进行排序

由于dict是无序存储，有时需要根据key/value排序，对前N项进行输出，这里对dict排序也是常用操作。

from englishname import ALL\_ENG\_NAMES

from collections import OrderedDict

end\_index = len(ALL\_ENG\_NAMES)-1

\# 生成随机字典

rand\_dict = \{ALL\_ENG\_NAMES\[random.randint(0, end\_index)\]: random.randint(0,100) for x in range(1,10)\}

print(rand\_dict)

\# 根据key进行sorted

rs = OrderedDict(sorted(rand\_dict.items(), key = lambda x: x\[0\]))

\# 根据value进行sorted

rs = OrderedDict(sorted(rand\_dict.items(), key = lambda x: x\[1\]))

\# 根据key长度进行sorted

rs = OrderedDict(sorted(rand\_dict.items(), key = lambda x: len(x\[0\])))

print(rs)

L、根据value对字典进行排序

from englishname import ALL\_ENG\_NAMES

from collections import OrderedDict

end\_index = len(ALL\_ENG\_NAMES)-1

\# 生成随机字典

rand\_dict = \{ALL\_ENG\_NAMES\[random.randint(0, end\_index)\]: random.randint(0,100) for x in range(1,10)\}

print(rand\_dict)

\# \{'mLennon': 21, 'fRyleigh': 57, 'mQuinn': 17, 'mCampbell': 36, 'mEnrique': 97, 'mChris': 56, 'fCoral': 97, 'fMadyson': 39, 'mMarcos': 0\}

\# 使用zip转为(value, key)的元组列表，然后排序

zip\_dict = zip(rand\_dict.values(), rand\_dict.keys())

rs = sorted(zip\_dict)

print(rs)

\# \[(0, 'mMarcos'), (17, 'mQuinn'), (21, 'mLennon'), (36, 'mCampbell'), (39, 'fMadyson'), (56, 'mChris'), (57, 'fRyleigh'), (97, 'fCoral'), (97, 'mEnrique')\]

\#使用OrderedDict，根据顺序存放dict元素

ordered\_dict = OrderedDict()

for x in rs:

ordered\_dict\[x\[1\]\] = x\[0\]

print(dict(ordered\_dict))

\# \{'mMarcos': 0, 'mQuinn': 17, 'mLennon': 21, 'mCampbell': 36, 'fMadyson': 39, 'mChris': 56, 'fRyleigh': 57, 'fCoral': 97, 'mEnrique': 97\}

M、快速寻找多个字典中公共键

使用传统的遍历，对a、b、c三个字典进行遍历，找出公共键。

from random import sample

rand\_dict\_a = \{x: random.randint(1, 4) for x in sample('ABCDEFG', random.randint(3, 6))\}

rand\_dict\_b = \{x: random.randint(1, 4) for x in sample('ABCDEFG', random.randint(3, 6))\}

rand\_dict\_c = \{x: random.randint(1, 4) for x in sample('ABCDEFG', random.randint(3, 6))\}

rand\_dict\_list = \[rand\_dict\_a, rand\_dict\_b, rand\_dict\_c\]

for rand\_dict in rand\_dict\_list:

print(rand\_dict)

rs = list()

for key in rand\_dict\_a:

if key in rand\_dict\_b and key in rand\_dict\_c:

rs.append(key)

print(rs)

'''\{'C': 3, 'F': 2, 'A': 3, 'E': 4\}\{'G': 2, 'C': 4, 'D': 2, 'E': 1, 'A': 1\}\{'D': 3, 'F': 1, 'A': 3\}\['A'\]'''

使用set的求交集方式过滤。

from random import sample

rand\_dict\_a = \{x: random.randint(1, 4) for x in sample('ABCDEFG', random.randint(3, 6))\}

rand\_dict\_b = \{x: random.randint(1, 4) for x in sample('ABCDEFG', random.randint(3, 6))\}

rand\_dict\_c = \{x: random.randint(1, 4) for x in sample('ABCDEFG', random.randint(3, 6))\}

rand\_dict\_list = \[rand\_dict\_a, rand\_dict\_b, rand\_dict\_c\]

for rand\_dict in rand\_dict\_list:

print(rand\_dict)

\# dict.keys会返回key的集合

\# 使用集合求交集的方法，进行去重

print(rand\_dict\_a.keys() & rand\_dict\_b.keys() & rand\_dict\_c.keys())

对于更多dict(N)，可以使用map-reduce进行过滤。

from random import sample

from functools import reduce

rand\_dict\_a = \{x: random.randint(1, 4) for x in sample('ABCDEFG', random.randint(3, 6))\}

rand\_dict\_b = \{x: random.randint(1, 4) for x in sample('ABCDEFG', random.randint(3, 6))\}

rand\_dict\_c = \{x: random.randint(1, 4) for x in sample('ABCDEFG', random.randint(3, 6))\}

rand\_dict\_list = \[rand\_dict\_a, rand\_dict\_b, rand\_dict\_c\]

for rand\_dict in rand\_dict\_list:

print(rand\_dict)

rs = reduce(lambda x, y: x & y, map(lambda x: x.keys(), rand\_dict\_list))

print(rs)

N、队列

参数字，随机产生\[0, 100\]间的数字，用户输入数值进行猜测，提醒用户该数字大了、小了，支持历史猜测查询。

from collections import deque

NUM = random.randint(0, 100)

queue = deque(\[\], 5)

def guess(guess\_num):

if guess\_num < NUM:

print("输入数字%s小于答案数字，请重新尝试" % guess\_num)

elif guess\_num > NUM:

print("输入数字%s大于答案数字，请重新尝试" % guess\_num)

else:

print("恭喜你，答案%s正确" % guess\_num)

return True

return False

while True:

line = input("请输入所猜测数字:")

if line.isdigit():

guess\_num = int(line)

queue.append(guess\_num)

if guess(guess\_num):

break

elif line == 'history' or line == '-h':

print(list(queue))

O、使用pickle保存对象

from englishname import ALL\_ENG\_NAMES

import pickle

pickle.dump(ALL\_ENG\_NAMES, open('names.txt', 'wb'))

rs = pickle.load(open('names.txt', 'rb'))

print(rs)

二、python字符串练习

A、拆分字符串

字符串包含进程信息，中间通过空格，tab进行分隔，可以使用string内置的split()进行分隔。

process\_str = 'X250 21812 5620 cons0 14:41:44 /d/java-dev/Python36/Scripts/ipython'

rs = process\_str.split()

print(rs)

\# \['X250', '21812', '5620', 'cons0', '14:41:44', '/d/java-dev/Python36/Scripts/ipython'\]

B、拆分含有多种分隔符的字符串

1、连续使用str.split()，每次处理一种分隔符

seps = '@-.'

mails = \['isisiwish-36000-stmp@vip--vip.qq.com'\]

for sep in seps:

tmp = list()

list(map(lambda x: tmp.extend(x.split(sep)), mails))

mails = tmp

mails = \[x for x in mails if x\]

print(mails)

\# \['isisiwish', '36000', 'stmp', 'vip', 'vip', 'qq', 'com'\]

2、使用re模块的split()模块，对分隔字符进行处理

import re

mail = 'isisiwish-36000-stmp@vip--vip.qq.com'

rs = re.split(r"\[-.@\]+", mail)

print(rs)

\# \['isisiwish', '36000', 'stmp', 'vip', 'vip', 'qq', 'com'\]

C、判断字符串开头结尾

import os

rs\_list = os.listdir()

rs\_list = \[x for x in rs\_list if x.endswith('.py')\]

print(rs\_list)

参考：

数据结构python版答案_「Python」 - 内部数据结构

发表评论取消回复

还没有评论，来说两句吧...

相关阅读

相关 python数据结构

相关 python数据结构

相关 python数据结构

相关 Python数据结构

相关数据结构python版答案_「Python」 - 内部数据结构

相关 python 树数据结构_python数据结构之树

相关 Python数据结构

相关 Python数据结构

相关 Python数据结构

相关 python数据结构