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')