python基础

1 为什么要学习python

1.1 渗透方向

1. 网络扫描与探测

2. 漏洞利用与EXP

3. Web应用渗透测试

4. 密码学分析与破解

5. 二进制分析与逆向工程

6. 社会工程学攻击

7. 无线网络安全

8. 报告与自动化

1.2 应急响应方向

1. 日志分析与收集

2. 内存与磁盘取证

3. 网络流量分析

4. 恶意软件分析

5. 自动化响应与恢复

6. 报告与通信

1.3 python的特点

1. 简洁易读

2. 丰富的标准库和第三方库

3. 跨平台性

4. 面向对象

5. 可扩展性

6. 强大的社区支持

7. 广泛的应用领域

2 python初次尝试

2.1 python安装

1.linux

sudo apt-get update
sudo apt-get install python3

2.mac

brew install python3

3 windwos

2.2 编辑器

vim:人类史上最好用的文本编辑器，从此以后你就是个充满极客风的hacker

better

Stronger

Faster

2.3 新建.vimrc

set nocompatible 
set number 
set nowrap    
set showmatch  
set scrolloff=3      
set encoding=utf-8  
set fenc=utf-8      
set mouse=a        
set hlsearch        
syntax on    
​
au BufNewFile,BufRead *.py
 set tabstop=4   
 set softtabstop=4  
 set shiftwidth=4   
 set textwidth=79  
 set expandtab       
 set autoindent      
 set fileformat=unix  

3 hello word

3.1hello world

新建vi hello.py

print('hello world')

输入 python hello.py

3.2 求圆的面积

新建round.py

#! /usr/bin/env python3
​
from math import pi
resuit = 5 * 5 * pi
print(resuit)

3.3 执行脚本

执行脚本方式
方式1
python  xxx.py
方式2
chmod +x xxx.py
./xxx.py

4 数据类型与变量

4.1 None和Bool:

None:表示空对象

Bool: Python中使用True和False来表示布尔值注意首字母大写，即判断 Python 对象、返回值、表达式真假的一组特殊数据类型

4.2 保留字:

保留字，又称为关键字，每种语言都有自己的一套预先保留的特殊标识符，Python 也不例外，它自带的keyword模块可以查看全部关键字。

4.3 内置函数

		内置函数
abs()	divmod()	input()	open()	staticmethod()
all()	enumerate()	int()	ord()	str()
any()	eval()	isinstance()	pow()	sum()
basestring()	execfile()	issubclass()	print()	super()
bin()	file()	iter()	property()	tuple()
bool()	filter()	len()	range()	type()
bytearray()	float()	list()	raw_input()	unichr()
callable()	format()	locals()	reduce()	unicode()
chr()	frozenset()	long()	reload()	vars()
classmethod()	getattr()	map()	repr()	xrange()
cmp()	globals()	max()	reverse()	zip()
compile()	hasattr()	memoryview()	round()	import()
complex()	hash()	min()	set()
delattr()	help()	next()	setattr()
dict()	hex()	object()	slice()
dir()	id()	oct()	sorted()	exec 内置表达式

4.4 变量

4.4.1 变量介绍

编程语言中为了能够更好的处理数据，都需要使用一些变量。变量基本上就是代表(或是引用某值的名字)。Python语言的变量可以是各种不同的数据类型，使用变量的时候不需要声明，Python解释器会自动判断数据类型。使用type(变量)可以查看该变量的类型。

4.4.2 变量命名规则

1. 标识符命名规则：

   • 变量名只能包含字母（a-z，A-Z）、数字（0-9）和下划线（_）。

   • 变量名不能以数字开头。例如，123var 是无效的，但 var123 是有效的。

   • 变量名是区分大小写的。例如，myVar 和 myvar 是两个不同的变量。

2. 推荐的命名风格：

   • 小写字母和下划线：这是Python中推荐的命名风格，也称为“snake_case”。例如，my_variable。

   • 对于类名，通常使用驼峰命名法，即首字母大写的单词组合，不使用下划线。例如，MyClass。

3. 避免使用Python保留字：

   • 不要使用Python的保留字（如 if, for, while, class, def 等）作为变量名。这会导致语法错误。

4. 清晰和描述性：

   • 变量名应该尽可能地清晰和描述性，以便其他阅读代码的人能够轻易理解其用途。例如，num_students 比 ns 更清晰。

5. 避免使用通用名称：

   • 避免使用像 l, O, I 这样的字母或像 list, dict, str 这样的通用类型名作为变量名，因为它们可能与Python的内置函数或类型混淆。

6. 使用有意义的缩写：

   • 如果变量名太长，可以使用有意义的缩写。但是，应确保这些缩写在上下文中是清晰的，并且对于不熟悉该代码的读者来说也是易于理解的。

7. 常量命名：

   • 如果一个变量的值在程序运行期间不会改变，通常我们会将其视为常量。在Python中，并没有内置的常量类型，但通常我们会使用全大写字母和下划线来命名常量，例如 MAX_VALUE。

5 空行，缩进与多行代码

5.1 空行

一般空行用于不同函数之间、不同类之间、以及类和函数之间进行分隔。空行不是 Python的语法，即使不插入空行程序运行也不会出错。插入空行的主要目的是方便代码阅读以及日后的维护。

5.2 缩进

Python对于缩进的要求是非常严格的，它依靠缩进距离区分代码块，所以在Python中缩进也是一种语法，缩进的距离是可变的，具有相同缩进距离的属于同一个代码块。

5.3 多行代码

Python代码中一般一行只写一条语句。如果想要在一行中写多条语句，那么语句之间就需要使用；进行分隔。

6 字符串

6.1 字符串

Python 3中的字符串可以使用双引号或单引号标示，如果字符串中出现引号，则可以使用\来去除引号标示字符串的特殊作用。

新建string.py

#!/usr/bin/env python3
​
str1 = "hello"
str2 = 'world'
str3 = 'hello,\'world\''
str4 = "hello,'world'"
str5 = 'hello,"world"'
​
print(str1)
print(str2)
print(str3)
print(str4)
print(str5)

新建string2.py

#!/usr/bin/env python3
​
str1 = "hello"
str2 = 'world'
str3 = 'hello,\'world\''
str4 = "hello,'world'"
str5 = 'hello,"world"'
str6 = """ hello,
world """
​
​
​
print(str1+' '+str2)
print(str6)
#print(str3)
#print(str4)
#print(str5)

6.2 字符串的常用属性和方法

1.count
2.split和strip
3.upper和lower
4._len_

7 运算符

7.1 算数运算符

运算符	描述	实例
+	加 - 两个对象相加	a + b 输出结果 30
-	减 - 得到负数或是一个数减去另一个数	a - b 输出结果 -10
*	乘 - 两个数相乘或是返回一个被重复若干次的字符串	a * b 输出结果 200
/	除 - x除以y	b / a 输出结果 2
%	取模 - 返回除法的余数	b % a 输出结果 0
**	幂 - 返回x的y次幂	a**b 为10的20次方， 输出结果 100000000000000000000
//	取整除 - 返回商的整数部分（向下取整）	>>> 9//2 4 >>> -9//2 -5

7.2 比较运算符

运算符	描述	实例
==	等于 - 比较对象是否相等	(a == b) 返回 False。
!=	不等于 - 比较两个对象是否不相等	(a != b) 返回 True。
<>	不等于 - 比较两个对象是否不相等。python3 已废弃。	(a <> b) 返回 True。这个运算符类似 != 。
>	大于 - 返回x是否大于y	(a > b) 返回 False。
<	小于 - 返回x是否小于y。所有比较运算符返回1表示真，返回0表示假。这分别与特殊的变量 True 和 False 等价。	(a < b) 返回 True。
>=	大于等于 - 返回x是否大于等于y。	(a >= b) 返回 False。
<=	小于等于 - 返回x是否小于等于y。	(a <= b) 返回 True。

7.3 赋值运算符

运算符	描述	实例
=	简单的赋值运算符	c = a + b 将 a + b 的运算结果赋值为 c
+=	加法赋值运算符	c += a 等效于 c = c + a
-=	减法赋值运算符	c -= a 等效于 c = c - a
*=	乘法赋值运算符	c *= a 等效于 c = c * a
/=	除法赋值运算符	c /= a 等效于 c = c / a
%=	取模赋值运算符	c %= a 等效于 c = c % a
**=	幂赋值运算符	c = a 等效于 c = c a
//=	取整除赋值运算符	c //= a 等效于 c = c // a

7.4 逻辑运算符

运算符	逻辑表达式	描述	实例
and	x and y	布尔"与" - 如果 x 为 False，x and y 返回 False，否则它返回 y 的计算值。	(a and b) 返回 20。
or	x or y	布尔"或" - 如果 x 是非 0，它返回 x 的计算值，否则它返回 y 的计算值。	(a or b) 返回 10。
not	not x	布尔"非" - 如果 x 为 True，返回 False 。如果 x 为 False，它返回 True。	not(a and b) 返回 False

7.5 成员运算符

运算符	描述	实例
in	如果在指定的序列中找到值返回 True，否则返回 False。	x 在 y 序列中 , 如果 x 在 y 序列中返回 True。
not in	如果在指定的序列中没有找到值返回 True，否则返回 False。	x 不在 y 序列中 , 如果 x 不在 y 序列中返回 True。

7.6 身份运算符

运算符	描述	实例
is	is 是判断两个标识符是不是引用自一个对象	x is y, 类似 id(x) == id(y) , 如果引用的是同一个对象则返回 True，否则返回 False
is not	is not 是判断两个标识符是不是引用自不同对象	x is not y ， 类似 id(a) != id(b)。如果引用的不是同一个对象则返回结果 True，否则返回 False。

7.7 运算符优先级

运算符	描述
**	指数 (最高优先级)
~ + -	按位翻转, 一元加号和减号 (最后两个的方法名为 +@ 和 -@)
* / % //	乘，除，取模和取整除
+ -	加法减法
>> <<	右移，左移运算符
&	位 'AND'
^ |	位运算符
<= < > >=	比较运算符
<> == !=	等于运算符
= %= /= //= -= += *= **=	赋值运算符
is is not	身份运算符
in not in	成员运算符
not and or	逻辑运算符

8 判断与循环

8.1 判断

8.1.1 单个if判断

if 语句用于控制程序的执行，基本形式为：

if 判断条件：
    执行语句……
else：
    执行语句……

#!/usr/bin/env python3
​
a = 15
​
if a > 20:
    print('a > 20')
elif a == 20:
    print('a == 20')
else:
    print('a < 20')

8.1.2 多个if判断

if 语句的判断条件可以用>（大于）、<(小于)、==（等于）、>=（大于等于）、<=（小于等于）来表示其关系。

当判断条件为多个值时，可以使用以下形式：

if 判断条件1:
    执行语句1……
elif 判断条件2:
    执行语句2……
elif 判断条件3:
    执行语句3……
else:
    执行语句4……

#!/usr/bin/env python3
​
a = 25
​
if a > 20:
    print('a > 20')
    if a == 25:
        print('a == 25')
elif a == 20:
    print('a == 20')
else:
    print('a < 20')

效果图

8.2 循环

8.2.1 while循环

while 语句用于循环执行程序，即在某条件下，循环执行某段程序，以处理需要重复处理的相同任务。其基本形式为：

while 判断条件(condition)：
    执行语句(statements)……

执行语句可以是单个语句或语句块。判断条件可以是任何表达式，任何非零、或非空（null）的值均为true。

当判断条件假 false 时，循环结束。

#!/usr/bin/env python3

a = 100

while a > 10:
    print(a)
    a -= 5

8.2.2 for循环

for循环可以遍历任何序列的项目，如一个列表或者一个字符串。

语法：

for循环的语法格式如下：

for iterating_var in sequence:
   statements(s)

#!/usr/bin/env python3

strlist = ['hello','world','wuyue']

for s in strlist:
    print(s)

8.2.3 嵌套循环

允许在一个循环体里面嵌入另一个循环。

#!/usr/bin/env python3  
  
i = 2  
while(i < 100):  
   j = 2  
   while(j * j <= i):  
      if (i % j) == 0:  
         break  
      j = j + 1  
   if (j * j > i):  
      print(i, "是素数")  
   i = i + 1  
  
print("Good bye!")

8.2.4 break控制

break语句，就像在C语言中，打破了最小封闭for或while循环。

break语句用来终止循环语句，即循环条件没有False条件或者序列还没被完全递归完，也会停止执行循环语句。

break语句用在while和for循环中。

如果您使用嵌套循环，break语句将停止执行最深层的循环，并开始执行下一行代码。

#!/usr/bin/env python3  
# -*- coding: UTF-8 -*-  
  
for letter in 'Python':     # 第一个实例  
    if letter == 'h':  
        break  
    print('当前字母 :', letter)  
  
var = 10                    # 第二个实例  
while var > 0:                
    print('当前变量值 :', var)  
    var = var - 1  
    if var == 5:   # 当变量 var 等于 5 时退出循环  
        break  
  
print("Good bye!")

8.2.5 continue 语句

continue 语句跳出本次循环，而break跳出整个循环。

continue 语句用来告诉Python跳过当前循环的剩余语句，然后继续进行下一轮循环。

continue语句用在while和for循环中。

#!/usr/bin/env python3  
# -*- coding: UTF-8 -*-  
  
for letter in 'Python':     # 第一个实例  
    if letter == 'h':  
        continue  
    print('当前字母 :', letter)  
  
var = 10                    # 第二个实例  
while var > 0:                
    var = var - 1  
    if var == 5:  
        continue  
    print('当前变量值 :', var)  
  
print("Good bye!")

9 命令行参数

#!/usr/bin/env python3
​
import sys
​
print(len(sys.argv))
​
for arg in sys.argv:
    print(arg)
​

10 模块

1 _name_与_main_

2 引入模块的方式
import xxxx
from xxx import xxx
from xxx import xxx as xxx

3.模块的搜索路径

11 包

pip常用命令:
显示版本和路径: pip3 --version
升级pip: sudo pip3 install --upgrade pip
安装包: (sudo) pip3 install package，如果需要指定版本就是:pip3 installpackage==1.0.3(写具体的版本号)
卸载包: pip3 uninstall package
升级包: pip3 install --upgrade package，可以使用==,>=,<=,<,>来指定版本号
查看安装已安装的包: pip3 list
把需要安装的一系列包写入requirements.txt 文件中，然后执行: pip3 install -r requirements.txt

12 列表

Python 列表（List）是一种有序的数据结构，用于存储一系列的元素。这些元素可以是任何数据类型，包括数字、字符串、列表等，且列表中的元素不需要具有相同的类型。以下是一些关于 Python 列表的笔记：

12.1. 创建列表

可以使用方括号 [] 或 list() 函数来创建列表。

# 使用方括号创建列表  
my_list = [1, 2, 3, 4, 5]  
  
# 使用 list() 函数创建列表  
another_list = list((1, 2, 3, 4, 5))

12.2. 访问列表元素

通过索引访问列表中的元素，索引从 0 开始。

my_list = [1, 2, 3, 4, 5]  
print(my_list[0])  # 输出 1  
print(my_list[-1])  # 输出 5，使用负索引从列表末尾开始计数

12.3. 修改列表元素

可以通过索引直接修改列表中的元素。

my_list = [1, 2, 3, 4, 5]  
my_list[0] = 10  # 将第一个元素修改为 10  
print(my_list)  # 输出 [10, 2, 3, 4, 5]

12.4. 列表操作

• 拼接：使用 + 运算符拼接两个列表。

• 复制：使用 * 运算符复制列表。

• 切片：使用 [start:stop:step] 获取列表的子序列。

list1 = [1, 2, 3, 4, 5]  
list2 = [6, 7, 8, 9, 10]  
  
combined_list = list1 + list2  # [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]  
repeated_list = list1 * 3  # [1, 2, 3, 4, 5, 1, 2, 3, 4, 5, 1, 2, 3, 4, 5]  
sliced_list = list1[1:4]  # [2, 3, 4]

12.5. 列表方法

• append(x)：在列表末尾添加元素。

• extend(L)：将另一个列表的所有元素添加到当前列表的末尾。

• insert(i, x)：在指定位置插入元素。

• remove(x)：移除列表中第一个值为 x 的元素。

• pop([i])：移除并返回指定位置的元素，默认移除并返回最后一个元素。

• index(x)：返回列表中第一个值为 x 的元素的索引。

• count(x)：返回列表中值为 x 的元素的个数。

• sort()：对列表进行排序，原地修改列表。

• sorted()：返回排序后的新列表，原列表不变。

• reverse()：反转列表中的元素顺序，原地修改列表。

• clear()：清空列表。

my_list = [1, 3, 2, 4]  
my_list.append(5)  # [1, 3, 2, 4, 5]  
my_list.insert(1, 'a')  # [1, 'a', 3, 2, 4, 5]  
my_list.remove(3)  # [1, 'a', 2, 4, 5]  
print(my_list.pop())  # 输出 5，列表变为 [1, 'a', 2, 4]  
print(my_list.index('a'))  # 输出 1  
print(my_list.count(2))  # 输出 1  
my_list.sort()  # [1, 'a', 2, 4]  
print(sorted(my_list))  # 输出 [1, 2, 4, 'a']，原列表不变  
my_list.reverse()  # ['a', 4, 2, 1]  
my_list.clear()  # 清空列表

13 元组

Python元组（Tuple）是一个不可变的有序列表。与列表不同，元组中的元素不能被修改，一旦创建，元组就不能被改变。这使得元组在存储一组不可变的数据时非常有用。以下是一些关于Python元组的笔记：

13.1. 创建元组

元组可以使用圆括号 () 或 tuple() 函数来创建。

# 使用圆括号创建元组  
my_tuple = (1, 2, 3, 4, 5)  
  
# 使用 tuple() 函数创建元组  
another_tuple = tuple([1, 2, 3, 4, 5])  
  
# 只有一个元素的元组，需要在元素后面加逗号  
single_element_tuple = (1,)

13.2. 访问元组元素

访问元组元素的方式与列表相同，使用索引。

my_tuple = (1, 2, 3, 4, 5)  
print(my_tuple[0])  # 输出 1  
print(my_tuple[-1])  # 输出 5

13.3. 元组操作

• 拼接：可以使用 + 运算符将两个元组拼接起来。

• 复制：可以使用 * 运算符复制元组。

• 切片：与列表相同，可以使用 [start:stop:step] 来获取元组的子序列。

tuple1 = (1, 2, 3, 4, 5)  
tuple2 = (6, 7, 8, 9, 10)  
  
combined_tuple = tuple1 + tuple2  # (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)  
repeated_tuple = tuple1 * 2  # (1, 2, 3, 4, 5, 1, 2, 3, 4, 5)  
sliced_tuple = tuple1[1:4]  # (2, 3, 4)

13.4. 元组方法

元组没有很多可修改的方法，因为它是一个不可变序列。但有一些基本的操作方法，如 index() 和 count()。

• index(x)：返回元组中第一个值为 x 的元素的索引。

• count(x)：返回元组中值为 x 的元素的个数。

my_tuple = (1, 2, 2, 3, 4)  
print(my_tuple.index(2))  # 输出 1  
print(my_tuple.count(2))  # 输出 2

13.5. 元组与列表的转换

元组和列表之间可以相互转换。

my_list = [1, 2, 3]  
my_tuple = tuple(my_list)  # 转换为元组  
print(my_tuple)  # 输出 (1, 2, 3)  
  
my_tuple = (1, 2, 3)  
my_list = list(my_tuple)  # 转换为列表  
print(my_list)  # 输出 [1, 2, 3]

14 集合

Python集合（Set）是一个无序且不包含重复元素的集合。集合用于存储一系列唯一的元素，并且支持集合运算，如并集、交集、差集等。以下是一些关于Python集合的笔记：

14.1. 创建集合

可以使用大括号 {} 或 set() 函数来创建集合。

# 使用大括号创建集合  
my_set = {1, 2, 3, 4, 5}  
  
# 使用 set() 函数创建集合  
another_set = set([1, 2, 2, 3, 4, 4, 5])  # 重复的元素会自动去重

14.2. 访问集合元素

由于集合是无序的，因此不能直接通过索引访问集合中的元素。但你可以遍历集合来访问其元素。

my_set = {1, 2, 3, 4, 5}  
for item in my_set:  
    print(item)

14.3. 集合操作

• 并集：使用 | 运算符或 union() 方法求两个集合的并集。

• 交集：使用 & 运算符或 intersection() 方法求两个集合的交集。

• 差集：使用 - 运算符或 difference() 方法求一个集合与另一个集合的差集。

• 对称差集：使用 ^ 运算符或 symmetric_difference() 方法求两个集合的对称差集。

set1 = {1, 2, 3, 4}  
set2 = {3, 4, 5, 6}  
  
# 并集  
union_set = set1 | set2  # {1, 2, 3, 4, 5, 6}  
union_set = set1.union(set2)  # {1, 2, 3, 4, 5, 6}  
  
# 交集  
intersection_set = set1 & set2  # {3, 4}  
intersection_set = set1.intersection(set2)  # {3, 4}  
  
# 差集  
difference_set = set1 - set2  # {1, 2}  
difference_set = set1.difference(set2)  # {1, 2}  
  
# 对称差集  
symmetric_diff_set = set1 ^ set2  # {1, 2, 5, 6}  
symmetric_diff_set = set1.symmetric_difference(set2)  # {1, 2, 5, 6}

14.4. 集合方法

• add(x)：向集合中添加一个元素。

• remove(x)：从集合中移除一个元素。如果元素不存在，会抛出 KeyError。

• discard(x)：从集合中移除一个元素。如果元素不存在，不会抛出异常。

• pop()：随机移除集合中的一个元素并返回它。如果集合为空，会抛出 KeyError。

• clear()：清空集合。

• update(s)：用一个集合更新另一个集合，即添加另一个集合中所有不在原集合中的元素。

• isdisjoint(s)：如果两个集合没有交集，返回 True。

• issubset(s) 或 <=：判断一个集合是否是另一个集合的子集。

• issuperset(s) 或 >=：判断一个集合是否是另一个集合的超集。

my_set = {1, 2, 3}  
my_set.add(4)  # {1, 2, 3, 4}  
my_set.remove(3)  # {1, 2, 4}  
my_set.discard(5)  # 不会抛出异常  
item = my_set.pop()  # 随机移除一个元素并返回，可能是 1、2 或 4  
my_set.clear()  # 清空集合  
  
other_set = {3, 4, 5}  
my_set.update(other_set)  # 使用 other_set 更新 my_set，结果可能是 {3, 4, 5}（取决于之前 my_set 是否被清空）  
  
print(my_set.isdisjoint(other_set))  # 如果两个集合没有交集，返回 True  
print(my_set.issubset(other_set))  # 判断 my_set 是否是 other_set 的子集  
print(other_set.iss

15 字典

Python字典是一种可变的、无序的、键-值对的集合。在Python中，字典用花括号 {} 表示，每个键-值对之间使用冒号 : 分隔，不同的键-值对之间使用逗号 , 分隔。以下是一些关于Python字典的笔记：

15.1. 创建字典

my_dict = {'key1': 'value1', 'key2': 'value2', 'key3': 'value3'}

15.2. 访问字典元素

• 使用方括号 []：

value = my_dict['key1']  # 访问键为'key1'的值

• 使用 get() 方法：

value = my_dict.get('key1')  # 如果键存在，则返回对应的值；如果不存在，返回 None 或指定的默认值

15.3. 修改字典元素

my_dict['key1'] = 'new_value1'  # 修改键为'key1'的值

15.4. 添加字典元素

my_dict['new_key'] = 'new_value'  # 添加一个新的键-值对

15.5. 删除字典元素

• 使用 del 语句：

del my_dict['key1']  # 删除键为'key1'的项

• 使用 pop() 方法：

value = my_dict.pop('key1')  # 删除键为'key1'的项，并返回其值

• 使用 popitem() 方法：

key, value = my_dict.popitem()  # 随机删除并返回一对键-值对

• 使用 clear() 方法：

my_dict.clear()  # 清空字典，即删除所有键值对

15.6. 字典方法

• keys()：返回字典中所有的键。

• values()：返回字典中所有的值。

• items()：返回字典中所有的键值对。

• setdefault(key, default)：如果键不存在，则在字典中添加一个新的键值对，并返回默认值；如果键存在，则返回其值。

• update(dict2)：将字典 dict2 的键值对添加到当前字典中，如果有重复的键，则用新的值替换旧的值。

• copy()：复制字典。

• len()：返回字典中键值对的个数。

15.7. 字典的遍历

可以遍历字典的键、值或键值对：

for key in my_dict.keys():  
    print(key)  
  
for value in my_dict.values():  
    print(value)  
  
for key, value in my_dict.items():  
    print(key, value)

16 数据类型转换

数	描述
[int(x ,base])	将x转换为一个整数
[long(x ,base] )	将x转换为一个长整数
float(x)	将x转换到一个浮点数
[complex(real ,imag])	创建一个复数
str(x)	将对象 x 转换为字符串
repr(x)	将对象 x 转换为表达式字符串
eval(str)	用来计算在字符串中的有效Python表达式,并返回一个对象
tuple(s)	将序列 s 转换为一个元组
list(s)	将序列 s 转换为一个列表
set(s)	转换为可变集合
dict(d)	创建一个字典。d 必须是一个序列 (key,value)元组。
frozenset(s)	转换为不可变集合
chr(x)	将一个整数转换为一个字符
unichr(x)	将一个整数转换为Unicode字符
ord(x)	将一个字符转换为它的整数值
hex(x)	将一个整数转换为一个十六进制字符串
oct(x)	将一个整数转换为一个八进制字符串

17 函数

17.1. 函数定义

Python中定义函数使用def关键字，后跟函数名和括号内的参数列表，最后以冒号结束。函数体是缩进的代码块，通常包含实现特定功能的语句。

def function_name(parameters):  
    """Docstring explaining the function."""  
    # Function body goes here  
    result = some_computation  
    return result

17.2. 返回值

函数通过return语句返回一个值。如果函数没有return语句，或只有return而没有跟任何值，那么函数返回None。

def get_sum(a, b):  
    return a + b  
  
result = get_sum(3, 4)  # result will be 7

17.3. 参数

函数参数是函数定义时指定的变量，用于接收传递给函数的值。参数可以是必需的，也可以有默认值。

def greet(name, greeting="Hello"):  
    return greeting + ", " + name + "!"  
  
print(greet("Alice"))       # 输出: Hello, Alice!  
print(greet("Bob", "Hi"))  # 输出: Hi, Bob!

17.4. 作用域

作用域决定了变量的可见性和生命周期。Python中的变量可以是局部的（在函数或循环内部定义），也可以是全局的（在函数外部定义）。在函数内部，你可以使用global关键字来声明一个变量为全局变量。

x = 10  # Global variable  
  
def test_scope():  
    global x  # Declare x as global  
    x = 20    # This will change the global x  
    y = 30    # Local variable  
    print(x)  # Prints 20  
  
test_scope()  
print(x)  # Prints 20 (global x has been changed)  
# print(y) # Raises NameError because y is local to the function

18 函数参数笔记

在 Python3 中，函数参数是用于传递值给函数并在函数内部进行操作的变量。函数参数有几种不同的类型，包括必需参数、默认参数、可变参数和关键字参数。下面是对这些参数类型的详细解释。

18.1 必需参数

必需参数是函数定义时指定的参数，调用函数时必须提供这些参数的值。

def greet(name):  
    return "Hello, " + name + "!"  
  
print(greet("Alice"))  # 输出: Hello, Alice!

在上面的例子中，name 是一个必需参数，调用 greet 函数时必须提供一个名字作为参数。

18.2. 默认参数

默认参数是在函数定义时赋了默认值的参数。如果在调用函数时没有提供这些参数的值，那么就会使用默认值。

def greet(name, greeting="Hello"):  
    return greeting + ", " + name + "!"  
  
print(greet("Alice"))           # 输出: Hello, Alice!  
print(greet("Bob", "Hi"))      # 输出: Hi, Bob!

在这个例子中，greeting 参数有一个默认值 "Hello"。如果调用 greet 函数时没有提供 greeting 参数的值，就会使用默认值 "Hello"。

18.3. 可变参数

可变参数允许你传入任意数量的参数到函数中。这可以通过使用 *args 来实现，其中 args 是一个元组，包含了所有传入的位置参数。

def sum_numbers(*args):  
    return sum(args)  
  
print(sum_numbers(1, 2, 3))  # 输出: 6  
print(sum_numbers(4, 5, 6, 7))  # 输出: 22

在这个例子中，sum_numbers 函数可以接受任意数量的参数，并将它们加在一起。

18.4. 关键字参数

关键字参数允许你通过参数名来指定参数的值。这可以通过使用 **kwargs 来实现，其中 kwargs 是一个字典，包含了所有传入的关键字参数。

def greet_person(**kwargs):  
    for key, value in kwargs.items():  
        print(f"{key}: {value}")  
  
greet_person(name="Alice", age=30, city="New York")  
# 输出:  
# name: Alice  
# age: 30  
# city: New York

在这个例子中，greet_person 函数可以接受任意数量的关键字参数，并打印出它们的键和值。

19 文件处理

19.1. I/O（输入/输出）

I/O操作指的是从外部设备（如硬盘、网络等）读取数据（输入）和向外部设备写入数据（输出）。在Python中，文件操作是最常见的I/O操作之一。

19.2. 打开和关闭文件（open/close）

打开文件 使用open()函数可以打开文件。需要指定文件路径和打开模式（如读取'r'，写入'w'，追加'a'等）。

file = open('filename.txt', 'r')  # 打开文件用于读取

关闭文件 使用close()方法可以关闭已打开的文件。

file.close()  # 关闭文件

19.3. 读取文件内容

读取整个文件

with open('filename.txt', 'r') as file:  
    content = file.read()  
print(content)

逐行读取

with open('filename.txt', 'r') as file:  
    for line in file:  
        print(line, end='')

19.4. 写入文件

写入文本

with open('filename.txt', 'w') as file:  
    file.write('Hello, World!')

追加文本

with open('filename.txt', 'a') as file:  
    file.write('\nAnother line of text.')

19.5. JSON序列化与反序列化

序列化（将Python对象转换为JSON字符串）

import json  
  
data = {  
    'name': 'Alice',  
    'age': 30  
}  
  
json_data = json.dumps(data)  # 序列化  
print(json_data)  # 输出：'{"name": "Alice", "age": 30}'

反序列化（将JSON字符串转换为Python对象）

python_data = json.loads(json_data)  # 反序列化  
print(python_data)  # 输出：{'name': 'Alice', 'age': 30}

19.6. CSV文件读取

读取CSV文件

import csv  
  
with open('example.csv', 'r') as csvfile:  
    reader = csv.reader(csvfile)  
    for row in reader:  
        print(row)  # 打印每一行，每行是一个列表

使用csv.DictReader读取CSV文件

csv.DictReader可以将CSV文件的每一行读取为字典，其中字典的键是列名。

import csv  
  
with open('example.csv', 'r') as csvfile:  
    reader = csv.DictReader(csvfile)  
    for row in reader:  
        print(row)  # 打印每一行，每行是一个字典

1 为什么要学习python

1.1 渗透方向

1. 网络扫描与探测

2. 漏洞利用与EXP

3. Web应用渗透测试

4. 密码学分析与破解

5. 二进制分析与逆向工程

6. 社会工程学攻击

7. 无线网络安全

8. 报告与自动化

1.2 应急响应方向

1. 日志分析与收集

2. 内存与磁盘取证

3. 网络流量分析

4. 恶意软件分析

5. 自动化响应与恢复

6. 报告与通信

1.3 python的特点

1. 简洁易读

2. 丰富的标准库和第三方库

3. 跨平台性

4. 面向对象

5. 可扩展性

6. 强大的社区支持

7. 广泛的应用领域

2 python初次尝试

2.1 python安装

1.linux

sudo apt-get update
sudo apt-get install python3

2.mac

brew install python3

3 windwos

2.2 编辑器

vim:人类史上最好用的文本编辑器，从此以后你就是个充满极客风的hacker

better

Stronger

Faster

2.3 新建.vimrc

set nocompatible 
set number 
set nowrap    
set showmatch  
set scrolloff=3      
set encoding=utf-8  
set fenc=utf-8      
set mouse=a        
set hlsearch        
syntax on    
​
au BufNewFile,BufRead *.py
 set tabstop=4   
 set softtabstop=4  
 set shiftwidth=4   
 set textwidth=79  
 set expandtab       
 set autoindent      
 set fileformat=unix  

3 hello word

3.1hello world

新建vi hello.py

print('hello world')

输入 python hello.py

3.2 求圆的面积

新建round.py

#! /usr/bin/env python3
​
from math import pi
resuit = 5 * 5 * pi
print(resuit)

3.3 执行脚本

执行脚本方式
方式1
python  xxx.py
方式2
chmod +x xxx.py
./xxx.py

4 数据类型与变量

4.1 None和Bool:

None:表示空对象

Bool: Python中使用True和False来表示布尔值注意首字母大写，即判断 Python 对象、返回值、表达式真假的一组特殊数据类型

4.2 保留字:

保留字，又称为关键字，每种语言都有自己的一套预先保留的特殊标识符，Python 也不例外，它自带的keyword模块可以查看全部关键字。

4.3 内置函数

		内置函数
abs()	divmod()	input()	open()	staticmethod()
all()	enumerate()	int()	ord()	str()
any()	eval()	isinstance()	pow()	sum()
basestring()	execfile()	issubclass()	print()	super()
bin()	file()	iter()	property()	tuple()
bool()	filter()	len()	range()	type()
bytearray()	float()	list()	raw_input()	unichr()
callable()	format()	locals()	reduce()	unicode()
chr()	frozenset()	long()	reload()	vars()
classmethod()	getattr()	map()	repr()	xrange()
cmp()	globals()	max()	reverse()	zip()
compile()	hasattr()	memoryview()	round()	import()
complex()	hash()	min()	set()
delattr()	help()	next()	setattr()
dict()	hex()	object()	slice()
dir()	id()	oct()	sorted()	exec 内置表达式

4.4 变量

4.4.1 变量介绍

编程语言中为了能够更好的处理数据，都需要使用一些变量。变量基本上就是代表(或是引用某值的名字)。Python语言的变量可以是各种不同的数据类型，使用变量的时候不需要声明，Python解释器会自动判断数据类型。使用type(变量)可以查看该变量的类型。

4.4.2 变量命名规则

1. 标识符命名规则：

   • 变量名只能包含字母（a-z，A-Z）、数字（0-9）和下划线（_）。

   • 变量名不能以数字开头。例如，123var 是无效的，但 var123 是有效的。

   • 变量名是区分大小写的。例如，myVar 和 myvar 是两个不同的变量。

2. 推荐的命名风格：

   • 小写字母和下划线：这是Python中推荐的命名风格，也称为“snake_case”。例如，my_variable。

   • 对于类名，通常使用驼峰命名法，即首字母大写的单词组合，不使用下划线。例如，MyClass。

3. 避免使用Python保留字：

   • 不要使用Python的保留字（如 if, for, while, class, def 等）作为变量名。这会导致语法错误。

4. 清晰和描述性：

   • 变量名应该尽可能地清晰和描述性，以便其他阅读代码的人能够轻易理解其用途。例如，num_students 比 ns 更清晰。

5. 避免使用通用名称：

   • 避免使用像 l, O, I 这样的字母或像 list, dict, str 这样的通用类型名作为变量名，因为它们可能与Python的内置函数或类型混淆。

6. 使用有意义的缩写：

   • 如果变量名太长，可以使用有意义的缩写。但是，应确保这些缩写在上下文中是清晰的，并且对于不熟悉该代码的读者来说也是易于理解的。

7. 常量命名：

   • 如果一个变量的值在程序运行期间不会改变，通常我们会将其视为常量。在Python中，并没有内置的常量类型，但通常我们会使用全大写字母和下划线来命名常量，例如 MAX_VALUE。

5 空行，缩进与多行代码

5.1 空行

一般空行用于不同函数之间、不同类之间、以及类和函数之间进行分隔。空行不是 Python的语法，即使不插入空行程序运行也不会出错。插入空行的主要目的是方便代码阅读以及日后的维护。

5.2 缩进

Python对于缩进的要求是非常严格的，它依靠缩进距离区分代码块，所以在Python中缩进也是一种语法，缩进的距离是可变的，具有相同缩进距离的属于同一个代码块。

5.3 多行代码

Python代码中一般一行只写一条语句。如果想要在一行中写多条语句，那么语句之间就需要使用；进行分隔。

6 字符串

6.1 字符串

Python 3中的字符串可以使用双引号或单引号标示，如果字符串中出现引号，则可以使用\来去除引号标示字符串的特殊作用。

新建string.py

#!/usr/bin/env python3
​
str1 = "hello"
str2 = 'world'
str3 = 'hello,\'world\''
str4 = "hello,'world'"
str5 = 'hello,"world"'
​
print(str1)
print(str2)
print(str3)
print(str4)
print(str5)

新建string2.py

#!/usr/bin/env python3
​
str1 = "hello"
str2 = 'world'
str3 = 'hello,\'world\''
str4 = "hello,'world'"
str5 = 'hello,"world"'
str6 = """ hello,
world """
​
​
​
print(str1+' '+str2)
print(str6)
#print(str3)
#print(str4)
#print(str5)

6.2 字符串的常用属性和方法

1.count
2.split和strip
3.upper和lower
4._len_

7 运算符

7.1 算数运算符

运算符	描述	实例
+	加 - 两个对象相加	a + b 输出结果 30
-	减 - 得到负数或是一个数减去另一个数	a - b 输出结果 -10
*	乘 - 两个数相乘或是返回一个被重复若干次的字符串	a * b 输出结果 200
/	除 - x除以y	b / a 输出结果 2
%	取模 - 返回除法的余数	b % a 输出结果 0
**	幂 - 返回x的y次幂	a**b 为10的20次方， 输出结果 100000000000000000000
//	取整除 - 返回商的整数部分（向下取整）	>>> 9//2 4 >>> -9//2 -5

7.2 比较运算符

运算符	描述	实例
==	等于 - 比较对象是否相等	(a == b) 返回 False。
!=	不等于 - 比较两个对象是否不相等	(a != b) 返回 True。
<>	不等于 - 比较两个对象是否不相等。python3 已废弃。	(a <> b) 返回 True。这个运算符类似 != 。
>	大于 - 返回x是否大于y	(a > b) 返回 False。
<	小于 - 返回x是否小于y。所有比较运算符返回1表示真，返回0表示假。这分别与特殊的变量 True 和 False 等价。	(a < b) 返回 True。
>=	大于等于 - 返回x是否大于等于y。	(a >= b) 返回 False。
<=	小于等于 - 返回x是否小于等于y。	(a <= b) 返回 True。

7.3 赋值运算符

运算符	描述	实例
=	简单的赋值运算符	c = a + b 将 a + b 的运算结果赋值为 c
+=	加法赋值运算符	c += a 等效于 c = c + a
-=	减法赋值运算符	c -= a 等效于 c = c - a
*=	乘法赋值运算符	c *= a 等效于 c = c * a
/=	除法赋值运算符	c /= a 等效于 c = c / a
%=	取模赋值运算符	c %= a 等效于 c = c % a
**=	幂赋值运算符	c = a 等效于 c = c a
//=	取整除赋值运算符	c //= a 等效于 c = c // a

7.4 逻辑运算符

运算符	逻辑表达式	描述	实例
and	x and y	布尔"与" - 如果 x 为 False，x and y 返回 False，否则它返回 y 的计算值。	(a and b) 返回 20。
or	x or y	布尔"或" - 如果 x 是非 0，它返回 x 的计算值，否则它返回 y 的计算值。	(a or b) 返回 10。
not	not x	布尔"非" - 如果 x 为 True，返回 False 。如果 x 为 False，它返回 True。	not(a and b) 返回 False

7.5 成员运算符

运算符	描述	实例
in	如果在指定的序列中找到值返回 True，否则返回 False。	x 在 y 序列中 , 如果 x 在 y 序列中返回 True。
not in	如果在指定的序列中没有找到值返回 True，否则返回 False。	x 不在 y 序列中 , 如果 x 不在 y 序列中返回 True。

7.6 身份运算符

运算符	描述	实例
is	is 是判断两个标识符是不是引用自一个对象	x is y, 类似 id(x) == id(y) , 如果引用的是同一个对象则返回 True，否则返回 False
is not	is not 是判断两个标识符是不是引用自不同对象	x is not y ， 类似 id(a) != id(b)。如果引用的不是同一个对象则返回结果 True，否则返回 False。

7.7 运算符优先级

运算符	描述
**	指数 (最高优先级)
~ + -	按位翻转, 一元加号和减号 (最后两个的方法名为 +@ 和 -@)
* / % //	乘，除，取模和取整除
+ -	加法减法
>> <<	右移，左移运算符
&	位 'AND'
^ |	位运算符
<= < > >=	比较运算符
<> == !=	等于运算符
= %= /= //= -= += *= **=	赋值运算符
is is not	身份运算符
in not in	成员运算符
not and or	逻辑运算符

8 判断与循环

8.1 判断

8.1.1 单个if判断

if 语句用于控制程序的执行，基本形式为：

if 判断条件：
    执行语句……
else：
    执行语句……

#!/usr/bin/env python3
​
a = 15
​
if a > 20:
    print('a > 20')
elif a == 20:
    print('a == 20')
else:
    print('a < 20')

8.1.2 多个if判断

if 语句的判断条件可以用>（大于）、<(小于)、==（等于）、>=（大于等于）、<=（小于等于）来表示其关系。

当判断条件为多个值时，可以使用以下形式：

if 判断条件1:
    执行语句1……
elif 判断条件2:
    执行语句2……
elif 判断条件3:
    执行语句3……
else:
    执行语句4……

#!/usr/bin/env python3
​
a = 25
​
if a > 20:
    print('a > 20')
    if a == 25:
        print('a == 25')
elif a == 20:
    print('a == 20')
else:
    print('a < 20')

效果图

8.2 循环

8.2.1 while循环

while 语句用于循环执行程序，即在某条件下，循环执行某段程序，以处理需要重复处理的相同任务。其基本形式为：

while 判断条件(condition)：
    执行语句(statements)……

执行语句可以是单个语句或语句块。判断条件可以是任何表达式，任何非零、或非空（null）的值均为true。

当判断条件假 false 时，循环结束。

#!/usr/bin/env python3
​
a = 100
​
while a > 10:
    print(a)
    a -= 5

8.2.2 for循环

for循环可以遍历任何序列的项目，如一个列表或者一个字符串。

语法：

for循环的语法格式如下：

for iterating_var in sequence:
   statements(s)

#!/usr/bin/env python3
​
strlist = ['hello','world','wuyue']
​
for s in strlist:
    print(s)

8.2.3 嵌套循环

允许在一个循环体里面嵌入另一个循环。

#!/usr/bin/env python3  
  
i = 2  
while(i < 100):  
   j = 2  
   while(j * j <= i):  
      if (i % j) == 0:  
         break  
      j = j + 1  
   if (j * j > i):  
      print(i, "是素数")  
   i = i + 1  
  
print("Good bye!")

8.2.4 break控制

break语句，就像在C语言中，打破了最小封闭for或while循环。

break语句用来终止循环语句，即循环条件没有False条件或者序列还没被完全递归完，也会停止执行循环语句。

break语句用在while和for循环中。

如果您使用嵌套循环，break语句将停止执行最深层的循环，并开始执行下一行代码。

#!/usr/bin/env python3  
# -*- coding: UTF-8 -*-  
  
for letter in 'Python':     # 第一个实例  
    if letter == 'h':  
        break  
    print('当前字母 :', letter)  
  
var = 10                    # 第二个实例  
while var > 0:                
    print('当前变量值 :', var)  
    var = var - 1  
    if var == 5:   # 当变量 var 等于 5 时退出循环  
        break  
  
print("Good bye!")

8.2.5 continue 语句

continue 语句跳出本次循环，而break跳出整个循环。

continue 语句用来告诉Python跳过当前循环的剩余语句，然后继续进行下一轮循环。

continue语句用在while和for循环中。

#!/usr/bin/env python3  
# -*- coding: UTF-8 -*-  
  
for letter in 'Python':     # 第一个实例  
    if letter == 'h':  
        continue  
    print('当前字母 :', letter)  
  
var = 10                    # 第二个实例  
while var > 0:                
    var = var - 1  
    if var == 5:  
        continue  
    print('当前变量值 :', var)  
  
print("Good bye!")

9 命令行参数

#!/usr/bin/env python3
​
import sys
​
print(len(sys.argv))
​
for arg in sys.argv:
    print(arg)
​

10 模块

1 _name_与_main_

2 引入模块的方式
import xxxx
from xxx import xxx
from xxx import xxx as xxx
​

3.模块的搜索路径

11 包

pip常用命令:
显示版本和路径: pip3 --version
升级pip: sudo pip3 install --upgrade pip
安装包: (sudo) pip3 install package，如果需要指定版本就是:pip3 installpackage==1.0.3(写具体的版本号)
卸载包: pip3 uninstall package
升级包: pip3 install --upgrade package，可以使用==,>=,<=,<,>来指定版本号
查看安装已安装的包: pip3 list
把需要安装的一系列包写入requirements.txt 文件中，然后执行: pip3 install -r requirements.txt

12 列表

Python 列表（List）是一种有序的数据结构，用于存储一系列的元素。这些元素可以是任何数据类型，包括数字、字符串、列表等，且列表中的元素不需要具有相同的类型。以下是一些关于 Python 列表的笔记：

12.1. 创建列表

可以使用方括号 [] 或 list() 函数来创建列表。

# 使用方括号创建列表  
my_list = [1, 2, 3, 4, 5]  
  
# 使用 list() 函数创建列表  
another_list = list((1, 2, 3, 4, 5))

12.2. 访问列表元素

通过索引访问列表中的元素，索引从 0 开始。

my_list = [1, 2, 3, 4, 5]  
print(my_list[0])  # 输出 1  
print(my_list[-1])  # 输出 5，使用负索引从列表末尾开始计数

12.3. 修改列表元素

可以通过索引直接修改列表中的元素。

my_list = [1, 2, 3, 4, 5]  
my_list[0] = 10  # 将第一个元素修改为 10  
print(my_list)  # 输出 [10, 2, 3, 4, 5]

12.4. 列表操作

• 拼接：使用 + 运算符拼接两个列表。

• 复制：使用 * 运算符复制列表。

• 切片：使用 [start:stop:step] 获取列表的子序列。

list1 = [1, 2, 3, 4, 5]  
list2 = [6, 7, 8, 9, 10]  
  
combined_list = list1 + list2  # [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]  
repeated_list = list1 * 3  # [1, 2, 3, 4, 5, 1, 2, 3, 4, 5, 1, 2, 3, 4, 5]  
sliced_list = list1[1:4]  # [2, 3, 4]

12.5. 列表方法

• append(x)：在列表末尾添加元素。

• extend(L)：将另一个列表的所有元素添加到当前列表的末尾。

• insert(i, x)：在指定位置插入元素。

• remove(x)：移除列表中第一个值为 x 的元素。

• pop([i])：移除并返回指定位置的元素，默认移除并返回最后一个元素。

• index(x)：返回列表中第一个值为 x 的元素的索引。

• count(x)：返回列表中值为 x 的元素的个数。

• sort()：对列表进行排序，原地修改列表。

• sorted()：返回排序后的新列表，原列表不变。

• reverse()：反转列表中的元素顺序，原地修改列表。

• clear()：清空列表。

my_list = [1, 3, 2, 4]  
my_list.append(5)  # [1, 3, 2, 4, 5]  
my_list.insert(1, 'a')  # [1, 'a', 3, 2, 4, 5]  
my_list.remove(3)  # [1, 'a', 2, 4, 5]  
print(my_list.pop())  # 输出 5，列表变为 [1, 'a', 2, 4]  
print(my_list.index('a'))  # 输出 1  
print(my_list.count(2))  # 输出 1  
my_list.sort()  # [1, 'a', 2, 4]  
print(sorted(my_list))  # 输出 [1, 2, 4, 'a']，原列表不变  
my_list.reverse()  # ['a', 4, 2, 1]  
my_list.clear()  # 清空列表

13 元组

Python元组（Tuple）是一个不可变的有序列表。与列表不同，元组中的元素不能被修改，一旦创建，元组就不能被改变。这使得元组在存储一组不可变的数据时非常有用。以下是一些关于Python元组的笔记：

13.1. 创建元组

元组可以使用圆括号 () 或 tuple() 函数来创建。

# 使用圆括号创建元组  
my_tuple = (1, 2, 3, 4, 5)  
  
# 使用 tuple() 函数创建元组  
another_tuple = tuple([1, 2, 3, 4, 5])  
  
# 只有一个元素的元组，需要在元素后面加逗号  
single_element_tuple = (1,)

13.2. 访问元组元素

访问元组元素的方式与列表相同，使用索引。

my_tuple = (1, 2, 3, 4, 5)  
print(my_tuple[0])  # 输出 1  
print(my_tuple[-1])  # 输出 5

13.3. 元组操作

• 拼接：可以使用 + 运算符将两个元组拼接起来。

• 复制：可以使用 * 运算符复制元组。

• 切片：与列表相同，可以使用 [start:stop:step] 来获取元组的子序列。

tuple1 = (1, 2, 3, 4, 5)  
tuple2 = (6, 7, 8, 9, 10)  
  
combined_tuple = tuple1 + tuple2  # (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)  
repeated_tuple = tuple1 * 2  # (1, 2, 3, 4, 5, 1, 2, 3, 4, 5)  
sliced_tuple = tuple1[1:4]  # (2, 3, 4)

13.4. 元组方法

元组没有很多可修改的方法，因为它是一个不可变序列。但有一些基本的操作方法，如 index() 和 count()。

• index(x)：返回元组中第一个值为 x 的元素的索引。

• count(x)：返回元组中值为 x 的元素的个数。

my_tuple = (1, 2, 2, 3, 4)  
print(my_tuple.index(2))  # 输出 1  
print(my_tuple.count(2))  # 输出 2

13.5. 元组与列表的转换

元组和列表之间可以相互转换。

my_list = [1, 2, 3]  
my_tuple = tuple(my_list)  # 转换为元组  
print(my_tuple)  # 输出 (1, 2, 3)  
  
my_tuple = (1, 2, 3)  
my_list = list(my_tuple)  # 转换为列表  
print(my_list)  # 输出 [1, 2, 3]

14 集合

Python集合（Set）是一个无序且不包含重复元素的集合。集合用于存储一系列唯一的元素，并且支持集合运算，如并集、交集、差集等。以下是一些关于Python集合的笔记：

14.1. 创建集合

可以使用大括号 {} 或 set() 函数来创建集合。

# 使用大括号创建集合  
my_set = {1, 2, 3, 4, 5}  
  
# 使用 set() 函数创建集合  
another_set = set([1, 2, 2, 3, 4, 4, 5])  # 重复的元素会自动去重

14.2. 访问集合元素

由于集合是无序的，因此不能直接通过索引访问集合中的元素。但你可以遍历集合来访问其元素。

my_set = {1, 2, 3, 4, 5}  
for item in my_set:  
    print(item)

14.3. 集合操作

• 并集：使用 | 运算符或 union() 方法求两个集合的并集。

• 交集：使用 & 运算符或 intersection() 方法求两个集合的交集。

• 差集：使用 - 运算符或 difference() 方法求一个集合与另一个集合的差集。

• 对称差集：使用 ^ 运算符或 symmetric_difference() 方法求两个集合的对称差集。

set1 = {1, 2, 3, 4}  
set2 = {3, 4, 5, 6}  
  
# 并集  
union_set = set1 | set2  # {1, 2, 3, 4, 5, 6}  
union_set = set1.union(set2)  # {1, 2, 3, 4, 5, 6}  
  
# 交集  
intersection_set = set1 & set2  # {3, 4}  
intersection_set = set1.intersection(set2)  # {3, 4}  
  
# 差集  
difference_set = set1 - set2  # {1, 2}  
difference_set = set1.difference(set2)  # {1, 2}  
  
# 对称差集  
symmetric_diff_set = set1 ^ set2  # {1, 2, 5, 6}  
symmetric_diff_set = set1.symmetric_difference(set2)  # {1, 2, 5, 6}

14.4. 集合方法

• add(x)：向集合中添加一个元素。

• remove(x)：从集合中移除一个元素。如果元素不存在，会抛出 KeyError。

• discard(x)：从集合中移除一个元素。如果元素不存在，不会抛出异常。

• pop()：随机移除集合中的一个元素并返回它。如果集合为空，会抛出 KeyError。

• clear()：清空集合。

• update(s)：用一个集合更新另一个集合，即添加另一个集合中所有不在原集合中的元素。

• isdisjoint(s)：如果两个集合没有交集，返回 True。

• issubset(s) 或 <=：判断一个集合是否是另一个集合的子集。

• issuperset(s) 或 >=：判断一个集合是否是另一个集合的超集。

my_set = {1, 2, 3}  
my_set.add(4)  # {1, 2, 3, 4}  
my_set.remove(3)  # {1, 2, 4}  
my_set.discard(5)  # 不会抛出异常  
item = my_set.pop()  # 随机移除一个元素并返回，可能是 1、2 或 4  
my_set.clear()  # 清空集合  
  
other_set = {3, 4, 5}  
my_set.update(other_set)  # 使用 other_set 更新 my_set，结果可能是 {3, 4, 5}（取决于之前 my_set 是否被清空）  
  
print(my_set.isdisjoint(other_set))  # 如果两个集合没有交集，返回 True  
print(my_set.issubset(other_set))  # 判断 my_set 是否是 other_set 的子集  
print(other_set.iss

15 字典

Python字典是一种可变的、无序的、键-值对的集合。在Python中，字典用花括号 {} 表示，每个键-值对之间使用冒号 : 分隔，不同的键-值对之间使用逗号 , 分隔。以下是一些关于Python字典的笔记：

15.1. 创建字典

my_dict = {'key1': 'value1', 'key2': 'value2', 'key3': 'value3'}

15.2. 访问字典元素

• 使用方括号 []：

value = my_dict['key1']  # 访问键为'key1'的值

• 使用 get() 方法：

value = my_dict.get('key1')  # 如果键存在，则返回对应的值；如果不存在，返回 None 或指定的默认值

15.3. 修改字典元素

my_dict['key1'] = 'new_value1'  # 修改键为'key1'的值

15.4. 添加字典元素

my_dict['new_key'] = 'new_value'  # 添加一个新的键-值对

15.5. 删除字典元素

• 使用 del 语句：

del my_dict['key1']  # 删除键为'key1'的项

• 使用 pop() 方法：

value = my_dict.pop('key1')  # 删除键为'key1'的项，并返回其值

• 使用 popitem() 方法：

key, value = my_dict.popitem()  # 随机删除并返回一对键-值对

• 使用 clear() 方法：

my_dict.clear()  # 清空字典，即删除所有键值对

15.6. 字典方法

• keys()：返回字典中所有的键。

• values()：返回字典中所有的值。

• items()：返回字典中所有的键值对。

• setdefault(key, default)：如果键不存在，则在字典中添加一个新的键值对，并返回默认值；如果键存在，则返回其值。

• update(dict2)：将字典 dict2 的键值对添加到当前字典中，如果有重复的键，则用新的值替换旧的值。

• copy()：复制字典。

• len()：返回字典中键值对的个数。

15.7. 字典的遍历

可以遍历字典的键、值或键值对：

for key in my_dict.keys():  
    print(key)  
  
for value in my_dict.values():  
    print(value)  
  
for key, value in my_dict.items():  
    print(key, value)

16 数据类型转换

数	描述
[int(x ,base])	将x转换为一个整数
[long(x ,base] )	将x转换为一个长整数
float(x)	将x转换到一个浮点数
[complex(real ,imag])	创建一个复数
str(x)	将对象 x 转换为字符串
repr(x)	将对象 x 转换为表达式字符串
eval(str)	用来计算在字符串中的有效Python表达式,并返回一个对象
tuple(s)	将序列 s 转换为一个元组
list(s)	将序列 s 转换为一个列表
set(s)	转换为可变集合
dict(d)	创建一个字典。d 必须是一个序列 (key,value)元组。
frozenset(s)	转换为不可变集合
chr(x)	将一个整数转换为一个字符
unichr(x)	将一个整数转换为Unicode字符
ord(x)	将一个字符转换为它的整数值
hex(x)	将一个整数转换为一个十六进制字符串
oct(x)	将一个整数转换为一个八进制字符串

17 函数

17.1. 函数定义

Python中定义函数使用def关键字，后跟函数名和括号内的参数列表，最后以冒号结束。函数体是缩进的代码块，通常包含实现特定功能的语句。

def function_name(parameters):  
    """Docstring explaining the function."""  
    # Function body goes here  
    result = some_computation  
    return result

17.2. 返回值

函数通过return语句返回一个值。如果函数没有return语句，或只有return而没有跟任何值，那么函数返回None。

def get_sum(a, b):  
    return a + b  
  
result = get_sum(3, 4)  # result will be 7

17.3. 参数

函数参数是函数定义时指定的变量，用于接收传递给函数的值。参数可以是必需的，也可以有默认值。

def greet(name, greeting="Hello"):  
    return greeting + ", " + name + "!"  
  
print(greet("Alice"))       # 输出: Hello, Alice!  
print(greet("Bob", "Hi"))  # 输出: Hi, Bob!

17.4. 作用域

作用域决定了变量的可见性和生命周期。Python中的变量可以是局部的（在函数或循环内部定义），也可以是全局的（在函数外部定义）。在函数内部，你可以使用global关键字来声明一个变量为全局变量。

x = 10  # Global variable  
  
def test_scope():  
    global x  # Declare x as global  
    x = 20    # This will change the global x  
    y = 30    # Local variable  
    print(x)  # Prints 20  
  
test_scope()  
print(x)  # Prints 20 (global x has been changed)  
# print(y) # Raises NameError because y is local to the function

18 函数参数笔记

在 Python3 中，函数参数是用于传递值给函数并在函数内部进行操作的变量。函数参数有几种不同的类型，包括必需参数、默认参数、可变参数和关键字参数。下面是对这些参数类型的详细解释。

18.1 必需参数

必需参数是函数定义时指定的参数，调用函数时必须提供这些参数的值。

def greet(name):  
    return "Hello, " + name + "!"  
  
print(greet("Alice"))  # 输出: Hello, Alice!

在上面的例子中，name 是一个必需参数，调用 greet 函数时必须提供一个名字作为参数。

18.2. 默认参数

默认参数是在函数定义时赋了默认值的参数。如果在调用函数时没有提供这些参数的值，那么就会使用默认值。

def greet(name, greeting="Hello"):  
    return greeting + ", " + name + "!"  
  
print(greet("Alice"))           # 输出: Hello, Alice!  
print(greet("Bob", "Hi"))      # 输出: Hi, Bob!

在这个例子中，greeting 参数有一个默认值 "Hello"。如果调用 greet 函数时没有提供 greeting 参数的值，就会使用默认值 "Hello"。

18.3. 可变参数

可变参数允许你传入任意数量的参数到函数中。这可以通过使用 *args 来实现，其中 args 是一个元组，包含了所有传入的位置参数。

def sum_numbers(*args):  
    return sum(args)  
  
print(sum_numbers(1, 2, 3))  # 输出: 6  
print(sum_numbers(4, 5, 6, 7))  # 输出: 22

在这个例子中，sum_numbers 函数可以接受任意数量的参数，并将它们加在一起。

18.4. 关键字参数

关键字参数允许你通过参数名来指定参数的值。这可以通过使用 **kwargs 来实现，其中 kwargs 是一个字典，包含了所有传入的关键字参数。

def greet_person(**kwargs):  
    for key, value in kwargs.items():  
        print(f"{key}: {value}")  
  
greet_person(name="Alice", age=30, city="New York")  
# 输出:  
# name: Alice  
# age: 30  
# city: New York

在这个例子中，greet_person 函数可以接受任意数量的关键字参数，并打印出它们的键和值。

19 文件处理

19.1. I/O（输入/输出）

I/O操作指的是从外部设备（如硬盘、网络等）读取数据（输入）和向外部设备写入数据（输出）。在Python中，文件操作是最常见的I/O操作之一。

19.2. 打开和关闭文件（open/close）

打开文件 使用open()函数可以打开文件。需要指定文件路径和打开模式（如读取'r'，写入'w'，追加'a'等）。

file = open('filename.txt', 'r')  # 打开文件用于读取

关闭文件 使用close()方法可以关闭已打开的文件。

file.close()  # 关闭文件

19.3. 读取文件内容

读取整个文件

with open('filename.txt', 'r') as file:  
    content = file.read()  
print(content)

逐行读取

with open('filename.txt', 'r') as file:  
    for line in file:  
        print(line, end='')

19.4. 写入文件

写入文本

with open('filename.txt', 'w') as file:  
    file.write('Hello, World!')

追加文本

with open('filename.txt', 'a') as file:  
    file.write('\nAnother line of text.')

19.5. JSON序列化与反序列化

序列化（将Python对象转换为JSON字符串）

import json  
  
data = {  
    'name': 'Alice',  
    'age': 30  
}  
  
json_data = json.dumps(data)  # 序列化  
print(json_data)  # 输出：'{"name": "Alice", "age": 30}'

反序列化（将JSON字符串转换为Python对象）

python_data = json.loads(json_data)  # 反序列化  
print(python_data)  # 输出：{'name': 'Alice', 'age': 30}

19.6. CSV文件读取

读取CSV文件

import csv  
  
with open('example.csv', 'r') as csvfile:  
    reader = csv.reader(csvfile)  
    for row in reader:  
        print(row)  # 打印每一行，每行是一个列表

使用csv.DictReader读取CSV文件

csv.DictReader可以将CSV文件的每一行读取为字典，其中字典的键是列名。

import csv  
  
with open('example.csv', 'r') as csvfile:  
    reader = csv.DictReader(csvfile)  
    for row in reader:  
        print(row)  # 打印每一行，每行是一个字典

20 异常处理

Python 3中的异常处理是一种强大的编程工具，它允许程序在运行时遇到错误或异常情况时能够优雅地处理，而不是简单地崩溃。以下是关于Python 3异常处理的一些笔记：

20.1. 异常类型

Python内置了许多异常类型，如ValueError、TypeError、KeyError、IndexError等。当Python解释器在执行代码时遇到错误时，它会引发一个异常。

20.2. try/except块

使用try/except块可以捕获并处理异常。try块包含可能引发异常的代码，而except块包含处理异常的代码。

try:  
    # 尝试执行的代码块  
    x = int('hello')  # 这会引发 ValueError  
except ValueError as e:  
    # 处理 ValueError 异常的代码块  
    print(f"An error occurred: {e}")

20.3. 多个except块

可以使用多个except块来捕获不同类型的异常。

try:  
    # 尝试执行的代码块  
    x = int('hello')  # 这会引发 ValueError  
    y = some_undefined_function()  # 这可能会引发 NameError  
except ValueError as e:  
    # 处理 ValueError 异常的代码块  
    print(f"Value error: {e}")  
except NameError as e:  
    # 处理 NameError 异常的代码块  
    print(f"Name error: {e}")  
except Exception as e:  
    # 处理其他所有异常的代码块  
    print(f"An unexpected error occurred: {e}")

20.4. else和finally块

else块与try/except一起使用时，它仅在try块中的代码成功执行而没有引发异常时运行。

try:  
    # 尝试执行的代码块  
    x = int('123')  
except ValueError:  
    # 处理异常  
    pass  
else:  
    # 如果没有异常发生，执行这里的代码  
    print("No error occurred")

finally块无论是否发生异常都会执行，常用于释放资源或执行清理操作。

try:  
    # 尝试执行的代码块  
    x = int('123')  
    # 其他操作...  
except ValueError:  
    # 处理异常  
    pass  
finally:  
    # 无论是否发生异常，都会执行这里的代码  
    print("This will always be printed")

20.5. 引发异常

使用raise语句可以显式地引发一个异常。

if some_condition:  
    raise ValueError("Some condition is not met")

20.6. 自定义异常

可以通过继承内置异常类来创建自定义异常。

class MyCustomException(Exception):  
    pass  
  
try:  
    raise MyCustomException("This is a custom exception")  
except MyCustomException as e:  
    print(f"Caught a custom exception: {e}")

20.7. 异常链

在Python 3中，可以在引发新异常时保留原始异常的上下文。这通过raise ... from ...语法实现。

try:  
    # 尝试执行的代码块  
    x = int('hello')  
except ValueError as e:  
    raise RuntimeError("A problem occurred") from e

在这个例子中，RuntimeError会包含ValueError的上下文信息。