python基础语法（mooc+小甲鱼）

探野野

于 2023-02-22 10:27:04 发布

阅读量697

点赞数

文章标签： python 开发语言

本文链接：https://blog.csdn.net/ycc321000/article/details/129157462

版权

文章目录

0.总介绍
- 编程语言分类：**人生苦短，我学python**
1.数据类型及操作
2.组合数据类型
3.**程序控制结构**
4.函数
5.**代码复用**：函数和对象为主要形式
6.模块化：打包分发
- pypi.org **找第三方库**
- UCI页面PyInstaller:将.py源代码转换成编程可执行文件
7.**文件和数据格式化**
8.库介绍
9.应用介绍

0.总介绍

编译：源代码一次性转换成目标代码，之后不再需要源代码

解释：将源代码逐条转换成目标代码并运行

编程语言分类：人生苦短，我学python

静态语言e.g.C/C++,Java 运行更快
脚本语言 e.g,Python 更容易维护

IPO:input,process,output

why编程:兴趣，乐趣，效率，就业

C:提高性能，理解计算机系统结构
Java:面向对象，理解主客体关系，跨平台
C++:大规模程序
VB:桌面应用开发，不常用
python:解决计算部分，是通用语言，语法简洁，生态高产
机器语言:代码直接执行
汇编语言:助记符
高级语言:与CPU型号无关，编译后运行
超级语言

缩进:单一程序内缩进长度一样

注释:# 或者"’ "’

命名变量:大小写字母，数字，汉字，下划线及组合

数字不是首字母，不可以是保留字

**保留字:**见图

逻辑思维，实证思维，计算思维
计算生态：开源思想，竞争发展，相互依存，更新迭代
用户体验：进度显示，异常处理，帮助信息
基本程序设计模式：IPO，自顶向下，自底向上，模块化（松耦合，紧耦合），配置化设计

思维

模块化思维：封装功能

规则化思维：抽象过程为规则

自顶向下（设计）

自底向上（执行）

1.数据类型及操作

类型

整数类型

4种进制:十进制，二进制(以0b或0B开头，比如0b010),八进制(以0o或0O开头)，十六进制(以0x或0X开头)

pow(x,y)是x的y次方

浮点数类型:有小数点的数字，即实数

浮点数间运算存在不确定尾数，不是bug，一般发生在16位左右

round(x,d)对x四舍五入，d为截取小数位数

e或E作为幂的符号，10是基数

aeb表示a×10的b次方

布尔类型

True=1,False=0

复数类型

j的平方等于负一

z.real获得实部

z.imag获得虚部

字符串（两侧有单引号或者双引号）

正向递增（从0开始），反向递减（从-1开始）

①""/''表示单行字符串

②’‘’ ‘’'/“”" “”"表示多行字符串

序号:正向递增，反向递减

索引字符串[M]

切片字符串[M:N] / 字符串[M,N,K]，K为步长

转义符╲

①表达特定字符本意，e.g.(╲")意思是"

>>> 'Let\'s go'
"Let's go"

②固定意思╲b为回退，╲n为换行，╲n为回车(光标回到本行首)

\也可能导致表示没有结束，只是换行

原始字符串：字符串前面加r
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-wl8qi3fe-1677032755795)(Mooc Python基础语法.assets/image-20221121120942619.png)]

数值运算操作符,生成最宽类型

//整数除，10//3是3
/产生浮点数结果
+x为x本身
x%y为余数
x**y，x的y次方，当y是小数时，开方运算

幂运算操作符比其左侧的一元操作符优先级高，比其右侧的一元操作符优先级低
```
>>> -5 ** 2 
    -25 
>>> 5 ** -2 
0.04 
```
二元操作符op x op=y，即x=x op y
+= -=
== !=
5 > 3 < 4 √
not>and>or
or从左至右依次判断，如果遇到非零，结束判断并返回该非零值
and从左到右计算表达式,若所有值均为真,则返回最后一个值,若存在假,返回第一个假值.
del 删除元素，变量，作用于原列表

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Ok1o1BLH-1677032755797)(Mooc Python基础语法.assets/image-20221121103506986.png)]

数值运算函数

abs(x)求解x的绝对值
divmod(x,y),商余，输出商和余数，(m,n)
pow(x,y,[z])，x的y次方，z是幂余,z可以省略
round(x,[d])四舍五入，d是保留小数位数，默认为0
max(x,y,z,…)/min(x,y,z,…)
int(x)将x变成整数，舍弃小数
float(x),将x变成浮点数，增加小数部分
complex(x)整数变复数

字符串操作

操作

x+y连接起来

nx/xn n是整数，复制n次字符x

x in s 如果x是s的子串，返回TRUE,否则输出FALSE

处理函数

len(x)返回长度

str(x)任意类型x对应的字符串形式

hex(x)或者oct(x)转换成十六进制或者八进制

chr(u) u是Unicode编码，返回其对应字符

ord(x) x是字符，返回Unicode编码

处理方法

方法必须要用.的形式

.lower/.upper 全部字符变成小/大写
.split(sep=None)返回一个列表，由str根据sep被分隔的部分组成
.replace(old,new)把字符串里面的old变成new
.center(width,fillchar)根据宽度居中，然后用fillchar填充剩余部分
.strip(chars)去掉字符串里面左右侧的chars
.join(iter)在iter变量除最后元素外每个元素后增加一个字符串，主要用于字符串inter分隔，支持一切课迭代对象(如列表，元组，字典，文件，集合或生成器等)
.count(sub,start[,end])
.find(sub,start[,end]),找不到就返回-1，或者可以用index(sub,start[,end]),错误会返回异常

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-io8ALlAP-1677032755798)(Mooc Python基础语法.assets/image-20221121113631305.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-aItnWyKZ-1677032755799)(Mooc Python基础语法.assets/image-20221121113654584.png)]

格式化字符串.format()

槽{参数序号:格式控制标记}
格式控制标记:

①第一组

填充(默认是填充空格)
对齐(^居中对齐，＜左对齐，大于右对齐)(默认是左对齐)
宽度

②第二组

，数字的千位分隔符
.精度浮点数小数精度或字符串最大输出长度
类型

①整数类型b(二进制),c(unicode),d(十进制),o(八进制),x(十六进制),X(大写十六进制)

②浮点数类型e(科学计数法e),E(科学记数法E),f(正常),%(百分数形式)

格式化操作符%

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-nr4mDAp8-1677032755799)(Mooc Python基础语法.assets/image-20221121120056185.png)]

举例：

>>> '%d转换为八进制是：%o' % (123, 123) '123转换为八进制是：173' 
>>> '%f用科学计数法表示为：%e' % (149500000, 149500000) 
'149500000.000000用科学计数法表示为：1.495000e+08'

>>> str1 = "一支穿云箭，千军万马来相见；"
>>> str2 = "两副忠义胆，刀山火海提命现。" 
>>> "%s%s" % (str1, str2) '一支穿云箭，千军万马来相见；两副忠义胆，刀山火海提命现。'

字符串拼接方法：

① 简单字符串连接时，直接使用加号（+），例如：full_name

=prefix + name。

② 复杂的，尤其有格式化需求时，使用格式化操作符（%）进行格

式化连接，例如：result = “result is %s:%d” % (name, score)。

③当有大量字符串拼接，尤其发生在循环体内部时，使用字符串

的join()方法无疑是最棒的，例如：result = “”.join(iterator)

格式化操作符辅助命令：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-GsXQtLo3-1677032755800)(Mooc Python基础语法.assets/image-20221121120643616.png)]

举例：

>>> '%5.1f' % 27.658
' 27.7' 
>>> '%.2e' % 27.658 
'2.77e+01' 
>>> '%10d' % 5 
'         5' 
>>> '%-10d' % 5
'5          ' 
>>> '%010d' % 5 
'0000000005' 
>>> '%#X' % 100 
'0X64'

2.组合数据类型

tips

list:从小到大排序–列表

set:去重–集合

可以联用

>>> list1 = [1, 2, 3, 4, 5, 5, 3, 1, 0]
>>> list1 = list(set(list1)) 
>>> list1 [0, 1, 2, 3, 4, 5]

集合{}set(唯一无序)

集合类型

集合中的元素是不可变数据类型
集合用{}表示，元素之间用,分隔
建立集合类型用{}或者set(),建立空集合必须用set
集合元素无序，而且不存在相同元素

集合操作符：

S|T 并

S-T 差

S&T 交

S^T 补

S<= 或 >=T 返回TRUE/FALSE

S< 或 >T 返回TRUE/FALSE

增强操作符：

S|=T 并，更新集合S

S-=T 差，更新集合S

S&=T 交，更新集合S

S^=T 补，更新集合S

集合处理方法：

S.add(x) 把x加到X里

S.discard(x) 移除，如果x不在S里不报错

**S.remove(x)**移除，如果不在，产生keyerror异常

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

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

**S.copy()**返回一个副本

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

x in S 判断S中元素x,x在集合S 中，返回True,否则返回False

x not in S

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

for in 获取时顺序不确定

不可变集合：frozenset()

set1=frozenset({1,2,3,4,5})
set1.add(7)
error

应用场景：

包含关系的比较
数据去重

序列[]（包括字符串，元组()tuple和列表[]list）

序列类型：

序列有先后关系
包括字符串类型，元组类型，列表类型
也是正向递增，反向递减

序列操作符

x in s返回TRUE或者FALSE

x not in s

s+t

sn或ns

s[i]

s[i:j:k]

len(s)

min(s)/max(s)

s.index(x)第一次出现x的位置

s.count(x) 出现x的次数

sorted(x)排序

sum(start)

reversed()是返回一个翻转后的迭代器对象

enumerate()方法生成由二元组（二元组就是元素数量为2的元组）

构成的一个迭代对象

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-avdDITS1-1677032755801)(Mooc Python基础语法.assets/image-20221121122318524.png)]

zip()用于返回由各个可迭代参数共同组成的元组

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-dTkRosky-1677032755801)(Mooc Python基础语法.assets/image-20221121122540811.png)]

1.字符串 str()

#字符串（两侧有单引号或者双引号）

2.元组类型及操作(固定)(保护数据)

元祖一旦被创建就不能被修改
可以用()或者tuple()创建，元素间用,分隔

可以使用或者不使用(), ","是关键

>>> tuple1 = (520,) 
>>> type(tuple1)# <class 'tuple'>
>>> tuple2 = 520, 
>>> tuple1 == tuple2 True 
>>> tuple3 = 1, 2, 3, 4, 5
>>> type(tuple3) <class 'tuple'>

切片时会生成一个新的元组

e.g

>>> tuple2 = tuple1[:]
>>> tuple2 (1, 2, 3, 4, 5, 6, 7, 8)

3.列表类型及操作

使用[]或者list()创建，元素间用,分隔
可以出现同一个列表有不同名字，赋值相当于重新命名
当列表包含多个元素的时候，默认是从第一个元素开始比较，只要有一个PK赢了，就算整个列表赢了

操作

ls[i]=x 替换第i元素为x

ls[i:j:k]=lt 用列表lt替换ls切片后对应元素新列表

del ls[i] 删除第i元素

del ls[i:j:k]

ls += lt 更新列表ls，将lt加进来

ls*n 更新列表ls,将其元素重复n次

ls.append(x)列表最后增加x，只支持一个参数

ls.extend([x,y,z…])支持添加多个元素

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

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

ls.insert(i,x)在列表第i位置增加元素x,i从0开始算

ls.pop(i) 将列表第i元素取出并删除该元素,如果不带参数，默认是最后一个元素

ls.remove(x)将第一个元素x删除

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

ls.count()

ls.index()限定查找范围

ls.sort()

>>> list1 = [8, 9, 3, 5, 2, 6, 10, 1, 0] 
>>> list1.sort(reverse=True) 
>>> list1 [10, 9, 8, 6, 5, 3, 2, 1, 0]

元素换位置ls[1],ls[3]=ls[3],ls[1]

序列里不放浮点数，必须是整除

字典{}dict()

字典类型

使用{}和dict(),键值对用冒号表示
索引用d[键]为值
增加 d[“a”]=1 或删减
修改元素也用赋值 d[键]=a
生成空字典:de={};type(de)返回变量x的类型
生成空集合只能用set()

如果命名，键的位置不能加表示字符串引号

同一个键也不能出现两次，如果同一个键被赋值两次，后一个值会被记住

键必须不可变，可以用数值，字符串或者元组充当

>>> a = dict(one=1, two=2, three=3)
>>> b = {'one': 1, 'two': 2, 'three': 3} 
>>> c = dict(zip(['one', 'two', 'three'], [1, 2, 3])) 
>>> d = dict([('two', 2), ('one', 1), ('three', 3)])
>>> e = dict({'three': 3, 'one': 1, 'two': 2})
>>> a == b == c == d == e 
True

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

k in d / k not in d

d.keys()返回所有键信息

d.values()返回所有值信息,格式还是字典

d.items()返回所有键值对信息

d.fromkeys(seq[,value])法用于创建并返回一个新的字典,值如果不给默认是None

>>> dict1 = {}
>>> dict1.fromkeys((1, 2, 3)) {1: None, 2: None, 3: None}
>>> dict2 = {} 
>>> dict2.fromkeys((1, 2, 3), "Number") 
{1: 'Number', 2: 'Number', 3: 'Number'}

setdefault(key[, default]) 类似get,在字典中找不到相应的键时会自动添加

d.get(k,)k存在，则返回相应值，不存在则返回default值

d.pop(k,)同理，只不过是取出

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

d.clear()

d.copy()

d.update([a=b])

字典应用:

反转键和值d变e

for k in d:

e[d[k]]=k

3.程序控制结构

顺序结构

输入的数字格式是字符串

可以用\换行增加可读性

a-=b相当于a=a-b

分支结构

条件判断及组合

操作符：!=意思是不等于，==是等于

条件组合的保留字：x and y,x or y,not x

if not True:

A(永远不会被执行）

else:

循环结构

1.遍历循环for

for in :

①计数循环：for i in range(m,n,k步长):

②字符串遍历循环：for i in s

③列表遍历循环：for item in ls

④文件遍历循环： for line in fi

2.无限循环while,条件为True执行操作

contrl c退出循环

循环控制保留字

①break，完全打断，跳出当前循环，1，个break只能跳出一个循环

②continue,只打断单次，然后开始下一轮循环

循环的高级用法：循环+else,可以知道循环是否被break结束

不执行break语句以后，执行else

程序异常处理

异常类型

AssertionError：assert关键字放到检查点

比如assert a >0
AttributeError：尝试访问未知的对象属性
IndexError：索引超出序列的范围
KeyError：字典中查找一个不存在的关键字
NameError：尝试访问一个不存在的变量
OSError：操作系统产生的异常,像打开一个不存在的文件会引发FileNotFoundError
SyntaxError：Python的语法错误
TypeError：不同类型间的无效操作
ZeroDivisionError：除数为零

try-except

try:
    语句块1
except 异常类型 as reason:
    print (str(reason))#也可以不写原因

多个异常可以统一处理

try:
    语句块1
except （异常类型1,异常类型2）:
    print (str(reason))#也可以写

try-finally

else 不发生异常时候执行

finally不论是不是异常都执行

try:
    while TRUE:
           语句
except:
     print()
finally:
     f.close()

raise语句可以自己抛出异常，带参数表示异常的解释

raise ZeroDivisionError("除数不能为0")

with可以自动关闭文件

try:
    with open("data.txt",'w') as f:
        for line in f:
            print(line)
except OSError as reason:
    print("出错啦"+str(reason))

4.函数

函数定义与使用

定义：是一段有功能的代码，用来函数复用

def 函数名(参数):#小括号必须有
   函数体
   return 函数名

调用：

调用时要给出实际参数
实际参数替换定义中的参数
函数调用后得到返回值

文档说明 ··· 。。。。 ···

可以用‘文件名.__doc__获取’

自带函数

定义：BIF（built-in functions)内置函数

dir(__builtins)

学过的：
- help(函数名)
- 输入input（）
- 输出print（"{:.}.format©）意思是把C填充到大括号里面取小数点后两位
  
  print(…,end=‘’)
  
  print(a,b)输出后a和b中间有一个空格
- 评估函数eval()去掉参数最外侧引号并执行余下语句的函数
- isinstance(待确定类型的数据,指定一个数据类型)
- type()
- id()

内嵌函数

允许在函数内部定义另一个函数，这种函数称为内嵌函数或者内部函数

在嵌套函数中，内部函数可以引用外部函数的局部变量

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-bZSHMCN2-1677032755802)(Mooc Python基础语法.assets/image-20221121134727895.png)]

LEGB含义解释：

• L-Local：函数内的名字空间。

• E-Enclosing function locals：嵌套函数中外部函数的名字空间。

• G-Global：函数定义所在模块的名字空间。

• B-Builtin：Python内置模块的名字空间。

那么变量的查找顺序依次就是L→E→G→B。

闭包（closure）：就是在嵌套函数的环境下，内部函数引用了外部函数的局部变量，那么内部函数就被认为是闭包

利用嵌套函数的外层作用域具有记忆能力的特性
将内层函数作为返回值返回

在内部函数中，只能对外部函数的局部变量进行访问，但不能进行修改

如果想修改可以用nonlocal 变量

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Ya8TdyY8-1677032755802)(Mooc Python基础语法.assets/image-20221121135734606.png)]

装饰器log()和@语法糖：把函数作为参数传递给另外一个函数

装饰器可以一层套一层

def log(func)
def wrapper(*name)
    print("开始调用Eat函数")
    func(*name)
    print("终于结束了")
@log
def eat(*name):
    print("%s开始吃了"% *name)
#把下面的函数作为一个参数塞到前面的语法糖里面的函数里面并且运行装饰器

装饰器串联时执行顺序是自下往上

装饰器可以传递参数

参数传递：

可以有参数，也可以没有参数，但是要保留括号

可选参数，放在非可选参数之后，

def 函数名（参数，m=1)
#m=1,意思是m默认为1，也可以变成给的参数

默认参数

def say(name="我"，word="好勤奋")：
    print(name+word)
say()
我好勤奋
say(你，好傻)
你好傻

可变参数传递，数量不定 def 函数名(参数，*b) #“星号”起到打包作用
- 如果后面还要指定其他参数，输入时要用a=b的形式
- 星号用到实操是解包的作用
```
>>> name = "FishC"
>>> print(*name) 
F i s h C
```
- 两个星号会打包成字典形式
调用时，不仅可以按照位置，也可以按照名称（关键字参数）

fact(m=5,n=10)

函数的返回值（也可以没有）

return a,b,c

会返回（a,b,c)是元组类型

局部变量和全局变量

函数外定义：全局变量

函数内定义：局部变量

规则：

1.局部变量和全局变量是不同变量

局部变量是函数内部的占位符，与全局变量可能重名但不同
函数运算结束后，局部变量被释放
可以使用global保留字在函数内部使用全局变量，global 函数名

2.局部变量如果是组合数据类型（比如列表），而且未在函数内部创建，就等同于全局变量

几个编写通用函数

lambda函数

返回函数名作为结果

函数名=lambda 参数：表达式

主要用做一些也定函数或者方法的参数

>>> g = lambda x, y : x + y 
>>> g(3, 4)
7

filter(函数/None,组合数据)

如果第一个参数是函数则将第二个可迭代对象里的每一个元素作为函数的参数进行计算，把返回True的值筛选出来
如果第一个参数为None，则直接将第二个参数中为True的值筛选出来
```
>>> list(filter(lambda x : x % 2, range(10)))
[1, 3, 5, 7, 9]
```

map(函数，可迭代对象)

定义：将可迭代对象的每一个元素作为函数的参数进行运算加工，直到可迭代序列每个元素都加工完毕，map()会从

所有可迭代对象中依次取一个元素组成一个元组，然后将元组传递给func。

注意：如果可迭代对象的长度不一致，则以较短的迭代结束为止

>>> list(map(lambda x : x * 2, range(10)))
[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]

>>> list(map(lambda x, y : x + y, [1, 3, 5], [10, 30, 50, 66, 88]))
[11, 33, 55]

无限制数量函数

cmul(a,*b) b在cmul表达除了a之外的所有参数，可以和eval连用

if下面可以用return,后面直接跟具体值

5.代码复用：函数和对象为主要形式

模块化设计：主程序，子程序和子程序之间的关系

紧耦合和松耦合，模块内部紧耦合，模块之间松耦合

函数递归：函数调用自身

关键要素：

1.链条：计算过程中存在递归链条

2.基例：存在一个或多个不需要再次递归的基例

递归实现：函数+分支语句

递归调用

6.模块化：打包分发

pypi.org 找第三方库

安装方法：

pip（要联网）

pip install -U 第三方库进行更新

pip uninstall 第三方库

pip domnload 第三方库

pip show 第三方库获得介绍信息

pip search 关键词

pip list

集成安装

Anaconda支持800个第三方库，适合数据分析

文件安装

pip可以下载，但是不能安装，需要编译环境

UCI页面PyInstaller:将.py源代码转换成编程可执行文件

第三方库

7.文件和数据格式化

文件

tips

stopwords() 可以去掉重复词

文件类型:

文件的展示方式（都以二进制存储）：

文本文件（由单一编码组成）
二进制文件（直接由比特01组成，没有统一字符编码）

文件打开与关闭:

打开

变量名=open(文件名路径 , 打开模式)

文件名路径：/要变成//或者\

绝对路径or相对路径（相同的变成.如果在同一个目录，可以直接用文件名）

打开模式：

默认是文本形式，只读模式，默认值

‘r’只读，如果不存在，返回FileNotFoundError
'w’覆盖写模式，文件不存在则创建，存在则完全覆盖,'w’打开模式会删除原来的文件内容
’x’创建写模式，不存在就创建，存在就返回FileExistsError
'a’追加写模式，文件不存在就创建，存在则在文件最后追加内容
‘b’二进制文件模式
’t’文本文件模式
‘+’与r/w/x/a一起使用，在原有基础上增加读写能力

e.g.rt/wb

文件关闭：变量.close()

读文件：

a.read(size)读入全部内容，如果给参数，读入前size长度
a.redline(size)读入一行内容，如果给出参数，读入该行前size长度
a.readlines(hint)读入文件所有行/读入前hint行

全文本操作

直接全部打开：a=b.read()
按数量读入逐渐打开：

fname()
c=open(fname,'r')
a=b.read(2)
while a !=""
    a=b.read(2)
c.close()

逐行操作：

#1.一次性读入
for a in b.readlines():
    指令
#2.
fo=open(fname,'r')
for line in fo

写文件：

f.write(s) 写入一个字符串或者字节流
f.writelines(lines) 将一个元素全为字符串的列表写入文件，没有换行没有空格
f.seek(offset,from)表示从from偏移offset字节,改变当前文件操作指针的位置，offset=0-文件开头 =1-当前那位置 =2-文件结尾
f.tell()返回当前文件的位置1个中文字符占用2字节的空间

例子：

d[chr(ord('a')+i)] = 0 遍历每一个字符
for c in line:
   d[c] = d.get(c, 0) + 1
cc += 1
#计算出现次数

数据

数据组织的维度：一维（列表，集合等），二维，多维，高维（仅用最基本的二元关系表达关系）

数据存储-表示-操作

1.一维数据

表示：有序用列表，无序用集合，用for循环
存储：①空格分隔不换行，但是数据中不能有空格，②逗号分隔 ③特殊符号分隔
处理：

ls=[…]

f=open(fname,‘w’)

①f.write(’ '.join(ls))（join将其前面的字符串分隔放到后面的字符串）

②ls=f.split()

2.二维数据：

表示：二维列表，两层for循环
存储：

CSV格式：comma-separated calues

.csv,每行一个一维数据，采用逗号分隔，无空行

注：

①如果某个元素缺失，逗号仍要保留

②二维数据的表头可以作为数据存储，也可以另行存储

③逗号为英文半角逗号，逗号与数据之间无额外空格

④数据里面有逗号，外面加引号或者转义符

⑤一般索引习惯：先行后列ls[row][column]

处理

读入：

fo=open(fname)
ls=[]
for line in fo:
    line=line.replace("\n","")
    ls.append(line.split(","))
fo.close()

写回CSV

ls =[ [],[],[] ]
f=open(fname)
for item in ls:
    f.write(",".join(item)+"\n")
f.close（）

逐一遍历：二层循环

ls=[ [],[],[] ]
for row in ls:
    for column in row:
    print(column)

8.库介绍

库引用 import 库名 / from turtle import*(下面不用写库名)(可能出现重名) / import 库名 as 库别名

a.b(不会出现重名)

__name__=’__main__‘

if __name__==`__main__`:
    test

搜索路径
包：创建一个文件夹用来存放相关的模块，文件夹的名字就是包的名字
- 在文件夹中创建一个__init__.py的文件，内容可以为空
- 将相关的模块放入文件夹zhong

1.turtle库

turtle.setup(width,height,startx,starty)

空间坐标体系:

绝对坐标，右上为正

turtle.goto(x,y)

海龟方向

turtle.fd(d)

turtle.bk(d)

turtle.left()

turtle.right()

角度坐标体系

绝对角度

RGB色彩

整数值/小数值(默认)

turtle.colormode()

画笔控制

penup()/pu()

pendown()/pd()

pensize()/width()

pencolor()①里面"purple"②RGB小数值③RGB元组值 +()

运动控制

fd()

circle(r,角度)默认圆心在左侧r距离

方向控制

seth(角度)绝对坐标，只改方向不前进

left/right 海龟坐标

2.time库:处理时间的标准库

函数

time,ctime,gmtime时间获取

①time.time()获取当前时间戳，是浮点数,从1970年开始按秒

②time.ctime()获取当前时间，以易读字符串形式表示

③time.gmtime()生成计算机可处理的时间格式

strftime,trptime时间格式化

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

tpl:控制符(%x)

%Y/m/B(月份名称)/b(月份名称缩写)/d(日期)/A(星期)/a(星期名称缩写)/H(24小时制时间)/I(12小时制时间)/p(上下午)/M(分钟)/S(秒)

②time.strptime(str,tpl)字符串变时间

sleep,perf_counter程序计时

①time.sleep(s) 产生时间,休眠

②time.per_counter,测量时间起止，特别精准，计数值起点不定，要用差值

3.random库,梅森旋转算法

基本随机函数：

**random,seed()种子可以不给，用来复现，**初始化给定的随机数种子默认为当前系统时间

**random.random()**生成一个[0.0,1.0)

之间的随机小数

扩展随机函数：

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

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

**getrandbits(k)**生成一个k比特长的随机整数

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

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

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

4.jieba库，中文分词第三方库

三种模式:

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

jieba.lcut(s) 精确模式

jieba.lcut(s,cut_all=True)全模式

jieba.lcut_for_search(s)搜索引擎模式

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

5.os库

功能-提供通用的，基本的操作系统交互功能

包括

路径操作：os.path子库，处理文件路径及信息

import os.path as op

函数

abspath（）返回绝对路径
normpath()归一化path,统一用\分隔路径
relpath()返回当前程序与文件之间的相对路径
dirname()返回path中的目录名称
basename（）返回path最后的文件名
join(path,*path)os.path.join()用于将路径名和文件名组合成一个完整的路径
exists()判断对应文件或者目录是否存在，返回True或者False
isfile()判断path对应是否为已存在的文件
isdir()判断path对应是否是已存在的目录
getatime()上次访问时间
getmtime()上次修改时间
getctime()上次创建时间
getsize()返回对应文件大小，以字节为单位

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-vkVYYXC8-1677032755803)(Mooc Python基础语法.assets/image-20221121185141672.png)]

进程管理：启动系统中其他程序

system(程序path 参数)

环境参数:获得系统软硬件信息等环境参数

chidr（）修改当前成都操作的路径

getcwd()返回程序的当前路径

getlogin()获得当前系统登录用户名称

spu_count()获得当前系统的CPU数量

urandom(n)获得n个字节长度的随机字符串，通常用于解密运算

walk()，遍历top参数指定路径下的所有子目录，并将结果返回一个三元组（路径，［包含目录］，［包含文件］）

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-dTlual9f-1677032755804)(Mooc Python基础语法.assets/image-20221121184313189.png)]

6.pickle模块

它几乎可以把所有Python的对象都转化为二进制的形式存放，这个过程称为pickling，那么从二进制形式转换回对象的过程称为unpickling

文件类型：.pkl

保存：dump

打开：load

import pickle
mylist=[123,1234]
picklefile=open('C:\\picklefile.pkl','wb')
pickle.dump(mylist,pickle) #存进去
picklefile.close

import pickle
picklefile=open('C:\\picklefile.pkl','wb')
mylist=pickle.load(picklefile)#读进来
print(mylist)

7.EasyGui:图形用户界面

运行：python 名称.py

.msgbox（消息[,标题]）
关键字参数choices = ['愿意', '不愿意', '有钱的时候就愿意']

按钮

.msgbox(消息，标题，ok_button=" ")
.ccbox()
ynbox()
==buttonbox(中间消息，image=“文件名”，choices=())==当用户单击任意一个按钮的时候，buttonbox()函数返回按钮的文本内容。如果用户取消或者关闭窗口，那么会返回默认选项（第一个选项）
indexbox() 当用户选择第一个按钮的时候返回索引值0，选择第二个按钮的时候返回索引值1
boolbox() 如果第一个按钮被选中则返回True，否则返回False

提供选项