Python 基础语法 2（数字字符串元祖列表字典）

2018-11-15

1.5 Python的数值和字符串
1.6 元组
1.7 列表
1.8/1.9 字典

1.5 Python的数值和字符串

Python数据类型包括
1）数字
2）字符串
3）列表
4）元组
5）字典

数字类型

数字类型	范围表示法
整型（int）	表整数如12 0
长整型（long）	表范围更大的整数如12L 34l
浮点型（float）	表小数 0.1 3e+2
复数型（complex）	-3.14j 32J

In [1]: type(456)  
Out[1]: int

In [3]: type(3.0/2) 
Out[3]: float

In [4]: type(3e+7) ## 3e+7等于3*10的7次方
Out[4]: float

In [5]: type(12j)
Out[5]: complex

In [7]: type(12L)
Out[7]: long

字符串类型

字符串（str）表一串字符的组合

创建字符串

str = ‘this is a string’ 使用单引号
str = “this is a string” 使用双引号
str = ‘’’this is a string’’’ 使用三个单引号三个双引号
小提示：三个单引号三个双引号还可以作注释

In [8]: type('12L')
Out[8]: str

In [9]: type("12L")
Out[9]: str

In [10]: type('''12L''')
Out[10]: str

In [11]: type("""12L""")
Out[11]: str

字符串是属于序列。序列又包括字符串，列表，元祖。序列都是可以使用索引和切片操作它。

索引：通过序列下标取得单个字符，从0开始，-1表最后一个

In [12]: a='abcde'

In [13]: a[0] ##下标是0的字符
Out[13]: 'a'

In [14]: a[2] ##下标是2的字符
Out[14]: 'c'

切片：通过序列下标连续或间续取得字符集合用分号隔开，从0开始，-1表最后一个，不写表示默认0或者-1

In [15]: a[0:2] ##从下标0开始取，到下标2前一位
Out[15]: 'ab'

In [16]: a[:2] ##不写表示默认用0开始取
Out[16]: 'ab'

In [18]: a[::2] ##这里2表示间断为2取字符
Out[18]: 'ace'

In [20]: a[-2:-4:-1] ##表示从-2从-3下标的字符 -1表示向左
Out[20]: 'dc'

序列的基本操作

序列操作符	作用
len()	求序列的长度
+	连接2个序列
*	重复序列元素后跟次数
in	判断元素是否在序列中
not in	判断元素是否不在序列中
max()	返回最大值
min()	返回最小值
cmp(x, y)	比较两个序列是否相等 1表示左边值大 0表示等于 -1表示右边值大

小提示：字符串之间比较是优先单个字符之间比较，全相同再比较字符串的长度

In [2]: len(a) ##求a变量的长度
Out[2]: 5

In [3]: a + 'f'
Out[3]: 'abcdef'

In [4]: a * 3  ##‘abcde’重复三次
Out[4]: 'abcdeabcdeabcde'

In [5]: 'a' in a  ##判断‘a’是否在变量a里
Out[5]: True

In [7]: 'a' not in a
Out[7]: False

In [8]: max(a)  ##求序列最大值
Out[8]: 'e'

In [9]: min(a)  ##求序列最小值
Out[9]: 'a'

In [10]: cmp(a,'as')  ##‘abced’<'as' 
Out[10]: -1

1.6 元组

元组是存储一系列的值。元组和列表十分相似，定义元祖使用()定义。
元组和字符串一样是不可变的，即定义元祖后元素的值不能重新再赋值。
元祖里面有是可以有任意类型的值字符数字元祖….

创建元祖

使用()把值给定义起来。当只有一个值时要使用,否则类型是值的类型

t= () 创建空元祖
t= (2,) 创建单个值的元祖
t = (‘james’, ‘M’) 创建多个值的元祖

In [18]: t= ('a',a,1)

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

In [14]: t = ('a')  ##类型是字符串

In [15]: type(t)
Out[15]: str

In [16]: t = ('a',)  ##类型是元祖

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

元组索引和分片

In [23]: t[0]  ##元祖的索引 0下标的值
Out[23]: 'a'

In [24]: t[0:2]  ##元祖的分片 下标0-1的值
Out[24]: ('a', 'abcde')

元祖的拆分

把元祖里的值分别再赋值给多个变量

In [30]: t
Out[30]: ('a', 'abcde', 1)

In [31]: a,b,c =t  ##把元祖的值赋值给多个变量

In [32]: a
Out[32]: 'a'

In [33]: b
Out[33]: 'abcde'

In [34]: c
Out[34]: 1

元祖的方法

在Python下元祖，字符串等等都叫对象，对象的方法使用.来引用，再按Tab来查看具体方法

方法	作用
t.count(value)	统计值出现在元祖中的次数
t.index(value)	查出值对应的下标，默认返回第一个

t.count(value)

In [46]: t=('a','b','a',1)

In [49]: t.count('a') ##'a'在元祖中出现2次
Out[49]: 2

In [45]: t.count(0) ##0在元祖中没有出现过
Out[45]: 0

t.index(value)

In [60]: t
Out[60]: ('a', 'b', 'a', 1)

In [61]: t.index('b')  ##'b'的下标是1
Out[61]: 1

In [62]: t.index('a') ##'a'的下标是0和2 默认显示第一个
Out[62]: 0

1.7 列表

列表是非常灵活的数据结构，列表里面的元素是可以改变的，也可以增加或者减少。定义列表使用[]定义。

创建列表

list1 = [] 创建空列表
list2 = list() 使用list函数创建空列表
list3 = [‘a’,1,2] 创建多个值的列表

In [66]: list1=[]

In [67]: type(list1)
Out[67]: list

In [68]: list2=list()  ##使用list函数创建空列表

In [69]: type(list2)
Out[69]: list

In [70]: list3=['a',1,(1,)]

In [72]: type(list3)
Out[72]: list

列表操作

索引

In [74]: list3
Out[74]: ['a', 1, (1,)]

In [76]: list3[1]= ['a','b']  ##通过索引来更改元素的值

In [77]: list3
Out[77]: ['a', ['a', 'b'], (1,)]

分片

In [85]: list3
Out[85]: ['a', ['a', 'b'], (1,), 666]

In [87]: list3[-2::-2]  ##从倒数第二个取 向左两位取下一个数
Out[87]: [(1,), 'a']

列表的方法

方法	作用
L.append(object)	添加对象到列表结尾
L.remove(value)	删除默认第一个出现的值
L.insert(index, object)	插入下标前插入对象
L.sort()	给列表升序
L.reverse()	翻转列表里面的值
L.pop([index])	删除指定索引的值不填默认最后一位
L.extend(iterable)	一次性追加另一个序列中的多个值到列表尾

L.append(object)

In [80]: list3.append(666)

In [81]: list3
Out[81]: ['a', ['a', 'b'], (1,), 666]

L.remove(value)

1	In [89]: list3.remove(666) ##删除666这个值

除了方法外还可以使用del命令使用下标来删除对应的值也可以直接删除列表

1
2
3

In [90]: del list3[0]  ##删除列表下标为0的值

In [91]: del list2  ##删除该列表

L.insert(index, object)

In [100]: list3.insert(0,'a')  ##在下标为0前插入'a'

In [101]: list3
Out[101]: ['a', ['a', 'b'], (1,)]

In [103]: list3    ##下标0是空列表
Out[103]: [[], 'a', ['a', 'b'], (1,)]

In [106]: list3[0].append('a')  在下标0里面添加值

In [107]: list3
Out[107]: [['a'], 'a', ['a', 'b'], (1,)]

L.sort()

In [113]: list3.sort()

In [114]: list3
Out[114]: [['a'], ['a', 'b'], 'a', (1,)]

L.reverse()

In [116]: list3.reverse()

In [117]: list3
Out[117]: [(1,), 'a', ['a', 'b'], ['a']]

L.pop([index])

In [120]: list3.pop(1)  ##把下标是1的值'a'删除掉
Out[120]: 'a'

In [122]: list3.pop()  ##删除最后一位下标的值
Out[122]: ['a']

L.extend(iterable)

In [124]: list3.extend(range(5))  ##把值0-4的一次性添加到列表中

In [125]: list3
Out[125]: [(1,), ['a', 'b'], 0, 1, 2, 3, 4]

内置函数	作用
zip()	把两个列表合并，两个下标1合为新的列表的元祖1

In [1]: list1=['tom',16]

In [2]: list2=['mary',20]

In [4]: zip(list1,list2)
Out[4]: [('tom', 'mary'), (16, 20)]

1.8/1.9 字典

字典是python中的唯一的映射类型。类似哈希表（key-value）
字典对象是可变的，但是字典的键必须使用不可变对象（字符串，元祖，数字），一个字典中可以使用不同类型的键值。定义字典使用{}定义,key和value用:分开。

创建字典

dic = {} 创建空字典
dic1 = dict() 使用dict函数创建空字典
dict((['a',1],['b',2])) dict(a=1, b=2) 使用dict函数创建字典
dic2 = {'a':1,('a',):2} 创建多个key-value的字典

In [7]: dic = {}

In [8]: type(dic)
Out[8]: dict

In [12]: dic2 = {'a':1,('a',):2}

In [13]: type(dic2)
Out[13]: dict

In [70]: dict(a=1,b=2)  ##使用dict函数查看字典
Out[70]: {'a': 1, 'b': 2}

In [71]: dict((['a',1],['b',2]))  ##使用dict函数查看字典
Out[71]: {'a': 1, 'b': 2}

字典的访问

字典中key是唯一的，访问对应的key就可以返回value

In [30]: dic['a']  ##类似索引，[]里面是key
Out[30]: 1

In [31]: dic['a']=2  ##把key是'a'对应的value改为2

In [32]: dic
Out[32]: {'a': 2, ('a',): 2}

字典的遍历

使用for循环可以遍历字典中的元素

In [1]: dic={'a':1,'b':2}

In [8]: for i in dic:
   ...:     print i
   ...:     
a
b

想返回key和value两个值可以使用.items()让字典变为列表再通过，元祖的分拆赋值给两个变量输出

In [10]: for k,v in dic.items():
    ...:     print k,v
    ...:     
a 1
b 2

字典的方法

方法	作用
D.keys()	把所有的key的组成列表
D.values()	把所有的values的组成列表
D.get(k[,d])	获得该key对应的value，如果没有返回设置的d（默认为none）
D.has_key(k)	判断key是否在字典里
D.items()	把字典变为列表
D.copy()	复制字典
D.clear()	清空字典的内容
D.pop(k[,d])	移除该key-value,没有则返回设置的d
D.update(E)	把字典D和E相加
dict.fromkeys(S[,v])	创建新字典字典中的key来自于可迭代（可遍历）对象S, v指定value（默认为none）

D.keys()

1 2	In [22]: dic.keys() Out[22]: ['a', ('a',)]

D.values()

1 2	In [24]: dic.values() Out[24]: [1, 2]

D.get(k[,d])

In [26]: dic.get('a',0)  ## 'a'对应的值是1
Out[26]: 1

In [28]: dic.get(10,0)  ##10没有对应的值，返回0
Out[28]: 0

D.has_key(k)

1 2	In [34]: dic.has_key('a') Out[34]: True

D.items()

1 2	In [37]: dic.items() Out[37]: [('a', 2), (('a',), 2)]

D.copy()

In [39]: a =dic.copy()  ##复制字典给a

In [40]: a
Out[40]: {'a': 2, ('a',): 2}

D.clear()

In [47]: b.clear()  ##清空字典的内容 ，只剩下空字典

In [48]: b  
Out[48]: {}

D.pop(k[,d])

In [55]: dic.pop('a')  ##移除'a':2
Out[55]: 2

In [56]: dic
Out[56]: {('a',): 2}

In [58]: dic.pop('a',666)  ##再移除'a'，已经没有返回666
Out[58]: 666

D.update(E)

In [63]: dic
Out[63]: {('a',): 2}

In [65]: dic1={'a':666,'b':1}

In [66]: dic.update(dic1)  ##把字典dic和字典dic2相加

In [67]: dic
Out[67]: {'a': 666, 'b': 1, ('a',): 2}

dict.fromkeys(S[,v])

1 2	In [76]: dic.fromkeys(range(5),'a') ##range(5)创建0-5的列表并逐个作为key Out[76]: {0: 'a', 1: 'a', 2: 'a', 3: 'a', 4: 'a'}

练习

从键盘上输入信息，存入字典里，再把字典打印出来

内置函数	作用
input()	等待键盘输入数值适合输入数字
raw_input()	等待键盘输入数值结果返回是字符串适合输入字符串

#!/usr/bin/python
#coding:utf-8   ##支持中文

name = raw_input('Please input name: ')
age = raw_input('Please input age: ')
sex = raw_input('Please input M/F: ')
dic = {}
dic['name'] = name  ##把变量name赋值给字典dic的key'name'
dic['age'] = age
dic['sex'] = sex
print dic

[root@kun05 ~]# python 3.py
Please input name: Tom
Please input age: 10
Please input M/F: M
{'age': '10', 'name': 'Tom', 'sex': 'M'}

优化打印结果

#!/usr/bin/python

name = raw_input('Please input name: ')
age = raw_input('Please input age: ')
sex = raw_input('Please input M/F: ')
dic = {}
dic['name'] = name
dic['age'] = age
dic['sex'] = sex
for k,v in dic.items():  
    print '%s: %s' %(k,v)

dic.items() 把字典变为列表
for循环遍历序列（列表，元祖，字符串）结果分别是（元祖，字符串，字符）
k和v 作用接受遍历出来的元素（这里是元祖）就是元祖的拆分 k,v=(‘name’,’Tom’)
只有k就接受列表中的元祖

[root@kun05 ~]# python 3.py
Please input name: Tom
Please input age: 10
Please input M/F: M
age: 10
name: Tom
sex: M