python study

记录学习python的路程

全程是跟着林粒粒呀up主学习的，这是链接

1
2
3
4
5
6
7
8
.title()可以将一个短语中所有单词首字母大写
.lower()可以将字母全部大写
.upper()可以将字母全部小写
.lstrip()可以将字符串左边空格移除
.rstrip()可以将字符串右边空格移除
.strip()可以将左右两边字符串都移除
.removeprefix("message")可以将前缀字母移除
.removesuffix("message")可以将后缀字母移除

最后两个需要注意，那个message必须是变量内容的前后缀，就连空格都要算入

然后如果想在print中插入变量的话，需要这样写print(f"xxxx,xx{变量}xx"}

python中需要数学运算时，需要导入math库import math
然后可以通过官方文档查找需要的数学函数
python数学库

tips:除法运算的结果是浮点数，而且如果参与运算的数字是浮点数，结果也是浮点数

注释有两种

1
2
3
4
5
6
7
#我是一行注释
'''
我是第一行注释
我是第二行注释
我是第三行注释
······
'''

在Windows中使用ctrl + /进行快捷注释（取消注释）
在mac中使用command + /进行快捷注释或取消注释

python中的数据类型很丰富
字符串类型 str
len(‘str’)可以得到该字符串的长度
“str”[索引]可以得到该位置的字符

整数类型 int

浮点型类型 float

布尔类型 bool
只有True和False两种

空值类型 NoneType
只有None,注意None不是0或空或False
用途就是如果我们不清楚定义变量的值，可以将变量定义为None

type()函数可以返回该变量的数据类型

列表

1
2
3
4
5
6
7
8
9
10
11
shopping_list=["键盘","键帽"]
shopping_list.append("显示器") #可以顺序增加新的元素
shopping_list.remove("显示器") #可以删除指定的元素
len(shopping_list) #返回的是列表中的元素个数

#列表还有新的函数
print(max(num_list)) #返回列表中最大值
print(min(num_list)) #返回列表中最小值
print(sorted(num_list)) #返回排序后的列表，但是并不会改变原本列表的顺序
sum(num_list) #可以将列表中的所有元素数字相加求和
names.insert(0,"yolo") #意味着给列表第一位插入新的元素"yolo"

使用for循环对很多东西进行迭代处理

1
2
3
4
5
temperature_list=[23.4,35.3,23.6,64.2,23.6]
for temperature in temperature_list:
    if temperature >=38:
        print(temperature)
        print("omg")

for还能加上range高效循环
range(起始值,结束值,步长)
总之range可以控制循环次数，比如说给列表中插入很多的元素

1
2
3
4
5
6
if[条件]:
    [执行语句]
    [执行语句]
else:
    [执行语句]
    [执行语句]

比较运算符 == >= != <=

嵌套条件语句

1
2
3
4
5
6
7
if [条件一]:
    if [条件二]:
        [执行语句]
    else:
        [执行语句]
else:
    [执行语句]

或者使用elif也能实现多次判断

1
2
3
4
if [条件一]:
    [执行语句]
elif [条件二]:
    [执行语句]

逻辑运算：and,or,not
and要求全成立
or要求只有一个成立即可
not要求不成立即可
优先级：not>and>or

字典用于存储键值对，格式长这样
contacts={"yolo":"b24041429","hyy":"b24041403"}
del contacts
元组不可变
example_tuple=(“yolo”,“hyy”)

字典中可以将元组作为键，比如说

1
contacts={("yolo",23):"b24041429",("yolo",234):"b240142124",("yolo",222):"basdf"}

print的时候，如果是整数，我们可以用str转化成字符串print(str(contacts["key"]))

temperature_dict.keys()可以返回字典中所有键
temperature_dict.values()可以返回字典中所有值
temperature_dict.items()可以返回字典中所有键值对

1
2
3
4
temperature_dict={"111":36.4,"112":36.6,"113":36.2,"114":44.3}
for staff_id,temperature in temperature_dict.items():
    if temperature>=38:
        print(staff_id)

这里确实学到新的知识了，for循环中，定义了两个参数，这是因为字典的items是由两个部分组成，一个是key，一个是value，然后这个for循环会顺序赋值

格式化字符串
方法一：format方法

1
2
3
4
5
6
7
8
9
10
11
12
13
message_content="""
绿回春渐，。。。。
新岁。。。。。。
金{0}贺岁，欢乐祥瑞。
金{0}敲门，五福临门。
给{1}及家人拜年啦！
新春快乐，{0}年大吉！

""".format(year,name)

gpa_dict={"yolo":3.222,"hyy":2.333}
for name,gpa in gpa_dict.items():
    print("{0}的绩点为：{1:.2f}".format(name,gpa))

方法二：f字符串

input()函数是传入函数
ps:input会默认传入的都是字符串
如果想要其他类型，可以使用int,float,str,比如说int(input(“enter the age:”)

while循环，用于不知道要进行多少次循环
while 条件a:
行动b

定义函数

1
2
3
4
5
def calculate_sector(central_angle,radius):
    sector_area=central_angle/360*3.14*radius**2
    print(f"the area:{sector_area}")

calculate_sector(160,30)

函数内定义的变量是局部变量，无法在外部使用，这时候，我们可以用return返回函数的值，让外部获取函数生成的值

类
就是一种面向对象，将一个变量的属性绑定到一起，让我们向函数传参数的时候能简化一点
方法就是把函数放到类里面
还有三个特性：封装，继承，多态
分装是把一些函数放到一个类里面
继承是允许其他子类调用父类的函数
多态是说根据对象的不同，而使用不同的方法

1
2
3
4
5
6
7
8
9
10
11
class CuteCat:
    def __init__(self,cat_name,cat_age,cat_color):
        self.name=cat_name
        self.age=cat_age
        self.color=cat_color

cat1=CuteCat("Jojo",16,"pink")

print(cat1.name)
print(cat1.age)
print(cat1.color)

上面定义了个CuteCat类，其中__init__定义了类的属性，创建新对象

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
class Restaurant:
    def __init__(self,restaurant_name,cuisine_type):
        self.restaurant_name=restaurant_name
        self.cuisine_type=cuisine_type
        self.number_served=0

    def describe_resturant(self):
        print(f"the name{self.restaurant_name}")
        print(f"cuisine:{self.cuisine_type}")

    def open_restaurant(self):
        print("opening......")

    def set_number_served(self,numbeer):
        self.number_served=numbeer

    def increment_number_served(self,increase):
        self.number_served+=increase
taotaoju=Restaurant("taotaoju","yuecai")
print(taotaoju.restaurant_name)
print(taotaoju.cuisine_type)
taotaoju.describe_resturant()
taotaoju.open_restaurant()
print(taotaoju.number_served)

taotaoju.set_number_served(500)
taotaoju.increment_number_served(20)
print(taotaoju.number_served)

上面就是简单的类的应用，还行吧，就是把正常的逻辑给绕了一下，弄了个中间商的感觉

然后类的继承也有点意思，分为一个父类和多个子类
它们可以这样理解，如果多个类有相同特征，那就把相同特征归并到父类中，这样就能优化一下，然后把不相同的特征放到子类即可，但是如果不同类的相同特征的内容不一样，那就可以在子类再定义一遍属性，这时候编译器会优先处理子类中的特性，如果子类没有的话，才会调用父类中的特性

然后有一些属性不一样的时候，我们可以使用

1
2
def __init__(self):
    super().__init__()

这样做可以让子类遇到共有属性调用父类，然后接下来可以定义属于自己的属性，那个super().__init__后面需要传递父类的参数，但是如果有参数已经确定了，可以直接传递固定值，这样的话，最上面的def就能少传递一个父类的参数名了

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
class Mammal:
    def __init__(self,name,sex):
        self.name=name
        self.sex=sex
        self.num_eyes=2

    def breath(self):
        print(self.name + "breathing")
    def poop(self):
        print(self.name + "pooping")

class Human(Mammal):
    def __init__(self,name,sex):
        super().__init__(name,sex)
        self.has_tail=False
    def read(self):
        print(self.name+"reading")

class Cat(Mammal):
    def __init__(self,name,sex):
        super().__init__(name,sex)
        self.has_tail=True
    def scratch_sofa(self):
        print(self.name+"scratch sofa")
    def poop(self):
        print(self.name+"poop in maosha...")

cat1=Cat("Jojo","man")
print(cat1.name)
cat1.poop()

文本的读取

1
2
3
4
5
6
7
8
9
10
11
12
#文件操作

from pathlib import Path

path=Path("./content.txt")

content=path.read_text()

lines=content.splitlines()
print(lines)
for line in lines:
    print(line)

可惜这里和我想的不太一样，我的需求是可以读取二进制文件那种，进行分析元数据

.read_text()读文件 待读取文件必须存在
.write_text()写文件 待写入文件可以不存在，会自动创建，但是如果存在而且有内容，会将之前的内容覆盖

1
2
3
4
5
6
7
8
9
10
from pathlib import Path
names=""
user_name=input("请输入name,q结束")
while user_name!="q":
    names+=user_name +"\n"
    user_name=input("请输入name,q结束")

path=Path("./content.txt")

path.write_text(names)

try,except语句倒是蛮有用的，在我看来是在try中如果发生某种报错，而这种报错又在except提到过，那就终端不会返回traceback了，而是返回在except处理后的结果

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
try:
    s=int(input("输入数字："))
    print(s)
except ValueError:
    print("都说了让你输入数字了")

'''
/Users/yolo/Desktop/py_study/.venv/bin/python /Users/yolo/Desktop/py_study/hello.py 
输入数字：23
23
/Users/yolo/Desktop/py_study/.venv/bin/python /Users/yolo/Desktop/py_study/hello.py 
输入数字：aaa
都说了让你输入数字了

'''

然后这里有一点，不清楚错误类型的时候，我们直接使用except:就好，然后在try,except语句中，如果用户输入的没有问题，我们最后面可以跟上else:语句进行下一步操作，然后还有一个finally:，它会在try无论错误与否都会进行

进行程序测试的时候，要assert和pytext库进行，但是感觉我这边用的不太多，就不记录了

summary

Python这种语言真的好神奇，也很nice，不过也很复杂，学习py并不是我上面这种速成就能学会的，更应该做的是多多开发自己的小项目，然后减少对AI的依赖，毕竟是干IT的，精通一门编程语言不管怎么说都应该是个必要条件

对于Yolo来说，接下来的训练python技术的方法是不断开发自己的妙妙小工具，不管是在我的ctf比赛中还是日常生活中，都很有益处

一些题外话

那位up主的视频我是从昨晚晚自习才开始看的，第一次发现全身心投入的学习真的好爽，都不知道上一次是什么时候了

一些实用语句

Python 标准库 Python 3.13.3 文档，可以认真学习学习

文件读取

模式 描述
‘r’ 只读（默认）
‘rb’ 二进制只读
‘r+’ 读写
‘w’ 只写（会覆盖）
‘a’ 追加

这是我举得一个读取文件的例子

文件读取还有个特殊的地方，如果我们选择在终端使用python fileopen.py <文件路径>，那我们就需要导入sys库

1
2
3
4
5
6
7
8
9
10
if __name__ == "__main__":
    import sys
    if len(sys.argv)!=2:
        print("使用方法：python fileopen.py <文件路径>")
        sys.exit(1)
    file_path=sys.argv[1]
    if check_png(file_path):
        print(f"文件{file_path}是一个有效的PNG文件")
    else:
        print(f"文件{file_path}不是一个有效的PNG文件")

这里的len(sys.argv)!=2的意思是说，希望终端能出现两个参数，一个是脚本路径，一个是图片路径，如果不满足的话，它会自动弹出使用方法，引导我们正确调用

然后这里还有一种，需要导入argparse库操作

1
2
3
4
5
6
7
8
9
10
import argparse
parser = argparse.ArgumentParser(description="检查文件是否为有效的PNG文件")
parser.add_argument("-f", "--file", required=True, help="指定要检查的文件路径")
args = parser.parse_args()

file_path = args.file
if check_png(file_path):
    print(f"文件{file_path}是一个有效的PNG文件")
else:
    print(f"文件{file_path}不是一个有效的PNG文件")

在我看来，各有好坏吧，用sys的话，更适合那种功能简单的程序，比方说这里仅仅是指定了文件路径，而argparse显然可以让我干更多的事情

然后读取文件的时候，如果是按照rb打开的时候，我们对数据操作，像跳过一些数据的时候可以用file.seek(想跳过的字节数)

说些什么吧！

waline