(本文仅作为学习记录使用) 感谢太白老师和王sir的谆谆教导.
01 昨日内容回顾
02 作业讲解
03 字典
04 字典的嵌套
05 集合（了解）
01 昨日内容回顾
注意顾头不顾腚的原则.
list的切片.
list[1]
list[-2]
list[1:3]
list[-2:1:-1]
list[-2::-2]
list[::]
list[::-1]
列表常用操作:
列表增有3种:
append:追加.一次只能追加1个.不能连续追加.
insert:插入,其中l1.insert(索引,字符串)
extend:迭代添加.假如是'abc',分别添加则为['a','b','c']
列表删有3种:(del单独列)
pop:按索引删除. l1.pop(索引)
remove:按元素删除. l1.remove(元素)
clear:清空list. l1.clear
del有3种用法:
按字符删除. del l1[1]
按切片删除. del l1[1:3]. 所有的这种按切片删或者添或者改的,只要步长发生变化,就一定要一一对应.
删除list. del l1 运算结果会报错(如果输出l1的话,因为l1被删除)
列表改只有1种:
直接改:
按索引:l1[1] ='a'
按切片:l1[1:3] = 'adad'
注意,当用切片时候,连在一起时候可以任意添加(会续下去),如果步长不是正负1的话,只能一一对应.
列表查:
索引查.
切片查.
for循环查看.
其他操作:
len:输出list长度.
sort:对list进行排序.
注意,有sort(reverse = True)为翻转排序.
reverse:对list进行翻转.
count:对元素进行计数.
index:寻求元素的索引.
列表的嵌套的话主要是通过赋值或者一个一个找下去直接赋值解决的.(def的话日后再说吧)
元组:tuple,不能改,里面的如list等的容量型数据可以改.
range的话主要是用在限制for循环的(个人理解).正好用在有限循环.
链接:https://www.cnblogs.com/smithpath/articles/10480185.html
02 作业讲解
# 1. 写代码，有如下列表，按照要求实现每⼀个功能li = ["alex", "WuSir", "ritian", "barry", "wenzhou"]
# li = ["alex", "WuSir", "ritian", "barry", "wenzhou"]
# a.计算列表的⻓度并输出
# print(len(li))
# b.列表中追加元素"seven", 并输出添加后的列表
# li.append('seven')
# print(li)
# c.请在列表的第1个位置插入元素"Tony", 并输出添加后的列表
# li.insert(0,'Tony')
# print(li)
# d.请修改列表第2个位置的元素为"Kelly", 并输出修改后的列表
# li[1]='Kelly'
# print(li)
# e.请将列表l2 = [1, "a", 3, 4, "heart"]的每⼀个元素添加到列表li中，⼀行代码实现，不允许循环添加。
# l2 = [1, "a", 3, 4, "heart"]
# li.extend(l2)
# print(li)
# f.请将字符串s = "qwert"的每⼀个元素添加到列表li中，⼀行代码实现，不允许循环添加。
# s = "qwert"
# li.extend(s)
# print(li)
# g.请删除列表中的元素"ritian", 并输出添加后的列表
# li.remove("ritian")
# print(li)
# h.请删除列表中的第2个元素，并输出删除的元素和删除元素后的列表
# print(li.pop(1))
# print(li)
# i.请删除列表中的第2至4个元素，并输出删除元素后的列表
# del li[1:4]
# print(li)
# j.请将列表所有得元素反转，并输出反转后的列表
# 法一
# l1 = li[::-1]
# print(l1)
# 法二
# li.reverse()
# print(li)
# k.请计算出"alex"元素在列表li中出现的次数，并输出该次数。
# print(li.count('alex'))
# 2.写代码，有如下列表，利用切片实现每⼀个功能
# li = [1, 3, 2, "a", 4, "b", 5, "c"]
# a.通过对li列表的切片形成新的列表l1, l1 = [1, 3, 2]
# l1 = li[:3]
# print(l1)
# b.通过对li列表的切片形成新的列表l2, l2 = ["a", 4, "b"]
# l2 =li[3:6]
# print(l2)
# c.通过对li列表的切片形成新的列表l3, l3 = ["1,2,4,5]
# l3 = li[::2]
# print(l3)
# d.通过对li列表的切片形成新的列表l4, l4 = [3, "a", "b"]
# l4 = li[1:6:2]
# print(l4)
# e.通过对li列表的切片形成新的列表l5, l5 = ["c"]
# 法一:
# l5 = [li[-1]]
# print(l5)
# 法二:
# print(li[-1:]) #加个冒号即可.
# f.通过对li列表的切片形成新的列表l6, l6 = ["b", "a", 3]
# l6 =li[5::-2]
# print(l6)
# 3.写代码，有如下列表，按照要求实现每⼀个功能。
# lis = [2, 3, "k", ["qwe", 20, ["k1", ["tt", 3, "1"]], 89], "ab", "adv"]
# a.将列表lis中的"tt"变成大写（用两种方式）。
# 法一:
# lis[3][2][1][0] = lis[3][2][1][0].upper()
# print(lis)
# 法二:
# a1 = lis[3]
# a2 = a1[2]
# a3 = a2[1]
# a3[0] = a3[0].upper()
# print(lis)
# b.将列表中的数字3变成字符串"100"（用两种方式）。
# 法一:
# lis[1] = '100'
# lis[3][2][1][1] ='100'
# print(lis)
# 法二:
# lis.remove(3)
# lis[2][2][1].remove(3)
# lis.insert(1,'100')
# lis[3][2][1].insert(1,'100')
# print(lis)
# 法三:(NB!!!)
# def list_for(lis):
# l1 = []
# for i in lis :
# if type(i) is not list :
# l1.append(str(i).lower())
# else :
# l1.extend(list_for(i))
# return l1
# for i in list_for(lis):
# print(i)
# c.将列表中的字符串"1"变成数字101（用两种方式）。
# 法一:
# lis[3][2][1][2] =101
# print(lis)
# 法二:
# lis[3][2][1].remove('1')
# lis[3][2][1].insert(2,101)
# print(lis)
# 4.请用代码实现：li = ["alex", "wusir", "taibai"]
# 利用下划线将列表的每⼀个元素拼接成字符串"alex_wusir_taibai"
# li = ["alex", "wusir", "taibai"]
# print('_'.join(li))
# 5.利用for循环和range打印出下面列表的索引。
# li = ["alex", "WuSir", "ritian", "barry", "wenzhou"]
# for i in range(0,len(li)) :
# print(i)
# 6.利用for循环和range找出100以内所有的偶数并将这些偶数插入到⼀个新列表中。
# 法一:
# l1 = []
# for i in range(0,101) :
# if i % 2==0 :
# l1.append(i)
# print(l1)
# 法二:
# l1 = []
# for i in range(0, 101):
# if i % 2 == 0:
# l1.extend([i])
# print(l1)
# 7.利用for循环和range 找出50以内能被3整除的数，并将这些数插入到⼀个新列表中。
# 法一:
# l1 = []
# for i in range(0, 50):
# if i % 3 == 0:
# l1.append(i)
# print(l1)
# 法二:
# l1 = []
# for i in range(0, 50):
# if i % 3 == 0:
# l1.extend([i])
# print(l1)
# 8.利用for循环和range从100~1，倒序打印。
# for i in range(100,0,-1) :
# print(i)
# 9.利用for循环和range从100~10，倒序将所有的偶数添加到⼀个新列表中，然后对列表的元素进⾏筛选，
# 将能被4整除的数留下来。
# #如果有如[1,2,2,2,3,4,4]这样的话会漏值,所以最好从后往前删.
# l1 = []
# for i in range(100, 9, -1):
# if i % 2 == 0:
# l1.append(i)
# for i in l1:
# if i % 4 != 0:
# l1.remove(i)
# print(l1)#其中append和remove可以用extend,pop,del等替代(可能吧...)
# 10.利用for循环和range，将1 - 30的数字⼀次添加到⼀个列表中，
# 并循环这个列表，将能被3整除的数改成 *。
# l1 = []
# for i in range(1,31):
# l1.append(i)
# if int(i) % 3 == 0:
# l1[i-1] = '*'
# print(l1)
# 11.查找列表li中的元素，移除每个元素的空格，并找出以"A"或者"a"开头，并以"c"结尾
# 的所有元素，并添加到⼀个新列表中, 最后循环打印这个新列表。
# 法一:
# li = ["TaiBai ", "alexC", "AbC ", "egon", " riTiAn", "WuSir", " aqc"]
# l1 = []
# for i in li :
# x = i.strip()
# if (x.startswith('a') or x.startswith('A')) and x.endswith('c') :
# l1.append(x)
# for i in l1 :
# print(i)
# 法二:
# li = ["TaiBai ", "alexC", "AbC ", "egon", " riTiAn", "WuSir", " aqc"]
# l1 = []
# for i in li:
# x = i.strip()
# if (x[0].lower() == 'a') and x.endswith('c'):
# l1.append(x)
# for i in l1:
# print(i)
# 12.开发敏感词语过滤程序，提示用户输入评论内容，如果用户输入的内容中包含特殊的字符：
# 敏感词列表li = ["苍老师", "东京热", "武藤兰", "波多野结衣"]
# 则将用户输入的内容中的敏感词汇替换成等⻓度的 *（苍老师就替换 ** *），并添加到⼀个列表中；
# 如果用户输入的内容没有敏感词汇，则直接添加到上述的列表中。
# li = ["苍老师", "东京热", "武藤兰", "波多野结衣"]
# msg = input('请输入内容:')
# l1 = []
# for i in li :
# # if i in msg : #该语句可以不写
# msg = (msg.replace(i,'*'*len(i)))
# l1.append(msg)
# print(l1)
# 13.有如下列表li = [1, 3, 4, "alex", [3, 7, 8, "TaiBai"], 5, "RiTiAn"]
# 循环打印列表中的每个元素，遇到列表则再循环打印出它里面的元素。
# 我想要的结果是：
# 1
# 3
# 4
# "alex"
# 3
# 7,
# 8
# "taibai"
# 5
# ritian
#法一:(麻烦了,只需要打印即可)
# li = [1, 3, 4, "alex", [3, 7, 8, "TaiBai"], 5, "RiTiAn"]
# l1 = []
# for i in li :
# if type(i) == list :
# for i1 in li[li.index(i)] :
# l1.append(i1)
# else :
# l1.append(i)
# for i in l1 :
# if str(i).isalpha() :
# l1[l1.index(i)] = l1[l1.index(i)].lower()
# for i in l1 :
# print(i)
#法二:
# li = [1, 3, 4, "alex", [3, 7, 8, "TaiBai"], 5, "RiTiAn"]
# for i in li :
# if type(i) == list :
# for i1 in i :
# print(str(i1).lower())
# else :
# print(str(i).lower())
03 字典
首先看字典的增删改查,
为什么要用字典?
1.list存储的数据多的话,相对来说查询较慢;
2.list存储的的数据相互之间没关联.
字典是Python基础数据类型之一. 是Python中唯一的映射类数据. 花括号{}括起来. 以键值对形式存储. 每一对键值对之间以冒号相连,不同键值对以逗号隔开.
PS:
数据类型的划分:
容器与非容器划分:
容器类型数据:list,tuple,dict,list.
非容器类型数据:int , str ,bool .
可变与不可变的划分:
可变(不可hash)的数据类型: list ,dic ,set.
不可变(可hash)的数据类型: str , bool ,int ,tuple .
字典是以键值对形式存储的，
键：不重复的,唯一的，键的数据类型必须是不可变的数据类型。
值：任意数据类型，对象。
字典可以存储大量的键值对数据，
python3.5包括3.5之前：字典是无序的。
python3.6之后，字典变成有序的。
字典的优点：
1，字典存储大量的关系型数据。
2，字典的查询速度非常快。
字典的增:
demo1:
# 增:2种方法
# 1.直接赋值修改
# 2.setdefault改
# 1.有则修改,无则添加
# dic['hight'] = 176
# dic['lover'] = 'zhaomin'
# print(dic)
# 2.有则不变,无则添加
# dic.setdefault('father')
# print(dic)
# dic.setdefault('father','zhang cuishan ')
# print(dic)
字典的删:
demo2:
# 删:3种方法 # 1.pop删键 # 2.clear清空字典 # 3.del删除 # pop:按照键删除 # ret = dic.pop('name') # print(ret) #按照键删除键值对 # print(dic) # ret1 = dic.pop('age1') # print(ret1) # print(dic)#报错 # ret1 = dic.pop('age1','无此键') # print(ret1) # print(dic) #后面定义了之后不报错 # clear:清空 # dic.clear() # print(dic) # popitem: 3.6版本之后就是删除最后一个键值对 # ret = dic.popitem() # print(ret) # print(dic) # del # del dic['name'] #按照键删除 # print(dic) # del dic['name1'] # print(dic) #报错 # del dic # print(dic) #删除字典
字典的改:
# 改:
# dic['age'] = 30
# print(dic)
# update
# dic.update(kongfu = 'jiuyang',xinjing = 'jijinjing')
# print(dic)
# dic2 ={'name':'yangguo','lover':'xiaolongnv','country':'Song'}
# dic.update(dic2)
# print(dic) #将dic里面的键值对覆盖到dic2中
字典的查:
demo3:
# 查
# 1.直接查
# print(dic['age'])
# print(dic['age1']) #报错,因为没age1
# 2.get
# print(dic.get('age'))
# print(dic.get('age1'))#找不到默认返回none
# print(dic.get('age1','666'))#可以自己设置返回值
字典的其他操作:
demo4:
# 其他操作:3个类似list的类型.
# dic.keys 类似list的类型
# dic.values 类似list的类型
# dic.items 可以生成元组.
# dic.keys() 这是类似list的容器类类型
# dic = {
# 'name': 'zhangwuji',
# 'age': 23,
# 'hobby': 'study kongfu'
# }
# ret = dic.keys()
# print(ret,type(ret))
# dic.values()
# print(dic.values())
# 转换成list
# print(list(dic.values()))
# for v in dic.values() :
# print(v)
# print(dic.items())
# print(type(dic.items()))
# for i in dic.items() :
# print(i)#输出的生成为元组.
# 分别赋值
# a, b = (1, 2)
# print(a, b)
# a, b, c = (1, 2, 3)
# print (a,b,c)
# a,b = 100 ,1000
# print(a,b)
# a,b=[100,1000]
# print(a,b)
# 相互赋值:(不用像c语言那样拿个中间值换碗)
# a,b = 1,2
# b,a = a,b
# print(a,b)
# a, b = {'name': 'zhangwuji', 'age': '23'}
# print(a, b) # 只能输出key值
# print(dic.items())
# for k,v in dic.items() :
# '''
# k,v = ('movie',''HarryPoter')
# k,v = ('money',666)
# k,v = ('sky','land')
# '''#诸如此类
# print('这是键',k)
# print('这是值:',v)
04 字典的嵌套:
demo5:(引用taibai上课举的例子)
# 字典嵌套:
# dic = {
# 'name_list': ['博哥', '菊哥', 'b哥', 'alex'],
# 'barry': {
# 'name': '太白金星',
# 'age': 18,
# 'hobby': 'wife',
# }
# }
# 1，给这个列表['博哥', '菊哥', 'b哥', 'alex'] 追加一个元素 '老男孩'。
# l1 = dic['name_list']
# l1.append('老男孩')
# print(dic)
# 简写:
# dic['name_list'].append('老男孩')
# print(dic)
# 2，将这个列表['博哥', '菊哥', 'b哥', 'alex']中的alex变成首字母大写。
# dic['name_list'][-1]= dic['name_list'][-1].capitalize()
# print(dic)
# 3，将这个键值对 'name': '太白金星' 的 '太白金星' 改成男神。
# dic['barry']['name'] = '男神'
# print(dic)
# 4，给barry对应的小字典增加一个键值对： weight: 160
# 法一:
# dic['barry'].setdefault('weigth',160)
# print(dic)
# 法二:
# dic['barry']['weight'] = 160
# print(dic)
05 set
set的话并没有讲. 简单了解一下即可.
set的输出:
注意,set中的元素不可重复.
demo6:
set1 = set({1, 2, 'zhangwuji'})
set2 = {1, 2, 'zhangwuji'}
print(set1, set2)
set的增加(2种方法):
demo7:
set1 = {'guojing','huangrong','yangguo','xiaolongnv','guoxiang'}
set1.add('zhangwuji')#随机添加进入
print(set1)
update：迭代着增加
set1.update('weiwuxian')
print(set1)
set1.update('lanwangji')
print(set1)
set1.update([1,2,3])
print(set1)#添加list会保持在一起
set1.update(['weiwuxian'])
set1.update(['lanwangji'])
print(set1)
set的删除(4种操作):
demo8:
set1 = {'guojing','huangrong','yangguo','xiaolongnv','guoxiang'}
set1.remove('guojing') # 删除一个元素
print(set1)
set1.pop() # 随机删除一个元素
print(set1)
set1.clear() # 清空集合
print(set1)
del set1 # 删除集合
print(set1)
set的其他操作:
demo*(直接复制老师的,理解即可)
4.1 交集。（& 或者 intersection）
set1 = {1,2,3,4,5}
set2 = {4,5,6,7,8}
print(set1 & set2) # {4, 5}
print(set1.intersection(set2)) # {4, 5}
4.2 并集。（| 或者 union）
set1 = {1,2,3,4,5}
set2 = {4,5,6,7,8}
print(set1 | set2) # {1, 2, 3, 4, 5, 6, 7,8}
print(set2.union(set1)) # {1, 2, 3, 4, 5, 6, 7,8}
4.3 差集。（- 或者 difference）
set1 = {1,2,3,4,5}
set2 = {4,5,6,7,8}
print(set1 - set2) # {1, 2, 3}
print(set1.difference(set2)) # {1, 2, 3}
4.4反交集。 （^ 或者 symmetric_difference）
set1 = {1,2,3,4,5}
set2 = {4,5,6,7,8}
print(set1 ^ set2) # {1, 2, 3, 6, 7, 8}
print(set1.symmetric_difference(set2)) # {1, 2, 3, 6, 7, 8}
4.5子集与超集
set1 = {1,2,3}
set2 = {1,2,3,4,5,6}
print(set1 < set2)
print(set1.issubset(set2)) # 这两个相同，都是说明set1是set2子集。
print(set2 > set1)
print(set2.issuperset(set1)) # 这两个相同，都是说明set2是set1超集。
5，frozenset不可变集合，让集合变成不可变类型。
s = frozenset('barry')
print(s,type(s)) # frozenset({'a', 'y', 'b', 'r'}) <class 'frozenset'>
PS:
1.养成习惯,input后面带个strip.(区分strip和split)
2.面试可能会问:
Python3.5(包括3.5之前):字典是无序的.
Python3.6之后:字典变成有序的.(按首次创建字典的顺序排列)
3.dict是选key输出value. key相当于索引.
4.分别赋值的概念很重要.
5.update后面的key不要加''. 值不能是数字.
![]()
![]()
![]()
6.keys, values, items. 类似list.
7.有返回值才能print.(注意观察)
8.others:(不想再分了)
有返回值才能print.(注意观察)
extend:把参数中的每个元素拆分添加到当前列表当中.
元组(上图)
[]:索引操作符
(list , tuple ,str 都可以用)
多层列表的话推荐如下写法.![]()
Python 文档解释：(了解item和iteritems) dict.items(): Return a copy of the dictionary’s list of (key, value) pairs. dict.iteritems(): Return an iterator over the dictionary’s (key, value) pairs. dict.items()返回的是一个完整的列表，而dict.iteritems()返回的是一个生成器(迭代器)。 dict.items()返回列表list的所有列表项，形如这样的二元组list：［(key,value),(key,value),...］,dict.iteritems()是generator, yield 2-tuple。相对来说，前者需要花费更多内存空间和时间，但访问某一项的时间较快(KEY)。后者花费很少的空间，通过next()不断取下一个值，但是将花费稍微多的时间来生成下一item。 --------------------- 转载自作者：iidol 来源：CSDN 原文：https://blog.csdn.net/u012542422/article/details/52052877
