#Python基础语法
Python学习
第一天
注释
单行注释： # 单行注释（#后面空一格） 快捷键：ctrl+/
多行注释： 两种写法
第一种：””” 注释内容”””（6个双引号）
第二种：’’’ 注释内容’’’ （6个单引号）
变量：重点
变量的作用：变量就是存储数据的时候当前数据所在的内存地址的名字而已
定义变量：
语法：变量名=值
变量名自定义，要满足标识符命名规则
标识符命名规则： 是python中定义各种名字的时候的统一规范
- 由数字、字母、下划线组成
- 不能数字开头
- 不能使用内置关键字
- 严格区分大小写
命名习惯：
- 见名知义
- 大驼峰：每个单词首字母都大写，例如：MyName 大小驼峰辨别：第一个字母是否大写
- 小驼峰：第二个（含）以后的单词首字母大写，例如：myName
- 下划线：例如：my_name
使用变量：
认识bug：
所谓bug，就是程序中的错误，如果程序有错误，需要程序员排查问题，纠正错误
debug工具
是Python中用来调试程序的工具，可以用来调解bug
使用步骤：
打断点
Debug调试
打断点：单击目标代码块行号右侧空白位置
认识数据类型：
list对应c++里面的数组
[ ] list 列表
（）tuple 元组
{ } set 集合
{‘name’:’TOM,’age’:18} 类似于c++中的结构体 类似于js中的对象 字典：键值对
检测数据类型：type（数据）
Bool类型通常判断使用，布尔类型有两个取值，分别是True 和 False
变量章节总结：元组存储的数据不能修改，字典存取的数据类型是键值对
输出
作用：程序输出内容给用户
格式化输出：
说明：有符号的整数包含负整数和正整数
有符号指的是在数字前面可以添加一个表示正负的符号
无符号指的是在数字前面不能添加正负号，所以这个数字是正数
特殊：%f 如果没有特殊说明，系统默认保留小数点后6位，%.mf 则可以保留小数点后m位
格式化符号高级使用方法
第二种方法可以在数字前面补上0，来对齐 语法：%0md : 在数字前面补上(m-1)个0
！重点：当有多个内容需要格式化时，% name 等用括号括起来写在最后面
更高级的用法：因为输入提示文字后就表示含有字符串，所以可以全部写为 %S %s强大
f-格式化： f格式化常用
语法： f ‘ {表达式} ’
转义字符；
\n:换行
\t:制表符，一个tab键（4个空格）的距离
结束符：
语法：print(‘输出的内容’，end=”\n”)
第二天
输入
语法：input(“提示信息”)
在python中，一般会把接收到的用户输入的数据当作字符串处理
输入特点：
- 遇到input，等待用户输入
- 接收input存变量
- Input接收到的数据类型是字符串
转换数据类型
例如：转换为int，强制转换
list是将元组（）转换为列表【 】 tuple是将列表【 】 转换为元组（）
eval转化为字符串里面原有的数据类型 例如：str = ‘1.1’字符串里面的数据是1.1，类型为浮点型，所以eval就将str转化为浮点型 eval简单理解为去掉字符串 可以转化int,float,str,tuple,list,set，但是eval不能转化str = ‘a’ ，eval(str)，里面已经是字符串就不能再转化，因为’a’是字符串，a也是字符串，所有不能转化
Python交互式开发：
Python console 极简单的程序可以使用，也没有什么特别的地方，就是不用输print,其他都一样
运算符的分类
·算数运算符
·赋值运算符
·复合赋值运算符
·比较运算符
·逻辑运算符
算数运算符
整除得到的数是商，取余得到的是余数
赋值运算符
多个变量赋值：多个变量，只有一个=
复合赋值运算符
复合运算符= 算数运算符+赋值运算符
重点！！注意： c += 1 +2 先算复合赋值运算符右面的表达式，再算复合赋值运算 右边看作一个整体
比较运算符
逻辑运算符
逻辑运算符书写习惯
一个整体最好加上小括号 规范书写，避免歧义
拓展：and运算符，只要有一个值为0，则结果为0，否则结果为最后一个非0数字
Or运算符，只有所有值为0结果才为0，否则结果为第一个非0数字
第三天
if语句
If语法：
If 条件:
条件成立执行的代码1
条件成立执行的代码2 ......
注意：在if下方没有缩进的代码，不属于if语句块，与条件成立与否无关，换言之，如果没有缩进，即使在if后面，会执行，跟条件无关
注意：input接收到的数字是字符串类型，如果要比较大小，需要转换成整形
If...else
作用：条件成立执行if下方的代码，条件不成立，执行if...else下方的代码
语法：
If 条件:
条件成立执行的代码1
条件成立执行的代码2 ......
else :
条件不成立执行的代码1
条件不成立执行的代码2 ......
if多重判断 当有多种情况需要判断的时候，就可以使用
If 条件1:
条件成立执行的代码1
条件成立执行的代码2 ......
elif 条件2:
条件成立执行的代码1
条件成立执行的代码2 ......
elif ......
else :
条件不成立执行的代码1
条件不成立执行的代码2 ......
多重判断也可以和else配合使用，一般else放到整个if语句的最后，表示以上条件都不成立的时候执行的代码
下面的简化也重要！！类似于数学
If嵌套
两个if分开看和单独写时没有区别 后面的if空格写
随机数：
- 导入random模块
Import 模块名
- 使用random模块中的随机整数功能
random.randint(开始数字，结束数字)
生成随机数：两个边界都能取到
调用模块（import）放在整个程序最前面
三目运算符（也叫三元运算符）
作用：化简if...else简单的代码
语法：条件成立执行的表达式 if 条件 else 条件不成立执行的表达式
第四天
循环
循环的作用：让代码更高效的重复进行
循环的分类
while循环 和 for循环，最终实现效果相同
while语法
while 条件： 【跟if一样】
条件成立重复执行的代码1
条件成立重复执行的代码2
循环的计数器：计数器的初始值为0 （ i = 0 ）
案例：1-100整数相加 1-100偶数相加(方法一：余数为0，法二：计数器，增量为2【奇数也行】) 方法一会更好一些
循环的注意事项：
只要有计数器，就一定要写增量，否则程序会死循环卡死
break: 退出整个循环
continue：退出当前一次循环而执行下一次循环
重点中的重点：如果使用了continue，在continue之前一定要修改计数器，否则会进入死循环
while循环嵌套
案例：while循环嵌套之打印✳（正方形）
打印星号（三角形）： 一行输出星星的个数和行号是相等的 （i <=j)
99乘法表
for循环 （有点类似于遍历）
语法：for 临时变量 in 序列:
重复执行的代码1
重复执行的代码2
序列：数据序列即一个数据内部有多个数据组成 序列：元组，列表，集合，字典等
break退出for循环
continue退出for循环
else 【无论是if还是循环都可以配合else使用】
循环可以和else配合使用，else下方缩进的代码指的是当循环正常结束之后要执行的代码
while...else
语法：
while...else之退出break
案例：给女朋友道歉5遍，第3遍不真诚，女朋友生气了，不原谅，让不再道歉了
需要记住：
while...else之退出continue:
for...else
语法：
for 临时变量 in 序列：
重复执行的代码
.........
else:
循环正常结束之后要执行的代码
for...else退出循环：
只要遇到break，中断程序，else下方的代码不执行，但是continue会，因为continue是正常结束
第五天
字符串
三引号字符串：跟注释一样，’’’ ‘’’ 作用：支持回车换行
字符串输出：%s 格式化 f-格式化
字符串输入：使用input（）接收用户输入
下标
“下标”又叫“索引”，就是编号
下标的作用就是通过下标快速找到对应的数据
比如：str[下标] ，跟js，c++一样，下标访问
切片：
切片是指对操作的对象截取其中一部分的操作。字符串、列表、元组都支持切片操作
语法：
序列[开始位置下标:结束位置下标:步长] 切片是【】，里面是： 而range是（），里面是，不管是切片，还是range（），取值都是【开始 结束），只有random是【开始，结束】
注意：
- 不包含结束位置下标对应的数据，正负整数均可； 【开始:结束）
- 步长是选取间隔，正负整数均可，默认步长为1.
案例：str=‘abcdef’ 输出abc
如果不写开始下标，默认从0开始，但是:要写
如果不写结束，默认取到最后，但是：要写
如果不写步长，默认为1
如果开始，结束，步长都没写，则全选，但是：要写
如果步长为负数，倒序
如果开始位置为负数，表示从序列最后面倒着数，-1代表最后一个（因为没有-0,被0占用了） 比如-4，表示从最后往前数4位
如果选取方向（下标开始到结束的方向）和步长的方向冲突，则无法选取数据
字符串常用操作方法
！！！【通用方法】记住函数的名字，记住函数的作用，记住函数参数传递的方式（函数参数的写法）
字符串的常用操作方法：查找、修改、判断
查找
字符串查找方法就是查找子串在字符串中的位置或出现的次数
find( ) : 检测某个字串是否包含在这个字符串中，如果在则返回这个子串开始的位置下标，否则返回-1
Index( ):检测某个字符串是否包含在这个字符串中，如果在返回这个子串开始的位置下标，否则报异常
count( ): 检测子串在母串中出现的次数
rfind( ): 和find功能相同，但查找方向为右侧开始【rightfind】
rindex( ):和index功能相同，但查找方向为右侧开始
语法：
find(子串，开始位置下标，结束位置下标)
注意：开始和结束位置下标可以省略，表示在整个字符串序列中查找
注意：空格也要算1个位置
字符串常用修改方法之修改（常用）
replace( )：替换
语法： 字符串序列.replace(旧子串，新子串，替换次数)
注意：如果替换次数没写，则全部替换，即有多少个旧子串就替换多少个新子串
replace函数有返回值，返回值是修改后的字符串
即原字符串调用了replace函数后，发现原有字符串的数据并没有做到修改，修改后的数据是replace函数的返回值 说明字符串是不可变数据类型
补充：根据数据是否可以改变划分为： 可变数据类型 和 不可变数据类型
如果替换次数超出子串出现的次数，表示替换所有子串（比如旧串中’and’出现2次，但替换次数写的10，则将旧串中’and’全部替换为新串‘but’
Split( ) 分割 返回一个列表
语法：
字符串序列.split(分割字符,num)
注意：num表示的是分割字符出现的次数，即将来返回列表，数据个数为num+1个
特点：会丢失分割字符，例如用and分割，分割完后就没有and
join( ) 合并列表里面的字符串数据为一个大字符串
语法：
字符或子串.join(多字符串组成的序列) 这里的“字符或字符串”就是连接符号
字符串常用操作方法之修改大小写转换
capitalize( )：将字符串第一个字符转换成大写
注意：capitalize( )函数转换后，只有字符串第一个字符大写，其他的字符全部小写（包括已经大写的都会被转换成小写）
title( ):将字符串每个单词首字母转换成大写
lower( ) : 将字符串中大写转小写
upper( ) :将字符串中小写转大写
字符串常用操作方法之修改之删除空白字符
lstrip( ):删除字符串左侧空白字符
rstrip( ):删除字符串右侧空白字符
strip( ):删除字符串两侧空白字符
字符串常用操作方法之修改之字符串对齐
ljust( ): 返回一个原字符串左对齐，并使用指定字符（默认空格）填充至对应长度的新字符
语法：
字符串序列.ljust(长度，填充字符)
rjust( ): 右对齐
center( ) :居中
字符串常用操作方法之修改之判断开头或结尾
startswith( ):检查字符串是否是以指定子串开头，是则返回True，否则返回False，如果设置开始和结束位置下标，则在指定范围内检查
语法：
字符串序列.startswith(子串，开始位置下标，结束位置下标) 第二第三个参数可以省略
endswith( ): 检查字符串是否是以指定子串结尾
字符串常用操作方法之判断
isalpha( ):如果是一个非空字符串并且所有字符串都是字母(空格就不算字母）则返回True，否则返回False
isdigit( ):如果字符串只包含数字则返回True否则返回False
isanum( ):如果字符串至少有一个字符并且所有字符都是字母或数字【数字字母的组合】则返回True，否则返回False
isspace( ):如果字符串全部由空格组成，则返回True，否则返回False
第六天
列表
应用场景：变量一次性只能存取一个数据，如果一次性要存取多个数据，就使用列表
列表的格式：
[数据1，数据2，数据3....]
列表可以一次性存取多个数据，且可以为不同数据类型【但是在工作中尽量保证一个列表存储相同的数据类型】
查找
- 通过下标查找
序列名[下标]
- 通过函数查找
Index( ): 返回指定数据所在位置的下标
语法：
列表序列.index(数据,开始位置下标，结束位置的下标)
注意：如果查找的数据不存在则报错
count( ) : 统计指定数据在当前列表中出现的次数
len( ): 访问列表长度，即列表中数据的个数【公共方法，字典，元组，字符串等也可以使用】
语法：
len(序列名)
判断是否存在
in:判断指定数据在某个列表序列，如果在返回True，否则返回False【公共方法】
not in:判断指定数据不在某个列表序列，如果不在返回True，否则返回False
作用：注册邮箱，如果在原有列表中，不注册（账号一般不重复）
案例：检查账号名是否重复
列表增加数据之append
作用：增加指定数据到列表中
append( ) : 列表结尾追加数据
语法
列表序列.append(数据)
1.列表是可变数据类型，不需要变量去接收【详见截图第二行】
2.append函数追加数据的时候，如果数据是一个列表，追加整个序列到列表的结尾
extend
列表结尾追加数据，如果数据是一个序列，则将整个序列的数据拆开逐一添加到列表
语法：
列表序列.expend(数据)
insert
insert( )：指定位置新增数据
语法:
列表序列.insert(位置下标，数据)
列表删除数据
del 目标
del 可以删除指定下标的数据，用下标
pop ( ) 删除指定下标的数据，如果不指定下标，默认删除最后一个数据，无论是按照下标还是删除最后一个，pop函数都会返回这个被删除的数据
语法：
序列名称.pop(下标)
remove( )
语法：
序列名称.remove(数据)
注意：remove里面填的是数据，并非下标
clear( ) 清空列表
语法：
序列.clear( )
列表修改数据
修改指定下标数据 ：通过下标找到，重新赋值
逆序：reverse( )
排序：sort( )
语法：列表序列.sort(key = None，reverse=False)
注意：reverse表示排序规则，reverse=True降序，reverse=False升序（默认）
所以只需要记住reverse=True降序即可，因为升序默认
key暂时不讲
复制
函数：copy( ) 不需要写任何参数
在工作中，涉及到修改、删除数据的时候，一般都会复制一份，保留原始数据的基础上再做修改和删除
语法：
列表序列.copy( )
列表的循环遍历
作用：依次打印列表中各个数据
用while可以实现 案例：遍历列表的元素
用for也可以实现 for循环不用下标 多敲敲
列表嵌套
应用场景：要存储班级一、二、三 三个班级学生姓名，且每个班级的学生姓名在一个列表
写法:[[列表1]，[列表2]]
列表嵌套查找元素：列表名[ ][ ] 有点类似于二维数组
案例： 随机分配办公室
需求：有3个办公室，8位老师随机分配到3个办公室
元组
应用场景：存储多个数据，但是这些数据是不能修改的
换句话说：一个元组可以存储多个数据，元组内的数据是不能修改的
例如：存取身份证号
定义元组
注意：如果定义的元组只有一个数据，最好加上“，”，否则整个元组的数据类型就是由该唯一的数据说了算
元组的常见操作之查找 元组只支持查找
按下标查找数据
Index( ): 查找数据
count( ):
len( ) :
元组数据的修改
如果元组里面有列表，修改列表里面的数据则是支持的
工作中，尽可能不要修改
第七天
字典
应用场景： 用key查找value 快速查找
字典数据和数据顺序没有关系，即字典不支持下标。
字典里面的数据是以键值对形式出现
创建字典
字典特点：
- 符号为大括号
- 数据为键值对形式出现
- 各个键值对之间用逗号隔开
字典常见操作
增
写法：字典序列[key] = 值
注意：如果key存在则修改这个key对应的值；如果key不存在则新增此键值对
注意：字典为可变类型
删
del 删除字典或删除字典中指定键值对
clear( ) 清空字典
改
写法：字典序列[key] = 值
查 （有2种写法:key值和函数，函数又有4种写法）
按key值查找
如果查找的key存在，则返回对应的值；否则报错
按函数查找
get（）写法
语法：
字典序列.get(key，默认值)
注意：如果查找的key不存在则返回第二个参数（默认值），如果省略第二个参数，则返回None
keys( ) 查找 查找字典中所有的key值，返回可迭代对象（可以用for循环遍历的对象）
语法：
字典序列.keys( )
values( )查找
跟keys一样
items( )查找 返回可迭代对象
语法：
字典序列.items( )
查找字典中所有的键值对，里面的数据是元组，元组数据1是key，元组数据2是value
字典的循环（4种情况）
遍历字典的key
遍历字典的value
遍历字典的元素 （元素指键值对）所以用items
遍历字典的键值对（拆包）
Items查找到的元组有keys和values，把元组分离，分别得到key，value两个临时变量，即拆包
集合
特点：去重，元素不允许重复的数据出现
创建集合
创建集合使用{ } 或set(),但是如果要创建空集合只能使用set( )，因为{ }用来创建空字典
集合没有顺序，不支持下标访问
增
add( )
语法：
序列.add( )
注意：因为集合有去重功能，所以，当向集合内追加的数据是当前集合已有数据的话，则不进行任何操作
特点：
- 集合是可变数据类型
- 增加的元素不一定在最后面，因为集合无序
update( ) 追加的数据是数据序列
语法；
序列.update( )
asdd与update区别：add增加一个单一数字，而update增加一个数据序列
删
remove( ) 删除集合中的指定数据，如果数据不存在则报错
语法:
序列.remove(删除的数据 )
discard( ) 删除集合中的指定数据，如果数据不存在也不会报错
语法：
序列.discard(删除的数据 )
pop( ) 随机删除集合中的某个数据，并返回这个数据
语法：
序列.pop( ) 不能指定删除数据，只能随机删除
查
in :判断数据在集合序列
not in :判断数据不在集合序列
第八条
公共操作
运算符 注意：集合也支持in
公共操作之运算符加号
公共操作之运算符乘号
公共操作之运算符判断数据是否存在
公共方法之len
公共方法之del
公共方法之max和min
语法：
max(数据序列)
公共方法之range
注意：range( )生成的序列不包含end的数字
公共方法之enumerate
语法：
enumerate(可遍历对象,start = 0)
注意：start参数用来设置遍历数据的下标的起始值，默认为0
返回结果是元组，元组第一个数据是原迭代对象的数据对应的下标，元组第二个数据是原迭代对象的数据
容器类型转换
tuple( )
list( )
set( )
注意：1.集合可以快速完成列表去重
2.集合不支持下标
推导式 只有列表、字典、集合有推导式
作用：化简代码
列表推导式（用while实现）
案例：创建一个0-10的列表
列表推导式（用for实现）
体验列表推导式
案例：创建一个0-10的列表
注意：读与写都从for循环开始
for左边的i是整个推导式返回的数据
带if的列表推导式
案例：创建0-10偶数列表
方法一：range；步长为2
方法二：if实现
实际上只需要照抄for和if语句，返回值往左填写
多个for循环实现列表推导式
第九天
函数
功能：函数就是将一段具有独立功能的代码块整合到一个整体并命名，在需要的位置调用这个名称即可完成对应的需求。
函数在开发过程中，可以更高效的实现代码重用
函数的使用步骤 （定义和调用）必须是先定义后调用
定义函数
语法：
def 函数名 (参数):
代码1
代码2
..........
调用函数
函数名（参数）
注意：
- 不同的需求，参数可有可无
- 在python中，函数必须先定义后使用
快速体验函数
函数的注意事项
如果没有调用函数，函数里面的代码不会执行
*****函数的执行流程：
当调用函数的时候，解释器回到定义函数的地方去执行下方缩进的代码，当这些代码的执行完之后会回到调用函数的地方继续向下执行
定义函数的时候，函数体内部所进的代码并没有执行
函数的参数作用
实参个数与形参个数要对应起来
体验函数返回值
在函数中如果需要返回结果给用户，需要使用函数返回值
return特点
- 负责函数的返回值
- 退出当前函数：导致return下方所有代码（函数体内的）不执行
函数的说明文档 提示函数作用的解释说明写法
定义函数说明文档：
语法：
def 函数名(参数):
“””说明文档的位置”””
代码
........
查看说明文档
help(函数名)：查看函数的说明文档（函数的解释说明的信息）
函数嵌套调用
指的是一个函数里面又调用了另外一个函数
目的：化简代码
案例：求3个数之和 以及求平均值
第十天
变量作用域
变量作用域指的是变量生效的范围，主要分为：局部变量和全局变量
局部变量
指定义在函数体内部的变量，即只在函数体内部生效
全局变量
指在函数体内、外都能生效的变量
修改全局变量
语法：
global a
a = 200 (修改a)
总结：1.如果在函数里面直接把变量a = 200赋值，此时的a不是全局变量的修改，而是相当于在函数内部声明了一个新的局部变量
- 函数体内部修改全局变量，先gloalal声明a为全局变量，然后再变量重新赋值
- 重点：修改全局变量的值，必须要调用函数之后才会起作用
比如：调用test1之后，全局变量glo_num的值才修改为100
多函数的执行流程
修改全局变量，要调用以后修改过的全局变量才会生效，同上
返回值作为参数传递
函数的返回值（一个函数有多个返回值）
注意：1.return a , b 写法，返回多个数据的时候，默认是元组类型
2.return 后面可以连接列表、元组或字典，以返回多个值
函数的参数 （一共有4种写法）
位置参数
定义：调用函数时根据函数定义的参数位置来传递参数
注意：传递和定义参数的顺序及个数必须一致
关键字参数
缺省参数
不定长参数
习惯：包裹位置传递的形参统一为 *args
包裹关键字传递的形参统一为 **kwargs
拆包
拆包：元组 核心：序列里有多少个元素，就用多少个变量去接收
拆包：字典 核心思想：字典有多少个键值对，就用多少个变量去接收
交换变量值 方法二常用
方法一：引入第三个变量
跟C++一样
t = a
a = b
b = t
方法二： 重新给a，b赋值
引用
结论： 在Python中，值是靠引用（变量名）来传递的
我们可以用id( )来判断两个变量是否为同一个值的引用，我们可以将id理解为那块内存的地址标识
id(a) //检查a的地址
引用当作实参
可变和不可变类型
所谓可变类型与不可变类型是指：数据能够直接进行修改，如果能直接修改那么就是可变；否则是不可变
可变类型
列表
字典
集合
不可变类型
整型
浮点型
字符串型
元组
第十一天
函数加强：学员管理系统
第十二天
递归（在Python基础课程中几乎用不到，但是属于Python语法当中 的知识点）
递归的作用：递归是一种编程思想，函数是编程的体现
应用场景：1.如果要遍历一个文件夹下面所有的文件，通常会使用递归来实现
2.在后续的算法课程中，很多算法都离不开递归，例如：快速排序
递归的特点：
函数内部自己调用自己
必须有出口
递归之回顾函数返回值
返回值返回的位置：函数调用的位置
递归代码实现
案例：3以内数字累加和
递归的执行流程
执行流程多看几遍
递归出口问题
如果没有出口，报错：超出最大递归深度
lambda 表达式 【匿名函数】
应用场景：如果一个函数有一个返回值，并且只有一句代码，可以使用lambda简化
lambda语法：
lambda 参数列表:表达式【其实就是返回值】 （此处的表达式必须有返回值）
注意:
1.lambda表达式的参数可有可无，函数的参数在lambda表达式中完全适用
2.lambda表达式能接收任何数量的参数但只能返回一个表达式的值
体验lambda
注意：直接打印lambda表达式，输出的是此lambda的内存地址
lambda实例之计算两个数字累加和
lambda参数之无参数 lambda参数写法跟函数参数的写法一样
无参数
fn1 = lambda:100
print(fn1（）)
一个参数
fn1 = lambda a:a
print(fn1(‘hello world’))
默认参数 [缺省参数]
fn1 = lambda a,b,c=10:a + b +c
可变参数：*args
fn1 = lambda *args:args
注意：这里的可变参数传入到lambda之后，返回值为元组
可变参数：**kwargs
注意：返回值是字典
lambda的应用（以下2个）
带判断的lambda：
跟三目运算符结合
列表数据按字典key的值排序
Key：按照列表里面字典的某个key排序用的 以上代码中的x代表一个集合
第十二天
高阶函数
定义：把函数作为参数传入，这样的函数称为高阶函数，高阶函数是函数式编程的体现。函数式编程就是指这种高度抽象的编程范式
体验高阶函数
在Python中，abs( )函数可以完成对数字求绝对值计算
round( )函数可以完成对数字四舍五入计算
体验高阶函数写法
内置高阶函数之map
语法：
map(func,list)
将传入的函数变量func作用到list变量的每个元素中，并将结果组成新的列表(python2环境)/迭代器(python3解释器，环境)返回
案例：列表元素的二次方
内置高阶函数之reduce()
语法：
reduce(func,list)，其中func必须有两个参数，每次func计算的结果继续和序列的下一个元素做累积计算
注意：reduce( )传入的参数func必须接收2个参数
要使用reduce，必须要导模块functools
案例：求序列中各个元素之和
内置高阶函数之filter
语法：
filter(func,list) 用于过滤序列，过滤掉不符合条件的元素，返回一个filter对象。如果要转换为列表，可以使用list( )来转换
案例：求列表中的偶数
文件操作
文件操作包含：打开、关闭、读、写、复制...
文件操作的作用是：读取内容、写入内容、备份内容...
总结：文件操作的作用就是把一些内容（数据）存储起来，可以让程序下一次执行的时候直接使用，而不必重新制作一份，省时省力
文件的基本操作
文件操作步骤：
- 打开文件
- 读写等操作
- 关闭文件
注意：可以只打开和关闭文件，不进行任何读写操作
打开
在python中，使用open函数，可以打开一个已经存在的文件，或者创建一个新文件
语法：
open(name,mode)
name:是要打开的目标文件名的字符串（可以包含文件所在的具体路径）
mode:设置打开文件的模式（访问模式）：只读、写入、追加等
访问模式特点
主访问模式特点：r：只读 w：只写 a：追加
r特点：1.如果文件不存在，报错 2.不支持写入操作，表示只读
w特点：1.如果文件不存在，新建文件 2.如果执行写入，会覆盖原有内容
a特点：1.如果文件不存在，新建文件 2.在原有内容基础上，追加新内容
说明：访问模式可以省略，如果省略表示访问模式为r
读
read
文件对象.read(num)
num表示要从文件中读取的数据的长度（单位是字节），如果没有传入num，那么就表示读取文件中所有的数据
readlines
readlines可以按照行的方式把整个文件中的内容进行一次性读取，并且返回的是一个列表，其中每一行的数据为一个元素
Readline
第十三天
了解面向对象（很重要） 【化简代码】
面向对象是一种抽象化的编程思想，很多编程语言中都有的一种思想
总结：面向对象就是将编程当成是一个事物（比如洗衣机），对外界来说，事物是直接使用的，不用去管他内部的情况。而编程就是设置事物能够做什么事。【可以理解为我们就是洗衣机制造商，制造洗衣机，然后使用洗衣机】
类和对象
在面向对象编程过程中，有两个重要组成部分：类和对象
类和对象关系：用类创建对象
类
类是对一系列具有相同特征和行为的事物的统称，是一个抽象的概念，不是真实存在的事物
特征即是属性【变量】
行为即是方法【函数】
对象
对象是类创建出来的真实存在的事物，例如：洗衣机
注意：开发中，先有类，再有对象
创建类
语法：
class 类名( ):
代码
............
注意：类名要满足标识符命名规则，同时遵循大驼峰命名习惯
创建对象
语法：
对象名 = 类名( )
类里面的self
self指的是调用该函数的对象
说明：由于打印对象和打印self得到的内存地址相同，所以self指的是调用该函数的对象
一个类创建多个对象
写法：将一个类多次赋值给对象
添加和获取对象属性
类外面添加对象属性
属性即是特征，比如：洗衣机的宽度、高度、重量......
对象属性既可以在类外面添加和获取，也能在类里面添加和获取
语法：
对象名.属性名 = 值
类外面获取对象属性
语法
对象名.属性名
类里面获取对象属性
语法：
self.属性名
魔法方法
在python中，___xx___( )的函数叫做魔法方法，指的是具有特殊功能的函数
___init___( )
作用：初始化对象
注意：
- __init__( )方法，在创建一个对象时默认被调用，不需要手动调用
- __init__(self)中的self参数，不需要开发者传递，python解释器会自动把当前的对象引用传递过去
带参数的__init__( )
使用场景：因为一个类可以创建多个对象，而此时多个对象要想初始化属性时能够有所差异，就可以传入参数（对不同的对象设置不同的初始化属性）
魔法方法之__str__( ) 【一般放置解释说明的文字】【解释说明：类的说明或对象状态的说明】
当使用print输出对象的时候，默认打印对象的内存地址。如果类定义了__str__方法，那么就会打印从这个方法中return的数据
作用：返回return的值
如下：
魔法方法之__del__( )
当删除对象时，python解释器也会默认调用__del__( )方法
第十四天
综合案例：烤地瓜、搬家具
面向对象-继承
继承的概念 好处：【简化代码量】
生活中的继承，一般指的是子女继承父辈的财产。
拓展经典类和新式类
解释器老版本执行经典类，新版本执行的是新式类
经典类：
class 类名:
代码
.........
新式类：
class 类名(object):
代码
........
体验继承
Python面向对象的继承指的是多个类之间的所属关系，即子类默认继承父类的所有属性和方法。
object是基类，其他类是派生类
第十五天
单继承
定义：一个父类继承给一个子类，是一种单一的继承关系。
多继承
定义：一个子类同时继承多个父类
注意：当一个类有多个父类的时候，优先继承第一个父类的同名属性和方法
子类重写父类同名方法和属性（子类中的属性和方法跟父类的属性和方法一致）
意思是：如果子类和父类拥有同名属性和方法，子类创建对象调用属性和方法的时候，调用到的是子类里面的同名属性和方法
拓展 __mro__ 顺序
写法：类名.__mro__
作用：查找类的继承关系
子类调用父类的同名方法和属性（因为默认调用的是子类的属性和方法）
写法：1.父类类名.函数名(self) 传递self参数 [写在子类里面]
2.再次初始化父类 {自身和父类都需要初始化}
3.自身也需要初始化
此类方法缺点：1.如果父类类名修改，调用父类时也需要修改【父类类名.函数名】
2.代码量庞大
多层继承 （大于2层的继承叫做多层继承）
父类继承给子类，这个子类又继承给它的子类
写法跟单继承、多继承一样的，套娃
第十六天
super( )调用父类方法
语法：
super(当前类名,self).函数( )
super( ).函数( ) [无参数写法常用]
注意：使用super( )可以自动查找父类。调用顺序遵循__mro__类属性的顺序。比较适合单继承使用。
私有权限
定义私有属性和方法
设置私有权限的方法：在属性名和方法名前面加上两个下划线__【先按照正常的定义书写，然后在属性和方法前面加上__】。
设置为私有权限后，就不会继承给子代，对某些数据和方法起到保护作用
注意：私有属性和私有方法只能在类里面访问和修改
获取和修改私有属性值【注意：不是获取和修改私有方法哈】
在Python中，一般定义函数名get_xx用来获取私有属性，定义set_xx用来修改私有属性值
注意：私有属性不能在类外面查找，所以更不可能在类外面修改
第十七天[面向对象-其他]
面向对象三大特性：封装、继承、多态
封装：
1.将属性和方法书写到类的里面的操作即为封装
2.封装可以为属性和方法添加私有属性
继承：
1.子类默认继承父类的所有属性和方法
2.子类可以重写父类属性和方法
多态：
1.传入不同的对象，产生不同的结果（最好依赖继承关系）
了解多态
定义：多态是一种使用对象的方式，子类重写父类方法，调用不同子类创建出来的对象的相同父类方法，可以产生不同的执行结果[因为涉及到子类、父类，最好 依赖继承关系]
好处：调用灵活，有了多态，更容易编写出通用的代码，做出通用的编程，以适应需求的不断变化
实现步骤：
1.定义父类，并提供公共方法
2.定义子类，并重写父类方法
3.传递子类创建的对象给调用者，可以看到不同子类执行效果不同
体验多态
类属性和实例属性
类属性
类属性就是类所拥有的属性，它被该类创建的所有对象所共有
类属性可以使用类或对象访问
定义类属性语法：
直接在类里面书写（不需要函数）：属性名 = 值
用类访问：类名.属性名
用对象访问：对象.属性名
类属性优点：
1.记录的某项数据始终保持一致时，则定义类属性
2.实例属性要求每个对象为其单独开辟一份内存空间来记录数据，而类属性为全类所共有，仅占用一份内存，更加节省空间
修改类属性
类属性修改只能通过类修改，不能通过对象修改，如果通过对象修改类属性，表示的是创建了一个新的同名属性
修改语法：
类名.属性名 = 值【多数修改都是这样实现的】
类方法
特点：需要用装饰器@classmethod来标识其为类方法，对于类方法，第一个参数必须是类对象，一般以cls作为第一个参数
使用场景：
当类方法中需要使用类对象（如访问私有类属性等）时，定义类方法
类方法一般和类属性配合使用
语法： @classmethod
定义函数等操作
静态方法
特点：需要通过装饰器@staticmethod来进行修饰，静态方法既不需要传递类也不需要传递对象（形参没有self/cls)
静态方法也能通过对象和类去访问
使用场景：
当方法（函数）中既不需要使用对象（如实例对象、实例属性），也不需要使用类（如类属性、类方法、创建实例等）时，定义静态方法
不需要参数传递，有利于减少不必要的内存占用和性能消耗
说明：类和对象都可以进行访问
第十八天【异常】
异常的写法 【最基本的写法】
语法：
try:
可能发生错误的代码
except:
如果出现异常执行的代码
捕获异常类型
语法：
try:
可能发生错误的代码
except 异常类型:
如果捕获到该异常类型执行的代码
注意：
1.如果尝试执行的代码的异常类型和要捕获的异常类型不一致，则无法捕获异常
2.一般try下方只放一行尝试执行的代码
捕获多个指定异常
当捕获多个异常时，可以把要捕获的异常类型的名字，放到except后，并使用元组的方式进行书写
捕获异常描述信息
result是一个变量，用于存放异常信息
捕获所有异常 【我自己任务它是重点，因为它比较通用，涵盖了前面的几种写法】
Exception是所有程序异常类的父类
异常的else
else表示的是如果没有异常要执行的代码
说明：else要放在try、except之后
异常的finally
finally表示的是无论是否异常都要执行的代码，例如关闭文件
说明：finally要放在try、except之后
异常传递 [自认为不重要]
定义:嵌套书写异常[跟嵌套书写if一样]
自定义异常
在python中，抛出自定义异常的语法为raise 异常类
作用:不符合程序逻辑要求的错误进行反馈(报错)
案例：用户输入的密码长度不足，捕获异常
步骤：
1.自定义异常类【继承Exception】
2.抛出自定义异常
3.捕获
一般会用到__str__魔法方法用来描述异常信息
自定义异常格式：
见下
第十九天【模块和包】
模块
模块（以random为例）就是一个python文件，以.py结尾，包含了python对象定义以及python语句。模块能定义类，函数和变量，模块里也能包含可执行的代码
导入模块
导入模块的方式：
方法一：import模块名
方法二：from模块名 import功能名 【这3种最基本】
方法三：from模块名 import*
import模块名as别名
from模块名import功能名as别名
方法一：
语法：
导入模块：
import模块名 【单个】【推荐】
import模块名1,模块名2,.....【多个】【不推荐】
调用功能：
模块名.功能名( )
eg：import random
random.randint
此外：import math
方法二：
语法： 导入模块：
from模块名 import功能1，功能2，功能3,....
调用模块：
功能名( )
方法三：
语法： 【导入模块里面的所有功能】
导入模块：
from模块名 import *
调用模块：
功能名( )
定义别名
语法：
模块定义别名: 【给模块名定义别名操作】
import模块名 as 别名
功能定义别名： 【给功能名定义别名操作】
from模块名import功能as别名
制作模块
在python中，每个python文件都可以作为一个模块，模块的名字就是文件的名字。也就是说自定义模块名必须要符合标识符命名规则
制作模块分3个步骤：定义模块、测试模块、调用模块
制作模块之定义模块
新建一个python文件，命名为xxx.py，并定义函数、类、变量
制作模块之测试模块
说明：__name__是一个系统变量，是模块的标识符，
值是：如果是自身模块值是__main__,否则是当前的模块的名字
制作模块之调用模块
模块定位顺序
当导入一个模块，Python解析器对模块位置的搜索顺序是：
1.当前目录【当前文件所在的文件夹】
2.如果不在当前目录，Python则搜索在shell变量PYTHONPATH下的每个目录
3.如果都找不到，Python会查看默认路径。
注意：
1.自己的文件名不要和已有模块名重复，否则导致模块功能无法使用【例如：已有random模块，自己的文件名就不要使用】
2.使用from模块名import功能的时候，如果功能名字重复，调用到的是后定义或导入的功能
拓展-名字重复的严重性
如果使用 import 模块名 就不用担心功能名字重复的问题
__all__列表 【__all__是一个变量，该变量取值是一个列表】
如果一个模块文件中有__all__变量，当使用from XXX import * 导入时，只能导入这个列表中的元素所携带的功能
包 【就是指一个文件夹】
包将有联系的模块组织在一起，即放到同一个文件夹下，并且在这个文件夹创建一个名字为__init__.py文件，那么这个文件夹就称之为包
制作包
流程：
[New]-----[Python Package] ------输入包名------[OK]------新建功能模块（有联系的模块）
注意：新建包后，包内部会自动创建__init__.py文件，这个文件控制着包的导入行为
导入包
方法一：
语法：
import包名.模块名
包名.模块名.目标
方法二：
语法：
from包名import *
模块名.目标
扫一扫
3318
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
