Python的基础
-
自动声明: 在 Python 中，不需要显式声明变量类型，变量的类型是在赋值时根据值自动推断的。
-
动态类型: Python 是动态类型语言，变量的类型可以在运行时改变。
-
x = 10 # 整数 x = "hello" # 现在是字符串
变量作用域
Python
-
作用域规则: Python 使用 LEGB（Local, Enclosing, Global, Built-in）规则来解析变量的作用域。
-
全局变量: 可以在函数内部使用
global关键字来修改全局变量。
python语法：
在Java中布尔表达都是用括号括起来的 python中可用可不用
if 布尔表达式1：
代码块
elif 布尔表达式2：
代码块
elif 布尔表达式3：
代码块
....
else:
代码块
s = int(input("请输入分数:"))
if 80 >= s >= 60:
print("及格")
elif 80 < s <= 90:
print("优秀")
elif 90 < s <= 100:
print("非常优秀")
else:
print("不及格")
while 布尔表达式:
代码块
for 变量 in 可迭代对象:
# 执行的代码块
fruits = ["apple", "banana", "cherry"]
for fruit in fruits:
print(fruit)
#python中循环十次，也是从0开始，但是对比起来就比Java轻便多了
for i in range(10):
if i == 5:
break # 当 i 等于 5 时退出循环
if i % 2 == 0:
continue # 跳过偶数
print(i)
python和Java定义数组的区别，此外python还有一个叫元组的：
Java 数组
在 Java 中，数组是固定大小的并且类型是严格的。定义数组的语法如下：
// 声明和初始化一个整型数组
int[] myArray = new int[5]; // 定义一个长度为5的整型数组
// 直接初始化数组
int[] anotherArray = {1, 2, 3, 4, 5};
int firstElement = myArray[0]; // 访问第一个元素
myArray[0] = 10; // 修改第一个元素的值
Python 列表
在 Python 中，数组通常是用列表（list）来表示。列表是动态大小的，可以包含不同类型的元素。在 Python 中，列表是动态的，可以随时添加或删除元素，定义数组的语法如下：
# 定义一个列表（相当于数组）
my_list = [1, 2, 3, 4, 5]
# 列表可以包含不同类型的元素
mixed_list = [1, "two", 3.0, True]
first_element = my_list[0] # 访问第一个元素
my_list[0] = 10 # 修改第一个元素的值
# 获取列表的长度
length = len(my_list)
# 动态添加元素
my_list.append(6)
#列表的操作
切片操作：变量[起始下标:结束下标] #结束下标取不到
l = [1, 2, 3, 4, 5]
print(l[0:4])
l = [2, 3, 4, 6]
print(5 not in l) #输出“5不在列表l中”这句话的真假
元组：
1. 不能修改，不可变类型
2. 用（）的形式
3. 元组也是可迭代对象
4. 元组是有序的，下标操作,支持切面操作[:]
1. 创建：
直接创建，例如 t = (1,2,3,4,5)
2. 访问：
t[下标] #获取元素
3. 切片操作：
t[:] 返回元组
t = (1, 2, 3, 4, 5)
print(t[2]) #输出下标为2的元组元素
n = t[2:4] #切片，范围是下标2~4
print(n)
t = (1, 2, 3, 4, 5)
print(5 not in t) #5不在元组里面
元组有的方法和列表一样。
字典：
1. 直接创建
语法： d = {} #空字典
例如： d = {"name":"不良人","apple":"苹果"}
2.用dick函数创建：
my_dict = dict(name='Alice', age=30, city='New York')
# 或者使用 items() 方法
my_dict = {
'name': 'Alice',
'age': 30,
'city': 'New York'
}
#循环把字段的值遍历出来
for key, value in my_dict.items():
print(f"{key}: {value}")
#打印前加f再在里面使用{}就可以使用变量了。而Java的话你就需要变成
#例如println（"我的名字"+name）
print(f"My name is {name} and I am {age} years old.")
#输出My name is Alice and I am 30 years old.
python中的函数：
# animals.py
class Dog:
def __init__(self, name):
self.name = name
def bark(self):
return f"{self.name} says woof!"
class Cat:
def __init__(self, name):
self.name = name
def meow(self):
return f"{self.name} says meow!"
# main.py
from animals import Dog, Cat
#这里有个小细节如果你给类里的这些方法前面加一个静态的装饰器，那么就不需要实例化对象了，
#可以直接Dog点方法。
my_dog = Dog(name="Buddy")
my_cat = Cat(name="Whiskers")
print(my_dog.bark()) # 输出: Buddy says woof!
print(my_cat.meow()) # 输出: Whiskers says meow!
# a.py
class A:
sqldress = "sadasd" # 类属性
# main.py
from a import A
print(A.sqldress) # 输出: sadasd
# a.py
class A:
def __init__(self):
self.sqldress = "sadasd" # 实例属性
# main.py
from a import A
a_instance = A() # 创建类的实例
print(a_instance.sqldress) # 输出: sadasd
在 Python 中，函数不一定需要定义在类里面。函数可以定义在模块的全局作用域中，也可以定义在类内部。函数的文档
写代码的时候我们经常需要写文档，前面有提过#和三引号可以进行代码的注释，但在这里要介绍一种新的方法，也是写代码时常用的函数文档书写格式：在函数体的第一行用 “”" “”" 进行文档说明，这是标准化的函数文档书写。
例如：
python中的函数的闭包的理解和使用：
使用闭包的条件：
1. 必须是一个内嵌函数
2. 外部函数必须返回内部函数的函数对象
3. 内部函数必须使用外部函数的局部变量
闭包本身在 Python 中是一个非常强大和优雅的特性，特别是在需要动态生成函数和保留状态时。
到底什么是闭包，为什么要使用闭包，下面举个例子实现计数器的功能你就知道了。
分别用闭包和类实现一样的功能
#使用闭包
def make_counter():
count = 0 # 每个计数器都有自己的状态
def counter():
nonlocal count # 使用外部函数的 count 变量
count += 1
return count
return counter
# 创建多个计数器
counter1 = make_counter()
print(counter1()) # 输出: 1
print(counter1()) # 输出: 2
#使用类
def make_counter():
count = 0 # 每个计数器都有自己的状态
def counter():
nonlocal count # 使用外部函数的 count 变量
count += 1
return count
return counter
# 创建多个计数器
counter1 = make_counter()
print(counter1()) # 输出: 1
print(counter1()) # 输出: 2
#相似性：闭包和类在封装和状态管理方面确实有相似之处。闭包可以看作是一个轻量级的封装工具，而类
#则提供了更为丰富和强大的特性。
#区别：闭包适合更简单的任务和轻量级的功能，而类则适合复杂的应用程序和结构化的代码设计。关于在自动化框架的python补充：
class Event:
@staticmethod
@allure.step('立即购买并点击提交订单')
def event_submit_order(driver):
"""
立即购买并点击提交订单
:param driver:
:return:
"""
try:
driver.get(ENV.url + '18/')
# driver.sel_click((By.XPATH, '//body/div[5]/div[2]/ul[1]/li[1]/a[1]/img[1]'))
driver.sel_click((By.XPATH, "(//a[contains(text(),'立即购买')])[1]"))
driver.sel_click((By.XPATH, "//a[contains(text(),'去结算')]"))
driver.sel_click((By.XPATH, "//a[@id='order_btn']"))
sleep(1)
except Exception as e:
log.error(f'立即购买并点击提交订单事件异常，为：{e}')
raise e关于字符串的小细节：在 Python 中，字符串可以用单引号 (') 或双引号 (") 来定义，这两个选项是等效的。选择使用哪一种主要取决于代码的可读性和对字符串内容的需求。 在Python中，字符和字符串没有区别。可能有些同学学过其他的语言，例如Java，在Java中，单引号’a’表示字符’a’，双引号"abc"表示字符串"abc"，但在Python当中，它们没有区别，都统称字符串。
关于自动化框架的修饰器补充：
@staticmethod
@allure.step('立即购买并点击提交订单')
这两个放置的先后顺序有关系吗？
在 Python 中，装饰器的应用顺序是有关系的，装饰器的叠加效果是从内到外，从下到上执行的。
@staticmethod
@allure.step('立即购买并点击提交订单')
def event_submit_order(driver):
...
具体效果
-
@allure.step:- 这个装饰器会将
event_submit_order方法标记为一个 Allure 测试步骤。这意味着每次调用这个方法时，Allure 会记录这个步骤，并在测试报告中显示。
- 这个装饰器会将
-
@staticmethod:- 这个装饰器会将
event_submit_order方法定义为一个静态方法，使得这个方法可以通过类名直接调用，而不需要实例化类。 @staticmethod是 Python 中的一个装饰器（decorator），用于将类中的方法定义为静态方法（static method）。静态方法是与类本身相关联的方法，而不是与类的实例相关联。它不需要访问类的实例（通过self）或类本身（通过cls）。
- 这个装饰器会将
@allure.step('立即购买并点击提交订单')
@staticmethod
def event_submit_order(driver):
#以下代码是解释@staticmethod装饰器的
class MathUtils:
@staticmethod
def add(x, y):
return x + y
@staticmethod
def subtract(x, y):
return x - y
# 使用静态方法
result1 = MathUtils.add(5, 3)
result2 = MathUtils.subtract(5, 3)那么 event_submit_order 方法会首先被 staticmethod 装饰器处理，然后再被 allure.step 装饰器处理。这会导致 allure.step 装饰器的作用无法正确应用，因为它会尝试将一个静态方法作为测试步骤，但静态方法不是一个实例方法，因此 Allure 可能无法正确记录这个步骤。
总结
装饰器的顺序非常重要。在你的例子中，保持 @staticmethod 在上面，@allure.step 在下面的顺序是正确的，确保方法既是一个静态方法，又能够被 Allure 正确记录。如果改为反向顺序，很可能导致 Allure 记录失败。因此，务必注意装饰器的顺序以确保预期的功能正常运作。
