python基础笔记
https://www.bilibili.com/video/BV1qW4y1a7fU/?p=12&spm_id_from=pageDriver&vd_source=db3d134c564b091aeb95550baf2fa5b0
第一阶段
01-python入门介绍
初始python
-
python起源
-
为什么选择python
- 优雅
- 简单、易学、开发效率高
- 适应面广
- 人工智能、机器学习、大数据
- 优雅
什么是编程语言
python安装
- 下载
- python官网下载
- 安装
- 验证
- cmd；输入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))
#
数据类型转换
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)
标识符
-
内容限定
- 只允许出现英文、中文、数字、下划线，不能以数字开头
-
大小写敏感
- 英文大小写
-
不可使用关键字
- 比如if、else、…
变量命名规范：见名知意、下划线命名法、英文字母全小写
# 内容限定 只允许出现英文、中文、数字、下划线，不能以数字开头
# 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)
字符串扩展
-
字符串得三种方式：
- 单引号
- 双引号
- 三引号
-
字符串拼接
-
s1='nihao' s2='whenhao' print(s1+s2) # nihaowhenhao
-
-
字符串格式化
-
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
-
n='yjy' print(f'你好我是{n}')
-
-
对表达式进行格式化
数据输入
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
#
使用场景：
用在函数无返回值上
用在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']
#
列表的下标索引：
下标索引：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 indexfor遍历：
for 临时变量 in 列表：
代码块
def while_func():
li=['z','s','s','a']
index=0
while indextuple（元组）
元组不可修改
元组的定义格式：
使用小括号，逗号隔开
# 定义元组字面量
(元素，元素，元素...元素)
# 定义元组变量
变量名=(元素，元素，元素...元素)
# 定义空元组
变量名=()
变量名=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是同一个对象
#
#
设计模式-工厂模式
工厂模式：
从原生的使用类的构造方法去创建对象的形式
"""
一般写法：
"""
# 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)