python常用数据类型

python数据类型

数值
字符串
列表
元组
字典

常用帮助方法

通过type查看类型，再看详细属性

 
#!/usr/bin/env python3
# -*- conding: utf-8 -*-
from __future__ import division
​
va1 = 9 / 2

1）通过type获取字符串类型，获取类型之后，获取模板，Ctrl+鼠标左键

carl = 'hello,world'
carl.upper()
carl.lower()
print(va1)
print(type(carl))
​

​

在属性中，找到定位功能（scroll from source）

然后点击右边的设置：show Members可以查看详细信息

int

所有对象所具备的功能都保存在相应的类

​

​

2）通过dic查看所有的功能

carl = "alex"
print(dir(carl))
​

​

​

3）通过help和type组合起来使用查看

carl = "alex"
help(type(carl))
​

4）直接点击

鼠标放在upper()上，Ctrl+左键，自动定位到upper功能处

​

​

int

案例

123和“123”一样吗？

123是数值，“123”是字符串

数值类型

整型
长整型
浮点型
复数型

整型

例如：

In [1]: a = 456
​
In [2]: type(a)
Out[2]: int    #整数型
​
In [3]: 2**32
Out[3]: 4294967296
​
In [4]: 2**31
Out[4]: 2147483648
 
 

长整型

例如：

In [5]: -2147483648 -- 2147483647     #整数赋值范围
Out[5]: -1
​
In [6]: a = 99999999999999999999999999
​
In [7]: a
Out[7]: 99999999999999999999999999L
In [9]: type(a)
Out[9]: long   #长整型
​
In [10]: a = 100l   #短数字长整型，L和l都一样
​
In [11]: type(a)
Out[11]: long
​
In [13]: 0x34aL     #0x通常表示16进制，34a表示  0-9  a-f
Out[13]: 842L
​
In [17]: a = 'abc'
​
In [18]: a
Out[18]: 'abc'
​
In [19]: a = "abc"
​
In [20]: a
Out[20]: 'abc'
​
In [21]: type(a)
Out[21]: str
 
 

浮点型

例如： 0.0 ， 12.0 ， -18.8 , 3e_7

除数和被除数，任意一个加上.0就是浮点数

例如：

In [14]: 3/2
Out[14]: 1
​
In [15]: 3.0/2
Out[15]: 1.5
​
In [16]: type(3.0/2)
Out[16]: float
​
In [44]: 3e+7   #科学计数法也属于浮点型
Out[44]: 30000000.0
​
In [45]: type(3e+7)   
Out[45]: float
​
 
 

复数型complex

python对复数提供内嵌支持，这是其他大部分软件所没有的

例如：

In [46]: a=23j
​
In [47]: type(a)
Out[47]: complex
 
 

字符串类型--string

有三种方法定义字符串类型
-str = 'this is a string'
-str = "this is a string"
-str = '''thin is a string'''

三重引号（docstring）除了能定义字符串还可以用作注释，当然也可以用#号进行注释，当字符串非常多的时候可以用三引号进行注释。
'''or"""都可以是三引号，但不能'''与“”“同时使用。

索引和切片

通过索引得到每个字符
例如

 

In [28]: a = 'abcde'
​
In [29]: a[0]
Out[29]: 'a'
​
In [30]: a[1]
Out[30]: 'b'
​
 
 

切片

元组和字典都会用到切片，默认从左到右进行切片

例如

 

In [31]: a[-1]
Out[31]: 'e'
​
In [32]: a[0]+a[1]
Out[32]: 'ab'
​
In [33]: a[0:2]
Out[33]: 'ab'
​
In [34]: a[:2]
Out[34]: 'ab'
​
In [35]: a[1:2]
Out[35]: 'b'
​
In [36]: a[1:]
Out[36]: 'bcde'
​
In [37]: a[:]
Out[37]: 'abcde'
​
In [38]: a[:-1]
Out[38]: 'abcd'
​
In [39]: a[::1]
Out[39]: 'abcde'
​
In [40]: a[::2]
Out[40]: 'ace'
​
In [41]: a[:]
Out[41]: 'abcde'
​
In [42]: a[-4:-2] 
Out[42]: 'bc'
​
In [43]: a[-2:-4:-1]  #从右往左，后面再加一个-1
Out[43]: 'dc'
​
 
 

字符串就是数列，数列的操作有索引和切片【数列里面比较关键的操作】

序列

字符串、列表和元组都是序列
序列的两个主要特点是索引操作符和切片操作符

索引操作符让我们可以从序列中抓取一个特定项目

切片操作符让我们能够获取序列的一个切片，即一部分序列。

序列的基本操作

len(): 求序列的长度
+：连接2个序列
*：重复序列元素 #*后面必须接数值
in：判断元素是否在序列中
max()：返回最大值
mix()：返回最小值
cmp(x,y): 比较两个序列是否相等

例如

In [2]: a = 'abcde'
​
In [3]: a
Out[3]: 'abcde'
​
In [4]: len(a)
Out[4]: 5
​
In [5]: a + 'f'
Out[5]: 'abcdef'
​
In [6]: a
Out[6]: 'abcde'
​
In [7]: a * 10
Out[7]: 'abcdeabcdeabcdeabcdeabcdeabcdeabcdeabcdeabcdeabcde'
​
In [8]: '#' * 50
Out[8]: '##################################################'
​
In [9]: a + '1'
Out[9]: 'abcde1'
​
In [10]: 'a' in a
Out[10]: True
​
In [12]: 'f' in a
Out[12]: False
​
In [13]: 'f' not in a
Out[13]: True
​
In [14]: 'f' not in a + 'f'
Out[14]: False
​
In [15]: a
Out[15]: 'abcde'
​
In [16]: max(a)
Out[16]: 'e'
​
In [17]: min(a)
Out[17]: 'a'
​
In [19]: cmp(a,'abcde')
Out[19]: 0
​
In [20]: cmp(a,'abcdef')
Out[20]: -1
​
In [21]: cmp(a,'abcd')
Out[21]: 1
​
In [22]: cmp(a+'g','abcd')
Out[22]: 1
​
In [23]: a
Out[23]: 'abcde'
​
In [24]: a[-1] = 'f'
​
 
 

元组

元组和列表十分相似
元组和字符串一样是不可变的

元组可以存储一系列的值

元组通常在用户定义的函数能够安全地采用一组值的时候，即被使用的元组的值不会改变。

元组操作

元组操作

元组和字符串一样属于序列类型，可以通过索引和切片操作

元组值不可变

元组的拆分

 
t = (1,2,3)
a,b,c = t

例如

 

n [25]: t = ('a',1,(1,))
​
In [26]: t
Out[26]: ('a', 1, (1,))
​
In [27]: t1 = (1)
​
In [28]: type(t1)
Out[28]: int
​
In [29]: t1 = (1,)
​
In [30]: type(t1)
Out[30]: tuple
​
In [31]: t[0]
Out[31]: 'a'
​
In [32]: t = (a, 'b', 'c')
​
In [33]: t
Out[33]: ('abcde', 'b', 'c')
​
In [34]: first , second, third = t
​
In [35]: first
Out[35]: 'abcde'
​
In [36]: second
Out[36]: 'b'
​
In [37]: third
Out[37]: 'c'
Out[38]: ('abcde', 'b', 'c')
​
In [39]: help(t.count)
​
​
In [40]: t.count('b')
Out[40]: 1
​
In [41]: t.count('c')
Out[41]: 1
​
In [42]: t.count('bc')
Out[42]: 0
​
In [43]: t.count(a)
Out[43]: 1
​
In [44]: help(t.index)
​
​
In [45]: t.index('b')
Out[45]: 1

​
 
 

总结

 

index(…)
    T.index(value, [start, [stop]]) -> integer -- return first index of value.
    Raises ValueError if the value is not present.
判断索引在第几个位置，如果有多个，就判断第一个出现的
​
 count(…)
    T.count(value) -> integer -- return number of occurrences of value
判断返回值是否在元组里，是返回0，不是返回1.
​
面向过程的一般称为函数，面向对象的一般称为方法。
在python里面一切皆为对象。 t.count  t就是对象，count就是方法。

​
 
 

列表

列表定义：

列表（list）是处理一组有序项目的数据结构，即可以在列表存储一个序列的项目。
列表是可变类型的数据
创建列表
例如

In [1]: list1 = []
​
In [2]: type(list1)
Out[2]: list
​
In [3]: list3 = ['a',1,(1,),['hello', 'python'] ]
​
In [4]: list3
Out[4]: ['a', 1, (1,), ['hello', 'python']]

列表操作

取值：切片和索引
添加：list.append() list.extend()
删除：del list[] list.remove(list[]) list.pop
修改：list[]= x
查找：var in list

例如

In [4]: list3
Out[4]: ['a', 1, (1,), ['hello', 'python']]
​
In [5]: len(list3)    #求长度
Out[5]: 4
​
In [6]: list3[0]
Out[6]: 'a'
​
In [7]: list3[0] = 'b'   #对象替换
​
In [8]: list3
Out[8]: ['b', 1, (1,), ['hello', 'python']]
​
In [9]: list3 + list1       #列表相加
Out[9]: ['b', 1, (1,), ['hello', 'python']]
​
In [12]: (list3 + list1) * 2  #列表相加乘次数
Out[12]: ['b', 1, (1,), ['hello', 'python'], 'b', 1, (1,), ['hello', 'python']]
​
In [13]: list3
Out[13]: ['b', 1, (1,), ['hello', 'python']]
​
In [14]: del list3[-1]   #删除对象
​
In [15]: list3
Out[15]: ['b', 1, (1,)]
​
In [19]: list3.append(1)  #添加对象到末尾
​
In [20]: list3
Out[20]: ['b', 1, (1,), 1]
​
In [21]: list3.remove(1)  #删除索引为1的对象
​
In [22]: list3
Out[22]: ['b', (1,), 1]
​
In [23]: 'a' in list3    #判断
Out[23]: False
​
In [24]: 'a' not in list3    #取反判断
Out[24]: True
​
In [25]: list3.insert(1, list1)    #插入列表1到索引为1的位置
​
In [26]: list3
Out[26]: ['b', [], (1,), 1]
​
In [27]: list3[1].append('abc')    #添加字符串到索引为1的位置
​
In [28]: list3
Out[28]: ['b', ['abc'], (1,), 1]
​
In [29]: list3.sort()    #对对象进行排序
​
In [30]: list3
Out[30]: [1, ['abc'], 'b', (1,)]
​
In [31]: list3.reverse()    #对对象进行反转排序
​
In [32]: list3
Out[32]: [(1,), 'b', ['abc'], 1]
​
In [33]: list3.pop(1)    #对列表索引为1的进行删除
Out[33]: 'b'
​
In [34]: list3
Out[34]: [(1,), ['abc'], 1]
​
In [35]: list3.pop()    #如果索引为空，删除最后一个对象
Out[35]: 1
​
In [36]: list3
Out[36]: [(1,), ['abc']]
​
In [37]: range(5)    #类似于seq
Out[37]: [0, 1, 2, 3, 4]
​
In [39]: list3.extend(range(5))    #添加序列
​
In [40]: list3
Out[40]: [(1,), ['abc'], 0, 1, 2, 3, 4] 
​
In [41]: list3.extend('abcd')    #添加字符串
​
In [42]: list3
Out[42]: [(1,), ['abc'], 0, 1, 2, 3, 4, 'a', 'b', 'c', 'd']
​
 
 

总结

字符串、元组、列表都是可迭代的，可迭代的都可用for循环去访问

dict

字典定义

此字典为python里面的数据结构

字典是python中的唯一的映射类型（哈希表）
字典对象时可变的，但是字典的键必须使用不可变对象，一个字典中可以使用不同类型的键值。
字典的方法：keys*() values() items()
常用的方法

字典的操作

 

In [59]: dic = {}    #创建一个孔子点
​
In [60]: type(dic)
Out[60]: dict
​
In [61]: dic = {'a':1,1:123}    #key可以是字符串、数字、和元组，但不能是列表
​
In [62]: dic
Out[62]: {1: 123, 'a': 1}
​
In [63]: dic = {'a':1,1:123,('a','b'):'hello'}
​
In [64]: dic
Out[64]: {1: 123, 'a': 1, ('a', 'b'): 'hello'}
​
In [65]: len(dic)    #求字典元素的长度或者个数
Out[65]: 3
​
In [66]: dic.keys()
Out[66]: ['a', 1, ('a', 'b')]
​
In [67]: dic.values()
Out[67]: [1, 123, 'hello']
​
In [68]: help(dic)   
​
​
In [69]: help(dic.get)     #使用帮助
​
​
In [70]: dic.get('a')    #获取key为a的value
Out[70]: 1
​
In [71]: dic[1]
Out[71]: 123
​
In [72]: dic['a']
Out[72]: 1
​
In [73]: dic['a'] = 2
​
In [74]: dic
Out[74]: {1: 123, 'a': 2, ('a', 'b'): 'hello'}
​
In [75]: dic[('a','b')]
Out[75]: 'hello'
​
In [76]: dic.get('b','python')    #当获取未知key，后接value的时候，返回value
Out[76]: 'python'
​
In [77]: 'b' in dic    #字典的判断
Out[77]: False
​
In [78]: 'a' in dic
Out[78]: True
​
In [79]: dic.has_key('a')    #用has_key方法进行判断
Out[79]: True
​
In [80]: dic.has_key('b')
Out[80]: False
​
In [81]: dic.items()    #把字典变成列表
Out[81]: [('a', 2), (1, 123), (('a', 'b'), 'hello')]    
​
In [82]: dic
Out[82]: {1: 123, 'a': 2, ('a', 'b'): 'hello'}
​
In [83]: dic1 = dic.copy()    #复制一份字典
​
In [84]: dic1
Out[84]: {1: 123, 'a': 2, ('a', 'b'): 'hello'}
​
In [85]: dic.pop(1)    #删除key为1的value
Out[85]: 123
​
In [86]: dic
Out[86]: {'a': 2, ('a', 'b'): 'hello'}
​
In [87]: dic.pop(2,'abc')    #删除不存在的key和value的时候，返回value
Out[87]: 'abc'
​
In [88]: help(dic.update)
​
​
In [89]: dic
Out[89]: {'a': 2, ('a', 'b'): 'hello'}    
​
In [90]: dic1 = {1:1, 2:2}
​
In [91]: dic.update(dic1)    #把字典dic1的对象添加到dic里面去
​
In [92]: dic1
Out[92]: {1: 1, 2: 2}
​
In [93]: dic
Out[93]: {1: 1, 2: 2, 'a': 2, ('a', 'b'): 'hello'}
​
In [94]: list1
Out[94]: ['name', 'age']
​
In [95]: list2
Out[95]: ['Tom', '20']
​
In [96]: zip(list1,list2)    #合并两个列表
Out[96]: [('name', 'Tom'), ('age', '20')]
​
In [97]: dict(zip(list1,list2))
Out[97]: {'age': '20', 'name': 'Tom'}
​
In [98]: dict(a=1,b=2)
Out[98]: {'a': 1, 'b': 2}
​
In [99]: dic
Out[99]: {1: 1, 2: 2, 'a': 2, ('a', 'b'): 'hello'}
​
In [100]: dic.fromkeys('abc')    #新增key，value
Out[100]: {'a': None, 'b': None, 'c': None}
​
In [101]: dic.fromkeys('abc',100)
Out[101]: {'a': 100, 'b': 100, 'c': 100}
​
In [102]: dic.fromkeys(range(5),100)    #也可以用range创建字典
Out[102]: {0: 100, 1: 100, 2: 100, 3: 100, 4: 100}
​
In [103]: dic
Out[103]: {1: 1, 2: 2, 'a': 2, ('a', 'b'): 'hello'}

​
 
 

我们可以通过循环去遍历字典

例如

In [116]: for k in dic1:
     …:     print k, dic1[k]
     …:     
1 1
2 2
​
In [117]: dic1
Out[117]: {1: 1, 2: 2}
​
In [118]: for k in dic1:
     …:     print "%s,%s" % (k, dic1[k])
     …:     
1,1
2,2
​
In [119]: for k, v in dic1.items():print k ,v
1 1
2 2
​
 
 

总结

key不可以变，value可变
字符串'' ""
元组()
列表[]
字典{}

简单字典练习

打印个人信息
例如

 

[root@wangtian day01]# vim 5.py 
#!/usr/bin/python
info = {}
name = raw_input("Please input name: ")
age = raw_input("Please input age: ")
gender = raw_input("Please input (M/F): ")
​
info['name'] = name
info['age'] = age
info['gender'] = gender
for k, v in info.items():
    print "%s: %s" % (k, v)
print "END"
 
 

操作
输出效果

[root@wangtian day01]# python 5.py 
Please input name: wangtian
Please input age: 24
Please input (M/F): M
gender: M
age: 24
name: wangtian
END

类型转换

In [58]: int('a', 16)    #16进制转换成10进制
Out[58]: 10

In [59]: int('0xa', 16)  #16进制默认前面带0x
Out[59]: 10

In [60]: hex(10)   #10进制转换成16进制
Out[60]: '0xa'

In [61]: str(10)   #10进制转换成字符串
Out[61]: '10'

In [62]: int('10')  #字符串转为10进制
Out[62]: 10

计算mac地址

[root@wangtian day02]# cat 19.py
#!/usr/bin/evn python
​
macaddr = '00:16:3e:00:2f:05'
prefix_mac = macaddr[:-3]
last_two = macaddr[-2:]
plus_one = int(last_two, 16) + 1
if plus_one in range(10):
    new_last_two = hex(plus_one)[2:]
    new_last_two = '0' + new_last_two
else:
    new_last_two = hex(plus_one)[2:]
    if len(new_last_two) == 1:
        new_last_two = '0' + new_last_two
new_mac = prefix_mac + ':' + new_last_two
print new_mac.upper()
[root@wangtian day02]# python 19.py
00:16:3E:00:2F:06
 
 

字符串转列表

list(string)
In [3]: s = 'abc'
​
In [4]: list(s)
Out[4]: ['a', 'b', 'c']
 
 

列表转字符串

''.join(list)
In [5]: l = list(s)
​
In [6]: l
Out[6]: ['a', 'b', 'c']
​
In [7]: ''.join(l)
Out[7]: 'abc'
​
In [8]: '.'.join(l)
Out[8]: 'a.b.c'
 
 

字符串转元组

tuple(string)
In [9]: s
Out[9]: 'abc'
​
In [10]: tuple(s)
Out[10]: ('a', 'b', 'c')
 
 

元组转字符串

''.jion(tuple)
​
In [11]: t = tuple(s)
​
In [12]: t
Out[12]: ('a', 'b', 'c')
​
In [13]: ''.join(t)
Out[13]: 'abc'
 
 

元组转换成列表

In [15]: list(t)
Out[15]: ['a', 'b', 'c']
 

列表转换成元组

 
In [16]: tuple(t)
Out[16]: ('a', 'b', 'c')

字典转换成列表

itmes()
​
In [17]: dic = {'a':1,'b':2}
​
In [18]: dic
Out[18]: {'a': 1, 'b': 2}
​
In [19]: dic.items()
Out[19]: [('a', 1), ('b', 2)]
 
 

列表转为字典

dict()
​
In [20]: l1 = dic.items()
​
In [21]: l1
Out[21]: [('a', 1), ('b', 2)]
​
In [22]: dict(l1)
Out[22]: {'a': 1, 'b': 2}
 
 

选择了奋斗，以后可以随时还有选择安逸的权力。但选择了安逸，可能以后就不那么轻易还能有选择奋斗的权力。