python二级考试

2019 计算机二级python考试笔记（基于考纲复习笔记）

原创 GoLee丶 发布于2018-08-31 14:16:07 阅读数 3033 收藏

更新于2019-01-25 20:18:49

分类专栏： python二级学习

展开

2019 计算机二级python考试笔记（基于考纲复习笔记）

写的有点乱，有考二级python的朋友加群，一起学习共同进步。群号：850284631（备注：CSDN）

一、eval函数用法

eval()函数十分强大，官方demo解释为：将字符串str当成有效的表达式来求值并返回计算结果。so，结合math当成一个计算器非常好用。

         
         
         
         

         
         
         
         

          
          
          
          
1
         
         
         
         

（1）：list,tuple,dict和string相互转化

a = "[1,2,3,4,5]"

         
         
         
         

         
         
         
         

          
          
          
          
1
         
         
         
         

type(a)

         
         
         
         

         
         
         
         

          
          
          
          
1
         
         
         
         

str

         
         
         
         

         
         
         
         

          
          
          
          
1
         
         
         
         

print(eval(a),type(eval(a)))

         
         
         
         

         
         
         
         

          
          
          
          
1
         
         
         
         

[1, 2, 3, 4, 5] 

         
         
         
         

         
         
         
         

          
          
          
          
1
         
         
         
         

（2）：作为数学运算使用

x=7
eval('3*x')

         
         
         
         

         
         
         
         

          
          
          
          
1
          
          
          
          
2
         
         
         
         

21

         
         
         
         

         
         
         
         

          
          
          
          
1
         
         
         
         

eval('pow(2,4)')

         
         
         
         

         
         
         
         

          
          
          
          
1
         
         
         
         

16

         
         
         
         

         
         
         
         

          
          
          
          
1
         
         
         
         

（3）：此函数存在危险

想一想这样的使用环境：须要用户输入一个表达式。并求值。

假设用户恶意输入。比如：

import(‘os’).system(‘dir’)

那么eval()之后，你会发现，当前文件夹文件都会展如今用户前面。

那么继续输入：

open(‘文件名称’).read()

代码都给人看了。

获取完成，一条删除命令。文件消失。

哭吧！

怎么避免安全问题？

１、自行写检查函数；

２、使用ast.literal_eval：自行查看DOCUMENT

3、很多其它好文：Restricted “safe” eval(Python recipe)

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25

二：format函数用法

format：字符串格式化。
用法：它通过{}和:来代替传统%方式

   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
   
   
   
   

（1）：使用位置参数——默认0-n

print('my name is {},age {}'.format('guo',18))

   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

my name is guo,age 18

   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

print('my name is {1},age {0}'.format('guo',18))

   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

my name is 18,age guo

   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

#参数索引从0开，传入位置参数列表可用*列表
name_age = ['guo',18]
print('my name is {},age {}'.format(*name_age))

   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
    
    
    
    
3
   
   
   
   

my name is guo,age 18

   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

（2）：使用关键字参数——dict

要点：关键字参数值要对得上，可用字典当关键字参数传入值，字典前加**即可

   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

print('my name is {name},age is {age}'.format(name='guo',age=18))

   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

my name is guo,age is 18

   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

dict_name = {'name':'guo','age':18}
print('my name is {name},age is {age}'.format(**dict_name))

   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
   
   
   
   

my name is guo,age is 18

   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

（3）：填充与格式化

:[填充字符][对齐方式 <^>][宽度]

   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

print('{:*^10}'.format('love'))

   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

***love***

   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

<:左对齐 ^：居中对齐 >:右对齐

（4）：精度与进制

print('{0:.2f}'.format(1/3)) #保留两位小数

   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

0.33

   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

print('{0:b}'.format(10))  #二进制

   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

1010

   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

print('{:,}'.format(12369132698)) #千分位

   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

12,369,132,698

   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

数字 格式 输出 描述
3.1415926 {:.2f} 3.14 保留小数点后两位
3.1415926 {:+.2f} +3.14 带符号保留小数点后两位
-1 {:+.2f} -1.00 带符号保留小数点后两位
2.71828 {:.0f} 3 不带小数
5 {:0>2d} 05 数字补零 (填充左边, 宽度为2)
5 {:x<4d} 5xxx 数字补x (填充右边, 宽度为4)
10 {:x<4d} 10xx 数字补x (填充右边, 宽度为4)
1000000 {:,} 1,000,000 以逗号分隔的数字格式
0.25 {:.2%} 25.00% 百分比格式
1000000000 {:.2e} 1.00e+09 指数记法
13 {:10d} 13 右对齐 (默认, 宽度为10)
13 {:<10d} 13 左对齐 (宽度为10)
13 {:^10d} 13 中间对齐 (宽度为10)
11

‘{:b}’.format(11) 1011
‘{:d}’.format(11) 11
‘{?}’.format(11) 13
‘{:x}’.format(11) b
‘{:#x}’.format(11) 0xb
‘{:#X}’.format(11) 0XB

（5）：使用索引

name_age

   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

['guo', 18]

   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

print('my name is {0[0]},age is {0[1]}'.format(name_age))

   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

my name is guo,age is 18

   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

三：复数数据类型

z = 3+4j
#用j表示虚部 j**2 = -1

   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
   
   
   
   

z.imag#虚部

   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

4.0

   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

z.real#实部

   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

3.0

   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

四：字符串操作

成员检查：in、not in                'Py' in str    'python' not in str
连接：+                             str_new = str1 + str2
复制：*                             str * 2
下标取值：s[i]                      str[3]
切片：s[i : j]                      str[3:8]
长度检查：len(s)        len(str)        print('%s length = %d' (str,len(str)))
最小值：min(s)          min(str)               空格在上面字符串中是最小的
最大值：max(s)          max(str)             大写字母要小于小写字母

   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
    
    
    
    
3
    
    
    
    
4
    
    
    
    
5
    
    
    
    
6
    
    
    
    
7
    
    
    
    
8
   
   
   
   

（1）字符串切片

s = 'Python string'
print(s[0],s[:2],s[:-1:2])#可设置步长为2

   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
   
   
   
   

P Py Pto ti

   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

（2）查找 & 替换类方法

#str.count(sub, start= 0,end=len(string))
#返回字符串里某个字符或是子字符串出现的次数。可选参数为在字符串搜索的开始(默认为第一个字符)与结束(默认为最后一个字符)位置。
s.count('t')

   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
    
    
    
    
3
   
   
   
   

2

   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

#查找某一字符串那个位置
#str.find(str, beg=0, end=len(string))   str.rfind(sub[, start[, end]])    str.index(sub[, start[, end]])    str.rindex(sub[, start[, end]])
s.find('t')
#没有找到返回-1

   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
    
    
    
    
3
    
    
    
    
4
   
   
   
   

2

   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

s.index('t')
#没有找到就报错

   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
   
   
   
   

2

   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

#替换字符串 可选参数count指定替换次数
#str.replace(old, new[, count])
s.replace('t','o')

   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
    
    
    
    
3
   
   
   
   

'Pyohon soring'

   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

#字符串替换映射 x——y 一一对应关系
#str.maketrans(x，y)      str.translate(map)
table = str.maketrans('abcd', '1234',)
str = 'abcda'
str.translate(table)

   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
    
    
    
    
3
    
    
    
    
4
    
    
    
    
5
   
   
   
   

'12341'

   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

（3）判断类方法

#判断开始以什么开头，以什么结尾
#str.endswith(str，beg，end)    str.startswith(str, beg=0,end=len(string))
s.endswith('g')

   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
    
    
    
    
3
   
   
   
   

True

   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

s.startswith('g')

   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

False

   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

#检测字符串是否由字母和数字组成（判断是否有空格等字符）
#str.isalnum()允许中文字符
s.isalnum()

   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
    
    
    
    
3
   
   
   
   

False

   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

#检测字符串是否只由字母组成
#str.isalpha()
s='anfkaf'
s.isalpha()

   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
    
    
    
    
3
    
    
    
    
4
   
   
   
   

True

   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

#检测字符串是否只由数字组成
#str.isdigit()       str.isdecimal()        str.isnumeric()
s='12313'
s.isdigit()

   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
    
    
    
    
3
    
    
    
    
4
   
   
   
   

True

   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

#检测字符串是否只由空格或制表符(\t)组成
#str.isspace()
s=' '
s.isspace()

   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
    
    
    
    
3
    
    
    
    
4
   
   
   
   

True

   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

#检测字符串中的字母字符是否全部由大小写字母组成（不会理会其他字符）
#str.islower()   str.isupper()
s='se ss'
s.islower()

   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
    
    
    
    
3
    
    
    
    
4
   
   
   
   

True

   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

#检测字符串中所有的单词拼写首字母是否为大写
#str.istitle()
s = 'Python Golee'
s.istitle()

   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
    
    
    
    
3
    
    
    
    
4
   
   
   
   

True

   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

#判断变量名是否合法
#str.isidentifier()
s.isidentifier()

   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
    
    
    
    
3
   
   
   
   

False

   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

#判断字符串所包含的字符是否全部可打印 字符串包含不可打印字符，如转义字符，将返回False
#str.isprintable()
s.isprintable()

   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
    
    
    
    
3
   
   
   
   

True

   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

（4）格式化类方法，返回一个格式化的新字符串

#全部字母字符转换成小写 / 大写或者大小写转换
#str.lower()    str.upper()     str.swapcase()
s.lower()

   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
    
    
    
    
3
   
   
   
   

'python golee'

   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

s.upper()

   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

'PYTHON GOLEE'

   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

s.swapcase()

   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

'pYTHON gOLEE'

   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

#将字符串的第一个字符转换为大写， 其余转换为小写
#str.capitalize()
s.lower().capitalize()

   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
    
    
    
    
3
   
   
   
   

'Python golee'

   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

#字符串中每个单词的首字母大写，其余小写
#str.title()
s.lower().title()

   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
    
    
    
    
3
   
   
   
   

'Python Golee'

   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

#返回一个指定的宽度 width 居中 / 左对齐 / 右对齐 的字符串
#str.center(width[, fillchar])      str.ljust(width[, fillchar])        str.rjust(width[, fillchar])
s.center(20,'*')

   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
    
    
    
    
3
   
   
   
   

'****Python Golee****'

   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

s.ljust(20,'*')

   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

'Python Golee********'

   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

#返回一个去除了特定字符的新字符串，chars参数是一个字符串，它包含了所有将要被移除的字符集合。默认为空格
#str.lstrip([chars])    str.rstrip([chars])     str.strip([chars])
s.strip()

   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
    
    
    
    
3
   
   
   
   

'Python Golee'

   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

#返回一个长度为width的字符串，最左边填充0 主要用于数字类字符串的格式化。
#str.zfill(width)
s.zfill(20)

   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
    
    
    
    
3
   
   
   
   

'00000000Python Golee'

   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

（5）拆分组合类方法

#拆分字符串，返回一个包含三个元素的元组
#str.partition(sep)     str.rpartition(sep)
s.partition('o')

   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
    
    
    
    
3
   
   
   
   

('Pyth', 'o', 'n Golee')

   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

#str.split([sep[, maxsplit]])       str.rsplit([sep[, maxsplit]])

   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

返回一个以Sep分隔的列表，maxsplit指定拆分次数（因此，列表中元素的个数为maxsplit + 1）。Sep默认为空格，maxsplit默认不限制拆分次数。
1）如果未指定Sep或指定Sep为None，str两端的空格将舍弃；如果指定Sep（不管能否在原字符串中找到Sep），str两端的空格将保留
2）如果未能在原字符串中找到Sep，则返回一个仅包含一个元素的列表，这个元素就是原字符串。
3) str.rsplit()只是从最右边开始拆分。只有在指定maxsplit的情况下才会看到不同效果

s.split()

   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

['Python', 'Golee']

   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

s.split('o',1)

   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

['Pyth', 'n Golee']

   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

#以指定字符串str作为分隔符，将iterable对象中所有的元素(字符串表示)合并为一个新的字符串. 如果传入一个非iterable对象，如整数、布尔值等，将返回Type Error。
#str.join(iterable)
s='123'
s.join('abc')

   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
    
    
    
    
3
    
    
    
    
4
   
   
   
   

'a123b123c'

   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

#拆分一个包含多行的字符串，以每行为一个元素返回一个列表。
#str.splitlines([keepends])
s='''
1
2
3
'''
s.splitlines()

   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
    
    
    
    
3
    
    
    
    
4
    
    
    
    
5
    
    
    
    
6
    
    
    
    
7
    
    
    
    
8
   
   
   
   

['', '1', '2', '3']

   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

五、类型判断和类型间转换

a=10
print(isinstance(a,int))  #判断类型

   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
   
   
   
   

True

   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

type(a) == int

   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

True

   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

int(x [,base]) int(“8”) 可以转换的包括String类型和其他数字类型，但是会丢失精度
float(x) float(1)或者float(“1”) 可以转换String和其他数字类型，不足的位数用0补齐，例如1会变成1.0
complex(real ,imag) complex(“1”)或者complex(1,2) 第一个参数可以是String或者数字，第二个参数只能为数字类型，第二个参数没有时默认为0
str(x) str(1) 将数字转化为String
repr(x) repr(Object) 返回一个对象的String格式
eval(str) eval(“12+23”) 执行一个字符串表达式，返回计算的结果,如例子中返回35
tuple(seq) tuple((1,2,3,4)) 参数可以是元组、列表或者字典，wie字典时，返回字典的key组成的集合
list(s) list((1,2,3,4)) 将序列转变成一个列表，参数可为元组、字典、列表，为字典时，返回字典的key组成的集合
set(s)set([‘b’, ‘r’])或者set(“asdfg”)将一个可以迭代对象转变为可变集合，并且去重复，返回结果可以用来计算差集x - y、并集x | y、交集x & y
frozenset(s) frozenset([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]) 将一个可迭代对象转变成不可变集合，参数为元组、字典、列表等，
chr(x) chr(0x30) chr()用一个范围在 range（256）内的（就是0～255）整数作参数，返回一个对应的字符。返回值是当前整数对应的ascii字符。
ord(x) ord(‘a’) 返回对应的 ASCII 数值，或者 Unicode 数值
hex(x) hex(12) 把一个整数转换为十六进制字符串
oct(x) oct(12) 把一个整数转换为八进制字符串

六、分支结构

（1）三元操作

x = 1
y = 2
if x<y:
    small = x
else:
    small = y
print(small)    
small_test = x if x<y else y
print(small_test)

   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
    
    
    
    
3
    
    
    
    
4
    
    
    
    
5
    
    
    
    
6
    
    
    
    
7
    
    
    
    
8
    
    
    
    
9
   
   
   
   

1
1

   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
   
   
   
   

（2）断言操作

一般来说可以用它在程序中置入检查点，当需要确保程序中的某个条件一定为真才能让程序正常工作时，assert关键字就非常有用了。

   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

assert 3 < 4

   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

assert 3 > 4

   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

---------------------------------------------------------------------------

AssertionError Traceback (most recent call last)

in ()
----> 1 assert 3 > 4

AssertionError:

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9

（3）while循环语句

x = 0
while x < 2:
    x +=1
    print(x)

   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
    
    
    
    
3
    
    
    
    
4
   
   
   
   

1
2

   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
   
   
   
   

（4）break语句

break语句的作用是终止当前循环，跳出循环体。

   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

x = 0
while x < 5:    
    if x == 1:
            break
    x +=1
    print(x)

   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
    
    
    
    
3
    
    
    
    
4
    
    
    
    
5
    
    
    
    
6
   
   
   
   

1

   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

（5）continue语句

continue语句的作用是终止本轮循环并开始下一轮循环（这里要注意的是：在开始下一步循环之前，会先测试循环条件）

   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

#continue 语句是一个删除的效果，他的存在是为了删除满足循环条件下的某些不需要的成分:
for i in range(10):
    if i % 2 != 0:
        continue
    print(i)   
    i += 2

• 1
• 2
• 3
• 4
• 5
• 6
• 7

0
2
4
6
8

   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
    
    
    
    
3
    
    
    
    
4
    
    
    
    
5
   
   
   
   

七、程序的异常处理

print(5/0)

   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

---------------------------------------------------------------------------

ZeroDivisionError Traceback (most recent call last)

in ()
----> 1 print(5/0)

ZeroDivisionError: division by zero

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9

try:
    print(5/0)
except ZeroDivisionError:
    print("you can't divide by zero")

   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
    
    
    
    
3
    
    
    
    
4
   
   
   
   

you can't divide by zero

   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

#or use pass this input
while True:
    first_num = input("\nFirst number:")
    if first_num == 'q':
        break
    second_num = input("\nsecond number:")
    try:
        answer = int(first_num) / int(second_num)
    except ZeroDivisionError:
        print("you can't divide by zero")
    else:
        print(answer)

   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
    
    
    
    
3
    
    
    
    
4
    
    
    
    
5
    
    
    
    
6
    
    
    
    
7
    
    
    
    
8
    
    
    
    
9
    
    
    
    
10
    
    
    
    
11
    
    
    
    
12
   
   
   
   

First number:2

second number:3
0.6666666666666666

First number:3

second number:0
you can’t divide by zero

First number:q

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11

def build_profile(first, last, **user_info):
    profile = {}
    profile['first_name'] = first
    profile['last_name'] = last
    for key, value in user_info.items():
        profile[key] = value
    return profile
user_profile = build_profile('albert', 'einstein',
location='princeton',
field='physics')
print(user_profile)

   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
    
    
    
    
3
    
    
    
    
4
    
    
    
    
5
    
    
    
    
6
    
    
    
    
7
    
    
    
    
8
    
    
    
    
9
    
    
    
    
10
    
    
    
    
11
   
   
   
   

{'first_name': 'albert', 'last_name': 'einstein', 'location': 'princeton', 'field': 'physics'}

   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

八、ramdom库使用

import random
dir(random)

   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
   
   
   
   

['BPF',
 'LOG4',
 'NV_MAGICCONST',
 'RECIP_BPF',
 'Random',
 'SG_MAGICCONST',
 'SystemRandom',
 'TWOPI',
 '_BuiltinMethodType',
 '_MethodType',
 '_Sequence',
 '_Set',
 '__all__',
 '__builtins__',
 '__cached__',
 '__doc__',
 '__file__',
 '__loader__',
 '__name__',
 '__package__',
 '__spec__',
 '_acos',
 '_bisect',
 '_ceil',
 '_cos',
 '_e',
 '_exp',
 '_inst',
 '_itertools',
 '_log',
 '_pi',
 '_random',
 '_sha512',
 '_sin',
 '_sqrt',
 '_test',
 '_test_generator',
 '_urandom',
 '_warn',
 'betavariate',
 'choice',
 'choices',
 'expovariate',
 'gammavariate',
 'gauss',
 'getrandbits',
 'getstate',
 'lognormvariate',
 'normalvariate',
 'paretovariate',
 'randint',
 'random',
 'randrange',
 'sample',
 'seed',
 'setstate',
 'shuffle',
 'triangular',
 'uniform',
 'vonmisesvariate',
 'weibullvariate']

   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
    
    
    
    
3
    
    
    
    
4
    
    
    
    
5
    
    
    
    
6
    
    
    
    
7
    
    
    
    
8
    
    
    
    
9
    
    
    
    
10
    
    
    
    
11
    
    
    
    
12
    
    
    
    
13
    
    
    
    
14
    
    
    
    
15
    
    
    
    
16
    
    
    
    
17
    
    
    
    
18
    
    
    
    
19
    
    
    
    
20
    
    
    
    
21
    
    
    
    
22
    
    
    
    
23
    
    
    
    
24
    
    
    
    
25
    
    
    
    
26
    
    
    
    
27
    
    
    
    
28
    
    
    
    
29
    
    
    
    
30
    
    
    
    
31
    
    
    
    
32
    
    
    
    
33
    
    
    
    
34
    
    
    
    
35
    
    
    
    
36
    
    
    
    
37
    
    
    
    
38
    
    
    
    
39
    
    
    
    
40
    
    
    
    
41
    
    
    
    
42
    
    
    
    
43
    
    
    
    
44
    
    
    
    
45
    
    
    
    
46
    
    
    
    
47
    
    
    
    
48
    
    
    
    
49
    
    
    
    
50
    
    
    
    
51
    
    
    
    
52
    
    
    
    
53
    
    
    
    
54
    
    
    
    
55
    
    
    
    
56
    
    
    
    
57
    
    
    
    
58
    
    
    
    
59
    
    
    
    
60
    
    
    
    
61
   
   
   
   

#生成一个范围内的整数
random.randint(1,10)

   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
   
   
   
   

6

   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

#生成一个0-1的随机浮点数
random.random()

   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
   
   
   
   

0.32555435954202816

   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

help(random.random)

   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

Help on built-in function random:

random(…) method of random.Random instance
random() -> x in the interval [0, 1).

• 1
• 2
• 3
• 4

#生成一个指定范围内的浮点数
random.uniform(1.2,1.6)

   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
   
   
   
   

1.5069837267640016

   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

help(random.uniform)

   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

Help on method uniform in module random:

uniform(a, b) method of random.Random instance
Get a random number in the range [a, b) or [a, b] depending on rounding.

• 1
• 2
• 3
• 4

#从序列中随机选取一个元素，可以为list，元组，字符串。
random.choice('gu2455')

   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
   
   
   
   

'u'

   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

random.choice(['gu12344','caoyang'])

   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

'gu12344'

   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

#生成一个从start到stop（不包括stop），间隔为step的一个随机整数
random.randrange(1,10,2)

   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
   
   
   
   

3

   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

#从p序列中，随机获取k个元素，生成一个新序列。sample不改变原来序列。
random.sample([1,2,3,4,5],4)

   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
   
   
   
   

[4, 2, 5, 1]

   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

#把序列中的元素顺序打乱。shuffle直接改变原有的序列
a = [i for i in range(5)]
a

   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
    
    
    
    
3
   
   
   
   

[0, 1, 2, 3, 4]

   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

random.shuffle(a)

   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

a

   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

[2, 1, 0, 4, 3]

   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

import numpy as np
dir(np.random)

   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
   
   
   
   

['Lock',
 'RandomState',
 '__RandomState_ctor',
 '__all__',
 '__builtins__',
 '__cached__',
 '__doc__',
 '__file__',
 '__loader__',
 '__name__',
 '__package__',
 '__path__',
 '__spec__',
 '_numpy_tester',
 'absolute_import',
 'bench',
 'beta',
 'binomial',
 'bytes',
 'chisquare',
 'choice',
 'dirichlet',
 'division',
 'exponential',
 'f',
 'gamma',
 'geometric',
 'get_state',
 'gumbel',
 'hypergeometric',
 'info',
 'laplace',
 'logistic',
 'lognormal',
 'logseries',
 'mtrand',
 'multinomial',
 'multivariate_normal',
 'negative_binomial',
 'noncentral_chisquare',
 'noncentral_f',
 'normal',
 'np',
 'operator',
 'pareto',
 'permutation',
 'poisson',
 'power',
 'print_function',
 'rand',
 'randint',
 'randn',
 'random',
 'random_integers',
 'random_sample',
 'ranf',
 'rayleigh',
 'sample',
 'seed',
 'set_state',
 'shuffle',
 'standard_cauchy',
 'standard_exponential',
 'standard_gamma',
 'standard_normal',
 'standard_t',
 'test',
 'triangular',
 'uniform',
 'vonmises',
 'wald',
 'warnings',
 'weibull',
 'zipf']

   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
    
    
    
    
3
    
    
    
    
4
    
    
    
    
5
    
    
    
    
6
    
    
    
    
7
    
    
    
    
8
    
    
    
    
9
    
    
    
    
10
    
    
    
    
11
    
    
    
    
12
    
    
    
    
13
    
    
    
    
14
    
    
    
    
15
    
    
    
    
16
    
    
    
    
17
    
    
    
    
18
    
    
    
    
19
    
    
    
    
20
    
    
    
    
21
    
    
    
    
22
    
    
    
    
23
    
    
    
    
24
    
    
    
    
25
    
    
    
    
26
    
    
    
    
27
    
    
    
    
28
    
    
    
    
29
    
    
    
    
30
    
    
    
    
31
    
    
    
    
32
    
    
    
    
33
    
    
    
    
34
    
    
    
    
35
    
    
    
    
36
    
    
    
    
37
    
    
    
    
38
    
    
    
    
39
    
    
    
    
40
    
    
    
    
41
    
    
    
    
42
    
    
    
    
43
    
    
    
    
44
    
    
    
    
45
    
    
    
    
46
    
    
    
    
47
    
    
    
    
48
    
    
    
    
49
    
    
    
    
50
    
    
    
    
51
    
    
    
    
52
    
    
    
    
53
    
    
    
    
54
    
    
    
    
55
    
    
    
    
56
    
    
    
    
57
    
    
    
    
58
    
    
    
    
59
    
    
    
    
60
    
    
    
    
61
    
    
    
    
62
    
    
    
    
63
    
    
    
    
64
    
    
    
    
65
    
    
    
    
66
    
    
    
    
67
    
    
    
    
68
    
    
    
    
69
    
    
    
    
70
    
    
    
    
71
    
    
    
    
72
    
    
    
    
73
    
    
    
    
74
   
   
   
   

#原始的random接口没有n个参数生成。
np.random.random(20)

   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
   
   
   
   

array([0.69454737, 0.77229112, 0.45121221, 0.06512901, 0.19775742,
       0.66398487, 0.20460758, 0.0545738 , 0.58054043, 0.1784286 ,
       0.32031521, 0.18602763, 0.99836724, 0.85094308, 0.53659558,
       0.55826864, 0.55052432, 0.22760714, 0.16809962, 0.86779955])

   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
    
    
    
    
3
    
    
    
    
4
   
   
   
   

np.random.uniform(10,20,20)

   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

array([10.05210186, 17.48397259, 15.0361042 , 13.56990686, 11.65007754,
       17.10151908, 11.90372554, 18.30047846, 11.48913799, 10.26947544,
       10.3940895 , 13.92287236, 12.99326584, 19.79723074, 19.65732271,
       11.23057858, 11.17339828, 12.44481384, 15.81981985, 18.32584816])

   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
    
    
    
    
3
    
    
    
    
4
   
   
   
   

import time

   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

九、time库使用

dir(time)

   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

['_STRUCT_TM_ITEMS',
 '__doc__',
 '__loader__',
 '__name__',
 '__package__',
 '__spec__',
 'altzone',
 'asctime',
 'clock',
 'ctime',
 'daylight',
 'get_clock_info',
 'gmtime',
 'localtime',
 'mktime',
 'monotonic',
 'perf_counter',
 'process_time',
 'sleep',
 'strftime',
 'strptime',
 'struct_time',
 'time',
 'timezone',
 'tzname']

   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
    
    
    
    
3
    
    
    
    
4
    
    
    
    
5
    
    
    
    
6
    
    
    
    
7
    
    
    
    
8
    
    
    
    
9
    
    
    
    
10
    
    
    
    
11
    
    
    
    
12
    
    
    
    
13
    
    
    
    
14
    
    
    
    
15
    
    
    
    
16
    
    
    
    
17
    
    
    
    
18
    
    
    
    
19
    
    
    
    
20
    
    
    
    
21
    
    
    
    
22
    
    
    
    
23
    
    
    
    
24
    
    
    
    
25
   
   
   
   

（1）结构化时间

time.localtime()

   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

time.struct_time(tm_year=2018, tm_mon=8, tm_mday=9, tm_hour=15, tm_min=50, tm_sec=0, tm_wday=3, tm_yday=221, tm_isdst=0)

   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

time.gmtime()

   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

time.struct_time(tm_year=2018, tm_mon=8, tm_mday=9, tm_hour=7, tm_min=50, tm_sec=9, tm_wday=3, tm_yday=221, tm_isdst=0)

   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

#结构化时间转成时间戳
time.mktime(time.localtime())

   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
   
   
   
   

1533801052.0

   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

#结构化时间转成字符串时间
time.strftime('%Y-%m-%d %X',time.localtime())

   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
   
   
   
   

'2018-08-09 15:52:25'

   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

#字符串时间转成结构化时间
time.strptime('2018-08-09 15:52:25','%Y-%m-%d %X')

   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
   
   
   
   

time.struct_time(tm_year=2018, tm_mon=8, tm_mday=9, tm_hour=15, tm_min=52, tm_sec=25, tm_wday=3, tm_yday=221, tm_isdst=-1)

   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

参考bolg：http://www.cnblogs.com/Echo-O/p/9385316.html

#当前时间戳
time.time()

   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
   
   
   
   

1533801293.4284136

   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

#推迟调用线程的运行
start_time = time.time()
time.sleep(5)
end_time = time.time()
print(start_time-end_time)

   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
    
    
    
    
3
    
    
    
    
4
    
    
    
    
5
   
   
   
   

-5.0061445236206055

   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

#将时间元组或者struct_time表示为国际表达时间格式
time.asctime(time.localtime())

   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
   
   
   
   

'Thu Aug  9 15:57:27 2018'

   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

#把时间戳表示为asctime格式
time.ctime(time.time())

   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
   
   
   
   

'Thu Aug  9 15:58:46 2018'

   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

#接受一个时间元组，返回一个struct_time()的对象
time.struct_time((2018, 8, 3, 12, 57, 19, 134860,0,0))

   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
   
   
   
   

time.struct_time(tm_year=2018, tm_mon=8, tm_mday=3, tm_hour=12, tm_min=57, tm_sec=19, tm_wday=134860, tm_yday=0, tm_isdst=0)

   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

#获取此时年月日
time.strftime('%y-%m-%d')

   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
   
   
   
   

'18-08-09'

   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

#获取此时时间
time.strftime('%X')

   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
   
   
   
   

'16:03:33'

   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

十、jieba使用小结

（1）：主要功能

jieba.cut 方法接受三个输入参数: 需要分词的字符串；cut_all 参数用来控制是否采用全模式；HMM 参数用来控制是否使用 HMM 模型
jieba.cut_for_search 方法接受两个参数：需要分词的字符串；是否使用 HMM 模型。该方法适合用于搜索引擎构建倒排索引的分词，粒度比较细待分词的字符串可以是 unicode 或 UTF-8 字符串、GBK 字符串。注意：不建议直接输入 GBK 字符串，可能无法预料地错误解码成 UTF-8
jieba.cut 以及 jieba.cut_for_search 返回的结构都是一个可迭代的 generator，可以使用 for 循环来获得分词后得到的每一个词语(unicode)，或者用
jieba.lcut 以及 jieba.lcut_for_search 直接返回 list
jieba.Tokenizer(dictionary=DEFAULT_DICT) 新建自定义分词器，可用于同时使用不同词典。 jieba.dt 为默认分词器，所有全局分词相关函数都是该分词器的映射。

   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
    
    
    
    
3
    
    
    
    
4
    
    
    
    
5
   
   
   
   

import jieba
seg_list = jieba.cut("我来到北京清华大学", cut_all=True) 
print("Full Mode: " + "/ ".join(seg_list))

   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
    
    
    
    
3
   
   
   
   

Building prefix dict from the default dictionary ...
Dumping model to file cache C:\Users\ADMINI~1\AppData\Local\Temp\jieba.cache
Loading model cost 1.074 seconds.
Prefix dict has been built succesfully.

Full Mode: 我/ 来到/ 北京/ 清华/ 清华大学/ 华大/ 大学

• 1
• 2
• 3
• 4
• 5
• 6
• 7

seg_list = jieba.cut("我来到北京清华大学", cut_all=False) 
print("Default Mode: " + "/ ".join(seg_list))

   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
   
   
   
   

Default Mode: 我/ 来到/ 北京/ 清华大学

   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

seg_list = jieba.cut("他来到了网易杭研大厦") # 默认是精确模式 
print(", ".join(seg_list))

   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
   
   
   
   

他, 来到, 了, 网易, 杭研, 大厦

   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

seg_list = jieba.cut_for_search("小明硕士毕业于中国科学院计算所，后在日本京都大学深造") # 搜索引擎模式
print("搜索引擎模式："+",".join(seg_list))

   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
   
   
   
   

搜索引擎模式：小明,硕士,毕业,于,中国,科学,学院,科学院,中国科学院,计算,计算所,，,后,在,日本,京都,大学,日本京都大学,深造

   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

（2）：载入词典

#用法： jieba.load_userdict(file_name)

   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

（3）：调整词典

使用 add_word(word, freq=None, tag=None) 和 del_word(word) 可在程序中动态修改词典
使用 suggest_freq(segment, tune=True) 可调节单个词语的词频，使其能（或不能）被分出来。
意：自动计算的词频在使用 HMM 新词发现功能时可能无效。

   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
    
    
    
    
3
   
   
   
   

 print('/'.join(jieba.cut('如果放到post中将出错。',HMM=False)))

   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

如果/放到/post/中将/出错/。

   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

jieba.suggest_freq(('中', '将'), True)

   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

494

   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

print('/'.join(jieba.cut('如果放到post中将出错。', HMM=False)))

   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

如果/放到/post/中/将/出错/。

   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

print('/'.join(jieba.cut('「台中」正确应该不会被切开', HMM=False)))

   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

「/台/中/」/正确/应该/不会/被/切开

   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

jieba.suggest_freq('台中', True)

   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

69

   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

print('/'.join(jieba.cut('「台中」正确应该不会被切开', HMM=False)))

   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

「/台中/」/正确/应该/不会/被/切开

   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

（4）：基于 TF-IDF 算法的关键词抽取

jieba.analyse.extract_tags(sentence, topK=20, withWeight=False, allowPOS=())
sentence 为待提取的文本
topK 为返回几个 TF/IDF 权重最大的关键词，默认值为 20
withWeight 为是否一并返回关键词权重值，默认值为 False
allowPOS 仅包括指定词性的词，默认值为空，即不筛选
jieba.analyse.TFIDF(idf_path=None) 新建 TFIDF 实例，idf_path 为 IDF 频率文件

关键词提取所使用逆向文件频率（IDF）文本语料库可以切换成自定义语料库的路径
用法： jieba.analyse.set_idf_path(file_name) # file_name为自定义语料库的路径

关键词提取所使用停止词（Stop Words）文本语料库可以切换成自定义语料库的路径
用法： jieba.analyse.set_stop_words(file_name) # file_name为自定义语料库的路径

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12

（5）：基于 TextRank 算法的关键词抽取

jieba.analyse.textrank(sentence, topK=20, withWeight=False, allowPOS=('ns', 'n', 'vn', 'v')) 直接使用，接口相同，注意默认过滤词性。
jieba.analyse.TextRank() 新建自定义 TextRank 实例

   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
   
   
   
   

10.5.1：词性标注

import jieba.posseg as pseg
words = pseg.cut("永远学习，相信自己")
for word,flag in words:
    print('%s %s' %(word,flag))

   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
    
    
    
    
3
    
    
    
    
4
   
   
   
   

永远 d
学习 v
， x
相信 v
自己 r

   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
    
    
    
    
3
    
    
    
    
4
    
    
    
    
5
   
   
   
   

10.5.2：并行分词

基于 python 自带的 multiprocessing 模块，目前暂不支持 Windows
jieba.enable_parallel(4) # 开启并行分词模式，参数为并行进程数
jieba.disable_parallel() # 关闭并行分词模式

   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
    
    
    
    
3
   
   
   
   

10.5.3：. Tokenize：返回词语在原文的起止位置

注意，输入参数只接受 unicode
默认模式

   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
   
   
   
   

result = jieba.tokenize(u'你最棒，nice do it')
for tk in result:
    print("word %s \t\t start:%d \t\t end:%d" %(tk[0],tk[1],tk[2]))

   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
    
    
    
    
3
   
   
   
   

word 你 		 start:0 		 end:2
word 最棒 		 start:2 		 end:4
word ， 		 start:4 		 end:5
word nice 		 start:5 		 end:9
word   		 start:9 		 end:10
word do 		 start:10 		 end:12
word   		 start:12 		 end:13
word it 		 start:13 		 end:15

   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
    
    
    
    
3
    
    
    
    
4
    
    
    
    
5
    
    
    
    
6
    
    
    
    
7
    
    
    
    
8
   
   
   
   

10.5.3：搜索模式

result = jieba.tokenize(u'永和服装饰品有限公司', mode='search')
for tk in result:
    print("word %s\t\t start: %d \t\t end:%d" % (tk[0],tk[1],tk[2]))

   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
    
    
    
    
3
   
   
   
   

word 永和		 start: 0 		 end:2
word 服装		 start: 2 		 end:4
word 饰品		 start: 4 		 end:6
word 有限		 start: 6 		 end:8
word 公司		 start: 8 		 end:10
word 有限公司		 start: 6 		 end:10

   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
    
    
    
    
3
    
    
    
    
4
    
    
    
    
5
    
    
    
    
6
   
   
   
   

十一、wordcloud库使用

from wordcloud import  WordCloud
import matplotlib.pyplot as plt

#初始化wordcloud
wc = WordCloud()
#传入词频统计的字典
wc.fit_words()
#展示词云图
plt.inshow(wc)
#关闭词云图
plt.close()

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11

---------------------------------------------------------------------------

TypeError Traceback (most recent call last)

in ()
5 wc = WordCloud()
6 #传入词频统计的字典
----> 7 wc.fit_words()
8 #展示词云图
9 plt.inshow(wc)

TypeError: fit_words() missing 1 required positional argument: ‘frequencies’

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13

#进行词频统计        
segStat = segmentDataFrame.groupby(
            by="segment"
        )["segment"].agg({
            "计数":numpy.size
        }).reset_index().sort_values(
            ["计数"],
            ascending=False
        );
#首先进行对词分组，使用agg对每一个segment列求size

   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
    
    
    
    
3
    
    
    
    
4
    
    
    
    
5
    
    
    
    
6
    
    
    
    
7
    
    
    
    
8
    
    
    
    
9
    
    
    
    
10
   
   
   
   

---------------------------------------------------------------------------

NameError Traceback (most recent call last)

in ()
1 #进行词频统计
----> 2 segStat = segmentDataFrame.groupby(
3 by=“segment”
4 )[“segment”].agg({
5 “计数”:numpy.size

NameError: name ‘segmentDataFrame’ is not defined

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13

十二、PyInstaller库

（1）：基本操作

cmd——> pyinstaller .py 

   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

（2）：带参数使用

例如：--icon参数的使用如下：（指定打包程序使用的图标文件）

>pyinstaller -F --icon=“D:\a.ico” D:\python_test.py

>pyinstaller -F -w -i D:\tmp\main.ico D:\python_test.py

-F 表示生成单个可执行文件,执行后dist目录中出现了python_test.exe文件，没有任何依赖库，执行它即可。
-w 表示去掉控制台窗口，这在GUI界面时非常有用。不过如果是命令行程序的话那就把这个选项删除吧！
-i 表示可执行文件的图标

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9

（3）：注意事项

文件路径中不能出现空格和英文句号（.）；
源文件必须是UTF-8编码，暂不支持其他编码类型。采用IDLE编写的源文件都保存为UTF -8编码形式，可直接使用即可。

   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
   
   
   
   

十三：数据的读取和写入

（1）数据的读取

filename = r'C:\Users\Administrator\Desktop\test11.csv'
with open(filename) as open_file:
    print(open_file.read())

   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
    
    
    
    
3
   
   
   
   

1,2
2,3
3,4
4,5
5,6
6,7
7,8
8,9

   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
    
    
    
    
3
    
    
    
    
4
    
    
    
    
5
    
    
    
    
6
    
    
    
    
7
    
    
    
    
8
   
   
   
   

filename = r'C:\Users\Administrator\Desktop\test11.csv'
with open(filename) as open_file:
    for line in open_file:
        print(line.replace('\n',''))

   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
    
    
    
    
3
    
    
    
    
4
   
   
   
   

1,2
2,3
3,4
4,5
5,6
6,7
7,8
8,9

   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
    
    
    
    
3
    
    
    
    
4
    
    
    
    
5
    
    
    
    
6
    
    
    
    
7
    
    
    
    
8
   
   
   
   

filename = r'C:\Users\Administrator\Desktop\test11.csv'
with open(filename) as open_file:
    lines = open_file.readlines()
for line in lines:
    print(line)

   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
    
    
    
    
3
    
    
    
    
4
    
    
    
    
5
   
   
   
   

1,2

2,3

3,4

4,5

5,6

6,7

7,8

8,9

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15

# 默认是带有\n
lines

   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
   
   
   
   

['1,2\n', '2,3\n', '3,4\n', '4,5\n', '5,6\n', '6,7\n', '7,8\n', '8,9\n']

   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

（2）：数据的写入

读取模式：‘r’，写入模式：‘w’，附加模式：‘a’，读取和写入模式：‘r+’

注意：w参数 没有文件是创建，有文件则是覆盖文件。
a参数 没有文件是创建，有文件则是追加内容

• 1
• 2
• 3
• 4

with open(filename,'a') as open_file:
    open_file.write('9,10')

   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
   
   
   
   

with open(filename) as open_file:
    for line in open_file:
        print(line.replace('\n',''))

   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
    
    
    
    
3
   
   
   
   

1,2
2,3
3,4
4,5
5,6
6,7
7,8
8,9
9,10

   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
    
    
    
    
3
    
    
    
    
4
    
    
    
    
5
    
    
    
    
6
    
    
    
    
7
    
    
    
    
8
    
    
    
    
9
   
   
   
   

with open(filename) as open_file:
    ls = []
    for line in open_file:
        line = line.replace('\n','')
        ls.append(line.split(','))
open_file.close()

   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
    
    
    
    
3
    
    
    
    
4
    
    
    
    
5
    
    
    
    
6
   
   
   
   

ls

   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

[['1', '2'],
 ['2', '3'],
 ['3', '4'],
 ['4', '5'],
 ['5', '6'],
 ['6', '7'],
 ['7', '8'],
 ['8', '9'],
 ['9', '10']]

   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
    
    
    
    
3
    
    
    
    
4
    
    
    
    
5
    
    
    
    
6
    
    
    
    
7
    
    
    
    
8
    
    
    
    
9
   
   
   
   

for raw in ls:
    for column in raw:
        print(column)

   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
    
    
    
    
3
   
   
   
   

1
2
2
3
3
4
4
5
5
6
6
7
7
8
8
9
9
10

   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
    
    
    
    
3
    
    
    
    
4
    
    
    
    
5
    
    
    
    
6
    
    
    
    
7
    
    
    
    
8
    
    
    
    
9
    
    
    
    
10
    
    
    
    
11
    
    
    
    
12
    
    
    
    
13
    
    
    
    
14
    
    
    
    
15
    
    
    
    
16
    
    
    
    
17
    
    
    
    
18
   
   
   
   

十四：组合数据类型：

（1）：列表的操作函数、列表的操作方法

list_1 = [i for i in range(5)]

   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

list_1

   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

[0, 1, 2, 3, 4]

   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

list_1.append(5)

   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

list_1

   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

[0, 1, 2, 3, 4, 5]

   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

#列表中插入元素
list_1.insert(0,0.99)

   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
   
   
   
   

list_1

   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

[0.99, 0, 1, 2, 3, 4, 5]

   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

#修改元素
list_1[0]=0.88
print(list_1)

   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
    
    
    
    
3
   
   
   
   

[0.88, 0, 1, 2, 3, 4, 5]

   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

#删除元素
del list_1[0]
print(list_1)

   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
    
    
    
    
3
   
   
   
   

[0, 1, 2, 3, 4, 5]

   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

list_1.pop()
print(list_1)

   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
   
   
   
   

[0, 1, 2, 3, 4]

   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

list_1.pop(0)
print(list_1)

   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
   
   
   
   

[1, 2, 3, 4]

   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

#根据值删除
list_1.remove(1)

   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
   
   
   
   

list_1

   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

[2, 3, 4]

   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

#sort 永久排序
list_1.sort(reverse=True)
list_1

   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
    
    
    
    
3
   
   
   
   

[4, 3, 2]

   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

#暂时排序
sorted(list_1)

   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
   
   
   
   

[2, 3, 4]

   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

list_1

   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

[4, 3, 2]

   
   
   
   

   
   
   
   

    
    
    
    
1
   
   
   
   

#倒着打印列表
print(list_1)
list_1.reverse()
print(list_1)

   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
    
    
    
    
3
    
    
    
    
4
   
   
   
   

[4, 3, 2]
[2, 3, 4]

   
   
   
   

   
   
   
   

    
    
    
    
1
    
    
    
    
2
   
   
   
   

#写的有点乱，往后继续完善补充。。。。。

• 点赞 29
• 收藏
• 分享
• • 文章举报

GoLee丶

发布了8 篇原创文章 · 获赞 32 · 访问量 4576

私信 关注