笔记

Python安装及配置

Python官网下载

直接下载到默认位置即可，并记住路径

环境安装及配置

将对应路径配置到用户变量，环境变量【个人认为，配置到一个地方即可】

PyCharm下载及配置

如果需要不同的类库，不同版本的包，则需要不同的虚拟环境做到分离
如果没有以上需要的话，只需要一份本地环境的话，先点击下图蓝色再选择对应的包

选择对应方式后选择右下方创建即可

如何安装第三方类库

搜索interpreter

当前工程只有两个库：pip、setuptools库

需要新加入时，点击加号，搜索关键词，再确定加入即可。

点击Install Package

添加成功后会加入示例中的pytest的相关依赖

Python基本操作

缩进与空格
见名知意

PEP8的编码规范，可以了解

变量

Python Connsole 进行指导

字符串

切片，从一个字符串中获取某一些部分

str_a="abcdefg";
print(str_a[1:]);//bcdefg

前闭后开原则

str_a="abcdefg";
print(str_a[1:2]);//b

1≤a＜2

str_a="abcdefg";
print(str_a[1:5:2]);//bd

star：stop：step

列表List

通过-1获取对应的列表值

var_list = [1,2,3,4,5, "a", "b", "c", True];
print(var_list[2::2]);//[3, 5, 'b', True]

字符串格式化符号

var_s = "abcdefg";
print("String is %s"%var_s);//String is abcdefg

符号类型列表

字面量插值

"str".format();

默认顺序放置
指定位置放置
变量赋值

demo = "hahaha is a {1} {0}"
demo_r = demo.format("joy","word");
print(demo_r);

demo = "hahaha is a {word}"
demo_r = demo.format(word="hello word");
print(demo_r);

3.6.5后 f{变量}

name_ = "name";
print(f"My {name_} is Lin");//My name is Lin

字符串常用API之join

a = ["a","p","p","l","e"];
print("/".join(a));//a/p/p/l/e

字符串常用API之split 数据切分

a = "hahhahhaha";
print(a.split("a"));//['h', 'hh', 'hh', 'h', '']

字符串常用API之replace 替代

var_s = "my name is ad";
print(var_s.replace("ad","广告"));//my name is 广告

Python运算符

算数运算符：加减乘除相同，%取余，**幂，//取整数，/将获得有小数的值
运算符
等于 a,b=1,2;
in,not in 返回true、false
==只管内容是否相等，不管地址是否相等；is为判断是否在同一地址当中：is，is not

ps:1. id(变量) 地址值 可变的数据结构，即使看着一样，但是内存地址是不同的，不可变的数据类型如果看着一样，那么他们的内存地址是相同的

Python控制流

分支判断

a="dev";
if a=="aaa":
    print("测试工程师");
elif a=="bbb":
    print("bbb");
else:
    print("ccc");

循环

range(开始数值，结束数值,[步长])

for i in range(0, 12, 3):
    print(i);

while

count = 0
while count<10:
    count = count+1
    print(count)

break; continue;

停止结束，任何判断循环都需要与break结合

必须与if判定结合使用

pass 占位符（不做特殊要求

常见数据结构

list

列表是动态的，是异构的（可以同时象），允许出现重复元素

列表方法
1. append()接受一个对象作为参数，添加在list的末尾，没有返回值void
2. extend()将一个可迭代对象（可以用for循环遍历值的+）的所有元素（字符串、元祖、集合、字典）加到列表末尾
3. insert()放入指定位置，（索引值，对象），void
4. pop()返回索引的指定元素，未指定则返回末尾元素，若索引不正确，或列表为空，则引发IndexError错误
5. remove()移除第一个等于item的元素，若目标元素不存在，则报ValueError
6. sort() 排序、字符串长度等排序，当进行长度的排序时需要使用key
7. reverse()

list = ['Python','Go','java','R']
list.sort(key=len)
print(list)//['R', 'Go', 'java', 'Python']
list.reverse()
print(list)//['Python', 'java', 'Go', 'R']

列表推导式

# 正常
result=[]
for i in range(1,11):
    if i % 2== 0:
        result.append(i ** 2)
print(result)//[4, 16, 36, 64, 100]


# 列表推导式
result2 = [i**2 for i in range(1,11) if i %2 == 0]
print(result2) #[4, 16, 36, 64, 100]

Tuple元组

元组是有序的不可变对象的集合
元组使用小括号包围，各个对象以括号分隔
元组是异构的

用赋值定义
用,分隔开进行定义
用tuple进行

t = tuple([1,2,3,4])
print(type(t),t) #<class 'tuple'> (1, 2, 3, 4)

tt = 1;
print(type(tt),tt) #输出<class 'int'> 1

ttt = 1,
print(type(ttt),ttt) #<class 'tuple'> (1,)

索引取值
切片
元组解包：把一个可迭代对象里的元素，一并赋值到由对应变量组成的元组中。

a,b,c = (1,2,3)
#a,b,c = [1,2,3]
print(a, b, c)//1 2 3

index()返回与目标元素相匹配的首个元素的索引，目标需要已存在
count()返回某个元素在元组出现的总次数

元组与列表

相同点：

都是有序的
都是异构的，能够包含不同类型的对象
都支持索引和切片

不同点：

声明方式不同，元组使用()，列表使用[]
列表是可变的，元组是不变的

set集合

唯一性，用大括号{}包围，对象相互之间使用逗号分隔
动态的，可以随时添加或删除元素
异构的

set1 = {1,2,3}
print(set1, type(set1)) #{1, 2, 3} <class 'set'>

set2 = set("abcdefg")
print(set2,type(set2)) #{'b', 'd', 'a', 'f', 'c', 'g', 'e'} <class 'set'>

in,not in
add()将单个元素加入
update()批量导入可迭代对象的所有元素
remove()时一定要确保元素存在，否则将进行报错
discard()从集合中移除指定对象item，元素不存在也没有关系，不会抛出KeyError错误
pop()随机从集合中移除并返回一个元素，如果集合为空则引发KeyError
clear()清空

set2 = set('abcdefg')
print(set2,type(set2))
set2.update([1, 2, 3])
print(set2,type(set2))

每次set2的输出结果都不一样

{'c', 'e', 'g', 'a', 'd', 'f', 'b'} <class 'set'>
{'c', 'e', 1, 2, 3, 'g', 'a', 'd', 'f', 'b'} <class 'set'>

运算：交并差

# 交集
set1 = {1,3,2}
set2 = {2,4,3}
print(set1.intersection(set2))
print(set1 & set2)
# 并集
print(set1.union(set2))
print(set1 | set2)
# 差集
print(set1.difference(set2))
print(set1 - set2)
print(set2.difference(set1))
print(set2 - set1)

集合推导式

实例：寻找hogwartess与hello world的相同字母

#普通方法
set1 = set()
for s in 'hogwartess':
    if s in 'hello world':
        set1.add(s)
print(set1)

#集合推导式方法
set2 = {s for s in 'hogwartess' if s in 'hello world'}
print(set2)

字典dict

另称为映射、哈希表等 & 通过键查找值

字典是无序的键值对集合 &
字典用{}包围
每个键、值对之间用一个逗号分隔
各个键与值之间用一个冒号分隔
字典是动态的

键通常为字符串or数值，为不可变类型

创建字典的三种方式:
- 使用大括号填充键值对
- 构造方法dict()
- 使用字典推导式 ``

"""字典使用：创建"""
# 1. 使用大括号填充键值对
dc1 = {"name": "Harry Potter", "age": 18}
print(type(dc1), dc1)
dc2 = {}
print(type(dc2), dc2)
# 2. 使用字典构造方法
dc3 = dict()
print(type(dc3), dc3)
dc4 = dict([("name", "Harry Potter"), ("age", 18)])
print(type(dc4), dc4)
# 3. 使用字典推导式（字典推导式的基础用法）
# 找出数据中的第一个和第二个 作为键和值
dc5 = {k: v for k, v in [("name", "Harry Potter"), ("age", 18)]}
print(type(dc5), dc5)

访问元素
- 用键访问其关联的值
- 已存在输出对应值，不存在报KeyError错误

dc1 = {"name": "Harry Potter", "age": 18}
print(dc1["name"])
print(dc1["name1"])
# Traceback (most recent call last):
#   File "D:\High\Python_software_ceshi\demo1.py", line 3, in <module>
#     print(dc1["name1"])
# KeyError: 'name1'
# Harry Potter

操作元素
- 添加元素 dict[key]=value 需要key不存在
- 修改元素 dict[key]=value key不存在

dc1 = {"name": "Harry Potter", "age": 18}
dc1["name"]="Hallo"
print(dc1)
# {'name': 'Hallo', 'age': 18}

嵌套字典（字典的值可以是字典对象）

dc1 = {"name": "Harry Potter", "age": 18, "course": {"magic": 90, "python": 80}}
print(dc1)
# {'name': 'Harry Potter', 'age': 18, 'course': {'magic': 90, 'python': 80}}
# 获取magic的值
print(dc1["course"]["magic"])
# 90
# 修改magic的值
dc1["course"]["magic"] = 100
print(dc1)
# {'name': 'Harry Potter', 'age': 18, 'course': {'magic': 100, 'python': 80}}

常用方法
1. keys() 获取所有的键返回由字典键组成的一个新视图对象
2. values() 获取所有的值
3. items() 获取所有成对的对象
4. get() 获取某个键的值 推荐，好处是无论该值是否存在，都不会报错
5. update() 更新字典用一个字典去更新另一个字典
6. pop(key) 删除指定key的键值对，并返回对应value值：如果key存在在字典汇总，则移除并返回value值；如果key不存在于字典中，则会引发KeyError。

dc1 = {"name": "Harry Potter", "age": 18, "course": {"magic": 90, "python": 80}}
print(dc1.keys())
print(dc1.values())
print(dc1.items())
# dict_keys(['name', 'age', 'course'])
# dict_values(['Harry Potter', 18, {'magic': 90, 'python': 80}])
# dict_items([('name', 'Harry Potter'), ('age', 18), ('course', {'magic': 90, 'python': 80})])
# 转成列表
print(list(dc1.keys()))
print(list(dc1.values()))
print(list(dc1.items()))
# ['name', 'age', 'course']
# ['Harry Potter', 18, {'magic': 90, 'python': 80}]
# [('name', 'Harry Potter'), ('age', 18), ('course', {'magic': 90, 'python': 80})]

get()

dc1 = {"name": "Harry Potter", "age": 18, "course": {"magic": 90, "python": 80}}
print(dc1.get("name"))
print(dc1.get("name1"))
# Harry Potter
# None

update()

dc1 = {"name": "Harry Potter", "age": 18}
date = {"age": 20, "course": {"magic": 90, "python": 80}}
dc1.update(date)
print(dc1)
# {'name': 'Harry Potter', 'age': 20, 'course': {'magic': 90, 'python': 80}}

pop(key)

dc1 = {"name": "Harry Potter", "age": 18, "course": {"magic": 90, "python": 80}}
print(dc1.pop("name"))
print(dc1.pop("name1"))
# Traceback (most recent call last):
#   File "D:\High\Python_software_ceshi\demo1.py", line 3, in <module>
#     print(dc1.pop("name1"))
# KeyError: 'name1'
# Harry Potter

字典推导式

字典推导式：可以从任何以键值对作为元素的可迭代对象中构造出字典实例: 给定一个字典对象{'a':1,'b':2,'c':3},找出其中所有大于1的键值对，同时value值进行平方运算。

# 未使用字典推导式
dc = {'a': 1, 'b': 2, 'c': 3}
dc_old = {}
for k, v in dc.items():
    if v > 1:
        dc_old[k] = v ** 2
print(dc_old)
# {'b': 4, 'c': 9}
# 使用字典推导式
dc_new = {k: v ** 2 for k, v in dc.items() if v > 1}
print(dc_new)
# {'b': 4, 'c': 9}

实例：给定一个字典对象，用字典推导式，将key和value互换

输入: {'a':1,'b':2,'c':3}
输出: {1:'a',2:'b',3:'c'}

# 未使用字典推导式
dc = {'a': 1, 'b': 2, 'c': 3}
dc_old = {}
for k, v in dc.items():
    dc_old[v] = k
print(dc_old)
# {1: 'a', 2: 'b', 3: 'c'}

# 使用字典推导式
dc_new = {v: k for k, v in dc.items()}
print(dc_new)
# {1: 'a', 2: 'b', 3: 'c'}

可变函数

*args

# *args 接收任意多个实际参数，并将其放到一个元组中
def print_language(*args):
    print(args)


print_language("java", "c", "c#", "c++")
# ('java', 'c', 'c#', 'c++')

# *args 接收任意多个实际参数，并将其放到一个元组中
def print_language(*args):
    print(args)
    # 每个参数拿出来
    for i in args:
        print(i)


print_language("java", "c", "c#", "c++")
# ('java', 'c', 'c#', 'c++')
# java
# c
# c#
# c++

*相当于一个解包的操作，在函数头相当于打包的操作

# *args 接收任意多个实际参数，并将其放到一个元组中
def print_language(*args):
    print(args)


lan = ["java", "c", "c#", "c++"]
print_language(lan)
# (['java', 'c', 'c#', 'c++'],)
# 解包 *lan
print_language(*lan)
# ('java', 'c', 'c#', 'c++')

**kwagrs

接收任意多个类似关键字参数一样显式赋值的实际参数，并将其放到一个字典中
使用已经存在字典作为函数的可变参数，可以在字典的名称前加**

def print_info(**kwargs):
    print(kwargs)


print_info(Tom=18, Lily=12)
print_info(Tom=18, Lily=12, Anna=16)
# {'Tom': 18, 'Lily': 12}
# {'Tom': 18, 'Lily': 12, 'Anna': 16}

**实现了打包的过程将key=value的形式打包成字典

def print_info(**kwargs):
    print(kwargs)


date = {
    "Tom": 18,
    "Lily": 12,
    "Jim": 20
}
print_info(**date)
# {'Tom': 18, 'Lily': 12, 'Jim': 20}

函数

标准函数

内置函数 — Python 3.11.1 文档

自定义函数

# 定义函数
def func_with_params(a, b, c):
    '''
    这是一个携带参数和注释的函数
    '''
    print(f"传入的参数为：a={a},b={b},c={c}")


# 打印函数 comments内容
print(func_with_params.__doc__)
help(func_with_params)


# 定义空函数
# 两种方式： 1. 加上pass语句 2. 加上comments语句
def filter_char(s):
    '''
    功能：过滤敏感词
    '''
    # pass

调用 & 形参为函数内实参为调用的函数体内传值

# 定义函数
def func_with_params(a, b, c):
    '''
    这是一个携带参数和注释的函数
    '''
    print(f"传入的参数为：a={a},b={b},c={c}")


func_with_params(1, 2, 3)

缩进的两种方法

ctrl+alt+L
四个空格

传参：位置传参 & 关键词传参

def func_with_params(a, b, c):
    print(f"传入的参数为：a={a},b={b},c={c}")


func_with_params(b=1, a=2, c=3)

默认参数:只能放在最后面 & 一定为不可变对象

可变对象的话将随着运行改变

def func_with_params(a, b, c=3):
    print(f"传入的参数为：a={a},b={b},c={c}")


func_with_params(b=1, a=2)

返回值

当返回多值时将返回包含多值的元组，若没有返回值则返回None

传入多值

def func_with_params(a, b, c=3):
    print(f"传入的参数为：a={a},b={b},c={c}")
    return a,b,c


result = func_with_params(b=1, a=2)
print(result);
# 传入的参数为：a=2,b=1,c=3
# (2, 1, 3)

2. 没有返回值

def func_with_params(a, b, c=3):
    print(f"传入的参数为：a={a},b={b},c={c}")


result = func_with_params(b=1, a=2)
print(result);
# 传入的参数为：a=2,b=1,c=3
# None

匿名函数

定义

没有名字的函数
用lambda表达式创建匿名函数

使用场景

需要一个函数，不想费神去命名这个函数
该函数只使用因此
可以指定短小的回调函数

例子

不可以省略前面的变量

import math


# 常规写法
def circle_area(r):
    '''
    计算圆面积
    :param r: 半径
    :return:
    '''
    result = math.pi * r * r
    return result


r = 10
print(f"半径为{r}的元的面积为{circle_area(r)}")
# 半径为10的元的面积为314.1592653589793
# 用lambda表达式实现
result = lambda r: math.pi * r * r
print(f"半径为{r}的元的面积为{result(r)}")
# 半径为10的元的面积为314.1592653589793
# 错误写法
print(lambda r: math.pi * r * r)
# <function <lambda> at 0x000002B2BC7BF910>

指定短小的回调函数例子

# 指定短小的回调函数
# 书籍信息
book_info = [    ("python 零基础入门", 22.5),    ("java 零基础入门", 20),    ("软件测试", 25)]
print(book_info)
# [('python 零基础入门', 22.5), ('java 零基础入门', 20), ('软件测试', 25)]
# 指定规则排序
# lambda x:(x[1]) 返回了列表中每个元组的第二个元素
book_info.sort(key=lambda x: (x[1]))
print(book_info)
# [('java 零基础入门', 20), ('python 零基础入门', 22.5), ('软件测试', 25)]

封装

封装：属性和实现细节，不允许外部直接访问
暴露：公开方式，实现对内部信息的操作和访问

class A:
    # 普通属性
    a = "A"
    # 内部属性(保护属性
    _b = "AB"
    # 私有属性
    __c = "ABC"


print(A.a)  # A
print(A._b)  # AB
print(A.__c)  # AttributeError: type object 'A' has no attribute '__c'

_b，__c不建议被查看

__c属于私有属性，系统默认成为_A__c

class A:
    # 普通属性
    a = "A"
    # 内部属性
    _b = "AB"
    # 私有属性
    __c = "ABC"

    @property
    def c(self):
        return self.__c

    @c.setter
    def c(self, value):
        # 进行修改、校验
        if len(value) == 3:
            self.__c = value
        else:
            print("c需要三位字母！")


# 实例化对象
obj = A()

# 访问私有属性
print(obj.c)
# ABC

# 修改值
# 合法 三位
obj.c = "aaa"
print(obj.c)
# aaa
# 不合法 四位
obj.c = "aaaa"
print(obj.c)
# c需要三位字母！
# aaa

继承

复用父类的公开属性和方法
拓展出新的属性和方法

python支持多继承

class Human:
    message = "这是Human类的属性"

    # 构造方法
    def __init__(self, name, age):
        self.name = name
        self.age = age

    # 实例方法
    def live(self):
        print("住在地球上")


class Student(Human):
    def study(self):
        print("正在学习")


# 实例化子类对象
stu = Student("哈利波特", 12)
# 这是Human类的属性
# 访问属性
print(stu.message)

print(stu.name, stu.age)
# 哈利波特 12

stu.live()
# 住在地球上
stu.study()
# 正在学习

类型检查

isinstance(实例，类名) 检查对象是否是某个类及其派生类的实例
issubclass(类名1，类名2) 类1是否是类2的子类

class Human:
    pass

class Student(Human):
    pass

class Teacher(Human):
    pass

# 实例化子类对象
stu = Student()
print(isinstance(stu, Human))
print(isinstance(stu, Teacher))
print(issubclass(Student, Human))
print(issubclass(Teacher, Human))
# True
# False
# True
# True

多态

同名调用产生不同的行为

class China:
    def speak(self):
        print("汉语")


class Usa:
    def speak(self):
        print("英语")


c = China()
u = Usa()

for x in (c, u):
    x.speak()

super

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

    def live(self):
        print("住在地球上")


class Student(Person):
    def __init__(self, name, age, school):
        # super().__init__(name, age)
        # super(Student, self).__init__(name, age)
        # Person.__init__(self, name, age)
        self.school = school

    def live(self):
        print(f"住在{self.school}的{self.age}岁的{self.name}")


stu = Student("哈利波特", 12, "Hogwart")

stu.live()
# 住在Hogwart的12岁的哈利波特

三种构造覆盖写法

Python模块

模块（eg. .py || 脚本）

系统内置模块（sys,os,time,json等）直接import
第三方开源模块通过包管理工具pip install安装PyYAML

import yaml

自定义模块

新建demo1的py文件和main的py文件
demo1.py

a = "这是一件好事"


def search():
    print("这是一个搜索方法")


class DemoTest:
    pass

3. main.py

from demo1 import search
from demo1 import a
from demo1 import DemoTest

search()

print(a)

DemoTest()
# 这是一个搜索方法
# 这是一件好事

等价于

from demo1 import *

search()

print(a)

DemoTest()

常用方法

# 当前模块可以调用的变量，方法
print(dir())
# ['DemoTest', '__annotations__', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', 'a', 'search', 'sys']

# 参数模块定义的对象
print(dir(sys))
# ['__breakpointhook__', '__displayhook__', '__doc__', '__excepthook__', '__interactivehook__', '__loader__', '__name__', '__package__', '__spec__', '__stderr__', '__stdin__', '__stdout__', '__unraisablehook__', '_base_executable', '_clear_type_cache', '_current_exceptions', '_current_frames', '_deactivate_opcache', '_debugmallocstats', '_enablelegacywindowsfsencoding', '_framework', '_getframe', '_git', '_home', '_xoptions', 'addaudithook', 'api_version', 'argv', 'audit', 'base_exec_prefix', 'base_prefix', 'breakpointhook', 'builtin_module_names', 'byteorder', 'call_tracing', 'copyright', 'displayhook', 'dllhandle', 'dont_write_bytecode', 'exc_info', 'excepthook', 'exec_prefix', 'executable', 'exit', 'flags', 'float_info', 'float_repr_style', 'get_asyncgen_hooks', 'get_coroutine_origin_tracking_depth', 'get_int_max_str_digits', 'getallocatedblocks', 'getdefaultencoding', 'getfilesystemencodeerrors', 'getfilesystemencoding', 'getprofile', 'getrecursionlimit', 'getrefcount', 'getsizeof', 'getswitchinterval', 'gettrace', 'getwindowsversion', 'hash_info', 'hexversion', 'implementation', 'int_info', 'intern', 'is_finalizing', 'maxsize', 'maxunicode', 'meta_path', 'modules', 'orig_argv', 'path', 'path_hooks', 'path_importer_cache', 'platform', 'platlibdir', 'prefix', 'pycache_prefix', 'set_asyncgen_hooks', 'set_coroutine_origin_tracking_depth', 'set_int_max_str_digits', 'setprofile', 'setrecursionlimit', 'setswitchinterval', 'settrace', 'stderr', 'stdin', 'stdlib_module_names', 'stdout', 'thread_info', 'unraisablehook', 'version', 'version_info', 'warnoptions', 'winver']

# 查找的路径顺序 如果路径下都没有后将报错
print(sys.path)
# ['D:\High\Python_software_ceshi', 'D:\High\Python_software_ceshi', 'C:\Users\21631\AppData\Local\Programs\Python\Python310\python310.zip', 'C:\Users\21631\AppData\Local\Programs\Python\Python310\DLLs', 'C:\Users\21631\AppData\Local\Programs\Python\Python310\lib', 'C:\Users\21631\AppData\Local\Programs\Python\Python310', 'C:\Users\21631\AppData\Local\Programs\Python\Python310\lib\site-packages']

错误与异常

错误

语法错误
逻辑错误
系统错误：内存泄露等引起的

异常

程序执行中出现的错误，可以被捕获和处理：除零错误

def div(param, param1):
    return param/param1


try:
    print(div(1, 0))
    print("1")
except Exception as e:
    print(e)
    print("异常！")

else:
    print("没有异常！")
finally:
    print("finally")
    
# division by zero
# 异常！
# finally

def age(num):
    if num <= 0 or num > 100:
        raise ValueError(f"值错误:{num}")
    else:
        print(f"设置的年龄为:{num}")

age(-1)

自定义异常

class MyError(Exception):
    def __init__(self, msg):
        print(f"这是一个异常:{msg}")


def age(num):
    if num <= 0 or num > 100:
        raise MyError(f"值错误:{num}")
    else:
        print(f"设置的年龄为:{num}")


age(-1)

程序调试

import logging


def a(aa):
    if aa == 1:
        logging.info("a == 1")
    else:
        logging.info("a != 1")


a(1)

两个标记点

上图六个带蓝图标

选中变量
下一步，不涉及进入函数的操作
进入函数内部，没有则继续下一步
跳到自己编码的位置，如果处于底层中，则跳出，跳到自己编写代码的下一行代码中
一层一层跳出函数
跳到下一个标记点的位置

左边是栈模式模拟的方法，跳入方法后会新方法名字加入，也代表该名字先出

OS

os：Operating System
os模块的常用功能
跨平台的差异

os的使用

导入os模块
查看os模块使用文档
- help(os)
- dir(os)

import os

# 查看帮助模块
help(os)

# 查看os模块的属性和常用方法
print(dir(os))

os常用方法

import os

# 获取系统名称 nt代表window posix代表linux
print(os.name)

# 获取系统环境变量信息
print(os.environ)

# 获取指定名称的环境变量信息
print(os.getenv('PATH'))

# 执行系统指令
os.system('pwd')  # linux系统
print(os.system('dir'))  # windows系统

目录文件的增删改查

import os

# 获取当前目录
print(os.getcwd())

# 切换目录
os.chdir('..')

# 列出当前目录内容
print(os.listdir())

# 创建空目录
os.mkdir('new')

# 递归创建多级目录
os.makedirs('a/b/c')

# 删除空目录
os.rmdir('new')

# 重命名目录
os.rename('a', 'a1')

# 删除文件
os.remove('demo.txt')

# 删除空目录
os.rmdir('a/b/c')
# 仅删除最底层的c空文件夹，若非空文件夹则会报错，若最底层非文件夹也会报错
# 删除某一个文件仅可使用remove

os路径相关

os.path --- 常用路径操作_os.path如何修改路径 os.path的路径为该项目根目录路径加上输入的目标路径

sys

Python自带的内置木块
与Python解释器交互的桥梁

import sys

print(help(sys))

print(dir(sys))

常用属性

import sys

# 版本解释器
print(sys.version)

# 操作系统平台名称
print(sys.platform)

# 返回外部向程序传递的参数
# 
print(sys.argv) 

# 返回已导入的模块信息
print(sys.modules)
print(sys.modules.keys())

# 返回导包的搜索路径列表
print(sys.path)

常用方法

"""sys模块常用方法"""
import sys

# 获取系统当前编码
print(sys.getdefaultencoding())
# utf-8 常见均为utf-8

# 运行时退出 0为正常终止，非0为异常终止
sys.exit()
# sys.exit(0)
# sys.exit("error")
# error

导入sys

# 添加自定义路径到导包路径列表中
import sys
import os.path

# 添加该项目hello文件夹到查找路径中 非永久的
my_dir = os.path.dirname(os.path.abspath(__file__)) + "/hello"
sys.path.append(my_dir)
print(sys.path)

添加成功！

文件处理

python-文件方法（读写）

# 第一个file必写；buffering缓冲区，默认-1；编码；errors当遇到错误是是抛出还是其他操作；换行符\r or \n or \r\n; 文件描述符
def open(file, mode='r', buffering=None, encoding=None, errors=None, newline=None, closefd=True):

换行、空格算一个字符

read返回String、readLine返回List

f.seek(0) 光标回到开始位置

注意忘记关闭文件：

文件打开一定数量会导致打开失败
占用内存空间，浪费资源
导致系统自动回收资源，导致文件内容丢失

# 推荐操作：with 简洁、自动将关闭动作完成
with open('data.txt', 'r', encoding='utf-8') as f:
    print(f.read())

print(f.closed)

输出了data.txt的内容并输出True标识

w+ 新建文件或在已存在文件，清空内容加入
r+ 替换，替换原本内容，之后的内容会保留
a+ 追加内容

使用with方法，自动完成关闭操作
通过python封装的API，可以实现读，写，追加操作
文件打开要使用utf-8格式，防止中文乱码

软件测试 Python相关

Python安装及配置

PyCharm下载及配置

如何安装第三方类库

Python基本操作

变量

字符串

列表List

字面量插值

"str".format();

3.6.5后 f{变量}

字符串常用API之join

字符串常用API之split 数据切分

字符串常用API之replace 替代

Python运算符

Python控制流

分支判断

循环

range(开始数值，结束数值,[步长])

while

break; continue;

pass 占位符（不做特殊要求

常见数据结构

list

列表推导式

Tuple元组

元组与列表

set集合

运算：交并差

集合推导式

字典dict

字典推导式

可变函数

*args

**kwagrs

函数

标准函数

自定义函数

缩进的两种方法

传参：位置传参 & 关键词传参

默认参数:只能放在最后面 & 一定为不可变对象

返回值

匿名函数

定义

使用场景

例子

指定短小的回调函数例子

封装

继承

类型检查

多态

同名调用产生不同的行为

super

三种构造覆盖写法

Python模块

模块 （eg. .py || 脚本）

常用方法

错误与异常

错误

异常

自定义异常

程序调试

OS

os的使用

os常用方法

目录文件的增删改查

os路径相关

sys

常用属性

常用方法

导入sys

文件处理

模块（eg. .py || 脚本）