python变量类型介绍

版权声明:本文为博主原创文章,遵循 CC 4.0 BY-SA 版权协议,转载请附上原文出处链接和本声明。
本文链接: https://blog.csdn.net/weixin_42398077/article/details/96512069

这段时间太忙, 一直顾不上博客,现在重新捡起来, 这篇就当做热身, 以后还会针对每种变量类型做详细介绍.

Python常见变量类型


1. 数字

数字类型用于存储数值, 是不可改变的数据类型.
比如:

In [1]: a = 20                                                                  
In [2]: b = 30.0                                                                

In [3]: a                                                                       
Out[3]: 20

In [4]: b                                                                       
Out[4]: 30.0

In [5]: type(a)                                                                 
Out[5]: int

In [6]: type(b)                                                                 
Out[6]: float


2. 字符串

字符串或串(String)是由数字、字母、下划线组成的一串字符,
如:

In [7]: c = "hello"                                                             

In [8]: c                                                                       
Out[8]: 'hello'

In [9]: type(c)                                                                 
Out[9]: str

In [10]: d = "20"                                                               

In [11]: d                                                                      
Out[11]: '20'

In [12]: type(d)                                                                
Out[12]: str

3. 列表

列表是python使用比较多的一种数据类型, 是一种有序的集合, 一般用中括号[ ]来表示, 创建时也可以使用list函数来创建.
如:

In [13]: l = [10, 20, 30, 40]                                                   

In [14]: l                                                                      
Out[14]: [10, 20, 30, 40]

In [15]: type(l)                                                                
Out[15]: list

列表可以进行索引和切片, 索引的意思是取出列表中的某个元素, 切片则是指取出列表的一部分,仍构成一个列表.
如:

In [14]: l                                                                      
Out[14]: [10, 20, 30, 40]

In [16]: l[0]                                                                   
Out[16]: 10

In [17]: l[-1]                                                                  
Out[17]: 40

In [18]: l[1: 3]                                                                
Out[18]: [20, 30]

In [19]: l[:3]                                                                  
Out[19]: [10, 20, 30]

In [20]: l[1:]                                                                  
Out[20]: [20, 30, 40]

In [21]: l[2: -1]                                                               
Out[21]: [30]

4. 字典

字典也是python中使用较为频繁的一种数据类型,是一种无序的对象集合.与列表的区别在于, 列表采用位置偏离来获取元素, 而字典采取键值对的方式, 键都是唯一的, 对每个元素建立了唯一的索引.字典一般用大括号{ }来表示.

In [22]: d = {"x": "Alice", "y": 20, "z": [1, 2, 3], 20: "Alice"}               

In [23]: d                                                                      
Out[23]: {'x': 'Alice', 'y': 20, 'z': [1, 2, 3], 20: 'Alice'}

In [24]: type(d)                                                                
Out[24]: dict

字典可以进行索引, 但是不能切片.索引是用过键的方法.
如:

In [23]: d                                                                      
Out[23]: {'x': 'Alice', 'y': 20, 'z': [1, 2, 3], 20: 'Alice'}

In [25]: d["x"]                                                                 
Out[25]: 'Alice'

In [26]: d[20]                                                                  
Out[26]: 'Alice'

In [27]: d["y"]                                                                 
Out[27]: 20

In [28]: d["z"]                                                                 
Out[28]: [1, 2, 3]

5. 元组

元组与列表类似, 但是不能改变, 相当于只读列表. 用小括号( )来表示.
其索引和切片也和列表类似.
如:

In [32]: t = (10, 20, 30, 40)                                                   

In [33]: t                                                                      
Out[33]: (10, 20, 30, 40)

In [34]: type(t)                                                                
Out[34]: tuple

In [35]: t[0]                                                                   
Out[35]: 10

In [36]: t[-1]                                                                  
Out[36]: 40

In [37]: t[1: 3]                                                                
Out[37]: (20, 30)

In [38]: t[: 2]                                                                 
Out[38]: (10, 20)

In [39]: t[1: ]                                                                 
Out[39]: (20, 30, 40)

In [40]: t[1: -1]                                                               
Out[40]: (20, 30)

6. 集合

集合也是用大括号{ }来表示, 不过不是键值对的形式, 与数学中集合的含义基本相同(元素不可重复性). 如果有相同的元素, 则自动去掉后才是结果, 所以常常用来去重.

In [44]: s1 = {10, 20, 30, 40}                                                  

In [45]: s1                                                                     
Out[45]: {10, 20, 30, 40}

In [46]: type(s1)                                                               
Out[46]: set

In [47]: s2 = {10, 20, 30, 40, 10, 20, 30, 40}                                  

In [48]: s2                                                                     
Out[48]: {10, 20, 30, 40}

In [49]: type(s2)                                                               
Out[49]: set


7. 类型间的转换

有些类型相互转换并没有太大的意义, 大家可以在ipython中多敲敲. 这里主要列举可能会用到的函数:

函数 描述
int(x [,base]) 将x转换为一个整数
long(x [,base] ) 将x转换为一个长整数
float(x) 将x转换到一个浮点数
complex(real [,imag]) 创建一个复数
str(x) 将对象 x 转换为字符串
repr(x) 将对象 x 转换为表达式字符串
eval(str) 用来计算在字符串中的有效Python表达式,并返回一个对象
tuple(s) 将序列 s 转换为一个元组
list(s) 将序列 s 转换为一个列表
set(s) 转换为可变集合
dict(d) 创建一个字典。d 必须是一个序列 (key,value)元组。
frozenset(s) 转换为不可变集合
chr(x) 将一个整数转换为一个字符
unichr(x) 将一个整数转换为Unicode字符
ord(x) 将一个字符转换为它的整数值
hex(x) 将一个整数转换为一个十六进制字符串
oct(x) 将一个整数转换为一个八进制字符串

猜你喜欢

转载自blog.csdn.net/weixin_42398077/article/details/96512069