1. 技术文章
  2. Python数据类型——整型、布尔型、列表、元祖、字典

Python数据类型——整型、布尔型、列表、元祖、字典

由 微笑、不失礼 提交于 2020-02-09 14:20:50

Python解释器可以自动识别用户输入的数据类型。创建对象的数据类型，可以通过type查看。需要注意的是：用户通过input输入的数据，其类型均为字符串

num1 = input("please input num1: ")
num2 = input("please input num2: ")
print("type of num1: ",type(num1),"type of num2: ",type(num2))
please input num1: test
please input num2: 123
type of num1:  <class 'str'> type of num2:  <class 'str'>

整型

整型可分为整型（32位机器上整型的取值范围为：-2* * 31~-2* *31）和长整型。Python2.7中会自动转换数字为整型、长整型。但在Python3.6中，不再有整型长整型之分。
Python中提供了10进制转换为其他进制的方法

  • 十进制转十六进制
>>> hex(10)
'0xa'
  • 十进制转八进制
>>> oct(10)
'0o12'
  • 十进制转二进制
>>> bin(10)
'0b1010'

在浮点数中，Python默认的精度为17位，这个精度越到后面越不准确。当我们的计算需要使用更高精度的时候，可以使用“getcontext”和"Decimal"的方式来实现

>>> a = 3.141592653002154564564
>>> a
3.1415926530021547
>>> from decimal import *
>>> getcontext()
Context(prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999, capitals=1, clamp=0, flags=[], traps=[InvalidOperation, DivisionByZero, Overflow])
>>> getcontext().prec = 50
>>> a = Decimal(1)/Decimal(3)
>>> a
Decimal('0.33333333333333333333333333333333333333333333333333')

整型的常用方法

  1. int：强制类型转换

    >>> a = "0xa"
>>> print(int(a,base=16))
10

  2. bit_length：整数转换成二进制后所占最少bit位数

    >>> a = 10
>>> print(a.bit_length())
4
>>> print(bin(a))
0b1010

布尔型

包含True（非0）和False（0）。注意首字母大写。以下内容均为False：

  • None，空；
  • ""，空字符串
  • ()，空元祖；
  • []，空列表；
  • {}，空字典
  • 数值0（整型、浮点型、复数）；
a = ("", (), [], {}, 0, 1, 1.1, 0.0, 0+0j,)
for i in a :
    if i :
        print("it is True.",i)
    else :
        print("it is False.",i)
it is False. 
it is False. ()
it is False. []
it is False. {}
it is False. 0
it is True. 1
it is True. 1.1
it is False. 0.0
it is False. 0j

列表

  • 列表的形式：使用中括号括起来
list #类，列表
li = [1,2,3,"li","liu"]   #通过list类创建的对象
  • 列表可以嵌套使用：
>>> li = ["test",223,"123",["12","ads"],{"name":"tuple"}]
>>> print(li[4]["name"])
tuple
  • 列表中的元素可以是：数字、字符串、列表、布尔值、字典（注意字典的无序特性）
  • 对列表进行切片后，所得到的数据还是列表
>>> li = ["test",223,"123",["12","ads"],{"name":"tuple"}]
>>> print(li[0:2],type(li[0:3]))
['test', 223] <class 'list'>
  • 支持for、while循环提取所有子序列
li = ["test",223,"123",["12","ads"],{"name":"tuple"}]
l = len(li)
num = 0
for i in li :
    print(i)
while num < l :
    print(li[num])
    num += 1
  • 字符串在内存中的地址是连续的，所以字符串的数值一旦发生改变，就需要重新开辟新的内存空间。而列表不一样，它的子序列的存储地址是非连续的，元素的内容可以被修改，被修改后元素对应的内存地址不会发生改变。这是因为每个元素是采用链表的形式存储的（即每个元素的内存空间中，不仅存放了元素的数值，而且还有下一个元素的内存地址）。列表的元素可以使用索引进行修改，也可以使用切片的方法进行修改
>>> li = ["test",223,"123",["12","ads"],{"name":"tuple"}]
>>> li[1] = "liu"
>>> li[2:4] = ["liu",234]
>>> print(li)
['test', 'liu', 'liu', 234, {'name': 'tuple'}]
  • 列表元素的删除
>>> li = ["test",223,"123",["12","ads"],{"name":"tuple"}]
>>> del li[0]
>>> del li[0:2]
>>> print(li)
[['12', 'ads'], {'name': 'tuple'}]
  • 如果列表的元素中存在列表或者字符串的话，可以对元素再进行索引或切片
  • 如果将一个字符串转换成list后，会将字符串中的每个元素转换成列表。int类型的对象不能转换成list
>>> string = "python"
>>> print(list(string))
['p', 'y', 't', 'h', 'o', 'n']
  • 列表转换成字符串的时候，需要自己写for循环。当列表中的元素只有字符串时，可以直接使用join
li = ["test",223,"123",["12","ads"],{"name":"tuple"}]
l = len(li)
r = range(0,l)
s = ""
for i in r :
    s += str(li[i])
print(s)
li02 = ["liu","hao","hai"]
print("".join(li02))
test223123['12', 'ads']{'name': 'tuple'}
liuhaohai

列表的常用方法

  1. append：在列表元素的最后进行追加（不需要对append进行赋值操作）

    >>> li = ["asd","fgh","liu"]
>>> li.append("hai")
>>> li.append(["lhh",123])
>>> print(li)
['asd', 'fgh', 'liu', 'hai', ['lhh', 123]]

  2. clear：清空列表

    >>> li = ["asd","fgh","liu"]
>>> li.clear()
>>> print(li)
[]

  3. copy：（浅）拷贝

    >>> li = ["asd","fgh","liu"]
>>> v = li.copy()
>>> print(v)
['asd', 'fgh', 'liu']

  4. count：计算列表中元素出现的次数

    >>> li = [11,22,33,22,11]
>>> print(li.count(22))
2

  5. extend：将extend后参数中每一个元素迭代append到原列表中。注意和append的区别

    >>> li = [11,22,33,22,11]
>>> li.extend(["asd",44])
>>> print(li)
[11, 22, 33, 22, 11, 'asd', 44]
>>> li.append(["asd",44])
>>> print(li)
[11, 22, 33, 22, 11, 'asd', 44, ['asd', 44]]

  6. index：查看指定元素在列表中的下标

    >>> li = [11,22,33,22,11]
>>> print(li.index(22))
1
>>> print(li.index(23))
Traceback (most recent call last):
 File "<stdin>", line 1, in <module>
ValueError: 23 is not in list

  7. insert：在列表中指定的下标前插入对象

    >>> li = [11,22,33,22,11]
>>> print(li.insert(1,["lhh",360]))
None
>>> li.insert(1,["lhh",360])
>>> print(li)
[11, ['lhh', 360], ['lhh', 360], 22, 33, 22, 11]

  8. pop：剔除指定下标的元素（默认剔除最后一个），并提取该元素的数值

    >>> li = [11,22,33,22,11]
>>> li.pop(2)
33
>>> print(li)
[11, 22, 22, 11]

  9. remove：从左开始删除指定元素，当列表中同时存在多个相同的元素是，删除第一个匹配的元素

    >>> li = [11,22,33,22,11]
>>> li.remove(22)
>>> print(li)
[11, 33, 22, 11]

  10. reverse：将列表中的元素反转显示

    >>> li = [1,2,3,4]
>>> li.reverse()
>>> print(li)
[4, 3, 2, 1]

  11. sort：将列表中的元素进行排序（默认为升序：reverse=False）

    >>> li = [1,2,3,4,8,5]
>>> li.sort()
>>> print(li)
[1, 2, 3, 4, 5, 8]
>>> li = [1,2,3,4,8,5]
>>> li.sort(reverse=True)
>>> print(li)
[8, 5, 4, 3, 2, 1]

元祖

  • 表现形式：使用小括号括起来的。元祖中的低级元素不可被修改，不支持增加删除
>>> tuple1 = (12,"dad",True,[12,23],(2,3,4),{"name":"lhh"})
>>> print(tuple1)
(12, 'dad', True, [12, 23], (2, 3, 4), {'name': 'lhh'})
>>> tuple1[0] = "123"
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment
>>> tuple1[3][1] = "lhh"
>>> print(tuple1)
(12, 'dad', True, [12, 'lhh'], (2, 3, 4), {'name': 'lhh'})
  • 元组中的元素可以是：字符串、数字、布尔值、列表、元组、字典
  • 为了防止和类的方法混淆，一般元祖的最后，加上一个“，”，而元祖的长度不会发生变化
  • 可以使用索引、切片查看元祖的元素，但是不能对元素增删。可以被for/while循环
>>> tuple1 = (12,"dad",True,[12,23],(2,3,4),{"name":"lhh"})
>>> print(tuple1[0:3])
(12, 'dad', True)
>>> for i in tuple1 :
...     print(i)
...
12
dad
True
[12, 23]
(2, 3, 4)
{'name': 'lhh'}
  • 字符串、列表都可以转换为元祖
>>> string = "python"
>>> li = ["lhh",360,True]
>>> print(tuple(string),tuple(li),sep="\n")
('p', 'y', 't', 'h', 'o', 'n')
('lhh', 360, True)
  • 元祖可以转换成字符串、列表
>>> tu = (123,"asd",True)
>>> print(list(tu))
[123, 'asd', True]
tu = (123,"asd",True)
s = ""
for i in tu :
    s += str(i)
print(s)
123asdTrue

元组的常用方法

  1. count：统计元祖中指定元素出现的次数

    >>> tu = (11,22,33,2,22,)
>>> print(tu.count(22))
2

  2. index：统计指定元素在元组中的下标。出现多个相同元素时，从左开始取第一个匹配的下标

    >>> tu = (11,22,33,2,22,)
>>> print(tu.index(22))
1

字典

  • 形式：使用大括号括起来。字典的键值对（key:value）中，value的类型可以是任意数据类型

    info = {
"k1":"string",
"k2":123,
"k3":False,
"k4":(123,"sd","hda"),
"k5":["sdf",23],
"k6":{
    "kk1":"sdf",
    "kk2":123
}
}
print(info)
{'k1': 'string', 'k2': 123, 'k3': False, 'k4': (123, 'sd', 'hda'), 'k5': ['sdf', 23], 'k6': {'kk1': 'sdf', 'kk2': 123}}

  • 列表、字典不能作为字典的key

    info = {
1:"string",
False:123,
(11,22):False,
#[11,22]:123,
#{"k1":"v1"}:123
}
print(info)
{1: 'string', False: 123, (11, 22): False}

  • 字典是无序的，无法通过切片的方式读取元素的值。可以通过Key值，使用索引读取某一个元素

>>> info = {1: 'string', False: 123, (11, 22): False}
>>> print(info[1])
string
  • 可以使用for循环提取字典中的key、value、key和value
info = {
    1:"string",
    False:123,
    (11,22):False,
}
for i in info :
    print(i)
for i in info.keys() :
    print(i)
for i in info.values() :
    print(i)
for i in info.items() :
    print(i)
for i,j in info.items() :
    print(i,j)
1
False
(11, 22)
1
False
(11, 22)
string
123
False
(1, 'string')
(False, 123)
((11, 22), False)
1 string
False 123
(11, 22) False
  • 字典元素的删除
info = {
    "k1":"v1",
    1:True,
    ("k3"):{
        "kk1":"lhh",
        "kk2":123,
        "kk3":False,
    }
}
del info[("k3")]["kk3"]
print(info)
{'k1': 'v1', 1: True, 'k3': {'kk1': 'lhh', 'kk2': 123}}

字典的常用方法

  1. clear ：清空字典中的所有元素

    >>> info = {1: 'string', False: 123, (11, 22): False}
>>> info.clear()
>>> print(info)
{}

  2. copy：（浅）拷贝

    >>> info = {1: 'string', False: 123, (11, 22): False}
>>> info_bak = info.copy()
>>> print(info_bak)
{1: 'string', False: 123, (11, 22): False}

  3. fromkeys：根据序列，创建字典，并为key指定统一的value。使用格式为dict.fromkyes()，而不是"dict类名称.fromkey()"。fromkeys方法后最多只能只能有2个参数，分别对应key/value。当只有1个参数时，创建的字典的value为None

    >>> dict.fromkeys(("asdf",123,False))
{'asdf': None, 123: None, False: None}
>>> dict.fromkeys(("asdf",123,False),123)
{'asdf': 123, 123: 123, False: 123}

  4. get：根据key，获取value的值。如果key不存在，返回指定的值

    >>> info = {1: 'string', False: 123, (11, 22): False}
>>> print(info.get(1))
string
>>> print(info.get(True))
string
>>> print(info.get("None"))
None
>>> print(info.get("None","space"))
space

  5. items：返回字典中的keys和values

    >>> info = {1: 'string', False: 123, (11, 22): False}
>>> info.items()
dict_items([(1, 'string'), (False, 123), ((11, 22), False)])

  6. keys：返回字典中的Keys

    >>> info = {1: 'string', False: 123, (11, 22): False}
>>> info.keys()
dict_keys([1, False, (11, 22)])

  7. pop：删除字典中指定key对应的键值对。如果key在字典中不存在，则返回None或者指定的值

    >>> info = {1: 'string', False: 123, (11, 22): False}
>>> info.pop(False)
123
>>> print(info)
{1: 'string', (11, 22): False}
>>> info.pop("space","NONE")
'NONE'
>>> print(info)
{1: 'string', (11, 22): False}

  8. popitem：删除字典最后一个元素，返回值为该元素的key:value

    >>> info = {1: 'string', False: 123, (11, 22): False,"k1":"v1","k2":"v2"}
>>> info.popitem()
('k2', 'v2')
>>> n,m = info.popitem()
>>> print(n,m)
k1 v1

  9. setdefault：设置字典元素的value值。如果元素中有存在的Key，不做任何操作；如果元素中没有对应的key，则在字典中的最后添加一个元素，元素对应的key:value，就是setdefault的2个参数

    >>> info = {1: 'string', False: 123, (11, 22): False,"k1":"v1","k2":"v2"}
>>> info = {1: 'string', False: 123, (11, 22): False}
>>> info.setdefault(1,"STR")
'string'
>>> print(info)
{1: 'string', False: 123, (11, 22): False}
>>> info.setdefault("k1","value")
'value'
>>> print(info)
{1: 'string', False: 123, (11, 22): False, 'k1': 'value'}

  10. update：更新字典元素对应的value。如果key不存在的则直接添加这个key:value，如果存在，则修改这个key对应的value值

    >>> info = {1: 'string', False: 123, (11, 22): False}
>>> info.update({1:"new_str"})
>>> print(info)
{1: 'new_str', False: 123, (11, 22): False}

  11. values：获取字典元素的value值

    >>> info = {1: 'string', False: 123, (11, 22): False}
>>> print(info.values())
dict_values(['string', 123, False])

可变数据类型和不可变数据类型

根据对象元素的数值是否可被修改，可以将数据类型分为可变数据类型和不可变数据类型。到目前为止，不可变数据类型有：整型、字符串、元祖。可变数据类型有：列表、字典。可变数据类型是能够被hash的。如果一个对象不能被hash的话，那么这个对象一定为可变数据类型。

标签
info
python for循环
python字符串操作
整型数据
布尔类型
asd
string
python
易学教程内所有资源均来自网络或用户发布的内容，如有违反法律规定的内容欢迎反馈！
该文章没有解决你所遇到的问题?点击提问,说说你的问题,让更多的人一起探讨吧!