我的【python基础】笔记

Python代码规范( PEP 8 版本 )

• 缩进采用4个空格
• 行长一般不超过72字符
• 注意空行

输入输出

print()    # 输出括号内容

• print默认end=‘\n’
• print支持格式化输出

print("%d" % n)    # 与C语言格式化输出类似，但使用%

print(f"{变量名}")

print("{}".format(值))

input()    # 输入，参数为提示

• input默认为字符串格式
• 若希望使用空格来连续输出，可以使用split()方法，然后取下标分别获取空格前后的内容

s = input().split()
A = int(s[0])
B = int(s[1])
C = int(s[2])
score = A * 0.2 + B * 0.3 + C * 0.5
print("%d" % score)

变量

命名规则

• 只包含字母、数字、下划线

• 不能有空格，首字母不能是数字

• 不能使用函数名或关键字

建议

简短具有描述性

少用小写i或大写O

命名空间

变量存储的位置，每一个变量都存储在命名空间中

locals()    # 返回当前命名空间

x = 1
print(locals())    # 返回全局命名空间

变量相关函数

函数名(变量名)

type()    # 获取变量类型
id()    # 获取内存地址
ord()    # 获取该字符的ASCII码
chr()    # 获取该整数对应的字符

数字

• 整数 int
• 浮点数 float

abs()    # 取绝对值

布尔

只有True 和 False两个值

作用域

指变量的生效区域

• 全局作用域：所有函数以外的位置
• 函数作用域：函数内的位置
  • 函数调用时创建，调用一次创建一次作用域

变量的查找规则变量访问从所在作用域开始寻找，一层层向外扩展

global x    # 声明后x为全局变量
nonlocal x    # 声明后x为函数变量，用在嵌套函数中，修改上一层函数

运算符

算术运算符

运算符	说明	实例	结果
+	加	12.45 + 15	27.45
-	减	4.56 - 0.26	4.3
*	乘	5 * 3.6	18.0
/	除法（和数学中的规则一样）	7 / 2	3.5
//	整除（向下取整）	7 // 2	3
%	取余，即返回除法的余数	7 % 2	1
**	幂运算/次方运算，即返回 x 的 y 次方	2 ** 4	16，即 24

1. / 的 结果一定是浮点数
2. // 保留整数部分
3. 如果运算中有小数参与，最后的结果一定小数

逻辑运算符

逻辑运算符	含义	基本格式	说明
and	逻辑与运算，等价于数学中的“且”	a and b	当 a 和 b 两个表达式都为真时，a and b 的结果才为真，否则为假。
or	逻辑或运算，等价于数学中的“或”	a or b	当 a 和 b 两个表达式都为假时，a or b 的结果才是假，否则为真。
not	逻辑非运算，等价于数学中的“非”	not a	如果 a 为真，那么 not a 的结果为假；如果 a 为假，那么 not a 的结果为真。相当于对 a 取反。

优先级为：not > and > or

比较运算符

比较运算符	说明
>	大于，如果>前面的值大于后面的值，则返回 True，否则返回 False。
<	小于，如果<前面的值小于后面的值，则返回 True，否则返回 False。
==	等于，如果==两边的值相等，则返回 True，否则返回 False。
>=	大于等于（等价于数学中的 ≥），如果>=前面的值大于或者等于后面的值，则返回 True，否则返回 False。
<=	小于等于（等价于数学中的 ≤），如果<=前面的值小于或者等于后面的值，则返回 True，否则返回 False。
!=	不等于（等价于数学中的 ≠），如果!=两边的值不相等，则返回 True，否则返回 False。

身份运算符

运算符	描述	实例
is	is 是判断两个标识符是不是引用自一个对象	x is y, 类似 id(x) == id(y) , 如果引用的是同一个对象则返回 True，否则返回 False
is not	is not 是判断两个标识符是不是引用自不同对象	x is not y ， 类似 id(a) != id(b)。如果引用的不是同一个对象则返回结果 True，否则返回 False。

身份运算符用来比较 两个对象的存储单元(地址)

成员运算符

运算符	描述	实例
in	如果在指定的序列中找到值返回 True，否则返回 False。	x 在 y 序列中 , 如果 x 在 y 序列中返回 True。
not in	如果在指定的序列中没有找到值返回 True，否则返回 False。	x 不在 y 序列中 , 如果 x 不在 y 序列中返回 True。

三目运算符

a if a > b else b    # 如果a>b成立,结果为a，不成立结果为b

运算符优先级

运算符说明	Python运算符	优先级	结合性
小括号	( )	19	无
乘方	**	16	右
符号运算符	+（正号）、-（负号）	14	右
乘除	*、/、//、%	13	左
加减	+、-	12	左
比较运算符	==、!=、>、>=、<、<=	7	左
is 运算符	is、is not	6	左
逻辑非	not	4	右
逻辑与	and	3	左
逻辑或	or	2	左

序列

序列方法函数一般情况下可通用

序列类型可以解包赋值

• 序列遍历方式

  # 第一种 变量名存储数字，用下标取元素  可以拿下标
  for 变量名 in range(len(序列名)):
  	print(序列名[变量名])
  
  # 第二种 注意直接是变量名 编写简单速度快
  for 变量名 in 序列名:
  	print(变量名)
  	
  

字符串

使用‘ “ ‘’‘括起来的内容，其中’''可跨行

字符串是一种序列，序列包括字符串、列表、元组

f字符串

f是format（格式）的简写，实现在字符串中插入变量的值，类似C语言中的格式化输入输出方法

语法：

f"{变量名1}{变量名2}..."

示例:

first_name = 'han'
last_name = 'chuanwang'
full_name = f"{first_name} {last_name}"
print(full_name)

r字符串

原始字符串，

r" "    # 使转义字符失效

字符串相关常用方法

字符串名.方法名(参数)

字符串不可被改变

.title()    # 首字母大写 以空格为划分

.upper()    # 大写

.lower()    # 小写

.strip()    # 清楚两侧空白

.lstrip()    # 清除左侧空白

.rstrip()    # 清除右侧空白

.split()    # 通过指定分隔符对字符串进行切片，默认为空格，转换为列表形式，不改变原值

.(r)find(s, start=0,end=len(str))    # 指定一个范围去查找子串s并返回下标(第一次出现子串s的下标)，若查找失败返回-1,start默认为0，end默认字符串长度,加r反向查找

.index(s, start=0,end=len(str))    # 与find基本一致，但如果查找失败直接报错 

.count(s)    # 返回子串s的个数

.replace(old, new, max)    # old要替换的子串，new新的子串，max替换次数默认为所有

.'指定字符'.join()    # 与split相反，通过指定符号连接，转换为字符串格式

.isdigit()    # 判断是否是数字

字符串相关常用函数

转义字符

• \n 换行

• \t 制表符

• \ 转义用

列表

由一系列按特定顺序排列的元素组成，用[]来表示，并用“,”来分割其中的元素，可以同时存储不同数据类型

列表是序列

• 创建列表：

numbers = [1, 2, 3, 4, 5]
numbers = [value for value in range(1,6)]    # 列表生成式
numbers = list(range(1,6))    # 强制类型转换

列表相关常用方法：

列表是可变类型

.append(元素)    # 将新元素添加到列表list末尾

.insert(索引,元素)    # 将新元素插入到列表list对应的索引位置，默认元素后移

.pop(索引)    # 弹出（删除）索引对应的列表中的元素，不加索引默认弹出最后一个元素。可以用一个变量存储被弹出的元素

.remove(元素)    # 删除列表中的出现的第一个与元素一致的元素，不存在会报错

.sort()   # 按字母顺序排列列表内容，会更改列表数据

.reverse()   # 反转列表的元素排列，会改变原来序列内容

.clear()    # 清空列表，会更改原来内容

# 注意：将reverse = True 作为参数传入方法中将实现与原方法排序相反的（倒序）的效果

列表相关常用函数：

sorted(序列名, key=func)    # 临时改变列表的顺序，不会更改原始列表内容,可以使用函数进行选择排序基准

len(序列名)    # 获取列表长度

min(序列名)    # 最小值

max(序列名)    # 最大值

sum(序列名)    # 求和

reversed(序列名)    # 反转序列内容等于切片中的反转

切片

序列[start:end:step] 来截取响应的字符串
start : 开始的下标
end   : 结束的下标(包头不包尾)
step  : 步长 默认为1

start如果为空，则默认从头开始切 如果 步长是正数 头在左边 如果 步长是负数头在右边
end如果为空，则默认切到最后 如果 步长是正数 尾巴在右边 如果 步长是负数尾巴在左边

#列表名[start : stop ：step] # 包头不包围列表名[::-1] # 列表反转python

元组

a = (1, 2, 3)
a, b, c = (1, 2, 3)    # a=1,b=2,c=3(解包)

值不可改变的列表，使用()而不是[]

元组是一种序列，序列方法函数通用

若元组内只有一个元素，末尾要加,

（）不加逗号会被python当作结合语法

元组相关函数

enumerate(序列名) # 将序列元素和对应的元素内容组成元组

其他

range(start,stop,step)    # 等差数字序列

有趣的示例

# 一串字符中的数字和字母分开提取出来
str_nums = '1this 2is a 345demo6 fo7r8 fun9'
int_nums = []
str_char = ''

for char in str_nums:
    try:
        int_nums.append(int(char))
    except ValueError:
        str_char += char

print(int_nums)
print(str_char)

i = input().split()

循环

编程小技巧:先写死，再变量化:)

for循环

for循环用法

# 循环输出1，2，3，4
for value in range(1,5):    
	print(value)

可迭代对象 内置有__iter__方法就是可迭代对象

for循环内部本质

1.调用可迭代对象的iter方法返回一个迭代器

2.不断调用next方法

3.处理异常

选择分支

pass关键字

应该填充内容的代码块可以先不写，使用pass跳过

pass 没有任何作用，暂时跳过

if语句

# 从上往下判断，如果为True则不往下执行了
if 条件表达式1:
    执行语句1
elif 条件表达式2:
    执行语句2
elif 条件表达式3:
    执行语句3
else:
    执行语句4

if 如果 elif 否则如果 else 否则

elif 这个条件可以是0个，也可以有多个

elif 如果有一个满足，剩下的表达式通通不执行，只执行那一个代码块

字典

在python中，字典是一系列键值对。每个键都与一个值相关联，可以使用键来访问相关联的值

创建字典

# 创建一个字典
字典名称 = {
		键:值,
		键:值
		}

访问字典

# 访问字典中的值
字典名[键]

添加键值对

字典名[要添加的键] = 该键对应的值

更改键值信息

字典名[要更改值的键] = 更改的值

删除键值对

del 字典名[键名]    # del语句会直接删除，可以用在多种删除中

字典相关常用方法

get(键名, 键不存在时要返回的值)    # 第一个参数不可省略，第二个参数默认为None

items()    # 返回一个键值对列表,可用于遍历字典

遍历字典

# 方法一
python_words = {
    'int': "整型",
    'float': "浮点型",
    'str': "字符串",
    'list': "列表",
}
for key, value in python_words.items():    # 使用item方法取得键值对列表，用两个变量分别表示键和值的内容
    print(f"{key} means:{value}")
    
# 方法二
favorite_numbers = {
    'Bob': 1,
    'stark': 2,
    'jack': 3,
    'bruce': 4,
    'han': 5
}
for name in favorite_numbers:
    print(f"{name}'s favorite number is {favorite_numbers[name]}") 

可变类型和不可变类型

• 可变：列表，字典，集合
• 不可变：数字，字符串，元组

散列类型

• 无序，不存在下标
• 内部元素不重复

集合(set)

语法:

集合名 = {1, 2, …}

当创建空集合时需要使用set(),因为{}会被判定为字典

存储不重复的内容,通常用来去重

使用场景：身份证，二维码，邮箱地址等

集合性质

• 唯一性：元素唯一存在，不重复
• 可变性：集合可以通过相关方法进行修改
• 无序性：元素没有下标，无顺序，不能通过下标来提取

集合中不能放列表

集合运算

& 交集 取公共元素

| 并集 取两集合共同元素

- 差集 左面集合减交集

in 判断是否在集合里面

集合相关方法

.add()    # 参数为所添加的元素，元素位置不确定

.update()    # 参数通常为序列类型，并将序列类型拆分后插入

.pop()    # 随机删除一个元素，但实际上并不是随机的，默认从左开始删，仅在集合元素是字符串，并在cmd中默认删除

.remove()    # 参数为元素内容，若元素不存在则报错

.discard()    # 同remove，但是元素不存在不会报错

.clear()    # 清空

字典（dict）

用来存储典型的“对应关系”的数据类型（键(key)值(value)对）

语法

字典名 = {
    键名1 : 值,
    键名2 : 值,
    ...
	}

取值：
字典名[键名]

字典性质

• 无序，无下标，字典可以通过键来访问数据

• 不重复，键不可以重复，值可以。若重复选择最后一个键的值

• 可变性，字典内的数据可变，且可以嵌套(可以嵌套序列或者再嵌套一个字典)

  cities = {
      "濮阳市": {
          "省份": "河南",
          "别名": "龙乡"
      },
      "天津市": {
          "省份": "天津",
          "别名": "九河下梢天津卫"
      }
  }
  for key, value in cities.items():
      print(f"{key}:{value['省份']}{value['别名']}")
  

字典相关常用方法

.setdefault(键名，值)    # 新增一个键，值默认为空None
# 一般不使用setdefault,增加键值对可以直接赋值

.pop()    # 参数：删除指定的键

.clear()    # 清空字典内容

.update()    # 参数为键值对，如果没有这个键值对，就新增一个

.get()    # 参数键名，获得键值，默认若没有会返回None，可以自定义返回内容

.keys()    # 获得所有的键

.values()    # 获得所有的值

.items()    # 返回键值对，并封装成元组

函数

函数可以用来保存可执行的代码，实现某个功能,需要先定义再使用

定义函数语法

def 函数名(形参):    # 函数名规则与变量类似,形参可以赋默认值
    函数内容

函数中的代码不会自动执行，需要调用

调用函数语法

函数名(实参)

优点：

• 减少代码量
• 提升代码项目的结构性，提高可读性
• 便于后期维护

# 两个形参，形参之间用逗号隔开
def login(username, password):
    if username == 'root' and password == '123456':
        print('登陆成功')
    else:
        print('登陆失败')


user_name = 'root'
pass_word = '123456'
login(user_name, pass_word)    # 传入实参

print(login)    # 函数login(没有加括号)所在的内存地址

实参的传入方法：

# 1.位置参数 实参对应形参顺序，依次传入
login(user_name, pass_word)
# 2.关键字参数 使用形参名将实参准确赋值给形参
login(password=pass_word,username=user_name)

混合使用关键字参数和位置参数时，必须把位置参数写在前面

函数的参数

可变参数（不定长参数）

*args

定义形参时，再形参前加*号，这种形参可以获得所有的位置形参，将所有的形参保存在一个元组中

def fn(*a):
    print(a)


fn(5,6,7,8)

(5, 6, 7, 8)    # 运行结果

• * 可以接收所有的实参，并将参数装在一个元组中（装包）
  • 一个函数中只能有一个可变参数
  • 可以和其他参数混合使用，但必须写在最后
  • 一般取名*args

**kwargs

• **形参可以接收任意的关键字参数，会将这些参数同意保存到字典中，字典的键就是参数的名字，字典的值就是参数的值
  • **形参只能有一个，写在最后面

参数解包

• * 序列名    # 传递实参时，`*序列名 `可以将序列类型中的元素依次作为参数传递
  

  • 需要保证序列中的元素可以被形参一一接受

• **为字典解包，字典键的名字需要和形参相同

返回值

return 函数的结果    # 函数的结果可以是任意的，但是必须是单值
return 1,2,3    # 结果是元组(1, 2, 3)

def fn():
    def fn2():
        print('h')

    return fn2


r = fn()    # fn()此时就是return的 fn2
r()    # 等价于fn2()

None

• python中None表示空值

函数没有返回值默认为None

函数进阶

函数可以被引用(赋值)

def fn():
    pass


f = fn
print(f)    # 输出的是fn的地址

函数可以作为参数传递给另一个函数

def fn2(x):
    print(x)

    
fn2(fn)    # 直接传fn，传的是fn函数的地址

函数可以作为返回值传递给另一个函数

def fn(x):
    return x


def fn2(y):
    return y


print(fn2(fn(1)))

函数可以作为容器的元素

list1 = [1, 2, 3, fn]
list1[3]()    # 实质就是调用了fn函数

匿名函数(lambda)

匿名函数没有名字的函数

语法格式

lambda 参数列表:运算表达式

lambda x:x*x

f = lambda x:x*x
print(f(5))

• lambda并不会带来程序效率提高
• lambda内不要循环，有的话用标准函数
• lambda只是为了减少单行函数的定义而存在

高阶函数

把函数作为参数,返回值传入

def ab_sum(a, b, f):
    return f(a) + f(b)


print(ab_sum(-1, -2, abs))

内置高阶函数

map(func, seq)    # 将传入的函数func作用到序列变量seq的每一个元素中，将结果作为新的迭代器返回

list_demo = [1, 2, 3, 4, 5]

print(list(map(lambda x:x+1, list_demo)))

reduce(func,seq)    # func必须有两个参数，将每次调用func的返回值作为下一次调用func的一个参数，然后与序列seq的下一个元素继续运算，以此类推，返回结果为一个单值，结果可以直接使用

reduce 在 functools 包中，使用时需要导包

filter(func, seq)    # 过滤序列seq,过滤掉不符合的元素，func需要返回bool值，若结果为True，就会保留seq中的元素

递归函数

递归 函数内调用函数自身

python对递归次数有自己的限制，不会无限递归下去

编写递归函数步骤

1. 首先定义一个出口

2. 算法不断接近出口

闭包与装饰器

闭包

闭包 如果在一个内部函数，对在外部作用域(非全局变量)的一个变量进行引用，那么内部函数就被认为闭包

def f():
    x = 10
    def g():    # g()被封闭起来且使用了外部作用域的x，这种操作称为闭包
        print(x)
        
    return g

h = f()
h()    # g()

装饰器

无参

time 时间模块
import time
time.time()    # 拿到此时此刻的时间

• 封闭原则：不允许修改内容
• 开放原则：允许对原内容进行扩展

下面show_time就是一个装饰器，可以在不改变原函数的情况下(封闭原则)扩展功能，一般将常用的功能做成装饰器，方便使用

import time

def foo():
    print("foo")

    
def show_time(func):
    def inner():
        start = time.time()
        func()
        end = time.time()
        print(f"运行了{end-start}秒")
    return inner


foo = show_time(foo)     

import time

    
def show_time(func):
    def inner():
        start = time.time()
        func()
        end = time.time()
        print(f"运行了{end-start}秒")
    return inner

@show_time
def foo():
    print("foo")    

上面两段代码功能一样，都是给原函数foo扩展计时功能

有参

import time


def show_time(func):
    def inner(*args,**kwargs):    # 传入多个参数并装包
        start = time.time()
        res = func(*args,**kwargs)    # 将装包的参数解包，依次传入func
        end = time.time()
        print(f"执行时间为{end-start}")

        return res

    return inner


@show_time    # add = show_time(add)
def add(x, y):
    return x + y


print(add(3, 4))

生成器与迭代器

生成器 生成器不占用内存空间，只有使用时才会取相关的值，因此有节省内存的优点。生成器是可迭代对象

两种语法

g = (i for i in range(100000))    #并不会直接存储，只有在使用时才会取值
g.__next__()    # 取g的第一个数    __next__为内部特殊方法，使用时并不建议使用可以使用next(g)

yield # 声明一个生成器

def f():
    yield 1
    
    
g = f()
print(next(g))

迭代器生成器就是迭代器

什么是迭代器

1. 有next方法
2. 有iter方法

模块与包

定义 包含一些数据、函数、类的文件，通常以.py结尾

模块之间的联系

模块导入

方法一：

# 将某模块整体导入到当前模块中
import 模块名    # 导入模块，直接执行模块中的全局作用域中的内容，优先搜索当前目录
模块名.成员    # 使用模块中的成员

通过模块名关联模块的地址

---

方法二：

from 模块名 import 成员    # 从模块中导入成员，可以直接使用成员

将指定模块的成员导入到当前模块

---

方法三：

from 模块名 import *    # 导入模块中的所有内容，最好在熟悉模块内容的情况下使用

将指定模块的所有成员导入当前模块

导入的成员不要与当前模块中的成员重名，若重名，则就近选择当前模块的成员

as 别名
# 避免不同模块中有相同成员
from 模块名 import 成员 as 别名

隐藏成员

定义模块中以下划线（_）开头的属性不会被方法三导入，通常称这些成员为隐藏成员（但可以通过其他方法导入）

# 示例
# module01.py
def func():
    print("func in module01")


def _func():	# 隐藏成员_func
    print("_func in module01")

# demo.py
from module01 import *

func()
_func()    # 无法找到

运行结果：

模块变量

__file__    # 模块对应的文件路径名

__name__    # 模块自身的名字，可以判断是否时主模块
# 主模块__name__绑定为'__main__'

python中__main__ ：

1. 如果一个.py文件作为主程序来运行时，那么__name__的值为__main__，如果为模块那么为__模块名__
2. 把一些非必要代码放入main函数内

if __name__ == '__main__':
    pass

分类

# 内置模块:在解析器内部可以直接使用
# 标准库模块：安装python时已经安装的模块，可以直接安装
# 第三方模块：通常时开源的，需要自己安装并学习使用
# 用户自己编写的模块

第三方模块安装方法

1. 通过在终端运行pip install 模块名 -i 源地址

   国内源地址

   1）清化大学
   PIP源地址：https://pypi.tuna.tsinghua.edu.cn/simple
   2）阿里云
   PIP源地址：http://mirrors.aliyun.com/pypi/simple/
   3）豆瓣
   PIP源地址：http://pypi.douban.com/simple/
   4）中国科学技术大学
   PIP源地址：http://pypi.mirrors.ustc.edu.cn/simple/
   5）华中科技大学
   PIP源地址：http://pypi.hustunique.com/

2. 在pycharm找到选项安装

包

python大致结构

包    # 文件夹
	模块    # 文件
    	函数
        	语句

包 将模块以文件夹的形式进行分组管理，管理模块。将相关的模块组织在一起，使逻辑结果更加清晰。python包里默认有__init__模块

包的导入

from 包.模块 import 成员    # 类似模块导入，另两种方法相似，但大多数选择这种形式

__init__.py

__init__.py    # 包内必须存放的文件，会在包加载时被自动调用

通常存放关于包内模块的使用说明

常用模块

sys

system:系统的意思。提供一些变量和函数，可以获取到Python解析器的信息

pprint:标准库模块，pprint()可以简单的美化数据打印

sys.modules    # 获取当前程序中引入的所有模块

sys.path    # 返回一个列表，列表中保存的是模块的搜索路径

sys.exit()    # 用来退出程序，括号内可以小写提示字符串

os

# 对操作系统进行访问


os.system()  # 用来执行操作系统的命令
	os.system('pip install jieba')
    
os.getcwd()    # 获取当前python工作目录

os.mkdir('文件夹名')    # 当前目录创建一个文件夹

os.rmdir('文件夹名')    # 删除当前目录下的文件夹（只能删空的）

os.rename('旧文件名','新文件名')    # 重命名

os.chdir('文件夹名')    # 切换当前执行程序的位置

os.listdir()    # 获取指定目录下所有文件和目录名
    
os.path  # 判断是否是文件夹和文件

os.path.exists(path) # 判断文件或者目录是否存在

os.path.isfile(path) # 判断是否为文件

os.path.isdir(path)  # 判断是否为文件夹

time

import time

time.time()    # 时间戳，返回utc时间，从1970年开始到现在经过的秒数

time.localtime()    # 返回一个时间元组，可以单独拿到属性

time.sleep()    # 程序休眠，单位为s

time.strftime()    # 配合localtime格式化获取时间
	# %Y 年
    # %m 月
    # %d 日
    # %H 时
    # %M 分
    # %S 秒
    t = time.localtime()
    print(time.strftime('%Y %m %d'))

random

import random

random.random()    # 生成大于0小于1的随机数

random.randint(start， end)    # 生成start~end随机整数

random.choice(序列)    # 随机生成指定的元素

random.uniform(start, end)    # 生成start~end随机小数

random.shuffle(序列)    # ”洗牌“打乱一个序列

json

前端 用户直接看到的

后端 接收前端请求，做该做的数据处理

json 一种文件的存储格式，主要用于存储，大部分的编程语言都可以识别，是一种兼容性很强的文件格式，网络中大部分数据都是以json形式传递让每个语言都可以访问

序列化数据 机器码（二进制）

反序列化数据 代码

import json

json.dumps(序列)    # 将序列内容序列化存储(按照json方式存储)

json.loads(序列化内容)    # 反序列化

文件

绝对路径 从根目录开始，文件的完整路径，具有唯一性

D:\Python【学习】\python自学\python函数方法自总结

相对路径 以当前文件资源所在的目录为参照基础，链接到目标文件资源

__file__    # 获得当前文件的路径

创建文件

打开文件

f = open(file, mode='r', buffering=-1, encoding=None, )    # python内置函数，打开文件,默认为只读(r)，编码为None, 

# 目标文件与.py文件在同级目录下file直接使用文件名称，不在同一目录下使用绝对路径

mode默认为只读

r read 只读

w write 写入 # 会覆盖源文件内容，如果文件不存在会创建文件

a add 追加 # 如果文件不存在会创建文件

+ 为操作符增加功能：

r+ # 可写也可读，文件不存在会报错

w+ #可写也可读，文件不存在会报错

a+ # 可写也可读，文件不存在会报错

关闭文件

f.close()    # 关闭文件

with open(fileName) as f:    # 使用该语法只会在改语法的内部保持文件打开的状态
    pass
f.read()    # 已经被自动关闭，执行后会报错

读取文件

f.read()    # 默认读取文本文件，文件内所有内容以字符串格式返回，可以指定访问字符数量，单位为字符不是字节。

# 若要读取二进制文件，需要把mode改为rb,类似的，二进制文件都需要加一个b

# 读取大文件的方式
with open(fileName, encoding='utf-8') as f:
    all_content = ''
    while True:
        content = f.read(3)
        if content == '':
            break
print(all_content)            

f.readlines()    # 按行来读取

写入文件

write open(fileName, mode='w',endcoding='utf-8') as f:
    f.write('Hello world')    # 返回值为写入的字符串长度
    f.read()

正则表达式

正则表达式：普通字符和元字符构成的字符串，描述一类字符串规则

需要导入re模块

习惯性使用原始字符串(r字符串)

import re

re.match(参数一, 参数二)    # 在参数二中从左往右匹配参数一的内容，匹配不到返回None
re.match().group()    # 可以直接返回匹配内容
re.findall()    # 返回一个列表，与match参数一样

元字符

.：任意字符，‘\n’除外,若在match中匹配到’\n’，会返回None

re.match('.', "web")    # 匹配成功，结果为w

\d：0~9的任意数字

re.match('\d', '0web')    # 匹配成功，结果为0

\D：非数字

re.match('\D', '123')    # 匹配失败，1为数字

\s：空白字符

re.match('\s', '\n')    # 匹配成功，换行空格等都是空白字符

\S：非空白字符

re.match('\S', '\\')    # 匹配成功，值为'\\',第一个'\'为转义字符

\w：英文字母，数字，下划线

re.match('\w', '5sd_')    # 匹配成功，值为5

\W：非英文字母，数字，下划线

re.match('\W', '&*^')    # 匹配成功，值为&

字符集

使用[]，表示一个字符的范围

re.match('[0-9][0-9]', '11')    # 匹配成功，取两位数，值为11

re.match('[a-d]', 'abcz')    # 匹配成功，值为a，'[a-d]'表示abcd，'[A-z]'为所有字母等等

^：取反符号

re.match('[^a-e]', 'f')    # 匹配成功，值为f。'^'加在前面表示取反，即匹配内容为a-e之外的字符

数量规则

*：匹配前一个字符的任意次数的字符,包括0次

t = '10086'
re.match('\d*', t)    # 匹配所有的数字，值为'10086'

+：匹配前一个字符重复一次以上的任意次数

import re
demo = ''

res_t = re.match('\w*', demo)
print(res_t)    # 结果为正常的空字符

res_a = re.match('\w+', demo)
print(res_a)    # 结果为None
'''
\d+:
	\d
	\d\d
	\d\d\d
	...
\d*:
	''
	\d
	\d\d
	\d\d\d
	...
'''

?：匹配前一个字符出现0次或者1次

t = '10086'
d = ''
re.match('\d?', t)    # 1
re.match('\w?', d)    # ''

+++

{m}    # 匹配前一个字符的m次
{m,}    # 至少匹配前一个字符m次以上
{m,n}    # 匹配m次以上，n次以下
t = '10086'
re.match('\d{2，}', t)    # 结果为'10086' 

边界处理

^：开始（只有在字符集中才是取反）

$：结束

# 学号格式201610916121前六位必须201610，共12位
n = '201610916121'
n.match('^201610\d{6}$', n)    # 必须从2开始，然后后面必须满足12位学号

分组匹配

t = '2022-06-15'
print(re.match('\d{4}-0[1-9]-\d{2}', t))    # 月份只有01~09，没有10~12

|：正则表达式中的或者

()：正则表达式中的分组

t = '2022-06-15'
print(re.match('\d{4}-(0[1-9]|1[0-2])-\d{2}', t))    # 可以正确匹配日期格式

re.match('\d{4}-(0[1-9]|1[0-2])-\d{2}', t).group()    # 返回分组内容'06'

re.match('(d{4})-(0[1-9]|1[0-2])-(\d{2})', t).group()    # 返回分组内容,有三对括号，所以有三个分组，group后的参数为返回分组的数量

import re

xml = '<a>hello</a>'
res = re.match('<\w+>(.*)</\w+>', xml)
# res = re.match('<(\w+)>(.*)</(\1)>', xml)
# \1 与第一个分组的内容相同 \1 == \w+
print(res)    # 取到'<a>hello</a>'
print(res.group())    # 取到'hello'

分组取别名：(?P<别名>) (?P = 别名)

MVC开发模式

包：分类，管理模块

MVC：架构分明，分工合作完成。方便开发，维护和更新。

• M：(model)模块层，对数据进行增删改查,一般处理sql数据
• V：(view)视图层，用于数据的显示媒介为html或者json
• C：(controller)控制层，用户的交互，控制行为

ATM项目

项目环境搭建

1. 准备计划，分析项目逻辑，细节

2. 新建文件夹

3. 建立架构

api    # Application Programming Interface 应用程序编程接口，专门处理业务逻辑相关操作
	user_interface.py
    bank_interface.py
config    # 配置（数据库的账号密码，python版本等）
	setting.py
core    # 核心文件，代码主要功能实现
	src.py    # source源代码
db    # database 数据库
	user_data    # 用户的数据
    db_handle.py    # 数据库处理
lib    # library 常用功能模块
	common.py    # 常见功能模块
readme.txt    # 说明文档
run.py    # 运行，主模块