Python从入门到精通

没有退路就是胜利之路

1.Python语言基础入门

下载安装Python解释器

下载安装：www.python.org/downloads

安装和配置PyCharm软件

修改软件颜色背景：File-Settings-Appearence&behavior-appearence-theme(Intellig Light)

修改默认字体大小:File-Settings-Editor-font-选择字体和默认大小的设置。

通过设置快捷键设置字体大小：File-Settings-Keymap-Editor Actions-Increase Font Size(右键)/decrease Font Size-Add Mouse Shortcut,按住ctrl+鼠标滚轮向上/向下。

字面量

定义: 代码中被写下来的固定的值，称为字面量。

字符串：是由任意数量的字符如中文，英文，各类符号，各自等组成。所以叫字符串。

Python种，字符串需要用双引号””包围起来，被引号包围起来的，都是字符串。

注释

1.注释的作用

注释:是在程序代码种对程序代码进行解释说明的文字.

作用:注释不是程序，不能被执行，只是对程序代码进行解释说明，让别人可以看懂程序代码的作用，能够大大增强程序的可读性。

2.使用单行注释和多行注释

单行注释:以#开头，#右边的所以文字当作说明，而不是真正执行的程序，起辅助说明作用。注意，#号和注释内容一般建议以一个空格隔开。

多行注释:以一对三个双引号引起来(“””注释内容”””)来解释说明一段代码的作用使用方法。

变量

1.变量的作用和特征

变量：在程序允许时，能存储计算结果或能表示值的抽象概念，简单的说，变量就是在程序运行时，记录数据用的。

2.变量的定义方式

格式：变量名词 = 变量的值

3.变量的特征

变量的值是可以改变的

数据类型

1.掌握使用type()语句查看数据的类a型

在print语句中，直接输出类型信息:print(type(被查看类型的数据))

用变量存储type()的结果

不仅可以使用自变量类型也可以查看变量中存储的数据类型

2.理解变量无类型而数据有类型的概念

在Python中变量是没有类型的，但变量存储的数据是有类型的。只表示变量存储了数据

数据类型变换

1.如何在字符串，整数，浮点数之间进行相互转换

2.了解转换的注意事项

想要将字符串转换成数字，必须要求字符串内的内容都是数字。

浮点数转整数时可能回丢失精度。

标识符

1.什么是标识符

变量/方法/类的名字等，拔它统一的称之为标识符，用来做内容的标识。所以，标识符是用户在编程的时候所使用的一系列名字，用于给变量，类，方法等命名。

2.标识符的命名规则

内容限定：命名只允许出现英文，中文，数字，下划线这四类元素，其他任何内容都不被允许

(不推荐使用中文，不能以数字开头)

大小写敏感：

不可使用关键字：

3.掌握变量的命名规范：见名知意，下划线命名法(间隔)，全部小写。

运算符

1.算术运算符

2.赋值运算符:=,+=,-=,=,/=,%=,*=,//=

字符串拓展

字符串的三种定义方式

1.单引号定义法

2.双引号定义法

3.三引号定义法：和多行注释的写法意义，同样支持换行操作。当使用变量接收它，它就算字符串，不使用变量接收它，就可以作为多行注释使用。

引号的嵌套：

1.可以使用: \来进行转义

2.单引号内可以写双引号或双引号内可以写单引号

字符串拼接

1.如何拼接字符串

一般用于字符串字面量和变量或变量和变量之间会使用拼接。+号拼接，而且无法和非字符串类型进行拼接。

字符串格式化1

拼接的缺点：1.变量太多，拼接起来实在是太麻烦了

2.字符串无法和数字或其他类型完成拼接

格式化：%s，其中%表示我要占位，s表示将变量变成字符串放入占位的地方。

多个变量占位，变量要用括号括起来，并按照占位的顺序填入。

格式化的精度控制

1.掌握格式化字符串的过程中做数字的精度控制

可以使用辅助符号”m.n”来控制数据的宽度和精度

m,控制宽度，要求是数字(很少使用)，设置的宽度小于数字自身，不生效

.n,控制小数点精度，要求是数字，会进行小数的四舍五入

%5d:表示将整数的宽度控制在五位，前面补空格

%5.2f:表示将宽度控制为5，将小数点精度设置为2

字符串格式化方式2

1.快速字符串格式化的方式

语法：f”内容{变量}”的格式来快速格式化

不理会类型，不做精度控制，适合对精度没有要求的适合快速使用。

对表达式进行格式化

1.什么是表达式：一条具有明确执行结果的代码语句。

2.对表达式进行字符串格式化

name = "传智播客"
stock_price = 19.99
stock_code = 003032
stock_price_daily_growth_factor = 1.2
growth_day = 7
printf("公司%s,股票代码%s,当前股价%.2f" % (name,stock_code,stock_price))
printf("每日的增长系数是:%.2f,经过%d天的增长后,股价达到了%2f" % (stock_price_daily_growth_factor,growth_day,(19.99*1.2)))

数据输入

使用input()语句可以从键盘获取输入

使用一个变量接收input语句获取的键盘输入数据

要注意，无论键盘输入什么类型的数据，获取到的数据永远都是字符串类型，如需其他类型可以进行数据类型转换。

Python判断语句的学习

布尔类型和比较运算符

布尔运算符:

比较运算符：==，!=,>,<,>=,<=,通过比较运算得到布尔类型的结果。

if语句的基本格式

if 要判断的条件:

条件成立时，要做的事

if语句的注意事项:

判断条件的结果一定要是布尔类型

不要忘记判断条件后的: 冒号

归属于if语句的代码块，需在前方填充4个空格缩进

if else 语句

if 要判断的条件:

条件成立时，要做的事

else:

不满足条件时要做的事情

if elif else语句

if 要判断的条件:

条件成立时，要做的事

elif 条件2：

条件成立时，要做的事

elif 条件2：

条件成立时，要做的事

…………..

else:

不满足条件时要做的事情

elif可以写多个。

判断是互斥且有序的，上一个满足后面就不会判断了。

可以在条件判断中，直接写input语句，节省代码量。

判断语句的嵌套

实战案例

循环语句

while循环：

while循环的基础语法：

while 条件:
    条件满足时，做的事情1
    条件满足时，做的事情2
    条件满足时，做的事情3
    ........(省略)....
# 只要条件满足，会无限循环执行
# 条件需提供布尔类型结果，True继续，False停止
# 空格缩进不能忘
# 请规划好循环终止条件，否则将无限循环

while循环的嵌套应用

while 条件1:
    条件1满足时，做的事情1
    条件1满足时，做的事情2
    条件1满足时，做的事情3
    ........(省略)....
    while 条件2:
    条件2满足时，做的事情1
    条件2满足时，做的事情2
    条件2满足时，做的事情3
    ........(省略)....
# 注意条件控制，避免出现无限循环(除非真的需要无限循环)

while循环的嵌套案例

print( )输出不换行：print(“不换行”，end=’ ‘)

在字符串中，有一个特殊符号\t,效果如同在键盘按下:tab键

打印九九乘法表

for循环:

for循环的基础语法

基础语法：

1
2
3

for 临时变量 in 待处理数据集/序列类型:
	循环满足条件时执行的代码
   # 同while循环不同，for循环是无法定义循环条件的 ，只能从被处理的数据集中，依次取			出内容进行处理。

range语句

语法1：
range(num)
# 获取一个从0开始，到num结束的数字序列(不含num本身)
语法2：
range(num1,num2)
# 获得一个从num1开始，到num2结束的数字序列(不含num2本身)
语法3：
range(num1,num2,step)
# 获得一个从num1开始，到num2结束的数字序列(不含num2本身)，数字之间的步长，以step为准(step默认为1)

变量作用域

如果在for循环外部访问临时变量:

实际上是可以访问到的

在编程规范上，是不允许，不建议这么做的(可以预先在循环外定义它)

for循环的嵌套应用

for 临时变量 in 待处理数据集(序列):
    循环满足要做的事情1
    循环满足要做的事情2
    循环满足要做的事情N
    for 临时变量 in 待处理数据集(序列):
        循环满足要做的事情1
    	循环满足要做的事情2
    	循环满足要做的事情N

循环控制: break和continue

特殊情况：暂时跳出某次循环，直接进行下一次/提前退出循环，不在继续

	continue关键字用于:中断本次循环，直接进入下一次循环//临时中断，作用范围在所在循环无法对上层循环起作用。

	continue可以用于：for循环和while循环，效果一致

	break关键字用于：直接结束循环//永久中断，作用范围在所在循环，无法对上层起作用

	break可以用于：for循环和while循环，效果一致

函数：

函数介绍

函数：是组织好的，可重复使用的，用来实现特定功能的代码段。

为什么使用函数：为了得到一个针对特定需求，可供重复利用的代码段，以提高程序的复用性，减少重复性代码，提高开发效率。

函数基础定义语法：

1
2
3

def 函数名(传入参数)：
	函数体
	return 返回值

函数的参数

传入参数的功能是:在函数进行计算的时候，接受外部(调用时)提供的数据。

函数的返回值

什么是返回值:程序中函数完成事情后，最后给调用者的结果

def 函数名(传入参数)：
	函数体
	return 返回值 #函数体在遇到return后就结束了
变量 = 函数(参数)

None类型：

如果函数没有使用return语句返回数据，那么函数有返回值吗? 实际上是有的，Python中有一个特殊的字面量:None,其类型是:<class ‘NoneType> 无返回值的函数，实际上就算返回了:None这个字面量。

None表示：空的，无实际意义的意思，函数返回了None，就表示这个函数没有返回什么有意义的内容，也就是返回了空的意思。

None类型的应用场景：

1.用在函数无返回值

2.用在if判断上

在if判断中，None等同于False,一般用于在函数中主动返回None，配合if判断做相关处理。

def check_age(age)
	if age>18:
        return "SUCESS"
    else
    	return None
result = check_age(16)
if not result:
    #进入if表示result是None，也就是False
    print("未成年，不可进入")

3.用在声明无内容的变量上

定义变量，但暂时不需要变量有具体值，可以用None来代替。

name=None

函数的说明文档

通过注释对函数进行解释说明

def func(x,y):
	"""
	函数说明
	:param x:形参x的说明
	:return 返回值
	函数体
	return 返回值
	"""
# 调用时悬停可以出现说明文档

函数的嵌套调用

所谓函数嵌套调用指的是一个函数里面又调用了另一个函数。

如果函数A中，调用了另一个函数B，那么先把函数B中得任务都执行完毕之后才会回到上次函数A执行的位置。

变量在函数的作用域

局部变量:定义在函数体内部的变量，即只在函数体内部生效。

全局变量:指的是在函数体内外都能生效的变量

在函数体内改全局变量:

# global关键字
num=200
def test_a():
    print(f"test_a:{num}")
def test_b():
    num=500
    print(f"test_b:"{num})
test_a()  #200
test_b()  #500
print(num) #200
#-----------------------------------
num=200
def test_a():
    print(f"test_a:{num}")
def test_b():
    global num=500
    print(f"test_b:"{num})
test_a()  #200
test_b()  #500
print(num) #500

综合案例

数据容器

目的是批量存储或者批量使用多份数据。

数据容器:一种可以容纳多份数据的数据类型，容纳的每一份数据称之为1个元素，每一个元素，可以是任意类型的数据，如字符串，数字，布尔等。

数据容器根据特点的不同，如:

是否支持重复元素

是否可以修改

是否有序，等

分为5类，分别是:列表(list),元组(tuple),字符串(str),集合(set),字典(dict)

数据容器:list列表

# 1.基本语法
#字面量
[元素1，元素2，元素3，元素4，...]
#定义变量
变量名称 = [元素1,元素2，元素3，元素4，....]
#定义空列表
变量名称 = []
变量名称 = list()
# 列表内的每一个数据，称之为元素，以[]作为标识，列表内每一个元素之间用，逗号隔开
# 列表可以一次存储多个数据，且可以为不同的数据类型，支持嵌套[[1,2,3],666,'itheima']。

2.使用列表的下标索引从列表中取出元素

# 语法: 列表[下标索引]
name_list = ['Tom','Lily','Rose']
print(name_list[0]) #结果:Tom
print(name_list[1]) #结果:Lily
print(name_list[2]) #结果:Rose

反向索引：

##### 	语法: 列表[下标索引]
name_list = ['Tom','Lily','Rose']
print(name_list[-1]) #结果:Rose
print(name_list[-2]) #结果:Lily
print(name_list[-3]) #结果:Tom

嵌套索引的下标：

# 要注意下标索引的取值范围，超出范围无法取出元素，并且会报错。

3.列表的常用操作:

在Python中，如果将函数定义为class(类)的成员，那么函数会称之为:方法

# 方法和函数功能一样，有传入参数，有返回值，只是方法的使用格式不同

#函数的使用
def add(x,y):
    return x+y
num = add(1,2)
#方法的使用
class Student:
    def add(self,x,y):
    return x+y
student = Student()
num = student.add(1,2)

3.1 查询某元素下标的功能 : 列表.index(元素)

功能:查找指定元素在列表的下标，如果找不到，报错ValueError

index就是列表对象(变量)内置的方法(函数)

3.2 修改特定下标的元素值: 列表[下标]=值

可以使用如上语法，直接对指定下标(正向，反向下标均可)的值进行:重新赋值(修改)

3.3 插入元素 ：列表.insert(下标，元素)，在指定的下标位置，插入指定的元素。

1
2
3

my_list = [1,2,3]
my_list.insert(1,"itheima")
print(my_list) #结果: [1,"itheima",2,3]

3.4 追加元素: 列表.append(),将指定元素，追加到列表的尾部

# 追加单个元素
my_list = [1,2,3]
print(my_list) #结果: [1,2,3]
my_list.append("itheima")
print(my_list) #结果: [1,2,3,"itheima"]
# 追加一批元素 
my_list = [1,2,3]
my_list.extend([4,5,6])
print(my_list)  # 结果：[1,2,3,4,5,6]

3.5 删除元素，清空列表：del 列表[下标] / 列表.pop(下标)

mylist = ["itcast","itheima","python"]
del mylist[2]
print(mylist)# 'itcast','itheima',
# --------------------------------------------
element=mylist.pop[1]
print(f"{my_list},取出的元素是{element}") # 'itcast'

3.6 指定元素内容删除：列表.remove(元素)

1
2
3

my_list = [1,2,3,2,3]
my_list.remove(2) # 从前到后去搜索这个元素，找到的第一个被删除。
print(my_list) #结果[1,3,2,3]

3.7 清空列表: 列表.clear( )

3.8 统计某元素在列表内的数量: 列表.count(元素)

1 2	my_list = [1,1,1,2,3] print(my_list.count(1)) #结果3

3.9 统计类别中全部元素的数量: len(列表)

列表的特点：

		可以容纳多个元素

		可以容纳不同类型的元素

		数据是有序存储的

		允许重复数据存在

		可以修改

list列表的遍历

掌握while循环遍历列表

while循环可以自定循环条件，并自行控制。

while循环可以通过控制条件控制做到无限循环。

while循环适用于任何想要循环的场景。

1 2	while 下标索引变量<列表的元素数量：下标索引变量+=1

掌握for循环遍历列表

for循环不可以自定循环条件，只可以一个个从容器内取出数据。

for循环理论上不可以无限循环，因为被遍历的容器容量不是无限的。

for循环适用于，遍历数据容器的场景或简单的固定次数循环场景。

1 2	for 临时变量 in 数据容器: 对临时变量进行处理

数据容器:tuple(元组)

列表是可以修改的，不适用于不被篡改的信息。

元组同列表一样，都是可以封装多个，不同类型的元素在内

格式:

# 定义元组字面量
(元素，元素，元素)
# 定义元组变量
变量名称=(元素，元素，元素)
# 定义空元组
变量名称 = () #方式1
变量名称 = tuple() #方式2
# !!!注意!!!：定义的元组只有一个数据，这个数据后面要添加逗号
t1 = ('Hello',)

特点:

元组也支持嵌套

操作:

1.下标索引取出元组内容

1 2	t5=((1,2,3),(4,5,6)) t5[1][2] # 6

2.index查找方法：元组.index(元素)

3.count统计方法: 元组.count(元素)

4.len函数统计元组元素数量: len(元组)

元组的遍历：

index=0
while 下标索引变量index<元组的元素数量：
	元组[index]
	下标索引变量+=1

1 2	for element in 元组: print(element)

特列：元组内嵌套的列表是可以修改的。

info=('周杰伦',11,['football','music'])
# 查询其年龄所在的下标位置
index=info.index(11)
print(f"11岁所在的下标位置是:{index}")
# 查询学生的姓名
name=info[0]
print(f"学生的姓名是:{name}")
# 删除学生爱好中的football
info[2].pop(0)
print(info)
# 增加爱好：coding到爱好内
info[2].append('coding')
print(info)

数据容器:str(字符串)

字符串是字符的容器，一个字符串可以存放任意数量的字符。

和其他容器一样如 : 列表，元组一样，字符串也可以通过下标进行访问。

从前向后，下标从0开始；从后向前，下标从-1开始。

同元组一样，字符串是一个无法修改的数据容器。

字符串常用操作：

1.查找特定字符串的下标索引值

语法: 字符串.index(字符串)

2.字符串替换

语法:字符串.replace(字符串1，字符串2)：将字符串内的全部字符串1替换为字符串2

注意：不是修改字符串本身，而是得到了一个新字符串。

3.字符串的分割

语法：字符串.split(分隔符字符串)：按照指定的分隔符字符串，将字符串划分为多个字符串，并存入列表对象中。

注意: 字符串本身不变，而是得到了一个列表对象。

1 2	"hello python itheima itcast" ["hello","python","itheima","itcast"]

4.字符串的规整操作(去除前后空格以及回车换行符)

语法: 字符串.strip()

1 2	my_str = " itheima and itheima " new_my_str=my_str_strip()#不传入参数，去除首尾空格

字符串的规整操作(去除前后指定字符串)

语法：字符串.strip(字符串)

注意:是按照单个字符串移除的

1 2	my_str = " 12itheima and itheima21 " new_my_str=my_str_strip(‘12’)#不传入参数，去除首位空格

5.统计字符串中某字符串出现的次数：count( )

6.统计字符串的长度，len( )

7.字符串遍历

数据容器(序列)的切片:

序列:内容连续，有序，可使用下标索引的一类数据容器；列表，元组，字符串，均可以视为序列。

序列操作-切片:从一个序列中，去除一个子序列

切片的语法：序列[起始下:结束下标:步长]

起始下标表示从何处开始，可以留空，留空视作从头开始

结束下标表示何处结束，可以留空，留空视作截取到结尾

步长表示，依次取元素的间隔(1:表示一个个取元素，2:跳过1个元素取，步长为负数表示反向去，起始下标和结束下标也要反向标记)

注意：此操作不会影响序列本身，而是会得到一个新的序列。

包头不包尾

数据容器:set(集合)

如果场景需要对内容做去重处理，列表，元组，字符串就不方便了。

# 基本语法:
# 定义集合字面量
{元素,元素,......,元素}
# 定义集合变量
变量名称 = {元素,元素,......,元素}
# 定义空集合
变量名称 = set()

集合的常用操作-修改：

首先，因为集合是无序的，所以集合不支持：下标索引访问，但是集合和列表一样，是允许修改的。

1.添加新元素：集合.add(元素)。将指定元素，添加到集合内。结果集合被修改，添加了新元素。

2.移除元素：集合.remove(元素)。将指定元素，从集合内移除，结果集合本身被修改，移除了元素。

3.从集合中随机取出元素:集合.pop(),功能是从集合中随机取出一个元素，结果会得到一个元素的结果。同时集合本身被修改，元素被移除。

4.清空集合：集合.clear(),直接清空集合。

5.取两个集合的差集：集合1.difference(集合2)，功能是取出集合1和集合2的差集(集合1有而集合2没有)，结果得到一个新集合，集合1和集合2不变

set1={1,2,3} 
set2={1,5,6}
set3=set1.difference(set2)
print(set3) #{2,3}
print(set1)	#{1,2,3}
print(set2) #{1,5,6}

6.消除两集合的差集：集合1.difference_update(集合2)，对比集合1和集合2，在集合1内，删除和集合2相同的元素，结果集合1被修改，集合2不变。

set1={1,2,3} 
set2={1,5,6}
set1.difference_update(set2)
print(set1)	#{2,3}
print(set2) #{1,5,6}

7.两个集合合并成一个:集合1.union(集合2)，将集合1和集合2组合成新集合，结果得到新集合，集合1和集合2不变。

set1={1,2,3} 
set2={1,5,6}
set3=set1.union(set2)
print(set3) #{1,2,3,5,6}
print(set1)	#{1,2,3}
print(set2) #{1,5,6}

8.统计集合元素数量：len(集合)

9.集合的遍历：不支持下标索引，不能适用while循环，可以使用for循环。

数据容器:dict(字典,映射)

通过key去找到对应的value(例如通过学生姓名检索学生的成绩)

字典的定义，同样使用{},不过存储的元素是一个个的:键值对，如下语法

# 定义字典字面量
{key:value,key:value,.......,key:value}
# 定义字典变量
my_dict={key:value,key:value,.......,key:value}
# 定义空字典
my_dict={}
mydict = dict()

定义重复key的字典(错×，后者覆盖前者)。

字典数据的获取：字典.[“key”],字典同集合一样，不可以使用下标索引，字典可以通过Key值来取得对应的Value.

字典的嵌套：字典的Key和Value可以说任意类型(Key不可为字典)

stu_score={
    "王力宏":{
        "语文":77,
        "数学":66,
        "英语":33
    },
    "周杰伦":{
        "语文":88,
        "数学":86,
        "英语":55
    }
    "林俊杰":{
        "语文":99,
        "数学":96,
        "英语":66
    }
}
#如何从嵌套的字典中获取数据
stu_score["周杰伦"]["语文"]   #77

字典的常用操作:

新增元素: 字典[Key]=Value,结果:(Key不存在)字典被修改，新增了元素。

更新元素: 字典[Key]=Value,结果:(Key不存在)字典被修改，元素被更新。注意！！,字典Key不可以重复，所以对已存在的Key执行上述操作，就是更新Value值。

删除元素: 字典.pop(Key),结果获得指定Key的Value，同时字典被修改，指定Key的数据被删除。

清空字典: 字典.clear(),结果:字典被修改，元素被清空。

获得全部的Key: 字典.keys(),结果:得到字典中的全部Key。

遍历字典: 方式一:for key in keys:通过找到全部的Key完成遍历

方式二:for key in my_dict:直接对字典进行for循环

统计字典内的全部元素:num=len(my_dict)

字典的特点:

数据容器的通用操作

遍历：5类数据容器都支持for循环遍历，列表，元组，字符串支持while循环，集合，字典不支持(无法下标索引)。

统计容器的元素个数:len(容器)

统计容器的最大元素:max(容器)

统计容器的最小元素:min(容器)

类型转换:

容器转列表:list(容器)

容器转元组:tuple(容器)

容器转字符串:str(容器)

容器转集合:set(容器)

容器的通用排序功能:

sorted(容器,[reverse=True]/降序),将给定容器进行排序,排序后的结果变成列表对象,字典会丢失Value。

Python函数进阶：

函数的多返回值:

如果一个函数要有多个返回值，该如何书写代码?

def test_return():
    return 1,2
x,y=test_return()  #按照返回值的顺序,写出对应的多个变量接收即可，变量之间用逗号隔开，支持不然类型的数据return。
print(x) #结果1
print(y) #结果2

函数的多种传参方式:

位置参数:调用函数时根据函数定义的参数位置来传递参数。传递的参数和定义的参数的顺序及个数必须一致。

关键字参数:函数调用时通过”键=值”形式传递参数.可以让函数更加清晰，容易使用，同时也清楚了参数的顺序需求。

函数调用时，如果有位置参数时，位置参数必须在关键字参数的前面，但关键字参数之间不存在先后顺序。

缺省参数:缺省参数也叫默认参数，用于定义函数，为参数提供默认值，调用函数时可不传该默认函数的值(注意:所有位置参数必须出现在默认参数前，包括函数定义和调用)

作用:当调用函数时没有传递参数，就会使用默认使用缺省参数对应的值。

不定长参数:也叫可变参数，用于不确定调用的时候会传递多少个参数(不传参也可以)的场景。

作用：当调用函数时不确定参数个数时，可以使用不定长参数。

类型：

1.位置传递不定长

注意:传进的所有参数都会被args变量收集，它会根据传进参数的位置合并为一个元组，args是元组类型。

2.关键字传递不定长

注意：参数是”键=值”形式的情况下，所有的”键=值“，都会被kwargs接受，同时会根据:”键=值”组成字典。

匿名函数:

函数接受数据{数字,字符串,字典，列表，元组等}和函数本身作为参数传入另一个函数内。

数据确定后传入函数作为参数，就算代码执行逻辑得传入。

lambda匿名函数：

函数的定义中

def关键字，可以定义带有名称的函数，可以基于名称重复使用。

lambda关键字，可以定义匿名函数(无名称)，只可以临时使用一次。

语法: lambda 传入参数: 函数体(一行代码)

lambda是关键字，表示定义匿名函数。

传入参数表示匿名函数的形式参数，如：x,y表示接收2个形式参数

函数体，就是函数的执行逻辑，要注意:只能写一行，无法写多行代码。

文件操作

文件的编码：

编码就是一种规则集合，记录了内容和二进制间进行相互转换的逻辑。编码有许多种，我们常用的是UTF-8编码。

计算机只认识0，1，所以需要将内容翻译成0和1才能保存在计算机中。同时也需要编码，将计算机保存的0和1，反向翻译会可以识别的内容。

文件的读取：

1.打开文件:open(name,mode,encoding),可以打开一个已经存在的文件，或者创建一个新文件。

name:是要打开的目标文件名的字符串(可以包含文件所在的具体路径).

mode:设置打开文件的模式(访问模式):只读r，写入w，追加a等.

encoding：编码格式(推荐使用UTF-8).

1 2	f=open('路径/python.txt',"r",encoding="UTF-8") #encoding的顺序不是第三位，所以不能用位置参数，用关键字参数直接指定。

 mode三种基础访问模式:

	r：以只读方式打开文件，文件的指针将会放在文件的开头，这是默认模式。

	w:打开一个文件只用于写入，如果该文件已存在则打开文件，并从头开始编辑，原有内容会被删除，如果该文件不存在，创建新文件。

	a:打开一个文件用于追加。如果该文件已存在，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。

2.读写文件：

read()方法：文件对象.read(num),num表示要从文件中读取的数据的长度(单位是字节)，如果没有传入num，那么就表示读取文件中所有的数据。

readlines()方法：readlines可以按照行的方式把整个文件中的内容进行一次性读取，并且返回的是一个列表，其中每一行的数据为一个元素。

readline()方法:一次读取一行内容。

！！！注意如果在程序中多次调用read，下一个read会在上一个read的结尾处接着读取。

for循环读取文件行:

1
2
3

for line in open("python.txt","r"):
    print(line)
# 每一个line临时变量，就记录了文件的一行数据。

3. 关闭文件：文件对象.close( )

关闭文件对象，也就是关闭对文件的占用，如果不调用close，同时程序没有停止运行，那么这个文件将一直被Python程序占用。

4.with open语法：

with open ("python.txt","r")as 文件对象:
    f.readlines()
# 通过在with open语句块中对文件进行操作
# 可以在操作完成后自动关闭close文件，避免遗忘掉close方法。

文件的写入：f.write(‘hello world’，“w”)

内容刷新: f.flish() # close方法内置了flush功能的。

# 1.打开文件，通过a模式打开即可
f=open('python.txt',"w")
# 2.文件写入
f.write("heool")
# 3.内容刷新
f.flush

注意:
直接调用write，内容并未真正写入文件，而是会积攒在程序内存中，称之为缓冲区。

当调用flush的时候，内容会真正写入文件。

这样做是避免频繁的操作硬盘，导致效率下降。

文件的追加：

# 1.打开文件，通过a模式打开即可
f=open('python.txt',"a")
# 2.文件写入
f.write("heool")
# 3.内容刷新
f.flush

文件操作的综合案例：

Python异常,模块,包

了解异常:程序出现问题

异常的捕获方法：

在力所能及的范围内，对可能出现的bug,进行提前准备，提前处理。

作用:提前假设某处会出现异常，做好提前准备，当真的出现异常的时候，可以有后续手段。

语法:

try:
      	可能发生错误的代码
      except:
          如果出现异常执行的代码
      #例子:尝试以'r'模式打开文件，如果文件不存在，则以'w'方式打开
      try:
          f=open("linux.txt",'r')
      except:
          f=open("linux.txt",'w')

捕获指定异常：//异常的类型有多种

# 1.捕获指定异常
  	try:
      	print(name)
  	except NameError as e://e：异常的类型
      	print("出现了变量未定义的异常")
      # 2.捕获多个异常,可以把要捕获的异常类型的名字，放在except后，并使用元组的方式进行书写。
      try:
      	print(name)
  	except (NameError,ZeroDivisionError) as e://e：异常的类型
      	print("出现了变量未定义的异常或者除0异常")
      # 3.捕获所有异常
      try:
      	print(name)
  	except Exception as e://e：异常的类型
      	print("出现异常")

异常else：//else表示的是如果没有异常要执行的代码

try:
     	print(name)
 	except Exception as e: //e：异常的类型
     	print(e)
     else:
         print("我是else，是没有异常的时候执行的代码")

异常的finally：//finally表示的是无论是否异常都要执行的代码，例如关闭文件

try:
      	f.open('test.txt','r')
  	except Exception as e: //e：异常的类型
      	f.open('test.txt','w')
      else:
          print("我是else，是没有异常的时候执行的代码")
      finally:
          f.close()

异常的传递

Python模块

Python模块是一个Python代码文件，以.py结尾。模块能定义函数，类和变量，模块里也能包含可执行的代码。

作用:python中有很多各种不同的模块，每一个模块都可以帮助我们快速的实现一些功能，比如实现和时间相关的功能就可以使用time模块，我们可以认为一个模块就是一个工具包，每一个工具包中都有各种不同的工具供我们使用进而实现各种不同的功能。

简而言之，模块就是一个Python文件，里面有类，函数，变量等，我们可以拿过来用。

模块的导入:

[from 模块名] import [模块|类|变量|函数|*] [as 别名]  #[]表示可选
"""
常用的组合形式如:
	1.import 模块名
    # 基本语法:---------------------
	import 模块名  //time
	import 模块名1，模块名2
	模块名.功能名() //time.sleep(5) 
    # -----------------------------
	2.from 模块名 import 类，变量，方法等
	# 基本语法:---------------------
	from time import sleep 
    print("开始")
	sleep(5)
    print("结束")
    # -----------------------------
	3.from 模块名 import *    # *表示全部的意识
	# 基本语法:---------------------
	from time import *
    print("开始")
	sleep(5)
    print("结束")
    # -----------------------------
	4.import 模块名 as 别名
	5.from 模块名 import 功能名 as 别名
	# 基本语法:---------------------
	import time as t 
    print("开始")
	t.sleep(5)
    print("结束")
    # -----------------------------
    # 基本语法:---------------------
	from time import sleep as sl 
    print("开始")
	sl(5)
    print("结束")
    # -----------------------------

"""

自定义模块:

新建一个Python文件，命名为AA.py,并定义函数。

当导入多个模块的时候，且模块内有同名功能，调用到的是后面导入的模块的功能(前面的被覆盖)

_ _ _main_ _ _:变量

右键运行可以执行，import导入不能执行

1
2
3

if _ _name_ _ == '__main__':
    test(1,2)
# 既满足了

_ _ _all _ _变量:如果一个模块文件中有_ _ _all _ _变量，当使用’from xxx import *‘,只能导入这个列表中的元素。

my_module1.py
_ _ all _ _=['test_A']
def test_A():
    print('testA')
def test_B():
    print('testB')
#----------------------
test_my_module1.py
from my_module1 import *  # *来自all
test_A()  #这里只能使用test_A函数

Python包

如果Python的模块太多了就可能造成一定的混乱，这就引出了模块如何管理的问题。

从物理上来看，包就是一个文件夹，在该文件夹下包含了一个 —init—.py 文件，该文件夹可用于包含多个模块文件。

从逻辑上看，包的本质依然是模块。

包的作用:当我们的模块文件越来越多时，包可以帮助我们管理这些模块，包的作用就是包含多个模块，但包的本质依然是模块。

包含_init_ .py(内容可以不写)文件就说包，不含就是文件夹。

创建包的步骤：

1.新键包’my_package’

2.新建包内模块:’my_moducle’和’my_module2’

导入包：

方式1：import 包名.模块名 (导入) 包名.模块名.目标 (使用)

方式2：from 包名 import 模块名 (导入) 模块名.目标 (使用)

from 包名.模块名 import 目标目标

     安装第三方Python包

一个包就是一堆同类型功能的集合体

在Python程序的生态中，有许多非常多的第三方包，可以极大帮助我们提高开发效率

numpy包：科学计算中常用的

pandas包：数据分析中常用的

pyspark,apache-flink包：大数据计算中常用的

matplotlib,pyecharts:图形可视化常用的

tensorflow:人工智能常用的

安装第三方包：pip

第一种安装:

第三方包的安装非常简单，我们只需要使用Python内置的pip程序即可

第二种安装: