Python 3 学习指南_cvxpy 绝对值-优快云博客

本文链接：https://blog.youkuaiyun.com/pengwill97/article/details/79406164

本文详细介绍Python3的基础语法、数据类型及操作、控制语句等内容，包括字符串、列表、元组、集合、字典等基本数据类型的操作方法，以及条件控制、循环控制等控制语句的应用。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

Python 3 学习指南

Python 3 学习指南
语法部分
二、数据类型与函数
三、控制语句
- 条件控制
  - if语句
- 循环控制
进阶部分

语法部分

基础语法

标识符
1）由字母、数字下划线组成，且大小写敏感。
2）查看保留字可以用 $keyword.keylist$ 。

注释
1）单行注释用#。
2）多行注释用”’(三个单引号)包含起来。

多行语句
1）如果多行语句可以在行末加上 \ ，若是在[ ],{ },( )内的语句，不需要 \ 。
2）若果需要在一行写多条语句，需要在行末加分号。

print用法
$print$ 默认输出是换行的，如果需要不换行，print(a,end=” “)。

基本数据类型

$Python3$ 中有多种数据类型，包括数字，字符串，列表，元组，集合，字典。

赋值
1）多变量赋一个值 $a=b=c=1$ 。
2）多变量赋不同值 $a,b,c=1,2,"pengwill"$ 。

数字类型

$Python3$ 支持 $int、float、bool、complex$ （复数）。

类型查看

1）可以用 $type()$ 函数查看变量的对象类型。
2）或者用 $isinstance(a, int)$ 来查看对象类型。

>>> a=100
>>> print(type(a))
<class 'int'>
>>> isinstance(a,int)
Ture

区别在于：
1） $type()$ 不会认为子类是一种父类类型。
2） $isinstance()$ 会认为子类是一种父类类型。

删除操作

1）可以用 $del$ + 变量名，来删除一个变量。
2）如若删除多个变量，用逗号分割开。

数值运算

>>> 5+3     # 加法
>>> 4.0-3   # 减法
>>> 4.0*5   # 乘法
>>> 100/3   # 除法，得到浮点数
>>> 100//3  # 除法，得到整数
>>> 100%3   # 取余
>>> 100**3  # 乘方

值得注意的是，在混合计算的时候，Python会把整数转换成浮点数进行运算。

String(字符串)

Index 索引与操作

1）字符串的索引值从0开始，-1表示倒数第二个。
2）+ 符号表示字符串的连接，* 字符表示字符串的复制次数（后面跟数字）。
3） $Python$ 中的字符串用单引号或双引号括起来，同时使用反斜杠()转义字符。
4） $Python$ 中的字符串不能发生改变，如str[0] = ‘a’会出错。

str = "pengwill"
print(str)              # 直接输出字符串
print(str[0:-1])        # 输出从第0个字符 到 倒数第2个字符
print(str[2:])          # 输出从第3个字符到末尾
print(str*2)            # 输出str两遍
print(str + "hello")    # 连接两个字符串
len(str)                # 求解字符串长度

格式化输出

使用类似C语言的输出方法。
1）基本形式为：print (“%s %d” % (‘abc’, 10))。
2）格式字符串同C语言，字符为%c，字符串%s，整数%d，浮点数%f，八进制%o，十六进制%x，科学计数法%e。
3）在字符串前加r/R表示原始字符串，原样输出。

循环遍历

使用此方法可以循环遍历字符串中的每一个字符

str = "pengwill"
for letter in str:
    dosomething

List(列表)

1）列表中的元素可以是任何数据类型，包括列表自身(嵌套)。
2）列表要用方括号[ ] 括起来，表示这是一个列表。
3）Index索引操作与字符串一致。
4）列表中的元素可以进行修改。
5）列表元素的删除，可以采用 $list[sta:end+ 1] =\ [\ ]$ 的方法。
6）求解列表长度可以用 $len()$ 方法。
7）列表中每个元素循环的方式同字符串。

Tuple(元组)

1）与list类似，不同之处在于元组不能修改，且需要用小括号( )。
2）构造一个空元组 $tup1 = ()$ 。
3）构造一个元素的元组 $tup2 = (20,)$ ，后面的逗号不能省略。
4）当需要函数返回多个参数的时候，实际是以元组形式返回的。

Set(集合)

1）集合中不允许包含重复元素。
2）可以用大括号{}或者set()，来创建一个集合，但是空集合必须使用set()来创建，因为空的{}表示创建一个空字典。

list1 =["a","b","c","d"] 
a = set(list1)
b = set(list1[0:3])
print(a - b) # a和b的差集
print(a | b) # a和b的并集
print(a & b) # a和b的交集
print(a ^ b) # a和b中不同时存在的元素

Dictionary(字典)

1）字典类似于 $c++STL$ 里的 $map$ ，key和value一一对应，但 $key$ 并不是有序排列的。
2）字典用大括号{ }，并且键与值之间要用冒号 : 连接，不同元素之间用逗号 , 分隔。
3） $key$ 不可以修改，且 $key$ 唯一。
4）创建空字典用 $dict = \{\}$ 。

输出操作

dict = {"mydic":1,"yourdic":2}
print(dict)             # 输出完整的字典
print(dict.keys())      # 输出所有key
print(dict.values())    # 输出所有的value
print(dict["mydic"])    # 输出key为mydic的value

类型转换

语法	作用	解释
$int(x,base)$	将字符串或整数转换为整数	$x$ 为字符串或数字， $base$ 为进制，默认十进制
$float(x)$	将字符串或者整数转换为浮点数	其中 $x$ 为字符串或者数字
$str(x)$	将对象转换为字符串	$x$ 为一个对象
$eval(str)$	计算字符串中的有效 $Python$ 表达式	$str$ 为一个字符串类型计算表达式
$tuple(x)/list(x)$	将 $x$ 转换为元组/列表	$x$ 可为一个 $list/tuple$
$ord(x)$	将字符 $x$ 转换为对应整数值 $(ASCII)$	$x$ 为单个字符
$hex(x)$	将整数 $x$ 转换为一个十六进制字符串	$x$ 为一个整数
$oct(x)$	将整数 $x$ 转换为八进制字符串	$x$ 为一个整数

运算符

基本运算符

1）算数运算符、比较运算符、赋值运算符、位运算符和C语言一致。
2）不同的是： $**$ (两个乘号)表示次幂运算， $//$ (两个斜线)表示整除运算。

逻辑运算符

运算符	表达式	解释	例子
$and$	$a \ and\ b$	布尔与，当 $a$ 为 $False$ 时返回 $False$ ，否则返回 $b$ 的值	$1\ and \ 2 = 2$
$or$	$a\ or \ b$	布尔或，当 $a$ 为 $True$ 返回 $x$ 的值，否则返回 $b$ 的值	$1 \ or \ 2 = 1$
$not$	$not\ x$	布尔非，返回非 $x$	$not(1\ and \ 2) = Flase$

成员运算符

运算符	解释	例子
$in$	若对象在指定序列里，返回 $True$ ，否则返回 $Fasle$ ，常用于循环	$for\ letter \ in \ wordlist$
$not\ in$	若对象不在指定序列里，返回 $True$ ，否则返回 $False$	\

身份运算符

比较两个对象是否为一个存储单元的内容。
$id(x)$ 用于获取对象 $x$ 的内存地址编号。

运算符解释例子

i s

$is$ 当

id(a)==id(b) i d ( a ) == i d ( b ) $id(a) == id(b)$ 返回

True T r u e $True$ ，否则返回

False F a l s e $False$

a is b a i s b $a\ is\ b$

is not i s n o t $is\ not$ 当

id(a)!=id(b) i d ( a ) ! = i d ( b ) $id(a) != id(b)$ 时返回

True T r u e $True$ ，否则返回

Flase F l a s e $Flase$

a is not b a i s n o t b $a\ is\ not\ b$

二、数据类型与函数

Number(数字)

数学函数

有些数学函数需要引入 $math$ 模块，而有些却不需要。

不需要引入 $math$ 模块的函数：
1） $abs(x)$ ：返回 $x$ 的绝对值，为整型，但是我发现根据对象不同也会返回浮点型。
2） $max(x_1\dots x_n)$ ：返回最大值，参数可以为列表。
3） $min(x_1\dots x_n)$ ：返回最小值，参数可以为列表。
4） $round(x,n)$ ：返回浮点数 $x$ 对 $n$ 位小数四舍五入的结果。

需要引入 $math$ 模块的函数：
1） $math.modf(x)$ ：分别返回浮点数 $x$ 的小数部分和整数部分，返回值为元组。
2） $math.ceil(x)/math.floor(x)$ ：返回上取整 / 下取整的结果，返回值为整数。
3） $math.log(x)/math.log10(x)$ ：返回以 $e/10$ 为底的对数，返回值为浮点数。
4） $math.exp(x)$ ：返回 $e^x$ ，返回值为浮点数。
5） $math.sqrt(x)$ ：返回 $x^{\frac{1}{2}}$ ，返回值为实数。
6） $math.fabs(x)$ ：返回 $x$ 的绝对值，返回值为浮点数。

还有一些三角函数，有兴趣可以查阅相关资料。

随机数函数

以下函数都需要引入 $random$ 模块。
1） $random.shuffle(x)$ ：将 $x$ 序列中的元素随机排列。
2） $random.choice(x)$ ：从 $x$ 序列中随机挑选一个元素。
3） $random.uniform(x,y)$ ：随机生成一个在 $[x,y]$ 内的实数。
4） $random.randrange(sta,end,step)$ ：在 $[sta,end)$ 范围内每 $step$ 的整数中，随机选择一个数字，默认 $step$ 为1。

import random
card = list(range(55))      # 产生一个0-54的序列
random.shuffle(card)        # 打乱序列
print(random.choice(card))  # 随机选一个数字输出
print(random.uniform(1,20)) # 从[1,20]中随机选一个实数输出
print(random.randrange(1,100,2)) # 从[1,100) 中随机选一个奇数输出

String(字符串)

内置字符串函数

这里默认字符串函数对象为 $str$ 。

1） $len(str)$ ：返回字符串长度。
2） $max(str)/min(str)$ ：返回字符串中 $ASCII$ 最大/最小的字母。
3） $str.upper()/str.lower()$ ：将字符串转化为大写/小写字母。
4） $str.isalnum()/str.isalpha()/str.isdigit()/str.isupper()/str.isspace()$ ：判断字符串是否只是数字和字母 / 只是字母 / 只包含数字 / 只包含大写字母 / 只包含空白。
5） $str.encode(”UTF-8”)$ ：将目标字符串转化为指定编码格式。
6） $str.find(substr,sta,len)$ ：从 $str$ 中长度为 $[sta,sta+len)$ 中查找是否含有 $substr$ ，若有返回索引值，否则返回-1， $sta$ 和 $len$ 可省略。
7） $str.split("substr",times)$ ：以 $substr$ 为分割符，分割 $times$ 次，返回值为元组。
8） $str.capitalize()$ ：将字符串第一个字母大写。

字符串的格式化函数

请移步至4.4.2 format格式输出。

List(列表)

脚本型操作

可以方便的进行一些简单的操作，这里假定 $mlist = [0,1,2]$ ， $ylist = [4,5]$ 。
1）组合操作 $mlist +ylist$
操作结果： $[0,1,2,4,5]$ ，注意结果和组合的顺序有关。
2）重复操作 $ylist * 2$
操作结果： $[4,5,4,5]$ 。
3）迭代操作 $for\ x\ in\ ylist; print(x，end="\ ");$
操作结果：4 5

内置列表函数

假定列表对象为 $list$ 。

1） $list.append(x)$ ：在 $list$ 末尾追加对象 $x$ 。
2） $list.count(x)$ ：统计 $list$ 中对象 $x$ 出现的次数
3） $list.insert(index,x)$ ：在 $index$ 后面插入对象 $x$ 。
4） $list.pop()$ ：删除最后一个元素。
5） $list.remove(x)$ ：删除第一个符合对象 $x$ 的元素。
6） $list.reverse()$ ：将列表逆置。
7） $list.sort([func])$ ：按照 $func$ 的方法对列表排序，省略为升序，降序排列参数为 $reverse = True$ 。
8） $list.clear()$ ：清空。

Tuple(元组)

可以理解为不能改变的列表。
操作请参见 $List$ 的脚本型操作(2.3.2节)。

Set(集合)

集合内置函数

假定集合对象为 $s$ 。

1） $s.add(x)$ ：将 $x$ 加入到集合 $s$ 中。
2） $s.update(x)$ ：将集合 $x$ 合并到原集合 $s$ 中。
3） $s.remove(x)$ ：将元素 $x$ 从集合中移除，若不存在会引发错误。
4） $s.union(x)$ ：返回集合 $s$ 与集合 $x$ 的并集或用 $s | x$ 。
5） $s.intersection(x)$ ：返回集合 $s$ 与集合 $x$ 的交集或用 $s \& x$ 。
6） $s.difference(x)$ ：返回集合 $s$ 对于集合 $x$ 的补集或用 $s - x$ 。
7） $s.symmetric_difference(x)$ ：返回集合 $s$ 于集合 $x$ 的对称差集或用 $s \hat{ } x$ 。
8） $s.issubset(x)$ ：判断 $s$ 是否是 $x$ 的子集。
9） $s.issuperset(x)$ ：判断 $s$ 是否是 $x$ 的父集。

Dictionary(字典)

内置字典函数

在字典中 $clear(),copy()$ 操作与列表操作一致。

假定字典对象为 $dict$ ，给出一些操作及其含义。

1） $dict.popitem()$ ：删除 $ditc$ 末尾的键值对。
2） $dict.pop(x)$ ：删除键为 $x$ 的键值对，返回为键为 $x$ 的值。
3） $dict.items()/dict.keys()/dict.keys()$ ：返回 $dict$ 中的键值对/键列表/值列表。
4） $dict.get(x)$ ：查找键为x的值，若不存在返回 $None$ 。
5） $dict.updata(dict2)$ ：将 $ditc2$ 的键值对更新到 $ditc$ 中。

字典注意事项

1）字典中值可以是任何对象，但键不可以。
2）由于键不可变的特性，故键只能是数字，字符串或者元组。
3）字典中键满足互异性。

三、控制语句

条件控制

if语句

基本语法

if condition_1 :
    dosomething_1
elif condition_2:
    dosomething_2
else:
    dosomething_3

循环控制

while循环

基本语法

while condition:
    dosomething_1
    dosomething_2
    dosomething_3

while-else循环

基本语法

while condition:
    dosomething_1
    dosomething_2
else:
    dosomething_3

当不满足 $while$ 循环条件的时候，将进入 $else$ 语句块。

for循环

基本语法

for var in sqe:
    dosomething_1
else:
    dosomething_2
 # 也可以使用range函数
for i in range(5):      # 循环[0,4]
    dosomething_3
for j in range(5,9):    # 循环[5,8]
    dosomething_4
for k in range(1,10,2): # 循环[1,9] 且步长为2
    dosomething_5

break,continue,pass语句

break
从 $for$ 、 $while$ 循环中终止，若其后又 $else$ 语句块，不执行。

continue
跳过本轮循环，直接进行下一轮循环。

pass
不执行任何动作，起占位作用，保持思维和代码的完整性。

进阶部分

本部分介绍关于迭代器与生成器，函数的参数与返回值，文件操作，读入输出操作，以及异常处理等问题。

迭代器与生成器

迭代器

在使用方面， $Python3$ 的迭代器与 $C++$ 的迭代器并无太大差异。基本作用均为遍历序列。值得注意的是，迭代器只能向前访问，不能向后访问。
迭代器的基本形式有两种，分别为 $iter()$ 和 $next()$ 。

# 使用iter
mylist = [1,2,3,4,5,6,7]
it = iter(mylist)
for x in it:
    print(x)
# 使用next
import sys
mylist = [1,2,3,4,5,6,7]
it = iter(mylist)
while True:
    try:
        print(next(it))
    except StopIteration:
        sys.exit()

生成器

emmm…生成器还需要好好理解，先挖个坑，回来再填。

函数

定义与声明

1）函数由关键字 $def$ 定义，后面接着函数名称，和用 $(\ )$ 括起来的参数表列。
2）函数体由 $:$ 冒号开始， $return$ 终止，并用缩进表示函数体的所属关系。
3） $return$ 结束函数，返回值可以是一个对象，可以是序列，没有返回值默认为 $None$ 。

import math
def cal(x1,y1,x2,y2): # 计算两点之间的距离
    return math.sqrt( (x1-x2) ** 2 + (y1-y2) ** 2 )

参数传递性

在 $Python3$ 中分为可更改对象 $(mutable)$ 和不可更改对象 $(immutable)$ 。
1）不可更改对象有： $String,Tuple,Number$ 。
2）可更改对象有： $List,Dictionary$ 。

参数传递的方式，根据对象的可更改性来决定。
1）参数为可更改对象：相当于 $C++$ 中的引用传参，在函数内部更改值对对象有作用。
2）参数为不可更改对象：相当于 $C++$ 中的值传参，将值拷贝一份传递给函数内部，所以函数内部修改对外部没有效果。

参数的类型

$Python3$ 参数分为必须参数，关键字参数，默认参数和不定长参数。
1）必须参数：按照顺序传入的参数，调用时的数量，顺序必须和声明时一致，否则会出现语法错误。
2）关键字参数：即在调用函数的时候，指明是哪个参数，因此可以忽略传参的顺序。
3）默认参数：在声明的时候，指明参数的默认值，若没有传入该参数，为默认值。默认参数要放到参数表列最后。
4）不定长参数：在声明时，变量前有个 $*$ 号，当没有传入参数的时候，为空元组。

# -----必须参数-----
def show(a):
    print(a+1)
show(9)                             # 参数不能忽略
# -----关键字参数-----
def show(name,score):
    print(name+" "+str(score))
show(score = 100,name = "pengwill") # 在调用时指明了参数，忽略参数顺序
#-----默认参数-----
def show(score,name = "pengwill"):
    print(name+" "+str(score))
show(score = 150)                   # 在调用时指明了参数，忽略参数顺序
#-----不定长参数-----
def show(score1,*score):
    print(score1)
    for x in score:
        print(x)
show(1,2,3,4,5)                     # 传入了多个参数

全局变量与局部变量

变量的作用域 $C++$ 几乎一样。
1）全局变量：定义在函数外的变量为全局变量，有全局作用域。
2）局部变量：定义在函数内部的变量为局部变量，有局部作用域。

如果需要在函数内部修改全局变量，或者在嵌套结构内修改结构外变量，就要涉及到 $global,nonlocal$ 关键字。
1） $global$ ：声明后可以在任何位置修改全局变量。
2） $nonlocal$ ：声明后可以在嵌套内部修改外部变量。

#-----global-----
num = 100
def change():
    global num              # 不声明会报错
    print(num); num = 10; print(num);
change()
#-----noncal-----
def change(*score):
    base = 0.5
    def printer(score):     # 函数内部定义函数
        for x in score: 
            nonlocal base   # 不声明会报错
            base+=0.01
            print(base*x)
    printer(score)
change(100,110,120)

模块

模块是一个包含所有你定义的函数和变量的文件，其后缀名是 $.py$ 。模块可以被别的程序引入，以使用该模块中的函数等功能。这也是使用 python 标准库的方法。

import 语句

解释器遇到 $import$ 语句，就会当将前目录中对应的 $.py$ 文件导入，应该将 $import$ 语句放在程序的顶端。
1）直接使用 $import$ 语句，可以导入对应 $.py$ 文件的所有函数，并执行主程序。如果不想执行主程序，要使用 $\_\_name\_\_$ 属性。
2）可以使用 $from...import...$ 语句，导入对应 $.py$ 文件的一个或者多个函数，并执行主程序。

# test.py
def out():
    print("I know you are from outside")
def judge():
    print("judging")
def out():
    print("I know you are from outside")
def judge():
    print("judging")
if __name__ == '__main__':  # 当直接运行本文件的时候，输出indeed
    print("indeed")
else:                       # 当从外部调用本文件的时候，不做任何操作
    pass
# test2.py
import test                 # 亦可采用from...import...的方法
test.out()
test.judge()

包

等待填坑

输入输出控制

从键盘输入

Python3提供从键盘输入的方法input()函数。其读入的结果为字符串。

str = input("请输入\n")
print("输入的是",str)

format格式输出

在 $Python3$ 中可以使用 $format$ 函数，解析输出，方便的连接不同类型的变量或内容。

基本语法为：“{ }的成绩分别是:{ },{ },平均分是{}”.format(“pengwill”,”100”,”0”,”50.0”)
1）字符串部分的{ }，可以理解为C语言的占位符，与 $format$ 中的内容按顺序一一对应。
2）若要不想按顺序，可以在字符串部分的{ }中写入序号，从0开始，表示与后面 $format$ 中对应的内容。
3）若想在字符串部分输出大括号，写两层大括号{ { } }表示。
4）在字符串部分的{ }，还可以添加格式控制标记。规则如下：{ :<填充> <对齐> <宽度> , <.精度> <类型>}。
5）<填充>：在宽度大于字符串长度或者数字串长度的时候，用何种符号填补。默认为空格。
6）<对齐>：有三种方式。< 表示左对齐，>表示右对齐，^表示居中对齐。
7）<宽度>：字符输出的宽度。
8）一个逗号,：数字的千位分隔符，对整数或者浮点数有效。
9）<精度>：浮点数的精度或者是字符串的最长长度。
10）<类型>：整数或者浮点数的格式控制规则，整数包括6种：b-二进制，c-整数对应的Unicode字符，d-十进制，o-八进制，x-小写十六进制，X-大写十六进制。对于浮点数包括4种：e-小写字母的指数形式，E-大写字母的质数形式，f-浮点数标准形式，%f-浮点数的百分数形式。

文件操作

open操作

$open()$ 会返回一个 $file$ 对象，基本语法为： $open(filename,mode)$ 。
其中 $filename$ 为文件名， $mode$ 为打开文件的模式，具体看下表。

模式	描述
$r$	只读模式。如果文件不存在，将产生错误。
$w$	只写模式。如果文件不存在则自动创建文件。否则重新写文件。
$a$	只写模式，并且将内容写到文件的末尾。
$rb$	只读二进制文件，如果文件不存在，将产生错误。
$wb$	只写模式，写二进制文件，如果文件不存在则自动创建
$ab$	附加二进制到文件末尾。
$a+$	读写文件，如果文件存在则追加到末尾，否则创建新文件。

文件对象函数

假定已经打开一个文件对象为 $file$ 。

1） $file.read(size)$ ：读取一个文件的内容，作为字符串返回。参数 $size$ 可选，表示数据规模，默认为文件全部内容。
2） $file.readline()$ ：从文件中读取单独的一行，如果读到文件的末尾，返回空字符串。
3） $file.readlines()$ ：从文件中读取所有的行，以列表形式返回。
4） $file.write(str)$ ：将str的内容写入文件，返回写入的字符数目。
5） $file.tell()$ ：返回文件所处的位置。
6） $file.close()$ ：关闭文件对象，若重复关闭，则会抛出异常。

异常处理

常见的异常分类

Exception 所有异常的基类
AttributeError 特性应用或赋值失败时引发
IOError 试图打开不存在的文件时引发
IndexError 在使用序列中不存在的索引时引发
KeyError 在使用映射不存在的键时引发
NameError 在找不到名字（变量）时引发
SyntaxError 在代码为错误形式时引发
TypeError 在内建操作或者函数应用于错误类型的对象是引发
ValueError 在内建操作或者函数应用于正确类型的对象，但是该对象使用不合适的值时引发 ZeroDivisionError 在除法或者摸除操作的第二个参数为0时引发

异常处理语法

异常处理的结构有很多种，基本上室友 $try...except...$ 结构组成。

1）首先执行 $try$ 内语句块，若发现异常，转至其后的 $except$ 。
2）若在 $except$ 中找到对应的异常类型，则执行其 $except$ 后的语句块。若 $except$ 后没有跟异常类型，表示捕捉一切异常。
3）若其后还有 $else$ ，则表示在没有异常时继续执行，可以执行文件释放等操作。
4） $finally$ 语句的含义为，无论是否出现异常，都会执行其语句块的内容。