AI算法工程师 | 02人工智能基础-Python基础（二）语言特性

文章目录

• Python基础语法
• • 一、Python语言特性
  • • 使用Jupyter Notebook
    • Python是强类型的动态脚本语言
    • Python中一切皆对象
  • 二、流程控制语句
  • • 条件判断语句
    • 循环语句
  • 三、Python中的切片
  • • 切片操作的用法
    • 切片操作的用途
  • 四、数据类型与类型转换
  • • 数据类型
    • 类型转换

Python基础语法 一、Python语言特性 使用Jupyter Notebook

启动Jupyter Notebook

使用Jupyter Notebook进行编程的好处：方便写注释

win + R 输入 cmd，进入窗口 → cd 切换到需要创建脚本的文件夹中 → 输入 jupyter notebook 来打开 Jupyter Notebook 浏览器（IDE嵌入在浏览器中）

注：使用Jupyter Notebook创建的脚本，是.ipynb格式的

cmd启动Jupyter Notebook时报错-参考： 问题 | ImportError: DLL load failed while importing _ssl: 找不到指定的模块 @Jupyter Notebook

部分常用快捷键

命令行模式（按 Esc 生效）
A	在上面插入单元格
B	在下面插入单元格
D,D	删除选中单元格
Y	把单元格变成代码快
M	把单元格变成 Markdown
Enter	进入编辑模式

编辑模式（按 Enter 生效）
Tab	代码补全或缩进
Ctrl-]	缩进
Ctrl-[	取消缩进
Shift-Enter	运行单元格, 选择下面的单元格
Ctrl-Enter	运行选中的单元格
Ctrl-M	进入命令行模式
Esc	进入命令行模式

Jupyter 笔记本有两种不同的键盘输入模式：
① 编辑模式：允许将代码或文本输入到一个单元格中，并通过一个绿色边框的单元格来表示；
② 命令模式：将键盘与笔记本级命令绑定在一起，并通过一个灰框、左边距蓝色的单元格显示。

Python是强类型的动态脚本语言

问：Python 到底是强语言类型还是弱语言类型 ?
答：强语言类型 ！ 该如何判别呢 ？ ↓↓↓

• 强类型：不允许不同类型相加。例如：整型+字符串会报类型错误

50 + "python" # 不同类型相加，会报错

TypeError                   Traceback (most recent call last)
 in ()
----> 1 50 + "python"

TypeError: unsupported operand type(s) for +: 'int' and 'str'

str(50) + "python"   # str(50)：把50这个Integer整型强转为String类型

'50python'

50 + int('5')

55

• 动态：不使用显示数据类型声明，且确定一个变量的类型是在给它赋值的时候（即：根据后面给的值类型，来决定前面变量的类型）

uid = 100
type(uid)

int

uid = "一百"
type(uid)

str

• 脚本语言：一般是解释性语言，运行代码只需要一个解释器，不需要编译器
  python语言写的程序不需要编译成二进制代码，可直接从源代码运行程序
  

Python中一切皆对象

对象和引用

Python 中，一切皆对象。每个对象由：标识（identity）、类型（type）、值（value）组成。对象的本质就是：一个内存块，拥有特定的值，支持特定类型的相关操作。

1. 标识 用于唯一标识对象，通常对应于对象在计算机内存中的地址。使用内置函数id(obj) 可返回对象 obj 的标识。
2. 类型 用于表示对象存储的“数据”的类型。类型可以限制对象的取值范围以及可执行的操作。可以使用 type(obj) 获得对象的所属类型。
3. 值 表示对象所存储的数据的信息。使用 print(obj) 可以直接打印出值。

在 Python 中，变量也成为：对象的引用。因为，变量存储的就是对象的地址。变量通过地址引用了“对象”。（ 变量位于：栈内存；对象位于：堆内存 ）

从图中可看出，栈内存中的引用指向堆内存中的对象（变量与对象：通过id关联）

uid = "一百"
id(uid)

1994692910416

type(uid)

str

print(uid)

一百

变量的声明和赋值

变量（variable）的主要作用：为 Python 中的某个值起个名字，方便记忆。

语法结构：变量名 = 变量值

在 Python 语言中，声明变量的同时需要为其赋值。
原因：不代表任何值的变量毫无意义，Python 中不允许有这样的变量。

示例：变量在使用前必须先被初始化（即：先被赋值）

# 声明变量 name 没被赋值，报错
name

NameError                       Traceback (most recent call last)
Input In [15], in ()
      1 #
----> 2 name

NameError: name 'name' is not defined

b         # 声明变量 b 没被赋值，报错
print(b)  # 输出未被赋值的 b，报错

NameError                       Traceback (most recent call last)
Input In [17], in ()
----> 1 b
      2 print(b)

NameError: name 'b' is not defined

二、流程控制语句

知识补充：关于Python代码的组织和缩进

• Python 语言是直接通过缩进来组织代码块的
  • 缩进时，几个空格都是允许的，但是数目必须统一。通常采用“四个空格”表示一个缩进。
  • 要避免将 “tab 制表符” 或者 tab 与空格 混合的缩进风格。
  • 目前，常用的编辑器一般设置成：tab 制表符就是 4 个空格。
• Python 与 C、Java 等高级语言不同，其代码块不使用大括号 {} 来控制语句、函数、类的作用域。Python 采用独特的缩进来控制模块作用域。

示例：

a=0
if a == 0:
    print("root")
else:
print("abc") # 缩进没有对齐，在执行时会报错

  Input In [25]
    print("abc") # 缩进没有对齐，在执行时会报错
    ^
IndentationError: expected an indented block

条件判断语句

1. 单分支语句 if

uid = 0   # 变量必须先初始化
if uid == 0:
    print("abc")
print("root")

abc
root

注意：
① 每个 if 条件后要使用冒号 ( : ) ，表示接下来是满足条件后要执行的语句；
② 使用缩进来划分语句块，相同缩进数的语句在一起组成一个语句块；
③ 在 Python 中没有 switch-case 语句。

2. 双分支语句 if-else

if uid == None:
    print("root")
else:
    print("abc")

abc

3. 多分支语句 if-elif

score = 88.8
level = int(score % 10)
​# if-elif 相当于 if-else if
if level >= 10:
    print('Level A+')
elif level == 9:
    print('Level A')
elif level == 8:
    print('Level B')
elif level == 7:
    print('Level C')
elif level == 6:
    print('Level D')
else:
    print('Level E')

Level B

4. 三元条件运算符

语法格式：A=Y if X else Z（ 如果X为真，则执行 A=Y；否则，执行 A=Z ）

level = int(88.8 % 10)
print('Level A+') if level >= 10 else print('Level Others')

Level Others

循环语句

1. while循环

语法结构：

while 条件表达式:
	循环体语句

示例：

count = 0
while count <= 9:
    print(count)
    count += 1  # count = count + 1

0
1
2
3
4
5
6
7
8
9

result = ''
count = 0
while count <= 9:
    result += (str(count) + ' ')  # 拼接 ; str(count)：类型转换
    count += 1  # count = count + 1
print(result)

0 1 2 3 4 5 6 7 8 9 

count = 0
while count <= 9:
    print(count, end=' ') #print中加end参数：让输出后不是默认回车，此处end=' '表示每次输出后空格
    count += 1  # count = count + 1
print() # 相当于：回车（换行）
print('Done')

0 1 2 3 4 5 6 7 8 9 
Done

count = 0
while count <= 9:
    print(count, end=' ')
    count += 1
​
print('end')

0 1 2 3 4 5 6 7 8 9 end

2. for循环

for 循环用于遍历一个集合，每次循环，会从集合中取得一个元素，并执行一次代码块，直到集合中所有的元素都获取，for 循环才结束。

语法结构：

for 变量 in 可迭代对象:
	循环体语句

# Python 可遍历的对象有：
# 序列(字符串、列表、元组)、字典、迭代器对象(iterator)、生成器函数文件对象

示例：

names = ['Tom', 'Peter', 'Jerry', 'Jack'] # python中的中括号[ ] 表示列表。列表是有序的集合，可根据索引号去取值
for name in names:  # name：形参
    print(name)

Tom
Peter
Jerry
Jack

• for 循环通常与 range() 函数一起使用。

# range([start,] end [,step]):生成的数值序列从 start 开始到 end 结束（不包含 end）
# 若未填写start，则默认从 0 开始。step 是可选的步长，默认为 1
range(4)

range(0, 4)

• Python3 中 range() 返回的是一个 range 对象，而不是列表。需要通过 list() 方法将其转换成列表对象。

list(range(4)) # 将range(4)强转成list列表类型

[0, 1, 2, 3]

for i in range(len(names)): #len(names)：names长度为4；range(4)是一个可迭代的对象
    print(names[i])

Tom
Peter
Jerry
Jack

3. 循环嵌套

一个循环体内可以嵌入另一个循环，一般称为“嵌套循环”，或者“多重循环”。

AI中常用的是双重for循环，如：寻找最优解

示例：打印九九乘法表

• while双重循环方式 打印九九乘法表

j = 1
while j <= 9:
    i = 1
    while i <= j:
        print("%d*%d=%d"%(j, i, i*j), end='t')
        i += 1
    print()
    j += 1

1*1=1	
2*1=2	2*2=4	
3*1=3	3*2=6	3*3=9	
4*1=4	4*2=8	4*3=12	4*4=16	
5*1=5	5*2=10	5*3=15	5*4=20	5*5=25	
6*1=6	6*2=12	6*3=18	6*4=24	6*5=30	6*6=36	
7*1=7	7*2=14	7*3=21	7*4=28	7*5=35	7*6=42	7*7=49	
8*1=8	8*2=16	8*3=24	8*4=32	8*5=40	8*6=48	8*7=56	8*8=64	
9*1=9	9*2=18	9*3=27	9*4=36	9*5=45	9*6=54	9*7=63	9*8=72	9*9=81	

• 双重for循环方式 打印九九乘法表

list(range(1, 10, 2)) # range(1, 10, 2)：2为步长

[1, 3, 5, 7, 9]

for j in range(1, 10): # for循环需要对可迭代对象进行遍历，range函数左闭右开
    for i in range(1, j+1):
        print("%d*%d=%d"%(j, i, i*j), end='t')
        i += 1
    print()
    j += 1

1*1=1	
2*1=2	2*2=4	
3*1=3	3*2=6	3*3=9	
4*1=4	4*2=8	4*3=12	4*4=16	
5*1=5	5*2=10	5*3=15	5*4=20	5*5=25	
6*1=6	6*2=12	6*3=18	6*4=24	6*5=30	6*6=36	
7*1=7	7*2=14	7*3=21	7*4=28	7*5=35	7*6=42	7*7=49	
8*1=8	8*2=16	8*3=24	8*4=32	8*5=40	8*6=48	8*7=56	8*8=64	
9*1=9	9*2=18	9*3=27	9*4=36	9*5=45	9*6=54	9*7=63	9*8=72	9*9=81	

• 知识补充：使用 % 实现格式化输出（%s : str；%d: int；%f: float）

# 格式输出
name="小华"
month=4
a=44.3
b=66.6
print("%s您好 ，您%d月已花费%f元，余额为%f"%(name,month,a,b))

小华您好 ，您4月已花费44.300000元，余额为66.600000

4. break与continue

break 语句可用于 while 和 for 循环，用来结束整个循环。当有嵌套循环时，break 语句只能跳出最近一层的循环。

continue 语句 用于结束本次循环，继续下一次。多个循环嵌套时，continue 也是应用于最近的一层循环。而 break 语句用来彻底退出循环。

示例：

for i in range(10): # range(10)返回 0~9
    if i % 2 == 0:
        continue
    print(i)

1
3
5
7
9

names = ['Tom', 'Peter', 'Jerry', 'Jack']
for i in range(len(names)):
    if i >=2:
        break
    print(names[i])

Tom
Peter

for i in range(3):
    for i in range(10):
        if i % 2 == 0:
            continue  # continue应用于最近的一层循环
        print(i)

1
3
5
7
9
1
3
5
7
9
1
3
5
7
9

names = ['Tom', 'Peter', 'Jerry', 'Jack']
for i in range(3):
    for i in range(len(names)):
        if i >=2:
            break # break 语句只能跳出最近一层的循环
        print(names[i])

Tom
Peter
Tom
Peter
Tom
Peter

三、Python中的切片 切片操作的用法

切片是 Python 序列及其重要的操作，适用于列表、元组、字符串等。

语法结构：列表[起始偏移量 start : 终止偏移量 end [:步长 step]]

示例：

pystr = 'Python'
pystr[:] # [:]提取整个列表

'Python'

pystr[2:] # [start:]从 start 索引开始到结尾

'thon'

pystr[:5] # [:end]从头开始直到 end-1 （左闭右开）

'Pytho'

pystr[1:5] # [start:end]从 start 到 end-1（左闭右开）

'ytho'

pystr[1:5:2] # [start:end:step]从 start 提取到 end-1，步长是 step

'yh'

• [start : end : step] 中三个量为负数的示例：

pystr[-3:] # 从列表的倒数第 3 个开始到列表结束

'hon'

pystr[-5:-3] # 从倒数第五个到倒数第三个(包头不包尾，即：实际到倒数第4个)

'yt'

pystr[::-2] # 步长为负，从右到左反向提取

'nhy'

• [start : end : step] 中正数和负数混用的示例：

pystr[1:-3]

'yt'

切片操作的用途

切片操作对机器学习训练中的作用：

• AI中需要数据Data，可对Data数据进行切分，得到训练集 TrainSet 和测试集 TestSet
• 分batch批次执行，如：利用切片，分批次的从训练集中取不同的数据
  

四、数据类型与类型转换 数据类型

数据类型是一个集合以及定义在这个集合上的一组操作。如：数值类型必然都是数字，字符串类型必然都是字符串。

元组型 Tuple、列表型 List、集合型 Set，这三类数据类型 是有顺序的（好处：切片操作可使用）

Python中的数据类型如图：

注：可变不可变指的是内存中的值是否可以被改变
① 不可变类型：对象所在内存块里面的值不可以改变
（重新给某变量赋值后，返回的是内存中新的数据类型，而不是原来的那个）；
② 可变类型：则是可以改变，主要有列表、字典。

类型转换

常见的Python类型转换：

语法	说明
int(x [,base])	将 x 转换为一个整数
long(x [,base] )	将 x 转换为一个长整数
float(x)	将 x 转换到一个浮点数
complex(real[,imag])	创建一个复数
str(x)	将对象 x 转换为字符串
repr(x)	将对象 x 转换为表达式字符串
eval(str)	用来计算在字符串中的有效 Python 表达式，并返回一个对象
Complex(A)	将参数转换为复数型
tuple(s)	将序列 s 转换为一个元组
list(s)	将序列 s 转换为一个列表
set(s)	转换为可变集合
dict(d)	创建一个字典。d 必须是一个序列 (key,value)元组
frozenset(s)	转换为不可变集合
chr(x)	将一个整数转换为一个字符
unichr(x)	将一个整数转换为 Unicode 字符
ord(x)	将一个字符转换为它的整数值
hex(x)	将一个整数转换为一个十六进制字符串
oct(x)	将一个整数转换为一个八进制字符串

类型转换之 eval函数：

• eval(str)：用来计算在字符串中的有效 Python 表达式，并返回一个对象

eval("5+10") 

15

a = 10
b = 20
eval("a+b")

30

—— 说明：本文内容基于python3.0