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 "<stdin>", line 1, in <module> 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) {1: 'string', False: 123, (11, 22): False}
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}
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) {1: 'string', (11, 22): False}
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) {1: 'string', False: 123, (11, 22): False, 'k1': 'value'}
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}
values:获取字典元素的value值
>>> info = {1: 'string', False: 123, (11, 22): False} >>> print(info.values()) dict_values(['string', 123, False])
可变数据类型和不可变数据类型
根据对象元素的数值是否可被修改,可以将数据类型分为可变数据类型和不可变数据类型。到目前为止,不可变数据类型有:整型、字符串、元祖。可变数据类型有:列表、字典。可变数据类型是能够被hash的。如果一个对象不能被hash的话,那么这个对象一定为可变数据类型。
转载于:https://www.cnblogs.com/hurst/p/10065134.html
Python数据类型——整型、布尔型、列表、元祖、字典相关推荐
- python字典、列表、元祖使用场景_python学习第七讲,python中的数据类型,列表,元祖,字典,之元祖使用与介绍...
python学习第七讲,python中的数据类型,列表,元祖,字典,之元祖使用与介绍 一丶元祖 1.元祖简介 元祖跟列表类似.只不过是有区别的. 如下: tuple(元祖英文) 跟列表类似, 元素不能 ...
- python学习第八讲,python中的数据类型,列表,元祖,字典,之字典使用与介绍
目录 python学习第八讲,python中的数据类型,列表,元祖,字典,之字典使用与介绍.md 一丶字典 1.字典的定义 2.字典的使用. 3.字典的常用方法. python学习第八讲,python ...
- python 常用字符串 列表元祖字典都 自带的函数方法
上节内容回顾和补充编程语言高级低级Python种类JavaPythoncPython *****pypy字节码 和 机器码Python程序:1. 终端:C:\python35\python.exe D ...
- python 列表 元祖 字典,Python 列表、元组、字典
可变数据类型和不可变数据类型 python里的数据都是保存在内存里的,python里的数据又分为可变类型和不可变类型: 1不可变数据类型:字符串.数字.元组,如果修改值,内存地址会发生变化: 2可变数 ...
- python列表元祖字典集合运算_Python基础5:列表 元祖 字典 集合 Json
[ 列表] 列表(list)是Python以及其他语言中最常用到的数据结构之一.Python使用使用中括号 [ ] 来解析列表. 列表是可变的(mutable)--即:可以改变列表的内容. 相关操作: ...
- python 列表 元祖 字典 集合_python基础知识之列表、元祖、字典、集合、字符串。...
1.可变类型之列表 列表用 [ ]来定义是可变的,可以通过索引值来去查询里面的字段可以可以追加,删除等 ```python names='zhangyang guyun xiangpeng xulia ...
- 列表 元祖 字典
1.列表 形如list1 = ['cat',1,3.4],由[ ]括起来的一组序列称为列表,属于可变数据类型.列表中的元素可以是任意数据类型,整型,浮点型,字符串类型,甚至可以是列表.元祖或者字典. ...
- python,看看有没有你需要的列表元祖和range知识!
列表--list 列表:列表是python的基础数据类型之一,存储多种数据类型 可变 支持索引 可切片 方便取值 li = ['alex',123,Ture,(1,2,3,'wusir'),[1,2, ...
- python 列表 元祖 字典 集合_python中列表、元祖、字典和集合
list 允许重复的集合,是有序的:即元素可以是一样的,也可以修改元素: tuple 允许重复的集合,是有序的:但子元素是不可以修改的 dict 允许重复的集合,是无序的:元素是可以修改的 set ...
最新文章
- 编译安装keepalived-1.2.2.tar.gz报错处理
- 如何快速是DNS修改生效
- 细数:数据中心机房对环境的严格要求有哪些?
- 第1节:C语言发展及基本格式步骤
- ELK学习3_使用redis+logstash+elasticsearch+kibana快速搭建日志平台
- Java黑皮书课后题第8章:**8.17(金融风暴)银行会互相借款……银行的总资产是它当时的余款减去它欠其他银行的贷款。如果一个银行的总资产在某个限以下,那么这个银行是不安全的。编写程序,找出所有不安
- G6 图可视化引擎——入门教程——绘制 Tutorial 案例
- LeetCode 395. 至少有K个重复字符的最长子串(分治)
- python123测验答案测验3_知到app数学分析3-3测验答案查询服务
- 为多个VLAN实现DCHP
- PIR控制器调节器并网逆变器电流谐波抑制策略
- 电脑上win10的mysql软件老闪退,技术编辑应对win10系统Mysql闪退的修复办法
- 芯片行业相关公司及就业岗位汇总
- vue仿163musicPC端
- hive 查询表Wrong FS: hdfs://node1/user/hive/warehouse/test1.db, expected: hdfs://node1.zjn.cn:8020/
- CloseHandle(),TerminateThread(),ExitThread()的区别
- STM32c8t6串口+蓝牙控制PC13亮灭
- 【跟彤砸学编程】—— 第一课
- Redim preserve
- XP的140个技巧(转)