Python笔记-CSDN博客

本文链接：https://blog.csdn.net/syzzz0/article/details/136986708

基础知识

#这是单行注释
'''这是多行注释1'''
"""这是多行注释2"""

变量：在程序运行时，可以发生变化的量；具有名称的内存空间
声明变量：变量名=变量值
a = 10
可以一次声明多个变量
a,b = 10,20
快速交换变量值
a,b = b,a

标识符的命名规范：
1.只能使用字母（大小写敏感）数字下划线
2.不能以数字开头
3.不能使用保留字和关键字
4.不能使用全局中已经使用的模块名
5.建议标识符名称有意义
6.建议使用小驼峰命名法（除第一个单词外的其他单词首字母大写）和_进行命名
7.类的命名采用大驼峰命名法（首字母全部大写）
8.PY没有常量关键字，使用全大写来代表常量

dir():显示对象中存在的方法

数据类型：基本数据类型和复合数据类型
基本数据类型：
1.数字类型：整型int、浮点型float、复数（虚数）a+bi
2.布尔型（bool）：true、false 判断条件是否成立 非0为真 0为假
3.字符串类型：""    '' str
复合数据类型：
1.数组
2.列表
3.元组
4.字典

type()：检测变量的数据类型
 '''   """ 都属于字符串
 \ ：转义符，使特殊符号无意义
当需要嵌套使用多个引号时，相同引号会优先判定最近两个
1. \ ：转义符，使特殊符号无意义
2. 交替使用单双引号

ord()：查看字符对应的ASCII码
chr()：将编码转换为对应的字符

\n：换行
\t：多空格

数据类型转换
自动类型转换：整型、浮点型、布尔型
强制类型转换：
1.转int
2.转float
3.转str

print("%s+%s=%s"%(a,b,c))
print(f"{a}+{b}={c},这是一个加法")
print("{0}+{1}={2},这是一个加法".format(a,b,c))

字符串格式化 printf("%s+%s"=%s %(a,b,c))
字符串只能和字符串拼接

常见运算符
算术运算符：+   -   *   /   //整除 %取余 **次方
关系运算符：> < >= <= == !=
逻辑运算符：and   or  not
所属运算符：in  not in
赋值运算符：=   +=  -=  *=  /=  //=  %=  **=
三目运算符：变量 = 值1 if 条件 else 值2
位运算符：
|(或运算) &(与运算) ^(异或) ~(非运算。带着符号位全部取反)
<<n 所有二进制位往左移n位 即十进制数增加2^n倍
>>n 所有二进制位往右移n位 即十进制数减少2^n倍

python中不存在自增自减a++;a--
最高位为符号位 1为负 0为正

解决正数负数加减问题
正数的原码反码补码相同
原码：十进制对应的二进制
反码：符号位不变，其余位取反
补码：反码+1
2+-3
 0000 0010
+1111 1101 -3补码
----------
 1111 1111 结果的补码
+1111 1110 结果的反码
----------
 1000 0001 结果的原码 -1

程序控制流程

解决语句与语句之间的顺序的问题
顺序：从上到下，从左至右，顺序执行

选择

不同条件，执行不同代码块
if 条件:
    条件成立时执行的语句块
elif 条件:
	条件成立时执行的语句块
else:
	语句块

循环

while 条件:
    语句块

while 条件:
    语句块
else:
    语句块

for循环在Python中一般用来迭代容器
for 临时变量 in 容器:
    语句块

for ():
    ()
else:
    ()

rang(n) 包含(0,n-1)的所有整数
rang(n1,n2) 包含(n1,n2-1)的所有整数
rang(n1,n2,step) step为步长,默认为1
step为负值时,需要n1>n2

容器

线性表：大小固定，内存空间需要连续
链表：大小不用固定，内存可以不连续
栈：先进后出
堆列：先进先出

列表

可以存不同的数据类型,元素可以重复，有序

定义变量名=[]
l = [1,2,3,‘yi’,‘er’]
修改变量名[下标]=值
长度=len(列表名)
遍历列表：for/while
方法：[ ‘append’, ‘clear’, ‘copy’, ‘count’, ‘extend’, ‘index’, ‘insert’, ‘pop’, ‘remove’, ‘reverse’, ‘sort’]

增：
.append(元素) 列表尾部追加元素
.insert(下标，追加元素) 列表下标位置追加元素
列表1.extend(列表2) 列表2元素追加到列表1尾部
删：
.remove(元素) 
.pop(下标) 默认删除尾部元素，也可通过下标删除，并返回删除的元素
.clear() 清空列表
查：
.index(元素) 匹配到的第一个该元素的下标
.index(元素,start) 从哪一位开始查找

.count(元素) 计数
.copy() 浅拷贝
.reverse() 反转列表
.sort() 排序，只能用在只包含整型、浮点型的列表中。默认由小到大排序
.sort(reverse=True) 由大到小排序

集合set

基于哈希算法实现，元素不能重复，无序

set中有重复元素不会报错，会直接将重复的元素只保留一个。因此set可以用来去重
set的无序特性决定set是不能被访问的
定义：set={}
长度=lan(set)
遍历：for
方法：[‘add’, ‘clear’, ‘copy’, ‘difference’, ‘difference_update’, ‘discard’, ‘intersection’, ‘intersection_update’, ‘isdisjoint’, ‘issubset’, ‘issuperset’, ‘pop’, ‘remove’, ‘symmetric_difference’, ‘symmetric_difference_update’, ‘union’, ‘update’]

.add(元素) 追加元素
.pop() 移除任意一个元素
.remove(元素) 移除指定元素，指定的元素不存在时 会 报错
.discard(元素) 移除指定元素，指定的元素不存在时 不会 报错
set1.intersection(set2) 取交集
set1.union(set2) 取并集
set1.difference(set2) 取差集

元组tuple

不可变数据类型，有序

定义：tuple=()
注意()还可用来提高变量的优先级，如果tuple只有一个元素，需要在元素后写’,’
访问：tuple[下标]
长度=len(tuple)
遍历：for/while
元组中可以存放可变数据类型(列表)(的地址)作为元素，可以通过下标找到该元素，修改该元素的内部元素
方法:[ ‘count’, ‘index’]

tuple = (1,2,3,[1,2,3])
tuple[2] = 3 会报错
tuple[3][1] = 4 可以修改

.count(元素) 统计该元素个数
.index(元素) 查找第一个该元素在第几个下标处

字典

元素是键值对的形式

定义：dict={}
dict = {‘key1’:“value1”,‘key2’:“value2”,……}
修改添加：dict[‘key’]=value
方法:[‘clear’, ‘copy’, ‘fromkeys’, ‘get’, ‘items’, ‘keys’, ‘pop’, ‘popitem’, ‘setdefault’, ‘update’, ‘values’]
遍历

方法
.get(key,) 获取key的value
.keys() 获取字典中所有的key
.values() 获取字典中所有的value
.setdefault() 添加键值对
.del(键值对) 移除，可以移除任何变量
.fromkeys(列表) 以列表的元素为key，键为none 
.pop(key) 删除key对应的键值对，并返回key的value
.items() 以列表形式返回键值对，用来遍历字典
dict1.update(dict2) 合并字典。相同key的value，用dict2的value覆盖

遍历
打印元组形式的键值对
for i in dict.items():
    print(i)
打印value
for i in dict:
    print(dict[i])
分别获取k，v,以设定形式打印
for k,v in dict.items()
    print(f"{k}:{v}")

排序

冒泡排序

冒泡排序
a = [91,47,83,89,29,63,16,98,82,96]
l = len(a)
for i in range(l-1):
    for j in range(l-1-i):
        if a[j] > a[j+1]:
            a[j],a[j+1]=a[j+1],a[j]
print(a)
相邻两个数比较，进行排列

选择排序

找最小或最大值，放在开头或最后
a = [3,11,74,91,45,83,1,71,96,13]
for i in range(len(a)-1):
    max = i
    for j in range(i+1,len(a)):
        if a[j] > a[max]:
            max = j
        if max != i:
            a[max],a[i]=a[i],a[max]
print(a)

插入排序

将选择到的数，放置于比较的位置
a = [4,90,69,80,36,27,57,35,92,19]
for i in range(len(a)-1):
    for j in range(i+1,0,-1):
        if a[j] > a[j-1]:
            a[j],a[j-1]=a[j-1],a[j]
print(a)

二分查找

只能找有大小，排好序的内容
a = [1,7,8,9,22,33,36,37,41,45,64,65,67,71,74,77,79,81,87,88]
item = int(input("输入想获取的数:"))
left = 0
right = len(a)-1
while right >= left:
    mid = int((left+right)/2)
    g = a[mid]
    if g == item:
        print(mid)
        break
    elif g < item:
        left = mid + 1
    elif g > item:
        right = mid - 1
else:
    print("nothing")

函数

一段实现某特定功能的代码集合，本是上实现了代码的高度复用

定义
def 函数名(形参):
函数体
return 返回值
形参可以不给数据类型，也可以通过 ‘形参:数据类型’ 来提示实参的数据类型，但实际上没有约束作用
函数没有返回值时，默认返回none
调用
函数名(实参)

3.查看函数中的注释
- Help查看
- 函数名.doc

变量

本地(局部)变量：声明在函数内部的变量，也只能在函数内部访问，要想在函数外部进行访问，需要返回出去
全局变量：在单个项目内都可被访问
默认情况下，全局变量不允许在函数内部被更改

函数调用的本质

函数启动的瞬间，会至少生成一个执行栈，函数实在堆中存放的，每当函数被调用的时候，会进行压栈，在调用结束后，会立刻进行弹栈

值传递与引用传递

值传递：传递变量的值
引用传递：传递变量的地址

参数

默认值参数

大多数情况下，该参数的值不需要改变，书写的位置一般在正常参数的后面。方便用户调用函数
只能指向不可变数据类型。若是指向可变数据类型，会把固定值反复复制

可变参数

定义： *参数名
将传入的变量以元组的形式存起来
如果要传元组或列表，只需要在名称前加上 * ，即可把容器的元素分别传进去

def s(*num):
    j = 1
    for i in num:
        j *= i
    return j 
a = [16,64,43,93,46]
print(s(*a))

关键字(命名)参数

定义： **参数名
将传入的变量以字典的形式存起来
如果要传字典，只要在变量名前加上 **，即可将元素分别传进去

def text(name,age,**keyarges):
    print(f"name是{name},age是{age},其他信息是{keyarges}")

dict = {"job":"student","hobby":'eating'}
text('L',20,**dict)

函数作为参数传递

匿名函数 lambda表达式
lambda[参数]:函数体
自带return ，再写会报错

偏函数

为已有函数重新固定接下来某个默认参数的值，并返回一个全新的函数
int(num,base=进制) 默认以十进制进行转换

递归函数

分治思想：将大问题分成若干个与大问题性质相同的小问题，分别解决小问题以达到解决大问题的效果
函数内部本身就可以调用函数
递归函数：函数内部调用函数自身。用来解决能以分治思想解决的问题
书写递归函数时，要先写递归出来

字符串对象

在python里，字符串也是一种不可变数据类型
字符串也存在下标
定义：’ ’ " " a= “”" “”" a= ‘’’ ‘’'，三引号必须赋值给变量
方法
.capitalize:首字母大写，返回新的字符串
.center()：在指定个数的元素中居中
.count():统计指定元素的个数
.endwith():判断字符串是否以指定字符结尾返回布尔值
.startwith():判断是否以指定字符开头返回布尔值
.find(‘元素’,start,end):查找指定元素，返回从左start到end内找到的第一个下标。若指定元素不存在，返回-1
.index(‘元素’,start,end):查找指定元素，返回从左start到end内找到的第一个下标。若指定元素不存在，报错
.rfind():查找指定元素，返回从右start到end内找到的第一个下标。若指定元素不存在，返回-1
.rindex():查找指定元素，返回从右start到end内找到的第一个下标。若指定元素不存在，报错
.format():格式化字符串
.join():拼接
.split(元素):以指定元素为标志，提取标志后的字符串，返回列表
.upper():转大写
.lower():转小写
.strip():清除字符串两边空格
.title():每个单词首字母大写
.replace(被替换内容,替换内容):替换
.encode():转换编码格式，将字符串转为字节
.decode():将字节转换为编码

切片

下标只能提取单个元素，而切片可以提取多个有序元素用于输出或赋值
格式：[start🔚step]
start默认为0，end默认为len，step默认为1，范围为[start,end)
[::-1]:便捷倒叙输出
切片超出范围不会报错
start>end时，从左往右切片，step>0
start<end时，从右往左切片，step<0

模块

概念：.py结尾的文件就是一个模块，里面存放的是类、函数、数据
模块的导入：
import 模块名：实质是将模块名关联了文件的内存地址
from 模块名 import 成员：把模块中的某个成员导入到当前作用域
from 模块名 import * ：把模块中的全部成员导入到当前作用域中

如果带入的成员和自身的成员冲突，将执行距离更近的方法；也可以通过 from 模块名 import 成员 as 重命名解决
如果模块中存在以 _ 开头的成员，则该成员无法通过 from 模块名 import * 导入
模块导入时，会执行模块中的顶层代码，而函数中的代码，只有在调用的时候才会执行

模块的方法：
__all__ ：通过[‘成员’,‘成员’,···]指定能被导入的成员。all只会限制from 模块名 import * 的导入
__doc__ ：查看当前模块的注释
__file__ ：获取当前文件的绝对路径
__name__ ：显示模块的名字

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

math模块

math.ceil() ：向上取整
math.floor() ：向下取整
math.pow(数，次方) ：计算数的次方
math.sqrt() ：开方
math.exp() ：指数
全局函数round() ：对于奇数，严格遵守四舍五入，对于偶数，0.5以下的小数省略

time模块

时间的表示方式：时间戳、时间元组、格式化时间字符串
time.time() ：时间戳
time.localtion() ：时间元组
格式化时间字符串：
%Y 年 %m 月 %d 日 %H 时 %M 分 %S 秒
time.strftime(“%Y-%m-%d %H:%M:%S”)

time.asctime() ：接受时间元组，返回时间字符串
time.ctime() ：接收时间戳，返回字符串
time.gctime() ：接收时间戳，返回时间元组
time.sleep(时间s) ：使程序经过指定时间后再执行

datetime.datetime模块

[ ‘astimezone’, ‘combine’, ‘ctime’, ‘date’, ‘day’, ‘dst’, ‘fold’, ‘fromisocalendar’, ‘fromisoformat’, ‘fromordinal’, ‘fromtimestamp’, ‘hour’, ‘isocalendar’, ‘isoformat’, ‘isoweekday’, ‘max’, ‘microsecond’, ‘min’, ‘minute’, ‘month’, ‘now’, ‘replace’, ‘resolution’, ‘second’, ‘strftime’, ‘strptime’, ‘time’, ‘timestamp’, ‘timetuple’, ‘timetz’, ‘today’, ‘toordinal’, ‘tzinfo’, ‘tzname’, ‘utcfromtimestamp’, ‘utcnow’, ‘utcoffset’, ‘utctimetuple’, ‘weekday’, ‘year’]

random模块

random.randint() ：取[n1,n2]之间的随机数
random.random() ：取[0,1)之间的随机数
random.choice() ：在（有序）列表中随机选出一个元素，直接返回该元素
random.choices() ：在（有序）列表中随机选出元素，返回元素的列表

os模块

os.system(“命令”) ：帮助执行命令
os.cutdir() ：获取相对路径
os.getcwd() ：获取绝对路径
os.chdir() ：切换工作路径
os.lisdir() ：遍历文件夹
os.mkdir() ：创建文件夹
os.getlogin() ：获取当前用户名
os.getpid() ：获取当前进程号
os.getppid() ：获取上级程序进程号
os.sep() ：获取当前系统分隔符

os.path模块

path.abspath(‘路径’) ：获取该路径的绝对路径
path.altsep() ：获取分隔符
path.basename(‘路径’) ：获取路径的文件名
path.dirname(‘路径’) ：获取路径中除文件名的部分
path.exists(‘路径’) ：判断路径是否存在
path.isdir() ：判断文件夹
path.isfile() ：判断文件
path.link() ：判断连接
path.ismount() ：判断挂载文件
path.join(参数1，参数2) ：用分隔符拼接路径

遍历磁盘例子

import os 
from os import path
def getAllFile(url):
    try:
        files = os.listdir(url)
        for i in files:
            rel_url = path.join(url,i)
            if path.isdir(rel_url):
                getAllFile(rel_url)
            else:
                print(rel_url)
    except PermissionError:
        pass

sys模块

sys,argv() ：获取脚本（运行文件）名称，用户的传参。多个值以列表的形式返回
sys.getdefaultencoding() ：获取选择使用的编码
sys.getfilesysemencoding() ：获取文件系统的默认编码
sys.getrecurionlimit() ：获取递归限制
sys.setrecursionlimit() ：设置递归限制
sys.getrefcount() ：获取引用限制

uuid模块

用来生成一个不会重复的标识符
方法：[‘Enum’, ‘NAMESPACE_DNS’, ‘NAMESPACE_OID’, ‘NAMESPACE_URL’, ‘NAMESPACE_X500’, ‘RESERVED_FUTURE’, ‘RESERVED_MICROSOFT’, ‘RESERVED_NCS’, ‘RFC_4122’, ‘SafeUUID’, ‘UUID’, ‘getnode’, ‘int_’, ‘main’, ‘os’, ‘sys’, ‘uuid1’, ‘uuid3’, ‘uuid4’, ‘uuid5’]

hashlib模块

用于：1.数字校验 2.数据加密

.hexdigest():查看加密后对应的字符串
.update():更新字符串，可以往里面加盐值

hmac模块

专门用来进行数据加密的模块
hmac.new(‘盐’.encode(),‘被加密的数据’.encode(),‘算法’)

calender模块

日历模块
方法：[‘APRIL’, ‘AUGUST’, ‘Calendar’, ‘DECEMBER’, ‘Day’, ‘EPOCH’, ‘FEBRUARY’, ‘FRIDAY’, ‘HTMLCalendar’, ‘IllegalMonthError’, ‘IllegalWeekdayError’, ‘IntEnum’, ‘JANUARY’, ‘JULY’, ‘JUNE’, ‘LocaleHTMLCalendar’, ‘LocaleTextCalendar’, ‘MARCH’, ‘MAY’, ‘MONDAY’, ‘Month’, ‘NOVEMBER’, ‘OCTOBER’, ‘SATURDAY’, ‘SEPTEMBER’, ‘SUNDAY’, ‘THURSDAY’, ‘TUESDAY’, ‘TextCalendar’, ‘WEDNESDAY’, ‘_EPOCH_ORD’, ‘c’, ‘calendar’, ‘datetime’, ‘day_abbr’, ‘day_name’, ‘different_locale’, ‘error’, ‘firstweekday’, ‘format’, ‘formatstring’, ‘global_enum’, ‘isleap’, ‘leapdays’, ‘main’, ‘mdays’, ‘month’, ‘month_abbr’, ‘month_name’, ‘monthcalendar’, ‘monthrange’, ‘prcal’, ‘prmonth’, ‘prweek’, ‘repeat’, ‘setfirstweekday’, ‘sys’, ‘timegm’, ‘warnings’, ‘week’, ‘weekday’, ‘weekheader’]

calendar.month(2024,4):2024年4月的月历
calendar.weekday(2024,4,6):查看2024年4月6日是周几

文件操作

I/O流：input、output、stream
广义：指代计算机中的数据的输入与输出，网络中的通信
狭义：指代内存中的输入与输出
磁盘——内存（重要的缓存设备）——CPU
I/O必须手动关闭

I/O的分类：
根据数据的流动方向：(在内存的角度)
输入流：磁盘中的文件读取dia内存当中
输出流：把内存当中的数据存储在磁盘上
根据数据类型：
字节流(二进制)：图片、音频、视频等媒体文件
字符流：字符串(读取效率高)
要注意编码问题，不能够读取图片、音频、视频等媒体文件

python操作I/O流

open（“路径”，encoding=“解码编码”，mode=“权限（rwtb）”）

.read(“值”):读取文件全部内容。值表示每次读的数据量
.close():检测该I/O流是否关闭
.closeed():关闭I/O流
.name():获取I/O流名称
.readable():返回该I/O流是否可读
.readline():按行读取
.readlines():返回列表，元素为每行的内容
.writable():获取文件是否可写
.write(“内容”):写入内容。权限为w时,会覆盖原本的内容;权限为a时,会将内容追加至末尾
.flush():刷新文件

pickle对象、json对象

序列化：将逻辑上存在的对象，转换为字节，进行传输或保存
反序列化：将字符或字节转换为对象
持久化：将数据长久的存储在磁盘中
反持久化：

方法

.load(反持久化):不需要先读再序列化了
.loads(反序列化):
.dump(持久化):不需要手动序列化
.dumps(序列化)

面向对象编程

作业

43题-数字直角三角形

43题

43
cs = int(input("请输入打印层数："))
kg = ' '
#A
for i in range(1,cs+1):
    for j in range(1,i+1):
        print(j,end=' ')
    print(kg*(i-1),end=' ')
    print()
#B
for i in range(1,cs+1):
    for j in range(1,cs+2-i):
        print(j,end=' ')
    print(kg*(i-1),end=' ')
    print()
#C
for i in range(1,cs+1):
    print(kg*(cs-i)*2,end='')
    for j in range(i,0,-1):
        print(j,end=' ')
    print()
#D
for i in range(1,cs+1):
    print(kg*(i-1)*2,end='')
    for j in range(1,cs+2-i):
        print(j,end=' ')
    print()

49题-石头剪刀布

49题

49
import random
ai = random.randint(0,2)
p_score = 0
a_score = 0
while p_score < 2 or a_score < 2:
    player = int(input("请出012代表石头剪刀布:"))
    print("ai出：%d"%ai)
    if player == ai:
        ai = random.randint(0,2)
        print("平局")
    else:
        if ai == 0:
            if player == 0:
                ai = random.randint(0,2)
                print("平局")
            else:
                a_score += 1
                ai = random.randint(0,2)
                print("输")
        elif ai == 1:
            if player == 0:
                p_score += 1
                ai = random.randint(0,2)
                print("赢")
            else:
                ai = random.randint(0,2)
                print("平局")
        else:
            if player == 0:
                a_score += 1
                ai = random.randint(0,2)
                print("输")
            else:
                p_score += 1
                ai = random.randint(0,2)
                print("赢")
    print("你的得分为：%d，ai的得分为：%d"%(p_score,a_score))
else:
    print("游戏结束")

54题-闰年

54题

54
register = 0
for i in range(2001,2101):
    if i%4==0 and i%100!=0 or i%400==0:
        print(i,end=" ")
        register += 1
        if register%10==0:
            print()
        else:
            print(end='')
    else:
        continue

57题-回文整数

#57
n = int(input("请输入想判断的数:"))

def reverse(num):
    num2 = ''
    while num != 0:
        num2 += str(num%10)
        num = num//10
    print(int(num2))
    return int(num2)


def isPalidrome(num):
    if reverse(num) == num:
        print(f"{n}是回文数")
    else:
        print(f"{n}不是回文数")

isPalidrome(n)

63题-回文素数

#63
def isPrimeNumber(num):
    for i in range(2,num):
        if num % i == 0:
            return False
        else:
            return True

def reverse(num):
    num2 = ''
    while num != 0:
        num2 += str(num%10)
        num = num//10
    return int(num2)


def isPalidrome(num):
    if reverse(num) == num:
        return True
    else:
        return False
   

def isPaP(num):
    if isPalidrome(num)==True and isPrimeNumber(num)==True:
        return True
    else:
        return False


register1 = 0
register2 = 0
num = 1
while register1 < 100:
    while num < 3:
        print(f"{num}\t",end=' ')
        num += 1
        register2 += 1
    else:
        while register2 < 11:
            if isPaP(num) == True:
                print(f"{num}\t",end=' ')
                register1 += 1
                register2 += 1
                num += 1
            else:
                num += 1
                continue
        else:
            register2 = 0
            print()

66题-双素数

#66
def isPrimeNumber(num):
    for i in range(2,num):
        if num % i == 0:
            return False
        elif i==num-1:
            return True

def difference2(num):
    num2 = num + 2
    if isPrimeNumber(num)==1 and isPrimeNumber(num2)==1:
        return True
    else:
        return False

num = 1
while num <= 1000:
    l = []
    if difference2(num) == 1:
        l.append(num)
        l.append(num+2)
        print(tuple(l))
    l = l.clear
    num += 1

(3, 5) (5, 7) (11, 13) (17, 19) (29, 31) (41, 43) (59, 61) (71, 73) (101, 103) (107, 109) (137, 139) (149, 151) (179, 181) (191, 193) (197, 199) (227, 229) (239, 241) (269, 271) (281, 283) (311, 313) (347, 349) (419, 421) (431, 433) (461, 463) (521, 523) (569, 571) (599, 601) (617, 619) (641, 643) (659, 661) (809, 811) (821, 823) (827, 829) (857, 859) (881, 883)

69题-判断SSN是否有效

SSN有效特征

#69
def cutArea(SSN):
    SSN = SSN.replace('-','')
    area = SSN[:3]
    return area

def cutGroup(SSN):
    SSN = SSN.replace('-','')
    group = SSN[3:5]
    return group

def cutSerial(SSN):
    SSN = SSN.replace('-','')
    serial = SSN[5:]
    return serial

def isAreaValid(SSN):
    if cutArea(SSN) != '666' or cutArea(SSN) != '000':
        return True
    else:
        return False
    
def isGroupValid(SSN):
    if cutGroup(SSN)!='00' or cutGroup(SSN)>='01' and cutGroup(SSN)<='99':
        return True
    else:
        return False

def isSerialValid(SSN):
    if cutSerial(SSN)>='0001' and cutSerial(SSN)<='9999':
        if cutArea(SSN)=='987' and cutGroup(SSN)=='65':
            if cutSerial(SSN)>='4320' and cutSerial(SSN)<='4329':
                return False
            else:
                return True
        else:
            return True
    else:
        return False
    
def isValid(SSN):
    if isAreaValid(SSN)==1 and isGroupValid(SSN)==1 and isSerialValid(SSN)==1:
        print("Valid SSN")
        return True
    else:
        print("Invalid SSN")
        return False

SSN = input("请按照'aaa-bb-cccc'的格式输入您的SSN码：")
print(isValid(SSN))

71题-检测子串

#71
str1 = input("请输入str1：")
str2 = input("请输入str2：")
def findStr(str1,str2):
    if len(str1) > len(str2):
        str1,str2 = str2,str1
    if str1 in str2:
        return True
    else:
        return False
print(findStr(str1,str2))

84题-计算最大公约数

#84
a = eval(input("请按[a,b·····]的格式输入5个数字："))
def gcd(num):
    a = num[0]
    for i in range(1,len(num)-1):
        b = num[i]
        while b>0:
            a,b = b, a%b
        return a
print(gcd(a))

面向对象1

在这里插入图片描述

class Vehicle(object):
    def __init__(self,brand,color):
        self.brand = brand
        self.color = color

    def showInfo(self):
        print(f"车辆的型号为{self.brand},颜色为{self.color}")

class Car(Vehicle):
    def __init__(self,seat):
        super().__init__('大货车','white')
        self.seat = seat

    def showInfo(self):
        print(f"车的座位数为{self.seat}，车辆的型号为{self.brand},颜色为{self.color}")

if __name__ == '__main__':
    car1 = Car(8)
    car1.showInfo()

车的座位数为8，车辆的型号为大货车,颜色为white

面向对象2

在这里插入图片描述

class Shape(object):
    def area(self):
        return self.width*self.height

class Rectangle(Shape):
    def __init__(self,width,height):
        self.width = width
        self.height = height

    def perimeter(self):
        return (self.height+self.width)*2