一,python的概念
Python由 荷兰国家数学与计算机科学研究中心 的 吉多·范罗苏姆 于1990年代初设计,作为一门叫做 ABC语言 的替代品。 Python提供了高效的高级 数据结构 ,还能简单有效地 面向对象 编程。y
python与c ,java 编译与解释的区别
![](https://i-blog.csdnimg.cn/blog_migrate/d48b5e2a1e6bd968144e1235d6863f23.png)
![](https://i-blog.csdnimg.cn/blog_migrate/c32ca1f8d2f9db07296236e11b8a1a76.png)
![](https://i-blog.csdnimg.cn/blog_migrate/6ca5c960c58bf912eb9728b9db217934.png)
安装环境
![](https://i-blog.csdnimg.cn/blog_migrate/8b417a93ab834e0381f2e34b08246834.png)
脚本与交互
![](https://i-blog.csdnimg.cn/blog_migrate/5a8bdb93c45a4248ba25e20a902d5e41.png)
![](https://i-blog.csdnimg.cn/blog_migrate/348df38fa2c863706dc850f09f2e5cc3.png)
![](https://i-blog.csdnimg.cn/blog_migrate/5bb2065383808784553e540dc1c35937.png)
![](https://i-blog.csdnimg.cn/blog_migrate/449025fbd0dbf40fc401c24f92e72a59.png)
![](https://i-blog.csdnimg.cn/blog_migrate/26b580805ce31d1ea71740f9a28838fd.png)
![](https://i-blog.csdnimg.cn/blog_migrate/519dd5a136a265d68058057ae167ecfe.png)
![](https://i-blog.csdnimg.cn/blog_migrate/62a4b14507a04dbde4f7b14c6fd9ff53.png)
![](https://i-blog.csdnimg.cn/blog_migrate/2487e6bd5fd3c62e0ff6a748d3059c96.png)
![](https://i-blog.csdnimg.cn/blog_migrate/7abbff5d6f128e9493967b4a75474299.png)
![](https://i-blog.csdnimg.cn/blog_migrate/d3cc46efdebb6ccc883712732f5d1238.png)
![](https://i-blog.csdnimg.cn/blog_migrate/f87bfced63f6d96464f06713b60bdc67.png)
![](https://i-blog.csdnimg.cn/blog_migrate/4135411c1f401663eabc5b1e36328406.png)
数据类型转换
![](https://i-blog.csdnimg.cn/blog_migrate/70028850e99826ccaf40a456d5e1406b.png)
![](https://i-blog.csdnimg.cn/blog_migrate/49ee00e87affc461266c21be89612cee.png)
![](https://i-blog.csdnimg.cn/blog_migrate/75c6e0ba2e4aa3d5bfd49ce9754ffb8b.png)
![](https://i-blog.csdnimg.cn/blog_migrate/a21bffaf7f9deac149ba95de208ea8e0.png)
![](https://i-blog.csdnimg.cn/blog_migrate/17ac91480fbadba7b79d68e19de684bd.png)
![](https://i-blog.csdnimg.cn/blog_migrate/eceb2684d04e76bf58848485fd1264ce.png)
![](https://i-blog.csdnimg.cn/blog_migrate/37851f180d3fee3b1cbdf850308d153b.png)
字符与ASCII码转换
![](https://i-blog.csdnimg.cn/blog_migrate/cfe77bf2073f93045397db5a839e7611.png)
![](https://i-blog.csdnimg.cn/blog_migrate/90c8ef4017f12fdfa5aa174160a47501.png)
常见的数学计算
![](https://i-blog.csdnimg.cn/blog_migrate/dbb1d1028c6de099c8180c7e869e8c35.png)
输入与输出
![](https://i-blog.csdnimg.cn/blog_migrate/c127476ec13e5f5a96c1070b6cca69e0.png)
![](https://i-blog.csdnimg.cn/blog_migrate/47f2238b8f2db40c3da356e5a179d66b.png)
![](https://i-blog.csdnimg.cn/blog_migrate/10f872b30c2a905b01ba745151ceac4b.png)
算术运算符
![](https://i-blog.csdnimg.cn/blog_migrate/abd437ca9a0e0e71bae118e0022751a4.png)
比较运算符
![](https://i-blog.csdnimg.cn/blog_migrate/f9a7f7704c15fed6da55b1f97c63a8ad.png)
赋值运算符
![](https://i-blog.csdnimg.cn/blog_migrate/e008d504f6fcfd6eb3e06a6acc560551.png)
![](https://i-blog.csdnimg.cn/blog_migrate/6d178bab77c4948c4fad4c20850970be.png)
位运输符
![](https://i-blog.csdnimg.cn/blog_migrate/eda1672317b641e48a0611ae65e32c3d.png)
成员运算符
![](https://i-blog.csdnimg.cn/blog_migrate/beaca85bf112ca9547b0788f7bf003e1.png)
身份运算符
![](https://i-blog.csdnimg.cn/blog_migrate/41ae567e00d46ea779b881237ed52dd6.png)
![](https://i-blog.csdnimg.cn/blog_migrate/0684d59c05be93b6978c767bdec84135.png)
![](https://i-blog.csdnimg.cn/blog_migrate/56f8253e90ba9d490357a2882581c7e7.png)
条件判断
![](https://i-blog.csdnimg.cn/blog_migrate/21a2769b0d0658a0bec0338c5dbe3f2d.png)
循环语句
![](https://i-blog.csdnimg.cn/blog_migrate/bc95415bc1fd90f2d38ee8319cfd4405.png)
![](https://i-blog.csdnimg.cn/blog_migrate/6955811141ad1476f53821c89445a3b9.png)
数组列表:
序列:序列是指一组有序的数据集合,其本质是一块存储多个值的连续内存空间。每个值在序列中都有对应的位置编号,即索引,这些值具有一定的顺序,可以通过索引访问对应的值。序列不是一种特定的数据类型,而是一种存储数据的方式。字符串,元组,集合,字典都可以是序列
序列通用操作
>>> 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
[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)
遍历问题
# 通过角标遍历
for i in range(len(arr)):
print(arr[i])
# 通过foreach遍历
for num in arr:
print(num)
最值问题
# 最大值
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)
存在性问题
# 元素是否存在
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)
翻转问题
# 0 1 2 3 4 5 6 7 8 9 角标
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)
排序算法
插入排序
插入排序(Insertion Sort)的基本思路是将一个未排序的数列,逐个插入到已排序的数列中,使得插入后的数列仍然有序。插入排序的优点是实现简单,适用于小规模的数据排序,时间复杂度为O(n^2),空间复杂度为O(1)。但是,对于大规模数据的排序,插入排序的效率较低。
实现步骤
(1)设数组长度为n。
(2)将第1个元素看成已排序部分,第2个元素到第n个元素看成未排序部分。
(3)从未排序部分取出第1个元素,将其插入已排序部分的合适位置。此时已排序部分的长度为1。
(4)从未排序部分取出第2个元素将其插入已排序部分的合适位置。此时已排序部分的长度为2。
(5)重复步骤4,直到所有元素都被插入到已排序部分。
选择排序
选择排序的基本思路是每次从未排序的数列中选择最小(或最大)的元素(最小即升序,最大即降序),将其放到已排序数列的末尾。重复这个过程,直到所有元素都被排序为止。选择排序是一种简单但效率较低的排序算法,其时间复杂度为O(n^2),不适用于大规模数据的排序。
实现步骤
(1)设数组长度为n。
(2)从数组中找到最小的元素,并记录其下标。
(3)将最小元素与第1个元素交换位置。
(4)在剩下的n-1个元素中,找到最小的元素,记录其下标。
(5)将最小元素与第2个元素交换位置。
(6)重复步骤4-5,直到排序完成。
冒泡排序
冒泡排序的基本思想是比较相邻两个元素的大小,如果顺序不对则交换它们的位置,一直重复这个过程直到整个序列有序。它的时间复杂度为O(n^2),因此对于较大的数据集不太适用,但对于小型数据集和教学目的来说是一种不错的选择。
实现步骤
(1)设数组为长度为n。
(2)从第一个元素开始,比较数组相邻的元素。如果前一个元素比后一个元素大,则交换他们的位置。经过一轮循环后,最后一个元素一定是本轮中最大的元素,因此下一轮循环时只需要比较前n-1个元素即可。
(3)不计最后一个元素,在剩下的n-1个元素中,重复步骤2,直到第一个元素(即在n-1个元素数中,继续比较相邻的元素)。
(4)重复步骤3,直到第一个元素结束,此时数组升序。
堆排序
堆排序(Heap Sort)是一种基于完全二叉树的排序算法,它的基本思想是将待排序的序列看成一棵完全二叉树,并将其构建成一个大根堆(或小根堆),然后将堆顶元素与堆底元素交换(因为堆顶元素最大),并重新调整堆,使得剩余元素仍满足堆的性质,重复以上操作,直到所有元素有序为止。堆排序的时间复杂度为 O(nlogn),空间复杂度为 O(1)。在实际应用中,堆排序是一种常用的排序算法,可以用于处理各种规模的数据。
实现步骤
(1)将待排序的序列构建成一个大根堆(或小根堆),这一步可以使用 Heapify 操作实现,即从最后一个非叶子节点开始,依次向下调整每个子树,使其满足堆的性质。
(2)将堆顶元素与堆底元素交换,并将堆的大小减一,(即将最大的元素放到最后)。
(3)对堆顶元素进行下沉操作,使其重新满足堆的性质(即在剩余的数中找最大的元素)。
(4)重复步骤 2 和 3,直到堆的大小为 1,此时整个序列有序。
查找算法
二分查找:要求数据必须有序
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)
归并排序
归并排序是一种基于分治策略的排序算法。它的基本思想是将待排序的序列不断地分成两个子序列,直到每个子序列只有一个元素,然后将这些子序列进行合并,直到最终得到一个有序序列。归并排序的时间复杂度为O(nlogn),其中n为待排序序列的长度。归并排序是稳定的排序算法,即相等元素的相对位置不会改变。
实现步骤
(1)将序列中待排序数字分为若干组,每个数字分为一组。
(2)将若干组两两合并,保证合并的组都是有序的。
(3)重复第二步的操作,直到剩下最后一组即为有序数列。
插值查找:数据必须是有序的,除了要考虑位置还得考虑元素的分布情况
列表对象函数
字符串对象函数
可变对象与不可变对象
列表是可变对象:可以修改列表中的元素 甚至长度
字符串是不可变对象:不可以修改字符串中的元素 包括 长度
math和random的应用
# 导入math模块
import math
# Math模块提供了许多数学函数和常量,以下是一些常见的用法:
# 数学常数
pi_value = math.pi # pi_value = 3.141592653589793
e_value = math.e # e_value = 2.718281828459045
# 数学函数
# 平方根
sqrt_result = math.sqrt(16) # sqrt_result = 4.0
# 对数函数
log_result = math.log(10) # log_result = 2.302585092994046
log10_result = math.log10(100) # log10_result = 2.0
# 三角函数
sin_result = math.sin(math.pi/2) # sin_result = 1.0
cos_result = math.cos(math.pi) # cos_result = -1.0
tan_result = math.tan(0) # tan_result = 0.0
# 向上取整
ceil_result = math.ceil(4.3) # ceil_result = 5
# 向下取整
floor_result = math.floor(4.7) # floor_result = 4
# 绝对值
abs_result = math.fabs(-4.5) # abs_result = 4.5
# 阶乘
factorial_result = math.factorial(5) # factorial_result = 120
# 幂运算
power_result = math.pow(2, 3) # power_result = 8.0
# 最大公约数
gcd_result = math.gcd(12, 8) # gcd_result = 4
# 最小公倍数
lcm_result = math.lcm(12, 8) # lcm_result = 24
# 导入random模块
import random
# Random模块提供了生成随机数的功能,以下是一些常见的用法:
# 生成随机整数
random_integer = random.randint(1, 10) # 生成1到10之间的随机整数
# 生成随机浮点数
random_float = random.uniform(1.0, 5.0) # 生成1.0到5.0之间的随机浮点数
# 从列表中随机选择一个元素
my_list = [1, 2, 3, 4, 5]
random_choice = random.choice(my_list) # 从my_list中随机选择一个元素
# 打乱列表顺序
random.shuffle(my_list) # 将my_list中的元素顺序打乱
# 生成随机种子
random_seed = random.seed(10) # 生成随机种子,设置种子值为10
# 生成随机高斯分布数
random_gaussian = random.gauss(0, 1) # 生成均值为0,标准差为1的随机高斯分布数