一、类型的可变和不可变

类型的可变与不可变: 在不改变变量引用的前提下,能否改变变量中引用中的数据,如果能改变是可变类型, 如果不能改变,是不可变类型
int float bool str list tuple dict
不可变类型: int float bool str tuple（一部分）
可变类型: list dict tuple（一部分）

# int型的地址改变了，因此是不可变类型，float、str和bool也一样
a = 10
print(id(a))  # 140722097784768
a = 20
print(id(a))  # 140722097785088
# list 列表地址没有改变，是可变类型，字典dict也一样
my_list = [1, 2]
print(id(my_list))  # 2359877309568
my_list.append(3)
print(id(my_list))  # 2359877309568
1
2
3
4
5
6
7
8
9
10

注意：在代码中不管值是多少都是true，在交互终端中，小整数的概念小整数默认范围-5~255
如果是小整数使用相同的引用地址如果不是，开辟新的内存

二、变量赋值浅复制深复制后变量id的变化

1.不可变对象,数值,字符串,元组(元素没有可变对象),其同样值赋值给两个变量,浅复制,深复制,其变量id一致
2.可变对象,列表,字典,集合,元组(元素有可变对象),其同样赋值给两个变量,浅复制,深复制,其变量id不一致

import copy
print('·' * 25 + '数值型' + '·' * 25)
a = 5
b = 5
c = copy.copy(a)
d = copy.deepcopy(a)
print('a和b通过=赋值后为:{},a和b的id是否一致:{}'.format(a, a is b))  # True
print('c通过浅拷贝a后值为:{},a和c的id是否一致:{}'.format(c, a is c))  # True
print('c通过深拷贝a后值为:{},a和d的id是否一致:{}'.format(d, a is d))  # True
a = -999999999
b = -999999999
c = copy.copy(a)
d = copy.deepcopy(a)
print('a和b通过=赋值后为:{},a和b的id是否一致:{}'.format(a, a is b))  # True
print('c通过浅拷贝a后值为:{},a和c的id是否一致:{}'.format(c, a is c))  # True
print('c通过深拷贝a后值为:{},a和d的id是否一致:{}'.format(d, a is d))  # True
a = 9999999999
b = 9999999999
c = copy.copy(a)
d = copy.deepcopy(a)
print('a和b通过=赋值后为:{},a和b的id是否一致:{}'.format(a, a is b))  # True
print('c通过浅拷贝a后值为:{},a和c的id是否一致:{}'.format(c, a is c))  # True
print('c通过深拷贝a后值为:{},a和d的id是否一致:{}'.format(d, a is d))  # True
a = 5.2
b = 5.2
c = copy.copy(a)
d = copy.deepcopy(a)
print('a和b通过=赋值后为:{},a和b的id是否一致:{}'.format(a, a is b))  # True
print('c通过浅拷贝a后值为:{},a和c的id是否一致:{}'.format(c, a is c))  # True
print('c通过深拷贝a后值为:{},a和d的id是否一致:{}'.format(d, a is d))  # True
print('·' * 25 + '字符串型' + '·' * 25)
a = 'redamancy'
b = 'redamancy'
c = copy.copy(a)
d = copy.deepcopy(a)
print('a和b通过=赋值后为:{},a和b的id是否一致:{}'.format(a, a is b))  # True
print('c通过浅拷贝a后值为:{},a和c的id是否一致:{}'.format(c, a is c))  # True
print('c通过深拷贝a后值为:{},a和d的id是否一致:{}'.format(d, a is d))  # True
a = 'redamancy52_'
b = 'redamancy52_'
c = copy.copy(a)
d = copy.deepcopy(a)
print('a和b通过=赋值后为:{},a和b的id是否一致:{}'.format(a, a is b))  # True
print('c通过浅拷贝a后值为:{},a和c的id是否一致:{}'.format(c, a is c))  # True
print('c通过深拷贝a后值为:{},a和d的id是否一致:{}'.format(d, a is d))  # True
a = 'redamancy52&'
b = 'redamancy52&'
c = copy.copy(a)
d = copy.deepcopy(a)
print('a和b通过=赋值后为:{},a和b的id是否一致:{}'.format(a, a is b))  # True
print('c通过浅拷贝a后值为:{},a和c的id是否一致:{}'.format(c, a is c))  # True
print('c通过深拷贝a后值为:{},a和d的id是否一致:{}'.format(d, a is d))  # True
print('·' * 25 + '元组型' + '·' * 25)
a = (15, 25, 35, )
b = (15, 25, 35)
c = copy.copy(a)
d = copy.deepcopy(a)
print('a和b通过=赋值后为:{},a和b的id是否一致:{}'.format(a, a is b))  # True
print('c通过浅拷贝a后值为:{},a和c的id是否一致:{}'.format(c, a is c))  # True
print('c通过深拷贝a后值为:{},a和d的id是否一致:{}'.format(d, a is d))  # True
a = (15, 25, 35, [15, 25, 35])  # 不可变的元组里面有可变元素
b = (15, 25, 35)
c = copy.copy(a)
d = copy.deepcopy(a)
print('a和b通过=赋值后为:{},a和b的id是否一致:{}'.format(a, a is b))  # False
print('c通过浅拷贝a后值为:{},a和c的id是否一致:{}'.format(c, a is c))  # True
print('c通过深拷贝a后值为:{},a和d的id是否一致:{}'.format(d, a is d))  # False
print('·' * 25 + '列表型' + '·' * 25)
a = [15, 25, 35]
b = [15, 25, 35]
c = copy.copy(a)
d = copy.deepcopy(a)
print('a和b通过=赋值后为:{},a和b的id是否一致:{}'.format(a, a is b))  # False
print('c通过浅拷贝a后值为:{},a和c的id是否一致:{}'.format(c, a is c))  # False
print('c通过深拷贝a后值为:{},a和d的id是否一致:{}'.format(d, a is d))  # False
print('·' * 25 + '字典型' + '·' * 25)
a = {'name': 'redamancy'}
b = {'name': 'redamancy'}
c = copy.copy(a)
d = copy.deepcopy(a)
print('a和b通过=赋值后为:{},a和b的id是否一致:{}'.format(a, a is b))  # False
print('c通过浅拷贝a后值为:{},a和c的id是否一致:{}'.format(c, a is c))  # False
print('c通过深拷贝a后值为:{},a和d的id是否一致:{}'.format(d, a is d))  # False
print('·' * 25 + '集合型' + '·' * 25)
a = {'age'}
b = {'age'}
c = copy.copy(a)
d = copy.deepcopy(a)
print('a和b通过=赋值后为:{},a和b的id是否一致:{}'.format(a, a is b))  # False
print('c通过浅拷贝a后值为:{},a和c的id是否一致:{}'.format(c, a is c))  # False
print('c通过深拷贝a后值为:{},a和d的id是否一致:{}'.format(d, a is d))  # False
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91

结果为：
a和b通过=赋值后为:5,a和b的id是否一致:True
c通过浅拷贝a后值为:5,a和c的id是否一致:True
c通过深拷贝a后值为:5,a和d的id是否一致:True
a和b通过=赋值后为:-999999999,a和b的id是否一致:True
c通过浅拷贝a后值为:-999999999,a和c的id是否一致:True
c通过深拷贝a后值为:-999999999,a和d的id是否一致:True
a和b通过=赋值后为:9999999999,a和b的id是否一致:True
c通过浅拷贝a后值为:9999999999,a和c的id是否一致:True
c通过深拷贝a后值为:9999999999,a和d的id是否一致:True
a和b通过=赋值后为:5.2,a和b的id是否一致:True
c通过浅拷贝a后值为:5.2,a和c的id是否一致:True
c通过深拷贝a后值为:5.2,a和d的id是否一致:True
·························字符串型·························
a和b通过=赋值后为:redamancy,a和b的id是否一致:True
c通过浅拷贝a后值为:redamancy,a和c的id是否一致:True
c通过深拷贝a后值为:redamancy,a和d的id是否一致:True
a和b通过=赋值后为:redamancy52_,a和b的id是否一致:True
c通过浅拷贝a后值为:redamancy52_,a和c的id是否一致:True
c通过深拷贝a后值为:redamancy52_,a和d的id是否一致:True
a和b通过=赋值后为:redamancy52&,a和b的id是否一致:True
c通过浅拷贝a后值为:redamancy52&,a和c的id是否一致:True
c通过深拷贝a后值为:redamancy52&,a和d的id是否一致:True
·························元组型·························
a和b通过=赋值后为:(15, 25, 35),a和b的id是否一致:True
c通过浅拷贝a后值为:(15, 25, 35),a和c的id是否一致:True
c通过深拷贝a后值为:(15, 25, 35),a和d的id是否一致:True
a和b通过=赋值后为:(15, 25, 35, [15, 25, 35]),a和b的id是否一致:False
c通过浅拷贝a后值为:(15, 25, 35, [15, 25, 35]),a和c的id是否一致:True
c通过深拷贝a后值为:(15, 25, 35, [15, 25, 35]),a和d的id是否一致:False
·························列表型·························
a和b通过=赋值后为:[15, 25, 35],a和b的id是否一致:False
c通过浅拷贝a后值为:[15, 25, 35],a和c的id是否一致:False
c通过深拷贝a后值为:[15, 25, 35],a和d的id是否一致:False
·························字典型·························
a和b通过=赋值后为:{‘name’: ‘redamancy’},a和b的id是否一致:False
c通过浅拷贝a后值为:{‘name’: ‘redamancy’},a和c的id是否一致:False
c通过深拷贝a后值为:{‘name’: ‘redamancy’},a和d的id是否一致:False
·························集合型·························
a和b通过=赋值后为:{‘age’},a和b的id是否一致:False
c通过浅拷贝a后值为:{‘age’},a和c的id是否一致:False
c通过深拷贝a后值为:{‘age’},a和d的id是否一致:False

三、小整数

所谓的小整数，就是[-5，256]之间的整数，顾头又顾腚～这些整数呢，在Python中存储的时候，为了提高运行的效率，只存储一个，也就是说多个变量引用相同的小整数的时候，所有的变量都指向了同一个内存空间，它们在内存中的地址是一样的，或者说它们就是同一个。

四、拆包应用交换两个变量的值

将a、b的值做交换方法一和方法二是常用的方法，方法三是利用组包和拆包实现的交换

a = 10
b = 20

# 方法一:
# c = a
# a = b
# b = c
# print(a, b)

# 方法二: +/-   */÷
# a = a + b  # a 30
# b = a - b  # 10
# a = a - b  # 20
# print(a, b)

# 方法三, python中的使用 组包和拆包
a, b = b, a
print(a, b)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

def func(*args, **kwargs):
    print('args', args)
    print('kwargs', kwargs)


my_list = [1, 2, 3, 4, 5, 6]
my_dict = {'a': 7, 'c': 8, 'b': 9, 'd': 10}

func(my_list)  # 将列表作为一个数据进行传递
print("`" * 25)
func(*my_list)  # 将列表中的每一个数据作为位置参数进行传递, 拆包
print("`" * 25)
func(my_dict)  # 将my_dict 作为一个位置实参进行传递
print("`" * 25)
func(*my_dict)  # 将my_dict中的key 作为位置实参进行传递
print("`" * 25)
func(**my_dict)  # 将my_dict中键值对作为关键字实参进行传递

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

五、Python中几种输出方式

1、加号拼接

str1 = 'redamancy'
print("你的名字是:" + str1)  # 你的名字是:redamancy
1
2

2、.format格式

a = 1
b = 2
print("a的值为:{},b的值为：{}".format(a, b))  # a的值为:1,b的值为：2
1
2
3

3、print(f “{}”) 的用法

a = 1
b = 2
print(f"a的值为:{a},b的值为：{b}")  # a的值为:1,b的值为：2
1
2
3

4、输出其他类型的方法

1.输出百分比方法

a = 1.8
print('数值为：%.0f%%' % (a))  # 数值为：2%
print('数值为：%.1f%%' % (a))  # 数值为：1.8%
print('数值为：%.2f%%' % (a))  # 数值为：1.80%
1
2
3
4

2.输出字符串方法

str1 = 'redamancy'
print('你的名字是：%s' % (str1))
1
2

3.输出整形方法

a = 2
print('数值为：%d' % (a))  # 数值为：2
1
2

4.输出浮点型方法

a = 2.8
print('数值为：%f' % (a))  # 数值为：2.800000
1
2

5.扩展知识