3、python基础语法知识
3.1变量
1.什么是变量？
可以变化的量
2.为什么要有变量？
程序去执行一种状态，并且是可以变化的
1.变量的使用
原则：先定义，后使用
name='hello' #定义
print(name) #使用
2.变量的内存管理
申请的变量不用就要释放
内存管理：垃圾回收机制
垃圾：没有变量名的值
引用计数：同一个值可以关联不同的变量名
引用计数增加：
x=10 #10的引用计数为1
y=x #10的引用计数为1
z=x #10的引用计数为1
引用计数减少：
x=10 #10的引用计数为1
y=x #10的引用计数为1
z=x #10的引用计数为1
del x #解除变量名x与值10的绑定关系，10的引用计数为2
del y #解除变量名y与值10的绑定关系，10的引用计数为1
z=12346 #z会解除与10的关联
print(z)
3.变量名的命名
原则：见名知意
命名规范：
变量名只能是字母，数字或者下划线的任意组合
变量名的第一个字符不能是字符
关键字不能声明为变量名
变量名的命名风格：
1.驼峰命名法
AgeOfAlex=30
2.纯小写加下划线的方法(python推荐使用这种方式)
age_of_alex=30
4.变量值
变量值的三个重要的特征
id：反映的是变量值的内存地址，内存地址不同，id不同
print(id(name))
type：数据类型
print(type(name))
value：值本身，等号右边的值
is与==
is:比较左右两个值身份id是否相等
==:比较左右两个值他们的值是否相等
注意：
值一样的情况下，id的值也不一样
id相同的情况下，值一定相同
注意：
小整数池:[-5,256]从Python解释器启动的那一刻开始，就会在内存中事先申请好一系列的内存空间来存放常用的整数
>>> m=10
>>> n=10
>>> m is n
True
>>> id(m),id(n)
(2423951786512, 2423951786512)
>>> x='aaa'
>>> y='bbb'
>>> id(x),id(y)
(2423953409264, 2423953414576)
# 垃圾回收机制
# 1.引用计数
# 1.1 直接引用
# x= 10
# print(id(x))
# 1.2 间接引用
# l=['a', x]
# print(id(l[1])) # id 地址都是相同的
# 列表在内存中开辟一个区域来存索引与内存地址，一个内存地址指向真正所存的
# x= 10
# l=['a','b', x] # l=['a的内存地址','b的内存地址','x的内存地址']
# x = 123
# x的值是变的，但是x的内存地址是不会变的
# 2.标记清除
# 循环引用
# 在循环引用的使用下，把l1,l2的直接引用去掉，没有直接访问的可能性，彼此只剩间接使用，引用计数不为0，此时他们成为了永远不能回收的垃圾，此时就叫内存泄露
l1 = [111]
l2 = [222]l1.append(l2)
# l1=['111的内存地址','l2的内存地址']
l2.append(l1)
# l2=['222的内存地址','l1的内存地址']print(id(l1))print(id(l2[0]))
# 3.分代回收
# 分代回收就是根据存活时间为变量划分不同的等级，然后对引用计数进行计算来回收
3.2常量
常量:不变的量
注意：在Python中没有常量的概念，但是在程序开发的过程中会涉及到常量的概念比如:π 一个人的年龄在某种情况下是常量
常量的表示：小写的字母全部为大写，代表常量
AGE_OF_A = 12 # 可以修改，但是最好不要修改
3.3数据类型
一、数字类型
1.整形int作用：记录年龄，身份证号码，个数等定义：age=18
2.浮点型float作用：记录薪资，身高，体重
3.数字类型的其他使用
做数学运算level = 1x = level + 1整数是可以和浮点型进行相加的
# 1.int类型
# 定义
# age = 10 # age = int(10)
# 纯数字转化为int
# res = int('1212')
# 了解:
# 十进制=》二进制
# print(bin(20)) # 0b表示是二进制
# 二进制=》十进制
# print(int('0b1001',2))
# 十进制=》八进制
# print(oct(11)) # 0o表示八进制
# 八进制转十进制
# print(int('0o12',8))
# 十进制=》十六进制
# print(hex(12)) # 0x开头表示十六进制
# 十六进制=》十进制
# print(int('0xb',16))
# 2.浮点型float的定义
# salary=3000.3 # 本质salary=float(3000.3)
# 注意：名字+括号的意思就是调用某个功能，比如
# print(...)调用打印功能
# int(...)调用创建整型数据的功能
# float(...)调用创建浮点型数据的功能
# float同样可以用来做数据类型的转换
# s = '12.3'
# res=float(s)
# (12.3, <class 'float'>)
二、字符串类型
作用：描述类型性质的状态，比如名字，一段话
定义：用引号(“”,”,”’ ”’,””” “””)包含的一串字符 延迟满足
name = ‘upup’
x= 18 x是整形
x = ’18’ x是字符串
# 作用:定义描述性质的状态
# 定义:
# msg = 'hello'
# 类型转换:str可以把任意类型都转成字符串
# res=str({'k1':12})
# print(res,type(res))
# 内置方法
# 1.优先掌握
# 1.1 按索引取值(正向取+反向取),只能取
# 正向取
# msg ='hello baby' # 空格也算字符
# print(msg[3])
# print(msg[6])
# 反向取
# msg ='hello baby' # 空格也算字符
# print(msg[-3])
# print(msg[-6])
# 只能取,不能改
# msg ='hello baby' # 空格也算字符
# msg[0]='H'
# print(msg[0])
# 1.2 切片：索引的扩展应用，从一个大字符串中拷贝一个小字符串
# msg ='hello baby'
# res = msg[0:5] # 顾头不顾尾
# print(res)
# 1.3步长
# 不写步长，默认步长为1
# msg ='hello baby'
# res=msg[0:5:2] # 0,2,4
# print(res)
# 反向步长
# msg = 'hello baby'
# res = msg[5:0:-1]
# print(res)
# msg = 'hello baby'
# res = msg[0:11]
# res = msg[:] # 与上面的效果是一样的
# print(res)
# 倒着取 把字符串倒着取过来
# res = msg[::-1]
# 1.4长度len
# msg = 'hello baby'
# print(len(msg))
# 1.5成员运算 in 或者not in
# 判断一个子字符串是否存在于一个大字符串中
# res='hello' in 'hello baby'
# print(res)
# 1.6移除字符串左右两侧的符号strip
# msg = ' hello '
# res=msg.strip() # 不传参数，默认去掉空格
# print(res) # 产生了新的值
# msg = '***hello***'
# print(msg.strip('*')) # 默认去掉*号
# 了解：strip只去两边，不去中间
# msg = 'h***h**'
# print(msg.strip('*'))
# msg = '**/*=-**hello*-=()**'
# print(msg.strip('*/-=()')) # 两边的符号可以完全去掉
# 应用
# uname=input('name:').strip()
# upwd=input('pwd:').strip()
# if uname=='hello' and upwd=='123':
# print('okok')
# else:
# print('error')
# 1.7切分split
# 把某一个字符串按照某种分隔符进行切分，得到一个列表
# info = "hello 18 baby"
# res=info.split() # 不传参数默认按照空格进行分割
# print(res) # 得到一个列表
# 指定分隔符
# info = "hello:18baby"
# res=info.split(':')
# print(res)
# 指定分割次数 了解
# info = "hello:18:baby"
# res=info.split(':',1)
# print(res)
# 1.8循环
# info = "hello:18:baby"
# for k in info:
# print(k)
# 2.需要掌握
# 2.1 strip lstrip(去左边的符号) rstrip(去右边的符号)
# 2.2 lower upper
# msg='asdfg'
# print(msg.upper())
# 2.3 startswitch endswitch 判断以什么开头与结尾的 返回的是布尔值
# msg = 'hello baby'
# res =msg.startswith('hello')
# print(res)
# 2.4format 的三种方式
# 3.str.format 字符串格式化 兼容性好
# 按照位置传值
# res = "我的名字是 {},我的年龄是 {}" .format('hello','19')
# print(res)
# res = "我的名字是 {0}{0}{0},我的年龄是 {1}" .format('hello','19')
# print(res)
# 打破位置限制，按照key=value传值
# res = "我的名字是{name},我的年纪是{age}".format(age=18,name="hello")
# print(res)
# 4.f:python3.5以后才支持这种格式
# x=input('name')
# y=input('age')
# res = f"我的名字是{x},我的年龄是{y}"
# print(res)
# 2.5split(从左往右开始切) rsplit(从右往左开始切)
# info = "hello:18:baby"
# res=info.split(':',1)
# res = info.rsplit(':',1)
# print(res)
# 2.6 join 把列表拼接成字符串
# l= ['name','12','hhhh']
# res=':'.join(l) # 按照某个分隔符，把纯字符串的列表拼接成一个大字符串 注意：必须全部都是字符串
# print(res)
# 2.7 replace 替换
# msg = 'hello baby'
# res=msg.replace('hello','hi',1) # 后面的数字表示替换几次
# print(res)
# 2.8isdigit
# 判断字符串是否是由数字组成
# res='123'.isdigit()
# print(res)
# 3 了解
# 3.1 find rfind index count
# msg='hello baby hhh'
# res=msg.find('e') # 返回要查找的字符串在大字符串中返回的起始索引，找不到返回-1
# res=msg.index('e') # 返回要找的起始索引，找不到就会抛出异常
# res=msg.count('h') # 统计要返回的次数
# print(res)
# 3.2 center ljust rjust zfill
# msg='hello'
# res = msg.center(10,'*') # 返回10个字符串，不够就用*号来补在左右两边
# res = msg.rjust(10,'*') # 在右边进行填充
# res = msg.ljust(10,'*') # 在左边进行填充
# res=msg.zfill(10) # 用0填充，默认右填充
# print(res)
# 3.3expandtabs
# msg='hello/tbaby'
# res=msg.expandtabs(4) # 设置制表符代表的空格数为4
# print(res)
# 3.4 capitalize swapcase title
# msg = 'hello baby'
# res=msg.capitalize() # 首字母大写
# res = msg.swapcase() # 大小写反转
# res = msg.title() # 每个单词的首字母大写
# print(res)
# 3.5 is数字系列
# 3.5.1 is其他
# print('abc'.islower())
# print('abc'.isupper())
# print('hello baby'.istitle()) # 每个单词的首字母大写
# print('123m'.isalnum()) # 是否是字母或数字组成
# print('123'.isalpha()) # 是否由字母组成
# print(' '.isspace()) # 字符串由空格组成结果为True
# print('def'.isidentifier()) # 是否是由Python的内置方法
num1=b'4' # bytes
num2=u'4' # Unicode 在Python3中无需加Unicode
num3='四' # 中文数字
num4='IV' # 罗马数字
# isdigit只能识别num1，num2
#isnumberic
#能识别num2，num3,num4
#isdecimal 能识别num2 几乎不用
三、列表类型
索引对应值，索引从0开始，0代表第一个值
作用：按位置记录多个值，并且可以安装索引取出的值
注意：列表中存放的数据大部分都是同一个性质
定义：在[]内用逗号分隔开多个任意类型的值，一个值称之为一个元素
# l = [10, 2, 'aaa', ['bbb', 'ccc'], 'ddd']
# print(l)
# print(l[3])
# print(l[3][1]) # 列表的嵌套取值
# print(l[-2][1])
# 其他的用途
student_info =[ ['Andy', 18, ['play']],
['Helen', 20, ['swim', 'sleep']]]
# 取出第二个学生的第一个爱好
print(student_info[1][2][0])
# 作用:按位置用来存多个值
# 定义:
# l=[1,2,3]
# print(type[l])
# 类型转换:能够被for循环遍历的类型都可以被当成参数传给list转成列表
# res=list('hello')
# print(res)
# 相似的还有字典
# 内置方法
# 1.优先掌握的方法
# 1.1 正向取,反向取
# l=[111,'hello','haha']
# print(l[0])
# print(l[-1])
# 可以取也可以改
# l[0]=222 # 索引存在则修改所对应的值
# 索引不存在就不能对他赋值，否则就会报错
# 往列表里面加值
# print(l)
# l=[111,'hello','haha']
# 追加值
# l.append(333) # 这个会往列表的末尾加
# 插入值
# l.insert(1,'wawa') # 这个是插入值
# print(l)
#往列表中添加列表
# l=[1,2,3]
# new_l=['12','34']
# l.extend(new_l)
# print(l)
# 1.2切片(顾头不顾尾，步长)
# l = [111,'hello','waha']
# print(l[0:3])
# print(l[0:5:2]) # 0 2 4
# 切完整的l列表
# print(l[0:len(l)])
# print(l[:])
# print(l[::-1]) # 把列表给倒过来
# 切片就是copy行为，相当于浅拷贝
# new_l = l[:]
# 1.3 长度
# print(len([1,2,3]))
# 1.3成员运算in 和not in
# print('aaa' in ['asd',222])
# 1.5删除
# 方式一 公用的删除，没有返回值 不支持赋值语法
# l = [111,'hello','waha']
# del # 删除整体
# del l[1]
# print(l)
# 方式二 列表相关的删除
# l.pop 有返回值,返回的是删除的元素
# l = [111,'hello','waha']
# l.pop()# 不指定索引默认删除最后一个
# l.pop(1) # 选择删除索引为1的元素
# 方式三
# l.remove 根据元素删除 返回值是None
# l = [111,'hello','waha']
# l.remove('hello')
# 1.6循环
# for x in ['ac',222,'cv']:
# print(x)
# 2.需要掌握
# 2.1
四、字典类型dict
key对应值，其中key通常为字符串类型，所以key对值有描述性
索引反应的是位置，对值没有描述的作用
作用：用来存多个值，每个值都有唯一一个key与其对应
定义：用花括号{}来表示,在括号内分开多个key:value value可以是任意类型(int float str list dict) 但是key必须是不可变类型 d = {‘a’:1,’b’:2}
# d = {'a':1, 'b':2}# print(d)
# print(type(d))
# 字典的其他用法: 嵌套取值
students_info = [
{'name1':'a', 'age1':18, 'gender':'male'},
{'name2':'b', 'age2':19, 'gender':'male'},
{'name3':'c', 'age3':30, 'gender':'male'}
]
print(students_info[1]['age2'])
五、布尔类型bool
作用:用来记录真假这两种状态的
# 定义:
# is_ok=True
# is_ok = False
# print(type(is_ok))
x = 1
y = 0
# 1和0也可以表示状态
print(type(y))
集合类型
# 1.作用
# 1.1 关系运算:取交集与并集
# f1={12,23,57,89,100}
# f2={23,12,78,100}
# l=[]
# for x in f1:
# if x in f2:
# l.append(x)
# print(l)
# 1.2 去重
'''
2.定义:在花括号{}内用逗号分隔开各个元素，元素满足一下三个条件：
1，元素为不可变类型
2.集合内元素为无序
3.集合内元素没有重复
'''
# # 注意
# s={} # 默认为空字典
# s=set() # 默认为空集合
# 3.类型转换 set()
# s=set({1,2,3})
# print(s)
# print(set({'k1':12,'k2':29,'k3':100})) # {'k1', 'k3', 'k2'}
# 4.内置方法
# f1={12,23,57,89,100}
# f2={23,12,78,100}
# 4.1 取交集 两者共同有的
# res=f1 & f2
# print(res)
# res = f1.intersection(f2)
# print(res)
# 4.2 取并集/合集 两者都有的
# res = f1 | f2
# print(res)
# print(f1.union(f2))
# 4.3 取差集 取第一个所独有的
# res=f1-f2
# print(res)
# print(f1.difference(f2))
# print(f2.difference(f1))
# 4.4 取对称差集 取两者独有的，即去掉共同有的
# 方式一:
# res=(f1-f2) | (f2-f1)
# print(res)
# 方式二:
# res=f1^f2
# print(res)
# print(f1.symmetric_difference(f2))
# 4.5 父子集:包含的关系
# f3={1,2,3}
# f4={1,2}
# print(f3>f4) # 当f1>f2时，f1为父，f2为子
# 如果 f1 = f2 的时候，f1与f2互为父子
# print(f3.issuperset(f4))
# print(f4.issubset(f3)) # f4 < f3
# 5.去重
# 5.1 只能针对不可变类型去重
# 5.2 无法保证原来的类型
# 对不需要去重，对顺序有要求的可以使用循环
# 6.其他操作
# 6.1 长度
# s={'a.txt','b','c'}
# print(len(s))
# 6.2 成员运算
# res = 'a.txt' in s
# print(res)
# 6.3 循环
# for x in s:
# print(x)
# 7 其他内置方法
# 7.1 discard 删除元素
# remove 也是删除一个元素，如果删除的元素不存在则会报错
# s={1,2,3,4,5}
# res = s.discard(1)
# res=s.discard(6)
# res = s.remove(4) # 会报错
# print(s)
# 更新 update
s={9,1,2,3,4,5}
# res=s.update({9,0})
# res=s.pop() # 去除掉第一个元素
# res=s.add(8)
# res=s.isdisjoint({3}) # 两个集合完全独立，没有共同部分，返回True
# print(res)
3.4与用户交互
# 接受用户的输入
# 在Python3中:input会将用户输入的所有的内存都存成字符串
username = input("请输入您的账号:")
print(username,type(username))
age = input("请输入您的年龄:")
print(age,type(age))
# age = int(age)
# int只能将纯数字的字符串转为整形# print(age,type(age))
# 在Python2中:有一个raw_input()与Python3的input一模一样
# 在Python2中的input必须要输入一个明确的数据类型
# 格式化输出
# 1.值按照位置与%s一一对应，多一个不行，少一个不行
# 缺点是要记位置，不方便
# res = "my name is %s,my age is %s"%('hello',"18")
# res = "my name is %s" % 'hello'# print(res)
# 2.以字典的形式传值，打破位置的限制
res = "我的名字是 %(name)s,我的年龄是 %(age)s" % {'age':'12','name':'hello'}
print(res)
# 注意:%s可以接受任意类型 %d只能接受int
# 3.str.format 字符串格式化 兼容性好
# 按照位置传值
res = "我的名字是 {},我的年龄是 {}" .format('hello','19')
print(res)# res = "我的名字是 {0}{0}{0},我的年龄是 {1}" .format('hello','19')
print(res)
# 打破位置限制，按照key=value传值
res = "我的名字是{name},我的年纪是{age}".format(age=18,name="hello")
print(res)
# 4.f:python3.5以后才支持这种格式
x=input('name')
y=input('age')
res = f"我的名字是{x},我的年龄是{y}"
print(res)
3.5运算符
1.算术运算符
print(1+1)
print(10 / 3) # 结果带小数
print(10 // 3) # 只保留整数部分
print(10 % 3) # 取模
2.比较运算符
返回的值是布尔值
print(10 > 3)
print(10 == 3)
print(10 <= 3)
name = input('name')
print(name=='hello')
3.赋值运算符
# 3.1增量赋值
# 年龄加1
age=18
age+=1
print(age)
# 3.2 链式赋值
x=10
y=x
z=y
x = y = z = 10 # 把上面的代码改写成这一行
# 3.3 交叉赋值
# m和n交换变量，先给一个临时变量
m=10
n=20
# temp = m
# m = n
# n = temp
# print(m)
# print(n)
m,n = n,m # 交叉赋值也可以用一行代码搞定
print(m)
print(n)
# 3.4解压赋值
# sal= [11,22,33,44,55]
# m0=sal[0]
# m1=sal[1]
# m2=sal[2]
# m3=sal[3]
# m4=sal[4]
# print(m0)
# print(m1)
# print(m2)
# print(m3)
# 更简单的做法，一行搞定 对应的变量名少一个不行，多一个不行
sal= [11,22,33,44,55]
m0,m1,m2,m3,m4,=sal
print(m0)
print(m1)
print(m2)
print(m3)
# 可以使用 *_ 来匹配所需要的值 下划线作为一个占位符
sal= [11,22,33,44,55]
x,y,z,*_=sal # 取前三个值
print(x,y,z)
*_,x,y,z=sal # 取后三个值
print(x,y,z)
x,y,*_,z # 取第一个值和第二个值，与最后一个值
print(x,y,z)
# 解压字典，默认解压出来的是字典的key
x,y,z=dict = {'a':1,'b':2,'c':3}
print(x,y,z)
4.逻辑运算符
会返回布尔值True或False
# 逻辑运算:用来判断
# not :就是把紧跟其后的那个条件结果取反
print(not 10 > 6)
print(not '')
# and 逻辑与 用来连接左右两个条件 全真为真,有一个条件为假，则结果为False
# print(True and 10 > 3)
# 偷懒原则:看到一个条件为假就不用继续算下去了，直接结果为假
# or 逻辑或 用来连接左右两个条件 全假为假，如果有一个条件为真，则结果为真
print(10 > 3 or 0)
# 也有偷懒原则：看到一个条件为真，直接结果为真
# 优先级 not > and > or
# 如果单独是一串and或者or 连接，就按照从左向右的顺序依次运算即可
# 如果是混用，就需要考虑优先级了
# 3 > 4 and not 4 > 3 or 1 ==3 and 'x'=='x' or 3 > 3
res= (3>4 and (not 4 > 3)) or (1==3 and 'x'=='x') or 3 > 3
print(bool(res))
5.成员运算符
# 5.成员运算符
# 5.1 in 判断一个子字符串是否存在于一定大字符串 第一种更好
print('happy' in 'happy new year')
print(111 in [111,222,333]) # 列表也算
print('k1' in {'k1':111,'k2':222}) # 字典是要用key值
# 5.2 not in 判断一个子字符串是否存在于一定大字符串 逻辑同 in 但语义不明确
print('happy' not in 'happy new year')
# 6.身份运算符
# is 判断的是id是否相等
3.6可变与不可变
# 可变与不可变类型
# 可变类型：值改变的情况下，id不变 证明改的是原值，原值是可以被改变的
# 不可变类型：值改变，id也改变了，证明是产生新的值，压根没有改变原值，原值是不可以被改变的
# int是不可变的类型
# float是不可变类型
# 字符串类型是不可变类型
# int float str 都被设计成了不可分割的整体，不能够被改变
# 列表 是可变类型 改变列表的值，整体是不会改变的，元素值的id会改变的
# l=['1','2','3']
# print(id(l))
# l[0]=['5']
# print(id(l))
# 字典 是可变类型 改变key的值，整体是不会改变的，元素值的id会改变的
dict = {'k1':1,'k2':2}
print(id(dict))
dict['k1']=[4]
print(id(dict))
# bool 不可变
# 什么可以当做条件？
# 1.显示布尔值
# 1.1条件可以是比较运算符
# age = 18
# print(age>18)
# 1.2条件可以是布尔值
# is_beautiful=True
# 2.隐式布尔值 所有的值都可以当做条件去使用
# 1，'aaa'
# 其中 空 0 None 为假 其余类型都为真
# abc= 1
# print(bool(abc))
3.7浅拷贝与深拷贝
# list1=['111','222','333']
# 二者分割不开，list1与list2指向的都是同一个地址
# lis2=list1 # 这个不是拷贝
# 需求:
# 1、拷贝一个原列表产生一个新的列表
# 2、想让两个列表完全独立开
# 如何copy列表
# 1.浅拷贝
# 浅拷贝：把原列表第一层内存地址完全copy一份给新列表
# list1 = [
# 'hello',
# 'bjt',
# [1,2,3]
# ]
#
# list2 = list1.copy()
# print(id(list1))
# print(id(list2))
# print(list2)
# print(list1)
# 2.深copy
# 想要copy得到的新列表和原列表的改操作完全独立开，必须要有一种可以区分可变类型与不可变类型的copy机制，这就是深copy
# 可变类型，重新开辟一个内存地址，但是内存地址里面所指的值并没有改变，全都指向原来的。不可变类型，还是用原来的地址。
import copy
list1 = [
'hello',
'bjt',
[1,2,3]
]
list2 = copy.deepcopy(list1)
# print(id(list1))
# print(id(list2))
print(id(list1[2]))
print(id(list2[2]))
3.8if判断语句
'''
写代码的时候要缩进四个空格
语法1：
if 条件:
代码1
代码3
代码3
'''
age = 12
name = 'abab'
if age==12 and name == 'abab' :
print('hjjjj')age = 12
print('我是其他代码')
'''
语法2:
if 条件:
代码1
代码2
代码3
else:
代码1
代码2
代码3
'''
age = 12
name = 'abab'
if age==11 and name == 'abab' :
print('我们是一样的')
else:
print('我们不一样')
'''
语法3:
if 条件:
代码1
代码2
代码3
elif 条件2:
代码1
代码2
代码3
elif 条件3:
代码1
代码2
代码3
`````
'''
score = input('请输入您的成绩:')
score=int(score)
if score >= 90:
print('优秀')
elif score >= 80:
print('良好')
elif score >= 70:
print('普通')
elif score >= 60:
print('及格')
elif score >= 0:
print('不及格')
'''
最完整的语法
语法3:
if 条件:
代码1
代码2
代码3
elif 条件2:
代码1
代码2
代码3
elif 条件3:
代码1
代码2
代码3
`````
else:
'''
score = input('请输入您的成绩:')
score=int(score)
if score >= 90:
print('优秀')
elif score >= 80:
print('良好')
elif score >= 70:
print('普通')
elif score >= 60:
print('及格')
else:
print('不及格')
# if 嵌套
age = 12
name = 'abab'
if age==12 and name == 'abab' :
print('我们是一样的')
is_sus=True
if is_sus:
print('happy!')
else:
print('我们不一样')
3.9while循环语句
while循环的语法及基本使用
'''
while 条件
代码1
代码2
代码3
运行步骤：
步骤1：如果条件为真，那么依次执行：代码1、代码2、代码3、......
步骤2：执行完毕后再次判断条件,如果条件为True则再次执行：代码1、代码2、代码3、......，如果条件为False,则循环终止
'''
count = 0
while count < 5:
print(count)
count+=1
print('hhh')
print('最后一行代码')
死循环与效率问题
# 输入输出会有一定的缓存时间，不会导致致命的效率问题
# count = 0
# while count < 5:
# print(count)
#
# while True: # 1 与True都一样，但是1的效率会比True快一些
# name=input('name:')
# print(name)
# 这个死循环会带来致命的效率问题。纯计算无io的死循环会导致致命的效率问题
# while True:
# 1+1
退出循环的两种方式
# 退出循环的两种方式
# 方式一:将条件改为false,等到下次循环判断条件时才会生效
# username = 'bjt'
# yourpwd = '123'
# tag = True
# while tag:
# name = input('请输入您的账号:')
# pwd = input('请输入您的密码:')
# if name == username and pwd == yourpwd:
# print('welcom')
# tag = False
# else:
# print('Error')
# print('hhhh')
# 方式二: 可以加一个break 终止循环 只要运行到break，就会立刻终止本层循环
username = 'bjt'
yourpwd = '123'
while True:
name = input('请输入您的账号:')
pwd = input('请输入您的密码:')
if name == username and pwd == yourpwd:
print('welcom')
break
else:
print('Error')
while循环应用
# 循环的应用
# username = 'bjt'
# yourpwd = '123'
# name = input('请输入您的账号:')
# pwd = input('请输入您的密码:')
# if name == username and pwd == yourpwd:
# print('welcom')
# else:
# print('Error')
# 优化代码，重复代码不可粘贴赋值来循环使用
username = 'bjt'
yourpwd = '123'
while True:
name = input('请输入您的账号:')
pwd = input('请输入您的密码:')
if name == username and pwd == yourpwd:
print('welcom')
else:
print('Error')
while循环嵌套
# while循环嵌套
'''
每一层都必须配一个break
while True:
while True:
while True:
break
break
break
'''
username = 'bjt'
yourpwd = '123'
while True:
name = input('请输入您的账号:')
pwd = input('请输入您的密码:')
if name == username and pwd == yourpwd:
print('welcom')
while True:
cmd = input('输入命名编号:')
if cmd == 'q':
break
print('{x}正在运行中'.format(x='cmd'))
break # 后面的代码都不会执行,立刻终止本层循环
else:
print('Error')
# 改变条件的方式
username = 'bjt'
yourpwd = '123'
tag = True
while tag:
name = input('请输入您的账号:')
pwd = input('请输入您的密码:')
if name == username and pwd == yourpwd:
print('welcom')
while tag:
cmd = input('输入命名编号:')
if cmd == 'q':
tag = False
else:
print('{x}正在运行中'.format(x=cmd))
else:
print('Error')
while与continue的使用
# while 与 continue的使用 结束本次循环，直接进入下一次循环
# 强调：在continue之后加同一行代码无意义，永远无法执行
count = 0
while count < 6:
if count == 4:
count+=1
continue
print(count)
count+=1
while+else的使用
# while + else
# else 包含的代码会在while循环结束后，没有被break打断的情况下，正常结束后才会运行
# count = 0
# while count<6:
# if count == 4:
# count+=1
# continue
# print(count)
# count+=1
# else:
# print('会在while循环结束后，没有被break打断的情况下，正常结束后才会运行')
# else不会运行
# count = 0
# while count<6:
# if count == 4:
# break
# print(count)
# count+=1
# else:
# print('会在while循环结束后，没有被break打断的情况下，正常结束后才会运行')
# else 是专门针对break的
# 案例 输错三次退出程序
username = 'bjt'
yourpwd = '123'
tag = True
count = 0
while tag: # count < 3也可以
if count == 3:
print('输入次数超过三次')
break
name = input('请输入您的账号:')
pwd = input('请输入您的密码:')
if name == username and pwd == yourpwd:
print('输入正确')
else:
print('账号密码错误')
count += 1
3.10 for循环
for循环是Python提供第二种循环机制
理论上for循环能做的事情上，while循环也可以做
for循环取值比while循环更简洁
如何使用for循环
# 如何使用for循环
'''
基本语法
for 变量名 in 可迭代对象:
代码1
代码2
代码3
···
可迭代对象可以是列表，字典，字符串，元组，集合
'''
**案例：**
```Python
# 案例 列表循环取值
# l=['aa','22','333']
# for x in l:
# print(x)
# l=['aa','22','333']
# i=0
# while i < 3:
# print(l[i])
# i+=1
# 字典循环取值
# dict = {'k1':11,'k2':22,'k3':33}
# for x in dict:
# print(x,dict[x])
# 字符串取值 空格也算
msg = 'have a good time'
for x in msg:
print(x)
总结for循环与while循环
# 总结 for 循环 与 while 循环
# 相同之处：都是循环，for循环能做的事，while循环也能做
# 不同之处：while循环称之为条件循环，循环次数取决于条件什么时候变为假
# for循环称之为取值循环，循环次数取决于in后面包含的值的个数
for循环:range()控制循环次数
# for循环控制循环次数:range()
# 有局限性
# for x in '1 2':
# print('循环我')# 会循环3次，空格也算
# range()功能介绍
'''
顾头不顾尾
range(10)
[0,1,2,3,4,5,6,7,8,9]
range(1,9)
[1,2,3,4,5,6,7,8]
range(1,9,1)
[1,2,3,4,5,6,7,8]
range(1,9,2)
[1,3,5,7]
'''
# for i in range(3):
# print('循环3次')
# for i in range(10):
# print('循环3次')
username = 'bjt'
yourpwd = '123'
for i in range(3):
name = input('请输入您的账号:')
pwd = input('请输入您的密码:')
if name==username and pwd == yourpwd:
print('输入正确')
break
else:
print('密码错误')
continue
print('错误次数超过三次')
# range()补充知识
# 1.可以按照索引取值 for循环可以按照range()索引取值，但是有点麻烦，不推荐
l = ['a','b','c','d']
for k in range(len(l)):
print(k,l[k])
# 2.range()在Python3里面得到的是一只会下鸡蛋的老母鸡
for i in range(10):
print(i)
for + continue
# for + continue
for i in range(6):
if i == 4:
continue
print(i)
for 循环嵌套
# for循环嵌套 外层循环执行一次，内层循环要全部执行玩
for i in range(3):
print('外层循环=====')
for j in range(5):
print('内层循环')
# 跳出for循环，只有break。结束本次，进入下一次只有continue
补充print()
# 补充：print()
# print()可以传多个值，逗号会表现为空格号 print()打印会自带一个换行符
print('hello/n',end='')
print('hi')
print('hello',end='')
print('hi')
原创文章，作者：ItWorker，如若转载，请注明出处：https://blog.ytso.com/283086.html