自动化之python面试

0：python有七大数据类型：

（1）数字（Number）：int(整型，长整型)，float(浮点型)，complex(复数）
（2）布尔（Boolean）：True,False
（3）字符串(String)：“Python”，‘python’
（4）列表（List）：[1,2,3,4]，[1,2,3,[1,2,3],"hello”]
（5）字典（Dictionary）:{1:“hello”,2:“world”}
（6）元组（Tuple）：（1,2,3，“hello”,“world”）
（7）集合（Set）:{1,2,3，“hello”}

一.基础数据类型的划分

可变/不可变：
可变：列表、集合、字典（可以进行更改，并且更改后物理地址不会发生改变）
不可变的：数字、字符串、元组（不可以进行更改，更改后就是一个新的对象了，物理地址发生了变化）

有序/无序：
有序序列包括：列表，元组，字符串 （list，tuple，string）-支持索引和切片
无序序列包括：字典，集合，（dictionary，set ）

二.列表和集合的区别

相同点：
a:都是可变的,可以对列表进行增删改查的操作。
对于查找操作，集合的性能明显优于列表，因为集合使用了哈希表来存储元素，可以在较短的时间内进行快速查找
对于增删操作，列表的性能会略优于集合，因为列表的底层实现是基于数组，可以进行快速的随机访问和修改，而集合的底层实现是哈希表，针对某些情况下需要重新构建哈希表。
不同点：
a:列表是有序的，集合是无序的
b:列表中中括号[]表示，集合用大括号{}表示
c:列表数据可重复，集合不可重复
Python列表和集合是可以相互转换的，需要使用内置函数list()和set()进行转换。

三.列表和元组的区别

相同点：
a.都是有序的
都可以存储任何数据类型
可以通过索引访问
都是有序的
都支持切片操作
不同点：
a.列表是可变的，元祖是不可变的
b.列表 以随意的增加、删除、修改元素，元素则不可以
d.定义列表时候使用中括号"[]“，定义元组时候使用小括号”()"
e.元祖的操作效率更高

四.字典和集合的区别

相同点：
都是用大括号“｛｝”
都是无序且可变的
不同点：
集合不能用索引
字典是键和值的配对，集合是一系列无序的、唯一的元素组合

五.python列表排序

sort() :不返回新列表，而是直接修改原始列表,默认升序
列表.sort(reverse=True) #倒叙
sorted()：它返回一个新的已排序列表，而不会改变原始列表，默认升序
sorted(列表，reverse=True) #倒叙

六：python 统计log文件有多少小写字母

a.用open打卡log文件，如果有中文，需要设置 字符编码 utf-8
b.读取文件的内容，读取出的格式为字符串
c.用正则表达式求出文件中的小写字母，读取的格式是list列表
d.求出列表的长度，即是小写字母的个数
a = os.path.dirname(file)
b = os.path.join(a,“filelog.log”)
print(b)
fs = open(b, encoding=“utf-8”)
content = fs.read()
print(content)
len_da = len(re.findall(r’[a-z]', content)) # 把大写字母单个的整合到一个列表里边，并计算长度
print(‘小写字母有%d个’ % len_da)

七：Python 中 *args 和 **kwargs 的作用

我们不确定将多少个参数传递给函数时使用，args用于元祖，**kwargs用于字典，同时使用*args和kwargs时，*args参数必须要列在kwargs前，否则会报错

八.Python中的self是什么？

self是类的实例或对象,init方法中的self变量引用新创建的对象，而在其他方法中，它引用其方法被调用的对象。

九.什么是装饰器和闭包

装饰器 装饰器本质上是一个函数，它可以接收一个函数作为参数，并返回一个新的函数。装饰器的作用是在不修改原函数源代码的情况下，为函数添加新的功能或者修改函数的行为。
装饰器的实现原理是使用了Python的函数嵌套和闭包特性。具体来说，装饰器实际上是将原函数作为参数传递给装饰器函数，然后在装饰器函数内部定义一个新的函数，该函数可以修改原函数的行为，然后再返回该函数。

闭包：
闭包是指一个函数能够访问并操作在其外部作用域定义的变量。在 Python 中，函数内部可以访问外部函数中的变量，这种嵌套函数的结构称为闭包。
装饰器是一个常见的使用闭包的应用场景，通过在外部函数内定义一个内部函数并返回它的引用，可以将内部函数作为装饰器函数来使用。装饰器函数可以修改被装饰函数的行为，例如在函数执行前后添加日志、计时等功能

装饰器的加载过程：
被装饰的函数头上会@装饰器名，当调用函数时，第一件事并不是调用这个函数，而且将这个函数作为参数传入到装饰器，先执行装饰器内函数的前半部分再执行这个函数内容，最后执行后半部分

 函数装饰器
 def my_decorator(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        print('wrapper of decorator')
        func(*args, **kwargs)
    return wrapper
@my_decorator
def greet(message):
    print(message)
greet('hello world')
print(greet.__name__)  # greet,

类装饰器
class Count:
    def __init__(self, a, *args, **kwargs):  # 类装饰器参数
        self.a = a
        self.num_calls = 0

    def __call__(self, func):  # 被装饰函数
        print(self.a)

        def wrapper(*args, **kwargs):
            print(self.a)
            self.num_calls += 1
            print('num of calls is: {}'.format(self.num_calls))
            return func(*args, **kwargs)

        return wrapper
@Count("aaaa")
def example():
    print("hello world")

十.字符串去重

s = “ajldjlajfdljfddd”
s = set(s)
s = list(s)
s.sort(reverse=False)
res = “”.join(s)

十一：字符串的基本操作

1.取值 字符串[下标]
2.获取字符串的长度 len(字符串)
3.切片（截取一部分字符串） 格式:字符串[起始索引：结束索引:步长] 取头不取尾
4.替换 replace(旧，新)
5.查找 find通过元素找索引，找到返回索引，找不到返回-1;index通过元素找索引，找到返回索引，找不到返回error
6.删除字符串前后的空格/字符 s.strip()
7.字符串分割：使用split方法来将字符串按照指定的分隔符进行分割，返回一个列表，s.split() # 默认就是以空格作为分隔符
8.字符串连接：使用join方法来将多个字符串连接为一个字符串，拼接符.join(列表) #拼接符也是字符串类型
9.无规则，拼接2个字符串 +

十二：字典的基本操作

1.创建字典{}
#使用大括号创建带有键值对的字典
my_dict = {‘key1’: ‘value1’, ‘key2’: ‘value2’}
#使用 dict() 函数创建带有键值对的字典
my_dict = dict(key1=‘value1’, key2=‘value2’)
#从列表创建字典，列表中的元素是由键值对组成的元组
my_dict = dict([(‘key1’, ‘value1’), (‘key2’, ‘value2’), (‘key3’, ‘value3’)])

2.访问字典中的值
可以使用方括号 [] 来访问字典中的值，将键作为索引传递给字典即可获取对应的值。
print(my_dict[‘name’]) #如果访问不存在的键，会触发 KeyError 异常
可以使用字典名.get(key名) 如果key不存在，不会报错。 返回None

3.修改和新增字典
字典[‘key’] = 值 #修改key的值，如果key不存在 则 新增键值对
update(): 将一个字典的键值对更新到另一个字典中。

4.删除字典元素
可以使用 del 关键字来删除字典中的元素，通过指定要删除的键来完成删除操作。
del my_dict[‘key’] ## 删除键’key’及其对应的值 ,如果尝试删除不存在的键，会触发 KeyError 异常
可以使用 pop() 方法来删除键，并返回对应的值，如果键不存在，pop() 方法会返回指定的默认值None。
removed_age = my_dict.pop(‘age’) # 删除键’age’及其对应的值，并返回被删除的值
还可以使用 popitem() 方法删除字典中的最后一个键值对，并返回被删除的键值对。
removed_item = my_dict.popitem() # 删除最后一个键值对，并返回被删除的键值对
clear(): 清空字典中的所有键值对
5.字典的遍历
遍历键：
for key in my_dict:
遍历值:
for value in my_dict.values():
遍历键和值：
for key, value in my_dict.items():
6.检查键是否存在
可以使用 in 关键字来检查某个键是否存在于字典中。
7.获取字典长度
可以使用len()函数来获取字典的长度，即键值对的数量

十三：列表的基本操作

1.创建列表
1.1 list0 = [] 或 list1 = [‘Baidu’, ‘Alibaba’]
1.2 list() 函数 创建(转换为)列表 this_list = list((‘apple’, ‘banana’))
2.访问列表
2.1 下标索引
list_name[0]表示列表的第一个元素，list_name[-1]则表示列表的最后一个元素。

2.2 切片访问
list_name[strat : end : step]，[start：end] 是左闭右开区间
3.循环遍历
for i in list
4.检查项目是否存在 i in list
使用 in 关键字检查列表中是否存在指定项时，如果存在，则返回 True ；反之，则返回 False
5.更改列表值 可以使用 append() 方法来添加列表项
6.列表连接(合并)/复制
+连接（合并） *复制
7.列表的比较 引入 operator 模块的 eq 方法
operator.eq(a, b)
8.列表的长度 len(list)
9.将其他类型 转换为列表list()
list(字符串) list(元祖) list(字典) list(集合)
10.max() 函数的作用是返回列表中元素最大值。min() 函数的作用是返回列表中元素最小值

11.删除列表 del del list[索引]删除单个元素 del list_de删除整个列表

12.内置方法
12.1 append() 方法用于在列表末尾添加新的对象。list.append(element) 必需。任何类型（字符串、数字、对象等）的元素。
12.2 insert() 方法用于将指定对象插入列表的指定位置。 list.insert(position, element)
12.3 extend() 方法用于在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）list.extend(iterable)
iterable必需。任何可迭代对象（列表、集合、元组等）。

12.4 count() 法用于统计某个元素在列表中出现的次数。 list.count(value) value必需。任何类型（字符串、数字、列表、元组等）。要搜索的值
sort() 方法用于对原列表进行排序，如果指定参数，则使用比较函数指定的比较函数。list.sort(reverse=True|False, key=myFunc)
reverse() 方法用于反向列表中元素。
删除元素 pop()、remove()、clear()

十三：字典嵌套字典，取出所有key

D = {'emp1': {'name': 'Bob', 'job': 'Mgr'},
     'emp2': {'name2': 'Kim', 'job2': 'Dev'},
     'emp4':'wo'
     }
list=[]
for key,value in D.items():
    list.append(key)
    if  isinstance(value,dict):
        for key in value:
            list.append(key)
print(list)

十四：一个球从100m高度自由落下，每次落地后反跳回原高度的一半，再落下，反弹，求在第5次落地时，共经过多少米，第5次反弹多高

sn = int(input("第一次球落下高度："))
hn = sn/2
print(hn)
for item  in range(1,5):
    sn = sn+2*hn  #第n次落地时共经过的米数
    hn = hn/2  # 第n次反跳高度

print("第5次落地共经过：",sn,"米")
print("第5次反弹",hn,"米高")

十五：深浅拷贝
浅拷贝：使用内置函数copy.copy(),创建一个新对象，该对象复制了原始对象的引用,修改新对象的嵌套对象会影响到原始对象。浅拷贝只复制对象的顶层结构
浅拷贝：使用内置函数copy.deepcopy(),创建一个新对象，该对象是独立的，与原始对象完全分离，修改新对象的嵌套对象不会影响到原始对象。深拷贝递归地复制了所有嵌套对象

import copy
original_list = [1, 2, [3, 4]]
print("原始对象",original_list) #[1, 2, [3, 4]]

new_list = copy.copy(original_list)
new_list[2].append(5)
print("浅拷贝后修改的原始对象",original_list)#[1, 2, [3, 4, 5]]
print("浅拷贝后修改的新对象",new_list)#[1, 2, [3, 4, 5]]

original_list_dep = [1, 2, [3, 4]]
print("原始对象",original_list_dep)#[1, 2, [3, 4]]
new_list_dep = copy.deepcopy(original_list_dep)
new_list_dep[2].append(5)
print("深拷贝后修改的原始对象",original_list_dep)# [1, 2, [3, 4]]
print("深拷贝后修改的新对象",new_list_dep)# [1, 2, [3, 4, 5]]

十五：统计列表中每个元素出现次数

# 方法一：使用函数Counter，可以迅速获取list中每个元素出现的次数
from collections import  Counter
print( Counter(list))
#方法二：利用list中的函数count，获取每个元素出现的次数
# 1.先定义一个空字典 ，给字典新增数据
# 2.列表去重 set,进行循环 #key=列表中的元素（需去重）,value=出现的次数
list = [1,2,5,1,2]
result ={}
for i in set(list):
    result[i] = list.count(i)
print(result)

十六：冒泡排序（基本/双向）

#基本冒泡排序
#这种方法使用双重循环遍历整个列表，每次比较相邻的元素并进行交#换。外层循环控制比较的轮数，内层循环遍历每个元素并进行比较。
def bubble_sort(arr):
    n = len(arr)
    for i in range(n):
        for j in range(n-i-1):
            if arr[j] > arr[j+1]:
                arr[j], arr[j+1] = arr[j+1], arr[j]
    return arr

arr = [5, 69, 12, 1, 66, 85, 21]
print('待排序的数组为：', arr)
print('从小到大排序后结果为：', bubble_sort(arr))

# 双向冒泡排序
#这个算法的基本思路是先从左到右遍历数组并将相邻的元素比较，如果顺序不正确就交换它们的位置。然后从右到左遍历数组并将相邻的元素比较，如果顺序不正确就交换它们的位置。不断重复这个过程，直到整个数组都排好序为止。
#每一次遍历时，都需要设置一个标志（swapped），以检查是否有元素被交换过，如果没有交换，说明数组已经排好序了，可以结束排序过程。

def cocktail_sort(array):
    n = len(array)  # 列表的长度
    start = 0
    end = n - 1
    swapped = True
    while swapped:
        swapped = False
        # 从左到右排序
        for i in range(start, end):
            if array[i] > array[i + 1]:
                array[i], array[i + 1] = array[i + 1], array[i]
                swapped = True
        if not swapped: #如果没有交换，说明已经排好序了，可以结束排序过程
            break
        end -= 1
        # 从右到左排序
        for i in range(end - 1, start - 1, -1):
            if array[i] > array[i + 1]:
                array[i], array[i + 1] = array[i + 1], array[i]
                swapped = True
        start += 1
    return array
arr = [23, -16, 0, 10]
print('待排序的数组为：', arr)
print('从小到大排序后结果为：', cocktail_sort(arr))

十五：生成器和迭代器
生成器：是一种特殊类型的迭代器，它使用函数和yield关键字定义，可以像普通函数一样调用和执行。在调用生成器运行的过程中，每次遇到yield时函数会暂停并保存当前所有的运行信息，返回yield的值，并在下一次执行next()方法时从当前位置继续运行，在使用时，生成器函数会返回一个生成器对象，取值时，通过next()方法或for循环操作获取生成器对象中的值。

迭代器：可以迭代取值的工具，实现了__next__方法，返回序列的下一个元素，如果没有元素了，就会抛出StopIteration异常，在python中，内部含有__iter__方法并且含有__next__方法的对象就是迭代器

十六：实例方法，类方法，静态方法的区别

实例方法：在类中定义的方法 默认都是实例方法，第一个形参是self，不需要使用任何的修饰符修饰
调用：对象.方法名
类名.方法名(对象, 参数列表)
类方法：使用 @classmethod 进行修饰，方法中第一个形参是cls
调用：对象.方法名
类名.方法名
应用场景：当一个方法中只涉及到静态属性的时候可以使用类方法(类方法用来修改类属性)
静态方法：使用 @staticmethod 来修饰，静态方法的 参数 没有任何的限制，可以没有任何参数，第一个参数也不必像 类方法 和 实例方法 那样
调用：对象.方法名
类名.方法名
应用场景：一般用于既不需要访问实例属性或者实例方法，也不需要访问类属性或类方法

十七：单例模式

单例模式，是指在内存中只会创建且仅创建一次对象的设计模式，让所有需要调用的地方都共享这一单例对象，主要目的是保证某一个实例对象只会存在一个，减少资源的消耗
实现方式1：重写 new 方法
实现方式2：闭包定义装饰器
使用场景：
需要频繁创建和销毁的对象；
创建花费太多时间或资源，但经常使用的对象；
工具类对象；
经常访问数据库或文件的对象。

十八：python常用的库

Pandas：主要用于数据分析
NumPy：用于支持N维数组。这些多维数组的稳健性是Python列表的50倍
Plotly库：构建可视化的必备工具，它非常强大，易于使用，并且能够与可视化交互
Selenium：一个用于Web应用程序测试的工具，可以自动控制浏览器，实现自动化测试
Appium：一个用于自动化移动应用测试的开源框架，可以用来测试Android和iOS应用程序
pytest：一个强大的Python测试框架，可以轻松地编写和运行测试用例
pytest-xdist：一个用于并行测试的框架，可以用来同时运行多个测试用例，提高测试效率
pytest-allure：一个用于生成Allure报告的框架，可以用来跟踪测试结果，并生成可读性强的Allure报告。
Unittest：Python的标准库，用于单元测试，可以自动运行测试用例，并生成测试报告
openpyxl库：读取 / 编写 Excel 2010 xlsx/xlsm/xltx/xltm 文件
Requests库：接口请求