[Python知识库]python常用数据类型操作

Numbers（数值类型）

1. 表现形式

   • 整数int：二0b、八0/0o、十、十六进制0x

   • long

   • 浮点数float

     • 可以使用科学计数法表示：1.68e3

     数complex

   • 注意：python3的整型，可以自动的调整大小，当作long类型使用

2. 进制转换

3. 常用操作

   1. 适用于几乎所有python运算符

      • 算术运算符

      • 复合运算符

      • 比较运算符

      • 逻辑运算符

      • 注意

        当int和float类型进行算数运算时，结果会被提升为float类型

        数值类型如果参与逻辑运算，参照的原则是非零即真

   2. 数学函数

      1. 内建函数
         • abs()
         • max()
         • min()
         • round()
         • pow()
      2. math模块函数
         • ceil()
         • floor()
         • sqrt()
         • log()

   3. 随机函数

      1. 内建函数：random()：[0,1)范围内的随机小数
      2. random模块
         • choice(seq)：从一个序列中，随机挑选一个数值；random.choice((1,2,35,5))
         • uniform(x,y)：[x,y]范围内的随机小数
         • randomint(x,y)：[x,y]范围内的随机整数
         • randrange(start,stop=None,step=1)：给定区间[start,stop)内的随机整数

   4. 三角函数

      • sin(x)
      • cos(x)
      • tan(x)
      • asin(x)
      • acos(x)
      • atan(x)
      • degres(x)：弧度-》角度
      • radians(x)：角度-》弧度

   5. 数学常量

      • pi

Bool（布尔类型）

1. bool：True、False
2. 是int类型的子类
3. 应用场景：
   • 当作int类型，参与相关运算
   • 比较表达式的运算结果
   • 可以用于if判定条件和while循环条件

String（字符串）

’abc‘、”abc“、’’‘字符串’’’、""“字符串”""

1. 概念：由单个字符组成的一个有序集合

2. 字符串操作

   1. 使用方法：①内建函数，直接使用；②对象方法，对象.方法(参数)

   2. 查找计算：

      1. len（内建函数）
      2. find
         • 作用：查找子串索引（下标）位置
         • 语法：find(sub,start=0,end=len(str))
         • 返回值：找到了即返回指定索引，整型
      3. rfind
      4. index
      5. rindex
      6. count
         • 作用：计算某个子字符串的出现个数
         • 语法：count(sub,start=0,end=len(str))
         • 返回值：子字符串出现的个数，整型

   3. 转换

      1. replace
         • 作用：使用给定的新字符串，替换原字符串中的旧字符串
         • 语法：replace(old,new[,count])
         • 返回值：替换后的结果字符串
         • 注意：并不会修改原字符串本身
      2. capitalize
         • 作用：将字符串首字母变为大写
      3. title
         • 作用：将字符串每个单词的首字母变为大写
         • 语法：title()
         • 参数：无
         • 返回值：每个单词首字母大写后的新字符串
         • 注意：并不会修改原字符串本身
      4. lower
      5. upper

   4. 填充压缩

      1. ljust
         • 作用：根据指定字符（一个），将原字符串填充至指定长度
         • 语法：ljust(width,fillchar)
         • 返回值：填充后的结果字符串
         • 注意：不会修改原字符串；填充字符的长度为1；只有原字符串长度<指定结果长度时才会填充
      2. rjust
      3. center
      4. lstrip
         • 作用：移除所有原字符串指定字符（默认为空白字符）
         • 语法：lstrip(chars)
         • 参数：chars：需要移除的字符集合，表现为字符串，即“abc”表示为“a“|”b“|”c“
         • 返回值：移除完毕的结果字符串
         • 注意：不会修改原字符串
      5. rstrip

   5. 分割拼接

      1. split

         • 作用：将一个大的字符串分割成几个子字符串
         • 语法：split(sep[,maxsplit])
         • 返回值：分割后的子字符串组成的列表
         • 注意：不会修改原字符串本身

      2. partition

         • 作用：根据指定的分隔符，返回（分隔符左侧内容，分隔符，分隔符右侧内容）

         • 语法：partition(sep)

         • 返回值：

           ? 如果查找到分隔符：（分隔符左侧内容，分隔符，分隔符右侧内容），tuple类型

           ? 如果内查找到分隔符：(原字符串，”“，”“)，tuple类型

         • 注意：不会修改原字符串；从左侧开始查找分隔符

      3. rpartition

      4. splitlines

         • 作用：按照换行符（\r,\n），将字符串拆成多个元素，保存到列表中
         • 语法：splitlines(keepends)
         • 参数：keepends：是否保留换行符，bool类型
         • 返回值：list类型
         • 注意：不会修改原字符串

      5. join

         • 作用：根据指定字符串，将给定的可迭代对象，进行拼接，得到拼接后的字符串
         • 语法：join(iterable)
         • 参数：iterable：可迭代的对象，如字符串、元组、列表等
         • 返回值：拼接好的新字符串

   6. 判定

      1. isalpha
         • 作用：字符串中是否所有字符都是字母（不包含数字、特殊字符、标点符号等；至少有一个字符）
         • 语法：isalpha()
      2. isdigit
      3. isalnum
         • 作用：字符串中是否所有的字符都是数字或字母（不包含特殊字符、标点符号等；至少有一个字符
         • 语法：isalnum()
      4. isspace：空白符，包括空格、缩进、换行等不可见转义符
      5. startswith：startswith(prefix,start=0,end=len(str))
      6. endswith
      7. 补充：
         • in：判定一个字符串是否被另外一个字符串包含
         • not in

List（列表）

1. 概念：有序可变的元素集合

2. 定义

   1. 方式1
   2. 方式2
      1. 列表生成式
      2. 列表推导式：从一个list推到出另外一个list
         1. 概念
            • 映射解析：一对一变更
            • 过滤：从多到少
         2. 语法
            • [表达式 for 变量 in 列表]
            • [表达式]for 变量 in 列表 if 条件]
   3. 列表的嵌套
   4. 注意和c语言中数组的区别

3. 常用操作

   1. 增

      • append

        作用：往列表中增加一个新的元素（在列表的最后）

        语法：l.append(object)

        返回值：None

        注意：会直接修改原列表

      • insert

        作用：往列表中追加一个新的元素（在指定索引前面）

        语法：l.insert(index,object)

        返回值：None

        注意：会直接修改原列表

      • extend

        作用：往列表中扩展另外一个可迭代序列

        语法：l.extend(iterable)

        参数：iterable：可迭代集合，如字符串、列表、元组等

        返回值：None

        注意：会直接修改原列表

      • 乘法运算

        [“a”] * 3 = [‘a’,‘a’,‘a’]

      • 加法运算

        [“a”] + [“b”,“c”] = [“a”,“b”,“c”]

        和extend区别：只能列表类型和列表类型相加

   2. 删

      • del语句

        作用：可以删除一个指定元素（对象）

        语法：del 指定元素

        注意：可以删除整个列表、一个变量、more元素

      • pop

        作用：移除并返回列表中指定索引对应元素

        语法：l.pop(index=-1)

        返回值：被删除的元素

        注意：会直接修改原列表；注意索引越界

      • remove

        作用：移除列表中指定元素

        语法：l.remove(object)

        返回值：None

        注意：会直接修改原列表；如果元素不存在会报错；如果存在多个元素，则只会删除最左边一个；注意循环内删除列表元素带来的坑

   3. 改：names[index] = 666

   4. 查

      1. 获取单个元素：items[index]

      2. 获取元素索引：index()

      3. 获取指定元素个数：count()

      4. 获取多个元素：切片items[start：end:step]

      5. 遍历

         • 方式一：根据元素进行遍历

           for item in list:
               print(item)
           

         • 方式二：根据索引进行遍历

           for index in range(len(list)):
               print(index,list[index])
           

         • 方式三：创建对应的枚举对象，遍历枚举对象

           for idx,val in enumerate(values):
               print(idx)
               print(val)
               
           for tupleValue in enumerate(values):
               idx,val = tupleValue
               print(idx)
               print(val)
           

         • 方式四：使用迭代器进行遍历

   5. 其他操作

      1. 判定

         • 元素 in 列表
         • 元素 not in 列表

      2. 排序

         1. 方式一

            1. 内建函数：可以对所有可迭代对象进行排序

            2. 语法：sorted(itrearble,key=None,reverse=False)

            3. 参数：

               • itrearble：可迭代对象
               • key：排序关键字；值为一个函数，此函数只有一个参数且返回一个值用来比较
               • reverse：控制升序降序；默认为False，即升序

            4. 返回值：一个已经排好序的列表

            5. 案例：

               s = [("sz",18),("sz2",16),("sz1",17),("sz3",15)]
               def getKey(x):
                   return x[1]
               result = sorted(s,key=getKey,reverse=True)
               print(result)
               
               #[("sz",18),("sz1",17),("sz2",16),("sz3",15)]
               

         2. 方式二

            1. 列表对象方法
            2. 语法：list.sort(key=None,reverse=False)
            3. 参数：同上

      3. 乱序：random.shuffle(list)：随机打乱一个列表

      4. 比较

         • cmp()

           内建函数

           如果比较的是列表，则针对每个元素，从左到右逐一比较

           作用同c

           python3不支持

         • 比较运算符

           ==、>、<…

           针对每个元素，从左到右逐一比较

      5. 反转：l.reverse()；切片反转l[::-1]

Tuple（元组）

1. 概念：有序的不可变的元素集合（和列表的区别就是，元组元素不能修改）

2. 定义

   1. 一个元素的写法：(666,)

      注：(666)是int类型

   2. 多个元素的写法：(1,2,3)

   3. 多个对象，以逗号隔开，默认为元组：tuple = 1,2,3,"sz"

   4. 从列表转换成元组：tuple(seq)（内建函数）

   5. 补充：元组嵌套：元组中国的元素可以是元组

3. 常用操作

   1. 注：没有增删改（因为元组是不可变的）

   2. 查

      • 获取单个元素：tuple[index]
      • 获取多个元素：tuple[start:end：step]

   3. 其他操作

      • 获取

        • tuple.count(item)
        • tuple.index(item)
        • len(tup)
        • max(tup)
        • min(tup)

      • 判定

        • 元素 in 元组
        • 元素 not in 元组

      • 比较

        • cmp()内建函数：python3不支持
        • 比较运算符

      • 拼接

        • 乘法
        • 加法

      • 拆包

        a,b = (10,20)或a,b = 10,20

集合

1. 概念

   1. 无序的，不可随机访问的，不可重复的元素集合
   2. 与数学中的集合的概念类似，可对其进行交并补差等逻辑计算
   3. 分为可变集合和非可变集合
      • set可变集合
        • 增
        • 删
        • 改
      • frozenset不可变集合：创建好之后无法增删改

2. 定义

   1. 可变集合

      • s = {1,2,3,4}

      • s = set(iterable)

      • 集合推导式：

        s = set(x**2 for x in range(1,10) if x%2==0)
        s = {推导式}
        

   2. 不可变集合frozenset

      • fs = frozenset(iterable)

        其中iterable可以是字符串、列表、元组、字典等

        但为dict时，只会获取key作为set中的元素

      • 集合推导式：

        s = frozenset(x**2 for x in range(1,10) if x%2==0)
        

   3. 注意

      • 创建一个空集合时，需要使用set()或frozenset()，不能使用s={}：会被识别成为字典

      • 集合中的元素，必须是可哈希的值

        如果一个对象在自己的生命周期中有一哈希值是不可改变的，那么它就是可哈希的；

        暂时理解为元素是不可变类型

      • 如果集合中的元素出现重复，则会被合并为1个

3. 常用操作

   1. 单一集合操作

      1. 可变集合

         • 增：s.add(element)

         • 删:

           • s.remove(element)：返回值为None；如果集合中没有这个元素，则返回一个错误

           • s.discard(element)：返回值为None；若没有这个元素，则do nothing

           • s.pop()：

             随机删除并返回集合中的一个元素；若集合为空，则返回一个错误

           • s.clear()：返回值为None；

         • 改：元素是不可变类型，不能修改

         • 查

           • 无法通过索引或key进行查询
           • 通过for in 进行遍历
           • 通过迭代器进行访问

      2. 不可变集合

         • 不能增删改
         • 查
           • 通过for in进行遍历
           • 通过迭代器进行访问

   2. 集合之间操作

      1. 交集：

         • intersection(Iterable)

           • 字符串：只判定字符串中的非数字

           • 列表

           • 元组

           • 字典：只判定key

           • 集合

             。。。。。。

         • 逻辑与‘&’

         • intersection_update(…)

           交集计算完毕后，会再次赋值给原对象；

           会更改原对象；

           所以只适用于原对象是可变集合

      2. 并集

         • union()：返回并集
         • 逻辑或’|’：返回并集
         • update()：更新并集，返回值为None

      3. 差集

         • difference()
         • 算术运算符‘-’
         • difference_update()

      4. 判定

         • isdisjoint()：两个集合不相交
         • issuperset()：一个集合包含另一个集合
         • issubset()：一个集合包含于另一个集合

   3. 注意：可变与不可变集合混合运算，返回结果以运算符左侧为主

Dictory（字典）

1. 概念：无序的，可变的键值对集合

2. 定义

   1. 方式一

      {key1:value1,key2:value2}

      例如：{“name”:“sz”,“age”:18}

   2. 方式二

      fromkeys(seq,value=None)

      • 静态方法：类和对象都可以调用
      • 类调用：dict.fromkeys(“abc”,666)（此处的dict是指字典类型）：{‘a’:666,‘c’:666,‘b’:666}
      • 对象调用：dic.fromkeys(“abc”,666)（此处的dic是实例化的字典对象）：{‘a’:666,‘c’:666,‘b’:666}

   3. 注意

      • key不能重复：如果重复，后值会把前值覆盖

      • key必须是任意不可变类型：

        可变类型：列表、字典、可变集合等

        不可变类型：数值、布尔、字符串、元组等

      • 原因：

        • python的字典，采用哈希的方式实现

        • 简单存储过程：

          1. 初始化一个表格（哈希表），用来存放所有的值；

          2. 在存储一个键值对时，会作如下操作：

             • 根据给定的key，通过某些操作，得到一个在”哈希表“中的索引位置；

               • 把key通过”哈希函数“转换成一个整型数字，称为”哈希值“；

               • 将该数字对数组长度进行取余，取余结果就当作数组的下标；

               • 如果产生了”哈希冲突“：

                 比如两个不同的key计算出来的索引是同一个，则采用”开放寻址法“：通过探测函数查找下一个空位

             • 根据索引位置，存储给定的值

        • 简单查找过程：再次使用哈希函数将key转换为对应的列表的索引，并定位到列表的位置获取value

3. 存在意义

   • 可以通过key访问对应的值，使得这种访问更具意义：person[“name”]
   • 查询效率得到很大提升：可想象”汉字字典“的使用方式

4. 常用操作

   1. 增：dic[key] = value

   2. 删

      • del dic[key]

      • dic.pop(key[,default])

        删除指定的键值对，并返回对应的值；

        如果key不存在，则返回给定的default值；

        不作删除动作

        如果没有给定默认值，则报错

      • dic.popitem()

        删除按升序排序后的第一个键值对，并以元组的形式返回该键值对

        如果字典为空，则报错

      • dic.clear()

        删除字典内所有键值对，返回None

        注意：字典对象本身还存在，只不过内容被清空了

        注意和del的内容

   3. 改

      • 只能改值，不能改key

      • 修改单个键值对：dic[key] = value

      • 批量修改键值对：oldDic.update(newDic)

        根据新的字典，批量更新旧字典中的键值对；如果旧字典没有对应的key，则新增键值对

   4. 查

      • 获取单个值

        • 方式一：dic[key]

          如果key不存在，则会报错

        • 方式二：dic.get(key[,default])

        • 方式三：dic.setdefault(key[,default])

      • 获取所有值：dic.values()

      • 获取所有键：dic.keys()

      • 获取字典的键值对：dic.items()

      • 遍历

        • for key in d.keys()
        • for key,value in d.items()

      • 注意

        • python2和python3版本之间关于获取键、值、item之间的区别

          python2直接是一个列表：可通过下标进行获取指定元素

          python3是Dictionary view objects

        • 在python2中提供了如下方法：

          • viewkeys()
          • viewvalues()
          • viewitems()
          • 作用如同python3中的Dictionary view objects

   5. 计算

      • len(info)：键值对的个数

   6. 判定

      • x in dic
      • x not in dic
      • dic.has_key(key)：已过期，建议使用in来代替

时间日历

1. python程序能用很多方式处理日期和时间，转换日期格式是一个常用功能。

2. 常用操作

   1. time模块

      • 提供了处理时间和表示之间转换的功能

      • 获取当前时间戳

        • 概念：从0时区的1970年1月1日0时0分0秒，到所给定日期时间的秒数；浮点数

        • 获取方式

          import time
          time.time()
          

      • 获取时间元组

        • 概念：很多python时间函数将时间处理为9个数字的元组

          [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-jRZA5d78-1637059730356)(images/KGT8VB${9T7YF319K{08A6B.jpg)]

        • 获取方式

          import time
          time.localtime([seconds])
          #seconds:可选的时间戳；默认是当前时间戳
          

      • 获取格式化的时间

        • 秒->可读时间

          import time
          time.ctime([seconds])
          #可选的时间戳；默认当前时间戳
          

        • 时间元组->可读时间

          import time
          time.asctime([p_tuple])
          #可选的时间元组；默认是当前时间元组
          

      • 格式化日期字符串<–>时间戳

        • 时间元组->格式化日期：time.strftime(格式字符串，时间元组)

          import time
          time.strftime("%Y-%m-%d %H:%M:%S",time.localtime())
          

        • 格式化日期->时间元组：time.strptime(日期字符串，格式符字符串)

          时间元组->时间戳：time.mktime(时间元组)

        • 常用格式符

          %y：两位数的年份表示（00-99）

          %Y：四位数的年份表示（000-9999）

          %m：月份（01-12）

          %d：月内中的一天（0-31）

          %H：24小时制小时数（0-23）

          %I：12小时制小时数（01-12）

          %M：分钟数（00-59）

          %S：秒（00-59）

          %a：本地简化星期名称

          %A：本地完整星期名称

          %b：本地简化的月份名称

          %B：本地完整的月份名称

          %c：本地相应的日期表示和时间表示

      • 获取当前CPU时间：time.clock()：浮点数的秒数，可用于来统计一段程序代码的执行耗时

      • 休眠n秒：time.sleep(secs)，推迟线程的执行，可简单理解为让程序暂停

   2. calendar模块

      • 提供与日历相关的功能，比如：为给定的月份或年份打印文本日历的功能

      • 获取某月日历

        import calendar
        calendar.month(2017,9)
        

   3. datetime模块

      • python处理日期和时间的标准库：这个库里面有datetime类、data类、time类；可以做一些计算之类的操作

      • 获取当前日期

        import datetime
        print(datetime.datetime.now())
        print(datetime.datetime.today())
        

      • 单独获取当前的年月日时分秒

        import datetime
        now = datetime.datetime.now()
        print(now.year)
        print(now.month)
        print(now.day)
        print(now.hour)
        print(now.minute)
        print(now.second)
        

      • 计算两个日期的天数差

        import datetime
        first = datetime.datetime(2017,9,1,12,0,0)
        second = datetime.datetime(2017,9,2,12,0,0)
        result = second - first
        print(result)
        

      • 获取两个日期时间的时间差

        import datetime
        first = datetime.datetime(2017,9,1,12,0,0)
        second = datetime.datetime(2017,9,2,12,0,0)
        result = second - first
        print(result.total_seconds())
        

      • 计算n天之后的日期

        import datetime
        now = datetime.datetime.now()
        future = now + datetime.timedelta(days=7)
        print(future)
        

访问集合的方式——迭代器

1. 概念

   1. 迭代
      • 是访问集合元素的一种方式
      • 按照某种顺序逐个访问集合中的每一项
   2. 可迭代对象
      • 能够被迭代的对象，称为可迭代对象
      • 判定依据：能作用于for in
      • 判定方法：import collections isinstance(obj,collections.Iterable)
   3. 迭代器
      • 是可以记录遍历位置的对象
      • 从第一个元素开始，往后通过next()函数，进行遍历
      • 只能往后，不能往前
      • 判定依据：能作用于next()函数
      • 判定方法：import collections isinstance(obj,collections.Iterator)
   4. 注意：迭代器也是可迭代对象，所以也可以作用于for in

2. 为什么会产生迭代器

   1. 仅仅在迭代到某个元素时才处理该元素

      • 在此之前，元素可以不存在
      • 在此之后，元素可以被销毁
      • 特别适合于遍历一些巨大的或无限的集合

   2. 提供了一个统一的访问集合的接口

      • 可以把所有的可迭代读写，转化成迭代器进行使用

      • iter(Iterable)

        iter(str)

        iter(list)

        iter(tuple)

        iter(dict)

        …

3. 迭代器简单使用

   1. 使用next()函数，从迭代器中取出下一个对象，从第一个元素开始
   2. 因为迭代器比较常用，所以在python中，可以直接作用于for in
      • 内部会调用迭代器对象的next()
      • 会自动处理迭代完毕的错误

4. 注意事项

   1. 如果取出完毕，再继续取，则会报错：StopIteration
   2. 迭代器一般不能多次迭代

NoneType（空类型）

查看类型：

print(type(8)