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 ); //0x789printf ( "%d" , * c ); //0x123printf ( "%d" , &**& c ); //0x456
在Java中，引用数据类型变量（将对象在堆内存中的地址给变量）
Object obj = new Object ();Object obj2 = obj
动态语言（所有的数据都是对象！所有的变量都是引用数据类型变量）
var a = 1var b = 1.1b = new object ();
1.4 安装环境
Python开发工具包
http://python.p2hp.com/downloads/windows/index.html
如何验证安装成功：
win+R
输入
cmd
打开控制台 输入
python
命令
C:\Users\Administrator>pythonPython 3.12.1 (tags/v3.12.1:2305ca5, Dec 7 2023, 22:03:25) [MSC v.1937 64 bit(AMD64)] on win32Type "help", "copyright", "credits" or "license" for more information.>>>
如果没有出现
3.12.1
的提示，去找到
Python
的安装目录：
C:\Users\Administrator\AppData\Local\Programs\Python\Python312
我的电脑图标，邮件，属性，高级系统设置，环境变量，
Path
，双击，新建，粘贴路径，确定，确定，确定，重新打开CMD窗口测试
VSCode
https://code.visualstudio.com/
1.5 脚本与交互
交互模式
打开
CMD
窗口，输入
python
指令，进入到了
python
交互模式
C:\Users\Administrator>pythonPython 3.12.1 (tags/v3.12.1:2305ca5, Dec 7 2023, 22:03:25) [MSC v.1937 64 bit(AMD64)] on win32Type "help", "copyright", "credits" or "license" for more information.>>> print("Hello Wolrd!")Hello Wolrd!>>> print(1 + 2)3
print()
输出函数，输出的内容写在一对小括号中
print(XXX)
弊端：代码不能持久保存，代码随着窗口关闭而消失
我们一般在做简单的代码演示、测试会使用到交互模式
为了永久保存代码，需要脚本模式
脚本模式
打开
VSCode
，
File
，
New Folder
，选择代码目录，
New File
按钮创建文件，输入名称和后缀名
(.py)
注意：一定要养成随时按crtl+s
的习惯 保存
如何运行
Python
脚本文件呢
打开
CMD
窗口，进入到代码目录路径
指令：
python XXX.py
运行
XXX.py
文件
1.6 基本数据
Python
能够操作的数据都有哪些
常量
不能够改变的量
-
字面量
- 整数常量
>>> print ( 10 ) # 十进制10>>> print ( 0b1001 ) # 二进制 binary9>>> print ( 0o12 ) # 八进制 Oct...10>>> print ( 0x12 ) # 十六进制 Hex...18
123 % 7 = 417 % 7 = 32 % 7 = 2234 七进制4 * 7 ^ 0 + 3 * 7 ^ 1 + 2 * 7 ^ 2 = 4 + 21 + 98 = 123
注意：没有
byte short long
之分 一律默认
int
- 小数常量
>>> print(1.34)1.34>>> print(0.12e10) #0.12*10^101200000000.0
注意：没有
float
与
double
之分 默认
float
- 字符串常量
字符串表示一段文本信息，程序会将文本信息原封不动的处理
>>> print("1+2+3")1+2+3>>> print('1+2+3')1+2+3
Python
没有字符的数据，一律当成字符串处理，双引号和单引号都可以表示字符串
>>> print(" 张老师说 :" 好好学习 "")File "<stdin>", line 1print("张老师说:" 好好学习 "")^^^^^^^^^^^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
赋予了特殊的含义，不能随便使用
>>> 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 + 47>>> 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 + 47>>> 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变量 = 数据单独定义一个变量时>>> a = 1>>> b = 2同时定义多个变量，给定多个数据>>> a, b, c = 1, 2, 3>>> a1>>> b2>>> c3多个变量的值是一样的>>> a = b = c = 1>>> a1>>> b1>>> c1
1.7 数据转换
int a = (int) 3.14;
数据类型转换
int()
将其他有效的数据转为整数
- 取整
- 从字符串中解析整数
>>> 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 ** 21318>>> 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 0base 进制基数 = [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>>> 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)
常见的数学计算
>>> 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
1.8 输入与输出
input()
#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,456579"""num1 , num2 = eval ( input ( " 请输入两个数字 :" ))print ( num1 + num2 )
print()
print ( "Hello World" )print ( 1 + 2 + 3 )print ( 1 , 2 , 3 , "Hello World!" ) # 多数据输出 用空格分隔print ( 1 , 2 , 3 , sep = "#" ) # sep 默认空格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 = 18height = 1.23print ( " 它叫 " , name , " ，今年 " , age , " 岁 " , sep = "" )# %s 对应字符串 %d 对应整数 %f 对应小数print ( " 它叫 %s ，今年 %d 岁，身高 %.2f 米 " % ( name , age , height ))
1.9 运算符
算数运算符
- 加法：数值相加，序列拼接
>>> 1 + 23>>> "123" + "456"'123456'
- 减法：数值相减
- 乘法：数值相乘，序列增倍
>>> 3 * 618>>> " 我爱你 " * 3' 我爱你我爱你我爱你 '
- 除法：小数除 /，整数除 //
整数除 只要两边都是整数 结果一律为整数 但凡有一个小数 结果就是小数（只有整数位，小数位都为
0
）
>>> 10 / 25.0>>> 10 // 25>>> 10 / 33.3333333333333335>>> 10 // 33>>> 10.0 // 33.0>>> 10.5 // 33.0
- 幂运算
>>> 2 ** 38>>> 16 ** 0.54.0
- 取余：10 / 3 = 3 ~ 1
>>> 10 % 31
取余经常用于哪些场景，带有数据重复或循环的情况
22
日对应周五，
22 % 7 = 1
余数为
1
则对应周五
0
对应周四
....
30 % 7 = 2
对应周六
布尔判断运算符
运算结果一律为布尔值
大于 小于 大于等于 小于等于 不等于 等于
> < >= <= != ==
Python
允许连续比较
>>> 1 < 2 < 3True>>> 1 < 2 and 2 < 3True
在
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 += 2a = a + 2b **= 2b = 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 ++ ); // 12System . out . println ( x ); // 5
逻辑运算符
与 或 非
= and or not
（
&& || !
）
与：全真则真 有假则假
或：有真则真 全假则假
非：取反
>>> 1 < 2 and 2 < 3True>>> 1 < 2 or 2 > 3True>>> not 1 < 2False
&
与
&&
的区别
int x = 0;int y = 0;System.out.println(x++ < 0 & y ++ < 0); // 无论左边是否为假 右边都要计算System.out.println(x); //1System.out.println(y); //1int x = 0;int y = 0;System.out.println(x++ < 0 && y ++ < 0); // 如果左边是假 右边不计算System.out.println(x); //1System.out.println(y); //0&& 就是为了避免一些没有必要的计算 提高效率
位运算符
& 按位与>>> 13 & 75110101110101 = 5| 按位或>>> 13 | 715110101111111 = 15>> 右移>>> 16 >> 210000100|00100 = 416 / 2 ^ 2<< 左移>>> 2 << 3160010001000010000 = 162 * 2 ^ 3~ 取反 符号取反再减 1>>> ~15-1601111 = 1510000 = -16^ 异或：相等为假 不同为真>>> 13 ^ 710110101111010 = 10
关于变量交换值
a = 1b = 3temp = aa = bb = tempa, b = b, a # Python 自带的交换特点只针对整数a = 10b = 100a = a + b # 110b = a - b # 10a = a - b # 100只针对整数a = a ^ bb = a ^ ba = 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 == bTrue>>> a is bTrue>>> a == 1000False>>> a = 1000>>> b = 1000>>> a == bTrue>>> a is bFalse>>> a = "abc" # 字符串>>> b = "abc" # 之前已经创建了 "abc" 这里直接复用 而不是重新创建 跟整数是有区别的>>> a == bTrue>>> a is bTrue>>> id(a)140715463387184>>> id(b)140715463387184
1.10 条件判断
只有
if-else
语句，
Python
不支持
switch
语句
# 单 if 语句if 条件语句 :条件为真时执行的内容# if-else 语句if 条件语句 :条件为真时执行的内容else :条件为假时执行的内容# if-elif 语句 else ifif 条件语句 1 :条件语句1 为真时执行的内容elif 条件语句 2 :条件语句2 为真时执行的内容elif ....else :所有条件都不满足时执行的内容# 语句嵌套if 条件 1 :if 条件 2 :执行内容 ( 1 和 2 都满足 )else :执行内容 ( 满足 1 不满足 2 )else :执行内容 ( 1 和 2 都不满足 )
1.11 循环语句
主要解决什么样的问题：具有重复性、规律性的问题
向前走
10
步：有明显的循环次数的
- for
向前走，直到碰墙为止：没有明显的循环次数的，但是有结束条件
- while
循环四要素：
- 循环的开始（从第1步开始；从第1步开始/从起点开始）
- 循环的继续条件（还没走到第10步；没有碰到墙/就是看距离）
- 循环体（走的每一步；走的每一步）
- 循环的步长/间隔/周期/进度（步数的统计；距离的统计）
// 打印 1 ~ 100for ( ① 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) 步长默认为 10 1 2 3 4 5 6 7 8 9 10i循环的开始： 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 ()
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 arrTrue>>> 10 in arrFalse
长度与最值
>>> 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 ] * 5print ( 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 % 10b = num // 10 % 10c = num // 100if 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 = 10for num in arr :if num == key :print ( " 存在 " )breakelse :print ( " 不存在 " )# 元素在哪个位置 从左到右第 1 次出现的角标 不存在返回 -1key = - 4index = 0for i in range ( len ( arr )):if arr [ i ] == key :index = ibreakelse :index = - 1print ( index )
翻转问题
arr = [ 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 , 10 ]# 0 1 2 3 4 5 6 7 8arr = arr [ - 1 :: - 1 ]print ( arr )for i in range ( 0 , len ( arr ) // 2 ):j = len ( arr ) - 1 - iarr [ i ], arr [ j ] = arr [ j ], arr [ i ]print ( arr )left = 0right = len ( arr ) - 1while left < = right :arr [ left ], arr [ right ] = arr [ right ], arr [ left ]left += 1right -= 1print ( 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)
希尔排序
快速排序
堆排序
归并排序
计数排序
基数排序
桶排序
查找算法
二分查找：要求数据必须有序
介绍
二分查找法，也称为折半查找法，是一种在有序数组中查找特定元素的高效算法。其基本思路是将目标元素与数组中间的元素进行比较，从而可以确定目标元素可能在数组的哪一半，然后逐步缩小搜索范围，直到找到目标元素或确定其不存在为止。
思路
- 确定搜索范围： 首先，确定整个有序数组的搜索范围，即左边界和右边界。通常初始时左边界为数组的第一个元素索引，右边界为数组的最后一个元素索引。
- 计算中间元素： 计算左边界和右边界的中间索引，可以使用 (left + right) / 2 进行计算。这个中间元素将用于与目标元素进行比较。
- 比较与目标元素： 将目标元素与中间元素进行比较。如果目标元素等于中间元素，则找到了目标，返回中间元素的索引。如果目标元素小于中间元素，则说明目标可能在左半边，更新右边界为中间元素的前一个索引。如果目标元素大于中间元素，则说明目标可能在右半边，更新左边界为中间元素的后一个索引。
- 缩小搜索范围： 根据上一步的比较结果，缩小搜索范围。如果目标在左半边，就在左半边继续进行二分查找；如果目标在右半边，就在右半边继续进行二分查找。重复这个过程，不断缩小搜索范围，直到找到目标元素或搜索范围为空。
- 重复步骤： 重复执行步骤 2 到步骤 4，直到找到目标元素或搜索范围为空。如果搜索范围为空，说明目标元素不存在于数组中。
arr = [1, 2, 3, 4, 5, 6, 7, 8, 9]
left = 0
right = len(arr) - 1
mid = (left + right) // 2
key = 5
while arr[mid] != key:
if arr[mid] < key:
left = mid + 1
else:
right = mid - 1
if left > right:
mid = -1
break
mid = (left + right) // 2
print(mid)
插值查找：数据必须是有序的，除了要考虑位置还得考虑元素的分布情况
"""
插值查找适用于数据分布比较均匀的情况
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)
斐波那契查找
列表对象函数
对象函数是区别于内置函数的，内置函数直接调用即可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]
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
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())
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)
math模块
Python 数学模块介绍
Python 的数学模块是一个内置库，提供了对大量数学函数和常量的访问。该模块是在 Python 中进行数学计算的重要工具。数学模块提供了基本算术运算的函数，如加法、减法、乘法和除法。它还提供了更高级的数学运算函数，如三角函数、对数函数和指数函数。
基本算术功能
数学模块提供进行简单计算所必需的基本算术功能。这些函数包括加法、减法、乘法和除法。下面举例说明如何使用这些函数：
import math
# 加法
a = math.add(2, 3)
# 减法
b = math.subtract(5, 2)
# 乘法
c = math.multiply(3, 4)
# 除法
d = math.divide(10, 2)
三角函数
数学模块提供了一系列三角函数，这些函数对于进行涉及角度的计算至关重要。这些函数包括正弦、余弦、正切、余切、正割和余割。下面举例说明如何使用这些函数：
import math
# 正弦函数
a = math.sin(math.pi/2)
# 余弦函数
b = math.cos(math.pi/2)
# 正切函数
c = math.tan(math.pi/4)
# 余切函数
d = math.cot(math.pi/4)
# 正割函数
e = math.sec(math.pi/3)
# 余割函数
f = math.csc(math.pi/6)
对数函数
数学模块提供的对数函数对进行涉及对数的计算至关重要。这些函数包括自然对数（log base e）、普通对数（log base 10）和任意基数对数。下面举例说明如何使用这些函数：
import math
# 自然对数
a = math.log(2.718)
# 常用(普通)对数
b = math.log10(100)
# 任意基数的对数
c = math.log(16, 2)
指数函数
数学模块提供的指数函数对于进行涉及指数的计算至关重要。这些函数包括指数函数（e 升为 x 的幂次）和幂函数（x 升为 y 的幂次）。下面举例说明如何使用这些函数：
import math
# 指数函数
a = math.exp(2)
# 幂函数
b = math.pow(2, 3)
random模块
1、返回整数
random.randange()
语法如下：
random.randrange(stop)
random.randrange(start, stop[, step])参数解析：
- stop： 末尾数字，不包含（取不到 stop 这个值）
- start： 起始数字，包含（取得到 start 这个值）
- step： 步长
示例如下：
import random
for i in range(5):
print(random.randrange(30))
############
9
25
21
3
20
------------------
import random
for i in range(5):
print(random.randrange(10, 20))
###########
14
12
11
14
13
-------------------
import random
for i in range(5):
print(random.randrange(20, 30, 2))
############
24
28
22
22
24random.randint()
语法如下：
random.randint(a, b)语法说明：
- 该语句相当于
random.randint(a, b+1) - 返回随机整数 N 满足
a <= N <= b
示例如下：
import random
for i in range(5):
print(random.randint(10,20))
######
12
15
10
13
13注：该方法可以返回两端的值
2、返回浮点数
random.random()
语法格式：
random.random()上述语法将返回一个[0.0,1.0)之间的一个浮点数
使用示例
import random
for i in range(5):
print(random.random())
-----------------
0.051698653828633145
0.10619823413246887
0.33732593583951986
0.6763699334756532
0.16816052346812582
import math
import random
for i in range(6):
print(math.ceil(random.random() * 1000))
---------------------
67
38
612
639
454
870random.uniform()
语法格式如下：
random.uniform(a, b)语法说明：
- 返回一个随机浮点数 N
- 当
a <= b时，a <= N <= b - 当
b < a时，b <= N <= a
使用示例
import random
for i in range(5):
print(random.uniform(1, 10))
###############
5.457242422186069
8.633135221688587
2.9232627928020625
7.921168676991703
2.07340428271263
---------------------
import random
for i in range(5):
print(random.uniform(12, 3))
####################
3.1848989873887614
5.15029109210898
3.947059333936842
9.637384540893176
4.816027706079555以列表作为参数
random.choice()
语法如下：
random.choice(seq)
语法说明：
- 从非空序列 seq 返回一个随机元素
- 如果 seq 为空，会抛出 IndexError
示例如下：
import string
print(random.choice([1, 2, 3, 4, 5]))
# 字母数组
print(random.choice(["a", "b", "c"]))
# 字母元组
print(random.choice(("a", "b", "c")))
# 字符串
print(random.choice("abcdef"))
# string 模块返回的大小写字母字符串
print(random.choice(string.ascii_letters))
# string 模块返回的数字字符串
print(random.choice(string.digits))
# string 模块返回的数字字符串+大小写字母字符串
print(random.choice(string.digits + string.ascii_uppercase))
#############
3
b
c
d
e
7
Hrandom.choices()
语法如下：
random.choices(population, weights=None, *, cum_weights=None, k=1)参数说明：
- populaiton：序列
- weights：普通权重
- cum_weights：累加权重
- k：选择次数
注：weights 和 cum_weights 不能同时传，只能选择一个来传
示例如下：
import random
a = [1,2,3,4,5]
print(random.choices(a,k=5))
#########
[4, 3, 5, 3, 5]
---------
a = [1, 2, 3, 4, 5]
print(random.choices(a, weights=[0, 0, 0, 0, 1], k=5))
# 序列有多长，weights 对应的序列就得多长，每个位置都是一一对应
# 像这里，5 的权重是 1，其他是 0 ，所以每次都取 5，因为它的权重最高，其他元素没有权重
########
[5, 5, 5, 5, 5]
------------------------
a = [1, 2, 3, 4, 5]
print(random.choices(a, weights=[0, 0, 2, 0, 1], k=5))
# 2 的权重更大，所以取到它的概率更高
################
[3, 3, 5, 3, 5]random.shuffle()
语法如下：
random.shuffle(x[, random])- 将序列 x 随机打乱位置
- 只能是列表[]，元组、字符串会报错
示例如下：
import random
# 数字数组
a = [1, 2, 3, 4, 5]
random.shuffle(a)
print(a)
# 字母数组
b = ["a", "b", "c"]
random.shuffle(b)
print(b)
######
[4, 3, 2, 1, 5]
['b', 'a', 'c']random.sample()
语法如下：
random.sample(population, k)示例如下：
import random
import string
print(random.sample([1, 2, 3, 4, 5], 3))
# 字母数组
print(random.sample(["a", "b", "c"], 3))
# 字母元组
print(random.sample(("a", "b", "c"), 3))
# 字符串
print(random.sample("abcdef", 3))
# string 模块返回的大小写字母字符串
print(random.sample(string.ascii_letters, 3))
# string 模块返回的数字字符串
print(random.sample(string.digits, 3))
# string 模块返回的数字字符串+大小写字母字符串
print(random.sample(string.digits + string.ascii_uppercase, 3))
############
[4, 3, 5]
['b', 'c', 'a']
['a', 'b', 'c']
['c', 'a', 'f']
['l', 't', 'y']
['0', '8', '3']
['5', '8', 'T']
3万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
