(二)python基础超全总结

本文详细介绍了Python中的数据类型,包括编码(ASCII, Unicode, GBK, UTF-8)、整型(int)、字符串(str)、布尔(bool)、数据类型转换、列表(list)、元组(tuple)、集合(set)和字典(dict)。讲解了这些类型的特点、操作以及相互转换。还探讨了编码与乱码问题,以及字符串的格式化输出。此外,提供了大量练习题,帮助读者巩固知识。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

一、 编码

计算机会将中文内存为01010101的组合,最终存储到硬盘上。
计算机中会有很多编码,如 utf-8, gbk等

  • 编码必须要保证:保存与打开一致,否则会出现乱码
  • 默认python解释器是以UTF-8的编码形式打开文件。
  • 如果想要修改python的默认编码,可以通过 # -*- coding:gbk -*-,但是一定要保持编码与打开形式一致。
    在这里插入图片描述

乱码的原因:

  • 文件的存储与打开方式不一致
  • 数据丢失

1.1 ascii 编码

ascii规定使用1个字节来表示字母与二进制的对应关系,ascii码只有 2**8个数据

1.2 unicode 编码

unicode称为万国码,为全球的每个文字都分配一个码位(二进制)

  • Ucs2:用固定的2个字节表示一个文字
  • Ucs4:用固定的4个字节表示一个文字
    缺点:Ucs2与 Ucs4浪费空间
    一般在文件存储或者网络传输不会使用unicode编码,而在内存中会使用unicode,便于做计算

1.3 gbk 编码

GB2312是国家制定的汉字编码标准,使用双子节进行编码,共收入6763个汉字和682个非汉字图形字符。GBK即对国标编码的扩展,在GB2312的基础上进行扩展形成的,使用双子节编码方式,共收入21003个汉字,从而大大满足了汉字使用的需要。

1.4 UTF-8编码

本质上:uft-8是对unicode的压缩,用尽量少的二进制与文字进行对应,全球应用最为广泛的一种编码

二、输出

  • 默认print在尾部会加换行符
print("看着风景美如画")
print("本想吟诗走天下")


输出:
看着风景美如画
本想吟诗走天下        
  • 如果想要不换行
print("看着风景美如画",end="")
print("本想吟诗走天下",end="")

输出:看着风景美如画本想吟诗走天下
print("看着风景美如画",end=",")
print("本想吟诗走天下",end=".")

输出:看着风景美如画,本想吟诗走天下.

三、数据类型

3.1 整形 int

十进制整数的统称,如1,99,888,编办表示年龄、序号

3.1.1 定义

number = 10
age = 10

3.1.2 独有功能(不重要)

int num1 =10
print(bin(num1))   # 0b1010
#bit_length返回的是二进制有多少位
print(num1.bit_length)  # 4

3.1.3 公共功能

加减乘除

3.1.4 数据转换

一般是str 与 bool 转整型

## str转int
v1 = int("186",base=10)  #把字符串看成是10进制的值,然后进行转换,结果是186
v2 = int("0b1001",base=2)  #把字符串看成是2进制的值,然后进行转换,结果是9
v3= int("0o144",base=8)  #把字符串看成是8进制的值,然后进行转换,结果是100
v4= int("0x59",base=16)  #把字符串看成是16进制的值,然后进行转换,结果是89


## bool转换int
int (True)  #1
int (False)  #0

3.1.5 其他

  • 长整型(long) python2中存在;python3中int长度无限制
  • 地板除
#py3
v1=9/2 # 4.5
#py2
v1=9/2 # 4

##
from _future_import division
v1=9/2 # 4.5

3.2 字符串 str

3.2.1 定义

#单行字符串
print ("aaaaaaaaaaaa")
print ('aaaaaaaaaaaa')
print ("aaa'a'aaaaaaaa")
print ('aaaaaa"a"aaaaa')

#多行字符串
print ("""aaaaaaaaaaaa
			dddddddd
			vvvvvvvv""")

3.2.2 独有功能(18/48)

"xxxxxx".功能(...)
  • 1.判断字符串是否以xx开头,得到布尔值
v1 = "章子怡是汪峰的妻子"
result = v1.startwith("章子怡")
print(result)   #True
##案例
v1 = input("请输入地址")
if v1.startswith("北京市"):
    print("北京户口")
else:
    print("非北京户口")
  • 2.判断是否以XXX结尾,得到布尔值
v1 = "章子怡是汪峰的妻子"
result = v1.endwith("妻子")
print(result)   #True
##案例
v1 = input("请输入地址")
if v1.startswith("村"):
    print("农村户口")
else:
    print("非农村户口")
  • 3.判断字符串是否是十进制?得到布尔值
v1 = "12345"
result = v1.isdecimal()
print(result)
v2 = input("请输入值:")
v3 = input("请输入值:")
if v2.isdecimal() and v3.isdecimal():
    print(int(v2)+int(v3))
else:
    print('请输入正确数字')

v3.isdigit() 与 v3.isdecimal() 的区别

  • v3.isdigit() 任何序号如“1”,“①”等都可以判断为True;而v3.isdecimal()只可以将十进制数判断为“True”
  • 4 .去除字符串两边的空格、换行符、制表符,得到一个新的字符串 (排除空格、换行符、制表符对程序处理的影响)
msg = "  h e l l o,runrun   "
print(msg.strip())
print(msg.lstrip())
print(msg.rstrip())


'''
##结果:
“h e l l o,runrun”
“h e l l o,runrun   ”
“  h e l l o,runrun”
'''
code = input("请输入验证码")
if code.strip()=="Fb08":
    print("验证码正确")
else:
    print("错误!")

补充:去除字符串两边的指定的内容

msg = " h e l l o,runrun"
print(msg.strip("un"))
#结果:
#“ h e l l o,runr”
  • 5 .将原来的字符串变成大写/小写,得到一个新的字符串,不改变原来的字符串
msg = "My name is runrun"
print(msg.upper())

msg = "My name is runrun"
print(msg.lower())
##
# "MY NAME IS RUNRUN"
code = input("请输入验证码")
value=code.strip() 
data=code.upper()
if data=="FB08":
    print("验证码正确")
else:
    print("错误!")
    
'''
注:
code 值"  Fb08 "
value 值"Fb08"
data 值"FB08"
'''
   
  • 6 .字符串内容替换,得到一个新的字符串
msg = "你很好,但是不适合我"
print(msg.replace("好","优秀"))
'''
result:你很优秀,但是不适合我
'''
content = input("请输入您的评论")
content1=content.replace("cnm","***")
content2=content1.replace("sb","***")
print(content2)

'''
结果:
请输入您的评论 sb,cnm,你真棒
 ***,***,你真棒
 注:
content  "sb,cnm,你真棒"
content1  "sb,***,你真棒"
content2  "***,***,你真棒"
'''
  • 7 .字符串的切割
data = "runrun|Central South university|Hunan|Changsha"
result= data.split("|")
print(result)

"""
结果:['runrun', 'Central South university', 'Hunan', 'Changsha']
注:
如果没有指定根据什么来切割,默认为按照空格切割
"""
info="runrun,CSUer"
list = info.split(",")
name = input("请输入名字")
psw = input("请输入属性")
if name == list[0] and psw == list[1] :
    print("认证成功")
else:
    print("认证失败")
"""
扩展:
默认是从左切割
新功能: 从右切割
		限定切割数目
"""
file_path = "xxx/xxxx/xxx.xxx.mp4"
print(file_path.rsplit(".",1))
print(file_path.split("/",1))


"""
结果
['xxx/xxxx/xxx.xxx', 'mp4']
['xxx', 'xxxx/xxx.xxx.mp4']
"""
  • 8 .字符串的拼接,得到一个新的字符串
data_list = ["runrun","is","a","Chinese"]
v1 = "__".join(data_list)
print(v1)

'''
结果:runrun__is__a__Chinese
'''
  • 9 . 格式化字符串,得到新的字符串
data = "{name} 喜欢很多动物,如{pet1},{pet2}"
data2=data.format(name = "runrun" , pet1="dog", pet2="cat")
print(data)
print(data2)
'''
结果:
{name} 喜欢很多动物,如{pet1},{pet2}
runrun 喜欢很多动物,如dog,cat
'''
  • 10 .字符串转换成字节类型
data = "子润"   # unicode 字符串类型
v1 = data.encode("utf-8")  #utf-8 字节类型
v2 =data.encode("gbk")  #gbk 字节类型
print(v1)
print(v2)
s1 = v1.decode("utf-8")
s2 = v2.decode("gbk")
print(s1)
print(s2)


'''
b'\xe5\xad\x90\xe6\xb6\xa6'
b'\xd7\xd3\xc8\xf3'
子润
子润
'''
  • 11 . 将字符串内容居中,居左,居右显示
v1 = "runrun"
v2=v1.center(20,"*")
v3=v1.ljust(20,"-")
v4=v1.rjust(20,"-")
print(v2)
print(v3)
print(v4)


'''
*******runrun*******
runrun--------------
--------------runrun
'''
  • 12 . 帮助填充0 (zfill有点类似于rjust)
    多应用与处理二进制数据
data = "101"
v1 = data.zfill(8)
print(v1)


'''
00000101
'''

3.2.3 公共功能

  • 1 . 加: 两个字符串拼接
print"I am "+"the best"
  • 2 . :整形和字符串相乘,使字符串重复出现N次并拼接起来
print (3*"加油")
  • 3 . 长度
data = "runrun"
length = len(data)
print(length)  #6
  • 4 . 获取字符串中的字符,索引 :
data = "runrun"
print(data[0])  #r
print(data[1])  #u
print(data[2])  #n
print(data[-1])  #n

注:字符串中只能通过索引来取值,无法修改值(字符串在内部存储的时候不允许对内部元素进行修改)

  • 5 . 获取字符串中的子序列、切片
    前取后不取
msg="I am  the best"
print(msg[0:4])  #I am
print(msg[2:])  #am  the best
print(msg[:4])  #I am

注:切片中只能取值,无法修改值

  • 6 . 步长,跳着取字符串的内容
name = "生活不是电影,生活比电影苦"
print(name[0:5:2]) # 输出:生不电[前两个值表示区间范围,最后一个表示步长]
print(name[8:1:-1]) # 输出:活生,影电是不  [倒序]
#面试题:给你一个字符串,请将这个字符串翻转
name = "生活不是电影,生活比电影苦"
value = name[::-1]
print(value)
  • 7 . 循环

while 循环

name = "生活不是电影,生活比电影苦"
index = 0
while index < len(name):
    print(name[index])
    index += 1

For循环

name = "生活不是电影,生活比电影苦"
for item in name:
    print(item)

Range:帮助我们生成一系列数字

range(10) #[0,1,2,3,4,5,6,7,8,9]
range(1,10) #[1,2,3,4,5,6,7,8,9]
range(1,10,2) #[1,3,5,7,9]

For+Range

name = "生活不是电影,生活比电影苦"
for i in range(len(name)):
	print(name[i])

一般应用场景

  • while:一般在做无限制(未知)循环此处时使用 while True:
  • for:一般应用在已知的循环数量的场景

3.2.4 其他

  • 字符串不可修改,列表可以修改

3.3 布尔类型(bool)

共有两个值:True/False

3.3.1 定义

data = False
runrun _nb = True

3.3.2 独有功能

3.3.3 公共功能

加减乘除 (没什么意义)

3.3.4 数据转换(重要)

都可以转换成布尔类型

注:只有整数0,空字符串,空字典,空列表 ,None转换成bool为False ;其他皆为True

3.3.5 其他

  • 作条件自动转换

如果在if 、while条件中写一个值作为条件的话,他会默认为布尔类型,然后再做条件判断

if 888:
	print("发财了") 
else:
	print("999")

#结果为 发财了

3.4 数据类型转换

想转换成什么,则只需要让他包括一下

3.4.1 转换成整形
#字符串转换成整型
int"66"int"99""6" + "9"    #它的结果应该是 " 69 "
int("6") + int("9") #的结果应该是 15
int"湖南长沙"#报错



# 布尔转化为int
int(True)  #转换成1
int(False)   #转换成0
3.4.2 转换成字符串
# int 转成str
str345str345+str(678)   #结果为'345678'


# bool 转成str
str(True)    #结果为 "True"
3.4.3 转换成布尔

#整形转换成布尔
bool(1)  #True
bool(0)  #False
bool(-10)  #True


#字符串转换成布尔
bool('alex')  #True
bool('')  #False
bool(' ')  #True

  1. 其他所有类型转换成布尔类型的,除了空字符串,0,其他的都是True
  2. 字符串转换成整型,只有那种‘998’的字符串才可以转换成整型,其他的都报错
  3. 想要转换成那种类型,用它包裹一下就可以

注:

  1. int 与 str 的差:str 需用print输出的时候需要加上引号 ,而 int 不用
  2. 如果有小黄色波浪,则通过菜单code-reformat code来进行调整

3.5 基本数据类型练习题一

  • 1 . 现有v1=123和v2=456,请将这两个值转换为二进制,并将其二进制中的前缀0b去掉,然后将两个二进制拼接起来,最终再转换为整型(十进制)
v1 = 123
v2 = 456
str1 = bin(v1)
new_str1 = str1.lstrip("0b")
str2 = bin(v2)
new_str2 = str2.lstrip("0b")
all_str = new_str1 + new_str2
result = int(all_str, base=2)
print(result)  #63432
  • 2 . 现有v1=123和v2=456,请将这两个值转换为二进制,并将其二进制中的前缀0b去掉,再补足为2个字节(16位):,然后将两个二进制拼接起来,最终再转换为整型(十进制)。
v1 = 123
v2 = 456
str1 = bin(v1)
new_str1 = str1.lstrip("0b")
str2 = bin(v2)
new_str2 = str2.lstrip("0b")
all_str = new_str1.zfill(16) + new_str2.zfill(16)
result = int(all_str,base=2)
print(result)   #8061384
  • 3 . 获取用户两次输入的内容,并提取其中的数字,实现数字的相加
    • 法1
msg1= input("请输入msg1")
rel1=""
rel2=""
for item in msg1:
    if item.isdecimal():
        rel1=rel1+item

msg2= input("请输入msg2")
for item in msg2:
    if item.isdecimal():
        rel2=rel2+item

all=int(rel1)+int(rel2)
print(all)
  • 法2
list1=[]
list2=[]
msg1= input("请输入msg1")
msg2= input("请输入msg2")
for item in msg1:
    if item.isdecimal():
        list1.append(item)
for item in msg2:
    if item.isdecimal():
        list2.append(item)
num="".join(list1)
num2="".join(list2)
print(int(num)+int(num2))

3.6 列表(list)

列表是一个有序可变容器,可以存放多个不同类型的元素

3.6.1 定义

user_list=[1,"runrun",True]
  • 不可变类型:字符串,布尔,整型(已最小,内部无法进行修改)
  • 可变类型:列表,元组,字典(内部元素可以修改)

3.6.2 独有功能

  • 1.插入 【list.insert(v1[0],“jie”)】
name_list=[]
while True:
    name=input("请输入您的姓名,输入Q/q退出")
    if name.upper()=="Q":
        break
    elif name=="小猫咪":
        name_list.insert(0,name)
    else:
        name_list.append(name)
print(name_list)

注: 如果输入的索引不在列表的现有的索引之内,则若索引值<0,将其插入到首位;若索引值>0,将其插入到尾部;

  • 2.在原列表中根据值删除(从左到右找到第一个删除【慎用,如果没有的话,就会报错】)【list.remove(“cat”)】
import random
data_list=["dog","cat","bird"]
while data_list:
   name = input("请输入您的姓名")
   value = random.choice(data_list)
   print("恭喜{}得到一只{}".format(name,value))
   data_list.remove(value)
print("小动物没有了")

'''
请输入您的姓名r
恭喜r得到一只cat
请输入您的姓名j
恭喜j得到一只bird
请输入您的姓名z
恭喜z得到一只dog
小动物没有了
'''
  • 3.在原列表中根据索引删除【data_list.pop(1)】
data_list=["dog","cat","bird","warm","duck","hen","cow"]
item = data_list.pop(1)  #item是剔除的那个值,“cat”
print(data_list)
  • 4.追加:尾部追加值【list.append(v1)】
#案例1
user_list=[]
while True:
    user=input("请输入用户名,输入Q退出")
    if user=="Q":
        break
    user_list.append(user)
print(user_list)
#案例2

user_list=[]
print("-----------欢迎参加NB游戏-----------")
num = input("请输入游戏人数")
while True:
    if num.isdecimal():
        for i in range(int(num)):
            user_list.append(input("请输入玩家姓名({}/{})".format(i+1,num)))
        print(user_list)
        break

    else:
        print("输入错误,请重新输入")
        num = num = input("请输入游戏人数")

  • 5 . 批量追加(将列表中的元素注意添加到另一个列表)
user=["run","jie","zhe"]
pets=["dog","cat","bird"]
for item in user:
    new_list=pets.append(item)
print(pets)
print(new_list)



'''
['dog', 'cat', 'bird', 'run', 'jie', 'zhe']
None

注:列表变换直接在原列表变换,不产生新的列表,故后者输出为None
'''
user=["run","jie","zhe"]
pets=["dog","cat","bird"]
user.extend(pets)
print(user)


"""
['run', 'jie', 'zhe', 'dog', 'cat', 'bird']
"""
  • 6 .清空原列表
data_list=["dog","cat","bird","warm","duck","hen","cow"]
data_list.clear()
print(data_list)
  • 7 . 根据值获取索引(从左到右找到第一个)【找不到报错】
data_list=["dog","cat","bird","warm","duck","hen","cow"]
index = data_list.index("cat")
print(index)  #  1
  • 8 . 根据列表内容排序(直接改变原列表)
## 整数排序
data_list=[1,33,55,2,7,45,56]
data_list.sort()
print(data_list)
data_list.sort(reverse=True)
print(data_list)

'''
[1, 2, 7, 33, 45, 55, 56]
[56, 55, 45, 33, 7, 2, 1]
'''
data_list=["dog","cat","bird","warm","duck","hen","cow"]
data_list.sort()
print(data_list)
data_list.sort(reverse=True)
print(data_list)

'''
['bird', 'cat', 'cow', 'dog', 'duck', 'hen', 'warm']
['warm', 'hen', 'duck', 'dog', 'cow', 'cat', 'bird']
'''

##将字符串转换成unicode 16进制的码点
data="王"
va=ord(data)
print(hex(va))     #0x738b
  • 字符串的排序:将字符串根据unicode的码点进行排序
  • 如果列表存在int和str则会报错,只能同类型之间继续比较
  • 9 . 列表的翻转
data_list=["dog","cat","bird","warm","duck","hen","cow"]
data_list.reverse()
print(data_list)

'''
['cow', 'hen', 'duck', 'warm', 'bird', 'cat', 'dog']
'''

3.6.2 公共功能

    1. 相加

data_list=["dog","cat","bird"]
data_list2=["warm","duck","hen","cow"]
print(data_list+data_list2)

'''
['dog', 'cat', 'bird', 'warm', 'duck', 'hen', 'cow']
'''
    1. 相乘
data_list=["dog","cat","bird"]
print(data_list*2)


'''
['dog', 'cat', 'bird', 'dog', 'cat', 'bird']
'''
    1. 运算符in包含
data_list=["dog","cat","bird","warm","duck","hen","cow"]
if "dog" in data_list:
    print("Yes!Remove it!")
    data_list.remove("dog")
else:
    print("no")
print(data_list)

'''
Yes!Remove it!
['cat', 'bird', 'warm', 'duck', 'hen', 'cow']

'''

注:列表检查元素是否存在,是采用逐一比较的方式,效率会比较低,可以用集合或者字典

    1. 获取长度
data_list=["dog","cat","bird","warm","duck","hen","cow"]
print(len(data_list))  #7
    1. 索引

data_list=["dog","cat","bird","warm","duck","hen","cow"]
print(data_list[0])  # 读取
data_list[0] ="runrun"  #修改
print(data_list) 
del data_list[0]   # 删除
print(data_list)


'''
dog
['runrun', 'cat', 'bird', 'warm', 'duck', 'hen', 'cow']
['cat', 'bird', 'warm', 'duck', 'hen', 'cow']
`
'''

注:

  1. 字符串只能进行读取,不能做删除修改操作
  2. 超出索引范围就会报错
    1. 切片

读取

data_list=["dog","cat","bird","warm","duck","hen","cow"]
print(data_list[2:4])
print(data_list[:4])
print(data_list[2:])

'''
['bird', 'warm']
['dog', 'cat', 'bird', 'warm']
['bird', 'warm', 'duck', 'hen', 'cow']
'''

修改

data_list=["dog","cat","bird","warm","duck","hen","cow"]
data_list[2:4]=[11,22,33]
print(data_list)
data_list=["dog","cat","bird","warm","duck","hen","cow"]
data_list[2:]=[11,22,33,44,55]
print(data_list)
data_list=["dog","cat","bird","warm","duck","hen","cow"]
data_list[:4]=[11,22,33,55]
print(data_list)

'''
['dog', 'cat', 11, 22, 33, 'duck', 'hen', 'cow']
['dog', 'cat', 11, 22, 33, 44, 55]
[11, 22, 33, 55, 'duck', 'hen', 'cow']
'''

删除

data_list=["dog","cat","bird","warm","duck","hen","cow"]
del data_list[0:3]
print(data_list)

'''
['warm', 'duck', 'hen', 'cow']
'''
    1. 步长
#实现列表的翻转
data_list=["dog","cat","bird","warm","duck","hen","cow"]
new_data_list = data_list[::-1]
print(new_data_list)

new_data_list=data_list.reverse()
'''
['cow', 'hen', 'duck', 'warm', 'bird', 'cat', 'dog']
'''

注意:.reverse() 只能应用于列表的翻转,不能应用于字符串的翻转,字符串只能通过步长或者for循环

    1. for循环
data_list=["dog","cat","bird","warm","duck","hen","cow"]
for item in data_list:
    print(item)

for index  in range(len(data_list)):
    print(data_list[index])

for index in range(len(data_list)):
    print(data_list[len(data_list)-index-1])  #倒序输出

注意:
1 . 千万不要在循环的过程中,边循环列表,边删除列表的数据。

#错误示范
data_list=["run","zhe ","runrun","ruang","huang"]
for item in data_list:
    if item.startswith("r"):
        data_list.remove(item)

print(data_list)

'''
['zhe ', 'ruang', 'huang']
'''
# 正确的方式:倒着处理
data_list=["run","zhe ","runrun","ruang","huang"]
for index in range(len(data_list)-1,-1,-1):
    item = data_list[index]
    if item.startswith("r"):
        data_list.remove(item)

print(data_list)

'''
['zhe ', 'huang']
'''

3.6.4 转换

  • int、bool 无法转换成列表
  • str
name= "runrun"
data = list(name)
print(data)

'''
['r', 'u', 'n', 'r', 'u', 'n']
'''
  • 元组:元组转换成列表的意义在于,元组不可以进行修改,故转换成列表可以修改
data = ("dog","cat","bird","warm","duck","hen","cow")
new_list = list(data)
print(new_list)

'''
['dog', 'cat', 'bird', 'warm', 'duck', 'hen', 'cow']
'''
  • 集合
data = {"dog","cat","bird","warm","duck","hen","cow"}
new_list = list(data)
print(new_list)

3.6.5 嵌套

data = [ "谢广 坤"["海燕" , "赵本山”],True, [11,22,33,44],"宋小宝”]

print( data[0] ) #“谢广坤“

print( data[1] ) # ["海燕”,” 赵本山"]
print( data[0][2] ) #“坤"

print( data[1][-1] ) #“赵本山”

data . append(666)

print(data) # [“谢广坤",[“海燕",”赵本山”],True, [11,22,33,44],“宋小宝”,666]

data[1]. append( "谢大脚")

print(data) # [“谢广 坤”,[“海燕","赵本山”,“谢大脚"] , True,[11,22,33,44],“宋小宝",666 ]

del data[-2]

print(data) # [“谢广 坤",[“海燕","赵本山”,“谢大脚"] , True,[11,22,33,44],666 ]

data[-2][1] = "alex"

print(data) # [ "谢广 坤",["海燕" ,“赵本山”,"谢大脚"],True,[11,"alex" ,33,44],666 ]

data[1][0:2] = [999,666]

print(data) # [ "谢广 坤",[999, 666,"谢大脚" ], True,[11,"alex" ,33,44],666 ]

3.6.6练习

user_list=[]
while True:
    user = input("请输入您的用户名:(按Q/q退出程序)")
    if user.upper() =="Q":
        break
    else:
        psw = input("请输入您的密码")
        user_list.append([user,psw])

print("程序结束")
print(user_list)
  1. 写代码实现以下功能
    如有变量goods = [汽车;飞机:火箭]提示用户可供选择的商品:[0,汽车,1,飞机,2,火箭] 用户输入索引后,将指定商品的内容拼接打印,如:用户输入0,则打印您选择的商品是汽车。

goods= ["汽车","飞机","火箭"]
index = input("请输入所需物品索引值,0:汽车,1:飞机,2:火箭")
chioce = goods[int(index)]
print("您选择的商品是{n1}".format(n1=chioce))
  1. 利用for循环和range 找出0 ~ 50以内能被3整除的数,并追加到一个列表/将新数值追加到列表前。
nums=[]
for i in range(50):
    if i%3==0:
        nums.append(i)
print(nums)
  1. 査找列表li中的元素,移除每个元素的空格,并找出以"a"开头,并添加到一个新列表中,最后循坏打印这个新列表 li =[“alexC”, “AbC “, “egon”, " riTiAn”, “WuSir”, " aqc”]
new_li=[]
li = ["alexC", "AbC ", "egon", " riTiAn", "WuSir", " aqc"]
for index in range(len(li)):
    li[index] = li[index].strip()
print(li)
for item in li:
    if item.startswith("a"):
        new_li.append(item)
print(new_li)
print("修改结束")
for item in new_li:
    print(item)
new_li=[]
li = ["alexC", "AbC ", "egon", " riTiAn", "WuSir", " aqc"]
for index in range(len(li)):
    li[index] = li[index].strip()
    if li[index].startswith("a"):
        new_li.append(li[index])
print(new_li)
print("修改结束")
for item in new_li:
    print(item)

3.7 元组

列表,是一个有序且可变的容器,里边可以存放多个不同类型的元素
元组是一个有序且不可变的容器,里边可以存放多个不同类型的元素

如何体现不可变?
“我儿子不能是别人,但是我儿子可以长大”

3.7.1定义

注:建议在元组的最后多加一个逗号,用于标识他是一个元组

user_list=(1,"runrun",True,)
面试题
1. 比较v1=(1),v2=1,v3=(1,)有什么区别
2. 比较值v1=((1),(2),(3))与v2=((1,),(2,),(3,))有什么区别

答:
3. v1=1 (int)  v1=1(int)  ,v3=(1,) (tuple)
4. v1=(1,2,3) (1层元组) ,v2=((1,),(2,),(3,)) (2层元组)

3.7.2独有功能

【无】

3.7.3公共功能

与list基本一致

  • 翻转:因为tuple不能修改,所以只能新建一个tuple进行翻转
# 元组
li = ("alexC", "AbC ", "egon", " riTiAn", "WuSir", " aqc",)
data = li[::-1]


# 列表(两种方法)
#法1
li = ["alexC", "AbC ", "egon", " riTiAn", "WuSir", " aqc"]
data = li[::-1]
#法2
li = ["alexC", "AbC ", "egon", " riTiAn", "WuSir", " aqc"]
li.reverse()

3.7.4 转换

其他类型转化成元组,使用tuple(其他类型),目前只有字符串和列表可以转换成元组

3.7.4 嵌套

类似于list
元组的元素不能变化,但是如果元组中含有列表,列表的元素可以变化

data = ("123" ,666,[11,22,33], ("alex" ,"run" ,[999,666,(5,6,7)],) )

# 1.将"123" 替换成9   报错
# 2.将[11,22,33] 换成“武沛齐"    报错
# 3.将11换成99

data[2]10] = 99
print (data)
#  ("123" ,666,[99,22,33], ("alex" ,"run" ,[999,666,(5,6,7)],) )
# 4.在列表11,22,331 追加一个44

data[2]. append(44)
print(data) 

# ("123" ,666,[11,22,33,44], ("alex","run" ,[999,666,(5,6,7)],))

3.8 集合(set)

集合是一个无序、可变、不允许重复的容器,相当于一个不重复的list

3.8.1 定义

li = {"alexC", "AbC ", "egon", " riTiAn", "WuSir", " aqc"}
  • 无序,无法通过索引取值
  • 可变,可以添加和删除元素
# 添加
li = {"alexC", "AbC ", "egon", " riTiAn", "WuSir", " aqc"}
li.add(55)

#  55加在哪是不确定的
  • 不允许数据重复

一般什么时候使用集合呢?

  • 就是想维护一大堆不重复的数据时,就可以使用它。比如:用爬虫去网上找图片的链接,为避免链接重复,可以使用集合取存储地址。

注:

  • 定义空集合时,只能使用v = set() ,不能使用v = () ( 这样是定义一个空字典)
v1 = []
v11 = list()

v2 = ()
v22 = tuple()

v3 = set()

v4 = {}   #空字典
v44 = dict{}

3.8.2 独有功能

  1. 添加元素
data = {"alexC", "AbC ", "egon", " riTiAn"}
data.add("run")
print(data)

'''
{'run', 'AbC ', 'alexC', 'egon', ' riTiAn'}
'''
data = set()
data.add("run")
print(data)
  1. 删除元素
data = {"alexC", "AbC ", "egon", " riTiAn"}
data.discard("alexC")
print(data)

'''
{' riTiAn', 'AbC ', 'egon'}
'''
  1. 交集
data = {"alexC", "AbC ", "egon", " riTiAn"}
data2 = {"huang","run","zhe", "AbC "," riTiAn"}
s = data & data2  #方法1
s2 = data.intersection(data2)  #方法2
print(s)

'''
{' riTiAn', 'AbC '}
'''
  1. 并集
data = {"alexC", "AbC ", "egon", " riTiAn"}
data2 = {"huang","run","zhe", "AbC "," riTiAn"}
s = data | data2  #方法1
s2 = data.union(data2)  #方法2
print(s)

'''
{'alexC', 'run', 'zhe', 'AbC ', 'egon', ' riTiAn', 'huang'}
'''
  1. 差集
data = {"alexC", "AbC ", "egon", " riTiAn"}
data2 = {"huang","run","zhe", "AbC "," riTiAn"}
s = data - data2   #方法1   data中有且data2中没有的值
s2 = data.different(data2)   #方法2
print(s)
print(s2)

'''
{'alexC', 'egon'}
'''

3.8.3 公共功能

无切片,步长,索引功能

    1. 长度
data2 = {"huang","run","zhe", "AbC "," riTiAn"}
print(len(data2))
    1. for循环
      不可以通过索引,因为集合里的元素是无序的
data2 = {"huang","run","zhe", "AbC "," riTiAn"}
for item in data2:
    print(item)

3.8.4 转化

其他类型如果想要转换成集合类型,可以通过set进行转换,并且如果数据有重复自动剔除

int/list/tuple/dict 都可以转化成集合

3.8.5 其他

    1. 集合的存储原理
      在这里插入图片描述
    1. 元素必须可哈希:即内部通过哈希函数把值转换成一个数字
    • 目前可哈希的数据类型:int ,str , tuple , bool ; 而set ,list 是不可哈希的
    • 故:集合额元素只能是 int ,str , tuple , bool
    1. 查找速度特别快 (数据量大的时候才明显)
data2 = {"huang","run","zhe", "AbC "," riTiAn"}
if "run" in data2:
    print("Yes")
else:
    print("no")
    1. 对比与嵌套
      在这里插入图片描述
    • 嵌套要注意,嵌套的子子孙孙元素都必须可哈希,故一定不可包含set ,list
    • 由于True 与False 本质上都是1,0, 而集合又不允许重复,所以在整数0,1 与True False同时出现会出现以下情况
v1 = {1, True}
print(v1)

v2 = {True,1}
print(v2)

v3 = {0,False}
print(v3)

v4 = {False,0}
print(v4)


'''
{1}
{True}
{0}
{False}
'''

3.9 字典

字典是无序键不重复元素只能是键值对可变容器

  • 容器
  • 元素必须是键值对
  • 键不重复,重复会覆盖
  • 无序 (py3.6之后字典是有序,之前的是无序)

3.9.1 定义

v1 = {}
v2 = dict()


info ={
    "age":12,
    "statue":True,
    "name":"runrun",
    "hobby":"soccer"
}

字典中对键的要求

  • 键:必须可哈希,目前学到的可哈希的类型:int,bool,tuple,str 不可哈希:set,list,dict
  • 值:可以为任意值
dic = {
    1:89,
    True:3
}
print(dic)

#  {1,3}

什么情况才使用字典呢?

  • 但我们想表示一组固定信息的时候,可以用字典

3.9.2 独有功能

  1. 获取值
info ={
    "age":12,
    "statue":True,
    "name":"runrun",
    "hobby":"soccer"
}


data = info.get("name")
data2 = info.get("class")
data3 = info.get("class",123)

print(data)
print(data2)
print(data3)


'''
runrun
None
123
'''
1. 若字典中键不存在,返回None
2. info.get("class",123) ,写成这种形式,如果键存在,返回键的值,如果键不存在,返回123
3. 可以利用 1或者2  来判断键是否存在
info ={
    "runrun":"qwe",
    "jie":"zxc",
    "zhe":"asd",
}
user = input("请输入您的用户名")
if info.get(user):
    print("用户名存在于系统中")
psw = input("请输入您的密码")
password = info.get(psw)
if password==psw:
    print("success")
else:
    print("Fail")

  1. 所有的键
v2 = dict()
info ={
    "age":12,
    "statue":True,
    "name":"runrun",
    "hobby":"soccer"
}

data = info.keys()   #得到的不是一个列表,而是一个高仿的列表,可以将其转化成列表
print(data)
print(list(data))


'''
dict_keys(['age', 'statue', 'name', 'hobby'])
['age', 'statue', 'name', 'hobby']
'''
  1. 所有的值
v2 = dict()
info ={
    "age":12,
    "statue":True,
    "name":"runrun",
    "hobby":"soccer"
}

data = info.values()   #py2得到的是一个列表,py3是一个高仿的列表,可以将其转化成列表
print(data)
print(list(data))


'''
dict_values([12, True, 'runrun', 'soccer'])
[12, True, 'runrun', 'soccer']
'''
  1. 所有的键值
v2 = dict()
info ={
    "age":12,
    "statue":True,
    "name":"runrun",
    "hobby":"soccer"
}

data = info.items()
print(data)

'''
输出是元组
dict_items([('age', 12), ('statue', True), ('name', 'runrun'), ('hobby', 'soccer')])
'''
v2 = dict()
info ={
    "age":12,
    "statue":True,
    "name":"runrun",
    "hobby":"soccer"
}

for item in info.items():
    print(item)
    print(item[0],item[1])

'''
item 在此是一个元组 (键,值)
'''
for key,values in info.items():
    print(key)
    print(values)
'''
相当于直接将元组拆成了key, values
'''
  1. 设置值 (对字典元素的新增功能)

info ={
    "age":12,
    "statue":True,
    "name":"runrun",
    "hobby":"soccer"
}


info.setdefault("age",17)
print(info)
info.setdefault("class","aasd")
print(info)

如果是原来就存在键值对,则通过setdefault()不能对原有键值对进行修改

  1. 更新字典键值对
info ={
    "age":12,
    "statue":True,
    "name":"runrun",
    "hobby":"soccer"
}


info.update({"age":17,"class":"aasd"})
print(info)

'''
{'age': 17, 'statue': True, 'name': 'runrun', 'hobby': 'soccer', 'class': 'aasd'}
'''
更新键值对
- info中没有的直接添加
- info中有的则更新键值
  1. 移除指定键值对
info ={
    "age":12,
    "statue":True,
    "name":"runrun",
    "hobby":"soccer"
}

data = info.pop("age")
print(info)
print(data)  #可以获取移除的值
  1. 按照顺序移除 (后进先出)
info ={
    "age":12,
    "statue":True,
    "name":"runrun",
    "hobby":"soccer"
}

info.popitem()
print(info)   #{'age': 12, 'statue': True, 'name': 'runrun'}

 py3.6+ 移除后边的
 py3.6前 移除随意位置的

3.9.3 公共功能

    1. 并集(py3.9+)
info ={
    "age":12, "statue":True }

info2 = { "age":17, "hobby":"soccer"}
info3 = info|info2
print(info3)
    1. 获取长度
info ={ "age":12, "statue":True }
print(len(info))  #2
    1. 运算符in包含
info ={
    "age":12,
    "statue":True,
    "name":"runrun",
    "hobby":"soccer"
}

v1 = "age" in info   #默认判断是否在键中,等价于v2
print(v1)   #True

v2 = "age" in info.keys()
print(v2)   #True

v3 = "runrun" in info.values()
print(v3)   #True

v4 = ("age" ,12) in info.items()
print(v4)   #True
    1. 索引 (键)

字典不同于元组和列表,字典的索引是键,而列表和元组则是0、1、2等数值



info ={
    "age":12,
    "statue":True,
    "name":"runrun",
    "hobby":"soccer"
}

print (info["age"])
print(info["xxx"])    #若键不存在,会报错

value = info.get("age")   #若键不存在,不会报错 ,None
    1. 根据键 修改值 、添加值 、 删除键值对

修改

info ={
    "age":12,
    "statue":True,
    "name":"runrun",
    "hobby":"soccer"
}

info["age"] =17    #字典中存在,则直接修改
print(info)

添加

info ={
    "age":12,
    "statue":True,
    "name":"runrun",
    "hobby":"soccer"
}

info["class"] ="sf"   #字典中不存在,则直接添加
print(info)

删除

info ={
    "age":12,
    "statue":True,
    "name":"runrun",
    "hobby":"soccer"
}

del info["age"]  #删除字典中键为“age”的那个键值对,如果不存在则报错
data = info.pop("age")  #删除字典中键为“age”的那个键值对,如果不存在则报错,但此种方法可以返回删除的值
print(info)
    1. for循环
info ={
    "age":12,
    "statue":True,
    "name":"runrun",
    "hobby":"soccer"
}

for item in info():   #所有的键,等价于3
    pass
for item in info.items():
    pass
for keys in info.keys():
    pass
for value in info.values():
    pass
for keys,values in info.items():
    pass

3.9.4 转换 (用的比较少)

info ={
    "age":12,
    "statue":True,
    "name":"runrun",
    "hobby":"soccer"
}

v1 = list(info.keys())
v2 = tuple(info.values())
v3 = set(info)
print(v1)
print(v2)
print(v3)

3.9.5 其他

    1. 存储原理
      在这里插入图片描述
    1. 速度快 (原理同tuple)
info ={
    "age":12,
    "statue":True,
    "name":"runrun",
    "hobby":"soccer"
}

if "age" in info:
    pass
v1 = info.get("name")
print(v1)
    1. 嵌套
  • 字典的键必须可哈希(list/set/dict 不可哈希)
  • 字典的值可以是任意类型,但如果值是必须可哈希的类型(set/dict),那么其嵌套内容也必须可哈希
  • 字典的键和集合的元素在遇到 布尔值和0、1 需要注意重复的情况
  • 元组的元素不可以被替换
  • 4.练习
dic = {
    'name': '汪峰',
    'age': 48,
    'wife': [{'name': '国际章', 'age': 38}, {' name': '李杰', 'age': 48}],
    'children': ['第一个娃', '第二个娃', ]}

1.获取汪峰的妻子名字
2.获取汪峰的孩子们
3.获取汪峰的第一个孩子
4.汪峰的媳妇姓名变更为章子怡
5.汪峰再娶一名妻子,名字为阿章
6.给汪峰添加一个爱好:吹牛逼
7.删除汪峰的年龄
dic = {
    'name': '汪峰',
    'age': 48,
    'wife': [{'name': '国际章', 'age': 38}, {'name': '李杰', 'age': 48}],
    'children': ['第一个娃', '第二个娃']}
#1
li1 = dic.get("wife")
for index in range(len(li1)):
    print(li1[index]["name"])
#2
li2 = dic.get("children")
for index in range(len(li2)):
    print(li2[index])
#3
child1 = dic.get("children")[0]
print(child1)
#4
dic.get("wife")[0]["name"]="章子怡"
print(dic["wife"])
#5
dic.get("wife").append({"name":"阿章"})
print(dic["wife"])
#6
dic["hobby"]="吹牛"
print(dic)
#7
del dic["age"]
print(dic)

3.10 float(浮点)

  • 在类型转化时,浮点型转换成整型,会将小数部分去掉
  • 想要保留小数位后N位
v1 = 3.1415926
v2 = round(v1,4)   #四舍五入
print(v2)
  • 浮点型的坑
    在这里插入图片描述
    如果想要精确的值

import decimal
v1 = decimal.Decimal("0.1")
v2 = decimal.Decimal("0.2")
print(v1+v2)

3.11 None

None 表示空,一定程度可以节省内存

v1 = None
v2 = None

...
v1 = {"run","zhe"}
v2 = 3

3.12 阶段练习

1.根据需求写代码

dic = {'k1': "v1","k2": "v2", "k3": [11,22,33]}
#请在字典中添加一一个键值对,"k4”: "v4", 输出添加后的字典
#请在修改字典中“k1" 对应的值为"alex", 输出修改后的字典
#请在k3对应的值中追加一个元素44,输出修改后的字典
#请在k3对应的值的第1个位置插入个元素18, 输出修改后的字典
dic = {'k1': "v1","k2": "v2", "k3": [11,22,33]}

dic["k4"]="v4"
print(dic)
dic["k1"]="alex"
print(dic)
dic["k3"].append(44)
print(dic)
dic["k3"].insert(1,18)
print(dic)

2.根据需求写代码.

dic1 = {
    'name': ['alex', 2, 3, 5],
    'job': 'teacher',
    'oldboy': {'alex': ['pythonl', 'python2', 100]}
}

# 1,将name对应的列表追加一个元素' wusir'.
# 2,将name对应的列表中的alex首字母大写。
# 3, oldboy对应的字典加一个键值对'老男孩’,'linux'。
# 4,将oldboy对应的字典中的alex对应的列表中的python2删除

dic1 = {
    'name': ['alex', 2, 3, 5],
    'job': 'teacher',
    'oldboy': {'alex': ['pythonl', 'python2', 100]}
}

dic1["name"].append("Wusir")
new_name = dic1["name"][0].capitalize()
dic1["name"][0]=new_name
dic1["oldboy"]["老男孩"]="linux"
del dic1['oldboy']["alex"][1]
print(dic1)

3.循环提示用户输入,并将输入内容添加到字典中(如果输入N或n则停止循环)

例如:用户输入x1 |wupeiqi ,则需要再字典中添加键值对{’ x1’ : “wupeiqi” }

new_dic={}
while True:
    str = input("请输入内容  格式:x1|runrun  (N/n停止)")
    if str.upper()=="N":
        break
    li1 = str.split("|")
    new_dic[li1[0]]=li1[1]
print(new_dic)

4.将字典的键和值分别追加到key. list和value, list两个列表中,如:

key_list=[]
value_list=[]
info={'k1':'v1','k2':'v2','k3':'v3'}
key_list=[]
value_list=[]
info={'k1':'v1','k2':'v2','k3':'v3'}
for key,value in info.items():
    key_list.append(key)
    value_list.append(value)
print(key_list)
print(value_list)

5.字典dic= {k1: “V1”, “k2”:“Vv2", “k3”: [1,2,33]}

a.请循环输出所有的key
b.请循环输出所有的value
c.请循环输出所有的key和value
d.请在字典中添加一个键值对,"k4": “v4", 输出添加后的字典
e.请在修改字典中"k1" 对应的值为"alex",输出修改后的字典
f.请在k3对应的值中追加一个元素44, 输出修改后的字典
g.请在k3对应的值的第1个位置插入个元素18, 输出修改后的字典
dic= {"k1": "V1", "k2":"v2", "k3": [1,2,33]}
for item in dic.keys():
    print(item)
for item in dic.values():
    print(item)
for key,value in dic.items():
    print(key,value)
dic["k4"]="v4"
print(dic)
dic["k1"]="alex"
print(dic)
dic["k3"].append(44)
print(dic)
dic["k3"].insert(1,18)
print(dic)

6.请循环打印k2对应的值中的每个元素。

info={
‘k1’:‘v1’,
‘k2’:[(‘alex’),(‘wupeiqi’ ),(‘oldboy’)],}

info={
'k1':'v1',
'k2':[('alex'),('wupeiqi' ),('oldboy')],}

for item in info['k2']:
    print(item)

7.有字符串"k: 1|k1:2|k2:3 |k3 :4"处理成字典{“k”:1,“k1”:2…}

dic={}
str1 = "k: 1|k1:2|k2:3 |k3 :4"
li = str1.split("|")
for i in range(len(li)):
    li2 = li[i].split(":")
    dic[li2[0]]=int(li2[1].strip())
print(dic)

8.写代码

有如下值li= [11,22,33,44,55,66,77,88,99,90] ,将所有大于66的值保存至字典的第1个key对应的列表中,将小于66的值保存至第二个key对应的列表中。
result = {'k1':[],'k2':[]}
result = {"k1":[],"k2":[]}
li= [11,22,33,44,55,66,77,88,99,90]
for item in li:
    if item > 66:
        result["k1"].append(item)
    else:
        result["k2"].append(item)
print(result)
商品列表:

goods = [
    {"name": "电脑", "price": 1999},
    {"name": "鼠标", "price": 10},
    {"name": "美女", "price": 998},
    {"name": "游艇", "price": 20},
]
要求:

1:页面显示序号+商晶名称+商品价格,如:
	1 电脑 1999
	2 鼠标 10
2:用户输入选择的商品序号,然后打印商品名称及商品价格
3:如果用户输入的商品序号有误,则提示输入有误,并重新输入。
4:用户输入Q或者q,退出程序。

goods = [
    {"name": "电脑", "price": 1999},
    {"name": "鼠标", "price": 10},
    {"name": "美女", "price": 998},
    {"name": "游艇", "price": 20},
]
for index in range(len(goods)):
    text1 = str(index + 1) + " " + goods[index]["name"] + " " + str(goods[index]["price"])
    print(text1)
while True:
    str1 = input("请输入您所选择的商品ID(Q/q退出)")
    if str1.upper() == "Q":
        break
    if str1.isdecimal():
        id_ = int(str1)
        if id_ <= 0 or id_ > len(goods):
            print("输入的商品序号有误,请重新输入")
            continue
        name = goods[id_-1]["name"]
        price = goods[id_-1]["price"]
        print(name, price)

四、变量

格式:【变量名=值】,之后可以通过变量名来错做对应的值

4.1 变量名的规范

  • 变量名只能包括字母、数字、下划线
  • 不能以数字开头
  • 不能使用python的内置关键字

4.1 变量内存指向关系

name1 = "wupeiqi"
name2 = "alex"

在这里插入图片描述

name1 = "wupeiqi"
name2 = name1

在这里插入图片描述

name1 = "wupeiqi"
name2 = name1
name1 = "alex"

在这里插入图片描述

num =18
name = str(num)

在这里插入图片描述

五、输入

实现用户与程序的交互

name= input("请输入用户名:")
if  name =="alxe"
	print("OK")
else :
	print("NO")

注意:用户输入的任何内容本质上都是字符串

例:

提示输入姓名/位置/行为,然后拼接xx在xx 做xx

name = input("请输入名字")
location = input("请输入地点")
action = input ("在干啥")

text = name + location + action  
print(text)

六、条件语句

if 条件:
	xxxxx
else:
	xxxxx

注:注意缩进问题,否则程序会报错,一般用4个空格,可以用‘tab’键

6.1基本条件语句

  • 例1 :
print("开始")
if True:
	print("123")
else:	
	print("456")
print('结束')

6.2 多条件判断

if 条件A:
	xxx
elif 条件B:
	xxxx
elif 条件C:
	xxx
else :
	xxxx
  • 例:
num = input("请输入一个数字")
data = int(num)
if data > 90:
	print("优秀")
elif 90 > data > 80:
	print("良好")
else : 
	print("差")

6.3 条件嵌套

if 条件A:
	if  条件B:
		xxx
	else :
		xxx
else :
	xxx

七 循环语句

7.1 While 循环

while 条件:
	xxx
	xxx
	xxx
  • 例:重复3次输出 我爱我的祖国
num = 1
while num <= 3:
    print("我爱我的祖国")
    num = num + 1

7.2 break

break 用户while循环中终止循环

while True:
	print ("1")
	break
	print("2")
print ("3")

##
#输出结果为:
#1
#3
msg = "生活不是电影"
for char in msg:
	if char=="不":
		break
	print(char)
	
		
"""
生
活
"""		
print("开始")

while True:
    user = input("请输入你的用户名")
    password = input("请输入您的密码")
    if user == "wupeiqi" and password == "uuu":
        print ("登陆成功")
        break
    else :
        print("登陆失败")

7.3 continue

continue 用来在循环中结束本次循环,开始下次循环(回到while首)

while True:
	print("1")
	continue
	print("2")
print("结束")
# 输出
1
1
1
1
...
msg = "生活不是电影"
for char in msg:
	if char=="不":
		continue
	print(char)
		
"""
生
活
是
电
影
"""		
num = 1
while True:
    if num <=4:
        if num ==2:
            num = num+1
            continue
        print(num)
        num = num+1
    else:
        break
# 输出
1
3
4

7.4 while else(很少用)

while 条件:
	xxx
else:
	xxxx

练习题

name=input("please input your name!")
password = input ('please input your password')
if name == "wupeiqi" and password == 'uuu':
    print('Success!')
else :
    print('Fail to login in ')
num = input("请输入一个数字:")
num = int(num)   #注意此处一定要将num换成整型,否则不可比较
if num > 10:
    print("Right")
else :
    print('Wrong')
num = input("请输入一个数字:")
num = int(num)
if num %2 ==0:
    print("偶偶偶数")
else :
    print("奇奇奇数")

在这里插入图片描述

  • 1
num = 66
flag = True
while flag:
    input_num = input("请输入数字:")
    if int(input_num) == num:
        print("输入正确!")
        flag = False
    elif int(input_num) > num:
        print(" 输入数字偏大!")
    elif int(input_num) < num :
        print("输入数字偏小!")
    else :
        print("错误!")
  • 2
num =1
while num <=100:
    print(num)
    num = num+1
  • 3
num = 1
while num <=10:
    if num !=7:
        print(num)
    num = num + 1

## 或者
num = 1
while num <=10:
    if num ==7:
    	pass   #什么都不做
    else:
        print(num)
    num = num + 1

  • 5
num =1
while num<=100:
    if num % 2 ==0:
        print(num)
    num=num+1
  • 6
num = 1
sum_num = 1
while num < 100:
    num = num+1
    sum_num = sum_num+num
print(sum_num)

用户登录案例

用户登录系统,反复让用户输入账户密码,知道输入正确才停止

  • 方法1
user = input("请输入你的用户名")
password = input("亲输入您的密码")

while user != "wupeiqi" or password != "uuu":
    print("登录失败")
    user = input("请输入你的用户名")
    password = input("请输入您的密码")

print ("登陆成功")
  • 方法2
print("开始")
flag = True
while flag:
    user = input("请输入你的用户名")
    password = input("请输入您的密码")
    if user == "wupeiqi" and password == "uuu":
        print ("登陆成功")
        flag = False
    else :
        print("登陆失败")

八 字符串格式化

使用更加边界的形式实现字符串的拼接

8.1 %

8.1.1 基本格式化操作

  • 法1
name = "runrun"
year = 18
text = "我是%s,今年%d岁"% (name,year)
print(text)
  • 法2
name = "runrun"
year = 18
text = "我是%(name)s,今年%(year)d岁"% {"name":name,"year":year}
print(text)

结:字符串 %s , 整型 % d

8.1.2 百分比

一旦字符串格式化的过程中出现百分比的情况,一定要加上 %% 以实现输出%

name = "runrun"
year = 18
text = "我是%s,已经完成了90%%的作业了" %(name)
print(text)

#输出
#我是runrun,已经完成了90%的作业了

8.2 format

name = "runrun"
year = 18
text = "我是{0},今年{1}岁".format(name,year)
print(text)

text2 = "我是{},今年{}岁".format(name,year)
print(text2)

text3 = "我是{n1},今年{n2}岁".format(n1=name,n2=year)
print(text3)

8.3 f

python 3.6版本,更便捷

name = "runrun"
year = 18
text = f"我是{name},今年{year}岁"
print(text)
  • 进制转化
text = f"我今年{18:#b}岁"  #二进制
print(text)
text2 = f"我今年{18:#o}岁" #8进制
print(text2)
text3 = f"我今年{18:#x}岁"  #16进制
print(text3)
输出:
我今年0b10010岁
我今年0o22岁
我今年0x12岁

九 运算符

9.1 算数运算

在这里插入图片描述

9.2 比较运算

在这里插入图片描述

9.3 赋值运算

在这里插入图片描述

9.4 逻辑运算

在这里插入图片描述

9.5 成员运算

在这里插入图片描述

可用于检测用户输入的话中有无敏感词

v1 ='章子怡是汪峰的妻子'
if "章子怡"  in v1:
    print("从句话包含敏感词")
else:
    print (v1)

9.6 算数优先级

  • 算数优先级 大于 比较优先级
  • 比较优先级 大于 逻辑运算符
  • 逻辑运算符内部:not > and > or

结: 加减乘除 > 比较 > not >and >or
实在拿不准,加括号

9.7 运算符的面试题

  • 逻辑运算中的:and or
v1 = "a" and "b"
# 1.将字符串转换成bool,True and True
# 2.判断本次操作取决与谁,由于前边的是True,故本溪逻辑判断取决于后边的值
#3. 结果为"b"


v2 = "" and "b"
#结果为""

v3 = " " and "b"
#结果为"b"

v4 = 1 or 8
# 1.将字符串转换成bool,True or True
# 2.判断本次操作取决与谁,由于前边的是True,故本次逻辑判断取决于前边的值
#3. 结果为1


v4 = 0 or 8
# 1.将字符串转换成bool,False or True
# 2.判断本次操作取决与谁,由于前边的是False,故本次逻辑判断取决于后边的值
#3. 结果为8

练习题

在这里插入图片描述

结果:
1.  1、-1、-1、100、10、wupeiqi
2. 8、0、88、、、、0
  • or 看第一个值,如果第一个值是真,结果为第一个值,否则为第二个值
  • and 看第一个值,如果第一个值为真,结果为第二个值,否则为第一个值

在这里插入图片描述

先计算and ,再计算or
结果:
1.  0 or 3 or 7 or 6 = 3
2.  8 or 4 or 0 or 7 = 8
3.  0 or 4 or 0 or 3 = 4

注释的快捷键:ctrl + ?

作业

在这里插入图片描述

  • 1
1 . False or True or False and True and True or False 
    =False or True or False or False  = True
2 . False  and  True  or  False and True and True or False
    =False or False  or False
    =False
  • 2
1 .  = 8 or 4 or 0 or 7 = 8
2 .  = 0 or 4 or 0 or 3 = 4 
  • 4
num = 1
while num <=3:
    user = input("请输入您的账户")
    password = input("请输入您的密码")
    if user=="runrun" and password =="1234":
        print("登陆成功")
        break
    else:
        print("登陆失败,您还有{}次登陆机会".format(3-num))
    num += 1
  • 5
num =66
i=1
while  i <= 3:
    input_num = input("请输入一个数字:")
    if int(input_num) == num:
        print("猜对了")
        break
    else:
        print("猜错了")
    i += 1
  • 6
num = 66
i =1
while True:
    input_num  = input("请输入一个数字")
    if int(input_num) == num:
        print("猜对了")
        break
    else:
        print("猜错了")
    i += 1
    if i == 4:
        answer = input("请问您还想继续吗?请输入N or Y")
        if answer=="N":
            break
        else:
        	print("结束!")
            i=1
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值