1.
基础阶段
1.1
课程定位
（
1
）从行业角度来说：开发、网安、云原生、都会用到编程相关的技术
（
2
）从校招角度来说：所有
IT
岗位都会对学生编程能力进行考查
（
3
）
Python
相对而言比较简单，容易入手，比较好学
1.2
学习方法
（
1
）逢山开路，遇水架桥：学习编程的核心并不是仅局限于语法，而是在于如何利用语法去解决实际的
计算机问题
（
2
）观千剑而识器，操千曲而晓声：学习编程没有捷径，只有不停地多敲，多练，多解决问题，只有量
变才能质变
（
3
）应该将编程的学习当成一个长期的任务去执行
（
4
）前期的编码，禁止使用各种高级的编码软件（
PyCharm
，
Eclpise
）
,
必须要做到一点，一字一字地
去敲代码
（
5
）推荐了两个题集，不要眼高手低
1.3
软件概述
软件的定义
是指一些按照特定顺序组织的能够被计算机识别的数据与指令的集合
在解决问题的时候，一定要先分析问题（把解决问题的步骤先一步一步列出来，然后再利用编程语言进
行编码）
软件的分类
操作系统软件：
Windows Android IOS Harmony
主要负责管理和调控计算机硬件，给用户提供最基本的计算机功能（磁盘管理，上网管理，内存管理，
用户管理
......
）
应用软件：微信 优酷 支付宝 网易云
提供专业领域服务的软件，是基于操作系统软件运行的
编程语言
机器语言：所有的数据都是由
0
和
1
组成，人看不懂，机器能看懂
汇编语言：
1 2 add
，必须要考虑计算机的执行过程，门槛比较高
高级语言：
C C++ Java Python JavaScript....
，以人类的角度设计的，对学习者非常友好，但是计算机就
看不懂了
进阶知识：
静态编译型：
C C++ Java
动态解释型：
Python JavaScript
（脚本语言）
编译与解释的区别：
静态与动态的区别：
静态对于变量有明确的类型定义的 动态对变量没有明确类型定义的
在
C C++ Java
中，基本数据类型变量（将常量数据存储在变量空间当中）
int
a
=
3
;
int
b
=
4
;
在
C C++
中，指针变量（存储的是变量的物理内存地址）
int
a
=
3
;
int*
b
;
b
= &
a
;
int**
c
;
c
= &
b
;
printf
(
"%d"
,
&
c
);
//0x789
printf
(
"%d"
,
*
c
);
//0x123
printf
(
"%d"
,
&**&
c
);
//0x456
在
Java
中，引用数据类型变量（将对象在堆内存中的地址给变量）
Object
obj
=
new
Object
();
Object
obj2
=
obj
;
动态语言（所有的数据都是对象！所有的变量都是引用数据类型变量）
var
a
=
1
var
b
=
1.1
b
=
new
object
();
3 / 25
1.4
安装环境
Python
开发工具包
http://python.p2hp.com/downloads/windows/index.html
如何验证安装成功：
win+R
输入
cmd
打开控制台 输入
python
命令
如果没有出现
3.12.1
的提示，去找到
Python
的安装目录：
C:\Users\Administrator\AppData\Local\Programs\Python\Python312
我的电脑图标，邮件，属性，高级系统设置，环境变量，
Path
，双击，新建，粘贴路径，确定，确定，
确定，重新打开
CMD
窗口测试
VSCode
https://code.visualstudio.com/
1.5
脚本与交互
交互模式
打开
CMD
窗口，输入
python
指令，进入到了
python
交互模式
print()
输出函数，输出的内容写在一对小括号中
print(XXX)
弊端：代码不能持久保存，代码随着窗口关闭而消失
C:\Users\Administrator>python
Python 3.12.1 (tags/v3.12.1:2305ca5, Dec 7 2023, 22:03:25) [MSC v.1937 64 bit
(AMD64)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>>
C:\Users\Administrator>python
Python 3.12.1 (tags/v3.12.1:2305ca5, Dec 7 2023, 22:03:25) [MSC v.1937 64 bit
(AMD64)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>> print("Hello Wolrd!")
Hello Wolrd!
>>> print(1 + 2)
3
我们一般在做简单的代码演示、测试会使用到交互模式
为了永久保存代码，需要脚本模式
脚本模式
打开
VSCode
，
File
，
New Folder
，选择代码目录，
New File
按钮创建文件，输入名称和后缀名
(.py)
注意：一定要养成随时按
crtl+s
的习惯 保存
如何运行
Python
脚本文件呢
打开
CMD
窗口，进入到代码目录路径
指令：
python XXX.py
运行
XXX.py
文件
1.6
基本数据
Python
能够操作的数据都有哪些
常量
不能够改变的量
-
字面量
整数常量
注意：没有
byte short long
之分 一律默认
int
小数常量
注意：没有
float
与
double
之分 默认
float
字符串常量
字符串表示一段文本信息，程序会将文本信息原封不动的处理
>>>
print
(
10
)
#
十进制
10
>>>
print
(
0b1001
)
#
二进制
binary
9
>>>
print
(
0o12
)
#
八进制
Oct...
10
>>>
print
(
0x12
)
#
十六进制
Hex...
18
123
%
7
=
4
17
%
7
=
3
2
%
7
=
2
234
七进制
4
*
7
^
0
+
3
*
7
^
1
+
2
*
7
^
2
=
4
+
21
+
98
=
123
>>> print(1.34)
1.34
>>> print(0.12e10) #0.12*10^10
1200000000.0
>>> print("1+2+3")
1+2+3
>>> print('1+2+3')
1+2+3
Python
没有字符的数据，一律当成字符串处理，双引号和单引号都可以表示字符串
>>> print("
张老师说
:"
好好学习
"")
File "<stdin>", line 1
print("
张老师说
:"
好好学习
"")
^^^^^^^^^^^
SyntaxError: invalid syntax. Perhaps you forgot a comma?
>>> print("
张老师说
:'
好好学习
'")
张老师说
:'
好好学习
'
布尔值常量
只有两个值
True
，
False
，
T
和
F
是大写的
>>>
print
(
True
+
1
)
2
>>>
print
(
False
+
1
)
1
True
如果参与运算默认为
1 False
默认为
0
，这种有意义吗？
复数常量
>>> 1+2j
(1+2j)
>>> complex(1,2)
(1+2j)
>>> (1+2j)*(1-2j)
(5+0j)
标识符
就是我们程序员自定义的一些名称（变量 函数 类）
规则：
由字母、数字、下划线、美元符组成
数字不能开头
是一个连续的词，中间不能有空格分开
规范：
小驼峰：变量 函数 多个单词出现时 第一个单词首字母小写 之后单词首字母都大写
myName
大驼峰：类
所有单词首字母大写
MyName
下划线分割：单词之间用下划线分割 不大写
my_name
起的任何名字必须有含义，就算英文单词记得不多，也可以允许用拼音
关键字
就是一些单词，被
Python
赋予了特殊的含义，不能随便使用
6 / 25
>>> keyword.kwlist
['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break',
'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for',
'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or',
'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']
内置函数名
/
类名
内置函数就是
Python
自带的一些具有特殊功能的函数
>>> print(123)
123
>>> print = 3
>>> print + 4
7
>>> print(7)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'int' object is not callable
>>> print(3)
3
>>> show = print #
把
print
指向的那个函数给了
show
>>> print = 3 #
把
3
对象的地址给了
print
>>> print + 4
7
>>> show(7)
7
所以，我们在使用内置函数的时候，一定要注意名称不能够被更改
>>>
max
(
432
,
5443
,
1
,
2
,
5
,
6
,
78
,
4
,
5
,
435
)
5443
>>>
max
=
10
>>>
max
(
1
,
2
,
3
)
Traceback
(
most recent call last
):
File
"<stdin>"
,
line
1
,
in
<
module
>
TypeError
:
'int'
object
is not
callable
注释
单行注释
#
后面就是注释的内容 直到换行为止
多行注释
"""
中间多行注释
"""
变量
在
Python
当中 变量其实就是一个万能箱子 他可以存储任何数据
本质：变量它只存储数据在内存中的地址（引用类型变量）
数据类型 变量名
=
数据
# C Java
1.7
数据转换
数据类型转换
int()
将其他有效的数据转为整数
取整
从字符串中解析整数
变量
=
数据
单独定义一个变量时
>>> a = 1
>>> b = 2
同时定义多个变量，给定多个数据
>>> a, b, c = 1, 2, 3
>>> a
1
>>> b
2
>>> c
3
多个变量的值是一样的
>>> a = b = c = 1
>>> a
1
>>> b
1
>>> c
1
int a = (int) 3.14;
>>> int(3.14) #
将小数进行取整操作
3
>>> int("123") #
将数字字符串进行解析（默认十进制），解析出一个整数
123
>>> int("123abc")
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: invalid literal for int() with base 10: '123abc'
>>> int("AD", 16) #
将数字字符串进行十六进制解析，结果都是十进制
173
# 10*16^1 + 13*16^0 = 173
>>> int("91A", 12)
1318
>>> 10 * 12 ** 0 + 1 * 12 ** 1 + 9 * 12 ** 2
1318
>>> int("A1F", 13)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: invalid literal for int() with base 13: 'A1F'
>>> int("91a", 100)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: int() base must be >= 2 and <= 36, or 0
base
进制基数
= [2, 36]
>>> int("98*!",12) #
出现特殊符号
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: invalid literal for int() with base 12: '98*!'
>>> int("10010101") #
注意坑 二进制串特不一定是二进制数字
10010101
>>> int("10010101", 2)
149
float()
：将其他的数据转为小数
>>> float(3)
3.0
>>> float(3.14)
3.14
>>> float("3.14")
3.14
>>> float("3.14", 10)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: float expected at most 1 argument, got 2
str()
：将其他数据转字符串
>>> str(123)
'123'
>>> str(3.14)
'3.14'
>>> str(print)
'<built-in function print>'
bool()
：将其他数据转布尔类型
#
对于数值类型的话 非
0
全是
True 0
就是
False
>>> bool(1)
True
>>> bool(-1)
True
>>> bool(0)
False
>>> bool(3.14)
True
>>> bool(-3.14)
True
9 / 25
>>> bool(0.0)
False
#
对字符串 空串为
False
非空为
True
>>> bool("abc")
True
>>> bool("") #
空串
False
进制转换
>>> bin(123) #
转二进制字符串
'0b1111011'
>>> oct(123) #
转八进制字符串
'0o173'
>>> hex(123) #
转十六进制字符串
'0x7b'
>>> bin("123") #
参数必须是整数
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'str' object cannot be interpreted as an integer
>>> bin(3.14)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'float' object cannot be interpreted as an integer
字符与
ASCII
码转换
a~z A~Z 0~9
他们在
ASCII
中的编号都是连续的
ord()
：获取字符对应的
ASCII
码编号
>>> ord('a')
97
>>> ord('A')
65
>>> ord('0')
48
chr()
：根据给定的
ASCII
码编号获取对应的字符
>>> chr(98)
'b'
>>> chr(57)
'9'
A = 10 B = 11 ...... F = 15
13 - D
chr(ord('A') + 13 - 10)
常见的数学计算
1.8
输入与输出
input()
print()
>>> abs(3.14) #
取绝对值
3.14
>>> abs(-3.14)
3.14
>>> pow(2, 4) #
求
a
的
b
次幂
16
>>> pow(2.0, 4)
16.0
>>> pow(16, 0.5)
4.0
>>> max(1, 2, 3, 4) #
求最值问题
4
>>> min(1,2,3,4)
1
>>> round(3.14) #
四舍五入
3
>>> round(3.51)
4
#num = int(input("
请输入一个数字
:"))
num
=
eval
(
input
(
"
请输入一个数字
:"
))
# input()
默认输入的是一个字符串
(
整行
)
print
(
num
+
1
)
"""
TypeError: can only concatenate str (not "int") to str
反向证明输入的是字符串
ValueError: invalid literal for int() with base 10: '123 456'
"""
#
处理一行内多个数据的输入
# eval
处理的数据必须要有逗号分隔
# eval
自动处理字符串解析
# eval
既可以处理单值 也可以处理多值
"""
请输入两个数字
:123,456
579
"""
num1
,
num2
=
eval
(
input
(
"
请输入两个数字
:"
))
print
(
num1
+
num2
)
print
(
"Hello World"
)
print
(
1
+
2
+
3
)
print
(
1
,
2
,
3
,
"Hello World!"
)
#
多数据输出 用空格分隔
print
(
1
,
2
,
3
,
sep
=
"#"
)
# sep
默认空格
1.9
运算符
算数运算符
加法：数值相加，序列拼接
减法：数值相减
乘法：数值相乘，序列增倍
除法：小数除
/
，整数除
//
整数除 只要两边都是整数 结果一律为整数 但凡有一个小数 结果就是小数（只有整数位，小数位都为
0
）
幂运算
print
(
1
,
2
,
3
,
end
=
"!!!"
)
# end
输出的解围 默认
"\n"
# print(*args, sep=' ', end='\n', file=None, flush=False)
print
(
1
,
2
,
3
,
end
=
"!!!"
)
print
(
"Hello World"
,
end
=
"!!!"
)
print
(
"Hello World"
,
end
=
"!!!"
)
print
()
#
单独一个
print
换行的意思 其实打印的是空串
#
格式化输出
name
=
"
旺财
"
age
=
18
height
=
1.23
print
(
"
它叫
"
,
name
,
"
，今年
"
,
age
,
"
岁
"
,
sep
=
""
)
# %s
对应字符串
%d
对应整数
%f
对应小数
print
(
"
它叫
%s
，今年
%d
岁，身高
%.2f
米
"
%
(
name
,
age
,
height
))
>>> 1 + 2
3
>>> "123" + "456"
'123456'
>>> 3 * 6
18
>>> "
我爱你
" * 3
'
我爱你我爱你我爱你
'
>>> 10 / 2
5.0
>>> 10 // 2
5
>>> 10 / 3
3.3333333333333335
>>> 10 // 3
3
>>> 10.0 // 3
3.0
>>> 10.5 // 3
3.0
12 / 25
>>> 2 ** 3
8
>>> 16 ** 0.5
4.0
取余：
10 / 3 = 3 ~ 1
>>> 10 % 3
1
取余经常用于哪些场景，带有数据重复或循环的情况
22
日对应周五，
22 % 7 = 1
余数为
1
则对应周五
0
对应周四
....
30 % 7 = 2
对应周六
布尔判断运算符
运算结果一律为布尔值
大于 小于 大于等于 小于等于 不等于 等于
> < >= <= != ==
Python
允许连续比较
>>> 1 < 2 < 3
True
>>> 1 < 2 and 2 < 3
True
在
Python
当中
==
到底比得是啥？
答：比的是具体对象的值
>>> a = 1
>>> b = 1
>>> id(a) # id
取变量中存储的数据对象在内存中的地址
140715464473016
>>> id(b)
140715464473016
>>> a = 1000
>>> b = 1000
>>> id(a)
3267440575376
>>> id(b)
3267440589968
可以发现
a
和
b
在为
1000
时 对象地址不一样？
因为在
Python
当中 只有
-5~256 Python
会自动创建这些数据对象，提供给调用者使用
也就意味着如果创建该范围之外的数据对象的话，
Python
则重新创建新的对象出来
a = 1000, b = 1000
其实是两个
1000
数据的对象
a == b
比的是对象的内容 但是
a
和
b
存的地址不一样
a = 1, b = 1,
其实只有一个
1
数据的对象
a == b
比的是对象的内容 但是
a
和
b
存的地址一样
增强型赋值运算符
+= -= *= /= //= **= %=
a += 2
a = a + 2
b **= 2
b = b ** 2
额外多说一句：在
Python
中 是不存在
++ --
这种自增运算符的！
int
i
=
1
;
i
++
;
System
.
out
.
println
(
i
);
System
.
out
.
println
(
i
++
);
int
j
=
i
++
;
System
.
out
.
println
(
i
);
System
.
out
.
println
(
j
);
i
=
i
++
;
System
.
out
.
println
(
i
);
i
=
i
++
;
System
.
out
.
println
(
i
);
i++
流程
1.
开辟临时存储区
2.
将
i
的值复制到临时存储区内
3. i
自身
+1
4.
临时存储区的值等待被调用（输出 赋值 参与运算）
System
.
out
.
println
(
x
++ + ++
x
+ ++
x
+
x
++
);
// 12
System
.
out
.
println
(
x
);
// 5
逻辑运算符
与 或 非
= and or not
（
&& || !
）
与：全真则真 有假则假
或：有真则真 全假则假
非：取反
>>> 1 < 2 and 2 < 3
True
>>> 1 < 2 or 2 > 3
True
>>> not 1 < 2
False
&
与
&&
的区别
int x = 0;
int y = 0;
System.out.println(x++ < 0 & y ++ < 0); //
无论左边是否为假 右边都要计算
System.out.println(x); //1
System.out.println(y); //1
int x = 0;
int y = 0;
System.out.println(x++ < 0 && y ++ < 0); //
如果左边是假 右边不计算
System.out.println(x); //1
System.out.println(y); //0
&&
就是为了避免一些没有必要的计算 提高效率
位运算符
&
按位与
>>> 13 & 7
5
1101
0111
0101 = 5
|
按位或
>>> 13 | 7
15
1101
0111
1111 = 15
>>
右移
>>> 16 >> 2
10000
100|00
100 = 4
16 / 2 ^ 2
<<
左移
>>> 2 << 3
16
0010
0010000
10000 = 16
2 * 2 ^ 3
~
取反 符号取反再减
1
>>> ~15
-16
01111 = 15
10000 = -16
^
异或：相等为假 不同为真
>>> 13 ^ 7
10
1101
0111
1010 = 10
关于变量交换值
a = 1
b = 3
temp = a
a = b
b = temp
a, b = b, a # Python
自带的交换特点
只针对整数
a = 10
b = 100
a = a + b # 110
b = a - b # 10
a = a - b # 100
只针对整数
a = a ^ b
b = a ^ b
a = a ^ b
成员运算符
in
和
not in
判断一个元素是否在另一个序列中
>>> "abc" in "sakjdgjhsgadugashjdvasvdjgsa"
False
>>> "abc" in "sakjdgabca"
True
>>> 1 in [2,3,4]
False
从属
/
身份运算符
is
和
not is
判断两个变量指向的对象是否是同一个对象（比地址）
>>> a = 1
>>> b = 1
>>> a == b
True
>>> a is b
True
>>> a == 1000
False
语法基础编程练习
Demo01
Demo02
Demo05
>>> a = 1000
>>> b = 1000
>>> a == b
True
>>> a is b
False
>>> a = "abc" #
字符串
>>> b = "abc" #
之前已经创建了
"abc"
这里直接复用 而不是重新创建 跟整数是有区别的
>>> a == b
True
>>> a is b
True
>>> id(a)
140715463387184
>>> id(b)
140715463387184
"""
数据：
cel fah
步骤：
1.
输入
cel
2.
根据给定公式计算
fah
3.
输出
fah
"""
cel
=
eval
(
input
())
fah
=
9
/
5
*
cel
+
32
print
(
"%.1f"
%
fah
)
"""
数据：
radius length area volume
步骤：
1.
输入
radius
和
length
2.
计算
area
底面积
3.
计算
volume
体积
4.
输出
"""
radius
,
length
=
eval
(
input
())
area
=
radius
*
radius
*
3.14159267
volume
=
area
*
length
print
(
"%.2f"
%
area
)
print
(
"%.2f"
%
volume
)
"""
数据：
num ge shi bai total
步骤：
1.
输入一个数字
[0,1000
）
2.
按照顺序 从右往左拆
123 % 10 = 3
123 // 10 = 12
12 % 10 = 2
12 // 10 = 1
1 % 10 = 1
1 // 10 = 0
3.
三者相加 输出
"""
num
=
eval
(
input
())
ge
=
num
%
10
num
//=
10
# num = num // 10
shi
=
num
%
10
num
//=
10
bai
=
num
%
10
nsum
=
ge
+
shi
+
bai
print
(
nsum
)
Demo06
"""
数据：
minutes hours days years
步骤
:
1.
输入
minutes
2.
计算总小时数
minutes // 60
3.
计算总天数
hours // 24
4.
计算总年数
days // 365
5.
输出
"""
minutes
=
eval
(
input
())
hours
=
minutes
//
60
days
=
hours
//
24
years
=
days
//
365
days
=
days
%
365
print
(
years
)
print
(
days
)
Demo09
"""
数据：三个顶点坐标
x-1-2-3 y1-2-3
三边
side1-2-3
半周长
s area
步骤
:
1.
输入数据
2.
分别计算三边长度
3.
通过三边算面积
4.
输出
"""
x1
,
y1
,
x2
,
y2
,
x3
,
y3
=
eval
(
input
())
side1
= ((
x1
-
x2
)
**
2
+
(
y1
-
y2
)
**
2
)
**
0.5
side2
= ((
x3
-
x2
)
**
2
+
(
y3
-
y2
)
**
2
)
**
0.5
side3
= ((
x1
-
x3
)
**
2
+
(
y1
-
y3
)
**
2
)
**
0.5
s
= (
side1
+
side2
+
side3
)
/
2
area
= (
s
*
(
s
-
side1
)
*
(
s
-
side2
)
*
(
s
-
side3
))
**
0.5
print
(
"%.1f"
%
area
)
Demo10
1.10
条件判断
只有
if-else
语句，
Python
不支持
switch
语句
条件语句编程练习
Demo14
import
time
print
(
time
.
time
())
# 1711245794.7560694
#
表示从
1970
年
1
月
1
日
00:00:00
至今 经历的总秒数
#
格林威治时间制
#
北京时间 东八区
#
单
if
语句
if
条件语句
:
条件为真时执行的内容
# if-else
语句
if
条件语句
:
条件为真时执行的内容
else
:
条件为假时执行的内容
# if-elif
语句
else if
if
条件语句
1
:
条件语句
1
为真时执行的内容
elif
条件语句
2
:
条件语句
2
为真时执行的内容
elif
....
else
:
所有条件都不满足时执行的内容
#
语句嵌套
if
条件
1
:
if
条件
2
:
执行内容
(
1
和
2
都满足
)
else
:
执行内容
(
满足
1
不满足
2
)
else
:
执行内容
(
1
和
2
都不满足
)
"""
数据
:
体重
weight
身高
height BMI
步骤
:
1.
输入体重和身高
2.
计算
BMI
的值
3.
参照表格
4.
输出对应的结果
"""
weight
,
height
=
eval
(
input
())
BMI
=
weight
/
height
**
2
#
一般写条件 先考虑边界
/
特殊
/
最多情况
if
BMI
<
18.5
:
print
(
"
超轻
"
)
elif
BMI
<
25.0
:
print
(
"
标准
"
)
elif
BMI
<
30.0
:
print
(
"
超重
"
)
else
:
print
(
"
肥胖
"
)
Demo16
"""
数据
:
随机产生的数字
randNum
用户输入的数字
userNum r1 r2 u1 u2
randNum = r1 * 10 + r2
userNum = u1 * 10 + u2
步骤
:
1.
输入
2.
拆数字
3.
判断
(1) randNum == userNum
(2) r1 == u2 and r2 == u1
(3) r1 == u1 or r1 == u2 or r2 == u1 or r2 == u2
(4)
啥也没有
4.
输出对应的结果
"""
import
random
randNum
=
random
.
randint
(
10
,
99
)
userNum
=
eval
(
input
())
r1
=
randNum
//
10
r2
=
randNum
%
10
u1
=
userNum
//
10
u2
=
userNum
%
10
if
randNum
==
userNum
:
print
(
10000
)
elif
r1
==
u2
and
r2
==
u1
:
print
(
5000
)
elif
r1
==
u1
or
r1
==
u2
or
r2
==
u1
or
r2
==
u2
:
print
(
3000
)
else
:
print
(
0
)
Demo17
"""
数据
:a b c delt x1 x2
步骤
:
1.
输入
a b c
2.
计算
delt = b^2 - 4ac
3.delt
判断
(1)> 0
(2)== 0
(3)< 0
4.
根据不同结果输出
"""
a
,
b
,
c
=
eval
(
input
())
delt
=
b
**
2
-
4
*
a
*
c
1.11
循环语句
主要解决什么样的问题：具有重复性、规律性的问题
向前走
10
步：有明显的循环次数的
- for
向前走，直到碰墙为止：没有明显的循环次数的，但是有结束条件
- while
循环四要素：
循环的开始（从第
1
步开始；从第
1
步开始
/
从起点开始）
循环的继续条件（还没走到第
10
步；没有碰到墙
/
就是看距离）
循环体（走的每一步；走的每一步）
循环的步长
/
间隔
/
周期
/
进度（步数的统计；距离的统计）
if
delt
>
0
:
x1
= (
-
b
+
delt
**
0.5
)
/
(
2
*
a
)
x2
= (
-
b
-
delt
**
0.5
)
/
(
2
*
a
)
print
(
x1
)
print
(
x2
)
elif
delt
==
0
:
x
=
-
b
/
(
2
*
a
)
print
(
x
)
else
:
print
(
"
无实数解
"
)
//
打印
1
~
100
for
(
①
int i
=
1
;
②
i
<
=
100
;
④
i
++
) {
③
System
.
out
.
println
(
i
);
}
①
->
②
->
③
->
④
->
②
->
③
->
④
->
②
->
③
->
④
->
②
不满足为止
int
i
=
1
;
for
(;
i
<
=
100
;) {
System
.
out
.
println
(
i
);
i
++
;
}
==
>
int
i
=
1
;
while
(
i
<
=
100
) {
System
.
out
.
println
(
i
);
i
++
;
}
Python
中
for
i
in
range
(
11
):
print
(
i
)
"""
range(n) :
取值范围是
[0,n)
步长默认为
1
0 1 2 3 4 5 6 7 8 9 10
i
循环的开始：
0
循环的继续条件：
i < n
循环体：
print(i)
循环的步长
:
步长默认为
1
"""
for
i
in
range
(
2
,
10
):
print
(
i
)
循环语句编程练习
"""
range(a, b):
取值范围
[a, b)
步长默认
1
"""
for
i
in
range
(
2
,
13
,
2
):
print
(
i
)
"""
range(a, b, c):
取值范围
[a, b)
步长默认
2
"""
print
(
"="
*
12
)
for
i
in
range
(
100
,
1
):
print
(
i
)
for
i
in
range
(
100
,
10
,
-
10
):
print
(
i
)
"""
range(a,b,c)
如果
c > 0, a < b
才是有效范围 递增
如果
c < 0, a > b
才是有效范围 递减
"""
#
特殊的 结合序列去使用 遍历序列中每一个元素
for
i
in
"abcdefg"
:
print
(
i
)
"""
******
******
******
******
******
"""
for
i
in
range
(
5
):
print
(
"******"
)
print
(
"="
*
10
)
for
i
in
range
(
5
):
for
j
in
range
(
6
):
print
(
"*"
,
end
=
""
)
print
()
print
(
"="
*
10
)
"""
*
**
***
****
*****
******
"""
for
n
in
range
(
6
):
for
i
in
range
(
n
):
print
(
"*"
,
end
=
""
)
print
()
22 / 25
Demo27
print
(
"
模式
A"
)
for
n
in
range
(
1
,
7
):
for
i
in
range
(
1
,
n
+
1
):
print
(
i
,
end
=
" "
)
print
()
print
(
"
模式
B"
)
for
n
in
range
(
1
,
7
):
for
i
in
range
(
1
,
8
-
n
):
print
(
i
,
end
=
" "
)
print
()
for
n
in
range
(
6
,
0
,
-
1
):
for
i
in
range
(
1
,
n
+
1
):
print
(
i
,
end
=
" "
)
print
()
print
(
"
模式
C"
)
for
n
in
range
(
1
,
7
):
for
k
in
range
(
6
-
n
):
print
(
" "
,
end
=
" "
)
for
i
in
range
(
n
,
0
,
-
1
):
print
(
i
,
end
=
" "
)
print
()
print
(
"
模式
D"
)
for
n
in
range
(
6
,
0
,
-
1
):
for
k
in
range
(
6
-
n
):
print
(
" "
,
end
=
" "
)
for
i
in
range
(
1
,
n
+
1
):
print
(
i
,
end
=
" "
)
print
()
Demo28
for
n
in
range
(
1
,
8
):
for
k
in
range
(
7
-
n
):
print
(
" "
,
end
=
" "
)
for
x
in
range
(
1
-
n
,
n
):
print
(
abs
(
x
)
+
1
,
end
=
" "
)
print
()
Demo29
for
n
in
range
(
1
,
8
):
for
k
in
range
(
7
-
n
):
print
(
" "
,
end
=
" "
)
for
x
in
range
(
1
-
n
,
n
):
num
=
2
**
(
n
-
1
-
abs
(
x
))
print
(
"%2d"
%
(
num
),
end
=
" "
)
print
()
Demo30
# n = 9
"""
n = eval(input())
23 / 25
m = n // 2
for i in range(-m, m + 1):
for k in range(abs(i)):
print(" ", end = "")
for j in range(m + 1 - abs(i)):
print("*", end = " ")
print()
"""
"""
i j k
* 1 1 4
* * 2 1 2 3
* * * 3 1 2 3 2
* * * * 4 1 2 3 4 1
* * * * * 5 1 2 3 4 5 0
* * * * 6 1 2 3 4 1
* * * 7 1 2 3 2
* * 8 1 2 3
* 9 1 4
j <= i and i + j <= 10
"""
n
=
eval
(
input
())
for
i
in
range
(
1
,
n
+
1
):
for
k
in
range
(
abs
(
n
//
2
+
1
-
i
)):
print
(
" "
,
end
=
""
)
for
j
in
range
(
1
,
i
+
1
):
if
j
<
=
i
and
i
+
j
<
=
n
+
1
:
print
(
"*"
,
end
=
" "
)
print
()
Demo31
"""
i j k
* 1 1 4
* * 2 1 2 3
* * * 3 1 2 3 2
* * * * 4 1 2 3 4 1
* * * * * 5 1 2 3 4 5 0
* * * * 6 1 2 3 4 1
* * * 7 1 2 3 2
* * 8 1 2 3
* 9 1 4
j <= i and i + j <= 10
j == 1 or j == i or i + j == 10
"""
n
=
eval
(
input
())
for
i
in
range
(
1
,
n
+
1
):
for
k
in
range
(
abs
(
n
//
2
+
1
-
i
)):
print
(
" "
,
end
=
""
)
for
j
in
range
(
1
,
i
+
1
):
if
j
<
=
i
and
i
+
j
<
=
n
+
1
:
if
j
==
1
or
j
==
i
or
j
+
i
==
n
+
1
:
print
(
"*"
,
end
=
" "
)
Demo34
num1
,
num2
=
eval
(
input
())
min_num
=
min
(
num1
,
num2
)
for
num
in
range
(
min_num
,
0
,
-
1
):
if
num1
%
num
==
0
and
num2
%
num
==
0
:
print
(
num
)
break
Demo35
num
=
eval
(
input
())
#
哨兵：监控状态变化
flag
=
True
#
默认是素数
for
n
in
range
(
2
,
num
//
2
+
1
):
if
num
%
n
==
0
:
flag
=
False
break
if
flag
:
print
(
"YES"
)
else
:
print
(
"No"
)
Demo37
num
=
eval
(
input
())
while
num
!
=
1
:
# 120 60 30 15 5
for
n
in
range
(
2
,
num
+
1
):
if
num
%
n
==
0
:
print
(
n
,
end
=
" "
)
num
=
num
//
n
break
# 2 2 2 3
# O(N * logN)
Demo33
import
random
randNum
=
random
.
randint
(
0
,
100
)
"""
usrNum = eval(input())
while randNum != usrNum:
if usrNum < randNum:
print("小了")
elif usrNum > randNum:
print("大了")
usrNum = eval(input())
print("
猜对了
")
"""
while True
:
usrNum
=
eval
(
input
())
if
usrNum
<
randNum
:
print
(
"
小了
"
)
elif
usrNum
>
randNum
:
print
(
"
大了
"
)
else
:
print
(
"
猜对了
"
)
break
Demo39
num
=
2
count
=
0
while
count
!
=
50
:
flag
=
True
for
n
in
range
(
2
,
num
//
2
+
1
):
if
num
%
n
==
0
:
flag
=
False
break
#
是素数怎么去处理
if
flag
:
print
(
num
,
end
=
"\t"
)
count
+=
1
if
count
%
10
==
0
:
print
()
num
+=
1
Demo50
"""
9 ÷ 2 = 4 ~ 1
4 ÷ 2 = 2 ~ 0
2 ÷ 2 = 1 ~ 0
1 ÷ 2 = 0 ~ 1
1001 = 9
123321 ÷ 16 = 7707 ~ 9
7707 ÷ 16 = 481 ~ 11
481 ÷ 16 = 30 ~ 1
30 ÷ 16 = 1 ~ 14 E
1 ÷ 16 = 0 ~ 1
1E1B9
"""
num
=
eval
(
input
())
s
=
""
while
num
!
=
0
:
y
=
num
%
16
if
y
>
=
10
:
y
=
chr
(
ord
(
'A'
)
+
y
-
10
)
s
=
str
(
y
)
+
s
num
=
num
//
16
print
(
s
)
Demo46
n
=
eval
(
input
())
if
n
==
1
or
n
==
2
:
print
(
n
)
else
:
# n = 5
a
=
1
b
=
2
c
=
0
for
i
in
range
(
3
,
n
+
1
):
c
=
a
+
b
a
=
b
b
=
c
print
(
c
)
Demo47
a
,
n
=
eval
(
input
())
sum
=
0
num
=
0
for
i
in
range
(
n
):
num
=
num
*
10
+
a
# 2 22 222
sum
+=
num
print
(
sum
)
1.12
数组列表
序列：存储一堆数据的集合
/
容器
列表、字符串、元组、集合、字典
序列通用操作
索引
/
角标
>>> arr = [1,2,3,4,5,6,7,8,9]
>>> arr[0]
1
>>> arr[8]
9
>>> arr[-1] #
倒数第
1
个
9
>>> arr[-2] #
倒数第
2
个
8
>>> arr[-100]
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
IndexError: list index out of range
>>> arr[100]
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
IndexError: list index out of range
切片 就是获取序列中某一个连续子区间
序列名
[a : b : c]
跟
range(a, b, c)
基本类似
>>> arr[2:] #
从角标
2
开始向尾遍历 步长为
1
[3, 4, 5, 6, 7, 8, 9]
>>> arr[2::2] #
从角标
2
开始向尾遍历 步长为
2
[3, 5, 7, 9]
>>> arr[:6] #
从头开始到角标
6(
不取
)
步长为
1
[1, 2, 3, 4, 5, 6]
>>> arr[:6:3] #
从头开始到角标
6(
不取
)
步长为
3
[1, 4]
>>> arr[:] #
从头到尾
[1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> arr[::]
[1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> arr[::2]
[1, 3, 5, 7, 9]
=======================================
特殊的
>>> arr[-1:-7] #
从尾到头 步长必须负数
[]
>>> arr[-1:-7:-1]
[9, 8, 7, 6, 5, 4]
>>> arr[-9:7] #
从头到尾 步长为正数
[1, 2, 3, 4, 5, 6, 7]
>>> arr[0:7]
[1, 2, 3, 4, 5, 6, 7]
>>> arr[-9:-2] #
从头到尾 步长为正数
[1, 2, 3, 4, 5, 6, 7]
连接和重复
+ *
成员资格
>>> 1 in arr
True
>>> 10 in arr
False
长度与最值
>>> len(arr) #
获取序列的长度
9
>>> len(arr)
9
>>> max(arr)
9
>>> min(arr)
1
>>> s = "ABC"
>>> len(s)
3
>>> max(s)
'C'
>>> min(s)
'A'
常见操作
创建问题
"""
列表
1.
存储多个数据 数据不一定都是同一个类型 但是为了方便操作 建议存一样的类型
2.
可以通过索引
/
角标来访问元素
3.
可变长的数组 我们后续可以在列表中进行 增 删
4.
用一对中括号
[]
"""
#
创建一个空的列表
arr
= []
print
(
arr
)
#
创建一个具有若干元素的列表
arr
= [
1
,
2
,
3
,
4
]
print
(
arr
)
#
创建一个具有长度但是没有值的列表
arr
= [
None
]
*
5
print
(
arr
)
#
通过【列表推导式
/
解析式】来进行创建
# [
目标值表达式
for
目标值
in
迭代对象
if ....]
#
创建
1~100
当中 能够被
3
整除 且 能够被
5
整除 的所有数字
"""
for x in range(1, 101):
if x % 3 == 0 and x % 5 == 0:
print(x)
"""
arr
= [
x
for
x
in
range
(
1
,
101
)
if
x
%
3
==
0
and
x
%
5
==
0
]
print
(
arr
)
#
创建
1~100
当中 偶数
arr
= [
x
for
x
in
range
(
1
,
101
)
if
x
%
2
==
0
]
print
(
arr
)
#
水仙花数
for
num
in
range
(
100
,
1000
):
a
=
num
%
10
b
=
num
//
10
%
10
c
=
num
//
100
if
a
**
3
+
b
**
3
+
c
**
3
==
num
:
print
(
num
)
arr
= [
num
for
num
in
range
(
100
,
1000
)
if
(
num
%
10
)
**
3
+
(
num
//
10
%
10
)
**
3
+
(
num
//
100
)
**
3
==
num
]
print
(
arr
)
arr
= [
x
*
3
+
"
哈哈
"
for
x
in
"ABCDEFG"
]
print
(
arr
)
#
通过输入来获取元素
"""
5
"1" "2" "3" "4" "5"
"""
n
=
eval
(
input
())
arr
=
input
().
split
(
" "
)
#
将输入的数据以空格分割 分割的结果就是列表
print
(
arr
)
arr
= [
int
(
x
)
for
x
in
arr
]
print
(
arr
)
遍历问题
arr
= [
1
,
2
,
3
,
4
,
5
,
6
,
7
,
8
,
9
]
#
通过角标遍历
for
i
in
range
(
len
(
arr
)):
print
(
arr
[
i
])
#
通过
foreach
遍历
for
num
in
arr
:
print
(
num
)
最值问题
arr
= [
1
,
2
,
3
,
4
,
5
,
6
,
7
,
8
,
9
]
#
最大值
maxNum
=
arr
[
0
]
minNum
=
arr
[
0
]
for
i
in
range
(
1
,
len
(
arr
)):
if
arr
[
i
]
>
maxNum
:
maxNum
=
arr
[
i
]
if
arr
[
i
]
<
minNum
:
minNum
=
arr
[
i
]
print
(
maxNum
)
print
(
minNum
)
存在性问题
arr
= [
1
,
2
,
3
,
4
,
5
,
4
,
6
,
4
,
7
,
8
,
9
]
#
元素是否存在
key
=
10
for
num
in
arr
:
if
num
==
key
:
print
(
"
存在
"
)
break
else
:
print
(
"
不存在
"
)
#
元素在哪个位置 从左到右第
1
次出现的角标 不存在返回
-1
key
=
-
4
index
=
0
for
i
in
range
(
len
(
arr
)):
if
arr
[
i
] ==
key
:
index
=
i
break
else
:
index
=
-
1
print
(
index
)
翻转问题
arr
= [
1
,
2
,
3
,
4
,
5
,
6
,
7
,
8
,
9
,
10
]
# 0 1 2 3 4 5 6 7 8
arr
=
arr
[
-
1
::
-
1
]
print
(
arr
)
for
i
in
range
(
0
,
len
(
arr
)
//
2
):
j
=
len
(
arr
)
-
1
-
i
arr
[
i
],
arr
[
j
] =
arr
[
j
],
arr
[
i
]
print
(
arr
)left
=
0
right
=
len
(
arr
)
-
1
while
left
<
=
right
:
arr
[
left
],
arr
[
right
] =
arr
[
right
],
arr
[
left
]
left
+=
1
right
-=
1
print
(
arr
)
排序算法
选择排序
arr
= [
6
,
2
,
1
,
3
,
5
,
7
,
4
,
8
,
9
]
for
i
in
range
(
len
(
arr
)
-
1
):
# -1
少比较
1
轮
for
j
in
range
(
i
+
1
,
len
(
arr
)):
if
arr
[
i
]
>
arr
[
j
]:
arr
[
i
],
arr
[
j
] =
arr
[
j
],
arr
[
i
]
print
(
arr
)
冒泡排序
arr
= [
6
,
2
,
1
,
3
,
5
,
7
,
4
,
8
,
9
]
for
i
in
range
(
len
(
arr
)
-
1
):
# -1
少比较
1
轮
for
j
in
range
(
len
(
arr
)
-
i
-
1
):
if
arr
[
j
]
>
arr
[
j
+
1
]:
arr
[
j
],
arr
[
j
+
1
] =
arr
[
j
+
1
],
arr
[
j
]
print
(
arr
)
插入排序
arr
= [
6
,
2
,
1
,
3
,
5
,
7
,
4
,
8
,
9
]
"""
for i in range(1, len(arr)):
j = i
while j > 0 and arr[j - 1] > arr[j]:
arr[j], arr[j - 1] = arr[j - 1], arr[j]
j -= 1
"""
#
优化后的插入排序
for
i
in
range
(
1
,
len
(
arr
)):
e
=
arr
[
i
]
j
=
i
while
j
>
0
and
arr
[
j
-
1
]
>
e
:
arr
[
j
] =
arr
[
j
-
1
]
j
-=
1
arr
[
j
] =
e
print
(
arr
)
希尔排序
快速排序
堆排序
归并排序
计数排序
arr
= [
8
,
2
,
1
,
4
,
8
,
7
,
9
,
2
,
3
,
4
]
minValue
=
min
(
arr
)
maxValue
=
max
(
arr
)
temp
= [
0
]
*
(
maxValue
-
minValue
+
1
)
for
i
in
range
(
len
(
arr
)):
temp
[
arr
[
i
]
-
minValue
] +=
1
k
=
0
for
index
in
range
(
len
(
temp
)):
while
temp
[
index
]
>
0
:
arr
[
k
] =
index
+
minValue
k
+=
1
temp
[
index
] -=
1
print
(
arr
)
基数排序
桶排序
插值查找：数据必须是有序的，除了要考虑位置还得考虑元素的分布情况
"""
插值查找适用于数据分布比较均匀的情况
low
区间最小值角标
high
区间最大值角标
mid
区间中间值角标
mid = (key- arr[low]) / (arr[high] - arr[low]) * (high - low) + low
"""
arr
= [
1
,
12
,
24
,
31
,
32
,
36
,
42
,
45
,
51
,
52
,
65
,
72
,
99
]
low
=
0
high
=
len
(
arr
)
-
1
mid
=
0
key
=
31
while True
:
mid
=
int
((
key
-
arr
[
low
])
/
(
arr
[
high
]
-
arr
[
low
])
*
(
high
-
low
))
+
low
if
mid
>
high
or
mid
<
low
:
mid
=
-
1
break
if
arr
[
mid
] ==
key
:
break
elif
arr
[
mid
]
<
key
:
low
=
mid
+
1
else
:
high
=
mid
-
1
print
(
mid
)
斐波那契查找
选择排序
是一种简单直观的
排序算法。它的工作原理是每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，所以称为：选择排序。
冒泡排序
冒泡排序是一种简单的
排序算法，它也是一种稳定排序算法。其实现原理是重复扫描待排序序列，并比较每一对相邻的元素，当该对元素顺序不正确时进行交换。一直重复这个过程，直到没有任何两个相邻的元素可以交换，就表明完成了排序。
插入排序
插入排序(Insertion Sort)，也被称为直接插入排序，是一种常见的排序算法。
插入排序是将元素列表中未排序的数据依次插入到有序序列中。从元素列表的第一个数据开始(将第一个数据视为已排序序列)，按顺序将后面未排序的数据依次插入到前面已排序的序列中。对每一个未排序数据进行插入，是将该数据依次与相邻的前一个数据进行比较，如果顺序错误则交换位置，直到不需要交换则该数据插入完成。
查找算法
二分查找：要求数据必须有序
arr
= [
1
,
2
,
3
,
4
,
5
,
6
,
7
,
8
,
9
]
minIndex
=
0
maxIndex
=
len
(
arr
)
-
1
midIndex
= (
minIndex
+
maxIndex
)
//
2
key
=
8
while
arr
[
midIndex
]
!
=
key
:
if
arr
[
midIndex
]
<
key
:
minIndex
=
midIndex
+
1
else
:
maxIndex
=
midIndex
-
1
if
minIndex
>
maxIndex
:
midIndex
=
-
1
break
midIndex
= (
minIndex
+
maxIndex
)
//
2
print
(
midIndex
)
插值查找
数组相关函数
快慢指针算法思想：
- 定义快慢指针fast和slow，起始均位于链表头部。规定fast每次后移2步，slow后移1步；
- 若fast遇到null节点，则表示链表无环，结束；
- 若链中有环，fast和slow一定会再次相遇；
- 当fast和slow相遇时，额外创建指针ptr，并指向链表头部，且每次后移1步，最终slow和ptr会在入环点相遇。
双指针，指的是在遍历对象的过程中，不是普通的使用单个指针进行访问，而是使用两个相同方向（
快慢指针）或者相反方向（
对撞指针）的指针进行扫描，从而达到相应的目的。
单调栈（Monotone Stack）：一种特殊的栈。在栈的「先进后出」规则基础上，要求「从
栈顶 到
栈底 的元素是单调递增（或者单调递减）」。其中满足从栈顶到栈底的元素是单调递增的栈，叫做「单调递增栈」。满足从栈顶到栈底的元素是单调递减的栈，叫做「单调递减栈」。
单调队列 是一种主要用于解决 滑动窗口 类问题的数据结构，即，在长度为 n 的序列中，求每个长度为 m 的区间的区间最值。 它的时间复杂度是 O (n) ，在这个问题中比 O (nlog n) 的 ST表 和 线段树 要优。
斐波那契查找
列表对象函数
对象函数是区别于内置函数的，内置函数直接调用即可
len() max()
对象函数 必须通过某一个具体的对象来调用 列表
.
函数名
()
# append()
#
将某一个元素对象添加在列表的表尾
#
如果添加的是其他的序列，该序列也会被看成是一个数据对象
arr
= [
1
,
2
,
3
,
4
]
arr
.
append
(
5
)
print
(
arr
)
arr2
= [
6
,
7
,
8
]
arr
.
append
(
arr2
)
print
(
arr
)
# count()
#
统计列表当中 某一个元素出现的次数
arr
= [
1
,
2
,
3
,
4
,
1
,
2
,
3
,
1
,
1
,
2
,
0
,
0
,
1
]
print
(
arr
.
count
(
1
))
# extend()
#
在当前列表中 将传入的其他序列的元素添加在表尾
arr1
= [
1
,
2
,
3
]
arr2
= [
4
,
5
,
6
]
arr1
.
extend
(
arr2
)
print
(
arr1
)
"""
arr1.extend(7)
TypeError: 'int' object is not iterable(
可迭代的
=
序列
)
"""
arr1
.
extend
(
"ABC"
)
print
(
arr1
)
# index()
#
查找
(
从左到右
)
元素第一次出现的位置
(
角标
)
arr
= [
1
,
2
,
3
,
4
,
5
,
6
,
7
,
4
,
5
,
6
,
9
]
print
(
arr
.
index
(
4
))
print
(
arr
.
index
(
4
,
5
,
8
))
#[5, 8)
区间中找
4
的角标
"""
print(arr.index(10))
ValueError: 10 is not in list
找不到则报错
"""
# insert(index, obj)
#
在某一个角标出处插入一个元素
arr
= [
1
,
2
,
3
,
4
]
33 / 38
arr
.
insert
(
2
,
5
)
print
(
arr
)
# pop()
#
弹栈：删除最后一个元素 并返回其值
#
也可以删除指定角标处的元素
arr
= [
1
,
2
,
3
,
4
]
print
(
arr
.
pop
())
print
(
arr
)
print
(
arr
.
pop
(
1
))
print
(
arr
)
# remove()
#
移除指定元素 从左到右第一次出现的
arr
= [
1
,
2
,
3
,
4
,
2
,
3
,
4
,
2
,
3
,
4
]
arr
.
remove
(
4
)
print
(
arr
)
# reverse()
#
翻转列表
arr
= [
1
,
2
,
3
,
4
]
arr
.
reverse
()
print
(
arr
)
# sort()
#
排序
arr
= [
4
,
2
,
5
,
2
,
6
,
2
,
7
,
9
,
4
,
7
,
2
,
7
]
# arr.sort() #
默认升序
arr
.
sort
(
reverse
=
True
)
#
降序
arr
= [
"ABC"
,
"123123123"
,
"
我爱你中国
"
,
"123123123"
,
"kasdkjas"
]
arr
.
sort
(
key
=
len
)
#
以序列的长度为基准进行排序
print
(
arr
)
# clear()
#
清空
arr
= [
1
,
2
,
3
,
4
]
arr
.
clear
()
print
(
arr
)
# copy()
#
复制一个列表
(
浅拷贝
)
arr1
= [
1
,
2
,
3
,
4
]
arr2
=
arr1
.
copy
()
print
(
arr1
==
arr2
)
# True
比较的是内容
print
(
arr1
is
arr2
)
# False
比较的是对象地址
print
(
arr1
)
print
(
arr2
)
arr1
[
0
] =
5
print
(
arr2
[
0
])
#
上述代码在
arr1
中修改元素 并不影响
arr2
arr1
= [
1
,
2
,
3
,[
4
,
5
,
6
]]
arr2
=
arr1
.
copy
()
arr2
[
0
] =
7
print
(
arr1
[
0
])
print
(
arr2
[
0
])
arr2
[
3
][
0
] =
666
print
(
arr1
[
3
])
#
上述代码在
arr2
中修改元素 影响
arr1
34 / 38
arr2
[
3
] = [
9
,
9
,
9
]
print
(
arr1
[
3
])
print
(
arr2
[
3
])
#
额外的知识
# del
关键字：删除
arr
= [
1
,
2
,
3
,
4
]
del
arr
[
0
]
#
删除序列中的元素
print
(
arr
)
del
arr
#
删除变量
"""
NameError: name 'arr' is not defined. Did you mean: 'arr2'?
print(arr)
"""
字符串对象函数
可变对象与不可变对象
列表是可变对象：可以修改列表中的元素 甚至长度
字符串是不可变对象：不可以修改字符串中的元素 包括 长度
注意：也就意味着对字符串的修改 一律不是在本身修改 而是创建一个新的字符串！
>>> arr = [1,2,3]
>>> arr[0] = 4
>>> arr
[4, 2, 3]
>>> s = "ABC"
>>> s[0]
'A'
>>> s[0] = "D"
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'str' object does not support item assignment
字符串对象不支持元素修改
# center()
#
指定填充字符 将目标字符进行居中
s1
=
"ABC"
s2
=
s1
.
center
(
10
,
"#"
)
print
(
s1
)
print
(
s2
)
# count()
#
和列表的
count
相似 统计字符串的个数
s
=
"abchjghjabcjkhjkhabchkjhabc"
print
(
s
.
count
(
"abc"
))
print
(
s
.
count
(
"a"
))
# count
是非贪心统计 贪心统计
6
个
s
=
"AAAAAAAA"
print
(
s
.
count
(
"AAA"
))
print
(
s
.
count
(
"AAA"
,
2
,
6
))
# endswith()
#
过滤字符串结尾 同样也可以指定区间
s
=
"
泷泽萝拉
.avi"
print
(
s
.
endswith
(
".avi"
))
# find()
#
寻找字符串第一次出现的位置 同样也可以指定区间
s
=
"
八百标兵奔北坡
"
print
(
s
.
find
(
"
标兵
"
))
# 2
指定是标的角标
# format()
#
格式化输出
name
=
"
小强
"
age
=
18
print
(
"
我的名字叫
%s,
年龄
%d
岁
"
%
(
name
,
age
))
print
(
"
我的名字叫
{},
年龄
{}
岁
"
.
format
(
name
,
age
))
print
(
f"
我的名字叫
{name},
年龄
{age}
岁
"
)
print
(
f"
我的名字叫
{3 > 2},
年龄
{2 ** 8}
岁
"
)
# index()
#
寻找字符串第一次出现的位置 同样也可以指定区间
s
=
"
八百标兵奔北坡
"
print
(
s
.
index
(
"
标兵
"
))
# 2
指定是标的角标
s
=
"ABC"
print
(
s
.
find
(
"D"
))
# -1
如果找不到 则返回
-1
# print(s.index("D"))#
如果找不到 直接报错
ValueError: substring not found
# isalnum()
#
判断是否是字母或数字字符串
al-alpha
字母
num-number
数字
print
(
"abc"
.
isalnum
())
print
(
"123"
.
isalnum
())
print
(
"abc123"
.
isalnum
())
print
(
"abc123^&%&^&"
.
isalnum
())
# isalpha()
是否是纯字母字符串
# isdecimal()
是否是十进制纯数字字符串
# isdigit()
是否是纯数字字符串
# isspace()
是否是纯空格字符串
# islower()
出现的字母是否是小写字母
print
(
"123abc"
.
islower
())
print
(
"123Abc"
.
islower
())
# isupper()
出现的字母是否是大写字母
# join()
将字符串列表进行拼接的
arr
= [
"banana"
,
"orange"
,
"apple"
,
"pich"
]
s
=
"-"
.
join
(
arr
)
print
(
s
)
# ljust()
左对齐
rjust()
右对齐
print
(
"ABC"
.
ljust
(
10
,
"#"
))
print
(
"ABC"
.
rjust
(
10
,
"#"
))
# lower()
出现的大写字母转小写
upper()
相反
print
(
"Hello World123"
.
lower
())
# lstrip()
去除左边空格
rstrip()
去除右边空格
print
(
" ABC "
.
lstrip
())
常用的就如上所示，你们自己下去百度，将其他的字符串相关的函数进行整理
自行整理：
math
模块
| 功能 | 描述 |
|---|---|
| ceil(x) | 返回大于或等于x的最小整数。 |
| copysign(x, y) | 返回带有y符号的x |
| fabs(x) | 返回x的绝对值 |
| factorial(x) | 返回x的阶乘 |
| floor(x) | 返回小于或等于x的最大整数 |
| fmod(x, y) | 当x除以y时返回余数 |
| frexp(x) | 返回x的尾数和指数作为对（m，e） |
| fsum(iterable) | 返回迭代器中值的准确浮点和 |
| isfinite(x) | 如果x既不是无穷大也不是NaN（不是数字），则返回True |
| isinf(x) | 如果x是正或负无穷大，则返回True |
| isnan(x) | 如果x是NaN，则返回True |
| ldexp(x, i) | 返回x *（2 ** i） |
| modf(x) | 返回x的小数和整数部分 |
| trunc(x) | 返回x的截断整数值 |
| exp(x) | 返回e ** x |
| expm1(x) | 返回e ** x-1 |
| log(x[, base]) | 将x的对数返回底数（默认为e） |
| log1p(x) | 返回1 + x的自然对数 |
| log2(x) | 返回x的以2为底的对数 |
| log10(x) | 返回x的以10为底的对数 |
| pow(x, y) | 返回x的幂y |
| sqrt(x) | 返回x的平方根 |
| acos(x) | 返回x的反余弦 |
| asin(x) | 返回x的反正弦 |
| atan(x) | 返回x的反正切 |
| atan2(y, x) | 返回atan（y / x） |
| cos(x) | 返回x的余弦 |
| hypot(x, y) | 返回欧几里得范数sqrt（x * x + y * y） |
| sin(x) | 返回x的正弦 |
| tan(x) | 返回x的切线 |
| degrees(x) | 将角度x从弧度转换为度 |
| radians(x) | 将角度x从度转换为弧度 |
| acosh(x) | 返回x的反双曲余弦值 |
| asinh(x) | 返回x的反双曲正弦值 |
| atanh(x) | 返回x的反双曲正切值 |
| cosh(x) | 返回x的双曲余弦值 |
| sinh(x) | 返回x的双曲余弦值 |
| tanh(x) | 返回x的双曲正切 |
| erf(x) | 返回x处的误差函数 |
| erfc(x) | 返回x处的互补误差函数 |
| gamma(x) | 返回x处的Gamma函数 |
| lgamma(x) | 返回x处Gamma函数绝对值的自然对数 |
| pi | 数学常数，圆的周长与其直径之比（3.14159 ...） |
| e | 数学常数e（2.71828 ...） |
| 功能 | 描述 |
| ceil(x) | 返回大于或等于x的最小整数。 |
| copysign(x, y) | 返回带有y符号的x |
| fabs(x) | 返回x的绝对值 |
| factorial(x) | 返回x的阶乘 |
| floor(x) | 返回小于或等于x的最大整数 |
| fmod(x, y) | 当x除以y时返回余数 |
| frexp(x) | 返回x的尾数和指数作为对（m，e） |
| fsum(iterable) | 返回迭代器中值的准确浮点和 |
| isfinite(x) | 如果x既不是无穷大也不是NaN（不是数字），则返回True |
| isinf(x) | 如果x是正或负无穷大，则返回True |
| isnan(x) | 如果x是NaN，则返回True |
| ldexp(x, i) | 返回x *（2 ** i） |
| modf(x) | 返回x的小数和整数部分 |
| trunc(x) | 返回x的截断整数值 |
| exp(x) | 返回e ** x |
| expm1(x) | 返回e ** x-1 |
| log(x[, base]) | 将x的对数返回底数（默认为e） |
| log1p(x) | 返回1 + x的自然对数 |
| log2(x) | 返回x的以2为底的对数 |
| log10(x) | 返回x的以10为底的对数 |
| pow(x, y) | 返回x的幂y |
| sqrt(x) | 返回x的平方根 |
| acos(x) | 返回x的反余弦 |
| asin(x) | 返回x的反正弦 |
| atan(x) | 返回x的反正切 |
| atan2(y, x) | 返回atan（y / x） |
| cos(x) | 返回x的余弦 |
| hypot(x, y) | 返回欧几里得范数sqrt（x * x + y * y） |
| sin(x) | 返回x的正弦 |
| tan(x) | 返回x的切线 |
| degrees(x) | 将角度x从弧度转换为度 |
| radians(x) | 将角度x从度转换为弧度 |
| acosh(x) | 返回x的反双曲余弦值 |
| asinh(x) | 返回x的反双曲正弦值 |
| atanh(x) | 返回x的反双曲正切值 |
| cosh(x) | 返回x的双曲余弦值 |
| sinh(x) | 返回x的双曲余弦值 |
| tanh(x) | 返回x的双曲正切 |
| erf(x) | 返回x处的误差函数 |
| erfc(x) | 返回x处的互补误差函数 |
| gamma(x) | 返回x处的Gamma函数 |
| lgamma(x) | 返回x处Gamma函数绝对值的自然对数 |
| pi | 数学常数，圆的周长与其直径之比（3.14159 ...） |
| e | 数学常数e（2.71828 ...） |
自行整理：
random
模块
random 模块方法如下：
| 方法 | 描述 |
|---|---|
| seed() | 初始化随机数生成器 |
| getstate() | 返回捕获生成器当前内部状态的对象。 |
| setstate() | state 应该是从之前调用 getstate() 获得的，并且 setstate() 将生成器的内部状态恢复到 getstate() 被调用时的状态。 |
| getrandbits(k) | 返回具有 k 个随机比特位的非负 Python 整数。 此方法随 MersenneTwister 生成器一起提供，其他一些生成器也可能将其作为 API 的可选部分提供。 在可能的情况下，getrandbits() 会启用 randrange() 来处理任意大的区间。 |
| randrange() | 从 range(start, stop, step) 返回一个随机选择的元素。 |
| randint(a, b) | 返回随机整数 N 满足 a <= N <= b。 |
| choice(seq) | 从非空序列 seq 返回一个随机元素。 如果 seq 为空，则引发 IndexError。 |
| choices(population, weights=None, *, cum_weights=None, k=1) | 从 population 中选择替换，返回大小为 k 的元素列表。 如果 population 为空，则引发 IndexError。 |
| shuffle(x[, random]) | 将序列 x 随机打乱位置。 |
| sample(population, k, *, counts=None) | 返回从总体序列或集合中选择的唯一元素的 k 长度列表。 用于无重复的随机抽样。 |
| random() | 返回 [0.0, 1.0) 范围内的下一个随机浮点数。 |
| uniform() | 返回一个随机浮点数 N ，当 a <= b 时 a <= N <= b ，当 b < a 时 b <= N <= a 。 |
| triangular(low, high, mode) | 返回一个随机浮点数 N ，使得 low <= N <= high 并在这些边界之间使用指定的 mode 。 low 和 high 边界默认为零和一。 mode 参数默认为边界之间的中点，给出对称分布。 |
| betavariate(alpha, beta) | Beta 分布。 参数的条件是 alpha > 0 和 beta > 0。 返回值的范围介于 0 和 1 之间。 |
| expovariate(lambd) | 指数分布。 lambd 是 1.0 除以所需的平均值，它应该是非零的。 |
| gammavariate() | Gamma 分布（ 不是伽马函数） 参数的条件是 alpha > 0 和 beta > 0。 |
| gauss(mu, sigma) | 正态分布，也称高斯分布。 mu 为平均值，而 sigma 为标准差。 此函数要稍快于下面所定义的 normalvariate() 函数。 |
| lognormvariate(mu, sigma) | 对数正态分布。 如果你采用这个分布的自然对数，你将得到一个正态分布，平均值为 mu 和标准差为 sigma 。 mu 可以是任何值，sigma 必须大于零。 |
| normalvariate(mu, sigma) | 正态分布。 mu 是平均值，sigma 是标准差。 |
| vonmisesvariate(mu, kappa) | 冯·米塞斯分布。 mu 是平均角度，以弧度表示，介于0和 2*pi 之间，kappa 是浓度参数，必须大于或等于零。 如果 kappa 等于零，则该分布在 0 到 2*pi 的范围内减小到均匀的随机角度。 |
| paretovariate(alpha) | 帕累托分布。 alpha 是形状参数。 |
| weibullvariate(alpha, beta) | 威布尔分布。 alpha 是比例参数，beta 是形状参数。 |
列表字符串编程练习题
Demo53
Demo54
print
(
" ABC "
.
rstrip
())
print
(
" ABC "
.
strip
())
#
两边都去掉连续空格
print
(
" A B C "
.
strip
())
# replace(a,b)
替换
a
旧
b
新
s
=
"
宇智波佐助、宇智波斑、宇智波鼬、宇智波泉奈、宇智波止水、宇智波卡卡西
"
s1
=
s
.
replace
(
"
宇智波
"
,
"
千手
"
)
print
(
s
)
print
(
s1
)
# split()
以某一个分割符来切割字符串 结果是一个字符串的列表
s
=
"
泰罗
-
杰克
-
赛文
-
迪迦
-
梦比优斯
"
arr
=
s
.
split
(
"-"
)
print
(
arr
)
arr
=
"1 2 34 4.12"
.
split
(
" "
)
print
(
arr
)
列表字符串编程练习题
Demo53
#
关于字符串匹配：
KMP
算法
#
本代码仅非贪暴力解
s1
=
input
()
s2
=
input
()
count
=
0
i
=
0
while
i
<
=
len
(
s1
)
-
len
(
s2
):
if
s1
[
i
] ==
s2
[
0
]:
j
=
i
+
1
for
k
in
range
(
1
,
len
(
s2
)):
if
s1
[
j
]
!
=
s2
[
k
]:
i
+=
1
break
j
+=
1
else
:
count
+=
1
i
=
j
else
:
i
+=
1
print
(
count
)
Demo54
s1
=
input
()
s2
=
input
()
length
=
len
(
s2
)
while
length
>
0
:
left
=
0
right
=
length
-
1
while
right
<
len
(
s2
):
s
=
s2
[
left
:
right
+
1
]
print
(
s
)
if
s
in
s1
:
print
(
s
)
exit
()
#
退出程序
break
left
+=
1
right
+=
1
length
-=
1
2万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
