Python_day01-----day07

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("登陆失败")

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

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

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

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 = False
    else:
        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 + num
        num = num + 1
        print(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("红旗飘飘，军号响。")
    break
    print("剑已出鞘，雷鸣电闪。")
    print("从来都是狭路相逢勇者胜。")
print("结束")

示例2：

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

示例3：

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

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

continue关键字

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

continue用法

while True:
    ...
    continue
    ...

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

示例1：

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

示例:2

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

示例3：

print("开始")
i = 1
while True:
    if i == 7:
        i = i + 1
        continue
    print(i)
    i = i + 1
    if 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 True
    print(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 = 1

v5 = 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 6
     0 or 3 or 7 or 9 and 6
     0 or 3 or 7 or 6
     3 or 7 or 6
     3 or 6
     3
v2 = 8 or 3 and 4 or 2 and 0 or 9 and 7
		 8
  
  
v3 = 0 or 2 and 3 and 4 or 6 and 0 or 3
		 4

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

v4 = not 8 or 3 and 4 or 2
		 4

总结

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

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

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

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

count = 0
while count < 3:
    count += 1
    age = input("请输入与年龄：")
    age = int(age)
    if age == 73:
        print("恭喜你才对了")
        break
    else:
        print("猜错了")
    if count == 3:
        choice = input("输入Y游戏继续/输入游戏结束N：")
        if choice == "N":
            break
        elif choice == "Y":
            count = 0
            continue
        else:
            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位 = 5b
      011011010 就是 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        0
  00000001        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 ~ ffffffff
  ucs4中字符和码位的具体对应关系参见：
      https://unicode-table.com/en/#00A5
      https://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              0XXXXXXX
   0080 ~ 07FF              110XXXXX 10XXXXXX
   0800 ~ FFFF              1110XXXX 10XXXXXX 10XXXXXX
  10000 ~ 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    6
    0110 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)  # 3

v2 = 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) # 4

from __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 值:
   pass

while 值:
   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()) # True

v2 = "①"
print(v2.isdecimal()) # False

v3 = "123"
print(v3.isdigit()) # True

v4 = "①"
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]) # 来做点py

print(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)
        break
    else:
        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":
        continue
    print(char)

# 结果为
来
做
点
y
交
易
呀

message = "来做点py交易呀"
for char in message:
    if char == "p":
        break
    print(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)
        break
    else:
        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":
        break
    if 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:
        break
    print(user_list)

案例：自动抽奖程序

import random
data_list = ["iphone12","耳机","mp3","mp4","谢谢惠顾"]
while data_list:
    name = input("自动抽奖程序，请输入自己的姓名：")
    # 随机data_list抽取一个值出来
    value = random.choice(data_list) # iphone12
    print("恭喜{},抽中{}".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":
        break
    user_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":
        break
    pwd = 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 == "刘华强":
        continue
    print(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) # {'皮长山'}

3. |，计算并集

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) # 输出：12

data = 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) # 输出123

user_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 decimal

v1 = 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. xxx
      2. xxx
      3. 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":
        break
    if num.isdecimal():
        num = int(num)
        if 0 < num < 5:
            target_index = num - 1
            choice_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":
        break
    if not num.isdecimal():
        print("用输入的格式错误")
        break
    num = int(num)

    if num > 4 or num < 0:
        print("范围选择错误")
        break
    target_index = num - 1
    choice_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 = v1

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

# 示例3
v1 = None
v2 = None

print(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) # 值为5
  
  v2 = 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 10000000
                  10000000
      
  data = 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":
        break
    if num.isdecimal():
        num = int(num)
        if 0 < num < 5:
            target_index = num - 1
            choice_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":
        break
    if not num.isdecimal():
        print("用输入的格式错误")
        break
    num = int(num)

    if num > 4 or num < 0:
        print("范围选择错误")
        break
    target_index = num - 1
    choice_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 = v1

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

# 示例3
v1 = None
v2 = None

print(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) # 值为5
  
  v2 = 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 10000000
                  10000000
      
  data = v & 128
  if data == 0:
      print("还有数据")
  else:
      print("已完毕")
  

3.阶段总结

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

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