python学习-Day6-python的数据类型（二）

python的数据类型有：列表，元组，字符串。表达方式为：
     列表是用中括号表示
     元组是用小括号表示
     字符串是用引号表示
字符串，列表，元组都是可迭代的，凡是可迭代的都可以用for循环访问。

python 列表的常用方法

首先需要明确：列表是可变型的数据类型。列表里边的元素是可变的，可以增加，可以删除。

列表（list）是处理一组有序项目的数据结构，即可以在列表中存储一个序列的项目。

1、创建列表

    list1 = []

    list2 = list()

    list3 = ['a',1,2]

方法一：

In [1]: list1 = []  //创建一个空的列表

In [2]: type(list1)  //查看list1的类型

Out[2]: list  //类型为列表

方法二：

In [3]: list2 = list()

In [4]: list2

Out[4]: []

方法三：

In [5]: list3 = ['a',1,(1,),['hello','python']]

In [6]: list3

Out[6]: ['a', 1, (1,), ['hello', 'python']]

创建一个list3的列表：列表里边可以是字符，数字，可以是元组，也可以是列表。列表里每个元素之间用逗号隔开。

可以通过len（）查看序列长度

In [7]: len(list3)

Out[7]: 4

2、列表是可变元素

In [8]: list3  

Out[8]: ['a', 1, (1,), ['hello', 'python']]

In [9]:list3[0]  //取list3中第一个元素

Out[9]: 'a'//第一个元素是a

In [10]: list3[0] = 'b'  //把第一个元素变成b

In [11]:list3  //在查看list3的列表元素

Out[11]: ['b', 1, (1,), ['hello', 'python']]

3、列表相加，构成一个大的列表

In [7]: list3

Out[7]: ['b', 1]

In [9]: list2 = []   //创建空列表list2

In [10]: list2

Out[10]: []

In [11]: list2.append('python')  //list2里面追加字符“python”，只能追加一个参数

In [12]: list2

Out[12]: ['python']

In [13]: list2 + list3  //两个列表相加

Out[13]: ['python', 'b', 1]

4、列表也可以进行重复

In [15]: (list2 + list3)*2   //列表使用括号表示优先级要高，先进行括号里的在重复两遍

Out[15]: ['python', 'b', 1, 'python', 'b', 1]

5、列表操作

取值

      切片和索引

添加

      list.append()

删除

       del list[]

       list.removed(list[])

eg1：

      In [19]: list3

Out[19]: ['b', 1, 'linux']

      In [21]:del list3[-1]   //del删除的方式是用列表的下标表示

In [22]: list3

Out[22]: ['b', 1]

eg2：del 还可以删除变量

    In [23]: list2

Out[23]: ['python']

In [24]:del list2

In [26]: list2   //删除后，查看list2报错

---------------------------------------------------------------------------

NameError                                 Traceback (most recent call last)

<ipython-input-26-db9b7629a516> in <module>()

----> 1 list2

eg3：list.remove(list[])

In [32]: list1   //列表中可以有重复的字符

Out[35]: ['a', 3, 'abcd', 3]

In [41]: list1.remove(list1[1])  //删除列表中的3，可以看出列表删除的是第一个3

 

eg5：

In [45]: list1

Out[45]: ['a', 'abcd', 3]

In [46]:list1.remove(3)  /括号里的3，指的是列表中的数字3，这个存在的值。不是切片的索引。

In [48]: list1.remove('a')  //删除字母a

In [49]: list1

Out[49]: ['abcd']

In [47]: list1

Out[47]: ['a', 'abcd']

In [42]: list1

Out[42]: ['a', 'abcd', 3]

 

修改

        list[] = x

查找

        var in list

In [52]: list3

Out[52]: ['b', 1]

In [53]:'d' in list3    //查看字符d在不在列表list3里，在的话显示true，不再的话显示flase

Out[53]: False

In [54]: 'a' not in list3  //查看a是否在list3列表中，不再显示true，在现实flase

Out[54]: True

 

使用insert进行插入

eg1：

In [55]: list1   //list1为空列表

Out[55]: []

In [56]: list3    //list3的列表

Out[56]: ['b', 1]

In [57]: list3.insert(0,list1)  //在list3列表中，字符b的前边插入一个空的列表--list1.命令当中的0是字符b的切片索引值

In [58]: list3

Out[58]: [[], 'b', 1]

eg2：

In [58]: list3  //list3中有一个空的列表

Out[58]: [[], 'b', 1]

In [59]: list3[0].append('abcd')//往list3空的列表当中，插入字符abcd

In [60]: list3

Out[60]: [['abcd'], 'b', 1]

 

列表排序

In [61]: list3.  //table键

list3.append   list3.extend   list3.insert   list3.remove  list3.sort

list3.count    list3.index    list3.pop      list3.reverse

In [61]: list3

Out[61]: [['abcd'], 'b', 1]

In [62]: list3.sort()

In [64]: list3

Out[64]: [1, ['abcd'], 'b']  //列表是按升序排的

 

列表里的元素进行反转 L.reverse()

In [64]: list3

Out[64]: [1, ['abcd'], 'b']

In [65]:list3.reverse()

In [66]: list3

Out[66]: ['b', ['abcd'], 1]

 

删除列表里的元素

L.pop,示例如下

In [61]: a   //a列表

Out[61]: [4, '2', 'abc', (2, 'ding')]

In [63]: a.pop(2)   //删除索引为2的

Out[63]: 'abc'

In [64]: a

Out[64]: [4, '2', (2, 'ding')]

In [64]: a

Out[64]: [4, '2', (2, 'ding')]

In [65]: a.pop()   //如果不加索引，默认删除最后一个

Out[65]: (2, 'ding')

In [66]: a

Out[66]: [4, '2']

 

追加

In [71]: range(5)

Out[71]: [0, 1, 2, 3, 4]

In [72]: a

Out[72]: [4, '2', 2, 'ding']

In [73]: a.extend(range(5))    //把range（5）追加到a列表里

In [74]: a

Out[74]: [4, '2', 2, 'ding', 0, 1, 2, 3, 4]

 

In [80]: list2

Out[80]: ['bb', 2, 3]

In [81]: a.extend(list2)    ///把list2的单个元素 追加到a列表里边

In [82]: a

Out[82]: [4, '2', 2, 'ding', 0, 1, 2, 3, 4, 'bb', 2, 3]   //追加的是list2的单个元素

关于列表的相关示例：
#/usr/bin/python
#coding=utf-8
#@File   :列表.py
list1 = [1,2,3,4]
print type(list1)
str1 = 'abcd'
print list(str1)
print dir(list1)
>>>
<type 'list'>
['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__delslice__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getslice__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__setslice__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']
print '###'*20

#append()  在末尾追加一个元素

list2 = ['a','b','c','d']

list2.append('00')

print list2

>>> ['a', 'b', 'c', 'd', '00']

#index() 用于列表中第一个匹配项的索引位置

list3 = ['heoll','world','good','ABC']

print list3.index('good')

print type(str(list3))

print str(list3)

print str(list3)[20]

print (str(list3)).find('good')

>>> 2

　　<type 'list'>

　　['heoll', 'world', 'good', 'ABC']

　　<type 'str'>

　　g

　　20

#insert() 用于将制定对象插入制定位置

list4 = ['abc','tty','oop']

list4.insert(1,'aa')  //在索引1的位置后插入字符aa

print list4

>>> ['abc', 'aa', 'tty', 'oop']

 

#pop() 用于移除列表中的一个元素（默认为最后一个元素），并且返回该元素的值

print list4

list4.pop()

list4.pop(0)

print list4

>>> ['abc', 'tty', 'oop']

　　oop

　　abc

　　['tty']

#remove() 用于移除列表中某个值的第一个匹配项

list4 = ['abc','tty','oop']

list4.remove('tty')

print list4

>>> ['abc', 'oop']

 

#sort() 对列表进行原址排序，既然是原址排序，那显然元祖不可能拥有这种方法，因为元祖是不可变的

x = [4,7,8,3,5,1,2,6,9]

x.sort()

print x

>>> [1, 2, 3, 4, 5, 6, 7, 8, 9]

 

#reverse()  函数用于反向列表中的元素

x1 = ['d','c','abc','ab','a','123','1']

x1.sort()

print x1

x1.reverse()

print x1

>>> '1', '123', 'a', 'ab', 'abc', 'c', 'd']

#切片

x1 = ['d','c','abc','ab','a','123','1']

print x1[:]

print x1[1:]

print x1[1:5]

print x1[1:6:2]

>>> 

　　['d', 'c', 'abc', 'ab', 'a', '123', '1']

　　['c', 'abc', 'ab', 'a', '123', '1']

　　['c', 'abc', 'ab', 'a']

　　['c', 'ab', '123']

python的元组-序列

序列

1、字符串，列表，元组都是序列。

2、序列的两个特点是索引操作符和切片操作符

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

切片操作符：让我们可以获取序列的一个切片，即一部分序列

2.序列的基本操作：

1、len() //求序列的长度

2、+ //连接2个序列

3、* //重复序列元素

4、in //判断元素是否在序列中

5、max() //返回最大值

6、min() //返回最小值

7、cmp(x,y) //比较两个序列是否相等。cmp比较的不是字母多少个，比较的是字母的大小（a-z由小到大）

len用法：求序列的长度

In [2]: a = 'abcdef'

In [3]: a

Out[3]: 'abcdef'

In [4]: len(a)

Out[4]: 6

 

‘+’ 号用法：连接两个序列

In [5]: a + 'g'

Out[5]: 'abcdefg'

 

‘*’ 号用法：重复序列元素

In [6]: a *3 //abcdef 重复3次

Out[6]: 'abcdefabcdefabcdef'

In [9]: '#' * 5 //#号重复5次

Out[9]: '#####'

in用法：判断元素是否在序列里

In [10]: a

Out[10]: 'abcdef'

In [11]: 'a' in a //判断a的字符是否在a的序列里，返回值为true

Out[11]: True

In [12]: 'h' in a //判断h是否在a的序列里，返回值为false，说明不在a的序列里

Out[12]: False

not in 用法：//判断元素不在序列里

In [13]: 'h' not in a //判断h是否在a的序列里，返回值为true，说明h不在a的序列里

Out[13]: True

max() 与 min() 求一个序列里的最大值与最小值

In [14]: a

Out[14]: 'abcdef'

In [15]: max(a) //a序列里的最大值为f

Out[15]: 'f'

In [16]: min(a) //a序列里的最小值为a

Out[16]: 'a'

cmp（x，y）：比较两序列是否相等

In [17]: help(cmp)

Help on built-in function cmp in module __builtin__:

cmp(...)

cmp(x, y) -> integer

 

Return negative if x<y, zero if x==y, positive if x>y.

注：如果返回值为负数（negative）则x小于y。如果返回值为0，则x等于y。如果返回值为正数，则x大于y。

In [24]: a //a的序列为“abcdef”

Out[24]: 'abcdef'

In [23]: cmp(a,'abcde') //比较a的序列与字符串abcde。返回值为正数，说明a序列大于字符串abcde

Out[23]: 1

In [25]: cmp(a,'abcdef') //返回值为0，说明a序列等于字符串“abcdef”

Out[25]: 0

In [26]: cmp(a,'abcdefg') //返回值为负1，说明a序列小于字符串“abcdefg”

Out[26]: -1

In [27]: cmp(a+'g','abcdefg') //返回值为0，说明相等

Out[27]: 0

元组（），定义元组用圆括号表示

1、元组和列表十分相似

2、元组和字符串一样是不可变的

元组可以存储一系列的值

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

3、定义一个元组

In [30]: t = ('a',1,(1,)) //元组里可以存放：字符，数字，还可以存放另一个元组（1，）

In [31]: t

Out[31]: ('a', 1, (1,))

In [32]: t1 = (1,) //定义一个新的元组为t1，圆括号里边的1，只有加逗号才表示元组

In [34]: type (t1) //t1的类型

Out[34]: tuple 元组

In [35]: t //查看t元组

Out[35]: ('a', 1, (1,))

In [36]: t[0] //查看t元组中第一个字符为a

Out[36]: 'a'

In [37]: t[0] = 6 //想把第一个字符变成6，报错，说明元组里的东西是不可变的

---------------------------------------------------------------------------

TypeError Traceback (most recent call last)

<ipython-input-37-b3ff79bf2df1> in <module>()

----> 1 t[0] = 6

TypeError: 'tuple' object does not support item assignment //元组里的项目不支持改变

元组的操作。

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

元组值不可变

元组的操作：

In [20]: a

Out[20]: 'abc'

In [21]: t = (a,'b','c')

In [22]: t

Out[22]: ('abc', 'b', 'c')

2、元组的拆分

- t = (1,2,3)

a,b,c = t

通过变量接收元组的值：

In [23]: first,second,third = t

In [24]: first

Out[24]: 'abc'

In [25]: second

Out[25]: 'b'

In [26]: third

Out[26]: 'c'

查看元组里边的方法

In [27]: t.

t.count t.index //有两个方法。python是一个面向对象的语言，count，index等都是t的方法。

In [28]: help(t.count)

Help on built-in function count:

count(...)

T.count(value) -> integer -- return number of occurrences of value

查看value 值在元组中出现的次数

In [32]: a

Out[32]: 'abc'

In [33]: t = (a,'b','c') //t的元组

In [34]: t

Out[34]: ('abc', 'b', 'c')

In [30]: t.count('b')

Out[30]: 1 // b元素在元组里出现里1次。abc 是一个整体

In [31]: t.count('f')

Out[31]: 0 // f元素没在元组里出现过

In [35]: t.count(a)

Out[35]: 1 //value值为一个变量时，返回值也是整数

 

In [36]: help(t.index)

Help on built-in function index:

index(...)

T.index(value, [start, [stop]]) -> integer -- return first index of value.

Raises ValueError if the value is not present.

查找 t.index元组里边value元素的第一个索引值。例子如下：

In [38]: t

Out[38]: ('abc', 'b', 'c')

In [39]: t.index('b')

Out[39]: 1

元组示例：

#/usr/bin/python
#coding=utf-8
#@File :元组.py

#tuple() 字符串转换成元组
str1 = 'abcd efg hiop'
print type(tuple(str1))
print tuple(str1)

 >>> 

<type 'tuple'>
('a', 'b', 'c', 'd', ' ', ' ', 'e', 'f', 'g', ' ', ' ', 'h', 'i', 'o', 'p')

#注意元组的写法,单个tuple元素的时候，元素后面要加逗号
n = ('abc')
m = ('abc',)
print type(n)
print type(m)
print '###'*20

 >>>  <type 'str'>

        <type 'tuple'>

#tuple的方法 count() index()
print dir(tuple)

>>> ['__add__', '__class__', '__contains__', '__delattr__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__getslice__', '__gt__', '__hash__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'count', 'index']

 

#count() 方法：统计某个元素出现的次数
t1 = ('abcd','aaa','bcde','fff','eee','123','abcd')
t2 = ('a','b','c','a','d','b','a')
print t1.count('abcd')
print t2.count('a')
print '%%%%%'*20

 >>> 2

        3

#index()方法,查找元组中某个元素的切片位置
print t1.index('aaa')
print '&&&&'*20

 >>> 1

字典的表达方式：

k1 = dict(a = 1, b = 2, c = 3)print (k1)print (type(k1))

{'a': 1, 'c': 3, 'b': 2}
<type 'dict'>

d = dict([('name', 'xiaojingjing'), ('age', '18')])print (d)print (type(d))

{'age': '18', 'name': 'xiaojingjing'}
<type 'dict'>

字典的常用方法：

clear():清除字典内容

k1.clear()

print(k1)

返回结果：{}

表示字典内容被清空了。

get():

print(d.get('name'))

xiaojingjing

print(d.get('address'))

None\\没有的内容，则返回空

setdefault()：增加字典值

print(d.setdefault('name', 'aming'))

xiaojingjing\\字典本身有对应的key-value，这条方法就类似get

print(d.setdefault('address', 'beijing'))

beijing\\如果本身字典内没有对应的value值，则会将这里的值赋值给字典。与get方法的区别

keys()：获取key

print(d.keys())

['name', 'age', 'address'] \\这里是获取到了字典中的所有key。

values()：获取所有value

print(d.values())

['xiaojingjing', '18', 'beijing']

iteritems():

print(k.iteritems())

print (type(d))print (d.items())\\一次性全部取出来print (type(d.items()))for x, y in d.iteritems():\\有节操的程序员，推荐这个方法，节约系统内存资源。    print (x, y)
<type 'dict'>[('age', '18'), ('name', 'xiaojingjing'), ('address', 'beijing')]<type 'list'>('age', '18')('name', 'xiaojingjing')('address', 'beijing')

pop():删除key

print(d.pop('name'))print(d)

xiaojingjing
{'age': '18', 'address': 'beijing'}

字典的高级操作：

l = ['a', 'b', 'c', 'd', 'e']d = {}n = d.fromkeys(l, 123)print (n)n = dict.fromkeys(l, 456)print (n)

{'a': 123, 'c': 123, 'b': 123, 'e': 123, 'd': 123}
{'a': 456, 'c': 456, 'b': 456, 'e': 456, 'd': 456}

#zip()函数接受多个任意（包括0和1）序列作为参数，返回一个tuple列表。可以把多个列表叠加成一个元组列表

l1 = ['a','b','c','d']

l2 = [1,2,3,4]

l3 = zip(l1,l2)\\这里其实可以进行修改直接转换成字典：l3 = dict(zip(l1, l2))

print l3

>>> [('a', 1), ('b', 2), ('c', 3), ('d', 4)]

>>> {'a': 1, b'', 2, 'c', 3, 'd', 4}

将两个字典进行合并：update()

l1 = ['a', 'b', 'c', 'd', 'e']l2 = ['1', '2', '3', '4', '5']n2 = {'age': '18', 'address': 'beijing'}z = dict(zip(l1, l2))print (z)z.update(n2)print (z)

{'a': '1', 'c': '3', 'b': '2', 'e': '5', 'd': '4'}
{'a': '1', 'c': '3', 'b': '2', 'e': '5', 'd': '4', 'address': 'beijing', 'age': '18'}

对字典进行排序：sorted()

mm = dict(a=1, b=10, c=3, d=9)print (mm)print sorted(mm.iteritems(), key = lambda d: d[0], reverse = True)\\匿名函数print sorted(mm.iteritems(), key = lambda d: d[0], reverse = False)\\d[0/1]这里就是指定用key排序还是valueprint sorted(mm.iteritems(), key = lambda d: d[1], reverse = True)\\reverse指定True正序还是False倒叙print sorted(mm.iteritems(), key = lambda d: d[1], reverse = False)\\正序是从大到小

{'a': 1, 'c': 3, 'b': 10, 'd': 9}
[('d', 9), ('c', 3), ('b', 10), ('a', 1)]
[('a', 1), ('b', 10), ('c', 3), ('d', 9)]
[('b', 10), ('d', 9), ('c', 3), ('a', 1)]

[('a', 1), ('c', 3), ('d', 9), ('b', 10)]

mm.iteritems()：这里取出的是类似('a', 1)这样的结构，所以才有后面的匿名函数来确定指定排序关键字