（二）python基础超全总结

最新推荐文章于 2023-03-04 10:50:54 发布

笙久拥

最新推荐文章于 2023-03-04 10:50:54 发布

阅读量1.9k

点赞数 2

CC 4.0 BY-SA版权

分类专栏： python 学习其他文章标签： python

本文链接：https://blog.youkuaiyun.com/weixin_44736161/article/details/112695536

python 学习同时被 2 个专栏收录

10 篇文章

订阅专栏

其他

1 篇文章

订阅专栏

本文详细介绍了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
str（345）
str（345）+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

结

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

注:

int 与 str 的差：str 需用print输出的时候需要加上引号，而 int 不用
如果有小黄色波浪，则通过菜单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. 切片

读取

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)

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


goods= ["汽车","飞机","火箭"]
index = input("请输入所需物品索引值，0：汽车,1：飞机,2:火箭")
chioce = goods[int(index)]
print("您选择的商品是{n1}".format(n1=chioce))

利用for循环和range 找出0 ~ 50以内能被3整除的数，并追加到一个列表/将新数值追加到列表前。

nums=[]
for i in range(50):
    if i%3==0:
        nums.append(i)
print(nums)

査找列表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 独有功能

添加元素

data = {"alexC", "AbC ", "egon", " riTiAn"}
data.add("run")
print(data)

'''
{'run', 'AbC ', 'alexC', 'egon', ' riTiAn'}
'''

data = set()
data.add("run")
print(data)

删除元素

data = {"alexC", "AbC ", "egon", " riTiAn"}
data.discard("alexC")
print(data)

'''
{' riTiAn', 'AbC ', 'egon'}
'''

交集

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

'''
{' riTiAn', 'AbC '}
'''

并集

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

差集

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 独有功能

获取值

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

所有的键

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

所有的值

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

所有的键值

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

设置值（对字典元素的新增功能）


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


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

如果是原来就存在键值对，则通过setdefault（）不能对原有键值对进行修改

更新字典键值对

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中有的则更新键值

移除指定键值对

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

data = info.pop("age")
print(info)
print(data)  #可以获取移除的值

按照顺序移除（后进先出）

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("奇奇奇数")

在这里插入图片描述

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("错误!")

num =1
while num <=100:
    print(num)
    num = num+1

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

num =1
while num<=100:
    if num % 2 ==0:
        print(num)
    num=num+1

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 . 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

1 .  = 8 or 4 or 0 or 7 = 8
2 .  = 0 or 4 or 0 or 3 = 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

num =66
i=1
while  i <= 3:
    input_num = input("请输入一个数字:")
    if int(input_num) == num:
        print("猜对了")
        break
    else:
        print("猜错了")
    i += 1

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