Python基础学习笔记

第一章认识Python

Python语言的优缺点:

优点:

1. 简单易学、明确优雅、开发速度快
2. 跨平台、可移植、可扩展、交互式、解释型、面向对象的动态语言
3. 有大量的标准库和第三方库
4. 社区活跃，贡献者多，互帮互助
5. 开源语言，发展动力巨大

缺点:

1. 向比与C语言运行速度相对较慢
2. GIL（Global Interpreter Lock）全局解释器锁(伪多线程)
3. Python2和Python3的不兼容性

Python语言的应用方向:

1. 常规软件开发
2. 科学计算
3. 自动化运维
4. 云计算
5. WEB开发
6. 网络爬虫
7. 数据分析
8. 人工智能

Python的安转百度就好,建议使用PyCharm工具,快捷键和idea一样

你好世界

▼
Python
复制代码
print("Hello World")

第二章Python的基础语法

常用的6种数据类型

类型	描述	说明
数字（Number）	支持整数（int）浮点数（float）复数（complex）布尔（bool）	整数（int），如：10、-10 浮点数（float），如：13.14、-13.14 复数（complex），如：4+3j，以j结尾表示复数 布尔（bool）表达现实生活中的逻辑，即真和假，True表示真，False表示假。True本质上是一个数字记作1，False记作0
字符串（String）	描述文本的一种数据类型	字符串（string）由任意数量的字符组成
列表（List）	有序的可变序列	Python中使用最频繁的数据类型，可有序记录一堆数据
元组（Tuple）	有序的不可变序列	可有序记录一堆不可变的Python数据集合
集合（Set）	无序不重复集合	可无序记录一堆不重复的Python数据集合
字典（Dictionary）	无序Key-Value集合	可无序记录一堆Key-Value型的Python数据集合

注释的使用

▼
Python
复制代码
# 单行注释

"""
	多行注释
"""

声明变量的方式

▼
Python
复制代码
# 变量名=变量值
name="value"
print("多个输出","值",name)
# 输出: 多个输出 值 value

type()的使用

▼
text
复制代码
# tepy(被查看的数据)
print(type("字符"))

# 输出<class 'str'>

字符串的定义

▼
Python
复制代码
text1='字符串1'
text2="字符串2"
text3="""字符串3"""

数据转换

语句**(函数)**	说明
int(x)	将x转换为一个整数
float(x)	将x转换为一个浮点数
str(x)	将对象 x 转换为字符串

▼
python
复制代码
# 字符需要纯数字才能转数字,高精度转低精度,精度会丢失
text='1'
number=int(text)

标识符的命名规则和规范

命名规则

1. 只能出现英文、中文、数字、下划线（_）
2. 区分大小写，
3. 不可使用关键字

命名规范

1. 见名知意
2. 下划线命名法
3. 英文字母全小写

预算符

算术（数字）运算符

运算符	描述	实例
+	加	两个对象相加 a + b 输出结果 30
-	减	得到负数或是一个数减去另一个数 a - b 输出结果 -10
*	乘	两个数相乘或是返回一个被重复若干次的字符串 a * b 输出结果 200
/	除	b / a 输出结果 2
//	取整除	返回商的整数部分 9//2 输出结果 4 , 9.0//2.0 输出结果 4.0
%	取余	返回除法的余数 b % a 输出结果 0
**	指数	a**b 为10的20次方， 输出结果 100000000000000000000

赋值运算符

运算符	描述	实例
=	赋值运算符	把 = 号右边的结果 赋给 左边的变量，如 num = 1 + 2 * 3，结果num的值为7

复合赋值运算符

运算符	描述	实例
+=	加法赋值运算符	c += a 等效于 c = c + a
-=	减法赋值运算符	c -= a 等效于 c = c - a
*=	乘法赋值运算符	c *= a 等效于 c = c * a
/=	除法赋值运算符	c /= a 等效于 c = c / a
%=	取模赋值运算符	c %= a 等效于 c = c % a
**=	幂赋值运算符	c **= a 等效于 c = c ** a
//=	取整除赋值运算符	c //= a 等效于 c = c // a

字符串扩展

字符串的引号嵌套

1. 单引号定义法，可以内含双引号
2. 双引号定义法，可以内含单引号
3. 可以使用转移字符（\）来将引号解除效用，变成普通字符串

字符串拼接

▼
Python
复制代码
name="晓向"
age=18
score=59.5
# 字符串拼接字符串 直接使用+号
print("姓名:"+name)
# 输出:姓名:晓向
"""
    字符串拼接其他变量 
    1.字符串格式化 使用%s
    %  表示：我要占位
    s  表示：将变量变成字符串放入占位的地方
"""
print("姓名:%s,年龄:%d,成绩:%f" % (name,age,score))
# 输出: 姓名:晓向,年龄:18,成绩:59.500000

# 使用f"内容{变量}"的格式来快速格式化
print(f"姓名:{name},年龄:{age},成绩:{score}")
# 输出: 姓名:晓向,年龄:18,成绩:59.5

格式符号	转化
%s	将内容转换成字符串，放入占位位置
%d	将内容转换成整数，放入占位位置
%f	将内容转换成浮点型，放入占位位置

数字的精度控制

▼
Python
复制代码
"""
我们可以使用辅助符号"m.n"来控制数据的宽度和精度
m，控制宽度，要求是数字（很少使用）,设置的宽度小于数字自身，不生效
.n，控制小数点精度，要求是数字，会进行小数的四舍五入
示例：
%5d：表示将整数的宽度控制在5位，如数字11，被设置为5d，就会变成：[空格][空格][空格]11，用三个空格补足宽度。
%5.2f：表示将宽度控制为5，将小数点精度设置为2
      小数点和小数部分也算入宽度计算。如，对11.345设置了%7.2f 后，结果是：[空格][空格]11.35。2个空格补足宽度，小数部分限制2位精度后，四舍五入为 .35
%.2f：表示不限制宽度，只设置小数点精度为2，如11.345设置%.2f后，结果是11.35
"""
num1=11
num2=11.345
print("数字11宽度限制为5.结果: %5d" % num1)
print("数字11宽度限制为1.结果: %1d" % num1)
print("数字11.345宽度限制为5.结果: %7.2f" % num2)
print("数字11.345宽度限制为5.结果: %.2f" % num2)
print("数字1+1= %d" % int(1+1))
"""
输出:
数字11宽度限制为5.结果:    11
数字11宽度限制为1.结果: 11
数字11.345宽度限制为5.结果:   11.35
数字11.345宽度限制为5.结果: 11.35
数字1+1= 2
"""

数据输入

▼
Python
复制代码
"""
input()语句的功能是，获取键盘输入的数据
input(提示信息)，用以在使用者输入内容之前显示提示信息。
无论键盘输入什么类型的数据，获取到的数据永远都是字符串类型
"""
print("你的名字是?")
name=input("请输入你的名字:")
print(f"你好{name}",f"name的数据类型是{type(name)}")
"""
你的名字是?
请输入你的名字:晓向
你好晓向 name的数据类型是<class 'str'>
"""

第三章Python的判断语句

布尔类型

▼
Python
复制代码
"""
布尔类型的字面量：
True  表示真（是、肯定）
False 表示假 （否、否定）
变量声明: 变量名称 = 布尔类型字面量
"""
boole=True

比较运算符

运算符	描述	示例
==	判断内容是否相等，满足为True，不满足为False	如a=3,b=3，则(a == b) 为 True
!=	判断内容是否不相等，满足为True，不满足为False	如a=1,b=3，则(a != b) 为 True
>	判断运算符左侧内容是否大于右侧满足为True，不满足为False	如a=7,b=3，则(a > b) 为 True
<	判断运算符左侧内容是否小于右侧满足为True，不满足为False	如a=3,b=7，则(a < b) 为 True
>=	判断运算符左侧内容是否大于等于右侧满足为True，不满足为False	如a=3,b=3，则(a >= b) 为 True
<=	判断运算符左侧内容是否小于等于右侧满足为True，不满足为False	如a=3,b=3，则(a <= b) 为 True

判断语句的基本使用

if判断

▼
python
复制代码
"""
判断语句的结果，必须是布尔类型True或False
True会执行if内的代码语句
False则不会执行

归属于if判断的代码语句块，需在前方填充4个空格缩进
Python通过缩进判断代码块的归属关系。
"""
name="晓向"
age=18
score=59.5
height=120
if age>=18:
    print(name+"我成年了")
#输出: 晓向我成年了
if age>=6:
    print(name+"我坐车要买票")
else:
    print(name+"我坐车不用买票")
#输出: 晓向我坐车要买票
if score>=90:
    print(name+"我很优秀")
elif score>=60:
    print(name+"我及格了")
else:
    print(name+"我没及格")
#输出: 晓向我没及格

第四章Python循环语句

循环语句的基本使用

while循环

▼
Python
复制代码
"""
1. while的条件需得到布尔类型，True表示继续循环，False表示结束循环
2. 需要设置循环终止的条件，如i += 1配合 i < 100，就能确保100次后停止，否则将无限循环
3. 空格缩进和if判断一样，都需要设置
"""
i = 0
while i < 100:
    print(f"我是第{i}为小黑子")
    i += 1
"""
输出:
我是第0为小黑子
我是第1为小黑子
......
"""

for循环

▼
Python
复制代码
"""
for循环是将字符串的内容：依次取出
所以，for循环也被称之为：遍历循环

同while循环不同，for循环是无法定义循环条件的。
只能从被处理的数据集中，依次取出内容进行处理。
所以，理论上讲，Python的for循环无法构建无限循环（被处理的数据集不可能无限大）
"""
# 定义字符串name
name = "xioaHeiZi"
# for循环处理字符串
for x in name:
       print(x)
"""
x
i
o
a
H
e
i
Z
i
"""

range()语句

▼
Python
复制代码
"""
语法一:range(num)
获取一个从0开始，到num结束的数字序列（不含num本身）
如range(5)取得的数据是：[0, 1, 2, 3, 4]
语法一:range(num1,num2)
获得一个从num1开始，到num2结束的数字序列（不含num2本身）
如，range(5, 10)取得的数据是：[5, 6, 7, 8, 9]
语法一:range(num1,num2,step)
获得一个从num1开始，到num2结束的数字序列（不含num2本身）
数字之间的步长，以step为准（step默认为1）
如，range(5, 10, 2)取得的数据是：[5, 7, 9]
"""
for i in range(5):
       print(i)
"""
输出:
0
1
2
3
4
"""

变量作用域

▼
Python
复制代码
"""
变量作用域:
临时变量，在编程规范上，作用范围（作用域），只限定在for循环内部
如果在for循环外部访问临时变量：
实际上是可以访问到的
在编程规范上，是不允许、不建议这么做的

是编程规范的限定，而非强制限定
不遵守也能正常运行，但是不建议这样做
如需访问临时变量，可以预先在循环外定义它
"""
i=0
for i in range(5):
       print(i)
print(i)

continue和break关键字控制循环

▼
python
复制代码
"""
continue关键字用于：中断本次循环，直接进入下一次循环

break关键字用于：直接结束所在循环

continue和break，在for和while循环中作用一致
在嵌套循环中，只能作用在所在的循环上，无法对上层循环起作用
"""
for i in range(10):
    print("小黑子来了")
    continue
    print("小黑子走了")
"""
输出:
小黑子来了
小黑子来了
......
"""
for j in range(10):
    print("小黑子走了")
    break
"""
输出:
小黑子走了
"""    

第五章函数

什么是函数

组织好的、可重复使用的、用来实现特定功能的代码段

好处是将功能封装在函数内，可供随时随地重复利用提高代码的复用性，减少重复代码，提高开发效率

函数的定义

▼
python
复制代码
# 函数的定义
def 函数名(参数)
	函数体
    return 返回值
# 函数的调用
函数名(参数)
"""
参数如不需要，可以省略
返回值如不需要，可以省略
函数必须先定义后使
"""
def add(num1,num2):
    """
    函数说明文档,说明参数和返回值的解释
    :param num1:数字1
    :param num2:数字2
    :return:int类型的和
    """
    num1=int(num1)
    num2=int(num2)
    return num1+num2
add(1.1,2.2)
"""
返回值None:
None表示：空的、无实际意义的意思
函数返回的None，就表示，这个函数没有返回什么有意义的内容。
也就是返回了空的意思。
"""

变量的作用域

变量作用域指的是变量的作用范围（变量在哪里可用，在哪里不可用）主要分为两类：局部变量和全局变量

▼
python
复制代码
# 局部变量的作用：在函数体内部，临时保存数据，即当函数调用完成后，则销毁局部变量
# 全局变量，指的是在函数体内、外都能生效的变量
# 使用 global关键字 可以在函数内部声明变量为全局变量
num=100
def testA():
    print(num)

def testB():
    # global 关键字声明a是全局变量
    global num
    num=200
    print(num)
testA()
testB()
print(f'全局变量num ={num}')
"""
输出:
100
200
全局变量num =200
"""

第六章数据容器

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

数据容器根据特点的不同，如：是否支持重复元素是否可以修改是否有序，等分为5类，分别是：

列表（list）、元组（tuple）、字符串（str）、集合（set）、字典（dict）

list(列表)

列表的定义

可以容纳多个数据(上限为2**63-1、9223372036854775807个)

可以容纳不同类型的数据(混装)

数据是有序存储的(有下标序号)允许重复数据存在

可以修改(增加或删除元素等)

▼
python
复制代码
"""
    定义空列表
    变量名称=[]
    变量名称=list()
    获取指定位置数据(下标从0开始)
    列表[下标]
"""
list1=[]
list1=list()
"""
    定义变量
    变量名=[元素1,元素2,元素3元素4,...]
"""
list1=["唱","跳","rap","小黑子"]
"""
    获取指定位置数据(下标从0开始)
    列表[下标]
"""
print(list1[0])
# 输出: 唱

列表的方法

编号	使用方式	作用
1	列表.append(元素)	向列表中追加一个元素
2	列表.extend(容器)	将数据容器的内容依次取出，追加到列表尾部
3	列表.insert(下标, 元素)	在指定下标处，插入指定的元素
4	del 列表[下标]	删除列表指定下标元素
5	列表.pop(下标)	删除列表指定下标元素
6	列表.remove(元素)	从前向后，删除此元素第一个匹配项
7	列表.clear()	清空列表
8	列表.count(元素)	统计此元素在列表中出现的次数
9	列表.index(元素)	查找指定元素在列表的下标找不到报错ValueError
10	len(列表)	统计容器内有多少元素

▼
python
复制代码
list1=["唱","跳","rap","小黑子"]
"""
查找某元素的下标
     功能：查找指定元素在列表的下标，如果找不到，报错ValueError
     语法：列表.index(元素)
"""
print(list1.index("rap"))
# 输出: 2
"""
修改特定位置（索引）的元素值：
     语法：列表[下标] = 值
     可以使用如上语法，直接对指定下标（正向、反向下标均可）的值进行：重新赋值（修改）
"""
# 正向下标
list1[3]="小黑子在rap"
print(list1)
# 输出: ['唱', '跳', 'rap', '小黑子在rap']
# 返向下标
list1[-1]="小黑子在唱"
print(list1)
# 输出: ['唱', '跳', 'rap', '小黑子在唱']
"""
插入元素：
     语法：列表.insert(下标, 元素)，在指定的下标位置，插入指定的元素
"""
list1.insert(2,"你干嘛")
print(list1)
# 输出: ['唱', '跳', '你干嘛', 'rap', '小黑子在唱']
"""
追加元素：
     语法：列表.append(元素)，将指定元素，追加到列表的尾部
追加元素方式2：
     语法：列表.extend(其它数据容器)，将其它数据容器的内容取出，依次追加到列表尾部     
"""
list1.append("不要过来啊")
print(list1)
# 输出: ['唱', '跳', '你干嘛', 'rap', '小黑子在唱', '不要过来啊']
list1.extend(["奥德彪","送香蕉"])
print(list1)
# 输出: ['唱', '跳', '你干嘛', 'rap', '小黑子在唱', '不要过来啊', '奥德彪', '送香蕉']
"""
删除元素
    语法1： del 列表[下标]
    语法2：列表.pop(下标)
"""
del(list1[-1])
print(list1)
# 输出: ['唱', '跳', '你干嘛', 'rap', '小黑子在唱', '不要过来啊', '奥德彪']
list1.pop(3)
print(list1)
# 输出: ['唱', '跳', '你干嘛', '小黑子在唱', '不要过来啊', '奥德彪']
"""
删除某元素在列表中的第一个匹配项
     语法：列表.remove(元素)
"""
list1.remove("你干嘛")
print(list1)
# 输出: ['唱', '跳', '小黑子在唱', '不要过来啊', '奥德彪']
"""
统计某元素在列表内的数量
     语法：列表.count(元素)
"""
print(list1.count("奥德彪"))
# 输出: 1
"""
统计列表内，有多少元素
     语法：len(列表)
     可以得到一个int数字，表示列表内的元素数量
"""
print(len(list1))
# 输出: 5
"""
清空列表内容，语法：列表.clear()
"""
list1.clear()
print(list1)
# 输出: []

列表遍历

▼
python
复制代码
"""
while循环和for循环，都是循环语句，但细节不同：
在循环控制上：
while循环可以自定循环条件，并自行控制
for循环不可以自定循环条件，只可以一个个从容器内取出数据
在无限循环上：
while循环可以通过条件控制做到无限循环
for循环理论上不可以，因为被遍历的容器容量不是无限的
在使用场景上：
while循环适用于任何想要循环的场景
for循环适用于，遍历数据容器的场景或简单的固定次数循环场景

"""
while index<len(list1):
    print(list1[index])
    index+=1
    
for i in list1:
    print(i)

tuple(元组)

元组的定义

元组同列表一样，都是可以封装多个、不同类型的元素在内。但最大的不同点在于：

元组一旦定义完成，就不可修改

▼
Python
复制代码
"""
    定义空元组
    变量名称=()
    变量名称=tuple()
"""
tuple1=()
tuple1=tuple()
"""
    元组的变量
    变量名称=(元素,元素,...)
"""
tuple1=("唱","跳","rap","小黑子")

元组的常用操作

编号	方法	作用
1	index()	查找某个数据，如果数据存在返回对应的下标，否则报错
2	count()	统计某个数据在当前元组出现的次数
3	len(元组)	统计元组内的元素个数

str(字符串)

字符串的特点

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

和其它容器如：列表、元组一样，字符串也可以通过下标进行访问从前向后，下标从0开始从后向前，下标从-1开始

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

字符串的常用操作

编号	操作	说明
1	字符串[下标]	根据下标索引取出特定位置字符
2	字符串.index(字符串）	查找给定字符的第一个匹配项的下标
3	字符串.replace(字符串1, 字符串2)	将字符串内的全部字符串1，替换为字符串2不会修改原字符串，而是得到一个新的
4	字符串.split(字符串)	按照给定字符串，对字符串进行分隔不会修改原字符串，而是得到一个新的列表
5	字符串.strip()字符串.strip(字符串)	移除首尾的空格和换行符或指定字符串
6	字符串.count(字符串)	统计字符串内某字符串的出现次数
7	len(字符串)	统计字符串的字符个数

(序列)的切片

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

▼
python
复制代码
"""
序列支持切片，即：列表、元组、字符串，均支持进行切片操作
切片：从一个序列中，取出一个子序列

语法：序列[起始下标:结束下标:步长]
表示从序列中，从指定位置开始，依次取出元素，到指定位置结束，得到一个新序列：
起始下标表示从何处开始，可以留空，留空视作从头开始
结束下标（不含）表示何处结束，可以留空，留空视作截取到结尾
步长表示，依次取元素的间隔
步长1表示，一个个取元素
步长2表示，每次跳过1个元素取
步长N表示，每次跳过N-1个元素取
步长为负数表示，反向取（注意，起始下标和结束下标也要反向标记）

注意，此操作不会影响序列本身，而是会得到一个新的序列（列表、元组、字符串）
"""
my_list = [1, 2, 3, 4, 5]
new_list = my_list[1:4]	# 下标1开始，下标4（不含）结束，步长1
print(new_list)		# 结果：[2, 3, 4]

my_tuple = (1, 2, 3, 4, 5)
new_tuple = my_tuple[:]	# 从头开始，到最后结束，步长1
print(new_tuple)		# 结果：(1, 2, 3, 4, 5)

my_list = [1, 2, 3, 4, 5]
new_list = my_list[::2]		# 从头开始，到最后结束，步长2
print(new_list)		# 结果：[1, 3, 5]

my_str = "12345"
new_str = my_str[:4:2]	# 从头开始，到下标4（不含）结束，步长2
print(new_str)		# 结果："13"

my_str = "12345"
new_str = my_str[::-1]	# 从头（最后）开始，到尾结束，步长-1（倒序）
print(new_str)		# 结果："54321"

my_list = [1, 2, 3, 4, 5]
new_list = my_list[3:1:-1]	# 从下标3开始，到下标1（不含）结束，步长-1（倒序）
print(new_list)		# 结果：[4, 3]

my_tuple = (1, 2, 3, 4, 5)
new_tuple = my_tuple[:1:-2] 	# 从头（最后）开始，到下标1(不含)结束，步长-2（倒序）
print(new_tuple)		# 结果：(5, 3)

set(集合)

集合不支持元素的重复（自带去重功能）、并且内容无序

不支持：下标索引访问

set的定义

▼
Python
复制代码
"""
    定义空集合
    变量名称=set()
"""
set1=set()
"""
    定义集合变量
    变量名称={元素,元素,...}
"""
set1={"唱","跳","rap"}

set的常用操作

编号	操作	说明
1	集合.add(元素)	集合内添加一个元素
2	集合.remove(元素)	移除集合内指定的元素
3	集合.pop()	从集合中随机取出一个元素
4	集合.clear()	将集合清空
5	集合1.difference(集合2)	得到一个新集合，内含2个集合的差集原有的2个集合内容不变
6	集合1.difference_update(集合2)	在集合1中，删除集合2中存在的元素集合1被修改，集合2不变
7	集合1.union(集合2)	得到1个新集合，内含2个集合的全部元素原有的2个集合内容不变
8	len(集合)	得到一个整数，记录了集合的元素数量

dict(字典、映射)

字典，实现用key取出Value的操作

键值对的Key和Value可以是任意类型（Key不可为字典）

字典内Key不允许重复，重复添加等同于覆盖原有数据

字典不可用下标索引，而是通过Key检索Value

字典的定义

▼
python
复制代码
"""
    定义空字典
    变量名称={}
    变量名称=dict()
"""
dict1={}
dict1=dict()
"""
    定义字典变量
    变量名称={key1:value1,key2:value2,...}
"""
dict1={"小黑子":"唱跳",1:2.3}

字典的常用操作

编号	操作	说明
1	字典[Key]	获取指定Key对应的Value值
2	字典[Key] = Value	添加或更新键值对
3	字典.pop(Key)	取出Key对应的Value并在字典内删除此Key的键值对
4	字典.clear()	清空字典
5	字典.keys()	获取字典的全部Key，可用于for循环遍历字典
6	len(字典)	计算字典内的元素数量

数据容器对比总结

数据容器可以从以下视角进行简单的分类：

是否支持下标索引

​ 支持：列表、元组、字符串 - 序列类型

​ 不支持：集合、字典 - 非序列类型

是否支持重复元素：

​ 支持：列表、元组、字符串 - 序列类型

​ 不支持：集合、字典 - 非序列类型

是否可以修改

​ 支持：列表、集合、字典

​ 不支持：元组、字符串

数据容器特点对比

** **	列表	元组	字符串	集合	字典
元素数量	支持多个	支持多个	支持多个	支持多个	支持多个
元素类型	任意	任意	仅字符	任意	Key：ValueKey：除字典外任意类型Value：任意类型
下标索引	支持	支持	支持	不支持	不支持
重复元素	支持	支持	支持	不支持	不支持
可修改性	支持	不支持	不支持	支持	支持
数据有序	是	是	是	否	否
使用场景	可修改、可重复的一批数据记录场景	不可修改、可重复的一批数据记录场景	一串字符的记录场景	不可重复的数据记录场景	以Key检索Value的数据记录场景

容器通用功能

功能	描述
通用for循环	遍历容器（字典是遍历key）
max	容器内最大元素
min()	容器内最小元素
len()	容器元素个数
list()	转换为列表
tuple()	转换为元组
str()	转换为字符串
set()	转换为集合
sorted(序列, [reverse=True])	排序，reverse=True表示降序得到一个排好序的列表

字符串比较

字符串比较从头到尾，一位位进行比较，其中一位大，后面就无需比较了。

单个字符之间通过ASCII码表，确定字符对应的码值数字来确定大小

第七章Python函数进阶

函数多返回值

▼
python
复制代码
"""
按照返回值的顺序，写对应顺序的多个变量接收即可
变量之间用逗号隔开
支持不同类型的数据return
"""
def more_return():
    return 1,2
a,b=more_return()
print(a,b) #结果  1,2

函数多种传参方式

位置参数

▼
python
复制代码
"""
位置参数：调用函数时根据函数定义的参数位置来传递参数
注意：传递的参数和定义的参数的顺序及个数必须一致
"""
def user_info(name,age,score):
    print(f"姓名:{name},年龄:{age},成绩:{score}")

user_info("晓向",18,59)

关键字参数

▼
python
复制代码
"""
关键字参数：函数调用时通过“键=值”形式传递参数.
作用: 可以让函数更加清晰、容易使用，同时也清除了参数的顺序需求.
注意：函数调用时，如果有位置参数时，位置参数必须在关键字参数的前面，但关键字参数之间不存在先后顺序
"""
def user_info(name,age,score):
    print(f"姓名:{name},年龄:{age},成绩:{score}")
# 关键字传参
user_info(name="晓向",age=18,score=59)
# 可以不按照固定顺序
user_info(score=59,name="晓向",age=18)
# 可以和位置参数混用,位置参数必须在前,且匹配参数顺序
user_info("晓向",score=59,age=18)

缺省参数

▼
python
复制代码
"""
缺省参数：缺省参数也叫默认参数，用于定义函数，为参数提供默认值，调用函数时可不传该默认参数的值（注意：所有位置参数必须出现在默认参数前，包括函数定义和调用）.
作用: 当调用函数时没有传递参数, 就会使用默认是用缺省参数对应的值.
注意：函数调用时，如果为缺省参数传值则修改默认参数值, 否则使用这个默认值
"""
def user_info(name,age,score=60):
    print(f"姓名:{name},年龄:{age},成绩:{score}")

user_info("晓向",18)
user_info("晓向",20,88)

不定长参数

▼
python
复制代码
"""
不定长参数：不定长参数也叫可变参数. 用于不确定调用的时候会传递多少个参数(不传参也可以)的场景.
作用: 当调用函数时不确定参数个数时, 可以使用不定长参数
不定长参数的类型:
     ①位置传递
     注意：传进的所有参数都会被args变量收集，它会根据传进参数的位置合并为一个元组(tuple)，args是元组类型，这就是位置传递
     ②关键字传递
    注意：参数是“键=值”形式的形式的情况下, 所有的“键=值”都会被kwargs接受, 同时会根据“键=值”组成字典.
"""
# 位置传递
def user_info(*args):
    print(f"姓名:{args[0]},年龄:{args[1]},成绩:{args[2]}")

user_info("晓向",20,66)
# 关键字传递
def user_info(**kwargs):
    name=kwargs["name"]
    age=kwargs["age"]
    score=kwargs["score"]
    print(f"姓名:{name},年龄:{age},成绩:{score}")

user_info(name="晓向",age=18,score=99)

匿名函数

▼
python
复制代码
"""
函数本身是可以作为参数，传入另一个函数中进行使用的。
将函数传入的作用在于：传入计算逻辑，而非传入数据。
"""
def func(compute):
    result = compute(1,2)
    print(result)

def compute(x,y):
    return x,y

func(compute)

lambda表达式

▼
python
复制代码
"""
匿名函数用于临时构建一个函数，只用一次的场景
匿名函数的定义中，函数体只能写一行代码，如果函数体要写多行代码，不可用lambda匿名函数，应使用def定义带名函数

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

def func(compute):
    result = compute(1,2)

    print(result)

func(lambda x,y:x+y)

第八章Python文件操作

1. 什么是编码？

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

2. 为什么需要使用编码？

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

open()打开函数

▼
python
复制代码
"""
open(name, mode, encoding)
    name：是要打开的目标文件名的字符串(可以包含文件所在的具体路径)。
    mode：设置打开文件的模式(访问模式)：只读、写入、追加等。
    encoding:编码格式（推荐使用UTF-8）
encoding的顺序不是第三位，所以不能用位置参数，用关键字参数直接指定
此时的`f`是`open`函数的文件对象，对象是Python中一种特殊的数据类型，拥有属性和方法，可以使用对象.属性或对象.方法对其进行访问
"""
f = open('python.txt', 'r', encoding="UTF-8")

模式	描述
r	以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。
w	打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，原有内容会被删除。如果该文件不存在，创建新文件。
a	打开一个文件用于追加。如果该文件已存在，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。

读操作相关方法

▼
python
复制代码
"""
read()方法：
    文件对象.read(num)
    num表示要从文件中读取的数据的长度（单位是字节），如果没有传入num，那么就表示读取文件中所有的数据。
readlines()方法：
readlines可以按照行的方式把整个文件中的内容进行一次性读取，并且返回的是一个列表，其中每一行的数据为一个元素。
"""
f = open('python.txt')
content = f.readlines()

# ['hello world\n', 'abcdefg\n', 'aaa\n', 'bbb\n', 'ccc']
print(content)

# 关闭文件
f.close()
"""
readline()方法：一次读取一行内容
"""
f = open('python.txt')

content = f.readline()
print(f'第一行：{content}')

content = f.readline()
print(f'第二行：{content}')

# 关闭文件
f.close()
"""
for循环读取文件行
"""
for line in open("python.txt", "r"):
    print(line)

# 每一个line临时变量，就记录了文件的一行数据

"""
close() 关闭文件对象
"""
f = open("python.txt", "r")

f.close()

# 最后通过close，关闭文件对象，也就是关闭对文件的占用
# 如果不调用close,同时程序没有停止运行，那么这个文件将一直被Python程序占用。
"""
with open 语法
"""
with open("python.txt", "r") as f:
    f.readlines()

# 通过在with open的语句块中对文件进行操作
# 可以在操作完成后自动关闭close文件，避免遗忘掉close方法

操作	功能
文件对象 = open(file, mode, encoding)	打开文件获得文件对象
文件对象.read(num)	读取指定长度字节不指定num读取文件全部
文件对象.readline()	读取一行
文件对象.readlines()	读取全部行，得到列表
for line in 文件对象	for循环文件行，一次循环得到一行数据
文件对象.close()	关闭文件对象
with open() as f	通过with open语法打开文件，可以自动关闭

文件写入

▼
python
复制代码
# 1. 打开文件
f = open('python.txt', 'w')

# 2.文件写入
f.write('hello world')

# 3. 内容刷新
f.flush()
"""
直接调用write，内容并未真正写入文件，而是会积攒在程序的内存中，称之为缓冲区
当调用flush的时候，内容会真正写入文件
这样做是避免频繁的操作硬盘，导致效率下降（攒一堆，一次性写磁盘）
文件如果不存在，使用”w”模式，会创建新文件
文件如果存在，使用”w”模式，会将原有内容清空
"""

# 1. 打开文件，通过a模式打开即可
f = open('python.txt', 'a')

# 2.文件写入
f.write('hello world')

# 3. 内容刷新
f.flush()

"""
a模式，文件不存在会创建文件
a模式，文件存在会在最后，追加写入文件
"""

第九章Python异常模块与包

异常:当检测到一个错误时，Python解释器就无法继续执行了，反而出现了一些错误的提示，这就是所谓的“异常”, 也就是我们常说的BUG

异常捕获

▼
python
复制代码
"""
捕获异常基本语法
try:
    可能发生错误的代码
except:
    如果出现异常执行的代码
"""
try:
    f = open('linux.txt', 'r')
except:
    f = open('linux.txt', 'w')
"""
捕获指定异常
① 如果尝试执行的代码的异常类型和要捕获的异常类型不一致，则无法捕获异常。
② 一般try下方只放一行尝试执行的代码。
"""
try:
    print(name)
except NameError as e:
    print('name变量名称未定义错误')
"""
捕获多个异常
"""
try:
    print(1/0)
except (NameError, ZeroDivisionError):
    print('ZeroDivision错误...')
"""
捕获异常并输出描述信息
"""
try:
    print(num)
except (NameError, ZeroDivisionError) as e:
    print(e)
   
"""
捕获所有异常
"""
try:
    print(name)
except Exception as e:
    print(e)
"""
异常else
""" 
try:
    print(1)
except Exception as e:
    print(e)
else:
    print('我是else，是没有异常的时候执行的代码')
"""
异常的finally
"""       
try:
    f = open('test.txt', 'r')
except Exception as e:
    f = open('test.txt', 'w')
else:
    print('没有异常，真开心')
finally:
    f.close()
    

异常的传递性

▼
python
复制代码
"""
异常是具有传递性的

当函数func01中发生异常, 并且没有捕获处理这个异常的时候, 异常
会传递到函数func02, 当func02也没有捕获处理这个异常的时候
main函数会捕获这个异常,  这就是异常的传递性.
当所有函数都没有捕获异常的时候, 程序就会报错
"""
def func01():# 异常在funco1中没有被捕获
    print("这是func01开始")
    num=1/0
    print("这是func01结束")
    #异常在funco2中没有被捕获
def func02():
    print("这是func02开始")
    func01()
    print("这是func02结束")
def main():#异常在mian中被捕获
    try:
        func02()
    except Exception as e:
        print(e)
main()

Python的模块与包

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

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

▼
python
复制代码
"""
模块的导入方式
[form 模块名] import [模块|类|变量|函数|*][as 别名]
常用的组合形式如：
import 模块名
from 模块名 import 类、变量、方法等
from 模块名 import *
import 模块名 as 别名
from 模块名 import 功能名 as 别名
基本语法
	import 模块名
	import 模块名1，模块名2

	模块名.功能名()
"""
# 导入时间模块
import time

print("开始")
# 让程序睡眠1秒(阻塞)
time.sleep(1)
print("结束")

自定义模块

每个Python文件都可以作为一个模块，模块的名字就是文件的名字. 也就是说自定义模块名必须要符合标识符命名规则

▼
python
复制代码
def test(a, b):
    print(a + b)

# 只在当前文件中调用该函数，其他导入的文件内不符合该条件，则不执行test函数调用
if __name__ == '__main__':
    test (1, 1)

当导入多个模块的时候，且模块内有同名功能. 当调用这个同名功能的时候，调用到的是后面导入的模块的功能

▼
python
复制代码
# 模块1代码
def my_test(a,b):
	print(a + b)
# 模块2代码
def my_test(a,b):
    print(a-b)
# 导入模块和调用功能代码
from my_modulel import my_test
from my_module2 import my_test
# my_test函数是模块2中的函数
my_test(1，1)

如果一个模块文件中有__all__变量，当使用from xxx import *导入时，只能导入这个列表中的元素

Python包的定义

从物理上看，包就是一个文件夹，在该文件夹下包含了一个 init.py 文件，该文件夹可用于包含多个模块文件从逻辑上看，包的本质依然是模块

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

新建包后，包内部会自动创建__init__.py文件，这个文件控制着包的导入行为

▼
Python
复制代码
"""
导入包的方式一:
import 包名.模块名

包名.模块名.目标
"""
import my_package.my_module1
import my_package.my_module2
# 包中的my_module1模块的info_print1()方法
my_package.my_module1.info_print1()
# 包中的my_module1模块的info_print2()方法
my_package.my_module2.info_ print2()

"""
导入包的方式一:
from 包名 import *
模块名.目标
必须在`__init__.py`文件中添加`__all__ = []`，控制允许导入的模块列表
"""

安装第三方包

在命令提示符下输入

▼
text
复制代码
pip install 包名称

修改网络连接地址

▼
text
复制代码
pip install -i https://pypi.tuna.tsinghua.edu.cn/simple 包名称

第十章Python面向对象

类的定义和使用

▼
Python
复制代码
"""
class 类名称:
	类的属性
	
	类的行为
class是关键字，表示要定义类了
类的属性，即定义在类中的变量（成员变量）
类的行为，即定义在类中的函数（成员方法）

创建对象的语法
对象 =类名称()
"""
class Student:
    name=None
    age=None
    
    def say_hi(self):
		print(f"Hi大家好,我是{self.name}")    

stu=Student()
stu.name="晓向"
stu.say_hi()
"""
类中定义的属性（变量），我们称之为：成员变量
类中定义的行为（函数），我们称之为：成员方法
成员方法的定义:
	def 方法名(self,形参1,形参...)
		方法体
		
	self必须填写,表示对象本身,调用成员方法时会自动传入	
"""

构造方法和其他内置方法

▼
Python
复制代码
"""
在创建类对象（构造类）的时候，会自动执行。
在创建类对象（构造类）的时候，将传入参数自动传递给__init__方法使用。
"""
class Student:

    def __init__(self,name,age):
        self.name=name
        self.age=age
        
stu = Student("晓向",18)  

方法	功能
init	构造方法，可用于创建类对象的时候设置初始化行为
str	用于实现类对象转字符串的行为
lt	用于2个类对象进行小于或大于比较
le	用于2个类对象进行小于等于或大于等于比较
eq	用于2个类对象进行相等比较

封装

▼
python
复制代码
"""
私有成员变量：变量名以__开头（2个下划线）
私有成员方法：方法名以__开头（2个下划线）
"""
class Phone:
    IMEI=None
    prducer=None

    __current_voltage =None
    def call_by_5g(selfself):
        print("5g通话已开启")
    def __keep_single_core(selfself):
        print("让CPU以单核模式运行以节省电量")

继承

▼
Python
复制代码
"""
方式1：
调用父类成员
     使用成员变量：父类名.成员变量
     使用成员方法：父类名.成员方法(self)

方式2：
使用super()调用父类成员
     使用成员变量：super().成员变量
     使用成员方法：super().成员方法()
"""
class Phone2024(Phone):

    def call_by_5g(self):
        super().call_by_4g()
        print("2022最新5g通话")

phone1=Phone2024()
phone1.call_by_5g()

类型注解

类型注解：在代码中涉及数据交互的地方，提供数据类型的注解（显式的说明）。 主要功能： 帮助第三方IDE工具（如PyCharm）对代码进行类型推断，协助做代码提示 帮助开发者自身对变量进行类型注释

支持： 变量的类型注解 函数（方法）形参列表和返回值的类型注解

▼
Python
复制代码
"""
基础语法：  变量: 类型
"""
var_1:int =10
var_2:float=3.1415926
var_3:boo7= True
var_4:str ="晓向"

class student:
    pass
stu:student=student()

my_list:list=[1,2,3]
my_tuple:tuple=(1,2,3)
my_set:set={1,2,3}
my_dict:dict={itheima:"666"}
my_str:str ="晓向"

my_list:list[int]=[1,2,3]
my_tuple:tuple[str,int,bool]=("itheima",666,True)
my_set:set[int]={1,2,3}
my_dict: dict[str,int]={"晓向": 666}

"""
类型注解主要功能在于：
帮助第三方IDE工具（如PyCharm）对代码进行类型推断，协助做代码提示
帮助开发者自身对变量进行类型注释（备注）

并不会真正的对类型做验证和判断。
也就是，类型注解仅仅是提示性的，不是决定性的

如图代码，是不会报错的哦。
"""
"""
函数类型注解:
	def 函数方法名(形参名:类型，形参名:类型,.....):
		pass
"""
def add(x:int,y:int):
	return x
"""
函数类型注解返回值
def 函数方法名(形参:类型,....·，形参:类型)->返回值类型
	pass
"""
def add(x:int,y:int)-> int:
	return x

"""
使用Union[类型, ......, 类型]
可以定义联合类型注解
"""
from typing import union
my_list:list[union[str,int]]=[1,2,"itheima", "itcast"]
my_dict: dict[str, union[str, int]]= {"name":“周杰轮”,"age": 31}

多态

多态，指的是：多种状态，即完成某个行为时，使用不同的对象会得到不同的状态。

▼
Python
复制代码
"""
抽象类：含有抽象方法的类称之为抽象类
抽象方法：方法体是空实现的（pass）称之为抽象方法
"""
class Animal:
    def speak(self):
        pass
class Dog(Animal):
    def speak(self):
        print("汪汪汪")
class cat(Animal):
    def speak(self):
        print("喵喵喵”)