pyhon语法快速上手-优快云博客

pip install -i https://mirrors.tuna.tsinghua.edu.cn/pypi/web/simple opencv-python


C:\Users\sponge>python -c "import cv2; print(f'OpenCV版本: {cv2.__version__}')"
OpenCV版本: 4.11.0

一.3种注释

#print("hello world1")

"""
print("hello world2")
"""

'''
print("hello world3")
'''

二.输出变量

1.输出变量

a=123
print(a)
print(f'hello1 {a}')
print('hello2 %d'%a)

2.结束符end

end表示结束符，默认end=“\n”

print("hello world1",end=" ")
print("hello world2")
print("hello world3")

三.input输入变量

input默认字符串类型，可强制类型转换

a=int(input('请输入：'))
print(a)

四.生成随机数random

功能场景	Python 标准库`random`	NumPy`numpy.random`
生成整数随机数	`randint(a, b)`：闭区间`[a, b]`	`randint(low, high=None, size=None)`：半开区间`[low, high)`，支持`size`参数指定数组形状
生成浮点数随机数	`random()`：范围`[0.0, 1.0)` `uniform(a, b)`：范围`[a, b]`	`random(size=None)`：支持`size`参数生成数组 `uniform(low, high, size)`：范围`[low, high)`

1. random模块

import random
a=random.randint(1,10)  #生成整数随机数
b=random.uniform(1,10)  #生成浮点数随机数
c=random.random()       #生成 [0, 1) 的浮点数
print(a,b,c)

、

2.numpy中的random模块

np.random.randint(low, high=None, size=None, dtype=int)

功能：生成指定范围内的整数随机数。
参数：
- low：下限（闭区间）。
- high：上限（开区间，默认None时生成[0, low)的整数）。
- size：输出数组的形状（如3、(2,3)）。
- dtype：数据类型（默认int，可选np.int32、np.uint8等）。

np.random.randint(1, 5)        # 生成1到4之间的单个整数
np.random.randint(5, size=3)   # 生成3个0到4之间的整数
np.random.randint(1, 5, (2,3)) # 生成2x3的整数矩阵

五.整数可自动变为小数、**为次方

a=10
a/=3
print(a)

b=10
b**=3
print(b)

六.or对应||，and对应&&

a = False
b = not a
c = (a and  (b or not a)) or a
print(a,b,c)

七.字符可加、可乘

a='ab'
b='cd'
c=a+b
d=a*2+b
print(c,d)

——————abcd ababcd

八.循环语句

1.if、else示例，if，while，for不用加括号而用：

Python使用冒号(:)和缩进代替其他语言的括号和花括号
条件表达式本身可以加括号（但不改变语义），但控制语句关键字后绝对不能加

语句类型	正确写法	错误写法（带括号）
`while`	`while a < 10:`	`while (a < 10):` ❌
`if`	`if a == 5:`	`if (a == 5):` ❌
`for`	`for i in range(5):`	`for (i in range(5)):` ❌

2.for循环示例

range[5] 相当 [0,5)，即0、1、2、3、4

#[0,1,2,3,4,5,6,7,8,9]
for i in range(10):    i是range序列里的一个元素
    print(i)        输出：竖着打印0、1、2、3…… 8、9
    
for i in range(1, 256):    打印从1~255这个序列，因为是左闭右开
    print(i)

arr=[1,2,3,4,5]
for j in arr:
    print(j)        输出：竖着打印1、2、3、4、5

string="ABCDEFG"
for i in string:
    print(i)        输出：竖着打印A、B、C…… G

竖着打印例如：

3.for、while循环搭配else

for i in range(10):
    print(i)
    if i==5:
        break
else:
    print('正常结束')

a=0
while a<5:
    a+=1
else:
    print('end')

九.字符串切片

1.a[1:5]

a=a[1:5] ————左闭右开，切出下标为1、2、3、4的元素，不包括下标为5的元素

a='my name is XXX'
a=a[1:5]    左闭右开，切出下标为1、2、3、4的元素
print(a) 
    ————a=y na

————y na

2.切片各种示例

s = "Hello, World!"
print(s[7:])    # 输出: World!（从索引7开始到结尾）
print(s[:5])    # 输出: Hello（从开头到索引5之前，即开头到索引5的左闭右开）
print(s[3:8])   # 输出: lo, W（从索引3到索引8的左闭右开，即索引3到索引7）
print(s[::2])   # 输出: Hlo ol!（每隔一个字符取一个）步长2是序列操作中跳过元素的间隔数
print(s[::-1])  # 输出: !dlroW ,olleH（反转字符串）
print(s[:])     # 输出: Hello, World!（全部）
print(s[-5:-1])    # 输出: orld 倒数第五个到倒数第一个的左闭右开

❌不用看下面这个例子了❌

a='my name is XXX'
a1=a[:5]    从开始到下标5的左闭右开，即从0到4
print(a1)
    ————my na
a2=a[1:]    从1开始到结尾
print(a2)
    ————y name is XXX
a3=a[:]    全部
print(a3)
    ————my name is XXX
a4=a[1:5:2]  步长2是序列操作中跳过元素的间隔数
print(a4) 
    ————yn
a5=a[::-1]    把字符串反过来
print(a5)
    ————XXX si eman ym
a6=a[-5:-1]   倒数第五个到倒数第一个的左闭右开
print(a6)
    ————s XX

十.字符串操作

1.替换replace

a='my name is XXX'
a=a.replace('XXX','pig')
print(a)

————my name is pig

2.拼接字符串除了直接相加，还可以用join

a=["Hello", "World", "!"]
b="+".join(a)
print(b) # 输出: Hello+World+!

将 a 列表中的所有字符串连接起来，并且使用字符串 "+" 作为连接符。

3.其他操作

十一.与c一样的索引访问

十二.列表（数组）

0.一维列表初始化

（1）把arr1元素全初始化为0

arr1 = [0 for i in range(5)]
for i in range(5):
    print(arr1[i])

（2） numpy一维数组初始化

①

import numpy as np

# 1.从列表创建
arr = np.array([1, 2, 3, 4])
print(arr)  # 输出: [1 2 3 4]

# 2.指定数据类型为浮点数
float_arr = np.array([1, 2, 3], dtype=np.float64)

②固定值数组

# 3.长度为5的全0数组
zeros_arr = np.zeros(5)  # 输出: [0. 0. 0. 0. 0.]

# 4.长度为3的全1数组（整数类型）
ones_arr = np.ones(3, dtype=int)  # 输出: [1 1 1]

# 5.长度为4的全5数组
full_arr = np.full(4, 5)  # 输出: [5 5 5 5]

1.二维列表

a=[1,2,3]

b=6

（1）二维列表初始化

外层m行，内层每行n个0

m, n = 3, 4  # 行数、列数
arr2 = [[0 for _ in range(n)] for _ in range(m)]
print(arr2)

（2）numpy二维数组初始化

用于定义卷积核，因为后续用到 cv2.filter2D() 等函数进行卷积操作，该函数 要求卷积核必须是 NumPy 数组

 kernel_x = np.array([[1, 0], [0, -1]], dtype=np.float32)

如果直接kernel_x =[[1, 0], [0, -1]]，会触发 类型错误（TypeError），因为 OpenCV 无法处理原生 Python 列表。

（3）numpy中初始化全0数组

NumPy 数组的底层数据缓冲区是在堆上分配的，类似于C++中的malloc

import numpy as np

# 创建一个形状为 (3, 4) 的全零二维数组（3行4列）
arr = np.zeros((3, 4)，dtype=np.uint8)
print(arr)

# 创建3×4的全0数组
zeros_arr = np.zeros((3, 4))  # 形状用元组(3, 4)表示

# 创建2×2的全1数组
ones_arr = np.ones((2, 2), dtype=np.int32)  # 指定整数类型

# 创建3×3的全5数组
full_arr = np.full((3, 3), 5)

输出：[[0. 0. 0. 0.] [0. 0. 0. 0.] [0. 0. 0. 0.]]

参数1：(3, 4)——指定数组的形状（shape），用元组表示。对于图像，通常是 (高度, 宽度)。
参数2：dtype=np.uint8（如果不写，默认类型是float）：指定数组的数据类型。在图像处理中，通常用 uint8（无符号 8 位整数，范围 0-255）表示像素值。

2.三维列表

3.遍历三维列表

a是array中的子元素、b是a中的子元素、c是b中的子元素

4.判断一个元素是否在列表中（列表什么类型元素任意放）

5.判断一个元素是否不在列表中

6.append追加元素、insert插入元素、pop删除元素、remove删除元素、clear清空元素、del删列表

b=12
a= [1,False,"happy", b,[1,2,3]]
a.append ("abc")    #在列表尾部追加一个字符串元素"abc"
print(a)    #输出：[1, False, 'happy', 12, [1, 2, 3], 'abc']

a= [1,False,"happy", b,[1,2,3]]
a.insert(1,'t')     #在索引1的前面加上元素't'
print(a)    #输出：[1, 't', False, 'happy', 12, [1, 2, 3]]

a= [1,False,"happy", b,[1,2,3]]
a.pop(0)           #删除索引0的元素
print(a)    #输出：[False, 'happy', 12, [1, 2, 3]]

a= [1,False,"happy", b,[1,2,3]]
a.remove("happy")  #删除指定元素
print(a)    #输出：[1, False, 12, [1, 2, 3]]

a= [1,False,"happy", b,[1,2,3]]
a.clear()          #清空列表元素
print(a)    #输出：[]

del a   #直接删除列表a

7.列表可直接修改元素，字符串不可

字符串不可修改，因为字符串是不可变数据类型

8.列表的拷贝

了解深浅拷贝的区别：把这两个链接结合看C++入门：构造函数，析构函数，拷贝构造函数，运算符重载详解_构造函数的重载规则-优快云博客

大标题三—> 小标题 2 —>小小标题 <5

C++:vector类【后序】（模拟实现）+深拷贝_c++ vector 深拷贝-优快云博客

大标题三—> 小标题 1

不愿意看的话，直接总结来说：在c++中举例，浅拷贝只适用于日期类这种数据成员中没有指针的类，不适用栈类这种数据成员中有指针的类，如果对

浅拷贝，它能够完成类成员的一一复制。当数据成员中没有指针时，浅拷贝是可行的；但当数据成员中有指针时，如果采用简单的浅拷贝，则两类中的两个指针将指向同一个地址，当对象快结束时，会调用两次析构函数，而导致指针悬挂现象，所以，此时，必须采用深拷贝。
深拷贝与浅拷贝的区别就在于深拷贝对于第一个对象中的指针指向的数据，在拷贝出第二个对象时，会在堆内存中另外申请空间来储存一份同样的数据，从而也就解决了指针悬挂的问题。而浅拷贝会导致拷贝出第二个对象时，仅仅把第一个对象的指针复制进第二个对象中，这俩对象的指针会指向同一空间，这样修改第二个对象中指针指向的数据时，第一个对象中的这部分数据也会被修改。简而言之，当数据成员中有指针时，必须要用深拷贝。

b=12
a= [1,False,"happy", b,[1,2,3]]
c=a            #①仅仅拷贝指针
d=a.copy()     #②独立开辟空间再赋值给d

d.append(5)
d[4].append(4)
print("原始列表 a:", a)  输出:原始列表 a: [1, False, 'happy', 12, [1, 2, 3, 4]]
print("拷贝列表 d:", d)  输出:拷贝列表 d: [1, False, 'happy', 12, [1, 2, 3, 4], 5]

①此处c=a：c和a都指向完全相同的数据

②d=a.copy()：d是a的浅拷贝，1，False，"happy", b这些，它属于基本数据类型，直接浅拷贝，自己也有一份，改的就是自己的；而[1,2,3,4]这种，本质d里面拷贝的是a的[1,2,3,4]的首元素地址。所以a、d里面的【1，2，3，4】本质都是一个，因为他们地址一样。所以正常情况还是得用深拷贝deepcopy才能完全把内部的列表（实际是指针）彻底分离、互不影响。

9.排序

sort是直接修改a里面的元素，而sorted有返回值

a=[4,2,3,1]
a.sort()        #直接把a排序
a=sorted(a)     #排序完返回一个列表

10.列表与元组

（1）元组不可修改，只可访问

a=[1,2,3]    列表
b=(1,2,3)    元组

a[0]=5        
print(b[0])

特性	列表（List）	元组（Tuple）
可变性	✅ 可变（Mutable）	❌ 不可变（Immutable）
语法标识	方括号 `[]`	圆括号 `()`（可省略）
内存占用	较大（动态扩容）	较小（固定分配）
性能	增删慢（平均O(n)）	访问快（O(1)）
适用场景	需要修改的数据集合	固定数据（如坐标、配置项）

（2）两种遍历

第一个直接遍历，第二个是索引遍历

a=(1,2,3,4,5)
for i in a:
    print(i,end="")

print()    #打印一个换行

for i in range(len(a)):
    print(a[i],end="")

十三.集合

1.介绍

在python中，一般通过花括号或set来定义一个集合，例如

S = set()   # 定义一个空的集合
S1={}    #这是一个空字典了

使用花括号定义一个有数据的集合，元素可以是数字、字符串、元组等

S = {1.1, "AA", ("X", "Y")}

注意：由于定义集合的符号与字典一致，所以当定义一个空的花括号会被识别为字典，而不是集合

集合的特点：

集合中的元素是唯一的，重复的元素会被自动忽略。
集合是无序的，元素没有固定的位置。
集合中的元素必须是可哈希的，因此，只能包含不可变对象，如数字、字符串、元组等。
集合支持常用的集合操作，如并集、交集、差集等。

S = {1, 2, 2, 4,4}
print(S)        #输出：{1, 2, 4}

2.添加元素

常用的两种添加元素方法：

add：向集合中添加一个元素。如果集合中已经存在该元素，则不会进行任何操作。
update：向集合中添加一个或多个元素，参数可以是可迭代对象。

【示例一】添加一个元素 add

S = {"A", "B"}
S.add(10)
print(S)

输出：{'A', 10, 'B'}

【示例二】添加多个元素 update

S = {"A", "B"}
S.update([1, 2, 3])
print(S)

输出：{1, 2, 3, 'A', 'B'}

3.删除元素

常见有4种删除元素的方法：

remove：如果元素在集合中，则移除该元素，否则会引发 KeyError 错误。
discard：如果元素在集合中，则移除该元素，否则不做任何操作。
pop：随机移除并返回集合中的一个元素。如果集合为空，会引发 KeyError 错误。
clear：移除集合中所有的元素

S={"A","B","C","D","E","F","G","H"}
S.remove('A')
print(S)  #输出:{'B', 'E', 'C', 'H', 'F', 'G', 'D'}
S.discard('B')
print(S)  #输出:{'E', 'C', 'H', 'F', 'G', 'D'}
S.pop()
print(S)  #输出:{'C', 'H', 'F', 'G', 'D'}
S.clear()
print(S)  #输出:set()

4.修改元素

集合是无序且不可更改的，所以需要修改某个元素时只能先删除，后添加

S = {"A", "B", "C"}
 
# 移除B
S.discard("B")
 
# 添加E
S.add("E")

5. 访问元素

集合一般是用于存储唯一元素的无序数据结构，重点在于元素的唯一性和高效的成员关系测试。所以它的重点并不是用于访问单个元素，而是用于快速读取。

S = {1, 2, "A", "B"}
for i in S:
    print(f"当前元素是: {i}")

6.统计元素

S = {1, 2,3, 4}
print(len(S))    统计元素个数            输出：4
print(max(S))    求最大值（仅全数字）     输出：4
print(min(S))    求最小值（仅全数字）     输出：1
print(sum(S))    求和（仅全数字）         输出：10

7.计算列表不重数个数

S = [1, 2, 2, 3, "A", "A"]  # 示例输入（列表）
step1 = set(S)               # 去重：{1, 2, 3, "A"}
step2 = len(step1)           # 计算唯一元素数量：4
print(step2)                 # 输出：4

8.成员检查

集合提供了一种高效的方法来检查元素是否属于某个集合。使用集合的成员关系操作，可以快速判断一个元素是否在集合中。

在集合中一般通过 in 判断某个元素是否存在。成功为True，失败为False

S = {1, 2, "A", "B"}
print("A" in S)        输出：True
print("A" not in S)    输出：Flase

十四.字典

1.介绍

字典中元素是一个个键值对

2.各种字典操作

d =  {"name":"sponge", "age" :20}
d.keys()              取出所有key值
# ['name', 'age']
d.values()            取出所有val值
#['sponge',20]
d.items()             返回键值对组成的元组，元组又靠列表包着
#[('name','sponge'),('age',20)]
for k,v in d.items():    遍历
    print(k)
    print(v)

d = {"name" : "sponge", "age": 20}
print(d["name"])            访问值
d["name"] ="squidward"      修改值
del d["age"]                删除值
d.clear()                   清空字典
del d                       删除字典

十五.定义函数

1.定义格式

def function():
    print('hello world1')
for i in range(5):
    function()

2.形参、实参

n是形参、num是实参

3.函数使用外部变量

函数使用外部变量要用global关键字声明这是一个外部变量

4.函数的形参可以用冒号标识类型

5.函数返回元组、元组的拆包

def g():
    return 1,2
a=g()   #变成元组
print(a)
a,b=g() #元组的拆包
print(a,b)

输出：

(1, 2)
1 2

6.不定长参数 args

不定长参数允许函数接受可变数量的参数。下面g函数里面，n是普通参数，要写到不定长参数前面，调用中实参填入的“1”传入n这个普通参数中。args是不定长参数，可以传任意个参数，调用中实参填入的“2,3,4,5,6”传入不定长参数中。

def g(n,*args):
    print(f"n:{n}")
    for i in args:
        print(f"args:{i}",end=" ")
g(1,2,3,4,5,6)

输出：

n:1
args:2 args:3 args:4 args:5 args:6

7.包裹关键字参数

传入的是字典

def func(**kwargs):
    print(kwargs)  # kwargs 是一个字典

func(name="Alice", age=25)  # 输出: {'name': 'Alice', 'age': 25}

十六.调试

启动调试：Shift + F9

操作	功能描述
F9	跳到下一个断点
`F8`	执行当前行并跳到下一行，不进入函数内部（适合跳过已知正确的代码）。
`F7`	进入当前函数内部（如调试`calculate_average()`时，按`F7`进入函数体）。
`Alt + Shift + F7`	只进入自己项目的代码，忽略库函数（如跳过 NumPy 内部实现）。
`Shift + F8`	从当前函数返回到调用处（执行完当前函数剩余代码并跳出）。
`Alt + F9`	快速执行到光标所在位置（无需设置断点，适合跳过大量无关代码）。