https://www.bilibili.com/video/BV1qW4y1a7fU/?p=12&spm_id_from=pageDriver&vd_source=db3d134c564b091aeb95550baf2fa5b0
第一阶段
01-python入门介绍
初始python
什么是编程语言
python安装
第一个python程序
print('hello world!')
扩展
1、cmd找不到：win+r、输入cmd
2、输入python，显示不是内部或外部命令，也不是可运行的程序或批处理文件：安装python时没有勾选add python to PATH；可以卸载重新安装
python解释器
计算机只认识二进制
python解释器：将python代码翻译成二进制
python环境就是python解释器程序
python解释器：是一个计算机程序，用来翻译python代码，并提交给计算机执行——翻译、执行
python.exe就是python解释器程序
python开发环境
python解释器
python解释器程序
pycharm
02-python基础语法
字面量
-
字面量：被写下来的固定的值
-
常见值类型：
- 数字（整数int、浮点数float、复数complex、布尔bool）
- 字符串（string）
- 列表（list）
- 元组（tuple）
集合（set）
- 字典（dict）
a = 999
b = 1.2
c = 'hello world'
print(a, b, c)
注释
-
注释作用：
-
注释分类：
-
单行注释
-
# 我是单行注释
-
多行注释
-
"""
我是多行注释
多行注释
"""
变量
变量：能村粗计算结果或能表示值得抽象概念
变量名称=变量的值（=：赋值）
money = 50
print(money)
money = money - 10
print(money)
数据类型
使用type()查看数据类型
a=10
print(type(a))
# <class 'int'>
数据类型转换
int()
float()
str()
a = 10
b = int(a)
c = float(a)
d = str(a)
print(type(b), b)
print(type(c), c)
print(type(d), d)
标识符
-
内容限定
- 只允许出现英文、中文、数字、下划线，不能以数字开头
-
大小写敏感
-
不可使用关键字
变量命名规范：见名知意、下划线命名法、英文字母全小写
# 内容限定 只允许出现英文、中文、数字、下划线，不能以数字开头
# 1_name=10
name = 10
name_1 = 10
_name = 10
# 大小写敏感
andy = 999
Andy = 666
print(andy, Andy)
# 不可使用关键字
# if=10
运算符
算数运算符
+、-、*、/、//（取整除）、%、**（指数）
赋值运算符
=
复合赋值运算符
+=、-=、*=、/=、//=、%=、**=
# 算术运算符
print("1+1=", 1 + 1)
print("2-1=", 2 - 1)
print("3*3=", 3 * 3)
print("4/2=", 4 / 2)
print("11//2=", 11 // 2)
print("9%2=", 9 % 2)
print("4**4=", 4 ** 4)
# 赋值运算符
num = 1 + 2 + 3
# 复合赋值运算符
n = 1
n += 1 # n=n+1
print("n+=1", n)
n-=1
print("n-=1",n)
n*=4
print('n*=4',n)
n/=2
print('n/=2',n)
字符串扩展
-
字符串得三种方式：
-
字符串拼接
-
字符串格式化
-
name='黑马'
mes='学it:%s'%name
print(mes）
#学it:黑马
-
n = 57
s = 12243543
mes = "python,北京%s期毕业工资：%s" % (n, s)
print(mes)
#python,北京57期毕业工资：12243543
-
%s：字符串
-
%d：整数
-
%f：浮点数
-
格式化得精度控制
-
字符串格式化方式2
-
对表达式进行格式化
数据输入
input()
a=input()
print(a)
03-python判断语句
布尔类型和比较运算符
True、False
==、!=、>、<、>=、<=
# 定义变量存储布尔类型的数据
bool_1 = True
bool_2 = False
print(f'bool_1的内容是：{bool_1},类型是：{type(bool_1)}')
print(f'bool_2的内容是：{bool_2},类型是：{type(bool_2)}')
# 比较运算符的使用
# == != > < >= <=
n1 = 10
n2 = 10
print(n1 == n2)
n1 = 10
n2 = 15
print(n1 != n2)
n1 = 'dsds'
n2 = 'dsdsada'
print(n1 == n2)
# 演示> < >= <=
n1 = 10
n2 = 5
print(n1 > n2)
print(n1 < n2)
n1 = 10
n2 = 11
print(n1 >= n2)
print(n1 <= n2)
if语句
语法：
if 条件成立: # 注意冒号
代码块 # 注意缩进
例子：
age=30
if age>=18:
print('我已经成年了')
print('时间过得真快')
案例：
"""
结合前面所学的input输入语句，完成案例：
1、通过input语句，获取键盘输入，为变量age赋值
2、通过if语句判断是否成年，满足则输出提示信息，如下：
欢迎来到游乐场，儿童免费，成人收费
请输入您的年龄：30
您已成年，游玩需要补票10元。
祝你游玩愉快
"""
print('欢迎来到游乐场，儿童免费，成人收费')
age = int(input('请输入您的年龄:'))
if age > 18:
print('您已成年，游玩需要补票10元。')
print('祝你游玩愉快')
if else语句
语法：
if 条件:
代码块
else:
代码块
例子：
print('欢迎来到游乐场，儿童免费，成人收费')
age = int(input('请输入您的年龄:'))
if age > 18:
print('您已成年，游玩需要补票10元。')
else:
print('您未成年，可以免费游玩')
print('祝你游玩愉快')
案例：
"""
通过input语句获取键盘输入的身高
判断身高是否超过120cm，并通过print给出提示信息
欢迎来到到动物园
请输入你的身高（cm）:130
您的身高超出120，游玩需购票19元
祝你愉快
/
欢迎来到到动物园
请输入你的身高（cm）:111
您的身高未超出120，可以免费游玩
祝你愉快
"""
print('欢迎来到到动物园')
height=int(input('请输入你的身高（cm）:'))
if height>120:
print('您的身高超出120，游玩需购票10元')
else:
print('您的身高未超出120，可以免费游玩')
print('祝你愉快')
if elif else语句
语法：
if 条件1:
代码块
elif 条件2:
代码块
elif 条件3:
代码块
...
else:
代码块
例子：
print('欢迎来到到动物园')
height=int(input('请输入你的身高（cm）:'))
vip_level=int(input('请输入你的vip级别(1~5):'))
if height<120:
print('您的身高未超出120，可以免费游玩')
elif vip_level>3:
print('您的vip级别>3，可以免费游玩')
else:
print('不好意思，所有条件不满足，需要支付10票价')
print('祝你愉快')
案例：
"""
定义一个变量，数字类型，内容随意
判断是否一致
请输入第一次猜想的数字:1
不对，再猜一次：2
不对，最后再猜一次：3
不好意思，全错，我想的是：10
"""
n = 5
input_n1 = int(input('请输入第一次猜想的数字:'))
input_n2 = int(input('不对，再猜一次:'))
input_n3 = int(input('不对，最后再猜一次：'))
if input_n1 == n:
print('猜对了')
elif input_n2 == n:
print('猜对了')
elif input_n3 == n:
print('猜对了')
else:
print(f'不好意思，全错，我想的是：{n}')
判断语句的嵌套
语法：
if 条件1:
代码块
if 条件2:
代码块
例子：
print('欢迎来到到动物园')
# height = int(input('请输入你的身高（cm）:'))
# vip_level = int(input('请输入你的vip级别(1~5):'))
if int(input('请输入你的身高（cm）:')) > 120:
print('您的身高超出120，不可以免费游玩')
print('不过如果你的vip级别大于3，可以免费游玩')
if int(input('请输入你的vip级别(1~5):')) > 3:
print('您的vip级别>3，可以免费游玩')
else:
print('不好意思，所有条件不满足，需要支付10票价')
else:
print('祝你愉快')
实战
"""
定义一个数字（1~10，随机产生），通过3次判断来猜数字
要求：
1、数字随机产生（1~10）
2、有3次机会猜数字，嵌套来实现
3、每次猜不中，会提示大了或小了
提示：
通过下列代码，可以定义一个变量num，变量内存储随机数字
import random
num=random.randint(1,10)
"""
print('猜数字小游戏')
# 定义随机数
import random
num = random.randint(1, 10)
input_n1 = int(input('请输入数字:'))
# 中、大、小
if input_n1 == num:
print('第一次就猜对了')
else:
if input_n1 > num:
print('大了')
else:
print('小了')
input_n1 = int(input('请再次输入数字:'))
if input_n1 == num:
print('第二次就猜对了')
else:
if input_n1 > num:
print('大了')
else:
print('小了')
04-python循环语句
while循环的基础语法
语法：
while 条件:
代码块（条件成立所运行的代码）
例子：
i = 0
while i < 100:
print('I LOVE YOU')
i += 1
案例：
"""
通过while循环，计算1累加到100的和
"""
i = 1
sum = 0
while i <= 100:
sum += i
i += 1
print(sum)
while循环的基础案例
"""
设置一个范围1-100的随机整数变量，通过while循环，配合input语句，判断输入的数字是否等于随机数
要求：
1、无限次机会，直到猜中为止
2、每一次猜不中，提示大了或小了
3、猜完数字后，提示猜了几次
提示：
无限次机会，终止条件不适合用数字累加来判断
可以考虑布尔
需要提示几次猜中
"""
import random
num = random.randint(1, 100)
sum = 0
flag = True
while flag:
n = int(input('请输入数字(1-100):'))
sum += 1
if n == num:
print('猜中了')
flag = False
else:
if n > num:
print('大了')
else:
print('小了')
print(f'一共猜了{sum}次')
while循环的嵌套应用
语法：
while 条件1:
代码块
while 条件2:
代码块
例子：
i = 1
while i <= 100:
print(f'今天是第{i}天，准备表白。。。')
j = 1
while j <= 10:
print(f'送了第{j}只玫瑰花')
j += 1
print('I LOVE YOU ')
i += 1
print('表白成功')
补充知识
print输出不换行:
print('hello')
print('world!')
# hello
# world!
print('hello', end="")
print('world!', end="")
# helloworld!
制表符 \t：
\t等同于tab键，可以实现多行字符串进行对齐
print('hello world!')
print('sjdosos sdlasad')
# hello world!
# sjdosos sdlasad
print('hello\tworld!')
print('sjdosos\tsdlasad')
# hello world!
# sjdosos sdlasad
while循环的嵌套案例
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-sl3TndqN-1673768832032)(assets/python基础2.asset/image-20221230170355659.png)]
1、控制行的循环 i<=9
2、控制每一行输出的循环 j<=i
3、每一行内容 j*i
"""
九九乘法表
"""
i = 1
while i <= 9:
j = 1
while j <= i:
print(f'{j}*{i}={j * i}\t', end="")
j += 1
i += 1
print() # print空就是输出一个换行
for循环的基础语法
轮询机制、逐个处理
语法：
for 临时变量 in 待处理数据集
代码块
例子：
# for循环 遍历字符串
str='result'
for x in str:
print(x)
# r
# e
# s
# u
# l
# t
案例：
"""
定义字符串变量name，内容为'I LOVE YOU JESTING'
通过for循环遍历字符串，统计有多少个英文字母：‘O’
"""
name='I LOVE YOU JESTING'
sum=0
for i in name:
if i=='O':
sum+=1
print(sum)
range语句：
for循环语句，本质上是遍历：序列类型
语法1：
range(num)
# 获取一个从0开始，到num结束的数字序列（不含num本身）
# 如：range(5)，获取到的是[0,1,2,3,4]
语法2:
range(num1,num2)
# 获取一个从num1开始，到num2结束的数字序列（不含num2）
# 如：range(5,10),则[5,6,7,8,9]
语法3：
range(num1,num2,step)
# 获取一个从num1开始，到num2结束的数字序列（不含num2）
# 数字之间的步长，以step为准（step默认为1）
# 如：range(5,10,2),则[5,7,9]
例子：
# 语法1
for x in range(10):
print(x)
# 0
# 1
# 2
# 3
# 4
# 5
# 6
# 7
# 8
# 9
# 语法2
for x in range(5,10):
print(x)
# 5
# 6
# 7
# 8
# 9
# 语法3
for x in range(5,10,2):
print(x)
# 5
# 7
# 9
循环临时变量作用域：
限定为循环内
案例：
"""
定义一个数字变量num，内容随意
并使用range()语句，获取1-num的序列，使用for循环遍历它
并统计多少偶数的出现
提示：
偶数：判断数字余2是否为0即可
"""
n=123
sum=0
for x in range(1,n):
if x%2==0:
print(x)
sum+=1
print(sum)
for循环的嵌套应用
语法：
for 临时变量 in 待处理数据（序列）:
代码块
for 临时变量 in 待处理数据（序列）:
代码块
例子：
# 坚持表白100天，每天送10朵玫瑰花
for x in range(1,101):
print(f'今天是第{x}天，坚持！！！！')
for i in range(1,11):
print(f'第{i}朵玫瑰')
print(f'第{x}天表白成功')
案例：
"""
使用for 打印九九乘法表
"""
for i in range(1, 10):
for j in range(1, i + 1):
print(f'{j}*{i}={j * i}\t', end="")
print()
循环中断：continue、break
continue：中断本次循环
break：直接结束循环
综合案例
"""
某公司，账户余额1w元，给20位员工发工资
员工编号从1-20.从编号1开始，每人可领取1000元
领工资时，财务判断员工的绩效（1-10）（随机生成），如果低于5，不发工资，换下一位
如果工资发完了，结束发工资
"""
money=10000
for i in range(1,21):
import random
score=random.randint(1,10)
if score<5:
print(f'员工{i}绩效为{score}，不满足，不发工资，下一位')
continue
if money>=1000:
money-=1000
print(f'员工{i}绩效为{score}，满足，发工资，公司账户余额{money}')
else:
print('公司账户余额不足，下个月再发')
break
05-python函数
函数介绍
函数：是组织好的、可重复使用的，用来实现特定功能的代码段
比如：len()内置函数是用来统计长度
# 统计字符串长度，不使用len()
# s1 = 'dsdsfsfd'
#
# sum = 0
# for x in s1:
# sum += 1
# print(sum)
def len_1(s):
sum = 0
for x in s:
sum += 1
print(sum)
len_1('ssadsadsada')
len_1('sss')
len_1('sdfg')
优雅
方便使用
提高复用性、减少重复性代码、提高效率
函数的定义
函数定义语法：
def 函数名(传入参数):
函数题
return 返回值
函数调用语法：
函数名(传入参数)
注意：
参数、返回值可以省略
例子：
# 定义函数
def say_hi():
print('hello wolrd!')
# 调用函数
say_hi()
案例：
"""
定义一个函数，函数名任意，要求调用函数后输出以下内容：
欢迎光临
请出示行程码和健康码
"""
def func():
print('欢迎光临')
print('请出示行程码和健康码')
func()
函数的参数
传入参数功能：在函数计算时，接受外部提供的数据
使用：
def add(n1, n2):
res = n1 + n2
print(f'{n1}+{n2}={res}')
add(1, 2)
注意：
函数定义中的参数称为形式参数
函数调用中的参数称为实际参数
参数不限
传入参数的时候，要和形式参数一一对应
案例：
"""
定义一个函数，名称任意，并接受一个参数传入（数字类型，表示体温）
再函数内进行提问判断（正常范围：小于等于37.5）并输出如下内容：
欢迎光临，请出示行程码和健康码，并配合测量体温
您的体温为：36.5，体温正常，请进
您的体温为：37.9，体温异常，隔离
"""
def check(tem):
print('欢迎光临，请出示行程码和健康码，并配合测量体温')
if tem<37.5:
print(f'您的体温为：{tem}，体温正常，请进')
else:
print(f'您的体温为：{tem}，体温异常，隔离')
check(34.5)
函数的返回值
返回值：就是程序中函数完成事情后，最后给调用者的结果
语法：
def 函数名(传入参数):
函数题
return 返回值
变量=函数(参数)
注意：
函数体在遇到return后结束了，所有return后的代码不运行
None类型：
如果函数没有使用return，函数会有返回值吗？——有的
None：表示空的、无实际意义
def hi():
print('hi')
res1=hi()
print(res1)
print(type(res1))
# None
# <class 'NoneType'>
使用场景：
用在函数无返回值上
用在if上：None同等于False
用于声明无初始值的变量
函数说明文档
说明文档：辅助理解函数的作用
语法：
def func(x,y):
"""
函数说明
:param x: 形参x的说明
:param y: 形参y的说明
:return: 返回值的说明
"""
函数体
return 返回值
函数的嵌套调用
函数嵌套调用：在一个函数里又调用另一个函数
语法：
def fun1():
print('1')
def fun2():
print('2')
fun1()
print('3')
fun2()
变量的作用域
变量作用域：变量的作用范围（变量在哪里可用，在哪里不可以）
类别：局部变量和全局变量
局部变量：定义在函数体内部的变量，及只在函数体内生效
def test1():
num=100
print(num)
test1()
print(num)
# 100
# NameError: name 'num' is not defined. Did you mean: 'sum'?
全局变量：在函数体内、外都能生效
num = 100
def test1():
print(f'内部:{num}')
test1()
print(f'外部:{num}')
# 内部:100
# 外部:100
global关键字：将函数内定义的变量声明为1全局变量
语法：
global 变量
综合案例
06-python数据容器
数据容器
一个变量，完成多个数据的记录
数据容器：一个可以容纳多份数据的数据类型，容纳的每一个数据称为1个元素，每一个元素可以是任意的数据，如字符串、数字、布尔等。
数据容器根据特点的不同，如：
是否支持重复元素；是否可以修改；是否有序；等
分类五类：
列表（list）、元组（tuple）、字符串（str）、集合（set）、字典（dict）
list（列表）
列表的定义：
使用[]定义列表
name_list=['andy','mike','jack','python']
print(name_list)
print(type(name_list))
# ['andy','mike','jack','python']
# <class 'list'>
列表的下标索引：
下标索引：0，1，2，3…
反向索引：…、-5、-4、-3、-2、-1
列表[下标索引]
# 下标索引
name_list = ['a', 'b', 'ssd', 'das']
print(name_list[0])
print(name_list[1])
print(name_list[2])
print(name_list[3])
# a
# b
# ssd
# das
# 反向索引
name_list = ['a', 'b', 'ssd', 'das']
print(name_list[-1])
print(name_list[-2])
print(name_list[-3])
print(name_list[-4])
# das
# ssd
# b
# a
列表的常用操作
index方法
列表.index(元素)
# 返回元素的下标
修改元素
列表[下标]=值
插入 insert
列表.insert(下标,元素)
追加元素 append extend
列表.append(元素)
# 在尾部追加
列表.extend(其他数据容器) # 追加一批
删除元素、清空列表
del 列表[下标]
列表.pop(下标)
列表.remove(元素)
# 删除列表的第一个匹配项
列表.clear()
# 列表清空
统计某元素在列表的数量
列表.count(元素)
统计列表有多少个元素
len(列表)
练习：
"""
有一个列表，内容是：[21,25,21,23,22,20]，记录的是一批学生的年龄
请通过列表的功能（方法），对其进行：
1、定义这个列表，并用变量接受它
2、追加一个数字31到列表的尾部
3、追加一个新列表[29,33,30]
4、取出第一个元素（应是：21）
5、取出最后一个元素（应是：30）
6、查找元素31.在列表的下标位置
"""
ages = [21,25,21,23,22,20]
print(ages)
ages.append(31)
print(ages)
ages.extend([29,33,30])
print(ages)
first=ages[0]
print(first)
last=ages[-1]
print(last)
index_31=ages.index(31)
print(index_31)
list的遍历
遍历：依次取出列表中的每一个元素
whiel遍历：
index=0
while index<len(列表):
元素=列表[index]
代码块
index+=1
for遍历：
for 临时变量 in 列表：
代码块
def while_func():
li=['z','s','s','a']
index=0
while index<len(li):
print(li[index])
index+=1
def for_func():
li=['z','s','s','a']
for index in li:
print(index)
# while_func()
for_func()
tuple（元组）
元组不可修改
元组的定义格式：
使用小括号，逗号隔开
# 定义元组字面量
(元素，元素，元素...元素)
# 定义元组变量
变量名=(元素，元素，元素...元素)
# 定义空元组
变量名=()
变量名=tuple()
元组的特点：（和list不同就是不可修改）
可以容纳多个元素
可以容纳不同类型的数据
数据是有序存储的
允许重复数据存在
不可以修改
支持for循环
元组的常见操作：
index()
count()
len()
注意事项：
不可修改元组的内容，否则报错
可以修改元组内的list内容
str（字符串）
字符串是字符的容器
字符串的下标索引：从前向后，下标从0开始；从后向前，下标从-1开始。
字符串不可修改。
字符串的常用操作：
.index()
.replace(字符串1，字符串2) 字符串1替换为字符串2
.split(分割符字符串) 字符串的分割
.strip() 字符串的规整操作（去前后空格）
.strip(字符串) 去前后指定字符串
.count()
len()
字符串特点：
只存储字符串
不可以修改
序列的切片
序列支持切片，即：列表、元组、字符串，均支持进行切片操作
切片：从一个序列中，取出一个子序列
语法：序列[起始下标；结束下标；步长]
表示从序列中，从指定位置开始，依次取出元素，到指定位置结束，得到新序列。
起始下标：表示从何处开始，可以留空，留空即从头开始
结束下标：表示到何处为止（不含），可以留空，留空即取到结尾
步长：表示取得间隔
set（集合)
语法：
# 定义集合字面量
{元素1,元素2,...,元素}
# 定义集合变量
变量名称={元素1,元素2,...,元素}
# 定义空集合
变量名称=set()
修改:
集合不支持下标索引
- add() 添加新元素
- remove() 移除元素
- pop() 随机取出元素
- clear() 清空元素
- 集合1.difference(集合2) 取2个集合的差集
- 结果：得到一个新集合，集合1和集合2不变
- 功能：集合1有而集合2没有的
- 集合1.difference_update(集合2) 消除2个集合的差集
- 功能：对比集合1和集合2，在集合1内，删除和集合2相同的元素
- 结果：集合1被修改，集合2不变
- 集合1.union(集合2) 2个集合合并
- 功能：将集合1和集合2组合成新集合
- 结果：得到新集合，集合1和集合2不变
dict（字典）
生活中的字典：通过字，就能找到对应的含义。
python中的字典：可以按【key】找出对应的【value】。
字典的定义：使用{}，键值对,如下：
# 定义字典字面量
{key:value,key:value,...,key:value}
# 定义字典变量
d1={key:value,key:value,...,key:value}
# 定义空字典
d1={}
d2=dict()
字典内key不允许重复，重复添加等同于覆盖原有数据
字典数据的获取：通过key获取value
字典的嵌套：多层字典
字典的常用操作：
新增元素
语法：字典[key]=value
结果：字典被修改，新增了元素
例子：
my_dict = {'小周': 99, '小林': 88, '小华': 77}
my_dict['小郑'] = 66
print(my_dict)
更新元素
语法：字典[key]=value
结果：字典被修改，元素被更新
例子：
my_dict = {'小周': 99, '小林': 88, '小华': 77}
my_dict['小周'] = 33
print(my_dict)
元素删除：
语法：字典.pop(key)
结果：获取指定的key的value，同时字典被修改，指定key的数据被删除。
my_dict = {'小周': 99, '小林': 88, '小华': 77}
sc=my_dict.pop('小周')
print(sc)
print(my_dict)
清空元素：
语法：字典.clear()
my_dict.clear()
print(my_dict)
获取全部的key：
语法：字典.keys()
结果：得到全部key
my_dict = {'小周': 99, '小林': 88, '小华': 77}
keys=my_dict.keys()
print(keys)
统计元素数量：len(字典)
字典的特点：
可以容纳多个数据
可以容纳不同的数据
每一份数据都是键值对
可以通过key获取value
不支持下标索引
可以修改
支持for循环
总结对比
-
分类
- 是否支持下标索引：
- 支持：列表、元组、字符串——序列类型
- 不支持：集合、字典——非序列类型
- 是否支持重复元素：
- 支持：列表、元组、字符串——序列类型
- 不支持：集合、字典——非序列类型
- 是否可以修改
-
特点对比
|
列表 |
元组 |
字符串 |
集合 |
字典 |
| 元素数量 |
多个 |
多个 |
多个 |
多个 |
多个 |
| 元素类型 |
任意 |
任意 |
仅字符 |
任意 |
键值对（key:value) |
| 下标索引 |
支持 |
支持 |
支持 |
不支持 |
不支持 |
| 重复元素 |
支持 |
支持 |
支持 |
不支持 |
不支持 |
| 可修改性 |
支持 |
不支持 |
不支持 |
支持 |
支持 |
| 数据有序 |
有序 |
有序 |
有序 |
无序 |
无序 |
| 使用场景 |
可修改、可重复的一批数据记录场景 |
不可修改、可重复的一批数据记录场景 |
一串字符的记录场景 |
不可重复的数据记录场景 |
以key检索value的数据记录场景 |
通用操作
for循环遍历
len()
max()
min()
通用容器类型转换
list()
str()
tuple()
set()
通用排序
sorted(容器,[reverse=True])
li = [2, 6, 1, 7, 9, 5]
print(sorted(li, reverse=True))
print(sorted(li, reverse=False))
字符串大小比较
ASCII码
07-python函数进阶
函数多多返回值
语法：
def func():
return 1,2
x,y=func()
print(x,y)
函数多种传参方式
位置参数
位置参数：调用函数时根据函数定义的参数位置来传递参数
def f(name,age,gender):
print(name,age,gender)
f('tom',20,'男')
关键字参数
关键字参数：函数调用时通过“键=值”形式传递参数
def f(name,age,gender):
print(name,age,gender)
# 关键字参数
f(name='jack',age=20,gender='男')
# 无先后顺序
f(age=20,name='mike',gender='男')
# 和位置参数进行混用
f('jes',age=21,gender='女')
注意：函数调用时如果有位置参数，位置参数必须在关键字参数的前面，但关键字参数之间不存在先后顺序。
不定长参数
不定长参数：也叫可变参数，用于不确定调用时传递多少个参数。
分类：位置传递、关键字传递
位置传递的不定长：
def f5(*args):
print(args)
f5('TOM')
f5('TOM',18)
注意：根据传进参数的位置合并为一个元组
关键字传递的不定长：
def f6(**kwargs):
print(kwargs)
f6(name='tom',age=20,gender='男')
注意：参数是”键=值“形式的，所有的键值对都会被kwargs接受，同时会组成字典。
缺省参数
缺省参数：缺省参数也叫默认参数，用于定义函数，为参数提供默认值，调用函数时可不传该默认参数
def f3(name,age,school='jhc'):
print(name,age,school)
f3('jack',20)
f3('rose',19,jhc-1)
匿名函数
lambda匿名函数
语法：
lambda 传入参数:函数体(一行代码)
# lambda是关键字
传入参数和函数体和之前一致
08-python文件操作
文件的编码
编码技术：编译的规则，记录如何将内容翻译成二进制，以及如何将二进制翻译回可识别内容
可用编码：utf-8、gbk、big5…
查看编码：windows记事本
文件的读取
打开文件——open()
open(name,mode,encoding)
# name:是要打开文件名的字符串（可以包含文件所在的具体路径）
# mode：打开文件的模式（只读、写入、追加）
# encoding：编码格式
示例：
f=open('python.txt','r',encoding='utf-8')
# 注意此时的f是open函数的文件对象，对象是python中一种特俗的数据类型，拥有数学和方法
mode的三种模式：
r（只读）
w（写入；如果文件已存在，原内容被删除；如果文件不存在，创建新文件）
a（追加；如果文件已存在，在原内容后追加；如果文件不存在，创建新文件）
read()方法
文件对象.read(num)
# num表示要从文件中读取数据的长度（单位是字节），如果没有传入num，表示读取所有数据
readlines()方法
文件对象.readlines()
# readlines可以按照行的方式把整个文件中的内容进行一次性读取，并且返回的是一个列表，其中每一行的数据为一个元素
readline()方法
文件对象.readline()
# 一次读取一行内容
close()方法
文件对象.close()
# 文件关闭
with open语法
with open('python.txt','r') as f:
f.readlines()
# 通过with open的语句块对文件进行操作
# 可在操作完成后自动关闭文件
文件的写入
write()方法
文件对象.write('内容')
# 直接调用write，内容并未真正写入文件，而是积攒在程序的内存中，称为缓冲区
flush()方法
# flush方法内容会真正写入文件
# write写内存，flush写入硬盘
文件的追加
模式为a
综合案例
https://www.bilibili.com/video/BV1qW4y1a7fU/?p=90&spm_id_from=pageDriver&vd_source=db3d134c564b091aeb95550baf2fa5b0
09-python异常处理、模块与包
了解异常
异常：当检测到一个错误时，python解释器就无法继续执行，反而会出现一些错误的提示，这就是所谓的“异常”。也就是bug
异常的捕获方法
捕获常规异常
try:
可能发生的错误的代码
except:
如果出现异常执行的代码
捕获指定异常
try:
print(name)
except NameError as e:
print(’name变量名称未定义')
捕获多个异常
try:
print(1/0)
except (NameError,ZeroDivisionError):
print(’zero')
捕获全部异常
try:
print(1/0)
except Exception as e:
print('出现异常')
异常else
# 表示如果没有出现异常执行的代码
try:
print(1)
except:
prnit('异常')
else:
print('无异常执行代码')
异常finally
# 表示无论是否异常都要执行的代码
异常的传递
比如在函数调用时，异常是具有传递性的
python模块
什么是模块：module，是一个python文件，模块能定义函数、类、变量
模块作用：工具包
模块的导入方式：
[from 模块名] import [模块 | 类 | 变量 | 函数 | *] [as 别名]
# import 模块名
# from 模块名 import 类、变量、方法
# from 模块名 import *
# import 模块名 as 别名
# from 模块名 import 功能名 as 别名
自定义模块：
__main__变量
all变量
python包
从物理上看，包就是一个文件夹，在该文件夹下包含了一个_init_.py文件，该文件夹可用于包含多个模块文件（只要有—init.py，它就是python包）
从逻辑上，包的本质依然是模块
包管理模块，包包含多个模块
安装第三方包：pip
第三方包：numpy，pandas、matplotlib
pip install 包名称
pip install -i https://pypi.tuna.tsinghua.edu.cn/simple 包名称
综合案例
https://www.bilibili.com/video/BV1qW4y1a7fU/?p=98&spm_id_from=pageDriver&vd_source=db3d134c564b091aeb95550baf2fa5b0
10-可视化案例
https://www.bilibili.com/video/BV1qW4y1a7fU/?p=99&spm_id_from=pageDriver&vd_source=db3d134c564b091aeb95550baf2fa5b0
（p99-p110）
第二阶段
01-python面向对象
初始对象
生活中：收集学生信息
使用对象组织数据：
1、在程序中设计表格，我们称之为：设计类（class）
class Student:
name=None
2、在程序中打印生产表格，我们称之为：创建对象
stu_1=Student()
stu_2=Student()
3、在程序中填写表格，我们称之为：对象属性赋值
stu_1.name='小周'
stu_2.name='小林'
成员方法
类的定义和使用：
class 类名称:
类的属性
类的行为
# class时关键字
# 类的属性，即定义在类中的变量（成员变量）
# 类的行为，即定义在类中的函数（成员方法）
# 创建类对象的语法
对象=类名称()
类的行为（方法）：
class Student:
name=None
age=None
def say_hi(self):
print(f'hi，我是{self.name}')
def 方法名(self,形参1,...,形参):
方法体
类和对象
现实事物包含属性和行为；
现实事物包含事和物：
事：做核算（属性有何时何地，行为有登记、检测、查询）
物：手机（属性有长宽高、重量、型号；行为有打电话、上网）
类和对象：类只是一中程序内的‘设计图纸”，需要基于图纸生产实体（对象），这中手段也成为面向对象编程。
比如：生产一个闹钟，首先需要有一个生生产图纸，然后进行生产不同序列号的闹钟，其中属性有序列号、价格；行为有响铃
面向对象编程：设计类，基于类创建对象做具体的工作
构造方法
python类可以使用：__ init __ ()方法，称之为构造方法
可以实现：
在创建类对象的时候，会自动执行
在创建类对象的时候，将传入的参数自动传递给__ init __ 方法使用。
class Student:
name=None
age=None
tel=None
def __init__(self,name,age,tel):
self.name=name
self.age=age
self.tel=tel
stu=Student('小周',20,'12345678')
类内置方法
__ init __构造方法 ，是python类内置的方法之一。
这些内置方法称为：魔术方法
除此之外：__ str __ 字符串方法、__ lt __小于大于比较、
__ le __ 小于等于大于等于符号比较、__ eq __ ==符号比较
__ str __ 方法
class Student:
def __init__(self,name,age):
self.name = name
self.age = age
def __str__(self):
return f'{self.name}{self.age}'
stu = Student('小周', 10)
print(stu)
print(str(stu))
__ lt __方法
class Student1:
def __init__(self, name, age):
self.name = name
self.age = age
def __lt__(self, other):
return self.age < other.age
stu1 = Student1('小周', 11)
stu2 = Student1('小王', 13)
print(stu1 < stu2)
__ le __ 方法
同上类似
__ eq __方法
同上类似
封装
面向对象编程：基于模板（类）取创建实体（对象），使用对象完成功能开发
面向对象3大特性：封装、继承、多态
将现实中的属性和行为，在程序中描述为成员变量和成员方法，称为封装。
类中提供了私有成员的形式来支持：私有成员变量、私有成员方法，只需要在变量名或方法名前以__开头
class Phone:
__current_voltage =None # 私有成员变量
def __keep_single_core(self):
print('保持单核运行') # 私有成员方法
如何使用私有成员变量？
私有成员无法被类对象使用，但是可以被其他的成员使用。
class Phone:
__current_voltage = 0.5 # 当前手机运行电压 私有成员变量
def __keep_single_core(self):
print('保持单核运行') # 私有成员方法
# 在其他成员中使用私有成员变量、方法
def call_by_5G(self):
if self.__current_voltage >= 1:
print('满足5g的电压要求')
else:
print('不满足5g的电压要求,已设置单核运行模式')
self.__keep_single_core()
# 其他成员使用私有成员
phone1.call_by_5G()
简单来说：私有变量、方法只能在内部使用，无法在外部使用。
练习：
"""
设计一个手机类，内部包含：
私有成员变量：__is_5g_enable,类型bool，True表示开启5g，Flase便是关闭5g。
私有成员方法：__check_5g(),会判断私有成员__is_5g_enable的值
若为True，打印输出‘5g is open’
若为False，打印输出'5g is close，using 4g'
公开成员方法：call_by_5g()，调用它会被执行
调用私有成员方法:__check_5g()，判断5g网络状态
打印输出'is ringing'
运行结果例子：
5g is close,using 4g
is ringing
"""
class Phone:
# 定义私有成员变量
__is_5g_enable = False
# 定义私有成员方法
def __check_5g(self):
if self.__is_5g_enable == True: # 使用私有成员变量
print('5g is open')
else:
print('5g is close，using 4g')
# 公开成员方法
def call_by_5g(self):
print('正在判断5g网络状态....')
self.__check_5g() # 使用私有成员方法
phone1 = Phone()
phone1.call_by_5g()
继承
继承的基础语法
现实生活中：苹果手机的不断更新迭代，基于老款的设计图进行修改。
程序中：构建phone类，基于已有的类进行修改
可以使用继承进行修改
继承：
# 单继承
class 类名(父类名):
类内容体
"""
单继承
"""
class Phone:
id = None
preducer = 'NJ'
def call_by_4g(self):
print('4g')
class Phone2022(Phone):
face_id = '0001'
def call_by_5g(self):
print('phone2022')
# 实例化
p1=Phone2022()
print(p1.id)
print(p1.face_id)
p1.call_by_4g()
p1.call_by_5g()
多继承：
一个类，继承多个负类。比如小米手机继承了手机、NFC读卡器、红外遥控器。
class 类名(父类1,父类2,...):
类内容体
"""
多继承
"""
class Phone:
id = None
preducer = 'NJ'
def call_by_4g(self):
print('4g')
class NFC:
type = '第五代'
producer = 'MI'
def read_card(self):
print('NFC读卡')
def write_self(self):
print('NFC写卡')
class RemoteControl:
type = '红外遥控'
def control(self):
print('控制开启')
class MyPhone(Phone, NFC, RemoteControl):
pass
myPhone1 = MyPhone()
myPhone1.control()
多继承注意事项：多个父类中，如果有同名的成员，那么默认以继承顺序（从左到右）为优先级。即：先继承的保留，后继承的被覆盖
pass关键字的使用
复写和使用父类成员
复写：子类继承父类的成员属性和方法后，如果不满意，可以进行复写。即：在子类中重新定义同名的属性或方法
示例：
# 定义父类
class Phone:
id = None
producer = 'MI'
def call_by_5g(self):
print('5g。。。。')
# 定义子类，复写父类成员
class MyPhone(Phone):
# 复写父类的成员变量
producer = 'HUAWEI'
# 复写父类的成员方法
def call_by_5g(self):
print('1111')
print('5g。。。。')
print('2222')
p1 = MyPhone()
p1.call_by_5g()
print(p1.producer)
在子类中调用父类成员变量、方法
调用父类同名成员：复写后还想使用父类的成员变量、方法
使用被复写的父类的成员方式：
方式1：
## 调用父类成员：
父类名.成员变量。
父类名.成员方法(self)
方式2：
# 使用super()调用父类成员
super().成员变量
super().成员方法()
类型注解
为什么要类型注解？
在pycharm中自动提示某个方法，知道什么类型的数据
类型注解：在代码中涉及数据交互的地方，提供数据类型的注解（显式的说明）
功能：帮助第三方IDE工具，提示；帮助开发者对变量进行类型注释
支持：变量、函数形参返回值的类型注解
变量的类型注解：
变量:类型
# 基础数据类型注解
var_1:int=10
var_2:float=3.14
var_3:bool=True
var_4:str='mi'
# 类对象类型注解
class Student:
pass
stu: Student=Student()
# 基础容器类型注解
my_list: list = [1, 2, 3]
my_tupke: tuple = (1, 2, 3)
my_set: set = {1, 2, 3}
my_dict: dict = {'1': 1}
my_str: str = 'mi'
# 容器类型详细注解
my_list: list[int] = [1, 2, 3]
my_tupke: tuple[str, int, bool] = ('mi', 666, True)
my_set: set[int] = {1, 2, 3}
my_dict: dict[str, int] = {'1': 1}
"""
元组需要将每一个元素都标记出来
字典需要2个，第一个key，第二个是value
"""
还可以使用:
#type:类型
class Student:
pass
var_1=random.randint(1,10) # type:int
var_2={'s':1} # type:dict[str,int]
var_3=Student() # type:Student
函数的形参、返回值的类型注解：
def 函数或方法名(形参名:类型,形参名:类型):
pass
def 函数或方法名(形参名:类型,形参名:类型) ->返回值类型:
pass
def func(x: int, y: float):
res = x + y
print(res)
func(1, 3.14)
def func1(x: int, y: int) -> int:
return print(x + y)
func1(1, 3)
Union类型注解：
联合类型注解，混搭
from typing import Union
Union[类型,...，类型]
from typing import Union
my_list:list[Union[str,int]]=[1,2,'s','q']
my_dict:dict[str,Union[str,int]]={'name':'zhou','age':12}
Union在变量、函数都可以使用
多态
多态：多种状态，即完成某个行为时，使用不同的对象会得到不同的状态
理解：同样的行为（函数），传入不同的对象，得到不同的状态。
class Animal:
def speak(self):
pass
class Dog(Animal):
def speak(self):
print('www')
class Cat(Animal):
def speak(self):
print('mmm')
def make_noise(animal:Animal):
animal.speak()
dog1=Dog()
cat1=Cat()
make_noise(dog1) # www
make_noise(cat1) # mmm
多态常作用在继承关系上：
比如：函数（方法）形参声明接受父类对象；实际传入父类的子类对象进行工作。
即：以父类做声明定义；以子类做实际工作；用以获得同一行为，不同状态
示例：如上
多态还用在抽象类（接口）：
前面的父类Animal的speak方法是空（pass）。这中设计的含义是父类用来确定有哪些方法；具体的方法由子类自行决定。这种写法也叫做抽象类（也称接口）
抽象类：含有抽象方法的类
抽象方法：方法体是空实现的（pass)
示例：
class AC:
def cool_wind(self):
# 制冷
pass
def hot_wind(self):
# 制热
pass
def swing(self):
# 摆风
pass
class Midea_AC(AC):
def cool_wind(self):
print('media制冷')
def hot_wind(self):
print('hot制冷')
def swing(self):
print('media制冷')
class GREE_AC(AC):
def cool_wind(self):
print('gree制冷')
def hot_wind(self):
print('gree制冷')
def swing(self):
print('gree制冷')
def make_cool(ac:AC):
ac.cool_wind()
media_ac=Midea_AC()
gree_ac=GREE_AC()
make_cool(media_ac)
make_cool(gree_ac)
抽象类作用：多用于顶层设计（设计标准），以便于子类做具体实现。也是对子类一种软性越苏，要求子类必须写复写父类的一些方法，并且配合多态去使用获得不同的工作状态。
综合案例
https://www.bilibili.com/video/BV1qW4y1a7fU/?p=124&spm_id_from=pageDriver&vd_source=db3d134c564b091aeb95550baf2fa5b0
（124-126）
02-SQL入门和使用
第三阶段
01-PySpark案例
02-python高阶技巧
闭包
在函数嵌套的前提下，内部函数使用了外部函数的变量，并且外部函数返回了内部函数，我们把这个使用外部函数变量的内部函数称为闭包。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-AsibjCcR-1673768832033)(assets/python基础2.asset/image-20230114203255893.png)]
简单闭包
"""
简单闭包
"""
def outer(logo):
def inner(msg):
print(f'<{logo}>{msg}<{logo}>')
return inner
fn1=outer('黑马')
fn1('大家好')
fn1('我是你爹')
fn2=outer('白马')
fn2('你好')
fn2('我是你儿')
在闭包中修改外部函数变量的值：
def outer(num1):
def inner(num2):
nonlocal num1 # 需要使用nonlocal关键字修饰外部函数的变量才可以才可以在内部函数中修改它
num1 += num2
print(num1)
return inner
fn=outer(10)
fn(10)
fn(10)
案例：
account_amount=0 # 账户余额
def Atm(num,deposit=True):
global account_amount
if deposit:
account_amount+=num
print(f'存款:+{num},账户余额:{account_amount}')
else:
account_amount-=num
print(f'取款:-{num},账户余额:{account_amount}')
Atm(300,deposit=True)
Atm(300)
Atm(100,deposit=False)
# 使用闭包实现
def account_create(initial_amount=0):
def atm(num,deposit=True):
nonlocal initial_amount
if deposit:
initial_amount+=num
print(f'存款:+{num},账户余额:{initial_amount}')
else:
initial_amount -= num
print(f'取款:-{num},账户余额:{initial_amount}')
return atm
fn=account_create()
fn(300)
fn(300)
fn(100,False)
闭包注意事项：
1、无需定义全局变量即可实现通过函数，持续地访问、修改某个值
2、闭包使用的变量的所用于在函数内，难以被错误的调用修改
3、但是由于内部函数持续引用外部函数的值，所以会导致这一部分内存空间不被释放，占用内存
装饰器
装饰器其实也是一种闭包，其功能就是在不破坏目标函数原有的代码和功能的前提下，为目标函数增加新功能。
装饰器的一般写法（闭包写法）：
def outer(func):
def inner():
print("我要睡觉了")
func()
print('我起床了')
return inner
def sleep():
import random
import time
print('睡眠中。。。。。。')
time.sleep(random.randint(1,5))
fn=outer(sleep)
fn()
装饰器的语法糖写法：
def outer(func):
def inner():
print("我要睡觉了")
func()
print('我起床了')
return inner
@outer
def sleep():
import random
import time
print('睡眠中。。。。。。')
time.sleep(random.randint(1, 5))
sleep()
设计模式-单例模式
设计模式是一种编程套路，可以提供开发效率。
最常见、经典的设计模式就是面向对象。
除面向对象外，还有其他模式：单例、工厂模式；建造者、责任链、状态、备忘录、解释器、访问者、观察者、中介、模板、代理模式；等等
单例模式：
单例模式是一种常用的软件设计模式，该模式的目的是确保某一个类只有一个实例存在。
在整个系统中，某个类只能出现一个实例时，单例对象就能派上用场.。
定义：保证一个类只有一个实例，并提供一个访问它的全局访问点。
适用场景：当一个类只能有一个实例，而客户可以从一个众所周知的访问点访问它时。
单例的实现模式：
在一个文件中定义类：
class Str:
pass
str=Str()
在另一个文件中导入对象
from test import str
s1=str
s2=str
print(s1)
print(s2)
# s1和s2是同一个对象
# <test.Str object at 0x000002652918D3C0>
# <test.Str object at 0x000002652918D3C0>
设计模式-工厂模式
工厂模式：
从原生的使用类的构造方法去创建对象的形式
"""
一般写法：
"""
# class Person:
# pass
# class Worker(Person):
# pass
# class Student(Person):
# pass
# class Teacher(Person):
# pass
#
# worker =Worker()
# stu=Student()
# teacher =Teacher()
"""
工厂模式
"""
class Person:
pass
class Worker(Person):
pass
class Student(Person):
pass
class Teacher(Person):
pass
class Factory:
def get_person(self, p_type):
if p_type == 'w':
return Worker()
elif p_type == 's':
return Student()
else:
return Teacher()
factory = Factory()
worker = factory.get_person('w')
student = factory.get_person('s')
teacher = factory.get_person('t')
优点：
1、大批量创建对象的时候有统一的入口，易于代码维护
2、当发生修改时，进修改工厂类的创建方法即可
2、符合现实世界的模式，即有工厂来制作产品（对象）
多线程-进程、线程和并行执行
进程：就是一个程序，运行在系统之上，称这个程序为一个运行进程，并分配进程ID方便系统管理。
线程：线程归属于进程，一个进程可以开启多个线程，执行不同的工作，是进程的实际工作最小单位。
进程之间是隔离的，不同的进程拥有各自的内存空间。线程之间是内存共享的。
并行执行：同一时间做不同的工作。
进程就是并行执行的.
多个进程同时进行，即不同程序同时进行，称之为：多任务并行执行。
一个进程内的多个线程同时运行，称之为：多线程并行执行。
多线程编程
threding模块：
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-gbjI6qyN-1673768832034)(assets/python基础2.asset/image-20230114215332716.png)]
单线程：
import time
def sing():
while True:
print('singsing....')
time.sleep(1)
def dance():
while True:
print('dancedance....')
time.sleep(1)
if __name__ == '__main__':
sing()
dance()
多线程：
import threading
import time
def sing():
while True:
print('singsing....')
time.sleep(1)
def dance():
while True:
print('dancedance....')
time.sleep(1)
if __name__ == '__main__':
# 创建线程
sing_1=threading.Thread(target=sing)
dance_1=threading.Thread(target=dance)
# 启动线程
sing_1.start()
dance_1.start()
如何传参：
import threading
import time
def sing(msg):
while True:
print(msg)
time.sleep(1)
def dance():
while True:
print('dancedance....')
time.sleep(1)
if __name__ == '__main__':
# 创建线程
sing_1 = threading.Thread(target=sing, args=('sing',))
dance_1 = threading.Thread(target=dance,kwargs={'msg': 'dance'})
# 启动线程
sing_1.start()
dance_1.start()
Socket服务端开发
Socket（简称 套接器）是进程之间通信一个工具，好比生活中的插座，所有的家电想要工作都是基于插座的；进程之间想要进行网络通信需要socket。
socket负责进程之间的网络数据传输，好比数据的搬运工。
服务端和客户端：
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-nzR5vXEy-1673768832034)(assets/python基础2.asset/image-20230115122602728.png)]
socket服务端编程
1、创建socket对象
2、绑定socket_server到指定ip和地址
3、服务端开始监听端口
4、接受客户端连接，获得连接对象
5、客户端连接后，通过revc方法，接收客户端发送的消息
6、通过coon（客户端当次连接对象），调用send方法可以回复消息
7、coon（客户端当次连接对象）和socket_server对象调用close方法，关闭连接。
import socket
# 1、创建socket对象
socket_server = socket.socket()
# 2、绑定ip地址和端口
socket_server.bind(('localhost', 8888))
# 3、监听端口
socket_server.listen(1) # 1表示接收的连接数量
# 4、等待客户端连接
# res = socket_server.accept()
# coon = res[0] # 客户端和服务端的连接对象
# address = res[1] # 客户端的地址信息
coon, address = socket_server.accept()
# accept()方法返回的是二元元组（链接对象、客户端地址信息）
# 可以通过 变量1、变量2=socket_server.accept()的形式接收
# accept()方法，是阻塞的方法，等待客户端的链接，如果没有链接就卡在这一直不向下执行
print(f'接收到了客户端的连接:{address}')
# 5、接收客户端信息
data: str = coon.recv(1024).decode('UTF-8')
# recv接收的参数是缓冲区大小，一般给1024
# recv方法的返回值是一个字节数组也就是bytes对象，不是字符串，可以通过decode方法utf-8编码，将字节数组转换为字符串
print(f'客户端发来的消息是:{data}')
# 6、发送回复消息
msg=input('请输入回复的内容:').encode('utf-8') # encode将字符串编码为字节数组对象
coon.send(msg)
# 7、关闭连接
coon.close()
socket_server.close()
Socket客户端开发
1、创建socket对象
2、连接到服务端
3、发送消息
4、接收返回消息
5、关闭连接
# 1、创建socket对象
import socket
socket_client = socket.socket()
# 2、连接到服务端
socket_client.connect(('localhost',8888))
# 3、发送消息
socket_client.send('你好'.encode('utf-8'))
# 4、接收返回消息
recv_data=socket_client.recv(1024).decode('utf-8')
print(f'服务端回复的消息是{recv_data}')
# 5、关闭连接
socket_client.close()
正则表达式-基础方法
正则表达式：又称规则表达式，是使用单个字符串来描述、匹配某个句法规则的字符串，常被用来检索、替换符合某个模式（规则）的文本。
简单来说：就是使用字符串定义规则，并通过规则去验证字符串是否匹配。
正则的三个基础语法：
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-EMVzfPqk-1673768832034)(assets/python基础2.asset/image-20230115130518679.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-4jUfEfeE-1673768832034)(assets/python基础2.asset/image-20230115130740470.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-tGRVhVKt-1673768832035)(assets/python基础2.asset/image-20230115130854051.png)]
正则表达式-元字符匹配
单字符匹配：
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Be5CPwyO-1673768832035)(assets/python基础2.asset/image-20230115131454827.png)]
数量匹配：
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-1WAVVbhE-1673768832035)(assets/python基础2.asset/image-20230115131510007.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-PAhRqfz0-1673768832036)(assets/python基础2.asset/image-20230115131548824.png)]
递归
递归是一种非常重要的算法;
递归：即函数自己调用自己的
def func():
if ...:
func()
return ...
使用场景：递归找文件
"""
演示递归
需求：通过递归，找出一个指定文件夹内的全部文件
思路：写一个函数，列出文件夹内的全部内容，
如果是文件就收集到list中，如果是文件夹，就调用自己，再次判断
"""
import os
def test_os():
# 演示os模块三个基础方法
print(os.listdir('test')) # 判断路径下的内容
print(os.path.isdir('test/a')) # 判断指定路径是不是文件夹
print(os.path.exists('test')) # 判断指定路径是否存在
def get_all_files(path):
"""
从指定文件夹中使用递归的方法，获取全部的文件列表
:param path: 被判断的文件夹
:return: 包含全部的文件，如果目录不存在或无文件就返回一个空list
"""
file_list = []
if os.path.exists(path):
for f in os.listdir(path):
new_path = path + '/' + f
if os.path.isdir(new_path):
# 递归
file_list += get_all_files(new_path)
else:
file_list.append(new_path)
else:
print(f'指定路径：{path} 不存在')
return []
return file_list
file_list=get_all_files('test')
print(file_list)
