Python-数据结构（一）

最新推荐文章于 2024-09-26 19:15:00 发布

Python之眼

最新推荐文章于 2024-09-26 19:15:00 发布

阅读量161

点赞数

分类专栏： Python 文章标签： python 程序员新手入门

本文链接：https://blog.csdn.net/weixin_42625143/article/details/96301074

版权

Python 专栏收录该内容

189 篇文章 1 订阅

订阅专栏

一、数字

整数

Python可以处理任意大小的整数，当然包括负整数，在程序中的表示方法和数学上的写法一模一样，例如：1，100，-8080，0，等等。

计算机由于使用二进制，所以，有时候用十六进制表示整数比较方便，十六进制用0x前缀和0-9，a-f表示，例如：0xff00，0xa5b4c3d2，等等。

浮点数

浮点数也就是小数，之所以称为浮点数，是因为按照科学记数法表示时，一个浮点数的小数点位置是可变的，比如，1.23x109和12.3x108是完全相等的。浮点数可以用数学写法，如1.23，3.14，-9.01，等等。但是对于很大或很小的浮点数，就必须用科学计数法表示，把10用e替代，1.23x109就是1.23e9，或者12.3e8，0.000012可以写成1.2e-5，等等。

整数和浮点数在计算机内部存储的方式是不同的，整数运算永远是精确的（除法难道也是精确的？是的！），而浮点数运算则可能会有四舍五入的误差。

常用方法：

int 将字符串转化为数字

	--------------------------------------------------------------------
	注：如果你对python感兴趣，我这有个学习Python基地，里面有很多学习资料，感兴趣的+Q群：895817687
	--------------------------------------------------------------------

    #!/usr/bin/env python
    # -*- coding:utf-8 -*-
    a = '123'
    print(type(a), a)
    a = int(a)
    print(type(a), a)

 
#输出
<class 'str'> 123
<class 'int'> 123

bit_length 当前数字的二进制至少用几位表示

    #!/usr/bin/env python
    # -*- coding:utf-8 -*-
    age = 10
    r = age.bit_length()
    print(r)
     
    #输出
    4

二、字符串

1. 常用方法

capitalize 把字符串的第一个字符大写
　　　　mystr.capitalize()
casefold lower 转换 mystr 中所有大写字符为小写 casefold可以识别特殊字符
　　　　mystr.lower()
upper 转换 mystr 中的小写字母为大写
　　　　mystr.upper()
swapcase 大小写切换
　　　　mystr.swapcase()

    test = 'sFHVahKHJss'
    v = test.swapcase()
    print(v)
     
    #输出
    SfhvAHkhjSS

center 返回一个原字符串居中,并使用fillchar填充至长度 width 的新字符串
　　　　mystr.center(width, fillchar=” ”)
count 返回str在start和end之间在 mystr里面出现的次数
　　　　mystr.count(str, start=0, end=len(mystr))
endswith 检查字符串是否以obj结束，如果是返回True,否则返回 False.
　　　　mystr.endswith(obj)
startswith 检查字符串是否是以 obj 开头, 是则返回 True，否则返回 False
　　　　mystr.startswith(obj)
find 检测str是否包含在 mystr中，如果包含返回开始的索引值，否则返回-1
　　　　mystr.find(str, start=0, end=len(mystr))
index 跟find()方法一样，只不过如果str不在 mystr中会报一个异常
　　　　mystr.index(str, start=0, end=len(mystr))

format 字符串格式化

    #!/usr/bin/env python
    # -*- coding:utf-8 -*-
    test = 'my name is {name},age is {age}'
    print(test)
    mstr = test.format(name='Tom', age=15)
    print(mstr)
     
    #输出
    my name is {name},age is {age}
    my name is Tom,age is 15

    # format的三种玩法
    res1 = '{} {} {}'.format('egon', 18, 'male')
    res2 = '{1} {0} {1}'.format('egon', 18, 'male')
    res3 = '{name} {age} {sex}'.format(sex='male', name='egon', age=18)
    print(res1)
    print(res2)
    print(res3)
     
    #输出
    egon 18 male
    18 egon 18
    egon 18 male

format_map 类似于format，但传入的参数是一个字典

    #!/usr/bin/env python
    # -*- coding:utf-8 -*-
    test = 'my name is {name},age is {age}'
    print(test)
    mstr = test.format_map({"name":"Tom", "age":"15"})
    print(mstr)
     
    #输出
    my name is {name},age is {age}
    my name is Tom,age is 15
    replace    把 mystr 中的 str1 替换成 str2,如果 count 指定，则替换不超过 count 次
    　　　　mystr.replace(str1, str2,  mystr.count(str1))

    name = 'alex say :i have one tesla,my name is alex'
    print(name.replace('alex', 'SB', 1))
     
    #输出
    SB say :i have one tesla,my name is alex

split 以 str 为分隔符切片 mystr，如果 maxsplit有指定值，则仅分隔 maxsplit 个子字符串
　　　　mystr.split(str=" ", maxsplit)

    name = 'root:x:0:0::/root:/bin/bash'
    print(name.split(':'))  # 默认分隔符为空格
    name = 'C:/a/b/c/d.txt'  # 只想拿到顶级目录
    print(name.split('/', 1))
     
    #输出
    ['root', 'x', '0', '0', '', '/root', '/bin/bash']
    ['C:', 'a/b/c/d.txt']

rsplit 类似split，但从右边开始
title 把字符串的每个单词首字母大写
　　　　mystr.title()
ljust 返回一个原字符串左对齐,并使用fillchar填充至长度 width 的新字符串
　　　　mystr.ljust(width, fillchar=” ”)
rjust 返回一个原字符串右对齐,并使用fillchar填充至长度 width 的新字符串
　　　　mystr.rjust(width, fillchar=” ”)
zfill 返回指定长度的字符串，原字符串右对齐，前面填充0
　　　　mystr.zfill(width)
lstrip 删除 mystr 左边的空白字符也可以去除指定的字符
　　　　mystr.lstrip()

    #!/usr/bin/env python
    # -*- encoding:utf-8 -*-
    test = 'asdfghh'
    v = test.lstrip('8assdf') # 消除所有匹配到的字符
    print(v)
     
    #输出
    ghh

rstrip 删除 mystr 右边的空白字符也可以去除指定的字符
　　　　mystr.rstrip()
strip 删除mystr字符串两端的空白字符也可以去除指定的字符
　　　　mystr.strip()
rfind 类似于 find()函数，不过是从右边开始查找
　　　　mystr.rfind(str, start=0,end=len(mystr) )
rindex 类似于 index()，不过是从右边开始.
　　　　mystr.rindex( str, start=0,end=len(mystr))
partition 把mystr以str分割成三部分,str前，str和str后
　　　　mystr.partition(str)

    test = 'ahjsyklsuiyska'
    v = test.partition('s')
    print(v)
     
    #输出
    ('ahj', 's', 'yklsuiyska')

rpartition 类似于 partition()函数,不过是从右边开始.
　　　　mystr.rpartition(str）
splitlines 按照行分隔，返回一个包含各行作为元素的列表
　　　　mystr.splitlines()

    test = 'ahjsykls\nuiyska\nvjshgk\ndhvgks'
    v1 = test.splitlines(True)
    print(v1)
    v2 = test.splitlines(False)
    print(v2)
     
    #输出
    ['ahjsykls\n', 'uiyska\n', 'vjshgk\n', 'dhvgks']
    ['ahjsykls', 'uiyska', 'vjshgk', 'dhvgks']

isupper 判断字符串否全是大写字母
　　　　mystr.isupper()
islower 判断字符串否全是小写字母
　　　　mystr.islower()
isalpha 如果 mystr 所有字符都是字母则返回 True,否则返回 False
　　　　mystr.isalpha()
isdigit isdecimal isnumeric 如果 mystr 只包含数字则返回 True 否则返回
False。isdigit可以判断一些特殊字符例如②。 isnumeric可以判断中文数字例如二。
　　　　mystr.isdigit()

    #!/usr/bin/env python
    # -*- encoding:utf-8 -*-
    test = '②'
    v1 = test.isdecimal()
    v2 = test.isdigit()
    print(v1, v2)
     
    #输出
    False True

    test = '二'
    v1 = test.isdecimal()
    v2 = test.isdigit()
    v3 = test.isnumeric()
    print(v1, v2, v3)
     
    #输出
    False False True

isalnum 如果 mystr 所有字符都是字母或数字则返回 True,否则返回 False
　　　　mystr.isalnum()
isspace 如果 mystr 中只包含空格，则返回 True，否则返回 False
　　　　mystr.isspace()
istitle 如果字符串的每个单词的首字母都是大写，则返回True，否则返回False
　　　　mystr.istitle()
isprintable 判断字符串是否能够被打印
　　　　mystr.isprintable()

    test = '\n'
    v = test.isprintable()
    print(v)
     
    #输出
    False

join 将字符串、元组、列表中的元素以mystr连接生成一个新的字符串
　　　　mystr.join(str)

    mystr = ' '
    print(mystr.join(["haha", "hehe", "heihei"]))
    mystr = '-'
    print(mystr.join(["haha", "hehe", "heihei"]))
    # 运行结果：
	haha hehe heihei
	haha-hehe-heihei

expandtabs 方法把字符串中的 tab 符号(’\t’)转为空格，tab 符号(’\t’)默认的空格数是
8。从头开始数，数到第一个\t正好为8个空格，不足则补空格，如果还有\t，接着从第一个\t数到第二个\t仍然为8个空格，以此类推直到最后一个\t结束。
　　　　S.expandtabs([tabsize=8])

    #!/usr/bin/python3
      
    S = "this is\tstring example....wow!!!"
    print ("原始字符串: " + S)
    print ("替换 \\t 符号: " +  S.expandtabs())
    print ("使用16个空格替换 \\t 符号: " +  S.expandtabs(16))
    """
    以上实例输出结果如下：
    原始字符串: this is     string example....wow!!!
    替换 \t 符号: this is string example....wow!!!
    使用16个空格替换 \t 符号: this is         string example....wow!!!
    """

    #!/usr/bin/env python
    #-*- encoding:utf-8 -*-
     
    S = "username\temail\tpassword\nlaiying\tying@q.com\t123\nlaiying\tying@q.com\t123\nlaiying\tying@q.com\t123"
    v = S.expandtabs(20)
    print(v)

在这里插入图片描述

translate 替换字符串中指定的字符

    test = 'ahjsykliuiyjka'
    m = str.maketrans('aeiou','12345')
    v = test.translate(m)
    print(v)
     
    #输出
    1hjsykl353yjk1

重点：

1、strip,lstrip,rstrip

2、lower,upper

3、startswith,endswith

4、format的三种玩法

5、split,rsplit

6、join

7、replace

8、isdigit

2. 下标切片
字符串中"下标"的使用

字符串实际上就是字符的数组，所以支持下标索引。

如果有字符串:name = ‘abcdef’，在内存中的实际存储如下:

如果想取出部分字符，那么可以通过下标的方法，（注意python中下标从 0 开始）

    name = 'abcdef'
    print(name[0])
    print(name[1])
    print(name[2])
     
    运行结果：
    a
    b
    c

切片

切片是指对操作的对象截取其中一部分的操作。

切片的语法：变量名[起始:结束:步长]

注意：选取的区间属于左闭右开型，即从"起始"位开始，到"结束"位的前一位结束（包含起始位本身但不包含结束位本身)。结束位可以不写，那么默认按照步长一直到末尾。

如果取出一部分，则可以在中括号[]中

    示例1：
    name = 'abcdef'
    print(name[0:3])  # 取下标0~2 的字符
    运行结果：
    abc
     
    示例2：
    name = 'abcdef'
    print(name[2:])  # 取下标为2开始到最后的字符
    运行结果：
    cdef
     
    示例3：
    name = 'abcdef'
    print(name[len(name)-1])  # 取下标为字符长度-1的字符
    print(name[-1])  # 取下标为倒数第一个的字符
    运行结果：
    f
    f
     
    示例4：
    name = 'abcdef'
    print(name[1:-1])  # 取第2个到倒数第2个字符切片
    print(name[0::2])  # 从第一个字符开始每次步长为2取切片
    运行结果：
    bcde
    ace
     
    示例5：
    name = 'abcdef'
    print(name[-1:-5:-1])  # 逆向取倒数第一个到倒数第4个字符切片
    print(name[-1::-1])  # 逆向取倒数第一个到末尾的字符切片
    print(name[::-1])  # 倒序字符的切片
    运行结果：
    fedc
    fedcba
    fedcba