Python学习笔记_python笔记-CSDN博客

本文链接：https://blog.csdn.net/qq_34585625/article/details/102634632

Python 学习笔记（基础）

0. 简介

Python 编程第一步

以下所有 Python 程序的运行环境都为Anaconda 3.7

定义

python的源码以.py为拓展名保存，如helloworld.py。

第一个程序：monPremierProg.py

print( "hello world!" )

在命令行中输出

在python中用如下语句来做命令行输出：

print( message, end = "" ) # 输出message，不换行

print( message ) # 输出message + 换行

注意：如果这个message是混合了字符与数字，则我们要用逗号,将字符与数字分开。Python将会自动在两个值之间加入空格。

示例

print( "Vive les loutres", end = "" ) # 打出字符串后不会换行
print( " et Charlie!" ) # 输出后换行
i = 1337
print( "Du texte, 1 variable:", i, " et 1 valeur:", 42 )

以上代码在命令行的输出为：

Vive les loutres et Charlie!

Du texte, 1 variable: 1337 et 1 valeur: 42

在命令行输入

在python中用如下语句来做命令行输入：

input( message ) # 输出 message（可缺省）后等待用户输入

注意：input( ) 函数的返回值为字符串，所以我们要将其返回值转换（指派 cast）为我们需要的数据类型（int, float…)。

示例

i = int( input( "Entrer un entier: " ) ) # i即为一整型数
f = float( input( "Entrer un reel: " ) ) # f为一浮点型数
phrase = input( )                        # 字符串

模块与包

定义：

模块：
- 包含定义的变量，函数，方法或类等的文件
- 模块的设计通常遵循对于不同的问题域，有清晰的逻辑边界的原则
包：
- 将重组后的多个模块包含在同一个目录中
- 一般在同一个包中的模块都有一个共同点（如汽车的管理，小轿车，卡车等）
- 文件的名字即为包的名字

用处

提高代码的复用性，模块化编程
- 节省时间，避免重复造轮子
- 提高代码的可读性和可维护性

语法

导入包或模块：

```
import random # 导入 random 模块
```

from math import acos # 从 math 模块中导入 acos 函数

from math import * # 导入 math 模块中的所有函数

注意：使用 from...import... 这种形式的语句，调用 math 模块中的函数时不需要 math. 前缀。但是使用完整的名称会让代码更可读，所以最好是使用普通形式的 import 语句。

示例

from random import random  # random 函数来生成随机数
import math                # 使用 math 模块中的函数

nAlea = random( )          # 0到1范围内的随机数
angle = math.acos( nAlea ) # 相应的角度
print( "acos(", nAlea, ") =", angle, "raid" )

命令行输出为：

acos( 0.3016517887149436 ) = 1.264371655140188 raid

错误和异常

定义

编程中存在两种错误：

语法错误：程序无法编译
运行时出错（异常）：程序无法被正确运行

语法错误：

在编译过程中弹出的错误
没有遵守基本的语法规则（如错误的缩进，变量没有声名…）
易于纠正：可以被解释器检测到并发出信号

示例

 x = 1
z = x + a
print( "z = ", z )

命令行输出为：

File “main.py”, line 2, in
z = x + a

NameError: name ‘a’ is not defined

File “main.py”, line 1
x = 1
^
IndentationError: expected an indented block

异常

程序运行时跳出的错误
- ~~程序挂起并出现错误信息~~
- 程序产生了错误的运行结果
不易纠正：编译器无法检测到该种错误，必须要一步一步debug程序以检查出哪里出现了异常

典型异常

出现异常信息
- 变量没有被创建（AttributeError）
- 访问位置超出数组索引（IndexError）
产生错误结果
- 变量初始化错误
- 缩进错误
- 条件总为真/假 $\Rightarrow$ 无法进入循环

注释

好处

用来解释代码：
- 变量的作用
- 方法的功能
- 语句的目的
不会被编译 $\Rightarrow$ 不会增加程序运行的负担（所以要多加注释！）
注意：在Python中我们经常用 """ 这是注释 """ 的形式来写较长的注释（或多句话）。

两种注释方法的示例：

# 以下定义函数maMethode( )

def maMethode( param1 ) :
    """ 这是注释一个函数的示例
    	@param param1 定义的函数的第一个参数
    	@return 运行成功返回True，失败则返回False
    	@author YYZ
    	@Version 1.0
    """

1. 数据类型与运算符

数据类型

定义

Python 有4种默认数据类型
- 布尔型 bool （True 或 False）
- 整型 int
- 浮点型 float
- 字符及字符串 str

注意

Python是一种弱类型语言，变量的类型可在程序运行时被自动的选择或改变
我们可以用函数 type( maVariable ) 来获取变量的数据类型

类型转换（指派cast）

可在实数与整数之间转换类型
两种转换方式：
- 扩展：将一个类型转换为较大的类型（隐式的）
- 缩小：将一个类型转换为较小的类型（必须显式的表示）

扩展的示例

i = 42      # i是一个整型数
f = i + 0.1 # i的值在加上0.1之后被自动转换为浮点型

缩小的示例

f = 13.37
# 转换后会缺失精度
i = int( f ) # i = 13（其值被截断）

错误示例

f = 0.1  # 没有将所有二进制位全表示出
         # => f的值是被截断的
    	# 所以3*f与0.3所表示的并不一样
print( 3*f == 0.3 ) # => 输出False

操作符

操作符	连接性
`()` `[]` `.`	从左向右
`not`	从右向左
`**`	从左向右
`*` `/` `//` `%`	从左向右
`+` `-`	从左向右
`<` `<=` `>` `>=` `isinstance`	从左向右
`==` `!=`	从左向右
`and`	从左向右
`or`	从左向右
`=` `+=` `-=` `*=` `/=` `//=` `%=`	从右向左

赋值与运算符

一般赋值符

s = 0 # 一般赋值

运算符

加	`a + b`
减	`a - b`
乘	`a * b`
除	`a / b`
求商	`a // b`
取余	`a % b`
幂	`a ** b`

示例

unEntier = 8 + 3           # unEntier = 11
unEntier = unEntier % 7    # unEntier = 4

unReel = 3.                # unReel = 3.0
unReel = unReel * unEntier # unReel = 12.0
unReel = unReel / 5        # unReel = 2.4

赋值运算符

加	`a += b` $\Rightarrow$ `a = a + b`
减	`a -= b` $\Rightarrow$ `a = a - b`
乘	`a = b` $\Rightarrow$ `a = a b`
除	`a /= b` $\Rightarrow$ `a = a / b`
求商	`a //= b` $\Rightarrow$ `a = a // b`
取余	`a %= b` $\Rightarrow$ `a = a % b`
幂	`a = b` $\Rightarrow$ `a = a b`

使用这种赋值运算符可以精简代码

示例

unEntier = 8 + 3   # unEntier = 11
unEntier %= 7      # unEntier = 4

unReel = 3.        # unReel = 3.0
unReel *= unEntier # unReel = 12.0
unReel /= 5        # unReel = 2.4

关系运算符

小于	`a < b` `a <= b`
大于	`a > b` `a >= b`
等于	`a == b`
不等于	`a != b`

逻辑运算符

非逻辑	`not a`(a 必须是布尔型)
与逻辑	`a and b`
或逻辑	`a or b`

示例

val1, val2 = 1, 2
b = (val1 == 1) and (val2 > 2)
print( "(val1 = 1 ET val2 > 2) est ", b )
b = not (val1 == 1) or (val2 > 2)
print( "(val1 != 1 OU val2 > 2) est ", b )

运行结果为：

(val1 = 1 ET val2 > 2) est False

(val1 != 1 OU val2 > 2) est False

2. 控制流

分支语句

if 语句

当判断条件为真时则执行语句或代码块：

if condition :
    # 当 condition 为真(True)时语句或代码块会被执行
    # 代码块中所有相同缩进的语句
    # 将会被执行

注意：

判定条件为假时代码不会被执行
在Pyhton中，代码块完全是靠各语句之间的缩进关系定义的

else 子句

定义了当判定条件不满足时程序将执行的语句：

if condition :
    # 当 condition 为 True 时执行此处代码块
else :
    # 当 condition 为 False 时则执行此处代码块

if … else 语句串联

可以将多个 if … else 语句相连：

if condition1 :
    # 如果 condition1 为真执行此处语句
elif condition2 :
    # 当 condition1 为假但 condition2 为真时
    # 执行此处语句
else :
    # 当 condition1 和 condition2 都为假时
    # 执行此处语句

示例

if unEntier % 2 == 0 :
    print( unEntier, " est pair." )
else :
    print( unEntier, " est impair." )
    
if unReel > 0 :
    print( unReel, " est positif." )
elif unReel < 0 :
    print( unReel, " est negatif." )
else :
    print( unReel, " est nul." )

单行分支语句

if condition :
    uneVar = valeurVraie
else :
    uneVar = valeurFausse

我们可以将以上代码改写为一行（类似 C 语言的 ? 运算符）：

uneVar = valeurVrais if condition else valeurFausse

示例

dX = int( input( "Entrer un deplacement lateral: " ) )
gaucheOuDroite = "gauche" if dX < 0 else "droite"
print( "Vous avez entre", dX, end = "" )
print( " et nous allons donc a", gaucheOuDroite )

循环语句

定义

使用循环语句可将一段代码块按顺序执行多次
两种循环方法：
- 代码块要重复执行的次数未知：使用入口条件判定循环语句
  
  while : 在进入循环前对循环条件进行判断，其中的代码块可能不会被执行
- 代码块要重复执行的次数已知：带计数的循环
  
  for

for 循环

循环的次数已知
带计数的循环：须指定以下参数
- 计数器初值
- 计数器终值
- 计数器在每次执行完代码块后自增的步长
```
for uneVar in range( debut, fin, incrementation ) :
    # 要循环的代码块
```
- 注意：
  - uneVar 变量的值从 debut 开始，每次执行完代码块后自增 incrementation ，直到其值为 fin 时
  - 计数器的初值和步长可以省略
```
for uneVar in range( fin ) :
    # 代码块
```
    此时默认初值为0，自增步长为1
  - 注意缩进！

示例

""" 一般循环 """
# 输出0到10之前的所有整数
for i in range ( 10 ) :
    print( i )
    
""" 反向循环 """
# 按顺序输出3之前到1的整数
for i in range( 3, 0, -1 ) : # i 每次自减1
    print( i )
    
""" 任意步长循环 """
# 输出10之前的所有偶数
for i in range( 0, 10, 2 ) : # i 每次自增2
    print( i )

while 循环

定义

循环次数未知
是否继续循环的条件在循环的入口处判定
要在循环开始前初始化一些变量（如用作计数的变量）
如果循环的初始条件判定为假，则程序不会执行循环中的任何语句
如果循环是否继续的条件判定一直不为假，则程序将不会跳出该循环（我们称之为无限循环）

$\Rightarrow$ 在循环中一个或多个语句会处理与循环继续条件有关的变量来递进该变量使循环走向结束

语法

while condition :
    # 代码块

示例

计算两个整数 a 除 b 的商及余数，不使用运算符 // 和 % :

已知商和余数的初值（q = 0，r = a）
循环次数未知
当 b > a 时不能进入循环（循环继续条件）

$\Rightarrow$ 可以使用 while 循环

# 让用户输入 a 和 b
a = int( input( ) )
b = int( input( ) )
q, r = 0, a
while r >= b :
    q += 1 # 每次使商自增1
    r -= b # 每次使余数自减 b => 修改停止循环条件的变量的值
print( a, " = ", b, " * ", q, " + ", r )

for 循环转换为 while 循环

#         初始化，检测，自增
for i in rang( 0, 4, 1 ) :
    print( i )

i = 0         # 初始化
while i < 4 : # 检测
    print( i )
    i += 1    # 自增

3. 函数

函数声名

函数声名语法

关键字：def

def nomMethode( parametres ) :
    # 函数的代码块
    # 注意缩进！

parametres ：函数的形参列表，多个参数时每个参数之间用逗号 , 隔开
注意：当函数没有形参时 $\Rightarrow$ 空括号

示例：

# 无参数的函数
def afficheLoutre( ) :
    print( "Vive les loutres!" )

# 单个参数的函数
def afficheSigne( n ) :
    if n >= 0 :
        print( "n est positif" )
    else :
        print( "n est negatif" )
        
# 多个参数的函数   
def afficheSigne( n, nom ) :
    print( nom, "est", "positif" if n >= 0 else "negatif" )

函数的返回值语法

def nomMethode( parametres ) :
    """ 代码块
        ...
    """ 
    return uneValeur # 函数运行的结果

返回值 = 函数的运行结果
关键字 return
- 函数运行至该语句时结束
- 向后面的语句传递运行结果
没有返回值 $\Rightarrow$
- 函数在代码块结尾处结束运行
- 不用写 return

示例

def somme( a, b ) :
    res = a + b
    return res

def max( a, b ) :
    if a >= b :
        return a
    else :
        return b
    
def affiche( x ) :
    print( "x =", x )

函数调用

当一个函数被定义之后并不会被执行，只有当其被主程序或其他函数调用后才会被运行
形参与实参：
- 函数的形参的作用域仅存在于该函数的局部作用域内
- 一个函数被调用后，需要将其所需数据作为参数传递给函数 $\rightarrow$ 实参
- 一个实参可以是一个变量，可以是一个表达式，也可以是另一个函数的返回值

语法

无返回值的函数：
```
nomMethode( parametres_effectifs )
```

有返回值的函数：

variable = nomMethode( parametres_effectifs )

注意：

函数或方法必须在其被调用前声名
函数实参的数量和顺序必须和其形参一样

示例

def somme( a, b ) :                 # 此处 a, b 为函数的形参
    return a + b

def afficheSomme( a, b ) :
    s = somme( b, a )               # 此处 b, a 为被调用函数的实参
    print( "La somme est", s )
    
x = 4
res = somme( x, 38 )                # x, 38为函数的实参
print( "res =", res )
afficherSomme( 13, somme( x, 38 ) ) # 13, somme( x, 38 ) 为函数的实参

变量作用域

局部和全局变量变量

在一个函数中被声名的变量，处于该函数的局部作用域中。处于局部作用域的变量即为局部变量
在所有函数外声名的变量，属于全局作用域。处于全局作用域的变量即为全局变量

变量作用域

一个变量的作用域定义了该变量在程序中能被使用的区域
全局作用域中的代码不能使用任何局部变量
一个函数的形参即为该函数被调用时初始化的局部变量

示例

def somme( a, b ) :     # a, b 为函数的形参
    res = a + b
    return res          # res 为作用域在该函数中的局部变量

a = 4                   # 此处 a 为全局变量
print( somme( 38, a ) )

注意：如果在不同的作用域中，你可以用相同的名字命名不同的变量（如以上代码中的全局变量 a 和 somme 函数中的形参 a）

调用预设函数

round( x ) ：返回浮点数 x 的四舍五入值
abs( x ) ：返回 $∣ x ∣$

模块 math 中的常用函数：

sqrt( x ) ： $\sqrt{x}$
cos( x ) ，sin( x ) ，tan( x ) ： $\cos$ ， $\sin$ ， $\tan$ （ x 的单位为弧度）
exp( x ) ，log( x ) ： $e^x$ ， $\ln(x)$
math.pi ： $\pi$

模块 random 中的常用函数：

random( ) ：生成0到1（不包括1）之间的随机实数
randint( a, b ) ：生成 a 到 b 之间（包括两端）的随机整数

示例

# 导入模块
import math
import random

x = abs( round( 13.75 ) )                      # 求四舍五入并取绝对值
cosPi4 = math.cos( math.pi / 4 )               # 计算 cos( pi / 4 )
cosEgal = ( cosPi4 == ( 1 / math.sqrt( 2 ) ) ) # 比较 cos( pi / 4 ) 与 1 / sqrt( 2 )
de = random.randint( 1, 6 )                    # 生成1到6之间的随机整数

4. 列表

声名与使用

声名列表

一般我们有：

大小固定
列表的数据项不需要具有相同的类型
用下标来寻址
其存储在内存中的一块连续区域

语法

tabEntier = [ ]             # 空列表
tabEntier1 = [ 0 ] * 4      # 列表中4个元素全为0
tabEntier2 = [ 1, 3, 3, 7 ] # 含有4个元素的列表

列表的使用

访问列表中的值
- 我们通过用列表的下标做索引来访问列表中的值：tab[i]
- 注意：列表的下标是从0到 n - 1 （ n 是列表的大小）
- 可以使用-1下标来访问列表最后一个元素
向列表尾端添加元素：tab.append( val )
列表的长度：len( tab )

示例

tabEntier = [1, 3, 3, 7]
tabEntier[2] = 42        # 修改列表的第三个元素
i = tabEntier[0]         # i 的值为列表第一个元素的值

tabEntier.append(142857) # 在列表末尾加入新元素
print( tabEntier[-1] )   # 输出列表最后一个元素

lTab = len( tab )        # 列表的长度
tabEntier[lTab] = 2      # 错误！列表的最大下标是 lTab - 1

列表的截取有类似 “Matlab” 的语法：sousTab = tab[a : b : c]
- a ：起始下标（默认为0）
- b ：终止下标（默认到最后一个元素）
- c ：步长（默认为1）
注意：我们截取列表的范围为 $[a, b [$

示例

tab = [i for i in range( 20 )] # 列表元素为从0到19的全部整数

sTab = tab[0 : 10 : 1]         # 以1为步长截取下标从0到9的元素
sTab = tab[0 : 10 : 2]         # 以2为步长截取下标从0到10（不包括）的元素

# 反向截取
sTab = tab[10 : 0 : -1]        # 截取下标从10到0（不包括）的所有元素

# 可忽略一些参数
sTab = tab[0 : 10]             # 0到10（不包括）的所有元素
sTab = tab[: 10 : 2]           # 以2为步长截取下标从0到10（不包括）的元素
sTab = tab[10 : : 1]           # 截取下标从10之后的所有元素
sTab = tab[: : 2]              # 截取所有偶数下标的元素

遍历整个列表 $\Rightarrow$ 使用 for 循环：

# 循环访问列表中的所有元素
for i in range( len( tab ) ) :
    # 代码块

示例

# 输出列表中的所有元素
for i in range( len( tab ) ) :
    print( tab[i], " ", end = "" )
print( "" ) # 回到新的一行

# 寻找列表中最大的元素和它的下标
maxT = 0
posT = 0
for i in range( len( tab ) ) :
    if maxT < tab[i] :
        maxT = tab[i]
        posT = i

完全遍历的缩略语法，如果我们需要：
- 列表中的所有值：for valT in tab
- 列表中的值和它们的下标：for i, valT in enumerate( tab )
  
  使用 enumerate 可以返回列表中的元素和它们对应的下标

示例

# 输出列表所有的元素
for valT in tab :                # valT 变量依次遍历列表元素的值
    print( valT, " ", end = "" )
print( "" )

# 找到列表元素的最大值和其下标
maxT = 0
posT = 0
# 使用 enumerate
for i, valT in enumerate( tab ) :
    if maxT < valT : 
        maxT = valT
        posT = i

部分遍历列表，且不知道循环的次数 $\Rightarrow$ 使用 while 循环：
```
i = 0
while i < len( tab ) and condition :
    # 代码块
    i += 1
```

示例

# 寻找列表中第一个5
i = 0
while i == len( tab ) and tab[i] != 5 :
    i += 1
if i == len( tab ) :
    print( "Pas de 5 dans le tableau" )
else :
    print( "Le 1er 5 est a la position", i )

二维列表（矩阵）

定义

一个矩阵可视为：一个列表，它其中的所有元素都为一个列表
声名：
- 空矩阵：mat = [ ]
- $n\times m$ 阶矩阵，且其元素都相同：mat = [[val] * m] * n
- 一般的矩阵：mat = [[val11, val12, ...], [val21, val22, ...], ...]
使用：访问第 i 行第 j 列的元素：mat[i][j]

示例

from random import randint
# 初始化一个 n x m 阶的矩阵，其元素为 a 到 b 之间的随机数
n, m = 13, 37
a, b = 1, 6
mat = [[randint( a, b ) for _ in range( m )] for _ in range( n )]

# 截取一整行
tab = mat[1]

# 输出矩阵中所有的元素
for i in range( len( mat ) ) :            # 遍历行
    for j in range( len( mat[i] ) ) :     # 遍历列
        print( mat[i][j], " ", end = "" )
    print( "" )

5. 字符串

定义与语法

语法

用两个双引号""或单引号' 将构成字符串的值包围
+ 操作符：
- 可以将多个字符串串连为一个字符串
- 如果操作数不是字符串，则要先使用str( val )将其转换为字符串
注意：一个字符串即为一个列表，因此我们有：
- 字符串的长度：len( chaine )
- 访问字符串中的一个字符：c = chaine[pos]
  
  pos是一个在0到 len( chaine ) - 1之间的整数

示例

# 声名字符串
chaine = 'Vive les loutres'
chaine2 = "Des nombres (42, 142.857) et des symboles (&, _)"

# 串连两个字符串
chaine += " et Charlie"
# 此时 chaine 字符串为 "Vive les loutres et Charlie"

# 串连一个字符串和一个数字
chaine = "La reponse est " + str( 42 )
# 此时 chaine 值为 "La reponse est 42"

# 串连字符串与变量
i = 4
x = 3.
chaine = str( x ) + "^" + str( i ) + "=" + str( x ** i )
# 此时 chaine 值为 "3.0^4 = 81.0"

常用函数

注意 :

字符串方法的调用方式为：nomVaribale.nomMethode( parametres )

比较两个字符串：

我们可以使用 < ，>，== 运算符来比价两个字符串

从字符串中检索子字符：

idx = chaine.find( car )
从一个位置开始：idx = chaine.find( car, debut )
在一个区间中检索：idx = chaine.find( car, debut, fin )

注意：如果包含子字符串则返回开始的索引值，否则返回 -1

操作字符串：

截取子字符串：chaine2 = chaine[deb : fin]

注意：子字符串中不包括fin处的字符
对字符串切片：tabChaine = chaine.split( c )
替换字符：chaine2 = chaine.replace( oldChar, newChar )
将字符串全转换为小写字母：chaine2 = chaine.lower( )
将字符串全转换为大小字母：chaine2 = chaine.upper( )

一个列表，因此我们有：*

字符串的长度：len( chaine )
访问字符串中的一个字符：c = chaine[pos]

pos是一个在0到 len( chaine ) - 1之间的整数

示例

# 声名字符串
chaine = 'Vive les loutres'
chaine2 = "Des nombres (42, 142.857) et des symboles (&, _)"

# 串连两个字符串
chaine += " et Charlie"
# 此时 chaine 字符串为 "Vive les loutres et Charlie"

# 串连一个字符串和一个数字
chaine = "La reponse est " + str( 42 )
# 此时 chaine 值为 "La reponse est 42"

# 串连字符串与变量
i = 4
x = 3.
chaine = str( x ) + "^" + str( i ) + "=" + str( x ** i )
# 此时 chaine 值为 "3.0^4 = 81.0"