zoukankan      html  css  js  c++  java
  • python《信息安全专业导论》期末考试知识点总结

      1 ###数据类型:1.数字类型(不可变):整型(int)、浮点型(float)、布尔型(bool)、复数类型(Complex)
      2 #               int*float=float、int/int=float、int*str=str(3*'a'='aaa')
      3 #           2.字符串(str)(包含在引号中的字符序列)(不可变)
      4 #           3.序列:列表(可变)(x=[a,b,c···])
      5 #                   元组(不可变)(x=(a,b,c···))
      6 #                   字典(可变)(x=[a:h,b:i,c:j···])
      7 #           4.集合(可变/不可变)         
      8 
      9 ###运算符(优先级从高到低):0.()
     10 #                        1.[表达式]:abs(求绝对值)
     11 #                                min(求最小值)
     12 #                                max(求最大值)
     13 #                                sqrt(开方)
     14 #                                len(求字符串长度或列表、元组、字典的元素个数)
     15 #                        2.x[i](索引运算符)(访问字符串x的第i个字母或列表、元组、字典x的第i个元素)
     16 #                            (i是索引:该字符相对于第一个字符的偏移量,第一个字符索引为0)
     17 #                        3.**(乘幂)
     18 #                        4.+x,-x(正号,负号)
     19 #                        5.*、/、//、%(乘法、除法、整除、取模/求余数)
     20 #                        6.+、-(加法、减法)
     21 #                        7.in、not in、<、<=、>、>=、!=、==(布尔运算符)
     22 #                        8.not x(布尔非)
     23 #                        9.and(布尔与)
     24 #                        10.or(布尔或)
     25 
     26 ###列表运算符(一定有返回值):in lst、not in lst、lst+lst、lst*(int)、lst[i]、len(lst)、min(lst)、max(lst)、sum(lst)
     27 #  列表方法(不一定有返回值):list.append(i)(把i添加到lst尾部)
     28 #  (print(无返回值的方法)会   lst.count(i)(返回i在lst中出现的次数)(有返回值)
     29 #   输出None)                       lst.index(i)(返回i在lst中第一次出现的索引号)(有返回值)
     30 #                          lst.insert(index,i)(在lst中索引index之前插入i))
     31 #                          lst.pop()(移除lst中的最后一项)
     32 #                          lst.remove(i)(移除lst中的第一个i)
     33 #                          lst.reverse()(将lst的项逆序排列)
     34 #                          lst.sort()(将lst排序)
     35 
     36 ###类型转换:int()、float()、str()
     37 
     38 ###调用python库:1.import x(调用x库)(使用y方法:x.y)
     39 #               2.from x import y(只调用x库的y方法)(使用y方法:y)
     40 #               3.from x import *(调用x库的所有方法和变量名)(使用y方法:y)
     41 
     42 ###输入与输出:print(i)(输出变量i的值)
     43 #             print(i,j,sep=';')(输出i,j,并用;间隔开)
     44 #             print(i,end='')(输出i,用空格结尾)
     45 #             print('a,{}:c,d:{},f'.format(b,e))(单引号之间是输出内容,大括号依次用format括号中的变量替换,
     46 #                   输出结果为a,b:c,d:e,f)(大括号中可以指定输出方式:{:3。2}为占三个宽度输出并保留两位小数,
     47 #                   {:f/d}是以浮点型/整型输出,{:b/c/d/o/x}是以二进制/字符串/十进制/八进制/十六进制输出)
     48 #             x=input("")(输入一个字符串并赋值给变量x)(引号中为提示语,可省略)
     49 #             x=eval(input())(输入一个字符串并将其转换成整型后赋值给变量x)(引号中为提示语,可省略)
     50 #             x=list(input().split)(将用空格隔开的元素依次储存在列表中)
     51 
     52 ###控制结构:if:1.if(判断条件):
     53 #                     缩进语句块
     54 #                 elif(判断条件):
     55 #                     缩进语句块
     56 #                 else:
     57 #                     缩进语句块
     58 #                 非缩进语句
     59 #判断条件之间应互斥,执行if语句时先判断,当一个条件为True时执行对应的缩进语句,所有条件判断都为False时执行else对应的缩进语句块
     60 
     61 ###循环结构:for···in···(遍历控制):1.for x in a(a为字符串、列表、元组、字典、集合):
     62 #                                       缩进语句块(循环次数为a中元素个数)
     63 #                                   非缩进语句
     64 #                                 2.for x in range(a,b,c):     (在a到b-1的范围中循环,c为步幅)
     65 #                                       缩进语句块
     66 #                                   非缩进语句 
     67 #           while(条件控制):while (判断条件):          (必须先初始化变量)
     68 #                              缩进语句块(当条件判断为True的时候执行)
     69 #                          非缩进语句
     70 #                          while True:              (循环无限次)
     71 #                              缩进语句块()
     72 #                          非缩进语句
     73 
     74 ###迭代控制语句:1.break(执行break语句时,停止当前循环迭代,退出循环,继续执行紧跟在循环语句后面的语句,如果中断语句
     75 #                       在嵌套循环模式的循环体代码中,则只中断包含break语句的最内层循环)
     76 #               2.continue(终止当前最内层的循环迭代,与break语句不同的是,执行continue语句后继续执行当前最内层
     77 #                       循环的下一次迭代)
     78 #简单来说就是break停止整个循环,continue停止这一次迭代
     79 
     80 ###定义函数:def x(a,b···):             (定义一个函数x,带有若干参数a,b···)
     81 #               缩进语句块(将变化后的结果赋值给变量y)
     82 #               ruturn y               (将变量y返回)
     83 #调用函数:z=x(a,b···)(最终会把变量y的值赋给变量z)
     84 
     85 ###字符串切割:s[i:j](是字符串s从i到j-1结束的子字符串)(i=0时可省略i变为s[:j],j为最后一位时可省略j变为s[i:])
     86 #             s[-i:-j](是字符串s从-i到-(j-1)结束的子字符串)(正向i从0开始,逆向i从1开始)
     87 #
     88 
     89 ###字符串方法:a.find(i)(检查i是否是a的子字符串,如果是,返回字符串a中第一次出现i的位置,否则返回-1)
     90 #             a.count(i)(返回i作为子字符串在a中出现的次数)
     91 #             a.replace(i,j)(返回一个副本,其中所有的子字符串i被替换为j,不改变a)
     92 #             a.split(i j)(切开所有空格,将所得结果储存在列表中,并返回该列表)
     93 
     94 ###打开文件:a=open('x.txt','r')(打开名为x的文件并将其赋值给变量a)(读取模式)
     95 #           a=open('x.txt','w')(打开名为x的文件并将其赋值给变量a)(写入模式,如果文件已存在,则清除原内容)
     96 #           a=open('x.txt','a')(打开名为x的文件并将其赋值给变量a)(附加模式,将数据内容附加写入到文件末尾)
     97 #           a=open('x.txt','r')(打开名为x的文件并将其赋值给变量a)(b)(二进制模式)
     98 
     99 ###文件对象方法:a.read(n)(从a中读取n个字符或直到文件末尾,并把读取的字符作为一个字符串返回)
    100 #               a.read()(从a中读取全部字符,并把读取的字符作为一个字符串返回)
    101 #               a.readline()(从a中读取一行数据,直到包括换行符或直到文件末尾,并把读取的字符作为一个字符串返回)
    102 #               a.write(s)(把字符串s写入到a中)
    103 #               a.close()(关闭文件)
    104 
    105 ###字典:(可变类型)也叫映射,包含一系列键值对,用:隔开。比如x={a:b,c:d,e:b},索引键时会输出对应的值,比如x[a]=b,x[e]=
    106 #        (键和值都为字符串或已初始化的变量)
    107 
    108 ###字典运算符:与列表运算符基本相同,不能使用+和*,由于字典没有顺序,也不能使用索引运算符。
    109 
    110 ###字典方法:假设字典x{a:b,c:d,e:a}
    111 #           x.pop(a/c/e)(移除字典x的某个键)
    112 #           y.update(x)(将字典x的键值对添加到字典y中)(键相同时x中的键值对会覆盖掉y中的键值对)
    113 #           x.keys()(返回字典x的所有键)
    114 #           x.values()(返回字典x的所有值)
    115 #           x.items()(返回字典x的所有键值对)
    116 
    117 ###集合:(不可变类型)用大括号定义,x={a,b,c}具有数学集合的全部特征,不允许重复项
    118 
    119 ###集合方法:x.add(a)(把a添加到集合x中)
    120 #           x.remove(a)(把a从集合x中删除)
    121 #           x.clear(清空集合)
    122 
    123 #随机方法:(调用random库)random.shuffle(x)(把列表x混排一次)
    124 #                       y=random.choice(x)(从列表x中随机选择一项赋值给y)
    125 #                       y=random.sample(x,n)(从列表x中随机选择n项组成列表并赋值给y)
    126 
    127 ###名称空间:每个函数都有自己的一个名称空间,在主函数中定义的变量(全局变量)与在自定义函数中定义的同名变量(局部变量)互不干扰。
    128 #           在自定义函数中使用全局变量时首先应该通过global x来声明变量x使用全局变量
    129 
    130 ###递归:递归函数是调用自身的函数。包含1.一个或多个基本情况,为递归提供停止条件。
    131 #                                   2.一个或多个递归调用,相对与输入参数,其输出参数必须更接近基本情况。
    132 
    133 ###几个实例
    134 #斐波那契数列
    135 def fib(n):#累加器
    136     previous=1
    137     current=1
    138     i=1
    139     while i<n:
    140         previous,current=current,previous+current
    141         i+=1
    142     return current
    143 def rfib(n):#递归
    144     if n<2:
    145         return 1
    146     return rfib(n-1)+rfib(n-2)
    147 #二分查找
    148 from collections import deque
    149 def binary(x, y):#定义一个函数,带两个输入参数x,y。x为待检索列表,y为要检索的对象
    150     first = 0#将first初始化为0
    151 
    152     last = len(x)#将列表的长度赋值给last
    153     x.sort()#将列表排序
    154     for j in range(last):#迭代last次
    155         i = (first+last)//2#取first和last的平均值
    156         a = x[i]#把x的第i项赋值给a
    157         if(y > a):#将y与a比较,如果y>a
    158             first = i#把first赋值给i,舍弃i前的列表
    159         elif(y < a):#将y与a比较,如果y<a
    160             last = i #把last赋值给i,舍弃i后的列表
    161         elif(y == a):#如果y=a
    162             return True#返回真,即存在
    163     return False#如果迭代结束后仍未搜索到,返回假
    164 #快速排序
    165 def quicksort(s):#定义函数
    166     if len(s) < 2:
    167         return s#如果列表小于2,不用排序
    168     p = s[0]#选一个基准值
    169     l = []#小于基准值的列表
    170     e = []#等于基准值的列表
    171     r = []#大于基准值的列表
    172     while len(s) > 0:#当列表不为空时
    173         if s[-1] < p:#如果列表最后一项小于基准值
    174             l.append(s.pop())#把列表最后一项加入l中并将其从列表中删除
    175         elif s[-1] == p:   #如果列表最后一项等于基准值
    176             e.append(s.pop())  # 把列表最后一项加入e中并将其从列表中删除
    177         else:  # 如果列表最后一项大于基准值
    178             r.append(s.pop())  # 把列表最后一项加入r中并将其从列表中删除
    179     quicksort(l)#递归l
    180     quicksort(r)#递归r
    181     s.extend(l)
    182     s.extend(e)
    183     s.extend(r)#经过上述变化后s是空列表,将l,e,r依次加入到s中
    184     return s  #返回s
    185 
    186 #广度优先搜索
    187 #题目:假设你经营着一个芒果农场,需要寻找芒果销售商,以便将芒果卖给他,你的人际关系如图,已知名字最后一位字母是m的是芒果
    188 #       销售商,请找到和你关系最近的芒果销售商
    189 graph = {}
    190 graph["you"] = ["alice", "bob", "claire"]
    191 graph["bob"] = ["anuj", "peggy"]
    192 graph["alice"] = ["peggy"]
    193 graph["claire"] = ["thom", "jonny"]
    194 graph["anuj"] = {}
    195 graph["peggy"] = {}
    196 graph["thom"] = {}
    197 graph["jonny"] = {}#以上部分为用字典构建图
    198 
    199 def person_is_seller(name):
    200     return name[-1] == 'm'#只有最后一行字母是m才返回
    201 
    202 def search(name):#定义一个搜索函数
    203     search_queue = deque()#创建一个队列
    204     search_queue += graph[name]#把初始节点的子节点加入队列
    205     searched = []#定义一个已搜索列表
    206     while search_queue:#当队列不为空时一直循环
    207         person = search_queue.popleft()#将队列最左边的元素赋值给person并将其从队列中删除
    208         if person not in searched:#如果person未被检索
    209             if person_is_seller(person):#如果person满足条件
    210                 print(person, "is a mango seller!")#输出
    211                 return True#返回真
    212             else:#如果person不满足条件
    213                 search_queue += graph[person]#将person的子节点加入队列
    214                 searched.append(person)#将person标记为已检索
    215     return False#如果直到循环结束都没有返回真就返回假,即未搜索到
    216 search("you")#运行搜索函数
    217 
    218 #深度优先搜索
    219 graph = {}
    220 graph["you"] = ["alice", "bob", "claire"]
    221 graph["bob"] = ["anuj", "peggy"]
    222 graph["alice"] = ["peggy"]
    223 graph["claire"] = ["thom", "jonny"]
    224 graph["anuj"] = {}
    225 graph["peggy"] = {}
    226 graph["thom"] = {}
    227 graph["jonny"] = {}  # 以上部分为用字典构建图
    228 
    229 def person_is_seller(name):
    230     return name[-1] == 'm'  # 只有最后一行字母是m才返回
    231 
    232 
    233 def search(name):  # 定义一个搜索函数
    234     search_queue = [name]#用列表来模拟栈
    235     search_queue += graph[name]  # 把初始节点的子节点加入列表
    236     searched = []  # 定义一个已搜索列表
    237     while search_queue:  # 当列表不为空时一直循环
    238         person = search_queue[-1]#把列表最后一项赋值给person
    239         search_queue.pop()#把列表最后一项删除
    240         if person not in searched:  # 如果person未被检索
    241             if person_is_seller(person):  # 如果person满足条件
    242                 print(person, "is a mango seller!")#输出
    243                 return True#返回真
    244             else:  # 如果person不满足条件
    245                 search_queue += graph[person]  # 将person的子节点加入列表
    246                 searched.append(person)  # 将person标记为已检索
    247         else:#如果person已检索
    248             search_queue.pop()  # 把列表最后一项删除
    249     return False  # 如果直到循环结束都没有返回真就返回假,即未搜索到
    250 search("you")#运行搜索函数
  • 相关阅读:
    Javascript绝句欣赏
    JAVA应用程序单独集成Mybatis使用Demo
    [转]文件上传原理:Web上传文件的原理及实现
    聚类算法之DBScan(Java实现)[转]
    [转]常见hash算法的原理
    [转]谈工程师的价值和发展
    [转]阿里巴巴离职DBA职业生涯总结
    [转]RandomAccessFile
    使用Cxf发布Webservice服务,如果待发布的接口中有重载方法,怎么处理??[转]
    execute、executeUpdate、executeQuery三者的区别
  • 原文地址:https://www.cnblogs.com/20201212ycy/p/14232095.html
Copyright © 2011-2022 走看看