一、切片

• 对序列截取一部分的操作
• 字符串、列表、元组都支持切片操作

l1 = [i for i in range(10)]
print(l1)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
print(l1[2])
2

格式：对象[start : end : step] 左闭右开 省略start代表从零开始，end代表包括最后，步长省略代表1

print(l1[2:]) # [2, 3, 4, 5, 6, 7, 8, 9]
print(l1[0:4:2]) #[0, 2]
print(l1[0:-2]) #[0, 1, 2, 3, 4, 5, 6, 7]
print(l1[-4:-2]) #[6, 7]
print(l1[-4:2]) #[]
print(l1[-1:-3:-1]) # [9, 8]
print(l1[-1:1:-1])# [9, 8, 7, 6, 5, 4, 3, 2]
print(l1[3:1:-1]) #[3, 2]
print(l1[3:-3:-1]) #[]
print(l1[::]) # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
print(l1[:]) #[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
print(l1[::2]) # [0, 2, 4, 6, 8]
#反转这个列表
print(l1[::-1])
[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

1.1、使用切片来原地修改列表内容

a = [3,5,7]
a[len(a):] = [9]
print(a)#[3, 5, 7, 9]
a[:3] = [1,2,3]
print(a)#[1, 2, 3, 9]
a[:3] = []
print(a)#[9]

1.2使用del 和切片结合删除列表的元素

a = [3, 5, 7, 9,11]
# del a[:3]
# print(a)
del a[::2]
print(a) # [5, 9]

1.3浅复制

是指生成了一个新的列表,并且把原列表中所有元素的引用都复制到这个新的列表中

aList = [3, 5, 7]
bList = aList # bList与aList指向同一个内存
bList[1] = 8
print(aList) # 修改其中的一个对象会影响另外的一个对象
print(id(aList))#4146640
print(id(bList))#4146640

print(aList == bList) # == 是判断两个列表中的元素是否完全一样
print(aList is bList) # 判断两个列表是否是同一个对象


aList = [3, 5, 7]
bList = aList[::] #切片 浅复制
print(aList == bList)  # True
print(aList is bList) # False
print(id(aList))#2508240
print(id(bList))#2509400
bList[1] = 8
print(bList)#[3, 8, 7]
print(aList)#[3, 5, 7]
#自己加的辅助理解代码
aList = [3,5,7]
bList = aList  #bList与aList指向同一个内存
bList[:2] = [8,9]
print(aList)#[8, 9, 7]
print(aList == bList) #True
print(aList is bList)#True

结论 :

• 切片返回的是列表的元素的浅复制
• id() 查看元素的内存地址
• == 是判断两个对象中的元素是否完全一样
• is 判断两个列表是否是同一个对象

二、元组（tuple）

元组属于不可变的序列，一旦创建，用任何方法都不能将其修改 （）表示

a = (1, 2, 3)
print(type(a)) #tuple

• 一个元素的元组

x=(3)
print(type(x))#<class 'int'>
x = (3,)
print(type(x))#<class 'tuple'>

x = (3)*4
print(x)#12
print(type(x))#<class 'int'>
x = (3, )*4
print(x)#(3, 3, 3, 3)
print(type(x))#<class 'tuple'>

2.1、使用tuple函数将其他的序列转换成元组

2.1.1、列表转换成元组

from random import randint
a = [randint(-10,10) for _ in range(10)]
print(a)#[-4, 8, -5, -7, 8, 8, -4, -7, 1, -7]
a_tuple = tuple(a)
print(a_tuple)#(-4, 8, -5, -7, 8, 8, -4, -7, 1, -7)

2.1.2、range函数

print(list(range(6)))#[0, 1, 2, 3, 4, 5]
print(tuple(range(6)))#(0, 1, 2, 3, 4, 5)

2.1.3、字符串

import string
print(string.ascii_lowercase[:7])#abcdefg
t = tuple(string.ascii_lowercase[:7])
print(t)#('a', 'b', 'c', 'd', 'e', 'f', 'g')

2.2元组和列表的区别

1、元组中数据一旦定义就不允许修改了
2、元组中没有 append()、extend()、insert()等方法，不能向元组中添加元素。
3、元组中也没有删除相关方法，不能从元组中删除元素
4、从效果上看，tuple函数是冻结列表，list函数是融化列表

2.3元组优点

1、元组的速度要比列表快
2、让代码更加安全
3、元组可以用做字典的键,还可以作为函数的返回值返回（返回多个值）

三、字符串

3.1、字符串的切片

import string
letters = string.ascii_uppercase[:9]
print(letters)#ABCDEFGHI
print(letters[3])#D
print(letters[2:4])#CD
print(letters[:]) #默认值返回整个字符串，不过这是个浅复制
#ABCDEFGHI
print(letters[-2:])#HI
print('letters[-2:2]',letters[-2,2])#letters[-2:2] 
print(letters[::-1])#IHGFEDCBA

3.2、字符串常用操作方法

3.2.1、

strip 默认取出字符前后两端的空格，换行，tab 常用指数*****

# rstrip lstrip
s1 = '   \ncom \t   '
print(len(s1))#12
print(len(s1.strip()))#3
s2 = 'aabbccddff'
s2 = s2.strip('aa')
print(s2)#bbccddff
s2 = s2.rstrip('ff') # 指定为右端
print(s2)#aabbccdd
s2 = s2.lstrip('ff') # 指定为左端
print(s2)#aabbccddff
# 指定之后，指定端若没有则也不取出其他位置的相同字符。
s3 = 'ffaabbccdd'
s3 = s2.lstrip('ff')
print(s3)#aabbccdd
s3= 'aaffbbccdd'
s3 = s2.lstrip('ff')
print(s3)#aaffbbccdd

3.2.2、

• split 把字符串分隔成列表 默认是以空格进行分隔 常用指数*****

s1 = 'life ;is ;short,; use; Python'
print(s1.split()) # 默认是以空格进行分隔#['life', ';is', ';short,;', 'use;', 'Python']
print(s1.split(','))#['life ;is ;short', '; use; Python']
print(s1.split(';', 1)) # 指定分隔多少个#['life ', 'is ;short,; use; Python']
print(s1.split(';', 3)[3])# use; Python
s2 = 'wwNEUw.\nwwwNEUEDU.com' # 按照行分隔，返回包含按照各行分隔为元素的列表
s2.rsplit()
s2.lstrip()
s2 = s2.splitlines()
print(s2)#['wwNEUw.', 'wwwNEUEDU.com']

3.2.3、

• join 把列表转换成字符串 常用指数*****

s1 = 'life is short use Python'
l1 = s1.split()
print(l1) #l1里面元素必须全是字符串#['life', 'is', 'short', 'use', 'Python']
s2 = ''.join(l1)
print(s2)#lifeisshortusePython
s2 = ' '.join(l1)
print(s2)#life is short use Python
s2 = '_'.join(l1)
print(s2)#life_is_short_use_Python
s2 = '/'.join(l1)
print(s2)#life/is/short/use/Python
s2 = '\\'.join(l1)
print(s2)life\is\short\use\Python

3.2.4、

• replace 常用指数***** 替换指定的字符

name = '1233Neusoft1233'
name = name.replace('1233','')
print(name)#Neusoft
name = name.replace('1233','',1)
print(name)#Neusoft1233

name = '1233Neu1233soft1233'
name = name.replace('1233',' ',-1)
print(name)# Neu soft   -1代表全部替换
 name = name.replace('1233',' ',1)
print(name)# Neu1233soft1233替换第一个
name = name.replace('1233',' ',2)
print(name)# Neu soft1233替换前两个

3.2.5、

• count 计算某个字符出现的次数 常用指数****

name = 'Neusoft1233'
print(name.count('3'))#2

3.2.6、

3、查找元素 find() index() 、 rfind、 rindex 常用指数****

# 获取指定元素首次出现的下标
s1 = 'www.wwwNEUEDU.com'
print(s1.find('N'))#7
print(s1.index('N'))#7
print(s1.find('F'))#-1 代表没有
print(s1.index('F')) # index 找不到这个子串会报错
print(s1.rfind('w')) #6 获取指定元素首次出现的下标,只不过是从右面开始 
print(s1.rindex('w'))#6

3.2.7、

upper()、.lower() 常用指数***

s1 = 'www.NEUEDU.com'
print(s1.upper()) # 全部大写WWW.NEUEDU.COM
print(s1.lower()) # 全部小写www.neuedu.com

3.2.8、

startswith endswith 常用指数***

s1 = 'www.wwwNEUEDU.com'
print(s1.startswith('www')) # 判断是否以prefix开头 True
print(s1.startswith('www',4, 6)) # 左闭右开  False
print(s1.endswith('.com'))#True

3.2.9、

is系列 常用指数***

name = 'Neusoft123'
print(name.isalnum()) # 所有的字符串是否是数字或者字母True
print(name.isdigit()) # 所有的字符串是否是数字False
print(name.isalpha()) # 所有的字符串是否是字母False
print(name.islower()) # 所有的字符串是否是小写False
print(name.isupper()) # 所有的字符串是否是大写False
print(name.istitle()) # 所有的字符串是否是首字母大写True
print(name.isspace()) # 所有的字符串是否是空白字符False

3.2.10、

首字母大写 常用指数**

name = 'neusoft1233'
print(name.capitalize())

3.2.11、

• center 将字符串居中 常用指数*
• 参数可以设置字符串的总长度，可以使用*进行填充

name = 'neusoft'
print(name.center(20))#      neusoft       
print(name.center(20,'*'))#******neusoft*******
print(len(name.center(20,'*')))#20
# ljust
s1 = 'neuedu'
print(len(s1)) # 6
print(s1.ljust(20))#neuedu              
print(s1.rjust(20))#              neuedu
print(len(s1.ljust(20))) #20
print(s1.ljust(20,'*'))#neuedu**************

3.2.12、

title ：非字母隔开的每个单词的首字母大写 常用指数*

s = 'chen wuang4fhsa￥fh。f'
print(s.title())#Chen Wuang4Fhsa￥Fh。F

3.2.13、

partition 将字符串分成三部分

s1 = 'wwNEUw.wwwNEUEDU.com'
print(s1.partition('NEU')) #返回的是元组('ww', 'NEU', 'w.wwwNEUEDU.com')
print(s1.rpartition('NEU')) #返回的是元组('wwNEUw.www', 'NEU', 'EDU.com')

四、字典

包含若干键值对的无序可变的序列， 字典中的键可以为任意的不可变的数据 比如number、string、tuple

4.1创建字典

import string
d = {'server': 'db.neuedu.com', 'database': 'oracle'}
print(type(d))#<class 'dict'>
print(d)#{'server': 'db.neuedu.com', 'database': 'oracle'}
# 空字典
d1 = {}
d2 = dict()
print('d2',d2)#d2 {}
print(type(d1))#<class 'dict'>

4.2使用dict函数将已有数据转化成字典

4.2.1、两个列表

keys = [x for x in string.ascii_lowercase[:5]]
print(keys)#['a', 'b', 'c', 'd', 'e']
values = [i for i in range(1, 6)]
print(values)#[1, 2, 3, 4, 5]
print(dict(zip(keys, values)))#{'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5}

4.2.2 使用dict() 根据给定的键值创建

d3 = dict(name='yangjiulin', age=26, gender= 'female')
print('d3', d3)#d3 {'name': 'yangjiulin', 'age': 26, 'gender': 'female'}

4.2.3、根据给定的内容为键、创建值为空的字典

print(dict.fromkeys(['name', 'age', 'gender']))#{'name': None, 'age': None, 'gender': None}

4.3 字典的读取

# 字典名['键']
print(d3['name'])#yangjiulin
# print(d3['addr']) #以键作为下标读取字典元素，不存在这个键就会抛出异常
# 解决办法： 使用字典的get方法获取指定键对应的值，并且可以为不存在的键指定默认返回值
print('**'*50)
print(d3.get('name'))yangjiulin
print(d3.get('addr')) # None
print(d3.get('addr','辽宁沈阳')) # 辽宁沈阳

print('**'*50)
# 获取字典所有键 返回包含这个字典所有键的列表
print(list(d3.keys()))#['name', 'age', 'gender']
# 获取字典所有的值 返回包含这个字典所有值的列表
print(list(d3.values()))#['yangjiulin', 26, 'female']
# 获取字典所有的键、值
l3 = list(d3.items())
print(l3)#[('name', 'yangjiulin'), ('age', 26), ('gender', 'female')]
d4 = dict(l3)
print(d4)#{'name': 'yangjiulin', 'age': 26, 'gender': 'female'}

4.4字典的修改

print('**********************字典的修改**************************************************')
print('d3', d3)#d3 {'name': 'yangjiulin', 'age': 26, 'gender': 'female'}
# 字典名['键'] = '新的值'
d3['gender'] = 'male'
print(d3)#{'name': 'yangjiulin', 'age': 26, 'gender': 'male'}

print('**********************字典的添加**************************************************')
# 字典名['字典中不存的键'] = '新的值'
# 当字典中存在这个键进行赋值时是修改操作，
#        不存在这个键进行赋值时是添加操作
d3['addr'] = '沈阳市浑南区新秀街'
print(d3)#{'name': 'yangjiulin', 'age': 26, 'gender': 'male', 'addr': '沈阳市浑南区新秀街'}

4.4字典的删除

print('**********************字典的删除**************************************************')

4.4.1、del 可以删除整个字典，或者其中的指定元素

print(d3)
del d3 # 字典完全被删除
# print(d3) #报错： name 'd3' is not defined

# 根据键删除整个元素
del d3['addr']
print(d3)#{'name': 'yangjiulin', 'age': 26, 'gender': 'male'}

4.4.2、clear()清除字典的所有数据

d3.clear()
print(d3)#{}

4.4.3、pop

删除指定键所对应的值，返回整个值并且从字典中把他移除

ret = d3.pop('name')
print(ret)#yangjiulin
print(d3)#{'age': 26, 'gender': 'male', 'addr': '沈阳市浑南区新秀街'}
# 按照后进先出的顺序返回并删除字典的最后的键值对
d3.popitem()
print(d3)#{'name': 'yangjiulin', 'age': 26, 'gender': 'male'}
d3.popitem()
print(d3)#{'name': 'yangjiulin', 'age': 26}
d3.popitem()
print(d3)#{'name': 'yangjiulin'}
d3.popitem()
print(d3)#{}

4.4.4判断一个key 是否在字典中

print('name' in d3.keys())#True
print('name' in d3)#True

4.4.5字典的遍历

print('**********************字典的遍历**************************************************')
# 遍历所有的键
for key in d3.keys():
    print(key)
#
name
age
gender
addr
#
# 遍历所有的值
for v in d3.values():
    print(v)
#
yangjiulin
26
male
沈阳市浑南区新秀街
#
# 遍历所有的项
for kv in d3.items():
    print(kv) # 元组
#
('name', 'yangjiulin')
('age', 26)
('gender', 'male')
('addr', '沈阳市浑南区新秀街')
#
# 遍历字典所有键值
for k, v in d3.items():
    print(k,'----->',v)
#
name -----> yangjiulin
age -----> 26
gender -----> male
addr -----> 沈阳市浑南区新秀街
#

4.5有序字典

可以使用collection模块的

from collections import OrderedDict
#  创建一个无序字典
x = {}
x['b'] = 3
x['a'] = 1
x['c'] = 5
print(x)#{'b': 3, 'a': 1, 'c': 5}
x = OrderedDict()
x['b'] = 3
x['a'] = 1
x['c'] = 5
print(dict(x))#{'b': 3, 'a': 1, 'c': 5}

4.6字典推导式 （字典解析）

[i for i in range(10)]
# {k: v for 临时变量 in 迭代对象 if 条件}
from random import randint
#{'student1':90,'student2':90,'student3':90,}  20 名学生
l1 = [randint(0, 101) for _ in range(1, 21)]
grade = {'student{}'.format(x): randint(0, 100) for x in range(1, 11)}
print(l1)#[91, 57, 52, 82, 42, 6, 55, 30, 63, 9, 7, 34, 60, 83, 21, 79, 42, 5, 88, 62]
print(grade)#{'student1': 66, 'student2': 17, 'student3': 1, 'student4': 93, 'student5': 23, 'student6': 77, 'student7': 48, 'student8': 31, 'student9': 88, 'student10': 4}

• 使用字典解析筛选 大于60分成绩的学生

jiege = {}
for k,v in grade.items():
    if v > 60:
        jiege[k] = v
print(jiege)#{'student2': 91, 'student3': 62, 'student6': 92, 'student8': 72}

jiege = {k:v for k, v in grade.items() if v>60}
print(jiege)#{'student2': 91, 'student3': 62, 'student6': 92, 'student8': 72}

• 用字典推导式以字符串以及其索引位置建字典

strings = ['import','is','with','if','file','exception','liuhu']
#  用字典推导式以字符串以及其索引位置建字典
# 1、枚举
print({val: index for index, val in enumerate(strings)})#{'import': 0, 'is': 1, 'with': 2, 'if': 3, 'file': 4, 'exception': 5, 'liuhu': 6}
# 2、
print({strings[i]: i for i in range(len(strings))})#{'import': 0, 'is': 1, 'with': 2, 'if': 3, 'file': 4, 'exception': 5, 'liuhu': 6}
# 3、
print({v: len(v) for v in strings})#{'import': 6, 'is': 2, 'with': 4, 'if': 2, 'file': 4, 'exception': 9, 'liuhu': 5}

• 同一个字母但不同大小写的值合并起来了

mc = {'a': 10, 'b': 34, 'A': 7, 'Z': 3}

# 都合并到小写
print({k.lower(): mc.get(k.lower(), 0)+mc.get(k.upper(),0) for k in mc.keys()})#{'a': 17, 'b': 34, 'z': 3}

五、集合

• 无序不重复
• 只能包含不可变数据(数字、字符串、元组)

5.1创建

a = {}
print(type(a))#<class 'dict'>
b = {3,6,7,9}
print(type(b))#<class 'set'>
print(b)#{9, 3, 6, 7}

5.2添加

b.add('8')
print(b)#{3, '8', 6, 7, 9}
# 将其他数据类型转化为集合
a = print(set(range(10)))
print(a)#{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
c= set([i for i in range(25)])
print(c)#{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24}
del c
print(c) #name'c' is not defined

#update方法
d= {8,2,4}
d.update({5,7,4})
print(d)#{2, 4, 5, 7, 8}

5.3删除

# pop() 弹出并删除其中的一个元素
v = d.pop()
print(v)#2
print(d)#{4, 5, 7, 8}

#删除指定元素的值
d.remove(5)
print(d)#{4, 7, 8}

# 清空集合
d.clear()
print(d)#set()

5.4使用集合快速提取序列中单一元素

from random import choice
#随机选取序列中的一个元素
print(choice(['a', 'b', 'c']))#b
print(choice('asdhjkas'))#k
random_list = [choice(range(25)) for _ in range(50)]
print(random_list)
print(len(random_list))#50
#生成一个norepeat的集合
noRepeat = []
#筛选出单一元素
for x in random_list:
    if x not in noRepeat:
        noRepeat.append(x)
print(len(noRepeat))#19
noRepeat = set(noRepeat)
print(noRepeat){0, 1, 3, 4, 5, 6, 7, 8, 9, 12, 14, 16, 17, 18, 19, 20, 21, 23, 24}

5.5集合解析

# 将列表转化为集合，并且做每个元素两端去空格处理
s = ['  ddd','  is  ','  python  ']
print({x.strip() for x in s})#{'python', 'ddd', 'is'}