Python列表、字符串、字典、集合、切片、元组、推导式以及深浅

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})