大数据 爬虫Python AI Sql程序员

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

2018-11-30  本文已影响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

上一篇下一篇

猜你喜欢

热点阅读