一、概述

• 该文章面向人群：嵌入式方向，偶儿使用Python3进行简单开发，有C/C++语言基础，对Python要求不高的人群
• Python3.0+的安装方法本文不作赘述
• 注意Python2.0+与Python3.0+语法的差异，以下语法可能不适用于Python2.0+

二、运行

1、终端启动 Python3 交互式解释器直接执行：

  在终端输入python3指令启动Python3交互式解释器，允许用户在命令行中直接输入和执行Python3代码，‌实时查看结果。‌这种方式对于快速测试代码片段或进行交互式编程非常有用。‌

  如下图所示：

2、.py 文件运行：

.py文件中输入Python3代码，如hello.py中输入：

print ("Hello, Python!")

执行：

python3 hello.py

• 即使不以.py为后缀的文件，依然可以用python3 xxx.xxx执行Python3代码

3、可执行文件运行：

#!/usr/bin/python3加入Python3解释器的位置，如hello.py：

#!/usr/bin/python3print ("Hello, Python!")

加入可执行权限：

chmod +x hello.py

执行：

./hello.py

• 同样地，即使不以.py为后缀的可执行文件，只要加入解释器位置语句，依然可以用./xxx.xxx执行Python3代码

三、基础语法

1、Python 中文编码：

  Python 3源码文件默认以UTF-8编码，所有字符串都是unicode字符串。所以不需要再为中文指定UTF-8编码，不过也可以为源码文件指定不同的编码

2、注释：

可以以#开头注释，也可以使用'''或"""多行注释：

#!/usr/bin/python3# 第一个注释
# 第二个注释'''
多行注释
多行注释
'''"""
多行注释
多行注释
"""

3、print 输出：

print默认输出是换行的，如果要实现不换行需要在变量末尾加上end=""：

#!/usr/bin/python3# 换行输出
print( "Hello, Python!" )# 不换行输出
print( "Hello, Python!", end=" " )

或者输出变量：

#!/usr/bin/python3a = 1
b = 2
print( a, ": Hello, Python!" )
print( b, ": Hello, Python!" )

运行结果：

4、变量赋值：

• Python中的变量不需要声明。每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建
• 在Python中，变量就是变量，它没有类型，我们所说的“类型”是变量所指的内存中对象的类型
• Python是一门弱类型语言，它不过于强调类型

#!/usr/bin/python3counter = 100          # 整型变量
miles   = 1000.0       # 浮点型变量
name    = "runoob"     # 字符串# 字符串也可以用单引号 '' 表示print (counter)
print (miles)
print (name)

5、行与缩进：

缩进的空格数是可变的，但是同一个代码块的语句必须包含相同的缩进空格数

#!/usr/bin/python3if True:print ("True")
else:print ("False")

以下代码最后一行语句缩进数的空格数不一致，会导致运行错误：

#!/usr/bin/python3if True:print ("Answer")print ("True")
else:print ("Answer")print ("False")    # 缩进不一致，会导致运行错误

运行结果：

6、Python 空行：

  函数之间或类的方法之间用空行分隔，表示一段新的代码的开始。类和函数入口之间也用一行空行分隔，以突出函数入口的开始。空行与代码缩进不同，空行并不是Python语法的一部分。
  书写时不插入空行，Python解释器运行也不会出错。但是空行的作用在于分隔两段不同功能或含义的代码，便于日后代码的维护或重构。空行也是程序代码的一部分。和C语言类似

7、等待用户输入：

#!/usr/bin/python3# raw_input("\n\n按下 enter 键后退出。")
# 从 python3.2 开始，raw_input() 已被移除，input() 的返回类型已经变为 str
str = input("\n按下 enter 键后退出。")
print( str )

8、类型转换：

由于input()返回的类型为str，如果用户输入的是数字：

#!/usr/bin/python3a = input("请输入第一个加数，按下 enter 键后退出：")
b = input("请输入第二个加数，按下 enter 键后退出：")
ret = a + b
print( ret )

运行结果：

所以此时我们需要作类型转换：

#!/usr/bin/python3a = input("请输入第一个加数，按下 enter 键后退出：")
b = input("请输入第二个加数，按下 enter 键后退出：")
a = int(a)
b = int(b)
ret = a + b
print( ret )

运行结果：

9、数字(Number)类型

python中数字有四种类型：整数、布尔型、浮点数和复数

• int(整数)：   如1, 只有一种整数类型int，表示为长整型，没有python2中的Long
• bool(布尔)：    如True、False
• float(浮点数)： 如1.23、3E-2
• complex(复数)： 如1 + 2j、1.1 + 2.2j

10、流程控制：

① if 语句：

Python中if语句的一般形式如下：

#!/usr/bin/python3if condition_1:statement_block_1
elif condition_2:statement_block_2
else:statement_block_3

每个条件后面要使用冒号:，表示接下来是满足条件后要执行的语句块。

使用缩进来划分语句块，相同缩进数的语句在一起组成一个语句块，例如：

#!/usr/bin/python3var1 = 100
if var1:print ("1 - if 表达式条件为 true")print (var1)var2 = 0
if var2:print ("2 - if 表达式条件为 true")print (var2)
print ("Good bye!")

运行结果：

1 - if 表达式条件为 true
100
Good bye!

② while 语句：

#!/usr/bin/python3a = 1
while a < 5 :print(a)a += 1
print ("Good bye!")

运行结果：

1
2
3
4
Good bye!

③ 逻辑运算符：

Python的逻辑运算符与C语言有少许差异，如：

#!/usr/bin/python3num = 10
if num >= 0 and num <= 10:print('num >= 0 and num <= 10')num = 20
if num < 0 or num > 10:print('num < 0 or num > 10')name = 'c'
if name == 'python':print("name == python")

④ for 语句：

Python for循环可以遍历任何可迭代对象，如一个列表或者一个字符串，如：

#!/usr/bin/python3for letter in 'Python':print(letter)sites = ["Baidu", "Google", "Runoob", "Taobao"]
for site in sites:print(site)

运行结果：

P
y
t
h
o
n
Baidu
Google
Runoob
Taobao

整数范围值可以配合range()函数使用：

#!/usr/bin/python3#  1 到 5 的所有数字：
for number in range(1, 6):print(number)

运行结果：

1
2
3
4
5

11、Python3 字符串：

① 创建字符串：

字符串是Python中最常用的数据类型。我们可以使用引号('或")来创建字符串：

var1 = 'Hello World!'
var2 = "Runoob"

② Python 访问字符串中的值：

Python不支持单字符类型，单字符在Python中也是作为一个字符串使用。

Python访问子字符串，可以使用方括号[]来截取字符串，字符串的截取的语法格式如下：

变量[头下标:尾下标]

③ 字符串拼接：

#!/usr/bin/python3var1 = 'Hello World!'
var2 = "Runoob"
print( var1 + var2)print( var1[:6] + var2)

运行结果：

Hello World!Runoob
Hello Runoob

④ 字符串格式化：

最基本的用法是将一个值插入到一个有字符串格式符%s的字符串中，占位符不止%s一种形式：

#!/usr/bin/python3print ("我叫 %s 今年 %d 岁!" % ('小明', 10))

运行结果：

我叫 小明 今年 10 岁!

12、Python3 列表：

① 创建列表：

列表的数据项不需要具有相同的类型。
创建一个列表，只要把逗号分隔的不同的数据项使用方括号括起来即可。
如下所示：

list1 = ['Google', 'Runoob', 1997, 2000]
list2 = [1, 2, 3, 4, 5]
list3 = ["a", "b", "c", "d"]
list4 = ['red', 'green', 'blue', 'yellow', 'white', 'black']

② 访问列表中的值：

类似于C语言中的数组下标，如：

#!/usr/bin/python3list = ['red', 'green', 'blue', 'yellow', 'white', 'black']
print( list[0] )
print( list[1] )
print( list[2] )

运行结果：

red
green
blue

索引也可以从尾部开始，如图所示：

#!/usr/bin/python3list = ['red', 'green', 'blue', 'yellow', 'white', 'black']
print( list[-1] )
print( list[-2] )
print( list[-3] )

运行结果：

black
white
yellow

当然，也可以截取字符：

#!/usr/bin/python3nums = [10, 20, 30, 40, 50, 60, 70, 80, 90]
print(nums[0:4])
print(nums[1:-2])

运行结果：

[10, 20, 30, 40]
[20, 30, 40, 50, 60, 70]

③ 更新列表：

可以对列表的数据项进行修改或更新，也可以使用append()方法来添加列表项，如：

#!/usr/bin/python3list = ['Google', 'Runoob', 1949, 2000]print ( "更新前：", list)
list[2] = 1999
print ( "更新后：", list)list1 = ['Google', 'Runoob', 'Taobao']
list1.append('Baidu')
print ("更新后的列表 : ", list1)

运行结果：

更新前： ['Google', 'Runoob', 1949, 2000]
更新后： ['Google', 'Runoob', 1999, 2000]
更新后的列表 :  ['Google', 'Runoob', 'Taobao', 'Baidu']

④ 删除列表元素：

可以使用del语句来删除列表中的元素，如：

#!/usr/bin/python3list = ['Google', 'Runoob', 1949, 2000]print ("原始列表 : ", list)
del list[2]
print ("删除第三个元素 : ", list)

运行结果：

原始列表 :  ['Google', 'Runoob', 1997, 2000]
删除第三个元素 :  ['Google', 'Runoob', 2000]

13、Python3 元组：

Python的元组与列表类似，不同之处在于元组的元素不能修改

① 创建元组：

元组使用小括号()，列表使用方括号[]

tup1 = ('Google', 'Runoob', 1949, 2000)
tup2 = (1, 2, 3, 4, 5 )
tup3 = "a", "b", "c", "d"   # 不需要括号也可以

② 访问元组：

#!/usr/bin/python3tup1 = ('Google', 'Runoob', 1949, 2000)
tup2 = (1, 2, 3, 4, 5, 6, 7 )print ("tup1[0]: ", tup1[0])
print ("tup2[1:5]: ", tup2[1:5])

运行结果：

tup1[0]:  Google
tup2[1:5]:  (2, 3, 4, 5)

③ 修改元组：

元组中的元素值是不允许修改的，但我们可以对元组进行连接组合，如：

#!/usr/bin/python3tup1 = (12, 34.56)
tup2 = ('abc', 'xyz')tup3 = tup1 + tup2
print (tup3)

运行结果：

(12, 34.56, 'abc', 'xyz')

④ 删除元组：

元组中的元素值是不允许删除的，但我们可以使用del语句来删除整个元组，如：

#!/usr/bin/python3tup = ('Google', 'Runoob', 1997, 2000)print (tup)
del tup
print ("删除后的元组 tup : ")
print (tup)

元组被删除后就没有了，此时输出会出现异常信息，运行结果：

('Google', 'Runoob', 1997, 2000)
删除后的元组 tup :
Traceback (most recent call last):File "/home/orangepi/./hello.py", line 8, in <module>print (tup)
NameError: name 'tup' is not defined

14、Python3 字典：

Python字典类似于SQLite数据库中的表

① 创建字典：

字典的每个键值key=>value对用冒号:分割，每个对之间用逗号,分割，整个字典包括在花括号{}中，格式如下（注意：dict作为Python的关键字和内置函数，变量名不建议命名为dict）：

d = {key1 : value1, key2 : value2, key3 : value3 }

键必须是唯一的，但值则不必；值可以取任何数据类型，但键必须是不可变的，如字符串，数字，如：

tinydict1 = {'name': 'runoob', 'likes': 123, 'url': 'www.runoob.com'}
tinydict2 = { 'abc': 123, 98.6: 37 }

② 访问字典里的值：

#!/usr/bin/python3tinydict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}print ("tinydict['Name']: ", tinydict['Name'])
print ("tinydict['Age']: ", tinydict['Age'])

运行结果：

tinydict['Name']:  Runoob
tinydict['Age']:  7

③ 修改字典：

#!/usr/bin/python3tinydict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}tinydict['Age'] = 8					# 更新 Age
tinydict['School'] = "菜鸟教程"		# 添加信息print ("tinydict['Age']: ", tinydict['Age'])
print ("tinydict['School']: ", tinydict['School'])
print (tinydict)

运行结果：

tinydict['Age']:  8
tinydict['School']:  菜鸟教程
{'Name': 'Runoob', 'Age': 8, 'Class': 'First', 'School': '菜鸟教程'}

④ 删除字典元素：

#!/usr/bin/python3tinydict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}del tinydict['Name']	# 删除键 'Name'
tinydict.clear()		# 清空字典
del tinydict			# 删除字典

⑤ 字典的多层嵌套：

现在有如下嵌套，我们现在需要获取字典garbage_dict中的Data键字典值的Elements键列表值中唯一一个字典元素中的Category键'干垃圾'值，如下所示：

#!/usr/bin/python3garbage_dict = {'Data': {'Elements': [{'Category': '干垃圾', 'CategoryScore': 0.8855999999999999, 'Rubbish': '', 'RubbishScore': 0.0}], 'Sensitive': False}, 'RequestId': '1AB9E813-3781-5CA2-95A0-1EA334E80663'}# 逐层拆解
data = garbage_dict['Data']
elements = data['Elements']
element = elements[0]
category = element['Category']
print(category)# 一步到位
category = garbage_dict['Data']['Elements'][0]['Category']
print(category)

运行结果：

干垃圾
干垃圾

15、Python3 日期和时间：

① 获取当前时间：

#!/usr/bin/python3import time  # 引入time模块ticks = time.time()		# 获取当前时间戳
print ("当前时间戳为:", ticks)localtime = time.localtime(time.time())		# 获取本地时间
print ("本地时间为 :", localtime)localtime = time.asctime( time.localtime(time.time()) )		# 获取格式化的时间
print ("本地时间为 :", localtime)

运行结果：

当前时间戳为: 1721383086.9457712
本地时间为 : time.struct_time(tm_year=2024, tm_mon=7, tm_mday=19, tm_hour=9, tm_min=58, tm_sec=6, tm_wday=4, tm_yday=201, tm_isdst=0)
本地时间为 : Fri Jul 19 09:58:06 2024

16、Python3 函数：

① 定义函数、调用函数：

#!/usr/bin/python3def max(a, b):if a > b:return aelse:return ba = 4
b = 5
print(max(a, b))

② 传不可变对象实例：

#!/usr/bin/python3def change(a):print("---func---")print(a)   # 指向的是同一个对象a=10print(a)   # 一个新对象print("---func---")a=1
print(a)
change(a)
print(a)

运行结果：

1
---func---
1
10
---func---
1

③ 传可变对象实例：

#!/usr/bin/python3# 可写函数说明
def changeme( mylist ):# 修改传入的列表mylist.append([1,2,3,4])print ("函数内取值: ", mylist)return# 调用changeme函数
mylist = [10,20,30]
changeme( mylist )
print ("函数外取值: ", mylist)

运行结果：

函数内取值:  [10, 20, 30, [1, 2, 3, 4]]
函数外取值:  [10, 20, 30, [1, 2, 3, 4]]

④ 不定长参数：

你可能需要一个函数能处理比当初声明时更多的参数。这些参数叫做不定长参数，和上述 2 种参数不同，声明时不会命名

加了星号*的参数会以元组 (tuple) 的形式导入，存放所有未命名的变量参数

#!/usr/bin/python3# 可写函数说明
def printinfo( arg1, *vartuple ):"打印任何传入的参数"print ("输出: ")print (arg1)print (vartuple)# 调用 printinfo 函数
printinfo( 70, 60, 50 )

运行结果：

输出: 
70
(60, 50)

17、Python3 模块：

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

① import 语句：

想使用Python源文件，只需在另一个源文件里执行import语句，如：

support.py模块：

#!/usr/bin/python3
# Filename: support.pydef print_func( par ):print ("Hello : ", par)return

test.py引入support模块：

#!/usr/bin/python3
# Filename: test.py# 导入模块
import support# 现在可以调用模块里包含的函数了
support.print_func("Runoob")

运行结果：

$ python3 test.py 
Hello :  Runoob

import 搜索路径：

1、当前目录
2、如果不在当前目录，Python则搜索在shell变量PYTHONPATH下的每个目录（环境变量）
3、如果都找不到，Python会查看默认路径，UNIX下，默认路径一般为/usr/local/lib/python/
 

• 模块搜索路径存储在system模块的sys.path变量中，变量里包含当前目录，PYTHONPATH和由安装过程决定的默认目录

② from…import… 语句：

这个声明不会把整个support模块导入到当前的命名空间中，它只会将support里的print_func函数引入进来

support.py模块：

#!/usr/bin/python3
# Filename: support.pydef print_func( par ):print ("Hello : ", par)return

test.py引入support模块的print_func函数：

#!/usr/bin/python3
# Filename: test.py# 导入模块函数
from support import print_func# 不需要再 support. 来指定模块
print_func("Runoob")

③ __name__属性：

  一个模块被另一个程序第一次引入时，模块的主程序将运行。如果我们想在模块被引入时，模块中的某一程序块不执行，我们可以用__name__属性来使该程序块仅在该模块自身运行时执行。

  每个模块都有一个__name__属性，当其值是__main__时，表明该模块自身在运行，否则是被引入，如：

#!/usr/bin/python3
# Filename: using_name.pyif __name__ == '__main__':print('程序自身在运行')
else:print('我来自另一模块')

运行结果：

$ python using_name.py
程序自身在运行

$ python
>>> import using_name
我来自另一模块
>>>

18、“读”和“写”文件

#!/usr/bin/python3# 打开一个文件
f = open("/tmp/foo.txt", "w")f.write( "Python 是一个非常好的语言。\n是的，的确非常好!!\n" )# 关闭打开的文件
f.close()

#!/usr/bin/python3# 打开一个文件
f = open("/tmp/foo.txt", "r")str = f.read()		# 
print(str)# 关闭打开的文件
f.close()

运行结果：

Python 是一个非常好的语言。
是的，的确非常好!!

#!/usr/bin/python3# 打开一个文件
f = open("/tmp/foo.txt", "r")f.seek(16)
str = f.read()
print(str)# 关闭打开的文件
f.close()

运行结果：

非常好的语言。
是的，的确非常好!!

f.read()

  为了读取一个文件的内容，调用f.read(size)，这将读取size个字节的数据, 然后作为字符串或字节对象返回。size 是一个可选的数字类型的参数。 当 size 被忽略了或者为负, 那么该文件的所有内容都将被读取并且返回。

f.write()

 
  f.write(string)将string写入到文件中, 然后返回写入的字符数。

f.tell()

 
  f.tell()用于返回文件当前的读/写位置（即文件指针的位置）。文件指针表示从文件开头开始的字节数偏移量。f.tell()返回一个整数，表示文件指针的当前位置。

f.seek()

 
  f.seek(offset, whence)用于移动文件指针到指定位置。offset表示相对于whence参数的偏移量，from_what的值, 如果是0表示开头, 如果是1表示当前位置, 2表示文件的结尾。from_what值为默认为0，即文件开头。
 

• seek(x,0) ： 从起始位置即文件首行首字符开始移动 x 个字符
• seek(x,1) ： 表示从当前位置往后移动x个字符
• seek(-x,2)：表示从文件的结尾往前移动x个字符

四、参考文章：

RUNOOB.COM------Python3 菜鸟教程