未完成的代码
6.3 实例9 基本统计值计算
6.6 实例10 文本词频统计

---

Python社区
https://pypi.org/

---

print()
print()函数默认在输出最后增加一个’\n’
如果不希望换行，可以使用print("", end=’’)

---

字符串操作

---

字符串切片

<字符串>[M:N] M缺省表示至开头，N缺省表示至结尾
<字符串>[M:N:K] 根据步长K对字符串进行切片

>>> "〇一二三四五六七八九十"[:3]
"〇一二"
>>> "〇一二三四五六七八九十"[1:8:2]
"一三五七"
>>> "〇一二三四五六七八九十"[::-1]
"十九八七六五四三二一〇"

字符串操作符

• x+y
  连接两个字符串
• n*x
  复制n次字符串x
• x in s
  判断x是否为s的子串

---

字符串操作函数

长度函数len()
返回字符串的长度

>>> len("123456")
6

转变字符串函数str()
将任何类型数据转变为字符串形式（直接在最外层添加引号）

>>> str(1.23)
"1.23"
>>> str([1,2])
"[1,2]"

注：str()与eval()是完全相反的两个函数

---

字符串处理方法

“方法”在编程中是一个专有名词

• “方法”特指< a >.< b >()风格中的函数< b >()
• 方法本身也是函数，但与< a >有关，< a >.< b >()风格使用
• 字符串及常量也是< a >，存在一些方法

str.lower() or str.upper()
返回字符串的副本，全部字符小写/大写

>>> "AbCdEfGh".lower()
"abcdefg"

str.split(sep=None)
返回一个列表，由str根据sep被分隔的部分组成，默认为空格(包含’\n’)

>>> "A,B,C".split(",")
['A','B','C']

str.count(sub)
返回字串sub在str中出现的次数

>>> "an apple a day".count("a")
4

str.replace(old,new)
返回字符串str副本，所有old子串被替换为new

>>> "python".replace("n","n123.io")
"python123.io"

str.center(width,fillchar])
字符串根据宽度width居中，fillchar为填充

>>>"python".center(20,"=")
"=======python======="

str.strip(chars)
从str中去掉其左侧和右侧chars中列出的字符

>>> "= python= ".strip(" =np")
"ytho"

str.join(iter)
在iter变量中，除最后元素外，每个元素后增加一个str

>>>",".join("12345")
"1,2,3,4,5"

---

内置函数

评估函数 eval()
去掉参数最外层引号，并执行余下语句
eval(<字符串 or 字符串变量>)

>>> eval("1+2")
3
>>> eval('print("Hello")')
Hello

浮点数处理round()
round(x,d) 对x四舍五入，d是小数截取位数
浮点数间运算及比较，用round()函数辅助

>>> 0.1 + 0.2 == 0.3
False

>>> round(0.1+0.2, 1)
True

数字序列函数range()
range(i)：产生[0, i)的序列
range(m,n,k)：产生[m, n)以k为步长的序列

排序函数sorted(ls)
将无序列表，变为有序列表

>>> a = [3,4,2,5,1,8]
>>> sorted(a)
[1, 2, 3, 4, 5, 8]

类型函数type(x)
返回变量x的类型

>>> de = {
    }
>>> type(de)
<class 'dict'>

---

time库

time库是处理时间的标准库

import time
time.f() # f()为函数

time() & ctime() & gmtime()
获取当前时间戳，即计算机内部时间值

>>> time.time()
1568874452.184287
>>> time.ctime()
'Thu Sep 19 14:27:07 2019'
>>> time.gmtime() # 格式化输出的时间，便于程序调用
time.struct_time(tm_year=2019, tm_mon=9, tm_mday=19, tm_hour=6, tm_min=29, tm_sec=23, tm_wday=3, tm_yday=262, tm_isdst=0)

---

时间格式化

strftime(tpl,ts)
tpl是格式化模板字符串，用来定义输出效果
ts是计算机内部时间类型变量（用time.gmtime()获取）

>>> t = time.gmtime()
>>> time.strftime("%Y-%m-%d %H:%M:%S", t)
'2019-09-20 05:56:09'

strptime(str,tpi)
str是字符串形式的时间值
tpl是格式化模板字符串，用来定义输入效果

>>> timeStr = "2018-01-26 12:55:20"
>>> time.strptime(timeStr, "%Y-%m-%d %H:%M:%S")
time.struct_time(tm_year=2018, tm_mon=1, tm_mday=26, tm_hour=12, tm_min=55, tm_sec=20, tm_wday=4, tm_yday=26, tm_isdst=-1)

---

程序计时

perf_counter()
返回一个CPU级别的精确时间计数值，单位为秒

>>> start = time.perf_counter()
>>> end = time.perf_counter()
>>> end - start
14.7999896

sleep(s)
s拟休眠的时间，单位是秒，可以是浮点数

>>> sleep(3)
# 程序延迟3s后退出

---

异常处理

try:
	<语句块1>
except [异常类型]:
	<语句块2>

try:
	num = eval(input("请输入一个整数："))
	print(num**2)
except [NameError]:
	print("输入的不是整数")	

---

循环

遍历循环for + 无限循环 while

for <循环变量> in <遍历结构>:
<语句块>

>>>for i in range(5):
       print(i, end=',')
0,1,2,3,4,

>>>for i in range(1,6,2):
       print(i, end=',')
1,3,5,

>>>for c in "Python123":
       print(c, end=',')
P,y,t,h,o,n,1,2,3,

>>>for item in [123, "PY", 456]:
       print(item, end=',')
123,PY,456,

---

循环的扩展 else（与break有关）

for <循环变量> in <遍历结构>:
<语句块1>
else:
<语句块2>

---

while <条件>:
<语句块1>
else:
<语句块2>

---

当循环没有被break语句退出时，执行else语句块
else语句块作为正常完成循环的奖励

---

random库

random库是使用随机数的标准库

import random
random.f() # f()为函数

seed(a)
a为种子参数，对于相同的种子，产生的随机数序列是一定的。如果不使用该函数，则每次生成的随机数序列是不同的。

>>> random.seed(10) #产生种子10对应的序列

random()
生成一个[0.0, 1.0]之间的随机小数

>>> random.random()
0.5714025946899135

randint(a, b)
生成一个[a,b]之间的整数

>>> random.randint(1,100)
17

randrange(m,n,k)
生成一个[m,n)之间以k为步长的随机整数

>>> random.randrange(10,100,10)
20

uniform(a,b)
生成一个[a,b]之间的随机小数

>>> random.uniform(10,100)
73.10456301278674

choice(seq)
从序列seq中随机选择一个元素

>>> random.choice([1,2,3,4,5,6,7,8,9])
8

shuffle(seq)
将序列seq中元素随机排列，返回打乱后的序列

>>> s = [1,2,3,4,5,6,7,8,9]
>>> random.shuffle(s)
>>> s
[4, 9, 8, 5, 1, 3, 6, 2, 7]

---

函数

可选参数传递

已经给予传递默认值的参数

def <函数名>(<非可选参数>,<可选参数>):
<函数体>
return <返回值>
注：<非可选参数>一定要放在<可选参数>之前

def fact(n, m=1):
	s = 1
	for i in range(1, n+1):
		s *= i
	return s//m
	
>>> fact(10)
3628800
>>> fact(10,5)
725760

可变参数传递

可以设计可变数量参数，即不确定参数总数量

def <函数名>(<参数>, *b):
<函数体>
return <返回值>

def fact(n, *b):
	s = 1
	for i in range(1, n+1):
		s *= i
	for item in b:
		s *= item
	return s

函数多返回值

def fact(n, m=1):
	s = 1
	for i in range(1, n+1):
		s *= i
	return s//m, n, m
	
>>> fact(10, 5)
(725760, 10, 5)
>>> a,b,c = fact(10,5)
>>> print(a,b,c)
725760 10 5	

局部变量&全局变量

规则1：在函数内部可以通过global保留字声明全局变量

n, s = 10, 100
def fact(n):
	global s # 此处声明，函数内部使用的s是全局变量s
	for i in range(1, n+1):
		s *= i
	return s
	
>>>print(fact(n), s)
362880000 362880000

规则2：局部变量为组合数据类型且未创建，等同于全局变量

ls = ["F", "f"]
def func(a):
	ls.append(a)
	return 
func("C")

>>> print(ls)
['F','f','C']

ls = ["F", "f"]
def func(a):
	ls = [] # 此处ls是局部变量
	ls.append(a)
	return 
func("C")

>>> print(ls)
['F','f']

---

组合数据类型

包括集合类型、序列类型、字典类型

---

集合类型

多个元素的无序组合，不存在相同元素
集合元素不可更改，不能是可变数据类型

使用 {} or set() 建立集合

注：如果想构建空集合，只能使用set()

>>> A = {
    "python", 123, ("python",123)}
>>> print(A)
{
    123, 'python', ('python', 123)}

>>> B = set("pypy123")
>>> print(B)
{
    'y', 'p', '3', '2', '1'}

>>> C = {
    "python", 123, "python", 123}
>>> print(C)
{
    123, 'python'}

---

集合操作符

>>> A = {
    "p", "y", 123}
>>> B = set("pypy123")
>>> A - B
{
    123}
>>> B - A
{
    '2', '3', '1'}
>>> A & B
{
    'y', 'p'}
>>> A | B
{
    'y', 'p', '3', '2', 123, '1'}
>>> A ^ B
{
    '3', '2', 123, '1'}

---

集合处理函数&方法

S.add(x)
如果x不在S中，将x增加到S

S.discard(x)
移除S中元素x，如果x不在集合S中，不报错

S.reamove(x)
移除S中元素x，如果x不在集合S中，产生KeyError异常

S.clear()
移除S中所有元素

S.pop()
随机返回S的一个元素，更新S，若S为空产生KeyError异常

S.copy()
返回集合S的一个副本

len(S)
返回集合S的元素个数

set(x)
将其他类型变量x转变为集合类型

---

典型应用：数据去重

>>> ls = ["p", "p", "y", "y", 123]
>>> s = set(ls)
>>> lt = list(s)
>>> print(lt)
[123, 'y', 'p']

---

序列类型

序列是具有先后关系的一组元素
包括：字符串类型、元组类型、列表类型

序列处理函数&方法

len(s)
返回序列s的长度

>>> ls = ["python", 123, ".io"]
>>> len(ls)
3

min(s)
返回序列s的最小元素，s中元素需要可比较

max(s)
返回序列s的最大元素，s中元素需要可比较

>>> s = "python123.io"
>>> max(s)
'y'

s.index(x) or s.index(x,i,j)
返回序列s从i开始到j位置中，第一次出现元素x的位置

s.count(x)
返回序列s中出现x的总次数

---

元组类型

元组是序列类型的一种拓展，一旦创建就不能被修改
使用 () or tuple() 创建，元素间用","分隔
可以使用，也可以不使用 小括号

>>> a = 1,2
>>> a
(1, 2)

>>> b = (1,2)
>>> b
(1, 2)

---

列表类型

列表是一种序列类型，创建后可以随意修改
使用 [] or list() 创建，元素间用","分隔
列表中各元素类型可以不同，无长度限制

列表类型处理函数&方法

del ls[i]
删除列表ls中第i个元素

del ls[i:j:k]
删除列表ls中第i到第j以k为步长的元素

ls += lt
更新列表ls，将列表lt元素增加到列表ls中

ls *= n

更新列表ls，其元素重复n次

>>> ls = ["cat", "dog", "tiger", 1024]
>>> ls[1:2] = [1,2,3,4]
>>> print(ls)
['cat', 1, 2, 3, 4, 'tiger', 1024]
>>> del ls[::3]
>>> print(ls)
[1, 2, 4, 'tiger']
>>> ls *2
[1, 2, 4, 'tiger', 1, 2, 4, 'tiger']

ls.append(x)
在列表ls最后增加一个元素x

ls.clear()
删除列表ls中所有元素

ls.copy()
生成一个新列表，赋值ls中所有元素

ls.insert(i,x)
在列表ls的第i位置增加元素x

ls.pop(i)
将列表ls中第i位置元素取出，并删除该元素

ls.remove(x)
将列表ls中出现的第一个元素x删除

ls.reverse()
将列表ls中的元素反转

---

字典类型

映射： 键（索引）-> 值（数据）

字典类型是“映射”的体现
字典是键值对的集合，键值对之间无序
采用 {} or dict() 创建，键值对用 “:” 表示

>>> d = {
    "中国":"北京", "美国":"华盛顿", "法国":"巴黎"}
>>> d
{
    "中国":"北京", "美国":"华盛顿", "法国":"巴黎"}
>>> d["中国"]
'北京'

---

字典类型处理函数&方法

del d[k]
删除字典d中键k对应的数据值

d.keys()
返回字典d中所有的键信息

d.values()
返回字典中所有的值信息

d.items()
返回字典中所有的键值对信息

k in d
判断键k是否在字典d中，返回True or False

>>> d = {
    "中国":"北京", "美国":"华盛顿", "法国":"巴黎"}
>>> "中国" in d
True

>>> d.keys()
dict_keys(['中国', '美国', '法国'])

>>> d.values()
dict_values(['北京', '华盛顿', '巴黎'])

d.get(k, <>)
键k存在，则返回相应值；不存在，则返回<>

d.pop(k, <>)
键k存在，则取出相应值；不存在，则返回<>

d.popitem()
随机从字典d中取出一个键值对，以元组形式返回

d.clear()
删除所有键值对

len(d)
返回字典d中的元素个数

>>> d = {
    "中国":"北京", "美国":"华盛顿", "法国":"巴黎"}
>>> d.get("中国", "伊斯兰堡")
'北京'

>>> d.get("巴基斯坦", "伊斯兰堡")
'伊斯兰堡'

>>> d.popitem()
('美国', '华盛顿')

---

jieba库

第三方中文分词库

jieba.lcut(s)
精确模式，返回一个列表类型的分词结果

>>> jieba.lcut("中国是一个伟大的国家")
['中国', '是', '一个', '伟大', '的', '国家']

jieba.add_word(w)
向分词词典增加新词w

>>> jieba.add_word("呵呵哒")

---

wordcloud库

词云展示第三方库
wordcloud库把词云当作一个WordCloud对象

• wordcloud.WordCloud()代表一个文本对应的词云
• 可以根据文本中词语出现的频率等参数绘制词云
• 绘制词云的形状、尺寸、颜色都可以设定

坑：

使用这个库的代码，所在文件夹中(包括该文件自身)，绝不能存在“wordcloud.py”命名的文件！！！

# 生成英文词云
import wordcloud 
txt  = "life is short, you need python"
w = wordcloud.WordCloud(background_color = 'white')
w.generate(txt)
w.to_file("pywcloud.png")

# 生成中文词云（中文需要先分词）
import jieba
import wordcloud 
txt  = "程序设计语言是计算机能够理解和识别用户操作意图的一种交互体系，\
        它按照特定规则组织计算机指令，\
        使计算机能够自动进行各种运算处理。"
w = wordcloud.WordCloud(width=1000, font_path="msyh.ttc", height=700)
w.generate(" ".join(jieba.lcut(txt)))
w.to_file("pywcloud.png")

---

文件

文本文件 vs. 二进制文件
本质上，所有文件都是二进制形式存储
形式上，所有文件采用两种方式展示

文本文件
由单一特定编码组成的文件，如UTF-8编码
可以看作存储着的长字符串，适用于例如：.txt文件，.py文件

二进制文件
直接由比特0和1组成，没有同一字符编码
使用于例如：.png文件、.avi文件

---

文件的打开关闭

文件处理的步骤：打开-操作-关闭

文件的打开
<变量名> = open(<文件名>, <打开模式>)


文件的关闭
<变量名>.close()

---

文件内容的读取

f.read(size=-1)
读入全部内容，如果给出参数，读入前size长度

>>> s = f.read(2)
中国

注：如果文本过大，内存资源占用过多。

fname = input("请输入要打开的文件名称：")
fo = open(fname, "r")
txt = fo.read(2)
while txt !=- "" :
	# 对txt进行处理
	txt = fo.read(2)
fo.close()

---

f.readline(size=-1)
读入一行内容，如果给出参数，读入该行前size长度

>>> s = f.readline()
中国是一个伟大的国家！

f.readlines(hint=-1)
读入文件所有行，以每行为元素形成列表。如果给出参数，读入前hint行

>>> s = f.readlines()
[‘中国是一个伟大的国家！’]

# 逐行遍历文件：方法一
fname = input("请输入要打开的文件名称：")
fo = open(fname, "r")
for line in fo.readlines():
	print(line)
fo.close()

# 逐行遍历文件：方法二
fname = input("请输入要打开的文件名称：")
fo = open(fname, "r")
for line in fo:
	print(line)
fo.close()

---

数据文件的写入

f.write(s)
向文件写入一个字符串or字节流

>>> f.write("中国是一个伟大的国家！")

---

f.writelines(lines)
将一个元素全为字符串的列表写入文件

>>> ls = ["中国", "法国", "美国"]
>>> f.writelines(ls) # 没有换行、空格等，直接连接
中国法国美国

fo = open("output.txt", "w+")
ls = ["中国", "法国", "美国"]
fo.writelines(ls)
fo.seek(0) # 如果不将光标回到文件开始，将不会有输出结果
for line in fo:
	print(line)
fo.close()

---

f.seek(offset)
改变当前文件操作指针的位置，offset含义如下：
0 - 文件开头；1 - 当前位置；2 - 文件结尾

>>> f.seek(0) # 回到文件开头

---

一维数据的读、写处理

从空格分隔的文件中读入数据

txt = open(fname).read()
ls = txt.split()
f.close()

采用空格分隔方式将数据写入文件

ls = ['中国', '美国', '日本']
f = open(fname, 'w')
f.write(' '.join(ls)) # 将空格加入到ls各元素之间
f.close()

---

二维数据的读、写处理

从CSV格式的文件中读入数据

fo = open(fname)
ls = []
for line in fo:
	line = line.replace("\n","") # 去除每行最后的换行符
	ls.append(line.split(","))
fo.close()

将数据写入CSV格式的文件

ls = [[], [], []] # 二维列表
f = open(fname, 'w')
for item in ls:
	f.write(','.join(item) + '\n')
f.close()

---

OS库

os库是提供通用的、基本的操作系统交互功能的标准库

• 路径操作：os.path子库，处理文件路径及信息
• 进程管理：启动系统中其他程序
• 环境参数：获得系统软硬件信息等环境参数

---

路径操作

os.path子库以path为入口，用于操作和处理文件路径

import os.path
import os.path as op

---

进程管理

os.system(command)

• 执行程序或命令command
• 在Windows系统中，返回值为cmd的调用返回信息

>>> import os
>>> os.system("C:\\Windows\\System32\\calc.exe") # 调用计算器程序
0

>>> import os
>>> os.system("C:\\Windows\\System32\\calc.exe \
			   D:\\PYECourse\\grwordcloud.png") 
			   # 调用画图程序打开文件（路径间用空格隔开）
0

# 批量安装第三方库
import os
libs = {
    "numpy", "sklearn", "pandas", "jieba"}

try:
    for lib in libs:
        os.system("pip install " + lib)
    print("Successful")
except:
    print("Failed Somehow")

---

环境参数

获取或改变系统环境信息

---

一些NB的库