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安装教程

Python安装超详细教程

安装包 包含numpycp39+matplotlib cp39的原因是，因不了解规则，我在安装这两个包时耗时时间太长。希望对看到这篇文章的小伙伴有帮助，一下是曾经遇到的问题和解决方法
导包问题解决–ImportError: DLL load failed while importing _path: 找不到指定的模块

Pycharm安装包

pycharm安装包-pycharm-community-2022.1.3

Pycharm安装教程

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、变量

定义：关联一个对象的标识符。

变量名定义时注意事项：

1. 变量名的定义不允许以数字开头，必须是字母或下划线开头，后跟字母、数字、下划线。

2. 变量名不支持除了_（下划线）以外的特殊字符

3. 变量名是区分大小写的

4. 不支持中文作为变量名，必须使用英文

5. 不能使用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 第二章.

Python编程：从入门到实践 （第三版）

2、认识运算符

注：python中“=”是赋值的意思；“==”是用于判断是否相等
一、算术运算符
加：+
减：-
乘：*
除：/除尽 或 //取商
模：%
幂：**

二、赋值运算符
= ：等于
+=：加等于
-=：减等于
*= ：乘等于
/=：除等于
//=：整除等于
%=：模等于
**=：幂等于

三、关系运算符
大于：>
小于：<
恒等于：==
不等于：!=
大于等于：>=
小于等于：<=

四、逻辑运算符
与运算：and
或运算：or
非运算：not

五、位运算符
位与运算：&
位或运算：|
位异或运算：^
位取反运算：~

六、布尔运算
布尔数据类型是用于条件判断、比较运算和逻辑运算，只有两个值真（True）和假(False)。
标准值False和None、各种类型（包括浮点数、复数等）的数值0、空序列（如空字符串、空元组和空列表）以及空映射（如空字典）都被视为假，而其他各种值都被视为真。

>>> True == 1
True
>>> False == 0
True
>>> True + True 
2

3、使用运算符

python基础-运算符

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 第五、七章.

Python编程：从入门到实践 （第三版）

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天")

猜数字

python random 的用法

import random
# 计算机出数字
computer = random.randint(1,5)
# 你出数字
you = int(input('我想好数字了,你来猜:'))
# 条件判断
if you == computer:
    print('恭喜,猜对了!')
elif you > computer:
    print('很遗憾,猜大了!')
else:
    print('很遗憾,猜小了!')

4、while循环用法讲解

Python教程：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 第四章.

Python编程：从入门到实践 （第三版）

2、 Python – 元组详解

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 第三、四章.

Python编程：从入门到实践 （第三版）

2、Python 列表list详解

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 第六章.

Python编程：从入门到实践 （第三版）

2、Python字典详解

Python字典(dict)详解

字典基础

"""
    字典
"""

# 创建空字典
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 第八章.

Python编程：从入门到实践 （第三版）

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 第九章.

Python编程：从入门到实践 （第三版）

第1节 - python面向对象基础视频

第1节 - python面向对象基础

2、Python——类

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类的封装教程

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 第九章.

Python编程：从入门到实践 （第三版）

2、【Python 面向对象】继承

【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 第十二–十四章.

Python编程：从入门到实践 （第三版）

2、安装pygame

pip install pygame
python3中pygame安装过程

3、pygame经典教程

python游戏库pygame经典教程

4、pagame 官网

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库-安装教程

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
后续还需进一步更新，如有错，请留言指出。

学如逆水行舟，不进则退