Python入门第二步：Python内置类型 String，List，Dict，Tuple，Set_list tuple dict set string如何切片

本节将详细介绍string，list，dict，tuple，set的用法，以及面试中经常问到的类型转换以及排序。

String

在这里重点介绍了字符串的切片方法
字符串的输入：input获取的数据，都以字符串的方式进行保存，即使输入的是数字，那么也是以字符串方式保存
字符串的输出：%s（后面讲到进制转换的时候回介绍d%，o%等）

	userName = input('请输入用户名:')
    print("用户名为：%s" % userName)

    password = input('请输入密码:')
    print("密码为：%s" % password)
1
2
3
4
5

下标和切片

字符串本身是可迭代对象，可以通过下表来取值
切片是指对操作的对象截取其中一部分的操作。字符串、列表、元组都支持切片操作,切片的基本形式：[起始:结束:步长]，其中步长为可选字段，选取的范围用数学语言描述：[起始，结束)
• [:] 提取从开头（默认位置0）到结尾（默认位置-1）的整个字符串
• [start:] 从start 提取到结尾
• [:end] 从开头提取到end - 1
• [start:end] 从start 提取到end - 1
• [start?step] 从start 提取到end - 1，每step 个字符提取一个
• 左侧第一个字符的位置/偏移量为0，右侧最后一个字符的位置/偏移量为-1
•可以理解为选定区域[start,end) 当步长为负数的时候，从start开始，往前推，如果在选定区域就有值，如果步长为正数，则从start开始往后推…
在基础Python面试题的时候经常会遇到对字符串的逆序操作，就可以用切片

'''下标'''
  name = 'abcdef'

   print(name[0])
   print(name[1])
   print(name[2])

'''切片'''
     name = 'abcdef'
     print(name[0:3]) # 取 下标0~2 的字符
'''切片的高级用法，弄懂这个列子就足够了'''
   li=[1,2,3,4,5,6,7,8,9,10]
    print(li[:])#输出全部
    print(li[:-1])#输出1-9
    print(li[:-2])#输出1-8
    print(li[::])#输出全部
    print(li[::2])#输出1,3,5,7,9
    print(li[::-1])#逆序输出
    print(li[::-2])#输出10,8,6,4,2
    print(li[1::-1])#输出2,1
    print(li[1:2:-2])#空
    print(li[3:1:-1])#4,3
    print(li[3:6])
    print(li[3:6:-1])#输出空
    print(li[3:0:-1])#输出4,3,2
    print(li[-2:1:-2])#输出9,7,5,3
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

字符串常见操作

find：检测 str 是否包含在 mystr中，如果是则返回第一次检索到的索引值并结束检索，否则返回-1
count：统计子串在原串中出现的次数
index：mystr.index(str, start=0, end=len(mystr)) ，跟find()方法一样，返回寻找子串的第一次出现的索引，只不过如果str不在 mystr中会报一个异常.
replace：把 mystr 中的 str1 替换成 str2,如果 count 指定，则替换不超过 count 次，mystr.replace(str1, str2, mystr.count(str1))
split：以 str 为分隔符切片 mystr，如果 maxsplit有指定值，则仅分隔 maxsplit 个子字符串，mystr.split(‘切分标志’，分成的段数),值得注意的是split切分之后会将字符串的类型转换成列表类型，从而可以使用列表的属性
capitalize：把字符串的第一个字符大写
title： 把字符串的每个单词首字母大写
startswith：检查字符串是否是以 hello 开头, 是则返回 True，否则返回 False
endswith：检查字符串是否以obj结束，如果是返回True,否则返回 False.
lower：转换 mystr 中所有大写字符为小写
upper：转换 mystr 中的小写字母为大写
center：返回一个原字符串居中,并使用空格填充至长度 width 的新字符串
lstrip：删除 mystr 左边的空白字符
rstrip：删除 mystr 右边的空白字符
strip：删除mystr字符串两端的空白字符
rfind：类似于 find()函数，不过是从右边开始查找
rindex：类似于 index()，不过是从右边开始.
partition：把mystr以str分割成三部分,str前，str和str后
isalpha：如果 mystr 所有字符都是字母 则返回 True,否则返回 False
isdigit：如果 mystr 只包含数字则返回 True 否则返回 False.
isalnum：如果 mystr 所有字符都是字母或数字则返回 True,否则返回 False
join：拼接字符串，如果拼接的字符串较小，可以直接使用+来连接，如果多久用join，mystr.join(str)，str每个字符串后面加mystr,构造出一个新的字符串

最常用的也就这么些吧，用法大同小异，值得注意的是以上操作都是深拷贝，即源字符串的形式是没有变的。

     st1='abcdabb'
    print(st1.find('b'))#1
    print(st1.find('da'))#3
    print(st1.count('ab'))#2
    print(st1.index('b'))#1
    print(st1.index('b',2))#5
    st2='cc dda bc ddb'
    print(st2.replace('dd','**'))
    print(st2.replace('dd', '**',1),st2)
    st3=st2.split(' ',2)
    st3.append(100)
    print(st2.split(' ',2),type(st2),st2,type(st3))
    str4='   stick to a little bit of accumulation every day     '
    print(str4.capitalize())
    print(str4.title())
    print(str4.startswith('ck'))
    print(str4.endswith('ay',1))
    print(str4.lower())
    print(str4.upper())
    print(str4.center(50))
    print(str4.lstrip())
    print(str4.partition('of'))
    print(str4.isalpha())
    print(str4.isdigit())
    a='hello'
    b='word '
    print(','.join(b))
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

列表

列表的基本形式[],可通过循环来取值，和c的数组概念差不多，列表常见方法如下：
append：通过append可以向列表追加加元素（尾插）
extend：可以将另一个集合中的元素逐一添加到列表中
insert：insert(index, object) 在指定位置index前插入元素object
所谓的查找，就是看看指定的元素是否存在
in, not in
python中查找的常用方法为：
in（存在）,如果存在那么结果为true，否则为false
not in（不存在），如果不存在那么结果为true，否则false
index和count与字符串中的用法相同
del：根据下标进行删除
pop：删除最后一个元素
remove：根据元素的值进行删除
sort方法是将list按特定顺序重新排列，默认为由小到大，参数reverse=True可改为倒序，由大到小。
reverse方法是将list逆置

    namesList = ['xiaoWang','xiaoZhang','xiaoHua']
    for name in namesList:
        print(name)

   #定义变量A，默认有3个元素
    A = ['xiaoWang','xiaoZhang','xiaoHua']

    print("-----添加之前，列表A的数据-----")
    for tempName in A:
        print(tempName)

    #提示、并添加元素
    temp = input('请输入要添加的学生姓名:')
    A.append(temp)

    print("-----添加之后，列表A的数据-----")
    for tempName in A:
        print(tempName)
       
    li1=[1,2,3,4]
    li2=['a','b','c']
    li1.append(li2)
    print(li1)
    li.extend(li2)
    print(li1)
    # 待查找的列表
    nameList = ['xiaoWang', 'xiaoZhang', 'xiaoHua']

    # 获取用户要查找的名字
    findName = input('请输入要查找的姓名:')

    # 查找是否存在
    if findName in nameList:
        print('在字典中找到了相同的名字')
    else:
        print('没有找到')

    movieName = ['加勒比海盗', '骇客帝国', '第一滴血', '指环王', '霍比特人', '速度与激情']

    print('------删除之前------')
    for tempName in movieName:
        print(tempName)

    del movieName[2]
    # movieName.pop()
    # movieName.remove('指环王')

    print('------删除之后------')
    for tempName in movieName:
        print(tempName)

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
38
39
40
41
42
43
44
45
46
47
48
49
50
51

元祖

Python的元组与列表类似，不同之处在于元组的元素不能修改，即元祖没有增删改方法，只有查找，统计和排序方法。元组使用小括号，列表使用方括号

a = ('a', 'b', 'c', 'a', 'b')
a.index('a', 1, 3) # 注意是左闭右开区间
a.count('b')
a.index('a', 1, 4) 

1
2
3
4
5

字典

字典是以key:value的方式来存储数据，即键值对
info = {‘name’:‘班长’, ‘id’:100, ‘sex’:‘f’, ‘address’:‘地球亚洲中国北京’}这是一个普通的字典
字典和列表一样，也能够存储多个数据
列表中找某个元素时，是根据下标进行的，字典中找某个元素时，是根据’名字’（就是冒号:前面的那个值，例如上面代码中的’name’、‘id’、‘sex’），字典的每个元素由2部分组成，键:值。例如 ‘name’:‘班长’ ,'name’为键，'班长’为值

字典的常用方法如下：
在增加方法中，如果在使用 变量名[‘键’] = 数据 时，这个“键”在字典中，不存在，那么就会新增这个元素

'''查看元素'''
    info = {'name':'吴彦祖','age':18}

    print(info['age']) # 获取年龄

    # print(info['sex']) # 获取不存在的key，会发生异常

    print(info.get('sex')) # 获取不存在的key，获取到空的内容，不会出现异常
    =========================================================
    '''修改元素'''
        info = {'name':'班长', 'id':100, 'sex':'f', 'address':'地球亚洲中国北京'}

    newId = input('请输入新的学号')

    info['id'] = int(newId)

    print('修改之后的id为%d:'%info['id'])
    ====================================
     info = {'name':'班长', 'sex':'f', 'address':'地球亚洲中国北京'}

    # print('id为:%d'%info['id'])#程序会终端运行，因为访问了不存在的键

    newId = input('请输入新的学号')

    info['id'] = newId

    print('添加之后的id为:%d'%info['id'])

=======================================================
 info = {'name':'班长', 'sex':'f', 'address':'地球亚洲中国北京'}

    print('删除前,%s'%info['name'])

    del info['name']   #删除指定元素
    del info   #删除字典
    info.clear()     #清楚字典

    print('删除后,%s'%info['name'])
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
38

len(dict)测量字典中，键值对的个数
dict.keys()返回一个包含字典所有KEY的列表
dict,values()返回一个包含字典所有KEY的列表
dict.items()返回一个包含所有（键，值）元祖的列表

字典的遍历：

1、遍历key值，value值（下面写法完全等价）：
a = {'a': '1', 'b': '2', 'c': '3'}
方式一：
for key in a:
    print(key+':'+a[key])
方式二：
for key in a.keys():
    print(key+':'+a[key])
方式三：
for key,value in a.items():
       print(key+':'+value)
方式四：
for (key,value) in a.items():
    print(key+':'+value)

 
2、遍历value值：
for value in a.values():
    print(value)
 
3、遍历字典项
for kv in a.items():
    print(kv)
打印结果：
('a', '1')
('b', '2')
('c', '3')
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

集合

集合是无序的，集合中的元素是唯一的，集合一般用于元组或者列表中的元素去重，感觉集合最大的作用就是去重复
集合的基本操作：
add：向集合中添加元素
update：将传递的元素拆开，一个一个添加到集合当中，但无序
remove：删除指定元素，如果元素不存在会报错
pop：随机删除集合中的元素，如果集合为空那么会直接报错
discard：删除指定元素，如果元素不存在不做任何操作
**&：**取两个结合的交集
**|：**取两个集合的并集

  set1 = set()
  # 注意以下写法为一个空字典
  set2 = {}
  set1 = {1, 2, 4, 5}
#添加元素
set1.add(8)

set1 = {1, 2, 4, 5}
#是把要传入的元素拆分，做为个体传入到集合中
set1.update("abcd")  #1,2，a，2,4，b,c,5,d集合无序

set1 = {1, 2, 4, 5}

# 使用remove删除集合中的元素 如果有 直接删除 如果没有 程序报错
set1.remove(22)

set1 = {1, 2, 4, 5}

# 使用pop删除是随机删除集合中的元素 如果set1没有元素讲程序报错
set1.pop()

set1 = {1, 2, 4, 5}

# 使用discard删除 如果元素存在 直接删除 如果元素不存在 不做任何操作
set1.discard(2)

set1 = {1, 2, 3, 4}
set2 = {3, 4, 5, 6}
new_set = set1 & set2
print(new_set) 

set1 = {1, 2, 3, 4}
set2 = {3, 4, 5, 6}
new_set = set1 | set2
print(new_set)
# {1, 2, 3, 4, 5, 6}
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

以上就是Python内置类型常用方法的总结，欢迎各位前辈批评补充。