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

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')

整型的常用方法

int：强制类型转换

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

```

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

列表的常用方法

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

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

```

clear：清空列表

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

```

copy：（浅）拷贝

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

```

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

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

```

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]]

```

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

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

```

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]

```

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

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

```

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

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

```

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

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

```

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

元组的常用方法

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

tu = (11,22,33,2,22,)
print(tu.count(22))
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}}

字典的常用方法

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

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

```

copy：（浅）拷贝

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

```

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)

```

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

```

items：返回字典中的keys和values

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

```

keys：返回字典中的Keys

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

```

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)

```

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

```

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)

```

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

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

```

values：获取字典元素的value值

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

```

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

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

posted @ 2018-12-04 16:54 Hurst_Liu 阅读(609) 评论(0) 编辑收藏举报

会员力量，点亮园子希望

刷新页面返回顶部

Hurst_Liu

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

整型

布尔型

列表

元祖

字典

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

公告