第2节a. 最全够用的python基础语法（小白版）

原创 于 2026-02-13 20:45:00 发布 · 442 阅读 · 7 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
GEO检测
收录于
深度学习和机器学习专栏

当前文章被收录于：

深度学习和机器学习专栏
9 篇文章 0 人学习

自学写一些七七八八的diary。李哥课程心得记录

订阅专栏 查看详情

#python接近于人的使用习惯

#掌握一门语言的内核，学4个点：陈述、循环、 判断、函数

#使用PyCharm以及如何新建并运行一个项目，方法如下

一、PyCharm

1、新建项目

安装好以后，点击软件运行，点击左上角文件-新建文件

如果有先前配置的解释器可以点击下方【先前配置的解释器】；若没有，可以【使用此工具新建环境】

会显示正在创建新项目，然后出现一个空白项目如下。其中左上角是会出现的所有项目

右键项目，再点击运行。或使用快捷键shift+F10

下方会出现hi PyCharm

也可以点右上角的运行，但这里的运行是指最近运行的项目，不一定是当前界面里的项目，比如现在再打开一个新建项目test随便写一点代码，随便点一个运行、再点击右上角的运行，会发现出现的还是这个新建项目test的结果

所以还是建议新手老老实实按照项目右键-运行来

2、解释器设置

右下角点击这里点击

解释器设置

设置-全部显示

再点击应用，可以发现环境里面有很多包，再点击确定

环境至此搭建完成。要看这里的环境是怎么安装的，详见《00-Conda\PyTorch\PyCharm深度学习环境安装》

3、Pycharm的常用快捷键

ctrl+/         选中部分全部解释，或取消解释

：             冒号后敲回车键会自动缩进

tab            即4个空格，完成Python中最基础的缩进

shift+tab   选中部分取消4个空格的缩进

二、Python的基本语法

以下可以在上面搭建好的环境里敲代码来试运行

1、数据结构-赋值语句

整型、浮点型

a=3
b=4       #整型
a=3.0     #浮点型
name="ligekaoyan"  #字符串型
print(a)
print(a,b)
print(name)
print(name[2])    #输出字符串中的第2个元素，即g
a,b=b,a   #交换a、b的值
print(a,b)

列表、字典、字符串

List1=[1,2,3,4,5]
print(list1)
print(list1[2])   #输出元素3
print(list1[-1])  #其他语言访问到最后一个元素需要O(n)的复杂度，这是Python的一大优势
#字典 哈希表 dict{}
#key:value，要用字符串或数字作为key值
dict1 = {"name":"ligekaoyan","age"=28,20:80}
print(dict1["name"])
print(dict1["age"])
print(dict1[20])

#可以让字典、数字、字符串同时存在于list列表中
#python的语法非常自由
list2=[1,"art",dit1]
print(list2)

2、判断judge、缩进、空值

以上为陈述语句，以下为判断

a=3
if a==3:
    print("正确的")
    print("今天天气好")

if a==4:
    print("错误的")


#最终输出的结果是正确的  今天天气好
#python的输出结果会自动换行

嵌套判断，注意你的if下面有没有缩进，代表是不是属于同一“套”里面的嵌套

a=3
b=4
if a==3:
    if b>3:
        print("正确的")
    else:
        print("b不大于a")
if a!=4:
    print("错误的")

#最终会输出 正确的  错误的

#靠缩进表达对应关系的，Python的缩进一定要严谨

空，即None

A=None
if A==None:
    print("A是空")

#最终会输出  A是空

3、循环语句

for……in……；while

列表+for循环

#for i in 范围     不可以是数值  可以是list、range

list1 = [1,2,3,4,5]
for i in list1:
    print(i)
#会输出自动换行的1 2 3 4 5

for i in range(10):         #左闭右开
    print (i)
#会输出自动换行的0 1 2 3 4 5 6 7 8 9

for i in range(1,10):
    print (i)
#会输出自动换行的1 2 3 4 5 6 7 8 9

for i in range(1,10,2):           #1是开头，10是结尾，2是步长
    print (i)
#会输出自动换行的1 3 5 7 9

字典+for循环

dict1 = {"name":"ligekaoyan","age":28,20:80}
print(dict1)


for each in dict1:
    print(each)            #会输出dict1中的每一个key值
    print(dict1[each])     #会输出dict1中的每一个value值

#字典顾名思义，作用就是给一个key值，查找一个value值，像查字典一样

while 循环

i=0
while i<10:
    i+=1
    print(i)
#会输出自动换行的1 2 3 4 5 6 7 8 9 10

4、列表的切片、插入、删除

列表的切片

list1=[1,2,3,4,5]
for each in list1:
    print(each)

#切片是Python的神器
print(list1[1:4])   #左闭右开，往下要召唤出第1个到第3个元素
print(list1[1:-1]
#一个效果，会输出[2,3,4]

print(list1[0:4])
#会输出[1,2,3,4]

print(list1[1:])    #冒号后面没有值，表示到终点（含）才结束
print(list1[:])     #冒号前面、后面没有值，表示从开头打印到结尾

列表的切片+循环遍历

list1=[1,2,3,4,5]
for i in list1[1:4]:
    print(i)
#会输出自动换行的2 3 4

list2=[1,"art",dict1]
dict1={"name":"ligekaoyan","age":28,20:80}
print(list2)
for each in list2:
    print(each)
#会输出自动换行的list2中的元素

删除

remove后跟的是真实值

del后跟的是下标

list1=[1,2,3,4,5,6]
print(list1)
#会输出[1,2,3,4,5,6]

list1.remove(4)    #此处的4指的不是下标，是指真实值
print(list1)
#会输出[1,2,3,5,6]

list2=[1,2,3,4,5,6]
del list2[3]       #此处的3指的是下标
print(list2)
#会输出[1,2,3,5,6]

插入

append插入元素

extend插入列表

list1=[1,2,3,10,5,6]
print(list1)
list1.append(7)        #可以插入元素
print(list1)
#会输出[1,2,3,10,5,6,7]

list1=[1,2,3,10,5,6]
list1.extend([8,9])   #可以插入列表
print(list1)
#会输出[1,2,3,10,5,6,8,9]

循环后置、切片循环后置，极大地简化了代码


list2=[i for i in range(10)]   #相当于for i in range(10)
print(list2)
#会输出[0,1,2,3,4,5,6,7,8,9]

list3=[]
for i in range (10):
     list3.append(i)
print(list3)
#一样的效果，输出同上

#极大地简化了代码

list4=[i for i in range(1,10,2)]   #切片+循环后置  
print(list2)
#会输出[1,3,5,7,9]

5、函数的加减乘除、传入、格式

函数是为满足特定功能的代码的集合。函数的加减乘除、传入

a=3
b=2
print(a+b)
print(a-b)
print(a*b)
print(a/b)
print(a//b) #地板除，向下取整，结果为1
print(a**b) #a的b次方

#返回A的平方
def myfun(A):
    C=A**2
    return C       #return后面一定要有空格

a=3
print(myfun(a))  #结果是9

#返回A的B次方
def myfun1(A,B):
    return A**B

a=3
b=2
print(myfun1(a,b))  #结果是9

更复杂一点的函数，下面这个的写法和上面的区别是，如果没有传入B也不会报错、默认了B=2（可以尝试删掉上面的b=2，会发现马上报错）

记住带等号的B一定要放后面

#如果传入B，就返回A的B次方，如果没有传入B，就返回A的平方
def myfun(A,B=2)：
    return A**B

a=3
b=2
print(myfun(a))  #输出9


def myfun(A,B=2)：
    return A**B

a=3

print(myfun(a,10))  #输出59049

函数格式

def  函数名(参数1，参数2……)：

        return 返回值

输入值1

输入值2

……

print(函数名(参数))

6、类

深度学习、模型中常用的，一个集成很多属性和自己的函数，是这个类的，就可以用类的东西

（1）命名格式、初始化

格式：
class 类名():

       def__init_(属性1,属性2,……）

              self.属性1=

              self.属性2=

             ……

实例名=类名（属性1,属性2,……）
可以声明不同的属性

#__init__
class person():     #定义一个叫person的类
    def __init__(self, name, age):        #self用来初始化的，给类注入一些特征定义，表示类本身、类自己
        self.name = name		#每一个person都要有name和age
        self.age = age

    #现在定义2个print函数。缩进表示函数继续属于这个类
    def print_name(self):	#通过self，在不同函数之间传递
        print(self.name)

    def print_age(self):
        print(self.age)
laoli=person("ligekaoyan",28)  #定义类以后，一定要实例化
print(laoli.name)       #print后一定要跟实例的名称，不然不能访问
print(laoli.age)

laoli.print_name()    #会输出ligekaoyan，调用了上面的函数
print(laoli.print_name())	#会输出ligekaoyan（来自于函数调用过程中的运行）和None（来自于函数调用后没有该函数任何返回值）
class superman():
    def __init__(self,name,age):
        self.name=name	#定义有name、age、fly，这3个属性的超人
        self.age=age
        self.fly_=True   #为了和后面的函数名fly不重复
    def print_name(self):
        print (self.name)

    def print_age(self):
        print(self.age)
    def fly(self):
        if self.fly_==True:
            print("我会飞")
lige=superman("lige",28)
lige.print_name()    #输出结果是lige

（2）类的继承

程序需避免重复，尽量提高运行效率。人中包含了超人，超人只比人多一个fly的属性。超人首先是个人，所以可把超人的类在人的类里加工一下得到，即继承属性。

继承之后可以不用初始化重复的属性，表示继承之前的初始化，可以把之前写的初始化代码全部删掉

继承之后也会继承之前里面的类定义的函数，如print_name

如果在读代码的时候发现没有定义但是能用的函数，那么就是之前已经封装好的函数

修改初始化有一个图标可以快捷选中，选中以后直接就帮助修改了

修改成继承后的代码

class superman(person):
    def __init__(self,name,age):
        super(superman,self).__init__(name,age) 	#init的括号里要加上name、age才会有原来的初始化
        self.fly_=True

    def fly(self):
        if self.fly_==True:
            print("我会飞!")
lige=superman("lige",28)
lige.print_name()  #输出lige
print(lige.name)     #输出lige
lige.fly()				#输出“我会飞!”

7、矩阵numpy

深度学习中基本都是矩阵运算，所以需要矩阵操作

（1）命名和合并

import numpy    #这里一定要按照安装包来，解释器要用Python3.8（li_3_8)的环境，不然会显示报错没有numpy
import numpy as np #后面可以用np这个名字来引用numpy
import torch    #是我们安装的pytorch，可以把矩阵转化为张量，可以理解为是放在了一张网络上的矩阵，可以用来计算梯度

#tensor
list1=[
	[1,2,3,4,5],
	[6,7,8,9,10],
	[11,12,13,14,15],
	]
print(list1)

#列表list1转化为矩阵
array1=np.array(list1)
#输出的结果的区别是，第一个list是出现在同一行的、有逗号的、二维的，第二个array是一个5*3矩阵、没有逗号的

#矩阵可以有很多操作，首先是合并。但是必须把要合并的内容用括号括起来
array2=np.array(list1)
print(array2)

array3=np.concatenate((array1,array2))
print(array3)  #输出一个变长的5*6矩阵

array4=np.concatenate((array1,array2),axis=1)	#设置轴axis为1。往下变长是第0维，往右变宽是第1维。不写的话默认是0值，向下边长合并
print(array4)  #输出一个变宽的10*3矩阵

（2）切片

可以切到中间的方框

list1=[
	[1,2,3,4,5],
	[6,7,8,9,10],
	[11,12,13,14,15],
	]
print(list1)
array=np.array(list1)
print(list1[1:3])  #左闭右开，输出下标第1行和第2行，
print(array[1:3])
print(array[1:3,2:5])  #array不仅可以取行，还可以取列
#输出[[8,9,10]	    下标第1行和第2行，下标第2、3、4列
#	  [13,14,15]]
print(array[:,2:5]) #输出所有行，下标第2、3、4列
#输出[[3,4,5]
#	  [8,9,10]	
#	  [13,14,15]]
print(array[:,:]) #输出所有行、所有列，相当于print(array)

#跳着切，只想要下标为1、3的列
idx=[1,3] #要的列号
print(array[:,idx])	#所有行，下标为1、3的列

8、张量

把矩阵放在张量网上，可以进行计算、求梯度

有2个创建方法，一个是从列表转化，一个是直接建立

先看从列表转化

（1）从列表转化

import torch
import numpy as np

list1=[
	[1,2,3,4,5],
	[6,7,8,9,10],
	[11,12,13,14,15],
	]
print(list1)
tensor1=torch.tensor(list1)
array=np.array(list1)
print(array)
print(tensor1)  #输出结果有点类似tensor（），（）里面套了一个array的内容

import torch
import numpy as np

x=torch.tensor(3.0)
x.requires_grad_(True)  #如果不写需要求grad梯度的话 下面要print就会报错
y=x**2
print(y)
y.backward()   #求y的梯度，即y对x求导
				#如果是y=x**2+w，求y的梯度，即y对x、w分别求导
print(x.grad)    #y’=2x，x=3,所以y’=6

#x放在张量网上不能放CPU上、不能存储、不能画图，不需要计算梯度的时候。需要从张量网上摘下来
#使用该代码x=x.detach()
#用完之后可以求一下梯度，然后就会发现报错了

#x.grad=torch.tensor(0.0) 	#把x的梯度设为0
y2=x**2
y2.backward()  
print(y2)		#输出y2的结果是tensor(9.)
print(x.grad)   #输出x的梯度结果是tensor(12.)，会和上面y的梯度产生叠加，即6+6=12。想要不叠加的话把上面的代码放出来即可得到梯度是6

（2）直接建立一个张量

tensor1=torch.ones((100,4))   #建立一个4列、100行的张量，元素全是1
print(tensor1)

tensor2=torch.zeros((10,4))   #建立一个4列、10行的张量，元素全是0
print(tensor2)

tensor3=torch.normal(0,0.01,(10,4))	#建立一个4列、10行的张量，元素基于正态分布（normal），平均值是0，方差是0.01（很稳定）。这里也可以调整方差来玩一下
print(tensor3)

tensor4=torch.normal(0,0.01,(3,10,4))	#建立一个4列、10行、3维的张量，元素基于正态分布，平均值是0，方差是0.01。和tensor2相比，多了深度，会出现类似于3个2维的tensor2

（3）张量的求和

tensor1=torch.ones((10,4))   #建立一个4列、10行的张量，元素全是1
print(tensor1)

sum1=torch.sum(tensor1)
print(sum1)  #会把张量1中的所有的元素求和，输出结果tensor(40.)

sum2=torch.sum(tensor1,dim=0)   #dim是维度的意思，0即列，上面讲过，是竖着相加。理解成竖着向下把它拍扁
print(sum2)		#输出结果tensor([10.,10.,10.,10.])

sum3=torch.sum(tensor1,dim=1)   #dim是维度的意思，1即行，上面讲过，是横着相加，理解成横着向右把它推扁
print(sum3)		#输出结果tensor([4.,4.,4.,4.,4.,4.,4.,4.,4.,4.])

sum4=torch.sum(tensor1,dim=1,keepdim=True)   #想要保持原本的输出形状不变，就这样加个条件keepdim
print(sum4)		#输出结果tensor([[4.],
								#[4.],
								#[4.],
								#[4.],
								#[4.],
								#[4.],
								#[4.],
								#[4.],
								#[4.],
								#[4.])
print(tensor1.shape)    #想知道tensor1的形状可以调用shape
#输出结果是torch.Size([10,4])

9、引用

引用其他代码文件的包

from……import……

#假如我们上面的文件是分别用myclass、mytensor来命名的，现在创建了一个新的代码文件，想调用其他文件里的内容，可以用一下下面的代码来调用，会把那个文件里的结果都再运行一遍
from mytensor import tensor1
from myclass import superman

#然后就可以随便用了
print(tensor1)
lige=superman("li",24)

标签
#机器学习 #深度学习 #python #数据结构 #pytorch
#开发语言
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值