1.5 python的数值和字符串、1.6 元组、1.7 列表

2019独角兽企业重金招聘Python工程师标准>>>

1.5 python的数值和字符串

数值的类型

• 整型： int

整数类型的范围是 2的32次方

整数又分为，正数和负数 所以他的范围为

负的 2的31次方 到 正的 2的31次方 减一，因为还有一个0 位 也就是 -2147483648 到 2147483647 //中间还有一个 0 这个位

• 长整型：long

当范围超出整型以后，显示出来的数值最后会有一个 L ，这个就是长整型 赋值为长整型 的 L 不分大小写

• 浮点型：float

科学计数法也属于浮点型

例：

0.1 12.0

• 复数型：complex

赋值： J

字符串

三种方法赋值为字符串

单引号，双引号 ，引号

'
"
'''
"""

三引号，也可以做注释用

例：手写 换行会比较麻烦，可以用 三引号直接回车换号

In [48]: a = 'hello\nworld'

In [49]: print a
hello
world

In [50]: a = '''hello
    ...: world'''

In [51]: a
Out[51]: 'hello\nworld'

In [52]: print a
hello
world

知识点：

• 字符串切片

字符串为一个序列，可以通过索引进行切片。索引从0开始

索引，取最后一位，可以用-1来表示。

In [53]: a = "abcdefg"

In [55]: a[0:5]
Out[55]: 'abcde'

In [56]: a = "abcdefgwsdkfuqwebaksdhadjhj"

In [57]: a[-1]
Out[57]: 'j'

从第一位开始取字符串的时候，0位可以不写，同样取到最后一位的时候，可以不写最后一位

In [58]: a
Out[58]: 'abcdefgwsdkfuqwebaksdhadjhj'

In [59]: a[5:]
Out[59]: 'fgwsdkfuqwebaksdhadjhj'

In [61]: a[:7]
Out[61]: 'abcdefg'

• 步径值

可以理解为，一位一位的取，

In [62]: a[::1]          //一位一位的取值
Out[62]: 'abcdefgwsdkfuqwebaksdhadjhj'

In [63]: a[::2]        // 走两位去一个值
Out[63]: 'acegskuwbkdajj'

In [64]: a[::3]        //同理可得
Out[64]: 'adgduekhj'

In [65]: a[::4]        //同理可得
Out[65]: 'aesubdj'

• 反向排序取值

In [72]: a
Out[72]: 'ABVDEFGHIJKLMNOPQRSTUVWSYZ'

In [73]: a[-5:-7]                        // -7为比-5还要靠前，所以取到的值为空
Out[73]: ''

In [74]: a[-5:-5]                        // -7为比-5还要靠前，所以取到的值为空
Out[74]: ''

In [75]: a[-5:-2]                        // 因为-1是最后一位，所以-5到-2位，就能取到应有的值
Out[75]: 'VWS'

• 反向取值

In [72]: a
Out[72]: 'ABVDEFGHIJKLMNOPQRSTUVWSYZ'

In [76]: a[-5:-7:-1]          //加上 -1 以后就能正确取值了，因为这个-1 在这里表示方向，不写，一般默认为0 表示正向
Out[76]: 'VU'

1.6 元组

• 元组属于序列的一种

• 序列有三种

• 字符串、列表和元组都是序列

序列的两个主要特点都是索引操作符合切片操作符

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

<>

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

序列的基本操作

1、 len() //求序列或者元素的长度

In [77]: len(a)
Out[77]: 26

2、 “+” //连接两个序列，不能连接非字符串

In [78]: a + 'a'
Out[78]: 'ABVDEFGHIJKLMNOPQRSTUVWSYZa'

3、 “*” //重复序列元素 ，重复次数必须为数值

In [82]: '#$ %' * 7            //重复7次
Out[82]: '#$ %#$ %#$ %#$ %#$ %#$ %#$ %'

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

也有not in

In [83]: 'a' in a
Out[83]: False

In [84]: 'A' in a
Out[84]: True

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

In [85]: max(a)
Out[85]: 'Z'

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

In [86]: min(a)
Out[86]: 'A'

7、 cmp(x,y) //比较两个序列是否相等

In [94]: a
Out[94]: 'ABVDEFGHIJKLMNOPQRSTUVWSYZ'

In [95]: b
Out[95]: 'BVDEFGHIJKLMNOPQRSTUVWSY'

In [97]: c
Out[97]: 'BVDEFGHIJKLMNOPQRSTUVWSY'

In [92]: cmp(a,b)
Out[92]: -1

In [93]: cmp(b,a)
Out[93]: 1

In [98]: cmp(b,c)
Out[98]: 0

元组 tuple

用括号来定义 ( )

元组和列表十分相似

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

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

定义元组

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

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

In [104]: t1 = (1)

In [105]: type(t1)
Out[105]: int

In [106]: t1
Out[106]: 1

In [107]: t1 = (1,)            //定义的时候如果只有一个元素要加个 逗号 “，”，才会被认为是元组

In [108]: type(t1)
Out[108]: tuple

元组的拆分

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

In [111]: t
Out[111]: ('ABVDEFGHIJKLMNOPQRSTUVWSYZ', 'b', 'BVDEFGHIJKLMNOPQRSTUVWSY', 'c')

In [112]: first, second, third = t //变量支持解压的值，貌似有限。。。
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-112-ca88106418c1> in <module>()
----> 1 first, second, third = t

ValueError: too many values to unpack


In [118]: t
Out[118]: ('abcde', 'b', 'BVDEFGHIJKLMNOPQRSTUVWSY', 'c') 

In [119]: first, second, =t  // 貌似不能同时解压两个变量？还是这个值的长度依然超标
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-119-3d861d4a71e7> in <module>()
----> 1 first, second, =t

ValueError: too many values to unpack





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

In [122]: t
Out[122]: ('abcde', 'b', 'c')

In [123]: first, second, third=t  //有时候，在数据量大的情况下，可以通过这个变量去接收元组的值

In [124]: first
Out[124]: 'abcde'

通过ipython 可以使用tab 补全看这个元组有什么方法

t.count

这个方法就是判断元素，是否在元组里

In [130]: t
Out[130]: ('abcde', 'b', 'c')

In [129]: t.count('b')
Out[129]: 1

In [125]: t.count(b)
Out[125]: 0

In [126]: t.count(c)
Out[126]: 0

t.index 告知元素所在元组的位置

In [130]: t
Out[130]: ('abcde', 'b', 'c')

In [135]: t.index('b')
Out[135]: 1

In [136]: t.index('c')
Out[136]: 2

In [137]: t.index(a)
Out[137]: 0

1.7 列表

定义

• 列表 用 [ ] 来定义

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

• 列表是可变类型的数据

创建列表

例：

-list =[]
-list2 = list()
-list3 = ['a',1,2]

取值

In [2]: list1 = []

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

In [4]: list2 = list()

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

In [6]: list2
Out[6]: []

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

In [9]: list3
Out[9]: ['a', 1, (1,), ['hello', 'python']]

In [10]: len(list3)
Out[10]: 4

每个元素以逗号分开“，”

改变元素

In [11]: list3[0]
Out[11]: 'a'

In [12]: list3[0] = 'b'

In [13]: list3
Out[13]: ['b', 1, (1,), ['hello', 'python']]

追加元素

In [14]: list2
Out[14]: []

In [15]: list2.append('linux')

In [16]: list2
Out[16]: ['linux']

删除

• 根据下表进行执行

这样操作需要先知道元素的下标

del list3[]

In [13]: list3
Out[13]: ['b', 1, (1,), ['hello', 'python']]

In [20]: del list3[-1]

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

del 也可以直接用于删除变量

In [22]: list2
Out[22]: ['linux']

In [23]: del list2

In [24]: list2
---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
<ipython-input-24-db9b7629a516> in <module>()
----> 1 list2

NameError: name 'list2' is not defined

• 通过列表里面的方法

list3.remove，这个方法会删除列表里面第一个出现的元素（可以根据help(list3.remove)进行查看方法的东西）

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

In [26]: list3.append(1)

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

In [28]: list3.remove(1)

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

连接列表

In [17]: list3 + list2
Out[17]: ['b', 1, (1,), ['hello', 'python'], 'linux']

运算

运算优先级，加号，之后再运行乘号（重复显示这个list3+list2 2次）

In [18]: (list3 + list2) * 2
Out[18]:
['b',
1,
(1,),
['hello', 'python'],
'linux',
'b',
1,
(1,),
['hello', 'python'],
'linux']

查找

可以直接使用逻辑方法进行查询

In [30]: 'a' in list3
Out[30]: False

In [31]: '1' in list3
Out[31]: False

In [32]: 'a' not in list3
Out[32]: True

In [33]: '1' not in list3
Out[33]: True

插入

list3.insert()

插入的时候，需要表明是在那个索引前面添加

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

In [35]: list3.insert(1,list1)

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

往列表里面的列表添加

需要表明元素所在索引

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

In [38]: list3[1].append('abc')

In [39]: list3
Out[39]: ['b', ['abc'], (1,), 1]

排序

升序排序

list3.sort

In [39]: list3
Out[39]: ['b', ['abc'], (1,), 1]

In [41]: list3.sort()

In [42]: list3
Out[42]: [1, ['abc'], 'b', (1,)]

翻转

list3.revse


In [42]: list3
Out[42]: [1, ['abc'], 'b', (1,)]

In [43]: list3.reverse()

In [44]: list3
Out[44]: [(1,), 'b', ['abc'], 1]

pop方法

删除一个指定索引，并返回到屏幕（感觉想，告诉你，我把这个东西删了）

In [49]: list3
Out[49]: [(1,), 'b', ['abc'], 1]

In [50]: list3.pop(1)
Out[50]: 'b'

In [51]: list3
Out[51]: [(1,), ['abc'], 1]

extend方法

• 字符串，元组，序列都是可迭代的（理解为依次进去或许好一些）

所以，都可以用extend方法添加

In [53]: range(5)
Out[53]: [0, 1, 2, 3, 4]

In [54]: list3.extend(range(5))

In [55]: list3
Out[55]: [(1,), ['abc'], 1, 0, 1, 2, 3, 4]

In [56]: list3.extend('dbdetw')

In [57]: list3
Out[57]: [(1,), ['abc'], 1, 0, 1, 2, 3, 4, 'd', 'b', 'd', 'e', 't', 'w']

In [58]: t = ('t1','t2')

In [59]: t
Out[59]: ('t1', 't2')

In [60]: list3.extend(t)

In [61]: list3
Out[61]: [(1,), ['abc'], 1, 0, 1, 2, 3, 4, 'd', 'b', 'd', 'e', 't', 'w', 't1', 't2']

11月20日习题

练习1：

将 “123” 转换成整数

In [63]: a = "123"

In [64]: type(a)
Out[64]: str

In [65]: b = int(a)

In [66]: type(b)
Out[66]: int

将 “9999999999999999999” 转换成长整数

In [67]: a = "9999999999999999999"

In [68]: type(a)
Out[68]: str

In [69]: b = long(a)

In [70]: b
Out[70]: 9999999999999999999L

将 “3.1415926” 转换成一个浮点数

In [71]: a = "3.1415926"

In [72]: type(a)
Out[72]: str

In [73]: b = float(a)

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

将 123 转换成一个字符串

In [75]: a = 123

In [76]: a
Out[76]: 123

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

In [78]: b = str(a)

In [79]: b
Out[79]: '123'

In [80]: type(b)
Out[80]: str

现有以下字符串

• 字符串1：" abc deFGh&*ijkl opq mnrst((uvwxyz "
• 字符串2：" ABC#DEF GH%IJ MNOPQ KLRS&&TUVWX(*&YZ " 使用字符串的各种方法转换成如下方式
• ABCDEFGHIJKLMNOPQRSTUVWXYZzyxwvutsrqponmlkjihgfedcba

In [82]: a= " abc deFGh&*ijkl opq mnrst((uvwxyz "

In [83]: a
Out[83]: ' abc deFGh&*ijkl opq mnrst((uvwxyz '

In [84]: b = " ABC#DEF GH%IJ MNOPQ KLRS&&TUVWX(*&YZ "

In [85]: b
Out[85]: ' ABC#DEF GH%IJ MNOPQ KLRS&&TUVWX(*&YZ '

In [97]: aa = a[1:4] + a[5:7] + a[9:10] + a[12:16] + a[21:23] + a[17:20] + a[23:26] + a[28:34]

In [98]: aa
Out[98]: 'abcdehijklmnopqrstuvwxyz'

In [138]: bb = b[1:4] +b[5:8] + b[9:11] + b[12:14] + b[21:23] + b[15:17] + b[17:20] + b[23:25] + b[27:32] + b[35:37]

In [139]: c = bb + aa[::-1]

In [140]: c
Out[140]: 'ABCDEFGHIJKLMNOPQRSTUVWXYZzyxwvutsrqponmlkjihedcba'

练习2：

现有列表

list1 = ['XXXX', 'b', 3, 'c', '&', 'a', 3, '3', 3, 'aa', '3', 'XXXX']
list2 = ['e', 'f', 'g']


In [141]: list1 = ['XXXX', 'b', 3, 'c', '&', 'a', 3, '3', 3, 'aa', '3', 'XXXX']

In [142]: list2 = ['e', 'f', 'g']

要求对其做以下操作：

1. 取出 ‘XXXX’ 中间的部分，形成一个新的列表list3

In [158]: list3 = list1[1:11]

In [160]: list3
Out[160]: ['b', 3, 'c', '&', 'a', 3, '3', 3, 'aa', '3']

2. 对list3 做一下几部操作

1）删除特殊符号

In [162]: list3
Out[162]: ['b', 3, 'c', '&', 'a', 3, '3', 3, 'aa', '3']

In [168]: list3.index('&')
Out[168]: 3

In [169]: list3.pop(3)
Out[169]: '&'

In [170]: list3
Out[170]: ['b', 3, 'c', 'a', 3, '3', 3, 'aa', '3']

2）统计 3 在list3中出现的次数 没有加 引号，应该是指变量吧

In [170]: list3
Out[170]: ['b', 3, 'c', 'a', 3, '3', 3, 'aa', '3']

In [171]: list3.count(3)
Out[171]: 3

3）用最简短的代码去除list3中 26个字母以外的元素(要求只能对list3操作)

In [170]: list3
Out[170]: ['b', 3, 'c', 'a', 3, '3', 3, 'aa', '3']

In [174]: list3.sort()

In [182]: list3
Out[182]: [3, 3, 3, '3', '3', 'a', 'aa', 'b', 'c']

In [183]: del list3[:5]

In [187]: list3
Out[187]: ['a', 'aa', 'b', 'c']

4）对list3排序

In [5]: list3
Out[5]: ['a', 'aa', 'b', 'c']

In [6]: list3.reverse()

In [7]: list3
Out[7]: ['c', 'b', 'aa', 'a']

5）在末尾追加'd',并把list2追加到list3

In [7]: list3
Out[7]: ['c', 'b', 'aa', 'a']

In [14]: list3
Out[14]: ['c', 'b', 'aa', 'a', 'e', 'f', 'g', 'd']

In [9]: list2
Out[9]: ['e', 'f', 'g']

In [15]: list3.extend(list2)

In [16]: list3
Out[16]: ['c', 'b', 'aa', 'a', 'e', 'f', 'g', 'd', 'e', 'f', 'g']

练习3. 现有两个变量

a = ('h',) b = ('h')

1）将a和b分别追加到上一题的list3中，观察有什么区别

In [37]: list3 = ['c', 'b', 'aa', 'a', 'e', 'f', 'g', 'd', 'e', 'f', 'g']

In [38]: a
Out[38]: ('h',)

In [39]: b
Out[39]: 'h'

In [40]: list3.append(a)

In [41]: list3
Out[41]: ['c', 'b', 'aa', 'a', 'e', 'f', 'g', 'd', 'e', 'f', 'g', ('h',)]

In [42]: list3.append(b)

In [43]: list3
Out[43]: ['c', 'b', 'aa', 'a', 'e', 'f', 'g', 'd', 'e', 'f', 'g', ('h',), 'h']

2）将1生成的list3转换成元组(扩展：自己搜索方法)

In [45]: c = tuple(list3)

In [46]: c
Out[46]: ('c', 'b', 'aa', 'a', 'e', 'f', 'g', 'd', 'e', 'f', 'g', ('h',), 'h')

3）打印出只有一个元素'h'的元组，在2中生成的元组中的索引

In [47]: c.count('h')
Out[47]: 1

In [48]: c[-1]
Out[48]: 'h'

转载于:https://my.oschina.net/nova12315/blog/2878749