码迷,mamicode.com
首页 > 编程语言 > 详细

python数据类型基础总结(字符串 列表 元组 字典 集合 )

时间:2019-08-28 22:36:58      阅读:112      评论:0      收藏:0      [点我收藏+]

标签:cti   不可变   定位   不用   加工   one   字符串方法   遍历   apc   

字符串:
有序、不可变数据类型,支持索引,切片,步长(字符串中的每一个字母或字符都称为元素)
索引(下标):通过索引精确定位到每个元素
索引从左开始向右排 从0开始 索引时不能超过最大值,超出报错 从右向左排从-1开始
切片(顾头不顾尾)
步长 print(name[::2] 取整个字符串,步长为2
字符串方法:

  upper 全部大写   lower全部小写     capitalize  首字母大写     title每个单词的首字母大写    
  swapcase 大小写转换
  starswith 以..开头   endswith  以..结尾    
  center  居中 (填充)
  find 查找(通过元素查找索引,找不到返回-1)    index 查找(通过元素查找索引,查找不到报错)
  join 拼接 (将列表转化为字符串) print("_".join(["1","2","4"]))
  count 统计     strip脱去两端的空格换行以及制表符
  split 分割 (以空格和换行以及制表符进行分割,也可以以指定的方式进行分割)
  replace 替换 format 字符串格式化

判断系列(is)
   isdecimal 判断是否是十进制
   isalnum  判断是否是字母中文 数字
   isalpha 判断是否是字母中文
   isdigit 判断是否是全部是阿拉伯数字

列表(关键字:list):它是以[]括起来,每个元素以逗号隔开,可以存放各种数据类型
可变有序的数据类型 支持索引,切片,步长和增删改查
列表的增:append insert extend
insert 方法用于将对象插入到列表中,而append方法则用于在列表末尾追加新的对象,
extend 把一个可迭代对象打开.每一项拿出来追加到list中 ,他们三个有个共同点就是没有返回值。
列表的删:remove pop del clear
1、 pop. 向外弹出最后一个或指定元素的索引,有返回值,可用一个变量接受被删除的内容,指定索引不存在时,会报错。
2、remove 指定元素进行删除 是元素不是索引,删除不存在的元素会报错。
3、 clear 清空列表
4、del 列表 将整个列表删除切片删除
del lst[1:3] 将指定切片范围内的元素进行删除
列表的改:索引、切片、步长
索引修改 li1 = [1, 2, 3, {‘a‘:1, ‘b‘:2}] li1[0] = ‘a‘ # 改变1
切片修改(范围或区间)不带步长或者是步长为1的切片,则不用关心切片与修改的元素个数是否相等。
注意:步长不为1,要注意切片内的元素个数是否与更改的值是否相等。 如果步长不是1, 要注意. 元素的个数必须相同
列表的查:
for循环
列表的嵌套:[......] 视为一个元素

列表的其他:
1、count
查询列表中某个元素出现的次数
c = lst.count("太白") # 查询太白出现的次数
2、降序
lst.sort(reverse=True)
lis.sort(func=None, key=None, reverse=False(or True))
与sorted 的区别是sort是原地修改,只能用于列表,而sorted是返回一个新的序列,可以用在任意一个可迭代对象中
3、reverse
原地翻转
lst.reverse()
4、len
列表的长度

5、index
     返回从左到右列表中某个元素出现的第一个索引值

列表推导式
[变量(加工后的变量) for 变量 in 列表] 循环模式

列表sort()添加key和reverse参数操作方法
sort()是python列表排序方法,key和reverse更是经常用到的sort方法另外两个可选参数。使用时要通过关键字参数,也就是名字来指定。
key在sort()函数中的作用,使用时都需要提供可以做为排序依据的函数。比如说我们有一个列表,要以列表内元素的长度来排序,那么就需要用到计算长度的len()函数
x = [‘hello‘,‘abc‘,‘iplaypython.com‘]
>>> x.sort(key=len)
>>> x
[‘abc‘, ‘hello‘, ‘iplaypython.com‘]
当然做为key排序依据的函数,不仅仅是len,只要按照你的需求写入对应的函数就可以。假如需要以整型数字来排序,就需要用到int:

    >>> a = ['3','188','50','1225']
    >>> a.sort(key=int)
    >>> a
    ['3', '50', '188', '1225']

    sort()还有另外一个关键字参数,就是reverse,它是一个布尔值True/False,作用是用来决定是否要对列表进行反向排序

        >>> a.sort(key=int,reverse=True)
        >>> a
        ['1225', '188', '50', '3']

l st = [1,23,4,5,7,8,9]
print(lst.index(4)) # 通过元素查找索引
lst.sort() # 排序 默认是升序
lst.sort(reverse=True) # 降序
print(lst)

        lst = [1,23,4,5,7,8,9]
        lst.sort()
        lst.reverse()             # 人工降序
        print(lst)

        lst = [1,23,4,5,7,8,9]
        lst.reverse()
        print(lst)               # 将源数据进行反转

        lst = [1,23,4,5,7,8,9]
        lst1 = lst[::-1]
        print(lst)
        print(lst1)              # 不修改源数据进行反转

        lst = [1,2,3,4]
        lst = lst + [1,2,3]
        print(lst)  # [1,2,3,4,[1,2,3],]   [1,2,3,4,1,2,3]

        lst = [1,2,3] * 5
        print(lst)
        print(id(lst[0]),id(lst[3]))

元组(关键字:tuple):
有序,不可变数据类型(只有查)

range范围:
range(1,10)[起始位置:终止位置]顾头不顾尾,可迭代对象
range(1,10,2)[起始位置:终止位置:步长]
? (10代表的是终止位置,起始位置默认为0)
range的诞生是为了解决不能循环数字

字典(关键字:dict):所有的操作都是通过键
无序可变的数据类型
键:必须是不可变数据类型, 值是任意的

    字典的增:通过键值对添加(强加)
                       字典名['键]="值"
                      有则不加,无则不加
                        字典名.setdefault(键    , 值     )
    字典的删:pop  clear  del   字典中没有remove
                       字典名.pop()    通过字典的键进行删除
                       字典名clear()  清空整个列表
                       del.字典名[''键”]  通过键进行删除  
     字典的改                 
                   字典名['键]="值"
                    update
                        d={'x':5}
                        c={'12':65}
                        c.update(d)
                        print(c)

    字典的查
        dic.get("键") 查询不到返回None,查找不到的时候,返回自己制定的内容
        dic.setdefault(" 键 ")查询不到返回None
        print(dic.keys( ))    获取一个键高仿列表
        print(dic.values())获取一个值高仿列表
        高仿列表支持迭代,不支持索引
      for i in dic :
      print(i,dic[i])   打印键值
        lst.append(i,dic[i])

        for i in dic.items():
        print(lst(dic.items()))

    字典的其他:
        dic = {"key":1,"key1":2,"key2":4,"key3":1}
        print(dic.popitem())   # 随机删除  python3.6版删除最后一个键值对
        # popitem返回的是被删除的键值对
        print(dic)

集合(关键字:set) 集合就是没有值的字典(天然去重)
可变 无序的数量类型
一行代码去重
print(list(set(去重的内容))
集合的增:add(直接添加) update(迭代添加)
集合的删:remove(指定元素删除) clear(清空) pop(随机删,通常是最小的)
集合的改: 先删后加
集合的查: 只有for循环

集合的其他操作
s1 = {"刘能", "赵四", "???"}
s2 = {"刘科?", "冯乡?", "???"}
交集
两个集合中的共有元素
print(s1 & s2) # {‘???‘}
print(s1.intersection(s2)) # {‘???‘}
并集
print(s1 | s2) # {‘刘科?‘, ‘冯乡?‘, ‘赵四‘, ‘???‘, ‘刘能‘}
print(s1.union(s2)) # {‘刘科?‘, ‘冯乡?‘, ‘赵四‘, ‘???‘, ‘刘能‘}
差集
print(s1 - s2) # {‘赵四‘, ‘刘能‘} 得到第?个中单独存在的
print(s1.difference(s2)) # {‘赵四‘, ‘刘能‘}
反交集
print(s1 ^ s2) # 两个集合中单独存在的数据 {‘冯乡?‘, ‘刘能‘, ‘刘科?‘, ‘赵四‘}
print(s1.symmetric_difference(s2)) # {‘冯乡?‘, ‘刘能‘, ‘刘科?‘, ‘赵四‘}
s1 = {"刘能", "赵四"}
s2 = {"刘能", "赵四", "???"}
?集
print(s1 < s2) # set1是set2的?集吗? True
print(s1.issubset(s2))
超集
print(s1 > s2) # set1是set2的超集吗? False
print(s1.issuperset(s2))

数据类型的各种转换

str -- int
int -- str
str -- bool
bool -- str
int -- bool
bool -- int

list -- tuple 元组
lst = [1,23,5,4]
print(tuple(lst))

tuple -- list
tu = (1,23,5,4)
print(list(tu))

list -- set
lst = [1,23,12,31,23]
print(set(lst))

set -- list

tuple -- set
tu = (1,2,3,4,5)
print(set(tu))

set -- tuple

目前字典转换,自己实现方法
例:有字符串"k: 1|k1:2|k2:3 |k3 :4" 处理成字典 {‘k‘:1,‘k1‘:2,‘k3‘:4}
dic = {}
a=a.split(‘|‘)
print(a)
for i in a:
print(i)
i=i.split(‘:‘)
dic.setdefault(i[0],int(i[1]))
print(dic)

字典和集合在遍历(循环)时不能修改原来的大小(字典的长度),可以进行修改值
s = {1,2,3,4,5,6}
for i in s:
s.pop()
print(s)

python数据类型基础总结(字符串 列表 元组 字典 集合 )

标签:cti   不可变   定位   不用   加工   one   字符串方法   遍历   apc   

原文地址:https://www.cnblogs.com/python111/p/11426752.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!