python基础一

1.python语句

2.数据类型

2-1:数字型

整型 (int)
浮点型（float）
布尔型（bool）：真 True，假 False

复数型 (complex)

主要用于科学计算，例如：平面场问题、波动问题、电感电容等问题

2-2:非数字型

字符串

1.概念：字符串 就是 一串字符，是编程语言中表示文本的数据类型
在 Python 中可以使用 一对双引号 " 或者 一对单引号 ’ 定义一个字符串
可以使用 索引 获取一个字符串中 指定位置的字符，索引计数从 0 开始
也可以使用 for 循环遍历 字符串中每一个字符
（双引号的作用，跟单引号的区别：
a='I’am zhangyy ’ 报错
a=“I’am zhangyy” #没问题 ）
2.转义字符()
#\'单引号
#\"双引号
#\t制表符 4个空格）
#\n换行符
#\\ 插入倒斜杠\
3.字符串操作
3-1.查找
字符串.find(目标字符串, 开始索引, 结束索引) 在指定范围内, 查询目标字符串的索引, 不存在返回-1
字符串.rfind(目标字符串, 开始索引, 结束索引) 在指定范围内, 查询目标字符串的索引, 不存在返回-1, 从结尾处开始查找
字符串.index(目标字符串, 开始索引, 结束索引) 在指定范围内, 查询目标字符串的索引, 不存在会报错
3-2.替换
字符串.replace(原内容, 新内容, 替换次数) 返回一个替换了原内容的新字符串，可以指定替换次数
3-3.分割
字符串.split(分割符) 以分割符拆分字符串, 返回列表
字符串.partition(分割符) 返回元组，把字符串分成一个 3 元素的元组 (分割符前面, 分割符, 分割符后面)
3-4.拼接
1.字符串.join(字符串列表) 以字符串来连接字符串列表中每个元素，合并为一个新的字符串。案例：
str1 = “,”
name_list = [“beijing”, “shenzhen”, “shanghai”, “guangzhou”]
#以字符串为连接符拼接字符串列表的元素,生成新的字符串
str2 = str1.join(name_list)
print(str2) # “beijing,shenzhen,shanghai,guangzhou”
2.拼接两个字符串 ： 字符串 + 字符串
3-5.大小写
字符串.upper（） 全部大写
字符串.lower() 返回新字符串，转换 字符串 中所有大写字符为小写
字符串.title() 首字母大写 istitle是判断仅首字母是否大写
3-6.判断

# if str1.isalpha():
#     print("都是字母")
# if str1.isdecimal():
#     print("都是数字")
# if str1.isupper():
#     print("字母都是大写")
# if str1.islower():
#     print("字母都是小写")
# if str1.startswith("he"):
#     print("以指定内容开头")
# if str1.endswith("66"):
#     print("以指定内容结尾")
真就返回true

3-7.文本对齐
字符串.center（） 居中对齐
str1 = “hello”
#设置左对齐
str2 = str1.ljust(11, “-”)
print(str2) # hello------
str1 = “hello”
#设置右对齐
str2 = str1.rjust(11, “-”)
print(str2) # ------hello
3-8.去字符（和文本对齐相反）
字符串.strip(目标字符串)
字符串.lstrip(目标字符串)
字符串.rstrip(目标字符串)
4.切片

num_str = "0123456789"
#1. 截取从 2 ~ 5 位置 的字符串
print(num_str[2:6])
#2. 截取从 2 ~ `末尾` 的字符串
print(num_str[2:])
#6. 字符串的逆序
print(num_str[::-1])
#7. 字符串的后两位
print(num_str[9:7:-1])

列表

列表操作
1.增加元素操作

list.append(值)；在末尾追加值
list.insert(索引，值)；在指定位置插入值, 超过索引会追加值
list.extend(可迭代对象)；可以理解为列表相加，将可迭代对象中的元素追加到列表： 例如：     list1.extend(list2)

2.删除元素操作

list.remove(值) ;删除指定值的 第一个匹配项
del list[索引]  ;删除指定位置的值
list.pop(索引)  ;删除指定索引的值, 并返回被删除的值
list.clear()   ;清空列表

实操案例：取出列表中的偶数

a = [1, 2, 4, 6, 3, 4, 8, 5]
#方法一
a =[i for i in a if i % 2 != 0]
print(a)
#方法二：
for i in a[:]:
    if i %2 ==0:
        a.remove(i)
print(a)

错误代码:该方法会落掉一些元素

a = [1, 2, 4, 6, 3, 4, 8, 5]
for i in a :
    if i%2==0:
        a.remove(i)
print(a)

3.修改元素操作

list[索引]=值  ；修改指定索引的值，索引不存在会报错
Tuple（元组）与列表类似，不同之处在于元组的 元素不能修改

4.查看元素操作

list[索引]  ；根据索引取值，索引不存在会报错
len（list） ；列表长度(元素个数)
if 值 in list :   ;判断列表中是否包含某个值
list.index(值)  ；根据值查询索引，返回 第一个匹配项 的索引，没有查到会报错
list.count(值)  ；查询值在列表中出现的次数

5.复制列表

a=[1,2]
b=a   #直接等于那么b直接引用a的地址
v=a.copy()   #复制a并储存在新的地址
print(id(a)) #36492744
print(id(b)) #36492744
print(id(v)) #42406984

6.列表的排序

list.sort()   ;排序（升序） 
list.sort(reverse=True)   ；降序
list.reverse()   ;  逆序，反序排序

排序实操：

names=['page_001_table_002','page_001_table_001', 'page_002_table_002','page_002_table_001', 'page_003_table_001', 'page_004_table_001']
names.sort(key=lambda x: (int(x.split("_")[1]), int(x.split("_")[-1])))
print(names)

7.列表嵌套（和矩阵类似）
转置计算：

A=np.mat(label_list)
    print(A.T)
    # B=zip(label_list)
    print((zip(*label_list)))
    print(list(zip(*label_list)))
    # label_list=label_list[::-1]
    # print(label_list)
    #列表表达式
    C=[[label_list[j][i] for j in range(len(label_list))] for i in range(len(label_list[0]))]
    print("C",C)
    print("label_list",label_list)
    b=[]
    for i in range(len(label_list[0])):
        a=[]
        for j in range(i,len(label_list)):
            a.append(label_list[j][i])
        b.append(a)
    print("b",b)
    print(label_list)

元组

元组（tuple=(1,2,3 )）元素不能修改，所以只有查询和列表差不多
操作使用：
1.元组没有排序；要转化为列表在排序；list（元组）=列表形式在排序
Tuple（元组）与列表类似，不同之处在于元组的 元素不能修改
2.元组[索引] 根据索引取值，索引不存在会报错
3.len(元组) 元组长度(元素个数)
4.if 值 in 元组: 判断元组中是否包含某个值
5.元组.index(值) 根据值查询索引，返回 第一个匹配项 的索引，没有查到会报错
6.元组.count(值) 值在元组中出现的次数

字典：{key:value}

1.值 ：可以取任何数据类型，但 键 只能使用 字符串、数字或 元组
键 ：必须是唯一的
2.字典操作
增添：字典[键] = 值 键不存在，会添加键值对
删除：
1.字典.pop(键) 删除指定键值对,返回被删除的值,如果键不存在,会报错
2.del 字典[键] 根据键删除键值对
3.字典.clear() 清空字典
修改：
1.字典[键] = 值 键存在，会修改键值对的值
2.字典.setdefault(键，数据) 键值对不存在，添加键值对；存在则不做处理
3.字典.update(字典2) 取出字典2的键值对对字典1操作，键值对不存在，添加键值对；存在则修改值
查询：
1.字典[键] 根据键取值，键值对不存在会报错
2.字典.get(键) 根据键取值，键值对不存在返回None, 不会报错
3.for key in 字典： 遍历字典, 获取所有的键
4.for key in 字典.keys() 遍历字典, 获取所有的键
5.for value in 字典.values() 遍历字典, 获取所有的值
6.for item in 字典.items() 遍历字典, 获取所有的键值对 (键, 值)
7.for k，v in 字典.items（）：
实操案例：使用字典计数

a = [1, 2, 4, 6, 3, 4, 8, 5]
a_dict={}
for i in a :
    if i in a_dict.keys():
        a_dict[i]+=1
    else:
        a_dict[i]=1
print(a_dict)   
#{1: 1, 2: 1, 4: 2, 6: 1, 3: 1, 8: 1, 5: 1}

无序集合

1.集合的作用：具有唯一性，不会有重复的
例如：list中的元素去重复的功能
2.两个特点:去重 无序

3.函数

01函数参数详解

01位置实参

def func(num1, num2):
   print("num1: %d" % num1)
   print("num2: %d" % num2)
func(1, 2)  # num1: 1  num2: 2

2 关键字实参

def func(num1, num2):
   print("num1: %d" % num1)
   print("num2: %d" % num2)
func(num2=1, num1=2)  # num1: 2  num2: 1

3 默认形参

def func(num1, num2=10):  # 默认形参必须在普通形参的后边
    print(num1)
    print(num2)
func(1, 2)  # 默认形参如果设置对应的实参, 就使用实参
func(1)  # 默认形参没有设置对应的实参, 就使用默认值

4 可变形参
元组型可变形参
函数可以定义 可变形参，用于接收任意数量的位置实参
可变形参的前边需要添加*，用于提示python解释器该参数为可变形参
使用可变形参直接用args即可（不需要加*）
可变形参的本质是 将传递的参数包装成了元组

def func_sum(*args):
    result = 0  
    for num in args:
        result += num
    print(result)
func_sum(1, 2, 3)
func_sum(1, 2, 3, 4)

字典型可变形参
可变形参还有一种形式 可以接收任意数量的关键字实参
定义参数时需要在形参名前添加**
这种可变形参会将 关键字参数包装成字典

def print_info(name, **kwargs):  
    # 存在形参name, name不会被包装到字典中
    print(name)  # zhangsan
    print(kwargs)  # {"age": 20, "height": 1.75}
print_info(name="zhangsan", age=20, height=1.75)

4.文件操作

1. 读取关闭文件

1.读取关闭文件

 # 新建一个文件，文件名为:123.txt
    f = open('123.txt', 'w')
    # 关闭这个文件
    f.close()

1-1.读取asni文件报错，此时忽略编码格式错误，即可打开文件

file_name=r"C:\Users\yyz\actionstatus_ctrl"
f = open(file_name,encoding='utf-8',mode='r',errors='ignore')
conte=f.read()
print(conte)

2.自动关闭文件

with open("123.txt", "w") as f:
    pass  # 执行完缩进代码, 会自动关闭文件

访问模式 说明
r 只用于读取, 默认模式。文件不存在,会报错。
w 只用于写入。文件存在则先清空内容, 文件不存在，创建新文件。
a 只用于写入。文件存在则追加内容, 文件不存在，创建新文件。
r+ 用于读写。文件不存在,会报错。
w+ 用于读写。文件存在则先清空内容, 文件不存在，创建新文件。
a+ 用于读写。文件存在则追加内容, 文件不存在，创建新文件。
rb 二进制格式的只读操作。
wb 二进制格式的只写操作。
ab 二进制格式的追加操作。
3.读取json文件

with open(file_name, 'r', encoding='utf-8') as load_json:
     root = json.load(load_json, encoding='utf-8')

4.保存json文件

    with open(save_files, 'w',encoding="utf-8") as f:
        json.dump(text, f, ensure_ascii=False)

2.文件的读写

1. 写数据(write)
   使用write()可以完成向文件写入数据

#打开文件  w write 写入   r  read 读取
f = open("123.txt", "w")
2.写入数据
f.write("hello world")
#关闭文件  
f.close()

2. 读数据(read)
   read(n) n为读取的字符数, 不设置则全部读取

with open("123.txt", "r") as f:
    content = f.read()

3. 读数据（readlines）
   readlines() 一次全部读出, 返回列表 (每行内容是一个元素)

with open("123.txt", "r") as f:
    content = f.readlines()
    print(content)

4. 读数据（readline）
   readline() 每次读取一行数据

with open("123.txt", "r") as f:
    content = f.readline()
    print(content, end="")

3.os相关操作

os.mkdir(“张三”) #可在当前路径下新建文件夹
os.rmdir(“张三”) #删除当前路径下的(空文件夹)
os.rename(“毕业论文.txt”,“毕业论文—最终版.txt”) #修改文件名
os.remove(“毕业论文—最终版.txt”) #删除的文件
print（ os.getcwd()） #获取当前目录路径
#修改当前路径
os.chdir(“张三”) #修改当前路径的张三的子目录下
#修改路径之后后续操作在修改后的路径操作。
os.listdir() #在os.chdir(“张三”)获取张三目录的列表
os.makedirs(img_path,exist_ok=True) #自动创建文件夹，存在就不会创建
###os.path操作
1.路径拼接

os.path.join(save_path,os.path.splitext(img_name)[0]+".json")

2.分割文件路径获取文件名

file_path=r"C:\Users\Administrator\Desktop\ocr_easy\static\想对你说的话.html"
print(os.path.split(file_path))

(‘C:\Users\Administrator\Desktop\ocr_easy\static’, ‘想对你说的话.html’)、
3.分割文件名称

file="想对你说.的话.html"
print(os.path.splitext(file))

(‘想对你说.的话’, ‘.html’)
os.path.abspath(path) 返回绝对路径
os.path.basename(path) 返回文件名
os.path.commonprefix(list) 返回list(多个路径)中，所有path共有的最长的路径
os.path.dirname(path) 返回文件路径
os.path.exists(path) 如果路径 path 存在，返回 True；如果路径 path 不存在，返回 False。
os.path.isabs(path) 判断是否为绝对路径
os.path.isfile(path) 判断路径是否为文件
os.path.isdir(path) 判断路径是否为目录
os.path.islink(path) 判断路径是否为链接
os.path.ismount(path) 判断路径是否为挂载点
4.os.path.walk遍历文件夹