python3语法

fooooooooreword：This is my **very first **post. After having my own blog, I am not willing to delete this article, just keep it as a memorial.

00.前言

我连python都傻傻不懂，真是太弱小了，没有力量~

本篇主要是关于python3的语法。

01.python的标识符规则

命名数字字母下划线，不以数字开头；

大小写敏感；

缩进严格；

变量名不能是关键字：

[‘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’]

02.python的数据类型

1.数字有四种类型：整数、布尔型、浮点数和复数。

• int (整数), 如 1, 只有一种整数类型 int，表示为长整型，没有 python2 中的 Long。
• bool (布尔), 如 True。
• float (浮点数), 如 1.23、3E-2
• complex (复数) - 复数由实部和虚部组成，形式为 a + bj，其中 a 是实部，b 是虚部，j 表示虚数单位。如 1 + 2j、 1.1 + 2.2j

Python Number 类型转换

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 转换为一个列表  
chr(x )                 将一个整数转换为一个字符  
unichr(x )              将一个整数转换为Unicode字符  
ord(x )                 将一个字符转换为它的整数值  
hex(x )                 将一个整数转换为一个十六进制字符串  
oct(x )                 将一个整数转换为一个八进制字符串

Python数学函数

函数	返回值 ( 描述 )
abs(x)	返回数字的绝对值，如abs(-10) 返回 10
ceil(x)	返回数字的上入整数，如math.ceil(4.1) 返回 5
cmp(x, y)	如果 x < y 返回 -1, 如果 x == y 返回 0, 如果 x > y 返回 1
exp(x)	返回e的x次幂(ex),如math.exp(1) 返回2.718281828459045
fabs(x)	以浮点数形式返回数字的绝对值，如math.fabs(-10) 返回10.0
floor(x)	返回数字的下舍整数，如math.floor(4.9)返回 4
log(x)	如math.log(math.e)返回1.0,math.log(100,10)返回2.0
log10(x)	返回以10为基数的x的对数，如math.log10(100)返回 2.0
max(x1, x2,…)	返回给定参数的最大值，参数可以为序列。
min(x1, x2,…)	返回给定参数的最小值，参数可以为序列。
modf(x)	返回x的整数部分与小数部分，两部分的数值符号与x相同，整数部分以浮点型表示。
pow(x, y)	x**y 运算后的值。
round(x [,n])	返回浮点数x的四舍五入值，如给出n值，则代表舍入到小数点后的位数。
sqrt(x)	返回数字x的平方根

Python随机数函数

随机数可以用于数学，游戏，安全等领域中，还经常被嵌入到算法中，用以提高算法效率，并提高程序的安全性。

Python包含以下常用随机数函数：

函数	描述
choice(seq)	从序列的元素中随机挑选一个元素，比如random.choice(range(10))，从0到9中随机挑选一个整数。
randrange ([start,] stop [,step])	从指定范围内，按指定基数递增的集合中获取一个随机数，基数默认值为 1
random()	随机生成下一个实数，它在[0,1)范围内。
seed([x])	改变随机数生成器的种子seed。如果你不了解其原理，你不必特别去设定seed，Python会帮你选择seed。
shuffle(lst)	将序列的所有元素随机排序
uniform(x, y)	随机生成下一个实数，它在[x,y]范围内。

2.字符串(String)

• Python 中==单引号 ‘ 和双引号 “ 使用完全相同==。

• 使用三引号(‘’’ 或 “””)可以指定一个多行字符串。

• ==反斜杠可以用来转义==，使用 r 可以让反斜杠不发生转义。 如 r”this is a line with \n” 则 \n 会显示，并不是换行。

• 按字面意义级联字符串，如 “this “ “is “ “string” 会被自动转换为 this is string。

• 字符串可以用 + 运算符连接在一起，用 ***** 运算符重复。

• Python 中的字符串有两种索引方式，从左往右以 0 开始，从右往左以 -1 开始。

• Python 中的字符串不能改变。

• Python 没有单独的字符类型，一个字符就是长度为 1 的字符串。

• 字符串切片 str[start:end]，其中 start（包含）是切片开始的索引，end（不包含）是切片结束的索引。（==左闭右开！==）

• 字符串的切片可以加上步长参数 step，语法格式如下：

  str[start:end:step]

str='123456789'
 
print(str)                 # 输出字符串
print(str[0:-1])           # 输出第一个到倒数第二个的所有字符
print(str[0])              # 输出字符串第一个字符
print(str[2:5])            # 输出从第三个开始到第六个的字符（不包含）
print(str[2:])             # 输出从第三个开始后的所有字符
print(str[1:5:2])          # 输出从第二个开始到第五个且每隔一个的字符（步长为2）
print(str * 2)             # 输出字符串两次
print(str + '你好')         # 连接字符串
 
print('------------------------------')
 
print('hello\nrunoob')      # 使用反斜杠(\)+n转义特殊字符
print(r'hello\nrunoob')     # 在字符串前面添加一个 r，表示原始字符串，不会发生转义

123456789
12345678
1
345
3456789
24
123456789123456789
123456789你好
------------------------------
hello
runoob
hello\nrunoob

03.python的切片操作

在 Python 里，==切片操作能够提取序列（像字符串、列表、元组等）中的一部分元素==。切片的基本语法是 [start:stop:step]，其中 start 是起始索引，stop 是结束索引（不包含该索引对应的元素），step 是步长。==这三个参数都可省略==，下面详细介绍并举例说明：

省略 start

若省略 start，切片会从序列的起始位置开始。

# 字符串切片示例
s = "abcdef"
print(s[:3])  # 输出: "abc"

# 列表切片示例
lst = [1, 2, 3, 4, 5]
print(lst[:2])  # 输出: [1, 2]

# 元组切片示例
tup = (10, 20, 30, 40, 50)
print(tup[:4])  # 输出: (10, 20, 30, 40)

省略 stop

若省略 stop，切片会一直取到序列的末尾。

# 字符串切片示例
s = "abcdef"
print(s[2:])  # 输出: "cdef"

# 列表切片示例
lst = [1, 2, 3, 4, 5]
print(lst[3:])  # 输出: [4, 5]

# 元组切片示例
tup = (10, 20, 30, 40, 50)
print(tup[1:])  # 输出: (20, 30, 40, 50)

省略 step

若省略 step，默认步长为 1。

# 字符串切片示例
s = "abcdef"
print(s[1:4])  # 输出: "bcd"

# 列表切片示例
lst = [1, 2, 3, 4, 5]
print(lst[0:3])  # 输出: [1, 2, 3]

# 元组切片示例
tup = (10, 20, 30, 40, 50)
print(tup[2:5])  # 输出: (30, 40, 50)

同时省略多个参数

• 省略 start 和 stop：会获取整个序列，此时可指定步长。

# 字符串切片示例
s = "abcdef"
print(s[::2])  # 输出: "ace"

# 列表切片示例
lst = [1, 2, 3, 4, 5]
print(lst[::3])  # 输出: [1, 4]

# 元组切片示例
tup = (10, 20, 30, 40, 50)
print(tup[::2])  # 输出: (10, 30, 50)

• 省略 start、stop 和 step：会获取整个序列，步长默认为 1，相当于复制序列。

# 字符串切片示例
s = "abcdef"
print(s[:])  # 输出: "abcdef"

# 列表切片示例
lst = [1, 2, 3, 4, 5]
print(lst[:])  # 输出: [1, 2, 3, 4, 5]

# 元组切片示例
tup = (10, 20, 30, 40, 50)
print(tup[:])  # 输出: (10, 20, 30, 40, 50)

使用负数作为参数

切片操作中，还能使用负数作为 start、stop 和 step 参数。负数索引从序列末尾开始计数，-1 表示最后一个元素，-2 表示倒数第二个元素，依此类推。

# 字符串切片示例
s = "abcdef"
print(s[-3:])  # 输出: "def"
print(s[:-2])  # 输出: "abcd"
print(s[::-1])  # 输出: "fedcba"

# 列表切片示例
lst = [1, 2, 3, 4, 5]
print(lst[-2:])  # 输出: [4, 5]
print(lst[:-3])  # 输出: [1, 2]
print(lst[::-2])  # 输出: [5, 3, 1]

# 元组切片示例
tup = (10, 20, 30, 40, 50)
print(tup[-3:])  # 输出: (30, 40, 50)
print(tup[:-1])  # 输出: (10, 20, 30, 40)
print(tup[::-1])  # 输出: (50, 40, 30, 20, 10)

切片操作中的 start、stop 和 step 参数都可省略

04.python的运算符

以下假设变量： a=10，b=20：

运算符	描述	实例
/	除 - x除以y	b / a 输出结果 2
%	取模 - 返回除法的余数	b % a 输出结果 0
**	幂 - 返回x的y次幂	a**b 为10的20次方， 输出结果 100000000000000000000
//	取整除 - 返回商的整数部分（向下取整）	>>> 9//2 4 >>> -9//2 -5

比较运算符与c相同。

05.python的判断，循环

1.判断：

与c基本相同，注意没有大括号，取而代之是冒号。

2.for循环：

（1）遍历可迭代对象

基本格式：

for 变量 in 可迭代对象:
    代码语句

如：

fruits = ["apple", "banana", "cherry"]
for fruit in fruits:
    print(fruit)

fruits是一个列表，属于可迭代对象。fruit是循环变量，在每次循环时，fruit会依次被赋值为列表里的元素，然后执行循环体中的代码，也就是打印出当前元素。

（2）使用range()函数

基本格式：

for 变量 in range(起始值, 结束值, 步长):
    # 循环体，执行的代码块
    代码语句

起始值是可选的，默认值为 0；==结束值是必需的==，循环会在达到该值之前停止；步长也是可选的，默认值为 1。也是左闭右开

如：

for i in range(0, 5, 1):
    print(i)

在这个示例中，range(0, 5, 1)会生成一个从 0 到 4 的整数序列，i是循环变量，每次循环时i会依次被赋值为序列中的元素，接着执行循环体中的代码，即打印出当前元素。

3.while循环：

（1）遍历可迭代对象

基本格式：

while 条件:
    代码语句

如：

while i <= 5:
    sum_num += i
    i += 1
print(sum_num)

while True:
    print("这是一个无限循环！")

4.循环时并列使用 else 语句：

for 和 while 循环都可以和 else 语句并列使用，这和正常写语句是有区别的。

numbers = [1, 2, 3, 4, 5]
for num in numbers:
    print(num)

# 正常写的语句
print("循环结束后执行此语句")

在这个例子中，不管 for 循环是正常遍历完列表结束，还是在遍历过程中使用 break 提前终止，print("循环结束后执行此语句") 都会执行。

for 循环与 else 语句示例

numbers = [1, 2, 3, 4, 5]
for num in numbers:
    if num == 3:
        break
    print(num)
else:
    print("循环正常结束")

在这个例子中，当 num 等于 3 时，会执行 break 语句，提前终止循环。此时，else 语句块中的 print("循环正常结束") 不会执行。

如果将 break 语句去掉，循环会正常结束，else 语句块中的代码就会执行：

numbers = [1, 2, 3, 4, 5]
for num in numbers:
    print(num)
else:
    print("循环正常结束")

即：else 语句块中的代码在有break提前终止时不执行。

5.循环控制：

break：跳出整个循环。

continue：提前结束，进入下一个循环。

pass：就是回车占位。

跟c一样。

06.python自定义函数

1.定义一般函数

以下是简单的规则：（其实跟c一样，就是define改def，大括号改成 :）

• 函数代码块以 def 关键词开头，后接函数标识符名称和圆括号**()**。

• 任何传入参数和自变量必须放在圆括号中间。圆括号之间可以用于定义参数。

• 函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。

• 函数内容以冒号起始，并且缩进。

• return [表达式] 结束函数，选择性地返回一个值给调用方（通常会是一个字节串，如payload）。不带表达式的return相当于返回 None。

  在ret2csu的时候蛮常用的。

  newstar的MY_GBC!!!片段：

def csu1(rbx, rbp, r12, r13, r14, r15):
    payload = p64(0x4013AA)
    payload += p64(rbx)
    payload += p64(rbp)
    payload += p64(r12)
    payload += p64(r13)  # rsi
    payload += p64(r14)  # rdx
    payload += p64(r15)
    return payload
def csu(rbx, rbp, r12, r13, r14, r15):
    payload = csu1(rbx, rbp, r12, r13, r14, r15)
    payload += p64(0x401390)
    return payload

2.定义匿名函数

python 使用 lambda 来创建匿名函数。格式：自定义函数名=lambda 参数 : 表达式。

• lambda只是一个表达式，而不是一个代码块，函数体比def简单很多。仅仅能在lambda表达式中封装有限的逻辑进去。
• lambda函数拥有自己的命名空间，且==不能访问自有参数列表之外或全局命名空间里的参数==。
• lambda函数只能写一行，为了调用小函数时不占用栈内存从而增加运行效率。

在写exp前可以提前定义如recv等常用函数。

sla = lambda delim, data: p.sendlineafter(delim, data)

sa = lambda delim, data: p.sendafter(delim, data)

s = lambda data: p.send(data)

sl = lambda data: p.sendline(data)

ru = lambda delim, **kwargs: p.recvuntil(delim, **kwargs)

io = lambda: p.interactive()

log = lambda name, data: success(f'{name}: {data:#x}')

99.python杂项

print 输出

print 默认输出是换行的，如果要实现不换行需要在变量末尾加上 end=” ”：

#!/usr/bin/python3   <==============这玩意是用来指定执行该脚本的解释器路径的
 
x="a"
y="b"
# 换行输出
print( x )
print( y )
 
print('---------')
# 不换行输出
print( x, end=" " )
print( y, end=" " )
print()

以上实例执行结果为：

a
b
---------
a b