Python 基础知识学习笔记
学习目标：
两周掌握 Python 入门知识
学习内容：
day01 搭建开发环境
1、看书: Python编程：从入门到实践.pdf 第二章.
2、了解三大操作系统
1、Unix ：MacOS
2、Linux ：Ubuntu18.04 、CentOS、RedHat
3、Windows ：Win7、Win8、Win10
3、CSDN注册
能看到这篇文章，可以忽略了！懂得都懂。
4、安装教学环境
Python3.9安装包
python3.9安装包+numpy cp39+matplotlib cp39
Python安装教程
安装包 包含numpycp39+matplotlib cp39的原因是，因不了解规则，我在安装这两个包时耗时时间太长。希望对看到这篇文章的小伙伴有帮助，一下是曾经遇到的问题和解决方法
导包问题解决–ImportError: DLL load failed while importing _path: 找不到指定的模块
Pycharm安装包
pycharm安装包-pycharm-community-2022.1.3
Pycharm安装教程
5、安装成功检测
5.1 Python安装检测
cmd + python + enter
5.2 Pycharm安装检测
一下技能依据个人能力，自行了解。
6、Linux命令
1、pwd ：查看当前所在路径
2、cd ：切换目录
cd 路径
cd … ：回退到上一级目录
cd ：回到用户主目录
史上最全的Linux常用命令汇总（超全面！超详细！）
7、Pycharm常用快捷键
[Pycharm常用快捷键](https://blog.csdn.net/momoda118/article/details/120155611?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522169240893416777224427135%2522%252C%2522scm%2522%253A%252220140713.130102334..%2522%257D&request_id=169240893416777224427135&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2~blog~top_click~default-3-120155611-null-null.268%5Ev1%5Ekoosearch&utm_term=Pycharm%E5%BF%AB%E6%8D%B7%E9%94%AE&spm=1018.2226.3001.4450)
day02 名词理解
完成环境配置，开始学习语法基础：
1、第一个Python程序 ：hello world
hello.py
print("你好,世界")
了解常用函数
标准输出函数 print()----作用 ：把内容输出到终端
标准输入函数input()----作用 ：内置函数从标准输入（键盘）读入一行文本，默认的标准输入是键盘。
score = int(input('请输入成绩:'))
print('成绩为:%d' % score)
2、注释
注释的作用，能够大大增强程序的可读性。在代码关键部位加上注释，以方便程序员的理解和阅读，工作中同事之间都是相互配合工作的，从而增加工作效率。
注释的特点：
解释器不执行注释内容，注释可以在任何位置
一般在书写单行注释的时候，在#好后面空一格再写内容，如果单行注释紧跟在代码后面，一般是代码后面空2格后再写#号
# 单行注释
"""
多行注释
"""
3、变量
定义：关联一个对象的标识符。
变量名定义时注意事项：
-
变量名的定义不允许以数字开头，必须是字母或下划线开头，后跟字母、数字、下划线。
-
变量名不支持除了_（下划线）以外的特殊字符
-
变量名是区分大小写的
-
不支持中文作为变量名，必须使用英文
-
不能使用python关键字作为变量名（比如print就不能拿来做变量名）
否则发生语法错误：SyntaxError: invalid syntax。
建议命名：字母小写，多个单词以下划线隔开。
class_name
赋值：创建一个变量或改变一个变量绑定的数据。
语法：变量名 = 数据
变量名1 = 变量名2 = 数据
变量名1, 变量名2, = 数据1, 数据2
变量的定义方式：变量名=value 例：a=1
多个变量的命名格式：变量名1,变量名2=value1,value2 例：a,b=1,2
删除变量名格式： del 变量名 删除后的变量名再也无法访问
"""
变量
"""
# 变量名 = ....
a = "你好"
b = "python"
c = b + a
class_name = "2023"
stu_name = "zxs"
class_name = class_name + stu_name
4、常量
在程序运行的过程中，值不会发生变化的量
从代码的角度而言，直接在代码中出现的数据，统称为字面量；变量通过特殊的手段可以变成常量的形式；
整数常量
浮点数常量
复数常量
布尔值常量
None常量
字符串常量
>>> print(0)
0
>>> print(-3)
-3
>>> 3 > 2
True
>>> 3 < 2
False
>>> 4 > 2 and 3 < 2
False
>>> True and False
False
>>> print("Hello World!")
Hello World!
>>> print('a')
a
在python中可以通过自定义实现常量，要求常量的标识符必须全是大写字母，且该值不能被修改。
PI=3.1415926
URL = 'www.taobao.com'
5、数据类型
Number（数字）
String（字符串）
bool（布尔类型）
List（列表）
Tuple（元组）
Set（集合）
Dictionary（字典）
Python3 的六个标准数据类型中：
不可变数据（3 个）：Number（数字）、String（字符串）、Tuple（元组）；
可变数据（3 个）：List（列表）、Dictionary（字典）、Set（集合）。
Number（数字）、String（字符串）、bool（布尔类型）
"""
数据类型
"""
# 1. 整数int
常使用十进制与十六进制
# -- 十进制
num01 = 18
# -- 十六进制(每逢16进1) 0--9 a(10) -- f(15)
num04 = 0x10
print(num04)
# 2. 浮点数(小数)float
f01 = 1.0
f02 = 1.234e2
print(f02)
f03 = 1.234e-3
print(f03)
字符串规则 英文双引号 "XXX"
# 3. 字符串str
s01 = "唐僧"
s02 = "10"
s03 = "1.5"
print("10"+"2")
print(10+2)
# 4. 复数 complex
c01 = 1j
c02 = 5 + 1j
print(c02)
print(type(c01))
# 5. 布尔bool
b01 = True # 真的 对的 成立的 满足条件的
b02 = False# 假的 错的 不成立的 不满足条件的
b03 = 1 > 2
print(b03)
先了解列表、元组、集合、字典的写法
List（列表）、Tuple（元组）、Set（集合）、Dictionary（字典）
# 列表 识别方法[,,,,]
list = [ 'abcd', 786 , 2.23, 'runoob', 70.2 ]
# 元组 识别方法(,,,,)
tuple = ( 'abcd', 786 , 2.23, 'runoob', 70.2 )
# 集合 识别方法{,,,,}
sites = {'Google', 'Taobao', 'Runoob', 'Facebook', 'Zhihu', 'Baidu'}
# 字典 识别方法{:,:,:,:,}
tinydict = {'name': 'runoob','code':1, 'site': 'www.runoob.com'}
6、函数
如果在开发程序时，需要某块代码多次，但是为了提高编写的效率以及代码的重用，所以把具有独立功能的代码块组织为一个小模块，这就是函数
先慢慢理解。
7、语句块
语句块是在条件为真（条件语句）时执行或者执行多次（循环语句）的一组语句。在代码前放置空格来缩进语句即可创建语句块。
8、python行
1.物理行：程序员编写代码的行
2.逻辑行：python解释器需要执行的指令
3.建议一个逻辑行在一个物理行上
4.如果物理行中使用多个逻辑行，需要分号隔开
5.如果逻辑行过长，可以使用隐式换行，所有括号内的内容都是隐式换行
括号包括:() [] {}
"""行"""
# 3个物理行3个逻辑行
a =1
b=2
a+=b
# 1个物理行3个逻辑行
a=1;b=2;a+=b
# 一个物理行两个逻辑行\表示折行符
d=1+2+\
3+4
d=(
1+
2+
3+
4
)
9、简单练习
"""
简单练习
"""
name = input("请输入姓名:")
age = input("请输入年龄:")
print("输入的是:"+name)
print("年龄是:"+age)
10、 两个数据交换
# 在控制台获取一个变量
# 再获取一个变量
# 让两个变量交换.
# 输出结果
input01 = input("请输入第一个变量:")
input02 = input("请输入第二个变量:")
# 利用临时变量进行交换
# temp = input01
# input01 = input02
# input02 = temp
# 直接交换
# input01 , input02 = 222,111
input01, input02 = input02, input01
print("第一个变量是" + input01)
print("第二个变量是" + input02)
day03 运算规则
1、看书: Python编程：从入门到实践.pdf 第二章.
2、认识运算符
注：python中“=”是赋值的意思；“==”是用于判断是否相等
一、算术运算符
加：+
减：-
乘：*
除：/除尽 或 //取商
模：%
幂：**
二、赋值运算符
= ：等于
+=：加等于
-=：减等于
*= ：乘等于
/=：除等于
//=：整除等于
%=：模等于
**=：幂等于
三、关系运算符
大于：>
小于：<
恒等于：==
不等于：!=
大于等于：>=
小于等于：<=
四、逻辑运算符
与运算：and
或运算：or
非运算：not
五、位运算符
位与运算：&
位或运算：|
位异或运算：^
位取反运算：~
六、布尔运算
布尔数据类型是用于条件判断、比较运算和逻辑运算，只有两个值真（True）和假(False)。
标准值False和None、各种类型（包括浮点数、复数等）的数值0、空序列（如空字符串、空元组和空列表）以及空映射（如空字典）都被视为假，而其他各种值都被视为真。
>>> True == 1
True
>>> False == 0
True
>>> True + True
2
3、使用运算符
day04 知识回顾与习题练习
在练习一下习题时，如果有不理解的知识点，可以回顾day02和day03的知识点。
温度换算器(华氏度,摄氏度,开氏度)
# 温度换算器(华氏度,摄氏度,开氏度)
# 摄氏度 = (华氏度 - 32) / 1.8
# 华氏度 = 摄氏度*1.8 + 32
# 开氏度 = 摄氏度 + 273.15
# fahrenheit = float(input("请输入华氏度:"))
# centigrade = (fahrenheit - 32) / 1.8
# print("摄氏度是:"+str(centigrade))
# centigrade = float(input("请输入摄氏度:"))
# fahrenheit =centigrade *1.8 + 32
# print("华氏度是:"+str(fahrenheit))
centigrade = float(input("请输入摄氏度:"))
kelvin =centigrade + 273.15
print("开氏度是:"+str(kelvin))
获取圆形的半径
# 获取圆形的半径
# 计算面积(3.14 * r 的平方)与周长(2 * 3.14 * r)
radius = float(input("请输入半径"))
area = 3.14 * radius ** 2
# length = 2 * 3.14 * radius# 31.400000000000002
# round()函数可以四舍五入
length = round(2 * 3.14 * radius, 3)
print("面积是:" + str(area) + ",周5长是:" + str(length))
凌晨0:0:0秒计时，过了65520秒,现在是几点几分几秒
# 从凌晨0:0:0秒计时,到现在过了65520秒,现在是几点几分几秒
# 提示 ：地板除 和 取余
h = 65523 // 3600
m = 65523 % 3600 // 60
s = 65523 % 60
print('现在是%d时%d分%d秒' % (h,m,s))
在控制台中获取小时/分钟/秒,计算总秒数.
# 在控制台中获取小时/分钟/秒,计算总秒数.
hour = int(input("请输入小时:"))
minute = int(input("请输入分钟:"))
second = int(input("请输入秒:"))
result = hour * 3600 + minute * 60 + second
print("总秒数是:"+str(result))
day05 条件判断 / 循环语句
1、 看书: Python编程：从入门到实践.pdf 第五、七章.
2、if条件判断
1.1、if语句
对于if语句，若条件判定为真，那么后面的语句块就会被执行。若条件判定为假，语句块就会被跳过，不会执行。
sex = input("请输入性别:")
if sex == "男":
print("您好,先生!")
1.2、else语句
else子句只是增加一种选择（之所以叫做子句是因为它不是独立的语句，而是if的一部分）。if…else…搭配，若if语句为False，不执行if下的语句块，而去else下的语句块。
sex = input("请输入性别:")
if sex == "男":
print("您好,先生!")
else:
print("您好,女士!")
1.3、 elif语句
如果需要检查多个条件，就可以使用elif，它是else if的简写，也是if和else语句的联合使用，即使用elif做更细致的判断：
sex = input("请输入性别:")
if sex == "男":
print("您好,先生!")
elif sex == "女":
print("您好,女士!")
else:
print("性别未知")
1.4、条件语句总结
if <条件判断1>:
<执行1>
elif <条件判断2>:
<执行2>
elif <条件判断3>:
<执行3>
else:
<执行4>
1.5、注意点
if语句执行有个特点，它是从上往下判断，如果在某个判断上是True，把该判断对应的语句执行后，就忽略掉剩下的elif和else语句，所以，请测试并解释为什么下面的程序打印的是teenager：
3、if习题练习
购物实例
# 5.如果金额不足,提示还差多少钱,如果金额够,提示应找回多少钱.
# -- 尝试:如果总价到达100元,打八折.
str_unit_price = input("请输入商品单价:")
int_unit_price = float(str_unit_price)
amount = int(input("请输入商品数量:"))
money = float(input("请输入金额:"))
# 总金额
total_price = int_unit_price * amount
# 满足条件打折
if total_price >= 100:
total_price /= 0
# 如果钱够
if money > total_price:
result = money - total_price
print("应找回:"+str(result))
else:
print("还差"+str(total_price - money)+"钱")
# 调试:让程序在指定的行中断,然后逐语句执行,我们审查程序运行过程,以及变量的取值.
# 1. 在可能出错的行,加入断点.
# 2. 开始调试 Alt + Shift + F9
# 3. 命中断点后(断点行是蓝色的),逐语句执行F7.
# .....(判断执行过程,以及变量取值).....
# 4. 停止调试Ctrl + F2
奇偶判断
number = input('请输入一个数字:')
# 转成整型
number = int(number)
if number % 2 == 0:
print('%d是偶数' % number)
elif number % 2 != 0:
print('%d是奇数' % number)
数字判断
number = int(input('请输入一个数字:'))
if number > 0:
print('%d是正数' % number)
elif number < 0:
print('%d是负数' % number)
else:
print('零')
print('哇哈哈')
计算最大数
# 计算最大数
# 思路:假设第一个变量就是最大值,
# 然后一次与下面的几个变量进行比较,如果还有更大的则替换假设的.
num01 = 8
num02 = 6
num03 = 10
num04 = 5
max_value = num01
if max_value < num02:
max_value = num02
if max_value < num03:
max_value = num03
if max_value < num04:
max_value = num04
print(max_value)
判断是平年还是闰年
# 在控制台中输入一个年份
# 如果是闰年 则显示闰年 否则显示平年
year = int(input("请输入年份:"))
if year % 4 == 0 and year % 100 != 0 or year % 400 == 0:
print("闰年")
else:
print("平年")
返回该月份的天数
# 在控制台中输入一个月份,11:30
# 返回该月份的天数
# 1 3 5 7 8 10 12 ---> 31 天
# 4 6 9 11 ---> 30 天
# 2 ---> 28 天
month = int(input("请输入月份:"))
if month < 1 or month > 12:
print("输入有误")
elif month == 2:
print("28天")
elif month == 4 or month == 6 or month == 9 or month == 11:
print("30天")
else:
print("31天")
猜数字
import random
# 计算机出数字
computer = random.randint(1,5)
# 你出数字
you = int(input('我想好数字了,你来猜:'))
# 条件判断
if you == computer:
print('恭喜,猜对了!')
elif you > computer:
print('很遗憾,猜大了!')
else:
print('很遗憾,猜小了!')
4、while循环用法讲解
5、while习题练习
输出中间的数字
#在控制台中分别获取两个整数,一个作为开始值,一个作为结束值.
# 请输出中间的数字
# 8 13
# 9 10 11 12
begin = int(input("请输入开始值:"))# 8
end = int(input("请输入结束值:"))# 13
while begin < end - 1:
begin += 1
print(begin)
对折游戏
# 练习2:一张纸厚度是0.01毫米
# 请问,对折多少次,可以超过珠穆朗玛峰8844.43米.
thickness = 0.01 / 1000
count = 0# 计数器
while thickness < 8844.43:
thickness *= 2
count+=1
print(count)
猜数字
"""
猜数字1.0
规则:系统产生1 -- 100 之间的随机数.
让用户重复猜测,直到猜对了为止.
提示:大了 小了 猜对了.
猜数字2.0
最多只能猜10次.
"""
import random
random_number = random.randint(1, 100)
# 1.0
# while True:
# input_number = int(input("请输入:"))
# if input_number > random_number:
# print("大了")
# elif input_number < random_number:
# print("小了")
# else:
# print("猜对了")
# break
# 2.0
count = 0
while count < 10:
count += 1
input_number = int(input("第"+str(count)+"次猜:"))
if input_number > random_number:
print("大了")
elif input_number < random_number:
print("小了")
else:
print("猜对了")
break
else:
# 只有从while条件结束,才执行else语句.
# (从循环体内部break,不会执行)
print("没机会了你")
无限循环
while True:
num = int(input("请输入一个数字："))
print("您输入的数字是%d" % num)
day06 元组知识点
1、看书: Python编程：从入门到实践.pdf 第四章.
2、 Python – 元组详解
元组基础
"""
元组
"""
# 1. 创建空元组
t01 = ()
t02 = tuple()
# 2. 创建具有默认值的元组
t01 = (1,2,3)
t01 = tuple("abcd")
t01 = (1,2,[4,5])
print(t01)
# 修改
# t01[2] = 100 元组元素不能修改
t01[2][0] = 100 # 修改的是元素第三个元素(列表)的元素．
# 3. 获取元素(索引 ／ 切片)
print(t01[:2])
# 获取元组所有元素
for item in t01:
print(item)
# 倒序获取元组所有元素
for i in range(len(t01)-1, -1,-1):
print(t01[i])
t02 = ("a","b")
l02 = ["a","b"]
t03 = t02
l03 = l02
t02 += ("c","d") # 创建了新元组对象，改变了t02存储的地址．
l02 += ["c","d"] # 将["c","d"]追加到原列表中．
print(t02) # ('a', 'b', 'c', 'd')
print(t03) # ('a', 'b')
print(l03) # ['a', 'b', 'c', 'd']
# 如果元组只有一个元素，必须多写一个逗号，否则视为普通对象，不是元组对象．
t04 = (1,)
print(t04)
3、元组习题练习
根据月份，计算天数
"""
根据月份，计算天数．
"""
# month = int(input("请输入月份:"))
# if month < 1 or month > 12:
# print("输入有误")
# elif month == 2:
# print("28天")
# # elif month == 4 or month == 6 or month == 9 or month == 11:
# elif month in (4,6,9,11):
# print("30天")
# else:
# print("31天")
month = int(input("请输入月份:"))
if month < 1 or month > 12:
print("输入有误")
else:
# 将每月的天数，存入元组．
day_of_month = (31,28,31,30,31,30,31,31,30,31,30,31)
print(day_of_month[month - 1])
在控制台中输入月，日． 计算这是一年的第几天．
# 练习２：在控制台中输入月，日．
# 计算这是一年的第几天．
# 例如：３月５日
# 累加１月，２月总天数，再累加３月的５天．
# 例如：５月１０日
# 累加１月，２月，３月，４月总天数，再累加５月的１０天．
# month = int(input("请输入月份："))
# day = int(input("请输入天："))
# day_of_month = (31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31)
# result = 0
# # 累加前几个月
# for i in range(month - 1):
# result += day_of_month[i]
# # 累加当月
# result += day
# print(result)
month = int(input("请输入月份："))
day = int(input("请输入天："))
day_of_month = (31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31)
# 累加前几个月
result = sum(day_of_month[:month - 1])
# 累加当月
result += day
print(result)
day07 列表知识点
1、看书: Python编程：从入门到实践.pdf 第三、四章.
2、Python 列表list详解
后期会遇到各种各样的增改删查操作。
列表基础
(1) 定义：由一系列变量组成的可变序列．
(2) 操作：
创建: [] list()
[1,2,3] list(可迭代对象)
添加： 列表名称.append(元素)
列表名称.insert(索引,元素)
删除: 列表名称.remove(元素)
del 列表名称[索引]
del 列表名称[切片]
修改：列表名称[索引] = 元素
列表名称[切片] = 列表
查询：列表名称[索引]
列表名称[切片]
定位：索引 切片
"""
列表
作用：
列表非常适合用于存储数值集合；
在游戏中，用于跟踪每个角色的位置，
在数据可视化中，处理经度，纬度，距离等；
"""
# 1. 创建空列表
list01 = []
list01 = list()
# 2. 创建具有默认值的列表 [元素1,元素2....] list(可迭代对象)
list02 = [1, True, 1.2]
list02 = list("abcd")# ['a', 'b', 'c', 'd']
# range（）函数可以生成一系列的数。
# list（）函数可以将range（）的结果直接转换为列表。
list02 = list(range(5))
# 3. 添加元素
# append 在末尾追加
list02.append("q")
list02.append("t")
# insert 插入(索引,元素)
list02.insert(1,"x")
# 4. 删除元素
# 移除指定的元素
list02.remove(2)
# 删除指定索引的元素
del list02[1]
# 5. 定位元素(索引 切片)
# 获取前三个元素
# print(list02[:3])
print(list02)
# 修改元素
# list02[:3] = ["a","b","c"]
# list02[:3] = ["a","b","c","d","e"]
# list02[:3] = ["a"]
# del list02[:3]
# print(list02)
# 6. 遍历元素
# 正着
# for i in range(len(list02)):# 0 1 2
# print(list02[i])
# 跳着
# for i in range(0,len(list02),2):
# print(list02[i])
# 倒着
for i in range(len(list02) - 1,-1,-1):
print(list02[i])
# 7.简单的统计计算
digits = [1,2,3,4,5,6,7,8,9,0]
min(digits)
# 结果：0
max(digits)
# 结果：9
sum(digits)
# 结果：45
3、列表习题练习
获取最大／最小值
"""
获取最大／最小值
"""
list01 = [34, 5, 6, 78, 9, 0, 5, 8, 88, 4]
# # 假设第一个元素就是最大值
# max = list01[0]
# # 依次与后面（从第二个开始）元素进行比较
# for i in range(1,len(list01)):
# # 发现更大的，则替换假设的．
# if max < list01[i]:
# max = list01[i]
# # 最后假设的就是真的最大值．
# print(max)
# 练习２：查找最小元素
# 假设第一个元素就是最大值
min = list01[0]
# 依次与后面（从第二个开始）元素进行比较
for i in range(1, len(list01)):
# 发现更大的，则替换假设的．
if min > list01[i]:
min = list01[i]
# 最后假设的就是真的最大值．
print(min)
在控制台中录入学生姓名。
# 在控制台中录入学生姓名。
# 要求：姓名不能重复
# 如果录入esc,则停止录入，打印每个学生姓名．
list_names = []
while True:
name = input("请输入第%d个学生姓名：" % (len(list_names) + 1))
if name == "esc":
break
# 如果姓名不存在：
if name not in list_names:
list_names.append(name)
for item in list_names:
print(item)
day08 字典知识点
1、看书: Python编程：从入门到实践.pdf 第六章.
2、Python字典详解
字典基础
"""
字典
"""
# 创建空字典
d01 = {}
d02 = dict()
d01 = {"a":"A","b":"B"}
# d01 = dict("ab") # 分不清key value
d01 = dict([(1,2),(3,4)]) # {1: 2, 3: 4}
# 第一次增加
d01["c"] = "C"
# 第二次修改
d01["c"] = "CC"
# 读取元素(如果不存在则异常)
# 建议：在字典中读取元素，先判断存在，在进行读取．
if "d" in d01:
print(d01["d"])
print(d01)
# 删除
del d01["c"]
print(d01)
# 获取字典中所有元素：
for key in d01:
print(key)
print(d01[key])
# 获取字典中所有记录(元组)
for item in d01.items():
print(item[0]) # ｋｅｙ
print(item[1]) # value
for k,v in d01.items():
print(k) # ｋｅｙ
print(v) # value
# 获取所有键
for k in d01.keys():
print(k)
# 获取所有值
for v in d01.values():
print(v)
3、字典习题练习
输入季度
# season = int(input("请输入季度:"))
# if season < 1 or season > 4:
# print("输入有误")
# elif season == 1:
# print("有1,2,3月")
# elif season == 2:
# print("有4,5,6月")
# elif season == 3:
# print("有7,8,9月")
# else:
# print("有10,11,12月")
# [(季度,月份)]
seasons = {
1: "有1,2,3月",
2: "有4,5,6月",
3: "有7,8,9月",
4: "有10,11,12月"
}
season = int(input("请输入季度:"))
# 判断键是否存在
if season not in seasons:
print("输入有误")
else:
value = seasons[season]
print(value)
在控制台中录入一个字符串
# 在控制台中录入一个字符串
# 打印这个字符串中的字符以及出现的次数．
# abcdbcdb
# a字符1次
# b 3
# c 2
# d 2
str_input = "abcdbcdb"
# key: 字符 value:次数
result = {}
# (1)逐一判断字符，出现的次数．
for item in str_input:
# (2)如果没有统计过该字符串
if item not in result:
result[item] = 1
else:
# (3)否则,次数增加
# result[item] = result[item] + 1
result[item] += 1
print(result)
day09 集合知识点
1、集合基础
"""
集合
练习：exercise01
"""
# 1. 创建空集合
s01 = set()
# 2. 创建具有默认值的集合
s01 = {1,2,3,4}
# print(type(s01))
# 3. 其他容器 －－＞ 集合
s02 = set("abcdace")
s02 = set([1,7,56,8,7,8])
# 集合 －－＞ 其他容器
l02 = list(s02)
t02 = tuple(s02)
# 4. 添加
s02.add("a")
s02.add("b")
s02.add("c")
print(s02)# {1, 7, 8, 'c', 'b', 56, 'a'}
# 5. 删除
# s02.remove(7)
# s02.remove(9) # 如果该元素不存在，则错误．
# if 9 in s02:
# s02.remove(9)
s02.discard("a") # 如果该元素不存在，不会错误．
print(s02)
# 6. 获取所有元素
for item in s02:
print(item)
# 7. 计算
s03 = {1,2,3}
s04 = {2,3,4}
# 交集
s05 = s03 & s04
print(s05)# {1, 2}
# 并集
s05 = s03 | s04
print(s05) # {1, 2, 3, 4}
# 补集
s05 = s03 ^ s04
print(s05) # {1, 4}
s05 = s03 - s04
print(s05) # {1}
s05 = s04 - s03
print(s05) # {4}
# 子集 超集
s06 = {1,2,3}
s07 = {1,2}
re = s07 < s06 # True 说明s07 是 s06 的子集
re = s06 > s07 # True 说明s06 是 s07 的超集
print(re)
# 相同 不同
s08 = {1,2,3}
s09 = {1,2,3}
re = s08 != s09 # True 说明s08 与 s09 相同
print(re)
2、总结
容器
字符串：字符 不可变 序列
列表：变量 可变 序列
元组：变量 不可变 序列
字典：键值对 可变 映射
集合／固定集合
3、习题练习
day10 函数知识点
1、看书: Python编程：从入门到实践.pdf 第八章.
2、python基础篇——函数
python基础篇——函数
函数
１． 语法：
def 函数名称(形参):
函数体
return 数据
函数名称(实参)
变量 ＝ 函数名称(实参)
２．函数名称：动词 见名知义 与变量命名相同
３．形参：变量 定义者要求调用者必须提供的信息
４．实参：数据 调用者 告诉 定义者的信息
５．返回值：结果 定义者 告诉 调用者的信息
６．函数：一个功能
函数基础
"""
函数
函数定义者：做功能的人
函数调用者：使用功能的人
练习：exercise03
"""
# 定义函数
def attack():
print("摆拳")
print("直拳")
print("重拳")
print("....")
# 调用函数
# attack()
# 形式上的参数
def attack_repeat(count):
for i in range(count):
print("摆拳")
print("直拳")
print("重拳")
print("....")
# 实际参数
attack_repeat(2)
函数基础–返回值（结果）
"""
函数－－返回值（结果）
返回值：方法定义者 告诉 方法调用者的 结果
参数：调用者 告诉 定义者
练习：exercise05/06
"""
# 定义两个整数相加的函数
# def add():
# # 获取数据
# number01 = int(input("请输入第一个整数："))
# number02 = int(input("请输入第二个整数："))
# # 逻辑处理
# result = number01 +number02
# # 显示结果
# print(result)
def add(number01,number02):
# 逻辑处理
result = number01 +number02
# 返回结果 ＋ 退出方法
return result
# print("当前代码在ｒｅｔｕｒｎ之后，不能执行．")
# 定义变量，接收方法的返回值
re = add(1,2)
print(re)
不可变对象传参
"""
不可变对象传参
"""
def fun01(num01):
num01 = 2
print("num01:" + str(num01))# 2
number01 = 1
# 调用方法,在内存中开辟空间(栈帧)
# 栈帧中定义该方法内部创建的变量
# 方法执行完毕后，栈帧立即释放．
fun01(number01)
print("number01:" + str(number01))# 1
可变对象传参
"""
可变对象传参
"""
def fun01(list_target):
list_target[0] = 2
print("list_target[0]:" + str(list_target[0]))
list_number = [1,2]
fun01(list_number)
print("list_number:" + str(list_number[0]))
3、函数习题练习
统计一个方法的调用次数．
# 统计一个方法的调用次数．
count = 0
def fun01():
global count
count += 1
pass
fun01()
fun01()
fun01()
print(count)
定义函数，整数相加的函数。
# 定义函数，整数相加的函数。
def add(*args):
sum = 0
for item in args:
sum += item
return sum
re = add(1,2,3,4,45,43)
print(re)
定义根据月份，判断季节的方法
# 定义根据月份，判断季节的方法．
def get_season(month):
if month < 1 or month > 12:
return "输入有误"
if month <= 3:
return "春天"
if month <= 6:
return "夏天"
if month <= 9:
return "秋天"
return "冬天"
print(get_season(5))
print(get_season(15))
4、参数总结
# 参数总结
"""
实参：
-- 位置实参：fun03(1,2,3)
-- 序列实参：
# 运行时，根据某些逻辑计算而来．
list01 = [1,2,3]
fun03(*list01)
-- 关键字实参：fun03(b = 1,c = 2)
-- 字典实参：
# 运行时，根据某些逻辑计算而来．
dict01 = {"b":2,"c":"3"}
fun03(**dict01)
形参：
-- 默认形参
def fun03(a = 0,b = 0,c=0):
pass
-- 位置形参
def fun03(a,b,c):
pass
-- 星号元组形参 def fun03(*args)
-- 关键字形参
def fun03(*args,a,b,c):
pass
-- 双星号字典形参
def fun03(**kwargs)
"""
day11 类知识点
1、看书: Python编程：从入门到实践.pdf 第九章.
第1节 - python面向对象基础视频
2、Python——类
面向对象 类、对象的理解
"""
面向对象：考虑问题，从对象的角度出发．
类：模板 抽象
对象：具体
"""
class Wife:
"""
老婆
"""
# 1.数据成员 姓名 年龄 性别 ．．．
def __init__(self, name, age, sex):
# self "自己"，调用当前方法的对象
print(id(self))
self.name = name
self.age = age
self.sex = sex
# 2.方法成员 做饭 ．．．
def cooking(self):
print(id(self))
print(self.name + "做饭")
# 创建对象(实例化)
# 调用 __init__(self,name,age,sex) 方法
w01 = Wife("丽丽", 21, "女")
print(id(w01))
# 调用对象的方法 w01 将自身传入方法
w01.cooking()
w02 = Wife("芳芳", 22, "男")
w02.cooking()
print(id(w02))
# 在内存中，方法只有一份．而对象有多份．
3、类习题练习
Student
"""
(1)学生student是一个类，具有姓名，年龄等数据；
具有学习study，工作work等行为。
对象：悟空同学，28岁。
八戒同学，29岁。
"""
class Student:
"""
学生类
"""
def __init__(self,name,age):
self.name = name
self.age = age
def study(self):
print(str(self.age) + "学习")
def work(self):
print(self.name+"工作")
# s01 悟空对象的地址
s01 = Student("悟空",28)
s02 = Student("八戒",29)
# 通过对象地址，调用对象方法，会自动传递对象地址．
s01.study()
s02.work()
# s01 = Student("悟空",28)
# s02 = s01
# s01.name = "孙悟空"
# print(s02.name) # ?
s01 = Student("悟空",28)
s02 = s01
s01 = Student("八戒",28)
s01.name = "孙悟空"
print(s02.name) # ? 悟空
Enemy
"""
练习：
"""
class Enemy:
"""
敌人
"""
def __init__(self,name = "",hp = 0,atk = 0.0,atk_speed = 0.0):
self.name = name
self.hp = hp
self.atk = atk
self.atk_speed = atk_speed
def print_self(self):
print(self.name,self.hp,self.atk,self.atk_speed)
# 1. 在控制台中输入３个敌人，存入列表．
# 2. 将敌人列表输出（调用print_self）到控制台
# e01 = Enemy("zs",100,1000,5)
# list_enemy = []
# for i in range(3):
# e = Enemy()
# e.name = input("请输入姓名：")
# e.hp = int(input("请输入血量："))
# e.atk = float(input("请输入攻击力："))
# e.atk_speed = float(input("请输入攻击速度："))
# list_enemy.append(e)
#
# for item in list_enemy:
# item.print_self()
# 练习３：定义函数，在敌人列表中，根据姓名查找敌人对象．
# e01 = Enemy("zs",100,10,2)
# e02 = Enemy("ls",200,5,3)
# e03 = Enemy("ww",300,8,5)
#
# list_enemy = [e01,e02,e03]
def get_enemy_for_name(list_enemy,name):
# 遍历敌人列列表
for item in list_enemy:
# 如果有指定名称的敌人对象
if item.name == name:
# 则返回对象地址
return item
list01 = [
Enemy("zs",100,10,2),
Enemy("ls", 200, 5, 3),
Enemy("ww",300,8,5)
]
re = get_enemy_for_name(list01,"ls")
if re != None:
re.print_self()
else:
print("没有找到")
1. 面向过程：分析解决问题的步骤，然后逐步实现．
2. 面向对象：找出解决问题的人，然后分配职责．
3. 类：创建对象的模板，抽象的概念．
4. 对象： 具体，存储的是数据．
从设计角度讲：先有对象，再创建类．
从编码角度讲：先有类，再创建对象．
5. 类与类区别：行为不同.
对象与对象区别：数据不同．
day12 继承知识点
1、Python类的封装教程
使用方法封装变量
"""
封装数据优势：
１．符合人类思考方式
２．将数据与对数据的操作封装起来。
使用方法封装变量
"""
class Wife01:
def __init__(self, name, age):
self.name = name
# 缺点：缺乏对象数据的封装，外界可以随意赋值．
self.age = age
w01 = Wife01("芳芳", 26)
w02 = Wife01("铁锤", 86)
w02.age = 87
# print(w02.age)
# 注意：通过两个方法，读写私有变量．
# 练习：定义敌人类(姓名，攻击力，攻击速度(０－１０)，血量(０－－１００))
class Wife02:
def __init__(self, name = "", age = 0):
self.set_name(name)
# 私有成员：障眼法(解释器会改变双下划线开头的变量名)
# self.__age = age
self.set_age(age)
def get_name(self):
return self.__name
def set_name(self,value):
self.__name = value
def get_age(self):
return self.__age
def set_age(self,value):
if 20 <= value <= 30:
self.__age = value
else:
print("我不要")
w01 = Wife02("铁锤",86)
# 找不到双下划线开头的数据
# print(w01.__age)
# 通过下划线 ＋ 类名 可以访问双下划线开头的数据
# print(w01._Wife02__age)
w01.set_age(50)
print(w01.get_age())
print(w01.__dict__)
使用属性封装变量
"""
使用属性封装变量
"""
# 练习：修改Enemy类，使用属性封装变量
class Wife:
def __init__(self, name="", age=0):
self.name = name # 调用 @name.setter 修饰的方法
self.age = age # 调用 @age.setter 修饰的方法
@property # 拦截读取变量的操作
def name(self): # get_name()
return self.__name
@name.setter # 拦截写入变量的操作
def name(self, value): # set_name()
self.__name = value
@property
def age(self):
return self.__age
@age.setter
def age(self, value):
if 20 <= value <= 30:
self.__age = value
else:
self.__age = 0
print("我不要")
w01 = Wife("铁锤", 86)
print(w01.name)
print(w01.age)
2、封装习题练习
方法封装变量
"""
方法封装变量
"""
class Enemy:
def __init__(self,name,atk,speed,hp):
self.set_name(name)
self.set_atk(atk)
self.set_atk_speed(speed)
self.set_hp(hp)
def get_name(self):
return self.__name
def set_name(self,value):
self.__name = value
def get_atk(self):
return self.__atk
def set_atk(self, value):
self.__atk = value
def get_atk_speed(self):
return self.__atk_speed
def set_atk_speed(self, value):
if 0 <= value <= 10:
self.__atk_speed = value
else:
self.__atk_speed = 0
print("速度不再范围内，赋值失败")
def get_hp(self):
return self.__hp
def set_hp(self, value):
if 0 <= value <= 100:
self.__hp = value
else:
self.__hp = 0
print("血量不再范围内，赋值失败")
e01 = Enemy("zs",200,50,200)
print(e01.get_name(),e01.get_hp(),e01.get_atk_speed())
属性封装变量
"""
属性封装变量
"""
class Enemy:
def __init__(self, name, atk, speed, hp):
self.name = name
self.atk = atk
self.speed = speed
self.hp = hp
@property
def name(self):
return self.__name
@name.setter
def name(self,value):
self.__name = value
@property
def atk(self):
return self.__atk
@atk.setter
def atk(self, value):
self.__atk = value
@property
def speed(self):
return self.__speed
@speed.setter
def speed(self, value):
self.__speed = value
@property
def hp(self):
return self.__hp
@hp.setter
def hp(self, value):
self.__hp= value
e01 = Enemy("zs", 200, 50, 200)
print(e01.name, e01.hp, e01.speed)
封装:
1. 封装数据:将多个基本类型复合为一个自定义类型.
-- 优势:复合人类的思考方式
体现对数据的操作方式
2. 封装功能:对外提供必要的功能,隐藏实现细节.
-- 模块化的编程思想
3. 分而治之, 封装变化, 高内聚, 低耦合.
分解 变化点 类职责单一 类与类的关系松散
day13 继承知识点
1、看书: Python编程：从入门到实践.pdf 第九章.
2、【Python 面向对象】继承
继承语法 – 方法
"""
继承语法 -- 方法
财产
皇位
#练习1:定义父类--宠物, 行为:吃
# 定义子类--狗, 行为:防守xx
# 定义子类--鸟, 行为:飞
#创建相应对象,调用相应方法.测试isinstance,issubclass函数
#14:35
"""
# 学生 与 老师 在某种概念上是统一的
# 学生是 人
# 老师是 人
#
class Person:
def say(self):
print("说")
class Student(Person):
def study(self):
print("学习")
class Teacher(Person):
def teach(self):
print("教")
s01 = Student()
s01.study()
# 可以直接使用父类成员
s01.say()
p02 = Person()
p02.say()
# 父类不能使用子类成员
# p02.study()
t03 = Teacher()
t03.teach()
# 不能使用"兄弟"类成员
# t03.study()
# 判断一个对象是否"兼容"一个类型
print(isinstance(s01,Person)) # True
print(isinstance(s01,Student)) # True
print(isinstance(s01,object)) # True
print(isinstance(s01,Teacher)) # False
print(isinstance(p02,Student)) # False
# 判断一个类是否"兼容"一个类型
print(issubclass(Student,Person)) # True
print(issubclass(Student,Teacher)) # False
print(issubclass(Student,(Teacher,Person))) # True
print(issubclass(Student,Student)) # True
继承语法 – 数据
"""
继承语法 -- 数据
# 练习: 定义父类--宠物, 数据:名字
# 定义子类--狗, 数据:工作
# 创建相应对象,画出内存图
"""
class Person:
def __init__(self,name):
self.name = name
class Student(Person):
def __init__(self,name,score):
# 通过函数,调用父类方法
super().__init__(name)
self.score = score
class Teacher(Person):
def __init__(self,name,salary):
super().__init__(name)
self.salary = salary
s01 = Student("zs",100)
print(s01.score)
print(s01.name)
p02 = Person("ww")
print(p02.name)
继承 – 设计思想
"""
继承 -- 设计思想
面向对象设计原则
练习:exercise01.py
1. 开闭原则
开放 关闭
对扩展 对修改
允许增加新功能 不允许改变(增加/删除/修改)以前的代码
2. 依赖倒置(抽象)
使用抽象(父类),而不使用具体(子类).
"""
# 老张开车去东北
# 变化:飞机
# 火车
# 汽车
# .......
class Person:
def __init__(self, name):
self.name = name
# def go_to(self, str_type, str_pos):
# if str_type == "汽车":
# Car().run(str_pos)
# elif str_type =="飞机":
# Airplane().fly(str_pos)
# # elif xxxxx:
def go_to(self, vehicle, str_pos):
"""
写代码期间:
使用的是交通工具的,而不是汽车,飞机等
所以无需判断具体类型
运行期间:
传递具体的对象(汽车,飞机)
:param vehicle:
:param str_pos:
:return:
"""
# 如果传入的对象,不是交通工具,则退出.
if not isinstance(vehicle,Vehicle):
print("传入的不是交通工具")
return
vehicle.transport(str_pos)
# class Car:
# def run(self, str_pos):
# print("行驶到", str_pos)
#
#
# class Airplane:
# def fly(self, str_pos):
# print("飞到", str_pos)
class Vehicle:
"""
交通工具
"""
def transport(self, str_pos):
# 人为创造一个错误()
raise NotImplementedError()
# print("儿子们,必须有这个方法啊")
class Car(Vehicle):
def transport(self, str_pos):
print("行驶到", str_pos)
class Airplane(Vehicle):
def transport(self, str_pos):
print("飞到", str_pos)
# ....
p01 = Person("老张")
# p01.go_to("汽车", "东北")
p01.go_to(Airplane(),"东北")
3、继承习题练习
Grenade手雷
# 练习:手雷爆炸了,可能伤害敌人,玩家.还有可能伤害未知事物(鸭子,树,房子).
# 要求:如果增加了新的事物,手雷代码不变. 17:15
class Grenade:
"""
手雷
"""
def __init__(self, atk):
self.atk = atk
def explode(self, *args):
"""
爆炸
:return:
"""
for item in args:
if not isinstance(item, Damageable):
print("类型不兼容")
return
item.damage(self.atk)
class Damageable:
"""
可以受伤
"""
def __init__(self, hp):
self.hp = hp
def damage(self, value):
# 约束子类必须具有当前方法
# raise NotImplementedError()
self.hp -= value
class Player(Damageable):
def damage(self, value=0):
# self.hp -= value
super().damage(value)
print("碎屏")
class Enemy(Damageable):
def damage(self, value):
# self.hp -= value
super().damage(value)
print("播放动画")
g01 = Grenade(10)
p02 = Player(100)
e03 = Enemy(50)
g01.explode(p02, e03)
图形管理器
"""
有若干个图形(圆形,矩形........)
每种图形,都可以计算面积.
定义图形管理器,记录所有图形,提供计算总面积的方法.
要求:增加新的图形,不改变图形管理器代码.
"""
class GraphicManager:
def __init__(self):
# 记录所有图形
self.__graphics = []
def add_graphic(self,g):
if not isinstance(g,Graphic):
return
self.__graphics.append(g)
def get_total_area(self):
"""
计算总面积
:return:
"""
total_area = 0
for item in self.__graphics:
total_area += item.get_area()
return total_area
class Graphic:
"""
图形
"""
def get_area(self):
pass
class Circle(Graphic):
"""
圆形
"""
def __init__(self,radius):
self.radius = radius
def get_area(self):
return self.radius ** 2 * 3.14
class Rectangle(Graphic):
"""
矩形
"""
def __init__(self, length,width):
self.length = length
self.width = width
def get_area(self):
return self.length * self.width
manager = GraphicManager()
manager.add_graphic("ok")
manager.add_graphic(Rectangle(2,3))
manager.add_graphic(Circle(5))
# 加断点,调试
print(manager.get_total_area())
day14 pygame安装
1、看书: Python编程：从入门到实践.pdf 第十二–十四章.
2、安装pygame
pip install pygame
python3中pygame安装过程
3、pygame经典教程
4、pagame 官网
day15 pygame知识点
猜拳游戏
import random
def rock_paper_scissors():
choices = ["石头", "剪刀", "布"]
player_choice = input("请输入你的选择（石头、剪刀、布）：")
computer_choice = random.choice(choices)
print("你选择了：", player_choice)
print("计算机选择了：", computer_choice)
if player_choice == computer_choice:
print("平局！")
elif (player_choice == "石头" and computer_choice == "剪刀") or \
(player_choice == "剪刀" and computer_choice == "布") or \
(player_choice == "布" and computer_choice == "石头"):
print("你赢了！")
else:
print("你输了！")
rock_paper_scissors()
frist_pygame
#导入所需的模块
import sys
import pygame
# 使用pygame之前必须初始化
pygame.init()
# 设置主屏窗口
screen = pygame.display.set_mode((400,400))
# 设置窗口的标题，即游戏名称
pygame.display.set_caption('hello world')
# 引入字体类型
f = pygame.font.Font('C:/Windows/Fonts/simhei.ttf',50)
# 生成文本信息，第一个参数文本内容；第二个参数，字体是否平滑；
# 第三个参数，RGB模式的字体颜色；第四个参数，RGB模式字体背景颜色；
text = f.render("C语言中文网",True,(255,0,0),(0,0,0))
#获得显示对象的rect区域坐标
textRect =text.get_rect()
# 设置显示对象居中
textRect.center = (200,200)
# 将准备好的文本信息，绘制到主屏幕 Screen 上。
screen.blit(text,textRect)
# 固定代码段，实现点击"X"号退出界面的功能，几乎所有的pygame都会使用该段代码
while True:
# 循环获取事件，监听事件状态
for event in pygame.event.get():
# 判断用户是否点了"X"关闭按钮,并执行if代码段
if event.type == pygame.QUIT:
#卸载所有模块
pygame.quit()
#终止程序，确保退出程序
sys.exit()
pygame.display.flip() #更新屏幕内容
Python：pygame包的详细使用方法 ＜用实例渐进掌握＞
Python：pygame包的详细使用方法 ＜用实例渐进掌握＞
plane 小甲鱼飞机大战
根据视频学习并跟随写出90%的模仿代码；
主要理解 类、封装、继承的概念。
python3.9-pygame-plane
day16 文件库知识点
path_read
建立pi_digits.txt
from pathlib import Path
path = Path("pi_digits.txt")
contents = path.read_text()
print(contents)
path_write
from pathlib import Path
path = Path("programming.txt")
path.write_text("I love programming")
try_except 异常处理
from pathlib import Path
# print(5/0)
try:
print(5 / 0)
except ZeroDivisionError:
print("You can't division by zero!")
day17 matplotlib知识点
Numpy 和 Matplotlib库-安装教程
Python3.9安装包
Python3.9安装包+Numpy + Matplotlib
画折线
# # 使用Ctrl+/ 可以将多行注释取消注释。
# 1.画简单的折线
# import matplotlib.pyplot as plt
# squares = [1, 14, 15, 37, 9]
# # 可以理解成我们需要一张画板才能开始绘图。
# fig, ax = plt.subplots()
# #在作画前我们还需要轴，没有轴的话就没有绘图基准
# ax.plot(squares)
# plt.show()
# # 2.修改标签文字和线条粗细
# import matplotlib.pyplot as plt
# squares = [1, 4, 9, 16, 25]
# fig, ax = plt.subplots()
# # 折线粗细设置
# ax.plot(squares, linewidth=3)
# # 设置折线图标题与字体大小
# ax.set_title("square_num", fontsize=24)
# # 设置折线图x轴名称与字体大小
# ax.set_xlabel("value", fontsize=14)
# #y
# ax.set_ylabel("square", fontsize=14)
# # 设计刻度标记的样式
# # ax.tick_params(lablesize=14)
#
# plt.show()
# #3.校正绘图
# import matplotlib.pyplot as plt
# input_values = [1, 2, 3, 4, 5]
# squares = [1, 4, 9, 16, 25]
#
# fig, ax = plt.subplots()
# # 折线粗细设置
# ax.plot(input_values, squares, linewidth=3)
# # 设置折线图标题与字体大小
# ax.set_title("square_num", fontsize=24)
# # 设置折线图x轴名称与字体大小
# ax.set_xlabel("value", fontsize=14)
# # y轴
# ax.set_ylabel("square", fontsize=14)
# # 设计刻度标记的样式
# # ax.tick_params(lablesize=14)
#
# plt.show()
#4.内置样式
import matplotlib.pyplot as plt
plt.style.available
input_values = [1, 2, 3, 4, 5]
squares = [1, 4, 9, 16, 25]
plt.style.use("seaborn")
fig, ax = plt.subplots()
# 折线粗细设置
ax.plot(input_values, squares, linewidth=3)
# 设置折线图标题与字体大小
ax.set_title("square_num", fontsize=24)
# 设置折线图x轴名称与字体大小
ax.set_xlabel("value", fontsize=14)
# y轴
ax.set_ylabel("square", fontsize=14)
# 设计刻度标记的样式
# ax.tick_params(lablesize=14)
plt.show()
好的python 学习网站。
Python编程基础：Python编程基础
写在最后：
独立将基础知识练习完成；
学习需要长时间的积累，两周的时间只能大体了解Python的使用规则，如果想灵活运用，需要长时间重复练习，直至融会贯通；
基础知识就像一团泥一样，而我们完成的项目就像一个个泥塑；
泥还是那个泥；但泥塑却是多变的。
以上知识来自小甲鱼零基础入门学习Python视频教程、网上购买的学习资料、黑马python3爬虫编程网课学习人工智能零基础，Python编程：从入门到实践 （第三版），菜鸟教程等各类学习教程，我只是把里面我能吸收的经典案例展现出来。
从2022年暑假开始至2023年暑假结束，大概一年的时间，经历了学习、忘记，在学习，再忘记；反反复复。
csdn中Python资料多如牛毛，关键在坚持。
2023-08-19
后续还需进一步更新，如有错，请留言指出。
学如逆水行舟，不进则退
7万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
