变量

变量接收

变量的接收是靠input()函数实现，它经常用于程序与用户的交互。

要使用输入的值对变量进行赋值保存可以在input()函数前加上变量=，例如notice = input("这里输入提示信息")

1
2
3
4
5
6
7
input("此处的提示信息必须使用引号引用起来")
//在Linux的bash中断使用ipython测试
In [1]: n = input("请输入n的值:")
请输入n的值：8

In [2]: n
Out[2]: '8'

变量命名规范

变量名只能是字母、数字、下划线的任意组合；

头部只能是字母或者下划线开头，不能使用数字开头；

保留字不能声明为变量名；

变量名区分大小写；

选择有意义的单词作为变量，可以使用大驼峰或者下驼峰写法；

不建议使用系统内置的模块名、类型名或者函数名以及已经导入的模块名及其成员名作为变量名，；

1
2
3
4
5
6
//保留字如下
In [1]: import keyword

In [2]: keyword.kwlist
Out[2]: 
['False','None','True','and','as','assert','async','await','break','class','continue','def','del','elif','else','except','finally','for','from','global','if','import','in','is','lambda','nonlocal','not','or','pass','raise','return','try','while','with','yield']

变量赋值

python中变量的赋值如下所示，需要注意的逻辑关系是，hello会在内存中先被创建，之后再把变量名s分配给hello。

所以在我们阅读python代码时，遇到变量赋值应该先看等号的右边。

对象是在右边先被创建或者被获取的，在此之后左边的变量名才会被绑定到对象上，这就像是为对象贴上了一个标签。

一个对象可以有多个标签或名字。

1
s = 'hello'

多元赋值

字符串以及后面的列表、元组都支持这种操作，也要元组解包。

多元赋值需要等号两边的元数相同，通常等号右边的值需要用到,进行分割，但还可以使用''单引号将值分割，每一个字符都是一个单独的元。另外列表也可以进行多元赋值。

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
In [3]: n1,n2=1,2

In [4]: n1
Out[4]: 1

In [5]: n2
Out[5]: 2

In [6]: n1=1,2

In [7]: n1
Out[7]: (1, 2)

In [8]: n1,n2,n3=1,2
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
Cell In[8], line 1
----> 1 n1,n2,n3=1,2

ValueError: not enough values to unpack (expected 3, got 2)

In [9]: n1,n2=1,2,3
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
Cell In[9], line 1
----> 1 n1,n2=1,2,3

ValueError: too many values to unpack (expected 2)

In [10]: n1,n2=1
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[10], line 1
----> 1 n1,n2=1

TypeError: cannot unpack non-iterable int object

In [11]: n1,n2='12'

In [12]: n1
Out[12]: '1'

In [13]: n2
Out[13]: '2'

In [18]: num,s=[100,'hello']

In [19]: num
Out[19]: 100

In [20]: s
Out[20]: 'hello'

判断表达式

python中使用判断符号判断条件的真假，条件为真则返回True，条件为假则返回False，True和False的首字母必须是大写。

判断符号

符号 释义
= 对变量进行赋值
== 判断变量是否和条件相等
!= 判断变量是否与条件不相等
> 判断变量是否大于条件
< 判断变量是否小于条件
>= 判断变量是否大于等于条件
<= 判断变量是否小于等于条件

数据类型

在变量接收时，input()函数接收到的任何数据都会转换成字符串类型（str），而我们如果输入的是整型的数字，但是input()接收将其转换成字符串后，进行判断比较就会返回False值。

在不确定变量接收的数据类型时，我们可以使用type()函数进行数据类型查验。

1
2
3
4
5
6
7
8
9
10
11
In [25]: n = input("输入一个数字：")
输入一个数字：10

In [26]: n
Out[26]: '10'

In [27]: type(n)
Out[27]: str

In [28]: n == 10
Out[28]: False

基本的数据类型

数据类型 释义
整型（int） 我们所知的整数即为整型，如1、-1、0等这些都是整型。
浮点型（float） 带小数点的数即为浮点型，如1.1、0.2、-3.2这些都是浮点型。
布尔型（bool） 真值和假值即True和False为布尔型，它主要用于条件判断的结果返回。
字符串（str） 在python中，使用单引号''引用的都为字符串类型。
二进制（bytes） 二进制与字符串的区别在于需要在单引号''前加上b。

类型转换

要想把用户的输入(str)和整型(int)进行正确的比较大小，就需要把字符串类型的数据转换成整型。

这种把一个数据从一个类型转换成为另一个类型的操作就叫做类型转换。

int转换

1
2
3
4
5
6
7
8
In [29]: int('10')
Out[29]: 10

In [30]: int(1.1)
Out[30]: 1

In [31]: int('-10')
Out[31]: -10

float转换

1
2
3
4
5
In [32]: float(1)
Out[32]: 1.0

In [33]: float('-1')
Out[33]: -1.0

str转换

二进制转换成字符串的时候，需要指定字符编码。

1
2
3
4
5
6
7
8
9
10
11
In [1]: str(10)
Out[1]: '10'

In [2]: str(-1.11)
Out[2]: '-1.11'

In [3]: str(b'hello',encoding='utf-8')
Out[3]: 'hello'

In [4]: str(b'hello')
Out[4]: "b'hello'"

二进制转换

同样的，字符串转换成二进制时也需要指定字符编码。

1
2
3
4
5
6
7
8
9
10
In [5]: bytes('你好',encoding='utf-8')
Out[5]: b'\xe4\xbd\xa0\xe5\xa5\xbd'

In [6]: bytes('你好')
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[6], line 1
----> 1 bytes('你好')

TypeError: string argument without an encoding

字符串

转义字符

转义字符 释义
\" 字符串双引号
\n 换行
\t 制表符（tab）缩进，在python中默认是四个空格符
\r 回车

字符串拼接

字符串拼接使用+，拼接只能是字符串和字符串进行操作，不可以用字符串和非字符串类型的对象相加。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
In [1]: fileName = "python字符串拼接"

In [2]: suffix = ".txt"

In [3]: file_name = fileName + suffix

In [4]: print(file_name)
python字符串拼接.txt

In [5]: print(file_name + 1)
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[5], line 1
----> 1 print(file_name + 1)

TypeError: can only concatenate str (not "int") to str

字符串复制

字符串复制使用*。

1
2
3
4
In [6]: count = '-' * 10

In [7]: print(count)
----------

字符串取值和切片

字符串是python中的一个序列类型的数据结构，字符串存放的数据在其内是有序的，但是其序列索引值是0开始的，即索引值0为序列第一个元素。

序列类型的特点：

  • 序列里的每个数据被称为序列的一个元素。
  • 元素在序列里都是有个自己的位置的，这个未知被称为索引，从0开始，从左到右依次递增，python支持负值索引，即-1代表倒数第一个元素。
  • 序列中的每一个元素可以通过这个元素的索引来获取到。
  • 获取到序列类型元素中的多个元素需要用切片的操作来获取。

通过索引值取单个元素示例如下：

1
2
3
4
5
6
7
8
In [9]: print(file_name)
python字符串拼接.txt

In [10]: print(file_name[4])
o

In [11]: print(file_name[-1])
t

使用切片获取多个元素需要先进行分片[start:end:step]，start是起始索引号，end是终止索引号，step是可选步长。

分片操作只包含位于起始索引号位置的元素，不包含位于终止索引号位置的元素，同时起始和终止的意义都是针对于从左向右的顺序来定义的。

步长是每数几个取一个的意思，步长为正数时是从左向右开始操作，步长时负数时，是从右向左操作。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
In [9]: print(file_name)
python字符串拼接.txt

In [12]: print(file_name[0:4])			//索引号位置是4对应的元素是0，但是没有取到
pyth

In [13]: print(file_name[0:7:3])		//设置步长为3，即每三个元素取值
ph字

In [14]: print(file_name[0::3])			//end没有设置即默认取到结束
ph字拼t

In [15]: print(file_name[:7:3])			//start没有设置即默认从起始位置开始取值
ph字

In [16]: print(file_name[::-3])			//step设置为负值时从右向左取值
t.串nt

字符串方法

统计序列数据的长度

就是获取一个序列数据的元素个数，这个适用于所有的序列类型的数据，比如字符串、列表、元组。

转义字符被认为是一个元素。

获取字符串的长度，包含空格和换行符。

1
2
3
4
In [17]: string1 = "a \n\t"

In [18]: len(string1)
Out[18]: 4

in成员判断

用于判断元素是否在字符串内，若在则返回True值，不在即返回False值。

空字符串总是被视为任何其他字符串的子串，因此空字串判断都会返回True值。

1
2
3
4
5
6
7
8
9
10
In [19]: line = "Size: 1024MB"

In [20]: "Size" in line
Out[20]: True

In [21]: "" in line
Out[21]: True

In [22]: "SIZE" in line
Out[22]: False

strip()去除两端的空白字符

strip()用于区域字符串两端的空白字符，如空格、\t、\n等。

1
2
3
4
In [23]: line = "   Size: 1024MB\t"

In [25]: line.strip()
Out[25]: 'Size: 1024MB'

split()分割

默认使用空白字符作为分隔符（空格、\t、\n）

和shell中的awk一个道理。

1
2
In [26]: line.split()
Out[26]: ['Size:', '1024MB']

指定分隔符。

1
2
In [27]: line.split(":")
Out[27]: ['   Size', ' 1024MB\t']

链式操作，可以将strip()和split()一起使用用于去除字符串两端空白字符再指定分隔符。

1
2
In [31]: line.strip().split(": ")
Out[31]: ['Size', '1024MB']

replace()替换

可以使用replace()对字符串中的元素进行替换。

1
2
In [32]: line.strip().replace("MB","GB")
Out[32]: 'Size: 1024GB'

startswith()判断字符串的开头

1
2
3
In [33]: line = "Locator: DIMM_A2"
In [35]: line.startswith("Locator:")
Out[35]: True

endswith()判断字符串的结尾

1
2
3
4
In [36]: line = "Size: 1024MB"

In [38]: line.endswith("MB")
Out[38]: True

列表

列表特性介绍：

  • 列表和字符串一样也是序列型的数据。
  • 列表内的元素直接用英文的逗号隔开，元素是可变的，所以列表是可变的数据类型，而字符串不是。
  • 列表的元素可以是python中的任何类型的数据对象如字符串、列表、元组、字典、集合、函数。
  • 列表中的具有相同值的元素允许出现多次。

创建列表

1
2
3
4
5
6
7
8
9
In [39]: li1 = []		//创建空列表

In [40]: li2 = ['python','学习']

In [44]: list("hello")			//list()从其他类型转换
Out[44]: ['h', 'e', 'l', 'l', 'o']

In [47]: "blog.7464824.top".split(".")		//从字符串转换split()
Out[47]: ['blog', '7464824', 'top']

嵌套列表

1
2
3
4
In [50]: li3 = ["blog.7464824.top".split("."),['python','学习']]

In [51]: print(li3)
[['blog', '7464824', 'top'], ['python', '学习']]

列表基本操作

没有嵌套的列表取值

1
2
3
4
5
6
7
In [52]: li1 = ['insert','append','remove','pop','sort']

In [53]: li1[0]
Out[53]: 'insert'

In [54]: li1[-2]
Out[54]: 'pop'

嵌套的列表取值

对于嵌套的列表取值，可以多次使用中括号进行取值。

1
2
3
4
5
6
7
In [55]: li2 = [['insert','append','remove','pop','sort'],[1,2,3]]

In [56]: li2[0]
Out[56]: ['insert', 'append', 'remove', 'pop', 'sort']

In [57]: li2[0][2]
Out[57]: 'remove'

就地修改

可以通过索引直接修改索引对应位置的数据。

1
2
3
4
In [59]: li2[0][4] = 'delete'

In [60]: print(li2)
[['insert', 'append', 'remove', 'pop', 'delete'], [1, 2, 3]]

切片

同字符串的切片一致，示例如下：

1
2
3
4
5
6
7
In [62]: line = 'Size: 1024 MB\n'

In [64]: line.split('\n')
Out[64]: ['Size: 1024 MB', '']

In [66]: line.split('\n')[:-1]
Out[66]: ['Size: 1024 MB']

列表的方法

列表方法可以使用len()和in，前面字符串方法已经提到过就不再赘述，但是in方法需要注意的是列表中的数据类型的区分。

append()

append()方法是向列表的最后位置，添加一个元素，只接收一个参数。

1
2
3
4
5
6
7
8
9
In [1]: li = ['blog','7464824','top','666']

In [2]: li
Out[2]: ['blog', '7464824', 'top', '666']

In [3]: li.append(999)

In [4]: li
Out[4]: ['blog', '7464824', 'top', '666', 999]

insert()

向原列表的指定位置插入一个元素，接收两个参数，第一个是索引号，第二个是要插入的元素，索引位置插入元素之后，原位置的元素向后移位。

1
2
3
4
In [5]: li.insert(1,777)

In [6]: li
Out[6]: ['blog', 777, '7464824', 'top', '666', 999]

remove()

移除列表中某个指定的元素，没有返回值，并且加入有多个相同值的元素存在，每次只会移除排在最前面的元素。

1
2
3
4
In [7]: li.remove(999)

In [8]: li
Out[8]: ['blog', 777, '7464824', 'top', '666']

pop()

从原列表中删除一个元素，并且把这个元素返回。接收零个或一个参数，参数是偏移量，int类型。pop()默认情况下是删除最后一个元素，当然如果要删除指定元素，可以定义其要删除元素位置的索引号。

1
2
3
4
5
6
7
8
In [12]: li
Out[12]: ['blog', 777, '7464824', 'top', '666']

In [13]: li.pop(2)
Out[13]: '7464824'

In [15]: li.pop()
Out[15]: '666'

元组

元组和列表一样，也是一种序列类型的数据。

唯一的不同是，元组是相对不可变的。

元组的创建

单一元组使用,创建。

1
2
3
4
5
6
7
8
9
In [17]: n = (3)

In [18]: type(n)
Out[18]: int

In [19]: t = 3,

In [20]: type(t)
Out[20]: tuple

转换

使用tuple()可以对其他序列类型数据转换为元组。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
In [21]: s1 = 'car'

In [22]: tuple(s1)
Out[22]: ('c', 'a', 'r')

In [23]: li2 = [1,2,3]

In [24]: tuple(li2)
Out[24]: (1, 2, 3)

In [25]: dl = [1,2,3,['a','b']]

In [26]: tuple(dl)
Out[26]: (1, 2, 3, ['a', 'b'])

元组的取值

元组的取值和切片与列表的操作一致。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
In [27]: dl
Out[27]: [1, 2, 3, ['a', 'b']]

In [28]: dl = tuple(dl)

In [29]: dl
Out[29]: (1, 2, 3, ['a', 'b'])

In [30]: dl[1]
Out[30]: 2

In [31]: dl[3][1]
Out[31]: 'b'

In [32]: dl[1:-1]
Out[32]: (2, 3)

元组的方法

常见的len()和in方法使用跟之前一致，就不再赘述。

count()

count()统计一个元素在元组内出现的次数。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
In [34]: dl
Out[34]: (1, 2, 3, ['a', 'b'])

In [35]: dl.count(2)
Out[35]: 1

In [36]: dl.count(a)
---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
Cell In[36], line 1
----> 1 dl.count(a)

NameError: name 'a' is not defined

In [37]: dl[-1].count('a')
Out[37]: 1

index()

index()返回一个元素在元组内的索引。

1
2
3
4
5
In [38]: dl
Out[38]: (1, 2, 3, ['a', 'b'])

In [39]: dl.index(3)
Out[39]: 2

元组的相对不可变

元组本身是不可变的，就是元组内的元素是不可变的，一旦创建一个元组，这个元组内的元素个数和数据都是固定的。

相对不可变的意思是，元组内的元素自身是可变的数据对象，就可以通过修改这个可变元素来间接改变元组的样子。

使用id()可以返回python中一个对象的内存地址（id号），可以帮助我们验证元组的相对不可变。

假设我们将dl元组中的元素2修改为20，使用索引值进行修改，会发现会报错。

1
2
3
4
5
6
7
8
9
10
In [40]: dl
Out[40]: (1, 2, 3, ['a', 'b'])

In [41]: dl[1] = 20
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[41], line 1
----> 1 dl[1] = 20

TypeError: 'tuple' object does not support item assignment

但是当元组中存在列表，那么列表中的元素是可以改变的，我们可以对列表进行直接操作，通俗的话来讲，列表就相当于一个盒子，我们可以随意的往里边加减东西，在外观上看这个盒子是始终不变的，但是内部却发生了改变。

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
In [42]: dl[-1]
Out[42]: ['a', 'b']

In [43]: id(dl[-1])
Out[43]: 139754981285888			//修改列表元素前的id

In [44]: dl[-1].pop()
Out[44]: 'b'

In [45]: dl
Out[45]: (1, 2, 3, ['a'])

In [46]: id(dl[-1])
Out[46]: 139754981285888			//修改列表元素后的id

In [48]: dl
Out[48]: (1, 2, 3, ['a', 'b'])

In [49]: dl[-1][-1]
Out[49]: 'b'

In [50]: id(dl[-1][-1])
Out[50]: 8298432

In [51]: dl[-1].insert(1,'c')

In [52]: dl
Out[52]: (1, 2, 3, ['a', 'c', 'b'])

In [53]: id(dl[-1][1])
Out[53]: 8396320

In [54]: id(dl[-1][-1])
Out[54]: 8298432

元组的优点

  1. 占用内存小；
  2. 元组内的值不会被意外的修改；
  3. 可作为字典的键；
  4. 函数的参数是以元组形式传递的。

字典

字典创建

字典可使用{}创建，但是其中的元素必须是键和值成对存在的，此称为键值对。

1
2
3
4
5
6
7
In [57]: d = {'a': 10,'b': 20}

In [58]: d
Out[58]: {'a': 10, 'b': 20}

In [59]: type(d)
Out[59]: dict

字典转换

字典的转换可以使用dict()函数进行转换，但是转换的元素需要成对。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
In [60]: li1 = [1,2,3]

In [61]: dict(li1)
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[61], line 1
----> 1 dict(li1)

TypeError: cannot convert dictionary update sequence element #0 to a sequence

In [62]: li2 = [(1,2),(3,4)]

In [63]: dict(li2)
Out[63]: {1: 2, 3: 4}

字典的key

字典中key是不允许重复的，但是值可以重复。

字典中，key可以使用整型、浮点型、布尔型、字符串、元组这些不可变类型的数据。

不可变类型的数据可以用hash()出来。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
In [64]: hash(1.1)
Out[64]: 230584300921369601

In [65]: hash(1)
Out[65]: 1

In [66]: hash(True)
Out[66]: 1

In [67]: hash('abc')
Out[67]: -1543172106383047608

In [68]: hash((1,))
Out[68]: -6644214454873602895

比较有意思的是，1和True以及0和False的hash值是一样的，通常key判断是否相同是使用hash值来进行判断，而如果我们将1和True或者0和False同时作为字典的key，那么创建出来的字典只会是一个键值对，并且key是使用的第一个key，值是使用的最后一个值。

1
2
3
4
5
6
7
8
9
In [69]: d = {1: "值1",True: "值2"}

In [70]: d
Out[70]: {1: '值2'}

In [71]: d2 = {True: "值1",1: "值2"}

In [73]: d2
Out[73]: {True: '值2'}

字典的value

字典的value可以存放多种数据类型以及多个值，甚至函数以及函数执行结果。

字典实战

1
2
3
4
5
6
7
8
9
10
11
In [4]: dic_map = {
   ...:     "Manufacturer": "manufacturer",
   ...:     "Product Name": "pod_name",
   ...:     "Serial Number": "sn"
   ...:     }

In [5]: dic_map
Out[5]: 
{'Manufacturer': 'manufacturer',
 'Product Name': 'pod_name',
 'Serial Number': 'sn'}

假如我们得到了一个line= '\tManufacturer: Alibaba Cloud'，判断Manufacturer是否在dic_map中。

1
2
3
4
5
6
In [7]: line= '\tManufacturer: Alibaba Cloud'

In [9]: s = line.strip().split(": ")[0]

In [10]: s in dic_map
Out[10]: True

假设我们需要获得指定key的vlaue值，只需要在字典后加上[key]即可。

1
2
In [11]: dic_map["Manufacturer"]
Out[11]: 'manufacturer'

对于key是否存在于字典中可以先进行判断，可以使用if进行判断，也可以使用get()进行判断，如果有就会返回对应的value，如果不存在即什么都不返回，当然也可以自定义返回参数提示不存在。

1
2
3
4
5
6
7
8
In [13]: dic_map.get(s)
Out[13]: 'manufacturer'

In [14]: dic_map.get('Manufacturer')
Out[14]: 'manufacturer'

In [15]: dic_map.get('Manufacturerr','参数不存在！')
Out[15]: '参数不存在！'

关于字典的key和value进行循环，可以先将字典的key或者vlaue提取出来。

1
2
3
4
5
In [18]: dic_map.keys()
Out[18]: dict_keys(['Manufacturer', 'Product Name', 'Serial Number'])

In [17]: dic_map.values()
Out[17]: dict_values(['manufacturer', 'pod_name', 'sn'])

如果想要同时得到key和vlaue。

1
2
3
4
5
6
7
8
In [19]: dic_map.items()
Out[19]: dict_items([('Manufacturer', 'manufacturer'), ('Product Name', 'pod_name'), ('Serial Number', 'sn')])

In [21]: list(dic_map.items())
Out[21]: 
[('Manufacturer', 'manufacturer'),
 ('Product Name', 'pod_name'),
 ('Serial Number', 'sn')]

字典修改

添加键值对

在字典中，没有的key可以直接添加，有key的再次添加会将旧值覆盖。

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
In [27]: info = {}

In [28]: info['cpu'] = 'E5'

In [29]: info['core'] = 4

In [30]: info['memory'] = [4096,4096]

In [31]: info
Out[31]: {'cpu': 'E5', 'core': 4, 'memory': [4096, 4096]}

In [32]: info['core'] = 8

In [33]: info
Out[33]: {'cpu': 'E5', 'core': 8, 'memory': [4096, 4096]}

//另外还可以使用update添加修改键值对。
In [10]: disk = {'disk': [1024]}

In [11]: info = {}

In [12]: info.update(disk)

In [13]: info
Out[13]: {'disk': [1024]}

In [14]: info.update({'core': 8})

In [15]: info
Out[15]: {'disk': [1024], 'core': 8}

对于接收到的li = ['Manufacturer: Alibaba Cloud', 'Product Name: Alibaba Cloud ECS', 'Version: pc-i440fx-2.1', 'Serial Number: 0gdkjdgv-2389-2132-9sfc-asvdfqwe13f5']，需要将冒号之前的单词映射给dic_map的value作为一个新字典，而冒号后面的值作为新字典的value。

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
In [34]: li = ['Manufacturer: Alibaba Cloud', 'Product Name: Alibaba Cloud ECS', 'Version: pc-i440fx-2.1', 'Serial Number: 0gdkjdgv-2389-2132-9sfc-asvdfqwe13f5']

In [35]: li
Out[35]: 
['Manufacturer: Alibaba Cloud',
 'Product Name: Alibaba Cloud ECS',
 'Version: pc-i440fx-2.1',
 'Serial Number: 0gdkjdgv-2389-2132-9sfc-asvdfqwe13f5']

In [36]: dic_map
Out[36]: 
{'Manufacturer': 'manufacturer',
 'Product Name': 'pod_name',
 'Serial Number': 'sn'}

In [37]: prod_info = {}

In [38]: for line in li:
   ...:     k,v = line.split(': ')
   ...:     if k in dic_map:
   ...:         new_k = dic_map[k]
   ...:         prod_info[new_k] = v

In [39]: prod_info
Out[39]: 
{'manufacturer': 'Alibaba Cloud',
 'pod_name': 'Alibaba Cloud ECS',
 'sn': '0gdkjdgv-2389-2132-9sfc-asvdfqwe13f5'}

面向字典编程

对于python是没有case控制语句的，但是3.10版本之后新加入了match...case语句与case类似，但是对于3.10以下的版本，我们可以通过字典来实现case。

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
In [16]: data = {'0': 'zero','1': 'one','2': 'two'}

In [17]: data
Out[17]: {'0': 'zero', '1': 'one', '2': 'two'}

In [18]: while True:
    ...:     arg = input(">>: ")
    ...:     v = data.get(arg,'nothing')
    ...:     print(v)
    ...: 
>>: 1
one
>>: 2
two
>>: 0
zero
>>: 
  
In [20]: data.update({'q': 'quit'})

In [21]: data
Out[21]: {'0': 'zero', '1': 'one', '2': 'two', 'q': 'quit'}

In [24]: def input_game():
    ...:     while True:
    ...:         arg = input('>>: ')
    ...:         v = data.get(arg,'nothing')
    ...:         if v == 'quit':
    ...:             break
    ...:         else:
    ...:             print(v)
    ...: 

In [25]: input_game()
>>: 1
one
>>: 2
two
>>: 0
zero
>>: q

集合

创建集合

与字典相似，但是集合只有key，因此集合就是只有key的字典。

集合与字典的符号都是{}，因此创建一个空集合需要使用set()，而集合里的元素不能出现重复，有重复的只会默认输出一个。

同样的，集合是可变的，那么集合里就不能有集合，集合里的元素是可以被HASH的元素，集合中存在字典只会保留key的值。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
In [1]: set(('disk','cpu'))
Out[1]: {'cpu', 'disk'}

In [2]: set({'disk': '64G','cpu': '4'})
Out[2]: {'cpu', 'disk'}

In [3]: set(set('disk'))
Out[3]: {'d', 'i', 'k', 's'}

In [4]: set(['disk','cpu',1,[2]])
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[4], line 1
----> 1 set(['disk','cpu',1,[2]])

TypeError: unhashable type: 'list'

In [5]: {{10}}
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[5], line 1
----> 1 {{10}}

TypeError: unhashable type: 'set'

集合运算

集合运算中，交集使用&，并集使用|。并集会将重复的值进行去重。

1
2
3
4
5
6
7
8
9
In [6]: s1 = {"198.200.39.51","198.200.39.45"}

In [7]: s2 = {"198.200.39.51","137.175.65.169"}

In [8]: s1 & s2
Out[8]: {'198.200.39.51'}

In [9]: s1 | s2
Out[9]: {'137.175.65.169', '198.200.39.45', '198.200.39.51'}

差集使用-，输出符号之前独有的元素。

1
2
3
4
5
6
7
8
9
In [6]: s1 = {"198.200.39.51","198.200.39.45"}

In [7]: s2 = {"198.200.39.51","137.175.65.169"}

In [10]: s1 - s2
Out[10]: {'198.200.39.45'}

In [11]: s2 - s1
Out[11]: {'137.175.65.169'}

异或集使用^，将集合中没有的取出生成一个新的集合。

1
2
3
4
5
6
In [6]: s1 = {"198.200.39.51","198.200.39.45"}

In [7]: s2 = {"198.200.39.51","137.175.65.169"}

In [12]: s1 ^ s2
Out[12]: {'137.175.65.169', '198.200.39.45'}

if语句

if-else

值得注意的是，在if判断中，''、False、[]、()、{}、0、None都是为假。

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
In [1]: n = input("猜数字游戏，请输入你猜的数字：")
猜数字游戏，请输入你猜的数字：18

In [2]: n = int(n)

In [3]: type(n)
Out[3]: int

In [4]: if n == 18:
   ...:     print("恭喜你，猜对了！")
   ...: else:
   ...:     print("很抱歉，你猜错了！")
   ...: 
恭喜你，猜对了！

In [10]: if n:
    ...:     print("真")
    ...: else:
    ...:     print("假")
    ...: 
假

In [11]: n = 1

In [12]: if n:
    ...:     print("真")
    ...: else:
    ...:     print("假")
    ...: 
真

if-elif

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
In [5]: n = input("猜数字游戏，请输入你猜的数字：")
猜数字游戏，请输入你猜的数字：18

In [6]: n = int(n)

In [7]: type(n)
Out[7]: int

In [8]: if n == 19:
   ...:     print("恭喜你，猜对了！")
   ...: elif n > 19:
   ...:     print("很抱歉，值大了！")
   ...: else:
   ...:     print("很抱歉，值小了！")
   ...: 
很抱歉，值小了！

循环语句

while循环

1
2
3
4
5
6
7
8
9
10
11
12
13
while 条件表达式:
    条件表达式结果为真则执行此处代码
    
while True:
    n = input("请输入你猜的数字：")
    n = int(n)
    if n == 20:
        print("恭喜你，猜对了！")
        break
    elif n > 20:
        print("很抱歉，值大了，再试试吧！")
    else:
        print("很抱歉，值小了，再试试吧！")

for循环

for循环列表

可迭代对象可以理解为被for循环的数据。比如：字符串、列表、元组、文件对象等。

1
2
3
4
5
6
7
8
9
for 变量 in 可迭代对象:
    循环体的代码，同样需要缩进四位。
    
In [16]: for item in li:
    ...:     print(item)
    ...: 
blog
777
top

for循环元组

1
2
3
4
5
6
7
In [55]: for item in dl:
    ...:     print(item)
    ...: 
1
2
3
['a', 'c', 'b']

for循环字典

对于字典内的内容可以使用for循环打印出来。并且还能进行元组解包。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
In [23]: for i in dic_map.items():
    ...:     print(i)
    ...: 
('Manufacturer', 'manufacturer')
('Product Name', 'pod_name')
('Serial Number', 'sn')

In [24]: for i in dic_map.items():
    ...:     k,v = i						//循环打印出来之后进行元组解包
    ...:     print(k,v)
    ...: 
Manufacturer manufacturer
Product Name pod_name
Serial Number sn

//除了在循环体中进行元组解包，也可以在for循环表达式中进行元组解包
In [25]: for k,v in dic_map.items():
    ...:     print(k,v)
    ...: 
Manufacturer manufacturer
Product Name pod_name
Serial Number sn

函数

函数的定义

函数名的命名规则与变量命名规则一致。

1
2
def 函数名():
    函数体，即代码，每行缩进4个空格，多行缩进保持一致。

函数的调用

python属于解释性语言，就是代码需要读一行解释器解释一行。跟shell编程中函数的定义及调用类似。需要先定义函数才能调用函数。

调用方法：

1
函数名()

示例

1
2
3
4
5
6
7
8
9
10
11
12
13
def guess_number_game():
    while True:
        n = input("请输入你猜的数字：")
        n = int(n)
        if n == 20:
            print("恭喜你，猜对了！")
            break
        elif n > 20:
            print("很抱歉，值大了，再试试吧！")
        else:
            print("很抱歉，值小了，再试试吧！")
            
guess_number_game()

函数的参数

形如def foo(x,y):中的foo函数里的x和y被称为形参，也被称为位置参数，也可以通过变量来进行传参。

函数定义了几个参数就需要传入几个参数，不能多也不能少。

另外，也可以定义默认参数，当默认参数没有参数传递时，值就使用默认定义的值，但未知参数必须传入值。

默认参数必须要放在后边，如果前一个参数定义的是默认参数，后一个是未知参数，那么会出现语法错误。

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
In [13]: def foo(x,y):
    ...:     print("x的值是:",x)
    ...:     print("y的值是:",y)
    ...: 

In [14]: foo(2,3)
x的值是: 2
y的值是: 3

In [15]: a = 1

In [16]: b = 2

In [17]: foo(a,b)
x的值是: 1
y的值是: 2

In [18]: foo(a)
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[18], line 1
----> 1 foo(a)

TypeError: foo() missing 1 required positional argument: 'y'

In [20]: foo(a)
x的值是: 1
y的值是: 10

In [21]: foo(a,b)
x的值是: 1
y的值是: 2

In [22]: foo()
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[22], line 1
----> 1 foo()

TypeError: foo() missing 1 required positional argument: 'x'

In [23]: def foo(x=10,y):
    ...:     print(x)
  Cell In[23], line 1
    def foo(x=10,y):
                 ^
SyntaxError: non-default argument follows default argument

函数的返回值

函数的执行结果可以使用返回值来查看，返回值有多个，并且返回值的数据类型没有限制。

接收函数单个返回值可以使用变量名 = 函数名()的方式对返回值进行存储。

如果需要接收多个返回值，可以使用单个字符接收全部返回值或者定义多个接收变量接收。

如果只想接收第一个可以使用n, *_ = foo()，想要接收最后一个可以使用*_, dc = foo()。

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
In [24]: def foo():
    ...:     return 1, 'hello', [1,2], {'a',1}
    ...: 

In [25]: t = foo()

In [26]: t
Out[26]: (1, 'hello', [1, 2], {1, 'a'})

In [27]: n, s ,li ,dc = foo()

In [28]: n
Out[28]: 1

In [29]: s
Out[29]: 'hello'

In [30]: li
Out[30]: [1, 2]

In [31]: dc
Out[31]: {1, 'a'}

In [32]: n,*_ = foo()

In [33]: n
Out[33]: 1

In [34]: *_, dc = foo()

In [35]: dc
Out[35]: {1, 'a'}

In [36]: *_, li, dc = foo()

In [37]: li
Out[37]: [1, 2]

In [38]: dc
Out[38]: {1, 'a'}