python语言总结（持续更新）

本文主要是总结各函数，简单的函数不会给予示例，如果在平日遇到一些新类型将会添加

基础知识

输入与输出

print([要输出的内容])输出函数

input([提示内容]如果输入提示内容会在交互界面显示，用以提示用户)输入函数

注释

#

单行注释符，加在语句后面，或者单独为一行均不会被python程序解释

三引号（eg.''' """）

多行注释，这里与字符区分就是仅用三引号引起来，而不赋值，这就仅是一个注释

变量

变量就是一个名字，需要先定义（或者赋值）再使用。变量的命名要符合标识符的命名规范，标识符相当于名字，包括变量名/函数名/类名

标识符的命名规范：

可以由字母，数字（数字不能作为标识符的开头），下划线组成
区分大小写
不能使用关键字和保留字

关键字：if,while,for,as,import

保留字：input,print,range
没有长度限制
最好是能根据名字明白意思，eg.数字就用num或者number
大小写:

1. 包名：全小写，例如 time ;
2. 类名：每个单词的首字母大写，其他的小写，简称大驼峰命名，例如 HelloWorld ；
3. 变量名/函数名:第一个单词的首字母小写，后面的单词的首字母大写，简称小驼峰命名，例如 helloWorld ；
4. 常量：全大写，例如 HELLO 。

数据类型分类

整型：整数，int
浮点型：小数，float
复数：包含实数也包含虚数，complex(real[,imag]){这里的real是复数的实部，imag是复数的虚部}
字符串：字符，str 表现形式：‘xxx’，“xxx”，"""xxx""",'''xxx'''
布尔类型：bool，返回值分为Flase，Ture。1为真，0为假
None是一个单独的数据类型，标识空或者不存在的值。若将变量赋值为None，标识该变量没有实际的值

不存在的值：如果一个变量尚未赋值或其值是未知的，则将它设置为 None。

空集合：None 可以用于表示空集合、空列表或空字典。

函数返回值：当函数没有要返回的明确值时，可以使用 None 作为返回值。
列表，元组，字典，集合(这四个类型后续详讲）

类型转换（仅常见的）

字符串转数字

int（str）[转为整数]   /    float（str）[转为浮点数]

其中的str只可以由数字组成

浮点型与整型互换

浮点转整型

int(float)  直接去掉小数部分，保留整数部分

整型转浮点型

float（int）未表明精确度，默认为一位小数

数字转字符

str(int)[整型转字符]   /   str（float）[浮点转字符]

获取类型

type()函数

type(对象[可以先将对象赋值给一个变量再type；也可以直接将对象放在圆括号中])

type()函数返回的是对象的类型

>>> a=123
>>> type(a)
<class 'int'>

>>> type([1,23,4,5])
<class 'list'>

如果不是在交互型中的，仅仅只是一个type()不会有输出，所以我们需要print()配合嵌套使用，即print(type(对象))，或者将type（对象）赋值给一个变量再print（变量）

isinstance()函数

isinstance(对象,class)
 class是种类的意思

返回的值是布尔值，即这个函数是自己猜测类型，再用这个函数来确定类型是否正确（这个函数不常用）

运算符

一般运算符

+（加）， -（减）， *（乘）， /（除）

// （整除，去掉小数部分）， %（取模，或者说是取余），**（幂运算）

比较运算符

返回的是布尔值，即False和True

符号	意义
==	等于
！=	不等于
>	大于
<	小于
>=	大于等于
<=	小于等于

赋值运算符

=（简单的赋值符号，eg.a=c+v，就是将c+v的结果赋值给a）

<变量1>[算数运算符]=<变量2> eg.a+=5，这个等效于a=a+5。也就是算数运算的简写方法，不用重新再赋值，而是将算后的结果直接赋值给前面的变量

位运算符

运算符	意义/描述
&	按位与运算：参与运算的两个值,如果两个相应位都为1,则该位的结果为1,否则为0
\|	按位或运算符：只要对应的二个二进位有一个为1时，结果位就为1。
^	按位异或运算符：当两对应的二进位相异时，结果为1
~	按位取反运算符：将二进制表示中的每一位取反，0 变为 1，1 变为 0。~x 类似于 -x-1
>>	右移动运算符：把">>"左边的运算数的各二进位全部右移若干位，>> 右边的数字指定了移动的位数
<<	左移动运算符：运算数的各二进位全部左移若干位，由 << 右边的数字指定了移动的位数，高位丢弃，低位补0。

成员运算符

判断是不是在序列里

in(在) not in(不在)

身份运算符

判断二者的标识符是不是引用自同一个对象

is（是） is not（不是）

逻辑运算符

and 与两者同时为真才为真，一假为假

or 或两者任一为真就为真，全假为假

not 非非真，非假

注意运算先后

数字运算函数

abs(x) 绝对值函数，取x的绝对值

divmod(x,y) 商余函数。表示(x//y,x%y) 二元组形式输出，含括号

pow（x,y[,z]）如果仅有x和y就仅仅只是x**y，y是指数，如果有三个参数，就是x**y%z(模幂运算)

round(x[,d])计算保留函数。对x取舍，保留d位小数“四舍五入”，没有d就四舍五入为整数

max( , , , , )在一堆数中取最大的

min( , , , , )在一堆数中取最小的

字符串操作

len(x)返回字符串x的长度，或者组合数据类型的元素个数

str(x)任意类型x转字符类型

chr(x)返回Unicode编码对应的单字符

ord（x）返回单字符的Unicode编码

range的语法：

range(start,end,step=num)

start和end可以为空，start就是字符串开始，end就是字符串结尾，step可以为负数，为负就代表反向获取字符

如果是遍历字符串的话：

start和end可以是顺次的索引，也可以是逆向的索引，但是start所索引的字符的位置必须在end所索引的位置之前

for i in range(start,end,step):
<tab>[语句块]

step如果不设置就表示步长为1，直接依次遍历；如果有步长，就从start到end-1的字符串中提取步长为n的字符

流程控制

条件判断

顺次往下进行，不返回进行

if（单分支）

if [需要进行的条件判断，布尔表达式]：
<一个tab>[语句块]

当条件判断后为真，就进行语句块的执行

if else（双分支）

if [布尔表达式，条件判断]:
<tab>[语句块]
else:
<tab>[语句块]

if条件判断为真就进行if下面的语句块的执行，否则执行else的语句块

if elif else（多分支）

if [条件判断表达式]:
<tab>[语句块]
elif [条件判断表达式]:
<tab>[语句块]
.
.
.
elif [条件判断表达式]:
<tab>[语句块]
else:
<tab>[语句块]

当if语句为真，就执行其下方的语句块（后面的判断就不会经历），否则就往后进行条件判断，直到为真时停【一旦在if或各elif语句实现了判断为真就跳出这个结构，直接进行else的语句块以后的程序；如果前方的都不满足，就执行else的语句块】

条件判断的嵌套使用

s = int(input("请输入分数:"))
if 80 >= s >= 60:
    print("及格")
elif 80 < s <= 90:
    print("优秀")
elif 90 < s <= 100:
    print("非常优秀")
else:
    print("不及格")
    if s > 50:
        print("你的分数在60分左右")
    else:
        print("你的分数低于50分")

循环结构

for循环（遍历循环）

知道遍历次数，或者有需要遍历的对象进行提取其中的东西

range

遍历n次，i从0到n-1

for i in range(n)：
<tab>[语句块]

遍历字符串

for i in s:
<tab>[语句块]

逐一提取字符串s中的字符并赋给i

enumerate()
for index,char in enumerate(x):
<tab>[语句块]

利用enumerate函数遍历字符串x，并获取字符串x的每一个字符及其对应的索引

遍历列表

for item in ls:
<tab>[语句块]

遍历列表ls里的每一个元素

遍历文件f

for line in f:
<tab>[语句块]

逐一提取文件f的每一行

whlie循环（条件循环）

不知道需要循环的次数。条件循环是只要满足条件就一直循环下去，知道条件为False后才会结束

while [条件]：
<tab>[语句块]

循环控制

break

跳出最内层的循环，仅是跳出当前层的循环，外层循环将会继续

continue

结束当前当次的尚未执行的语句，但不跳出当前循环。

对于while循环：遇continue将返回，继续判断循环条件

对于for循环：遇continue将返回，程序继续遍历下一个元素

for s in "dasgfsasdgadgs":

if s=="s":

countinue

print(s,end='')

#dagfadgadg

for s in "dasgfsasdgadgs":

if s=="s":

break

print(s,end='')

#da

continue与break的区别

continue仅结束本次循环

break直接结束整个循环过程

字符串（str）

字符串的特点：

1. 字符串不可变类型
2. 字符串是可迭代对象
3. 字符串支持索引和切片操作
4. 支持操作符;

字符串的操作

       拼接：+   #字符串a与字符串b连接起来
        重复操作符：*   #将字符串重复
        比较运算符： > < <= >= == !=
        逻辑运算符：not and or
        成员关系： in    not in

字符串的处理

格式化输出

格式化输出有多种表达方式，且在日常经常会遇见吗，常用的方法有 format 和 $% 。

format

仅有{}占位，无下标的对应

顺序是前后对应的

a='python'
b='easy'
print("{} is {}".format(a,b))
#python is easy

用{}数字（小标）占位

以format内的顺序为下标来对应前面的数字，此处b的下标为1，a的下标为1，所以就得是b，a

a='python'
b='easy'
print("{1} is {0}".formate(b,a))
#输出：python is easy

用{}字母（标识符）占位

将需要加入的内容在format中写出，其标识符在输出字段里占位

print("{a} is {b}".format(a='python',b='easy'))
#python is easy

%s

常见的是参数可以为任意值

for i in range(1, 10):
    for j in range(1, i + 1):
        print("%s * %s = %s" % (i, j, i * j), end="\t")
    print()

转义字符

\n 换行

\\ 反斜杠

\'   单引号

\"   双引号

\t    制表符

列表(List)

列表是可以存放任何数据，包括整型，浮点型，字符串，布尔型等等，是常用的数据类型之一。

列表也是一个可迭代对象
1. 普通形式
        l = [1,2,3,4,5] ---整型列表
        l = ["a","b","c"] ---字符串列表
        l = [True,False,1>2,5<6]---布尔列表
2. 混合列表
        l = [1,2.5,"a",True]
3. 空列表
        l = []

创建列表

先定义一个空列表，再用函数加入元素

l=[]
l.append()

列表中含有元素直接创建

l=[1,23,43,'adf',True]

用list函数

l=list(一个组合类型的数据)

获取列表元素

for循环

l=['a',1,23,'sdf']
for i in l:
    print(i,end='')

#a123sdf

下标提取

这个的下标与字符串的相同

l=[12,23,354,56]
print(l[1])

#23

添加元素

交换元素的位置

l = [1, 2, 3, 4, 5] # 下标/索引：0开始
l[2], l[3] = l[3], l[2]
print(l)

改值

l[a:b]=['希望改后的结果s1'，‘希望改后的结果s2’.......]#这里的a，b是l列表的将被改动的区域的下标,如果后面的不满足前面的个数，遵循“多增少减”（也就是以后面的为准）

删除元素

列表元素重新排序

l.sort(reverse=False) 默认将列表从小到大排列

字典

字典用于储存数据，其中的数据以映射关系存储（key：value）

特点

1. 字典是Python中唯一的映射类型
2. 字典是无序的
3. 字典是可迭代对象
4. 字典的构成
    键：key
    值：value
    映射：键映射值
    键-值：键值对，又叫项

创建字典

直接创建

d={}
#d={}  空列表
#d = {"name":"不良人","apple":"苹果"}

dict()函数

d=dict()  得到空列表
d=dict(key1=value1,key2=value2...)  得到列表d{key1:value1,key2:value2...}

dict(可迭代对象)

将可以有对应关系的转为字典

d3 = dict([("one",1),("two",2)])
print(d3)
#{one:1,two:2}

字典的访问

<dict>['key']

变量名[键名] #输出键所对应的值

d = {"name":"不良人","apple":"苹果"}
print(d["name"])
#输出：不良人

字典的一些处理

1.添加一个键值对
变量名[键名]=值
2.修改一个键值对的值
变量名[已有的键名]=值

字典的for循环

1. 字典可以使用for循环

for i in d2:
print(i) #键，不包含值

2. 输出一个键值对

for i in d2.items():
print(i)

3. 成员关系操作符

in/not in

只能查询键

函数

`print(r.recvall())`

‌ 是使用 Python 的 requests 库发送网络请求时，用于接收服务器响应的全部内容。

这种在pwn的exp中可以运用到，用于连接服务器后将所有都输出

eval()函数

eval() 函数用来执行一个字符串表达式，并返回表达式的值。

字符串表达式可以包含变量、函数调用、运算符和其他 Python 语法元素。

语法：

eval(expression[, globals[, locals]])

expression -- 表达式。
globals -- 变量作用域，全局命名空间，如果被提供，则必须是一个字典对象。
locals -- 变量作用域，局部命名空间，如果被提供，可以是任何映射对象。

eval() 函数将字符串转换为相应的对象，并返回表达式的结果。

注意： eval() 函数执行的代码具有潜在的安全风险。如果使用不受信任的字符串作为表达式，则可能导致代码注入漏洞，因此，应谨慎使用 eval() 函数，并确保仅执行可信任的字符串表达式。

自定义函数

函数代码块以 def 关键词开头，后接函数标识符名称和圆括号()。
任何传入参数和自变量必须放在圆括号中间。圆括号之间可以用于定义参数。
函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
函数内容以冒号起始，并且缩进。
return [表达式] 结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回 None。

def sum(a,b):
    sum=a+b
    print(sum)
sum(3,5)
#输出8

自定义函数后的调用，就直接用自己定义的函数名就行了，比如上面的例子就是定义了一个函数sum用来求和；然后一个sum（3，5）实现了调用sum函数，并且将3传给形参a，5传给形参b

函数运行机制

1. 从函数调用开始执行
2. 通过函数名字找到函数定义的位置（创建函数的位置）
3. 执行函数体
4. 执行完毕之后，返回到函数的调用处

函数变量机制

分为两个变量：局部变量和全局变量

1. 局部变量
        定义在函数内部的变量
        先赋值在使用
        从定义开始到包含他的代码结束
        在外部无法访问
2. 全局变量
        1. 定义在源文件的开头
        2. 作用范围：整个文件
        3. 局部变量和全局变量发生命名冲突时，以局部变量优先

3.global：

        声明全局变量

4.nonlocal

        声明局部变量

这里的global需要理清楚

在函数中，可以访问全局变量，并使用其值。但是如果不对变量进行global宣言，则不会改变全局变量的值。

a=1
def sum(x):
    a=12
    print(x+a)
sum(3)
print(a)
#15
#1

如果需要在函数中改变全局变量的值，需要在函数中先定义global，用例如下。

a=1
def sum(x):
    global a
    a=12
    print(x+a)
sum(3)
print(a)
#15
#12

函数的参数：

形式参数：形参

在定义函数的时候传递的参数

实际参数：实参

在调用函数时传递的参数

无参

没有任何参数

地址参数

实参的位置与形参的位置一一对应，不能多也不可少这个例子中3和5既是实参，也是地址参数

默认参数：

给了默认值的参数--形

如果传递了新的值，那么默认值就被覆盖了

def sum(a=1,b=2):
    sum=a+b
    print(sum)
sum()
sum(10,5)
#3
#15

`if name == 'main':`

这个在本次开学考中有所遇见，但是当时不太懂，现在补一下

用于判断当前运行的脚本是否是主程序，而不是被其他脚本导入的模块。这是Python的一种约定俗成的用法，用于控制脚本的执行流程。这个条件判断确保了，只有当该脚本被直接运行时，紧随其后的代码块才会被执行。如果该文件被其他Python脚本通过import语句导入，那么这部分代码将不会执行。

通常是先用def（）函数实现了自定义函数，再通过该语句来判断是否为主函数（没有被导入其他脚本），如果是主函数就执行

def main():
    print("This is the main program.")

if __name__ == "__main__":
    main()

例如这个代码，只有当这个自定义的main函数没有被导入一个脚本时会被执行

百度安全验证

Python 运算符 | 菜鸟教程