Python语言入门

最新推荐文章于 2022-07-08 10:18:58 发布

Cheney822

最新推荐文章于 2022-07-08 10:18:58 发布

阅读量890

点赞数 1

分类专栏：计算机专业基础知识文章标签： python 笔记

本文链接：https://blog.csdn.net/weixin_46291251/article/details/120824587

版权

计算机专业基础知识专栏收录该内容

25 篇文章 8 订阅

订阅专栏

本笔记根据嵩天老师的慕课：Python语言程序设计制作
推荐零基础的同学入门学习
原笔记写在有道云笔记上：链接

注释：

单行注释：以#开头，其后内容为注释
多行注释：以’’'开头和结尾

保留字：
and elif import raise global as else in return nonlocal assert except is try True break finally lambda while False class for not with None continue from or yield async def if pass del await

数据类型：

整数类型： 10011101
字符串类型： “10,011,101”
列表类型： [10, 011, 101]

字符串：由0个或多个字符组成的有序字符序列 - 字符串由一对单引号或一对双引号表示 "请输入带有符号的温度值: "或者 ‘C’ - 字符串是字符的有序序列，可以对其中的字符进行索引（正向递增和反向递减） “请” 是 "请输入带有符号的温度值: " 的第0个字符
字符串的使用：使用[ ]获取字符串中一个或多个字符

索引：返回字符串中单个字符 <字符串>[M] "请输入带有符号的温度值: "[0] 或者 TempStr[-1]
- 切片：返回字符串中一段字符子串 <字符串>[M: N] "请输入带有符号的温度值: "[1:3] 或者 TempStr[0:-1]

列表:由0个或多个数据组成的有序序列

列表使用[ ]表示，采用逗号(,)分隔各元素 [‘F’,‘f’]表示两个元素’F’和’f’
使用保留字 in 判断一个元素是否在列表中 TempStr[-1] in [‘C’,‘c’]判断前者是否与列表中某个元素相同

输入函数 input() :

input()函数的使用格式： <变量> = input(<提示信息字符串>)
用户输入的信息以字符串类型保存在<变量>中 TempStr = input(“请输入”) # TempStr保存用户输入的信息

输出函数 print():以字符形式向控制台输出结果的函数

print()函数的基本使用格式： print(<拟输出字符串或字符串变量>)
字符串类型的一对引号仅在程序内部使用，输出无引号 print(“输入格式错误”) # 向控制台输出输入格式错误
print()函数的格式化： print(“转换后的温度是{:.2f}C”.format©) ,{ }表示槽，后续变量填充到槽中 , { :.2f }表示将变量C填充到这个位置时取小数点后2位

评估函数 eval(): 去掉参数最外侧引号并执行余下语句的函数

eval()函数的基本使用格式： eval(<字符串或字符串变量>)

range()函数：产生循环计数序列

range(N) 产生 0 到 N-1的整数序列，共N个如：range(5) ： 0, 1, 2, 3, 4
range(M,N) 产生 M 到 N-1的整数序列，共N-M个如： range(2, 5)：2, 3, 4

库引用

使用import保留字完成，采用.()编码风格 - import <库名> ----<库名>.<函数名>(<函数参数>)
import更多用法：
from <库名> import <函数名>
from <库名> import * ---- <函数名>(<函数参数>)
import <库名> as <库别名> ---- <库别名>.<函数名>(<函数参数>)

turtle库的使用：
►turtle的绘图窗体：

turtle.setup(width, height, startx, starty)，width, height表示对话框尺寸， startx, starty表示对话框左上角位置坐标
4个参数中后两个可选
setup()不是必须的

►turtle空间坐标体系：
绝对坐标：对话框正中间为(0, 0)
turtle.goto(x, y)
turtle.bk(d) turtle.fd(d) turtle.circle(r,angle)

►turtle角度坐标体系
turtle.seth(angle)

seth()改变海龟行进方向 - angle为绝对度数 - seth()只改变方向但不行进
turtle.left(angle) turtle.right(angle)

►RGB色彩体系
turtle.colormode(mode)

►画笔控制函数
画笔操作后一直有效，直至下次重新设置，一般成对出现

turtle.penup() 别名 turtle.pu()
turtle.pendown() 别名 turtle.pd()
turtle.pensize(width) 别名 turtle.width(width)
turtle.pencolor(color) 其中color可以有三种形式：
颜色字符串：turtle.pencolor(“purple”)
RGB的小数值：turtle.pencolor(0.63, 0.13, 0.94)
RGB的元组值：turtle.pencolor((0.63,0.13,0.94))

►运动控制函数
走直线：- turtle.forward(d) 别名 turtle.fd(d)

d: 行进距离，可以为负数
走曲线：- turtle.circle(r, extent=None)
根据半径r绘制extent角度的弧形
r: 默认圆心在海龟左侧r距离的位置
extent: 绘制角度，默认是360度整圆

►方向控制函数
绝对角度：- turtle.setheading(angle) 别名 turtle.seth(angle)
改变行进方向，海龟走角度

angle: 行进方向的绝对角度
海龟角度：
turtle.left(angle) 海龟向左转
turtle.right(angle) 海龟向右转
angle: 在海龟当前行进方向上旋转的角度

数字类型及操作
►整数类型

可正可负，没有取值范围限制 - pow(x,y)函数：计算 x的y次方，想算多大算多大
4种进制表示形式
十进制：1010, 99, -217
二进制，以0b或0B开头：0b010, -0B101
八进制，以0o或0O开头：0o123, -0O456
十六进制，以0x或0X开头：0x9a, -0X89

► 浮点数类型：

与数学中实数的概念一致
带有小数点及小数的数字
浮点数取值范围和小数精度都存在限制，但常规计算可忽略
取值范围数量级约-10307至10308，精度数量级10-16
浮点数间运算存在不确定尾数，不是bug

0.1 + 0.2 == 0.3 False
round(0.1+0.2, 1) == 0.3 True
其中：round(x, d)：对x四舍五入，d是小数截取位数

►复数类型
z.real 获得实部 z.imag 获得虚部

►数值运算操作符
x / y 除，x与y之商 10/3结果是3.3333333333333335
x // y 整数除，x与y之整数商 10//3结果是3
x % y 余数，模运算 10%3结果是1
x ** y 幂运算，x的y次幂，xy，，当y是小数时，开方运算10**0.5结果是根号十

三种类型存在一种逐渐"扩展"或"变宽"的关系：整数 -> 浮点数 -> 复数
类型间可进行混合运算，生成结果为"最宽"类型

►数值运算函数
函数及使用描述
abs(x) 绝对值，x的绝对值 abs(-10.01) 结果为 10.01
divmod(x,y) 同时输出商和余数 divmod(10, 3) 结果为 (3, 1)
pow(x, y[, z]) 幂余，(x**y)%z，[…]表示参数z可省略 pow(3, pow(3, 99), 10000) 结果为 4587
round(x[, d]) 四舍五入，d是保留小数位数，默认值为0 round(-10.123, 2) 结果为 -10.12
max(x1,x2, … ,xn) 最大值，返回x1,x2, … ,xn中的最大值，n不限 max(1, 9, 5, 4, 3) 结果为 9
min(x1,x2, … ,xn) 最小值，返回x1,x2, … ,xn中的最小值，n不限 min(1, 9, 5, 4, 3) 结果为 1
int(x) 将x变成整数，舍弃小数部分 int(123.45) 结果为123； int(“123”) 结果为123
float(x) 将x变成浮点数，增加小数部分 float(12) 结果为12.0； float(“1.23”) 结果为1.23
complex(x) 将x变成复数，增加虚数部分 complex(4) 结果为 4 + 0j

字符串类型及操作
►字符串类型的表示
字符串：由0个或多个字符组成的有序字符序列

字符串由一对单引号或一对双引号表示
字符串是字符的有序序列，可以对其中的字符进行索引
表示方法：
由一对单引号或双引号表示，仅表示单行字符串 "请输入带有符号的温度值: " 或者 ‘C’
由一对三单引号或三双引号表示，可表示多行字符串 ‘’’ Python 语言 ‘’’
如果希望在字符串中包含双引号或单引号呢？ ‘这里有个双引号(")’ 或者 “这里有个单引号(’)”
如果希望在字符串中既包括单引号又包括双引号呢？ ‘’’ 这里既有单引号(’)又有双引号 (") ‘’’
序号：正向递增序号和反向递减序号
使用：
索引：返回字符串中单个字符 <字符串>[M] "请输入带有符号的温度值: "[0] 或者 TempStr[-1]
切片：返回字符串中一段字符子串 <字符串>[M: N] "请输入带有符号的温度值: "[1:3] 或者 TempStr[0:-1]
切片高级用法：
<字符串>[M: N]，M缺失表示至开头，N缺失表示至结尾
<字符串>[M: N: K]，根据步长K对字符串切片
特殊字符：
转义符表达特定字符的本意 “这里有个双引号(”)" 结果为这里有个双引号(")
转义符形成一些组合，表达一些不可打印的含义 "\b"回退 "\n"换行(光标移动到下行首) “\r” 回车(光标移动到本行首)

►字符串操作符
x + y 连接两个字符串x和y
n * x 或 x * n 复制n次字符串x
x in s 如果x是s的子串，返回True，否则返回False

►字符串处理函数
len(x) 长度，返回字符串x的长度 len(“一二三456”) 结果为 6
str(x) 任意类型x所对应的字符串形式 str(1.23)结果为"1.23" str([1,2])结果为"[1,2]"
hex(x) 或 oct(x) 整数x的十六进制或八进制小写形式字符串 hex(425)结果为"0x1a9" oct(425)结果为"0o651"
chr(u) x为Unicode编码，返回其对应的字符
ord(x) x为字符，返回其对应的Unicode编码

►字符串处理方法
str.lower() 或 str.upper() 返回字符串的副本，全部字符小写/大写 “AbCdEfGh”.lower() 结果为 “abcdefgh”
str.split(sep=None) 返回一个列表，由str根据sep被分隔的部分组成 “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]) 字符串str根据宽度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” #主要用于字符串分隔等

►字符串类型的格式化

字符串格式化使用.format()方法，用法如下： <模板字符串>.format(<逗号分隔的参数>)

： <填充> <对齐> <宽度> <,> <.精度> < <类型>
引导符号用于填充的单个字符 < 左对齐 > 右对齐^ 居中对齐槽设定的输出宽度数字的千位分隔符浮点数小数精度或字符串最大输出长度整数类型 b, c, d, o, x, X 浮点数类型 e, E, f, %

“{0:=^20}”.format(“PYTHON”) ‘=PYTHON=’
“{0:*>20}”.format(“BIT”) ‘*****************BIT’
“{:10}”.format(“BIT”) 'BIT ’
“{0:,.2f}”.format(12345.6789) ‘12,345.68’
“{0:b},{0:c},{0:d},{0:o},{0:x},{0:X}”.format(425) ‘110101001,Ʃ,425,651,1a9,1A9’
“{0:e},{0:E},{0:f},{0:%}”.format(3.14) ‘3.140000e+00,3.140000E+00,3.140000,314.000000%’

time库的使用：
►时间获取：time() ctime() gmtime()
time() 获取当前时间戳，即计算机内部时间值，浮点数 >>>time.time() 1516939876.6022282
ctime() 获取当前时间并以易读方式表示，返回字符串 >>>time.ctime() ‘Fri Jan 26 12:11:16 2018’
gmtime() 获取当前时间，表示为计算机可处理的时间格式>>>time.gmtime()time.struct_time(tm_year=2018, tm_mon=1,tm_mday=26, tm_hour=4, tm_min=11, tm_sec=16,tm_wday=4, tm_yday=26, tm_isdst=0)

►时间格式化：strftime() strptime()
strftime(tpl, ts) tpl是格式化模板字符串，用来定义输出效果 ts是计算机内部时间类型变量 >>>t = time.gmtime() >>>time.strftime("%Y-%m-%d %H:%M:%S",t) ‘2018-01-26 12:55:20’
strptime(str, tpl) 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=4, tm_min=11, tm_sec=16, tm_wday=4, tm_yday=26, tm_isdst=0)
格式化控制符：
格式化字符串日期/时间说明值范围和实例
%Y 年份 0000~9999，例如：1900
%m 月份 01~12，例如：10
%B 月份名称 January~December，例如：April
%b 月份名称缩写 Jan~Dec，例如：Apr
%d 日期 01~31，例如：25
%A 星期 Monday~Sunday，例如：Wednesday
%a 星期缩写 Mon~Sun，例如：Wed
%H 小时（24h制） 00~23，例如：12
%I 小时（12h制） 01~12，例如：7
%p 上/下午 AM, PM，例如：PM
%M 分钟 00~59，例如：26
%S 秒 00~59，例如：26
►程序计时：sleep(), perf_counter()
perf_counter() 返回一个CPU级别的精确时间计数值，单位为秒由于这个计数值起点不确定，连续调用差值才有意义 >>>start = time.perf_counter() 318.66599499718114 >>>end = time.perf_counter() 341.3905185375658 >>>end - start 22.724523540384666
sleep(s) s拟休眠的时间，单位是秒，可以是浮点数>>>def wait():time.sleep(3.3)>>>wait() #程序将等待3.3秒后再退出

程序的异常处理：
try : <语句块1> except : <语句块2>
try : <语句块1> except <异常类型> : <语句块2>
异常处理的高级使用：
try : <语句块1> except : <语句块2> else : <语句块3> finally : <语句块4>

finally对应语句块4一定执行
else对应语句块3在不发生异常时执行

random库
►函数：
seed(a=None) 初始化给定的随机数种子，默认为当前系统时间 >>>random.seed(10) #产生种子10对应的序列
random() 生成一个[0.0, 1.0)之间的随机小数 >>>random.random() 0.5714025946899135
►扩展随机数函数：
randint(a, b) 生成一个[a, b]之间的整数 >>>random.randint(10, 100) 64
randrange(m, n[, k]) 生成一个[m, n)之间以k为步长的随机整数 >>>random.randrange(10, 100, 10) 80
getrandbits(k) 生成一个k比特长的随机整数 >>>random.getrandbits(16) 37885
uniform(a, b) 生成一个[a, b]之间的随机小数 >>>random.uniform(10, 100) 13.096321648808136
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);print(s) [3, 5, 8, 9, 6, 1, 2, 7, 4]

函数
►定义：
def <函数名>(<参数(0个或多个)>) :
<函数体>
return <返回值>

►参数：

函数可以有参数，也可以没有，但必须保留括号
函数定义时可为某些参数指定默认值，构成可选参数： def <函数名>(<非可选参>, <可选参>) ：
函数定义时可以设计可变数量参数，即不确定参数总数量：def <函数名>(<参数>, *b ) :
函数调用时，参数可以按照位置或名称方式传递>>> fact( 10,5 ) >>> fact( m=5,n=10 )

►返回值

函数可以有返回值，也可以没有，可以有return，也可以没有
return可以传递0个返回值，也可以传递任意多个返回值
return s//m, n, m

a,b,c = fact(10,5)

PyInstaller库
►概述:
将.py源代码转换成无需源代码的可执行文件

官方网站：http://www.pyinstaller.org
第三方库：使用前需要额外安装
需要使用pip工具:(cmd命令行) pip install pyinstaller

►常用参数:
-h

-i <图标文件名.ico> 指定打包程序使用的图标(icon)文件

集合类型及操作
►定义:

集合类型与数学中的集合概念一致
集合元素之间无序，每个元素唯一，不存在相同元素
集合元素不可更改，不能是可变数据类型
集合用大括号 {} 表示，元素间用逗号分隔
建立集合类型用 {} 或 set()
建立空集合类型，必须使用set()

►操作符:
例如：>>> A = {“p”, “y” , 123} >>> B = set(“pypy123”)
S | T 并，返回一个新集合，包括在集合S和T中的所有元素 >>> A|B {‘1’, ‘p’, ‘2’, ‘y’, ‘3’, 123}
S - T 差，返回一个新集合，包括在集合S但不在T中的元素 >>> A-B {123} >>> B-A{‘3’, ‘1’, ‘2’}
S & T 交，返回一个新集合，包括同时在集合S和T中的元素 >>> A&B {‘p’, ‘y’}
S ^ T 补，返回一个新集合，包括集合S和T中的非相同元素 >>> A^B {‘2’, 123, ‘3’, ‘1’}
S <= T 或 S < T 返回True/False，判断S和T的子集关系
S >= T 或 S > T 返回True/False，判断S和T的包含关系
S |= T 并，更新集合S，包括在集合S和T中的所有元素
S -= T 差，更新集合S，包括在集合S但不在T中的元素
S &= T 交，更新集合S，包括同时在集合S和T中的元素
S ^= T 补，更新集合S，包括集合S和T中的非相同元素

►集合处理方法：
S.add(x) 如果x不在集合S中，将x增加到S
S.discard(x) 移除S中元素x，如果x不在集合S中，不报错
S.remove(x) 移除S中元素x，如果x不在集合S中，产生KeyError异常
S.clear() 移除S中所有元素
S.pop() 随机返回S的一个元素，更新S，若S为空产生KeyError异常
S.copy() 返回集合S的一个副本
len(S) 返回集合S的元素个数
x in S 判断S中元素x，x在集合S中，返回True，否则返回False
x not in S 判断S中元素x，x不在集合S中，返回True，否则返回False
set(x) 将其他类型变量x转变为集合类型

►集合类型的应用：

数据去重（利用集合元素的互异性）
包含关系比较（直接用 > 、< 、=）

序列类型及操作
►- 序列类型定义
字符串
序列元组
列表
正向递增序号 0 1 2 3
反向递减序号-1-2-3-4

►- 序列处理函数及方法
序列类型通用操作符：
x in s 如果x是序列s的元素，返回True，否则返回False
x not in s 如果x是序列s的元素，返回False，否则返回True
s + t 连接两个序列s和t
sn 或 ns 将序列s复制n次
s[i] 索引，返回s中的第i个元素，i是序列的序号
s[i: j] 或 s[i: j: k] 切片，返回序列s中第i到j以k为步长的元素子序列
序列类型通用函数和方法：
len(s)

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

►元组类型及操作

元组是序列类型的一种扩展
元组是一种序列类型，一旦创建就不能被修改
使用小括号 () 或 tuple() 创建，元素间用逗号 , 分隔
可以使用或不使用小括号
例如：

creature = “cat” , “dog” , “tiger” , “human”
creature (‘cat’, ‘dog’, ‘tiger’, ‘human’)
color = (0x001100, “blue”, creature)
color (4352, ‘blue’, (‘cat’, ‘dog’, ‘tiger’, ‘human’))

操作：

元组继承了序列类型的全部通用操作
元组因为创建后不能修改，因此没有特殊操作
使用或不使用小括号

►列表类型及操作

列表是序列类型的一种扩展，十分常用
列表是一种序列类型，创建后可以随意被修改
使用方括号 [] 或list() 创建，元素间用逗号 , 分隔
列表中各元素类型可以不同，无长度限制
例如：

ls = [“cat” , “dog” , “tiger” , 1024]
ls [‘cat’, ‘dog’, ‘tiger’, 1024]
lt = ls >>> lt [‘cat’, ‘dog’, ‘tiger’, 1024]
方括号 [] 真正创建一个列表，赋值仅传递引用（类似于指针）

函数和方法：
ls[i] = x 替换列表ls第i元素为x
ls[i: j: k] = lt 用列表lt替换ls切片后所对应元素子列表
del ls[i] 删除列表ls中第i元素
del ls[i: j: k] 删删除列表ls中第i到第j以k为步长的元素
ls += lt 更新列表ls，将列表lt元素增加到列表ls中
ls *= n 更新列表ls，其元素重复n次
ls.append(x)
ls.clear()
ls.copy()
ls.insert(i,x)

例如：

ls = [“cat” , “dog” , “tiger” , 1024]
ls[1:2] = [1, 2, 3, 4] [‘cat’, 1, 2, 3, 4, ‘tiger’, 1024]
del ls[::3] [1, 2, 4, ‘tiger’]
ls*2 [1, 2, 4, ‘tiger’, 1, 2, 4, ‘tiger’]
ls.append(1234) [‘cat’, ‘dog’, ‘tiger’, 1024, 1234]
ls.insert(3, “human”) [‘cat’, ‘dog’, ‘tiger’, ‘human’, 1024, 1234]
ls.reverse() [1234, 1024, ‘human’, ‘tiger’, ‘dog’, ‘cat’]

►序列类型应用场景
1.数据表示：元组和列表

元组用于元素不改变的应用场景，更多用于固定搭配场景
列表更加灵活，它是最常用的序列类型
最主要作用：表示一组有序数据，进而操作它们
2.元素遍历: for item in ls :
3.数据保护: 如果不希望数据被程序所改变，转换成元组类型

字典类型及操作
►字典类型定义

映射是一种键(索引)和值(数据)的对应
序列类型由0…N整数作为数据的默认索引
字典类型则由用户为数据定义索引
键值对：键是数据索引的扩展
字典是键值对的集合，键值对之间无序
采用大括号{}和dict()创建，键值对用冒号: 表示

用法：在字典变量中，通过键获得值
<字典变量> = {<键1>:<值1>, … , <键n>:<值n>}
<值> = <字典变量>[<键>]
<字典变量>[<键>] = <值>
[ ] 用来向字典变量中索引或增加元素

实例：

d = {“中国”:“北京”, “美国”:“华盛顿”, “法国”:“巴黎”}
d {‘中国’: ‘北京’, ‘美国’: ‘华盛顿’, ‘法国’: ‘巴黎’}
d[“中国”] ‘北京’
de = {} ; type(de)
type(x) 返回变量x的类型

►字典处理函数及方法
del d[k] 删除字典d中键k对应的数据值
k in d 判断键k是否在字典d中，如果在返回True，否则False
d.keys() 返回字典d中所有的键信息
d.values() 返回字典d中所有的值信息
d.items() 返回字典d中所有的键值对信息
d.get(k, ) 键k存在，则返回相应值，不在则返回值
d.pop(k, )
d.popitem()
d.clear()
len(d
实例：

d = {“中国”:“北京”, “美国”:“华盛顿”, “法国”:“巴黎”}
“中国” in d -----True
d.keys() dict_keys([‘中国’, ‘美国’, ‘法国’])
d.values() dict_values([‘北京’, ‘华盛顿’, ‘巴黎’])
d.get(“中国”,“伊斯兰堡”) ‘北京’
d.get(“巴基斯坦”,“伊斯兰堡”) ‘伊斯兰堡’
d.popitem() (‘美国’, ‘华盛顿’)

►字典类型应用场景
1.映射的表达

映射无处不在，键值对无处不在
例如：统计数据出现的次数，数据是键，次数是值
最主要作用：表达键值对数据，进而操作它们
2.元素遍历
for k in d : <语句块>

jieba库的使用
►概述

jieba是优秀的中文分词第三方库
中文文本需要通过分词获得单个的词语
jieba是优秀的中文分词第三方库，需要额外安装
jieba库提供三种分词模式，最简单只需掌握一个函数

►三种模式

精确模式：把文本精确的切分开，不存在冗余单词
全模式：把文本中所有可能的词语都扫描出来，有冗余
搜索引擎模式：在精确模式基础上，对长词再次切分

►常用函数
jieba.lcut(s) 精确模式，返回一个列表类型的分词结果 >>>jieba.lcut(“中国是一个伟大的国家”) [‘中国’, ‘是’, ‘一个’, ‘伟大’, ‘的’, ‘国家’]
jieba.lcut(s, cut_all=True) 全模式，返回一个列表类型的分词结果，存在冗余 >>>jieba.lcut(“中国是一个伟大的国家”,cut_all=True) [‘中国’, ‘国是’, ‘一个’, ‘伟大’, ‘的’, ‘国家’]
jieba.lcut_for_sear ch(s) 搜索引擎模式，返回一个列表类型的分词结果，存在冗余 >>>jieba.lcut_for_search(“中华人民共和国是伟大的") [‘中华’, ‘华人’, ‘人民’, ‘共和’, ‘共和国’, ‘中华人民共和国’, ‘是’, ‘伟大’, ‘的’]
jieba.add_word(w) 向分词词典增加新词>>>jieba.add_word(“蟒蛇语言”)

文件的使用
►文件的类型

文件是存储在辅助存储器上的数据序列
文件是数据存储的一种形式
文件展现形态：文本文件和二进制文件
文件文件和二进制文件只是文件的展示方式
本质上，所有文件都是二进制形式存储
形式上，所有文件采用两种方式展示

文本文件:

由单一特定编码组成的文件，如UTF-8编码
由于存在编码，也被看成是存储着的长字符串
适用于例如：.txt文件、.py文件等
二进制文件 :
直接由比特0和1组成，没有统一字符编码
一般存在二进制0和1的组织结构，即文件格式
适用于例如：.png文件、.avi文件等

► 文件的打开和关闭
步骤: 打开-操作-关闭
打开:<变量名> = open(<文件名>, <打开模式>)
变量名：文件句柄
文件名：文件路径和名称源文件同目录可省路径
打开模式：文本 or 二进制 && 读 or 写具体如下表：
‘r’ 只读模式，默认值，如果文件不存在，返回FileNotFoundError
‘w’ 覆盖写模式，文件不存在则创建，存在则完全覆盖
‘x’ 创建写模式，文件不存在则创建，存在则返回FileExistsError
‘a’ 追加写模式，文件不存在则创建，存在则在文件最后追加内容
‘b’ 二进制文件模式
‘t’ 文本文件模式，默认值
‘+’ 与r/w/x/a一同使用，在原功能基础上增加同时读写功能
关闭：<变量名>.close()

►文件内容的读取
操作方法:
.read(size=-1) 读入全部内容，如果给出参数，读入前size长度 >>>s = f.read(2) 中国
.readline(size=-1) 读入一行内容，如果给出参数，读入该行前size长度 >>>s = f.readline() 中国是一个伟大的国家！
.readlines(hint=-1) 读入文件所有行，以每行为元素形成列表如果给出参数，读入前hint行 >>>s = f.readlines() [‘中国是一个伟大的国家！’]
全文本操作:
方法一:一次读入，统一处理
fname = input(“请输入要打开的文件名称:”)
fo = open(fname,“r”)
txt = fo.read() #对全文txt进行处理
fo.close()

方法二:按数量读入，逐步处理
fname = input(“请输入要打开的文件名称:”)
fo = open(fname,“r”) txt = fo.read(2)
while txt != “”: #对txt进行处理
txt = fo.read(2)
fo.close()

文件的逐行操作:
方法一:一次读入，分行处理
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()

► 数据的文件写入
.write(s) 向文件写入一个字符串或字节流 >>>f.write(“中国是一个伟大的国家!”)
.writelines(lines) 将一个元素全为字符串的列表写入文件 >>>ls = [“中国”, “法国”, “美国”] >>>f.writelines(ls) 中国法国美国
.seek(offset) 改变当前文件操作指针的位置，offset含义如下： 0 – 文件开头； 1 – 当前位置； 2 – 文件结尾 >>>f.seek(0) #回到文件开头

一维数据的格式化和处理
►一维数据的表示
有序：使用列表类型

列表类型可以表达一维有序数据
for循环可以遍历数据，进而对每个数据进行处理
无序：使用集合类型
集合类型可以表达一维无序数据
for循环可以遍历数据，进而对每个数据进行处理

►一维数据的存储
存储方式一：空格分隔

使用一个或多个空格分隔进行存储，不换行
缺点：数据中不能存在空格
存储方式二：逗号分隔
使用英文半角逗号分隔数据进行存储，不换行
缺点：数据中不能有英文逗号
存储方式三：其他方式
使用其他符号或符号组合分隔，建议采用特殊符号
缺点：需要根据数据特点定义，通用性较差

►一维数据的处理

将存储的数据读入程序
将程序表示的数据写入文件
ls = [‘中国’ , ‘美国’ , ‘日本’]
f = open(fname, ‘w’)
f.write(’ ‘.join(ls)) #采用空格分隔方式将数据写入文件
#f.write(’$’.join(ls)) #采用特殊分隔方式将数据写入文件
f.close()

二维数据的格式化和处理
►二维数据的表示
一二维数据的Python表示: 数据维度是数据的组织形式