python笔记-自用

2024/1/3

# python用+号实现字符串的拼接，非字符串不能拼接
from pymysql import  Connection

# 连接mysql数据库

salary = 100
name = "wang"

ans = "%s" % salary + name
print(ans)

x = 1
y = 2
sum = "%s %s" % (x, y)
print(sum)

# %s字符串占位， %d整数占位 ， %f浮点数占位

# 格式化的精度控制
# m.n控制精度

price = 100.00123
print("%7.3f" % price)

print("请输入您的名字:")
# z = input()
# print("你的名字:", z)
# input()函数内部默认输入为str类型
# int() str() 类型转换

res = 10 > 5
print(res)

b = 100 == 10
print(b)

for i in range(10):
    print(i)
# print(i)

# 列表，元组，字符串，集合，字典
# index() 寻找下标索引是否在列表中
# 修改元素直接改 插入用insert(索引，元素)
# 追加元素append()
# extend(数据容器)方法追加一批元素
# 删除元素del list[0]  元素 = list.pop(下标)  remove(元素):删除列表中满足相等的第一个元素
# list.clear()清空列表
# list.count(元素) 统计元素个数
# tuple元组的操作：index() count() len()
# str字符串的函数 index(元素) s.replace(s1,s2) s1换成s2
# s.split(" ")按照空格进行拆分
# s.strip("字符串") 删除前后空格 s.strip(字符串)删除前后字符串
# s.count() len(s)

# 集合的定义:set()  {元素，元素} 集合是去重且无序的 集合是不能通过下标访问
# add(元素)集合添加元素 remove(元素)集合移除元素 集合.pop()随机取出一个元素 clear()
# set3 = set1.difference(set2) 两个集合的差集  set1.difference_update(set2)
# set1.union(set2) 集合合并
# len(set1) 集合元素数目
# 集合可以用for循环遍历，不支持while循环遍历
# 字典，你终于来了，哈哈哈哈
# 字典是通过key取相应的值，不能通过下标索引取 dict[key]
# 新增和更新元素dict[key] = value
# 字典移除元素 value = dict.pop(key) clear()
# 获取全部的key dict.keys()
# for key in dict 遍历取得key
# 字典不支持while循环
# len(dict)元素数目
# 函数可以返回多个值，函数可以按位置传输，按键值传输，指定参数，按不定参数传输：元组、字典
# 函数可以作为形参进行传入，这是计算逻辑的传递不是数据的传递
# lambda匿名函数 匿名函数一般无法二次使用

h = lambda x, y : x+y

def get_sum(h):
    result = h(1,2)
    return result
print(get_sum(h))


# python的文件操作
# 文件的读取操作
# file = open(文件对象路径，文件模式mode，encoding = 编码方式) 得到对文件进行操作的对象
# file.read(num) 读取num字节的结果 file.readLines()读取文件的全部行，封装到列表中
# file.readline() 每次读取一行内容
# file.close()方法关闭文件，解除对文件的占用
# with open() as f: 这种方法可以自动关闭文件流
# 文件的写入操作： f.write(内容) f.flush() 将内存中的数据刷新到硬盘中
# close()方法内置flush()方法
# w模式写入，文件不存在会创建，文件存在会清空
# a模式是追加模式，w是清空写入模式
# \n换行写入
# 异常处理 try: 代码块 except：异常捕获后处理的代码 finally：最后处理
# 异常具有向上层传递性
# 模块就是python文件，里面有类，对象，变量等
# import 模块名 as 别名  from 模块名 import 功能名 as 别名
# 自定义一个模块，使用import导入就可以直接使用了
# 不同模块出现同名，后者会覆盖前者
# 右键运行的时候main==true，不运行该条路径不走
# all变量控制导入的*
# class 类名： name = wang 变量  类中可以定义成员变量，也可以定义成员方法
# def 方法名(self,形参):self是成员方法必须定义的，表示类对象自身的意思，在方法内部访问类的成员变量，必须使用self关键字
# 函数一般写在类外面 方法写在class内部，成员方法
#



class Student:
    name = None
    age = None
    # new方法实现类的实例化，init方法实现初始化
    def __new__(cls, *args, **kwargs):
        pass

    def __init__(self, name, age):
        self.name = name
        self.age = age
    # 返回字符串对象的方法
    def __str__(self):
        return self.name + str(self.age)
    # 比较对象的方法
    def __lt__(self, other):
        return self.age < other.age
    # 比较对象的方法
    def __le__(self, other):
        return self.age <= other.age
    # 比较对象的方法
    def __eq__(self, other):
        return self.age == other.age




stu = Student("wang", 18)
print(stu.name , stu.age )
print(stu)
stu1 = Student("1", 13)
stu2 = Student("2", 13)
print(stu1 < stu2)
print(stu1 <= stu2)
print(stu1 == stu2)


# python魔术方法
# 两个下划线开头的变量和方法都是私有的
# class Phone:
#     __current_value = 100
#     def __fun_1(self):
#         print("no")
#     def call(self):
#         if self.__current_value >= 10:
#             print("ok")
#         else:
#             self.__fun_1()
#
# phone = Phone()
# # 类对象不能使用私有的变量与方法
# # 私有的可以给类中的其它成员访问
# phone.call()
# python 继承是通过(父类)完成的
# class (父类1, 父类2,... )可以实现多继承  python支持直接多继承，java不支持直接多继承
# 多继承，成员同名，优先按照左侧的
# 子类可以调用父类的成员 使用父类名.成员 或者 super().成员

# python3支持类型注解，设置类型注解有利于第三方IDE工具对代码进行推断
# 变量：类型  容器：类型
# 方法的类型注解 形参的类型注解 变量:类型 函数返回值的类型注解 函数->类型
# 类型注解是提示型的不是决定性的
# Union[类型1，类型2]联合类型注解 需要先导包才能继续使用
var1 = 2
print(f"你好{var1}")
# 闭包 函数的嵌套 内部函数使用外部函数的变量，外部函数返回内部函数的引用
# 装饰器：不破坏 目标函数代码的前提下为增强目标函数的功能
# 装饰器本质上是创建一个闭包函数，在闭包函数中调用目标函数，可以实现不改变目标函数的情况下增加目标函数的功能
# 进程与线程 使用threading模块实现多线程编程
# target代表目标任务， name是线程名，args与kwargs是按照元组与字典的形式传参
# from time import  sleep
# import  threading
# def sing(msg, msg1):
#     while True:
#         print(f"我喜欢唱歌:{msg,msg1}")
#         sleep(1)
# def dance(msg):
#     while True:
#         print(f"我爱跳舞:{msg}")
#         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()

# 正则表达式 验证字符串是否符合某个规则  基于re模型进行匹配
# match search findall
import re
s = "python java python"
# match是 匹配从头是否符合
res1 = re.match("python", s)
print(res1)
print(res1.span())
print(res1.group())
# search 找出第一个
res2 = re.search("python", s)
print(res2)
# findall 找到全部匹配的
res3 = re.findall("python", s)
print(res3)

# 字符串前面带有r表示转义无效就是普通字符串
# 递归算法： 方法或者函数自己调用自己

# is是对象是否相同 == 是值是否相同
# 迭代器是可以记住遍历位置的对象 从集合的第一个元素开始访问，直到访问完所有元素
# iter()：创建 next()：遍历  也可以使用for循环遍历，python中的迭代器只能向前遍历元素不能后退
# python中使用yield的函数的被成为生成器 生成器返回迭代器对象，生成器是一个特殊的迭代器，
# 调用生成器会在yield位置停下来，在yield位置返回，下一次next()从当前位置继续执行