Python 基础 下

Posted

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了Python 基础 下相关的知识,希望对你有一定的参考价值。

  str()的方法
  字符串练习

  1.str.capitalize
  str.capitalize #返回首字母大写,其他字母小写的字符串
  >>> a = ‘gwdsr‘
  >>> a.capitalize()
  ‘gwdsr‘
  >>>
  2.str.casefold
  str.casefold #字符串转换成小写,用于不区分大小写的字符串比较

  >>> a = ‘gwdsr‘
  >>> b = a.capitalize()
  >>> b
  ‘gwdsr‘
  >>> b.casefold()
  ‘gwdsr‘
  3.str.center
  str.center #返回指定长度的字符串,字符串内容居中,并使用指定字符填充

  >>> b.center(40,‘-‘)
  ‘-----------------gwdsr------------------‘
  4.str.count
  str.count #返回子字符串在字符串中出现的次数
  >>> b.count(‘a‘)
  0
  >>> b.count(‘e‘)
  2
  >>> b
  ‘gwdsr‘
  5.str.encode
  str.encode #对字符串进行编码,返回字节对象
  >>> b.encode(‘gbk‘)
  b‘gwdsr‘
  6.str.endswith
  str.endswith #判断字符串是否以指定的后缀结尾
  >>> b
  ‘gwdsr‘
  >>> b.endswith(‘r‘)
  True
  >>> b.endswith(‘d‘)
  False
  7.str.expandtabs
  str.expandtabs #使用空格替换tab

  >>> str.expandtabs(‘hello\tworld‘)
  ‘hello world‘
  8.str.find
  str.find #返回子字符串在字符串中第一次出现的位置;如没找到,返回-1
  >>> c.find(‘wo‘)
  8
  >>> c
  ‘hello world‘
  9.str.format
  str.format #执行字符串格式化操作,替换字段使用{}分隔,替换字段可以是表
  >>> str.format(‘hello {}‘,‘world‘)
  ‘hello world‘
  10.str.format_map
  str.format_map #执行字符串格式化操作,替换字段使用{}分隔,同str.for
  11.str.index
  str.index #同find(),但如果在字符串中没找到子字符串,会抛出错误
  >>> a = ‘gwdsr‘
  >>> a.index(‘e‘)
  1
  >>> a.index(‘a‘)
  Traceback (most recent call last):
  File "<input>", line 1, in <module>
  ValueError: substring not found
  12.str.isalnum
  12.str.isalnum #判断字符串中是否至少有一个字符,并且所有字符都是字母或数字
  In [202]: a = ‘asf23234d‘

  In [203]: a.isalnum()
  Out[203]: True

  In [204]: b = ‘asf‘

  In [205]: b.isalnum()
  Out[205]: True

  In [206]: c = ‘a*sf32‘

  In [207]: c.isalnum()
  Out[207]: False

  In [208]: d = ‘‘

  In [209]: d.isalnum()
  Out[209]: False
  13.str.isalpha
  13.str.isalpha #判断字符串中是否至少有一个字符,并且所有字符都是字母
  In [194]: a
  Out[194]: ‘123‘

  In [195]: a.isa
  a.isalnum a.isalpha

  In [195]: a.isalpha()
  Out[195]: False

  In [196]: b
  Out[196]: ‘1a‘

  In [197]: b.isa
  b.isalnum b.isalpha

  In [197]: b.isalpha()
  Out[197]: False

  In [198]: c
  Out[198]: ‘‘

  In [199]: c.isalpha()
  Out[199]: False

  In [200]: d = ‘adsf‘

  In [201]: d.isalpha()
  Out[201]: True
  14.str.isdecimal
  14.str.isdecimal #判断字符串中是否至少有一个字符,并且所有字符都是十进制数字
  In [183]: a = ‘123‘

  In [184]: b = ‘1a‘

  In [185]: c = ‘‘

  In [189]: e = ‘1.3‘

  In [190]: a.isdecimal()
  Out[190]: True

  In [191]: b.isdecimal()
  Out[191]: False

  In [192]: c.isdecimal()
  Out[192]: False

  In [193]: e.isdecimal()
  Out[193]: False
  15.str.isdigit
  15.str.isdigit #判断字符串中是否至少有一个字符,并且所有字符都是数字
  In [183]: a = ‘123‘

  In [184]: b = ‘1a‘

  In [185]: c = ‘‘

  In [186]: a.isdigit()
  Out[186]: True

  In [187]: b.isdigit()
  Out[187]: False

  In [188]: c.isdigit()
  Out[188]: False
  16.str.isidentifier
  16.str.isidentifier #判断字符串中是否是有效标识符
  In [172]: a
  Out[172]: ‘gwdsr‘

  In [173]: b
  Out[173]: ‘ASDF‘

  In [174]: a
  Out[174]: ‘gwdsr‘

  In [175]: b = ‘12‘

  In [176]: c = ‘‘

  In [178]: d = ‘*‘

  In [179]: a.isidentifier()
  Out[179]: True

  In [180]: b.isidentifier()
  Out[180]: False

  In [181]: c.isidentifier()
  Out[181]: False

  In [182]: b.isidentifier()
  Out[182]: False
  17.str.islower
  17.str.islower #判断字符串中是否小字并且至少有一个字符
  In [166]: a = ‘gwdsr‘

  In [167]: b = ‘ASDF‘

  In [168]: c = ‘‘

  In [169]: a.islower()
  Out[169]: True

  In [170]: b.islower()
  Out[170]: False

  In [171]: c.islower()
  Out[171]: False
  18.str.isnumeric
  18.str.isnumeric #判断字符串中是否至少有一个字符,并且所有字符都是数字字符
  In [159]: a = ‘124‘

  In [160]: b = ‘as234‘

  In [161]: c = ‘‘

  In [162]: a.isnumeric()
  Out[162]: True

  In [163]: b.isnumeric()
  Out[163]: False

  In [164]: c.isnumeric()
  Out[164]: False
  19.str.isprintable
  19.str.isprintable #判断字符串的所有字符都是可打印字符或字符串为空
  In [151]: a = "\tPuppy"

  In [152]: b = "PUPPY\a"

  In [153]: c = "puppy"

  In [154]: d = "a puppy\b"

  In [155]: a.isprintable()
  Out[155]: False

  In [156]: b.isprintable()
  Out[156]: False

  In [157]: c.isprintable()
  Out[157]: True

  In [158]: d.isprintable()
  Out[158]: False
  20.str.isspace
  20.str.isspace #判断字符串中是否至少有一个字符,并且所有字符都是空白字符
  In [144]: t2
  Out[144]: ‘‘

  In [145]: t2.isspace()
  Out[145]: False

  In [146]: t3 = ‘ ‘

  In [147]: t3.isspace()
  Out[147]: True


  In [149]: t
  Out[149]: ‘gwdsr is a student‘

  In [150]: t.isspace()
  Out[150]: False
  21.str.istitle
  21.str.istitle #判断字符串中是否至少有一个字符,并且所有字符都是titlecase字符
  In [135]: t = ‘gwdsr is a student‘

  In [137]: t1 = t.title()

  In [138]: t.istitle()
  Out[138]: False

  In [139]: t1.istitle()
  Out[139]: True

  In [142]: t2 = ‘‘

  In [143]: t2.istitle()
  Out[143]: False
  22.str.isupper
  22.str.isupper #判断字符串中是否全部是大写字母,空字符串为false
  In [124]: a = ‘gwdsr‘

  In [125]: a.isupper()
  Out[125]: False

  In [126]: a = ‘gwdsR‘

  In [127]: a.isupper()
  Out[127]: True

  In [128]: b = ‘‘

  In [129]: b.isupper()
  Out[129]: False
  23.str.join
  23.str.join #使用字符串作为分隔符串连多个数据为一个字符串
  In [116]: a
  Out[116]: ‘gwdsr‘

  In [117]: e = [‘a‘,‘b‘,‘c‘,‘d‘]

  In [118]: ‘‘.join(e)
  Out[118]: ‘abcd‘

  In [119]: ‘*‘.join(e)
  Out[119]: ‘a*b*c*d‘

  In [120]: ‘*‘.join(a)
  Out[120]: ‘p*e*t*e*r‘

  In [121]: ‘‘.join(a)
  Out[121]: ‘gwdsr‘
  ### 24.str.ljust

  24.str.ljust #返回指定长度的字符串,字符串内容居左,并使用指定字符填充
  In [88]: a.ljust(10,‘-‘)
  Out[88]: ‘gwdsr-----‘

  In [89]: a.ljust(1,‘-‘)
  Out[89]: ‘gwdsr‘

  In [90]: a.ljust(6,‘0‘)
  Out[90]: ‘gwdsr0‘
  ### 25.str.lower

  25.str.lower #字符串转换成小写
  In [81]: a = ‘gwdsr‘

  In [82]: a.upper()
  Out[82]: ‘gwdsR‘

  In [83]: b = a.upper()

  In [84]: b
  Out[84]: ‘gwdsR‘

  In [85]: b.lower()
  Out[85]: ‘gwdsr‘
  26.str.lstrip
  26.str.lstrip #去掉字符串前面的空格,或参数中的字符
  27. str.translate / str.maketrans
  str.translate #根据table表的映射关系,将字符串中的每个字符转换成另一个#返回一个转换表
  In [32]: m = str.maketrans(‘e‘,‘b‘)

  In [33]: a.translate(m)
  Out[33]: ‘pbtbr‘
  28.str.partition
  28.str.partition #返回包含字符串中分隔符之前、分隔符、分隔符之后的子字符串的tuple
  #指定的分隔符,则返回一个3元的元组,第一个为分隔符左边的子串,第二个为分隔符本身,第三个为分隔符右边的子串
  In [77]: g = ‘www.google.com‘
  In [79]: g.partition(‘.‘)
  Out[79]: (‘www‘, ‘.‘, ‘google.com‘)

  In [80]: g.partition(‘g‘)
  Out[80]: (‘www.‘, ‘g‘, ‘oogle.com‘)
  29.str.replace
  29.str.replace #替换字符串中所有的子字符串old为新的字符串new
  >>> a.replace(‘e‘,‘A‘)
  ‘pAtAr‘
  >>>
  30.str.rfind #返回子字符串在字符串中最后一次出现的位置;如没找到,返回-1
  31.str.rindex #同rfind(),但如果在字符串中没找到子字符串,会抛出错误
  32.str.rjust #返回指定长度的字符串,字符串内容居右,并使用指定字符填充
  33.str.rpartition #从后往前查找,返回包含字符串中分隔符之前、分隔符、分隔符之后
  34.str.rsplit #从后往前拆分字符串,返回一个列表
  35.str.rstrip #去掉字符串后面的空格,或参数中的字符
  36.str.split
  36.str.split #拆分字符串,返回一个列表
  In [58]: a = ‘ gwdsr is a student ‘

  In [59]: a.split()
  Out[59]: [‘gwdsr‘, ‘is‘, ‘a‘, ‘student‘]
  37.str.splitlines
  37.str.splitlines #字符串以换行符为分隔符拆分,去掉换行符;如果keepends
  In [54]: a
  Out[54]: ‘gwdsr\n is \na student‘

  In [55]: print(a)
  gwdsr
  is
  a student

  In [56]: print(a.splitlines())
  [‘gwdsr‘, ‘ is ‘, ‘a student‘]
  )
  38.str.startswith
  38.str.startswith #判断字符串是否以指定的前缀开始
  In [47]: a
  Out[47]: ‘ gwdsr is a student ‘

  In [48]: a.startswith(‘ ‘)
  Out[48]: True

  In [49]: a.startswith(‘a‘)
  Out[49]: False
  39.str.strip
  39.str.strip #去掉字符串前后的空格,或指定的所有字符
  In [41]: a = ‘ gwdsr is a student ‘

  In [42]: a
  Out[42]: ‘ gwdsr is a student ‘

  In [43]: a.strip()
  Out[43]: ‘gwdsr is a student‘
  40.str.swapcase
  40.str.swapcase #大写字符转换成小写字符,小写字符转换成大写字符
  In [38]: b = a.title()

  In [39]: b
  Out[39]: ‘gwdsr Is A Student‘

  In [40]: b.swapcase()
  Out[40]: ‘gwdsR iS a sTUDENT‘
  41.str.title
  41.str.title #每个单词的第一个字符转换成titlecase字符,其他字符转
  In [34]: a = ‘gwdsr is a student‘

  In [35]: a.title()
  Out[35]: ‘gwdsr Is A Student‘
  43.str.upper
  43.str.upper #字符串转换成大写
  In [26]: a.upper()
  Out[26]: ‘gwdsR‘
  44.str.zfill
  44.str.zfill #在字符串的左边填充0,不会截断字符串
  In [24]: a.zfill(10)
  Out[24]: ‘00000gwdsr‘

  In [25]: a.zfill(5)
  Out[25]: ‘gwdsr‘
  builtins Python内置函数
  1.abs #求绝对值
  2.all #判断迭代器中的所有数据是否都为true
  3.any #判断迭代器中的是否有一个数据为true
  4.bin #转换整数为一个二进制字符串
  5.bool #转换一个数据为布尔值
  6.bytearray #将数据转换为字节数组
  7.bytes #将数据转换为字节数组
  8.callable #判断一个对象是否可调用
  9.chr #将整数转成字符
  10.classmethod #得到function的classmethod
  11.compile #编译source为code或AST对象
  12.complex #创建一个复数
  13.delattr #删除指定的属性
  14.dict #创建一个字典dictionary
  15.dir #返回对象的属性列表
  16.divmod #得到两个数字相除的结果和余数
  17.enumerate #得到一个枚举对象
  18.eval #执行一个表达式
  19.exec #动态执行Python代码
  20.filter #过滤数据得到一个迭代器
  21.float #将字符串或数字转为浮点数
  22.format #格式化数据
  23.frozenset #得到新的frozenset对象
  24.getattr #得到对象属性的值
  25.globals #得到当前模块的全局符号表的字典
  26.hasattr #判断对象是否存在属性
  27.hash #得到对象的哈希值
  28.help #显示帮助信息
  29.hex #整数转换为十六进制表示
  30.id #得到对象的id
  31.input #输出提示符,读取用户输入
  32.int #将数字或字符串转为整数
  33.isinstance #判断object是否是classinfo的实例
  34.issubclass #判断一个类是否是另一个类的父类
  35.iter #得到一个迭代器
  36.len #返回对象的长度或集合的数据个数
  37.list #创建一个列表
  38.locals #得到当前符号表字典
  39.map #更改迭代器中的每个数据得到一个新的迭代器
  40.max #得到迭代器中最大的或两个或多个参数中最大的
  41.min #得到迭代器中最小的或两个或多个参数中最小的
  42.next #得到迭代器的下一个数据
  43.object #得到object的实例
  44.oct #整数转换为八进制表示
  45.open #打开文件并返回一个流
  46.ord #得到字符的整数表示
  47.pow #乘方运算
  48.print #输出数据到流
  49.property #得到属性
  50.range #创建一个范围对象
  51.repr #得到对象的字符串表示
  52.reversed #反转序列得到一个迭代器
  53.round #浮点数按小数位数做舍入操作
  54.set #创建一个集合对象
  55.setattr #更改属性的值
  56.slice #得到分片对象
  57.sorted #排序可迭代的数据得到一个列表
  58.staticmethod #得到function的staticmethod
  59.str #得到对象的str版本
  60.sum #计算可迭代数据的合计
  61.tuple #创建一个元组
  62.type #返回对象的类型或创建一个新的类型对象
  63.vars #得到属性信息

  dict() 方法练习
  1.dict.clear
  dict.clear #删除dictionary中的所有key-value对

  >>> a = {‘k1‘:‘v1‘}
  >>> a
  {‘k1‘: ‘v1‘}
  >>> a.clear()
  2.dict.copy
  dict.copy #浅拷贝dictionary

  >>> b = a.copy()
  >>> b
  {‘k1‘: ‘v1‘}
  3.dict.fromkeys
  dict.fromkeys #返回一个新的dictionary,key由iterable的元素组成,value等于value

  >>> a = dict.fromkeys([‘k1‘,‘k2‘,‘k3‘],‘vvv‘)
  >>> a
  {‘k3‘: ‘vvv‘, ‘k2‘: ‘vvv‘, ‘k1‘: ‘vvv‘}
  4.dict.get
  dict.get #返回dictionary中key为指定值k对应的value,

  >>> a.get(‘k3‘)
  ‘vvv‘

  >>> b = {‘k1‘:a}
  >>> b
  {‘k1‘: {‘k3‘: ‘vvv‘, ‘k2‘: ‘vvv‘, ‘k1‘: ‘vvv‘}}
  >>> b.get(‘k1‘)[‘k3‘]
  ‘vvv‘
  >>>
  5.dict.items
  dict.items #返回dictionary所有key-value对组成的集合

  >>> b.items()
  [(‘k1‘, {‘k3‘: ‘vvv‘, ‘k2‘: ‘vvv‘, ‘k1‘: ‘vvv‘})]
  6.dict.keys
  dict.keys #返回dictionary所有key组成的集合

  >>> b.keys()
  [‘k1‘]
  7.dict.pop
  dict.pop #从dictionary中删除指定key,返回指定key对应的value。如果dictionary中不存在指定key,如果指定了d,返回d,否则抛出例外

  >>> c = b.pop(‘k1‘)
  >>> c
  {‘k3‘: ‘vvv‘, ‘k2‘: ‘vvv‘, ‘k1‘: ‘vvv‘}
  >>> b
  {}
  >>>
  8.dict.popitem
  dict.popitem #删除并返回key-value对(key, value)作为2-tuple,如果dictionary为空,抛出例外

  >>> e = c.popitem()
  >>> e
  (‘k3‘, ‘vvv‘)
  >>> c
  {‘k2‘: ‘vvv‘, ‘k1‘: ‘vvv‘}
  >>>
  9.dict.setdefau
  dict.setdefault #如果dictionary中不存在k,设置D[k]=d


  >>> c
  {‘k2‘: ‘vvv‘, ‘k1‘: ‘vvv‘}
  >>> c.setdefault(‘k1‘,‘v1‘)
  ‘vvv‘
  >>> c
  {‘k2‘: ‘vvv‘, ‘k1‘: ‘vvv‘}
  >>> c.setdefault(‘k4‘,‘v4‘)
  ‘v4‘
  >>> c
  {‘k2‘: ‘vvv‘, ‘k1‘: ‘vvv‘, ‘k4‘: ‘v4‘}
  >>>
  10.dict.update
  dict.update #使用E(dict/iterable)和F的数据更新dicti

  >>> a = {‘ak1‘:‘av1‘}
  >>> b = {‘bk1‘:‘bv1‘}
  >>> b.update(a)
  >>> b
  {‘ak1‘: ‘av1‘, ‘bk1‘: ‘bv1‘}
  11.dict.values
  dict.values #返回dictionary所有value组成的集合
  >>> b.values()
  [‘av1‘, ‘bv1‘]
  >>>
  list()
  列表练习

  1.list.append
  list.append #附加一个对象到list

  >>> a = [‘a‘,‘b‘,1,3,4]
  >>> a
  [‘a‘, ‘b‘, 1, 3, 4]
  >>> a.append(‘d‘)
  >>> a
  [‘a‘, ‘b‘, 1, 3, 4, ‘d‘]
  2.list.clear
  list.clear #删除list中的所有元素

  >>> a.clear()
  >>> a
  []
  3.list.copy
  list.copy #浅拷贝list

  >>> a = [‘a‘,‘b‘,1,3,4]
  >>> a
  [‘a‘, ‘b‘, 1, 3, 4]
  >>> b = a.copy()
  >>> b
  [‘a‘, ‘b‘, 1, 3, 4]
  4.list.count
  list.count #返回指定参数在list中出现的次数

  >>> a.count(‘b‘)
  1
  5.list.extend
  list.extend #附加指定iterable中的元素到list

  >>> b = [6,6,5,4,2,4]
  >>> a.extend(b)
  >>> a
  [‘a‘, ‘b‘, 1, 3, 4, ‘d‘, 6, 6, 5, 4, 2, 4]
  >>>
  6.list.index
  list.index #返回指定值在list中第一次出现的位置,如果list上存在指

  >>> a
  [‘a‘, ‘b‘, 1, 3, 4, ‘d‘, 6, 6, 5, 4, 2, 4]
  >>> a.index(1)
  2
  7.list.insert
  list.insert #在list的指定位置index插入object

  >>> a.insert(2,‘sddsds‘)
  >>> a
  [‘a‘, ‘b‘, ‘sddsds‘, 1, 3, 4, ‘d‘, 6, 6, 5, 4, 2, 4]
  8.list.pop
  list.pop #删除并返回指定位置index的元素,默认为最后位置,如果index超过范围或list为空,抛出错误

  >>> a
  [‘a‘, ‘b‘, ‘sddsds‘, 1, 3, 4, ‘d‘, 6, 6, 5, 4, 2, 4]
  >>> b = a.pop()
  >>> b
  4
  >>> a
  [‘a‘, ‘b‘, ‘sddsds‘, 1, 3, 4, ‘d‘, 6, 6, 5, 4, 2]
  >>>
  9.list.remove
  list.remove #从list中删除第一次出现的指定值,如果指定值不存在,抛出例外

  >>> a
  [‘a‘, ‘b‘, ‘sddsds‘, 1, 3, 4, ‘d‘, 6, 6, 5, 4, 2]
  >>> a.remove(‘a‘)
  >>> a
  [‘b‘, ‘sddsds‘, 1, 3, 4, ‘d‘, 6, 6, 5, 4, 2]
  10.list.reverse
  list.reverse #反转list中的元素

  >>> a
  [‘b‘, ‘sddsds‘, 1, 3, 4, ‘d‘, 6, 6, 5, 4, 2]
  >>> a.reverse()
  >>> a
  [2, 4, 5, 6, 6, ‘d‘, 4, 3, 1, ‘sddsds‘, ‘b‘]
  11.list.sort
  list.sort #对list进行排序

  >>> a
  [2, 4, 5, 6, 6, ‘d‘, 4, 3, 1, ‘sddsds‘, ‘b‘]
  >>> a.sort()
  >>> a
  [1, 2, 3, 4, 4, 5, 6, 6, ‘b‘, ‘d‘, ‘sddsds‘]
  >>>
  tuple()
  元组练习

  1.tuple.count
  tuple.count #返回指定参数在tuple中出现的次数

  >>> b
  (1, 2, 3, 4, 4, 5, 6, 6, ‘b‘, ‘d‘, ‘sddsds‘)
  >>> b.count(4)
  2
  2.tuple.index
  tuple.index #返回指定值在tuple中第一次出现的位置,如果tuple中不

  >>> b
  (1, 2, 3, 4, 4, 5, 6, 6, ‘b‘, ‘d‘, ‘sddsds‘)
  >>> b.count(4)
  2
  >>> b.index(2)
  1
  >>> b.index(1)
  0
  >>>

以上是关于Python 基础 下的主要内容,如果未能解决你的问题,请参考以下文章

C++ 解释器/控制台/片段编译器

201555332盛照宗—网络对抗实验1—逆向与bof基础

20155201 李卓雯 《网络对抗技术》实验一 逆向及Bof基础

python之基础篇——模块与包

[vscode]--HTML代码片段(基础版,reactvuejquery)

逆向及Bof基础实践