只差一点点

这就是最好的时代

Python学习日志Day3

分类于

始、Python数据类型

序列：一组按照顺序排列的数据集合

Python中有三种内置的序列类型：字符串、列表、元组

​ 优点：支持索引和切片操作

​ 特征：第一个正索引为0，指向左端，第一个索引为负数的时候指向右端

一、字符串

切片：截取字符串中的其中一段内容

语法：[起始下标：结束下标：步长]，[start: end: step]，不包含end，step默认是1

1
2
3
4
5
6
7
8
9
#切片
strMsg = 'hello world'
#slice[start: end: step] 左闭右开
print(strMsg)
print(strMsg[2: 7: 1])
print(strMsg[2:])
print(strMsg[: 3])
print(strMsg[: : -1])
print(strMsg[: : -2])

输出：

1
2
3
4
5
6
7
8
i love python
I LOVE PYTHON
hello world
llo w
llo world
hel
dlrow olleh
drwolh

下标会越界，切片不会

常用函数：

1.capitalize()：将字符串首字母变成大写

2.strip()：去除字符串中的空格

3.lstrip()：去除字符串左边空格

4.rstrip()：去除字符串右边空格

5.id()：查看对象的内存地址

6.find()：查找对象是否在序列中，返回第一个对象下标，不存在返回-1

7.index()：检测字符串中是否包含子字符串，返回下标，不存在则报错

8.startswith()：判断是否以某子串开头

9.endswith()：判断是否以某子串结尾

10.lower()：转换成小写

11.upper()：转换成大写

12.join()：循环取出所有值用xx去连接

13.split()：切割字符串

14.count()：统计出现的次数

…

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
#常用函数
name = 'peter'
print(name.capitalize())
#
a = '          hello    '
b = a.strip()
print(a)
print(b)
#
b = a
print('a的内存地址%d'%id(a))
print('b的内存地址%d'%id(b))
#
dataStr = 'I love python'
print(dataStr.find('p'))
print(dataStr.find('a'))
print(dataStr.index('o'))
#
print(dataStr.startswith('I'))
print(dataStr.endswith('o'))
#
print(dataStr.lower())
print(dataStr.upper())

输出：

1
2
3
4
5
6
7
8
9
10
11
Peter
          hello
hello
a的内存地址2290605664992
b的内存地址2290605664992
7
3
True
False
i love python
I LOVE PYTHON

二、元组

元组是一种不可变的序列，创建之后不能做任何的修改，特点：

​ 1.不可变

​ 2.用（）创建元组类型，数据项之间用逗号分隔，数据项可以是任意数据类型

​ 3.元组中只有一个元素时，要加逗号以免被当作其他类型

​ 4.支持切片操作

元组不可修改，但是元组中的列表中的元素可以修改

常用方法与列表相似：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
tupleA = (1, )
print(type(tupleA))
print(id(tupleA))

tupleA = ('abcd', 66, 1.255, [22, 'fafa'])
print(tupleA)
print(id(tupleA))

for item in tupleA:
    print(item, end = ' ')
    pass
print()

print(tupleA[2: 4])
print(tupleA[-1: -4: -2]) #反向遍历下标从-1开始
print(tupleA[-4: -2: ])

tupleA[3][0] = 66
print(tupleA)

print(tupleA.count(66)) #统计元素出现的次数

输出：

1
2
3
4
5
6
7
8
9
10
<class 'tuple'>
1350340798616
('abcd', 66, 1.255, [22, 'fafa'])
1350340804424
abcd 66 1.255 [22, 'fafa']
(1.255, [22, 'fafa'])
([22, 'fafa'], 66)
('abcd', 66)
('abcd', 66, 1.255, [66, 'fafa'])
1

三、列表

列表是一种有序的数据集合，特点：

​ 1.支持增删查改

​ 2.列表中的数据可以变化

​ 3.用[ ]表示列表类型，数据项之间用逗号分隔，数据项可以是任意数据类型

​ 4.支持索引和切片操作

常用方法：

1.append()：在列表后面追加元素

2.count()：统计元素出现的次数

3.extend()：扩展，相当于批量添加

4.index()：获取指定元素索引号

5.insert()：在指定位置插入

6.pop()：删除最后一个元素

7.remove()：移除左边找到的第一个元素

8.reverse()：反转列表

9.sort()：列表排序

10.len()：获取列表对象的数据个数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
#列表
li = []
print(type(li))
li = [1, 2, 3, '你好']
print(len(li))

#查找、遍历
listA = ['abcd', 785, 12.23, 'qiuzhi', True]
print(listA[3])
print(listA[1: 4]) #左闭右开
print(listA * 3)
print(listA.index(True))

#增加
listA.append(['fff', 'ddd'])
print(listA)
listA.insert(1, '插入')
print(listA)
rsData = list(range(10))
listA.append(rsData)
print(listA)

#修改
listA[0] = 'peter'
print(listA)

#删除
del listA[7]
print(listA)
del listA[1: 7: 5] #切片批量删除
print(listA)
listA.remove(785)
print(listA)
listA.pop()
print(listA)
listA.pop(0)
print(listA)

输出：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
<class 'list'>
4
qiuzhi
[785, 12.23, 'qiuzhi']
['abcd', 785, 12.23, 'qiuzhi', True, 'abcd', 785, 12.23, 'qiuzhi', True, 'abcd', 785, 12.23, 'qiuzhi', True]
4
['abcd', 785, 12.23, 'qiuzhi', True, ['fff', 'ddd']]
['abcd', '插入', 785, 12.23, 'qiuzhi', True, ['fff', 'ddd']]
['abcd', '插入', 785, 12.23, 'qiuzhi', True, ['fff', 'ddd'], [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]]
['peter', '插入', 785, 12.23, 'qiuzhi', True, ['fff', 'ddd'], [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]]
['peter', '插入', 785, 12.23, 'qiuzhi', True, ['fff', 'ddd']]
['peter', 785, 12.23, 'qiuzhi', True]
['peter', 12.23, 'qiuzhi', True]
['peter', 12.23, 'qiuzhi']
[12.23, 'qiuzhi']

四、字典

字典是以键值对 {‘key': 'value’} 的形式创建并可以存储任意对象的数据类型

键（key）不能重复，值（value）可以重复

键（key）只能是不可变类型，如数字、字符串、元组

字典不是序列类型， 没有下标的概念，是一个无序的键值集合

常用方法：

1.keys()：获取所有的键

2.values()：获取所有的值

3.items()：获取所有的键值对

4.update()：更新键值对，可以修改也可以添加

5.pop()：删除指定键

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
#初始化
from typing import ItemsView
dictA = {'pro': '艺术', 'school': '北影'}
print(type(dictA))
#赋值
dictA['name'] = '刘德华'
dictA['age'] = '50'
dictA['pos'] = '影星'
print(dictA)
print(len(dictA))
print(dictA['name'])
#修改
dictA['name'] = '张家辉'
dictA['school'] = '港大'
dictA.update({'age': '40'})
dictA.update({'height': '180'})
print(dictA)
#输出
print(dictA.keys())
print(dictA.values())
print(dictA.items())
for key,value in dictA.items():
    print('%s==%s'%(key, value))
    pass
#删除
del dictA['name']
dictA.pop('age')
print(dictA)
#排序
print(sorted(dictA.items(), key = lambda d: d[0]))
print(sorted(dictA.items(), key = lambda d: d[1]))

输出：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
<class 'dict'>
{'pro': '艺术', 'school': '北影', 'name': '刘德华', 'age': '50', 'pos': '影星'}
5
刘德华
{'pro': '艺术', 'school': '港大', 'name': '张家辉', 'age': '40', 'pos': '影星', 'height': '180'}
dict_keys(['pro', 'school', 'name', 'age', 'pos', 'height'])
dict_values(['艺术', '港大', '张家辉', '40', '影星', '180'])
dict_items([('pro', '艺术'), ('school', '港大'), ('name', '张家辉'), ('age', '40'), ('pos', '影星'), ('height', '180')])
pro==艺术
school==港大
name==张家辉
age==40
pos==影星
height==180
{'pro': '艺术', 'school': '港大', 'pos': '影星', 'height': '180'}
[('height', '180'), ('pos', '影星'), ('pro', '艺术'), ('school', '港大')]
[('height', '180'), ('pos', '影星'), ('school', '港大'), ('pro', '艺术')]

五、通用操作

1.+：合并两个对象

2.*：对象自身按指定次数复制合并

3.in：判断元素是否存在

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#
strA = '人生苦短'
strB = '我用Python'
print(strA + strB)
listA = list(range(11))
listB = list(range(11, 20))
print(listA + listB)
#
print(strA * 3)
print(listA * 2)
#
print('生' in strA)
print(8 in listA)
print(10 in listB)
dictA = {'name': 'peter'}
print('name' in dictA)

输出：

1
2
3
4
5
6
7
8
人生苦短我用Python
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]
人生苦短人生苦短人生苦短
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
True
True
False
True