python的基本数据类型

---

1.几个概念

1.1 表达式

形如：

1 + 2
1
'
运行
运行

1.1.2表达式的定义

由数字、算符、数字分组符号（括号）、自由变量和约束变量等以能求得数值的有意义排列方法所得的组合

1.1.2 表达式特点

• 表达式一般仅仅用于计算一些结果，不会对程序产生实质性的影响
• 类似于数学式子
• 如果在交互模式中输入一个表达式，解释器会自动将表达式的结果输出

1.2 语句

• 一个语法上自成体系的单位，它由一个词或句法上有关连的一组词构成
• 语句的执行一般会对程序产生一定的影响,在交互模式中不一定会输出语句的执行结果

# 语句
input('请输入：')  # 输入语句
print(111)  # 打印语句

i = 6
if i < 5:  # if判断语句   只有符合判断语句的条件的时候，才会进入到if语句内部去执行代码, 后面的代码是一个tab或者四个空格的距离
    # pass  # pass做占位的作用
    # if语句里面的代码，我们称呼为一个代码块， 代码块要么都执行，要么都不执行
    print('abc')

1
2
3
4
5
6
7
8
9
10
'
运行
运行

1.3 程序（program）

• 程序就是由一条一条的语句和一条一条的表达式构成的。

1.4 函数（function）

# 函数
# 形如：def xxx():
#          pass

# 内置函数  built in 内建函数
1
2
3
4
5
'
运行
运行

1.4.1 函数的定义

• 函数就是一种语句，函数专门用来完成特定的功能
• 函数长的形如：xxx()

1.4.2 函数的分类

• 内置函数 : 或者内建函数，就是由语法规定存在的函数，这些函数，包含在编译器的运行时库中，程序员不比单独书写代码实现它，只需要调用既可。
• 自定义函数 : 由程序员自主的创建的函数 当我们需要完成某个功能时，就可以去调用内置函数，或者自定义函数

1.4.3 函数的两个要素

• 参数
• 返回值

1.5 注释

当运行程序的时候，你如果不想要某一行代码执行，你可以直接注释他，那么注释的哪一行代码将不再执行

1.6 调试

打断的方式，称呼为调试，就是帮你解决代码有问题的情况

1.7 可变类型与不可变类型

1.7.1 可变类型

1.7.1.1 定义

里面的元素改变了，但是他的id还是不会变化

1.7.1.2 包含

• 列表
• 字典
• 集合

1.7.2 不可变类型

1.7.2.1 定义

里面的元素改变了，而且他的id也就发生了变化

1.7.2.2 包含

• int
• float
• 字符串
• 元组

2.标识符

2.1 关键字

• python一些具有特殊功能的标识符，这就是所谓的关键字关键字，是python已经使用的了，所以不允许开发者自己定义和关键字相同的名字的标识符

2.2 标识符概念

• 开发人员在程序中自定义的一些符号和名称。标识符是自己定义的,如变量名 、函数名等

2.3 标识符的组成

26个英文字母大小写
数字： 0-9
符号： _$

2.4 标识符的规则:

• 标识符中可以包含字母、数字、_，但是不能使用数字开头 例如：name1 name_1 _name1 1name（不行）
• Python中不能使用关键字和保留字来作为标识符

2.5 命名方式

2.5.1 驼峰命名法

• 小驼峰式命名法： 第一个单词以小写字母开始；第二个单词的首字母大写，例如：myName、aDog
• 大驼峰式命名法： 每一个单字的首字母都采用大写字母，例如：FirstName、LastName

2.5.2 下划线命名法

• 不过在程序员中还有一种命名法比较流行，就是用下划线“_”来连接所有的单词。比如 get_url buffer_size

3.变量

3.1 变量的概念

• 变量是计算机内存中的一块区域，存储规定范围内的值，值 可以改变，通俗的说变量就是给数据起个名字。

3.2变量命名规则

• 变量名由字母、数字、下划线组成要符合标识符的命名规范
• 数字不能开头
• 不能使用关键字

3.3 注意 :

• 两个对象相等和两个对象是同一个对象是两个概念
• 变量是可以是很多的数据类型的， 不仅仅局限于整数

3.4 变量的判断

判断两个变量是不是同一个变量 ，判断的是他们的id是否相等

a = 1
b = 1
print(id(a), id(b))
1
2
3
'
运行
运行

输出结果如下：

1700228112 1700228112

a = 12343454356456
b = 12343454356456
print(id(a), id(b))
1
2
3
'
运行
运行

输出结果如下：

2037718433520 2037718433520

d = [1, 2, 3]
c = [1, 2, 3]
print(d is c)  # 判断的是id
print(d == c)  # 判断的是值

1
2
3
4
5
'
运行
运行

输出结果如下：

False
True

d = [1, 2, 3]
c = [1, 2, 3]
print(id(d), id(c))
1
2
3
'
运行
运行

输出结果如下：

1785047241032 1785048082056

4.基本数据类型

数据类型指的就是变量的值的类型，也就是可以为变量赋哪些值

4.1 数字类型

4.1.1 整数(int)

所有整数 例如 : a = 1 b = 100 c =999 都是int类型

a=1
b=100
c=999
print(type(a))
print(type(b))
print(type(c))
1
2
3
4
5
6
'
运行
运行

输出结果如下：

<class 'int'>
<class 'int'>
<class 'int'>
1
2
3

4.1.2 浮点型(float)

所有小数 例如 a = 1.2 b=6.66 用float类型表示

a=1.2
b=6.66
print(type(a))
print(type(b))
1
2
3
4
'
运行
运行

输出结果如下：

<class 'float'>
<class 'float'>
1
2

4.1.3 复数类型(Complex)

基本不用，但是存在，a+bj的形式，其中a,b为数值

a=1+2j
print(type(a))
1
2
'
运行
运行

输出结果如下：

<class 'complex'>
1

4.2 字符串类型(str)

4.2.1 字符串基础知识

Python中的字符串用单引号 ’ 或双引号 " 括起来，同时使用反斜杠 \ 转义特殊字符
加号 + 是字符串的连接符， 星号 * 表示复制当前字符串，与之结合的数字为复制的次数。实例如下：

a='abcde'
print(type(a))
print(a+'fghijk')  # 用“+”进行字符串的拼接
print(a*2)
print(a[0:-1])    # 输出第一个到倒数第二个的所有字符
print(a[0])       # 输出字符串第一个字符
print(a[2:5])     # 输出从第三个开始到第五个的字符
print(a[2:])      # 输出从第三个开始的后的所有字符

print('abcd\ne')  # 使用反斜杠 \ 转义特殊字符，如果你不想让反斜杠发生转义，可以在字符串前面添加一个 r，表示原始字符串：
print(r'abcd\ne') # 反斜杠(\)可以作为续行符，表示下一行是上一行的延续。也可以使用 """...""" 或者 '''...''' 跨越多行。
1
2
3
4
5
6
7
8
9
10
11
'
运行
运行

输出结果如下：

<class 'str'>
abcdefghijk
abcdeabcde
abcd
a
cde
cde
abcd
e
abcd\ne
1
2
3
4
5
6
7
8
9
10

4.2.2 字符串格式化

格式化字符串时，python使用一个字符串作为模板。模板中有格式符，这些格式符为真实值预留位置，并说明真实数值应该呈现的格式。python用一个tuple将多个值传递给模板，每个值对应一个格式符。

4.2.3注意：

1、反斜杠可以用来转义，使用r可以让反斜杠不发生转义。
2、字符串可以用+运算符连接在一起，用*运算符重复。
3、Python中的字符串有两种索引方式，从左往右以0开始，从右往左以-1开始。
4、Python中的字符串不能改变。

4.2.4 字符串的拆包

a = 'abcde'
b, *c = a
print(b, c)
1
2
3
'
运行
运行

运行结果如下：

>>> a ['b', 'c', 'd', 'e']
1

4.3 逻辑类型

4.3.1 布尔类型(Boolean)

只有两个值一个是True 一个是False

a=True
print(type(a))
1
2
'
运行
运行

输出结果如下：

<class 'bool'>
1

4.4 空值(None变量)

只有一个数值就是None 也就是空值

4.5 列表(list)

4.5.1 列表的定义

List（列表） 是 Python 中使用最频繁的数据类型。
列表使用[]来表示的 用list来表示

list1 = [1, 'python', True, None]
print(list1, type(list1))
1
2
'
运行
运行

列表就是用来存储对象的对象

4.5.2 列表的特点

1.列表可以完成大多数集合类的数据结构实现。
2.列表是写在方括号 [] 之间、用逗号分隔开的元素列表。
eg:

m=['a','b','c','d']
1
'
运行
运行

3.列表中元素的类型可以不相同，它支持数字，字符串甚至可以包含列表（所谓嵌套）
4.和字符串一样，列表同样可以被索引和截取，列表被截取后返回一个包含所需元素的新列表。
5.list [ ] 有序可修改

4.5.3 列表截取的语法格式

变量[头下标:尾下标]

索引值以 0 为开始值，-1 为从末尾的开始位置。

4.5.4 取数据

通过索引来取数据

list1 = [1, 'python', True, None]
print(list1[0])
print(list1[-1])
print(list1[-2])
print(list1[-3])
print(len(list1))

[运行结果如下]
1
None
True
python
4
1
2
3
4
5
6
7
8
9
10
11
12
13

4.5.5 列表的创建

创建空列表

list1 = []
print(list1)
1
2
'
运行
运行

4.5.6 列表的切片

4.5.6.1 语法

str[]
list[起始索引：结束索引：步长]

4.5.6.2 实例

list1 = ['孙悟空', '猪八戒', '白龙马', '白骨精', '蜘蛛精', '铁扇公主']
print(list1[3:5])
print(list1[-2:-4:-1])

>>> ['白骨精', '蜘蛛精']
    ['蜘蛛精', '白骨精']
1
2
3
4
5
6

4.5.7 列表的修改方法

4.5.7.1 添加元素

list.append() 向类表中最后的位置插入一个元素

list1 = ['孙悟空', '猪八戒', '白龙马', '白骨精', '蜘蛛精', '铁扇公主', '铁扇公主', '铁扇公主']
list1.append('女儿国国王')
print(list1)

[输出结果如下：]
>>> ['孙悟空', '猪八戒', '白龙马', '白骨精', '蜘蛛精', '铁扇公主', '铁扇公主', '铁扇公主', '女儿国国王']
1
2
3
4
5
6

4.5.7.2 插入元素

list.insert() 向列表中的指定位置插入一个元素，第一个参数是要插入的位置，第二个参数是要插入的内容

list2 = ['孙悟空', '猪八戒', '白龙马', '白骨精', '蜘蛛精', '铁扇公主', '铁扇公主', '铁扇公主']
list2.insert(4, '唐僧')
print(list2)

>>> ['孙悟空', '猪八戒', '白龙马', '白骨精', '唐僧', '蜘蛛精', '铁扇公主', '铁扇公主', '铁扇公主']
1
2
3
4
5

4.5.7.3 删除元素

list.pop() 根据索引删除并返回元素， 如果不传递索引，默认删除最后一个

list3 = ['孙悟空', '猪八戒', '白龙马', '白骨精', '蜘蛛精', '铁扇公主', '铁扇公主', '铁扇公主']
a = list3.pop()
print(a)
print(list3)

>>> 铁扇公主
    ['孙悟空', '猪八戒', '白龙马', '白骨精', '蜘蛛精', '铁扇公主', '铁扇公主']
1
2
3
4
5
6
7

4.5.7.4 删除指定元素

list.remove() 删除指定的元素

list4 = ['孙悟空', '猪八戒', '白龙马', '白骨精', '蜘蛛精', '铁扇公主', '铁扇公主', '铁扇公主']
list4.remove('铁扇公主')
print(list4)

>>> ['孙悟空', '猪八戒', '白龙马', '白骨精', '蜘蛛精', '铁扇公主', '铁扇公主']
1
2
3
4
5

4.5.7.5 扩展序列

list.extend() 使用新的序列来扩展当前序列

list5 = ['孙悟空', '猪八戒', '白龙马', '白骨精', '蜘蛛精', '铁扇公主', '铁扇公主', '铁扇公主']
list5.extend(['唐僧', '沙悟净'])
print(list5)

>>> ['孙悟空', '猪八戒', '白龙马', '白骨精', '蜘蛛精', '铁扇公主', '铁扇公主', '铁扇公主', '唐僧', '沙悟净']
1
2
3
4
5

4.5.7.6 反转列表

reverse()

list6= ['孙悟空', '猪八戒', '白龙马', '白骨精', '蜘蛛精', '铁扇公主', '铁扇公主', '铁扇公主']
list6.reverse()
print(list6)

>>> ['铁扇公主', '铁扇公主', '铁扇公主', '蜘蛛精', '白骨精', '白龙马', '猪八戒', '孙悟空']
1
2
3
4
5

4.5.7.7 排序

list.sort() 默认是正序排序 他有一个参数reverse

list7= ['孙悟空', '猪八戒', '白龙马', '白骨精', '蜘蛛精', '铁扇公主', '铁扇公主', '铁扇公主']
list7.sort(reverse=True)
print(list7)

>>> ['铁扇公主', '铁扇公主', '铁扇公主', '蜘蛛精', '白龙马', '白骨精', '猪八戒', '孙悟空']
1
2
3
4
5

4.6 元组(tuple)

4.6.1 元组的基本知识

元组表现形式tuple
1.元组（tuple）与列表类似，不同之处在于元组的元素不能修改。元组写在小括号 () 里，列表使用大括号[ ],元素之间用逗号隔开。
2.tuple () 有序不可修改
3.元组是一个不可变序列(一般当我们希望数据不改变时，我们使用元组，其他情况下基本都用列表)
4.使用()创建元素

eg:

tuple1 = (1, 2, 3, 4, 5)
print(tuple1, type(tuple1))
print(tuple1[2])
print(tuple1[2::])

>>> (1, 2, 3, 4, 5) <class 'tuple'>
3
(3, 4, 5)
1
2
3
4
5
6
7
8

5.元组不是空元组至少有一个 逗号(,) 当元组不是空元组时括号可以省略

tuple2 = 10,
tuple3 = (10)
print(tuple2, type(tuple2))
print(tuple3, type(tuple3))

[运行结果如下:]
(10,) <class 'tuple'>
10 <class 'int'>
1
2
3
4
5
6
7
8

6.元组解包指将元组当中的每一个元素都赋值给一个变量

4.6.2 元组的拆包

拆包:
拆包的时候如果有 “*”， 那么有且只能有一个“ * ”, * 接受参数之后，结果是用一个列表来放置的

# 元组的拆包
tuple1=(1,2,3,)
*a,b,=tuple1
print(a,b)

tuple2=(1,2,3,4)
a,b,*c###=tuple2
print(a,b,c)

>>> [1, 2] 3 
>>> 1 2 [3, 4]
1
2
3
4
5
6
7
8
9
10
11

4.6.3 元组的修改方法

4.7 集合(set)

4.7.1 集合简介

• 使用{}来创建集合
• 集合表现形式set 集合和列表非常相似

4.7.2 集合和列表不同点

• 集合只能存储不可变对象

s1 = {1, 0.2,'abc', (1,2,3)}  # int float str tuple
print(s1, type(s1))

>>> {0.2, 1, 'abc', (1, 2, 3)} <class 'set'>
1
2
3
4

• 集合中存储的对象是无序的

s2 = {6, 8, 9, 10}
print(s2)

>>> {8, 9, 10, 6}
1
2
3
4

• 集合不能出现重复元素

s3 = {1, 2, 3, 4, 1, 2, 3, 4}
print(s3)

>>> {1, 2, 3, 4}
1
2
3
4

• 可以通过set()来将序列和字典转换成集合

list1 = [1, 1, 2, 3, 3]
s4 = set(list1)
print(s4)

dict1 = {'1': 1}
print(set(dict1))

>>> {1, 2, 3}
    {'1'}
1
2
3
4
5
6
7
8
9

• len() 使用len()来获取集合中元素的数量

s={1,2}
m=len(s)
print(m)
>>> 2
1
2
3
4

• add()像集合中添加元素

s = set()
s.add(1)
s.add(2)
print(s)

>>> {1, 2}
1
2
3
4
5
6

• update()将一个集合中的元素添加到另一个集合当中

s1 = {1, 2, 3}
s2 = {4, 5, 6}
s1.update(s2)
print(s1)

>>> {1, 2, 3, 4, 5, 6}
1
2
3
4
5
6

• pop()随机删除集合中的一个元素一般是删除最后一个元素

s1={1, 2, 3, 4, 5, 6}
s1.pop()
s1.pop()
s1.pop()
s1.pop()
print(s1)

>>> {5, 6}
1
2
3
4
5
6
7
8

• remove() 删除集合中指定的元素

s1={1, 2, 3, 4, 5, 6}
s1.remove(1)
print(s1)

>>> {2, 3, 4, 5, 6}
1
2
3
4
5

• clear() 清空集合

s1={1, 2, 3, 4, 5, 6}
s1.clear()
print(s1)

>>> set()
1
2
3
4
5

4.7.2 集合的运算

1.& 交集运算
2.| 并集运算
3.- 差集运算
4.^ 亦或集
5.<= 检查一个集合是否是另一个集合的子集
6.< 检查一个集合是否是另一个集合的真子集
7.>=检查一个集合是否是另一个集合的超集
8.>检查一个集合是否是另一个集合的真超集

s1 = {1, 2, 3, 7, 8}
s2 = {4, 5, 6, 7, 8}

# & 交集运算
s3 = s1 & s2
print(s3)

# | 并集运算
s4 = s1 | s2
print(s4)
# - 差集运算
s5 = s1 - s2
print(s5)
# ^ 亦或集
s6 = s1 ^ s2
print(s6)

[运行结果如下：]
>>> {8, 7}
    {1, 2, 3, 4, 5, 6, 7, 8}
    {1, 2, 3}
    {1, 2, 3, 4, 5, 6}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

4.7.3 创建格式：

parame = {value01,value02,…} 或者 set(value)

eg:

m = {'a','b','c','d','e','f' }
print(m)     # 输出集合，重复的元素被自动去掉


if 'c' in m:     # 成员测试
    print('该元素在此集合中')
else:
    print('该元素不在此集合中')

[输出结果如下：]
>>> {'c', 'b', 'a', 'd', 'f', 'e'}
>>> 该元素在此集合中
1
2
3
4
5
6
7
8
9
10
11
12

4.8 字典(Dictionary）

4.8.1 字典的基本介绍

1.字典属于一种新的数据结构称为映射(mapping)
2.字典的作用和列表类似，都是用来存储对象的容器
3.列表存储数据的性能好，但是查询数据的性能差，字典正好与之相反
4.在字典中每一个元素都有唯一的名字，通过这个唯一的名字可以找到指定的元素
5.这个唯一的名字我们称之为key 通过key可以快速查询value 也可以称之为值
6.字典我们也称之为键值对(key-value)结构
7.每个字典中都可以有多个键值对，而每一个键值对我们称其为一项(item)
8.创建一个有数据的字典 语法：

{key:value}

9.字典的值可以是任意对象 字典的键可以是任意的不可变对象(int str bool tuple…)
10.字典的键是不能重复的，如果出现重复的后面的会替换前面的，在同一个字典中，键(key)必须是唯一的。

4.8.2 字典的使用

• dict()函数来创建字典，其用的符号为{}

dict = {}
dict[1]="jjj"
dict[2]="iii"
print(dict[1])   # 输出键为1的值
print(dict[2])   # 输出键为2的值
1
2
3
4
5
'
运行
运行

1. 用{}创建
2. 使用dict类去创建字典
3. 使用dict去创建
   在python2中应用
   orderdict 无序字典
   需要dict（）括号里的数据是属于一种双值子序列的形式
   双值序列 [1, 2]
   子序列 （‘a’）
   双值子序列： [(1, 2), (3, 4)]

# 1.用{}创建
dict={'name':'郭靖',
       'age':18,
       'sex':'男',
       'skill':'降龙十八掌'}
print(dict,type(dict))

# 2.使用dict类去创建字典
dict1=dict(name='郭靖',age=18,sex='男',skill='降龙十八掌')

# 3.使用dict去创建
# 在python2中应用
# orderdict  无序字典
# 需要dict（）括号里的数据是属于一种双值子序列的形式
# 双值序列 [1, 2]
# 子序列  （'a'）
# 双值子序列： [(1, 2), (3, 4)]
dict2 = dict([('name', '郭靖'), ('age', 18), ('sex', '男')])
print(dict2, type(dict2))

>>> {'name': '郭靖', 'age': 18, 'sex': '男'} <class 'dict'>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

• 当字典中的key有重复的时候，后面的key-value会替换前面的

dict2 = {
        'name': '郭靖',
         'age': 18,
         'sex': '男',
         'name': '欧阳锋',
        'skill': '蛤蟆功'
}
print(dict2, type(dict2))
1
2
3
4
5
6
7
8
'
运行
运行

获取value， 直接用 dict[key]

dict2 = {
        'name': '郭靖',
         'age': 18,
         'sex': '男',
         'name': '欧阳锋',
        'skill': '蛤蟆功'
}
print(dict2['skill'])

>>> 蛤蟆功
1
2
3
4
5
6
7
8
9
10

4.8.3 字典的增删改查

4.8.3.1 获取值的方式

使用key获取value
dict[key] 如果不存在key则会报错
dict.get(key) 不存在key不会报错
• get(key[,default]) 根据键来获取字典的值。第二个参数可以指定一个默认值，当获取不到值的时候会返回默认值

dict1={'a':1,'b':2,'c':3}
print(dict1.get('c'))

[运行结果如下:]
>>> 3
1
2
3
4
5

4.8.3.2 字典的key-value添加

• update() 将其他字典的key-value添加到当前的字典当中

dict1={'a':1,'b':2,'c':3}
dict2={'d':4,'e':5,'f':6}
dict1.update(dict2)
print(dict1)

[运行结果如下：]
>>> {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5, 'f': 6}
1
2
3
4
5
6
7

4.8.3.3 del 删除字典中的key-value

dict1={'a':1,'b':2,'c':3}
del dict1['c']
print(dict1)

[运行结果如下：]
>>> {'a': 1, 'b': 2}
1
2
3
4
5
6

4.8.3.4 随机删除键值对

• popitem() 删除字典最后的一个key-value 这个方法是有返回值的。删除之后它会将删除的key-value作为返回值返回
随机删除一个键值对，一般都会删除最后一个, 有一个返回值，就是删除的对象，结果是一个元组

dict1={'a':1,'b':2,'c':3}
result = dict1.popitem()
print(result)
print(dict1)

[运行结果如下：]
>>> ('c', 3)
    {'a': 1, 'b': 2}
1
2
3
4
5
6
7
8

4.8.3.5 清空字典

• dict.clear（）

dict1={'a':1,'b':2,'c':3}
dict1.clear()
print(dict1)

[运行结果如下：]
>>> None
1
2
3
4
5
6

4.8.3.6 修改字典

• dict[key] = value

dict1={'a':1,'b':2,'c':3}
dict1['a']=10
print(dict1)

[运行结果如下：]
>>> {'a': '10', 'b': 2, 'c': 3}
1
2
3
4
5
6

3.8.3.7 删除指定value

• pop(key[,default]) 根据key删除自定中的value。第二个参数可以指定一个默认值，当获取不到值的时候会返回默认值

dict1={'a':1,'b':2,'c':3}
dict1.pop('a')
print(dict1)

[运行结果如下：]
>>> {'b': 2, 'c': 3}
1
2
3
4
5
6

4.8.4 遍历字典

我们主要可以通过3种方式对字典进行遍历
• keys() 该方法返回字典所有的key

dict1={'a':1,'b':2,'c':3}
for i in dict1.keys():
    print(dict1[i])
    
[运行结果如下：]
>>> 1
    2
    3
1
2
3
4
5
6
7
8

• values() 该方法返回一个序列 序列中保存有字典的值

dict1={'a':1,'b':2,'c':3}
for j in dict1.values():
    print(j)

[运行结果如下：]
>>> 1
    2
    3
1
2
3
4
5
6
7
8

• items() 该方法会返回字典中所有的项 它返回一个序列，序列中包含有双值子序列 双值分别是 字典中的key和value
• 通过一项来进行遍历 dict.items()

dict1={'a':1,'b':2,'c':3}
for i,j in dict1.items():
    print(i,'=',j)

[运行结果如下：]
>>> a = 1
    b = 2
    c = 3
1
2
3
4
5
6
7
8

4.9 Bytes

4.9.1 bytes介绍

在Python3以后，字符串和bytes类型彻底分开了。字符串是以字符为单位进行处理的，bytes类型是以字节为单位处理的。
bytes数据类型在所有的操作和使用甚至内置方法上和字符串数据类型基本一样，也是不可变的序列对象。
Python3中，bytes通常用于网络数据传输、二进制图片和文件的保存等等。

4.9.2 bytes创建

可以通过调用bytes()生成bytes实例，其值形式为 b’xxxxx’，对于同一个字符串如果采用不同的编码方式生成bytes对象，就会形成不同的值。

>>> a = b'hello'
>>> type(a)
<class 'bytes'>
>>> b = bytes('hello',encoding='utf8')
>>> type(b)
<class 'bytes'>
1
2
3
4
5
6

4.9.3 bytes类型常用转换

那在实际应用中，我们通常会将bytes类型与str类型做转换。

4.9.3.1 字节转为字符串

>>> d = b'world'
>>> d.decode()
'world'
>>> type(d)
<class 'bytes'>
1
2
3
4
5

4.9.3.2 字符串转为字节

>>> e = 'world'
>>> e.encode()
b'world'
>>> type(e)
<class 'str'>
1
2
3
4
5

5. 浅拷贝与深拷贝

5.1 浅拷贝(copy)

• copy() 方法用来对字典进行复制
• 做拷贝的对象必须是可变类型
• 浅拷贝只能对第一层的数据进行拷贝，如果，第一层的数据也是个可变类型，那么浅拷贝无法将这个数据重新拷贝一份形成新的id

dict1 = {'1': 1, '2': 2, 'list1': [1, 2, 3, {'name': [12, 23]}]}
dict2 = {'1': 1, '2': 2}
dict2 = copy.copy(dict1)
dict2 = dict1.copy()
print(id(dict1), id(dict2))
print(id(dict1['list1']), id(dict2['list1']))

[运行结果如下：]
>>> 2390268476728 2390298372280
    2390298861640 2390298861640
1
2
3
4
5
6
7
8
9
10

5.2 深拷贝

• 深拷贝则可以对所有的数据全部进行拷贝，形成一个新的id

import copy
dict1 = {'1': 1, '2': 2, 'list1': [1, 2, 3, {'name': [12, 23]}]}
dict2 = copy.deepcopy(dict1)
print(dict1,id(dict1))
print(dict2,id(dict2))

[运行结果如下：]
>>> {'1': 1, '2': 2, 'list1': [1, 2, 3, {'name': [12, 23]}]} 2440433925432 
>>> {'1': 1, '2': 2, 'list1': [1, 2, 3, {'name': [12, 23]}]} 2489202093296
1
2
3
4
5
6
7
8
9

注意:浅拷贝只会复制字典本身，如果字典中还有个字典是不会进行复制的

6.数据类型转换

7.思维导图

8. 课后练习

1. a,b = 6, 8 我想让a=8 b=6我该怎么办？用2种方式实现

# 1. a,b = 6, 8 我想让a=8 b=6我该怎么办？用2种方式实现
# 方法一：
def fun(a, b):
    print("a={}".format(b))
    print("b={}".format(a))


fun(6, 8)

#  方法二：
a, b = 6, 8
a = 8
b = 6
print(a, b)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
'
运行
运行

2. 完成字符串的逆序以及统计
   • 设计一个程序，要求只能输入长度低于31的字符串，否则提示用户重新输入
   • 打印出字符串长度
   • 使用切片逆序打印出字符串

while True:
    x = []
    x = input('输入长度为0-30的字符串：')
    if len(x) >= 31 and x is not str:
        print('输入错误，请重新输入：')
    else:
        break
print(len(x))
print(x[::-1])
1
2
3
4
5
6
7
8
9
'
运行
运行

3. 要求从键盘输入用户名和密码，校验格式是否符合规则，如果不符合，打印出不符合的原因，并提示重新输入
   • 用户名长度6-20，用户名必须以字母开头
   • 密码长度至少6位，不能为纯数字，不能有空格

# 知识点
# .isalpha() #检测字符串是否只由字母组成。是则为true
# .isdigit() #检测字符串是否只由数字组成。是则为true
# .isspace() #检测字符串是否只由空格组成。是则为true
admin = input('请输入用户名:(长度6-20，必须以字母开头)')
a: str = admin[:1]
if (6 < len(admin) < 20) and a.isalpha():
    pass
else:
    print('输入错误，请重新输入：')
password = input('请输入密码：(至少6位，不能为纯数字，不能有空格)')
if len(password) >= 6:
    pass
elif password.isdigit() and password.isnotspace() and password.isalpha():
    pass
else:
    print('输入错误，请重新输入：')
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

4. 现在有 a = [1,2,3,4,5,6] 不通过函数的形式实现列表的反转([6,5,4,3,2,1]) 并写出推导过程

# 方法一：
a = [1, 2, 3, 4, 5, 6]  # 列表的reverse方法进行逆序输出
a.reverse()
print(a)
# 方法二：
a = [1, 2, 3, 4, 5, 6]  # 列表的sort方法进行逆序输出
a.sort(reverse=True)
print(a)
# 方法三：
a = [1, 2, 3, 4, 5, 6]
b = a[::-1]
print(b)
1
2
3
4
5
6
7
8
9
10
11
12
'
运行
运行

5. 给 用户9次机会 猜1 - 10 个数字随机来猜数字。如果随机的数字和用户输入的数字一致则表示正确，如果不一致则表示错误。最终结果要求用户怎么也猜不对

player_list = []
total_list = list(range(1, 11))

for i in range(9):
    guess = int(input('请猜1 - 10 之间的一个整数：'))
    player_list.append(guess)
    print('猜错了，你还有', 8 - i, '次机会')

for k in total_list:
    if k in player_list:
        continue
    else:
        print('游戏结束，正确数字为:', k, '，想不到吧！')
1
2
3
4
5
6
7
8
9
10
11
12
13

6. 有两个列表 lst1 = [11, 22, 33] lst2 = [22, 33, 44]获取内容相同的元素

list1 = [11, 22, 33]
list2 = [22, 33, 44]
Same_list = []
for i in list1:
    if i in list2:
        Same_list.append(i)
    else:
        continue
print(Same_list)
1
2
3
4
5
6
7
8
9
'
运行
运行

7. 现在有8位老师，3个办公室，要求将8位老师随机的分配到三个办公室中

import random
Teacher = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H']
Room=[1,2,3]
for i in Teacher:
    Room=random.randint(1,3)
    print("{}老师分配到{}号办公室".format(i,Room))
1
2
3
4
5
6
'
运行
运行

8. 现在有8位老师，3个办公室，要求将8位老师随机的分配到三个办公室中，要求每个办公室至少有一个老师（如果觉得上面的题不够写的话，写这个）

import random

teacher_lst = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H']
off_lst = [1, 2, 3]
basic_tindex = random.sample(range(0, 8), 3)

for i in off_lst:
    print(teacher_lst[basic_tindex[i - 1]], '老师', '分在', i, '号办公室')

for j in range(8):
    if j not in basic_tindex:
        off_j = random.randint(1, 3)
        print(teacher_lst[j], '老师', '分在', off_j, '号办公室')
    else:
        continue
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
'
运行
运行

9. a = {“name”:“123”,“data”:{“result”:[{“src”:“python1”},{“src”:“python2”},{“src”:“python3”}]}} 找到python1/python2/python3

a = {"name":"123",
     "data":{"result":
                 [{"src":"python1"},
                  {"src":"python2"},
                  {"src":"python3"}

]
}}
for i in a["data"]["result"]:
    print(i["src"])
1
2
3
4
5
6
7
8
9
10
'
运行
运行

10. 有如下值集合[11,22,33,44,55,66,77,88,99,90], 将所有大于66的值保存至字典的第一个key的值中，将小于66值保存至第二个key的值中。

b = [11, 22, 33, 44, 55, 66, 77, 88, 99, 90]
dict1 = {}
c = []
d = []
for i in b:
    if i < 66:
        d.append(i)
    else:
        c.append(i)

dict1 = dict(one=c, two=d)
print(dict1)
1
2
3
4
5
6
7
8
9
10
11
12
'
运行
运行