01：源码安装Python3

一、源码安装

安装依赖软件包

[[email protected] ~]# yum groupinstall "Development Tools"
[[email protected] ~]# yum -y install  zlib-devel bzip2-devel openssl-devel  sqlite-devel readline-devel  libffi-devel

下载源码包

可以直接点击下载，也可以右键选择复制链接地址。

[[email protected] ~]# wget https://www.python.org/ftp/python/3.7.6/Python-3.7.6.tar.xz

解压安装

[[email protected] ~]# tar -xf Python-3.7.6.tar.xz

[[email protected] ~]# cd Python-3.7.6

修改配置信息

可以选择如下两种方式之一

4.1 方式一：直接使用 vi 修改

修改文件 Python-3.7.6/Modules/Setup.dist，去掉如下几行的注释：

readline readline.c -lreadline -ltermcap

SSL=/usr/local/ssl
_ssl _ssl.c \
        -DUSE_SSL -I$(SSL)/include -I$(SSL)/include/openssl \
        -L$(SSL)/lib -lssl -lcrypto

4.2 方式二：在 shell 命令提示符下执行如下命令：

sed -ri 's/^#readline/readline/' Modules/Setup.dist
sed -ri 's/^#(SSL=)/\1/' Modules/Setup.dist
sed -ri 's/^#(_ssl)/\1/' Modules/Setup.dist 
sed -ri 's/^#([\t]*-DUSE)/\1/' Modules/Setup.dist 
sed -ri 's/^#([\t]*-L\$\(SSL\))/\1/' Modules/Setup.dist

开始编译安装

[[email protected] ~]# ./configure --enable-shared

[[email protected] ~]# make -j 2 && make install
# -j  当前主机的 cpu 核心数

–enable-shared 指定安装共享库，共享库在使用其他需调用python的软件时会用到，比如使用mod_wgsi 连接Apache与python时需要。

二、配置环境

执行如下命令

[[email protected] ~]# cmd1='export LD_LIBRARY_PATH='
[[email protected] ~]# cmd2='$LD_LIBRARY_PATH:/usr/local/lib'
[[email protected] ~]# file="/etc/profile.d/python3_lib.sh"
[[email protected] ~]# echo "${cmd1}${cmd2}" >$file

[[email protected] ~]# path="l"
[[email protected] ~]# file2="/etc/ld.so.conf.d/python3.conf"
[[email protected] ~]# echo ${path} > $file2

接下来，执行如下命令使配置好的环境信息生效

[[email protected] ~]# ldconfig
[[email protected] ~]# source /etc/profile

三、测试安装

测试 python3

[[email protected] ~]#  python3 -V
Python 3.7.6
[[email protected] ~]#

假如上面显示的含有 Python3.7.6 就没问题了

测试 pip3

[[email protected] ~]# pip3 -V
pip 20.0.2 from /usr/local/lib/python3.7/site-packages/pip (python 3.7)

输出的信息中的目录
/usr/local/lib/python3.7/site-packages/
是用于存放安装的第三方模块的

四、配置使用本地的源安装第三方模块

在当前用户的家目录下创建一个隐藏的目录 .pip

[[email protected] ~]# mkdir ~/.pip

执行如下命令，以便写入国内的源：

[[email protected] ~]# echo '[global]' >> ~/.pip/pip.conf
[[email protected] ~]# c1="index-url=https://"
[[email protected] ~]# c2="mirrors.aliyun.com/pypi/simple"
[[email protected] ~]# echo "${c1}${c2}" >> ~/.pip/pip.conf

豆瓣源: https://pypi.douban.com/simple/
阿里源: https://mirrors.aliyun.com/pypi/simple

测试配置正确行

可以安装一个增强版的解释器 ipython 用于测试后面也会用的这个模块

[[email protected] ~]# pip3  install ipython

python 不支持执行系统命令

ipython 增强版本，支持执行系统命令

02：ipython的基本使用

一、安装

[[email protected] ~]# pip3 install ipython

二、基本使用

启动 Ipython

[[email protected] ~]# ipython

特点

支持 Tab 键补全

连续按下两次 Tab 键即可

可以查看函数的源码

方法：??函数名

In [5]: ??open   # 按下回车即可查看 open 函数的源码，输入 q 退出源码

可以执行系统命令

方法： !命令

In [6]: !vi hello.py

输入如下内容，并保存退出

执行脚本程序

In [8]: %run hello.py
hello

In [9]:

03：猜数游戏开始学习基本语法

一、需求

假设目前需要写一个小的程序，程序的功能非常简单，就叫猜数游戏吧。

给用户一个提示信息，让其输入一个数字
接着拿用户输入的数字和 18 进行比较大小
等于 18 , 就输出 “相等”
小于 18，就输出 “小了”
大于 18，就输出 “大了”

二、需求分析和分解技术点

程序和用户交互

思考一下，如何实现？

我们可以分析一下

给提示信息，让其输入一个数字

这里会用的和用户的交互，就是程序和用户的交互。

python 中使用 input 函数实现

input("这里写提示信息， 必须使用引号引起来")

变量

那用户的输入可以使用一个变量接收

输入的都是字符类型是字符串

n = input("请输入一个数字")

2.1 变量命名潜规则:

不要以单下划线和双下划线开头；如：_user或 __user
变量命名要易读；如：user_name,而不是username
不用使用标准库中(内置)的模块名或者第三方的模块名
不要用这些 Python 内置的关键字：

>>> import keyword
>>> keyword.kwlist
['False', 'None', 'True', 'and', 'as', 'assert', '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']

2.2 如何理解 python 的变量赋值

在 python 中究竟该如何正确理解变量的赋值过程呢？

s = 'hello'

以上的变量赋值，应该说成把变量名 s 分配给 hello 这个对象更合理。

hello 这个对象会在内存中先被创建，之后再把变量名 s 分配给这个对象。

所以要理解 Python 中的变量赋值，应该始终先看等号右边。

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

一个对象可以有多个标签或者名字。
比如：我们自己就有很多名字，身份证上的名字，网络昵称等。

请看下面的代码示例：

a = 1
b = a
a = 2
print(b)  # b 会是 ?

a = 1 时如下图：

b = a 时如下图:

a = 2 时如下图:

上面的 b = a 我们称它为 传递引用，此时对象会拥有两个名称(标签) ，分别是 a 和 b

2.3 多元赋值

字符串、列表、元组的多元赋值统称为元祖解包

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

规范写法是等号两边和逗号后面都有空格

In [9]: n1, n2 = 1, 2

In [10]: n1
Out[10]: 1

字符串的解包是按照字符分割的
In [11]: n2
Out[11]: 2
In [75]: s1, s2 = '12'

In [76]: s1
Out[76]: '1'

In [77]: s2
Out[77]: '2'

列表的解包是按照元素分割的
In [78]: num, s = [10, 'hello']   # 这个是列表， 后面会讲到

In [79]: num
Out[79]: 10

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

好，至此，我们解决了使用变量来接收用户的输入，接下来就要解决判断的问题了。
那 python 中如何进行判断呢？

要判断需要使用判断条件

python 中的判断条件

>>> n = 10
>>> n == 10 # 等于
True              # 条件为真，则返回 True
>>> n != 10 # 不等于
False             # 条件为假，则返回 False
>>> n > 10  # 大于
False
>>> n < 10  # 小于
False
>>> n >= 10  # 大于等于
True
>>> n <= 10 # 小于等于
True
>>>

那接下来，在 Ipython 中来实际操作一下

In [1]: n = input("请输入一个数字>>:")
请输入一个数字>>:10

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

In [3]:

会发现返回 False
在编程语言中，数据是有类型之分的。
input() 接收到的任何数据都会成为字符串类型(str)，就是普通的字符串
而我们等号右边的 10 是整型(int)

数据类型

4.1 查看数据的类型，使用 type

In [3]: type(n)    # 查看 input 接收到的数据类型
Out[3]: str

In [4]: type(10)
Out[4]: int

In [5]:

4.2 基本的数据类型

记住：整型、浮点型、字符串、布尔型、二进制

整型(int)

In [11]: type(0)
Out[11]: int

In [12]: type(-1)
Out[12]: int

In [13]: type(1)
Out[13]: int

浮点型（带小数点的小数）

In [17]: type(1.1)
Out[17]: float

In [18]: type(-0.1)
Out[18]: float

布尔型

In [19]: type(True)
Out[19]: bool

In [20]: type(False)
Out[20]: bool

字符串(str)

In [14]: type('10')
Out[14]: str

In [15]: type('hello')
Out[15]: str

In [16]: type('-1.1')
Out[16]: str

In [17]:

二进制(bytes)

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-fEfWkWZ2-1600591396517)(/root/Bilder/2020-09-20 14-11-32 的屏幕截图.png)]

In [18]: type(b'hello')
Out[18]: bytes

我们来验证一下 input 接收的数据的类型

In [36]: n = input("请输入一个数字>>:")
请输入一个数字>>:10

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

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

要想把用户的输入(str)和整型(int)进行正确的比较大小，就需要把字符串类型的数据转换整型。
这种把一个数据从一个类型转换为另外一个类型的操作叫类型装换

类型转换

转换为 int

In [21]: int('10')
Out[21]: 10

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

In [23]: int(1.9)
Out[23]: 1

转换为 float

In [25]: float(1)
Out[25]: 1.0

In [26]: float(-1)
Out[26]: -1.0

In [27]: float('1.1')
Out[27]: 1.1

转换为 str

In [28]: str(111)
Out[28]: '111'

In [29]: str(-111)
Out[29]: '-111'

In [30]: str(-11.1)
Out[30]: '-11.1'

In [31]: str(b'hello', encoding='utf-8')
Out[31]: 'hello'
注意：'utf-8'　用引号引起来

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

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-SZ8t1E6A-1600591396520)(/root/Bilder/2020-09-20 14-24-56 的屏幕截图.png)]

转换为二进制

In [32]: bytes('千锋', encoding='utf-8')
Out[32]: b'\xe5\x8d\x83\xe9\x94\x8b'

In [58]: b = bytes('千锋', encoding='utf-8')

In [59]: b
Out[59]: b'\xe5\x8d\x83\xe9\x94\x8b'

In [60]: str(b, encoding='utf-8')
Out[60]: '千锋'

In [61]: s= str(b, encoding='utf-8')

In [62]: s
Out[62]: '千锋'

In [63]: type(s)
Out[63]: str

注意字符串转二进制，二进制转字符串，需要指定字符编码

if 判断语句

python中，所有结构语句用：号开头

通过字符缩进判断结束

判断条件可以用在 if 判断语句中
语法结构是这样的：

语法一：

if  判断条件:   # 冒号必须的
    如果判断条件为真，执行这里的代码，这里的代码必须缩进4个空格
    并且每一行代码的缩进要一致

示例：

In [39]: n = input("请输入一个数字>>:")
请输入一个数字>>:18

注意输入的是字符串类型，判断大小需要转换成整型
    
In [40]: n = int(n)

In [41]: if n == 18:
    ...:     print("相等")
    ...:
相等

语法二：

if  判断条件:
    如果判断条件为真，执行这里的代码
else:   # 这里的冒号也是必须的
    如果判断条件为假，执行这里的代码，这里的代码必须缩进4个空格
    并且每一行代码的缩进都要一致

示例：

In [44]: if n == 10:
    ...:     print("相等")
    ...: else:
    ...:     print("不相等")
    ...:
不相等

语法三：

if  判断条件:
    如果判断条件添加为真，执行这里的代码，这里的代码必须缩进4个空格
    并且每一行代码的缩进要一致
elif  判断条件:   # 这里同样需要加条件
    如果判断条件添加为真，执行这里的代码，这里的代码必须缩进4个空格
    并且每一行代码的缩进要一致
else:   # 这里的冒号也是必须的
    如果判断条件为假，执行这里的代码，这里的代码必须缩进4个空格
    并且每一行代码的缩进都要一致

elif 根据需求可以出现多个

示例:

In [51]: n = 20

In [52]: if n == 10:
    ...:     print("相等")
    ...: elif n > 10:
    ...:     print("大了")
    ...: else:
    ...:     print("小了")
    ...:
大了

做实验，特结论

下面的代码会打印出几次 'ok'

一个，执行第一个就不往后执行了

if 1 == 1:
    print("ok")
elif  2 == 2:
    print("ok")
elif 3 == 3:
    print("ok")

三、Python 程序

在生产中，通常我们会把程序的代码写的一个文件种，这个文件就成为 Python 的一个程序文件，文件名一般都是以 .py 为结尾，有时候也成为一个 python 的程序。

使用 vi 编辑器,来把我们这个猜数游戏的小程序写一下吧

#!/usr/bin/env python3
# file name hello.py

print("猜数游戏开始")

n = input("请输入一个数字")
n = int(n)

if n == 18:
    print("猜对了")
elif  n > 18:
    print("大了")
else:
    print("小了")

第一行不是注释，和 shell 脚本一样，是在声明这个脚本默认使用的解释器

执行 python 程序

[[email protected] ~]# ./hello.py
猜数游戏开始
请输入一个数字8
小了

四、 while 循环

语法：

while 条件表达式:
    条件表达示为真，就执行这里的代码，必须缩进 4 个空格
    多行代码保持缩进一致

条件表达式可以是:

True # 布尔值的 True

1 < 10 # 凡是在 if 语句中使用的判断表达示，这里都可以使用

猜数游戏优化版本

#!/usr/bin/env python3

print("猜数游戏开始")

while True:
    n = input("请输入一个数字")

    # 如果输入空，就重新开始新一轮的循环
    if not n:
        continue

    # 如果输入 q 就是跳出循环
    if n == 'q':
        break

    n = int(n)

    if n == 18:
        print("猜对了")
    elif  n > 18:
        print("大了")
    else:
        print("小了")

# 退出循环后，程序继续运行下面的代码
exit("退出程序..")

[root@sun mnt]# python3 sun.py 
>>:q
退出程序
python3编译可以exit

ipython里面不支持

五、函数的定义和调用

函数的定义

def 函数名():
    """函数的说明，主要是说明一下函数的主要功能，这是可选的"""
    函数体，就是代码
    缩进 4 个空格，多行缩进保持一致

函数名的规则和变量名的命名规则一致

函数的调用

调用方式:

函数名()

python 属于解释性语言，就是代码需要读一行，解释器解释一行。
因此，函数就像是定义一个变量，必须先定义函数，才能调用函数。

示例

def  foo():
    print("我是函数体，只有在调用函数时，这里的代码才会被执行")

foo()
执行后会输出：
我是函数体，只有在调用函数时，这里的代码才会被执行

那我们现在可以把之前写的猜数游戏，编写函数

#!/usr/bin/env python3

def guess_number():
    """输入一个数字，和18 比较大小"""
    print("猜数游戏开始")

    while True:
        n = input("请输入一个数字")

        # 如果输入空，就重新开始新一轮的循环
        if not n:
            continue

        # 如果输入 q 就是跳出循环
        if n == 'q':
            break

        n = int(n)

        if n == 18:
            print("猜对了")
        elif  n > 18:
            print("大了")
        else:
            print("小了")


# 调用函数
guess_number()

exit("退出程序..")

六、今日作业：

编写一个小程序，实现如下效果

用户输入一个数字，返回对应的服务名称，加上没有对应的服务，就返回未知的服务。
输入q 退出

python的两个条件同时满足用　and　连接

python的两个条件满足一个用 or 连接

其他写法不支持

[[email protected] ~]# python3 search_server.py
常用端口-->查询程序
请输入一个常用的服务默认端口号:80
HTTP 服务
请输入一个常用的服务默认端口号:22
SSHD 服务
请输入一个常用的服务默认端口号:21
FTP 服务
请输入一个常用的服务默认端口号:3306
Mysql 服务
请输入一个常用的服务默认端口号:9080
未知服务
请输入一个常用的服务默认端口号:

常见服务的端口号：

ftp 20、21
ssh 22
Telnet 23
DNS 53
HTTP、Niginx 80
NTP 123/udp
HTTPS 443
rsyslog 514
NFS 2049/tcp
mysql 3306
redis 6379
Weblogic 7001
tomcat 8080（8005、8009）
php 9000
zabbix 10050 10051

while True:
    n = input("请输入要查询的端口号>>:")
    if not n:
        continue
    if n == 'q':
        break

    n = int(n)
    if n == 20 or n == 21:
        print("ftp服务")
    elif n == 22:
        print("ssh服务")
    elif n == 23:
        print("telnet服务")
    elif n == 53:
        print("DNS服务")
    elif n == 80:
        print("HTTP、Niginx服务")
    elif n == 443:
        print("HTTPS服务")
    elif n == 514:
        print("rsyslog服务")
    elif n == 2049:
        print("NFS服务")
    elif n == 3306:
        print("Mysql服务")
    elif n == 6379:
        print("Redis服务")
    elif n == 7001:
        print("weblogc服务")
    elif n == 8080 or n == 8005 or n == 8009:
        print("tomcat服务")
    elif n == 9000:
        print("php服务")
    elif n == 10050 or n == 10051:
        print("zabbix服务")
    else:
        print("未知服务")

04：VSCode的部署和使用

一、下载安装

打开浏览器

输入百度的网址并搜索 vscode

打开官网

点击

按照提示安装即可

也可以右键打开终端，输入如下命令进行安装

[[email protected] ~] sudo rpm --import https://packages.microsoft.com/keys/microsoft.asc
[[email protected] ~]# sh -c 'echo -e "[code]\nname=Visual Studio Code\nbaseurl=https://packages.microsoft.com\
/yumrepos/vscode\nenabled=1\ngpgcheck=1\ngpgkey=\
https://packages.microsoft.com/keys/microsoft.asc" > /etc/yum.repos.d/vscode.repo'
[[email protected] ~]# yum check-update
[[email protected] ~]# yum install code

添加桌面快捷方式

在终端中输入如下命令

[[email protected] ~]# cp /usr/share/applications/code.desktop ~/桌面/
或者
[[email protected] ~]# cp /usr/share/applications/code.desktop ~/Desktop/

接下来双击桌面快捷方式，再点击 标记为信任

完成

二、安装插件

双击桌面图标打开软件
打开商店，安装中文简体插件

重启软件生效

汉化完成

安装文档图标

接下来会自动提示设置图标主题

三、基本设置

打开配置文件方式

添加如下内容到 settings.json 配置文件中,并按下 Control + s 保存

{
    
    
    "editor.fontSize": 30,
    "debug.console.fontSize": 30,
    "markdown.preview.fontSize": 26,
    "terminal.integrated.fontSize": 30,
    //  编辑的文件 每 1 秒自动保存一次
    "files.autoSave": "afterDelay"
}

完成后的样子

鼠标悬停到某一行，会自动显示当前配置项的意义

四、创建一个 python 文件

创建的文件需要有对应的扩展名，有了对应的扩展名，VSCode 就会自动识别，并提示安装对应的插件进行支持。

比如下面创建一个 python 的文件的步骤

可以在当前用户的家目录下，创建一个文件夹 python_code

[[email protected] ~]# mkdir python_code

接下来在 VSCode 中打开这个文件夹

目前打开的这个目录就是一个项目的主目录，项目所有的代码都应该放到这个目录下，可以在这个目录下再创建其他目录（稍后介绍）。

重要：在VSCode 看来，这个目录就是当前的工作目录，假设在 vscode 中执行的代码的相对路径，就是相对于这个目录的，而不会是这个目录下面的其他目录。

鼠标点击项目目录会出现创建文档的图标

安装对应的插件

VSCode 会自动提示安装对应的插件

配置默认的 python 解释器

vscode 默认选择的python 解释器是 python2.7 ，我们需要的是 python3

接下来会提示安装用于 python 语法检测的插件 pylint

这个插件会突出显示了Python源代码中的语法和风格问题，通常可以帮助您识别和纠正细微的编程错误或可能导致错误的非常规编码实践。
例如，检测未使用或未定义的变量的使用，对未定义函数的调用，缺少括号以及甚至更细微的问题，
例如尝试重新定义内置类型或函数。
因此，与Formatting不同，因为这个插件分析代码的运行方式并检测错误，而Formatting仅重组代码的显示方式。

五、编辑代码并运行

运行的输出结果

六、安装 Code Runner

刚刚的执行方式有点小缺点，当你重复执行这个文件的时候，之前的输出在终端中不能清除，这可能会影响观看。使用 code runner 插件可以解决，并且它支持多重语言。

安装 Code Runner

配置 Run Code

再次打开配置文件 settings.json 文件添加如下内容，并按下 Control + s 保存

    "code-runner.clearPreviousOutput": true,
    "code-runner.runInTerminal": true,
    // 每次运行文件之前，保存当前文件
    "code-runner.saveFileBeforeRun": true,
    // 默认的语言
    "code-runner.defaultLanguage": "python",
    // 每次运行文件前 保存所有的文件
    "code-runner.saveAllFilesBeforeRun": true,
    // 设置 phthon3 解释器路径
    "code-runner.executorMap": {
    
    
        "python": "/usr/local/bin/python3"
    }

七、最终的配置文件

{
    
    
    "workbench.iconTheme": "vscode-icons",
    "editor.fontSize": 30,
    "debug.console.fontSize": 30,
    "markdown.preview.fontSize": 26,
    "terminal.integrated.fontSize": 30,
    //  编辑的文件 每 1 秒自动保存一次
    "files.autoSave": "afterDelay",
    "code-runner.clearPreviousOutput": true,
    "code-runner.runInTerminal": true,
    "code-runner.saveFileBeforeRun": true,
    "code-runner.defaultLanguage": "python",
    "code-runner.saveAllFilesBeforeRun": true,
    // set python path
    "code-runner.executorMap": {
    
    
        "python": "/usr/local/bin/python3"
    }
}

八、部分快捷键

快速添加注释

鼠标点击某一行，同时按下 Ctrl 和 ?/, 重复按下取消注释

快速复制一行

通用鼠标选中需要复制的行，之后先按住 Ctrl 和 Shift 不放，再按下方向键,会向下自动复制被选中的内容。

05：字符串和数据的切片

两行代码下载网站数据

一、创建

s1 = 'lenovo'
s2 = "QF"
s3 = """hello lenovo"""
s4 = '''hello 千锋云计算'''
s5 = """hello
shark
"""
s6 = '''hello
world'''

二、简单使用

\ 转义符

testimony = 'This shirt doesn\'t fit me'

words = 'hello \nshark'

+ 拼接

In [1]: file_name= "成功的21个信念"

In [2]: suffix = '.txt'

In [3]: file_name = file_name + suffix

In [4]: file_name
Out[4]: '成功的21个信念.txt'

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

In [5]: '西瓜甜' + 1   ## 这会报错的

* 复制

python中支持字符串的乘法复制

In [6]: "-" * 10
Out[6]: '----------'

In [7]: print('*' * 10)
**********

三、取值和切片

字符串是 Python 中的一个序列类型的数据结构

存放的数据，在其内是有序的。

s1 = "shark"

序列类型的特点

序列里的每个数据被称为序列的一个元素
元素在序列里都是有个自己的位置的，这个位置被称为索引或

者叫偏移量，也有叫下标的，从 0 开始，从左到右依次递增
序列中的每一个元素可以通过这个元素的索引来获取到
获取到序列类型数据中的多个元素需要用切片的操作来获取

通过索引取值，获取单个元素

In [10]: s1 = "shark"

In [11]: s1[0]
Out[11]: 's'

In [12]: s1[-1]
Out[12]: 'k'

In [13]: s1[3]
Out[13]: 'r'

切片，获取多个元素

str[从索引号开始取：到第几个结束：每隔n-1个取一次]

3.1 一般操作

# 使用切片获取多个元素
In [15]: s1[0:3]
Out[15]: 'sha'

# 起始和结尾的索引号可以省略
In [16]: s1[:3]
Out[16]: 'sha'

In [17]: s1[1:]
Out[17]: 'hark'

# 索引可以使用 负数
In [18]: s1[2:-1]
Out[18]: 'ar'

In [19]:

去掉最后一个字符
In [13]: s1[:-1]
Out[13]: 'shar'
去掉第一个字符
In [14]: s1[1:]
Out[14]: 'hark'

下面这样的操作，臣妾做不到

>>> s1[-1:-3]
''
>>>

因为默认的切片是从左向右开始操作，索引号 -1 的右边没有任何索引号了
-3 在 -1 的左边

3.2 使用步长

步长就是每数几个取一个的意思

步长是正数时，是从左向右开始操作

步长是负数时，是从右向左操作

In [19]: s2 = 'abcdefg'

In [20]: s2[::2]
Out[20]: 'aceg'

In [21]: s2[::-1]
Out[21]: 'gfedcba'

In [22]: s2[::-2]
Out[22]: 'geca'

四、字符串方法

统计序列数据的长度

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

# 获取字符串的长度，包含空格和换行符
In [25]: s3 = "a \n\t"

In [26]: len(s3)
Out[26]: 4

\n 是一个换行符
\t 是一个 Tab 键

in 成员判断

In [39]: line = 'Size: 8192 MB'

In [40]: if 'Size' in line:
    ...:     print(line)
    ...:
    Size: 8192 MB

注意：空的字符串总是被视为任何其他字符串的子串，因此 "" in "abc" 将返回 True。

strip() 去除字符串两端的空白字符（空格、\t、 \n）

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-qvJHFtpc-1600602992531)(/root/Bilder/2020-09-16 11-45-03 的屏幕截图.png)]

Out[41]: line = '    Size: 8192 MB'

In [42]: line.strip()
Out[42]: 'Size: 8192 MB'

字符串两边的任意都可以擦除（传递要擦除的参数）
In [31]: s = "sun"
In [33]: s.strip('n')
Out[33]: 'su'

In [34]: s.strip('sn')
Out[34]: 'u'
    
In [35]: s.strip('un')
Out[35]: 's'

split() 分割

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-0U5Vkgbv-1600602992535)(/root/Bilder/2020-09-16 11-46-10 的屏幕截图.png)]

默认使用空白字符作为分隔符（空格、\t、 \n）
和 shell 中的 awk 一样道理

In [47]: line
Out[47]: '    Size: 8192 MB'

In [48]: line.split()
Out[48]: ['Size:', '8192', 'MB']

In [49]: s
Out[49]: '\tab\n'

In [50]: s.split()
Out[50]: ['ab']

可以指定分隔符

In [51]: line.split(':')
Out[51]: ['    Size', ' 8192 MB']
指定多个分割符号，空格放在后面
In [52]: line.split(': ')
Out[52]: ['    Size', '8192 MB']

strip() 返回的是字符串，所以可以连续操作

In [73]: line.strip().split(': ')
Out[73]: ['Size', '8192 MB']

In [74]: line
Out[74]: '    Size: 8192 MB'

In [75]: k, v = line.strip().split(': ')

In [76]: k
Out[76]: 'Size'

In [77]: v
Out[77]: '8192 MB'

replace() 替换

In [65]: line = '　　<strong>10、命运在自己手里，而不是在别人的嘴里</strong></p>'

In [66]: line.strip()   ## 先去除两端空白字符
Out[66]: '<strong>10、命运在自己手里，而不是在别人的嘴里</strong></p>'

In [67]: line.strip().replace('strong>', '')    ## 将字符串 strong> 替换为空
Out[67]: '<10、命运在自己手里，而不是在别人的嘴里</</p>'

In [68]: line.strip().replace('strong>', '')[1:-6]
Out[68]: '10、命运在自己手里，而不是在别人的嘴里'
    
In [36]: s
Out[36]: 'sun'

In [37]: s.replace('s','ji')
Out[37]: 'jiu

字符串.replace('查找的内容','替换的内容')

startswith() 判断字符串以什么为开头

In [85]: line = 'Locator: DIMM_A2'

In [86]: line.startswith("Locator:")
Out[86]: True

endswith() 判断字符串以什么为结尾

In [87]: line = 'Size: 8192 MB'

In [88]: line.endswith('MB')
Out[88]: True

五、字符串的判断（扩展自修）

In [1]: s = '123'

In [2]: s.isdigit()   # 判断是否是纯数字
Out[2]: True

In [3]: s1 = '123adb'  

In [4]: s1.isalnum()  # 判断是否是数字和字母
Out[4]: True

In [5]: s2 = 'adb'

In [6]: s2.isalpha()  # 判断是否是纯字母
Out[6]: True

In [7]: s2.encode()   # 转换为二进制 bytes 类型
Out[7]: b'adb'

In [8]: s4 = "云计算"

In [9]: s4.encode()   # 转换为二进制 bytes 类型，默认编码 utf-8
Out[9]: b'\xe4\xba\x91\xe8\xae\xa1\xe7\xae\x97'

In [16]: b = s4.encode()  

In [17]: b.hex()      # bytes 转换成 16 进制
Out[17]: 'e4ba91e8aea1e7ae97'
  
In [18]: b.decode()   # bytes 转换成 str，默认编码 utf-8
Out[18]: '云计算'

06：列表、元组

两行代码下载网站数据

一、列表

列表的特性介绍

千锋云计算

列表和字符串一样也是序列类型的数据

列表内的元素直接用英文的逗号隔开，元素是可变的，所以列表是可变的数据类型，而字符串不是。

列表中的元素可以是 Python 中的任何类型的数据对象

如：字符串、列表、元组、字典、集合、函数

列表中的具有相同值的元素允许出现多次

[1, 2, 1, 1, 1, 1, 3, 3, 2]

创建列表

嵌套的列表

列表中可包含 python 中任何类型的元素(对象)，当然也可以包括一个或多个列表

li = [['one', 'two', 'three'], [1, 2, 3]]

列表的基本操作

4.1 取值和就地修改

没有嵌套的列表取值

In [90]: l2 = ['insert', 'append', 'remove', 'pop', 'sort']

In [91]: l2[0]
Out[91]: 'insert'

In [92]: l2[-1]
Out[92]: 'sort'

4.2 嵌套的列表取值

In [93]: l3 = [['one', 'two', 'three'], [1, 2, 3]]

In [94]: l3[0]
Out[94]: ['one', 'two', 'three']

In [95]: ll = l3[0]

In [96]: ll[1]
Out[96]: 'two'

In [97]: l3[0][1]
Out[97]: 'two'

4.3 就地修改

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

In [113]: li
Out[113]: ['qfedu.com', 1314, '521']

In [114]: li[0] = '千锋教育'

In [115]: li
Out[115]: ['千锋教育', 1314, '521']
    
In [79]: li[1:]
Out[79]: [1314, '521']

In [80]: li[1:] = ['jiji']
列表重新赋值，是列表格式
li[1:] = ''
删除列表的值

4.3 切片

同字符串的切片一样,详情参考字符串教程中的切片

几点简单示例

In [100]: line = 'Size: 8192 MB\n'
    
In [66]: line.split('\n')[0].split(': ')
Out[66]: ['Size', '8192 MB']
可以指定连续的多个分隔符


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

In [102]: l5 = line.split('\n')

In [103]: l5[:-1]
Out[103]: ['Size: 8192 MB']

In [104]: line.split('\n')[:-1]   # 可以直接连续操作
Out[104]: ['Size: 8192 MB']
去掉最后一个

4.4 必会方法

len() 适合字符串、列表、元组
方法是一个内置函数，可以统计序列类型的数据结构的长度。

In [108]: li = ['qfedu.com', 1314, '521']

In [109]: len(li)
Out[109]: 3

in
判断元素是否存在于列表中。

适合字符串、列表、元组

In [3]: li = ['qfedu.com', 1314, '521']

    
In [4]: '521' in li
Out[4]: True

In [5]: 1314 in li
Out[5]: True

In [6]: if 'qfedu.com' in li:
   ...:     print('ok')
   ...:
ok

In [7]:

append() 真正可以改变列表

每次只能在列表最后插入一个元素

没有返回值，不能被变量接收

向列表的最后位置，添加一个元素，只接收一个参数。

In [7]: li.append(521)

In [8]: li
Out[8]: ['qfedu.com', 1314, '521', 521]

insert()

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

没有返回值，不能被变量接收

In [9]: li.insert(0, 521)

In [10]: li
Out[10]: [521, 'qfedu.com', 1314, '521', 521]

remove()

移除列表中某个指定的元素，，并且假如有多个相同值的元素存在，每次只会移除排在最前面的那个元素

没有返回值，不能被变量接收

In [14]: li.remove(521)

In [15]: li
Out[15]: ['qfedu.com', 1314, '521', 521, 'qf', 'yangge']

pop()

默认删除最后一个

从原列表中删除一个元素，并且把这个元素返回，有返回，就可以用变量接收
接收零个或一个参数，参数是偏移量，int 类型。

# 删除列表中的最后一个元素
In [16]: name = li.pop()

In [17]: name
Out[17]: 'yangge'

In [18]: li
Out[18]: ['qfedu.com', 1314, '521', 521, 'qf']

 # 删除列表中第二个索引号对应的元素，并且返回这个元素，用变量名`n` 接收。  
In [19]: n = li.pop(-2)

In [20]: n
Out[20]: 521

In [21]: li
Out[21]: ['qfedu.com', 1314, '521', 'qf']

循环列表

5.1 for 循环语法

for 变量   in   可迭代对象:
    循环体的代码,必须缩进 4 个空格
    多行代码缩进要一致

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

for-list.py 文件内容如下：

li = ['qfedu.com', 1314, '521', 'qf']

for item in li:
    print(item)

执行

python3 for-list.py

输出结果

qfedu.com
1314
521
qf

二、元组

元组特点

元组和列表一样，也是一种序列类型的数据。
唯一的不同是，元组是相对不可变的。

高效创建元组

t1 = ()    # 创建 空 元素的元组

单一元素元组怎么搞？
有元素的元组实际上是使用英文的逗号创建的

In [168]: n = (3)

In [169]: t = 3,

In [170]: type(n)

Out[170]: int

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

创建非空元素的元组是用逗号，而不是用小括号

转换

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

In [173]: s1 = 'car'

In [174]: li = [1,2,3]

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

In [176]: tuple(li)
Out[176]: (1, 2, 3)

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

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

元组的取值

元组也是序列类型的数据，取值和切片和列表的操作一样

In [33]: t1 = (1, 2, 3, ['a', 'b'])
In [34]: t1[3][0]=0
In [35]: t1
Out[35]: (1, 2, 3, [0, 'b'])

元组的方法

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

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

In [117]: t1 = (1,'hello', ['a', 'b'])
In [4]: t1.count(1)
Out[4]: 1

In [5]: t1.index('hello')
Out[5]: 1

In [118]: t1.            # 按 Tab 键
count index    # 可以看出没有可以改变其自身的方法

元组的相对不可变

元组本身是不可变的，就是元组内的元素是不可变的，一旦创建一个元组，这个元组内的元素个数和数据都是固定的了
相对不可变的意思是，元组内的元素自身是可变的数据对象，就可以通过修改这个可变元素，来间接改变元组的样子。

说下面的示例之前，先说一个内置函数 id(), 这个函数可以返回python 中一个对象的内存地址（id 号）

In [119]: id('hello')
Out[119]: 4478905344

In [120]: id(t1)
Out[120]: 4479260568

In [121]: id(t1[-1])
Out[121]: 4478661192

接下来就来验证元组是相对不可变的

假设我想把上个示例中的元组 t1 中的最后一个元素，修改为 ['a']

In [122]: t1[-1]
Out[122]: ['a', 'b']

In [123]: t1[-1] = ['a']
-----------------------------------------------------------------------
TypeError                             Traceback (most recent call last)
<ipython-input-123-9d326d207854> in <module>
----> 1 t1[-1] = ['a']

TypeError: 'tuple' object does not support item assignment

可以看到，我们不能通过元组的索引就地复制为 ['a']
但是，元组中的最后一个元素是列表，列表中的元素是可以改变的，所以可以直接操作列表本身就行

In [129]: t1 = (1,'hello', ['a', 'b'])

In [130]: t1[-1]
Out[130]: ['a', 'b']

In [131]: id(t1[-1])           # 改变前的 id
Out[131]: 4473983368

In [132]: t1[-1].pop()
Out[132]: 'b'

In [133]: t1
Out[133]: (1, 'hello', ['a'])

In [134]: id(t1[-1])          # 改变后的 id
Out[134]: 4473983368

for 循环元组

for-tuple.py 文件内容

t = ('qfedu.com', 1314, 521)

for item in t:
    print(item)

执行

python3 for-tuple.py

输出结果

qfedu.com
1314
521

元组的优点

给我一个理由

占用内存空间小
元组内的值不会被意外的修改
可作为字典的键
函数的参数是以元组形式传递的

07：获取服务器信息

获取 CPU 信息

先看这个： https://www.jianshu.com/p/150c13ec54d4

二、Python 代码

1 获取 CPU 信息

获取物理CPU型号

grep 'model name' /proc/cpuinfo |sort| uniq |wc -l

In [1]: import subprocess

In [2]: cmd_cpu_name = "grep 'model name' /proc/cpuinfo | uniq"

In [3]: subprocess.getoutput(cmd_cpu_name)
Out[3]: 'model name\t: Intel(R) Xeon(R) Platinum 8163 CPU @ 2.50GHz'

In [4]: cpu_name = subprocess.getoutput(cmd_cpu_name).split(": ")[1]

In [5]: cpu_name
Out[5]: 'Intel(R) Xeon(R) Platinum 8163 CPU @ 2.50GHz'

查看物理CPU颗数

grep 'physical id' /proc/cpuinfo | sort -u | wc -l

In [8]: cmd_cpu_pyc = "grep 'physical id' /proc/cpuinfo | sort -u | wc -l"

In [9]: subprocess.getoutput(cmd_cpu_pyc)
Out[9]: '1'

In [10]: cpu_pyc = subprocess.getoutput(cmd_cpu_pyc)
    
In [11]: cpu_pyc = int(cpu_pyc)

查看每颗物理 CPU 的核心数

grep 'cpu cores' /proc/cpuinfo | uniq   # 每颗 CPU 的核心数，不是总核心数

In [13]: subprocess.getoutput("grep 'cpu cores' /proc/cpuinfo | uniq")
Out[13]: 'cpu cores\t: 1'

In [14]: cpu_cores_each = subprocess.getoutput("grep 'cpu cores' /proc/cpuinfo | uniq")

In [15]: cpu_cores_each = cpu_cores_each.split(": ")[1]

In [16]: cpu_cores_each = int(cpu_cores_each)

In [17]: cpu_cores_each
Out[17]: 1

2 获取 IP 地址信息

In [2]: from subprocess import getoutput

In [3]: ret = getoutput("ip a")

In [4]: ips = []
   ...: for line in ret.splitlines():
   ...:     if 'inet ' in line and '127.0.0.1' not in line:
   ...:         _,ip,*_,net_name = line.split()
   ...:         ips.append([net_name, ip])
   ...:

In [7]: ips
Out[7]: [['ens33', '10.11.59.169/24'], ['ens37', '192.168.8.128/24']]

3 获取硬盘信息

In [8]: from subprocess import getoutput

In [9]: ret = getoutput("lsblk")

In [10]: print(ret)
NAME            MAJ:MIN RM  SIZE RO TYPE MOUNTPOINT
sda               8:0    0   30G  0 disk
├─sda1            8:1    0    1G  0 part /boot
└─sda2            8:2    0   29G  0 part
  ├─centos-root 253:0    0   27G  0 lvm  /
  └─centos-swap 253:1    0    2G  0 lvm  [SWAP]
sdb               8:16   0    5G  0 disk
sr0              11:0    1  4.3G  0 rom

In [11]: disks = []
    ...: for line in ret.splitlines():
    ...:     if 'disk' in line:
    ...:         dev_name, *_, size = line.split()
    ...:         disks.append([dev_name, size])
    ...:

In [12]: disks
Out[12]: [['sda', 'disk'], ['sdb', 'disk']]

Python＃Typora-Python笔记

01：源码安装Python3

02：ipython的基本使用

03：猜数游戏开始学习基本语法

04：VSCode的部署和使用

05：字符串和数据的切片

06：列表、元组

07：获取服务器信息

猜你喜欢