【无标题】

5.组合数据类型（python123）

5.3单词统计

编写一个 Python 程序，获取用户输入的字符串，使用 jieba 库进行分词后，统计给定字符串中各单词出现的次数，去除标点符号，如"," “.” " "。

import jieba


text = input()
lst = jieba.lcut(text)
word_count = {}
for word in lst:
    if word not in [",", ".", " "]:
        word_count[word] = word_count.get(word, 0) + 1
for k, v in word_count.items():
    print(f"{k}: {v}")

5.5集合操作

编写一个 Python 程序，将元组(“北京”, “上海”, “广州”, “武汉”, “成都”, “上海”, “武汉”)进行一些操作，操作要求如下：‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬

1.删除重复元素
2.将元素 “北京” 更换为 “Beijing”
3.处理后所有元素使用sorted函数进行排序，并输出显示

city = ("北京", "上海", "广州", "武汉", "成都", "上海", "武汉")
city = set(city)  #用集合操作来进行删除重复元素
city.remove("北京")
city.add("Beijing")
print(sorted(city))

5.6 元组操作

# 1. 定义一个任意元组，对元组使用append() 查看错误信息
tuple1 = ('x', 'y', 3, 4, 5)
print(tuple1)
# 元组定义完成一般不可变，也没有append方法，会报错
# AttributeError: 'tuple' object has no attribute 'append'
# tuple1.append()

# 2. 访问元组中的倒数第二个元素
# 元组也是序列，因此可以使用序列操作
print(tuple1[-2])

# 3. 定义一个新的元组，和 1. 的元组连接成一个新的元组
tuple2 = ('a', 'b', 'c')
print(tuple2)
tuple3 = tuple1 + tuple2
print(tuple3)
# 组成新的元组之后会新申请一块内存存放元组，操作的两个元组不变
print(tuple1)
print(tuple2)
# 4. 计算最后得到的元组元素个数
# 可以使用len( )方法计算，也可以使用自带的__len__( )方法得到元组元素的个数，
# 元组元素的个数和总长度是一样的
print(len(tuple3))
# print(tuple3.__len__())

5.9 集合操作（集合的异或操作）

对称差分‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬

数学上，两个集合的对称差是只属于其中一个集合，而不属于另一个集合的元素组成的集合。‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬

集合论中的这个运算相当于布尔逻辑中的异或运算。

def func(m: str, n: str):
    set_m = set(map(int, m.split()))
    set_n = set(map(int, n.split()))
    result = set_m ^ set_n
    for i in sorted(result):
        print(i)
        
m_ = input()
n_ = input()
func(m_, n_)

7.面向对象（python123）

7.1

#找中位数（列表篇）
def median(self):
        lst = sorted(self.data)
        if len(lst) % 2 == 0:
            return (lst[len(lst) // 2] + lst[len(lst) // 2 - 1]) / 2
        else:
            return lst[len(lst) // 2]

class Statistics:
    def __init__(self, data: list):
        self.data = data

    def __len__(self):
        return len(self.data)

    def sum(self):
        return round(sum(self.data), 2)

    def mean(self):
        return round(self.sum() / len(self), 2)

    def median(self):
        lst = sorted(self.data)
        if len(lst) % 2 == 0:
            return (lst[len(lst) // 2] + lst[len(lst) // 2 - 1]) / 2
        else:
            return lst[len(lst) // 2]
        
s = Statistics(eval(input()))
print(len(s))  #这个可以用，因为def 函数写的是__len__(self)
print(s.sum())#这里可以用s.sum(),不能用sum(s)
print(s.mean())  
print(s.median())

7.7字典排序类

编程一个 Python 程序，构造一个用于字典排序的Dict类，该类包含以下方法：‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬

__init__方法，用于初始化排序对象，包含以下参数：
data：用于排序的数据，为一个字典
sort_dict_by_key方法，用于对字典的键进行排序，返回排序后的字典，支持升序和降序排序
sort_dict_by_value方法：用于对字典的值进行排序，返回排序后的字典，支持升序和降序排序

class Dict:
    def __init__(self, data: dict):
        """初始化"""
        self.data = data

    def sort_dict_by_key(self, reverse=False):
        """按照key排序"""
        return dict(sorted(self.data.items(), reverse=reverse))

    def sort_dict_by_value(self, reverse=False):
        """按照value排序"""
        return sorted(self.data.items(), key=lambda x: x[1], reverse=reverse)


d = Dict(eval(input("")))
print(d.sort_dict_by_key())
print(d.sort_dict_by_value())
print(d.sort_dict_by_key(True))
print(d.sort_dict_by_value(True))

7.9markdown方法

class Markdown:
    def __init__(self):
        self.content = ""

    def title(self, text, level):
        if level == 1:
            self.content += f"# {text}\n\n"
        elif level == 2:
            self.content += f"## {text}\n\n"
        elif level == 3:
            self.content += f"### {text}\n\n"
        elif level == 4:
            self.content += f"#### {text}\n\n"
        elif level == 5:
            self.content += f"##### {text}\n\n"
        elif level == 6:
            self.content += f"###### {text}\n\n"

    def code(self, text, style, lang: str = "python"):
        if style == "inline":
            self.content += f"`{text}`\n\n"
        elif style == "block":
            self.content += f"```{lang}\n{text}\n```\n\n"

    def print(self):
        print(self.content)


m = Markdown()
m.title("Hello World", 1)
m.title("Hello World", 2)
m.title("Hello World", 3)
m.title("Hello World", 4)
m.title("Hello World", 5)
m.title("Hello World", 6)
m.code("print('Hello World')", "inline")
m.code("print('Hello World')", "block")
m.print()