day1 计算机基础和环境搭建

返回主页

课程目标：让大家了解计算机基础知识并完成Python的环境搭建。

课程概要：

1.计算机基础

1.1 基本概念

1.2 编程语言

软件，是由程序员使用 编程语言 开发出来的一大堆代码的集合。全球的编程语言有2500+多种，常见的编程语言：Java、C#、Python、PHP、C…

作文，是由小学生使用 汉语/英语/法语/日语… 写出来一大堆的文字的集合。

本质上学习编程语言就是学习他的语法，根据语法再去编写相应的软件中的功能。

1.3 编译器/解释器

编译器/解释器，就是一个翻译官，将代码翻译成计算机能够识别的命令。

A使用Python开发了一个软件 1000              B使用Golang开发了一个软件 2000

       Python解释器                        Golang编译器

                    操    作    系    统

               CPU    硬盘    网卡    内存    电源 .....

image

为什么有的叫解释器？有的叫编译器？

Python、PHP、JavaScript、Ruby…一般称为解释型语言。

C、C++、Go、Java…一般称为编译型语言。

2.学习编程的本质

学编程本质上就是三件事：

3.Python的介绍

3.1 语言的分类

注意：现在基本上都使用高级编程语言。

3.2 Python

Python的创始人为吉多·范罗苏姆（Guido van Rossum）。1989年的圣诞节期间，Guido开始写Python语言的编译器。Python这个名字，来自Guido所挚爱的电视剧Monty Python’s Flying Circus。他希望这个新的叫做Python的语言，能符合他的理想：创造一种C和shell之间，功能全面，易学易用，可拓展的语言。

全球众多编程语言，为何Python可以脱颖而出成为业界炙手可热的编程语言？目前位居TIOBE排行榜第三名并且一直呈上升趋势。

image

Python如此火爆的原因如下：

3.3 Python的解释器种类（了解）

想要学一门编程语言：安装Python解释器、学习python语法并编写代码、使用Python解释器去执行编写好的代码。

Python在全球非常的火，很多公司都会想要来层热度。

由于Python太火了，所有就有很多的公司都开发了Python解释器（用来翻译python代码成为计算机能够识别的命令）。

注意：常说的Python解释器默认指的就是CPython解释器。

3.4 CPython解释器的版本

CPython的解释器主要有两大版本：

4.环境搭建

4.1 安装Python解释器

4.1.1 windows系统

4.3 安装Pycharm编辑器（win)

总结

  1. 了解硬件 & 操作系统 & 软件（应用系统）之间的关系。
  2. 了解常见的操作系统都有哪些。
  3. 了解编译器和解释器的区别和作用。
  4. 编程语言进行分类
  5. 了解Python解释器的种类
  6. 了解CPython解释器的版本
  7. 学会如何安装Python解释器。
  8. 了解什么环境变量的作用。
  9. 了解Python和Pycharm的区别。

day2 一点数据类型

1.编码

编码有

utf-8和gbk

就用utf-8就行了

2.输出

print（）

3.认识一点数据类型

3.1整形（int）

就是数字

可以加减乘除

3.2字符串（str）

用 “ “这个括起来的就是字符串

例： “sb”这个就是

可以加 ， 乘

3.3布尔类型（bool）

就两个True，False

3.4类型转换

类型总结

3.4.1转整形（十进制数字）

int（东西）

进制转整形

int（“2或8或16进制的东西”，base = “2或8或16进制”）

扩展：

整数转2或8或16进制：

	2进制

	bin（“整形”）

	8进制：

	oct（“整形”）

	16进制：

	hex（“整形”）

3.4.2转字符串

str（”东西“）

3.4.3转布尔

bool（“东西”）

4变量规范

三个规范（只要有一条就会报错）：

全局变量用大写，局部变量用小写

day03，循环

1. 循环有while，for

1.1while：

1.2break

1.3 continue

1.4 while else语句

2.字符串格式化

字符串格式化有三种方式：%，format ，f “ “

一般用第三个，第二个比较少用，

f “ “方法是3.X版本的东西

2.1 format

text = "我叫{0}，今年18岁".format("杨昌辉")

text = "我叫{0}，今年{1}岁".format("杨昌辉",18)

text = "我叫{0}，今年{1}岁，真是的姓名是{0}。".format("杨昌辉",18)

2.2 f “ “

# 理解
text = f"我是{'alex'}，我爱大铁锤"

name = "alex"
text = f"我是{name}，我爱大铁锤"

name = "alex"
text = f"我是{ name.upper() }，我爱大铁锤"

# 输出：我是ALEX，我爱大铁锤

3.运算符

3.1运算符

提到运算符，我想大家首先想到的就是加、减、乘、除之类， 本节要系统的跟大家来聊一聊，我们写代码时常见的运算符可以分为5种：

3.2优先级

上述这3个优先级从高到低总结：加减乘除 > 比较 > not and or 。绝招：加括号。

算数：

and：

or：

再次注意：加减乘除 > 比较 > not > and > or

day4进制与编码

课程目标：讲解计算机中一些必备的常识知识，让学员了解一些常见名词背后的含义（重在理解）。

课程概要：

1.Python代码运行方式

image

2.进制

计算机中底层所有的数据都是以 010101的形式存在（图片、文本、视频等）。

image

2.1 进制转换

image

v1 = bin(25) # 十进制转换为二进制
print(v1) # "0b11001"

v2 = oct(23) # 十进制转换为八进制
print(v2) # "0o27"

v3 = hex(28) # 十进制转换为十六进制
print(v3) # "0x1c"

i1 = int("0b11001",base=2) # 25

i2 = int("0o27",base=8) # 23 

i3 = int("0x1c",base=16) # 28

3. 计算机中的单位

由于计算机中本质上所有的东西以为二进制存储和操作的，为了方便对于二进制值大小的表示，所以就搞了一些单位。

做个小练习：

4 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()

5.总结

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

  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)

day5数据类型（int,bool,str）

数据类型有：

1.整形（int）

1.1定义

就是数字：123456789

1.2方法

bin

1.3功能

加减乘除

+-*/

1.4转换

可以将字符串“123”

		布尔类型“True” =1

		浮点数

和2,8,16进制转换成整数

v1 = int("0b1001",base = 2)
#把“2”换成8,16就行了
v2 = int(3.9)#3

1.5补充：

在python2中

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

2.布尔类型（bool）

2.1定义

True or False

2.2转换

任何非空的东西为True

None，0，“”为False，“ ”为True

2.3补充

用于if，while的判断上

3.字符串类型（str）

不可变类型，有序

3.1定义

"你好"

3.2方法

1.判断是否为“XX”开头 : startswith(“XX”) ——> bool

2.判断是否为“XX”结尾：endswith(“XX”) ——> bool

3.判断字符串是否为整形：isdecimal()——> bool

4.去除字符串两边的空格、换行符、制表符：strip去除全部

																	  **lstrip去除左边**

																	  **rstrip去除右边**

																	   返回——> new_str

5.字符串变大写：upper——>new_str

6.字符串变小写：lower——>new_str

7.字符串内容替换，replace（”原文中的字符串”，”要改成的字符串”）——>new_str

8.字符串切割：split(‘符号’,”要切几个符号(不写为全切)”)——>list

(前面加“r”从右切)(“l”从左切)split

9.拼接字符串：“符号”. join(列表)——>new_str

10.字符串格式：format（）

11.字符串转字节类型：encode（“编码形式,如utf-8”）——>new_str

12将字符串内容居中、居左、居右展示：center(居中),ljust(居左),rjust(居右) ——> new_str

v1 = "王老汉"
# data = v1.center(21, "-")
# print(data) #---------王老汉---------

# data = v1.ljust(21, "-")
# print(data) # 王老汉------------------

# data = v1.rjust(21, "-")
# print(data) # ------------------王老汉

13.帮助你填充0：zfill（补几个0，数字） ——> new_str

用于二进制处理

day6数据类型（list，tuple）

1.列表（list）

列表（list），是一个有序且可变的容器，在里面可以存放多个不同类型的元素。

1.1定义

v1 = ["猪","狗"]
v2 = [1,2,3]

1.2方法

1.在原列表追加一个值：append

v1 = [1,2,3]
v1.append(4)
print(v1)#[1,2,3,4]

2.追加一个列表(将列表元素逐一添加入列表)：extend

v1 = [1,2,3]
v2 = [4,5,6]
v1.extend(v2)# 或 v1.extend(4,5,6])
print(v1)#[1,2,3,4,5,6]

3.根据索引位置插入值：insert(索引，要传的东西)

v1 = [1,2,3,4,5,6]
v1.insert(0,0)
v1.insert(2,"x")
print(v1)#[0,1,"x",2,3,4,5,6]

4.删除一个原列表中的值，从左到右找删除第一个，没有参数或参数不存在则报错，慎用：remove(要删除的东西)

v1 = [1,2,3,4,5,6]
v1.remove(1)
v1.remove(8)#报错
print(v1)#[2,3,4,5,6]

5.根据索引位置删除值，并返回这个值：pop（索引）

v1 = [1,2,3,4,5,6]
#索引  0 1 2 3 4 5
v2 = v1.pop(2)
print(v1)#[1,2,4,5,6]
print(v2) # 3

6.清空列表：clear（）：

#清空列表
v1 = [1,2,3,4,5,6]
v1.clear()
print(v1)#[]

#删除列表
del v1
print(v1)#报错

7.根据值获取索引，从左到右找，没有参数或参数不存在则报错：index

v1 = [1,2,3,4,5,6]
v2 = v1.index(3)
print(v2) # 2

8.列表元素排列: sort() 注：sort()数学是从小到大，从大到小sort(reverse == True)，字符串和其他类型是以二进制的小排列的

v1 = [2,3,4,7,5,6,1,0]
v1.sort()
print(v1)#[0,1,2,3,4,5,6,7]
v1.sort(reverse == True)
print(v1)#[7,6,5,4,3,2,1,0]

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

9.翻转原列表：reverse()

v1 = [0,1,2,3,4,5,6,7]
v1.reverse()
print(v1) # [7,6,5,4,3,2,1,0]

1.3功能

1.相加，两个列表相加新生成一个新列表：

v1 = [1,2,3]
v2 = [4,5,6]
v3 = v1 + v2
print(v2)#[1,2,3,4,5,6]

2.相乘

v1 = ["猪","狗"]
v2 = v1 * 2
print(v2)#["猪","狗","猪","狗"]
  1. in：判断是否是列表的元素
v1 = ["猪","狗"]
v2 = "狗" in v1
print(v2)#True

4.获得长度

v1 = [0,1,2,3,4,5,6,7]
v2 = len(v1)
print(v2) # 8

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]

user_list.remove("刘华强")
ele = user_list.pop(1)

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, '刘华强', '尼古拉斯赵四']

# 删
user_list = ["范德彪", "刘华强", '尼古拉斯赵四']
del user_list[1:]
print(user_list) # 输出 ['范德彪']

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:1:-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:
    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转换

其他的类型转列表都没什么意义

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,),) 有什么区别？
              (1,2,3)

2.2方法、

没有滚

2.3功能

1.相加与列表一致（去看列表吧）

2.相乘与列表一致（去看列表吧）

3.获取长度（去看列表吧）

4.索引，切片，步长都是只能读不能改，与列表一致（去看列表吧）

2.4转换（懒了）

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

data = tuple(其他)

# str / list 

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) # 小姨子低声说道说和姐夫还提钱

day7（set,dict,froat）

1.集合（set）

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

1.1定义

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

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

什么时候用集合？

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

1.2 方法

  1. 添加元素

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

  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) 		# 差集，s1中有且s2中没有的值 {"刘能", "赵四"}
s6 = s2.difference(s1)   	# 差集，s2中有且s1中没有的值 {"刘科⻓", "冯乡⻓"}
   
s3 = s1 - s2   			   # 差集，s1中有且s2中没有的值
s5 = s2 - s1   			   # 差集，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)

  5. fof

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

1.5集合的那些事

1.5.1集合的存储原理

image

1.5.2 元素必须可哈希

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

image

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

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

1.5.3 查找速度特别快

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

None类型

Python的数据类型中有一个特殊的值None，意味着这个值啥都不是 或 表示空。 相当于其他语言中 null作用一样。 在一定程度上可以帮助我们去节省内存

None就是无的意思，啥也没有

None在判断里是False

2.字典（dict）

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

2.1定义

字典中对键值得要求：

#定义一个字典
v1 = {}
#或是
v2 = dict()

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

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

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

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

2.2方法

1.获取字典指定“键”的值：get（“键”） –> str

info = { 
    "age":12, 
    "status":True, 
    "name":"杨昌辉",
    "data":None
}
data1 = info.get("name")
print(data1) # 输出：杨昌辉

2.获取字典所有键：keys() –>高仿列表

info = { 
    "age":12, 
    "status":True, 
    "name":"杨昌辉",
    "data":None
}
a = info.keys()
print(a) #dict_keys(['age', 'status', 'name', 'data'])

#高仿列表可以for循环
for i in a:
	print(i)
#输出
age
status
name
data

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

3.获取字典所有的值values(): –>高仿列表

info = { 
    "age":12, 
    "status":True, 
    "name":"杨昌辉",
    "data":None
}
a = info.values()
print(a) #dict_values([12, True, '杨昌辉', None])

#高仿列表可以for循环
for i in a:
	print(i)
    
#输出
12
True
杨昌辉
None

4.获取字典所有的键值:items() –>高仿列表

info = { 
    "age":12, 
    "status":True, 
    "name":"杨昌辉",
    "data":None
}
a = info.items()
print(a) #dict_items([('age', 12), ('status', True), ('name', '杨昌辉'), ('data', None)])


for i in a:
	print(i)
    
#输出
('age', 12)
('status', True)
('name', '杨昌辉')
('data', None)

5.更新字典键值对(无则添加，有则更新)：update

info = {"age":12, "status":True}
info.update({"eng": 123})
print(info)
#输出
{"age":12, "status":True，"eng": 123}

6.设置值(有键则什么也不干，没有键则添加键值对) : setdefault

data = {
    "name": "杨昌辉",
    "email": 'xxx@live.com'
}
data.setdefault("age", 18)
print(data)  
#输出： {'name': '杨昌辉', 'email': 'xxx@live.com', 'age': 18}

data.setdefault("name", "alex")
print(data)
#输出：{'name': '杨昌辉', 'email': 'xxx@live.com', 'age': 18}

7.移除指定键值对,并返回该键的值：pop(“键”)：–> 值

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","杨昌辉")

2.3公共功能

  1. 求并集（Python3.9新加入）

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

  2. 长度：len ( )

    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)#True

    4.索引（键）

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

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

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

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

    info = {"age":12, "status":True,"name":"杨昌辉"}
#添加
info["gender"] = "男"
print(info) 
# 输出：
{"age":12, "status":True,"name":"杨昌辉","gender":"男"}
   
#更新
info["age"] = "18" 
print(info) 
# 输出： 
{"age":"18", "status":True,"name":"杨昌辉"}
   
#删除
del info["age"]  # 键不存在则报错
   
print(info) 
# 输出： 
{"status":True,"name":"杨昌辉"}

2.4 其他

2.4.1 存储原理

与集合一样

image

所以速度快

2.4.2 速度快

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

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

3.浮点型（float）的坑

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

v1 = 3.14
v2 = 9.89

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

image

底层原理视频：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