data

docs/Python/常用语句.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
+```
+
+
+## 
+
+
+
+

docs/test/测试面试.md

@@ -1,6 +1,6 @@
 ---
 layout: default
-title: Jmeter理论
+title: 测试面试
 parent: Test
 ---