python 数据结构综合实践

已知字符串s="skdaskerkjsalkj"，统计字符中字母出现的次数:

要统计字符串 s="skdaskerkjsalkj" 中各字母出现的次数，您可以使用 Python 编程语言，并且可以采用字典数据结构来存储每个字母及其对应的出现次数。以下是一个简单的 Python 代码示例来实现这一任务：

s = "skdaskerkjsalkj"

# 初始化一个空字典用于存储字母及其出现次数
char_count = {}

# 遍历字符串中的每个字符
for char in s:
    # 只统计字母（忽略非字母字符如空格、标点等）
    if char.isalpha():
        # 如果字母已经在字典中，则增加其计数
        if char in char_count:
            char_count[char] += 1
        # 否则，将其添加到字典中并设置计数为1
        else:
            char_count[char] = 1

# 打印统计结果
for letter, count in char_count.items():
    print(f"{letter}: {count}")

这段代码首先定义了待分析的字符串 s。接着，创建了一个空字典 char_count 用于存储字母及其出现次数。接下来，通过 for 循环遍历字符串中的每一个字符。对于每个字符，我们使用 isalpha() 方法判断它是否为字母。如果是字母，则在字典中查找该字母，如果已存在，则增加其计数；否则，将该字母添加到字典中并设置计数为1。

最后，遍历字典 char_count，打印出每个字母及其对应的出现次数。

# 打印统计结果
for letter, count in char_count.items():
    print(f"{letter}: {count}")

这段Python代码是用来打印字符统计结果的。这里假设 char_count是一个字典，其中的键（key）是字符（letter），值（value）是该字符出现的次数（count）。这段代码通过遍历字典 char_count的每一个键值对，并使用f-string（格式化字符串字面量）来格式化输出每个字符及其对应的计数。

详细解释如下：

用到了迭代解构点击查看

char_count.items() 返回的是一个视图对象，这个视图对象包含了字典 char_count 中所有项的键值对元组。当你在 for 循环中使用 for letter, count in char_count.items(): 时，Python 会自动将这些元组解包，也就是说，每个元组中的第一个元素（键）会被赋值给变量 letter，第二个元素（值）会被赋值给变量 count。

这是Python中迭代协议的一个应用实例，具体到字典的 .items() 方法上，它允许你同时处理字典的键和值，而不需要单独访问它们。所以，尽管 .items() 返回的是元组的集合，但在循环中，这些元组被透明地处理成了独立的变量，使得代码更简洁、易读。这是一种称为迭代器协议或迭代解构的过程。

for letter, count in char_count.items():：这是一个for循环，它遍历字典 char_count的所有项。.items()方法返回字典中的键值对作为元组，每一迭代步骤中，letter会被赋值为当前项的键（字符），count会被赋值为该项的值（计数）。
print(f"{letter}: {count}")：这一行负责打印每个字符及其出现次数。f-string是Python 3.6及以上版本引入的一种字符串格式化方式，它允许你在字符串中嵌入表达式。${letter}: ${count}中的 ${letter}和 ${count}会在打印时被替换为它们实际的值。所以，比如如果 char_count字典中有一个项是 'a': 3，这行代码就会打印出 a: 3。

综上所述，这段代码的功能是展示 char_count字典中每个字符及其出现次数的统计信息。

执行上述代码后，您将得到类似以下的输出：

s: 9
k: ½
d: 2
a: 4
r: 2
e: 1
j: 2

已知列表 li_one=[1,2,1,2,3,5,4,35,7,4,7,8]，请删除列表li_one中的重复数据。

要删除列表 li_one 中的重复数据，可以使用 Python 的内置数据结构 set，因为集合（set）不允许有重复元素。以下是具体操作步骤：

li_one = [1, 2, 1, 2, 3, 5, 4, 35, 7, 4, 7, 8]

# 将列表转换为集合以去除重复元素
unique_elements = set(li_one)

# 再将集合转换回列表
li_one_without_duplicates = list(unique_elements)

print(li_one_without_duplicates)

执行上述代码后，输出结果为：

[1, 2, 3, 5, 4, 35, 7, 8]

这样就成功地从原始列表 li_one 中删除了重复数据。

下面是一个保持元素原始顺序的方法：

`li_one = [1, 2, 1, 2, 3, 5, 4, 35, 7, 4, 7, 8]

使用列表推导式和一个辅助集合来保持顺序

li_one = [1, 2, 1, 2, 3, 5, 4, 35, 7, 4, 7, 8]
# 使用列表推导式和一个辅助集合来保持顺序
unique_li_one = []
seen = set()
for item in li_one:
    if item not in seen:
        unique_li_one.append(item)
        seen.add(item)
print(unique_li_one)

li_one=[1,2,3,4,6,7,5,1,7,8,9,5,2,0,4,5,2,3,6]
li_two=[]
for i in li_one:
    if i in li_two:
        a=1
    else:
        li_two.append(i)
print(li_two)

Python魔方阵

神奇魔方阵，又称为纵横图，是一种特殊的方阵，其中包含从 1 到 ( n \times n ) 的自然数，且满足以下条件：

元素唯一：方阵中的每个元素都是不同的。
和相等：每一行、每一列以及两条对角线（主对角线和副对角线）上各元素之和相同。
2.实例分析
下面先看如下的3*3的魔方阵:
8 1 6
3 5 7
4 9 2
观察以上的魔方阵，可以得出如下规律：
（1）1位于第1行的中间一列；
（2）2~n*n之间的各数字依次按下列规律放置：每个数所放置的行数比前-个数的行数少 1，列数比前一个数的列数多 1。例如，5位于 4的上一行、后一列。
（3）若前一个数字的行数为1，则后一个数的行数为n(最后一行）。例如，1位于第一行、中间一列，2位于最后一行、最后一列。
（4）若前一个数的列数为n，则后一个数的列数为1。例如，2位于第n列，3位于第1列。
（5）若按照上面的规则放置时某位置上已经有数字，或者前一个数字位于第1行、第n列，则将后一个数放置到前一个数字的下方。例如，4按上面的规则应被放置于第1行、第2列，但因为该位置已被其他数字1占据，所以被放置于数字3的下方。
本实例可按照以上规律实现一个5行5列的魔方阵，也就是说将1~25分别填写到方阵的前一个某位置上。我们可以先创建一个嵌套5个列表元素的列表，其中每个列表元素对应魔方阵的一行数据。

这里提供一个简单的 Python 代码示例来生成一个奇数阶的神奇魔方阵：

# 定义魔方阵的大小
n = 5

# 创建一个5x5的全零二维列表
magic_square = [[0 for _ in range(n)] for _ in range(n)]

# 初始化变量i和j
i = n // 2
j = n - 1

# 设置初始数字为1
num = 1

# 使用while循环填充魔方阵
while num <= n * n:
  
    # 检查当前位置是否已经填过数字
    if magic_square[int(i)][int(j)] != 0:
  
        # 如果当前位置已经被填过，更新i和j的值
        if i == -1 and j == n - 1:
            i = n - 2
            j = 0
        elif j == n:
            j = 0
            if i < 0:
                i = n - 1
        else:
            j = 0
            i = n - 1
  
    else:
        # 如果当前位置未被填过，将数字num填入
        magic_square[int(i)][int(j)] = num
        # 更新i和j的值
        if j == n:
            j = 0
            if i < 0:
                i = n - 1
        else:
            j = 0
            i = i - 1
        num += 1

# 打印生成的魔方阵
for i in range(0, n):
    for j in range(0, n):
        print('%2d' % (magic_square[i][j]), end='')
        if j == n - 1:
            print()

这段代码首先定义了魔方阵的大小n为5，然后创建了一个5x5的全零二维列表。接下来，初始化变量i和j分别指向魔方阵的中心位置，并设置初始数字为1。在while循环中，检查当前位置是否已经被填过数字。如果已经填过，则更新i和j的值；否则，将数字num填入当前位置并更新i和j和num的值。当num达到n*n时，循环结束，此时生成的魔方阵已经完成。最后，遍历并打印生成的魔方阵。

注意：这段代码假设输入的n为奇数，因为只有奇数阶的魔方阵才能满足所有条件。如果n为偶数，那么需要使用不同的方法来构造魔方阵。

计票机制

票数越多，排名越靠前，接受选手姓名和票数，输出排序后的成绩

#创建空字典
dirt={}
m=[]
while True:
    s=str(input("quit退出"))
    if(s=="quit"):
        break
    a=str(input("选手姓名："))
    b=int(input(("选手票数：")))
    m.append(list([b,a]))
    # print (m)
# 默认按第一个List值排列
m.sort(reverse=True)
print(m)
for i in m:
    dirt[i[0]]=i[1]
print(dirt)

手机通讯录

dirt={}
while True:
    a=int(input("操作"))
    if a==1:
        b=str(input("姓名："))
        c=str(input("手机号："))
        dirt[b]=c
    elif a==2:
        b = str(input("姓名："))
        dirt.pop(f'{b}')
    elif a==3:
        b = str(input("原始姓名："))
        q = str(input("新姓名："))
        c = str(input("手机号："))
        dirt.pop(b)
        dirt[q] = c
    elif a==4:
        b = str(input("姓名："))
        print("手机号",dirt[b])
    else:
        print(dirt)

Python神奇魔方阵，也被称为纵横图，是一种特殊的n×n方阵，其特点包括：

由自然数填充：魔方阵包含从1到n²的所有自然数，其中n为奇数。
唯一性与对称性：对于给定的n值，魔方阵是唯一的，并且具有良好的对称性。
和相等：任意一行、一列或一条对角线（主对角线和副对角线）上数字的和都是相同的，这个和通常用特定公式计算得到，即 n * (n² + 1) / 2。
元素分布规律：魔方阵的构建遵循特定的填充规则，以确保满足上述特性。这些规则可能包括但不限于：
- 数字1通常位于第一行的中间列。
- 后续数字按照某种特定的移动模式（如右上角方向）递增填充，遇到边界时回绕至相应位置继续填充。

下面是一个简单的Python实现，基于魔方阵的常见构造方法，生成一个n阶神奇魔方阵：

def create_magic_square(n):
    assert n % 2 != 0, "n must be an odd number"
  
    # 初始化一个n×n的全零矩阵
    magic_square = [[0] * n for _ in range(n)]
  
    # 中心行、中心列和起始位置
    center_row, center_col = n // 2, n // 2
    current_pos = [center_row, center_col]
  
    # 填充数字1到n²
    num = 1
    while num <= n ** 2:
        magic_square[current_pos[0]][current_pos[1]] = num
        num += 1
  
        # 更新当前位置
        current_pos[0], current_pos[1] = (
            (current_pos[0] - 1) % n,
            (current_pos[1] + 1) % n
        )
  
        # 如果当前位置已存在数字（由于回绕导致），则向上移动一行
        if magic_square[current_pos[0]][current_pos[1]]:
            current_pos[0] = (current_pos[0] - 2) % n
  
    return magic_square

# 示例：生成一个5阶神奇魔方阵并打印
n = 5
magic_5x5 = create_magic_square(n)
for row in magic_5x5:
    print(row)

这段代码首先定义了一个函数 create_magic_square(n)，用于创建一个n阶神奇魔方阵。它首先检查输入的n是否为奇数，然后初始化一个全零的n×n矩阵。接着，它确定起始位置（即第一行中间列），并从数字1开始，按照右上角方向的移动规则填充矩阵。当遇到已填充的位置时，向上移动一行以避免重复。最后，返回填充好的神奇魔方阵。

示例部分展示了如何调用该函数生成一个5阶神奇魔方阵，并将其打印出来。运行这段代码将输出一个符合神奇魔方阵特性的5×5矩阵。您可以根据需要调整 n 的值来生成不同大小的神奇魔方阵。

Python代码 magic_square = [[0] * n for _ in range(n)] 是用来初始化一个n×n大小的二维数组（即矩阵），用于创建一个空的魔法方阵（Magic Square）。这段代码使用了列表推导式（List Comprehension）这一简洁高效的语法结构。下面是对代码的详细解释：

[[0] * n]：
- 0 是一个整数值，表示我们要在矩阵中填充的初始值。这里选择0，是因为通常在创建一个空白魔法方阵时，会先用0填充所有位置，后续再按照特定规则填入其他数字。
- * n 运算符用于重复列表。在这里，它将包含单个元素0的列表重复 n次，生成一个新的列表，如 [0, 0, 0, ...]（n个0）。这个新列表代表了魔法方阵的一行。
for _ in range(n)：
- range(n) 生成一个包含从0到n-1（含0和n-1）的整数序列，用于迭代 n次。
- _ 是一个占位符变量，用于在列表推导式中表示迭代过程中不需要特别引用的临时值。这里表示我们并不关心具体的迭代次数，只需要迭代n次来创建n行。
[[0] * n for _ in range(n)]：
- 整个表达式构成了一个列表推导式，它将上述的行生成逻辑封装在方括号 [] 内，并通过 for _ in range(n) 循环执行n次。
- 每次循环，都会生成一个形如 [0, 0, ..., 0] 的列表（长度为n），并将其作为新的一行添加到最终结果列表中。
- 当循环结束后，列表推导式返回的是一个嵌套列表，即一个n×n的二维数组，其中每个元素都是0。这个二维数组就是我们所需的初始魔法方阵。

这段代码 ls=[[0 for x in range(5)] for y in range(5)] 是Python中用来创建一个二维列表（也就是一个矩阵）的方法，具体细节如下：

列表推导式（List Comprehension）: 这是一种简洁的创建列表的方式。在这里使用了两层嵌套的列表推导式来生成一个5x5的二维列表。
外层循环: for y in range(5)，这一部分实际上对于创建每一行是冗余的，因为内层已经决定了行数。但按照逻辑，它遍历了从0到4（共5个值），代表将要创建5行。
内层循环: for x in range(5)，对每个 y值（即使在这个上下文中 y的值未被直接使用），这个循环都会执行，创建一个包含5个元素的子列表。每个子列表的元素都被初始化为0。

结果: 最终得到的 ls是一个5行5列的二维列表，所有元素都是0，形如：

[
    [0, 0, 0, 0, 0],
    [0, 0, 0, 0, 0],
    [0, 0, 0, 0, 0],
    [0, 0, 0, 0, 0],
    [0, 0, 0, 0, 0]
]

总结来说，这段代码高效地创建了一个维度为5x5的二维列表，其中所有单元格都被初始化为0，作为后续操作的基础结构。

综上所述，这段Python代码 magic_square = [[0] * n for _ in range(n)] 用于初始化一个n×n的二维数组，其中每个元素均为0，作为构建魔法方阵的基础。这样得到的 magic_square可以进一步被填充实际的数字，以满足魔法方阵的特性，即每一行、每一列以及两条对角线上的数字之和均相等。

Python 中的成员运算符 in 和 not in 可用于判断字典中是否存在特定的键（key）或通过函数获取值（value）判断，但它们的行为取决于所使用的对象。

判断键（key）是否存在：
当使用成员运算符 in 或 not in 与一个字典进行比较时，如果提供的对象是字典的一个键，那么运算符将检查这个键是否存在于字典中。示例：
```
my_dict = {'apple': 3, 'banana': 2, 'orange': 5}

if 'apple' in my_dict:
    print("Key 'apple' is present in the dictionary.")
```
上述代码中，'apple' in my_dict 返回 True，因为 'apple' 是字典 my_dict 的一个键。
判断值（value）是否存在：
虽然成员运算符不直接支持对字典值的查询，但可以通过循环遍历字典的值来判断某个值是否存在。如果需要更简洁的方法，可以使用 Python 3.8 及以上版本提供的 dict.values() 方法结合 any() 函数来实现：
```
my_dict = {'apple': 3, 'banana': 2, 'orange': 5}

if 3 in my_dict.values():
    print("Value 3 is present in the dictionary.")
```
或者在较早版本的 Python 中：
```
if any(value == 3 for value in my_dict.values()):
    print("Value 3 is present in the dictionary.")
```
注意，上述代码检查的是值 3 是否在字典的任意一个条目中作为值出现。

总结来说：

成员运算符 in 和 not in 直接应用于字典时，用来判断键的存在性。
若要判断值的存在性，需要使用字典的 values() 方法结合循环、列表推导式、any() 函数等手段。

因此，成员运算符可以用于判断字典的键，而对于值的判断则需要配合额外的操作。

菜单

分享

Python数据结构综合实践|成员运算符与字典

python 数据结构综合实践

已知字符串s="skdaskerkjsalkj"，统计字符中字母出现的次数:

用到了迭代解构点击查看

已知列表 li_one=[1,2,1,2,3,5,4,35,7,4,7,8]，请删除列表li_one中的重复数据。

使用列表推导式和一个辅助集合来保持顺序

Python魔方阵

计票机制

手机通讯录

评论

arpl编译下载速度过慢？修改两个文件拯救你的下载速度（转载）

用.bat批处理文件运行conda环境下的Python程序

nat打洞(p2p)

PHP 命名空间(namespace)详解

PHP|Python 循环与条件语句内变量作用域及global、nonlocal关键字解析

Linux 使用 ‘useradd’ 命令的 ‘-g’ 选项指定组时，新用户为何不在 /etc/group 中作为组成员显示？

MySQL 外键约束

Linux输入输出(错误)重定向，分界符，解释，实例，综合实例，实际应用 cat命令解释

mysql设置约束|删除约束

MySQL 索引详解