Day23-Leonwenbin

索引分正负索引，正索引从零开始，从0往右；负索引-1开始，从右往左

string = 'morning'

print(string[3])

输出：n

print(string[-1])

输出：g

切片 使用索引值来限定范围 从一个大的字符串中切出小的字符串

1.切片是建立在索引之上

2.切片的表达式[start_index : end_index: step] 开始索引 结束索引 步长值

3.能取到开始索引，但是取不到结束索引

4.步长值有正负之分，默认为正数; 正步长从左往右取，负则相反

5.步长值默认为1

6.开始或者结束的索引没有值，则取两头对应的值，到底取哪一头，看步长的正负

7.步长值n>1的时候，每隔n个取一个

string = 'good_morning'

print(string[::])    >> good_morning

print(string[1:4:1]) >> ood

print(string[1::])   >> ood_morning

print(string[:5:])   >> good_

print(string[5:6:])  >> m

print(string[::-1])  >> gninrom_doog

print(string[2::-1]) >> oog

print(string[:2:-1]) >> gninrom_d

print(string[7:3:-1])>> rom_

注意：当step为正时，start_index必须大于end_index；当step为负时，start_index必须小于end_index，否则无意义

字符串是Python中最常用的数据类型。我们可以使用单引号''或者双引号""来创建字

符串。

str1 = 'good_morning'

str2 = "good_morning"

字符串常用函数：

1、capitalize()：首字符大写

print(str.capitalize()) >> Good_morning

print(str.title()) >> Good_Morning

2、count()：统计具体字符出现的次数

print(string.count('g')) >> 2

3、join()：把集合中的字符按自定义的分隔符连接在一起

print('*'.join(string)) >> g*o*o*d*_*m*o*r*n*i*n*g

4、split()：把字符串通过指定标识符进行分割

5、strip(ab)：删除字符串开头和结尾有a或b的字符

print(string.split('o')) >> ['g', '', 'd_m', 'rning']

6、lstrip(ab)：删除字符串开头有ab序列字符

print(string.lstrip('g')) >> ood_morning

7、rstrip(ab)：删除字符串结尾有ab序列字符

print(string.rstrip('g')) >> good_mornin

8、startswith(ab)：判断字符串是否以ab开始

print(string.startswith('goo')) >> True

print(string.startswith('M')) >> False

9、endswith(ab)：判断字符串是否以ab结束

print(string.endswith('g')) >> True

print(string.endswith('f')) >> False

10、find()/rfind()：字符串查询find()是左边开始查，rfind()从右边开始查，结果显示下标

print(string.find('mor')) >> 5

print(string.find('fl')) >> -1

print(string.find('g')) >> 0

print(string.rfind('g')) >> 11

print(string.find('_m')) >> 4

print(string.rfind('_m')) >> 4

11、replace()：replace(substring,newstring,count) substring表示被替换的字

符串,newstring要替换字符串,count表示替换的次数

print(string.replace('o', '$')) >> g$$d_m$rning # 全部替换

print(string.replace('g', '#', 1)) >> #ood_morning

print(string.replace('o', '%', 3)) >> g%%d_m%rning

count可以大于substring出现的次数

12、lower()：方法转换字符串中所有大写字符为小写

string = 'Good_Morning'

print(string.lower()) >> good_morning

13、upper()：将字符串中的所有小写字符转换为大写字母输出

string = 'Good_Morning'

print(string.upper()) >> GOOD_MORNING

14、isdigit()：判断字符串中是否全为数字

string = '7895asf7'

print(string.isdigit()) >> False

string = '7897'

print(string.isdigit()) >> True

15、isalpha()：判断字符串中是否全为字母

string = 's5cas_'

print(string.isalpha()) >> False

string = 'asdf'

print(string.isalpha()) >> True

16、isalnum()：判断字符串当中是否全都为数字，全为字母，或者数字字母组合返回布尔值：True和False 如果有特殊符号就是否

string='1234aa@#$'

print (str.isalnum()) >> False

string = '12345'

print (str.isalnum()) >> True

string = 'asdg'

print (str.isalnum()) >> True

string  = '1ed34tr'

print (str.isalnum()) >> True

17、istitle()：判断字符串中首字母是否为大写，其他是否为小写，其他不为小写则为否

string = 'GoodMorning'

print (string.istitle()) >> False

string = 'Goodmorning'

print (string.istitle()) >> True

18、isupper()/islower():is开头的就是判断一个字符串是否展示为都是大写或者都是小写

string = 'goodmorning'

print(string.islower()) >> True

string = 'GOOD'

print(string.isupper()) >> TRUE

(1)定义：列表（list）是一组有序存储的数据，也是python常见的序列之一，序列

中的每个元素都分配一个索引，第一个元素索引是0，第二个元素索引是1，依此

类推。序列都可以进行的操作包括索引，切片，加，乘，检查成员

列表表达符为：[]

(2)定义列表的两种方法：

方法一：list1 = [1,2,3,4]    #直接通过[]进行定义

方法二：list2 = list('1234') #使用list()方法进行定义

(3)列表中对应的函数

1、索引和切片赋值

list1 = [1, 2, 3, 'good', 'T', 4]

list1[2] = 666

print(list1) >> [1, 2, 666, 'good', 'T', 4]

list1[3:] = list('123')

print(list1) >> [1, 2, '1', '2', '3']

2、列表中文打印乱码解决方法

a = [1,2,3,"中国"]

print (str(a).decode('string_escape'))

decode()：指定编码格式

string-escape：编码格式，能解决因为被\转义的问题

3、append函数：添加一个元素

list1 = [1,2,3,4]

list1.append('duoceshi')

print (list1) >> [1, 2, 3, 4, 'duoceshi']

4、extend函数：连接两个列表

list1=[1,2,3,4,5]

list2 =[6,7,8]

list1.extend(list2)

print(list1) >> [1, 2, 3, 4, 5, 6, 7, 8]

注意：extend与append方法的相似之处在于都是将新接收到参数放置到已有列表的后面

append方法可以接收任意数据类型的参数，并且追加到list尾部

extend方法一般和列表还有字符串进行拼接。

5、insert(index,value)函数：在指定位置插入一条数据

list1 = [1,2,3,4]

list1.insert(0,'test')

print(list1) >> ['test', 1, 2, 3, 4]

6、remove函数：移除元素(一个一个的移除)

list1 = [1,2,3,4,1]

list1.remove(1)

print(list1) >> [2, 3, 4, 1]

list1.remove(1)

print(list1) >> [2, 3, 4]

7、索引删除值

list1 = [1,2,3,4]

del list1[0]

print(list1) >> [2,3,4]

8、index函数：在列表中查找元素所对应的索引值

list1 = [1,2,3,4]

print(list1.index(2)) >> 1

9、sort函数：实现列表的升序排列

list1 = [6,1,3,4,0]

list1.sort()

print(list1) >> [0, 1, 3, 4, 6]

10、sorted函数：实现降序排列

list1 = [1,2,3,4,1]

print (sorted(list1,reverse=True)) >> [6, 4, 3, 1, 0] # reverse=False是升序排序

11、reverse函数：列表元素反转

list1 = [6,1,3,4,0]

list1.reverse()

print(list1) >> [0, 4, 3, 1, 6]

12、pop函数：

list1 = [1,2,3,4]

print (list1.pop(0))

1.默认移除列表最后一个元素,并返回元素的值

2.移除指定位置的元素list1.pop(0)表示移除第一个元素

3.在列表中pop函数是唯一一个既能改变列表元素又有返回值

pop()移除的是index对应的value值，remove直接移除value值

定义：元组（tuple）是Python中常用的一种数据结构。元组由不同的元素组成，

每个元素可以存储不同类型的数据，如字符串、数字、甚至元组。元组是'写保护'

的，即元组中元素作为一个整体，创建后不能再做任何修改操作。

元组表达符为：()

元组的定义：tuple1=（1,2,3）

注意：当元组只有一个元素时,后面要加逗号，如：tuple1 = (1,)

元组中常见的操作

1、元组转换为列表

tuple1 = ('a','b','c','d')

list1=list(tuple1)

print(list1,type(list1)) >> ['a', 'b', 'c', 'd'] <class 'list'>

2、列表转换为元组

list1=[1,2,3,4]

tuple1=tuple(list1)

print (tuple1,type(tuple1)) >> (1, 2, 3, 4) <class 'tuple'>

3、元组中的值是不可以直接改变的

tuple1=('a','b','c')

tuple1.insert(0,'d')

print(tuple1) >> TypeError: 'tuple' object does not support item assignment

4、元组中的值是可以间接来改变

tuple1 = ('a', 'b', 'c', 'd')

list1 = list(tuple1)  # 先改成列表

list1[1] = 'test'  # 通过列表改值

tuple1 = tuple(list1)  # 在转换成元组

print(tuple1)

5、元组和列表的区别

相同：

a、都是序列类型的容器对象，可以存放任何类型的数据

b、支持切片、迭代等操作

不同：

a、list是可变的对象，元组tuple是不可变的对象

b、tuple不可变，所以使用tuple可以使代码更安全

定义：

1、字典（dict）是另一种可变容器模型，且可存储任意类型对象。字典的

每个键值key：value对用冒号 : 分割，每个键值对之间用逗号分割，整个字

典包括在大括号 {} 中

2、字典同时是无序，字典都是以键值对的形式存在，先键后值，键是唯一

的，值且不唯一

字典表达符：{}

字典的定义方式：

方式一：

dict1={'name':'duoceshi','age':18} # 通过{}直接定义

方式二：

dict1 = [('a',1),('b',2),('c',3)]

dict2 = dict(dict1) # 通过dict()方法定义

1、添加一个键值对

dict1 = {"name":"xiaowang","age":"10"}

dict1['sex']=1 # 如果字典里已经有这个键，旧数据将会替换

print(dict1) >> {'name': 'xiaowang', 'age': '10', 'sex': 1}

2、取出键返回列表

dict1 = {"name":"xiaowang","age":"10"}

print(dict1.keys()) >> dict_keys(['name', 'age'])

3、取出值返回列表

dict1 = {"name":"xiaowang","age":"10"}

print(dict1.values()) >> dict_values(['xiaowang', '10'])

4、取出具体键的值

dict1 = {"name":"xiaowang","age":"10"}

print(dict1['name']) >> xiaowang

5、字典添加元素setdefault（）

dict1 = {'name':'xiaowang','age':18}

dict1.setdefault('sex','1')

print(dict1) >> {'name': 'xiaowang', 'age': 18, 'sex': '1'}

# 注：如果插入数据键已经在字典里,插入是不生效的,默认值为空时,插入数据为None

6、删除字典

dict1 = {"name":"xiaowang","age":"18","sex":"1"}

del (dict1)

print(dict1) >> NameError: name 'dict1' is not defined

7、删除指定的键，连同值也删除

dict1 = {"name":"xiaowang","age":"18","sex":"1"}

del (dict1["name"])

print(dict1) >> {'age': '18', 'sex': '1'}

8、字典的遍历：for...in...遍历字典

dict1 = {'name': 'xiaowang', 'age': 18}

for key in dict1:

print(key,dict1[key])

9、使用items()完成遍历

dict1 = {'name': 'xiaowang', 'age': 18}

for key,value in dict1.items():

print(key,value)

10、pop(key)函数，删除指定键并返回删除的值

dict1 = {'name':'xiaowang','age':'18','sex':'1'}

print(dict1.pop("name")) >> xiaowang

print(dict1) >> {'age': '18', 'sex': '1'}

12、clear()清空字典所有项

dict = {'name':'xiaowang','age':18}

dict.clear()

print(dict) >> {}

13、get(key)方法,通过key获取值,当键不存在,返回None

dict = {'name':'xiaowang','age':18}

print(dict.get('name')) >> xiaowang

14、fromkeys函数可以给具体的键指定值

dict1 = {'name':'xiaowang','age':18}

print({}.fromkeys(['name','age'])) >> {'name': None, 'age': None} # 不指定默认值

print({}.fromkeys(['name','age'],'duoceshi')) >> {'name': 'duoceshi', 'age': 'duoceshi'}# 指定默认值为'duoceshi'

15、__contains__()函数检查字典是否有指定的键，有返回True，没有返回False

dict1 = {'name': 'xiaowang', 'age': 18}

print(dict1.__contains__('name')) >> True # 返回true,因为键存在

16、popitem函数随机返回并删除字典中的键值对(一般删除末尾对)

如果字典已经为空，却调用了此方法，就报出KeyError异常

dict1 = {'name':'xiaowang','age':18,'class':24}

print(dict1.popitem()) >> ('class', 24)

print(dict1) >> {'name': 'xiaowang', 'age': 18}

17、update函数利用一个字典更新另外一个字典

dict1 = {'name': 'xiaowang', 'age': 18}

dict2 = {"sex": 1}

dict1.update(dict2)

print(dict1) >> {'name': 'xiaowang', 'age': 18, 'sex': 1}

注意：如果要更新的元素项在原字典里存在,则把原来的项覆盖

集合：最重要的功能就是去重

1、可变集合set

list1 = [1, 2, 3, 10, 'duoceshi', 'dcs']

set1 = set(list1)

print(set1) >> {1, 2, 3, 10, 'dcs', 'duoceshi'}

set1.add('dcs')

print(set1) >> {1, 2, 3, 10, 'dcs', 'duoceshi'}

set1.remove('dcs')

print(set1) >> {1, 2, 3, 10, 'duoceshi'}

set1.pop()  # 把最前面这个给删除了,不能指定位置删除

print(set1) >> {2, 3, 'duoceshi', 10}

set1.clear()

print(set1) >> set()

2、不可变集合frozenset

string = 'hello'

a = frozenset(string)

b = a.copy()

b.add('666')

print(b) >> AttributeError: 'frozenset' object has no attribute 'add'