diff --git "a/docs/Python/\345\270\270\347\224\250\350\257\255\345\217\245.md" "b/docs/Python/\345\270\270\347\224\250\350\257\255\345\217\245.md" index 8862e69..ace4746 100644 --- "a/docs/Python/\345\270\270\347\224\250\350\257\255\345\217\245.md" +++ "b/docs/Python/\345\270\270\347\224\250\350\257\255\345\217\245.md" @@ -194,10 +194,10 @@ zhaoliu 1_2_3_5_4 ``` - ### 切片 `序列[起始下标:结束小标:步长]` + ```python num_list = [1, 2, 3, 4, 5] new_list2 = num_list[1:4] @@ -207,7 +207,278 @@ new_list = num_list[3:1:-1] ``` - ## tuple 因为元组中的元素是不能修改的，修改会报错。 + +## set + +```python + name_set = {"zhangsan", "lisi", 1, "zhaoliu", 3, "chenba"} # 定义一个容器 + print(name_set) + name_set.add("add") + name_set.pop() + name_set.remove("add") + name_set.union(name_set) + name_set.difference(name_set) + name_set.difference_update(name_set) +``` + +## dict + +```python + dict_a = {"d":1,"a":3} + dict_a.get("d") +``` + +# function + +```python + +def triple_print(a: int, b: None, c=3): + """ + 默认值 + b:None + c=3 + + list = [1, 2, 3] + triple_print(*list)这样调用是序列实参 + + dict01 = {"a": 1, "c": 3, "b": 2} + triple_print(**dict01)这样调用是字典实参 + """ + print(f"{a},{b},{c}") + + +def four_print(a=2, *b, d, **c): + """ + *b:是一个元组，接收任意个数的参数 + **c: + # args 是一个元组，接收任意个数的参数 + 可以多返回值 + """ + print(f"{a},{b},{c},{d}") + return a, b + +``` + +## Union类型 + +```python +from typing import Union + +my_list: list[Union[int, str]] = [1, "name"] # 定义了list中的元素是多种数据类型 +my_dict: dict[str, Union[int, str]] = {"name": "zhangsan", "age": 18} # 定义了value可以是多种类型 + + +def fun(data: Union[int, str]) -> Union[int, str]: # 定义返回值的类型注解 + pass + +def fun(data: Union[int, str]) -> list[Union[int, str]]: # 定义list返回值的类型注解 + pass + +``` + +# 类 + +```python +class Student: + + stu_count = 0; + + def __init__(self, sid, name, age): + self.sid = sid # 学号 + self.name = name # 姓名 + self.age = age # 年龄 + Student.stu_count += 1 + + @classmethod + def get_stu_count(cls): + print(f"一共创建了{Student.stu_count}个学生") + + +stu1 = Student("001", "张三", 18) +stu2 = Student("002", "李四", 19) +stu2 = Student("003", "王五", 17) +Student.get_stu_count() +``` + +## static method + +```python +class Math_Util: + + @staticmethod + def get_max(a, b): # 获取大的数 + return a if a > b else b + + @staticmethod + def get_min(a, b): # 获取小的数 + return a if a < b else b + + +max_num = Math_Util.get_max(11, 15) +print(max_num) + +min_num = Math_Util.get_min(11, 15) +print(min_num) + +``` + +## inner method + +```python +def __str__(self): + return f"sid:{self.sid}, name:{self.name}, age:{self.age}" +def __lt__(self, other): # other表示另一个对象，返回值为True或Flase + return self.age < other.age +def __le__(self, other): # other表示另一个对象，返回值为True或Flase + return self.age <= other.age +def __eq__(self, other): # other表示另一个对象，返回值为True或Flase + return self.age == other.age +def __repr__(self): + return f"Student('{self.sid}', '{self.name}', {self.age})" + +stu1 = Student("001", "张三", 18) +stu_str = repr(stu1) # 获取__repr__()方法返回的string数据 +print(stu_str) + +stu2 = eval(stu_str) # 将string执行，返回的是一个对象，相当于克隆了一个对象 +print(stu2.name) +print(stu1 == stu2) + + +``` + +## 私有属性和方法 + +定义私有成员的方式： + +定义私有成员变量：变量名以 __开头，2个下划线开头 +定义私有成员方法：方法名以 __开头，2个下划线开头 + +```python +class Phone: + + def __init__(self): + self.producer = "华为" # 手机品牌 + self.__voltage = 12 # 电压 + + def call(self): + print("打电话") + print(f"手机品牌：{self.producer}") + print(f"手机电压：{self.__voltage}") + + # 定义一个私有方法 + def __get_run_voltage(self): + print(f"当前电压：{self.__voltage}") + +phone = Phone() +phone._Phone__voltage = 24 # 修改私有属性 +phone.call() +phone._Phone__get_run_voltage() # 调用私有方法 + +``` + +**私有属性和私有方法是骗人的障眼法，完全可以通过 _类型__私有属性 和 _类型__私有方法 的形式来调用。** + +## getter和setter的初级进化 + +```python +producer = property(get_producer, set_producer) +voltage = property(get_voltage, set_voltage) +``` + +这是给属性绑定了getter和setter方法，这样，在访问属性的时候，会直接调用getter和setter方法。 + +所以 self.producer 和 phone.producer 都是调用的是方法，而不是属性，通过执行结果可以看出来，或者通过断点调试。 + +## getter和setter的终极写法 + +```python +class Phone: + + def __init__(self, producer, voltage): + self.producer = producer # 访问的不是属性，是方法 + self.voltage = voltage # 访问的不是属性，是方法 + + @property + def producer(self): + return self.__producer + + @producer.setter + def producer(self, producer): + self.__producer = producer + + @property + def voltage(self): + return self.__voltage + + @voltage.setter + def voltage(self, voltage): + if voltage < 36: + self.__voltage = voltage + else: + raise ValueError("参数错误") # 限制传入的参数值，进行报错处理 + + +phone = Phone("华为", 12) +print(phone.producer) # 调用的是方法，不是属性 +print(phone.voltage) + +phone.producer = "小米" # 调用的是方法，不是属性 +phone.voltage = 24 +print(phone.producer) +print(phone.voltage) +``` + +每个属性对应两个与属性名相同的方法，分别用于获取和设置属性，并在方法上添加 @property 和 @属性.setter 注解。 + +## `__slots__` + +我们之前可以通过 对象.属性 = 值 随时为一个对象添加属性。 + +`__slots__` 的作用就是限制一个类创建的实例只能有固定的属性，不能随意添加属性。 + + +```python +class Phone: + + __slots__ = ("producer", "__voltage") + + def __init__(self, producer, voltage): + self.producer = producer + self.__voltage = voltage + + +phone = Phone("华为", 12) +phone.size = 6 # 报错：AttributeError: 'Phone' object has no attribute 'size' +``` + +## 继承判定函数 +- type() 函数：type()函数可以判断某个对象是否是某个类型，注意：子类的对象不是父类的对象的类型。 +- isinstance()函数：isinstance()函数可以判断某个对象是否是某个类型的实例，子类对象也是父类对象的实例。 +- issubclass()函数：issubclass()函数可以用来判断一个类是否是另外一个类的子类。 + +## 多继承的解析顺序 +如果继承的多个父类拥有同样的属性和方法，那么会使用哪个父类的呢？ + +会使用先继承的父类的，后继承的无效，如果父类中都没有，则会去父类的父类寻找，一直向上找。 + +即使类没有写明继承其他类，但是所有的类都直接或间接继承自Object类。 + +## 抽象类 +含有抽象方法的类成为抽象类。抽象方法就是没有方法体，方法体为空的方法。 + +```python +class Vehicle: + def transport(self, destination): + pass +``` + + +## + + + + diff --git "a/docs/test/\346\265\213\350\257\225\351\235\242\350\257\225.md" "b/docs/test/\346\265\213\350\257\225\351\235\242\350\257\225.md" index bced0c2..c6fdd59 100644 --- "a/docs/test/\346\265\213\350\257\225\351\235\242\350\257\225.md" +++ "b/docs/test/\346\265\213\350\257\225\351\235\242\350\257\225.md" @@ -1,6 +1,6 @@ --- layout: default -title: Jmeter理论 +title: 测试面试 parent: Test ---