流程控制

1. 顺序结构: 代码从上往下依次执行
2. 分支结构: 通过if 进行分支选择
3. 循环结构: 通过while或for进行循环操作

分支1

格式:

if 条件: true环境

规则:

条件为真, 则执行true环境

条件为假, 则跳过true环境

分析:

条件就是一个表达式, 例如: 比较, 赋值, 逻辑 …

最终条件只有两个结果: true 和 false

分支2

if 条件:

true环境 (代码块)

代码块: 一行或者多行代码, 但不能不写

分支3

if 条件:

true环境

else:

false环境

规则:

条件为真, 则执行true环境

条件为假, 则执行false环境

分支4

if 条件:

true环境 (代码块)

elif 条件2:

true2环境 (代码块)

elif 条件3:

true3环境 (代码块)

…

多个条件满足一个即可进入代码块

例如: 男生挑女朋友!!

长得好看吗

身材好吗

温柔乖巧吗

姿势多吗

分支5

if 条件:

true环境 (代码块)

elif 条件2:

true2环境 (代码块)

elif 条件3:

true3环境 (代码块)

…

多个条件满足一个即可进入代码块

例如: 男生挑女朋友!!

长得好看吗

身材好吗

温柔巧吗

姿势多吗

while循环

循环:

作用: 将某一部分的代码功能, 重复的执行, 直到不满足某些条件时, 终止循环

好处: 偷懒, 减少代码量

1. while格式

while 1.条件:

2.true环境 (代码块)

1. 循环外的代码

条件成立, 则进入true环境

条件不成立, 则结束循环, 准备执行while外面的代码

循环1

while 条件: true环境 		仅适合简单功能

一条命令独占一行, 一般不允许同在一行

若强制同在一行, 每条命令之间用 分号 隔开

循环2

死循环, 无限循环: 条件永远成立 例如True, 1 …

在未来实时请求时, 非常有用

例如: 游戏人物对话, 按回车才能进行下一步

例如: 循环次数不确定时, 当满足某些指定条件时, 在循环中通过一些特殊手段来终止循环

循环3

while ①条件:

​ ②true环境 (代码块)

​ else:

​ ③false环境 (代码块)

执行顺序:成立: 则执行 ②

条件① 不成立: 则执行 ③

for循环

循环1

for 变量 in 容器:

​ 代码块

容器: list, tuple, set, dict

这里也可以填 string

变量 会一次获取容器中一个值

循环2

for 变量 in 容器:

​ 代码块

else:

​ 进阶体

这里的else是值: 当循环完了就立马进入else

循环3

for 变量 in 数字区间:

代码块

数字区间:

range(start, stop, step)

参数:

start: 从start开始, 默认从0开始

stop: 到stop结束, 不包括stop

step: 步长, 默认为1

函数

1.定义

将代码组织在一起, 从而实现一个完整的功能

功能相似, 位置相同, 用循环

功能相似, 位置不同, 用函数

2.作用

可重复利用, 降低冗余率

提高开发效率

便于代码维护

3.分类

内置函数: 内建函数, 系统函数, 编程语言自带的, 可以直接使用

自定义函数: 根据实际需求而创造的函数

4.自定义

格式:

def 函数名( 参数1, 参数2, … ):

​ 函数体,代码块

注意:

函数体一定要缩进

组成:

​ 关键字: def​ 函数名​ 参数​ 函数体​ 返回值

5.特性

不调用不执行

函数可以互相调用, 却互不影响

调用函数的位置 必须在 定义函数位置的后面 (有顺序要求)

执行原理:

先调用函数

再执行函数体,代码块

当代码块全部执行完毕后, 回到调用函数的地方

6.调用函数

函数名()

函数名

1.命名规范：

由数字, 字母和下划线组成，不能以数字开头，严格区分大小写，命名形式

参考: PEP

注意点：

​ 1.函数重名

​ 2.调用函数, 会调用前面最近的一个指定函数

​ 3.函数可以覆盖, 后面的覆盖前面的

​ 4.尽量别重名

4.2 函数名意义

为了后期的维护, 提高代码的可读性, 函数名最好通俗易懂

看到名字就大致知道什么功能

惯性:

函数名习惯以 动词+名词 形式出现

2.返回值

1.关键字: return：函数中的值 返回到调用函数的地方

2.作用：提前结束函数, 并返回, return 后面的代码将不再执行

3.返回类型

1.return 可以返回任意类型

2.多返回值

return 值1, 值2, …)

return [值1, 值2, …]

return {值1, 值2, …}

需要一次性返回多个值:

​ 1) 将多个值 以逗号隔开

​ 2) 将值 包装到list, tuple, set 中

3.如果函数 没有return, 默认返回None

4.参数

1.定义

参数: 能用将函数功能进行微弱的变化, 从而达到通用的效果

形参: 在定义函数时给的参数 (parameter)

实参: 在调用函数时给的参数 (argument)

2.参数传递

​ 1.值 和 传址

传值: 仅仅是将值 传递过去

传址: 不仅将值 传递过去, 而且将内存地址传递过去

​ 2.区分:

传值: 不可变数据类型 (Number, string, tuple, set)

传址: 可变数据类型 (list, dict)

3.参数类型

1.必须参数

实参个数 = 形参个数 (参数个数必须一致)

先到先得

2.关键字参数

实参指定 参数名来传入

好处: 不用按照顺序来传入

3.默认参数

即便实参没有传值, 形参可以采用默认值

4.不定长参数

在形参前面加 * , 以元组形式接收没人要的实参

在形参前面加 **, 以字典形式接收没人要的关键字实参

单独出现 * , 在*后面的参数必须以关键字实参进行传入

且关键字 必须与 形参名 一致

5.匿名函数

没有名字的函数

场景: 功能太简单, 又不想写def, 不用取函数名

lambda 形参 : 返回值

冒号左边: 想要传递的参数

冒号右边: 需要return的结果

注意: lambda是一个表达式, 并非语句, 用在def不能用的地方

小结:

lambda 用于简单功能

def 用于复杂功能

变量的作用域

全局变量

在函数外部定义的变量

局部变量

在函数内部定义的变量

作用域

查询规则:

L -> E -> G -> B

仅仅是访问, 不代表修改或删除

x = int(10.5) 		# 内置作用域 B	

a = 0 				# 全局作用域 G 
def outer():
	b = 1 			# 闭包函数外的函数内 E
	print(\'b的变量: %d \' % b)

	def inner():
		c = b 		# 局部作用域 L
		c = a
		print(\'c的变量: %d\' % c) 	# L 区间能找到E区间的变量
									# L 区间能找到G区间的变量	

	inner()
	# print(\'c的变量: %d\' % c) 	# E 区间找不到L区间的变量
outer()
print(\'a的变量: %d\' % a)
# print(\'b的变量: %d\' % b) 	# G 区间不能找到 E区间的变量

改变作用域

在作用域E中, 不能直接改变全局变量, 通过global声明一下, 就可以改变全局变量

注意点:

global a 之后, 全局a 和 global a 公用一个内存

而在E 区间中, 单独写 a = 15, 仅仅是给E区间中声明一个新的变量a, 该变量a 与 全局a 内存不一样

如果仅仅是访问全局a , 不需要global声明

L 区间可以访问E区间的变量, 不能直接改变E区间的变量, 通过 nonlocal来声明一下就可以改变E区间的变量

小结:

需要改变作用G 中的变量, 则通过global

需要改变作用E 中的变量, 则通过nonlocal

代码案例:

a = 10 		# G 区间
def outer(): 
	b = 5 	# E 区间
	global a
	a += b 
	print(a)

outer()
print(a)

a = 10
def outer():
	b = 55 			# E区间
	def inner():
		nonlocal b
		b += 5 		# L区间
		print(b)
	inner()
outer()

闭包函数

定义

函数A 里面定义了一个新的函数B

函数B 使用函数A的变量

只要满足以上两个条件, 函数B就是一个闭包函数

例如：

def A():
	a = 10
	def B():
		print(a) 	# 使用函数A的变量, 那么此时函数B, 就成为了 闭包函数

# 通俗说法: 函数A 常被称之为: 外部函数
# 		   函数B 常被称之为: 内部函数

闭包的两种使用方式

直接调用

def A():
	a = 10
	def B():	
		b = 20
		b += a
		print(b)

	B() 	# 直接调用
A()

def A():
	a = 10

	def  B():
		b = 20
		b += a
		print(b)

	return B 	# 返回的是 函数B

result = A() 	# result = 函数B
result() 	
result() 	

分析:

当执行完53行, 到54行时, A() 已经执行完毕了.

由于返回的是函数, 导致了函数B内的变量, 依旧占用内存

默认情况下, 一个函数结束时, 函数内的变量应该是 全部释放(删除)

作用

优点: 数据的持久化

缺点: 因为持久化, 没哟及时释放内存, 所以一直占用内存, 浪费了性能

注意点

闭包函数不能直接修改外部函数的变量

内置函数

类型相关

int()

float()

bool()

complex()

str()

list()

tuple()

set()

dict()

变量相关

id() 获取变量的内存地址

type() 获取变量的数据类型

print() 输出变量

locals() 获取当前作用域中的所有变量

数学相关

abs()

sum()

max()

min()

pow()

round()

range()

进制相关

hex() 十六进制

oct() 八进制

bin() 二进制

chr() ascii => 字符

ord() 字符 => ascii

repr() 原始字符串

eval() 解析字符串 (能够将字符串 当成公式执行. 例如含有变量, 那么就会解析变量)

字符串方法

格式

方法就是函数
​ 对象: 一切皆对象

字符串方法
​ 对象.方法名()

    方法就是函数
    对象: 一切皆对象

    .upper()        全部转为大写
    .lower()        全部转为小写
    .capitalize()   首字母大写
    .title()        每个单词的首字母大写
    .isalnum()      只能有数字, 字母 , 中文
    .isalpha()      只能有字母, 中文
    .isdigit()      只能有数字
    .isupper()      检测是否为大写
    .islower()      检测是否为小写

格式化函数

基础用法

a = \'{},{},{}高高兴兴牵着手, 一起冲向女厕所\'

print(a)
print(a.format(\'熊大\', \'熊二\', \'光头强\')  )

索引格式化

a = \'{0},{1},{2}高高兴兴牵着手, 一起冲向女厕所\'
a = \'{2},{1},{0}高高兴兴牵着手, 一起冲向女厕所\'
a = \'{1},{2},{0}高高兴兴牵着手, 一起冲向女厕所\'

print(a.format(\'熊大\', \'熊二\', \'光头强\')  )

关键字格式化

a  = \'{name}头顶{2}, 身披{pro1},\'锅盖\', pro2=\'麻袋\', pro3=\'白菜\'))
print(a.format(pro1=\'锅盖\', pro2=\'麻袋\', pro3=\'白菜\', name=\'狗蛋\'))

索引、关键字混合

a  = \'{0}头顶{1}, 身披{pro2}, 脚踩{pro3}, 吾称屌丝二代\'
print( a.format(\'二狗\', \'锅盖\', pro2=\'麻袋\', pro3=\'白菜\'   )  )
# print( a.format( pro2=\'麻袋\', pro3=\'白菜\', \'二狗\', \'锅盖\')  )
print( a.format(\'二狗\', \'锅盖\', pro3=\'白菜\', pro2=\'麻袋\'   )  )

格式限定符

{a:bcd}

a: 索引/关键字

b: 填充符号 默认 空字符串

c: 对齐符号 左< 右> 居中^

d: 总长度

如果a 比 d 还长, 那么bc就看不出来, 以实际a 的长度为准

如果a 比 d 还小, 那么不够的长度用b来填

进制限定

b: 二进制

o: 八进制

d: 十进制

x: 十六进制

格式: {:b}

格式: {