💖说了0基础，就是0基础，中国人不骗中国人
🤞秋名山码民的主页🤞
🎉欢迎关注🔎点赞👍收藏⭐️留言📝
🙏作者水平很有限，如果发现错误，一定要及时告知作者
🤞所选内容来自菜鸟教程+自己理解🤞

前言

博主能力有限，帮助有限，但还是不希望看到同学挂科，毕竟老师讲的真的岌岌可危，写这篇博客的目的也很简单，就是以补挂科为前提而创作，码民的奖学金已经丢了，不希望有的人因为python而失去评奖，还是那句话，假如你不想要钱的话，什么活动都可以不参加，所以说我感觉我丢了，综测？牛马？可能不适合我这个人吧！话不多说，发车了，由于篇幅原因，打算分为2-3篇来写，还是从不挂科的角度来说的，所以说你想要提高，不建议以我的来看

一、python介绍（背）

简单来说一点考试常考的，就记忆一下就好，毕竟也不会让你重新来过🤣

• Python 是一种解释型语言： 这意味着开发过程中没有了编译这个环节。类似于PHP和Perl语言。
• Python 是交互式语言： 这意味着，您可以在一个 Python 提示符 >>> 后直接执行代码。
• Python 是面向对象语言: 这意味着Python支持面向对象的风格或代码封装在对象的编程技术。
• Python 是初学者的语言：Python 对初级程序员而言，是一种伟大的语言，它支持广泛的应用程序开发，从简单的文字处理到 Web 浏览器再到游戏。

有下列特点

1.易于学习：Python有相对较少的关键字，结构简单，和一个明确定义的语法，学习起来更加简单。
2.易于阅读：Python代码定义的更清晰。
3.易于维护：Python的成功在于它的源代码是相当容易维护的。
4.一个广泛的标准库：Python的最大的优势之一是丰富的库，跨平台的，在UNIX，Windows和Macintosh兼容很好。
5.互动模式：互动模式的支持，您可以从终端输入执行代码并获得结果的语言，互动的测试和调试代码片断。
6.可移植：基于其开放源代码的特性，Python已经被移植（也就是使其工作）到许多平台。
7,可扩展：如果你需要一段运行很快的关键代码，或者是想要编写一些不愿开放的算法，你可以使用C或C++完成那部分程序，然后从你的Python程序中调用。
8.数据库：Python提供所有主要的商业数据库的接口。
9.GUI编程：Python支持GUI可以创建和移植到许多系统调用。
10.可嵌入: 你可以将Python嵌入到C/C++程序，让你的程序的用户获得"脚本化"的能力。

缺点：
运行速度慢，有速度要求的话，用 C++ 改写关键部分吧。

二、基本语法

1. 格式

print(“Hello World”) # 注释

if True:
    # 缩进
    print("True")
else:
    print("False")

# 多行语句'\'
"total = item_one + \
        item_two + \
        item_tree"

数字类型

# int 整型
# bool 布尔型
# float 浮点型
# complex 复数 ，1+2j

“字符串”

注意：python中没有单独字符一说，比如c++中的char，，在python中’a’也是一个字符串

string
python中单引号和双引号使用完全相同
使用三引号‘’‘或“”“可以指定一个多行字符串
转义符
反斜杠可以用来转义，也可以用来不转义\

print("this is a line with \\n")
print(r'\n')

字符串连接方式

按照字面意思来连接字符串，”this"“is”“string"自动换为"this is string”
字符串可以使用+运算符连接，用*运算符重载
2种索引方式，从左往右，0开始，从右往左，-1开始
字符串不能更改
没有单独的字符类型，一个字符就是一个字符串
截取语法：变量[头下标:尾下标:步长]

paragraph = "这是一个段落，" \
           "可以由多行组成"

print(paragraph)
print(paragraph[0:-1]) # 输出从第一个到倒数第二个
print(paragraph[0]) # 第一个
print(paragraph[2:5]) # 第三个到第五个
print(paragraph[1:5:2]) # 第二个到第五个每次间隔2个
print(paragraph*2) # 2次
print(paragraph + '你好')
print("\n") # 空行分割

像下图一样

代码规范

python和其他高级语言一样，可以在一行中存在多条语句，在python中我们通过**分号;**来实现

代码组:缩进相同的一组语句称之为代码组
例如if while def class这样的复合语句

print输出最基本的用法

这块首先值得注意的一点就是python中的print，输出一个语句是默认换行的，要使其不执行换行操作，需要在末尾加上 end="" ,下面我们从代码中来看这个操作

print("l",end="")
print("y)

库

python简单，方便，有很大一部分原因就是取决于它的库实在是太多了，所以说我们不挂科的要求，也就是要了解库，会调用库

由于实在是太多了，我列举一俩个，其他的按照需求学习
俩种方式

import导入整个库
from…import…导入库中所需的那部分

import sys
print("----------")
print('命令行参数')
for i in sys.argv:
    print(i)
print('\npython 路径为：',sys.path)

from sys import argv,path #导入特定的成员
print('------------')
print('path:',path)
#因为已经导入path成员，所以此处引用不要加sys.path

基本数据类型

0基础，等号，=，左边是变量名，右边是数值

conunter = 100  #整型变量
miles = 1000.0 #浮点型变量
name = "runoob" #字符串

多个变量赋值

a = b = c = 1
a,b,c = 1,2,"runoob"

标准数据类型（难点）

先放个大纲
number(数字)
string(字符串)
list(列表)
tuple(元组)
set(集合)
dictionary(字典)

可以分为俩类

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

那么如何判断数据的类型呢？python中提供了俩种方式， type()函数 isinstance函数
区别：不要记了，涉及到了对象的知识

type不会认为子类是一种父类类型
isinstance会认为子类是一种父类类型

a, b, c, d = 20,5.5,True,4+3j
print(type(a),type(b),type(c),type(d))

a = 111
print(isinstance(a,int))

有如下的数值计算方式

加法，减法，乘法，除法/（浮点数），除法//（整数），取余%，乘方

需要注意以下：

1. Python可以同时为多个变量赋值，如a, b = 1, 2。
2. 一个变量可以通过赋值指向不同类型的对象。
3. 数值的除法包含两个运算符：/ 返回一个浮点数，// 返回一个整数。
4. 在混合计算时，Python会把整型转换成为浮点数。

#复数中实部和虚部都是浮点型
#string 0为开始值，-1为末尾开始的位置
#与 C 字符串不同的是，
# Python 字符串不能被改变。向一个索引位置赋值，比如word[0] = 'm'会导致错误。

列表

其实吧，这更像c++中数组的一个超集，

列表可以完成大多数数集合类的数据结构实现，列表中的元素的类型可以不相同，它甚至可以包含一个列表，叫做列表的嵌套

语法规则: [数据1，数据2，数据3]
索引与字符串一致，截取后返回一个包含所需要元素的新列表

实例

list = ['abcd',789,2.23,'runoob',7.02]
tinylise = [123,'runnoob']

print(list)
print(list[0])
print(list[1:3])
print(list[2:]) # 输出从第三个元素开始的所有元素
print(tinylise * 2)
print(list + tinylise)

总结以下：

1、List写在方括号之间，元素用逗号隔开。
2、和字符串一样，list可以被索引和切片。
3、List可以使用+操作符进行拼接。
4、List中的元素是可以改变的。

元组

列表可以修改，但是元组不可以修改元素
语法：tuple = ()

tuple = ( 'abcd', 786 , 2.23, 'runoob', 70.2  )
tinytuple = (123, 'runoob')

print (tuple)             # 输出完整元组
print (tuple[0])          # 输出元组的第一个元素
print (tuple[1:3])        # 输出从第二个元素开始到第三个元素
print (tuple[2:])         # 输出从第三个元素开始的所有元素
print (tinytuple * 2)     # 输出两次元组
print (tuple + tinytuple) # 连接元组

用一个例子来说明修改元组元素非法

tuple = (1,2,3)
tuple[0] = 11

1、与字符串一样，元组的元素不能修改。
2、元组也可以被索引和切片，方法一样。
3、注意构造包含 0 或 1 个元素的元组的特殊语法规则。
4、元组也可以使用+操作符进行拼接。

集合

集合（set）是由一个或数个形态各异的大小整体组成的，构成集合的事物或对象称作元素或是成员。
基本功能是进行成员关系测试和删除重复元素。
可以使用大括号 { } 或者 set() 函数创建集合，
注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空

sites = {'Google','taobao','qq','weixin','taobao'}
print(sites) # 输出集合，重复的元素会被自动去掉

#成员测试
if 'taobao' in sites :
    print("在")
else :
    print("不在")

集合是可以进行运算的

a = set('abracadabra')
b = set('alacazam')
print(a)
print(a - b)     # a 和 b 的差集
print(a | b)     # a 和 b 的并集
print(a & b)     # a 和 b 的交集
print(a ^ b)     # a 和 b 中不同时存在的元素

字典

列表是有序的对象集合，字典是无序的对象集合。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。
字典是一种映射类型，字典用 { } 标识，它是一个无序的 键(key) : 值(value) 的集合。
键(key)必须使用不可变类型。
在同一个字典中，键(key)必须是唯一的。

dict ={}
dict['one'] = "1-ye"
dict['two'] = "2-no"
print(dict['one']) #输出键为one的值
print(dict[2]) #输出键为2的值
print(dict) #输出完整的字典
print(dict.keys()) #输出所有键
print(dict.values()) #输出所有值

1、字典是一种映射类型，它的元素是键值对。
2、字典的关键字必须为不可变类型，且不能重复。
3、创建空字典使用 { }。n

python入门的进阶知识——运算

运算符

这个知识难亦或是不难，看你想要学到什么程度了，如果是期末不挂科的话，靠上一篇就已经够了，但是绩点嘛，还是要学一点的

位运算符

几乎是每个语言都是一样的，所以说我还是想啰嗦一下，当你开始学算法的时候，会发现这个东西是真的快，天下武功，唯快不破

&按位与 相应位为1，否则为0
|按位或 相应位有一个1，就为1
^按位异或 当俩对应的二进制位相异时，结果为一，
~按位取反，对于每个二进制位取反操作
<< 左移 运算数的各二进位全部左移若干位，高位丢弃，低位补0。
|>> 右移 把">>"左边的运算数的各二进位全部右移若干

a = 60  # 60 = 0011 1100
b = 13  # 13 = 0000 1101
c = 0

c = a & b  # 12 = 0000 1100
print("1 - c 的值为：", c)

c = a | b  # 61 = 0011 1101
print("2 - c 的值为：", c)

c = a ^ b  # 49 = 0011 0001
print("3 - c 的值为：", c)

c = ~a  # -61 = 1100 0011
print("4 - c 的值为：", c)

c = a << 2  # 240 = 1111 0000
print("5 - c 的值为：", c)

c = a >> 2  # 15 = 0000 1111
print("6 - c 的值为：", c)

逻辑运算符

and or not
3个，按照字面意思来理解

成员运算符

in x 在 y 序列中 , 如果 x 在 y 序列中返回 True。
not in x 不在 y 序列中 , 如果 x 不在 y 序列中返回 True

这个还是有用的，在c++中要单独定义函数

list1 = [1,2,3,4,5]
x=1
y=10
if(x in list1):
    print("a in list")
if(y not in list1):
    print("b not in list")

身份运算符

这个涉及到了对象，在期末编程解决问题的时候不用也能解决，

运算符的优先级问题

这个的考察形式有点像当年奥赛初赛的考察形式，就是阅读程序写答案的题，不能用电脑啊！，所以说要记忆

字符串加强

不得不说字符串的函数太多了，和c++还是有区别的，比c++多，使用也有些许不同，我根据题库来挑几个常用的，不要全记了，实在不会的话，暴力来解决，循环字符串，if判断，来达到自己的需求

合并，索引基本操作上一篇已经写过了，所以这一篇我们来说一点比较有用的东西，全学完可能有点困难，毕竟我们的目标是：不挂科

\ 转义：注意’\n’换行操作
r’\n’输出**\n.**
具体定义如下：
原始字符串 - 原始字符串：所有的字符串都是直接按照字面的意思来使用，没有转义特殊或不能打印的字符。

a = "Hello"
b = "Python"
 
print("a + b 输出结果：", a + b)
print("a * 2 输出结果：", a * 2)
print("a[1] 输出结果：", a[1])
print("a[1:4] 输出结果：", a[1:4])
 
if( "H" in a) :
    print("H 在变量 a 中")
else :
    print("H 不在变量 a 中")
 
if( "M" not in a) :
    print("M 不在变量 a 中")
else :
    print("M 在变量 a 中")
 
print (r'\n')
print (R'\n')

难点

格式化字符串，有点像强制转换的意思，了解即可，写题中可以不使用
常用的格式化字符串符号有以下几个

%c:格式化字符及其ASCII码
%s: 格式化字符串
%d:格式化整数
%o: 格式化无符号八进制数
%x:格式化无符号十六进制数

题外话：在 Python 中，字符串格式化使用与 C 中 printf 函数一样的语法。

print ("我叫 %s 今年 %d 岁!" % ('小明', 10))

内置函数

🤣多啊,怎么记?我就说一下我记的几个吧,感觉这几个还经常使用

find 查找:检测字符串中是否包含子字符串 str
语法:str.find(str, beg=0, end=len(string))
其中:str – 指定检索的字符串
beg – 开始索引，默认为0。
end – 结束索引，默认为字符串的长度。

也就是说我们可以这样写

str1 = "Runoob example....wow!!!"
str2 = "exam";
 
print (str1.find(str2))
print (str1.find(str2, 5))
print (str1.find(str2, 10))

通过len()函数返回字符串的长度

text='python'
len(text)

当你上面的都没有记住时,请记住replace这个函数 替换

s = 'abc12321cba'
 
print(s.replace('a', ''))

也就相当于一个删除操作,将s中的a都替换为" "
该字符串在Python中是不可变的，因此此函数将返回一个新字符串，而原始字符串将保持不变。

列表

这块注意索引,python中的列表更像c中数组的超集
从头开始

从尾开始

常用操作

插入,删除,还是一样的知道函数容易做,不知道函数也能做,索引+循环+判断,自己造一个出来就行了,列表允许修改

增加:append() 方法用于在列表末尾添加新的对象。

list = ['Google', 'Runoob', 1997, 2000]
 
print ("第三个元素为 : ", list[2])
list[2] = 2001
print ("更新后的第三个元素为 : ", list[2])
 
list1 = ['Google', 'Runoob', 'Taobao']
list1.append('Baidu')
print ("更新后的列表 : ", list1)

删除:del 语句

list = ['Google', 'Runoob', 1997, 2000]
 
print ("原始列表 : ", list)
del list[2]
print ("删除第三个元素 : ", list)

如果你一个函数都不记的话也不是不行,然后我们循环来写

#for 循环内部使用变量 in 列表
name_list = ["zhangsan","lisi","wangwu"]
for name in name_list:
    # 循环内部针对列表元素进行操作
     print(name)

元组

元组与列表最大的不同,就是元组不允许修改,在python中提供了一个函数可以将元组修改为列表

list() 方法用于将元组或字符串转换为列表。
相当于一个强制转换

#元组转换列表
aTuple = (123, 'Google', 'Runoob', 'Taobao')
list1 = list(aTuple)
print ("列表元素 : ", list1)
#字符串转换列表
str="Hello World"
list2=list(str)
print ("列表元素 : ", list2)

选看:元组为什么不能修改

我们从内存的角度来看

>>> tup = ('r', 'u', 'n', 'o', 'o', 'b')
>>> tup[0] = 'g'     # 不支持修改元素
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment
>>> id(tup)     # 查看内存地址
4440687904
>>> tup = (1,2,3)
>>> id(tup)
4441088800    # 内存地址不一样了

重新赋值的元组 tup，绑定到新的对象了，不是修改了原来的对象

字典和集合

考察的也不多,出来基本上没有编程大题,所以秉承着不挂科的原则,我就不说了,我们来看条件语句+循环语句,这个才是期末考试的重点

条件控制

这个应该是高中学过的吧🤞

if a:
	print(a)
elif b:
	print(b)
else:
	print(c)

如果a为true，打印a
如果a为false，但是b为true，打印b
如果a，b都为false，则打印c
记得加 : 使用缩进来区分

简单的猜数字案例

number = 7
guess = -1
print("数字猜谜游戏!")
while guess != number:
    guess = int(input("请输入你猜的数字："))
 
    if guess == number:
        print("恭喜，你猜对了！")
    elif guess < number:
        print("猜的数字小了...")
    elif guess > number:
        print("猜的数字大了...")

if 嵌套

在嵌套 if 语句中，可以把 if…elif…else 结构放在另外一个 if…elif…else 结构中。

num=int(input("输入一个数字："))
if num%2==0:
    if num%3==0:
        print ("你输入的数字可以整除 2 和 3")
    else:
        print ("你输入的数字可以整除 2，但不能整除 3")
else:
    if num%3==0:
        print ("你输入的数字可以整除 3，但不能整除 2")
    else:
        print  ("你输入的数字不能整除 2 和 3")

循环语句

格式：while 判断条件：
执行语句……

值得注意的一点是python中没有do……while……循环

例题：

n = 100
 
sum = 0
counter = 1
while counter <= n:
    sum = sum + counter
    counter += 1
 
print("1 到 %d 之和为: %d" % (n,sum))

还记得我高中最开始学循环的时候，有的算法题目不会，提交的时候给它整一个死循环，来个玉石俱焚

var = 1
while var == 1 :  # 表达式永远为 true
	print(var)

for语句：
for 循环可以遍历任何可迭代对象，如一个列表或者一个字符串

languages = ["C", "C++", "Perl", "Python"]
for x in languages:
    print (x)

当你入门的时候，应该用过这样一个函数，range（），目的就是生成一个数列

for i in range(5,9)#区间
	print(i)
for i in range(5)
	print(i)
for i in range(0,10,3)#间隔3，也可以说是步长为3
	print(i)

break和continue和else

break

n = 5
while n > 0:
    n -= 1
    if n == 2:
        break
    print(n)
print('循环结束。')

continue

n = 5
while n > 0:
    n -= 1
    if n == 2:
        continue
    print(n)
print('循环结束。')

例子：
循环字符串 Runoob，碰到字母 o 跳过输出

for letter in 'Runoob':     # 第一个实例
   if letter == 'o':        # 字母为 o 时跳过输出
      continue
   print ('当前字母 :', letter)
 
var = 10                    # 第二个实例
while var > 0:              
   var = var -1
   if var == 5:             # 变量为 5 时跳过输出
      continue
   print ('当前变量值 :', var)
print ("Good bye!")

对比之下，可以变成检测字符串中是否有一个字符，也就是我们，上面记忆的函数，所以我才敢说字符串函数不用全部记忆

else:循环语句可以有 else 子句，它在穷尽列表(以for循环)或条件变为 false (以while循环)导致循环终止时被执行，但循环被 break 终止时不执行。

for n in range(2, 10):
    for x in range(2, n):
        if n % x == 0:
            print(n, '等于', x, '*', n//x)
            break
    else:
        # 循环中没有找到元素
        print(n, ' 是质数')

pass语句：这个是为了程序的完整性而出现的，没有实际的意义

for letter in 'Runoob': 
   if letter == 'o':
      pass
      print ('执行 pass 块')
   print ('当前字母 :', letter)
 
print ("Good bye!")

函数

函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段

万物存在即有它的价值，像你我一样，试想一下，函数存在的意义是什么？从定义来看，可重复利用，假如要实现俩个数的交换操作，a，b交换
当然在python中可以写a，b = b，a这样的语句，但是你是不是每次都要写？
如果写一个函数，只需要传入俩个参数就实现交换数字的操作，a，b又亦或是c，d

def swap(a,b):
　　# 创建临时变量，并交换
    temp = a
    a = b
    b = temp
    print(a,b)

用上面这个例子来说明，函数的基本用法

定义一个函数

1. 函数代码块以 def 关键词开头，后接函数标识符名称和圆括号 ()。
2. 任何传入参数和自变量必须放在圆括号中间，圆括号之间可以用于定义参数。
3. 函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
   函数内容以冒号 : 起始，并且缩进。
4. return [表达式] 结束函数，选择性地返回一个值给调用方，不带表达式的 return 相当于返回 None。

下面我们来做一个例子，返回最大值的函数

def max(a, b):
    if a > b:
        return a
    else:
        return b
 
a = 4
b = 5
print(max(a, b))

函数调用

实际上你刚刚在不经意间已经调用了max，没错就是这么的简单，

def max(a, b):
    if a > b:
        return a
    else:
        return b
 
a = 4
b = 5
print(max(a, b))
print("再次调用max",max(5,6))

参数

这个老师讲的岌岌可危，虽然我旷课，但是基本概念还是没有问题的，下面让我这个小小码民来说一下几个必要的概念

• 实参：函数实际传入的参数
• 形参：函数（）中提前定义的参数

四大参数

1. 位置参数：函数的参数传入的位置
2. 默认参数：形参和实参可以不一致，如果不想使用默认的参数，在调用函数的时候可以指定(调用函数时，默认参数的值如果没有传入，则被认为是默认值)，即max(5,6)
3. 可变参数:a代表可变参数，a使元组数据类型
   def mysum(*;a)可变参数在函数调用时候，自动组装为一个元组（tuple）
4. 关键字参数:关键字参数允许你传入0个或任意个含参数名的参数，0意味着关键字参数可填可不填，这些关键字参数在函数内部自动组装为一个dict。

实际上这么多函数参数，理解形参和实参就够用了，毕竟看了题库后，函数的考察还是停留在应用上，我们的目的就是不挂科，

题库解答

累加思想

这类题目有一个特点就是，给你一串数字，或直接是一个列表，然后让计算数值，一般情况下，定义一个sum=0，来累加sum，从而解决问题

题目：请补充横线处的代码。dictMenu中存放了你的双人下午套餐（包括咖啡2份和点心2份的价格，让Python帮忙计算并输出消费总额。
要求：输出一个数字

dictMenu = {'卡布奇洛':32,'摩卡':30,'抹茶蛋糕':28,'布朗尼':26}
sum = 0
for i in dictMenu.values():
  sum +=  i
print(sum)

这是字典，对于字典的值的遍历，详细可参考前面的文章

多重判断

通俗的来讲就是if判断，if嵌套判断，循环语句中使用if

题目：从键盘为一维整型数组输入10个整数，找出其中最小的数，
在main函数中输出。
要求：采用内置函数完成

思路：
定义一个最小的值，用for循环各个元素逐个与min进行比较，或者直接用min函数

def main():
    list_first = []
    for i in range(10):
        a = input("【请分别输入10个整数，每输入一个整数按回车确认:】")
	x = min(a)
    print("【最小数是：】%d " % x);
if __name__ == '__main__':
    main()

或者这样：

for i in range(10):
	if x>a[i]:
		a[i] = x

水仙花数，回文是出现次数比较多的入门题，和我高中初赛差不多，都是入门，给定一个概念来考察循环+判断，也比较简单，但是很有必要学一下

水仙花数

所谓“水仙花数”是指一3位数，其各位数字立方和等于该数本身。
153是一个水仙花数，因为153=1+125+27
首先我们要学一下，如何来计算个，十，百，各位的数字
a=153 ge=a%10取余 shi=a//10%10 a除10为百位，百位取余为个 bai=a//100

好了，我们来看题

def fun(i):
    ge = i % 10
    shi = i // 10 %10
    bai = i // 100
    if (ge**3+shi**3+bai**3 == i):
    	return 1
    else:
    	return 0

def main():
    print("【请连续判断四次输入的三位数是否为水仙花数：】")
    for n in range(4):
        print("【第%d次：】" %(n+1))
        a = int(input("【请输入一个三位数，并按回车确认:】"))
        flag=fun(a)
        if flag:
            print("%d是【水仙花数】" %a)
        else:
            print("%d不是【水仙花数】" %a)
if __name__ == '__main__':
    main()

回文——字符串

由于回文的特殊性，所以将它与字符串迭代起来考察就成了特别好的入门习题了，也导致在考试中频繁出现，所以说这个必看！与水仙花数重要性是一样的

abcdcba是回文。abcdefg不是回文。也就是反转字符串，还是老样子笨办法和函数办法

函数办法：

s = input('')
if not s:
    print('请不要输入空字符串！')
    s = input('请重新输入一个字符串：')
a = reversed(list(s))#函数反转
if list(a) == list(s):#强制转换列表
    print('是回文')
else:
    print('不是回文')

循环笨办法：

s[0:len(s)//2]==s[-1:len(s)//2:-1]
python很强大，可以逆着来判断，但是在c中可能要求比较多

列表插入

ls 是一个列表，内容如下：
ls = [123, “456”, 789, “123”, 456, “789”]
请补充如下代码，在 789 后增加一个元素 012。

ls.insert(2,012) #插入函数

质(素)数判断

质数是指在大于1的自然数中，除了1和它本身以外不再有其他因数的自然数。

想要判断一个素数，首先要进行一个特殊判断，因为<2的数都不是素数

x = int(input())
if x<2:
	print("f")

接下来，我们要进行大于2的数的判断。方法就是：用数x对从2到x平方根依次取模，如果结果为0，说明x不是质数，如果一遍判断下来取模结果都不为0，则说明x为素数

import math
x = int(input())
f = 0

for i in range(2,int(math.sqrt(x))):
	if x % i == 0:
		print("f")
		f = 1

if f = 0:
	print("t")

用户自定义函数就如下所示：

import math

def isprime(x):
    if x<2:
        return "F"

    for i in range(2,int(math.sqrt(x))+1):
        if x % i == 0:
            return "F"

    return "T"

x = int(input())
print(isprime(x))

最后

还有就是几个画图的库，由于自己也没有学，所以还希望大家能自学一下，主要是记忆为主，毕竟以后也不一定用python做为主语言来进行工作，如果我有时间会在考试前做一个背诵专题，一切以时间的充分为主，过几天会写一个go+语言的推广，还请大家来捧场，这个是有奖金的，说白了我穷，可怜一下这个小博主吧！🤞

由于博主不是python出身，所以只能根据题库所写，与网上资源，和自己自学理解，来搞出这个不挂科系列，如有不足，还请评论区指教，感谢大家的支持，原创不易，给个三连😁。