python（递归、模块、面向对象、继承）

递归

字符串：是一种典型的不可变类型，是一个对象

定义：
' '
" "
a = """ """
b = ''' '''
 
字符串也存在下标
 
字符串对象常见的方法：
'capitalize', 'casefold', 'center', 'count', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'format_map', 'index', 'isalnum', 'isalpha', 'isascii', 'isdecimal', 'isdigit', 'isidentifier', 'islower', 'isnumeric', 'isprintable', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'maketrans', 'partition', 'removeprefix', 'removesuffix', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill'
 
capitalize(): 首字母大写返回新的字符串
 
center()：居中对齐
>>> s.center(50,"*")
'*********************huazhhu**********************'
>>>
 
>>> a = "huazhu"
 
count()：统计元素的个数
>>> a.count("u")
2

endswith()：判断字符串是否以什么结尾
返回的是布尔值
>>> a.endswith("zhu")
True

startswith()：是否以什么开始
>>> a.startswith("hua")
True
>>> a.startswith("ha")
False

find(查找的字符，[检索开始的下标，检索结束的下标]): 从左到右检索某个字符或字符串，找到第一个满足的字符或字符串，并且返回下标
 
find如果未检索到，最终会返回-1
 
index(): 
未检索到，直接报错
 
rfind(): 从右向左边进行检索
 
rindex(): 
 
format(): 格式化字符串的
>>> print("姓名是{}".format(num))
姓名是2
 
join():按照特定的规则进行字符串的拼接
 
split(): 按照特定的字符串进行分割，最终返回的是一个列表
>>> s.split(" ")
['huazhhu']
 
upper():转大写
 
lower(): 转小写
 
strip(): 清除字符串两边的空格的
 
lstrip(): 清除左边的空格
 
rstrip(): 清除右边的空格
 
title(): 标题格式（每个单词的首字母大写）
 
replace(old,new): 返回一个新的字符串
 
encode(): 转换编码格式，将字符串转换为字节
 
decode(): 将字节转换为对应的编码
 
下标：某一个元素
切片：拿到多个有序的元素
可以对标range
[start:end:step]:
 
start:不写的情况下，默认从下标为0的地方开始切片
取左不取右
 
end:不写的情况下，默认直接切片到所有元素结束

step:不写的情况下默认为1
 
切片切不到时，只会无返回，不会进行报错
 
Print(str1[1:6:-1]): start = 1 end= 6
表明切片方向是从左向右，但是step采用-1，是表明从右向左切

模块：一个.py结尾的文件就是一个模块，里面存放的是类、函数、数据……
 
模块导入的时候，会执行模块中的顶层代码，而函数中的代码，只有在调用的时候会执行
 
导入模块
import 模块名
 
__all__：[""]通过其指定的，只会限制from 模块名 import *的导入
__doc__：获取文档注释
__file__：获取当前文件的绝对路径
__name__：显示模块的名字
 

模块

模块：内置模块、标准库模块、第三方库模块

math模块：

import math
① ceil()：向上取整
>>> math.ceil(3.0000001)
4
 
② floor()：向下取整
>>> math.floor(3.999)
3
 
③ round()：全局函数，进入四舍五入
>>> round(3.5)
4
>>> round(4.5)
4
对于奇数，严格遵循四舍五入，对于偶数，以0.5为界限
 
④ pow()：幂函数，返回的是浮点数
>>> math.pow(2,4)
16.0
 
⑤ sqrt()：开方函数
>>> math.sqrt(9)
3.0
 
⑥ exp()：e的x次幂
>>> math.exp(1)
2.718281828459045

时间模块

三种表示时间的方式：时间戳、时间元组、格式化时间字符串
时间戳：（1970-1-1 0：0：0）直到指定时间的秒数

import time
print(time.time())
1712840938.0636406

时间元组：
print(time.localtime())
time.struct_time(tm_year=2024, tm_mon=4, tm_mday=11, tm_hour=21, tm_min=10, tm_sec=47, tm_wday=3, tm_yday=102, tm_isdst=0) 

格式化时间字符串：2024-4-11 21：07
%Y(年)   %m(月)   %d(日)   %H(时)   %M(分)   %S(秒)
print(time.strftime("%Y-%m-%d  %H:%M:%S"))

asctime：接收时间元组，转换为字符串返回
print(time.asctime(time.localtime()))

ctime()：接收时间戳，返回字符串
print(time.ctime(time.time()))

睡眠（单位是秒）
time.sleep(4)
print(time.gmtime(time.time()))

random模块

random：伪随机数
 
random.randint(1,10)获取某个范围内的随机整数
int(random.randint()*10)
 
random.choice()：从有序的序列里面随机选一个元素，直接返回具体的元素
>>> ls = [1,2,3,4,"zhangsan"]
>>> random.choice(ls)
'zhangsan'
>>> random.choice(ls)
2
 
random.choices()：返回的是随机抽取的元素组成的列表
>>> ls = (1,2,3,4)
>>> random.choices(ls)
[4]
>>> random.choices(ls)
[3]
 
[left,right]

os模块

os：与操作系统相关的功能
os.system("ipconfig")：帮助执行命令的
os.curdir：获取相对路径
 
os.getcwd()：获取当前工作目录的绝对路径
>>> os.getcwd()
'C:\\Users\\lxt04'
 
os.chdir("D:\\")：切换工作路径
>>> os.chdir("D:\\")
>>> os.getcwd()
'D:\\'
 
 os.listdir("D:\\C++")：
 
os.getlogin()：当前登录的用户名
>>> os.getlogin()
'lxt04'
>>> os.getpid()
1036
 
os.getppid()：返回父级的进程
>>> os.getppid()
1492
 
os.sep：获取分隔符的
>>> os.sep
'\\'
 
os.path：专门针对路径和文件系统的
 
ll = "文件地址"
path.basename(ll)：获取的是地址中的文件名
path.dirname(ll)：返回路径
path.exists(ll)：判断文件是否存在
 
path.isfile()
path.isdir()
 
path.split(ll)：分割
path.join(参数1, 参数2)：用分割符将两个参数进行拼接
 
sys：提供的关于操作python自身解释器的方法，以及变量
 
sys.argv：返回的是脚本名称返回的列表可以是多个值
PS D:\云计算\python运行> python .\06-sys.py 1 2 3 4
['.\\06-sys.py', '1', '2', '3', '4']

getdefaultencoding：获取默认编码
>>> sys.getdefaultencoding()
'utf-8'
 
getfilesystemencoding：获取文件系统的默认编码
>>> sys.getfilesystemencoding()
'utf-8'
 
getrecursionlimit：获取递归限制
>>> sys.getrecursionlimit()
1000
 
setrecursionlimit：设置递归限制
>>> sys.setrecursionlimit(1500)
>>> sys.getrecursionlimit()
1500
 
getrefcount：获取引用数量
>>> a =[1,2,3,4]
>>> sys.getrefcount(a)
2
>>> b = a
>>> sys.getrefcount(a)
3
>>> b = None
>>> sys.getrefcount(a)
2
 
垃圾回收机制：
代码运行在内存中，函数，进行弹栈释放内存，但是存储在堆里边，如何释放？
 
引用计数（缺点：无法解决循环引用的问题，内存浪费）
arr1 = [1,2,3,4,5]
a = arr1

a = None
arr1 = None

标记清除
 
UUID：生成一个不会重复的标识
缺点：检索效率会相应降低
>>> uuid.uuid4()
UUID('8909a70b-303f-4fbb-85e2-91cbf314c205')
 
hash相关的模块：
哈希表：
1.结果唯一
2.无序
3.单项不可逆
 
加密算法：
对称加密：加密和解密用的是一个密钥   des
非对称加密：加密和解密采用的不是一个密钥   res
hashlib
1.数字校验
2.数据加密
>>> md5 = hashlib.md5("123456".encode())
>>> md5
<md5 _hashlib.HASH object @ 0x0000018DAB31F8B0>
>>> md5.hexdigest()
'e10adc3949ba59abbe56e057f20f883e'
 
盐值混淆：
>>> md5.update("789".encode())
>>> md5.hexdigest()
'25f9e794323b453885f5181f1b624d0b'
 
hmac：专门进行数字加密的模块（难破密）
>>> a = hmac.new("789".encode(),"123456".encode(),"MD5")
>>> a
<hmac.HMAC object at 0x0000018DAB2C7470>
>>> a.hexdigest()
'a0b0d1c294daeda58c18fc45e7db233f'

calendar模块

>>> calendar.month(2024,4)
'     April 2024\nMo Tu We Th Fr Sa Su\n 1  2  3  4  5  6  7\n 8  9 10 11 12 13 14\n15 16 17 18 19 20 21\n22 23 24 25 26 27 28\n29 30\n'
>>> calendar.weekday(2024,4,14)
6

面向对象

oop：面向对象编程
面向过程：
函数
 
面向对象：
对象：110  200
 
人是一类
张三是一个对象
属性：身高/年龄/爱好
方法：唱歌、跳舞、敲代码
 
类：逻辑上存在的，虚拟的
对象：真真切切存在的，对象之间互不干扰

你   userid   passwd     def：走  输入
ATM def：校验  取钱  存钱    id
 
类、对象
统计学校所有学生的信息：姓名、年龄、专业、id
person1 = {
username:"zhangsan",
age:21,
zhuanye:"jake",
id:110
}
 
类成员：
1.属性
2.方法：在类里面的函数
 
python中创建类的方式：
类名称：采用大驼峰命名法进行区分   UserName
class 类名称(object[father1,father2]):
def __init__(self,uname,age
Self.uname = uname
Self.age = age
 
def __str__(self):
return "xxx"

#实例化对象
对象名 = 类名（传参）
 
面向对象的特征：封装、继承、多态
一、封装
1.类的成员全部封装在类中
2.为了安全考虑，有些属性和方法，不希望被随意访问。因此，在大多数情况下，往往要对对象的属性进行私有化，然后，提供公开的方法进行访问   get_   set_
 
python进行成员的私有化：__属性名    __方法名
私有化的成员在class中可以被访问

_方法名、_变量名：表示不能被其他模块所引用的
from 模块名 import *
 
property():
 
@property
@name.setter
 
函数重载：存在多个函数名相同的函数，但是参数个数或者参数类型不同，会使得在调用的时候，自动调用对应函数的现象

二、继承

父类：被继承的一方   超类、基类
子类：
 
子类不能继承父类的私有成员
 
方法重写：父类中的方法已经不能满足子类的需求，因此，在子类中重新定义一个与父类方法名相同的方法，我们把这种情况，叫做方法重写（方法覆盖）
 
python中的类的继承，是支持继承多个类的
Class Son(Father,Mother):
Pass

如果Son类中，也存在__init__，那么一定要在代码的第一行手动调用父类
 
super()：是一个指针，指向自己的父类，只用在类中