记录python学习，直到学会基本的爬虫，使用python搭建接口自动化测试就算学会了，在进阶webui自动化，app自动化

标识符约定

在 Python 中，有一些约定和最佳实践来命名标识符（变量、函数、类等的名字）。
变量名：

使用小写字母，并用下划线分隔单词，这称为“snake_case”。
例如：my_variable、user_name。
函数名：

与变量名类似，也使用小写字母和下划线分隔单词。
例如：my_function、calculate_area。
类名：

使用首字母大写的驼峰式命名（CapWords），也称为“CapWords”或“CamelCase”。
例如：MyClass、UserManager。
模块名：

使用小写字母，单词间可以用下划线分隔，但尽量避免使用下划线，除非模块名包含多个单词。
例如：mymodule、imageprocessing。
包名：

与模块名类似，但通常更短，且全部使用小写字母。
例如：mypackage、django。
常量名：

使用全大写字母，并用下划线分隔单词。
例如：MAX_VALUE、PI。
异常名：

通常遵循类名的约定，使用首字母大写的驼峰式命名。
例如：MyError、ValueTooLargeError。
方法名和属性名：

与函数名类似，使用小写字母和下划线。
例如：my_method、get_data。
私有变量：

使用单个前导下划线表示私有变量，但这不是硬性规定，仅作为约定。
例如：_my_variable。
受保护的变量：

使用单个前导下划线和后导下划线表示受保护的变量，这也不是硬性规定。
例如：my_variable。
私有方法：

使用双下划线前缀表示私有方法，Python 会对其进行名称改写（name mangling）。
例如：__my_method。
特殊方法：

使用双下划线前后缀，这些方法通常不需要用户直接调用。
例如：__init__、__call__。

动态语言和静态语言

动态语言（Dynamic Languages）
类型检查时机：动态语言在运行时（Runtime）进行类型检查。这意味着变量在定义时不必指定类型，它们的类型会在程序执行过程中根据赋值自动确定。

类型灵活性：在动态语言中，同一个变量可以在程序的不同部分被赋予不同类型的值，而不需要显式地声明类型转换。

示例语言：Python、Ruby、JavaScript、Perl 等。

优点：

快速开发：由于不需要事先声明类型，可以快速编写和修改代码。
灵活性：代码更加灵活，可以轻松地处理不同类型的数据。
缺点：

运行时错误：类型错误可能在程序运行时才被发现，这可能使得调试更加困难。
性能：由于类型检查发生在运行时，可能会对性能产生一定影响。
静态语言（Static Languages）
类型检查时机：静态语言在编译时（Compile Time）进行类型检查。这意味着在代码编译之前，所有的变量和函数都必须有明确的类型。

类型严格性：在静态语言中，一旦变量被赋予了特定的类型，通常就不能被赋予其他类型的值，除非进行显式的类型转换。

示例语言：C、C++、Java、C# 等。

优点：

编译时错误检测：类型错误和其他一些错误可以在编译时被发现，有助于提前发现和修复错误。
性能：由于类型检查在编译时完成，运行时性能通常更好。
缺点：

开发速度：需要事先声明类型，可能会减慢开发速度。
灵活性较低：代码的灵活性不如动态语言，处理不同类型的数据时可能需要更多的类型转换。

隐式转换和显式转换

隐式转换

python 在进行算术运算时会自动将整数转换为浮点数，但不会将浮点数转换为复数，也不会将较小的数值类型转换为较大的数值类型（例如，int 到 float）。Python 的隐式类型转换通常发生在：
注意:在实际使用了，不要用隐式转换，统一用显式转换，不要问为什么？实际中懒得找数据

1、将整数与浮点数进行运算时，整数会被转换为浮点数。
2、将字符串与数值类型进行运算时，字符串会被尝试转换为数值类型。

字符串与数值相加：

python
number = 10
result = number + " days"  # "10 days"

在这里，整数 10 被隐式转换为字符串，然后与 " days" 连接。

不同数值类型之间的运算：

python
integer_value = 10
float_value = 3.14
result = integer_value + float_value  # 13.14

整数 10 被隐式转换为浮点数，以便与 3.14 进行加法运算。

列表与整数进行运算：

python
my_list = [1, 2, 3]
result = my_list * 3  # [1, 2, 3, 1, 2, 3, 1, 2, 3]

这里，列表被隐式地重复了三次。

布尔上下文中的隐式转换
布尔上下文中的隐式布尔值转换：

python
my_list = []
if my_list:  # 等同于 if bool(my_list):
    print("List is not empty")
else:
    print("List is empty")  # 这会被打印，因为 my_list 为空，所以被视为 False
空列表 [] 在布尔上下文中被隐式转换为 False。

数字在布尔上下文中的隐式转换：

python
number = 0
if number:  # 等同于 if bool(number):
    print("Number is true")
else:
    print("Number is false")  # 这会被打印，因为 number 为 0，被视为 False
数字 0 在布尔上下文中被隐式转换为 False。

比较操作中的隐式转换
字符串与数字比较：

python
number = 23
string = "23"
if number == string:  # True
    print("Number and string are equal")
在这里，数字 23 被隐式转换为字符串 "23"，然后进行比较。

不同类型的序列比较：

python
list1 = [1, 2, 3]
tuple1 = (1, 2, 3)
if list1 == tuple1:  # True
    print("List and tuple are equal")
列表 list1 被隐式转换为元组，然后与 tuple1 进行比较。

显式转换

int(x)：将 x 转换为整数类型。如果 x 是一个字符串，那么它必须表示一个有效的整数。

python
int("123")  # 结果是 123
int(12.34)  # 结果是 12

float(x)：将 x 转换为浮点数类型。x 可以是一个整数、字符串或另一个浮点数。

python
float("123.45")  # 结果是 123.45
float(123)       # 结果是 123.0

str(x)：将 x 转换为字符串类型。几乎所有类型的对象都可以被转换为字符串。

python
str(123)        # 结果是 '123'
str(12.34)      # 结果是 '12.34'
str([1, 2, 3])  # 结果是 '[1, 2, 3]'

bool(x)：将 x 转换为布尔类型。空值、零、空字符串等被视为 False，非空值被视为 True。

python
bool(0)         # 结果是 False
bool(1)         # 结果是 True
bool([])        # 结果是 False
bool([1, 2, 3]) # 结果是 True

complex(real, imag)：将实部和虚部转换为复数类型。如果只提供一个参数，它将被用作实部，虚部为 0。

python
complex(1, 2)   # 结果是 1+2j
complex("1+2j") # 结果也是 1+2j

list(x)：将 x 转换为列表类型。x 可以是任何可迭代对象。

python
list("hello")   # 结果是 ['h', 'e', 'l', 'l', 'o']
list((1, 2, 3)) # 结果是 [1, 2, 3]

tuple(x)：将 x 转换为元组类型。x 可以是任何可迭代对象。

python
tuple([1, 2, 3]) # 结果是 (1, 2, 3)
tuple("hello")   # 结果是 ('h', 'e', 'l', 'l', 'o')

set(x)：将 x 转换为集合类型。x 可以是任何可迭代对象，重复的元素会被自动去除。

python
set([1, 2, 2, 3]) # 结果是 {1, 2, 3}
set("hello")      # 结果是 {'h', 'e', 'l', 'o'}

dict(x)：将 x 转换为字典类型。x 应该是一个包含键值对的可迭代对象，如列表或元组的列表。

python
dict([("a", 1), ("b", 2)]) # 结果是 {'a': 1, 'b': 2}
dict({'a': 1, 'b': 2})     # 结果是 {'a': 1, 'b': 2}

bytes(x)：将 x 转换为字节类型。x 可以是一个字符串或者任何支持缓冲区协议的对象。

python
bytes("hello", "utf-8")  # 结果是 b'hello'
bytes([0x48, 0x65, 0x6c, 0x6c, 0x6f])  # 结果是 b'Hello'
组。

bytearray(x)：与 bytes() 类似，但返回的是一个可变的字节数

python
bytearray(5)  # 结果是 bytearray(b'\x00\x00\x00\x00\x00')

实践是检验真理的唯一标准