文档是在B站学习“黑马程序员”Python课程记录的笔记，供自己和大家参考，原视频链接:
https://www.bilibili.com/video/BV1qW4y1a7fU/?spm_id_from=333.337.search-card.all.click
目前是第一阶段结束第二章结束，后面要学习mysq了！准备单独写一篇！
补充：python操作mysql部分
第1章
- 主要讲的python的安装，此处省略
第2章
01 字面量
常见的值类型
python中常用的有6种（数据）类型
| 类型 | 描述 | 说明 |
|---|---|---|
| 数字（Number） | 支持 - 整数（int） - 浮点数（float） - 布尔（bool） | |
| 字符串（String） | 描述文本的一种类型 | |
| 列表（List） | 有序的可变序列 | |
| 元组（Tuple） | 有序的不可变序列 | |
| 集合（Set） | 无序不重复集合 | |
| 字典（Dictionary） | 无序Key-Value集合 |
02 注释
-
单行注释：以#开头
# 我是单行注释 print("Hello World") -
多行注释：以一对三个双引号引起来
- 一般对Python文件、类或方法进行注释
""" 我是多行注释 哈哈哈哈 哈哈哈 """ print("第一行") print("第二行") print("第三行")
03 变量
-
例如
money = 50 print("钱包还有：", money) # 买了一个冰淇淋 花费10 money = money - 10 print("钱包还有：", money) -
print(内容1，内容2，……，内容N)
04 数据类型
-
验证数据类型
print(type("黑马程序员")) print(type(666)) print(type(13.14)) name = "zhangsan" name_type = type(name) print(name_type)
05 数据类型转换
| 语句 | 说明 |
|---|---|
| int(x) | 将x转换为一个整数 |
| float（x） | 将x转换成为一个浮点数 |
| str(x) | 将对象x转换为字符串 |
-
示例
num_str = str(11) print(type(num_str), num_str) float_str = str(13.14) print(type(float_str), float_str) num = int ("11") print(type(int), num) num2 = float ("11.234") print(type(int), num2) # 整数转浮点数 float_num = float(11) print(type(float_num),float_num) #浮点数转整数 int_num = int(float(11.345)) print(type(int_num), int_num)
06 标识符
标识符命名中，只允许出现：
- 英文 大小写敏感
- 中文 不推荐中文
- 数字 不能以数字开头
- 下划线（_）
这四类元素
- 变量的命名规范
- 见名知意
- 下划线命名法
- 英文字母全小写
07 运算符
| 运算符 | 描述 | 实例 |
|---|---|---|
| + | 加 | |
| - | 减 | |
| * | 乘 | |
| / | 除 | |
| // | 取整数 | 9//2 输出结果4 9.0//2.0 输出结果4.0 |
| % | 取余数 | 9 % 2 输出结果1 |
| ** | 指数 | 2的3次方，输出结果8 |
复合赋值运算符
| 运算符 | 描述 | 实例 |
|---|---|---|
| += | 加 | 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 |
08 字符串的三种定义方式
-
单引号定义
-
双引号定义
-
三引号定义
name = '黑马程序员' name = "黑马程序员" name = """黑马 程序员""" print(name) # 使用转义字符 \ 解除引号效用 name = "\"黑马程序员\"" name1 = '\'黑马程序员\'' print(name, name1)
09 如何拼接字符串
name = "zhangsan"
age = 20
print(name + "今年" + age + "岁了！")
# 无法和数字拼接
10 字符串格式化
-
占位**%s**，多个变量占位，变量需要用括号，并按顺序填写
name = "zhangsan" age = 20 print("我是%s,今年%s岁了!" % (name, age)) -
常用的三种数据类型占位
格式符号 转化 %s 将内容转换为字符串，放入占位位置 %d 将内容转换为整数，放入占位位置 %f 将内容转换为浮点型，放入占位位置 name = "zhangsan" age = 20 high = 167.88 print("我是%s,今年%d岁了! 我身高%f" % (name, age, high))
11 字符串格式化的精度控制
-
辅助符号：“m.n”
- m，控制宽度（较少使用），设置的宽度小于数字本身，不生效
- n，控制小数点精度，会进行小数的四舍五入
-
示例
-
%5d：表示将整数的宽度控制在5位
如数字11，设置为5d，就会变成 [空格][空格][空格]11
-
%5.2f：表示将宽度设置为5，小数点精度设置为2
如，对11.345设置了%7.2f后，结果是 [空格][空格]11.35 空格补全，小数部分限制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宽度限制7，小数点精度2，结果是：%7.2d" % num2) print("数字11.345宽度不限制，小数点精度2，结果是：%.2d" % num2) # 数字11宽度限制5，结果是： 11 # 数字11宽度限制1，结果是：11 # 数字11.345宽度限制7，小数点精度2，结果是： 11 # 数字11.345宽度不限制，小数点精度2，结果是：11
-
12 字符串格式化方式2
-
语法：f"内容{变量}"
不理会类型，不做精度控制
name = "zhangsan" age = 20 high = 167.88 print(f"我是{name}, 今年{age}岁了，身高{high}")
13 对表达式的格式化
print("1 * 1 的结果是：%d" % (1 * 1))
print(f"1 * 2 的结果是：{1 * 2}")
print("字符串在Python中的类型名称是：%s" % type('字符串'))
# 1 * 1 的结果是：1
# 1 * 2 的结果是：2
# 字符串在Python中的类型名称是：<class 'str'>
小练习
name = "传智播客"
stock_price = 19.99
stock_code = '003032'
stock_price_daily_growth_factor = 1.2
growth_days = 7
print(f"公司：{name}, 股票代码：{stock_code}, 当前股价：{stock_price}")
print("每日增长系数是：%.1f, 经过%d天的增长后，股价达到了：%.2f" % (stock_price_daily_growth_factor, growth_days,stock_price*stock_price_daily_growth_factor**growth_days))
# 公司：传智播客, 股票代码：003032, 当前股价：19.99
# 每日增长系数是：1.2, 经过7天的增长后，股价达到了：71.63
015 数据输入（input语句）
name = input("请告诉我你是谁？")
print("我知道了，你是：%s" % name)
num = input("请告诉我你的银行卡密码：")
num = int(num)
print("你的银行卡密码类型是：", type(num))
获取到的数据永远都是字符串类型，如果需要其他类型需要转换
-
小练习
user_name = input("请输入您的用户名:") user_type = input("请输入您的用户类型:") print(f"您好！{user_name}, 您是尊贵的：{user_type}用户，欢迎您的光临。")
第3章
01 布尔类型和比较运算符
-
布尔类型
True 表示真
False表示假
-
比较运算符
- == 判断是否相等
- != 是否不相等
- > 是否大于
- < 是否小于
- >= 是否大于等于
- <= 是否小于等于
02 if语句的基本格式
03 案例练习
# 获取键盘输入
age = int(input("请输入你的年龄："))
if age >= 18:
print("您已成年，游玩需要买票，10元")
print("祝您游玩愉快！")
04 if else组合判断语句
# 获取键盘输入
age = int(input("请输入你的年龄："))
if age >= 18:
print("您已成年，游玩需要买票，10元")
else:
print("您未成年，可以免费游玩")
print("祝您游玩愉快！")
06 if_elif_else组合判断语句
height = int(input("请输入你的身高（cm）："))
vip_level = int(input("请输入你的VIP等级（1-5）："))
if height < 120 :
print("身高小于120cm，可以免费。")
elif vip_level > 3:
print("vip等级大于3，可以免费。")
else:
print("不好意思，所有条件都不满足，需要买票10元。")
08 判断语句的嵌套
09 判断语句综合案例
import random
num = random.randint(1,10)
guess_num = int(input("输入你要猜测的数字："))
if guess_num == num:
print("恭喜，第一次就猜中了")
else:
if guess_num > num:
print("你猜测的数字大了")
else:
print("你猜测的数字小了")
guess_num = int(input("再次输入你要猜测的数字："))
if guess_num == num:
print("恭喜，第二次猜中了")
else:
if guess_num > num:
print("你猜测的数字大了")
else:
print("你猜测的数字小了")
guess_num = int(input("再次输入你要猜测的数字："))
if guess_num == num:
print("恭喜，第三次猜中了")
else:
print("三次机会用完了！没有猜中")
第4章
01 while循环的应用基础
i = 0
while i < 100:
print("小美，我喜欢你")
i = i + 1
-
计算1-100的和
i = 1 sum = 0 while i<= 100: i += 1 sum =sum +i print(f"1到100和是:{sum}") -
猜数字案例
import random num = random.randint(1,100) count = 0 flag = True while flag: guess_num = int(input("请输入你猜测的数字：")) count += 1 if guess_num == num: print("猜中了！") flag = False elif guess_num > num: print("猜大了") else: print("猜小了") print(f"你总共猜测了{count}次。")
04 while循环的嵌套应用
# 外层：表白100天的控制
# 内层：每天表白都送10支玫瑰花的控制
i = 1
while i <= 100:
print(f"今天是第{i}天，准备表白……")
j = 1
while j <= 10:
print(f"送给小宇的第{j}支玫瑰花")
j += 1
print("小宇，我喜欢你！")
i += 1
print(f"坚持到第{i-1}天，表白成功")
05 while循环的嵌套案例
打印9*9乘法表
-
print()不换行
print("Hello", end='') print("Hello", end='') -
制表符：\t
print("Hello World") print("itheima best") print("Hello\tWorld") print("itheima\tbest") # Hello World # itheima best # Hello World # itheima besti = 1 while i <= 9: print(f"") j = 1 while j<= i: print(f"{j}*{i}={i*j}\t",end='') j += 1 i += 1[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-U4bViP2V-1686107515096)(C:\Users\28193\AppData\Roaming\Typora\typora-user-images\image-20230527200524459.png)]
06 for循环的基础语法
-
遍历字符串
name = "itheima is a brand of itcast" count = 0 for x in name: if x == "a": count = count + 1 print(f"itheima is a brand of itcast中共含有：{count}字母a")
08 range语句
-
语法1：
range(num) 获取一个从0开始，到num结束的数字序列（不含num本身）
例如range(5)取得的数据是[0, 1, 2, 3, 4]
-
语法2：
获得一个从num开始，到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]
09 循环临时变量作用域
i = 0 #全局变量
for i in range(5):
print(i)
print(i)
不建议这么做，需要定义全局变量
10 for循环的嵌套使用
# 坚持表白100天，每天都送10朵花
for i in range(1,101):
print(f"今天是向小美表白的第{i}天，加油坚持")
for j in range(1,11):
print(f"给小美送的第{j}朵玫瑰花")
11 乘法表
# 乘法表
for i in range(1,10):
print(f"")
for j in range(1,i+1):
print(f"{j}*{i}={i*j}\t",end='')
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-aZ1e5Fzj-1686107515097)(C:\Users\28193\AppData\Roaming\Typora\typora-user-images\image-20230527211438931.png)]
12 contine 和 break
-
continue关键字用于：中断本次循环，直接进入下一次循环
-
continue可以用于：for 和while循环，效果一致
for i in range(5): print("语句1") for j in range(5): print("语句2") continue print("语句3") print("语句4")for i in range(6): print("语句1") for j in range(1,6): print("语句2") break print("语句3") print("语句4")13 综合案例
import random count = 0 for i in range(1,21): score = random.randint(1, 10) if sum == 0: print(f"工资发完了，下个月领取吧！") break if score >=5: count = count + 1 sum = 10000 - 1000 * count print(f"向员工{i}发放工资1000元，账户余额还剩余{sum}元。") else: print(f"员工{i}，绩效分{score}，低于5，不发工资，下一位。") continue
第5章
02 函数的基础
def 函数名 (传入参数):
函数体
return 返回值
- 参数不需要，可以省略
- 返回值不需要，可以省略
04 函数的传入参数
def add(x, y):
result = x + y
print(f"{x}+{y}={result}")
add(3, 5)
- x, y 是形式参数
- 函数调用中的3和5是实际参数，需要按顺序传递
综合案例
def Tem(x):
print(f"请出示您的健康码以及72小时核酸证明，并配合测量体温！\n体温测量中，",end='')
if x <= 37.5:
print(f"您的体温是:{x}度，体温正常请进！")
else:
print(f"您的体温是：{x}度，需要隔离！")
print("------------------------------------------------")
Tem(35)
Tem(39)
06 函数的返回值
- 所谓“返回值”，就是程序中函数完成事情后，最后给调用者的结果
def 函数(参数……):
函数体
return 返回值
变量 = 函数(参数)
def add(x, y):
result = x + y
return result
print("------") #不会执行
r = add(2, 5)
print(r)
07 函数返回值-None
def say_hi():
print("你好呀！")
result = say_hi()
print(f"无返回值函数，返回的内容是：{result}")
print(f"无返回值函数，返回的内容类型是：{type(result)}")
-
if 判断中None表示False
-
用于声明无初始内容变量
name = None
08 函数的说明文档
def add(x, y):
"""
ada函数可以接受两个参数，进行两数相加功能
:param x: 其中一个数字
:param y: 其中另一个数字
:return: 两数相加的结果
"""
result = x + y
print(f"2数相加的结果是：{result}")
return result
09 函数的嵌套调用
def fun_b():
print("---2---")
def fun_a():
print("---1---")
fun_b()
print("---3---")
fun_a()
10 变量在函数中的作用域
-
局部变量
定义在函数体的内部，只在函数体内部生效
-
全局变量
在函数体内外都可以使用
num = 200 def test_a(): print(f"test_a:{num}") def test_b(): print(f"test_b:{num}") test_a() test_b() -
使用global关键字 可以在函数内部声明变量为全局变量
num = 100 def testA(): print(num) def testB(): global num num = 200 print(num) testA() testB() print(num)
11 综合案例
money = 5000000
name = input("请输入你的名字：")
def query(show_header):
if show_header:
print(f"-------------查询余额-------------")
print(f"{name}，您好，您的余额剩余：{money}元")
def cuk(x):
global money
money = money + x
print(f"---------------存款---------------")
print(f"{name}，您好，您存款{x}元成功")
query(False)
def quk(x):
global money
money -= x
print(f"---------------取款---------------")
print(f"{name}，您好，您取款{x}元成功")
query(False)
def main():
print("------------------主菜单--------------------")
print(f"{name}，您好，欢迎来到未来银行ATM。请选择操作：")
print(f"查询余额\t[输入1]")
print(f"存款\t\t[输入2]")
print(f"取款\t\t[输入3]")
print(f"退出\t\t[输入4]")
return input("请输入您的选择：")
while True:
keyword_input = main()
if keyword_input == "1":
query(True)
continue
elif keyword_input == "2":
x = int(input("您想要存入多少钱？请输入？"))
cuk(x)
continue
elif keyword_input == "3":
x = int(input("您想要取出多少钱？请输入？"))
quk(x)
continue
else:
break
第6章
01 数据容器的入门
- 数据容器类型
- 列表（list）
- 元组（temple）
- 字符串（str）
- 集合（set）
- 字典
02 列表
-
基本语法：
字面量
[元素1，元素2，元素3，元素4，……]
定义变量
变量名称 = [元素1，元素2，元素3，元素4，……]
定义空列表
变量名称 = []
变量名称 = list()
my_list = ['ithema', 'itcast', 'python']
print(my_list)
print(type(my_list))
my_list = ['itheima', 666, True]
print(my_list)
print(type(my_list))
# 定义一个嵌套列表
my_list = [['1', '2', '3'], ['4', '5', '6']]
print(my_list)
print(type(my_list))
-
列表的下标索引
-
列表[下标索引]，从前向后从0开始，每次+1， 从后向前从-1开始，每次-1
my_list = [['1', '2', '3'], ['4', '5', '6']] print(my_list[0]) print(my_list[1]) print(my_list[0][2]) print(my_list[1][1]) # 通过下标索引取出对应位置的数据 my_list = ['Tom', 'Lily', 'Rose'] print(my_list[0]) print(my_list[1]) print(my_list[2]) print(my_list[-1]) print(my_list[-2]) print(my_list[-3])
04 列表的常用操作方法
| 使用方式 | 作用 |
|---|---|
| 列表.append(元素) | 向列表中追加一个元素 |
| 列表.extend(元素) | 将数据容器的内容依次取出，追加到列表尾部 |
| 列表.insert(下标，元素) | 在指定下标处，插入指定的元素 |
| del 列表[下标] | 删除列表指定下标元素 |
| 列表.pop(下标) | 删除列表指定下标元素 |
| 列表.remove(元素) | 从前向后，删除此元素第一个匹配项 |
| 列表.clear() | 清空列表 |
| 列表.count(元素) | 统计此元素在列表中出现的次数 |
| 列表.index(元素) | 查找指定元素在列表的下标，找不到报错ValueError |
| len(列表) | 统计容器内有多少元素 |
my_list = ['itcast', 'itheima', 'python']
# 查找元素在列表内的下标索引
index = my_list.index('itheima')
print(index)
# 如果被查找的元素不存在，会报错
# index = my_list.index('hello')
# print(f"hello在列表中的下标索引值是：")
# 修改特定元素的下标索引值
my_list[0] = '教育'
print(my_list)
# 在指定下标位置插入元素
my_list.insert(1, 'best')
print(my_list)
# 在尾部追加单个新元素
my_list.append('zhangsan')
print(my_list)
# 在列表尾部追加一批新元素
my_list2 = [1, 2, 3]
my_list.extend(my_list2)
print(my_list)
# 删除元素
my_list = ['itcast', 'itheima', 'python']
# 1.通过下标指定元素进行删除
del my_list[2]
print(my_list)
#2.使用pop方法删除
my_list = ['itcast', 'itheima', 'python']
element = my_list.pop(2)
print(element)
my_list = ['itcast', 'itheima', 'python']
# 删除某元素在列表中的第一个匹配项
my_list = ['itcast','itheima', 'itcast', 'itheima', 'python']
my_list.remove('itheima')
print(my_list)
# 清空列表
my_list.clear()
print(my_list)
# 统计某元素在列表中的数量
my_list = ['itcast','itheima', 'itcast', 'itheima', 'python']
count = my_list.count('itheima')
print(count)
#统计列表中全部的元素数量
my_list = ['itcast','itheima', 'itcast', 'itheima', 'python']
count = len(my_list)
print(count)
05 案例练习
age = [21, 25, 21, 23, 22, 20]
age.append(31)
print(age)
age1 = [29, 33, 30]
age.extend(age1)
print(age)
num1 = age[0]
print(num1)
num2 = age[-1]
print(num2)
a = age.index(31)
print(a)
06 列表的循环遍历
-
列表的遍历 - while循环
index = 0 while index <len(列表)： 元素 = 列表 对元素进行处理 index += 1def list_while_func(): """ 使用while循环遍历列表的演示函数 :return: """ my_list = ['itcast', 'itheima', 'python'] index = 0 while index < len(my_list): element = my_list[index] print(f"列表的元素：{element}") index += 1 list_while_func() -
列表的遍历 - for循环
for 临时变量 in 数据容器： 对临时变量进行处理def list_for_func(): """ 使用for循环遍历列表的演示函数 :return: """ my_list = [1, 2, 3, 4, 5] for element in my_list: print(element) list_for_func() -
练习
oushu1 = [] oushu2 = [] index = 0 while index < len(nums): if nums[index] % 2 ==0: oushu1.append(nums[index]) index += 1 print(oushu1) for num in nums: if num %2 == 0: oushu2.append(num) print(oushu2)
07 元组的定义和操作
-
元组使用小括号，逗号隔开
变量名称 = ()
变量名称 = tuple()
-
注意：元组只有一个数据，这个数据后面要加上逗号。
t1 = (1, 'Hello', True) print(t1) t4 = ('Hello',) print(f"{type(t4)}") # 元组的嵌套 t5 = ((1, 2, 3), (4, 5, 6)) print(f"t5的类型是：{type(t5)}，内容是{t5}") # 下标索引取出内容 num = t5[1][2] print(f"从嵌套元组中取出的数据是：{num}") -
元组的操作
- index() 查找某个数据，如果数据存在返回对应的下标，否则报错
- count() 统计某个数据在当前元组出现的次数
- len() 统计元组内的元素个数
-
支持for和while循环
-
元组只读，不可修改
-
可以修改元组内的list内容(修改元素、增加、删除、反转等)
t9 = (1, 2, ['itheima', 'itcast']) t9[2][0] = "zhangsan" t9[2][1] = "lisi" print(t9) -
练习
message = ('zhangsan', 11, ['football', 'music']) num1 = message.index(11) print(num1) name = message[0] print(name) message[2].remove('football') print(message) message[2].append('coding') print(message)
08 字符串的定义和操作
my_str = "itheima and incast"
value = my_str[2]
value2 = my_str[-16]
print(value)
print(value2)
-
同元组一样，字符串是一个：无法修改的数据容器
-
下标索引
my_str = "itheima and incast" value = my_str.index('and') print(value) -
字符串的转换
my_str = "itheima and itcast" new_str = my_str.replace('it', "程序") print(my_str) print(new_str) -
字符串的分割
my_str = "hello python itheima itcast" my_str_list = my_str.split(" ") print(my_str_list) -
字符串的规整操作
my_str = " itheima itcast " new_my_str = my_str.strip() print(new_my_str) #不传入参数，取出收尾空格 my_str = "12itheima itcast21" new_my_str = my_str.strip('12') print(new_my_str) -
统计字符串的长度
my_str = "itheima itcast" count = my_str.count("it") print(count) length = len(my_str) print(length) -
字符串的遍历
支持for和while循环
-
小练习
str = "itheima itcast boxuegu" count = str.count("it") print(count) new_str = str.replace(" ", "|") print(new_str) str_list = new_str.split("|") print(str_list)
10 数据容器（序列）的切片
-
列表、元组、字符串，均可以视为序列
-
切片操作
语法：序列[起始下标:结束下标:步长]
步长表示：
- 步长1表示：一个个取元素
- 步长2表示：每次跳过一个元素取
- 步长N表示：每次跳过N-1个元素取
- 步长为负数表示，反向取（注意，起始下标和结束下标也要反向标记）
my_list = [0, 1, 2, 3, 4, 5, 6] result1 = my_list[1:4] print(result1) my_tuple = (0, 1, 2, 3, 4, 5, 6) result2 = my_tuple[:] print(result2) my_str = "01234567" result3 = my_str[::2] print(result3) my_str = "01234567" result4 = my_str[::-1] print(result4) my_list = [0, 1, 2, 3, 4, 5, 6] result5 = my_list[3:1:-1] print(result5) my_tuple = (0, 1, 2, 3, 4, 5, 6) result6 = my_tuple[::-2] print(result6)
12 集合的定义和操作
-
语法
变量名称 = {元素，元素，元素}
变量名称 = set()
my_set = {"张三", "李四", "王五", "张三", "李四", "王五", "张三", "李四", "王五"} my_set_empty = set() print(f"my_set的内容是：{my_set}，类型是：{type(my_set)}") print(f"my_set的内容是：{my_set_empty }，类型是：{type(my_set_empty)}") -
集合内容不能重复
-
无序的，不支持下标索引访问
-
是允许修改的
my_set.add('python') my_set.add("张三") print(f"my_set添加元素后的结果是：{my_set}") my_set.remove("python") print(f"my_移除python元素后的结果是：{my_set}") element = my_set.pop() print(f"集合被取出元素是：{element}") my_set.clear() print(my_set) -
取出2个集合的差集
语法：集合1.difference(集合2)
功能：取出集合1和集合2的差集（集合1有而集合2没有的）
结果：得到一个新集合，集合1和集合2不变
set1 = {1, 2 ,3} set2 = {1, 5, 6} set3 = set1.difference(set2) print(set1) print(set2) print(set3) -
消除2个集合的差集
语法：集合1.difference_update(集合2)
功能：对比集合1和集合2，在集合1内，删除和集合2相同的元素
结果：集合1被修改，集合2不变
set1 = {1, 2 ,3} set2 = {1, 5, 6} set1.difference_update(set2) print(set1) print(set2) -
2个集合合并
语法：集合1.union(集合2)
功能：将集合1和集合2组合成新集合
结果：得到新集合，集合1和集合2不变
set1 = {1, 2 ,3} set2 = {1, 5, 6} set3 = set1.union(set2) print(set1) print(set2) print(set3) -
统计集合元素数量
num = len(set3) print(num) -
集合的遍历
不能用while循环
可以用for循环
for i in set3: print(f"集合的元素有：{i}")
14 字典的定义
-
语法
my_dict = {key1:value1, key2:value2}
my_dict = dict()
dict1 = {"zhangsan":80, "lisi":90, "wangwu":95} dict2 = {} dict3 = dict() print(f"字典1的内容是：{dict1}，类型是{type(dict1)}") print(f"字典1的内容是：{dict2}，类型是{type(dict2)}") print(f"字典1的内容是：{dict3}，类型是{type(dict3)}") -
key不能重复
-
从字典中通过key获取value的值
socre = dict1["lisi"] print(socre) -
字典的嵌套
stu_ccore = { "zhangsan": { "语文": 77, "数学": 66, "英语": 33 }, "lisi": { "语文": 88, "数学": 86, "英语": 55 }, "wangwu": { "语文": 99, "数学": 96, "英语": 66 } } print(f"学生的考试信息是{stu_ccore}") score = stu_ccore["zhangsan"]["语文"] print(score)
15 字典的常用操作
-
新增/修改元素
语法:字典[key] = value
stu_ccore = {"zhangsan": 90, "lisi": 98, "wangwu": 89} stu_ccore["zhaoliu"] = 86 print(stu_ccore) stu_ccore["zhangsan"] = 60 print(stu_ccore) -
删除元素
score = stu_ccore.pop("zhangsan") print(stu_ccore, score) -
清空字典
stu_ccore.clear() print(stu_ccore) -
取出全部key
stu_ccore = {"zhangsan": 90, "lisi": 98, "wangwu": 89} stus = stu_ccore.keys() print(stus) # 遍历字典 # 方式1 for key in stus: print(f"字典的key是：{key}") print(f"字典的value是：{stu_ccore[key]}") # 方式2 for key in stu_ccore: print(f"字典的key是：{key}") print(f"字典的value是：{stu_ccore[key]}") # 统计字典的元素数量 num = len(stu_ccore) print(num)
16 练习
emps = {
"zhangsan": {
"部门": "科技部",
"工资": 3000,
"级别": 1
},
"lisi": {
"部门": "市场部",
"工资": 5000,
"级别": 2
},
"wangwu":{
"部门": "市场部",
"工资": 7000,
"级别": 3
},
"zhaoliu":{
"部门": "科技部",
"工资": 4000,
"级别": 1
},
"liqi":{
"部门": "市场部",
"工资": 6000,
"级别": 2
}
}
for key in emps:
if emps[key]["级别"] == 1:
emps[key]["级别"] += 1
emps[key]["工资"] += 1000
print(emps)
17 5类数据容器的总结对比
-
是否支持下标索引
- 支持：列表，元组，字符串 ——序列类型
- 不支持：集合、字典 ——非序列类型
-
是否支持重复元素
- 支持：列表，元组，字符串 ——序列类型
- 不支持：集合、字典 ——非序列类型
-
是否可以修改
- 支持：列表，集合，字典
- 不支持：元组，字符串
18 数据容器的通用操作
-
数据容器的通用功能
my_list = [1, 2, 3, 4, 5] my_tuple = (1, 2, 3, 4, 5) my_str = "abcdefg" my_set = {1, 2, 3, 4, 5} my_dict = {"key1": 1, "key2": 2, "key3": 3, "key4": 4, "key5": 5} # 长度 print(f"列表 元素个数有：{len(my_list)}") print(f"元组 元素个数有：{len(my_tuple)}") print(f"字符串 元素个数有：{len(my_str)}") print(f"集合 元素个数有：{len(my_set)}") print(f"字典 元素个数有：{len(my_dict)}") # 最大值max print(f"列表 最大的元素是：{max(my_list)}") print(f"元组 最大的元素是：{max(my_tuple)}") print(f"字符串 最大的元素是：{max(my_str)}") print(f"集合 最大的元素是：{max(my_set)}") print(f"字典 最大的元素是：{max(my_dict)}") # 最小值min print(f"列表 最小的元素是：{min(my_list)}") print(f"元组 最小的元素是：{min(my_tuple)}") print(f"字符串 最小的元素是：{min(my_str)}") print(f"集合 最小的元素是：{min(my_set)}") print(f"字典 最小的元素是：{min(my_dict)}") # 容器类型转换 # …………………………省略 -
通用排序功能
sorted(容器，[reverse = True])
print(f"列表对象的排序结果：{sorted(my_list)}") print(f"元组对象的排序结果：{sorted(my_tuple)}") print(f"字符串对象的排序结果：{sorted(my_str)}") print(f"集合对象的排序结果：{sorted(my_set)}") print(f"字典对象的排序结果：{sorted(my_dict)}") # 反向排序 print(f"列表对象的排序结果：{sorted(my_list, reverse=True)}") print(f"元组对象的排序结果：{sorted(my_tuple, reverse=True)}") print(f"字符串对象的排序结果：{sorted(my_str, reverse=True)}") print(f"集合对象的排序结果：{sorted(my_set, reverse=True)}") print(f"字典对象的排序结果：{sorted(my_dict, reverse=True)}")
19 拓展-字符串大小比较方式
- ASCII码表
第7章
01 函数的多返回值
-
语法
def test_return(): return 1, 2 x, y = test_return() print(x) #结果1 print(y) #结果2
02 函数的多种传参方式
-
位置参数
传递的参数和定义的参数顺序及个数必须一致
def user_info(name, age, gender): print(f"您的名字是{name}, 年龄是{age}, 性别是{gender}") user_info('Tom', 30, '男') -
关键字参数
可以不按照固定顺序
def user_info(name, age, gender): print(f"您的名字是{name}, 年龄是{age}, 性别是{gender}") user_info(name='Tom', age=30, gender='男') -
缺省参数
函数调用时没有传递参数，就会使用默认是缺省参数对应的值
该参数需要放在最后面
def user_info(name, age, gender = '男'): print(f"您的名字是{name}, 年龄是{age}, 性别是{gender}") user_info('小甜', 15) user_info('小六', 23, '女') -
不定长参数
# 方式1：位置传递 def user_info(*args): print(args) user_info('小甜', 15) user_info('小六', 23, '女') # 方式2：关键字传递 def user_info1(**kwargs): print(kwargs) user_info1(name='xiaoer', age=18, gender='女')
03 函数作为参数传递
def test_func(compute):
result = compute(1, 2)
print(f"compute参数的类型是：{type(compute)}")
print(f"计算结果是：{result}")
def compute(x, y):
result = x + y
return result
test_func(compute)
04 lambda匿名函数
-
函数定义中
-
def关键字，可以定义带有名称的函数；可基于名称重复使用
-
lambda关键字，可以定义匿名函数（无名称）；只能临时使用一次
-
语法：
lambda 传入参数：函数体（一行代码）
lambda x, y : x + y
-
第8章
01 文件编码概念
02 文件的读取操作
-
打开文件
-
读写文件
-
关闭文件
-
open()打开函数
open(name, mode, encoding)name: 是要打开的目标文件名的字符串（可以包含文件所在的具体路径）
mode：设置打开的文件模式（访问模式）：只读、写入、追加等
encoding：编码格式（推荐使用UTF-8）
示例代码
f = open('python.txt', 'r', encoding="UTF-8") -
mode常用的三种基础访问
模式 描述 r 以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式 w 打开一个文件用于写入。如果该文件已经存在则打开文件，并从头开始编辑，原内容会被删除。如果该文件不存在，创建新文件 a 打开一个文件用于追加。如果该文件已存在，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入 -
文件读操作相关方法
-
read()
文件对象.read(num) # num表示要从文件中读取的数据长度（单位是字节），如果没有传入num，那么就表示读取文件中所有的数据 -
readlines()
readlines可以按照行的方式把整个文件中的内容进行一次性读取，并且返回的是一个列表，其中每一行的数据为一个元素
f = open("D:/测试.txt", "r", encoding="UTF-8") print(type(f)) # print(f"读取10字节的结果：{f.read(10)}") # print(f"读取全部内容的结果：{f.read()}") print("----------------------------------") # readlines()方法 lines = f.readlines() print(f"lines对象的类型：{type(lines)}") print(f"lines对象的内容是{lines}") -
readline()方法：一次读取一行内容
line1 = f.readline() line2 = f.readline() line3 = f.readline() line4 = f.readline() print(line1) print(line2) print(line3) print(line4) -
for循环
f = open("D:/测试.txt", "r", encoding="UTF-8") for line in f: print(f"每一行数据是：{line}") -
close()关闭文件对象
f.close() -
with open 语法
通过在with open的语句中对文件进行操作，可以在操作完成后自动关闭close文件，避免遗忘掉close方法
with open("D:/测试.txt", "r", encoding="UTF-8") as f: for line in f: print(line) time.sleep(500000)
-
-
练习
with open("D:/测试.txt", 'r', encoding='UTF-8') as f: count = 0 for words in f: words = words.strip() for word in words: if word == '你': count += 1 print(f"'你'字共有{count}个") # 第二种方法---------------------------------------------- with open("D:/测试.txt", 'r', encoding='UTF-8') as f: content = f.read() count = content.count("你") print(f"'你'字共有{count}个")
04 文件的写入操作
-
文件写入
f.write(‘hello, world’) 写内存
-
内容刷新
f.flush() 写到硬盘里面
import time f = open('D:/test.txt', 'w', encoding='UTF-8') f.write("Hello World!!!") f.flush()f = open('D:/test.txt', 'w', encoding='UTF-8') f.write("我喜欢学python") f.flush() -
close()方法，会带有flush()方法功能
05 文件的追加写入操作
-
a模式，文件不存在会创建文件
-
a模式，文件存在会在最后，追加写入文件
f = open('D:/test1.txt', 'a', encoding='UTF-8') f.write("Hello World!!!") f.flush()
06 文件操作的综合练习
f1 = open("D:/bill.txt", 'r', encoding='UTF-8')
f2 = open("D:/bill.txt.bak", 'w', encoding='UTF-8')
for lines in f1:
lines = lines.strip()
line = lines.split(",")
print(lines)
if line[4] == "测试":
continue
else:
f2.write(lines)
f2.write("\n")
f1.close()
f2.close()
第9章
01 了解异常
02 捕获异常
-
捕获异常
try: 可能发生错误的代码 except: 如果出现异常执行的代码 -
捕获指定异常
try： print(name) except NameError as e: print('name变量名称未定义错误')try: print(name) except NameError as e: print("出现了变量未定义异常") print(e) -
捕获多个异常
try: print(1/0) except (NameError,ZeroDivisionError): print('ZeroDivision错误')try: # print(1/0) print(name) except(NameError,ZeroDivisionError) as e: print('出现变量未定义或除0异常') -
捕获全部异常
try: 1/0 except Exception as e: print('出现异常了') -
异常else
try: print(1) except Exception as e: print('e') else: print('我是else,是没有异常的时候的代码') -
finally
try: f = open('D:/abcd.txt', 'r', encoding='UTF-8') except Exception as e: print('出现异常了') f = open('D:/abcd.txt', 'w', encoding='UTF-8') else: print('我是else,是没有异常的时候的代码') finally: print("我是finally，有没有异常我都要执行") f.close()
03 异常的传递
def func1():
print("func1 开始执行")
num = 1/0
print("func1 结束执行")
def func2():
print("func2 开始执行")
func1()
print("func2 结束执行")
def main():
func2()
main()
Traceback (most recent call last):
File "C:\Users\28193\Desktop\Python\python-learn\test.py", line 14, in <module>
main()
File "C:\Users\28193\Desktop\Python\python-learn\test.py", line 12, in main
func2()
File "C:\Users\28193\Desktop\Python\python-learn\test.py", line 8, in func2
func1()
File "C:\Users\28193\Desktop\Python\python-learn\test.py", line 3, in func1
num = 1/0
ZeroDivisionError: division by zero
func2 开始执行
func1 开始执行
def func1():
print("func1 开始执行")
num = 1/0
print("func1 结束执行")
def func2():
print("func2 开始执行")
func1()
print("func2 结束执行")
def main():
try:
func2()
except Exception as e :
print(e)
main()
04 模块的概念和导入
-
什么是模块
Python模块（Module）,是一个Python文件，以.py结尾。
模块能定义函数，类和变量，模块里也可能包含可执行的代码
**大白话：**模块就是一个python文件，里面有类、函数、变量等，我们可以直接拿过来用
-
模块的导入方式
[from 模块名] import [模块 | 类 | 变量 | 函数 | *] [as 别名]
常见的组合形式如：
- import 模块名
- from 模块名 import 类、变量、方法等
- from 模块名 import *
- from 模块名 as 别名
- from 模块名 import 功能名 as 别名
05 自定义模块并导入
-
制作自定义模块
# 新建一个module.py文件 def test(a, b): print(a + b) # import module test(2, 6) -
测试模块
解决测试时也执行问题
if __name__ == '__main__': test(1, 2) -
_all_
__all__ = ['test_a'] def test_a(a, b): print(a + b) def test_b(a, b): print(a - b) from module import * 只能使用test_a()
06 自定义python包
-
可以理解为python包为文件夹
包含各个模块的文件和_init_.py文件
import my_package.module1 import my_package.module2 my_package.module1.info_print() my_package.module2.info_print() from my_package import module2 from my_package.module2 import info_print module2.info_print() info_print() -
导入包，方法二
# 在__init__文件中输入 __all__ = ['module1'] # 则import*时只能使用module1 from my_package import * module1.info_print() module2.info_print()
07 安装第三方包
-
常用的第三方包
- 科学计算中常用的：numpy包
- 数据分析中常用的：pandas包
- 大数据计算中常用的：pyspark、apache-flink
- 图形可视化常用的：matplotlib、pyecharts
- 人工智能常用的：tensortflow
- 等
-
pip 安装
- pip install 包名称
- pip install -i https://pypi.tuna.tsinghua.edu.cn/simple 包名称
-
在PyCharm安装
08 综合案例
- file_util.py
def print_file_info(file_name):
try:
f = open(file_name, 'r', encoding='UTF-8')
txt = f.read()
print(txt)
except Exception as e:
print(e)
finally:
f.close()
if __name__ == '__main__':
print_file_info("D:/bill.txt")
def append_to_file(file_name, data):
f = open(file_name, 'a', encoding='UTF-8')
f.write(data)
f.flush()
f.close()
if __name__ == '__main__':
append_to_file('D:/abc.txt', "我爱学python1\n")
- str_util.py
def str_reverse(s):
s = s[::-1]
print(s)
if __name__ == '__main__':
str_reverse('python')
def substr(s, x, y):
s = s[x:y:1]
print(s)
if __name__ == '__main__':
substr('pythonoopython', 6, 8)
第10章
02 json数据格式的转化
"""
演示json数据和python字典的相互转换
"""
import json
# 准备列表
data = [{"name": "张三", "age": 11}, {"name": "李四", "age": 13}, {"name": "王五", "age": 12}]
json_str = json.dumps(data, ensure_ascii=False) # 转换中文时，需要用ensure_ascii=False
print(type(json_str))
print(json_str)
# 准备字典，将字典转换为json
d = {"name": "张三", "age": 11}
json_str = json.dumps(d, ensure_ascii=False)
print(json_str)
# 将JSON字符串转换为python数据类型-列表
s = '[{"name": "张三", "age": 11}, {"name": "李四", "age": 13}, {"name": "王五", "age": 12}]'
l = json.loads(s)
print(type(l))
print(l)
# 将JSON字符串转换为python数据类型-字典
s = '{"name": "张三", "age": 11}'
l = json.loads(s)
print(type(l))
print(l)
03 pyecharts模块简介
- 如果想要做出数据可视化
- (https://pyecharts.org/#/zh-cn/)
- (https://gallery.pyecharts.org/#/README)
04 pyecharts的入门使用
-
生成简单图表
""" 演示pyecharts的基础入门 """ from pyecharts.charts import Line # 创建一个折线图对象 line = Line() # 给折线图对象添加X轴数据 line.add_xaxis(["中国", "美国", "英国"]) # 给折线图对象添加Y轴数据 line.add_yaxis("GDP", [30, 20, 10]) # 通过render方法，将代码生成为图像 line.render() -
全局配置
set_global_opts方法
""" 演示pyecharts的基础入门 """ from pyecharts.charts import Line from pyecharts.options import TitleOpts, LegendOpts, ToolboxOpts, VisualMapOpts # 创建一个折线图对象 line = Line() # 给折线图对象添加X轴数据 line.add_xaxis(["中国", "美国", "英国"]) # 给折线图对象添加Y轴数据 line.add_yaxis("GDP", [30, 20, 10]) # 设置全局配置项 line.set_global_opts( title_opts=TitleOpts(title="GDP展示", pos_left="center", pos_bottom="1%"), legend_opts=LegendOpts(is_show=True), toolbox_opts=ToolboxOpts(is_show=True), visualmap_opts=VisualMapOpts(is_show=True) ) # 通过render方法，将代码生成为图像 line.render()
05 数据准备
-
小练习
""" 演示可视化需求1：折线图开发 """ import json from pyecharts.charts import Line from pyecharts.options import TitleOpts, LabelOpts # 处理数据 f_us = open("D:/美国.txt", 'r', encoding='UTF-8') us_data = f_us.read() f_jp = open("D:/日本.txt", 'r', encoding='UTF-8') jp_data = f_jp.read() f_in = open("D:/印度.txt", 'r', encoding='UTF-8') in_data = f_in.read() # 去掉不规范的开头或结尾 us_data = us_data.replace("jsonp_1629344292311_69436(", "") us_data = us_data[:-2] jp_data = jp_data.replace("jsonp_1629350871167_29498(", "") jp_data = jp_data[:-2] in_data = in_data.replace("jsonp_1629350745930_63180(", "") in_data = in_data[:-2] # JSON转python字典 us_dict = json.loads(us_data) jp_dict = json.loads(jp_data) in_dict = json.loads(in_data) # 获取trend key us_trend_data = us_dict['data'][0]['trend'] jp_trend_data = jp_dict['data'][0]['trend'] in_trend_data = in_dict['data'][0]['trend'] # 获取日期数据，用于x轴，取2020年（到314下标结束） us_x_data = us_trend_data['updateDate'][:314] jp_x_data = jp_trend_data['updateDate'][:314] in_x_data = in_trend_data['updateDate'][:314] # 获取确认数，用于y轴，取2020年（314下标结束） us_y_data = us_trend_data['list'][0]['data'][:314] jp_y_data = jp_trend_data['list'][0]['data'][:314] in_y_data = in_trend_data['list'][0]['data'][:314] # 生成图表 line = Line() # 添加X轴数据 line.add_xaxis(us_x_data) # x轴数据可以共用，添加一个就行 # 添加y轴数据 line.add_yaxis("美国确诊人数", us_y_data, label_opts=LabelOpts(is_show=False)) line.add_yaxis("日本确诊人数", jp_y_data, label_opts=LabelOpts(is_show=False)) line.add_yaxis("印度确诊人数", in_y_data, label_opts=LabelOpts(is_show=False)) # 设置全局选项 line.set_global_opts( # 标题设置 title_opts=TitleOpts(title="2020年美日印三国确诊人数对比折线图", pos_bottom="1%", pos_left="center"), ) # 调用render（）方法生成图表 line.render() # 关闭文件 f_us.close() f_jp.close() f_in.close()
第11章
01 数据可视化案例-地图-基础地图使用
-
地图基本演示
""" 演示地图可视化的基本使用 """ from pyecharts.charts import Map from pyecharts.options import VisualMapOpts # 准备地图对象 map = Map() # 准备数据 data = [ ("北京市", 99), ("上海市", 199), ("湖南省", 299), ("台湾省", 399), ("广东省", 499) ] # 添加数据 map.add("测试地图", data, "china") # 设置全局选项 map.set_global_opts( visualmap_opts=VisualMapOpts( is_show=True, is_piecewise=True, pieces=[ {"min": 1, "max": 99, "label": "1-9人", "color": "#CCFFFF"}, {"min": 100, "max":299, "label": "100-299人", "color": "#FF6666"}, {"min": 300, "label": "300以上", "color": "#990033"} ] ) ) # 绘图 map.render()
02 全国疫情地图构建
"""
演示地图可视化的基本使用
"""
import json
from pyecharts.charts import Map
from pyecharts.options import *
# 读取文件
f = open("D:/疫情.txt", 'r', encoding="UTF-8")
data = f.read()
# 关闭文件
f.close()
# 取到各省数据
# 将字符串json转换为python的字典
data_dict = json.loads(data)
# 从字典中取省份数据
province_data_list = data_dict["areaTree"][0]["children"]
print(province_data_list)
# 取出各个省份名称，确诊人数
data_list = []
for province_data in province_data_list:
province_name = province_data["name"]
province_confirm = province_data["total"]["confirm"]
data_list.append((province_name + "省", province_confirm))
print(data_list)
# 准备地图对象
map = Map()
# 添加数据
map.add("各省份确诊人数", data_list, "china")
# 设置全局选项
map.set_global_opts(
title_opts=TitleOpts(title="全国疫情地图"),
visualmap_opts=VisualMapOpts(
is_show=True,
is_piecewise=True,
pieces=[
{"min": 1, "max": 99, "label": "1-99人", "color": "#CCFFFF"},
{"min": 100, "max":999, "label": "100-999人", "color": "#FFFF99"},
{"min": 1000, "max":4999, "label": "1000-4999人", "color": "#FF9966"},
{"min": 5000, "max":9999, "label": "5000-9999人", "color": "#FF6666"},
{"min": 10000, "max":99999, "label": "10000-99999人", "color": "#CC3333"},
{"min": 100000, "label": "100000+", "color": "#990033"}
]
)
)
# 绘图
map.render("全国疫情地图.html")
03 省级疫情地图
"""
演示地图可视化的基本使用
"""
import json
from pyecharts.charts import Map
from pyecharts.options import *
# 读取文件
f = open("D:/疫情.txt", 'r', encoding="UTF-8")
data = f.read()
# 关闭文件
f.close()
# 取到各省数据
# 将字符串json转换为python的字典
data_dict = json.loads(data)
# 从字典中取省份数据
cities_data = data_dict["areaTree"][0]["children"][3]["children"]
print(cities_data)
# 取出各个省份名称，确诊人数
data_list = []
for city_data in cities_data:
city_name = city_data['name'] + "市"
city_confirm = city_data["total"]["confirm"]
data_list.append((city_name, city_confirm))
print(data_list)
# 准备地图对象
map = Map()
# 添加数据
map.add("各市确诊人数", data_list, "河南")
# 设置全局选项
map.set_global_opts(
title_opts=TitleOpts(title="河南省疫情地图"),
visualmap_opts=VisualMapOpts(
is_show=True,
is_piecewise=True,
pieces=[
{"min": 1, "max": 9, "label": "1-9人", "color": "#CCFFFF"},
{"min": 10, "max":99, "label": "10-99人", "color": "#FFFF99"},
{"min": 100, "max":499, "label": "100-499人", "color": "#FF9966"},
{"min": 500, "label": "500人以上", "color": "#FF6666"},
]
)
)
# 绘图
map.render("河南省疫情地图.html")
第12章
01 基础柱状图构建
from pyecharts.charts import Bar
from pyecharts.options import *
bar = Bar()
bar.add_xaxis(["中国", "美国", "英国"])
bar.add_yaxis("GDP", [30, 20, 10], label_opts=LabelOpts(position="right"))
bar.reversal_axis()
bar.render("基础柱状图.html")
02 基础时间线柱状图绘制
-
创建时间线
Timeline()-时间线
from pyecharts.charts import Bar, Timeline from pyecharts.options import * from pyecharts.globals import ThemeType bar1 = Bar() bar1.add_xaxis(["中国", "美国", "英国"]) bar1.add_yaxis("GDP", [30, 20, 10], label_opts=LabelOpts(position="right")) bar1.reversal_axis() bar2 = Bar() bar2.add_xaxis(["中国", "美国", "英国"]) bar2.add_yaxis("GDP", [50, 30, 20], label_opts=LabelOpts(position="right")) bar2.reversal_axis() timeline = Timeline( {"theme": ThemeType.LIGHT} # 设置主题 ) timeline.add(bar1, "2021年GDP") timeline.add(bar2, "2022年GDP") # 设置自动播放 timeline.add_schema( play_interval=300, # 自动播放时间间隔 is_timeline_show=True, # 是否在自动播放的时候，显示时间线 is_auto_play=True, # 是否自动播放 is_loop_play=True # 是否循环播放 ) # 通过时间线绘图 timeline.render("基础柱状图-时间线.html")
03 动态GDP柱状图绘制
-
列表的sort方法
列表.sort(key=选择排序依据的函数，reverse=True|False)
- 参数key，要去传入一个函数，表示将列表的每一个元素都传入函数中，返回排序依据
- 参数reverse，是否反转排序结果，True表示降序，False表示升序
my_list = [["a", 33], ["b", 55], ["c", 11]] def chosse_sort_key(element): return element[1] my_list.sort(key=chosse_sort_key, reverse=True) print(my_list) # 匿名函数 my_list.sort(key=lambda element: element[1], reverse=True) print(my_list) -
数据处理
""" GDP动态图开发 """ from pyecharts.charts import Bar, Timeline from pyecharts.options import * from pyecharts.globals import ThemeType timeline = Timeline({ "theme": ThemeType.LIGHT }) f = open("D:/1960-2019全球GDP数据.csv", 'r', encoding="GB2312") data_lines = f.readlines() f.close() data_lines.pop(0) data_dict = {} for line in data_lines: year = int(line.split(",")[0]) # 年份 country = line.split(",")[1] # 国家 gdp = float(line.split(",")[2]) # GDP数据 # 如何判断字段里面有没有key try: data_dict[year].append([country, gdp]) except KeyError: data_dict[year] = [] data_dict[year].append([country, gdp]) # print(data_dict[1960]) sorted_year_list = sorted(data_dict.keys()) for year in sorted_year_list: data_dict[year].sort(key=lambda element: element[1], reverse=True) # 取出本年份前8的国家 year_data = data_dict[year][0:8] x_data = [] y_data = [] for country_gdp in year_data: x_data.append(country_gdp[0]) y_data.append(country_gdp[1]/100000000) bar = Bar() x_data.reverse() y_data.reverse() bar.add_xaxis(x_data) bar.add_yaxis("GDP(亿)", y_data, label_opts=LabelOpts(position="right")) # 反转x轴和y轴 bar.reversal_axis() # 设置每年图标标题 bar.set_global_opts( title_opts=TitleOpts(title=f"{year}年全球前8GDP数据") ) timeline.add(bar, str(year)) timeline.add_schema( play_interval=500, is_timeline_show=True, is_auto_play=True, is_loop_play=False ) # 绘图 timeline.render("1960年-2019全球GDP前8国家.html")
第二阶段 第1章
01 初识对象
-
设计一个类
class Student: name = None gender = None nationality = None native_place = None age = None stu1 = Student() stu1.name = "zhangsan" stu1.gender = "男" stu1.nationality = "中国" stu1.native_place = "山东省" stu1.age = 26 print(stu1.name) print(stu1.gender) print(stu1.nationality) print(stu1.native_place) print(stu1.age)
02 类的成员方法
-
类的定义和使用
class 类名称 类的属性 # 即定义在类中的变量（成员变量） 类的行为 # 即定义在类函数中的函数（成员方法） 对象 = 类名称（）创建类对象的语法 -
成员方法的定义语法
def 方法名(self, 形参1， 形参2，……，形参N)： 方法体self关键字是成员方法定义的时候，必须填写的。
- 它用来表示自身的意思
- 当我们使用类对象调用方法的是，self会自动被python传入
- 在方法内部，想要访问类的成员变量，必须使用self
self关键字传参数的时候可以忽略
""" 演示面向对象类中的成员方法定义和使用 """ # 定义一个带有成员方法的类 class Student: name = None # 学生的姓名 def say_hi(self): print(f"大家好呀！我是{self.name}，欢迎大家多多关照") def say_hi2(self, msg): print(f"大家好！我是{self.name}, {msg}") stu = Student() stu.name = "zhangsan" stu.say_hi2("哎呦不错哟") stu2 = Student() stu2.name = "lisi" stu2.say_hi2("小伙子，我看好你") stu3 = Student() stu3.name = "wangwu" stu3.say_hi2("希望大家天天开心")
03 类和对象
-
基于类创建对象
""" 演示类和对象的关系，即面向对象的编程套路 """ # 设计一个闹钟类 class Clock: id = None price = None def ring(self): import winsound winsound.Beep(2000, 3000) # 构建2个闹钟对象并让其工作 clock1 = Clock() clock1.id = "003032" clock1.price = 19.99 print(f"闹钟ID：{clock1.id}，价格：{clock1.price}") clock1.ring() clock2 = Clock() clock2.id = "003033" clock2.price = 21.99 print(f"闹钟ID：{clock2.id}，价格：{clock2.price}") clock1.ring()
04 构造方法
-
属性（成员变量赋值）
-
构造方法
python类可以使用：_init_()方法，称之为构造方法
可以实现
- 在创建类对象（构造类）的时候，会自动执行
- 在创建类对象（构造类）的时候，将传入参数自动传递给_init_()方法使用。
""" 演示类的构造方法 """ # 演示使用构造方法对成员变量进行赋值 # 构造方法的名称：__init__ class Student: def __init__(self, name, age, tel): self.name = name self.age = age self.tel = tel print("Student类创建了一个类对象") stu = Student("zhangsan", 18, "1888888888") -
构造方法注意事项
- 构造方法不要忘记self关键字
- 在方法内使用成员变量需要使用self
-
学生信息录入
class Student: def __init__(self, name, age, addr): self.name = name self.age = age self.addr = addr for i in range(1,11): print(f"当前录入第{i}位学生信息，总共需录入10位学生信息") name = input("请输入学生姓名:") age = input("请输入学生年龄:") addr = input("请输入学生地址:") stu = Student(name, age, addr) print(f"学生{i}信息录入完成，信息为：【学生姓名:{name}，年龄：{age}，地址：{addr}】")
05 魔术方法
-
__str__字符串方法
class Student: def __init__(self, name, age): self.name = name # 学生姓名 self.age = age # 学生年龄 # __str__魔术方法 def __str__(self): return f"Student类对象，name:{self.name}，age:{self.age}" stu = Student("zhangsan", 18) print(stu) -
__lt__小于符号比较方法
class Student: def __init__(self, name, age): self.name = name # 学生姓名 self.age = age # 学生年龄 # __lt__魔术方法 def __lt__(self, other): return self.age < other.age stu1 = Student("zhangsan", 18) stu2 = Student("lisi", 26) print(stu1 < stu2) -
__le__小于等于比较运算符
class Student: def __init__(self, name, age): self.name = name # 学生姓名 self.age = age # 学生年龄 # __le__魔术方法 def __le__(self, other): return self.age <= other.age stu1 = Student("zhangsan", 18) stu2 = Student("lisi", 26) print(stu1 <= stu2) -
__eq__比较运算符实现方法
class Student: def __init__(self, name, age): self.name = name # 学生姓名 self.age = age # 学生年龄 # __eq__魔术方法 def __eq__(self, other): return self.age == other.age stu1 = Student("zhangsan", 18) stu2 = Student("lisi", 26) print(stu1 == stu2)
06 封装
-
私有成员 只能类内部其他成员使用
__变量名
__方法名
""" 演示面向对象封装思想中私有成员的使用 """ # 定义一个类，内含私有成员变量和私有成员方法 class Phone: __current_voltage = 0.5 # 当前手机运行电压 def __keep_single_core(self): print("让CPU以单核模式运行") def call_by_5g(self): if self.__current_voltage >= 1: print("5G通话已开启") else: self.__keep_single_core() print("电量不足，无法使用5G通话，并已设置为单核运行") phone = Phone() phone.call_by_5g() -
练习
class Phone: __is_5g_enable = False def __check_5g(self): if self.__is_5g_enable: print("5G开启") else: print("5G关闭，使用4G网络") def call_by_5g(self): self.__check_5g() print("正在通话中") phone = Phone() phone.call_by_5g()
08 继承
-
语法
class 类名(父类名): 类内容体 -
单继承 --一个子类继承1个父类
class Phone: IMEI = None # 序列号 producer = "HM" # 厂商 def call_by_4g(self): print("4g通话") class Phone2022(Phone): face_id = "10001" # 面部识别ID def call_by_5g(self): print("2022年新功能：5g通话") phone = Phone2022() print(phone.producer) phone.call_by_5g() phone.call_by_4g() -
多继承—一个子类继承多个父类
多个父类中，如果有同名成员，那么默认以继承顺序（从左到右）为优先级
即：先继承的保留，后继承的被覆盖
class 类名(父类1, 父类2，……，父类N): 类内容体""" 演示面向对象：继承的基础语法 """ # 演示单继承 class Phone: IMEI = None # 序列号 producer = "HM" # 厂商 def call_by_4g(self): print("4g通话") # 演示多继承 class NFCReader: nfc_type = "第五代" producer = "It" def read_card(self): print("NFC读卡") def write_card(self): print("NFC写卡") class RemoteControl: rc_type = "红外遥控" def control(self): print("红外遥控开启了") class MyPhone(NFCReader,Phone, RemoteControl): pass phone = MyPhone() phone.call_by_4g() phone.read_card() phone.write_card() phone.control() print(phone.producer) # 演示多继承下，父类成员名一致的场景 -
pass关键字的作用
pass是占位语句，用来保证函数（方法）或类的定义完整性，表示无内容，空的意思
09 复写父类成员和调用父类成员
-
复写父类
class Phone: IMEI = None producer = "ITCAST" def call_by_5g(self): print("使用5g进行通话") class MyPhone(Phone): producer = "ITHAIMA" # 复写父类的成员属性 def call_by_5g(self): print("开启CPU单核模式，确保通话的时候省电") print("使用5g网络进行通话") phone = MyPhone() phone.call_by_5g() print(phone.producer) -
调用父类的同名成员
方式1：调用父类成员
- 使用成员变量：父类名.成员变量
- 使用成员方法：父类名.成员方法（self）
方式2：使用super()调用父类成员
- 使用成员变量：super().成员变量
- 使用成员方法：super().成员方法()
class Phone: producer = "ITCAST" def call_by_5g(self): print("使用5g进行通话") class MyPhone(Phone): producer = "ITHAIMA" # 复写父类的成员属性 def call_by_5g(self): print("开启CPU单核模式，确保通话的时候省电") super().call_by_5g() phone = MyPhone() phone.call_by_5g() print(Phone.producer)
10 类型注解
-
变量的类型注解
语法：变量：类型
-
函数（方法）形参列表和返回值的类型注解
""" 演示变量的注释类型 """ import json import random # 基础数据类型注解 var_1: int = 10 var_2: str = "itheima" var_3: bool = True # 类对象类型注解 class Student: pass stu: Student = Student() # 基础容器类型注解 my_list: list = [1, 2, 3] my_tuple: tuple = (1, 2, 3) my_dict: dict = {"zhangsan": 18} # 容器类型详细注解 my_list1: list[int] = [1, 2, 3] my_tuple1: tuple[int, str, bool] = (1, 2, 3) my_dict1: dict[str, int] = {"zhangsan": 18} # 在注释中进行类型注解 var_11 = random.randint(1, 10) # type: int var_22 = json.loads({"name": "zhangsan"}) # type: dict[str, str] def func(): return 10 var_33 = func() #type: int -
一般，无法直接看出变量类型时会添加变量的类型注解
-
帮助开发者自身对变量进行类型注释（备注）
11 函数和方法类型注解
-
语法：
def 函数方法名(形参名：类型，形参名：类型)： pass -
对返回值进行类型注解
def 函数方法名(形参名：类型，形参名：类型) -> 返回值类型： pass""" 演示函数（方法）进行类型注解 """ # 对形参进行类型注解 def add(x: int, y: int): return x + y add() # 对返回值进行类型注解 def func(data: list) -> list: return data
12 Union联合类型注解
-
Union类型
""" 演示Union联合类型注解 """ # 使用Unino类型，必须先导包 from typing import Union my_list: list[Union[int, str]] = [1, 2, "iit", "python"] def func(data: Union[int, str]) -> Union[str, int]: pass func()
13 多态
-
示例
""" 演示面向对象的多态特性以及抽象类（接口）的使用 """ class Animal: def speak(self): pass class Dog(Animal): def speak(self): print("汪汪汪") class Cat(Animal): def speak(self): print("喵喵喵") def make_noise(animal: Animal): """制造噪音点，需要传入Aniaml对象""" animal.speak() # 演示多态，使用2个子类对象来调用函数 dog = Dog() cat = Cat() make_noise(dog) make_noise(cat)
14 综合案例
-
data_define.py
""" 数据定义的类 """ class Record: def __init__(self, date, order_id, money, province): self.date = date # 订单日期 self.order_id = order_id # 订单ID self.money = money # 订单金额 self.province = province # 销售省份 def __str__(self): return f"{self.date}, {self.order_id}, {self.money}, {self.province}" -
file_define.py
""" 数据定义的类 """ class Record: def __init__(self, date, order_id, money, province): self.date = date # 订单日期 self.order_id = order_id # 订单ID self.money = money # 订单金额 self.province = province # 销售省份 def __str__(self): return f"{self.date}, {self.order_id}, {self.money}, {self.province}" -
main.py
""" 面向对象，数据分析案例，主业务逻辑代码 实现步骤： 1. 设计一个类。可以完成数据的封装 2. 设计一个抽象类，定义文件读取相关功能，并使用子类实现具体功能 3. 读取文件，生产数据对象 4. 进行数据需求的逻辑计算（计算每一天的销售额） 5. 通过pyecharts进行图形绘制 """ from file_define import FileReader, TextFileReader, JsonFileReader from data_define import Record from pyecharts.charts import Bar from pyecharts.options import * from pyecharts.globals import ThemeType text_file_reader = TextFileReader("D:/2011年1月销售数据.txt") json_file_reader = JsonFileReader("D:/2011年2月销售数据JSON.txt") jan_data: list[Record] = text_file_reader.read_data() feb_data: list[Record] = json_file_reader.read_data() # 将两个月份的数据合并为一个list来存储 all_data: list[Record] = jan_data + feb_data # 开始进行数据计算 data_dict = {} for record in all_data: if record.date in data_dict.keys(): # 当前日期已存在 data_dict[record.date] += record.money else: data_dict[record.date] = record.money # 可视化图表开发 bar = Bar(init_opts=InitOpts(theme=ThemeType.LIGHT)) bar.add_xaxis(list(data_dict.keys())) # 添加X轴数据 bar.add_yaxis("销售额", list(data_dict.values()), label_opts=LabelOpts(is_show=False)) # 添加Y轴数据 bar.set_global_opts( title_opts=TitleOpts(title="每日销售额") ) bar.render("每日销售额柱状图.html")
第三阶段 Python高阶技巧
01 闭包
-
定义双层嵌套函数，内层函数可以访问外层函数的变量
-
将内层函数作为外层函数的返回，此内层函数就是闭包函数
-
在闭包函数（内层函数中）想要修改外部函数的变量值，需要用nonloacl声明这个外部变量
-
简单示例
def outer(logo): def inner(msg): print(f"<{logo}>{msg}<{logo}>") return inner fn1 = outer("黑马程序员") fn1("大家好") f2 = outer("传智教育") f2("大家好")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 a = account_create() a(100) a(100) a(100, deposit=False)
02 装饰器
-
其实也是一种闭包，其功能就是在不破坏目标函数原有的代码和功能的前提下，为目标函数增加新功能
-
装饰器的一般写法（闭包写法）
""" 演示装饰器的写法 """ # 装饰器的一般写法（闭包） 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()
03 设计模式-单例模式
-
单例：节省内存，节省创建对象的开销
-
str_tools.py
class StrTools: pass str_tool = StrTools() -
main.py
from str_tools import str_tool s1 = str_tool s2 = str_tool print(id(s1)) print(id(s2))
04 工厂模式
-
大量创建一个类的实例的时候，可以使用工厂模式
""" 演示设计模式之工厂模式 """ class Person: pass class Worker(Person): pass class Student(Person): pass class Teacher(Person): pass class PersonFactory: def get_person(self, p_type): if p_type == 'w': return Worker() elif p_type == "s": return Student() else: return Teacher() pf = PersonFactory() worker = pf.get_person('w') stu = pf.get_person('s') teacher = pf.get_person('t')
05 多线程并行执行概念
- 进程：程序在一个操作系统内运行，即成为一个运行进程
- 线程：进程内部可以有多个线程，程序的运行本质就是由进程内部的线程在实际工作的
- 并行执行：
- 多个进程同时在运行，即不同程序同时运行，称之为：多任务并行执行
- 一个进程内的多个线程同时在运行，称之为：多线程并行执行
06 多线程编程
-
threading模块
""" 演示多线程编程的使用 """ import time import threading def sing(msg): while True: print(msg) time.sleep(1) def dance(msg): while True: print(msg) time.sleep(1) if __name__ == '__main__': # 创建一个唱歌的线程 sing_thread = threading.Thread(target=sing, args=("我要唱歌 哈哈哈", )) # 创建一个跳舞的线程 dance_thread = threading.Thread(target=dance, kwargs={"msg": "我在跳舞，啦啦啦"}) # 让线程开始工作 sing_thread.start() dance_thread.start()
07 Socket服务端开发
-
socket服务端
""" 演示Socket服务端开发 """ import socket # 创建Socket对象 socket_sever = socket.socket() # 绑定ip地址和端口 socket_sever.bind(("localhost", 8888)) # 监听端口 socket_sever.listen(1) # listen方法内接受一个整数传参数，表示接受的链接数量 # 等待客户端连接 # result = socket_sever.accept() # conn = result[0] # 客户端和服务端的链接对象 # address = result[1] # 客户端地址信息 conn, address = socket_sever.accept() # accept方法返回的是二元元组（链接对象， 客户端地址信息） # 可以通过变量1，变量2 = socket_server.accept()的形式，直接接受二元元组内的两个元素 # accept()方法，是阻塞方法，等待客户端的链接，如果没有链接，就卡在这一行不执行了 print(f"接收到了客户端的链接，客户端信息是：{address}") while True: # 接受客户端信息，要使用客户端和服务单的本次链接对象，而非socket_server对象 data : str = conn.recv(1024).decode("UTF-8") # recv接受的参数是缓冲区大小，一般给1024即可 # recv方法的返回值是一个字节数组也就是bytes对象，不是字符串，可以通过decode方法编码，将字节数组转换为字符串对象 print(f"客户端发来的消息是：{data}") # 发送回复消息 msg = input("请输入你要和客户端回复的消息:") if msg == 'exit': break conn.send(msg.encode("UTF-8")) # 关闭链接 conn.close() socket_sever.close()
08 Socket客户端编程
-
Socket客户端
""" 演示Socket客户端开发 """ import socket # 创建socket对象 socket_client = socket.socket() # 连接到服务器 socket_client.connect(("localhost", 8888)) # 发送消息 while True: msg = input("请输入你要给服务端发送的消息：") if msg == 'exit': break socket_client.send(msg.encode("UTF-8")) # 接收返回消息 recv_data = socket_client.recv(1024) # 1024是缓冲区的大小，一般1024即可，同样recv方法是阻塞的 print(f"服务端回复的消息是：{recv_data.decode('UTF-8')}") # 关闭链接 socket_client.close()
09 正则表达式-基础方法
-
正则的三个基础方法
Python正则表达式，使用re模块，并基于re模块中三个基础方法来做正则匹配
分别是：match、search、findall三个基础方法
-
re.match（匹配规则，被匹配字符串）
从被匹配字符串开头进行匹配，匹配成功返回匹配对象（包含匹配信息），匹配不成功返回空
-
re.search（匹配规则，被匹配字符串）
搜索整个字符串，找出匹配的。从前向后，找到第一个后，就停止 ，不会继续向后
-
re.findall（匹配规则，被匹配字符串）
匹配整个字符串，找出全部匹配项。找不到返回空list: []
""" 演示Python正则表达式re模块的3个基础匹配方法 """ import re s = "python itheima" # match 从头匹配 result = re.match("python", s) print(result) print(result.span()) print(result.group()) # search 搜索匹配 s1 = "1python666itheima6666python1111python" result = re.search("python", s1) print(result) # findall搜索匹配 result = re.findall("python", s1) print(result) import re s = "python itheima" # match 从头匹配 result = re.match("python", s) print(result) print(result.span()) print(result.group()) # search 搜索匹配 s1 = "1python666itheima6666python1111python" result = re.search("python", s1) print(result) # findall搜索匹配 result = re.findall("python", s1) print(result) -
10 正则表达式-元字符匹配
| 字符 | 工能 |
|---|---|
| . | 匹配任意1个字符（除了\n）,\. 匹配.本身 |
| [] | 匹配[]中列举的字符 |
| \d | 匹配数字，即0-9 |
| \D | 匹配非数字 |
| \s | 匹配空白，即空格、tab键 |
| \S | 匹配非空白 |
| \w | 匹配单词字符，即a-z、A-Z、0-9、_ |
| \W | 匹配非单词字符 |
数量匹配
| 字符 | 功能 |
|---|---|
| * | 匹配前一个规则的字符出现0至无数次 |
| + | 匹配前一个规则的字符出现1至无数次 |
| ？ | 匹配前一个规则的字符出现0次或1次 |
| {m} | 匹配前一个规则的字符出现m次 |
| {m,} | 匹配前一个规则的字符出现最少m次 |
| {m,n} | 匹配前一个规则的字符出现m到n次 |
边界匹配
| 字符 | 功能 |
|---|---|
| ^ | 匹配字符串开头 |
| $ | 匹配字符串结尾 |
| \b | 匹配一个单词的边界 |
| \B | 匹配非单词边界 |
分组匹配
| 字符 | 功能 |
|---|---|
| | | 匹配左右任意一个表达式 |
| () | 将括号中字符作为一个分组 |
示例
"""
演示python正则表达式使用元字符进行匹配
"""
import re
s = "zhangsan @@python !!!6666 ##study8899"
result1 = re.findall(r'\d', s) # 字符串前面带上r的标记，表示字符串中转义字符无效，就是普通字符的意思
print(result1)
# 找出特殊字符
result2 = re.findall(r'\W', s)
print(result2)
# 找出全部英文字母
result3 = re.findall(r'[a-zA-Z]', s) # []内可以写：a-zA-Z0-9这三种指定范围组合或指定单个字符如[aceDFG123]
print(result3)
# 匹配账号，只能由字母和数字组成，长度限制6-10位
r = '[a-zA-Z0-9]{6,10}$'
s = '123328a'
print(re.findall(r, s))
# 匹配QQ号，要求纯数字，长度5-11，第一位不为0
r = '^[1-9][0-9]{4,10}$'
s = '123445'
print(re.findall(r, s))
# 匹配邮箱地址，只允许qq、163、gmail这三种邮箱地址
r = '(^[\w-]+(\.[\w-]+)*@(qq|163|gmail)(\.[\w-]+)+$)'
s = 'a.b.c.d@gmail.com.z.zz.dd'
print(re.match(r, s).group())
11 递归
-
自己调用自己
-
递归使用注意事项：
- 注意退出的条件，否则容易变成无限递归
- 注意返回值的传递，确保从最内层，层层传递到最外层
""" 演示python递归操作 需求：通过递归，找出一个指定文件内的全部内容 思路：写一个函数，列出文件夹内的全部内容，如果是文件就收集到list 如果是文件夹，就递归调用自己，再次判断 """ import os def test_os(): """演示os模块的3个基础方法""" print(os.listdir("D:/test")) # 列出路径下的内容 print(os.path.isdir("D:/test/a")) # 判断指定路径是不是文件夹 print(os.path.exists("D:/test")) # 判断指定路径是否存在 def get_files_recursion_from_dir(path): """ 从指定的文件夹中使用递归的方式，获取全部的文件列表 :param path: 被判断的文件夹 :return: list，包含全部的文件，如果目录不存在或者无文件就返回一个空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_files_recursion_from_dir(new_path) else: file_list.append(new_path) else: print(f"指定的目录{path}，不存在") return [] return file_list if __name__ == '__main__': print(get_files_recursion_from_dir("D:/test"))
))
print(result.group())
-
search 搜索匹配
s1 = “1python666itheima6666python1111python”
result = re.search(“python”, s1)
print(result) -
findall搜索匹配
result = re.findall(“python”, s1)
print(result)
import re
s = “python itheima”
-
match 从头匹配
result = re.match(“python”, s)
print(result)
print(result.span())
print(result.group()) -
search 搜索匹配
s1 = “1python666itheima6666python1111python”
result = re.search(“python”, s1)
print(result) -
findall搜索匹配
result = re.findall(“python”, s1)
print(result)
## 10 正则表达式-元字符匹配
| 字符 | 工能 |
| ---- | --------------------------------------- |
| . | 匹配任意1个字符（除了\n）,\\. 匹配.本身 |
| [] | 匹配[]中列举的字符 |
| \d | 匹配数字，即0-9 |
| \D | 匹配非数字 |
| \s | 匹配空白，即空格、tab键 |
| \S | 匹配非空白 |
| \w | 匹配单词字符，即a-z、A-Z、0-9、_ |
| \W | 匹配非单词字符 |
数量匹配
| 字符 | 功能 |
| ----- | --------------------------------- |
| * | 匹配前一个规则的字符出现0至无数次 |
| + | 匹配前一个规则的字符出现1至无数次 |
| ？ | 匹配前一个规则的字符出现0次或1次 |
| {m} | 匹配前一个规则的字符出现m次 |
| {m,} | 匹配前一个规则的字符出现最少m次 |
| {m,n} | 匹配前一个规则的字符出现m到n次 |
边界匹配
| 字符 | 功能 |
| ---- | ------------------ |
| ^ | 匹配字符串开头 |
| $ | 匹配字符串结尾 |
| \b | 匹配一个单词的边界 |
| \B | 匹配非单词边界 |
分组匹配
| 字符 | 功能 |
| ---- | ------------------------ |
| \| | 匹配左右任意一个表达式 |
| () | 将括号中字符作为一个分组 |
示例
```python
"""
演示python正则表达式使用元字符进行匹配
"""
import re
s = "zhangsan @@python !!!6666 ##study8899"
result1 = re.findall(r'\d', s) # 字符串前面带上r的标记，表示字符串中转义字符无效，就是普通字符的意思
print(result1)
# 找出特殊字符
result2 = re.findall(r'\W', s)
print(result2)
# 找出全部英文字母
result3 = re.findall(r'[a-zA-Z]', s) # []内可以写：a-zA-Z0-9这三种指定范围组合或指定单个字符如[aceDFG123]
print(result3)
# 匹配账号，只能由字母和数字组成，长度限制6-10位
r = '[a-zA-Z0-9]{6,10}$'
s = '123328a'
print(re.findall(r, s))
# 匹配QQ号，要求纯数字，长度5-11，第一位不为0
r = '^[1-9][0-9]{4,10}$'
s = '123445'
print(re.findall(r, s))
# 匹配邮箱地址，只允许qq、163、gmail这三种邮箱地址
r = '(^[\w-]+(\.[\w-]+)*@(qq|163|gmail)(\.[\w-]+)+$)'
s = 'a.b.c.d@gmail.com.z.zz.dd'
print(re.match(r, s).group())
11 递归
-
自己调用自己
-
递归使用注意事项：
- 注意退出的条件，否则容易变成无限递归
- 注意返回值的传递，确保从最内层，层层传递到最外层
""" 演示python递归操作 需求：通过递归，找出一个指定文件内的全部内容 思路：写一个函数，列出文件夹内的全部内容，如果是文件就收集到list 如果是文件夹，就递归调用自己，再次判断 """ import os def test_os(): """演示os模块的3个基础方法""" print(os.listdir("D:/test")) # 列出路径下的内容 print(os.path.isdir("D:/test/a")) # 判断指定路径是不是文件夹 print(os.path.exists("D:/test")) # 判断指定路径是否存在 def get_files_recursion_from_dir(path): """ 从指定的文件夹中使用递归的方式，获取全部的文件列表 :param path: 被判断的文件夹 :return: list，包含全部的文件，如果目录不存在或者无文件就返回一个空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_files_recursion_from_dir(new_path) else: file_list.append(new_path) else: print(f"指定的目录{path}，不存在") return [] return file_list if __name__ == '__main__': print(get_files_recursion_from_dir("D:/test"))补充：Python操作mysql
-
示例
""" 演示Python pymysql库的基础 """ from pymysql import Connection # 构建到MySQL数据库的链接 conn = Connection( host="localhost", port=3306, user="root", password="123456" ) # print(conn.get_server_info()) # 执行非查询性质的SQL cursor = conn.cursor() # 获取游标对象 # 选择数据库 conn.select_db("world") # # 执行SQL # cursor.execute("create table test_pymysql(id int);") # 执行查询性质的SQL cursor.execute("select * from city") results = cursor.fetchall() print(results) for r in results: print(r) # 关闭连接 conn.close() -
数据插入
""" 演示Python pymysql库的基础 """ from pymysql import Connection # 构建到MySQL数据库的链接 conn = Connection( host="localhost", port=3306, user="root", password="123456", autocommit=True ) cursor = conn.cursor() # 获取游标对象 # 选择数据库 conn.select_db("world") # # 执行SQL cursor.execute("insert into countrylanguage values('AFG', 'English', 'F', 11.8)") # 关闭连接 conn.close() -
读取数据库文件，转换为json格式
import json from pymysql import Connection # 构建到MySQL数据库的链接 conn = Connection( host="localhost", port=3306, user="root", password="123456" ) cursor = conn.cursor() # 获取游标对象 # 选择数据库 conn.select_db("world") cursor.execute("select * from city") results = cursor.fetchall() def readerData(): for r in results: data = dict = {} dict["ID"] = r[0] dict["Name"] = r[1] dict["CountryCode"] = r[2] dict["District"] = r[3] dict["Population"] = r[4] json_data = json.dumps(data) print(json_data) with open("D:/data.txt", 'a', encoding="utf-8") as f: f.write(json_data) f.write("\n") readerData() # 关闭连接 conn.close()
1710
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
