python常用数据类型操作

最新推荐文章于 2024-07-27 17:39:19 发布

诺顿与苏菲

最新推荐文章于 2024-07-27 17:39:19 发布

阅读量271

点赞数 1

分类专栏： python基础文章标签： python

本文链接：https://blog.csdn.net/qq_44866009/article/details/121362493

版权

python基础专栏收录该内容

5 篇文章 1 订阅

订阅专栏

Numbers（数值类型）

表现形式
- 整数int：二0b、八0/0o、十、十六进制0x
- long
- 浮点数float
  - 可以使用科学计数法表示：1.68e3
  数complex
- 注意：python3的整型，可以自动的调整大小，当作long类型使用
进制转换
常用操作
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（布尔类型）

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

String（字符串）

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

概念：由单个字符组成的一个有序集合
字符串操作
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. 方式1
2. 方式2
  1. 列表生成式
  2. 列表推导式：从一个list推到出另外一个list
    1. 概念
      - 映射解析：一对一变更
      - 过滤：从多到少
    2. 语法
      - [表达式 for 变量 in 列表]
      - [表达式]for 变量 in 列表 if 条件]
3. 列表的嵌套
4. 注意和c语言中数组的区别
常用操作
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. 一个元素的写法：(666,)
  
  注：(666)是int类型
2. 多个元素的写法：(1,2,3)
3. 多个对象，以逗号隔开，默认为元组：tuple = 1,2,3,"sz"
4. 从列表转换成元组：tuple(seq)（内建函数）
5. 补充：元组嵌套：元组中国的元素可以是元组
常用操作
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. 无序的，不可随机访问的，不可重复的元素集合
2. 与数学中的集合的概念类似，可对其进行交并补差等逻辑计算
3. 分为可变集合和非可变集合
  - set可变集合
    - 增
    - 删
    - 改
  - frozenset不可变集合：创建好之后无法增删改
定义
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个
常用操作
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. 方式一
  
  {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
存在意义
- 可以通过key访问对应的值，使得这种访问更具意义：person[“name”]
- 查询效率得到很大提升：可想象”汉字字典“的使用方式
常用操作
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来代替

时间日历

python程序能用很多方式处理日期和时间，转换日期格式是一个常用功能。
常用操作
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. 迭代
  - 是访问集合元素的一种方式
  - 按照某种顺序逐个访问集合中的每一项
2. 可迭代对象
  - 能够被迭代的对象，称为可迭代对象
  - 判定依据：能作用于for in
  - 判定方法：import collections isinstance(obj,collections.Iterable)
3. 迭代器
  - 是可以记录遍历位置的对象
  - 从第一个元素开始，往后通过next()函数，进行遍历
  - 只能往后，不能往前
  - 判定依据：能作用于next()函数
  - 判定方法：import collections isinstance(obj,collections.Iterator)
4. 注意：迭代器也是可迭代对象，所以也可以作用于for in
为什么会产生迭代器
1. 仅仅在迭代到某个元素时才处理该元素
  - 在此之前，元素可以不存在
  - 在此之后，元素可以被销毁
  - 特别适合于遍历一些巨大的或无限的集合
2. 提供了一个统一的访问集合的接口
  - 可以把所有的可迭代读写，转化成迭代器进行使用
  - iter(Iterable)
    
    iter(str)
    
    iter(list)
    
    iter(tuple)
    
    iter(dict)
    
    …
迭代器简单使用
1. 使用next()函数，从迭代器中取出下一个对象，从第一个元素开始
2. 因为迭代器比较常用，所以在python中，可以直接作用于for in
  - 内部会调用迭代器对象的next()
  - 会自动处理迭代完毕的错误
注意事项
1. 如果取出完毕，再继续取，则会报错：StopIteration
2. 迭代器一般不能多次迭代

NoneType（空类型）

查看类型：

print(type(8)

诺顿与苏菲

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
python常用数据类型操作

Numbers（数值类型）表现形式整数int：二0b、八0/0o、十、十六进制0xlong浮点数float可以使用科学计数法表示：1.68e3数complex注意：python3的整型，可以自动的调整大小，当作long类型使用进制转换常用操作适用于几乎所有python运算符算术运算符复合运算符比较运算符逻辑运算符注意当int和float类型进行算数运算时，结果会被提升为float类型数值类型如果参与逻辑运算，参照的
复制链接

扫一扫

专栏目录