按着不同基础的同学，顺序总结每级别快速必备 snipper code
Junior
Primary
Intermediate
Senior

例如 字典结构优雅的Pythonic风格

1、牌桌上有一副牌，统计四个花色的牌各有多少张，输出为全称
{'C':'Club',
'H':'Heart',
'D':'Diamand',
'S':'Spader'}

solve by code

DECK = ['2S','3S','4S','5S','6S','7S','8S','9S','10S','JS','QS','KS','AS',
        '2D','3D','4D','5D','6D','7D','8D','9D','10D','JD','QD','KD','AD',
        '2H','3H','4H','5H','6H','7H','8H','9H','10H','JH','QH','KH','AH',
        '2C','3C','4C','5C','6C','7C','8C','9C','10C','JC','QC','KC','AC']

def define_suit(card):
    return # Good luck

# ericlee new tasks
def countSuit(DECK):
    suit = {'C':'Club',
            'H':'Heart',
            'D':'Diamand',
            'S':'Spader'}

    collect = {'Club':0,
               'Heart':0,
               'Diamand':0,
               'Spader':0}
    for card in DECK:
        collect[suit[card[-1]]] += 1 #why [-1 instead of [1]
    return collect
print(countSuit(DECK))

{'Club': 13, 'Heart': 13, 'Diamand': 13, 'Spader': 13}

2、模拟 n 个人发牌，输出每个人手里拿到的牌
两个函数 deal() 和 shuffle()

#2 模拟洗牌 shuffle()

def deal(DECK,n): # n == 人数
    random.shuffle(DECK)

    person = []
    for i in range(n):
        c = DECK[i:len(DECK):n]
        person.append(c)
    return person

#3  模拟发牌
# 黑桃Spade, 方片Diamond,红桃heart,梅花Club,

def shuffle(person):
    cards = []
    for card in person:
        suit = {'C':[],
                'H':[],
                'D':[],
                'S':[]
                }

        for c in card:
            suit[c[-1]].append(c)
            #print(suit)
        cards.append(suit)
    return cards

n = 4
print('shuffle: ',shuffle(person))

[{'C': ['KC', '10C', '3C'], 'H': ['3H', 'JH', '8H', '5H'], 'D': ['KD', '3D', '2D', '8D'], 'S': ['3S', 'QS']}, 

{'C': ['4C', 'JC'], 'H': ['AH'], 'D': ['AD', 'JD', '7D', '5D', '9D'], 'S': ['10S', 'JS', '2S', 'KS', 'AS']}, 

{'C': ['7C', '2C', 'AC', '6C', 'QC', '9C', '5C'], 'H': ['QH'], 'D': ['QD'], 'S': ['8S', '4S', '9S', '6S']},

{'C': ['8C'], 'H': ['6H', '2H', '7H', '10H', '4H', '9H', 'KH'], 'D': ['10D', '6D', '4D'], 'S': ['7S', '5S']}]

3、洗牌后实现下面顺序：
自上而下2，3，.... J, K , Q, A
花色依顺序为：黑桃spade, 方片diamond,红桃, heart,梅花club,

代码 A- for loop + slice

def T_shape(rect):
    s_line, d_line, h_line, c_line = rect[:13], rect[13:26], rect[26:39], rect[39:]
    for i in range(13):
        print(f"{c_line[i]} {h_line[i]} {d_line[i]} {s_line[i]}")

print(T_shape(DECK))

OUTPUT:

2C 2H 2D 2S
3C 3H 3D 3S
4C 4H 4D 4S
5C 5H 5D 5S
6C 6H 6D 6S
7C 7H 7D 7S
8C 8H 8D 8S
9C 9H 9D 9S
10C 10H 10D 10S
JC JH JD JS
QC QH QD QS
KC KH KD KS
AC AH AD AS

代码 B - import numpy as np 转置

import numpy as np
DECK = [DECK[i:i+13] for i in range(0,len(DECK),len(DECK)//4)]
A = np.mat(DECK)
print(A.T)

[['2S' '2D' '2H' '2C']
 ['3S' '3D' '3H' '3C']
 ['4S' '4D' '4H' '4C']
 ['5S' '5D' '5H' '5C']
 ['6S' '6D' '6H' '6C']
 ['7S' '7D' '7H' '7C']
 ['8S' '8D' '8H' '8C']
 ['9S' '9D' '9H' '9C']
 ['10S' '10D' '10H' '10C']
 ['JS' 'JD' 'JH' 'JC']
 ['QS' 'QD' 'QH' 'QC']
 ['KS' 'KD' 'KH' 'KC']
 ['AS' 'AD' 'AH' 'AC']]

Python是一种高级的、通用的、解释性的编程语言。它以非常容易学习但功能强大而闻名，在许多不同的领域有许多用途。

如果你是一个想开始学习Python的人，很容易在互联网上所有优秀的学习资源中迷失。

现在这篇文章并不是想成为那群人中的另一个头。相反，在这里我将向你介绍 Python 的基础知识，并为你指出正确的方向。

在这篇文章中，我将在大量代码实例的帮助下介绍Python编程语言的基础知识。我将对它们进行非常详细的解释，并包括进一步学习的链接。

一旦我向你介绍了该语言的基本水平，我将向你推荐一些优秀的学习资源，并解释如何充分利用它们。

虽然我会对代码实例进行详尽的解释，但我假设你已经熟悉了常见的编程概念，如表达式、语句、变量、函数等等。所以我不会花时间详细解释这些编程概念--相反，我将重点介绍Python实现/使用它们的方式。

不多说了，让我们开始吧

目录

Python的高层概述
如何用Python写 "你好，世界"？
Python 中的变量
Python中的数据类型
如何在Python中写注释
Python中的字符串
Python中的数字
如何在Python中处理用户输入
Python中的if-else-elif
Python中的match-case
Python中的列表和元组
Python中的循环
Python中的字典
Python中的函数
其他Python学习资源

总结
Python的高级概述
在我开始编码之前，你需要在你的系统上安装并准备好 Python。根据你所运行的系统--Windows、macOS或Linux--安装过程会有所不同。

如果你是在Windows上，我的同伴freeCodeCamp的作者Md. Fahim Bin Amin写了一篇关于如何在Windows上安装Python的优秀指南。另一位作者 Dillion Megida 写了另一篇关于如何在 Mac 上安装 Python 3 的优秀文章。

一些平台，例如一些现代的Linux发行版，已经预装了相当最新的Python版本。因此，如果你是在Linux上，执行下面的命令来检查你的Python版本。

python3 --版本
在你的系统上安装任何版本的Python 3都足够了。除了Python之外，你还需要一个非常适合编写Python代码的代码编辑器或IDE。

在我的Python IDE --Python的最佳IDE和编辑器一文中，我列出了三个最好的代码编辑器和IDE，你可以用来编写Python代码。

所以，如果你已经有了 Python 和一个代码编辑器或 IDE，让我们继续写你的第一段 Python 代码。

如何用 Python 编写 Hello, World!
在你的电脑中的某个地方，创建一个名为program.py的新文件，并在其中放入以下代码。

print('Hello, World!')
要运行这段代码，在你放置program.py文件的目录中打开终端，并执行以下命令。

在Windows和MacOS上

python program.py

在Linux上

python3 program.py
代码的输出将是你作为print()函数的参数所传递的内容，在这个代码片断中，它是。

Hello, World!
正如你可能已经猜到的，print() 是一个内置的 Python 函数，可以在控制台中打印你给它的任何东西。这个函数可以打印字符串、数字、表达式--或多或少，你可以把任何东西扔给它。

print('Hello, World!')
print(100)
print(5 + 5)

第一条语句打印出字符串Hello, World！就像以前一样。第二条语句打印出一个数字，第三条语句打印出5+5表达式的结果。

Hello, World!
100
10

有一点你可能注意到了，也可能没有注意到，这三个打印语句是在三个独立的行中输出的。而在其他语言中，如C/C++/C#/Java，你必须明确附加一个换行符。

事实证明，print()的功能默认为换行符，你可以覆盖这个默认行为，如下。

print('Hello, World!', end=' | ')
print(100, end=' | ')
print(5 + 5)

现在，程序的输出将是。

Hello, World! | 100 | 10

这意味着你作为end参数的值传递的任何字符串都将被用作打印行的结束符。

在这里，我使用了|作为前两条语句的结束符。但是，我使用了默认的换行符作为最后一条语句的结束符。

你可以通过玩耍或阅读该函数的官方文档来了解更多关于 print() 函数的信息。

Python 中的变量
要在Python中声明一个变量，首先要写出变量的名称，然后是等号，接着是变量的值。

name = 'Farhan

print('我的名字是' + name)

这段代码的输出将是

我的名字是Farhan

正如你所看到的，声明一个变量没有特殊的关键字。Python 很聪明，可以从你所赋的值中得到变量的类型。

在上面的例子中，name变量包含Farhan字符串。由于Farhan这个词在引号内，Python将把这个变量当作一个字符串。

在Python中，你可以使用加号将两个字符串连接起来。这就是我们在上面的 print() 语句中所做的。但是如果你把代码改成如下。

name = 'Farhan
年龄=27

print('我的名字是' +名字)
print('I am ' + age + 'year old')

并尝试运行这个程序，你会面临以下问题。

我的名字是Farhan
回溯（最近一次调用）

  File "C:\Users\shovi\repos\python-playground\hello-world.py", line 5, in <module>.
    print('I am ' + age + 'year old')

类型错误：只能将str（而不是 "int"）串联到str上

正如你所看到的，字符串只能与字符串相连接，而age变量是一个整数。有一种更好的方法可以在字符串语句中嵌入变量。

name = 'Farhan'
age = 27

print(f'My name is {name}')
print(f'I am {age} years old')

我希望你已经注意到在print()语句内的字符串开头的f。这个f把字符串变成了f-strings。这些字符串在运行时被评估，所以在 f-字符串里面，你可以把任何有效的 Python 语句放在大括号里。这使得在字符串中嵌入变量或甚至简单的逻辑变得非常容易。

你可以在程序的任何地方重新声明你的变量。如果你愿意，你甚至可以改变它们的类型。

a = '这是一个字符串'
a = 10
print(a)

这是一个完全有效的程序，a的值将被打印为10，因为你已经在第二行覆盖了初始值。

Python中的数据类型
在Python中，有四种主要的文字类型，你需要注意。

整数 1
浮点 2.0
布尔型真
字符串 'freeCodeCamp'

类型举例

整数和浮点是不言自明的。布尔值可以是真或假，而Python中的字符串可以用单引号或双引号括起来。我更喜欢使用单引号。你可以使用你喜欢的一种，但尽量不要把两种类型的引号混在一起。

Python 中的注释
Python 中的注释以一个哈希符号开始。

# 这个像‘井’字的符号后面，并不会执行，只是一个注释

多行：使用引号如：''' 注释内容在此 '''
使用哈希符号写的注释只能是单行的。如果你想在Python中写多行注释，你就必须使用引号，如下所示。

'''这是个注释
 一直到
 和
 and on...'''

根据需要对你的代码进行注释是一种很好的记录方式。但要确保你不要在只看代码就能轻松理解的地方添加注释。

Python 中的字符串
Python 中的字符串是 Unicode 字符的有序集合。字符串在运行时不能被修改。你已经看到了如何声明一个字符串。在本节中，你将学习常见的字符串操作。

在一个字符串中，每个字符都会有一个索引。和数组一样，字符串的索引是基于零的。

name = 'Farhan'

# F -> 0
# a -> 1
# r -> 2
# h -> 3
# a -> 4
# n -> 5

可以使用这些索引来访问这些字符，如下所示。

name = 'Farhan'
print(name[0])
print(name[1])
print(name[2])
print(name[3])
print(name[4])
print(name[5])

F
a
r
h
a
n

这个程序的输出将如下。

你可以使用这些索引做的另一件有趣的事情是切片。假设你想从一个字符串中取出一个部分。

name = 'Chongqin'
print(name[0:3])

这个程序的输出将是

Chon

在这个例子中，name[0:3]意味着从索引0到索引3开始打印。现在你可能认为h在索引3处，你会认为这是对的。但关于切片的问题是，它不包括结束索引处的字符。

如果你想了解更多关于分片的知识，有一篇题为《如何在Python中对字符串进行分片》的文章，你可能会发现很有用。

你可以使用 len() 函数来计算一个字符串的长度，如下所示。

name = 'Chongqin'
print(len(name))

这个程序的输出结果将是 8，因为字符串中有六个字符。

Python 有大量的字符串方法，但在这里不可能逐一演示，所以我将演示一些最常用的方法。

第一个方法是 capitalize()。这个方法返回一个给定字符串的副本，其第一个字符大写，其余的小写。

print('Python is awesome'.capitalize())

这段代码的输出将是Python is awesome。如果你想把整个句子转换成大写字母，可以使用 upper() 方法。

print('python is awesome'.upper())

这段代码的输出将是PYTHON IS AWESOME。你可以用lower()方法做相反的事情。

print('PYTHON IS AWESOME'.lower())

这段代码的输出将是Python is awesome。有isupper()和islower()方法来检查一个字符串是大写还是小写。

print('PYTHON IS AWESOME'.islower())
print('PYTHON IS AWESOME'.isupper())
#代码的输出将如下：
False
True

如果你想在一个字符串中替换所有出现的子串，你可以通过使用replace()方法来实现。

print('python is awesome'.replace('python', 'freeCodeCamp'))

这段代码将用freeCodeCamp替换给定字符串中所有出现的python。

最后，还有 split() 和 join() 方法。第一个方法是将一个字符串分割成一个列表。

print('python is awesome'.split(' '))

该方法需要一个分隔符来分割字符串。在这里，我使用了空格作为分隔符。这个代码的输出将是 ['python', 'is', 'awesome']。这是一个列表。我们还没有讨论过列表，但我们很快就会讨论。现在，请理解它们就像数组一样。

你可以使用join()方法，用一个可迭代的元素，也就是一个列表，产生一个新的字符串。

print(' '.join(['python', 'is', 'awesome'])

我在一个空格上调用了join()方法，所以这段代码的结果将是一个在中间使用空格连接的字符串，如下所示。

python是很好的
如果你想了解更多关于Python中所有的字符串方法，请随时查阅官方文档。

Python中的数字
Python中的数字可以是整数、浮点和复合类型。在这篇文章中，我只讨论与实数有关的操作，即整数和浮点数。

你可以使用整数和浮点数进行加、减、乘、除运算，就像在其他编程语言中一样。

a = 10
b = 5

print(a+b)
print(a-b)
print(a*b)
print(a/b)

这段代码的输出将如下。

15
5
50
2.0

需要记住的一点是，即使你在两个整数之间进行除法运算，其结果也总是浮点数。如果你想让结果是一个整数，你可以这样做。

a = 10
b = 5
print(a//b)

这一次，结果将是一个整数。要注意的是，如果小数点后有任何数字，它们会被砍掉。
如果你想了解更多关于Python中的数字类型，可以随时查阅官方文档。

如何在 Python 中处理用户输入
对于接受用户的输入，有一个 input() 函数。

name = input('你的名字是什么? ')
print(f'我的名字是 {name}')

这个程序的输出将如下。

你的名字是什么？ 丁丁猫 <——光标闪烁在此输入名字
你的名字是丁丁猫
input()函数将用户的输入保存为字符串，即使用户输入的是数字。因此，如果你从用户那里接受一个数字作为输入，一定要把它转换为适当的数据类型。

Python中的if-elif-else
像其他编程语言一样，Python有常见的if-elif-else语句。

a = float(input('First: '))
b = float(input('Second: '))
op = input('操作(sum/sub/mul/div): ')

if op == 'sum':
    print(f'a + b = {a+b}' )
elif op == 'sub':
    print(f'a - b = {a-b}')
elif op == 'mul':
    print(f'a * b = {a*b}')
elif op == 'div':
    print(f'a / b = {a/b}')
else:
    print('无效的操作！')

这是一个非常简单的计算器程序。根据你选择的操作，计算器将执行上述操作之一。

在Python中，诸如if块或elif块或else块的代码块以关键字和冒号开始。

缩进在Python中是至关重要的，如果你在代码块中缩进的代码不合适，代码将无法运行。

Python中的match-case
在Python中，匹配大小写相当于其他编程语言中的开关大小写语句。前面提到的计算器程序可以用 match-case 重写如下。

a = float(input('First: '))
b = float(input('Second: '))
op = input('操作(sum/sub/mul/div): ')

match op:
    case 'sum':
        print(f'a + b = {a+b}' )
    case 'sub':
        print(f'a - b = {a-b}')
    case 'mul':
        print(f'a * b = {a*b}')
    case 'div':
        print(f'a / b = {a/b}')
    case _:
        print('无效的操作！')

同样，根据op的值，将执行其中一种情况。如果用户的输入与任何一种情况都不匹配，那么通配符_的操作就会发生。

请记住，match-case只在Python 3.10及以后的版本中可用。所以如果你使用的是旧版本，你可能没有这个语句。

Python 中的列表和图元
Python 中的列表是一个值的序列。你可以在运行时修改列表。你可以创建一个列表，如下所示。

vowels = ['a', 'e', 'i', 'o', 'u']
print(vowels)

这个程序的输出将是['a', 'e', 'i', 'o', 'u']。像字符串一样，Python 列表中的每个元素都有一个索引，这些索引从零开始。

vowels = ['a', 'e', 'i', 'o', 'u']
print(vowels[0])
print(vowels[1])
print(vowels[2])
print(vowels[3])
print(vowels[4])
print(vowels[5])

注意最后的 vowels[5] 会报什么错误提示？

汉英对照看
元音 = ['a', 'e', 'i', 'o', 'u']
print(vowels[0])
print(vowels[1])
print(元音[2])
print(元音[3])
print(元音[4])

像字符串一样，你也可以对列表进行切分，切分列表的语法与字符串的语法是一样的。

Python 中的列表有很多有用的方法。要向列表中添加新的项目，有 append()、extend() 和 insert() 方法。

append()方法在列表中添加一个新项，extend()方法添加多个项。

vowels = ('a', 'e', 'i', 'o', 'u')
print(vowels)

元音 = ['a', 'e']
vowels.append('i') ：元音.扩展(['o', 'u'])

另一方面，insert()方法在列表中的指定索引处插入一个项目。

vowels = ['a', 'i', 'o', 'u']
vowels.insert(1, 'e')
print(vowels)

pop()方法将最后一个元素从列表中弹出。

vowels = ['a', 'e', 'i', 'o', 'u']
popped_item = vowels.pop()
print(popped_item)
print(vowels)

#这段代码的输出将是
u
['a', 'e', 'i', 'o']

remove()方法可以从列表中删除一个给定的元素。

vowels = ['a', 'e', 'i', 'o', 'u']
vowels.remove('e')
print(vowels)

这将从元音列表中删除e。

最后是 clear() 方法，它将从列表中删除所有的元素。

vowels.clear()

非常有用的sorted和sortt()方法：

vowels = ['u', 'e', 'a', 'o', 'i'] 
vowels.sort()
print(vowels)

sort()方法以升序对列表进行排序。这个方法对列表进行原地排序。这意味着它不会返回一个新的列表，而是对原始列表进行排序。

如果你想反转列表，有 reverse() 方法。

vowels = ['u', 'e', 'a', 'o', 'i']
vowels.reverse()
print(vowels)

这也是一个像sort一样的就地方法。它只是排序方法的反向（没有双关语的意思）。你可以从官方文档中了解更多关于列表的信息。

sorted()

vowels = ['u', 'e', 'a', 'o', 'i']
sorted(vowels )

输出alphbet字母表顺序
['a', 'e', 'i', 'o', 'u']

在 Python 中还有一种叫做元组的不可变的序列类型。元组与列表很相似，但你不能修改元组。

vowels = ('a', 'e', 'i', 'o', 'u')
print(vowels)

这段代码的输出将是（'a', 'e', 'i', 'o', 'u'）。元组不同于列表[]，元组的方法不多。如果你想了解更多关于图元的信息，请查阅官方文档。

Python中的循环
你可以在 Python 中使用循环来迭代一个像列表一样的序列类型。

vowels = ['a', 'e', 'i', 'o', 'u'] 。

for letter in vowels:
    print(letter.upper())

还有 while 循环，但由于 for 循环是你主要使用的，我不会花时间解释 while 循环。

Python中的字典
让我们假设我给了你一行 "快速的棕色狐狸跳过了懒惰的狗"，并告诉你要计算每个字母出现的次数。你可以使用哈希姆普（hashhmap）轻松完成这个任务。

hashmap是一个键值对的集合。

{
    key_1: value_1,
    key_2: value_2,
    key_3: value_3,
    key_4: value_4,
    key_5: value_5,
}

为了完成我之前给你的任务，你可以写下面的代码。

sentence = 'the quick brown fox jumped over the lazy dog'

record = {}

for letter in sentence:
    if letter in record:
        record[letter] += 1
    else:
        record[letter]=1

print(record)

这段代码的输出将如下。

{'t': 2, 'h': 2, 'e': 4, ' ': 8, 'q': 1, 'u': 2, 'i': 1, 'c': 1, 'k': 1, 'b': 1, 'R': 2, 'O': 4, 'W': 1, 'n': 1, 'f': 1, 'x': 1, 'j': 1, 'M': 1, 'P': 1, 'D': 2, 'V': 1, 'L': 1, 'A': 1, 'Z': 1, 'y': 1, 'g': 1}

这是一个字典。每个字母是一个键，它们的出现次数是值。在代码片段中，你在第二行声明了一个 dictionary。

Estefania Cassingena Navone 写了一篇名为《Python Dictionary 101: A Detailed Visual Introduction》的文章，你可以参考它以了解更多关于字典的信息。

Python 中的函数
我将讨论的最后一个概念是函数。编程中的函数是执行某种任务的大块代码。

在 Python 中，你可以使用 def 关键字和函数签名来声明一个函数。

def sum(a, b):
    return a + b

def sub(a, b):
    return a - b

def mul(a, b):
    return a * b

def div(a, b):
    return a / b

a = float(input('First: '))
b = float(input('Second: '))
op = input('Operation (sum/sub/mul/div): ')

if op == 'sum':
    print(f'a + b = {sum(a, b)}')
elif op == 'sub':
    print(f'a - b = {sub(a, b)}')
elif op == 'mul':
    print(f'a * b = {mul(a, b)}')
elif op == 'div':
    print(f'a / b = {div(a, b)}')
else:
    print('Invalid Operation!')

部分汉化解释

def sum(a, b):
    返回 a + b

def sub(a, b):
    返回 a - b

def mul(a, b):
    返回 a * b

def div(a, b):
    返回 a / b

a = float(input('First: '))
b = float(input('Second: '))
op = input('操作(sum/sub/mul/div): ')

如果op == 'sum':
    print(f'a + b = {sum(a, b)}' )
elif op == 'sub':
    print(f'a - b = {sub(a, b)}')
elif op == 'mul':
    print(f'a * b = {mul(a, b)}')
elif op == 'div':
    print(f'a / b = {div(a, b)}')
否则。
    print('无效的操作！')

这和以前的计算器程序是一样的，但现在的操作都写在独立的函数中。

要了解更多关于函数的信息，你可以阅读这篇文章。
Bala Priya C.撰写的《Python中的函数--用代码实例进行解释》。

如果你想成为一个优秀的Python程序员，还有很多其他的概念需要学习。

MoreThanSentiments:

一个用于文本量化的Python库

一个帮助研究人员在python中计算模板、冗余度、特异性、相对流行性等的函数集合。

照片：Patrick Tomasso on Unsplash

简介

MoreThanSentiments

Jiang和Srinivasan，2022年

是一个python库，用来帮助研究人员

计算模板（Lang和Stice-Lawrence，2015年）

冗余度（Cazier和Pfeiffer，2017年）

特异性（Hope等人，2016年）

相对流行率（Blankespoor，2019年）等

现在，人们经常谈论文本嵌入、语义相似性、意图检测和情感分析......

然而，MoreThanSentiments的灵感来自于正确量化文本结构也将帮助研究人员提取大量有意义的信息。

在文本分析中，模板是指可以从一个句子中删除而不明显改变原意的词汇组合。换句话说，它是一种信息量的衡量标准。它是根据含有模板的句子与总字数的比例来计算的。

import MoreThanSentiments as mts
my_dir_path =  "D:/data_science/seaborn.txt"
df = mts.read_txt_files(PATH = my_dir_path)
my_dir_path = "D:/data_science/seaborn.txt"

df = mts.read_txt_files(PATH = my_dir_path)
df['sent_tok'] = df.text.apply(mts.sent_tok)

#my_dir_path = "D:/YourDataFolder" 
my_dir_path =  "D:/data_science/seaborn.txt"
df = mts.read_txt_files(PATH = my_dir_path)

df['sent_tok'] = df.text.apply(mts.sent_tok)


df['cleaned_data'] = pd.Series()    
for i in range(len(df['sent_tok'])):
    df['cleaned_data'][i] = [mts.clean_data]
                             
    df['cleaned_data'] = df.text.apply(mts.clean_data, args=(True, True, False, True, False))

    df['Boilerplate'] = mts.Boilerplate(sent_tok, n = 4, min_doc = 5)

    df['Redundancy'] = mts.Redundancy(df.cleaned_data, n = 10)

    df['Specificity'] = mts.Specificity(df.text)

    df['Relative_prevalence'] = mts.Relative_prevalence(df.text)

冗余度

冗余度是对文本有用性的一种衡量。它被定义为在每个文档中出现一次以上的超长句子/短语（例如10克）的百分比。直观地说，如果一个超长的句子/短语被重复使用，这意味着作者试图强加以前提到的重复信息。

特异性

特异性是衡量与某一特定主题唯一相关的质量。它被定义为特定的实体名称、数量值和时间/日期的数量，这些都是以文档中的总字数为尺度。目前，特异性的功能是建立在spaCy的命名实体识别器上。

相对普遍性

相对普遍性是对硬信息的一种衡量。它是数值的数量与整个文本的长度的对比。它有助于评估一个给定文本中的定量信息部分。

安装

安装工具箱最简单的方法是通过pip（某些发行版的pip3）。

使用方法

导入软件包

从txt文件中读取数据

这是一个内置函数，可以帮助你在python中读取一个由分离的.txt文件组成的文件夹。如果你已经将所有的数据存储在一个.csv文件中，你可以像平常一样用pandas读取该文件。

句子标记

如果你想计算模板和冗余度，有必要对句子进行标记，因为n-grams是在句子层面产生的。

清洁数据

如果你想在句子层面上进行清理。

如果你想在文档层面上进行清理。

对于数据清理功能，我们提供以下选项。

小写：使所有的字都小写

标点符号：删除语料库中的所有标点符号

数字：删除语料库中的所有数字

unicode：删除语料库中的所有Unicode。

stop_words：删除语料库中的停顿词。

模板

参数。

input_data：这个函数需要标记化的文档。

n：要使用的n-grams的数量。默认为4。

min_doc：在建立n-gram列表时，忽略那些文档频率严格低于给定阈值的n-grams。默认值为5个文档。建议使用文档数的30%。

冗余度

参数。

input_data：这个函数需要标记化的文档。

n：要使用的n-grams的数量。默认为10。

特异性

参数。

input_data：这个函数需要没有标记化的文件。

相对普遍性

参数。

input_data：这个函数需要没有标记化的文件。

结论

MoreThanSentiments仍然是一个发展中的项目。但它已经显示出帮助不同领域的研究人员的潜力。这个软件包简化了量化文本结构的过程，并为他们的NLP项目提供各种文本评分。

以下是完整例子的链接。

Python脚本

Python Jupyter笔记本

我与堪萨斯大学商学院商业分析助理教授Karthik Srinivasan博士合作了这个项目。

这是《和Pj一起学Python！》系列的第三部分。
请务必阅读
第一部分--入门，
第二部分--列表和循环，
以及第三部分--函数和字符串。

到目前为止，我已经用Python学到了很多东西，但是当我学到字典（有时简称为dicts）时，我对可以做的事情非常兴奋。Python 中的字典是一系列的键和值，存储在一个单一的对象中。这有点像一个超级数组；它允许你将键和值连接在一起，成为一个容易访问的来源。从数组中创建字典实际上也可以非常简单。

在这篇博客中，我将深入探讨如何创建字典以及如何在代码中读写文件。
字典
Python 中的字典是用大括号来表示的，或者我喜欢叫它小胡子。 { } 表示你正在看的列表根本就不是一个列表，而是一个字典。

shows_and _characters = {
    "Bojack Horseman"。"Todd",
    "My Hero Academia": "Midoriya"
    "Ozark": "Ruth"
    "Arrested Development": "托比亚斯"。
    "Derry Girls": "迈克尔修女"。
    "Tuca & Bertie": "Bertie"
    }

这是一个关于我最喜欢的电视节目和该节目中我最喜欢的人物的字典。在这个例子中，键在左边，值在右边。要访问字典，你要使用与列表类似的调用，只是不使用元素编号，而使用键。 print(shows_and_characters["Ozark"]) 会将 Ruth 打印到控制台。此外，这个例子中的键和值都是字符串，但这并不是一个要求。键可以是任何不可变的类型，如字符串、ints、floats和tuples。值没有这个限制，因此值可以是一个嵌套的字典或一个列表，此外还有提到的键的类型。例如，下面这个字典是一个有效的字典。

shows_with_lists = {
    "Bojack Horseman"。["Todd", "Princess Carolyn", "Judah", "Diane"] 。
    "我的英雄学院"。["Midoriya", "Shoto", "All Might", "Bakugo", " Kirishima"]。
    "Ozark": ["Ruth", "Jonah", "Wyatt"] 。
    "Arrested Development": ["Tobias", "Gob", "Anne", "Maeby"] 。
    "Derry Girls": ["迈克尔修女"、"奥拉"、"艾琳"、"克莱尔"、"詹姆斯"]。
    "图卡和伯蒂"。["Bertie", "Speckle", "Tuca", "Dakota"]
    }

在这个例子中，每个值都是一个列表。因此，如果我们试图打印键 "Derry Girls "的值，我们会看到

["Sister Michael", "Orla", "Erin", "Claire", "James"] 

打印到控制台。然而，如果我们想要值列表中的最后一个元素，我们会写 shows_with_lists["Derry Girls"] [-1]。这将打印列表中的最后一个元素，在本例中就是 James

字典可以手动编写，或者，如果你有两个列表，你可以结合 dict() 和 zip() 方法使列表变成一个字典。

list_of_shows = ["Bojack Horseman",
                 "我的英雄学院",
                 "Ozark",
                 "Arrested Development",
                 "Derry Girls",
                 "Tuca & Bertie"]
list_of_characters = [["Todd", "Princess Carolyn", "Judah", "Diane"],
                      ["绿谷", "庄户", "全能", "巴古", "雾岛"],
                      ["Ruth", "Jonah", "Wyatt"],
                      ["托比亚斯"、"戈布"、"安妮"、"马比"]。
                      ["迈克尔修女"、"奥拉"、"艾琳"、"克莱尔"、"詹姆斯"]。
                      ["Bertie", "Speckle", "Tuca", "Dakota"].

combined_shows_characters = dict(zip(list_of_shows, list_of_characters))

print(combined_shows_characters)

这是创建字典的一种方法。另一种叫做字典理解。这个要多花点功夫，但可以用在各种不同的地方，包括在一个单一的列表上使用一点逻辑，用这个原始列表生成一个字典。下面用两个例子来说明：一个是基于上述列表的，另一个是用单个列表和一些逻辑。
输入数学

这是在做与上面的例子相同的工作，但用Dict Comprehension代替。

comprehension_shows_characters = { shows:characters for shows, characters in zip(list_of_shows, list_of_characters) }

hip_to_be_square = [4, 9, 16, 25, 36, 49] 。

no_longer_hip_to_square = { key:math.sqrt(key) for key in hip_to_square }

print(no_longer_hip_to_be_square)

在 no_longer_hip_to_square 字典中，key 在 hip_to_square 列表中找到。每个键的值是它自己的平方根，用 import math 函数带来的。这里还有很多处理字典的有用方法。
读取和写入文件
这是 Python 的一个相当酷的部分：在代码中直接读写其他文件。有了Python，你能够获取某些类型文件的内容并在你的代码中使用它，甚至可以根据一些输入创建一个新的文件。这对数据处理很有用，可以用于各种文件类型。我在这里要介绍的两个文件是.csv和.txt。

从文件中阅读
想象一下，有一个名为best-ever.txt的文件，其中有一行我最喜欢的电视节目是Derry Girls。我们可以用Python将这一行变成一个变量。运行下面的代码将把.txt文件的内容打印到终端。

with open("best-ever.txt") as text_file:
  text_data = text_file.read()

#这将打印出.txt文件的内容。
print(text_data)

通过使用与open(NAME OF FILE)作为VARIABLE_NAME:，我们可以将文件的内容作为一个单一的字符串来检查。如果文件有多行，你甚至可以通过使用for循环和.readlines()方法，通过迭代来分离这些行。使用一个名为buncha-lines的假想的.txt文件，我们可以使用下面的方法来单独打印出每一行。

with open("buncha-lines.txt") as lines_doc:
  for line in lines_doc.readlines():
    print(line)

写入一个新文件
用 Python 创建一个新文件也很容易。open()函数可以接受一个额外的参数，以便创建一个新的文件。事实上，有一个默认的参数，每次都是在我们不知道的情况下被传递的！r是open()的默认参数，使其处于读模式。要打开写模式，可以在第二个参数中传入一个w。下面的代码将写一个全新的文件，名为best_tv_character.txt，内容是《广告狂人》中的Peggy Olson。

with open("best_tv_character.txt", "w") as best_character:
    best_character.write("Peggy Olson from Mad Men")

使用.csv文件
通过在文件的开头使用 import csv，然后在代码中使用它的一些内置方法，你可以用 Python 读取 .csv 文件。然而，尽管 .csv 文件是纯文本，像对待 .txt 文件一样对待 .csv 文件会导致难以阅读的输出；毕竟，电子表格的意义在于将信息列表。如果没有这个表格，输出结果可能会很混乱。

一个解决这个问题的方法是使用dictreader()方法。这个方法允许你将每一行的信息映射到一个你可以创建字段名的字典中。如果没有给出字段名，则从.csv的第一行收集默认的字段名。想象一下，一个.csv文件中的列标有："网络"、"节目名称"、"季节"。也许我们只想从这个.csv文件中打印出季节的数量。

import csv 

with open("shows.csv") as shows_csv:
  shows_dict = csv.DictReader(shows_csv)
  for row in shows_dict:
    print(row["Seasons"])

这将在新的一行中向控制台打印.csv中存在的每一行的季节数。
就像对待 .txt 文件一样，你也可以用 Python 创建 .csv 文件。这有点复杂，因为你需要定义标题，或列名，但它仍然是一个快速的过程。这可以用来把列表变成 .csv 文件。让我们看看下面的例子。

import csv

working_list = [{"网络": "Netflix", "节目名称": "Bojack Horseman", "季数":6}, 
                {"Network": "Channel 4", "Show Name": "Derry Girls", "Seasons": 3}, 
                {"Network": "HBO Max", "Show Name": "Our Flag Means Death", "Seasons": 1}]


with open("shows.csv", "w") as shows_csv:
    fields = ["Network", "Show Name", "Seasons"]
    shows_w = csv.DictWriter(shows_csv, fieldnames = fields)

    shows_w.writeheader()
    for item in working_list:
        shows_w.writerow(item)

之前的代码块通过使用open()中的 "w "参数创建了一个全新的csv文件。我们按照字段在一个单独的列表中出现的顺序手动命名，然后将该列表传递给DictWriter参数fieldnames。

最后，我们使用writeheader()和for循环与writerow()方法来创建一个标题行，并在working_list上进行迭代，将每个条目变成.csv中的一个行。

这些只是处理.csv和.txt文件的几种方法；Python是非常通用的 ...