Python第一天

编程初体验

编码

计算机所有的数据本质上都是以0和1的组合来存储

注意：保存文件使用某种编码，打开文件时就必须使用次编码，否则就会出现乱码

初体验

在pycharm中创建一个任意python文件(一般python文件都是以.py后缀)，并 写入一下代码并运行

• 默认python解释器是UTF-8编码的形式打开文件，如果想要修改python的默认解释器编码，可以这样做

# -*- coding:gbk -*-
print("我是你大哥")

• 建议：所有python代码文件的都要以UTF-8编码保存和读取
• 默认是UTF-8

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-cEhTugxU-1639822023847)(Python第一天.assets/2-1.png)]

我们把这个过程分为两步：

【第一步】创建py文件&写代码

【第二步】保存代码文件，注意右下角黄色字体显示，此py文件是以utf-8编码保存（默认）。
【第三步】解释器运行代码文件，由于py文件是以utf-8编码保存，所以在Python解释器运行文件时也需要使用utf-8编码去打开并运行。代码文件顶部# -*- coding:utf-8 -*-的作用就是告诉Python解释器用utf-8编码去打开并运行此py代码文件。

如果代码文件是以gbk编码保存，那么文件的头部应该写成 # -*- coding:gbk -*-,这样解释器就会以gbk编码去打开并运行代码文件。

输出

输出，目的的将代码中结果或提示呈现给用户，让用户可以看到。

格式：print("要输出的内容")

• 默认输出要占一行，因为print的结束时默认会加换行符end="\n"

# 将结果呈现出来
print("看着风景美如画")

print("看着风景美如画")
print("本想吟诗赠天下")输出的结果
看着风景美如画
本想吟诗赠天下

• 不换行，加入end=""表示print结束时不再加\n而换成空。

print("看着风景美如画",end="")
print("本想吟诗赠天下",end="")输出结果
着风景美如画本想吟诗赠天下

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

练习题

1.使用print输出自己的名字
2.使用print输出
春眠不觉晓
处处闻啼鸟
夜来风雨声
花落知多少
3.使用print输出
春眠不觉晓，处处闻啼鸟，夜来风雨声 ，花落知多少print("戴浩")print("春眠不觉晓")
print("处处闻啼鸟")
print("也来风雨声")
print("花落知多少")print("春眠不觉晓",end=",")
print("处处闻啼鸟",end=".")
print("也来风雨声",end=",")
print("花落知多少",end=".")

数据类型：str/int/bool

int(整形)

在python中都成为整形，且支持 加/减/乘/除/取余/指数 等操作。

# 创建整型 666，并使用并使用print输出
print(666)
# 计算 2 加 10 的结果，并使用print输出
print(2+10)
# 计算 2 乘以 10 的结果，并使用print输出
print(2*10)
# 计算 10 除以 2 的结果，并使用print输出
print(10/2)
# 计算 10 除以 3 得的余数，并使用print输出
print(10%2)
# 计算 2 的 4 次方，并使用print输出
print(2**4)

注意：print在此处只起到输出结果的作用，与加减乘除无关。 # 是单行注释，# 后面的内容不会被解释器当做代码处理，个人可以用他做解释说明，方便理解。

str(字符串)

字符串，其实就是我们生活中的文本信息。例如：姓名、地址、自动介绍等。

字符串有一个特点，他必须有引号引起来、如：

# 创建字符串"武沛齐"，并使用print输出
print("武沛齐")
# 创建字符串 "中国北京昌平区"，并使用print输出
print("中国北京昌平区")
# 创建字符串 "我是谁？我是永远都得不到的爸爸呀！"，并使用print输出
print("我是谁？我是永远都得不到的爸爸呀！")

注意：print在此处只起到输出结果的作用

在整型中支持整型之间的加减乘除，在字符串中则支持字符串的 加、乘。

• 字符串拼接（相加）格式： “字符串A” + “字符串B” ，要求字符串只能和字符拼接。
• 字符串相乘格式： 整型 * “字符串”，效果就是让此字符串重新出现多少次，要求必须是整型和字符串相乘。

# 两个字符串 "金角" + "你是大王吧" 相加（一般称字符串相加为字符串拼接），并使用print输出
# 代码内部会先做字符串拼接，再调用print输出凭借后结果
print( "金角"+"你是大王吧" )
# 整型和字符串拼接（错误，不支持）
print(  5+"乔碧萝" )
# 整型和字符串相乘，得到字符串 "小逼崽子小逼崽子小逼崽子"
print( 3*"小逼崽子" )

bool(布尔值)

布尔值，其实就是我们生活通过某种判断的得到的真假，。例如：1>2是假、1小于7是真。

布尔值中只有两个值True（真）/False（假）

# 判断 1大于2 是True/False？并使用print输出
print( 1>2 )
# 判断 66等于99 是True/False？并使用print输出
print( 66==99 )
# 判断 字符串"二货"等于字符串"李杰" 是True/False？并使用print输出
print( "二货"=="李杰"  )
# 判断 1小于7是True/False？并使用print输出
print( 1<7 )
# 判断 字符串admin等于字符串admin是True/False？并使用print输出
print( "admin"=="admin")
# 判断 字符串666 等于整型 666 是True/False？并使用print输出
print( "666"==666 )

类型转换

• 整型定义时，必须是数字且无引号，例如：5、8、9
• 字符串定义时，必须用双引号括起来，例如：”中国”、”武沛齐”、”666”
• 布尔值定义时，只能写True和False

不同的数据类型都有不同的功能，例如：整形可以加减乘除而字符串只能加(拼接)和乘法。如果想要做转换可遵循一个基本规则：想转换类型让他包裹一些。例如：str(666)是将 整型转换为字符串、int（”888”)是将字符串转换为整型，具体转换实例如下：

转为整型

# ####### 字符串转整型的格式为：int(字符串) #######
print( int("666") )
print( int("100") + int("200") )
# 报错，“hula”应该转换为数字多少呢？没法确定。所以Python规定只有 "数字" 格式的字符串的才能转为整型。
print( int("hula") )
# 分别输出整型： 666、300、报错
# ####### 布尔值转整型的格式为：int(布尔值) #######
print( int(True) )
print( int(False) )
# 布尔值转换为整型，分别输出：1 、 0

转为字符串

# ####### 整型转字符串的格式为：str(整型) #######
print( str(666)+str(999) )
# 整型转换为字符串，然后两个字符串拼接，最终输出字符串：666999
# ####### 布尔值转字符串的格式为：str(布尔值) #######
print( str(True) )
print( str(False) )
print( str(True) + str(False) )
# 布尔值转换字符串，分别输出三个字符串：True 、 False 、 TrueFalse

转布尔值

# ####### 整型转布尔值的格式为：bool(整型) #######
print(1)
print(9)
print(-100)
print(0)
# 整型转换为布尔值，分别输出布尔值：True 、 True 、 True 、 False
# 注意：整型转布尔值时，只有0转换为False，其他均为True
# ####### 字符串转布尔值的格式为：bool(字符串) #######
print("你好")
print("fuck you")
print("666")
print("0")
print("")
# 字符串转换为布尔值，分别输出：True、True、True、True、False
# 注意：整型转布尔值时，只有空字符串转换为False，其他均为True

以上就是三种数据类型的相互转换。

总结：

• 想要转换成什么类型，就要用什么来包裹一下。(int/str/bool)
• 字符串转整型时，只能转那些引号是数字的字符串例如：例如：”88”、”99”，否则报错
• 其他类型布尔值时，只有00和“” 会转为False，其他均为Ture

练习题

1. 计算整型50乘以10再除以5的商并使用print输出。

2. 判断整型8是否大于10的结果并使用print输出。

3. 计算整型30除以2得到的余数并使用print输出。

4. 使用字符串乘法实现 把字符串”我爱我的祖国”创建三遍并拼接起来最终使用print输出。

5. 判断 字符串”wupeiqi”和”alex”是否相等的结果并使用print输出。

6. 判断 整型666和整型666是否相等的结果并使用print输出。

7. 判断 字符串”666”和整型666是否相等的结果并使用print输出。

8. 看代码写结果（禁止运行代码）：

   print( int("100")*3 )
   print( int("123") + int("88") )
   print( str(111) + str(222) )
   print( str(111)*3 )
   print( int("8") > 7 )
   print( str(111) == 111 )
   print( bool(-1) )
   print( bool(0) )
   print( bool("") )
   print( bool("你好") )
   print( True == True)
   print( True == False)
   print( bool("") == bool(0) )运行结果
   300
   211
   111222
   111111111
   True
   False
   True
   False
   False
   True
   True
   False
   True
   

注意：类型转换不是改变原来值，实际在底层是新创建了一个值。例如有整数注意：类型转换不是改变原来值，而是新创建了一个新的值。例如有整数 6 ，然后使用 str(6) 转化了一下得到 “6”,实际上这个字符串”6”是依据整数6新创建的。

变量

变量，其实就是我们生活中起别名和外号，让变量名指向某个值，格式为： 【变量名 = 值】，以后可以通过变量名来操作其对应的值。例如：

age = 18
name = "武沛齐"
flag = 1 > 18
address = "河北邯郸" + name
print(age) # 输出 18
print(name) # 输出 武沛齐
print(flag) # 输出 False
print(address) # 输出 河北邯郸武沛齐

变量名

Python中的变量名不是随便定义的，关于变量名的定义需要遵循如下规范：

• 三条规范（必须遵循，否则定义变量会报错）
  • 变量名只能由 字母、数字、下划线 组成。
  • 变量名不能以数字开头。
  • 变量名不能是Python内置关键字，如：

*[‘and’, ‘as’, ‘assert’, ‘break’, ‘class’, ‘continue’, ‘def’, ‘del’, ‘elif’, ‘else’, ‘except’, ‘exec’, ‘finally’, ‘for’, ‘from’, ‘global’, ‘if’, ‘import’, ‘in’, ‘is’, ‘lambda’, ‘not’, ‘or’, ‘pass’, ‘print’, ‘raise’, ‘return’, ‘try’, ‘while’, ‘with’, ‘yield’]*

二条建议（遵循可以显得更加专业，不遵循也可以正常运行不报错）

• 下划线命名法，多个单词表示的变量名用下划线连接（均小写

age = 58
name = "xiaohaoge"
brother_name = "alex"

• 见名知意，通过阅读变量名就能知道此变量的含义

age = 18
color = "red"
current_user_first_name = "勒布朗"

内存指向

通过学习上述变量知识让我们对变量了有了初步认识，接下来我们就要从稍稍高级一些的角度来学习变量，即：内存指向（在电脑的内存中是怎么存储的）。

情景一

name = "wupeiqi"

在计算机的内存中创建一块区域保存字符串”wupeiqi”，name变量名则指向这块区域。

情景二

name = "wupeiqi"
name = "alex"

在计算机的内存中创建一块区域保存字符串”wupeiqi”，name变量名则指向这块区域。然后又再内存中创建了一块域保存字符串”alex”，name变量名则指向”alex”所在的区域，不再指向”wupeiqi”所在区域（无人指向的数据会被标记为垃圾，由解释器自动化回收）

情景三

name = "wupeiqi"
new_name = name

情景四

name = "wupeiqi"
new_name = name
name = "alex"

在计算机的内存中创建一块区域保存字符串”wupeiqi”，name变量名则指向这块区域。new_name变量名指向name变量，因为被指向的是变量名，所以自动会转指向到name变量代表的内存区域.

情景五

num = 18age = str(num)

在计算机的内存中创建一块区域保存字符串”wupeiqi”，name变量名则指向这块区域(灰色线)， 然后new_name指向name所指向的内存区域，最后又创建了一块区域存放”alex”，让name变量指向”alex”所在区域.

练习题

看代码说结果

alex_length = 3
wupeiqi_length = 18
total = alex_length + wupeiqi_length
print(total)

按要求写代码

# 假设age为小明的年龄
age = 18
# 问：已知小李比小明大3岁，计算小李年龄赋值给ming_age变量并输出。
# 问：已知大刘比小明和小李年龄的和还要大5岁，计算大刘的年龄赋值给liu_age变量并输入。

看代码写结果

nickname = "一米八大高个"
username = nickname
username = "弟弟"
print(nickname)
print(username)

看代码写结果

nickname = "一米八大高个"
username = nickname
nickname = "弟弟"
print(nickname)
print(username)

看代码写结果

nickname = "一米八大高个"
username = "弟弟"
text = username + nickname
print(text)

看代码写结果

string_number = "20"
num = int(string_number)
data = string_number * 3
print(data)
value = num * 3
print(value)

注释

写代码的时候，如果想要对某些内容进行注释处理，即：解释器忽略，不会按照代码去运行。

• 单行注释，队一行或一行中某段内容进行注释，格式：#号行开头

# 单行注释，解释器忽略此行，不按照代码去解释此行代码。
name = 'alex'
age = 18 # 单行注释，解释器忽略#后面的内容，不按照代码去解释。

• 多行注释，对多行进行注释

"""
一行
又一行
注释多行，三引号括起来的内容解释器会忽略，不按照代码去解释代码。
"""
print("资源分享平台pythonav.com，奥利给！！！")

• 快捷键注释

mac 用command + ？键 win 用ctrl + ？

输入

学了上面的那些知识点，我们可以实现先定义一些数据类型，然后再让这些数据类型进行一些操作，最终通过print来进行输出，所有通过上述的指点只能完成规定死的逻辑最终输入得到的结果。

那么问题来了，如果想要实现用户交互怎么做呢？例如：

• 让用户输入账号和密码代码检测用户密码是否真确？
• 让用户输入数字，代码判断数字进行抽奖

这些功能均需要让用户输入一些值，然后我们根据用户输入的值进行相应的操作，接下来就学习如何让用户可以输入一些内容，然后咱们对输入的内容进行操作：

# 第一步：执行 input('请输入用户名：') ，输出区域 会提示用户来输入"请输入用户名"# 第二步：在下方任意输入，输入之后点击回车；之后会讲输入的内容赋值给name变量，name就代指你输入的内容name = input('请输入用户名：')# 第三步：输出name变量代指的值，即：输出刚才输入的内容print(name)

特别注意 ：基于input输入的内容是字符串类型，即使输入了一个数字。

示例1：提示输入姓名，然后给姓名后面拼接一个“烧饼”，提示输入姓名，然后给姓名后面拼接一个“烧饼”，最终打印结果。

name = input("请输入姓名:")text = name + "烧饼"print(text)

示例2：提示输入姓名/位置/行为，然后做拼接并打印：xx 在 xx 做 xx 。

name = input("请输入姓名：")
address = input("请输入位置：")
action = input("请输入行为：")
data = name + "在" + address + action
print(data)

实例三：提示输入两个数字，计算两个数字的和

num1 = input("请输入一个数字：")
num2 = input("请再输入一个数字：")
value = int(num1) + int(num2)
print(value)

条件语句

生活我们经常说：如果 xx ,就xx和 如果 xx ，否则就 xx.

如果我是女生，就让我哪些单生20年的哥们好好爽爽。
如果我是你爸，我就特么 天天凑你。
如果把Alex变成狗，就天天喊狗崽子
如果我有1000W就去找各种大模，否则就能找大妈了

在Python代码中想根据条件不同做不同操作，就可以使用if条件语句，他的书写个数如下：

if 条件 :条件成立，则执行这一块代码
else :条件不成立，则执行这一块代码
# 如果条件不成立不做任何操作，就可以else省去，只有：
if 条件:条件成立，则执行这一块代码

注意：if和else下面的代码都需要相同缩进（建议4个空格）

基本条件语句

关于条件语句我们通过实例代码来进行解释，例如：

print("开始")if 5 == 5:    print("原来5等于5")else:    print("5居然不等于5")print("结束")

示例2：

if 5 == "5":print("整数5等于字符串5")
else:print("整数5居然不等于字符串5")

• 示例 3：

num = 19
if num > 10:print("num变量对应值大于10")
else:print("num变量对应值不大于10")

• 示例4：

username = "wupeiqi"
password = "666"
if username == "wupeiqi" and password == "666":print("恭喜你，登录成功")
else:print("登录失败")

• 示例 5：

username = "wupeiqi"
if username == "wupeiqi" or username == "alex":print("VIP大会员用户")
else:print("普通用户")

示例：6

number = 19
if number%2 == 1:print("number是奇数")
else:print("number是偶数")

• 示例7

print("开始")
if 5 == 5:print("原来5等于5")
print("结束")

练习题：

1. 提示用户输入用户名和密码，用户名等于”wupeiqi”且密码等于”uuu”就输出登录成功；否则输出登录失败。

user = input("请输出姓名")
pwd = input("请输入密码")
if user == "daihao" and pwd == "123":print("登陆成功")
else:print("登陆失败")

1. 猜数字，提示用户输入一个数字，判断数字如果大于10，就输出猜错了；否则输出猜对了。

num = input("请输入一个数字")
if int(num) > 10:print("猜错了")
else:print("恭喜你猜对了")

1. 提示用户输入一个数字，判断是否为偶数，是偶数则输出 偶偶偶数，否则输出 奇奇奇数。

num = input("请输入一个数字：")
new_num = int(num)
if new_num % 2 == 1:print("我是奇数")
else:print("我是偶数")

多条件判断

如果判断逻辑中有多个条件可以，使用天剑语句的if elif实现，格式如下：

if 条件A:条件A成立则执行此处代码
elif 条件B:条件A不成立，条件B成立，则执行此处代码
elif 条件C:条件A/B都不成立，条件C成立，则执行此处代码
...
else:以上条件都不成立，则执行此处代码（如果没有功能，也可以把else省略）

示例：用户输入数字，判断是否等于6，如果大于6 则输出太大了。小于6输出太小了。等于6则提示刚刚好

num = input("请输入数字：")
data = int(num)
if data > 6:print("太大了")
elif data == 6:print("刚刚好")
else:print("太小了")

条件语句嵌套

条件语句可以进行嵌套，用以完成更加复杂的条件判断。嵌套时，一定要注意通过缩进来区分代码块之间的关系。

if 条件A：if 条件B :写代码...else:写代码...
elif 条件C：写代码...
else:if 条件D:写代码...

示例：模拟10086客服提醒

print("欢迎致电10086，我们提供如下服务：1，话费相关；2.业务办了；3.人工服务")
n1 = input("请选择要咨询的服务序号")
number = int(n1)
if number == 1:cost = input("查询话费请按1；交话费请按2；")if cost == "1":print("话费剩余100元")elif cost == "2":print("话费已成功充值一百元")else:print("输入错误")
elif number == 2:cost = input("宽带办理业务请按1；协议办理请按2；")if cost == "1":print("恭喜你成功办理宽带")elif cost == "2":print("协议办理宽带成功")else:print("输入错误")
elif number == 3:print("客服务007号为您服务")
else:print("序号出入错误，没有相关服务")

作业

1. 谈谈你了解的编码以及为什么会出现乱码的现象？

编码相当于是一个密码本，其中存储中文字和01010的对因果关系
乱码的出现是因为文件的存储方式和打开方式不一致导致，另外，数据丢失也可能会造成乱码

2.python解释器默认编码是什么？如何修改？

python解释器默认编码 ：utf-8
在文件中的顶部通过设置：# -*- coding: 编码 -*- 实现修改

3.用print打印出下面内容：

⽂能提笔安天下,
武能上⻢定乾坤.
⼼存谋略何⼈胜,
古今英雄唯是君。

方法一：
print("文能提笔安天下，")
print("武能上⻢定乾坤。")
print("⼼存谋略何⼈胜，")
print("古今英雄唯是君。")方法二：
text = """
文能提笔安天下，
武能上⻢定乾坤。
⼼存谋略何⼈胜，
古今英雄唯是君。
"""
print(text)

4.变量名的命名规范和建议？

三条规则（必须遵循，否则定义变量会报错）
- 变量名只能由，字符、数字、下划线组成。
- 变量名不能以数字开头。
- 变量名不能是python内置关键字二条建议（遵循可以显示更加专业，不遵循也可正常运行
不会报错）
- 下划线命名法，多个单词表示的变量名用下划线连接（均小写）
- 见名知意，通过阅读变量名就能知道变量的含义

5.如下那个变量名是正确的？

name = '武沛齐'
_ = 'alex'
_9 = "老男孩"
9name = "宝浪"  # 错误
oldboy(edu = 666  3 #错误

6.设定一个理想数字比如：66，让用户输入数字，如果比66大，则显示猜测的结果大了；如果比66小，则显示猜测的结果小了;只有等于66，显示猜测结果正确。

num =input("请输入数字")
data = int(num)
if data > 66:print("猜测的结果大了")
elif data < 66:print("猜测的结果小了")
else:print("猜测结果正确")

7.提⽰⽤户输入⿇花藤. 判断⽤户输入的对不对。如果对, 提⽰真聪明, 如果不对, 提⽰你 是傻逼么。

text = input("请输入")
if text == "麻花藤":print("真聪敏")
else:print("你是傻逼吗")

8.写程序，成绩有ABCDE5个等级，与分数的对应关系如下.要求用户输入0-100的数字后，你能正确打印他的对应成绩等级.

A    90-100
B    80-89
C    60-79
D    40-59
E    0-39

sore = input("请输入分数")
data = int(sore)
if 90 <= data <=100:print("A")
elif 80 <= data <=89:print("B")
elif 60 <= data <= 79:print("C")
elif 40 <= data <= 59:print("D")
else:print("E")

python第二天

while循环语句

生活中，我们经常会遇到一些重复的情况，例如：每天奔波与家和公司之间，循环播放音乐，网站密码输错时，需要重新输入

代码中想要实现一些重复行的操作，可以借助while循环语句来实现。例如实现:提示用户输入用户名和密码，如果出错则重新提示用户输入用户名和密码等。

while循环语句的基本结构

while 条件......可能有很多行代码(这种在while缩进里面的代码统称循环体)

关于执行过程：如果while后面的条件为假，则不会进入循环体；如果while后面的条件为真，则进入执行循环体中的所有代码。循环体中代码执行完之后，会再次回到 while条件判断的位置，再次判断此时条件是否为真，如果为真，则循环体中的代码会再执行一遍，然后再回到while条件判断…
如果某次执行完循环体中的代码之后，再次回到while条件判断的位置时，条件为假，则循环体中代码不再执行，跳过while语句继续向下执行其他代码。

循环语句

结合之前的知识点写出一些逻更加严谨的代码

示例1:

print("开始")
while True:print("如果祖国遭受到侵犯，热血男儿当自强。")
print("结束")

示例2：

print("开始")
while 1 > 2:print("喝干这碗家乡的酒，壮士一去不复返。")
print("结束")

示例3：

print("开始")
flag = True
while flag:print("滚滚黄河，滔滔长江。")flag = False
print("结束")

示例4：

print("开始")
num = 1
while num < 3:print("滚滚黄河，滔滔长江。")num = 5
print("结束")

示例5：

print("开始")
num = 1
while num < 5:print("给我生命，给我力量。")num = num + 1
print("结束")

示例6：

print("开始运行系统")
flag = True
while flag:user = input("请输入用户名：")pwd =  input("请输入密码：")if user == 'wupeiqi' and pwd = "oldboy":print("登录成功")flag = Falseelse:print("用户名或密码错误，请重新登录")
print("系统结束")

通过实例可以发现，只要能判断while后台的条件是真/假，就把循环的事搞定了。接下来再来几个练习题

练习题：

1.补充代码实现
猜数字，设定一个理想数字比如：66，一直提示让用户输入数字，如果比66大，则显示猜测的结果大了；如果比66小，则显示猜测的结果小了;只有输入等于66，显示猜测结果正确，然后退出循环。

number = 66
flag = True
while flag:...实现方法：data = True
while data:num = input("请输入一个数字：")num = int(num)if  num > 66:print("猜测的结果大了")elif num < 66:print("猜测的结果小了")else:print("恭喜你猜对了")data = False

2.使用循环输出1~100所有整数。

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

3.使用循环输出 1 2 3 4 5 6 8 9 10，即：10以内除7以外的整数。

# 方法一：
num = 1
while num <=10:if num == 7:pass  # 表示跳过本次循环啥事也不干else:print(num)num = num +1
# 方法二：
num = 1
while num <=10:if num != 7:  # !=表示不等于print(num)num = num +1

4.输出 1~100 内的所有奇数。

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

5.输出 1~100 内的所有偶数。

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

6.求 1~100 的所有整数的和。

total = 0
num = 1
while num <=100:total = total + numnum = num + 1print(total)

7.输出10~1 所有整数

num = 10
while num >=1:print(num)num = num -1

break关键字

通过上面的循环语句示例的学习，了解到可以通过，变量+条件配合来实现终止循环语句的执行。

break实现终止循环。

break使用语法

while True:...break...

关于执行过程：while循环体一旦遇到break,则立即终止while循环，从break的位置直接跳出while，去执行while之后的代码。

注意：break只能出现在循环体中，用于终止循环。

通过实例来更加深入理解break的应用

示例1：

print("开始")
while True:print("红旗飘飘，军号响。")breakprint("剑已出鞘，雷鸣电闪。")print("从来都是狭路相逢勇者胜。")
print("结束")

示例2：

print("开始")
i = 1
while True:print(i)i = i + 1if i == 101:break
print("结束")

示例3：

print("开始运行系统")
while True:user = input("请输入用户名：")pwd =  input("请输入密码：")if user == 'wupeiqi' and pwd = "oldboy":print("登录成功")breakelse:print("用户名或密码错误，请重新登录")
print("系统结束")

所以，以后写代码时候，想要结束循环可以通过两种方式实现了,即:条件判断和break关键字，两种在使用时无好坏之分，只要能实现功能就行。

continue关键字

continue关键字，用于结束本次循环，开始下次循环。

continue用法

while True:...continue...

执行过程：在循环中遇到continue之后，本次循环不在执行continue下面的代码，直接回到while条件判断的位置开始下一次循环。

示例1：

print("开始")
while True:print("红旗飘飘，军号响。")continueprint("剑已出鞘，雷鸣电闪。")print("从来都是狭路相逢勇者胜。")
print("结束")

示例:2

print("开始")
i = 1
while i < 101:if i == 7:i = i + 1continueprint(i)i = i + 1
print("结束")

示例3：

print("开始")
i = 1
while True:if i == 7:i = i + 1continueprint(i)i = i + 1if i == 101:break
print("结束")

写在最后，对于break和continue都是放在循环语句中用于控制循环过程的，一旦遇到break就停止所有循环，一旦遇到continue就停止本次循环，开始下次循环。

当然，如果没有了break和continue我们用while条件的判断以及其他协助也能完成很多功能，有了break和continue可以在一定程度上简化我们的代码逻辑。

while else语法

当while后的条件不成立时，else中的代码机会被执行

while else用法

while 条件：代码
else：代码

示例：1

while False:pass
else:print(123)

示例：2

num = 1
while num < 5:print(num)num = num + 1
else:priint(666)

示例:3

while Trueprint(123)break
else:print(666)

字符串格式

在开发的过程中我们经常遇到，将多个数据拼接，然后再处理的情况。之前我们都是使用字符串相加来实现的拼接，

2.1占位符:%s和%d

示例:1

name = "无佩奇"
age = 18
data = "我叫%s，今年%d岁" %(name,age)
print(data)
# 输出：我叫wupeiqi，今年18岁

代码解析过程：

1. 现有一个含有特殊%s的字符串 【”我叫%s，今年%d岁”】；
2. 在字符串后面紧跟 %(“替换第一个%s位置”,”替换第二个%d的位置”)，就会把字符串中的特殊%s和%d替换，最终得到替换的字符串【”我叫无佩奇，今年18岁”】;
3. 将这个已被替换完成字符串赋值给data，输出data就得到结果了。

注意：一般称字符串的%s叫占位符，而占位符被替代的过程叫字符串格式化。%s用于字符串类型%d用于整形类型

更多详细请参考博客：https://www.cnblogs.com/wupeiqi/artcles/5484747.html

示例:2

name = "王哥"
message = "Alex今天不在家，%s你什么时候过来？" %(name)
print(message)
# 输出：Alex今天不在家，王哥你什么时候过来？

示例:3

name = "王哥"
template = "Alex今天不在家，%s你什么时候过来？"
message = template %(name)
print(message)
# 输出：Alex今天不在家，王哥你什么时候过来？

示例:4

user = input("请输入用户名：")
address = input("请输入地点：")
action = input("请输入行为：")
data = "%s在%s，一直在%s。" %(user,address,action)
print(data)

示例:5

text = "我叫%s,今年%d岁"
data1 = text %{"无佩奇",20}
data2 = text %{"alex",84}

2.2占位符 %%

上面通过%s占位符实现格式化，但如果想要在页面上输出百分比的话就比较难了

# 正确
message = "兄弟们，这个片我已经下载 90 %了，马上就可以开看了啊。
print(message)

# 报错
message = "兄弟们，这个片我已经下载 %s %了，马上就可以开看了啊。" %(99,)
print(message)

# 正确
message = "兄弟们，这个片我已经下载 %s %%了，马上就可以开看了啊。" %(99,)
print(message)

在字符串格式化时，如果想要输出%,则必须写两个%%才能正确输出%.

写在最后，关于字符串格式化还有其他方式(如: format/f-string),但为了让初学者更好掌握，在此不再一一进行赘述，因为 %和%d基本上就可以完成所有的字符串格式化的任务，目前只要掌握 %s和%d 就行。

2.3format(推荐)

示例:1

text = "我叫{0},今年18岁".format("无佩奇")
text = "我叫{0},今年{1}岁".format("无佩奇",18)
# 复用
text = "我叫{0},今年{1}岁,真实姓名{0})".format("无佩奇",18)

示例:2

text = "我叫{},今年18".format("无佩奇")
text = "我叫{},今年{}".format("无佩奇",18)
# 复用
text = "我叫{},今年{},真实姓名".format("无佩奇",18)

示例:3

text = "我叫{n1},今年18岁".format("无佩奇")
text = "我叫{n1},今年{age}".format("无佩奇",18)
text = "我叫{n1},今年{age},真实姓名{n1}".format("无佩奇",18)

示例:4

text = "我叫{0}，今年{1}岁"
data1 = text.format{"无佩奇"，666}
data2 = text.format{"alex"，73}

2.4f

到python3.6版本，更便捷

示例：1

text = f"妹子喜欢(跑步)，跑完之后满身大汗"

示例:2

action = "跑步"
text = f"妹子喜欢(action),跑完之后满身大汗"

示例：3

name = "喵喵"
age = 19
text = f"妹子的名字{name},今年{age}岁"
print(text)

示例：4

text = f"妹子的名字叫喵喵，今年{19 + 2}岁"
print(text)

示例：5

在python3.8引入

text = f "妹子的名字叫喵喵，今年{19 + 2=}岁"
print(text)

进制转换

v1 = f"妹子今年{22}岁"
print(v1)# 转换为二进制
v2 = f"妹子今年{22:#b}岁"
print(v2)# 转换为八进制
v3 = f"妹子今年{22:#o}岁"
print(v3)# 转换为16进制
v4 = f"妹子今年{22:#x}岁"
print(v4)

理解即可

text = f"我是{'alex'},我爱大铁锤"name = "alex"
text = f"我是{name}，我爱大锤"# 将小写转为大写
name = "alex"
text = f"我是{ name.upper() }我爱大铁锤"
输出为：我是ALEX，我爱大铁锤

运算符

• 算数运算符，例如：加减乘除

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-h4uprELG-1639822023849)(Python第一天.assets/1.png)]

• 比较运算符，例如：大于、小于

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-g40kVOBN-1639822023849)(Python第一天.assets/2.png)]

注意：python3中不支持<>

if 1 >2:pass
while 1>2:pass # 跳过本次循环data = 1 == 2

• 复制运算，例如：变量赋值

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-OA646PlU-1639822023850)(Python第一天.assets/3.png)]

• 成员运算，例如：是否包含

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-bIlxIM4b-1639822023850)(Python第一天.assets/4.png)]

v1 = "le" in "alex"  # True/False
# 让用户输入一段文本，检测文本中是否包含敏感词。
text = input("请输入内容：")
if "苍老师" in text:print("少儿不宜")
else:print(text)

• 逻辑运算，例如：是或非

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-M7ZxE3ix-1639822023850)(Python第一天.assets/5.png)]

运算符优先级

运算的优先级有很多，常见的没几个，推荐记住3个即可：

• 算数优先级优先级 大于 比较运算符

if 2 + 10 > 11:print("真")
else:print("假")

• 比较运算符优先级 大于 逻辑运算符

if 1>2 and 2<10:print("成立")
else:print("不成立")

• 逻辑运算符内部三个优先级 not > and > or

if not 1 and 1>2 or 3 == 8:print("真")
else:print("假")

上述这3个优先级从高到低总结：加减乘除 > 比较 > not and or。当拿不定注意的时候：加括号()

逻辑运算(重要补充)

通常情况下逻辑运算一般都用在含有条件判断的位置，用于判断真假，例如：

示例：

if 1 == 1 and 2 > 3:print("真")
# 示例2
name = input("请输入用户名：")
if "wupeiqi" == name or 1 == 1:print("真")
# 示例3
flag = False
if not flag:print("来了老弟")
# 示例4
while 1 == 2 and 2 == 9:print("来了老妹")

但在python中逻辑运算还具有赋值的功能，让我们写代码简便，并且也是面试题中常见题型

温馨提醒：目前常见转换为布尔值为False的有“”和*0*(空字符和0)

示例：1

v2 = "wupeiqi" and "alex"# 第一步：将and前后的只转换为布尔值 True and True
# 第二步：判断本次操作取决于谁？由于前面的是True，所以本次逻辑判断取决于后面的值。
# 所以，后面的只等于多少最终结果就是多少。 v2 = "alex"v3 = "" and "alex"
# 第一步：将and前后的只转换为布尔值 False and True
# 第二步：判断本次操作取决于谁？由于前面的是False，所以本次逻辑判断取决于前面的值。
# 所以，前面的只等于多少最终结果就是多少。 v2 = ""v4 = 1 or 8
# 第一步：将and前后的只转换为布尔值 True or True
# 第二步：判断本次操作取决于谁？由于前面的是True，所以本次逻辑判断取决于前面的值。
# v4 = 1v5 = 0 or 8
# 第一步：将and前后的只转换为布尔值 False or True
# 第二步：判断本次操作决于谁？由于前面的是False，所以本次逻辑判断取决于后面的值。
# v5 = 8

练习题

v1 = 1 or 2 # 1
v2 = -1 or 3 # -1
v3 = 0 or -1 # -1
v4 = 0 or 100 # 100
v5 = "" or 10 # 10
v6 = "wupeiqi" or "" # "weipeiqi"
v7 = 0 or ""  # 空
print(v1,v2,v3,v4,v5,v6,v7)
# or,看第一个值，如果第一个值为真，结果就应该是第一个值，否则结果就是第二个值v1 = 4 and 8 # 8
v2 = 0 and 6 # 0
v3 = -1 and 88 # 88
v4 = "" and 7 # 空
v5 = "武沛齐" and "" # 空
v6 = "" and 0 # 空
v7 = 0 and "中国" # 0
print(v1,v2,v3,v4,v5,v6,v7)
# and,看一个值，如果第一个值为真结果就应该是第二个值，否则结果就是第一个值。

面试题

如果多个and和or的情况，先计算and在计算or

v1 = 0 or 4 and 3 or 7 or 9 and 60 or 3 or 7 or 9 and 60 or 3 or 7 or 63 or 7 or 63 or 63
v2 = 8 or 3 and 4 or 2 and 0 or 9 and 78v3 = 0 or 2 and 3 and 4 or 6 and 0 or 34

先计算not，在计算and，最后计算or

v4 = not 8 or 3 and 4 or 24

总结

1.while循环语句

2.break和continue关键字的作用

3.三种字符创格式化的方式

4.基础运算符，（逻辑运算符涉及的相关面试题）

今日作业

1. 判断下列逻辑语句的True,False

   1 > 1 or 3 < 4 or 4 > 5 and 2 > 1 and 9 > 8 or 7 < 6   # ture
   not 2 > 1 and 3 < 4 or 4 > 5 and 2 > 1 and 9 > 8 or 7 < 6  # false
   

2. 求出下列逻辑语句的值。

   8 or 3 and 4 or 2 and 0 or 9 and 7 #  8
   0 or 2 and 3 and 4 or 6 and 0 or 3 # 4
   

3. 下列结果是什么？

   6 or 2 > 1 # 6
   3 or 2 > 1 # 3
   0 or 5 < 4 # false
   5 < 4 or 3 # 3
   2 > 1 or 6 # ture
   3 and 2 > 1 # ture
   0 and 3 > 1 # 0
   2 > 1 and 3 # 3
   3 > 1 and 0 # 0
   3 > 1 and 2 or 2 < 3 and 3 and 4 or 3 > 2 # 2
   

4. 实现用户登录系统，并且要支持连续三次输错之后直接退出，并且在每次输错误时显示剩余错误次数（提示：使⽤字符串格式化）。

# 方法一：
count = 3
while count > 0:count -= 1user = input("请输出用户名：")pwd = input("请输入密码：")if user == "wupeiqi" and pwd == "123":print("登陆成功")breakelse:message = "用户名或者密码错误，剩余次数为{}次".format(count)print(message)# 方法二：
count = 0
while count  < 3:count += 1user = input("请输出用户名：")pwd = input("请输入密码：")if user == "wupeiqi" and pwd == "123":print("登陆成功")breakelse:message = "用户名或者密码错误，剩余次数为{}次".format(3- count)print(message)

2.猜年龄游戏
要求：允许用户最多尝试3次，3次都没猜对的话，就直接退出，如果猜对了，打印恭喜信息并退出。

ount = 0
while count < 3:count += 1age = input("请输入年龄：")age = int(age)if age == 73:print("恭喜你猜对了")breakelse:print("猜错了")

3.猜年龄游戏升级版
要求：允许用户最多尝试3次，每尝试3次后，如果还没猜对，就问用户是否还想继续玩，如果回答Y，就继续让其猜3次，以此往复，如果回答N，就退出程序，如何猜对了，就直接退出。

count = 0
while count < 3:count += 1age = input("请输入与年龄：")age = int(age)if age == 73:print("恭喜你才对了")breakelse:print("猜错了")if count == 3:choice = input("输入Y游戏继续/输入游戏结束N：")if choice == "N":breakelif choice == "Y":count = 0continueelse:print("请安提示输入")break
print("游戏结束")

python第三天

程序员常说的几种进制：

• 二进制，满二进位
• 八进制，满八进位
• 十进制，满十进位
• 十六进制，满十六进位

从上面的进制关系对照表可以发现，不同进制之间其实就进位的时机不同分别：满2、8、10、16进位。按照不同进制在表示同个数值时，会出现不同的值，例如：常说的数字14（十进制）用不同进制表示分别为:

• 关于十进制：在计算机诞生前，我们所有的计算都是通过人脑来实现。所以我们从小就开始学习数学，例如：12345678910、1+1=2等，其实就是十进制。把人类的大脑都培养成懂得十进制运算，这样人与人之间进行交流时候，就可以快速相互交换信息了。

• 关于二进制：计算机诞生，人类创造计算机就是为了模拟人脑来进行一些操作，但计算机被创造出来时只能懂得二进制，也就是一大堆的01010等，所以我们平时在计算机上想要实现 8 + 13 = 21功能，在计算机的内部会将它转换为二进制1000 和 1101之间的计算，本质上计算机中的一些行为都是以二进制来实现。

• 关于八进制：计算机中对数据另一种表示形式，一般写代码用不到，可暂忽略。（某些设备或PIC编码等场景有用到）

• 关于十六进制：由于计算机中本质上存储的都是二进制，一般在表示二进制时会使用十六进制，因为他用更短内容可以表示的数据更多，例如：二进制 100010001000101 用十六进制表示只需要 4445即可。

注意：计算机是由很多二极管组成，可以把二极管看成 灯，灯亮表示1；灯不亮表示0，计算机内部运行本质就是通过这种形式实现。其实也类似于古时候打仗，多个烽火台上的火把有没有被点亮，点亮的每一个火把都代表了不同的含义。

进制转换

v1 = bin(25) # 十进制转换为二进制
print(v1) # "0b11001"v2 = oct(23) # 十进制转换为八进制
print(v2) # "0o27"v3 = hex(28) # 十进制转换为十六进制
print(v3) # "0x1c"

# 二进制转换为十进制
i1 = int("0b11001",base=2) # 25
print(i1)# 八进制转换为十进制
i2 = int("0o27",base=8) # 23
print(i2)#十六进制转换为十进制
i3 = int("0x1c",base=16) # 28
print(i3)

计算机中到的单位

由于计算机本质上所有的东西以为二进制存储和操作前，为了方便对于二进制大小的表示，所有就搞了一些单位，例如：流量还有多少M，硬盘容量有1T，计算机8G内存等。宽带是200M，千兆网络等

计算汇总表示对于二进制大小的常见单位有

• b（bit），位

  表示二进制有多少位，例如：01101     就是 5位 = 5b011011010 就是 9位 = 9b

• B（byte），字节

 8位就是1个字节，例如：10100101                就是 8位 = 8b = 1B= 1个字节1010010110100101        就是 16位 = 16b = 2B= 2个字节

• KB（Kilobyte），千字节

 1024个字节就是1千字节（1KB），即：1 KB = 1024 B = 1024*8 b

• M（Megabyte），兆

  1024个千字节就是1兆（1M)，即：1M = 1024 KB = 1024 * 1024 B = 1024 * 1024 * 8 b

G（Gigabyte），千兆

1024个兆就是1千兆（1G),即：
1G = 1024 M = 1024 * 1024 KB = 1024 * 1024 * 1024 B = 1024 * 1024 * 1024 * 8 b

T（Terabyte），万亿字节

1024个G就是1T

做个小练习：假设1个汉字需要2个字节(2B=16位来表示，如：1000101011001100)，那么1G流量可以通过网络传输多少汉字呢？（计算机传输本质上也是二进制）

解答

已知 1G = 1024 MB = 1024 * 1024 KB = 1024 * 1024 * 1024 B 且 2B表示一个汉字。
所以 1024 * 1024 * 1024 / 2 = 536870912，即：1G流量可以传输536870912个汉字。

ascii编码

全世界第一台计算机是在美国诞生，诞生之初计算机只能怪支持英语，也就是说只能支持符号、字母数字，不支持：汉语、日语、汉语、泰语等，由于计算机本质上全部都是二进制操作，所有当时做了一张字符和二进制的对照表（ascii编码）

通过上图可以发现：

• ascii码表中的256个对应关系，足以支持所有的英文操作了

  ascii码规定用8位来表示一个字符。因为每一位有0/1两种可能，8位就可以支持256种可能，即：从 0000000、00000001、00000010 ~ 11111111 有256个，ascii就是这些二进制和字符来做的对应关系。

• 表示没有展示出二进制，按顺序仅分别显示了十、十六、八进制，如果包含了二进制关系的话，分别应该有

  二进制     十进制00000000        000000001        2...11111111        255

注意：ascii码中的 0 ~ 9 指的不是数字而是字符串"1"、"2"..."9" 与 二进制的对应关系。例如：

• 获取整数9对应的二进制时，直接通过 十进制和二进制的关系转换，即：1001
• 获取字符串”9”对应的二进制时，直接通过ascii码去找，即：00111001。

gb-2312编码

gb-2312编码，由国家信息标准委员会制作（1980年）。

gbk编码，对gb2312进行扩展，包含了中日韩等文字（1995年）。

在与二进制做对应关系时，由如下逻辑：

• 单字节表示，用一个字节表示对应关系。2**8 = 256
• 双字节表示，用两个字节表示对应关系。2**16 = 65536中可能性。

Unicode字符集

由于ascii码只能表示256中字符对照关系，无法表示其他国家的文字，所有为了能让计算机支持全世界任意的文字就搞出来了一个unicode（字符集），他为全世界已知语言的所有字符都分配了一个码位（相当于是一个身份证ID），码位本质上也是个二进制。

读到这里，你可能会感觉unicode字符集 和 ascii编码一样，但其实字符集和编码还是有区别，如下：

• ascii编码，直接是字符和二进制的对照表，此二进制可在计算机中用于 内存计算、硬盘存储、网络传输等。

字符    二进制a    01100001（十进制97；十六进制61）b    01100010（十进制98；十六进制62）

• unicode字符集，是字符和码位的对应关系，码位本质上也是二进制，此二进制可在计算机中用于内存计算，但一般不会做硬盘存储和网络传输

  字符           码位（ID）
  a    00000000 01100001（十进制97；十六进制61）
  b    00000000 01100010（十进制98；十六进制62）
  武   01101011 01100110（十进制27494；十六进制6B66）
  갵   10101100 00110101（十进制44085；十六进制AC35）
  

• utf-8编码，是对unicode字符集的码位进行转换处理得到的二进制，此二进制可用于 内存计算、硬盘存储、网络传输等。

  字符           码位（ID）                             utf-8编码（可以对码位进行加工处理）
  a    00000000 01100001（十进制97；十六进制61）            01100001
  b    00000000 01100010（十进制98；十六进制62）            01100010
  武   01101011 01100110（十进制27494；十六进制6B66）       11100110 10101101 10100110
  갵   10101100 00110101（十进制44085；十六进制AC35）       11101010 10110000 10110101
  注意：这样一来utf-8编码的二级制和字符就生成了一个间接的对照表。
  

• 起初unicode字符集固定使用2个字节来表示码位，即：ucs2。

ucs2用2个字节表示码位，所以码位能表示从 0000000000000000 至 1111111111111111 共 2**16=65525种可能，同时意味着ucs2能表示65535个字符。用十六进制表示这个范围的话就是：0000 ~ FFFF。ucs2中字符和码位的对应关系参见：http://www.columbia.edu/kermit/ucs2.html

• 后来unicode使用4个字节表示所有字符，即：ucs4

因为随着时间的推移，发现的字符越来越多，这65535不够用了。
所以就有了ucs4，他使用固定4个字节表示码位，码位就可以表示 2**32 = 4294967296 种可能，范围如下：二进制表示   00000000 00000000 00000000 00000000 ~ 11111111 11111111 11111111 11111111十六进制表示                            00000000 ~ ffffffffucs4中字符和码位的具体对应关系参见：https://unicode-table.com/en/#00A5https://www.unicode.org/charts/

截止2019年5月unicode已收集137929个字符，也就说ucs4还没被占满，如果发现其他的文字还可以继续扩增。

注意：ucs4其实是对ucs2的一个扩展，ucs4默认使用4个字节表示码位而ucs2用2个字节表示码位。 对于ucs2的65535个码位，ucs4会在ucs2表示的码位前加 0，即：ucs2：01101011 01100110 变为 ucs4：00000000 00000000 01101011 01100110； 对于第65535后面的码位，则ucs4在ucs2基础上在进行扩增（图2和图3）。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-53aMfN6q-1639822023850)(C:\Users\diahao0615\Desktop\py\Python第一天.assets\unicode.png)]

图二

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-l74sY8T7-1639822023851)(C:\Users\diahao0615\Desktop\py\Python第一天.assets\unicode2.png)]

图三

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-QaDCwua5-1639822023851)(C:\Users\diahao0615\Desktop\py\Python第一天.assets\unicode-3.png)]

写在最后，一般情况下用ucs2可以满足常见的文字，但如果想要表示更全/更多的话，肯定选择ucs4，并且现在越来越多的人都开始选择使用ucs4，例如：想要在系统中支持emoji图标，肯定要支持ucs4。

ucs4的优缺点：

• 缺点：因为都使用4个字节表示码位，同样的字符的码位会更占空间。所以，计算机中再网络传输、硬盘存储时都不会用unicode字符集的码位存储，而是把码位转换（压缩）成utf-8等编码的二进制再进行传输和硬盘存储。
• 优点：可以表示所有字符并且长度固定4字节，方便内存中进行数据计算（不必担心太占用内存空间，因为内存占用的计算的数据一般不会太大）。

注：网络传输指的是通过网络发送一段文字等消息； 硬盘存储指的是把一些文档等信息保存到硬盘上。

utf-8编码

utf-8，是一套以8位为一个编码单位的可以变长的编码。会将一个码位编码为 1 到 4 个字节，对于码位进行编码时分为两步：

• 第一步：根据码位选择转换模板

码位范围（十六进制）                转换模板0000 ~ 007F              0XXXXXXX0080 ~ 07FF              110XXXXX 10XXXXXX0800 ~ FFFF              1110XXXX 10XXXXXX 10XXXXXX10000 ~ 10FFFF            11110XXX 10XXXXXX 10XXXXXX 10XXXXXX例如："B"  对应的unicode码位为 0042，那么他应该选择的一个模板。"ǣ"  对应的unicode码位为 01E3，则应该选择第二个模板。"武" 对应的unicode码位为 6B66，则应该选择第三个模板。"沛" 对应的unicode码位为 6C9B，则应该选择第三个模板。"齐" 对应的unicode码位为 9F50，则应该选择第三个模板。注意：一般中文都使用第三个模板（3个字节），这也就是平时大家说中文在utf-8中会占3个字节的原因了。

• 第二步：码位以二进制展示，再根据模板进行转换

码位拆分： "武"的码位为6B66，则二进制为 0110101101100110
根据模板转换：6    B    6    60110 1011 0110 0110----------------------------1110XXXX 10XXXXXX 10XXXXXX    使用第三个模板11100110 10XXXXXX 10XXXXXX    第一步：取二进制前四位0110填充到模板的第一个字节的xxxx位置11100110 10101101 10XXXXXX    第二步：挨着向后取6位101101填充到模板的第二个字节的xxxxxx位置11100110 10101101 10100110    第二步：再挨着向后取6位100110填充到模板的第三个字节的xxxxxx位置
最终，"武"对应的utf-8编码为 11100110 10101101 10100110

除了utf-8之外，其实还有一些其他的 utf-7/utf-16/utf-32 等编码，他们跟utf-8类似，但没有utf-8应用广泛。

python相关的编码

字符串（str）     "alex媳妇叫铁锤"             unicode处理               一般在内存
字节（byte）      b"alexfdsfdsdfskdfsd"      utf-8编码 or gbk编码       一般用于文件或网络处理

v1 = "武"v2 = "武".encode("utf-8")
v2 = "武".encode("gbk")

将一个字符串写入到一个文件中

name = "今天好热热的满身大汗"
data = name.encode("utf-8") # 这里是把字符串转换为字节# 打开一个文件
file_object = open("log.txt",mode="wb")
# 在文件中写内容
file_object.write(data)
# 关闭文件
file_object.close()

总结

本章的知识点属于理解为主，了解这些基础之后有利于后面知识点的学习，接下来对本节所有的知识点进行归纳总结：

1. 计算机上所有的东西最终都会转换成为二进制再去运行。

2. ascii编码、unicode字符集、utf-8编码本质上都是字符与二进制的关系。

   • ascii，字符和二进制的对照表。
   • unicode，字符和二进制（码位）的对照表。
   • utf-8，对unicode字符集的码位进行压缩处理，间接也维护了字符和二进制的对照表。

3. ucs2和ucs4指的是使用多少个字节来表示unicode字符集的码位。

4. 目前最广泛的编码为：utf-8，他可以表示所有的字符且存储或网络传输也不会浪费资源（对码位进行压缩了）。

5. 二进制、八进制、十进制、十六进制其实就是进位的时机不同。

6. 基于Python实现二进制、八进制、十进制、十六进制之间的转换。

7. 一个字节8位

8. 计算机中常见单位b/B/KB/M/G的关系。

9. 汉字，用gbk编码需要用2个字节；用utf-8编码需要用3个字节。

10. 基于Python实现将字符串转换为字节（utf-8编码）

    # 字符串类型
    name = "武沛齐"print(name) # 武沛齐
    # 字符串转换为字节类型
    data = name.encode("utf-8")
    print(data) # b'\xe6\xad\xa6\xe6\xb2\x9b\xe9\xbd\x90'# 把字节转换为字符串
    old = data.decode("utf-8")
    print(old)
    

11. 基于Python实现将字符串转换为字节（gbk编码）

    # 字符串类型
    name = "武沛齐"
    print(name) # 武沛齐
    # 字符串转换为字节类型
    data = name.encode("gbk")
    # print(data) # b'\xe6\xad\xa6\xe6\xb2\x9b\xe9\xbd\x90'  utf8，中文3个字节
    print(data) # b'\xce\xe4\xc5\xe6\xc6\xeb'              gbk，中文2个字节# 把字节转换为字符串
    old = data.decode("gbk")
    print(old)
    

python第四天

• int，整数类型（整形）
• bool，布尔类型
• str，字符串类型
• list，列表类型
• tuple，元组类型
• dict，字典类型
• set，集合类型
• float，浮点类型（浮点型）

每种数据类型都有自己的特点及应用场景，以后的开发中需要根据实际的开发情况选择合适的数据类型。

每种数据类型的学习，会按照以下4个维度来进行：

1.定义

2.独有功能

3.公共功能

4.类型转换

5.其他

整型(int)

整型其实就是十进制整数的统称比如：1、68、999都属于整型。他一般用于表示 年龄、序号等。

1.1定义整型

number = 10
age = 99
# 可以通过type查看下到底是什么类型
print( type(number) )

1.2独有功能

v1 = 5
print(bin(v1))  # 0b101  转化为二进制 0b代表二进制
# 调用v1（int）的独有功能，获取v1的二进制有多少个位组成。
result1 = v1.bit_length()
print(result1)  # 3v2 = 10
print(bin(10))  # 0b1010
# 调用v2（int）的独有功能，获取v2的二进制有多少个位组成。
result2 = v2.bit_length()
print(result2)  # 4

1.3公共功能

加成乘除

v1 = 4
v2 = 8
v3 = v1 + v2

1.4转换为整型

在项目开发和面试题中经常会出现一些“字符串”和布尔值转换为整型的情况

整数0、空字符串、空列表、空元组、空字典转换为布尔值时均为False、其他均为True

# 布尔值转整型
n1 = int(True)  # True转换为整数 1
n2 = int(False) # False转换为整数 0
# 字符串转整型
v1 = int("186",base=10) # 把字符串看成十进制的值，然后再转换为 十进制整数，结果：v1 = 186
v2 = int("0b1001",base=2) # 把字符串看成二进制的值，然后再转换为 十进制整数，结果：v1 = 9 (0b表示二进制)
v3 = int("0o144",base=8)  # 把字符串看成八进制的值，然后转换为 十进制整数，结果：v1 = 100 (0o表示八进制)
v4 = int("0x59",base=16)  # 把字符串看成十六进制的值，然后转换为 十进制整数，结果：v1 = 89 （0x表示十六进制）# 浮点型(小数)
v1 = int(8.7) # 8

所以，如果以后别人给你一个按 二进制、八进制、十进制、十六进制 规则存储的字符串时，可以轻松的通过int转换为十进制的整数。

1.5其他

1.5.1 长整型

• Python3：整型（无限制）
• Python2：整型、长整形

在python2中跟整数相关的数据类型有两种：int(整型)、long（长整型），他们都是整数只不过能表示的值范围不同。

• int，可表示的范围：-9223372036854775808～9223372036854775807
• long，整数值超出int范围之后自动会转换为long类型（无限制）。

在python3中去除了long只剩下：int（整型），并且 int 长度不在限制。

扩展：python2中两个值相除时，默认进行地板除，只保留整数位。（python3中默认会保留小数）

地板除

• python3

v1 = 9/2
print(v1) # 4.5

• python2

v1 = 9/2
print(v1) # 4from __future__ import division v1 = 9/2
print(v1) # 4.5

布尔值(bool)

布尔值，其实就是真、假

定义

data = False
alex_is_sb = True

常见方法

无

转换为布尔值

在以后的项目开发中，会经常使用其他类型转换为布尔值的情景，此处只要记住一个规律即可。

整数0、空字符串、空列表、空元祖、空字典转换为布尔值时均为False
其他均为True

练习题：查看一些变量为True还是False

v1 = bool(0)
v2 = bool(-10)
v3 = bool(10)
v4 = bool("武沛齐")
v5 = bool("")
v6 = bool(" ")
v7 = bool([]) # [] 表示空列表
v8 = bool([11，22，33]) # [11，22，33] 表示非空列表
v9 = bool({}) # {} 表示空字典
v10 = bool({"name":"武沛齐","age":18}) # {"name":"武沛齐","age":18} 表示非空字典

其他

如果if、while条件后面写一个值当做条件时，他会默认转为为布尔值类型，然后再做条件判断。

if 666:print("太六了")
if "武沛齐":print("你好")
if 0:print("你是傻逼？")
else:print("你是逗比？")

while 1>9;pass

if 值:passwhile 值:pass

字符串

字符串，我们平时会用来表示文本信息，例如：姓名、地址、自我介绍等。

定义

v1 = "包治百病"
v2 = '包治百病'
v3 = "包'治百病"
v4 = '包"治百病'
v5 = """
吵架都是我的错，
因为大家打不过。
"""
# 三个引号，可以支持多行/换行表示一个字符串，其他的都只能在一行中表示一个字符串。

常见方法

python中给属于字符串的所有值都能提供一些功能(方法)，从而可以快速对字符串进行一些方便的操作。

注意：这是字符串类型的独有功能，其他类型没有次功能。

1.判断字符串是否以xx开头？得到一个布尔值

startswith # 表示以什么开头
v1 = "叨逼叨的一天，烦死了"
result = v1.startswith("叨逼")
print(result) # 值为True

案例1

 # 案例v1 = input("请输入住址：")if v1.startswith("北京市"):print("北京人口")else:print("非北京人口")

2.判断字符串是否以什么结尾？得到一个布尔值

endswith  # 表示以什么结尾
v1 = "叨逼叨的一天，烦死了"
result = v1.endswith("烦死")
print(result) # 值为False

案例

[ address = input("请输入地址：")
if address.endswith('村'):
print("农业户口")
else:
print("非农户口")]

3.判断字符串是否以十进制？得到一个布尔值

isdecimal  # 表示十进制
v1 = "1238871"
result = v1.isdecimal()
print(result) # True

案例

v1 = input("请输入值：")
v2 = input("请输入值：")
if v1.isdecimal() and v2.isdecimal():data = int(v1) + int(v2)print(data)
else:print("请正确输入数字")

v1 = "123"
print(v1.isdecimal()) # Truev2 = "①"
print(v2.isdecimal()) # Falsev3 = "123"
print(v3.isdigit()) # Truev4 = "①"
print(v4.isdigit()) # True

4.去除字符串两边的空格、换行符、得到一个新字符串

strip  # 表示去除两边空格
msg = " H e ll o啊，树哥 "
data = msg.strip()
print(data) # 将msg两边的空白去掉，得到"H e ll o啊，树哥"

去除两边指定的内容

lstrip # 表示去除左边空格
msg = " H e ll o啊，树哥 "
data = msg.lstrip()
print(data) # 将msg左边的空白去掉，得到"H e ll o啊，树哥 "

rstrip  #表示去除右手边空格
msg = " H e ll o啊，树哥 "
data = msg.rstrip()
print(data) # 将msg右边的空白去掉，得到" H e ll o啊，树哥"

补充：去除空格、换行符、制表符

 # 案例code = input("请输入4位验证码：")data = code.strip()if data == "FB87":print('验证码正确')else:print("验证码错误")

5.字符串变大写，得到一个新的字符串

upper  # 表示字符串变大写
msg = "my name is oliver queen"
data = msg.upper() # 新生成一个值，不改变原来的值
print(data) # 输出为：MY NAME IS OLIVER QUEEN

案例

 code = input("请输入4位验证码：")data = code.strip()value = data.upper()# value = code.strip().upper()if value == "FB87":print('验证码正确')else:print("验证码错误")# 注意事项
"""
code的值"fb88 "
value的值"FB88 "
data的值"FB88"
"""

6.字符串小写，得到一个新的字符串

 msg = "My Name Is Oliver Queen"data = msg.upper()print(data) # 输出为：my name is oliver queen

案例

lower # 表示字符串变小写
code = input("请输入4位验证码：")
value = code.strip().lower()
if value == "fb87":print('验证码正确')
else:print("验证码错误")

7.字符串内容替换，得到一个新的字符串

replace  # 表示字符串内容替换
data = "你是个好人，但是好人不合适我"
value = data.replace("好人","贱人")
print(data)  # "你是个好人，但是好人不合适我"
print(value) # "你是个贱人，但是贱人不合适我"

案例

video_file_name = "高清无码爱情动作片.mp4"new_file_name = video_file_name.replace("mp4","avi") # "高清无码爱情动作片.avi"final_file_name = new_file_name.replace("无码","步兵") # "高清步兵爱情动作片.avi"print(final_file_name)

video_file_name = "高清无码爱情动作片.mp4"new_file_name = video_file_name.replace("mp4","avi") # "高清无码爱情动作片.avi"final_file_name = video_file_name.replace("无码","步兵") # "高清步兵爱情动作片.mp4"print(final_file_name)

content = input("请输入评论信息") # alex是一个草包
content = content.replace("草","**") # alex是一个**包
content = content.replace("泥马","***") # alex是一个**包
print(content) # alex是一个**包

char_list = ["草拟吗","逗比","二蛋","钢球"]content = input("请输入评论信息")
for item in char_list:content = content.repalce(item,"**")print(content)

8.字符串切割，得到一个列表

split  # 表示字符串切割
data = "武沛齐|root|wupeiqi@qq.com"
result = data.split('|') # ["武沛齐","root","wupeiqi@qq.com"]
print(data) # "武沛齐|root|wupeiqi@qq.com"
print(result) # 输出 ["武沛齐","root","wupeiqi@qq.com"] 根据特定字符切开之后保存在列表中，方便以后的操作

# 案例：判断用户名密码是否正确
info = "武沛齐,root"   # 备注：字符串中存储了用户名和密码
user_list = info.split(',')    # 得到一个包含了2个元素的列表 [ "武沛齐" , "root" ]# user_list[0]
# user_list[1]user = input("请输入用户名：")
pwd = input("请输入密码：")if user == user_list[0] and pwd == user_list[1]:print("登录成功")
else:print("用户名或密码错误")

扩展

data = "武沛齐|root|wupeiqi@qq.com"
v1 = data.split("|")   # ['武沛齐', 'root', 'wupeiqi@qq.com']
print(v1)v2 = data.split("|", 2) # ['武沛齐', 'root|wupeiqi@qq.com']
print(v2)

再次扩展

data = "武沛齐,root,wupeiqi@qq.com"v1 = data.rsplit(',')
print(v1) # ['武沛齐', 'root', 'wupeiqi@qq.com']v2 = data.rsplit(',',1)
print(v2) # ['武沛齐,root', 'wupeiqi@qq.com']

应用场景

file_path = "xxx/xxxx/xx.xx/xxx.mp4"data_list = file_path.rsplit(".",1) # ["xxx/xxxx/xx.xx/xxx","mp4"]
data_list[0]
data_list[1]

9.字符串拼接，得到一个新的字符串

.join  # 表示字符串拼接
data_list = ["alex","是","大烧饼"]
v1 = "_".join(data_list) # alex_是_大烧饼
print(v1)

10.格式化字符串，得到新的字符串

name = "{0}的喜欢干很多行业，例如有：{1}、{2} 等"
data = name.format("老王","护士","嫩模")
print(data) # 老王的喜欢干很多行业，例如有：护士、嫩模 等

name = "{}的喜欢干很多行业，例如有：{}、{} 等"
data = name.format("老王","护士","嫩模")
print(data) # 老王的喜欢干很多行业，例如有：护士、嫩模 等

name = "{name}的喜欢干很多行业，例如有：{h1}、{h2} 等"
data = name.format(name="老王",h1="护士",h2="嫩模")
print(data) # 老王的喜欢干很多行业，例如有：护士、嫩模 等

11.字符串转换为字节类型

encode # 表示字字符串转类型
data = "饺子"  # unicode，字符串类型v1 = data.encode("utf-8")  # utf-8，字节类型
v2 = data.encode("gbk")  # gbk，字节类型print(v1)  # b'\xe5\xab\x82 \xe5\xad\x90'
print(v2)  # b'\xc9\xa9 \xd7\xd3's1 = v1.decode("utf-8") # 饺子
s2 = v2.decode("gbk") # 饺子
print(s1)
print(s2)

12.将字符串内容居中，居左，居右展示

# center 居中展示
v1 = "王老汉"
data = v1.center(21, "-")
print(data) #---------王老汉---------#ljust 居左展示
data = v1.ljust(21, "-")
print(data) # 王老汉------------------# rjust居右展示
data = v1.rjust(21, "-")
print(data) # ------------------王老汉

13.帮助你填充0

# zfill 帮助填充0
data = "alex"
v1 = data.zfill(10)
print(v1) # 000000alex

应用场景：处理二进制数据

data = "101" # "00000101"
v1 = data.zfill(8)
print(v1) # "00000101"

公共功能

1.相加：字符串 + 字符串

v1 = "alex" + "大sb"
print(v1)

2.相乘：字符串*整数

data = "饺子" * 3
print(data)# 饺子饺子饺子

3.长度

data = "饺子味道很好"
value = len(data)
print(value) # 6

4.获取字符串中的字符，索引

message = "来做点py交易呀"
prin(message)[0] # 来
prin(message)[1] # 做
prin(message)[2] # 点prin(message)[-1] # 呀
prin(message)[-2] # 易
prin(message)[-3] # 交

注意：字符串是通过索引取值，无法修改值。【字符串在内部存储时不允许内部元素修改，想修改只能重新创建。】

message = "来做点py交易呀"
index = 0
while index < len(message):value = message[index]print(value)index += 1

倒序输出

message = "来做点py交易呀"
index = len(message) - 1
while index >= 0:value = message[index]print(value)index -= 1

5.获取字符串的子序列，切片

message = "来做点py交易呀"
print(message[0:2]) # "来做"
print(message[3:7]) # py交易呀
print(message[3:]) # 从第三个字符串取到结尾
# 从第一个字符串到第五个字符串
print(message[:5]) # 来做点pyprint(message[4:-1]) # "y交易"
print(message[4:-2]) # "y交"
print(message[4:len(message)]) # "y交易呀"

注意：字符串中的切片只能读取数据，无法修改数据。【字符串在内部存储时不允许对内部元素修改，想要修改只能重新创建】

message = "来做点py交易呀"
value = message[:3] + "python" + message[5:]
print(value)

6.步长，跳着取字符串的内容

name = "生活不是电影，生活比电影哭"
print(name[0:5:2])  # 输出： 生不点 【前两个值表示区间范围，最右一个值表示步长】
print(name[:8:2])   # 输出：生不电，【区间范围的前面不写则表示起始范围为0开始】
print(name[2::3])  # 输出：不影生活，活电苦 【区间范围的后面不写则表示结束范围为最后】
print(name[::2])  # 输出：生不电。电活哭 【区间范围不写表示整个字符串】
print(name[8:1:-1]) # 输出：活生，影电是不【倒序】
print(name[-1:1:-1]) # 输出：哭影电比活生，影电是不

面试题 ：给你一个字符串，请将这个字符串反转

value = (name[::-1])
print(name) # 哭影电比活生，影电是不活生

for循环

message = "来做点py交易呀"
for char in message:print(char)

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]
range(10,1,-1) #[10,9,8,7,6,5,4,3,2]

for + range的使用

for i in range(10):print(i)

message = "来做点py交易呀"
for i in range(5):print(message[i])# 结果
来
做
点
p
y

message = "来做点py交易"
for i in range(len(message)):print(message[i])# 结果
来
做
点
p
y
交
易

一般应用场景：

while循环，一般用作于无限制(未知)循环处使用。

num = 0
while =True:data = input("请输入内容：")if data.isdecimal():num = int(data)breakelse:print("输入错误，请重新输入！")

for循环，一般应用在一直的循环数量的场景处使用

message = "来做点py交易呀"
for char in message:print(char)

message = "来做点py交易呀"
for i in range(5):print(message[i])

breake和continue关键字

message = "来做点py交易呀"
for char in message:if char == "p":continueprint(char)# 结果为
来
做
点
y
交
易
呀

message = "来做点py交易呀"
for char in message:if char == "p":breakprint(char)# 结果
来
做
点

for循环嵌套语句

for i in range(5):print(i)for j in range(3):print(j)

转换

num = 999
data = str(num)
print(data) # "999"

data_list = ["alex","eric",999]
data =str(data_list)
print(data) # '["alex","eric",999]'

一般情况下，只有整形转字符串才有意义。

字符串不可以被修改

name = "无佩奇"
name[1]
name[1:2]

num_list = [11,22,33]
num_list[0]
num_list[0] = 666

总结

1.整形在Python2和Python3中的区别

2.进制之间的转换

3.其他类型转换为布尔类型时，空和0位False,其他均为True

4.条件语句中可自动化转换为布尔类型来做判断。

if "小猪佩奇":print(666)
else:print(9999)

5.字符串中常见的独有功能。

6.字符串中常见的公共功能

7.字符串创建之后是不可被修改的。

Python第五天

数据类型中：

常见的数据类型

• int，整形类型（整形）

• bool，布尔类型

• str，字符串类型

• list，列表类型

• tuple，元祖类型

• dict,字典类型

• set,结合类型

• float，浮点类型（浮点类型）

目标：掌握列表和元祖数据类型的各种操作，（知识点应用案例）

课程概要：

• list，列表类型，用于存储一些数据的容器，（有序&可修改）
• tuple，元祖类型，用于存储一些数据的容器，（有序&不可修改）

1.列表（list）

user_list = "李老师","讲课"，"讲的真好"
number_list = [98,88,666,12,-1]
data_list = [1,True,"Alex","宝强"，"贾乃亮"]

user_list = []
user_list.append("铁锤")
user_list.append(123)
user_list.append(True)
print(user_list) # ["铁锤"，123，True]

不可变类型：字符串、布尔、整形（已最小，内部数据无法进行修改）

可变类型：列表（内部数据元素可以修改）

1.2独有功能

Python中为所有的列表类型的数据提供了一批独有的功能。

字符串和列表的对比：

• 字符串，不可变，即：创建好之后内部就无法修改。【独有功能都是新创建一份数据】

name = "alex"
data =name.upper()
print(name)
print(data)

• 列表，可变，即：创建好之后内部元素可以修改。【独有功能基本上都是直接操作列表内部，不会创建新的一份数据】

user_list = ["车子","房子"]
user_list.append("妹子")
print(user_list) # ["车子","房子","妹子"]

列表中的常见独有功能如下：

1.追加，在原列表中尾部追加值

data_list = []
v1 = input("请输入姓名")
data_list.append(v1)v2= input("请输入姓名")
data_list.append(2)
print(ddata_list) # ["alex" ,"eric"]

案例1

user_list = []
while True:user = input("请输入用户名(Q退出)：")if user == "Q":break
print(user_list)

案例二：

welcome = "欢迎使用NB游戏".center(30, '*')
print(welcome)
user_list = 0
while True:count = input("请输入游戏人数：")if count.isdecimal():user_count = int(count)breakelse:print("输入格式错误，人数必须是数字。")
message = "{}人数参加游戏NB游戏。".format(user_count)
print(message)
user_name_list = []
for i in range(1, user_count + 1):tips = "请输入玩家姓名({}/{}):".format(i, user_count)name = input(tips)user_name_list.append(name)
print(user_name_list)

2.批量追加，将一个列表中的元素逐一添加另外一个列表。

tools = ["搬砖","菜刀","榔头"]
tools.extend( [11,22,33]) # weapon中的值逐一追加到tools中
print(tools) #['搬砖', '菜刀', '榔头', 11, 22, 33]

tools = ["搬砖","菜刀","榔头"]
weapon = ["AK37","M6"]
#tools.extend(weapon) # weapon中的值逐一追加到tools中
#print(tools) # ['搬砖', '菜刀', '榔头', 'AK37', 'M6']
weapon.extend(tools)
print(tools)  #['搬砖', '菜刀', '榔头']
print(weapon) # ['AK37', 'M6', '搬砖', '菜刀', '榔头']

等价于(扩展)

weapon = ["Ak47","M6"]
for item in weapon:print(item)
# 输出
# Ak47
# M6
tools = ["搬砖","菜刀","榔头"]
weapon = ["AK47","M6"]
for item in weapon:tools.append(item)
print(tools) #['搬砖', '菜刀', '榔头', 'AK47', 'M6']

3.插入，在原列表的指定索引位置插入值

user_list = ["李老师","刘老师","吴老师"]
user_list.insert(0,"马老师")
user_list.insert(2,"肖老师")
print(user_list)

案例

name_list = []
while True:name = input("请输入购买火车票用户名姓名（Q/q退出）")if name.upper() == "Q":breakif name.startswith("刁"):name_list.insert(0,name)else:name_list.append(name)
print(name_list)

4.在原列表中根据值删除（从左到右找到第一个删除）【慎用，里面没有会报错】

user_list = ["王宝强","陈羽凡","Alex","贾乃亮","Alex"]
user_list.remove("Alex")
print(user_list)user_list = ["王宝强","陈羽凡","Alex","贾乃亮","Alex"]
if "Alex" in user_list:user_list.remove("Alex")
print(user_list)user_list = ["王宝强","陈羽凡","Alex","贾乃亮","Alex"]
while True:if "Alex" in user_list:user_list.remove("Alex")else:breakprint(user_list)

案例：自动抽奖程序

import random
data_list = ["iphone12","耳机","mp3","mp4","谢谢惠顾"]
while data_list:name = input("自动抽奖程序，请输入自己的姓名：")# 随机data_list抽取一个值出来value = random.choice(data_list) # iphone12print("恭喜{},抽中{}".format(name,value))data_list.remove(value) # iphone12

5.在原列表中索引踢出某个元素（根据索引位置删除）

user_list = ["王宝强","陈羽凡","Alex","贾乃亮","Alex"]
#               0       1       2      3       4
user_list.pop(1)
print(user_list) #['王宝强', '贾乃亮', 'Alex']user_list.pop()
print(user_list) #['王宝强', '贾乃亮']item = user_list.pop(1)
print(item) # Alex
print(user_list) #['王宝强', '贾乃亮']

案例:排队买火车票

user_qurue = []
while True:name = input("北京~上海火车票，购买请输入姓名排队（Q退出）：")if name == "Q":breakuser_qurue.append(name)
ticket_count = 3
for i in range(ticket_count):username = user_qurue.pop(0)message = "恭喜{}，购买火车票成功。".format(username)print(message)# user_queue = ["无佩奇"，"老妖"，"钢球"]
faild_user =  "、".join(user_qurue) # "无佩奇、老妖、钢球"
faild_message = "非常抱歉,票已售完，一下几位用户选择其他出行方式，名单：{}。".format(faild_user)
print(faild_message)

7.根据值获取索引（从左到右找到第一个删除）【慎用，找到到报错】

user_list = ["王宝强","陈羽凡","Alex","贾乃亮","Alex"]
#               0       1       2      3       4
if "Alex" in user_list:index = user_list.index("Alex")print(index) #2
else:print("不存在")

8.列表元素排序

# 数字排序
num_list = [11,22,4,5,11,99,88]
print(num_list)
num_list.sort() # 让num_list从小到大排序
num_list.sort(reverse=True) # 让num_list从大到小排序
print(num_list)

字符串排序

user_list = ["王宝强","AB陈羽凡","Alex","贾乃亮","贾乃","1"]
print(user_list)
user_list.sort()
print(user_list)sort的排序原理:是根据Unicode编码去进行排序
# 结果
['王宝强', 'AB陈羽凡', 'Alex', '贾乃亮', '贾乃', '1']
['1', 'AB陈羽凡', 'Alex', '王宝强', '贾乃', '贾乃亮']

注意：排序内部元素无法进行比较时，程序汇报报错（尽量数据类型统一）

9.反转原列表

user_list = ["王宝强","陈羽凡","Alex","贾乃亮","Alex"]
user_list.reverse()
print(user_list)
# 结果
['Alex', '贾乃亮', 'Alex', '陈羽凡', '王宝强']

1.3 公共功能

1.相加，两家列表加获取生成一个新的列表。

data = ["赵四","刘能"] + ["宋晓晓","范德彪"]
print(data) #[['赵四', '刘能', '宋晓晓', '范德彪']]
v1 = ["赵四","刘能"]
v2 = ["宋晓峰","范德彪"]
v3 = v1 + v2
print(v3) # ['赵四', '刘能', '宋晓峰', '范德彪']

2.相乘，列表*整形将列表中的元素在创建N份生成一个新的列表

data = ["赵四","刘能"] * 2
print(data) # ['赵四', '刘能', '赵四', '刘能']v1 = ["赵四","刘能"]
v2 = v1 * 2
print(v1) # ['赵四', '刘能']
print(v2) # ['赵四', '刘能', '赵四', '刘能']

3.运算int包含

由于列表内部是由多个元素组成，可以通过in来潘墩元素是否列表中。

user_list = ["狗子","二蛋","沙雕","Alex"]
result = "Alex" in user_list
print(result) # True
if "Alex" in user_list:print("在，在他删除")user_list.remove("Alex")
else:print("不在")

user_list = ["狗子","二蛋","沙雕","Alex"]
if "Alex" in user_list:print("在，在他删除")user_list.remove("Alex")
else:print("不在")text = "小倒小日本"data = "日" in text

案例

user_list = ["王宝强","陈羽凡","Alex","贾乃亮","Alex"]
if "Alex" in user_list:index = user_list.index("Alex")user_list.pop(index)

注意：列表检查元素是否存在时，是采用逐一比较的方式，效率会比较低。

4.获取长度

user_list = ["f范德彪","刘华强","尼古拉斯赵四"]
print( len(user_list))

5.索引，一个元素的操作

user_list = ["范德彪","刘华强","尼古拉斯赵四"]
print(user_list[0])
print(user_list[2])
print(user_list[3])

# 改
user_list = ["范德彪","刘华强","尼古拉斯赵四"]
user_list[0] = "无佩奇"
print(user_list)

# 删
user_list = ["范德彪","刘华强","尼古拉斯赵四"]
del user_list[1]
print(user_list)
user_list.remove("刘华强")
ele =user_list.pop(1)
print(user_list)

注意：超出索引范围会报错。

提示：由于字符串是不可变类型，所以他只有索引读的功能，而列表可以进行读，改、删

6.切片，多个元素的操作（很少用）

#读
user_list = ["范德彪","刘华强","尼古拉斯赵四"]
print(user_list[0:2]) #['范德彪', '刘华强']
print(user_list[1:]) #['刘华强', '尼古拉斯赵四']
print(user_list[:-1]) # ['范德彪', '刘华强']

# 改
user_list = ["范德彪","刘华强","尼古拉斯赵四"]
user_list[0:2] = [11,22,33,44]
print(user_list) #[11, 22, 33, 44, '尼古拉斯赵四']user_list = ["范德彪","刘华强","尼古拉斯赵四"]
user_list[2:] = [11,22,33,44]
print(user_list) #['范德彪', '刘华强', 11, 22, 33, 44]user_list = ["范德彪","刘华强","尼古拉斯赵四"]
user_list[3:] = [11,22,33,44]
print(user_list) #['范德彪', '刘华强', '尼古拉斯赵四', 11, 22, 33, 44]user_list = ["范德彪","刘华强","尼古拉斯赵四"]
user_list[10000:] = [11,22,33,44]
print(user_list) #['范德彪', '刘华强', '尼古拉斯赵四', 11, 22, 33, 44]user_list = ["范德彪","刘华强","尼古拉斯赵四"]
user_list[-10000:1] = [11,22,33,44]
print(user_list) #[11, 22, 33, 44, '刘华强', '尼古拉斯赵四']

7.步长

user_list = ["范德彪", "刘华强", "尼古拉斯赵四", "宋小宝", "刘能"]
#               0       1          2         3       4
print(user_list[1:4:2])  # ['刘华强', '宋小宝']
print(user_list[0::2])  # ['范德彪', '尼古拉斯赵四', '刘能']
print(user_list[1::2])  # ['刘华强', '宋小宝']
print(user_list[4:2:-1])  # ['刘能', '宋小宝']

# 案例：实现列表的翻转
user_list = ["范德彪", "刘华强", "尼古拉斯赵四", "宋小宝", "刘能"]
new_data = user_list[::-1]
print(new_data) #['刘能', '宋小宝', '尼古拉斯赵四', '刘华强', '范德彪']data_list = ["范德彪", "刘华强", "尼古拉斯赵四", "宋小宝", "刘能"]
data_list.reverse()
print(data_list)# ['刘能', '宋小宝', '尼古拉斯赵四', '刘华强', '范德彪']# 给你一个字符串请实现字符串的反转？
name = "无佩奇"
name = [::-1]

8.for循环

user_list = ["范德彪", "刘华强", "尼古拉斯赵四", "宋小宝", "刘能"]
for item in user_list:print(item)

user_list = ["范德彪", "刘华强", "尼古拉斯赵四", "宋小宝", "刘能"]
for index in range(len(user_list)):item = user_index[index]print(item)

切记，循环的过程中数据进行删除会踩坑【面试题】

# 错误方式，有坑，结果不是想要的。
user_list = ["刘的话","范德彪","刘华强","刘尼古拉斯赵四","宋小宝","刘能"]
for item in user_list:if item.startswith("刘"):user_list.remove(item)
print(user_list)

user_list = ["刘的话","范德彪","刘华强","刘尼古拉斯赵四","宋小宝","刘能"]
for index in range(len(user_list)-1,-1,-1):item = user_list[index]if item.startswith("刘"):user_list.remove(item)
print(user_list) # ['范德彪', '宋小宝']

1.4转换

• int、bool无法转成列表
• ste

name = "无佩奇"
data = list(name)
print(data) #['无', '佩', '奇']

• 超前

v1 = (11,22,33,44) # 元祖
vv1 = list(v1) # 列表
print(vv1) #[11, 22, 33, 44]
v2 = {"alex","eric","dsb"} # 集合
vv2 = list(v2) # 列表
print(vv2) # ['eric', 'dsb', 'alex']

1.5嵌套

列表属于容器，内部可以存放的各种数量，所以他也支持列表的嵌套，如：

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

对于嵌套的值，可以根据之前学习的索引知识点进行学习，例如：

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]

# 创建用户列表
# 用户列表应该长：[["alex","123"],["eric","666"]]
#user_list = [["alex","123"],["eric","666"]]
#user_list.append(["alex","123"])
#user_list.append("eric","666")user_list = []
while True:user = input("请输入用户名：")pwd = input("请输入密码")data = []data.append(user)data.append(pwd)user_list.append(data)

user_list = []
while True:user = input("请输入用户名(Q退出)：")if user == "Q":breakpwd = input("请输入密码：")data = [user,pwd]user_list.append(data)
print(user_list)

2.元祖(tuple)

元祖也是一个容器，里面可以存放各种数据，（和列表相似），但他有一个特殊的店：元祖的儿子元素不允许添加，不允许修改，不允许删除，只能读，一般用于存储一些在程序中不应该被修改的一系列值。

2.1元祖的定义

v1 = (11,22,33)
v2 = ("李杰","alex")
v3 = (True,123,"Alex",[11,22,33,44])
建议：在元祖的最好多加一个逗号v3 = ("李杰","alex",)

注意：建议在元祖的最后多加一个逗号，用于标识他是一个元祖。

# 面试题
1. 比较值 v1 = (1) 和 v2 = 1 和 v3 = (1,) 有什么区别？
2. 比较值 v1 = ((1),(2),(3)) 和 v2 = ((1,),(2,),(3,),) 有什么区别？

2.2独有功能

无

2.3公共功能

1.相加，两个列表相加获取生成一个新的列表

data = ("赵四","刘能") + ("宋晓峰","范德彪")
print(data) #('赵四', '刘能', '宋晓峰', '范德彪')
v1 = ("赵四","刘能")
v2 = ("宋晓峰","范德彪")
v3 = v1 +v2
print(v3) #('赵四', '刘能', '宋晓峰', '范德彪')

2.相乘，列表*整形将列表中的元素再创建N份并生成一个新的列表。

v1 = ("赵四", "刘能")
v2 = v1 * 2
print(v1)  # ('赵四', '刘能')
print(v2)  # ('赵四', '刘能', '赵四', '刘能')

3.获取长度

user_list = ("范德彪", "刘华能", "尼古拉斯赵四")
print(len(user_list)) #3

4.索引

user_list = ("范德彪", "刘华能", "尼古拉斯赵四")
print(user_list[0])
print(user_list[2])
print(user_list)[3] # 超出索引会报错

5.切片

user_list = ("范德彪", "刘华能", "尼古拉斯赵四")
print( user_list[0:2])
print(user_list[1:])
print(user_list[:-1])

6.步长

user_list = ("范德彪", "刘华能", "尼古拉斯赵四", "宋小宝", "刘能")
print(user_list[1:4:2])  # ('刘华能', '宋小宝')
print(user_list[0:2])  # ('范德彪', '刘华能')
print(user_list[1:2])  # ('刘华能',)
print(user_list[4:1:-1])  # ('刘能', '宋小宝', '尼古拉斯赵四')

字符串 & 元祖

user_list = ("范德彪", "刘华能", "尼古拉斯赵四", "宋小宝", "刘能")
data = user_list[::-1]

列表

user_list = ("范德彪", "刘华能", "尼古拉斯赵四", "宋小宝", "刘能")
data = user_list[::-1]user_list.reverse()
print(user_list)

7.for循环

user_list = ("范德彪", "刘华能", "尼古拉斯赵四", "宋小宝", "刘能")
for item in user_list:print(item)

user_list = ("范德彪", "刘华强", "尼古拉斯赵四", "宋小宝", "刘能")
for item in user_list:if item == "刘华强":continueprint(item)

目前：只有str、list、tuple可以被for循环。

user_list = ("范德彪", "刘华强", "尼古拉斯赵四", "宋小宝", "刘能")
for index in range(len(user_list)):item = user_list[index]print(item)

2.4转换

其他类型可以转换为元祖，使用tuple(其他类型)一般可以被循环的元素才能转换，目前我们学到的只有字符串和列表转换为元祖。

name = "武沛齐"
data = tuple(name)
print(data) # 输出 ("武","沛","齐")

name = ["无佩奇","18","pythonav"]
data = tuple(name)
print(data) #('无佩奇', '18', 'pythonav')

2.5嵌套

由于元祖和列表都可以充当容器,他们内部可以放很多元素，并且也支持元素内的各种嵌套。

tu = ('今天不在家','他们兄弟两在客厅聊天',('哥哥问弟弟税后与输入多少','弟弟说声到别提了'))
tu1 = tu[0]
tu2 = tu[1]
tu3 = tu[2][0]
tu4 = tu[2][1]
tu5 = tu[2][1][3]print(tu1) #今天不在家
print(tu2) #他们兄弟两在客厅聊天
print(tu3) #哥哥问弟弟税后与输入多少
print(tu4) #弟弟说声到别提了

总结

1.概述

• 列表，以后写程序会用的非常多，要多写多练
• 元祖，以后写程序用的不是很多，主要了解其他特殊和用法为主。

2.列表和元祖的区别。

3.可变类型和不可变类型。

4.列表独有功能&公共功能(不用特地去记，多做题目取用，以后每天都会有相关的练习题)。

5.列表和元祖等数据的嵌套。

6.元祖中(1)和(1,)的区别

6.元祖的元素不能被替换，但元祖的元素如果是可变类型，可变类型内部是可以修改的

Python第六天

数据类型

常见的数类型：

• int，整形类型（整形）

• bool，布尔类型

• str，字符串类型

• list，列表类型

• tuple 元祖类型

• dict，字典类型

• set，集合类型

• float，浮点类型（浮点型）

目标：掌握字典、集合、浮点类型相关知识

课程概要：

• set集合，一个不允许重复重复&可变乐行（元素可哈希）
• dict字典，一个容器切元素必须是键值对
• float类型，我们生活中常见的小数

1.集合(set)

集合是一个无序，可变、不允许数据重复的容器

1.1定义

v1 = {11,22,33,"alex"}

• 无序，无法通过索引取值。
• 可变，可以添加和删除元素

v1 = {11,22,33,44}
v1.add(55)
print(v1) #{33, 11, 44, 22, 55}

• 不允许数据重复

v1 = {11,22,33,44}
v1.add(22)
print(v1) #{33, 11, 44, 22}

一般什么时候用集合呢？

就是想要维护一大堆不重复的数据时，就可以用它，比如：做爬虫去网上找图片的链接，为了避免链接重复，可以选择用集合去存储链接地址。

注意：定义集合时，只能使用v = set()不能使用v={}这样时定义一个空字典

v1 = []
v2 = ()
v2 = tuple()
v3 = set()
v4 = {} # 空字典
v44 = dict{}

1.2独有功能

1.添加元素

data = {"刘嘉玲","关之琳","王祖贤"}
data.add("郑玉林")
print(data) #{'刘嘉玲', '郑玉林', '关之琳', '王祖贤'}data = set()
data.add("周杰伦")
data.add("林俊杰")
print(data) #{'林俊杰', '周杰伦'}

2.删除元素

data = {"刘嘉玲","关之琳","王祖贤","张曼玉","李若彤","刘亦菲"}
data.discard("关之琳")
print(data)

3.交集

s1 = {"刘能","赵四","皮长山"}
s2 = {"刘科长","冯乡长","皮长山"}
s4 = s1.intersection(s2)  # 去两个集合的交集
print(s4)s3 = s1 & s2 # 取两个集合的交集
print(s3)

4.并集

s1 = {"刘能","赵四","皮长山"}
s2 = {"刘科长","冯乡长","皮长山"}
s4 = s1.union(s2) # 取两个集合的并集
print(s4) #{'赵四', '刘科长', '皮长山', '刘能', '冯乡长'}s3 = s1 | s2
print(s3) #{'刘科长', '皮长山', '赵四', '冯乡长', '刘能'}

5.差集

s1 = {"刘能", "赵四", "皮长山"}
s2 = {"刘科长", "冯乡长", "皮长山"}
s4 = s1.difference(s2)
s6 = s2.difference(s1)s3 = s1 - s2
s5 = s2 - s1
print(s5,s6) #{'刘科长', '冯乡长'} {'刘科长', '冯乡长'}

1.3公共功能

1.减，计算差集

s1 = {"刘能", "赵四", "皮长山"}
s2 = {"刘科长", "冯乡长", "皮长山"}
s3 = s1 - s2
s4 = s2 - s1
print(s3) # {'刘能', '赵四'}
print(s4) # {'冯乡长', '刘科长'}

2.& ，计算交接

s1 = {"刘能", "赵四", "皮长山"}
s2 = {"刘科长", "冯乡长", "皮长山"}
s3 = s1 & s2
print(s3) # {'皮长山'}

1. |，计算并集

s1 = {"刘能", "赵四", "皮长山"}
s2 = {"刘科长", "冯乡长", "皮长山"}
s3 = s1 | s2
print(s3) # {'刘科长', '皮长山', '刘能', '冯乡长', '赵四'}

4.长度

v = {"刘能","赵四","尼古拉斯"}
data = len(v)
print(data) # 3

5.for循环

v = {"刘能","赵四","尼古拉斯"}
for item in v:print(item) # 尼古拉斯 赵四 刘能

1.4转换

其他类型如果想要转换为集合类型，可以通过set进行转换，并如果数据有重复自动删除。

提示：int/list/tuple/dict都可以转换为集合

v1 = "无佩奇"
v2 = set(v1)
print(v2) # {'无', '佩', '奇'}

v1 = [11,22,33,11,3,99.22]
v2 = set(v1)
print(v2) #{33, 3, 99.22, 11, 22}

v1 = (11,22,3,11)
v2 = set(v1)
print(v2) #{3, 11, 22}

提示：这其实也是去重的一个手段。

data = {11,22,33,3,99}
v1 = list(data) #
v2 = tulpe(data) #data = {11,22,33,3,99}
print(v1) # [33, 99, 3, 22, 11]
print(v2) # [33, 99, 3, 22, 11]

1.5其他

1.5.1集合的存储原理

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Eteckymk-1639822023852)(/Users/daihao/Library/Application Support/typora-user-images/image-20211212165446322.png)]

1.5.2元素必须可哈希

因存储原理，集合的元素必须是可哈希的值，即：内部通过哈希函数把值换成一个数字。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-9g33t4AF-1639822023852)(/Users/daihao/Library/Application Support/typora-user-images/image-20211212165514976.png)]

目前可哈希的数据类型：int、bool、tuple，而list是不可哈希的。

总结:集合的元素只能是int、bool、str、tuple、

• 转换成功

v1 = [11,22,33,11,3,99,22]
v2 = set(v1)
print(v2) #{33, 3, 99, 11, 22}

• 转换失败

v1 = [11,22,["alex","eric"],33]
v2 = set(v1)
print(v2) # 报错

1.5.3查找速度特别快

因存储原理特殊，集合的查找效率非常高（数据量大了才明显）

• 低

user_list = ["无佩奇","alex","李璐"]
if "alex" in user_list:print("在")
else:print("不在")user_tuple = ["无佩奇","alex","李璐"]
if "alex" in user_tuple:print("在")
else:print("不在")

• 效率高

user_set = ["无佩奇","alex","李璐"]
if "alex" in user_set:print("在")
else:print("不在")

1.5.4对比和嵌套

类型	是否可变	是否有序	元素要求	是否可哈希	转换	定义空
list	是	是	无	否	list(其他)	v=[]或v=list()
tuple	否	是	无	是	tuple(其他)	v=()或v=tuple()
set	否	否	可哈希	否	set(其他)	v=set

data_list = ["alex",11,(11, 22, 33, {"alex", "eric"}, 22),[11, 22, 33, 22],{11, 22, (True, ["中国", "北京"], "沙河"), 33}
]

注意：由于True和False本质上存储的是1和0，而集合又不允许重复，所以在整数0、1和False、True出现在集合中会会有如下现象：

v1 = {True, 1}
print(v1)  # {True}v2 = {1, True}
print(v2)  # {1}v3 = {0, False}
print(v3)  # {0}v4 = {False, 0}
print(v4)  # {False}

强插：None类型

python的数据类型中有一个特殊的值Node，意味着这个值啥都不是或，表示空。相当于其他语言中null作用一样。

在一定程度上可以帮助我们去节省内存。例如：

v1 = None
v2 = None
v1 = [11,22,33,44]
v2 = [111,22,43]

注意：暂不考虑Python内部的缓存和驻留机制。

目前所有转换为布尔值为Flase的值有：

()
""
[] or list[]
() or tuple()
set()
None

if None:pass

2.字典(dict)

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

data = {"k1":1, "k2":2}

• 容器
• 元素必须键值对
• 键不重复，重复会被覆盖

data = {"k1": 1, "k2": 2}
print(data) # {'k1': 1, 'k2': 2}

• 无序，（在Python3.6+字典就是有序了，之前的字典都是无序。）

data = {"k1": 1, "k2": 2}
print(data)

2.1定义

v1 = {}
v2 = dict()

data = {"k1":1,"k2":2
}

info = {"age":12,"status":True,"name":"wupeiqi","hobby":['篮球','足球']
}

字典中对键值的要求：

• 键：必须可哈希，目前为止学到的可哈希的类型：int/bool/str/tuple；不可哈希的类型：list/stt/dice。（集合）
• 值：任意类型

data_dict = {"无佩奇":29,True:5,123:5,(11,22,33):["alex","eric"]
}

错误写法

v1 = {[1,2,3]: '周杰伦',"age" : 18
}
v2 = {{1,2,3}: "哈哈哈"'name':"alex"
}v3 = {{"k1":123,"k2":456}: '呵呵呵'"age" ：999
}

data_dict = {1:29,True: 5
}
print(data_dict) #{1: 5}

一般在什么情况下会用到字典呢？

当我饿们想要表示一组固定信息时，用字典可以更加的直观，例如：

# 用户列表
user_list = [("alex","123"),("admin","888")]

# 用户列表
user_list = [{"name": "alex", "pwd": "123"}, {"name": "eric", "pwd": "123"}]

2.2独有功能

1.获取值

info = {"age":12,"status":True,"name":"无佩奇","data":None
}
data1 = info.get("name")
print(data1) # 输出：无佩奇data2 = info.get("age")
print(data2) # 输出：12data = info.get("email")
print(data) # 键不存在，默认返回None"""
if data ==None:print("此键不存在")
else:print(data)if data:print(data)
else:print("键不存在")
""""""
# 字典的键中是否存在email
if "email" in info:data = info.get("email")print(data)
else:print("不存在")
"""
data = info.get("hobby",123)
print(data) # 输出123

案例

data = info.get("hobby",123)
print(data) # 输出123user_list = {"无佩奇":"123","alex":"uk87",
}
username = input("请输入用户名：")
password = input("请输入密码：")
# None，用户名不存在
# 密码，接下来比较密码
pwd = user_list.get(username)
if pwd == None:print("用户名不存在")
else:if password == pwd:print("登录成功")else:print("密码错误")

案例2

user_list = {"wupeiqi": "123","alex": "uk87",
}
username = input("请输入用户名：")
password = input("请输入密码：")
# None，用户名不存在
# 密码，接下来比较密码
pwd = user_list.get(username)
if pwd:if password == pwd:print("登录成功")else:print("密码错误")
else:print("用户名不存在")

案例3：

ser_list = {"wupeiqi": "123","alex": "uk87",
}
username = input("请输入用户名：")
password = input("请输入密码：")
# None，用户名不存在
# 密码，接下来比较密码
pwd = user_list.get(username)
if not pwd:print("用户名不存在")
else:if password == pwd:print("登录成功")else:print("密码错误")
# 写代码的准则，简单的逻辑处理放在前面，复杂的逻辑放在后面

2.所有的键

info = {"age":12, "status":True,"name":"wupeiqi","email":"xx@live.com"}
data = info.keys() # 获取所有的键
print(data) # 输出：dict_keys(['age', 'status', 'name', 'email'])result = list(data)
print(result) # ['age', 'status', 'name', 'email']

注意：Python2中字典.keys()直接获取到的是列表，而Python3中返回的是高仿列表。这个高仿的列表可以被循环显示

info = {"age":12, "status":True,"name":"wupeiqi","email":"xx@live.com"}
for ele in info.keys():print(ele) # age status name email

是否存在

info = {"age":12, "status":True,"name":"wupeiqi","email":"xx@live.com"}
# info.keys() # dict_keys(['age', 'status', 'name', 'email'])
for age in info.keys():print("age是字典的键")
else:print("age不是")

3.所有的值

info = {"age":12, "status":True,"name":"wupeiqi","email":"xx@live.com"}
data = info.values() # 获取所有的值
print(data) # dict_values([12, True, 'wupeiqi', 'xx@live.com'])

注意：在python2中字典.values()直接获取到的是列表，而Python3中返回的是高仿列表，这个高仿的列表可以被循环显示

# 循环获取所有的值values
info = {"age":12, "status":True,"name":"wupeiqi","email":"xx@live.com"}
for val in info.values():print(val)
# 输出的结果
12
True
wupeiqi
xx@live.com

4.所有的键值

info = {"age":12, "status":True,"name":"wupeiqi","email":"xx@live.com"}
data = info.items()
print(data) # 输出：dict_items([('age', 12), ('status', True), ('name', 'wupeiqi'), ('email', 'xx@live.com')])

for item in info.items():print(item[0],item[1]) # item是一个元祖（键，值）# 输出结果 email xx@live.com

for key,value in info.items():print(key,value) # key代表键，value代表值，将键值从元祖中直接拆分出来了。
# 输出的结果
age 12
status True
name wupeiqi
email xx@live.com

5.设置值

# 不存在则会添加一个新的值
data = {"name":"无佩奇","email":'xx@live.com'
}
data.setdefault("age",18)
print(data) # {'name': '无佩奇', 'email': 'xx@live.com', 'age': 18}# 不会添加已存在的值
data.setdefault("name","alex")
print(data) # {'name': '无佩奇', 'email': 'xx@live.com', 'age': 18}

6.更新字典键值对

info = {"age":12, "status":True}
info.update({"age":14, "name":"无佩奇"}) # info中没有的键值直接添加，有的键值则更新值
print(info) # 输出：{'age': 14, 'status': True, 'name': '无佩奇'}

7.移除指定键值对

info = {"age":12, "status":True,"name":"无佩奇"}
data = info.pop("age")
print(info) # {'status': True, 'name': '无佩奇'}
print(data) # 12

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

info = {"age": 12, "status": True, "name": "无佩奇"}
data = info.popitem()  # ("name","无佩奇")
print(info) # {'age': 12, 'status': True}
print(data) # ('name', '无佩奇')

• python3.6以后，popitem移除最后的值。
• Python3.6之前, popitem随机删除

2.3公共功能

1.求并集(python3.9新加入)

v1 = {"k1": 1, "k2": 2}
v2 = {"k3": 22, "k4": 33}
v3 = v1 | v2
print(v3)  # {'k1': 1, 'k2': 2, 'k3': 22, 'k4': 33}

2.长度

info = {"age": 12, "status": True, "name": "无佩奇"}
data = len(info)
print(data) # 输出：3

3.是否包含

info = {"age": 12, "status": True, "name": "无佩奇"}
v1 = "age" in info
print(v1)v2 = "age" in info.keys()
print(v2)if "age" in info:pass
else:pass

info = {"age": 12, "status": True, "name": "无佩奇"}
v1 = "无佩奇" in info.values()
print(info)  # {'age': 12, 'status': True, 'name': '无佩奇'}

info = {"age": 12, "status": True, "name": "无佩奇"}
# 输出info.items()获取的 dict_items([ ('age',12), ('status',True), ('name','无佩奇','wupeqi'), ('email', 'xx@live.com') ])
v1 = ("age",12) in info.items()
print(v1)

4.索引（键）

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

info = {"age": 12, "status": True, "name": "无佩奇"}
print(info["age"])  # 输出 12
print(info["name"])  # 输出 无佩奇
print(info["status"])  # 输出 True
print(info["xxxxx"]) # 报错，通过键为索引获取之后时，键不存在会报错（以后项目开发时建议使用get方法根据键去获取值）

5.根据键。修改值和添加和删除键值对

上述是咧通过键可以找到字典中的值，通过键也可以对字典进行添加和更新操作

# 没有这个键值则添加
info = {"age": 12, "status": True, "name": "无佩奇"}
info["gender"] ="男"
print(info) #输出：{'age': 12, 'status': True, 'name': '无佩奇', 'gender': '男'}

info = {"age": 12, "status": True, "name": "无佩奇"}
info["age"] = "18"
print(info) # {'age': '18', 'status': True, 'name': '无佩奇'}

info = {"age": 12, "status": True, "name": "无佩奇"}
del info["age"]  # 删除info字典中键为age的那个键值对（键不存在则报错）
print(info) # 输出 ：{'status': True, 'name': '无佩奇'}

info = {"age": 12, "status": True, "name": "无佩奇"}
if "agea" in info:# del info["age"]data = info.pop("age")print(info)print(data)
else:print("键不存在")

6.for循环

由于字典也属于是容器，内部可以包含多个键值对，可以通过玄幻对其中的：键、值、键值进行循环；

info = {"age": 12, "status": True, "name": "无佩奇"}
for item in info:print(item) # 输出所有键

info = {"age": 12, "status": True, "name": "无佩奇"}
for item in info.keys():print(item)

info = {"age": 12, "status": True, "name": "无佩奇"}
for item in info.values():print(item)  # 输出所有值

info = {"age": 12, "status": True, "name": "无佩奇"}
for key,value in info.items():print(key,value) # 输出所有的键值

1.5其他

1.51存储原理

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-7l1qm33z-1639822023853)(/Users/daihao/Library/Application Support/typora-user-images/image-20211218102533352.png)]

1.5.2速度快

info = {"alex":["肝胆","铁锤"],"老男孩":["二蛋","缺货"]
}
for "alex" in info:print("在"）

info = {"alex":["肝胆","铁锤"],"老男孩":["二蛋","缺货"]
}
v1 = info["alex"]
v2= info.get("alex")

1.5.3嵌套

我们已学了很多数据类型，在涉及多种数据类型之间的嵌套时，需注意一下几点：

• 字典的键必须可哈希（list/set/dict不可哈希）。

  info = {(11,22):123
  }# 错误
  info = {(11,[11,22,],22):"alex"
  }
  

• 字典的值可以是任意类型。

  info = {"k1":{12,3,5},"k2":{"xx":"x1"}
  }
  

• 字典的键和集合的元素在遇到 布尔值 和 1、0 时，需注意重复的情况。

• 元组的元素不可以被替换。

dic = {'name':'汪峰','age':48,'wife':[ {'name':'国际章','age':38},{'name':'李杰','age':48} ],'children':['第一个娃','第二个娃']
}
"""
1. 获取汪峰的妻子名字d1 = dic['wife'][0]['name']print(d1)
2. 获取汪峰的孩子们d2 = dic['children']print(d2)
3. 获取汪峰的第一个孩子d3 = dic['children'][0]print(d3)
4. 汪峰的媳妇姓名变更为 章子怡dic['wife'][0]['name] = "章子怡"print(dic)
5. 汪峰再娶一任妻子dic['wife'].append( {"name":"铁锤","age":19} )print(dic)6. 给汪峰添加一个爱好：吹牛逼dic['hobby'] = "吹牛逼"print(dic)
7. 删除汪峰的年龄del dic['age']或dic.pop('age')print(dic)
"""

3.浮点型（float)

浮点型，一般在开发中用于表示小数

v1 = 3.14
v2 = 9.89

关于浮点型的其他知识点如下：

• 在类型转换时需要，在浮点型转换为整形时，会将小数部分去掉。

v1 = 3.14
data = int(v1)
print(data) # 3

• 想要保留小数点后N为

v2 = 3.1415926
result = round(v2,3)
print(result) #3.142

• 浮点型的坑（所有语言中）

v3 = 0.1
v4 = 0.2
v5 = v3 + v4
print(v5) # 0.30000000000000004

• 底层原理视频：https://www.bilibili.com/video/BV1354y1B7o1/

  在项目中如果遇到精确的小数计算应该怎么办？

import decimalv1 = decimal.Decimal("0.1")
v2 = decimal.Decimal("0.2")
v3 = v1 + v2
print(v3) # 0.3

总结

1. 集合，是 无序、不重复、元素必须可哈希、可变的一个容器（子孙元素都必须是可哈希）。

2. 集合的查找速度比较快（底层是基于哈希进行存储）

3. 集合可以具有 交并差 的功能。

4. 字典是 无序、键不重复 且 元素只能是键值对的可变的一个容器（键子孙元素都必须是可哈希）。

5. py3.6+之后字典就变为有序了。

6. py3.9 新增了一个 {} | {}运算。

7. 字典的常见功能。

8. 在python2和python3中，字典的 keys() 、values()、items() 三个功能获取的数据类型不一样。

9. None是代表内存中的一个空值。

   0
   ""
   [] or list()
   () or tuple()
   set()
   None
   {} or dict()
   

10. 浮点型用于表示小数，但是由于其内部存储原理可能会引发数据存储不够精准。

Python第七天总结和考试

课程目标：对第一模块 “Python基础” 阶段的知识点进行总结和考试，让学员更好的掌握此模块的相关知识。

课程概要：

• 代码规范
• 知识补充
• 阶段总结（思维导图）
• 考试题

1. 代码规范

程序员写代码是有规范的，不只是实现功能而已。

1.1 名称

在Python开发过程中会创建文件夹/文件/变量等，这些在命名有一些潜规则（编写代码时也要注意pep8规范）。

• 文件夹，小写 & 小写下划线连接，例如：commands、data_utils等。

• 文件，小写 & 小写下划线连接，例如：page.py、db_convert.py等。

• 变量

  • 全局变量，大写 & 大写下划线连接，例如：NAME = "武沛齐" 、BASE_NAME = 18
  • 局部变量，小写 & 小写下划线连接，例如：data = [11,22,33]、user_parent_id = 9等。

1.2 注释

作为程序员，写代码注释是非常基础且有用的技能，方便以后对代码进行维护和理解。

• 文件夹

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-w61S60gS-1639822023853)(/Users/daihao/Library/Application Support/typora-user-images/image-20211218175652667.png)]

• 文件注释

  """
  这个文件主要为项目提供工具和转换的功能，初次之外还有日志....
  例如：.........
  """....
  

• 代码注释

  name = "alex"
  # 在名称后面添加一个大烧饼
  data = name + "dsb"
  print(data)
  

  name = "alex"
  """
  在名称后面添加一个大烧饼，内部的实现机制：1. xxx2. xxx3. xx
  """
  data = name + "dsb"
  print(data)
  

1.3 todo

基于注释可以实现todo注释的效果，例如：

1.4 条件嵌套

以后写条件语句一定要想办法减少嵌套的层级（最好不要超过3层）。

1.5 简单逻辑先处理

示例1：

goods = [{"name": "电脑", "price": 1999},{"name": "鼠标", "price": 10},{"name": "游艇", "price": 20},{"name": "美女", "price": 998}
]
for index in range(len(goods)):item = goods[index]print(index + 1, item['name'], item['price'])while True:num = input("请输入要选择的商品序号(Q/q)：")  # "1"if num.upper() == "Q":breakif num.isdecimal():num = int(num)if 0 < num < 5:target_index = num - 1choice_item = goods[target_index]print(choice_item["name"], choice_item['price'])else:print("序号范围选择错误")else:print("用户输入的序号格式错误")

示例2：

goods = [{"name": "电脑", "price": 1999},{"name": "鼠标", "price": 10},{"name": "游艇", "price": 20},{"name": "美女", "price": 998}
]
for index in range(len(goods)):item = goods[index]print(index + 1, item['name'], item['price'])while True:num = input("请输入要选择的商品序号(Q/q)：")  # "1"if num.upper() == "Q":breakif not num.isdecimal():print("用输入的格式错误")breaknum = int(num)if num > 4 or num < 0:print("范围选择错误")breaktarget_index = num - 1choice_item = goods[target_index]print(choice_item["name"], choice_item['price'])

1.6 循环

尽量少循环多干事，提高代码效率。

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)

info = {'k1': 'v1', 'k2': 'v2', 'k3': 'v3'}key_list = list(info.keys())
value_list = list(info.values())

1.7 变量和值

# 推荐
name = "武沛齐"
age = 19

# 不推荐
name="武沛齐"
age= 18

可以基于Pycharm的格式化工具来实现自动处理。

python代码规范：PEP8规范。

2.知识补充

2.1 pass

一般Python的代码块是基于 : 和缩进来实现，Python中规定代码块中必须要有代码才算完整，在没有代码的情况下为了保证语法的完整性可以用pass代替，例如：

# 其他编程语言
if 提交{...
}else{....
}

if 条件 :pass
else:pass

if 条件:pass
else:pass

for i in range(xxx):pass

2.2 is 比较

is 和 ==的区别是什么？

• ==，用于比较两个值是否相等。
• is，用于表示内存地址是否一致。

# 示例1
v1 = []
v2 = []print( v1 == v2 )  # True，两个值相当
print( v1 is v2 )  # False，不属于同一块内存。

# 示例2
v1 = []
v2 = v1print( v1 == v2 )  # True，两个值相当
print( v1 is v2 )  # True，属于同一块内存。

# 示例3
v1 = None
v2 = Noneprint(v1 == v2)  # True，两个值相当
print(v1 is v2)  # True，属于同一块内存。

2.3 位运算

计算机底层本质上都是二进制，我们平时在计算机中做的很多操作底层都会转换为二进制的操作，位运算就是对二进制的操作。

• &，与（都为1）

  a = 60            # 60 = 0011 1100
  b = 13            # 13 = 0000 1101 c = a & b         # 12 = 0000 1100
  

• |，或（只要有一个为1）

  a = 60            # 60 = 0011 1100
  b = 13            # 13 = 0000 1101 c = a | b         # 61 = 0011 1101
  

• ^，异或（值不同）

  a = 60            # 60 = 0011 1100
  b = 13            # 13 = 0000 1101 c = a ^ b         # 49 = 0011 0001
  

• ~，取反

  a = 60            #  60 = 0011 1100 c = ~a;           # -61 = 1100 0011
  

• <<，左移动

  a = 60            #  60 = 0011 1100
  c = a << 2;       # 240 = 1111 0000
  

• >>，右移动

  a = 60            # 60 = 0011 1101
  c = a >> 2;       # 15 = 0000 1111
  

平时在开发中，二进制的位运算几乎很好少使用，在计算机底层 或 网络协议底层用的会比较多，例如：

• 计算 2**n

  2**0    1 << 0   1     1
  2**1    1 << 1   10    2
  2**2    1 << 2   100   4
  2**3    1 << 3   1000  8
  ...
  

• 计算一个数的一半【面试题】

  v1 = 10 >> 1
  print(v1) # 值为5v2 = 20 >> 1
  print(v2) # 值为 10
  

• 网络传输数据，文件太大还未传完（websocket源码为例）。

       第1个字节         第2个字节         ... 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
  +-+-+-+-+-------+-+-------------+-------------------------------+
  |F|R|R|R| opcode|M| Payload len |    Extended payload length    |
  |I|S|S|S|  (4)  |A|     (7)     |             (16/64)           |
  |N|V|V|V|       |S|             |   (if payload len==126/127)   |
  | |1|2|3|       |K|             |                               |
  +-+-+-+-+-------+-+-------------+ - - - - - - - - - - - - - - - +FIN位置是0，表示这是一部分数据，后续还有数据。
  FIN位置是1，表示这是最后数据，已发送完毕。
  

  # 例如：接收到的第一个字节的值为245（11110101），让v的二进制和 1000 0000 做 & 与运算。v = 245   # 245 11110101# 128 1000000010000000data = v & 128
  if data == 0:print("还有数据")
  else:print("已完毕")
  

3.阶段总结

可使用思维导图（ xmind 软件），对阶段知识点的内容进行梳理，将知识梗概和重点写出来，也便于以后的回顾和复习。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-4b2p74kq-1639822023853)(/Users/daihao/Library/Application Support/typora-user-images/image-20211218175822617.png)]
yle=“zoom: 33%;float:left;” />

1.5 简单逻辑先处理

示例1：

goods = [{"name": "电脑", "price": 1999},{"name": "鼠标", "price": 10},{"name": "游艇", "price": 20},{"name": "美女", "price": 998}
]
for index in range(len(goods)):item = goods[index]print(index + 1, item['name'], item['price'])while True:num = input("请输入要选择的商品序号(Q/q)：")  # "1"if num.upper() == "Q":breakif num.isdecimal():num = int(num)if 0 < num < 5:target_index = num - 1choice_item = goods[target_index]print(choice_item["name"], choice_item['price'])else:print("序号范围选择错误")else:print("用户输入的序号格式错误")

示例2：

goods = [{"name": "电脑", "price": 1999},{"name": "鼠标", "price": 10},{"name": "游艇", "price": 20},{"name": "美女", "price": 998}
]
for index in range(len(goods)):item = goods[index]print(index + 1, item['name'], item['price'])while True:num = input("请输入要选择的商品序号(Q/q)：")  # "1"if num.upper() == "Q":breakif not num.isdecimal():print("用输入的格式错误")breaknum = int(num)if num > 4 or num < 0:print("范围选择错误")breaktarget_index = num - 1choice_item = goods[target_index]print(choice_item["name"], choice_item['price'])

1.6 循环

尽量少循环多干事，提高代码效率。

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)

info = {'k1': 'v1', 'k2': 'v2', 'k3': 'v3'}key_list = list(info.keys())
value_list = list(info.values())

1.7 变量和值

# 推荐
name = "武沛齐"
age = 19

# 不推荐
name="武沛齐"
age= 18

可以基于Pycharm的格式化工具来实现自动处理。

python代码规范：PEP8规范。

2.知识补充

2.1 pass

一般Python的代码块是基于 : 和缩进来实现，Python中规定代码块中必须要有代码才算完整，在没有代码的情况下为了保证语法的完整性可以用pass代替，例如：

# 其他编程语言
if 提交{...
}else{....
}

if 条件 :pass
else:pass

if 条件:pass
else:pass

for i in range(xxx):pass

2.2 is 比较

is 和 ==的区别是什么？

• ==，用于比较两个值是否相等。
• is，用于表示内存地址是否一致。

# 示例1
v1 = []
v2 = []print( v1 == v2 )  # True，两个值相当
print( v1 is v2 )  # False，不属于同一块内存。

# 示例2
v1 = []
v2 = v1print( v1 == v2 )  # True，两个值相当
print( v1 is v2 )  # True，属于同一块内存。

# 示例3
v1 = None
v2 = Noneprint(v1 == v2)  # True，两个值相当
print(v1 is v2)  # True，属于同一块内存。

2.3 位运算

计算机底层本质上都是二进制，我们平时在计算机中做的很多操作底层都会转换为二进制的操作，位运算就是对二进制的操作。

• &，与（都为1）

  a = 60            # 60 = 0011 1100
  b = 13            # 13 = 0000 1101 c = a & b         # 12 = 0000 1100
  

• |，或（只要有一个为1）

  a = 60            # 60 = 0011 1100
  b = 13            # 13 = 0000 1101 c = a | b         # 61 = 0011 1101
  

• ^，异或（值不同）

  a = 60            # 60 = 0011 1100
  b = 13            # 13 = 0000 1101 c = a ^ b         # 49 = 0011 0001
  

• ~，取反

  a = 60            #  60 = 0011 1100 c = ~a;           # -61 = 1100 0011
  

• <<，左移动

  a = 60            #  60 = 0011 1100
  c = a << 2;       # 240 = 1111 0000
  

• >>，右移动

  a = 60            # 60 = 0011 1101
  c = a >> 2;       # 15 = 0000 1111
  

平时在开发中，二进制的位运算几乎很好少使用，在计算机底层 或 网络协议底层用的会比较多，例如：

• 计算 2**n

  2**0    1 << 0   1     1
  2**1    1 << 1   10    2
  2**2    1 << 2   100   4
  2**3    1 << 3   1000  8
  ...
  

• 计算一个数的一半【面试题】

  v1 = 10 >> 1
  print(v1) # 值为5v2 = 20 >> 1
  print(v2) # 值为 10
  

• 网络传输数据，文件太大还未传完（websocket源码为例）。

       第1个字节         第2个字节         ... 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
  +-+-+-+-+-------+-+-------------+-------------------------------+
  |F|R|R|R| opcode|M| Payload len |    Extended payload length    |
  |I|S|S|S|  (4)  |A|     (7)     |             (16/64)           |
  |N|V|V|V|       |S|             |   (if payload len==126/127)   |
  | |1|2|3|       |K|             |                               |
  +-+-+-+-+-------+-+-------------+ - - - - - - - - - - - - - - - +FIN位置是0，表示这是一部分数据，后续还有数据。
  FIN位置是1，表示这是最后数据，已发送完毕。
  

  # 例如：接收到的第一个字节的值为245（11110101），让v的二进制和 1000 0000 做 & 与运算。v = 245   # 245 11110101# 128 1000000010000000data = v & 128
  if data == 0:print("还有数据")
  else:print("已完毕")
  

3.阶段总结

可使用思维导图（ xmind 软件），对阶段知识点的内容进行梳理，将知识梗概和重点写出来，也便于以后的回顾和复习。

[外链图片转存中…(img-4b2p74kq-1639822023853)]

Python_day01-----day07相关推荐

1. Python基础day07 作业解析【文件操作(文件读写、文件夹操作)】

   视频.源码.课件.软件.笔记:超全面Python基础入门教程[十天课程]博客笔记汇总表[黑马程序员] Python基础day07[文件读写.文件夹操作.面向对象(类.对象)] 目录 加强训练 题目1 ...

2. 【168天】黑马程序员27天视频学习笔记【Day07】

   [168天]黑马程序员27天视频学习笔记[Day07] 叨逼叨两句 决定了,我会记住这一天! 07-01:构造方法Constructor概述和格式 构造方法概述和作用 给对象的数据(属性)进行初始化. ...

3. Python菜鸟入门：day07条件循环

   写在前面: 此博客仅用于记录个人学习进度,学识浅薄,若有错误观点欢迎评论区指出.欢迎各位前来交流.(部分材料来源网络,若有侵权,立即删除) 传送门: day01基础知识 day02知识分类 day03 ...

4. JAVA day07 权限，封装，JavaBean（规范代码），static、final关键字

   1.权限 在Java中提供了四种访问权限,使⽤不同的访问权限修饰符修饰时,被修饰的内容会有不同的访问权限: public:公共的 protected:受保护的 default(friendly):默认 ...

5. day07【后台】SpringSecurity

   day07[后台]SpringSecurity 1.权限控制框架 1.1.SpringSecurity 框架简介 用户登录系统时我们协助 SpringSecurity 把用户对应的角色. 权限组装好, ...

6. PYTHON1.day07

   day06回顾    列表      可变的序列容器    创建列表的方法:      字面值 [], [1, 2, 3]      构造函数 list() , list(range(10))     ...

7. 2020年12月-第02阶段-前端基础-CSS Day07

   CSS Day07 CSS高级技巧 理解 能说出元素显示隐藏最常见的写法 能说出精灵图产生的目的 能说出去除图片底侧空白缝隙的方法 应用 能写出最常见的鼠标样式 能使用精灵图技术 能用滑动门做导航栏案 ...

8. day07【Collection、泛型、数据结构】

   day07[Collection.泛型.数据结构] 反馈和复习 1.老师多照顾一下基础差的哥们 2.老师讲的太慢了 3.学生管理系统3遍 今日内容 今日+明日+后日(非常重要!!主要讲各种集合!!) ...

9. vue尚品汇商城项目-day07【vue插件-49.（了解）自定义插件】

   文章目录 49.(了解)自定义插件 本人其他相关文章链接 49.(了解)自定义插件 自定义插件好处: 功能:用于增强Vue 本质:包含install方法的一个对象,install的第一个参数是Vue, ...

10. day07 c++复习 核心编程02 核心内容（1、友元 2、3、继承 ）

    目录 全局函数做友元 类做友元 成员函数做友元 下一章是运算符重载,这章太难了,而且重要,单独出一版 继承 继承的基本语法 派生类中的成员,包含两大部分: 继承方式 继承中的对象模型 继承中构造和析构 ...

最新文章

1. 字典创建列表的2种方法，作业
2. Spring Cloud Alibaba基础教程：Sentinel使用Nacos存储规则
3. 9月26日数聚云端·智驭未来「阿里云数据库创新上云峰会」邀你进入数智未来
4. 【DP】[NOI2013]书法家
5. docker registry 镜像同步
6. 前端学习（2388）：封装请求模块
7. php异步表单,利用ajax实现表单的异步互动——2018年4月10日
8. pdf2htmlex linux,pdf2htmlEX Windows Version
9. 【一起看花书1.1】——第五章 机器学习基础
10. 如何（不开百度会员进行下载提速）合作双赢之路
11. Idea翻译插件google翻译失败超时
12. Linux面板对Linux系统维护（Linux运维）全网最详细
13. 什么是token以及token的原理
14. discuz模板介绍
15. windows系统用cmd命令开启WiFi共享功能
16. Android UI 绘制流程及原理
17. ios 编译ffmpeg 支持 x264 fdk-aac openssl 并裁剪库大小
18. CleanMyMac X真正好用的Mac电脑系统优化软件应用工具
19. matlab 中trace,trace命令和tracert命令的用途 matlab中的trace 怎么用的？
20. Android各类权限意思祥解

热门文章

1. ArcGIS Pro 关于地震数据可视化制作流程（附练习数据下载）
2. 外贸收款（解析重点）——上海赢支付wintopay
3. php 美颜,怀念以前无滤镜美颜的影视剧
4. flv格式转换为mp4(ffmpeg)
5. avformat_seek_file函数介绍
6. 手机号码测凶吉附带手机号码归属地C#版
7. 儿童视力档案小程序开发，视力“云管家”
8. Xcode 报错及解决办法汇总
9. python手机app开发_python可以开发app吗
10. 一年中最后一个月的最后一天说说_2020年最后一个月的朋友圈说说句子