标签：10 name Python res 知识 语法 msg print hello
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')
标签：10,name,Python,res,知识,语法,msg,print,hello 来源： https://www.cnblogs.com/xionghuan01/p/16638786.html
本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享； 2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关； 3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关； 4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除； 5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。