文章目录
环境搭建环境安装相关下载地址
Python语言要点注释
类和对象行为属性继承组合面向对象编程面向过程编程变量与类型集合类型的操作类型转换表达式数学运算符比较运算符赋值运算符位运算符逻辑运算符运算符优先级
字符串控制语句条件判断语句循环控制语句循环中断命令列表推导式
函数模块__main__项目需求代码
环境搭建
环境安装相关下载地址
https://www.anaconda.com/distribution/https://docs.microsoft.com/en-us/visualstudio/releasenotes/vs2017-relnoteshttps://pytorch.org/https://opencv.org/releases/https://developer.nvidia.com/rdp/cudnn-download
Python语言
要点
建立整体概念非常重要。
注释
Python有3种注释方式：
‘’‘ ** ’‘’ 可注释多行
“”“ ** “”" 可注释多行
Python是从上往下执行的
'''
这是一个
python源文件
'''
"""这是一个
python源文件"""
print("1")
print("2")
print("3")
if True:
print("4")
print("5")
print("6")
类和对象
类：种类，归类。比如人类，动物，桌子等。对象（也叫实例）：种类的具体化。比如张三（人类的具体化），那只鸭子（动物类的具体化），这张桌子（桌子类的具体化）。实例化：把一个类具体化的过程。
class Person:
pass
p
= Person
()
行为
类之间有共同的行为（动作，方法，行为函数），在类中可以定义这种行为。比如人类都能说话。对象可以具体化执行某个行为。比如张三说了一句“您好”，李四说了句“新年快乐”。虽然都是说话这个行为，但说的内容不一样。
class Person:
def say(self
, content
):
print(content
)
zhang3
= Person
()
zhang3
.say
("您好")
li4
= Person
()
li4
.say
("新年好")
class Person:
def get(self
, obj
):
return obj
zhang3
= Person
()
print(zhang3
.get
("3元"))
class Person:
def __init__(self
):
print("Hello World.")
p
= Person
()
代码解读
Python中的默认行为：构造函数（特殊的行为）、成员函数（行为函数）。对象在被创建的时候，会自动执行。
class Person:
def __call__(self
):
print("调用__call__行为")
zhang3
= Person
()
zhang3
()
代码解读
__call__ 行为也是一种特殊行为，主要是在调用的时候直接使用()调用。
class Person:
def __init__(self
, name
, age
):
self
.name
= name
self
.age
= age
def __add__(self
, other
):
return self
.age
+ other
.age
zhang3
= Person
("张三", 32)
li4
= Person
("李四", 36)
print(zhang3
+ li4
)
代码解读
我们可以把一些基本的运算符号定义在对象运算操作上。这里定义了一个加法符号。因为Person相加没有直接意义，我们就定义Person相加就是年龄相加。
算术运算符的重载方法
方法名表达式说明
__add__(self, other)self + other加法__sub__(self, other)self - other减法__mul__(self, other)self * other乘法__truediv__(self, other)self / other除法__floordiv__(self, other)self // other地板法__mod__(self, other)self % other取模（求余）__pow__(self, other)self ** other幂运算
属性
类之间都有共同的属性，比如人类都有身高，性别等属性。每个人类对象的属性都有具体的值，比如张三身高1.72米，性别男。属性是可以被读取或者修改的。静态的东西称为属性，动态的东西称为行为。
class Person:
def __init__(self
, name
):
self
.name
= name
self
.height
= 1.72
self
.sex
= "男"
def show(self
):
print(self
.name
)
print(self
.height
)
print(self
.sex
)
p
= Person
("张三")
p
.show
()
p
.height
= 1.75
print(p
.height
)
继承
类是可以继承的。继承的类也继承了父类的行为和属性。
class Animal:
def __init__(self
, name
):
self
.name
= name
def show(self
):
print(self
.name
)
class Cat(Animal
):
def __init__(self
, name
):
super().__init__
(name
)
cat1
= Cat
("大白")
cat1
.show
()
组合
类与类之间不仅有继承关系，还有组合关系。比如人类是有眼睛类，鼻子类等等很多类别组合而成。我们可以把对象定义为属性的方式来组合类与类之间的关系。
class Eye:
def __init__(self
, color
):
self
.color
= color
class Nose:
def __init__(self
, shape
):
self
.shape
= shape
class Person:
def __init__(self
, eye
, nose
):
self
.eye
= eye
self
.nose
= nose
def show(self
):
print(self
.eye
.color
)
print(self
.nose
.shape
)
eye
= Eye
("黑色")
nose
= Nose
("挺拔")
p
= Person
(eye
, nose
)
p
.show
()
面向对象编程
把事物抽象成类，然后把类实例化，并通过实例化执行行为，修改属性，这种编程模式叫做面向对象的编程。
面向对象编程思想非常重要，它有助于对复杂问题的分解。在大型项目和复杂项目中，采用面向对象的编程模式，往往可以降低开发难度，代码结构更加清晰，扩展性更强。
面向对象指的是整体大的架构编程，面向过程是具体实现细节的编程
面向过程编程
面向对象编程中，行为的实现往往通过面向过程编程来实现。面向对象和面向过程是不冲突的，是相辅相成的。对整体结构的通过面向对象模式来设计，在实现行为通过面向过程来实现。按1，2，3，4，5这样的顺序实现一个算法的过程称为面向过程编程。
变量与类型
变量就是执行过程中可以被改变的量，类似属性。变量由名称和值构成，通过=号修改变量。(Python中 =表示赋值 ，==表示等于)变量是有类型的，类型包括：数字（整形、浮点型），布尔型，字符串，列表、元组、集合、字典，类。无论是基础类型还是面向对象中的类，我们都可以认为类型就是类，值就是对象。（类和对象绑在一起用）None是代表没有。
a
= 1
b
= 1.2
c
= "我爱中国"
e
= True
class Person:
pass
d
= Person
()
print("a=", a
)
print("b=", b
)
print("c=", c
)
print("d=", d
)
print("e=", e
)
print("========华丽分割线========")
a
= 2
b
= 3.8
c
= "中国爱我"
e
= False
print("a=", a
)
print("b=", b
)
print("c=", c
)
print("e=", e
)
集合类型的操作
list、tuple、set 操作类似。list能增删改查，tuple只能查，set里面没有重复的元素，但能增删。顺序索引从0开始。dict 的元素是 key-value 对（键值对），并且存储无顺序。列表嵌套与切片。
print(" ============ list 操作 ============")
a
= [1, 2, 3, 4]
print(len(a
))
print(a
[2])
a
[3] = 5
print(a
)
a
.remove
(a
[3])
print(a
)
a
.append
(8)
print(a
)
a
.insert
(2, 7)
print(a
)
a
.extend
([0, 2, 5])
print(a
)
b
= [7,8,9]
a
.append
(b
)
print(a
)
print(a
.index
(7))
a
.sort
()
print(a
)
a
.sort
(reverse
=True)
print(a
)
a
.clear
()
print(a
)
print(" ============ tuple 操作 ============")
a
= (1, 2, 3, 4)
print(len(a
))
print(a
[2])
print(a
.index
(4))
print(" ============ set 操作 ============")
a
= {9, 2, 3, 4}
print(len(a
))
a
.remove
(3)
print(a
)
a
.add
(5)
print(a
)
a
.add
(2)
print(a
)
代码解读
集合（set）是一个无序的不重复元素序列。可以使用大括号 { } 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。
print(" ============ dict 操作 ============")
a
= {"name": "zhang3", "sex": "男", "age": 36}
print(len(a
))
print(a
["name"])
a
["age"] = 37
print(a
)
a
["height"] = 1.72
print(a
)
a
.pop
("sex")
print(a
)
a
= [[1, 2], [3, 4], [5, 6], [7, 8], [9, 10], [11, 12], [13, 14], [15, 16]]
print(a
[0])
print(a
[1][0])
print(a
[2:])
print(a
[:4])
print(a
[::2])
print(a
[2:7:2])
print(a
[::-1])
print(a
[-1:2:-1])
代码解读
切片时，a[start : end : step] 其中 end 和 step 可以不写，end 的位置取不到，取头不取尾。step=-1，倒着取，类似于反序（颠倒顺序）。list的切片很简单，但是切片这一功能很重要，尤其在numpy和pytorch中。
类型转换
有些类型与类型之间是可以相互转换的。比如整数类型可以转为浮点型。猫类可以转换为动物类。如果类型之间不能转换，执行的时候代码会报错。比如"abc"字符串转换为数字。有些类型之间转换可能会丢失精度。比如浮点型转换为整数。类型转换有两种，隐式转换和显示转换。子类转父类，低精度转高精度可以隐式转换。其他的必须显示转换。可以通过type()查看当前变量类型。
举例
3 + 2.1 + 5 + 6 包含隐式转换，电脑需要把所有数字转为浮点型之后，才会进行加法运算。
a
= 1
print(type(a
))
b
= a
print(type(b
), b
)
b
= float(a
)
print(type(b
), b
)
print("=============================")
c
= [1, 2, 3]
print(type(c
))
d
= tuple(c
)
print(type(d
))
print("=============================")
e
= [1, 1, 2, 2, 3, 3]
print(e
)
print(list(set(e
)))
表达式
数学运算符
运算符描述实例
+加：两个对象相加a=20 b=10 a+b=30-减：得到负数或是一个数减去另一个数a=20 b=10 a-b=10*乘：两个数相乘或是返回一个被重复若干次的字符串a=20 b=10 a*b=200/除：两个数相除a=20 b=10 a/b=2%取模：返回除法的余数a=20 b=10 a%b=0**幂：返回x的y次幂x=3 y=4 x**y=81//取整除-返回商的整数部分（向下取整）9//2=4 -9//2=-5
比较运算符
运算符描述实例
==等于：比较对象是否相等(a==b) 返回 False!=不等于：比价两个对象是否不相等(a!=b) 返回 True<>不等于：比价两个对象是否不相等 Python3已废弃(a<>b) 返回 True>大于：返回a是否大于b(a>b) 返回 False<小于：返回a是否小于b 所有比较运算符返回1表示真，返回0表示假。这分别与特殊的变量True和False等价。(a<b) 返回 True>=大于等于：返回a是否大于等于b(a>=b) 返回 False<=小于等于：返回a是否小于等于b(a<=b) 返回 True
注释
表格中的变量a=1，b=2比较结果返回的是布尔型
print(3 == 2)
print(5 > 3)
print(4 < 3)
print(3 <= 3)
print(9 >= 8)
print(9 != 7)
赋值运算符
运算符描述实例
=简单的复制运算符c=a+b 将a+b的运算结果复制为c+=加法赋值运算符c+=a 等效于 c=c+a-=减法赋值运算符c-=a 等效于 c=c-a*=乘法赋值运算符c*=a 等效于 c=c*a/=除法赋值运算符c/=a 等效于 c=c/a%=取模赋值运算符c%=a 等效于 c=c%a**=幂赋值运算符c**=a 等效于 c=c**a//=取整除赋值运算符c//=a 等效于 c=c//a
赋值运算符实际上是一种简化的写法
a
= 4
a
+= 3
print(a
)
a
**= 2
print(a
)
位运算符
运算符描述实例
&按位与运算符：参与运算的两个值，如果两个相应位都为1，则该位的结果为1，否则为0（相同为真，不同为假）(a & b) 输出结果 12，二进制解释：0000 1100|按位或运算符：只要对应的两个二进位有一个为1时，结果位就位1(a | b) 输出结果 61，二进制解释：0011 1101^按位异或运算符：当两对应的二进位相异时，结果为1（相同为假，不同为真）(a ^ b) 输出结果 49，二进制解释：0011 0001~按位取反运算符：对数据的每个二进制位取反，即把1变为0，把0变为1。~x类似于-x-1(~a) 输出结果 -61，二进制解释：1100 0011，在一个有符号二进制数的补码形式。<<左移动运算符：运算数的各二进位全部左移若干位，由<<右边的数字指定移动的位数，高位丢弃，低位补0a << 2 输出结果 240，二进制解释：1111 0000>>右移动运算符：运算数的各二进位全部右移若干位，由>>右边的数字指定移动的位数，低位丢弃，高位补0a >> 2 输出结果 15，二进制解释：0000 1111
注释
表格中 a=60，二进制格式为 0011 1100；b=13，二进制格式为 0000 1101
a
= 60
b
= 13
print(bin(a
))
print(bin(b
))
print(a
& b
)
print(a
| b
)
print(a
^ b
)
print(~a
)
print(a
<< 2)
print(a
>> 2)
逻辑运算符
运算符逻辑表达式描述
andx and y布尔“与”：如果x为False，x and y返回False，否则返回y的计算值。orx or y布尔“或”：如果x是非0，它返回x的值，否则返回y的计算值。notnot x布尔“非”：如果x为True，返回False；如果x为False，返回True
print(3 < 4 and 7 > 2)
print(3 > 4 or 7 > 2)
print(not 3 > 4)
print(0 and 20)
print(10 and 20)
print(0 or 20)
print(10 or 20)
print(not(0 and 20))
print(not(0 or 20))
print(not(10 or 20))
print('a' and 'b')
print('a' and 'a')
print('True' and 'False')
print('True' or 'False')
print('False' or 'True')
print('None' or 'True')
代码解读
逻辑运算符中x和y可以是一个表达式，也可以是一个数字，或者字符串。如果x和y是两个表达式，则返回True或者False。
运算符优先级
运算符描述
**指数（最高优先级）~ + -按位翻转，一元加号和减号（最后两个的方法名为 +@ 和 -@）* / % //乘，除，取模，取整除+ -加法，减法>> <<右移，左移运算符&位“与” AND^ |位 “异或”，“或”<= < > >=比较运算符<> == !=（不）等于运算符= %= /= //= -= += *= **=赋值运算符is is not身份运算符in not in成员运算符not and or逻辑运算符
如果要改变优先级，可以使用 ()
a
="hello"
b
="hello"
print(a
is b
, a
==b
)
print(a
is not b
, a
!=b
)
a
=["hello"]
b
=["hello"]
print(a
is b
, a
==b
)
print(a
is not b
, a
!=b
)
代码解读
is, is not 对比的是两个变量的内存地址；==, != 对比的是两个变量的值。假如比较的两个变量，指向的都是不可变的类型（str, tuple等），那么is，is not 和 ==，!= 是完全等价的。假如对比的两个变量，指向的是可变的类型（list, dict等），则is，is not 和 ==，!= 是有区别的。
a
= 'A'
b
= 'D'
c
= ['A','B','C','H']
print(a
in c
)
print(a
not in c
)
print(b
in c
)
print(b
not in c
)
a
= [1, 2]
b
= [5, 6]
c
= [[1, 2], [3, 4]]
print(a
in c
)
print(a
not in c
)
print(b
in c
)
print(b
not in c
)
b
= 1
c
= (1, 2, 3, 4)
print(b
in c
)
print(b
not in c
)
b
= 1
c
= {1, 2, 3, 4}
print(b
in c
)
print(b
not in c
)
a
= 18
b
= 'name'
c
= {'name': 'Tom', 'age': 18}
print(a
in c
)
print(b
in c
)
print(b
not in c
)
代码解读
成员运算符可用于判定某一个字符串、数字、列表等是否在某一个列表、元组、集合、字典等中。
字符串
字符串连接转义字符运算格式化
a
= "hello"
b
= "world"
c
= a
+ " " + b
print(c
)
print("=========================")
d
= a
+ "\n" + b
print(d
)
print("=========================")
print("hello\nworld")
print(r
"hello\nworld")
print("=========================")
print(a
[1:])
print("=========================111")
print(a
.index
("llo"))
print(a
.find
("lo"))
print("=========================")
print("{} {}!".format(a
, b
))
print(f
"{a} {b}!")
代码解读
使用index和find查找字串索引时，两者是有一点区别的，如果不存在该字串，index会报错，find会返回-1。字符串格式化非常重要，经常使用format的方式。
控制语句
数据都放在变量里面，变量与变量之间的交互(流程)，是需要控制语句来控制的。“程序”，“序”，就是流程。
条件判断语句
Created with Raphaël 2.2.0
Start
条件
条件代码
End
yes
no
a
= True
if a
:
print("当前 a = True")
else:
print("当前 a = False")
print("============================")
b
= 2
if b
== 0:
print("当前 b = 0")
elif b
== 1:
print("当前 b = 1")
else:
print("当前 b = 其它")
代码解读
elif else 不是必须要有的。
循环控制语句
Created with Raphaël 2.2.0
Start
条件
条件代码
End
yes
no
for i
in range(3, 10, 2):
print(i
, end
=" ")
print("\n=======================")
a_list
= {4, 5, 6, 7, 8, 9}
for a
in a_list
:
print(a
, end
=" ")
print("\n=======================")
for i
, a
in enumerate(a_list
):
print(i
, ":", a
)
print("\n=======================")
b_dict
= {"name": "zhang3", "sex": "男", "age": 36}
for key
, value
in b_dict
.items
():
print(key
, ":", value
)
循环中断命令
continue：本次循环终止，继续下轮循环break：跳出循环，整个循环终止
for i
in range(10):
if i
== 5:
continue
print(i
, end
=" ")
print("\n=======================")
for i
in range(10):
if i
== 5:
break
print(i
, end
=" ")
列表推导式
对于list的循环操作，我们可以用列表推导式来简化。
a_list
= [1, 2, 3, 4, 5, 6]
b_list
= []
for a
in a_list
:
b_list
.append
(a
* 2)
print(b_list
)
c_list
= [x
* 2 for x
in a_list
]
print(c_list
)
函数
函数与类的方法非常相似，只是函数不依赖类，并且第一个参数不是self函数的语法如下：
def functionname(parameters
):
function_suite
return [expression
]
functionname
(parameters
)
def add(a
, b
):
c
= a
+ b
return c
if __name__
== '__main__':
d
= add
(3, 5)
print(d
)
模块
我们经常将代码规划到多个python文件中，然后相互调用。每个python文件都是一个模块。模块导入语法：
from ... import ... as ...
模块调用语法：
模块名
, 函数名
模块名
, 变量
import AddFn
as F
print(F
.add
(3, 4))
main
在python文件中的功能被导入的时候，为了防止测试代码被导入，需要将测试代码（不应该被导入的代码）放在__main__函数下面。
def add(a
, b
):
c
= a
+ b
return c
if __name__
== '__main__':
d
= add
(3, 5)
print(d
)
项目
需求
定义矩阵，并完成矩阵的加法操作。
代码
class Matrix:
def __init__(self
, data
):
self
.data
= data
def __add__(self
, other
):
a_row
= len(self
.data
)
a_col
= len(self
.data
[0])
b_row
= len(other
.data
)
b_col
= len(other
.data
[0])
if a_row
!= b_row
and a_col
!= b_col
:
return "形状不同，不能相加"
for row
in range(a_row
):
for col
in range(a_col
):
self
.data
[row
][col
] += other
.data
[row
][col
]
return self
def __str__(self
):
return str(self
.data
)
if __name__
== '__main__':
a
= Matrix
([[1, 2], [3, 4]])
b
= Matrix
([[5, 6], [7, 8]])
print(a
+ b
)
备注：部分内容摘录自其它网站，若有侵权，请联系作者删除！
