python多次判断_python判断与循环

三目运算符

exp1 if contion else exp2

exp1 exp2 表达式contion 判断条件

如果contion为true 执行exp1，否则执行exp2

max = a if a>b else b 如果a>b 返回a，否则返回b

嵌套

遇到嵌套，从里到外

a if a>b else c if c>d else d

从里到外分解

第一步 c if c>d else d先判断这个 返回一个结果

第二步 a if a>b else 第一步返回值

assert 表达式断言。成立继续执行，不成立直接报错，用语排错

AssertionError 异常

1.判断

if 表达式1:

代码

elif 表达式2:

代码

..........

else:

代码

同一范围内if elif else

同一范围内的同类可以分类嵌套 if else if else

存在子类可以在对应范围内嵌套

一个范围不需要执行代码，什么都不做 pass

2.循环

在循环的if中判断

break 跳出循环，如果有嵌套，只跳出所在循环体

continue直接执行下一次循环

pass 什么都不做

嵌套循环类似矩阵，从内到外计算，对应矩阵从行到列

2.1 while

while表达式:

代码

常用的2种使用方法

2.11 指定一个数字，循环多少次

num = 0

while num<10:#输出0到910个数

print(num,end='')

num +=1

2.12 使用数字当索引值，输出序列

len() 从1开始数，指定数字从0，范围中后面的开区间

刚好可以遍历整个序列

lemon = 'abcdef'

i = 0

while i < len(lemon):

print(lemon[i],end='')

i += 1

print()

print(i)

输出

abcdef

6

2.2 for

迭代，按顺序访问每一项

for 迭代变量 in 序列(str,list,tuple,dict,set):

代码块

2.21 遍历序列

lemon = 'abcdef'

for i in lemon:

print(i,end='') #全部输出

2.22 数值循环

for i in range(0,6):

print(i,end='') #输出0~5没有6

2.23 遍历字典values() items()

d = {'a':1,'b':2}

for i in d.items():#输出key-value

print(i)

for i in d.values():#输出value

print(i)

输出

('a', 1)

('b', 2)

1

2

2.3 推导式，快速初始化各种序列

list推导式

[表达式 for 迭代变量 in 可迭代对象[if文]]

把正常的for文的表达式部分放到前面

for 迭代变量 in可迭代对象:

表达式

嵌套

[(x, y) for x in range(5) for y in range(4)]

for x in range(5):

for y in range(4):

listname.append((x, y))

lemon = [x * x for x in range(5) ] #[0, 1, 4, 9, 16]

banana =[x * x for x in range(5) if x%2 == 0]

orange = [(x, y) for x in range(5) for y in range(4)] #嵌套

print(lemon)

tuple推导式

生成一个生成器对象，遍历之后为空

a = (x for x in range(1,10))

for i in a:

print(i,end=' ')

print(tuple(a))

输出

1 2 3 4 5 6 7 8 9 ()

a = (x for x in range(1,10))

print(tuple(a))#(1, 2, 3, 4, 5, 6, 7, 8, 9)

print(tuple(a)) #()

set推导式

集合元素唯一

lemon = (1,2,2,3)

se = {x**2 for x in lemon}

print(se)#{1, 4, 9}

dict推导式

将列表中各字符串值为键，各字符串的长度为值，组成键值对

lemon = ['aaa','bb']

n = {key:len(key) for key in lemon}

print(n)#{'aaa': 3, 'bb': 2}

交换现有dict中key-value

lemon ={'aaa': 3, 'bb': 2}

n = {key:value for value,key in lemon.items()}

print(n)#{3: 'aaa', 2: 'bb'}

使用字典中的value组成set

lemon = {'1':1,'2':2,'3':3}

se = {x for x in lemon.keys()}

print(se)#{'3', '1', '2'}

2.4 冒泡排序

1.比较两个数，大的放后面

2.重复整个列表，最大的放最后

重复12使得从小到大排序

列表名 data

第一步判断前后大小，前面大交换位置

if (data[j] > data[j+1]):

data[j],data[j+1] = data[j+1],data[j]

第二部 重复整个列表，重复次数是列表长度，剩下最后一个不用排序，-1

for j in range(len(data)-1):

重复12，第i次的时候，后面有i个最大的数，不用再比较,-i

for i in range(len(data)-1):

for j in range(len(data)-i-1):

if (data[j] > data[j+1]):

data[j],data[j+1] = data[j+1],data[j]

2.5 zip()

list推导式 嵌套，可以生成一个位置多个元素的列表

[(x, y) for x in range(5) for y in range(4)]

压缩可以讲多个序列压缩成一个zip对象

生成一个位置多个元素的列表

两种用法 结果相同

my_list = [11,12,13]

my_tuple = (21,22,23)

print([x for x in zip(my_list,my_tuple)])

my_list = [11,12,13]

my_tuple = (21,22,23)

print(list(zip(my_list,my_tuple)))

[(11, 21), (12, 22), (13, 23)]

2.6 使用函数对序列排序 reversed() sorted()

reversed() 返回逆序迭代器，不改变原序列

sorted()可以设置升序和降序 默认升序 reverse = True 降序 False 升序

返回序列不改变原序列

基本的排序分4种，正序倒序，升序降序

reversed()正序倒序按照原序列的正反排序

sorted() 升序降序按照大小排序

a = [1,2,4,3,5]

print(list(reversed(a))) #[5, 3, 4, 2, 1]

print(a)#[1, 2, 4, 3, 5]

print(sorted(a,reverse = True)) #[5, 3, 4, 2, 1]

print(a)#[1, 2, 4, 3, 5]

推导式创建

a = (1,2,4,3,5)

print([x for x in reversed(a)])