テスト自動化の面接での質問

パイソン

Pythonにはどのようなデータ型がありますか?

Python は、次の一般的なデータ型を含む、さまざまなデータ型をサポートしています。

1. 数値タイプ: 整数 (int)、浮動小数点 (float)、および複素数 (complex)。

2. 文字列型: 引用符 (一重または二重) で囲まれた不変の文字のシーケンス。

3. リスト (リスト): 角括弧で囲まれた、さまざまなタイプの要素を含めることができる順序付けされた変数シーケンス。

4. タプル (Tuple): 括弧で囲まれた、さまざまなタイプの要素を含めることができる順序付けされた不変シーケンス。

5. コレクション (セット): 中括弧で囲まれた、固有の要素を含む順序付けされていないコンテナー。

6. ディクショナリ (ディクショナリ): 中括弧で囲まれ、キーと値の間がコロンで区切られたキーと値のペアの順序付けされていないコレクション。

7. ブール型 (Bool): true または false の値を表し、True と False の 2 つの値のみを表します。

8. Null (なし): 存在しない値または空のオブジェクトを示します。

上記の一般的なデータ型に加えて、Python は、日時型 (datetime)、バイト型 (bytes)、バイト配列型 (bytearray) など、その他の特殊なデータ型も提供します。

Python は動的型付け言語であり、変数の型はその値に応じて決定され、必要に応じて異なるデータ型間で変換できます。同時に、Python はユーザー定義のデータ型もサポートしており、オブジェクトの作成、クラス (クラス) による属性とメソッドの定義、より複雑なデータ構造と動作の実現を実現します。

2 つの辞書を結合するにはどうすればよいですか?

Python では、update()メソッドまたは**演算子を使用して 2 つの辞書を 1 つの辞書にマージできます。以下に具体的な例と手順を示します。

1. 使用方法update():update()このメソッドは、ある辞書のキーと値のペアを別の辞書に更新または追加するために使用されます。2 つの辞書に同じキーがある場合、結合された辞書の値は新しい辞書の値で更新されます。

dict1 = {
    
    'a': 1, 'b': 2}
dict2 = {
    
    'b': 3, 'c': 4}

dict1.update(dict2)

print(dict1)
# 输出: {'a': 1, 'b': 3, 'c': 4}

上記の例では、dict1と がdict2マージされ、結果が に格納されますdict1。のキーと重複するdict2キー 'b' が存在するため、元のキー 'b' に対応する値が新しい値 3 に更新され、新しいキーと値のペア 'c': 4 が追加されます。に。dict1dict1dict1

2. **演算子を使用する:**演算子は、関数が呼び出されるときに、辞書のキーと値のペアをパラメーターとして解凍できます。辞書を結合する場合、2 つの辞書を解凍して新しい辞書に渡すことができます。

dict1 = {
    
    'a': 1, 'b': 2}
dict2 = {
    
    'b': 3, 'c': 4}

dict_merged = {
    
    **dict1, **dict2}

print(dict_merged)
# 输出: {'a': 1, 'b': 3, 'c': 4}

上の例では、合計が解凍されて新しい辞書に渡されdict1、演算子が 2 つの辞書のキーと値のペアを 1 つにマージします。このメソッドと同様に、キー「b」の値が 3 に更新され、新しいキーと値のペア「c」: 4 が追加されます。dict2dict_merged**dict_mergedupdate()

update()メソッドを使用するか**演算子を使用するかにかかわらず、2 つの辞書を結合して新しい辞書を作成し、ニーズに応じて適切な方法を選択できます。

Python はどのようにして json をファイルに書き込むのでしょうか?

JSON データをファイルに書き込むには、Python のjsonモジュールを使用できます。簡単な例を次に示します。

import json

data = {
    
    
    "name": "John",
    "age": 30,
    "city": "New York"
}

# 将数据写入 JSON 文件
with open("data.json", "w") as file:
    json.dump(data, file)

data上の例では、 JSON ファイルに書き込まれるデータを含むディクショナリを作成しました。次に、open()関数を使用してファイルを書き込みモードで開き、json.dump()関数を使用してファイルにデータを書き込みます。

このうち、json.dump()関数には 2 つのパラメータがあります。書き込むデータ (この場合はdata) と書き込むファイル オブジェクト (この場合はfile) です。を実行するとjson.dump(data, file)、指定したファイル（今回の場合data.json）にJSONデータが書き込まれます。

with open() as fileこの構文を使用する場合、withファイルはコード ブロックの終了後に自動的に閉じられるため、ファイルを明示的に閉じる必要がないことに注意してください。

上記のコードを実行すると、現在のディレクトリに という名前のファイルが生成されdata.json、dataそのファイル内の JSON データに辞書が書き込まれます。

のコードは、Except ステートメントの return 後に最終的に実行されますか?

exceptステートメント ブロック内のステートメントを実行した後、ステートメント ブロックが存在するreturn場合でも、ステートメント ブロック内のコードは引き続き実行されます。finallyfinally

finallyブロック内のコードは、try例外が発生したか、exceptステートメント内でステートメントが実行されたかに関係なく、ブロック内のコードが実行された後に常に実行されますreturn。exceptで実行してもreturn実行finallyされます。

これを説明する例を次に示します。

def test_function():
    try:
        print("Inside try block")
        return 1
    except:
        print("Inside except block")
        return 2
    finally:
        print("Inside finally block")

result = test_function()
print("Returned value:", result)

出力は次のとおりです。

Inside try block
Inside finally block
Returned value: 1

上記の例では、try「try ブロック内」がブロック内に出力され、実行されますreturn 1。次に、finally「Finally ブロック内」を出力するブロック内のコードが実行されます。最後に、関数は値 1 を返します。

したがって、tryまたはブロックexcept内で何returnが実行されるかに関係なくfinally、内部のコードは常に実行されます。

可変型と不変型とは何ですか?

Python では、Mutable と Immutable は、オブジェクトが変更できるかどうかを説明するために使用される概念です。可変オブジェクトは内部状態を変更または変更できるオブジェクトですが、不変オブジェクトは内部状態を変更できないオブジェクトです。

Python の不変型には、整数 (int)、浮動小数点数 (float)、ブール値 (bool)、文字列 (str)、タプルなどが含まれます。これらのオブジェクトは、作成後にその値や内部構造を変更することはできません。不変オブジェクトを変更しようとすると、実際には新しいオブジェクトが作成されます。

例えば：

x = 5  # 整数是不可变类型
x += 1  # 修改 x，实际上创建了一个新的整数对象
print(x)  # 输出：6

変数のタイプには、リスト (list)、辞書 (dict)、コレクション (set) などが含まれます。これらのオブジェクトは、作成後に値を変更したり、要素を追加または削除したりすることができます。

例えば：

my_list = [1, 2, 3]  # 列表是可变类型
my_list.append(4)  # 直接修改 my_list
print(my_list)  # 输出：[1, 2, 3, 4]

不変オブジェクトが特定の操作 (文字列の連結など) を実行する場合、元のオブジェクトをその場で変更する代わりに、新しいオブジェクトが作成される場合があることに注意してください。

オブジェクトの変更可能性を理解することは、オブジェクトの割り当て、受け渡し、および変更を適切に処理するために重要であり、予期しない動作やエラーを回避するのに役立ちます。

Python 関数が呼び出されるとき、パラメーターは値によって渡されますか、それとも参照によって渡されますか?

Python では、関数呼び出し時のパラメータの受け渡しは「値渡し」です。具体的には、Python は「参照値によってオブジェクトを渡す」アプローチを使用します。

関数を呼び出してパラメータを渡すとき、実際にはオブジェクトへの参照をパラメータとして関数に渡しています。これは、関数内では、関数パラメータと元のオブジェクトの両方が同じメモリ アドレスを参照することを意味します。

関数内で渡された可変オブジェクトを変更すると、元のオブジェクトは同じオブジェクトを参照するため、影響を受けます。不変オブジェクトの場合、その値は変更できないため、関数内の操作によって新しいオブジェクトが作成され、元のオブジェクトは影響を受けません。

例えば：

def modify_list(lst, number):
    lst.append(number)  # 修改传递的列表对象
    number += 1  # 对传递的数字进行操作，但不会影响原始对象

my_list = [1, 2, 3]
my_number = 5

modify_list(my_list, my_number)

print(my_list)  # 输出：[1, 2, 3, 5]
print(my_number)  # 输出：5

ご覧のとおり、変更可能なオブジェクトへの変更は関数の外部に表示されますが、不変オブジェクトへの変更は何の効果もありません。

パラメータの受け渡し方法は「値の受け渡し」ですが、可変オブジェクトの場合は参照によってオブジェクトの値を変更できることに注意してください。これは「参照渡し」に似ていますが、概念が異なります。実際、Python には実際の「参照渡し」はありません。

Pythonの深いコピーと浅いコピーの違い

Python では、ディープ コピーとシャロー コピーは、オブジェクトをコピーする 2 つの異なる方法です。(子オブジェクトに影響します)

ディープ コピーとは、単に参照をコピーするのではなく、すべてのサブオブジェクトを含むオブジェクトの新しいコピーをメモリ内に作成することです。これは、元のオブジェクトまたはそのサブオブジェクトが変更されても、ディープコピーされたオブジェクトは影響を受けないことを意味します。ディープコピーはcopy.deepcopy()関数単位で実装可能です。

浅いコピーでは新しいオブジェクトを作成しますが、元のオブジェクトの参照のみをコピーし、サブオブジェクト自体はコピーしません。元のオブジェクトのサブオブジェクトが変更されると、浅いコピー後のオブジェクトもそれに応じて変更されます。浅いコピーはcopy.copy()関数またはスライス操作で実装できます。

以下は、ディープ コピーとシャロー コピーのサンプル コードです。

import copy

# 深拷贝示例
list1 = [1, 2, [3, 4]]
list2 = copy.deepcopy(list1)  # 深拷贝 list1，创建了一个全新的对象副本

list2[0] = 5
list2[2][0] = 6

print(list1)  # 输出：[1, 2, [3, 4]]
print(list2)  # 输出：[5, 2, [6, 4]]

# 浅拷贝示例
list1 = [1, 2, [3, 4]]
list2 = copy.copy(list1)  # 浅拷贝 list1，创建了一个新对象，但仍然共享其中的子对象

list2[0] = 5
list2[2][0] = 6

print(list1)  # 输出：[1, 2, [6, 4]]
print(list2)  # 输出：[5, 2, [6, 4]]

ディープコピー後のオブジェクトは完全に独立したコピーであり、その変更は元のオブジェクトに影響を与えないことがわかります。場合によっては、浅いコピー後のオブジェクトは元のオブジェクトのサブオブジェクトを共有するため、サブオブジェクトの変更は 2 つのオブジェクトに影響します。

プログラムの正確性と期待される動作を保証するには、特定の状況に応じてディープ コピーまたはシャロー コピーを選択する必要があります。

Python が *args と **kwargs を使用するのはなぜですか

Python では、*argsと は**kwargs関数への可変数の引数を処理する 2 つの特別な引数です。これらを使用すると、関数をより柔軟かつ汎用的にすることができます。

*argsは、任意の数の非キーワード引数 (位置引数) を渡すための引数です。これにより、関数は任意の数の引数を受け取り、それらをタプルとして関数本体の引数に渡すことができます。これは、関数定義が受け取るパラメーターの数が不明な場合に便利です。

例えば：

def sum_numbers(*args):
    result = 0
    for num in args:
        result += num
    return result

print(sum_numbers(1, 2, 3, 4))  # 输出：10
print(sum_numbers(1, 2, 3, 4, 5, 6))  # 输出：21

**kwargsは、任意の数のキーワード引数を渡すための引数です。これにより、関数は任意の数のキーワード引数を受け入れ、それらを辞書として関数本体の引数に渡すことができます。これは、関数定義が受け取るキーワード引数の数がわからない場合に便利です。

例えば：

def build_person(**kwargs):
    person = {
    
    }
    for key, value in kwargs.items():
        person[key] = value
    return person

print(build_person(name='Alice', age=25, city='New York'))  
# 输出：{'name': 'Alice', 'age': 25, 'city': 'New York'}

関数呼び出しを使用する*argsと簡素化され、関数が任意の数の引数を処理できるようになります。**kwargs同時に、より柔軟なインターフェイスも提供し、機能の多用途性と適応性を高めます。

Python の継承とポリモーフィズムについての知識はありますか? 親クラスはサブクラスのメソッドを使用できますか?

オブジェクト指向プログラミングでは、Python は継承とポリモーフィズムの概念をサポートしています。

継承とは、クラス (サブクラスまたは派生クラスと呼ばれる) が別のクラス (親クラスまたは基本クラスと呼ばれる) のプロパティとメソッドを継承できることを意味します。サブクラスは、親クラスを変更することなく、親クラスの機能を自動的に取得できます。サブクラスは、継承されたメソッドをオーバーロード (オーバーライド) したり、独自の一意のメソッドを追加したりできます。

簡単な継承の例を次に示します。

class Animal:
    def __init__(self, name):
        self.name = name

    def speak(self):
        print("Animal speaks!")

class Cat(Animal):
    def speak(self):
        print("Meow!")

animal = Animal("Generic animal")
animal.speak()  # 输出：Animal speaks!

cat = Cat("Tom")
cat.speak()  # 输出：Meow!

上記の例では、Animalは親クラス、Catは子クラスです。Catクラスは、Animalそのクラスのプロパティとメソッドを継承し、親クラスのメソッドを書き換えます (カバーします) speak。

ポリモーフィズムとは、オブジェクトが異なるクラス間で異なる動作を示すこと、つまり、同じメソッドが異なるオブジェクトに従って異なる操作を実行できることを意味します。ポリモーフィズムにより、複数の異なるオブジェクトを統一した方法で操作できるようになり、柔軟性と保守性が向上します。

簡単なポリモーフィックな例を次に示します。

class Animal:
    def speak(self):
        pass

class Dog(Animal):
    def speak(self):
        print("Woof!")

class Cat(Animal):
    def speak(self):
        print("Meow!")

def animal_speak(animal):
    animal.speak()

animal = Animal()
dog = Dog()
cat = Cat()

animal_speak(animal)  # 输出：（什么都不输出）
animal_speak(dog)  # 输出：Woof!
animal_speak(cat)  # 输出：Meow!

上記の例では、animal_speak関数はオブジェクトをAnimalパラメータとして受け取り、そのspeakメソッドを呼び出します。渡されたさまざまなオブジェクトに応じて、speakメソッドはさまざまな動作を示し、ポリモーフィズムを実現します。ポリモーフィズムにより、関数コードを変更せずにさまざまなオブジェクトを処理できます。

継承とポリモーフィズムはオブジェクト指向プログラミングにおける重要な概念であり、コードの再利用性、スケーラビリティ、保守性の実現に役立ちます。Python では、継承とポリモーフィズムを通じて、より柔軟で拡張可能なコードを作成できます。

包装に対するあなたの理解について教えてください

カプセル化はオブジェクト指向プログラミングの重要な概念であり、データ (プロパティ) と操作 (メソッド) をユニット (クラス) にカプセル化し、内部実装の詳細を外部から隠し、内部データにアクセスして操作するための限られたインターフェイスのみを提供します。

Python では、アクセス制御文字を使用してカプセル化が実現されます。Python には 3 つのアクセス制御文字が用意されています。

1. パブリック アクセス修飾子 (パブリック アクセス修飾子): 特別なマークやシンボルはありません。デフォルトでは、すべてのプロパティとメソッドはパブリックであり、クラスによって内部および外部からアクセスできます。

2. プライベート アクセス修飾子 (プライベート アクセス修飾子): プロパティとメソッドの前に二重アンダースコア「__」を追加します。これは、プロパティまたはメソッドがプライベートであり、クラス内でのみアクセスでき、外部からは直接アクセスできないことを示します。

3. 保護されたアクセス修飾子 (保護されたアクセス修飾子): プロパティとメソッドの前に 1 つのアンダースコア「_」を追加します。これは、プロパティまたはメソッドが保護されており、クラスおよびサブクラス内でのみアクセスでき、外部からは直接アクセスできないことを示します。

簡単なパッケージの例を次に示します。

class Car:
    def __init__(self):
        self.__max_speed = 200  # 私有属性
        self._current_speed = 0  # 受保护属性

    def accelerate(self, speed):
        if self._current_speed + speed <= self.__max_speed:
            self._current_speed += speed
        else:
            self._current_speed = self.__max_speed

    def get_speed(self):
        return self._current_speed

car = Car()
car.accelerate(100)
print(car.get_speed())  # 输出：100

# 在类的外部访问私有属性会引发错误
print(car.__max_speed)  # 报错：AttributeError: 'Car' object has no attribute '__max_speed'

# 在类的外部访问受保护属性是合法的，但不建议直接访问
print(car._current_speed)  # 输出：100

上の例では、__max_speedこれは私有財産であり、外部から直接アクセスすることはできません。_current_speedこれは保護された属性であり、外部からアクセスできますが、直接アクセスすることはお勧めできません。accelerateカプセル化は、プロパティにアクセスして操作するためのや などのパブリック メソッドを提供することによってget_speed実現されます。

カプセル化は、内部実装の詳細を隠し、優れたインターフェイスを提供し、コードをより保守しやすく、安全で、理解しやすくするのに役立ちます。カプセル化により、プロパティやメソッドへの直接アクセスを制限し、偶発的な変更やエラーの可能性を減らすと同時に、コードの再利用性と柔軟性を向上させることができます。

Python の self パラメータは何をするのでしょうか?

Python では、selfパラメータはオブジェクト自体を参照するために使用される従来の名前です。これはクラス内のメソッドの最初のパラメータであり、通常はメソッド定義内の他のすべてのパラメータの前に表示されます。

selfパラメーターの機能は、クラスのインスタンス (オブジェクト) をクラス内のメソッドに渡し、メソッドがインスタンスのプロパティとメソッドにアクセスして操作できるようにすることです。

クラスのメソッドを呼び出すと、メソッドを呼び出すインスタンスがselfパラメータとしてメソッドに自動的に渡されます。

を使用した例を次に示しますself。

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def introduce(self):
        print("My name is", self.name, "and I am", self.age, "years old.")

person = Person("Alice", 25)
person.introduce()  # 输出：My name is Alice and I am 25 years old.

上記の例では、パラメータはメソッドとメソッドでself使用されています。このメソッドでは、オブジェクトのプロパティを初期化するために、新しく作成されたオブジェクトにパラメータが渡されます。メソッド内のパラメータは、メソッドがオブジェクトに属していることを示し、オブジェクトのプロパティには を介し​​てアクセスできます。__init__introduce__init__selfintroduceselfself

selfこれは単なる慣例的な名前であり、代わりに他の名前を使用できることに注意してください。selfただし、オブジェクト自体を表すためにこの規則を使用することで、コードをより明確に理解するのに役立ちます。

要約すると、selfパラメーターを使用すると、メソッドはクラスのインスタンスのプロパティとメソッドにアクセスして操作できるようになります。これはオブジェクト指向プログラミングにおける重要な概念であり、クラスでメソッドを定義して使用するときにインスタンスとの接続を確立するのに役立ちます。

仕事でPythonを使って何をしましたか? なぜそれを使うのでしょうか？

1) インターフェイスと UI の自動化テストを実行します。
2) インターフェイス テスト ケース生成ツールなどの効率向上ツールを作成します。
3) 必要な情報を取得するためのクローラー スクリプトを作成します。
4) バッチ実行タスク スクリプトを作成します。

Pythonデコレータ

デコレータは、Python の強力で柔軟な構文機能であり、デコレータ関数のソース コードを変更せずに関数に機能を追加できます。デコレーターは、通常、@この表記法を使用して関数またはメソッドに適用されます。これは本質的に、関数を引数として受け取り、新しい関数または呼び出し可能な関数を返す高階関数です。

以下は、デコレータを定義して適用する方法を示す簡単なデコレータの例です。

def decorator(func):
    def wrapper(*args, **kwargs):
        # 在被装饰函数执行前的操作
        print("Before function execution")
        
        # 执行被装饰函数
        result = func(*args, **kwargs)
        
        # 在被装饰函数执行后的操作
        print("After function execution")
        
        # 返回被装饰函数的结果
        return result
    
    # 返回装饰后的函数
    return wrapper

@decorator
def some_function():
    print("Inside the function")
    
# 调用装饰后的函数
some_function()

関数実行前
関数内 関数
実行後

上記の例では、decoratorは関数を引数として受け取り、新しい関数を返すデコレータ関数ですwrapper。wrapperこの関数は、装飾された関数の実行の前後に追加の操作を追加し、装飾された関数を呼び出して、その結果を返します。

装飾された関数の前にこれを使用することで@decorator、デコレーターを適用して、some_function()実行の前後に追加の情報を出力します。したがって、 が呼び出されるときsome_function()、装飾された関数が実際に呼び出されますwrapper。

デコレータは、ロギング、プロファイリング、例外処理など、さまざまなシナリオで使用できます。特定のニーズに応じて独自のデコレーター関数を定義し、それを追加する必要がある関数またはメソッドに適用して、コードの再利用と柔軟性を実現できます。

PythonでのOSモジュールの一般的なアプローチ?

Python では、os モジュールはオペレーティング システムと対話するための組み込みモジュールです。ファイルやディレクトリの操作、プロセス管理、環境変数などに関連する操作を実行するための多くのメソッドが提供されます。os モジュールの一般的なメソッドをいくつか示します。

1. ファイルとディレクトリの操作:

• os.getcwd(): 現在の作業ディレクトリのパスを取得します。
• os.chdir(path): 現在の作業ディレクトリを指定したパスに変更します。
• os.listdir(path): 指定されたパスにあるすべてのファイルとディレクトリのリストを返します。
• os.mkdir(path): 指定したパスでディレクトリを作成します。
• os.makedirs(path): 複数レベルのディレクトリを再帰的に作成します。
• os.remove(path): 指定したパスのファイルを削除します。
• os.rmdir(path): 指定したパスのディレクトリを削除します。ディレクトリが空の場合のみ削除できます。
• os.removedirs(path): 複数レベルのディレクトリを再帰的に削除します。
• os.path.isfile(path): パスがファイルであるかどうかを確認してください。
• os.path.isdir(path): パスがディレクトリであるかどうかを確認します。

2. プロセス管理:

• os.system(command): サブシェルで指定されたコマンドを実行します。
• os.spawnl(mode, path, ...): 指定されたプログラムを新しいプロセスで実行します。
• os.kill(pid, signal): 指定したプロセスにシグナルを送信します。

3. 環境変数：

• os.environ: 環境変数を含む辞書。
• os.getenv(key): 指定されたキーに基づいて環境変数の値を取得します。
• os.putenv(key, value): 環境変数の値を設定します。

4. その他の一般的な方法:

• os.name: 現在のオペレーティング システムの名前を取得します。
• os.path.join(path1, path2): 2 つのパスを連結します。
• os.path.exists(path): パスが存在するかどうかを確認します。
• os.path.abspath(path): 指定されたパスの絶対パスを返します。

OS モジュールの一部のメソッドは、基礎となるオペレーティング システムと対話するため、オペレーティング システムが異なると異なる場合があることに注意してください。したがって、os モジュールを使用するときは、異なるオペレーティング システム間の違いを考慮することが最善です。

これは、os モジュールによって提供されるいくつかの一般的なメソッドのサンプルにすぎません。公式ドキュメントを参照するか、help(os)コマンドを使用して詳細な情報を取得し、他の方法について学ぶことができます。

仕事ではどのような Python の組み込みライブラリとサードパーティ ライブラリを使用していますか?

時間
リクエストランダム セレンhttprunner Python の習熟度とアプリケーションはどの程度ですか
。

たとえば、インターフェイス自動化テストを行う学生は、よく使用されるライブラリ (openpyxl、pymysql、unittest、pytest、allure、os、logging...) をすぐにリストアップできます。

職場では、Python を使用して自動テストを行うことができ、また、作業効率を向上させるためにいくつかのスクリプトを作成することもできます。

PEP8とは何ですか?

PEP 8 (Python Enhancement Proposal 8) は、Python コードのスタイルを統一し、コードの可読性を向上させるために Python コミュニティによって開発された公式スタイル ガイドです。

PEP 8 には、Python コード仕様に関する一連の推奨事項とルールが含まれており、命名規則、コード レイアウト、コメント、インポート ステートメント、その他多くの側面をカバーしています。その目的は、さまざまな開発者によって作成された Python コード スタイルに一貫性を持たせ、コードを読みやすく、理解し、保守しやすくすることです。

PEP 8 の一般的な仕様と推奨事項をいくつか示します。

1. インデントとスペース:

• インデントには 4 つのスペースを使用します。
• インデントにタブを使用しないでください。
• 二項演算子の前後、カンマの後、コロンの後にスペースを使用します。

2. 命名規則：

• 変数、関数、モジュールの名前には小文字とアンダースコアを使用します。
• クラス名にはキャメルケースが使用され、各単語の最初の文字は大文字になります。

3. ノート：

• 関数、クラス、またはモジュールに docstring の注釈を付けます。
• 行コメントには # を使用します。

4. インポートステートメント:

• 各 import ステートメントは別の行に置く必要があります。
• 合意された順序でモジュールをインポートすることをお勧めします (最初に標準ライブラリ モジュール、次にサードパーティ モジュール、最後にカスタム モジュール)。

これは PEP 8 の仕様の一部にすぎません。完全な PEP 8 ガイドにはさらに多くの内容と詳細が含まれており、公式 Python ドキュメント (https://www.python.org/dev/peps/pep-0008) で見つけることができます。 /)。

PEP 8 仕様に従うと、コードが読みやすく、理解しやすく、保守しやすくなり、他の Python 開発者とのコラボレーションの効率が向上します。Python コードを作成するときは、PEP 8 に従うことをお勧めします。多くの開発ツールとエディタは、PEP 8 の自動チェックとフォーマットを提供し、一貫したコード スタイルを維持するのに役立ちます。

プログラミング

1 から 100 までの合計を得るには、Python スクリプトを使用してください。

Python スクリプトでループとアキュムレータ変数を使用して、1 から 100 までの合計を計算できます。簡単な例を次に示します。

total = 0

for num in range(1, 101):
    total += num

print("从1到100的求和结果为：", total)

上の例では、まずtotal変数を 0 に初期化し、次にforを使用して 1 から 100 までの数値をループします。各ループで、現在の数値をtotal変数に追加し、totalの値を更新します。最後に、print関数を使用して結果を出力します。

上記のコードを実行すると、次のように出力されます。

从1到100的求和结果为： 5050

上記は、1 から 100 までの合計を計算する一般的な方法です。数式を使用して解くなど、他の方法を使用することもできます。

加算演算を実行できるように無名関数を作成します。たとえば、入力 1、2 は結果を 3 として計算できます。

add=lambda x,y:x+y
print(add(2,3))
Python では、匿名関数は名前のない関数であり、ラムダ関数とも呼ばれます。これは関数を定義する簡潔な方法で、コードが 1 行だけの単純な関数に適しています。

匿名関数は、lambdaキーワード、パラメータ リストとコロン、関数本体を使用して定義されます。関数本体は式のみにすることができ、式の結果は匿名関数の戻り値として使用されます。

無名関数の例をいくつか示します。

1. 2 つの数値の合計を求めます。

add = lambda x, y: x + y
print(add(2, 3))  # 输出：5

2. 数値の二乗を求めます。

square = lambda x: x ** 2
print(square(5))  # 输出：25

3. 姓名に基づいてフルネームを返します。

full_name = lambda first, last: first.title() + " " + last.title()
print(full_name("alice", "smith"))  # 输出：Alice Smith

匿名関数は、関数オブジェクトが必要な単純な関数を定義するためによく使用されます。これらは他の関数に引数として渡すことも、リスト内包表記、マップ、フィルターなどの関数で使用することもできます。

匿名関数には単一の式しか含めることができないため、機能が制限されており、複数行のコードを含む複雑なロジックや関数には適していないことに注意してください。この場合、通常の名前付き関数を使用して実現する方が良いでしょう。

要約すると、匿名関数は関数を定義するための簡潔な方法であり、単純な関数シナリオに適しています。これは lambda キーワードを使用して定義され、関数オブジェクトが必要な場所であればどこでも使用できます。

list_1=[1,2,1,2,15,4,3,2,1,2]、list_1の重複する値を削除し、大きいものから小さいものへ並べ替えます。

set 関数と sort 関数を使用して、重複する値を削除し、リストを最大から最小の順に並べ替えることができます。実装のサンプルコードは次のとおりです。

list_1 = [1, 2, 1, 2, 15, 4, 3, 2, 1, 2]

# 去除重复值
unique_list = list(set(list_1))

# 从大到小排序
sorted_list = sorted(unique_list, reverse=True)

print(sorted_list)

上記のコードでは、set(list_1)コレクションの特性により要素の繰り返しが許可されないため、最初に を使用してリストをコレクションに変換します。次に、コレクションをリストに戻して、繰り返しのないリストを取得しますunique_list。

次に、sorted関数を使用して をunique_list並べ替えます。パラメータを設定することでreverse=True、大きい順から小さい順にソートすることが可能です。

最後に、print関数を使用してソートされたリストを出力します。

上記のコードを実行すると、次の出力が得られます。

[15, 4, 3, 2, 1]

上記のコードは、list_1重複する値を削除し、結果を大きいものから小さいものに並べ替えるという要件を満たしています。

文字列内の単語の数を数えます。単語とは、スペースではない連続した文字を指します。文字列には印刷不可能な文字が含まれていないと想定できることに注意してください。

[出力] 入力: "Hello, my name is John" 出力: 5
説明: ここでの単語はスペースではない連続した文字を指すため、「Hello,」は 1 単語としてカウントされます。

a= "Hello, my name is John"
i=0
for Char in a:
    if Char==" ":
        i=i+1
print(i+1)

Pythonでフィボナッチ数列を実現してみる

フィボナッチ数列は古典的な数列で、最初の 2 つの数は 0 と 1 で、3 番目の数から始まり、各数は前の 2 つの数の合計になります。シーケンスの最初のいくつかの数字は、0、1、1、2、3、5、8、13、21、…です。

以下は、フィボナッチ数列を計算するために Python で作成された関数です。

def fibonacci(n):
    sequence = [0, 1]  # 前两个数
    for i in range(2, n):
        next_num = sequence[i-1] + sequence[i-2]  # 计算下一个数
        sequence.append(next_num)
    return sequence

# 示例用法，计算前10个斐波那契数：
fib_nums = fibonacci(10)
print(fib_nums)

上の例では、計算されるフィボナッチ数列の長さを表すfibonacciパラメーターを受け取る関数を定義しました。nまずシーケンスの最初の 2 つの数値を定義し[0, 1]、次にループを使用して次の数値を計算し、指定された長さに達するまでシーケンスに追加します。最後に、完全なフィボナッチ数列が返されます。

fibonacci(10)この例では、最初の 10 個のフィボナッチ数を計算し、結果をfib_nums変数に格納するために呼び出します。次に、print関数を使用して結果を出力します。

上記のコードを実行すると、次のように出力されます。

[0, 1, 1, 2, 3, 5, 8, 13, 21, 34]

上記はフィボナッチ数列を計算する簡単な例です。の値を調整するnことで、より長いシーケンスを計算できます。

リスト内で最も繰り返しの多い要素とその繰り返し数を取得してください。

例 1: パラメータ ['a', 'b', 'a', 'b', 'c', 'd', '1', 'd', '2'] 結果: 最も繰り返されるものは次のとおりです: [ ' d', 'a', 'b']、繰り返し数: 2
例 2: パラメータ ['a', 'a', 'a', 'b', 'a', 'b', 'c' , 'd', '1', 'd', '2'] 結果: 最も多く繰り返される要素: ['a']、繰り返し数: 4 は、リスト内で最も繰り返される要素を使用することで達成できます
。collections.Counter繰り返される頻度。Counterハッシュ可能なオブジェクトの出現をカウントする Dictionary のサブクラスです。

以下のサンプル コードを見てください。リスト内で最も繰り返される要素と繰り返し数を取得する方法が示されています。

from collections import Counter

def get_most_frequent_element(lst):
    counter = Counter(lst)
    max_count = max(counter.values())
    most_frequent = [item for item, count in counter.items() if count == max_count]
    return most_frequent, max_count

# 测试示例
lst = ['a', 'b', 'a', 'b', 'c', 'd', '1', 'd', '2']
result = get_most_frequent_element(lst)
print("重复最多的是:", result[0])
print("重复个数:", result[1])

上記のコードを実行すると、出力が得られます。

重复最多的是: ['a', 'b', 'd']
重复个数: 2

上記のコードでは、Counter(lst)リスト内の要素の出現数をカウントするためにカウンター オブジェクトが作成されます。関数を使用しmax()て最大カウント値を検索し、リスト内包表記を使用してカウンタの項目を反復処理し、最大カウント値と等しい出現回数を持つ要素をリストに追加しますmost_frequent。

最後に、most_frequent結果としてカウント値と最大値を返します。このようにして、リスト内で最も多くの要素が繰り返される要素とその繰り返し数を取得できます。
このコードでは、[]リスト内包表記の構文になります。リスト内包表記は、新しいリストを作成し、特定の条件またはロジックに基づいて元のリストの要素をフィルタリング、変換、または処理するための簡潔な構文です。

1. counter.items(): これはcounterカウンター オブジェクトによって呼び出されるメソッドで、カウンターのキーと値のペアを含む反復子を返します。このコンテキストでは、返されたキーと値のペアは、リスト内の要素とその出現数を表します。

2. for item, count in counter.items(): これはイテレータを横断するループ構造です。これにより、イテレータ内の各キーと値のペアがitem2 つのcount変数と に解凍され、それぞれ要素とその数にアクセスできるようになります。

3. if count == max_count: これは要素をフィルタリングするために使用される条件文です。この条件は、要素の出現数がcount最大カウント値と等しい場合にmax_countのみ true になります。

4. item: これは、条件が満たされた場合に結果のリストに含める要素を定義するリスト内包表記の式部分です。

このリストの理解により、指定された条件に従って必要な要素をすばやくフィルタリングして、それらを新しいリストに形成することができますmost_frequent。

def func(data):
    # 重复最多的次数
    mv = max([data.count(i) for i in set(data)])
    # 获取重复最多的元素
    ns = [k for k in set(data) if data.count(k) == mv]
    print("重复最多的是：{},重复个数：{}".format(ns, mv))
​
if __name__ == '__main__':
    data = ['a', 'b', 'a', 'b', 'c', 'd', '1', 'd', '2']
    func(data)

Pythonで文字列内の指定された文字の出現数を数える方法

Pythonで文字列内の指定された文字の出現数を数える方法

s = "Count, the number of spaces."
print(s.count(" "))
x = "I like to program in Python"
print(x.count("i"))

リストの重複を排除し、リスト内の重複要素を検索します。

from collections import Counter #引入Counter
a = [1, 2, 3, 3, 4, 4]
b = dict(Counter(a))
print(b)
print([key for key,value in b.items() if value > 1]) #只展示重复元素
print({
    
    key:value for key,value in b.items() if value > 1}) #展现重复元素和重复次数

リスト (list) 内の各要素の出現数をカウントします。

lista = [1, 2, 3, 4, 12, 22, 15, 44, 3, 4, 4, 4, 7, 7, 44, 77, 100]
​
new_dict = {
    
    }
for item in lista:
    if item not in new_dict.keys():
        new_dict[item] = lista.count(item)
​
print(new_dict)

リスト内包表記では、リスト内のすべての奇数を検索し、新しいリスト a = [1,2,3,4,5,6,7,8,9,10] を構築します。

a = [1,2,3,4,5,6,7,8,9,10]
b=[item for item in a if (item%2!=0)]
print(b)

Python でバブルソートを書く a = [1, 3, 10, 9, 21, 35, 4, 6]

もちろん、特定のリストを並べ替えるためのバブル ソート アルゴリズムの作成をお手伝いします。以下は、Python で実装されたバブル ソート アルゴリズムです。

def bubble_sort(arr):
    n = len(arr)
    for i in range(n-1):
        for j in range(n-1-i):
            if arr[j] > arr[j+1]:
                arr[j], arr[j+1] = arr[j+1], arr[j]
    return arr

# 测试示例
a = [1, 3, 10, 9, 21, 35, 4, 6]
sorted_a = bubble_sort(a)
print(sorted_a)

このコードでは、関数は引数としてbubble_sortリストを受け取り、それをバブルソートします。このアルゴリズムの基本的な考え方は、リストを複数回走査することによって、より大きな要素をリストの末尾に徐々に入れ替えることです。(ラウンドごとに最大値が最後に移動します)arr

外側のループは、for i in range(n-1)通過するラウンド数を制御します。ここで、nはリストの長さです。内部ループfor j in range(n-1-i)走査の各ラウンドで、2 つの隣接する要素を比較し、サイズ関係に従ってそれらの位置を交換します。

最後に、ソートされたリストを返し、結果を出力します。この例では、sorted_aとなります[1, 3, 4, 6, 9, 10, 21, 35]。
Pythonでバブルソートを書く

a = [1, 3, 10, 9, 21, 35, 4, 6]
​
for _ in range(1,len(a)):
    for i in range(0,len(a)-j):
        # 前一位数 > 后一位数。交换位置。
        if a[i] > a[i+1]:
            a[i],a[i+1] = a[i+1],a[i]
​
print(a)

x の n 乗の再帰計算。例: 3 の 4 乗は 333*3=81

def fun(a,n):
    i=1
    for j in range(0,n):
        i=i*a
    print(i)
fun(3,4)

#再帰的な方法
def mi(x, n):
n == 0 の場合:
1 を返す
それ以外の場合:
x*mi(x, n-1) を返す
print(mi(3, 4))
#
非再帰的な方法:
def mix( x,n): range(n) 内のカウントの
結果 = 1 :結果 *= x結果を返しますprint (mi(3,4))

文字列を指定すると、重複を見つけてその位置を出力します。入力: abcaaXY12ab12 出力: a, 1; a, 4; a, 5; a, 10; b, 2; b, 11; 1, 8; 1, 12; 2, 9; 2, 13

特定の文字列内で重複を見つけてその位置を出力するには、辞書を使用して各文字が出現する場所を記録します。この機能を実現するための Python コードは次のとおりです。

def find_duplicate_positions(s):
    positions = {
    
    }
    duplicates = set()
    result = []

    for i, c in enumerate(s):
        if c in positions:
            duplicates.add(c)
            result.append((c, positions[c]))
        positions[c] = i + 1
    
    return result

# 测试示例
input_string = "abcaaXY12ab12"
duplicate_positions = find_duplicate_positions(input_string)
for char, position in duplicate_positions:
    print(f"{
      
      char}, {
      
      position}")

このコードでは、find_duplicate_positions関数は文字列をs引数として受け取り、繰り返される文字の位置のリストを返します。

まず、空の辞書を作成してpositions、各文字が出現する場所を記録します。また、空のコレクションを作成して、duplicates繰り返しの文字を保存します。

次に、s文字列内の各文字を反復処理します。この関数を使用して、enumerate文字のインデックスと値の両方を取得します。各文字について、それが辞書にcすでに存在するかどうかを確認します。positionsすでに出現している場合は、それが繰り返し文字であることを意味し、それをセットに追加しduplicates、その位置を結果リストに追加しますresult。最後に、c文字の最新の位置を現在のインデックスに 1 を加えた値になるように更新します。

最後に、結果リストが返され、メイン プログラムでテストされます。指定された例では、出力は次のように表示されます。

a, 1
a, 4
a, 5
a, 10
b, 2
b, 11
1, 8
1, 12
2, 9
2, 13

def find_repeat_char(s):
    data = {
    
    }
    for index, char in enumerate(s):
        temp = data.get(char, [])
        temp.append('{}, {}'.format(char, index+1))
        data[char] = temp
    print(data)
    res = []
    for value in data.values():
        if len(value) > 1:
            res.extend(value)
    return '; '.join(res)

print(find_repeat_char('abcaaXY12ab12'))

自動化された基本能力評価

jsonと辞書の違い

形式: JSON は、データをテキスト形式で表現し、データをキーと値のペアで保存するデータ交換形式です。ディクショナリは、キーと値のペアの形式でデータを保存する Python データ型です。

単体テスト フレームワークにはどのモジュールが含まれていますか?

Unittest フレームワークは、Python の標準テスト フレームワークであり、次のモジュールが含まれています。

1. unittest.TestCase:TestCaseはテスト ケースを作成するための基本クラスです。テスト ケースは、テスト メソッドと関連するアサーションを含む、テスト プロセスの最小単位です。

2. unittest.TestLoader:TestLoaderテスト ケースをロードするために使用されます。loadTestsFromModule()モジュール、テスト クラス、またはディレクトリからテスト ケースをロードするための、 、 、loadTestsFromTestCase()などのメソッドが提供されますdiscover()。

3. unittest.TestSuite:TestSuiteテスト ケースのコレクションです。複数のテスト ケースを整理および管理するために使用できます。

4. unittest.TextTestRunner:TextTestRunnerは、テスト ケースを実行し、テスト結果のテキスト レポートを生成するテキスト テスト ランナーです。テストを実行するためのメソッドを提供しますrun()。

5. unittest.mock: mockmodule は、unittestテストでモック オブジェクトとアサーションを作成するために使用されるフレームワークのアクセサリ モジュールです。ダミー オブジェクトの作成、関数の戻り値のモック化など、テスト関連の機能を提供します。

上記は、unittestフレームワークの主要なモジュールの一部です。これらのモジュールを使用すると、単体テストの作成と実行、テスト ケースの読み込みと管理、テスト結果レポートの生成を行うことができます。

__all__ = ['TestResult', 'TestCase', 'TestSuite',
           'TextTestRunner', 'TestLoader', 'FunctionTestCase', 'main',
           'defaultTestLoader', 'SkipTest', 'skip', 'skipIf', 'skipUnless',
           'expectedFailure', 'TextTestResult', 'installHandler',
           'registerResult', 'removeResult', 'removeHandler']

Jemeter または postman はマルチインターフェイス アソシエーション テストを実装していますか? アソシエーションを行うにはどうすればよいですか?

http://t.csdn.cn/qlJG7
JMeter では、インターフェイスの関連付けとは通常、インターフェイスの応答データから特定の値を抽出し、それらを後続のリクエストにパラメーターとして渡すことを指します。これは、後続のリクエストで使用する必要があるログイン後に取得された認証トークンなど、いくつかの動的な対話シナリオをシミュレートするときに役立ちます。

JMeter でインターフェイスの関連付けを実装する一般的な手順は次のとおりです。

1. 最初のリクエストを送信して応答を取得する: まず、インターフェイスの最初のリクエストを送信して応答を取得する必要があります。HTTP サンプラー (HTTP リクエストなど) を使用してリクエストを送信し、結果ツリー リスナーで応答データを表示できます。

2. エクストラクターを使用して関連する値を抽出する: 次に、JMeter が提供するエクストラクターを使用して、応答データから必要な値を抽出する必要があります。JMeter は、正規表現エクストラクター (Regular Expression Extractor)、CSS/JQuery エクストラクター (CSS/JQuery Extractor)、XPath2 エクストラクターなど、さまざまなエクストラクターを提供します。応答データのタイプと形式に基づいて適切な抽出ツールを選択し、必要な値を抽出するための抽出ルールを設定できます。

3. 後続のリクエストを追加し、関連する値を使用する: 後続のリクエストでは、JMeter のパラメータ化機能を使用して、抽出された関連する値をパラメータとしてリクエストに渡すことができます。リクエスト パラメーターで式を使用して、${}関連する値を参照できます${token}。

4. スレッド グループ パラメータの構成: テストで複数のスレッドを使用する場合は、各スレッドが関連付けられた値を正しく使用していることを確認する必要があります。スレッド グループにユーザー変数を設定し、関連付けられた値をユーザー変数に保存し、後続のリクエストでその変数を参照することができます。

上記の手順により、JMeter にインターフェイスの関連付けを実装し、インターフェイスの応答データを抽出して後続のリクエストに渡すことができます。これにより、実際のシナリオの動的な相互作用がシミュレートされ、インターフェイスの機能が効果的にテストされます。

インターフェース自動化のアサーションを行う方法

インターフェイス自動テストでは、アサーションはインターフェイスの応答結果が期待どおりかどうかを検証する重要なステップです。一般的なアサーション メソッドをいくつか示します。

1. アサーション ステータス コード: 応答のステータス コードをアサートすることで、インターフェイスの実行が成功したかどうかを確認します。通常、ステータス コード 2xx は成功を示し、4xx はクライアント エラーを、5xx はサーバー エラーを示します。

import requests
import unittest

class APITestCase(unittest.TestCase):
    def test_get_user(self):
        url = "http://example.com/api/user/1"
        response = requests.get(url)

        # 断言状态码为200
        self.assertEqual(response.status_code, 200, "接口返回状态码错误")

2. アサーション応答ヘッダー: 応答の特定のヘッダー情報をアサートすることで、インターフェイスの返されたコンテンツを検証します。

import requests
import unittest

class APITestCase(unittest.TestCase):
    def test_get_user(self):
        url = "http://example.com/api/user/1"
        response = requests.get(url)

        # 断言Content-Type头信息为application/json
        self.assertEqual(response.headers["Content-Type"], "application/json", "响应头信息错误")

3. 応答本文のアサート: 応答本文内のデータをアサートすることで、インターフェイスの返されたコンテンツを検証します。等価アサーション (assertEqual)、包含アサーション (assertIn) など、特定の比較のためにアサーション ライブラリによって提供されるメソッドを使用できます。

import requests
import unittest

class APITestCase(unittest.TestCase):
    def test_get_user(self):
        url = "http://example.com/api/user/1"
        response = requests.get(url)

        # 断言响应体中是否包含期望的字段值
        self.assertIn("John Doe", response.json()["name"], "响应体中的字段值错误")

4. 応答時間をアサート: 応答時間をアサートすることで、インターフェイスが期待どおりに動作していることを確認します。

import requests
import unittest

class APITestCase(unittest.TestCase):
    def test_get_user(self):
        url = "http://example.com/api/user/1"
        response = requests.get(url)

        # 断言响应时间小于1秒
        self.assertLess(response.elapsed.total_seconds(), 1, "接口响应时间过长")

上記は、一般的なインターフェイス自動テスト アサーション メソッドの一部であり、インターフェイスの特定の要件と期待される結果に応じて、適切なアサーション メソッドを選択できます。アサーションを使用すると、自動テストでインターフェイスの正確さと安定性を検証するのに役立ちます。

自動テストを使用してインターフェイスを削除する必要がある場合、アサートする方法

1) インターフェイスを要求した後に応答を取得し、ステータス コードをアサートしてフィールドを返し、インターフェイスが正しく返されることを確認します。
2) データベース操作を実行して、データが削除されたかどうかを確認します。
3) クエリ インターフェイスを呼び出して、削除されたデータがもう存在しないかどうかを確認します。

自動化の過程で検証コードを処理する方法

キャプチャの処理は、Web 自動テストにおける一般的な課題の 1 つです。キャプチャを処理する方法は次のとおりです。

1. 手動処理​​: 開発環境およびテスト環境のキャプチャの場合、自動テストを続行できるように、キャプチャを一時的に手動で入力できます。これにより、完全に自動化されていませんが、テスト プロセスが続行されます。

2. キャプチャのバイパス: テスト環境または開発環境のキャプチャが自動テストに必要ない場合は、自動テスト プロセスを正常に進めるためにキャプチャを一時的にバイパスできるかどうか開発チームと話し合うことができます。

3. プリセット検証コード: 特定のケースでは、開発チームと協力してテスト環境に固定検証コードをプリセットし、その固定検証コードを自動テストで使用して検証コードの検出をバイパスできるようにすることができます。

4. サードパーティのソリューションを使用する: キャプチャの問題を解決するために使用できるサードパーティのツールやサービスがいくつかあります。これらのサービスは、キャプチャを自動的に識別したりバイパスしたりするのに役立ちます。一般的なサードパーティのキャプチャ ソリューションには、Tesseract、Google Cloud Vision などの画像認識 (OCR) ライブラリの使用、または Anti-Captcha、2Captcha などのキャプチャ認識サービスの使用が含まれます。

サードパーティのソリューションを使用する場合は、サービス プロバイダーの条件と価格に注意する必要があり、一部のソリューションはすべての種類のキャプチャで機能しない可能性があることに注意してください。

どちらの道を選択する場合でも、開発チームとテスト チームと緊密にコミュニケーションを取り、状況に最適なソリューションを選択することが重要です。同時に、自動テストにおいて関連する法律、規制、倫理ガイドラインが確実に遵守されるように、検証コードの問題は慎重に処理する必要があります。

Pythonでデータベースを操作するにはどうすればよいですか?

Python では、さまざまなライブラリを使用してデータベースを操作できます。最も一般的なのは次のライブラリです。

1. SQLite3: Python に付属する標準ライブラリは、軽量のデータベース操作に適しています。

   import sqlite3
   
   # 连接到数据库
   conn = sqlite3.connect('your_database.db')
   
   # 创建游标对象
   cursor = conn.cursor()
   
   # 执行 SQL 查询
   cursor.execute('SELECT * FROM your_table')
   
   # 获取查询结果
   results = cursor.fetchall()
   
   # 关闭游标和连接
   cursor.close()
   conn.close()
   

2. MySQL: PyMySQL や mysql-connector-python などのサードパーティ ライブラリをインストールすると、Python で MySQL データベースに接続できます。

   import pymysql
   
   # 连接到数据库
   conn = pymysql.connect(host='your_host', user='your_user', password='your_password', database='your_database')
   
   # 创建游标对象
   cursor = conn.cursor()
   
   # 执行 SQL 查询
   cursor.execute('SELECT * FROM your_table')
   
   # 获取查询结果
   results = cursor.fetchall()
   
   # 关闭游标和连接
   cursor.close()
   conn.close()
   

3. PostgreSQL: psycopg2 または同様のライブラリをインストールすると、Python で PostgreSQL データベースに接続できます。

   import psycopg2
   
   # 连接到数据库
   conn = psycopg2.connect(host='your_host', user='your_user', password='your_password', database='your_database')
   
   # 创建游标对象
   cursor = conn.cursor()
   
   # 执行 SQL 查询
   cursor.execute('SELECT * FROM your_table')
   
   # 获取查询结果
   results = cursor.fetchall()
   
   # 关闭游标和连接
   cursor.close()
   conn.close()
   

上記のコードは、データベースへの接続、クエリの実行、接続の終了という基本的な操作の例を示しているだけです。具体的なデータベース操作は、挿入、更新、削除など、実行する操作によって異なります。データベースの種類と運用要件によっては、詳細と例について、対応するライブラリのドキュメントを参照する必要がある場合があります。

自動テストケースの書き方

1. テストケース ファイルでクラスを定義し、クラスに事前操作を実装します。
2. 各テスト メソッドはクラスのメソッド内に表示され、テスト メソッドにはテスト ステップ、テスト データの呼び出し、アサーション、および後処理操作が含まれます。

pytest のフロントエンド実装にはどのような方法がありますか?

pytest では、フィクスチャを使用してテスト ケースの事前操作を実装できます。以下は、pytest で一般的に使用されるいくつかのフロントエンド実装メソッドです。

1. 関数レベルのフィクスチャ: @pytest.fixture デコレーターを使用して、単一のテスト関数の実行の前後に事前操作または事後操作を実行できる関数レベルのフィクスチャを定義できます。

import pytest

@pytest.fixture
def setup():
    # 执行前置操作
    yield
    # 执行后置操作

def test_example(setup):
    # 测试代码

2. クラスレベルのフィクスチャ: @pytest.fixture デコレーターを使用して、テストクラスの各テストメソッドの実行前後に事前操作または事後操作を実行するクラスレベルのフィクスチャを定義できます。

import pytest

@pytest.fixture(scope="class")
def setup_class():
    # 执行前置操作
    yield
    # 执行后置操作

@pytest.mark.usefixtures("setup_class")
class TestExample:
    def test_method1(self):
        # 测试代码

    def test_method2(self):
        # 测试代码

3. モジュールレベルのフィクスチャ: @pytest.fixture デコレーターを使用してモジュールレベルのフィクスチャを定義できます。これにより、テスト モジュール全体のすべてのテスト関数の実行の前後に、事前操作または事後操作を実行できます。

import pytest

@pytest.fixture(scope="module")
def setup_module():
    # 执行前置操作
    yield
    # 执行后置操作

def test_example1(setup_module):
    # 测试代码

def test_example2(setup_module):
    # 测试代码

4. セッションレベルのフィクスチャ: @pytest.fixture(scope="session") デコレータを使用して、pytest セッション全体のすべてのテスト モジュールの実行前後に事前操作または事後操作を実行するセッションレベルのフィクスチャを定義できます。 。

import pytest

@pytest.fixture(scope="session")
def setup_session():
    # 执行前置操作
    yield
    # 执行后置操作

def test_example(setup_session):
    # 测试代码

上記は、pytest でのいくつかの一般的なフロントエンド実装メソッドです。テスト ケースの要件と範囲に従って、適切なフィクスチャ レベルを選択して事前操作を実装し、テストの実行前に必要な準備が確実に行われるようにします。

Appiumを始めるにはどのような方法がありますか

Appium はモバイル端末での自動テスト用ツールで、さまざまなテスト要件やシナリオに合わせて複数の起動方法をサポートしています。Appium を起動する一般的な方法は次のとおりです。

1. Appium Desktop 経由で開始する: Appium Desktop は、Appium サーバーを起動するための使いやすいインターフェイスを提供するビジュアル インターフェイスを備えた Appium ツールです。Appium サーバーを起動するには、デバイスを選択し、関連するパラメータを設定して、開始ボタンをクリックします。

2. コマンド ラインから開始:appiumコマンドを使用して、コマンド ライン インターフェイスから Appium サーバーを起動できます。たとえば、ターミナルでコマンドを実行すると、appiumデフォルト設定で Appium サーバーが起動します。

3. Appium Server から始める: Appium Server ライブラリを使用して、独自のコードで Appium サーバーを起動できます。このようにして、起動パラメータをより柔軟にカスタマイズできます。

from appium import webdriver

desired_caps = {
    
    
    'platformName': 'Android',
    'deviceName': 'device',
    'appPackage': 'com.example.app',
    'appActivity': 'com.example.app.MainActivity'
}

# 启动Appium服务器，建立会话
driver = webdriver.Remote('http://localhost:4723/wd/hub', desired_caps)

4. Appium サービスを開始する: Appium の Python ライブラリで提供される Appium サービスを使用して、Appium サーバーを開始できます。このアプローチにより、コード内で Appium サーバーを起動および停止できるようになり、自動テスト フレームワークへの統合が向上します。

from appium import webdriver
from appium.webdriver.appium_service import AppiumService

# 创建Appium Service实例
appium_service = AppiumService()

# 启动Appium服务
appium_service.start()

desired_caps = {
    
    
    'platformName': 'Android',
    'deviceName': 'device',
    'appPackage': 'com.example.app',
    'appActivity': 'com.example.app.MainActivity'
}

# 建立会话
driver = webdriver.Remote(appium_service.service_url, desired_caps)

# 执行测试

# 停止Appium服务
appium_service.stop()

Appium の主な起動方法は上記の通りですが、ご自身のニーズやテストフレームワークの要件に応じて、適切な起動方法を選択してください。どの方法を使用する場合でも、デバイスまたはエミュレータが適切にセットアップされ、Appium サーバーに接続されていることを確認する必要があります。

Web UIオートメーションにおける明示的な待機と暗黙的な待機の違いは何ですか

表示待機は、webdriverWait メソッドを呼び出して、要素が存在するか表示されるかを待機します。表示待機の自由度が高い。
暗黙的待機はグローバルな待機方法であり、配置時にすべての要素が見つからない場合は、暗黙的待機を使用して待機できます。

明示的待機と暗黙的待機は、Web UI 自動テストでページの読み込みと要素が表示されるのを待機するために使用される 2 つの一般的な待機方法ですが、次のような違いがあります。

明示的な待機 (明示的な待機):

• コード内で待機条件を明示的に指定して、条件が満たされるか最大待機時間を超えるまで待機します。
• WebDriverWait クラスを使用して明示的な待機を実装し、期待条件と組み合わせて待機条件を定義できます。
• 要素が表示されるまで待機する、要素が存在するまで待機する、要素がクリック可能になるまで待機するなど、さまざまな待機条件に応じて柔軟な待機を実行できます。
• 明示的な待機はより柔軟であり、特定のシナリオで実行を続行する前に条件が発生するまで待機する必要がある状況に適しています。

from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC

# 创建WebDriverWait对象，等待10秒，每0.5秒检查一次
wait = WebDriverWait(driver, 10, 0.5)

# 等待直到元素可见
element = wait.until(EC.visibility_of_element_located((By.ID, "element_id")))

暗黙的な待機:

• WebDriver オブジェクトをインスタンス化するときにグローバル待ち時間を設定し、各コマンドを実行するときに待ち時間が満たされているかどうかを確認します。
• 要素を検索するときに、その要素がすぐに利用できない場合、WebDriver は例外をスローする前に指定された時間待機します。
• 暗黙的な待機は、すべての検索操作に待機を適用し、要素が見つかるか、指定された待機時間を超えるまで、すべての要素の検索を待機します。
• 暗黙的待機の待機時間はドライバーのライフサイクル全体で有効であるため、ドライバーがインスタンス化されるときに一度設定する必要があります。

from selenium import webdriver

# 创建WebDriver对象，并设置隐式等待时间为10秒
driver = webdriver.Chrome()
driver.implicitly_wait(10)

# 查找元素时会等待10秒，如果找到元素则立即返回，否则抛出异常
element = driver.find_element_by_id("element_id")

概要:
明示的待機と暗黙的待機の間には、待機メカニズムと使用法にいくつかの違いがあります。明示的待機はより柔軟で、特定の条件に従って待機できるため、特定の条件が発生した後も実行を継続する必要がある状況に適しています。暗黙的な待機では、グローバルな待機時間を設定します。これはページ全体の要素検索操作に適用され、すべての要素の検索に対して事前に設定された時間待機します。待機方法を選択するときは、特定のニーズとシナリオに応じて使用する待機方法を決定できます。

要素を配置できない状況に遭遇したことはありますか? どうやって対処すればいいのでしょうか？

Web オートメーション テストで要素が見つからない場合は、次の理由が考えられます。

1. WebDriverWait要素がロードされていないか、遅延ロードされています: 要素が表示されるまで待機する時間が十分ではありません。要素が表示されるか操作可能になるまで、「しばらく待機」を使用します。

2. 不正確な要素の配置方法: 使用されている配置方法が正しくありません。別のセレクター (id、クラス、Xpath、CSS セレクターなど) を使用するなど、他の配置方法を使用して要素を見つけることができます。

3. 要素ロケーターの変更: Web ページの構造または動的コンテンツによって要素の位置情報が変更されるため、ロケーターを更新する必要があります。ブラウザの開発者ツールを使用して要素の属性を確認したり、より安定した配置方法を使用したりできます。

4. 要素が iframe またはフレーム内にある: 配置される要素が iframe またはフレーム内にある場合は、配置する前に対応する iframe またはフレームに切り替える必要があります。

5. 非同期読み込みまたは動的レンダリング: 一部のページでは非同期読み込みまたは動的レンダリング技術が使用されており、ページが読み込まれた後のある時点で要素が表示される場合があります。待機メソッド (明示的待機、暗黙的待機など) を使用して、要素が表示されるのを待つことができます。

6. 要素が複数の場所に存在する: ページ上に同一または類似の要素が複数ある場合、インデックスまたはその他の属性を使用して、目的の要素を正確に見つけることができます。

7. ページが完全に読み込まれていません。ページが完全に読み込まれていないか、ネットワーク遅延やその他の理由により要素が時間内に表示されない場合は、適切な待ち時間を増やすか、ネットワーク設定を調整してください。

要素が見つからない状況が発生した場合は、ログの出力、ページの状態の観察、デバッグツールなどを使用して問題の原因を分析し、状況に応じて対応する解決策を講じることができます。テストプロセス中に、さまざまな位置決め方法と待機戦略を柔軟に適用することで、要素の位置決めの精度と安定性を向上させることができます。

要素に ID がなく、iframe が多数ある場合、xpath の記述にも問題があり、id も xpath も使用できません。

要素に ID がなく、正確な位置決めに XPath も使用できず、ページ上に複数の iframe がある場合は、要素の位置決めに次の方法を使用してみてください。

1. クラス属性の使用: 要素に一意のクラス属性がある場合、driver.find_element_by_class_name()メソッドを使用して要素を見つけることができます。

element = driver.find_element_by_class_name("class_name")

2. name 属性の使用: 要素に一意の name 属性がある場合、driver.find_element_by_name()メソッドを使用して要素を見つけることができます。

element = driver.find_element_by_name("element_name")

3. CSS セレクターを使用する: 要素に固有の CSS プロパティがある場合は、driver.find_element_by_css_selector()メソッドを使用して要素をターゲットにすることができます。

element = driver.find_element_by_css_selector("css_selector")

4. 親要素を使用して検索する: まず、要素が配置されている親要素を検索し、その後、親要素のスコープ内でターゲット要素を検索し続けることができます。

parent_element = driver.find_element_by_xpath("parent_xpath")
element = parent_element.find_element_by_xpath("child_xpath")

これらのメソッドを使用する場合、ターゲット要素を十分に正確に特定できるように、選択した属性または要素が一意であることを確認する必要があります。また、要素がロードされて表示さWebDriverWaitれていることを確認するために、showwait() を使用して要素が表示されるのを待つことをお勧めします。

上記の方法でも要素を特定できない場合は、開発チームと協力して、正確な位置を特定するために要素に一意の識別子を追加するよう依頼することを検討してください。

同じブラウザで 2 つのウィンドウが開く場合、切り替えるには Selenium のどのコマンドを使用する必要がありますか?

Selenium を使用してテストを自動化する場合は、同じブラウザ内でウィンドウを切り替えるメソッドを使用できますswitch_to.window()。

具体的な手順は次のとおりです。

1. 現在のウィンドウのハンドル (ハンドル) を取得する:current_window_handleプロパティを使用して、現在のウィンドウのハンドルを取得できますcurrent_window = driver.current_window_handle。

2. すべてのウィンドウへのハンドルを取得:window_handlesプロパティを使用して、すべてのウィンドウへのハンドルを取得できますall_windows = driver.window_handles。

3. 別のウィンドウに切り替える:switch_to.window()メソッドを使用すると、切り替えるウィンドウ ハンドルがパラメータとして渡されます。たとえばdriver.switch_to.window(handle)、 はhandle切り替え先のウィンドウ ハンドルです。

簡単なサンプルコードを次に示します。

# 定位到当前窗口的句柄
current_window = driver.current_window_handle

# 打开一个新的窗口（可以是通过点击链接或其它操作打开的新窗口）

# 获取所有窗口的句柄
all_windows = driver.window_handles

# 切换到新窗口
for window in all_windows:
    if window != current_window:
        driver.switch_to.window(window)
        break

# 现在处于新的窗口进行操作

# 切回到原窗口
driver.switch_to.window(current_window)

ウィンドウを切り替える前に、現在のウィンドウのハンドルを保存し、loop ステートメントを使用して別のウィンドウに切り替えることに注意してください。最後に、switch_to.window()このメソッドを再度使用して、元のウィンドウに切り替えることができます。

アプリの自動化は行われていますか? どの技術フレームワークが使用されているか知っていますか?

https://blog.csdn.net/spasvo_dr/article/details/131131861
Appium しか知らない

アプリの自動化では実マシンと仮想マシンのどちらを使用しますか?

PO モード、ページ ファクトリーとは何ですか?

ページ ファクトリは、自動テストでページ オブジェクトを管理するための設計パターンです。これは、ページ オブジェクト モデル (ページ オブジェクト モデル) の実装を簡素化するように設計された Selenium WebDriver の拡張機能です。

ページ オブジェクト モデルは、ページをオブジェクトに抽象化するテスト設計パターンであり、各ページはクラスを表します。各クラスには、ページ内の要素と対応する操作が含まれます。これにより、ページ オブジェクトをインスタンス化し、そのメソッドを呼び出すことによってページを操作できるようになります。

Page Factory は、ページ オブジェクトを初期化するためのより高度な方法を提供します。注釈と反映メカニズムを使用してページ オブジェクトの要素が自動的に初期化されるため、要素を手動で検索して配置する必要がなくなります。

Page Factory では、@FindByページ オブジェクト クラスのページ要素に注釈を付けるために注釈が必要です。@FindByアノテーションは、たとえば CSS セレクター、XPath、またはその他の検索メソッドを使用して、要素の検索に関する情報を受け取ります。アノテーションを使用して、@FindBys複数のターゲティング基準を組み合わせることができます。テスト コードがページ ファクトリを使用してページ オブジェクトを作成すると、アノテーションによってページ オブジェクト内の要素が自動的に初期化されます。

以下は、Page Factory を使用してページ オブジェクトを初期化するプロセスを示すサンプル コードです。

public class LoginPage {
    
    
    @FindBy(id = "username")
    private WebElement usernameInput;

    @FindBy(id = "password")
    private WebElement passwordInput;

    @FindBy(id = "login-button")
    private WebElement loginButton;

    public LoginPage(WebDriver driver) {
    
    
        PageFactory.initElements(driver, this);
    }

    public void login(String username, String password) {
    
    
        usernameInput.sendKeys(username);
        passwordInput.sendKeys(password);
        loginButton.click();
    }
}

上の例では、LoginPageクラスはログイン ページを表します。注釈を使用して@FindBy、ユーザー名入力ボックス、パスワード入力ボックス、ログイン ボタンに注釈を付けます。PageFactory.initElements(driver, this)ページ オブジェクトの要素を初期化するためにコンストラクターで呼び出されます。

Page Factory を利用することで、ページオブジェクトモデルをより便利に実装でき、テストコードの可読性や保守性が向上します。要素を見つけて配置するプロセスが簡素化され、テスト コードがより明確になり、記述が容易になります。

セレンの原理を簡単に説明すると

ブラウザ API を制御する Web ドライバを提供し、ブラウザ ドライバを通じてブラウザと対話します。

UI 自動化テスト ケースは、実行プロセス中に不安定に見えることがよくあります。これは、今回は合格しても、次回は合格しないことを意味します。テスト ケースの安定性を向上するにはどうすればよいですか?

1. 表示待機の合理的な使用法
   2) 要素の配置方法をハードコーディングしないでください。
   3) データ処理後のテストリカバリ。
   chatgpt:
   UI 自動化テスト ケースの安定性を向上させるための一般的な提案とヒントをいくつか示します。

1. 明示的な待機: 明示的な待機メカニズムを使用して、ページ要素が表示されるか操作が完了するのを待機します。明示的な待機を使用すると、テスト コードは、単に固定された待機時間を使用するのではなく、特定の条件が発生するまで待機できます。これにより、ユースケースの安定性が向上し、ネットワーク遅延やページ読み込みなどの要因による予測不可能な動作を回避できます。

2. 配置戦略: ページ要素を配置するための適切な配置戦略を選択します。ID または一意の CSS セレクターに基づいてターゲットを設定すると、ユースケースの安定性が向上します。ページ構造の変更により位置情報エラーが発生する可能性があるため、位置情報に揮発性属性または XPath 式を使用しないでください。

3. 独立したテスト環境: UI 自動テスト用に独立したテスト環境を作成します。これにより、ユース ケースの安定性に対する外部要因の影響を軽減できます。たとえば、専用のテスト データベースを使用し、実際の運用データとのやり取りを避けます。

4. データ駆動型テスト: テスト データをテスト ケース コードから分離し、データ駆動型の方法でテストを実行します。このようにして、テスト データの変更を分離し、テスト ケースの安定性に影響を与えることなくテスト データを柔軟に更新できます。

5. 例外処理: 要素が見つからない、タイムアウトなど、考えられる例外を適切に処理します。try-catch ステートメントを使用して例外をキャッチし、例外が発生したときにエラー メッセージを処理してログに記録し、より適切な問題診断を行います。

6. 十分な待機時間: アクションを実行する前に、ページの読み込みとレンダリングに十分な時間を確保してください。要素を使用する前にページの初期化に時間が必要な場合は、要素が使用可能になるように適切な待機時間を追加できます。

7. 適切なテスト環境の回復: テスト ケースの実行後、テスト環境で適切な回復操作を実行します。これにより、各テスト ケースが同じ環境で実行されるようになり、環境問題によって引き起こされる不安定性が軽減されます。

8. テストを並行して実行する: テスト時間を短縮し、安定性を向上させるために、自動テストを並行して実行することを検討してください。複数のテスト ケースを同時に実行することで、実際のユーザーの動作をより適切にシミュレートし、潜在的な問題をより迅速に発見できます。

要約すると、UI 自動化テスト ケースの安定性は、適切な待機メカニズム、安定した配置戦略、独立したテスト環境、および適切な例外処理を使用することで向上できます。テスト ケースを作成するときは、さまざまなシナリオと境界条件を考慮し、テスト ケース内のバグや問題を適時に修正して、信頼性と安定性を確保することを忘れないでください。

自動化プロジェクトの実際の戦闘能力の評価

自動化は自分で構築したフレームワークですか、それとも既存のフレームワークで、そこにいくつかのユースケースが書かれているだけですか?

職場で自動テストを行う方法について教えてください。

UI 自動化:
1) まず、自動化フレームワークを選択し、自動化フレームワークを構築します。
2) 自動化が必要なテストケースと優先度の高いユースケースを整理します。
3) ページ オブジェクトを作成します。
4) テスト ケースを作成します。
5) 継続的な運用のために自動化プロジェクトを jenkins に統合します。
6) 自動テストメンテナンス。

会社が自動化をしたいと考え、あなたにそれを依頼した場合、どのような点から始めますか?

自動テストプロセス中に上流インターフェイスと下流インターフェイスのデータ依存関係にどのように対処するかについて、フレームワーク内のこの部分の設計ロジックの詳細を詳しく説明してください。

テスト ケースの前ステップでデータの準備を実行するか、データベースからのデータ クエリを実行するか、インターフェイスから返されたデータを使用するか、シミュレートされたデータを使用します。
自動テストにおけるアップストリーム インターフェイスとダウンストリーム インターフェイスのデータ依存関係に対処することは重要な問題です。この状況に対処するための一般的な方法をいくつか示します。

1. データのプリセット: 自動テストを実行する前にテスト データをプリセットします。これは手動で行うことも、自動スクリプトを使用して行うこともできます。事前構成されたデータには必要な依存データが含まれており、テストを開始する前に、これらのデータが対応するインターフェイスにすでに存在していることを確認してください。

2. インターフェイス データのロールバック: テスト前に、インターフェイスの削除または復元関数を呼び出すことによって、データが必要な初期状態にロールバックされます。テスト中に作成または変更されたデータは、インターフェイスが提供する特定の機能を使用して削除または復元できます。

3. データ生成: テストに必要なデータは、コードを記述するかデータ生成ツールを使用することで自動生成できます。これにより、テストが実行されるたびに新しい独立したデータが保証されます。たとえば、テスト データは、乱数発生器を使用して、または指定されたルールに従って生成できます。

4. インターフェイス間のデータ転送: アップストリーム インターフェイスの出力データをダウンストリーム インターフェイスのテストに使用する必要がある場合、データが正しく転送されることを確認する必要があります。これは、応答データをアップストリーム インターフェイスからダウンストリーム インターフェイスにフィードすることによって、またはアップストリーム インターフェイスからの出力データを共有データベースまたはファイルに保存することによって実行できます。これは、ダウンストリーム インターフェイスによって読み取られて消費されます。

5. データ シミュレーションとスタブ化: 直接制御できないアップストリーム インターフェイスの場合、データ シミュレーションまたはスタブ化技術を使用して、依存データの戻りをシミュレートできます。これは、シミュレーション ツールを使用するか、仮想サーバーを作成するか、プロキシ サーバーを使用することで実現できます。テスト要件に応じてシミュレートされたデータを設定できます。

6. 依存関係管理ツール: 依存関係管理ツール (Maven、Gradle など) を使用すると、関連するインターフェイスと依存関係の管理を簡素化できます。ビルド構成ファイルで依存関係を定義すると、テストの実行前に必要なインターフェイスとデータが適切に準備および構成されていることを確認できます。

上記の方法は、特定のテスト要件や環境に応じて選択して組み合わせて使用​​できます。テストの再現性と安定性を確保するには、自動化テストを開始する前に、アップストリーム インターフェイスとダウンストリーム インターフェイスのデータ依存性を考慮して解決することが重要です。

複数の環境、pytest はどのように環境を切り替えるのですか?

Pytest での異なる環境間の切り替えは、コマンド ライン パラメーター、構成ファイル、または環境変数をカスタマイズすることで実現できます。一般的に使用されるいくつかの方法を次に示します。

1. コマンド ライン パラメーター: カスタム コマンド ライン パラメーターを追加して、テストを実行する環境を指定します。pytest.addoptionこのメソッドを使用して、新しいコマンドライン パラメーターを定義し、テスト コードでそのパラメーターの値を読み取ることができます。たとえば、--envパラメータを追加して環境を指定できます。

# conftest.py

def pytest_addoption(parser):
    parser.addoption("--env", action="store", default="dev", help="Specify the test environment")

# test_module.py

def test_function(request):
    env = request.config.getoption("--env")
    if env == "dev":
        # 执行针对开发环境的测试逻辑
    elif env == "staging":
        # 执行针对演示环境的测试逻辑
    elif env == "prod":
        # 执行针对生产环境的测试逻辑
    # ...

--envテストを実行するときは、パラメータを使用して目的の環境を指定できますpytest --env dev。

2. 構成ファイル: 構成ファイルを使用して、さまざまな環境の構成オプションを定義します。pytest.iniまたはファイルを使用して、pytest.cfgテストの構成オプションを定義し、さまざまな環境構成に基づいてテストを実行できます。構成ファイルでは、次のようなさまざまな環境の変数を定義できます。

# pytest.ini

[pytest]
env = dev

次に、テスト コード内の構成オプションの値を読み取ります。

# test_module.py

def test_function(pytestconfig):
    env = pytestconfig.getoption("env")
    if env == "dev":
        # 执行针对开发环境的测试逻辑
    elif env == "staging":
        # 执行针对演示环境的测试逻辑
    elif env == "prod":
        # 执行针对生产环境的测试逻辑
    # ...

3. 環境変数: 環境変数を設定して、使用する環境を指定します。という名前の環境変数またはその他のカスタム環境変数を設定しPYTEST_ENV、テスト コードで環境変数の値を読み取って、使用される環境を判断できます。例えば：

# test_module.py

import os

def test_function():
    env = os.environ.get("PYTEST_ENV")
    if env == "dev":
        # 执行针对开发环境的测试逻辑
    elif env == "staging":
        # 执行针对演示环境的测试逻辑
    elif env == "prod":
        # 执行针对生产环境的测试逻辑
    # ...

上記の方法を使用すると、必要に応じて Pytest の異なる環境を柔軟に切り替えることができるため、テスト コードを異なる環境で実行できます。環境を切り替えるには、ニーズに最も適した方法を選択してください。

pytest がすべてのケースを実行した後にデータベースをクリーンアップするにはどうすればよいですか?

Pytest では、Fixture を使用してデータベースのクリーニング操作を実行できます。フィクスチャは、テストの実行に必要なリソースと環境を提供するために、テストの実行の前後に実行される関数です。フィクスチャを作成することでデータベースをクリーンアップできます。

以下は、Fixture を使用してデータベースをクリーンアップする方法を示すサンプル コードです。

import pytest
import your_database_module

@pytest.fixture(scope='session')
def db_cleanup():
    # 初始化数据库连接
    db = your_database_module.Database()
    
    # 清理数据库操作
    db_cleanup()
    
    # 关闭数据库连接
    db.close()

def test_example():
    # 测试逻辑
    
# 在测试运行之后执行 Fixture
def pytest_sessionfinish():
    db_cleanup()

db_cleanup()上記のコードでは、テスト全体で 1 回だけ実行されるFixture を定義します。ではdb_cleanup()、データベースをクリーンアップする操作を実行します。次に、テストの実行が失敗した場合でもデータベースが確実にクリーンアップされるようにpytest_sessionfinish()呼び出します。db_cleanup()

すべてのテスト ケースを実行すると、Pytest はフィクスチャの実行ロジックを自動的に処理し、各テスト ケースの実行前後に対応するフィクスチャが確実に実行されるようにします。

上記のコードは、your_database_module実際に使用するデータベース モジュールに置き換える必要があることに注意してください。特定のデータベース クリーニング操作は、使用するデータベースとデータ構造に従って作成する必要があります。

フィクスチャをカスタマイズすると、Pytest がすべてのテスト ケースを実行した後にデータベース クリーンアップやその他のクリーンアップ タスクを実行できるため、テストの独立性と精度が確保されます。