if和 else

顺序结构

分支结构

if 是流程控制语句,用来判断


if 语句的格式,if 语句格式要求使用冒号和缩进

正常代码......

if 条件 A: 条件 A 成立是(true) 要执行的代码正常代码

当a等于10的时候输出"条件成立"

a = 10

if a == 10:

print("条件成立")

if else 语句

正常代码......

if 条件 A:

条件A 成立时(true) 要执行的代码

.......

else:

条件A 不成立是(False)要执行的代码正常代码

当a 等于10时输出条件成立,当A 不等于10时输出条件不成立

a = input("请输入a的值") a = int(a)

if a == 10:

print("条件成立") else:

print("条件不成立")

#=============================================

number = input("请输入一个数") #把字符转换成的数字

number = int(number) #判断这个数字是否是偶数if number %2 ==0:

print("你输入的数字是{number},他是一个偶数") else:

print("你输入的数字是{number},他不是一个偶数") print("END")

ELIF及注意事项

if 语句中可以添加 elif 处理额外的判断条件 if A: 代码 ...... elif B: 代码..... elif C: 代码.....

#根据用户输入自己的考试分数(0-100) '''

100 s

90-99 a

80-89 b

70-79 c

60-69 d

0-60 e '''

score = input("请输入自己的分数") if score != "":

score = int(score) if 1<= score <=100:

if score ==100: print('s')

elif 90<= score <=99: print('a')

elif 80<= score <=89: print('b')

elif 70<= score <=79: print('d')

elif 60<= score <=69: print('e')

else:

print("不及格")

else:

print("输入的分数有误")

else:

print("你没有输入分数")

列表和元祖

列表和下标

列表是python中最基本的数据结构

列表中可以包涵任意多个数据元素,和任意的数据类型

my_list=[12,"a",3.5,4]

列表下标从0开始,可以使用下标获取元素 my_list[2]

列表也可以使用负数下标 my_list[‐1]

可以使用[start:end:step] 对列表进行截取

my_list[1:4]

<font color=red>和字符串的截取方式一样</font>

<font color=red> 字符串是不可变类型,列表里面的数据是可以通过索引重新赋值和修改,截取列表只是产生一个新的列表,不会改变原来的列表</font>

my_list = [] #空列表b=[1,2,3,4]

print(type(b))# 打印b的数据类型c=[1,2,"a",bool," 打 印 "] print(c[1])

print(c[‐1]) print(c[1:2:1])

列表的简单使用

使用in 或 not in 判断列表是否包涵某个元素12 in my_list

列表可使用 + 进行拼接 new_list = list1 + list2 列表可使用 * 进行重复 new_list = my_list*3

my_list = [1,2,3,4,"列表"] new_list= my_list*3 print(new_list)

[1, 2, 3, 4, '列表', 1, 2, 3, 4, '列表', 1, 2, 3, 4, '列表']

使用reverse() 方法反序列表

使用max()函数获取列表中最大的元素使用min()函数获取列表中最小的元素

使用sort()方法排序某个列表 必须是同一类型的

查找元素

对列表的主要操作是增删改查

查找和修改元素最简单的方法就是使用下标去查找

增加新的元素

通过下标获取元素内容进行修改

通过元素内容查找元素在列表中首次出现的的位置查找某一个元素在列表中出现了几次

my_list = [1,2,3,4,"列表"]

my_list[2]="修改"#修改列表中第二个元素的值print(my_list)

num=my_list.index('修改') #查找字符串在列表中的位置print(num)

print(my_list.count(2)) #查找2在列表中出现过几次my_list[2],my_list[3]=my_list[3],my_list[2] #交换列表3 2的位置print(my_list)

======================================= [1, 2, '修改', 4, '列表'] 2 1 [1, 2, 4, '修改', '列表']

===============================

列表和字符串转换

print(my_list)

s="周一,周二,周三,周四,周五,周六,周日" a=s.split(",")# 把字符串转换成列表

s2 = ",".join(a)#把一个列表组合成一个字符串,需要类型一致print(s2)

print(a)

列表新增元素

my_list.append(5) #往列表的末尾增加元素my_list.insert(2,"hi")

# 把"hi"插入到下标为2的位置,列表中的其他元素一次往后移动

增加多个元素到列表中

my_list.extend([5,6,7])#把多个元素添加到列表的尾部

删除元素

my_list=["周一","周二","周三","周四","周五","周六","周日"]

移除列表中的最后一个元素

print(my_list.pop())#移除列表中的最后一个元素print(my_list)

移除列表中下标为5的元素

print(my_list.pop(5))#移除列表中下标为5的元素print(my_list)

从列表中移除指定内容

my_list.remove("周二")#从列表中移除指定内容print(my_list)

清空列表

my_list.clear()#清空列表print(my_list)

元祖

元祖(Tuple)也是一种有序容器 使用小括号元祖也使用下标索引元素

元祖也可以和列表一样进行截取元祖和列表的最本质区别

元祖是不可变类型,所以不能进行增删改查操作 对于关联性比较强的数据可以使用元祖 比如坐标,rgb(xxx,xxx,xxx)

my_list=("周一","周二","周三","周四","周五","周六","周日")#初始化一个元祖a=(1)#在这里表示运算符提高优先级,如果需要是元祖必须在b的后面添加一个逗号a=(1,)#初始胡一个元祖a 只有一个元祖1

#在给元祖初始化时可以不写小括号print(type(my_list)) print(my_list[::‐1])#对元祖返回b,c,d ,e,f,g,h= my_list

print("b={b} c={c} d={d} e={e} f={f} g={g} h={h}".format(b=b, c=c, d=d ,e=e, f=f ,g=g

,h=f))

my_list[0],my_list[1] = (my_list[1],my_list[0]) # 取出下标1 下标0 的值 组成一个新的元祖,用这个新的元祖给my_list[0],my_list[1] 重新赋值

列表嵌套

嵌套列表的使用

列表 List 中可以存放任意类型的元素

stu1 = ["小明",95]

stu2 = ["小红",86]

stu3 = ["小王",68]

students = [stu1,stu2,stu3] print(students) print(students[1][0])

print("分数:={} 姓名={}".format(students[0][0], students[0][1]))

循环语句

Range 方法


L3 = List(range(100))

range(end) 生成0-end之间的整数,不包含end

生成从start,到end之间的整数

生成从start,到end,步长为2的列表

生成一个元祖

my_list = Tuple(range(100)) print(my_list)

把列表转换成元祖

my_list = list(range(100)) print(my_list)

my_list1 = tuple(my_list)#把列表转换成元祖

列表遍历

#生成一个1‐99的列表

from typing import Tuple

#生成一个100个元素的列表,并遍历该列表输出my_list = list(range(100))

for item in my_list: print(item)

#遍历字符串

str= "abcdefghigklmn" for item in str:

print(item)

For循环

如何控制循环的次数

计算1+2+ 99的和

while 循环

注意不要死循环

while True: #死循环print("python")

====================================

l=[]

i=""

while True:

i= input("请输入你计划(q 退出):") if i=="q":

break l.append(i)

print(l)

pass 占位符,保持程序的完整性

列表推导式

使用列表推导试

l=[1,2,3,4,5,6]

l1 = [i for i in l] #生成新的列表print(l1)

l1 = [i*2 for i in l] #一次获取l中的元素 *2 放到l1中生成新的列表

print(l1)

l1 = [i*2 for i in range(10)] #使用range生成0‐9这10个元素 *2 放到l1中形成新的列表

print(l1)

l1 = [i for i in range(10) if i%2==0]# 获取0‐9 10个元素,并判断是否为偶数,使用偶数形成新的列表l1

print(l1)

l1 = [str(i*2) for i in range(10)] #使用range生成0‐9这10个元素 *2 并转换成字符串保存到列表l1 中

###推导式练习

#获取列表中所有元素的第一个字母组成一个字符串l = ["food","Moon","Loop"]

l1 = [i[0] for i in l] str1="".join(l1) print(str1)

#找出同时出现在列表l1和l2中的字符l1 = [2,4,6,8,10,12]

l2=[3,6,9,12]

l3=[ i for i in l1 if i in l2] print(l3)

#讲列表中的所有元素都打印出来

l1 = [1,3,5,7,9]

[print(i) for i in l1]

for item in range(len(l1)): print(l1[item])

循环嵌套

l=[[1,2,3],[4,5,6],[7,8,9]]

for i in l:

for j in i:

print(j)

===============================================

l=[[1,2,3],[4,5,6],[7,8,9]]

for i in range(len(l)):

for j in range(len(l[i])):

print(l[i][j])

###使用列表推导式 完成

[[ print(j) for j in i ] for i in l ]

字典

字典中的键必须是唯一不能重复的,字典中的键必须是不可变类型

字典操作