Python灰帽编程——初识Python上篇

1. Python简介

常用安全工具语言	示例
perl	joomscan whatweb
ruby	metasploit-framework
python	sqlmap pocsuite3
go	goby

1.1 Pyhton 特点

特点	说明
高级	有高级的数据结构，缩短开发时间与代码量
面向对象	为数据和逻辑相分离的结构化和过程化编程添加了新的活力
可升级	提供了基本的开发模块，可以在它上面开发软件，实现代码的重用
可扩展	通过将其分离为多个文件或模块加以组织管理
可移植性	Python 是用C 写的，又由于C 的可移植性， 使得Python 可以运行在任何带有ANSI C 编译器的平台上
易学	Python 关键字少、结构简单、语法清晰
易读	没有其他语言通常用来访问变量、定义代码块和进行模式匹配的命令式符号
内存管理器	内存管理是由python 解释器负责的

1.2 环境准备

1.2.1 Python 版本

Python 官网

两个大版本：

• 3.x
• 2.x

1.2.2 CentOS7 下安装Python

下载安装包，此处以python3.7.3 为例进行源码包安装演示。

计算md5值

[root@localhost ~]# md5sum Desktop/Python-3.7.3.tgz 
2ee10f25e3d1b14215d56c3882486fcf  Desktop/Python-3.7.3.tgz
[root@localhost ~]#

安装开发环境

[root@localhost ~]# yum install gcc gcc-c++ zlib-devel bzip2-devel openssl-devel sqlite-devel readline-devel libffi-devel -y

...

Complete!
[root@localhost ~]#

1.2.2.1 编译安装

解压缩

[root@localhost ~]# tar xf Desktop/Python-3.7.3.tgz

修改配置

[root@localhost ~]# vim Python-3.7.3/Modules/Setup.dist    
[root@localhost ~]# cat Python-3.7.3/Modules/Setup.dist |grep "^readline"
readline readline.c -lreadline -ltermcap                # 开启代码补全
[root@localhost ~]# cat Python-3.7.3/Modules/Setup.dist |grep "^SSL=" -A3
SSL=/usr/local/ssl                  # 开启SSL 功能，使得Python 可以通过pip 使用https 协议
_ssl _ssl.c \
    -DUSE_SSL -I$(SSL)/include -I$(SSL)/include/openssl \
    -L$(SSL)/lib -lssl -lcrypto
[root@localhost ~]#

编辑安装

[root@localhost ~]# ./Python-3.7.3/configure && make && make install

...

[root@localhost ~]# which python3
/usr/local/bin/python3
[root@localhost ~]#

1.2.2.2 安装测试

Python3

[root@localhost ~]# python3
Python 3.7.3 (default, Feb 13 2021, 14:04:11) 
[GCC 4.8.5 20150623 (Red Hat 4.8.5-28)] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> print("Hello,World")
Hello,World
>>> exit()
[root@localhost ~]#

Python2

[root@localhost ~]# python
Python 2.7.5 (default, Apr 11 2018, 07:36:10) 
[GCC 4.8.5 20150623 (Red Hat 4.8.5-28)] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> print "Hello,World"
Hello,World
>>> exit()
[root@localhost ~]#

1.2.2.3 配置pip3

配置更新源

[root@localhost ~]# mkdir ~/.pip
[root@localhost ~]# vim ~/.pip/pip.conf
[root@localhost ~]# cat ~/.pip/pip.conf
[global]
index-url=https://pypi.douban.com/simple
[root@localhost ~]#

验证下载

[root@localhost ~]# pip3 install bs4
Looking in indexes: https://pypi.douban.com/simple
Collecting bs4
  Downloading https://pypi.doubanio.com/packages/10/ed/7e8b97591f6f456174139ec089c769f89a94a1a4025fe967691de971f314/bs4-0.0.1.tar.gz
Collecting beautifulsoup4 (from bs4)
  Downloading https://pypi.doubanio.com/packages/d1/41/e6495bd7d3781cee623ce23ea6ac73282a373088fcd0ddc809a047b18eae/beautifulsoup4-4.9.3-py3-none-any.whl (115kB)
    100% |████████████████████████████████| 122kB 8.5MB/s
Collecting soupsieve>1.2; python_version >= "3.0" (from beautifulsoup4->bs4)
  Downloading https://pypi.doubanio.com/packages/41/e7/3617a4b988ed7744743fb0dbba5aa0a6e3f95a9557b43f8c4740d296b48a/soupsieve-2.2-py3-none-any.whl
Installing collected packages: soupsieve, beautifulsoup4, bs4
  Running setup.py install for bs4 ... done
Successfully installed beautifulsoup4-4.9.3 bs4-0.0.1 soupsieve-2.2
You are using pip version 19.0.3, however version 21.0.1 is available.
You should consider upgrading via the 'pip install --upgrade pip' command.
[root@localhost ~]#

1.2.3 Windows 下安装Python

1.2.3.1 软件包安装

Win7 下安装3.6.0。疯狂下一步即可，记着配置环境变量。Win10 可以安装更高版本，区别不是很大。

1.2.3.2 环境变量

C:\Users\wuhu\AppData\Local\Programs\Python\Python36\Scripts\
C:\Users\wuhu\AppData\Local\Programs\Python\Python36\

1.2.3.3 配置pip 网络源

在当前用户家目录下新建文件夹pip，并在该文件夹中新建文件pip.ini，例如。

c:\Users\wuhu\pip\pip.ini

写入如下内容

[global]
timeout = 6000
index-url = https://pypi.tuna.tsinghua.edu.cn/simple
trusted-host = pypi.tuna.tsinghua.edu.cn

网络源测试

C:\Users\wuhu>pip install bs4
Collecting bs4
  Downloading https://pypi.tuna.tsinghua.edu.cn/packages/10/ed/7e8b97591f6f45617
4139ec089c769f89a94a1a4025fe967691de971f314/bs4-0.0.1.tar.gz
Collecting beautifulsoup4 (from bs4)
  Downloading https://pypi.tuna.tsinghua.edu.cn/packages/d1/41/e6495bd7d3781cee6
23ce23ea6ac73282a373088fcd0ddc809a047b18eae/beautifulsoup4-4.9.3-py3-none-any.wh
l (115kB)
    100% |████████████████████████████████| 122kB 6.6MB/s
Collecting soupsieve>1.2; python_version >= "3.0" (from beautifulsoup4->bs4)
  Downloading https://pypi.tuna.tsinghua.edu.cn/packages/41/e7/3617a4b988ed77447
43fb0dbba5aa0a6e3f95a9557b43f8c4740d296b48a/soupsieve-2.2-py3-none-any.whl
Installing collected packages: soupsieve, beautifulsoup4, bs4
  Running setup.py install for bs4 ... done
Successfully installed beautifulsoup4-4.9.3 bs4-0.0.1 soupsieve-2.2

C:\Users\wuhu>

1.3 开发工具

• vscode
• 自动安装插件

1.4 Python 的运行方法

1.4.1 命令行模式

直接在Python 解释器中运行Python 脚本。

1.4.2 文件模式

把Python 语句保存在文件（.py）中，然后运行py 文件。

指定命令解释器和文件编码：

#!/usr/bin/env python3
# coding:utf-8

自带编辑器IDLE。

• 字体调整
• F5 运行脚本

命令行下

PS C:\python_code\01day> python .\基本输出.py
芜湖

2. Python 初识

Python 语言官方参考

2.1 Python 语法结构

2.1.1 基本输出

# 01 - 基本输入输出.py

print("芜湖")

2.1.2 注释

和大部分脚本及Unix-shell 语言一样，Python 也使用【# 符号】标示注释，从# 开始，直到一行结束的内容都是注释，良好的注释习惯可以： 方便其他人了解程序功能 方便以后易读懂代码

除了# 号以外，引号在python 中也同样作为注释使用如三个连续单引号以及连续3 个双引号，通常引号内的字符串作为文档说明使用。

# 02 - 注释.py

'''
    这是注释
'''

"""
    我是
    注释
"""

'单引号可以理解为注释'

"双引号可以理解为注释"

print("芜湖")

2.1.3 缩进

这是Python 语法与其他编程语言最大的区别。

Python代码块通过缩进/对齐表达代码逻辑，而不是使用大括号。缩进表达一个语句属于哪个代码块。缩进风格，空格：

• 1或2 空格：太短，很难确定代码语句属于哪个块；
• 8至10 空格：太长，如果代码内嵌的层次太多，就会使得代码很难阅读；
• 4 个空格：刚刚好，范·罗萨姆支持的风格。

2.1.4 续行

一行过长的语句可以使用反斜杠\ 分解成几行。

# 03 - 续行.py

print("I like Python very very very very very very very very ve\
ry very very very very very very very very very very very very v\
ery very very very very very very very very very very very very much")

s = "I like Python very very very very very very very very ve"
s += "ry very very very very very very very very very very very very v"
s += "ery very very very very very very very very very very very very much"

print(s)

2.1.5 同行多句

Python 推荐每条语句单独占一行，不推荐同行多句。可以使用分号; 将多个语句写在同一行上。

# 04 - 同行多句.py
# 不推荐此种写法

a = 10;print(a)

2.2 Python 变量

根据用户的输入，获取用户名，然后输出欢迎信息。

2.2.1 变量定义

变量名称约定：

• 变量名由字母、数字、下划线组成，不是全都必须有。
• 不能以数字开头。
• 区分大小写。

序号	用户名	是否合法
1	username
2	userName
3	UserName
4	username_1
5	_username_	合法尽量避免
6	userN@me	不合法，包含特殊符号@
7	1userName	不合法，数字开头

变量的使用过程：

• 声明变量（变量名字、变量类型）
• 初始化（变量第一次赋值）
• 变量赋值和反复使用（赋值）

Python 是（动态类型语言）解释型脚本语言，不需要编译，即不需要预先声明变量的类型，拿过来就能用。

2.2.2 变量赋值

变量的类型和值在赋值那一刻被初始化，变量赋值通过赋值运算符 = 来执行。

一个变量如果要使用，就赋值；如果不用，别让它出现。

# 05 - 变量赋值.py

username = "wuhu"

# print("Welcome, " + username)

# print("Welcome, {}".format(username))

print(f"Welcome, {
      
      username}")

Python 语言中，等号 = 是主要的赋值运算符。赋值并不是直接将一个值赋给一个变量。在Python 中，对象是通过引用传递的。在赋值时，不管这个对象是新创建的，还是一个已经存在的，都是将该对象的引用（并不是值）赋值给变量。

赋值的多种玩法：

• 链式多重赋值

>>> x = y = 1
>>> y
1
>>> x
1
>>>

• 增量赋值：从Python 2.0 开始，等号可以和一个算术运算符组合在一起，将计算结果重新赋值给左边的变量,这被称为增量赋值。

>>> x = 3
>>> x = x + 3
>>> x
6
>>> x = x + 3
>>> x
9
>>> x ++
  File "<stdin>", line 1
    x ++
       ^
SyntaxError: invalid syntax
>>>

• 多元赋值：将多个变量同时赋值的方法称为多元赋值，采用这种方式赋值时，等号两边的对象都是元组。

>>> x,y,z = 1,2,3
>>> y
2
>>>

2.2.3 捕获屏幕输入

根据用户的输入打印信息。

# 06-打印输入信息.py

username = input("Please input your name: ")
print(f"Welcome, {
      
      username}")

命令行输入

# 打印输入信息.py

import sys
username = sys.argv[1]
print(f"Welcome, {
      
      username}")

说明： sys.argv 来获取命令行参数

2.3 运算符

2.3.1 算术运算符

参与运算的操作数是数字，结果也是数字。

算数运算符	解释
+	如果操作数是字符类型，则字符串拼接 * 如果操作数是数字类型，则算术运算。
-
*	如果操作数是数字类型，则算数运算。 如果两个操作数其中一个是字符串类型，另一个是数字类型，则将字符串重复输出。
/
%	取余
//	取商
**	幂运算

>>> 10 + 3
13
>>> 10 - 3
7
>>> 10 * 3
30
>>> "wuhu" * 5
'wuhuwuhuwuhuwuhuwuhu'
>>> 10 / 3
3.3333333333333335
>>> 10 % 3
1
>>> 10 // 3
3
>>> 10 ** 3
1000
>>>

2.3.2 比较运算符

运算结果是布尔类型的值。运算结果是布尔类型的值，True | False。

比较运算符	运算结果
<
<=
>
>=
==
!=

>>> 10 < 3
False
>>> 10 <= 3
False
>>> 10 > 3
True
>>> 10 >= 3
True
>>> 10 == 3
False
>>> 10 != 3
True
>>>

2.3.3 逻辑运算符

参与运算的操作数是布尔类型的值，运算结果是布尔类型的值。

逻辑运算符	解释	字符表达
and	逻辑与运算	&
or	逻辑或运算	|
not	逻辑非运算

>>> True and False
False
>>> True or False
True
>>> not True
False
>>>

2.4 标识符

2.4.1 关键字

和其他的高级语言一样，Python也拥有一些被称作关键字的保留字符。任何语言的关键字应该保持相对的稳定，但是因为Python是一门不断成长和进化的语言，其关键字偶尔会更新。

通过keyword模块查看关键字。

>>> import keyword
>>> keyword.iskeyword("if")
True
>>> keyword.iskeyword("ajest")
False
>>> keyword.kwlist
['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']
>>>

2.4.2 builtins

除了关键字之外，Python 还有可以在任何一级代码使用的“内建”的名字集合，这些名字可以由解释器设置或使用，内置函数就是在任何时候，任何地方都可以调用的函数。虽然built-in 不是关键字，但是应该把它当作“系统保留字”。

内置方法（函数），在任何地方都可以调用如下：

		内置函数
abs()	delattr()	hash()	memoryview()	set()
all()	dict()	help()	min()	setattr()
any()	dir()	hex()	next()	slice()
ascii()	divmod()	id()	object()	sorted()
bin()	enumerate()	input()	oct()	staticmethod()
bool()	eval()	int()	open()	str()
breakpoint()	exec()	isinstance()	ord()	sum()
bytearray()	filter()	issubclass()	pow()	super()
bytes()	float()	iter()	print()	tuple()
callable()	format()	len()	property()	type()
chr()	frozenset()	list()	range()	vars()
classmethod()	getattr()	locals()	repr()	zip()
compile()	globals()	map()	reversed()	_import_()
complex()	hasattr()	max()	round()

保留的常量：

• True
• False
• None

2.4.3 基本风格

编写程序时，应该建立一种统一且容易阅读的结构，并将它应用到每一个文件中去。在Python 语言中：{} 并不代表代码块，是通过缩进来表示代码块的。

#!/usr/bin/env python3
# -*- coding:gbk -*-                     #起始行
'this is a test module'             	 #模块文档字符串

import sys                      		 #导入模块
import os

debug = True                    		 #全局变量声明

class FooClass(object):            		 #类定义
    'Foo class'
    pass

def test():                          	 #函数定义
    "test function"
    foo = FooClass()
    
if __name__ == '__main__':            	 #程序主体
    test()

3. Python 变量类型

3.1 对象

3.1.1 Python 对象特征

所有的Python 对象都拥有三个特性：

特性	说明	例子
身份	每一个对象都有一个唯一的身份，标识自己， 任何对象的身份可以使用内建函数id() 来得到	id(username)
类型	决定了该对象可以保存什么类型的值， 可以进行什么样的操作，以及遵循什么样的规则。 用内建函数type() 查看对象的类型	type(username)
值	对象表示的数据项	print(username)

3.1.2 Python 对象属性

某些Python 对象有属性、值或相关联的可执行代码，用点. 标记法来访问属性。最常用的属性是函数和方法，不过有一些Python 类型也有数据属性。含有数据属性的对象包括（但不限于）：类、类实例、模块、复数和文件。

输入username.然后点击Tab键。

>>> username.
userName.capitalize(   userName.isdigit(      userName.rfind(
userName.casefold(     userName.isidentifier( userName.rindex(
userName.center(       userName.islower(      userName.rjust(
userName.count(        userName.isnumeric(    userName.rpartition(
userName.encode(       userName.isprintable(  userName.rsplit(
userName.endswith(     userName.isspace(      userName.rstrip(
userName.expandtabs(   userName.istitle(      userName.split(
userName.find(         userName.isupper(      userName.splitlines(
userName.format(       userName.join(         userName.startswith(
userName.format_map(   userName.ljust(        userName.strip(
userName.index(        userName.lower(        userName.swapcase(
userName.isalnum(      userName.lstrip(       userName.title(
userName.isalpha(      userName.maketrans(    userName.translate(
userName.isascii(      userName.partition(    userName.upper(
userName.isdecimal(    userName.replace(      userName.zfill(
>>> username.lower()
'ajest'
>>> userName
'AJEST'
>>>

说明：少了右括号的需要参数。而括号完整的是不需要参数的。

3.1.3 对象身份比较

对象可以通过引用被赋值到另一个变量，因为每个变量都指向同一个（共享的）数据对象，只要任何一个引用发生改变，该对象的其它引用也会随之改变。

>>> x = 1
>>> y = x
>>> id(x)
4318726800
>>> id(y)
4318726800
>>>

3.2 数字

3.2.1 基本数字类型

关键字	解释	例子
int	有符号整数	自然数
bool boolean	布尔值	True：1 False：0
float	浮点数	π

3.2.2 进制间的数字表示方式

Python 默认以十进制数显示，可以用其他方法表示数字：

进制	表达	实例
10 进制	默认表达方式	11
2 进制	数字以0b 或0B 开头	0b11
8 进制	数字以0o 开头	0o11
16 进制	数字以0x 或0X 开头	0x11

>>> 11
11
>>> 0b11
3
>>> 0o11
9
>>> 0x11
17
>>>

3.2.3 位运算符

位运算符	功能
num1 << num2	num1 左移num2 位
num1 >> num2	num1 右移num2 位
num1 & num2	num1 与num2 按位与
num1 ^ num2	num1 异或 num2
num1 | num2	num1 与num2 按位或
~num	单目运算，对数的每一位取反

>>> 2 >> 2
0
>>> 2 << 2
8
>>>

3.2.4 数字类型函数

函数	说明
int()	将字符串转化为数字
str()	将数字住转化为字符串
long()
float()
complex()
abs()	返回给定参数的绝对值
divmod()	内建函数把除法和取余运算结合起来，返回一个包含商和余数的元组
pow()	进行指数运算
round()	用于对浮点数进行四舍五入运算

3.2.5 仅用于整数的函数

函数	说明
hex()	10 进制数转换为字符串形式的16 进制数
oct()	10 进制数转换为字符串形式的8 进制数
bin()	10 进制数转换为字符串形式的2 进制数

>>> hex(11)
'0xb'
>>> oct(11)
'0o13'
>>> bin(11)
'0b1011'
>>>

3.3 字符串

3.3.1 字符串的定义

Python 中字符串被定义为引号之间的字符集合。Python 支持使用成对的单引号或双引号，无论单引号，还是双引号，表示的意义相同。Python 还支持三引号（三个连续的单引号或者双引号），可以用来包含特殊字符；Python 不区分字符和字符串。

# 07 - 字符串的定义.py

username = 'wuhu'
username = "wuhu"
username = '''wuhu'''
username = """wuhu"""

print(type(username))

3.3.2 字符串连接

字符串连接的时候可以使用 + 或者 * 。

使用 + 号可以将多个字符串拼接在一起。或者使用 * 号可以将一个字符串重复多次输出。

# 08 - 字符串拼接.py

username = "wuhu"

print("Welcome, " + username + !)
print("Welcome, " + username * 5)

问题：

>>> 2 + 'dog'
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unsupported operand type(s) for +: 'int' and 'str'
>>> str(2) + 'dog'
'2dog'
>>>

3.3.3 单个字符操作

单个字符操作	例子
将字符转化成ASCII 码	ord(‘a’)
将ASCII 码转化位字符	chr(97)

3.3.4 字符串操作

字符串操作	实例
比较运算符： 字符串按照字符的ASCII 码值进行比较。	‘b’ < ‘bool’ ‘b’ > ‘abcd’
角标访问： 利用偏离量获取字符串中的字符。（从0开始）	‘AJEST’[1]
切片：取子串 str[n:m]，n，m 均代表偏移量，m > n，[n,m-1] str[::n]，每n 个字母一组，取第一个字母 str[::-1]，字符串反向。 左闭右开	‘AJEST’[1:3] ‘AJEST’[::3] ‘AJEST’[::-1]
成员关系： 字符串A是否是字符串B的子串	‘AJ’ in ‘AJEST’ ‘a’ not in ‘AJEST’

切片说明：str[::n] 的含义是从字符串 str 的开头到结尾，以步长 n 获取字符。步长指定了切片的间隔，即提取字符的间隔。如果步长为正数，则从左到右提取字符；如果步长为负数，则从右到左提取字符。

string.printable：string模块，printable显示键盘中可打印的所有字符。

import string
string.printable

3.3.5 格式化操作符

格式化字符	转换方式
%s	字符串
%d	10 进制数
%e	科学计数法 “%e” %10000000000
%f	浮点数
辅助指令	作用
数值	定义宽度或小数点精度，例如：%5s，%.3f
-	左对齐
+	正负数前面显示符号 “%+d” %-10

# 字符串格式化输出.py

students = [
    {
    
    "name":"AJEST", "age":24}, 
    {
    
    "name":"Lilei", "age":25}, 
    {
    
    "name":"Hanmeimei", "age":23}
    ]
print("name: %10s, age: %10d" % (students[0]["name"], students[0]["age"]))
print("name: %10s, age: %10d" % (students[1]["name"], students[1]["age"]))
print("name: %-10s, age: %-10d" % (students[2]["name"], students[2]["age"]))

3.3.6 format 格式化

Python2.6 开始，新增了一种格式化字符串的函数str.format()，它增强了字符串格式化的功能。基本语法是通过{} 和 : 来代替以前的%。format 函数可以接受不限个参数，位置可以不按顺序。

>>>"{} {}".format("hello", "world")    # 不设置指定位置，按默认顺序
'hello world'

>>> "{0} {1}".format("hello", "world")  # 设置指定位置
'hello world'

>>> "{1} {0} {1}".format("hello", "world")  # 设置指定位置
'world hello world'

3.3.7 字符串常用内建函数

常用内建函数	说明	示例
s.strip()	删除字符串实例字符串两端的空白	’ WUHU’.strip()
s.replace(sub,rep)	搜索s 字符串中的sub， 并替换为rep	‘wuhu’.replace(‘e’,‘E’)
s.split©	分割字符串，并返回一个列表， 可以指定分隔符c，默认为空白。	‘127.0.0.1’.split(‘.’)
s.center(width)	返回一个原字符串居中， 并使用空格填充至长度width 的新字符串	“WUHU”.center(11)
s.upper()	转换字符串实例中的小写字母为大写	‘wuhu’.upper()
s.lower()	转换字符串实例中的大写字母为小写	‘WUHU’.lower()
s.rfind()	返回指定字符（或字符串）最后一次出现的索引位置。	参考练习

3.3.8 字符串练习

给定IP 地址【10.4.7.133/24】，获取其主机位

ip = '10.4.7.133'
	
print("主机位是：" + ip.split('.')[3])			# 以点作为分割，选其中的第3个参数
print("主机位是：" + ip[7::])					# 提取从索引位置7开始到字符串末尾的子字符串
print("主机位是：" + ip[-3::])					# 提取从倒数第三个字符到字符串末尾的子字符串
print("主机位是：" + ip[ip.rfind('.') + 1 ::])	# 提取从最后一个点(".")的索引位置加一开始到字符串末尾的子字符串。  

3.4 列表

可以将列表当成普通的数组，它能保存任意数量任意类型的Python 对象。像字符串一样，列表也支持下标和切片操作；列表中的项目可以改变。

3.4.1 列表的定义

# 09 - 列表的定义.py

stu1 = ["wuhu", True, 24, 59.9]

3.4.2 列表元素访问

通过下标（偏移量）访问数组元素。

# 10 - 列表元素的访问.py

stu1 = ["wuhu", True, 24, 59.9]

print(f"{
      
      stu1[0]} 的成绩是{
      
      stu1[3]}")

stu1[3] += 0.1

print(f"经过不断刻苦努力，{
      
      stu1[0]} 的成绩提高了0.1 分，为{
      
      stu1[3]}")

3.4.3 列表也是序列

由于列表也是序列类型，所以+ |* | in | not in，都适用于列表，但是需要注意参与运算的对象属于同一类型。

>>> nsClass = ["AJEST", "LL", "HMM", "LH"]
>>> pyClass = ['MDM']
>>> nsClass += pyClass
>>> nsClass
['AJEST', 'LL', 'HMM', 'LH', 'MDM']
>>> "LH" in nsClass
True
>>>

3.4.4 作用于列表的函数

直接向函数中传参，参数为列表。

函数	说明	示例
list()	将序列转化成列表	list(‘wuhu’)
len()	长度	len(stu)
max()	最大值	max(stu)
min()	最小值	min(stu)
sorted()	排序	sorted(stu)
enumerate()	取脚标和元素	list(enumerate(stu))

详细说明：

• sorted(stu)：这个表达式将返回一个对学生姓名进行排序后的新列表。它将按字母顺序对学生姓名进行排序，并返回排序后的结果，而不会修改原始列表。

• enumerate()：这是一个内置函数，用于将一个可迭代对象（如列表）转换为一个枚举对象。它会返回一个包含索引和元素的元组的迭代器。默认情况下，它从索引 0 开始计数，但也可以通过传递 start 参数来指定起始索引。

3.4.5 列表内建函数

函数	说明	示例
l.append(new)	向列表中添加一个对象new
l.pop(obj)	删除列表中的元素
l.count(obj)	返回一个对象obj 在列表中出现的次数
l.index(obj)	obj 首次出现的位置
l.insert(index,obj)	在偏移量为index 的位置插入对象obj
l.reverse()	翻转列表
l.sort()	排序
l.extend(seq)	把序列seq 的内容添加到列表中

>>> name = 'ajest'
>>> l = list(name)
>>> l
['a', 'j', 'e', 's', 't']
>>>
>>> l.append('a')
>>> l
['a', 'j', 'e', 's', 't', 'a']
>>>
>>> l.count('a')
2
>>>
>>> l.index('e')
2
>>>
>>> l.insert(0,'a')
>>> l
['a', 'a', 'j', 'e', 's', 't', 'a']
>>>
>>> l.reverse()
>>> l
['a', 't', 's', 'e', 'j', 'a', 'a']
>>>
>>> l.sort()
>>> l
['a', 'a', 'a', 'e', 'j', 's', 't']
>>>
>>> l.extend(name)
>>> l
['a', 'a', 'a', 'e', 'j', 's', 't', 'a', 'j', 'e', 's', 't']
>>>

3.4.6 列表操作

可以通过角标访问的数据类型，叫做序列。序列支持的操作：

• 角标访问
• 加法或乘法
• 切片
• 成员关系判断（不推荐）

3.4.7 多维列表

列表元素也可以是列表

stu1 = ["wuhu",True,24,99.9]
stu2 = ["dididi",True,24,99.9]

nc_class = [stu1,stu2]
# 多维列表元素输出
print(nc_class)

# 多维列表元素访问
print(f"{
      
      nc_class[0][0]}和{
      
      nc_class[1][0]}")

3.5 元组

3.5.1 元组定义

可以认为元组是静态的列表，元组一旦定义，不能改变。

>>> stu1 = ("wuhu", True, 24, 59.9)
>>> type(stu1)
<class 'tuple'>
>>> stu1[3]
59.9
>>> stu1[3] += 0.1
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment
>>>

3.5.2 成员关系判断

由于元组也是序列类型，所以作用在序列上的操作都可以作用于元组，通过in、not in判断成员关系。

>>> 24 in stu1
True
>>>

3.5.3 单元素元组

如果一个元组中只有一个元素，那么创建该元组的时候，需要加上一个逗号。

>>> t = ("wuhu")
>>> type(t)
<class 'str'>
>>> t = ("wuhu",)
>>> type(t)
<class 'tuple'>
>>>

3.5.4 序列

字符串、列表、元组都是序列。

3.5.5 序列类型操作符

序列操作符	作用
序列偏移量，脚标[n]	获取脚标中的元素
序列切片，脚标[x:y]	取脚标之间的值，y 的值不取
序列 * n	重复输出n 次数
序列1 + 序列2	序列累加拼接
元素 in 序列	判断元素是否在字符串中

3.5.6 内建函数

函数	含义
list(可迭代对象)	转换为列表，可以将字符串转化为列表。
str(对象)	将对象转换为字符串
tuple(可迭代对象)	把可迭代对象转为元组
len(可迭代对象)	返回对象长度
enumerate(可迭代对象)	返回两个值一个脚标一个对应值
sorted(可迭代对象)	对迭代对象排序，返回一个有序列表
reversed(可迭代对象)	逆序迭代器

3.6 字典

3.6.1 字典定义

字典是由键-值(key-value) 对构成的映射数据类型，通过键取值，不支持下标操作。

>>> stu1 =  {
    
    "name": 'wuhu', "sex": True, "age": 24, "score": 59.9}
>>> type(stu1)
<class 'dict'>
>>>

3.6.2 创建字典

出了可以通过{ } 操作符创建字典，还可以通过 dict() 工厂方法创建字典或者通过fromkeys() 创建具有相同值的默认字典

>>> stu2 = dict((['name','LL'],['sex',True],['age',25],['score',69.9]))
>>> stu2
{
    
    'name': 'LL', 'sex': True, 'age': 25, 'score': 69.9}
>>> stu3 = {
    
    }.fromkeys(('name','sex','age','score'),24)
>>> stu3
{
    
    'name': 24, 'sex': 24, 'age': 24, 'score': 24}
>>>

3.6.3 访问字典

字典是映射类型，意味着它没有下标，有键值对，访问字典中的值需要使用相应的键。

>>> print(f"{
      
      stu1['name']} 的成绩是{
      
      stu1['score']}")
wuhu 的成绩是59.9
>>>

3.6.4 更新字典元素

通过键名更新字典键值：如果字典中有该键名，则更新对应的键值。如果字典中没有该键名，则向字典中添加键值对。

>>> stu1['score'] += 0.1
>>> print(f"{
      
      stu1['name']} 的成绩是{
      
      stu1['score']}")
wuhu 的成绩是60.0
>>> stu1['e-mail'] = "[email protected]"
>>> stu1
{
    
    'name': 'wuhu', 'sex': True, 'age': 24, 'score': 60.0, 'e-mail': '[email protected]'}
>>>

3.6.5 删除字典元素

使用pop() 方法可以“弹出”字典中的元素。

>>> stu1.pop("e-mail")
'[email protected]'
>>> stu1
{
    
    'name': 'wuhu', 'sex': True, 'age': 24, 'score': 60.0}
>>>

3.6.6 字典的内建方法

方法	说明
d.copy()	返回字典的一个副本
d.get(key)	对字典dict 中的键key，返回它对应的值value， 如果字典中不存在此键，则返回default 的值
d.keys()	返回一个包含字典中键的列表
d.values()	返回一个包含字典中所有值的列表
d.update(dict2)	将字典dict2 的键-值对添加到字典dict
d.items()	返回一个包含字典中(键，值)对元组的列表

>>> stu1.keys()
dict_keys(['name', 'sex', 'age', 'score'])
>>> stu1.values()
dict_values(['wuhu', True, 24, 65.0])
>>>

4. 流程控制

4.1 条件分支

通过if 语句进行学生成绩判断。

4.1.1 单向条件分支

如果学生成绩大于等于60 分，则输出“恭喜”。

# 11 - 单向条件分支.py

stu1 = {
    
    
    "name"  :   "wuhu",
    "sex"   :   True,
    "age"   :   24,
    "score" :   69.9
}

if stu1['score'] >= 60 :
    print("Congratulations!")

4.1.2 双向条件分支

如果学生成绩大于等于60 分，则输出“恭喜”，否则输出“对不起！”。

# 12 - 双向条件分支.py

stu1 = {
    
    
    "name"  :   "wuhu",
    "sex"   :   True,
    "age"   :   24,
    "score" :   59.9
}

if stu1['score'] >= 60 :
    print("Congratulations!")
else :
    print("Sorry! You may need help!")

4.1.3 多向条件分支

可以根据学生成绩进行定级：

• 如果学生成绩大于等于90 分，则定为A。
• 如果学生成绩大于等于80 分，则定为B。
• 如果学生成绩大于等于70 分，则定为C。
• 如果学生成绩大于等于60 分，则定为D。
• 如果学生成绩小于60 分，则定为不及格。

# 13 - 多向条件分支.py

stu1 = {
    
    
    "name"  :   "wuhu",
    "sex"   :   True,
    "age"   :   24,
    "score" :   89.9
}

if stu1['score'] >= 90 :
    print("A")
elif stu1['score'] >= 80 :
    print("B")
elif stu1['score'] >= 70 :
    print("C")
elif stu1['score'] >= 60 :
    print("D")
else :
    print("Sorry!")

4.1.4 if 判断条件探究

紧接着if 关键字后的条件判断语句为True，则进入if 分支；否则进入else 分支。这里面判断语句的值大多数情况下，是非布尔类型变量。这种情况下，就会产生一个问题，什么样的表达式的值会被当做True 来看待，什么样的值会当做False 来看待。

基本原则：

• 大部分非布尔类型的变量都会被认为是True 值。
• 少部分非布尔类型的变量会被认为是False 值。

# 14 - if 判断条件探究.py

flag = True
flag = False

flag = 0
flag = 0.0

flag = ""
flag = []
flag = ()
flag = {
    
    }

flag = None

if flag :
    print(f"{
      
      flag} means True")

else :
    print(f"{
      
      flag} means False")

4.2 循环结构

输出1 到100 所有的整数。

4.2.1 while 循环

当需要语句不断的重复执行时，可以使用while 循环。while 循环中语句块会连续不断的执行，直到表达式的值为False。

当满足的条件的时候，则执行循环体。

# 15 - while 循环.py

i = 0

while i < 100 :
    i += 1
    print(i)

主要注意的问题：

• 死循环问题
• 计数器

4.2.2 for 循环

遍历，所有元素依次访问一遍。Python 中的for 接受可迭代对象（例如序列或迭代器）作为其参数，每次迭代其中一个元素。与while 循环一样，支持break、continue 语句。一般情况下，循环次数未知采用while 循环，循环次数已知（字符串，元组，列表，字典…），采用for 循环。

# 16 - for 循环.py

for i in range(1, 101):
    print(i)

4.3 特殊流程控制语句

4.3.1 break 语句

break 结束当前循环，跳出循环体。

快速猜数字：程序随机生成一个数字，用户输入数字，程序判断大小。

# 17 - 快速猜数字游戏.py

import random

numRand = random.choice(range(1, 101))

while True:
    numIn = input("Please input a number: ")
    numIn = int(numIn)

    if numIn > numRand :
        print("猜大了")
    elif numIn < numRand :
        print("猜小了")
    else : 
        print("猜对了")
        break

4.3.2 continue 语句

当触发continue 语句时，程序会忽略下方语句，回到循环的顶端继续循环，意味着本次循环“轮空”。

# 18 - continue 语句.py

for i in range(1, 101):
    if i % 2 == 1 :
        continue
    print(i)

非布尔类型的变量会被认为是False 值。

# 14 - if 判断条件探究.py

flag = True
flag = False

flag = 0
flag = 0.0

flag = ""
flag = []
flag = ()
flag = {
    
    }

flag = None

if flag :
    print(f"{
      
      flag} means True")

else :
    print(f"{
      
      flag} means False")

4.2 循环结构

输出1 到100 所有的整数。

4.2.1 while 循环

当需要语句不断的重复执行时，可以使用while 循环。while 循环中语句块会连续不断的执行，直到表达式的值为False。

当满足的条件的时候，则执行循环体。

# 15 - while 循环.py

i = 0

while i < 100 :
    i += 1
    print(i)

主要注意的问题：

• 死循环问题
• 计数器

4.2.2 for 循环

遍历，所有元素依次访问一遍。Python 中的for 接受可迭代对象（例如序列或迭代器）作为其参数，每次迭代其中一个元素。与while 循环一样，支持break、continue 语句。一般情况下，循环次数未知采用while 循环，循环次数已知（字符串，元组，列表，字典…），采用for 循环。

# 16 - for 循环.py

for i in range(1, 101):
    print(i)

4.3 特殊流程控制语句

4.3.1 break 语句

break 结束当前循环，跳出循环体。

快速猜数字：程序随机生成一个数字，用户输入数字，程序判断大小。

# 17 - 快速猜数字游戏.py

import random

numRand = random.choice(range(1, 101))

while True:
    numIn = input("Please input a number: ")
    numIn = int(numIn)

    if numIn > numRand :
        print("猜大了")
    elif numIn < numRand :
        print("猜小了")
    else : 
        print("猜对了")
        break

[外链图片转存中…(img-6FzYgJzl-1694483813240)]

4.3.2 continue 语句

当触发continue 语句时，程序会忽略下方语句，回到循环的顶端继续循环，意味着本次循环“轮空”。

# 18 - continue 语句.py

for i in range(1, 101):
    if i % 2 == 1 :
        continue
    print(i)