python基础 - 技术栈

python的特点

解释型语言：不用预先编译，便解释边执行；

动态类型：变量类型在运行时确定；

强类型：类习惯转换需要显示操作；

面向对象：支持类、继承、多态；

胶水语言：可轻松调用C/C++库

丰富的库：标准库强大，第三方库丰富
python中的变量类型
- 数字 Numbers
  int整型、long长整型（3.x版本被移出）、float浮点型、complex复数
- 字符串 String
- 列表 List
- 元组 Tuple
- 字典 Dictionary
  可通过type()函数查看变量的类型

数字之间的转换

python 复制代码

str1, str2, str3, x  = '18', '4+5**2', '0x23', 17
print( int(str1, base=10) ) #将字符数字转换为十进制的数字，base为当前str的进制
print( int(str3, 16) ) #将字符数字转换为十进制的数字，base为当前str的进制
print( str(x) )       #将对象x转换成字符串
print( eval(str1) )   #计算字符串中的表达式，如eval('2+3*4')、eval('[i for i in range(10)]')
print( hex(x) )       #将一个整数转换为一个16进制字符串
print( oct(x) )       #将以各整数转换为一个8进制字符串

python中的常用数学函数

python 复制代码

import math
x, y , n1, n2= 3, 4, math.pi, 27
xabs = abs(x)     #求绝对值
xround = round(n1,y) #对n1进行四舍五位，保留y位小数
xpow = math.pow(x,y) #求x的y次方
xsqrt = math.sqrt(x)  #求x的平方根
n1ceil = math.ceil(n1)  #向上取整
n1floor = math.floor(n1) #向下取整
ex = math.exp(x)   #求e的x次方幂
n2log = math.log(n2,x) #以x为底，n2的对数

print(xabs, xround,xpow,xsqrt,n1ceil, n1floor, ex, n2log)

python中的随机函数

python 复制代码

import random
seq = [i for i in range(100)]
strs = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
random_from_seq = random.choice(seq)  # 从序列的元素中随机挑选一个元素
randoms = random.sample(seq, k=3)  # 从序列中随机选k个元素，返回一个列表
randoms_str = ''.join(random.sample(strs, k=3)) # 从序列中随机选择k个元素，组成一个随机字符串
random_1 = random.random()  # 随机生成一个实数，范围在[0，1)之间
print(random_from_seq, randoms, randoms_str, random_1)

字符串常用方法

python 复制代码

strf = f'D:\py \nhhh\D\d\.'  # 原样表示，\不表示转义，而表示\本身, 除了\n会被转义，其余都会原样
ss = ' Helloo World' + 'hhh! ' * 2
L = ss.split('!')  # 分割为列表，分割
s1 = ss.replace('!', '@')  # 替换
s2 = ss.strip()  # 去掉ss两边的空格
s3 = ss.zfill(30)  # 保留指定长度，不足长度的在前面补0，足够的话就取一整个字符串
print(strf,'\n', ss, '\n', L, '\n', s1, '\n', s2, '\n', s3)


# 正则匹配查找
import re
ss = 'This is a string. and is a variable!'
res1 = re.match(r'This is', ss) #从字符串从头开始匹配，返回匹配对象或None。
res2 = re.match(r'is is', ss)  #match只从头开始匹配，字串的开头和字符串不一致，匹配不上

if res1:
	print(res1.group())

if res2:
	print(res2.group())
else:
	print('没有匹配到')

res3 = re.search(r'is..', ss)  #扫描整个字符串找到第一个匹配的位置，返回匹配对象或None
if res3:
	print(res3.group())  # 匹配的第一个子串内容
	print(res3.span())  # 匹配到的位置（start, end）

res4 = re.findall(r'[a-z]+', ss) # 查找所有匹配，返回一个匹配的子串列表
res5 = re.findall(r'f', ss) # 没有匹配到，返回一个空列表
print(res4)
print(res5)

元组

python 复制代码

tup1 = tuple()  #空元组
tup2 = (1,3,5,'hhh',[1,3,5])
print(tup1)
print(tup2)

列表

python 复制代码

list1 = []  # 定义一个空列表
list1.append(3)  # 在列表后面添加元素
list1.append('hello')
list1.insert(0, 'insert')  # 在下标为0的位置插入
print(list1)

del list1[1]  # 删除列表中下标为1的元素
print(list1)

L = [str(i) for i in range(13) if i%2 ==0]  # 推导式生成字符列表
print(L)

L.sort()  # 排序，无返回，直接改变原列表，默认升序
print('直接排序，默认升序：', L)

L.sort(key=int)  # 将元素转换为数字进行排序，默认升序
print('将元素转换成整型，再进行排序：', L)

L.sort(key=len, reverse=True)  # 按照每个原色的长度就行排序，降序排序（reverse=True表示降序，默认为False）
print('按照每个元素的长度进行排序：', L)

L1 = sorted(L, key=int)  # 排序，不改变原列表，返回一个新列表
print('L1：', L1, '  L:', L)

# 计数
count = L.count('10')  # 字符串1出现的次数
print(count)

# 遍历
for i in L:
	print(L)

for i in range(len(L)):
	print(L[i])

字典

python 复制代码

'''
哈希表实现，平均O(1)
的时间复杂度。
键要求：必须是可哈希对象（不可变类型）
冲突解决：开放法定址。
'''

dict1 = {'a': 11, 'b': '22', 'c': 33, 'd': [2, 3, ]} # 创建字典

v1 = dict1.get('a')  # 获取指定键的值，若键不存在，则返回默认值，默认值默认为空
print(v1)

its = dict1.items()  # 获取字典的（键，值）元组
print('items：', its)

# 遍历键值对
for a in its:
	print(' '*6, a)

ks = dict1.keys()  # 获取字典的所有键
print('keys：', ks)

vs = dict1.values()  # 获取字典的所有值
print('values：', vs)

# 字典的内置方法
seq = [i for i in range(5)]
val = 'hhh'
dict2 = dict.fromkeys(seq, val)  # 创建一个新字典，以序列seq为键，val为所有键的初始值
print('dict2：', dict2)

日期和时间

python 复制代码

import time, datetime

# time获取当前日期、时间
tstamp = time.time()    # 获取当前时间戳
t = time.localtime()	# 获取本地时间，返回为一个struct_time元组
print('当前时间戳：', tstamp)
print('本地时间：', t)

# time格式化日期
tstr1 = time.strftime('%Y-%m-%d %H:%M:%S', t) # 格式化指定的时间元组t
tstr2 = time.strftime('%Y-%m-%d %H:%M:%S')    # 格式化当前时间
print('tstr1：', tstr1, '  tstr2：', tstr2)

# struct_time元组
#     time.struct_time(tm_year=2025, tm_mon=12, tm_mday=25, tm_hour=16, tm_min=38, tm_sec=9, tm_wday=3, tm_yday=359, tm_isdst=0)
#     各个字段分别表示：年 月 日 时 分 秒 这周的地几天 今年的第几天 是否为夏令时

# datetime获取当前的日期、时间
now = datetime.datetime.now() 	# 当前日期和时间，返回一个元组(年，月，日，时，分，秒，秒的精确小数位)
today = datetime.date.today()	# 当前的日期，返回一个元组(年，月，日)
ctime = datetime.datetime.now().time() # 当前时间，返回一个元组(时，分，秒，秒的精确小数位)，print语句打印时会用冒号分隔
print('now：',now, ' today：' , today, ' ctime：', ctime)

# datetime创建指定日期、时间
dt1 = datetime.datetime(2025,10,10,13,14)  # 创建指定的日期和时间
dt2 = datetime.date(2025,10,10)
dt3 = datetime.time(13,14,12)
print('dt1：',dt1, '  dt2：', dt2, '  dt3：', dt3)

# datetime通过字符串创建日期时间对象
dt_str1 = '2025-12-10 10:10:10'
dt1 = datetime.datetime.strptime(dt_str1,'%Y-%m-%d %H:%M:%S')

# datetime转换为字符串
dt_str2 = dt1.strftime('%Y-%m-%d %H:%M:%S')
print(dt_str2)

lambda匿名函数

python 复制代码

#匿名函数的定义 lambda *args : expression
isequals = lambda a,b :a==b
res = isequals(3,4) # 调用lambda匿名函数
print(res)

闭包函数与装饰器

闭包

在一个函数A中定义子函数B，子函数A使用了函数B中的变量。

python 复制代码

def funcA(a):
	b = a * 2
	def funcB(c):
		nonlocal a
		a = 1
		result = a + b + c
		return result
	return funcB

res = funcA(3)  # res是一个funcB对象
print(res(2))

装饰器（也是闭包的一种）

将一个函数作为另一个函数的入参。

python 复制代码

def decorator(func):  # 将函数func作为入参
	def wrapper(*args, **kwargs):
		# 在调用原始函数之前/之后执行的代码
		print('befor')
		result = func(*args, **kwargs)
		# 在调用原始函数之后执行的代码
		print('after')
		return result
	return wrapper

# 通过@装饰器函数的形式，将紧接着的函数作为装饰器的入参
@decorator
def powerof2(n):
	''' 求2的n次方 '''
	j = 1
	for i in range(n):
		j = j*2
		print(j)
	return n

res = powerof2(3)
print(res)

模块

一个.py文件就是一个模块

导入模块时，解释器的搜索顺序：

1、内置模块，如：sys、os、math等

2、当前目录

3、环境变量PYTHONPATH指定的目录中的所有目录（import sys sys.path）

4、标准安装库的安装位置（import os os.file ）

5、第三方库的安装目录 site-packages

文件操作

open()函数

打开模式有： r只读 w只写(覆盖) a追加 x创建新文件并写入 b二进制模式 t文本模式(默认) +读写模式

常用编码：utf-8 gbk ascii

python 复制代码

filepath = r'D:\test.txt'

# 以只写的方式打开文件，会把原文件覆盖
with open(filepath, mode='w', encoding='utf-8') as f:
	f.write('写入的内容哈哈哈哈\n')  # 写入字符串
	# 写入多个内容
	text_lines = [f'这是第{i}行的内容\n' for i in range(3)]
	f.writelines(text_lines)

# 以追加的方式打开文件
with open(filepath, mode='a', encoding='utf-8') as f:
	f.write('追加写入\n')  # 写入字符串
	# 写入多个内容
	text_lines = [f'这是第{i}行追加写入的内容\n' for i in range(3)]
	f.writelines(text_lines)

# 以只读的方式打开文件
with open(filepath, mode='r', encoding='utf-8') as f:
	all_content = f.read()  # 读取全部内容，读取之后，指针移到最后
	print('一次性读取的全部内容-----------\n', all_content)

	f.seek(0)  # 指针移动到文件开头
	partial = f.read(5)  # 读取前n个字符
	print('f.read(50)的结果 ', partial)

	f.seek(0)  # 指针移动到文件开头
	line = f.readline()  # 读取单行内容
	print('读取一行',line)

	f.seek(0)  # 指针移动到文件开头
	line_list = f.readlines()  # 读取所有行到列表，每行为列表的一个元素
	print('读取所有行，返回一个列表 ',line_list)

	# 遍历文件行
	f.seek(0)  # 指针移动到文件开头
	for per_line in f:
		print(per_line, end='')

	pos = f.tell()  # 获取当前的位置
	print('当前指针的位置 ', pos)


	f.seek(10)  # 移动到第10个字节
	print('f.seek(10)之后，指针的位置 ', f.tell())

	# f.seek(-3, 2)  # 相对移动（第二个参数 1表示从当前位置 2表示从文件最后 0表示从文件头）向前移动5个字节，只能再以2进制打开文件时进行相对移动
	print('当前指针的位置 ', f.tell())

json数据的处理

python 复制代码

# json的常用方法
import json

# 从字符串生成json(字典)
data_str = '{"caseno":"1", "casename":"hhh", "otherdata":"..."}'
json_ob = json.loads(data_str)
print(json_ob)

# 把json对象转换成json字符
data_dic = {'status':"0", "data":[1,2,3]}
json_str = json.dumps(data_dic)
print(json_str)

# 写入json文件
with open('datas.json','w', encoding='utf-8') as f:
	json.dump(data_dic, f, indent=2)

# 从json文件读取json数据
with open('datas.json','r',encoding='utf-8') as f:
	loaded_data = json.load(f)
	print('文件读取 ', loaded_data)