17-Python常用数据类型操作1

作者: 撩课学院 | 来源:发表于2018-11-30 10:54 被阅读6次

    1.数值

        表现形式
            整数(int)
                二进制
                    0b
                        +
                            二进制数
                                只能包含01
                八进制
                    0 / 0o
                        +
                            八进制数
                                只能包含0-7
                十进制
                    十进制数
                        只能包含0-9
                十六进制
                    0x
                        +
                            十六进制数
                                只能包含0-9, a-f
            浮点数(float)
                由整数部分和小数部分组成
                    168.2
                可以使用科学计数法表示
                    1.682e2
                        1.682 * 10²
            复数(complex)
                由实部和虚部组成
                    a + bj
                        complex(a, b)
                    a, b 都是浮点数
            注意
                Python3的整型, 可以自动的调整大小, 当做Long类型使用
                    所以, Python3中, 没有Python2中的Long类型
                分正负
                    6
                    -6
        进制转换
            进制的概念
                进位的制度
                    逢x进1
                    x进制
            常用进制
                二进制
                    逢2进1
                八进制
                    逢8进1
                十进制
                    逢10进1
                十六进制
                    逢16进1
            进制转换
                其他进制 -> 十进制
                    x进制
                        111101
                        1 * x ^ 0 + 0 * x ^ 1
                十进制 -> 其他进制
                    规律
                        整除倒取余
                二进制 <-> 八进制
                    整合3位为1位
                二进制 <-> 十六进制
                    整合4位为1位
        常用操作
            适用于几乎所有Python运算符
                算术运算符
                    +
                        加法运算符
                    -
                        减法运算符
                    *
                        乘法运算符
                    **
                        幂运算符
                    /
                        除法运算符
                    //
                        整除运算符
                    %
                        求模运算符
                    =
                        赋值运算符
                            a = 10
                            b = a + c
                            a, b, c = 10, 20, 30
                            链式赋值
                                a = b = c = 3
                    注意
                        除以0
                        优先级问题
                            ()使用
                    整除和求余的应用场景
                        行列
                复合运算符
                    +=
                    -=
                    *=
                    %=
                    **=
                    //=
                    a
                        a  x= 值
                        a = a x 值
                比较运算符
                    >
                    <
                    !=
                    <>
                        Python2.x版本支持
                        等同于!=
                        以后统一使用!=表示不等于
                    >=
                    <=
                    ==
                    is
                        比对唯一标识
                    链状比较运算符
                        10 < a <=66
                    注意
                        整型比对
                            ==
                            is
                        案例
                            256
                                True
                                True
                            257
                                True
                                False
                        解答
                            出于对性能的考虑,Python内部做了很多的优化工作,对于整数对象,Python把一些频繁使用的整数对象缓存起来,保存到一个叫small_ints的链表中,在Python的整个生命周期内,任何需要引用这些整数对象的地方,都不再重新创建新的对象,而是直接引用缓存中的对象。Python把这些可能频繁使用的整数对象规定在范围[-5, 256]之间的小对象放在small_ints中,但凡是需要用些小整数时,就从这里面取,不再去临时创建新的对象。因为257不再小整数范围内,因此尽管a和b的值是一样,但是他们在Python内部却是以两个独立的对象存在的,各自为政,互不干涉。
                            。Python内部为了将性能进一步的提高,凡是在一个代码块中创建的整数对象,如果存在一个值与其相同的对象于该代码块中了,那么就直接引用,否则创建一个新的对象出来。Python出于对性能的考虑,但凡是不可变对象,在同一个代码块中的对象,只有是值相同的对象,就不会重复创建,而是直接引用已经存在的对象。因此,不仅是整数对象,还有字符串对象也遵循同样的原则。所以 a is b就理所当然的返回True了,而c和a不在同一个代码块中,因此在Python内部创建了两个值都是257的对象。
                逻辑运算符
                    not
                        非
                        取反
                            真的变假
                            假的变真
                    and
                        与
                        一假全假
                    or
                        或
                        一真全真
                    注意
                        非布尔类型的值, 如果作为真假来判定, 一般都是非零即真, 非空即真
                        整个逻辑表达式的结果不一定只是True和False
                    注意
                        当int和float类型进行算术运算时, 结果会被提升为float类型
                    数值类型如果参与逻辑运算, 参照的原则是
                        非零即真
            数学函数
                部分函数使用前注意
                    导入对应模块
                        例如: import math
                    使用函数时
                        模块名.函数名(参数)
                        math.fabs(-10)
                abs(num)
                    返回数字的绝对值
                max(num1, num2...)
                    返回序列中的最大元素
                min(num1, num2...)
                    返回序列中的最小元素
                round(num[, n])
                    四舍五入
                    , n
                        表示四舍五入的位数
                        可以省略
                pow(x, y)
                    返回 x 的 y次幂
                        x ** y
    

    ---------------------分割线-------------------

                ceil(num)
                    上取整
                floor(num)
                    下取整
                sqrt(num)
                    开平方
                log(x, base)
                    以base为基数, x的对数
                内建函数
                math模块函数
            随机函数
                random()
                    [0, 1)
                        范围之内的随机小数
                choice(seq)
                    从一个序列中, 随机挑选一个数值
                    random.choice((1, 3, 6, 8))
                uniform(x, y)
                    [x, y]
                        范围之内的随机小数
                randint(x, y)
                    [x, y]
                        范围之内的随机整数
                randrange(start, stop=None, step=1)
                    给定区间内的一随机整数
                    [start, stop)
                random模块
            三角函数
                sin(x)
                    正弦
                cos(x)
                    余弦
                tan(x)
                    正切
                asin(x)
                    反正弦
                acos(x)
                    反余弦
                atan(x)
                    反正切
                degrees(x)
                    弧度 -> 角度
                radians(x)
                    角度 -> 弧度
                math模块
            数学常量
                pi
                    数学中的π
                        3.14...
    

    2.布尔

    bool
        True
        False
    是int类型的子类
        issubclass(bool, int)
    应用场景
        当做int类型,参与相关运算
        比较表达式的运算结果
            3 > 2
        可以用于if判定条件和while循环条件
    

    3.字符串

        概念
            由单个字符组成的一个集合
        形式
            非原始字符串
                使用单引号包含的
                    'abc'
                使用双引号包含的
                    "abc"
                使用3个单引号
                    ''' abc '''
                使用3个双引号
                    """ abc """
            原始字符串
                使用单引号包含的
                    r'abc'
                使用双引号包含的
                    r"abc"
                使用3个单引号
                    r''' abc '''
                使用3个双引号
                    r""" abc """
            概念补充
                转义符
                    概念
                        通过转换某个指定的字符, 使它具备特殊的含义
                    常见转义符
                        \(在行尾时)     续行符
                        \'  单引号
                        \"  双引号
                        \n  换行
                        \t  横向制表符
        各个形式的特点
            单/双引号
                混合使用可以避免使用引号转义符
                一般内容需要写成一行
                    跨行
                        需要连行符 \
                            name = "s \
        z"
                        使用小括号
                            name = ("s"
        "z")
            三引号
                可以直接跨行书写
                可用于注释
        字符串一般操作
            字符串拼接
                方式1
                    str1 + str2
                    例如:
                        "wangzha" + "shunzi"
                        "wangzhashunzi"
                方式2
                    str1str2
                        直接把两个字符串放一块
                    例如:
                        "wangzha""shunzi"
                        "wangzhashunzi"
                方式3
                    ”xxx%sxxx“%(a+b)
                方式4
                    字符串乘法
                    "abc" * 3
                        "abcabcabc"
            字符串切片
                概念
                    获取一个字符串的某个片段
                获取某一个字符
                    name[下标]
                    下标
                        字符串中每个字符的编号
                            座位编号
                        注意
                            下标越界
                            负数下标
                                如果为负数, 则会从尾部开始定位
                                最后一个字符为 -1
                获取一个字符串片段
                    name[起始:结束:步长]
                    注意
                        获取范围
                            [起始, 结束)
                                起始包含
                                结束不包含
                        默认值
                            起始默认值: 0
                            结束默认值: len(name)
                                整个字符串的长度
                            步长默认值: 1
                        获取顺序
                            步长 > 0
                                从左边到右
                            步长 < 0
                                从右往左
                            注意: 不能从头部跳到尾部, 或者从尾部跳到头部
                    特殊案例
                        反转字符串
                        字符串[::-1]
        字符串函数操作
            使用方式
                小旗子的代表是内建函数, 直接使用
                不带小旗子的属于对象方法
                    对象.方法(参数)
            len
                作用
                    计算字符串的字符个数
                语法
                    len(name)
                参数
                    字符串
                返回值
                    整型
                    字符个数
            find
                作用
                    查找子串索引位置
                语法
                    find(sub, start=0, end=len(str))
                参数
                    参数1-sub
                        需要检索的字符串
                    参数2-start
                        检索的起始位置
                        可省略, 默认0
                    参数3-end
                        检索的结束位置
                        可省略, 默认len(str)
                返回值
                    找到了
                        指定索引
                        整型
                    找不到
                        -1
                注意
                    从左到右进行查找
                    找到后立即停止
            rfind
                功能使用, 同find
                区别
                    从右往左进行查找
            index
                作用
                    获取子串索引位置
                语法
                    index(sub, start=0, end=len(str))
                参数
                    参数1-sub
                        需要检索的字符串
                    参数2-start
                        检索的起始位置
                        可省略, 默认0
                    参数3-end
                        检索的结束位置
                        可省略, 默认len(str)
                返回值
                    找到了
                        指定索引
                        整型
                    找不到
                        异常
                注意
                    从左到右进行查找
                    找到后立即停止
            rindex
                功能使用, 同index
                区别
                    从右往左进行查找
            count
                作用
                    计算某个子字符串的出现个数
                语法
                    count(sub, start=0, end=len(str))
                参数
                    参数1-sub
                        需要检索的字符串
                    参数2-start
                        检索的起始位置
                        可省略, 默认0
                    参数3-end
                        检索的结束位置
                        可省略, 默认len(str)
                返回值
                    子字符串出现的个数
                    整型
            replace
                作用
                    使用给定的新字符串 替换原字符串中的 旧字符串
                语法
                    replace(old, new[, count])
                参数
                    参数1-old
                        需要被替换的旧字符串
                    参数2-new
                        替换后的新字符串
                    参数3-count
                        替换的个数
                        可省略, 表示替换全部
                返回值
                    替换后的结果字符串
                注意
                    并不会修改原字符串本身
            capitalize
                作用
                    将字符串首字母变为大写
                语法
                    capitalize()
                参数
                    无
                返回值
                    首字符大写后的新字符串
                注意
                    并不会修改原字符串本身
            title
                作用
                    将字符串每个单词的首字母变为大写
                语法
                    title()
                参数
                    无
                返回值
                    每个单词首字符大写后的新字符串
                注意
                    并不会修改原字符串本身
            lower
                作用
                    将字符串每个字符都变为小写
                语法
                    title()
                参数
                    无
                返回值
                    全部变为小写后的新字符串
                注意
                    并不会修改原字符串本身
            upper
                作用
                    将字符串每个字符都变为大写
                语法
                    upper()
                参数
                    无
                返回值
                    全部变为大写后的新字符串
                注意
                    并不会修改原字符串本身
            ljust
                作用
                    根据指定字符(1个), 将原字符串填充够指定长度
                    l
                        表示原字符串靠左
                语法
                    ljust(width, fillchar)
                参数
                    参数1-width
                        指定结果字符串的长度
                    参数2-fillchar
                        如果原字符串长度 < 指定长度时
                        填充过去的字符
                返回值
                    填充完毕的结果字符串
                注意
                    不会修改原字符串
                    填充字符的长度为1
                    只有原字符串长度 < 指定结果长度时才会填充
            rjust
                作用
                    根据指定字符(1个), 将原字符串填充够指定长度
                    r
                        表示原字符串靠右
                语法
                    rjust(width, fillchar)
                参数
                    参数1-width
                        指定结果字符串的长度
                    参数2-fillchar
                        如果原字符串长度 < 指定长度时
                        填充过去的字符
                返回值
                    填充完毕的结果字符串
                注意
                    不会修改原字符串
                    填充字符的长度为1
                    只有原字符串长度 < 指定结果长度时才会填充
            center
                作用
                    根据指定字符(1个), 将原字符串填充够指定长度
                    center
                        表示原字符串居中
                语法
                    center(width, fillchar)
                参数
                    参数1-width
                        指定结果字符串的长度
                    参数2-fillchar
                        如果原字符串长度 < 指定长度时
                        填充过去的字符
                返回值
                    填充完毕的结果字符串
                注意
                    不会修改原字符串
                    填充字符的长度为1
                    只有原字符串长度 < 指定结果长度时才会填充
            lstrip
                作用
                    移除所有原字符串指定字符(默认为空白字符)
                    l
                        表示从左侧开始移除
                语法
                    lstrip(chars)
                参数
                    参数-chars
                        需要移除的字符集
                        表现形式为字符串
                            "abc"
                            表示,"a"|"b"|"c"
                返回值
                    移除完毕的结果字符串
                注意
                    不会修改原字符串
            rstrip
                作用
                    移除所有原字符串指定字符(默认为空白字符)
                    r
                        表示从右侧开始移除
                语法
                    rstrip(chars)
                参数
                    参数-chars
                        需要移除的字符集
                        表现形式为字符串
                            "abc"
                            表示,"a"|"b"|"c"
                返回值
                    移除完毕的结果字符串
                注意
                    不会修改原字符串
            split
                作用
                    将一个大的字符串分割成几个子字符串
                语法
                    split(sep, maxsplit)
                参数
                    参数1-sep
                        分隔符
                    参数2-maxsplit
                        最大的分割次数
                        可省略, 有多少分割多少
                返回值
                    分割后的子字符串, 组成的列表
                    list 列表类型
                注意
                    并不会修改原字符串本身
            partition
                作用
                    根据指定的分隔符, 返回(分隔符左侧内容, 分隔符, 分隔符右侧内容)
                语法
                    partition(sep)
                参数
                    参数-sep
                        分隔符
                返回值
                    如果查找到分隔符
                        (分隔符左侧内容, 分隔符, 分隔符右侧内容)
                        tuple 类型
                    如果没有查找到分隔符
                        (原字符串, "", "")
                        tuple 类型
                注意
                    不会修改原字符串
                    从左侧开始查找分隔符
            rpartition
                作用
                    根据指定的分隔符, 返回(分隔符左侧内容, 分隔符, 分隔符右侧内容)
                    r
                        表示从右侧开始查找分隔符
                语法
                    partition(sep)
                参数
                    参数-sep
                        分隔符
                返回值
                    如果查找到分隔符
                        (分隔符左侧内容, 分隔符, 分隔符右侧内容)
                        tuple 类型
                    如果没有查找到分隔符
                        (原字符串, "", "")
                        tuple 类型
                注意
                    不会修改原字符串
                    从右侧开始查找分隔符
            splitlines
                作用
                    按照换行符(\r, \n), 将字符串拆成多个元素, 保存到列表中
                语法
                    splitlines(keepends)
                参数
                    参数-keepends
                        是否保留换行符
                        bool 类型
                返回值
                    被换行符分割的多个字符串, 作为元素组成的列表
                    list 类型
                注意
                    不会修改原字符串
            join
                作用
                    根据指定字符串, 将给定的可迭代对象, 进行拼接, 得到拼接后的字符串
                语法
                    join(iterable)
                参数
                    iterable
                        可迭代的对象
                            字符串
                            元组
                            列表
                            ...
                返回值
                    拼接好的新字符串
            isalpha
                作用
                    字符串中是否所有的字符都是字母
                        不包含该数字,特殊符号,标点符号等等
                        至少有一个字符
                语法
                    isalpha()
                参数
                    无
                返回值
                    是否全是字母
                    bool 类型
            isdigit
                作用
                    字符串中是否所有的字符都是数字
                        不包含该字母,特殊符号,标点符号等等
                        至少有一个字符
                语法
                    isdigit()
                参数
                    无
                返回值
                    是否全是数字
                    bool 类型
            isalnum
                作用
                    字符串中是否所有的字符都是数字或者字母
                        不包含该特殊符号,标点符号等等
                        至少有一个字符
                语法
                    isalnum()
                参数
                    无
                返回值
                    是否全是数字或者字母
                    bool 类型
            isspace
                作用
                    字符串中是否所有的字符都是空白符
                        包括空格,缩进,换行等不可见转义符
                        至少有一个字符
                语法
                    isspace()
                参数
                    无
                返回值
                    是否全是空白符
                    bool 类型
            startswith
                作用
                    判定一个字符串是否以某个前缀开头
                语法
                    startswith(prefix, start=0, end=len(str))
                参数
                    参数1-prefix
                        需要判定的前缀字符串
                    参数2-start
                        判定起始位置
                    参数3-end
                        判定结束位置
                返回值
                    是否以指定前缀开头
                    bool 类型
            endswith
                作用
                    判定一个字符串是否以某个后缀结尾
                语法
                    endswith(suffix, start=0, end=len(str))
                参数
                    参数1-suffix
                        需要判定的后缀字符串
                    参数2-start
                        判定起始位置
                    参数3-end
                        判定结束位置
                返回值
                    是否以指定后缀结尾
                    bool 类型
            补充
                in
                    判定一个字符串, 是否被另外一个字符串包含
                not in
                    判定一个字符串, 是否不被另外一个字符串包含
            查找计算
            转换
            填充压缩
            分割拼接
            判定
    

    学习地址:

    撩课-Python大数据+人工智能1
    撩课-Python大数据+人工智能2
    撩课-Python大数据+人工智能3
    撩课-Python大数据+人工智能4
    撩课-Python大数据+人工智能5
    撩课-Python大数据+人工智能6
    撩课-Python-GUI编程-PyQt5

    相关文章

      网友评论

        本文标题:17-Python常用数据类型操作1

        本文链接:https://www.haomeiwen.com/subject/jffxqqtx.html