1.切片
格式 ：对象[star : end : step] 左闭右开，省略star代表从0开始，end 代表包括最后 ，步长省略代表1
切片是对序列截取一部分的操作（自符串、列表、元组都支持切片操作）
- 练习：
l1 = [i for i in range(10)]
print(l1)
print(l1[2])
print(l1[2:7])#[2, 3, 4, 5, 6]
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)使用切片来原地修改列表的内容
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]
2)使用del 和切片结合删除列表的元素
a = [3, 5, 7, 9, 11]
del a[:3]
print(a) #[9, 11]
del a[::2]
print(a) #[5, 9]
3)浅复制
是指生成了一个新的列表，并且把原列表中所有元素的引用都复制到这个新的列表中
注：
(1) 切片返回的是列表的元素的浅复制
(2) id() 查看元素的内存地址
(3) == 是判断两个列表中的元素是否完全一样
(4) is 判断两个列表是否是同一个对象
alist = [3, 5, 7]
blist = alist #blist与alist指向同一内存
# print(id(alist))#1918416
# print(id(blist))#1918416
blist[1] = 3
print(alist)#修改其中的一个对象会影响另外一个对象
print(id(alist))#1918416
print(id(blist))#1918416
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) == id(blist)) #False
2.元组 tuple
元组属于不可变的序列 一旦创建，用任何方法都不能将其修改 ()表示
注：
- 元组和列表的区别：
1)元组中数据一旦定义就不允许修改了
2)元组中没有append()、insert()、等方法。 不能向元组中添加元素
3)从效果上看，tuple函数是冻结列表，list函数是融化列表 - 元组优点
1)元组的速度要比列表快
2)元组对数据进行‘写保护’，让代码更加安全
3)元组可以用字典得键，还可以作为函数的返回值返回（返回多个键）
a = (1, 2, 3)
print(type(a)) #tuple
#一个元素的元组
x = (3,) #tuple
print(type(x))
2.1使用tuple函数将其他的序列转化为元组
- 2.1.1将列表转化成元组
from random import randint
a = [randint(-10, 10)for _ in range(10)]
print(a) #[-10, 2, -8, 10, 8, 4, -10, -10, -5, 8]
print(tuple(a)) #(-10, 2, -8, 10, 8, 4, -10, -10, -5, 8)
- 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 string
import string
print(string.ascii_lowercase[:7])#abcdefg
t = tuple(string.ascii_lowercase[:7])#('a', 'b', 'c', 'd', 'e', 'f', 'g')
print(t)
3.字符串
3.1 字符串的切片
import string
letters = string.ascii_uppercase[:9]
print(letters) #ABCDEFGHI
print(letters[3]) #D
print(letters[2:4]) #CD
print(letters[:]) #默认返回整个字符串，不过这是个浅复制
print(letters[-2:])
3.2字符串常用方法
- 3.2.1 upper()、lower() 常用指数 ***
s1 = 'www.NEUEDU.com'
print(s1.upper()) #全部大写
print(s1.lower()) #全部小写
- 3.2.2 startswith、endswith 常用指数***
s1 = 'www.NEUEDU.com'
print(s1.startswith('www')) #判断是否以prefix 开头
print(s1.startswith('www', 4, 6))#左闭右开
print(s1.endswith('.com'))
- 3.2.3 查找元素find() index()
获取指定元素首次出现的下标
s1 = 'www.NEUEDU.com'
print(s1.find('h'))
# print(s1.index('x')) #index 找不到这个子串会报错
print(s1.rfind('U')) #9 获取指定元素首次出现的下标，只不过从右边开始，索引是从左开始
# print(s1.rindex('x'))
- 3.2.4strip 默认取出字符前后两端的空格，换行，tab 常用指数******
s1 = ' \nwww.NEUEDU.com\t'
print(len(s1))#22
print(len(s1.strip()))#14
s2 = 'aabbccdddeeff'
s2 = s2.strip('aa')
print(s2) bbccdddeeff
s2 =s2.rstrip('ff') #指定为右端
print(s2)#bbccdddee
s2 = 'ffaabbccdddeeff'
s2 =s2.lstrip('ff') #指定为左端
print(s2)#aabbccdddeeff
- 3.2.5 split 把字符串分割成列表 默认是以空格进行分割 常用指数*****
s1 = 'life is short, use python'
print(s1.split()) #['life', 'is', 'short,', 'use', 'python']
print(s1.split(','))#['life is short', ' use python']
s2 = 'www.www\nNEUEDU.com'#按照行分割
s2 = s2.splitlines()
print(s2)
- 3.2.6 join 把列表转换成字符串 常用指数*****
s1 = 'life is short use python'
l1 = s1.split()
print(l1)#['life', 'is', 'short', 'use', 'python']
s2 = ''.join(l1)
print(l1)#['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.7 is系列 常用指数***
name = 'Neusoft123'
print(name.isalnum()) #所有的字符串是否是数字或者字母
print(name.isdigit()) #所有的字符串是否是数字
print(name.isalpha()) #所有的字符串是否是字母
print(name.islower()) #所有的字符串是否是小写
print(name.isupper()) #所有的字符串是否是大写
print(name.istitle()) #所有的字符串是否是首字母大写
print(name.isspace()) #所有的字符串是否是空白字符
- 3.2.8 count 计算某个字符串出现的次数 常用指数****
name = 'Neusoft1223333'
print(name.count('3'))#4
- 3.2.9 replace 替换指定字符 常用指数*****
name = 'Neusoft1223333'
name = name.replace('12233', ' ')
print(name)#Neusoft 33
name = '122Neusoft1223333'
name = name.replace('122', '', 1)#1代表替换几次
print(name)#Neusoft1223333
- 3.2.10 首字母大写
name = 'neusoft1223333'
print(name.capitalize()) #Neusoft1223333
- 3.2.11 center 将字符串居中 常用指数 *
参数可以设置字符串的总长度， 可以使用 * 进行填充
name = 'neusoft1223333'
print(name.center(50))# neusoft1223333
print(name.center(50, '*'))#******************neusoft1223333******************
print(len(name.center(50, '*'))) #50
- 3.2.12 just 将字符串对齐
s1 = 'neuedu'
print(len(s1))
print(s1.ljust(20))#左对齐
print(s1.rjust(20))#右对齐
print(len(s1.ljust(20)))#20
- 3.2.13 title
非字母隔开的每个单词的首字母大写
s = 'chen wuang4fhsa￥fh。f'
print(s.title()) #Chen Wuang4Fhsa￥Fh。F
- 3.2.14 partition 将字符串分成三部分
s1 = 'www.wwwNEUEDU.com'
print(s1.partition('NEU')) #返回的是元组
#('www.www', 'NEU', 'EDU.com')
3.字典
包含若干键值对的无序可变的序列，字典中的键可以为任意的不可变的数据 比如： number、string、tuple
- 创建字典
d = {'server': 'db.neuedu.com', 'database':' oracle'}
print(type(d)) #dict
print(d)
#空字典
d1 = {}
print(type(d1))
3.1使用dict函数将已有数据转化成字典
(1) 两个列表
keys = [x for x in string.ascii_lowercase[:5]]
print(keys)
values = [i for i in range(1, 6)]#['a', 'b', 'c', 'd', 'e']
print(values)#[1, 2, 3, 4, 5]
print(dict(zip(keys,values)))#{'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5}
(2) 使用dict() 根据给定的键值创建
d3 = dict(name='qq', age=18)
print('d3', d3)#d3 {'name': 'qq', 'age': 18}
(3)根据给定的内容为键 创建值为空的字典
print(dict.fromkeys(['name', 'age', 'gender']))#{'name': None, 'age': None, 'gender': None}
3.2字典的读取
格式：字典名['键']
d3 = dict(name='qq', age=18)
print(d3['name'])#qq
#print(d3['adder'])#KeyError: 'adder' 以键作为下标读取字典元素，不存在这个键就会抛出异常
#解决办法： 使用字典的get方法获取指定键对应的值，并且可以为不存在的键指定默认返回值
print(d3.get('name'))
print(d3.get('adder'))#None
print(d3.get('adder','北京')) #北京
- 3.2.1获取字典所有键 返回包含这个字典所有键的列表
print(list(d3.keys())) #['name', 'age']
#获取字典所有的值 返回包含这个字典所有值的列表
print(list(d3.values())) #['qq', 18]
- 3.2.2获取字典所有的键、值
l3 = list(d3.items()) #[('name', 'qq'), ('age', 18)]
print(l3) #[('name', 'qq'), ('age', 18)]
d4 = dict(l3)
print(d4) #{'name': 'qq', 'age': 18}
3.3 字典的修改
格式：字典名['键'] = '新的值'
print('d3', d3) # d3 {'name': 'wunan', 'age': 18, 'gender': 'female'}
d3['gender'] = 'male'
print(d3) # {'name': 'wunan', 'age': 18, 'gender': 'male'}
3.4 字典的添加
格式：字典名['字典中不存在的键']='新的值'
注：
当字典中存在这个键进行赋值时是修改操作
当字典中不存在这个键进行赋值时是添加操作
d3['addr'] = '沈阳市浑南区新秀街'
print(d3) # {'name': 'wunan', 'age': 18, 'gender': 'male', 'addr': '沈阳市浑南区新秀街'}
3.5 字典的删除
- 3.5.1 del 可以删除整个字典，或者其中的某个指定元素
print(d3) # {'name': 'wunan', 'age': 18, 'gender': 'male', 'addr': '沈阳市浑南区新秀街'}
del d3 # 字典完全被删除
#根据键删除整个元素
del d3['addr']
print(d3) # {'name': 'wunan', 'age': 18, 'gender': 'male'}
- 3.5.2 清除字典的所有数据
d3.clear()
print(d3) # {}
- 3.5.3 pop 删除指定键所对应的值，返回这个值并且从字典中把他移除
ret = d3.pop('addr')
print(ret) # 沈阳市浑南区新秀街
print(d3) # {'name': 'wunan', 'age': 18, 'gender': 'male'}
- 3.5.4 popitem()
按照后进先出的顺序返回并删除字典的最后的键值对
a = d3.popitem()
print(a) # ('addr', '沈阳市浑南区新秀街')
print(d3) #{'name': 'wunan', 'age': 18, 'gender': 'male'}
- 3.5.5 判断一个key 是否在字典中
print('name' in d3.keys()) # True
print('name' in d3) # True
3.6 字典的遍历
- 3.6.1 遍历所有的键
for k in d3.keys():
print(k)
for v in d3.values():
print(v)
- 3.6.2 遍历所有的项
for kv in d3.items():
print(kv)
for k, v in d3.items():
print(k, v)
- 3.6.3 有序字典(默认无序)
可以用collection模块实现有序
from collections import OrderedDict
#创建一个无序字典
# x = {}
# x['b'] = 3
# x['a'] = 1
# x['c'] = 5
# print(x)
x = OrderedDict()
x['b'] = 3
x['a'] = 1
x['c'] = 5
print(dict(x))
3.7 字典推导式（字典解析)
格式：{k:v for 临时变量 in 可迭代对象 if 条件}
from random import randint
{'student1':90,'student2':90,'student3':90 } #20名学生
grade = {'student{}'.format(x): randint(0, 101) for x in range(1, 21)}
print(grade)
- 3.7.1 使用字典解析删选 成绩大于60分的学生
jige={}
for k, v in grade.items():
if v > 60:
jige[k] = v
print(jige)
jige = {k: v for k, v in grade.items() if v > 60}
- 3.7.2 用字典推导式 以字符串以及其索引位置建字典
strings = ['import','is','with','if','file','exception','liuhu']
print([(index,v) for index,v in enumerate(strings)])
print({val:index for index,val in enumerate(strings)})
print({strings[i]:i for i in range(len(strings))})
print({v: len(v) for v in strings})
- 3.7.3 同一个字母但不同大小写的值合并起来
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()})
4.集合
注：无序不重复的，只能包含不可变数据(数字、字符串、元组)
- 4.1 集合的添加
#创建
a = {3, 6, 9}
print(a)
#集合的添加
a.add('8')
print(a)
- 4.2 将其他数据类型转化为集合
a = set(range(10))
print(a)
c = set([i for i in range(25)])
print(c)
- 4.3 updata
相同的合并
d = {1,2,4}
d.update({5,7,4})
print(d)
- 4.4 删除
- 4.4.1 pop()
弹出并删除其中的一个元素
v = d.pop()
print(v)
print(d)
- 4.4.2 删除指定元素的值
d.remove(4)
print(d)#{2}
- 4.5 清空集合
d.clear()
print(d)#set()
- 4.6 使用集合快速提取序列中单一元素
from random import choice
# 随机选取序列中的一个元素
print(choice(['a', 'b', 'c']))
print(choice('ddddasasdasxasaafd'))
random_list = [choice(range(100)) for _ in range(200)]
print(random_list)
print(len(random_list))
- 4.7 生成一个norepeat 的集合
noRepeat = []
for x in random_list:
if x not in noRepeat:
noRepeat.append(x)
print(len(noRepeat))
noRepeat = set(noRepeat)
print(noRepeat)
- 4.8 集合解析
将列表转化为集合，并且做每个元素两端去空格处理
s = [' d d dddd',' is ', ' python ']
print({x.strip() for x in s})
