Python入门笔记

Miniconda安装及使用

Miniconda下载：https://mirrors.tuna.tsinghua.edu.cn/anaconda/miniconda/Miniconda3-latest-Windows-x86_64.exe

安装：务必勾选“Add Miniconda3 to my PATH environment variable”

         （不配置环境变量，是无法再cmd命令行界面使用conda命令的）

创建环境

conda create -n env_name python=3.10

（'env_name'是自定义的‘python=3.10’环境的名字）

进入环境

conda activate env_name

退出环境

conda deactivate

VSCode安装

VSCode下载：https://code.visualstudio.com/Download

在上述官网选择对应的安装包下载（Windows x64）

安装成功后，左侧“extensions”搜索Chinese语言包并安装，按照提示重启VSCode

在左侧“扩展”搜索python，安装python扩展

Jupyter Notebook安装及使用

【pip安装源默认是官网，可网上找国内pip镜像安装】

安装（打开Anaconda prompt或者cmd）

pip install jupyter

cmd（终端）打开方式：Windows+R

（在激活的某个虚拟环境中安装）

打开（可直接在VS code的终端打开）

jupyter notebook

Python基础

参考：

聪明办法学Python：

 https://datawhalechina.github.io/learn-python-the-smart-way-v2/​​​​​​

菜鸟教程：

 https://www.runoob.com/python3/python3-basic-syntax.html

day1 变量和数据类型：

#变量

驼峰命名法+下划线命名法

#数据类型

#键值对 键：值

#字典的值 是键

函数：

1. print（）可输入任何数据、表达式、一些符号

2. id（变量）——获取数据存储的地址

3. type（）——获取数据的类型

4. 一般用‘’‘表示多行注释

   #只能表示单行注释

   ’/“表示字符串类型（只能输出单行字符串）

5. Ctrl+/——#注释

6. Ctrl+alt+l——快速格式化代码

#类型转换

数值（int，float，bool） 容器（字符串，列表，集合，字典，元组） ————不能相互转化

#特殊情况：

字符串（只含数字的）—— 可转化为int(无小数点的）/flout（有小数点的）

所有数据类型都可转化为布尔类型 —— 非0即真（数值） 非空即真（容器）

day2 输入输出和运算符

#交互函数

print（） 输出

input（） 输入

input（‘请输入信息：’） ————接收用户的输入（键盘的输入）————返回的结果为用户输入的内容（返回的是字符串类型）————可将其赋值给一个变量，将数据保存下来

【eval()——类型转换（传入的是字符串类型，将字符串类型转化为其他类型）的函数 把引号去掉之后，数据是什么类型，就转换成什么类型】

#sep = ' 输入希望的间隔符 ' 控制 同一个print函数中不同的输出对象之间的间隔符（默认情况为空格）

#end = ‘输入希望的分隔符’ 控制 print函数跟下一个print函数之间的分隔符号

#格式化输出的方式

1. ‘ %d / %s / %f ’ + %（对应的变量） （占位符）

   %d 只能填充数值类型——若为浮点数，则强制取整——输出的是整数类型

   %s 万能的（输出的是字符串类型）

   %f 只能填充数值类型——若为整数，则默认保留六位小数——输出的是浮点数类型

   %e 科学计数法

2. ‘{}’ + .format（对应的变量）

3. f + ‘{直接填需要的变量}’

   注： '{a:.3f}'——代表a以小数点后三位输出

#算数运算符（可直接写在print里）

= - * /(有小数的) //(只取整) % **（乘方）

注：当运算中有小数时，结果都以浮点数展现

#赋值运算符&复合赋值运算（不能直接写在print里）

同c语言类似

#比较运算（可直接写在print里）

——返回的是布尔值

#逻辑运算

and（同时） or（或者） not（取反）——同c语言类似

#运算符优先级

算术运算符>比较运算符>逻辑运算符（not>and>or）

day3 条件判断

#执行流程

顺序流程 分支流程（选择性执行） 循环流程（重复执行）

#分支流程——if 判断

if 语句：

【根据表达式判断，若成立，则执行if后面带缩进的代码块，否则不执行】

表达式——单个数值 或 复杂的运算符 ‘hello’ 4>9 4 and 5

冒号——表示代码块的开始

缩进—— 四个空格 / tab键 区分代码块

if -else语句：

【根据表达式判断，若成立，则执行if后面带缩进的代码块，否则执行else后面带缩进的代码块】

if 表达式：

成立时执行的代码块

else：

不成立时执行的代码块

if-elif-elif...-else语句：

if 表达式1：

1成立时执行的代码块

elif 表达式2：

2成立时执行的代码块

elif 表达式3：

3成立时执行的代码块

......

else：

不成立时执行的代码块

#分支流程——嵌套判断（同时需要判断多个条件）

——if语句中嵌套if语句

#三目运算

格式：

为真时的结果 if 判断条件 else 为假时的结果

day4 while循环

#循环流程——while循环

格式：

while 循环条件：

执行语句

循环条件——决定重复次数（条件的逻辑值为真时一直执行）

#调试——debug

1. 在行数后面打上断点

2. 在代码编辑区域 右击 选择 debug

3. 在调试窗口 点击下一步

#导入模块——import decimal

格式：

import decimal

print（decimal.Decimal('0.1')+decimal.Decimal('0.2'))

——可以得到精准的0.3

#循环控制语句

break——结束整个循环（跳出循环）

continue——结束当前循环（跳出循环这一轮剩下的语句 进入下一轮）

#循环嵌套

#print（）——默认换行

day5 for循环

#循环流程——for循环

可遍历任意序列的项目，是一种“轮询机制”

for-in遍历的对象必须是可迭代对象【可迭代对象就是能被for循环遍历的对象】

构成：

for 临时变量 in 容器对象 冒号

格式：

for 临时变量 in 容器：

循环体

循环次数：

由容器内的元素个数决定

#range（）函数

生成一个连续的数字序列

例：range（10）——生成0-10不包含10的一个序列

range（10,20）——起始值+结束值(不包含)——生成10-20不包含20的一个序列

range（10,50,2）——起始值 结束值 步长(每两个数的间隔，差几)

注：返回的不是一个直接的序列，需将其转化为容器，输出才能直观看到其元素

但其可以被遍历，是一个可迭代的对象

需多次使用时，可将其赋给一个变量

#for循环中的控制语句

break continue

#循环嵌套

#转义字符（字符串中会出现）

\n \r \t \b

\r:把光标移动到最前面（同时删除\r前面的内容）

\n:把光标移动到下一行

\t:相当于tab键

\b:相当于backspace键（退一键）

取消转义的方式：

1. \ + 转义字符——输出的就是\n,\b,\r,\t本身

2. 在整体前面加个r

#导入模块——import random

格式：

import random

number = random.randint(1,100)

print(number)

[此处的number即为1-100的随机数]

day6 字符串操作

#下标（索引）

通过编号（下标 索引）去快速找到对应的元素

方法：使用【】

1. 从前往后 开始编号 默认从0开始

2. 从后往前 开始编号 默认从-1开始

#切片

获取 连续的多个元素

方法：

1.使用【起始下标：结束下标】

—— 冒号表示范围 结束下标不包含自己

2.使用【起始下标：结束下标：步长】

—— 步长控制相邻两个数间的间隔，也可控制方向

当步长为正数时，从左往右开始切

当步长为负数时，从右往左开始切

注：

【：】——只存在一个冒号时，冒号左边表示起始值，右边表示结束值

【：：】存在两个冒号时，第一个冒号左边是起始值，两冒号间是结束值，第二个冒号右边是步长

#常用操作方法

可变类型（列表，集合，字典）

不可变类型（数值，字符串，元组）

一.修改：

1. replace(替换)

   格式：

   变量(或直接写数据).replace('旧元素','新元素',修改的次数)

2. split(切割)

   例：

   'helo wor dofs ofs'.split(' ') —— 用空格作切割符

   输出结果为['helo','wor','dofs','ofs']

   'helo wor dofs ofs'.split('o') —— 用o作切割符

输出结果为['hel',' w','r d','fs ','fs']

1. strip(去除)

   ——去除字符串前后（两端）指定的符号

   lstrip(去除左端的)

   rstrip(去除右边的)

   例：

   'helloworld'.strip('hled')

   输出结果为owor

2. join(拼接)

   格式：

   '拼接符'.join(字符串类型)【列表，元组等可迭代对象都可以，其内的元素必须是字符串类型】

   ——每两个元素之间用指定的符号拼接

二.查询：

1. find/index(查询下标)【默认从左边开始找】

   rfind【默认从右边开始找】

区别：

find——若查询的元素不在字符串中，则返回-1

index——若查询的元素不在字符串中，则报错

2. count(查询某个元素出现的次数)

三.转换：

1. upper(小写字母变成大写)

2. lower(大写字母变成小写)

3. capitalize(首字母大写)

4. title(每个单词(用空格隔开的)首字母大写)

四.判断：（返回true/false）

1. endswith(判断是否以什么结尾)

2. startswith(判断是否以什么开头)

3. isdigit(判断是否全是数字)

4. isalpha(判断是否全是字母)

5. islower(判断是否全是小写字母)

6. isalnum(判断是否只存在数字和字母)

day7 列表&元组&集合的常用操作

#列表【可变】

#添加

1. append（末尾添加一个新元素）【元素类型不限】

格式：

变量(数据).append(新元素)

1. extend（末尾添加一个序列【容器】中的每一个元素）

2. insert（在指定地方添加一个元素）

格式：

变量(数据).insert(下标【尽量写在列表长度以内的】，新元素)

#修改（重新赋值）

索引找到并赋值

#删除

1. pop（删除指定下标的元素）

2. remove（删除指定的元素）

3. clear（删除所有元素）——不需给定参数

4. del（Python的内置回收方法）

#查看

1. index（根据元素查看对应下标）

2. len【公用方法】（查看容器中有多少个元素）

格式：

len(容器名)

1. count（统计指定数据在容器中出现的次数）

2. in与not in（判断某数据是否在或不在容器中）

#排序

1. sort

例：

变量名.sort(reverse=True)——【逆置】

1. reverse【公用方法】（逆置）

   注：返回的是对象，需转换类型看具体的内部元素

#元组【不可变，不支持修改】

#查询：

1. len

2. 下标，切片

3. index

4. count

#集合【可变，但不可修改，查看也无意义——所有元素都是无序的】

注：集合里只能存不可变的数据类型

元组和列表能存任何类型

#添加：

1. add（只能添加一个数据）

2. update（添加一个序列中的每一个元素）

#删除：

1. pop（随机删除）

2. remove（删除指定元素）【会报错】

3. discard（删除指定元素）【不会报错】

4. clear（清空）

5. del

注：空容器：

【】——空列表 （）——空元组

set（）——空集合 {}——空字典

#序列的循环遍历

day8 字典&序列操作

#字典

字典在内存中只存key，在判断成员运算符时判断的是key

key（键）——不允许重复，只能是不可变类型

value（值）

#索引

字典中没有下标，根据key索引

#增加

修改和新增的区别在于key是否已经存在：

key存在时——修改

key不存在时——新增

1. update

   格式：

   1. 名称.update({key:value})

   2. 名称.update(key=value)——等号赋值的方法

2. 根据索引修改或增加（名称[key]=某个值）

#删除

1. pop（按照指定的key删除对应元素）

   名称.pop(key)

2. popitem（不需给参数，默认删除最后一个键值对）

3. clear del（清除）

#查询

1. len（共多少元素）

2. 通过key找到值——查某个具体的值（key不存在时会报错）

3. get——查某个具体的值（key不存在时不会报错）

4. values——查询所有的value

5. keys——查询所有的key

6. items——查询所有的键值对（输出后每一项都是元组类型）

#序列操作

1.运算符

运算符 描述 支持的容器类型

+ —— 拼接（合并）—— 字符串，列表，元组

& —— 交集 —— 集合

* —— 复制 —— 字符串，列表，元组

in —— 是否存在 —— 所有

not in—— 是否不存在 —— 所有

day9 函数入门

print() input() id() type() len() max() min() sum() ......——内置函数

#自定义函数

调用才会执行

#定义函数

1. 组成：

def——函数的关键字 函数名（一般用小写）

（）——定义参数 冒号 函数体

1. 格式：

def 函数名(形参):

代码块

注：形参无实际值，调用函数时，实参会给形参传值

()中形参的顺序：必备 默认 不定长

形参：必备参数 （必须接收到值）

默认参数（在定义时给个初始值）——调用函数时，可以传参，也可以不传，当传参时，用实际接收到的参数，不传时， 用给的那个初始值

不定长参数 （*参数(常用args)/**参数(常用kwargs)）——接收的参数个数 不固定（有就接收，没有就不接收）

【*：接收位置参数，保存为一个元组（args输出的是元组）

**：接收关键字参数，保存为一个字典】

注：*和**仅是标志

#调用函数

格式：

函数名(实参)

注：()中实参的顺序：位置 关键字

实参： 位置参数 （以单纯的值的形式传参）

关键字参数（赋值的形式传参）——实参全为关键字参数时，若形参有必备参数或默认参数，关键字参数等号左侧的名字会与形参名称有对应关系；实参不全为关键字参数，则没有这样的关系

## *列表（/元组等）——元素，元素，....——当做位置参数

**字典——k=v，k=v，....——当做关键字参数

#函数的返回值

——通过return返回（将函数执行的结果返回到调用函数处，函数终止）

格式：return 结果(或表达式)

注:只写return时，默认返回none

day10 函数进阶

#变量的作用域

全局变量——定义在函数外部，定义后都可以使用

局部变量——定义在函数内部，只能在函数内部使用

*定义在函数内部的，可以声明成全局变量

格式：global 变量名

#高阶函数

1. 如果一个函数的参数是另一个函数，则为高阶函数

2. 如果一个函数的返回值是另一个函数，则是高阶函数（若返回值是该函数本身，成为递归）

#内置的高阶函数

1. map()

接收一个函数和一个可迭代对象作为参数，将函数用于可迭代对象的每一个元素，返回的是迭代器，可通过转换类型查看

例：

接收两个参数，第一个为函数地址，第二个为序列

1. filter()

接收一个函数和一个可迭代对象作为参数，将函数用用于可迭代对象的每一个元素，转换后返回的是一个序列，序列中的元素是函数用于每个元素后为true的元素

1. sorted()

返回一个排序后的列表

若只接收一个序列做参数，则为普通函数

#递归

1. 函数内部调用自身

2. 递归出口

3. 递归体

##lambda表达式

格式：

lambda 参数列表：返回值 （参数可以有多个，返回值只能有一个）

直接调用的格式：

print((lambda 形参:返回值)(实际参数))——【参数间以逗号隔开】

day11 文件操作

绝对路径：从根磁盘开始

相对路径：./当前路径 ../上级路径

#打开

open('文件路径'，mode='打开模式'，encoding='编码')【编码一般是utf-8】

打开模式：(常用：r，w，a)

##移动光标：

.seck()

例：.seck(0)——移动光标到最开始的位置

#读取

变量.read()——读取到的是字符串

.readlines()——读取到的是列表

#写入

变量.write()——写入字符串类型

.writelines()——写入列表类型

#关闭

.close()

#文件备份

##备份：两个文件

根据源文件 创建新文件

##上下文管理器：with【结束后自动关闭，不需close】

单文件备份操作：

with open(源文件)as 名称(取个别名):

变量1 = 别名.read()

变量2= open(新文件)

变量2.write(变量1)

批量文件及文件夹操作：

import os

os.mkdir('新的文件夹名称')——创建文件夹

os.rmdir('新的文件夹名称')——只能删除空文件夹

os.rename('文件夹(或文件)名称'，'新名称')——重命名

os.remove('文件名')——只能删除文件

os.getcwd()——获取当前路径（目录）

os.listdir(指定的目录)——获取目录下的所有文件及文件夹

批量备份操作：

import os

old_dir(变量名) = '路径(目录)'

new_dir='新文件夹名称'

if not os.path.exists(new_dir):【判断文件夹是否存在】

os.mkdir(new_dir)

for file in os.listdir(old_dir):

if file.endswith('.py'):

with open(file...)/(若old_dir不是当前目录)with open(old_dir+'\\'+file,'r',encoding='utf-8')as f:

data = f.read()

with open(new_dir+'\\'+file,'w',encoding='utf-8')as f:

f.write(data)

print(f'{file}备份成功-----‘)

else:

print(f'{file}不是Python文件，不进行备份')

day12 模块

#模块

是一个包含所有你定义的函数和变量的文件，扩展名为.py。可被其他程序引入，以使用该模块中的函数等功能。（是使用Python标准库的方法）【所有的.py文件都可以是一个模块】

##___name___ ——是个属性

当在本程序中执行时，其结果为___main___

当在其他程序中被导入时，结果为其所在的程序的文件名

if __name__ == '__main__':

pass(无东西时用此带过) ————是否在当前文件(程序)中执行

##导入模块的方式：

• import + 模块名（文件名，不含.py） ——导入模块

• from + 模块名 + import + 模块中的某个类【导入具体的功能】/*【模块的所有功能】 ——不常用

• import + 模块名 + as 别名 ——导入模块并取别名

#包

包含所有.py文件的一个文件夹

若是要导入包里的所有模块(*)，则在包里定义一个__ init __ 模块，在模块中写入变量 __ all __ ,并给出可以导入的范围——即列出可导入的模块(列表类型的)

• from + 包名【综合】（不能以数字开头）+ import + 综合里的某个模块/*（ *代表导入综合里的所有模块） ——导入包中的模块

• import 综合.模块