Python记录

字符串中常用方法：
   1：str.find(sub,_start,_end)     # 返回字符串中sub的下标，若没有则返回-1
   2：str.replace(_old,_new,count) # 将字符串中所有old字符替换为new
   3：str.split(sep,maxsplit) # 将字符串从sep处进行分割，maxsplit为最大分割次数
   4：str.join(_iterable) # 将被分割的字符串通过str合并为一个字符串

列表中常用方法与关键字：
   1：list.index(data,_start,_end) # 返回列表中data的下标，若没有则报错
   2：_Data in _Docker # 判断容器中某个数据是否存在，若存在返回TRUE，否则返回FALSE
   3：list.count(Data) # 返回数据在列表中出现的次数

列表添加数据的方法：
   1：list.append(Data) #将数据添加到列表的尾部，返回值为None
   2：list.insert(_index，_Object) #在指定的位置添加数据，若原位置有数据，则原数据会后移
   3：list1.extend(list2) #将list2中的所有数据逐个添加到list1的尾部

列表中删除数据的方法：
   1：list.pop(_index) # 删除指定下标位置对应的数据，若不写，则删除最后一个数据
      返回值为删除的数据
   2：list.remove(_Data) # 根据数据值进行删除，返回值为None
   3：list.clear(_Data) # 清空列表

列表中的其他常用方法：
   1：list.reverse(_Docker) # 列表的反转 == list[::-1]
   区别：reverse方法直接修改原列表，list[::-1]会生成一个新列表
   2：list.copy(_Docker) # 列表的复制 == list[::]
   3：list.sort(_Docker)# 列表的排序,按照升序排序  list.sort(reverse = True),按照降序排序
   4：列表嵌套：类似于二维数组
   
字典常用操作：
   1：del dict[key] # 删除指定键值对
   2：dict.clear() # 清空
   3：dict.get(key) # 根据键获取对应的值 == dict[key]

字典的遍历：
   1：for i in my_dict.keys():  # 对字典的键进行遍历，其中dict.keys()可以省略不写
          print(i)
   2：for j in my_dict.values():  # 对字典的值进行遍历,dict.values()获取字典中所有的值
          print(j)
   3：for i , j in my_dict.items():   # 对字典的键值对进行遍历，dict.items()获取所有键值对
          print(i,':',j)

集合的唯一功能：去重 set( )，缺点：不能保证原顺序

只有 = ，可以改变引用

可变类型做参数，在函数内部，如果不使用 = 直接修改形参的引用，对形参进行的修改会同步到实参中

在Python中 += 操作等同于extend操作

组包(pack)：将多个数据值使用逗号连接，形成元祖

拆包(unpack)：将容器中的数据值使用多个变量分别保存的过程，变量的数量和容器中数据的数量要保持一致

函数返回多个函数值是将多个数据值组成容器进行返回，一般是元组（组包）

混合传参时关键字传参必须写在尾部

缺省参数概念：
(1)缺省参数是声明或定义函数时为函数的参数指定一个默认值 ；
(2)在调用该函数时，如果没有指定实参则采用该默认值，否则使用指定的实参。

不定长位置参数：当不确定参数的具体个数时，可以使用不定长参数
使用方式：在普通参数的前面加上一个*，这个参数就变成不定长位置参数，这个形参就可以接受多个位置传参的数据
此时 形参的类型是元组,且应写在普通参数的后面，一般写为 *args

想要将列表中的数据 分别作为位置参数 进行传参 需要对列表进行拆包操作
# func(*my_list)
想要将字典中的数据 作为关键字传参 需要使用 ** 对关键字进行拆包
# func(**my_dict)

ord(字符) #获取字符对应的ASCII码值
chr(ASCII码值) #获取ASCII码值对应的字符

面向对象代码设计的步骤：
    1:定义类，在定义类之前先设计类
    2：创建对象，使用第一步创建的类定义对象
    3：通过对象调用方法

面向对象代码书写格式：
1:定义类
先定义简单的类，使用class关键字
方法：方法的本质是函数，只不过第一个关键字是self
class 类名：
    def 方法名(self)
        pass

2：创建对象
创建对象是使用 类名()进行创建
类名() #创建一个对象，但在后续不能使用
# 若想要在后续继续使用，需要使用一个变量将这个对象保存起来
变量 = 类名() # 这个变量中保存的是对象的地址，一般称这个变量为对象

3：调用方法
对象.方法名()

self是普通的形参，但是在调用的时候没有传递实参值，原因是Python解释器在执行代码时自动将调用这个方法的对象传递给了self，即self
的本质是对象

**** 魔法方法__init__方法
在创建对象之后会自动调用，主要用于给对象添加属性，也称为构造方法
例：class Cat:
    def __init__(self,name,age):
        self.name = name
        self.age = age
#        print("-" * 30)

    def show_info(self):
        print(f"猫的名字是{self.name},年龄是{self.age}")
        print("-" * 30)

blue_cat = Cat('蓝猫',2)
yellow_cat = Cat("黄猫",3)
blue_cat.show_info()

***__str__方法
使用print(对象) 打印对象时会自动调用，一般用于书写对象的属性信息，即打印对象时想查看什么信息需要在此方法中定义
若类中没有定义__str__方法，print(对象)，默认输出对象的引用地址
注意：必须返回一个字符串


*__del__方法(了解即可)
调用场景：程序代码运行结束，所有对象都被销毁或者直接使用del删除对象

案例一：小明吃饭跑步
class Person:
    def __init__(self, name, weight):
        self.name = name
        self.weight = weight

    def __str__(self):
        return f"{self.name}的体重是{self.weight}"

    def eat(self,i):
        self.weight += i

    def run(self,j):
        self.weight -= 0.5*j


xiaoming = Person("xiaoming", 75)
xiaoming.eat(3)
xiaoming.run(3)
print(xiaoming)

# 案例二： 家具的摆放
class House:
    def __init__(self,name,total_area):
        self.name = name
        self.total_area = total_area
        self.free_area = self.total_area
        self.item_list = []

    def __str__(self):
        return f"户型为：{self.name} 总面积为{self.total_area} 剩余面积为{self.free_area} 家具名称列表为{self.item_list}"

    def add_item(self,item):
        if self.free_area > item.area:
            self.free_area -= item.area
            self.item_list.append(item.name)


class HouseItem:
    def __init__(self,name,area):
        self.name = name
        self.area = area

    def __str__(self):
        return f"添加家具{self.name}中..."


# 家具对象的创建
bed = HouseItem("席梦思",4)
chest = HouseItem("衣柜",2)
table = HouseItem("餐桌",1.5)

YourHouse = House("113Cl",113)
print(YourHouse)
print(bed)
print(chest)
print(table)
YourHouse.add_item(bed)
print(YourHouse)

# 案例三 模拟登录页面
class LoginPage:
    def __init__(self, name, pw, cd):
        self.username = name
        self.password = pw
        self.code = cd
        self.button = "登录"

    # def __str__(self):
    #     pass

    def login(self):
        print(f"1.输入用户名 {self.username}")
        print(f"2.输入密码   {self.password}")
        print(f"3.输入验证码 {self.code}")
        print(f"4.点击按钮   {self.button}")

user1 = LoginPage("zhangsan", 625726, 5471)
user1.login()

公有和私有：
    在类内部，属性名或者方法名的前边加上两个下划线，这个属性或方法就变成了私有的
私有的本质：当Python解释器发现属性名或方法名前有两个__，会将这个名字重命名，在这个名字的前面加上_类名前缀
如果想在类外部操作私有属性，就需要在类内部定义公有的方法

补充： 对象.__dict__ 魔法属性，可以将对象具有的属性组成字典返回
例：class Person:
    def __init__(self,name,age):
        self.__name = name
        self.age = age


    def __str__(self):
        return f"{self.__name}的年龄是{self.age}"


xm = Person("xm",13)
xm.__name = "ss"
print(xm)

xm._Person__name = "ss"
print(xm)

print(xm.__dict__)

继承的语法：
class A:
    pass

class B(A):   # B类继承A类
    pass

子类继承父类后，子类的对象可以直接使用父类中定义的公有属性和方法

重写：在子类中定义了和父类中名字相同的方法
原因：父类中的方法无法满足子类对象的需求
重写的方式：
    1.覆盖：父类中的功能完全抛弃
    2.扩展：父类中的功能还调用，只是添加一些新的功能

扩展例子：
    class Animal:
    def eat(self):
        print("吃饱了")


class Dog(Animal):
    def eat(self):
        print("该睡觉了")
        super().eat()
        print("...")


dog1 = Dog()
dog1.eat()

属性的划分
1.实例属性
2.类属性：在类内部，方法外部，直接定义的变量
    使用：类对象.属性名 = 属性值 or 类名.属性名 = 属性值

类属性实例：
class Dog:
    count = 0

    def __init__(self,name):
        self.name = name
        Dog.count += 1


dog1 = Dog("xm")
do = Dog("xl")
print(Dog.count)

方法的划分：
    1：实例方法
    2：类方法：在方法名字上方书写@classmethod装饰器，当方法中不需要使用实例属性时可以定义

class Demo:
    @classmethod
    def func(cls): #参数一般写作cls
        pass

    3：静态方法：在方法名字上方书写@staticmethod装饰器，当方法中不需要使用实例属性也不使用类属性时定义
class Demo:
    @staticmethod
    def func(): #一般没有参数
        pass

文件操作：
    1:打开文件：open(file,mode = 'r',encoding = None)
        <1>file 为要打开的文件，路径可以是相对路径也可以是绝对路径
        <2>mode 为缺省参数，表示文件打开的方式
        <3>encoding 为编码方式，一般使用utf-8
        <4>返回值：返回的是文件对象
    2:读写文件
        <1>写文件：向文件中写入指定的内容，必须处于w和a状态的文件
            文件对象.write('写入文件的内容')
            返回值：写入文件的字符数，一般不关注
            # 'a'方式打开文件，文件不存在会创建文件，文件存在会在末尾写入内容
        <2>读文件：将文件中的内容读取出来，打开方式必须为'r'
            文件对象.read(n) 参数n表示读取多少个字符，一般不写表示读取全部内容
            返回值：读取到的文件内容，类型为字符串
    3：关闭文件：文件对象.close()
        将文件占用的资源进行清理，并保存文件

json文件的处理：
    json文件可以直接使用read()和write()方法进行操作，但不方便
    常在测试时将测试数据定义为json文件，并使用代码读取json文件，即读取测试数据进行传参

json文件的语法：
    1.后缀.json
    2.主要数据类型为 对象({}类似Python中的字典) 和 数组([],类似Python中的列表)，对象和列表可以相互嵌套
    3.一个json文件是一个 对象或者数组(即json文件的最外层要么是{},要么是[])
    4.json中的对象是由键值对组成，每个数据之间使用逗号隔开，但最后一个数据后面不用写逗号
    5.字符串必须使用双引号
    6.其他数据类型：
        <1>数字类型 ---> int float
        <2>字符串 ---> str
        <3>布尔类型 ---> true,false

读取json文件：
import json
json.load(文件对象) #返回值为字典(对象)或者列表(数组)

json文件的写入：

import json
my_list = [...]
with open ("info.json",'w',encoding = 'utf-8') as f:
    json.dump((my_list,f,ensure_ascii = False,indent = 4) # ensure_ascii , indent皆为可选参数

异常捕获基本语法：
try:
    可能发生异常的代码
except：        或者except 异常类型 # 只能捕获指定类型的异常
    发生异常执行的代码

异常捕获的完整格式：
try:
    可能发生异常执行代码
except 异常类型1：
    发生异常类型1执行代码
except Exception as 变量：
    发生其他类型的异常执行代码
else:
    没有发生异常执行的代码
finally:
    无论异常是否发生都执行的代码

模块的两种导入方法：
方法一：
import 模块名
#使用模块中的内容 模块名.工具名
import random
random.randint(a,b)

方法二：
from 模块名 import 工具名
#使用内容 直接模块名，如果是函数和类需要加括号
from random import randint
randint(a,b)

__name__的作用
1.每个代码文件都是一个模块
2.再导入模块的时候，会执行模块中的代码

如果在导入时有一段不想执行的代码，只需要使用if判断即可
if __name__ == __main__:
    ...